Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ioctl.c
Go to the documentation of this file.
1 /*
2  * linux/fs/ext4/ioctl.c
3  *
4  * Copyright (C) 1993, 1994, 1995
5  * Remy Card ([email protected])
6  * Laboratoire MASI - Institut Blaise Pascal
7  * Universite Pierre et Marie Curie (Paris VI)
8  */
9 
10 #include <linux/fs.h>
11 #include <linux/jbd2.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 <asm/uaccess.h>
18 #include "ext4_jbd2.h"
19 #include "ext4.h"
20 
21 #define MAX_32_NUM ((((unsigned long long) 1) << 32) - 1)
22 
23 long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
24 {
25  struct inode *inode = filp->f_dentry->d_inode;
26  struct super_block *sb = inode->i_sb;
27  struct ext4_inode_info *ei = EXT4_I(inode);
28  unsigned int flags;
29 
30  ext4_debug("cmd = %u, arg = %lu\n", cmd, arg);
31 
32  switch (cmd) {
33  case EXT4_IOC_GETFLAGS:
34  ext4_get_inode_flags(ei);
35  flags = ei->i_flags & EXT4_FL_USER_VISIBLE;
36  return put_user(flags, (int __user *) arg);
37  case EXT4_IOC_SETFLAGS: {
38  handle_t *handle = NULL;
39  int err, migrate = 0;
40  struct ext4_iloc iloc;
41  unsigned int oldflags, mask, i;
42  unsigned int jflag;
43 
44  if (!inode_owner_or_capable(inode))
45  return -EACCES;
46 
47  if (get_user(flags, (int __user *) arg))
48  return -EFAULT;
49 
50  err = mnt_want_write_file(filp);
51  if (err)
52  return err;
53 
54  flags = ext4_mask_flags(inode->i_mode, flags);
55 
56  err = -EPERM;
57  mutex_lock(&inode->i_mutex);
58  /* Is it quota file? Do not allow user to mess with it */
59  if (IS_NOQUOTA(inode))
60  goto flags_out;
61 
62  oldflags = ei->i_flags;
63 
64  /* The JOURNAL_DATA flag is modifiable only by root */
65  jflag = flags & EXT4_JOURNAL_DATA_FL;
66 
67  /*
68  * The IMMUTABLE and APPEND_ONLY flags can only be changed by
69  * the relevant capability.
70  *
71  * This test looks nicer. Thanks to Pauline Middelink
72  */
73  if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) {
74  if (!capable(CAP_LINUX_IMMUTABLE))
75  goto flags_out;
76  }
77 
78  /*
79  * The JOURNAL_DATA flag can only be changed by
80  * the relevant capability.
81  */
82  if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
83  if (!capable(CAP_SYS_RESOURCE))
84  goto flags_out;
85  }
86  if (oldflags & EXT4_EXTENTS_FL) {
87  /* We don't support clearning extent flags */
88  if (!(flags & EXT4_EXTENTS_FL)) {
89  err = -EOPNOTSUPP;
90  goto flags_out;
91  }
92  } else if (flags & EXT4_EXTENTS_FL) {
93  /* migrate the file */
94  migrate = 1;
95  flags &= ~EXT4_EXTENTS_FL;
96  }
97 
98  if (flags & EXT4_EOFBLOCKS_FL) {
99  /* we don't support adding EOFBLOCKS flag */
100  if (!(oldflags & EXT4_EOFBLOCKS_FL)) {
101  err = -EOPNOTSUPP;
102  goto flags_out;
103  }
104  } else if (oldflags & EXT4_EOFBLOCKS_FL)
105  ext4_truncate(inode);
106 
107  handle = ext4_journal_start(inode, 1);
108  if (IS_ERR(handle)) {
109  err = PTR_ERR(handle);
110  goto flags_out;
111  }
112  if (IS_SYNC(inode))
113  ext4_handle_sync(handle);
114  err = ext4_reserve_inode_write(handle, inode, &iloc);
115  if (err)
116  goto flags_err;
117 
118  for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
119  if (!(mask & EXT4_FL_USER_MODIFIABLE))
120  continue;
121  if (mask & flags)
122  ext4_set_inode_flag(inode, i);
123  else
124  ext4_clear_inode_flag(inode, i);
125  }
126 
127  ext4_set_inode_flags(inode);
128  inode->i_ctime = ext4_current_time(inode);
129 
130  err = ext4_mark_iloc_dirty(handle, inode, &iloc);
131 flags_err:
132  ext4_journal_stop(handle);
133  if (err)
134  goto flags_out;
135 
136  if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL))
137  err = ext4_change_inode_journal_flag(inode, jflag);
138  if (err)
139  goto flags_out;
140  if (migrate)
141  err = ext4_ext_migrate(inode);
142 flags_out:
143  mutex_unlock(&inode->i_mutex);
144  mnt_drop_write_file(filp);
145  return err;
146  }
147  case EXT4_IOC_GETVERSION:
148  case EXT4_IOC_GETVERSION_OLD:
149  return put_user(inode->i_generation, (int __user *) arg);
150  case EXT4_IOC_SETVERSION:
151  case EXT4_IOC_SETVERSION_OLD: {
152  handle_t *handle;
153  struct ext4_iloc iloc;
154  __u32 generation;
155  int err;
156 
157  if (!inode_owner_or_capable(inode))
158  return -EPERM;
159 
160  if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
161  EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
162  ext4_warning(sb, "Setting inode version is not "
163  "supported with metadata_csum enabled.");
164  return -ENOTTY;
165  }
166 
167  err = mnt_want_write_file(filp);
168  if (err)
169  return err;
170  if (get_user(generation, (int __user *) arg)) {
171  err = -EFAULT;
172  goto setversion_out;
173  }
174 
175  mutex_lock(&inode->i_mutex);
176  handle = ext4_journal_start(inode, 1);
177  if (IS_ERR(handle)) {
178  err = PTR_ERR(handle);
179  goto unlock_out;
180  }
181  err = ext4_reserve_inode_write(handle, inode, &iloc);
182  if (err == 0) {
183  inode->i_ctime = ext4_current_time(inode);
184  inode->i_generation = generation;
185  err = ext4_mark_iloc_dirty(handle, inode, &iloc);
186  }
187  ext4_journal_stop(handle);
188 
189 unlock_out:
190  mutex_unlock(&inode->i_mutex);
191 setversion_out:
192  mnt_drop_write_file(filp);
193  return err;
194  }
195  case EXT4_IOC_GROUP_EXTEND: {
196  ext4_fsblk_t n_blocks_count;
197  int err, err2=0;
198 
199  err = ext4_resize_begin(sb);
200  if (err)
201  return err;
202 
203  if (get_user(n_blocks_count, (__u32 __user *)arg)) {
204  err = -EFAULT;
205  goto group_extend_out;
206  }
207 
208  if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
209  EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
210  ext4_msg(sb, KERN_ERR,
211  "Online resizing not supported with bigalloc");
212  err = -EOPNOTSUPP;
213  goto group_extend_out;
214  }
215 
216  err = mnt_want_write_file(filp);
217  if (err)
218  goto group_extend_out;
219 
220  err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);
221  if (EXT4_SB(sb)->s_journal) {
222  jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
223  err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
224  jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
225  }
226  if (err == 0)
227  err = err2;
228  mnt_drop_write_file(filp);
229 group_extend_out:
230  ext4_resize_end(sb);
231  return err;
232  }
233 
234  case EXT4_IOC_MOVE_EXT: {
235  struct move_extent me;
236  struct fd donor;
237  int err;
238 
239  if (!(filp->f_mode & FMODE_READ) ||
240  !(filp->f_mode & FMODE_WRITE))
241  return -EBADF;
242 
243  if (copy_from_user(&me,
244  (struct move_extent __user *)arg, sizeof(me)))
245  return -EFAULT;
246  me.moved_len = 0;
247 
248  donor = fdget(me.donor_fd);
249  if (!donor.file)
250  return -EBADF;
251 
252  if (!(donor.file->f_mode & FMODE_WRITE)) {
253  err = -EBADF;
254  goto mext_out;
255  }
256 
257  if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
258  EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
259  ext4_msg(sb, KERN_ERR,
260  "Online defrag not supported with bigalloc");
261  err = -EOPNOTSUPP;
262  goto mext_out;
263  }
264 
265  err = mnt_want_write_file(filp);
266  if (err)
267  goto mext_out;
268 
269  err = ext4_move_extents(filp, donor.file, me.orig_start,
270  me.donor_start, me.len, &me.moved_len);
271  mnt_drop_write_file(filp);
272 
273  if (copy_to_user((struct move_extent __user *)arg,
274  &me, sizeof(me)))
275  err = -EFAULT;
276 mext_out:
277  fdput(donor);
278  return err;
279  }
280 
281  case EXT4_IOC_GROUP_ADD: {
282  struct ext4_new_group_data input;
283  int err, err2=0;
284 
285  err = ext4_resize_begin(sb);
286  if (err)
287  return err;
288 
289  if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
290  sizeof(input))) {
291  err = -EFAULT;
292  goto group_add_out;
293  }
294 
295  if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
296  EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
297  ext4_msg(sb, KERN_ERR,
298  "Online resizing not supported with bigalloc");
299  err = -EOPNOTSUPP;
300  goto group_add_out;
301  }
302 
303  err = mnt_want_write_file(filp);
304  if (err)
305  goto group_add_out;
306 
307  err = ext4_group_add(sb, &input);
308  if (EXT4_SB(sb)->s_journal) {
309  jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
310  err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
311  jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
312  }
313  if (err == 0)
314  err = err2;
315  mnt_drop_write_file(filp);
316 group_add_out:
317  ext4_resize_end(sb);
318  return err;
319  }
320 
321  case EXT4_IOC_MIGRATE:
322  {
323  int err;
324  if (!inode_owner_or_capable(inode))
325  return -EACCES;
326 
327  err = mnt_want_write_file(filp);
328  if (err)
329  return err;
330  /*
331  * inode_mutex prevent write and truncate on the file.
332  * Read still goes through. We take i_data_sem in
333  * ext4_ext_swap_inode_data before we switch the
334  * inode format to prevent read.
335  */
336  mutex_lock(&(inode->i_mutex));
337  err = ext4_ext_migrate(inode);
338  mutex_unlock(&(inode->i_mutex));
339  mnt_drop_write_file(filp);
340  return err;
341  }
342 
343  case EXT4_IOC_ALLOC_DA_BLKS:
344  {
345  int err;
346  if (!inode_owner_or_capable(inode))
347  return -EACCES;
348 
349  err = mnt_want_write_file(filp);
350  if (err)
351  return err;
352  err = ext4_alloc_da_blocks(inode);
353  mnt_drop_write_file(filp);
354  return err;
355  }
356 
357  case EXT4_IOC_RESIZE_FS: {
358  ext4_fsblk_t n_blocks_count;
359  struct super_block *sb = inode->i_sb;
360  int err = 0, err2 = 0;
361 
362  if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
363  EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
364  ext4_msg(sb, KERN_ERR,
365  "Online resizing not (yet) supported with bigalloc");
366  return -EOPNOTSUPP;
367  }
368 
369  if (copy_from_user(&n_blocks_count, (__u64 __user *)arg,
370  sizeof(__u64))) {
371  return -EFAULT;
372  }
373 
374  err = ext4_resize_begin(sb);
375  if (err)
376  return err;
377 
378  err = mnt_want_write_file(filp);
379  if (err)
380  goto resizefs_out;
381 
382  err = ext4_resize_fs(sb, n_blocks_count);
383  if (EXT4_SB(sb)->s_journal) {
384  jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
385  err2 = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
386  jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
387  }
388  if (err == 0)
389  err = err2;
390  mnt_drop_write_file(filp);
391 resizefs_out:
392  ext4_resize_end(sb);
393  return err;
394  }
395 
396  case FITRIM:
397  {
398  struct request_queue *q = bdev_get_queue(sb->s_bdev);
399  struct fstrim_range range;
400  int ret = 0;
401 
402  if (!capable(CAP_SYS_ADMIN))
403  return -EPERM;
404 
405  if (!blk_queue_discard(q))
406  return -EOPNOTSUPP;
407 
408  if (copy_from_user(&range, (struct fstrim_range __user *)arg,
409  sizeof(range)))
410  return -EFAULT;
411 
412  range.minlen = max((unsigned int)range.minlen,
413  q->limits.discard_granularity);
414  ret = ext4_trim_fs(sb, &range);
415  if (ret < 0)
416  return ret;
417 
418  if (copy_to_user((struct fstrim_range __user *)arg, &range,
419  sizeof(range)))
420  return -EFAULT;
421 
422  return 0;
423  }
424 
425  default:
426  return -ENOTTY;
427  }
428 }
429 
430 #ifdef CONFIG_COMPAT
431 long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
432 {
433  /* These are just misnamed, they actually get/put from/to user an int */
434  switch (cmd) {
435  case EXT4_IOC32_GETFLAGS:
436  cmd = EXT4_IOC_GETFLAGS;
437  break;
438  case EXT4_IOC32_SETFLAGS:
439  cmd = EXT4_IOC_SETFLAGS;
440  break;
441  case EXT4_IOC32_GETVERSION:
442  cmd = EXT4_IOC_GETVERSION;
443  break;
444  case EXT4_IOC32_SETVERSION:
445  cmd = EXT4_IOC_SETVERSION;
446  break;
447  case EXT4_IOC32_GROUP_EXTEND:
448  cmd = EXT4_IOC_GROUP_EXTEND;
449  break;
450  case EXT4_IOC32_GETVERSION_OLD:
451  cmd = EXT4_IOC_GETVERSION_OLD;
452  break;
453  case EXT4_IOC32_SETVERSION_OLD:
454  cmd = EXT4_IOC_SETVERSION_OLD;
455  break;
456  case EXT4_IOC32_GETRSVSZ:
457  cmd = EXT4_IOC_GETRSVSZ;
458  break;
459  case EXT4_IOC32_SETRSVSZ:
460  cmd = EXT4_IOC_SETRSVSZ;
461  break;
462  case EXT4_IOC32_GROUP_ADD: {
463  struct compat_ext4_new_group_input __user *uinput;
464  struct ext4_new_group_input input;
465  mm_segment_t old_fs;
466  int err;
467 
468  uinput = compat_ptr(arg);
469  err = get_user(input.group, &uinput->group);
470  err |= get_user(input.block_bitmap, &uinput->block_bitmap);
471  err |= get_user(input.inode_bitmap, &uinput->inode_bitmap);
472  err |= get_user(input.inode_table, &uinput->inode_table);
473  err |= get_user(input.blocks_count, &uinput->blocks_count);
474  err |= get_user(input.reserved_blocks,
475  &uinput->reserved_blocks);
476  if (err)
477  return -EFAULT;
478  old_fs = get_fs();
479  set_fs(KERNEL_DS);
480  err = ext4_ioctl(file, EXT4_IOC_GROUP_ADD,
481  (unsigned long) &input);
482  set_fs(old_fs);
483  return err;
484  }
485  case EXT4_IOC_MOVE_EXT:
486  case FITRIM:
487  case EXT4_IOC_RESIZE_FS:
488  break;
489  default:
490  return -ENOIOCTLCMD;
491  }
492  return ext4_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
493 }
494 #endif
Generated on Thu Jan 10 2013 13:12:45 for Linux Kernel by   doxygen 1.8.2