blob: bf5ae8ebbc9788f8e6335bb1c24967dd03a60e22 [file] [log] [blame]
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001/*
Mingming Cao617ba132006-10-11 01:20:53 -07002 * linux/fs/ext4/ioctl.c
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003 *
4 * Copyright (C) 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
8 */
9
10#include <linux/fs.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070011#include <linux/capability.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070012#include <linux/time.h>
13#include <linux/compat.h>
Dave Hansen42a74f22008-02-15 14:37:46 -080014#include <linux/mount.h>
Akira Fujita748de672009-06-17 19:24:03 -040015#include <linux/file.h>
Li Xi9b7365f2016-01-08 16:01:22 -050016#include <linux/quotaops.h>
Andy Shevchenko8da4b8c2016-05-20 17:01:00 -070017#include <linux/uuid.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070018#include <asm/uaccess.h>
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040019#include "ext4_jbd2.h"
20#include "ext4.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070021
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -040022/**
23 * Swap memory between @a and @b for @len bytes.
24 *
25 * @a: pointer to first memory area
26 * @b: pointer to second memory area
27 * @len: number of bytes to swap
28 *
29 */
30static void memswap(void *a, void *b, size_t len)
31{
32 unsigned char *ap, *bp;
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -040033
34 ap = (unsigned char *)a;
35 bp = (unsigned char *)b;
36 while (len-- > 0) {
Fabian Frederick4b7e2db2015-06-12 23:46:33 -040037 swap(*ap, *bp);
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -040038 ap++;
39 bp++;
40 }
41}
42
43/**
44 * Swap i_data and associated attributes between @inode1 and @inode2.
45 * This function is used for the primary swap between inode1 and inode2
46 * and also to revert this primary swap in case of errors.
47 *
48 * Therefore you have to make sure, that calling this method twice
49 * will revert all changes.
50 *
51 * @inode1: pointer to first inode
52 * @inode2: pointer to second inode
53 */
54static void swap_inode_data(struct inode *inode1, struct inode *inode2)
55{
56 loff_t isize;
57 struct ext4_inode_info *ei1;
58 struct ext4_inode_info *ei2;
59
60 ei1 = EXT4_I(inode1);
61 ei2 = EXT4_I(inode2);
62
63 memswap(&inode1->i_flags, &inode2->i_flags, sizeof(inode1->i_flags));
64 memswap(&inode1->i_version, &inode2->i_version,
65 sizeof(inode1->i_version));
66 memswap(&inode1->i_blocks, &inode2->i_blocks,
67 sizeof(inode1->i_blocks));
68 memswap(&inode1->i_bytes, &inode2->i_bytes, sizeof(inode1->i_bytes));
69 memswap(&inode1->i_atime, &inode2->i_atime, sizeof(inode1->i_atime));
70 memswap(&inode1->i_mtime, &inode2->i_mtime, sizeof(inode1->i_mtime));
71
72 memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data));
73 memswap(&ei1->i_flags, &ei2->i_flags, sizeof(ei1->i_flags));
74 memswap(&ei1->i_disksize, &ei2->i_disksize, sizeof(ei1->i_disksize));
Theodore Ts'ocde2d7a2013-08-12 09:29:30 -040075 ext4_es_remove_extent(inode1, 0, EXT_MAX_BLOCKS);
76 ext4_es_remove_extent(inode2, 0, EXT_MAX_BLOCKS);
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -040077
78 isize = i_size_read(inode1);
79 i_size_write(inode1, i_size_read(inode2));
80 i_size_write(inode2, isize);
81}
82
83/**
84 * Swap the information from the given @inode and the inode
85 * EXT4_BOOT_LOADER_INO. It will basically swap i_data and all other
86 * important fields of the inodes.
87 *
88 * @sb: the super block of the filesystem
89 * @inode: the inode to swap with EXT4_BOOT_LOADER_INO
90 *
91 */
92static long swap_inode_boot_loader(struct super_block *sb,
93 struct inode *inode)
94{
95 handle_t *handle;
96 int err;
97 struct inode *inode_bl;
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -040098 struct ext4_inode_info *ei_bl;
jon ernstd7092ae2014-01-11 13:26:56 -050099 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400100
Theodore Ts'od8558a22014-02-17 20:44:36 -0500101 if (inode->i_nlink != 1 || !S_ISREG(inode->i_mode))
102 return -EINVAL;
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400103
Theodore Ts'od8558a22014-02-17 20:44:36 -0500104 if (!inode_owner_or_capable(inode) || !capable(CAP_SYS_ADMIN))
105 return -EPERM;
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400106
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400107 inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO);
Theodore Ts'od8558a22014-02-17 20:44:36 -0500108 if (IS_ERR(inode_bl))
109 return PTR_ERR(inode_bl);
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400110 ei_bl = EXT4_I(inode_bl);
111
112 filemap_flush(inode->i_mapping);
113 filemap_flush(inode_bl->i_mapping);
114
115 /* Protect orig inodes against a truncate and make sure,
116 * that only 1 swap_inode_boot_loader is running. */
J. Bruce Fields375e2892012-04-18 15:16:33 -0400117 lock_two_nondirectories(inode, inode_bl);
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400118
119 truncate_inode_pages(&inode->i_data, 0);
120 truncate_inode_pages(&inode_bl->i_data, 0);
121
122 /* Wait for all existing dio workers */
123 ext4_inode_block_unlocked_dio(inode);
124 ext4_inode_block_unlocked_dio(inode_bl);
125 inode_dio_wait(inode);
126 inode_dio_wait(inode_bl);
127
128 handle = ext4_journal_start(inode_bl, EXT4_HT_MOVE_EXTENTS, 2);
129 if (IS_ERR(handle)) {
130 err = -EINVAL;
Zheng Liu30d29b12014-02-12 11:48:31 -0500131 goto journal_err_out;
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400132 }
133
134 /* Protect extent tree against block allocations via delalloc */
135 ext4_double_down_write_data_sem(inode, inode_bl);
136
137 if (inode_bl->i_nlink == 0) {
138 /* this inode has never been used as a BOOT_LOADER */
139 set_nlink(inode_bl, 1);
140 i_uid_write(inode_bl, 0);
141 i_gid_write(inode_bl, 0);
142 inode_bl->i_flags = 0;
143 ei_bl->i_flags = 0;
144 inode_bl->i_version = 1;
145 i_size_write(inode_bl, 0);
146 inode_bl->i_mode = S_IFREG;
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400147 if (ext4_has_feature_extents(sb)) {
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400148 ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);
149 ext4_ext_tree_init(handle, inode_bl);
150 } else
151 memset(ei_bl->i_data, 0, sizeof(ei_bl->i_data));
152 }
153
154 swap_inode_data(inode, inode_bl);
155
156 inode->i_ctime = inode_bl->i_ctime = ext4_current_time(inode);
157
158 spin_lock(&sbi->s_next_gen_lock);
159 inode->i_generation = sbi->s_next_generation++;
160 inode_bl->i_generation = sbi->s_next_generation++;
161 spin_unlock(&sbi->s_next_gen_lock);
162
163 ext4_discard_preallocations(inode);
164
165 err = ext4_mark_inode_dirty(handle, inode);
166 if (err < 0) {
167 ext4_warning(inode->i_sb,
168 "couldn't mark inode #%lu dirty (err %d)",
169 inode->i_ino, err);
170 /* Revert all changes: */
171 swap_inode_data(inode, inode_bl);
172 } else {
173 err = ext4_mark_inode_dirty(handle, inode_bl);
174 if (err < 0) {
175 ext4_warning(inode_bl->i_sb,
176 "couldn't mark inode #%lu dirty (err %d)",
177 inode_bl->i_ino, err);
178 /* Revert all changes: */
179 swap_inode_data(inode, inode_bl);
180 ext4_mark_inode_dirty(handle, inode);
181 }
182 }
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400183 ext4_journal_stop(handle);
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400184 ext4_double_up_write_data_sem(inode, inode_bl);
185
Zheng Liu30d29b12014-02-12 11:48:31 -0500186journal_err_out:
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400187 ext4_inode_resume_unlocked_dio(inode);
188 ext4_inode_resume_unlocked_dio(inode_bl);
J. Bruce Fields375e2892012-04-18 15:16:33 -0400189 unlock_two_nondirectories(inode, inode_bl);
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400190 iput(inode_bl);
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400191 return err;
192}
193
Michael Halcrow9bd82122015-04-11 07:48:01 -0400194static int uuid_is_zero(__u8 u[16])
195{
196 int i;
197
198 for (i = 0; i < 16; i++)
199 if (u[i])
200 return 0;
201 return 1;
202}
203
Li Xi9b7365f2016-01-08 16:01:22 -0500204static int ext4_ioctl_setflags(struct inode *inode,
205 unsigned int flags)
206{
207 struct ext4_inode_info *ei = EXT4_I(inode);
208 handle_t *handle = NULL;
Anton Protopopovfdde3682016-02-11 23:57:21 -0500209 int err = -EPERM, migrate = 0;
Li Xi9b7365f2016-01-08 16:01:22 -0500210 struct ext4_iloc iloc;
211 unsigned int oldflags, mask, i;
212 unsigned int jflag;
213
214 /* Is it quota file? Do not allow user to mess with it */
215 if (IS_NOQUOTA(inode))
216 goto flags_out;
217
218 oldflags = ei->i_flags;
219
220 /* The JOURNAL_DATA flag is modifiable only by root */
221 jflag = flags & EXT4_JOURNAL_DATA_FL;
222
223 /*
224 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
225 * the relevant capability.
226 *
227 * This test looks nicer. Thanks to Pauline Middelink
228 */
229 if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) {
230 if (!capable(CAP_LINUX_IMMUTABLE))
231 goto flags_out;
232 }
233
234 /*
235 * The JOURNAL_DATA flag can only be changed by
236 * the relevant capability.
237 */
238 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
239 if (!capable(CAP_SYS_RESOURCE))
240 goto flags_out;
241 }
242 if ((flags ^ oldflags) & EXT4_EXTENTS_FL)
243 migrate = 1;
244
245 if (flags & EXT4_EOFBLOCKS_FL) {
246 /* we don't support adding EOFBLOCKS flag */
247 if (!(oldflags & EXT4_EOFBLOCKS_FL)) {
248 err = -EOPNOTSUPP;
249 goto flags_out;
250 }
251 } else if (oldflags & EXT4_EOFBLOCKS_FL)
252 ext4_truncate(inode);
253
254 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
255 if (IS_ERR(handle)) {
256 err = PTR_ERR(handle);
257 goto flags_out;
258 }
259 if (IS_SYNC(inode))
260 ext4_handle_sync(handle);
261 err = ext4_reserve_inode_write(handle, inode, &iloc);
262 if (err)
263 goto flags_err;
264
265 for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
266 if (!(mask & EXT4_FL_USER_MODIFIABLE))
267 continue;
268 if (mask & flags)
269 ext4_set_inode_flag(inode, i);
270 else
271 ext4_clear_inode_flag(inode, i);
272 }
273
274 ext4_set_inode_flags(inode);
275 inode->i_ctime = ext4_current_time(inode);
276
277 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
278flags_err:
279 ext4_journal_stop(handle);
280 if (err)
281 goto flags_out;
282
283 if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL))
284 err = ext4_change_inode_journal_flag(inode, jflag);
285 if (err)
286 goto flags_out;
287 if (migrate) {
288 if (flags & EXT4_EXTENTS_FL)
289 err = ext4_ext_migrate(inode);
290 else
291 err = ext4_ind_migrate(inode);
292 }
293
294flags_out:
295 return err;
296}
297
298#ifdef CONFIG_QUOTA
299static int ext4_ioctl_setproject(struct file *filp, __u32 projid)
300{
301 struct inode *inode = file_inode(filp);
302 struct super_block *sb = inode->i_sb;
303 struct ext4_inode_info *ei = EXT4_I(inode);
304 int err, rc;
305 handle_t *handle;
306 kprojid_t kprojid;
307 struct ext4_iloc iloc;
308 struct ext4_inode *raw_inode;
Wang Shilong079788d2016-07-05 21:33:52 -0400309 struct dquot *transfer_to[MAXQUOTAS] = { };
Li Xi9b7365f2016-01-08 16:01:22 -0500310
Kaho Ng0b7b7772016-09-05 23:11:58 -0400311 if (!ext4_has_feature_project(sb)) {
Li Xi9b7365f2016-01-08 16:01:22 -0500312 if (projid != EXT4_DEF_PROJID)
313 return -EOPNOTSUPP;
314 else
315 return 0;
316 }
317
318 if (EXT4_INODE_SIZE(sb) <= EXT4_GOOD_OLD_INODE_SIZE)
319 return -EOPNOTSUPP;
320
321 kprojid = make_kprojid(&init_user_ns, (projid_t)projid);
322
323 if (projid_eq(kprojid, EXT4_I(inode)->i_projid))
324 return 0;
325
326 err = mnt_want_write_file(filp);
327 if (err)
328 return err;
329
330 err = -EPERM;
Al Viro59551022016-01-22 15:40:57 -0500331 inode_lock(inode);
Li Xi9b7365f2016-01-08 16:01:22 -0500332 /* Is it quota file? Do not allow user to mess with it */
333 if (IS_NOQUOTA(inode))
334 goto out_unlock;
335
336 err = ext4_get_inode_loc(inode, &iloc);
337 if (err)
338 goto out_unlock;
339
340 raw_inode = ext4_raw_inode(&iloc);
341 if (!EXT4_FITS_IN_INODE(raw_inode, ei, i_projid)) {
342 err = -EOVERFLOW;
343 brelse(iloc.bh);
344 goto out_unlock;
345 }
346 brelse(iloc.bh);
347
348 dquot_initialize(inode);
349
350 handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
351 EXT4_QUOTA_INIT_BLOCKS(sb) +
352 EXT4_QUOTA_DEL_BLOCKS(sb) + 3);
353 if (IS_ERR(handle)) {
354 err = PTR_ERR(handle);
355 goto out_unlock;
356 }
357
358 err = ext4_reserve_inode_write(handle, inode, &iloc);
359 if (err)
360 goto out_stop;
361
Wang Shilong079788d2016-07-05 21:33:52 -0400362 transfer_to[PRJQUOTA] = dqget(sb, make_kqid_projid(kprojid));
363 if (!IS_ERR(transfer_to[PRJQUOTA])) {
364 err = __dquot_transfer(inode, transfer_to);
365 dqput(transfer_to[PRJQUOTA]);
366 if (err)
367 goto out_dirty;
Li Xi9b7365f2016-01-08 16:01:22 -0500368 }
Wang Shilong079788d2016-07-05 21:33:52 -0400369
Li Xi9b7365f2016-01-08 16:01:22 -0500370 EXT4_I(inode)->i_projid = kprojid;
371 inode->i_ctime = ext4_current_time(inode);
372out_dirty:
373 rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
374 if (!err)
375 err = rc;
376out_stop:
377 ext4_journal_stop(handle);
378out_unlock:
Al Viro59551022016-01-22 15:40:57 -0500379 inode_unlock(inode);
Li Xi9b7365f2016-01-08 16:01:22 -0500380 mnt_drop_write_file(filp);
381 return err;
382}
383#else
384static int ext4_ioctl_setproject(struct file *filp, __u32 projid)
385{
386 if (projid != EXT4_DEF_PROJID)
387 return -EOPNOTSUPP;
388 return 0;
389}
390#endif
391
392/* Transfer internal flags to xflags */
393static inline __u32 ext4_iflags_to_xflags(unsigned long iflags)
394{
395 __u32 xflags = 0;
396
397 if (iflags & EXT4_SYNC_FL)
398 xflags |= FS_XFLAG_SYNC;
399 if (iflags & EXT4_IMMUTABLE_FL)
400 xflags |= FS_XFLAG_IMMUTABLE;
401 if (iflags & EXT4_APPEND_FL)
402 xflags |= FS_XFLAG_APPEND;
403 if (iflags & EXT4_NODUMP_FL)
404 xflags |= FS_XFLAG_NODUMP;
405 if (iflags & EXT4_NOATIME_FL)
406 xflags |= FS_XFLAG_NOATIME;
407 if (iflags & EXT4_PROJINHERIT_FL)
408 xflags |= FS_XFLAG_PROJINHERIT;
409 return xflags;
410}
411
412/* Transfer xflags flags to internal */
413static inline unsigned long ext4_xflags_to_iflags(__u32 xflags)
414{
415 unsigned long iflags = 0;
416
417 if (xflags & FS_XFLAG_SYNC)
418 iflags |= EXT4_SYNC_FL;
419 if (xflags & FS_XFLAG_IMMUTABLE)
420 iflags |= EXT4_IMMUTABLE_FL;
421 if (xflags & FS_XFLAG_APPEND)
422 iflags |= EXT4_APPEND_FL;
423 if (xflags & FS_XFLAG_NODUMP)
424 iflags |= EXT4_NODUMP_FL;
425 if (xflags & FS_XFLAG_NOATIME)
426 iflags |= EXT4_NOATIME_FL;
427 if (xflags & FS_XFLAG_PROJINHERIT)
428 iflags |= EXT4_PROJINHERIT_FL;
429
430 return iflags;
431}
432
Andi Kleen5cdd7b22008-04-29 22:03:54 -0400433long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700434{
Al Viro496ad9a2013-01-23 17:07:38 -0500435 struct inode *inode = file_inode(filp);
Theodore Ts'obab08ab2011-09-09 18:36:51 -0400436 struct super_block *sb = inode->i_sb;
Mingming Cao617ba132006-10-11 01:20:53 -0700437 struct ext4_inode_info *ei = EXT4_I(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700438 unsigned int flags;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700439
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400440 ext4_debug("cmd = %u, arg = %lu\n", cmd, arg);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700441
442 switch (cmd) {
Mingming Cao617ba132006-10-11 01:20:53 -0700443 case EXT4_IOC_GETFLAGS:
Jan Karaff9ddf72007-07-18 09:24:20 -0400444 ext4_get_inode_flags(ei);
Mingming Cao617ba132006-10-11 01:20:53 -0700445 flags = ei->i_flags & EXT4_FL_USER_VISIBLE;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700446 return put_user(flags, (int __user *) arg);
Mingming Cao617ba132006-10-11 01:20:53 -0700447 case EXT4_IOC_SETFLAGS: {
Li Xi9b7365f2016-01-08 16:01:22 -0500448 int err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700449
Serge E. Hallyn2e149672011-03-23 16:43:26 -0700450 if (!inode_owner_or_capable(inode))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700451 return -EACCES;
452
453 if (get_user(flags, (int __user *) arg))
454 return -EFAULT;
455
Al Viroa561be72011-11-23 11:57:51 -0500456 err = mnt_want_write_file(filp);
Dave Hansen42a74f22008-02-15 14:37:46 -0800457 if (err)
458 return err;
459
Duane Griffin2dc6b0d2009-02-15 18:09:20 -0500460 flags = ext4_mask_flags(inode->i_mode, flags);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700461
Al Viro59551022016-01-22 15:40:57 -0500462 inode_lock(inode);
Li Xi9b7365f2016-01-08 16:01:22 -0500463 err = ext4_ioctl_setflags(inode, flags);
Al Viro59551022016-01-22 15:40:57 -0500464 inode_unlock(inode);
Al Viro2a79f172011-12-09 08:06:57 -0500465 mnt_drop_write_file(filp);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700466 return err;
467 }
Mingming Cao617ba132006-10-11 01:20:53 -0700468 case EXT4_IOC_GETVERSION:
469 case EXT4_IOC_GETVERSION_OLD:
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700470 return put_user(inode->i_generation, (int __user *) arg);
Mingming Cao617ba132006-10-11 01:20:53 -0700471 case EXT4_IOC_SETVERSION:
472 case EXT4_IOC_SETVERSION_OLD: {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700473 handle_t *handle;
Mingming Cao617ba132006-10-11 01:20:53 -0700474 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700475 __u32 generation;
476 int err;
477
Serge E. Hallyn2e149672011-03-23 16:43:26 -0700478 if (!inode_owner_or_capable(inode))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700479 return -EPERM;
Dave Hansen42a74f22008-02-15 14:37:46 -0800480
Dmitry Monakhov9aa5d322014-10-13 03:36:16 -0400481 if (ext4_has_metadata_csum(inode->i_sb)) {
Darrick J. Wong814525f2012-04-29 18:31:10 -0400482 ext4_warning(sb, "Setting inode version is not "
483 "supported with metadata_csum enabled.");
484 return -ENOTTY;
485 }
486
Al Viroa561be72011-11-23 11:57:51 -0500487 err = mnt_want_write_file(filp);
Dave Hansen42a74f22008-02-15 14:37:46 -0800488 if (err)
489 return err;
490 if (get_user(generation, (int __user *) arg)) {
491 err = -EFAULT;
492 goto setversion_out;
493 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700494
Al Viro59551022016-01-22 15:40:57 -0500495 inode_lock(inode);
Theodore Ts'o9924a922013-02-08 21:59:22 -0500496 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
Dave Hansen42a74f22008-02-15 14:37:46 -0800497 if (IS_ERR(handle)) {
498 err = PTR_ERR(handle);
Djalal Harouni6c2155b2012-01-03 02:31:52 +0100499 goto unlock_out;
Dave Hansen42a74f22008-02-15 14:37:46 -0800500 }
Mingming Cao617ba132006-10-11 01:20:53 -0700501 err = ext4_reserve_inode_write(handle, inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700502 if (err == 0) {
Kalpak Shahef7f3832007-07-18 09:15:20 -0400503 inode->i_ctime = ext4_current_time(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700504 inode->i_generation = generation;
Mingming Cao617ba132006-10-11 01:20:53 -0700505 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700506 }
Mingming Cao617ba132006-10-11 01:20:53 -0700507 ext4_journal_stop(handle);
Djalal Harouni6c2155b2012-01-03 02:31:52 +0100508
509unlock_out:
Al Viro59551022016-01-22 15:40:57 -0500510 inode_unlock(inode);
Dave Hansen42a74f22008-02-15 14:37:46 -0800511setversion_out:
Al Viro2a79f172011-12-09 08:06:57 -0500512 mnt_drop_write_file(filp);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700513 return err;
514 }
Mingming Cao617ba132006-10-11 01:20:53 -0700515 case EXT4_IOC_GROUP_EXTEND: {
516 ext4_fsblk_t n_blocks_count;
Peng Taoac046f12009-07-13 09:30:17 -0400517 int err, err2=0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700518
Yongqiang Yang8f82f842011-07-26 21:35:44 -0400519 err = ext4_resize_begin(sb);
520 if (err)
521 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700522
Djalal Harouni014a1772012-01-04 17:09:52 -0500523 if (get_user(n_blocks_count, (__u32 __user *)arg)) {
524 err = -EFAULT;
525 goto group_extend_out;
526 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700527
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400528 if (ext4_has_feature_bigalloc(sb)) {
Theodore Ts'obab08ab2011-09-09 18:36:51 -0400529 ext4_msg(sb, KERN_ERR,
530 "Online resizing not supported with bigalloc");
Djalal Harouni014a1772012-01-04 17:09:52 -0500531 err = -EOPNOTSUPP;
532 goto group_extend_out;
Theodore Ts'obab08ab2011-09-09 18:36:51 -0400533 }
534
Al Viroa561be72011-11-23 11:57:51 -0500535 err = mnt_want_write_file(filp);
Dave Hansen42a74f22008-02-15 14:37:46 -0800536 if (err)
Djalal Harouni014a1772012-01-04 17:09:52 -0500537 goto group_extend_out;
Dave Hansen42a74f22008-02-15 14:37:46 -0800538
Mingming Cao617ba132006-10-11 01:20:53 -0700539 err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);
Peng Taoac046f12009-07-13 09:30:17 -0400540 if (EXT4_SB(sb)->s_journal) {
541 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
542 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
543 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
544 }
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -0400545 if (err == 0)
546 err = err2;
Al Viro2a79f172011-12-09 08:06:57 -0500547 mnt_drop_write_file(filp);
Djalal Harouni014a1772012-01-04 17:09:52 -0500548group_extend_out:
Yongqiang Yang8f82f842011-07-26 21:35:44 -0400549 ext4_resize_end(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700550 return err;
551 }
Akira Fujita748de672009-06-17 19:24:03 -0400552
553 case EXT4_IOC_MOVE_EXT: {
554 struct move_extent me;
Al Viro2903ff02012-08-28 12:52:22 -0400555 struct fd donor;
556 int err;
Akira Fujita748de672009-06-17 19:24:03 -0400557
Akira Fujita4a585792009-12-06 23:38:31 -0500558 if (!(filp->f_mode & FMODE_READ) ||
559 !(filp->f_mode & FMODE_WRITE))
560 return -EBADF;
561
Akira Fujita748de672009-06-17 19:24:03 -0400562 if (copy_from_user(&me,
563 (struct move_extent __user *)arg, sizeof(me)))
564 return -EFAULT;
Akira Fujita4a585792009-12-06 23:38:31 -0500565 me.moved_len = 0;
Akira Fujita748de672009-06-17 19:24:03 -0400566
Al Viro2903ff02012-08-28 12:52:22 -0400567 donor = fdget(me.donor_fd);
568 if (!donor.file)
Akira Fujita748de672009-06-17 19:24:03 -0400569 return -EBADF;
570
Al Viro2903ff02012-08-28 12:52:22 -0400571 if (!(donor.file->f_mode & FMODE_WRITE)) {
Akira Fujita4a585792009-12-06 23:38:31 -0500572 err = -EBADF;
573 goto mext_out;
Akira Fujita748de672009-06-17 19:24:03 -0400574 }
575
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400576 if (ext4_has_feature_bigalloc(sb)) {
Theodore Ts'obab08ab2011-09-09 18:36:51 -0400577 ext4_msg(sb, KERN_ERR,
578 "Online defrag not supported with bigalloc");
Al Viro399c9b82012-08-26 21:00:03 -0400579 err = -EOPNOTSUPP;
580 goto mext_out;
Ross Zwisler73f34a52016-02-26 15:19:49 -0800581 } else if (IS_DAX(inode)) {
582 ext4_msg(sb, KERN_ERR,
583 "Online defrag not supported with DAX");
584 err = -EOPNOTSUPP;
585 goto mext_out;
Theodore Ts'obab08ab2011-09-09 18:36:51 -0400586 }
587
Al Viroa561be72011-11-23 11:57:51 -0500588 err = mnt_want_write_file(filp);
Akira Fujita4a585792009-12-06 23:38:31 -0500589 if (err)
590 goto mext_out;
591
Al Viro2903ff02012-08-28 12:52:22 -0400592 err = ext4_move_extents(filp, donor.file, me.orig_start,
Akira Fujita748de672009-06-17 19:24:03 -0400593 me.donor_start, me.len, &me.moved_len);
Al Viro2a79f172011-12-09 08:06:57 -0500594 mnt_drop_write_file(filp);
Akira Fujita748de672009-06-17 19:24:03 -0400595
Theodore Ts'o60e66792010-05-17 07:00:00 -0400596 if (copy_to_user((struct move_extent __user *)arg,
Akira Fujitac437b272010-03-04 00:39:24 -0500597 &me, sizeof(me)))
Akira Fujita4a585792009-12-06 23:38:31 -0500598 err = -EFAULT;
599mext_out:
Al Viro2903ff02012-08-28 12:52:22 -0400600 fdput(donor);
Akira Fujita748de672009-06-17 19:24:03 -0400601 return err;
602 }
603
Mingming Cao617ba132006-10-11 01:20:53 -0700604 case EXT4_IOC_GROUP_ADD: {
605 struct ext4_new_group_data input;
Peng Taoac046f12009-07-13 09:30:17 -0400606 int err, err2=0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700607
Yongqiang Yang8f82f842011-07-26 21:35:44 -0400608 err = ext4_resize_begin(sb);
609 if (err)
610 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700611
Mingming Cao617ba132006-10-11 01:20:53 -0700612 if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
Djalal Harouni014a1772012-01-04 17:09:52 -0500613 sizeof(input))) {
614 err = -EFAULT;
615 goto group_add_out;
616 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700617
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400618 if (ext4_has_feature_bigalloc(sb)) {
Theodore Ts'obab08ab2011-09-09 18:36:51 -0400619 ext4_msg(sb, KERN_ERR,
620 "Online resizing not supported with bigalloc");
Djalal Harouni014a1772012-01-04 17:09:52 -0500621 err = -EOPNOTSUPP;
622 goto group_add_out;
Theodore Ts'obab08ab2011-09-09 18:36:51 -0400623 }
624
Al Viroa561be72011-11-23 11:57:51 -0500625 err = mnt_want_write_file(filp);
Dave Hansen42a74f22008-02-15 14:37:46 -0800626 if (err)
Djalal Harouni014a1772012-01-04 17:09:52 -0500627 goto group_add_out;
Dave Hansen42a74f22008-02-15 14:37:46 -0800628
Mingming Cao617ba132006-10-11 01:20:53 -0700629 err = ext4_group_add(sb, &input);
Peng Taoac046f12009-07-13 09:30:17 -0400630 if (EXT4_SB(sb)->s_journal) {
631 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
632 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
633 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
634 }
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -0400635 if (err == 0)
636 err = err2;
Al Viro2a79f172011-12-09 08:06:57 -0500637 mnt_drop_write_file(filp);
Theodore Ts'o7f511862013-01-13 08:41:45 -0500638 if (!err && ext4_has_group_desc_csum(sb) &&
639 test_opt(sb, INIT_INODE_TABLE))
640 err = ext4_register_li_request(sb, input.group);
Djalal Harouni014a1772012-01-04 17:09:52 -0500641group_add_out:
Yongqiang Yang8f82f842011-07-26 21:35:44 -0400642 ext4_resize_end(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700643 return err;
644 }
645
Aneesh Kumar K.Vc14c6fd2008-01-28 23:58:26 -0500646 case EXT4_IOC_MIGRATE:
Aneesh Kumar K.V2a43a872008-09-13 12:52:26 -0400647 {
648 int err;
Serge E. Hallyn2e149672011-03-23 16:43:26 -0700649 if (!inode_owner_or_capable(inode))
Aneesh Kumar K.V2a43a872008-09-13 12:52:26 -0400650 return -EACCES;
651
Al Viroa561be72011-11-23 11:57:51 -0500652 err = mnt_want_write_file(filp);
Aneesh Kumar K.V2a43a872008-09-13 12:52:26 -0400653 if (err)
654 return err;
655 /*
656 * inode_mutex prevent write and truncate on the file.
657 * Read still goes through. We take i_data_sem in
658 * ext4_ext_swap_inode_data before we switch the
659 * inode format to prevent read.
660 */
Al Viro59551022016-01-22 15:40:57 -0500661 inode_lock((inode));
Aneesh Kumar K.V2a43a872008-09-13 12:52:26 -0400662 err = ext4_ext_migrate(inode);
Al Viro59551022016-01-22 15:40:57 -0500663 inode_unlock((inode));
Al Viro2a79f172011-12-09 08:06:57 -0500664 mnt_drop_write_file(filp);
Aneesh Kumar K.V2a43a872008-09-13 12:52:26 -0400665 return err;
666 }
Aneesh Kumar K.Vc14c6fd2008-01-28 23:58:26 -0500667
Theodore Ts'occd25062009-02-26 01:04:07 -0500668 case EXT4_IOC_ALLOC_DA_BLKS:
669 {
670 int err;
Serge E. Hallyn2e149672011-03-23 16:43:26 -0700671 if (!inode_owner_or_capable(inode))
Theodore Ts'occd25062009-02-26 01:04:07 -0500672 return -EACCES;
673
Al Viroa561be72011-11-23 11:57:51 -0500674 err = mnt_want_write_file(filp);
Theodore Ts'occd25062009-02-26 01:04:07 -0500675 if (err)
676 return err;
677 err = ext4_alloc_da_blocks(inode);
Al Viro2a79f172011-12-09 08:06:57 -0500678 mnt_drop_write_file(filp);
Theodore Ts'occd25062009-02-26 01:04:07 -0500679 return err;
680 }
681
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400682 case EXT4_IOC_SWAP_BOOT:
Dmitry Monakhov3e67cfad22014-10-03 12:47:23 -0400683 {
684 int err;
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400685 if (!(filp->f_mode & FMODE_WRITE))
686 return -EBADF;
Dmitry Monakhov3e67cfad22014-10-03 12:47:23 -0400687 err = mnt_want_write_file(filp);
688 if (err)
689 return err;
690 err = swap_inode_boot_loader(sb, inode);
691 mnt_drop_write_file(filp);
692 return err;
693 }
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -0400694
Yongqiang Yang19c52462012-01-04 17:09:44 -0500695 case EXT4_IOC_RESIZE_FS: {
696 ext4_fsblk_t n_blocks_count;
Yongqiang Yang19c52462012-01-04 17:09:44 -0500697 int err = 0, err2 = 0;
Theodore Ts'o7f511862013-01-13 08:41:45 -0500698 ext4_group_t o_group = EXT4_SB(sb)->s_groups_count;
Yongqiang Yang19c52462012-01-04 17:09:44 -0500699
Darrick J. Wonge2b911c2015-10-17 16:18:43 -0400700 if (ext4_has_feature_bigalloc(sb)) {
Yongqiang Yang19c52462012-01-04 17:09:44 -0500701 ext4_msg(sb, KERN_ERR,
702 "Online resizing not (yet) supported with bigalloc");
703 return -EOPNOTSUPP;
704 }
705
Yongqiang Yang19c52462012-01-04 17:09:44 -0500706 if (copy_from_user(&n_blocks_count, (__u64 __user *)arg,
707 sizeof(__u64))) {
708 return -EFAULT;
709 }
710
Yongqiang Yang19c52462012-01-04 17:09:44 -0500711 err = ext4_resize_begin(sb);
712 if (err)
713 return err;
714
Al Viro8cae6f72012-07-19 11:19:07 +0400715 err = mnt_want_write_file(filp);
Yongqiang Yang19c52462012-01-04 17:09:44 -0500716 if (err)
717 goto resizefs_out;
718
719 err = ext4_resize_fs(sb, n_blocks_count);
720 if (EXT4_SB(sb)->s_journal) {
721 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
722 err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
723 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
724 }
725 if (err == 0)
726 err = err2;
Al Viro8cae6f72012-07-19 11:19:07 +0400727 mnt_drop_write_file(filp);
Theodore Ts'o7f511862013-01-13 08:41:45 -0500728 if (!err && (o_group > EXT4_SB(sb)->s_groups_count) &&
729 ext4_has_group_desc_csum(sb) &&
730 test_opt(sb, INIT_INODE_TABLE))
731 err = ext4_register_li_request(sb, o_group);
732
Yongqiang Yang19c52462012-01-04 17:09:44 -0500733resizefs_out:
734 ext4_resize_end(sb);
735 return err;
736 }
737
Lukas Czernere681c042010-11-19 21:47:07 -0500738 case FITRIM:
739 {
Lukas Czerner41431792011-02-23 12:42:32 -0500740 struct request_queue *q = bdev_get_queue(sb->s_bdev);
Lukas Czernere681c042010-11-19 21:47:07 -0500741 struct fstrim_range range;
742 int ret = 0;
743
744 if (!capable(CAP_SYS_ADMIN))
745 return -EPERM;
746
Lukas Czerner41431792011-02-23 12:42:32 -0500747 if (!blk_queue_discard(q))
748 return -EOPNOTSUPP;
749
H Hartley Sweetene6705f72011-10-18 10:59:51 -0400750 if (copy_from_user(&range, (struct fstrim_range __user *)arg,
Lukas Czernere681c042010-11-19 21:47:07 -0500751 sizeof(range)))
752 return -EFAULT;
753
Lukas Czerner5c2ed622011-02-23 17:49:51 -0500754 range.minlen = max((unsigned int)range.minlen,
755 q->limits.discard_granularity);
Lukas Czernere681c042010-11-19 21:47:07 -0500756 ret = ext4_trim_fs(sb, &range);
757 if (ret < 0)
758 return ret;
759
H Hartley Sweetene6705f72011-10-18 10:59:51 -0400760 if (copy_to_user((struct fstrim_range __user *)arg, &range,
Lukas Czernere681c042010-11-19 21:47:07 -0500761 sizeof(range)))
762 return -EFAULT;
763
764 return 0;
765 }
Theodore Ts'o7869a4a2013-08-16 22:05:14 -0400766 case EXT4_IOC_PRECACHE_EXTENTS:
767 return ext4_ext_precache(inode);
Michael Halcrow9bd82122015-04-11 07:48:01 -0400768 case EXT4_IOC_SET_ENCRYPTION_POLICY: {
769#ifdef CONFIG_EXT4_FS_ENCRYPTION
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400770 struct fscrypt_policy policy;
Lukas Czernere681c042010-11-19 21:47:07 -0500771
Richard Weinberger9a200d02016-09-30 01:49:55 -0400772 if (!ext4_has_feature_encrypt(sb))
773 return -EOPNOTSUPP;
774
Michael Halcrow9bd82122015-04-11 07:48:01 -0400775 if (copy_from_user(&policy,
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400776 (struct fscrypt_policy __user *)arg,
777 sizeof(policy)))
778 return -EFAULT;
Eric Biggersba63f232016-09-08 14:20:38 -0700779 return fscrypt_process_policy(filp, &policy);
Michael Halcrow9bd82122015-04-11 07:48:01 -0400780#else
781 return -EOPNOTSUPP;
782#endif
783 }
784 case EXT4_IOC_GET_ENCRYPTION_PWSALT: {
785 int err, err2;
786 struct ext4_sb_info *sbi = EXT4_SB(sb);
787 handle_t *handle;
788
789 if (!ext4_sb_has_crypto(sb))
790 return -EOPNOTSUPP;
791 if (uuid_is_zero(sbi->s_es->s_encrypt_pw_salt)) {
792 err = mnt_want_write_file(filp);
793 if (err)
794 return err;
795 handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1);
796 if (IS_ERR(handle)) {
797 err = PTR_ERR(handle);
798 goto pwsalt_err_exit;
799 }
800 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
801 if (err)
802 goto pwsalt_err_journal;
803 generate_random_uuid(sbi->s_es->s_encrypt_pw_salt);
804 err = ext4_handle_dirty_metadata(handle, NULL,
805 sbi->s_sbh);
806 pwsalt_err_journal:
807 err2 = ext4_journal_stop(handle);
808 if (err2 && !err)
809 err = err2;
810 pwsalt_err_exit:
811 mnt_drop_write_file(filp);
812 if (err)
813 return err;
814 }
Fabian Frederickb4ab9e22015-06-08 12:23:21 -0400815 if (copy_to_user((void __user *) arg,
816 sbi->s_es->s_encrypt_pw_salt, 16))
Michael Halcrow9bd82122015-04-11 07:48:01 -0400817 return -EFAULT;
818 return 0;
819 }
820 case EXT4_IOC_GET_ENCRYPTION_POLICY: {
821#ifdef CONFIG_EXT4_FS_ENCRYPTION
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400822 struct fscrypt_policy policy;
Michael Halcrow9bd82122015-04-11 07:48:01 -0400823 int err = 0;
824
825 if (!ext4_encrypted_inode(inode))
826 return -ENOENT;
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400827 err = fscrypt_get_policy(inode, &policy);
Michael Halcrow9bd82122015-04-11 07:48:01 -0400828 if (err)
829 return err;
Fabian Frederickb4ab9e22015-06-08 12:23:21 -0400830 if (copy_to_user((void __user *)arg, &policy, sizeof(policy)))
Michael Halcrow9bd82122015-04-11 07:48:01 -0400831 return -EFAULT;
832 return 0;
833#else
834 return -EOPNOTSUPP;
835#endif
836 }
Li Xi9b7365f2016-01-08 16:01:22 -0500837 case EXT4_IOC_FSGETXATTR:
838 {
839 struct fsxattr fa;
840
841 memset(&fa, 0, sizeof(struct fsxattr));
842 ext4_get_inode_flags(ei);
843 fa.fsx_xflags = ext4_iflags_to_xflags(ei->i_flags & EXT4_FL_USER_VISIBLE);
844
Kaho Ng0b7b7772016-09-05 23:11:58 -0400845 if (ext4_has_feature_project(inode->i_sb)) {
Li Xi9b7365f2016-01-08 16:01:22 -0500846 fa.fsx_projid = (__u32)from_kprojid(&init_user_ns,
847 EXT4_I(inode)->i_projid);
848 }
849
850 if (copy_to_user((struct fsxattr __user *)arg,
851 &fa, sizeof(fa)))
852 return -EFAULT;
853 return 0;
854 }
855 case EXT4_IOC_FSSETXATTR:
856 {
857 struct fsxattr fa;
858 int err;
859
860 if (copy_from_user(&fa, (struct fsxattr __user *)arg,
861 sizeof(fa)))
862 return -EFAULT;
863
864 /* Make sure caller has proper permission */
865 if (!inode_owner_or_capable(inode))
866 return -EACCES;
867
868 err = mnt_want_write_file(filp);
869 if (err)
870 return err;
871
872 flags = ext4_xflags_to_iflags(fa.fsx_xflags);
873 flags = ext4_mask_flags(inode->i_mode, flags);
874
Al Viro59551022016-01-22 15:40:57 -0500875 inode_lock(inode);
Li Xi9b7365f2016-01-08 16:01:22 -0500876 flags = (ei->i_flags & ~EXT4_FL_XFLAG_VISIBLE) |
877 (flags & EXT4_FL_XFLAG_VISIBLE);
878 err = ext4_ioctl_setflags(inode, flags);
Al Viro59551022016-01-22 15:40:57 -0500879 inode_unlock(inode);
Li Xi9b7365f2016-01-08 16:01:22 -0500880 mnt_drop_write_file(filp);
881 if (err)
882 return err;
883
884 err = ext4_ioctl_setproject(filp, fa.fsx_projid);
885 if (err)
886 return err;
887
888 return 0;
889 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700890 default:
891 return -ENOTTY;
892 }
893}
894
895#ifdef CONFIG_COMPAT
Mingming Cao617ba132006-10-11 01:20:53 -0700896long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700897{
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700898 /* These are just misnamed, they actually get/put from/to user an int */
899 switch (cmd) {
Mingming Cao617ba132006-10-11 01:20:53 -0700900 case EXT4_IOC32_GETFLAGS:
901 cmd = EXT4_IOC_GETFLAGS;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700902 break;
Mingming Cao617ba132006-10-11 01:20:53 -0700903 case EXT4_IOC32_SETFLAGS:
904 cmd = EXT4_IOC_SETFLAGS;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700905 break;
Mingming Cao617ba132006-10-11 01:20:53 -0700906 case EXT4_IOC32_GETVERSION:
907 cmd = EXT4_IOC_GETVERSION;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700908 break;
Mingming Cao617ba132006-10-11 01:20:53 -0700909 case EXT4_IOC32_SETVERSION:
910 cmd = EXT4_IOC_SETVERSION;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700911 break;
Mingming Cao617ba132006-10-11 01:20:53 -0700912 case EXT4_IOC32_GROUP_EXTEND:
913 cmd = EXT4_IOC_GROUP_EXTEND;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700914 break;
Mingming Cao617ba132006-10-11 01:20:53 -0700915 case EXT4_IOC32_GETVERSION_OLD:
916 cmd = EXT4_IOC_GETVERSION_OLD;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700917 break;
Mingming Cao617ba132006-10-11 01:20:53 -0700918 case EXT4_IOC32_SETVERSION_OLD:
919 cmd = EXT4_IOC_SETVERSION_OLD;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700920 break;
Mingming Cao617ba132006-10-11 01:20:53 -0700921 case EXT4_IOC32_GETRSVSZ:
922 cmd = EXT4_IOC_GETRSVSZ;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700923 break;
Mingming Cao617ba132006-10-11 01:20:53 -0700924 case EXT4_IOC32_SETRSVSZ:
925 cmd = EXT4_IOC_SETRSVSZ;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700926 break;
Ben Hutchings4d92dc02010-05-17 06:00:00 -0400927 case EXT4_IOC32_GROUP_ADD: {
928 struct compat_ext4_new_group_input __user *uinput;
929 struct ext4_new_group_input input;
930 mm_segment_t old_fs;
931 int err;
932
933 uinput = compat_ptr(arg);
934 err = get_user(input.group, &uinput->group);
935 err |= get_user(input.block_bitmap, &uinput->block_bitmap);
936 err |= get_user(input.inode_bitmap, &uinput->inode_bitmap);
937 err |= get_user(input.inode_table, &uinput->inode_table);
938 err |= get_user(input.blocks_count, &uinput->blocks_count);
939 err |= get_user(input.reserved_blocks,
940 &uinput->reserved_blocks);
941 if (err)
942 return -EFAULT;
943 old_fs = get_fs();
944 set_fs(KERNEL_DS);
945 err = ext4_ioctl(file, EXT4_IOC_GROUP_ADD,
946 (unsigned long) &input);
947 set_fs(old_fs);
948 return err;
949 }
Christian Borntraegerb684b2e2010-05-15 00:00:00 -0400950 case EXT4_IOC_MOVE_EXT:
Yongqiang Yang19c52462012-01-04 17:09:44 -0500951 case EXT4_IOC_RESIZE_FS:
Theodore Ts'o7869a4a2013-08-16 22:05:14 -0400952 case EXT4_IOC_PRECACHE_EXTENTS:
Michael Halcrow9bd82122015-04-11 07:48:01 -0400953 case EXT4_IOC_SET_ENCRYPTION_POLICY:
954 case EXT4_IOC_GET_ENCRYPTION_PWSALT:
955 case EXT4_IOC_GET_ENCRYPTION_POLICY:
Christian Borntraegerb684b2e2010-05-15 00:00:00 -0400956 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700957 default:
958 return -ENOIOCTLCMD;
959 }
Andi Kleen5cdd7b22008-04-29 22:03:54 -0400960 return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700961}
962#endif