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