projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
net: move fib_rules_unregister() under rtnl lock
[deliverable/linux.git] / fs / xfs / 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_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_mount.h"
25 #include "xfs_inode.h"
26 #include "xfs_ioctl.h"
27 #include "xfs_alloc.h"
28 #include "xfs_rtalloc.h"
29 #include "xfs_itable.h"
30 #include "xfs_error.h"
31 #include "xfs_attr.h"
32 #include "xfs_bmap.h"
33 #include "xfs_bmap_util.h"
34 #include "xfs_fsops.h"
35 #include "xfs_discard.h"
36 #include "xfs_quota.h"
37 #include "xfs_export.h"
38 #include "xfs_trace.h"
39 #include "xfs_icache.h"
40 #include "xfs_symlink.h"
41 #include "xfs_trans.h"
42 #include "xfs_pnfs.h"
43
44 #include <linux/capability.h>
45 #include <linux/dcache.h>
46 #include <linux/mount.h>
47 #include <linux/namei.h>
48 #include <linux/pagemap.h>
49 #include <linux/slab.h>
50 #include <linux/exportfs.h>
51
52 /*
53 * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
54 * a file or fs handle.
55 *
56 * XFS_IOC_PATH_TO_FSHANDLE
57 * returns fs handle for a mount point or path within that mount point
58 * XFS_IOC_FD_TO_HANDLE
59 * returns full handle for a FD opened in user space
60 * XFS_IOC_PATH_TO_HANDLE
61 * returns full handle for a path
62 */
63 int
64 xfs_find_handle(
65 unsigned int cmd,
66 xfs_fsop_handlereq_t *hreq)
67 {
68 int hsize;
69 xfs_handle_t handle;
70 struct inode *inode;
71 struct fd f = {NULL};
72 struct path path;
73 int error;
74 struct xfs_inode *ip;
75
76 if (cmd == XFS_IOC_FD_TO_HANDLE) {
77 f = fdget(hreq->fd);
78 if (!f.file)
79 return -EBADF;
80 inode = file_inode(f.file);
81 } else {
82 error = user_lpath((const char __user *)hreq->path, &path);
83 if (error)
84 return error;
85 inode = path.dentry->d_inode;
86 }
87 ip = XFS_I(inode);
88
89 /*
90 * We can only generate handles for inodes residing on a XFS filesystem,
91 * and only for regular files, directories or symbolic links.
92 */
93 error = -EINVAL;
94 if (inode->i_sb->s_magic != XFS_SB_MAGIC)
95 goto out_put;
96
97 error = -EBADF;
98 if (!S_ISREG(inode->i_mode) &&
99 !S_ISDIR(inode->i_mode) &&
100 !S_ISLNK(inode->i_mode))
101 goto out_put;
102
103
104 memcpy(&handle.ha_fsid, ip->i_mount->m_fixedfsid, sizeof(xfs_fsid_t));
105
106 if (cmd == XFS_IOC_PATH_TO_FSHANDLE) {
107 /*
108 * This handle only contains an fsid, zero the rest.
109 */
110 memset(&handle.ha_fid, 0, sizeof(handle.ha_fid));
111 hsize = sizeof(xfs_fsid_t);
112 } else {
113 handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
114 sizeof(handle.ha_fid.fid_len);
115 handle.ha_fid.fid_pad = 0;
116 handle.ha_fid.fid_gen = ip->i_d.di_gen;
117 handle.ha_fid.fid_ino = ip->i_ino;
118
119 hsize = XFS_HSIZE(handle);
120 }
121
122 error = -EFAULT;
123 if (copy_to_user(hreq->ohandle, &handle, hsize) ||
124 copy_to_user(hreq->ohandlen, &hsize, sizeof(__s32)))
125 goto out_put;
126
127 error = 0;
128
129 out_put:
130 if (cmd == XFS_IOC_FD_TO_HANDLE)
131 fdput(f);
132 else
133 path_put(&path);
134 return error;
135 }
136
137 /*
138 * No need to do permission checks on the various pathname components
139 * as the handle operations are privileged.
140 */
141 STATIC int
142 xfs_handle_acceptable(
143 void *context,
144 struct dentry *dentry)
145 {
146 return 1;
147 }
148
149 /*
150 * Convert userspace handle data into a dentry.
151 */
152 struct dentry *
153 xfs_handle_to_dentry(
154 struct file *parfilp,
155 void __user *uhandle,
156 u32 hlen)
157 {
158 xfs_handle_t handle;
159 struct xfs_fid64 fid;
160
161 /*
162 * Only allow handle opens under a directory.
163 */
164 if (!S_ISDIR(file_inode(parfilp)->i_mode))
165 return ERR_PTR(-ENOTDIR);
166
167 if (hlen != sizeof(xfs_handle_t))
168 return ERR_PTR(-EINVAL);
169 if (copy_from_user(&handle, uhandle, hlen))
170 return ERR_PTR(-EFAULT);
171 if (handle.ha_fid.fid_len !=
172 sizeof(handle.ha_fid) - sizeof(handle.ha_fid.fid_len))
173 return ERR_PTR(-EINVAL);
174
175 memset(&fid, 0, sizeof(struct fid));
176 fid.ino = handle.ha_fid.fid_ino;
177 fid.gen = handle.ha_fid.fid_gen;
178
179 return exportfs_decode_fh(parfilp->f_path.mnt, (struct fid *)&fid, 3,
180 FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG,
181 xfs_handle_acceptable, NULL);
182 }
183
184 STATIC struct dentry *
185 xfs_handlereq_to_dentry(
186 struct file *parfilp,
187 xfs_fsop_handlereq_t *hreq)
188 {
189 return xfs_handle_to_dentry(parfilp, hreq->ihandle, hreq->ihandlen);
190 }
191
192 int
193 xfs_open_by_handle(
194 struct file *parfilp,
195 xfs_fsop_handlereq_t *hreq)
196 {
197 const struct cred *cred = current_cred();
198 int error;
199 int fd;
200 int permflag;
201 struct file *filp;
202 struct inode *inode;
203 struct dentry *dentry;
204 fmode_t fmode;
205 struct path path;
206
207 if (!capable(CAP_SYS_ADMIN))
208 return -EPERM;
209
210 dentry = xfs_handlereq_to_dentry(parfilp, hreq);
211 if (IS_ERR(dentry))
212 return PTR_ERR(dentry);
213 inode = dentry->d_inode;
214
215 /* Restrict xfs_open_by_handle to directories & regular files. */
216 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
217 error = -EPERM;
218 goto out_dput;
219 }
220
221 #if BITS_PER_LONG != 32
222 hreq->oflags |= O_LARGEFILE;
223 #endif
224
225 permflag = hreq->oflags;
226 fmode = OPEN_FMODE(permflag);
227 if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
228 (fmode & FMODE_WRITE) && IS_APPEND(inode)) {
229 error = -EPERM;
230 goto out_dput;
231 }
232
233 if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
234 error = -EACCES;
235 goto out_dput;
236 }
237
238 /* Can't write directories. */
239 if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
240 error = -EISDIR;
241 goto out_dput;
242 }
243
244 fd = get_unused_fd_flags(0);
245 if (fd < 0) {
246 error = fd;
247 goto out_dput;
248 }
249
250 path.mnt = parfilp->f_path.mnt;
251 path.dentry = dentry;
252 filp = dentry_open(&path, hreq->oflags, cred);
253 dput(dentry);
254 if (IS_ERR(filp)) {
255 put_unused_fd(fd);
256 return PTR_ERR(filp);
257 }
258
259 if (S_ISREG(inode->i_mode)) {
260 filp->f_flags |= O_NOATIME;
261 filp->f_mode |= FMODE_NOCMTIME;
262 }
263
264 fd_install(fd, filp);
265 return fd;
266
267 out_dput:
268 dput(dentry);
269 return error;
270 }
271
272 int
273 xfs_readlink_by_handle(
274 struct file *parfilp,
275 xfs_fsop_handlereq_t *hreq)
276 {
277 struct dentry *dentry;
278 __u32 olen;
279 void *link;
280 int error;
281
282 if (!capable(CAP_SYS_ADMIN))
283 return -EPERM;
284
285 dentry = xfs_handlereq_to_dentry(parfilp, hreq);
286 if (IS_ERR(dentry))
287 return PTR_ERR(dentry);
288
289 /* Restrict this handle operation to symlinks only. */
290 if (!d_is_symlink(dentry)) {
291 error = -EINVAL;
292 goto out_dput;
293 }
294
295 if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
296 error = -EFAULT;
297 goto out_dput;
298 }
299
300 link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
301 if (!link) {
302 error = -ENOMEM;
303 goto out_dput;
304 }
305
306 error = xfs_readlink(XFS_I(dentry->d_inode), link);
307 if (error)
308 goto out_kfree;
309 error = readlink_copy(hreq->ohandle, olen, link);
310 if (error)
311 goto out_kfree;
312
313 out_kfree:
314 kfree(link);
315 out_dput:
316 dput(dentry);
317 return error;
318 }
319
320 int
321 xfs_set_dmattrs(
322 xfs_inode_t *ip,
323 u_int evmask,
324 u_int16_t state)
325 {
326 xfs_mount_t *mp = ip->i_mount;
327 xfs_trans_t *tp;
328 int error;
329
330 if (!capable(CAP_SYS_ADMIN))
331 return -EPERM;
332
333 if (XFS_FORCED_SHUTDOWN(mp))
334 return -EIO;
335
336 tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
337 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
338 if (error) {
339 xfs_trans_cancel(tp, 0);
340 return error;
341 }
342 xfs_ilock(ip, XFS_ILOCK_EXCL);
343 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
344
345 ip->i_d.di_dmevmask = evmask;
346 ip->i_d.di_dmstate = state;
347
348 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
349 error = xfs_trans_commit(tp, 0);
350
351 return error;
352 }
353
354 STATIC int
355 xfs_fssetdm_by_handle(
356 struct file *parfilp,
357 void __user *arg)
358 {
359 int error;
360 struct fsdmidata fsd;
361 xfs_fsop_setdm_handlereq_t dmhreq;
362 struct dentry *dentry;
363
364 if (!capable(CAP_MKNOD))
365 return -EPERM;
366 if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
367 return -EFAULT;
368
369 error = mnt_want_write_file(parfilp);
370 if (error)
371 return error;
372
373 dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);
374 if (IS_ERR(dentry)) {
375 mnt_drop_write_file(parfilp);
376 return PTR_ERR(dentry);
377 }
378
379 if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
380 error = -EPERM;
381 goto out;
382 }
383
384 if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
385 error = -EFAULT;
386 goto out;
387 }
388
389 error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
390 fsd.fsd_dmstate);
391
392 out:
393 mnt_drop_write_file(parfilp);
394 dput(dentry);
395 return error;
396 }
397
398 STATIC int
399 xfs_attrlist_by_handle(
400 struct file *parfilp,
401 void __user *arg)
402 {
403 int error = -ENOMEM;
404 attrlist_cursor_kern_t *cursor;
405 xfs_fsop_attrlist_handlereq_t al_hreq;
406 struct dentry *dentry;
407 char *kbuf;
408
409 if (!capable(CAP_SYS_ADMIN))
410 return -EPERM;
411 if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
412 return -EFAULT;
413 if (al_hreq.buflen < sizeof(struct attrlist) ||
414 al_hreq.buflen > XATTR_LIST_MAX)
415 return -EINVAL;
416
417 /*
418 * Reject flags, only allow namespaces.
419 */
420 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
421 return -EINVAL;
422
423 dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
424 if (IS_ERR(dentry))
425 return PTR_ERR(dentry);
426
427 kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP);
428 if (!kbuf)
429 goto out_dput;
430
431 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
432 error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
433 al_hreq.flags, cursor);
434 if (error)
435 goto out_kfree;
436
437 if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
438 error = -EFAULT;
439
440 out_kfree:
441 kmem_free(kbuf);
442 out_dput:
443 dput(dentry);
444 return error;
445 }
446
447 int
448 xfs_attrmulti_attr_get(
449 struct inode *inode,
450 unsigned char *name,
451 unsigned char __user *ubuf,
452 __uint32_t *len,
453 __uint32_t flags)
454 {
455 unsigned char *kbuf;
456 int error = -EFAULT;
457
458 if (*len > XATTR_SIZE_MAX)
459 return -EINVAL;
460 kbuf = kmem_zalloc_large(*len, KM_SLEEP);
461 if (!kbuf)
462 return -ENOMEM;
463
464 error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
465 if (error)
466 goto out_kfree;
467
468 if (copy_to_user(ubuf, kbuf, *len))
469 error = -EFAULT;
470
471 out_kfree:
472 kmem_free(kbuf);
473 return error;
474 }
475
476 int
477 xfs_attrmulti_attr_set(
478 struct inode *inode,
479 unsigned char *name,
480 const unsigned char __user *ubuf,
481 __uint32_t len,
482 __uint32_t flags)
483 {
484 unsigned char *kbuf;
485
486 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
487 return -EPERM;
488 if (len > XATTR_SIZE_MAX)
489 return -EINVAL;
490
491 kbuf = memdup_user(ubuf, len);
492 if (IS_ERR(kbuf))
493 return PTR_ERR(kbuf);
494
495 return xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
496 }
497
498 int
499 xfs_attrmulti_attr_remove(
500 struct inode *inode,
501 unsigned char *name,
502 __uint32_t flags)
503 {
504 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
505 return -EPERM;
506 return xfs_attr_remove(XFS_I(inode), name, flags);
507 }
508
509 STATIC int
510 xfs_attrmulti_by_handle(
511 struct file *parfilp,
512 void __user *arg)
513 {
514 int error;
515 xfs_attr_multiop_t *ops;
516 xfs_fsop_attrmulti_handlereq_t am_hreq;
517 struct dentry *dentry;
518 unsigned int i, size;
519 unsigned char *attr_name;
520
521 if (!capable(CAP_SYS_ADMIN))
522 return -EPERM;
523 if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
524 return -EFAULT;
525
526 /* overflow check */
527 if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
528 return -E2BIG;
529
530 dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
531 if (IS_ERR(dentry))
532 return PTR_ERR(dentry);
533
534 error = -E2BIG;
535 size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
536 if (!size || size > 16 * PAGE_SIZE)
537 goto out_dput;
538
539 ops = memdup_user(am_hreq.ops, size);
540 if (IS_ERR(ops)) {
541 error = PTR_ERR(ops);
542 goto out_dput;
543 }
544
545 error = -ENOMEM;
546 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
547 if (!attr_name)
548 goto out_kfree_ops;
549
550 error = 0;
551 for (i = 0; i < am_hreq.opcount; i++) {
552 ops[i].am_error = strncpy_from_user((char *)attr_name,
553 ops[i].am_attrname, MAXNAMELEN);
554 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
555 error = -ERANGE;
556 if (ops[i].am_error < 0)
557 break;
558
559 switch (ops[i].am_opcode) {
560 case ATTR_OP_GET:
561 ops[i].am_error = xfs_attrmulti_attr_get(
562 dentry->d_inode, attr_name,
563 ops[i].am_attrvalue, &ops[i].am_length,
564 ops[i].am_flags);
565 break;
566 case ATTR_OP_SET:
567 ops[i].am_error = mnt_want_write_file(parfilp);
568 if (ops[i].am_error)
569 break;
570 ops[i].am_error = xfs_attrmulti_attr_set(
571 dentry->d_inode, attr_name,
572 ops[i].am_attrvalue, ops[i].am_length,
573 ops[i].am_flags);
574 mnt_drop_write_file(parfilp);
575 break;
576 case ATTR_OP_REMOVE:
577 ops[i].am_error = mnt_want_write_file(parfilp);
578 if (ops[i].am_error)
579 break;
580 ops[i].am_error = xfs_attrmulti_attr_remove(
581 dentry->d_inode, attr_name,
582 ops[i].am_flags);
583 mnt_drop_write_file(parfilp);
584 break;
585 default:
586 ops[i].am_error = -EINVAL;
587 }
588 }
589
590 if (copy_to_user(am_hreq.ops, ops, size))
591 error = -EFAULT;
592
593 kfree(attr_name);
594 out_kfree_ops:
595 kfree(ops);
596 out_dput:
597 dput(dentry);
598 return error;
599 }
600
601 int
602 xfs_ioc_space(
603 struct xfs_inode *ip,
604 struct inode *inode,
605 struct file *filp,
606 int ioflags,
607 unsigned int cmd,
608 xfs_flock64_t *bf)
609 {
610 struct iattr iattr;
611 enum xfs_prealloc_flags flags = 0;
612 uint iolock = XFS_IOLOCK_EXCL;
613 int error;
614
615 /*
616 * Only allow the sys admin to reserve space unless
617 * unwritten extents are enabled.
618 */
619 if (!xfs_sb_version_hasextflgbit(&ip->i_mount->m_sb) &&
620 !capable(CAP_SYS_ADMIN))
621 return -EPERM;
622
623 if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
624 return -EPERM;
625
626 if (!(filp->f_mode & FMODE_WRITE))
627 return -EBADF;
628
629 if (!S_ISREG(inode->i_mode))
630 return -EINVAL;
631
632 if (filp->f_flags & O_DSYNC)
633 flags |= XFS_PREALLOC_SYNC;
634 if (ioflags & XFS_IO_INVIS)
635 flags |= XFS_PREALLOC_INVISIBLE;
636
637 error = mnt_want_write_file(filp);
638 if (error)
639 return error;
640
641 xfs_ilock(ip, iolock);
642 error = xfs_break_layouts(inode, &iolock);
643 if (error)
644 goto out_unlock;
645
646 switch (bf->l_whence) {
647 case 0: /*SEEK_SET*/
648 break;
649 case 1: /*SEEK_CUR*/
650 bf->l_start += filp->f_pos;
651 break;
652 case 2: /*SEEK_END*/
653 bf->l_start += XFS_ISIZE(ip);
654 break;
655 default:
656 error = -EINVAL;
657 goto out_unlock;
658 }
659
660 /*
661 * length of <= 0 for resv/unresv/zero is invalid. length for
662 * alloc/free is ignored completely and we have no idea what userspace
663 * might have set it to, so set it to zero to allow range
664 * checks to pass.
665 */
666 switch (cmd) {
667 case XFS_IOC_ZERO_RANGE:
668 case XFS_IOC_RESVSP:
669 case XFS_IOC_RESVSP64:
670 case XFS_IOC_UNRESVSP:
671 case XFS_IOC_UNRESVSP64:
672 if (bf->l_len <= 0) {
673 error = -EINVAL;
674 goto out_unlock;
675 }
676 break;
677 default:
678 bf->l_len = 0;
679 break;
680 }
681
682 if (bf->l_start < 0 ||
683 bf->l_start > inode->i_sb->s_maxbytes ||
684 bf->l_start + bf->l_len < 0 ||
685 bf->l_start + bf->l_len >= inode->i_sb->s_maxbytes) {
686 error = -EINVAL;
687 goto out_unlock;
688 }
689
690 switch (cmd) {
691 case XFS_IOC_ZERO_RANGE:
692 flags |= XFS_PREALLOC_SET;
693 error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
694 break;
695 case XFS_IOC_RESVSP:
696 case XFS_IOC_RESVSP64:
697 flags |= XFS_PREALLOC_SET;
698 error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
699 XFS_BMAPI_PREALLOC);
700 break;
701 case XFS_IOC_UNRESVSP:
702 case XFS_IOC_UNRESVSP64:
703 error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
704 break;
705 case XFS_IOC_ALLOCSP:
706 case XFS_IOC_ALLOCSP64:
707 case XFS_IOC_FREESP:
708 case XFS_IOC_FREESP64:
709 flags |= XFS_PREALLOC_CLEAR;
710 if (bf->l_start > XFS_ISIZE(ip)) {
711 error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
712 bf->l_start - XFS_ISIZE(ip), 0);
713 if (error)
714 goto out_unlock;
715 }
716
717 iattr.ia_valid = ATTR_SIZE;
718 iattr.ia_size = bf->l_start;
719
720 error = xfs_setattr_size(ip, &iattr);
721 break;
722 default:
723 ASSERT(0);
724 error = -EINVAL;
725 }
726
727 if (error)
728 goto out_unlock;
729
730 error = xfs_update_prealloc_flags(ip, flags);
731
732 out_unlock:
733 xfs_iunlock(ip, iolock);
734 mnt_drop_write_file(filp);
735 return error;
736 }
737
738 STATIC int
739 xfs_ioc_bulkstat(
740 xfs_mount_t *mp,
741 unsigned int cmd,
742 void __user *arg)
743 {
744 xfs_fsop_bulkreq_t bulkreq;
745 int count; /* # of records returned */
746 xfs_ino_t inlast; /* last inode number */
747 int done;
748 int error;
749
750 /* done = 1 if there are more stats to get and if bulkstat */
751 /* should be called again (unused here, but used in dmapi) */
752
753 if (!capable(CAP_SYS_ADMIN))
754 return -EPERM;
755
756 if (XFS_FORCED_SHUTDOWN(mp))
757 return -EIO;
758
759 if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
760 return -EFAULT;
761
762 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
763 return -EFAULT;
764
765 if ((count = bulkreq.icount) <= 0)
766 return -EINVAL;
767
768 if (bulkreq.ubuffer == NULL)
769 return -EINVAL;
770
771 if (cmd == XFS_IOC_FSINUMBERS)
772 error = xfs_inumbers(mp, &inlast, &count,
773 bulkreq.ubuffer, xfs_inumbers_fmt);
774 else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
775 error = xfs_bulkstat_one(mp, inlast, bulkreq.ubuffer,
776 sizeof(xfs_bstat_t), NULL, &done);
777 else /* XFS_IOC_FSBULKSTAT */
778 error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
779 sizeof(xfs_bstat_t), bulkreq.ubuffer,
780 &done);
781
782 if (error)
783 return error;
784
785 if (bulkreq.ocount != NULL) {
786 if (copy_to_user(bulkreq.lastip, &inlast,
787 sizeof(xfs_ino_t)))
788 return -EFAULT;
789
790 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
791 return -EFAULT;
792 }
793
794 return 0;
795 }
796
797 STATIC int
798 xfs_ioc_fsgeometry_v1(
799 xfs_mount_t *mp,
800 void __user *arg)
801 {
802 xfs_fsop_geom_t fsgeo;
803 int error;
804
805 error = xfs_fs_geometry(mp, &fsgeo, 3);
806 if (error)
807 return error;
808
809 /*
810 * Caller should have passed an argument of type
811 * xfs_fsop_geom_v1_t. This is a proper subset of the
812 * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
813 */
814 if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
815 return -EFAULT;
816 return 0;
817 }
818
819 STATIC int
820 xfs_ioc_fsgeometry(
821 xfs_mount_t *mp,
822 void __user *arg)
823 {
824 xfs_fsop_geom_t fsgeo;
825 int error;
826
827 error = xfs_fs_geometry(mp, &fsgeo, 4);
828 if (error)
829 return error;
830
831 if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
832 return -EFAULT;
833 return 0;
834 }
835
836 /*
837 * Linux extended inode flags interface.
838 */
839
840 STATIC unsigned int
841 xfs_merge_ioc_xflags(
842 unsigned int flags,
843 unsigned int start)
844 {
845 unsigned int xflags = start;
846
847 if (flags & FS_IMMUTABLE_FL)
848 xflags |= XFS_XFLAG_IMMUTABLE;
849 else
850 xflags &= ~XFS_XFLAG_IMMUTABLE;
851 if (flags & FS_APPEND_FL)
852 xflags |= XFS_XFLAG_APPEND;
853 else
854 xflags &= ~XFS_XFLAG_APPEND;
855 if (flags & FS_SYNC_FL)
856 xflags |= XFS_XFLAG_SYNC;
857 else
858 xflags &= ~XFS_XFLAG_SYNC;
859 if (flags & FS_NOATIME_FL)
860 xflags |= XFS_XFLAG_NOATIME;
861 else
862 xflags &= ~XFS_XFLAG_NOATIME;
863 if (flags & FS_NODUMP_FL)
864 xflags |= XFS_XFLAG_NODUMP;
865 else
866 xflags &= ~XFS_XFLAG_NODUMP;
867
868 return xflags;
869 }
870
871 STATIC unsigned int
872 xfs_di2lxflags(
873 __uint16_t di_flags)
874 {
875 unsigned int flags = 0;
876
877 if (di_flags & XFS_DIFLAG_IMMUTABLE)
878 flags |= FS_IMMUTABLE_FL;
879 if (di_flags & XFS_DIFLAG_APPEND)
880 flags |= FS_APPEND_FL;
881 if (di_flags & XFS_DIFLAG_SYNC)
882 flags |= FS_SYNC_FL;
883 if (di_flags & XFS_DIFLAG_NOATIME)
884 flags |= FS_NOATIME_FL;
885 if (di_flags & XFS_DIFLAG_NODUMP)
886 flags |= FS_NODUMP_FL;
887 return flags;
888 }
889
890 STATIC int
891 xfs_ioc_fsgetxattr(
892 xfs_inode_t *ip,
893 int attr,
894 void __user *arg)
895 {
896 struct fsxattr fa;
897
898 memset(&fa, 0, sizeof(struct fsxattr));
899
900 xfs_ilock(ip, XFS_ILOCK_SHARED);
901 fa.fsx_xflags = xfs_ip2xflags(ip);
902 fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
903 fa.fsx_projid = xfs_get_projid(ip);
904
905 if (attr) {
906 if (ip->i_afp) {
907 if (ip->i_afp->if_flags & XFS_IFEXTENTS)
908 fa.fsx_nextents = ip->i_afp->if_bytes /
909 sizeof(xfs_bmbt_rec_t);
910 else
911 fa.fsx_nextents = ip->i_d.di_anextents;
912 } else
913 fa.fsx_nextents = 0;
914 } else {
915 if (ip->i_df.if_flags & XFS_IFEXTENTS)
916 fa.fsx_nextents = ip->i_df.if_bytes /
917 sizeof(xfs_bmbt_rec_t);
918 else
919 fa.fsx_nextents = ip->i_d.di_nextents;
920 }
921 xfs_iunlock(ip, XFS_ILOCK_SHARED);
922
923 if (copy_to_user(arg, &fa, sizeof(fa)))
924 return -EFAULT;
925 return 0;
926 }
927
928 STATIC void
929 xfs_set_diflags(
930 struct xfs_inode *ip,
931 unsigned int xflags)
932 {
933 unsigned int di_flags;
934
935 /* can't set PREALLOC this way, just preserve it */
936 di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
937 if (xflags & XFS_XFLAG_IMMUTABLE)
938 di_flags |= XFS_DIFLAG_IMMUTABLE;
939 if (xflags & XFS_XFLAG_APPEND)
940 di_flags |= XFS_DIFLAG_APPEND;
941 if (xflags & XFS_XFLAG_SYNC)
942 di_flags |= XFS_DIFLAG_SYNC;
943 if (xflags & XFS_XFLAG_NOATIME)
944 di_flags |= XFS_DIFLAG_NOATIME;
945 if (xflags & XFS_XFLAG_NODUMP)
946 di_flags |= XFS_DIFLAG_NODUMP;
947 if (xflags & XFS_XFLAG_NODEFRAG)
948 di_flags |= XFS_DIFLAG_NODEFRAG;
949 if (xflags & XFS_XFLAG_FILESTREAM)
950 di_flags |= XFS_DIFLAG_FILESTREAM;
951 if (S_ISDIR(ip->i_d.di_mode)) {
952 if (xflags & XFS_XFLAG_RTINHERIT)
953 di_flags |= XFS_DIFLAG_RTINHERIT;
954 if (xflags & XFS_XFLAG_NOSYMLINKS)
955 di_flags |= XFS_DIFLAG_NOSYMLINKS;
956 if (xflags & XFS_XFLAG_EXTSZINHERIT)
957 di_flags |= XFS_DIFLAG_EXTSZINHERIT;
958 if (xflags & XFS_XFLAG_PROJINHERIT)
959 di_flags |= XFS_DIFLAG_PROJINHERIT;
960 } else if (S_ISREG(ip->i_d.di_mode)) {
961 if (xflags & XFS_XFLAG_REALTIME)
962 di_flags |= XFS_DIFLAG_REALTIME;
963 if (xflags & XFS_XFLAG_EXTSIZE)
964 di_flags |= XFS_DIFLAG_EXTSIZE;
965 }
966
967 ip->i_d.di_flags = di_flags;
968 }
969
970 STATIC void
971 xfs_diflags_to_linux(
972 struct xfs_inode *ip)
973 {
974 struct inode *inode = VFS_I(ip);
975 unsigned int xflags = xfs_ip2xflags(ip);
976
977 if (xflags & XFS_XFLAG_IMMUTABLE)
978 inode->i_flags |= S_IMMUTABLE;
979 else
980 inode->i_flags &= ~S_IMMUTABLE;
981 if (xflags & XFS_XFLAG_APPEND)
982 inode->i_flags |= S_APPEND;
983 else
984 inode->i_flags &= ~S_APPEND;
985 if (xflags & XFS_XFLAG_SYNC)
986 inode->i_flags |= S_SYNC;
987 else
988 inode->i_flags &= ~S_SYNC;
989 if (xflags & XFS_XFLAG_NOATIME)
990 inode->i_flags |= S_NOATIME;
991 else
992 inode->i_flags &= ~S_NOATIME;
993 }
994
995 static int
996 xfs_ioctl_setattr_xflags(
997 struct xfs_trans *tp,
998 struct xfs_inode *ip,
999 struct fsxattr *fa)
1000 {
1001 struct xfs_mount *mp = ip->i_mount;
1002
1003 /* Can't change realtime flag if any extents are allocated. */
1004 if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1005 XFS_IS_REALTIME_INODE(ip) != (fa->fsx_xflags & XFS_XFLAG_REALTIME))
1006 return -EINVAL;
1007
1008 /* If realtime flag is set then must have realtime device */
1009 if (fa->fsx_xflags & XFS_XFLAG_REALTIME) {
1010 if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
1011 (ip->i_d.di_extsize % mp->m_sb.sb_rextsize))
1012 return -EINVAL;
1013 }
1014
1015 /*
1016 * Can't modify an immutable/append-only file unless
1017 * we have appropriate permission.
1018 */
1019 if (((ip->i_d.di_flags & (XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND)) ||
1020 (fa->fsx_xflags & (XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
1021 !capable(CAP_LINUX_IMMUTABLE))
1022 return -EPERM;
1023
1024 xfs_set_diflags(ip, fa->fsx_xflags);
1025 xfs_diflags_to_linux(ip);
1026 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1027 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1028 XFS_STATS_INC(xs_ig_attrchg);
1029 return 0;
1030 }
1031
1032 /*
1033 * Set up the transaction structure for the setattr operation, checking that we
1034 * have permission to do so. On success, return a clean transaction and the
1035 * inode locked exclusively ready for further operation specific checks. On
1036 * failure, return an error without modifying or locking the inode.
1037 */
1038 static struct xfs_trans *
1039 xfs_ioctl_setattr_get_trans(
1040 struct xfs_inode *ip)
1041 {
1042 struct xfs_mount *mp = ip->i_mount;
1043 struct xfs_trans *tp;
1044 int error;
1045
1046 if (mp->m_flags & XFS_MOUNT_RDONLY)
1047 return ERR_PTR(-EROFS);
1048 if (XFS_FORCED_SHUTDOWN(mp))
1049 return ERR_PTR(-EIO);
1050
1051 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
1052 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
1053 if (error)
1054 goto out_cancel;
1055
1056 xfs_ilock(ip, XFS_ILOCK_EXCL);
1057 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1058
1059 /*
1060 * CAP_FOWNER overrides the following restrictions:
1061 *
1062 * The user ID of the calling process must be equal to the file owner
1063 * ID, except in cases where the CAP_FSETID capability is applicable.
1064 */
1065 if (!inode_owner_or_capable(VFS_I(ip))) {
1066 error = -EPERM;
1067 goto out_cancel;
1068 }
1069
1070 if (mp->m_flags & XFS_MOUNT_WSYNC)
1071 xfs_trans_set_sync(tp);
1072
1073 return tp;
1074
1075 out_cancel:
1076 xfs_trans_cancel(tp, 0);
1077 return ERR_PTR(error);
1078 }
1079
1080 /*
1081 * extent size hint validation is somewhat cumbersome. Rules are:
1082 *
1083 * 1. extent size hint is only valid for directories and regular files
1084 * 2. XFS_XFLAG_EXTSIZE is only valid for regular files
1085 * 3. XFS_XFLAG_EXTSZINHERIT is only valid for directories.
1086 * 4. can only be changed on regular files if no extents are allocated
1087 * 5. can be changed on directories at any time
1088 * 6. extsize hint of 0 turns off hints, clears inode flags.
1089 * 7. Extent size must be a multiple of the appropriate block size.
1090 * 8. for non-realtime files, the extent size hint must be limited
1091 * to half the AG size to avoid alignment extending the extent beyond the
1092 * limits of the AG.
1093 */
1094 static int
1095 xfs_ioctl_setattr_check_extsize(
1096 struct xfs_inode *ip,
1097 struct fsxattr *fa)
1098 {
1099 struct xfs_mount *mp = ip->i_mount;
1100
1101 if ((fa->fsx_xflags & XFS_XFLAG_EXTSIZE) && !S_ISREG(ip->i_d.di_mode))
1102 return -EINVAL;
1103
1104 if ((fa->fsx_xflags & XFS_XFLAG_EXTSZINHERIT) &&
1105 !S_ISDIR(ip->i_d.di_mode))
1106 return -EINVAL;
1107
1108 if (S_ISREG(ip->i_d.di_mode) && ip->i_d.di_nextents &&
1109 ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) != fa->fsx_extsize))
1110 return -EINVAL;
1111
1112 if (fa->fsx_extsize != 0) {
1113 xfs_extlen_t size;
1114 xfs_fsblock_t extsize_fsb;
1115
1116 extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
1117 if (extsize_fsb > MAXEXTLEN)
1118 return -EINVAL;
1119
1120 if (XFS_IS_REALTIME_INODE(ip) ||
1121 (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
1122 size = mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog;
1123 } else {
1124 size = mp->m_sb.sb_blocksize;
1125 if (extsize_fsb > mp->m_sb.sb_agblocks / 2)
1126 return -EINVAL;
1127 }
1128
1129 if (fa->fsx_extsize % size)
1130 return -EINVAL;
1131 } else
1132 fa->fsx_xflags &= ~(XFS_XFLAG_EXTSIZE | XFS_XFLAG_EXTSZINHERIT);
1133
1134 return 0;
1135 }
1136
1137 static int
1138 xfs_ioctl_setattr_check_projid(
1139 struct xfs_inode *ip,
1140 struct fsxattr *fa)
1141 {
1142 /* Disallow 32bit project ids if projid32bit feature is not enabled. */
1143 if (fa->fsx_projid > (__uint16_t)-1 &&
1144 !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
1145 return -EINVAL;
1146
1147 /*
1148 * Project Quota ID state is only allowed to change from within the init
1149 * namespace. Enforce that restriction only if we are trying to change
1150 * the quota ID state. Everything else is allowed in user namespaces.
1151 */
1152 if (current_user_ns() == &init_user_ns)
1153 return 0;
1154
1155 if (xfs_get_projid(ip) != fa->fsx_projid)
1156 return -EINVAL;
1157 if ((fa->fsx_xflags & XFS_XFLAG_PROJINHERIT) !=
1158 (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT))
1159 return -EINVAL;
1160
1161 return 0;
1162 }
1163
1164 STATIC int
1165 xfs_ioctl_setattr(
1166 xfs_inode_t *ip,
1167 struct fsxattr *fa)
1168 {
1169 struct xfs_mount *mp = ip->i_mount;
1170 struct xfs_trans *tp;
1171 struct xfs_dquot *udqp = NULL;
1172 struct xfs_dquot *pdqp = NULL;
1173 struct xfs_dquot *olddquot = NULL;
1174 int code;
1175
1176 trace_xfs_ioctl_setattr(ip);
1177
1178 code = xfs_ioctl_setattr_check_projid(ip, fa);
1179 if (code)
1180 return code;
1181
1182 /*
1183 * If disk quotas is on, we make sure that the dquots do exist on disk,
1184 * before we start any other transactions. Trying to do this later
1185 * is messy. We don't care to take a readlock to look at the ids
1186 * in inode here, because we can't hold it across the trans_reserve.
1187 * If the IDs do change before we take the ilock, we're covered
1188 * because the i_*dquot fields will get updated anyway.
1189 */
1190 if (XFS_IS_QUOTA_ON(mp)) {
1191 code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
1192 ip->i_d.di_gid, fa->fsx_projid,
1193 XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
1194 if (code)
1195 return code;
1196 }
1197
1198 tp = xfs_ioctl_setattr_get_trans(ip);
1199 if (IS_ERR(tp)) {
1200 code = PTR_ERR(tp);
1201 goto error_free_dquots;
1202 }
1203
1204
1205 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp) &&
1206 xfs_get_projid(ip) != fa->fsx_projid) {
1207 code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL, pdqp,
1208 capable(CAP_FOWNER) ? XFS_QMOPT_FORCE_RES : 0);
1209 if (code) /* out of quota */
1210 goto error_trans_cancel;
1211 }
1212
1213 code = xfs_ioctl_setattr_check_extsize(ip, fa);
1214 if (code)
1215 goto error_trans_cancel;
1216
1217 code = xfs_ioctl_setattr_xflags(tp, ip, fa);
1218 if (code)
1219 goto error_trans_cancel;
1220
1221 /*
1222 * Change file ownership. Must be the owner or privileged. CAP_FSETID
1223 * overrides the following restrictions:
1224 *
1225 * The set-user-ID and set-group-ID bits of a file will be cleared upon
1226 * successful return from chown()
1227 */
1228
1229 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1230 !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))
1231 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
1232
1233 /* Change the ownerships and register project quota modifications */
1234 if (xfs_get_projid(ip) != fa->fsx_projid) {
1235 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
1236 olddquot = xfs_qm_vop_chown(tp, ip,
1237 &ip->i_pdquot, pdqp);
1238 }
1239 ASSERT(ip->i_d.di_version > 1);
1240 xfs_set_projid(ip, fa->fsx_projid);
1241 }
1242
1243 /*
1244 * Only set the extent size hint if we've already determined that the
1245 * extent size hint should be set on the inode. If no extent size flags
1246 * are set on the inode then unconditionally clear the extent size hint.
1247 */
1248 if (ip->i_d.di_flags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
1249 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1250 else
1251 ip->i_d.di_extsize = 0;
1252
1253 code = xfs_trans_commit(tp, 0);
1254
1255 /*
1256 * Release any dquot(s) the inode had kept before chown.
1257 */
1258 xfs_qm_dqrele(olddquot);
1259 xfs_qm_dqrele(udqp);
1260 xfs_qm_dqrele(pdqp);
1261
1262 return code;
1263
1264 error_trans_cancel:
1265 xfs_trans_cancel(tp, 0);
1266 error_free_dquots:
1267 xfs_qm_dqrele(udqp);
1268 xfs_qm_dqrele(pdqp);
1269 return code;
1270 }
1271
1272 STATIC int
1273 xfs_ioc_fssetxattr(
1274 xfs_inode_t *ip,
1275 struct file *filp,
1276 void __user *arg)
1277 {
1278 struct fsxattr fa;
1279 int error;
1280
1281 if (copy_from_user(&fa, arg, sizeof(fa)))
1282 return -EFAULT;
1283
1284 error = mnt_want_write_file(filp);
1285 if (error)
1286 return error;
1287 error = xfs_ioctl_setattr(ip, &fa);
1288 mnt_drop_write_file(filp);
1289 return error;
1290 }
1291
1292 STATIC int
1293 xfs_ioc_getxflags(
1294 xfs_inode_t *ip,
1295 void __user *arg)
1296 {
1297 unsigned int flags;
1298
1299 flags = xfs_di2lxflags(ip->i_d.di_flags);
1300 if (copy_to_user(arg, &flags, sizeof(flags)))
1301 return -EFAULT;
1302 return 0;
1303 }
1304
1305 STATIC int
1306 xfs_ioc_setxflags(
1307 struct xfs_inode *ip,
1308 struct file *filp,
1309 void __user *arg)
1310 {
1311 struct xfs_trans *tp;
1312 struct fsxattr fa;
1313 unsigned int flags;
1314 int error;
1315
1316 if (copy_from_user(&flags, arg, sizeof(flags)))
1317 return -EFAULT;
1318
1319 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
1320 FS_NOATIME_FL | FS_NODUMP_FL | \
1321 FS_SYNC_FL))
1322 return -EOPNOTSUPP;
1323
1324 fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
1325
1326 error = mnt_want_write_file(filp);
1327 if (error)
1328 return error;
1329
1330 tp = xfs_ioctl_setattr_get_trans(ip);
1331 if (IS_ERR(tp)) {
1332 error = PTR_ERR(tp);
1333 goto out_drop_write;
1334 }
1335
1336 error = xfs_ioctl_setattr_xflags(tp, ip, &fa);
1337 if (error) {
1338 xfs_trans_cancel(tp, 0);
1339 goto out_drop_write;
1340 }
1341
1342 error = xfs_trans_commit(tp, 0);
1343 out_drop_write:
1344 mnt_drop_write_file(filp);
1345 return error;
1346 }
1347
1348 STATIC int
1349 xfs_getbmap_format(void **ap, struct getbmapx *bmv, int *full)
1350 {
1351 struct getbmap __user *base = (struct getbmap __user *)*ap;
1352
1353 /* copy only getbmap portion (not getbmapx) */
1354 if (copy_to_user(base, bmv, sizeof(struct getbmap)))
1355 return -EFAULT;
1356
1357 *ap += sizeof(struct getbmap);
1358 return 0;
1359 }
1360
1361 STATIC int
1362 xfs_ioc_getbmap(
1363 struct xfs_inode *ip,
1364 int ioflags,
1365 unsigned int cmd,
1366 void __user *arg)
1367 {
1368 struct getbmapx bmx;
1369 int error;
1370
1371 if (copy_from_user(&bmx, arg, sizeof(struct getbmapx)))
1372 return -EFAULT;
1373
1374 if (bmx.bmv_count < 2)
1375 return -EINVAL;
1376
1377 bmx.bmv_iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1378 if (ioflags & XFS_IO_INVIS)
1379 bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
1380
1381 error = xfs_getbmap(ip, &bmx, xfs_getbmap_format,
1382 (__force struct getbmap *)arg+1);
1383 if (error)
1384 return error;
1385
1386 /* copy back header - only size of getbmap */
1387 if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
1388 return -EFAULT;
1389 return 0;
1390 }
1391
1392 STATIC int
1393 xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
1394 {
1395 struct getbmapx __user *base = (struct getbmapx __user *)*ap;
1396
1397 if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
1398 return -EFAULT;
1399
1400 *ap += sizeof(struct getbmapx);
1401 return 0;
1402 }
1403
1404 STATIC int
1405 xfs_ioc_getbmapx(
1406 struct xfs_inode *ip,
1407 void __user *arg)
1408 {
1409 struct getbmapx bmx;
1410 int error;
1411
1412 if (copy_from_user(&bmx, arg, sizeof(bmx)))
1413 return -EFAULT;
1414
1415 if (bmx.bmv_count < 2)
1416 return -EINVAL;
1417
1418 if (bmx.bmv_iflags & (~BMV_IF_VALID))
1419 return -EINVAL;
1420
1421 error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
1422 (__force struct getbmapx *)arg+1);
1423 if (error)
1424 return error;
1425
1426 /* copy back header */
1427 if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
1428 return -EFAULT;
1429
1430 return 0;
1431 }
1432
1433 int
1434 xfs_ioc_swapext(
1435 xfs_swapext_t *sxp)
1436 {
1437 xfs_inode_t *ip, *tip;
1438 struct fd f, tmp;
1439 int error = 0;
1440
1441 /* Pull information for the target fd */
1442 f = fdget((int)sxp->sx_fdtarget);
1443 if (!f.file) {
1444 error = -EINVAL;
1445 goto out;
1446 }
1447
1448 if (!(f.file->f_mode & FMODE_WRITE) ||
1449 !(f.file->f_mode & FMODE_READ) ||
1450 (f.file->f_flags & O_APPEND)) {
1451 error = -EBADF;
1452 goto out_put_file;
1453 }
1454
1455 tmp = fdget((int)sxp->sx_fdtmp);
1456 if (!tmp.file) {
1457 error = -EINVAL;
1458 goto out_put_file;
1459 }
1460
1461 if (!(tmp.file->f_mode & FMODE_WRITE) ||
1462 !(tmp.file->f_mode & FMODE_READ) ||
1463 (tmp.file->f_flags & O_APPEND)) {
1464 error = -EBADF;
1465 goto out_put_tmp_file;
1466 }
1467
1468 if (IS_SWAPFILE(file_inode(f.file)) ||
1469 IS_SWAPFILE(file_inode(tmp.file))) {
1470 error = -EINVAL;
1471 goto out_put_tmp_file;
1472 }
1473
1474 ip = XFS_I(file_inode(f.file));
1475 tip = XFS_I(file_inode(tmp.file));
1476
1477 if (ip->i_mount != tip->i_mount) {
1478 error = -EINVAL;
1479 goto out_put_tmp_file;
1480 }
1481
1482 if (ip->i_ino == tip->i_ino) {
1483 error = -EINVAL;
1484 goto out_put_tmp_file;
1485 }
1486
1487 if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1488 error = -EIO;
1489 goto out_put_tmp_file;
1490 }
1491
1492 error = xfs_swap_extents(ip, tip, sxp);
1493
1494 out_put_tmp_file:
1495 fdput(tmp);
1496 out_put_file:
1497 fdput(f);
1498 out:
1499 return error;
1500 }
1501
1502 /*
1503 * Note: some of the ioctl's return positive numbers as a
1504 * byte count indicating success, such as readlink_by_handle.
1505 * So we don't "sign flip" like most other routines. This means
1506 * true errors need to be returned as a negative value.
1507 */
1508 long
1509 xfs_file_ioctl(
1510 struct file *filp,
1511 unsigned int cmd,
1512 unsigned long p)
1513 {
1514 struct inode *inode = file_inode(filp);
1515 struct xfs_inode *ip = XFS_I(inode);
1516 struct xfs_mount *mp = ip->i_mount;
1517 void __user *arg = (void __user *)p;
1518 int ioflags = 0;
1519 int error;
1520
1521 if (filp->f_mode & FMODE_NOCMTIME)
1522 ioflags |= XFS_IO_INVIS;
1523
1524 trace_xfs_file_ioctl(ip);
1525
1526 switch (cmd) {
1527 case FITRIM:
1528 return xfs_ioc_trim(mp, arg);
1529 case XFS_IOC_ALLOCSP:
1530 case XFS_IOC_FREESP:
1531 case XFS_IOC_RESVSP:
1532 case XFS_IOC_UNRESVSP:
1533 case XFS_IOC_ALLOCSP64:
1534 case XFS_IOC_FREESP64:
1535 case XFS_IOC_RESVSP64:
1536 case XFS_IOC_UNRESVSP64:
1537 case XFS_IOC_ZERO_RANGE: {
1538 xfs_flock64_t bf;
1539
1540 if (copy_from_user(&bf, arg, sizeof(bf)))
1541 return -EFAULT;
1542 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
1543 }
1544 case XFS_IOC_DIOINFO: {
1545 struct dioattr da;
1546 xfs_buftarg_t *target =
1547 XFS_IS_REALTIME_INODE(ip) ?
1548 mp->m_rtdev_targp : mp->m_ddev_targp;
1549
1550 da.d_mem = da.d_miniosz = target->bt_logical_sectorsize;
1551 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);
1552
1553 if (copy_to_user(arg, &da, sizeof(da)))
1554 return -EFAULT;
1555 return 0;
1556 }
1557
1558 case XFS_IOC_FSBULKSTAT_SINGLE:
1559 case XFS_IOC_FSBULKSTAT:
1560 case XFS_IOC_FSINUMBERS:
1561 return xfs_ioc_bulkstat(mp, cmd, arg);
1562
1563 case XFS_IOC_FSGEOMETRY_V1:
1564 return xfs_ioc_fsgeometry_v1(mp, arg);
1565
1566 case XFS_IOC_FSGEOMETRY:
1567 return xfs_ioc_fsgeometry(mp, arg);
1568
1569 case XFS_IOC_GETVERSION:
1570 return put_user(inode->i_generation, (int __user *)arg);
1571
1572 case XFS_IOC_FSGETXATTR:
1573 return xfs_ioc_fsgetxattr(ip, 0, arg);
1574 case XFS_IOC_FSGETXATTRA:
1575 return xfs_ioc_fsgetxattr(ip, 1, arg);
1576 case XFS_IOC_FSSETXATTR:
1577 return xfs_ioc_fssetxattr(ip, filp, arg);
1578 case XFS_IOC_GETXFLAGS:
1579 return xfs_ioc_getxflags(ip, arg);
1580 case XFS_IOC_SETXFLAGS:
1581 return xfs_ioc_setxflags(ip, filp, arg);
1582
1583 case XFS_IOC_FSSETDM: {
1584 struct fsdmidata dmi;
1585
1586 if (copy_from_user(&dmi, arg, sizeof(dmi)))
1587 return -EFAULT;
1588
1589 error = mnt_want_write_file(filp);
1590 if (error)
1591 return error;
1592
1593 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
1594 dmi.fsd_dmstate);
1595 mnt_drop_write_file(filp);
1596 return error;
1597 }
1598
1599 case XFS_IOC_GETBMAP:
1600 case XFS_IOC_GETBMAPA:
1601 return xfs_ioc_getbmap(ip, ioflags, cmd, arg);
1602
1603 case XFS_IOC_GETBMAPX:
1604 return xfs_ioc_getbmapx(ip, arg);
1605
1606 case XFS_IOC_FD_TO_HANDLE:
1607 case XFS_IOC_PATH_TO_HANDLE:
1608 case XFS_IOC_PATH_TO_FSHANDLE: {
1609 xfs_fsop_handlereq_t hreq;
1610
1611 if (copy_from_user(&hreq, arg, sizeof(hreq)))
1612 return -EFAULT;
1613 return xfs_find_handle(cmd, &hreq);
1614 }
1615 case XFS_IOC_OPEN_BY_HANDLE: {
1616 xfs_fsop_handlereq_t hreq;
1617
1618 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1619 return -EFAULT;
1620 return xfs_open_by_handle(filp, &hreq);
1621 }
1622 case XFS_IOC_FSSETDM_BY_HANDLE:
1623 return xfs_fssetdm_by_handle(filp, arg);
1624
1625 case XFS_IOC_READLINK_BY_HANDLE: {
1626 xfs_fsop_handlereq_t hreq;
1627
1628 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
1629 return -EFAULT;
1630 return xfs_readlink_by_handle(filp, &hreq);
1631 }
1632 case XFS_IOC_ATTRLIST_BY_HANDLE:
1633 return xfs_attrlist_by_handle(filp, arg);
1634
1635 case XFS_IOC_ATTRMULTI_BY_HANDLE:
1636 return xfs_attrmulti_by_handle(filp, arg);
1637
1638 case XFS_IOC_SWAPEXT: {
1639 struct xfs_swapext sxp;
1640
1641 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
1642 return -EFAULT;
1643 error = mnt_want_write_file(filp);
1644 if (error)
1645 return error;
1646 error = xfs_ioc_swapext(&sxp);
1647 mnt_drop_write_file(filp);
1648 return error;
1649 }
1650
1651 case XFS_IOC_FSCOUNTS: {
1652 xfs_fsop_counts_t out;
1653
1654 error = xfs_fs_counts(mp, &out);
1655 if (error)
1656 return error;
1657
1658 if (copy_to_user(arg, &out, sizeof(out)))
1659 return -EFAULT;
1660 return 0;
1661 }
1662
1663 case XFS_IOC_SET_RESBLKS: {
1664 xfs_fsop_resblks_t inout;
1665 __uint64_t in;
1666
1667 if (!capable(CAP_SYS_ADMIN))
1668 return -EPERM;
1669
1670 if (mp->m_flags & XFS_MOUNT_RDONLY)
1671 return -EROFS;
1672
1673 if (copy_from_user(&inout, arg, sizeof(inout)))
1674 return -EFAULT;
1675
1676 error = mnt_want_write_file(filp);
1677 if (error)
1678 return error;
1679
1680 /* input parameter is passed in resblks field of structure */
1681 in = inout.resblks;
1682 error = xfs_reserve_blocks(mp, &in, &inout);
1683 mnt_drop_write_file(filp);
1684 if (error)
1685 return error;
1686
1687 if (copy_to_user(arg, &inout, sizeof(inout)))
1688 return -EFAULT;
1689 return 0;
1690 }
1691
1692 case XFS_IOC_GET_RESBLKS: {
1693 xfs_fsop_resblks_t out;
1694
1695 if (!capable(CAP_SYS_ADMIN))
1696 return -EPERM;
1697
1698 error = xfs_reserve_blocks(mp, NULL, &out);
1699 if (error)
1700 return error;
1701
1702 if (copy_to_user(arg, &out, sizeof(out)))
1703 return -EFAULT;
1704
1705 return 0;
1706 }
1707
1708 case XFS_IOC_FSGROWFSDATA: {
1709 xfs_growfs_data_t in;
1710
1711 if (copy_from_user(&in, arg, sizeof(in)))
1712 return -EFAULT;
1713
1714 error = mnt_want_write_file(filp);
1715 if (error)
1716 return error;
1717 error = xfs_growfs_data(mp, &in);
1718 mnt_drop_write_file(filp);
1719 return error;
1720 }
1721
1722 case XFS_IOC_FSGROWFSLOG: {
1723 xfs_growfs_log_t in;
1724
1725 if (copy_from_user(&in, arg, sizeof(in)))
1726 return -EFAULT;
1727
1728 error = mnt_want_write_file(filp);
1729 if (error)
1730 return error;
1731 error = xfs_growfs_log(mp, &in);
1732 mnt_drop_write_file(filp);
1733 return error;
1734 }
1735
1736 case XFS_IOC_FSGROWFSRT: {
1737 xfs_growfs_rt_t in;
1738
1739 if (copy_from_user(&in, arg, sizeof(in)))
1740 return -EFAULT;
1741
1742 error = mnt_want_write_file(filp);
1743 if (error)
1744 return error;
1745 error = xfs_growfs_rt(mp, &in);
1746 mnt_drop_write_file(filp);
1747 return error;
1748 }
1749
1750 case XFS_IOC_GOINGDOWN: {
1751 __uint32_t in;
1752
1753 if (!capable(CAP_SYS_ADMIN))
1754 return -EPERM;
1755
1756 if (get_user(in, (__uint32_t __user *)arg))
1757 return -EFAULT;
1758
1759 return xfs_fs_goingdown(mp, in);
1760 }
1761
1762 case XFS_IOC_ERROR_INJECTION: {
1763 xfs_error_injection_t in;
1764
1765 if (!capable(CAP_SYS_ADMIN))
1766 return -EPERM;
1767
1768 if (copy_from_user(&in, arg, sizeof(in)))
1769 return -EFAULT;
1770
1771 return xfs_errortag_add(in.errtag, mp);
1772 }
1773
1774 case XFS_IOC_ERROR_CLEARALL:
1775 if (!capable(CAP_SYS_ADMIN))
1776 return -EPERM;
1777
1778 return xfs_errortag_clearall(mp, 1);
1779
1780 case XFS_IOC_FREE_EOFBLOCKS: {
1781 struct xfs_fs_eofblocks eofb;
1782 struct xfs_eofblocks keofb;
1783
1784 if (!capable(CAP_SYS_ADMIN))
1785 return -EPERM;
1786
1787 if (mp->m_flags & XFS_MOUNT_RDONLY)
1788 return -EROFS;
1789
1790 if (copy_from_user(&eofb, arg, sizeof(eofb)))
1791 return -EFAULT;
1792
1793 error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
1794 if (error)
1795 return error;
1796
1797 return xfs_icache_free_eofblocks(mp, &keofb);
1798 }
1799
1800 default:
1801 return -ENOTTY;
1802 }
1803 }
Linux kernel - Deliverables
This page took 0.10155 seconds and 5 git commands to generate.