2 * VMware vSockets Driver
4 * Copyright (C) 2007-2013 VMware, Inc. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 /* Implementation notes:
18 * - There are two kinds of sockets: those created by user action (such as
19 * calling socket(2)) and those created by incoming connection request packets.
21 * - There are two "global" tables, one for bound sockets (sockets that have
22 * specified an address that they are responsible for) and one for connected
23 * sockets (sockets that have established a connection with another socket).
24 * These tables are "global" in that all sockets on the system are placed
25 * within them. - Note, though, that the bound table contains an extra entry
26 * for a list of unbound sockets and SOCK_DGRAM sockets will always remain in
27 * that list. The bound table is used solely for lookup of sockets when packets
28 * are received and that's not necessary for SOCK_DGRAM sockets since we create
29 * a datagram handle for each and need not perform a lookup. Keeping SOCK_DGRAM
30 * sockets out of the bound hash buckets will reduce the chance of collisions
31 * when looking for SOCK_STREAM sockets and prevents us from having to check the
32 * socket type in the hash table lookups.
34 * - Sockets created by user action will either be "client" sockets that
35 * initiate a connection or "server" sockets that listen for connections; we do
36 * not support simultaneous connects (two "client" sockets connecting).
38 * - "Server" sockets are referred to as listener sockets throughout this
39 * implementation because they are in the SS_LISTEN state. When a connection
40 * request is received (the second kind of socket mentioned above), we create a
41 * new socket and refer to it as a pending socket. These pending sockets are
42 * placed on the pending connection list of the listener socket. When future
43 * packets are received for the address the listener socket is bound to, we
44 * check if the source of the packet is from one that has an existing pending
45 * connection. If it does, we process the packet for the pending socket. When
46 * that socket reaches the connected state, it is removed from the listener
47 * socket's pending list and enqueued in the listener socket's accept queue.
48 * Callers of accept(2) will accept connected sockets from the listener socket's
49 * accept queue. If the socket cannot be accepted for some reason then it is
50 * marked rejected. Once the connection is accepted, it is owned by the user
51 * process and the responsibility for cleanup falls with that user process.
53 * - It is possible that these pending sockets will never reach the connected
54 * state; in fact, we may never receive another packet after the connection
55 * request. Because of this, we must schedule a cleanup function to run in the
56 * future, after some amount of time passes where a connection should have been
57 * established. This function ensures that the socket is off all lists so it
58 * cannot be retrieved, then drops all references to the socket so it is cleaned
59 * up (sock_put() -> sk_free() -> our sk_destruct implementation). Note this
60 * function will also cleanup rejected sockets, those that reach the connected
61 * state but leave it before they have been accepted.
63 * - Sockets created by user action will be cleaned up when the user process
64 * calls close(2), causing our release implementation to be called. Our release
65 * implementation will perform some cleanup then drop the last reference so our
66 * sk_destruct implementation is invoked. Our sk_destruct implementation will
67 * perform additional cleanup that's common for both types of sockets.
69 * - A socket's reference count is what ensures that the structure won't be
70 * freed. Each entry in a list (such as the "global" bound and connected tables
71 * and the listener socket's pending list and connected queue) ensures a
72 * reference. When we defer work until process context and pass a socket as our
73 * argument, we must ensure the reference count is increased to ensure the
74 * socket isn't freed before the function is run; the deferred function will
75 * then drop the reference.
78 #include <linux/types.h>
79 #include <linux/bitops.h>
80 #include <linux/cred.h>
81 #include <linux/init.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>
100 #include "af_vsock.h"
102 static int __vsock_bind(struct sock
*sk
, struct sockaddr_vm
*addr
);
103 static void vsock_sk_destruct(struct sock
*sk
);
104 static int vsock_queue_rcv_skb(struct sock
*sk
, struct sk_buff
*skb
);
106 /* Protocol family. */
107 static struct proto vsock_proto
= {
109 .owner
= THIS_MODULE
,
110 .obj_size
= sizeof(struct vsock_sock
),
113 /* The default peer timeout indicates how long we will wait for a peer response
114 * to a control message.
116 #define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ)
118 #define SS_LISTEN 255
120 static const struct vsock_transport
*transport
;
121 static DEFINE_MUTEX(vsock_register_mutex
);
125 /* Get the ID of the local context. This is transport dependent. */
127 int vm_sockets_get_local_cid(void)
129 return transport
->get_local_cid();
131 EXPORT_SYMBOL_GPL(vm_sockets_get_local_cid
);
135 /* Each bound VSocket is stored in the bind hash table and each connected
136 * VSocket is stored in the connected hash table.
138 * Unbound sockets are all put on the same list attached to the end of the hash
139 * table (vsock_unbound_sockets). Bound sockets are added to the hash table in
140 * the bucket that their local address hashes to (vsock_bound_sockets(addr)
141 * represents the list that addr hashes to).
143 * Specifically, we initialize the vsock_bind_table array to a size of
144 * VSOCK_HASH_SIZE + 1 so that vsock_bind_table[0] through
145 * vsock_bind_table[VSOCK_HASH_SIZE - 1] are for bound sockets and
146 * vsock_bind_table[VSOCK_HASH_SIZE] is for unbound sockets. The hash function
147 * mods with VSOCK_HASH_SIZE to ensure this.
149 #define VSOCK_HASH_SIZE 251
150 #define MAX_PORT_RETRIES 24
152 #define VSOCK_HASH(addr) ((addr)->svm_port % VSOCK_HASH_SIZE)
153 #define vsock_bound_sockets(addr) (&vsock_bind_table[VSOCK_HASH(addr)])
154 #define vsock_unbound_sockets (&vsock_bind_table[VSOCK_HASH_SIZE])
156 /* XXX This can probably be implemented in a better way. */
157 #define VSOCK_CONN_HASH(src, dst) \
158 (((src)->svm_cid ^ (dst)->svm_port) % VSOCK_HASH_SIZE)
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)
164 static struct list_head vsock_bind_table
[VSOCK_HASH_SIZE
+ 1];
165 static struct list_head vsock_connected_table
[VSOCK_HASH_SIZE
];
166 static DEFINE_SPINLOCK(vsock_table_lock
);
168 /* Autobind this socket to the local address if necessary. */
169 static int vsock_auto_bind(struct vsock_sock
*vsk
)
171 struct sock
*sk
= sk_vsock(vsk
);
172 struct sockaddr_vm local_addr
;
174 if (vsock_addr_bound(&vsk
->local_addr
))
176 vsock_addr_init(&local_addr
, VMADDR_CID_ANY
, VMADDR_PORT_ANY
);
177 return __vsock_bind(sk
, &local_addr
);
180 static void vsock_init_tables(void)
184 for (i
= 0; i
< ARRAY_SIZE(vsock_bind_table
); i
++)
185 INIT_LIST_HEAD(&vsock_bind_table
[i
]);
187 for (i
= 0; i
< ARRAY_SIZE(vsock_connected_table
); i
++)
188 INIT_LIST_HEAD(&vsock_connected_table
[i
]);
191 static void __vsock_insert_bound(struct list_head
*list
,
192 struct vsock_sock
*vsk
)
195 list_add(&vsk
->bound_table
, list
);
198 static void __vsock_insert_connected(struct list_head
*list
,
199 struct vsock_sock
*vsk
)
202 list_add(&vsk
->connected_table
, list
);
205 static void __vsock_remove_bound(struct vsock_sock
*vsk
)
207 list_del_init(&vsk
->bound_table
);
211 static void __vsock_remove_connected(struct vsock_sock
*vsk
)
213 list_del_init(&vsk
->connected_table
);
217 static struct sock
*__vsock_find_bound_socket(struct sockaddr_vm
*addr
)
219 struct vsock_sock
*vsk
;
221 list_for_each_entry(vsk
, vsock_bound_sockets(addr
), bound_table
)
222 if (addr
->svm_port
== vsk
->local_addr
.svm_port
)
223 return sk_vsock(vsk
);
228 static struct sock
*__vsock_find_connected_socket(struct sockaddr_vm
*src
,
229 struct sockaddr_vm
*dst
)
231 struct vsock_sock
*vsk
;
233 list_for_each_entry(vsk
, vsock_connected_sockets(src
, dst
),
235 if (vsock_addr_equals_addr(src
, &vsk
->remote_addr
) &&
236 dst
->svm_port
== vsk
->local_addr
.svm_port
) {
237 return sk_vsock(vsk
);
244 static bool __vsock_in_bound_table(struct vsock_sock
*vsk
)
246 return !list_empty(&vsk
->bound_table
);
249 static bool __vsock_in_connected_table(struct vsock_sock
*vsk
)
251 return !list_empty(&vsk
->connected_table
);
254 static void vsock_insert_unbound(struct vsock_sock
*vsk
)
256 spin_lock_bh(&vsock_table_lock
);
257 __vsock_insert_bound(vsock_unbound_sockets
, vsk
);
258 spin_unlock_bh(&vsock_table_lock
);
261 void vsock_insert_connected(struct vsock_sock
*vsk
)
263 struct list_head
*list
= vsock_connected_sockets(
264 &vsk
->remote_addr
, &vsk
->local_addr
);
266 spin_lock_bh(&vsock_table_lock
);
267 __vsock_insert_connected(list
, vsk
);
268 spin_unlock_bh(&vsock_table_lock
);
270 EXPORT_SYMBOL_GPL(vsock_insert_connected
);
272 void vsock_remove_bound(struct vsock_sock
*vsk
)
274 spin_lock_bh(&vsock_table_lock
);
275 __vsock_remove_bound(vsk
);
276 spin_unlock_bh(&vsock_table_lock
);
278 EXPORT_SYMBOL_GPL(vsock_remove_bound
);
280 void vsock_remove_connected(struct vsock_sock
*vsk
)
282 spin_lock_bh(&vsock_table_lock
);
283 __vsock_remove_connected(vsk
);
284 spin_unlock_bh(&vsock_table_lock
);
286 EXPORT_SYMBOL_GPL(vsock_remove_connected
);
288 struct sock
*vsock_find_bound_socket(struct sockaddr_vm
*addr
)
292 spin_lock_bh(&vsock_table_lock
);
293 sk
= __vsock_find_bound_socket(addr
);
297 spin_unlock_bh(&vsock_table_lock
);
301 EXPORT_SYMBOL_GPL(vsock_find_bound_socket
);
303 struct sock
*vsock_find_connected_socket(struct sockaddr_vm
*src
,
304 struct sockaddr_vm
*dst
)
308 spin_lock_bh(&vsock_table_lock
);
309 sk
= __vsock_find_connected_socket(src
, dst
);
313 spin_unlock_bh(&vsock_table_lock
);
317 EXPORT_SYMBOL_GPL(vsock_find_connected_socket
);
319 static bool vsock_in_bound_table(struct vsock_sock
*vsk
)
323 spin_lock_bh(&vsock_table_lock
);
324 ret
= __vsock_in_bound_table(vsk
);
325 spin_unlock_bh(&vsock_table_lock
);
330 static bool vsock_in_connected_table(struct vsock_sock
*vsk
)
334 spin_lock_bh(&vsock_table_lock
);
335 ret
= __vsock_in_connected_table(vsk
);
336 spin_unlock_bh(&vsock_table_lock
);
341 void vsock_for_each_connected_socket(void (*fn
)(struct sock
*sk
))
345 spin_lock_bh(&vsock_table_lock
);
347 for (i
= 0; i
< ARRAY_SIZE(vsock_connected_table
); i
++) {
348 struct vsock_sock
*vsk
;
349 list_for_each_entry(vsk
, &vsock_connected_table
[i
],
354 spin_unlock_bh(&vsock_table_lock
);
356 EXPORT_SYMBOL_GPL(vsock_for_each_connected_socket
);
358 void vsock_add_pending(struct sock
*listener
, struct sock
*pending
)
360 struct vsock_sock
*vlistener
;
361 struct vsock_sock
*vpending
;
363 vlistener
= vsock_sk(listener
);
364 vpending
= vsock_sk(pending
);
368 list_add_tail(&vpending
->pending_links
, &vlistener
->pending_links
);
370 EXPORT_SYMBOL_GPL(vsock_add_pending
);
372 void vsock_remove_pending(struct sock
*listener
, struct sock
*pending
)
374 struct vsock_sock
*vpending
= vsock_sk(pending
);
376 list_del_init(&vpending
->pending_links
);
380 EXPORT_SYMBOL_GPL(vsock_remove_pending
);
382 void vsock_enqueue_accept(struct sock
*listener
, struct sock
*connected
)
384 struct vsock_sock
*vlistener
;
385 struct vsock_sock
*vconnected
;
387 vlistener
= vsock_sk(listener
);
388 vconnected
= vsock_sk(connected
);
390 sock_hold(connected
);
392 list_add_tail(&vconnected
->accept_queue
, &vlistener
->accept_queue
);
394 EXPORT_SYMBOL_GPL(vsock_enqueue_accept
);
396 static struct sock
*vsock_dequeue_accept(struct sock
*listener
)
398 struct vsock_sock
*vlistener
;
399 struct vsock_sock
*vconnected
;
401 vlistener
= vsock_sk(listener
);
403 if (list_empty(&vlistener
->accept_queue
))
406 vconnected
= list_entry(vlistener
->accept_queue
.next
,
407 struct vsock_sock
, accept_queue
);
409 list_del_init(&vconnected
->accept_queue
);
411 /* The caller will need a reference on the connected socket so we let
412 * it call sock_put().
415 return sk_vsock(vconnected
);
418 static bool vsock_is_accept_queue_empty(struct sock
*sk
)
420 struct vsock_sock
*vsk
= vsock_sk(sk
);
421 return list_empty(&vsk
->accept_queue
);
424 static bool vsock_is_pending(struct sock
*sk
)
426 struct vsock_sock
*vsk
= vsock_sk(sk
);
427 return !list_empty(&vsk
->pending_links
);
430 static int vsock_send_shutdown(struct sock
*sk
, int mode
)
432 return transport
->shutdown(vsock_sk(sk
), mode
);
435 void vsock_pending_work(struct work_struct
*work
)
438 struct sock
*listener
;
439 struct vsock_sock
*vsk
;
442 vsk
= container_of(work
, struct vsock_sock
, dwork
.work
);
444 listener
= vsk
->listener
;
450 if (vsock_is_pending(sk
)) {
451 vsock_remove_pending(listener
, sk
);
452 } else if (!vsk
->rejected
) {
453 /* We are not on the pending list and accept() did not reject
454 * us, so we must have been accepted by our user process. We
455 * just need to drop our references to the sockets and be on
462 listener
->sk_ack_backlog
--;
464 /* We need to remove ourself from the global connected sockets list so
465 * incoming packets can't find this socket, and to reduce the reference
468 if (vsock_in_connected_table(vsk
))
469 vsock_remove_connected(vsk
);
471 sk
->sk_state
= SS_FREE
;
475 release_sock(listener
);
482 EXPORT_SYMBOL_GPL(vsock_pending_work
);
484 /**** SOCKET OPERATIONS ****/
486 static int __vsock_bind_stream(struct vsock_sock
*vsk
,
487 struct sockaddr_vm
*addr
)
489 static u32 port
= LAST_RESERVED_PORT
+ 1;
490 struct sockaddr_vm new_addr
;
492 vsock_addr_init(&new_addr
, addr
->svm_cid
, addr
->svm_port
);
494 if (addr
->svm_port
== VMADDR_PORT_ANY
) {
498 for (i
= 0; i
< MAX_PORT_RETRIES
; i
++) {
499 if (port
<= LAST_RESERVED_PORT
)
500 port
= LAST_RESERVED_PORT
+ 1;
502 new_addr
.svm_port
= port
++;
504 if (!__vsock_find_bound_socket(&new_addr
)) {
511 return -EADDRNOTAVAIL
;
513 /* If port is in reserved range, ensure caller
514 * has necessary privileges.
516 if (addr
->svm_port
<= LAST_RESERVED_PORT
&&
517 !capable(CAP_NET_BIND_SERVICE
)) {
521 if (__vsock_find_bound_socket(&new_addr
))
525 vsock_addr_init(&vsk
->local_addr
, new_addr
.svm_cid
, new_addr
.svm_port
);
527 /* Remove stream sockets from the unbound list and add them to the hash
528 * table for easy lookup by its address. The unbound list is simply an
529 * extra entry at the end of the hash table, a trick used by AF_UNIX.
531 __vsock_remove_bound(vsk
);
532 __vsock_insert_bound(vsock_bound_sockets(&vsk
->local_addr
), vsk
);
537 static int __vsock_bind_dgram(struct vsock_sock
*vsk
,
538 struct sockaddr_vm
*addr
)
540 return transport
->dgram_bind(vsk
, addr
);
543 static int __vsock_bind(struct sock
*sk
, struct sockaddr_vm
*addr
)
545 struct vsock_sock
*vsk
= vsock_sk(sk
);
549 /* First ensure this socket isn't already bound. */
550 if (vsock_addr_bound(&vsk
->local_addr
))
553 /* Now bind to the provided address or select appropriate values if
554 * none are provided (VMADDR_CID_ANY and VMADDR_PORT_ANY). Note that
555 * like AF_INET prevents binding to a non-local IP address (in most
556 * cases), we only allow binding to the local CID.
558 cid
= transport
->get_local_cid();
559 if (addr
->svm_cid
!= cid
&& addr
->svm_cid
!= VMADDR_CID_ANY
)
560 return -EADDRNOTAVAIL
;
562 switch (sk
->sk_socket
->type
) {
564 spin_lock_bh(&vsock_table_lock
);
565 retval
= __vsock_bind_stream(vsk
, addr
);
566 spin_unlock_bh(&vsock_table_lock
);
570 retval
= __vsock_bind_dgram(vsk
, addr
);
581 struct sock
*__vsock_create(struct net
*net
,
588 struct vsock_sock
*psk
;
589 struct vsock_sock
*vsk
;
591 sk
= sk_alloc(net
, AF_VSOCK
, priority
, &vsock_proto
);
595 sock_init_data(sock
, sk
);
597 /* sk->sk_type is normally set in sock_init_data, but only if sock is
598 * non-NULL. We make sure that our sockets always have a type by
599 * setting it here if needed.
605 vsock_addr_init(&vsk
->local_addr
, VMADDR_CID_ANY
, VMADDR_PORT_ANY
);
606 vsock_addr_init(&vsk
->remote_addr
, VMADDR_CID_ANY
, VMADDR_PORT_ANY
);
608 sk
->sk_destruct
= vsock_sk_destruct
;
609 sk
->sk_backlog_rcv
= vsock_queue_rcv_skb
;
611 sock_reset_flag(sk
, SOCK_DONE
);
613 INIT_LIST_HEAD(&vsk
->bound_table
);
614 INIT_LIST_HEAD(&vsk
->connected_table
);
615 vsk
->listener
= NULL
;
616 INIT_LIST_HEAD(&vsk
->pending_links
);
617 INIT_LIST_HEAD(&vsk
->accept_queue
);
618 vsk
->rejected
= false;
619 vsk
->sent_request
= false;
620 vsk
->ignore_connecting_rst
= false;
621 vsk
->peer_shutdown
= 0;
623 psk
= parent
? vsock_sk(parent
) : NULL
;
625 vsk
->trusted
= psk
->trusted
;
626 vsk
->owner
= get_cred(psk
->owner
);
627 vsk
->connect_timeout
= psk
->connect_timeout
;
629 vsk
->trusted
= capable(CAP_NET_ADMIN
);
630 vsk
->owner
= get_current_cred();
631 vsk
->connect_timeout
= VSOCK_DEFAULT_CONNECT_TIMEOUT
;
634 if (transport
->init(vsk
, psk
) < 0) {
640 vsock_insert_unbound(vsk
);
644 EXPORT_SYMBOL_GPL(__vsock_create
);
646 static void __vsock_release(struct sock
*sk
)
650 struct sock
*pending
;
651 struct vsock_sock
*vsk
;
654 pending
= NULL
; /* Compiler warning. */
656 if (vsock_in_bound_table(vsk
))
657 vsock_remove_bound(vsk
);
659 if (vsock_in_connected_table(vsk
))
660 vsock_remove_connected(vsk
);
662 transport
->release(vsk
);
666 sk
->sk_shutdown
= SHUTDOWN_MASK
;
668 while ((skb
= skb_dequeue(&sk
->sk_receive_queue
)))
671 /* Clean up any sockets that never were accepted. */
672 while ((pending
= vsock_dequeue_accept(sk
)) != NULL
) {
673 __vsock_release(pending
);
682 static void vsock_sk_destruct(struct sock
*sk
)
684 struct vsock_sock
*vsk
= vsock_sk(sk
);
686 transport
->destruct(vsk
);
688 /* When clearing these addresses, there's no need to set the family and
689 * possibly register the address family with the kernel.
691 vsock_addr_init(&vsk
->local_addr
, VMADDR_CID_ANY
, VMADDR_PORT_ANY
);
692 vsock_addr_init(&vsk
->remote_addr
, VMADDR_CID_ANY
, VMADDR_PORT_ANY
);
694 put_cred(vsk
->owner
);
697 static int vsock_queue_rcv_skb(struct sock
*sk
, struct sk_buff
*skb
)
701 err
= sock_queue_rcv_skb(sk
, skb
);
708 s64
vsock_stream_has_data(struct vsock_sock
*vsk
)
710 return transport
->stream_has_data(vsk
);
712 EXPORT_SYMBOL_GPL(vsock_stream_has_data
);
714 s64
vsock_stream_has_space(struct vsock_sock
*vsk
)
716 return transport
->stream_has_space(vsk
);
718 EXPORT_SYMBOL_GPL(vsock_stream_has_space
);
720 static int vsock_release(struct socket
*sock
)
722 __vsock_release(sock
->sk
);
724 sock
->state
= SS_FREE
;
730 vsock_bind(struct socket
*sock
, struct sockaddr
*addr
, int addr_len
)
734 struct sockaddr_vm
*vm_addr
;
738 if (vsock_addr_cast(addr
, addr_len
, &vm_addr
) != 0)
742 err
= __vsock_bind(sk
, vm_addr
);
748 static int vsock_getname(struct socket
*sock
,
749 struct sockaddr
*addr
, int *addr_len
, int peer
)
753 struct vsock_sock
*vsk
;
754 struct sockaddr_vm
*vm_addr
;
763 if (sock
->state
!= SS_CONNECTED
) {
767 vm_addr
= &vsk
->remote_addr
;
769 vm_addr
= &vsk
->local_addr
;
777 /* sys_getsockname() and sys_getpeername() pass us a
778 * MAX_SOCK_ADDR-sized buffer and don't set addr_len. Unfortunately
779 * that macro is defined in socket.c instead of .h, so we hardcode its
782 BUILD_BUG_ON(sizeof(*vm_addr
) > 128);
783 memcpy(addr
, vm_addr
, sizeof(*vm_addr
));
784 *addr_len
= sizeof(*vm_addr
);
791 static int vsock_shutdown(struct socket
*sock
, int mode
)
796 /* User level uses SHUT_RD (0) and SHUT_WR (1), but the kernel uses
797 * RCV_SHUTDOWN (1) and SEND_SHUTDOWN (2), so we must increment mode
798 * here like the other address families do. Note also that the
799 * increment makes SHUT_RDWR (2) into RCV_SHUTDOWN | SEND_SHUTDOWN (3),
800 * which is what we want.
804 if ((mode
& ~SHUTDOWN_MASK
) || !mode
)
807 /* If this is a STREAM socket and it is not connected then bail out
808 * immediately. If it is a DGRAM socket then we must first kick the
809 * socket so that it wakes up from any sleeping calls, for example
810 * recv(), and then afterwards return the error.
814 if (sock
->state
== SS_UNCONNECTED
) {
816 if (sk
->sk_type
== SOCK_STREAM
)
819 sock
->state
= SS_DISCONNECTING
;
823 /* Receive and send shutdowns are treated alike. */
824 mode
= mode
& (RCV_SHUTDOWN
| SEND_SHUTDOWN
);
827 sk
->sk_shutdown
|= mode
;
828 sk
->sk_state_change(sk
);
831 if (sk
->sk_type
== SOCK_STREAM
) {
832 sock_reset_flag(sk
, SOCK_DONE
);
833 vsock_send_shutdown(sk
, mode
);
840 static unsigned int vsock_poll(struct file
*file
, struct socket
*sock
,
845 struct vsock_sock
*vsk
;
850 poll_wait(file
, sk_sleep(sk
), wait
);
854 /* Signify that there has been an error on this socket. */
857 /* INET sockets treat local write shutdown and peer write shutdown as a
858 * case of POLLHUP set.
860 if ((sk
->sk_shutdown
== SHUTDOWN_MASK
) ||
861 ((sk
->sk_shutdown
& SEND_SHUTDOWN
) &&
862 (vsk
->peer_shutdown
& SEND_SHUTDOWN
))) {
866 if (sk
->sk_shutdown
& RCV_SHUTDOWN
||
867 vsk
->peer_shutdown
& SEND_SHUTDOWN
) {
871 if (sock
->type
== SOCK_DGRAM
) {
872 /* For datagram sockets we can read if there is something in
873 * the queue and write as long as the socket isn't shutdown for
876 if (!skb_queue_empty(&sk
->sk_receive_queue
) ||
877 (sk
->sk_shutdown
& RCV_SHUTDOWN
)) {
878 mask
|= POLLIN
| POLLRDNORM
;
881 if (!(sk
->sk_shutdown
& SEND_SHUTDOWN
))
882 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
884 } else if (sock
->type
== SOCK_STREAM
) {
887 /* Listening sockets that have connections in their accept
890 if (sk
->sk_state
== SS_LISTEN
891 && !vsock_is_accept_queue_empty(sk
))
892 mask
|= POLLIN
| POLLRDNORM
;
894 /* If there is something in the queue then we can read. */
895 if (transport
->stream_is_active(vsk
) &&
896 !(sk
->sk_shutdown
& RCV_SHUTDOWN
)) {
897 bool data_ready_now
= false;
898 int ret
= transport
->notify_poll_in(
899 vsk
, 1, &data_ready_now
);
904 mask
|= POLLIN
| POLLRDNORM
;
909 /* Sockets whose connections have been closed, reset, or
910 * terminated should also be considered read, and we check the
911 * shutdown flag for that.
913 if (sk
->sk_shutdown
& RCV_SHUTDOWN
||
914 vsk
->peer_shutdown
& SEND_SHUTDOWN
) {
915 mask
|= POLLIN
| POLLRDNORM
;
918 /* Connected sockets that can produce data can be written. */
919 if (sk
->sk_state
== SS_CONNECTED
) {
920 if (!(sk
->sk_shutdown
& SEND_SHUTDOWN
)) {
921 bool space_avail_now
= false;
922 int ret
= transport
->notify_poll_out(
923 vsk
, 1, &space_avail_now
);
928 /* Remove POLLWRBAND since INET
929 * sockets are not setting it.
931 mask
|= POLLOUT
| POLLWRNORM
;
937 /* Simulate INET socket poll behaviors, which sets
938 * POLLOUT|POLLWRNORM when peer is closed and nothing to read,
939 * but local send is not shutdown.
941 if (sk
->sk_state
== SS_UNCONNECTED
) {
942 if (!(sk
->sk_shutdown
& SEND_SHUTDOWN
))
943 mask
|= POLLOUT
| POLLWRNORM
;
953 static int vsock_dgram_sendmsg(struct kiocb
*kiocb
, struct socket
*sock
,
954 struct msghdr
*msg
, size_t len
)
958 struct vsock_sock
*vsk
;
959 struct sockaddr_vm
*remote_addr
;
961 if (msg
->msg_flags
& MSG_OOB
)
964 /* For now, MSG_DONTWAIT is always assumed... */
971 err
= vsock_auto_bind(vsk
);
976 /* If the provided message contains an address, use that. Otherwise
977 * fall back on the socket's remote handle (if it has been connected).
980 vsock_addr_cast(msg
->msg_name
, msg
->msg_namelen
,
981 &remote_addr
) == 0) {
982 /* Ensure this address is of the right type and is a valid
986 if (remote_addr
->svm_cid
== VMADDR_CID_ANY
)
987 remote_addr
->svm_cid
= transport
->get_local_cid();
989 if (!vsock_addr_bound(remote_addr
)) {
993 } else if (sock
->state
== SS_CONNECTED
) {
994 remote_addr
= &vsk
->remote_addr
;
996 if (remote_addr
->svm_cid
== VMADDR_CID_ANY
)
997 remote_addr
->svm_cid
= transport
->get_local_cid();
999 /* XXX Should connect() or this function ensure remote_addr is
1002 if (!vsock_addr_bound(&vsk
->remote_addr
)) {
1011 if (!transport
->dgram_allow(remote_addr
->svm_cid
,
1012 remote_addr
->svm_port
)) {
1017 err
= transport
->dgram_enqueue(vsk
, remote_addr
, msg
->msg_iov
, len
);
1024 static int vsock_dgram_connect(struct socket
*sock
,
1025 struct sockaddr
*addr
, int addr_len
, int flags
)
1029 struct vsock_sock
*vsk
;
1030 struct sockaddr_vm
*remote_addr
;
1035 err
= vsock_addr_cast(addr
, addr_len
, &remote_addr
);
1036 if (err
== -EAFNOSUPPORT
&& remote_addr
->svm_family
== AF_UNSPEC
) {
1038 vsock_addr_init(&vsk
->remote_addr
, VMADDR_CID_ANY
,
1040 sock
->state
= SS_UNCONNECTED
;
1043 } else if (err
!= 0)
1048 err
= vsock_auto_bind(vsk
);
1052 if (!transport
->dgram_allow(remote_addr
->svm_cid
,
1053 remote_addr
->svm_port
)) {
1058 memcpy(&vsk
->remote_addr
, remote_addr
, sizeof(vsk
->remote_addr
));
1059 sock
->state
= SS_CONNECTED
;
1066 static int vsock_dgram_recvmsg(struct kiocb
*kiocb
, struct socket
*sock
,
1067 struct msghdr
*msg
, size_t len
, int flags
)
1069 return transport
->dgram_dequeue(kiocb
, vsock_sk(sock
->sk
), msg
, len
,
1073 static const struct proto_ops vsock_dgram_ops
= {
1075 .owner
= THIS_MODULE
,
1076 .release
= vsock_release
,
1078 .connect
= vsock_dgram_connect
,
1079 .socketpair
= sock_no_socketpair
,
1080 .accept
= sock_no_accept
,
1081 .getname
= vsock_getname
,
1083 .ioctl
= sock_no_ioctl
,
1084 .listen
= sock_no_listen
,
1085 .shutdown
= vsock_shutdown
,
1086 .setsockopt
= sock_no_setsockopt
,
1087 .getsockopt
= sock_no_getsockopt
,
1088 .sendmsg
= vsock_dgram_sendmsg
,
1089 .recvmsg
= vsock_dgram_recvmsg
,
1090 .mmap
= sock_no_mmap
,
1091 .sendpage
= sock_no_sendpage
,
1094 static void vsock_connect_timeout(struct work_struct
*work
)
1097 struct vsock_sock
*vsk
;
1099 vsk
= container_of(work
, struct vsock_sock
, dwork
.work
);
1103 if (sk
->sk_state
== SS_CONNECTING
&&
1104 (sk
->sk_shutdown
!= SHUTDOWN_MASK
)) {
1105 sk
->sk_state
= SS_UNCONNECTED
;
1106 sk
->sk_err
= ETIMEDOUT
;
1107 sk
->sk_error_report(sk
);
1114 static int vsock_stream_connect(struct socket
*sock
, struct sockaddr
*addr
,
1115 int addr_len
, int flags
)
1119 struct vsock_sock
*vsk
;
1120 struct sockaddr_vm
*remote_addr
;
1130 /* XXX AF_UNSPEC should make us disconnect like AF_INET. */
1131 switch (sock
->state
) {
1135 case SS_DISCONNECTING
:
1139 /* This continues on so we can move sock into the SS_CONNECTED
1140 * state once the connection has completed (at which point err
1141 * will be set to zero also). Otherwise, we will either wait
1142 * for the connection or return -EALREADY should this be a
1143 * non-blocking call.
1148 if ((sk
->sk_state
== SS_LISTEN
) ||
1149 vsock_addr_cast(addr
, addr_len
, &remote_addr
) != 0) {
1154 /* The hypervisor and well-known contexts do not have socket
1157 if (!transport
->stream_allow(remote_addr
->svm_cid
,
1158 remote_addr
->svm_port
)) {
1163 /* Set the remote address that we are connecting to. */
1164 memcpy(&vsk
->remote_addr
, remote_addr
,
1165 sizeof(vsk
->remote_addr
));
1167 err
= vsock_auto_bind(vsk
);
1171 sk
->sk_state
= SS_CONNECTING
;
1173 err
= transport
->connect(vsk
);
1177 /* Mark sock as connecting and set the error code to in
1178 * progress in case this is a non-blocking connect.
1180 sock
->state
= SS_CONNECTING
;
1184 /* The receive path will handle all communication until we are able to
1185 * enter the connected state. Here we wait for the connection to be
1186 * completed or a notification of an error.
1188 timeout
= vsk
->connect_timeout
;
1189 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
1191 while (sk
->sk_state
!= SS_CONNECTED
&& sk
->sk_err
== 0) {
1192 if (flags
& O_NONBLOCK
) {
1193 /* If we're not going to block, we schedule a timeout
1194 * function to generate a timeout on the connection
1195 * attempt, in case the peer doesn't respond in a
1196 * timely manner. We hold on to the socket until the
1200 INIT_DELAYED_WORK(&vsk
->dwork
,
1201 vsock_connect_timeout
);
1202 schedule_delayed_work(&vsk
->dwork
, timeout
);
1204 /* Skip ahead to preserve error code set above. */
1209 timeout
= schedule_timeout(timeout
);
1212 if (signal_pending(current
)) {
1213 err
= sock_intr_errno(timeout
);
1214 goto out_wait_error
;
1215 } else if (timeout
== 0) {
1217 goto out_wait_error
;
1220 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
1225 goto out_wait_error
;
1230 finish_wait(sk_sleep(sk
), &wait
);
1236 sk
->sk_state
= SS_UNCONNECTED
;
1237 sock
->state
= SS_UNCONNECTED
;
1241 static int vsock_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
1243 struct sock
*listener
;
1245 struct sock
*connected
;
1246 struct vsock_sock
*vconnected
;
1251 listener
= sock
->sk
;
1253 lock_sock(listener
);
1255 if (sock
->type
!= SOCK_STREAM
) {
1260 if (listener
->sk_state
!= SS_LISTEN
) {
1265 /* Wait for children sockets to appear; these are the new sockets
1266 * created upon connection establishment.
1268 timeout
= sock_sndtimeo(listener
, flags
& O_NONBLOCK
);
1269 prepare_to_wait(sk_sleep(listener
), &wait
, TASK_INTERRUPTIBLE
);
1271 while ((connected
= vsock_dequeue_accept(listener
)) == NULL
&&
1272 listener
->sk_err
== 0) {
1273 release_sock(listener
);
1274 timeout
= schedule_timeout(timeout
);
1275 lock_sock(listener
);
1277 if (signal_pending(current
)) {
1278 err
= sock_intr_errno(timeout
);
1280 } else if (timeout
== 0) {
1285 prepare_to_wait(sk_sleep(listener
), &wait
, TASK_INTERRUPTIBLE
);
1288 if (listener
->sk_err
)
1289 err
= -listener
->sk_err
;
1292 listener
->sk_ack_backlog
--;
1294 lock_sock(connected
);
1295 vconnected
= vsock_sk(connected
);
1297 /* If the listener socket has received an error, then we should
1298 * reject this socket and return. Note that we simply mark the
1299 * socket rejected, drop our reference, and let the cleanup
1300 * function handle the cleanup; the fact that we found it in
1301 * the listener's accept queue guarantees that the cleanup
1302 * function hasn't run yet.
1305 vconnected
->rejected
= true;
1306 release_sock(connected
);
1307 sock_put(connected
);
1311 newsock
->state
= SS_CONNECTED
;
1312 sock_graft(connected
, newsock
);
1313 release_sock(connected
);
1314 sock_put(connected
);
1318 finish_wait(sk_sleep(listener
), &wait
);
1320 release_sock(listener
);
1324 static int vsock_listen(struct socket
*sock
, int backlog
)
1328 struct vsock_sock
*vsk
;
1334 if (sock
->type
!= SOCK_STREAM
) {
1339 if (sock
->state
!= SS_UNCONNECTED
) {
1346 if (!vsock_addr_bound(&vsk
->local_addr
)) {
1351 sk
->sk_max_ack_backlog
= backlog
;
1352 sk
->sk_state
= SS_LISTEN
;
1361 static int vsock_stream_setsockopt(struct socket
*sock
,
1364 char __user
*optval
,
1365 unsigned int optlen
)
1369 struct vsock_sock
*vsk
;
1372 if (level
!= AF_VSOCK
)
1373 return -ENOPROTOOPT
;
1375 #define COPY_IN(_v) \
1377 if (optlen < sizeof(_v)) { \
1381 if (copy_from_user(&_v, optval, sizeof(_v)) != 0) { \
1394 case SO_VM_SOCKETS_BUFFER_SIZE
:
1396 transport
->set_buffer_size(vsk
, val
);
1399 case SO_VM_SOCKETS_BUFFER_MAX_SIZE
:
1401 transport
->set_max_buffer_size(vsk
, val
);
1404 case SO_VM_SOCKETS_BUFFER_MIN_SIZE
:
1406 transport
->set_min_buffer_size(vsk
, val
);
1409 case SO_VM_SOCKETS_CONNECT_TIMEOUT
: {
1412 if (tv
.tv_sec
>= 0 && tv
.tv_usec
< USEC_PER_SEC
&&
1413 tv
.tv_sec
< (MAX_SCHEDULE_TIMEOUT
/ HZ
- 1)) {
1414 vsk
->connect_timeout
= tv
.tv_sec
* HZ
+
1415 DIV_ROUND_UP(tv
.tv_usec
, (1000000 / HZ
));
1416 if (vsk
->connect_timeout
== 0)
1417 vsk
->connect_timeout
=
1418 VSOCK_DEFAULT_CONNECT_TIMEOUT
;
1438 static int vsock_stream_getsockopt(struct socket
*sock
,
1439 int level
, int optname
,
1440 char __user
*optval
,
1446 struct vsock_sock
*vsk
;
1449 if (level
!= AF_VSOCK
)
1450 return -ENOPROTOOPT
;
1452 err
= get_user(len
, optlen
);
1456 #define COPY_OUT(_v) \
1458 if (len < sizeof(_v)) \
1462 if (copy_to_user(optval, &_v, len) != 0) \
1472 case SO_VM_SOCKETS_BUFFER_SIZE
:
1473 val
= transport
->get_buffer_size(vsk
);
1477 case SO_VM_SOCKETS_BUFFER_MAX_SIZE
:
1478 val
= transport
->get_max_buffer_size(vsk
);
1482 case SO_VM_SOCKETS_BUFFER_MIN_SIZE
:
1483 val
= transport
->get_min_buffer_size(vsk
);
1487 case SO_VM_SOCKETS_CONNECT_TIMEOUT
: {
1489 tv
.tv_sec
= vsk
->connect_timeout
/ HZ
;
1491 (vsk
->connect_timeout
-
1492 tv
.tv_sec
* HZ
) * (1000000 / HZ
);
1497 return -ENOPROTOOPT
;
1500 err
= put_user(len
, optlen
);
1509 static int vsock_stream_sendmsg(struct kiocb
*kiocb
, struct socket
*sock
,
1510 struct msghdr
*msg
, size_t len
)
1513 struct vsock_sock
*vsk
;
1514 ssize_t total_written
;
1517 struct vsock_transport_send_notify_data send_data
;
1526 if (msg
->msg_flags
& MSG_OOB
)
1531 /* Callers should not provide a destination with stream sockets. */
1532 if (msg
->msg_namelen
) {
1533 err
= sk
->sk_state
== SS_CONNECTED
? -EISCONN
: -EOPNOTSUPP
;
1537 /* Send data only if both sides are not shutdown in the direction. */
1538 if (sk
->sk_shutdown
& SEND_SHUTDOWN
||
1539 vsk
->peer_shutdown
& RCV_SHUTDOWN
) {
1544 if (sk
->sk_state
!= SS_CONNECTED
||
1545 !vsock_addr_bound(&vsk
->local_addr
)) {
1550 if (!vsock_addr_bound(&vsk
->remote_addr
)) {
1551 err
= -EDESTADDRREQ
;
1555 /* Wait for room in the produce queue to enqueue our user's data. */
1556 timeout
= sock_sndtimeo(sk
, msg
->msg_flags
& MSG_DONTWAIT
);
1558 err
= transport
->notify_send_init(vsk
, &send_data
);
1562 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
1564 while (total_written
< len
) {
1567 while (vsock_stream_has_space(vsk
) == 0 &&
1569 !(sk
->sk_shutdown
& SEND_SHUTDOWN
) &&
1570 !(vsk
->peer_shutdown
& RCV_SHUTDOWN
)) {
1572 /* Don't wait for non-blocking sockets. */
1578 err
= transport
->notify_send_pre_block(vsk
, &send_data
);
1583 timeout
= schedule_timeout(timeout
);
1585 if (signal_pending(current
)) {
1586 err
= sock_intr_errno(timeout
);
1588 } else if (timeout
== 0) {
1593 prepare_to_wait(sk_sleep(sk
), &wait
,
1594 TASK_INTERRUPTIBLE
);
1597 /* These checks occur both as part of and after the loop
1598 * conditional since we need to check before and after
1604 } else if ((sk
->sk_shutdown
& SEND_SHUTDOWN
) ||
1605 (vsk
->peer_shutdown
& RCV_SHUTDOWN
)) {
1610 err
= transport
->notify_send_pre_enqueue(vsk
, &send_data
);
1614 /* Note that enqueue will only write as many bytes as are free
1615 * in the produce queue, so we don't need to ensure len is
1616 * smaller than the queue size. It is the caller's
1617 * responsibility to check how many bytes we were able to send.
1620 written
= transport
->stream_enqueue(
1622 len
- total_written
);
1628 total_written
+= written
;
1630 err
= transport
->notify_send_post_enqueue(
1631 vsk
, written
, &send_data
);
1638 if (total_written
> 0)
1639 err
= total_written
;
1640 finish_wait(sk_sleep(sk
), &wait
);
1648 vsock_stream_recvmsg(struct kiocb
*kiocb
,
1649 struct socket
*sock
,
1650 struct msghdr
*msg
, size_t len
, int flags
)
1653 struct vsock_sock
*vsk
;
1658 struct vsock_transport_recv_notify_data recv_data
;
1666 msg
->msg_namelen
= 0;
1670 if (sk
->sk_state
!= SS_CONNECTED
) {
1671 /* Recvmsg is supposed to return 0 if a peer performs an
1672 * orderly shutdown. Differentiate between that case and when a
1673 * peer has not connected or a local shutdown occured with the
1676 if (sock_flag(sk
, SOCK_DONE
))
1684 if (flags
& MSG_OOB
) {
1689 /* We don't check peer_shutdown flag here since peer may actually shut
1690 * down, but there can be data in the queue that a local socket can
1693 if (sk
->sk_shutdown
& RCV_SHUTDOWN
) {
1698 /* It is valid on Linux to pass in a zero-length receive buffer. This
1699 * is not an error. We may as well bail out now.
1706 /* We must not copy less than target bytes into the user's buffer
1707 * before returning successfully, so we wait for the consume queue to
1708 * have that much data to consume before dequeueing. Note that this
1709 * makes it impossible to handle cases where target is greater than the
1712 target
= sock_rcvlowat(sk
, flags
& MSG_WAITALL
, len
);
1713 if (target
>= transport
->stream_rcvhiwat(vsk
)) {
1717 timeout
= sock_rcvtimeo(sk
, flags
& MSG_DONTWAIT
);
1720 err
= transport
->notify_recv_init(vsk
, target
, &recv_data
);
1724 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
1727 s64 ready
= vsock_stream_has_data(vsk
);
1730 /* Invalid queue pair content. XXX This should be
1731 * changed to a connection reset in a later change.
1736 } else if (ready
> 0) {
1739 err
= transport
->notify_recv_pre_dequeue(
1740 vsk
, target
, &recv_data
);
1744 read
= transport
->stream_dequeue(
1746 len
- copied
, flags
);
1754 err
= transport
->notify_recv_post_dequeue(
1756 !(flags
& MSG_PEEK
), &recv_data
);
1760 if (read
>= target
|| flags
& MSG_PEEK
)
1765 if (sk
->sk_err
!= 0 || (sk
->sk_shutdown
& RCV_SHUTDOWN
)
1766 || (vsk
->peer_shutdown
& SEND_SHUTDOWN
)) {
1769 /* Don't wait for non-blocking sockets. */
1775 err
= transport
->notify_recv_pre_block(
1776 vsk
, target
, &recv_data
);
1781 timeout
= schedule_timeout(timeout
);
1784 if (signal_pending(current
)) {
1785 err
= sock_intr_errno(timeout
);
1787 } else if (timeout
== 0) {
1792 prepare_to_wait(sk_sleep(sk
), &wait
,
1793 TASK_INTERRUPTIBLE
);
1799 else if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
1803 /* We only do these additional bookkeeping/notification steps
1804 * if we actually copied something out of the queue pair
1805 * instead of just peeking ahead.
1808 if (!(flags
& MSG_PEEK
)) {
1809 /* If the other side has shutdown for sending and there
1810 * is nothing more to read, then modify the socket
1813 if (vsk
->peer_shutdown
& SEND_SHUTDOWN
) {
1814 if (vsock_stream_has_data(vsk
) <= 0) {
1815 sk
->sk_state
= SS_UNCONNECTED
;
1816 sock_set_flag(sk
, SOCK_DONE
);
1817 sk
->sk_state_change(sk
);
1825 finish_wait(sk_sleep(sk
), &wait
);
1831 static const struct proto_ops vsock_stream_ops
= {
1833 .owner
= THIS_MODULE
,
1834 .release
= vsock_release
,
1836 .connect
= vsock_stream_connect
,
1837 .socketpair
= sock_no_socketpair
,
1838 .accept
= vsock_accept
,
1839 .getname
= vsock_getname
,
1841 .ioctl
= sock_no_ioctl
,
1842 .listen
= vsock_listen
,
1843 .shutdown
= vsock_shutdown
,
1844 .setsockopt
= vsock_stream_setsockopt
,
1845 .getsockopt
= vsock_stream_getsockopt
,
1846 .sendmsg
= vsock_stream_sendmsg
,
1847 .recvmsg
= vsock_stream_recvmsg
,
1848 .mmap
= sock_no_mmap
,
1849 .sendpage
= sock_no_sendpage
,
1852 static int vsock_create(struct net
*net
, struct socket
*sock
,
1853 int protocol
, int kern
)
1858 if (protocol
&& protocol
!= PF_VSOCK
)
1859 return -EPROTONOSUPPORT
;
1861 switch (sock
->type
) {
1863 sock
->ops
= &vsock_dgram_ops
;
1866 sock
->ops
= &vsock_stream_ops
;
1869 return -ESOCKTNOSUPPORT
;
1872 sock
->state
= SS_UNCONNECTED
;
1874 return __vsock_create(net
, sock
, NULL
, GFP_KERNEL
, 0) ? 0 : -ENOMEM
;
1877 static const struct net_proto_family vsock_family_ops
= {
1879 .create
= vsock_create
,
1880 .owner
= THIS_MODULE
,
1883 static long vsock_dev_do_ioctl(struct file
*filp
,
1884 unsigned int cmd
, void __user
*ptr
)
1886 u32 __user
*p
= ptr
;
1890 case IOCTL_VM_SOCKETS_GET_LOCAL_CID
:
1891 if (put_user(transport
->get_local_cid(), p
) != 0)
1896 pr_err("Unknown ioctl %d\n", cmd
);
1903 static long vsock_dev_ioctl(struct file
*filp
,
1904 unsigned int cmd
, unsigned long arg
)
1906 return vsock_dev_do_ioctl(filp
, cmd
, (void __user
*)arg
);
1909 #ifdef CONFIG_COMPAT
1910 static long vsock_dev_compat_ioctl(struct file
*filp
,
1911 unsigned int cmd
, unsigned long arg
)
1913 return vsock_dev_do_ioctl(filp
, cmd
, compat_ptr(arg
));
1917 static const struct file_operations vsock_device_ops
= {
1918 .owner
= THIS_MODULE
,
1919 .unlocked_ioctl
= vsock_dev_ioctl
,
1920 #ifdef CONFIG_COMPAT
1921 .compat_ioctl
= vsock_dev_compat_ioctl
,
1923 .open
= nonseekable_open
,
1926 static struct miscdevice vsock_device
= {
1928 .fops
= &vsock_device_ops
,
1931 static int __vsock_core_init(void)
1935 vsock_init_tables();
1937 vsock_device
.minor
= MISC_DYNAMIC_MINOR
;
1938 err
= misc_register(&vsock_device
);
1940 pr_err("Failed to register misc device\n");
1944 err
= proto_register(&vsock_proto
, 1); /* we want our slab */
1946 pr_err("Cannot register vsock protocol\n");
1947 goto err_misc_deregister
;
1950 err
= sock_register(&vsock_family_ops
);
1952 pr_err("could not register af_vsock (%d) address family: %d\n",
1954 goto err_unregister_proto
;
1959 err_unregister_proto
:
1960 proto_unregister(&vsock_proto
);
1961 err_misc_deregister
:
1962 misc_deregister(&vsock_device
);
1966 int vsock_core_init(const struct vsock_transport
*t
)
1968 int retval
= mutex_lock_interruptible(&vsock_register_mutex
);
1978 retval
= __vsock_core_init();
1983 mutex_unlock(&vsock_register_mutex
);
1986 EXPORT_SYMBOL_GPL(vsock_core_init
);
1988 void vsock_core_exit(void)
1990 mutex_lock(&vsock_register_mutex
);
1992 misc_deregister(&vsock_device
);
1993 sock_unregister(AF_VSOCK
);
1994 proto_unregister(&vsock_proto
);
1996 /* We do not want the assignment below re-ordered. */
2000 mutex_unlock(&vsock_register_mutex
);
2002 EXPORT_SYMBOL_GPL(vsock_core_exit
);
2004 MODULE_AUTHOR("VMware, Inc.");
2005 MODULE_DESCRIPTION("VMware Virtual Socket Family");
2006 MODULE_VERSION("1.0.0.0-k");
2007 MODULE_LICENSE("GPL v2");