projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[XFS] Check for invalid flags in xfs_attrlist_by_handle.
[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 /*
472 * Reject flags, only allow namespaces.
473 */
474 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
475 return -XFS_ERROR(EINVAL);
476
477 error = xfs_vget_fsop_handlereq(mp, parinode, &al_hreq.hreq, &inode);
478 if (error)
479 goto out;
480
481 kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);
482 if (!kbuf)
483 goto out_vn_rele;
484
485 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
486 error = xfs_attr_list(XFS_I(inode), kbuf, al_hreq.buflen,
487 al_hreq.flags, cursor);
488 if (error)
489 goto out_kfree;
490
491 if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
492 error = -EFAULT;
493
494 out_kfree:
495 kfree(kbuf);
496 out_vn_rele:
497 iput(inode);
498 out:
499 return -error;
500 }
501
502 STATIC int
503 xfs_attrmulti_attr_get(
504 struct inode *inode,
505 char *name,
506 char __user *ubuf,
507 __uint32_t *len,
508 __uint32_t flags)
509 {
510 char *kbuf;
511 int error = EFAULT;
512
513 if (*len > XATTR_SIZE_MAX)
514 return EINVAL;
515 kbuf = kmalloc(*len, GFP_KERNEL);
516 if (!kbuf)
517 return ENOMEM;
518
519 error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
520 if (error)
521 goto out_kfree;
522
523 if (copy_to_user(ubuf, kbuf, *len))
524 error = EFAULT;
525
526 out_kfree:
527 kfree(kbuf);
528 return error;
529 }
530
531 STATIC int
532 xfs_attrmulti_attr_set(
533 struct inode *inode,
534 char *name,
535 const char __user *ubuf,
536 __uint32_t len,
537 __uint32_t flags)
538 {
539 char *kbuf;
540 int error = EFAULT;
541
542 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
543 return EPERM;
544 if (len > XATTR_SIZE_MAX)
545 return EINVAL;
546
547 kbuf = kmalloc(len, GFP_KERNEL);
548 if (!kbuf)
549 return ENOMEM;
550
551 if (copy_from_user(kbuf, ubuf, len))
552 goto out_kfree;
553
554 error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
555
556 out_kfree:
557 kfree(kbuf);
558 return error;
559 }
560
561 STATIC int
562 xfs_attrmulti_attr_remove(
563 struct inode *inode,
564 char *name,
565 __uint32_t flags)
566 {
567 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
568 return EPERM;
569 return xfs_attr_remove(XFS_I(inode), name, flags);
570 }
571
572 STATIC int
573 xfs_attrmulti_by_handle(
574 xfs_mount_t *mp,
575 void __user *arg,
576 struct file *parfilp,
577 struct inode *parinode)
578 {
579 int error;
580 xfs_attr_multiop_t *ops;
581 xfs_fsop_attrmulti_handlereq_t am_hreq;
582 struct inode *inode;
583 unsigned int i, size;
584 char *attr_name;
585
586 if (!capable(CAP_SYS_ADMIN))
587 return -XFS_ERROR(EPERM);
588 if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
589 return -XFS_ERROR(EFAULT);
590
591 error = xfs_vget_fsop_handlereq(mp, parinode, &am_hreq.hreq, &inode);
592 if (error)
593 goto out;
594
595 error = E2BIG;
596 size = am_hreq.opcount * sizeof(attr_multiop_t);
597 if (!size || size > 16 * PAGE_SIZE)
598 goto out_vn_rele;
599
600 error = ENOMEM;
601 ops = kmalloc(size, GFP_KERNEL);
602 if (!ops)
603 goto out_vn_rele;
604
605 error = EFAULT;
606 if (copy_from_user(ops, am_hreq.ops, size))
607 goto out_kfree_ops;
608
609 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
610 if (!attr_name)
611 goto out_kfree_ops;
612
613
614 error = 0;
615 for (i = 0; i < am_hreq.opcount; i++) {
616 ops[i].am_error = strncpy_from_user(attr_name,
617 ops[i].am_attrname, MAXNAMELEN);
618 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
619 error = -ERANGE;
620 if (ops[i].am_error < 0)
621 break;
622
623 switch (ops[i].am_opcode) {
624 case ATTR_OP_GET:
625 ops[i].am_error = xfs_attrmulti_attr_get(inode,
626 attr_name, ops[i].am_attrvalue,
627 &ops[i].am_length, ops[i].am_flags);
628 break;
629 case ATTR_OP_SET:
630 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
631 if (ops[i].am_error)
632 break;
633 ops[i].am_error = xfs_attrmulti_attr_set(inode,
634 attr_name, ops[i].am_attrvalue,
635 ops[i].am_length, ops[i].am_flags);
636 mnt_drop_write(parfilp->f_path.mnt);
637 break;
638 case ATTR_OP_REMOVE:
639 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
640 if (ops[i].am_error)
641 break;
642 ops[i].am_error = xfs_attrmulti_attr_remove(inode,
643 attr_name, ops[i].am_flags);
644 mnt_drop_write(parfilp->f_path.mnt);
645 break;
646 default:
647 ops[i].am_error = EINVAL;
648 }
649 }
650
651 if (copy_to_user(am_hreq.ops, ops, size))
652 error = XFS_ERROR(EFAULT);
653
654 kfree(attr_name);
655 out_kfree_ops:
656 kfree(ops);
657 out_vn_rele:
658 iput(inode);
659 out:
660 return -error;
661 }
662
663 STATIC int
664 xfs_ioc_space(
665 struct xfs_inode *ip,
666 struct inode *inode,
667 struct file *filp,
668 int ioflags,
669 unsigned int cmd,
670 void __user *arg)
671 {
672 xfs_flock64_t bf;
673 int attr_flags = 0;
674 int error;
675
676 if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
677 return -XFS_ERROR(EPERM);
678
679 if (!(filp->f_mode & FMODE_WRITE))
680 return -XFS_ERROR(EBADF);
681
682 if (!S_ISREG(inode->i_mode))
683 return -XFS_ERROR(EINVAL);
684
685 if (copy_from_user(&bf, arg, sizeof(bf)))
686 return -XFS_ERROR(EFAULT);
687
688 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
689 attr_flags |= ATTR_NONBLOCK;
690 if (ioflags & IO_INVIS)
691 attr_flags |= ATTR_DMI;
692
693 error = xfs_change_file_space(ip, cmd, &bf, filp->f_pos,
694 NULL, attr_flags);
695 return -error;
696 }
697
698 STATIC int
699 xfs_ioc_bulkstat(
700 xfs_mount_t *mp,
701 unsigned int cmd,
702 void __user *arg)
703 {
704 xfs_fsop_bulkreq_t bulkreq;
705 int count; /* # of records returned */
706 xfs_ino_t inlast; /* last inode number */
707 int done;
708 int error;
709
710 /* done = 1 if there are more stats to get and if bulkstat */
711 /* should be called again (unused here, but used in dmapi) */
712
713 if (!capable(CAP_SYS_ADMIN))
714 return -EPERM;
715
716 if (XFS_FORCED_SHUTDOWN(mp))
717 return -XFS_ERROR(EIO);
718
719 if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
720 return -XFS_ERROR(EFAULT);
721
722 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
723 return -XFS_ERROR(EFAULT);
724
725 if ((count = bulkreq.icount) <= 0)
726 return -XFS_ERROR(EINVAL);
727
728 if (bulkreq.ubuffer == NULL)
729 return -XFS_ERROR(EINVAL);
730
731 if (cmd == XFS_IOC_FSINUMBERS)
732 error = xfs_inumbers(mp, &inlast, &count,
733 bulkreq.ubuffer, xfs_inumbers_fmt);
734 else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
735 error = xfs_bulkstat_single(mp, &inlast,
736 bulkreq.ubuffer, &done);
737 else /* XFS_IOC_FSBULKSTAT */
738 error = xfs_bulkstat(mp, &inlast, &count,
739 (bulkstat_one_pf)xfs_bulkstat_one, NULL,
740 sizeof(xfs_bstat_t), bulkreq.ubuffer,
741 BULKSTAT_FG_QUICK, &done);
742
743 if (error)
744 return -error;
745
746 if (bulkreq.ocount != NULL) {
747 if (copy_to_user(bulkreq.lastip, &inlast,
748 sizeof(xfs_ino_t)))
749 return -XFS_ERROR(EFAULT);
750
751 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
752 return -XFS_ERROR(EFAULT);
753 }
754
755 return 0;
756 }
757
758 STATIC int
759 xfs_ioc_fsgeometry_v1(
760 xfs_mount_t *mp,
761 void __user *arg)
762 {
763 xfs_fsop_geom_v1_t fsgeo;
764 int error;
765
766 error = xfs_fs_geometry(mp, (xfs_fsop_geom_t *)&fsgeo, 3);
767 if (error)
768 return -error;
769
770 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
771 return -XFS_ERROR(EFAULT);
772 return 0;
773 }
774
775 STATIC int
776 xfs_ioc_fsgeometry(
777 xfs_mount_t *mp,
778 void __user *arg)
779 {
780 xfs_fsop_geom_t fsgeo;
781 int error;
782
783 error = xfs_fs_geometry(mp, &fsgeo, 4);
784 if (error)
785 return -error;
786
787 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
788 return -XFS_ERROR(EFAULT);
789 return 0;
790 }
791
792 /*
793 * Linux extended inode flags interface.
794 */
795
796 STATIC unsigned int
797 xfs_merge_ioc_xflags(
798 unsigned int flags,
799 unsigned int start)
800 {
801 unsigned int xflags = start;
802
803 if (flags & FS_IMMUTABLE_FL)
804 xflags |= XFS_XFLAG_IMMUTABLE;
805 else
806 xflags &= ~XFS_XFLAG_IMMUTABLE;
807 if (flags & FS_APPEND_FL)
808 xflags |= XFS_XFLAG_APPEND;
809 else
810 xflags &= ~XFS_XFLAG_APPEND;
811 if (flags & FS_SYNC_FL)
812 xflags |= XFS_XFLAG_SYNC;
813 else
814 xflags &= ~XFS_XFLAG_SYNC;
815 if (flags & FS_NOATIME_FL)
816 xflags |= XFS_XFLAG_NOATIME;
817 else
818 xflags &= ~XFS_XFLAG_NOATIME;
819 if (flags & FS_NODUMP_FL)
820 xflags |= XFS_XFLAG_NODUMP;
821 else
822 xflags &= ~XFS_XFLAG_NODUMP;
823
824 return xflags;
825 }
826
827 STATIC unsigned int
828 xfs_di2lxflags(
829 __uint16_t di_flags)
830 {
831 unsigned int flags = 0;
832
833 if (di_flags & XFS_DIFLAG_IMMUTABLE)
834 flags |= FS_IMMUTABLE_FL;
835 if (di_flags & XFS_DIFLAG_APPEND)
836 flags |= FS_APPEND_FL;
837 if (di_flags & XFS_DIFLAG_SYNC)
838 flags |= FS_SYNC_FL;
839 if (di_flags & XFS_DIFLAG_NOATIME)
840 flags |= FS_NOATIME_FL;
841 if (di_flags & XFS_DIFLAG_NODUMP)
842 flags |= FS_NODUMP_FL;
843 return flags;
844 }
845
846 STATIC int
847 xfs_ioc_fsgetxattr(
848 xfs_inode_t *ip,
849 int attr,
850 void __user *arg)
851 {
852 struct fsxattr fa;
853
854 xfs_ilock(ip, XFS_ILOCK_SHARED);
855 fa.fsx_xflags = xfs_ip2xflags(ip);
856 fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
857 fa.fsx_projid = ip->i_d.di_projid;
858
859 if (attr) {
860 if (ip->i_afp) {
861 if (ip->i_afp->if_flags & XFS_IFEXTENTS)
862 fa.fsx_nextents = ip->i_afp->if_bytes /
863 sizeof(xfs_bmbt_rec_t);
864 else
865 fa.fsx_nextents = ip->i_d.di_anextents;
866 } else
867 fa.fsx_nextents = 0;
868 } else {
869 if (ip->i_df.if_flags & XFS_IFEXTENTS)
870 fa.fsx_nextents = ip->i_df.if_bytes /
871 sizeof(xfs_bmbt_rec_t);
872 else
873 fa.fsx_nextents = ip->i_d.di_nextents;
874 }
875 xfs_iunlock(ip, XFS_ILOCK_SHARED);
876
877 if (copy_to_user(arg, &fa, sizeof(fa)))
878 return -EFAULT;
879 return 0;
880 }
881
882 STATIC int
883 xfs_ioc_fssetxattr(
884 xfs_inode_t *ip,
885 struct file *filp,
886 void __user *arg)
887 {
888 struct fsxattr fa;
889 struct bhv_vattr *vattr;
890 int error;
891 int attr_flags;
892
893 if (copy_from_user(&fa, arg, sizeof(fa)))
894 return -EFAULT;
895
896 vattr = kmalloc(sizeof(*vattr), GFP_KERNEL);
897 if (unlikely(!vattr))
898 return -ENOMEM;
899
900 attr_flags = 0;
901 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
902 attr_flags |= ATTR_NONBLOCK;
903
904 vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | XFS_AT_PROJID;
905 vattr->va_xflags = fa.fsx_xflags;
906 vattr->va_extsize = fa.fsx_extsize;
907 vattr->va_projid = fa.fsx_projid;
908
909 error = -xfs_setattr(ip, vattr, attr_flags, NULL);
910 if (!error)
911 vn_revalidate(XFS_ITOV(ip)); /* update flags */
912 kfree(vattr);
913 return 0;
914 }
915
916 STATIC int
917 xfs_ioc_getxflags(
918 xfs_inode_t *ip,
919 void __user *arg)
920 {
921 unsigned int flags;
922
923 flags = xfs_di2lxflags(ip->i_d.di_flags);
924 if (copy_to_user(arg, &flags, sizeof(flags)))
925 return -EFAULT;
926 return 0;
927 }
928
929 STATIC int
930 xfs_ioc_setxflags(
931 xfs_inode_t *ip,
932 struct file *filp,
933 void __user *arg)
934 {
935 struct bhv_vattr *vattr;
936 unsigned int flags;
937 int attr_flags;
938 int error;
939
940 if (copy_from_user(&flags, arg, sizeof(flags)))
941 return -EFAULT;
942
943 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
944 FS_NOATIME_FL | FS_NODUMP_FL | \
945 FS_SYNC_FL))
946 return -EOPNOTSUPP;
947
948 vattr = kmalloc(sizeof(*vattr), GFP_KERNEL);
949 if (unlikely(!vattr))
950 return -ENOMEM;
951
952 attr_flags = 0;
953 if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
954 attr_flags |= ATTR_NONBLOCK;
955
956 vattr->va_mask = XFS_AT_XFLAGS;
957 vattr->va_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
958
959 error = -xfs_setattr(ip, vattr, attr_flags, NULL);
960 if (likely(!error))
961 vn_revalidate(XFS_ITOV(ip)); /* update flags */
962 kfree(vattr);
963 return error;
964 }
965
966 STATIC int
967 xfs_ioc_getbmap(
968 struct xfs_inode *ip,
969 int ioflags,
970 unsigned int cmd,
971 void __user *arg)
972 {
973 struct getbmap bm;
974 int iflags;
975 int error;
976
977 if (copy_from_user(&bm, arg, sizeof(bm)))
978 return -XFS_ERROR(EFAULT);
979
980 if (bm.bmv_count < 2)
981 return -XFS_ERROR(EINVAL);
982
983 iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
984 if (ioflags & IO_INVIS)
985 iflags |= BMV_IF_NO_DMAPI_READ;
986
987 error = xfs_getbmap(ip, &bm, (struct getbmap __user *)arg+1, iflags);
988 if (error)
989 return -error;
990
991 if (copy_to_user(arg, &bm, sizeof(bm)))
992 return -XFS_ERROR(EFAULT);
993 return 0;
994 }
995
996 STATIC int
997 xfs_ioc_getbmapx(
998 struct xfs_inode *ip,
999 void __user *arg)
1000 {
1001 struct getbmapx bmx;
1002 struct getbmap bm;
1003 int iflags;
1004 int error;
1005
1006 if (copy_from_user(&bmx, arg, sizeof(bmx)))
1007 return -XFS_ERROR(EFAULT);
1008
1009 if (bmx.bmv_count < 2)
1010 return -XFS_ERROR(EINVAL);
1011
1012 /*
1013 * Map input getbmapx structure to a getbmap
1014 * structure for xfs_getbmap.
1015 */
1016 GETBMAP_CONVERT(bmx, bm);
1017
1018 iflags = bmx.bmv_iflags;
1019
1020 if (iflags & (~BMV_IF_VALID))
1021 return -XFS_ERROR(EINVAL);
1022
1023 iflags |= BMV_IF_EXTENDED;
1024
1025 error = xfs_getbmap(ip, &bm, (struct getbmapx __user *)arg+1, iflags);
1026 if (error)
1027 return -error;
1028
1029 GETBMAP_CONVERT(bm, bmx);
1030
1031 if (copy_to_user(arg, &bmx, sizeof(bmx)))
1032 return -XFS_ERROR(EFAULT);
1033
1034 return 0;
1035 }
1036
1037 int
1038 xfs_ioctl(
1039 xfs_inode_t *ip,
1040 struct file *filp,
1041 int ioflags,
1042 unsigned int cmd,
1043 void __user *arg)
1044 {
1045 struct inode *inode = filp->f_path.dentry->d_inode;
1046 xfs_mount_t *mp = ip->i_mount;
1047 int error;
1048
1049 xfs_itrace_entry(XFS_I(inode));
1050 switch (cmd) {
1051
1052 case XFS_IOC_ALLOCSP:
1053 case XFS_IOC_FREESP:
1054 case XFS_IOC_RESVSP:
1055 case XFS_IOC_UNRESVSP:
1056 case XFS_IOC_ALLOCSP64:
1057 case XFS_IOC_FREESP64:
1058 case XFS_IOC_RESVSP64:
1059 case XFS_IOC_UNRESVSP64:
1060 /*
1061 * Only allow the sys admin to reserve space unless
1062 * unwritten extents are enabled.
1063 */
1064 if (!xfs_sb_version_hasextflgbit(&mp->m_sb) &&
1065 !capable(CAP_SYS_ADMIN))
1066 return -EPERM;
1067
1068 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, arg);
1069
1070 case XFS_IOC_DIOINFO: {
1071 struct dioattr da;
1072 xfs_buftarg_t *target =
1073 XFS_IS_REALTIME_INODE(ip) ?
1074 mp->m_rtdev_targp : mp->m_ddev_targp;
1075
1076 da.d_mem = da.d_miniosz = 1 << target->bt_sshift;
1077 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1078
1079 if (copy_to_user(arg, &da, sizeof(da)))
1080 return -XFS_ERROR(EFAULT);
1081 return 0;
1082 }
1083
1084 case XFS_IOC_FSBULKSTAT_SINGLE:
1085 case XFS_IOC_FSBULKSTAT:
1086 case XFS_IOC_FSINUMBERS:
1087 return xfs_ioc_bulkstat(mp, cmd, arg);
1088
1089 case XFS_IOC_FSGEOMETRY_V1:
1090 return xfs_ioc_fsgeometry_v1(mp, arg);
1091
1092 case XFS_IOC_FSGEOMETRY:
1093 return xfs_ioc_fsgeometry(mp, arg);
1094
1095 case XFS_IOC_GETVERSION:
1096 return put_user(inode->i_generation, (int __user *)arg);
1097
1098 case XFS_IOC_FSGETXATTR:
1099 return xfs_ioc_fsgetxattr(ip, 0, arg);
1100 case XFS_IOC_FSGETXATTRA:
1101 return xfs_ioc_fsgetxattr(ip, 1, arg);
1102 case XFS_IOC_FSSETXATTR:
1103 return xfs_ioc_fssetxattr(ip, filp, arg);
1104 case XFS_IOC_GETXFLAGS:
1105 return xfs_ioc_getxflags(ip, arg);
1106 case XFS_IOC_SETXFLAGS:
1107 return xfs_ioc_setxflags(ip, filp, arg);
1108
1109 case XFS_IOC_FSSETDM: {
1110 struct fsdmidata dmi;
1111
1112 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1113 return -XFS_ERROR(EFAULT);
1114
1115 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1116 dmi.fsd_dmstate);
1117 return -error;
1118 }
1119
1120 case XFS_IOC_GETBMAP:
1121 case XFS_IOC_GETBMAPA:
1122 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1123
1124 case XFS_IOC_GETBMAPX:
1125 return xfs_ioc_getbmapx(ip, arg);
1126
1127 case XFS_IOC_FD_TO_HANDLE:
1128 case XFS_IOC_PATH_TO_HANDLE:
1129 case XFS_IOC_PATH_TO_FSHANDLE:
1130 return xfs_find_handle(cmd, arg);
1131
1132 case XFS_IOC_OPEN_BY_HANDLE:
1133 return xfs_open_by_handle(mp, arg, filp, inode);
1134
1135 case XFS_IOC_FSSETDM_BY_HANDLE:
1136 return xfs_fssetdm_by_handle(mp, arg, inode);
1137
1138 case XFS_IOC_READLINK_BY_HANDLE:
1139 return xfs_readlink_by_handle(mp, arg, inode);
1140
1141 case XFS_IOC_ATTRLIST_BY_HANDLE:
1142 return xfs_attrlist_by_handle(mp, arg, inode);
1143
1144 case XFS_IOC_ATTRMULTI_BY_HANDLE:
1145 return xfs_attrmulti_by_handle(mp, arg, filp, inode);
1146
1147 case XFS_IOC_SWAPEXT: {
1148 error = xfs_swapext((struct xfs_swapext __user *)arg);
1149 return -error;
1150 }
1151
1152 case XFS_IOC_FSCOUNTS: {
1153 xfs_fsop_counts_t out;
1154
1155 error = xfs_fs_counts(mp, &out);
1156 if (error)
1157 return -error;
1158
1159 if (copy_to_user(arg, &out, sizeof(out)))
1160 return -XFS_ERROR(EFAULT);
1161 return 0;
1162 }
1163
1164 case XFS_IOC_SET_RESBLKS: {
1165 xfs_fsop_resblks_t inout;
1166 __uint64_t in;
1167
1168 if (!capable(CAP_SYS_ADMIN))
1169 return -EPERM;
1170
1171 if (copy_from_user(&inout, arg, sizeof(inout)))
1172 return -XFS_ERROR(EFAULT);
1173
1174 /* input parameter is passed in resblks field of structure */
1175 in = inout.resblks;
1176 error = xfs_reserve_blocks(mp, &in, &inout);
1177 if (error)
1178 return -error;
1179
1180 if (copy_to_user(arg, &inout, sizeof(inout)))
1181 return -XFS_ERROR(EFAULT);
1182 return 0;
1183 }
1184
1185 case XFS_IOC_GET_RESBLKS: {
1186 xfs_fsop_resblks_t out;
1187
1188 if (!capable(CAP_SYS_ADMIN))
1189 return -EPERM;
1190
1191 error = xfs_reserve_blocks(mp, NULL, &out);
1192 if (error)
1193 return -error;
1194
1195 if (copy_to_user(arg, &out, sizeof(out)))
1196 return -XFS_ERROR(EFAULT);
1197
1198 return 0;
1199 }
1200
1201 case XFS_IOC_FSGROWFSDATA: {
1202 xfs_growfs_data_t in;
1203
1204 if (!capable(CAP_SYS_ADMIN))
1205 return -EPERM;
1206
1207 if (copy_from_user(&in, arg, sizeof(in)))
1208 return -XFS_ERROR(EFAULT);
1209
1210 error = xfs_growfs_data(mp, &in);
1211 return -error;
1212 }
1213
1214 case XFS_IOC_FSGROWFSLOG: {
1215 xfs_growfs_log_t in;
1216
1217 if (!capable(CAP_SYS_ADMIN))
1218 return -EPERM;
1219
1220 if (copy_from_user(&in, arg, sizeof(in)))
1221 return -XFS_ERROR(EFAULT);
1222
1223 error = xfs_growfs_log(mp, &in);
1224 return -error;
1225 }
1226
1227 case XFS_IOC_FSGROWFSRT: {
1228 xfs_growfs_rt_t in;
1229
1230 if (!capable(CAP_SYS_ADMIN))
1231 return -EPERM;
1232
1233 if (copy_from_user(&in, arg, sizeof(in)))
1234 return -XFS_ERROR(EFAULT);
1235
1236 error = xfs_growfs_rt(mp, &in);
1237 return -error;
1238 }
1239
1240 case XFS_IOC_FREEZE:
1241 if (!capable(CAP_SYS_ADMIN))
1242 return -EPERM;
1243
1244 if (inode->i_sb->s_frozen == SB_UNFROZEN)
1245 freeze_bdev(inode->i_sb->s_bdev);
1246 return 0;
1247
1248 case XFS_IOC_THAW:
1249 if (!capable(CAP_SYS_ADMIN))
1250 return -EPERM;
1251 if (inode->i_sb->s_frozen != SB_UNFROZEN)
1252 thaw_bdev(inode->i_sb->s_bdev, inode->i_sb);
1253 return 0;
1254
1255 case XFS_IOC_GOINGDOWN: {
1256 __uint32_t in;
1257
1258 if (!capable(CAP_SYS_ADMIN))
1259 return -EPERM;
1260
1261 if (get_user(in, (__uint32_t __user *)arg))
1262 return -XFS_ERROR(EFAULT);
1263
1264 error = xfs_fs_goingdown(mp, in);
1265 return -error;
1266 }
1267
1268 case XFS_IOC_ERROR_INJECTION: {
1269 xfs_error_injection_t in;
1270
1271 if (!capable(CAP_SYS_ADMIN))
1272 return -EPERM;
1273
1274 if (copy_from_user(&in, arg, sizeof(in)))
1275 return -XFS_ERROR(EFAULT);
1276
1277 error = xfs_errortag_add(in.errtag, mp);
1278 return -error;
1279 }
1280
1281 case XFS_IOC_ERROR_CLEARALL:
1282 if (!capable(CAP_SYS_ADMIN))
1283 return -EPERM;
1284
1285 error = xfs_errortag_clearall(mp, 1);
1286 return -error;
1287
1288 default:
1289 return -ENOTTY;
1290 }
1291 }
Linux kernel - Deliverables
This page took 0.128278 seconds and 5 git commands to generate.