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