fs/crypto/keyinfo.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * key management facility for FS encryption support.
   4  *
   5  * Copyright (C) 2015, Google, Inc.
   6  *
   7  * This contains encryption key functions.
   8  *
   9  * Written by Michael Halcrow, Ildar Muslukhov, and Uday Savagaonkar, 2015.
  10  */
  11
  12 #include <keys/user-type.h>
  13 #include <linux/hashtable.h>
  14 #include <linux/scatterlist.h>
  15 #include <crypto/aes.h>
  16 #include <crypto/algapi.h>
  17 #include <crypto/sha.h>
  18 #include <crypto/skcipher.h>
  19 #include "fscrypt_private.h"
  20
  21 static struct crypto_shash *essiv_hash_tfm;
  22
  23 /* Table of keys referenced by FS_POLICY_FLAG_DIRECT_KEY policies */
  24 static DEFINE_HASHTABLE(fscrypt_master_keys, 6); /* 6 bits = 64 buckets */
  25 static DEFINE_SPINLOCK(fscrypt_master_keys_lock);
  26
  27 /*
  28  * Key derivation function.  This generates the derived key by encrypting the
  29  * master key with AES-128-ECB using the inode's nonce as the AES key.
  30  *
  31  * The master key must be at least as long as the derived key.  If the master
  32  * key is longer, then only the first 'derived_keysize' bytes are used.
  33  */
  34 static int derive_key_aes(const u8 *master_key,
  35                           const struct fscrypt_context *ctx,
  36                           u8 *derived_key, unsigned int derived_keysize)
  37 {
  38         int res = 0;
  39         struct skcipher_request *req = NULL;
  40         DECLARE_CRYPTO_WAIT(wait);
  41         struct scatterlist src_sg, dst_sg;
  42         struct crypto_skcipher *tfm = crypto_alloc_skcipher("ecb(aes)", 0, 0);
  43
  44         if (IS_ERR(tfm)) {
  45                 res = PTR_ERR(tfm);
  46                 tfm = NULL;
  47                 goto out;
  48         }
  49         crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
  50         req = skcipher_request_alloc(tfm, GFP_NOFS);
  51         if (!req) {
  52                 res = -ENOMEM;
  53                 goto out;
  54         }
  55         skcipher_request_set_callback(req,
  56                         CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
  57                         crypto_req_done, &wait);
  58         res = crypto_skcipher_setkey(tfm, ctx->nonce, sizeof(ctx->nonce));
  59         if (res < 0)
  60                 goto out;
  61
  62         sg_init_one(&src_sg, master_key, derived_keysize);
  63         sg_init_one(&dst_sg, derived_key, derived_keysize);
  64         skcipher_request_set_crypt(req, &src_sg, &dst_sg, derived_keysize,
  65                                    NULL);
  66         res = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);
  67 out:
  68         skcipher_request_free(req);
  69         crypto_free_skcipher(tfm);
  70         return res;
  71 }
  72
  73 /*
  74  * Search the current task's subscribed keyrings for a "logon" key with
  75  * description prefix:descriptor, and if found acquire a read lock on it and
  76  * return a pointer to its validated payload in *payload_ret.
  77  */
  78 static struct key *
  79 find_and_lock_process_key(const char *prefix,
  80                           const u8 descriptor[FS_KEY_DESCRIPTOR_SIZE],
  81                           unsigned int min_keysize,
  82                           const struct fscrypt_key **payload_ret)
  83 {
  84         char *description;
  85         struct key *key;
  86         const struct user_key_payload *ukp;
  87         const struct fscrypt_key *payload;
  88
  89         description = kasprintf(GFP_NOFS, "%s%*phN", prefix,
  90                                 FS_KEY_DESCRIPTOR_SIZE, descriptor);
  91         if (!description)
  92                 return ERR_PTR(-ENOMEM);
  93
  94         key = request_key(&key_type_logon, description, NULL);
  95         kfree(description);
  96         if (IS_ERR(key))
  97                 return key;
  98
  99         down_read(&key->sem);
 100         ukp = user_key_payload_locked(key);
 101
 102         if (!ukp) /* was the key revoked before we acquired its semaphore? */
 103                 goto invalid;
 104
 105         payload = (const struct fscrypt_key *)ukp->data;
 106
 107         if (ukp->datalen != sizeof(struct fscrypt_key) ||
 108             payload->size < 1 || payload->size > FS_MAX_KEY_SIZE) {
 109                 fscrypt_warn(NULL,
 110                              "key with description '%s' has invalid payload",
 111                              key->description);
 112                 goto invalid;
 113         }
 114
 115         if (payload->size < min_keysize) {
 116                 fscrypt_warn(NULL,
 117                              "key with description '%s' is too short (got %u bytes, need %u+ bytes)",
 118                              key->description, payload->size, min_keysize);
 119                 goto invalid;
 120         }
 121
 122         *payload_ret = payload;
 123         return key;
 124
 125 invalid:
 126         up_read(&key->sem);
 127         key_put(key);
 128         return ERR_PTR(-ENOKEY);
 129 }
 130
 131 static struct fscrypt_mode available_modes[] = {
 132         [FS_ENCRYPTION_MODE_AES_256_XTS] = {
 133                 .friendly_name = "AES-256-XTS",
 134                 .cipher_str = "xts(aes)",
 135                 .keysize = 64,
 136                 .ivsize = 16,
 137         },
 138         [FS_ENCRYPTION_MODE_AES_256_CTS] = {
 139                 .friendly_name = "AES-256-CTS-CBC",
 140                 .cipher_str = "cts(cbc(aes))",
 141                 .keysize = 32,
 142                 .ivsize = 16,
 143         },
 144         [FS_ENCRYPTION_MODE_AES_128_CBC] = {
 145                 .friendly_name = "AES-128-CBC",
 146                 .cipher_str = "cbc(aes)",
 147                 .keysize = 16,
 148                 .ivsize = 16,
 149                 .needs_essiv = true,
 150         },
 151         [FS_ENCRYPTION_MODE_AES_128_CTS] = {
 152                 .friendly_name = "AES-128-CTS-CBC",
 153                 .cipher_str = "cts(cbc(aes))",
 154                 .keysize = 16,
 155                 .ivsize = 16,
 156         },
 157         [FS_ENCRYPTION_MODE_ADIANTUM] = {
 158                 .friendly_name = "Adiantum",
 159                 .cipher_str = "adiantum(xchacha12,aes)",
 160                 .keysize = 32,
 161                 .ivsize = 32,
 162         },
 163 };
 164
 165 static struct fscrypt_mode *
 166 select_encryption_mode(const struct fscrypt_info *ci, const struct inode *inode)
 167 {
 168         if (!fscrypt_valid_enc_modes(ci->ci_data_mode, ci->ci_filename_mode)) {
 169                 fscrypt_warn(inode,
 170                              "Unsupported encryption modes (contents mode %d, filenames mode %d)",
 171                              ci->ci_data_mode, ci->ci_filename_mode);
 172                 return ERR_PTR(-EINVAL);
 173         }
 174
 175         if (S_ISREG(inode->i_mode))
 176                 return &available_modes[ci->ci_data_mode];
 177
 178         if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
 179                 return &available_modes[ci->ci_filename_mode];
 180
 181         WARN_ONCE(1, "fscrypt: filesystem tried to load encryption info for inode %lu, which is not encryptable (file type %d)\n",
 182                   inode->i_ino, (inode->i_mode & S_IFMT));
 183         return ERR_PTR(-EINVAL);
 184 }
 185
 186 /* Find the master key, then derive the inode's actual encryption key */
 187 static int find_and_derive_key(const struct inode *inode,
 188                                const struct fscrypt_context *ctx,
 189                                u8 *derived_key, const struct fscrypt_mode *mode)
 190 {
 191         struct key *key;
 192         const struct fscrypt_key *payload;
 193         int err;
 194
 195         key = find_and_lock_process_key(FS_KEY_DESC_PREFIX,
 196                                         ctx->master_key_descriptor,
 197                                         mode->keysize, &payload);
 198         if (key == ERR_PTR(-ENOKEY) && inode->i_sb->s_cop->key_prefix) {
 199                 key = find_and_lock_process_key(inode->i_sb->s_cop->key_prefix,
 200                                                 ctx->master_key_descriptor,
 201                                                 mode->keysize, &payload);
 202         }
 203         if (IS_ERR(key))
 204                 return PTR_ERR(key);
 205
 206         if (ctx->flags & FS_POLICY_FLAG_DIRECT_KEY) {
 207                 if (mode->ivsize < offsetofend(union fscrypt_iv, nonce)) {
 208                         fscrypt_warn(inode,
 209                                      "Direct key mode not allowed with %s",
 210                                      mode->friendly_name);
 211                         err = -EINVAL;
 212                 } else if (ctx->contents_encryption_mode !=
 213                            ctx->filenames_encryption_mode) {
 214                         fscrypt_warn(inode,
 215                                      "Direct key mode not allowed with different contents and filenames modes");
 216                         err = -EINVAL;
 217                 } else {
 218                         memcpy(derived_key, payload->raw, mode->keysize);
 219                         err = 0;
 220                 }
 221         } else {
 222                 err = derive_key_aes(payload->raw, ctx, derived_key,
 223                                      mode->keysize);
 224         }
 225         up_read(&key->sem);
 226         key_put(key);
 227         return err;
 228 }
 229
 230 /* Allocate and key a symmetric cipher object for the given encryption mode */
 231 static struct crypto_skcipher *
 232 allocate_skcipher_for_mode(struct fscrypt_mode *mode, const u8 *raw_key,
 233                            const struct inode *inode)
 234 {
 235         struct crypto_skcipher *tfm;
 236         int err;
 237
 238         tfm = crypto_alloc_skcipher(mode->cipher_str, 0, 0);
 239         if (IS_ERR(tfm)) {
 240                 fscrypt_warn(inode, "Error allocating '%s' transform: %ld",
 241                              mode->cipher_str, PTR_ERR(tfm));
 242                 return tfm;
 243         }
 244         if (unlikely(!mode->logged_impl_name)) {
 245                 /*
 246                  * fscrypt performance can vary greatly depending on which
 247                  * crypto algorithm implementation is used.  Help people debug
 248                  * performance problems by logging the ->cra_driver_name the
 249                  * first time a mode is used.  Note that multiple threads can
 250                  * race here, but it doesn't really matter.
 251                  */
 252                 mode->logged_impl_name = true;
 253                 pr_info("fscrypt: %s using implementation \"%s\"\n",
 254                         mode->friendly_name,
 255                         crypto_skcipher_alg(tfm)->base.cra_driver_name);
 256         }
 257         crypto_skcipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
 258         err = crypto_skcipher_setkey(tfm, raw_key, mode->keysize);
 259         if (err)
 260                 goto err_free_tfm;
 261
 262         return tfm;
 263
 264 err_free_tfm:
 265         crypto_free_skcipher(tfm);
 266         return ERR_PTR(err);
 267 }
 268
 269 /* Master key referenced by FS_POLICY_FLAG_DIRECT_KEY policy */
 270 struct fscrypt_master_key {
 271         struct hlist_node mk_node;
 272         refcount_t mk_refcount;
 273         const struct fscrypt_mode *mk_mode;
 274         struct crypto_skcipher *mk_ctfm;
 275         u8 mk_descriptor[FS_KEY_DESCRIPTOR_SIZE];
 276         u8 mk_raw[FS_MAX_KEY_SIZE];
 277 };
 278
 279 static void free_master_key(struct fscrypt_master_key *mk)
 280 {
 281         if (mk) {
 282                 crypto_free_skcipher(mk->mk_ctfm);
 283                 kzfree(mk);
 284         }
 285 }
 286
 287 static void put_master_key(struct fscrypt_master_key *mk)
 288 {
 289         if (!refcount_dec_and_lock(&mk->mk_refcount, &fscrypt_master_keys_lock))
 290                 return;
 291         hash_del(&mk->mk_node);
 292         spin_unlock(&fscrypt_master_keys_lock);
 293
 294         free_master_key(mk);
 295 }
 296
 297 /*
 298  * Find/insert the given master key into the fscrypt_master_keys table.  If
 299  * found, it is returned with elevated refcount, and 'to_insert' is freed if
 300  * non-NULL.  If not found, 'to_insert' is inserted and returned if it's
 301  * non-NULL; otherwise NULL is returned.
 302  */
 303 static struct fscrypt_master_key *
 304 find_or_insert_master_key(struct fscrypt_master_key *to_insert,
 305                           const u8 *raw_key, const struct fscrypt_mode *mode,
 306                           const struct fscrypt_info *ci)
 307 {
 308         unsigned long hash_key;
 309         struct fscrypt_master_key *mk;
 310
 311         /*
 312          * Careful: to avoid potentially leaking secret key bytes via timing
 313          * information, we must key the hash table by descriptor rather than by
 314          * raw key, and use crypto_memneq() when comparing raw keys.
 315          */
 316
 317         BUILD_BUG_ON(sizeof(hash_key) > FS_KEY_DESCRIPTOR_SIZE);
 318         memcpy(&hash_key, ci->ci_master_key_descriptor, sizeof(hash_key));
 319
 320         spin_lock(&fscrypt_master_keys_lock);
 321         hash_for_each_possible(fscrypt_master_keys, mk, mk_node, hash_key) {
 322                 if (memcmp(ci->ci_master_key_descriptor, mk->mk_descriptor,
 323                            FS_KEY_DESCRIPTOR_SIZE) != 0)
 324                         continue;
 325                 if (mode != mk->mk_mode)
 326                         continue;
 327                 if (crypto_memneq(raw_key, mk->mk_raw, mode->keysize))
 328                         continue;
 329                 /* using existing tfm with same (descriptor, mode, raw_key) */
 330                 refcount_inc(&mk->mk_refcount);
 331                 spin_unlock(&fscrypt_master_keys_lock);
 332                 free_master_key(to_insert);
 333                 return mk;
 334         }
 335         if (to_insert)
 336                 hash_add(fscrypt_master_keys, &to_insert->mk_node, hash_key);
 337         spin_unlock(&fscrypt_master_keys_lock);
 338         return to_insert;
 339 }
 340
 341 /* Prepare to encrypt directly using the master key in the given mode */
 342 static struct fscrypt_master_key *
 343 fscrypt_get_master_key(const struct fscrypt_info *ci, struct fscrypt_mode *mode,
 344                        const u8 *raw_key, const struct inode *inode)
 345 {
 346         struct fscrypt_master_key *mk;
 347         int err;
 348
 349         /* Is there already a tfm for this key? */
 350         mk = find_or_insert_master_key(NULL, raw_key, mode, ci);
 351         if (mk)
 352                 return mk;
 353
 354         /* Nope, allocate one. */
 355         mk = kzalloc(sizeof(*mk), GFP_NOFS);
 356         if (!mk)
 357                 return ERR_PTR(-ENOMEM);
 358         refcount_set(&mk->mk_refcount, 1);
 359         mk->mk_mode = mode;
 360         mk->mk_ctfm = allocate_skcipher_for_mode(mode, raw_key, inode);
 361         if (IS_ERR(mk->mk_ctfm)) {
 362                 err = PTR_ERR(mk->mk_ctfm);
 363                 mk->mk_ctfm = NULL;
 364                 goto err_free_mk;
 365         }
 366         memcpy(mk->mk_descriptor, ci->ci_master_key_descriptor,
 367                FS_KEY_DESCRIPTOR_SIZE);
 368         memcpy(mk->mk_raw, raw_key, mode->keysize);
 369
 370         return find_or_insert_master_key(mk, raw_key, mode, ci);
 371
 372 err_free_mk:
 373         free_master_key(mk);
 374         return ERR_PTR(err);
 375 }
 376
 377 static int derive_essiv_salt(const u8 *key, int keysize, u8 *salt)
 378 {
 379         struct crypto_shash *tfm = READ_ONCE(essiv_hash_tfm);
 380
 381         /* init hash transform on demand */
 382         if (unlikely(!tfm)) {
 383                 struct crypto_shash *prev_tfm;
 384
 385                 tfm = crypto_alloc_shash("sha256", 0, 0);
 386                 if (IS_ERR(tfm)) {
 387                         fscrypt_warn(NULL,
 388                                      "error allocating SHA-256 transform: %ld",
 389                                      PTR_ERR(tfm));
 390                         return PTR_ERR(tfm);
 391                 }
 392                 prev_tfm = cmpxchg(&essiv_hash_tfm, NULL, tfm);
 393                 if (prev_tfm) {
 394                         crypto_free_shash(tfm);
 395                         tfm = prev_tfm;
 396                 }
 397         }
 398
 399         {
 400                 SHASH_DESC_ON_STACK(desc, tfm);
 401                 desc->tfm = tfm;
 402
 403                 return crypto_shash_digest(desc, key, keysize, salt);
 404         }
 405 }
 406
 407 static int init_essiv_generator(struct fscrypt_info *ci, const u8 *raw_key,
 408                                 int keysize)
 409 {
 410         int err;
 411         struct crypto_cipher *essiv_tfm;
 412         u8 salt[SHA256_DIGEST_SIZE];
 413
 414         essiv_tfm = crypto_alloc_cipher("aes", 0, 0);
 415         if (IS_ERR(essiv_tfm))
 416                 return PTR_ERR(essiv_tfm);
 417
 418         ci->ci_essiv_tfm = essiv_tfm;
 419
 420         err = derive_essiv_salt(raw_key, keysize, salt);
 421         if (err)
 422                 goto out;
 423
 424         /*
 425          * Using SHA256 to derive the salt/key will result in AES-256 being
 426          * used for IV generation. File contents encryption will still use the
 427          * configured keysize (AES-128) nevertheless.
 428          */
 429         err = crypto_cipher_setkey(essiv_tfm, salt, sizeof(salt));
 430         if (err)
 431                 goto out;
 432
 433 out:
 434         memzero_explicit(salt, sizeof(salt));
 435         return err;
 436 }
 437
 438 /*
 439  * Given the encryption mode and key (normally the derived key, but for
 440  * FS_POLICY_FLAG_DIRECT_KEY mode it's the master key), set up the inode's
 441  * symmetric cipher transform object(s).
 442  */
 443 static int setup_crypto_transform(struct fscrypt_info *ci,
 444                                   struct fscrypt_mode *mode,
 445                                   const u8 *raw_key, const struct inode *inode)
 446 {
 447         struct fscrypt_master_key *mk;
 448         struct crypto_skcipher *ctfm;
 449         int err;
 450
 451         if (ci->ci_flags & FS_POLICY_FLAG_DIRECT_KEY) {
 452                 mk = fscrypt_get_master_key(ci, mode, raw_key, inode);
 453                 if (IS_ERR(mk))
 454                         return PTR_ERR(mk);
 455                 ctfm = mk->mk_ctfm;
 456         } else {
 457                 mk = NULL;
 458                 ctfm = allocate_skcipher_for_mode(mode, raw_key, inode);
 459                 if (IS_ERR(ctfm))
 460                         return PTR_ERR(ctfm);
 461         }
 462         ci->ci_master_key = mk;
 463         ci->ci_ctfm = ctfm;
 464
 465         if (mode->needs_essiv) {
 466                 /* ESSIV implies 16-byte IVs which implies !DIRECT_KEY */
 467                 WARN_ON(mode->ivsize != AES_BLOCK_SIZE);
 468                 WARN_ON(ci->ci_flags & FS_POLICY_FLAG_DIRECT_KEY);
 469
 470                 err = init_essiv_generator(ci, raw_key, mode->keysize);
 471                 if (err) {
 472                         fscrypt_warn(inode,
 473                                      "Error initializing ESSIV generator: %d",
 474                                      err);
 475                         return err;
 476                 }
 477         }
 478         return 0;
 479 }
 480
 481 static void put_crypt_info(struct fscrypt_info *ci)
 482 {
 483         if (!ci)
 484                 return;
 485
 486         if (ci->ci_master_key) {
 487                 put_master_key(ci->ci_master_key);
 488         } else {
 489                 crypto_free_skcipher(ci->ci_ctfm);
 490                 crypto_free_cipher(ci->ci_essiv_tfm);
 491         }
 492         kmem_cache_free(fscrypt_info_cachep, ci);
 493 }
 494
 495 int fscrypt_get_encryption_info(struct inode *inode)
 496 {
 497         struct fscrypt_info *crypt_info;
 498         struct fscrypt_context ctx;
 499         struct fscrypt_mode *mode;
 500         u8 *raw_key = NULL;
 501         int res;
 502
 503         if (fscrypt_has_encryption_key(inode))
 504                 return 0;
 505
 506         res = fscrypt_initialize(inode->i_sb->s_cop->flags);
 507         if (res)
 508                 return res;
 509
 510         res = inode->i_sb->s_cop->get_context(inode, &ctx, sizeof(ctx));
 511         if (res < 0) {
 512                 if (!fscrypt_dummy_context_enabled(inode) ||
 513                     IS_ENCRYPTED(inode)) {
 514                         fscrypt_warn(inode,
 515                                      "Error %d getting encryption context",
 516                                      res);
 517                         return res;
 518                 }
 519                 /* Fake up a context for an unencrypted directory */
 520                 memset(&ctx, 0, sizeof(ctx));
 521                 ctx.format = FS_ENCRYPTION_CONTEXT_FORMAT_V1;
 522                 ctx.contents_encryption_mode = FS_ENCRYPTION_MODE_AES_256_XTS;
 523                 ctx.filenames_encryption_mode = FS_ENCRYPTION_MODE_AES_256_CTS;
 524                 memset(ctx.master_key_descriptor, 0x42, FS_KEY_DESCRIPTOR_SIZE);
 525         } else if (res != sizeof(ctx)) {
 526                 fscrypt_warn(inode,
 527                              "Unknown encryption context size (%d bytes)", res);
 528                 return -EINVAL;
 529         }
 530
 531         if (ctx.format != FS_ENCRYPTION_CONTEXT_FORMAT_V1) {
 532                 fscrypt_warn(inode, "Unknown encryption context version (%d)",
 533                              ctx.format);
 534                 return -EINVAL;
 535         }
 536
 537         if (ctx.flags & ~FS_POLICY_FLAGS_VALID) {
 538                 fscrypt_warn(inode, "Unknown encryption context flags (0x%02x)",
 539                              ctx.flags);
 540                 return -EINVAL;
 541         }
 542
 543         crypt_info = kmem_cache_zalloc(fscrypt_info_cachep, GFP_NOFS);
 544         if (!crypt_info)
 545                 return -ENOMEM;
 546
 547         crypt_info->ci_flags = ctx.flags;
 548         crypt_info->ci_data_mode = ctx.contents_encryption_mode;
 549         crypt_info->ci_filename_mode = ctx.filenames_encryption_mode;
 550         memcpy(crypt_info->ci_master_key_descriptor, ctx.master_key_descriptor,
 551                FS_KEY_DESCRIPTOR_SIZE);
 552         memcpy(crypt_info->ci_nonce, ctx.nonce, FS_KEY_DERIVATION_NONCE_SIZE);
 553
 554         mode = select_encryption_mode(crypt_info, inode);
 555         if (IS_ERR(mode)) {
 556                 res = PTR_ERR(mode);
 557                 goto out;
 558         }
 559         WARN_ON(mode->ivsize > FSCRYPT_MAX_IV_SIZE);
 560         crypt_info->ci_mode = mode;
 561
 562         /*
 563          * This cannot be a stack buffer because it may be passed to the
 564          * scatterlist crypto API as part of key derivation.
 565          */
 566         res = -ENOMEM;
 567         raw_key = kmalloc(mode->keysize, GFP_NOFS);
 568         if (!raw_key)
 569                 goto out;
 570
 571         res = find_and_derive_key(inode, &ctx, raw_key, mode);
 572         if (res)
 573                 goto out;
 574
 575         res = setup_crypto_transform(crypt_info, mode, raw_key, inode);
 576         if (res)
 577                 goto out;
 578
 579         if (cmpxchg_release(&inode->i_crypt_info, NULL, crypt_info) == NULL)
 580                 crypt_info = NULL;
 581 out:
 582         if (res == -ENOKEY)
 583                 res = 0;
 584         put_crypt_info(crypt_info);
 585         kzfree(raw_key);
 586         return res;
 587 }
 588 EXPORT_SYMBOL(fscrypt_get_encryption_info);
 589
 590 /**
 591  * fscrypt_put_encryption_info - free most of an inode's fscrypt data
 592  *
 593  * Free the inode's fscrypt_info.  Filesystems must call this when the inode is
 594  * being evicted.  An RCU grace period need not have elapsed yet.
 595  */
 596 void fscrypt_put_encryption_info(struct inode *inode)
 597 {
 598         put_crypt_info(inode->i_crypt_info);
 599         inode->i_crypt_info = NULL;
 600 }
 601 EXPORT_SYMBOL(fscrypt_put_encryption_info);
 602
 603 /**
 604  * fscrypt_free_inode - free an inode's fscrypt data requiring RCU delay
 605  *
 606  * Free the inode's cached decrypted symlink target, if any.  Filesystems must
 607  * call this after an RCU grace period, just before they free the inode.
 608  */
 609 void fscrypt_free_inode(struct inode *inode)
 610 {
 611         if (IS_ENCRYPTED(inode) && S_ISLNK(inode->i_mode)) {
 612                 kfree(inode->i_link);
 613                 inode->i_link = NULL;
 614         }
 615 }
 616 EXPORT_SYMBOL(fscrypt_free_inode);