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

TOMOYO Linux Cross Reference
Linux/fs/ext4/ioctl.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.14 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.57 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.138 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.193 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ 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.85 ] ~ [ 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-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 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * linux/fs/ext4/ioctl.c
  4  *
  5  * Copyright (C) 1993, 1994, 1995
  6  * Remy Card (card@masi.ibp.fr)
  7  * Laboratoire MASI - Institut Blaise Pascal
  8  * Universite Pierre et Marie Curie (Paris VI)
  9  */
 10 
 11 #include <linux/fs.h>
 12 #include <linux/capability.h>
 13 #include <linux/time.h>
 14 #include <linux/compat.h>
 15 #include <linux/mount.h>
 16 #include <linux/file.h>
 17 #include <linux/quotaops.h>
 18 #include <linux/random.h>
 19 #include <linux/uuid.h>
 20 #include <linux/uaccess.h>
 21 #include <linux/delay.h>
 22 #include <linux/iversion.h>
 23 #include "ext4_jbd2.h"
 24 #include "ext4.h"
 25 #include <linux/fsmap.h>
 26 #include "fsmap.h"
 27 #include <trace/events/ext4.h>
 28 
 29 /**
 30  * Swap memory between @a and @b for @len bytes.
 31  *
 32  * @a:          pointer to first memory area
 33  * @b:          pointer to second memory area
 34  * @len:        number of bytes to swap
 35  *
 36  */
 37 static void memswap(void *a, void *b, size_t len)
 38 {
 39         unsigned char *ap, *bp;
 40 
 41         ap = (unsigned char *)a;
 42         bp = (unsigned char *)b;
 43         while (len-- > 0) {
 44                 swap(*ap, *bp);
 45                 ap++;
 46                 bp++;
 47         }
 48 }
 49 
 50 /**
 51  * Swap i_data and associated attributes between @inode1 and @inode2.
 52  * This function is used for the primary swap between inode1 and inode2
 53  * and also to revert this primary swap in case of errors.
 54  *
 55  * Therefore you have to make sure, that calling this method twice
 56  * will revert all changes.
 57  *
 58  * @inode1:     pointer to first inode
 59  * @inode2:     pointer to second inode
 60  */
 61 static void swap_inode_data(struct inode *inode1, struct inode *inode2)
 62 {
 63         loff_t isize;
 64         struct ext4_inode_info *ei1;
 65         struct ext4_inode_info *ei2;
 66         unsigned long tmp;
 67 
 68         ei1 = EXT4_I(inode1);
 69         ei2 = EXT4_I(inode2);
 70 
 71         swap(inode1->i_version, inode2->i_version);
 72         swap(inode1->i_atime, inode2->i_atime);
 73         swap(inode1->i_mtime, inode2->i_mtime);
 74 
 75         memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data));
 76         tmp = ei1->i_flags & EXT4_FL_SHOULD_SWAP;
 77         ei1->i_flags = (ei2->i_flags & EXT4_FL_SHOULD_SWAP) |
 78                 (ei1->i_flags & ~EXT4_FL_SHOULD_SWAP);
 79         ei2->i_flags = tmp | (ei2->i_flags & ~EXT4_FL_SHOULD_SWAP);
 80         swap(ei1->i_disksize, ei2->i_disksize);
 81         ext4_es_remove_extent(inode1, 0, EXT_MAX_BLOCKS);
 82         ext4_es_remove_extent(inode2, 0, EXT_MAX_BLOCKS);
 83 
 84         isize = i_size_read(inode1);
 85         i_size_write(inode1, i_size_read(inode2));
 86         i_size_write(inode2, isize);
 87 }
 88 
 89 static void reset_inode_seed(struct inode *inode)
 90 {
 91         struct ext4_inode_info *ei = EXT4_I(inode);
 92         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
 93         __le32 inum = cpu_to_le32(inode->i_ino);
 94         __le32 gen = cpu_to_le32(inode->i_generation);
 95         __u32 csum;
 96 
 97         if (!ext4_has_metadata_csum(inode->i_sb))
 98                 return;
 99 
100         csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum, sizeof(inum));
101         ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen, sizeof(gen));
102 }
103 
104 /**
105  * Swap the information from the given @inode and the inode
106  * EXT4_BOOT_LOADER_INO. It will basically swap i_data and all other
107  * important fields of the inodes.
108  *
109  * @sb:         the super block of the filesystem
110  * @inode:      the inode to swap with EXT4_BOOT_LOADER_INO
111  *
112  */
113 static long swap_inode_boot_loader(struct super_block *sb,
114                                 struct inode *inode)
115 {
116         handle_t *handle;
117         int err;
118         struct inode *inode_bl;
119         struct ext4_inode_info *ei_bl;
120         qsize_t size, size_bl, diff;
121         blkcnt_t blocks;
122         unsigned short bytes;
123 
124         inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO, EXT4_IGET_SPECIAL);
125         if (IS_ERR(inode_bl))
126                 return PTR_ERR(inode_bl);
127         ei_bl = EXT4_I(inode_bl);
128 
129         /* Protect orig inodes against a truncate and make sure,
130          * that only 1 swap_inode_boot_loader is running. */
131         lock_two_nondirectories(inode, inode_bl);
132 
133         if (inode->i_nlink != 1 || !S_ISREG(inode->i_mode) ||
134             IS_SWAPFILE(inode) || IS_ENCRYPTED(inode) ||
135             (EXT4_I(inode)->i_flags & EXT4_JOURNAL_DATA_FL) ||
136             ext4_has_inline_data(inode)) {
137                 err = -EINVAL;
138                 goto journal_err_out;
139         }
140 
141         if (IS_RDONLY(inode) || IS_APPEND(inode) || IS_IMMUTABLE(inode) ||
142             !inode_owner_or_capable(inode) || !capable(CAP_SYS_ADMIN)) {
143                 err = -EPERM;
144                 goto journal_err_out;
145         }
146 
147         down_write(&EXT4_I(inode)->i_mmap_sem);
148         err = filemap_write_and_wait(inode->i_mapping);
149         if (err)
150                 goto err_out;
151 
152         err = filemap_write_and_wait(inode_bl->i_mapping);
153         if (err)
154                 goto err_out;
155 
156         /* Wait for all existing dio workers */
157         inode_dio_wait(inode);
158         inode_dio_wait(inode_bl);
159 
160         truncate_inode_pages(&inode->i_data, 0);
161         truncate_inode_pages(&inode_bl->i_data, 0);
162 
163         handle = ext4_journal_start(inode_bl, EXT4_HT_MOVE_EXTENTS, 2);
164         if (IS_ERR(handle)) {
165                 err = -EINVAL;
166                 goto err_out;
167         }
168 
169         /* Protect extent tree against block allocations via delalloc */
170         ext4_double_down_write_data_sem(inode, inode_bl);
171 
172         if (inode_bl->i_nlink == 0) {
173                 /* this inode has never been used as a BOOT_LOADER */
174                 set_nlink(inode_bl, 1);
175                 i_uid_write(inode_bl, 0);
176                 i_gid_write(inode_bl, 0);
177                 inode_bl->i_flags = 0;
178                 ei_bl->i_flags = 0;
179                 inode_set_iversion(inode_bl, 1);
180                 i_size_write(inode_bl, 0);
181                 inode_bl->i_mode = S_IFREG;
182                 if (ext4_has_feature_extents(sb)) {
183                         ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);
184                         ext4_ext_tree_init(handle, inode_bl);
185                 } else
186                         memset(ei_bl->i_data, 0, sizeof(ei_bl->i_data));
187         }
188 
189         err = dquot_initialize(inode);
190         if (err)
191                 goto err_out1;
192 
193         size = (qsize_t)(inode->i_blocks) * (1 << 9) + inode->i_bytes;
194         size_bl = (qsize_t)(inode_bl->i_blocks) * (1 << 9) + inode_bl->i_bytes;
195         diff = size - size_bl;
196         swap_inode_data(inode, inode_bl);
197 
198         inode->i_ctime = inode_bl->i_ctime = current_time(inode);
199 
200         inode->i_generation = prandom_u32();
201         inode_bl->i_generation = prandom_u32();
202         reset_inode_seed(inode);
203         reset_inode_seed(inode_bl);
204 
205         ext4_discard_preallocations(inode);
206 
207         err = ext4_mark_inode_dirty(handle, inode);
208         if (err < 0) {
209                 /* No need to update quota information. */
210                 ext4_warning(inode->i_sb,
211                         "couldn't mark inode #%lu dirty (err %d)",
212                         inode->i_ino, err);
213                 /* Revert all changes: */
214                 swap_inode_data(inode, inode_bl);
215                 ext4_mark_inode_dirty(handle, inode);
216                 goto err_out1;
217         }
218 
219         blocks = inode_bl->i_blocks;
220         bytes = inode_bl->i_bytes;
221         inode_bl->i_blocks = inode->i_blocks;
222         inode_bl->i_bytes = inode->i_bytes;
223         err = ext4_mark_inode_dirty(handle, inode_bl);
224         if (err < 0) {
225                 /* No need to update quota information. */
226                 ext4_warning(inode_bl->i_sb,
227                         "couldn't mark inode #%lu dirty (err %d)",
228                         inode_bl->i_ino, err);
229                 goto revert;
230         }
231 
232         /* Bootloader inode should not be counted into quota information. */
233         if (diff > 0)
234                 dquot_free_space(inode, diff);
235         else
236                 err = dquot_alloc_space(inode, -1 * diff);
237 
238         if (err < 0) {
239 revert:
240                 /* Revert all changes: */
241                 inode_bl->i_blocks = blocks;
242                 inode_bl->i_bytes = bytes;
243                 swap_inode_data(inode, inode_bl);
244                 ext4_mark_inode_dirty(handle, inode);
245                 ext4_mark_inode_dirty(handle, inode_bl);
246         }
247 
248 err_out1:
249         ext4_journal_stop(handle);
250         ext4_double_up_write_data_sem(inode, inode_bl);
251 
252 err_out:
253         up_write(&EXT4_I(inode)->i_mmap_sem);
254 journal_err_out:
255         unlock_two_nondirectories(inode, inode_bl);
256         iput(inode_bl);
257         return err;
258 }
259 
260 #ifdef CONFIG_FS_ENCRYPTION
261 static int uuid_is_zero(__u8 u[16])
262 {
263         int     i;
264 
265         for (i = 0; i < 16; i++)
266                 if (u[i])
267                         return 0;
268         return 1;
269 }
270 #endif
271 
272 /*
273  * If immutable is set and we are not clearing it, we're not allowed to change
274  * anything else in the inode.  Don't error out if we're only trying to set
275  * immutable on an immutable file.
276  */
277 static int ext4_ioctl_check_immutable(struct inode *inode, __u32 new_projid,
278                                       unsigned int flags)
279 {
280         struct ext4_inode_info *ei = EXT4_I(inode);
281         unsigned int oldflags = ei->i_flags;
282 
283         if (!(oldflags & EXT4_IMMUTABLE_FL) || !(flags & EXT4_IMMUTABLE_FL))
284                 return 0;
285 
286         if ((oldflags & ~EXT4_IMMUTABLE_FL) != (flags & ~EXT4_IMMUTABLE_FL))
287                 return -EPERM;
288         if (ext4_has_feature_project(inode->i_sb) &&
289             __kprojid_val(ei->i_projid) != new_projid)
290                 return -EPERM;
291 
292         return 0;
293 }
294 
295 static int ext4_ioctl_setflags(struct inode *inode,
296                                unsigned int flags)
297 {
298         struct ext4_inode_info *ei = EXT4_I(inode);
299         handle_t *handle = NULL;
300         int err = -EPERM, migrate = 0;
301         struct ext4_iloc iloc;
302         unsigned int oldflags, mask, i;
303         unsigned int jflag;
304         struct super_block *sb = inode->i_sb;
305 
306         /* Is it quota file? Do not allow user to mess with it */
307         if (ext4_is_quota_file(inode))
308                 goto flags_out;
309 
310         oldflags = ei->i_flags;
311 
312         /* The JOURNAL_DATA flag is modifiable only by root */
313         jflag = flags & EXT4_JOURNAL_DATA_FL;
314 
315         /*
316          * The IMMUTABLE and APPEND_ONLY flags can only be changed by
317          * the relevant capability.
318          *
319          * This test looks nicer. Thanks to Pauline Middelink
320          */
321         if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) {
322                 if (!capable(CAP_LINUX_IMMUTABLE))
323                         goto flags_out;
324         }
325 
326         /*
327          * The JOURNAL_DATA flag can only be changed by
328          * the relevant capability.
329          */
330         if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
331                 if (!capable(CAP_SYS_RESOURCE))
332                         goto flags_out;
333         }
334         if ((flags ^ oldflags) & EXT4_EXTENTS_FL)
335                 migrate = 1;
336 
337         if (flags & EXT4_EOFBLOCKS_FL) {
338                 /* we don't support adding EOFBLOCKS flag */
339                 if (!(oldflags & EXT4_EOFBLOCKS_FL)) {
340                         err = -EOPNOTSUPP;
341                         goto flags_out;
342                 }
343         } else if (oldflags & EXT4_EOFBLOCKS_FL) {
344                 err = ext4_truncate(inode);
345                 if (err)
346                         goto flags_out;
347         }
348 
349         if ((flags ^ oldflags) & EXT4_CASEFOLD_FL) {
350                 if (!ext4_has_feature_casefold(sb)) {
351                         err = -EOPNOTSUPP;
352                         goto flags_out;
353                 }
354 
355                 if (!S_ISDIR(inode->i_mode)) {
356                         err = -ENOTDIR;
357                         goto flags_out;
358                 }
359 
360                 if (!ext4_empty_dir(inode)) {
361                         err = -ENOTEMPTY;
362                         goto flags_out;
363                 }
364         }
365 
366         /*
367          * Wait for all pending directio and then flush all the dirty pages
368          * for this file.  The flush marks all the pages readonly, so any
369          * subsequent attempt to write to the file (particularly mmap pages)
370          * will come through the filesystem and fail.
371          */
372         if (S_ISREG(inode->i_mode) && !IS_IMMUTABLE(inode) &&
373             (flags & EXT4_IMMUTABLE_FL)) {
374                 inode_dio_wait(inode);
375                 err = filemap_write_and_wait(inode->i_mapping);
376                 if (err)
377                         goto flags_out;
378         }
379 
380         handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
381         if (IS_ERR(handle)) {
382                 err = PTR_ERR(handle);
383                 goto flags_out;
384         }
385         if (IS_SYNC(inode))
386                 ext4_handle_sync(handle);
387         err = ext4_reserve_inode_write(handle, inode, &iloc);
388         if (err)
389                 goto flags_err;
390 
391         for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
392                 if (!(mask & EXT4_FL_USER_MODIFIABLE))
393                         continue;
394                 /* These flags get special treatment later */
395                 if (mask == EXT4_JOURNAL_DATA_FL || mask == EXT4_EXTENTS_FL)
396                         continue;
397                 if (mask & flags)
398                         ext4_set_inode_flag(inode, i);
399                 else
400                         ext4_clear_inode_flag(inode, i);
401         }
402 
403         ext4_set_inode_flags(inode);
404         inode->i_ctime = current_time(inode);
405 
406         err = ext4_mark_iloc_dirty(handle, inode, &iloc);
407 flags_err:
408         ext4_journal_stop(handle);
409         if (err)
410                 goto flags_out;
411 
412         if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
413                 /*
414                  * Changes to the journaling mode can cause unsafe changes to
415                  * S_DAX if we are using the DAX mount option.
416                  */
417                 if (test_opt(inode->i_sb, DAX)) {
418                         err = -EBUSY;
419                         goto flags_out;
420                 }
421 
422                 err = ext4_change_inode_journal_flag(inode, jflag);
423                 if (err)
424                         goto flags_out;
425         }
426         if (migrate) {
427                 if (flags & EXT4_EXTENTS_FL)
428                         err = ext4_ext_migrate(inode);
429                 else
430                         err = ext4_ind_migrate(inode);
431         }
432 
433 flags_out:
434         return err;
435 }
436 
437 #ifdef CONFIG_QUOTA
438 static int ext4_ioctl_setproject(struct file *filp, __u32 projid)
439 {
440         struct inode *inode = file_inode(filp);
441         struct super_block *sb = inode->i_sb;
442         struct ext4_inode_info *ei = EXT4_I(inode);
443         int err, rc;
444         handle_t *handle;
445         kprojid_t kprojid;
446         struct ext4_iloc iloc;
447         struct ext4_inode *raw_inode;
448         struct dquot *transfer_to[MAXQUOTAS] = { };
449 
450         if (!ext4_has_feature_project(sb)) {
451                 if (projid != EXT4_DEF_PROJID)
452                         return -EOPNOTSUPP;
453                 else
454                         return 0;
455         }
456 
457         if (EXT4_INODE_SIZE(sb) <= EXT4_GOOD_OLD_INODE_SIZE)
458                 return -EOPNOTSUPP;
459 
460         kprojid = make_kprojid(&init_user_ns, (projid_t)projid);
461 
462         if (projid_eq(kprojid, EXT4_I(inode)->i_projid))
463                 return 0;
464 
465         err = -EPERM;
466         /* Is it quota file? Do not allow user to mess with it */
467         if (ext4_is_quota_file(inode))
468                 return err;
469 
470         err = ext4_get_inode_loc(inode, &iloc);
471         if (err)
472                 return err;
473 
474         raw_inode = ext4_raw_inode(&iloc);
475         if (!EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) {
476                 err = ext4_expand_extra_isize(inode,
477                                               EXT4_SB(sb)->s_want_extra_isize,
478                                               &iloc);
479                 if (err)
480                         return err;
481         } else {
482                 brelse(iloc.bh);
483         }
484 
485         err = dquot_initialize(inode);
486         if (err)
487                 return err;
488 
489         handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
490                 EXT4_QUOTA_INIT_BLOCKS(sb) +
491                 EXT4_QUOTA_DEL_BLOCKS(sb) + 3);
492         if (IS_ERR(handle))
493                 return PTR_ERR(handle);
494 
495         err = ext4_reserve_inode_write(handle, inode, &iloc);
496         if (err)
497                 goto out_stop;
498 
499         transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
500         if (!IS_ERR(transfer_to[PRJQUOTA])) {
501 
502                 /* __dquot_transfer() calls back ext4_get_inode_usage() which
503                  * counts xattr inode references.
504                  */
505                 down_read(&EXT4_I(inode)->xattr_sem);
506                 err = __dquot_transfer(inode, transfer_to);
507                 up_read(&EXT4_I(inode)->xattr_sem);
508                 dqput(transfer_to[PRJQUOTA]);
509                 if (err)
510                         goto out_dirty;
511         }
512 
513         EXT4_I(inode)->i_projid = kprojid;
514         inode->i_ctime = current_time(inode);
515 out_dirty:
516         rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
517         if (!err)
518                 err = rc;
519 out_stop:
520         ext4_journal_stop(handle);
521         return err;
522 }
523 #else
524 static int ext4_ioctl_setproject(struct file *filp, __u32 projid)
525 {
526         if (projid != EXT4_DEF_PROJID)
527                 return -EOPNOTSUPP;
528         return 0;
529 }
530 #endif
531 
532 /* Transfer internal flags to xflags */
533 static inline __u32 ext4_iflags_to_xflags(unsigned long iflags)
534 {
535         __u32 xflags = 0;
536 
537         if (iflags & EXT4_SYNC_FL)
538                 xflags |= FS_XFLAG_SYNC;
539         if (iflags & EXT4_IMMUTABLE_FL)
540                 xflags |= FS_XFLAG_IMMUTABLE;
541         if (iflags & EXT4_APPEND_FL)
542                 xflags |= FS_XFLAG_APPEND;
543         if (iflags & EXT4_NODUMP_FL)
544                 xflags |= FS_XFLAG_NODUMP;
545         if (iflags & EXT4_NOATIME_FL)
546                 xflags |= FS_XFLAG_NOATIME;
547         if (iflags & EXT4_PROJINHERIT_FL)
548                 xflags |= FS_XFLAG_PROJINHERIT;
549         return xflags;
550 }
551 
552 #define EXT4_SUPPORTED_FS_XFLAGS (FS_XFLAG_SYNC | FS_XFLAG_IMMUTABLE | \
553                                   FS_XFLAG_APPEND | FS_XFLAG_NODUMP | \
554                                   FS_XFLAG_NOATIME | FS_XFLAG_PROJINHERIT)
555 
556 /* Transfer xflags flags to internal */
557 static inline unsigned long ext4_xflags_to_iflags(__u32 xflags)
558 {
559         unsigned long iflags = 0;
560 
561         if (xflags & FS_XFLAG_SYNC)
562                 iflags |= EXT4_SYNC_FL;
563         if (xflags & FS_XFLAG_IMMUTABLE)
564                 iflags |= EXT4_IMMUTABLE_FL;
565         if (xflags & FS_XFLAG_APPEND)
566                 iflags |= EXT4_APPEND_FL;
567         if (xflags & FS_XFLAG_NODUMP)
568                 iflags |= EXT4_NODUMP_FL;
569         if (xflags & FS_XFLAG_NOATIME)
570                 iflags |= EXT4_NOATIME_FL;
571         if (xflags & FS_XFLAG_PROJINHERIT)
572                 iflags |= EXT4_PROJINHERIT_FL;
573 
574         return iflags;
575 }
576 
577 static int ext4_shutdown(struct super_block *sb, unsigned long arg)
578 {
579         struct ext4_sb_info *sbi = EXT4_SB(sb);
580         __u32 flags;
581 
582         if (!capable(CAP_SYS_ADMIN))
583                 return -EPERM;
584 
585         if (get_user(flags, (__u32 __user *)arg))
586                 return -EFAULT;
587 
588         if (flags > EXT4_GOING_FLAGS_NOLOGFLUSH)
589                 return -EINVAL;
590 
591         if (ext4_forced_shutdown(sbi))
592                 return 0;
593 
594         ext4_msg(sb, KERN_ALERT, "shut down requested (%d)", flags);
595         trace_ext4_shutdown(sb, flags);
596 
597         switch (flags) {
598         case EXT4_GOING_FLAGS_DEFAULT:
599                 freeze_bdev(sb->s_bdev);
600                 set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
601                 thaw_bdev(sb->s_bdev, sb);
602                 break;
603         case EXT4_GOING_FLAGS_LOGFLUSH:
604                 set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
605                 if (sbi->s_journal && !is_journal_aborted(sbi->s_journal)) {
606                         (void) ext4_force_commit(sb);
607                         jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
608                 }
609                 break;
610         case EXT4_GOING_FLAGS_NOLOGFLUSH:
611                 set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
612                 if (sbi->s_journal && !is_journal_aborted(sbi->s_journal))
613                         jbd2_journal_abort(sbi->s_journal, -ESHUTDOWN);
614                 break;
615         default:
616                 return -EINVAL;
617         }
618         clear_opt(sb, DISCARD);
619         return 0;
620 }
621 
622 struct getfsmap_info {
623         struct super_block      *gi_sb;
624         struct fsmap_head __user *gi_data;
625         unsigned int            gi_idx;
626         __u32                   gi_last_flags;
627 };
628 
629 static int ext4_getfsmap_format(struct ext4_fsmap *xfm, void *priv)
630 {
631         struct getfsmap_info *info = priv;
632         struct fsmap fm;
633 
634         trace_ext4_getfsmap_mapping(info->gi_sb, xfm);
635 
636         info->gi_last_flags = xfm->fmr_flags;
637         ext4_fsmap_from_internal(info->gi_sb, &fm, xfm);
638         if (copy_to_user(&info->gi_data->fmh_recs[info->gi_idx++], &fm,
639                         sizeof(struct fsmap)))
640                 return -EFAULT;
641 
642         return 0;
643 }
644 
645 static int ext4_ioc_getfsmap(struct super_block *sb,
646                              struct fsmap_head __user *arg)
647 {
648         struct getfsmap_info info = { NULL };
649         struct ext4_fsmap_head xhead = {0};
650         struct fsmap_head head;
651         bool aborted = false;
652         int error;
653 
654         if (copy_from_user(&head, arg, sizeof(struct fsmap_head)))
655                 return -EFAULT;
656         if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) ||
657             memchr_inv(head.fmh_keys[0].fmr_reserved, 0,
658                        sizeof(head.fmh_keys[0].fmr_reserved)) ||
659             memchr_inv(head.fmh_keys[1].fmr_reserved, 0,
660                        sizeof(head.fmh_keys[1].fmr_reserved)))
661                 return -EINVAL;
662         /*
663          * ext4 doesn't report file extents at all, so the only valid
664          * file offsets are the magic ones (all zeroes or all ones).
665          */
666         if (head.fmh_keys[0].fmr_offset ||
667             (head.fmh_keys[1].fmr_offset != 0 &&
668              head.fmh_keys[1].fmr_offset != -1ULL))
669                 return -EINVAL;
670 
671         xhead.fmh_iflags = head.fmh_iflags;
672         xhead.fmh_count = head.fmh_count;
673         ext4_fsmap_to_internal(sb, &xhead.fmh_keys[0], &head.fmh_keys[0]);
674         ext4_fsmap_to_internal(sb, &xhead.fmh_keys[1], &head.fmh_keys[1]);
675 
676         trace_ext4_getfsmap_low_key(sb, &xhead.fmh_keys[0]);
677         trace_ext4_getfsmap_high_key(sb, &xhead.fmh_keys[1]);
678 
679         info.gi_sb = sb;
680         info.gi_data = arg;
681         error = ext4_getfsmap(sb, &xhead, ext4_getfsmap_format, &info);
682         if (error == EXT4_QUERY_RANGE_ABORT) {
683                 error = 0;
684                 aborted = true;
685         } else if (error)
686                 return error;
687 
688         /* If we didn't abort, set the "last" flag in the last fmx */
689         if (!aborted && info.gi_idx) {
690                 info.gi_last_flags |= FMR_OF_LAST;
691                 if (copy_to_user(&info.gi_data->fmh_recs[info.gi_idx - 1].fmr_flags,
692                                  &info.gi_last_flags,
693                                  sizeof(info.gi_last_flags)))
694                         return -EFAULT;
695         }
696 
697         /* copy back header */
698         head.fmh_entries = xhead.fmh_entries;
699         head.fmh_oflags = xhead.fmh_oflags;
700         if (copy_to_user(arg, &head, sizeof(struct fsmap_head)))
701                 return -EFAULT;
702 
703         return 0;
704 }
705 
706 static long ext4_ioctl_group_add(struct file *file,
707                                  struct ext4_new_group_data *input)
708 {
709         struct super_block *sb = file_inode(file)->i_sb;
710         int err, err2=0;
711 
712         err = ext4_resize_begin(sb);
713         if (err)
714                 return err;
715 
716         if (ext4_has_feature_bigalloc(sb)) {
717                 ext4_msg(sb, KERN_ERR,
718                          "Online resizing not supported with bigalloc");
719                 err = -EOPNOTSUPP;
720                 goto group_add_out;
721         }
722 
723         err = mnt_want_write_file(file);
724         if (err)
725                 goto group_add_out;
726 
727         err = ext4_group_add(sb, input);
728         if (EXT4_SB(sb)->s_journal) {
729                 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
730                 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
731                 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
732         }
733         if (err == 0)
734                 err = err2;
735         mnt_drop_write_file(file);
736         if (!err && ext4_has_group_desc_csum(sb) &&
737             test_opt(sb, INIT_INODE_TABLE))
738                 err = ext4_register_li_request(sb, input->group);
739 group_add_out:
740         ext4_resize_end(sb);
741         return err;
742 }
743 
744 static int ext4_ioctl_check_project(struct inode *inode, struct fsxattr *fa)
745 {
746         /*
747          * Project Quota ID state is only allowed to change from within the init
748          * namespace. Enforce that restriction only if we are trying to change
749          * the quota ID state. Everything else is allowed in user namespaces.
750          */
751         if (current_user_ns() == &init_user_ns)
752                 return 0;
753 
754         if (__kprojid_val(EXT4_I(inode)->i_projid) != fa->fsx_projid)
755                 return -EINVAL;
756 
757         if (ext4_test_inode_flag(inode, EXT4_INODE_PROJINHERIT)) {
758                 if (!(fa->fsx_xflags & FS_XFLAG_PROJINHERIT))
759                         return -EINVAL;
760         } else {
761                 if (fa->fsx_xflags & FS_XFLAG_PROJINHERIT)
762                         return -EINVAL;
763         }
764 
765         return 0;
766 }
767 
768 long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
769 {
770         struct inode *inode = file_inode(filp);
771         struct super_block *sb = inode->i_sb;
772         struct ext4_inode_info *ei = EXT4_I(inode);
773         unsigned int flags;
774 
775         ext4_debug("cmd = %u, arg = %lu\n", cmd, arg);
776 
777         switch (cmd) {
778         case FS_IOC_GETFSMAP:
779                 return ext4_ioc_getfsmap(sb, (void __user *)arg);
780         case EXT4_IOC_GETFLAGS:
781                 flags = ei->i_flags & EXT4_FL_USER_VISIBLE;
782                 return put_user(flags, (int __user *) arg);
783         case EXT4_IOC_SETFLAGS: {
784                 int err;
785 
786                 if (!inode_owner_or_capable(inode))
787                         return -EACCES;
788 
789                 if (get_user(flags, (int __user *) arg))
790                         return -EFAULT;
791 
792                 if (flags & ~EXT4_FL_USER_VISIBLE)
793                         return -EOPNOTSUPP;
794                 /*
795                  * chattr(1) grabs flags via GETFLAGS, modifies the result and
796                  * passes that to SETFLAGS. So we cannot easily make SETFLAGS
797                  * more restrictive than just silently masking off visible but
798                  * not settable flags as we always did.
799                  */
800                 flags &= EXT4_FL_USER_MODIFIABLE;
801                 if (ext4_mask_flags(inode->i_mode, flags) != flags)
802                         return -EOPNOTSUPP;
803 
804                 err = mnt_want_write_file(filp);
805                 if (err)
806                         return err;
807 
808                 inode_lock(inode);
809                 err = ext4_ioctl_check_immutable(inode,
810                                 from_kprojid(&init_user_ns, ei->i_projid),
811                                 flags);
812                 if (!err)
813                         err = ext4_ioctl_setflags(inode, flags);
814                 inode_unlock(inode);
815                 mnt_drop_write_file(filp);
816                 return err;
817         }
818         case EXT4_IOC_GETVERSION:
819         case EXT4_IOC_GETVERSION_OLD:
820                 return put_user(inode->i_generation, (int __user *) arg);
821         case EXT4_IOC_SETVERSION:
822         case EXT4_IOC_SETVERSION_OLD: {
823                 handle_t *handle;
824                 struct ext4_iloc iloc;
825                 __u32 generation;
826                 int err;
827 
828                 if (!inode_owner_or_capable(inode))
829                         return -EPERM;
830 
831                 if (ext4_has_metadata_csum(inode->i_sb)) {
832                         ext4_warning(sb, "Setting inode version is not "
833                                      "supported with metadata_csum enabled.");
834                         return -ENOTTY;
835                 }
836 
837                 err = mnt_want_write_file(filp);
838                 if (err)
839                         return err;
840                 if (get_user(generation, (int __user *) arg)) {
841                         err = -EFAULT;
842                         goto setversion_out;
843                 }
844 
845                 inode_lock(inode);
846                 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
847                 if (IS_ERR(handle)) {
848                         err = PTR_ERR(handle);
849                         goto unlock_out;
850                 }
851                 err = ext4_reserve_inode_write(handle, inode, &iloc);
852                 if (err == 0) {
853                         inode->i_ctime = current_time(inode);
854                         inode->i_generation = generation;
855                         err = ext4_mark_iloc_dirty(handle, inode, &iloc);
856                 }
857                 ext4_journal_stop(handle);
858 
859 unlock_out:
860                 inode_unlock(inode);
861 setversion_out:
862                 mnt_drop_write_file(filp);
863                 return err;
864         }
865         case EXT4_IOC_GROUP_EXTEND: {
866                 ext4_fsblk_t n_blocks_count;
867                 int err, err2=0;
868 
869                 err = ext4_resize_begin(sb);
870                 if (err)
871                         return err;
872 
873                 if (get_user(n_blocks_count, (__u32 __user *)arg)) {
874                         err = -EFAULT;
875                         goto group_extend_out;
876                 }
877 
878                 if (ext4_has_feature_bigalloc(sb)) {
879                         ext4_msg(sb, KERN_ERR,
880                                  "Online resizing not supported with bigalloc");
881                         err = -EOPNOTSUPP;
882                         goto group_extend_out;
883                 }
884 
885                 err = mnt_want_write_file(filp);
886                 if (err)
887                         goto group_extend_out;
888 
889                 err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);
890                 if (EXT4_SB(sb)->s_journal) {
891                         jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
892                         err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
893                         jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
894                 }
895                 if (err == 0)
896                         err = err2;
897                 mnt_drop_write_file(filp);
898 group_extend_out:
899                 ext4_resize_end(sb);
900                 return err;
901         }
902 
903         case EXT4_IOC_MOVE_EXT: {
904                 struct move_extent me;
905                 struct fd donor;
906                 int err;
907 
908                 if (!(filp->f_mode & FMODE_READ) ||
909                     !(filp->f_mode & FMODE_WRITE))
910                         return -EBADF;
911 
912                 if (copy_from_user(&me,
913                         (struct move_extent __user *)arg, sizeof(me)))
914                         return -EFAULT;
915                 me.moved_len = 0;
916 
917                 donor = fdget(me.donor_fd);
918                 if (!donor.file)
919                         return -EBADF;
920 
921                 if (!(donor.file->f_mode & FMODE_WRITE)) {
922                         err = -EBADF;
923                         goto mext_out;
924                 }
925 
926                 if (ext4_has_feature_bigalloc(sb)) {
927                         ext4_msg(sb, KERN_ERR,
928                                  "Online defrag not supported with bigalloc");
929                         err = -EOPNOTSUPP;
930                         goto mext_out;
931                 } else if (IS_DAX(inode)) {
932                         ext4_msg(sb, KERN_ERR,
933                                  "Online defrag not supported with DAX");
934                         err = -EOPNOTSUPP;
935                         goto mext_out;
936                 }
937 
938                 err = mnt_want_write_file(filp);
939                 if (err)
940                         goto mext_out;
941 
942                 err = ext4_move_extents(filp, donor.file, me.orig_start,
943                                         me.donor_start, me.len, &me.moved_len);
944                 mnt_drop_write_file(filp);
945 
946                 if (copy_to_user((struct move_extent __user *)arg,
947                                  &me, sizeof(me)))
948                         err = -EFAULT;
949 mext_out:
950                 fdput(donor);
951                 return err;
952         }
953 
954         case EXT4_IOC_GROUP_ADD: {
955                 struct ext4_new_group_data input;
956 
957                 if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
958                                 sizeof(input)))
959                         return -EFAULT;
960 
961                 return ext4_ioctl_group_add(filp, &input);
962         }
963 
964         case EXT4_IOC_MIGRATE:
965         {
966                 int err;
967                 if (!inode_owner_or_capable(inode))
968                         return -EACCES;
969 
970                 err = mnt_want_write_file(filp);
971                 if (err)
972                         return err;
973                 /*
974                  * inode_mutex prevent write and truncate on the file.
975                  * Read still goes through. We take i_data_sem in
976                  * ext4_ext_swap_inode_data before we switch the
977                  * inode format to prevent read.
978                  */
979                 inode_lock((inode));
980                 err = ext4_ext_migrate(inode);
981                 inode_unlock((inode));
982                 mnt_drop_write_file(filp);
983                 return err;
984         }
985 
986         case EXT4_IOC_ALLOC_DA_BLKS:
987         {
988                 int err;
989                 if (!inode_owner_or_capable(inode))
990                         return -EACCES;
991 
992                 err = mnt_want_write_file(filp);
993                 if (err)
994                         return err;
995                 err = ext4_alloc_da_blocks(inode);
996                 mnt_drop_write_file(filp);
997                 return err;
998         }
999 
1000         case EXT4_IOC_SWAP_BOOT:
1001         {
1002                 int err;
1003                 if (!(filp->f_mode & FMODE_WRITE))
1004                         return -EBADF;
1005                 err = mnt_want_write_file(filp);
1006                 if (err)
1007                         return err;
1008                 err = swap_inode_boot_loader(sb, inode);
1009                 mnt_drop_write_file(filp);
1010                 return err;
1011         }
1012 
1013         case EXT4_IOC_RESIZE_FS: {
1014                 ext4_fsblk_t n_blocks_count;
1015                 int err = 0, err2 = 0;
1016                 ext4_group_t o_group = EXT4_SB(sb)->s_groups_count;
1017 
1018                 if (copy_from_user(&n_blocks_count, (__u64 __user *)arg,
1019                                    sizeof(__u64))) {
1020                         return -EFAULT;
1021                 }
1022 
1023                 err = ext4_resize_begin(sb);
1024                 if (err)
1025                         return err;
1026 
1027                 err = mnt_want_write_file(filp);
1028                 if (err)
1029                         goto resizefs_out;
1030 
1031                 err = ext4_resize_fs(sb, n_blocks_count);
1032                 if (EXT4_SB(sb)->s_journal) {
1033                         jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
1034                         err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
1035                         jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
1036                 }
1037                 if (err == 0)
1038                         err = err2;
1039                 mnt_drop_write_file(filp);
1040                 if (!err && (o_group < EXT4_SB(sb)->s_groups_count) &&
1041                     ext4_has_group_desc_csum(sb) &&
1042                     test_opt(sb, INIT_INODE_TABLE))
1043                         err = ext4_register_li_request(sb, o_group);
1044 
1045 resizefs_out:
1046                 ext4_resize_end(sb);
1047                 return err;
1048         }
1049 
1050         case FITRIM:
1051         {
1052                 struct request_queue *q = bdev_get_queue(sb->s_bdev);
1053                 struct fstrim_range range;
1054                 int ret = 0;
1055 
1056                 if (!capable(CAP_SYS_ADMIN))
1057                         return -EPERM;
1058 
1059                 if (!blk_queue_discard(q))
1060                         return -EOPNOTSUPP;
1061 
1062                 /*
1063                  * We haven't replayed the journal, so we cannot use our
1064                  * block-bitmap-guided storage zapping commands.
1065                  */
1066                 if (test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb))
1067                         return -EROFS;
1068 
1069                 if (copy_from_user(&range, (struct fstrim_range __user *)arg,
1070                     sizeof(range)))
1071                         return -EFAULT;
1072 
1073                 range.minlen = max((unsigned int)range.minlen,
1074                                    q->limits.discard_granularity);
1075                 ret = ext4_trim_fs(sb, &range);
1076                 if (ret < 0)
1077                         return ret;
1078 
1079                 if (copy_to_user((struct fstrim_range __user *)arg, &range,
1080                     sizeof(range)))
1081                         return -EFAULT;
1082 
1083                 return 0;
1084         }
1085         case EXT4_IOC_PRECACHE_EXTENTS:
1086                 return ext4_ext_precache(inode);
1087 
1088         case EXT4_IOC_SET_ENCRYPTION_POLICY:
1089                 if (!ext4_has_feature_encrypt(sb))
1090                         return -EOPNOTSUPP;
1091                 return fscrypt_ioctl_set_policy(filp, (const void __user *)arg);
1092 
1093         case EXT4_IOC_GET_ENCRYPTION_PWSALT: {
1094 #ifdef CONFIG_FS_ENCRYPTION
1095                 int err, err2;
1096                 struct ext4_sb_info *sbi = EXT4_SB(sb);
1097                 handle_t *handle;
1098 
1099                 if (!ext4_has_feature_encrypt(sb))
1100                         return -EOPNOTSUPP;
1101                 if (uuid_is_zero(sbi->s_es->s_encrypt_pw_salt)) {
1102                         err = mnt_want_write_file(filp);
1103                         if (err)
1104                                 return err;
1105                         handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
1106                         if (IS_ERR(handle)) {
1107                                 err = PTR_ERR(handle);
1108                                 goto pwsalt_err_exit;
1109                         }
1110                         err = ext4_journal_get_write_access(handle, sbi->s_sbh);
1111                         if (err)
1112                                 goto pwsalt_err_journal;
1113                         generate_random_uuid(sbi->s_es->s_encrypt_pw_salt);
1114                         err = ext4_handle_dirty_metadata(handle, NULL,
1115                                                          sbi->s_sbh);
1116                 pwsalt_err_journal:
1117                         err2 = ext4_journal_stop(handle);
1118                         if (err2 && !err)
1119                                 err = err2;
1120                 pwsalt_err_exit:
1121                         mnt_drop_write_file(filp);
1122                         if (err)
1123                                 return err;
1124                 }
1125                 if (copy_to_user((void __user *) arg,
1126                                  sbi->s_es->s_encrypt_pw_salt, 16))
1127                         return -EFAULT;
1128                 return 0;
1129 #else
1130                 return -EOPNOTSUPP;
1131 #endif
1132         }
1133         case EXT4_IOC_GET_ENCRYPTION_POLICY:
1134                 return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
1135 
1136         case EXT4_IOC_FSGETXATTR:
1137         {
1138                 struct fsxattr fa;
1139 
1140                 memset(&fa, 0, sizeof(struct fsxattr));
1141                 fa.fsx_xflags = ext4_iflags_to_xflags(ei->i_flags & EXT4_FL_USER_VISIBLE);
1142 
1143                 if (ext4_has_feature_project(inode->i_sb)) {
1144                         fa.fsx_projid = (__u32)from_kprojid(&init_user_ns,
1145                                 EXT4_I(inode)->i_projid);
1146                 }
1147 
1148                 if (copy_to_user((struct fsxattr __user *)arg,
1149                                  &fa, sizeof(fa)))
1150                         return -EFAULT;
1151                 return 0;
1152         }
1153         case EXT4_IOC_FSSETXATTR:
1154         {
1155                 struct fsxattr fa;
1156                 int err;
1157 
1158                 if (copy_from_user(&fa, (struct fsxattr __user *)arg,
1159                                    sizeof(fa)))
1160                         return -EFAULT;
1161 
1162                 /* Make sure caller has proper permission */
1163                 if (!inode_owner_or_capable(inode))
1164                         return -EACCES;
1165 
1166                 if (fa.fsx_xflags & ~EXT4_SUPPORTED_FS_XFLAGS)
1167                         return -EOPNOTSUPP;
1168 
1169                 flags = ext4_xflags_to_iflags(fa.fsx_xflags);
1170                 if (ext4_mask_flags(inode->i_mode, flags) != flags)
1171                         return -EOPNOTSUPP;
1172 
1173                 err = mnt_want_write_file(filp);
1174                 if (err)
1175                         return err;
1176 
1177                 inode_lock(inode);
1178                 err = ext4_ioctl_check_project(inode, &fa);
1179                 if (err)
1180                         goto out;
1181                 flags = (ei->i_flags & ~EXT4_FL_XFLAG_VISIBLE) |
1182                          (flags & EXT4_FL_XFLAG_VISIBLE);
1183                 err = ext4_ioctl_check_immutable(inode, fa.fsx_projid, flags);
1184                 if (err)
1185                         goto out;
1186                 err = ext4_ioctl_setflags(inode, flags);
1187                 if (err)
1188                         goto out;
1189                 err = ext4_ioctl_setproject(filp, fa.fsx_projid);
1190 out:
1191                 inode_unlock(inode);
1192                 mnt_drop_write_file(filp);
1193                 return err;
1194         }
1195         case EXT4_IOC_SHUTDOWN:
1196                 return ext4_shutdown(sb, arg);
1197         default:
1198                 return -ENOTTY;
1199         }
1200 }
1201 
1202 #ifdef CONFIG_COMPAT
1203 long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1204 {
1205         /* These are just misnamed, they actually get/put from/to user an int */
1206         switch (cmd) {
1207         case EXT4_IOC32_GETFLAGS:
1208                 cmd = EXT4_IOC_GETFLAGS;
1209                 break;
1210         case EXT4_IOC32_SETFLAGS:
1211                 cmd = EXT4_IOC_SETFLAGS;
1212                 break;
1213         case EXT4_IOC32_GETVERSION:
1214                 cmd = EXT4_IOC_GETVERSION;
1215                 break;
1216         case EXT4_IOC32_SETVERSION:
1217                 cmd = EXT4_IOC_SETVERSION;
1218                 break;
1219         case EXT4_IOC32_GROUP_EXTEND:
1220                 cmd = EXT4_IOC_GROUP_EXTEND;
1221                 break;
1222         case EXT4_IOC32_GETVERSION_OLD:
1223                 cmd = EXT4_IOC_GETVERSION_OLD;
1224                 break;
1225         case EXT4_IOC32_SETVERSION_OLD:
1226                 cmd = EXT4_IOC_SETVERSION_OLD;
1227                 break;
1228         case EXT4_IOC32_GETRSVSZ:
1229                 cmd = EXT4_IOC_GETRSVSZ;
1230                 break;
1231         case EXT4_IOC32_SETRSVSZ:
1232                 cmd = EXT4_IOC_SETRSVSZ;
1233                 break;
1234         case EXT4_IOC32_GROUP_ADD: {
1235                 struct compat_ext4_new_group_input __user *uinput;
1236                 struct ext4_new_group_data input;
1237                 int err;
1238 
1239                 uinput = compat_ptr(arg);
1240                 err = get_user(input.group, &uinput->group);
1241                 err |= get_user(input.block_bitmap, &uinput->block_bitmap);
1242                 err |= get_user(input.inode_bitmap, &uinput->inode_bitmap);
1243                 err |= get_user(input.inode_table, &uinput->inode_table);
1244                 err |= get_user(input.blocks_count, &uinput->blocks_count);
1245                 err |= get_user(input.reserved_blocks,
1246                                 &uinput->reserved_blocks);
1247                 if (err)
1248                         return -EFAULT;
1249                 return ext4_ioctl_group_add(file, &input);
1250         }
1251         case EXT4_IOC_MOVE_EXT:
1252         case EXT4_IOC_RESIZE_FS:
1253         case EXT4_IOC_PRECACHE_EXTENTS:
1254         case EXT4_IOC_SET_ENCRYPTION_POLICY:
1255         case EXT4_IOC_GET_ENCRYPTION_PWSALT:
1256         case EXT4_IOC_GET_ENCRYPTION_POLICY:
1257         case EXT4_IOC_SHUTDOWN:
1258         case FS_IOC_GETFSMAP:
1259                 break;
1260         default:
1261                 return -ENOIOCTLCMD;
1262         }
1263         return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
1264 }
1265 #endif
1266 

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