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