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