fs/ecryptfs/inode.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
lock_parent
unlock_dir
ecryptfs_inode_test
ecryptfs_inode_set
__ecryptfs_get_inode
ecryptfs_get_inode
ecryptfs_interpose
ecryptfs_do_unlink
ecryptfs_do_create
ecryptfs_initialize_file
ecryptfs_create
ecryptfs_i_size_read
ecryptfs_lookup_interpose
ecryptfs_lookup
ecryptfs_link
ecryptfs_unlink
ecryptfs_symlink
ecryptfs_mkdir
ecryptfs_rmdir
ecryptfs_mknod
ecryptfs_rename
ecryptfs_readlink_lower
ecryptfs_get_link
upper_size_to_lower_size
truncate_upper
ecryptfs_inode_newsize_ok
ecryptfs_truncate
ecryptfs_permission
ecryptfs_setattr
ecryptfs_getattr_link
ecryptfs_getattr
ecryptfs_setxattr
ecryptfs_getxattr_lower
ecryptfs_getxattr
ecryptfs_listxattr
ecryptfs_removexattr
ecryptfs_xattr_get
ecryptfs_xattr_set
   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /**
   3  * eCryptfs: Linux filesystem encryption layer
   4  *
   5  * Copyright (C) 1997-2004 Erez Zadok
   6  * Copyright (C) 2001-2004 Stony Brook University
   7  * Copyright (C) 2004-2007 International Business Machines Corp.
   8  *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
   9  *              Michael C. Thompsion <mcthomps@us.ibm.com>
  10  */
  11 
  12 #include <linux/file.h>
  13 #include <linux/vmalloc.h>
  14 #include <linux/pagemap.h>
  15 #include <linux/dcache.h>
  16 #include <linux/namei.h>
  17 #include <linux/mount.h>
  18 #include <linux/fs_stack.h>
  19 #include <linux/slab.h>
  20 #include <linux/xattr.h>
  21 #include <asm/unaligned.h>
  22 #include "ecryptfs_kernel.h"
  23 
  24 static struct dentry *lock_parent(struct dentry *dentry)
  25 {
  26         struct dentry *dir;
  27 
  28         dir = dget_parent(dentry);
  29         inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
  30         return dir;
  31 }
  32 
  33 static void unlock_dir(struct dentry *dir)
  34 {
  35         inode_unlock(d_inode(dir));
  36         dput(dir);
  37 }
  38 
  39 static int ecryptfs_inode_test(struct inode *inode, void *lower_inode)
  40 {
  41         return ecryptfs_inode_to_lower(inode) == lower_inode;
  42 }
  43 
  44 static int ecryptfs_inode_set(struct inode *inode, void *opaque)
  45 {
  46         struct inode *lower_inode = opaque;
  47 
  48         ecryptfs_set_inode_lower(inode, lower_inode);
  49         fsstack_copy_attr_all(inode, lower_inode);
  50         /* i_size will be overwritten for encrypted regular files */
  51         fsstack_copy_inode_size(inode, lower_inode);
  52         inode->i_ino = lower_inode->i_ino;
  53         inode->i_mapping->a_ops = &ecryptfs_aops;
  54 
  55         if (S_ISLNK(inode->i_mode))
  56                 inode->i_op = &ecryptfs_symlink_iops;
  57         else if (S_ISDIR(inode->i_mode))
  58                 inode->i_op = &ecryptfs_dir_iops;
  59         else
  60                 inode->i_op = &ecryptfs_main_iops;
  61 
  62         if (S_ISDIR(inode->i_mode))
  63                 inode->i_fop = &ecryptfs_dir_fops;
  64         else if (special_file(inode->i_mode))
  65                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
  66         else
  67                 inode->i_fop = &ecryptfs_main_fops;
  68 
  69         return 0;
  70 }
  71 
  72 static struct inode *__ecryptfs_get_inode(struct inode *lower_inode,
  73                                           struct super_block *sb)
  74 {
  75         struct inode *inode;
  76 
  77         if (lower_inode->i_sb != ecryptfs_superblock_to_lower(sb))
  78                 return ERR_PTR(-EXDEV);
  79         if (!igrab(lower_inode))
  80                 return ERR_PTR(-ESTALE);
  81         inode = iget5_locked(sb, (unsigned long)lower_inode,
  82                              ecryptfs_inode_test, ecryptfs_inode_set,
  83                              lower_inode);
  84         if (!inode) {
  85                 iput(lower_inode);
  86                 return ERR_PTR(-EACCES);
  87         }
  88         if (!(inode->i_state & I_NEW))
  89                 iput(lower_inode);
  90 
  91         return inode;
  92 }
  93 
  94 struct inode *ecryptfs_get_inode(struct inode *lower_inode,
  95                                  struct super_block *sb)
  96 {
  97         struct inode *inode = __ecryptfs_get_inode(lower_inode, sb);
  98 
  99         if (!IS_ERR(inode) && (inode->i_state & I_NEW))
 100                 unlock_new_inode(inode);
 101 
 102         return inode;
 103 }
 104 
 105 /**
 106  * ecryptfs_interpose
 107  * @lower_dentry: Existing dentry in the lower filesystem
 108  * @dentry: ecryptfs' dentry
 109  * @sb: ecryptfs's super_block
 110  *
 111  * Interposes upper and lower dentries.
 112  *
 113  * Returns zero on success; non-zero otherwise
 114  */
 115 static int ecryptfs_interpose(struct dentry *lower_dentry,
 116                               struct dentry *dentry, struct super_block *sb)
 117 {
 118         struct inode *inode = ecryptfs_get_inode(d_inode(lower_dentry), sb);
 119 
 120         if (IS_ERR(inode))
 121                 return PTR_ERR(inode);
 122         d_instantiate(dentry, inode);
 123 
 124         return 0;
 125 }
 126 
 127 static int ecryptfs_do_unlink(struct inode *dir, struct dentry *dentry,
 128                               struct inode *inode)
 129 {
 130         struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
 131         struct dentry *lower_dir_dentry;
 132         struct inode *lower_dir_inode;
 133         int rc;
 134 
 135         lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent);
 136         lower_dir_inode = d_inode(lower_dir_dentry);
 137         inode_lock_nested(lower_dir_inode, I_MUTEX_PARENT);
 138         dget(lower_dentry);     // don't even try to make the lower negative
 139         if (lower_dentry->d_parent != lower_dir_dentry)
 140                 rc = -EINVAL;
 141         else if (d_unhashed(lower_dentry))
 142                 rc = -EINVAL;
 143         else
 144                 rc = vfs_unlink(lower_dir_inode, lower_dentry, NULL);
 145         if (rc) {
 146                 printk(KERN_ERR "Error in vfs_unlink; rc = [%d]\n", rc);
 147                 goto out_unlock;
 148         }
 149         fsstack_copy_attr_times(dir, lower_dir_inode);
 150         set_nlink(inode, ecryptfs_inode_to_lower(inode)->i_nlink);
 151         inode->i_ctime = dir->i_ctime;
 152 out_unlock:
 153         dput(lower_dentry);
 154         inode_unlock(lower_dir_inode);
 155         if (!rc)
 156                 d_drop(dentry);
 157         return rc;
 158 }
 159 
 160 /**
 161  * ecryptfs_do_create
 162  * @directory_inode: inode of the new file's dentry's parent in ecryptfs
 163  * @ecryptfs_dentry: New file's dentry in ecryptfs
 164  * @mode: The mode of the new file
 165  *
 166  * Creates the underlying file and the eCryptfs inode which will link to
 167  * it. It will also update the eCryptfs directory inode to mimic the
 168  * stat of the lower directory inode.
 169  *
 170  * Returns the new eCryptfs inode on success; an ERR_PTR on error condition
 171  */
 172 static struct inode *
 173 ecryptfs_do_create(struct inode *directory_inode,
 174                    struct dentry *ecryptfs_dentry, umode_t mode)
 175 {
 176         int rc;
 177         struct dentry *lower_dentry;
 178         struct dentry *lower_dir_dentry;
 179         struct inode *inode;
 180 
 181         lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
 182         lower_dir_dentry = lock_parent(lower_dentry);
 183         rc = vfs_create(d_inode(lower_dir_dentry), lower_dentry, mode, true);
 184         if (rc) {
 185                 printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
 186                        "rc = [%d]\n", __func__, rc);
 187                 inode = ERR_PTR(rc);
 188                 goto out_lock;
 189         }
 190         inode = __ecryptfs_get_inode(d_inode(lower_dentry),
 191                                      directory_inode->i_sb);
 192         if (IS_ERR(inode)) {
 193                 vfs_unlink(d_inode(lower_dir_dentry), lower_dentry, NULL);
 194                 goto out_lock;
 195         }
 196         fsstack_copy_attr_times(directory_inode, d_inode(lower_dir_dentry));
 197         fsstack_copy_inode_size(directory_inode, d_inode(lower_dir_dentry));
 198 out_lock:
 199         unlock_dir(lower_dir_dentry);
 200         return inode;
 201 }
 202 
 203 /**
 204  * ecryptfs_initialize_file
 205  *
 206  * Cause the file to be changed from a basic empty file to an ecryptfs
 207  * file with a header and first data page.
 208  *
 209  * Returns zero on success
 210  */
 211 int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry,
 212                              struct inode *ecryptfs_inode)
 213 {
 214         struct ecryptfs_crypt_stat *crypt_stat =
 215                 &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
 216         int rc = 0;
 217 
 218         if (S_ISDIR(ecryptfs_inode->i_mode)) {
 219                 ecryptfs_printk(KERN_DEBUG, "This is a directory\n");
 220                 crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
 221                 goto out;
 222         }
 223         ecryptfs_printk(KERN_DEBUG, "Initializing crypto context\n");
 224         rc = ecryptfs_new_file_context(ecryptfs_inode);
 225         if (rc) {
 226                 ecryptfs_printk(KERN_ERR, "Error creating new file "
 227                                 "context; rc = [%d]\n", rc);
 228                 goto out;
 229         }
 230         rc = ecryptfs_get_lower_file(ecryptfs_dentry, ecryptfs_inode);
 231         if (rc) {
 232                 printk(KERN_ERR "%s: Error attempting to initialize "
 233                         "the lower file for the dentry with name "
 234                         "[%pd]; rc = [%d]\n", __func__,
 235                         ecryptfs_dentry, rc);
 236                 goto out;
 237         }
 238         rc = ecryptfs_write_metadata(ecryptfs_dentry, ecryptfs_inode);
 239         if (rc)
 240                 printk(KERN_ERR "Error writing headers; rc = [%d]\n", rc);
 241         ecryptfs_put_lower_file(ecryptfs_inode);
 242 out:
 243         return rc;
 244 }
 245 
 246 /**
 247  * ecryptfs_create
 248  * @dir: The inode of the directory in which to create the file.
 249  * @dentry: The eCryptfs dentry
 250  * @mode: The mode of the new file.
 251  *
 252  * Creates a new file.
 253  *
 254  * Returns zero on success; non-zero on error condition
 255  */
 256 static int
 257 ecryptfs_create(struct inode *directory_inode, struct dentry *ecryptfs_dentry,
 258                 umode_t mode, bool excl)
 259 {
 260         struct inode *ecryptfs_inode;
 261         int rc;
 262 
 263         ecryptfs_inode = ecryptfs_do_create(directory_inode, ecryptfs_dentry,
 264                                             mode);
 265         if (IS_ERR(ecryptfs_inode)) {
 266                 ecryptfs_printk(KERN_WARNING, "Failed to create file in"
 267                                 "lower filesystem\n");
 268                 rc = PTR_ERR(ecryptfs_inode);
 269                 goto out;
 270         }
 271         /* At this point, a file exists on "disk"; we need to make sure
 272          * that this on disk file is prepared to be an ecryptfs file */
 273         rc = ecryptfs_initialize_file(ecryptfs_dentry, ecryptfs_inode);
 274         if (rc) {
 275                 ecryptfs_do_unlink(directory_inode, ecryptfs_dentry,
 276                                    ecryptfs_inode);
 277                 iget_failed(ecryptfs_inode);
 278                 goto out;
 279         }
 280         d_instantiate_new(ecryptfs_dentry, ecryptfs_inode);
 281 out:
 282         return rc;
 283 }
 284 
 285 static int ecryptfs_i_size_read(struct dentry *dentry, struct inode *inode)
 286 {
 287         struct ecryptfs_crypt_stat *crypt_stat;
 288         int rc;
 289 
 290         rc = ecryptfs_get_lower_file(dentry, inode);
 291         if (rc) {
 292                 printk(KERN_ERR "%s: Error attempting to initialize "
 293                         "the lower file for the dentry with name "
 294                         "[%pd]; rc = [%d]\n", __func__,
 295                         dentry, rc);
 296                 return rc;
 297         }
 298 
 299         crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
 300         /* TODO: lock for crypt_stat comparison */
 301         if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED))
 302                 ecryptfs_set_default_sizes(crypt_stat);
 303 
 304         rc = ecryptfs_read_and_validate_header_region(inode);
 305         ecryptfs_put_lower_file(inode);
 306         if (rc) {
 307                 rc = ecryptfs_read_and_validate_xattr_region(dentry, inode);
 308                 if (!rc)
 309                         crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;
 310         }
 311 
 312         /* Must return 0 to allow non-eCryptfs files to be looked up, too */
 313         return 0;
 314 }
 315 
 316 /**
 317  * ecryptfs_lookup_interpose - Dentry interposition for a lookup
 318  */
 319 static struct dentry *ecryptfs_lookup_interpose(struct dentry *dentry,
 320                                      struct dentry *lower_dentry)
 321 {
 322         struct path *path = ecryptfs_dentry_to_lower_path(dentry->d_parent);
 323         struct inode *inode, *lower_inode;
 324         struct ecryptfs_dentry_info *dentry_info;
 325         int rc = 0;
 326 
 327         dentry_info = kmem_cache_alloc(ecryptfs_dentry_info_cache, GFP_KERNEL);
 328         if (!dentry_info) {
 329                 dput(lower_dentry);
 330                 return ERR_PTR(-ENOMEM);
 331         }
 332 
 333         fsstack_copy_attr_atime(d_inode(dentry->d_parent),
 334                                 d_inode(path->dentry));
 335         BUG_ON(!d_count(lower_dentry));
 336 
 337         ecryptfs_set_dentry_private(dentry, dentry_info);
 338         dentry_info->lower_path.mnt = mntget(path->mnt);
 339         dentry_info->lower_path.dentry = lower_dentry;
 340 
 341         /*
 342          * negative dentry can go positive under us here - its parent is not
 343          * locked.  That's OK and that could happen just as we return from
 344          * ecryptfs_lookup() anyway.  Just need to be careful and fetch
 345          * ->d_inode only once - it's not stable here.
 346          */
 347         lower_inode = READ_ONCE(lower_dentry->d_inode);
 348 
 349         if (!lower_inode) {
 350                 /* We want to add because we couldn't find in lower */
 351                 d_add(dentry, NULL);
 352                 return NULL;
 353         }
 354         inode = __ecryptfs_get_inode(lower_inode, dentry->d_sb);
 355         if (IS_ERR(inode)) {
 356                 printk(KERN_ERR "%s: Error interposing; rc = [%ld]\n",
 357                        __func__, PTR_ERR(inode));
 358                 return ERR_CAST(inode);
 359         }
 360         if (S_ISREG(inode->i_mode)) {
 361                 rc = ecryptfs_i_size_read(dentry, inode);
 362                 if (rc) {
 363                         make_bad_inode(inode);
 364                         return ERR_PTR(rc);
 365                 }
 366         }
 367 
 368         if (inode->i_state & I_NEW)
 369                 unlock_new_inode(inode);
 370         return d_splice_alias(inode, dentry);
 371 }
 372 
 373 /**
 374  * ecryptfs_lookup
 375  * @ecryptfs_dir_inode: The eCryptfs directory inode
 376  * @ecryptfs_dentry: The eCryptfs dentry that we are looking up
 377  * @flags: lookup flags
 378  *
 379  * Find a file on disk. If the file does not exist, then we'll add it to the
 380  * dentry cache and continue on to read it from the disk.
 381  */
 382 static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
 383                                       struct dentry *ecryptfs_dentry,
 384                                       unsigned int flags)
 385 {
 386         char *encrypted_and_encoded_name = NULL;
 387         struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
 388         struct dentry *lower_dir_dentry, *lower_dentry;
 389         const char *name = ecryptfs_dentry->d_name.name;
 390         size_t len = ecryptfs_dentry->d_name.len;
 391         struct dentry *res;
 392         int rc = 0;
 393 
 394         lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent);
 395 
 396         mount_crypt_stat = &ecryptfs_superblock_to_private(
 397                                 ecryptfs_dentry->d_sb)->mount_crypt_stat;
 398         if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
 399                 rc = ecryptfs_encrypt_and_encode_filename(
 400                         &encrypted_and_encoded_name, &len,
 401                         mount_crypt_stat, name, len);
 402                 if (rc) {
 403                         printk(KERN_ERR "%s: Error attempting to encrypt and encode "
 404                                "filename; rc = [%d]\n", __func__, rc);
 405                         return ERR_PTR(rc);
 406                 }
 407                 name = encrypted_and_encoded_name;
 408         }
 409 
 410         lower_dentry = lookup_one_len_unlocked(name, lower_dir_dentry, len);
 411         if (IS_ERR(lower_dentry)) {
 412                 ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
 413                                 "[%ld] on lower_dentry = [%s]\n", __func__,
 414                                 PTR_ERR(lower_dentry),
 415                                 name);
 416                 res = ERR_CAST(lower_dentry);
 417         } else {
 418                 res = ecryptfs_lookup_interpose(ecryptfs_dentry, lower_dentry);
 419         }
 420         kfree(encrypted_and_encoded_name);
 421         return res;
 422 }
 423 
 424 static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,
 425                          struct dentry *new_dentry)
 426 {
 427         struct dentry *lower_old_dentry;
 428         struct dentry *lower_new_dentry;
 429         struct dentry *lower_dir_dentry;
 430         u64 file_size_save;
 431         int rc;
 432 
 433         file_size_save = i_size_read(d_inode(old_dentry));
 434         lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
 435         lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
 436         dget(lower_old_dentry);
 437         dget(lower_new_dentry);
 438         lower_dir_dentry = lock_parent(lower_new_dentry);
 439         rc = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry),
 440                       lower_new_dentry, NULL);
 441         if (rc || d_really_is_negative(lower_new_dentry))
 442                 goto out_lock;
 443         rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb);
 444         if (rc)
 445                 goto out_lock;
 446         fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
 447         fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 448         set_nlink(d_inode(old_dentry),
 449                   ecryptfs_inode_to_lower(d_inode(old_dentry))->i_nlink);
 450         i_size_write(d_inode(new_dentry), file_size_save);
 451 out_lock:
 452         unlock_dir(lower_dir_dentry);
 453         dput(lower_new_dentry);
 454         dput(lower_old_dentry);
 455         return rc;
 456 }
 457 
 458 static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
 459 {
 460         return ecryptfs_do_unlink(dir, dentry, d_inode(dentry));
 461 }
 462 
 463 static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,
 464                             const char *symname)
 465 {
 466         int rc;
 467         struct dentry *lower_dentry;
 468         struct dentry *lower_dir_dentry;
 469         char *encoded_symname;
 470         size_t encoded_symlen;
 471         struct ecryptfs_mount_crypt_stat *mount_crypt_stat = NULL;
 472 
 473         lower_dentry = ecryptfs_dentry_to_lower(dentry);
 474         dget(lower_dentry);
 475         lower_dir_dentry = lock_parent(lower_dentry);
 476         mount_crypt_stat = &ecryptfs_superblock_to_private(
 477                 dir->i_sb)->mount_crypt_stat;
 478         rc = ecryptfs_encrypt_and_encode_filename(&encoded_symname,
 479                                                   &encoded_symlen,
 480                                                   mount_crypt_stat, symname,
 481                                                   strlen(symname));
 482         if (rc)
 483                 goto out_lock;
 484         rc = vfs_symlink(d_inode(lower_dir_dentry), lower_dentry,
 485                          encoded_symname);
 486         kfree(encoded_symname);
 487         if (rc || d_really_is_negative(lower_dentry))
 488                 goto out_lock;
 489         rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
 490         if (rc)
 491                 goto out_lock;
 492         fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
 493         fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 494 out_lock:
 495         unlock_dir(lower_dir_dentry);
 496         dput(lower_dentry);
 497         if (d_really_is_negative(dentry))
 498                 d_drop(dentry);
 499         return rc;
 500 }
 501 
 502 static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 503 {
 504         int rc;
 505         struct dentry *lower_dentry;
 506         struct dentry *lower_dir_dentry;
 507 
 508         lower_dentry = ecryptfs_dentry_to_lower(dentry);
 509         lower_dir_dentry = lock_parent(lower_dentry);
 510         rc = vfs_mkdir(d_inode(lower_dir_dentry), lower_dentry, mode);
 511         if (rc || d_really_is_negative(lower_dentry))
 512                 goto out;
 513         rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
 514         if (rc)
 515                 goto out;
 516         fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
 517         fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 518         set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
 519 out:
 520         unlock_dir(lower_dir_dentry);
 521         if (d_really_is_negative(dentry))
 522                 d_drop(dentry);
 523         return rc;
 524 }
 525 
 526 static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
 527 {
 528         struct dentry *lower_dentry;
 529         struct dentry *lower_dir_dentry;
 530         struct inode *lower_dir_inode;
 531         int rc;
 532 
 533         lower_dentry = ecryptfs_dentry_to_lower(dentry);
 534         lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent);
 535         lower_dir_inode = d_inode(lower_dir_dentry);
 536 
 537         inode_lock_nested(lower_dir_inode, I_MUTEX_PARENT);
 538         dget(lower_dentry);     // don't even try to make the lower negative
 539         if (lower_dentry->d_parent != lower_dir_dentry)
 540                 rc = -EINVAL;
 541         else if (d_unhashed(lower_dentry))
 542                 rc = -EINVAL;
 543         else
 544                 rc = vfs_rmdir(lower_dir_inode, lower_dentry);
 545         if (!rc) {
 546                 clear_nlink(d_inode(dentry));
 547                 fsstack_copy_attr_times(dir, lower_dir_inode);
 548                 set_nlink(dir, lower_dir_inode->i_nlink);
 549         }
 550         dput(lower_dentry);
 551         inode_unlock(lower_dir_inode);
 552         if (!rc)
 553                 d_drop(dentry);
 554         return rc;
 555 }
 556 
 557 static int
 558 ecryptfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
 559 {
 560         int rc;
 561         struct dentry *lower_dentry;
 562         struct dentry *lower_dir_dentry;
 563 
 564         lower_dentry = ecryptfs_dentry_to_lower(dentry);
 565         lower_dir_dentry = lock_parent(lower_dentry);
 566         rc = vfs_mknod(d_inode(lower_dir_dentry), lower_dentry, mode, dev);
 567         if (rc || d_really_is_negative(lower_dentry))
 568                 goto out;
 569         rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
 570         if (rc)
 571                 goto out;
 572         fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
 573         fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
 574 out:
 575         unlock_dir(lower_dir_dentry);
 576         if (d_really_is_negative(dentry))
 577                 d_drop(dentry);
 578         return rc;
 579 }
 580 
 581 static int
 582 ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 583                 struct inode *new_dir, struct dentry *new_dentry,
 584                 unsigned int flags)
 585 {
 586         int rc;
 587         struct dentry *lower_old_dentry;
 588         struct dentry *lower_new_dentry;
 589         struct dentry *lower_old_dir_dentry;
 590         struct dentry *lower_new_dir_dentry;
 591         struct dentry *trap;
 592         struct inode *target_inode;
 593 
 594         if (flags)
 595                 return -EINVAL;
 596 
 597         lower_old_dir_dentry = ecryptfs_dentry_to_lower(old_dentry->d_parent);
 598         lower_new_dir_dentry = ecryptfs_dentry_to_lower(new_dentry->d_parent);
 599 
 600         lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
 601         lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
 602 
 603         target_inode = d_inode(new_dentry);
 604 
 605         trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
 606         dget(lower_new_dentry);
 607         rc = -EINVAL;
 608         if (lower_old_dentry->d_parent != lower_old_dir_dentry)
 609                 goto out_lock;
 610         if (lower_new_dentry->d_parent != lower_new_dir_dentry)
 611                 goto out_lock;
 612         if (d_unhashed(lower_old_dentry) || d_unhashed(lower_new_dentry))
 613                 goto out_lock;
 614         /* source should not be ancestor of target */
 615         if (trap == lower_old_dentry)
 616                 goto out_lock;
 617         /* target should not be ancestor of source */
 618         if (trap == lower_new_dentry) {
 619                 rc = -ENOTEMPTY;
 620                 goto out_lock;
 621         }
 622         rc = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry,
 623                         d_inode(lower_new_dir_dentry), lower_new_dentry,
 624                         NULL, 0);
 625         if (rc)
 626                 goto out_lock;
 627         if (target_inode)
 628                 fsstack_copy_attr_all(target_inode,
 629                                       ecryptfs_inode_to_lower(target_inode));
 630         fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));
 631         if (new_dir != old_dir)
 632                 fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));
 633 out_lock:
 634         dput(lower_new_dentry);
 635         unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
 636         return rc;
 637 }
 638 
 639 static char *ecryptfs_readlink_lower(struct dentry *dentry, size_t *bufsiz)
 640 {
 641         DEFINE_DELAYED_CALL(done);
 642         struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
 643         const char *link;
 644         char *buf;
 645         int rc;
 646 
 647         link = vfs_get_link(lower_dentry, &done);
 648         if (IS_ERR(link))
 649                 return ERR_CAST(link);
 650 
 651         rc = ecryptfs_decode_and_decrypt_filename(&buf, bufsiz, dentry->d_sb,
 652                                                   link, strlen(link));
 653         do_delayed_call(&done);
 654         if (rc)
 655                 return ERR_PTR(rc);
 656 
 657         return buf;
 658 }
 659 
 660 static const char *ecryptfs_get_link(struct dentry *dentry,
 661                                      struct inode *inode,
 662                                      struct delayed_call *done)
 663 {
 664         size_t len;
 665         char *buf;
 666 
 667         if (!dentry)
 668                 return ERR_PTR(-ECHILD);
 669 
 670         buf = ecryptfs_readlink_lower(dentry, &len);
 671         if (IS_ERR(buf))
 672                 return buf;
 673         fsstack_copy_attr_atime(d_inode(dentry),
 674                                 d_inode(ecryptfs_dentry_to_lower(dentry)));
 675         buf[len] = '\0';
 676         set_delayed_call(done, kfree_link, buf);
 677         return buf;
 678 }
 679 
 680 /**
 681  * upper_size_to_lower_size
 682  * @crypt_stat: Crypt_stat associated with file
 683  * @upper_size: Size of the upper file
 684  *
 685  * Calculate the required size of the lower file based on the
 686  * specified size of the upper file. This calculation is based on the
 687  * number of headers in the underlying file and the extent size.
 688  *
 689  * Returns Calculated size of the lower file.
 690  */
 691 static loff_t
 692 upper_size_to_lower_size(struct ecryptfs_crypt_stat *crypt_stat,
 693                          loff_t upper_size)
 694 {
 695         loff_t lower_size;
 696 
 697         lower_size = ecryptfs_lower_header_size(crypt_stat);
 698         if (upper_size != 0) {
 699                 loff_t num_extents;
 700 
 701                 num_extents = upper_size >> crypt_stat->extent_shift;
 702                 if (upper_size & ~crypt_stat->extent_mask)
 703                         num_extents++;
 704                 lower_size += (num_extents * crypt_stat->extent_size);
 705         }
 706         return lower_size;
 707 }
 708 
 709 /**
 710  * truncate_upper
 711  * @dentry: The ecryptfs layer dentry
 712  * @ia: Address of the ecryptfs inode's attributes
 713  * @lower_ia: Address of the lower inode's attributes
 714  *
 715  * Function to handle truncations modifying the size of the file. Note
 716  * that the file sizes are interpolated. When expanding, we are simply
 717  * writing strings of 0's out. When truncating, we truncate the upper
 718  * inode and update the lower_ia according to the page index
 719  * interpolations. If ATTR_SIZE is set in lower_ia->ia_valid upon return,
 720  * the caller must use lower_ia in a call to notify_change() to perform
 721  * the truncation of the lower inode.
 722  *
 723  * Returns zero on success; non-zero otherwise
 724  */
 725 static int truncate_upper(struct dentry *dentry, struct iattr *ia,
 726                           struct iattr *lower_ia)
 727 {
 728         int rc = 0;
 729         struct inode *inode = d_inode(dentry);
 730         struct ecryptfs_crypt_stat *crypt_stat;
 731         loff_t i_size = i_size_read(inode);
 732         loff_t lower_size_before_truncate;
 733         loff_t lower_size_after_truncate;
 734 
 735         if (unlikely((ia->ia_size == i_size))) {
 736                 lower_ia->ia_valid &= ~ATTR_SIZE;
 737                 return 0;
 738         }
 739         rc = ecryptfs_get_lower_file(dentry, inode);
 740         if (rc)
 741                 return rc;
 742         crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
 743         /* Switch on growing or shrinking file */
 744         if (ia->ia_size > i_size) {
 745                 char zero[] = { 0x00 };
 746 
 747                 lower_ia->ia_valid &= ~ATTR_SIZE;
 748                 /* Write a single 0 at the last position of the file;
 749                  * this triggers code that will fill in 0's throughout
 750                  * the intermediate portion of the previous end of the
 751                  * file and the new and of the file */
 752                 rc = ecryptfs_write(inode, zero,
 753                                     (ia->ia_size - 1), 1);
 754         } else { /* ia->ia_size < i_size_read(inode) */
 755                 /* We're chopping off all the pages down to the page
 756                  * in which ia->ia_size is located. Fill in the end of
 757                  * that page from (ia->ia_size & ~PAGE_MASK) to
 758                  * PAGE_SIZE with zeros. */
 759                 size_t num_zeros = (PAGE_SIZE
 760                                     - (ia->ia_size & ~PAGE_MASK));
 761 
 762                 if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
 763                         truncate_setsize(inode, ia->ia_size);
 764                         lower_ia->ia_size = ia->ia_size;
 765                         lower_ia->ia_valid |= ATTR_SIZE;
 766                         goto out;
 767                 }
 768                 if (num_zeros) {
 769                         char *zeros_virt;
 770 
 771                         zeros_virt = kzalloc(num_zeros, GFP_KERNEL);
 772                         if (!zeros_virt) {
 773                                 rc = -ENOMEM;
 774                                 goto out;
 775                         }
 776                         rc = ecryptfs_write(inode, zeros_virt,
 777                                             ia->ia_size, num_zeros);
 778                         kfree(zeros_virt);
 779                         if (rc) {
 780                                 printk(KERN_ERR "Error attempting to zero out "
 781                                        "the remainder of the end page on "
 782                                        "reducing truncate; rc = [%d]\n", rc);
 783                                 goto out;
 784                         }
 785                 }
 786                 truncate_setsize(inode, ia->ia_size);
 787                 rc = ecryptfs_write_inode_size_to_metadata(inode);
 788                 if (rc) {
 789                         printk(KERN_ERR "Problem with "
 790                                "ecryptfs_write_inode_size_to_metadata; "
 791                                "rc = [%d]\n", rc);
 792                         goto out;
 793                 }
 794                 /* We are reducing the size of the ecryptfs file, and need to
 795                  * know if we need to reduce the size of the lower file. */
 796                 lower_size_before_truncate =
 797                     upper_size_to_lower_size(crypt_stat, i_size);
 798                 lower_size_after_truncate =
 799                     upper_size_to_lower_size(crypt_stat, ia->ia_size);
 800                 if (lower_size_after_truncate < lower_size_before_truncate) {
 801                         lower_ia->ia_size = lower_size_after_truncate;
 802                         lower_ia->ia_valid |= ATTR_SIZE;
 803                 } else
 804                         lower_ia->ia_valid &= ~ATTR_SIZE;
 805         }
 806 out:
 807         ecryptfs_put_lower_file(inode);
 808         return rc;
 809 }
 810 
 811 static int ecryptfs_inode_newsize_ok(struct inode *inode, loff_t offset)
 812 {
 813         struct ecryptfs_crypt_stat *crypt_stat;
 814         loff_t lower_oldsize, lower_newsize;
 815 
 816         crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
 817         lower_oldsize = upper_size_to_lower_size(crypt_stat,
 818                                                  i_size_read(inode));
 819         lower_newsize = upper_size_to_lower_size(crypt_stat, offset);
 820         if (lower_newsize > lower_oldsize) {
 821                 /*
 822                  * The eCryptfs inode and the new *lower* size are mixed here
 823                  * because we may not have the lower i_mutex held and/or it may
 824                  * not be appropriate to call inode_newsize_ok() with inodes
 825                  * from other filesystems.
 826                  */
 827                 return inode_newsize_ok(inode, lower_newsize);
 828         }
 829 
 830         return 0;
 831 }
 832 
 833 /**
 834  * ecryptfs_truncate
 835  * @dentry: The ecryptfs layer dentry
 836  * @new_length: The length to expand the file to
 837  *
 838  * Simple function that handles the truncation of an eCryptfs inode and
 839  * its corresponding lower inode.
 840  *
 841  * Returns zero on success; non-zero otherwise
 842  */
 843 int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
 844 {
 845         struct iattr ia = { .ia_valid = ATTR_SIZE, .ia_size = new_length };
 846         struct iattr lower_ia = { .ia_valid = 0 };
 847         int rc;
 848 
 849         rc = ecryptfs_inode_newsize_ok(d_inode(dentry), new_length);
 850         if (rc)
 851                 return rc;
 852 
 853         rc = truncate_upper(dentry, &ia, &lower_ia);
 854         if (!rc && lower_ia.ia_valid & ATTR_SIZE) {
 855                 struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
 856 
 857                 inode_lock(d_inode(lower_dentry));
 858                 rc = notify_change(lower_dentry, &lower_ia, NULL);
 859                 inode_unlock(d_inode(lower_dentry));
 860         }
 861         return rc;
 862 }
 863 
 864 static int
 865 ecryptfs_permission(struct inode *inode, int mask)
 866 {
 867         return inode_permission(ecryptfs_inode_to_lower(inode), mask);
 868 }
 869 
 870 /**
 871  * ecryptfs_setattr
 872  * @dentry: dentry handle to the inode to modify
 873  * @ia: Structure with flags of what to change and values
 874  *
 875  * Updates the metadata of an inode. If the update is to the size
 876  * i.e. truncation, then ecryptfs_truncate will handle the size modification
 877  * of both the ecryptfs inode and the lower inode.
 878  *
 879  * All other metadata changes will be passed right to the lower filesystem,
 880  * and we will just update our inode to look like the lower.
 881  */
 882 static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
 883 {
 884         int rc = 0;
 885         struct dentry *lower_dentry;
 886         struct iattr lower_ia;
 887         struct inode *inode;
 888         struct inode *lower_inode;
 889         struct ecryptfs_crypt_stat *crypt_stat;
 890 
 891         crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
 892         if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED)) {
 893                 rc = ecryptfs_init_crypt_stat(crypt_stat);
 894                 if (rc)
 895                         return rc;
 896         }
 897         inode = d_inode(dentry);
 898         lower_inode = ecryptfs_inode_to_lower(inode);
 899         lower_dentry = ecryptfs_dentry_to_lower(dentry);
 900         mutex_lock(&crypt_stat->cs_mutex);
 901         if (d_is_dir(dentry))
 902                 crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
 903         else if (d_is_reg(dentry)
 904                  && (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)
 905                      || !(crypt_stat->flags & ECRYPTFS_KEY_VALID))) {
 906                 struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
 907 
 908                 mount_crypt_stat = &ecryptfs_superblock_to_private(
 909                         dentry->d_sb)->mount_crypt_stat;
 910                 rc = ecryptfs_get_lower_file(dentry, inode);
 911                 if (rc) {
 912                         mutex_unlock(&crypt_stat->cs_mutex);
 913                         goto out;
 914                 }
 915                 rc = ecryptfs_read_metadata(dentry);
 916                 ecryptfs_put_lower_file(inode);
 917                 if (rc) {
 918                         if (!(mount_crypt_stat->flags
 919                               & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)) {
 920                                 rc = -EIO;
 921                                 printk(KERN_WARNING "Either the lower file "
 922                                        "is not in a valid eCryptfs format, "
 923                                        "or the key could not be retrieved. "
 924                                        "Plaintext passthrough mode is not "
 925                                        "enabled; returning -EIO\n");
 926                                 mutex_unlock(&crypt_stat->cs_mutex);
 927                                 goto out;
 928                         }
 929                         rc = 0;
 930                         crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
 931                                                | ECRYPTFS_ENCRYPTED);
 932                 }
 933         }
 934         mutex_unlock(&crypt_stat->cs_mutex);
 935 
 936         rc = setattr_prepare(dentry, ia);
 937         if (rc)
 938                 goto out;
 939         if (ia->ia_valid & ATTR_SIZE) {
 940                 rc = ecryptfs_inode_newsize_ok(inode, ia->ia_size);
 941                 if (rc)
 942                         goto out;
 943         }
 944 
 945         memcpy(&lower_ia, ia, sizeof(lower_ia));
 946         if (ia->ia_valid & ATTR_FILE)
 947                 lower_ia.ia_file = ecryptfs_file_to_lower(ia->ia_file);
 948         if (ia->ia_valid & ATTR_SIZE) {
 949                 rc = truncate_upper(dentry, ia, &lower_ia);
 950                 if (rc < 0)
 951                         goto out;
 952         }
 953 
 954         /*
 955          * mode change is for clearing setuid/setgid bits. Allow lower fs
 956          * to interpret this in its own way.
 957          */
 958         if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
 959                 lower_ia.ia_valid &= ~ATTR_MODE;
 960 
 961         inode_lock(d_inode(lower_dentry));
 962         rc = notify_change(lower_dentry, &lower_ia, NULL);
 963         inode_unlock(d_inode(lower_dentry));
 964 out:
 965         fsstack_copy_attr_all(inode, lower_inode);
 966         return rc;
 967 }
 968 
 969 static int ecryptfs_getattr_link(const struct path *path, struct kstat *stat,
 970                                  u32 request_mask, unsigned int flags)
 971 {
 972         struct dentry *dentry = path->dentry;
 973         struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
 974         int rc = 0;
 975 
 976         mount_crypt_stat = &ecryptfs_superblock_to_private(
 977                                                 dentry->d_sb)->mount_crypt_stat;
 978         generic_fillattr(d_inode(dentry), stat);
 979         if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
 980                 char *target;
 981                 size_t targetsiz;
 982 
 983                 target = ecryptfs_readlink_lower(dentry, &targetsiz);
 984                 if (!IS_ERR(target)) {
 985                         kfree(target);
 986                         stat->size = targetsiz;
 987                 } else {
 988                         rc = PTR_ERR(target);
 989                 }
 990         }
 991         return rc;
 992 }
 993 
 994 static int ecryptfs_getattr(const struct path *path, struct kstat *stat,
 995                             u32 request_mask, unsigned int flags)
 996 {
 997         struct dentry *dentry = path->dentry;
 998         struct kstat lower_stat;
 999         int rc;
1000 
1001         rc = vfs_getattr(ecryptfs_dentry_to_lower_path(dentry), &lower_stat,
1002                          request_mask, flags);
1003         if (!rc) {
1004                 fsstack_copy_attr_all(d_inode(dentry),
1005                                       ecryptfs_inode_to_lower(d_inode(dentry)));
1006                 generic_fillattr(d_inode(dentry), stat);
1007                 stat->blocks = lower_stat.blocks;
1008         }
1009         return rc;
1010 }
1011 
1012 int
1013 ecryptfs_setxattr(struct dentry *dentry, struct inode *inode,
1014                   const char *name, const void *value,
1015                   size_t size, int flags)
1016 {
1017         int rc;
1018         struct dentry *lower_dentry;
1019 
1020         lower_dentry = ecryptfs_dentry_to_lower(dentry);
1021         if (!(d_inode(lower_dentry)->i_opflags & IOP_XATTR)) {
1022                 rc = -EOPNOTSUPP;
1023                 goto out;
1024         }
1025         rc = vfs_setxattr(lower_dentry, name, value, size, flags);
1026         if (!rc && inode)
1027                 fsstack_copy_attr_all(inode, d_inode(lower_dentry));
1028 out:
1029         return rc;
1030 }
1031 
1032 ssize_t
1033 ecryptfs_getxattr_lower(struct dentry *lower_dentry, struct inode *lower_inode,
1034                         const char *name, void *value, size_t size)
1035 {
1036         int rc;
1037 
1038         if (!(lower_inode->i_opflags & IOP_XATTR)) {
1039                 rc = -EOPNOTSUPP;
1040                 goto out;
1041         }
1042         inode_lock(lower_inode);
1043         rc = __vfs_getxattr(lower_dentry, lower_inode, name, value, size);
1044         inode_unlock(lower_inode);
1045 out:
1046         return rc;
1047 }
1048 
1049 static ssize_t
1050 ecryptfs_getxattr(struct dentry *dentry, struct inode *inode,
1051                   const char *name, void *value, size_t size)
1052 {
1053         return ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry),
1054                                        ecryptfs_inode_to_lower(inode),
1055                                        name, value, size);
1056 }
1057 
1058 static ssize_t
1059 ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size)
1060 {
1061         int rc = 0;
1062         struct dentry *lower_dentry;
1063 
1064         lower_dentry = ecryptfs_dentry_to_lower(dentry);
1065         if (!d_inode(lower_dentry)->i_op->listxattr) {
1066                 rc = -EOPNOTSUPP;
1067                 goto out;
1068         }
1069         inode_lock(d_inode(lower_dentry));
1070         rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size);
1071         inode_unlock(d_inode(lower_dentry));
1072 out:
1073         return rc;
1074 }
1075 
1076 static int ecryptfs_removexattr(struct dentry *dentry, struct inode *inode,
1077                                 const char *name)
1078 {
1079         int rc;
1080         struct dentry *lower_dentry;
1081         struct inode *lower_inode;
1082 
1083         lower_dentry = ecryptfs_dentry_to_lower(dentry);
1084         lower_inode = ecryptfs_inode_to_lower(inode);
1085         if (!(lower_inode->i_opflags & IOP_XATTR)) {
1086                 rc = -EOPNOTSUPP;
1087                 goto out;
1088         }
1089         inode_lock(lower_inode);
1090         rc = __vfs_removexattr(lower_dentry, name);
1091         inode_unlock(lower_inode);
1092 out:
1093         return rc;
1094 }
1095 
1096 const struct inode_operations ecryptfs_symlink_iops = {
1097         .get_link = ecryptfs_get_link,
1098         .permission = ecryptfs_permission,
1099         .setattr = ecryptfs_setattr,
1100         .getattr = ecryptfs_getattr_link,
1101         .listxattr = ecryptfs_listxattr,
1102 };
1103 
1104 const struct inode_operations ecryptfs_dir_iops = {
1105         .create = ecryptfs_create,
1106         .lookup = ecryptfs_lookup,
1107         .link = ecryptfs_link,
1108         .unlink = ecryptfs_unlink,
1109         .symlink = ecryptfs_symlink,
1110         .mkdir = ecryptfs_mkdir,
1111         .rmdir = ecryptfs_rmdir,
1112         .mknod = ecryptfs_mknod,
1113         .rename = ecryptfs_rename,
1114         .permission = ecryptfs_permission,
1115         .setattr = ecryptfs_setattr,
1116         .listxattr = ecryptfs_listxattr,
1117 };
1118 
1119 const struct inode_operations ecryptfs_main_iops = {
1120         .permission = ecryptfs_permission,
1121         .setattr = ecryptfs_setattr,
1122         .getattr = ecryptfs_getattr,
1123         .listxattr = ecryptfs_listxattr,
1124 };
1125 
1126 static int ecryptfs_xattr_get(const struct xattr_handler *handler,
1127                               struct dentry *dentry, struct inode *inode,
1128                               const char *name, void *buffer, size_t size)
1129 {
1130         return ecryptfs_getxattr(dentry, inode, name, buffer, size);
1131 }
1132 
1133 static int ecryptfs_xattr_set(const struct xattr_handler *handler,
1134                               struct dentry *dentry, struct inode *inode,
1135                               const char *name, const void *value, size_t size,
1136                               int flags)
1137 {
1138         if (value)
1139                 return ecryptfs_setxattr(dentry, inode, name, value, size, flags);
1140         else {
1141                 BUG_ON(flags != XATTR_REPLACE);
1142                 return ecryptfs_removexattr(dentry, inode, name);
1143         }
1144 }
1145 
1146 static const struct xattr_handler ecryptfs_xattr_handler = {
1147         .prefix = "",  /* match anything */
1148         .get = ecryptfs_xattr_get,
1149         .set = ecryptfs_xattr_set,
1150 };
1151 
1152 const struct xattr_handler *ecryptfs_xattr_handlers[] = {
1153         &ecryptfs_xattr_handler,
1154         NULL
1155 };
/* [<][>][^][v][top][bottom][index][help] */
root/fs/ecryptfs/inode.c

DEFINITIONS
