blob: eb596b4199420fa8378dcd49146640c9783037b4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Christoph Hellwigdda35b82010-02-15 09:44:46 +000019#include "xfs_fs.h"
Dave Chinner70a9883c2013-10-23 10:36:05 +110020#include "xfs_shared.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110021#include "xfs_format.h"
Dave Chinner239880e2013-10-23 10:50:10 +110022#include "xfs_log_format.h"
23#include "xfs_trans_resv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_sb.h"
Nathan Scotta844f452005-11-02 14:38:42 +110025#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_mount.h"
Dave Chinner57062782013-10-15 09:17:51 +110027#include "xfs_da_format.h"
28#include "xfs_da_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_inode.h"
Dave Chinner239880e2013-10-23 10:50:10 +110030#include "xfs_trans.h"
Christoph Hellwigfd3200b2010-02-15 09:44:48 +000031#include "xfs_inode_item.h"
Christoph Hellwigdda35b82010-02-15 09:44:46 +000032#include "xfs_bmap.h"
Dave Chinnerc24b5df2013-08-12 20:49:45 +100033#include "xfs_bmap_util.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_error.h"
Dave Chinner2b9ab5a2013-08-12 20:49:37 +100035#include "xfs_dir2.h"
Dave Chinnerc24b5df2013-08-12 20:49:45 +100036#include "xfs_dir2_priv.h"
Christoph Hellwigddcd8562008-12-03 07:55:34 -050037#include "xfs_ioctl.h"
Christoph Hellwigdda35b82010-02-15 09:44:46 +000038#include "xfs_trace.h"
Dave Chinner239880e2013-10-23 10:50:10 +110039#include "xfs_log.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110040#include "xfs_dinode.h"
Brian Fosterdc06f3982014-07-24 19:49:28 +100041#include "xfs_icache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Kent Overstreeta27bb332013-05-07 16:19:08 -070043#include <linux/aio.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/dcache.h>
Christoph Hellwig2fe17c12011-01-14 13:07:43 +010045#include <linux/falloc.h>
Jeff Liud126d432012-08-21 17:11:57 +080046#include <linux/pagevec.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +040048static const struct vm_operations_struct xfs_file_vm_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Christoph Hellwigdda35b82010-02-15 09:44:46 +000050/*
Dave Chinner487f84f2011-01-12 11:37:10 +110051 * Locking primitives for read and write IO paths to ensure we consistently use
52 * and order the inode->i_mutex, ip->i_lock and ip->i_iolock.
53 */
54static inline void
55xfs_rw_ilock(
56 struct xfs_inode *ip,
57 int type)
58{
59 if (type & XFS_IOLOCK_EXCL)
60 mutex_lock(&VFS_I(ip)->i_mutex);
61 xfs_ilock(ip, type);
62}
63
64static inline void
65xfs_rw_iunlock(
66 struct xfs_inode *ip,
67 int type)
68{
69 xfs_iunlock(ip, type);
70 if (type & XFS_IOLOCK_EXCL)
71 mutex_unlock(&VFS_I(ip)->i_mutex);
72}
73
74static inline void
75xfs_rw_ilock_demote(
76 struct xfs_inode *ip,
77 int type)
78{
79 xfs_ilock_demote(ip, type);
80 if (type & XFS_IOLOCK_EXCL)
81 mutex_unlock(&VFS_I(ip)->i_mutex);
82}
83
84/*
Christoph Hellwigdda35b82010-02-15 09:44:46 +000085 * xfs_iozero
86 *
87 * xfs_iozero clears the specified range of buffer supplied,
88 * and marks all the affected blocks as valid and modified. If
89 * an affected block is not allocated, it will be allocated. If
90 * an affected block is not completely overwritten, and is not
91 * valid before the operation, it will be read from disk before
92 * being partially zeroed.
93 */
Dave Chinneref9d8732012-11-29 15:26:33 +110094int
Christoph Hellwigdda35b82010-02-15 09:44:46 +000095xfs_iozero(
96 struct xfs_inode *ip, /* inode */
97 loff_t pos, /* offset in file */
98 size_t count) /* size of data to zero */
99{
100 struct page *page;
101 struct address_space *mapping;
102 int status;
103
104 mapping = VFS_I(ip)->i_mapping;
105 do {
106 unsigned offset, bytes;
107 void *fsdata;
108
109 offset = (pos & (PAGE_CACHE_SIZE -1)); /* Within page */
110 bytes = PAGE_CACHE_SIZE - offset;
111 if (bytes > count)
112 bytes = count;
113
114 status = pagecache_write_begin(NULL, mapping, pos, bytes,
115 AOP_FLAG_UNINTERRUPTIBLE,
116 &page, &fsdata);
117 if (status)
118 break;
119
120 zero_user(page, offset, bytes);
121
122 status = pagecache_write_end(NULL, mapping, pos, bytes, bytes,
123 page, fsdata);
124 WARN_ON(status <= 0); /* can't return less than zero! */
125 pos += bytes;
126 count -= bytes;
127 status = 0;
128 } while (count);
129
130 return (-status);
131}
132
Christoph Hellwig1da2f2d2011-10-02 14:25:16 +0000133/*
134 * Fsync operations on directories are much simpler than on regular files,
135 * as there is no file data to flush, and thus also no need for explicit
136 * cache flush operations, and there are no non-transaction metadata updates
137 * on directories either.
138 */
139STATIC int
140xfs_dir_fsync(
141 struct file *file,
142 loff_t start,
143 loff_t end,
144 int datasync)
145{
146 struct xfs_inode *ip = XFS_I(file->f_mapping->host);
147 struct xfs_mount *mp = ip->i_mount;
148 xfs_lsn_t lsn = 0;
149
150 trace_xfs_dir_fsync(ip);
151
152 xfs_ilock(ip, XFS_ILOCK_SHARED);
153 if (xfs_ipincount(ip))
154 lsn = ip->i_itemp->ili_last_lsn;
155 xfs_iunlock(ip, XFS_ILOCK_SHARED);
156
157 if (!lsn)
158 return 0;
Dave Chinner24513372014-06-25 14:58:08 +1000159 return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
Christoph Hellwig1da2f2d2011-10-02 14:25:16 +0000160}
161
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000162STATIC int
163xfs_file_fsync(
164 struct file *file,
Josef Bacik02c24a82011-07-16 20:44:56 -0400165 loff_t start,
166 loff_t end,
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000167 int datasync)
168{
Christoph Hellwig7ea80852010-05-26 17:53:25 +0200169 struct inode *inode = file->f_mapping->host;
170 struct xfs_inode *ip = XFS_I(inode);
Christoph Hellwiga27a2632011-06-16 12:02:23 +0000171 struct xfs_mount *mp = ip->i_mount;
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000172 int error = 0;
173 int log_flushed = 0;
Christoph Hellwigb1037052011-09-19 14:55:51 +0000174 xfs_lsn_t lsn = 0;
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000175
Christoph Hellwigcca28fb2010-06-24 11:57:09 +1000176 trace_xfs_file_fsync(ip);
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000177
Josef Bacik02c24a82011-07-16 20:44:56 -0400178 error = filemap_write_and_wait_range(inode->i_mapping, start, end);
179 if (error)
180 return error;
181
Christoph Hellwiga27a2632011-06-16 12:02:23 +0000182 if (XFS_FORCED_SHUTDOWN(mp))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000183 return -EIO;
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000184
185 xfs_iflags_clear(ip, XFS_ITRUNCATED);
186
Christoph Hellwiga27a2632011-06-16 12:02:23 +0000187 if (mp->m_flags & XFS_MOUNT_BARRIER) {
188 /*
189 * If we have an RT and/or log subvolume we need to make sure
190 * to flush the write cache the device used for file data
191 * first. This is to ensure newly written file data make
192 * it to disk before logging the new inode size in case of
193 * an extending write.
194 */
195 if (XFS_IS_REALTIME_INODE(ip))
196 xfs_blkdev_issue_flush(mp->m_rtdev_targp);
197 else if (mp->m_logdev_targp != mp->m_ddev_targp)
198 xfs_blkdev_issue_flush(mp->m_ddev_targp);
199 }
200
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000201 /*
Christoph Hellwig8a9c9982012-02-29 09:53:52 +0000202 * All metadata updates are logged, which means that we just have
203 * to flush the log up to the latest LSN that touched the inode.
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000204 */
205 xfs_ilock(ip, XFS_ILOCK_SHARED);
Christoph Hellwig8f639dd2012-02-29 09:53:55 +0000206 if (xfs_ipincount(ip)) {
207 if (!datasync ||
208 (ip->i_itemp->ili_fields & ~XFS_ILOG_TIMESTAMP))
209 lsn = ip->i_itemp->ili_last_lsn;
210 }
Christoph Hellwig8a9c9982012-02-29 09:53:52 +0000211 xfs_iunlock(ip, XFS_ILOCK_SHARED);
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000212
Christoph Hellwig8a9c9982012-02-29 09:53:52 +0000213 if (lsn)
Christoph Hellwigb1037052011-09-19 14:55:51 +0000214 error = _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, &log_flushed);
215
Christoph Hellwiga27a2632011-06-16 12:02:23 +0000216 /*
217 * If we only have a single device, and the log force about was
218 * a no-op we might have to flush the data device cache here.
219 * This can only happen for fdatasync/O_DSYNC if we were overwriting
220 * an already allocated file and thus do not have any metadata to
221 * commit.
222 */
223 if ((mp->m_flags & XFS_MOUNT_BARRIER) &&
224 mp->m_logdev_targp == mp->m_ddev_targp &&
225 !XFS_IS_REALTIME_INODE(ip) &&
226 !log_flushed)
227 xfs_blkdev_issue_flush(mp->m_ddev_targp);
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000228
Dave Chinner24513372014-06-25 14:58:08 +1000229 return error;
Christoph Hellwigfd3200b2010-02-15 09:44:48 +0000230}
231
Christoph Hellwig00258e32010-02-15 09:44:47 +0000232STATIC ssize_t
Al Virob4f5d2c2014-04-02 14:37:59 -0400233xfs_file_read_iter(
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000234 struct kiocb *iocb,
Al Virob4f5d2c2014-04-02 14:37:59 -0400235 struct iov_iter *to)
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000236{
237 struct file *file = iocb->ki_filp;
238 struct inode *inode = file->f_mapping->host;
Christoph Hellwig00258e32010-02-15 09:44:47 +0000239 struct xfs_inode *ip = XFS_I(inode);
240 struct xfs_mount *mp = ip->i_mount;
Al Virob4f5d2c2014-04-02 14:37:59 -0400241 size_t size = iov_iter_count(to);
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000242 ssize_t ret = 0;
Christoph Hellwig00258e32010-02-15 09:44:47 +0000243 int ioflags = 0;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000244 xfs_fsize_t n;
Al Virob4f5d2c2014-04-02 14:37:59 -0400245 loff_t pos = iocb->ki_pos;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000246
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000247 XFS_STATS_INC(xs_read_calls);
248
Christoph Hellwig00258e32010-02-15 09:44:47 +0000249 if (unlikely(file->f_flags & O_DIRECT))
Dave Chinnerb92cc59f62014-08-04 13:28:20 +1000250 ioflags |= XFS_IO_ISDIRECT;
Christoph Hellwig00258e32010-02-15 09:44:47 +0000251 if (file->f_mode & FMODE_NOCMTIME)
Dave Chinnerb92cc59f62014-08-04 13:28:20 +1000252 ioflags |= XFS_IO_INVIS;
Christoph Hellwig00258e32010-02-15 09:44:47 +0000253
Dave Chinnerb92cc59f62014-08-04 13:28:20 +1000254 if (unlikely(ioflags & XFS_IO_ISDIRECT)) {
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000255 xfs_buftarg_t *target =
256 XFS_IS_REALTIME_INODE(ip) ?
257 mp->m_rtdev_targp : mp->m_ddev_targp;
Eric Sandeen7c71ee72014-01-21 16:46:23 -0600258 /* DIO must be aligned to device logical sector size */
259 if ((pos | size) & target->bt_logical_sectormask) {
Dave Chinnerfb595812012-11-12 22:53:57 +1100260 if (pos == i_size_read(inode))
Christoph Hellwig00258e32010-02-15 09:44:47 +0000261 return 0;
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000262 return -EINVAL;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000263 }
264 }
265
Dave Chinnerfb595812012-11-12 22:53:57 +1100266 n = mp->m_super->s_maxbytes - pos;
Christoph Hellwig00258e32010-02-15 09:44:47 +0000267 if (n <= 0 || size == 0)
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000268 return 0;
269
270 if (n < size)
271 size = n;
272
273 if (XFS_FORCED_SHUTDOWN(mp))
274 return -EIO;
275
Dave Chinner0c38a252011-08-25 07:17:01 +0000276 /*
277 * Locking is a bit tricky here. If we take an exclusive lock
278 * for direct IO, we effectively serialise all new concurrent
279 * read IO to this file and block it behind IO that is currently in
280 * progress because IO in progress holds the IO lock shared. We only
281 * need to hold the lock exclusive to blow away the page cache, so
282 * only take lock exclusively if the page cache needs invalidation.
283 * This allows the normal direct IO case of no page cache pages to
284 * proceeed concurrently without serialisation.
285 */
286 xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
Dave Chinnerb92cc59f62014-08-04 13:28:20 +1000287 if ((ioflags & XFS_IO_ISDIRECT) && inode->i_mapping->nrpages) {
Dave Chinner0c38a252011-08-25 07:17:01 +0000288 xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
Dave Chinner487f84f2011-01-12 11:37:10 +1100289 xfs_rw_ilock(ip, XFS_IOLOCK_EXCL);
290
Christoph Hellwig00258e32010-02-15 09:44:47 +0000291 if (inode->i_mapping->nrpages) {
Dave Chinner8ff1e672014-05-15 09:21:37 +1000292 ret = filemap_write_and_wait_range(
Dave Chinnerfb595812012-11-12 22:53:57 +1100293 VFS_I(ip)->i_mapping,
Dave Chinner7d4ea3c2014-09-02 12:12:53 +1000294 pos, pos + size - 1);
Dave Chinner487f84f2011-01-12 11:37:10 +1100295 if (ret) {
296 xfs_rw_iunlock(ip, XFS_IOLOCK_EXCL);
297 return ret;
298 }
Chris Mason85e584d2014-09-02 12:12:52 +1000299
300 /*
301 * Invalidate whole pages. This can return an error if
302 * we fail to invalidate a page, but this should never
303 * happen on XFS. Warn if it does fail.
304 */
305 ret = invalidate_inode_pages2_range(VFS_I(ip)->i_mapping,
Dave Chinner7d4ea3c2014-09-02 12:12:53 +1000306 pos >> PAGE_CACHE_SHIFT,
307 (pos + size - 1) >> PAGE_CACHE_SHIFT);
Chris Mason85e584d2014-09-02 12:12:52 +1000308 WARN_ON_ONCE(ret);
309 ret = 0;
Christoph Hellwig00258e32010-02-15 09:44:47 +0000310 }
Dave Chinner487f84f2011-01-12 11:37:10 +1100311 xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL);
Dave Chinner0c38a252011-08-25 07:17:01 +0000312 }
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000313
Dave Chinnerfb595812012-11-12 22:53:57 +1100314 trace_xfs_file_read(ip, size, pos, ioflags);
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000315
Al Virob4f5d2c2014-04-02 14:37:59 -0400316 ret = generic_file_read_iter(iocb, to);
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000317 if (ret > 0)
318 XFS_STATS_ADD(xs_read_bytes, ret);
319
Dave Chinner487f84f2011-01-12 11:37:10 +1100320 xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000321 return ret;
322}
323
Christoph Hellwig00258e32010-02-15 09:44:47 +0000324STATIC ssize_t
325xfs_file_splice_read(
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000326 struct file *infilp,
327 loff_t *ppos,
328 struct pipe_inode_info *pipe,
329 size_t count,
Christoph Hellwig00258e32010-02-15 09:44:47 +0000330 unsigned int flags)
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000331{
Christoph Hellwig00258e32010-02-15 09:44:47 +0000332 struct xfs_inode *ip = XFS_I(infilp->f_mapping->host);
Christoph Hellwig00258e32010-02-15 09:44:47 +0000333 int ioflags = 0;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000334 ssize_t ret;
335
336 XFS_STATS_INC(xs_read_calls);
Christoph Hellwig00258e32010-02-15 09:44:47 +0000337
338 if (infilp->f_mode & FMODE_NOCMTIME)
Dave Chinnerb92cc59f62014-08-04 13:28:20 +1000339 ioflags |= XFS_IO_INVIS;
Christoph Hellwig00258e32010-02-15 09:44:47 +0000340
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000341 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
342 return -EIO;
343
Dave Chinner487f84f2011-01-12 11:37:10 +1100344 xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000345
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000346 trace_xfs_file_splice_read(ip, count, *ppos, ioflags);
347
348 ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
349 if (ret > 0)
350 XFS_STATS_ADD(xs_read_bytes, ret);
351
Dave Chinner487f84f2011-01-12 11:37:10 +1100352 xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000353 return ret;
354}
355
Dave Chinner4c5cfd12011-01-11 10:14:16 +1100356/*
Christoph Hellwig193aec12012-03-27 10:34:49 -0400357 * This routine is called to handle zeroing any space in the last block of the
358 * file that is beyond the EOF. We do this since the size is being increased
359 * without writing anything to that block and we don't want to read the
360 * garbage on the disk.
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000361 */
362STATIC int /* error (positive) */
363xfs_zero_last_block(
Christoph Hellwig193aec12012-03-27 10:34:49 -0400364 struct xfs_inode *ip,
365 xfs_fsize_t offset,
366 xfs_fsize_t isize)
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000367{
Christoph Hellwig193aec12012-03-27 10:34:49 -0400368 struct xfs_mount *mp = ip->i_mount;
369 xfs_fileoff_t last_fsb = XFS_B_TO_FSBT(mp, isize);
370 int zero_offset = XFS_B_FSB_OFFSET(mp, isize);
371 int zero_len;
372 int nimaps = 1;
373 int error = 0;
374 struct xfs_bmbt_irec imap;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000375
Christoph Hellwig193aec12012-03-27 10:34:49 -0400376 xfs_ilock(ip, XFS_ILOCK_EXCL);
Dave Chinner5c8ed202011-09-18 20:40:45 +0000377 error = xfs_bmapi_read(ip, last_fsb, 1, &imap, &nimaps, 0);
Christoph Hellwig193aec12012-03-27 10:34:49 -0400378 xfs_iunlock(ip, XFS_ILOCK_EXCL);
Dave Chinner5c8ed202011-09-18 20:40:45 +0000379 if (error)
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000380 return error;
Christoph Hellwig193aec12012-03-27 10:34:49 -0400381
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000382 ASSERT(nimaps > 0);
Christoph Hellwig193aec12012-03-27 10:34:49 -0400383
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000384 /*
385 * If the block underlying isize is just a hole, then there
386 * is nothing to zero.
387 */
Christoph Hellwig193aec12012-03-27 10:34:49 -0400388 if (imap.br_startblock == HOLESTARTBLOCK)
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000389 return 0;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000390
391 zero_len = mp->m_sb.sb_blocksize - zero_offset;
392 if (isize + zero_len > offset)
393 zero_len = offset - isize;
Christoph Hellwig193aec12012-03-27 10:34:49 -0400394 return xfs_iozero(ip, isize, zero_len);
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000395}
396
397/*
Christoph Hellwig193aec12012-03-27 10:34:49 -0400398 * Zero any on disk space between the current EOF and the new, larger EOF.
399 *
400 * This handles the normal case of zeroing the remainder of the last block in
401 * the file and the unusual case of zeroing blocks out beyond the size of the
402 * file. This second case only happens with fixed size extents and when the
403 * system crashes before the inode size was updated but after blocks were
404 * allocated.
405 *
406 * Expects the iolock to be held exclusive, and will take the ilock internally.
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000407 */
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000408int /* error (positive) */
409xfs_zero_eof(
Christoph Hellwig193aec12012-03-27 10:34:49 -0400410 struct xfs_inode *ip,
411 xfs_off_t offset, /* starting I/O offset */
412 xfs_fsize_t isize) /* current inode size */
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000413{
Christoph Hellwig193aec12012-03-27 10:34:49 -0400414 struct xfs_mount *mp = ip->i_mount;
415 xfs_fileoff_t start_zero_fsb;
416 xfs_fileoff_t end_zero_fsb;
417 xfs_fileoff_t zero_count_fsb;
418 xfs_fileoff_t last_fsb;
419 xfs_fileoff_t zero_off;
420 xfs_fsize_t zero_len;
421 int nimaps;
422 int error = 0;
423 struct xfs_bmbt_irec imap;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000424
Christoph Hellwig193aec12012-03-27 10:34:49 -0400425 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000426 ASSERT(offset > isize);
427
428 /*
429 * First handle zeroing the block on which isize resides.
Christoph Hellwig193aec12012-03-27 10:34:49 -0400430 *
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000431 * We only zero a part of that block so it is handled specially.
432 */
Christoph Hellwig193aec12012-03-27 10:34:49 -0400433 if (XFS_B_FSB_OFFSET(mp, isize) != 0) {
434 error = xfs_zero_last_block(ip, offset, isize);
435 if (error)
436 return error;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000437 }
438
439 /*
Christoph Hellwig193aec12012-03-27 10:34:49 -0400440 * Calculate the range between the new size and the old where blocks
441 * needing to be zeroed may exist.
442 *
443 * To get the block where the last byte in the file currently resides,
444 * we need to subtract one from the size and truncate back to a block
445 * boundary. We subtract 1 in case the size is exactly on a block
446 * boundary.
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000447 */
448 last_fsb = isize ? XFS_B_TO_FSBT(mp, isize - 1) : (xfs_fileoff_t)-1;
449 start_zero_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)isize);
450 end_zero_fsb = XFS_B_TO_FSBT(mp, offset - 1);
451 ASSERT((xfs_sfiloff_t)last_fsb < (xfs_sfiloff_t)start_zero_fsb);
452 if (last_fsb == end_zero_fsb) {
453 /*
454 * The size was only incremented on its last block.
455 * We took care of that above, so just return.
456 */
457 return 0;
458 }
459
460 ASSERT(start_zero_fsb <= end_zero_fsb);
461 while (start_zero_fsb <= end_zero_fsb) {
462 nimaps = 1;
463 zero_count_fsb = end_zero_fsb - start_zero_fsb + 1;
Christoph Hellwig193aec12012-03-27 10:34:49 -0400464
465 xfs_ilock(ip, XFS_ILOCK_EXCL);
Dave Chinner5c8ed202011-09-18 20:40:45 +0000466 error = xfs_bmapi_read(ip, start_zero_fsb, zero_count_fsb,
467 &imap, &nimaps, 0);
Christoph Hellwig193aec12012-03-27 10:34:49 -0400468 xfs_iunlock(ip, XFS_ILOCK_EXCL);
469 if (error)
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000470 return error;
Christoph Hellwig193aec12012-03-27 10:34:49 -0400471
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000472 ASSERT(nimaps > 0);
473
474 if (imap.br_state == XFS_EXT_UNWRITTEN ||
475 imap.br_startblock == HOLESTARTBLOCK) {
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000476 start_zero_fsb = imap.br_startoff + imap.br_blockcount;
477 ASSERT(start_zero_fsb <= (end_zero_fsb + 1));
478 continue;
479 }
480
481 /*
482 * There are blocks we need to zero.
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000483 */
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000484 zero_off = XFS_FSB_TO_B(mp, start_zero_fsb);
485 zero_len = XFS_FSB_TO_B(mp, imap.br_blockcount);
486
487 if ((zero_off + zero_len) > offset)
488 zero_len = offset - zero_off;
489
490 error = xfs_iozero(ip, zero_off, zero_len);
Christoph Hellwig193aec12012-03-27 10:34:49 -0400491 if (error)
492 return error;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000493
494 start_zero_fsb = imap.br_startoff + imap.br_blockcount;
495 ASSERT(start_zero_fsb <= (end_zero_fsb + 1));
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000496 }
497
498 return 0;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000499}
500
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100501/*
Dave Chinner4d8d1582011-01-11 10:23:42 +1100502 * Common pre-write limit and setup checks.
503 *
Christoph Hellwig5bf1f262011-12-18 20:00:13 +0000504 * Called with the iolocked held either shared and exclusive according to
505 * @iolock, and returns with it held. Might upgrade the iolock to exclusive
506 * if called for a direct write beyond i_size.
Dave Chinner4d8d1582011-01-11 10:23:42 +1100507 */
508STATIC ssize_t
509xfs_file_aio_write_checks(
510 struct file *file,
511 loff_t *pos,
512 size_t *count,
513 int *iolock)
514{
515 struct inode *inode = file->f_mapping->host;
516 struct xfs_inode *ip = XFS_I(inode);
Dave Chinner4d8d1582011-01-11 10:23:42 +1100517 int error = 0;
518
Dave Chinner7271d242011-08-25 07:17:02 +0000519restart:
Dave Chinner4d8d1582011-01-11 10:23:42 +1100520 error = generic_write_checks(file, pos, count, S_ISBLK(inode->i_mode));
Christoph Hellwig467f7892012-03-27 10:34:47 -0400521 if (error)
Dave Chinner4d8d1582011-01-11 10:23:42 +1100522 return error;
Dave Chinner4d8d1582011-01-11 10:23:42 +1100523
Dave Chinner4d8d1582011-01-11 10:23:42 +1100524 /*
525 * If the offset is beyond the size of the file, we need to zero any
526 * blocks that fall between the existing EOF and the start of this
Christoph Hellwig2813d682011-12-18 20:00:12 +0000527 * write. If zeroing is needed and we are currently holding the
Christoph Hellwig467f7892012-03-27 10:34:47 -0400528 * iolock shared, we need to update it to exclusive which implies
529 * having to redo all checks before.
Dave Chinner4d8d1582011-01-11 10:23:42 +1100530 */
Christoph Hellwig2813d682011-12-18 20:00:12 +0000531 if (*pos > i_size_read(inode)) {
Dave Chinner7271d242011-08-25 07:17:02 +0000532 if (*iolock == XFS_IOLOCK_SHARED) {
Christoph Hellwig467f7892012-03-27 10:34:47 -0400533 xfs_rw_iunlock(ip, *iolock);
Dave Chinner7271d242011-08-25 07:17:02 +0000534 *iolock = XFS_IOLOCK_EXCL;
Christoph Hellwig467f7892012-03-27 10:34:47 -0400535 xfs_rw_ilock(ip, *iolock);
Dave Chinner7271d242011-08-25 07:17:02 +0000536 goto restart;
537 }
Dave Chinner24513372014-06-25 14:58:08 +1000538 error = xfs_zero_eof(ip, *pos, i_size_read(inode));
Christoph Hellwig467f7892012-03-27 10:34:47 -0400539 if (error)
540 return error;
Dave Chinner7271d242011-08-25 07:17:02 +0000541 }
Dave Chinner4d8d1582011-01-11 10:23:42 +1100542
543 /*
Christoph Hellwig8a9c9982012-02-29 09:53:52 +0000544 * Updating the timestamps will grab the ilock again from
545 * xfs_fs_dirty_inode, so we have to call it after dropping the
546 * lock above. Eventually we should look into a way to avoid
547 * the pointless lock roundtrip.
548 */
Josef Bacikc3b2da32012-03-26 09:59:21 -0400549 if (likely(!(file->f_mode & FMODE_NOCMTIME))) {
550 error = file_update_time(file);
551 if (error)
552 return error;
553 }
Christoph Hellwig8a9c9982012-02-29 09:53:52 +0000554
555 /*
Dave Chinner4d8d1582011-01-11 10:23:42 +1100556 * If we're writing the file then make sure to clear the setuid and
557 * setgid bits if the process is not being run by root. This keeps
558 * people from modifying setuid and setgid binaries.
559 */
560 return file_remove_suid(file);
Dave Chinner4d8d1582011-01-11 10:23:42 +1100561}
562
563/*
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100564 * xfs_file_dio_aio_write - handle direct IO writes
565 *
566 * Lock the inode appropriately to prepare for and issue a direct IO write.
Dave Chinnereda77982011-01-11 10:22:40 +1100567 * By separating it from the buffered write path we remove all the tricky to
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100568 * follow locking changes and looping.
569 *
Dave Chinnereda77982011-01-11 10:22:40 +1100570 * If there are cached pages or we're extending the file, we need IOLOCK_EXCL
571 * until we're sure the bytes at the new EOF have been zeroed and/or the cached
572 * pages are flushed out.
573 *
574 * In most cases the direct IO writes will be done holding IOLOCK_SHARED
575 * allowing them to be done in parallel with reads and other direct IO writes.
576 * However, if the IO is not aligned to filesystem blocks, the direct IO layer
577 * needs to do sub-block zeroing and that requires serialisation against other
578 * direct IOs to the same block. In this case we need to serialise the
579 * submission of the unaligned IOs so that we don't get racing block zeroing in
580 * the dio layer. To avoid the problem with aio, we also need to wait for
581 * outstanding IOs to complete so that unwritten extent conversion is completed
582 * before we try to map the overlapping block. This is currently implemented by
Christoph Hellwig4a06fd22011-08-23 08:28:13 +0000583 * hitting it with a big hammer (i.e. inode_dio_wait()).
Dave Chinnereda77982011-01-11 10:22:40 +1100584 *
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100585 * Returns with locks held indicated by @iolock and errors indicated by
586 * negative return values.
587 */
588STATIC ssize_t
589xfs_file_dio_aio_write(
590 struct kiocb *iocb,
Al Virob3188912014-04-02 07:06:30 -0400591 struct iov_iter *from)
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100592{
593 struct file *file = iocb->ki_filp;
594 struct address_space *mapping = file->f_mapping;
595 struct inode *inode = mapping->host;
596 struct xfs_inode *ip = XFS_I(inode);
597 struct xfs_mount *mp = ip->i_mount;
598 ssize_t ret = 0;
Dave Chinnereda77982011-01-11 10:22:40 +1100599 int unaligned_io = 0;
Christoph Hellwigd0606462011-12-18 20:00:14 +0000600 int iolock;
Al Virob3188912014-04-02 07:06:30 -0400601 size_t count = iov_iter_count(from);
602 loff_t pos = iocb->ki_pos;
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100603 struct xfs_buftarg *target = XFS_IS_REALTIME_INODE(ip) ?
604 mp->m_rtdev_targp : mp->m_ddev_targp;
605
Eric Sandeen7c71ee72014-01-21 16:46:23 -0600606 /* DIO must be aligned to device logical sector size */
607 if ((pos | count) & target->bt_logical_sectormask)
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000608 return -EINVAL;
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100609
Eric Sandeen7c71ee72014-01-21 16:46:23 -0600610 /* "unaligned" here means not aligned to a filesystem block */
Dave Chinnereda77982011-01-11 10:22:40 +1100611 if ((pos & mp->m_blockmask) || ((pos + count) & mp->m_blockmask))
612 unaligned_io = 1;
613
Dave Chinner7271d242011-08-25 07:17:02 +0000614 /*
615 * We don't need to take an exclusive lock unless there page cache needs
616 * to be invalidated or unaligned IO is being executed. We don't need to
617 * consider the EOF extension case here because
618 * xfs_file_aio_write_checks() will relock the inode as necessary for
619 * EOF zeroing cases and fill out the new inode size as appropriate.
620 */
621 if (unaligned_io || mapping->nrpages)
Christoph Hellwigd0606462011-12-18 20:00:14 +0000622 iolock = XFS_IOLOCK_EXCL;
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100623 else
Christoph Hellwigd0606462011-12-18 20:00:14 +0000624 iolock = XFS_IOLOCK_SHARED;
625 xfs_rw_ilock(ip, iolock);
Christoph Hellwigc58cb162011-08-27 14:42:53 +0000626
627 /*
628 * Recheck if there are cached pages that need invalidate after we got
629 * the iolock to protect against other threads adding new pages while
630 * we were waiting for the iolock.
631 */
Christoph Hellwigd0606462011-12-18 20:00:14 +0000632 if (mapping->nrpages && iolock == XFS_IOLOCK_SHARED) {
633 xfs_rw_iunlock(ip, iolock);
634 iolock = XFS_IOLOCK_EXCL;
635 xfs_rw_ilock(ip, iolock);
Christoph Hellwigc58cb162011-08-27 14:42:53 +0000636 }
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100637
Christoph Hellwigd0606462011-12-18 20:00:14 +0000638 ret = xfs_file_aio_write_checks(file, &pos, &count, &iolock);
Dave Chinner4d8d1582011-01-11 10:23:42 +1100639 if (ret)
Christoph Hellwigd0606462011-12-18 20:00:14 +0000640 goto out;
Al Virob3188912014-04-02 07:06:30 -0400641 iov_iter_truncate(from, count);
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100642
643 if (mapping->nrpages) {
Dave Chinner07d50352014-04-17 08:15:27 +1000644 ret = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
Dave Chinner7d4ea3c2014-09-02 12:12:53 +1000645 pos, pos + count - 1);
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100646 if (ret)
Christoph Hellwigd0606462011-12-18 20:00:14 +0000647 goto out;
Dave Chinner834ffca2014-09-02 12:12:52 +1000648 /*
649 * Invalidate whole pages. This can return an error if
650 * we fail to invalidate a page, but this should never
651 * happen on XFS. Warn if it does fail.
652 */
653 ret = invalidate_inode_pages2_range(VFS_I(ip)->i_mapping,
Dave Chinner7d4ea3c2014-09-02 12:12:53 +1000654 pos >> PAGE_CACHE_SHIFT,
655 (pos + count - 1) >> PAGE_CACHE_SHIFT);
Dave Chinner834ffca2014-09-02 12:12:52 +1000656 WARN_ON_ONCE(ret);
657 ret = 0;
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100658 }
659
Dave Chinnereda77982011-01-11 10:22:40 +1100660 /*
661 * If we are doing unaligned IO, wait for all other IO to drain,
662 * otherwise demote the lock if we had to flush cached pages
663 */
664 if (unaligned_io)
Christoph Hellwig4a06fd22011-08-23 08:28:13 +0000665 inode_dio_wait(inode);
Christoph Hellwigd0606462011-12-18 20:00:14 +0000666 else if (iolock == XFS_IOLOCK_EXCL) {
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100667 xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL);
Christoph Hellwigd0606462011-12-18 20:00:14 +0000668 iolock = XFS_IOLOCK_SHARED;
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100669 }
670
671 trace_xfs_file_direct_write(ip, count, iocb->ki_pos, 0);
Al Virob3188912014-04-02 07:06:30 -0400672 ret = generic_file_direct_write(iocb, from, pos);
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100673
Christoph Hellwigd0606462011-12-18 20:00:14 +0000674out:
675 xfs_rw_iunlock(ip, iolock);
676
Dave Chinnerf0d26e82011-01-11 10:15:36 +1100677 /* No fallback to buffered IO on errors for XFS. */
678 ASSERT(ret < 0 || ret == count);
679 return ret;
680}
681
Christoph Hellwig00258e32010-02-15 09:44:47 +0000682STATIC ssize_t
Dave Chinner637bbc72011-01-11 10:17:30 +1100683xfs_file_buffered_aio_write(
684 struct kiocb *iocb,
Al Virob3188912014-04-02 07:06:30 -0400685 struct iov_iter *from)
Dave Chinner637bbc72011-01-11 10:17:30 +1100686{
687 struct file *file = iocb->ki_filp;
688 struct address_space *mapping = file->f_mapping;
689 struct inode *inode = mapping->host;
690 struct xfs_inode *ip = XFS_I(inode);
691 ssize_t ret;
692 int enospc = 0;
Christoph Hellwigd0606462011-12-18 20:00:14 +0000693 int iolock = XFS_IOLOCK_EXCL;
Al Virob3188912014-04-02 07:06:30 -0400694 loff_t pos = iocb->ki_pos;
695 size_t count = iov_iter_count(from);
Dave Chinner637bbc72011-01-11 10:17:30 +1100696
Christoph Hellwigd0606462011-12-18 20:00:14 +0000697 xfs_rw_ilock(ip, iolock);
Dave Chinner637bbc72011-01-11 10:17:30 +1100698
Christoph Hellwigd0606462011-12-18 20:00:14 +0000699 ret = xfs_file_aio_write_checks(file, &pos, &count, &iolock);
Dave Chinner4d8d1582011-01-11 10:23:42 +1100700 if (ret)
Christoph Hellwigd0606462011-12-18 20:00:14 +0000701 goto out;
Dave Chinner637bbc72011-01-11 10:17:30 +1100702
Al Virob3188912014-04-02 07:06:30 -0400703 iov_iter_truncate(from, count);
Dave Chinner637bbc72011-01-11 10:17:30 +1100704 /* We can write back this queue in page reclaim */
705 current->backing_dev_info = mapping->backing_dev_info;
706
707write_retry:
708 trace_xfs_file_buffered_write(ip, count, iocb->ki_pos, 0);
Al Virob3188912014-04-02 07:06:30 -0400709 ret = generic_perform_write(file, from, pos);
Al Viro0a64bc22014-02-11 22:25:22 -0500710 if (likely(ret >= 0))
711 iocb->ki_pos = pos + ret;
Brian Fosterdc06f3982014-07-24 19:49:28 +1000712
Dave Chinner637bbc72011-01-11 10:17:30 +1100713 /*
Brian Fosterdc06f3982014-07-24 19:49:28 +1000714 * If we hit a space limit, try to free up some lingering preallocated
715 * space before returning an error. In the case of ENOSPC, first try to
716 * write back all dirty inodes to free up some of the excess reserved
717 * metadata space. This reduces the chances that the eofblocks scan
718 * waits on dirty mappings. Since xfs_flush_inodes() is serialized, this
719 * also behaves as a filter to prevent too many eofblocks scans from
720 * running at the same time.
Dave Chinner637bbc72011-01-11 10:17:30 +1100721 */
Brian Fosterdc06f3982014-07-24 19:49:28 +1000722 if (ret == -EDQUOT && !enospc) {
723 enospc = xfs_inode_free_quota_eofblocks(ip);
724 if (enospc)
725 goto write_retry;
726 } else if (ret == -ENOSPC && !enospc) {
727 struct xfs_eofblocks eofb = {0};
728
Dave Chinner637bbc72011-01-11 10:17:30 +1100729 enospc = 1;
Dave Chinner9aa05002012-10-08 21:56:04 +1100730 xfs_flush_inodes(ip->i_mount);
Brian Fosterdc06f3982014-07-24 19:49:28 +1000731 eofb.eof_scan_owner = ip->i_ino; /* for locking */
732 eofb.eof_flags = XFS_EOF_FLAGS_SYNC;
733 xfs_icache_free_eofblocks(ip->i_mount, &eofb);
Dave Chinner9aa05002012-10-08 21:56:04 +1100734 goto write_retry;
Dave Chinner637bbc72011-01-11 10:17:30 +1100735 }
Christoph Hellwigd0606462011-12-18 20:00:14 +0000736
Dave Chinner637bbc72011-01-11 10:17:30 +1100737 current->backing_dev_info = NULL;
Christoph Hellwigd0606462011-12-18 20:00:14 +0000738out:
739 xfs_rw_iunlock(ip, iolock);
Dave Chinner637bbc72011-01-11 10:17:30 +1100740 return ret;
741}
742
743STATIC ssize_t
Al Virobf97f3bc2014-04-03 14:20:23 -0400744xfs_file_write_iter(
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000745 struct kiocb *iocb,
Al Virobf97f3bc2014-04-03 14:20:23 -0400746 struct iov_iter *from)
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000747{
748 struct file *file = iocb->ki_filp;
749 struct address_space *mapping = file->f_mapping;
750 struct inode *inode = mapping->host;
Christoph Hellwig00258e32010-02-15 09:44:47 +0000751 struct xfs_inode *ip = XFS_I(inode);
Dave Chinner637bbc72011-01-11 10:17:30 +1100752 ssize_t ret;
Al Virobf97f3bc2014-04-03 14:20:23 -0400753 size_t ocount = iov_iter_count(from);
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000754
755 XFS_STATS_INC(xs_write_calls);
756
Dave Chinner637bbc72011-01-11 10:17:30 +1100757 if (ocount == 0)
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000758 return 0;
759
Al Virobf97f3bc2014-04-03 14:20:23 -0400760 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
761 return -EIO;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000762
Dave Chinner637bbc72011-01-11 10:17:30 +1100763 if (unlikely(file->f_flags & O_DIRECT))
Al Virobf97f3bc2014-04-03 14:20:23 -0400764 ret = xfs_file_dio_aio_write(iocb, from);
Dave Chinner637bbc72011-01-11 10:17:30 +1100765 else
Al Virobf97f3bc2014-04-03 14:20:23 -0400766 ret = xfs_file_buffered_aio_write(iocb, from);
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000767
Christoph Hellwigd0606462011-12-18 20:00:14 +0000768 if (ret > 0) {
769 ssize_t err;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000770
Christoph Hellwigd0606462011-12-18 20:00:14 +0000771 XFS_STATS_ADD(xs_write_bytes, ret);
Christoph Hellwigce7ae1512011-12-18 20:00:11 +0000772
Christoph Hellwigd0606462011-12-18 20:00:14 +0000773 /* Handle various SYNC-type writes */
Al Virod311d792014-02-09 15:18:09 -0500774 err = generic_write_sync(file, iocb->ki_pos - ret, ret);
Christoph Hellwigd0606462011-12-18 20:00:14 +0000775 if (err < 0)
776 ret = err;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000777 }
Dave Chinnera363f0c2011-01-11 10:13:53 +1100778 return ret;
Christoph Hellwigdda35b82010-02-15 09:44:46 +0000779}
780
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100781STATIC long
782xfs_file_fallocate(
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700783 struct file *file,
784 int mode,
785 loff_t offset,
786 loff_t len)
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100787{
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700788 struct inode *inode = file_inode(file);
789 struct xfs_inode *ip = XFS_I(inode);
790 struct xfs_trans *tp;
791 long error;
792 loff_t new_size = 0;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100793
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700794 if (!S_ISREG(inode->i_mode))
795 return -EINVAL;
Namjae Jeone1d8fb82014-02-24 10:58:19 +1100796 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
Lukas Czerner376ba312014-03-13 19:07:58 +1100797 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE))
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100798 return -EOPNOTSUPP;
799
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100800 xfs_ilock(ip, XFS_IOLOCK_EXCL);
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700801 if (mode & FALLOC_FL_PUNCH_HOLE) {
802 error = xfs_free_file_space(ip, offset, len);
803 if (error)
804 goto out_unlock;
Namjae Jeone1d8fb82014-02-24 10:58:19 +1100805 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
806 unsigned blksize_mask = (1 << inode->i_blkbits) - 1;
807
808 if (offset & blksize_mask || len & blksize_mask) {
Dave Chinner24513372014-06-25 14:58:08 +1000809 error = -EINVAL;
Namjae Jeone1d8fb82014-02-24 10:58:19 +1100810 goto out_unlock;
811 }
812
Lukas Czerner23fffa92014-04-12 09:56:41 -0400813 /*
814 * There is no need to overlap collapse range with EOF,
815 * in which case it is effectively a truncate operation
816 */
817 if (offset + len >= i_size_read(inode)) {
Dave Chinner24513372014-06-25 14:58:08 +1000818 error = -EINVAL;
Lukas Czerner23fffa92014-04-12 09:56:41 -0400819 goto out_unlock;
820 }
821
Namjae Jeone1d8fb82014-02-24 10:58:19 +1100822 new_size = i_size_read(inode) - len;
823
824 error = xfs_collapse_file_space(ip, offset, len);
825 if (error)
826 goto out_unlock;
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700827 } else {
828 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
829 offset + len > i_size_read(inode)) {
830 new_size = offset + len;
Dave Chinner24513372014-06-25 14:58:08 +1000831 error = inode_newsize_ok(inode, new_size);
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700832 if (error)
833 goto out_unlock;
834 }
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100835
Lukas Czerner376ba312014-03-13 19:07:58 +1100836 if (mode & FALLOC_FL_ZERO_RANGE)
837 error = xfs_zero_file_space(ip, offset, len);
838 else
839 error = xfs_alloc_file_space(ip, offset, len,
840 XFS_BMAPI_PREALLOC);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100841 if (error)
842 goto out_unlock;
843 }
844
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700845 tp = xfs_trans_alloc(ip->i_mount, XFS_TRANS_WRITEID);
846 error = xfs_trans_reserve(tp, &M_RES(ip->i_mount)->tr_writeid, 0, 0);
847 if (error) {
848 xfs_trans_cancel(tp, 0);
849 goto out_unlock;
850 }
Dave Chinner82878892011-03-26 09:13:08 +1100851
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700852 xfs_ilock(ip, XFS_ILOCK_EXCL);
853 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
854 ip->i_d.di_mode &= ~S_ISUID;
855 if (ip->i_d.di_mode & S_IXGRP)
856 ip->i_d.di_mode &= ~S_ISGID;
857
Namjae Jeone1d8fb82014-02-24 10:58:19 +1100858 if (!(mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_COLLAPSE_RANGE)))
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700859 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
860
861 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
862 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
863
864 if (file->f_flags & O_DSYNC)
865 xfs_trans_set_sync(tp);
866 error = xfs_trans_commit(tp, 0);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100867 if (error)
868 goto out_unlock;
869
870 /* Change file size if needed */
871 if (new_size) {
872 struct iattr iattr;
873
874 iattr.ia_valid = ATTR_SIZE;
875 iattr.ia_size = new_size;
Christoph Hellwig83aee9e2013-10-12 00:55:07 -0700876 error = xfs_setattr_size(ip, &iattr);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100877 }
878
879out_unlock:
880 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
Dave Chinner24513372014-06-25 14:58:08 +1000881 return error;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +0100882}
883
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885STATIC int
Nathan Scott3562fd42006-03-14 14:00:35 +1100886xfs_file_open(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 struct inode *inode,
Christoph Hellwigf999a5b2008-11-28 14:23:32 +1100888 struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889{
Christoph Hellwigf999a5b2008-11-28 14:23:32 +1100890 if (!(file->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 return -EFBIG;
Christoph Hellwigf999a5b2008-11-28 14:23:32 +1100892 if (XFS_FORCED_SHUTDOWN(XFS_M(inode->i_sb)))
893 return -EIO;
894 return 0;
895}
896
897STATIC int
898xfs_dir_open(
899 struct inode *inode,
900 struct file *file)
901{
902 struct xfs_inode *ip = XFS_I(inode);
903 int mode;
904 int error;
905
906 error = xfs_file_open(inode, file);
907 if (error)
908 return error;
909
910 /*
911 * If there are any blocks, read-ahead block 0 as we're almost
912 * certain to have the next operation be a read there.
913 */
Christoph Hellwig309ecac2013-12-06 12:30:09 -0800914 mode = xfs_ilock_data_map_shared(ip);
Christoph Hellwigf999a5b2008-11-28 14:23:32 +1100915 if (ip->i_d.di_nextents > 0)
Eric Sandeen9df2dd02014-04-14 19:01:59 +1000916 xfs_dir3_data_readahead(ip, 0, -1);
Christoph Hellwigf999a5b2008-11-28 14:23:32 +1100917 xfs_iunlock(ip, mode);
918 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919}
920
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921STATIC int
Nathan Scott3562fd42006-03-14 14:00:35 +1100922xfs_file_release(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 struct inode *inode,
924 struct file *filp)
925{
Dave Chinner24513372014-06-25 14:58:08 +1000926 return xfs_release(XFS_I(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927}
928
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929STATIC int
Nathan Scott3562fd42006-03-14 14:00:35 +1100930xfs_file_readdir(
Al Virob8227552013-05-22 17:07:56 -0400931 struct file *file,
932 struct dir_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933{
Al Virob8227552013-05-22 17:07:56 -0400934 struct inode *inode = file_inode(file);
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000935 xfs_inode_t *ip = XFS_I(inode);
Christoph Hellwig051e7cd2007-08-28 13:58:24 +1000936 int error;
937 size_t bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
Christoph Hellwig051e7cd2007-08-28 13:58:24 +1000939 /*
940 * The Linux API doesn't pass down the total size of the buffer
941 * we read into down to the filesystem. With the filldir concept
942 * it's not needed for correct information, but the XFS dir2 leaf
943 * code wants an estimate of the buffer size to calculate it's
944 * readahead window and size the buffers used for mapping to
945 * physical blocks.
946 *
947 * Try to give it an estimate that's good enough, maybe at some
948 * point we can change the ->readdir prototype to include the
Eric Sandeena9cc7992010-02-03 17:50:13 +0000949 * buffer size. For now we use the current glibc buffer size.
Christoph Hellwig051e7cd2007-08-28 13:58:24 +1000950 */
Eric Sandeena9cc7992010-02-03 17:50:13 +0000951 bufsize = (size_t)min_t(loff_t, 32768, ip->i_d.di_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
Al Virob8227552013-05-22 17:07:56 -0400953 error = xfs_readdir(ip, ctx, bufsize);
Christoph Hellwig051e7cd2007-08-28 13:58:24 +1000954 if (error)
Dave Chinner24513372014-06-25 14:58:08 +1000955 return error;
Christoph Hellwig051e7cd2007-08-28 13:58:24 +1000956 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957}
958
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959STATIC int
Nathan Scott3562fd42006-03-14 14:00:35 +1100960xfs_file_mmap(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 struct file *filp,
962 struct vm_area_struct *vma)
963{
Nathan Scott3562fd42006-03-14 14:00:35 +1100964 vma->vm_ops = &xfs_file_vm_ops;
Dean Roehrich6fac0cb2005-06-21 14:07:45 +1000965
Nathan Scottfbc14622006-06-09 14:52:13 +1000966 file_accessed(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 return 0;
968}
969
David Chinner4f57dbc2007-07-19 16:28:17 +1000970/*
971 * mmap()d file has taken write protection fault and is being made
972 * writable. We can set the page state up correctly for a writable
973 * page, which means we can do correct delalloc accounting (ENOSPC
974 * checking!) and unwritten extent mapping.
975 */
976STATIC int
977xfs_vm_page_mkwrite(
978 struct vm_area_struct *vma,
Nick Pigginc2ec1752009-03-31 15:23:21 -0700979 struct vm_fault *vmf)
David Chinner4f57dbc2007-07-19 16:28:17 +1000980{
Nick Pigginc2ec1752009-03-31 15:23:21 -0700981 return block_page_mkwrite(vma, vmf, xfs_get_blocks);
David Chinner4f57dbc2007-07-19 16:28:17 +1000982}
983
Jeff Liud126d432012-08-21 17:11:57 +0800984/*
985 * This type is designed to indicate the type of offset we would like
Eric Sandeen49c69592014-09-09 11:56:48 +1000986 * to search from page cache for xfs_seek_hole_data().
Jeff Liud126d432012-08-21 17:11:57 +0800987 */
988enum {
989 HOLE_OFF = 0,
990 DATA_OFF,
991};
992
993/*
994 * Lookup the desired type of offset from the given page.
995 *
996 * On success, return true and the offset argument will point to the
997 * start of the region that was found. Otherwise this function will
998 * return false and keep the offset argument unchanged.
999 */
1000STATIC bool
1001xfs_lookup_buffer_offset(
1002 struct page *page,
1003 loff_t *offset,
1004 unsigned int type)
1005{
1006 loff_t lastoff = page_offset(page);
1007 bool found = false;
1008 struct buffer_head *bh, *head;
1009
1010 bh = head = page_buffers(page);
1011 do {
1012 /*
1013 * Unwritten extents that have data in the page
1014 * cache covering them can be identified by the
1015 * BH_Unwritten state flag. Pages with multiple
1016 * buffers might have a mix of holes, data and
1017 * unwritten extents - any buffer with valid
1018 * data in it should have BH_Uptodate flag set
1019 * on it.
1020 */
1021 if (buffer_unwritten(bh) ||
1022 buffer_uptodate(bh)) {
1023 if (type == DATA_OFF)
1024 found = true;
1025 } else {
1026 if (type == HOLE_OFF)
1027 found = true;
1028 }
1029
1030 if (found) {
1031 *offset = lastoff;
1032 break;
1033 }
1034 lastoff += bh->b_size;
1035 } while ((bh = bh->b_this_page) != head);
1036
1037 return found;
1038}
1039
1040/*
1041 * This routine is called to find out and return a data or hole offset
1042 * from the page cache for unwritten extents according to the desired
Eric Sandeen49c69592014-09-09 11:56:48 +10001043 * type for xfs_seek_hole_data().
Jeff Liud126d432012-08-21 17:11:57 +08001044 *
1045 * The argument offset is used to tell where we start to search from the
1046 * page cache. Map is used to figure out the end points of the range to
1047 * lookup pages.
1048 *
1049 * Return true if the desired type of offset was found, and the argument
1050 * offset is filled with that address. Otherwise, return false and keep
1051 * offset unchanged.
1052 */
1053STATIC bool
1054xfs_find_get_desired_pgoff(
1055 struct inode *inode,
1056 struct xfs_bmbt_irec *map,
1057 unsigned int type,
1058 loff_t *offset)
1059{
1060 struct xfs_inode *ip = XFS_I(inode);
1061 struct xfs_mount *mp = ip->i_mount;
1062 struct pagevec pvec;
1063 pgoff_t index;
1064 pgoff_t end;
1065 loff_t endoff;
1066 loff_t startoff = *offset;
1067 loff_t lastoff = startoff;
1068 bool found = false;
1069
1070 pagevec_init(&pvec, 0);
1071
1072 index = startoff >> PAGE_CACHE_SHIFT;
1073 endoff = XFS_FSB_TO_B(mp, map->br_startoff + map->br_blockcount);
1074 end = endoff >> PAGE_CACHE_SHIFT;
1075 do {
1076 int want;
1077 unsigned nr_pages;
1078 unsigned int i;
1079
1080 want = min_t(pgoff_t, end - index, PAGEVEC_SIZE);
1081 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
1082 want);
1083 /*
1084 * No page mapped into given range. If we are searching holes
1085 * and if this is the first time we got into the loop, it means
1086 * that the given offset is landed in a hole, return it.
1087 *
1088 * If we have already stepped through some block buffers to find
1089 * holes but they all contains data. In this case, the last
1090 * offset is already updated and pointed to the end of the last
1091 * mapped page, if it does not reach the endpoint to search,
1092 * that means there should be a hole between them.
1093 */
1094 if (nr_pages == 0) {
1095 /* Data search found nothing */
1096 if (type == DATA_OFF)
1097 break;
1098
1099 ASSERT(type == HOLE_OFF);
1100 if (lastoff == startoff || lastoff < endoff) {
1101 found = true;
1102 *offset = lastoff;
1103 }
1104 break;
1105 }
1106
1107 /*
1108 * At lease we found one page. If this is the first time we
1109 * step into the loop, and if the first page index offset is
1110 * greater than the given search offset, a hole was found.
1111 */
1112 if (type == HOLE_OFF && lastoff == startoff &&
1113 lastoff < page_offset(pvec.pages[0])) {
1114 found = true;
1115 break;
1116 }
1117
1118 for (i = 0; i < nr_pages; i++) {
1119 struct page *page = pvec.pages[i];
1120 loff_t b_offset;
1121
1122 /*
1123 * At this point, the page may be truncated or
1124 * invalidated (changing page->mapping to NULL),
1125 * or even swizzled back from swapper_space to tmpfs
1126 * file mapping. However, page->index will not change
1127 * because we have a reference on the page.
1128 *
1129 * Searching done if the page index is out of range.
1130 * If the current offset is not reaches the end of
1131 * the specified search range, there should be a hole
1132 * between them.
1133 */
1134 if (page->index > end) {
1135 if (type == HOLE_OFF && lastoff < endoff) {
1136 *offset = lastoff;
1137 found = true;
1138 }
1139 goto out;
1140 }
1141
1142 lock_page(page);
1143 /*
1144 * Page truncated or invalidated(page->mapping == NULL).
1145 * We can freely skip it and proceed to check the next
1146 * page.
1147 */
1148 if (unlikely(page->mapping != inode->i_mapping)) {
1149 unlock_page(page);
1150 continue;
1151 }
1152
1153 if (!page_has_buffers(page)) {
1154 unlock_page(page);
1155 continue;
1156 }
1157
1158 found = xfs_lookup_buffer_offset(page, &b_offset, type);
1159 if (found) {
1160 /*
1161 * The found offset may be less than the start
1162 * point to search if this is the first time to
1163 * come here.
1164 */
1165 *offset = max_t(loff_t, startoff, b_offset);
1166 unlock_page(page);
1167 goto out;
1168 }
1169
1170 /*
1171 * We either searching data but nothing was found, or
1172 * searching hole but found a data buffer. In either
1173 * case, probably the next page contains the desired
1174 * things, update the last offset to it so.
1175 */
1176 lastoff = page_offset(page) + PAGE_SIZE;
1177 unlock_page(page);
1178 }
1179
1180 /*
1181 * The number of returned pages less than our desired, search
1182 * done. In this case, nothing was found for searching data,
1183 * but we found a hole behind the last offset.
1184 */
1185 if (nr_pages < want) {
1186 if (type == HOLE_OFF) {
1187 *offset = lastoff;
1188 found = true;
1189 }
1190 break;
1191 }
1192
1193 index = pvec.pages[i - 1]->index + 1;
1194 pagevec_release(&pvec);
1195 } while (index <= end);
1196
1197out:
1198 pagevec_release(&pvec);
1199 return found;
1200}
1201
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001202STATIC loff_t
Eric Sandeen49c69592014-09-09 11:56:48 +10001203xfs_seek_hole_data(
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001204 struct file *file,
Eric Sandeen49c69592014-09-09 11:56:48 +10001205 loff_t start,
1206 int whence)
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001207{
1208 struct inode *inode = file->f_mapping->host;
1209 struct xfs_inode *ip = XFS_I(inode);
1210 struct xfs_mount *mp = ip->i_mount;
1211 loff_t uninitialized_var(offset);
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001212 xfs_fsize_t isize;
1213 xfs_fileoff_t fsbno;
Jeff Liub686d1f2012-08-21 17:12:18 +08001214 xfs_filblks_t end;
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001215 uint lock;
1216 int error;
1217
1218 if (XFS_FORCED_SHUTDOWN(mp))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001219 return -EIO;
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001220
Christoph Hellwig309ecac2013-12-06 12:30:09 -08001221 lock = xfs_ilock_data_map_shared(ip);
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001222
1223 isize = i_size_read(inode);
1224 if (start >= isize) {
Dave Chinner24513372014-06-25 14:58:08 +10001225 error = -ENXIO;
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001226 goto out_unlock;
1227 }
1228
Eric Sandeen49c69592014-09-09 11:56:48 +10001229 /*
1230 * Try to read extents from the first block indicated
1231 * by fsbno to the end block of the file.
1232 */
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001233 fsbno = XFS_B_TO_FSBT(mp, start);
Jeff Liub686d1f2012-08-21 17:12:18 +08001234 end = XFS_B_TO_FSB(mp, isize);
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001235
Jeff Liub686d1f2012-08-21 17:12:18 +08001236 for (;;) {
1237 struct xfs_bmbt_irec map[2];
1238 int nmap = 2;
1239 unsigned int i;
1240
1241 error = xfs_bmapi_read(ip, fsbno, end - fsbno, map, &nmap,
1242 XFS_BMAPI_ENTIRE);
1243 if (error)
1244 goto out_unlock;
1245
1246 /* No extents at given offset, must be beyond EOF */
1247 if (nmap == 0) {
Dave Chinner24513372014-06-25 14:58:08 +10001248 error = -ENXIO;
Jeff Liub686d1f2012-08-21 17:12:18 +08001249 goto out_unlock;
1250 }
1251
1252 for (i = 0; i < nmap; i++) {
1253 offset = max_t(loff_t, start,
1254 XFS_FSB_TO_B(mp, map[i].br_startoff));
1255
Eric Sandeen49c69592014-09-09 11:56:48 +10001256 /* Landed in the hole we wanted? */
1257 if (whence == SEEK_HOLE &&
1258 map[i].br_startblock == HOLESTARTBLOCK)
1259 goto out;
1260
1261 /* Landed in the data extent we wanted? */
1262 if (whence == SEEK_DATA &&
1263 (map[i].br_startblock == DELAYSTARTBLOCK ||
1264 (map[i].br_state == XFS_EXT_NORM &&
1265 !isnullstartblock(map[i].br_startblock))))
Jeff Liub686d1f2012-08-21 17:12:18 +08001266 goto out;
1267
1268 /*
Eric Sandeen49c69592014-09-09 11:56:48 +10001269 * Landed in an unwritten extent, try to search
1270 * for hole or data from page cache.
Jeff Liub686d1f2012-08-21 17:12:18 +08001271 */
1272 if (map[i].br_state == XFS_EXT_UNWRITTEN) {
1273 if (xfs_find_get_desired_pgoff(inode, &map[i],
Eric Sandeen49c69592014-09-09 11:56:48 +10001274 whence == SEEK_HOLE ? HOLE_OFF : DATA_OFF,
1275 &offset))
Jeff Liub686d1f2012-08-21 17:12:18 +08001276 goto out;
1277 }
1278 }
1279
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001280 /*
Eric Sandeen49c69592014-09-09 11:56:48 +10001281 * We only received one extent out of the two requested. This
1282 * means we've hit EOF and didn't find what we are looking for.
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001283 */
Jeff Liub686d1f2012-08-21 17:12:18 +08001284 if (nmap == 1) {
Eric Sandeen49c69592014-09-09 11:56:48 +10001285 /*
1286 * If we were looking for a hole, set offset to
1287 * the end of the file (i.e., there is an implicit
1288 * hole at the end of any file).
1289 */
1290 if (whence == SEEK_HOLE) {
1291 offset = isize;
1292 break;
1293 }
1294 /*
1295 * If we were looking for data, it's nowhere to be found
1296 */
1297 ASSERT(whence == SEEK_DATA);
1298 error = -ENXIO;
1299 goto out_unlock;
Jeff Liub686d1f2012-08-21 17:12:18 +08001300 }
1301
1302 ASSERT(i > 1);
1303
1304 /*
Eric Sandeen49c69592014-09-09 11:56:48 +10001305 * Nothing was found, proceed to the next round of search
1306 * if the next reading offset is not at or beyond EOF.
Jeff Liub686d1f2012-08-21 17:12:18 +08001307 */
1308 fsbno = map[i - 1].br_startoff + map[i - 1].br_blockcount;
1309 start = XFS_FSB_TO_B(mp, fsbno);
1310 if (start >= isize) {
Eric Sandeen49c69592014-09-09 11:56:48 +10001311 if (whence == SEEK_HOLE) {
1312 offset = isize;
1313 break;
1314 }
1315 ASSERT(whence == SEEK_DATA);
1316 error = -ENXIO;
1317 goto out_unlock;
Jeff Liub686d1f2012-08-21 17:12:18 +08001318 }
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001319 }
1320
Jeff Liub686d1f2012-08-21 17:12:18 +08001321out:
1322 /*
Eric Sandeen49c69592014-09-09 11:56:48 +10001323 * If at this point we have found the hole we wanted, the returned
Jeff Liub686d1f2012-08-21 17:12:18 +08001324 * offset may be bigger than the file size as it may be aligned to
Eric Sandeen49c69592014-09-09 11:56:48 +10001325 * page boundary for unwritten extents. We need to deal with this
Jeff Liub686d1f2012-08-21 17:12:18 +08001326 * situation in particular.
1327 */
Eric Sandeen49c69592014-09-09 11:56:48 +10001328 if (whence == SEEK_HOLE)
1329 offset = min_t(loff_t, offset, isize);
Jie Liu46a1c2c2013-06-25 12:02:13 +08001330 offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001331
1332out_unlock:
Christoph Hellwig01f4f322013-12-06 12:30:08 -08001333 xfs_iunlock(ip, lock);
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001334
1335 if (error)
Dave Chinner24513372014-06-25 14:58:08 +10001336 return error;
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001337 return offset;
1338}
1339
1340STATIC loff_t
1341xfs_file_llseek(
1342 struct file *file,
1343 loff_t offset,
Eric Sandeen59f9c002014-09-09 11:57:10 +10001344 int whence)
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001345{
Eric Sandeen59f9c002014-09-09 11:57:10 +10001346 switch (whence) {
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001347 case SEEK_END:
1348 case SEEK_CUR:
1349 case SEEK_SET:
Eric Sandeen59f9c002014-09-09 11:57:10 +10001350 return generic_file_llseek(file, offset, whence);
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001351 case SEEK_HOLE:
Eric Sandeen49c69592014-09-09 11:56:48 +10001352 case SEEK_DATA:
Eric Sandeen59f9c002014-09-09 11:57:10 +10001353 return xfs_seek_hole_data(file, offset, whence);
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001354 default:
1355 return -EINVAL;
1356 }
1357}
1358
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001359const struct file_operations xfs_file_operations = {
Jeff Liu3fe3e6b2012-05-10 21:29:17 +08001360 .llseek = xfs_file_llseek,
Al Virob4f5d2c2014-04-02 14:37:59 -04001361 .read = new_sync_read,
Al Virobf97f3bc2014-04-03 14:20:23 -04001362 .write = new_sync_write,
Al Virob4f5d2c2014-04-02 14:37:59 -04001363 .read_iter = xfs_file_read_iter,
Al Virobf97f3bc2014-04-03 14:20:23 -04001364 .write_iter = xfs_file_write_iter,
Nathan Scott1b895842006-03-31 13:08:59 +10001365 .splice_read = xfs_file_splice_read,
Al Viro8d020762014-04-05 04:27:08 -04001366 .splice_write = iter_file_splice_write,
Nathan Scott3562fd42006-03-14 14:00:35 +11001367 .unlocked_ioctl = xfs_file_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368#ifdef CONFIG_COMPAT
Nathan Scott3562fd42006-03-14 14:00:35 +11001369 .compat_ioctl = xfs_file_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370#endif
Nathan Scott3562fd42006-03-14 14:00:35 +11001371 .mmap = xfs_file_mmap,
1372 .open = xfs_file_open,
1373 .release = xfs_file_release,
1374 .fsync = xfs_file_fsync,
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01001375 .fallocate = xfs_file_fallocate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376};
1377
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08001378const struct file_operations xfs_dir_file_operations = {
Christoph Hellwigf999a5b2008-11-28 14:23:32 +11001379 .open = xfs_dir_open,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 .read = generic_read_dir,
Al Virob8227552013-05-22 17:07:56 -04001381 .iterate = xfs_file_readdir,
Al Viro59af1582008-08-24 07:24:41 -04001382 .llseek = generic_file_llseek,
Nathan Scott3562fd42006-03-14 14:00:35 +11001383 .unlocked_ioctl = xfs_file_ioctl,
Nathan Scottd3870392005-05-06 06:44:46 -07001384#ifdef CONFIG_COMPAT
Nathan Scott3562fd42006-03-14 14:00:35 +11001385 .compat_ioctl = xfs_file_compat_ioctl,
Nathan Scottd3870392005-05-06 06:44:46 -07001386#endif
Christoph Hellwig1da2f2d2011-10-02 14:25:16 +00001387 .fsync = xfs_dir_fsync,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388};
1389
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +04001390static const struct vm_operations_struct xfs_file_vm_ops = {
Nick Piggin54cb8822007-07-19 01:46:59 -07001391 .fault = filemap_fault,
Kirill A. Shutemovf1820362014-04-07 15:37:19 -07001392 .map_pages = filemap_map_pages,
David Chinner4f57dbc2007-07-19 16:28:17 +10001393 .page_mkwrite = xfs_vm_page_mkwrite,
Konstantin Khlebnikov0b173bc2012-10-08 16:28:46 -07001394 .remap_pages = generic_file_remap_pages,
Dean Roehrich6fac0cb2005-06-21 14:07:45 +10001395};