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/crypto.h> 33 #include <linux/fs_stack.h> 34 #include <asm/unaligned.h> 35 #include "ecryptfs_kernel.h" 36 37 static struct dentry *lock_parent(struct dentry *dentry) 38 { 39 struct dentry *dir; 40 41 dir = dget_parent(dentry); 42 mutex_lock_nested(&(dir->d_inode->i_mutex), I_MUTEX_PARENT); 43 return dir; 44 } 45 46 static void unlock_dir(struct dentry *dir) 47 { 48 mutex_unlock(&dir->d_inode->i_mutex); 49 dput(dir); 50 } 51 52 /** 53 * ecryptfs_create_underlying_file 54 * @lower_dir_inode: inode of the parent in the lower fs of the new file 55 * @lower_dentry: New file's dentry in the lower fs 56 * @ecryptfs_dentry: New file's dentry in ecryptfs 57 * @mode: The mode of the new file 58 * @nd: nameidata of ecryptfs' parent's dentry & vfsmount 59 * 60 * Creates the file in the lower file system. 61 * 62 * Returns zero on success; non-zero on error condition 63 */ 64 static int 65 ecryptfs_create_underlying_file(struct inode *lower_dir_inode, 66 struct dentry *dentry, int mode, 67 struct nameidata *nd) 68 { 69 struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry); 70 struct vfsmount *lower_mnt = ecryptfs_dentry_to_lower_mnt(dentry); 71 struct dentry *dentry_save; 72 struct vfsmount *vfsmount_save; 73 int rc; 74 75 dentry_save = nd->path.dentry; 76 vfsmount_save = nd->path.mnt; 77 nd->path.dentry = lower_dentry; 78 nd->path.mnt = lower_mnt; 79 rc = vfs_create(lower_dir_inode, lower_dentry, mode, nd); 80 nd->path.dentry = dentry_save; 81 nd->path.mnt = vfsmount_save; 82 return rc; 83 } 84 85 /** 86 * ecryptfs_do_create 87 * @directory_inode: inode of the new file's dentry's parent in ecryptfs 88 * @ecryptfs_dentry: New file's dentry in ecryptfs 89 * @mode: The mode of the new file 90 * @nd: nameidata of ecryptfs' parent's dentry & vfsmount 91 * 92 * Creates the underlying file and the eCryptfs inode which will link to 93 * it. It will also update the eCryptfs directory inode to mimic the 94 * stat of the lower directory inode. 95 * 96 * Returns zero on success; non-zero on error condition 97 */ 98 static int 99 ecryptfs_do_create(struct inode *directory_inode, 100 struct dentry *ecryptfs_dentry, int mode, 101 struct nameidata *nd) 102 { 103 int rc; 104 struct dentry *lower_dentry; 105 struct dentry *lower_dir_dentry; 106 107 lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry); 108 lower_dir_dentry = lock_parent(lower_dentry); 109 if (IS_ERR(lower_dir_dentry)) { 110 ecryptfs_printk(KERN_ERR, "Error locking directory of " 111 "dentry\n"); 112 rc = PTR_ERR(lower_dir_dentry); 113 goto out; 114 } 115 rc = ecryptfs_create_underlying_file(lower_dir_dentry->d_inode, 116 ecryptfs_dentry, mode, nd); 117 if (rc) { 118 printk(KERN_ERR "%s: Failure to create dentry in lower fs; " 119 "rc = [%d]\n", __func__, rc); 120 goto out_lock; 121 } 122 rc = ecryptfs_interpose(lower_dentry, ecryptfs_dentry, 123 directory_inode->i_sb, 0); 124 if (rc) { 125 ecryptfs_printk(KERN_ERR, "Failure in ecryptfs_interpose\n"); 126 goto out_lock; 127 } 128 fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_inode); 129 fsstack_copy_inode_size(directory_inode, lower_dir_dentry->d_inode); 130 out_lock: 131 unlock_dir(lower_dir_dentry); 132 out: 133 return rc; 134 } 135 136 /** 137 * grow_file 138 * @ecryptfs_dentry: the eCryptfs dentry 139 * 140 * This is the code which will grow the file to its correct size. 141 */ 142 static int grow_file(struct dentry *ecryptfs_dentry) 143 { 144 struct inode *ecryptfs_inode = ecryptfs_dentry->d_inode; 145 struct file fake_file; 146 struct ecryptfs_file_info tmp_file_info; 147 char zero_virt[] = { 0x00 }; 148 int rc = 0; 149 150 memset(&fake_file, 0, sizeof(fake_file)); 151 fake_file.f_path.dentry = ecryptfs_dentry; 152 memset(&tmp_file_info, 0, sizeof(tmp_file_info)); 153 ecryptfs_set_file_private(&fake_file, &tmp_file_info); 154 ecryptfs_set_file_lower( 155 &fake_file, 156 ecryptfs_inode_to_private(ecryptfs_inode)->lower_file); 157 rc = ecryptfs_write(&fake_file, zero_virt, 0, 1); 158 i_size_write(ecryptfs_inode, 0); 159 rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode); 160 ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat.flags |= 161 ECRYPTFS_NEW_FILE; 162 return rc; 163 } 164 165 /** 166 * ecryptfs_initialize_file 167 * 168 * Cause the file to be changed from a basic empty file to an ecryptfs 169 * file with a header and first data page. 170 * 171 * Returns zero on success 172 */ 173 static int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry) 174 { 175 struct ecryptfs_crypt_stat *crypt_stat = 176 &ecryptfs_inode_to_private(ecryptfs_dentry->d_inode)->crypt_stat; 177 int rc = 0; 178 179 if (S_ISDIR(ecryptfs_dentry->d_inode->i_mode)) { 180 ecryptfs_printk(KERN_DEBUG, "This is a directory\n"); 181 crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED); 182 goto out; 183 } 184 crypt_stat->flags |= ECRYPTFS_NEW_FILE; 185 ecryptfs_printk(KERN_DEBUG, "Initializing crypto context\n"); 186 rc = ecryptfs_new_file_context(ecryptfs_dentry); 187 if (rc) { 188 ecryptfs_printk(KERN_ERR, "Error creating new file " 189 "context; rc = [%d]\n", rc); 190 goto out; 191 } 192 if (!ecryptfs_inode_to_private(ecryptfs_dentry->d_inode)->lower_file) { 193 rc = ecryptfs_init_persistent_file(ecryptfs_dentry); 194 if (rc) { 195 printk(KERN_ERR "%s: Error attempting to initialize " 196 "the persistent file for the dentry with name " 197 "[%s]; rc = [%d]\n", __func__, 198 ecryptfs_dentry->d_name.name, rc); 199 goto out; 200 } 201 } 202 rc = ecryptfs_write_metadata(ecryptfs_dentry); 203 if (rc) { 204 printk(KERN_ERR "Error writing headers; rc = [%d]\n", rc); 205 goto out; 206 } 207 rc = grow_file(ecryptfs_dentry); 208 if (rc) 209 printk(KERN_ERR "Error growing file; rc = [%d]\n", rc); 210 out: 211 return rc; 212 } 213 214 /** 215 * ecryptfs_create 216 * @dir: The inode of the directory in which to create the file. 217 * @dentry: The eCryptfs dentry 218 * @mode: The mode of the new file. 219 * @nd: nameidata 220 * 221 * Creates a new file. 222 * 223 * Returns zero on success; non-zero on error condition 224 */ 225 static int 226 ecryptfs_create(struct inode *directory_inode, struct dentry *ecryptfs_dentry, 227 int mode, struct nameidata *nd) 228 { 229 int rc; 230 231 /* ecryptfs_do_create() calls ecryptfs_interpose(), which opens 232 * the crypt_stat->lower_file (persistent file) */ 233 rc = ecryptfs_do_create(directory_inode, ecryptfs_dentry, mode, nd); 234 if (unlikely(rc)) { 235 ecryptfs_printk(KERN_WARNING, "Failed to create file in" 236 "lower filesystem\n"); 237 goto out; 238 } 239 /* At this point, a file exists on "disk"; we need to make sure 240 * that this on disk file is prepared to be an ecryptfs file */ 241 rc = ecryptfs_initialize_file(ecryptfs_dentry); 242 out: 243 return rc; 244 } 245 246 /** 247 * ecryptfs_lookup 248 * @dir: inode 249 * @dentry: The dentry 250 * @nd: nameidata, may be NULL 251 * 252 * Find a file on disk. If the file does not exist, then we'll add it to the 253 * dentry cache and continue on to read it from the disk. 254 */ 255 static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry, 256 struct nameidata *nd) 257 { 258 int rc = 0; 259 struct dentry *lower_dir_dentry; 260 struct dentry *lower_dentry; 261 struct vfsmount *lower_mnt; 262 char *encoded_name; 263 int encoded_namelen; 264 struct ecryptfs_crypt_stat *crypt_stat = NULL; 265 struct ecryptfs_mount_crypt_stat *mount_crypt_stat; 266 char *page_virt = NULL; 267 struct inode *lower_inode; 268 u64 file_size; 269 270 lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent); 271 dentry->d_op = &ecryptfs_dops; 272 if ((dentry->d_name.len == 1 && !strcmp(dentry->d_name.name, ".")) 273 || (dentry->d_name.len == 2 274 && !strcmp(dentry->d_name.name, ".."))) { 275 d_drop(dentry); 276 goto out; 277 } 278 encoded_namelen = ecryptfs_encode_filename(crypt_stat, 279 dentry->d_name.name, 280 dentry->d_name.len, 281 &encoded_name); 282 if (encoded_namelen < 0) { 283 rc = encoded_namelen; 284 d_drop(dentry); 285 goto out; 286 } 287 ecryptfs_printk(KERN_DEBUG, "encoded_name = [%s]; encoded_namelen " 288 "= [%d]\n", encoded_name, encoded_namelen); 289 lower_dentry = lookup_one_len(encoded_name, lower_dir_dentry, 290 encoded_namelen - 1); 291 kfree(encoded_name); 292 if (IS_ERR(lower_dentry)) { 293 ecryptfs_printk(KERN_ERR, "ERR from lower_dentry\n"); 294 rc = PTR_ERR(lower_dentry); 295 d_drop(dentry); 296 goto out; 297 } 298 lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(dentry->d_parent)); 299 ecryptfs_printk(KERN_DEBUG, "lower_dentry = [%p]; lower_dentry->" 300 "d_name.name = [%s]\n", lower_dentry, 301 lower_dentry->d_name.name); 302 lower_inode = lower_dentry->d_inode; 303 fsstack_copy_attr_atime(dir, lower_dir_dentry->d_inode); 304 BUG_ON(!atomic_read(&lower_dentry->d_count)); 305 ecryptfs_set_dentry_private(dentry, 306 kmem_cache_alloc(ecryptfs_dentry_info_cache, 307 GFP_KERNEL)); 308 if (!ecryptfs_dentry_to_private(dentry)) { 309 rc = -ENOMEM; 310 ecryptfs_printk(KERN_ERR, "Out of memory whilst attempting " 311 "to allocate ecryptfs_dentry_info struct\n"); 312 goto out_dput; 313 } 314 ecryptfs_set_dentry_lower(dentry, lower_dentry); 315 ecryptfs_set_dentry_lower_mnt(dentry, lower_mnt); 316 if (!lower_dentry->d_inode) { 317 /* We want to add because we couldn't find in lower */ 318 d_add(dentry, NULL); 319 goto out; 320 } 321 rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb, 322 ECRYPTFS_INTERPOSE_FLAG_D_ADD); 323 if (rc) { 324 ecryptfs_printk(KERN_ERR, "Error interposing\n"); 325 goto out; 326 } 327 if (S_ISDIR(lower_inode->i_mode)) { 328 ecryptfs_printk(KERN_DEBUG, "Is a directory; returning\n"); 329 goto out; 330 } 331 if (S_ISLNK(lower_inode->i_mode)) { 332 ecryptfs_printk(KERN_DEBUG, "Is a symlink; returning\n"); 333 goto out; 334 } 335 if (special_file(lower_inode->i_mode)) { 336 ecryptfs_printk(KERN_DEBUG, "Is a special file; returning\n"); 337 goto out; 338 } 339 if (!nd) { 340 ecryptfs_printk(KERN_DEBUG, "We have a NULL nd, just leave" 341 "as we *think* we are about to unlink\n"); 342 goto out; 343 } 344 /* Released in this function */ 345 page_virt = kmem_cache_zalloc(ecryptfs_header_cache_2, 346 GFP_USER); 347 if (!page_virt) { 348 rc = -ENOMEM; 349 ecryptfs_printk(KERN_ERR, 350 "Cannot ecryptfs_kmalloc a page\n"); 351 goto out; 352 } 353 crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat; 354 if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)) 355 ecryptfs_set_default_sizes(crypt_stat); 356 if (!ecryptfs_inode_to_private(dentry->d_inode)->lower_file) { 357 rc = ecryptfs_init_persistent_file(dentry); 358 if (rc) { 359 printk(KERN_ERR "%s: Error attempting to initialize " 360 "the persistent file for the dentry with name " 361 "[%s]; rc = [%d]\n", __func__, 362 dentry->d_name.name, rc); 363 goto out; 364 } 365 } 366 rc = ecryptfs_read_and_validate_header_region(page_virt, 367 dentry->d_inode); 368 if (rc) { 369 rc = ecryptfs_read_and_validate_xattr_region(page_virt, dentry); 370 if (rc) { 371 printk(KERN_DEBUG "Valid metadata not found in header " 372 "region or xattr region; treating file as " 373 "unencrypted\n"); 374 rc = 0; 375 kmem_cache_free(ecryptfs_header_cache_2, page_virt); 376 goto out; 377 } 378 crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR; 379 } 380 mount_crypt_stat = &ecryptfs_superblock_to_private( 381 dentry->d_sb)->mount_crypt_stat; 382 if (mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED) { 383 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) 384 file_size = (crypt_stat->num_header_bytes_at_front 385 + i_size_read(lower_dentry->d_inode)); 386 else 387 file_size = i_size_read(lower_dentry->d_inode); 388 } else { 389 file_size = get_unaligned_be64(page_virt); 390 } 391 i_size_write(dentry->d_inode, (loff_t)file_size); 392 kmem_cache_free(ecryptfs_header_cache_2, page_virt); 393 goto out; 394 395 out_dput: 396 dput(lower_dentry); 397 d_drop(dentry); 398 out: 399 return ERR_PTR(rc); 400 } 401 402 static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir, 403 struct dentry *new_dentry) 404 { 405 struct dentry *lower_old_dentry; 406 struct dentry *lower_new_dentry; 407 struct dentry *lower_dir_dentry; 408 u64 file_size_save; 409 int rc; 410 411 file_size_save = i_size_read(old_dentry->d_inode); 412 lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry); 413 lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry); 414 dget(lower_old_dentry); 415 dget(lower_new_dentry); 416 lower_dir_dentry = lock_parent(lower_new_dentry); 417 rc = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode, 418 lower_new_dentry); 419 if (rc || !lower_new_dentry->d_inode) 420 goto out_lock; 421 rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb, 0); 422 if (rc) 423 goto out_lock; 424 fsstack_copy_attr_times(dir, lower_new_dentry->d_inode); 425 fsstack_copy_inode_size(dir, lower_new_dentry->d_inode); 426 old_dentry->d_inode->i_nlink = 427 ecryptfs_inode_to_lower(old_dentry->d_inode)->i_nlink; 428 i_size_write(new_dentry->d_inode, file_size_save); 429 out_lock: 430 unlock_dir(lower_dir_dentry); 431 dput(lower_new_dentry); 432 dput(lower_old_dentry); 433 d_drop(lower_old_dentry); 434 d_drop(new_dentry); 435 d_drop(old_dentry); 436 return rc; 437 } 438 439 static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry) 440 { 441 int rc = 0; 442 struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry); 443 struct inode *lower_dir_inode = ecryptfs_inode_to_lower(dir); 444 struct dentry *lower_dir_dentry; 445 446 lower_dir_dentry = lock_parent(lower_dentry); 447 rc = vfs_unlink(lower_dir_inode, lower_dentry); 448 if (rc) { 449 printk(KERN_ERR "Error in vfs_unlink; rc = [%d]\n", rc); 450 goto out_unlock; 451 } 452 fsstack_copy_attr_times(dir, lower_dir_inode); 453 dentry->d_inode->i_nlink = 454 ecryptfs_inode_to_lower(dentry->d_inode)->i_nlink; 455 dentry->d_inode->i_ctime = dir->i_ctime; 456 d_drop(dentry); 457 out_unlock: 458 unlock_dir(lower_dir_dentry); 459 return rc; 460 } 461 462 static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry, 463 const char *symname) 464 { 465 int rc; 466 struct dentry *lower_dentry; 467 struct dentry *lower_dir_dentry; 468 char *encoded_symname; 469 int encoded_symlen; 470 struct ecryptfs_crypt_stat *crypt_stat = NULL; 471 472 lower_dentry = ecryptfs_dentry_to_lower(dentry); 473 dget(lower_dentry); 474 lower_dir_dentry = lock_parent(lower_dentry); 475 encoded_symlen = ecryptfs_encode_filename(crypt_stat, symname, 476 strlen(symname), 477 &encoded_symname); 478 if (encoded_symlen < 0) { 479 rc = encoded_symlen; 480 goto out_lock; 481 } 482 rc = vfs_symlink(lower_dir_dentry->d_inode, lower_dentry, 483 encoded_symname); 484 kfree(encoded_symname); 485 if (rc || !lower_dentry->d_inode) 486 goto out_lock; 487 rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb, 0); 488 if (rc) 489 goto out_lock; 490 fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode); 491 fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode); 492 out_lock: 493 unlock_dir(lower_dir_dentry); 494 dput(lower_dentry); 495 if (!dentry->d_inode) 496 d_drop(dentry); 497 return rc; 498 } 499 500 static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 501 { 502 int rc; 503 struct dentry *lower_dentry; 504 struct dentry *lower_dir_dentry; 505 506 lower_dentry = ecryptfs_dentry_to_lower(dentry); 507 lower_dir_dentry = lock_parent(lower_dentry); 508 rc = vfs_mkdir(lower_dir_dentry->d_inode, lower_dentry, mode); 509 if (rc || !lower_dentry->d_inode) 510 goto out; 511 rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb, 0); 512 if (rc) 513 goto out; 514 fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode); 515 fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode); 516 dir->i_nlink = lower_dir_dentry->d_inode->i_nlink; 517 out: 518 unlock_dir(lower_dir_dentry); 519 if (!dentry->d_inode) 520 d_drop(dentry); 521 return rc; 522 } 523 524 static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry) 525 { 526 struct dentry *lower_dentry; 527 struct dentry *lower_dir_dentry; 528 int rc; 529 530 lower_dentry = ecryptfs_dentry_to_lower(dentry); 531 dget(dentry); 532 lower_dir_dentry = lock_parent(lower_dentry); 533 dget(lower_dentry); 534 rc = vfs_rmdir(lower_dir_dentry->d_inode, lower_dentry); 535 dput(lower_dentry); 536 if (!rc) 537 d_delete(lower_dentry); 538 fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode); 539 dir->i_nlink = lower_dir_dentry->d_inode->i_nlink; 540 unlock_dir(lower_dir_dentry); 541 if (!rc) 542 d_drop(dentry); 543 dput(dentry); 544 return rc; 545 } 546 547 static int 548 ecryptfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev) 549 { 550 int rc; 551 struct dentry *lower_dentry; 552 struct dentry *lower_dir_dentry; 553 554 lower_dentry = ecryptfs_dentry_to_lower(dentry); 555 lower_dir_dentry = lock_parent(lower_dentry); 556 rc = vfs_mknod(lower_dir_dentry->d_inode, lower_dentry, mode, dev); 557 if (rc || !lower_dentry->d_inode) 558 goto out; 559 rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb, 0); 560 if (rc) 561 goto out; 562 fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode); 563 fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode); 564 out: 565 unlock_dir(lower_dir_dentry); 566 if (!dentry->d_inode) 567 d_drop(dentry); 568 return rc; 569 } 570 571 static int 572 ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry, 573 struct inode *new_dir, struct dentry *new_dentry) 574 { 575 int rc; 576 struct dentry *lower_old_dentry; 577 struct dentry *lower_new_dentry; 578 struct dentry *lower_old_dir_dentry; 579 struct dentry *lower_new_dir_dentry; 580 581 lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry); 582 lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry); 583 dget(lower_old_dentry); 584 dget(lower_new_dentry); 585 lower_old_dir_dentry = dget_parent(lower_old_dentry); 586 lower_new_dir_dentry = dget_parent(lower_new_dentry); 587 lock_rename(lower_old_dir_dentry, lower_new_dir_dentry); 588 rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry, 589 lower_new_dir_dentry->d_inode, lower_new_dentry); 590 if (rc) 591 goto out_lock; 592 fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode, NULL); 593 if (new_dir != old_dir) 594 fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode, NULL); 595 out_lock: 596 unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry); 597 dput(lower_new_dentry->d_parent); 598 dput(lower_old_dentry->d_parent); 599 dput(lower_new_dentry); 600 dput(lower_old_dentry); 601 return rc; 602 } 603 604 static int 605 ecryptfs_readlink(struct dentry *dentry, char __user * buf, int bufsiz) 606 { 607 int rc; 608 struct dentry *lower_dentry; 609 char *decoded_name; 610 char *lower_buf; 611 mm_segment_t old_fs; 612 struct ecryptfs_crypt_stat *crypt_stat; 613 614 lower_dentry = ecryptfs_dentry_to_lower(dentry); 615 if (!lower_dentry->d_inode->i_op || 616 !lower_dentry->d_inode->i_op->readlink) { 617 rc = -EINVAL; 618 goto out; 619 } 620 /* Released in this function */ 621 lower_buf = kmalloc(bufsiz, GFP_KERNEL); 622 if (lower_buf == NULL) { 623 ecryptfs_printk(KERN_ERR, "Out of memory\n"); 624 rc = -ENOMEM; 625 goto out; 626 } 627 old_fs = get_fs(); 628 set_fs(get_ds()); 629 ecryptfs_printk(KERN_DEBUG, "Calling readlink w/ " 630 "lower_dentry->d_name.name = [%s]\n", 631 lower_dentry->d_name.name); 632 rc = lower_dentry->d_inode->i_op->readlink(lower_dentry, 633 (char __user *)lower_buf, 634 bufsiz); 635 set_fs(old_fs); 636 if (rc >= 0) { 637 crypt_stat = NULL; 638 rc = ecryptfs_decode_filename(crypt_stat, lower_buf, rc, 639 &decoded_name); 640 if (rc == -ENOMEM) 641 goto out_free_lower_buf; 642 if (rc > 0) { 643 ecryptfs_printk(KERN_DEBUG, "Copying [%d] bytes " 644 "to userspace: [%*s]\n", rc, 645 decoded_name); 646 if (copy_to_user(buf, decoded_name, rc)) 647 rc = -EFAULT; 648 } 649 kfree(decoded_name); 650 fsstack_copy_attr_atime(dentry->d_inode, 651 lower_dentry->d_inode); 652 } 653 out_free_lower_buf: 654 kfree(lower_buf); 655 out: 656 return rc; 657 } 658 659 static void *ecryptfs_follow_link(struct dentry *dentry, struct nameidata *nd) 660 { 661 char *buf; 662 int len = PAGE_SIZE, rc; 663 mm_segment_t old_fs; 664 665 /* Released in ecryptfs_put_link(); only release here on error */ 666 buf = kmalloc(len, GFP_KERNEL); 667 if (!buf) { 668 rc = -ENOMEM; 669 goto out; 670 } 671 old_fs = get_fs(); 672 set_fs(get_ds()); 673 ecryptfs_printk(KERN_DEBUG, "Calling readlink w/ " 674 "dentry->d_name.name = [%s]\n", dentry->d_name.name); 675 rc = dentry->d_inode->i_op->readlink(dentry, (char __user *)buf, len); 676 buf[rc] = '\0'; 677 set_fs(old_fs); 678 if (rc < 0) 679 goto out_free; 680 rc = 0; 681 nd_set_link(nd, buf); 682 goto out; 683 out_free: 684 kfree(buf); 685 out: 686 return ERR_PTR(rc); 687 } 688 689 static void 690 ecryptfs_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr) 691 { 692 /* Free the char* */ 693 kfree(nd_get_link(nd)); 694 } 695 696 /** 697 * upper_size_to_lower_size 698 * @crypt_stat: Crypt_stat associated with file 699 * @upper_size: Size of the upper file 700 * 701 * Calculate the required size of the lower file based on the 702 * specified size of the upper file. This calculation is based on the 703 * number of headers in the underlying file and the extent size. 704 * 705 * Returns Calculated size of the lower file. 706 */ 707 static loff_t 708 upper_size_to_lower_size(struct ecryptfs_crypt_stat *crypt_stat, 709 loff_t upper_size) 710 { 711 loff_t lower_size; 712 713 lower_size = crypt_stat->num_header_bytes_at_front; 714 if (upper_size != 0) { 715 loff_t num_extents; 716 717 num_extents = upper_size >> crypt_stat->extent_shift; 718 if (upper_size & ~crypt_stat->extent_mask) 719 num_extents++; 720 lower_size += (num_extents * crypt_stat->extent_size); 721 } 722 return lower_size; 723 } 724 725 /** 726 * ecryptfs_truncate 727 * @dentry: The ecryptfs layer dentry 728 * @new_length: The length to expand the file to 729 * 730 * Function to handle truncations modifying the size of the file. Note 731 * that the file sizes are interpolated. When expanding, we are simply 732 * writing strings of 0's out. When truncating, we need to modify the 733 * underlying file size according to the page index interpolations. 734 * 735 * Returns zero on success; non-zero otherwise 736 */ 737 int ecryptfs_truncate(struct dentry *dentry, loff_t new_length) 738 { 739 int rc = 0; 740 struct inode *inode = dentry->d_inode; 741 struct dentry *lower_dentry; 742 struct file fake_ecryptfs_file; 743 struct ecryptfs_crypt_stat *crypt_stat; 744 loff_t i_size = i_size_read(inode); 745 loff_t lower_size_before_truncate; 746 loff_t lower_size_after_truncate; 747 748 if (unlikely((new_length == i_size))) 749 goto out; 750 crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat; 751 /* Set up a fake ecryptfs file, this is used to interface with 752 * the file in the underlying filesystem so that the 753 * truncation has an effect there as well. */ 754 memset(&fake_ecryptfs_file, 0, sizeof(fake_ecryptfs_file)); 755 fake_ecryptfs_file.f_path.dentry = dentry; 756 /* Released at out_free: label */ 757 ecryptfs_set_file_private(&fake_ecryptfs_file, 758 kmem_cache_alloc(ecryptfs_file_info_cache, 759 GFP_KERNEL)); 760 if (unlikely(!ecryptfs_file_to_private(&fake_ecryptfs_file))) { 761 rc = -ENOMEM; 762 goto out; 763 } 764 lower_dentry = ecryptfs_dentry_to_lower(dentry); 765 ecryptfs_set_file_lower( 766 &fake_ecryptfs_file, 767 ecryptfs_inode_to_private(dentry->d_inode)->lower_file); 768 /* Switch on growing or shrinking file */ 769 if (new_length > i_size) { 770 char zero[] = { 0x00 }; 771 772 /* Write a single 0 at the last position of the file; 773 * this triggers code that will fill in 0's throughout 774 * the intermediate portion of the previous end of the 775 * file and the new and of the file */ 776 rc = ecryptfs_write(&fake_ecryptfs_file, zero, 777 (new_length - 1), 1); 778 } else { /* new_length < i_size_read(inode) */ 779 /* We're chopping off all the pages down do the page 780 * in which new_length is located. Fill in the end of 781 * that page from (new_length & ~PAGE_CACHE_MASK) to 782 * PAGE_CACHE_SIZE with zeros. */ 783 size_t num_zeros = (PAGE_CACHE_SIZE 784 - (new_length & ~PAGE_CACHE_MASK)); 785 786 if (num_zeros) { 787 char *zeros_virt; 788 789 zeros_virt = kzalloc(num_zeros, GFP_KERNEL); 790 if (!zeros_virt) { 791 rc = -ENOMEM; 792 goto out_free; 793 } 794 rc = ecryptfs_write(&fake_ecryptfs_file, zeros_virt, 795 new_length, num_zeros); 796 kfree(zeros_virt); 797 if (rc) { 798 printk(KERN_ERR "Error attempting to zero out " 799 "the remainder of the end page on " 800 "reducing truncate; rc = [%d]\n", rc); 801 goto out_free; 802 } 803 } 804 vmtruncate(inode, new_length); 805 rc = ecryptfs_write_inode_size_to_metadata(inode); 806 if (rc) { 807 printk(KERN_ERR "Problem with " 808 "ecryptfs_write_inode_size_to_metadata; " 809 "rc = [%d]\n", rc); 810 goto out_free; 811 } 812 /* We are reducing the size of the ecryptfs file, and need to 813 * know if we need to reduce the size of the lower file. */ 814 lower_size_before_truncate = 815 upper_size_to_lower_size(crypt_stat, i_size); 816 lower_size_after_truncate = 817 upper_size_to_lower_size(crypt_stat, new_length); 818 if (lower_size_after_truncate < lower_size_before_truncate) 819 vmtruncate(lower_dentry->d_inode, 820 lower_size_after_truncate); 821 } 822 out_free: 823 if (ecryptfs_file_to_private(&fake_ecryptfs_file)) 824 kmem_cache_free(ecryptfs_file_info_cache, 825 ecryptfs_file_to_private(&fake_ecryptfs_file)); 826 out: 827 return rc; 828 } 829 830 static int 831 ecryptfs_permission(struct inode *inode, int mask) 832 { 833 return inode_permission(ecryptfs_inode_to_lower(inode), mask); 834 } 835 836 /** 837 * ecryptfs_setattr 838 * @dentry: dentry handle to the inode to modify 839 * @ia: Structure with flags of what to change and values 840 * 841 * Updates the metadata of an inode. If the update is to the size 842 * i.e. truncation, then ecryptfs_truncate will handle the size modification 843 * of both the ecryptfs inode and the lower inode. 844 * 845 * All other metadata changes will be passed right to the lower filesystem, 846 * and we will just update our inode to look like the lower. 847 */ 848 static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia) 849 { 850 int rc = 0; 851 struct dentry *lower_dentry; 852 struct inode *inode; 853 struct inode *lower_inode; 854 struct ecryptfs_crypt_stat *crypt_stat; 855 856 crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat; 857 if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED)) 858 ecryptfs_init_crypt_stat(crypt_stat); 859 inode = dentry->d_inode; 860 lower_inode = ecryptfs_inode_to_lower(inode); 861 lower_dentry = ecryptfs_dentry_to_lower(dentry); 862 mutex_lock(&crypt_stat->cs_mutex); 863 if (S_ISDIR(dentry->d_inode->i_mode)) 864 crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED); 865 else if (S_ISREG(dentry->d_inode->i_mode) 866 && (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED) 867 || !(crypt_stat->flags & ECRYPTFS_KEY_VALID))) { 868 struct ecryptfs_mount_crypt_stat *mount_crypt_stat; 869 870 mount_crypt_stat = &ecryptfs_superblock_to_private( 871 dentry->d_sb)->mount_crypt_stat; 872 rc = ecryptfs_read_metadata(dentry); 873 if (rc) { 874 if (!(mount_crypt_stat->flags 875 & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)) { 876 rc = -EIO; 877 printk(KERN_WARNING "Either the lower file " 878 "is not in a valid eCryptfs format, " 879 "or the key could not be retrieved. " 880 "Plaintext passthrough mode is not " 881 "enabled; returning -EIO\n"); 882 mutex_unlock(&crypt_stat->cs_mutex); 883 goto out; 884 } 885 rc = 0; 886 crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED); 887 mutex_unlock(&crypt_stat->cs_mutex); 888 goto out; 889 } 890 } 891 mutex_unlock(&crypt_stat->cs_mutex); 892 if (ia->ia_valid & ATTR_SIZE) { 893 ecryptfs_printk(KERN_DEBUG, 894 "ia->ia_valid = [0x%x] ATTR_SIZE" " = [0x%x]\n", 895 ia->ia_valid, ATTR_SIZE); 896 rc = ecryptfs_truncate(dentry, ia->ia_size); 897 /* ecryptfs_truncate handles resizing of the lower file */ 898 ia->ia_valid &= ~ATTR_SIZE; 899 ecryptfs_printk(KERN_DEBUG, "ia->ia_valid = [%x]\n", 900 ia->ia_valid); 901 if (rc < 0) 902 goto out; 903 } 904 905 /* 906 * mode change is for clearing setuid/setgid bits. Allow lower fs 907 * to interpret this in its own way. 908 */ 909 if (ia->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) 910 ia->ia_valid &= ~ATTR_MODE; 911 912 mutex_lock(&lower_dentry->d_inode->i_mutex); 913 rc = notify_change(lower_dentry, ia); 914 mutex_unlock(&lower_dentry->d_inode->i_mutex); 915 out: 916 fsstack_copy_attr_all(inode, lower_inode, NULL); 917 return rc; 918 } 919 920 int 921 ecryptfs_setxattr(struct dentry *dentry, const char *name, const void *value, 922 size_t size, int flags) 923 { 924 int rc = 0; 925 struct dentry *lower_dentry; 926 927 lower_dentry = ecryptfs_dentry_to_lower(dentry); 928 if (!lower_dentry->d_inode->i_op->setxattr) { 929 rc = -ENOSYS; 930 goto out; 931 } 932 mutex_lock(&lower_dentry->d_inode->i_mutex); 933 rc = lower_dentry->d_inode->i_op->setxattr(lower_dentry, name, value, 934 size, flags); 935 mutex_unlock(&lower_dentry->d_inode->i_mutex); 936 out: 937 return rc; 938 } 939 940 ssize_t 941 ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name, 942 void *value, size_t size) 943 { 944 int rc = 0; 945 946 if (!lower_dentry->d_inode->i_op->getxattr) { 947 rc = -ENOSYS; 948 goto out; 949 } 950 mutex_lock(&lower_dentry->d_inode->i_mutex); 951 rc = lower_dentry->d_inode->i_op->getxattr(lower_dentry, name, value, 952 size); 953 mutex_unlock(&lower_dentry->d_inode->i_mutex); 954 out: 955 return rc; 956 } 957 958 static ssize_t 959 ecryptfs_getxattr(struct dentry *dentry, const char *name, void *value, 960 size_t size) 961 { 962 return ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry), name, 963 value, size); 964 } 965 966 static ssize_t 967 ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size) 968 { 969 int rc = 0; 970 struct dentry *lower_dentry; 971 972 lower_dentry = ecryptfs_dentry_to_lower(dentry); 973 if (!lower_dentry->d_inode->i_op->listxattr) { 974 rc = -ENOSYS; 975 goto out; 976 } 977 mutex_lock(&lower_dentry->d_inode->i_mutex); 978 rc = lower_dentry->d_inode->i_op->listxattr(lower_dentry, list, size); 979 mutex_unlock(&lower_dentry->d_inode->i_mutex); 980 out: 981 return rc; 982 } 983 984 static int ecryptfs_removexattr(struct dentry *dentry, const char *name) 985 { 986 int rc = 0; 987 struct dentry *lower_dentry; 988 989 lower_dentry = ecryptfs_dentry_to_lower(dentry); 990 if (!lower_dentry->d_inode->i_op->removexattr) { 991 rc = -ENOSYS; 992 goto out; 993 } 994 mutex_lock(&lower_dentry->d_inode->i_mutex); 995 rc = lower_dentry->d_inode->i_op->removexattr(lower_dentry, name); 996 mutex_unlock(&lower_dentry->d_inode->i_mutex); 997 out: 998 return rc; 999 } 1000 1001 int ecryptfs_inode_test(struct inode *inode, void *candidate_lower_inode) 1002 { 1003 if ((ecryptfs_inode_to_lower(inode) 1004 == (struct inode *)candidate_lower_inode)) 1005 return 1; 1006 else 1007 return 0; 1008 } 1009 1010 int ecryptfs_inode_set(struct inode *inode, void *lower_inode) 1011 { 1012 ecryptfs_init_inode(inode, (struct inode *)lower_inode); 1013 return 0; 1014 } 1015 1016 const struct inode_operations ecryptfs_symlink_iops = { 1017 .readlink = ecryptfs_readlink, 1018 .follow_link = ecryptfs_follow_link, 1019 .put_link = ecryptfs_put_link, 1020 .permission = ecryptfs_permission, 1021 .setattr = ecryptfs_setattr, 1022 .setxattr = ecryptfs_setxattr, 1023 .getxattr = ecryptfs_getxattr, 1024 .listxattr = ecryptfs_listxattr, 1025 .removexattr = ecryptfs_removexattr 1026 }; 1027 1028 const struct inode_operations ecryptfs_dir_iops = { 1029 .create = ecryptfs_create, 1030 .lookup = ecryptfs_lookup, 1031 .link = ecryptfs_link, 1032 .unlink = ecryptfs_unlink, 1033 .symlink = ecryptfs_symlink, 1034 .mkdir = ecryptfs_mkdir, 1035 .rmdir = ecryptfs_rmdir, 1036 .mknod = ecryptfs_mknod, 1037 .rename = ecryptfs_rename, 1038 .permission = ecryptfs_permission, 1039 .setattr = ecryptfs_setattr, 1040 .setxattr = ecryptfs_setxattr, 1041 .getxattr = ecryptfs_getxattr, 1042 .listxattr = ecryptfs_listxattr, 1043 .removexattr = ecryptfs_removexattr 1044 }; 1045 1046 const struct inode_operations ecryptfs_main_iops = { 1047 .permission = ecryptfs_permission, 1048 .setattr = ecryptfs_setattr, 1049 .setxattr = ecryptfs_setxattr, 1050 .getxattr = ecryptfs_getxattr, 1051 .listxattr = ecryptfs_listxattr, 1052 .removexattr = ecryptfs_removexattr 1053 }; 1054