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