xfs_file.c 36 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417
  1. /*
  2. * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  3. * All Rights Reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it would be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write the Free Software Foundation,
  16. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #include "xfs.h"
  19. #include "xfs_fs.h"
  20. #include "xfs_shared.h"
  21. #include "xfs_format.h"
  22. #include "xfs_log_format.h"
  23. #include "xfs_trans_resv.h"
  24. #include "xfs_mount.h"
  25. #include "xfs_da_format.h"
  26. #include "xfs_da_btree.h"
  27. #include "xfs_inode.h"
  28. #include "xfs_trans.h"
  29. #include "xfs_inode_item.h"
  30. #include "xfs_bmap.h"
  31. #include "xfs_bmap_util.h"
  32. #include "xfs_error.h"
  33. #include "xfs_dir2.h"
  34. #include "xfs_dir2_priv.h"
  35. #include "xfs_ioctl.h"
  36. #include "xfs_trace.h"
  37. #include "xfs_log.h"
  38. #include "xfs_icache.h"
  39. #include "xfs_pnfs.h"
  40. #include <linux/aio.h>
  41. #include <linux/dcache.h>
  42. #include <linux/falloc.h>
  43. #include <linux/pagevec.h>
  44. static const struct vm_operations_struct xfs_file_vm_ops;
  45. /*
  46. * Locking primitives for read and write IO paths to ensure we consistently use
  47. * and order the inode->i_mutex, ip->i_lock and ip->i_iolock.
  48. */
  49. static inline void
  50. xfs_rw_ilock(
  51. struct xfs_inode *ip,
  52. int type)
  53. {
  54. if (type & XFS_IOLOCK_EXCL)
  55. mutex_lock(&VFS_I(ip)->i_mutex);
  56. xfs_ilock(ip, type);
  57. }
  58. static inline void
  59. xfs_rw_iunlock(
  60. struct xfs_inode *ip,
  61. int type)
  62. {
  63. xfs_iunlock(ip, type);
  64. if (type & XFS_IOLOCK_EXCL)
  65. mutex_unlock(&VFS_I(ip)->i_mutex);
  66. }
  67. static inline void
  68. xfs_rw_ilock_demote(
  69. struct xfs_inode *ip,
  70. int type)
  71. {
  72. xfs_ilock_demote(ip, type);
  73. if (type & XFS_IOLOCK_EXCL)
  74. mutex_unlock(&VFS_I(ip)->i_mutex);
  75. }
  76. /*
  77. * xfs_iozero
  78. *
  79. * xfs_iozero clears the specified range of buffer supplied,
  80. * and marks all the affected blocks as valid and modified. If
  81. * an affected block is not allocated, it will be allocated. If
  82. * an affected block is not completely overwritten, and is not
  83. * valid before the operation, it will be read from disk before
  84. * being partially zeroed.
  85. */
  86. int
  87. xfs_iozero(
  88. struct xfs_inode *ip, /* inode */
  89. loff_t pos, /* offset in file */
  90. size_t count) /* size of data to zero */
  91. {
  92. struct page *page;
  93. struct address_space *mapping;
  94. int status;
  95. mapping = VFS_I(ip)->i_mapping;
  96. do {
  97. unsigned offset, bytes;
  98. void *fsdata;
  99. offset = (pos & (PAGE_CACHE_SIZE -1)); /* Within page */
  100. bytes = PAGE_CACHE_SIZE - offset;
  101. if (bytes > count)
  102. bytes = count;
  103. status = pagecache_write_begin(NULL, mapping, pos, bytes,
  104. AOP_FLAG_UNINTERRUPTIBLE,
  105. &page, &fsdata);
  106. if (status)
  107. break;
  108. zero_user(page, offset, bytes);
  109. status = pagecache_write_end(NULL, mapping, pos, bytes, bytes,
  110. page, fsdata);
  111. WARN_ON(status <= 0); /* can't return less than zero! */
  112. pos += bytes;
  113. count -= bytes;
  114. status = 0;
  115. } while (count);
  116. return (-status);
  117. }
  118. int
  119. xfs_update_prealloc_flags(
  120. struct xfs_inode *ip,
  121. enum xfs_prealloc_flags flags)
  122. {
  123. struct xfs_trans *tp;
  124. int error;
  125. tp = xfs_trans_alloc(ip->i_mount, XFS_TRANS_WRITEID);
  126. error = xfs_trans_reserve(tp, &M_RES(ip->i_mount)->tr_writeid, 0, 0);
  127. if (error) {
  128. xfs_trans_cancel(tp, 0);
  129. return error;
  130. }
  131. xfs_ilock(ip, XFS_ILOCK_EXCL);
  132. xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
  133. if (!(flags & XFS_PREALLOC_INVISIBLE)) {
  134. ip->i_d.di_mode &= ~S_ISUID;
  135. if (ip->i_d.di_mode & S_IXGRP)
  136. ip->i_d.di_mode &= ~S_ISGID;
  137. xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
  138. }
  139. if (flags & XFS_PREALLOC_SET)
  140. ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
  141. if (flags & XFS_PREALLOC_CLEAR)
  142. ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
  143. xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
  144. if (flags & XFS_PREALLOC_SYNC)
  145. xfs_trans_set_sync(tp);
  146. return xfs_trans_commit(tp, 0);
  147. }
  148. /*
  149. * Fsync operations on directories are much simpler than on regular files,
  150. * as there is no file data to flush, and thus also no need for explicit
  151. * cache flush operations, and there are no non-transaction metadata updates
  152. * on directories either.
  153. */
  154. STATIC int
  155. xfs_dir_fsync(
  156. struct file *file,
  157. loff_t start,
  158. loff_t end,
  159. int datasync)
  160. {
  161. struct xfs_inode *ip = XFS_I(file->f_mapping->host);
  162. struct xfs_mount *mp = ip->i_mount;
  163. xfs_lsn_t lsn = 0;
  164. trace_xfs_dir_fsync(ip);
  165. xfs_ilock(ip, XFS_ILOCK_SHARED);
  166. if (xfs_ipincount(ip))
  167. lsn = ip->i_itemp->ili_last_lsn;
  168. xfs_iunlock(ip, XFS_ILOCK_SHARED);
  169. if (!lsn)
  170. return 0;
  171. return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
  172. }
  173. STATIC int
  174. xfs_file_fsync(
  175. struct file *file,
  176. loff_t start,
  177. loff_t end,
  178. int datasync)
  179. {
  180. struct inode *inode = file->f_mapping->host;
  181. struct xfs_inode *ip = XFS_I(inode);
  182. struct xfs_mount *mp = ip->i_mount;
  183. int error = 0;
  184. int log_flushed = 0;
  185. xfs_lsn_t lsn = 0;
  186. trace_xfs_file_fsync(ip);
  187. error = filemap_write_and_wait_range(inode->i_mapping, start, end);
  188. if (error)
  189. return error;
  190. if (XFS_FORCED_SHUTDOWN(mp))
  191. return -EIO;
  192. xfs_iflags_clear(ip, XFS_ITRUNCATED);
  193. if (mp->m_flags & XFS_MOUNT_BARRIER) {
  194. /*
  195. * If we have an RT and/or log subvolume we need to make sure
  196. * to flush the write cache the device used for file data
  197. * first. This is to ensure newly written file data make
  198. * it to disk before logging the new inode size in case of
  199. * an extending write.
  200. */
  201. if (XFS_IS_REALTIME_INODE(ip))
  202. xfs_blkdev_issue_flush(mp->m_rtdev_targp);
  203. else if (mp->m_logdev_targp != mp->m_ddev_targp)
  204. xfs_blkdev_issue_flush(mp->m_ddev_targp);
  205. }
  206. /*
  207. * All metadata updates are logged, which means that we just have
  208. * to flush the log up to the latest LSN that touched the inode.
  209. */
  210. xfs_ilock(ip, XFS_ILOCK_SHARED);
  211. if (xfs_ipincount(ip)) {
  212. if (!datasync ||
  213. (ip->i_itemp->ili_fields & ~XFS_ILOG_TIMESTAMP))
  214. lsn = ip->i_itemp->ili_last_lsn;
  215. }
  216. xfs_iunlock(ip, XFS_ILOCK_SHARED);
  217. if (lsn)
  218. error = _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, &log_flushed);
  219. /*
  220. * If we only have a single device, and the log force about was
  221. * a no-op we might have to flush the data device cache here.
  222. * This can only happen for fdatasync/O_DSYNC if we were overwriting
  223. * an already allocated file and thus do not have any metadata to
  224. * commit.
  225. */
  226. if ((mp->m_flags & XFS_MOUNT_BARRIER) &&
  227. mp->m_logdev_targp == mp->m_ddev_targp &&
  228. !XFS_IS_REALTIME_INODE(ip) &&
  229. !log_flushed)
  230. xfs_blkdev_issue_flush(mp->m_ddev_targp);
  231. return error;
  232. }
  233. STATIC ssize_t
  234. xfs_file_read_iter(
  235. struct kiocb *iocb,
  236. struct iov_iter *to)
  237. {
  238. struct file *file = iocb->ki_filp;
  239. struct inode *inode = file->f_mapping->host;
  240. struct xfs_inode *ip = XFS_I(inode);
  241. struct xfs_mount *mp = ip->i_mount;
  242. size_t size = iov_iter_count(to);
  243. ssize_t ret = 0;
  244. int ioflags = 0;
  245. xfs_fsize_t n;
  246. loff_t pos = iocb->ki_pos;
  247. XFS_STATS_INC(xs_read_calls);
  248. if (unlikely(file->f_flags & O_DIRECT))
  249. ioflags |= XFS_IO_ISDIRECT;
  250. if (file->f_mode & FMODE_NOCMTIME)
  251. ioflags |= XFS_IO_INVIS;
  252. if (unlikely(ioflags & XFS_IO_ISDIRECT)) {
  253. xfs_buftarg_t *target =
  254. XFS_IS_REALTIME_INODE(ip) ?
  255. mp->m_rtdev_targp : mp->m_ddev_targp;
  256. /* DIO must be aligned to device logical sector size */
  257. if ((pos | size) & target->bt_logical_sectormask) {
  258. if (pos == i_size_read(inode))
  259. return 0;
  260. return -EINVAL;
  261. }
  262. }
  263. n = mp->m_super->s_maxbytes - pos;
  264. if (n <= 0 || size == 0)
  265. return 0;
  266. if (n < size)
  267. size = n;
  268. if (XFS_FORCED_SHUTDOWN(mp))
  269. return -EIO;
  270. /*
  271. * Locking is a bit tricky here. If we take an exclusive lock
  272. * for direct IO, we effectively serialise all new concurrent
  273. * read IO to this file and block it behind IO that is currently in
  274. * progress because IO in progress holds the IO lock shared. We only
  275. * need to hold the lock exclusive to blow away the page cache, so
  276. * only take lock exclusively if the page cache needs invalidation.
  277. * This allows the normal direct IO case of no page cache pages to
  278. * proceeed concurrently without serialisation.
  279. */
  280. xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
  281. if ((ioflags & XFS_IO_ISDIRECT) && inode->i_mapping->nrpages) {
  282. xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
  283. xfs_rw_ilock(ip, XFS_IOLOCK_EXCL);
  284. if (inode->i_mapping->nrpages) {
  285. ret = filemap_write_and_wait_range(
  286. VFS_I(ip)->i_mapping,
  287. pos, pos + size - 1);
  288. if (ret) {
  289. xfs_rw_iunlock(ip, XFS_IOLOCK_EXCL);
  290. return ret;
  291. }
  292. /*
  293. * Invalidate whole pages. This can return an error if
  294. * we fail to invalidate a page, but this should never
  295. * happen on XFS. Warn if it does fail.
  296. */
  297. ret = invalidate_inode_pages2_range(VFS_I(ip)->i_mapping,
  298. pos >> PAGE_CACHE_SHIFT,
  299. (pos + size - 1) >> PAGE_CACHE_SHIFT);
  300. WARN_ON_ONCE(ret);
  301. ret = 0;
  302. }
  303. xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL);
  304. }
  305. trace_xfs_file_read(ip, size, pos, ioflags);
  306. ret = generic_file_read_iter(iocb, to);
  307. if (ret > 0)
  308. XFS_STATS_ADD(xs_read_bytes, ret);
  309. xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
  310. return ret;
  311. }
  312. STATIC ssize_t
  313. xfs_file_splice_read(
  314. struct file *infilp,
  315. loff_t *ppos,
  316. struct pipe_inode_info *pipe,
  317. size_t count,
  318. unsigned int flags)
  319. {
  320. struct xfs_inode *ip = XFS_I(infilp->f_mapping->host);
  321. int ioflags = 0;
  322. ssize_t ret;
  323. XFS_STATS_INC(xs_read_calls);
  324. if (infilp->f_mode & FMODE_NOCMTIME)
  325. ioflags |= XFS_IO_INVIS;
  326. if (XFS_FORCED_SHUTDOWN(ip->i_mount))
  327. return -EIO;
  328. xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
  329. trace_xfs_file_splice_read(ip, count, *ppos, ioflags);
  330. ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
  331. if (ret > 0)
  332. XFS_STATS_ADD(xs_read_bytes, ret);
  333. xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
  334. return ret;
  335. }
  336. /*
  337. * This routine is called to handle zeroing any space in the last block of the
  338. * file that is beyond the EOF. We do this since the size is being increased
  339. * without writing anything to that block and we don't want to read the
  340. * garbage on the disk.
  341. */
  342. STATIC int /* error (positive) */
  343. xfs_zero_last_block(
  344. struct xfs_inode *ip,
  345. xfs_fsize_t offset,
  346. xfs_fsize_t isize)
  347. {
  348. struct xfs_mount *mp = ip->i_mount;
  349. xfs_fileoff_t last_fsb = XFS_B_TO_FSBT(mp, isize);
  350. int zero_offset = XFS_B_FSB_OFFSET(mp, isize);
  351. int zero_len;
  352. int nimaps = 1;
  353. int error = 0;
  354. struct xfs_bmbt_irec imap;
  355. xfs_ilock(ip, XFS_ILOCK_EXCL);
  356. error = xfs_bmapi_read(ip, last_fsb, 1, &imap, &nimaps, 0);
  357. xfs_iunlock(ip, XFS_ILOCK_EXCL);
  358. if (error)
  359. return error;
  360. ASSERT(nimaps > 0);
  361. /*
  362. * If the block underlying isize is just a hole, then there
  363. * is nothing to zero.
  364. */
  365. if (imap.br_startblock == HOLESTARTBLOCK)
  366. return 0;
  367. zero_len = mp->m_sb.sb_blocksize - zero_offset;
  368. if (isize + zero_len > offset)
  369. zero_len = offset - isize;
  370. return xfs_iozero(ip, isize, zero_len);
  371. }
  372. /*
  373. * Zero any on disk space between the current EOF and the new, larger EOF.
  374. *
  375. * This handles the normal case of zeroing the remainder of the last block in
  376. * the file and the unusual case of zeroing blocks out beyond the size of the
  377. * file. This second case only happens with fixed size extents and when the
  378. * system crashes before the inode size was updated but after blocks were
  379. * allocated.
  380. *
  381. * Expects the iolock to be held exclusive, and will take the ilock internally.
  382. */
  383. int /* error (positive) */
  384. xfs_zero_eof(
  385. struct xfs_inode *ip,
  386. xfs_off_t offset, /* starting I/O offset */
  387. xfs_fsize_t isize) /* current inode size */
  388. {
  389. struct xfs_mount *mp = ip->i_mount;
  390. xfs_fileoff_t start_zero_fsb;
  391. xfs_fileoff_t end_zero_fsb;
  392. xfs_fileoff_t zero_count_fsb;
  393. xfs_fileoff_t last_fsb;
  394. xfs_fileoff_t zero_off;
  395. xfs_fsize_t zero_len;
  396. int nimaps;
  397. int error = 0;
  398. struct xfs_bmbt_irec imap;
  399. ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
  400. ASSERT(offset > isize);
  401. /*
  402. * First handle zeroing the block on which isize resides.
  403. *
  404. * We only zero a part of that block so it is handled specially.
  405. */
  406. if (XFS_B_FSB_OFFSET(mp, isize) != 0) {
  407. error = xfs_zero_last_block(ip, offset, isize);
  408. if (error)
  409. return error;
  410. }
  411. /*
  412. * Calculate the range between the new size and the old where blocks
  413. * needing to be zeroed may exist.
  414. *
  415. * To get the block where the last byte in the file currently resides,
  416. * we need to subtract one from the size and truncate back to a block
  417. * boundary. We subtract 1 in case the size is exactly on a block
  418. * boundary.
  419. */
  420. last_fsb = isize ? XFS_B_TO_FSBT(mp, isize - 1) : (xfs_fileoff_t)-1;
  421. start_zero_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)isize);
  422. end_zero_fsb = XFS_B_TO_FSBT(mp, offset - 1);
  423. ASSERT((xfs_sfiloff_t)last_fsb < (xfs_sfiloff_t)start_zero_fsb);
  424. if (last_fsb == end_zero_fsb) {
  425. /*
  426. * The size was only incremented on its last block.
  427. * We took care of that above, so just return.
  428. */
  429. return 0;
  430. }
  431. ASSERT(start_zero_fsb <= end_zero_fsb);
  432. while (start_zero_fsb <= end_zero_fsb) {
  433. nimaps = 1;
  434. zero_count_fsb = end_zero_fsb - start_zero_fsb + 1;
  435. xfs_ilock(ip, XFS_ILOCK_EXCL);
  436. error = xfs_bmapi_read(ip, start_zero_fsb, zero_count_fsb,
  437. &imap, &nimaps, 0);
  438. xfs_iunlock(ip, XFS_ILOCK_EXCL);
  439. if (error)
  440. return error;
  441. ASSERT(nimaps > 0);
  442. if (imap.br_state == XFS_EXT_UNWRITTEN ||
  443. imap.br_startblock == HOLESTARTBLOCK) {
  444. start_zero_fsb = imap.br_startoff + imap.br_blockcount;
  445. ASSERT(start_zero_fsb <= (end_zero_fsb + 1));
  446. continue;
  447. }
  448. /*
  449. * There are blocks we need to zero.
  450. */
  451. zero_off = XFS_FSB_TO_B(mp, start_zero_fsb);
  452. zero_len = XFS_FSB_TO_B(mp, imap.br_blockcount);
  453. if ((zero_off + zero_len) > offset)
  454. zero_len = offset - zero_off;
  455. error = xfs_iozero(ip, zero_off, zero_len);
  456. if (error)
  457. return error;
  458. start_zero_fsb = imap.br_startoff + imap.br_blockcount;
  459. ASSERT(start_zero_fsb <= (end_zero_fsb + 1));
  460. }
  461. return 0;
  462. }
  463. /*
  464. * Common pre-write limit and setup checks.
  465. *
  466. * Called with the iolocked held either shared and exclusive according to
  467. * @iolock, and returns with it held. Might upgrade the iolock to exclusive
  468. * if called for a direct write beyond i_size.
  469. */
  470. STATIC ssize_t
  471. xfs_file_aio_write_checks(
  472. struct file *file,
  473. loff_t *pos,
  474. size_t *count,
  475. int *iolock)
  476. {
  477. struct inode *inode = file->f_mapping->host;
  478. struct xfs_inode *ip = XFS_I(inode);
  479. int error = 0;
  480. restart:
  481. error = generic_write_checks(file, pos, count, S_ISBLK(inode->i_mode));
  482. if (error)
  483. return error;
  484. error = xfs_break_layouts(inode, iolock);
  485. if (error)
  486. return error;
  487. /*
  488. * If the offset is beyond the size of the file, we need to zero any
  489. * blocks that fall between the existing EOF and the start of this
  490. * write. If zeroing is needed and we are currently holding the
  491. * iolock shared, we need to update it to exclusive which implies
  492. * having to redo all checks before.
  493. */
  494. if (*pos > i_size_read(inode)) {
  495. if (*iolock == XFS_IOLOCK_SHARED) {
  496. xfs_rw_iunlock(ip, *iolock);
  497. *iolock = XFS_IOLOCK_EXCL;
  498. xfs_rw_ilock(ip, *iolock);
  499. goto restart;
  500. }
  501. error = xfs_zero_eof(ip, *pos, i_size_read(inode));
  502. if (error)
  503. return error;
  504. }
  505. /*
  506. * Updating the timestamps will grab the ilock again from
  507. * xfs_fs_dirty_inode, so we have to call it after dropping the
  508. * lock above. Eventually we should look into a way to avoid
  509. * the pointless lock roundtrip.
  510. */
  511. if (likely(!(file->f_mode & FMODE_NOCMTIME))) {
  512. error = file_update_time(file);
  513. if (error)
  514. return error;
  515. }
  516. /*
  517. * If we're writing the file then make sure to clear the setuid and
  518. * setgid bits if the process is not being run by root. This keeps
  519. * people from modifying setuid and setgid binaries.
  520. */
  521. return file_remove_suid(file);
  522. }
  523. /*
  524. * xfs_file_dio_aio_write - handle direct IO writes
  525. *
  526. * Lock the inode appropriately to prepare for and issue a direct IO write.
  527. * By separating it from the buffered write path we remove all the tricky to
  528. * follow locking changes and looping.
  529. *
  530. * If there are cached pages or we're extending the file, we need IOLOCK_EXCL
  531. * until we're sure the bytes at the new EOF have been zeroed and/or the cached
  532. * pages are flushed out.
  533. *
  534. * In most cases the direct IO writes will be done holding IOLOCK_SHARED
  535. * allowing them to be done in parallel with reads and other direct IO writes.
  536. * However, if the IO is not aligned to filesystem blocks, the direct IO layer
  537. * needs to do sub-block zeroing and that requires serialisation against other
  538. * direct IOs to the same block. In this case we need to serialise the
  539. * submission of the unaligned IOs so that we don't get racing block zeroing in
  540. * the dio layer. To avoid the problem with aio, we also need to wait for
  541. * outstanding IOs to complete so that unwritten extent conversion is completed
  542. * before we try to map the overlapping block. This is currently implemented by
  543. * hitting it with a big hammer (i.e. inode_dio_wait()).
  544. *
  545. * Returns with locks held indicated by @iolock and errors indicated by
  546. * negative return values.
  547. */
  548. STATIC ssize_t
  549. xfs_file_dio_aio_write(
  550. struct kiocb *iocb,
  551. struct iov_iter *from)
  552. {
  553. struct file *file = iocb->ki_filp;
  554. struct address_space *mapping = file->f_mapping;
  555. struct inode *inode = mapping->host;
  556. struct xfs_inode *ip = XFS_I(inode);
  557. struct xfs_mount *mp = ip->i_mount;
  558. ssize_t ret = 0;
  559. int unaligned_io = 0;
  560. int iolock;
  561. size_t count = iov_iter_count(from);
  562. loff_t pos = iocb->ki_pos;
  563. struct xfs_buftarg *target = XFS_IS_REALTIME_INODE(ip) ?
  564. mp->m_rtdev_targp : mp->m_ddev_targp;
  565. /* DIO must be aligned to device logical sector size */
  566. if ((pos | count) & target->bt_logical_sectormask)
  567. return -EINVAL;
  568. /* "unaligned" here means not aligned to a filesystem block */
  569. if ((pos & mp->m_blockmask) || ((pos + count) & mp->m_blockmask))
  570. unaligned_io = 1;
  571. /*
  572. * We don't need to take an exclusive lock unless there page cache needs
  573. * to be invalidated or unaligned IO is being executed. We don't need to
  574. * consider the EOF extension case here because
  575. * xfs_file_aio_write_checks() will relock the inode as necessary for
  576. * EOF zeroing cases and fill out the new inode size as appropriate.
  577. */
  578. if (unaligned_io || mapping->nrpages)
  579. iolock = XFS_IOLOCK_EXCL;
  580. else
  581. iolock = XFS_IOLOCK_SHARED;
  582. xfs_rw_ilock(ip, iolock);
  583. /*
  584. * Recheck if there are cached pages that need invalidate after we got
  585. * the iolock to protect against other threads adding new pages while
  586. * we were waiting for the iolock.
  587. */
  588. if (mapping->nrpages && iolock == XFS_IOLOCK_SHARED) {
  589. xfs_rw_iunlock(ip, iolock);
  590. iolock = XFS_IOLOCK_EXCL;
  591. xfs_rw_ilock(ip, iolock);
  592. }
  593. ret = xfs_file_aio_write_checks(file, &pos, &count, &iolock);
  594. if (ret)
  595. goto out;
  596. iov_iter_truncate(from, count);
  597. if (mapping->nrpages) {
  598. ret = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
  599. pos, pos + count - 1);
  600. if (ret)
  601. goto out;
  602. /*
  603. * Invalidate whole pages. This can return an error if
  604. * we fail to invalidate a page, but this should never
  605. * happen on XFS. Warn if it does fail.
  606. */
  607. ret = invalidate_inode_pages2_range(VFS_I(ip)->i_mapping,
  608. pos >> PAGE_CACHE_SHIFT,
  609. (pos + count - 1) >> PAGE_CACHE_SHIFT);
  610. WARN_ON_ONCE(ret);
  611. ret = 0;
  612. }
  613. /*
  614. * If we are doing unaligned IO, wait for all other IO to drain,
  615. * otherwise demote the lock if we had to flush cached pages
  616. */
  617. if (unaligned_io)
  618. inode_dio_wait(inode);
  619. else if (iolock == XFS_IOLOCK_EXCL) {
  620. xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL);
  621. iolock = XFS_IOLOCK_SHARED;
  622. }
  623. trace_xfs_file_direct_write(ip, count, iocb->ki_pos, 0);
  624. ret = generic_file_direct_write(iocb, from, pos);
  625. out:
  626. xfs_rw_iunlock(ip, iolock);
  627. /* No fallback to buffered IO on errors for XFS. */
  628. ASSERT(ret < 0 || ret == count);
  629. return ret;
  630. }
  631. STATIC ssize_t
  632. xfs_file_buffered_aio_write(
  633. struct kiocb *iocb,
  634. struct iov_iter *from)
  635. {
  636. struct file *file = iocb->ki_filp;
  637. struct address_space *mapping = file->f_mapping;
  638. struct inode *inode = mapping->host;
  639. struct xfs_inode *ip = XFS_I(inode);
  640. ssize_t ret;
  641. int enospc = 0;
  642. int iolock = XFS_IOLOCK_EXCL;
  643. loff_t pos = iocb->ki_pos;
  644. size_t count = iov_iter_count(from);
  645. xfs_rw_ilock(ip, iolock);
  646. ret = xfs_file_aio_write_checks(file, &pos, &count, &iolock);
  647. if (ret)
  648. goto out;
  649. iov_iter_truncate(from, count);
  650. /* We can write back this queue in page reclaim */
  651. current->backing_dev_info = inode_to_bdi(inode);
  652. write_retry:
  653. trace_xfs_file_buffered_write(ip, count, iocb->ki_pos, 0);
  654. ret = generic_perform_write(file, from, pos);
  655. if (likely(ret >= 0))
  656. iocb->ki_pos = pos + ret;
  657. /*
  658. * If we hit a space limit, try to free up some lingering preallocated
  659. * space before returning an error. In the case of ENOSPC, first try to
  660. * write back all dirty inodes to free up some of the excess reserved
  661. * metadata space. This reduces the chances that the eofblocks scan
  662. * waits on dirty mappings. Since xfs_flush_inodes() is serialized, this
  663. * also behaves as a filter to prevent too many eofblocks scans from
  664. * running at the same time.
  665. */
  666. if (ret == -EDQUOT && !enospc) {
  667. enospc = xfs_inode_free_quota_eofblocks(ip);
  668. if (enospc)
  669. goto write_retry;
  670. } else if (ret == -ENOSPC && !enospc) {
  671. struct xfs_eofblocks eofb = {0};
  672. enospc = 1;
  673. xfs_flush_inodes(ip->i_mount);
  674. eofb.eof_scan_owner = ip->i_ino; /* for locking */
  675. eofb.eof_flags = XFS_EOF_FLAGS_SYNC;
  676. xfs_icache_free_eofblocks(ip->i_mount, &eofb);
  677. goto write_retry;
  678. }
  679. current->backing_dev_info = NULL;
  680. out:
  681. xfs_rw_iunlock(ip, iolock);
  682. return ret;
  683. }
  684. STATIC ssize_t
  685. xfs_file_write_iter(
  686. struct kiocb *iocb,
  687. struct iov_iter *from)
  688. {
  689. struct file *file = iocb->ki_filp;
  690. struct address_space *mapping = file->f_mapping;
  691. struct inode *inode = mapping->host;
  692. struct xfs_inode *ip = XFS_I(inode);
  693. ssize_t ret;
  694. size_t ocount = iov_iter_count(from);
  695. XFS_STATS_INC(xs_write_calls);
  696. if (ocount == 0)
  697. return 0;
  698. if (XFS_FORCED_SHUTDOWN(ip->i_mount))
  699. return -EIO;
  700. if (unlikely(file->f_flags & O_DIRECT))
  701. ret = xfs_file_dio_aio_write(iocb, from);
  702. else
  703. ret = xfs_file_buffered_aio_write(iocb, from);
  704. if (ret > 0) {
  705. ssize_t err;
  706. XFS_STATS_ADD(xs_write_bytes, ret);
  707. /* Handle various SYNC-type writes */
  708. err = generic_write_sync(file, iocb->ki_pos - ret, ret);
  709. if (err < 0)
  710. ret = err;
  711. }
  712. return ret;
  713. }
  714. STATIC long
  715. xfs_file_fallocate(
  716. struct file *file,
  717. int mode,
  718. loff_t offset,
  719. loff_t len)
  720. {
  721. struct inode *inode = file_inode(file);
  722. struct xfs_inode *ip = XFS_I(inode);
  723. long error;
  724. enum xfs_prealloc_flags flags = 0;
  725. uint iolock = XFS_IOLOCK_EXCL;
  726. loff_t new_size = 0;
  727. if (!S_ISREG(inode->i_mode))
  728. return -EINVAL;
  729. if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
  730. FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE))
  731. return -EOPNOTSUPP;
  732. xfs_ilock(ip, iolock);
  733. error = xfs_break_layouts(inode, &iolock);
  734. if (error)
  735. goto out_unlock;
  736. if (mode & FALLOC_FL_PUNCH_HOLE) {
  737. error = xfs_free_file_space(ip, offset, len);
  738. if (error)
  739. goto out_unlock;
  740. } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
  741. unsigned blksize_mask = (1 << inode->i_blkbits) - 1;
  742. if (offset & blksize_mask || len & blksize_mask) {
  743. error = -EINVAL;
  744. goto out_unlock;
  745. }
  746. /*
  747. * There is no need to overlap collapse range with EOF,
  748. * in which case it is effectively a truncate operation
  749. */
  750. if (offset + len >= i_size_read(inode)) {
  751. error = -EINVAL;
  752. goto out_unlock;
  753. }
  754. new_size = i_size_read(inode) - len;
  755. error = xfs_collapse_file_space(ip, offset, len);
  756. if (error)
  757. goto out_unlock;
  758. } else {
  759. flags |= XFS_PREALLOC_SET;
  760. if (!(mode & FALLOC_FL_KEEP_SIZE) &&
  761. offset + len > i_size_read(inode)) {
  762. new_size = offset + len;
  763. error = inode_newsize_ok(inode, new_size);
  764. if (error)
  765. goto out_unlock;
  766. }
  767. if (mode & FALLOC_FL_ZERO_RANGE)
  768. error = xfs_zero_file_space(ip, offset, len);
  769. else
  770. error = xfs_alloc_file_space(ip, offset, len,
  771. XFS_BMAPI_PREALLOC);
  772. if (error)
  773. goto out_unlock;
  774. }
  775. if (file->f_flags & O_DSYNC)
  776. flags |= XFS_PREALLOC_SYNC;
  777. error = xfs_update_prealloc_flags(ip, flags);
  778. if (error)
  779. goto out_unlock;
  780. /* Change file size if needed */
  781. if (new_size) {
  782. struct iattr iattr;
  783. iattr.ia_valid = ATTR_SIZE;
  784. iattr.ia_size = new_size;
  785. error = xfs_setattr_size(ip, &iattr);
  786. }
  787. out_unlock:
  788. xfs_iunlock(ip, iolock);
  789. return error;
  790. }
  791. STATIC int
  792. xfs_file_open(
  793. struct inode *inode,
  794. struct file *file)
  795. {
  796. if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
  797. return -EFBIG;
  798. if (XFS_FORCED_SHUTDOWN(XFS_M(inode->i_sb)))
  799. return -EIO;
  800. return 0;
  801. }
  802. STATIC int
  803. xfs_dir_open(
  804. struct inode *inode,
  805. struct file *file)
  806. {
  807. struct xfs_inode *ip = XFS_I(inode);
  808. int mode;
  809. int error;
  810. error = xfs_file_open(inode, file);
  811. if (error)
  812. return error;
  813. /*
  814. * If there are any blocks, read-ahead block 0 as we're almost
  815. * certain to have the next operation be a read there.
  816. */
  817. mode = xfs_ilock_data_map_shared(ip);
  818. if (ip->i_d.di_nextents > 0)
  819. xfs_dir3_data_readahead(ip, 0, -1);
  820. xfs_iunlock(ip, mode);
  821. return 0;
  822. }
  823. STATIC int
  824. xfs_file_release(
  825. struct inode *inode,
  826. struct file *filp)
  827. {
  828. return xfs_release(XFS_I(inode));
  829. }
  830. STATIC int
  831. xfs_file_readdir(
  832. struct file *file,
  833. struct dir_context *ctx)
  834. {
  835. struct inode *inode = file_inode(file);
  836. xfs_inode_t *ip = XFS_I(inode);
  837. size_t bufsize;
  838. /*
  839. * The Linux API doesn't pass down the total size of the buffer
  840. * we read into down to the filesystem. With the filldir concept
  841. * it's not needed for correct information, but the XFS dir2 leaf
  842. * code wants an estimate of the buffer size to calculate it's
  843. * readahead window and size the buffers used for mapping to
  844. * physical blocks.
  845. *
  846. * Try to give it an estimate that's good enough, maybe at some
  847. * point we can change the ->readdir prototype to include the
  848. * buffer size. For now we use the current glibc buffer size.
  849. */
  850. bufsize = (size_t)min_t(loff_t, 32768, ip->i_d.di_size);
  851. return xfs_readdir(ip, ctx, bufsize);
  852. }
  853. STATIC int
  854. xfs_file_mmap(
  855. struct file *filp,
  856. struct vm_area_struct *vma)
  857. {
  858. vma->vm_ops = &xfs_file_vm_ops;
  859. file_accessed(filp);
  860. return 0;
  861. }
  862. /*
  863. * mmap()d file has taken write protection fault and is being made
  864. * writable. We can set the page state up correctly for a writable
  865. * page, which means we can do correct delalloc accounting (ENOSPC
  866. * checking!) and unwritten extent mapping.
  867. */
  868. STATIC int
  869. xfs_vm_page_mkwrite(
  870. struct vm_area_struct *vma,
  871. struct vm_fault *vmf)
  872. {
  873. return block_page_mkwrite(vma, vmf, xfs_get_blocks);
  874. }
  875. /*
  876. * This type is designed to indicate the type of offset we would like
  877. * to search from page cache for xfs_seek_hole_data().
  878. */
  879. enum {
  880. HOLE_OFF = 0,
  881. DATA_OFF,
  882. };
  883. /*
  884. * Lookup the desired type of offset from the given page.
  885. *
  886. * On success, return true and the offset argument will point to the
  887. * start of the region that was found. Otherwise this function will
  888. * return false and keep the offset argument unchanged.
  889. */
  890. STATIC bool
  891. xfs_lookup_buffer_offset(
  892. struct page *page,
  893. loff_t *offset,
  894. unsigned int type)
  895. {
  896. loff_t lastoff = page_offset(page);
  897. bool found = false;
  898. struct buffer_head *bh, *head;
  899. bh = head = page_buffers(page);
  900. do {
  901. /*
  902. * Unwritten extents that have data in the page
  903. * cache covering them can be identified by the
  904. * BH_Unwritten state flag. Pages with multiple
  905. * buffers might have a mix of holes, data and
  906. * unwritten extents - any buffer with valid
  907. * data in it should have BH_Uptodate flag set
  908. * on it.
  909. */
  910. if (buffer_unwritten(bh) ||
  911. buffer_uptodate(bh)) {
  912. if (type == DATA_OFF)
  913. found = true;
  914. } else {
  915. if (type == HOLE_OFF)
  916. found = true;
  917. }
  918. if (found) {
  919. *offset = lastoff;
  920. break;
  921. }
  922. lastoff += bh->b_size;
  923. } while ((bh = bh->b_this_page) != head);
  924. return found;
  925. }
  926. /*
  927. * This routine is called to find out and return a data or hole offset
  928. * from the page cache for unwritten extents according to the desired
  929. * type for xfs_seek_hole_data().
  930. *
  931. * The argument offset is used to tell where we start to search from the
  932. * page cache. Map is used to figure out the end points of the range to
  933. * lookup pages.
  934. *
  935. * Return true if the desired type of offset was found, and the argument
  936. * offset is filled with that address. Otherwise, return false and keep
  937. * offset unchanged.
  938. */
  939. STATIC bool
  940. xfs_find_get_desired_pgoff(
  941. struct inode *inode,
  942. struct xfs_bmbt_irec *map,
  943. unsigned int type,
  944. loff_t *offset)
  945. {
  946. struct xfs_inode *ip = XFS_I(inode);
  947. struct xfs_mount *mp = ip->i_mount;
  948. struct pagevec pvec;
  949. pgoff_t index;
  950. pgoff_t end;
  951. loff_t endoff;
  952. loff_t startoff = *offset;
  953. loff_t lastoff = startoff;
  954. bool found = false;
  955. pagevec_init(&pvec, 0);
  956. index = startoff >> PAGE_CACHE_SHIFT;
  957. endoff = XFS_FSB_TO_B(mp, map->br_startoff + map->br_blockcount);
  958. end = endoff >> PAGE_CACHE_SHIFT;
  959. do {
  960. int want;
  961. unsigned nr_pages;
  962. unsigned int i;
  963. want = min_t(pgoff_t, end - index, PAGEVEC_SIZE);
  964. nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
  965. want);
  966. /*
  967. * No page mapped into given range. If we are searching holes
  968. * and if this is the first time we got into the loop, it means
  969. * that the given offset is landed in a hole, return it.
  970. *
  971. * If we have already stepped through some block buffers to find
  972. * holes but they all contains data. In this case, the last
  973. * offset is already updated and pointed to the end of the last
  974. * mapped page, if it does not reach the endpoint to search,
  975. * that means there should be a hole between them.
  976. */
  977. if (nr_pages == 0) {
  978. /* Data search found nothing */
  979. if (type == DATA_OFF)
  980. break;
  981. ASSERT(type == HOLE_OFF);
  982. if (lastoff == startoff || lastoff < endoff) {
  983. found = true;
  984. *offset = lastoff;
  985. }
  986. break;
  987. }
  988. /*
  989. * At lease we found one page. If this is the first time we
  990. * step into the loop, and if the first page index offset is
  991. * greater than the given search offset, a hole was found.
  992. */
  993. if (type == HOLE_OFF && lastoff == startoff &&
  994. lastoff < page_offset(pvec.pages[0])) {
  995. found = true;
  996. break;
  997. }
  998. for (i = 0; i < nr_pages; i++) {
  999. struct page *page = pvec.pages[i];
  1000. loff_t b_offset;
  1001. /*
  1002. * At this point, the page may be truncated or
  1003. * invalidated (changing page->mapping to NULL),
  1004. * or even swizzled back from swapper_space to tmpfs
  1005. * file mapping. However, page->index will not change
  1006. * because we have a reference on the page.
  1007. *
  1008. * Searching done if the page index is out of range.
  1009. * If the current offset is not reaches the end of
  1010. * the specified search range, there should be a hole
  1011. * between them.
  1012. */
  1013. if (page->index > end) {
  1014. if (type == HOLE_OFF && lastoff < endoff) {
  1015. *offset = lastoff;
  1016. found = true;
  1017. }
  1018. goto out;
  1019. }
  1020. lock_page(page);
  1021. /*
  1022. * Page truncated or invalidated(page->mapping == NULL).
  1023. * We can freely skip it and proceed to check the next
  1024. * page.
  1025. */
  1026. if (unlikely(page->mapping != inode->i_mapping)) {
  1027. unlock_page(page);
  1028. continue;
  1029. }
  1030. if (!page_has_buffers(page)) {
  1031. unlock_page(page);
  1032. continue;
  1033. }
  1034. found = xfs_lookup_buffer_offset(page, &b_offset, type);
  1035. if (found) {
  1036. /*
  1037. * The found offset may be less than the start
  1038. * point to search if this is the first time to
  1039. * come here.
  1040. */
  1041. *offset = max_t(loff_t, startoff, b_offset);
  1042. unlock_page(page);
  1043. goto out;
  1044. }
  1045. /*
  1046. * We either searching data but nothing was found, or
  1047. * searching hole but found a data buffer. In either
  1048. * case, probably the next page contains the desired
  1049. * things, update the last offset to it so.
  1050. */
  1051. lastoff = page_offset(page) + PAGE_SIZE;
  1052. unlock_page(page);
  1053. }
  1054. /*
  1055. * The number of returned pages less than our desired, search
  1056. * done. In this case, nothing was found for searching data,
  1057. * but we found a hole behind the last offset.
  1058. */
  1059. if (nr_pages < want) {
  1060. if (type == HOLE_OFF) {
  1061. *offset = lastoff;
  1062. found = true;
  1063. }
  1064. break;
  1065. }
  1066. index = pvec.pages[i - 1]->index + 1;
  1067. pagevec_release(&pvec);
  1068. } while (index <= end);
  1069. out:
  1070. pagevec_release(&pvec);
  1071. return found;
  1072. }
  1073. STATIC loff_t
  1074. xfs_seek_hole_data(
  1075. struct file *file,
  1076. loff_t start,
  1077. int whence)
  1078. {
  1079. struct inode *inode = file->f_mapping->host;
  1080. struct xfs_inode *ip = XFS_I(inode);
  1081. struct xfs_mount *mp = ip->i_mount;
  1082. loff_t uninitialized_var(offset);
  1083. xfs_fsize_t isize;
  1084. xfs_fileoff_t fsbno;
  1085. xfs_filblks_t end;
  1086. uint lock;
  1087. int error;
  1088. if (XFS_FORCED_SHUTDOWN(mp))
  1089. return -EIO;
  1090. lock = xfs_ilock_data_map_shared(ip);
  1091. isize = i_size_read(inode);
  1092. if (start >= isize) {
  1093. error = -ENXIO;
  1094. goto out_unlock;
  1095. }
  1096. /*
  1097. * Try to read extents from the first block indicated
  1098. * by fsbno to the end block of the file.
  1099. */
  1100. fsbno = XFS_B_TO_FSBT(mp, start);
  1101. end = XFS_B_TO_FSB(mp, isize);
  1102. for (;;) {
  1103. struct xfs_bmbt_irec map[2];
  1104. int nmap = 2;
  1105. unsigned int i;
  1106. error = xfs_bmapi_read(ip, fsbno, end - fsbno, map, &nmap,
  1107. XFS_BMAPI_ENTIRE);
  1108. if (error)
  1109. goto out_unlock;
  1110. /* No extents at given offset, must be beyond EOF */
  1111. if (nmap == 0) {
  1112. error = -ENXIO;
  1113. goto out_unlock;
  1114. }
  1115. for (i = 0; i < nmap; i++) {
  1116. offset = max_t(loff_t, start,
  1117. XFS_FSB_TO_B(mp, map[i].br_startoff));
  1118. /* Landed in the hole we wanted? */
  1119. if (whence == SEEK_HOLE &&
  1120. map[i].br_startblock == HOLESTARTBLOCK)
  1121. goto out;
  1122. /* Landed in the data extent we wanted? */
  1123. if (whence == SEEK_DATA &&
  1124. (map[i].br_startblock == DELAYSTARTBLOCK ||
  1125. (map[i].br_state == XFS_EXT_NORM &&
  1126. !isnullstartblock(map[i].br_startblock))))
  1127. goto out;
  1128. /*
  1129. * Landed in an unwritten extent, try to search
  1130. * for hole or data from page cache.
  1131. */
  1132. if (map[i].br_state == XFS_EXT_UNWRITTEN) {
  1133. if (xfs_find_get_desired_pgoff(inode, &map[i],
  1134. whence == SEEK_HOLE ? HOLE_OFF : DATA_OFF,
  1135. &offset))
  1136. goto out;
  1137. }
  1138. }
  1139. /*
  1140. * We only received one extent out of the two requested. This
  1141. * means we've hit EOF and didn't find what we are looking for.
  1142. */
  1143. if (nmap == 1) {
  1144. /*
  1145. * If we were looking for a hole, set offset to
  1146. * the end of the file (i.e., there is an implicit
  1147. * hole at the end of any file).
  1148. */
  1149. if (whence == SEEK_HOLE) {
  1150. offset = isize;
  1151. break;
  1152. }
  1153. /*
  1154. * If we were looking for data, it's nowhere to be found
  1155. */
  1156. ASSERT(whence == SEEK_DATA);
  1157. error = -ENXIO;
  1158. goto out_unlock;
  1159. }
  1160. ASSERT(i > 1);
  1161. /*
  1162. * Nothing was found, proceed to the next round of search
  1163. * if the next reading offset is not at or beyond EOF.
  1164. */
  1165. fsbno = map[i - 1].br_startoff + map[i - 1].br_blockcount;
  1166. start = XFS_FSB_TO_B(mp, fsbno);
  1167. if (start >= isize) {
  1168. if (whence == SEEK_HOLE) {
  1169. offset = isize;
  1170. break;
  1171. }
  1172. ASSERT(whence == SEEK_DATA);
  1173. error = -ENXIO;
  1174. goto out_unlock;
  1175. }
  1176. }
  1177. out:
  1178. /*
  1179. * If at this point we have found the hole we wanted, the returned
  1180. * offset may be bigger than the file size as it may be aligned to
  1181. * page boundary for unwritten extents. We need to deal with this
  1182. * situation in particular.
  1183. */
  1184. if (whence == SEEK_HOLE)
  1185. offset = min_t(loff_t, offset, isize);
  1186. offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
  1187. out_unlock:
  1188. xfs_iunlock(ip, lock);
  1189. if (error)
  1190. return error;
  1191. return offset;
  1192. }
  1193. STATIC loff_t
  1194. xfs_file_llseek(
  1195. struct file *file,
  1196. loff_t offset,
  1197. int whence)
  1198. {
  1199. switch (whence) {
  1200. case SEEK_END:
  1201. case SEEK_CUR:
  1202. case SEEK_SET:
  1203. return generic_file_llseek(file, offset, whence);
  1204. case SEEK_HOLE:
  1205. case SEEK_DATA:
  1206. return xfs_seek_hole_data(file, offset, whence);
  1207. default:
  1208. return -EINVAL;
  1209. }
  1210. }
  1211. const struct file_operations xfs_file_operations = {
  1212. .llseek = xfs_file_llseek,
  1213. .read = new_sync_read,
  1214. .write = new_sync_write,
  1215. .read_iter = xfs_file_read_iter,
  1216. .write_iter = xfs_file_write_iter,
  1217. .splice_read = xfs_file_splice_read,
  1218. .splice_write = iter_file_splice_write,
  1219. .unlocked_ioctl = xfs_file_ioctl,
  1220. #ifdef CONFIG_COMPAT
  1221. .compat_ioctl = xfs_file_compat_ioctl,
  1222. #endif
  1223. .mmap = xfs_file_mmap,
  1224. .open = xfs_file_open,
  1225. .release = xfs_file_release,
  1226. .fsync = xfs_file_fsync,
  1227. .fallocate = xfs_file_fallocate,
  1228. };
  1229. const struct file_operations xfs_dir_file_operations = {
  1230. .open = xfs_dir_open,
  1231. .read = generic_read_dir,
  1232. .iterate = xfs_file_readdir,
  1233. .llseek = generic_file_llseek,
  1234. .unlocked_ioctl = xfs_file_ioctl,
  1235. #ifdef CONFIG_COMPAT
  1236. .compat_ioctl = xfs_file_compat_ioctl,
  1237. #endif
  1238. .fsync = xfs_dir_fsync,
  1239. };
  1240. static const struct vm_operations_struct xfs_file_vm_ops = {
  1241. .fault = filemap_fault,
  1242. .map_pages = filemap_map_pages,
  1243. .page_mkwrite = xfs_vm_page_mkwrite,
  1244. };