Linux Audio

Check our new training course

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