inode.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * inode.c - NILFS inode operations.
  4. *
  5. * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
  6. *
  7. * Written by Ryusuke Konishi.
  8. *
  9. */
  10. #include <linux/buffer_head.h>
  11. #include <linux/gfp.h>
  12. #include <linux/mpage.h>
  13. #include <linux/pagemap.h>
  14. #include <linux/writeback.h>
  15. #include <linux/uio.h>
  16. #include <linux/fiemap.h>
  17. #include "nilfs.h"
  18. #include "btnode.h"
  19. #include "segment.h"
  20. #include "page.h"
  21. #include "mdt.h"
  22. #include "cpfile.h"
  23. #include "ifile.h"
  24. /**
  25. * struct nilfs_iget_args - arguments used during comparison between inodes
  26. * @ino: inode number
  27. * @cno: checkpoint number
  28. * @root: pointer on NILFS root object (mounted checkpoint)
  29. * @for_gc: inode for GC flag
  30. */
  31. struct nilfs_iget_args {
  32. u64 ino;
  33. __u64 cno;
  34. struct nilfs_root *root;
  35. int for_gc;
  36. };
  37. static int nilfs_iget_test(struct inode *inode, void *opaque);
  38. void nilfs_inode_add_blocks(struct inode *inode, int n)
  39. {
  40. struct nilfs_root *root = NILFS_I(inode)->i_root;
  41. inode_add_bytes(inode, i_blocksize(inode) * n);
  42. if (root)
  43. atomic64_add(n, &root->blocks_count);
  44. }
  45. void nilfs_inode_sub_blocks(struct inode *inode, int n)
  46. {
  47. struct nilfs_root *root = NILFS_I(inode)->i_root;
  48. inode_sub_bytes(inode, i_blocksize(inode) * n);
  49. if (root)
  50. atomic64_sub(n, &root->blocks_count);
  51. }
  52. /**
  53. * nilfs_get_block() - get a file block on the filesystem (callback function)
  54. * @inode - inode struct of the target file
  55. * @blkoff - file block number
  56. * @bh_result - buffer head to be mapped on
  57. * @create - indicate whether allocating the block or not when it has not
  58. * been allocated yet.
  59. *
  60. * This function does not issue actual read request of the specified data
  61. * block. It is done by VFS.
  62. */
  63. int nilfs_get_block(struct inode *inode, sector_t blkoff,
  64. struct buffer_head *bh_result, int create)
  65. {
  66. struct nilfs_inode_info *ii = NILFS_I(inode);
  67. struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
  68. __u64 blknum = 0;
  69. int err = 0, ret;
  70. unsigned int maxblocks = bh_result->b_size >> inode->i_blkbits;
  71. down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
  72. ret = nilfs_bmap_lookup_contig(ii->i_bmap, blkoff, &blknum, maxblocks);
  73. up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
  74. if (ret >= 0) { /* found */
  75. map_bh(bh_result, inode->i_sb, blknum);
  76. if (ret > 0)
  77. bh_result->b_size = (ret << inode->i_blkbits);
  78. goto out;
  79. }
  80. /* data block was not found */
  81. if (ret == -ENOENT && create) {
  82. struct nilfs_transaction_info ti;
  83. bh_result->b_blocknr = 0;
  84. err = nilfs_transaction_begin(inode->i_sb, &ti, 1);
  85. if (unlikely(err))
  86. goto out;
  87. err = nilfs_bmap_insert(ii->i_bmap, blkoff,
  88. (unsigned long)bh_result);
  89. if (unlikely(err != 0)) {
  90. if (err == -EEXIST) {
  91. /*
  92. * The get_block() function could be called
  93. * from multiple callers for an inode.
  94. * However, the page having this block must
  95. * be locked in this case.
  96. */
  97. nilfs_warn(inode->i_sb,
  98. "%s (ino=%lu): a race condition while inserting a data block at offset=%llu",
  99. __func__, inode->i_ino,
  100. (unsigned long long)blkoff);
  101. err = 0;
  102. }
  103. nilfs_transaction_abort(inode->i_sb);
  104. goto out;
  105. }
  106. nilfs_mark_inode_dirty_sync(inode);
  107. nilfs_transaction_commit(inode->i_sb); /* never fails */
  108. /* Error handling should be detailed */
  109. set_buffer_new(bh_result);
  110. set_buffer_delay(bh_result);
  111. map_bh(bh_result, inode->i_sb, 0);
  112. /* Disk block number must be changed to proper value */
  113. } else if (ret == -ENOENT) {
  114. /*
  115. * not found is not error (e.g. hole); must return without
  116. * the mapped state flag.
  117. */
  118. ;
  119. } else {
  120. err = ret;
  121. }
  122. out:
  123. return err;
  124. }
  125. /**
  126. * nilfs_readpage() - implement readpage() method of nilfs_aops {}
  127. * address_space_operations.
  128. * @file - file struct of the file to be read
  129. * @page - the page to be read
  130. */
  131. static int nilfs_readpage(struct file *file, struct page *page)
  132. {
  133. return mpage_readpage(page, nilfs_get_block);
  134. }
  135. static void nilfs_readahead(struct readahead_control *rac)
  136. {
  137. mpage_readahead(rac, nilfs_get_block);
  138. }
  139. static int nilfs_writepages(struct address_space *mapping,
  140. struct writeback_control *wbc)
  141. {
  142. struct inode *inode = mapping->host;
  143. int err = 0;
  144. if (sb_rdonly(inode->i_sb)) {
  145. nilfs_clear_dirty_pages(mapping, false);
  146. return -EROFS;
  147. }
  148. if (wbc->sync_mode == WB_SYNC_ALL)
  149. err = nilfs_construct_dsync_segment(inode->i_sb, inode,
  150. wbc->range_start,
  151. wbc->range_end);
  152. return err;
  153. }
  154. static int nilfs_writepage(struct page *page, struct writeback_control *wbc)
  155. {
  156. struct inode *inode = page->mapping->host;
  157. int err;
  158. if (sb_rdonly(inode->i_sb)) {
  159. /*
  160. * It means that filesystem was remounted in read-only
  161. * mode because of error or metadata corruption. But we
  162. * have dirty pages that try to be flushed in background.
  163. * So, here we simply discard this dirty page.
  164. */
  165. nilfs_clear_dirty_page(page, false);
  166. unlock_page(page);
  167. return -EROFS;
  168. }
  169. redirty_page_for_writepage(wbc, page);
  170. unlock_page(page);
  171. if (wbc->sync_mode == WB_SYNC_ALL) {
  172. err = nilfs_construct_segment(inode->i_sb);
  173. if (unlikely(err))
  174. return err;
  175. } else if (wbc->for_reclaim)
  176. nilfs_flush_segment(inode->i_sb, inode->i_ino);
  177. return 0;
  178. }
  179. static int nilfs_set_page_dirty(struct page *page)
  180. {
  181. struct inode *inode = page->mapping->host;
  182. int ret = __set_page_dirty_nobuffers(page);
  183. if (page_has_buffers(page)) {
  184. unsigned int nr_dirty = 0;
  185. struct buffer_head *bh, *head;
  186. /*
  187. * This page is locked by callers, and no other thread
  188. * concurrently marks its buffers dirty since they are
  189. * only dirtied through routines in fs/buffer.c in
  190. * which call sites of mark_buffer_dirty are protected
  191. * by page lock.
  192. */
  193. bh = head = page_buffers(page);
  194. do {
  195. /* Do not mark hole blocks dirty */
  196. if (buffer_dirty(bh) || !buffer_mapped(bh))
  197. continue;
  198. set_buffer_dirty(bh);
  199. nr_dirty++;
  200. } while (bh = bh->b_this_page, bh != head);
  201. if (nr_dirty)
  202. nilfs_set_file_dirty(inode, nr_dirty);
  203. } else if (ret) {
  204. unsigned int nr_dirty = 1 << (PAGE_SHIFT - inode->i_blkbits);
  205. nilfs_set_file_dirty(inode, nr_dirty);
  206. }
  207. return ret;
  208. }
  209. void nilfs_write_failed(struct address_space *mapping, loff_t to)
  210. {
  211. struct inode *inode = mapping->host;
  212. if (to > inode->i_size) {
  213. truncate_pagecache(inode, inode->i_size);
  214. nilfs_truncate(inode);
  215. }
  216. }
  217. static int nilfs_write_begin(struct file *file, struct address_space *mapping,
  218. loff_t pos, unsigned len, unsigned flags,
  219. struct page **pagep, void **fsdata)
  220. {
  221. struct inode *inode = mapping->host;
  222. int err = nilfs_transaction_begin(inode->i_sb, NULL, 1);
  223. if (unlikely(err))
  224. return err;
  225. err = block_write_begin(mapping, pos, len, flags, pagep,
  226. nilfs_get_block);
  227. if (unlikely(err)) {
  228. nilfs_write_failed(mapping, pos + len);
  229. nilfs_transaction_abort(inode->i_sb);
  230. }
  231. return err;
  232. }
  233. static int nilfs_write_end(struct file *file, struct address_space *mapping,
  234. loff_t pos, unsigned len, unsigned copied,
  235. struct page *page, void *fsdata)
  236. {
  237. struct inode *inode = mapping->host;
  238. unsigned int start = pos & (PAGE_SIZE - 1);
  239. unsigned int nr_dirty;
  240. int err;
  241. nr_dirty = nilfs_page_count_clean_buffers(page, start,
  242. start + copied);
  243. copied = generic_write_end(file, mapping, pos, len, copied, page,
  244. fsdata);
  245. nilfs_set_file_dirty(inode, nr_dirty);
  246. err = nilfs_transaction_commit(inode->i_sb);
  247. return err ? : copied;
  248. }
  249. static ssize_t
  250. nilfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
  251. {
  252. struct inode *inode = file_inode(iocb->ki_filp);
  253. if (iov_iter_rw(iter) == WRITE)
  254. return 0;
  255. /* Needs synchronization with the cleaner */
  256. return blockdev_direct_IO(iocb, inode, iter, nilfs_get_block);
  257. }
  258. const struct address_space_operations nilfs_aops = {
  259. .writepage = nilfs_writepage,
  260. .readpage = nilfs_readpage,
  261. .writepages = nilfs_writepages,
  262. .set_page_dirty = nilfs_set_page_dirty,
  263. .readahead = nilfs_readahead,
  264. .write_begin = nilfs_write_begin,
  265. .write_end = nilfs_write_end,
  266. /* .releasepage = nilfs_releasepage, */
  267. .invalidatepage = block_invalidatepage,
  268. .direct_IO = nilfs_direct_IO,
  269. .is_partially_uptodate = block_is_partially_uptodate,
  270. };
  271. static int nilfs_insert_inode_locked(struct inode *inode,
  272. struct nilfs_root *root,
  273. unsigned long ino)
  274. {
  275. struct nilfs_iget_args args = {
  276. .ino = ino, .root = root, .cno = 0, .for_gc = 0
  277. };
  278. return insert_inode_locked4(inode, ino, nilfs_iget_test, &args);
  279. }
  280. struct inode *nilfs_new_inode(struct inode *dir, umode_t mode)
  281. {
  282. struct super_block *sb = dir->i_sb;
  283. struct the_nilfs *nilfs = sb->s_fs_info;
  284. struct inode *inode;
  285. struct nilfs_inode_info *ii;
  286. struct nilfs_root *root;
  287. int err = -ENOMEM;
  288. ino_t ino;
  289. inode = new_inode(sb);
  290. if (unlikely(!inode))
  291. goto failed;
  292. mapping_set_gfp_mask(inode->i_mapping,
  293. mapping_gfp_constraint(inode->i_mapping, ~__GFP_FS));
  294. root = NILFS_I(dir)->i_root;
  295. ii = NILFS_I(inode);
  296. ii->i_state = BIT(NILFS_I_NEW);
  297. ii->i_root = root;
  298. err = nilfs_ifile_create_inode(root->ifile, &ino, &ii->i_bh);
  299. if (unlikely(err))
  300. goto failed_ifile_create_inode;
  301. /* reference count of i_bh inherits from nilfs_mdt_read_block() */
  302. atomic64_inc(&root->inodes_count);
  303. inode_init_owner(inode, dir, mode);
  304. inode->i_ino = ino;
  305. inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
  306. if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
  307. err = nilfs_bmap_read(ii->i_bmap, NULL);
  308. if (err < 0)
  309. goto failed_after_creation;
  310. set_bit(NILFS_I_BMAP, &ii->i_state);
  311. /* No lock is needed; iget() ensures it. */
  312. }
  313. ii->i_flags = nilfs_mask_flags(
  314. mode, NILFS_I(dir)->i_flags & NILFS_FL_INHERITED);
  315. /* ii->i_file_acl = 0; */
  316. /* ii->i_dir_acl = 0; */
  317. ii->i_dir_start_lookup = 0;
  318. nilfs_set_inode_flags(inode);
  319. spin_lock(&nilfs->ns_next_gen_lock);
  320. inode->i_generation = nilfs->ns_next_generation++;
  321. spin_unlock(&nilfs->ns_next_gen_lock);
  322. if (nilfs_insert_inode_locked(inode, root, ino) < 0) {
  323. err = -EIO;
  324. goto failed_after_creation;
  325. }
  326. err = nilfs_init_acl(inode, dir);
  327. if (unlikely(err))
  328. /*
  329. * Never occur. When supporting nilfs_init_acl(),
  330. * proper cancellation of above jobs should be considered.
  331. */
  332. goto failed_after_creation;
  333. return inode;
  334. failed_after_creation:
  335. clear_nlink(inode);
  336. if (inode->i_state & I_NEW)
  337. unlock_new_inode(inode);
  338. iput(inode); /*
  339. * raw_inode will be deleted through
  340. * nilfs_evict_inode().
  341. */
  342. goto failed;
  343. failed_ifile_create_inode:
  344. make_bad_inode(inode);
  345. iput(inode);
  346. failed:
  347. return ERR_PTR(err);
  348. }
  349. void nilfs_set_inode_flags(struct inode *inode)
  350. {
  351. unsigned int flags = NILFS_I(inode)->i_flags;
  352. unsigned int new_fl = 0;
  353. if (flags & FS_SYNC_FL)
  354. new_fl |= S_SYNC;
  355. if (flags & FS_APPEND_FL)
  356. new_fl |= S_APPEND;
  357. if (flags & FS_IMMUTABLE_FL)
  358. new_fl |= S_IMMUTABLE;
  359. if (flags & FS_NOATIME_FL)
  360. new_fl |= S_NOATIME;
  361. if (flags & FS_DIRSYNC_FL)
  362. new_fl |= S_DIRSYNC;
  363. inode_set_flags(inode, new_fl, S_SYNC | S_APPEND | S_IMMUTABLE |
  364. S_NOATIME | S_DIRSYNC);
  365. }
  366. int nilfs_read_inode_common(struct inode *inode,
  367. struct nilfs_inode *raw_inode)
  368. {
  369. struct nilfs_inode_info *ii = NILFS_I(inode);
  370. int err;
  371. inode->i_mode = le16_to_cpu(raw_inode->i_mode);
  372. i_uid_write(inode, le32_to_cpu(raw_inode->i_uid));
  373. i_gid_write(inode, le32_to_cpu(raw_inode->i_gid));
  374. set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
  375. inode->i_size = le64_to_cpu(raw_inode->i_size);
  376. inode->i_atime.tv_sec = le64_to_cpu(raw_inode->i_mtime);
  377. inode->i_ctime.tv_sec = le64_to_cpu(raw_inode->i_ctime);
  378. inode->i_mtime.tv_sec = le64_to_cpu(raw_inode->i_mtime);
  379. inode->i_atime.tv_nsec = le32_to_cpu(raw_inode->i_mtime_nsec);
  380. inode->i_ctime.tv_nsec = le32_to_cpu(raw_inode->i_ctime_nsec);
  381. inode->i_mtime.tv_nsec = le32_to_cpu(raw_inode->i_mtime_nsec);
  382. if (inode->i_nlink == 0)
  383. return -ESTALE; /* this inode is deleted */
  384. inode->i_blocks = le64_to_cpu(raw_inode->i_blocks);
  385. ii->i_flags = le32_to_cpu(raw_inode->i_flags);
  386. #if 0
  387. ii->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
  388. ii->i_dir_acl = S_ISREG(inode->i_mode) ?
  389. 0 : le32_to_cpu(raw_inode->i_dir_acl);
  390. #endif
  391. ii->i_dir_start_lookup = 0;
  392. inode->i_generation = le32_to_cpu(raw_inode->i_generation);
  393. if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
  394. S_ISLNK(inode->i_mode)) {
  395. err = nilfs_bmap_read(ii->i_bmap, raw_inode);
  396. if (err < 0)
  397. return err;
  398. set_bit(NILFS_I_BMAP, &ii->i_state);
  399. /* No lock is needed; iget() ensures it. */
  400. }
  401. return 0;
  402. }
  403. static int __nilfs_read_inode(struct super_block *sb,
  404. struct nilfs_root *root, unsigned long ino,
  405. struct inode *inode)
  406. {
  407. struct the_nilfs *nilfs = sb->s_fs_info;
  408. struct buffer_head *bh;
  409. struct nilfs_inode *raw_inode;
  410. int err;
  411. down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
  412. err = nilfs_ifile_get_inode_block(root->ifile, ino, &bh);
  413. if (unlikely(err))
  414. goto bad_inode;
  415. raw_inode = nilfs_ifile_map_inode(root->ifile, ino, bh);
  416. err = nilfs_read_inode_common(inode, raw_inode);
  417. if (err)
  418. goto failed_unmap;
  419. if (S_ISREG(inode->i_mode)) {
  420. inode->i_op = &nilfs_file_inode_operations;
  421. inode->i_fop = &nilfs_file_operations;
  422. inode->i_mapping->a_ops = &nilfs_aops;
  423. } else if (S_ISDIR(inode->i_mode)) {
  424. inode->i_op = &nilfs_dir_inode_operations;
  425. inode->i_fop = &nilfs_dir_operations;
  426. inode->i_mapping->a_ops = &nilfs_aops;
  427. } else if (S_ISLNK(inode->i_mode)) {
  428. inode->i_op = &nilfs_symlink_inode_operations;
  429. inode_nohighmem(inode);
  430. inode->i_mapping->a_ops = &nilfs_aops;
  431. } else {
  432. inode->i_op = &nilfs_special_inode_operations;
  433. init_special_inode(
  434. inode, inode->i_mode,
  435. huge_decode_dev(le64_to_cpu(raw_inode->i_device_code)));
  436. }
  437. nilfs_ifile_unmap_inode(root->ifile, ino, bh);
  438. brelse(bh);
  439. up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
  440. nilfs_set_inode_flags(inode);
  441. mapping_set_gfp_mask(inode->i_mapping,
  442. mapping_gfp_constraint(inode->i_mapping, ~__GFP_FS));
  443. return 0;
  444. failed_unmap:
  445. nilfs_ifile_unmap_inode(root->ifile, ino, bh);
  446. brelse(bh);
  447. bad_inode:
  448. up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
  449. return err;
  450. }
  451. static int nilfs_iget_test(struct inode *inode, void *opaque)
  452. {
  453. struct nilfs_iget_args *args = opaque;
  454. struct nilfs_inode_info *ii;
  455. if (args->ino != inode->i_ino || args->root != NILFS_I(inode)->i_root)
  456. return 0;
  457. ii = NILFS_I(inode);
  458. if (!test_bit(NILFS_I_GCINODE, &ii->i_state))
  459. return !args->for_gc;
  460. return args->for_gc && args->cno == ii->i_cno;
  461. }
  462. static int nilfs_iget_set(struct inode *inode, void *opaque)
  463. {
  464. struct nilfs_iget_args *args = opaque;
  465. inode->i_ino = args->ino;
  466. if (args->for_gc) {
  467. NILFS_I(inode)->i_state = BIT(NILFS_I_GCINODE);
  468. NILFS_I(inode)->i_cno = args->cno;
  469. NILFS_I(inode)->i_root = NULL;
  470. } else {
  471. if (args->root && args->ino == NILFS_ROOT_INO)
  472. nilfs_get_root(args->root);
  473. NILFS_I(inode)->i_root = args->root;
  474. }
  475. return 0;
  476. }
  477. struct inode *nilfs_ilookup(struct super_block *sb, struct nilfs_root *root,
  478. unsigned long ino)
  479. {
  480. struct nilfs_iget_args args = {
  481. .ino = ino, .root = root, .cno = 0, .for_gc = 0
  482. };
  483. return ilookup5(sb, ino, nilfs_iget_test, &args);
  484. }
  485. struct inode *nilfs_iget_locked(struct super_block *sb, struct nilfs_root *root,
  486. unsigned long ino)
  487. {
  488. struct nilfs_iget_args args = {
  489. .ino = ino, .root = root, .cno = 0, .for_gc = 0
  490. };
  491. return iget5_locked(sb, ino, nilfs_iget_test, nilfs_iget_set, &args);
  492. }
  493. struct inode *nilfs_iget(struct super_block *sb, struct nilfs_root *root,
  494. unsigned long ino)
  495. {
  496. struct inode *inode;
  497. int err;
  498. inode = nilfs_iget_locked(sb, root, ino);
  499. if (unlikely(!inode))
  500. return ERR_PTR(-ENOMEM);
  501. if (!(inode->i_state & I_NEW))
  502. return inode;
  503. err = __nilfs_read_inode(sb, root, ino, inode);
  504. if (unlikely(err)) {
  505. iget_failed(inode);
  506. return ERR_PTR(err);
  507. }
  508. unlock_new_inode(inode);
  509. return inode;
  510. }
  511. struct inode *nilfs_iget_for_gc(struct super_block *sb, unsigned long ino,
  512. __u64 cno)
  513. {
  514. struct nilfs_iget_args args = {
  515. .ino = ino, .root = NULL, .cno = cno, .for_gc = 1
  516. };
  517. struct inode *inode;
  518. int err;
  519. inode = iget5_locked(sb, ino, nilfs_iget_test, nilfs_iget_set, &args);
  520. if (unlikely(!inode))
  521. return ERR_PTR(-ENOMEM);
  522. if (!(inode->i_state & I_NEW))
  523. return inode;
  524. err = nilfs_init_gcinode(inode);
  525. if (unlikely(err)) {
  526. iget_failed(inode);
  527. return ERR_PTR(err);
  528. }
  529. unlock_new_inode(inode);
  530. return inode;
  531. }
  532. void nilfs_write_inode_common(struct inode *inode,
  533. struct nilfs_inode *raw_inode, int has_bmap)
  534. {
  535. struct nilfs_inode_info *ii = NILFS_I(inode);
  536. raw_inode->i_mode = cpu_to_le16(inode->i_mode);
  537. raw_inode->i_uid = cpu_to_le32(i_uid_read(inode));
  538. raw_inode->i_gid = cpu_to_le32(i_gid_read(inode));
  539. raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
  540. raw_inode->i_size = cpu_to_le64(inode->i_size);
  541. raw_inode->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
  542. raw_inode->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
  543. raw_inode->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
  544. raw_inode->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
  545. raw_inode->i_blocks = cpu_to_le64(inode->i_blocks);
  546. raw_inode->i_flags = cpu_to_le32(ii->i_flags);
  547. raw_inode->i_generation = cpu_to_le32(inode->i_generation);
  548. if (NILFS_ROOT_METADATA_FILE(inode->i_ino)) {
  549. struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
  550. /* zero-fill unused portion in the case of super root block */
  551. raw_inode->i_xattr = 0;
  552. raw_inode->i_pad = 0;
  553. memset((void *)raw_inode + sizeof(*raw_inode), 0,
  554. nilfs->ns_inode_size - sizeof(*raw_inode));
  555. }
  556. if (has_bmap)
  557. nilfs_bmap_write(ii->i_bmap, raw_inode);
  558. else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  559. raw_inode->i_device_code =
  560. cpu_to_le64(huge_encode_dev(inode->i_rdev));
  561. /*
  562. * When extending inode, nilfs->ns_inode_size should be checked
  563. * for substitutions of appended fields.
  564. */
  565. }
  566. void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh, int flags)
  567. {
  568. ino_t ino = inode->i_ino;
  569. struct nilfs_inode_info *ii = NILFS_I(inode);
  570. struct inode *ifile = ii->i_root->ifile;
  571. struct nilfs_inode *raw_inode;
  572. raw_inode = nilfs_ifile_map_inode(ifile, ino, ibh);
  573. if (test_and_clear_bit(NILFS_I_NEW, &ii->i_state))
  574. memset(raw_inode, 0, NILFS_MDT(ifile)->mi_entry_size);
  575. if (flags & I_DIRTY_DATASYNC)
  576. set_bit(NILFS_I_INODE_SYNC, &ii->i_state);
  577. nilfs_write_inode_common(inode, raw_inode, 0);
  578. /*
  579. * XXX: call with has_bmap = 0 is a workaround to avoid
  580. * deadlock of bmap. This delays update of i_bmap to just
  581. * before writing.
  582. */
  583. nilfs_ifile_unmap_inode(ifile, ino, ibh);
  584. }
  585. #define NILFS_MAX_TRUNCATE_BLOCKS 16384 /* 64MB for 4KB block */
  586. static void nilfs_truncate_bmap(struct nilfs_inode_info *ii,
  587. unsigned long from)
  588. {
  589. __u64 b;
  590. int ret;
  591. if (!test_bit(NILFS_I_BMAP, &ii->i_state))
  592. return;
  593. repeat:
  594. ret = nilfs_bmap_last_key(ii->i_bmap, &b);
  595. if (ret == -ENOENT)
  596. return;
  597. else if (ret < 0)
  598. goto failed;
  599. if (b < from)
  600. return;
  601. b -= min_t(__u64, NILFS_MAX_TRUNCATE_BLOCKS, b - from);
  602. ret = nilfs_bmap_truncate(ii->i_bmap, b);
  603. nilfs_relax_pressure_in_lock(ii->vfs_inode.i_sb);
  604. if (!ret || (ret == -ENOMEM &&
  605. nilfs_bmap_truncate(ii->i_bmap, b) == 0))
  606. goto repeat;
  607. failed:
  608. nilfs_warn(ii->vfs_inode.i_sb, "error %d truncating bmap (ino=%lu)",
  609. ret, ii->vfs_inode.i_ino);
  610. }
  611. void nilfs_truncate(struct inode *inode)
  612. {
  613. unsigned long blkoff;
  614. unsigned int blocksize;
  615. struct nilfs_transaction_info ti;
  616. struct super_block *sb = inode->i_sb;
  617. struct nilfs_inode_info *ii = NILFS_I(inode);
  618. if (!test_bit(NILFS_I_BMAP, &ii->i_state))
  619. return;
  620. if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
  621. return;
  622. blocksize = sb->s_blocksize;
  623. blkoff = (inode->i_size + blocksize - 1) >> sb->s_blocksize_bits;
  624. nilfs_transaction_begin(sb, &ti, 0); /* never fails */
  625. block_truncate_page(inode->i_mapping, inode->i_size, nilfs_get_block);
  626. nilfs_truncate_bmap(ii, blkoff);
  627. inode->i_mtime = inode->i_ctime = current_time(inode);
  628. if (IS_SYNC(inode))
  629. nilfs_set_transaction_flag(NILFS_TI_SYNC);
  630. nilfs_mark_inode_dirty(inode);
  631. nilfs_set_file_dirty(inode, 0);
  632. nilfs_transaction_commit(sb);
  633. /*
  634. * May construct a logical segment and may fail in sync mode.
  635. * But truncate has no return value.
  636. */
  637. }
  638. static void nilfs_clear_inode(struct inode *inode)
  639. {
  640. struct nilfs_inode_info *ii = NILFS_I(inode);
  641. /*
  642. * Free resources allocated in nilfs_read_inode(), here.
  643. */
  644. BUG_ON(!list_empty(&ii->i_dirty));
  645. brelse(ii->i_bh);
  646. ii->i_bh = NULL;
  647. if (nilfs_is_metadata_file_inode(inode))
  648. nilfs_mdt_clear(inode);
  649. if (test_bit(NILFS_I_BMAP, &ii->i_state))
  650. nilfs_bmap_clear(ii->i_bmap);
  651. nilfs_btnode_cache_clear(&ii->i_btnode_cache);
  652. if (ii->i_root && inode->i_ino == NILFS_ROOT_INO)
  653. nilfs_put_root(ii->i_root);
  654. }
  655. void nilfs_evict_inode(struct inode *inode)
  656. {
  657. struct nilfs_transaction_info ti;
  658. struct super_block *sb = inode->i_sb;
  659. struct nilfs_inode_info *ii = NILFS_I(inode);
  660. int ret;
  661. if (inode->i_nlink || !ii->i_root || unlikely(is_bad_inode(inode))) {
  662. truncate_inode_pages_final(&inode->i_data);
  663. clear_inode(inode);
  664. nilfs_clear_inode(inode);
  665. return;
  666. }
  667. nilfs_transaction_begin(sb, &ti, 0); /* never fails */
  668. truncate_inode_pages_final(&inode->i_data);
  669. /* TODO: some of the following operations may fail. */
  670. nilfs_truncate_bmap(ii, 0);
  671. nilfs_mark_inode_dirty(inode);
  672. clear_inode(inode);
  673. ret = nilfs_ifile_delete_inode(ii->i_root->ifile, inode->i_ino);
  674. if (!ret)
  675. atomic64_dec(&ii->i_root->inodes_count);
  676. nilfs_clear_inode(inode);
  677. if (IS_SYNC(inode))
  678. nilfs_set_transaction_flag(NILFS_TI_SYNC);
  679. nilfs_transaction_commit(sb);
  680. /*
  681. * May construct a logical segment and may fail in sync mode.
  682. * But delete_inode has no return value.
  683. */
  684. }
  685. int nilfs_setattr(struct dentry *dentry, struct iattr *iattr)
  686. {
  687. struct nilfs_transaction_info ti;
  688. struct inode *inode = d_inode(dentry);
  689. struct super_block *sb = inode->i_sb;
  690. int err;
  691. err = setattr_prepare(dentry, iattr);
  692. if (err)
  693. return err;
  694. err = nilfs_transaction_begin(sb, &ti, 0);
  695. if (unlikely(err))
  696. return err;
  697. if ((iattr->ia_valid & ATTR_SIZE) &&
  698. iattr->ia_size != i_size_read(inode)) {
  699. inode_dio_wait(inode);
  700. truncate_setsize(inode, iattr->ia_size);
  701. nilfs_truncate(inode);
  702. }
  703. setattr_copy(inode, iattr);
  704. mark_inode_dirty(inode);
  705. if (iattr->ia_valid & ATTR_MODE) {
  706. err = nilfs_acl_chmod(inode);
  707. if (unlikely(err))
  708. goto out_err;
  709. }
  710. return nilfs_transaction_commit(sb);
  711. out_err:
  712. nilfs_transaction_abort(sb);
  713. return err;
  714. }
  715. int nilfs_permission(struct inode *inode, int mask)
  716. {
  717. struct nilfs_root *root = NILFS_I(inode)->i_root;
  718. if ((mask & MAY_WRITE) && root &&
  719. root->cno != NILFS_CPTREE_CURRENT_CNO)
  720. return -EROFS; /* snapshot is not writable */
  721. return generic_permission(inode, mask);
  722. }
  723. int nilfs_load_inode_block(struct inode *inode, struct buffer_head **pbh)
  724. {
  725. struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
  726. struct nilfs_inode_info *ii = NILFS_I(inode);
  727. int err;
  728. spin_lock(&nilfs->ns_inode_lock);
  729. if (ii->i_bh == NULL) {
  730. spin_unlock(&nilfs->ns_inode_lock);
  731. err = nilfs_ifile_get_inode_block(ii->i_root->ifile,
  732. inode->i_ino, pbh);
  733. if (unlikely(err))
  734. return err;
  735. spin_lock(&nilfs->ns_inode_lock);
  736. if (ii->i_bh == NULL)
  737. ii->i_bh = *pbh;
  738. else {
  739. brelse(*pbh);
  740. *pbh = ii->i_bh;
  741. }
  742. } else
  743. *pbh = ii->i_bh;
  744. get_bh(*pbh);
  745. spin_unlock(&nilfs->ns_inode_lock);
  746. return 0;
  747. }
  748. int nilfs_inode_dirty(struct inode *inode)
  749. {
  750. struct nilfs_inode_info *ii = NILFS_I(inode);
  751. struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
  752. int ret = 0;
  753. if (!list_empty(&ii->i_dirty)) {
  754. spin_lock(&nilfs->ns_inode_lock);
  755. ret = test_bit(NILFS_I_DIRTY, &ii->i_state) ||
  756. test_bit(NILFS_I_BUSY, &ii->i_state);
  757. spin_unlock(&nilfs->ns_inode_lock);
  758. }
  759. return ret;
  760. }
  761. int nilfs_set_file_dirty(struct inode *inode, unsigned int nr_dirty)
  762. {
  763. struct nilfs_inode_info *ii = NILFS_I(inode);
  764. struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
  765. atomic_add(nr_dirty, &nilfs->ns_ndirtyblks);
  766. if (test_and_set_bit(NILFS_I_DIRTY, &ii->i_state))
  767. return 0;
  768. spin_lock(&nilfs->ns_inode_lock);
  769. if (!test_bit(NILFS_I_QUEUED, &ii->i_state) &&
  770. !test_bit(NILFS_I_BUSY, &ii->i_state)) {
  771. /*
  772. * Because this routine may race with nilfs_dispose_list(),
  773. * we have to check NILFS_I_QUEUED here, too.
  774. */
  775. if (list_empty(&ii->i_dirty) && igrab(inode) == NULL) {
  776. /*
  777. * This will happen when somebody is freeing
  778. * this inode.
  779. */
  780. nilfs_warn(inode->i_sb,
  781. "cannot set file dirty (ino=%lu): the file is being freed",
  782. inode->i_ino);
  783. spin_unlock(&nilfs->ns_inode_lock);
  784. return -EINVAL; /*
  785. * NILFS_I_DIRTY may remain for
  786. * freeing inode.
  787. */
  788. }
  789. list_move_tail(&ii->i_dirty, &nilfs->ns_dirty_files);
  790. set_bit(NILFS_I_QUEUED, &ii->i_state);
  791. }
  792. spin_unlock(&nilfs->ns_inode_lock);
  793. return 0;
  794. }
  795. int __nilfs_mark_inode_dirty(struct inode *inode, int flags)
  796. {
  797. struct buffer_head *ibh;
  798. int err;
  799. err = nilfs_load_inode_block(inode, &ibh);
  800. if (unlikely(err)) {
  801. nilfs_warn(inode->i_sb,
  802. "cannot mark inode dirty (ino=%lu): error %d loading inode block",
  803. inode->i_ino, err);
  804. return err;
  805. }
  806. nilfs_update_inode(inode, ibh, flags);
  807. mark_buffer_dirty(ibh);
  808. nilfs_mdt_mark_dirty(NILFS_I(inode)->i_root->ifile);
  809. brelse(ibh);
  810. return 0;
  811. }
  812. /**
  813. * nilfs_dirty_inode - reflect changes on given inode to an inode block.
  814. * @inode: inode of the file to be registered.
  815. *
  816. * nilfs_dirty_inode() loads a inode block containing the specified
  817. * @inode and copies data from a nilfs_inode to a corresponding inode
  818. * entry in the inode block. This operation is excluded from the segment
  819. * construction. This function can be called both as a single operation
  820. * and as a part of indivisible file operations.
  821. */
  822. void nilfs_dirty_inode(struct inode *inode, int flags)
  823. {
  824. struct nilfs_transaction_info ti;
  825. struct nilfs_mdt_info *mdi = NILFS_MDT(inode);
  826. if (is_bad_inode(inode)) {
  827. nilfs_warn(inode->i_sb,
  828. "tried to mark bad_inode dirty. ignored.");
  829. dump_stack();
  830. return;
  831. }
  832. if (mdi) {
  833. nilfs_mdt_mark_dirty(inode);
  834. return;
  835. }
  836. nilfs_transaction_begin(inode->i_sb, &ti, 0);
  837. __nilfs_mark_inode_dirty(inode, flags);
  838. nilfs_transaction_commit(inode->i_sb); /* never fails */
  839. }
  840. int nilfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
  841. __u64 start, __u64 len)
  842. {
  843. struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
  844. __u64 logical = 0, phys = 0, size = 0;
  845. __u32 flags = 0;
  846. loff_t isize;
  847. sector_t blkoff, end_blkoff;
  848. sector_t delalloc_blkoff;
  849. unsigned long delalloc_blklen;
  850. unsigned int blkbits = inode->i_blkbits;
  851. int ret, n;
  852. ret = fiemap_prep(inode, fieinfo, start, &len, 0);
  853. if (ret)
  854. return ret;
  855. inode_lock(inode);
  856. isize = i_size_read(inode);
  857. blkoff = start >> blkbits;
  858. end_blkoff = (start + len - 1) >> blkbits;
  859. delalloc_blklen = nilfs_find_uncommitted_extent(inode, blkoff,
  860. &delalloc_blkoff);
  861. do {
  862. __u64 blkphy;
  863. unsigned int maxblocks;
  864. if (delalloc_blklen && blkoff == delalloc_blkoff) {
  865. if (size) {
  866. /* End of the current extent */
  867. ret = fiemap_fill_next_extent(
  868. fieinfo, logical, phys, size, flags);
  869. if (ret)
  870. break;
  871. }
  872. if (blkoff > end_blkoff)
  873. break;
  874. flags = FIEMAP_EXTENT_MERGED | FIEMAP_EXTENT_DELALLOC;
  875. logical = blkoff << blkbits;
  876. phys = 0;
  877. size = delalloc_blklen << blkbits;
  878. blkoff = delalloc_blkoff + delalloc_blklen;
  879. delalloc_blklen = nilfs_find_uncommitted_extent(
  880. inode, blkoff, &delalloc_blkoff);
  881. continue;
  882. }
  883. /*
  884. * Limit the number of blocks that we look up so as
  885. * not to get into the next delayed allocation extent.
  886. */
  887. maxblocks = INT_MAX;
  888. if (delalloc_blklen)
  889. maxblocks = min_t(sector_t, delalloc_blkoff - blkoff,
  890. maxblocks);
  891. blkphy = 0;
  892. down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
  893. n = nilfs_bmap_lookup_contig(
  894. NILFS_I(inode)->i_bmap, blkoff, &blkphy, maxblocks);
  895. up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem);
  896. if (n < 0) {
  897. int past_eof;
  898. if (unlikely(n != -ENOENT))
  899. break; /* error */
  900. /* HOLE */
  901. blkoff++;
  902. past_eof = ((blkoff << blkbits) >= isize);
  903. if (size) {
  904. /* End of the current extent */
  905. if (past_eof)
  906. flags |= FIEMAP_EXTENT_LAST;
  907. ret = fiemap_fill_next_extent(
  908. fieinfo, logical, phys, size, flags);
  909. if (ret)
  910. break;
  911. size = 0;
  912. }
  913. if (blkoff > end_blkoff || past_eof)
  914. break;
  915. } else {
  916. if (size) {
  917. if (phys && blkphy << blkbits == phys + size) {
  918. /* The current extent goes on */
  919. size += n << blkbits;
  920. } else {
  921. /* Terminate the current extent */
  922. ret = fiemap_fill_next_extent(
  923. fieinfo, logical, phys, size,
  924. flags);
  925. if (ret || blkoff > end_blkoff)
  926. break;
  927. /* Start another extent */
  928. flags = FIEMAP_EXTENT_MERGED;
  929. logical = blkoff << blkbits;
  930. phys = blkphy << blkbits;
  931. size = n << blkbits;
  932. }
  933. } else {
  934. /* Start a new extent */
  935. flags = FIEMAP_EXTENT_MERGED;
  936. logical = blkoff << blkbits;
  937. phys = blkphy << blkbits;
  938. size = n << blkbits;
  939. }
  940. blkoff += n;
  941. }
  942. cond_resched();
  943. } while (true);
  944. /* If ret is 1 then we just hit the end of the extent array */
  945. if (ret == 1)
  946. ret = 0;
  947. inode_unlock(inode);
  948. return ret;
  949. }