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