2 * Copyright (c) 2004-2005 Silicon Graphics, Inc.
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.
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.
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
18 #include <linux/compat.h>
19 #include <linux/ioctl.h>
20 #include <linux/mount.h>
21 #include <asm/uaccess.h>
27 #include "xfs_trans.h"
31 #include "xfs_dmapi.h"
32 #include "xfs_mount.h"
33 #include "xfs_bmap_btree.h"
34 #include "xfs_attr_sf.h"
35 #include "xfs_dir2_sf.h"
36 #include "xfs_vnode.h"
37 #include "xfs_dinode.h"
38 #include "xfs_inode.h"
39 #include "xfs_itable.h"
40 #include "xfs_error.h"
41 #include "xfs_dfrag.h"
42 #include "xfs_vnodeops.h"
43 #include "xfs_fsops.h"
44 #include "xfs_alloc.h"
45 #include "xfs_rtalloc.h"
47 #include "xfs_ioctl.h"
48 #include "xfs_ioctl32.h"
49 #include "xfs_trace.h"
51 #define _NATIVE_IOC(cmd, type) \
52 _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type))
54 #ifdef BROKEN_X86_ALIGNMENT
56 xfs_compat_flock64_copyin(
58 compat_xfs_flock64_t __user
*arg32
)
60 if (get_user(bf
->l_type
, &arg32
->l_type
) ||
61 get_user(bf
->l_whence
, &arg32
->l_whence
) ||
62 get_user(bf
->l_start
, &arg32
->l_start
) ||
63 get_user(bf
->l_len
, &arg32
->l_len
) ||
64 get_user(bf
->l_sysid
, &arg32
->l_sysid
) ||
65 get_user(bf
->l_pid
, &arg32
->l_pid
) ||
66 copy_from_user(bf
->l_pad
, &arg32
->l_pad
, 4*sizeof(u32
)))
67 return -XFS_ERROR(EFAULT
);
72 xfs_compat_ioc_fsgeometry_v1(
74 compat_xfs_fsop_geom_v1_t __user
*arg32
)
76 xfs_fsop_geom_t fsgeo
;
79 error
= xfs_fs_geometry(mp
, &fsgeo
, 3);
82 /* The 32-bit variant simply has some padding at the end */
83 if (copy_to_user(arg32
, &fsgeo
, sizeof(struct compat_xfs_fsop_geom_v1
)))
84 return -XFS_ERROR(EFAULT
);
89 xfs_compat_growfs_data_copyin(
90 struct xfs_growfs_data
*in
,
91 compat_xfs_growfs_data_t __user
*arg32
)
93 if (get_user(in
->newblocks
, &arg32
->newblocks
) ||
94 get_user(in
->imaxpct
, &arg32
->imaxpct
))
95 return -XFS_ERROR(EFAULT
);
100 xfs_compat_growfs_rt_copyin(
101 struct xfs_growfs_rt
*in
,
102 compat_xfs_growfs_rt_t __user
*arg32
)
104 if (get_user(in
->newblocks
, &arg32
->newblocks
) ||
105 get_user(in
->extsize
, &arg32
->extsize
))
106 return -XFS_ERROR(EFAULT
);
111 xfs_inumbers_fmt_compat(
112 void __user
*ubuffer
,
113 const xfs_inogrp_t
*buffer
,
117 compat_xfs_inogrp_t __user
*p32
= ubuffer
;
120 for (i
= 0; i
< count
; i
++) {
121 if (put_user(buffer
[i
].xi_startino
, &p32
[i
].xi_startino
) ||
122 put_user(buffer
[i
].xi_alloccount
, &p32
[i
].xi_alloccount
) ||
123 put_user(buffer
[i
].xi_allocmask
, &p32
[i
].xi_allocmask
))
124 return -XFS_ERROR(EFAULT
);
126 *written
= count
* sizeof(*p32
);
131 #define xfs_inumbers_fmt_compat xfs_inumbers_fmt
132 #endif /* BROKEN_X86_ALIGNMENT */
135 xfs_ioctl32_bstime_copyin(
136 xfs_bstime_t
*bstime
,
137 compat_xfs_bstime_t __user
*bstime32
)
139 compat_time_t sec32
; /* tv_sec differs on 64 vs. 32 */
141 if (get_user(sec32
, &bstime32
->tv_sec
) ||
142 get_user(bstime
->tv_nsec
, &bstime32
->tv_nsec
))
143 return -XFS_ERROR(EFAULT
);
144 bstime
->tv_sec
= sec32
;
148 /* xfs_bstat_t has differing alignment on intel, & bstime_t sizes everywhere */
150 xfs_ioctl32_bstat_copyin(
152 compat_xfs_bstat_t __user
*bstat32
)
154 if (get_user(bstat
->bs_ino
, &bstat32
->bs_ino
) ||
155 get_user(bstat
->bs_mode
, &bstat32
->bs_mode
) ||
156 get_user(bstat
->bs_nlink
, &bstat32
->bs_nlink
) ||
157 get_user(bstat
->bs_uid
, &bstat32
->bs_uid
) ||
158 get_user(bstat
->bs_gid
, &bstat32
->bs_gid
) ||
159 get_user(bstat
->bs_rdev
, &bstat32
->bs_rdev
) ||
160 get_user(bstat
->bs_blksize
, &bstat32
->bs_blksize
) ||
161 get_user(bstat
->bs_size
, &bstat32
->bs_size
) ||
162 xfs_ioctl32_bstime_copyin(&bstat
->bs_atime
, &bstat32
->bs_atime
) ||
163 xfs_ioctl32_bstime_copyin(&bstat
->bs_mtime
, &bstat32
->bs_mtime
) ||
164 xfs_ioctl32_bstime_copyin(&bstat
->bs_ctime
, &bstat32
->bs_ctime
) ||
165 get_user(bstat
->bs_blocks
, &bstat32
->bs_size
) ||
166 get_user(bstat
->bs_xflags
, &bstat32
->bs_size
) ||
167 get_user(bstat
->bs_extsize
, &bstat32
->bs_extsize
) ||
168 get_user(bstat
->bs_extents
, &bstat32
->bs_extents
) ||
169 get_user(bstat
->bs_gen
, &bstat32
->bs_gen
) ||
170 get_user(bstat
->bs_projid
, &bstat32
->bs_projid
) ||
171 get_user(bstat
->bs_dmevmask
, &bstat32
->bs_dmevmask
) ||
172 get_user(bstat
->bs_dmstate
, &bstat32
->bs_dmstate
) ||
173 get_user(bstat
->bs_aextents
, &bstat32
->bs_aextents
))
174 return -XFS_ERROR(EFAULT
);
178 /* XFS_IOC_FSBULKSTAT and friends */
181 xfs_bstime_store_compat(
182 compat_xfs_bstime_t __user
*p32
,
183 const xfs_bstime_t
*p
)
188 if (put_user(sec32
, &p32
->tv_sec
) ||
189 put_user(p
->tv_nsec
, &p32
->tv_nsec
))
190 return -XFS_ERROR(EFAULT
);
194 /* Return 0 on success or positive error (to xfs_bulkstat()) */
196 xfs_bulkstat_one_fmt_compat(
197 void __user
*ubuffer
,
200 const xfs_bstat_t
*buffer
)
202 compat_xfs_bstat_t __user
*p32
= ubuffer
;
204 if (ubsize
< sizeof(*p32
))
205 return XFS_ERROR(ENOMEM
);
207 if (put_user(buffer
->bs_ino
, &p32
->bs_ino
) ||
208 put_user(buffer
->bs_mode
, &p32
->bs_mode
) ||
209 put_user(buffer
->bs_nlink
, &p32
->bs_nlink
) ||
210 put_user(buffer
->bs_uid
, &p32
->bs_uid
) ||
211 put_user(buffer
->bs_gid
, &p32
->bs_gid
) ||
212 put_user(buffer
->bs_rdev
, &p32
->bs_rdev
) ||
213 put_user(buffer
->bs_blksize
, &p32
->bs_blksize
) ||
214 put_user(buffer
->bs_size
, &p32
->bs_size
) ||
215 xfs_bstime_store_compat(&p32
->bs_atime
, &buffer
->bs_atime
) ||
216 xfs_bstime_store_compat(&p32
->bs_mtime
, &buffer
->bs_mtime
) ||
217 xfs_bstime_store_compat(&p32
->bs_ctime
, &buffer
->bs_ctime
) ||
218 put_user(buffer
->bs_blocks
, &p32
->bs_blocks
) ||
219 put_user(buffer
->bs_xflags
, &p32
->bs_xflags
) ||
220 put_user(buffer
->bs_extsize
, &p32
->bs_extsize
) ||
221 put_user(buffer
->bs_extents
, &p32
->bs_extents
) ||
222 put_user(buffer
->bs_gen
, &p32
->bs_gen
) ||
223 put_user(buffer
->bs_projid
, &p32
->bs_projid
) ||
224 put_user(buffer
->bs_dmevmask
, &p32
->bs_dmevmask
) ||
225 put_user(buffer
->bs_dmstate
, &p32
->bs_dmstate
) ||
226 put_user(buffer
->bs_aextents
, &p32
->bs_aextents
))
227 return XFS_ERROR(EFAULT
);
229 *ubused
= sizeof(*p32
);
234 xfs_bulkstat_one_compat(
235 xfs_mount_t
*mp
, /* mount point for filesystem */
236 xfs_ino_t ino
, /* inode number to get data for */
237 void __user
*buffer
, /* buffer to place output in */
238 int ubsize
, /* size of buffer */
239 void *private_data
, /* my private data */
240 xfs_daddr_t bno
, /* starting bno of inode cluster */
241 int *ubused
, /* bytes used by me */
242 void *dibuff
, /* on-disk inode buffer */
243 int *stat
) /* BULKSTAT_RV_... */
245 return xfs_bulkstat_one_int(mp
, ino
, buffer
, ubsize
,
246 xfs_bulkstat_one_fmt_compat
, bno
,
247 ubused
, dibuff
, stat
);
250 /* copied from xfs_ioctl.c */
252 xfs_compat_ioc_bulkstat(
255 compat_xfs_fsop_bulkreq_t __user
*p32
)
258 xfs_fsop_bulkreq_t bulkreq
;
259 int count
; /* # of records returned */
260 xfs_ino_t inlast
; /* last inode number */
264 /* done = 1 if there are more stats to get and if bulkstat */
265 /* should be called again (unused here, but used in dmapi) */
267 if (!capable(CAP_SYS_ADMIN
))
268 return -XFS_ERROR(EPERM
);
270 if (XFS_FORCED_SHUTDOWN(mp
))
271 return -XFS_ERROR(EIO
);
273 if (get_user(addr
, &p32
->lastip
))
274 return -XFS_ERROR(EFAULT
);
275 bulkreq
.lastip
= compat_ptr(addr
);
276 if (get_user(bulkreq
.icount
, &p32
->icount
) ||
277 get_user(addr
, &p32
->ubuffer
))
278 return -XFS_ERROR(EFAULT
);
279 bulkreq
.ubuffer
= compat_ptr(addr
);
280 if (get_user(addr
, &p32
->ocount
))
281 return -XFS_ERROR(EFAULT
);
282 bulkreq
.ocount
= compat_ptr(addr
);
284 if (copy_from_user(&inlast
, bulkreq
.lastip
, sizeof(__s64
)))
285 return -XFS_ERROR(EFAULT
);
287 if ((count
= bulkreq
.icount
) <= 0)
288 return -XFS_ERROR(EINVAL
);
290 if (bulkreq
.ubuffer
== NULL
)
291 return -XFS_ERROR(EINVAL
);
293 if (cmd
== XFS_IOC_FSINUMBERS_32
) {
294 error
= xfs_inumbers(mp
, &inlast
, &count
,
295 bulkreq
.ubuffer
, xfs_inumbers_fmt_compat
);
296 } else if (cmd
== XFS_IOC_FSBULKSTAT_SINGLE_32
) {
299 error
= xfs_bulkstat_one_compat(mp
, inlast
, bulkreq
.ubuffer
,
300 sizeof(compat_xfs_bstat_t
),
301 NULL
, 0, NULL
, NULL
, &res
);
302 } else if (cmd
== XFS_IOC_FSBULKSTAT_32
) {
303 error
= xfs_bulkstat(mp
, &inlast
, &count
,
304 xfs_bulkstat_one_compat
, NULL
,
305 sizeof(compat_xfs_bstat_t
), bulkreq
.ubuffer
,
306 BULKSTAT_FG_QUICK
, &done
);
308 error
= XFS_ERROR(EINVAL
);
312 if (bulkreq
.ocount
!= NULL
) {
313 if (copy_to_user(bulkreq
.lastip
, &inlast
,
315 return -XFS_ERROR(EFAULT
);
317 if (copy_to_user(bulkreq
.ocount
, &count
, sizeof(count
)))
318 return -XFS_ERROR(EFAULT
);
325 xfs_compat_handlereq_copyin(
326 xfs_fsop_handlereq_t
*hreq
,
327 compat_xfs_fsop_handlereq_t __user
*arg32
)
329 compat_xfs_fsop_handlereq_t hreq32
;
331 if (copy_from_user(&hreq32
, arg32
, sizeof(compat_xfs_fsop_handlereq_t
)))
332 return -XFS_ERROR(EFAULT
);
334 hreq
->fd
= hreq32
.fd
;
335 hreq
->path
= compat_ptr(hreq32
.path
);
336 hreq
->oflags
= hreq32
.oflags
;
337 hreq
->ihandle
= compat_ptr(hreq32
.ihandle
);
338 hreq
->ihandlen
= hreq32
.ihandlen
;
339 hreq
->ohandle
= compat_ptr(hreq32
.ohandle
);
340 hreq
->ohandlen
= compat_ptr(hreq32
.ohandlen
);
345 STATIC
struct dentry
*
346 xfs_compat_handlereq_to_dentry(
347 struct file
*parfilp
,
348 compat_xfs_fsop_handlereq_t
*hreq
)
350 return xfs_handle_to_dentry(parfilp
,
351 compat_ptr(hreq
->ihandle
), hreq
->ihandlen
);
355 xfs_compat_attrlist_by_handle(
356 struct file
*parfilp
,
360 attrlist_cursor_kern_t
*cursor
;
361 compat_xfs_fsop_attrlist_handlereq_t al_hreq
;
362 struct dentry
*dentry
;
365 if (!capable(CAP_SYS_ADMIN
))
366 return -XFS_ERROR(EPERM
);
367 if (copy_from_user(&al_hreq
, arg
,
368 sizeof(compat_xfs_fsop_attrlist_handlereq_t
)))
369 return -XFS_ERROR(EFAULT
);
370 if (al_hreq
.buflen
> XATTR_LIST_MAX
)
371 return -XFS_ERROR(EINVAL
);
374 * Reject flags, only allow namespaces.
376 if (al_hreq
.flags
& ~(ATTR_ROOT
| ATTR_SECURE
))
377 return -XFS_ERROR(EINVAL
);
379 dentry
= xfs_compat_handlereq_to_dentry(parfilp
, &al_hreq
.hreq
);
381 return PTR_ERR(dentry
);
384 kbuf
= kmalloc(al_hreq
.buflen
, GFP_KERNEL
);
388 cursor
= (attrlist_cursor_kern_t
*)&al_hreq
.pos
;
389 error
= -xfs_attr_list(XFS_I(dentry
->d_inode
), kbuf
, al_hreq
.buflen
,
390 al_hreq
.flags
, cursor
);
394 if (copy_to_user(compat_ptr(al_hreq
.buffer
), kbuf
, al_hreq
.buflen
))
405 xfs_compat_attrmulti_by_handle(
406 struct file
*parfilp
,
410 compat_xfs_attr_multiop_t
*ops
;
411 compat_xfs_fsop_attrmulti_handlereq_t am_hreq
;
412 struct dentry
*dentry
;
413 unsigned int i
, size
;
416 if (!capable(CAP_SYS_ADMIN
))
417 return -XFS_ERROR(EPERM
);
418 if (copy_from_user(&am_hreq
, arg
,
419 sizeof(compat_xfs_fsop_attrmulti_handlereq_t
)))
420 return -XFS_ERROR(EFAULT
);
422 dentry
= xfs_compat_handlereq_to_dentry(parfilp
, &am_hreq
.hreq
);
424 return PTR_ERR(dentry
);
427 size
= am_hreq
.opcount
* sizeof(compat_xfs_attr_multiop_t
);
428 if (!size
|| size
> 16 * PAGE_SIZE
)
431 ops
= memdup_user(compat_ptr(am_hreq
.ops
), size
);
433 error
= PTR_ERR(ops
);
437 attr_name
= kmalloc(MAXNAMELEN
, GFP_KERNEL
);
442 for (i
= 0; i
< am_hreq
.opcount
; i
++) {
443 ops
[i
].am_error
= strncpy_from_user(attr_name
,
444 compat_ptr(ops
[i
].am_attrname
),
446 if (ops
[i
].am_error
== 0 || ops
[i
].am_error
== MAXNAMELEN
)
448 if (ops
[i
].am_error
< 0)
451 switch (ops
[i
].am_opcode
) {
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
);
459 ops
[i
].am_error
= mnt_want_write(parfilp
->f_path
.mnt
);
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(parfilp
->f_path
.mnt
);
469 ops
[i
].am_error
= mnt_want_write(parfilp
->f_path
.mnt
);
472 ops
[i
].am_error
= xfs_attrmulti_attr_remove(
473 dentry
->d_inode
, attr_name
,
475 mnt_drop_write(parfilp
->f_path
.mnt
);
478 ops
[i
].am_error
= EINVAL
;
482 if (copy_to_user(compat_ptr(am_hreq
.ops
), ops
, size
))
483 error
= XFS_ERROR(EFAULT
);
494 xfs_compat_fssetdm_by_handle(
495 struct file
*parfilp
,
499 struct fsdmidata fsd
;
500 compat_xfs_fsop_setdm_handlereq_t dmhreq
;
501 struct dentry
*dentry
;
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
);
509 dentry
= xfs_compat_handlereq_to_dentry(parfilp
, &dmhreq
.hreq
);
511 return PTR_ERR(dentry
);
513 if (IS_IMMUTABLE(dentry
->d_inode
) || IS_APPEND(dentry
->d_inode
)) {
514 error
= -XFS_ERROR(EPERM
);
518 if (copy_from_user(&fsd
, compat_ptr(dmhreq
.data
), sizeof(fsd
))) {
519 error
= -XFS_ERROR(EFAULT
);
523 error
= -xfs_set_dmattrs(XFS_I(dentry
->d_inode
), fsd
.fsd_dmevmask
,
532 xfs_file_compat_ioctl(
537 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
538 struct xfs_inode
*ip
= XFS_I(inode
);
539 struct xfs_mount
*mp
= ip
->i_mount
;
540 void __user
*arg
= (void __user
*)p
;
544 if (filp
->f_mode
& FMODE_NOCMTIME
)
547 xfs_itrace_entry(ip
);
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
:
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 return xfs_file_ioctl(filp
, cmd
, p
);
583 case XFS_IOC_ALLOCSP_32
:
584 case XFS_IOC_FREESP_32
:
585 case XFS_IOC_ALLOCSP64_32
:
586 case XFS_IOC_FREESP64_32
:
587 case XFS_IOC_RESVSP_32
:
588 case XFS_IOC_UNRESVSP_32
:
589 case XFS_IOC_RESVSP64_32
:
590 case XFS_IOC_UNRESVSP64_32
: {
591 struct xfs_flock64 bf
;
593 if (xfs_compat_flock64_copyin(&bf
, arg
))
594 return -XFS_ERROR(EFAULT
);
595 cmd
= _NATIVE_IOC(cmd
, struct xfs_flock64
);
596 return xfs_ioc_space(ip
, inode
, filp
, ioflags
, cmd
, &bf
);
598 case XFS_IOC_FSGEOMETRY_V1_32
:
599 return xfs_compat_ioc_fsgeometry_v1(mp
, arg
);
600 case XFS_IOC_FSGROWFSDATA_32
: {
601 struct xfs_growfs_data in
;
603 if (xfs_compat_growfs_data_copyin(&in
, arg
))
604 return -XFS_ERROR(EFAULT
);
605 error
= xfs_growfs_data(mp
, &in
);
608 case XFS_IOC_FSGROWFSRT_32
: {
609 struct xfs_growfs_rt in
;
611 if (xfs_compat_growfs_rt_copyin(&in
, arg
))
612 return -XFS_ERROR(EFAULT
);
613 error
= xfs_growfs_rt(mp
, &in
);
617 /* long changes size, but xfs only copiese out 32 bits */
618 case XFS_IOC_GETXFLAGS_32
:
619 case XFS_IOC_SETXFLAGS_32
:
620 case XFS_IOC_GETVERSION_32
:
621 cmd
= _NATIVE_IOC(cmd
, long);
622 return xfs_file_ioctl(filp
, cmd
, p
);
623 case XFS_IOC_SWAPEXT_32
: {
624 struct xfs_swapext sxp
;
625 struct compat_xfs_swapext __user
*sxu
= arg
;
627 /* Bulk copy in up to the sx_stat field, then copy bstat */
628 if (copy_from_user(&sxp
, sxu
,
629 offsetof(struct xfs_swapext
, sx_stat
)) ||
630 xfs_ioctl32_bstat_copyin(&sxp
.sx_stat
, &sxu
->sx_stat
))
631 return -XFS_ERROR(EFAULT
);
632 error
= xfs_swapext(&sxp
);
635 case XFS_IOC_FSBULKSTAT_32
:
636 case XFS_IOC_FSBULKSTAT_SINGLE_32
:
637 case XFS_IOC_FSINUMBERS_32
:
638 return xfs_compat_ioc_bulkstat(mp
, cmd
, arg
);
639 case XFS_IOC_FD_TO_HANDLE_32
:
640 case XFS_IOC_PATH_TO_HANDLE_32
:
641 case XFS_IOC_PATH_TO_FSHANDLE_32
: {
642 struct xfs_fsop_handlereq hreq
;
644 if (xfs_compat_handlereq_copyin(&hreq
, arg
))
645 return -XFS_ERROR(EFAULT
);
646 cmd
= _NATIVE_IOC(cmd
, struct xfs_fsop_handlereq
);
647 return xfs_find_handle(cmd
, &hreq
);
649 case XFS_IOC_OPEN_BY_HANDLE_32
: {
650 struct xfs_fsop_handlereq hreq
;
652 if (xfs_compat_handlereq_copyin(&hreq
, arg
))
653 return -XFS_ERROR(EFAULT
);
654 return xfs_open_by_handle(filp
, &hreq
);
656 case XFS_IOC_READLINK_BY_HANDLE_32
: {
657 struct xfs_fsop_handlereq hreq
;
659 if (xfs_compat_handlereq_copyin(&hreq
, arg
))
660 return -XFS_ERROR(EFAULT
);
661 return xfs_readlink_by_handle(filp
, &hreq
);
663 case XFS_IOC_ATTRLIST_BY_HANDLE_32
:
664 return xfs_compat_attrlist_by_handle(filp
, arg
);
665 case XFS_IOC_ATTRMULTI_BY_HANDLE_32
:
666 return xfs_compat_attrmulti_by_handle(filp
, arg
);
667 case XFS_IOC_FSSETDM_BY_HANDLE_32
:
668 return xfs_compat_fssetdm_by_handle(filp
, arg
);
670 return -XFS_ERROR(ENOIOCTLCMD
);