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 <linux/uaccess.h>
23 #include <linux/fsmap.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"
37 #include "xfs_ioctl.h"
38 #include "xfs_ioctl32.h"
39 #include "xfs_trace.h"
42 #define _NATIVE_IOC(cmd, type) \
43 _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type))
45 #ifdef BROKEN_X86_ALIGNMENT
47 xfs_compat_flock64_copyin(
49 compat_xfs_flock64_t __user
*arg32
)
51 if (get_user(bf
->l_type
, &arg32
->l_type
) ||
52 get_user(bf
->l_whence
, &arg32
->l_whence
) ||
53 get_user(bf
->l_start
, &arg32
->l_start
) ||
54 get_user(bf
->l_len
, &arg32
->l_len
) ||
55 get_user(bf
->l_sysid
, &arg32
->l_sysid
) ||
56 get_user(bf
->l_pid
, &arg32
->l_pid
) ||
57 copy_from_user(bf
->l_pad
, &arg32
->l_pad
, 4*sizeof(u32
)))
63 xfs_compat_ioc_fsgeometry_v1(
65 compat_xfs_fsop_geom_v1_t __user
*arg32
)
67 xfs_fsop_geom_t fsgeo
;
70 error
= xfs_fs_geometry(&mp
->m_sb
, &fsgeo
, 3);
73 /* The 32-bit variant simply has some padding at the end */
74 if (copy_to_user(arg32
, &fsgeo
, sizeof(struct compat_xfs_fsop_geom_v1
)))
80 xfs_compat_growfs_data_copyin(
81 struct xfs_growfs_data
*in
,
82 compat_xfs_growfs_data_t __user
*arg32
)
84 if (get_user(in
->newblocks
, &arg32
->newblocks
) ||
85 get_user(in
->imaxpct
, &arg32
->imaxpct
))
91 xfs_compat_growfs_rt_copyin(
92 struct xfs_growfs_rt
*in
,
93 compat_xfs_growfs_rt_t __user
*arg32
)
95 if (get_user(in
->newblocks
, &arg32
->newblocks
) ||
96 get_user(in
->extsize
, &arg32
->extsize
))
102 xfs_inumbers_fmt_compat(
103 void __user
*ubuffer
,
104 const struct xfs_inogrp
*buffer
,
108 compat_xfs_inogrp_t __user
*p32
= ubuffer
;
111 for (i
= 0; i
< count
; i
++) {
112 if (put_user(buffer
[i
].xi_startino
, &p32
[i
].xi_startino
) ||
113 put_user(buffer
[i
].xi_alloccount
, &p32
[i
].xi_alloccount
) ||
114 put_user(buffer
[i
].xi_allocmask
, &p32
[i
].xi_allocmask
))
117 *written
= count
* sizeof(*p32
);
122 #define xfs_inumbers_fmt_compat xfs_inumbers_fmt
123 #endif /* BROKEN_X86_ALIGNMENT */
126 xfs_ioctl32_bstime_copyin(
127 xfs_bstime_t
*bstime
,
128 compat_xfs_bstime_t __user
*bstime32
)
130 compat_time_t sec32
; /* tv_sec differs on 64 vs. 32 */
132 if (get_user(sec32
, &bstime32
->tv_sec
) ||
133 get_user(bstime
->tv_nsec
, &bstime32
->tv_nsec
))
135 bstime
->tv_sec
= sec32
;
139 /* xfs_bstat_t has differing alignment on intel, & bstime_t sizes everywhere */
141 xfs_ioctl32_bstat_copyin(
143 compat_xfs_bstat_t __user
*bstat32
)
145 if (get_user(bstat
->bs_ino
, &bstat32
->bs_ino
) ||
146 get_user(bstat
->bs_mode
, &bstat32
->bs_mode
) ||
147 get_user(bstat
->bs_nlink
, &bstat32
->bs_nlink
) ||
148 get_user(bstat
->bs_uid
, &bstat32
->bs_uid
) ||
149 get_user(bstat
->bs_gid
, &bstat32
->bs_gid
) ||
150 get_user(bstat
->bs_rdev
, &bstat32
->bs_rdev
) ||
151 get_user(bstat
->bs_blksize
, &bstat32
->bs_blksize
) ||
152 get_user(bstat
->bs_size
, &bstat32
->bs_size
) ||
153 xfs_ioctl32_bstime_copyin(&bstat
->bs_atime
, &bstat32
->bs_atime
) ||
154 xfs_ioctl32_bstime_copyin(&bstat
->bs_mtime
, &bstat32
->bs_mtime
) ||
155 xfs_ioctl32_bstime_copyin(&bstat
->bs_ctime
, &bstat32
->bs_ctime
) ||
156 get_user(bstat
->bs_blocks
, &bstat32
->bs_size
) ||
157 get_user(bstat
->bs_xflags
, &bstat32
->bs_size
) ||
158 get_user(bstat
->bs_extsize
, &bstat32
->bs_extsize
) ||
159 get_user(bstat
->bs_extents
, &bstat32
->bs_extents
) ||
160 get_user(bstat
->bs_gen
, &bstat32
->bs_gen
) ||
161 get_user(bstat
->bs_projid_lo
, &bstat32
->bs_projid_lo
) ||
162 get_user(bstat
->bs_projid_hi
, &bstat32
->bs_projid_hi
) ||
163 get_user(bstat
->bs_forkoff
, &bstat32
->bs_forkoff
) ||
164 get_user(bstat
->bs_dmevmask
, &bstat32
->bs_dmevmask
) ||
165 get_user(bstat
->bs_dmstate
, &bstat32
->bs_dmstate
) ||
166 get_user(bstat
->bs_aextents
, &bstat32
->bs_aextents
))
171 /* XFS_IOC_FSBULKSTAT and friends */
174 xfs_bstime_store_compat(
175 compat_xfs_bstime_t __user
*p32
,
176 const xfs_bstime_t
*p
)
181 if (put_user(sec32
, &p32
->tv_sec
) ||
182 put_user(p
->tv_nsec
, &p32
->tv_nsec
))
187 /* Return 0 on success or positive error (to xfs_bulkstat()) */
189 xfs_bulkstat_one_fmt_compat(
190 void __user
*ubuffer
,
193 const xfs_bstat_t
*buffer
)
195 compat_xfs_bstat_t __user
*p32
= ubuffer
;
197 if (ubsize
< sizeof(*p32
))
200 if (put_user(buffer
->bs_ino
, &p32
->bs_ino
) ||
201 put_user(buffer
->bs_mode
, &p32
->bs_mode
) ||
202 put_user(buffer
->bs_nlink
, &p32
->bs_nlink
) ||
203 put_user(buffer
->bs_uid
, &p32
->bs_uid
) ||
204 put_user(buffer
->bs_gid
, &p32
->bs_gid
) ||
205 put_user(buffer
->bs_rdev
, &p32
->bs_rdev
) ||
206 put_user(buffer
->bs_blksize
, &p32
->bs_blksize
) ||
207 put_user(buffer
->bs_size
, &p32
->bs_size
) ||
208 xfs_bstime_store_compat(&p32
->bs_atime
, &buffer
->bs_atime
) ||
209 xfs_bstime_store_compat(&p32
->bs_mtime
, &buffer
->bs_mtime
) ||
210 xfs_bstime_store_compat(&p32
->bs_ctime
, &buffer
->bs_ctime
) ||
211 put_user(buffer
->bs_blocks
, &p32
->bs_blocks
) ||
212 put_user(buffer
->bs_xflags
, &p32
->bs_xflags
) ||
213 put_user(buffer
->bs_extsize
, &p32
->bs_extsize
) ||
214 put_user(buffer
->bs_extents
, &p32
->bs_extents
) ||
215 put_user(buffer
->bs_gen
, &p32
->bs_gen
) ||
216 put_user(buffer
->bs_projid
, &p32
->bs_projid
) ||
217 put_user(buffer
->bs_projid_hi
, &p32
->bs_projid_hi
) ||
218 put_user(buffer
->bs_forkoff
, &p32
->bs_forkoff
) ||
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
))
224 *ubused
= sizeof(*p32
);
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_... */
237 return xfs_bulkstat_one_int(mp
, ino
, buffer
, ubsize
,
238 xfs_bulkstat_one_fmt_compat
,
242 /* copied from xfs_ioctl.c */
244 xfs_compat_ioc_bulkstat(
247 compat_xfs_fsop_bulkreq_t __user
*p32
)
250 xfs_fsop_bulkreq_t bulkreq
;
251 int count
; /* # of records returned */
252 xfs_ino_t inlast
; /* last inode number */
256 /* done = 1 if there are more stats to get and if bulkstat */
257 /* should be called again (unused here, but used in dmapi) */
259 if (!capable(CAP_SYS_ADMIN
))
262 if (XFS_FORCED_SHUTDOWN(mp
))
265 if (get_user(addr
, &p32
->lastip
))
267 bulkreq
.lastip
= compat_ptr(addr
);
268 if (get_user(bulkreq
.icount
, &p32
->icount
) ||
269 get_user(addr
, &p32
->ubuffer
))
271 bulkreq
.ubuffer
= compat_ptr(addr
);
272 if (get_user(addr
, &p32
->ocount
))
274 bulkreq
.ocount
= compat_ptr(addr
);
276 if (copy_from_user(&inlast
, bulkreq
.lastip
, sizeof(__s64
)))
279 if ((count
= bulkreq
.icount
) <= 0)
282 if (bulkreq
.ubuffer
== NULL
)
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
) {
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
);
302 if (bulkreq
.ocount
!= NULL
) {
303 if (copy_to_user(bulkreq
.lastip
, &inlast
,
307 if (copy_to_user(bulkreq
.ocount
, &count
, sizeof(count
)))
315 xfs_compat_handlereq_copyin(
316 xfs_fsop_handlereq_t
*hreq
,
317 compat_xfs_fsop_handlereq_t __user
*arg32
)
319 compat_xfs_fsop_handlereq_t hreq32
;
321 if (copy_from_user(&hreq32
, arg32
, sizeof(compat_xfs_fsop_handlereq_t
)))
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
);
335 STATIC
struct dentry
*
336 xfs_compat_handlereq_to_dentry(
337 struct file
*parfilp
,
338 compat_xfs_fsop_handlereq_t
*hreq
)
340 return xfs_handle_to_dentry(parfilp
,
341 compat_ptr(hreq
->ihandle
), hreq
->ihandlen
);
345 xfs_compat_attrlist_by_handle(
346 struct file
*parfilp
,
350 attrlist_cursor_kern_t
*cursor
;
351 compat_xfs_fsop_attrlist_handlereq_t al_hreq
;
352 struct dentry
*dentry
;
355 if (!capable(CAP_SYS_ADMIN
))
357 if (copy_from_user(&al_hreq
, arg
,
358 sizeof(compat_xfs_fsop_attrlist_handlereq_t
)))
360 if (al_hreq
.buflen
< sizeof(struct attrlist
) ||
361 al_hreq
.buflen
> XFS_XATTR_LIST_MAX
)
365 * Reject flags, only allow namespaces.
367 if (al_hreq
.flags
& ~(ATTR_ROOT
| ATTR_SECURE
))
370 dentry
= xfs_compat_handlereq_to_dentry(parfilp
, &al_hreq
.hreq
);
372 return PTR_ERR(dentry
);
375 kbuf
= kmem_zalloc_large(al_hreq
.buflen
, KM_SLEEP
);
379 cursor
= (attrlist_cursor_kern_t
*)&al_hreq
.pos
;
380 error
= xfs_attr_list(XFS_I(d_inode(dentry
)), kbuf
, al_hreq
.buflen
,
381 al_hreq
.flags
, cursor
);
385 if (copy_to_user(compat_ptr(al_hreq
.buffer
), kbuf
, al_hreq
.buflen
))
396 xfs_compat_attrmulti_by_handle(
397 struct file
*parfilp
,
401 compat_xfs_attr_multiop_t
*ops
;
402 compat_xfs_fsop_attrmulti_handlereq_t am_hreq
;
403 struct dentry
*dentry
;
404 unsigned int i
, size
;
405 unsigned char *attr_name
;
407 if (!capable(CAP_SYS_ADMIN
))
409 if (copy_from_user(&am_hreq
, arg
,
410 sizeof(compat_xfs_fsop_attrmulti_handlereq_t
)))
414 if (am_hreq
.opcount
>= INT_MAX
/ sizeof(compat_xfs_attr_multiop_t
))
417 dentry
= xfs_compat_handlereq_to_dentry(parfilp
, &am_hreq
.hreq
);
419 return PTR_ERR(dentry
);
422 size
= am_hreq
.opcount
* sizeof(compat_xfs_attr_multiop_t
);
423 if (!size
|| size
> 16 * PAGE_SIZE
)
426 ops
= memdup_user(compat_ptr(am_hreq
.ops
), size
);
428 error
= PTR_ERR(ops
);
433 attr_name
= kmalloc(MAXNAMELEN
, GFP_KERNEL
);
438 for (i
= 0; i
< am_hreq
.opcount
; i
++) {
439 ops
[i
].am_error
= strncpy_from_user((char *)attr_name
,
440 compat_ptr(ops
[i
].am_attrname
),
442 if (ops
[i
].am_error
== 0 || ops
[i
].am_error
== MAXNAMELEN
)
444 if (ops
[i
].am_error
< 0)
447 switch (ops
[i
].am_opcode
) {
449 ops
[i
].am_error
= xfs_attrmulti_attr_get(
450 d_inode(dentry
), attr_name
,
451 compat_ptr(ops
[i
].am_attrvalue
),
452 &ops
[i
].am_length
, ops
[i
].am_flags
);
455 ops
[i
].am_error
= mnt_want_write_file(parfilp
);
458 ops
[i
].am_error
= xfs_attrmulti_attr_set(
459 d_inode(dentry
), attr_name
,
460 compat_ptr(ops
[i
].am_attrvalue
),
461 ops
[i
].am_length
, ops
[i
].am_flags
);
462 mnt_drop_write_file(parfilp
);
465 ops
[i
].am_error
= mnt_want_write_file(parfilp
);
468 ops
[i
].am_error
= xfs_attrmulti_attr_remove(
469 d_inode(dentry
), attr_name
,
471 mnt_drop_write_file(parfilp
);
474 ops
[i
].am_error
= -EINVAL
;
478 if (copy_to_user(compat_ptr(am_hreq
.ops
), ops
, size
))
490 xfs_compat_fssetdm_by_handle(
491 struct file
*parfilp
,
495 struct fsdmidata fsd
;
496 compat_xfs_fsop_setdm_handlereq_t dmhreq
;
497 struct dentry
*dentry
;
499 if (!capable(CAP_MKNOD
))
501 if (copy_from_user(&dmhreq
, arg
,
502 sizeof(compat_xfs_fsop_setdm_handlereq_t
)))
505 dentry
= xfs_compat_handlereq_to_dentry(parfilp
, &dmhreq
.hreq
);
507 return PTR_ERR(dentry
);
509 if (IS_IMMUTABLE(d_inode(dentry
)) || IS_APPEND(d_inode(dentry
))) {
514 if (copy_from_user(&fsd
, compat_ptr(dmhreq
.data
), sizeof(fsd
))) {
519 error
= xfs_set_dmattrs(XFS_I(d_inode(dentry
)), fsd
.fsd_dmevmask
,
528 xfs_file_compat_ioctl(
533 struct inode
*inode
= file_inode(filp
);
534 struct xfs_inode
*ip
= XFS_I(inode
);
535 struct xfs_mount
*mp
= ip
->i_mount
;
536 void __user
*arg
= (void __user
*)p
;
539 trace_xfs_file_compat_ioctl(ip
);
542 /* No size or alignment issues on any arch */
543 case XFS_IOC_DIOINFO
:
544 case XFS_IOC_FSGEOMETRY
:
545 case XFS_IOC_FSGETXATTR
:
546 case XFS_IOC_FSSETXATTR
:
547 case XFS_IOC_FSGETXATTRA
:
548 case XFS_IOC_FSSETDM
:
549 case XFS_IOC_GETBMAP
:
550 case XFS_IOC_GETBMAPA
:
551 case XFS_IOC_GETBMAPX
:
552 case XFS_IOC_FSCOUNTS
:
553 case XFS_IOC_SET_RESBLKS
:
554 case XFS_IOC_GET_RESBLKS
:
555 case XFS_IOC_FSGROWFSLOG
:
556 case XFS_IOC_GOINGDOWN
:
557 case XFS_IOC_ERROR_INJECTION
:
558 case XFS_IOC_ERROR_CLEARALL
:
559 case FS_IOC_GETFSMAP
:
560 case XFS_IOC_SCRUB_METADATA
:
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
:
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
);
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
;
589 if (xfs_compat_flock64_copyin(&bf
, arg
))
591 cmd
= _NATIVE_IOC(cmd
, struct xfs_flock64
);
592 return xfs_ioc_space(filp
, cmd
, &bf
);
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
;
599 if (xfs_compat_growfs_data_copyin(&in
, arg
))
601 error
= mnt_want_write_file(filp
);
604 error
= xfs_growfs_data(mp
, &in
);
605 mnt_drop_write_file(filp
);
608 case XFS_IOC_FSGROWFSRT_32
: {
609 struct xfs_growfs_rt in
;
611 if (xfs_compat_growfs_rt_copyin(&in
, arg
))
613 error
= mnt_want_write_file(filp
);
616 error
= xfs_growfs_rt(mp
, &in
);
617 mnt_drop_write_file(filp
);
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
;
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
))
636 error
= mnt_want_write_file(filp
);
639 error
= xfs_ioc_swapext(&sxp
);
640 mnt_drop_write_file(filp
);
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
;
652 if (xfs_compat_handlereq_copyin(&hreq
, arg
))
654 cmd
= _NATIVE_IOC(cmd
, struct xfs_fsop_handlereq
);
655 return xfs_find_handle(cmd
, &hreq
);
657 case XFS_IOC_OPEN_BY_HANDLE_32
: {
658 struct xfs_fsop_handlereq hreq
;
660 if (xfs_compat_handlereq_copyin(&hreq
, arg
))
662 return xfs_open_by_handle(filp
, &hreq
);
664 case XFS_IOC_READLINK_BY_HANDLE_32
: {
665 struct xfs_fsop_handlereq hreq
;
667 if (xfs_compat_handlereq_copyin(&hreq
, arg
))
669 return xfs_readlink_by_handle(filp
, &hreq
);
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
);