1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2019 Samsung Electronics Co., Ltd. 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/string.h> 8 #include <linux/err.h> 9 #include <linux/slab.h> 10 #include <linux/wait.h> 11 #include <linux/sched.h> 12 13 #include "glob.h" 14 #include "crypto_ctx.h" 15 16 struct crypto_ctx_list { 17 spinlock_t ctx_lock; 18 int avail_ctx; 19 struct list_head idle_ctx; 20 wait_queue_head_t ctx_wait; 21 }; 22 23 static struct crypto_ctx_list ctx_list; 24 25 static inline void free_aead(struct crypto_aead *aead) 26 { 27 if (aead) 28 crypto_free_aead(aead); 29 } 30 31 static void free_shash(struct shash_desc *shash) 32 { 33 if (shash) { 34 crypto_free_shash(shash->tfm); 35 kfree(shash); 36 } 37 } 38 39 static struct crypto_aead *alloc_aead(int id) 40 { 41 struct crypto_aead *tfm = NULL; 42 43 switch (id) { 44 case CRYPTO_AEAD_AES_GCM: 45 tfm = crypto_alloc_aead("gcm(aes)", 0, 0); 46 break; 47 case CRYPTO_AEAD_AES_CCM: 48 tfm = crypto_alloc_aead("ccm(aes)", 0, 0); 49 break; 50 default: 51 pr_err("Does not support encrypt ahead(id : %d)\n", id); 52 return NULL; 53 } 54 55 if (IS_ERR(tfm)) { 56 pr_err("Failed to alloc encrypt aead : %ld\n", PTR_ERR(tfm)); 57 return NULL; 58 } 59 60 return tfm; 61 } 62 63 static struct shash_desc *alloc_shash_desc(int id) 64 { 65 struct crypto_shash *tfm = NULL; 66 struct shash_desc *shash; 67 68 switch (id) { 69 case CRYPTO_SHASH_HMACMD5: 70 tfm = crypto_alloc_shash("hmac(md5)", 0, 0); 71 break; 72 case CRYPTO_SHASH_HMACSHA256: 73 tfm = crypto_alloc_shash("hmac(sha256)", 0, 0); 74 break; 75 case CRYPTO_SHASH_CMACAES: 76 tfm = crypto_alloc_shash("cmac(aes)", 0, 0); 77 break; 78 case CRYPTO_SHASH_SHA256: 79 tfm = crypto_alloc_shash("sha256", 0, 0); 80 break; 81 case CRYPTO_SHASH_SHA512: 82 tfm = crypto_alloc_shash("sha512", 0, 0); 83 break; 84 default: 85 return NULL; 86 } 87 88 if (IS_ERR(tfm)) 89 return NULL; 90 91 shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(tfm), 92 GFP_KERNEL); 93 if (!shash) 94 crypto_free_shash(tfm); 95 else 96 shash->tfm = tfm; 97 return shash; 98 } 99 100 static void ctx_free(struct ksmbd_crypto_ctx *ctx) 101 { 102 int i; 103 104 for (i = 0; i < CRYPTO_SHASH_MAX; i++) 105 free_shash(ctx->desc[i]); 106 for (i = 0; i < CRYPTO_AEAD_MAX; i++) 107 free_aead(ctx->ccmaes[i]); 108 kfree(ctx); 109 } 110 111 static struct ksmbd_crypto_ctx *ksmbd_find_crypto_ctx(void) 112 { 113 struct ksmbd_crypto_ctx *ctx; 114 115 while (1) { 116 spin_lock(&ctx_list.ctx_lock); 117 if (!list_empty(&ctx_list.idle_ctx)) { 118 ctx = list_entry(ctx_list.idle_ctx.next, 119 struct ksmbd_crypto_ctx, 120 list); 121 list_del(&ctx->list); 122 spin_unlock(&ctx_list.ctx_lock); 123 return ctx; 124 } 125 126 if (ctx_list.avail_ctx > num_online_cpus()) { 127 spin_unlock(&ctx_list.ctx_lock); 128 wait_event(ctx_list.ctx_wait, 129 !list_empty(&ctx_list.idle_ctx)); 130 continue; 131 } 132 133 ctx_list.avail_ctx++; 134 spin_unlock(&ctx_list.ctx_lock); 135 136 ctx = kzalloc(sizeof(struct ksmbd_crypto_ctx), GFP_KERNEL); 137 if (!ctx) { 138 spin_lock(&ctx_list.ctx_lock); 139 ctx_list.avail_ctx--; 140 spin_unlock(&ctx_list.ctx_lock); 141 wait_event(ctx_list.ctx_wait, 142 !list_empty(&ctx_list.idle_ctx)); 143 continue; 144 } 145 break; 146 } 147 return ctx; 148 } 149 150 void ksmbd_release_crypto_ctx(struct ksmbd_crypto_ctx *ctx) 151 { 152 if (!ctx) 153 return; 154 155 spin_lock(&ctx_list.ctx_lock); 156 if (ctx_list.avail_ctx <= num_online_cpus()) { 157 list_add(&ctx->list, &ctx_list.idle_ctx); 158 spin_unlock(&ctx_list.ctx_lock); 159 wake_up(&ctx_list.ctx_wait); 160 return; 161 } 162 163 ctx_list.avail_ctx--; 164 spin_unlock(&ctx_list.ctx_lock); 165 ctx_free(ctx); 166 } 167 168 static struct ksmbd_crypto_ctx *____crypto_shash_ctx_find(int id) 169 { 170 struct ksmbd_crypto_ctx *ctx; 171 172 if (id >= CRYPTO_SHASH_MAX) 173 return NULL; 174 175 ctx = ksmbd_find_crypto_ctx(); 176 if (ctx->desc[id]) 177 return ctx; 178 179 ctx->desc[id] = alloc_shash_desc(id); 180 if (ctx->desc[id]) 181 return ctx; 182 ksmbd_release_crypto_ctx(ctx); 183 return NULL; 184 } 185 186 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_hmacmd5(void) 187 { 188 return ____crypto_shash_ctx_find(CRYPTO_SHASH_HMACMD5); 189 } 190 191 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_hmacsha256(void) 192 { 193 return ____crypto_shash_ctx_find(CRYPTO_SHASH_HMACSHA256); 194 } 195 196 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_cmacaes(void) 197 { 198 return ____crypto_shash_ctx_find(CRYPTO_SHASH_CMACAES); 199 } 200 201 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_sha256(void) 202 { 203 return ____crypto_shash_ctx_find(CRYPTO_SHASH_SHA256); 204 } 205 206 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_sha512(void) 207 { 208 return ____crypto_shash_ctx_find(CRYPTO_SHASH_SHA512); 209 } 210 211 static struct ksmbd_crypto_ctx *____crypto_aead_ctx_find(int id) 212 { 213 struct ksmbd_crypto_ctx *ctx; 214 215 if (id >= CRYPTO_AEAD_MAX) 216 return NULL; 217 218 ctx = ksmbd_find_crypto_ctx(); 219 if (ctx->ccmaes[id]) 220 return ctx; 221 222 ctx->ccmaes[id] = alloc_aead(id); 223 if (ctx->ccmaes[id]) 224 return ctx; 225 ksmbd_release_crypto_ctx(ctx); 226 return NULL; 227 } 228 229 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_gcm(void) 230 { 231 return ____crypto_aead_ctx_find(CRYPTO_AEAD_AES_GCM); 232 } 233 234 struct ksmbd_crypto_ctx *ksmbd_crypto_ctx_find_ccm(void) 235 { 236 return ____crypto_aead_ctx_find(CRYPTO_AEAD_AES_CCM); 237 } 238 239 void ksmbd_crypto_destroy(void) 240 { 241 struct ksmbd_crypto_ctx *ctx; 242 243 while (!list_empty(&ctx_list.idle_ctx)) { 244 ctx = list_entry(ctx_list.idle_ctx.next, 245 struct ksmbd_crypto_ctx, 246 list); 247 list_del(&ctx->list); 248 ctx_free(ctx); 249 } 250 } 251 252 int ksmbd_crypto_create(void) 253 { 254 struct ksmbd_crypto_ctx *ctx; 255 256 spin_lock_init(&ctx_list.ctx_lock); 257 INIT_LIST_HEAD(&ctx_list.idle_ctx); 258 init_waitqueue_head(&ctx_list.ctx_wait); 259 ctx_list.avail_ctx = 1; 260 261 ctx = kzalloc(sizeof(struct ksmbd_crypto_ctx), GFP_KERNEL); 262 if (!ctx) 263 return -ENOMEM; 264 list_add(&ctx->list, &ctx_list.idle_ctx); 265 return 0; 266 } 267