1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 4 * Copyright (c) 2022-2024 Oracle. 5 * All rights reserved. 6 */ 7 #include "xfs.h" 8 #include "xfs_fs.h" 9 #include "xfs_format.h" 10 #include "xfs_log_format.h" 11 #include "xfs_shared.h" 12 #include "xfs_trans_resv.h" 13 #include "xfs_mount.h" 14 #include "xfs_bmap_btree.h" 15 #include "xfs_inode.h" 16 #include "xfs_error.h" 17 #include "xfs_trace.h" 18 #include "xfs_trans.h" 19 #include "xfs_da_format.h" 20 #include "xfs_da_btree.h" 21 #include "xfs_attr.h" 22 #include "xfs_ioctl.h" 23 #include "xfs_parent.h" 24 #include "xfs_da_btree.h" 25 #include "xfs_handle.h" 26 #include "xfs_health.h" 27 #include "xfs_icache.h" 28 #include "xfs_export.h" 29 #include "xfs_xattr.h" 30 #include "xfs_acl.h" 31 32 #include <linux/namei.h> 33 34 static inline size_t 35 xfs_filehandle_fid_len(void) 36 { 37 struct xfs_handle *handle = NULL; 38 39 return sizeof(struct xfs_fid) - sizeof(handle->ha_fid.fid_len); 40 } 41 42 static inline size_t 43 xfs_filehandle_init( 44 struct xfs_mount *mp, 45 xfs_ino_t ino, 46 uint32_t gen, 47 struct xfs_handle *handle) 48 { 49 memcpy(&handle->ha_fsid, mp->m_fixedfsid, sizeof(struct xfs_fsid)); 50 51 handle->ha_fid.fid_len = xfs_filehandle_fid_len(); 52 handle->ha_fid.fid_pad = 0; 53 handle->ha_fid.fid_gen = gen; 54 handle->ha_fid.fid_ino = ino; 55 56 return sizeof(struct xfs_handle); 57 } 58 59 static inline size_t 60 xfs_fshandle_init( 61 struct xfs_mount *mp, 62 struct xfs_handle *handle) 63 { 64 memcpy(&handle->ha_fsid, mp->m_fixedfsid, sizeof(struct xfs_fsid)); 65 memset(&handle->ha_fid, 0, sizeof(handle->ha_fid)); 66 67 return sizeof(struct xfs_fsid); 68 } 69 70 /* 71 * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to 72 * a file or fs handle. 73 * 74 * XFS_IOC_PATH_TO_FSHANDLE 75 * returns fs handle for a mount point or path within that mount point 76 * XFS_IOC_FD_TO_HANDLE 77 * returns full handle for a FD opened in user space 78 * XFS_IOC_PATH_TO_HANDLE 79 * returns full handle for a path 80 */ 81 int 82 xfs_find_handle( 83 unsigned int cmd, 84 xfs_fsop_handlereq_t *hreq) 85 { 86 int hsize; 87 xfs_handle_t handle; 88 struct inode *inode; 89 struct fd f = {NULL}; 90 struct path path; 91 int error; 92 struct xfs_inode *ip; 93 94 if (cmd == XFS_IOC_FD_TO_HANDLE) { 95 f = fdget(hreq->fd); 96 if (!f.file) 97 return -EBADF; 98 inode = file_inode(f.file); 99 } else { 100 error = user_path_at(AT_FDCWD, hreq->path, 0, &path); 101 if (error) 102 return error; 103 inode = d_inode(path.dentry); 104 } 105 ip = XFS_I(inode); 106 107 /* 108 * We can only generate handles for inodes residing on a XFS filesystem, 109 * and only for regular files, directories or symbolic links. 110 */ 111 error = -EINVAL; 112 if (inode->i_sb->s_magic != XFS_SB_MAGIC) 113 goto out_put; 114 115 error = -EBADF; 116 if (!S_ISREG(inode->i_mode) && 117 !S_ISDIR(inode->i_mode) && 118 !S_ISLNK(inode->i_mode)) 119 goto out_put; 120 121 122 memcpy(&handle.ha_fsid, ip->i_mount->m_fixedfsid, sizeof(xfs_fsid_t)); 123 124 if (cmd == XFS_IOC_PATH_TO_FSHANDLE) 125 hsize = xfs_fshandle_init(ip->i_mount, &handle); 126 else 127 hsize = xfs_filehandle_init(ip->i_mount, ip->i_ino, 128 inode->i_generation, &handle); 129 130 error = -EFAULT; 131 if (copy_to_user(hreq->ohandle, &handle, hsize) || 132 copy_to_user(hreq->ohandlen, &hsize, sizeof(__s32))) 133 goto out_put; 134 135 error = 0; 136 137 out_put: 138 if (cmd == XFS_IOC_FD_TO_HANDLE) 139 fdput(f); 140 else 141 path_put(&path); 142 return error; 143 } 144 145 /* 146 * No need to do permission checks on the various pathname components 147 * as the handle operations are privileged. 148 */ 149 STATIC int 150 xfs_handle_acceptable( 151 void *context, 152 struct dentry *dentry) 153 { 154 return 1; 155 } 156 157 /* Convert handle already copied to kernel space into a dentry. */ 158 static struct dentry * 159 xfs_khandle_to_dentry( 160 struct file *file, 161 struct xfs_handle *handle) 162 { 163 struct xfs_fid64 fid = { 164 .ino = handle->ha_fid.fid_ino, 165 .gen = handle->ha_fid.fid_gen, 166 }; 167 168 /* 169 * Only allow handle opens under a directory. 170 */ 171 if (!S_ISDIR(file_inode(file)->i_mode)) 172 return ERR_PTR(-ENOTDIR); 173 174 if (handle->ha_fid.fid_len != xfs_filehandle_fid_len()) 175 return ERR_PTR(-EINVAL); 176 177 return exportfs_decode_fh(file->f_path.mnt, (struct fid *)&fid, 3, 178 FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG, 179 xfs_handle_acceptable, NULL); 180 } 181 182 /* Convert handle already copied to kernel space into an xfs_inode. */ 183 static struct xfs_inode * 184 xfs_khandle_to_inode( 185 struct file *file, 186 struct xfs_handle *handle) 187 { 188 struct xfs_inode *ip = XFS_I(file_inode(file)); 189 struct xfs_mount *mp = ip->i_mount; 190 struct inode *inode; 191 192 if (!S_ISDIR(VFS_I(ip)->i_mode)) 193 return ERR_PTR(-ENOTDIR); 194 195 if (handle->ha_fid.fid_len != xfs_filehandle_fid_len()) 196 return ERR_PTR(-EINVAL); 197 198 inode = xfs_nfs_get_inode(mp->m_super, handle->ha_fid.fid_ino, 199 handle->ha_fid.fid_gen); 200 if (IS_ERR(inode)) 201 return ERR_CAST(inode); 202 203 return XFS_I(inode); 204 } 205 206 /* 207 * Convert userspace handle data into a dentry. 208 */ 209 struct dentry * 210 xfs_handle_to_dentry( 211 struct file *parfilp, 212 void __user *uhandle, 213 u32 hlen) 214 { 215 xfs_handle_t handle; 216 217 if (hlen != sizeof(xfs_handle_t)) 218 return ERR_PTR(-EINVAL); 219 if (copy_from_user(&handle, uhandle, hlen)) 220 return ERR_PTR(-EFAULT); 221 222 return xfs_khandle_to_dentry(parfilp, &handle); 223 } 224 225 STATIC struct dentry * 226 xfs_handlereq_to_dentry( 227 struct file *parfilp, 228 xfs_fsop_handlereq_t *hreq) 229 { 230 return xfs_handle_to_dentry(parfilp, hreq->ihandle, hreq->ihandlen); 231 } 232 233 int 234 xfs_open_by_handle( 235 struct file *parfilp, 236 xfs_fsop_handlereq_t *hreq) 237 { 238 const struct cred *cred = current_cred(); 239 int error; 240 int fd; 241 int permflag; 242 struct file *filp; 243 struct inode *inode; 244 struct dentry *dentry; 245 fmode_t fmode; 246 struct path path; 247 248 if (!capable(CAP_SYS_ADMIN)) 249 return -EPERM; 250 251 dentry = xfs_handlereq_to_dentry(parfilp, hreq); 252 if (IS_ERR(dentry)) 253 return PTR_ERR(dentry); 254 inode = d_inode(dentry); 255 256 /* Restrict xfs_open_by_handle to directories & regular files. */ 257 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) { 258 error = -EPERM; 259 goto out_dput; 260 } 261 262 #if BITS_PER_LONG != 32 263 hreq->oflags |= O_LARGEFILE; 264 #endif 265 266 permflag = hreq->oflags; 267 fmode = OPEN_FMODE(permflag); 268 if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) && 269 (fmode & FMODE_WRITE) && IS_APPEND(inode)) { 270 error = -EPERM; 271 goto out_dput; 272 } 273 274 if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) { 275 error = -EPERM; 276 goto out_dput; 277 } 278 279 /* Can't write directories. */ 280 if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) { 281 error = -EISDIR; 282 goto out_dput; 283 } 284 285 fd = get_unused_fd_flags(0); 286 if (fd < 0) { 287 error = fd; 288 goto out_dput; 289 } 290 291 path.mnt = parfilp->f_path.mnt; 292 path.dentry = dentry; 293 filp = dentry_open(&path, hreq->oflags, cred); 294 dput(dentry); 295 if (IS_ERR(filp)) { 296 put_unused_fd(fd); 297 return PTR_ERR(filp); 298 } 299 300 if (S_ISREG(inode->i_mode)) { 301 filp->f_flags |= O_NOATIME; 302 filp->f_mode |= FMODE_NOCMTIME; 303 } 304 305 fd_install(fd, filp); 306 return fd; 307 308 out_dput: 309 dput(dentry); 310 return error; 311 } 312 313 int 314 xfs_readlink_by_handle( 315 struct file *parfilp, 316 xfs_fsop_handlereq_t *hreq) 317 { 318 struct dentry *dentry; 319 __u32 olen; 320 int error; 321 322 if (!capable(CAP_SYS_ADMIN)) 323 return -EPERM; 324 325 dentry = xfs_handlereq_to_dentry(parfilp, hreq); 326 if (IS_ERR(dentry)) 327 return PTR_ERR(dentry); 328 329 /* Restrict this handle operation to symlinks only. */ 330 if (!d_is_symlink(dentry)) { 331 error = -EINVAL; 332 goto out_dput; 333 } 334 335 if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) { 336 error = -EFAULT; 337 goto out_dput; 338 } 339 340 error = vfs_readlink(dentry, hreq->ohandle, olen); 341 342 out_dput: 343 dput(dentry); 344 return error; 345 } 346 347 /* 348 * Format an attribute and copy it out to the user's buffer. 349 * Take care to check values and protect against them changing later, 350 * we may be reading them directly out of a user buffer. 351 */ 352 static void 353 xfs_ioc_attr_put_listent( 354 struct xfs_attr_list_context *context, 355 int flags, 356 unsigned char *name, 357 int namelen, 358 void *value, 359 int valuelen) 360 { 361 struct xfs_attrlist *alist = context->buffer; 362 struct xfs_attrlist_ent *aep; 363 int arraytop; 364 365 ASSERT(!context->seen_enough); 366 ASSERT(context->count >= 0); 367 ASSERT(context->count < (ATTR_MAX_VALUELEN/8)); 368 ASSERT(context->firstu >= sizeof(*alist)); 369 ASSERT(context->firstu <= context->bufsize); 370 371 /* 372 * Only list entries in the right namespace. 373 */ 374 if (context->attr_filter != (flags & XFS_ATTR_NSP_ONDISK_MASK)) 375 return; 376 377 arraytop = sizeof(*alist) + 378 context->count * sizeof(alist->al_offset[0]); 379 380 /* decrement by the actual bytes used by the attr */ 381 context->firstu -= round_up(offsetof(struct xfs_attrlist_ent, a_name) + 382 namelen + 1, sizeof(uint32_t)); 383 if (context->firstu < arraytop) { 384 trace_xfs_attr_list_full(context); 385 alist->al_more = 1; 386 context->seen_enough = 1; 387 return; 388 } 389 390 aep = context->buffer + context->firstu; 391 aep->a_valuelen = valuelen; 392 memcpy(aep->a_name, name, namelen); 393 aep->a_name[namelen] = 0; 394 alist->al_offset[context->count++] = context->firstu; 395 alist->al_count = context->count; 396 trace_xfs_attr_list_add(context); 397 } 398 399 static unsigned int 400 xfs_attr_filter( 401 u32 ioc_flags) 402 { 403 if (ioc_flags & XFS_IOC_ATTR_ROOT) 404 return XFS_ATTR_ROOT; 405 if (ioc_flags & XFS_IOC_ATTR_SECURE) 406 return XFS_ATTR_SECURE; 407 return 0; 408 } 409 410 static inline enum xfs_attr_update 411 xfs_xattr_flags( 412 u32 ioc_flags, 413 void *value) 414 { 415 if (!value) 416 return XFS_ATTRUPDATE_REMOVE; 417 if (ioc_flags & XFS_IOC_ATTR_CREATE) 418 return XFS_ATTRUPDATE_CREATE; 419 if (ioc_flags & XFS_IOC_ATTR_REPLACE) 420 return XFS_ATTRUPDATE_REPLACE; 421 return XFS_ATTRUPDATE_UPSERT; 422 } 423 424 int 425 xfs_ioc_attr_list( 426 struct xfs_inode *dp, 427 void __user *ubuf, 428 size_t bufsize, 429 int flags, 430 struct xfs_attrlist_cursor __user *ucursor) 431 { 432 struct xfs_attr_list_context context = { }; 433 struct xfs_attrlist *alist; 434 void *buffer; 435 int error; 436 437 if (bufsize < sizeof(struct xfs_attrlist) || 438 bufsize > XFS_XATTR_LIST_MAX) 439 return -EINVAL; 440 441 /* 442 * Reject flags, only allow namespaces. 443 */ 444 if (flags & ~(XFS_IOC_ATTR_ROOT | XFS_IOC_ATTR_SECURE)) 445 return -EINVAL; 446 if (flags == (XFS_IOC_ATTR_ROOT | XFS_IOC_ATTR_SECURE)) 447 return -EINVAL; 448 449 /* 450 * Validate the cursor. 451 */ 452 if (copy_from_user(&context.cursor, ucursor, sizeof(context.cursor))) 453 return -EFAULT; 454 if (context.cursor.pad1 || context.cursor.pad2) 455 return -EINVAL; 456 if (!context.cursor.initted && 457 (context.cursor.hashval || context.cursor.blkno || 458 context.cursor.offset)) 459 return -EINVAL; 460 461 buffer = kvzalloc(bufsize, GFP_KERNEL); 462 if (!buffer) 463 return -ENOMEM; 464 465 /* 466 * Initialize the output buffer. 467 */ 468 context.dp = dp; 469 context.resynch = 1; 470 context.attr_filter = xfs_attr_filter(flags); 471 context.buffer = buffer; 472 context.bufsize = round_down(bufsize, sizeof(uint32_t)); 473 context.firstu = context.bufsize; 474 context.put_listent = xfs_ioc_attr_put_listent; 475 476 alist = context.buffer; 477 alist->al_count = 0; 478 alist->al_more = 0; 479 alist->al_offset[0] = context.bufsize; 480 481 error = xfs_attr_list(&context); 482 if (error) 483 goto out_free; 484 485 if (copy_to_user(ubuf, buffer, bufsize) || 486 copy_to_user(ucursor, &context.cursor, sizeof(context.cursor))) 487 error = -EFAULT; 488 out_free: 489 kvfree(buffer); 490 return error; 491 } 492 493 int 494 xfs_attrlist_by_handle( 495 struct file *parfilp, 496 struct xfs_fsop_attrlist_handlereq __user *p) 497 { 498 struct xfs_fsop_attrlist_handlereq al_hreq; 499 struct dentry *dentry; 500 int error = -ENOMEM; 501 502 if (!capable(CAP_SYS_ADMIN)) 503 return -EPERM; 504 if (copy_from_user(&al_hreq, p, sizeof(al_hreq))) 505 return -EFAULT; 506 507 dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq); 508 if (IS_ERR(dentry)) 509 return PTR_ERR(dentry); 510 511 error = xfs_ioc_attr_list(XFS_I(d_inode(dentry)), al_hreq.buffer, 512 al_hreq.buflen, al_hreq.flags, &p->pos); 513 dput(dentry); 514 return error; 515 } 516 517 static int 518 xfs_attrmulti_attr_get( 519 struct inode *inode, 520 unsigned char *name, 521 unsigned char __user *ubuf, 522 uint32_t *len, 523 uint32_t flags) 524 { 525 struct xfs_da_args args = { 526 .dp = XFS_I(inode), 527 .attr_filter = xfs_attr_filter(flags), 528 .name = name, 529 .namelen = strlen(name), 530 .valuelen = *len, 531 }; 532 int error; 533 534 if (*len > XFS_XATTR_SIZE_MAX) 535 return -EINVAL; 536 537 error = xfs_attr_get(&args); 538 if (error) 539 goto out_kfree; 540 541 *len = args.valuelen; 542 if (copy_to_user(ubuf, args.value, args.valuelen)) 543 error = -EFAULT; 544 545 out_kfree: 546 kvfree(args.value); 547 return error; 548 } 549 550 static int 551 xfs_attrmulti_attr_set( 552 struct inode *inode, 553 unsigned char *name, 554 const unsigned char __user *ubuf, 555 uint32_t len, 556 uint32_t flags) 557 { 558 struct xfs_da_args args = { 559 .dp = XFS_I(inode), 560 .attr_filter = xfs_attr_filter(flags), 561 .name = name, 562 .namelen = strlen(name), 563 }; 564 int error; 565 566 if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) 567 return -EPERM; 568 569 if (ubuf) { 570 if (len > XFS_XATTR_SIZE_MAX) 571 return -EINVAL; 572 args.value = memdup_user(ubuf, len); 573 if (IS_ERR(args.value)) 574 return PTR_ERR(args.value); 575 args.valuelen = len; 576 } 577 578 error = xfs_attr_change(&args, xfs_xattr_flags(flags, args.value)); 579 if (!error && (flags & XFS_IOC_ATTR_ROOT)) 580 xfs_forget_acl(inode, name); 581 kfree(args.value); 582 return error; 583 } 584 585 int 586 xfs_ioc_attrmulti_one( 587 struct file *parfilp, 588 struct inode *inode, 589 uint32_t opcode, 590 void __user *uname, 591 void __user *value, 592 uint32_t *len, 593 uint32_t flags) 594 { 595 unsigned char *name; 596 int error; 597 598 if ((flags & XFS_IOC_ATTR_ROOT) && (flags & XFS_IOC_ATTR_SECURE)) 599 return -EINVAL; 600 601 name = strndup_user(uname, MAXNAMELEN); 602 if (IS_ERR(name)) 603 return PTR_ERR(name); 604 605 switch (opcode) { 606 case ATTR_OP_GET: 607 error = xfs_attrmulti_attr_get(inode, name, value, len, flags); 608 break; 609 case ATTR_OP_REMOVE: 610 value = NULL; 611 *len = 0; 612 fallthrough; 613 case ATTR_OP_SET: 614 error = mnt_want_write_file(parfilp); 615 if (error) 616 break; 617 error = xfs_attrmulti_attr_set(inode, name, value, *len, flags); 618 mnt_drop_write_file(parfilp); 619 break; 620 default: 621 error = -EINVAL; 622 break; 623 } 624 625 kfree(name); 626 return error; 627 } 628 629 int 630 xfs_attrmulti_by_handle( 631 struct file *parfilp, 632 void __user *arg) 633 { 634 int error; 635 xfs_attr_multiop_t *ops; 636 xfs_fsop_attrmulti_handlereq_t am_hreq; 637 struct dentry *dentry; 638 unsigned int i, size; 639 640 if (!capable(CAP_SYS_ADMIN)) 641 return -EPERM; 642 if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t))) 643 return -EFAULT; 644 645 /* overflow check */ 646 if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t)) 647 return -E2BIG; 648 649 dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq); 650 if (IS_ERR(dentry)) 651 return PTR_ERR(dentry); 652 653 error = -E2BIG; 654 size = am_hreq.opcount * sizeof(xfs_attr_multiop_t); 655 if (!size || size > 16 * PAGE_SIZE) 656 goto out_dput; 657 658 ops = memdup_user(am_hreq.ops, size); 659 if (IS_ERR(ops)) { 660 error = PTR_ERR(ops); 661 goto out_dput; 662 } 663 664 error = 0; 665 for (i = 0; i < am_hreq.opcount; i++) { 666 ops[i].am_error = xfs_ioc_attrmulti_one(parfilp, 667 d_inode(dentry), ops[i].am_opcode, 668 ops[i].am_attrname, ops[i].am_attrvalue, 669 &ops[i].am_length, ops[i].am_flags); 670 } 671 672 if (copy_to_user(am_hreq.ops, ops, size)) 673 error = -EFAULT; 674 675 kfree(ops); 676 out_dput: 677 dput(dentry); 678 return error; 679 } 680 681 struct xfs_getparents_ctx { 682 struct xfs_attr_list_context context; 683 struct xfs_getparents_by_handle gph; 684 685 /* File to target */ 686 struct xfs_inode *ip; 687 688 /* Internal buffer where we format records */ 689 void *krecords; 690 691 /* Last record filled out */ 692 struct xfs_getparents_rec *lastrec; 693 694 unsigned int count; 695 }; 696 697 static inline unsigned int 698 xfs_getparents_rec_sizeof( 699 unsigned int namelen) 700 { 701 return round_up(sizeof(struct xfs_getparents_rec) + namelen + 1, 702 sizeof(uint64_t)); 703 } 704 705 static void 706 xfs_getparents_put_listent( 707 struct xfs_attr_list_context *context, 708 int flags, 709 unsigned char *name, 710 int namelen, 711 void *value, 712 int valuelen) 713 { 714 struct xfs_getparents_ctx *gpx = 715 container_of(context, struct xfs_getparents_ctx, context); 716 struct xfs_inode *ip = context->dp; 717 struct xfs_mount *mp = ip->i_mount; 718 struct xfs_getparents *gp = &gpx->gph.gph_request; 719 struct xfs_getparents_rec *gpr = gpx->krecords + context->firstu; 720 unsigned short reclen = 721 xfs_getparents_rec_sizeof(namelen); 722 xfs_ino_t ino; 723 uint32_t gen; 724 int error; 725 726 if (!(flags & XFS_ATTR_PARENT)) 727 return; 728 729 error = xfs_parent_from_attr(mp, flags, name, namelen, value, valuelen, 730 &ino, &gen); 731 if (error) { 732 xfs_inode_mark_sick(ip, XFS_SICK_INO_PARENT); 733 context->seen_enough = -EFSCORRUPTED; 734 return; 735 } 736 737 /* 738 * We found a parent pointer, but we've filled up the buffer. Signal 739 * to the caller that we did /not/ reach the end of the parent pointer 740 * recordset. 741 */ 742 if (context->firstu > context->bufsize - reclen) { 743 context->seen_enough = 1; 744 return; 745 } 746 747 /* Format the parent pointer directly into the caller buffer. */ 748 gpr->gpr_reclen = reclen; 749 xfs_filehandle_init(mp, ino, gen, &gpr->gpr_parent); 750 memcpy(gpr->gpr_name, name, namelen); 751 gpr->gpr_name[namelen] = 0; 752 753 trace_xfs_getparents_put_listent(ip, gp, context, gpr); 754 755 context->firstu += reclen; 756 gpx->count++; 757 gpx->lastrec = gpr; 758 } 759 760 /* Expand the last record to fill the rest of the caller's buffer. */ 761 static inline void 762 xfs_getparents_expand_lastrec( 763 struct xfs_getparents_ctx *gpx) 764 { 765 struct xfs_getparents *gp = &gpx->gph.gph_request; 766 struct xfs_getparents_rec *gpr = gpx->lastrec; 767 768 if (!gpx->lastrec) 769 gpr = gpx->krecords; 770 771 gpr->gpr_reclen = gp->gp_bufsize - ((void *)gpr - gpx->krecords); 772 773 trace_xfs_getparents_expand_lastrec(gpx->ip, gp, &gpx->context, gpr); 774 } 775 776 static inline void __user *u64_to_uptr(u64 val) 777 { 778 return (void __user *)(uintptr_t)val; 779 } 780 781 /* Retrieve the parent pointers for a given inode. */ 782 STATIC int 783 xfs_getparents( 784 struct xfs_getparents_ctx *gpx) 785 { 786 struct xfs_getparents *gp = &gpx->gph.gph_request; 787 struct xfs_inode *ip = gpx->ip; 788 struct xfs_mount *mp = ip->i_mount; 789 size_t bufsize; 790 int error; 791 792 /* Check size of buffer requested by user */ 793 if (gp->gp_bufsize > XFS_XATTR_LIST_MAX) 794 return -ENOMEM; 795 if (gp->gp_bufsize < xfs_getparents_rec_sizeof(1)) 796 return -EINVAL; 797 798 if (gp->gp_iflags & ~XFS_GETPARENTS_IFLAGS_ALL) 799 return -EINVAL; 800 if (gp->gp_reserved) 801 return -EINVAL; 802 803 bufsize = round_down(gp->gp_bufsize, sizeof(uint64_t)); 804 gpx->krecords = kvzalloc(bufsize, GFP_KERNEL); 805 if (!gpx->krecords) { 806 bufsize = min(bufsize, PAGE_SIZE); 807 gpx->krecords = kvzalloc(bufsize, GFP_KERNEL); 808 if (!gpx->krecords) 809 return -ENOMEM; 810 } 811 812 gpx->context.dp = ip; 813 gpx->context.resynch = 1; 814 gpx->context.put_listent = xfs_getparents_put_listent; 815 gpx->context.bufsize = bufsize; 816 /* firstu is used to track the bytes filled in the buffer */ 817 gpx->context.firstu = 0; 818 819 /* Copy the cursor provided by caller */ 820 memcpy(&gpx->context.cursor, &gp->gp_cursor, 821 sizeof(struct xfs_attrlist_cursor)); 822 gpx->count = 0; 823 gp->gp_oflags = 0; 824 825 trace_xfs_getparents_begin(ip, gp, &gpx->context.cursor); 826 827 error = xfs_attr_list(&gpx->context); 828 if (error) 829 goto out_free_buf; 830 if (gpx->context.seen_enough < 0) { 831 error = gpx->context.seen_enough; 832 goto out_free_buf; 833 } 834 xfs_getparents_expand_lastrec(gpx); 835 836 /* Update the caller with the current cursor position */ 837 memcpy(&gp->gp_cursor, &gpx->context.cursor, 838 sizeof(struct xfs_attrlist_cursor)); 839 840 /* Is this the root directory? */ 841 if (ip->i_ino == mp->m_sb.sb_rootino) 842 gp->gp_oflags |= XFS_GETPARENTS_OFLAG_ROOT; 843 844 if (gpx->context.seen_enough == 0) { 845 /* 846 * If we did not run out of buffer space, then we reached the 847 * end of the pptr recordset, so set the DONE flag. 848 */ 849 gp->gp_oflags |= XFS_GETPARENTS_OFLAG_DONE; 850 } else if (gpx->count == 0) { 851 /* 852 * If we ran out of buffer space before copying any parent 853 * pointers at all, the caller's buffer was too short. Tell 854 * userspace that, erm, the message is too long. 855 */ 856 error = -EMSGSIZE; 857 goto out_free_buf; 858 } 859 860 trace_xfs_getparents_end(ip, gp, &gpx->context.cursor); 861 862 ASSERT(gpx->context.firstu <= gpx->gph.gph_request.gp_bufsize); 863 864 /* Copy the records to userspace. */ 865 if (copy_to_user(u64_to_uptr(gpx->gph.gph_request.gp_buffer), 866 gpx->krecords, gpx->context.firstu)) 867 error = -EFAULT; 868 869 out_free_buf: 870 kvfree(gpx->krecords); 871 gpx->krecords = NULL; 872 return error; 873 } 874 875 /* Retrieve the parents of this file and pass them back to userspace. */ 876 int 877 xfs_ioc_getparents( 878 struct file *file, 879 struct xfs_getparents __user *ureq) 880 { 881 struct xfs_getparents_ctx gpx = { 882 .ip = XFS_I(file_inode(file)), 883 }; 884 struct xfs_getparents *kreq = &gpx.gph.gph_request; 885 struct xfs_mount *mp = gpx.ip->i_mount; 886 int error; 887 888 if (!capable(CAP_SYS_ADMIN)) 889 return -EPERM; 890 if (!xfs_has_parent(mp)) 891 return -EOPNOTSUPP; 892 if (copy_from_user(kreq, ureq, sizeof(*kreq))) 893 return -EFAULT; 894 895 error = xfs_getparents(&gpx); 896 if (error) 897 return error; 898 899 if (copy_to_user(ureq, kreq, sizeof(*kreq))) 900 return -EFAULT; 901 902 return 0; 903 } 904 905 /* Retrieve the parents of this file handle and pass them back to userspace. */ 906 int 907 xfs_ioc_getparents_by_handle( 908 struct file *file, 909 struct xfs_getparents_by_handle __user *ureq) 910 { 911 struct xfs_getparents_ctx gpx = { }; 912 struct xfs_inode *ip = XFS_I(file_inode(file)); 913 struct xfs_mount *mp = ip->i_mount; 914 struct xfs_getparents_by_handle *kreq = &gpx.gph; 915 struct xfs_handle *handle = &kreq->gph_handle; 916 int error; 917 918 if (!capable(CAP_SYS_ADMIN)) 919 return -EPERM; 920 if (!xfs_has_parent(mp)) 921 return -EOPNOTSUPP; 922 if (copy_from_user(kreq, ureq, sizeof(*kreq))) 923 return -EFAULT; 924 925 /* 926 * We don't use exportfs_decode_fh because it does too much work here. 927 * If the handle refers to a directory, the exportfs code will walk 928 * upwards through the directory tree to connect the dentries to the 929 * root directory dentry. For GETPARENTS we don't care about that 930 * because we're not actually going to open a file descriptor; we only 931 * want to open an inode and read its parent pointers. 932 * 933 * Note that xfs_scrub uses GETPARENTS to log that it will try to fix a 934 * corrupted file's metadata. For this usecase we would really rather 935 * userspace single-step the path reconstruction to avoid loops or 936 * other strange things if the directory tree is corrupt. 937 */ 938 gpx.ip = xfs_khandle_to_inode(file, handle); 939 if (IS_ERR(gpx.ip)) 940 return PTR_ERR(gpx.ip); 941 942 error = xfs_getparents(&gpx); 943 if (error) 944 goto out_rele; 945 946 if (copy_to_user(ureq, kreq, sizeof(*kreq))) 947 error = -EFAULT; 948 949 out_rele: 950 xfs_irele(gpx.ip); 951 return error; 952 } 953