1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * fscrypt.h: declarations for per-file encryption
4 *
5 * Filesystems that implement per-file encryption must include this header
6 * file.
7 *
8 * Copyright (C) 2015, Google, Inc.
9 *
10 * Written by Michael Halcrow, 2015.
11 * Modified by Jaegeuk Kim, 2015.
12 */
13 #ifndef _LINUX_FSCRYPT_H
14 #define _LINUX_FSCRYPT_H
15
16 #include <linux/fs.h>
17 #include <linux/mm.h>
18 #include <linux/slab.h>
19 #include <uapi/linux/fscrypt.h>
20
21 /*
22 * The lengths of all file contents blocks must be divisible by this value.
23 * This is needed to ensure that all contents encryption modes will work, as
24 * some of the supported modes don't support arbitrarily byte-aligned messages.
25 *
26 * Since the needed alignment is 16 bytes, most filesystems will meet this
27 * requirement naturally, as typical block sizes are powers of 2. However, if a
28 * filesystem can generate arbitrarily byte-aligned block lengths (e.g., via
29 * compression), then it will need to pad to this alignment before encryption.
30 */
31 #define FSCRYPT_CONTENTS_ALIGNMENT 16
32
33 union fscrypt_policy;
34 struct fscrypt_info;
35 struct fs_parameter;
36 struct seq_file;
37
38 struct fscrypt_str {
39 unsigned char *name;
40 u32 len;
41 };
42
43 struct fscrypt_name {
44 const struct qstr *usr_fname;
45 struct fscrypt_str disk_name;
46 u32 hash;
47 u32 minor_hash;
48 struct fscrypt_str crypto_buf;
49 bool is_nokey_name;
50 };
51
52 #define FSTR_INIT(n, l) { .name = n, .len = l }
53 #define FSTR_TO_QSTR(f) QSTR_INIT((f)->name, (f)->len)
54 #define fname_name(p) ((p)->disk_name.name)
55 #define fname_len(p) ((p)->disk_name.len)
56
57 /* Maximum value for the third parameter of fscrypt_operations.set_context(). */
58 #define FSCRYPT_SET_CONTEXT_MAX_SIZE 40
59
60 #ifdef CONFIG_FS_ENCRYPTION
61
62 /*
63 * If set, the fscrypt bounce page pool won't be allocated (unless another
64 * filesystem needs it). Set this if the filesystem always uses its own bounce
65 * pages for writes and therefore won't need the fscrypt bounce page pool.
66 */
67 #define FS_CFLG_OWN_PAGES (1U << 1)
68
69 /* Crypto operations for filesystems */
70 struct fscrypt_operations {
71
72 /* Set of optional flags; see above for allowed flags */
73 unsigned int flags;
74
75 /*
76 * If set, this is a filesystem-specific key description prefix that
77 * will be accepted for "logon" keys for v1 fscrypt policies, in
78 * addition to the generic prefix "fscrypt:". This functionality is
79 * deprecated, so new filesystems shouldn't set this field.
80 */
81 const char *key_prefix;
82
83 /*
84 * Get the fscrypt context of the given inode.
85 *
86 * @inode: the inode whose context to get
87 * @ctx: the buffer into which to get the context
88 * @len: length of the @ctx buffer in bytes
89 *
90 * Return: On success, returns the length of the context in bytes; this
91 * may be less than @len. On failure, returns -ENODATA if the
92 * inode doesn't have a context, -ERANGE if the context is
93 * longer than @len, or another -errno code.
94 */
95 int (*get_context)(struct inode *inode, void *ctx, size_t len);
96
97 /*
98 * Set an fscrypt context on the given inode.
99 *
100 * @inode: the inode whose context to set. The inode won't already have
101 * an fscrypt context.
102 * @ctx: the context to set
103 * @len: length of @ctx in bytes (at most FSCRYPT_SET_CONTEXT_MAX_SIZE)
104 * @fs_data: If called from fscrypt_set_context(), this will be the
105 * value the filesystem passed to fscrypt_set_context().
106 * Otherwise (i.e. when called from
107 * FS_IOC_SET_ENCRYPTION_POLICY) this will be NULL.
108 *
109 * i_rwsem will be held for write.
110 *
111 * Return: 0 on success, -errno on failure.
112 */
113 int (*set_context)(struct inode *inode, const void *ctx, size_t len,
114 void *fs_data);
115
116 /*
117 * Get the dummy fscrypt policy in use on the filesystem (if any).
118 *
119 * Filesystems only need to implement this function if they support the
120 * test_dummy_encryption mount option.
121 *
122 * Return: A pointer to the dummy fscrypt policy, if the filesystem is
123 * mounted with test_dummy_encryption; otherwise NULL.
124 */
125 const union fscrypt_policy *(*get_dummy_policy)(struct super_block *sb);
126
127 /*
128 * Check whether a directory is empty. i_rwsem will be held for write.
129 */
130 bool (*empty_dir)(struct inode *inode);
131
132 /*
133 * Check whether the filesystem's inode numbers and UUID are stable,
134 * meaning that they will never be changed even by offline operations
135 * such as filesystem shrinking and therefore can be used in the
136 * encryption without the possibility of files becoming unreadable.
137 *
138 * Filesystems only need to implement this function if they want to
139 * support the FSCRYPT_POLICY_FLAG_IV_INO_LBLK_{32,64} flags. These
140 * flags are designed to work around the limitations of UFS and eMMC
141 * inline crypto hardware, and they shouldn't be used in scenarios where
142 * such hardware isn't being used.
143 *
144 * Leaving this NULL is equivalent to always returning false.
145 */
146 bool (*has_stable_inodes)(struct super_block *sb);
147
148 /*
149 * Get the number of bits that the filesystem uses to represent inode
150 * numbers and file logical block numbers.
151 *
152 * By default, both of these are assumed to be 64-bit. This function
153 * can be implemented to declare that either or both of these numbers is
154 * shorter, which may allow the use of the
155 * FSCRYPT_POLICY_FLAG_IV_INO_LBLK_{32,64} flags and/or the use of
156 * inline crypto hardware whose maximum DUN length is less than 64 bits
157 * (e.g., eMMC v5.2 spec compliant hardware). This function only needs
158 * to be implemented if support for one of these features is needed.
159 */
160 void (*get_ino_and_lblk_bits)(struct super_block *sb,
161 int *ino_bits_ret, int *lblk_bits_ret);
162
163 /*
164 * Return the number of block devices to which the filesystem may write
165 * encrypted file contents.
166 *
167 * If the filesystem can use multiple block devices (other than block
168 * devices that aren't used for encrypted file contents, such as
169 * external journal devices), and wants to support inline encryption,
170 * then it must implement this function. Otherwise it's not needed.
171 */
172 int (*get_num_devices)(struct super_block *sb);
173
174 /*
175 * If ->get_num_devices() returns a value greater than 1, then this
176 * function is called to get the array of request_queues that the
177 * filesystem is using -- one per block device. (There may be duplicate
178 * entries in this array, as block devices can share a request_queue.)
179 */
180 void (*get_devices)(struct super_block *sb,
181 struct request_queue **devs);
182 };
183
fscrypt_get_info(const struct inode * inode)184 static inline struct fscrypt_info *fscrypt_get_info(const struct inode *inode)
185 {
186 /*
187 * Pairs with the cmpxchg_release() in fscrypt_setup_encryption_info().
188 * I.e., another task may publish ->i_crypt_info concurrently, executing
189 * a RELEASE barrier. We need to use smp_load_acquire() here to safely
190 * ACQUIRE the memory the other task published.
191 */
192 return smp_load_acquire(&inode->i_crypt_info);
193 }
194
195 /**
196 * fscrypt_needs_contents_encryption() - check whether an inode needs
197 * contents encryption
198 * @inode: the inode to check
199 *
200 * Return: %true iff the inode is an encrypted regular file and the kernel was
201 * built with fscrypt support.
202 *
203 * If you need to know whether the encrypt bit is set even when the kernel was
204 * built without fscrypt support, you must use IS_ENCRYPTED() directly instead.
205 */
fscrypt_needs_contents_encryption(const struct inode * inode)206 static inline bool fscrypt_needs_contents_encryption(const struct inode *inode)
207 {
208 return IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode);
209 }
210
211 /*
212 * When d_splice_alias() moves a directory's no-key alias to its plaintext alias
213 * as a result of the encryption key being added, DCACHE_NOKEY_NAME must be
214 * cleared. Note that we don't have to support arbitrary moves of this flag
215 * because fscrypt doesn't allow no-key names to be the source or target of a
216 * rename().
217 */
fscrypt_handle_d_move(struct dentry * dentry)218 static inline void fscrypt_handle_d_move(struct dentry *dentry)
219 {
220 dentry->d_flags &= ~DCACHE_NOKEY_NAME;
221 }
222
223 /**
224 * fscrypt_is_nokey_name() - test whether a dentry is a no-key name
225 * @dentry: the dentry to check
226 *
227 * This returns true if the dentry is a no-key dentry. A no-key dentry is a
228 * dentry that was created in an encrypted directory that hasn't had its
229 * encryption key added yet. Such dentries may be either positive or negative.
230 *
231 * When a filesystem is asked to create a new filename in an encrypted directory
232 * and the new filename's dentry is a no-key dentry, it must fail the operation
233 * with ENOKEY. This includes ->create(), ->mkdir(), ->mknod(), ->symlink(),
234 * ->rename(), and ->link(). (However, ->rename() and ->link() are already
235 * handled by fscrypt_prepare_rename() and fscrypt_prepare_link().)
236 *
237 * This is necessary because creating a filename requires the directory's
238 * encryption key, but just checking for the key on the directory inode during
239 * the final filesystem operation doesn't guarantee that the key was available
240 * during the preceding dentry lookup. And the key must have already been
241 * available during the dentry lookup in order for it to have been checked
242 * whether the filename already exists in the directory and for the new file's
243 * dentry not to be invalidated due to it incorrectly having the no-key flag.
244 *
245 * Return: %true if the dentry is a no-key name
246 */
fscrypt_is_nokey_name(const struct dentry * dentry)247 static inline bool fscrypt_is_nokey_name(const struct dentry *dentry)
248 {
249 return dentry->d_flags & DCACHE_NOKEY_NAME;
250 }
251
252 /* crypto.c */
253 void fscrypt_enqueue_decrypt_work(struct work_struct *);
254
255 struct page *fscrypt_encrypt_pagecache_blocks(struct page *page,
256 unsigned int len,
257 unsigned int offs,
258 gfp_t gfp_flags);
259 int fscrypt_encrypt_block_inplace(const struct inode *inode, struct page *page,
260 unsigned int len, unsigned int offs,
261 u64 lblk_num, gfp_t gfp_flags);
262
263 int fscrypt_decrypt_pagecache_blocks(struct page *page, unsigned int len,
264 unsigned int offs);
265 int fscrypt_decrypt_block_inplace(const struct inode *inode, struct page *page,
266 unsigned int len, unsigned int offs,
267 u64 lblk_num);
268
fscrypt_is_bounce_page(struct page * page)269 static inline bool fscrypt_is_bounce_page(struct page *page)
270 {
271 return page->mapping == NULL;
272 }
273
fscrypt_pagecache_page(struct page * bounce_page)274 static inline struct page *fscrypt_pagecache_page(struct page *bounce_page)
275 {
276 return (struct page *)page_private(bounce_page);
277 }
278
279 void fscrypt_free_bounce_page(struct page *bounce_page);
280
281 /* policy.c */
282 int fscrypt_ioctl_set_policy(struct file *filp, const void __user *arg);
283 int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg);
284 int fscrypt_ioctl_get_policy_ex(struct file *filp, void __user *arg);
285 int fscrypt_ioctl_get_nonce(struct file *filp, void __user *arg);
286 int fscrypt_has_permitted_context(struct inode *parent, struct inode *child);
287 int fscrypt_set_context(struct inode *inode, void *fs_data);
288
289 struct fscrypt_dummy_policy {
290 const union fscrypt_policy *policy;
291 };
292
293 int fscrypt_parse_test_dummy_encryption(const struct fs_parameter *param,
294 struct fscrypt_dummy_policy *dummy_policy);
295 bool fscrypt_dummy_policies_equal(const struct fscrypt_dummy_policy *p1,
296 const struct fscrypt_dummy_policy *p2);
297 int fscrypt_set_test_dummy_encryption(struct super_block *sb, const char *arg,
298 struct fscrypt_dummy_policy *dummy_policy);
299 void fscrypt_show_test_dummy_encryption(struct seq_file *seq, char sep,
300 struct super_block *sb);
301 static inline bool
fscrypt_is_dummy_policy_set(const struct fscrypt_dummy_policy * dummy_policy)302 fscrypt_is_dummy_policy_set(const struct fscrypt_dummy_policy *dummy_policy)
303 {
304 return dummy_policy->policy != NULL;
305 }
306 static inline void
fscrypt_free_dummy_policy(struct fscrypt_dummy_policy * dummy_policy)307 fscrypt_free_dummy_policy(struct fscrypt_dummy_policy *dummy_policy)
308 {
309 kfree(dummy_policy->policy);
310 dummy_policy->policy = NULL;
311 }
312
313 /* keyring.c */
314 void fscrypt_sb_free(struct super_block *sb);
315 int fscrypt_ioctl_add_key(struct file *filp, void __user *arg);
316 int fscrypt_add_test_dummy_key(struct super_block *sb,
317 const struct fscrypt_dummy_policy *dummy_policy);
318 int fscrypt_ioctl_remove_key(struct file *filp, void __user *arg);
319 int fscrypt_ioctl_remove_key_all_users(struct file *filp, void __user *arg);
320 int fscrypt_ioctl_get_key_status(struct file *filp, void __user *arg);
321
322 /* keysetup.c */
323 int fscrypt_prepare_new_inode(struct inode *dir, struct inode *inode,
324 bool *encrypt_ret);
325 void fscrypt_put_encryption_info(struct inode *inode);
326 void fscrypt_free_inode(struct inode *inode);
327 int fscrypt_drop_inode(struct inode *inode);
328
329 /* fname.c */
330 int fscrypt_setup_filename(struct inode *inode, const struct qstr *iname,
331 int lookup, struct fscrypt_name *fname);
332
fscrypt_free_filename(struct fscrypt_name * fname)333 static inline void fscrypt_free_filename(struct fscrypt_name *fname)
334 {
335 kfree(fname->crypto_buf.name);
336 }
337
338 int fscrypt_fname_alloc_buffer(u32 max_encrypted_len,
339 struct fscrypt_str *crypto_str);
340 void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str);
341 int fscrypt_fname_disk_to_usr(const struct inode *inode,
342 u32 hash, u32 minor_hash,
343 const struct fscrypt_str *iname,
344 struct fscrypt_str *oname);
345 bool fscrypt_match_name(const struct fscrypt_name *fname,
346 const u8 *de_name, u32 de_name_len);
347 u64 fscrypt_fname_siphash(const struct inode *dir, const struct qstr *name);
348 int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags);
349
350 /* bio.c */
351 void fscrypt_decrypt_bio(struct bio *bio);
352 int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
353 sector_t pblk, unsigned int len);
354
355 /* hooks.c */
356 int fscrypt_file_open(struct inode *inode, struct file *filp);
357 int __fscrypt_prepare_link(struct inode *inode, struct inode *dir,
358 struct dentry *dentry);
359 int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry,
360 struct inode *new_dir, struct dentry *new_dentry,
361 unsigned int flags);
362 int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry,
363 struct fscrypt_name *fname);
364 int __fscrypt_prepare_readdir(struct inode *dir);
365 int __fscrypt_prepare_setattr(struct dentry *dentry, struct iattr *attr);
366 int fscrypt_prepare_setflags(struct inode *inode,
367 unsigned int oldflags, unsigned int flags);
368 int fscrypt_prepare_symlink(struct inode *dir, const char *target,
369 unsigned int len, unsigned int max_len,
370 struct fscrypt_str *disk_link);
371 int __fscrypt_encrypt_symlink(struct inode *inode, const char *target,
372 unsigned int len, struct fscrypt_str *disk_link);
373 const char *fscrypt_get_symlink(struct inode *inode, const void *caddr,
374 unsigned int max_size,
375 struct delayed_call *done);
376 int fscrypt_symlink_getattr(const struct path *path, struct kstat *stat);
fscrypt_set_ops(struct super_block * sb,const struct fscrypt_operations * s_cop)377 static inline void fscrypt_set_ops(struct super_block *sb,
378 const struct fscrypt_operations *s_cop)
379 {
380 sb->s_cop = s_cop;
381 }
382 #else /* !CONFIG_FS_ENCRYPTION */
383
fscrypt_get_info(const struct inode * inode)384 static inline struct fscrypt_info *fscrypt_get_info(const struct inode *inode)
385 {
386 return NULL;
387 }
388
fscrypt_needs_contents_encryption(const struct inode * inode)389 static inline bool fscrypt_needs_contents_encryption(const struct inode *inode)
390 {
391 return false;
392 }
393
fscrypt_handle_d_move(struct dentry * dentry)394 static inline void fscrypt_handle_d_move(struct dentry *dentry)
395 {
396 }
397
fscrypt_is_nokey_name(const struct dentry * dentry)398 static inline bool fscrypt_is_nokey_name(const struct dentry *dentry)
399 {
400 return false;
401 }
402
403 /* crypto.c */
fscrypt_enqueue_decrypt_work(struct work_struct * work)404 static inline void fscrypt_enqueue_decrypt_work(struct work_struct *work)
405 {
406 }
407
fscrypt_encrypt_pagecache_blocks(struct page * page,unsigned int len,unsigned int offs,gfp_t gfp_flags)408 static inline struct page *fscrypt_encrypt_pagecache_blocks(struct page *page,
409 unsigned int len,
410 unsigned int offs,
411 gfp_t gfp_flags)
412 {
413 return ERR_PTR(-EOPNOTSUPP);
414 }
415
fscrypt_encrypt_block_inplace(const struct inode * inode,struct page * page,unsigned int len,unsigned int offs,u64 lblk_num,gfp_t gfp_flags)416 static inline int fscrypt_encrypt_block_inplace(const struct inode *inode,
417 struct page *page,
418 unsigned int len,
419 unsigned int offs, u64 lblk_num,
420 gfp_t gfp_flags)
421 {
422 return -EOPNOTSUPP;
423 }
424
fscrypt_decrypt_pagecache_blocks(struct page * page,unsigned int len,unsigned int offs)425 static inline int fscrypt_decrypt_pagecache_blocks(struct page *page,
426 unsigned int len,
427 unsigned int offs)
428 {
429 return -EOPNOTSUPP;
430 }
431
fscrypt_decrypt_block_inplace(const struct inode * inode,struct page * page,unsigned int len,unsigned int offs,u64 lblk_num)432 static inline int fscrypt_decrypt_block_inplace(const struct inode *inode,
433 struct page *page,
434 unsigned int len,
435 unsigned int offs, u64 lblk_num)
436 {
437 return -EOPNOTSUPP;
438 }
439
fscrypt_is_bounce_page(struct page * page)440 static inline bool fscrypt_is_bounce_page(struct page *page)
441 {
442 return false;
443 }
444
fscrypt_pagecache_page(struct page * bounce_page)445 static inline struct page *fscrypt_pagecache_page(struct page *bounce_page)
446 {
447 WARN_ON_ONCE(1);
448 return ERR_PTR(-EINVAL);
449 }
450
fscrypt_free_bounce_page(struct page * bounce_page)451 static inline void fscrypt_free_bounce_page(struct page *bounce_page)
452 {
453 }
454
455 /* policy.c */
fscrypt_ioctl_set_policy(struct file * filp,const void __user * arg)456 static inline int fscrypt_ioctl_set_policy(struct file *filp,
457 const void __user *arg)
458 {
459 return -EOPNOTSUPP;
460 }
461
fscrypt_ioctl_get_policy(struct file * filp,void __user * arg)462 static inline int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg)
463 {
464 return -EOPNOTSUPP;
465 }
466
fscrypt_ioctl_get_policy_ex(struct file * filp,void __user * arg)467 static inline int fscrypt_ioctl_get_policy_ex(struct file *filp,
468 void __user *arg)
469 {
470 return -EOPNOTSUPP;
471 }
472
fscrypt_ioctl_get_nonce(struct file * filp,void __user * arg)473 static inline int fscrypt_ioctl_get_nonce(struct file *filp, void __user *arg)
474 {
475 return -EOPNOTSUPP;
476 }
477
fscrypt_has_permitted_context(struct inode * parent,struct inode * child)478 static inline int fscrypt_has_permitted_context(struct inode *parent,
479 struct inode *child)
480 {
481 return 0;
482 }
483
fscrypt_set_context(struct inode * inode,void * fs_data)484 static inline int fscrypt_set_context(struct inode *inode, void *fs_data)
485 {
486 return -EOPNOTSUPP;
487 }
488
489 struct fscrypt_dummy_policy {
490 };
491
492 static inline int
fscrypt_parse_test_dummy_encryption(const struct fs_parameter * param,struct fscrypt_dummy_policy * dummy_policy)493 fscrypt_parse_test_dummy_encryption(const struct fs_parameter *param,
494 struct fscrypt_dummy_policy *dummy_policy)
495 {
496 return -EINVAL;
497 }
498
499 static inline bool
fscrypt_dummy_policies_equal(const struct fscrypt_dummy_policy * p1,const struct fscrypt_dummy_policy * p2)500 fscrypt_dummy_policies_equal(const struct fscrypt_dummy_policy *p1,
501 const struct fscrypt_dummy_policy *p2)
502 {
503 return true;
504 }
505
fscrypt_show_test_dummy_encryption(struct seq_file * seq,char sep,struct super_block * sb)506 static inline void fscrypt_show_test_dummy_encryption(struct seq_file *seq,
507 char sep,
508 struct super_block *sb)
509 {
510 }
511
512 static inline bool
fscrypt_is_dummy_policy_set(const struct fscrypt_dummy_policy * dummy_policy)513 fscrypt_is_dummy_policy_set(const struct fscrypt_dummy_policy *dummy_policy)
514 {
515 return false;
516 }
517
518 static inline void
fscrypt_free_dummy_policy(struct fscrypt_dummy_policy * dummy_policy)519 fscrypt_free_dummy_policy(struct fscrypt_dummy_policy *dummy_policy)
520 {
521 }
522
523 /* keyring.c */
fscrypt_sb_free(struct super_block * sb)524 static inline void fscrypt_sb_free(struct super_block *sb)
525 {
526 }
527
fscrypt_ioctl_add_key(struct file * filp,void __user * arg)528 static inline int fscrypt_ioctl_add_key(struct file *filp, void __user *arg)
529 {
530 return -EOPNOTSUPP;
531 }
532
533 static inline int
fscrypt_add_test_dummy_key(struct super_block * sb,const struct fscrypt_dummy_policy * dummy_policy)534 fscrypt_add_test_dummy_key(struct super_block *sb,
535 const struct fscrypt_dummy_policy *dummy_policy)
536 {
537 return 0;
538 }
539
fscrypt_ioctl_remove_key(struct file * filp,void __user * arg)540 static inline int fscrypt_ioctl_remove_key(struct file *filp, void __user *arg)
541 {
542 return -EOPNOTSUPP;
543 }
544
fscrypt_ioctl_remove_key_all_users(struct file * filp,void __user * arg)545 static inline int fscrypt_ioctl_remove_key_all_users(struct file *filp,
546 void __user *arg)
547 {
548 return -EOPNOTSUPP;
549 }
550
fscrypt_ioctl_get_key_status(struct file * filp,void __user * arg)551 static inline int fscrypt_ioctl_get_key_status(struct file *filp,
552 void __user *arg)
553 {
554 return -EOPNOTSUPP;
555 }
556
557 /* keysetup.c */
558
fscrypt_prepare_new_inode(struct inode * dir,struct inode * inode,bool * encrypt_ret)559 static inline int fscrypt_prepare_new_inode(struct inode *dir,
560 struct inode *inode,
561 bool *encrypt_ret)
562 {
563 if (IS_ENCRYPTED(dir))
564 return -EOPNOTSUPP;
565 return 0;
566 }
567
fscrypt_put_encryption_info(struct inode * inode)568 static inline void fscrypt_put_encryption_info(struct inode *inode)
569 {
570 return;
571 }
572
fscrypt_free_inode(struct inode * inode)573 static inline void fscrypt_free_inode(struct inode *inode)
574 {
575 }
576
fscrypt_drop_inode(struct inode * inode)577 static inline int fscrypt_drop_inode(struct inode *inode)
578 {
579 return 0;
580 }
581
582 /* fname.c */
fscrypt_setup_filename(struct inode * dir,const struct qstr * iname,int lookup,struct fscrypt_name * fname)583 static inline int fscrypt_setup_filename(struct inode *dir,
584 const struct qstr *iname,
585 int lookup, struct fscrypt_name *fname)
586 {
587 if (IS_ENCRYPTED(dir))
588 return -EOPNOTSUPP;
589
590 memset(fname, 0, sizeof(*fname));
591 fname->usr_fname = iname;
592 fname->disk_name.name = (unsigned char *)iname->name;
593 fname->disk_name.len = iname->len;
594 return 0;
595 }
596
fscrypt_free_filename(struct fscrypt_name * fname)597 static inline void fscrypt_free_filename(struct fscrypt_name *fname)
598 {
599 return;
600 }
601
fscrypt_fname_alloc_buffer(u32 max_encrypted_len,struct fscrypt_str * crypto_str)602 static inline int fscrypt_fname_alloc_buffer(u32 max_encrypted_len,
603 struct fscrypt_str *crypto_str)
604 {
605 return -EOPNOTSUPP;
606 }
607
fscrypt_fname_free_buffer(struct fscrypt_str * crypto_str)608 static inline void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str)
609 {
610 return;
611 }
612
fscrypt_fname_disk_to_usr(const struct inode * inode,u32 hash,u32 minor_hash,const struct fscrypt_str * iname,struct fscrypt_str * oname)613 static inline int fscrypt_fname_disk_to_usr(const struct inode *inode,
614 u32 hash, u32 minor_hash,
615 const struct fscrypt_str *iname,
616 struct fscrypt_str *oname)
617 {
618 return -EOPNOTSUPP;
619 }
620
fscrypt_match_name(const struct fscrypt_name * fname,const u8 * de_name,u32 de_name_len)621 static inline bool fscrypt_match_name(const struct fscrypt_name *fname,
622 const u8 *de_name, u32 de_name_len)
623 {
624 /* Encryption support disabled; use standard comparison */
625 if (de_name_len != fname->disk_name.len)
626 return false;
627 return !memcmp(de_name, fname->disk_name.name, fname->disk_name.len);
628 }
629
fscrypt_fname_siphash(const struct inode * dir,const struct qstr * name)630 static inline u64 fscrypt_fname_siphash(const struct inode *dir,
631 const struct qstr *name)
632 {
633 WARN_ON_ONCE(1);
634 return 0;
635 }
636
fscrypt_d_revalidate(struct dentry * dentry,unsigned int flags)637 static inline int fscrypt_d_revalidate(struct dentry *dentry,
638 unsigned int flags)
639 {
640 return 1;
641 }
642
643 /* bio.c */
fscrypt_decrypt_bio(struct bio * bio)644 static inline void fscrypt_decrypt_bio(struct bio *bio)
645 {
646 }
647
fscrypt_zeroout_range(const struct inode * inode,pgoff_t lblk,sector_t pblk,unsigned int len)648 static inline int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
649 sector_t pblk, unsigned int len)
650 {
651 return -EOPNOTSUPP;
652 }
653
654 /* hooks.c */
655
fscrypt_file_open(struct inode * inode,struct file * filp)656 static inline int fscrypt_file_open(struct inode *inode, struct file *filp)
657 {
658 if (IS_ENCRYPTED(inode))
659 return -EOPNOTSUPP;
660 return 0;
661 }
662
__fscrypt_prepare_link(struct inode * inode,struct inode * dir,struct dentry * dentry)663 static inline int __fscrypt_prepare_link(struct inode *inode, struct inode *dir,
664 struct dentry *dentry)
665 {
666 return -EOPNOTSUPP;
667 }
668
__fscrypt_prepare_rename(struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)669 static inline int __fscrypt_prepare_rename(struct inode *old_dir,
670 struct dentry *old_dentry,
671 struct inode *new_dir,
672 struct dentry *new_dentry,
673 unsigned int flags)
674 {
675 return -EOPNOTSUPP;
676 }
677
__fscrypt_prepare_lookup(struct inode * dir,struct dentry * dentry,struct fscrypt_name * fname)678 static inline int __fscrypt_prepare_lookup(struct inode *dir,
679 struct dentry *dentry,
680 struct fscrypt_name *fname)
681 {
682 return -EOPNOTSUPP;
683 }
684
__fscrypt_prepare_readdir(struct inode * dir)685 static inline int __fscrypt_prepare_readdir(struct inode *dir)
686 {
687 return -EOPNOTSUPP;
688 }
689
__fscrypt_prepare_setattr(struct dentry * dentry,struct iattr * attr)690 static inline int __fscrypt_prepare_setattr(struct dentry *dentry,
691 struct iattr *attr)
692 {
693 return -EOPNOTSUPP;
694 }
695
fscrypt_prepare_setflags(struct inode * inode,unsigned int oldflags,unsigned int flags)696 static inline int fscrypt_prepare_setflags(struct inode *inode,
697 unsigned int oldflags,
698 unsigned int flags)
699 {
700 return 0;
701 }
702
fscrypt_prepare_symlink(struct inode * dir,const char * target,unsigned int len,unsigned int max_len,struct fscrypt_str * disk_link)703 static inline int fscrypt_prepare_symlink(struct inode *dir,
704 const char *target,
705 unsigned int len,
706 unsigned int max_len,
707 struct fscrypt_str *disk_link)
708 {
709 if (IS_ENCRYPTED(dir))
710 return -EOPNOTSUPP;
711 disk_link->name = (unsigned char *)target;
712 disk_link->len = len + 1;
713 if (disk_link->len > max_len)
714 return -ENAMETOOLONG;
715 return 0;
716 }
717
__fscrypt_encrypt_symlink(struct inode * inode,const char * target,unsigned int len,struct fscrypt_str * disk_link)718 static inline int __fscrypt_encrypt_symlink(struct inode *inode,
719 const char *target,
720 unsigned int len,
721 struct fscrypt_str *disk_link)
722 {
723 return -EOPNOTSUPP;
724 }
725
fscrypt_get_symlink(struct inode * inode,const void * caddr,unsigned int max_size,struct delayed_call * done)726 static inline const char *fscrypt_get_symlink(struct inode *inode,
727 const void *caddr,
728 unsigned int max_size,
729 struct delayed_call *done)
730 {
731 return ERR_PTR(-EOPNOTSUPP);
732 }
733
fscrypt_symlink_getattr(const struct path * path,struct kstat * stat)734 static inline int fscrypt_symlink_getattr(const struct path *path,
735 struct kstat *stat)
736 {
737 return -EOPNOTSUPP;
738 }
739
fscrypt_set_ops(struct super_block * sb,const struct fscrypt_operations * s_cop)740 static inline void fscrypt_set_ops(struct super_block *sb,
741 const struct fscrypt_operations *s_cop)
742 {
743 }
744
745 #endif /* !CONFIG_FS_ENCRYPTION */
746
747 /* inline_crypt.c */
748 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
749
750 bool __fscrypt_inode_uses_inline_crypto(const struct inode *inode);
751
752 void fscrypt_set_bio_crypt_ctx(struct bio *bio,
753 const struct inode *inode, u64 first_lblk,
754 gfp_t gfp_mask);
755
756 void fscrypt_set_bio_crypt_ctx_bh(struct bio *bio,
757 const struct buffer_head *first_bh,
758 gfp_t gfp_mask);
759
760 bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
761 u64 next_lblk);
762
763 bool fscrypt_mergeable_bio_bh(struct bio *bio,
764 const struct buffer_head *next_bh);
765
766 bool fscrypt_dio_supported(struct kiocb *iocb, struct iov_iter *iter);
767
768 u64 fscrypt_limit_io_blocks(const struct inode *inode, u64 lblk, u64 nr_blocks);
769
770 #else /* CONFIG_FS_ENCRYPTION_INLINE_CRYPT */
771
__fscrypt_inode_uses_inline_crypto(const struct inode * inode)772 static inline bool __fscrypt_inode_uses_inline_crypto(const struct inode *inode)
773 {
774 return false;
775 }
776
fscrypt_set_bio_crypt_ctx(struct bio * bio,const struct inode * inode,u64 first_lblk,gfp_t gfp_mask)777 static inline void fscrypt_set_bio_crypt_ctx(struct bio *bio,
778 const struct inode *inode,
779 u64 first_lblk, gfp_t gfp_mask) { }
780
fscrypt_set_bio_crypt_ctx_bh(struct bio * bio,const struct buffer_head * first_bh,gfp_t gfp_mask)781 static inline void fscrypt_set_bio_crypt_ctx_bh(
782 struct bio *bio,
783 const struct buffer_head *first_bh,
784 gfp_t gfp_mask) { }
785
fscrypt_mergeable_bio(struct bio * bio,const struct inode * inode,u64 next_lblk)786 static inline bool fscrypt_mergeable_bio(struct bio *bio,
787 const struct inode *inode,
788 u64 next_lblk)
789 {
790 return true;
791 }
792
fscrypt_mergeable_bio_bh(struct bio * bio,const struct buffer_head * next_bh)793 static inline bool fscrypt_mergeable_bio_bh(struct bio *bio,
794 const struct buffer_head *next_bh)
795 {
796 return true;
797 }
798
fscrypt_dio_supported(struct kiocb * iocb,struct iov_iter * iter)799 static inline bool fscrypt_dio_supported(struct kiocb *iocb,
800 struct iov_iter *iter)
801 {
802 const struct inode *inode = file_inode(iocb->ki_filp);
803
804 return !fscrypt_needs_contents_encryption(inode);
805 }
806
fscrypt_limit_io_blocks(const struct inode * inode,u64 lblk,u64 nr_blocks)807 static inline u64 fscrypt_limit_io_blocks(const struct inode *inode, u64 lblk,
808 u64 nr_blocks)
809 {
810 return nr_blocks;
811 }
812 #endif /* !CONFIG_FS_ENCRYPTION_INLINE_CRYPT */
813
814 /**
815 * fscrypt_inode_uses_inline_crypto() - test whether an inode uses inline
816 * encryption
817 * @inode: an inode. If encrypted, its key must be set up.
818 *
819 * Return: true if the inode requires file contents encryption and if the
820 * encryption should be done in the block layer via blk-crypto rather
821 * than in the filesystem layer.
822 */
fscrypt_inode_uses_inline_crypto(const struct inode * inode)823 static inline bool fscrypt_inode_uses_inline_crypto(const struct inode *inode)
824 {
825 return fscrypt_needs_contents_encryption(inode) &&
826 __fscrypt_inode_uses_inline_crypto(inode);
827 }
828
829 /**
830 * fscrypt_inode_uses_fs_layer_crypto() - test whether an inode uses fs-layer
831 * encryption
832 * @inode: an inode. If encrypted, its key must be set up.
833 *
834 * Return: true if the inode requires file contents encryption and if the
835 * encryption should be done in the filesystem layer rather than in the
836 * block layer via blk-crypto.
837 */
fscrypt_inode_uses_fs_layer_crypto(const struct inode * inode)838 static inline bool fscrypt_inode_uses_fs_layer_crypto(const struct inode *inode)
839 {
840 return fscrypt_needs_contents_encryption(inode) &&
841 !__fscrypt_inode_uses_inline_crypto(inode);
842 }
843
844 /**
845 * fscrypt_has_encryption_key() - check whether an inode has had its key set up
846 * @inode: the inode to check
847 *
848 * Return: %true if the inode has had its encryption key set up, else %false.
849 *
850 * Usually this should be preceded by fscrypt_get_encryption_info() to try to
851 * set up the key first.
852 */
fscrypt_has_encryption_key(const struct inode * inode)853 static inline bool fscrypt_has_encryption_key(const struct inode *inode)
854 {
855 return fscrypt_get_info(inode) != NULL;
856 }
857
858 /**
859 * fscrypt_prepare_link() - prepare to link an inode into a possibly-encrypted
860 * directory
861 * @old_dentry: an existing dentry for the inode being linked
862 * @dir: the target directory
863 * @dentry: negative dentry for the target filename
864 *
865 * A new link can only be added to an encrypted directory if the directory's
866 * encryption key is available --- since otherwise we'd have no way to encrypt
867 * the filename.
868 *
869 * We also verify that the link will not violate the constraint that all files
870 * in an encrypted directory tree use the same encryption policy.
871 *
872 * Return: 0 on success, -ENOKEY if the directory's encryption key is missing,
873 * -EXDEV if the link would result in an inconsistent encryption policy, or
874 * another -errno code.
875 */
fscrypt_prepare_link(struct dentry * old_dentry,struct inode * dir,struct dentry * dentry)876 static inline int fscrypt_prepare_link(struct dentry *old_dentry,
877 struct inode *dir,
878 struct dentry *dentry)
879 {
880 if (IS_ENCRYPTED(dir))
881 return __fscrypt_prepare_link(d_inode(old_dentry), dir, dentry);
882 return 0;
883 }
884
885 /**
886 * fscrypt_prepare_rename() - prepare for a rename between possibly-encrypted
887 * directories
888 * @old_dir: source directory
889 * @old_dentry: dentry for source file
890 * @new_dir: target directory
891 * @new_dentry: dentry for target location (may be negative unless exchanging)
892 * @flags: rename flags (we care at least about %RENAME_EXCHANGE)
893 *
894 * Prepare for ->rename() where the source and/or target directories may be
895 * encrypted. A new link can only be added to an encrypted directory if the
896 * directory's encryption key is available --- since otherwise we'd have no way
897 * to encrypt the filename. A rename to an existing name, on the other hand,
898 * *is* cryptographically possible without the key. However, we take the more
899 * conservative approach and just forbid all no-key renames.
900 *
901 * We also verify that the rename will not violate the constraint that all files
902 * in an encrypted directory tree use the same encryption policy.
903 *
904 * Return: 0 on success, -ENOKEY if an encryption key is missing, -EXDEV if the
905 * rename would cause inconsistent encryption policies, or another -errno code.
906 */
fscrypt_prepare_rename(struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)907 static inline int fscrypt_prepare_rename(struct inode *old_dir,
908 struct dentry *old_dentry,
909 struct inode *new_dir,
910 struct dentry *new_dentry,
911 unsigned int flags)
912 {
913 if (IS_ENCRYPTED(old_dir) || IS_ENCRYPTED(new_dir))
914 return __fscrypt_prepare_rename(old_dir, old_dentry,
915 new_dir, new_dentry, flags);
916 return 0;
917 }
918
919 /**
920 * fscrypt_prepare_lookup() - prepare to lookup a name in a possibly-encrypted
921 * directory
922 * @dir: directory being searched
923 * @dentry: filename being looked up
924 * @fname: (output) the name to use to search the on-disk directory
925 *
926 * Prepare for ->lookup() in a directory which may be encrypted by determining
927 * the name that will actually be used to search the directory on-disk. If the
928 * directory's encryption policy is supported by this kernel and its encryption
929 * key is available, then the lookup is assumed to be by plaintext name;
930 * otherwise, it is assumed to be by no-key name.
931 *
932 * This will set DCACHE_NOKEY_NAME on the dentry if the lookup is by no-key
933 * name. In this case the filesystem must assign the dentry a dentry_operations
934 * which contains fscrypt_d_revalidate (or contains a d_revalidate method that
935 * calls fscrypt_d_revalidate), so that the dentry will be invalidated if the
936 * directory's encryption key is later added.
937 *
938 * Return: 0 on success; -ENOENT if the directory's key is unavailable but the
939 * filename isn't a valid no-key name, so a negative dentry should be created;
940 * or another -errno code.
941 */
fscrypt_prepare_lookup(struct inode * dir,struct dentry * dentry,struct fscrypt_name * fname)942 static inline int fscrypt_prepare_lookup(struct inode *dir,
943 struct dentry *dentry,
944 struct fscrypt_name *fname)
945 {
946 if (IS_ENCRYPTED(dir))
947 return __fscrypt_prepare_lookup(dir, dentry, fname);
948
949 memset(fname, 0, sizeof(*fname));
950 fname->usr_fname = &dentry->d_name;
951 fname->disk_name.name = (unsigned char *)dentry->d_name.name;
952 fname->disk_name.len = dentry->d_name.len;
953 return 0;
954 }
955
956 /**
957 * fscrypt_prepare_readdir() - prepare to read a possibly-encrypted directory
958 * @dir: the directory inode
959 *
960 * If the directory is encrypted and it doesn't already have its encryption key
961 * set up, try to set it up so that the filenames will be listed in plaintext
962 * form rather than in no-key form.
963 *
964 * Return: 0 on success; -errno on error. Note that the encryption key being
965 * unavailable is not considered an error. It is also not an error if
966 * the encryption policy is unsupported by this kernel; that is treated
967 * like the key being unavailable, so that files can still be deleted.
968 */
fscrypt_prepare_readdir(struct inode * dir)969 static inline int fscrypt_prepare_readdir(struct inode *dir)
970 {
971 if (IS_ENCRYPTED(dir))
972 return __fscrypt_prepare_readdir(dir);
973 return 0;
974 }
975
976 /**
977 * fscrypt_prepare_setattr() - prepare to change a possibly-encrypted inode's
978 * attributes
979 * @dentry: dentry through which the inode is being changed
980 * @attr: attributes to change
981 *
982 * Prepare for ->setattr() on a possibly-encrypted inode. On an encrypted file,
983 * most attribute changes are allowed even without the encryption key. However,
984 * without the encryption key we do have to forbid truncates. This is needed
985 * because the size being truncated to may not be a multiple of the filesystem
986 * block size, and in that case we'd have to decrypt the final block, zero the
987 * portion past i_size, and re-encrypt it. (We *could* allow truncating to a
988 * filesystem block boundary, but it's simpler to just forbid all truncates ---
989 * and we already forbid all other contents modifications without the key.)
990 *
991 * Return: 0 on success, -ENOKEY if the key is missing, or another -errno code
992 * if a problem occurred while setting up the encryption key.
993 */
fscrypt_prepare_setattr(struct dentry * dentry,struct iattr * attr)994 static inline int fscrypt_prepare_setattr(struct dentry *dentry,
995 struct iattr *attr)
996 {
997 if (IS_ENCRYPTED(d_inode(dentry)))
998 return __fscrypt_prepare_setattr(dentry, attr);
999 return 0;
1000 }
1001
1002 /**
1003 * fscrypt_encrypt_symlink() - encrypt the symlink target if needed
1004 * @inode: symlink inode
1005 * @target: plaintext symlink target
1006 * @len: length of @target excluding null terminator
1007 * @disk_link: (in/out) the on-disk symlink target being prepared
1008 *
1009 * If the symlink target needs to be encrypted, then this function encrypts it
1010 * into @disk_link->name. fscrypt_prepare_symlink() must have been called
1011 * previously to compute @disk_link->len. If the filesystem did not allocate a
1012 * buffer for @disk_link->name after calling fscrypt_prepare_link(), then one
1013 * will be kmalloc()'ed and the filesystem will be responsible for freeing it.
1014 *
1015 * Return: 0 on success, -errno on failure
1016 */
fscrypt_encrypt_symlink(struct inode * inode,const char * target,unsigned int len,struct fscrypt_str * disk_link)1017 static inline int fscrypt_encrypt_symlink(struct inode *inode,
1018 const char *target,
1019 unsigned int len,
1020 struct fscrypt_str *disk_link)
1021 {
1022 if (IS_ENCRYPTED(inode))
1023 return __fscrypt_encrypt_symlink(inode, target, len, disk_link);
1024 return 0;
1025 }
1026
1027 /* If *pagep is a bounce page, free it and set *pagep to the pagecache page */
fscrypt_finalize_bounce_page(struct page ** pagep)1028 static inline void fscrypt_finalize_bounce_page(struct page **pagep)
1029 {
1030 struct page *page = *pagep;
1031
1032 if (fscrypt_is_bounce_page(page)) {
1033 *pagep = fscrypt_pagecache_page(page);
1034 fscrypt_free_bounce_page(page);
1035 }
1036 }
1037
1038 #endif /* _LINUX_FSCRYPT_H */
1039