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