[PATCH] Make XFS use BH_Unwritten and BH_Delay correctly
[linux-2.6] / 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
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);
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 }