Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
file.c
Go to the documentation of this file.
1 /*
2  * linux/fs/fat/file.c
3  *
4  * Written 1992,1993 by Werner Almesberger
5  *
6  * regular file handling primitives for fat-based filesystems
7  */
8 
9 #include <linux/capability.h>
10 #include <linux/module.h>
11 #include <linux/compat.h>
12 #include <linux/mount.h>
13 #include <linux/time.h>
14 #include <linux/buffer_head.h>
15 #include <linux/writeback.h>
16 #include <linux/backing-dev.h>
17 #include <linux/blkdev.h>
18 #include <linux/fsnotify.h>
19 #include <linux/security.h>
20 #include "fat.h"
21 
22 static int fat_ioctl_get_attributes(struct inode *inode, u32 __user *user_attr)
23 {
24  u32 attr;
25 
26  mutex_lock(&inode->i_mutex);
27  attr = fat_make_attrs(inode);
28  mutex_unlock(&inode->i_mutex);
29 
30  return put_user(attr, user_attr);
31 }
32 
33 static int fat_ioctl_set_attributes(struct file *file, u32 __user *user_attr)
34 {
35  struct inode *inode = file->f_path.dentry->d_inode;
36  struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
37  int is_dir = S_ISDIR(inode->i_mode);
38  u32 attr, oldattr;
39  struct iattr ia;
40  int err;
41 
42  err = get_user(attr, user_attr);
43  if (err)
44  goto out;
45 
46  err = mnt_want_write_file(file);
47  if (err)
48  goto out;
49  mutex_lock(&inode->i_mutex);
50 
51  /*
52  * ATTR_VOLUME and ATTR_DIR cannot be changed; this also
53  * prevents the user from turning us into a VFAT
54  * longname entry. Also, we obviously can't set
55  * any of the NTFS attributes in the high 24 bits.
56  */
57  attr &= 0xff & ~(ATTR_VOLUME | ATTR_DIR);
58  /* Merge in ATTR_VOLUME and ATTR_DIR */
59  attr |= (MSDOS_I(inode)->i_attrs & ATTR_VOLUME) |
60  (is_dir ? ATTR_DIR : 0);
61  oldattr = fat_make_attrs(inode);
62 
63  /* Equivalent to a chmod() */
64  ia.ia_valid = ATTR_MODE | ATTR_CTIME;
65  ia.ia_ctime = current_fs_time(inode->i_sb);
66  if (is_dir)
67  ia.ia_mode = fat_make_mode(sbi, attr, S_IRWXUGO);
68  else {
69  ia.ia_mode = fat_make_mode(sbi, attr,
70  S_IRUGO | S_IWUGO | (inode->i_mode & S_IXUGO));
71  }
72 
73  /* The root directory has no attributes */
74  if (inode->i_ino == MSDOS_ROOT_INO && attr != ATTR_DIR) {
75  err = -EINVAL;
76  goto out_unlock_inode;
77  }
78 
79  if (sbi->options.sys_immutable &&
80  ((attr | oldattr) & ATTR_SYS) &&
82  err = -EPERM;
83  goto out_unlock_inode;
84  }
85 
86  /*
87  * The security check is questionable... We single
88  * out the RO attribute for checking by the security
89  * module, just because it maps to a file mode.
90  */
91  err = security_inode_setattr(file->f_path.dentry, &ia);
92  if (err)
93  goto out_unlock_inode;
94 
95  /* This MUST be done before doing anything irreversible... */
96  err = fat_setattr(file->f_path.dentry, &ia);
97  if (err)
98  goto out_unlock_inode;
99 
100  fsnotify_change(file->f_path.dentry, ia.ia_valid);
101  if (sbi->options.sys_immutable) {
102  if (attr & ATTR_SYS)
103  inode->i_flags |= S_IMMUTABLE;
104  else
105  inode->i_flags &= ~S_IMMUTABLE;
106  }
107 
108  fat_save_attrs(inode, attr);
109  mark_inode_dirty(inode);
110 out_unlock_inode:
111  mutex_unlock(&inode->i_mutex);
112  mnt_drop_write_file(file);
113 out:
114  return err;
115 }
116 
117 long fat_generic_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
118 {
119  struct inode *inode = filp->f_path.dentry->d_inode;
120  u32 __user *user_attr = (u32 __user *)arg;
121 
122  switch (cmd) {
124  return fat_ioctl_get_attributes(inode, user_attr);
126  return fat_ioctl_set_attributes(filp, user_attr);
127  default:
128  return -ENOTTY; /* Inappropriate ioctl for device */
129  }
130 }
131 
132 #ifdef CONFIG_COMPAT
133 static long fat_generic_compat_ioctl(struct file *filp, unsigned int cmd,
134  unsigned long arg)
135 
136 {
137  return fat_generic_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
138 }
139 #endif
140 
141 static int fat_file_release(struct inode *inode, struct file *filp)
142 {
143  if ((filp->f_mode & FMODE_WRITE) &&
144  MSDOS_SB(inode->i_sb)->options.flush) {
145  fat_flush_inodes(inode->i_sb, inode, NULL);
147  }
148  return 0;
149 }
150 
151 int fat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
152 {
153  struct inode *inode = filp->f_mapping->host;
154  int res, err;
155 
156  res = generic_file_fsync(filp, start, end, datasync);
157  err = sync_mapping_buffers(MSDOS_SB(inode->i_sb)->fat_inode->i_mapping);
158 
159  return res ? res : err;
160 }
161 
162 
164  .llseek = generic_file_llseek,
165  .read = do_sync_read,
166  .write = do_sync_write,
167  .aio_read = generic_file_aio_read,
168  .aio_write = generic_file_aio_write,
169  .mmap = generic_file_mmap,
170  .release = fat_file_release,
171  .unlocked_ioctl = fat_generic_ioctl,
172 #ifdef CONFIG_COMPAT
173  .compat_ioctl = fat_generic_compat_ioctl,
174 #endif
175  .fsync = fat_file_fsync,
176  .splice_read = generic_file_splice_read,
177 };
178 
179 static int fat_cont_expand(struct inode *inode, loff_t size)
180 {
181  struct address_space *mapping = inode->i_mapping;
182  loff_t start = inode->i_size, count = size - inode->i_size;
183  int err;
184 
185  err = generic_cont_expand_simple(inode, size);
186  if (err)
187  goto out;
188 
189  inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
190  mark_inode_dirty(inode);
191  if (IS_SYNC(inode)) {
192  int err2;
193 
194  /*
195  * Opencode syncing since we don't have a file open to use
196  * standard fsync path.
197  */
198  err = filemap_fdatawrite_range(mapping, start,
199  start + count - 1);
200  err2 = sync_mapping_buffers(mapping);
201  if (!err)
202  err = err2;
203  err2 = write_inode_now(inode, 1);
204  if (!err)
205  err = err2;
206  if (!err) {
207  err = filemap_fdatawait_range(mapping, start,
208  start + count - 1);
209  }
210  }
211 out:
212  return err;
213 }
214 
215 /* Free all clusters after the skip'th cluster. */
216 static int fat_free(struct inode *inode, int skip)
217 {
218  struct super_block *sb = inode->i_sb;
219  int err, wait, free_start, i_start, i_logstart;
220 
221  if (MSDOS_I(inode)->i_start == 0)
222  return 0;
223 
224  fat_cache_inval_inode(inode);
225 
226  wait = IS_DIRSYNC(inode);
227  i_start = free_start = MSDOS_I(inode)->i_start;
228  i_logstart = MSDOS_I(inode)->i_logstart;
229 
230  /* First, we write the new file size. */
231  if (!skip) {
232  MSDOS_I(inode)->i_start = 0;
233  MSDOS_I(inode)->i_logstart = 0;
234  }
235  MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
236  inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
237  if (wait) {
238  err = fat_sync_inode(inode);
239  if (err) {
240  MSDOS_I(inode)->i_start = i_start;
241  MSDOS_I(inode)->i_logstart = i_logstart;
242  return err;
243  }
244  } else
245  mark_inode_dirty(inode);
246 
247  /* Write a new EOF, and get the remaining cluster chain for freeing. */
248  if (skip) {
249  struct fat_entry fatent;
250  int ret, fclus, dclus;
251 
252  ret = fat_get_cluster(inode, skip - 1, &fclus, &dclus);
253  if (ret < 0)
254  return ret;
255  else if (ret == FAT_ENT_EOF)
256  return 0;
257 
258  fatent_init(&fatent);
259  ret = fat_ent_read(inode, &fatent, dclus);
260  if (ret == FAT_ENT_EOF) {
261  fatent_brelse(&fatent);
262  return 0;
263  } else if (ret == FAT_ENT_FREE) {
264  fat_fs_error(sb,
265  "%s: invalid cluster chain (i_pos %lld)",
266  __func__, MSDOS_I(inode)->i_pos);
267  ret = -EIO;
268  } else if (ret > 0) {
269  err = fat_ent_write(inode, &fatent, FAT_ENT_EOF, wait);
270  if (err)
271  ret = err;
272  }
273  fatent_brelse(&fatent);
274  if (ret < 0)
275  return ret;
276 
277  free_start = ret;
278  }
279  inode->i_blocks = skip << (MSDOS_SB(sb)->cluster_bits - 9);
280 
281  /* Freeing the remained cluster chain */
282  return fat_free_clusters(inode, free_start);
283 }
284 
285 void fat_truncate_blocks(struct inode *inode, loff_t offset)
286 {
287  struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
288  const unsigned int cluster_size = sbi->cluster_size;
289  int nr_clusters;
290 
291  /*
292  * This protects against truncating a file bigger than it was then
293  * trying to write into the hole.
294  */
295  if (MSDOS_I(inode)->mmu_private > offset)
296  MSDOS_I(inode)->mmu_private = offset;
297 
298  nr_clusters = (offset + (cluster_size - 1)) >> sbi->cluster_bits;
299 
300  fat_free(inode, nr_clusters);
301  fat_flush_inodes(inode->i_sb, inode, NULL);
302 }
303 
304 int fat_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
305 {
306  struct inode *inode = dentry->d_inode;
307  generic_fillattr(inode, stat);
308  stat->blksize = MSDOS_SB(inode->i_sb)->cluster_size;
309  return 0;
310 }
312 
313 static int fat_sanitize_mode(const struct msdos_sb_info *sbi,
314  struct inode *inode, umode_t *mode_ptr)
315 {
316  umode_t mask, perm;
317 
318  /*
319  * Note, the basic check is already done by a caller of
320  * (attr->ia_mode & ~FAT_VALID_MODE)
321  */
322 
323  if (S_ISREG(inode->i_mode))
324  mask = sbi->options.fs_fmask;
325  else
326  mask = sbi->options.fs_dmask;
327 
328  perm = *mode_ptr & ~(S_IFMT | mask);
329 
330  /*
331  * Of the r and x bits, all (subject to umask) must be present. Of the
332  * w bits, either all (subject to umask) or none must be present.
333  *
334  * If fat_mode_can_hold_ro(inode) is false, can't change w bits.
335  */
336  if ((perm & (S_IRUGO | S_IXUGO)) != (inode->i_mode & (S_IRUGO|S_IXUGO)))
337  return -EPERM;
338  if (fat_mode_can_hold_ro(inode)) {
339  if ((perm & S_IWUGO) && ((perm & S_IWUGO) != (S_IWUGO & ~mask)))
340  return -EPERM;
341  } else {
342  if ((perm & S_IWUGO) != (S_IWUGO & ~mask))
343  return -EPERM;
344  }
345 
346  *mode_ptr &= S_IFMT | perm;
347 
348  return 0;
349 }
350 
351 static int fat_allow_set_time(struct msdos_sb_info *sbi, struct inode *inode)
352 {
353  umode_t allow_utime = sbi->options.allow_utime;
354 
355  if (!uid_eq(current_fsuid(), inode->i_uid)) {
356  if (in_group_p(inode->i_gid))
357  allow_utime >>= 3;
358  if (allow_utime & MAY_WRITE)
359  return 1;
360  }
361 
362  /* use a default check */
363  return 0;
364 }
365 
366 #define TIMES_SET_FLAGS (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET)
367 /* valid file mode bits */
368 #define FAT_VALID_MODE (S_IFREG | S_IFDIR | S_IRWXUGO)
369 
370 int fat_setattr(struct dentry *dentry, struct iattr *attr)
371 {
372  struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb);
373  struct inode *inode = dentry->d_inode;
374  unsigned int ia_valid;
375  int error;
376 
377  /* Check for setting the inode time. */
378  ia_valid = attr->ia_valid;
379  if (ia_valid & TIMES_SET_FLAGS) {
380  if (fat_allow_set_time(sbi, inode))
381  attr->ia_valid &= ~TIMES_SET_FLAGS;
382  }
383 
384  error = inode_change_ok(inode, attr);
385  attr->ia_valid = ia_valid;
386  if (error) {
387  if (sbi->options.quiet)
388  error = 0;
389  goto out;
390  }
391 
392  /*
393  * Expand the file. Since inode_setattr() updates ->i_size
394  * before calling the ->truncate(), but FAT needs to fill the
395  * hole before it. XXX: this is no longer true with new truncate
396  * sequence.
397  */
398  if (attr->ia_valid & ATTR_SIZE) {
399  inode_dio_wait(inode);
400 
401  if (attr->ia_size > inode->i_size) {
402  error = fat_cont_expand(inode, attr->ia_size);
403  if (error || attr->ia_valid == ATTR_SIZE)
404  goto out;
405  attr->ia_valid &= ~ATTR_SIZE;
406  }
407  }
408 
409  if (((attr->ia_valid & ATTR_UID) &&
410  (!uid_eq(attr->ia_uid, sbi->options.fs_uid))) ||
411  ((attr->ia_valid & ATTR_GID) &&
412  (!gid_eq(attr->ia_gid, sbi->options.fs_gid))) ||
413  ((attr->ia_valid & ATTR_MODE) &&
414  (attr->ia_mode & ~FAT_VALID_MODE)))
415  error = -EPERM;
416 
417  if (error) {
418  if (sbi->options.quiet)
419  error = 0;
420  goto out;
421  }
422 
423  /*
424  * We don't return -EPERM here. Yes, strange, but this is too
425  * old behavior.
426  */
427  if (attr->ia_valid & ATTR_MODE) {
428  if (fat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0)
429  attr->ia_valid &= ~ATTR_MODE;
430  }
431 
432  if (attr->ia_valid & ATTR_SIZE) {
433  down_write(&MSDOS_I(inode)->truncate_lock);
434  truncate_setsize(inode, attr->ia_size);
435  fat_truncate_blocks(inode, attr->ia_size);
436  up_write(&MSDOS_I(inode)->truncate_lock);
437  }
438 
439  setattr_copy(inode, attr);
440  mark_inode_dirty(inode);
441 out:
442  return error;
443 }
445 
447  .setattr = fat_setattr,
448  .getattr = fat_getattr,
449 };