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