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