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
52 #include <linux/capability.h>
53 #include <linux/dcache.h>
54 #include <linux/mount.h>
55 #include <linux/namei.h>
56 #include <linux/pagemap.h>
57
58 /*
59 * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
60 * a file or fs handle.
61 *
62 * XFS_IOC_PATH_TO_FSHANDLE
63 * returns fs handle for a mount point or path within that mount point
64 * XFS_IOC_FD_TO_HANDLE
65 * returns full handle for a FD opened in user space
66 * XFS_IOC_PATH_TO_HANDLE
67 * returns full handle for a path
68 */
69 STATIC int
70 xfs_find_handle(
71 unsigned int cmd,
72 void __user *arg)
73 {
74 int hsize;
75 xfs_handle_t handle;
76 xfs_fsop_handlereq_t hreq;
77 struct inode *inode;
78
79 if (copy_from_user(&hreq, arg, sizeof(hreq)))
80 return -XFS_ERROR(EFAULT);
81
82 memset((char *)&handle, 0, sizeof(handle));
83
84 switch (cmd) {
85 case XFS_IOC_PATH_TO_FSHANDLE:
86 case XFS_IOC_PATH_TO_HANDLE: {
87 struct nameidata nd;
88 int error;
89
90 error = user_path_walk_link((const char __user *)hreq.path, &nd);
91 if (error)
92 return error;
93
94 ASSERT(nd.path.dentry);
95 ASSERT(nd.path.dentry->d_inode);
96 inode = igrab(nd.path.dentry->d_inode);
97 path_put(&nd.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_mode == 0 || 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 = XFS_ITOV(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_alloc_anon(inode);
315 if (dentry == NULL) {
316 iput(inode);
317 put_unused_fd(new_fd);
318 return -XFS_ERROR(ENOMEM);
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);
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 error = xfs_vget_fsop_handlereq(mp, parinode, &al_hreq.hreq, &inode);
474 if (error)
475 goto out;
476
477 kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);
478 if (!kbuf)
479 goto out_vn_rele;
480
481 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
482 error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,
483 al_hreq.flags, cursor);
484 if (error)
485 goto out_kfree;
486
487 if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
488 error = -EFAULT;
489
490 out_kfree:
491 kfree(kbuf);
492 out_vn_rele:
493 iput(inode);
494 out:
495 return -error;
496 }
497
498 STATIC int
499 xfs_attrmulti_attr_get(
500 struct inode *inode,
501 char *name,
502 char __user *ubuf,
503 __uint32_t *len,
504 __uint32_t flags)
505 {
506 char *kbuf;
507 int error = EFAULT;
508
509 if (*len > XATTR_SIZE_MAX)
510 return EINVAL;
511 kbuf = kmalloc(*len, GFP_KERNEL);
512 if (!kbuf)
513 return ENOMEM;
514
515 error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags, NULL);
516 if (error)
517 goto out_kfree;
518
519 if (copy_to_user(ubuf, kbuf, *len))
520 error = EFAULT;
521
522 out_kfree:
523 kfree(kbuf);
524 return error;
525 }
526
527 STATIC int
528 xfs_attrmulti_attr_set(
529 struct inode *inode,
530 char *name,
531 const char __user *ubuf,
532 __uint32_t len,
533 __uint32_t flags)
534 {
535 char *kbuf;
536 int error = EFAULT;
537
538 if (IS_RDONLY(inode))
539 return -EROFS;
540 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
541 return EPERM;
542 if (len > XATTR_SIZE_MAX)
543 return EINVAL;
544
545 kbuf = kmalloc(len, GFP_KERNEL);
546 if (!kbuf)
547 return ENOMEM;
548
549 if (copy_from_user(kbuf, ubuf, len))
550 goto out_kfree;
551
552 error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
553
554 out_kfree:
555 kfree(kbuf);
556 return error;
557 }
558
559 STATIC int
560 xfs_attrmulti_attr_remove(
561 struct inode *inode,
562 char *name,
563 __uint32_t flags)
564 {
565 if (IS_RDONLY(inode))
566 return -EROFS;
567 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
568 return EPERM;
569 return xfs_attr_remove(XFS_I(inode), name, flags);
570 }
571
572 STATIC int
573 xfs_attrmulti_by_handle(
574 xfs_mount_t *mp,
575 void __user *arg,
576 struct inode *parinode)
577 {
578 int error;
579 xfs_attr_multiop_t *ops;
580 xfs_fsop_attrmulti_handlereq_t am_hreq;
581 struct inode *inode;
582 unsigned int i, size;
583 char *attr_name;
584
585 if (!capable(CAP_SYS_ADMIN))
586 return -XFS_ERROR(EPERM);
587 if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
588 return -XFS_ERROR(EFAULT);
589
590 error = xfs_vget_fsop_handlereq(mp, parinode, &am_hreq.hreq, &inode);
591 if (error)
592 goto out;
593
594 error = E2BIG;
595 size = am_hreq.opcount * sizeof(attr_multiop_t);
596 if (!size || size > 16 * PAGE_SIZE)
597 goto out_vn_rele;
598
599 error = ENOMEM;
600 ops = kmalloc(size, GFP_KERNEL);
601 if (!ops)
602 goto out_vn_rele;
603
604 error = EFAULT;
605 if (copy_from_user(ops, am_hreq.ops, size))
606 goto out_kfree_ops;
607
608 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
609 if (!attr_name)
610 goto out_kfree_ops;
611
612
613 error = 0;
614 for (i = 0; i < am_hreq.opcount; i++) {
615 ops[i].am_error = strncpy_from_user(attr_name,
616 ops[i].am_attrname, MAXNAMELEN);
617 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
618 error = -ERANGE;
619 if (ops[i].am_error < 0)
620 break;
621
622 switch (ops[i].am_opcode) {
623 case ATTR_OP_GET:
624 ops[i].am_error = xfs_attrmulti_attr_get(inode,
625 attr_name, ops[i].am_attrvalue,
626 &ops[i].am_length, ops[i].am_flags);
627 break;
628 case ATTR_OP_SET:
629 ops[i].am_error = xfs_attrmulti_attr_set(inode,
630 attr_name, ops[i].am_attrvalue,
631 ops[i].am_length, ops[i].am_flags);
632 break;
633 case ATTR_OP_REMOVE:
634 ops[i].am_error = xfs_attrmulti_attr_remove(inode,
635 attr_name, ops[i].am_flags);
636 break;
637 default:
638 ops[i].am_error = EINVAL;
639 }
640 }
641
642 if (copy_to_user(am_hreq.ops, ops, size))
643 error = XFS_ERROR(EFAULT);
644
645 kfree(attr_name);
646 out_kfree_ops:
647 kfree(ops);
648 out_vn_rele:
649 iput(inode);
650 out:
651 return -error;
652 }
653
654 /* prototypes for a few of the stack-hungry cases that have
655 * their own functions. Functions are defined after their use
656 * so gcc doesn't get fancy and inline them with -03 */
657
658 STATIC int
659 xfs_ioc_space(
660 struct xfs_inode *ip,
661 struct inode *inode,
662 struct file *filp,
663 int flags,
664 unsigned int cmd,
665 void __user *arg);
666
667 STATIC int
668 xfs_ioc_bulkstat(
669 xfs_mount_t *mp,
670 unsigned int cmd,
671 void __user *arg);
672
673 STATIC int
674 xfs_ioc_fsgeometry_v1(
675 xfs_mount_t *mp,
676 void __user *arg);
677
678 STATIC int
679 xfs_ioc_fsgeometry(
680 xfs_mount_t *mp,
681 void __user *arg);
682
683 STATIC int
684 xfs_ioc_xattr(
685 xfs_inode_t *ip,
686 struct file *filp,
687 unsigned int cmd,
688 void __user *arg);
689
690 STATIC int
691 xfs_ioc_fsgetxattr(
692 xfs_inode_t *ip,
693 int attr,
694 void __user *arg);
695
696 STATIC int
697 xfs_ioc_getbmap(
698 struct xfs_inode *ip,
699 int flags,
700 unsigned int cmd,
701 void __user *arg);
702
703 STATIC int
704 xfs_ioc_getbmapx(
705 struct xfs_inode *ip,
706 void __user *arg);
707
708 int
709 xfs_ioctl(
710 xfs_inode_t *ip,
711 struct file *filp,
712 int ioflags,
713 unsigned int cmd,
714 void __user *arg)
715 {
716 struct inode *inode = filp->f_path.dentry->d_inode;
717 xfs_mount_t *mp = ip->i_mount;
718 int error;
719
720 xfs_itrace_entry(XFS_I(inode));
721 switch (cmd) {
722
723 case XFS_IOC_ALLOCSP:
724 case XFS_IOC_FREESP:
725 case XFS_IOC_RESVSP:
726 case XFS_IOC_UNRESVSP:
727 case XFS_IOC_ALLOCSP64:
728 case XFS_IOC_FREESP64:
729 case XFS_IOC_RESVSP64:
730 case XFS_IOC_UNRESVSP64:
731 /*
732 * Only allow the sys admin to reserve space unless
733 * unwritten extents are enabled.
734 */
735 if (!xfs_sb_version_hasextflgbit(&mp->m_sb) &&
736 !capable(CAP_SYS_ADMIN))
737 return -EPERM;
738
739 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, arg);
740
741 case XFS_IOC_DIOINFO: {
742 struct dioattr da;
743 xfs_buftarg_t *target =
744 XFS_IS_REALTIME_INODE(ip) ?
745 mp->m_rtdev_targp : mp->m_ddev_targp;
746
747 da.d_mem = da.d_miniosz = 1 << target->bt_sshift;
748 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
749
750 if (copy_to_user(arg, &da, sizeof(da)))
751 return -XFS_ERROR(EFAULT);
752 return 0;
753 }
754
755 case XFS_IOC_FSBULKSTAT_SINGLE:
756 case XFS_IOC_FSBULKSTAT:
757 case XFS_IOC_FSINUMBERS:
758 return xfs_ioc_bulkstat(mp, cmd, arg);
759
760 case XFS_IOC_FSGEOMETRY_V1:
761 return xfs_ioc_fsgeometry_v1(mp, arg);
762
763 case XFS_IOC_FSGEOMETRY:
764 return xfs_ioc_fsgeometry(mp, arg);
765
766 case XFS_IOC_GETVERSION:
767 return put_user(inode->i_generation, (int __user *)arg);
768
769 case XFS_IOC_FSGETXATTR:
770 return xfs_ioc_fsgetxattr(ip, 0, arg);
771 case XFS_IOC_FSGETXATTRA:
772 return xfs_ioc_fsgetxattr(ip, 1, arg);
773 case XFS_IOC_GETXFLAGS:
774 case XFS_IOC_SETXFLAGS:
775 case XFS_IOC_FSSETXATTR:
776 return xfs_ioc_xattr(ip, filp, cmd, arg);
777
778 case XFS_IOC_FSSETDM: {
779 struct fsdmidata dmi;
780
781 if (copy_from_user(&dmi, arg, sizeof(dmi)))
782 return -XFS_ERROR(EFAULT);
783
784 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
785 dmi.fsd_dmstate);
786 return -error;
787 }
788
789 case XFS_IOC_GETBMAP:
790 case XFS_IOC_GETBMAPA:
791 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
792
793 case XFS_IOC_GETBMAPX:
794 return xfs_ioc_getbmapx(ip, arg);
795
796 case XFS_IOC_FD_TO_HANDLE:
797 case XFS_IOC_PATH_TO_HANDLE:
798 case XFS_IOC_PATH_TO_FSHANDLE:
799 return xfs_find_handle(cmd, arg);
800
801 case XFS_IOC_OPEN_BY_HANDLE:
802 return xfs_open_by_handle(mp, arg, filp, inode);
803
804 case XFS_IOC_FSSETDM_BY_HANDLE:
805 return xfs_fssetdm_by_handle(mp, arg, inode);
806
807 case XFS_IOC_READLINK_BY_HANDLE:
808 return xfs_readlink_by_handle(mp, arg, inode);
809
810 case XFS_IOC_ATTRLIST_BY_HANDLE:
811 return xfs_attrlist_by_handle(mp, arg, inode);
812
813 case XFS_IOC_ATTRMULTI_BY_HANDLE:
814 return xfs_attrmulti_by_handle(mp, arg, inode);
815
816 case XFS_IOC_SWAPEXT: {
817 error = xfs_swapext((struct xfs_swapext __user *)arg);
818 return -error;
819 }
820
821 case XFS_IOC_FSCOUNTS: {
822 xfs_fsop_counts_t out;
823
824 error = xfs_fs_counts(mp, &out);
825 if (error)
826 return -error;
827
828 if (copy_to_user(arg, &out, sizeof(out)))
829 return -XFS_ERROR(EFAULT);
830 return 0;
831 }
832
833 case XFS_IOC_SET_RESBLKS: {
834 xfs_fsop_resblks_t inout;
835 __uint64_t in;
836
837 if (!capable(CAP_SYS_ADMIN))
838 return -EPERM;
839
840 if (copy_from_user(&inout, arg, sizeof(inout)))
841 return -XFS_ERROR(EFAULT);
842
843 /* input parameter is passed in resblks field of structure */
844 in = inout.resblks;
845 error = xfs_reserve_blocks(mp, &in, &inout);
846 if (error)
847 return -error;
848
849 if (copy_to_user(arg, &inout, sizeof(inout)))
850 return -XFS_ERROR(EFAULT);
851 return 0;
852 }
853
854 case XFS_IOC_GET_RESBLKS: {
855 xfs_fsop_resblks_t out;
856
857 if (!capable(CAP_SYS_ADMIN))
858 return -EPERM;
859
860 error = xfs_reserve_blocks(mp, NULL, &out);
861 if (error)
862 return -error;
863
864 if (copy_to_user(arg, &out, sizeof(out)))
865 return -XFS_ERROR(EFAULT);
866
867 return 0;
868 }
869
870 case XFS_IOC_FSGROWFSDATA: {
871 xfs_growfs_data_t in;
872
873 if (!capable(CAP_SYS_ADMIN))
874 return -EPERM;
875
876 if (copy_from_user(&in, arg, sizeof(in)))
877 return -XFS_ERROR(EFAULT);
878
879 error = xfs_growfs_data(mp, &in);
880 return -error;
881 }
882
883 case XFS_IOC_FSGROWFSLOG: {
884 xfs_growfs_log_t in;
885
886 if (!capable(CAP_SYS_ADMIN))
887 return -EPERM;
888
889 if (copy_from_user(&in, arg, sizeof(in)))
890 return -XFS_ERROR(EFAULT);
891
892 error = xfs_growfs_log(mp, &in);
893 return -error;
894 }
895
896 case XFS_IOC_FSGROWFSRT: {
897 xfs_growfs_rt_t in;
898
899 if (!capable(CAP_SYS_ADMIN))
900 return -EPERM;
901
902 if (copy_from_user(&in, arg, sizeof(in)))
903 return -XFS_ERROR(EFAULT);
904
905 error = xfs_growfs_rt(mp, &in);
906 return -error;
907 }
908
909 case XFS_IOC_FREEZE:
910 if (!capable(CAP_SYS_ADMIN))
911 return -EPERM;
912
913 if (inode->i_sb->s_frozen == SB_UNFROZEN)
914 freeze_bdev(inode->i_sb->s_bdev);
915 return 0;
916
917 case XFS_IOC_THAW:
918 if (!capable(CAP_SYS_ADMIN))
919 return -EPERM;
920 if (inode->i_sb->s_frozen != SB_UNFROZEN)
921 thaw_bdev(inode->i_sb->s_bdev, inode->i_sb);
922 return 0;
923
924 case XFS_IOC_GOINGDOWN: {
925 __uint32_t in;
926
927 if (!capable(CAP_SYS_ADMIN))
928 return -EPERM;
929
930 if (get_user(in, (__uint32_t __user *)arg))
931 return -XFS_ERROR(EFAULT);
932
933 error = xfs_fs_goingdown(mp, in);
934 return -error;
935 }
936
937 case XFS_IOC_ERROR_INJECTION: {
938 xfs_error_injection_t in;
939
940 if (!capable(CAP_SYS_ADMIN))
941 return -EPERM;
942
943 if (copy_from_user(&in, arg, sizeof(in)))
944 return -XFS_ERROR(EFAULT);
945
946 error = xfs_errortag_add(in.errtag, mp);
947 return -error;
948 }
949
950 case XFS_IOC_ERROR_CLEARALL:
951 if (!capable(CAP_SYS_ADMIN))
952 return -EPERM;
953
954 error = xfs_errortag_clearall(mp, 1);
955 return -error;
956
957 default:
958 return -ENOTTY;
959 }
960 }
961
962 STATIC int
963 xfs_ioc_space(
964 struct xfs_inode *ip,
965 struct inode *inode,
966 struct file *filp,
967 int ioflags,
968 unsigned int cmd,
969 void __user *arg)
970 {
971 xfs_flock64_t bf;
972 int attr_flags = 0;
973 int error;
974
975 if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
976 return -XFS_ERROR(EPERM);
977
978 if (!(filp->f_mode & FMODE_WRITE))
979 return -XFS_ERROR(EBADF);
980
981 if (!S_ISREG(inode->i_mode))
982 return -XFS_ERROR(EINVAL);
983
984 if (copy_from_user(&bf, arg, sizeof(bf)))
985 return -XFS_ERROR(EFAULT);
986
987 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
988 attr_flags |= ATTR_NONBLOCK;
989 if (ioflags & IO_INVIS)
990 attr_flags |= ATTR_DMI;
991
992 error = xfs_change_file_space(ip, cmd, &bf, filp->f_pos,
993 NULL, attr_flags);
994 return -error;
995 }
996
997 STATIC int
998 xfs_ioc_bulkstat(
999 xfs_mount_t *mp,
1000 unsigned int cmd,
1001 void __user *arg)
1002 {
1003 xfs_fsop_bulkreq_t bulkreq;
1004 int count; /* # of records returned */
1005 xfs_ino_t inlast; /* last inode number */
1006 int done;
1007 int error;
1008
1009 /* done = 1 if there are more stats to get and if bulkstat */
1010 /* should be called again (unused here, but used in dmapi) */
1011
1012 if (!capable(CAP_SYS_ADMIN))
1013 return -EPERM;
1014
1015 if (XFS_FORCED_SHUTDOWN(mp))
1016 return -XFS_ERROR(EIO);
1017
1018 if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
1019 return -XFS_ERROR(EFAULT);
1020
1021 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
1022 return -XFS_ERROR(EFAULT);
1023
1024 if ((count = bulkreq.icount) <= 0)
1025 return -XFS_ERROR(EINVAL);
1026
1027 if (bulkreq.ubuffer == NULL)
1028 return -XFS_ERROR(EINVAL);
1029
1030 if (cmd == XFS_IOC_FSINUMBERS)
1031 error = xfs_inumbers(mp, &inlast, &count,
1032 bulkreq.ubuffer, xfs_inumbers_fmt);
1033 else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
1034 error = xfs_bulkstat_single(mp, &inlast,
1035 bulkreq.ubuffer, &done);
1036 else /* XFS_IOC_FSBULKSTAT */
1037 error = xfs_bulkstat(mp, &inlast, &count,
1038 (bulkstat_one_pf)xfs_bulkstat_one, NULL,
1039 sizeof(xfs_bstat_t), bulkreq.ubuffer,
1040 BULKSTAT_FG_QUICK, &done);
1041
1042 if (error)
1043 return -error;
1044
1045 if (bulkreq.ocount != NULL) {
1046 if (copy_to_user(bulkreq.lastip, &inlast,
1047 sizeof(xfs_ino_t)))
1048 return -XFS_ERROR(EFAULT);
1049
1050 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
1051 return -XFS_ERROR(EFAULT);
1052 }
1053
1054 return 0;
1055 }
1056
1057 STATIC int
1058 xfs_ioc_fsgeometry_v1(
1059 xfs_mount_t *mp,
1060 void __user *arg)
1061 {
1062 xfs_fsop_geom_v1_t fsgeo;
1063 int error;
1064
1065 error = xfs_fs_geometry(mp, (xfs_fsop_geom_t *)&fsgeo, 3);
1066 if (error)
1067 return -error;
1068
1069 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
1070 return -XFS_ERROR(EFAULT);
1071 return 0;
1072 }
1073
1074 STATIC int
1075 xfs_ioc_fsgeometry(
1076 xfs_mount_t *mp,
1077 void __user *arg)
1078 {
1079 xfs_fsop_geom_t fsgeo;
1080 int error;
1081
1082 error = xfs_fs_geometry(mp, &fsgeo, 4);
1083 if (error)
1084 return -error;
1085
1086 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
1087 return -XFS_ERROR(EFAULT);
1088 return 0;
1089 }
1090
1091 /*
1092 * Linux extended inode flags interface.
1093 */
1094
1095 STATIC unsigned int
1096 xfs_merge_ioc_xflags(
1097 unsigned int flags,
1098 unsigned int start)
1099 {
1100 unsigned int xflags = start;
1101
1102 if (flags & FS_IMMUTABLE_FL)
1103 xflags |= XFS_XFLAG_IMMUTABLE;
1104 else
1105 xflags &= ~XFS_XFLAG_IMMUTABLE;
1106 if (flags & FS_APPEND_FL)
1107 xflags |= XFS_XFLAG_APPEND;
1108 else
1109 xflags &= ~XFS_XFLAG_APPEND;
1110 if (flags & FS_SYNC_FL)
1111 xflags |= XFS_XFLAG_SYNC;
1112 else
1113 xflags &= ~XFS_XFLAG_SYNC;
1114 if (flags & FS_NOATIME_FL)
1115 xflags |= XFS_XFLAG_NOATIME;
1116 else
1117 xflags &= ~XFS_XFLAG_NOATIME;
1118 if (flags & FS_NODUMP_FL)
1119 xflags |= XFS_XFLAG_NODUMP;
1120 else
1121 xflags &= ~XFS_XFLAG_NODUMP;
1122
1123 return xflags;
1124 }
1125
1126 STATIC unsigned int
1127 xfs_di2lxflags(
1128 __uint16_t di_flags)
1129 {
1130 unsigned int flags = 0;
1131
1132 if (di_flags & XFS_DIFLAG_IMMUTABLE)
1133 flags |= FS_IMMUTABLE_FL;
1134 if (di_flags & XFS_DIFLAG_APPEND)
1135 flags |= FS_APPEND_FL;
1136 if (di_flags & XFS_DIFLAG_SYNC)
1137 flags |= FS_SYNC_FL;
1138 if (di_flags & XFS_DIFLAG_NOATIME)
1139 flags |= FS_NOATIME_FL;
1140 if (di_flags & XFS_DIFLAG_NODUMP)
1141 flags |= FS_NODUMP_FL;
1142 return flags;
1143 }
1144
1145 STATIC int
1146 xfs_ioc_fsgetxattr(
1147 xfs_inode_t *ip,
1148 int attr,
1149 void __user *arg)
1150 {
1151 struct fsxattr fa;
1152
1153 xfs_ilock(ip, XFS_ILOCK_SHARED);
1154 fa.fsx_xflags = xfs_ip2xflags(ip);
1155 fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
1156 fa.fsx_projid = ip->i_d.di_projid;
1157
1158 if (attr) {
1159 if (ip->i_afp) {
1160 if (ip->i_afp->if_flags & XFS_IFEXTENTS)
1161 fa.fsx_nextents = ip->i_afp->if_bytes /
1162 sizeof(xfs_bmbt_rec_t);
1163 else
1164 fa.fsx_nextents = ip->i_d.di_anextents;
1165 } else
1166 fa.fsx_nextents = 0;
1167 } else {
1168 if (ip->i_df.if_flags & XFS_IFEXTENTS)
1169 fa.fsx_nextents = ip->i_df.if_bytes /
1170 sizeof(xfs_bmbt_rec_t);
1171 else
1172 fa.fsx_nextents = ip->i_d.di_nextents;
1173 }
1174 xfs_iunlock(ip, XFS_ILOCK_SHARED);
1175
1176 if (copy_to_user(arg, &fa, sizeof(fa)))
1177 return -EFAULT;
1178 return 0;
1179 }
1180
1181 STATIC int
1182 xfs_ioc_xattr(
1183 xfs_inode_t *ip,
1184 struct file *filp,
1185 unsigned int cmd,
1186 void __user *arg)
1187 {
1188 struct fsxattr fa;
1189 struct bhv_vattr *vattr;
1190 int error = 0;
1191 int attr_flags;
1192 unsigned int flags;
1193
1194 vattr = kmalloc(sizeof(*vattr), GFP_KERNEL);
1195 if (unlikely(!vattr))
1196 return -ENOMEM;
1197
1198 switch (cmd) {
1199 case XFS_IOC_FSSETXATTR: {
1200 if (copy_from_user(&fa, arg, sizeof(fa))) {
1201 error = -EFAULT;
1202 break;
1203 }
1204
1205 attr_flags = 0;
1206 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1207 attr_flags |= ATTR_NONBLOCK;
1208
1209 vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | XFS_AT_PROJID;
1210 vattr->va_xflags = fa.fsx_xflags;
1211 vattr->va_extsize = fa.fsx_extsize;
1212 vattr->va_projid = fa.fsx_projid;
1213
1214 error = xfs_setattr(ip, vattr, attr_flags, NULL);
1215 if (likely(!error))
1216 vn_revalidate(XFS_ITOV(ip)); /* update flags */
1217 error = -error;
1218 break;
1219 }
1220
1221 case XFS_IOC_GETXFLAGS: {
1222 flags = xfs_di2lxflags(ip->i_d.di_flags);
1223 if (copy_to_user(arg, &flags, sizeof(flags)))
1224 error = -EFAULT;
1225 break;
1226 }
1227
1228 case XFS_IOC_SETXFLAGS: {
1229 if (copy_from_user(&flags, arg, sizeof(flags))) {
1230 error = -EFAULT;
1231 break;
1232 }
1233
1234 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1235 FS_NOATIME_FL | FS_NODUMP_FL | \
1236 FS_SYNC_FL)) {
1237 error = -EOPNOTSUPP;
1238 break;
1239 }
1240
1241 attr_flags = 0;
1242 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1243 attr_flags |= ATTR_NONBLOCK;
1244
1245 vattr->va_mask = XFS_AT_XFLAGS;
1246 vattr->va_xflags = xfs_merge_ioc_xflags(flags,
1247 xfs_ip2xflags(ip));
1248
1249 error = xfs_setattr(ip, vattr, attr_flags, NULL);
1250 if (likely(!error))
1251 vn_revalidate(XFS_ITOV(ip)); /* update flags */
1252 error = -error;
1253 break;
1254 }
1255
1256 default:
1257 error = -ENOTTY;
1258 break;
1259 }
1260
1261 kfree(vattr);
1262 return error;
1263 }
1264
1265 STATIC int
1266 xfs_ioc_getbmap(
1267 struct xfs_inode *ip,
1268 int ioflags,
1269 unsigned int cmd,
1270 void __user *arg)
1271 {
1272 struct getbmap bm;
1273 int iflags;
1274 int error;
1275
1276 if (copy_from_user(&bm, arg, sizeof(bm)))
1277 return -XFS_ERROR(EFAULT);
1278
1279 if (bm.bmv_count < 2)
1280 return -XFS_ERROR(EINVAL);
1281
1282 iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1283 if (ioflags & IO_INVIS)
1284 iflags |= BMV_IF_NO_DMAPI_READ;
1285
1286 error = xfs_getbmap(ip, &bm, (struct getbmap __user *)arg+1, iflags);
1287 if (error)
1288 return -error;
1289
1290 if (copy_to_user(arg, &bm, sizeof(bm)))
1291 return -XFS_ERROR(EFAULT);
1292 return 0;
1293 }
1294
1295 STATIC int
1296 xfs_ioc_getbmapx(
1297 struct xfs_inode *ip,
1298 void __user *arg)
1299 {
1300 struct getbmapx bmx;
1301 struct getbmap bm;
1302 int iflags;
1303 int error;
1304
1305 if (copy_from_user(&bmx, arg, sizeof(bmx)))
1306 return -XFS_ERROR(EFAULT);
1307
1308 if (bmx.bmv_count < 2)
1309 return -XFS_ERROR(EINVAL);
1310
1311 /*
1312 * Map input getbmapx structure to a getbmap
1313 * structure for xfs_getbmap.
1314 */
1315 GETBMAP_CONVERT(bmx, bm);
1316
1317 iflags = bmx.bmv_iflags;
1318
1319 if (iflags & (~BMV_IF_VALID))
1320 return -XFS_ERROR(EINVAL);
1321
1322 iflags |= BMV_IF_EXTENDED;
1323
1324 error = xfs_getbmap(ip, &bm, (struct getbmapx __user *)arg+1, iflags);
1325 if (error)
1326 return -error;
1327
1328 GETBMAP_CONVERT(bm, bmx);
1329
1330 if (copy_to_user(arg, &bmx, sizeof(bmx)))
1331 return -XFS_ERROR(EFAULT);
1332
1333 return 0;
1334 }
1335
|
This page was automatically generated by the
LXR engine.
|