projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
xfs: more reserved blocks fixups
[linux-2.6-block.git] / fs / xfs / linux-2.6 / xfs_ioctl32.c
CommitLineData
1da177e4 1/*
7b718769
NS		 2 * Copyright (c) 2004-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
1da177e4 4 *
7b718769
NS		 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
1da177e4
LT		 7 * published by the Free Software Foundation.
8 *
7b718769
NS		 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.
1da177e4 13 *
7b718769
NS		 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
1da177e4 17 */
1da177e4 18#include <linux/compat.h>
1da177e4 19#include <linux/ioctl.h>
62e194ec 20#include <linux/mount.h>
1da177e4 21#include <asm/uaccess.h>
1da177e4 22#include "xfs.h"
1da177e4 23#include "xfs_fs.h"
faa63e95
MM		 24#include "xfs_bit.h"
25#include "xfs_log.h"
26#include "xfs_inum.h"
27#include "xfs_trans.h"
28#include "xfs_sb.h"
29#include "xfs_ag.h"
30#include "xfs_dir2.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"
1da177e4 36#include "xfs_vnode.h"
faa63e95
MM		 37#include "xfs_dinode.h"
38#include "xfs_inode.h"
39#include "xfs_itable.h"
40#include "xfs_error.h"
1da177e4 41#include "xfs_dfrag.h"
739bfb2a 42#include "xfs_vnodeops.h"
d5547f9f 43#include "xfs_fsops.h"
471d5910 44#include "xfs_alloc.h"
45#include "xfs_rtalloc.h"
ebeecd2b 46#include "xfs_attr.h"
d5547f9f 47#include "xfs_ioctl.h"
a8272ce0 48#include "xfs_ioctl32.h"
0b1b213f 49#include "xfs_trace.h"
1da177e4 50
526c420c
ES		 51#define _NATIVE_IOC(cmd, type) \
52 _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type))
53
ffae263a 54#ifdef BROKEN_X86_ALIGNMENT
d5547f9f 55STATIC int
56xfs_compat_flock64_copyin(
57 xfs_flock64_t *bf,
58 compat_xfs_flock64_t __user *arg32)
526c420c 59{
d5547f9f 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);
68 return 0;
526c420c
ES		 69}
70
d5547f9f 71STATIC int
72xfs_compat_ioc_fsgeometry_v1(
73 struct xfs_mount *mp,
74 compat_xfs_fsop_geom_v1_t __user *arg32)
547e00c3 75{
d5547f9f 76 xfs_fsop_geom_t fsgeo;
77 int error;
547e00c3 78
d5547f9f 79 error = xfs_fs_geometry(mp, &fsgeo, 3);
80 if (error)
81 return -error;
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);
85 return 0;
547e00c3
MM		 86}
87
471d5910 88STATIC int
89xfs_compat_growfs_data_copyin(
90 struct xfs_growfs_data *in,
91 compat_xfs_growfs_data_t __user *arg32)
92{
93 if (get_user(in->newblocks, &arg32->newblocks) ||
94 get_user(in->imaxpct, &arg32->imaxpct))
95 return -XFS_ERROR(EFAULT);
96 return 0;
97}
98
99STATIC int
100xfs_compat_growfs_rt_copyin(
101 struct xfs_growfs_rt *in,
102 compat_xfs_growfs_rt_t __user *arg32)
103{
104 if (get_user(in->newblocks, &arg32->newblocks) ||
105 get_user(in->extsize, &arg32->extsize))
106 return -XFS_ERROR(EFAULT);
107 return 0;
108}
109
d5547f9f 110STATIC int
111xfs_inumbers_fmt_compat(
112 void __user *ubuffer,
113 const xfs_inogrp_t *buffer,
114 long count,
115 long *written)
faa63e95 116{
d5547f9f 117 compat_xfs_inogrp_t __user *p32 = ubuffer;
118 long i;
faa63e95
MM		 119
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))
d5547f9f 124 return -XFS_ERROR(EFAULT);
faa63e95
MM		 125 }
126 *written = count * sizeof(*p32);
127 return 0;
128}
129
1da177e4 130#else
faa63e95 131#define xfs_inumbers_fmt_compat xfs_inumbers_fmt
e5d412f1 132#endif /* BROKEN_X86_ALIGNMENT */
faa63e95 133
e94fc4a4 134STATIC int
135xfs_ioctl32_bstime_copyin(
136 xfs_bstime_t *bstime,
137 compat_xfs_bstime_t __user *bstime32)
138{
139 compat_time_t sec32; /* tv_sec differs on 64 vs. 32 */
140
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;
145 return 0;
146}
147
148/* xfs_bstat_t has differing alignment on intel, & bstime_t sizes everywhere */
149STATIC int
150xfs_ioctl32_bstat_copyin(
151 xfs_bstat_t *bstat,
152 compat_xfs_bstat_t __user *bstat32)
153{
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);
175 return 0;
176}
177
faa63e95
MM		 178/* XFS_IOC_FSBULKSTAT and friends */
179
d5547f9f 180STATIC int
181xfs_bstime_store_compat(
182 compat_xfs_bstime_t __user *p32,
183 const xfs_bstime_t *p)
faa63e95 184{
d5547f9f 185 __s32 sec32;
faa63e95
MM		 186
187 sec32 = p->tv_sec;
188 if (put_user(sec32, &p32->tv_sec) ||
189 put_user(p->tv_nsec, &p32->tv_nsec))
d5547f9f 190 return -XFS_ERROR(EFAULT);
faa63e95
MM		 191 return 0;
192}
193
65fbaf24 194/* Return 0 on success or positive error (to xfs_bulkstat()) */
d5547f9f 195STATIC int
196xfs_bulkstat_one_fmt_compat(
faa63e95 197 void __user *ubuffer,
65fbaf24 198 int ubsize,
199 int *ubused,
faa63e95
MM		 200 const xfs_bstat_t *buffer)
201{
d5547f9f 202 compat_xfs_bstat_t __user *p32 = ubuffer;
faa63e95 203
65fbaf24 204 if (ubsize < sizeof(*p32))
205 return XFS_ERROR(ENOMEM);
206
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) ||
faa63e95
MM		 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) ||
65fbaf24 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) ||
faa63e95 226 put_user(buffer->bs_aextents, &p32->bs_aextents))
65fbaf24 227 return XFS_ERROR(EFAULT);
228 if (ubused)
229 *ubused = sizeof(*p32);
230 return 0;
faa63e95
MM		 231}
232
2ee4fa5c 233STATIC int
234xfs_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_... */
244{
245 return xfs_bulkstat_one_int(mp, ino, buffer, ubsize,
246 xfs_bulkstat_one_fmt_compat, bno,
247 ubused, dibuff, stat);
248}
249
faa63e95
MM		 250/* copied from xfs_ioctl.c */
251STATIC int
2ee4fa5c 252xfs_compat_ioc_bulkstat(
253 xfs_mount_t *mp,
254 unsigned int cmd,
255 compat_xfs_fsop_bulkreq_t __user *p32)
1da177e4 256{
1da177e4 257 u32 addr;
faa63e95
MM		 258 xfs_fsop_bulkreq_t bulkreq;
259 int count; /* # of records returned */
260 xfs_ino_t inlast; /* last inode number */
261 int done;
262 int error;
263
264 /* done = 1 if there are more stats to get and if bulkstat */
265 /* should be called again (unused here, but used in dmapi) */
1da177e4 266
faa63e95 267 if (!capable(CAP_SYS_ADMIN))
d5547f9f 268 return -XFS_ERROR(EPERM);
faa63e95
MM		 269
270 if (XFS_FORCED_SHUTDOWN(mp))
271 return -XFS_ERROR(EIO);
272
273 if (get_user(addr, &p32->lastip))
d5547f9f 274 return -XFS_ERROR(EFAULT);
faa63e95
MM		 275 bulkreq.lastip = compat_ptr(addr);
276 if (get_user(bulkreq.icount, &p32->icount) ||
277 get_user(addr, &p32->ubuffer))
d5547f9f 278 return -XFS_ERROR(EFAULT);
faa63e95
MM		 279 bulkreq.ubuffer = compat_ptr(addr);
280 if (get_user(addr, &p32->ocount))
d5547f9f 281 return -XFS_ERROR(EFAULT);
faa63e95 282 bulkreq.ocount = compat_ptr(addr);
1da177e4 283
faa63e95
MM		 284 if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
285 return -XFS_ERROR(EFAULT);
286
287 if ((count = bulkreq.icount) <= 0)
288 return -XFS_ERROR(EINVAL);
289
cd57e594
LM		 290 if (bulkreq.ubuffer == NULL)
291 return -XFS_ERROR(EINVAL);
292
af819d27 293 if (cmd == XFS_IOC_FSINUMBERS_32) {
faa63e95
MM		 294 error = xfs_inumbers(mp, &inlast, &count,
295 bulkreq.ubuffer, xfs_inumbers_fmt_compat);
af819d27 296 } else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE_32) {
297 int res;
298
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) {
faa63e95 303 error = xfs_bulkstat(mp, &inlast, &count,
2ee4fa5c 304 xfs_bulkstat_one_compat, NULL,
faa63e95
MM		 305 sizeof(compat_xfs_bstat_t), bulkreq.ubuffer,
306 BULKSTAT_FG_QUICK, &done);
af819d27 307 } else
308 error = XFS_ERROR(EINVAL);
faa63e95
MM		 309 if (error)
310 return -error;
311
312 if (bulkreq.ocount != NULL) {
313 if (copy_to_user(bulkreq.lastip, &inlast,
314 sizeof(xfs_ino_t)))
315 return -XFS_ERROR(EFAULT);
316
317 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
318 return -XFS_ERROR(EFAULT);
319 }
320
321 return 0;
1da177e4 322}
faa63e95 323
d5547f9f 324STATIC int
325xfs_compat_handlereq_copyin(
326 xfs_fsop_handlereq_t *hreq,
327 compat_xfs_fsop_handlereq_t __user *arg32)
1fa503df 328{
d5547f9f 329 compat_xfs_fsop_handlereq_t hreq32;
330
331 if (copy_from_user(&hreq32, arg32, sizeof(compat_xfs_fsop_handlereq_t)))
332 return -XFS_ERROR(EFAULT);
333
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);
341
342 return 0;
1fa503df
MM		 343}
344
ab596ad8
CH		 345STATIC struct dentry *
346xfs_compat_handlereq_to_dentry(
347 struct file *parfilp,
348 compat_xfs_fsop_handlereq_t *hreq)
ebeecd2b 349{
ab596ad8
CH		 350 return xfs_handle_to_dentry(parfilp,
351 compat_ptr(hreq->ihandle), hreq->ihandlen);
ebeecd2b 352}
353
354STATIC int
355xfs_compat_attrlist_by_handle(
ab596ad8
CH		 356 struct file *parfilp,
357 void __user *arg)
ebeecd2b 358{
359 int error;
360 attrlist_cursor_kern_t *cursor;
361 compat_xfs_fsop_attrlist_handlereq_t al_hreq;
ab596ad8 362 struct dentry *dentry;
ebeecd2b 363 char *kbuf;
364
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);
372
373 /*
374 * Reject flags, only allow namespaces.
375 */
376 if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
377 return -XFS_ERROR(EINVAL);
378
ab596ad8
CH		 379 dentry = xfs_compat_handlereq_to_dentry(parfilp, &al_hreq.hreq);
380 if (IS_ERR(dentry))
381 return PTR_ERR(dentry);
ebeecd2b 382
ab596ad8 383 error = -ENOMEM;
ebeecd2b 384 kbuf = kmalloc(al_hreq.buflen, GFP_KERNEL);
385 if (!kbuf)
ab596ad8 386 goto out_dput;
ebeecd2b 387
388 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
ab596ad8 389 error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
ebeecd2b 390 al_hreq.flags, cursor);
391 if (error)
392 goto out_kfree;
393
394 if (copy_to_user(compat_ptr(al_hreq.buffer), kbuf, al_hreq.buflen))
395 error = -EFAULT;
396
397 out_kfree:
398 kfree(kbuf);
ab596ad8
CH		 399 out_dput:
400 dput(dentry);
401 return error;
ebeecd2b 402}
403
28750975 404STATIC int
405xfs_compat_attrmulti_by_handle(
ab596ad8
CH		 406 struct file *parfilp,
407 void __user *arg)
28750975 408{
409 int error;
410 compat_xfs_attr_multiop_t *ops;
411 compat_xfs_fsop_attrmulti_handlereq_t am_hreq;
ab596ad8 412 struct dentry *dentry;
28750975 413 unsigned int i, size;
a9273ca5 414 unsigned char *attr_name;
28750975 415
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);
421
ab596ad8
CH		 422 dentry = xfs_compat_handlereq_to_dentry(parfilp, &am_hreq.hreq);
423 if (IS_ERR(dentry))
424 return PTR_ERR(dentry);
28750975 425
426 error = E2BIG;
427 size = am_hreq.opcount * sizeof(compat_xfs_attr_multiop_t);
428 if (!size || size > 16 * PAGE_SIZE)
ab596ad8 429 goto out_dput;
28750975 430
0e639bde
LZ		 431 ops = memdup_user(compat_ptr(am_hreq.ops), size);
432 if (IS_ERR(ops)) {
433 error = PTR_ERR(ops);
ab596ad8 434 goto out_dput;
0e639bde 435 }
28750975 436
437 attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
438 if (!attr_name)
439 goto out_kfree_ops;
440
28750975 441 error = 0;
442 for (i = 0; i < am_hreq.opcount; i++) {
a9273ca5 443 ops[i].am_error = strncpy_from_user((char *)attr_name,
28750975 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:
ab596ad8
CH		 453 ops[i].am_error = xfs_attrmulti_attr_get(
454 dentry->d_inode, attr_name,
28750975 455 compat_ptr(ops[i].am_attrvalue),
456 &ops[i].am_length, ops[i].am_flags);
457 break;
458 case ATTR_OP_SET:
62e194ec
CH		 459 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
460 if (ops[i].am_error)
461 break;
ab596ad8
CH		 462 ops[i].am_error = xfs_attrmulti_attr_set(
463 dentry->d_inode, attr_name,
28750975 464 compat_ptr(ops[i].am_attrvalue),
465 ops[i].am_length, ops[i].am_flags);
62e194ec 466 mnt_drop_write(parfilp->f_path.mnt);
28750975 467 break;
468 case ATTR_OP_REMOVE:
62e194ec
CH		 469 ops[i].am_error = mnt_want_write(parfilp->f_path.mnt);
470 if (ops[i].am_error)
471 break;
ab596ad8
CH		 472 ops[i].am_error = xfs_attrmulti_attr_remove(
473 dentry->d_inode, attr_name,
474 ops[i].am_flags);
62e194ec 475 mnt_drop_write(parfilp->f_path.mnt);
28750975 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);
ab596ad8
CH		 488 out_dput:
489 dput(dentry);
28750975 490 return -error;
491}
492
710d62aa 493STATIC int
494xfs_compat_fssetdm_by_handle(
ab596ad8
CH		 495 struct file *parfilp,
496 void __user *arg)
710d62aa 497{
498 int error;
499 struct fsdmidata fsd;
500 compat_xfs_fsop_setdm_handlereq_t dmhreq;
ab596ad8 501 struct dentry *dentry;
710d62aa 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
ab596ad8
CH		 509 dentry = xfs_compat_handlereq_to_dentry(parfilp, &dmhreq.hreq);
510 if (IS_ERR(dentry))
511 return PTR_ERR(dentry);
710d62aa 512
ab596ad8 513 if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
710d62aa 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
ab596ad8 523 error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
710d62aa 524 fsd.fsd_dmstate);
525
526out:
ab596ad8 527 dput(dentry);
710d62aa 528 return error;
529}
530
4d4be482
CH		 531long
532xfs_file_compat_ioctl(
533 struct file *filp,
534 unsigned cmd,
535 unsigned long p)
1da177e4 536{
4d4be482
CH		 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;
541 int ioflags = 0;
542 int error;
543
544 if (filp->f_mode & FMODE_NOCMTIME)
545 ioflags |= IO_INVIS;
546
547 xfs_itrace_entry(ip);
1da177e4
LT		 548
549 switch (cmd) {
e5d412f1 550 /* No size or alignment issues on any arch */
1da177e4 551 case XFS_IOC_DIOINFO:
1da177e4 552 case XFS_IOC_FSGEOMETRY:
1da177e4
LT		 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:
1da177e4
LT		 560 case XFS_IOC_FSCOUNTS:
561 case XFS_IOC_SET_RESBLKS:
562 case XFS_IOC_GET_RESBLKS:
1da177e4 563 case XFS_IOC_FSGROWFSLOG:
1da177e4
LT		 564 case XFS_IOC_GOINGDOWN:
565 case XFS_IOC_ERROR_INJECTION:
566 case XFS_IOC_ERROR_CLEARALL:
4d4be482 567 return xfs_file_ioctl(filp, cmd, p);
e5d412f1 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:
4d4be482 581 return xfs_file_ioctl(filp, cmd, p);
e5d412f1 582#else
526c420c
ES		 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:
d5547f9f 590 case XFS_IOC_UNRESVSP64_32: {
591 struct xfs_flock64 bf;
592
593 if (xfs_compat_flock64_copyin(&bf, arg))
594 return -XFS_ERROR(EFAULT);
526c420c 595 cmd = _NATIVE_IOC(cmd, struct xfs_flock64);
d5547f9f 596 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
597 }
547e00c3 598 case XFS_IOC_FSGEOMETRY_V1_32:
d5547f9f 599 return xfs_compat_ioc_fsgeometry_v1(mp, arg);
471d5910 600 case XFS_IOC_FSGROWFSDATA_32: {
601 struct xfs_growfs_data in;
602
603 if (xfs_compat_growfs_data_copyin(&in, arg))
604 return -XFS_ERROR(EFAULT);
605 error = xfs_growfs_data(mp, &in);
606 return -error;
607 }
608 case XFS_IOC_FSGROWFSRT_32: {
609 struct xfs_growfs_rt in;
610
611 if (xfs_compat_growfs_rt_copyin(&in, arg))
612 return -XFS_ERROR(EFAULT);
613 error = xfs_growfs_rt(mp, &in);
614 return -error;
615 }
1da177e4 616#endif
e5d412f1 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);
4d4be482 622 return xfs_file_ioctl(filp, cmd, p);
3725867d 623 case XFS_IOC_SWAPEXT_32: {
e5d412f1 624 struct xfs_swapext sxp;
625 struct compat_xfs_swapext __user *sxu = arg;
626
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);
633 return -error;
634 }
faa63e95
MM		 635 case XFS_IOC_FSBULKSTAT_32:
636 case XFS_IOC_FSBULKSTAT_SINGLE_32:
637 case XFS_IOC_FSINUMBERS_32:
2ee4fa5c 638 return xfs_compat_ioc_bulkstat(mp, cmd, arg);
1fa503df
MM		 639 case XFS_IOC_FD_TO_HANDLE_32:
640 case XFS_IOC_PATH_TO_HANDLE_32:
d5547f9f 641 case XFS_IOC_PATH_TO_FSHANDLE_32: {
642 struct xfs_fsop_handlereq hreq;
643
644 if (xfs_compat_handlereq_copyin(&hreq, arg))
645 return -XFS_ERROR(EFAULT);
1fa503df 646 cmd = _NATIVE_IOC(cmd, struct xfs_fsop_handlereq);
d5547f9f 647 return xfs_find_handle(cmd, &hreq);
648 }
649 case XFS_IOC_OPEN_BY_HANDLE_32: {
650 struct xfs_fsop_handlereq hreq;
651
652 if (xfs_compat_handlereq_copyin(&hreq, arg))
653 return -XFS_ERROR(EFAULT);
ab596ad8 654 return xfs_open_by_handle(filp, &hreq);
d5547f9f 655 }
656 case XFS_IOC_READLINK_BY_HANDLE_32: {
657 struct xfs_fsop_handlereq hreq;
658
659 if (xfs_compat_handlereq_copyin(&hreq, arg))
660 return -XFS_ERROR(EFAULT);
ab596ad8 661 return xfs_readlink_by_handle(filp, &hreq);
d5547f9f 662 }
ebeecd2b 663 case XFS_IOC_ATTRLIST_BY_HANDLE_32:
ab596ad8 664 return xfs_compat_attrlist_by_handle(filp, arg);
28750975 665 case XFS_IOC_ATTRMULTI_BY_HANDLE_32:
ab596ad8 666 return xfs_compat_attrmulti_by_handle(filp, arg);
710d62aa 667 case XFS_IOC_FSSETDM_BY_HANDLE_32:
ab596ad8 668 return xfs_compat_fssetdm_by_handle(filp, arg);
1da177e4 669 default:
d5547f9f 670 return -XFS_ERROR(ENOIOCTLCMD);
1da177e4 671 }
1da177e4 672}
Linux 6.x block layer and io_uring tree(s)