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