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