projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[XFS] fix uninitialised variable bug in dquot release.
[deliverable/linux.git] / fs / xfs / linux-2.6 / xfs_ioctl.c
CommitLineData
1da177e4 1/*
7b718769
NS		 2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
1da177e4 4 *
7b718769
NS		 5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
1da177e4
LT		 7 * published by the Free Software Foundation.
8 *
7b718769
NS		 9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
1da177e4 13 *
7b718769
NS		 14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1da177e4 17 */
1da177e4 18#include "xfs.h"
1da177e4 19#include "xfs_fs.h"
a844f451 20#include "xfs_bit.h"
1da177e4 21#include "xfs_log.h"
a844f451 22#include "xfs_inum.h"
1da177e4
LT		 23#include "xfs_trans.h"
24#include "xfs_sb.h"
a844f451 25#include "xfs_ag.h"
1da177e4
LT		 26#include "xfs_dir2.h"
27#include "xfs_alloc.h"
28#include "xfs_dmapi.h"
29#include "xfs_mount.h"
1da177e4 30#include "xfs_bmap_btree.h"
a844f451 31#include "xfs_alloc_btree.h"
1da177e4 32#include "xfs_ialloc_btree.h"
a844f451 33#include "xfs_attr_sf.h"
1da177e4
LT		 34#include "xfs_dir2_sf.h"
35#include "xfs_dinode.h"
36#include "xfs_inode.h"
a844f451
NS		 37#include "xfs_btree.h"
38#include "xfs_ialloc.h"
1da177e4 39#include "xfs_rtalloc.h"
1da177e4 40#include "xfs_itable.h"
a844f451 41#include "xfs_error.h"
1da177e4
LT		 42#include "xfs_rw.h"
43#include "xfs_acl.h"
1da177e4 44#include "xfs_attr.h"
a844f451 45#include "xfs_bmap.h"
1da177e4
LT		 46#include "xfs_buf_item.h"
47#include "xfs_utils.h"
48#include "xfs_dfrag.h"
49#include "xfs_fsops.h"
993386c1 50#include "xfs_vnodeops.h"
25fe55e8
CH		 51#include "xfs_quota.h"
52#include "xfs_inode_item.h"
1da177e4 53
16f7e0fe 54#include <linux/capability.h>
1da177e4
LT		 55#include <linux/dcache.h>
56#include <linux/mount.h>
57#include <linux/namei.h>
58#include <linux/pagemap.h>
59
60/*
61 * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
62 * a file or fs handle.
63 *
64 * XFS_IOC_PATH_TO_FSHANDLE
65 * returns fs handle for a mount point or path within that mount point
66 * XFS_IOC_FD_TO_HANDLE
67 * returns full handle for a FD opened in user space
68 * XFS_IOC_PATH_TO_HANDLE
69 * returns full handle for a path
70 */
71STATIC int
72xfs_find_handle(
73 unsigned int cmd,
74 void __user *arg)
75{
76 int hsize;
77 xfs_handle_t handle;
78 xfs_fsop_handlereq_t hreq;
79 struct inode *inode;
1da177e4
LT		 80
81 if (copy_from_user(&hreq, arg, sizeof(hreq)))
82 return -XFS_ERROR(EFAULT);
83
84 memset((char *)&handle, 0, sizeof(handle));
85
86 switch (cmd) {
87 case XFS_IOC_PATH_TO_FSHANDLE:
88 case XFS_IOC_PATH_TO_HANDLE: {
2d8f3038
AV		 89 struct path path;
90 int error = user_lpath((const char __user *)hreq.path, &path);
1da177e4
LT		 91 if (error)
92 return error;
93
2d8f3038
AV		 94 ASSERT(path.dentry);
95 ASSERT(path.dentry->d_inode);
96 inode = igrab(path.dentry->d_inode);
97 path_put(&path);
1da177e4
LT		 98 break;
99 }
100
101 case XFS_IOC_FD_TO_HANDLE: {
102 struct file *file;
103
104 file = fget(hreq.fd);
105 if (!file)
106 return -EBADF;
107
e678fb0d
JJS		 108 ASSERT(file->f_path.dentry);
109 ASSERT(file->f_path.dentry->d_inode);
110 inode = igrab(file->f_path.dentry->d_inode);
1da177e4
LT		 111 fput(file);
112 break;
113 }
114
115 default:
116 ASSERT(0);
117 return -XFS_ERROR(EINVAL);
118 }
119
120 if (inode->i_sb->s_magic != XFS_SB_MAGIC) {
121 /* we're not in XFS anymore, Toto */
122 iput(inode);
123 return -XFS_ERROR(EINVAL);
124 }
125
0432dab2
CH		 126 switch (inode->i_mode & S_IFMT) {
127 case S_IFREG:
128 case S_IFDIR:
129 case S_IFLNK:
130 break;
131 default:
1da177e4
LT		 132 iput(inode);
133 return -XFS_ERROR(EBADF);
134 }
135
136 /* now we can grab the fsid */
0ce4cfd4 137 memcpy(&handle.ha_fsid, XFS_I(inode)->i_mount->m_fixedfsid,
2f6f7b3d 138 sizeof(xfs_fsid_t));
1da177e4
LT		 139 hsize = sizeof(xfs_fsid_t);
140
141 if (cmd != XFS_IOC_PATH_TO_FSHANDLE) {
6e7f75ea 142 xfs_inode_t *ip = XFS_I(inode);
1da177e4
LT		 143 int lock_mode;
144
145 /* need to get access to the xfs_inode to read the generation */
1da177e4
LT		 146 lock_mode = xfs_ilock_map_shared(ip);
147
148 /* fill in fid section of handle from inode */
c6143911
CH		 149 handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
150 sizeof(handle.ha_fid.fid_len);
151 handle.ha_fid.fid_pad = 0;
152 handle.ha_fid.fid_gen = ip->i_d.di_gen;
153 handle.ha_fid.fid_ino = ip->i_ino;
1da177e4
LT		 154
155 xfs_iunlock_map_shared(ip, lock_mode);
156
157 hsize = XFS_HSIZE(handle);
158 }
159
160 /* now copy our handle into the user buffer & write out the size */
161 if (copy_to_user(hreq.ohandle, &handle, hsize) ||
162 copy_to_user(hreq.ohandlen, &hsize, sizeof(__s32))) {
163 iput(inode);
164 return -XFS_ERROR(EFAULT);
165 }
166
167 iput(inode);
168 return 0;
169}
170
171
172/*
6e7f75ea
CH		 173 * Convert userspace handle data into inode.
174 *
175 * We use the fact that all the fsop_handlereq ioctl calls have a data
176 * structure argument whose first component is always a xfs_fsop_handlereq_t,
177 * so we can pass that sub structure into this handy, shared routine.
1da177e4 178 *
6e7f75ea 179 * If no error, caller must always iput the returned inode.
1da177e4
LT		 180 */
181STATIC int
182xfs_vget_fsop_handlereq(
183 xfs_mount_t *mp,
184 struct inode *parinode, /* parent inode pointer */
185 xfs_fsop_handlereq_t *hreq,
1da177e4
LT		 186 struct inode **inode)
187{
188 void __user *hanp;
189 size_t hlen;
190 xfs_fid_t *xfid;
191 xfs_handle_t *handlep;
192 xfs_handle_t handle;
193 xfs_inode_t *ip;
1da177e4
LT		 194 xfs_ino_t ino;
195 __u32 igen;
196 int error;
197
198 /*
199 * Only allow handle opens under a directory.
200 */
201 if (!S_ISDIR(parinode->i_mode))
202 return XFS_ERROR(ENOTDIR);
203
204 hanp = hreq->ihandle;
205 hlen = hreq->ihandlen;
206 handlep = &handle;
207
208 if (hlen < sizeof(handlep->ha_fsid) || hlen > sizeof(*handlep))
209 return XFS_ERROR(EINVAL);
210 if (copy_from_user(handlep, hanp, hlen))
211 return XFS_ERROR(EFAULT);
212 if (hlen < sizeof(*handlep))
213 memset(((char *)handlep) + hlen, 0, sizeof(*handlep) - hlen);
214 if (hlen > sizeof(handlep->ha_fsid)) {
c6143911
CH		 215 if (handlep->ha_fid.fid_len !=
216 (hlen - sizeof(handlep->ha_fsid) -
217 sizeof(handlep->ha_fid.fid_len)) ||
218 handlep->ha_fid.fid_pad)
1da177e4
LT		 219 return XFS_ERROR(EINVAL);
220 }
221
222 /*
223 * Crack the handle, obtain the inode # & generation #
224 */
225 xfid = (struct xfs_fid *)&handlep->ha_fid;
c6143911
CH		 226 if (xfid->fid_len == sizeof(*xfid) - sizeof(xfid->fid_len)) {
227 ino = xfid->fid_ino;
228 igen = xfid->fid_gen;
1da177e4
LT		 229 } else {
230 return XFS_ERROR(EINVAL);
231 }
232
233 /*
6e7f75ea 234 * Get the XFS inode, building a Linux inode to go with it.
1da177e4
LT		 235 */
236 error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_SHARED, &ip, 0);
237 if (error)
238 return error;
239 if (ip == NULL)
240 return XFS_ERROR(EIO);
6a7f422d 241 if (ip->i_d.di_gen != igen) {
1da177e4
LT		 242 xfs_iput_new(ip, XFS_ILOCK_SHARED);
243 return XFS_ERROR(ENOENT);
244 }
245
1da177e4
LT		 246 xfs_iunlock(ip, XFS_ILOCK_SHARED);
247
e4f75291 248 *inode = VFS_I(ip);
1da177e4
LT		 249 return 0;
250}
251
252STATIC int
253xfs_open_by_handle(
254 xfs_mount_t *mp,
255 void __user *arg,
256 struct file *parfilp,
257 struct inode *parinode)
258{
259 int error;
260 int new_fd;
261 int permflag;
262 struct file *filp;
263 struct inode *inode;
264 struct dentry *dentry;
1da177e4
LT		 265 xfs_fsop_handlereq_t hreq;
266
267 if (!capable(CAP_SYS_ADMIN))
268 return -XFS_ERROR(EPERM);
269 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
270 return -XFS_ERROR(EFAULT);
271
6e7f75ea 272 error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &inode);
1da177e4
LT		 273 if (error)
274 return -error;
275
276 /* Restrict xfs_open_by_handle to directories & regular files. */
277 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
278 iput(inode);
279 return -XFS_ERROR(EINVAL);
280 }
281
282#if BITS_PER_LONG != 32
283 hreq.oflags |= O_LARGEFILE;
284#endif
285 /* Put open permission in namei format. */
286 permflag = hreq.oflags;
287 if ((permflag+1) & O_ACCMODE)
288 permflag++;
289 if (permflag & O_TRUNC)
290 permflag |= 2;
291
292 if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
293 (permflag & FMODE_WRITE) && IS_APPEND(inode)) {
294 iput(inode);
295 return -XFS_ERROR(EPERM);
296 }
297
298 if ((permflag & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
299 iput(inode);
300 return -XFS_ERROR(EACCES);
301 }
302
303 /* Can't write directories. */
304 if ( S_ISDIR(inode->i_mode) && (permflag & FMODE_WRITE)) {
305 iput(inode);
306 return -XFS_ERROR(EISDIR);
307 }
308
309 if ((new_fd = get_unused_fd()) < 0) {
310 iput(inode);
311 return new_fd;
312 }
313
44003728
CH		 314 dentry = d_obtain_alias(inode);
315 if (IS_ERR(dentry)) {
1da177e4 316 put_unused_fd(new_fd);
44003728 317 return PTR_ERR(dentry);
1da177e4
LT		 318 }
319
320 /* Ensure umount returns EBUSY on umounts while this file is open. */
e678fb0d 321 mntget(parfilp->f_path.mnt);
1da177e4
LT		 322
323 /* Create file pointer. */
e678fb0d 324 filp = dentry_open(dentry, parfilp->f_path.mnt, hreq.oflags);
1da177e4
LT		 325 if (IS_ERR(filp)) {
326 put_unused_fd(new_fd);
327 return -XFS_ERROR(-PTR_ERR(filp));
328 }
2e2e7bb1
VA		 329 if (inode->i_mode & S_IFREG) {
330 /* invisible operation should not change atime */
331 filp->f_flags |= O_NOATIME;
3562fd45 332 filp->f_op = &xfs_invis_file_operations;
2e2e7bb1 333 }
1da177e4
LT		 334
335 fd_install(new_fd, filp);
336 return new_fd;
337}
338
804c83c3
CH		 339/*
340 * This is a copy from fs/namei.c:vfs_readlink(), except for removing it's
341 * unused first argument.
342 */
343STATIC int
344do_readlink(
345 char __user *buffer,
346 int buflen,
347 const char *link)
348{
349 int len;
350
351 len = PTR_ERR(link);
352 if (IS_ERR(link))
353 goto out;
354
355 len = strlen(link);
356 if (len > (unsigned) buflen)
357 len = buflen;
358 if (copy_to_user(buffer, link, len))
359 len = -EFAULT;
360 out:
361 return len;
362}
363
364
1da177e4
LT		 365STATIC int
366xfs_readlink_by_handle(
367 xfs_mount_t *mp,
368 void __user *arg,
1da177e4
LT		 369 struct inode *parinode)
370{
1da177e4
LT		 371 struct inode *inode;
372 xfs_fsop_handlereq_t hreq;
1da177e4 373 __u32 olen;
804c83c3
CH		 374 void *link;
375 int error;
1da177e4
LT		 376
377 if (!capable(CAP_SYS_ADMIN))
378 return -XFS_ERROR(EPERM);
379 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
380 return -XFS_ERROR(EFAULT);
381
6e7f75ea 382 error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &inode);
1da177e4
LT		 383 if (error)
384 return -error;
385
386 /* Restrict this handle operation to symlinks only. */
0432dab2 387 if (!S_ISLNK(inode->i_mode)) {
804c83c3
CH		 388 error = -XFS_ERROR(EINVAL);
389 goto out_iput;
1da177e4
LT		 390 }
391
392 if (copy_from_user(&olen, hreq.ohandlen, sizeof(__u32))) {
804c83c3
CH		 393 error = -XFS_ERROR(EFAULT);
394 goto out_iput;
1da177e4 395 }
1da177e4 396
804c83c3
CH		 397 link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
398 if (!link)
399 goto out_iput;
1da177e4 400
739bfb2a 401 error = -xfs_readlink(XFS_I(inode), link);
67fcaa73 402 if (error)
804c83c3
CH		 403 goto out_kfree;
404 error = do_readlink(hreq.ohandle, olen, link);
405 if (error)
406 goto out_kfree;
67fcaa73 407
804c83c3
CH		 408 out_kfree:
409 kfree(link);
410 out_iput:
411 iput(inode);
412 return error;
1da177e4
LT		 413}
414
415STATIC int
416xfs_fssetdm_by_handle(
417 xfs_mount_t *mp,
418 void __user *arg,
1da177e4
LT		 419 struct inode *parinode)
420{
421 int error;
422 struct fsdmidata fsd;
423 xfs_fsop_setdm_handlereq_t dmhreq;
424 struct inode *inode;
1da177e4
LT		 425
426 if (!capable(CAP_MKNOD))
427 return -XFS_ERROR(EPERM);
428 if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
429 return -XFS_ERROR(EFAULT);
430
6e7f75ea 431 error = xfs_vget_fsop_handlereq(mp, parinode, &dmhreq.hreq, &inode);
1da177e4
LT		 432 if (error)
433 return -error;
434
435 if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {
6e7f75ea
CH		 436 error = -XFS_ERROR(EPERM);
437 goto out;
1da177e4
LT		 438 }
439
440 if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
6e7f75ea
CH		 441 error = -XFS_ERROR(EFAULT);
442 goto out;
1da177e4
LT		 443 }
444
6e7f75ea
CH		 445 error = -xfs_set_dmattrs(XFS_I(inode), fsd.fsd_dmevmask,
446 fsd.fsd_dmstate);
1da177e4 447
6e7f75ea
CH		 448 out:
449 iput(inode);
450 return error;
1da177e4
LT		 451}
452
453STATIC int
454xfs_attrlist_by_handle(
455 xfs_mount_t *mp,
456 void __user *arg,
1da177e4
LT		 457 struct inode *parinode)
458{
459 int error;
460 attrlist_cursor_kern_t *cursor;
461 xfs_fsop_attrlist_handlereq_t al_hreq;
462 struct inode *inode;
1da177e4
LT		 463 char *kbuf;
464
465 if (!capable(CAP_SYS_ADMIN))
466 return -XFS_ERROR(EPERM);
467 if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
468 return -XFS_ERROR(EFAULT);
469 if (al_hreq.buflen > XATTR_LIST_MAX)
470 return -XFS_ERROR(EINVAL);
471
90ad58a8
CH		 472 /*
473 * Reject flags, only allow namespaces.
474 */
475 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
476 return -XFS_ERROR(EINVAL);
477
6e7f75ea 478 error = xfs_vget_fsop_handlereq(mp, parinode, &al_hreq.hreq, &inode);
1da177e4
LT		 479 if (error)
480 goto out;
481
482 kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);
483 if (!kbuf)
484 goto out_vn_rele;
485
486 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
739bfb2a
CH		 487 error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,
488 al_hreq.flags, cursor);
1da177e4
LT		 489 if (error)
490 goto out_kfree;
491
492 if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
493 error = -EFAULT;
494
495 out_kfree:
496 kfree(kbuf);
497 out_vn_rele:
6e7f75ea 498 iput(inode);
1da177e4
LT		 499 out:
500 return -error;
501}
502
503STATIC int
504xfs_attrmulti_attr_get(
739bfb2a 505 struct inode *inode,
1da177e4
LT		 506 char *name,
507 char __user *ubuf,
508 __uint32_t *len,
509 __uint32_t flags)
510{
511 char *kbuf;
512 int error = EFAULT;
e8b0ebaa 513
1da177e4
LT		 514 if (*len > XATTR_SIZE_MAX)
515 return EINVAL;
516 kbuf = kmalloc(*len, GFP_KERNEL);
517 if (!kbuf)
518 return ENOMEM;
519
e8b0ebaa 520 error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
1da177e4
LT		 521 if (error)
522 goto out_kfree;
523
524 if (copy_to_user(ubuf, kbuf, *len))
525 error = EFAULT;
526
527 out_kfree:
528 kfree(kbuf);
529 return error;
530}
531
532STATIC int
533xfs_attrmulti_attr_set(
739bfb2a 534 struct inode *inode,
1da177e4
LT		 535 char *name,
536 const char __user *ubuf,
537 __uint32_t len,
538 __uint32_t flags)
539{
540 char *kbuf;
541 int error = EFAULT;
542
739bfb2a 543 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1da177e4
LT		 544 return EPERM;
545 if (len > XATTR_SIZE_MAX)
546 return EINVAL;
547
548 kbuf = kmalloc(len, GFP_KERNEL);
549 if (!kbuf)
550 return ENOMEM;
551
552 if (copy_from_user(kbuf, ubuf, len))
553 goto out_kfree;
e8b0ebaa 554
739bfb2a 555 error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
1da177e4
LT		 556
557 out_kfree:
558 kfree(kbuf);
559 return error;
560}
561
562STATIC int
563xfs_attrmulti_attr_remove(
739bfb2a 564 struct inode *inode,
1da177e4
LT		 565 char *name,
566 __uint32_t flags)
567{
739bfb2a 568 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1da177e4 569 return EPERM;
739bfb2a 570 return xfs_attr_remove(XFS_I(inode), name, flags);
1da177e4
LT		 571}
572
573STATIC int
574xfs_attrmulti_by_handle(
575 xfs_mount_t *mp,
576 void __user *arg,
42a74f20 577 struct file *parfilp,
1da177e4
LT		 578 struct inode *parinode)
579{
580 int error;
581 xfs_attr_multiop_t *ops;
582 xfs_fsop_attrmulti_handlereq_t am_hreq;
583 struct inode *inode;
1da177e4
LT		 584 unsigned int i, size;
585 char *attr_name;
586
587 if (!capable(CAP_SYS_ADMIN))
588 return -XFS_ERROR(EPERM);
589 if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
590 return -XFS_ERROR(EFAULT);
591
6e7f75ea 592 error = xfs_vget_fsop_handlereq(mp, parinode, &am_hreq.hreq, &inode);
1da177e4
LT		 593 if (error)
594 goto out;
595
596 error = E2BIG;
e182f57a 597 size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
1da177e4
LT		 598 if (!size || size > 16 * PAGE_SIZE)
599 goto out_vn_rele;
600
601 error = ENOMEM;
602 ops = kmalloc(size, GFP_KERNEL);
603 if (!ops)
604 goto out_vn_rele;
605
606 error = EFAULT;
607 if (copy_from_user(ops, am_hreq.ops, size))
608 goto out_kfree_ops;
609
610 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
611 if (!attr_name)
612 goto out_kfree_ops;
613
614
615 error = 0;
616 for (i = 0; i < am_hreq.opcount; i++) {
617 ops[i].am_error = strncpy_from_user(attr_name,
618 ops[i].am_attrname, MAXNAMELEN);
619 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
620 error = -ERANGE;
621 if (ops[i].am_error < 0)
622 break;
623
624 switch (ops[i].am_opcode) {
625 case ATTR_OP_GET:
739bfb2a 626 ops[i].am_error = xfs_attrmulti_attr_get(inode,
1da177e4
LT		 627 attr_name, ops[i].am_attrvalue,
628 &ops[i].am_length, ops[i].am_flags);
629 break;
630 case ATTR_OP_SET:
42a74f20
DH		 631 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
632 if (ops[i].am_error)
633 break;
739bfb2a 634 ops[i].am_error = xfs_attrmulti_attr_set(inode,
1da177e4
LT		 635 attr_name, ops[i].am_attrvalue,
636 ops[i].am_length, ops[i].am_flags);
42a74f20 637 mnt_drop_write(parfilp->f_path.mnt);
1da177e4
LT		 638 break;
639 case ATTR_OP_REMOVE:
42a74f20
DH		 640 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
641 if (ops[i].am_error)
642 break;
739bfb2a 643 ops[i].am_error = xfs_attrmulti_attr_remove(inode,
1da177e4 644 attr_name, ops[i].am_flags);
42a74f20 645 mnt_drop_write(parfilp->f_path.mnt);
1da177e4
LT		 646 break;
647 default:
648 ops[i].am_error = EINVAL;
649 }
650 }
651
652 if (copy_to_user(am_hreq.ops, ops, size))
653 error = XFS_ERROR(EFAULT);
654
655 kfree(attr_name);
656 out_kfree_ops:
657 kfree(ops);
658 out_vn_rele:
6e7f75ea 659 iput(inode);
1da177e4
LT		 660 out:
661 return -error;
662}
663
1da177e4
LT		 664STATIC int
665xfs_ioc_space(
993386c1 666 struct xfs_inode *ip,
f37ea149 667 struct inode *inode,
1da177e4
LT		 668 struct file *filp,
669 int ioflags,
670 unsigned int cmd,
671 void __user *arg)
672{
673 xfs_flock64_t bf;
674 int attr_flags = 0;
675 int error;
676
f37ea149 677 if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
1da177e4
LT		 678 return -XFS_ERROR(EPERM);
679
ad4a8ac4 680 if (!(filp->f_mode & FMODE_WRITE))
1da177e4
LT		 681 return -XFS_ERROR(EBADF);
682
f37ea149 683 if (!S_ISREG(inode->i_mode))
1da177e4
LT		 684 return -XFS_ERROR(EINVAL);
685
686 if (copy_from_user(&bf, arg, sizeof(bf)))
687 return -XFS_ERROR(EFAULT);
688
689 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
0f285c8a 690 attr_flags |= XFS_ATTR_NONBLOCK;
1da177e4 691 if (ioflags & IO_INVIS)
0f285c8a 692 attr_flags |= XFS_ATTR_DMI;
1da177e4 693
ea5a3dc8 694 error = xfs_change_file_space(ip, cmd, &bf, filp->f_pos, attr_flags);
1da177e4
LT		 695 return -error;
696}
697
698STATIC int
699xfs_ioc_bulkstat(
700 xfs_mount_t *mp,
701 unsigned int cmd,
702 void __user *arg)
703{
704 xfs_fsop_bulkreq_t bulkreq;
705 int count; /* # of records returned */
706 xfs_ino_t inlast; /* last inode number */
707 int done;
708 int error;
709
710 /* done = 1 if there are more stats to get and if bulkstat */
711 /* should be called again (unused here, but used in dmapi) */
712
713 if (!capable(CAP_SYS_ADMIN))
714 return -EPERM;
715
716 if (XFS_FORCED_SHUTDOWN(mp))
717 return -XFS_ERROR(EIO);
718
719 if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
720 return -XFS_ERROR(EFAULT);
721
722 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
723 return -XFS_ERROR(EFAULT);
724
725 if ((count = bulkreq.icount) <= 0)
726 return -XFS_ERROR(EINVAL);
727
cd57e594
LM		 728 if (bulkreq.ubuffer == NULL)
729 return -XFS_ERROR(EINVAL);
730
1da177e4
LT		 731 if (cmd == XFS_IOC_FSINUMBERS)
732 error = xfs_inumbers(mp, &inlast, &count,
faa63e95 733 bulkreq.ubuffer, xfs_inumbers_fmt);
1da177e4
LT		 734 else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
735 error = xfs_bulkstat_single(mp, &inlast,
736 bulkreq.ubuffer, &done);
cd57e594
LM		 737 else /* XFS_IOC_FSBULKSTAT */
738 error = xfs_bulkstat(mp, &inlast, &count,
739 (bulkstat_one_pf)xfs_bulkstat_one, NULL,
740 sizeof(xfs_bstat_t), bulkreq.ubuffer,
741 BULKSTAT_FG_QUICK, &done);
1da177e4
LT		 742
743 if (error)
744 return -error;
745
746 if (bulkreq.ocount != NULL) {
747 if (copy_to_user(bulkreq.lastip, &inlast,
748 sizeof(xfs_ino_t)))
749 return -XFS_ERROR(EFAULT);
750
751 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
752 return -XFS_ERROR(EFAULT);
753 }
754
755 return 0;
756}
757
758STATIC int
759xfs_ioc_fsgeometry_v1(
760 xfs_mount_t *mp,
761 void __user *arg)
762{
763 xfs_fsop_geom_v1_t fsgeo;
764 int error;
765
766 error = xfs_fs_geometry(mp, (xfs_fsop_geom_t *)&fsgeo, 3);
767 if (error)
768 return -error;
769
770 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
771 return -XFS_ERROR(EFAULT);
772 return 0;
773}
774
775STATIC int
776xfs_ioc_fsgeometry(
777 xfs_mount_t *mp,
778 void __user *arg)
779{
780 xfs_fsop_geom_t fsgeo;
781 int error;
782
783 error = xfs_fs_geometry(mp, &fsgeo, 4);
784 if (error)
785 return -error;
786
787 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
788 return -XFS_ERROR(EFAULT);
789 return 0;
790}
791
792/*
793 * Linux extended inode flags interface.
794 */
1da177e4
LT		 795
796STATIC unsigned int
797xfs_merge_ioc_xflags(
798 unsigned int flags,
799 unsigned int start)
800{
801 unsigned int xflags = start;
802
39058a0e 803 if (flags & FS_IMMUTABLE_FL)
1da177e4
LT		 804 xflags |= XFS_XFLAG_IMMUTABLE;
805 else
806 xflags &= ~XFS_XFLAG_IMMUTABLE;
39058a0e 807 if (flags & FS_APPEND_FL)
1da177e4
LT		 808 xflags |= XFS_XFLAG_APPEND;
809 else
810 xflags &= ~XFS_XFLAG_APPEND;
39058a0e 811 if (flags & FS_SYNC_FL)
1da177e4
LT		 812 xflags |= XFS_XFLAG_SYNC;
813 else
814 xflags &= ~XFS_XFLAG_SYNC;
39058a0e 815 if (flags & FS_NOATIME_FL)
1da177e4
LT		 816 xflags |= XFS_XFLAG_NOATIME;
817 else
818 xflags &= ~XFS_XFLAG_NOATIME;
39058a0e 819 if (flags & FS_NODUMP_FL)
1da177e4
LT		 820 xflags |= XFS_XFLAG_NODUMP;
821 else
822 xflags &= ~XFS_XFLAG_NODUMP;
823
824 return xflags;
825}
826
827STATIC unsigned int
828xfs_di2lxflags(
829 __uint16_t di_flags)
830{
831 unsigned int flags = 0;
832
833 if (di_flags & XFS_DIFLAG_IMMUTABLE)
39058a0e 834 flags |= FS_IMMUTABLE_FL;
1da177e4 835 if (di_flags & XFS_DIFLAG_APPEND)
39058a0e 836 flags |= FS_APPEND_FL;
1da177e4 837 if (di_flags & XFS_DIFLAG_SYNC)
39058a0e 838 flags |= FS_SYNC_FL;
1da177e4 839 if (di_flags & XFS_DIFLAG_NOATIME)
39058a0e 840 flags |= FS_NOATIME_FL;
1da177e4 841 if (di_flags & XFS_DIFLAG_NODUMP)
39058a0e 842 flags |= FS_NODUMP_FL;
1da177e4
LT		 843 return flags;
844}
845
c83bfab1
CH		 846STATIC int
847xfs_ioc_fsgetxattr(
848 xfs_inode_t *ip,
849 int attr,
850 void __user *arg)
851{
852 struct fsxattr fa;
853
854 xfs_ilock(ip, XFS_ILOCK_SHARED);
855 fa.fsx_xflags = xfs_ip2xflags(ip);
856 fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
857 fa.fsx_projid = ip->i_d.di_projid;
858
859 if (attr) {
860 if (ip->i_afp) {
861 if (ip->i_afp->if_flags & XFS_IFEXTENTS)
862 fa.fsx_nextents = ip->i_afp->if_bytes /
863 sizeof(xfs_bmbt_rec_t);
864 else
865 fa.fsx_nextents = ip->i_d.di_anextents;
866 } else
867 fa.fsx_nextents = 0;
868 } else {
869 if (ip->i_df.if_flags & XFS_IFEXTENTS)
870 fa.fsx_nextents = ip->i_df.if_bytes /
871 sizeof(xfs_bmbt_rec_t);
872 else
873 fa.fsx_nextents = ip->i_d.di_nextents;
874 }
875 xfs_iunlock(ip, XFS_ILOCK_SHARED);
876
877 if (copy_to_user(arg, &fa, sizeof(fa)))
878 return -EFAULT;
879 return 0;
880}
881
25fe55e8
CH		 882STATIC void
883xfs_set_diflags(
884 struct xfs_inode *ip,
885 unsigned int xflags)
886{
887 unsigned int di_flags;
888
889 /* can't set PREALLOC this way, just preserve it */
890 di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
891 if (xflags & XFS_XFLAG_IMMUTABLE)
892 di_flags |= XFS_DIFLAG_IMMUTABLE;
893 if (xflags & XFS_XFLAG_APPEND)
894 di_flags |= XFS_DIFLAG_APPEND;
895 if (xflags & XFS_XFLAG_SYNC)
896 di_flags |= XFS_DIFLAG_SYNC;
897 if (xflags & XFS_XFLAG_NOATIME)
898 di_flags |= XFS_DIFLAG_NOATIME;
899 if (xflags & XFS_XFLAG_NODUMP)
900 di_flags |= XFS_DIFLAG_NODUMP;
901 if (xflags & XFS_XFLAG_PROJINHERIT)
902 di_flags |= XFS_DIFLAG_PROJINHERIT;
903 if (xflags & XFS_XFLAG_NODEFRAG)
904 di_flags |= XFS_DIFLAG_NODEFRAG;
905 if (xflags & XFS_XFLAG_FILESTREAM)
906 di_flags |= XFS_DIFLAG_FILESTREAM;
907 if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
908 if (xflags & XFS_XFLAG_RTINHERIT)
909 di_flags |= XFS_DIFLAG_RTINHERIT;
910 if (xflags & XFS_XFLAG_NOSYMLINKS)
911 di_flags |= XFS_DIFLAG_NOSYMLINKS;
912 if (xflags & XFS_XFLAG_EXTSZINHERIT)
913 di_flags |= XFS_DIFLAG_EXTSZINHERIT;
914 } else if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
915 if (xflags & XFS_XFLAG_REALTIME)
916 di_flags |= XFS_DIFLAG_REALTIME;
917 if (xflags & XFS_XFLAG_EXTSIZE)
918 di_flags |= XFS_DIFLAG_EXTSIZE;
919 }
920
921 ip->i_d.di_flags = di_flags;
922}
923
f13fae2d
CH		 924STATIC void
925xfs_diflags_to_linux(
926 struct xfs_inode *ip)
927{
e4f75291 928 struct inode *inode = VFS_I(ip);
f13fae2d
CH		 929 unsigned int xflags = xfs_ip2xflags(ip);
930
931 if (xflags & XFS_XFLAG_IMMUTABLE)
932 inode->i_flags |= S_IMMUTABLE;
933 else
934 inode->i_flags &= ~S_IMMUTABLE;
935 if (xflags & XFS_XFLAG_APPEND)
936 inode->i_flags |= S_APPEND;
937 else
938 inode->i_flags &= ~S_APPEND;
939 if (xflags & XFS_XFLAG_SYNC)
940 inode->i_flags |= S_SYNC;
941 else
942 inode->i_flags &= ~S_SYNC;
943 if (xflags & XFS_XFLAG_NOATIME)
944 inode->i_flags |= S_NOATIME;
945 else
946 inode->i_flags &= ~S_NOATIME;
947}
25fe55e8
CH		 948
949#define FSX_PROJID 1
950#define FSX_EXTSIZE 2
951#define FSX_XFLAGS 4
952#define FSX_NONBLOCK 8
953
954STATIC int
955xfs_ioctl_setattr(
956 xfs_inode_t *ip,
957 struct fsxattr *fa,
958 int mask)
959{
960 struct xfs_mount *mp = ip->i_mount;
961 struct xfs_trans *tp;
962 unsigned int lock_flags = 0;
963 struct xfs_dquot *udqp = NULL, *gdqp = NULL;
964 struct xfs_dquot *olddquot = NULL;
965 int code;
966
967 xfs_itrace_entry(ip);
968
969 if (mp->m_flags & XFS_MOUNT_RDONLY)
970 return XFS_ERROR(EROFS);
971 if (XFS_FORCED_SHUTDOWN(mp))
972 return XFS_ERROR(EIO);
973
974 /*
975 * If disk quotas is on, we make sure that the dquots do exist on disk,
976 * before we start any other transactions. Trying to do this later
977 * is messy. We don't care to take a readlock to look at the ids
978 * in inode here, because we can't hold it across the trans_reserve.
979 * If the IDs do change before we take the ilock, we're covered
980 * because the i_*dquot fields will get updated anyway.
981 */
982 if (XFS_IS_QUOTA_ON(mp) && (mask & FSX_PROJID)) {
983 code = XFS_QM_DQVOPALLOC(mp, ip, ip->i_d.di_uid,
984 ip->i_d.di_gid, fa->fsx_projid,
985 XFS_QMOPT_PQUOTA, &udqp, &gdqp);
986 if (code)
987 return code;
988 }
989
990 /*
991 * For the other attributes, we acquire the inode lock and
992 * first do an error checking pass.
993 */
994 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
995 code = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);
996 if (code)
997 goto error_return;
998
999 lock_flags = XFS_ILOCK_EXCL;
1000 xfs_ilock(ip, lock_flags);
1001
1002 /*
1003 * CAP_FOWNER overrides the following restrictions:
1004 *
1005 * The user ID of the calling process must be equal
1006 * to the file owner ID, except in cases where the
1007 * CAP_FSETID capability is applicable.
1008 */
91b77712 1009 if (current_fsuid() != ip->i_d.di_uid && !capable(CAP_FOWNER)) {
25fe55e8
CH		 1010 code = XFS_ERROR(EPERM);
1011 goto error_return;
1012 }
1013
1014 /*
1015 * Do a quota reservation only if projid is actually going to change.
1016 */
1017 if (mask & FSX_PROJID) {
1018 if (XFS_IS_PQUOTA_ON(mp) &&
1019 ip->i_d.di_projid != fa->fsx_projid) {
1020 ASSERT(tp);
1021 code = XFS_QM_DQVOPCHOWNRESV(mp, tp, ip, udqp, gdqp,
1022 capable(CAP_FOWNER) ?
1023 XFS_QMOPT_FORCE_RES : 0);
1024 if (code) /* out of quota */
1025 goto error_return;
1026 }
1027 }
1028
1029 if (mask & FSX_EXTSIZE) {
1030 /*
1031 * Can't change extent size if any extents are allocated.
1032 */
1033 if (ip->i_d.di_nextents &&
1034 ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
1035 fa->fsx_extsize)) {
1036 code = XFS_ERROR(EINVAL); /* EFBIG? */
1037 goto error_return;
1038 }
1039
1040 /*
1041 * Extent size must be a multiple of the appropriate block
1042 * size, if set at all.
1043 */
1044 if (fa->fsx_extsize != 0) {
1045 xfs_extlen_t size;
1046
1047 if (XFS_IS_REALTIME_INODE(ip) ||
1048 ((mask & FSX_XFLAGS) &&
1049 (fa->fsx_xflags & XFS_XFLAG_REALTIME))) {
1050 size = mp->m_sb.sb_rextsize <<
1051 mp->m_sb.sb_blocklog;
1052 } else {
1053 size = mp->m_sb.sb_blocksize;
1054 }
1055
1056 if (fa->fsx_extsize % size) {
1057 code = XFS_ERROR(EINVAL);
1058 goto error_return;
1059 }
1060 }
1061 }
1062
1063
1064 if (mask & FSX_XFLAGS) {
1065 /*
1066 * Can't change realtime flag if any extents are allocated.
1067 */
1068 if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1069 (XFS_IS_REALTIME_INODE(ip)) !=
1070 (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1071 code = XFS_ERROR(EINVAL); /* EFBIG? */
1072 goto error_return;
1073 }
1074
1075 /*
1076 * If realtime flag is set then must have realtime data.
1077 */
1078 if ((fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1079 if ((mp->m_sb.sb_rblocks == 0) ||
1080 (mp->m_sb.sb_rextsize == 0) ||
1081 (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) {
1082 code = XFS_ERROR(EINVAL);
1083 goto error_return;
1084 }
1085 }
1086
1087 /*
1088 * Can't modify an immutable/append-only file unless
1089 * we have appropriate permission.
1090 */
1091 if ((ip->i_d.di_flags &
1092 (XFS_DIFLAG_IMMUTABLE|XFS_DIFLAG_APPEND) ||
1093 (fa->fsx_xflags &
1094 (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
1095 !capable(CAP_LINUX_IMMUTABLE)) {
1096 code = XFS_ERROR(EPERM);
1097 goto error_return;
1098 }
1099 }
1100
1101 xfs_trans_ijoin(tp, ip, lock_flags);
1102 xfs_trans_ihold(tp, ip);
1103
1104 /*
1105 * Change file ownership. Must be the owner or privileged.
25fe55e8
CH		 1106 */
1107 if (mask & FSX_PROJID) {
1108 /*
1109 * CAP_FSETID overrides the following restrictions:
1110 *
1111 * The set-user-ID and set-group-ID bits of a file will be
1112 * cleared upon successful return from chown()
1113 */
1114 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1115 !capable(CAP_FSETID))
1116 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
1117
1118 /*
1119 * Change the ownerships and register quota modifications
1120 * in the transaction.
1121 */
1122 if (ip->i_d.di_projid != fa->fsx_projid) {
1123 if (XFS_IS_PQUOTA_ON(mp)) {
1124 olddquot = XFS_QM_DQVOPCHOWN(mp, tp, ip,
1125 &ip->i_gdquot, gdqp);
1126 }
1127 ip->i_d.di_projid = fa->fsx_projid;
1128
1129 /*
1130 * We may have to rev the inode as well as
1131 * the superblock version number since projids didn't
1132 * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
1133 */
1134 if (ip->i_d.di_version == XFS_DINODE_VERSION_1)
1135 xfs_bump_ino_vers2(tp, ip);
1136 }
1137
1138 }
1139
1140 if (mask & FSX_EXTSIZE)
1141 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
f13fae2d 1142 if (mask & FSX_XFLAGS) {
25fe55e8 1143 xfs_set_diflags(ip, fa->fsx_xflags);
f13fae2d
CH		 1144 xfs_diflags_to_linux(ip);
1145 }
25fe55e8
CH		 1146
1147 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1148 xfs_ichgtime(ip, XFS_ICHGTIME_CHG);
1149
1150 XFS_STATS_INC(xs_ig_attrchg);
1151
1152 /*
1153 * If this is a synchronous mount, make sure that the
1154 * transaction goes to disk before returning to the user.
1155 * This is slightly sub-optimal in that truncates require
1156 * two sync transactions instead of one for wsync filesystems.
1157 * One for the truncate and one for the timestamps since we
1158 * don't want to change the timestamps unless we're sure the
1159 * truncate worked. Truncates are less than 1% of the laddis
1160 * mix so this probably isn't worth the trouble to optimize.
1161 */
1162 if (mp->m_flags & XFS_MOUNT_WSYNC)
1163 xfs_trans_set_sync(tp);
1164 code = xfs_trans_commit(tp, 0);
1165 xfs_iunlock(ip, lock_flags);
1166
1167 /*
1168 * Release any dquot(s) the inode had kept before chown.
1169 */
1170 XFS_QM_DQRELE(mp, olddquot);
1171 XFS_QM_DQRELE(mp, udqp);
1172 XFS_QM_DQRELE(mp, gdqp);
1173
1174 if (code)
1175 return code;
1176
1177 if (DM_EVENT_ENABLED(ip, DM_EVENT_ATTRIBUTE)) {
1178 XFS_SEND_NAMESP(mp, DM_EVENT_ATTRIBUTE, ip, DM_RIGHT_NULL,
1179 NULL, DM_RIGHT_NULL, NULL, NULL, 0, 0,
1180 (mask & FSX_NONBLOCK) ? DM_FLAGS_NDELAY : 0);
1181 }
1182
25fe55e8
CH		 1183 return 0;
1184
1185 error_return:
1186 XFS_QM_DQRELE(mp, udqp);
1187 XFS_QM_DQRELE(mp, gdqp);
1188 xfs_trans_cancel(tp, 0);
1189 if (lock_flags)
1190 xfs_iunlock(ip, lock_flags);
1191 return code;
1192}
1193
1da177e4 1194STATIC int
df26cfe8 1195xfs_ioc_fssetxattr(
1da177e4
LT		 1196 xfs_inode_t *ip,
1197 struct file *filp,
1da177e4
LT		 1198 void __user *arg)
1199{
1200 struct fsxattr fa;
25fe55e8 1201 unsigned int mask;
df26cfe8
LM		 1202
1203 if (copy_from_user(&fa, arg, sizeof(fa)))
1204 return -EFAULT;
1da177e4 1205
25fe55e8 1206 mask = FSX_XFLAGS | FSX_EXTSIZE | FSX_PROJID;
df26cfe8 1207 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
25fe55e8 1208 mask |= FSX_NONBLOCK;
1da177e4 1209
25fe55e8 1210 return -xfs_ioctl_setattr(ip, &fa, mask);
df26cfe8 1211}
1da177e4 1212
df26cfe8
LM		 1213STATIC int
1214xfs_ioc_getxflags(
1215 xfs_inode_t *ip,
1216 void __user *arg)
1217{
1218 unsigned int flags;
1da177e4 1219
df26cfe8
LM		 1220 flags = xfs_di2lxflags(ip->i_d.di_flags);
1221 if (copy_to_user(arg, &flags, sizeof(flags)))
1222 return -EFAULT;
1223 return 0;
1224}
1da177e4 1225
df26cfe8
LM		 1226STATIC int
1227xfs_ioc_setxflags(
1228 xfs_inode_t *ip,
1229 struct file *filp,
1230 void __user *arg)
1231{
25fe55e8 1232 struct fsxattr fa;
df26cfe8 1233 unsigned int flags;
25fe55e8 1234 unsigned int mask;
1da177e4 1235
df26cfe8
LM		 1236 if (copy_from_user(&flags, arg, sizeof(flags)))
1237 return -EFAULT;
1da177e4 1238
df26cfe8
LM		 1239 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1240 FS_NOATIME_FL | FS_NODUMP_FL | \
1241 FS_SYNC_FL))
1242 return -EOPNOTSUPP;
1da177e4 1243
25fe55e8 1244 mask = FSX_XFLAGS;
df26cfe8 1245 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
25fe55e8
CH		 1246 mask |= FSX_NONBLOCK;
1247 fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1da177e4 1248
25fe55e8 1249 return -xfs_ioctl_setattr(ip, &fa, mask);
1da177e4
LT		 1250}
1251
1252STATIC int
1253xfs_ioc_getbmap(
993386c1 1254 struct xfs_inode *ip,
1da177e4
LT		 1255 int ioflags,
1256 unsigned int cmd,
1257 void __user *arg)
1258{
1259 struct getbmap bm;
1260 int iflags;
1261 int error;
1262
1263 if (copy_from_user(&bm, arg, sizeof(bm)))
1264 return -XFS_ERROR(EFAULT);
1265
1266 if (bm.bmv_count < 2)
1267 return -XFS_ERROR(EINVAL);
1268
1269 iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1270 if (ioflags & IO_INVIS)
1271 iflags |= BMV_IF_NO_DMAPI_READ;
1272
993386c1 1273 error = xfs_getbmap(ip, &bm, (struct getbmap __user *)arg+1, iflags);
1da177e4
LT		 1274 if (error)
1275 return -error;
1276
1277 if (copy_to_user(arg, &bm, sizeof(bm)))
1278 return -XFS_ERROR(EFAULT);
1279 return 0;
1280}
1281
1282STATIC int
1283xfs_ioc_getbmapx(
993386c1 1284 struct xfs_inode *ip,
1da177e4
LT		 1285 void __user *arg)
1286{
1287 struct getbmapx bmx;
1288 struct getbmap bm;
1289 int iflags;
1290 int error;
1291
1292 if (copy_from_user(&bmx, arg, sizeof(bmx)))
1293 return -XFS_ERROR(EFAULT);
1294
1295 if (bmx.bmv_count < 2)
1296 return -XFS_ERROR(EINVAL);
1297
1298 /*
1299 * Map input getbmapx structure to a getbmap
1300 * structure for xfs_getbmap.
1301 */
1302 GETBMAP_CONVERT(bmx, bm);
1303
1304 iflags = bmx.bmv_iflags;
1305
1306 if (iflags & (~BMV_IF_VALID))
1307 return -XFS_ERROR(EINVAL);
1308
1309 iflags |= BMV_IF_EXTENDED;
1310
993386c1 1311 error = xfs_getbmap(ip, &bm, (struct getbmapx __user *)arg+1, iflags);
1da177e4
LT		 1312 if (error)
1313 return -error;
1314
1315 GETBMAP_CONVERT(bm, bmx);
1316
1317 if (copy_to_user(arg, &bmx, sizeof(bmx)))
1318 return -XFS_ERROR(EFAULT);
1319
1320 return 0;
1321}
df26cfe8
LM		 1322
1323int
1324xfs_ioctl(
1325 xfs_inode_t *ip,
1326 struct file *filp,
1327 int ioflags,
1328 unsigned int cmd,
1329 void __user *arg)
1330{
1331 struct inode *inode = filp->f_path.dentry->d_inode;
1332 xfs_mount_t *mp = ip->i_mount;
1333 int error;
1334
1335 xfs_itrace_entry(XFS_I(inode));
1336 switch (cmd) {
1337
1338 case XFS_IOC_ALLOCSP:
1339 case XFS_IOC_FREESP:
1340 case XFS_IOC_RESVSP:
1341 case XFS_IOC_UNRESVSP:
1342 case XFS_IOC_ALLOCSP64:
1343 case XFS_IOC_FREESP64:
1344 case XFS_IOC_RESVSP64:
1345 case XFS_IOC_UNRESVSP64:
1346 /*
1347 * Only allow the sys admin to reserve space unless
1348 * unwritten extents are enabled.
1349 */
1350 if (!xfs_sb_version_hasextflgbit(&mp->m_sb) &&
1351 !capable(CAP_SYS_ADMIN))
1352 return -EPERM;
1353
1354 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, arg);
1355
1356 case XFS_IOC_DIOINFO: {
1357 struct dioattr da;
1358 xfs_buftarg_t *target =
1359 XFS_IS_REALTIME_INODE(ip) ?
1360 mp->m_rtdev_targp : mp->m_ddev_targp;
1361
1362 da.d_mem = da.d_miniosz = 1 << target->bt_sshift;
1363 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1364
1365 if (copy_to_user(arg, &da, sizeof(da)))
1366 return -XFS_ERROR(EFAULT);
1367 return 0;
1368 }
1369
1370 case XFS_IOC_FSBULKSTAT_SINGLE:
1371 case XFS_IOC_FSBULKSTAT:
1372 case XFS_IOC_FSINUMBERS:
1373 return xfs_ioc_bulkstat(mp, cmd, arg);
1374
1375 case XFS_IOC_FSGEOMETRY_V1:
1376 return xfs_ioc_fsgeometry_v1(mp, arg);
1377
1378 case XFS_IOC_FSGEOMETRY:
1379 return xfs_ioc_fsgeometry(mp, arg);
1380
1381 case XFS_IOC_GETVERSION:
1382 return put_user(inode->i_generation, (int __user *)arg);
1383
1384 case XFS_IOC_FSGETXATTR:
1385 return xfs_ioc_fsgetxattr(ip, 0, arg);
1386 case XFS_IOC_FSGETXATTRA:
1387 return xfs_ioc_fsgetxattr(ip, 1, arg);
65e67f51
LM		 1388 case XFS_IOC_FSSETXATTR:
1389 return xfs_ioc_fssetxattr(ip, filp, arg);
df26cfe8 1390 case XFS_IOC_GETXFLAGS:
65e67f51 1391 return xfs_ioc_getxflags(ip, arg);
df26cfe8 1392 case XFS_IOC_SETXFLAGS:
65e67f51 1393 return xfs_ioc_setxflags(ip, filp, arg);
df26cfe8
LM		 1394
1395 case XFS_IOC_FSSETDM: {
1396 struct fsdmidata dmi;
1397
1398 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1399 return -XFS_ERROR(EFAULT);
1400
1401 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1402 dmi.fsd_dmstate);
1403 return -error;
1404 }
1405
1406 case XFS_IOC_GETBMAP:
1407 case XFS_IOC_GETBMAPA:
1408 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1409
1410 case XFS_IOC_GETBMAPX:
1411 return xfs_ioc_getbmapx(ip, arg);
1412
1413 case XFS_IOC_FD_TO_HANDLE:
1414 case XFS_IOC_PATH_TO_HANDLE:
1415 case XFS_IOC_PATH_TO_FSHANDLE:
1416 return xfs_find_handle(cmd, arg);
1417
1418 case XFS_IOC_OPEN_BY_HANDLE:
1419 return xfs_open_by_handle(mp, arg, filp, inode);
1420
1421 case XFS_IOC_FSSETDM_BY_HANDLE:
1422 return xfs_fssetdm_by_handle(mp, arg, inode);
1423
1424 case XFS_IOC_READLINK_BY_HANDLE:
1425 return xfs_readlink_by_handle(mp, arg, inode);
1426
1427 case XFS_IOC_ATTRLIST_BY_HANDLE:
1428 return xfs_attrlist_by_handle(mp, arg, inode);
1429
1430 case XFS_IOC_ATTRMULTI_BY_HANDLE:
42a74f20 1431 return xfs_attrmulti_by_handle(mp, arg, filp, inode);
df26cfe8
LM		 1432
1433 case XFS_IOC_SWAPEXT: {
1434 error = xfs_swapext((struct xfs_swapext __user *)arg);
1435 return -error;
1436 }
1437
1438 case XFS_IOC_FSCOUNTS: {
1439 xfs_fsop_counts_t out;
1440
1441 error = xfs_fs_counts(mp, &out);
1442 if (error)
1443 return -error;
1444
1445 if (copy_to_user(arg, &out, sizeof(out)))
1446 return -XFS_ERROR(EFAULT);
1447 return 0;
1448 }
1449
1450 case XFS_IOC_SET_RESBLKS: {
1451 xfs_fsop_resblks_t inout;
1452 __uint64_t in;
1453
1454 if (!capable(CAP_SYS_ADMIN))
1455 return -EPERM;
1456
1457 if (copy_from_user(&inout, arg, sizeof(inout)))
1458 return -XFS_ERROR(EFAULT);
1459
1460 /* input parameter is passed in resblks field of structure */
1461 in = inout.resblks;
1462 error = xfs_reserve_blocks(mp, &in, &inout);
1463 if (error)
1464 return -error;
1465
1466 if (copy_to_user(arg, &inout, sizeof(inout)))
1467 return -XFS_ERROR(EFAULT);
1468 return 0;
1469 }
1470
1471 case XFS_IOC_GET_RESBLKS: {
1472 xfs_fsop_resblks_t out;
1473
1474 if (!capable(CAP_SYS_ADMIN))
1475 return -EPERM;
1476
1477 error = xfs_reserve_blocks(mp, NULL, &out);
1478 if (error)
1479 return -error;
1480
1481 if (copy_to_user(arg, &out, sizeof(out)))
1482 return -XFS_ERROR(EFAULT);
1483
1484 return 0;
1485 }
1486
1487 case XFS_IOC_FSGROWFSDATA: {
1488 xfs_growfs_data_t in;
1489
1490 if (!capable(CAP_SYS_ADMIN))
1491 return -EPERM;
1492
1493 if (copy_from_user(&in, arg, sizeof(in)))
1494 return -XFS_ERROR(EFAULT);
1495
1496 error = xfs_growfs_data(mp, &in);
1497 return -error;
1498 }
1499
1500 case XFS_IOC_FSGROWFSLOG: {
1501 xfs_growfs_log_t in;
1502
1503 if (!capable(CAP_SYS_ADMIN))
1504 return -EPERM;
1505
1506 if (copy_from_user(&in, arg, sizeof(in)))
1507 return -XFS_ERROR(EFAULT);
1508
1509 error = xfs_growfs_log(mp, &in);
1510 return -error;
1511 }
1512
1513 case XFS_IOC_FSGROWFSRT: {
1514 xfs_growfs_rt_t in;
1515
1516 if (!capable(CAP_SYS_ADMIN))
1517 return -EPERM;
1518
1519 if (copy_from_user(&in, arg, sizeof(in)))
1520 return -XFS_ERROR(EFAULT);
1521
1522 error = xfs_growfs_rt(mp, &in);
1523 return -error;
1524 }
1525
1526 case XFS_IOC_FREEZE:
1527 if (!capable(CAP_SYS_ADMIN))
1528 return -EPERM;
1529
1530 if (inode->i_sb->s_frozen == SB_UNFROZEN)
1531 freeze_bdev(inode->i_sb->s_bdev);
1532 return 0;
1533
1534 case XFS_IOC_THAW:
1535 if (!capable(CAP_SYS_ADMIN))
1536 return -EPERM;
1537 if (inode->i_sb->s_frozen != SB_UNFROZEN)
1538 thaw_bdev(inode->i_sb->s_bdev, inode->i_sb);
1539 return 0;
1540
1541 case XFS_IOC_GOINGDOWN: {
1542 __uint32_t in;
1543
1544 if (!capable(CAP_SYS_ADMIN))
1545 return -EPERM;
1546
1547 if (get_user(in, (__uint32_t __user *)arg))
1548 return -XFS_ERROR(EFAULT);
1549
1550 error = xfs_fs_goingdown(mp, in);
1551 return -error;
1552 }
1553
1554 case XFS_IOC_ERROR_INJECTION: {
1555 xfs_error_injection_t in;
1556
1557 if (!capable(CAP_SYS_ADMIN))
1558 return -EPERM;
1559
1560 if (copy_from_user(&in, arg, sizeof(in)))
1561 return -XFS_ERROR(EFAULT);
1562
1563 error = xfs_errortag_add(in.errtag, mp);
1564 return -error;
1565 }
1566
1567 case XFS_IOC_ERROR_CLEARALL:
1568 if (!capable(CAP_SYS_ADMIN))
1569 return -EPERM;
1570
1571 error = xfs_errortag_clearall(mp, 1);
1572 return -error;
1573
1574 default:
1575 return -ENOTTY;
1576 }
1577}
Linux kernel - Deliverables
This page took 0.433062 seconds and 5 git commands to generate.