blob: ac4feae45eb308c39629f177c0b6620fae77fb69 [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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "xfs_fs.h"
Dave Chinner70a9883c2013-10-23 10:36:05 +110020#include "xfs_shared.h"
Dave Chinner239880e2013-10-23 10:50:10 +110021#include "xfs_format.h"
22#include "xfs_log_format.h"
23#include "xfs_trans_resv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_inode.h"
Hannes Eder7bf446f2009-03-05 15:20:25 +010026#include "xfs_ioctl.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110027#include "xfs_alloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "xfs_rtalloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_itable.h"
Nathan Scotta844f452005-11-02 14:38:42 +110030#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_attr.h"
Nathan Scotta844f452005-11-02 14:38:42 +110032#include "xfs_bmap.h"
Dave Chinner68988112013-08-12 20:49:42 +100033#include "xfs_bmap_util.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_fsops.h"
Christoph Hellwiga46db602011-01-07 13:02:04 +000035#include "xfs_discard.h"
Christoph Hellwig25fe55e2008-07-18 17:13:20 +100036#include "xfs_quota.h"
Christoph Hellwigd296d302009-01-19 02:02:57 +010037#include "xfs_export.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000038#include "xfs_trace.h"
Brian Foster8ca149d2012-11-07 12:21:12 -050039#include "xfs_icache.h"
Dave Chinnerc24b5df2013-08-12 20:49:45 +100040#include "xfs_symlink.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110041#include "xfs_trans.h"
Christoph Hellwig781355c2015-02-16 11:59:50 +110042#include "xfs_pnfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080044#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/dcache.h>
46#include <linux/mount.h>
47#include <linux/namei.h>
48#include <linux/pagemap.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090049#include <linux/slab.h>
Christoph Hellwigd296d302009-01-19 02:02:57 +010050#include <linux/exportfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52/*
53 * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
54 * a file or fs handle.
55 *
56 * XFS_IOC_PATH_TO_FSHANDLE
57 * returns fs handle for a mount point or path within that mount point
58 * XFS_IOC_FD_TO_HANDLE
59 * returns full handle for a FD opened in user space
60 * XFS_IOC_PATH_TO_HANDLE
61 * returns full handle for a path
62 */
sandeen@sandeen.netd5547f92008-11-25 21:20:08 -060063int
Linus Torvalds1da177e2005-04-16 15:20:36 -070064xfs_find_handle(
65 unsigned int cmd,
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -060066 xfs_fsop_handlereq_t *hreq)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
68 int hsize;
69 xfs_handle_t handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 struct inode *inode;
Dave Chinnera30b0362013-09-02 20:49:36 +100071 struct fd f = {NULL};
Christoph Hellwig4346cdd2009-02-08 21:51:14 +010072 struct path path;
Al Viro2903ff02012-08-28 12:52:22 -040073 int error;
Christoph Hellwig4346cdd2009-02-08 21:51:14 +010074 struct xfs_inode *ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Christoph Hellwig4346cdd2009-02-08 21:51:14 +010076 if (cmd == XFS_IOC_FD_TO_HANDLE) {
Al Viro2903ff02012-08-28 12:52:22 -040077 f = fdget(hreq->fd);
78 if (!f.file)
Christoph Hellwig4346cdd2009-02-08 21:51:14 +010079 return -EBADF;
Al Viro496ad9a2013-01-23 17:07:38 -050080 inode = file_inode(f.file);
Christoph Hellwig4346cdd2009-02-08 21:51:14 +010081 } else {
82 error = user_lpath((const char __user *)hreq->path, &path);
83 if (error)
84 return error;
85 inode = path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 }
Christoph Hellwig4346cdd2009-02-08 21:51:14 +010087 ip = XFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Christoph Hellwig4346cdd2009-02-08 21:51:14 +010089 /*
90 * We can only generate handles for inodes residing on a XFS filesystem,
91 * and only for regular files, directories or symbolic links.
92 */
93 error = -EINVAL;
94 if (inode->i_sb->s_magic != XFS_SB_MAGIC)
95 goto out_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Christoph Hellwig4346cdd2009-02-08 21:51:14 +010097 error = -EBADF;
98 if (!S_ISREG(inode->i_mode) &&
99 !S_ISDIR(inode->i_mode) &&
100 !S_ISLNK(inode->i_mode))
101 goto out_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Christoph Hellwig4346cdd2009-02-08 21:51:14 +0100104 memcpy(&handle.ha_fsid, ip->i_mount->m_fixedfsid, sizeof(xfs_fsid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
Christoph Hellwig4346cdd2009-02-08 21:51:14 +0100106 if (cmd == XFS_IOC_PATH_TO_FSHANDLE) {
107 /*
108 * This handle only contains an fsid, zero the rest.
109 */
110 memset(&handle.ha_fid, 0, sizeof(handle.ha_fid));
111 hsize = sizeof(xfs_fsid_t);
112 } else {
Christoph Hellwigc6143912007-09-14 15:22:37 +1000113 handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
114 sizeof(handle.ha_fid.fid_len);
115 handle.ha_fid.fid_pad = 0;
116 handle.ha_fid.fid_gen = ip->i_d.di_gen;
117 handle.ha_fid.fid_ino = ip->i_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
119 hsize = XFS_HSIZE(handle);
120 }
121
Christoph Hellwig4346cdd2009-02-08 21:51:14 +0100122 error = -EFAULT;
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -0600123 if (copy_to_user(hreq->ohandle, &handle, hsize) ||
Christoph Hellwig4346cdd2009-02-08 21:51:14 +0100124 copy_to_user(hreq->ohandlen, &hsize, sizeof(__s32)))
125 goto out_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
Christoph Hellwig4346cdd2009-02-08 21:51:14 +0100127 error = 0;
128
129 out_put:
130 if (cmd == XFS_IOC_FD_TO_HANDLE)
Al Viro2903ff02012-08-28 12:52:22 -0400131 fdput(f);
Christoph Hellwig4346cdd2009-02-08 21:51:14 +0100132 else
133 path_put(&path);
134 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135}
136
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137/*
Christoph Hellwigd296d302009-01-19 02:02:57 +0100138 * No need to do permission checks on the various pathname components
139 * as the handle operations are privileged.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 */
141STATIC int
Christoph Hellwigd296d302009-01-19 02:02:57 +0100142xfs_handle_acceptable(
143 void *context,
144 struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
Christoph Hellwigd296d302009-01-19 02:02:57 +0100146 return 1;
147}
148
149/*
150 * Convert userspace handle data into a dentry.
151 */
152struct dentry *
153xfs_handle_to_dentry(
154 struct file *parfilp,
155 void __user *uhandle,
156 u32 hlen)
157{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 xfs_handle_t handle;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100159 struct xfs_fid64 fid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161 /*
162 * Only allow handle opens under a directory.
163 */
Al Viro496ad9a2013-01-23 17:07:38 -0500164 if (!S_ISDIR(file_inode(parfilp)->i_mode))
Christoph Hellwigd296d302009-01-19 02:02:57 +0100165 return ERR_PTR(-ENOTDIR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Christoph Hellwigd296d302009-01-19 02:02:57 +0100167 if (hlen != sizeof(xfs_handle_t))
168 return ERR_PTR(-EINVAL);
169 if (copy_from_user(&handle, uhandle, hlen))
170 return ERR_PTR(-EFAULT);
171 if (handle.ha_fid.fid_len !=
172 sizeof(handle.ha_fid) - sizeof(handle.ha_fid.fid_len))
173 return ERR_PTR(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
Christoph Hellwigd296d302009-01-19 02:02:57 +0100175 memset(&fid, 0, sizeof(struct fid));
176 fid.ino = handle.ha_fid.fid_ino;
177 fid.gen = handle.ha_fid.fid_gen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Christoph Hellwigd296d302009-01-19 02:02:57 +0100179 return exportfs_decode_fh(parfilp->f_path.mnt, (struct fid *)&fid, 3,
180 FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG,
181 xfs_handle_acceptable, NULL);
182}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Christoph Hellwigd296d302009-01-19 02:02:57 +0100184STATIC struct dentry *
185xfs_handlereq_to_dentry(
186 struct file *parfilp,
187 xfs_fsop_handlereq_t *hreq)
188{
189 return xfs_handle_to_dentry(parfilp, hreq->ihandle, hreq->ihandlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190}
191
sandeen@sandeen.netd5547f92008-11-25 21:20:08 -0600192int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193xfs_open_by_handle(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 struct file *parfilp,
Christoph Hellwigd296d302009-01-19 02:02:57 +0100195 xfs_fsop_handlereq_t *hreq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196{
David Howells745ca242008-11-14 10:39:22 +1100197 const struct cred *cred = current_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 int error;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100199 int fd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 int permflag;
201 struct file *filp;
202 struct inode *inode;
203 struct dentry *dentry;
Dave Chinner1a1d7722012-03-22 05:15:06 +0000204 fmode_t fmode;
Al Viro765927b2012-06-26 21:58:53 +0400205 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
207 if (!capable(CAP_SYS_ADMIN))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000208 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Christoph Hellwigd296d302009-01-19 02:02:57 +0100210 dentry = xfs_handlereq_to_dentry(parfilp, hreq);
211 if (IS_ERR(dentry))
212 return PTR_ERR(dentry);
213 inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215 /* Restrict xfs_open_by_handle to directories & regular files. */
216 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000217 error = -EPERM;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100218 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 }
220
221#if BITS_PER_LONG != 32
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -0600222 hreq->oflags |= O_LARGEFILE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223#endif
Christoph Hellwigd296d302009-01-19 02:02:57 +0100224
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -0600225 permflag = hreq->oflags;
Dave Chinner1a1d7722012-03-22 05:15:06 +0000226 fmode = OPEN_FMODE(permflag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
Dave Chinner1a1d7722012-03-22 05:15:06 +0000228 (fmode & FMODE_WRITE) && IS_APPEND(inode)) {
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000229 error = -EPERM;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100230 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 }
232
Dave Chinner1a1d7722012-03-22 05:15:06 +0000233 if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000234 error = -EACCES;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100235 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 }
237
238 /* Can't write directories. */
Dave Chinner1a1d7722012-03-22 05:15:06 +0000239 if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000240 error = -EISDIR;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100241 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 }
243
Yann Droneaud862a6292013-07-02 18:39:34 +0200244 fd = get_unused_fd_flags(0);
Christoph Hellwigd296d302009-01-19 02:02:57 +0100245 if (fd < 0) {
246 error = fd;
247 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 }
249
Al Viro765927b2012-06-26 21:58:53 +0400250 path.mnt = parfilp->f_path.mnt;
251 path.dentry = dentry;
252 filp = dentry_open(&path, hreq->oflags, cred);
253 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 if (IS_ERR(filp)) {
Christoph Hellwigd296d302009-01-19 02:02:57 +0100255 put_unused_fd(fd);
256 return PTR_ERR(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
Christoph Hellwig4d4be482008-12-09 04:47:33 -0500258
Al Viro03209372011-07-25 20:54:24 -0400259 if (S_ISREG(inode->i_mode)) {
Vlad Apostolov2e2e7bb2006-11-11 18:04:47 +1100260 filp->f_flags |= O_NOATIME;
Christoph Hellwig4d4be482008-12-09 04:47:33 -0500261 filp->f_mode |= FMODE_NOCMTIME;
Vlad Apostolov2e2e7bb2006-11-11 18:04:47 +1100262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
Christoph Hellwigd296d302009-01-19 02:02:57 +0100264 fd_install(fd, filp);
265 return fd;
266
267 out_dput:
268 dput(dentry);
269 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270}
271
sandeen@sandeen.netd5547f92008-11-25 21:20:08 -0600272int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273xfs_readlink_by_handle(
Christoph Hellwigd296d302009-01-19 02:02:57 +0100274 struct file *parfilp,
275 xfs_fsop_handlereq_t *hreq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
Christoph Hellwigd296d302009-01-19 02:02:57 +0100277 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 __u32 olen;
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000279 void *link;
280 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
282 if (!capable(CAP_SYS_ADMIN))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000283 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Christoph Hellwigd296d302009-01-19 02:02:57 +0100285 dentry = xfs_handlereq_to_dentry(parfilp, hreq);
286 if (IS_ERR(dentry))
287 return PTR_ERR(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 /* Restrict this handle operation to symlinks only. */
David Howellse36cb0b2015-01-29 12:02:35 +0000290 if (!d_is_symlink(dentry)) {
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000291 error = -EINVAL;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100292 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 }
294
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -0600295 if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000296 error = -EFAULT;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100297 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000300 link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
Christoph Hellwigd296d302009-01-19 02:02:57 +0100301 if (!link) {
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000302 error = -ENOMEM;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100303 goto out_dput;
304 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
Dave Chinner24513372014-06-25 14:58:08 +1000306 error = xfs_readlink(XFS_I(dentry->d_inode), link);
Nathan Scott67fcaa72006-06-09 17:00:52 +1000307 if (error)
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000308 goto out_kfree;
Al Viro5d826c82014-03-14 13:42:45 -0400309 error = readlink_copy(hreq->ohandle, olen, link);
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000310 if (error)
311 goto out_kfree;
Nathan Scott67fcaa72006-06-09 17:00:52 +1000312
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000313 out_kfree:
314 kfree(link);
Christoph Hellwigd296d302009-01-19 02:02:57 +0100315 out_dput:
316 dput(dentry);
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000317 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
319
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000320int
321xfs_set_dmattrs(
322 xfs_inode_t *ip,
323 u_int evmask,
324 u_int16_t state)
325{
326 xfs_mount_t *mp = ip->i_mount;
327 xfs_trans_t *tp;
328 int error;
329
330 if (!capable(CAP_SYS_ADMIN))
Dave Chinner24513372014-06-25 14:58:08 +1000331 return -EPERM;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000332
333 if (XFS_FORCED_SHUTDOWN(mp))
Dave Chinner24513372014-06-25 14:58:08 +1000334 return -EIO;
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000335
336 tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
Jie Liu3d3c8b52013-08-12 20:49:59 +1000337 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
Dave Chinnerc24b5df2013-08-12 20:49:45 +1000338 if (error) {
339 xfs_trans_cancel(tp, 0);
340 return error;
341 }
342 xfs_ilock(ip, XFS_ILOCK_EXCL);
343 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
344
345 ip->i_d.di_dmevmask = evmask;
346 ip->i_d.di_dmstate = state;
347
348 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
349 error = xfs_trans_commit(tp, 0);
350
351 return error;
352}
353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354STATIC int
355xfs_fssetdm_by_handle(
Christoph Hellwigd296d302009-01-19 02:02:57 +0100356 struct file *parfilp,
357 void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
359 int error;
360 struct fsdmidata fsd;
361 xfs_fsop_setdm_handlereq_t dmhreq;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100362 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
364 if (!capable(CAP_MKNOD))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000365 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000367 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Jan Karad9457dc2012-06-12 16:20:39 +0200369 error = mnt_want_write_file(parfilp);
370 if (error)
371 return error;
372
Christoph Hellwigd296d302009-01-19 02:02:57 +0100373 dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);
Jan Karad9457dc2012-06-12 16:20:39 +0200374 if (IS_ERR(dentry)) {
375 mnt_drop_write_file(parfilp);
Christoph Hellwigd296d302009-01-19 02:02:57 +0100376 return PTR_ERR(dentry);
Jan Karad9457dc2012-06-12 16:20:39 +0200377 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
Christoph Hellwigd296d302009-01-19 02:02:57 +0100379 if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000380 error = -EPERM;
Christoph Hellwig6e7f75e2007-10-11 18:09:50 +1000381 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 }
383
384 if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000385 error = -EFAULT;
Christoph Hellwig6e7f75e2007-10-11 18:09:50 +1000386 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 }
388
Dave Chinner24513372014-06-25 14:58:08 +1000389 error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
Christoph Hellwig6e7f75e2007-10-11 18:09:50 +1000390 fsd.fsd_dmstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Christoph Hellwig6e7f75e2007-10-11 18:09:50 +1000392 out:
Jan Karad9457dc2012-06-12 16:20:39 +0200393 mnt_drop_write_file(parfilp);
Christoph Hellwigd296d302009-01-19 02:02:57 +0100394 dput(dentry);
Christoph Hellwig6e7f75e2007-10-11 18:09:50 +1000395 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396}
397
398STATIC int
399xfs_attrlist_by_handle(
Christoph Hellwigd296d302009-01-19 02:02:57 +0100400 struct file *parfilp,
401 void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402{
Christoph Hellwigd296d302009-01-19 02:02:57 +0100403 int error = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 attrlist_cursor_kern_t *cursor;
405 xfs_fsop_attrlist_handlereq_t al_hreq;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100406 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 char *kbuf;
408
409 if (!capable(CAP_SYS_ADMIN))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000410 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000412 return -EFAULT;
Dan Carpenter071c5292013-10-31 21:00:10 +0300413 if (al_hreq.buflen < sizeof(struct attrlist) ||
414 al_hreq.buflen > XATTR_LIST_MAX)
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000415 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
Christoph Hellwig90ad58a2008-06-27 13:32:19 +1000417 /*
418 * Reject flags, only allow namespaces.
419 */
420 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000421 return -EINVAL;
Christoph Hellwig90ad58a2008-06-27 13:32:19 +1000422
Christoph Hellwigd296d302009-01-19 02:02:57 +0100423 dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
424 if (IS_ERR(dentry))
425 return PTR_ERR(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Dave Chinnerfdd3cce2013-09-02 20:53:00 +1000427 kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP);
428 if (!kbuf)
429 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
Dave Chinner24513372014-06-25 14:58:08 +1000432 error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000433 al_hreq.flags, cursor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 if (error)
435 goto out_kfree;
436
437 if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
438 error = -EFAULT;
439
Dave Chinnerfdd3cce2013-09-02 20:53:00 +1000440out_kfree:
441 kmem_free(kbuf);
442out_dput:
Christoph Hellwigd296d302009-01-19 02:02:57 +0100443 dput(dentry);
444 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445}
446
sandeen@sandeen.net28750972008-11-25 21:20:15 -0600447int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448xfs_attrmulti_attr_get(
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000449 struct inode *inode,
Dave Chinnera9273ca2010-01-20 10:47:48 +1100450 unsigned char *name,
451 unsigned char __user *ubuf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 __uint32_t *len,
453 __uint32_t flags)
454{
Dave Chinnera9273ca2010-01-20 10:47:48 +1100455 unsigned char *kbuf;
Dave Chinner24513372014-06-25 14:58:08 +1000456 int error = -EFAULT;
Barry Naujoke8b0eba2008-04-22 17:34:31 +1000457
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 if (*len > XATTR_SIZE_MAX)
Dave Chinner24513372014-06-25 14:58:08 +1000459 return -EINVAL;
Dave Chinnerfdd3cce2013-09-02 20:53:00 +1000460 kbuf = kmem_zalloc_large(*len, KM_SLEEP);
461 if (!kbuf)
Dave Chinner24513372014-06-25 14:58:08 +1000462 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Barry Naujoke8b0eba2008-04-22 17:34:31 +1000464 error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 if (error)
466 goto out_kfree;
467
468 if (copy_to_user(ubuf, kbuf, *len))
Dave Chinner24513372014-06-25 14:58:08 +1000469 error = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
Dave Chinnerfdd3cce2013-09-02 20:53:00 +1000471out_kfree:
472 kmem_free(kbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 return error;
474}
475
sandeen@sandeen.net28750972008-11-25 21:20:15 -0600476int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477xfs_attrmulti_attr_set(
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000478 struct inode *inode,
Dave Chinnera9273ca2010-01-20 10:47:48 +1100479 unsigned char *name,
480 const unsigned char __user *ubuf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 __uint32_t len,
482 __uint32_t flags)
483{
Dave Chinnera9273ca2010-01-20 10:47:48 +1100484 unsigned char *kbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000486 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
Dave Chinner24513372014-06-25 14:58:08 +1000487 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 if (len > XATTR_SIZE_MAX)
Dave Chinner24513372014-06-25 14:58:08 +1000489 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Li Zefan0e639bd2009-04-08 15:08:04 +0800491 kbuf = memdup_user(ubuf, len);
492 if (IS_ERR(kbuf))
493 return PTR_ERR(kbuf);
Barry Naujoke8b0eba2008-04-22 17:34:31 +1000494
Dave Chinner24513372014-06-25 14:58:08 +1000495 return xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496}
497
sandeen@sandeen.net28750972008-11-25 21:20:15 -0600498int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499xfs_attrmulti_attr_remove(
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000500 struct inode *inode,
Dave Chinnera9273ca2010-01-20 10:47:48 +1100501 unsigned char *name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 __uint32_t flags)
503{
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000504 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
Dave Chinner24513372014-06-25 14:58:08 +1000505 return -EPERM;
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000506 return xfs_attr_remove(XFS_I(inode), name, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507}
508
509STATIC int
510xfs_attrmulti_by_handle(
Dave Hansen42a74f22008-02-15 14:37:46 -0800511 struct file *parfilp,
Christoph Hellwigd296d302009-01-19 02:02:57 +0100512 void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513{
514 int error;
515 xfs_attr_multiop_t *ops;
516 xfs_fsop_attrmulti_handlereq_t am_hreq;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100517 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 unsigned int i, size;
Dave Chinnera9273ca2010-01-20 10:47:48 +1100519 unsigned char *attr_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
521 if (!capable(CAP_SYS_ADMIN))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000522 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000524 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
Zhitong Wangfda168c2010-03-23 09:51:22 +1100526 /* overflow check */
527 if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
528 return -E2BIG;
529
Christoph Hellwigd296d302009-01-19 02:02:57 +0100530 dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
531 if (IS_ERR(dentry))
532 return PTR_ERR(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
Dave Chinner24513372014-06-25 14:58:08 +1000534 error = -E2BIG;
Christoph Hellwige182f572008-06-27 13:32:31 +1000535 size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 if (!size || size > 16 * PAGE_SIZE)
Christoph Hellwigd296d302009-01-19 02:02:57 +0100537 goto out_dput;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Li Zefan0e639bd2009-04-08 15:08:04 +0800539 ops = memdup_user(am_hreq.ops, size);
540 if (IS_ERR(ops)) {
Dave Chinner24513372014-06-25 14:58:08 +1000541 error = PTR_ERR(ops);
Christoph Hellwigd296d302009-01-19 02:02:57 +0100542 goto out_dput;
Li Zefan0e639bd2009-04-08 15:08:04 +0800543 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Dave Chinner24513372014-06-25 14:58:08 +1000545 error = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
547 if (!attr_name)
548 goto out_kfree_ops;
549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 error = 0;
551 for (i = 0; i < am_hreq.opcount; i++) {
Dave Chinnera9273ca2010-01-20 10:47:48 +1100552 ops[i].am_error = strncpy_from_user((char *)attr_name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 ops[i].am_attrname, MAXNAMELEN);
554 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
Dave Chinner24513372014-06-25 14:58:08 +1000555 error = -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 if (ops[i].am_error < 0)
557 break;
558
559 switch (ops[i].am_opcode) {
560 case ATTR_OP_GET:
Christoph Hellwigd296d302009-01-19 02:02:57 +0100561 ops[i].am_error = xfs_attrmulti_attr_get(
562 dentry->d_inode, attr_name,
563 ops[i].am_attrvalue, &ops[i].am_length,
564 ops[i].am_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 break;
566 case ATTR_OP_SET:
Al Viroa561be72011-11-23 11:57:51 -0500567 ops[i].am_error = mnt_want_write_file(parfilp);
Dave Hansen42a74f22008-02-15 14:37:46 -0800568 if (ops[i].am_error)
569 break;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100570 ops[i].am_error = xfs_attrmulti_attr_set(
571 dentry->d_inode, attr_name,
572 ops[i].am_attrvalue, ops[i].am_length,
573 ops[i].am_flags);
Al Viro2a79f172011-12-09 08:06:57 -0500574 mnt_drop_write_file(parfilp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 break;
576 case ATTR_OP_REMOVE:
Al Viroa561be72011-11-23 11:57:51 -0500577 ops[i].am_error = mnt_want_write_file(parfilp);
Dave Hansen42a74f22008-02-15 14:37:46 -0800578 if (ops[i].am_error)
579 break;
Christoph Hellwigd296d302009-01-19 02:02:57 +0100580 ops[i].am_error = xfs_attrmulti_attr_remove(
581 dentry->d_inode, attr_name,
582 ops[i].am_flags);
Al Viro2a79f172011-12-09 08:06:57 -0500583 mnt_drop_write_file(parfilp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 break;
585 default:
Dave Chinner24513372014-06-25 14:58:08 +1000586 ops[i].am_error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 }
588 }
589
590 if (copy_to_user(am_hreq.ops, ops, size))
Dave Chinner24513372014-06-25 14:58:08 +1000591 error = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 kfree(attr_name);
594 out_kfree_ops:
595 kfree(ops);
Christoph Hellwigd296d302009-01-19 02:02:57 +0100596 out_dput:
597 dput(dentry);
Dave Chinner24513372014-06-25 14:58:08 +1000598 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599}
600
sandeen@sandeen.netd5547f92008-11-25 21:20:08 -0600601int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602xfs_ioc_space(
Christoph Hellwig993386c2007-08-28 16:12:30 +1000603 struct xfs_inode *ip,
Alexey Dobriyanf37ea142006-09-28 10:52:04 +1000604 struct inode *inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 struct file *filp,
606 int ioflags,
607 unsigned int cmd,
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -0600608 xfs_flock64_t *bf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609{
Christoph Hellwig865e9442013-10-12 00:55:08 -0700610 struct iattr iattr;
Christoph Hellwig8add71c2015-02-02 09:53:56 +1100611 enum xfs_prealloc_flags flags = 0;
Christoph Hellwig781355c2015-02-16 11:59:50 +1100612 uint iolock = XFS_IOLOCK_EXCL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 int error;
614
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -0600615 /*
616 * Only allow the sys admin to reserve space unless
617 * unwritten extents are enabled.
618 */
619 if (!xfs_sb_version_hasextflgbit(&ip->i_mount->m_sb) &&
620 !capable(CAP_SYS_ADMIN))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000621 return -EPERM;
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -0600622
Alexey Dobriyanf37ea142006-09-28 10:52:04 +1000623 if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000624 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
Eric Sandeenad4a8ac2005-09-02 16:41:16 +1000626 if (!(filp->f_mode & FMODE_WRITE))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000627 return -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
Alexey Dobriyanf37ea142006-09-28 10:52:04 +1000629 if (!S_ISREG(inode->i_mode))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000630 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
Christoph Hellwig8add71c2015-02-02 09:53:56 +1100632 if (filp->f_flags & O_DSYNC)
633 flags |= XFS_PREALLOC_SYNC;
634 if (ioflags & XFS_IO_INVIS)
635 flags |= XFS_PREALLOC_INVISIBLE;
636
Jan Karad9457dc2012-06-12 16:20:39 +0200637 error = mnt_want_write_file(filp);
638 if (error)
639 return error;
Christoph Hellwig865e9442013-10-12 00:55:08 -0700640
Christoph Hellwig781355c2015-02-16 11:59:50 +1100641 xfs_ilock(ip, iolock);
642 error = xfs_break_layouts(inode, &iolock);
643 if (error)
644 goto out_unlock;
Christoph Hellwig865e9442013-10-12 00:55:08 -0700645
646 switch (bf->l_whence) {
647 case 0: /*SEEK_SET*/
648 break;
649 case 1: /*SEEK_CUR*/
650 bf->l_start += filp->f_pos;
651 break;
652 case 2: /*SEEK_END*/
653 bf->l_start += XFS_ISIZE(ip);
654 break;
655 default:
Dave Chinner24513372014-06-25 14:58:08 +1000656 error = -EINVAL;
Christoph Hellwig865e9442013-10-12 00:55:08 -0700657 goto out_unlock;
658 }
659
660 /*
661 * length of <= 0 for resv/unresv/zero is invalid. length for
662 * alloc/free is ignored completely and we have no idea what userspace
663 * might have set it to, so set it to zero to allow range
664 * checks to pass.
665 */
666 switch (cmd) {
667 case XFS_IOC_ZERO_RANGE:
668 case XFS_IOC_RESVSP:
669 case XFS_IOC_RESVSP64:
670 case XFS_IOC_UNRESVSP:
671 case XFS_IOC_UNRESVSP64:
672 if (bf->l_len <= 0) {
Dave Chinner24513372014-06-25 14:58:08 +1000673 error = -EINVAL;
Christoph Hellwig865e9442013-10-12 00:55:08 -0700674 goto out_unlock;
675 }
676 break;
677 default:
678 bf->l_len = 0;
679 break;
680 }
681
682 if (bf->l_start < 0 ||
Christoph Hellwig8add71c2015-02-02 09:53:56 +1100683 bf->l_start > inode->i_sb->s_maxbytes ||
Christoph Hellwig865e9442013-10-12 00:55:08 -0700684 bf->l_start + bf->l_len < 0 ||
Christoph Hellwig8add71c2015-02-02 09:53:56 +1100685 bf->l_start + bf->l_len >= inode->i_sb->s_maxbytes) {
Dave Chinner24513372014-06-25 14:58:08 +1000686 error = -EINVAL;
Christoph Hellwig865e9442013-10-12 00:55:08 -0700687 goto out_unlock;
688 }
689
690 switch (cmd) {
691 case XFS_IOC_ZERO_RANGE:
Christoph Hellwig8add71c2015-02-02 09:53:56 +1100692 flags |= XFS_PREALLOC_SET;
Christoph Hellwig865e9442013-10-12 00:55:08 -0700693 error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
Christoph Hellwig865e9442013-10-12 00:55:08 -0700694 break;
695 case XFS_IOC_RESVSP:
696 case XFS_IOC_RESVSP64:
Christoph Hellwig8add71c2015-02-02 09:53:56 +1100697 flags |= XFS_PREALLOC_SET;
Christoph Hellwig865e9442013-10-12 00:55:08 -0700698 error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
699 XFS_BMAPI_PREALLOC);
Christoph Hellwig865e9442013-10-12 00:55:08 -0700700 break;
701 case XFS_IOC_UNRESVSP:
702 case XFS_IOC_UNRESVSP64:
703 error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
704 break;
705 case XFS_IOC_ALLOCSP:
706 case XFS_IOC_ALLOCSP64:
707 case XFS_IOC_FREESP:
708 case XFS_IOC_FREESP64:
Christoph Hellwig8add71c2015-02-02 09:53:56 +1100709 flags |= XFS_PREALLOC_CLEAR;
Christoph Hellwig865e9442013-10-12 00:55:08 -0700710 if (bf->l_start > XFS_ISIZE(ip)) {
711 error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
712 bf->l_start - XFS_ISIZE(ip), 0);
713 if (error)
714 goto out_unlock;
715 }
716
717 iattr.ia_valid = ATTR_SIZE;
718 iattr.ia_size = bf->l_start;
719
720 error = xfs_setattr_size(ip, &iattr);
Christoph Hellwig865e9442013-10-12 00:55:08 -0700721 break;
722 default:
723 ASSERT(0);
Dave Chinner24513372014-06-25 14:58:08 +1000724 error = -EINVAL;
Christoph Hellwig865e9442013-10-12 00:55:08 -0700725 }
726
727 if (error)
728 goto out_unlock;
729
Christoph Hellwig8add71c2015-02-02 09:53:56 +1100730 error = xfs_update_prealloc_flags(ip, flags);
Christoph Hellwig865e9442013-10-12 00:55:08 -0700731
732out_unlock:
Christoph Hellwig781355c2015-02-16 11:59:50 +1100733 xfs_iunlock(ip, iolock);
Jan Karad9457dc2012-06-12 16:20:39 +0200734 mnt_drop_write_file(filp);
Dave Chinner24513372014-06-25 14:58:08 +1000735 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736}
737
738STATIC int
739xfs_ioc_bulkstat(
740 xfs_mount_t *mp,
741 unsigned int cmd,
742 void __user *arg)
743{
744 xfs_fsop_bulkreq_t bulkreq;
745 int count; /* # of records returned */
746 xfs_ino_t inlast; /* last inode number */
747 int done;
748 int error;
749
750 /* done = 1 if there are more stats to get and if bulkstat */
751 /* should be called again (unused here, but used in dmapi) */
752
753 if (!capable(CAP_SYS_ADMIN))
754 return -EPERM;
755
756 if (XFS_FORCED_SHUTDOWN(mp))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000757 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
759 if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000760 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
762 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000763 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
765 if ((count = bulkreq.icount) <= 0)
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000766 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
Lachlan McIlroycd57e592007-11-23 16:30:32 +1100768 if (bulkreq.ubuffer == NULL)
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000769 return -EINVAL;
Lachlan McIlroycd57e592007-11-23 16:30:32 +1100770
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 if (cmd == XFS_IOC_FSINUMBERS)
772 error = xfs_inumbers(mp, &inlast, &count,
Michal Marekfaa63e92007-07-11 11:10:19 +1000773 bulkreq.ubuffer, xfs_inumbers_fmt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
Christoph Hellwigd716f8e2014-07-24 12:07:15 +1000775 error = xfs_bulkstat_one(mp, inlast, bulkreq.ubuffer,
776 sizeof(xfs_bstat_t), NULL, &done);
Lachlan McIlroycd57e592007-11-23 16:30:32 +1100777 else /* XFS_IOC_FSBULKSTAT */
Christoph Hellwig7dce11d2010-06-23 18:11:11 +1000778 error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
779 sizeof(xfs_bstat_t), bulkreq.ubuffer,
780 &done);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781
782 if (error)
Dave Chinner24513372014-06-25 14:58:08 +1000783 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
785 if (bulkreq.ocount != NULL) {
786 if (copy_to_user(bulkreq.lastip, &inlast,
787 sizeof(xfs_ino_t)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000788 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
790 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000791 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 }
793
794 return 0;
795}
796
797STATIC int
798xfs_ioc_fsgeometry_v1(
799 xfs_mount_t *mp,
800 void __user *arg)
801{
Alex Eldereeb20362011-03-01 17:50:00 +0000802 xfs_fsop_geom_t fsgeo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 int error;
804
Alex Eldereeb20362011-03-01 17:50:00 +0000805 error = xfs_fs_geometry(mp, &fsgeo, 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 if (error)
Dave Chinner24513372014-06-25 14:58:08 +1000807 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
Alex Eldereeb20362011-03-01 17:50:00 +0000809 /*
810 * Caller should have passed an argument of type
811 * xfs_fsop_geom_v1_t. This is a proper subset of the
812 * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
813 */
814 if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000815 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 return 0;
817}
818
819STATIC int
820xfs_ioc_fsgeometry(
821 xfs_mount_t *mp,
822 void __user *arg)
823{
824 xfs_fsop_geom_t fsgeo;
825 int error;
826
827 error = xfs_fs_geometry(mp, &fsgeo, 4);
828 if (error)
Dave Chinner24513372014-06-25 14:58:08 +1000829 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
831 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +1000832 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 return 0;
834}
835
836/*
837 * Linux extended inode flags interface.
838 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
840STATIC unsigned int
841xfs_merge_ioc_xflags(
842 unsigned int flags,
843 unsigned int start)
844{
845 unsigned int xflags = start;
846
Eric Sandeen39058a02007-02-10 18:37:10 +1100847 if (flags & FS_IMMUTABLE_FL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 xflags |= XFS_XFLAG_IMMUTABLE;
849 else
850 xflags &= ~XFS_XFLAG_IMMUTABLE;
Eric Sandeen39058a02007-02-10 18:37:10 +1100851 if (flags & FS_APPEND_FL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 xflags |= XFS_XFLAG_APPEND;
853 else
854 xflags &= ~XFS_XFLAG_APPEND;
Eric Sandeen39058a02007-02-10 18:37:10 +1100855 if (flags & FS_SYNC_FL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 xflags |= XFS_XFLAG_SYNC;
857 else
858 xflags &= ~XFS_XFLAG_SYNC;
Eric Sandeen39058a02007-02-10 18:37:10 +1100859 if (flags & FS_NOATIME_FL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 xflags |= XFS_XFLAG_NOATIME;
861 else
862 xflags &= ~XFS_XFLAG_NOATIME;
Eric Sandeen39058a02007-02-10 18:37:10 +1100863 if (flags & FS_NODUMP_FL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 xflags |= XFS_XFLAG_NODUMP;
865 else
866 xflags &= ~XFS_XFLAG_NODUMP;
867
868 return xflags;
869}
870
871STATIC unsigned int
872xfs_di2lxflags(
873 __uint16_t di_flags)
874{
875 unsigned int flags = 0;
876
877 if (di_flags & XFS_DIFLAG_IMMUTABLE)
Eric Sandeen39058a02007-02-10 18:37:10 +1100878 flags |= FS_IMMUTABLE_FL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 if (di_flags & XFS_DIFLAG_APPEND)
Eric Sandeen39058a02007-02-10 18:37:10 +1100880 flags |= FS_APPEND_FL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 if (di_flags & XFS_DIFLAG_SYNC)
Eric Sandeen39058a02007-02-10 18:37:10 +1100882 flags |= FS_SYNC_FL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 if (di_flags & XFS_DIFLAG_NOATIME)
Eric Sandeen39058a02007-02-10 18:37:10 +1100884 flags |= FS_NOATIME_FL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 if (di_flags & XFS_DIFLAG_NODUMP)
Eric Sandeen39058a02007-02-10 18:37:10 +1100886 flags |= FS_NODUMP_FL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 return flags;
888}
889
890STATIC int
Christoph Hellwigc83bfab2007-10-11 17:47:00 +1000891xfs_ioc_fsgetxattr(
892 xfs_inode_t *ip,
893 int attr,
894 void __user *arg)
895{
896 struct fsxattr fa;
897
Dan Rosenberga122eb22010-09-06 18:24:57 -0400898 memset(&fa, 0, sizeof(struct fsxattr));
899
Christoph Hellwigc83bfab2007-10-11 17:47:00 +1000900 xfs_ilock(ip, XFS_ILOCK_SHARED);
901 fa.fsx_xflags = xfs_ip2xflags(ip);
902 fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
Arkadiusz Mi?kiewicz67430992010-09-26 06:10:18 +0000903 fa.fsx_projid = xfs_get_projid(ip);
Christoph Hellwigc83bfab2007-10-11 17:47:00 +1000904
905 if (attr) {
906 if (ip->i_afp) {
907 if (ip->i_afp->if_flags & XFS_IFEXTENTS)
908 fa.fsx_nextents = ip->i_afp->if_bytes /
909 sizeof(xfs_bmbt_rec_t);
910 else
911 fa.fsx_nextents = ip->i_d.di_anextents;
912 } else
913 fa.fsx_nextents = 0;
914 } else {
915 if (ip->i_df.if_flags & XFS_IFEXTENTS)
916 fa.fsx_nextents = ip->i_df.if_bytes /
917 sizeof(xfs_bmbt_rec_t);
918 else
919 fa.fsx_nextents = ip->i_d.di_nextents;
920 }
921 xfs_iunlock(ip, XFS_ILOCK_SHARED);
922
923 if (copy_to_user(arg, &fa, sizeof(fa)))
924 return -EFAULT;
925 return 0;
926}
927
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000928STATIC void
929xfs_set_diflags(
930 struct xfs_inode *ip,
931 unsigned int xflags)
932{
933 unsigned int di_flags;
934
935 /* can't set PREALLOC this way, just preserve it */
936 di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
937 if (xflags & XFS_XFLAG_IMMUTABLE)
938 di_flags |= XFS_DIFLAG_IMMUTABLE;
939 if (xflags & XFS_XFLAG_APPEND)
940 di_flags |= XFS_DIFLAG_APPEND;
941 if (xflags & XFS_XFLAG_SYNC)
942 di_flags |= XFS_DIFLAG_SYNC;
943 if (xflags & XFS_XFLAG_NOATIME)
944 di_flags |= XFS_DIFLAG_NOATIME;
945 if (xflags & XFS_XFLAG_NODUMP)
946 di_flags |= XFS_DIFLAG_NODUMP;
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000947 if (xflags & XFS_XFLAG_NODEFRAG)
948 di_flags |= XFS_DIFLAG_NODEFRAG;
949 if (xflags & XFS_XFLAG_FILESTREAM)
950 di_flags |= XFS_DIFLAG_FILESTREAM;
Al Viroabbede12011-07-26 02:31:30 -0400951 if (S_ISDIR(ip->i_d.di_mode)) {
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000952 if (xflags & XFS_XFLAG_RTINHERIT)
953 di_flags |= XFS_DIFLAG_RTINHERIT;
954 if (xflags & XFS_XFLAG_NOSYMLINKS)
955 di_flags |= XFS_DIFLAG_NOSYMLINKS;
956 if (xflags & XFS_XFLAG_EXTSZINHERIT)
957 di_flags |= XFS_DIFLAG_EXTSZINHERIT;
Dave Chinner9336e3a2014-10-02 09:18:40 +1000958 if (xflags & XFS_XFLAG_PROJINHERIT)
959 di_flags |= XFS_DIFLAG_PROJINHERIT;
Al Viroabbede12011-07-26 02:31:30 -0400960 } else if (S_ISREG(ip->i_d.di_mode)) {
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000961 if (xflags & XFS_XFLAG_REALTIME)
962 di_flags |= XFS_DIFLAG_REALTIME;
963 if (xflags & XFS_XFLAG_EXTSIZE)
964 di_flags |= XFS_DIFLAG_EXTSIZE;
965 }
966
967 ip->i_d.di_flags = di_flags;
968}
969
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000970STATIC void
971xfs_diflags_to_linux(
972 struct xfs_inode *ip)
973{
David Chinnere4f75292008-08-13 16:00:45 +1000974 struct inode *inode = VFS_I(ip);
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000975 unsigned int xflags = xfs_ip2xflags(ip);
976
977 if (xflags & XFS_XFLAG_IMMUTABLE)
978 inode->i_flags |= S_IMMUTABLE;
979 else
980 inode->i_flags &= ~S_IMMUTABLE;
981 if (xflags & XFS_XFLAG_APPEND)
982 inode->i_flags |= S_APPEND;
983 else
984 inode->i_flags &= ~S_APPEND;
985 if (xflags & XFS_XFLAG_SYNC)
986 inode->i_flags |= S_SYNC;
987 else
988 inode->i_flags &= ~S_SYNC;
989 if (xflags & XFS_XFLAG_NOATIME)
990 inode->i_flags |= S_NOATIME;
991 else
992 inode->i_flags &= ~S_NOATIME;
993}
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000994
Dave Chinner29a17c02015-02-02 10:14:25 +1100995static int
996xfs_ioctl_setattr_xflags(
997 struct xfs_trans *tp,
998 struct xfs_inode *ip,
999 struct fsxattr *fa)
1000{
1001 struct xfs_mount *mp = ip->i_mount;
1002
1003 /* Can't change realtime flag if any extents are allocated. */
1004 if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1005 XFS_IS_REALTIME_INODE(ip) != (fa->fsx_xflags & XFS_XFLAG_REALTIME))
1006 return -EINVAL;
1007
1008 /* If realtime flag is set then must have realtime device */
1009 if (fa->fsx_xflags & XFS_XFLAG_REALTIME) {
1010 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
1011 (ip->i_d.di_extsize % mp->m_sb.sb_rextsize))
1012 return -EINVAL;
1013 }
1014
1015 /*
1016 * Can't modify an immutable/append-only file unless
1017 * we have appropriate permission.
1018 */
1019 if (((ip->i_d.di_flags & (XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND)) ||
1020 (fa->fsx_xflags & (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
1021 !capable(CAP_LINUX_IMMUTABLE))
1022 return -EPERM;
1023
Dave Chinner29a17c02015-02-02 10:14:25 +11001024 xfs_set_diflags(ip, fa->fsx_xflags);
1025 xfs_diflags_to_linux(ip);
1026 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1027 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1028 XFS_STATS_INC(xs_ig_attrchg);
1029 return 0;
1030}
1031
Dave Chinner8f3d17a2015-02-02 10:15:35 +11001032/*
1033 * Set up the transaction structure for the setattr operation, checking that we
1034 * have permission to do so. On success, return a clean transaction and the
1035 * inode locked exclusively ready for further operation specific checks. On
1036 * failure, return an error without modifying or locking the inode.
1037 */
1038static struct xfs_trans *
1039xfs_ioctl_setattr_get_trans(
1040 struct xfs_inode *ip)
1041{
1042 struct xfs_mount *mp = ip->i_mount;
1043 struct xfs_trans *tp;
1044 int error;
1045
1046 if (mp->m_flags & XFS_MOUNT_RDONLY)
1047 return ERR_PTR(-EROFS);
1048 if (XFS_FORCED_SHUTDOWN(mp))
1049 return ERR_PTR(-EIO);
1050
1051 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
1052 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
1053 if (error)
1054 goto out_cancel;
1055
1056 xfs_ilock(ip, XFS_ILOCK_EXCL);
1057 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1058
1059 /*
1060 * CAP_FOWNER overrides the following restrictions:
1061 *
1062 * The user ID of the calling process must be equal to the file owner
1063 * ID, except in cases where the CAP_FSETID capability is applicable.
1064 */
1065 if (!inode_owner_or_capable(VFS_I(ip))) {
1066 error = -EPERM;
1067 goto out_cancel;
1068 }
1069
1070 if (mp->m_flags & XFS_MOUNT_WSYNC)
1071 xfs_trans_set_sync(tp);
1072
1073 return tp;
1074
1075out_cancel:
1076 xfs_trans_cancel(tp, 0);
1077 return ERR_PTR(error);
1078}
1079
Iustin Pop9b94fcc2015-02-02 10:26:26 +11001080/*
1081 * extent size hint validation is somewhat cumbersome. Rules are:
1082 *
1083 * 1. extent size hint is only valid for directories and regular files
1084 * 2. XFS_XFLAG_EXTSIZE is only valid for regular files
1085 * 3. XFS_XFLAG_EXTSZINHERIT is only valid for directories.
1086 * 4. can only be changed on regular files if no extents are allocated
1087 * 5. can be changed on directories at any time
1088 * 6. extsize hint of 0 turns off hints, clears inode flags.
1089 * 7. Extent size must be a multiple of the appropriate block size.
1090 * 8. for non-realtime files, the extent size hint must be limited
1091 * to half the AG size to avoid alignment extending the extent beyond the
1092 * limits of the AG.
1093 */
kbuild test robotf92090e2015-02-05 11:13:21 +11001094static int
Dave Chinnerd4388d3c2015-02-02 10:22:20 +11001095xfs_ioctl_setattr_check_extsize(
1096 struct xfs_inode *ip,
1097 struct fsxattr *fa)
1098{
1099 struct xfs_mount *mp = ip->i_mount;
1100
Iustin Pop9b94fcc2015-02-02 10:26:26 +11001101 if ((fa->fsx_xflags & XFS_XFLAG_EXTSIZE) && !S_ISREG(ip->i_d.di_mode))
1102 return -EINVAL;
1103
1104 if ((fa->fsx_xflags & XFS_XFLAG_EXTSZINHERIT) &&
1105 !S_ISDIR(ip->i_d.di_mode))
1106 return -EINVAL;
1107
1108 if (S_ISREG(ip->i_d.di_mode) && ip->i_d.di_nextents &&
Dave Chinnerd4388d3c2015-02-02 10:22:20 +11001109 ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) != fa->fsx_extsize))
1110 return -EINVAL;
1111
Dave Chinnerd4388d3c2015-02-02 10:22:20 +11001112 if (fa->fsx_extsize != 0) {
1113 xfs_extlen_t size;
1114 xfs_fsblock_t extsize_fsb;
1115
1116 extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
1117 if (extsize_fsb > MAXEXTLEN)
1118 return -EINVAL;
1119
1120 if (XFS_IS_REALTIME_INODE(ip) ||
1121 (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1122 size = mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog;
1123 } else {
1124 size = mp->m_sb.sb_blocksize;
1125 if (extsize_fsb > mp->m_sb.sb_agblocks / 2)
1126 return -EINVAL;
1127 }
1128
1129 if (fa->fsx_extsize % size)
1130 return -EINVAL;
Iustin Pop9b94fcc2015-02-02 10:26:26 +11001131 } else
1132 fa->fsx_xflags &= ~(XFS_XFLAG_EXTSIZE | XFS_XFLAG_EXTSZINHERIT);
1133
Dave Chinnerd4388d3c2015-02-02 10:22:20 +11001134 return 0;
1135}
1136
kbuild test robotf92090e2015-02-05 11:13:21 +11001137static int
Dave Chinner23bd0732015-02-02 10:22:53 +11001138xfs_ioctl_setattr_check_projid(
1139 struct xfs_inode *ip,
1140 struct fsxattr *fa)
1141{
1142 /* Disallow 32bit project ids if projid32bit feature is not enabled. */
1143 if (fa->fsx_projid > (__uint16_t)-1 &&
1144 !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
1145 return -EINVAL;
1146
1147 /*
1148 * Project Quota ID state is only allowed to change from within the init
1149 * namespace. Enforce that restriction only if we are trying to change
1150 * the quota ID state. Everything else is allowed in user namespaces.
1151 */
1152 if (current_user_ns() == &init_user_ns)
1153 return 0;
1154
1155 if (xfs_get_projid(ip) != fa->fsx_projid)
1156 return -EINVAL;
1157 if ((fa->fsx_xflags & XFS_XFLAG_PROJINHERIT) !=
1158 (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT))
1159 return -EINVAL;
1160
1161 return 0;
1162}
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001163
1164STATIC int
1165xfs_ioctl_setattr(
1166 xfs_inode_t *ip,
Dave Chinnerfd179b92015-02-02 10:16:25 +11001167 struct fsxattr *fa)
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001168{
1169 struct xfs_mount *mp = ip->i_mount;
1170 struct xfs_trans *tp;
Christoph Hellwig7d095252009-06-08 15:33:32 +02001171 struct xfs_dquot *udqp = NULL;
Chandra Seetharaman92f8ff72013-07-11 00:00:40 -05001172 struct xfs_dquot *pdqp = NULL;
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001173 struct xfs_dquot *olddquot = NULL;
1174 int code;
1175
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10001176 trace_xfs_ioctl_setattr(ip);
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001177
Dave Chinner23bd0732015-02-02 10:22:53 +11001178 code = xfs_ioctl_setattr_check_projid(ip, fa);
1179 if (code)
1180 return code;
Arkadiusz Mi?kiewicz23963e52010-08-26 10:19:43 +00001181
1182 /*
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001183 * If disk quotas is on, we make sure that the dquots do exist on disk,
1184 * before we start any other transactions. Trying to do this later
1185 * is messy. We don't care to take a readlock to look at the ids
1186 * in inode here, because we can't hold it across the trans_reserve.
1187 * If the IDs do change before we take the ilock, we're covered
1188 * because the i_*dquot fields will get updated anyway.
1189 */
Dave Chinnerfd179b92015-02-02 10:16:25 +11001190 if (XFS_IS_QUOTA_ON(mp)) {
Christoph Hellwig7d095252009-06-08 15:33:32 +02001191 code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001192 ip->i_d.di_gid, fa->fsx_projid,
Chandra Seetharaman92f8ff72013-07-11 00:00:40 -05001193 XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001194 if (code)
1195 return code;
1196 }
1197
Dave Chinner8f3d17a2015-02-02 10:15:35 +11001198 tp = xfs_ioctl_setattr_get_trans(ip);
1199 if (IS_ERR(tp)) {
1200 code = PTR_ERR(tp);
1201 goto error_free_dquots;
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001202 }
1203
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001204
Dave Chinnerfd179b92015-02-02 10:16:25 +11001205 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp) &&
1206 xfs_get_projid(ip) != fa->fsx_projid) {
1207 code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL, pdqp,
1208 capable(CAP_FOWNER) ? XFS_QMOPT_FORCE_RES : 0);
1209 if (code) /* out of quota */
Dave Chinnerd4388d3c2015-02-02 10:22:20 +11001210 goto error_trans_cancel;
Dave Chinnerfd179b92015-02-02 10:16:25 +11001211 }
1212
Dave Chinnerd4388d3c2015-02-02 10:22:20 +11001213 code = xfs_ioctl_setattr_check_extsize(ip, fa);
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001214 if (code)
Dave Chinnerd4388d3c2015-02-02 10:22:20 +11001215 goto error_trans_cancel;
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001216
Dave Chinner29a17c02015-02-02 10:14:25 +11001217 code = xfs_ioctl_setattr_xflags(tp, ip, fa);
1218 if (code)
Dave Chinnerd4388d3c2015-02-02 10:22:20 +11001219 goto error_trans_cancel;
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001220
1221 /*
Dave Chinnerfd179b92015-02-02 10:16:25 +11001222 * Change file ownership. Must be the owner or privileged. CAP_FSETID
1223 * overrides the following restrictions:
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001224 *
Dave Chinnerfd179b92015-02-02 10:16:25 +11001225 * The set-user-ID and set-group-ID bits of a file will be cleared upon
1226 * successful return from chown()
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001227 */
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001228
Dave Chinnerfd179b92015-02-02 10:16:25 +11001229 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1230 !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))
1231 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
1232
1233 /* Change the ownerships and register project quota modifications */
1234 if (xfs_get_projid(ip) != fa->fsx_projid) {
1235 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
1236 olddquot = xfs_qm_vop_chown(tp, ip,
1237 &ip->i_pdquot, pdqp);
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001238 }
Dave Chinnerfd179b92015-02-02 10:16:25 +11001239 ASSERT(ip->i_d.di_version > 1);
1240 xfs_set_projid(ip, fa->fsx_projid);
Christoph Hellwigf13fae22008-07-21 16:16:15 +10001241 }
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001242
Dave Chinnera8727032014-10-02 09:20:30 +10001243 /*
1244 * Only set the extent size hint if we've already determined that the
1245 * extent size hint should be set on the inode. If no extent size flags
1246 * are set on the inode then unconditionally clear the extent size hint.
1247 */
Dave Chinnerfd179b92015-02-02 10:16:25 +11001248 if (ip->i_d.di_flags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
1249 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1250 else
1251 ip->i_d.di_extsize = 0;
Dave Chinnera8727032014-10-02 09:20:30 +10001252
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001253 code = xfs_trans_commit(tp, 0);
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001254
1255 /*
1256 * Release any dquot(s) the inode had kept before chown.
1257 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001258 xfs_qm_dqrele(olddquot);
1259 xfs_qm_dqrele(udqp);
Chandra Seetharaman92f8ff72013-07-11 00:00:40 -05001260 xfs_qm_dqrele(pdqp);
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001261
Christoph Hellwig288699f2010-06-23 18:11:15 +10001262 return code;
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001263
Dave Chinnerd4388d3c2015-02-02 10:22:20 +11001264error_trans_cancel:
Dave Chinner8f3d17a2015-02-02 10:15:35 +11001265 xfs_trans_cancel(tp, 0);
1266error_free_dquots:
Christoph Hellwig7d095252009-06-08 15:33:32 +02001267 xfs_qm_dqrele(udqp);
Chandra Seetharaman92f8ff72013-07-11 00:00:40 -05001268 xfs_qm_dqrele(pdqp);
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001269 return code;
1270}
1271
Christoph Hellwigc83bfab2007-10-11 17:47:00 +10001272STATIC int
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001273xfs_ioc_fssetxattr(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 xfs_inode_t *ip,
1275 struct file *filp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 void __user *arg)
1277{
1278 struct fsxattr fa;
Jan Karad9457dc2012-06-12 16:20:39 +02001279 int error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001280
1281 if (copy_from_user(&fa, arg, sizeof(fa)))
1282 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Jan Karad9457dc2012-06-12 16:20:39 +02001284 error = mnt_want_write_file(filp);
1285 if (error)
1286 return error;
Dave Chinnerfd179b92015-02-02 10:16:25 +11001287 error = xfs_ioctl_setattr(ip, &fa);
Jan Karad9457dc2012-06-12 16:20:39 +02001288 mnt_drop_write_file(filp);
Dave Chinner24513372014-06-25 14:58:08 +10001289 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001290}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001292STATIC int
1293xfs_ioc_getxflags(
1294 xfs_inode_t *ip,
1295 void __user *arg)
1296{
1297 unsigned int flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001299 flags = xfs_di2lxflags(ip->i_d.di_flags);
1300 if (copy_to_user(arg, &flags, sizeof(flags)))
1301 return -EFAULT;
1302 return 0;
1303}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001305STATIC int
1306xfs_ioc_setxflags(
Dave Chinnerf96291f2015-02-02 10:15:56 +11001307 struct xfs_inode *ip,
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001308 struct file *filp,
1309 void __user *arg)
1310{
Dave Chinnerf96291f2015-02-02 10:15:56 +11001311 struct xfs_trans *tp;
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001312 struct fsxattr fa;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001313 unsigned int flags;
Dave Chinnerf96291f2015-02-02 10:15:56 +11001314 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001316 if (copy_from_user(&flags, arg, sizeof(flags)))
1317 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001319 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1320 FS_NOATIME_FL | FS_NODUMP_FL | \
1321 FS_SYNC_FL))
1322 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
Christoph Hellwig25fe55e2008-07-18 17:13:20 +10001324 fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
Jan Karad9457dc2012-06-12 16:20:39 +02001326 error = mnt_want_write_file(filp);
1327 if (error)
1328 return error;
Dave Chinnerf96291f2015-02-02 10:15:56 +11001329
1330 tp = xfs_ioctl_setattr_get_trans(ip);
1331 if (IS_ERR(tp)) {
1332 error = PTR_ERR(tp);
1333 goto out_drop_write;
1334 }
1335
1336 error = xfs_ioctl_setattr_xflags(tp, ip, &fa);
1337 if (error) {
1338 xfs_trans_cancel(tp, 0);
1339 goto out_drop_write;
1340 }
1341
1342 error = xfs_trans_commit(tp, 0);
1343out_drop_write:
Jan Karad9457dc2012-06-12 16:20:39 +02001344 mnt_drop_write_file(filp);
Dave Chinner24513372014-06-25 14:58:08 +10001345 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346}
1347
1348STATIC int
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001349xfs_getbmap_format(void **ap, struct getbmapx *bmv, int *full)
1350{
Dave Chinnerb972d072014-09-29 10:46:22 +10001351 struct getbmap __user *base = (struct getbmap __user *)*ap;
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001352
1353 /* copy only getbmap portion (not getbmapx) */
1354 if (copy_to_user(base, bmv, sizeof(struct getbmap)))
Dave Chinner24513372014-06-25 14:58:08 +10001355 return -EFAULT;
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001356
1357 *ap += sizeof(struct getbmap);
1358 return 0;
1359}
1360
1361STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362xfs_ioc_getbmap(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001363 struct xfs_inode *ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 int ioflags,
1365 unsigned int cmd,
1366 void __user *arg)
1367{
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001368 struct getbmapx bmx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 int error;
1370
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001371 if (copy_from_user(&bmx, arg, sizeof(struct getbmapx)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001372 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001374 if (bmx.bmv_count < 2)
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001375 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001377 bmx.bmv_iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
Dave Chinnerb92cc59f62014-08-04 13:28:20 +10001378 if (ioflags & XFS_IO_INVIS)
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001379 bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001381 error = xfs_getbmap(ip, &bmx, xfs_getbmap_format,
Dave Chinnerb972d072014-09-29 10:46:22 +10001382 (__force struct getbmap *)arg+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 if (error)
Dave Chinner24513372014-06-25 14:58:08 +10001384 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001386 /* copy back header - only size of getbmap */
1387 if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001388 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 return 0;
1390}
1391
1392STATIC int
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001393xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
1394{
Dave Chinnerb972d072014-09-29 10:46:22 +10001395 struct getbmapx __user *base = (struct getbmapx __user *)*ap;
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001396
1397 if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
Dave Chinner24513372014-06-25 14:58:08 +10001398 return -EFAULT;
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001399
1400 *ap += sizeof(struct getbmapx);
1401 return 0;
1402}
1403
1404STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405xfs_ioc_getbmapx(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001406 struct xfs_inode *ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 void __user *arg)
1408{
1409 struct getbmapx bmx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 int error;
1411
1412 if (copy_from_user(&bmx, arg, sizeof(bmx)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001413 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
1415 if (bmx.bmv_count < 2)
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001416 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001418 if (bmx.bmv_iflags & (~BMV_IF_VALID))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001419 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001421 error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
Dave Chinnerb972d072014-09-29 10:46:22 +10001422 (__force struct getbmapx *)arg+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 if (error)
Dave Chinner24513372014-06-25 14:58:08 +10001424 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
Eric Sandeen8a7141a2008-11-28 14:23:35 +11001426 /* copy back header */
1427 if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001428 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
1430 return 0;
1431}
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001432
Dave Chinnera133d952013-08-12 20:49:48 +10001433int
1434xfs_ioc_swapext(
1435 xfs_swapext_t *sxp)
1436{
1437 xfs_inode_t *ip, *tip;
1438 struct fd f, tmp;
1439 int error = 0;
1440
1441 /* Pull information for the target fd */
1442 f = fdget((int)sxp->sx_fdtarget);
1443 if (!f.file) {
Dave Chinner24513372014-06-25 14:58:08 +10001444 error = -EINVAL;
Dave Chinnera133d952013-08-12 20:49:48 +10001445 goto out;
1446 }
1447
1448 if (!(f.file->f_mode & FMODE_WRITE) ||
1449 !(f.file->f_mode & FMODE_READ) ||
1450 (f.file->f_flags & O_APPEND)) {
Dave Chinner24513372014-06-25 14:58:08 +10001451 error = -EBADF;
Dave Chinnera133d952013-08-12 20:49:48 +10001452 goto out_put_file;
1453 }
1454
1455 tmp = fdget((int)sxp->sx_fdtmp);
1456 if (!tmp.file) {
Dave Chinner24513372014-06-25 14:58:08 +10001457 error = -EINVAL;
Dave Chinnera133d952013-08-12 20:49:48 +10001458 goto out_put_file;
1459 }
1460
1461 if (!(tmp.file->f_mode & FMODE_WRITE) ||
1462 !(tmp.file->f_mode & FMODE_READ) ||
1463 (tmp.file->f_flags & O_APPEND)) {
Dave Chinner24513372014-06-25 14:58:08 +10001464 error = -EBADF;
Dave Chinnera133d952013-08-12 20:49:48 +10001465 goto out_put_tmp_file;
1466 }
1467
1468 if (IS_SWAPFILE(file_inode(f.file)) ||
1469 IS_SWAPFILE(file_inode(tmp.file))) {
Dave Chinner24513372014-06-25 14:58:08 +10001470 error = -EINVAL;
Dave Chinnera133d952013-08-12 20:49:48 +10001471 goto out_put_tmp_file;
1472 }
1473
1474 ip = XFS_I(file_inode(f.file));
1475 tip = XFS_I(file_inode(tmp.file));
1476
1477 if (ip->i_mount != tip->i_mount) {
Dave Chinner24513372014-06-25 14:58:08 +10001478 error = -EINVAL;
Dave Chinnera133d952013-08-12 20:49:48 +10001479 goto out_put_tmp_file;
1480 }
1481
1482 if (ip->i_ino == tip->i_ino) {
Dave Chinner24513372014-06-25 14:58:08 +10001483 error = -EINVAL;
Dave Chinnera133d952013-08-12 20:49:48 +10001484 goto out_put_tmp_file;
1485 }
1486
1487 if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
Dave Chinner24513372014-06-25 14:58:08 +10001488 error = -EIO;
Dave Chinnera133d952013-08-12 20:49:48 +10001489 goto out_put_tmp_file;
1490 }
1491
1492 error = xfs_swap_extents(ip, tip, sxp);
1493
1494 out_put_tmp_file:
1495 fdput(tmp);
1496 out_put_file:
1497 fdput(f);
1498 out:
1499 return error;
1500}
1501
Christoph Hellwig4d4be482008-12-09 04:47:33 -05001502/*
1503 * Note: some of the ioctl's return positive numbers as a
1504 * byte count indicating success, such as readlink_by_handle.
1505 * So we don't "sign flip" like most other routines. This means
1506 * true errors need to be returned as a negative value.
1507 */
1508long
1509xfs_file_ioctl(
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001510 struct file *filp,
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001511 unsigned int cmd,
Christoph Hellwig4d4be482008-12-09 04:47:33 -05001512 unsigned long p)
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001513{
Al Viro496ad9a2013-01-23 17:07:38 -05001514 struct inode *inode = file_inode(filp);
Christoph Hellwig4d4be482008-12-09 04:47:33 -05001515 struct xfs_inode *ip = XFS_I(inode);
1516 struct xfs_mount *mp = ip->i_mount;
1517 void __user *arg = (void __user *)p;
1518 int ioflags = 0;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001519 int error;
1520
Christoph Hellwig4d4be482008-12-09 04:47:33 -05001521 if (filp->f_mode & FMODE_NOCMTIME)
Dave Chinnerb92cc59f62014-08-04 13:28:20 +10001522 ioflags |= XFS_IO_INVIS;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001523
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10001524 trace_xfs_file_ioctl(ip);
Christoph Hellwig4d4be482008-12-09 04:47:33 -05001525
1526 switch (cmd) {
Christoph Hellwiga46db602011-01-07 13:02:04 +00001527 case FITRIM:
1528 return xfs_ioc_trim(mp, arg);
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001529 case XFS_IOC_ALLOCSP:
1530 case XFS_IOC_FREESP:
1531 case XFS_IOC_RESVSP:
1532 case XFS_IOC_UNRESVSP:
1533 case XFS_IOC_ALLOCSP64:
1534 case XFS_IOC_FREESP64:
1535 case XFS_IOC_RESVSP64:
Dave Chinner44722352010-08-24 12:02:11 +10001536 case XFS_IOC_UNRESVSP64:
1537 case XFS_IOC_ZERO_RANGE: {
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001538 xfs_flock64_t bf;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001539
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001540 if (copy_from_user(&bf, arg, sizeof(bf)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001541 return -EFAULT;
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001542 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
1543 }
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001544 case XFS_IOC_DIOINFO: {
1545 struct dioattr da;
1546 xfs_buftarg_t *target =
1547 XFS_IS_REALTIME_INODE(ip) ?
1548 mp->m_rtdev_targp : mp->m_ddev_targp;
1549
Eric Sandeen7c71ee72014-01-21 16:46:23 -06001550 da.d_mem = da.d_miniosz = target->bt_logical_sectorsize;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001551 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1552
1553 if (copy_to_user(arg, &da, sizeof(da)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001554 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001555 return 0;
1556 }
1557
1558 case XFS_IOC_FSBULKSTAT_SINGLE:
1559 case XFS_IOC_FSBULKSTAT:
1560 case XFS_IOC_FSINUMBERS:
1561 return xfs_ioc_bulkstat(mp, cmd, arg);
1562
1563 case XFS_IOC_FSGEOMETRY_V1:
1564 return xfs_ioc_fsgeometry_v1(mp, arg);
1565
1566 case XFS_IOC_FSGEOMETRY:
1567 return xfs_ioc_fsgeometry(mp, arg);
1568
1569 case XFS_IOC_GETVERSION:
1570 return put_user(inode->i_generation, (int __user *)arg);
1571
1572 case XFS_IOC_FSGETXATTR:
1573 return xfs_ioc_fsgetxattr(ip, 0, arg);
1574 case XFS_IOC_FSGETXATTRA:
1575 return xfs_ioc_fsgetxattr(ip, 1, arg);
Lachlan McIlroy3b2816b2008-04-18 12:43:35 +10001576 case XFS_IOC_FSSETXATTR:
Lachlan McIlroy65e67f52008-04-18 12:59:45 +10001577 return xfs_ioc_fssetxattr(ip, filp, arg);
1578 case XFS_IOC_GETXFLAGS:
1579 return xfs_ioc_getxflags(ip, arg);
1580 case XFS_IOC_SETXFLAGS:
1581 return xfs_ioc_setxflags(ip, filp, arg);
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001582
1583 case XFS_IOC_FSSETDM: {
1584 struct fsdmidata dmi;
1585
1586 if (copy_from_user(&dmi, arg, sizeof(dmi)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001587 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001588
Jan Karad9457dc2012-06-12 16:20:39 +02001589 error = mnt_want_write_file(filp);
1590 if (error)
1591 return error;
1592
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001593 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1594 dmi.fsd_dmstate);
Jan Karad9457dc2012-06-12 16:20:39 +02001595 mnt_drop_write_file(filp);
Dave Chinner24513372014-06-25 14:58:08 +10001596 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001597 }
1598
1599 case XFS_IOC_GETBMAP:
1600 case XFS_IOC_GETBMAPA:
1601 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1602
1603 case XFS_IOC_GETBMAPX:
1604 return xfs_ioc_getbmapx(ip, arg);
1605
1606 case XFS_IOC_FD_TO_HANDLE:
1607 case XFS_IOC_PATH_TO_HANDLE:
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001608 case XFS_IOC_PATH_TO_FSHANDLE: {
1609 xfs_fsop_handlereq_t hreq;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001610
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001611 if (copy_from_user(&hreq, arg, sizeof(hreq)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001612 return -EFAULT;
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001613 return xfs_find_handle(cmd, &hreq);
1614 }
1615 case XFS_IOC_OPEN_BY_HANDLE: {
1616 xfs_fsop_handlereq_t hreq;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001617
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001618 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001619 return -EFAULT;
Christoph Hellwigd296d302009-01-19 02:02:57 +01001620 return xfs_open_by_handle(filp, &hreq);
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001621 }
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001622 case XFS_IOC_FSSETDM_BY_HANDLE:
Christoph Hellwigd296d302009-01-19 02:02:57 +01001623 return xfs_fssetdm_by_handle(filp, arg);
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001624
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001625 case XFS_IOC_READLINK_BY_HANDLE: {
1626 xfs_fsop_handlereq_t hreq;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001627
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001628 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001629 return -EFAULT;
Christoph Hellwigd296d302009-01-19 02:02:57 +01001630 return xfs_readlink_by_handle(filp, &hreq);
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001631 }
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001632 case XFS_IOC_ATTRLIST_BY_HANDLE:
Christoph Hellwigd296d302009-01-19 02:02:57 +01001633 return xfs_attrlist_by_handle(filp, arg);
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001634
1635 case XFS_IOC_ATTRMULTI_BY_HANDLE:
Christoph Hellwigd296d302009-01-19 02:02:57 +01001636 return xfs_attrmulti_by_handle(filp, arg);
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001637
1638 case XFS_IOC_SWAPEXT: {
sandeen@sandeen.net743bb4652008-11-25 21:20:06 -06001639 struct xfs_swapext sxp;
1640
1641 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001642 return -EFAULT;
Jan Karad9457dc2012-06-12 16:20:39 +02001643 error = mnt_want_write_file(filp);
1644 if (error)
1645 return error;
Dave Chinnera133d952013-08-12 20:49:48 +10001646 error = xfs_ioc_swapext(&sxp);
Jan Karad9457dc2012-06-12 16:20:39 +02001647 mnt_drop_write_file(filp);
Dave Chinner24513372014-06-25 14:58:08 +10001648 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001649 }
1650
1651 case XFS_IOC_FSCOUNTS: {
1652 xfs_fsop_counts_t out;
1653
1654 error = xfs_fs_counts(mp, &out);
1655 if (error)
Dave Chinner24513372014-06-25 14:58:08 +10001656 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001657
1658 if (copy_to_user(arg, &out, sizeof(out)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001659 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001660 return 0;
1661 }
1662
1663 case XFS_IOC_SET_RESBLKS: {
1664 xfs_fsop_resblks_t inout;
1665 __uint64_t in;
1666
1667 if (!capable(CAP_SYS_ADMIN))
1668 return -EPERM;
1669
Eric Sandeend5db0f92010-02-05 22:59:53 +00001670 if (mp->m_flags & XFS_MOUNT_RDONLY)
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001671 return -EROFS;
Eric Sandeend5db0f92010-02-05 22:59:53 +00001672
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001673 if (copy_from_user(&inout, arg, sizeof(inout)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001674 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001675
Jan Karad9457dc2012-06-12 16:20:39 +02001676 error = mnt_want_write_file(filp);
1677 if (error)
1678 return error;
1679
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001680 /* input parameter is passed in resblks field of structure */
1681 in = inout.resblks;
1682 error = xfs_reserve_blocks(mp, &in, &inout);
Jan Karad9457dc2012-06-12 16:20:39 +02001683 mnt_drop_write_file(filp);
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001684 if (error)
Dave Chinner24513372014-06-25 14:58:08 +10001685 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001686
1687 if (copy_to_user(arg, &inout, sizeof(inout)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001688 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001689 return 0;
1690 }
1691
1692 case XFS_IOC_GET_RESBLKS: {
1693 xfs_fsop_resblks_t out;
1694
1695 if (!capable(CAP_SYS_ADMIN))
1696 return -EPERM;
1697
1698 error = xfs_reserve_blocks(mp, NULL, &out);
1699 if (error)
Dave Chinner24513372014-06-25 14:58:08 +10001700 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001701
1702 if (copy_to_user(arg, &out, sizeof(out)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001703 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001704
1705 return 0;
1706 }
1707
1708 case XFS_IOC_FSGROWFSDATA: {
1709 xfs_growfs_data_t in;
1710
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001711 if (copy_from_user(&in, arg, sizeof(in)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001712 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001713
Jan Karad9457dc2012-06-12 16:20:39 +02001714 error = mnt_want_write_file(filp);
1715 if (error)
1716 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001717 error = xfs_growfs_data(mp, &in);
Jan Karad9457dc2012-06-12 16:20:39 +02001718 mnt_drop_write_file(filp);
Dave Chinner24513372014-06-25 14:58:08 +10001719 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001720 }
1721
1722 case XFS_IOC_FSGROWFSLOG: {
1723 xfs_growfs_log_t in;
1724
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001725 if (copy_from_user(&in, arg, sizeof(in)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001726 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001727
Jan Karad9457dc2012-06-12 16:20:39 +02001728 error = mnt_want_write_file(filp);
1729 if (error)
1730 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001731 error = xfs_growfs_log(mp, &in);
Jan Karad9457dc2012-06-12 16:20:39 +02001732 mnt_drop_write_file(filp);
Dave Chinner24513372014-06-25 14:58:08 +10001733 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001734 }
1735
1736 case XFS_IOC_FSGROWFSRT: {
1737 xfs_growfs_rt_t in;
1738
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001739 if (copy_from_user(&in, arg, sizeof(in)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001740 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001741
Jan Karad9457dc2012-06-12 16:20:39 +02001742 error = mnt_want_write_file(filp);
1743 if (error)
1744 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001745 error = xfs_growfs_rt(mp, &in);
Jan Karad9457dc2012-06-12 16:20:39 +02001746 mnt_drop_write_file(filp);
Dave Chinner24513372014-06-25 14:58:08 +10001747 return error;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001748 }
1749
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001750 case XFS_IOC_GOINGDOWN: {
1751 __uint32_t in;
1752
1753 if (!capable(CAP_SYS_ADMIN))
1754 return -EPERM;
1755
1756 if (get_user(in, (__uint32_t __user *)arg))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001757 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001758
Dave Chinner24513372014-06-25 14:58:08 +10001759 return xfs_fs_goingdown(mp, in);
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001760 }
1761
1762 case XFS_IOC_ERROR_INJECTION: {
1763 xfs_error_injection_t in;
1764
1765 if (!capable(CAP_SYS_ADMIN))
1766 return -EPERM;
1767
1768 if (copy_from_user(&in, arg, sizeof(in)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001769 return -EFAULT;
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001770
Dave Chinner24513372014-06-25 14:58:08 +10001771 return xfs_errortag_add(in.errtag, mp);
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001772 }
1773
1774 case XFS_IOC_ERROR_CLEARALL:
1775 if (!capable(CAP_SYS_ADMIN))
1776 return -EPERM;
1777
Dave Chinner24513372014-06-25 14:58:08 +10001778 return xfs_errortag_clearall(mp, 1);
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001779
Brian Foster8ca149d2012-11-07 12:21:12 -05001780 case XFS_IOC_FREE_EOFBLOCKS: {
Dwight Engenb9fe5052013-08-15 14:08:02 -04001781 struct xfs_fs_eofblocks eofb;
1782 struct xfs_eofblocks keofb;
Brian Foster8ca149d2012-11-07 12:21:12 -05001783
Dwight Engen8c567a72013-08-15 14:08:03 -04001784 if (!capable(CAP_SYS_ADMIN))
1785 return -EPERM;
1786
1787 if (mp->m_flags & XFS_MOUNT_RDONLY)
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001788 return -EROFS;
Dwight Engen8c567a72013-08-15 14:08:03 -04001789
Brian Foster8ca149d2012-11-07 12:21:12 -05001790 if (copy_from_user(&eofb, arg, sizeof(eofb)))
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001791 return -EFAULT;
Brian Foster8ca149d2012-11-07 12:21:12 -05001792
Dwight Engenb9fe5052013-08-15 14:08:02 -04001793 error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
1794 if (error)
Dave Chinner24513372014-06-25 14:58:08 +10001795 return error;
Brian Foster8ca149d2012-11-07 12:21:12 -05001796
Dave Chinner24513372014-06-25 14:58:08 +10001797 return xfs_icache_free_eofblocks(mp, &keofb);
Brian Foster8ca149d2012-11-07 12:21:12 -05001798 }
1799
Lachlan McIlroydf26cfe2008-04-18 11:44:03 +10001800 default:
1801 return -ENOTTY;
1802 }
1803}