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 <linux/slab.h>
22 #include <asm/uaccess.h>
27 #include "xfs_trans.h"
30 #include "xfs_mount.h"
31 #include "xfs_bmap_btree.h"
32 #include "xfs_vnode.h"
33 #include "xfs_dinode.h"
34 #include "xfs_inode.h"
35 #include "xfs_itable.h"
36 #include "xfs_error.h"
37 #include "xfs_dfrag.h"
38 #include "xfs_vnodeops.h"
39 #include "xfs_fsops.h"
40 #include "xfs_alloc.h"
41 #include "xfs_rtalloc.h"
43 #include "xfs_ioctl.h"
44 #include "xfs_ioctl32.h"
45 #include "xfs_trace.h"
47 #define _NATIVE_IOC(cmd, type) \
48 _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type))
50 #ifdef BROKEN_X86_ALIGNMENT
52 xfs_compat_flock64_copyin(
54 compat_xfs_flock64_t __user
*arg32
)
56 if (get_user(bf
->l_type
, &arg32
->l_type
) ||
57 get_user(bf
->l_whence
, &arg32
->l_whence
) ||
58 get_user(bf
->l_start
, &arg32
->l_start
) ||
59 get_user(bf
->l_len
, &arg32
->l_len
) ||
60 get_user(bf
->l_sysid
, &arg32
->l_sysid
) ||
61 get_user(bf
->l_pid
, &arg32
->l_pid
) ||
62 copy_from_user(bf
->l_pad
, &arg32
->l_pad
, 4*sizeof(u32
)))
63 return -XFS_ERROR(EFAULT
);
68 xfs_compat_ioc_fsgeometry_v1(
70 compat_xfs_fsop_geom_v1_t __user
*arg32
)
72 xfs_fsop_geom_t fsgeo
;
75 error
= xfs_fs_geometry(mp
, &fsgeo
, 3);
78 /* The 32-bit variant simply has some padding at the end */
79 if (copy_to_user(arg32
, &fsgeo
, sizeof(struct compat_xfs_fsop_geom_v1
)))
80 return -XFS_ERROR(EFAULT
);
85 xfs_compat_growfs_data_copyin(
86 struct xfs_growfs_data
*in
,
87 compat_xfs_growfs_data_t __user
*arg32
)
89 if (get_user(in
->newblocks
, &arg32
->newblocks
) ||
90 get_user(in
->imaxpct
, &arg32
->imaxpct
))
91 return -XFS_ERROR(EFAULT
);
96 xfs_compat_growfs_rt_copyin(
97 struct xfs_growfs_rt
*in
,
98 compat_xfs_growfs_rt_t __user
*arg32
)
100 if (get_user(in
->newblocks
, &arg32
->newblocks
) ||
101 get_user(in
->extsize
, &arg32
->extsize
))
102 return -XFS_ERROR(EFAULT
);
107 xfs_inumbers_fmt_compat(
108 void __user
*ubuffer
,
109 const xfs_inogrp_t
*buffer
,
113 compat_xfs_inogrp_t __user
*p32
= ubuffer
;
116 for (i
= 0; i
< count
; i
++) {
117 if (put_user(buffer
[i
].xi_startino
, &p32
[i
].xi_startino
) ||
118 put_user(buffer
[i
].xi_alloccount
, &p32
[i
].xi_alloccount
) ||
119 put_user(buffer
[i
].xi_allocmask
, &p32
[i
].xi_allocmask
))
120 return -XFS_ERROR(EFAULT
);
122 *written
= count
* sizeof(*p32
);
127 #define xfs_inumbers_fmt_compat xfs_inumbers_fmt
128 #endif /* BROKEN_X86_ALIGNMENT */
131 xfs_ioctl32_bstime_copyin(
132 xfs_bstime_t
*bstime
,
133 compat_xfs_bstime_t __user
*bstime32
)
135 compat_time_t sec32
; /* tv_sec differs on 64 vs. 32 */
137 if (get_user(sec32
, &bstime32
->tv_sec
) ||
138 get_user(bstime
->tv_nsec
, &bstime32
->tv_nsec
))
139 return -XFS_ERROR(EFAULT
);
140 bstime
->tv_sec
= sec32
;
144 /* xfs_bstat_t has differing alignment on intel, & bstime_t sizes everywhere */
146 xfs_ioctl32_bstat_copyin(
148 compat_xfs_bstat_t __user
*bstat32
)
150 if (get_user(bstat
->bs_ino
, &bstat32
->bs_ino
) ||
151 get_user(bstat
->bs_mode
, &bstat32
->bs_mode
) ||
152 get_user(bstat
->bs_nlink
, &bstat32
->bs_nlink
) ||
153 get_user(bstat
->bs_uid
, &bstat32
->bs_uid
) ||
154 get_user(bstat
->bs_gid
, &bstat32
->bs_gid
) ||
155 get_user(bstat
->bs_rdev
, &bstat32
->bs_rdev
) ||
156 get_user(bstat
->bs_blksize
, &bstat32
->bs_blksize
) ||
157 get_user(bstat
->bs_size
, &bstat32
->bs_size
) ||
158 xfs_ioctl32_bstime_copyin(&bstat
->bs_atime
, &bstat32
->bs_atime
) ||
159 xfs_ioctl32_bstime_copyin(&bstat
->bs_mtime
, &bstat32
->bs_mtime
) ||
160 xfs_ioctl32_bstime_copyin(&bstat
->bs_ctime
, &bstat32
->bs_ctime
) ||
161 get_user(bstat
->bs_blocks
, &bstat32
->bs_size
) ||
162 get_user(bstat
->bs_xflags
, &bstat32
->bs_size
) ||
163 get_user(bstat
->bs_extsize
, &bstat32
->bs_extsize
) ||
164 get_user(bstat
->bs_extents
, &bstat32
->bs_extents
) ||
165 get_user(bstat
->bs_gen
, &bstat32
->bs_gen
) ||
166 get_user(bstat
->bs_projid_lo
, &bstat32
->bs_projid_lo
) ||
167 get_user(bstat
->bs_projid_hi
, &bstat32
->bs_projid_hi
) ||
168 get_user(bstat
->bs_dmevmask
, &bstat32
->bs_dmevmask
) ||
169 get_user(bstat
->bs_dmstate
, &bstat32
->bs_dmstate
) ||
170 get_user(bstat
->bs_aextents
, &bstat32
->bs_aextents
))
171 return -XFS_ERROR(EFAULT
);
175 /* XFS_IOC_FSBULKSTAT and friends */
178 xfs_bstime_store_compat(
179 compat_xfs_bstime_t __user
*p32
,
180 const xfs_bstime_t
*p
)
185 if (put_user(sec32
, &p32
->tv_sec
) ||
186 put_user(p
->tv_nsec
, &p32
->tv_nsec
))
187 return -XFS_ERROR(EFAULT
);
191 /* Return 0 on success or positive error (to xfs_bulkstat()) */
193 xfs_bulkstat_one_fmt_compat(
194 void __user
*ubuffer
,
197 const xfs_bstat_t
*buffer
)
199 compat_xfs_bstat_t __user
*p32
= ubuffer
;
201 if (ubsize
< sizeof(*p32
))
202 return XFS_ERROR(ENOMEM
);
204 if (put_user(buffer
->bs_ino
, &p32
->bs_ino
) ||
205 put_user(buffer
->bs_mode
, &p32
->bs_mode
) ||
206 put_user(buffer
->bs_nlink
, &p32
->bs_nlink
) ||
207 put_user(buffer
->bs_uid
, &p32
->bs_uid
) ||
208 put_user(buffer
->bs_gid
, &p32
->bs_gid
) ||
209 put_user(buffer
->bs_rdev
, &p32
->bs_rdev
) ||
210 put_user(buffer
->bs_blksize
, &p32
->bs_blksize
) ||
211 put_user(buffer
->bs_size
, &p32
->bs_size
) ||
212 xfs_bstime_store_compat(&p32
->bs_atime
, &buffer
->bs_atime
) ||
213 xfs_bstime_store_compat(&p32
->bs_mtime
, &buffer
->bs_mtime
) ||
214 xfs_bstime_store_compat(&p32
->bs_ctime
, &buffer
->bs_ctime
) ||
215 put_user(buffer
->bs_blocks
, &p32
->bs_blocks
) ||
216 put_user(buffer
->bs_xflags
, &p32
->bs_xflags
) ||
217 put_user(buffer
->bs_extsize
, &p32
->bs_extsize
) ||
218 put_user(buffer
->bs_extents
, &p32
->bs_extents
) ||
219 put_user(buffer
->bs_gen
, &p32
->bs_gen
) ||
220 put_user(buffer
->bs_projid
, &p32
->bs_projid
) ||
221 put_user(buffer
->bs_projid_hi
, &p32
->bs_projid_hi
) ||
222 put_user(buffer
->bs_dmevmask
, &p32
->bs_dmevmask
) ||
223 put_user(buffer
->bs_dmstate
, &p32
->bs_dmstate
) ||
224 put_user(buffer
->bs_aextents
, &p32
->bs_aextents
))
225 return XFS_ERROR(EFAULT
);
227 *ubused
= sizeof(*p32
);
232 xfs_bulkstat_one_compat(
233 xfs_mount_t
*mp
, /* mount point for filesystem */
234 xfs_ino_t ino
, /* inode number to get data for */
235 void __user
*buffer
, /* buffer to place output in */
236 int ubsize
, /* size of buffer */
237 int *ubused
, /* bytes used by me */
238 int *stat
) /* BULKSTAT_RV_... */
240 return xfs_bulkstat_one_int(mp
, ino
, buffer
, ubsize
,
241 xfs_bulkstat_one_fmt_compat
,
245 /* copied from xfs_ioctl.c */
247 xfs_compat_ioc_bulkstat(
250 compat_xfs_fsop_bulkreq_t __user
*p32
)
253 xfs_fsop_bulkreq_t bulkreq
;
254 int count
; /* # of records returned */
255 xfs_ino_t inlast
; /* last inode number */
259 /* done = 1 if there are more stats to get and if bulkstat */
260 /* should be called again (unused here, but used in dmapi) */
262 if (!capable(CAP_SYS_ADMIN
))
263 return -XFS_ERROR(EPERM
);
265 if (XFS_FORCED_SHUTDOWN(mp
))
266 return -XFS_ERROR(EIO
);
268 if (get_user(addr
, &p32
->lastip
))
269 return -XFS_ERROR(EFAULT
);
270 bulkreq
.lastip
= compat_ptr(addr
);
271 if (get_user(bulkreq
.icount
, &p32
->icount
) ||
272 get_user(addr
, &p32
->ubuffer
))
273 return -XFS_ERROR(EFAULT
);
274 bulkreq
.ubuffer
= compat_ptr(addr
);
275 if (get_user(addr
, &p32
->ocount
))
276 return -XFS_ERROR(EFAULT
);
277 bulkreq
.ocount
= compat_ptr(addr
);
279 if (copy_from_user(&inlast
, bulkreq
.lastip
, sizeof(__s64
)))
280 return -XFS_ERROR(EFAULT
);
282 if ((count
= bulkreq
.icount
) <= 0)
283 return -XFS_ERROR(EINVAL
);
285 if (bulkreq
.ubuffer
== NULL
)
286 return -XFS_ERROR(EINVAL
);
288 if (cmd
== XFS_IOC_FSINUMBERS_32
) {
289 error
= xfs_inumbers(mp
, &inlast
, &count
,
290 bulkreq
.ubuffer
, xfs_inumbers_fmt_compat
);
291 } else if (cmd
== XFS_IOC_FSBULKSTAT_SINGLE_32
) {
294 error
= xfs_bulkstat_one_compat(mp
, inlast
, bulkreq
.ubuffer
,
295 sizeof(compat_xfs_bstat_t
), NULL
, &res
);
296 } else if (cmd
== XFS_IOC_FSBULKSTAT_32
) {
297 error
= xfs_bulkstat(mp
, &inlast
, &count
,
298 xfs_bulkstat_one_compat
, sizeof(compat_xfs_bstat_t
),
299 bulkreq
.ubuffer
, &done
);
301 error
= XFS_ERROR(EINVAL
);
305 if (bulkreq
.ocount
!= NULL
) {
306 if (copy_to_user(bulkreq
.lastip
, &inlast
,
308 return -XFS_ERROR(EFAULT
);
310 if (copy_to_user(bulkreq
.ocount
, &count
, sizeof(count
)))
311 return -XFS_ERROR(EFAULT
);
318 xfs_compat_handlereq_copyin(
319 xfs_fsop_handlereq_t
*hreq
,
320 compat_xfs_fsop_handlereq_t __user
*arg32
)
322 compat_xfs_fsop_handlereq_t hreq32
;
324 if (copy_from_user(&hreq32
, arg32
, sizeof(compat_xfs_fsop_handlereq_t
)))
325 return -XFS_ERROR(EFAULT
);
327 hreq
->fd
= hreq32
.fd
;
328 hreq
->path
= compat_ptr(hreq32
.path
);
329 hreq
->oflags
= hreq32
.oflags
;
330 hreq
->ihandle
= compat_ptr(hreq32
.ihandle
);
331 hreq
->ihandlen
= hreq32
.ihandlen
;
332 hreq
->ohandle
= compat_ptr(hreq32
.ohandle
);
333 hreq
->ohandlen
= compat_ptr(hreq32
.ohandlen
);
338 STATIC
struct dentry
*
339 xfs_compat_handlereq_to_dentry(
340 struct file
*parfilp
,
341 compat_xfs_fsop_handlereq_t
*hreq
)
343 return xfs_handle_to_dentry(parfilp
,
344 compat_ptr(hreq
->ihandle
), hreq
->ihandlen
);
348 xfs_compat_attrlist_by_handle(
349 struct file
*parfilp
,
353 attrlist_cursor_kern_t
*cursor
;
354 compat_xfs_fsop_attrlist_handlereq_t al_hreq
;
355 struct dentry
*dentry
;
358 if (!capable(CAP_SYS_ADMIN
))
359 return -XFS_ERROR(EPERM
);
360 if (copy_from_user(&al_hreq
, arg
,
361 sizeof(compat_xfs_fsop_attrlist_handlereq_t
)))
362 return -XFS_ERROR(EFAULT
);
363 if (al_hreq
.buflen
> XATTR_LIST_MAX
)
364 return -XFS_ERROR(EINVAL
);
367 * Reject flags, only allow namespaces.
369 if (al_hreq
.flags
& ~(ATTR_ROOT
| ATTR_SECURE
))
370 return -XFS_ERROR(EINVAL
);
372 dentry
= xfs_compat_handlereq_to_dentry(parfilp
, &al_hreq
.hreq
);
374 return PTR_ERR(dentry
);
377 kbuf
= kmalloc(al_hreq
.buflen
, GFP_KERNEL
);
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
);
387 if (copy_to_user(compat_ptr(al_hreq
.buffer
), kbuf
, al_hreq
.buflen
))
398 xfs_compat_attrmulti_by_handle(
399 struct file
*parfilp
,
403 compat_xfs_attr_multiop_t
*ops
;
404 compat_xfs_fsop_attrmulti_handlereq_t am_hreq
;
405 struct dentry
*dentry
;
406 unsigned int i
, size
;
407 unsigned char *attr_name
;
409 if (!capable(CAP_SYS_ADMIN
))
410 return -XFS_ERROR(EPERM
);
411 if (copy_from_user(&am_hreq
, arg
,
412 sizeof(compat_xfs_fsop_attrmulti_handlereq_t
)))
413 return -XFS_ERROR(EFAULT
);
416 if (am_hreq
.opcount
>= INT_MAX
/ sizeof(compat_xfs_attr_multiop_t
))
419 dentry
= xfs_compat_handlereq_to_dentry(parfilp
, &am_hreq
.hreq
);
421 return PTR_ERR(dentry
);
424 size
= am_hreq
.opcount
* sizeof(compat_xfs_attr_multiop_t
);
425 if (!size
|| size
> 16 * PAGE_SIZE
)
428 ops
= memdup_user(compat_ptr(am_hreq
.ops
), size
);
430 error
= PTR_ERR(ops
);
434 attr_name
= kmalloc(MAXNAMELEN
, GFP_KERNEL
);
439 for (i
= 0; i
< am_hreq
.opcount
; i
++) {
440 ops
[i
].am_error
= strncpy_from_user((char *)attr_name
,
441 compat_ptr(ops
[i
].am_attrname
),
443 if (ops
[i
].am_error
== 0 || ops
[i
].am_error
== MAXNAMELEN
)
445 if (ops
[i
].am_error
< 0)
448 switch (ops
[i
].am_opcode
) {
450 ops
[i
].am_error
= xfs_attrmulti_attr_get(
451 dentry
->d_inode
, attr_name
,
452 compat_ptr(ops
[i
].am_attrvalue
),
453 &ops
[i
].am_length
, ops
[i
].am_flags
);
456 ops
[i
].am_error
= mnt_want_write_file(parfilp
);
459 ops
[i
].am_error
= xfs_attrmulti_attr_set(
460 dentry
->d_inode
, attr_name
,
461 compat_ptr(ops
[i
].am_attrvalue
),
462 ops
[i
].am_length
, ops
[i
].am_flags
);
463 mnt_drop_write_file(parfilp
);
466 ops
[i
].am_error
= mnt_want_write_file(parfilp
);
469 ops
[i
].am_error
= xfs_attrmulti_attr_remove(
470 dentry
->d_inode
, attr_name
,
472 mnt_drop_write_file(parfilp
);
475 ops
[i
].am_error
= EINVAL
;
479 if (copy_to_user(compat_ptr(am_hreq
.ops
), ops
, size
))
480 error
= XFS_ERROR(EFAULT
);
491 xfs_compat_fssetdm_by_handle(
492 struct file
*parfilp
,
496 struct fsdmidata fsd
;
497 compat_xfs_fsop_setdm_handlereq_t dmhreq
;
498 struct dentry
*dentry
;
500 if (!capable(CAP_MKNOD
))
501 return -XFS_ERROR(EPERM
);
502 if (copy_from_user(&dmhreq
, arg
,
503 sizeof(compat_xfs_fsop_setdm_handlereq_t
)))
504 return -XFS_ERROR(EFAULT
);
506 dentry
= xfs_compat_handlereq_to_dentry(parfilp
, &dmhreq
.hreq
);
508 return PTR_ERR(dentry
);
510 if (IS_IMMUTABLE(dentry
->d_inode
) || IS_APPEND(dentry
->d_inode
)) {
511 error
= -XFS_ERROR(EPERM
);
515 if (copy_from_user(&fsd
, compat_ptr(dmhreq
.data
), sizeof(fsd
))) {
516 error
= -XFS_ERROR(EFAULT
);
520 error
= -xfs_set_dmattrs(XFS_I(dentry
->d_inode
), fsd
.fsd_dmevmask
,
529 xfs_file_compat_ioctl(
534 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
535 struct xfs_inode
*ip
= XFS_I(inode
);
536 struct xfs_mount
*mp
= ip
->i_mount
;
537 void __user
*arg
= (void __user
*)p
;
541 if (filp
->f_mode
& FMODE_NOCMTIME
)
544 trace_xfs_file_compat_ioctl(ip
);
547 /* No size or alignment issues on any arch */
548 case XFS_IOC_DIOINFO
:
549 case XFS_IOC_FSGEOMETRY
:
550 case XFS_IOC_FSGETXATTR
:
551 case XFS_IOC_FSSETXATTR
:
552 case XFS_IOC_FSGETXATTRA
:
553 case XFS_IOC_FSSETDM
:
554 case XFS_IOC_GETBMAP
:
555 case XFS_IOC_GETBMAPA
:
556 case XFS_IOC_GETBMAPX
:
557 case XFS_IOC_FSCOUNTS
:
558 case XFS_IOC_SET_RESBLKS
:
559 case XFS_IOC_GET_RESBLKS
:
560 case XFS_IOC_FSGROWFSLOG
:
561 case XFS_IOC_GOINGDOWN
:
562 case XFS_IOC_ERROR_INJECTION
:
563 case XFS_IOC_ERROR_CLEARALL
:
564 return xfs_file_ioctl(filp
, cmd
, p
);
565 #ifndef BROKEN_X86_ALIGNMENT
566 /* These are handled fine if no alignment issues */
567 case XFS_IOC_ALLOCSP
:
570 case XFS_IOC_UNRESVSP
:
571 case XFS_IOC_ALLOCSP64
:
572 case XFS_IOC_FREESP64
:
573 case XFS_IOC_RESVSP64
:
574 case XFS_IOC_UNRESVSP64
:
575 case XFS_IOC_FSGEOMETRY_V1
:
576 case XFS_IOC_FSGROWFSDATA
:
577 case XFS_IOC_FSGROWFSRT
:
578 case XFS_IOC_ZERO_RANGE
:
579 return xfs_file_ioctl(filp
, cmd
, p
);
581 case XFS_IOC_ALLOCSP_32
:
582 case XFS_IOC_FREESP_32
:
583 case XFS_IOC_ALLOCSP64_32
:
584 case XFS_IOC_FREESP64_32
:
585 case XFS_IOC_RESVSP_32
:
586 case XFS_IOC_UNRESVSP_32
:
587 case XFS_IOC_RESVSP64_32
:
588 case XFS_IOC_UNRESVSP64_32
:
589 case XFS_IOC_ZERO_RANGE_32
: {
590 struct xfs_flock64 bf
;
592 if (xfs_compat_flock64_copyin(&bf
, arg
))
593 return -XFS_ERROR(EFAULT
);
594 cmd
= _NATIVE_IOC(cmd
, struct xfs_flock64
);
595 return xfs_ioc_space(ip
, inode
, filp
, ioflags
, cmd
, &bf
);
597 case XFS_IOC_FSGEOMETRY_V1_32
:
598 return xfs_compat_ioc_fsgeometry_v1(mp
, arg
);
599 case XFS_IOC_FSGROWFSDATA_32
: {
600 struct xfs_growfs_data in
;
602 if (xfs_compat_growfs_data_copyin(&in
, arg
))
603 return -XFS_ERROR(EFAULT
);
604 error
= xfs_growfs_data(mp
, &in
);
607 case XFS_IOC_FSGROWFSRT_32
: {
608 struct xfs_growfs_rt in
;
610 if (xfs_compat_growfs_rt_copyin(&in
, arg
))
611 return -XFS_ERROR(EFAULT
);
612 error
= xfs_growfs_rt(mp
, &in
);
616 /* long changes size, but xfs only copiese out 32 bits */
617 case XFS_IOC_GETXFLAGS_32
:
618 case XFS_IOC_SETXFLAGS_32
:
619 case XFS_IOC_GETVERSION_32
:
620 cmd
= _NATIVE_IOC(cmd
, long);
621 return xfs_file_ioctl(filp
, cmd
, p
);
622 case XFS_IOC_SWAPEXT_32
: {
623 struct xfs_swapext sxp
;
624 struct compat_xfs_swapext __user
*sxu
= arg
;
626 /* Bulk copy in up to the sx_stat field, then copy bstat */
627 if (copy_from_user(&sxp
, sxu
,
628 offsetof(struct xfs_swapext
, sx_stat
)) ||
629 xfs_ioctl32_bstat_copyin(&sxp
.sx_stat
, &sxu
->sx_stat
))
630 return -XFS_ERROR(EFAULT
);
631 error
= xfs_swapext(&sxp
);
634 case XFS_IOC_FSBULKSTAT_32
:
635 case XFS_IOC_FSBULKSTAT_SINGLE_32
:
636 case XFS_IOC_FSINUMBERS_32
:
637 return xfs_compat_ioc_bulkstat(mp
, cmd
, arg
);
638 case XFS_IOC_FD_TO_HANDLE_32
:
639 case XFS_IOC_PATH_TO_HANDLE_32
:
640 case XFS_IOC_PATH_TO_FSHANDLE_32
: {
641 struct xfs_fsop_handlereq hreq
;
643 if (xfs_compat_handlereq_copyin(&hreq
, arg
))
644 return -XFS_ERROR(EFAULT
);
645 cmd
= _NATIVE_IOC(cmd
, struct xfs_fsop_handlereq
);
646 return xfs_find_handle(cmd
, &hreq
);
648 case XFS_IOC_OPEN_BY_HANDLE_32
: {
649 struct xfs_fsop_handlereq hreq
;
651 if (xfs_compat_handlereq_copyin(&hreq
, arg
))
652 return -XFS_ERROR(EFAULT
);
653 return xfs_open_by_handle(filp
, &hreq
);
655 case XFS_IOC_READLINK_BY_HANDLE_32
: {
656 struct xfs_fsop_handlereq hreq
;
658 if (xfs_compat_handlereq_copyin(&hreq
, arg
))
659 return -XFS_ERROR(EFAULT
);
660 return xfs_readlink_by_handle(filp
, &hreq
);
662 case XFS_IOC_ATTRLIST_BY_HANDLE_32
:
663 return xfs_compat_attrlist_by_handle(filp
, arg
);
664 case XFS_IOC_ATTRMULTI_BY_HANDLE_32
:
665 return xfs_compat_attrmulti_by_handle(filp
, arg
);
666 case XFS_IOC_FSSETDM_BY_HANDLE_32
:
667 return xfs_compat_fssetdm_by_handle(filp
, arg
);
669 return -XFS_ERROR(ENOIOCTLCMD
);