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