~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/xfs_ioctl32.c

Version: ~ [ linux-5.4 ] ~ [ linux-5.3.13 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.86 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.156 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.203 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.202 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp