]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - fs/xfs/linux-2.6/xfs_ioctl.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[XFS] kill sys_cred
[mirror_ubuntu-bionic-kernel.git] / fs / xfs / linux-2.6 / xfs_ioctl.c
1 /*
2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_bit.h"
21 #include "xfs_log.h"
22 #include "xfs_inum.h"
23 #include "xfs_trans.h"
24 #include "xfs_sb.h"
25 #include "xfs_ag.h"
26 #include "xfs_dir2.h"
27 #include "xfs_alloc.h"
28 #include "xfs_dmapi.h"
29 #include "xfs_mount.h"
30 #include "xfs_bmap_btree.h"
31 #include "xfs_alloc_btree.h"
32 #include "xfs_ialloc_btree.h"
33 #include "xfs_attr_sf.h"
34 #include "xfs_dir2_sf.h"
35 #include "xfs_dinode.h"
36 #include "xfs_inode.h"
37 #include "xfs_btree.h"
38 #include "xfs_ialloc.h"
39 #include "xfs_rtalloc.h"
40 #include "xfs_itable.h"
41 #include "xfs_error.h"
42 #include "xfs_rw.h"
43 #include "xfs_acl.h"
44 #include "xfs_attr.h"
45 #include "xfs_bmap.h"
46 #include "xfs_buf_item.h"
47 #include "xfs_utils.h"
48 #include "xfs_dfrag.h"
49 #include "xfs_fsops.h"
50 #include "xfs_vnodeops.h"
51 #include "xfs_quota.h"
52 #include "xfs_inode_item.h"
53
54 #include <linux/capability.h>
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 */
71 STATIC int
72 xfs_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;
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: {
89 struct path path;
90 int error = user_lpath((const char __user *)hreq.path, &path);
91 if (error)
92 return error;
93
94 ASSERT(path.dentry);
95 ASSERT(path.dentry->d_inode);
96 inode = igrab(path.dentry->d_inode);
97 path_put(&path);
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
108 ASSERT(file->f_path.dentry);
109 ASSERT(file->f_path.dentry->d_inode);
110 inode = igrab(file->f_path.dentry->d_inode);
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
126 switch (inode->i_mode & S_IFMT) {
127 case S_IFREG:
128 case S_IFDIR:
129 case S_IFLNK:
130 break;
131 default:
132 iput(inode);
133 return -XFS_ERROR(EBADF);
134 }
135
136 /* now we can grab the fsid */
137 memcpy(&handle.ha_fsid, XFS_I(inode)->i_mount->m_fixedfsid,
138 sizeof(xfs_fsid_t));
139 hsize = sizeof(xfs_fsid_t);
140
141 if (cmd != XFS_IOC_PATH_TO_FSHANDLE) {
142 xfs_inode_t *ip = XFS_I(inode);
143 int lock_mode;
144
145 /* need to get access to the xfs_inode to read the generation */
146 lock_mode = xfs_ilock_map_shared(ip);
147
148 /* fill in fid section of handle from inode */
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;
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 /*
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.
178 *
179 * If no error, caller must always iput the returned inode.
180 */
181 STATIC int
182 xfs_vget_fsop_handlereq(
183 xfs_mount_t *mp,
184 struct inode *parinode, /* parent inode pointer */
185 xfs_fsop_handlereq_t *hreq,
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;
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)) {
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)
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;
226 if (xfid->fid_len == sizeof(*xfid) - sizeof(xfid->fid_len)) {
227 ino = xfid->fid_ino;
228 igen = xfid->fid_gen;
229 } else {
230 return XFS_ERROR(EINVAL);
231 }
232
233 /*
234 * Get the XFS inode, building a Linux inode to go with it.
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);
241 if (ip->i_d.di_gen != igen) {
242 xfs_iput_new(ip, XFS_ILOCK_SHARED);
243 return XFS_ERROR(ENOENT);
244 }
245
246 xfs_iunlock(ip, XFS_ILOCK_SHARED);
247
248 *inode = VFS_I(ip);
249 return 0;
250 }
251
252 STATIC int
253 xfs_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;
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
272 error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &inode);
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
314 dentry = d_obtain_alias(inode);
315 if (IS_ERR(dentry)) {
316 put_unused_fd(new_fd);
317 return PTR_ERR(dentry);
318 }
319
320 /* Ensure umount returns EBUSY on umounts while this file is open. */
321 mntget(parfilp->f_path.mnt);
322
323 /* Create file pointer. */
324 filp = dentry_open(dentry, parfilp->f_path.mnt, hreq.oflags);
325 if (IS_ERR(filp)) {
326 put_unused_fd(new_fd);
327 return -XFS_ERROR(-PTR_ERR(filp));
328 }
329 if (inode->i_mode & S_IFREG) {
330 /* invisible operation should not change atime */
331 filp->f_flags |= O_NOATIME;
332 filp->f_op = &xfs_invis_file_operations;
333 }
334
335 fd_install(new_fd, filp);
336 return new_fd;
337 }
338
339 /*
340 * This is a copy from fs/namei.c:vfs_readlink(), except for removing it's
341 * unused first argument.
342 */
343 STATIC int
344 do_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
365 STATIC int
366 xfs_readlink_by_handle(
367 xfs_mount_t *mp,
368 void __user *arg,
369 struct inode *parinode)
370 {
371 struct inode *inode;
372 xfs_fsop_handlereq_t hreq;
373 __u32 olen;
374 void *link;
375 int error;
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
382 error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &inode);
383 if (error)
384 return -error;
385
386 /* Restrict this handle operation to symlinks only. */
387 if (!S_ISLNK(inode->i_mode)) {
388 error = -XFS_ERROR(EINVAL);
389 goto out_iput;
390 }
391
392 if (copy_from_user(&olen, hreq.ohandlen, sizeof(__u32))) {
393 error = -XFS_ERROR(EFAULT);
394 goto out_iput;
395 }
396
397 link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
398 if (!link)
399 goto out_iput;
400
401 error = -xfs_readlink(XFS_I(inode), link);
402 if (error)
403 goto out_kfree;
404 error = do_readlink(hreq.ohandle, olen, link);
405 if (error)
406 goto out_kfree;
407
408 out_kfree:
409 kfree(link);
410 out_iput:
411 iput(inode);
412 return error;
413 }
414
415 STATIC int
416 xfs_fssetdm_by_handle(
417 xfs_mount_t *mp,
418 void __user *arg,
419 struct inode *parinode)
420 {
421 int error;
422 struct fsdmidata fsd;
423 xfs_fsop_setdm_handlereq_t dmhreq;
424 struct inode *inode;
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
431 error = xfs_vget_fsop_handlereq(mp, parinode, &dmhreq.hreq, &inode);
432 if (error)
433 return -error;
434
435 if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {
436 error = -XFS_ERROR(EPERM);
437 goto out;
438 }
439
440 if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
441 error = -XFS_ERROR(EFAULT);
442 goto out;
443 }
444
445 error = -xfs_set_dmattrs(XFS_I(inode), fsd.fsd_dmevmask,
446 fsd.fsd_dmstate);
447
448 out:
449 iput(inode);
450 return error;
451 }
452
453 STATIC int
454 xfs_attrlist_by_handle(
455 xfs_mount_t *mp,
456 void __user *arg,
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;
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
472 /*
473 * Reject flags, only allow namespaces.
474 */
475 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
476 return -XFS_ERROR(EINVAL);
477
478 error = xfs_vget_fsop_handlereq(mp, parinode, &al_hreq.hreq, &inode);
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;
487 error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,
488 al_hreq.flags, cursor);
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:
498 iput(inode);
499 out:
500 return -error;
501 }
502
503 STATIC int
504 xfs_attrmulti_attr_get(
505 struct inode *inode,
506 char *name,
507 char __user *ubuf,
508 __uint32_t *len,
509 __uint32_t flags)
510 {
511 char *kbuf;
512 int error = EFAULT;
513
514 if (*len > XATTR_SIZE_MAX)
515 return EINVAL;
516 kbuf = kmalloc(*len, GFP_KERNEL);
517 if (!kbuf)
518 return ENOMEM;
519
520 error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
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
532 STATIC int
533 xfs_attrmulti_attr_set(
534 struct inode *inode,
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
543 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
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;
554
555 error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
556
557 out_kfree:
558 kfree(kbuf);
559 return error;
560 }
561
562 STATIC int
563 xfs_attrmulti_attr_remove(
564 struct inode *inode,
565 char *name,
566 __uint32_t flags)
567 {
568 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
569 return EPERM;
570 return xfs_attr_remove(XFS_I(inode), name, flags);
571 }
572
573 STATIC int
574 xfs_attrmulti_by_handle(
575 xfs_mount_t *mp,
576 void __user *arg,
577 struct file *parfilp,
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;
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
592 error = xfs_vget_fsop_handlereq(mp, parinode, &am_hreq.hreq, &inode);
593 if (error)
594 goto out;
595
596 error = E2BIG;
597 size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
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:
626 ops[i].am_error = xfs_attrmulti_attr_get(inode,
627 attr_name, ops[i].am_attrvalue,
628 &ops[i].am_length, ops[i].am_flags);
629 break;
630 case ATTR_OP_SET:
631 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
632 if (ops[i].am_error)
633 break;
634 ops[i].am_error = xfs_attrmulti_attr_set(inode,
635 attr_name, ops[i].am_attrvalue,
636 ops[i].am_length, ops[i].am_flags);
637 mnt_drop_write(parfilp->f_path.mnt);
638 break;
639 case ATTR_OP_REMOVE:
640 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
641 if (ops[i].am_error)
642 break;
643 ops[i].am_error = xfs_attrmulti_attr_remove(inode,
644 attr_name, ops[i].am_flags);
645 mnt_drop_write(parfilp->f_path.mnt);
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:
659 iput(inode);
660 out:
661 return -error;
662 }
663
664 STATIC int
665 xfs_ioc_space(
666 struct xfs_inode *ip,
667 struct inode *inode,
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
677 if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
678 return -XFS_ERROR(EPERM);
679
680 if (!(filp->f_mode & FMODE_WRITE))
681 return -XFS_ERROR(EBADF);
682
683 if (!S_ISREG(inode->i_mode))
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))
690 attr_flags |= XFS_ATTR_NONBLOCK;
691 if (ioflags & IO_INVIS)
692 attr_flags |= XFS_ATTR_DMI;
693
694 error = xfs_change_file_space(ip, cmd, &bf, filp->f_pos, attr_flags);
695 return -error;
696 }
697
698 STATIC int
699 xfs_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
728 if (bulkreq.ubuffer == NULL)
729 return -XFS_ERROR(EINVAL);
730
731 if (cmd == XFS_IOC_FSINUMBERS)
732 error = xfs_inumbers(mp, &inlast, &count,
733 bulkreq.ubuffer, xfs_inumbers_fmt);
734 else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
735 error = xfs_bulkstat_single(mp, &inlast,
736 bulkreq.ubuffer, &done);
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);
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
758 STATIC int
759 xfs_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
775 STATIC int
776 xfs_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 */
795
796 STATIC unsigned int
797 xfs_merge_ioc_xflags(
798 unsigned int flags,
799 unsigned int start)
800 {
801 unsigned int xflags = start;
802
803 if (flags & FS_IMMUTABLE_FL)
804 xflags |= XFS_XFLAG_IMMUTABLE;
805 else
806 xflags &= ~XFS_XFLAG_IMMUTABLE;
807 if (flags & FS_APPEND_FL)
808 xflags |= XFS_XFLAG_APPEND;
809 else
810 xflags &= ~XFS_XFLAG_APPEND;
811 if (flags & FS_SYNC_FL)
812 xflags |= XFS_XFLAG_SYNC;
813 else
814 xflags &= ~XFS_XFLAG_SYNC;
815 if (flags & FS_NOATIME_FL)
816 xflags |= XFS_XFLAG_NOATIME;
817 else
818 xflags &= ~XFS_XFLAG_NOATIME;
819 if (flags & FS_NODUMP_FL)
820 xflags |= XFS_XFLAG_NODUMP;
821 else
822 xflags &= ~XFS_XFLAG_NODUMP;
823
824 return xflags;
825 }
826
827 STATIC unsigned int
828 xfs_di2lxflags(
829 __uint16_t di_flags)
830 {
831 unsigned int flags = 0;
832
833 if (di_flags & XFS_DIFLAG_IMMUTABLE)
834 flags |= FS_IMMUTABLE_FL;
835 if (di_flags & XFS_DIFLAG_APPEND)
836 flags |= FS_APPEND_FL;
837 if (di_flags & XFS_DIFLAG_SYNC)
838 flags |= FS_SYNC_FL;
839 if (di_flags & XFS_DIFLAG_NOATIME)
840 flags |= FS_NOATIME_FL;
841 if (di_flags & XFS_DIFLAG_NODUMP)
842 flags |= FS_NODUMP_FL;
843 return flags;
844 }
845
846 STATIC int
847 xfs_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
882 STATIC void
883 xfs_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
924 STATIC void
925 xfs_diflags_to_linux(
926 struct xfs_inode *ip)
927 {
928 struct inode *inode = VFS_I(ip);
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 }
948
949 #define FSX_PROJID 1
950 #define FSX_EXTSIZE 2
951 #define FSX_XFLAGS 4
952 #define FSX_NONBLOCK 8
953
954 STATIC int
955 xfs_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 */
1009 if (current->fsuid != ip->i_d.di_uid && !capable(CAP_FOWNER)) {
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.
1106 * If the system was configured with the "restricted_chown"
1107 * option, the owner is not permitted to give away the file,
1108 * and can change the group id only to a group of which he
1109 * or she is a member.
1110 */
1111 if (mask & FSX_PROJID) {
1112 /*
1113 * CAP_FSETID overrides the following restrictions:
1114 *
1115 * The set-user-ID and set-group-ID bits of a file will be
1116 * cleared upon successful return from chown()
1117 */
1118 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1119 !capable(CAP_FSETID))
1120 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
1121
1122 /*
1123 * Change the ownerships and register quota modifications
1124 * in the transaction.
1125 */
1126 if (ip->i_d.di_projid != fa->fsx_projid) {
1127 if (XFS_IS_PQUOTA_ON(mp)) {
1128 olddquot = XFS_QM_DQVOPCHOWN(mp, tp, ip,
1129 &ip->i_gdquot, gdqp);
1130 }
1131 ip->i_d.di_projid = fa->fsx_projid;
1132
1133 /*
1134 * We may have to rev the inode as well as
1135 * the superblock version number since projids didn't
1136 * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
1137 */
1138 if (ip->i_d.di_version == XFS_DINODE_VERSION_1)
1139 xfs_bump_ino_vers2(tp, ip);
1140 }
1141
1142 }
1143
1144 if (mask & FSX_EXTSIZE)
1145 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1146 if (mask & FSX_XFLAGS) {
1147 xfs_set_diflags(ip, fa->fsx_xflags);
1148 xfs_diflags_to_linux(ip);
1149 }
1150
1151 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1152 xfs_ichgtime(ip, XFS_ICHGTIME_CHG);
1153
1154 XFS_STATS_INC(xs_ig_attrchg);
1155
1156 /*
1157 * If this is a synchronous mount, make sure that the
1158 * transaction goes to disk before returning to the user.
1159 * This is slightly sub-optimal in that truncates require
1160 * two sync transactions instead of one for wsync filesystems.
1161 * One for the truncate and one for the timestamps since we
1162 * don't want to change the timestamps unless we're sure the
1163 * truncate worked. Truncates are less than 1% of the laddis
1164 * mix so this probably isn't worth the trouble to optimize.
1165 */
1166 if (mp->m_flags & XFS_MOUNT_WSYNC)
1167 xfs_trans_set_sync(tp);
1168 code = xfs_trans_commit(tp, 0);
1169 xfs_iunlock(ip, lock_flags);
1170
1171 /*
1172 * Release any dquot(s) the inode had kept before chown.
1173 */
1174 XFS_QM_DQRELE(mp, olddquot);
1175 XFS_QM_DQRELE(mp, udqp);
1176 XFS_QM_DQRELE(mp, gdqp);
1177
1178 if (code)
1179 return code;
1180
1181 if (DM_EVENT_ENABLED(ip, DM_EVENT_ATTRIBUTE)) {
1182 XFS_SEND_NAMESP(mp, DM_EVENT_ATTRIBUTE, ip, DM_RIGHT_NULL,
1183 NULL, DM_RIGHT_NULL, NULL, NULL, 0, 0,
1184 (mask & FSX_NONBLOCK) ? DM_FLAGS_NDELAY : 0);
1185 }
1186
1187 return 0;
1188
1189 error_return:
1190 XFS_QM_DQRELE(mp, udqp);
1191 XFS_QM_DQRELE(mp, gdqp);
1192 xfs_trans_cancel(tp, 0);
1193 if (lock_flags)
1194 xfs_iunlock(ip, lock_flags);
1195 return code;
1196 }
1197
1198 STATIC int
1199 xfs_ioc_fssetxattr(
1200 xfs_inode_t *ip,
1201 struct file *filp,
1202 void __user *arg)
1203 {
1204 struct fsxattr fa;
1205 unsigned int mask;
1206
1207 if (copy_from_user(&fa, arg, sizeof(fa)))
1208 return -EFAULT;
1209
1210 mask = FSX_XFLAGS | FSX_EXTSIZE | FSX_PROJID;
1211 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1212 mask |= FSX_NONBLOCK;
1213
1214 return -xfs_ioctl_setattr(ip, &fa, mask);
1215 }
1216
1217 STATIC int
1218 xfs_ioc_getxflags(
1219 xfs_inode_t *ip,
1220 void __user *arg)
1221 {
1222 unsigned int flags;
1223
1224 flags = xfs_di2lxflags(ip->i_d.di_flags);
1225 if (copy_to_user(arg, &flags, sizeof(flags)))
1226 return -EFAULT;
1227 return 0;
1228 }
1229
1230 STATIC int
1231 xfs_ioc_setxflags(
1232 xfs_inode_t *ip,
1233 struct file *filp,
1234 void __user *arg)
1235 {
1236 struct fsxattr fa;
1237 unsigned int flags;
1238 unsigned int mask;
1239
1240 if (copy_from_user(&flags, arg, sizeof(flags)))
1241 return -EFAULT;
1242
1243 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1244 FS_NOATIME_FL | FS_NODUMP_FL | \
1245 FS_SYNC_FL))
1246 return -EOPNOTSUPP;
1247
1248 mask = FSX_XFLAGS;
1249 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1250 mask |= FSX_NONBLOCK;
1251 fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1252
1253 return -xfs_ioctl_setattr(ip, &fa, mask);
1254 }
1255
1256 STATIC int
1257 xfs_ioc_getbmap(
1258 struct xfs_inode *ip,
1259 int ioflags,
1260 unsigned int cmd,
1261 void __user *arg)
1262 {
1263 struct getbmap bm;
1264 int iflags;
1265 int error;
1266
1267 if (copy_from_user(&bm, arg, sizeof(bm)))
1268 return -XFS_ERROR(EFAULT);
1269
1270 if (bm.bmv_count < 2)
1271 return -XFS_ERROR(EINVAL);
1272
1273 iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1274 if (ioflags & IO_INVIS)
1275 iflags |= BMV_IF_NO_DMAPI_READ;
1276
1277 error = xfs_getbmap(ip, &bm, (struct getbmap __user *)arg+1, iflags);
1278 if (error)
1279 return -error;
1280
1281 if (copy_to_user(arg, &bm, sizeof(bm)))
1282 return -XFS_ERROR(EFAULT);
1283 return 0;
1284 }
1285
1286 STATIC int
1287 xfs_ioc_getbmapx(
1288 struct xfs_inode *ip,
1289 void __user *arg)
1290 {
1291 struct getbmapx bmx;
1292 struct getbmap bm;
1293 int iflags;
1294 int error;
1295
1296 if (copy_from_user(&bmx, arg, sizeof(bmx)))
1297 return -XFS_ERROR(EFAULT);
1298
1299 if (bmx.bmv_count < 2)
1300 return -XFS_ERROR(EINVAL);
1301
1302 /*
1303 * Map input getbmapx structure to a getbmap
1304 * structure for xfs_getbmap.
1305 */
1306 GETBMAP_CONVERT(bmx, bm);
1307
1308 iflags = bmx.bmv_iflags;
1309
1310 if (iflags & (~BMV_IF_VALID))
1311 return -XFS_ERROR(EINVAL);
1312
1313 iflags |= BMV_IF_EXTENDED;
1314
1315 error = xfs_getbmap(ip, &bm, (struct getbmapx __user *)arg+1, iflags);
1316 if (error)
1317 return -error;
1318
1319 GETBMAP_CONVERT(bm, bmx);
1320
1321 if (copy_to_user(arg, &bmx, sizeof(bmx)))
1322 return -XFS_ERROR(EFAULT);
1323
1324 return 0;
1325 }
1326
1327 int
1328 xfs_ioctl(
1329 xfs_inode_t *ip,
1330 struct file *filp,
1331 int ioflags,
1332 unsigned int cmd,
1333 void __user *arg)
1334 {
1335 struct inode *inode = filp->f_path.dentry->d_inode;
1336 xfs_mount_t *mp = ip->i_mount;
1337 int error;
1338
1339 xfs_itrace_entry(XFS_I(inode));
1340 switch (cmd) {
1341
1342 case XFS_IOC_ALLOCSP:
1343 case XFS_IOC_FREESP:
1344 case XFS_IOC_RESVSP:
1345 case XFS_IOC_UNRESVSP:
1346 case XFS_IOC_ALLOCSP64:
1347 case XFS_IOC_FREESP64:
1348 case XFS_IOC_RESVSP64:
1349 case XFS_IOC_UNRESVSP64:
1350 /*
1351 * Only allow the sys admin to reserve space unless
1352 * unwritten extents are enabled.
1353 */
1354 if (!xfs_sb_version_hasextflgbit(&mp->m_sb) &&
1355 !capable(CAP_SYS_ADMIN))
1356 return -EPERM;
1357
1358 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, arg);
1359
1360 case XFS_IOC_DIOINFO: {
1361 struct dioattr da;
1362 xfs_buftarg_t *target =
1363 XFS_IS_REALTIME_INODE(ip) ?
1364 mp->m_rtdev_targp : mp->m_ddev_targp;
1365
1366 da.d_mem = da.d_miniosz = 1 << target->bt_sshift;
1367 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1368
1369 if (copy_to_user(arg, &da, sizeof(da)))
1370 return -XFS_ERROR(EFAULT);
1371 return 0;
1372 }
1373
1374 case XFS_IOC_FSBULKSTAT_SINGLE:
1375 case XFS_IOC_FSBULKSTAT:
1376 case XFS_IOC_FSINUMBERS:
1377 return xfs_ioc_bulkstat(mp, cmd, arg);
1378
1379 case XFS_IOC_FSGEOMETRY_V1:
1380 return xfs_ioc_fsgeometry_v1(mp, arg);
1381
1382 case XFS_IOC_FSGEOMETRY:
1383 return xfs_ioc_fsgeometry(mp, arg);
1384
1385 case XFS_IOC_GETVERSION:
1386 return put_user(inode->i_generation, (int __user *)arg);
1387
1388 case XFS_IOC_FSGETXATTR:
1389 return xfs_ioc_fsgetxattr(ip, 0, arg);
1390 case XFS_IOC_FSGETXATTRA:
1391 return xfs_ioc_fsgetxattr(ip, 1, arg);
1392 case XFS_IOC_FSSETXATTR:
1393 return xfs_ioc_fssetxattr(ip, filp, arg);
1394 case XFS_IOC_GETXFLAGS:
1395 return xfs_ioc_getxflags(ip, arg);
1396 case XFS_IOC_SETXFLAGS:
1397 return xfs_ioc_setxflags(ip, filp, arg);
1398
1399 case XFS_IOC_FSSETDM: {
1400 struct fsdmidata dmi;
1401
1402 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1403 return -XFS_ERROR(EFAULT);
1404
1405 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1406 dmi.fsd_dmstate);
1407 return -error;
1408 }
1409
1410 case XFS_IOC_GETBMAP:
1411 case XFS_IOC_GETBMAPA:
1412 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1413
1414 case XFS_IOC_GETBMAPX:
1415 return xfs_ioc_getbmapx(ip, arg);
1416
1417 case XFS_IOC_FD_TO_HANDLE:
1418 case XFS_IOC_PATH_TO_HANDLE:
1419 case XFS_IOC_PATH_TO_FSHANDLE:
1420 return xfs_find_handle(cmd, arg);
1421
1422 case XFS_IOC_OPEN_BY_HANDLE:
1423 return xfs_open_by_handle(mp, arg, filp, inode);
1424
1425 case XFS_IOC_FSSETDM_BY_HANDLE:
1426 return xfs_fssetdm_by_handle(mp, arg, inode);
1427
1428 case XFS_IOC_READLINK_BY_HANDLE:
1429 return xfs_readlink_by_handle(mp, arg, inode);
1430
1431 case XFS_IOC_ATTRLIST_BY_HANDLE:
1432 return xfs_attrlist_by_handle(mp, arg, inode);
1433
1434 case XFS_IOC_ATTRMULTI_BY_HANDLE:
1435 return xfs_attrmulti_by_handle(mp, arg, filp, inode);
1436
1437 case XFS_IOC_SWAPEXT: {
1438 error = xfs_swapext((struct xfs_swapext __user *)arg);
1439 return -error;
1440 }
1441
1442 case XFS_IOC_FSCOUNTS: {
1443 xfs_fsop_counts_t out;
1444
1445 error = xfs_fs_counts(mp, &out);
1446 if (error)
1447 return -error;
1448
1449 if (copy_to_user(arg, &out, sizeof(out)))
1450 return -XFS_ERROR(EFAULT);
1451 return 0;
1452 }
1453
1454 case XFS_IOC_SET_RESBLKS: {
1455 xfs_fsop_resblks_t inout;
1456 __uint64_t in;
1457
1458 if (!capable(CAP_SYS_ADMIN))
1459 return -EPERM;
1460
1461 if (copy_from_user(&inout, arg, sizeof(inout)))
1462 return -XFS_ERROR(EFAULT);
1463
1464 /* input parameter is passed in resblks field of structure */
1465 in = inout.resblks;
1466 error = xfs_reserve_blocks(mp, &in, &inout);
1467 if (error)
1468 return -error;
1469
1470 if (copy_to_user(arg, &inout, sizeof(inout)))
1471 return -XFS_ERROR(EFAULT);
1472 return 0;
1473 }
1474
1475 case XFS_IOC_GET_RESBLKS: {
1476 xfs_fsop_resblks_t out;
1477
1478 if (!capable(CAP_SYS_ADMIN))
1479 return -EPERM;
1480
1481 error = xfs_reserve_blocks(mp, NULL, &out);
1482 if (error)
1483 return -error;
1484
1485 if (copy_to_user(arg, &out, sizeof(out)))
1486 return -XFS_ERROR(EFAULT);
1487
1488 return 0;
1489 }
1490
1491 case XFS_IOC_FSGROWFSDATA: {
1492 xfs_growfs_data_t in;
1493
1494 if (!capable(CAP_SYS_ADMIN))
1495 return -EPERM;
1496
1497 if (copy_from_user(&in, arg, sizeof(in)))
1498 return -XFS_ERROR(EFAULT);
1499
1500 error = xfs_growfs_data(mp, &in);
1501 return -error;
1502 }
1503
1504 case XFS_IOC_FSGROWFSLOG: {
1505 xfs_growfs_log_t in;
1506
1507 if (!capable(CAP_SYS_ADMIN))
1508 return -EPERM;
1509
1510 if (copy_from_user(&in, arg, sizeof(in)))
1511 return -XFS_ERROR(EFAULT);
1512
1513 error = xfs_growfs_log(mp, &in);
1514 return -error;
1515 }
1516
1517 case XFS_IOC_FSGROWFSRT: {
1518 xfs_growfs_rt_t in;
1519
1520 if (!capable(CAP_SYS_ADMIN))
1521 return -EPERM;
1522
1523 if (copy_from_user(&in, arg, sizeof(in)))
1524 return -XFS_ERROR(EFAULT);
1525
1526 error = xfs_growfs_rt(mp, &in);
1527 return -error;
1528 }
1529
1530 case XFS_IOC_FREEZE:
1531 if (!capable(CAP_SYS_ADMIN))
1532 return -EPERM;
1533
1534 if (inode->i_sb->s_frozen == SB_UNFROZEN)
1535 freeze_bdev(inode->i_sb->s_bdev);
1536 return 0;
1537
1538 case XFS_IOC_THAW:
1539 if (!capable(CAP_SYS_ADMIN))
1540 return -EPERM;
1541 if (inode->i_sb->s_frozen != SB_UNFROZEN)
1542 thaw_bdev(inode->i_sb->s_bdev, inode->i_sb);
1543 return 0;
1544
1545 case XFS_IOC_GOINGDOWN: {
1546 __uint32_t in;
1547
1548 if (!capable(CAP_SYS_ADMIN))
1549 return -EPERM;
1550
1551 if (get_user(in, (__uint32_t __user *)arg))
1552 return -XFS_ERROR(EFAULT);
1553
1554 error = xfs_fs_goingdown(mp, in);
1555 return -error;
1556 }
1557
1558 case XFS_IOC_ERROR_INJECTION: {
1559 xfs_error_injection_t in;
1560
1561 if (!capable(CAP_SYS_ADMIN))
1562 return -EPERM;
1563
1564 if (copy_from_user(&in, arg, sizeof(in)))
1565 return -XFS_ERROR(EFAULT);
1566
1567 error = xfs_errortag_add(in.errtag, mp);
1568 return -error;
1569 }
1570
1571 case XFS_IOC_ERROR_CLEARALL:
1572 if (!capable(CAP_SYS_ADMIN))
1573 return -EPERM;
1574
1575 error = xfs_errortag_clearall(mp, 1);
1576 return -error;
1577
1578 default:
1579 return -ENOTTY;
1580 }
1581 }
ubuntu-bionic-kernel mirror