Line data Source code
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 : #define FS_CRYPTO_BLOCK_SIZE 16
22 :
23 : union fscrypt_policy;
24 : struct fscrypt_info;
25 : struct seq_file;
26 :
27 : struct fscrypt_str {
28 : unsigned char *name;
29 : u32 len;
30 : };
31 :
32 : struct fscrypt_name {
33 : const struct qstr *usr_fname;
34 : struct fscrypt_str disk_name;
35 : u32 hash;
36 : u32 minor_hash;
37 : struct fscrypt_str crypto_buf;
38 : bool is_nokey_name;
39 : };
40 :
41 : #define FSTR_INIT(n, l) { .name = n, .len = l }
42 : #define FSTR_TO_QSTR(f) QSTR_INIT((f)->name, (f)->len)
43 : #define fname_name(p) ((p)->disk_name.name)
44 : #define fname_len(p) ((p)->disk_name.len)
45 :
46 : /* Maximum value for the third parameter of fscrypt_operations.set_context(). */
47 : #define FSCRYPT_SET_CONTEXT_MAX_SIZE 40
48 :
49 : #ifdef CONFIG_FS_ENCRYPTION
50 : /*
51 : * fscrypt superblock flags
52 : */
53 : #define FS_CFLG_OWN_PAGES (1U << 1)
54 :
55 : /*
56 : * crypto operations for filesystems
57 : */
58 : struct fscrypt_operations {
59 : unsigned int flags;
60 : const char *key_prefix;
61 : int (*get_context)(struct inode *inode, void *ctx, size_t len);
62 : int (*set_context)(struct inode *inode, const void *ctx, size_t len,
63 : void *fs_data);
64 : const union fscrypt_policy *(*get_dummy_policy)(struct super_block *sb);
65 : bool (*empty_dir)(struct inode *inode);
66 : unsigned int max_namelen;
67 : bool (*has_stable_inodes)(struct super_block *sb);
68 : void (*get_ino_and_lblk_bits)(struct super_block *sb,
69 : int *ino_bits_ret, int *lblk_bits_ret);
70 : int (*get_num_devices)(struct super_block *sb);
71 : void (*get_devices)(struct super_block *sb,
72 : struct request_queue **devs);
73 : };
74 :
75 : static inline struct fscrypt_info *fscrypt_get_info(const struct inode *inode)
76 : {
77 : /*
78 : * Pairs with the cmpxchg_release() in fscrypt_setup_encryption_info().
79 : * I.e., another task may publish ->i_crypt_info concurrently, executing
80 : * a RELEASE barrier. We need to use smp_load_acquire() here to safely
81 : * ACQUIRE the memory the other task published.
82 : */
83 : return smp_load_acquire(&inode->i_crypt_info);
84 : }
85 :
86 : /**
87 : * fscrypt_needs_contents_encryption() - check whether an inode needs
88 : * contents encryption
89 : * @inode: the inode to check
90 : *
91 : * Return: %true iff the inode is an encrypted regular file and the kernel was
92 : * built with fscrypt support.
93 : *
94 : * If you need to know whether the encrypt bit is set even when the kernel was
95 : * built without fscrypt support, you must use IS_ENCRYPTED() directly instead.
96 : */
97 : static inline bool fscrypt_needs_contents_encryption(const struct inode *inode)
98 : {
99 : return IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode);
100 : }
101 :
102 : /*
103 : * When d_splice_alias() moves a directory's no-key alias to its plaintext alias
104 : * as a result of the encryption key being added, DCACHE_NOKEY_NAME must be
105 : * cleared. Note that we don't have to support arbitrary moves of this flag
106 : * because fscrypt doesn't allow no-key names to be the source or target of a
107 : * rename().
108 : */
109 : static inline void fscrypt_handle_d_move(struct dentry *dentry)
110 : {
111 : dentry->d_flags &= ~DCACHE_NOKEY_NAME;
112 : }
113 :
114 : /**
115 : * fscrypt_is_nokey_name() - test whether a dentry is a no-key name
116 : * @dentry: the dentry to check
117 : *
118 : * This returns true if the dentry is a no-key dentry. A no-key dentry is a
119 : * dentry that was created in an encrypted directory that hasn't had its
120 : * encryption key added yet. Such dentries may be either positive or negative.
121 : *
122 : * When a filesystem is asked to create a new filename in an encrypted directory
123 : * and the new filename's dentry is a no-key dentry, it must fail the operation
124 : * with ENOKEY. This includes ->create(), ->mkdir(), ->mknod(), ->symlink(),
125 : * ->rename(), and ->link(). (However, ->rename() and ->link() are already
126 : * handled by fscrypt_prepare_rename() and fscrypt_prepare_link().)
127 : *
128 : * This is necessary because creating a filename requires the directory's
129 : * encryption key, but just checking for the key on the directory inode during
130 : * the final filesystem operation doesn't guarantee that the key was available
131 : * during the preceding dentry lookup. And the key must have already been
132 : * available during the dentry lookup in order for it to have been checked
133 : * whether the filename already exists in the directory and for the new file's
134 : * dentry not to be invalidated due to it incorrectly having the no-key flag.
135 : *
136 : * Return: %true if the dentry is a no-key name
137 : */
138 : static inline bool fscrypt_is_nokey_name(const struct dentry *dentry)
139 : {
140 : return dentry->d_flags & DCACHE_NOKEY_NAME;
141 : }
142 :
143 : /* crypto.c */
144 : void fscrypt_enqueue_decrypt_work(struct work_struct *);
145 :
146 : struct page *fscrypt_encrypt_pagecache_blocks(struct page *page,
147 : unsigned int len,
148 : unsigned int offs,
149 : gfp_t gfp_flags);
150 : int fscrypt_encrypt_block_inplace(const struct inode *inode, struct page *page,
151 : unsigned int len, unsigned int offs,
152 : u64 lblk_num, gfp_t gfp_flags);
153 :
154 : int fscrypt_decrypt_pagecache_blocks(struct page *page, unsigned int len,
155 : unsigned int offs);
156 : int fscrypt_decrypt_block_inplace(const struct inode *inode, struct page *page,
157 : unsigned int len, unsigned int offs,
158 : u64 lblk_num);
159 :
160 : static inline bool fscrypt_is_bounce_page(struct page *page)
161 : {
162 : return page->mapping == NULL;
163 : }
164 :
165 : static inline struct page *fscrypt_pagecache_page(struct page *bounce_page)
166 : {
167 : return (struct page *)page_private(bounce_page);
168 : }
169 :
170 : void fscrypt_free_bounce_page(struct page *bounce_page);
171 :
172 : /* policy.c */
173 : int fscrypt_ioctl_set_policy(struct file *filp, const void __user *arg);
174 : int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg);
175 : int fscrypt_ioctl_get_policy_ex(struct file *filp, void __user *arg);
176 : int fscrypt_ioctl_get_nonce(struct file *filp, void __user *arg);
177 : int fscrypt_has_permitted_context(struct inode *parent, struct inode *child);
178 : int fscrypt_set_context(struct inode *inode, void *fs_data);
179 :
180 : struct fscrypt_dummy_policy {
181 : const union fscrypt_policy *policy;
182 : };
183 :
184 : int fscrypt_set_test_dummy_encryption(struct super_block *sb, const char *arg,
185 : struct fscrypt_dummy_policy *dummy_policy);
186 : void fscrypt_show_test_dummy_encryption(struct seq_file *seq, char sep,
187 : struct super_block *sb);
188 : static inline void
189 : fscrypt_free_dummy_policy(struct fscrypt_dummy_policy *dummy_policy)
190 : {
191 : kfree(dummy_policy->policy);
192 : dummy_policy->policy = NULL;
193 : }
194 :
195 : /* keyring.c */
196 : void fscrypt_sb_free(struct super_block *sb);
197 : int fscrypt_ioctl_add_key(struct file *filp, void __user *arg);
198 : int fscrypt_ioctl_remove_key(struct file *filp, void __user *arg);
199 : int fscrypt_ioctl_remove_key_all_users(struct file *filp, void __user *arg);
200 : int fscrypt_ioctl_get_key_status(struct file *filp, void __user *arg);
201 :
202 : /* keysetup.c */
203 : int fscrypt_prepare_new_inode(struct inode *dir, struct inode *inode,
204 : bool *encrypt_ret);
205 : void fscrypt_put_encryption_info(struct inode *inode);
206 : void fscrypt_free_inode(struct inode *inode);
207 : int fscrypt_drop_inode(struct inode *inode);
208 :
209 : /* fname.c */
210 : int fscrypt_setup_filename(struct inode *inode, const struct qstr *iname,
211 : int lookup, struct fscrypt_name *fname);
212 :
213 : static inline void fscrypt_free_filename(struct fscrypt_name *fname)
214 : {
215 : kfree(fname->crypto_buf.name);
216 : }
217 :
218 : int fscrypt_fname_alloc_buffer(u32 max_encrypted_len,
219 : struct fscrypt_str *crypto_str);
220 : void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str);
221 : int fscrypt_fname_disk_to_usr(const struct inode *inode,
222 : u32 hash, u32 minor_hash,
223 : const struct fscrypt_str *iname,
224 : struct fscrypt_str *oname);
225 : bool fscrypt_match_name(const struct fscrypt_name *fname,
226 : const u8 *de_name, u32 de_name_len);
227 : u64 fscrypt_fname_siphash(const struct inode *dir, const struct qstr *name);
228 : int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags);
229 :
230 : /* bio.c */
231 : void fscrypt_decrypt_bio(struct bio *bio);
232 : int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
233 : sector_t pblk, unsigned int len);
234 :
235 : /* hooks.c */
236 : int fscrypt_file_open(struct inode *inode, struct file *filp);
237 : int __fscrypt_prepare_link(struct inode *inode, struct inode *dir,
238 : struct dentry *dentry);
239 : int __fscrypt_prepare_rename(struct inode *old_dir, struct dentry *old_dentry,
240 : struct inode *new_dir, struct dentry *new_dentry,
241 : unsigned int flags);
242 : int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry,
243 : struct fscrypt_name *fname);
244 : int __fscrypt_prepare_readdir(struct inode *dir);
245 : int __fscrypt_prepare_setattr(struct dentry *dentry, struct iattr *attr);
246 : int fscrypt_prepare_setflags(struct inode *inode,
247 : unsigned int oldflags, unsigned int flags);
248 : int fscrypt_prepare_symlink(struct inode *dir, const char *target,
249 : unsigned int len, unsigned int max_len,
250 : struct fscrypt_str *disk_link);
251 : int __fscrypt_encrypt_symlink(struct inode *inode, const char *target,
252 : unsigned int len, struct fscrypt_str *disk_link);
253 : const char *fscrypt_get_symlink(struct inode *inode, const void *caddr,
254 : unsigned int max_size,
255 : struct delayed_call *done);
256 : static inline void fscrypt_set_ops(struct super_block *sb,
257 : const struct fscrypt_operations *s_cop)
258 : {
259 : sb->s_cop = s_cop;
260 : }
261 : #else /* !CONFIG_FS_ENCRYPTION */
262 :
263 : static inline struct fscrypt_info *fscrypt_get_info(const struct inode *inode)
264 : {
265 : return NULL;
266 : }
267 :
268 2191 : static inline bool fscrypt_needs_contents_encryption(const struct inode *inode)
269 : {
270 2191 : return false;
271 : }
272 :
273 392 : static inline void fscrypt_handle_d_move(struct dentry *dentry)
274 : {
275 392 : }
276 :
277 708 : static inline bool fscrypt_is_nokey_name(const struct dentry *dentry)
278 : {
279 708 : return false;
280 : }
281 :
282 : /* crypto.c */
283 0 : static inline void fscrypt_enqueue_decrypt_work(struct work_struct *work)
284 : {
285 0 : }
286 :
287 : static inline struct page *fscrypt_encrypt_pagecache_blocks(struct page *page,
288 : unsigned int len,
289 : unsigned int offs,
290 : gfp_t gfp_flags)
291 : {
292 : return ERR_PTR(-EOPNOTSUPP);
293 : }
294 :
295 : static inline int fscrypt_encrypt_block_inplace(const struct inode *inode,
296 : struct page *page,
297 : unsigned int len,
298 : unsigned int offs, u64 lblk_num,
299 : gfp_t gfp_flags)
300 : {
301 : return -EOPNOTSUPP;
302 : }
303 :
304 : static inline int fscrypt_decrypt_pagecache_blocks(struct page *page,
305 : unsigned int len,
306 : unsigned int offs)
307 : {
308 : return -EOPNOTSUPP;
309 : }
310 :
311 : static inline int fscrypt_decrypt_block_inplace(const struct inode *inode,
312 : struct page *page,
313 : unsigned int len,
314 : unsigned int offs, u64 lblk_num)
315 : {
316 : return -EOPNOTSUPP;
317 : }
318 :
319 514 : static inline bool fscrypt_is_bounce_page(struct page *page)
320 : {
321 514 : return false;
322 : }
323 :
324 : static inline struct page *fscrypt_pagecache_page(struct page *bounce_page)
325 : {
326 : WARN_ON_ONCE(1);
327 : return ERR_PTR(-EINVAL);
328 : }
329 :
330 514 : static inline void fscrypt_free_bounce_page(struct page *bounce_page)
331 : {
332 514 : }
333 :
334 : /* policy.c */
335 : static inline int fscrypt_ioctl_set_policy(struct file *filp,
336 : const void __user *arg)
337 : {
338 : return -EOPNOTSUPP;
339 : }
340 :
341 : static inline int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg)
342 : {
343 : return -EOPNOTSUPP;
344 : }
345 :
346 : static inline int fscrypt_ioctl_get_policy_ex(struct file *filp,
347 : void __user *arg)
348 : {
349 : return -EOPNOTSUPP;
350 : }
351 :
352 : static inline int fscrypt_ioctl_get_nonce(struct file *filp, void __user *arg)
353 : {
354 : return -EOPNOTSUPP;
355 : }
356 :
357 0 : static inline int fscrypt_has_permitted_context(struct inode *parent,
358 : struct inode *child)
359 : {
360 0 : return 0;
361 : }
362 :
363 : static inline int fscrypt_set_context(struct inode *inode, void *fs_data)
364 : {
365 : return -EOPNOTSUPP;
366 : }
367 :
368 : struct fscrypt_dummy_policy {
369 : };
370 :
371 606 : static inline void fscrypt_show_test_dummy_encryption(struct seq_file *seq,
372 : char sep,
373 : struct super_block *sb)
374 : {
375 606 : }
376 :
377 : static inline void
378 1 : fscrypt_free_dummy_policy(struct fscrypt_dummy_policy *dummy_policy)
379 : {
380 1 : }
381 :
382 : /* keyring.c */
383 99 : static inline void fscrypt_sb_free(struct super_block *sb)
384 : {
385 99 : }
386 :
387 : static inline int fscrypt_ioctl_add_key(struct file *filp, void __user *arg)
388 : {
389 : return -EOPNOTSUPP;
390 : }
391 :
392 : static inline int fscrypt_ioctl_remove_key(struct file *filp, void __user *arg)
393 : {
394 : return -EOPNOTSUPP;
395 : }
396 :
397 : static inline int fscrypt_ioctl_remove_key_all_users(struct file *filp,
398 : void __user *arg)
399 : {
400 : return -EOPNOTSUPP;
401 : }
402 :
403 : static inline int fscrypt_ioctl_get_key_status(struct file *filp,
404 : void __user *arg)
405 : {
406 : return -EOPNOTSUPP;
407 : }
408 :
409 : /* keysetup.c */
410 :
411 628 : static inline int fscrypt_prepare_new_inode(struct inode *dir,
412 : struct inode *inode,
413 : bool *encrypt_ret)
414 : {
415 628 : if (IS_ENCRYPTED(dir))
416 0 : return -EOPNOTSUPP;
417 : return 0;
418 : }
419 :
420 193 : static inline void fscrypt_put_encryption_info(struct inode *inode)
421 : {
422 193 : return;
423 : }
424 :
425 193 : static inline void fscrypt_free_inode(struct inode *inode)
426 : {
427 193 : }
428 :
429 : static inline int fscrypt_drop_inode(struct inode *inode)
430 : {
431 : return 0;
432 : }
433 :
434 : /* fname.c */
435 : static inline int fscrypt_setup_filename(struct inode *dir,
436 : const struct qstr *iname,
437 : int lookup, struct fscrypt_name *fname)
438 : {
439 : if (IS_ENCRYPTED(dir))
440 : return -EOPNOTSUPP;
441 :
442 : memset(fname, 0, sizeof(*fname));
443 : fname->usr_fname = iname;
444 : fname->disk_name.name = (unsigned char *)iname->name;
445 : fname->disk_name.len = iname->len;
446 : return 0;
447 : }
448 :
449 : static inline void fscrypt_free_filename(struct fscrypt_name *fname)
450 : {
451 : return;
452 : }
453 :
454 : static inline int fscrypt_fname_alloc_buffer(u32 max_encrypted_len,
455 : struct fscrypt_str *crypto_str)
456 : {
457 : return -EOPNOTSUPP;
458 : }
459 :
460 0 : static inline void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str)
461 : {
462 0 : return;
463 : }
464 :
465 0 : static inline int fscrypt_fname_disk_to_usr(const struct inode *inode,
466 : u32 hash, u32 minor_hash,
467 : const struct fscrypt_str *iname,
468 : struct fscrypt_str *oname)
469 : {
470 0 : return -EOPNOTSUPP;
471 : }
472 :
473 246046 : static inline bool fscrypt_match_name(const struct fscrypt_name *fname,
474 : const u8 *de_name, u32 de_name_len)
475 : {
476 : /* Encryption support disabled; use standard comparison */
477 246046 : if (de_name_len != fname->disk_name.len)
478 : return false;
479 24343 : return !memcmp(de_name, fname->disk_name.name, fname->disk_name.len);
480 : }
481 :
482 : static inline u64 fscrypt_fname_siphash(const struct inode *dir,
483 : const struct qstr *name)
484 : {
485 : WARN_ON_ONCE(1);
486 : return 0;
487 : }
488 :
489 : static inline int fscrypt_d_revalidate(struct dentry *dentry,
490 : unsigned int flags)
491 : {
492 : return 1;
493 : }
494 :
495 : /* bio.c */
496 0 : static inline void fscrypt_decrypt_bio(struct bio *bio)
497 : {
498 0 : }
499 :
500 : static inline int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
501 : sector_t pblk, unsigned int len)
502 : {
503 : return -EOPNOTSUPP;
504 : }
505 :
506 : /* hooks.c */
507 :
508 11413 : static inline int fscrypt_file_open(struct inode *inode, struct file *filp)
509 : {
510 11413 : if (IS_ENCRYPTED(inode))
511 : return -EOPNOTSUPP;
512 : return 0;
513 : }
514 :
515 : static inline int __fscrypt_prepare_link(struct inode *inode, struct inode *dir,
516 : struct dentry *dentry)
517 : {
518 : return -EOPNOTSUPP;
519 : }
520 :
521 : static inline int __fscrypt_prepare_rename(struct inode *old_dir,
522 : struct dentry *old_dentry,
523 : struct inode *new_dir,
524 : struct dentry *new_dentry,
525 : unsigned int flags)
526 : {
527 : return -EOPNOTSUPP;
528 : }
529 :
530 : static inline int __fscrypt_prepare_lookup(struct inode *dir,
531 : struct dentry *dentry,
532 : struct fscrypt_name *fname)
533 : {
534 : return -EOPNOTSUPP;
535 : }
536 :
537 0 : static inline int __fscrypt_prepare_readdir(struct inode *dir)
538 : {
539 0 : return -EOPNOTSUPP;
540 : }
541 :
542 : static inline int __fscrypt_prepare_setattr(struct dentry *dentry,
543 : struct iattr *attr)
544 : {
545 : return -EOPNOTSUPP;
546 : }
547 :
548 : static inline int fscrypt_prepare_setflags(struct inode *inode,
549 : unsigned int oldflags,
550 : unsigned int flags)
551 : {
552 : return 0;
553 : }
554 :
555 0 : static inline int fscrypt_prepare_symlink(struct inode *dir,
556 : const char *target,
557 : unsigned int len,
558 : unsigned int max_len,
559 : struct fscrypt_str *disk_link)
560 : {
561 0 : if (IS_ENCRYPTED(dir))
562 : return -EOPNOTSUPP;
563 0 : disk_link->name = (unsigned char *)target;
564 0 : disk_link->len = len + 1;
565 0 : if (disk_link->len > max_len)
566 : return -ENAMETOOLONG;
567 : return 0;
568 : }
569 :
570 0 : static inline int __fscrypt_encrypt_symlink(struct inode *inode,
571 : const char *target,
572 : unsigned int len,
573 : struct fscrypt_str *disk_link)
574 : {
575 0 : return -EOPNOTSUPP;
576 : }
577 :
578 0 : static inline const char *fscrypt_get_symlink(struct inode *inode,
579 : const void *caddr,
580 : unsigned int max_size,
581 : struct delayed_call *done)
582 : {
583 0 : return ERR_PTR(-EOPNOTSUPP);
584 : }
585 :
586 : static inline void fscrypt_set_ops(struct super_block *sb,
587 : const struct fscrypt_operations *s_cop)
588 : {
589 : }
590 :
591 : #endif /* !CONFIG_FS_ENCRYPTION */
592 :
593 : /* inline_crypt.c */
594 : #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
595 :
596 : bool __fscrypt_inode_uses_inline_crypto(const struct inode *inode);
597 :
598 : void fscrypt_set_bio_crypt_ctx(struct bio *bio,
599 : const struct inode *inode, u64 first_lblk,
600 : gfp_t gfp_mask);
601 :
602 : void fscrypt_set_bio_crypt_ctx_bh(struct bio *bio,
603 : const struct buffer_head *first_bh,
604 : gfp_t gfp_mask);
605 :
606 : bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
607 : u64 next_lblk);
608 :
609 : bool fscrypt_mergeable_bio_bh(struct bio *bio,
610 : const struct buffer_head *next_bh);
611 :
612 : #else /* CONFIG_FS_ENCRYPTION_INLINE_CRYPT */
613 :
614 : static inline bool __fscrypt_inode_uses_inline_crypto(const struct inode *inode)
615 : {
616 : return false;
617 : }
618 :
619 1677 : static inline void fscrypt_set_bio_crypt_ctx(struct bio *bio,
620 : const struct inode *inode,
621 1677 : u64 first_lblk, gfp_t gfp_mask) { }
622 :
623 6831 : static inline void fscrypt_set_bio_crypt_ctx_bh(
624 : struct bio *bio,
625 : const struct buffer_head *first_bh,
626 6831 : gfp_t gfp_mask) { }
627 :
628 : static inline bool fscrypt_mergeable_bio(struct bio *bio,
629 : const struct inode *inode,
630 : u64 next_lblk)
631 : {
632 : return true;
633 : }
634 :
635 : static inline bool fscrypt_mergeable_bio_bh(struct bio *bio,
636 : const struct buffer_head *next_bh)
637 : {
638 : return true;
639 : }
640 : #endif /* !CONFIG_FS_ENCRYPTION_INLINE_CRYPT */
641 :
642 : /**
643 : * fscrypt_inode_uses_inline_crypto() - test whether an inode uses inline
644 : * encryption
645 : * @inode: an inode. If encrypted, its key must be set up.
646 : *
647 : * Return: true if the inode requires file contents encryption and if the
648 : * encryption should be done in the block layer via blk-crypto rather
649 : * than in the filesystem layer.
650 : */
651 : static inline bool fscrypt_inode_uses_inline_crypto(const struct inode *inode)
652 : {
653 : return fscrypt_needs_contents_encryption(inode) &&
654 : __fscrypt_inode_uses_inline_crypto(inode);
655 : }
656 :
657 : /**
658 : * fscrypt_inode_uses_fs_layer_crypto() - test whether an inode uses fs-layer
659 : * encryption
660 : * @inode: an inode. If encrypted, its key must be set up.
661 : *
662 : * Return: true if the inode requires file contents encryption and if the
663 : * encryption should be done in the filesystem layer rather than in the
664 : * block layer via blk-crypto.
665 : */
666 2191 : static inline bool fscrypt_inode_uses_fs_layer_crypto(const struct inode *inode)
667 : {
668 2193 : return fscrypt_needs_contents_encryption(inode) &&
669 : !__fscrypt_inode_uses_inline_crypto(inode);
670 : }
671 :
672 : /**
673 : * fscrypt_has_encryption_key() - check whether an inode has had its key set up
674 : * @inode: the inode to check
675 : *
676 : * Return: %true if the inode has had its encryption key set up, else %false.
677 : *
678 : * Usually this should be preceded by fscrypt_get_encryption_info() to try to
679 : * set up the key first.
680 : */
681 : static inline bool fscrypt_has_encryption_key(const struct inode *inode)
682 : {
683 2 : return fscrypt_get_info(inode) != NULL;
684 : }
685 :
686 : /**
687 : * fscrypt_prepare_link() - prepare to link an inode into a possibly-encrypted
688 : * directory
689 : * @old_dentry: an existing dentry for the inode being linked
690 : * @dir: the target directory
691 : * @dentry: negative dentry for the target filename
692 : *
693 : * A new link can only be added to an encrypted directory if the directory's
694 : * encryption key is available --- since otherwise we'd have no way to encrypt
695 : * the filename.
696 : *
697 : * We also verify that the link will not violate the constraint that all files
698 : * in an encrypted directory tree use the same encryption policy.
699 : *
700 : * Return: 0 on success, -ENOKEY if the directory's encryption key is missing,
701 : * -EXDEV if the link would result in an inconsistent encryption policy, or
702 : * another -errno code.
703 : */
704 0 : static inline int fscrypt_prepare_link(struct dentry *old_dentry,
705 : struct inode *dir,
706 : struct dentry *dentry)
707 : {
708 0 : if (IS_ENCRYPTED(dir))
709 0 : return __fscrypt_prepare_link(d_inode(old_dentry), dir, dentry);
710 : return 0;
711 : }
712 :
713 : /**
714 : * fscrypt_prepare_rename() - prepare for a rename between possibly-encrypted
715 : * directories
716 : * @old_dir: source directory
717 : * @old_dentry: dentry for source file
718 : * @new_dir: target directory
719 : * @new_dentry: dentry for target location (may be negative unless exchanging)
720 : * @flags: rename flags (we care at least about %RENAME_EXCHANGE)
721 : *
722 : * Prepare for ->rename() where the source and/or target directories may be
723 : * encrypted. A new link can only be added to an encrypted directory if the
724 : * directory's encryption key is available --- since otherwise we'd have no way
725 : * to encrypt the filename. A rename to an existing name, on the other hand,
726 : * *is* cryptographically possible without the key. However, we take the more
727 : * conservative approach and just forbid all no-key renames.
728 : *
729 : * We also verify that the rename will not violate the constraint that all files
730 : * in an encrypted directory tree use the same encryption policy.
731 : *
732 : * Return: 0 on success, -ENOKEY if an encryption key is missing, -EXDEV if the
733 : * rename would cause inconsistent encryption policies, or another -errno code.
734 : */
735 101 : static inline int fscrypt_prepare_rename(struct inode *old_dir,
736 : struct dentry *old_dentry,
737 : struct inode *new_dir,
738 : struct dentry *new_dentry,
739 : unsigned int flags)
740 : {
741 101 : if (IS_ENCRYPTED(old_dir) || IS_ENCRYPTED(new_dir))
742 101 : return __fscrypt_prepare_rename(old_dir, old_dentry,
743 : new_dir, new_dentry, flags);
744 : return 0;
745 : }
746 :
747 : /**
748 : * fscrypt_prepare_lookup() - prepare to lookup a name in a possibly-encrypted
749 : * directory
750 : * @dir: directory being searched
751 : * @dentry: filename being looked up
752 : * @fname: (output) the name to use to search the on-disk directory
753 : *
754 : * Prepare for ->lookup() in a directory which may be encrypted by determining
755 : * the name that will actually be used to search the directory on-disk. If the
756 : * directory's encryption policy is supported by this kernel and its encryption
757 : * key is available, then the lookup is assumed to be by plaintext name;
758 : * otherwise, it is assumed to be by no-key name.
759 : *
760 : * This will set DCACHE_NOKEY_NAME on the dentry if the lookup is by no-key
761 : * name. In this case the filesystem must assign the dentry a dentry_operations
762 : * which contains fscrypt_d_revalidate (or contains a d_revalidate method that
763 : * calls fscrypt_d_revalidate), so that the dentry will be invalidated if the
764 : * directory's encryption key is later added.
765 : *
766 : * Return: 0 on success; -ENOENT if the directory's key is unavailable but the
767 : * filename isn't a valid no-key name, so a negative dentry should be created;
768 : * or another -errno code.
769 : */
770 : static inline int fscrypt_prepare_lookup(struct inode *dir,
771 : struct dentry *dentry,
772 : struct fscrypt_name *fname)
773 : {
774 : if (IS_ENCRYPTED(dir))
775 : return __fscrypt_prepare_lookup(dir, dentry, fname);
776 :
777 : memset(fname, 0, sizeof(*fname));
778 : fname->usr_fname = &dentry->d_name;
779 : fname->disk_name.name = (unsigned char *)dentry->d_name.name;
780 : fname->disk_name.len = dentry->d_name.len;
781 : return 0;
782 : }
783 :
784 : /**
785 : * fscrypt_prepare_readdir() - prepare to read a possibly-encrypted directory
786 : * @dir: the directory inode
787 : *
788 : * If the directory is encrypted and it doesn't already have its encryption key
789 : * set up, try to set it up so that the filenames will be listed in plaintext
790 : * form rather than in no-key form.
791 : *
792 : * Return: 0 on success; -errno on error. Note that the encryption key being
793 : * unavailable is not considered an error. It is also not an error if
794 : * the encryption policy is unsupported by this kernel; that is treated
795 : * like the key being unavailable, so that files can still be deleted.
796 : */
797 1099 : static inline int fscrypt_prepare_readdir(struct inode *dir)
798 : {
799 1099 : if (IS_ENCRYPTED(dir))
800 1099 : return __fscrypt_prepare_readdir(dir);
801 : return 0;
802 : }
803 :
804 : /**
805 : * fscrypt_prepare_setattr() - prepare to change a possibly-encrypted inode's
806 : * attributes
807 : * @dentry: dentry through which the inode is being changed
808 : * @attr: attributes to change
809 : *
810 : * Prepare for ->setattr() on a possibly-encrypted inode. On an encrypted file,
811 : * most attribute changes are allowed even without the encryption key. However,
812 : * without the encryption key we do have to forbid truncates. This is needed
813 : * because the size being truncated to may not be a multiple of the filesystem
814 : * block size, and in that case we'd have to decrypt the final block, zero the
815 : * portion past i_size, and re-encrypt it. (We *could* allow truncating to a
816 : * filesystem block boundary, but it's simpler to just forbid all truncates ---
817 : * and we already forbid all other contents modifications without the key.)
818 : *
819 : * Return: 0 on success, -ENOKEY if the key is missing, or another -errno code
820 : * if a problem occurred while setting up the encryption key.
821 : */
822 303 : static inline int fscrypt_prepare_setattr(struct dentry *dentry,
823 : struct iattr *attr)
824 : {
825 303 : if (IS_ENCRYPTED(d_inode(dentry)))
826 303 : return __fscrypt_prepare_setattr(dentry, attr);
827 : return 0;
828 : }
829 :
830 : /**
831 : * fscrypt_encrypt_symlink() - encrypt the symlink target if needed
832 : * @inode: symlink inode
833 : * @target: plaintext symlink target
834 : * @len: length of @target excluding null terminator
835 : * @disk_link: (in/out) the on-disk symlink target being prepared
836 : *
837 : * If the symlink target needs to be encrypted, then this function encrypts it
838 : * into @disk_link->name. fscrypt_prepare_symlink() must have been called
839 : * previously to compute @disk_link->len. If the filesystem did not allocate a
840 : * buffer for @disk_link->name after calling fscrypt_prepare_link(), then one
841 : * will be kmalloc()'ed and the filesystem will be responsible for freeing it.
842 : *
843 : * Return: 0 on success, -errno on failure
844 : */
845 0 : static inline int fscrypt_encrypt_symlink(struct inode *inode,
846 : const char *target,
847 : unsigned int len,
848 : struct fscrypt_str *disk_link)
849 : {
850 0 : if (IS_ENCRYPTED(inode))
851 0 : return __fscrypt_encrypt_symlink(inode, target, len, disk_link);
852 : return 0;
853 : }
854 :
855 : /* If *pagep is a bounce page, free it and set *pagep to the pagecache page */
856 : static inline void fscrypt_finalize_bounce_page(struct page **pagep)
857 : {
858 : struct page *page = *pagep;
859 :
860 : if (fscrypt_is_bounce_page(page)) {
861 : *pagep = fscrypt_pagecache_page(page);
862 : fscrypt_free_bounce_page(page);
863 : }
864 : }
865 :
866 : #endif /* _LINUX_FSCRYPT_H */
|
