Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
inode.c
Go to the documentation of this file.
1 
26 #include <linux/file.h>
27 #include <linux/vmalloc.h>
28 #include <linux/pagemap.h>
29 #include <linux/dcache.h>
30 #include <linux/namei.h>
31 #include <linux/mount.h>
32 #include <linux/crypto.h>
33 #include <linux/fs_stack.h>
34 #include <linux/slab.h>
35 #include <linux/xattr.h>
36 #include <asm/unaligned.h>
37 #include "ecryptfs_kernel.h"
38 
39 static struct dentry *lock_parent(struct dentry *dentry)
40 {
41  struct dentry *dir;
42 
43  dir = dget_parent(dentry);
44  mutex_lock_nested(&(dir->d_inode->i_mutex), I_MUTEX_PARENT);
45  return dir;
46 }
47 
48 static void unlock_dir(struct dentry *dir)
49 {
50  mutex_unlock(&dir->d_inode->i_mutex);
51  dput(dir);
52 }
53 
54 static int ecryptfs_inode_test(struct inode *inode, void *lower_inode)
55 {
56  if (ecryptfs_inode_to_lower(inode) == (struct inode *)lower_inode)
57  return 1;
58  return 0;
59 }
60 
61 static int ecryptfs_inode_set(struct inode *inode, void *opaque)
62 {
63  struct inode *lower_inode = opaque;
64 
65  ecryptfs_set_inode_lower(inode, lower_inode);
66  fsstack_copy_attr_all(inode, lower_inode);
67  /* i_size will be overwritten for encrypted regular files */
68  fsstack_copy_inode_size(inode, lower_inode);
69  inode->i_ino = lower_inode->i_ino;
70  inode->i_version++;
71  inode->i_mapping->a_ops = &ecryptfs_aops;
72  inode->i_mapping->backing_dev_info = inode->i_sb->s_bdi;
73 
74  if (S_ISLNK(inode->i_mode))
75  inode->i_op = &ecryptfs_symlink_iops;
76  else if (S_ISDIR(inode->i_mode))
77  inode->i_op = &ecryptfs_dir_iops;
78  else
79  inode->i_op = &ecryptfs_main_iops;
80 
81  if (S_ISDIR(inode->i_mode))
82  inode->i_fop = &ecryptfs_dir_fops;
83  else if (special_file(inode->i_mode))
84  init_special_inode(inode, inode->i_mode, inode->i_rdev);
85  else
86  inode->i_fop = &ecryptfs_main_fops;
87 
88  return 0;
89 }
90 
91 static struct inode *__ecryptfs_get_inode(struct inode *lower_inode,
92  struct super_block *sb)
93 {
94  struct inode *inode;
95 
96  if (lower_inode->i_sb != ecryptfs_superblock_to_lower(sb))
97  return ERR_PTR(-EXDEV);
98  if (!igrab(lower_inode))
99  return ERR_PTR(-ESTALE);
100  inode = iget5_locked(sb, (unsigned long)lower_inode,
101  ecryptfs_inode_test, ecryptfs_inode_set,
102  lower_inode);
103  if (!inode) {
104  iput(lower_inode);
105  return ERR_PTR(-EACCES);
106  }
107  if (!(inode->i_state & I_NEW))
108  iput(lower_inode);
109 
110  return inode;
111 }
112 
113 struct inode *ecryptfs_get_inode(struct inode *lower_inode,
114  struct super_block *sb)
115 {
116  struct inode *inode = __ecryptfs_get_inode(lower_inode, sb);
117 
118  if (!IS_ERR(inode) && (inode->i_state & I_NEW))
119  unlock_new_inode(inode);
120 
121  return inode;
122 }
123 
134 static int ecryptfs_interpose(struct dentry *lower_dentry,
135  struct dentry *dentry, struct super_block *sb)
136 {
137  struct inode *inode = ecryptfs_get_inode(lower_dentry->d_inode, sb);
138 
139  if (IS_ERR(inode))
140  return PTR_ERR(inode);
141  d_instantiate(dentry, inode);
142 
143  return 0;
144 }
145 
146 static int ecryptfs_do_unlink(struct inode *dir, struct dentry *dentry,
147  struct inode *inode)
148 {
149  struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
150  struct inode *lower_dir_inode = ecryptfs_inode_to_lower(dir);
151  struct dentry *lower_dir_dentry;
152  int rc;
153 
154  dget(lower_dentry);
155  lower_dir_dentry = lock_parent(lower_dentry);
156  rc = vfs_unlink(lower_dir_inode, lower_dentry);
157  if (rc) {
158  printk(KERN_ERR "Error in vfs_unlink; rc = [%d]\n", rc);
159  goto out_unlock;
160  }
161  fsstack_copy_attr_times(dir, lower_dir_inode);
162  set_nlink(inode, ecryptfs_inode_to_lower(inode)->i_nlink);
163  inode->i_ctime = dir->i_ctime;
164  d_drop(dentry);
165 out_unlock:
166  unlock_dir(lower_dir_dentry);
167  dput(lower_dentry);
168  return rc;
169 }
170 
184 static struct inode *
185 ecryptfs_do_create(struct inode *directory_inode,
186  struct dentry *ecryptfs_dentry, umode_t mode)
187 {
188  int rc;
189  struct dentry *lower_dentry;
190  struct dentry *lower_dir_dentry;
191  struct inode *inode;
192 
193  lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
194  lower_dir_dentry = lock_parent(lower_dentry);
195  if (IS_ERR(lower_dir_dentry)) {
196  ecryptfs_printk(KERN_ERR, "Error locking directory of "
197  "dentry\n");
198  inode = ERR_CAST(lower_dir_dentry);
199  goto out;
200  }
201  rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, true);
202  if (rc) {
203  printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
204  "rc = [%d]\n", __func__, rc);
205  inode = ERR_PTR(rc);
206  goto out_lock;
207  }
208  inode = __ecryptfs_get_inode(lower_dentry->d_inode,
209  directory_inode->i_sb);
210  if (IS_ERR(inode)) {
211  vfs_unlink(lower_dir_dentry->d_inode, lower_dentry);
212  goto out_lock;
213  }
214  fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_inode);
215  fsstack_copy_inode_size(directory_inode, lower_dir_dentry->d_inode);
216 out_lock:
217  unlock_dir(lower_dir_dentry);
218 out:
219  return inode;
220 }
221 
230 int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry,
231  struct inode *ecryptfs_inode)
232 {
233  struct ecryptfs_crypt_stat *crypt_stat =
234  &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
235  int rc = 0;
236 
237  if (S_ISDIR(ecryptfs_inode->i_mode)) {
238  ecryptfs_printk(KERN_DEBUG, "This is a directory\n");
239  crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
240  goto out;
241  }
242  ecryptfs_printk(KERN_DEBUG, "Initializing crypto context\n");
243  rc = ecryptfs_new_file_context(ecryptfs_inode);
244  if (rc) {
245  ecryptfs_printk(KERN_ERR, "Error creating new file "
246  "context; rc = [%d]\n", rc);
247  goto out;
248  }
249  rc = ecryptfs_get_lower_file(ecryptfs_dentry, ecryptfs_inode);
250  if (rc) {
251  printk(KERN_ERR "%s: Error attempting to initialize "
252  "the lower file for the dentry with name "
253  "[%s]; rc = [%d]\n", __func__,
254  ecryptfs_dentry->d_name.name, rc);
255  goto out;
256  }
257  rc = ecryptfs_write_metadata(ecryptfs_dentry, ecryptfs_inode);
258  if (rc)
259  printk(KERN_ERR "Error writing headers; rc = [%d]\n", rc);
260  ecryptfs_put_lower_file(ecryptfs_inode);
261 out:
262  return rc;
263 }
264 
275 static int
276 ecryptfs_create(struct inode *directory_inode, struct dentry *ecryptfs_dentry,
277  umode_t mode, bool excl)
278 {
279  struct inode *ecryptfs_inode;
280  int rc;
281 
282  ecryptfs_inode = ecryptfs_do_create(directory_inode, ecryptfs_dentry,
283  mode);
284  if (unlikely(IS_ERR(ecryptfs_inode))) {
285  ecryptfs_printk(KERN_WARNING, "Failed to create file in"
286  "lower filesystem\n");
287  rc = PTR_ERR(ecryptfs_inode);
288  goto out;
289  }
290  /* At this point, a file exists on "disk"; we need to make sure
291  * that this on disk file is prepared to be an ecryptfs file */
292  rc = ecryptfs_initialize_file(ecryptfs_dentry, ecryptfs_inode);
293  if (rc) {
294  ecryptfs_do_unlink(directory_inode, ecryptfs_dentry,
295  ecryptfs_inode);
296  make_bad_inode(ecryptfs_inode);
297  unlock_new_inode(ecryptfs_inode);
298  iput(ecryptfs_inode);
299  goto out;
300  }
301  unlock_new_inode(ecryptfs_inode);
302  d_instantiate(ecryptfs_dentry, ecryptfs_inode);
303 out:
304  return rc;
305 }
306 
307 static int ecryptfs_i_size_read(struct dentry *dentry, struct inode *inode)
308 {
309  struct ecryptfs_crypt_stat *crypt_stat;
310  int rc;
311 
312  rc = ecryptfs_get_lower_file(dentry, inode);
313  if (rc) {
314  printk(KERN_ERR "%s: Error attempting to initialize "
315  "the lower file for the dentry with name "
316  "[%s]; rc = [%d]\n", __func__,
317  dentry->d_name.name, rc);
318  return rc;
319  }
320 
321  crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
322  /* TODO: lock for crypt_stat comparison */
323  if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED))
324  ecryptfs_set_default_sizes(crypt_stat);
325 
326  rc = ecryptfs_read_and_validate_header_region(inode);
327  ecryptfs_put_lower_file(inode);
328  if (rc) {
329  rc = ecryptfs_read_and_validate_xattr_region(dentry, inode);
330  if (!rc)
331  crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;
332  }
333 
334  /* Must return 0 to allow non-eCryptfs files to be looked up, too */
335  return 0;
336 }
337 
341 static int ecryptfs_lookup_interpose(struct dentry *dentry,
342  struct dentry *lower_dentry,
343  struct inode *dir_inode)
344 {
345  struct inode *inode, *lower_inode = lower_dentry->d_inode;
346  struct ecryptfs_dentry_info *dentry_info;
347  struct vfsmount *lower_mnt;
348  int rc = 0;
349 
350  dentry_info = kmem_cache_alloc(ecryptfs_dentry_info_cache, GFP_KERNEL);
351  if (!dentry_info) {
352  printk(KERN_ERR "%s: Out of memory whilst attempting "
353  "to allocate ecryptfs_dentry_info struct\n",
354  __func__);
355  dput(lower_dentry);
356  return -ENOMEM;
357  }
358 
359  lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(dentry->d_parent));
360  fsstack_copy_attr_atime(dir_inode, lower_dentry->d_parent->d_inode);
361  BUG_ON(!lower_dentry->d_count);
362 
363  ecryptfs_set_dentry_private(dentry, dentry_info);
364  ecryptfs_set_dentry_lower(dentry, lower_dentry);
365  ecryptfs_set_dentry_lower_mnt(dentry, lower_mnt);
366 
367  if (!lower_dentry->d_inode) {
368  /* We want to add because we couldn't find in lower */
369  d_add(dentry, NULL);
370  return 0;
371  }
372  inode = __ecryptfs_get_inode(lower_inode, dir_inode->i_sb);
373  if (IS_ERR(inode)) {
374  printk(KERN_ERR "%s: Error interposing; rc = [%ld]\n",
375  __func__, PTR_ERR(inode));
376  return PTR_ERR(inode);
377  }
378  if (S_ISREG(inode->i_mode)) {
379  rc = ecryptfs_i_size_read(dentry, inode);
380  if (rc) {
381  make_bad_inode(inode);
382  return rc;
383  }
384  }
385 
386  if (inode->i_state & I_NEW)
387  unlock_new_inode(inode);
388  d_add(dentry, inode);
389 
390  return rc;
391 }
392 
402 static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
403  struct dentry *ecryptfs_dentry,
404  unsigned int flags)
405 {
406  char *encrypted_and_encoded_name = NULL;
407  size_t encrypted_and_encoded_name_size;
408  struct ecryptfs_mount_crypt_stat *mount_crypt_stat = NULL;
409  struct dentry *lower_dir_dentry, *lower_dentry;
410  int rc = 0;
411 
412  lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent);
413  mutex_lock(&lower_dir_dentry->d_inode->i_mutex);
414  lower_dentry = lookup_one_len(ecryptfs_dentry->d_name.name,
415  lower_dir_dentry,
416  ecryptfs_dentry->d_name.len);
417  mutex_unlock(&lower_dir_dentry->d_inode->i_mutex);
418  if (IS_ERR(lower_dentry)) {
419  rc = PTR_ERR(lower_dentry);
420  ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
421  "[%d] on lower_dentry = [%s]\n", __func__, rc,
422  ecryptfs_dentry->d_name.name);
423  goto out;
424  }
425  if (lower_dentry->d_inode)
426  goto interpose;
427  mount_crypt_stat = &ecryptfs_superblock_to_private(
428  ecryptfs_dentry->d_sb)->mount_crypt_stat;
429  if (!(mount_crypt_stat
430  && (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)))
431  goto interpose;
432  dput(lower_dentry);
433  rc = ecryptfs_encrypt_and_encode_filename(
434  &encrypted_and_encoded_name, &encrypted_and_encoded_name_size,
435  NULL, mount_crypt_stat, ecryptfs_dentry->d_name.name,
436  ecryptfs_dentry->d_name.len);
437  if (rc) {
438  printk(KERN_ERR "%s: Error attempting to encrypt and encode "
439  "filename; rc = [%d]\n", __func__, rc);
440  goto out;
441  }
442  mutex_lock(&lower_dir_dentry->d_inode->i_mutex);
443  lower_dentry = lookup_one_len(encrypted_and_encoded_name,
444  lower_dir_dentry,
445  encrypted_and_encoded_name_size);
446  mutex_unlock(&lower_dir_dentry->d_inode->i_mutex);
447  if (IS_ERR(lower_dentry)) {
448  rc = PTR_ERR(lower_dentry);
449  ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
450  "[%d] on lower_dentry = [%s]\n", __func__, rc,
451  encrypted_and_encoded_name);
452  goto out;
453  }
454 interpose:
455  rc = ecryptfs_lookup_interpose(ecryptfs_dentry, lower_dentry,
456  ecryptfs_dir_inode);
457 out:
458  kfree(encrypted_and_encoded_name);
459  return ERR_PTR(rc);
460 }
461 
462 static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,
463  struct dentry *new_dentry)
464 {
465  struct dentry *lower_old_dentry;
466  struct dentry *lower_new_dentry;
467  struct dentry *lower_dir_dentry;
468  u64 file_size_save;
469  int rc;
470 
471  file_size_save = i_size_read(old_dentry->d_inode);
472  lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
473  lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
474  dget(lower_old_dentry);
475  dget(lower_new_dentry);
476  lower_dir_dentry = lock_parent(lower_new_dentry);
477  rc = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,
478  lower_new_dentry);
479  if (rc || !lower_new_dentry->d_inode)
480  goto out_lock;
481  rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb);
482  if (rc)
483  goto out_lock;
484  fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
485  fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
486  set_nlink(old_dentry->d_inode,
487  ecryptfs_inode_to_lower(old_dentry->d_inode)->i_nlink);
488  i_size_write(new_dentry->d_inode, file_size_save);
489 out_lock:
490  unlock_dir(lower_dir_dentry);
491  dput(lower_new_dentry);
492  dput(lower_old_dentry);
493  return rc;
494 }
495 
496 static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
497 {
498  return ecryptfs_do_unlink(dir, dentry, dentry->d_inode);
499 }
500 
501 static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
502  const char *symname)
503 {
504  int rc;
505  struct dentry *lower_dentry;
506  struct dentry *lower_dir_dentry;
507  char *encoded_symname;
508  size_t encoded_symlen;
509  struct ecryptfs_mount_crypt_stat *mount_crypt_stat = NULL;
510 
511  lower_dentry = ecryptfs_dentry_to_lower(dentry);
512  dget(lower_dentry);
513  lower_dir_dentry = lock_parent(lower_dentry);
514  mount_crypt_stat = &ecryptfs_superblock_to_private(
515  dir->i_sb)->mount_crypt_stat;
516  rc = ecryptfs_encrypt_and_encode_filename(&encoded_symname,
517  &encoded_symlen,
518  NULL,
519  mount_crypt_stat, symname,
520  strlen(symname));
521  if (rc)
522  goto out_lock;
523  rc = vfs_symlink(lower_dir_dentry->d_inode, lower_dentry,
524  encoded_symname);
525  kfree(encoded_symname);
526  if (rc || !lower_dentry->d_inode)
527  goto out_lock;
528  rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
529  if (rc)
530  goto out_lock;
531  fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
532  fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
533 out_lock:
534  unlock_dir(lower_dir_dentry);
535  dput(lower_dentry);
536  if (!dentry->d_inode)
537  d_drop(dentry);
538  return rc;
539 }
540 
541 static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
542 {
543  int rc;
544  struct dentry *lower_dentry;
545  struct dentry *lower_dir_dentry;
546 
547  lower_dentry = ecryptfs_dentry_to_lower(dentry);
548  lower_dir_dentry = lock_parent(lower_dentry);
549  rc = vfs_mkdir(lower_dir_dentry->d_inode, lower_dentry, mode);
550  if (rc || !lower_dentry->d_inode)
551  goto out;
552  rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
553  if (rc)
554  goto out;
555  fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
556  fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
557  set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);
558 out:
559  unlock_dir(lower_dir_dentry);
560  if (!dentry->d_inode)
561  d_drop(dentry);
562  return rc;
563 }
564 
565 static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
566 {
567  struct dentry *lower_dentry;
568  struct dentry *lower_dir_dentry;
569  int rc;
570 
571  lower_dentry = ecryptfs_dentry_to_lower(dentry);
572  dget(dentry);
573  lower_dir_dentry = lock_parent(lower_dentry);
574  dget(lower_dentry);
575  rc = vfs_rmdir(lower_dir_dentry->d_inode, lower_dentry);
576  dput(lower_dentry);
577  if (!rc && dentry->d_inode)
578  clear_nlink(dentry->d_inode);
579  fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
580  set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);
581  unlock_dir(lower_dir_dentry);
582  if (!rc)
583  d_drop(dentry);
584  dput(dentry);
585  return rc;
586 }
587 
588 static int
589 ecryptfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
590 {
591  int rc;
592  struct dentry *lower_dentry;
593  struct dentry *lower_dir_dentry;
594 
595  lower_dentry = ecryptfs_dentry_to_lower(dentry);
596  lower_dir_dentry = lock_parent(lower_dentry);
597  rc = vfs_mknod(lower_dir_dentry->d_inode, lower_dentry, mode, dev);
598  if (rc || !lower_dentry->d_inode)
599  goto out;
600  rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
601  if (rc)
602  goto out;
603  fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
604  fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
605 out:
606  unlock_dir(lower_dir_dentry);
607  if (!dentry->d_inode)
608  d_drop(dentry);
609  return rc;
610 }
611 
612 static int
613 ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
614  struct inode *new_dir, struct dentry *new_dentry)
615 {
616  int rc;
617  struct dentry *lower_old_dentry;
618  struct dentry *lower_new_dentry;
619  struct dentry *lower_old_dir_dentry;
620  struct dentry *lower_new_dir_dentry;
621  struct dentry *trap = NULL;
622  struct inode *target_inode;
623 
624  lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
625  lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
626  dget(lower_old_dentry);
627  dget(lower_new_dentry);
628  lower_old_dir_dentry = dget_parent(lower_old_dentry);
629  lower_new_dir_dentry = dget_parent(lower_new_dentry);
630  target_inode = new_dentry->d_inode;
631  trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
632  /* source should not be ancestor of target */
633  if (trap == lower_old_dentry) {
634  rc = -EINVAL;
635  goto out_lock;
636  }
637  /* target should not be ancestor of source */
638  if (trap == lower_new_dentry) {
639  rc = -ENOTEMPTY;
640  goto out_lock;
641  }
642  rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,
643  lower_new_dir_dentry->d_inode, lower_new_dentry);
644  if (rc)
645  goto out_lock;
646  if (target_inode)
647  fsstack_copy_attr_all(target_inode,
648  ecryptfs_inode_to_lower(target_inode));
649  fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);
650  if (new_dir != old_dir)
651  fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);
652 out_lock:
653  unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
654  dput(lower_new_dir_dentry);
655  dput(lower_old_dir_dentry);
656  dput(lower_new_dentry);
657  dput(lower_old_dentry);
658  return rc;
659 }
660 
661 static int ecryptfs_readlink_lower(struct dentry *dentry, char **buf,
662  size_t *bufsiz)
663 {
664  struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
665  char *lower_buf;
666  mm_segment_t old_fs;
667  int rc;
668 
669  lower_buf = kmalloc(PATH_MAX, GFP_KERNEL);
670  if (!lower_buf) {
671  rc = -ENOMEM;
672  goto out;
673  }
674  old_fs = get_fs();
675  set_fs(get_ds());
676  rc = lower_dentry->d_inode->i_op->readlink(lower_dentry,
677  (char __user *)lower_buf,
678  PATH_MAX);
679  set_fs(old_fs);
680  if (rc < 0)
681  goto out;
682  rc = ecryptfs_decode_and_decrypt_filename(buf, bufsiz, dentry,
683  lower_buf, rc);
684 out:
685  kfree(lower_buf);
686  return rc;
687 }
688 
689 static void *ecryptfs_follow_link(struct dentry *dentry, struct nameidata *nd)
690 {
691  char *buf;
692  size_t len = PATH_MAX;
693  int rc;
694 
695  rc = ecryptfs_readlink_lower(dentry, &buf, &len);
696  if (rc)
697  goto out;
698  fsstack_copy_attr_atime(dentry->d_inode,
699  ecryptfs_dentry_to_lower(dentry)->d_inode);
700  buf[len] = '\0';
701 out:
702  nd_set_link(nd, buf);
703  return NULL;
704 }
705 
706 static void
707 ecryptfs_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr)
708 {
709  char *buf = nd_get_link(nd);
710  if (!IS_ERR(buf)) {
711  /* Free the char* */
712  kfree(buf);
713  }
714 }
715 
727 static loff_t
728 upper_size_to_lower_size(struct ecryptfs_crypt_stat *crypt_stat,
729  loff_t upper_size)
730 {
731  loff_t lower_size;
732 
733  lower_size = ecryptfs_lower_header_size(crypt_stat);
734  if (upper_size != 0) {
735  loff_t num_extents;
736 
737  num_extents = upper_size >> crypt_stat->extent_shift;
738  if (upper_size & ~crypt_stat->extent_mask)
739  num_extents++;
740  lower_size += (num_extents * crypt_stat->extent_size);
741  }
742  return lower_size;
743 }
744 
761 static int truncate_upper(struct dentry *dentry, struct iattr *ia,
762  struct iattr *lower_ia)
763 {
764  int rc = 0;
765  struct inode *inode = dentry->d_inode;
766  struct ecryptfs_crypt_stat *crypt_stat;
767  loff_t i_size = i_size_read(inode);
768  loff_t lower_size_before_truncate;
769  loff_t lower_size_after_truncate;
770 
771  if (unlikely((ia->ia_size == i_size))) {
772  lower_ia->ia_valid &= ~ATTR_SIZE;
773  return 0;
774  }
775  rc = ecryptfs_get_lower_file(dentry, inode);
776  if (rc)
777  return rc;
778  crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
779  /* Switch on growing or shrinking file */
780  if (ia->ia_size > i_size) {
781  char zero[] = { 0x00 };
782 
783  lower_ia->ia_valid &= ~ATTR_SIZE;
784  /* Write a single 0 at the last position of the file;
785  * this triggers code that will fill in 0's throughout
786  * the intermediate portion of the previous end of the
787  * file and the new and of the file */
788  rc = ecryptfs_write(inode, zero,
789  (ia->ia_size - 1), 1);
790  } else { /* ia->ia_size < i_size_read(inode) */
791  /* We're chopping off all the pages down to the page
792  * in which ia->ia_size is located. Fill in the end of
793  * that page from (ia->ia_size & ~PAGE_CACHE_MASK) to
794  * PAGE_CACHE_SIZE with zeros. */
795  size_t num_zeros = (PAGE_CACHE_SIZE
796  - (ia->ia_size & ~PAGE_CACHE_MASK));
797 
798  if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
799  truncate_setsize(inode, ia->ia_size);
800  lower_ia->ia_size = ia->ia_size;
801  lower_ia->ia_valid |= ATTR_SIZE;
802  goto out;
803  }
804  if (num_zeros) {
805  char *zeros_virt;
806 
807  zeros_virt = kzalloc(num_zeros, GFP_KERNEL);
808  if (!zeros_virt) {
809  rc = -ENOMEM;
810  goto out;
811  }
812  rc = ecryptfs_write(inode, zeros_virt,
813  ia->ia_size, num_zeros);
814  kfree(zeros_virt);
815  if (rc) {
816  printk(KERN_ERR "Error attempting to zero out "
817  "the remainder of the end page on "
818  "reducing truncate; rc = [%d]\n", rc);
819  goto out;
820  }
821  }
822  truncate_setsize(inode, ia->ia_size);
823  rc = ecryptfs_write_inode_size_to_metadata(inode);
824  if (rc) {
825  printk(KERN_ERR "Problem with "
826  "ecryptfs_write_inode_size_to_metadata; "
827  "rc = [%d]\n", rc);
828  goto out;
829  }
830  /* We are reducing the size of the ecryptfs file, and need to
831  * know if we need to reduce the size of the lower file. */
832  lower_size_before_truncate =
833  upper_size_to_lower_size(crypt_stat, i_size);
834  lower_size_after_truncate =
835  upper_size_to_lower_size(crypt_stat, ia->ia_size);
836  if (lower_size_after_truncate < lower_size_before_truncate) {
837  lower_ia->ia_size = lower_size_after_truncate;
838  lower_ia->ia_valid |= ATTR_SIZE;
839  } else
840  lower_ia->ia_valid &= ~ATTR_SIZE;
841  }
842 out:
843  ecryptfs_put_lower_file(inode);
844  return rc;
845 }
846 
847 static int ecryptfs_inode_newsize_ok(struct inode *inode, loff_t offset)
848 {
849  struct ecryptfs_crypt_stat *crypt_stat;
850  loff_t lower_oldsize, lower_newsize;
851 
852  crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
853  lower_oldsize = upper_size_to_lower_size(crypt_stat,
854  i_size_read(inode));
855  lower_newsize = upper_size_to_lower_size(crypt_stat, offset);
856  if (lower_newsize > lower_oldsize) {
857  /*
858  * The eCryptfs inode and the new *lower* size are mixed here
859  * because we may not have the lower i_mutex held and/or it may
860  * not be appropriate to call inode_newsize_ok() with inodes
861  * from other filesystems.
862  */
863  return inode_newsize_ok(inode, lower_newsize);
864  }
865 
866  return 0;
867 }
868 
879 int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
880 {
881  struct iattr ia = { .ia_valid = ATTR_SIZE, .ia_size = new_length };
882  struct iattr lower_ia = { .ia_valid = 0 };
883  int rc;
884 
885  rc = ecryptfs_inode_newsize_ok(dentry->d_inode, new_length);
886  if (rc)
887  return rc;
888 
889  rc = truncate_upper(dentry, &ia, &lower_ia);
890  if (!rc && lower_ia.ia_valid & ATTR_SIZE) {
891  struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
892 
893  mutex_lock(&lower_dentry->d_inode->i_mutex);
894  rc = notify_change(lower_dentry, &lower_ia);
895  mutex_unlock(&lower_dentry->d_inode->i_mutex);
896  }
897  return rc;
898 }
899 
900 static int
901 ecryptfs_permission(struct inode *inode, int mask)
902 {
903  return inode_permission(ecryptfs_inode_to_lower(inode), mask);
904 }
905 
918 static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
919 {
920  int rc = 0;
921  struct dentry *lower_dentry;
922  struct iattr lower_ia;
923  struct inode *inode;
924  struct inode *lower_inode;
925  struct ecryptfs_crypt_stat *crypt_stat;
926 
927  crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
928  if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED))
929  ecryptfs_init_crypt_stat(crypt_stat);
930  inode = dentry->d_inode;
931  lower_inode = ecryptfs_inode_to_lower(inode);
932  lower_dentry = ecryptfs_dentry_to_lower(dentry);
933  mutex_lock(&crypt_stat->cs_mutex);
934  if (S_ISDIR(dentry->d_inode->i_mode))
935  crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
936  else if (S_ISREG(dentry->d_inode->i_mode)
937  && (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)
938  || !(crypt_stat->flags & ECRYPTFS_KEY_VALID))) {
939  struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
940 
941  mount_crypt_stat = &ecryptfs_superblock_to_private(
942  dentry->d_sb)->mount_crypt_stat;
943  rc = ecryptfs_get_lower_file(dentry, inode);
944  if (rc) {
945  mutex_unlock(&crypt_stat->cs_mutex);
946  goto out;
947  }
948  rc = ecryptfs_read_metadata(dentry);
949  ecryptfs_put_lower_file(inode);
950  if (rc) {
951  if (!(mount_crypt_stat->flags
952  & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)) {
953  rc = -EIO;
954  printk(KERN_WARNING "Either the lower file "
955  "is not in a valid eCryptfs format, "
956  "or the key could not be retrieved. "
957  "Plaintext passthrough mode is not "
958  "enabled; returning -EIO\n");
959  mutex_unlock(&crypt_stat->cs_mutex);
960  goto out;
961  }
962  rc = 0;
963  crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
964  | ECRYPTFS_ENCRYPTED);
965  }
966  }
967  mutex_unlock(&crypt_stat->cs_mutex);
968 
969  rc = inode_change_ok(inode, ia);
970  if (rc)
971  goto out;
972  if (ia->ia_valid & ATTR_SIZE) {
973  rc = ecryptfs_inode_newsize_ok(inode, ia->ia_size);
974  if (rc)
975  goto out;
976  }
977 
978  memcpy(&lower_ia, ia, sizeof(lower_ia));
979  if (ia->ia_valid & ATTR_FILE)
980  lower_ia.ia_file = ecryptfs_file_to_lower(ia->ia_file);
981  if (ia->ia_valid & ATTR_SIZE) {
982  rc = truncate_upper(dentry, ia, &lower_ia);
983  if (rc < 0)
984  goto out;
985  }
986 
987  /*
988  * mode change is for clearing setuid/setgid bits. Allow lower fs
989  * to interpret this in its own way.
990  */
991  if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
992  lower_ia.ia_valid &= ~ATTR_MODE;
993 
994  mutex_lock(&lower_dentry->d_inode->i_mutex);
995  rc = notify_change(lower_dentry, &lower_ia);
996  mutex_unlock(&lower_dentry->d_inode->i_mutex);
997 out:
998  fsstack_copy_attr_all(inode, lower_inode);
999  return rc;
1000 }
1001 
1002 int ecryptfs_getattr_link(struct vfsmount *mnt, struct dentry *dentry,
1003  struct kstat *stat)
1004 {
1005  struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
1006  int rc = 0;
1007 
1008  mount_crypt_stat = &ecryptfs_superblock_to_private(
1009  dentry->d_sb)->mount_crypt_stat;
1010  generic_fillattr(dentry->d_inode, stat);
1011  if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
1012  char *target;
1013  size_t targetsiz;
1014 
1015  rc = ecryptfs_readlink_lower(dentry, &target, &targetsiz);
1016  if (!rc) {
1017  kfree(target);
1018  stat->size = targetsiz;
1019  }
1020  }
1021  return rc;
1022 }
1023 
1024 int ecryptfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1025  struct kstat *stat)
1026 {
1027  struct kstat lower_stat;
1028  int rc;
1029 
1030  rc = vfs_getattr(ecryptfs_dentry_to_lower_mnt(dentry),
1031  ecryptfs_dentry_to_lower(dentry), &lower_stat);
1032  if (!rc) {
1033  fsstack_copy_attr_all(dentry->d_inode,
1034  ecryptfs_inode_to_lower(dentry->d_inode));
1035  generic_fillattr(dentry->d_inode, stat);
1036  stat->blocks = lower_stat.blocks;
1037  }
1038  return rc;
1039 }
1040 
1041 int
1042 ecryptfs_setxattr(struct dentry *dentry, const char *name, const void *value,
1043  size_t size, int flags)
1044 {
1045  int rc = 0;
1046  struct dentry *lower_dentry;
1047 
1048  lower_dentry = ecryptfs_dentry_to_lower(dentry);
1049  if (!lower_dentry->d_inode->i_op->setxattr) {
1050  rc = -EOPNOTSUPP;
1051  goto out;
1052  }
1053 
1054  rc = vfs_setxattr(lower_dentry, name, value, size, flags);
1055  if (!rc)
1056  fsstack_copy_attr_all(dentry->d_inode, lower_dentry->d_inode);
1057 out:
1058  return rc;
1059 }
1060 
1061 ssize_t
1062 ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name,
1063  void *value, size_t size)
1064 {
1065  int rc = 0;
1066 
1067  if (!lower_dentry->d_inode->i_op->getxattr) {
1068  rc = -EOPNOTSUPP;
1069  goto out;
1070  }
1071  mutex_lock(&lower_dentry->d_inode->i_mutex);
1072  rc = lower_dentry->d_inode->i_op->getxattr(lower_dentry, name, value,
1073  size);
1074  mutex_unlock(&lower_dentry->d_inode->i_mutex);
1075 out:
1076  return rc;
1077 }
1078 
1079 static ssize_t
1080 ecryptfs_getxattr(struct dentry *dentry, const char *name, void *value,
1081  size_t size)
1082 {
1083  return ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry), name,
1084  value, size);
1085 }
1086 
1087 static ssize_t
1088 ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size)
1089 {
1090  int rc = 0;
1091  struct dentry *lower_dentry;
1092 
1093  lower_dentry = ecryptfs_dentry_to_lower(dentry);
1094  if (!lower_dentry->d_inode->i_op->listxattr) {
1095  rc = -EOPNOTSUPP;
1096  goto out;
1097  }
1098  mutex_lock(&lower_dentry->d_inode->i_mutex);
1099  rc = lower_dentry->d_inode->i_op->listxattr(lower_dentry, list, size);
1100  mutex_unlock(&lower_dentry->d_inode->i_mutex);
1101 out:
1102  return rc;
1103 }
1104 
1105 static int ecryptfs_removexattr(struct dentry *dentry, const char *name)
1106 {
1107  int rc = 0;
1108  struct dentry *lower_dentry;
1109 
1110  lower_dentry = ecryptfs_dentry_to_lower(dentry);
1111  if (!lower_dentry->d_inode->i_op->removexattr) {
1112  rc = -EOPNOTSUPP;
1113  goto out;
1114  }
1115  mutex_lock(&lower_dentry->d_inode->i_mutex);
1116  rc = lower_dentry->d_inode->i_op->removexattr(lower_dentry, name);
1117  mutex_unlock(&lower_dentry->d_inode->i_mutex);
1118 out:
1119  return rc;
1120 }
1121 
1122 const struct inode_operations ecryptfs_symlink_iops = {
1123  .readlink = generic_readlink,
1124  .follow_link = ecryptfs_follow_link,
1125  .put_link = ecryptfs_put_link,
1126  .permission = ecryptfs_permission,
1127  .setattr = ecryptfs_setattr,
1128  .getattr = ecryptfs_getattr_link,
1129  .setxattr = ecryptfs_setxattr,
1130  .getxattr = ecryptfs_getxattr,
1131  .listxattr = ecryptfs_listxattr,
1132  .removexattr = ecryptfs_removexattr
1133 };
1134 
1135 const struct inode_operations ecryptfs_dir_iops = {
1136  .create = ecryptfs_create,
1137  .lookup = ecryptfs_lookup,
1138  .link = ecryptfs_link,
1139  .unlink = ecryptfs_unlink,
1140  .symlink = ecryptfs_symlink,
1141  .mkdir = ecryptfs_mkdir,
1142  .rmdir = ecryptfs_rmdir,
1143  .mknod = ecryptfs_mknod,
1144  .rename = ecryptfs_rename,
1145  .permission = ecryptfs_permission,
1146  .setattr = ecryptfs_setattr,
1147  .setxattr = ecryptfs_setxattr,
1148  .getxattr = ecryptfs_getxattr,
1149  .listxattr = ecryptfs_listxattr,
1150  .removexattr = ecryptfs_removexattr
1151 };
1152 
1153 const struct inode_operations ecryptfs_main_iops = {
1154  .permission = ecryptfs_permission,
1155  .setattr = ecryptfs_setattr,
1156  .getattr = ecryptfs_getattr,
1157  .setxattr = ecryptfs_setxattr,
1158  .getxattr = ecryptfs_getxattr,
1159  .listxattr = ecryptfs_listxattr,
1160  .removexattr = ecryptfs_removexattr
1161 };
Generated on Thu Jan 10 2013 13:15:06 for Linux Kernel by   doxygen 1.8.2