inode.c 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) International Business Machines Corp., 2000-2004
  4. * Portions Copyright (C) Christoph Hellwig, 2001-2002
  5. */
  6. #include <linux/fs.h>
  7. #include <linux/mpage.h>
  8. #include <linux/buffer_head.h>
  9. #include <linux/pagemap.h>
  10. #include <linux/quotaops.h>
  11. #include <linux/uio.h>
  12. #include <linux/writeback.h>
  13. #include "jfs_incore.h"
  14. #include "jfs_inode.h"
  15. #include "jfs_filsys.h"
  16. #include "jfs_imap.h"
  17. #include "jfs_extent.h"
  18. #include "jfs_unicode.h"
  19. #include "jfs_debug.h"
  20. #include "jfs_dmap.h"
  21. struct inode *jfs_iget(struct super_block *sb, unsigned long ino)
  22. {
  23. struct inode *inode;
  24. int ret;
  25. inode = iget_locked(sb, ino);
  26. if (!inode)
  27. return ERR_PTR(-ENOMEM);
  28. if (!(inode->i_state & I_NEW))
  29. return inode;
  30. ret = diRead(inode);
  31. if (ret < 0) {
  32. iget_failed(inode);
  33. return ERR_PTR(ret);
  34. }
  35. if (S_ISREG(inode->i_mode)) {
  36. inode->i_op = &jfs_file_inode_operations;
  37. inode->i_fop = &jfs_file_operations;
  38. inode->i_mapping->a_ops = &jfs_aops;
  39. } else if (S_ISDIR(inode->i_mode)) {
  40. inode->i_op = &jfs_dir_inode_operations;
  41. inode->i_fop = &jfs_dir_operations;
  42. } else if (S_ISLNK(inode->i_mode)) {
  43. if (inode->i_size >= IDATASIZE) {
  44. inode->i_op = &page_symlink_inode_operations;
  45. inode_nohighmem(inode);
  46. inode->i_mapping->a_ops = &jfs_aops;
  47. } else {
  48. inode->i_op = &jfs_fast_symlink_inode_operations;
  49. inode->i_link = JFS_IP(inode)->i_inline;
  50. /*
  51. * The inline data should be null-terminated, but
  52. * don't let on-disk corruption crash the kernel
  53. */
  54. inode->i_link[inode->i_size] = '\0';
  55. }
  56. } else {
  57. inode->i_op = &jfs_file_inode_operations;
  58. init_special_inode(inode, inode->i_mode, inode->i_rdev);
  59. }
  60. unlock_new_inode(inode);
  61. return inode;
  62. }
  63. /*
  64. * Workhorse of both fsync & write_inode
  65. */
  66. int jfs_commit_inode(struct inode *inode, int wait)
  67. {
  68. int rc = 0;
  69. tid_t tid;
  70. static int noisy = 5;
  71. jfs_info("In jfs_commit_inode, inode = 0x%p", inode);
  72. /*
  73. * Don't commit if inode has been committed since last being
  74. * marked dirty, or if it has been deleted.
  75. */
  76. if (inode->i_nlink == 0 || !test_cflag(COMMIT_Dirty, inode))
  77. return 0;
  78. if (isReadOnly(inode)) {
  79. /* kernel allows writes to devices on read-only
  80. * partitions and may think inode is dirty
  81. */
  82. if (!special_file(inode->i_mode) && noisy) {
  83. jfs_err("jfs_commit_inode(0x%p) called on read-only volume",
  84. inode);
  85. jfs_err("Is remount racy?");
  86. noisy--;
  87. }
  88. return 0;
  89. }
  90. tid = txBegin(inode->i_sb, COMMIT_INODE);
  91. mutex_lock(&JFS_IP(inode)->commit_mutex);
  92. /*
  93. * Retest inode state after taking commit_mutex
  94. */
  95. if (inode->i_nlink && test_cflag(COMMIT_Dirty, inode))
  96. rc = txCommit(tid, 1, &inode, wait ? COMMIT_SYNC : 0);
  97. txEnd(tid);
  98. mutex_unlock(&JFS_IP(inode)->commit_mutex);
  99. return rc;
  100. }
  101. int jfs_write_inode(struct inode *inode, struct writeback_control *wbc)
  102. {
  103. int wait = wbc->sync_mode == WB_SYNC_ALL;
  104. if (inode->i_nlink == 0)
  105. return 0;
  106. /*
  107. * If COMMIT_DIRTY is not set, the inode isn't really dirty.
  108. * It has been committed since the last change, but was still
  109. * on the dirty inode list.
  110. */
  111. if (!test_cflag(COMMIT_Dirty, inode)) {
  112. /* Make sure committed changes hit the disk */
  113. jfs_flush_journal(JFS_SBI(inode->i_sb)->log, wait);
  114. return 0;
  115. }
  116. if (jfs_commit_inode(inode, wait)) {
  117. jfs_err("jfs_write_inode: jfs_commit_inode failed!");
  118. return -EIO;
  119. } else
  120. return 0;
  121. }
  122. void jfs_evict_inode(struct inode *inode)
  123. {
  124. struct jfs_inode_info *ji = JFS_IP(inode);
  125. jfs_info("In jfs_evict_inode, inode = 0x%p", inode);
  126. if (!inode->i_nlink && !is_bad_inode(inode)) {
  127. dquot_initialize(inode);
  128. if (JFS_IP(inode)->fileset == FILESYSTEM_I) {
  129. struct inode *ipimap = JFS_SBI(inode->i_sb)->ipimap;
  130. truncate_inode_pages_final(&inode->i_data);
  131. if (test_cflag(COMMIT_Freewmap, inode))
  132. jfs_free_zero_link(inode);
  133. if (ipimap && JFS_IP(ipimap)->i_imap)
  134. diFree(inode);
  135. /*
  136. * Free the inode from the quota allocation.
  137. */
  138. dquot_free_inode(inode);
  139. }
  140. } else {
  141. truncate_inode_pages_final(&inode->i_data);
  142. }
  143. clear_inode(inode);
  144. dquot_drop(inode);
  145. BUG_ON(!list_empty(&ji->anon_inode_list));
  146. spin_lock_irq(&ji->ag_lock);
  147. if (ji->active_ag != -1) {
  148. struct bmap *bmap = JFS_SBI(inode->i_sb)->bmap;
  149. atomic_dec(&bmap->db_active[ji->active_ag]);
  150. ji->active_ag = -1;
  151. }
  152. spin_unlock_irq(&ji->ag_lock);
  153. }
  154. void jfs_dirty_inode(struct inode *inode, int flags)
  155. {
  156. static int noisy = 5;
  157. if (isReadOnly(inode)) {
  158. if (!special_file(inode->i_mode) && noisy) {
  159. /* kernel allows writes to devices on read-only
  160. * partitions and may try to mark inode dirty
  161. */
  162. jfs_err("jfs_dirty_inode called on read-only volume");
  163. jfs_err("Is remount racy?");
  164. noisy--;
  165. }
  166. return;
  167. }
  168. set_cflag(COMMIT_Dirty, inode);
  169. }
  170. int jfs_get_block(struct inode *ip, sector_t lblock,
  171. struct buffer_head *bh_result, int create)
  172. {
  173. s64 lblock64 = lblock;
  174. int rc = 0;
  175. xad_t xad;
  176. s64 xaddr;
  177. int xflag;
  178. s32 xlen = bh_result->b_size >> ip->i_blkbits;
  179. /*
  180. * Take appropriate lock on inode
  181. */
  182. if (create)
  183. IWRITE_LOCK(ip, RDWRLOCK_NORMAL);
  184. else
  185. IREAD_LOCK(ip, RDWRLOCK_NORMAL);
  186. if (((lblock64 << ip->i_sb->s_blocksize_bits) < ip->i_size) &&
  187. (!xtLookup(ip, lblock64, xlen, &xflag, &xaddr, &xlen, 0)) &&
  188. xaddr) {
  189. if (xflag & XAD_NOTRECORDED) {
  190. if (!create)
  191. /*
  192. * Allocated but not recorded, read treats
  193. * this as a hole
  194. */
  195. goto unlock;
  196. #ifdef _JFS_4K
  197. XADoffset(&xad, lblock64);
  198. XADlength(&xad, xlen);
  199. XADaddress(&xad, xaddr);
  200. #else /* _JFS_4K */
  201. /*
  202. * As long as block size = 4K, this isn't a problem.
  203. * We should mark the whole page not ABNR, but how
  204. * will we know to mark the other blocks BH_New?
  205. */
  206. BUG();
  207. #endif /* _JFS_4K */
  208. rc = extRecord(ip, &xad);
  209. if (rc)
  210. goto unlock;
  211. set_buffer_new(bh_result);
  212. }
  213. map_bh(bh_result, ip->i_sb, xaddr);
  214. bh_result->b_size = xlen << ip->i_blkbits;
  215. goto unlock;
  216. }
  217. if (!create)
  218. goto unlock;
  219. /*
  220. * Allocate a new block
  221. */
  222. #ifdef _JFS_4K
  223. if ((rc = extHint(ip, lblock64 << ip->i_sb->s_blocksize_bits, &xad)))
  224. goto unlock;
  225. rc = extAlloc(ip, xlen, lblock64, &xad, false);
  226. if (rc)
  227. goto unlock;
  228. set_buffer_new(bh_result);
  229. map_bh(bh_result, ip->i_sb, addressXAD(&xad));
  230. bh_result->b_size = lengthXAD(&xad) << ip->i_blkbits;
  231. #else /* _JFS_4K */
  232. /*
  233. * We need to do whatever it takes to keep all but the last buffers
  234. * in 4K pages - see jfs_write.c
  235. */
  236. BUG();
  237. #endif /* _JFS_4K */
  238. unlock:
  239. /*
  240. * Release lock on inode
  241. */
  242. if (create)
  243. IWRITE_UNLOCK(ip);
  244. else
  245. IREAD_UNLOCK(ip);
  246. return rc;
  247. }
  248. static int jfs_writepage(struct page *page, struct writeback_control *wbc)
  249. {
  250. return block_write_full_page(page, jfs_get_block, wbc);
  251. }
  252. static int jfs_writepages(struct address_space *mapping,
  253. struct writeback_control *wbc)
  254. {
  255. return mpage_writepages(mapping, wbc, jfs_get_block);
  256. }
  257. static int jfs_readpage(struct file *file, struct page *page)
  258. {
  259. return mpage_readpage(page, jfs_get_block);
  260. }
  261. static void jfs_readahead(struct readahead_control *rac)
  262. {
  263. mpage_readahead(rac, jfs_get_block);
  264. }
  265. static void jfs_write_failed(struct address_space *mapping, loff_t to)
  266. {
  267. struct inode *inode = mapping->host;
  268. if (to > inode->i_size) {
  269. truncate_pagecache(inode, inode->i_size);
  270. jfs_truncate(inode);
  271. }
  272. }
  273. static int jfs_write_begin(struct file *file, struct address_space *mapping,
  274. loff_t pos, unsigned len, unsigned flags,
  275. struct page **pagep, void **fsdata)
  276. {
  277. int ret;
  278. ret = nobh_write_begin(mapping, pos, len, flags, pagep, fsdata,
  279. jfs_get_block);
  280. if (unlikely(ret))
  281. jfs_write_failed(mapping, pos + len);
  282. return ret;
  283. }
  284. static sector_t jfs_bmap(struct address_space *mapping, sector_t block)
  285. {
  286. return generic_block_bmap(mapping, block, jfs_get_block);
  287. }
  288. static ssize_t jfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
  289. {
  290. struct file *file = iocb->ki_filp;
  291. struct address_space *mapping = file->f_mapping;
  292. struct inode *inode = file->f_mapping->host;
  293. size_t count = iov_iter_count(iter);
  294. ssize_t ret;
  295. ret = blockdev_direct_IO(iocb, inode, iter, jfs_get_block);
  296. /*
  297. * In case of error extending write may have instantiated a few
  298. * blocks outside i_size. Trim these off again.
  299. */
  300. if (unlikely(iov_iter_rw(iter) == WRITE && ret < 0)) {
  301. loff_t isize = i_size_read(inode);
  302. loff_t end = iocb->ki_pos + count;
  303. if (end > isize)
  304. jfs_write_failed(mapping, end);
  305. }
  306. return ret;
  307. }
  308. const struct address_space_operations jfs_aops = {
  309. .readpage = jfs_readpage,
  310. .readahead = jfs_readahead,
  311. .writepage = jfs_writepage,
  312. .writepages = jfs_writepages,
  313. .write_begin = jfs_write_begin,
  314. .write_end = nobh_write_end,
  315. .bmap = jfs_bmap,
  316. .direct_IO = jfs_direct_IO,
  317. };
  318. /*
  319. * Guts of jfs_truncate. Called with locks already held. Can be called
  320. * with directory for truncating directory index table.
  321. */
  322. void jfs_truncate_nolock(struct inode *ip, loff_t length)
  323. {
  324. loff_t newsize;
  325. tid_t tid;
  326. ASSERT(length >= 0);
  327. if (test_cflag(COMMIT_Nolink, ip)) {
  328. xtTruncate(0, ip, length, COMMIT_WMAP);
  329. return;
  330. }
  331. do {
  332. tid = txBegin(ip->i_sb, 0);
  333. /*
  334. * The commit_mutex cannot be taken before txBegin.
  335. * txBegin may block and there is a chance the inode
  336. * could be marked dirty and need to be committed
  337. * before txBegin unblocks
  338. */
  339. mutex_lock(&JFS_IP(ip)->commit_mutex);
  340. newsize = xtTruncate(tid, ip, length,
  341. COMMIT_TRUNCATE | COMMIT_PWMAP);
  342. if (newsize < 0) {
  343. txEnd(tid);
  344. mutex_unlock(&JFS_IP(ip)->commit_mutex);
  345. break;
  346. }
  347. ip->i_mtime = ip->i_ctime = current_time(ip);
  348. mark_inode_dirty(ip);
  349. txCommit(tid, 1, &ip, 0);
  350. txEnd(tid);
  351. mutex_unlock(&JFS_IP(ip)->commit_mutex);
  352. } while (newsize > length); /* Truncate isn't always atomic */
  353. }
  354. void jfs_truncate(struct inode *ip)
  355. {
  356. jfs_info("jfs_truncate: size = 0x%lx", (ulong) ip->i_size);
  357. nobh_truncate_page(ip->i_mapping, ip->i_size, jfs_get_block);
  358. IWRITE_LOCK(ip, RDWRLOCK_NORMAL);
  359. jfs_truncate_nolock(ip, ip->i_size);
  360. IWRITE_UNLOCK(ip);
  361. }