1 /* 2 * Copyright (c) 2004-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 <linux/compat.h> 19 #include <linux/ioctl.h> 20 #include <linux/mount.h> 21 #include <linux/slab.h> 22 #include <asm/uaccess.h> 23 #include "xfs.h" 24 #include "xfs_fs.h" 25 #include "xfs_format.h" 26 #include "xfs_log_format.h" 27 #include "xfs_trans_resv.h" 28 #include "xfs_mount.h" 29 #include "xfs_inode.h" 30 #include "xfs_itable.h" 31 #include "xfs_error.h" 32 #include "xfs_fsops.h" 33 #include "xfs_alloc.h" 34 #include "xfs_rtalloc.h" 35 #include "xfs_attr.h" 36 #include "xfs_ioctl.h" 37 #include "xfs_ioctl32.h" 38 #include "xfs_trace.h" 39 40 #define _NATIVE_IOC(cmd, type) \ 41 _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type)) 42 43 #ifdef BROKEN_X86_ALIGNMENT 44 STATIC int 45 xfs_compat_flock64_copyin( 46 xfs_flock64_t *bf, 47 compat_xfs_flock64_t __user *arg32) 48 { 49 if (get_user(bf->l_type, &arg32->l_type) || 50 get_user(bf->l_whence, &arg32->l_whence) || 51 get_user(bf->l_start, &arg32->l_start) || 52 get_user(bf->l_len, &arg32->l_len) || 53 get_user(bf->l_sysid, &arg32->l_sysid) || 54 get_user(bf->l_pid, &arg32->l_pid) || 55 copy_from_user(bf->l_pad, &arg32->l_pad, 4*sizeof(u32))) 56 return -EFAULT; 57 return 0; 58 } 59 60 STATIC int 61 xfs_compat_ioc_fsgeometry_v1( 62 struct xfs_mount *mp, 63 compat_xfs_fsop_geom_v1_t __user *arg32) 64 { 65 xfs_fsop_geom_t fsgeo; 66 int error; 67 68 error = xfs_fs_geometry(mp, &fsgeo, 3); 69 if (error) 70 return error; 71 /* The 32-bit variant simply has some padding at the end */ 72 if (copy_to_user(arg32, &fsgeo, sizeof(struct compat_xfs_fsop_geom_v1))) 73 return -EFAULT; 74 return 0; 75 } 76 77 STATIC int 78 xfs_compat_growfs_data_copyin( 79 struct xfs_growfs_data *in, 80 compat_xfs_growfs_data_t __user *arg32) 81 { 82 if (get_user(in->newblocks, &arg32->newblocks) || 83 get_user(in->imaxpct, &arg32->imaxpct)) 84 return -EFAULT; 85 return 0; 86 } 87 88 STATIC int 89 xfs_compat_growfs_rt_copyin( 90 struct xfs_growfs_rt *in, 91 compat_xfs_growfs_rt_t __user *arg32) 92 { 93 if (get_user(in->newblocks, &arg32->newblocks) || 94 get_user(in->extsize, &arg32->extsize)) 95 return -EFAULT; 96 return 0; 97 } 98 99 STATIC int 100 xfs_inumbers_fmt_compat( 101 void __user *ubuffer, 102 const struct xfs_inogrp *buffer, 103 long count, 104 long *written) 105 { 106 compat_xfs_inogrp_t __user *p32 = ubuffer; 107 long i; 108 109 for (i = 0; i < count; i++) { 110 if (put_user(buffer[i].xi_startino, &p32[i].xi_startino) || 111 put_user(buffer[i].xi_alloccount, &p32[i].xi_alloccount) || 112 put_user(buffer[i].xi_allocmask, &p32[i].xi_allocmask)) 113 return -EFAULT; 114 } 115 *written = count * sizeof(*p32); 116 return 0; 117 } 118 119 #else 120 #define xfs_inumbers_fmt_compat xfs_inumbers_fmt 121 #endif /* BROKEN_X86_ALIGNMENT */ 122 123 STATIC int 124 xfs_ioctl32_bstime_copyin( 125 xfs_bstime_t *bstime, 126 compat_xfs_bstime_t __user *bstime32) 127 { 128 compat_time_t sec32; /* tv_sec differs on 64 vs. 32 */ 129 130 if (get_user(sec32, &bstime32->tv_sec) || 131 get_user(bstime->tv_nsec, &bstime32->tv_nsec)) 132 return -EFAULT; 133 bstime->tv_sec = sec32; 134 return 0; 135 } 136 137 /* xfs_bstat_t has differing alignment on intel, & bstime_t sizes everywhere */ 138 STATIC int 139 xfs_ioctl32_bstat_copyin( 140 xfs_bstat_t *bstat, 141 compat_xfs_bstat_t __user *bstat32) 142 { 143 if (get_user(bstat->bs_ino, &bstat32->bs_ino) || 144 get_user(bstat->bs_mode, &bstat32->bs_mode) || 145 get_user(bstat->bs_nlink, &bstat32->bs_nlink) || 146 get_user(bstat->bs_uid, &bstat32->bs_uid) || 147 get_user(bstat->bs_gid, &bstat32->bs_gid) || 148 get_user(bstat->bs_rdev, &bstat32->bs_rdev) || 149 get_user(bstat->bs_blksize, &bstat32->bs_blksize) || 150 get_user(bstat->bs_size, &bstat32->bs_size) || 151 xfs_ioctl32_bstime_copyin(&bstat->bs_atime, &bstat32->bs_atime) || 152 xfs_ioctl32_bstime_copyin(&bstat->bs_mtime, &bstat32->bs_mtime) || 153 xfs_ioctl32_bstime_copyin(&bstat->bs_ctime, &bstat32->bs_ctime) || 154 get_user(bstat->bs_blocks, &bstat32->bs_size) || 155 get_user(bstat->bs_xflags, &bstat32->bs_size) || 156 get_user(bstat->bs_extsize, &bstat32->bs_extsize) || 157 get_user(bstat->bs_extents, &bstat32->bs_extents) || 158 get_user(bstat->bs_gen, &bstat32->bs_gen) || 159 get_user(bstat->bs_projid_lo, &bstat32->bs_projid_lo) || 160 get_user(bstat->bs_projid_hi, &bstat32->bs_projid_hi) || 161 get_user(bstat->bs_forkoff, &bstat32->bs_forkoff) || 162 get_user(bstat->bs_dmevmask, &bstat32->bs_dmevmask) || 163 get_user(bstat->bs_dmstate, &bstat32->bs_dmstate) || 164 get_user(bstat->bs_aextents, &bstat32->bs_aextents)) 165 return -EFAULT; 166 return 0; 167 } 168 169 /* XFS_IOC_FSBULKSTAT and friends */ 170 171 STATIC int 172 xfs_bstime_store_compat( 173 compat_xfs_bstime_t __user *p32, 174 const xfs_bstime_t *p) 175 { 176 __s32 sec32; 177 178 sec32 = p->tv_sec; 179 if (put_user(sec32, &p32->tv_sec) || 180 put_user(p->tv_nsec, &p32->tv_nsec)) 181 return -EFAULT; 182 return 0; 183 } 184 185 /* Return 0 on success or positive error (to xfs_bulkstat()) */ 186 STATIC int 187 xfs_bulkstat_one_fmt_compat( 188 void __user *ubuffer, 189 int ubsize, 190 int *ubused, 191 const xfs_bstat_t *buffer) 192 { 193 compat_xfs_bstat_t __user *p32 = ubuffer; 194 195 if (ubsize < sizeof(*p32)) 196 return -ENOMEM; 197 198 if (put_user(buffer->bs_ino, &p32->bs_ino) || 199 put_user(buffer->bs_mode, &p32->bs_mode) || 200 put_user(buffer->bs_nlink, &p32->bs_nlink) || 201 put_user(buffer->bs_uid, &p32->bs_uid) || 202 put_user(buffer->bs_gid, &p32->bs_gid) || 203 put_user(buffer->bs_rdev, &p32->bs_rdev) || 204 put_user(buffer->bs_blksize, &p32->bs_blksize) || 205 put_user(buffer->bs_size, &p32->bs_size) || 206 xfs_bstime_store_compat(&p32->bs_atime, &buffer->bs_atime) || 207 xfs_bstime_store_compat(&p32->bs_mtime, &buffer->bs_mtime) || 208 xfs_bstime_store_compat(&p32->bs_ctime, &buffer->bs_ctime) || 209 put_user(buffer->bs_blocks, &p32->bs_blocks) || 210 put_user(buffer->bs_xflags, &p32->bs_xflags) || 211 put_user(buffer->bs_extsize, &p32->bs_extsize) || 212 put_user(buffer->bs_extents, &p32->bs_extents) || 213 put_user(buffer->bs_gen, &p32->bs_gen) || 214 put_user(buffer->bs_projid, &p32->bs_projid) || 215 put_user(buffer->bs_projid_hi, &p32->bs_projid_hi) || 216 put_user(buffer->bs_forkoff, &p32->bs_forkoff) || 217 put_user(buffer->bs_dmevmask, &p32->bs_dmevmask) || 218 put_user(buffer->bs_dmstate, &p32->bs_dmstate) || 219 put_user(buffer->bs_aextents, &p32->bs_aextents)) 220 return -EFAULT; 221 if (ubused) 222 *ubused = sizeof(*p32); 223 return 0; 224 } 225 226 STATIC int 227 xfs_bulkstat_one_compat( 228 xfs_mount_t *mp, /* mount point for filesystem */ 229 xfs_ino_t ino, /* inode number to get data for */ 230 void __user *buffer, /* buffer to place output in */ 231 int ubsize, /* size of buffer */ 232 int *ubused, /* bytes used by me */ 233 int *stat) /* BULKSTAT_RV_... */ 234 { 235 return xfs_bulkstat_one_int(mp, ino, buffer, ubsize, 236 xfs_bulkstat_one_fmt_compat, 237 ubused, stat); 238 } 239 240 /* copied from xfs_ioctl.c */ 241 STATIC int 242 xfs_compat_ioc_bulkstat( 243 xfs_mount_t *mp, 244 unsigned int cmd, 245 compat_xfs_fsop_bulkreq_t __user *p32) 246 { 247 u32 addr; 248 xfs_fsop_bulkreq_t bulkreq; 249 int count; /* # of records returned */ 250 xfs_ino_t inlast; /* last inode number */ 251 int done; 252 int error; 253 254 /* done = 1 if there are more stats to get and if bulkstat */ 255 /* should be called again (unused here, but used in dmapi) */ 256 257 if (!capable(CAP_SYS_ADMIN)) 258 return -EPERM; 259 260 if (XFS_FORCED_SHUTDOWN(mp)) 261 return -EIO; 262 263 if (get_user(addr, &p32->lastip)) 264 return -EFAULT; 265 bulkreq.lastip = compat_ptr(addr); 266 if (get_user(bulkreq.icount, &p32->icount) || 267 get_user(addr, &p32->ubuffer)) 268 return -EFAULT; 269 bulkreq.ubuffer = compat_ptr(addr); 270 if (get_user(addr, &p32->ocount)) 271 return -EFAULT; 272 bulkreq.ocount = compat_ptr(addr); 273 274 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64))) 275 return -EFAULT; 276 277 if ((count = bulkreq.icount) <= 0) 278 return -EINVAL; 279 280 if (bulkreq.ubuffer == NULL) 281 return -EINVAL; 282 283 if (cmd == XFS_IOC_FSINUMBERS_32) { 284 error = xfs_inumbers(mp, &inlast, &count, 285 bulkreq.ubuffer, xfs_inumbers_fmt_compat); 286 } else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE_32) { 287 int res; 288 289 error = xfs_bulkstat_one_compat(mp, inlast, bulkreq.ubuffer, 290 sizeof(compat_xfs_bstat_t), NULL, &res); 291 } else if (cmd == XFS_IOC_FSBULKSTAT_32) { 292 error = xfs_bulkstat(mp, &inlast, &count, 293 xfs_bulkstat_one_compat, sizeof(compat_xfs_bstat_t), 294 bulkreq.ubuffer, &done); 295 } else 296 error = -EINVAL; 297 if (error) 298 return error; 299 300 if (bulkreq.ocount != NULL) { 301 if (copy_to_user(bulkreq.lastip, &inlast, 302 sizeof(xfs_ino_t))) 303 return -EFAULT; 304 305 if (copy_to_user(bulkreq.ocount, &count, sizeof(count))) 306 return -EFAULT; 307 } 308 309 return 0; 310 } 311 312 STATIC int 313 xfs_compat_handlereq_copyin( 314 xfs_fsop_handlereq_t *hreq, 315 compat_xfs_fsop_handlereq_t __user *arg32) 316 { 317 compat_xfs_fsop_handlereq_t hreq32; 318 319 if (copy_from_user(&hreq32, arg32, sizeof(compat_xfs_fsop_handlereq_t))) 320 return -EFAULT; 321 322 hreq->fd = hreq32.fd; 323 hreq->path = compat_ptr(hreq32.path); 324 hreq->oflags = hreq32.oflags; 325 hreq->ihandle = compat_ptr(hreq32.ihandle); 326 hreq->ihandlen = hreq32.ihandlen; 327 hreq->ohandle = compat_ptr(hreq32.ohandle); 328 hreq->ohandlen = compat_ptr(hreq32.ohandlen); 329 330 return 0; 331 } 332 333 STATIC struct dentry * 334 xfs_compat_handlereq_to_dentry( 335 struct file *parfilp, 336 compat_xfs_fsop_handlereq_t *hreq) 337 { 338 return xfs_handle_to_dentry(parfilp, 339 compat_ptr(hreq->ihandle), hreq->ihandlen); 340 } 341 342 STATIC int 343 xfs_compat_attrlist_by_handle( 344 struct file *parfilp, 345 void __user *arg) 346 { 347 int error; 348 attrlist_cursor_kern_t *cursor; 349 compat_xfs_fsop_attrlist_handlereq_t al_hreq; 350 struct dentry *dentry; 351 char *kbuf; 352 353 if (!capable(CAP_SYS_ADMIN)) 354 return -EPERM; 355 if (copy_from_user(&al_hreq, arg, 356 sizeof(compat_xfs_fsop_attrlist_handlereq_t))) 357 return -EFAULT; 358 if (al_hreq.buflen < sizeof(struct attrlist) || 359 al_hreq.buflen > XATTR_LIST_MAX) 360 return -EINVAL; 361 362 /* 363 * Reject flags, only allow namespaces. 364 */ 365 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE)) 366 return -EINVAL; 367 368 dentry = xfs_compat_handlereq_to_dentry(parfilp, &al_hreq.hreq); 369 if (IS_ERR(dentry)) 370 return PTR_ERR(dentry); 371 372 error = -ENOMEM; 373 kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP); 374 if (!kbuf) 375 goto out_dput; 376 377 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos; 378 error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen, 379 al_hreq.flags, cursor); 380 if (error) 381 goto out_kfree; 382 383 if (copy_to_user(compat_ptr(al_hreq.buffer), kbuf, al_hreq.buflen)) 384 error = -EFAULT; 385 386 out_kfree: 387 kmem_free(kbuf); 388 out_dput: 389 dput(dentry); 390 return error; 391 } 392 393 STATIC int 394 xfs_compat_attrmulti_by_handle( 395 struct file *parfilp, 396 void __user *arg) 397 { 398 int error; 399 compat_xfs_attr_multiop_t *ops; 400 compat_xfs_fsop_attrmulti_handlereq_t am_hreq; 401 struct dentry *dentry; 402 unsigned int i, size; 403 unsigned char *attr_name; 404 405 if (!capable(CAP_SYS_ADMIN)) 406 return -EPERM; 407 if (copy_from_user(&am_hreq, arg, 408 sizeof(compat_xfs_fsop_attrmulti_handlereq_t))) 409 return -EFAULT; 410 411 /* overflow check */ 412 if (am_hreq.opcount >= INT_MAX / sizeof(compat_xfs_attr_multiop_t)) 413 return -E2BIG; 414 415 dentry = xfs_compat_handlereq_to_dentry(parfilp, &am_hreq.hreq); 416 if (IS_ERR(dentry)) 417 return PTR_ERR(dentry); 418 419 error = -E2BIG; 420 size = am_hreq.opcount * sizeof(compat_xfs_attr_multiop_t); 421 if (!size || size > 16 * PAGE_SIZE) 422 goto out_dput; 423 424 ops = memdup_user(compat_ptr(am_hreq.ops), size); 425 if (IS_ERR(ops)) { 426 error = PTR_ERR(ops); 427 goto out_dput; 428 } 429 430 error = -ENOMEM; 431 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL); 432 if (!attr_name) 433 goto out_kfree_ops; 434 435 error = 0; 436 for (i = 0; i < am_hreq.opcount; i++) { 437 ops[i].am_error = strncpy_from_user((char *)attr_name, 438 compat_ptr(ops[i].am_attrname), 439 MAXNAMELEN); 440 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN) 441 error = -ERANGE; 442 if (ops[i].am_error < 0) 443 break; 444 445 switch (ops[i].am_opcode) { 446 case ATTR_OP_GET: 447 ops[i].am_error = xfs_attrmulti_attr_get( 448 d_inode(dentry), attr_name, 449 compat_ptr(ops[i].am_attrvalue), 450 &ops[i].am_length, ops[i].am_flags); 451 break; 452 case ATTR_OP_SET: 453 ops[i].am_error = mnt_want_write_file(parfilp); 454 if (ops[i].am_error) 455 break; 456 ops[i].am_error = xfs_attrmulti_attr_set( 457 d_inode(dentry), attr_name, 458 compat_ptr(ops[i].am_attrvalue), 459 ops[i].am_length, ops[i].am_flags); 460 mnt_drop_write_file(parfilp); 461 break; 462 case ATTR_OP_REMOVE: 463 ops[i].am_error = mnt_want_write_file(parfilp); 464 if (ops[i].am_error) 465 break; 466 ops[i].am_error = xfs_attrmulti_attr_remove( 467 d_inode(dentry), attr_name, 468 ops[i].am_flags); 469 mnt_drop_write_file(parfilp); 470 break; 471 default: 472 ops[i].am_error = -EINVAL; 473 } 474 } 475 476 if (copy_to_user(compat_ptr(am_hreq.ops), ops, size)) 477 error = -EFAULT; 478 479 kfree(attr_name); 480 out_kfree_ops: 481 kfree(ops); 482 out_dput: 483 dput(dentry); 484 return error; 485 } 486 487 STATIC int 488 xfs_compat_fssetdm_by_handle( 489 struct file *parfilp, 490 void __user *arg) 491 { 492 int error; 493 struct fsdmidata fsd; 494 compat_xfs_fsop_setdm_handlereq_t dmhreq; 495 struct dentry *dentry; 496 497 if (!capable(CAP_MKNOD)) 498 return -EPERM; 499 if (copy_from_user(&dmhreq, arg, 500 sizeof(compat_xfs_fsop_setdm_handlereq_t))) 501 return -EFAULT; 502 503 dentry = xfs_compat_handlereq_to_dentry(parfilp, &dmhreq.hreq); 504 if (IS_ERR(dentry)) 505 return PTR_ERR(dentry); 506 507 if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) { 508 error = -EPERM; 509 goto out; 510 } 511 512 if (copy_from_user(&fsd, compat_ptr(dmhreq.data), sizeof(fsd))) { 513 error = -EFAULT; 514 goto out; 515 } 516 517 error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask, 518 fsd.fsd_dmstate); 519 520 out: 521 dput(dentry); 522 return error; 523 } 524 525 long 526 xfs_file_compat_ioctl( 527 struct file *filp, 528 unsigned cmd, 529 unsigned long p) 530 { 531 struct inode *inode = file_inode(filp); 532 struct xfs_inode *ip = XFS_I(inode); 533 struct xfs_mount *mp = ip->i_mount; 534 void __user *arg = (void __user *)p; 535 int ioflags = 0; 536 int error; 537 538 if (filp->f_mode & FMODE_NOCMTIME) 539 ioflags |= XFS_IO_INVIS; 540 541 trace_xfs_file_compat_ioctl(ip); 542 543 switch (cmd) { 544 /* No size or alignment issues on any arch */ 545 case XFS_IOC_DIOINFO: 546 case XFS_IOC_FSGEOMETRY: 547 case XFS_IOC_FSGETXATTR: 548 case XFS_IOC_FSSETXATTR: 549 case XFS_IOC_FSGETXATTRA: 550 case XFS_IOC_FSSETDM: 551 case XFS_IOC_GETBMAP: 552 case XFS_IOC_GETBMAPA: 553 case XFS_IOC_GETBMAPX: 554 case XFS_IOC_FSCOUNTS: 555 case XFS_IOC_SET_RESBLKS: 556 case XFS_IOC_GET_RESBLKS: 557 case XFS_IOC_FSGROWFSLOG: 558 case XFS_IOC_GOINGDOWN: 559 case XFS_IOC_ERROR_INJECTION: 560 case XFS_IOC_ERROR_CLEARALL: 561 return xfs_file_ioctl(filp, cmd, p); 562 #ifndef BROKEN_X86_ALIGNMENT 563 /* These are handled fine if no alignment issues */ 564 case XFS_IOC_ALLOCSP: 565 case XFS_IOC_FREESP: 566 case XFS_IOC_RESVSP: 567 case XFS_IOC_UNRESVSP: 568 case XFS_IOC_ALLOCSP64: 569 case XFS_IOC_FREESP64: 570 case XFS_IOC_RESVSP64: 571 case XFS_IOC_UNRESVSP64: 572 case XFS_IOC_FSGEOMETRY_V1: 573 case XFS_IOC_FSGROWFSDATA: 574 case XFS_IOC_FSGROWFSRT: 575 case XFS_IOC_ZERO_RANGE: 576 return xfs_file_ioctl(filp, cmd, p); 577 #else 578 case XFS_IOC_ALLOCSP_32: 579 case XFS_IOC_FREESP_32: 580 case XFS_IOC_ALLOCSP64_32: 581 case XFS_IOC_FREESP64_32: 582 case XFS_IOC_RESVSP_32: 583 case XFS_IOC_UNRESVSP_32: 584 case XFS_IOC_RESVSP64_32: 585 case XFS_IOC_UNRESVSP64_32: 586 case XFS_IOC_ZERO_RANGE_32: { 587 struct xfs_flock64 bf; 588 589 if (xfs_compat_flock64_copyin(&bf, arg)) 590 return -EFAULT; 591 cmd = _NATIVE_IOC(cmd, struct xfs_flock64); 592 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf); 593 } 594 case XFS_IOC_FSGEOMETRY_V1_32: 595 return xfs_compat_ioc_fsgeometry_v1(mp, arg); 596 case XFS_IOC_FSGROWFSDATA_32: { 597 struct xfs_growfs_data in; 598 599 if (xfs_compat_growfs_data_copyin(&in, arg)) 600 return -EFAULT; 601 error = mnt_want_write_file(filp); 602 if (error) 603 return error; 604 error = xfs_growfs_data(mp, &in); 605 mnt_drop_write_file(filp); 606 return error; 607 } 608 case XFS_IOC_FSGROWFSRT_32: { 609 struct xfs_growfs_rt in; 610 611 if (xfs_compat_growfs_rt_copyin(&in, arg)) 612 return -EFAULT; 613 error = mnt_want_write_file(filp); 614 if (error) 615 return error; 616 error = xfs_growfs_rt(mp, &in); 617 mnt_drop_write_file(filp); 618 return error; 619 } 620 #endif 621 /* long changes size, but xfs only copiese out 32 bits */ 622 case XFS_IOC_GETXFLAGS_32: 623 case XFS_IOC_SETXFLAGS_32: 624 case XFS_IOC_GETVERSION_32: 625 cmd = _NATIVE_IOC(cmd, long); 626 return xfs_file_ioctl(filp, cmd, p); 627 case XFS_IOC_SWAPEXT_32: { 628 struct xfs_swapext sxp; 629 struct compat_xfs_swapext __user *sxu = arg; 630 631 /* Bulk copy in up to the sx_stat field, then copy bstat */ 632 if (copy_from_user(&sxp, sxu, 633 offsetof(struct xfs_swapext, sx_stat)) || 634 xfs_ioctl32_bstat_copyin(&sxp.sx_stat, &sxu->sx_stat)) 635 return -EFAULT; 636 error = mnt_want_write_file(filp); 637 if (error) 638 return error; 639 error = xfs_ioc_swapext(&sxp); 640 mnt_drop_write_file(filp); 641 return error; 642 } 643 case XFS_IOC_FSBULKSTAT_32: 644 case XFS_IOC_FSBULKSTAT_SINGLE_32: 645 case XFS_IOC_FSINUMBERS_32: 646 return xfs_compat_ioc_bulkstat(mp, cmd, arg); 647 case XFS_IOC_FD_TO_HANDLE_32: 648 case XFS_IOC_PATH_TO_HANDLE_32: 649 case XFS_IOC_PATH_TO_FSHANDLE_32: { 650 struct xfs_fsop_handlereq hreq; 651 652 if (xfs_compat_handlereq_copyin(&hreq, arg)) 653 return -EFAULT; 654 cmd = _NATIVE_IOC(cmd, struct xfs_fsop_handlereq); 655 return xfs_find_handle(cmd, &hreq); 656 } 657 case XFS_IOC_OPEN_BY_HANDLE_32: { 658 struct xfs_fsop_handlereq hreq; 659 660 if (xfs_compat_handlereq_copyin(&hreq, arg)) 661 return -EFAULT; 662 return xfs_open_by_handle(filp, &hreq); 663 } 664 case XFS_IOC_READLINK_BY_HANDLE_32: { 665 struct xfs_fsop_handlereq hreq; 666 667 if (xfs_compat_handlereq_copyin(&hreq, arg)) 668 return -EFAULT; 669 return xfs_readlink_by_handle(filp, &hreq); 670 } 671 case XFS_IOC_ATTRLIST_BY_HANDLE_32: 672 return xfs_compat_attrlist_by_handle(filp, arg); 673 case XFS_IOC_ATTRMULTI_BY_HANDLE_32: 674 return xfs_compat_attrmulti_by_handle(filp, arg); 675 case XFS_IOC_FSSETDM_BY_HANDLE_32: 676 return xfs_compat_fssetdm_by_handle(filp, arg); 677 default: 678 return -ENOIOCTLCMD; 679 } 680 } 681