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(xfs_find_bdev_for_inode(VFS_I(ip)), 1107 sb->s_blocksize)) 1108 return -EINVAL; 1109 } 1110 1111 /* If the DAX state is not changing, we have nothing to do here. */ 1112 if ((fa->fsx_xflags & FS_XFLAG_DAX) && IS_DAX(inode)) 1113 return 0; 1114 if (!(fa->fsx_xflags & FS_XFLAG_DAX) && !IS_DAX(inode)) 1115 return 0; 1116 1117 /* lock, flush and invalidate mapping in preparation for flag change */ 1118 xfs_ilock(ip, XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL); 1119 error = filemap_write_and_wait(inode->i_mapping); 1120 if (error) 1121 goto out_unlock; 1122 error = invalidate_inode_pages2(inode->i_mapping); 1123 if (error) 1124 goto out_unlock; 1125 1126 *join_flags = XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL; 1127 return 0; 1128 1129 out_unlock: 1130 xfs_iunlock(ip, XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL); 1131 return error; 1132 1133 } 1134 1135 /* 1136 * Set up the transaction structure for the setattr operation, checking that we 1137 * have permission to do so. On success, return a clean transaction and the 1138 * inode locked exclusively ready for further operation specific checks. On 1139 * failure, return an error without modifying or locking the inode. 1140 * 1141 * The inode might already be IO locked on call. If this is the case, it is 1142 * indicated in @join_flags and we take full responsibility for ensuring they 1143 * are unlocked from now on. Hence if we have an error here, we still have to 1144 * unlock them. Otherwise, once they are joined to the transaction, they will 1145 * be unlocked on commit/cancel. 1146 */ 1147 static struct xfs_trans * 1148 xfs_ioctl_setattr_get_trans( 1149 struct xfs_inode *ip, 1150 int join_flags) 1151 { 1152 struct xfs_mount *mp = ip->i_mount; 1153 struct xfs_trans *tp; 1154 int error = -EROFS; 1155 1156 if (mp->m_flags & XFS_MOUNT_RDONLY) 1157 goto out_unlock; 1158 error = -EIO; 1159 if (XFS_FORCED_SHUTDOWN(mp)) 1160 goto out_unlock; 1161 1162 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp); 1163 if (error) 1164 return ERR_PTR(error); 1165 1166 xfs_ilock(ip, XFS_ILOCK_EXCL); 1167 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | join_flags); 1168 join_flags = 0; 1169 1170 /* 1171 * CAP_FOWNER overrides the following restrictions: 1172 * 1173 * The user ID of the calling process must be equal to the file owner 1174 * ID, except in cases where the CAP_FSETID capability is applicable. 1175 */ 1176 if (!inode_owner_or_capable(VFS_I(ip))) { 1177 error = -EPERM; 1178 goto out_cancel; 1179 } 1180 1181 if (mp->m_flags & XFS_MOUNT_WSYNC) 1182 xfs_trans_set_sync(tp); 1183 1184 return tp; 1185 1186 out_cancel: 1187 xfs_trans_cancel(tp); 1188 out_unlock: 1189 if (join_flags) 1190 xfs_iunlock(ip, join_flags); 1191 return ERR_PTR(error); 1192 } 1193 1194 /* 1195 * extent size hint validation is somewhat cumbersome. Rules are: 1196 * 1197 * 1. extent size hint is only valid for directories and regular files 1198 * 2. FS_XFLAG_EXTSIZE is only valid for regular files 1199 * 3. FS_XFLAG_EXTSZINHERIT is only valid for directories. 1200 * 4. can only be changed on regular files if no extents are allocated 1201 * 5. can be changed on directories at any time 1202 * 6. extsize hint of 0 turns off hints, clears inode flags. 1203 * 7. Extent size must be a multiple of the appropriate block size. 1204 * 8. for non-realtime files, the extent size hint must be limited 1205 * to half the AG size to avoid alignment extending the extent beyond the 1206 * limits of the AG. 1207 * 1208 * Please keep this function in sync with xfs_scrub_inode_extsize. 1209 */ 1210 static int 1211 xfs_ioctl_setattr_check_extsize( 1212 struct xfs_inode *ip, 1213 struct fsxattr *fa) 1214 { 1215 struct xfs_mount *mp = ip->i_mount; 1216 1217 if ((fa->fsx_xflags & FS_XFLAG_EXTSIZE) && !S_ISREG(VFS_I(ip)->i_mode)) 1218 return -EINVAL; 1219 1220 if ((fa->fsx_xflags & FS_XFLAG_EXTSZINHERIT) && 1221 !S_ISDIR(VFS_I(ip)->i_mode)) 1222 return -EINVAL; 1223 1224 if (S_ISREG(VFS_I(ip)->i_mode) && ip->i_d.di_nextents && 1225 ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) != fa->fsx_extsize)) 1226 return -EINVAL; 1227 1228 if (fa->fsx_extsize != 0) { 1229 xfs_extlen_t size; 1230 xfs_fsblock_t extsize_fsb; 1231 1232 extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize); 1233 if (extsize_fsb > MAXEXTLEN) 1234 return -EINVAL; 1235 1236 if (XFS_IS_REALTIME_INODE(ip) || 1237 (fa->fsx_xflags & FS_XFLAG_REALTIME)) { 1238 size = mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog; 1239 } else { 1240 size = mp->m_sb.sb_blocksize; 1241 if (extsize_fsb > mp->m_sb.sb_agblocks / 2) 1242 return -EINVAL; 1243 } 1244 1245 if (fa->fsx_extsize % size) 1246 return -EINVAL; 1247 } else 1248 fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE | FS_XFLAG_EXTSZINHERIT); 1249 1250 return 0; 1251 } 1252 1253 /* 1254 * CoW extent size hint validation rules are: 1255 * 1256 * 1. CoW extent size hint can only be set if reflink is enabled on the fs. 1257 * The inode does not have to have any shared blocks, but it must be a v3. 1258 * 2. FS_XFLAG_COWEXTSIZE is only valid for directories and regular files; 1259 * for a directory, the hint is propagated to new files. 1260 * 3. Can be changed on files & directories at any time. 1261 * 4. CoW extsize hint of 0 turns off hints, clears inode flags. 1262 * 5. Extent size must be a multiple of the appropriate block size. 1263 * 6. The extent size hint must be limited to half the AG size to avoid 1264 * alignment extending the extent beyond the limits of the AG. 1265 * 1266 * Please keep this function in sync with xfs_scrub_inode_cowextsize. 1267 */ 1268 static int 1269 xfs_ioctl_setattr_check_cowextsize( 1270 struct xfs_inode *ip, 1271 struct fsxattr *fa) 1272 { 1273 struct xfs_mount *mp = ip->i_mount; 1274 1275 if (!(fa->fsx_xflags & FS_XFLAG_COWEXTSIZE)) 1276 return 0; 1277 1278 if (!xfs_sb_version_hasreflink(&ip->i_mount->m_sb) || 1279 ip->i_d.di_version != 3) 1280 return -EINVAL; 1281 1282 if (!S_ISREG(VFS_I(ip)->i_mode) && !S_ISDIR(VFS_I(ip)->i_mode)) 1283 return -EINVAL; 1284 1285 if (fa->fsx_cowextsize != 0) { 1286 xfs_extlen_t size; 1287 xfs_fsblock_t cowextsize_fsb; 1288 1289 cowextsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_cowextsize); 1290 if (cowextsize_fsb > MAXEXTLEN) 1291 return -EINVAL; 1292 1293 size = mp->m_sb.sb_blocksize; 1294 if (cowextsize_fsb > mp->m_sb.sb_agblocks / 2) 1295 return -EINVAL; 1296 1297 if (fa->fsx_cowextsize % size) 1298 return -EINVAL; 1299 } else 1300 fa->fsx_xflags &= ~FS_XFLAG_COWEXTSIZE; 1301 1302 return 0; 1303 } 1304 1305 static int 1306 xfs_ioctl_setattr_check_projid( 1307 struct xfs_inode *ip, 1308 struct fsxattr *fa) 1309 { 1310 /* Disallow 32bit project ids if projid32bit feature is not enabled. */ 1311 if (fa->fsx_projid > (uint16_t)-1 && 1312 !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb)) 1313 return -EINVAL; 1314 1315 /* 1316 * Project Quota ID state is only allowed to change from within the init 1317 * namespace. Enforce that restriction only if we are trying to change 1318 * the quota ID state. Everything else is allowed in user namespaces. 1319 */ 1320 if (current_user_ns() == &init_user_ns) 1321 return 0; 1322 1323 if (xfs_get_projid(ip) != fa->fsx_projid) 1324 return -EINVAL; 1325 if ((fa->fsx_xflags & FS_XFLAG_PROJINHERIT) != 1326 (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)) 1327 return -EINVAL; 1328 1329 return 0; 1330 } 1331 1332 STATIC int 1333 xfs_ioctl_setattr( 1334 xfs_inode_t *ip, 1335 struct fsxattr *fa) 1336 { 1337 struct xfs_mount *mp = ip->i_mount; 1338 struct xfs_trans *tp; 1339 struct xfs_dquot *udqp = NULL; 1340 struct xfs_dquot *pdqp = NULL; 1341 struct xfs_dquot *olddquot = NULL; 1342 int code; 1343 int join_flags = 0; 1344 1345 trace_xfs_ioctl_setattr(ip); 1346 1347 code = xfs_ioctl_setattr_check_projid(ip, fa); 1348 if (code) 1349 return code; 1350 1351 /* 1352 * If disk quotas is on, we make sure that the dquots do exist on disk, 1353 * before we start any other transactions. Trying to do this later 1354 * is messy. We don't care to take a readlock to look at the ids 1355 * in inode here, because we can't hold it across the trans_reserve. 1356 * If the IDs do change before we take the ilock, we're covered 1357 * because the i_*dquot fields will get updated anyway. 1358 */ 1359 if (XFS_IS_QUOTA_ON(mp)) { 1360 code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid, 1361 ip->i_d.di_gid, fa->fsx_projid, 1362 XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp); 1363 if (code) 1364 return code; 1365 } 1366 1367 /* 1368 * Changing DAX config may require inode locking for mapping 1369 * invalidation. These need to be held all the way to transaction commit 1370 * or cancel time, so need to be passed through to 1371 * xfs_ioctl_setattr_get_trans() so it can apply them to the join call 1372 * appropriately. 1373 */ 1374 code = xfs_ioctl_setattr_dax_invalidate(ip, fa, &join_flags); 1375 if (code) 1376 goto error_free_dquots; 1377 1378 tp = xfs_ioctl_setattr_get_trans(ip, join_flags); 1379 if (IS_ERR(tp)) { 1380 code = PTR_ERR(tp); 1381 goto error_free_dquots; 1382 } 1383 1384 1385 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp) && 1386 xfs_get_projid(ip) != fa->fsx_projid) { 1387 code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL, pdqp, 1388 capable(CAP_FOWNER) ? XFS_QMOPT_FORCE_RES : 0); 1389 if (code) /* out of quota */ 1390 goto error_trans_cancel; 1391 } 1392 1393 code = xfs_ioctl_setattr_check_extsize(ip, fa); 1394 if (code) 1395 goto error_trans_cancel; 1396 1397 code = xfs_ioctl_setattr_check_cowextsize(ip, fa); 1398 if (code) 1399 goto error_trans_cancel; 1400 1401 code = xfs_ioctl_setattr_xflags(tp, ip, fa); 1402 if (code) 1403 goto error_trans_cancel; 1404 1405 /* 1406 * Change file ownership. Must be the owner or privileged. CAP_FSETID 1407 * overrides the following restrictions: 1408 * 1409 * The set-user-ID and set-group-ID bits of a file will be cleared upon 1410 * successful return from chown() 1411 */ 1412 1413 if ((VFS_I(ip)->i_mode & (S_ISUID|S_ISGID)) && 1414 !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID)) 1415 VFS_I(ip)->i_mode &= ~(S_ISUID|S_ISGID); 1416 1417 /* Change the ownerships and register project quota modifications */ 1418 if (xfs_get_projid(ip) != fa->fsx_projid) { 1419 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) { 1420 olddquot = xfs_qm_vop_chown(tp, ip, 1421 &ip->i_pdquot, pdqp); 1422 } 1423 ASSERT(ip->i_d.di_version > 1); 1424 xfs_set_projid(ip, fa->fsx_projid); 1425 } 1426 1427 /* 1428 * Only set the extent size hint if we've already determined that the 1429 * extent size hint should be set on the inode. If no extent size flags 1430 * are set on the inode then unconditionally clear the extent size hint. 1431 */ 1432 if (ip->i_d.di_flags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT)) 1433 ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog; 1434 else 1435 ip->i_d.di_extsize = 0; 1436 if (ip->i_d.di_version == 3 && 1437 (ip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE)) 1438 ip->i_d.di_cowextsize = fa->fsx_cowextsize >> 1439 mp->m_sb.sb_blocklog; 1440 else 1441 ip->i_d.di_cowextsize = 0; 1442 1443 code = xfs_trans_commit(tp); 1444 1445 /* 1446 * Release any dquot(s) the inode had kept before chown. 1447 */ 1448 xfs_qm_dqrele(olddquot); 1449 xfs_qm_dqrele(udqp); 1450 xfs_qm_dqrele(pdqp); 1451 1452 return code; 1453 1454 error_trans_cancel: 1455 xfs_trans_cancel(tp); 1456 error_free_dquots: 1457 xfs_qm_dqrele(udqp); 1458 xfs_qm_dqrele(pdqp); 1459 return code; 1460 } 1461 1462 STATIC int 1463 xfs_ioc_fssetxattr( 1464 xfs_inode_t *ip, 1465 struct file *filp, 1466 void __user *arg) 1467 { 1468 struct fsxattr fa; 1469 int error; 1470 1471 if (copy_from_user(&fa, arg, sizeof(fa))) 1472 return -EFAULT; 1473 1474 error = mnt_want_write_file(filp); 1475 if (error) 1476 return error; 1477 error = xfs_ioctl_setattr(ip, &fa); 1478 mnt_drop_write_file(filp); 1479 return error; 1480 } 1481 1482 STATIC int 1483 xfs_ioc_getxflags( 1484 xfs_inode_t *ip, 1485 void __user *arg) 1486 { 1487 unsigned int flags; 1488 1489 flags = xfs_di2lxflags(ip->i_d.di_flags); 1490 if (copy_to_user(arg, &flags, sizeof(flags))) 1491 return -EFAULT; 1492 return 0; 1493 } 1494 1495 STATIC int 1496 xfs_ioc_setxflags( 1497 struct xfs_inode *ip, 1498 struct file *filp, 1499 void __user *arg) 1500 { 1501 struct xfs_trans *tp; 1502 struct fsxattr fa; 1503 unsigned int flags; 1504 int join_flags = 0; 1505 int error; 1506 1507 if (copy_from_user(&flags, arg, sizeof(flags))) 1508 return -EFAULT; 1509 1510 if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \ 1511 FS_NOATIME_FL | FS_NODUMP_FL | \ 1512 FS_SYNC_FL)) 1513 return -EOPNOTSUPP; 1514 1515 fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip)); 1516 1517 error = mnt_want_write_file(filp); 1518 if (error) 1519 return error; 1520 1521 /* 1522 * Changing DAX config may require inode locking for mapping 1523 * invalidation. These need to be held all the way to transaction commit 1524 * or cancel time, so need to be passed through to 1525 * xfs_ioctl_setattr_get_trans() so it can apply them to the join call 1526 * appropriately. 1527 */ 1528 error = xfs_ioctl_setattr_dax_invalidate(ip, &fa, &join_flags); 1529 if (error) 1530 goto out_drop_write; 1531 1532 tp = xfs_ioctl_setattr_get_trans(ip, join_flags); 1533 if (IS_ERR(tp)) { 1534 error = PTR_ERR(tp); 1535 goto out_drop_write; 1536 } 1537 1538 error = xfs_ioctl_setattr_xflags(tp, ip, &fa); 1539 if (error) { 1540 xfs_trans_cancel(tp); 1541 goto out_drop_write; 1542 } 1543 1544 error = xfs_trans_commit(tp); 1545 out_drop_write: 1546 mnt_drop_write_file(filp); 1547 return error; 1548 } 1549 1550 static bool 1551 xfs_getbmap_format( 1552 struct kgetbmap *p, 1553 struct getbmapx __user *u, 1554 size_t recsize) 1555 { 1556 if (put_user(p->bmv_offset, &u->bmv_offset) || 1557 put_user(p->bmv_block, &u->bmv_block) || 1558 put_user(p->bmv_length, &u->bmv_length) || 1559 put_user(0, &u->bmv_count) || 1560 put_user(0, &u->bmv_entries)) 1561 return false; 1562 if (recsize < sizeof(struct getbmapx)) 1563 return true; 1564 if (put_user(0, &u->bmv_iflags) || 1565 put_user(p->bmv_oflags, &u->bmv_oflags) || 1566 put_user(0, &u->bmv_unused1) || 1567 put_user(0, &u->bmv_unused2)) 1568 return false; 1569 return true; 1570 } 1571 1572 STATIC int 1573 xfs_ioc_getbmap( 1574 struct file *file, 1575 unsigned int cmd, 1576 void __user *arg) 1577 { 1578 struct getbmapx bmx = { 0 }; 1579 struct kgetbmap *buf; 1580 size_t recsize; 1581 int error, i; 1582 1583 switch (cmd) { 1584 case XFS_IOC_GETBMAPA: 1585 bmx.bmv_iflags = BMV_IF_ATTRFORK; 1586 /*FALLTHRU*/ 1587 case XFS_IOC_GETBMAP: 1588 if (file->f_mode & FMODE_NOCMTIME) 1589 bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ; 1590 /* struct getbmap is a strict subset of struct getbmapx. */ 1591 recsize = sizeof(struct getbmap); 1592 break; 1593 case XFS_IOC_GETBMAPX: 1594 recsize = sizeof(struct getbmapx); 1595 break; 1596 default: 1597 return -EINVAL; 1598 } 1599 1600 if (copy_from_user(&bmx, arg, recsize)) 1601 return -EFAULT; 1602 1603 if (bmx.bmv_count < 2) 1604 return -EINVAL; 1605 if (bmx.bmv_count > ULONG_MAX / recsize) 1606 return -ENOMEM; 1607 1608 buf = kmem_zalloc_large(bmx.bmv_count * sizeof(*buf), 0); 1609 if (!buf) 1610 return -ENOMEM; 1611 1612 error = xfs_getbmap(XFS_I(file_inode(file)), &bmx, buf); 1613 if (error) 1614 goto out_free_buf; 1615 1616 error = -EFAULT; 1617 if (copy_to_user(arg, &bmx, recsize)) 1618 goto out_free_buf; 1619 arg += recsize; 1620 1621 for (i = 0; i < bmx.bmv_entries; i++) { 1622 if (!xfs_getbmap_format(buf + i, arg, recsize)) 1623 goto out_free_buf; 1624 arg += recsize; 1625 } 1626 1627 error = 0; 1628 out_free_buf: 1629 kmem_free(buf); 1630 return 0; 1631 } 1632 1633 struct getfsmap_info { 1634 struct xfs_mount *mp; 1635 struct fsmap_head __user *data; 1636 unsigned int idx; 1637 __u32 last_flags; 1638 }; 1639 1640 STATIC int 1641 xfs_getfsmap_format(struct xfs_fsmap *xfm, void *priv) 1642 { 1643 struct getfsmap_info *info = priv; 1644 struct fsmap fm; 1645 1646 trace_xfs_getfsmap_mapping(info->mp, xfm); 1647 1648 info->last_flags = xfm->fmr_flags; 1649 xfs_fsmap_from_internal(&fm, xfm); 1650 if (copy_to_user(&info->data->fmh_recs[info->idx++], &fm, 1651 sizeof(struct fsmap))) 1652 return -EFAULT; 1653 1654 return 0; 1655 } 1656 1657 STATIC int 1658 xfs_ioc_getfsmap( 1659 struct xfs_inode *ip, 1660 struct fsmap_head __user *arg) 1661 { 1662 struct getfsmap_info info = { NULL }; 1663 struct xfs_fsmap_head xhead = {0}; 1664 struct fsmap_head head; 1665 bool aborted = false; 1666 int error; 1667 1668 if (copy_from_user(&head, arg, sizeof(struct fsmap_head))) 1669 return -EFAULT; 1670 if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) || 1671 memchr_inv(head.fmh_keys[0].fmr_reserved, 0, 1672 sizeof(head.fmh_keys[0].fmr_reserved)) || 1673 memchr_inv(head.fmh_keys[1].fmr_reserved, 0, 1674 sizeof(head.fmh_keys[1].fmr_reserved))) 1675 return -EINVAL; 1676 1677 xhead.fmh_iflags = head.fmh_iflags; 1678 xhead.fmh_count = head.fmh_count; 1679 xfs_fsmap_to_internal(&xhead.fmh_keys[0], &head.fmh_keys[0]); 1680 xfs_fsmap_to_internal(&xhead.fmh_keys[1], &head.fmh_keys[1]); 1681 1682 trace_xfs_getfsmap_low_key(ip->i_mount, &xhead.fmh_keys[0]); 1683 trace_xfs_getfsmap_high_key(ip->i_mount, &xhead.fmh_keys[1]); 1684 1685 info.mp = ip->i_mount; 1686 info.data = arg; 1687 error = xfs_getfsmap(ip->i_mount, &xhead, xfs_getfsmap_format, &info); 1688 if (error == XFS_BTREE_QUERY_RANGE_ABORT) { 1689 error = 0; 1690 aborted = true; 1691 } else if (error) 1692 return error; 1693 1694 /* If we didn't abort, set the "last" flag in the last fmx */ 1695 if (!aborted && info.idx) { 1696 info.last_flags |= FMR_OF_LAST; 1697 if (copy_to_user(&info.data->fmh_recs[info.idx - 1].fmr_flags, 1698 &info.last_flags, sizeof(info.last_flags))) 1699 return -EFAULT; 1700 } 1701 1702 /* copy back header */ 1703 head.fmh_entries = xhead.fmh_entries; 1704 head.fmh_oflags = xhead.fmh_oflags; 1705 if (copy_to_user(arg, &head, sizeof(struct fsmap_head))) 1706 return -EFAULT; 1707 1708 return 0; 1709 } 1710 1711 STATIC int 1712 xfs_ioc_scrub_metadata( 1713 struct xfs_inode *ip, 1714 void __user *arg) 1715 { 1716 struct xfs_scrub_metadata scrub; 1717 int error; 1718 1719 if (!capable(CAP_SYS_ADMIN)) 1720 return -EPERM; 1721 1722 if (copy_from_user(&scrub, arg, sizeof(scrub))) 1723 return -EFAULT; 1724 1725 error = xfs_scrub_metadata(ip, &scrub); 1726 if (error) 1727 return error; 1728 1729 if (copy_to_user(arg, &scrub, sizeof(scrub))) 1730 return -EFAULT; 1731 1732 return 0; 1733 } 1734 1735 int 1736 xfs_ioc_swapext( 1737 xfs_swapext_t *sxp) 1738 { 1739 xfs_inode_t *ip, *tip; 1740 struct fd f, tmp; 1741 int error = 0; 1742 1743 /* Pull information for the target fd */ 1744 f = fdget((int)sxp->sx_fdtarget); 1745 if (!f.file) { 1746 error = -EINVAL; 1747 goto out; 1748 } 1749 1750 if (!(f.file->f_mode & FMODE_WRITE) || 1751 !(f.file->f_mode & FMODE_READ) || 1752 (f.file->f_flags & O_APPEND)) { 1753 error = -EBADF; 1754 goto out_put_file; 1755 } 1756 1757 tmp = fdget((int)sxp->sx_fdtmp); 1758 if (!tmp.file) { 1759 error = -EINVAL; 1760 goto out_put_file; 1761 } 1762 1763 if (!(tmp.file->f_mode & FMODE_WRITE) || 1764 !(tmp.file->f_mode & FMODE_READ) || 1765 (tmp.file->f_flags & O_APPEND)) { 1766 error = -EBADF; 1767 goto out_put_tmp_file; 1768 } 1769 1770 if (IS_SWAPFILE(file_inode(f.file)) || 1771 IS_SWAPFILE(file_inode(tmp.file))) { 1772 error = -EINVAL; 1773 goto out_put_tmp_file; 1774 } 1775 1776 /* 1777 * We need to ensure that the fds passed in point to XFS inodes 1778 * before we cast and access them as XFS structures as we have no 1779 * control over what the user passes us here. 1780 */ 1781 if (f.file->f_op != &xfs_file_operations || 1782 tmp.file->f_op != &xfs_file_operations) { 1783 error = -EINVAL; 1784 goto out_put_tmp_file; 1785 } 1786 1787 ip = XFS_I(file_inode(f.file)); 1788 tip = XFS_I(file_inode(tmp.file)); 1789 1790 if (ip->i_mount != tip->i_mount) { 1791 error = -EINVAL; 1792 goto out_put_tmp_file; 1793 } 1794 1795 if (ip->i_ino == tip->i_ino) { 1796 error = -EINVAL; 1797 goto out_put_tmp_file; 1798 } 1799 1800 if (XFS_FORCED_SHUTDOWN(ip->i_mount)) { 1801 error = -EIO; 1802 goto out_put_tmp_file; 1803 } 1804 1805 error = xfs_swap_extents(ip, tip, sxp); 1806 1807 out_put_tmp_file: 1808 fdput(tmp); 1809 out_put_file: 1810 fdput(f); 1811 out: 1812 return error; 1813 } 1814 1815 static int 1816 xfs_ioc_getlabel( 1817 struct xfs_mount *mp, 1818 char __user *user_label) 1819 { 1820 struct xfs_sb *sbp = &mp->m_sb; 1821 char label[XFSLABEL_MAX + 1]; 1822 1823 /* Paranoia */ 1824 BUILD_BUG_ON(sizeof(sbp->sb_fname) > FSLABEL_MAX); 1825 1826 spin_lock(&mp->m_sb_lock); 1827 strncpy(label, sbp->sb_fname, sizeof(sbp->sb_fname)); 1828 spin_unlock(&mp->m_sb_lock); 1829 1830 /* xfs on-disk label is 12 chars, be sure we send a null to user */ 1831 label[XFSLABEL_MAX] = '\0'; 1832 if (copy_to_user(user_label, label, sizeof(sbp->sb_fname))) 1833 return -EFAULT; 1834 return 0; 1835 } 1836 1837 static int 1838 xfs_ioc_setlabel( 1839 struct file *filp, 1840 struct xfs_mount *mp, 1841 char __user *newlabel) 1842 { 1843 struct xfs_sb *sbp = &mp->m_sb; 1844 char label[XFSLABEL_MAX + 1]; 1845 size_t len; 1846 int error; 1847 1848 if (!capable(CAP_SYS_ADMIN)) 1849 return -EPERM; 1850 /* 1851 * The generic ioctl allows up to FSLABEL_MAX chars, but XFS is much 1852 * smaller, at 12 bytes. We copy one more to be sure we find the 1853 * (required) NULL character to test the incoming label length. 1854 * NB: The on disk label doesn't need to be null terminated. 1855 */ 1856 if (copy_from_user(label, newlabel, XFSLABEL_MAX + 1)) 1857 return -EFAULT; 1858 len = strnlen(label, XFSLABEL_MAX + 1); 1859 if (len > sizeof(sbp->sb_fname)) 1860 return -EINVAL; 1861 1862 error = mnt_want_write_file(filp); 1863 if (error) 1864 return error; 1865 1866 spin_lock(&mp->m_sb_lock); 1867 memset(sbp->sb_fname, 0, sizeof(sbp->sb_fname)); 1868 strncpy(sbp->sb_fname, label, sizeof(sbp->sb_fname)); 1869 spin_unlock(&mp->m_sb_lock); 1870 1871 /* 1872 * Now we do several things to satisfy userspace. 1873 * In addition to normal logging of the primary superblock, we also 1874 * immediately write these changes to sector zero for the primary, then 1875 * update all backup supers (as xfs_db does for a label change), then 1876 * invalidate the block device page cache. This is so that any prior 1877 * buffered reads from userspace (i.e. from blkid) are invalidated, 1878 * and userspace will see the newly-written label. 1879 */ 1880 error = xfs_sync_sb_buf(mp); 1881 if (error) 1882 goto out; 1883 /* 1884 * growfs also updates backup supers so lock against that. 1885 */ 1886 mutex_lock(&mp->m_growlock); 1887 error = xfs_update_secondary_sbs(mp); 1888 mutex_unlock(&mp->m_growlock); 1889 1890 invalidate_bdev(mp->m_ddev_targp->bt_bdev); 1891 1892 out: 1893 mnt_drop_write_file(filp); 1894 return error; 1895 } 1896 1897 /* 1898 * Note: some of the ioctl's return positive numbers as a 1899 * byte count indicating success, such as readlink_by_handle. 1900 * So we don't "sign flip" like most other routines. This means 1901 * true errors need to be returned as a negative value. 1902 */ 1903 long 1904 xfs_file_ioctl( 1905 struct file *filp, 1906 unsigned int cmd, 1907 unsigned long p) 1908 { 1909 struct inode *inode = file_inode(filp); 1910 struct xfs_inode *ip = XFS_I(inode); 1911 struct xfs_mount *mp = ip->i_mount; 1912 void __user *arg = (void __user *)p; 1913 int error; 1914 1915 trace_xfs_file_ioctl(ip); 1916 1917 switch (cmd) { 1918 case FITRIM: 1919 return xfs_ioc_trim(mp, arg); 1920 case FS_IOC_GETFSLABEL: 1921 return xfs_ioc_getlabel(mp, arg); 1922 case FS_IOC_SETFSLABEL: 1923 return xfs_ioc_setlabel(filp, mp, arg); 1924 case XFS_IOC_ALLOCSP: 1925 case XFS_IOC_FREESP: 1926 case XFS_IOC_RESVSP: 1927 case XFS_IOC_UNRESVSP: 1928 case XFS_IOC_ALLOCSP64: 1929 case XFS_IOC_FREESP64: 1930 case XFS_IOC_RESVSP64: 1931 case XFS_IOC_UNRESVSP64: 1932 case XFS_IOC_ZERO_RANGE: { 1933 xfs_flock64_t bf; 1934 1935 if (copy_from_user(&bf, arg, sizeof(bf))) 1936 return -EFAULT; 1937 return xfs_ioc_space(filp, cmd, &bf); 1938 } 1939 case XFS_IOC_DIOINFO: { 1940 struct dioattr da; 1941 xfs_buftarg_t *target = 1942 XFS_IS_REALTIME_INODE(ip) ? 1943 mp->m_rtdev_targp : mp->m_ddev_targp; 1944 1945 da.d_mem = da.d_miniosz = target->bt_logical_sectorsize; 1946 da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1); 1947 1948 if (copy_to_user(arg, &da, sizeof(da))) 1949 return -EFAULT; 1950 return 0; 1951 } 1952 1953 case XFS_IOC_FSBULKSTAT_SINGLE: 1954 case XFS_IOC_FSBULKSTAT: 1955 case XFS_IOC_FSINUMBERS: 1956 return xfs_ioc_bulkstat(mp, cmd, arg); 1957 1958 case XFS_IOC_FSGEOMETRY_V1: 1959 return xfs_ioc_fsgeometry_v1(mp, arg); 1960 1961 case XFS_IOC_FSGEOMETRY: 1962 return xfs_ioc_fsgeometry(mp, arg); 1963 1964 case XFS_IOC_GETVERSION: 1965 return put_user(inode->i_generation, (int __user *)arg); 1966 1967 case XFS_IOC_FSGETXATTR: 1968 return xfs_ioc_fsgetxattr(ip, 0, arg); 1969 case XFS_IOC_FSGETXATTRA: 1970 return xfs_ioc_fsgetxattr(ip, 1, arg); 1971 case XFS_IOC_FSSETXATTR: 1972 return xfs_ioc_fssetxattr(ip, filp, arg); 1973 case XFS_IOC_GETXFLAGS: 1974 return xfs_ioc_getxflags(ip, arg); 1975 case XFS_IOC_SETXFLAGS: 1976 return xfs_ioc_setxflags(ip, filp, arg); 1977 1978 case XFS_IOC_FSSETDM: { 1979 struct fsdmidata dmi; 1980 1981 if (copy_from_user(&dmi, arg, sizeof(dmi))) 1982 return -EFAULT; 1983 1984 error = mnt_want_write_file(filp); 1985 if (error) 1986 return error; 1987 1988 error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask, 1989 dmi.fsd_dmstate); 1990 mnt_drop_write_file(filp); 1991 return error; 1992 } 1993 1994 case XFS_IOC_GETBMAP: 1995 case XFS_IOC_GETBMAPA: 1996 case XFS_IOC_GETBMAPX: 1997 return xfs_ioc_getbmap(filp, cmd, arg); 1998 1999 case FS_IOC_GETFSMAP: 2000 return xfs_ioc_getfsmap(ip, arg); 2001 2002 case XFS_IOC_SCRUB_METADATA: 2003 return xfs_ioc_scrub_metadata(ip, arg); 2004 2005 case XFS_IOC_FD_TO_HANDLE: 2006 case XFS_IOC_PATH_TO_HANDLE: 2007 case XFS_IOC_PATH_TO_FSHANDLE: { 2008 xfs_fsop_handlereq_t hreq; 2009 2010 if (copy_from_user(&hreq, arg, sizeof(hreq))) 2011 return -EFAULT; 2012 return xfs_find_handle(cmd, &hreq); 2013 } 2014 case XFS_IOC_OPEN_BY_HANDLE: { 2015 xfs_fsop_handlereq_t hreq; 2016 2017 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t))) 2018 return -EFAULT; 2019 return xfs_open_by_handle(filp, &hreq); 2020 } 2021 case XFS_IOC_FSSETDM_BY_HANDLE: 2022 return xfs_fssetdm_by_handle(filp, arg); 2023 2024 case XFS_IOC_READLINK_BY_HANDLE: { 2025 xfs_fsop_handlereq_t hreq; 2026 2027 if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t))) 2028 return -EFAULT; 2029 return xfs_readlink_by_handle(filp, &hreq); 2030 } 2031 case XFS_IOC_ATTRLIST_BY_HANDLE: 2032 return xfs_attrlist_by_handle(filp, arg); 2033 2034 case XFS_IOC_ATTRMULTI_BY_HANDLE: 2035 return xfs_attrmulti_by_handle(filp, arg); 2036 2037 case XFS_IOC_SWAPEXT: { 2038 struct xfs_swapext sxp; 2039 2040 if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t))) 2041 return -EFAULT; 2042 error = mnt_want_write_file(filp); 2043 if (error) 2044 return error; 2045 error = xfs_ioc_swapext(&sxp); 2046 mnt_drop_write_file(filp); 2047 return error; 2048 } 2049 2050 case XFS_IOC_FSCOUNTS: { 2051 xfs_fsop_counts_t out; 2052 2053 error = xfs_fs_counts(mp, &out); 2054 if (error) 2055 return error; 2056 2057 if (copy_to_user(arg, &out, sizeof(out))) 2058 return -EFAULT; 2059 return 0; 2060 } 2061 2062 case XFS_IOC_SET_RESBLKS: { 2063 xfs_fsop_resblks_t inout; 2064 uint64_t in; 2065 2066 if (!capable(CAP_SYS_ADMIN)) 2067 return -EPERM; 2068 2069 if (mp->m_flags & XFS_MOUNT_RDONLY) 2070 return -EROFS; 2071 2072 if (copy_from_user(&inout, arg, sizeof(inout))) 2073 return -EFAULT; 2074 2075 error = mnt_want_write_file(filp); 2076 if (error) 2077 return error; 2078 2079 /* input parameter is passed in resblks field of structure */ 2080 in = inout.resblks; 2081 error = xfs_reserve_blocks(mp, &in, &inout); 2082 mnt_drop_write_file(filp); 2083 if (error) 2084 return error; 2085 2086 if (copy_to_user(arg, &inout, sizeof(inout))) 2087 return -EFAULT; 2088 return 0; 2089 } 2090 2091 case XFS_IOC_GET_RESBLKS: { 2092 xfs_fsop_resblks_t out; 2093 2094 if (!capable(CAP_SYS_ADMIN)) 2095 return -EPERM; 2096 2097 error = xfs_reserve_blocks(mp, NULL, &out); 2098 if (error) 2099 return error; 2100 2101 if (copy_to_user(arg, &out, sizeof(out))) 2102 return -EFAULT; 2103 2104 return 0; 2105 } 2106 2107 case XFS_IOC_FSGROWFSDATA: { 2108 xfs_growfs_data_t in; 2109 2110 if (copy_from_user(&in, arg, sizeof(in))) 2111 return -EFAULT; 2112 2113 error = mnt_want_write_file(filp); 2114 if (error) 2115 return error; 2116 error = xfs_growfs_data(mp, &in); 2117 mnt_drop_write_file(filp); 2118 return error; 2119 } 2120 2121 case XFS_IOC_FSGROWFSLOG: { 2122 xfs_growfs_log_t in; 2123 2124 if (copy_from_user(&in, arg, sizeof(in))) 2125 return -EFAULT; 2126 2127 error = mnt_want_write_file(filp); 2128 if (error) 2129 return error; 2130 error = xfs_growfs_log(mp, &in); 2131 mnt_drop_write_file(filp); 2132 return error; 2133 } 2134 2135 case XFS_IOC_FSGROWFSRT: { 2136 xfs_growfs_rt_t in; 2137 2138 if (copy_from_user(&in, arg, sizeof(in))) 2139 return -EFAULT; 2140 2141 error = mnt_want_write_file(filp); 2142 if (error) 2143 return error; 2144 error = xfs_growfs_rt(mp, &in); 2145 mnt_drop_write_file(filp); 2146 return error; 2147 } 2148 2149 case XFS_IOC_GOINGDOWN: { 2150 uint32_t in; 2151 2152 if (!capable(CAP_SYS_ADMIN)) 2153 return -EPERM; 2154 2155 if (get_user(in, (uint32_t __user *)arg)) 2156 return -EFAULT; 2157 2158 return xfs_fs_goingdown(mp, in); 2159 } 2160 2161 case XFS_IOC_ERROR_INJECTION: { 2162 xfs_error_injection_t in; 2163 2164 if (!capable(CAP_SYS_ADMIN)) 2165 return -EPERM; 2166 2167 if (copy_from_user(&in, arg, sizeof(in))) 2168 return -EFAULT; 2169 2170 return xfs_errortag_add(mp, in.errtag); 2171 } 2172 2173 case XFS_IOC_ERROR_CLEARALL: 2174 if (!capable(CAP_SYS_ADMIN)) 2175 return -EPERM; 2176 2177 return xfs_errortag_clearall(mp); 2178 2179 case XFS_IOC_FREE_EOFBLOCKS: { 2180 struct xfs_fs_eofblocks eofb; 2181 struct xfs_eofblocks keofb; 2182 2183 if (!capable(CAP_SYS_ADMIN)) 2184 return -EPERM; 2185 2186 if (mp->m_flags & XFS_MOUNT_RDONLY) 2187 return -EROFS; 2188 2189 if (copy_from_user(&eofb, arg, sizeof(eofb))) 2190 return -EFAULT; 2191 2192 error = xfs_fs_eofblocks_from_user(&eofb, &keofb); 2193 if (error) 2194 return error; 2195 2196 return xfs_icache_free_eofblocks(mp, &keofb); 2197 } 2198 2199 default: 2200 return -ENOTTY; 2201 } 2202 } 2203