1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
73
74
75
76
77
78#include <linux/types.h>
79#include <linux/bitops.h>
80#include <linux/cred.h>
81#include <linux/init.h>
82#include <linux/io.h>
83#include <linux/kernel.h>
84#include <linux/kmod.h>
85#include <linux/list.h>
86#include <linux/miscdevice.h>
87#include <linux/module.h>
88#include <linux/mutex.h>
89#include <linux/net.h>
90#include <linux/poll.h>
91#include <linux/skbuff.h>
92#include <linux/smp.h>
93#include <linux/socket.h>
94#include <linux/stddef.h>
95#include <linux/unistd.h>
96#include <linux/wait.h>
97#include <linux/workqueue.h>
98#include <net/sock.h>
99
100#include "af_vsock.h"
101
102static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr);
103static void vsock_sk_destruct(struct sock *sk);
104static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
105
106
107static struct proto vsock_proto = {
108 .name = "AF_VSOCK",
109 .owner = THIS_MODULE,
110 .obj_size = sizeof(struct vsock_sock),
111};
112
113
114
115
116#define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ)
117
118#define SS_LISTEN 255
119
120static const struct vsock_transport *transport;
121static DEFINE_MUTEX(vsock_register_mutex);
122
123
124
125
126
127int vm_sockets_get_local_cid(void)
128{
129 return transport->get_local_cid();
130}
131EXPORT_SYMBOL_GPL(vm_sockets_get_local_cid);
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149#define VSOCK_HASH_SIZE 251
150#define MAX_PORT_RETRIES 24
151
152#define VSOCK_HASH(addr) ((addr)->svm_port % (VSOCK_HASH_SIZE - 1))
153#define vsock_bound_sockets(addr) (&vsock_bind_table[VSOCK_HASH(addr)])
154#define vsock_unbound_sockets (&vsock_bind_table[VSOCK_HASH_SIZE])
155
156
157#define VSOCK_CONN_HASH(src, dst) \
158 (((src)->svm_cid ^ (dst)->svm_port) % (VSOCK_HASH_SIZE - 1))
159#define vsock_connected_sockets(src, dst) \
160 (&vsock_connected_table[VSOCK_CONN_HASH(src, dst)])
161#define vsock_connected_sockets_vsk(vsk) \
162 vsock_connected_sockets(&(vsk)->remote_addr, &(vsk)->local_addr)
163
164static struct list_head vsock_bind_table[VSOCK_HASH_SIZE + 1];
165static struct list_head vsock_connected_table[VSOCK_HASH_SIZE];
166static DEFINE_SPINLOCK(vsock_table_lock);
167
168static void vsock_init_tables(void)
169{
170 int i;
171
172 for (i = 0; i < ARRAY_SIZE(vsock_bind_table); i++)
173 INIT_LIST_HEAD(&vsock_bind_table[i]);
174
175 for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++)
176 INIT_LIST_HEAD(&vsock_connected_table[i]);
177}
178
179static void __vsock_insert_bound(struct list_head *list,
180 struct vsock_sock *vsk)
181{
182 sock_hold(&vsk->sk);
183 list_add(&vsk->bound_table, list);
184}
185
186static void __vsock_insert_connected(struct list_head *list,
187 struct vsock_sock *vsk)
188{
189 sock_hold(&vsk->sk);
190 list_add(&vsk->connected_table, list);
191}
192
193static void __vsock_remove_bound(struct vsock_sock *vsk)
194{
195 list_del_init(&vsk->bound_table);
196 sock_put(&vsk->sk);
197}
198
199static void __vsock_remove_connected(struct vsock_sock *vsk)
200{
201 list_del_init(&vsk->connected_table);
202 sock_put(&vsk->sk);
203}
204
205static struct sock *__vsock_find_bound_socket(struct sockaddr_vm *addr)
206{
207 struct vsock_sock *vsk;
208
209 list_for_each_entry(vsk, vsock_bound_sockets(addr), bound_table)
210 if (addr->svm_port == vsk->local_addr.svm_port)
211 return sk_vsock(vsk);
212
213 return NULL;
214}
215
216static struct sock *__vsock_find_connected_socket(struct sockaddr_vm *src,
217 struct sockaddr_vm *dst)
218{
219 struct vsock_sock *vsk;
220
221 list_for_each_entry(vsk, vsock_connected_sockets(src, dst),
222 connected_table) {
223 if (vsock_addr_equals_addr(src, &vsk->remote_addr) &&
224 dst->svm_port == vsk->local_addr.svm_port) {
225 return sk_vsock(vsk);
226 }
227 }
228
229 return NULL;
230}
231
232static bool __vsock_in_bound_table(struct vsock_sock *vsk)
233{
234 return !list_empty(&vsk->bound_table);
235}
236
237static bool __vsock_in_connected_table(struct vsock_sock *vsk)
238{
239 return !list_empty(&vsk->connected_table);
240}
241
242static void vsock_insert_unbound(struct vsock_sock *vsk)
243{
244 spin_lock_bh(&vsock_table_lock);
245 __vsock_insert_bound(vsock_unbound_sockets, vsk);
246 spin_unlock_bh(&vsock_table_lock);
247}
248
249void vsock_insert_connected(struct vsock_sock *vsk)
250{
251 struct list_head *list = vsock_connected_sockets(
252 &vsk->remote_addr, &vsk->local_addr);
253
254 spin_lock_bh(&vsock_table_lock);
255 __vsock_insert_connected(list, vsk);
256 spin_unlock_bh(&vsock_table_lock);
257}
258EXPORT_SYMBOL_GPL(vsock_insert_connected);
259
260void vsock_remove_bound(struct vsock_sock *vsk)
261{
262 spin_lock_bh(&vsock_table_lock);
263 __vsock_remove_bound(vsk);
264 spin_unlock_bh(&vsock_table_lock);
265}
266EXPORT_SYMBOL_GPL(vsock_remove_bound);
267
268void vsock_remove_connected(struct vsock_sock *vsk)
269{
270 spin_lock_bh(&vsock_table_lock);
271 __vsock_remove_connected(vsk);
272 spin_unlock_bh(&vsock_table_lock);
273}
274EXPORT_SYMBOL_GPL(vsock_remove_connected);
275
276struct sock *vsock_find_bound_socket(struct sockaddr_vm *addr)
277{
278 struct sock *sk;
279
280 spin_lock_bh(&vsock_table_lock);
281 sk = __vsock_find_bound_socket(addr);
282 if (sk)
283 sock_hold(sk);
284
285 spin_unlock_bh(&vsock_table_lock);
286
287 return sk;
288}
289EXPORT_SYMBOL_GPL(vsock_find_bound_socket);
290
291struct sock *vsock_find_connected_socket(struct sockaddr_vm *src,
292 struct sockaddr_vm *dst)
293{
294 struct sock *sk;
295
296 spin_lock_bh(&vsock_table_lock);
297 sk = __vsock_find_connected_socket(src, dst);
298 if (sk)
299 sock_hold(sk);
300
301 spin_unlock_bh(&vsock_table_lock);
302
303 return sk;
304}
305EXPORT_SYMBOL_GPL(vsock_find_connected_socket);
306
307static bool vsock_in_bound_table(struct vsock_sock *vsk)
308{
309 bool ret;
310
311 spin_lock_bh(&vsock_table_lock);
312 ret = __vsock_in_bound_table(vsk);
313 spin_unlock_bh(&vsock_table_lock);
314
315 return ret;
316}
317
318static bool vsock_in_connected_table(struct vsock_sock *vsk)
319{
320 bool ret;
321
322 spin_lock_bh(&vsock_table_lock);
323 ret = __vsock_in_connected_table(vsk);
324 spin_unlock_bh(&vsock_table_lock);
325
326 return ret;
327}
328
329void vsock_for_each_connected_socket(void (*fn)(struct sock *sk))
330{
331 int i;
332
333 spin_lock_bh(&vsock_table_lock);
334
335 for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++) {
336 struct vsock_sock *vsk;
337 list_for_each_entry(vsk, &vsock_connected_table[i],
338 connected_table);
339 fn(sk_vsock(vsk));
340 }
341
342 spin_unlock_bh(&vsock_table_lock);
343}
344EXPORT_SYMBOL_GPL(vsock_for_each_connected_socket);
345
346void vsock_add_pending(struct sock *listener, struct sock *pending)
347{
348 struct vsock_sock *vlistener;
349 struct vsock_sock *vpending;
350
351 vlistener = vsock_sk(listener);
352 vpending = vsock_sk(pending);
353
354 sock_hold(pending);
355 sock_hold(listener);
356 list_add_tail(&vpending->pending_links, &vlistener->pending_links);
357}
358EXPORT_SYMBOL_GPL(vsock_add_pending);
359
360void vsock_remove_pending(struct sock *listener, struct sock *pending)
361{
362 struct vsock_sock *vpending = vsock_sk(pending);
363
364 list_del_init(&vpending->pending_links);
365 sock_put(listener);
366 sock_put(pending);
367}
368EXPORT_SYMBOL_GPL(vsock_remove_pending);
369
370void vsock_enqueue_accept(struct sock *listener, struct sock *connected)
371{
372 struct vsock_sock *vlistener;
373 struct vsock_sock *vconnected;
374
375 vlistener = vsock_sk(listener);
376 vconnected = vsock_sk(connected);
377
378 sock_hold(connected);
379 sock_hold(listener);
380 list_add_tail(&vconnected->accept_queue, &vlistener->accept_queue);
381}
382EXPORT_SYMBOL_GPL(vsock_enqueue_accept);
383
384static struct sock *vsock_dequeue_accept(struct sock *listener)
385{
386 struct vsock_sock *vlistener;
387 struct vsock_sock *vconnected;
388
389 vlistener = vsock_sk(listener);
390
391 if (list_empty(&vlistener->accept_queue))
392 return NULL;
393
394 vconnected = list_entry(vlistener->accept_queue.next,
395 struct vsock_sock, accept_queue);
396
397 list_del_init(&vconnected->accept_queue);
398 sock_put(listener);
399
400
401
402
403 return sk_vsock(vconnected);
404}
405
406static bool vsock_is_accept_queue_empty(struct sock *sk)
407{
408 struct vsock_sock *vsk = vsock_sk(sk);
409 return list_empty(&vsk->accept_queue);
410}
411
412static bool vsock_is_pending(struct sock *sk)
413{
414 struct vsock_sock *vsk = vsock_sk(sk);
415 return !list_empty(&vsk->pending_links);
416}
417
418static int vsock_send_shutdown(struct sock *sk, int mode)
419{
420 return transport->shutdown(vsock_sk(sk), mode);
421}
422
423void vsock_pending_work(struct work_struct *work)
424{
425 struct sock *sk;
426 struct sock *listener;
427 struct vsock_sock *vsk;
428 bool cleanup;
429
430 vsk = container_of(work, struct vsock_sock, dwork.work);
431 sk = sk_vsock(vsk);
432 listener = vsk->listener;
433 cleanup = true;
434
435 lock_sock(listener);
436 lock_sock(sk);
437
438 if (vsock_is_pending(sk)) {
439 vsock_remove_pending(listener, sk);
440 } else if (!vsk->rejected) {
441
442
443
444
445
446 cleanup = false;
447 goto out;
448 }
449
450 listener->sk_ack_backlog--;
451
452
453
454
455
456 if (vsock_in_connected_table(vsk))
457 vsock_remove_connected(vsk);
458
459 sk->sk_state = SS_FREE;
460
461out:
462 release_sock(sk);
463 release_sock(listener);
464 if (cleanup)
465 sock_put(sk);
466
467 sock_put(sk);
468 sock_put(listener);
469}
470EXPORT_SYMBOL_GPL(vsock_pending_work);
471
472
473
474static int __vsock_bind_stream(struct vsock_sock *vsk,
475 struct sockaddr_vm *addr)
476{
477 static u32 port = LAST_RESERVED_PORT + 1;
478 struct sockaddr_vm new_addr;
479
480 vsock_addr_init(&new_addr, addr->svm_cid, addr->svm_port);
481
482 if (addr->svm_port == VMADDR_PORT_ANY) {
483 bool found = false;
484 unsigned int i;
485
486 for (i = 0; i < MAX_PORT_RETRIES; i++) {
487 if (port <= LAST_RESERVED_PORT)
488 port = LAST_RESERVED_PORT + 1;
489
490 new_addr.svm_port = port++;
491
492 if (!__vsock_find_bound_socket(&new_addr)) {
493 found = true;
494 break;
495 }
496 }
497
498 if (!found)
499 return -EADDRNOTAVAIL;
500 } else {
501
502
503
504 if (addr->svm_port <= LAST_RESERVED_PORT &&
505 !capable(CAP_NET_BIND_SERVICE)) {
506 return -EACCES;
507 }
508
509 if (__vsock_find_bound_socket(&new_addr))
510 return -EADDRINUSE;
511 }
512
513 vsock_addr_init(&vsk->local_addr, new_addr.svm_cid, new_addr.svm_port);
514
515
516
517
518
519 __vsock_remove_bound(vsk);
520 __vsock_insert_bound(vsock_bound_sockets(&vsk->local_addr), vsk);
521
522 return 0;
523}
524
525static int __vsock_bind_dgram(struct vsock_sock *vsk,
526 struct sockaddr_vm *addr)
527{
528 return transport->dgram_bind(vsk, addr);
529}
530
531static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr)
532{
533 struct vsock_sock *vsk = vsock_sk(sk);
534 u32 cid;
535 int retval;
536
537
538 if (vsock_addr_bound(&vsk->local_addr))
539 return -EINVAL;
540
541
542
543
544
545
546 cid = transport->get_local_cid();
547 if (addr->svm_cid != cid && addr->svm_cid != VMADDR_CID_ANY)
548 return -EADDRNOTAVAIL;
549
550 switch (sk->sk_socket->type) {
551 case SOCK_STREAM:
552 spin_lock_bh(&vsock_table_lock);
553 retval = __vsock_bind_stream(vsk, addr);
554 spin_unlock_bh(&vsock_table_lock);
555 break;
556
557 case SOCK_DGRAM:
558 retval = __vsock_bind_dgram(vsk, addr);
559 break;
560
561 default:
562 retval = -EINVAL;
563 break;
564 }
565
566 return retval;
567}
568
569struct sock *__vsock_create(struct net *net,
570 struct socket *sock,
571 struct sock *parent,
572 gfp_t priority,
573 unsigned short type)
574{
575 struct sock *sk;
576 struct vsock_sock *psk;
577 struct vsock_sock *vsk;
578
579 sk = sk_alloc(net, AF_VSOCK, priority, &vsock_proto);
580 if (!sk)
581 return NULL;
582
583 sock_init_data(sock, sk);
584
585
586
587
588
589 if (!sock)
590 sk->sk_type = type;
591
592 vsk = vsock_sk(sk);
593 vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
594 vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
595
596 sk->sk_destruct = vsock_sk_destruct;
597 sk->sk_backlog_rcv = vsock_queue_rcv_skb;
598 sk->sk_state = 0;
599 sock_reset_flag(sk, SOCK_DONE);
600
601 INIT_LIST_HEAD(&vsk->bound_table);
602 INIT_LIST_HEAD(&vsk->connected_table);
603 vsk->listener = NULL;
604 INIT_LIST_HEAD(&vsk->pending_links);
605 INIT_LIST_HEAD(&vsk->accept_queue);
606 vsk->rejected = false;
607 vsk->sent_request = false;
608 vsk->ignore_connecting_rst = false;
609 vsk->peer_shutdown = 0;
610
611 psk = parent ? vsock_sk(parent) : NULL;
612 if (parent) {
613 vsk->trusted = psk->trusted;
614 vsk->owner = get_cred(psk->owner);
615 vsk->connect_timeout = psk->connect_timeout;
616 } else {
617 vsk->trusted = capable(CAP_NET_ADMIN);
618 vsk->owner = get_current_cred();
619 vsk->connect_timeout = VSOCK_DEFAULT_CONNECT_TIMEOUT;
620 }
621
622 if (transport->init(vsk, psk) < 0) {
623 sk_free(sk);
624 return NULL;
625 }
626
627 if (sock)
628 vsock_insert_unbound(vsk);
629
630 return sk;
631}
632EXPORT_SYMBOL_GPL(__vsock_create);
633
634static void __vsock_release(struct sock *sk)
635{
636 if (sk) {
637 struct sk_buff *skb;
638 struct sock *pending;
639 struct vsock_sock *vsk;
640
641 vsk = vsock_sk(sk);
642 pending = NULL;
643
644 if (vsock_in_bound_table(vsk))
645 vsock_remove_bound(vsk);
646
647 if (vsock_in_connected_table(vsk))
648 vsock_remove_connected(vsk);
649
650 transport->release(vsk);
651
652 lock_sock(sk);
653 sock_orphan(sk);
654 sk->sk_shutdown = SHUTDOWN_MASK;
655
656 while ((skb = skb_dequeue(&sk->sk_receive_queue)))
657 kfree_skb(skb);
658
659
660 while ((pending = vsock_dequeue_accept(sk)) != NULL) {
661 __vsock_release(pending);
662 sock_put(pending);
663 }
664
665 release_sock(sk);
666 sock_put(sk);
667 }
668}
669
670static void vsock_sk_destruct(struct sock *sk)
671{
672 struct vsock_sock *vsk = vsock_sk(sk);
673
674 transport->destruct(vsk);
675
676
677
678
679 vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
680 vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
681
682 put_cred(vsk->owner);
683}
684
685static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
686{
687 int err;
688
689 err = sock_queue_rcv_skb(sk, skb);
690 if (err)
691 kfree_skb(skb);
692
693 return err;
694}
695
696s64 vsock_stream_has_data(struct vsock_sock *vsk)
697{
698 return transport->stream_has_data(vsk);
699}
700EXPORT_SYMBOL_GPL(vsock_stream_has_data);
701
702s64 vsock_stream_has_space(struct vsock_sock *vsk)
703{
704 return transport->stream_has_space(vsk);
705}
706EXPORT_SYMBOL_GPL(vsock_stream_has_space);
707
708static int vsock_release(struct socket *sock)
709{
710 __vsock_release(sock->sk);
711 sock->sk = NULL;
712 sock->state = SS_FREE;
713
714 return 0;
715}
716
717static int
718vsock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
719{
720 int err;
721 struct sock *sk;
722 struct sockaddr_vm *vm_addr;
723
724 sk = sock->sk;
725
726 if (vsock_addr_cast(addr, addr_len, &vm_addr) != 0)
727 return -EINVAL;
728
729 lock_sock(sk);
730 err = __vsock_bind(sk, vm_addr);
731 release_sock(sk);
732
733 return err;
734}
735
736static int vsock_getname(struct socket *sock,
737 struct sockaddr *addr, int *addr_len, int peer)
738{
739 int err;
740 struct sock *sk;
741 struct vsock_sock *vsk;
742 struct sockaddr_vm *vm_addr;
743
744 sk = sock->sk;
745 vsk = vsock_sk(sk);
746 err = 0;
747
748 lock_sock(sk);
749
750 if (peer) {
751 if (sock->state != SS_CONNECTED) {
752 err = -ENOTCONN;
753 goto out;
754 }
755 vm_addr = &vsk->remote_addr;
756 } else {
757 vm_addr = &vsk->local_addr;
758 }
759
760 if (!vm_addr) {
761 err = -EINVAL;
762 goto out;
763 }
764
765
766
767
768
769
770 BUILD_BUG_ON(sizeof(*vm_addr) > 128);
771 memcpy(addr, vm_addr, sizeof(*vm_addr));
772 *addr_len = sizeof(*vm_addr);
773
774out:
775 release_sock(sk);
776 return err;
777}
778
779static int vsock_shutdown(struct socket *sock, int mode)
780{
781 int err;
782 struct sock *sk;
783
784
785
786
787
788
789
790 mode++;
791
792 if ((mode & ~SHUTDOWN_MASK) || !mode)
793 return -EINVAL;
794
795
796
797
798
799
800
801 sk = sock->sk;
802 if (sock->state == SS_UNCONNECTED) {
803 err = -ENOTCONN;
804 if (sk->sk_type == SOCK_STREAM)
805 return err;
806 } else {
807 sock->state = SS_DISCONNECTING;
808 err = 0;
809 }
810
811
812 mode = mode & (RCV_SHUTDOWN | SEND_SHUTDOWN);
813 if (mode) {
814 lock_sock(sk);
815 sk->sk_shutdown |= mode;
816 sk->sk_state_change(sk);
817 release_sock(sk);
818
819 if (sk->sk_type == SOCK_STREAM) {
820 sock_reset_flag(sk, SOCK_DONE);
821 vsock_send_shutdown(sk, mode);
822 }
823 }
824
825 return err;
826}
827
828static unsigned int vsock_poll(struct file *file, struct socket *sock,
829 poll_table *wait)
830{
831 struct sock *sk;
832 unsigned int mask;
833 struct vsock_sock *vsk;
834
835 sk = sock->sk;
836 vsk = vsock_sk(sk);
837
838 poll_wait(file, sk_sleep(sk), wait);
839 mask = 0;
840
841 if (sk->sk_err)
842
843 mask |= POLLERR;
844
845
846
847
848 if ((sk->sk_shutdown == SHUTDOWN_MASK) ||
849 ((sk->sk_shutdown & SEND_SHUTDOWN) &&
850 (vsk->peer_shutdown & SEND_SHUTDOWN))) {
851 mask |= POLLHUP;
852 }
853
854 if (sk->sk_shutdown & RCV_SHUTDOWN ||
855 vsk->peer_shutdown & SEND_SHUTDOWN) {
856 mask |= POLLRDHUP;
857 }
858
859 if (sock->type == SOCK_DGRAM) {
860
861
862
863
864 if (!skb_queue_empty(&sk->sk_receive_queue) ||
865 (sk->sk_shutdown & RCV_SHUTDOWN)) {
866 mask |= POLLIN | POLLRDNORM;
867 }
868
869 if (!(sk->sk_shutdown & SEND_SHUTDOWN))
870 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
871
872 } else if (sock->type == SOCK_STREAM) {
873 lock_sock(sk);
874
875
876
877
878 if (sk->sk_state == SS_LISTEN
879 && !vsock_is_accept_queue_empty(sk))
880 mask |= POLLIN | POLLRDNORM;
881
882
883 if (transport->stream_is_active(vsk) &&
884 !(sk->sk_shutdown & RCV_SHUTDOWN)) {
885 bool data_ready_now = false;
886 int ret = transport->notify_poll_in(
887 vsk, 1, &data_ready_now);
888 if (ret < 0) {
889 mask |= POLLERR;
890 } else {
891 if (data_ready_now)
892 mask |= POLLIN | POLLRDNORM;
893
894 }
895 }
896
897
898
899
900
901 if (sk->sk_shutdown & RCV_SHUTDOWN ||
902 vsk->peer_shutdown & SEND_SHUTDOWN) {
903 mask |= POLLIN | POLLRDNORM;
904 }
905
906
907 if (sk->sk_state == SS_CONNECTED) {
908 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
909 bool space_avail_now = false;
910 int ret = transport->notify_poll_out(
911 vsk, 1, &space_avail_now);
912 if (ret < 0) {
913 mask |= POLLERR;
914 } else {
915 if (space_avail_now)
916
917
918
919 mask |= POLLOUT | POLLWRNORM;
920
921 }
922 }
923 }
924
925
926
927
928
929 if (sk->sk_state == SS_UNCONNECTED) {
930 if (!(sk->sk_shutdown & SEND_SHUTDOWN))
931 mask |= POLLOUT | POLLWRNORM;
932
933 }
934
935 release_sock(sk);
936 }
937
938 return mask;
939}
940
941static int vsock_dgram_sendmsg(struct kiocb *kiocb, struct socket *sock,
942 struct msghdr *msg, size_t len)
943{
944 int err;
945 struct sock *sk;
946 struct vsock_sock *vsk;
947 struct sockaddr_vm *remote_addr;
948
949 if (msg->msg_flags & MSG_OOB)
950 return -EOPNOTSUPP;
951
952
953 err = 0;
954 sk = sock->sk;
955 vsk = vsock_sk(sk);
956
957 lock_sock(sk);
958
959 if (!vsock_addr_bound(&vsk->local_addr)) {
960 struct sockaddr_vm local_addr;
961
962 vsock_addr_init(&local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
963 err = __vsock_bind(sk, &local_addr);
964 if (err != 0)
965 goto out;
966
967 }
968
969
970
971
972 if (msg->msg_name &&
973 vsock_addr_cast(msg->msg_name, msg->msg_namelen,
974 &remote_addr) == 0) {
975
976
977
978
979 if (remote_addr->svm_cid == VMADDR_CID_ANY)
980 remote_addr->svm_cid = transport->get_local_cid();
981
982 if (!vsock_addr_bound(remote_addr)) {
983 err = -EINVAL;
984 goto out;
985 }
986 } else if (sock->state == SS_CONNECTED) {
987 remote_addr = &vsk->remote_addr;
988
989 if (remote_addr->svm_cid == VMADDR_CID_ANY)
990 remote_addr->svm_cid = transport->get_local_cid();
991
992
993
994
995 if (!vsock_addr_bound(&vsk->remote_addr)) {
996 err = -EINVAL;
997 goto out;
998 }
999 } else {
1000 err = -EINVAL;
1001 goto out;
1002 }
1003
1004 if (!transport->dgram_allow(remote_addr->svm_cid,
1005 remote_addr->svm_port)) {
1006 err = -EINVAL;
1007 goto out;
1008 }
1009
1010 err = transport->dgram_enqueue(vsk, remote_addr, msg->msg_iov, len);
1011
1012out:
1013 release_sock(sk);
1014 return err;
1015}
1016
1017static int vsock_dgram_connect(struct socket *sock,
1018 struct sockaddr *addr, int addr_len, int flags)
1019{
1020 int err;
1021 struct sock *sk;
1022 struct vsock_sock *vsk;
1023 struct sockaddr_vm *remote_addr;
1024
1025 sk = sock->sk;
1026 vsk = vsock_sk(sk);
1027
1028 err = vsock_addr_cast(addr, addr_len, &remote_addr);
1029 if (err == -EAFNOSUPPORT && remote_addr->svm_family == AF_UNSPEC) {
1030 lock_sock(sk);
1031 vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY,
1032 VMADDR_PORT_ANY);
1033 sock->state = SS_UNCONNECTED;
1034 release_sock(sk);
1035 return 0;
1036 } else if (err != 0)
1037 return -EINVAL;
1038
1039 lock_sock(sk);
1040
1041 if (!vsock_addr_bound(&vsk->local_addr)) {
1042 struct sockaddr_vm local_addr;
1043
1044 vsock_addr_init(&local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
1045 err = __vsock_bind(sk, &local_addr);
1046 if (err != 0)
1047 goto out;
1048
1049 }
1050
1051 if (!transport->dgram_allow(remote_addr->svm_cid,
1052 remote_addr->svm_port)) {
1053 err = -EINVAL;
1054 goto out;
1055 }
1056
1057 memcpy(&vsk->remote_addr, remote_addr, sizeof(vsk->remote_addr));
1058 sock->state = SS_CONNECTED;
1059
1060out:
1061 release_sock(sk);
1062 return err;
1063}
1064
1065static int vsock_dgram_recvmsg(struct kiocb *kiocb, struct socket *sock,
1066 struct msghdr *msg, size_t len, int flags)
1067{
1068 return transport->dgram_dequeue(kiocb, vsock_sk(sock->sk), msg, len,
1069 flags);
1070}
1071
1072static const struct proto_ops vsock_dgram_ops = {
1073 .family = PF_VSOCK,
1074 .owner = THIS_MODULE,
1075 .release = vsock_release,
1076 .bind = vsock_bind,
1077 .connect = vsock_dgram_connect,
1078 .socketpair = sock_no_socketpair,
1079 .accept = sock_no_accept,
1080 .getname = vsock_getname,
1081 .poll = vsock_poll,
1082 .ioctl = sock_no_ioctl,
1083 .listen = sock_no_listen,
1084 .shutdown = vsock_shutdown,
1085 .setsockopt = sock_no_setsockopt,
1086 .getsockopt = sock_no_getsockopt,
1087 .sendmsg = vsock_dgram_sendmsg,
1088 .recvmsg = vsock_dgram_recvmsg,
1089 .mmap = sock_no_mmap,
1090 .sendpage = sock_no_sendpage,
1091};
1092
1093static void vsock_connect_timeout(struct work_struct *work)
1094{
1095 struct sock *sk;
1096 struct vsock_sock *vsk;
1097
1098 vsk = container_of(work, struct vsock_sock, dwork.work);
1099 sk = sk_vsock(vsk);
1100
1101 lock_sock(sk);
1102 if (sk->sk_state == SS_CONNECTING &&
1103 (sk->sk_shutdown != SHUTDOWN_MASK)) {
1104 sk->sk_state = SS_UNCONNECTED;
1105 sk->sk_err = ETIMEDOUT;
1106 sk->sk_error_report(sk);
1107 }
1108 release_sock(sk);
1109
1110 sock_put(sk);
1111}
1112
1113static int vsock_stream_connect(struct socket *sock, struct sockaddr *addr,
1114 int addr_len, int flags)
1115{
1116 int err;
1117 struct sock *sk;
1118 struct vsock_sock *vsk;
1119 struct sockaddr_vm *remote_addr;
1120 long timeout;
1121 DEFINE_WAIT(wait);
1122
1123 err = 0;
1124 sk = sock->sk;
1125 vsk = vsock_sk(sk);
1126
1127 lock_sock(sk);
1128
1129
1130 switch (sock->state) {
1131 case SS_CONNECTED:
1132 err = -EISCONN;
1133 goto out;
1134 case SS_DISCONNECTING:
1135 err = -EINVAL;
1136 goto out;
1137 case SS_CONNECTING:
1138
1139
1140
1141
1142
1143
1144 err = -EALREADY;
1145 break;
1146 default:
1147 if ((sk->sk_state == SS_LISTEN) ||
1148 vsock_addr_cast(addr, addr_len, &remote_addr) != 0) {
1149 err = -EINVAL;
1150 goto out;
1151 }
1152
1153
1154
1155
1156 if (!transport->stream_allow(remote_addr->svm_cid,
1157 remote_addr->svm_port)) {
1158 err = -ENETUNREACH;
1159 goto out;
1160 }
1161
1162
1163 memcpy(&vsk->remote_addr, remote_addr,
1164 sizeof(vsk->remote_addr));
1165
1166
1167 if (!vsock_addr_bound(&vsk->local_addr)) {
1168 struct sockaddr_vm local_addr;
1169
1170 vsock_addr_init(&local_addr, VMADDR_CID_ANY,
1171 VMADDR_PORT_ANY);
1172 err = __vsock_bind(sk, &local_addr);
1173 if (err != 0)
1174 goto out;
1175
1176 }
1177
1178 sk->sk_state = SS_CONNECTING;
1179
1180 err = transport->connect(vsk);
1181 if (err < 0)
1182 goto out;
1183
1184
1185
1186
1187 sock->state = SS_CONNECTING;
1188 err = -EINPROGRESS;
1189 }
1190
1191
1192
1193
1194
1195 timeout = vsk->connect_timeout;
1196 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1197
1198 while (sk->sk_state != SS_CONNECTED && sk->sk_err == 0) {
1199 if (flags & O_NONBLOCK) {
1200
1201
1202
1203
1204
1205
1206 sock_hold(sk);
1207 INIT_DELAYED_WORK(&vsk->dwork,
1208 vsock_connect_timeout);
1209 schedule_delayed_work(&vsk->dwork, timeout);
1210
1211
1212 goto out_wait;
1213 }
1214
1215 release_sock(sk);
1216 timeout = schedule_timeout(timeout);
1217 lock_sock(sk);
1218
1219 if (signal_pending(current)) {
1220 err = sock_intr_errno(timeout);
1221 goto out_wait_error;
1222 } else if (timeout == 0) {
1223 err = -ETIMEDOUT;
1224 goto out_wait_error;
1225 }
1226
1227 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1228 }
1229
1230 if (sk->sk_err) {
1231 err = -sk->sk_err;
1232 goto out_wait_error;
1233 } else
1234 err = 0;
1235
1236out_wait:
1237 finish_wait(sk_sleep(sk), &wait);
1238out:
1239 release_sock(sk);
1240 return err;
1241
1242out_wait_error:
1243 sk->sk_state = SS_UNCONNECTED;
1244 sock->state = SS_UNCONNECTED;
1245 goto out_wait;
1246}
1247
1248static int vsock_accept(struct socket *sock, struct socket *newsock, int flags)
1249{
1250 struct sock *listener;
1251 int err;
1252 struct sock *connected;
1253 struct vsock_sock *vconnected;
1254 long timeout;
1255 DEFINE_WAIT(wait);
1256
1257 err = 0;
1258 listener = sock->sk;
1259
1260 lock_sock(listener);
1261
1262 if (sock->type != SOCK_STREAM) {
1263 err = -EOPNOTSUPP;
1264 goto out;
1265 }
1266
1267 if (listener->sk_state != SS_LISTEN) {
1268 err = -EINVAL;
1269 goto out;
1270 }
1271
1272
1273
1274
1275 timeout = sock_sndtimeo(listener, flags & O_NONBLOCK);
1276 prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE);
1277
1278 while ((connected = vsock_dequeue_accept(listener)) == NULL &&
1279 listener->sk_err == 0) {
1280 release_sock(listener);
1281 timeout = schedule_timeout(timeout);
1282 lock_sock(listener);
1283
1284 if (signal_pending(current)) {
1285 err = sock_intr_errno(timeout);
1286 goto out_wait;
1287 } else if (timeout == 0) {
1288 err = -EAGAIN;
1289 goto out_wait;
1290 }
1291
1292 prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE);
1293 }
1294
1295 if (listener->sk_err)
1296 err = -listener->sk_err;
1297
1298 if (connected) {
1299 listener->sk_ack_backlog--;
1300
1301 lock_sock(connected);
1302 vconnected = vsock_sk(connected);
1303
1304
1305
1306
1307
1308
1309
1310
1311 if (err) {
1312 vconnected->rejected = true;
1313 release_sock(connected);
1314 sock_put(connected);
1315 goto out_wait;
1316 }
1317
1318 newsock->state = SS_CONNECTED;
1319 sock_graft(connected, newsock);
1320 release_sock(connected);
1321 sock_put(connected);
1322 }
1323
1324out_wait:
1325 finish_wait(sk_sleep(listener), &wait);
1326out:
1327 release_sock(listener);
1328 return err;
1329}
1330
1331static int vsock_listen(struct socket *sock, int backlog)
1332{
1333 int err;
1334 struct sock *sk;
1335 struct vsock_sock *vsk;
1336
1337 sk = sock->sk;
1338
1339 lock_sock(sk);
1340
1341 if (sock->type != SOCK_STREAM) {
1342 err = -EOPNOTSUPP;
1343 goto out;
1344 }
1345
1346 if (sock->state != SS_UNCONNECTED) {
1347 err = -EINVAL;
1348 goto out;
1349 }
1350
1351 vsk = vsock_sk(sk);
1352
1353 if (!vsock_addr_bound(&vsk->local_addr)) {
1354 err = -EINVAL;
1355 goto out;
1356 }
1357
1358 sk->sk_max_ack_backlog = backlog;
1359 sk->sk_state = SS_LISTEN;
1360
1361 err = 0;
1362
1363out:
1364 release_sock(sk);
1365 return err;
1366}
1367
1368static int vsock_stream_setsockopt(struct socket *sock,
1369 int level,
1370 int optname,
1371 char __user *optval,
1372 unsigned int optlen)
1373{
1374 int err;
1375 struct sock *sk;
1376 struct vsock_sock *vsk;
1377 u64 val;
1378
1379 if (level != AF_VSOCK)
1380 return -ENOPROTOOPT;
1381
1382#define COPY_IN(_v) \
1383 do { \
1384 if (optlen < sizeof(_v)) { \
1385 err = -EINVAL; \
1386 goto exit; \
1387 } \
1388 if (copy_from_user(&_v, optval, sizeof(_v)) != 0) { \
1389 err = -EFAULT; \
1390 goto exit; \
1391 } \
1392 } while (0)
1393
1394 err = 0;
1395 sk = sock->sk;
1396 vsk = vsock_sk(sk);
1397
1398 lock_sock(sk);
1399
1400 switch (optname) {
1401 case SO_VM_SOCKETS_BUFFER_SIZE:
1402 COPY_IN(val);
1403 transport->set_buffer_size(vsk, val);
1404 break;
1405
1406 case SO_VM_SOCKETS_BUFFER_MAX_SIZE:
1407 COPY_IN(val);
1408 transport->set_max_buffer_size(vsk, val);
1409 break;
1410
1411 case SO_VM_SOCKETS_BUFFER_MIN_SIZE:
1412 COPY_IN(val);
1413 transport->set_min_buffer_size(vsk, val);
1414 break;
1415
1416 case SO_VM_SOCKETS_CONNECT_TIMEOUT: {
1417 struct timeval tv;
1418 COPY_IN(tv);
1419 if (tv.tv_sec >= 0 && tv.tv_usec < USEC_PER_SEC &&
1420 tv.tv_sec < (MAX_SCHEDULE_TIMEOUT / HZ - 1)) {
1421 vsk->connect_timeout = tv.tv_sec * HZ +
1422 DIV_ROUND_UP(tv.tv_usec, (1000000 / HZ));
1423 if (vsk->connect_timeout == 0)
1424 vsk->connect_timeout =
1425 VSOCK_DEFAULT_CONNECT_TIMEOUT;
1426
1427 } else {
1428 err = -ERANGE;
1429 }
1430 break;
1431 }
1432
1433 default:
1434 err = -ENOPROTOOPT;
1435 break;
1436 }
1437
1438#undef COPY_IN
1439
1440exit:
1441 release_sock(sk);
1442 return err;
1443}
1444
1445static int vsock_stream_getsockopt(struct socket *sock,
1446 int level, int optname,
1447 char __user *optval,
1448 int __user *optlen)
1449{
1450 int err;
1451 int len;
1452 struct sock *sk;
1453 struct vsock_sock *vsk;
1454 u64 val;
1455
1456 if (level != AF_VSOCK)
1457 return -ENOPROTOOPT;
1458
1459 err = get_user(len, optlen);
1460 if (err != 0)
1461 return err;
1462
1463#define COPY_OUT(_v) \
1464 do { \
1465 if (len < sizeof(_v)) \
1466 return -EINVAL; \
1467 \
1468 len = sizeof(_v); \
1469 if (copy_to_user(optval, &_v, len) != 0) \
1470 return -EFAULT; \
1471 \
1472 } while (0)
1473
1474 err = 0;
1475 sk = sock->sk;
1476 vsk = vsock_sk(sk);
1477
1478 switch (optname) {
1479 case SO_VM_SOCKETS_BUFFER_SIZE:
1480 val = transport->get_buffer_size(vsk);
1481 COPY_OUT(val);
1482 break;
1483
1484 case SO_VM_SOCKETS_BUFFER_MAX_SIZE:
1485 val = transport->get_max_buffer_size(vsk);
1486 COPY_OUT(val);
1487 break;
1488
1489 case SO_VM_SOCKETS_BUFFER_MIN_SIZE:
1490 val = transport->get_min_buffer_size(vsk);
1491 COPY_OUT(val);
1492 break;
1493
1494 case SO_VM_SOCKETS_CONNECT_TIMEOUT: {
1495 struct timeval tv;
1496 tv.tv_sec = vsk->connect_timeout / HZ;
1497 tv.tv_usec =
1498 (vsk->connect_timeout -
1499 tv.tv_sec * HZ) * (1000000 / HZ);
1500 COPY_OUT(tv);
1501 break;
1502 }
1503 default:
1504 return -ENOPROTOOPT;
1505 }
1506
1507 err = put_user(len, optlen);
1508 if (err != 0)
1509 return -EFAULT;
1510
1511#undef COPY_OUT
1512
1513 return 0;
1514}
1515
1516static int vsock_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
1517 struct msghdr *msg, size_t len)
1518{
1519 struct sock *sk;
1520 struct vsock_sock *vsk;
1521 ssize_t total_written;
1522 long timeout;
1523 int err;
1524 struct vsock_transport_send_notify_data send_data;
1525
1526 DEFINE_WAIT(wait);
1527
1528 sk = sock->sk;
1529 vsk = vsock_sk(sk);
1530 total_written = 0;
1531 err = 0;
1532
1533 if (msg->msg_flags & MSG_OOB)
1534 return -EOPNOTSUPP;
1535
1536 lock_sock(sk);
1537
1538
1539 if (msg->msg_namelen) {
1540 err = sk->sk_state == SS_CONNECTED ? -EISCONN : -EOPNOTSUPP;
1541 goto out;
1542 }
1543
1544
1545 if (sk->sk_shutdown & SEND_SHUTDOWN ||
1546 vsk->peer_shutdown & RCV_SHUTDOWN) {
1547 err = -EPIPE;
1548 goto out;
1549 }
1550
1551 if (sk->sk_state != SS_CONNECTED ||
1552 !vsock_addr_bound(&vsk->local_addr)) {
1553 err = -ENOTCONN;
1554 goto out;
1555 }
1556
1557 if (!vsock_addr_bound(&vsk->remote_addr)) {
1558 err = -EDESTADDRREQ;
1559 goto out;
1560 }
1561
1562
1563 timeout = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1564
1565 err = transport->notify_send_init(vsk, &send_data);
1566 if (err < 0)
1567 goto out;
1568
1569 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1570
1571 while (total_written < len) {
1572 ssize_t written;
1573
1574 while (vsock_stream_has_space(vsk) == 0 &&
1575 sk->sk_err == 0 &&
1576 !(sk->sk_shutdown & SEND_SHUTDOWN) &&
1577 !(vsk->peer_shutdown & RCV_SHUTDOWN)) {
1578
1579
1580 if (timeout == 0) {
1581 err = -EAGAIN;
1582 goto out_wait;
1583 }
1584
1585 err = transport->notify_send_pre_block(vsk, &send_data);
1586 if (err < 0)
1587 goto out_wait;
1588
1589 release_sock(sk);
1590 timeout = schedule_timeout(timeout);
1591 lock_sock(sk);
1592 if (signal_pending(current)) {
1593 err = sock_intr_errno(timeout);
1594 goto out_wait;
1595 } else if (timeout == 0) {
1596 err = -EAGAIN;
1597 goto out_wait;
1598 }
1599
1600 prepare_to_wait(sk_sleep(sk), &wait,
1601 TASK_INTERRUPTIBLE);
1602 }
1603
1604
1605
1606
1607
1608 if (sk->sk_err) {
1609 err = -sk->sk_err;
1610 goto out_wait;
1611 } else if ((sk->sk_shutdown & SEND_SHUTDOWN) ||
1612 (vsk->peer_shutdown & RCV_SHUTDOWN)) {
1613 err = -EPIPE;
1614 goto out_wait;
1615 }
1616
1617 err = transport->notify_send_pre_enqueue(vsk, &send_data);
1618 if (err < 0)
1619 goto out_wait;
1620
1621
1622
1623
1624
1625
1626
1627 written = transport->stream_enqueue(
1628 vsk, msg->msg_iov,
1629 len - total_written);
1630 if (written < 0) {
1631 err = -ENOMEM;
1632 goto out_wait;
1633 }
1634
1635 total_written += written;
1636
1637 err = transport->notify_send_post_enqueue(
1638 vsk, written, &send_data);
1639 if (err < 0)
1640 goto out_wait;
1641
1642 }
1643
1644out_wait:
1645 if (total_written > 0)
1646 err = total_written;
1647 finish_wait(sk_sleep(sk), &wait);
1648out:
1649 release_sock(sk);
1650 return err;
1651}
1652
1653
1654static int
1655vsock_stream_recvmsg(struct kiocb *kiocb,
1656 struct socket *sock,
1657 struct msghdr *msg, size_t len, int flags)
1658{
1659 struct sock *sk;
1660 struct vsock_sock *vsk;
1661 int err;
1662 size_t target;
1663 ssize_t copied;
1664 long timeout;
1665 struct vsock_transport_recv_notify_data recv_data;
1666
1667 DEFINE_WAIT(wait);
1668
1669 sk = sock->sk;
1670 vsk = vsock_sk(sk);
1671 err = 0;
1672
1673 msg->msg_namelen = 0;
1674
1675 lock_sock(sk);
1676
1677 if (sk->sk_state != SS_CONNECTED) {
1678
1679
1680
1681
1682
1683 if (sock_flag(sk, SOCK_DONE))
1684 err = 0;
1685 else
1686 err = -ENOTCONN;
1687
1688 goto out;
1689 }
1690
1691 if (flags & MSG_OOB) {
1692 err = -EOPNOTSUPP;
1693 goto out;
1694 }
1695
1696
1697
1698
1699
1700 if (sk->sk_shutdown & RCV_SHUTDOWN) {
1701 err = 0;
1702 goto out;
1703 }
1704
1705
1706
1707
1708 if (!len) {
1709 err = 0;
1710 goto out;
1711 }
1712
1713
1714
1715
1716
1717
1718
1719 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
1720 if (target >= transport->stream_rcvhiwat(vsk)) {
1721 err = -ENOMEM;
1722 goto out;
1723 }
1724 timeout = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
1725 copied = 0;
1726
1727 err = transport->notify_recv_init(vsk, target, &recv_data);
1728 if (err < 0)
1729 goto out;
1730
1731 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1732
1733 while (1) {
1734 s64 ready = vsock_stream_has_data(vsk);
1735
1736 if (ready < 0) {
1737
1738
1739
1740
1741 err = -ENOMEM;
1742 goto out_wait;
1743 } else if (ready > 0) {
1744 ssize_t read;
1745
1746 err = transport->notify_recv_pre_dequeue(
1747 vsk, target, &recv_data);
1748 if (err < 0)
1749 break;
1750
1751 read = transport->stream_dequeue(
1752 vsk, msg->msg_iov,
1753 len - copied, flags);
1754 if (read < 0) {
1755 err = -ENOMEM;
1756 break;
1757 }
1758
1759 copied += read;
1760
1761 err = transport->notify_recv_post_dequeue(
1762 vsk, target, read,
1763 !(flags & MSG_PEEK), &recv_data);
1764 if (err < 0)
1765 goto out_wait;
1766
1767 if (read >= target || flags & MSG_PEEK)
1768 break;
1769
1770 target -= read;
1771 } else {
1772 if (sk->sk_err != 0 || (sk->sk_shutdown & RCV_SHUTDOWN)
1773 || (vsk->peer_shutdown & SEND_SHUTDOWN)) {
1774 break;
1775 }
1776
1777 if (timeout == 0) {
1778 err = -EAGAIN;
1779 break;
1780 }
1781
1782 err = transport->notify_recv_pre_block(
1783 vsk, target, &recv_data);
1784 if (err < 0)
1785 break;
1786
1787 release_sock(sk);
1788 timeout = schedule_timeout(timeout);
1789 lock_sock(sk);
1790
1791 if (signal_pending(current)) {
1792 err = sock_intr_errno(timeout);
1793 break;
1794 } else if (timeout == 0) {
1795 err = -EAGAIN;
1796 break;
1797 }
1798
1799 prepare_to_wait(sk_sleep(sk), &wait,
1800 TASK_INTERRUPTIBLE);
1801 }
1802 }
1803
1804 if (sk->sk_err)
1805 err = -sk->sk_err;
1806 else if (sk->sk_shutdown & RCV_SHUTDOWN)
1807 err = 0;
1808
1809 if (copied > 0) {
1810
1811
1812
1813
1814
1815 if (!(flags & MSG_PEEK)) {
1816
1817
1818
1819
1820 if (vsk->peer_shutdown & SEND_SHUTDOWN) {
1821 if (vsock_stream_has_data(vsk) <= 0) {
1822 sk->sk_state = SS_UNCONNECTED;
1823 sock_set_flag(sk, SOCK_DONE);
1824 sk->sk_state_change(sk);
1825 }
1826 }
1827 }
1828 err = copied;
1829 }
1830
1831out_wait:
1832 finish_wait(sk_sleep(sk), &wait);
1833out:
1834 release_sock(sk);
1835 return err;
1836}
1837
1838static const struct proto_ops vsock_stream_ops = {
1839 .family = PF_VSOCK,
1840 .owner = THIS_MODULE,
1841 .release = vsock_release,
1842 .bind = vsock_bind,
1843 .connect = vsock_stream_connect,
1844 .socketpair = sock_no_socketpair,
1845 .accept = vsock_accept,
1846 .getname = vsock_getname,
1847 .poll = vsock_poll,
1848 .ioctl = sock_no_ioctl,
1849 .listen = vsock_listen,
1850 .shutdown = vsock_shutdown,
1851 .setsockopt = vsock_stream_setsockopt,
1852 .getsockopt = vsock_stream_getsockopt,
1853 .sendmsg = vsock_stream_sendmsg,
1854 .recvmsg = vsock_stream_recvmsg,
1855 .mmap = sock_no_mmap,
1856 .sendpage = sock_no_sendpage,
1857};
1858
1859static int vsock_create(struct net *net, struct socket *sock,
1860 int protocol, int kern)
1861{
1862 if (!sock)
1863 return -EINVAL;
1864
1865 if (protocol && protocol != PF_VSOCK)
1866 return -EPROTONOSUPPORT;
1867
1868 switch (sock->type) {
1869 case SOCK_DGRAM:
1870 sock->ops = &vsock_dgram_ops;
1871 break;
1872 case SOCK_STREAM:
1873 sock->ops = &vsock_stream_ops;
1874 break;
1875 default:
1876 return -ESOCKTNOSUPPORT;
1877 }
1878
1879 sock->state = SS_UNCONNECTED;
1880
1881 return __vsock_create(net, sock, NULL, GFP_KERNEL, 0) ? 0 : -ENOMEM;
1882}
1883
1884static const struct net_proto_family vsock_family_ops = {
1885 .family = AF_VSOCK,
1886 .create = vsock_create,
1887 .owner = THIS_MODULE,
1888};
1889
1890static long vsock_dev_do_ioctl(struct file *filp,
1891 unsigned int cmd, void __user *ptr)
1892{
1893 u32 __user *p = ptr;
1894 int retval = 0;
1895
1896 switch (cmd) {
1897 case IOCTL_VM_SOCKETS_GET_LOCAL_CID:
1898 if (put_user(transport->get_local_cid(), p) != 0)
1899 retval = -EFAULT;
1900 break;
1901
1902 default:
1903 pr_err("Unknown ioctl %d\n", cmd);
1904 retval = -EINVAL;
1905 }
1906
1907 return retval;
1908}
1909
1910static long vsock_dev_ioctl(struct file *filp,
1911 unsigned int cmd, unsigned long arg)
1912{
1913 return vsock_dev_do_ioctl(filp, cmd, (void __user *)arg);
1914}
1915
1916#ifdef CONFIG_COMPAT
1917static long vsock_dev_compat_ioctl(struct file *filp,
1918 unsigned int cmd, unsigned long arg)
1919{
1920 return vsock_dev_do_ioctl(filp, cmd, compat_ptr(arg));
1921}
1922#endif
1923
1924static const struct file_operations vsock_device_ops = {
1925 .owner = THIS_MODULE,
1926 .unlocked_ioctl = vsock_dev_ioctl,
1927#ifdef CONFIG_COMPAT
1928 .compat_ioctl = vsock_dev_compat_ioctl,
1929#endif
1930 .open = nonseekable_open,
1931};
1932
1933static struct miscdevice vsock_device = {
1934 .name = "vsock",
1935 .fops = &vsock_device_ops,
1936};
1937
1938static int __vsock_core_init(void)
1939{
1940 int err;
1941
1942 vsock_init_tables();
1943
1944 vsock_device.minor = MISC_DYNAMIC_MINOR;
1945 err = misc_register(&vsock_device);
1946 if (err) {
1947 pr_err("Failed to register misc device\n");
1948 return -ENOENT;
1949 }
1950
1951 err = proto_register(&vsock_proto, 1);
1952 if (err) {
1953 pr_err("Cannot register vsock protocol\n");
1954 goto err_misc_deregister;
1955 }
1956
1957 err = sock_register(&vsock_family_ops);
1958 if (err) {
1959 pr_err("could not register af_vsock (%d) address family: %d\n",
1960 AF_VSOCK, err);
1961 goto err_unregister_proto;
1962 }
1963
1964 return 0;
1965
1966err_unregister_proto:
1967 proto_unregister(&vsock_proto);
1968err_misc_deregister:
1969 misc_deregister(&vsock_device);
1970 return err;
1971}
1972
1973int vsock_core_init(const struct vsock_transport *t)
1974{
1975 int retval = mutex_lock_interruptible(&vsock_register_mutex);
1976 if (retval)
1977 return retval;
1978
1979 if (transport) {
1980 retval = -EBUSY;
1981 goto out;
1982 }
1983
1984 transport = t;
1985 retval = __vsock_core_init();
1986 if (retval)
1987 transport = NULL;
1988
1989out:
1990 mutex_unlock(&vsock_register_mutex);
1991 return retval;
1992}
1993EXPORT_SYMBOL_GPL(vsock_core_init);
1994
1995void vsock_core_exit(void)
1996{
1997 mutex_lock(&vsock_register_mutex);
1998
1999 misc_deregister(&vsock_device);
2000 sock_unregister(AF_VSOCK);
2001 proto_unregister(&vsock_proto);
2002
2003
2004 mb();
2005 transport = NULL;
2006
2007 mutex_unlock(&vsock_register_mutex);
2008}
2009EXPORT_SYMBOL_GPL(vsock_core_exit);
2010
2011MODULE_AUTHOR("VMware, Inc.");
2012MODULE_DESCRIPTION("VMware Virtual Socket Family");
2013MODULE_VERSION("1.0.0.0-k");
2014MODULE_LICENSE("GPL v2");
2015