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