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

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

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ 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 <asm/uaccess.h>
 23 #include "xfs.h"
 24 #include "xfs_fs.h"
 25 #include "xfs_format.h"
 26 #include "xfs_log_format.h"
 27 #include "xfs_trans_resv.h"
 28 #include "xfs_sb.h"
 29 #include "xfs_ag.h"
 30 #include "xfs_mount.h"
 31 #include "xfs_vnode.h"
 32 #include "xfs_inode.h"
 33 #include "xfs_itable.h"
 34 #include "xfs_error.h"
 35 #include "xfs_fsops.h"
 36 #include "xfs_alloc.h"
 37 #include "xfs_rtalloc.h"
 38 #include "xfs_attr.h"
 39 #include "xfs_ioctl.h"
 40 #include "xfs_ioctl32.h"
 41 #include "xfs_trace.h"
 42 
 43 #define  _NATIVE_IOC(cmd, type) \
 44           _IOC(_IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), sizeof(type))
 45 
 46 #ifdef BROKEN_X86_ALIGNMENT
 47 STATIC int
 48 xfs_compat_flock64_copyin(
 49         xfs_flock64_t           *bf,
 50         compat_xfs_flock64_t    __user *arg32)
 51 {
 52         if (get_user(bf->l_type,        &arg32->l_type) ||
 53             get_user(bf->l_whence,      &arg32->l_whence) ||
 54             get_user(bf->l_start,       &arg32->l_start) ||
 55             get_user(bf->l_len,         &arg32->l_len) ||
 56             get_user(bf->l_sysid,       &arg32->l_sysid) ||
 57             get_user(bf->l_pid,         &arg32->l_pid) ||
 58             copy_from_user(bf->l_pad,   &arg32->l_pad,  4*sizeof(u32)))
 59                 return -XFS_ERROR(EFAULT);
 60         return 0;
 61 }
 62 
 63 STATIC int
 64 xfs_compat_ioc_fsgeometry_v1(
 65         struct xfs_mount          *mp,
 66         compat_xfs_fsop_geom_v1_t __user *arg32)
 67 {
 68         xfs_fsop_geom_t           fsgeo;
 69         int                       error;
 70 
 71         error = xfs_fs_geometry(mp, &fsgeo, 3);
 72         if (error)
 73                 return -error;
 74         /* The 32-bit variant simply has some padding at the end */
 75         if (copy_to_user(arg32, &fsgeo, sizeof(struct compat_xfs_fsop_geom_v1)))
 76                 return -XFS_ERROR(EFAULT);
 77         return 0;
 78 }
 79 
 80 STATIC int
 81 xfs_compat_growfs_data_copyin(
 82         struct xfs_growfs_data   *in,
 83         compat_xfs_growfs_data_t __user *arg32)
 84 {
 85         if (get_user(in->newblocks, &arg32->newblocks) ||
 86             get_user(in->imaxpct,   &arg32->imaxpct))
 87                 return -XFS_ERROR(EFAULT);
 88         return 0;
 89 }
 90 
 91 STATIC int
 92 xfs_compat_growfs_rt_copyin(
 93         struct xfs_growfs_rt     *in,
 94         compat_xfs_growfs_rt_t  __user *arg32)
 95 {
 96         if (get_user(in->newblocks, &arg32->newblocks) ||
 97             get_user(in->extsize,   &arg32->extsize))
 98                 return -XFS_ERROR(EFAULT);
 99         return 0;
100 }
101 
102 STATIC int
103 xfs_inumbers_fmt_compat(
104         void                    __user *ubuffer,
105         const xfs_inogrp_t      *buffer,
106         long                    count,
107         long                    *written)
108 {
109         compat_xfs_inogrp_t     __user *p32 = ubuffer;
110         long                    i;
111 
112         for (i = 0; i < count; i++) {
113                 if (put_user(buffer[i].xi_startino,   &p32[i].xi_startino) ||
114                     put_user(buffer[i].xi_alloccount, &p32[i].xi_alloccount) ||
115                     put_user(buffer[i].xi_allocmask,  &p32[i].xi_allocmask))
116                         return -XFS_ERROR(EFAULT);
117         }
118         *written = count * sizeof(*p32);
119         return 0;
120 }
121 
122 #else
123 #define xfs_inumbers_fmt_compat xfs_inumbers_fmt
124 #endif  /* BROKEN_X86_ALIGNMENT */
125 
126 STATIC int
127 xfs_ioctl32_bstime_copyin(
128         xfs_bstime_t            *bstime,
129         compat_xfs_bstime_t     __user *bstime32)
130 {
131         compat_time_t           sec32;  /* tv_sec differs on 64 vs. 32 */
132 
133         if (get_user(sec32,             &bstime32->tv_sec)      ||
134             get_user(bstime->tv_nsec,   &bstime32->tv_nsec))
135                 return -XFS_ERROR(EFAULT);
136         bstime->tv_sec = sec32;
137         return 0;
138 }
139 
140 /* xfs_bstat_t has differing alignment on intel, & bstime_t sizes everywhere */
141 STATIC int
142 xfs_ioctl32_bstat_copyin(
143         xfs_bstat_t             *bstat,
144         compat_xfs_bstat_t      __user *bstat32)
145 {
146         if (get_user(bstat->bs_ino,     &bstat32->bs_ino)       ||
147             get_user(bstat->bs_mode,    &bstat32->bs_mode)      ||
148             get_user(bstat->bs_nlink,   &bstat32->bs_nlink)     ||
149             get_user(bstat->bs_uid,     &bstat32->bs_uid)       ||
150             get_user(bstat->bs_gid,     &bstat32->bs_gid)       ||
151             get_user(bstat->bs_rdev,    &bstat32->bs_rdev)      ||
152             get_user(bstat->bs_blksize, &bstat32->bs_blksize)   ||
153             get_user(bstat->bs_size,    &bstat32->bs_size)      ||
154             xfs_ioctl32_bstime_copyin(&bstat->bs_atime, &bstat32->bs_atime) ||
155             xfs_ioctl32_bstime_copyin(&bstat->bs_mtime, &bstat32->bs_mtime) ||
156             xfs_ioctl32_bstime_copyin(&bstat->bs_ctime, &bstat32->bs_ctime) ||
157             get_user(bstat->bs_blocks,  &bstat32->bs_size)      ||
158             get_user(bstat->bs_xflags,  &bstat32->bs_size)      ||
159             get_user(bstat->bs_extsize, &bstat32->bs_extsize)   ||
160             get_user(bstat->bs_extents, &bstat32->bs_extents)   ||
161             get_user(bstat->bs_gen,     &bstat32->bs_gen)       ||
162             get_user(bstat->bs_projid_lo, &bstat32->bs_projid_lo) ||
163             get_user(bstat->bs_projid_hi, &bstat32->bs_projid_hi) ||
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))
167                 return -XFS_ERROR(EFAULT);
168         return 0;
169 }
170 
171 /* XFS_IOC_FSBULKSTAT and friends */
172 
173 STATIC int
174 xfs_bstime_store_compat(
175         compat_xfs_bstime_t     __user *p32,
176         const xfs_bstime_t      *p)
177 {
178         __s32                   sec32;
179 
180         sec32 = p->tv_sec;
181         if (put_user(sec32, &p32->tv_sec) ||
182             put_user(p->tv_nsec, &p32->tv_nsec))
183                 return -XFS_ERROR(EFAULT);
184         return 0;
185 }
186 
187 /* Return 0 on success or positive error (to xfs_bulkstat()) */
188 STATIC int
189 xfs_bulkstat_one_fmt_compat(
190         void                    __user *ubuffer,
191         int                     ubsize,
192         int                     *ubused,
193         const xfs_bstat_t       *buffer)
194 {
195         compat_xfs_bstat_t      __user *p32 = ubuffer;
196 
197         if (ubsize < sizeof(*p32))
198                 return XFS_ERROR(ENOMEM);
199 
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_dmevmask, &p32->bs_dmevmask)    ||
219             put_user(buffer->bs_dmstate,  &p32->bs_dmstate)     ||
220             put_user(buffer->bs_aextents, &p32->bs_aextents))
221                 return XFS_ERROR(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 -XFS_ERROR(EPERM);
260 
261         if (XFS_FORCED_SHUTDOWN(mp))
262                 return -XFS_ERROR(EIO);
263 
264         if (get_user(addr, &p32->lastip))
265                 return -XFS_ERROR(EFAULT);
266         bulkreq.lastip = compat_ptr(addr);
267         if (get_user(bulkreq.icount, &p32->icount) ||
268             get_user(addr, &p32->ubuffer))
269                 return -XFS_ERROR(EFAULT);
270         bulkreq.ubuffer = compat_ptr(addr);
271         if (get_user(addr, &p32->ocount))
272                 return -XFS_ERROR(EFAULT);
273         bulkreq.ocount = compat_ptr(addr);
274 
275         if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
276                 return -XFS_ERROR(EFAULT);
277 
278         if ((count = bulkreq.icount) <= 0)
279                 return -XFS_ERROR(EINVAL);
280 
281         if (bulkreq.ubuffer == NULL)
282                 return -XFS_ERROR(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 = XFS_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 -XFS_ERROR(EFAULT);
305 
306                 if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
307                         return -XFS_ERROR(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 -XFS_ERROR(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 -XFS_ERROR(EPERM);
356         if (copy_from_user(&al_hreq, arg,
357                            sizeof(compat_xfs_fsop_attrlist_handlereq_t)))
358                 return -XFS_ERROR(EFAULT);
359         if (al_hreq.buflen < sizeof(struct attrlist) ||
360             al_hreq.buflen > XATTR_LIST_MAX)
361                 return -XFS_ERROR(EINVAL);
362 
363         /*
364          * Reject flags, only allow namespaces.
365          */
366         if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
367                 return -XFS_ERROR(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(dentry->d_inode), 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 -XFS_ERROR(EPERM);
408         if (copy_from_user(&am_hreq, arg,
409                            sizeof(compat_xfs_fsop_attrmulti_handlereq_t)))
410                 return -XFS_ERROR(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         attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
432         if (!attr_name)
433                 goto out_kfree_ops;
434 
435         error = 0;
436         for (i = 0; i < am_hreq.opcount; i++) {
437                 ops[i].am_error = strncpy_from_user((char *)attr_name,
438                                 compat_ptr(ops[i].am_attrname),
439                                 MAXNAMELEN);
440                 if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
441                         error = -ERANGE;
442                 if (ops[i].am_error < 0)
443                         break;
444 
445                 switch (ops[i].am_opcode) {
446                 case ATTR_OP_GET:
447                         ops[i].am_error = xfs_attrmulti_attr_get(
448                                         dentry->d_inode, attr_name,
449                                         compat_ptr(ops[i].am_attrvalue),
450                                         &ops[i].am_length, ops[i].am_flags);
451                         break;
452                 case ATTR_OP_SET:
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_set(
457                                         dentry->d_inode, attr_name,
458                                         compat_ptr(ops[i].am_attrvalue),
459                                         ops[i].am_length, ops[i].am_flags);
460                         mnt_drop_write_file(parfilp);
461                         break;
462                 case ATTR_OP_REMOVE:
463                         ops[i].am_error = mnt_want_write_file(parfilp);
464                         if (ops[i].am_error)
465                                 break;
466                         ops[i].am_error = xfs_attrmulti_attr_remove(
467                                         dentry->d_inode, attr_name,
468                                         ops[i].am_flags);
469                         mnt_drop_write_file(parfilp);
470                         break;
471                 default:
472                         ops[i].am_error = EINVAL;
473                 }
474         }
475 
476         if (copy_to_user(compat_ptr(am_hreq.ops), ops, size))
477                 error = XFS_ERROR(EFAULT);
478 
479         kfree(attr_name);
480  out_kfree_ops:
481         kfree(ops);
482  out_dput:
483         dput(dentry);
484         return -error;
485 }
486 
487 STATIC int
488 xfs_compat_fssetdm_by_handle(
489         struct file             *parfilp,
490         void                    __user *arg)
491 {
492         int                     error;
493         struct fsdmidata        fsd;
494         compat_xfs_fsop_setdm_handlereq_t dmhreq;
495         struct dentry           *dentry;
496 
497         if (!capable(CAP_MKNOD))
498                 return -XFS_ERROR(EPERM);
499         if (copy_from_user(&dmhreq, arg,
500                            sizeof(compat_xfs_fsop_setdm_handlereq_t)))
501                 return -XFS_ERROR(EFAULT);
502 
503         dentry = xfs_compat_handlereq_to_dentry(parfilp, &dmhreq.hreq);
504         if (IS_ERR(dentry))
505                 return PTR_ERR(dentry);
506 
507         if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
508                 error = -XFS_ERROR(EPERM);
509                 goto out;
510         }
511 
512         if (copy_from_user(&fsd, compat_ptr(dmhreq.data), sizeof(fsd))) {
513                 error = -XFS_ERROR(EFAULT);
514                 goto out;
515         }
516 
517         error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
518                                  fsd.fsd_dmstate);
519 
520 out:
521         dput(dentry);
522         return error;
523 }
524 
525 long
526 xfs_file_compat_ioctl(
527         struct file             *filp,
528         unsigned                cmd,
529         unsigned long           p)
530 {
531         struct inode            *inode = file_inode(filp);
532         struct xfs_inode        *ip = XFS_I(inode);
533         struct xfs_mount        *mp = ip->i_mount;
534         void                    __user *arg = (void __user *)p;
535         int                     ioflags = 0;
536         int                     error;
537 
538         if (filp->f_mode & FMODE_NOCMTIME)
539                 ioflags |= IO_INVIS;
540 
541         trace_xfs_file_compat_ioctl(ip);
542 
543         switch (cmd) {
544         /* No size or alignment issues on any arch */
545         case XFS_IOC_DIOINFO:
546         case XFS_IOC_FSGEOMETRY:
547         case XFS_IOC_FSGETXATTR:
548         case XFS_IOC_FSSETXATTR:
549         case XFS_IOC_FSGETXATTRA:
550         case XFS_IOC_FSSETDM:
551         case XFS_IOC_GETBMAP:
552         case XFS_IOC_GETBMAPA:
553         case XFS_IOC_GETBMAPX:
554         case XFS_IOC_FSCOUNTS:
555         case XFS_IOC_SET_RESBLKS:
556         case XFS_IOC_GET_RESBLKS:
557         case XFS_IOC_FSGROWFSLOG:
558         case XFS_IOC_GOINGDOWN:
559         case XFS_IOC_ERROR_INJECTION:
560         case XFS_IOC_ERROR_CLEARALL:
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:
565         case XFS_IOC_FREESP:
566         case XFS_IOC_RESVSP:
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);
577 #else
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;
588 
589                 if (xfs_compat_flock64_copyin(&bf, arg))
590                         return -XFS_ERROR(EFAULT);
591                 cmd = _NATIVE_IOC(cmd, struct xfs_flock64);
592                 return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
593         }
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;
598 
599                 if (xfs_compat_growfs_data_copyin(&in, arg))
600                         return -XFS_ERROR(EFAULT);
601                 error = mnt_want_write_file(filp);
602                 if (error)
603                         return error;
604                 error = xfs_growfs_data(mp, &in);
605                 mnt_drop_write_file(filp);
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 = mnt_want_write_file(filp);
614                 if (error)
615                         return error;
616                 error = xfs_growfs_rt(mp, &in);
617                 mnt_drop_write_file(filp);
618                 return -error;
619         }
620 #endif
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;
630 
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))
635                         return -XFS_ERROR(EFAULT);
636                 error = mnt_want_write_file(filp);
637                 if (error)
638                         return error;
639                 error = xfs_ioc_swapext(&sxp);
640                 mnt_drop_write_file(filp);
641                 return -error;
642         }
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;
651 
652                 if (xfs_compat_handlereq_copyin(&hreq, arg))
653                         return -XFS_ERROR(EFAULT);
654                 cmd = _NATIVE_IOC(cmd, struct xfs_fsop_handlereq);
655                 return xfs_find_handle(cmd, &hreq);
656         }
657         case XFS_IOC_OPEN_BY_HANDLE_32: {
658                 struct xfs_fsop_handlereq       hreq;
659 
660                 if (xfs_compat_handlereq_copyin(&hreq, arg))
661                         return -XFS_ERROR(EFAULT);
662                 return xfs_open_by_handle(filp, &hreq);
663         }
664         case XFS_IOC_READLINK_BY_HANDLE_32: {
665                 struct xfs_fsop_handlereq       hreq;
666 
667                 if (xfs_compat_handlereq_copyin(&hreq, arg))
668                         return -XFS_ERROR(EFAULT);
669                 return xfs_readlink_by_handle(filp, &hreq);
670         }
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);
677         default:
678                 return -XFS_ERROR(ENOIOCTLCMD);
679         }
680 }
681 

~ [ 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