?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
CRED: Pass credentials through dentry_open()
[linux-2.6/mini2440.git] / fs / xfs / linux-2.6 / xfs_ioctl.c
blob281cbd5a25cfd1550645370cf339e0e251d1f721
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 const struct cred *cred = current_cred();
260 int error;
261 int new_fd;
262 int permflag;
263 struct file *filp;
264 struct inode *inode;
265 struct dentry *dentry;
266 xfs_fsop_handlereq_t hreq;
267
268 if (!capable(CAP_SYS_ADMIN))
269 return -XFS_ERROR(EPERM);
270 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
271 return -XFS_ERROR(EFAULT);
272
273 error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &inode);
274 if (error)
275 return -error;
276
277 /* Restrict xfs_open_by_handle to directories & regular files. */
278 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
279 iput(inode);
280 return -XFS_ERROR(EINVAL);
281 }
282
283 #if BITS_PER_LONG != 32
284 hreq.oflags |= O_LARGEFILE;
285 #endif
286 /* Put open permission in namei format. */
287 permflag = hreq.oflags;
288 if ((permflag+1) & O_ACCMODE)
289 permflag++;
290 if (permflag & O_TRUNC)
291 permflag |= 2;
292
293 if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
294 (permflag & FMODE_WRITE) && IS_APPEND(inode)) {
295 iput(inode);
296 return -XFS_ERROR(EPERM);
297 }
298
299 if ((permflag & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
300 iput(inode);
301 return -XFS_ERROR(EACCES);
302 }
303
304 /* Can't write directories. */
305 if ( S_ISDIR(inode->i_mode) && (permflag & FMODE_WRITE)) {
306 iput(inode);
307 return -XFS_ERROR(EISDIR);
308 }
309
310 if ((new_fd = get_unused_fd()) < 0) {
311 iput(inode);
312 return new_fd;
313 }
314
315 dentry = d_obtain_alias(inode);
316 if (IS_ERR(dentry)) {
317 put_unused_fd(new_fd);
318 return PTR_ERR(dentry);
319 }
320
321 /* Ensure umount returns EBUSY on umounts while this file is open. */
322 mntget(parfilp->f_path.mnt);
323
324 /* Create file pointer. */
325 filp = dentry_open(dentry, parfilp->f_path.mnt, hreq.oflags, cred);
326 if (IS_ERR(filp)) {
327 put_unused_fd(new_fd);
328 return -XFS_ERROR(-PTR_ERR(filp));
329 }
330 if (inode->i_mode & S_IFREG) {
331 /* invisible operation should not change atime */
332 filp->f_flags |= O_NOATIME;
333 filp->f_op = &xfs_invis_file_operations;
334 }
335
336 fd_install(new_fd, filp);
337 return new_fd;
338 }
339
340 /*
341 * This is a copy from fs/namei.c:vfs_readlink(), except for removing it's
342 * unused first argument.
343 */
344 STATIC int
345 do_readlink(
346 char __user *buffer,
347 int buflen,
348 const char *link)
349 {
350 int len;
351
352 len = PTR_ERR(link);
353 if (IS_ERR(link))
354 goto out;
355
356 len = strlen(link);
357 if (len > (unsigned) buflen)
358 len = buflen;
359 if (copy_to_user(buffer, link, len))
360 len = -EFAULT;
361 out:
362 return len;
363 }
364
365
366 STATIC int
367 xfs_readlink_by_handle(
368 xfs_mount_t *mp,
369 void __user *arg,
370 struct inode *parinode)
371 {
372 struct inode *inode;
373 xfs_fsop_handlereq_t hreq;
374 __u32 olen;
375 void *link;
376 int error;
377
378 if (!capable(CAP_SYS_ADMIN))
379 return -XFS_ERROR(EPERM);
380 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
381 return -XFS_ERROR(EFAULT);
382
383 error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &inode);
384 if (error)
385 return -error;
386
387 /* Restrict this handle operation to symlinks only. */
388 if (!S_ISLNK(inode->i_mode)) {
389 error = -XFS_ERROR(EINVAL);
390 goto out_iput;
391 }
392
393 if (copy_from_user(&olen, hreq.ohandlen, sizeof(__u32))) {
394 error = -XFS_ERROR(EFAULT);
395 goto out_iput;
396 }
397
398 link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
399 if (!link)
400 goto out_iput;
401
402 error = -xfs_readlink(XFS_I(inode), link);
403 if (error)
404 goto out_kfree;
405 error = do_readlink(hreq.ohandle, olen, link);
406 if (error)
407 goto out_kfree;
408
409 out_kfree:
410 kfree(link);
411 out_iput:
412 iput(inode);
413 return error;
414 }
415
416 STATIC int
417 xfs_fssetdm_by_handle(
418 xfs_mount_t *mp,
419 void __user *arg,
420 struct inode *parinode)
421 {
422 int error;
423 struct fsdmidata fsd;
424 xfs_fsop_setdm_handlereq_t dmhreq;
425 struct inode *inode;
426
427 if (!capable(CAP_MKNOD))
428 return -XFS_ERROR(EPERM);
429 if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
430 return -XFS_ERROR(EFAULT);
431
432 error = xfs_vget_fsop_handlereq(mp, parinode, &dmhreq.hreq, &inode);
433 if (error)
434 return -error;
435
436 if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {
437 error = -XFS_ERROR(EPERM);
438 goto out;
439 }
440
441 if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
442 error = -XFS_ERROR(EFAULT);
443 goto out;
444 }
445
446 error = -xfs_set_dmattrs(XFS_I(inode), fsd.fsd_dmevmask,
447 fsd.fsd_dmstate);
448
449 out:
450 iput(inode);
451 return error;
452 }
453
454 STATIC int
455 xfs_attrlist_by_handle(
456 xfs_mount_t *mp,
457 void __user *arg,
458 struct inode *parinode)
459 {
460 int error;
461 attrlist_cursor_kern_t *cursor;
462 xfs_fsop_attrlist_handlereq_t al_hreq;
463 struct inode *inode;
464 char *kbuf;
465
466 if (!capable(CAP_SYS_ADMIN))
467 return -XFS_ERROR(EPERM);
468 if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
469 return -XFS_ERROR(EFAULT);
470 if (al_hreq.buflen > XATTR_LIST_MAX)
471 return -XFS_ERROR(EINVAL);
472
473 /*
474 * Reject flags, only allow namespaces.
475 */
476 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
477 return -XFS_ERROR(EINVAL);
478
479 error = xfs_vget_fsop_handlereq(mp, parinode, &al_hreq.hreq, &inode);
480 if (error)
481 goto out;
482
483 kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);
484 if (!kbuf)
485 goto out_vn_rele;
486
487 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
488 error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,
489 al_hreq.flags, cursor);
490 if (error)
491 goto out_kfree;
492
493 if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
494 error = -EFAULT;
495
496 out_kfree:
497 kfree(kbuf);
498 out_vn_rele:
499 iput(inode);
500 out:
501 return -error;
502 }
503
504 STATIC int
505 xfs_attrmulti_attr_get(
506 struct inode *inode,
507 char *name,
508 char __user *ubuf,
509 __uint32_t *len,
510 __uint32_t flags)
511 {
512 char *kbuf;
513 int error = EFAULT;
514
515 if (*len > XATTR_SIZE_MAX)
516 return EINVAL;
517 kbuf = kmalloc(*len, GFP_KERNEL);
518 if (!kbuf)
519 return ENOMEM;
520
521 error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
522 if (error)
523 goto out_kfree;
524
525 if (copy_to_user(ubuf, kbuf, *len))
526 error = EFAULT;
527
528 out_kfree:
529 kfree(kbuf);
530 return error;
531 }
532
533 STATIC int
534 xfs_attrmulti_attr_set(
535 struct inode *inode,
536 char *name,
537 const char __user *ubuf,
538 __uint32_t len,
539 __uint32_t flags)
540 {
541 char *kbuf;
542 int error = EFAULT;
543
544 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
545 return EPERM;
546 if (len > XATTR_SIZE_MAX)
547 return EINVAL;
548
549 kbuf = kmalloc(len, GFP_KERNEL);
550 if (!kbuf)
551 return ENOMEM;
552
553 if (copy_from_user(kbuf, ubuf, len))
554 goto out_kfree;
555
556 error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
557
558 out_kfree:
559 kfree(kbuf);
560 return error;
561 }
562
563 STATIC int
564 xfs_attrmulti_attr_remove(
565 struct inode *inode,
566 char *name,
567 __uint32_t flags)
568 {
569 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
570 return EPERM;
571 return xfs_attr_remove(XFS_I(inode), name, flags);
572 }
573
574 STATIC int
575 xfs_attrmulti_by_handle(
576 xfs_mount_t *mp,
577 void __user *arg,
578 struct file *parfilp,
579 struct inode *parinode)
580 {
581 int error;
582 xfs_attr_multiop_t *ops;
583 xfs_fsop_attrmulti_handlereq_t am_hreq;
584 struct inode *inode;
585 unsigned int i, size;
586 char *attr_name;
587
588 if (!capable(CAP_SYS_ADMIN))
589 return -XFS_ERROR(EPERM);
590 if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
591 return -XFS_ERROR(EFAULT);
592
593 error = xfs_vget_fsop_handlereq(mp, parinode, &am_hreq.hreq, &inode);
594 if (error)
595 goto out;
596
597 error = E2BIG;
598 size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
599 if (!size || size > 16 * PAGE_SIZE)
600 goto out_vn_rele;
601
602 error = ENOMEM;
603 ops = kmalloc(size, GFP_KERNEL);
604 if (!ops)
605 goto out_vn_rele;
606
607 error = EFAULT;
608 if (copy_from_user(ops, am_hreq.ops, size))
609 goto out_kfree_ops;
610
611 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
612 if (!attr_name)
613 goto out_kfree_ops;
614
615
616 error = 0;
617 for (i = 0; i < am_hreq.opcount; i++) {
618 ops[i].am_error = strncpy_from_user(attr_name,
619 ops[i].am_attrname, MAXNAMELEN);
620 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
621 error = -ERANGE;
622 if (ops[i].am_error < 0)
623 break;
624
625 switch (ops[i].am_opcode) {
626 case ATTR_OP_GET:
627 ops[i].am_error = xfs_attrmulti_attr_get(inode,
628 attr_name, ops[i].am_attrvalue,
629 &ops[i].am_length, ops[i].am_flags);
630 break;
631 case ATTR_OP_SET:
632 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
633 if (ops[i].am_error)
634 break;
635 ops[i].am_error = xfs_attrmulti_attr_set(inode,
636 attr_name, ops[i].am_attrvalue,
637 ops[i].am_length, ops[i].am_flags);
638 mnt_drop_write(parfilp->f_path.mnt);
639 break;
640 case ATTR_OP_REMOVE:
641 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
642 if (ops[i].am_error)
643 break;
644 ops[i].am_error = xfs_attrmulti_attr_remove(inode,
645 attr_name, ops[i].am_flags);
646 mnt_drop_write(parfilp->f_path.mnt);
647 break;
648 default:
649 ops[i].am_error = EINVAL;
650 }
651 }
652
653 if (copy_to_user(am_hreq.ops, ops, size))
654 error = XFS_ERROR(EFAULT);
655
656 kfree(attr_name);
657 out_kfree_ops:
658 kfree(ops);
659 out_vn_rele:
660 iput(inode);
661 out:
662 return -error;
663 }
664
665 STATIC int
666 xfs_ioc_space(
667 struct xfs_inode *ip,
668 struct inode *inode,
669 struct file *filp,
670 int ioflags,
671 unsigned int cmd,
672 void __user *arg)
673 {
674 xfs_flock64_t bf;
675 int attr_flags = 0;
676 int error;
677
678 if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
679 return -XFS_ERROR(EPERM);
680
681 if (!(filp->f_mode & FMODE_WRITE))
682 return -XFS_ERROR(EBADF);
683
684 if (!S_ISREG(inode->i_mode))
685 return -XFS_ERROR(EINVAL);
686
687 if (copy_from_user(&bf, arg, sizeof(bf)))
688 return -XFS_ERROR(EFAULT);
689
690 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
691 attr_flags |= XFS_ATTR_NONBLOCK;
692 if (ioflags & IO_INVIS)
693 attr_flags |= XFS_ATTR_DMI;
694
695 error = xfs_change_file_space(ip, cmd, &bf, filp->f_pos,
696 NULL, attr_flags);
697 return -error;
698 }
699
700 STATIC int
701 xfs_ioc_bulkstat(
702 xfs_mount_t *mp,
703 unsigned int cmd,
704 void __user *arg)
705 {
706 xfs_fsop_bulkreq_t bulkreq;
707 int count; /* # of records returned */
708 xfs_ino_t inlast; /* last inode number */
709 int done;
710 int error;
711
712 /* done = 1 if there are more stats to get and if bulkstat */
713 /* should be called again (unused here, but used in dmapi) */
714
715 if (!capable(CAP_SYS_ADMIN))
716 return -EPERM;
717
718 if (XFS_FORCED_SHUTDOWN(mp))
719 return -XFS_ERROR(EIO);
720
721 if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
722 return -XFS_ERROR(EFAULT);
723
724 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
725 return -XFS_ERROR(EFAULT);
726
727 if ((count = bulkreq.icount) <= 0)
728 return -XFS_ERROR(EINVAL);
729
730 if (bulkreq.ubuffer == NULL)
731 return -XFS_ERROR(EINVAL);
732
733 if (cmd == XFS_IOC_FSINUMBERS)
734 error = xfs_inumbers(mp, &inlast, &count,
735 bulkreq.ubuffer, xfs_inumbers_fmt);
736 else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
737 error = xfs_bulkstat_single(mp, &inlast,
738 bulkreq.ubuffer, &done);
739 else /* XFS_IOC_FSBULKSTAT */
740 error = xfs_bulkstat(mp, &inlast, &count,
741 (bulkstat_one_pf)xfs_bulkstat_one, NULL,
742 sizeof(xfs_bstat_t), bulkreq.ubuffer,
743 BULKSTAT_FG_QUICK, &done);
744
745 if (error)
746 return -error;
747
748 if (bulkreq.ocount != NULL) {
749 if (copy_to_user(bulkreq.lastip, &inlast,
750 sizeof(xfs_ino_t)))
751 return -XFS_ERROR(EFAULT);
752
753 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
754 return -XFS_ERROR(EFAULT);
755 }
756
757 return 0;
758 }
759
760 STATIC int
761 xfs_ioc_fsgeometry_v1(
762 xfs_mount_t *mp,
763 void __user *arg)
764 {
765 xfs_fsop_geom_v1_t fsgeo;
766 int error;
767
768 error = xfs_fs_geometry(mp, (xfs_fsop_geom_t *)&fsgeo, 3);
769 if (error)
770 return -error;
771
772 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
773 return -XFS_ERROR(EFAULT);
774 return 0;
775 }
776
777 STATIC int
778 xfs_ioc_fsgeometry(
779 xfs_mount_t *mp,
780 void __user *arg)
781 {
782 xfs_fsop_geom_t fsgeo;
783 int error;
784
785 error = xfs_fs_geometry(mp, &fsgeo, 4);
786 if (error)
787 return -error;
788
789 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
790 return -XFS_ERROR(EFAULT);
791 return 0;
792 }
793
794 /*
795 * Linux extended inode flags interface.
796 */
797
798 STATIC unsigned int
799 xfs_merge_ioc_xflags(
800 unsigned int flags,
801 unsigned int start)
802 {
803 unsigned int xflags = start;
804
805 if (flags & FS_IMMUTABLE_FL)
806 xflags |= XFS_XFLAG_IMMUTABLE;
807 else
808 xflags &= ~XFS_XFLAG_IMMUTABLE;
809 if (flags & FS_APPEND_FL)
810 xflags |= XFS_XFLAG_APPEND;
811 else
812 xflags &= ~XFS_XFLAG_APPEND;
813 if (flags & FS_SYNC_FL)
814 xflags |= XFS_XFLAG_SYNC;
815 else
816 xflags &= ~XFS_XFLAG_SYNC;
817 if (flags & FS_NOATIME_FL)
818 xflags |= XFS_XFLAG_NOATIME;
819 else
820 xflags &= ~XFS_XFLAG_NOATIME;
821 if (flags & FS_NODUMP_FL)
822 xflags |= XFS_XFLAG_NODUMP;
823 else
824 xflags &= ~XFS_XFLAG_NODUMP;
825
826 return xflags;
827 }
828
829 STATIC unsigned int
830 xfs_di2lxflags(
831 __uint16_t di_flags)
832 {
833 unsigned int flags = 0;
834
835 if (di_flags & XFS_DIFLAG_IMMUTABLE)
836 flags |= FS_IMMUTABLE_FL;
837 if (di_flags & XFS_DIFLAG_APPEND)
838 flags |= FS_APPEND_FL;
839 if (di_flags & XFS_DIFLAG_SYNC)
840 flags |= FS_SYNC_FL;
841 if (di_flags & XFS_DIFLAG_NOATIME)
842 flags |= FS_NOATIME_FL;
843 if (di_flags & XFS_DIFLAG_NODUMP)
844 flags |= FS_NODUMP_FL;
845 return flags;
846 }
847
848 STATIC int
849 xfs_ioc_fsgetxattr(
850 xfs_inode_t *ip,
851 int attr,
852 void __user *arg)
853 {
854 struct fsxattr fa;
855
856 xfs_ilock(ip, XFS_ILOCK_SHARED);
857 fa.fsx_xflags = xfs_ip2xflags(ip);
858 fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
859 fa.fsx_projid = ip->i_d.di_projid;
860
861 if (attr) {
862 if (ip->i_afp) {
863 if (ip->i_afp->if_flags & XFS_IFEXTENTS)
864 fa.fsx_nextents = ip->i_afp->if_bytes /
865 sizeof(xfs_bmbt_rec_t);
866 else
867 fa.fsx_nextents = ip->i_d.di_anextents;
868 } else
869 fa.fsx_nextents = 0;
870 } else {
871 if (ip->i_df.if_flags & XFS_IFEXTENTS)
872 fa.fsx_nextents = ip->i_df.if_bytes /
873 sizeof(xfs_bmbt_rec_t);
874 else
875 fa.fsx_nextents = ip->i_d.di_nextents;
876 }
877 xfs_iunlock(ip, XFS_ILOCK_SHARED);
878
879 if (copy_to_user(arg, &fa, sizeof(fa)))
880 return -EFAULT;
881 return 0;
882 }
883
884 STATIC void
885 xfs_set_diflags(
886 struct xfs_inode *ip,
887 unsigned int xflags)
888 {
889 unsigned int di_flags;
890
891 /* can't set PREALLOC this way, just preserve it */
892 di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
893 if (xflags & XFS_XFLAG_IMMUTABLE)
894 di_flags |= XFS_DIFLAG_IMMUTABLE;
895 if (xflags & XFS_XFLAG_APPEND)
896 di_flags |= XFS_DIFLAG_APPEND;
897 if (xflags & XFS_XFLAG_SYNC)
898 di_flags |= XFS_DIFLAG_SYNC;
899 if (xflags & XFS_XFLAG_NOATIME)
900 di_flags |= XFS_DIFLAG_NOATIME;
901 if (xflags & XFS_XFLAG_NODUMP)
902 di_flags |= XFS_DIFLAG_NODUMP;
903 if (xflags & XFS_XFLAG_PROJINHERIT)
904 di_flags |= XFS_DIFLAG_PROJINHERIT;
905 if (xflags & XFS_XFLAG_NODEFRAG)
906 di_flags |= XFS_DIFLAG_NODEFRAG;
907 if (xflags & XFS_XFLAG_FILESTREAM)
908 di_flags |= XFS_DIFLAG_FILESTREAM;
909 if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
910 if (xflags & XFS_XFLAG_RTINHERIT)
911 di_flags |= XFS_DIFLAG_RTINHERIT;
912 if (xflags & XFS_XFLAG_NOSYMLINKS)
913 di_flags |= XFS_DIFLAG_NOSYMLINKS;
914 if (xflags & XFS_XFLAG_EXTSZINHERIT)
915 di_flags |= XFS_DIFLAG_EXTSZINHERIT;
916 } else if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
917 if (xflags & XFS_XFLAG_REALTIME)
918 di_flags |= XFS_DIFLAG_REALTIME;
919 if (xflags & XFS_XFLAG_EXTSIZE)
920 di_flags |= XFS_DIFLAG_EXTSIZE;
921 }
922
923 ip->i_d.di_flags = di_flags;
924 }
925
926 STATIC void
927 xfs_diflags_to_linux(
928 struct xfs_inode *ip)
929 {
930 struct inode *inode = VFS_I(ip);
931 unsigned int xflags = xfs_ip2xflags(ip);
932
933 if (xflags & XFS_XFLAG_IMMUTABLE)
934 inode->i_flags |= S_IMMUTABLE;
935 else
936 inode->i_flags &= ~S_IMMUTABLE;
937 if (xflags & XFS_XFLAG_APPEND)
938 inode->i_flags |= S_APPEND;
939 else
940 inode->i_flags &= ~S_APPEND;
941 if (xflags & XFS_XFLAG_SYNC)
942 inode->i_flags |= S_SYNC;
943 else
944 inode->i_flags &= ~S_SYNC;
945 if (xflags & XFS_XFLAG_NOATIME)
946 inode->i_flags |= S_NOATIME;
947 else
948 inode->i_flags &= ~S_NOATIME;
949 }
950
951 #define FSX_PROJID 1
952 #define FSX_EXTSIZE 2
953 #define FSX_XFLAGS 4
954 #define FSX_NONBLOCK 8
955
956 STATIC int
957 xfs_ioctl_setattr(
958 xfs_inode_t *ip,
959 struct fsxattr *fa,
960 int mask)
961 {
962 struct xfs_mount *mp = ip->i_mount;
963 struct xfs_trans *tp;
964 unsigned int lock_flags = 0;
965 struct xfs_dquot *udqp = NULL, *gdqp = NULL;
966 struct xfs_dquot *olddquot = NULL;
967 int code;
968
969 xfs_itrace_entry(ip);
970
971 if (mp->m_flags & XFS_MOUNT_RDONLY)
972 return XFS_ERROR(EROFS);
973 if (XFS_FORCED_SHUTDOWN(mp))
974 return XFS_ERROR(EIO);
975
976 /*
977 * If disk quotas is on, we make sure that the dquots do exist on disk,
978 * before we start any other transactions. Trying to do this later
979 * is messy. We don't care to take a readlock to look at the ids
980 * in inode here, because we can't hold it across the trans_reserve.
981 * If the IDs do change before we take the ilock, we're covered
982 * because the i_*dquot fields will get updated anyway.
983 */
984 if (XFS_IS_QUOTA_ON(mp) && (mask & FSX_PROJID)) {
985 code = XFS_QM_DQVOPALLOC(mp, ip, ip->i_d.di_uid,
986 ip->i_d.di_gid, fa->fsx_projid,
987 XFS_QMOPT_PQUOTA, &udqp, &gdqp);
988 if (code)
989 return code;
990 }
991
992 /*
993 * For the other attributes, we acquire the inode lock and
994 * first do an error checking pass.
995 */
996 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
997 code = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);
998 if (code)
999 goto error_return;
1000
1001 lock_flags = XFS_ILOCK_EXCL;
1002 xfs_ilock(ip, lock_flags);
1003
1004 /*
1005 * CAP_FOWNER overrides the following restrictions:
1006 *
1007 * The user ID of the calling process must be equal
1008 * to the file owner ID, except in cases where the
1009 * CAP_FSETID capability is applicable.
1010 */
1011 if (current_fsuid() != ip->i_d.di_uid && !capable(CAP_FOWNER)) {
1012 code = XFS_ERROR(EPERM);
1013 goto error_return;
1014 }
1015
1016 /*
1017 * Do a quota reservation only if projid is actually going to change.
1018 */
1019 if (mask & FSX_PROJID) {
1020 if (XFS_IS_PQUOTA_ON(mp) &&
1021 ip->i_d.di_projid != fa->fsx_projid) {
1022 ASSERT(tp);
1023 code = XFS_QM_DQVOPCHOWNRESV(mp, tp, ip, udqp, gdqp,
1024 capable(CAP_FOWNER) ?
1025 XFS_QMOPT_FORCE_RES : 0);
1026 if (code) /* out of quota */
1027 goto error_return;
1028 }
1029 }
1030
1031 if (mask & FSX_EXTSIZE) {
1032 /*
1033 * Can't change extent size if any extents are allocated.
1034 */
1035 if (ip->i_d.di_nextents &&
1036 ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
1037 fa->fsx_extsize)) {
1038 code = XFS_ERROR(EINVAL); /* EFBIG? */
1039 goto error_return;
1040 }
1041
1042 /*
1043 * Extent size must be a multiple of the appropriate block
1044 * size, if set at all.
1045 */
1046 if (fa->fsx_extsize != 0) {
1047 xfs_extlen_t size;
1048
1049 if (XFS_IS_REALTIME_INODE(ip) ||
1050 ((mask & FSX_XFLAGS) &&
1051 (fa->fsx_xflags & XFS_XFLAG_REALTIME))) {
1052 size = mp->m_sb.sb_rextsize <<
1053 mp->m_sb.sb_blocklog;
1054 } else {
1055 size = mp->m_sb.sb_blocksize;
1056 }
1057
1058 if (fa->fsx_extsize % size) {
1059 code = XFS_ERROR(EINVAL);
1060 goto error_return;
1061 }
1062 }
1063 }
1064
1065
1066 if (mask & FSX_XFLAGS) {
1067 /*
1068 * Can't change realtime flag if any extents are allocated.
1069 */
1070 if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1071 (XFS_IS_REALTIME_INODE(ip)) !=
1072 (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1073 code = XFS_ERROR(EINVAL); /* EFBIG? */
1074 goto error_return;
1075 }
1076
1077 /*
1078 * If realtime flag is set then must have realtime data.
1079 */
1080 if ((fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1081 if ((mp->m_sb.sb_rblocks == 0) ||
1082 (mp->m_sb.sb_rextsize == 0) ||
1083 (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) {
1084 code = XFS_ERROR(EINVAL);
1085 goto error_return;
1086 }
1087 }
1088
1089 /*
1090 * Can't modify an immutable/append-only file unless
1091 * we have appropriate permission.
1092 */
1093 if ((ip->i_d.di_flags &
1094 (XFS_DIFLAG_IMMUTABLE|XFS_DIFLAG_APPEND) ||
1095 (fa->fsx_xflags &
1096 (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
1097 !capable(CAP_LINUX_IMMUTABLE)) {
1098 code = XFS_ERROR(EPERM);
1099 goto error_return;
1100 }
1101 }
1102
1103 xfs_trans_ijoin(tp, ip, lock_flags);
1104 xfs_trans_ihold(tp, ip);
1105
1106 /*
1107 * Change file ownership. Must be the owner or privileged.
1108 * If the system was configured with the "restricted_chown"
1109 * option, the owner is not permitted to give away the file,
1110 * and can change the group id only to a group of which he
1111 * or she is a member.
1112 */
1113 if (mask & FSX_PROJID) {
1114 /*
1115 * CAP_FSETID overrides the following restrictions:
1116 *
1117 * The set-user-ID and set-group-ID bits of a file will be
1118 * cleared upon successful return from chown()
1119 */
1120 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1121 !capable(CAP_FSETID))
1122 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
1123
1124 /*
1125 * Change the ownerships and register quota modifications
1126 * in the transaction.
1127 */
1128 if (ip->i_d.di_projid != fa->fsx_projid) {
1129 if (XFS_IS_PQUOTA_ON(mp)) {
1130 olddquot = XFS_QM_DQVOPCHOWN(mp, tp, ip,
1131 &ip->i_gdquot, gdqp);
1132 }
1133 ip->i_d.di_projid = fa->fsx_projid;
1134
1135 /*
1136 * We may have to rev the inode as well as
1137 * the superblock version number since projids didn't
1138 * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
1139 */
1140 if (ip->i_d.di_version == XFS_DINODE_VERSION_1)
1141 xfs_bump_ino_vers2(tp, ip);
1142 }
1143
1144 }
1145
1146 if (mask & FSX_EXTSIZE)
1147 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1148 if (mask & FSX_XFLAGS) {
1149 xfs_set_diflags(ip, fa->fsx_xflags);
1150 xfs_diflags_to_linux(ip);
1151 }
1152
1153 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1154 xfs_ichgtime(ip, XFS_ICHGTIME_CHG);
1155
1156 XFS_STATS_INC(xs_ig_attrchg);
1157
1158 /*
1159 * If this is a synchronous mount, make sure that the
1160 * transaction goes to disk before returning to the user.
1161 * This is slightly sub-optimal in that truncates require
1162 * two sync transactions instead of one for wsync filesystems.
1163 * One for the truncate and one for the timestamps since we
1164 * don't want to change the timestamps unless we're sure the
1165 * truncate worked. Truncates are less than 1% of the laddis
1166 * mix so this probably isn't worth the trouble to optimize.
1167 */
1168 if (mp->m_flags & XFS_MOUNT_WSYNC)
1169 xfs_trans_set_sync(tp);
1170 code = xfs_trans_commit(tp, 0);
1171 xfs_iunlock(ip, lock_flags);
1172
1173 /*
1174 * Release any dquot(s) the inode had kept before chown.
1175 */
1176 XFS_QM_DQRELE(mp, olddquot);
1177 XFS_QM_DQRELE(mp, udqp);
1178 XFS_QM_DQRELE(mp, gdqp);
1179
1180 if (code)
1181 return code;
1182
1183 if (DM_EVENT_ENABLED(ip, DM_EVENT_ATTRIBUTE)) {
1184 XFS_SEND_NAMESP(mp, DM_EVENT_ATTRIBUTE, ip, DM_RIGHT_NULL,
1185 NULL, DM_RIGHT_NULL, NULL, NULL, 0, 0,
1186 (mask & FSX_NONBLOCK) ? DM_FLAGS_NDELAY : 0);
1187 }
1188
1189 return 0;
1190
1191 error_return:
1192 XFS_QM_DQRELE(mp, udqp);
1193 XFS_QM_DQRELE(mp, gdqp);
1194 xfs_trans_cancel(tp, 0);
1195 if (lock_flags)
1196 xfs_iunlock(ip, lock_flags);
1197 return code;
1198 }
1199
1200 STATIC int
1201 xfs_ioc_fssetxattr(
1202 xfs_inode_t *ip,
1203 struct file *filp,
1204 void __user *arg)
1205 {
1206 struct fsxattr fa;
1207 unsigned int mask;
1208
1209 if (copy_from_user(&fa, arg, sizeof(fa)))
1210 return -EFAULT;
1211
1212 mask = FSX_XFLAGS | FSX_EXTSIZE | FSX_PROJID;
1213 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1214 mask |= FSX_NONBLOCK;
1215
1216 return -xfs_ioctl_setattr(ip, &fa, mask);
1217 }
1218
1219 STATIC int
1220 xfs_ioc_getxflags(
1221 xfs_inode_t *ip,
1222 void __user *arg)
1223 {
1224 unsigned int flags;
1225
1226 flags = xfs_di2lxflags(ip->i_d.di_flags);
1227 if (copy_to_user(arg, &flags, sizeof(flags)))
1228 return -EFAULT;
1229 return 0;
1230 }
1231
1232 STATIC int
1233 xfs_ioc_setxflags(
1234 xfs_inode_t *ip,
1235 struct file *filp,
1236 void __user *arg)
1237 {
1238 struct fsxattr fa;
1239 unsigned int flags;
1240 unsigned int mask;
1241
1242 if (copy_from_user(&flags, arg, sizeof(flags)))
1243 return -EFAULT;
1244
1245 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1246 FS_NOATIME_FL | FS_NODUMP_FL | \
1247 FS_SYNC_FL))
1248 return -EOPNOTSUPP;
1249
1250 mask = FSX_XFLAGS;
1251 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1252 mask |= FSX_NONBLOCK;
1253 fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1254
1255 return -xfs_ioctl_setattr(ip, &fa, mask);
1256 }
1257
1258 STATIC int
1259 xfs_ioc_getbmap(
1260 struct xfs_inode *ip,
1261 int ioflags,
1262 unsigned int cmd,
1263 void __user *arg)
1264 {
1265 struct getbmap bm;
1266 int iflags;
1267 int error;
1268
1269 if (copy_from_user(&bm, arg, sizeof(bm)))
1270 return -XFS_ERROR(EFAULT);
1271
1272 if (bm.bmv_count < 2)
1273 return -XFS_ERROR(EINVAL);
1274
1275 iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1276 if (ioflags & IO_INVIS)
1277 iflags |= BMV_IF_NO_DMAPI_READ;
1278
1279 error = xfs_getbmap(ip, &bm, (struct getbmap __user *)arg+1, iflags);
1280 if (error)
1281 return -error;
1282
1283 if (copy_to_user(arg, &bm, sizeof(bm)))
1284 return -XFS_ERROR(EFAULT);
1285 return 0;
1286 }
1287
1288 STATIC int
1289 xfs_ioc_getbmapx(
1290 struct xfs_inode *ip,
1291 void __user *arg)
1292 {
1293 struct getbmapx bmx;
1294 struct getbmap bm;
1295 int iflags;
1296 int error;
1297
1298 if (copy_from_user(&bmx, arg, sizeof(bmx)))
1299 return -XFS_ERROR(EFAULT);
1300
1301 if (bmx.bmv_count < 2)
1302 return -XFS_ERROR(EINVAL);
1303
1304 /*
1305 * Map input getbmapx structure to a getbmap
1306 * structure for xfs_getbmap.
1307 */
1308 GETBMAP_CONVERT(bmx, bm);
1309
1310 iflags = bmx.bmv_iflags;
1311
1312 if (iflags & (~BMV_IF_VALID))
1313 return -XFS_ERROR(EINVAL);
1314
1315 iflags |= BMV_IF_EXTENDED;
1316
1317 error = xfs_getbmap(ip, &bm, (struct getbmapx __user *)arg+1, iflags);
1318 if (error)
1319 return -error;
1320
1321 GETBMAP_CONVERT(bm, bmx);
1322
1323 if (copy_to_user(arg, &bmx, sizeof(bmx)))
1324 return -XFS_ERROR(EFAULT);
1325
1326 return 0;
1327 }
1328
1329 int
1330 xfs_ioctl(
1331 xfs_inode_t *ip,
1332 struct file *filp,
1333 int ioflags,
1334 unsigned int cmd,
1335 void __user *arg)
1336 {
1337 struct inode *inode = filp->f_path.dentry->d_inode;
1338 xfs_mount_t *mp = ip->i_mount;
1339 int error;
1340
1341 xfs_itrace_entry(XFS_I(inode));
1342 switch (cmd) {
1343
1344 case XFS_IOC_ALLOCSP:
1345 case XFS_IOC_FREESP:
1346 case XFS_IOC_RESVSP:
1347 case XFS_IOC_UNRESVSP:
1348 case XFS_IOC_ALLOCSP64:
1349 case XFS_IOC_FREESP64:
1350 case XFS_IOC_RESVSP64:
1351 case XFS_IOC_UNRESVSP64:
1352 /*
1353 * Only allow the sys admin to reserve space unless
1354 * unwritten extents are enabled.
1355 */
1356 if (!xfs_sb_version_hasextflgbit(&mp->m_sb) &&
1357 !capable(CAP_SYS_ADMIN))
1358 return -EPERM;
1359
1360 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, arg);
1361
1362 case XFS_IOC_DIOINFO: {
1363 struct dioattr da;
1364 xfs_buftarg_t *target =
1365 XFS_IS_REALTIME_INODE(ip) ?
1366 mp->m_rtdev_targp : mp->m_ddev_targp;
1367
1368 da.d_mem = da.d_miniosz = 1 << target->bt_sshift;
1369 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1370
1371 if (copy_to_user(arg, &da, sizeof(da)))
1372 return -XFS_ERROR(EFAULT);
1373 return 0;
1374 }
1375
1376 case XFS_IOC_FSBULKSTAT_SINGLE:
1377 case XFS_IOC_FSBULKSTAT:
1378 case XFS_IOC_FSINUMBERS:
1379 return xfs_ioc_bulkstat(mp, cmd, arg);
1380
1381 case XFS_IOC_FSGEOMETRY_V1:
1382 return xfs_ioc_fsgeometry_v1(mp, arg);
1383
1384 case XFS_IOC_FSGEOMETRY:
1385 return xfs_ioc_fsgeometry(mp, arg);
1386
1387 case XFS_IOC_GETVERSION:
1388 return put_user(inode->i_generation, (int __user *)arg);
1389
1390 case XFS_IOC_FSGETXATTR:
1391 return xfs_ioc_fsgetxattr(ip, 0, arg);
1392 case XFS_IOC_FSGETXATTRA:
1393 return xfs_ioc_fsgetxattr(ip, 1, arg);
1394 case XFS_IOC_FSSETXATTR:
1395 return xfs_ioc_fssetxattr(ip, filp, arg);
1396 case XFS_IOC_GETXFLAGS:
1397 return xfs_ioc_getxflags(ip, arg);
1398 case XFS_IOC_SETXFLAGS:
1399 return xfs_ioc_setxflags(ip, filp, arg);
1400
1401 case XFS_IOC_FSSETDM: {
1402 struct fsdmidata dmi;
1403
1404 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1405 return -XFS_ERROR(EFAULT);
1406
1407 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1408 dmi.fsd_dmstate);
1409 return -error;
1410 }
1411
1412 case XFS_IOC_GETBMAP:
1413 case XFS_IOC_GETBMAPA:
1414 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1415
1416 case XFS_IOC_GETBMAPX:
1417 return xfs_ioc_getbmapx(ip, arg);
1418
1419 case XFS_IOC_FD_TO_HANDLE:
1420 case XFS_IOC_PATH_TO_HANDLE:
1421 case XFS_IOC_PATH_TO_FSHANDLE:
1422 return xfs_find_handle(cmd, arg);
1423
1424 case XFS_IOC_OPEN_BY_HANDLE:
1425 return xfs_open_by_handle(mp, arg, filp, inode);
1426
1427 case XFS_IOC_FSSETDM_BY_HANDLE:
1428 return xfs_fssetdm_by_handle(mp, arg, inode);
1429
1430 case XFS_IOC_READLINK_BY_HANDLE:
1431 return xfs_readlink_by_handle(mp, arg, inode);
1432
1433 case XFS_IOC_ATTRLIST_BY_HANDLE:
1434 return xfs_attrlist_by_handle(mp, arg, inode);
1435
1436 case XFS_IOC_ATTRMULTI_BY_HANDLE:
1437 return xfs_attrmulti_by_handle(mp, arg, filp, inode);
1438
1439 case XFS_IOC_SWAPEXT: {
1440 error = xfs_swapext((struct xfs_swapext __user *)arg);
1441 return -error;
1442 }
1443
1444 case XFS_IOC_FSCOUNTS: {
1445 xfs_fsop_counts_t out;
1446
1447 error = xfs_fs_counts(mp, &out);
1448 if (error)
1449 return -error;
1450
1451 if (copy_to_user(arg, &out, sizeof(out)))
1452 return -XFS_ERROR(EFAULT);
1453 return 0;
1454 }
1455
1456 case XFS_IOC_SET_RESBLKS: {
1457 xfs_fsop_resblks_t inout;
1458 __uint64_t in;
1459
1460 if (!capable(CAP_SYS_ADMIN))
1461 return -EPERM;
1462
1463 if (copy_from_user(&inout, arg, sizeof(inout)))
1464 return -XFS_ERROR(EFAULT);
1465
1466 /* input parameter is passed in resblks field of structure */
1467 in = inout.resblks;
1468 error = xfs_reserve_blocks(mp, &in, &inout);
1469 if (error)
1470 return -error;
1471
1472 if (copy_to_user(arg, &inout, sizeof(inout)))
1473 return -XFS_ERROR(EFAULT);
1474 return 0;
1475 }
1476
1477 case XFS_IOC_GET_RESBLKS: {
1478 xfs_fsop_resblks_t out;
1479
1480 if (!capable(CAP_SYS_ADMIN))
1481 return -EPERM;
1482
1483 error = xfs_reserve_blocks(mp, NULL, &out);
1484 if (error)
1485 return -error;
1486
1487 if (copy_to_user(arg, &out, sizeof(out)))
1488 return -XFS_ERROR(EFAULT);
1489
1490 return 0;
1491 }
1492
1493 case XFS_IOC_FSGROWFSDATA: {
1494 xfs_growfs_data_t in;
1495
1496 if (!capable(CAP_SYS_ADMIN))
1497 return -EPERM;
1498
1499 if (copy_from_user(&in, arg, sizeof(in)))
1500 return -XFS_ERROR(EFAULT);
1501
1502 error = xfs_growfs_data(mp, &in);
1503 return -error;
1504 }
1505
1506 case XFS_IOC_FSGROWFSLOG: {
1507 xfs_growfs_log_t in;
1508
1509 if (!capable(CAP_SYS_ADMIN))
1510 return -EPERM;
1511
1512 if (copy_from_user(&in, arg, sizeof(in)))
1513 return -XFS_ERROR(EFAULT);
1514
1515 error = xfs_growfs_log(mp, &in);
1516 return -error;
1517 }
1518
1519 case XFS_IOC_FSGROWFSRT: {
1520 xfs_growfs_rt_t in;
1521
1522 if (!capable(CAP_SYS_ADMIN))
1523 return -EPERM;
1524
1525 if (copy_from_user(&in, arg, sizeof(in)))
1526 return -XFS_ERROR(EFAULT);
1527
1528 error = xfs_growfs_rt(mp, &in);
1529 return -error;
1530 }
1531
1532 case XFS_IOC_FREEZE:
1533 if (!capable(CAP_SYS_ADMIN))
1534 return -EPERM;
1535
1536 if (inode->i_sb->s_frozen == SB_UNFROZEN)
1537 freeze_bdev(inode->i_sb->s_bdev);
1538 return 0;
1539
1540 case XFS_IOC_THAW:
1541 if (!capable(CAP_SYS_ADMIN))
1542 return -EPERM;
1543 if (inode->i_sb->s_frozen != SB_UNFROZEN)
1544 thaw_bdev(inode->i_sb->s_bdev, inode->i_sb);
1545 return 0;
1546
1547 case XFS_IOC_GOINGDOWN: {
1548 __uint32_t in;
1549
1550 if (!capable(CAP_SYS_ADMIN))
1551 return -EPERM;
1552
1553 if (get_user(in, (__uint32_t __user *)arg))
1554 return -XFS_ERROR(EFAULT);
1555
1556 error = xfs_fs_goingdown(mp, in);
1557 return -error;
1558 }
1559
1560 case XFS_IOC_ERROR_INJECTION: {
1561 xfs_error_injection_t in;
1562
1563 if (!capable(CAP_SYS_ADMIN))
1564 return -EPERM;
1565
1566 if (copy_from_user(&in, arg, sizeof(in)))
1567 return -XFS_ERROR(EFAULT);
1568
1569 error = xfs_errortag_add(in.errtag, mp);
1570 return -error;
1571 }
1572
1573 case XFS_IOC_ERROR_CLEARALL:
1574 if (!capable(CAP_SYS_ADMIN))
1575 return -EPERM;
1576
1577 error = xfs_errortag_clearall(mp, 1);
1578 return -error;
1579
1580 default:
1581 return -ENOTTY;
1582 }
1583 }
Support for the Chinese Samsung S3C2440 based development boards