1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2004-2005 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 #include <linux/mount.h> 7 #include <linux/fsmap.h> 8 #include "xfs.h" 9 #include "xfs_fs.h" 10 #include "xfs_shared.h" 11 #include "xfs_format.h" 12 #include "xfs_log_format.h" 13 #include "xfs_trans_resv.h" 14 #include "xfs_mount.h" 15 #include "xfs_inode.h" 16 #include "xfs_iwalk.h" 17 #include "xfs_itable.h" 18 #include "xfs_fsops.h" 19 #include "xfs_rtalloc.h" 20 #include "xfs_attr.h" 21 #include "xfs_ioctl.h" 22 #include "xfs_ioctl32.h" 23 #include "xfs_trace.h" 24 #include "xfs_sb.h" 25 26 #define _NATIVE_IOC(cmd, type) \ 27 _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type)) 28 29 #ifdef BROKEN_X86_ALIGNMENT 30 STATIC int 31 xfs_compat_flock64_copyin( 32 xfs_flock64_t *bf, 33 compat_xfs_flock64_t __user *arg32) 34 { 35 if (get_user(bf->l_type, &arg32->l_type) || 36 get_user(bf->l_whence, &arg32->l_whence) || 37 get_user(bf->l_start, &arg32->l_start) || 38 get_user(bf->l_len, &arg32->l_len) || 39 get_user(bf->l_sysid, &arg32->l_sysid) || 40 get_user(bf->l_pid, &arg32->l_pid) || 41 copy_from_user(bf->l_pad, &arg32->l_pad, 4*sizeof(u32))) 42 return -EFAULT; 43 return 0; 44 } 45 46 STATIC int 47 xfs_compat_ioc_fsgeometry_v1( 48 struct xfs_mount *mp, 49 compat_xfs_fsop_geom_v1_t __user *arg32) 50 { 51 struct xfs_fsop_geom fsgeo; 52 53 xfs_fs_geometry(&mp->m_sb, &fsgeo, 3); 54 /* The 32-bit variant simply has some padding at the end */ 55 if (copy_to_user(arg32, &fsgeo, sizeof(struct compat_xfs_fsop_geom_v1))) 56 return -EFAULT; 57 return 0; 58 } 59 60 STATIC int 61 xfs_compat_growfs_data_copyin( 62 struct xfs_growfs_data *in, 63 compat_xfs_growfs_data_t __user *arg32) 64 { 65 if (get_user(in->newblocks, &arg32->newblocks) || 66 get_user(in->imaxpct, &arg32->imaxpct)) 67 return -EFAULT; 68 return 0; 69 } 70 71 STATIC int 72 xfs_compat_growfs_rt_copyin( 73 struct xfs_growfs_rt *in, 74 compat_xfs_growfs_rt_t __user *arg32) 75 { 76 if (get_user(in->newblocks, &arg32->newblocks) || 77 get_user(in->extsize, &arg32->extsize)) 78 return -EFAULT; 79 return 0; 80 } 81 82 STATIC int 83 xfs_fsinumbers_fmt_compat( 84 struct xfs_ibulk *breq, 85 const struct xfs_inumbers *ig) 86 { 87 struct compat_xfs_inogrp __user *p32 = breq->ubuffer; 88 struct xfs_inogrp ig1; 89 struct xfs_inogrp *igrp = &ig1; 90 91 xfs_inumbers_to_inogrp(&ig1, ig); 92 93 if (put_user(igrp->xi_startino, &p32->xi_startino) || 94 put_user(igrp->xi_alloccount, &p32->xi_alloccount) || 95 put_user(igrp->xi_allocmask, &p32->xi_allocmask)) 96 return -EFAULT; 97 98 return xfs_ibulk_advance(breq, sizeof(struct compat_xfs_inogrp)); 99 } 100 101 #else 102 #define xfs_fsinumbers_fmt_compat xfs_fsinumbers_fmt 103 #endif /* BROKEN_X86_ALIGNMENT */ 104 105 STATIC int 106 xfs_ioctl32_bstime_copyin( 107 xfs_bstime_t *bstime, 108 compat_xfs_bstime_t __user *bstime32) 109 { 110 compat_time_t sec32; /* tv_sec differs on 64 vs. 32 */ 111 112 if (get_user(sec32, &bstime32->tv_sec) || 113 get_user(bstime->tv_nsec, &bstime32->tv_nsec)) 114 return -EFAULT; 115 bstime->tv_sec = sec32; 116 return 0; 117 } 118 119 /* 120 * struct xfs_bstat has differing alignment on intel, & bstime_t sizes 121 * everywhere 122 */ 123 STATIC int 124 xfs_ioctl32_bstat_copyin( 125 struct xfs_bstat *bstat, 126 struct compat_xfs_bstat __user *bstat32) 127 { 128 if (get_user(bstat->bs_ino, &bstat32->bs_ino) || 129 get_user(bstat->bs_mode, &bstat32->bs_mode) || 130 get_user(bstat->bs_nlink, &bstat32->bs_nlink) || 131 get_user(bstat->bs_uid, &bstat32->bs_uid) || 132 get_user(bstat->bs_gid, &bstat32->bs_gid) || 133 get_user(bstat->bs_rdev, &bstat32->bs_rdev) || 134 get_user(bstat->bs_blksize, &bstat32->bs_blksize) || 135 get_user(bstat->bs_size, &bstat32->bs_size) || 136 xfs_ioctl32_bstime_copyin(&bstat->bs_atime, &bstat32->bs_atime) || 137 xfs_ioctl32_bstime_copyin(&bstat->bs_mtime, &bstat32->bs_mtime) || 138 xfs_ioctl32_bstime_copyin(&bstat->bs_ctime, &bstat32->bs_ctime) || 139 get_user(bstat->bs_blocks, &bstat32->bs_size) || 140 get_user(bstat->bs_xflags, &bstat32->bs_size) || 141 get_user(bstat->bs_extsize, &bstat32->bs_extsize) || 142 get_user(bstat->bs_extents, &bstat32->bs_extents) || 143 get_user(bstat->bs_gen, &bstat32->bs_gen) || 144 get_user(bstat->bs_projid_lo, &bstat32->bs_projid_lo) || 145 get_user(bstat->bs_projid_hi, &bstat32->bs_projid_hi) || 146 get_user(bstat->bs_forkoff, &bstat32->bs_forkoff) || 147 get_user(bstat->bs_dmevmask, &bstat32->bs_dmevmask) || 148 get_user(bstat->bs_dmstate, &bstat32->bs_dmstate) || 149 get_user(bstat->bs_aextents, &bstat32->bs_aextents)) 150 return -EFAULT; 151 return 0; 152 } 153 154 /* XFS_IOC_FSBULKSTAT and friends */ 155 156 STATIC int 157 xfs_bstime_store_compat( 158 compat_xfs_bstime_t __user *p32, 159 const xfs_bstime_t *p) 160 { 161 __s32 sec32; 162 163 sec32 = p->tv_sec; 164 if (put_user(sec32, &p32->tv_sec) || 165 put_user(p->tv_nsec, &p32->tv_nsec)) 166 return -EFAULT; 167 return 0; 168 } 169 170 /* Return 0 on success or positive error (to xfs_bulkstat()) */ 171 STATIC int 172 xfs_fsbulkstat_one_fmt_compat( 173 struct xfs_ibulk *breq, 174 const struct xfs_bulkstat *bstat) 175 { 176 struct compat_xfs_bstat __user *p32 = breq->ubuffer; 177 struct xfs_bstat bs1; 178 struct xfs_bstat *buffer = &bs1; 179 180 xfs_bulkstat_to_bstat(breq->mp, &bs1, bstat); 181 182 if (put_user(buffer->bs_ino, &p32->bs_ino) || 183 put_user(buffer->bs_mode, &p32->bs_mode) || 184 put_user(buffer->bs_nlink, &p32->bs_nlink) || 185 put_user(buffer->bs_uid, &p32->bs_uid) || 186 put_user(buffer->bs_gid, &p32->bs_gid) || 187 put_user(buffer->bs_rdev, &p32->bs_rdev) || 188 put_user(buffer->bs_blksize, &p32->bs_blksize) || 189 put_user(buffer->bs_size, &p32->bs_size) || 190 xfs_bstime_store_compat(&p32->bs_atime, &buffer->bs_atime) || 191 xfs_bstime_store_compat(&p32->bs_mtime, &buffer->bs_mtime) || 192 xfs_bstime_store_compat(&p32->bs_ctime, &buffer->bs_ctime) || 193 put_user(buffer->bs_blocks, &p32->bs_blocks) || 194 put_user(buffer->bs_xflags, &p32->bs_xflags) || 195 put_user(buffer->bs_extsize, &p32->bs_extsize) || 196 put_user(buffer->bs_extents, &p32->bs_extents) || 197 put_user(buffer->bs_gen, &p32->bs_gen) || 198 put_user(buffer->bs_projid, &p32->bs_projid) || 199 put_user(buffer->bs_projid_hi, &p32->bs_projid_hi) || 200 put_user(buffer->bs_forkoff, &p32->bs_forkoff) || 201 put_user(buffer->bs_dmevmask, &p32->bs_dmevmask) || 202 put_user(buffer->bs_dmstate, &p32->bs_dmstate) || 203 put_user(buffer->bs_aextents, &p32->bs_aextents)) 204 return -EFAULT; 205 206 return xfs_ibulk_advance(breq, sizeof(struct compat_xfs_bstat)); 207 } 208 209 /* copied from xfs_ioctl.c */ 210 STATIC int 211 xfs_compat_ioc_fsbulkstat( 212 xfs_mount_t *mp, 213 unsigned int cmd, 214 struct compat_xfs_fsop_bulkreq __user *p32) 215 { 216 u32 addr; 217 struct xfs_fsop_bulkreq bulkreq; 218 struct xfs_ibulk breq = { 219 .mp = mp, 220 .ocount = 0, 221 }; 222 xfs_ino_t lastino; 223 int error; 224 225 /* 226 * Output structure handling functions. Depending on the command, 227 * either the xfs_bstat and xfs_inogrp structures are written out 228 * to userpace memory via bulkreq.ubuffer. Normally the compat 229 * functions and structure size are the correct ones to use ... 230 */ 231 inumbers_fmt_pf inumbers_func = xfs_fsinumbers_fmt_compat; 232 bulkstat_one_fmt_pf bs_one_func = xfs_fsbulkstat_one_fmt_compat; 233 234 #ifdef CONFIG_X86_X32 235 if (in_x32_syscall()) { 236 /* 237 * ... but on x32 the input xfs_fsop_bulkreq has pointers 238 * which must be handled in the "compat" (32-bit) way, while 239 * the xfs_bstat and xfs_inogrp structures follow native 64- 240 * bit layout convention. So adjust accordingly, otherwise 241 * the data written out in compat layout will not match what 242 * x32 userspace expects. 243 */ 244 inumbers_func = xfs_fsinumbers_fmt; 245 bs_one_func = xfs_fsbulkstat_one_fmt; 246 } 247 #endif 248 249 /* done = 1 if there are more stats to get and if bulkstat */ 250 /* should be called again (unused here, but used in dmapi) */ 251 252 if (!capable(CAP_SYS_ADMIN)) 253 return -EPERM; 254 255 if (XFS_FORCED_SHUTDOWN(mp)) 256 return -EIO; 257 258 if (get_user(addr, &p32->lastip)) 259 return -EFAULT; 260 bulkreq.lastip = compat_ptr(addr); 261 if (get_user(bulkreq.icount, &p32->icount) || 262 get_user(addr, &p32->ubuffer)) 263 return -EFAULT; 264 bulkreq.ubuffer = compat_ptr(addr); 265 if (get_user(addr, &p32->ocount)) 266 return -EFAULT; 267 bulkreq.ocount = compat_ptr(addr); 268 269 if (copy_from_user(&lastino, bulkreq.lastip, sizeof(__s64))) 270 return -EFAULT; 271 272 if (bulkreq.icount <= 0) 273 return -EINVAL; 274 275 if (bulkreq.ubuffer == NULL) 276 return -EINVAL; 277 278 breq.ubuffer = bulkreq.ubuffer; 279 breq.icount = bulkreq.icount; 280 281 /* 282 * FSBULKSTAT_SINGLE expects that *lastip contains the inode number 283 * that we want to stat. However, FSINUMBERS and FSBULKSTAT expect 284 * that *lastip contains either zero or the number of the last inode to 285 * be examined by the previous call and return results starting with 286 * the next inode after that. The new bulk request back end functions 287 * take the inode to start with, so we have to compute the startino 288 * parameter from lastino to maintain correct function. lastino == 0 289 * is a special case because it has traditionally meant "first inode 290 * in filesystem". 291 */ 292 if (cmd == XFS_IOC_FSINUMBERS_32) { 293 breq.startino = lastino ? lastino + 1 : 0; 294 error = xfs_inumbers(&breq, inumbers_func); 295 lastino = breq.startino - 1; 296 } else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE_32) { 297 breq.startino = lastino; 298 breq.icount = 1; 299 error = xfs_bulkstat_one(&breq, bs_one_func); 300 lastino = breq.startino; 301 } else if (cmd == XFS_IOC_FSBULKSTAT_32) { 302 breq.startino = lastino ? lastino + 1 : 0; 303 error = xfs_bulkstat(&breq, bs_one_func); 304 lastino = breq.startino - 1; 305 } else { 306 error = -EINVAL; 307 } 308 if (error) 309 return error; 310 311 if (bulkreq.lastip != NULL && 312 copy_to_user(bulkreq.lastip, &lastino, sizeof(xfs_ino_t))) 313 return -EFAULT; 314 315 if (bulkreq.ocount != NULL && 316 copy_to_user(bulkreq.ocount, &breq.ocount, sizeof(__s32))) 317 return -EFAULT; 318 319 return 0; 320 } 321 322 STATIC int 323 xfs_compat_handlereq_copyin( 324 xfs_fsop_handlereq_t *hreq, 325 compat_xfs_fsop_handlereq_t __user *arg32) 326 { 327 compat_xfs_fsop_handlereq_t hreq32; 328 329 if (copy_from_user(&hreq32, arg32, sizeof(compat_xfs_fsop_handlereq_t))) 330 return -EFAULT; 331 332 hreq->fd = hreq32.fd; 333 hreq->path = compat_ptr(hreq32.path); 334 hreq->oflags = hreq32.oflags; 335 hreq->ihandle = compat_ptr(hreq32.ihandle); 336 hreq->ihandlen = hreq32.ihandlen; 337 hreq->ohandle = compat_ptr(hreq32.ohandle); 338 hreq->ohandlen = compat_ptr(hreq32.ohandlen); 339 340 return 0; 341 } 342 343 STATIC struct dentry * 344 xfs_compat_handlereq_to_dentry( 345 struct file *parfilp, 346 compat_xfs_fsop_handlereq_t *hreq) 347 { 348 return xfs_handle_to_dentry(parfilp, 349 compat_ptr(hreq->ihandle), hreq->ihandlen); 350 } 351 352 STATIC int 353 xfs_compat_attrlist_by_handle( 354 struct file *parfilp, 355 void __user *arg) 356 { 357 int error; 358 attrlist_cursor_kern_t *cursor; 359 compat_xfs_fsop_attrlist_handlereq_t __user *p = arg; 360 compat_xfs_fsop_attrlist_handlereq_t al_hreq; 361 struct dentry *dentry; 362 char *kbuf; 363 364 if (!capable(CAP_SYS_ADMIN)) 365 return -EPERM; 366 if (copy_from_user(&al_hreq, arg, 367 sizeof(compat_xfs_fsop_attrlist_handlereq_t))) 368 return -EFAULT; 369 if (al_hreq.buflen < sizeof(struct attrlist) || 370 al_hreq.buflen > XFS_XATTR_LIST_MAX) 371 return -EINVAL; 372 373 /* 374 * Reject flags, only allow namespaces. 375 */ 376 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE)) 377 return -EINVAL; 378 379 dentry = xfs_compat_handlereq_to_dentry(parfilp, &al_hreq.hreq); 380 if (IS_ERR(dentry)) 381 return PTR_ERR(dentry); 382 383 error = -ENOMEM; 384 kbuf = kmem_zalloc_large(al_hreq.buflen, 0); 385 if (!kbuf) 386 goto out_dput; 387 388 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos; 389 error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen, 390 al_hreq.flags, cursor); 391 if (error) 392 goto out_kfree; 393 394 if (copy_to_user(&p->pos, cursor, sizeof(attrlist_cursor_kern_t))) { 395 error = -EFAULT; 396 goto out_kfree; 397 } 398 399 if (copy_to_user(compat_ptr(al_hreq.buffer), kbuf, al_hreq.buflen)) 400 error = -EFAULT; 401 402 out_kfree: 403 kmem_free(kbuf); 404 out_dput: 405 dput(dentry); 406 return error; 407 } 408 409 STATIC int 410 xfs_compat_attrmulti_by_handle( 411 struct file *parfilp, 412 void __user *arg) 413 { 414 int error; 415 compat_xfs_attr_multiop_t *ops; 416 compat_xfs_fsop_attrmulti_handlereq_t am_hreq; 417 struct dentry *dentry; 418 unsigned int i, size; 419 unsigned char *attr_name; 420 421 if (!capable(CAP_SYS_ADMIN)) 422 return -EPERM; 423 if (copy_from_user(&am_hreq, arg, 424 sizeof(compat_xfs_fsop_attrmulti_handlereq_t))) 425 return -EFAULT; 426 427 /* overflow check */ 428 if (am_hreq.opcount >= INT_MAX / sizeof(compat_xfs_attr_multiop_t)) 429 return -E2BIG; 430 431 dentry = xfs_compat_handlereq_to_dentry(parfilp, &am_hreq.hreq); 432 if (IS_ERR(dentry)) 433 return PTR_ERR(dentry); 434 435 error = -E2BIG; 436 size = am_hreq.opcount * sizeof(compat_xfs_attr_multiop_t); 437 if (!size || size > 16 * PAGE_SIZE) 438 goto out_dput; 439 440 ops = memdup_user(compat_ptr(am_hreq.ops), size); 441 if (IS_ERR(ops)) { 442 error = PTR_ERR(ops); 443 goto out_dput; 444 } 445 446 error = -ENOMEM; 447 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL); 448 if (!attr_name) 449 goto out_kfree_ops; 450 451 error = 0; 452 for (i = 0; i < am_hreq.opcount; i++) { 453 ops[i].am_error = strncpy_from_user((char *)attr_name, 454 compat_ptr(ops[i].am_attrname), 455 MAXNAMELEN); 456 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN) 457 error = -ERANGE; 458 if (ops[i].am_error < 0) 459 break; 460 461 switch (ops[i].am_opcode) { 462 case ATTR_OP_GET: 463 ops[i].am_error = xfs_attrmulti_attr_get( 464 d_inode(dentry), attr_name, 465 compat_ptr(ops[i].am_attrvalue), 466 &ops[i].am_length, ops[i].am_flags); 467 break; 468 case ATTR_OP_SET: 469 ops[i].am_error = mnt_want_write_file(parfilp); 470 if (ops[i].am_error) 471 break; 472 ops[i].am_error = xfs_attrmulti_attr_set( 473 d_inode(dentry), attr_name, 474 compat_ptr(ops[i].am_attrvalue), 475 ops[i].am_length, ops[i].am_flags); 476 mnt_drop_write_file(parfilp); 477 break; 478 case ATTR_OP_REMOVE: 479 ops[i].am_error = mnt_want_write_file(parfilp); 480 if (ops[i].am_error) 481 break; 482 ops[i].am_error = xfs_attrmulti_attr_remove( 483 d_inode(dentry), attr_name, 484 ops[i].am_flags); 485 mnt_drop_write_file(parfilp); 486 break; 487 default: 488 ops[i].am_error = -EINVAL; 489 } 490 } 491 492 if (copy_to_user(compat_ptr(am_hreq.ops), ops, size)) 493 error = -EFAULT; 494 495 kfree(attr_name); 496 out_kfree_ops: 497 kfree(ops); 498 out_dput: 499 dput(dentry); 500 return error; 501 } 502 503 long 504 xfs_file_compat_ioctl( 505 struct file *filp, 506 unsigned cmd, 507 unsigned long p) 508 { 509 struct inode *inode = file_inode(filp); 510 struct xfs_inode *ip = XFS_I(inode); 511 struct xfs_mount *mp = ip->i_mount; 512 void __user *arg = compat_ptr(p); 513 int error; 514 515 trace_xfs_file_compat_ioctl(ip); 516 517 switch (cmd) { 518 #if defined(BROKEN_X86_ALIGNMENT) 519 case XFS_IOC_ALLOCSP_32: 520 case XFS_IOC_FREESP_32: 521 case XFS_IOC_ALLOCSP64_32: 522 case XFS_IOC_FREESP64_32: { 523 struct xfs_flock64 bf; 524 525 if (xfs_compat_flock64_copyin(&bf, arg)) 526 return -EFAULT; 527 cmd = _NATIVE_IOC(cmd, struct xfs_flock64); 528 return xfs_ioc_space(filp, &bf); 529 } 530 case XFS_IOC_FSGEOMETRY_V1_32: 531 return xfs_compat_ioc_fsgeometry_v1(mp, arg); 532 case XFS_IOC_FSGROWFSDATA_32: { 533 struct xfs_growfs_data in; 534 535 if (xfs_compat_growfs_data_copyin(&in, arg)) 536 return -EFAULT; 537 error = mnt_want_write_file(filp); 538 if (error) 539 return error; 540 error = xfs_growfs_data(mp, &in); 541 mnt_drop_write_file(filp); 542 return error; 543 } 544 case XFS_IOC_FSGROWFSRT_32: { 545 struct xfs_growfs_rt in; 546 547 if (xfs_compat_growfs_rt_copyin(&in, arg)) 548 return -EFAULT; 549 error = mnt_want_write_file(filp); 550 if (error) 551 return error; 552 error = xfs_growfs_rt(mp, &in); 553 mnt_drop_write_file(filp); 554 return error; 555 } 556 #endif 557 /* long changes size, but xfs only copiese out 32 bits */ 558 case XFS_IOC_GETXFLAGS_32: 559 case XFS_IOC_SETXFLAGS_32: 560 case XFS_IOC_GETVERSION_32: 561 cmd = _NATIVE_IOC(cmd, long); 562 return xfs_file_ioctl(filp, cmd, p); 563 case XFS_IOC_SWAPEXT_32: { 564 struct xfs_swapext sxp; 565 struct compat_xfs_swapext __user *sxu = arg; 566 567 /* Bulk copy in up to the sx_stat field, then copy bstat */ 568 if (copy_from_user(&sxp, sxu, 569 offsetof(struct xfs_swapext, sx_stat)) || 570 xfs_ioctl32_bstat_copyin(&sxp.sx_stat, &sxu->sx_stat)) 571 return -EFAULT; 572 error = mnt_want_write_file(filp); 573 if (error) 574 return error; 575 error = xfs_ioc_swapext(&sxp); 576 mnt_drop_write_file(filp); 577 return error; 578 } 579 case XFS_IOC_FSBULKSTAT_32: 580 case XFS_IOC_FSBULKSTAT_SINGLE_32: 581 case XFS_IOC_FSINUMBERS_32: 582 return xfs_compat_ioc_fsbulkstat(mp, cmd, arg); 583 case XFS_IOC_FD_TO_HANDLE_32: 584 case XFS_IOC_PATH_TO_HANDLE_32: 585 case XFS_IOC_PATH_TO_FSHANDLE_32: { 586 struct xfs_fsop_handlereq hreq; 587 588 if (xfs_compat_handlereq_copyin(&hreq, arg)) 589 return -EFAULT; 590 cmd = _NATIVE_IOC(cmd, struct xfs_fsop_handlereq); 591 return xfs_find_handle(cmd, &hreq); 592 } 593 case XFS_IOC_OPEN_BY_HANDLE_32: { 594 struct xfs_fsop_handlereq hreq; 595 596 if (xfs_compat_handlereq_copyin(&hreq, arg)) 597 return -EFAULT; 598 return xfs_open_by_handle(filp, &hreq); 599 } 600 case XFS_IOC_READLINK_BY_HANDLE_32: { 601 struct xfs_fsop_handlereq hreq; 602 603 if (xfs_compat_handlereq_copyin(&hreq, arg)) 604 return -EFAULT; 605 return xfs_readlink_by_handle(filp, &hreq); 606 } 607 case XFS_IOC_ATTRLIST_BY_HANDLE_32: 608 return xfs_compat_attrlist_by_handle(filp, arg); 609 case XFS_IOC_ATTRMULTI_BY_HANDLE_32: 610 return xfs_compat_attrmulti_by_handle(filp, arg); 611 default: 612 /* try the native version */ 613 return xfs_file_ioctl(filp, cmd, (unsigned long)arg); 614 } 615 } 616