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 struct static_key crct10dif_fallback __read_mostly;
  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             static_key_false(&crct10dif_fallback) ||
  30             strncmp(alg->cra_name, CRC_T10DIF_STRING, strlen(CRC_T10DIF_STRING)))
  31                 return 0;
  32
  33         schedule_work(&crct10dif_rehash_work);
  34         return 0;
  35 }
  36
  37 static void crc_t10dif_rehash(struct work_struct *work)
  38 {
  39         struct crypto_shash *new, *old;
  40
  41         mutex_lock(&crc_t10dif_mutex);
  42         old = rcu_dereference_protected(crct10dif_tfm,
  43                                         lockdep_is_held(&crc_t10dif_mutex));
  44         if (!old) {
  45                 mutex_unlock(&crc_t10dif_mutex);
  46                 return;
  47         }
  48         new = crypto_alloc_shash("crct10dif", 0, 0);
  49         if (IS_ERR(new)) {
  50                 mutex_unlock(&crc_t10dif_mutex);
  51                 return;
  52         }
  53         rcu_assign_pointer(crct10dif_tfm, new);
  54         mutex_unlock(&crc_t10dif_mutex);
  55
  56         synchronize_rcu();
  57         crypto_free_shash(old);
  58 }
  59
  60 static struct notifier_block crc_t10dif_nb = {
  61         .notifier_call = crc_t10dif_notify,
  62 };
  63
  64 __u16 crc_t10dif_update(__u16 crc, const unsigned char *buffer, size_t len)
  65 {
  66         struct {
  67                 struct shash_desc shash;
  68                 char ctx[2];
  69         } desc;
  70         int err;
  71
  72         if (static_key_false(&crct10dif_fallback))
  73                 return crc_t10dif_generic(crc, buffer, len);
  74
  75         rcu_read_lock();
  76         desc.shash.tfm = rcu_dereference(crct10dif_tfm);
  77         *(__u16 *)desc.ctx = crc;
  78
  79         err = crypto_shash_update(&desc.shash, buffer, len);
  80         rcu_read_unlock();
  81
  82         BUG_ON(err);
  83
  84         return *(__u16 *)desc.ctx;
  85 }
  86 EXPORT_SYMBOL(crc_t10dif_update);
  87
  88 __u16 crc_t10dif(const unsigned char *buffer, size_t len)
  89 {
  90         return crc_t10dif_update(0, buffer, len);
  91 }
  92 EXPORT_SYMBOL(crc_t10dif);
  93
  94 static int __init crc_t10dif_mod_init(void)
  95 {
  96         struct crypto_shash *tfm;
  97
  98         INIT_WORK(&crct10dif_rehash_work, crc_t10dif_rehash);
  99         crypto_register_notifier(&crc_t10dif_nb);
 100         mutex_lock(&crc_t10dif_mutex);
 101         tfm = crypto_alloc_shash("crct10dif", 0, 0);
 102         if (IS_ERR(tfm)) {
 103                 static_key_slow_inc(&crct10dif_fallback);
 104                 tfm = NULL;
 105         }
 106         RCU_INIT_POINTER(crct10dif_tfm, tfm);
 107         mutex_unlock(&crc_t10dif_mutex);
 108         return 0;
 109 }
 110
 111 static void __exit crc_t10dif_mod_fini(void)
 112 {
 113         crypto_unregister_notifier(&crc_t10dif_nb);
 114         cancel_work_sync(&crct10dif_rehash_work);
 115         crypto_free_shash(rcu_dereference_protected(crct10dif_tfm, 1));
 116 }
 117
 118 module_init(crc_t10dif_mod_init);
 119 module_exit(crc_t10dif_mod_fini);
 120
 121 static int crc_t10dif_transform_show(char *buffer, const struct kernel_param *kp)
 122 {
 123         struct crypto_shash *tfm;
 124         const char *name;
 125         int len;
 126
 127         if (static_key_false(&crct10dif_fallback))
 128                 return sprintf(buffer, "fallback\n");
 129
 130         rcu_read_lock();
 131         tfm = rcu_dereference(crct10dif_tfm);
 132         if (!tfm) {
 133                 len = sprintf(buffer, "init\n");
 134                 goto unlock;
 135         }
 136
 137         name = crypto_tfm_alg_driver_name(crypto_shash_tfm(tfm));
 138         len = sprintf(buffer, "%s\n", name);
 139
 140 unlock:
 141         rcu_read_unlock();
 142
 143         return len;
 144 }
 145
 146 module_param_call(transform, NULL, crc_t10dif_transform_show, NULL, 0644);
 147
 148 MODULE_DESCRIPTION("T10 DIF CRC calculation");
 149 MODULE_LICENSE("GPL");
 150 MODULE_SOFTDEP("pre: crct10dif");