lib/crc-t10dif.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * T10 Data Integrity Field CRC16 calculation
   4  *
   5  * Copyright (c) 2007 Oracle Corporation.  All rights reserved.
   6  * Written by Martin K. Petersen <martin.petersen@oracle.com>
   7  */
   8
   9 #include <linux/types.h>
  10 #include <linux/module.h>
  11 #include <linux/crc-t10dif.h>
  12 #include <linux/err.h>
  13 #include <linux/init.h>
  14 #include <crypto/hash.h>
  15 #include <crypto/algapi.h>
  16 #include <linux/static_key.h>
  17 #include <linux/notifier.h>
  18
  19 static struct crypto_shash __rcu *crct10dif_tfm;
  20 static DEFINE_STATIC_KEY_TRUE(crct10dif_fallback);
  21 static DEFINE_MUTEX(crc_t10dif_mutex);
  22 static struct work_struct crct10dif_rehash_work;
  23
  24 static int crc_t10dif_notify(struct notifier_block *self, unsigned long val, void *data)
  25 {
  26         struct crypto_alg *alg = data;
  27
  28         if (val != CRYPTO_MSG_ALG_LOADED ||
  29             strncmp(alg->cra_name, CRC_T10DIF_STRING, strlen(CRC_T10DIF_STRING)))
  30                 return 0;
  31
  32         schedule_work(&crct10dif_rehash_work);
  33         return 0;
  34 }
  35
  36 static void crc_t10dif_rehash(struct work_struct *work)
  37 {
  38         struct crypto_shash *new, *old;
  39
  40         mutex_lock(&crc_t10dif_mutex);
  41         old = rcu_dereference_protected(crct10dif_tfm,
  42                                         lockdep_is_held(&crc_t10dif_mutex));
  43         new = crypto_alloc_shash("crct10dif", 0, 0);
  44         if (IS_ERR(new)) {
  45                 mutex_unlock(&crc_t10dif_mutex);
  46                 return;
  47         }
  48         rcu_assign_pointer(crct10dif_tfm, new);
  49         mutex_unlock(&crc_t10dif_mutex);
  50
  51         if (old) {
  52                 synchronize_rcu();
  53                 crypto_free_shash(old);
  54         } else {
  55                 static_branch_disable(&crct10dif_fallback);
  56         }
  57 }
  58
  59 static struct notifier_block crc_t10dif_nb = {
  60         .notifier_call = crc_t10dif_notify,
  61 };
  62
  63 __u16 crc_t10dif_update(__u16 crc, const unsigned char *buffer, size_t len)
  64 {
  65         struct {
  66                 struct shash_desc shash;
  67                 char ctx[2];
  68         } desc;
  69         int err;
  70
  71         if (static_branch_unlikely(&crct10dif_fallback))
  72                 return crc_t10dif_generic(crc, buffer, len);
  73
  74         rcu_read_lock();
  75         desc.shash.tfm = rcu_dereference(crct10dif_tfm);
  76         *(__u16 *)desc.ctx = crc;
  77
  78         err = crypto_shash_update(&desc.shash, buffer, len);
  79         rcu_read_unlock();
  80
  81         BUG_ON(err);
  82
  83         return *(__u16 *)desc.ctx;
  84 }
  85 EXPORT_SYMBOL(crc_t10dif_update);
  86
  87 __u16 crc_t10dif(const unsigned char *buffer, size_t len)
  88 {
  89         return crc_t10dif_update(0, buffer, len);
  90 }
  91 EXPORT_SYMBOL(crc_t10dif);
  92
  93 static int __init crc_t10dif_mod_init(void)
  94 {
  95         INIT_WORK(&crct10dif_rehash_work, crc_t10dif_rehash);
  96         crypto_register_notifier(&crc_t10dif_nb);
  97         crc_t10dif_rehash(&crct10dif_rehash_work);
  98         return 0;
  99 }
 100
 101 static void __exit crc_t10dif_mod_fini(void)
 102 {
 103         crypto_unregister_notifier(&crc_t10dif_nb);
 104         cancel_work_sync(&crct10dif_rehash_work);
 105         crypto_free_shash(rcu_dereference_protected(crct10dif_tfm, 1));
 106 }
 107
 108 module_init(crc_t10dif_mod_init);
 109 module_exit(crc_t10dif_mod_fini);
 110
 111 static int crc_t10dif_transform_show(char *buffer, const struct kernel_param *kp)
 112 {
 113         struct crypto_shash *tfm;
 114         const char *name;
 115         int len;
 116
 117         if (static_branch_unlikely(&crct10dif_fallback))
 118                 return sprintf(buffer, "fallback\n");
 119
 120         rcu_read_lock();
 121         tfm = rcu_dereference(crct10dif_tfm);
 122         name = crypto_tfm_alg_driver_name(crypto_shash_tfm(tfm));
 123         len = sprintf(buffer, "%s\n", name);
 124         rcu_read_unlock();
 125
 126         return len;
 127 }
 128
 129 module_param_call(transform, NULL, crc_t10dif_transform_show, NULL, 0644);
 130
 131 MODULE_DESCRIPTION("T10 DIF CRC calculation");
 132 MODULE_LICENSE("GPL");
 133 MODULE_SOFTDEP("pre: crct10dif");