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