Blame view
crypto/af_alg.c
25.6 KB
2874c5fd2 treewide: Replace... |
1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
03c8efc1f crypto: af_alg - ... |
2 3 4 5 6 7 |
/* * af_alg: User-space algorithm interface * * This file provides the user-space API for algorithms. * * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au> |
03c8efc1f crypto: af_alg - ... |
8 |
*/ |
60063497a atomic: use <linu... |
9 |
#include <linux/atomic.h> |
03c8efc1f crypto: af_alg - ... |
10 11 12 13 14 15 16 17 |
#include <crypto/if_alg.h> #include <linux/crypto.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/list.h> #include <linux/module.h> #include <linux/net.h> #include <linux/rwsem.h> |
2d97591ef crypto: af_alg - ... |
18 |
#include <linux/sched/signal.h> |
4c63f83c2 crypto: af_alg - ... |
19 |
#include <linux/security.h> |
03c8efc1f crypto: af_alg - ... |
20 21 22 23 24 |
struct alg_type_list { const struct af_alg_type *type; struct list_head list; }; |
068695245 crypto: af_alg - ... |
25 |
static atomic_long_t alg_memory_allocated; |
03c8efc1f crypto: af_alg - ... |
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
static struct proto alg_proto = { .name = "ALG", .owner = THIS_MODULE, .memory_allocated = &alg_memory_allocated, .obj_size = sizeof(struct alg_sock), }; static LIST_HEAD(alg_types); static DECLARE_RWSEM(alg_types_sem); static const struct af_alg_type *alg_get_type(const char *name) { const struct af_alg_type *type = ERR_PTR(-ENOENT); struct alg_type_list *node; down_read(&alg_types_sem); list_for_each_entry(node, &alg_types, list) { if (strcmp(node->type->name, name)) continue; if (try_module_get(node->type->owner)) type = node->type; break; } up_read(&alg_types_sem); return type; } int af_alg_register_type(const struct af_alg_type *type) { struct alg_type_list *node; int err = -EEXIST; down_write(&alg_types_sem); list_for_each_entry(node, &alg_types, list) { if (!strcmp(node->type->name, type->name)) goto unlock; } node = kmalloc(sizeof(*node), GFP_KERNEL); err = -ENOMEM; if (!node) goto unlock; type->ops->owner = THIS_MODULE; |
37766586c crypto: af_alg - ... |
73 74 |
if (type->ops_nokey) type->ops_nokey->owner = THIS_MODULE; |
03c8efc1f crypto: af_alg - ... |
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 |
node->type = type; list_add(&node->list, &alg_types); err = 0; unlock: up_write(&alg_types_sem); return err; } EXPORT_SYMBOL_GPL(af_alg_register_type); int af_alg_unregister_type(const struct af_alg_type *type) { struct alg_type_list *node; int err = -ENOENT; down_write(&alg_types_sem); list_for_each_entry(node, &alg_types, list) { if (strcmp(node->type->name, type->name)) continue; list_del(&node->list); kfree(node); err = 0; break; } up_write(&alg_types_sem); return err; } EXPORT_SYMBOL_GPL(af_alg_unregister_type); static void alg_do_release(const struct af_alg_type *type, void *private) { if (!type) return; type->release(private); module_put(type->owner); } int af_alg_release(struct socket *sock) { |
9060cb719 net: crypto set s... |
118 |
if (sock->sk) { |
03c8efc1f crypto: af_alg - ... |
119 |
sock_put(sock->sk); |
9060cb719 net: crypto set s... |
120 121 |
sock->sk = NULL; } |
03c8efc1f crypto: af_alg - ... |
122 123 124 |
return 0; } EXPORT_SYMBOL_GPL(af_alg_release); |
c840ac6af crypto: af_alg - ... |
125 126 127 |
void af_alg_release_parent(struct sock *sk) { struct alg_sock *ask = alg_sk(sk); |
a6a48c565 crypto: af_alg - ... |
128 129 |
unsigned int nokey = ask->nokey_refcnt; bool last = nokey && !ask->refcnt; |
c840ac6af crypto: af_alg - ... |
130 131 132 |
sk = ask->parent; ask = alg_sk(sk); |
9d9b578ff crypto: af_alg - ... |
133 134 |
local_bh_disable(); bh_lock_sock(sk); |
a6a48c565 crypto: af_alg - ... |
135 136 137 |
ask->nokey_refcnt -= nokey; if (!last) last = !--ask->refcnt; |
9d9b578ff crypto: af_alg - ... |
138 139 |
bh_unlock_sock(sk); local_bh_enable(); |
c840ac6af crypto: af_alg - ... |
140 141 142 143 144 |
if (last) sock_put(sk); } EXPORT_SYMBOL_GPL(af_alg_release_parent); |
03c8efc1f crypto: af_alg - ... |
145 146 |
static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) { |
bb30b8848 crypto: af_alg - ... |
147 |
const u32 allowed = CRYPTO_ALG_KERN_DRIVER_ONLY; |
03c8efc1f crypto: af_alg - ... |
148 149 150 151 152 |
struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct sockaddr_alg *sa = (void *)uaddr; const struct af_alg_type *type; void *private; |
c840ac6af crypto: af_alg - ... |
153 |
int err; |
03c8efc1f crypto: af_alg - ... |
154 155 156 |
if (sock->state == SS_CONNECTED) return -EINVAL; |
3f69cc607 crypto: af_alg - ... |
157 |
if (addr_len < sizeof(*sa)) |
03c8efc1f crypto: af_alg - ... |
158 |
return -EINVAL; |
a466856e0 crypto: af_alg - ... |
159 160 161 |
/* If caller uses non-allowed flag, return error. */ if ((sa->salg_feat & ~allowed) || (sa->salg_mask & ~allowed)) return -EINVAL; |
03c8efc1f crypto: af_alg - ... |
162 |
sa->salg_type[sizeof(sa->salg_type) - 1] = 0; |
3f69cc607 crypto: af_alg - ... |
163 |
sa->salg_name[sizeof(sa->salg_name) + addr_len - sizeof(*sa) - 1] = 0; |
03c8efc1f crypto: af_alg - ... |
164 165 166 167 168 169 170 171 172 |
type = alg_get_type(sa->salg_type); if (IS_ERR(type) && PTR_ERR(type) == -ENOENT) { request_module("algif-%s", sa->salg_type); type = alg_get_type(sa->salg_type); } if (IS_ERR(type)) return PTR_ERR(type); |
bb30b8848 crypto: af_alg - ... |
173 |
private = type->bind(sa->salg_name, sa->salg_feat, sa->salg_mask); |
03c8efc1f crypto: af_alg - ... |
174 175 176 177 |
if (IS_ERR(private)) { module_put(type->owner); return PTR_ERR(private); } |
c840ac6af crypto: af_alg - ... |
178 |
err = -EBUSY; |
03c8efc1f crypto: af_alg - ... |
179 |
lock_sock(sk); |
a6a48c565 crypto: af_alg - ... |
180 |
if (ask->refcnt | ask->nokey_refcnt) |
c840ac6af crypto: af_alg - ... |
181 |
goto unlock; |
03c8efc1f crypto: af_alg - ... |
182 183 184 |
swap(ask->type, type); swap(ask->private, private); |
c840ac6af crypto: af_alg - ... |
185 186 187 |
err = 0; unlock: |
03c8efc1f crypto: af_alg - ... |
188 189 190 |
release_sock(sk); alg_do_release(type, private); |
c840ac6af crypto: af_alg - ... |
191 |
return err; |
03c8efc1f crypto: af_alg - ... |
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 |
} static int alg_setkey(struct sock *sk, char __user *ukey, unsigned int keylen) { struct alg_sock *ask = alg_sk(sk); const struct af_alg_type *type = ask->type; u8 *key; int err; key = sock_kmalloc(sk, keylen, GFP_KERNEL); if (!key) return -ENOMEM; err = -EFAULT; if (copy_from_user(key, ukey, keylen)) goto out; err = type->setkey(ask->private, key, keylen); out: |
ad202c8c1 crypto: af_alg - ... |
213 |
sock_kzfree_s(sk, key, keylen); |
03c8efc1f crypto: af_alg - ... |
214 215 216 217 218 219 220 221 222 223 |
return err; } static int alg_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen) { struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); const struct af_alg_type *type; |
c840ac6af crypto: af_alg - ... |
224 |
int err = -EBUSY; |
03c8efc1f crypto: af_alg - ... |
225 226 |
lock_sock(sk); |
c840ac6af crypto: af_alg - ... |
227 228 |
if (ask->refcnt) goto unlock; |
03c8efc1f crypto: af_alg - ... |
229 |
type = ask->type; |
c840ac6af crypto: af_alg - ... |
230 |
err = -ENOPROTOOPT; |
03c8efc1f crypto: af_alg - ... |
231 232 233 234 235 236 237 238 239 240 241 |
if (level != SOL_ALG || !type) goto unlock; switch (optname) { case ALG_SET_KEY: if (sock->state == SS_CONNECTED) goto unlock; if (!type->setkey) goto unlock; err = alg_setkey(sk, optval, optlen); |
25fb8638e crypto: af_alg - ... |
242 243 244 245 246 247 248 |
break; case ALG_SET_AEAD_AUTHSIZE: if (sock->state == SS_CONNECTED) goto unlock; if (!type->setauthsize) goto unlock; err = type->setauthsize(ask->private, optlen); |
03c8efc1f crypto: af_alg - ... |
249 250 251 252 253 254 255 |
} unlock: release_sock(sk); return err; } |
cdfbabfb2 net: Work around ... |
256 |
int af_alg_accept(struct sock *sk, struct socket *newsock, bool kern) |
03c8efc1f crypto: af_alg - ... |
257 258 259 260 |
{ struct alg_sock *ask = alg_sk(sk); const struct af_alg_type *type; struct sock *sk2; |
6a935170a crypto: af_alg - ... |
261 |
unsigned int nokey; |
03c8efc1f crypto: af_alg - ... |
262 263 264 265 266 267 268 269 |
int err; lock_sock(sk); type = ask->type; err = -EINVAL; if (!type) goto unlock; |
cdfbabfb2 net: Work around ... |
270 |
sk2 = sk_alloc(sock_net(sk), PF_ALG, GFP_KERNEL, &alg_proto, kern); |
03c8efc1f crypto: af_alg - ... |
271 272 273 274 275 |
err = -ENOMEM; if (!sk2) goto unlock; sock_init_data(newsock, sk2); |
2acce6aa9 Networking |
276 |
security_sock_graft(sk2, newsock); |
4c63f83c2 crypto: af_alg - ... |
277 |
security_sk_clone(sk, sk2); |
03c8efc1f crypto: af_alg - ... |
278 279 |
err = type->accept(ask->private, sk2); |
37766586c crypto: af_alg - ... |
280 281 282 283 |
nokey = err == -ENOKEY; if (nokey && type->accept_nokey) err = type->accept_nokey(ask->private, sk2); |
a383292c8 crypto: af_alg - ... |
284 |
if (err) |
03c8efc1f crypto: af_alg - ... |
285 |
goto unlock; |
03c8efc1f crypto: af_alg - ... |
286 |
|
37766586c crypto: af_alg - ... |
287 |
if (nokey || !ask->refcnt++) |
c840ac6af crypto: af_alg - ... |
288 |
sock_hold(sk); |
a6a48c565 crypto: af_alg - ... |
289 |
ask->nokey_refcnt += nokey; |
03c8efc1f crypto: af_alg - ... |
290 291 |
alg_sk(sk2)->parent = sk; alg_sk(sk2)->type = type; |
6a935170a crypto: af_alg - ... |
292 |
alg_sk(sk2)->nokey_refcnt = nokey; |
03c8efc1f crypto: af_alg - ... |
293 294 295 |
newsock->ops = type->ops; newsock->state = SS_CONNECTED; |
37766586c crypto: af_alg - ... |
296 297 |
if (nokey) newsock->ops = type->ops_nokey; |
03c8efc1f crypto: af_alg - ... |
298 299 300 301 302 303 304 305 |
err = 0; unlock: release_sock(sk); return err; } EXPORT_SYMBOL_GPL(af_alg_accept); |
cdfbabfb2 net: Work around ... |
306 307 |
static int alg_accept(struct socket *sock, struct socket *newsock, int flags, bool kern) |
03c8efc1f crypto: af_alg - ... |
308 |
{ |
cdfbabfb2 net: Work around ... |
309 |
return af_alg_accept(sock->sk, newsock, kern); |
03c8efc1f crypto: af_alg - ... |
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 |
} static const struct proto_ops alg_proto_ops = { .family = PF_ALG, .owner = THIS_MODULE, .connect = sock_no_connect, .socketpair = sock_no_socketpair, .getname = sock_no_getname, .ioctl = sock_no_ioctl, .listen = sock_no_listen, .shutdown = sock_no_shutdown, .getsockopt = sock_no_getsockopt, .mmap = sock_no_mmap, .sendpage = sock_no_sendpage, .sendmsg = sock_no_sendmsg, .recvmsg = sock_no_recvmsg, |
03c8efc1f crypto: af_alg - ... |
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 |
.bind = alg_bind, .release = af_alg_release, .setsockopt = alg_setsockopt, .accept = alg_accept, }; static void alg_sock_destruct(struct sock *sk) { struct alg_sock *ask = alg_sk(sk); alg_do_release(ask->type, ask->private); } static int alg_create(struct net *net, struct socket *sock, int protocol, int kern) { struct sock *sk; int err; if (sock->type != SOCK_SEQPACKET) return -ESOCKTNOSUPPORT; if (protocol != 0) return -EPROTONOSUPPORT; err = -ENOMEM; |
11aa9c28b net: Pass kern fr... |
353 |
sk = sk_alloc(net, PF_ALG, GFP_KERNEL, &alg_proto, kern); |
03c8efc1f crypto: af_alg - ... |
354 355 356 357 358 |
if (!sk) goto out; sock->ops = &alg_proto_ops; sock_init_data(sock, sk); |
03c8efc1f crypto: af_alg - ... |
359 360 361 362 363 364 365 366 367 368 369 370 |
sk->sk_destruct = alg_sock_destruct; return 0; out: return err; } static const struct net_proto_family alg_family = { .family = PF_ALG, .create = alg_create, .owner = THIS_MODULE, }; |
1d10eb2f1 crypto: switch af... |
371 |
int af_alg_make_sg(struct af_alg_sgl *sgl, struct iov_iter *iter, int len) |
03c8efc1f crypto: af_alg - ... |
372 |
{ |
1d10eb2f1 crypto: switch af... |
373 374 375 |
size_t off; ssize_t n; int npages, i; |
03c8efc1f crypto: af_alg - ... |
376 |
|
1d10eb2f1 crypto: switch af... |
377 378 379 |
n = iov_iter_get_pages(iter, sgl->pages, len, ALG_MAX_PAGES, &off); if (n < 0) return n; |
03c8efc1f crypto: af_alg - ... |
380 |
|
9399f0c51 crypto: fix af_al... |
381 |
npages = (off + n + PAGE_SIZE - 1) >> PAGE_SHIFT; |
03c8efc1f crypto: af_alg - ... |
382 |
if (WARN_ON(npages == 0)) |
1d10eb2f1 crypto: switch af... |
383 |
return -EINVAL; |
66db37391 crypto: af_alg - ... |
384 385 |
/* Add one extra for linking */ sg_init_table(sgl->sg, npages + 1); |
03c8efc1f crypto: af_alg - ... |
386 |
|
1d10eb2f1 crypto: switch af... |
387 |
for (i = 0, len = n; i < npages; i++) { |
03c8efc1f crypto: af_alg - ... |
388 389 390 391 392 393 |
int plen = min_t(int, len, PAGE_SIZE - off); sg_set_page(sgl->sg + i, sgl->pages[i], plen, off); off = 0; len -= plen; |
03c8efc1f crypto: af_alg - ... |
394 |
} |
66db37391 crypto: af_alg - ... |
395 396 |
sg_mark_end(sgl->sg + npages - 1); sgl->npages = npages; |
1d10eb2f1 crypto: switch af... |
397 |
return n; |
03c8efc1f crypto: af_alg - ... |
398 399 |
} EXPORT_SYMBOL_GPL(af_alg_make_sg); |
466e07592 crypto: af_alg - ... |
400 401 |
static void af_alg_link_sg(struct af_alg_sgl *sgl_prev, struct af_alg_sgl *sgl_new) |
66db37391 crypto: af_alg - ... |
402 403 404 405 |
{ sg_unmark_end(sgl_prev->sg + sgl_prev->npages - 1); sg_chain(sgl_prev->sg, sgl_prev->npages + 1, sgl_new->sg); } |
66db37391 crypto: af_alg - ... |
406 |
|
03c8efc1f crypto: af_alg - ... |
407 408 409 |
void af_alg_free_sg(struct af_alg_sgl *sgl) { int i; |
66db37391 crypto: af_alg - ... |
410 |
for (i = 0; i < sgl->npages; i++) |
03c8efc1f crypto: af_alg - ... |
411 |
put_page(sgl->pages[i]); |
03c8efc1f crypto: af_alg - ... |
412 413 |
} EXPORT_SYMBOL_GPL(af_alg_free_sg); |
466e07592 crypto: af_alg - ... |
414 |
static int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con) |
03c8efc1f crypto: af_alg - ... |
415 416 |
{ struct cmsghdr *cmsg; |
f95b414ed net: introduce he... |
417 |
for_each_cmsghdr(cmsg, msg) { |
03c8efc1f crypto: af_alg - ... |
418 419 420 421 |
if (!CMSG_OK(msg, cmsg)) return -EINVAL; if (cmsg->cmsg_level != SOL_ALG) continue; |
267c4221f crypto: af_alg - ... |
422 |
switch (cmsg->cmsg_type) { |
03c8efc1f crypto: af_alg - ... |
423 424 425 426 427 428 429 430 431 432 433 434 435 436 |
case ALG_SET_IV: if (cmsg->cmsg_len < CMSG_LEN(sizeof(*con->iv))) return -EINVAL; con->iv = (void *)CMSG_DATA(cmsg); if (cmsg->cmsg_len < CMSG_LEN(con->iv->ivlen + sizeof(*con->iv))) return -EINVAL; break; case ALG_SET_OP: if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32))) return -EINVAL; con->op = *(u32 *)CMSG_DATA(cmsg); break; |
af8e80731 crypto: af_alg - ... |
437 438 439 440 441 |
case ALG_SET_AEAD_ASSOCLEN: if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32))) return -EINVAL; con->aead_assoclen = *(u32 *)CMSG_DATA(cmsg); break; |
03c8efc1f crypto: af_alg - ... |
442 443 444 445 446 447 448 |
default: return -EINVAL; } } return 0; } |
03c8efc1f crypto: af_alg - ... |
449 |
|
2d97591ef crypto: af_alg - ... |
450 451 452 453 454 455 |
/** * af_alg_alloc_tsgl - allocate the TX SGL * * @sk socket of connection to user space * @return: 0 upon success, < 0 upon error */ |
466e07592 crypto: af_alg - ... |
456 |
static int af_alg_alloc_tsgl(struct sock *sk) |
2d97591ef crypto: af_alg - ... |
457 458 459 460 461 462 463 464 465 466 467 |
{ struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_tsgl *sgl; struct scatterlist *sg = NULL; sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl, list); if (!list_empty(&ctx->tsgl_list)) sg = sgl->sg; if (!sg || sgl->cur >= MAX_SGL_ENTS) { |
0ed2dd03b treewide: Use str... |
468 469 |
sgl = sock_kmalloc(sk, struct_size(sgl, sg, (MAX_SGL_ENTS + 1)), |
2d97591ef crypto: af_alg - ... |
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 |
GFP_KERNEL); if (!sgl) return -ENOMEM; sg_init_table(sgl->sg, MAX_SGL_ENTS + 1); sgl->cur = 0; if (sg) sg_chain(sg, MAX_SGL_ENTS + 1, sgl->sg); list_add_tail(&sgl->list, &ctx->tsgl_list); } return 0; } |
2d97591ef crypto: af_alg - ... |
485 486 487 488 489 490 491 492 493 494 495 496 497 498 |
/** * aead_count_tsgl - Count number of TX SG entries * * The counting starts from the beginning of the SGL to @bytes. If * an offset is provided, the counting of the SG entries starts at the offset. * * @sk socket of connection to user space * @bytes Count the number of SG entries holding given number of bytes. * @offset Start the counting of SG entries from the given offset. * @return Number of TX SG entries found given the constraints */ unsigned int af_alg_count_tsgl(struct sock *sk, size_t bytes, size_t offset) { |
7c39edfb0 crypto: af_alg - ... |
499 500 501 |
const struct alg_sock *ask = alg_sk(sk); const struct af_alg_ctx *ctx = ask->private; const struct af_alg_tsgl *sgl; |
2d97591ef crypto: af_alg - ... |
502 503 504 505 506 |
unsigned int i; unsigned int sgl_count = 0; if (!bytes) return 0; |
7c39edfb0 crypto: af_alg - ... |
507 508 |
list_for_each_entry(sgl, &ctx->tsgl_list, list) { const struct scatterlist *sg = sgl->sg; |
2d97591ef crypto: af_alg - ... |
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 |
for (i = 0; i < sgl->cur; i++) { size_t bytes_count; /* Skip offset */ if (offset >= sg[i].length) { offset -= sg[i].length; bytes -= sg[i].length; continue; } bytes_count = sg[i].length - offset; offset = 0; sgl_count++; /* If we have seen requested number of bytes, stop */ if (bytes_count >= bytes) return sgl_count; bytes -= bytes_count; } } return sgl_count; } EXPORT_SYMBOL_GPL(af_alg_count_tsgl); /** * aead_pull_tsgl - Release the specified buffers from TX SGL * * If @dst is non-null, reassign the pages to dst. The caller must release * the pages. If @dst_offset is given only reassign the pages to @dst starting * at the @dst_offset (byte). The caller must ensure that @dst is large * enough (e.g. by using af_alg_count_tsgl with the same offset). * * @sk socket of connection to user space * @used Number of bytes to pull from TX SGL * @dst If non-NULL, buffer is reassigned to dst SGL instead of releasing. The * caller must release the buffers in dst. * @dst_offset Reassign the TX SGL from given offset. All buffers before * reaching the offset is released. */ void af_alg_pull_tsgl(struct sock *sk, size_t used, struct scatterlist *dst, size_t dst_offset) { struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_tsgl *sgl; struct scatterlist *sg; |
e117765a1 crypto: af_alg - ... |
559 |
unsigned int i, j = 0; |
2d97591ef crypto: af_alg - ... |
560 561 562 563 564 |
while (!list_empty(&ctx->tsgl_list)) { sgl = list_first_entry(&ctx->tsgl_list, struct af_alg_tsgl, list); sg = sgl->sg; |
e117765a1 crypto: af_alg - ... |
565 |
for (i = 0; i < sgl->cur; i++) { |
2d97591ef crypto: af_alg - ... |
566 567 568 569 570 571 572 573 574 575 576 577 578 579 |
size_t plen = min_t(size_t, used, sg[i].length); struct page *page = sg_page(sg + i); if (!page) continue; /* * Assumption: caller created af_alg_count_tsgl(len) * SG entries in dst. */ if (dst) { if (dst_offset >= plen) { /* discard page before offset */ dst_offset -= plen; |
2d97591ef crypto: af_alg - ... |
580 581 |
} else { /* reassign page to dst after offset */ |
2d45a7e89 crypto: af_alg - ... |
582 |
get_page(page); |
2d97591ef crypto: af_alg - ... |
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 |
sg_set_page(dst + j, page, plen - dst_offset, sg[i].offset + dst_offset); dst_offset = 0; j++; } } sg[i].length -= plen; sg[i].offset += plen; used -= plen; ctx->used -= plen; if (sg[i].length) return; |
2d45a7e89 crypto: af_alg - ... |
599 |
put_page(page); |
2d97591ef crypto: af_alg - ... |
600 601 602 603 |
sg_assign_page(sg + i, NULL); } list_del(&sgl->list); |
91e14842f crypto: af_alg - ... |
604 |
sock_kfree_s(sk, sgl, struct_size(sgl, sg, MAX_SGL_ENTS + 1)); |
2d97591ef crypto: af_alg - ... |
605 606 607 608 609 610 611 612 613 614 615 616 |
} if (!ctx->used) ctx->merge = 0; } EXPORT_SYMBOL_GPL(af_alg_pull_tsgl); /** * af_alg_free_areq_sgls - Release TX and RX SGLs of the request * * @areq Request holding the TX and RX SGL */ |
466e07592 crypto: af_alg - ... |
617 |
static void af_alg_free_areq_sgls(struct af_alg_async_req *areq) |
2d97591ef crypto: af_alg - ... |
618 619 620 621 622 623 624 625 626 627 |
{ struct sock *sk = areq->sk; struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_rsgl *rsgl, *tmp; struct scatterlist *tsgl; struct scatterlist *sg; unsigned int i; list_for_each_entry_safe(rsgl, tmp, &areq->rsgl_list, list) { |
af955bf15 crypto: af_alg - ... |
628 |
atomic_sub(rsgl->sg_num_bytes, &ctx->rcvused); |
2d97591ef crypto: af_alg - ... |
629 630 631 632 633 634 635 |
af_alg_free_sg(&rsgl->sgl); list_del(&rsgl->list); if (rsgl != &areq->first_rsgl) sock_kfree_s(sk, rsgl, sizeof(*rsgl)); } tsgl = areq->tsgl; |
887207ed9 crypto: af_alg - ... |
636 637 638 639 640 641 |
if (tsgl) { for_each_sg(tsgl, sg, areq->tsgl_entries, i) { if (!sg_page(sg)) continue; put_page(sg_page(sg)); } |
2d97591ef crypto: af_alg - ... |
642 |
|
2d97591ef crypto: af_alg - ... |
643 |
sock_kfree_s(sk, tsgl, areq->tsgl_entries * sizeof(*tsgl)); |
887207ed9 crypto: af_alg - ... |
644 |
} |
2d97591ef crypto: af_alg - ... |
645 |
} |
2d97591ef crypto: af_alg - ... |
646 647 648 649 650 651 652 653 |
/** * af_alg_wait_for_wmem - wait for availability of writable memory * * @sk socket of connection to user space * @flags If MSG_DONTWAIT is set, then only report if function would sleep * @return 0 when writable memory is available, < 0 upon error */ |
466e07592 crypto: af_alg - ... |
654 |
static int af_alg_wait_for_wmem(struct sock *sk, unsigned int flags) |
2d97591ef crypto: af_alg - ... |
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 |
{ DEFINE_WAIT_FUNC(wait, woken_wake_function); int err = -ERESTARTSYS; long timeout; if (flags & MSG_DONTWAIT) return -EAGAIN; sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk); add_wait_queue(sk_sleep(sk), &wait); for (;;) { if (signal_pending(current)) break; timeout = MAX_SCHEDULE_TIMEOUT; if (sk_wait_event(sk, &timeout, af_alg_writable(sk), &wait)) { err = 0; break; } } remove_wait_queue(sk_sleep(sk), &wait); return err; } |
2d97591ef crypto: af_alg - ... |
679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 |
/** * af_alg_wmem_wakeup - wakeup caller when writable memory is available * * @sk socket of connection to user space */ void af_alg_wmem_wakeup(struct sock *sk) { struct socket_wq *wq; if (!af_alg_writable(sk)) return; rcu_read_lock(); wq = rcu_dereference(sk->sk_wq); if (skwq_has_sleeper(wq)) |
a9a08845e vfs: do bulk POLL... |
695 696 697 |
wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLRDNORM | EPOLLRDBAND); |
2d97591ef crypto: af_alg - ... |
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 |
sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN); rcu_read_unlock(); } EXPORT_SYMBOL_GPL(af_alg_wmem_wakeup); /** * af_alg_wait_for_data - wait for availability of TX data * * @sk socket of connection to user space * @flags If MSG_DONTWAIT is set, then only report if function would sleep * @return 0 when writable memory is available, < 0 upon error */ int af_alg_wait_for_data(struct sock *sk, unsigned flags) { DEFINE_WAIT_FUNC(wait, woken_wake_function); struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; long timeout; int err = -ERESTARTSYS; if (flags & MSG_DONTWAIT) return -EAGAIN; sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk); add_wait_queue(sk_sleep(sk), &wait); for (;;) { if (signal_pending(current)) break; timeout = MAX_SCHEDULE_TIMEOUT; if (sk_wait_event(sk, &timeout, (ctx->used || !ctx->more), &wait)) { err = 0; break; } } remove_wait_queue(sk_sleep(sk), &wait); sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk); return err; } EXPORT_SYMBOL_GPL(af_alg_wait_for_data); /** * af_alg_data_wakeup - wakeup caller when new data can be sent to kernel * * @sk socket of connection to user space */ |
466e07592 crypto: af_alg - ... |
747 |
static void af_alg_data_wakeup(struct sock *sk) |
2d97591ef crypto: af_alg - ... |
748 749 750 751 752 753 754 755 756 757 758 |
{ struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct socket_wq *wq; if (!ctx->used) return; rcu_read_lock(); wq = rcu_dereference(sk->sk_wq); if (skwq_has_sleeper(wq)) |
a9a08845e vfs: do bulk POLL... |
759 760 761 |
wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT | EPOLLRDNORM | EPOLLRDBAND); |
2d97591ef crypto: af_alg - ... |
762 763 764 |
sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT); rcu_read_unlock(); } |
2d97591ef crypto: af_alg - ... |
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 |
/** * af_alg_sendmsg - implementation of sendmsg system call handler * * The sendmsg system call handler obtains the user data and stores it * in ctx->tsgl_list. This implies allocation of the required numbers of * struct af_alg_tsgl. * * In addition, the ctx is filled with the information sent via CMSG. * * @sock socket of connection to user space * @msg message from user space * @size size of message from user space * @ivsize the size of the IV for the cipher operation to verify that the * user-space-provided IV has the right size * @return the number of copied data upon success, < 0 upon error */ int af_alg_sendmsg(struct socket *sock, struct msghdr *msg, size_t size, unsigned int ivsize) { struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_tsgl *sgl; struct af_alg_control con = {}; long copied = 0; bool enc = 0; bool init = 0; int err = 0; if (msg->msg_controllen) { err = af_alg_cmsg_send(msg, &con); if (err) return err; init = 1; switch (con.op) { case ALG_OP_ENCRYPT: enc = 1; break; case ALG_OP_DECRYPT: enc = 0; break; default: return -EINVAL; } if (con.iv && con.iv->ivlen != ivsize) return -EINVAL; } lock_sock(sk); if (!ctx->more && ctx->used) { err = -EINVAL; goto unlock; } if (init) { ctx->enc = enc; if (con.iv) memcpy(ctx->iv, con.iv->iv, ivsize); ctx->aead_assoclen = con.aead_assoclen; } while (size) { struct scatterlist *sg; size_t len = size; size_t plen; /* use the existing memory in an allocated page */ if (ctx->merge) { sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl, list); sg = sgl->sg + sgl->cur - 1; len = min_t(size_t, len, PAGE_SIZE - sg->offset - sg->length); err = memcpy_from_msg(page_address(sg_page(sg)) + sg->offset + sg->length, msg, len); if (err) goto unlock; sg->length += len; ctx->merge = (sg->offset + sg->length) & (PAGE_SIZE - 1); ctx->used += len; copied += len; size -= len; continue; } if (!af_alg_writable(sk)) { err = af_alg_wait_for_wmem(sk, msg->msg_flags); if (err) goto unlock; } /* allocate a new page */ len = min_t(unsigned long, len, af_alg_sndbuf(sk)); err = af_alg_alloc_tsgl(sk); if (err) goto unlock; sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl, list); sg = sgl->sg; if (sgl->cur) sg_unmark_end(sg + sgl->cur - 1); do { unsigned int i = sgl->cur; plen = min_t(size_t, len, PAGE_SIZE); sg_assign_page(sg + i, alloc_page(GFP_KERNEL)); if (!sg_page(sg + i)) { err = -ENOMEM; goto unlock; } err = memcpy_from_msg(page_address(sg_page(sg + i)), msg, plen); if (err) { __free_page(sg_page(sg + i)); sg_assign_page(sg + i, NULL); goto unlock; } sg[i].length = plen; len -= plen; ctx->used += plen; copied += plen; size -= plen; sgl->cur++; } while (len && sgl->cur < MAX_SGL_ENTS); if (!size) sg_mark_end(sg + sgl->cur - 1); ctx->merge = plen & (PAGE_SIZE - 1); } err = 0; ctx->more = msg->msg_flags & MSG_MORE; unlock: af_alg_data_wakeup(sk); release_sock(sk); return copied ?: err; } EXPORT_SYMBOL_GPL(af_alg_sendmsg); /** * af_alg_sendpage - sendpage system call handler * * This is a generic implementation of sendpage to fill ctx->tsgl_list. */ ssize_t af_alg_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags) { struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; struct af_alg_tsgl *sgl; int err = -EINVAL; if (flags & MSG_SENDPAGE_NOTLAST) flags |= MSG_MORE; lock_sock(sk); if (!ctx->more && ctx->used) goto unlock; if (!size) goto done; if (!af_alg_writable(sk)) { err = af_alg_wait_for_wmem(sk, flags); if (err) goto unlock; } err = af_alg_alloc_tsgl(sk); if (err) goto unlock; ctx->merge = 0; sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl, list); if (sgl->cur) sg_unmark_end(sgl->sg + sgl->cur - 1); sg_mark_end(sgl->sg + sgl->cur); get_page(page); sg_set_page(sgl->sg + sgl->cur, page, size, offset); sgl->cur++; ctx->used += size; done: ctx->more = flags & MSG_MORE; unlock: af_alg_data_wakeup(sk); release_sock(sk); return err ?: size; } EXPORT_SYMBOL_GPL(af_alg_sendpage); /** |
7d2c3f54e crypto: af_alg - ... |
982 983 984 985 986 987 988 989 990 991 992 993 |
* af_alg_free_resources - release resources required for crypto request */ void af_alg_free_resources(struct af_alg_async_req *areq) { struct sock *sk = areq->sk; af_alg_free_areq_sgls(areq); sock_kfree_s(sk, areq, areq->areqlen); } EXPORT_SYMBOL_GPL(af_alg_free_resources); /** |
2d97591ef crypto: af_alg - ... |
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 |
* af_alg_async_cb - AIO callback handler * * This handler cleans up the struct af_alg_async_req upon completion of the * AIO operation. * * The number of bytes to be generated with the AIO operation must be set * in areq->outlen before the AIO callback handler is invoked. */ void af_alg_async_cb(struct crypto_async_request *_req, int err) { struct af_alg_async_req *areq = _req->data; struct sock *sk = areq->sk; struct kiocb *iocb = areq->iocb; unsigned int resultlen; |
2d97591ef crypto: af_alg - ... |
1008 1009 |
/* Buffer size written by crypto operation. */ resultlen = areq->outlen; |
7d2c3f54e crypto: af_alg - ... |
1010 1011 |
af_alg_free_resources(areq); sock_put(sk); |
2d97591ef crypto: af_alg - ... |
1012 |
|
2a00d74e0 crypto: af_alg - ... |
1013 |
iocb->ki_complete(iocb, err ? err : (int)resultlen, 0); |
2d97591ef crypto: af_alg - ... |
1014 1015 |
} EXPORT_SYMBOL_GPL(af_alg_async_cb); |
a11e1d432 Revert changes to... |
1016 1017 1018 1019 1020 |
/** * af_alg_poll - poll system call handler */ __poll_t af_alg_poll(struct file *file, struct socket *sock, poll_table *wait) |
2d97591ef crypto: af_alg - ... |
1021 1022 1023 1024 |
{ struct sock *sk = sock->sk; struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; |
a11e1d432 Revert changes to... |
1025 |
__poll_t mask; |
89ab066d4 Revert "net: simp... |
1026 |
sock_poll_wait(file, sock, wait); |
a11e1d432 Revert changes to... |
1027 |
mask = 0; |
2d97591ef crypto: af_alg - ... |
1028 1029 |
if (!ctx->more || ctx->used) |
a9a08845e vfs: do bulk POLL... |
1030 |
mask |= EPOLLIN | EPOLLRDNORM; |
2d97591ef crypto: af_alg - ... |
1031 1032 |
if (af_alg_writable(sk)) |
a9a08845e vfs: do bulk POLL... |
1033 |
mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND; |
2d97591ef crypto: af_alg - ... |
1034 1035 1036 |
return mask; } |
a11e1d432 Revert changes to... |
1037 |
EXPORT_SYMBOL_GPL(af_alg_poll); |
2d97591ef crypto: af_alg - ... |
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 |
/** * af_alg_alloc_areq - allocate struct af_alg_async_req * * @sk socket of connection to user space * @areqlen size of struct af_alg_async_req + crypto_*_reqsize * @return allocated data structure or ERR_PTR upon error */ struct af_alg_async_req *af_alg_alloc_areq(struct sock *sk, unsigned int areqlen) { struct af_alg_async_req *areq = sock_kmalloc(sk, areqlen, GFP_KERNEL); if (unlikely(!areq)) return ERR_PTR(-ENOMEM); areq->areqlen = areqlen; areq->sk = sk; areq->last_rsgl = NULL; INIT_LIST_HEAD(&areq->rsgl_list); areq->tsgl = NULL; areq->tsgl_entries = 0; return areq; } EXPORT_SYMBOL_GPL(af_alg_alloc_areq); /** * af_alg_get_rsgl - create the RX SGL for the output data from the crypto * operation * * @sk socket of connection to user space * @msg user space message * @flags flags used to invoke recvmsg with * @areq instance of the cryptographic request that will hold the RX SGL * @maxsize maximum number of bytes to be pulled from user space * @outlen number of bytes in the RX SGL * @return 0 on success, < 0 upon error */ int af_alg_get_rsgl(struct sock *sk, struct msghdr *msg, int flags, struct af_alg_async_req *areq, size_t maxsize, size_t *outlen) { struct alg_sock *ask = alg_sk(sk); struct af_alg_ctx *ctx = ask->private; size_t len = 0; while (maxsize > len && msg_data_left(msg)) { struct af_alg_rsgl *rsgl; size_t seglen; int err; /* limit the amount of readable buffers */ if (!af_alg_readable(sk)) break; |
2d97591ef crypto: af_alg - ... |
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 |
seglen = min_t(size_t, (maxsize - len), msg_data_left(msg)); if (list_empty(&areq->rsgl_list)) { rsgl = &areq->first_rsgl; } else { rsgl = sock_kmalloc(sk, sizeof(*rsgl), GFP_KERNEL); if (unlikely(!rsgl)) return -ENOMEM; } rsgl->sgl.npages = 0; list_add_tail(&rsgl->list, &areq->rsgl_list); /* make one iovec available as scatterlist */ err = af_alg_make_sg(&rsgl->sgl, &msg->msg_iter, seglen); |
2546da992 crypto: af_alg - ... |
1109 1110 |
if (err < 0) { rsgl->sg_num_bytes = 0; |
2d97591ef crypto: af_alg - ... |
1111 |
return err; |
2546da992 crypto: af_alg - ... |
1112 |
} |
2d97591ef crypto: af_alg - ... |
1113 1114 1115 1116 1117 1118 1119 |
/* chain the new scatterlist with previous one */ if (areq->last_rsgl) af_alg_link_sg(&areq->last_rsgl->sgl, &rsgl->sgl); areq->last_rsgl = rsgl; len += err; |
af955bf15 crypto: af_alg - ... |
1120 |
atomic_add(err, &ctx->rcvused); |
2d97591ef crypto: af_alg - ... |
1121 1122 1123 1124 1125 1126 1127 1128 |
rsgl->sg_num_bytes = err; iov_iter_advance(&msg->msg_iter, err); } *outlen = len; return 0; } EXPORT_SYMBOL_GPL(af_alg_get_rsgl); |
03c8efc1f crypto: af_alg - ... |
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 |
static int __init af_alg_init(void) { int err = proto_register(&alg_proto, 0); if (err) goto out; err = sock_register(&alg_family); if (err != 0) goto out_unregister_proto; out: return err; out_unregister_proto: proto_unregister(&alg_proto); goto out; } static void __exit af_alg_exit(void) { sock_unregister(PF_ALG); proto_unregister(&alg_proto); } module_init(af_alg_init); module_exit(af_alg_exit); MODULE_LICENSE("GPL"); MODULE_ALIAS_NETPROTO(AF_ALG); |