]> git.proxmox.com Git - mirror_ubuntu-kernels.git/blob - fs/xfs/linux-2.6/xfs_ioctl.c
projects / mirror_ubuntu-kernels.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[XFS] call common xfs vnode-level helpers directly and remove vnode operations
[mirror_ubuntu-kernels.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
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 bhv_vnode_t *vp;
79
80 if (copy_from_user(&hreq, arg, sizeof(hreq)))
81 return -XFS_ERROR(EFAULT);
82
83 memset((char *)&handle, 0, sizeof(handle));
84
85 switch (cmd) {
86 case XFS_IOC_PATH_TO_FSHANDLE:
87 case XFS_IOC_PATH_TO_HANDLE: {
88 struct nameidata nd;
89 int error;
90
91 error = user_path_walk_link((const char __user *)hreq.path, &nd);
92 if (error)
93 return error;
94
95 ASSERT(nd.dentry);
96 ASSERT(nd.dentry->d_inode);
97 inode = igrab(nd.dentry->d_inode);
98 path_release(&nd);
99 break;
100 }
101
102 case XFS_IOC_FD_TO_HANDLE: {
103 struct file *file;
104
105 file = fget(hreq.fd);
106 if (!file)
107 return -EBADF;
108
109 ASSERT(file->f_path.dentry);
110 ASSERT(file->f_path.dentry->d_inode);
111 inode = igrab(file->f_path.dentry->d_inode);
112 fput(file);
113 break;
114 }
115
116 default:
117 ASSERT(0);
118 return -XFS_ERROR(EINVAL);
119 }
120
121 if (inode->i_sb->s_magic != XFS_SB_MAGIC) {
122 /* we're not in XFS anymore, Toto */
123 iput(inode);
124 return -XFS_ERROR(EINVAL);
125 }
126
127 switch (inode->i_mode & S_IFMT) {
128 case S_IFREG:
129 case S_IFDIR:
130 case S_IFLNK:
131 break;
132 default:
133 iput(inode);
134 return -XFS_ERROR(EBADF);
135 }
136
137 /* we need the vnode */
138 vp = vn_from_inode(inode);
139
140 /* now we can grab the fsid */
141 memcpy(&handle.ha_fsid, vp->v_vfsp->vfs_altfsid, sizeof(xfs_fsid_t));
142 hsize = sizeof(xfs_fsid_t);
143
144 if (cmd != XFS_IOC_PATH_TO_FSHANDLE) {
145 xfs_inode_t *ip;
146 int lock_mode;
147
148 /* need to get access to the xfs_inode to read the generation */
149 ip = xfs_vtoi(vp);
150 ASSERT(ip);
151 lock_mode = xfs_ilock_map_shared(ip);
152
153 /* fill in fid section of handle from inode */
154 handle.ha_fid.xfs_fid_len = sizeof(xfs_fid_t) -
155 sizeof(handle.ha_fid.xfs_fid_len);
156 handle.ha_fid.xfs_fid_pad = 0;
157 handle.ha_fid.xfs_fid_gen = ip->i_d.di_gen;
158 handle.ha_fid.xfs_fid_ino = ip->i_ino;
159
160 xfs_iunlock_map_shared(ip, lock_mode);
161
162 hsize = XFS_HSIZE(handle);
163 }
164
165 /* now copy our handle into the user buffer & write out the size */
166 if (copy_to_user(hreq.ohandle, &handle, hsize) ||
167 copy_to_user(hreq.ohandlen, &hsize, sizeof(__s32))) {
168 iput(inode);
169 return -XFS_ERROR(EFAULT);
170 }
171
172 iput(inode);
173 return 0;
174 }
175
176
177 /*
178 * Convert userspace handle data into vnode (and inode).
179 * We [ab]use the fact that all the fsop_handlereq ioctl calls
180 * have a data structure argument whose first component is always
181 * a xfs_fsop_handlereq_t, so we can cast to and from this type.
182 * This allows us to optimise the copy_from_user calls and gives
183 * a handy, shared routine.
184 *
185 * If no error, caller must always VN_RELE the returned vp.
186 */
187 STATIC int
188 xfs_vget_fsop_handlereq(
189 xfs_mount_t *mp,
190 struct inode *parinode, /* parent inode pointer */
191 xfs_fsop_handlereq_t *hreq,
192 bhv_vnode_t **vp,
193 struct inode **inode)
194 {
195 void __user *hanp;
196 size_t hlen;
197 xfs_fid_t *xfid;
198 xfs_handle_t *handlep;
199 xfs_handle_t handle;
200 xfs_inode_t *ip;
201 struct inode *inodep;
202 bhv_vnode_t *vpp;
203 xfs_ino_t ino;
204 __u32 igen;
205 int error;
206
207 /*
208 * Only allow handle opens under a directory.
209 */
210 if (!S_ISDIR(parinode->i_mode))
211 return XFS_ERROR(ENOTDIR);
212
213 hanp = hreq->ihandle;
214 hlen = hreq->ihandlen;
215 handlep = &handle;
216
217 if (hlen < sizeof(handlep->ha_fsid) || hlen > sizeof(*handlep))
218 return XFS_ERROR(EINVAL);
219 if (copy_from_user(handlep, hanp, hlen))
220 return XFS_ERROR(EFAULT);
221 if (hlen < sizeof(*handlep))
222 memset(((char *)handlep) + hlen, 0, sizeof(*handlep) - hlen);
223 if (hlen > sizeof(handlep->ha_fsid)) {
224 if (handlep->ha_fid.xfs_fid_len !=
225 (hlen - sizeof(handlep->ha_fsid)
226 - sizeof(handlep->ha_fid.xfs_fid_len))
227 || handlep->ha_fid.xfs_fid_pad)
228 return XFS_ERROR(EINVAL);
229 }
230
231 /*
232 * Crack the handle, obtain the inode # & generation #
233 */
234 xfid = (struct xfs_fid *)&handlep->ha_fid;
235 if (xfid->xfs_fid_len == sizeof(*xfid) - sizeof(xfid->xfs_fid_len)) {
236 ino = xfid->xfs_fid_ino;
237 igen = xfid->xfs_fid_gen;
238 } else {
239 return XFS_ERROR(EINVAL);
240 }
241
242 /*
243 * Get the XFS inode, building a vnode to go with it.
244 */
245 error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_SHARED, &ip, 0);
246 if (error)
247 return error;
248 if (ip == NULL)
249 return XFS_ERROR(EIO);
250 if (ip->i_d.di_mode == 0 || ip->i_d.di_gen != igen) {
251 xfs_iput_new(ip, XFS_ILOCK_SHARED);
252 return XFS_ERROR(ENOENT);
253 }
254
255 vpp = XFS_ITOV(ip);
256 inodep = vn_to_inode(vpp);
257 xfs_iunlock(ip, XFS_ILOCK_SHARED);
258
259 *vp = vpp;
260 *inode = inodep;
261 return 0;
262 }
263
264 STATIC int
265 xfs_open_by_handle(
266 xfs_mount_t *mp,
267 void __user *arg,
268 struct file *parfilp,
269 struct inode *parinode)
270 {
271 int error;
272 int new_fd;
273 int permflag;
274 struct file *filp;
275 struct inode *inode;
276 struct dentry *dentry;
277 bhv_vnode_t *vp;
278 xfs_fsop_handlereq_t hreq;
279
280 if (!capable(CAP_SYS_ADMIN))
281 return -XFS_ERROR(EPERM);
282 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
283 return -XFS_ERROR(EFAULT);
284
285 error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &vp, &inode);
286 if (error)
287 return -error;
288
289 /* Restrict xfs_open_by_handle to directories & regular files. */
290 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
291 iput(inode);
292 return -XFS_ERROR(EINVAL);
293 }
294
295 #if BITS_PER_LONG != 32
296 hreq.oflags |= O_LARGEFILE;
297 #endif
298 /* Put open permission in namei format. */
299 permflag = hreq.oflags;
300 if ((permflag+1) & O_ACCMODE)
301 permflag++;
302 if (permflag & O_TRUNC)
303 permflag |= 2;
304
305 if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
306 (permflag & FMODE_WRITE) && IS_APPEND(inode)) {
307 iput(inode);
308 return -XFS_ERROR(EPERM);
309 }
310
311 if ((permflag & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
312 iput(inode);
313 return -XFS_ERROR(EACCES);
314 }
315
316 /* Can't write directories. */
317 if ( S_ISDIR(inode->i_mode) && (permflag & FMODE_WRITE)) {
318 iput(inode);
319 return -XFS_ERROR(EISDIR);
320 }
321
322 if ((new_fd = get_unused_fd()) < 0) {
323 iput(inode);
324 return new_fd;
325 }
326
327 dentry = d_alloc_anon(inode);
328 if (dentry == NULL) {
329 iput(inode);
330 put_unused_fd(new_fd);
331 return -XFS_ERROR(ENOMEM);
332 }
333
334 /* Ensure umount returns EBUSY on umounts while this file is open. */
335 mntget(parfilp->f_path.mnt);
336
337 /* Create file pointer. */
338 filp = dentry_open(dentry, parfilp->f_path.mnt, hreq.oflags);
339 if (IS_ERR(filp)) {
340 put_unused_fd(new_fd);
341 return -XFS_ERROR(-PTR_ERR(filp));
342 }
343 if (inode->i_mode & S_IFREG) {
344 /* invisible operation should not change atime */
345 filp->f_flags |= O_NOATIME;
346 filp->f_op = &xfs_invis_file_operations;
347 }
348
349 fd_install(new_fd, filp);
350 return new_fd;
351 }
352
353 /*
354 * This is a copy from fs/namei.c:vfs_readlink(), except for removing it's
355 * unused first argument.
356 */
357 STATIC int
358 do_readlink(
359 char __user *buffer,
360 int buflen,
361 const char *link)
362 {
363 int len;
364
365 len = PTR_ERR(link);
366 if (IS_ERR(link))
367 goto out;
368
369 len = strlen(link);
370 if (len > (unsigned) buflen)
371 len = buflen;
372 if (copy_to_user(buffer, link, len))
373 len = -EFAULT;
374 out:
375 return len;
376 }
377
378
379 STATIC int
380 xfs_readlink_by_handle(
381 xfs_mount_t *mp,
382 void __user *arg,
383 struct inode *parinode)
384 {
385 struct inode *inode;
386 xfs_fsop_handlereq_t hreq;
387 bhv_vnode_t *vp;
388 __u32 olen;
389 void *link;
390 int error;
391
392 if (!capable(CAP_SYS_ADMIN))
393 return -XFS_ERROR(EPERM);
394 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
395 return -XFS_ERROR(EFAULT);
396
397 error = xfs_vget_fsop_handlereq(mp, parinode, &hreq, &vp, &inode);
398 if (error)
399 return -error;
400
401 /* Restrict this handle operation to symlinks only. */
402 if (!S_ISLNK(inode->i_mode)) {
403 error = -XFS_ERROR(EINVAL);
404 goto out_iput;
405 }
406
407 if (copy_from_user(&olen, hreq.ohandlen, sizeof(__u32))) {
408 error = -XFS_ERROR(EFAULT);
409 goto out_iput;
410 }
411
412 link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
413 if (!link)
414 goto out_iput;
415
416 error = -xfs_readlink(XFS_I(inode), link);
417 if (error)
418 goto out_kfree;
419 error = do_readlink(hreq.ohandle, olen, link);
420 if (error)
421 goto out_kfree;
422
423 out_kfree:
424 kfree(link);
425 out_iput:
426 iput(inode);
427 return error;
428 }
429
430 STATIC int
431 xfs_fssetdm_by_handle(
432 xfs_mount_t *mp,
433 void __user *arg,
434 struct inode *parinode)
435 {
436 int error;
437 struct fsdmidata fsd;
438 xfs_fsop_setdm_handlereq_t dmhreq;
439 struct inode *inode;
440 bhv_vnode_t *vp;
441
442 if (!capable(CAP_MKNOD))
443 return -XFS_ERROR(EPERM);
444 if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
445 return -XFS_ERROR(EFAULT);
446
447 error = xfs_vget_fsop_handlereq(mp, parinode, &dmhreq.hreq, &vp, &inode);
448 if (error)
449 return -error;
450
451 if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) {
452 VN_RELE(vp);
453 return -XFS_ERROR(EPERM);
454 }
455
456 if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
457 VN_RELE(vp);
458 return -XFS_ERROR(EFAULT);
459 }
460
461 error = xfs_set_dmattrs(xfs_vtoi(vp),
462 fsd.fsd_dmevmask, fsd.fsd_dmstate);
463
464 VN_RELE(vp);
465 if (error)
466 return -error;
467 return 0;
468 }
469
470 STATIC int
471 xfs_attrlist_by_handle(
472 xfs_mount_t *mp,
473 void __user *arg,
474 struct inode *parinode)
475 {
476 int error;
477 attrlist_cursor_kern_t *cursor;
478 xfs_fsop_attrlist_handlereq_t al_hreq;
479 struct inode *inode;
480 bhv_vnode_t *vp;
481 char *kbuf;
482
483 if (!capable(CAP_SYS_ADMIN))
484 return -XFS_ERROR(EPERM);
485 if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
486 return -XFS_ERROR(EFAULT);
487 if (al_hreq.buflen > XATTR_LIST_MAX)
488 return -XFS_ERROR(EINVAL);
489
490 error = xfs_vget_fsop_handlereq(mp, parinode, &al_hreq.hreq,
491 &vp, &inode);
492 if (error)
493 goto out;
494
495 kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);
496 if (!kbuf)
497 goto out_vn_rele;
498
499 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
500 error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,
501 al_hreq.flags, cursor);
502 if (error)
503 goto out_kfree;
504
505 if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
506 error = -EFAULT;
507
508 out_kfree:
509 kfree(kbuf);
510 out_vn_rele:
511 VN_RELE(vp);
512 out:
513 return -error;
514 }
515
516 STATIC int
517 xfs_attrmulti_attr_get(
518 struct inode *inode,
519 char *name,
520 char __user *ubuf,
521 __uint32_t *len,
522 __uint32_t flags)
523 {
524 char *kbuf;
525 int error = EFAULT;
526
527 if (*len > XATTR_SIZE_MAX)
528 return EINVAL;
529 kbuf = kmalloc(*len, GFP_KERNEL);
530 if (!kbuf)
531 return ENOMEM;
532
533 error = xfs_attr_get(XFS_I(inode), name, kbuf, len, flags, NULL);
534 if (error)
535 goto out_kfree;
536
537 if (copy_to_user(ubuf, kbuf, *len))
538 error = EFAULT;
539
540 out_kfree:
541 kfree(kbuf);
542 return error;
543 }
544
545 STATIC int
546 xfs_attrmulti_attr_set(
547 struct inode *inode,
548 char *name,
549 const char __user *ubuf,
550 __uint32_t len,
551 __uint32_t flags)
552 {
553 char *kbuf;
554 int error = EFAULT;
555
556 if (IS_RDONLY(inode))
557 return -EROFS;
558 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
559 return EPERM;
560 if (len > XATTR_SIZE_MAX)
561 return EINVAL;
562
563 kbuf = kmalloc(len, GFP_KERNEL);
564 if (!kbuf)
565 return ENOMEM;
566
567 if (copy_from_user(kbuf, ubuf, len))
568 goto out_kfree;
569
570 error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
571
572 out_kfree:
573 kfree(kbuf);
574 return error;
575 }
576
577 STATIC int
578 xfs_attrmulti_attr_remove(
579 struct inode *inode,
580 char *name,
581 __uint32_t flags)
582 {
583 if (IS_RDONLY(inode))
584 return -EROFS;
585 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
586 return EPERM;
587 return xfs_attr_remove(XFS_I(inode), name, flags);
588 }
589
590 STATIC int
591 xfs_attrmulti_by_handle(
592 xfs_mount_t *mp,
593 void __user *arg,
594 struct inode *parinode)
595 {
596 int error;
597 xfs_attr_multiop_t *ops;
598 xfs_fsop_attrmulti_handlereq_t am_hreq;
599 struct inode *inode;
600 bhv_vnode_t *vp;
601 unsigned int i, size;
602 char *attr_name;
603
604 if (!capable(CAP_SYS_ADMIN))
605 return -XFS_ERROR(EPERM);
606 if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
607 return -XFS_ERROR(EFAULT);
608
609 error = xfs_vget_fsop_handlereq(mp, parinode, &am_hreq.hreq, &vp, &inode);
610 if (error)
611 goto out;
612
613 error = E2BIG;
614 size = am_hreq.opcount * sizeof(attr_multiop_t);
615 if (!size || size > 16 * PAGE_SIZE)
616 goto out_vn_rele;
617
618 error = ENOMEM;
619 ops = kmalloc(size, GFP_KERNEL);
620 if (!ops)
621 goto out_vn_rele;
622
623 error = EFAULT;
624 if (copy_from_user(ops, am_hreq.ops, size))
625 goto out_kfree_ops;
626
627 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
628 if (!attr_name)
629 goto out_kfree_ops;
630
631
632 error = 0;
633 for (i = 0; i < am_hreq.opcount; i++) {
634 ops[i].am_error = strncpy_from_user(attr_name,
635 ops[i].am_attrname, MAXNAMELEN);
636 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
637 error = -ERANGE;
638 if (ops[i].am_error < 0)
639 break;
640
641 switch (ops[i].am_opcode) {
642 case ATTR_OP_GET:
643 ops[i].am_error = xfs_attrmulti_attr_get(inode,
644 attr_name, ops[i].am_attrvalue,
645 &ops[i].am_length, ops[i].am_flags);
646 break;
647 case ATTR_OP_SET:
648 ops[i].am_error = xfs_attrmulti_attr_set(inode,
649 attr_name, ops[i].am_attrvalue,
650 ops[i].am_length, ops[i].am_flags);
651 break;
652 case ATTR_OP_REMOVE:
653 ops[i].am_error = xfs_attrmulti_attr_remove(inode,
654 attr_name, ops[i].am_flags);
655 break;
656 default:
657 ops[i].am_error = EINVAL;
658 }
659 }
660
661 if (copy_to_user(am_hreq.ops, ops, size))
662 error = XFS_ERROR(EFAULT);
663
664 kfree(attr_name);
665 out_kfree_ops:
666 kfree(ops);
667 out_vn_rele:
668 VN_RELE(vp);
669 out:
670 return -error;
671 }
672
673 /* prototypes for a few of the stack-hungry cases that have
674 * their own functions. Functions are defined after their use
675 * so gcc doesn't get fancy and inline them with -03 */
676
677 STATIC int
678 xfs_ioc_space(
679 struct xfs_inode *ip,
680 struct inode *inode,
681 struct file *filp,
682 int flags,
683 unsigned int cmd,
684 void __user *arg);
685
686 STATIC int
687 xfs_ioc_bulkstat(
688 xfs_mount_t *mp,
689 unsigned int cmd,
690 void __user *arg);
691
692 STATIC int
693 xfs_ioc_fsgeometry_v1(
694 xfs_mount_t *mp,
695 void __user *arg);
696
697 STATIC int
698 xfs_ioc_fsgeometry(
699 xfs_mount_t *mp,
700 void __user *arg);
701
702 STATIC int
703 xfs_ioc_xattr(
704 bhv_vnode_t *vp,
705 xfs_inode_t *ip,
706 struct file *filp,
707 unsigned int cmd,
708 void __user *arg);
709
710 STATIC int
711 xfs_ioc_getbmap(
712 struct xfs_inode *ip,
713 int flags,
714 unsigned int cmd,
715 void __user *arg);
716
717 STATIC int
718 xfs_ioc_getbmapx(
719 struct xfs_inode *ip,
720 void __user *arg);
721
722 int
723 xfs_ioctl(
724 xfs_inode_t *ip,
725 struct file *filp,
726 int ioflags,
727 unsigned int cmd,
728 void __user *arg)
729 {
730 struct inode *inode = filp->f_path.dentry->d_inode;
731 bhv_vnode_t *vp = vn_from_inode(inode);
732 xfs_mount_t *mp = ip->i_mount;
733 int error;
734
735 vn_trace_entry(vp, "xfs_ioctl", (inst_t *)__return_address);
736
737 switch (cmd) {
738
739 case XFS_IOC_ALLOCSP:
740 case XFS_IOC_FREESP:
741 case XFS_IOC_RESVSP:
742 case XFS_IOC_UNRESVSP:
743 case XFS_IOC_ALLOCSP64:
744 case XFS_IOC_FREESP64:
745 case XFS_IOC_RESVSP64:
746 case XFS_IOC_UNRESVSP64:
747 /*
748 * Only allow the sys admin to reserve space unless
749 * unwritten extents are enabled.
750 */
751 if (!XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb) &&
752 !capable(CAP_SYS_ADMIN))
753 return -EPERM;
754
755 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, arg);
756
757 case XFS_IOC_DIOINFO: {
758 struct dioattr da;
759 xfs_buftarg_t *target =
760 (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) ?
761 mp->m_rtdev_targp : mp->m_ddev_targp;
762
763 da.d_mem = da.d_miniosz = 1 << target->bt_sshift;
764 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
765
766 if (copy_to_user(arg, &da, sizeof(da)))
767 return -XFS_ERROR(EFAULT);
768 return 0;
769 }
770
771 case XFS_IOC_FSBULKSTAT_SINGLE:
772 case XFS_IOC_FSBULKSTAT:
773 case XFS_IOC_FSINUMBERS:
774 return xfs_ioc_bulkstat(mp, cmd, arg);
775
776 case XFS_IOC_FSGEOMETRY_V1:
777 return xfs_ioc_fsgeometry_v1(mp, arg);
778
779 case XFS_IOC_FSGEOMETRY:
780 return xfs_ioc_fsgeometry(mp, arg);
781
782 case XFS_IOC_GETVERSION:
783 return put_user(inode->i_generation, (int __user *)arg);
784
785 case XFS_IOC_GETXFLAGS:
786 case XFS_IOC_SETXFLAGS:
787 case XFS_IOC_FSGETXATTR:
788 case XFS_IOC_FSSETXATTR:
789 case XFS_IOC_FSGETXATTRA:
790 return xfs_ioc_xattr(vp, ip, filp, cmd, arg);
791
792 case XFS_IOC_FSSETDM: {
793 struct fsdmidata dmi;
794
795 if (copy_from_user(&dmi, arg, sizeof(dmi)))
796 return -XFS_ERROR(EFAULT);
797
798 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
799 dmi.fsd_dmstate);
800 return -error;
801 }
802
803 case XFS_IOC_GETBMAP:
804 case XFS_IOC_GETBMAPA:
805 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
806
807 case XFS_IOC_GETBMAPX:
808 return xfs_ioc_getbmapx(ip, arg);
809
810 case XFS_IOC_FD_TO_HANDLE:
811 case XFS_IOC_PATH_TO_HANDLE:
812 case XFS_IOC_PATH_TO_FSHANDLE:
813 return xfs_find_handle(cmd, arg);
814
815 case XFS_IOC_OPEN_BY_HANDLE:
816 return xfs_open_by_handle(mp, arg, filp, inode);
817
818 case XFS_IOC_FSSETDM_BY_HANDLE:
819 return xfs_fssetdm_by_handle(mp, arg, inode);
820
821 case XFS_IOC_READLINK_BY_HANDLE:
822 return xfs_readlink_by_handle(mp, arg, inode);
823
824 case XFS_IOC_ATTRLIST_BY_HANDLE:
825 return xfs_attrlist_by_handle(mp, arg, inode);
826
827 case XFS_IOC_ATTRMULTI_BY_HANDLE:
828 return xfs_attrmulti_by_handle(mp, arg, inode);
829
830 case XFS_IOC_SWAPEXT: {
831 error = xfs_swapext((struct xfs_swapext __user *)arg);
832 return -error;
833 }
834
835 case XFS_IOC_FSCOUNTS: {
836 xfs_fsop_counts_t out;
837
838 error = xfs_fs_counts(mp, &out);
839 if (error)
840 return -error;
841
842 if (copy_to_user(arg, &out, sizeof(out)))
843 return -XFS_ERROR(EFAULT);
844 return 0;
845 }
846
847 case XFS_IOC_SET_RESBLKS: {
848 xfs_fsop_resblks_t inout;
849 __uint64_t in;
850
851 if (!capable(CAP_SYS_ADMIN))
852 return -EPERM;
853
854 if (copy_from_user(&inout, arg, sizeof(inout)))
855 return -XFS_ERROR(EFAULT);
856
857 /* input parameter is passed in resblks field of structure */
858 in = inout.resblks;
859 error = xfs_reserve_blocks(mp, &in, &inout);
860 if (error)
861 return -error;
862
863 if (copy_to_user(arg, &inout, sizeof(inout)))
864 return -XFS_ERROR(EFAULT);
865 return 0;
866 }
867
868 case XFS_IOC_GET_RESBLKS: {
869 xfs_fsop_resblks_t out;
870
871 if (!capable(CAP_SYS_ADMIN))
872 return -EPERM;
873
874 error = xfs_reserve_blocks(mp, NULL, &out);
875 if (error)
876 return -error;
877
878 if (copy_to_user(arg, &out, sizeof(out)))
879 return -XFS_ERROR(EFAULT);
880
881 return 0;
882 }
883
884 case XFS_IOC_FSGROWFSDATA: {
885 xfs_growfs_data_t in;
886
887 if (!capable(CAP_SYS_ADMIN))
888 return -EPERM;
889
890 if (copy_from_user(&in, arg, sizeof(in)))
891 return -XFS_ERROR(EFAULT);
892
893 error = xfs_growfs_data(mp, &in);
894 return -error;
895 }
896
897 case XFS_IOC_FSGROWFSLOG: {
898 xfs_growfs_log_t in;
899
900 if (!capable(CAP_SYS_ADMIN))
901 return -EPERM;
902
903 if (copy_from_user(&in, arg, sizeof(in)))
904 return -XFS_ERROR(EFAULT);
905
906 error = xfs_growfs_log(mp, &in);
907 return -error;
908 }
909
910 case XFS_IOC_FSGROWFSRT: {
911 xfs_growfs_rt_t in;
912
913 if (!capable(CAP_SYS_ADMIN))
914 return -EPERM;
915
916 if (copy_from_user(&in, arg, sizeof(in)))
917 return -XFS_ERROR(EFAULT);
918
919 error = xfs_growfs_rt(mp, &in);
920 return -error;
921 }
922
923 case XFS_IOC_FREEZE:
924 if (!capable(CAP_SYS_ADMIN))
925 return -EPERM;
926
927 if (inode->i_sb->s_frozen == SB_UNFROZEN)
928 freeze_bdev(inode->i_sb->s_bdev);
929 return 0;
930
931 case XFS_IOC_THAW:
932 if (!capable(CAP_SYS_ADMIN))
933 return -EPERM;
934 if (inode->i_sb->s_frozen != SB_UNFROZEN)
935 thaw_bdev(inode->i_sb->s_bdev, inode->i_sb);
936 return 0;
937
938 case XFS_IOC_GOINGDOWN: {
939 __uint32_t in;
940
941 if (!capable(CAP_SYS_ADMIN))
942 return -EPERM;
943
944 if (get_user(in, (__uint32_t __user *)arg))
945 return -XFS_ERROR(EFAULT);
946
947 error = xfs_fs_goingdown(mp, in);
948 return -error;
949 }
950
951 case XFS_IOC_ERROR_INJECTION: {
952 xfs_error_injection_t in;
953
954 if (!capable(CAP_SYS_ADMIN))
955 return -EPERM;
956
957 if (copy_from_user(&in, arg, sizeof(in)))
958 return -XFS_ERROR(EFAULT);
959
960 error = xfs_errortag_add(in.errtag, mp);
961 return -error;
962 }
963
964 case XFS_IOC_ERROR_CLEARALL:
965 if (!capable(CAP_SYS_ADMIN))
966 return -EPERM;
967
968 error = xfs_errortag_clearall(mp);
969 return -error;
970
971 default:
972 return -ENOTTY;
973 }
974 }
975
976 STATIC int
977 xfs_ioc_space(
978 struct xfs_inode *ip,
979 struct inode *inode,
980 struct file *filp,
981 int ioflags,
982 unsigned int cmd,
983 void __user *arg)
984 {
985 xfs_flock64_t bf;
986 int attr_flags = 0;
987 int error;
988
989 if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
990 return -XFS_ERROR(EPERM);
991
992 if (!(filp->f_mode & FMODE_WRITE))
993 return -XFS_ERROR(EBADF);
994
995 if (!S_ISREG(inode->i_mode))
996 return -XFS_ERROR(EINVAL);
997
998 if (copy_from_user(&bf, arg, sizeof(bf)))
999 return -XFS_ERROR(EFAULT);
1000
1001 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1002 attr_flags |= ATTR_NONBLOCK;
1003 if (ioflags & IO_INVIS)
1004 attr_flags |= ATTR_DMI;
1005
1006 error = xfs_change_file_space(ip, cmd, &bf, filp->f_pos,
1007 NULL, attr_flags);
1008 return -error;
1009 }
1010
1011 STATIC int
1012 xfs_ioc_bulkstat(
1013 xfs_mount_t *mp,
1014 unsigned int cmd,
1015 void __user *arg)
1016 {
1017 xfs_fsop_bulkreq_t bulkreq;
1018 int count; /* # of records returned */
1019 xfs_ino_t inlast; /* last inode number */
1020 int done;
1021 int error;
1022
1023 /* done = 1 if there are more stats to get and if bulkstat */
1024 /* should be called again (unused here, but used in dmapi) */
1025
1026 if (!capable(CAP_SYS_ADMIN))
1027 return -EPERM;
1028
1029 if (XFS_FORCED_SHUTDOWN(mp))
1030 return -XFS_ERROR(EIO);
1031
1032 if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
1033 return -XFS_ERROR(EFAULT);
1034
1035 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
1036 return -XFS_ERROR(EFAULT);
1037
1038 if ((count = bulkreq.icount) <= 0)
1039 return -XFS_ERROR(EINVAL);
1040
1041 if (cmd == XFS_IOC_FSINUMBERS)
1042 error = xfs_inumbers(mp, &inlast, &count,
1043 bulkreq.ubuffer, xfs_inumbers_fmt);
1044 else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
1045 error = xfs_bulkstat_single(mp, &inlast,
1046 bulkreq.ubuffer, &done);
1047 else { /* XFS_IOC_FSBULKSTAT */
1048 if (count == 1 && inlast != 0) {
1049 inlast++;
1050 error = xfs_bulkstat_single(mp, &inlast,
1051 bulkreq.ubuffer, &done);
1052 } else {
1053 error = xfs_bulkstat(mp, &inlast, &count,
1054 (bulkstat_one_pf)xfs_bulkstat_one, NULL,
1055 sizeof(xfs_bstat_t), bulkreq.ubuffer,
1056 BULKSTAT_FG_QUICK, &done);
1057 }
1058 }
1059
1060 if (error)
1061 return -error;
1062
1063 if (bulkreq.ocount != NULL) {
1064 if (copy_to_user(bulkreq.lastip, &inlast,
1065 sizeof(xfs_ino_t)))
1066 return -XFS_ERROR(EFAULT);
1067
1068 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
1069 return -XFS_ERROR(EFAULT);
1070 }
1071
1072 return 0;
1073 }
1074
1075 STATIC int
1076 xfs_ioc_fsgeometry_v1(
1077 xfs_mount_t *mp,
1078 void __user *arg)
1079 {
1080 xfs_fsop_geom_v1_t fsgeo;
1081 int error;
1082
1083 error = xfs_fs_geometry(mp, (xfs_fsop_geom_t *)&fsgeo, 3);
1084 if (error)
1085 return -error;
1086
1087 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
1088 return -XFS_ERROR(EFAULT);
1089 return 0;
1090 }
1091
1092 STATIC int
1093 xfs_ioc_fsgeometry(
1094 xfs_mount_t *mp,
1095 void __user *arg)
1096 {
1097 xfs_fsop_geom_t fsgeo;
1098 int error;
1099
1100 error = xfs_fs_geometry(mp, &fsgeo, 4);
1101 if (error)
1102 return -error;
1103
1104 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
1105 return -XFS_ERROR(EFAULT);
1106 return 0;
1107 }
1108
1109 /*
1110 * Linux extended inode flags interface.
1111 */
1112
1113 STATIC unsigned int
1114 xfs_merge_ioc_xflags(
1115 unsigned int flags,
1116 unsigned int start)
1117 {
1118 unsigned int xflags = start;
1119
1120 if (flags & FS_IMMUTABLE_FL)
1121 xflags |= XFS_XFLAG_IMMUTABLE;
1122 else
1123 xflags &= ~XFS_XFLAG_IMMUTABLE;
1124 if (flags & FS_APPEND_FL)
1125 xflags |= XFS_XFLAG_APPEND;
1126 else
1127 xflags &= ~XFS_XFLAG_APPEND;
1128 if (flags & FS_SYNC_FL)
1129 xflags |= XFS_XFLAG_SYNC;
1130 else
1131 xflags &= ~XFS_XFLAG_SYNC;
1132 if (flags & FS_NOATIME_FL)
1133 xflags |= XFS_XFLAG_NOATIME;
1134 else
1135 xflags &= ~XFS_XFLAG_NOATIME;
1136 if (flags & FS_NODUMP_FL)
1137 xflags |= XFS_XFLAG_NODUMP;
1138 else
1139 xflags &= ~XFS_XFLAG_NODUMP;
1140
1141 return xflags;
1142 }
1143
1144 STATIC unsigned int
1145 xfs_di2lxflags(
1146 __uint16_t di_flags)
1147 {
1148 unsigned int flags = 0;
1149
1150 if (di_flags & XFS_DIFLAG_IMMUTABLE)
1151 flags |= FS_IMMUTABLE_FL;
1152 if (di_flags & XFS_DIFLAG_APPEND)
1153 flags |= FS_APPEND_FL;
1154 if (di_flags & XFS_DIFLAG_SYNC)
1155 flags |= FS_SYNC_FL;
1156 if (di_flags & XFS_DIFLAG_NOATIME)
1157 flags |= FS_NOATIME_FL;
1158 if (di_flags & XFS_DIFLAG_NODUMP)
1159 flags |= FS_NODUMP_FL;
1160 return flags;
1161 }
1162
1163 STATIC int
1164 xfs_ioc_xattr(
1165 bhv_vnode_t *vp,
1166 xfs_inode_t *ip,
1167 struct file *filp,
1168 unsigned int cmd,
1169 void __user *arg)
1170 {
1171 struct fsxattr fa;
1172 struct bhv_vattr *vattr;
1173 int error = 0;
1174 int attr_flags;
1175 unsigned int flags;
1176
1177 vattr = kmalloc(sizeof(*vattr), GFP_KERNEL);
1178 if (unlikely(!vattr))
1179 return -ENOMEM;
1180
1181 switch (cmd) {
1182 case XFS_IOC_FSGETXATTR: {
1183 vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
1184 XFS_AT_NEXTENTS | XFS_AT_PROJID;
1185 error = xfs_getattr(ip, vattr, 0);
1186 if (unlikely(error)) {
1187 error = -error;
1188 break;
1189 }
1190
1191 fa.fsx_xflags = vattr->va_xflags;
1192 fa.fsx_extsize = vattr->va_extsize;
1193 fa.fsx_nextents = vattr->va_nextents;
1194 fa.fsx_projid = vattr->va_projid;
1195
1196 if (copy_to_user(arg, &fa, sizeof(fa))) {
1197 error = -EFAULT;
1198 break;
1199 }
1200 break;
1201 }
1202
1203 case XFS_IOC_FSSETXATTR: {
1204 if (copy_from_user(&fa, arg, sizeof(fa))) {
1205 error = -EFAULT;
1206 break;
1207 }
1208
1209 attr_flags = 0;
1210 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1211 attr_flags |= ATTR_NONBLOCK;
1212
1213 vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | XFS_AT_PROJID;
1214 vattr->va_xflags = fa.fsx_xflags;
1215 vattr->va_extsize = fa.fsx_extsize;
1216 vattr->va_projid = fa.fsx_projid;
1217
1218 error = xfs_setattr(ip, vattr, attr_flags, NULL);
1219 if (likely(!error))
1220 __vn_revalidate(vp, vattr); /* update flags */
1221 error = -error;
1222 break;
1223 }
1224
1225 case XFS_IOC_FSGETXATTRA: {
1226 vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
1227 XFS_AT_ANEXTENTS | XFS_AT_PROJID;
1228 error = xfs_getattr(ip, vattr, 0);
1229 if (unlikely(error)) {
1230 error = -error;
1231 break;
1232 }
1233
1234 fa.fsx_xflags = vattr->va_xflags;
1235 fa.fsx_extsize = vattr->va_extsize;
1236 fa.fsx_nextents = vattr->va_anextents;
1237 fa.fsx_projid = vattr->va_projid;
1238
1239 if (copy_to_user(arg, &fa, sizeof(fa))) {
1240 error = -EFAULT;
1241 break;
1242 }
1243 break;
1244 }
1245
1246 case XFS_IOC_GETXFLAGS: {
1247 flags = xfs_di2lxflags(ip->i_d.di_flags);
1248 if (copy_to_user(arg, &flags, sizeof(flags)))
1249 error = -EFAULT;
1250 break;
1251 }
1252
1253 case XFS_IOC_SETXFLAGS: {
1254 if (copy_from_user(&flags, arg, sizeof(flags))) {
1255 error = -EFAULT;
1256 break;
1257 }
1258
1259 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1260 FS_NOATIME_FL | FS_NODUMP_FL | \
1261 FS_SYNC_FL)) {
1262 error = -EOPNOTSUPP;
1263 break;
1264 }
1265
1266 attr_flags = 0;
1267 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1268 attr_flags |= ATTR_NONBLOCK;
1269
1270 vattr->va_mask = XFS_AT_XFLAGS;
1271 vattr->va_xflags = xfs_merge_ioc_xflags(flags,
1272 xfs_ip2xflags(ip));
1273
1274 error = xfs_setattr(ip, vattr, attr_flags, NULL);
1275 if (likely(!error))
1276 __vn_revalidate(vp, vattr); /* update flags */
1277 error = -error;
1278 break;
1279 }
1280
1281 default:
1282 error = -ENOTTY;
1283 break;
1284 }
1285
1286 kfree(vattr);
1287 return error;
1288 }
1289
1290 STATIC int
1291 xfs_ioc_getbmap(
1292 struct xfs_inode *ip,
1293 int ioflags,
1294 unsigned int cmd,
1295 void __user *arg)
1296 {
1297 struct getbmap bm;
1298 int iflags;
1299 int error;
1300
1301 if (copy_from_user(&bm, arg, sizeof(bm)))
1302 return -XFS_ERROR(EFAULT);
1303
1304 if (bm.bmv_count < 2)
1305 return -XFS_ERROR(EINVAL);
1306
1307 iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1308 if (ioflags & IO_INVIS)
1309 iflags |= BMV_IF_NO_DMAPI_READ;
1310
1311 error = xfs_getbmap(ip, &bm, (struct getbmap __user *)arg+1, iflags);
1312 if (error)
1313 return -error;
1314
1315 if (copy_to_user(arg, &bm, sizeof(bm)))
1316 return -XFS_ERROR(EFAULT);
1317 return 0;
1318 }
1319
1320 STATIC int
1321 xfs_ioc_getbmapx(
1322 struct xfs_inode *ip,
1323 void __user *arg)
1324 {
1325 struct getbmapx bmx;
1326 struct getbmap bm;
1327 int iflags;
1328 int error;
1329
1330 if (copy_from_user(&bmx, arg, sizeof(bmx)))
1331 return -XFS_ERROR(EFAULT);
1332
1333 if (bmx.bmv_count < 2)
1334 return -XFS_ERROR(EINVAL);
1335
1336 /*
1337 * Map input getbmapx structure to a getbmap
1338 * structure for xfs_getbmap.
1339 */
1340 GETBMAP_CONVERT(bmx, bm);
1341
1342 iflags = bmx.bmv_iflags;
1343
1344 if (iflags & (~BMV_IF_VALID))
1345 return -XFS_ERROR(EINVAL);
1346
1347 iflags |= BMV_IF_EXTENDED;
1348
1349 error = xfs_getbmap(ip, &bm, (struct getbmapx __user *)arg+1, iflags);
1350 if (error)
1351 return -error;
1352
1353 GETBMAP_CONVERT(bm, bmx);
1354
1355 if (copy_to_user(arg, &bmx, sizeof(bmx)))
1356 return -XFS_ERROR(EFAULT);
1357
1358 return 0;
1359 }
Ubuntu combined Linux kernel mirror