1685a6bf8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2d021c344SAndy King /* 3d021c344SAndy King * VMware vSockets Driver 4d021c344SAndy King * 5d021c344SAndy King * Copyright (C) 2007-2013 VMware, Inc. All rights reserved. 6d021c344SAndy King */ 7d021c344SAndy King 8d021c344SAndy King /* Implementation notes: 9d021c344SAndy King * 10d021c344SAndy King * - There are two kinds of sockets: those created by user action (such as 11d021c344SAndy King * calling socket(2)) and those created by incoming connection request packets. 12d021c344SAndy King * 13d021c344SAndy King * - There are two "global" tables, one for bound sockets (sockets that have 14d021c344SAndy King * specified an address that they are responsible for) and one for connected 15d021c344SAndy King * sockets (sockets that have established a connection with another socket). 16d021c344SAndy King * These tables are "global" in that all sockets on the system are placed 17d021c344SAndy King * within them. - Note, though, that the bound table contains an extra entry 18d021c344SAndy King * for a list of unbound sockets and SOCK_DGRAM sockets will always remain in 19d021c344SAndy King * that list. The bound table is used solely for lookup of sockets when packets 20d021c344SAndy King * are received and that's not necessary for SOCK_DGRAM sockets since we create 21d021c344SAndy King * a datagram handle for each and need not perform a lookup. Keeping SOCK_DGRAM 22d021c344SAndy King * sockets out of the bound hash buckets will reduce the chance of collisions 23d021c344SAndy King * when looking for SOCK_STREAM sockets and prevents us from having to check the 24d021c344SAndy King * socket type in the hash table lookups. 25d021c344SAndy King * 26d021c344SAndy King * - Sockets created by user action will either be "client" sockets that 27d021c344SAndy King * initiate a connection or "server" sockets that listen for connections; we do 28d021c344SAndy King * not support simultaneous connects (two "client" sockets connecting). 29d021c344SAndy King * 30d021c344SAndy King * - "Server" sockets are referred to as listener sockets throughout this 313b4477d2SStefan Hajnoczi * implementation because they are in the TCP_LISTEN state. When a 32ea3803c1SStefan Hajnoczi * connection request is received (the second kind of socket mentioned above), 33ea3803c1SStefan Hajnoczi * we create a new socket and refer to it as a pending socket. These pending 34ea3803c1SStefan Hajnoczi * sockets are placed on the pending connection list of the listener socket. 35ea3803c1SStefan Hajnoczi * When future packets are received for the address the listener socket is 36ea3803c1SStefan Hajnoczi * bound to, we check if the source of the packet is from one that has an 37ea3803c1SStefan Hajnoczi * existing pending connection. If it does, we process the packet for the 38ea3803c1SStefan Hajnoczi * pending socket. When that socket reaches the connected state, it is removed 39ea3803c1SStefan Hajnoczi * from the listener socket's pending list and enqueued in the listener 40ea3803c1SStefan Hajnoczi * socket's accept queue. Callers of accept(2) will accept connected sockets 41ea3803c1SStefan Hajnoczi * from the listener socket's accept queue. If the socket cannot be accepted 42ea3803c1SStefan Hajnoczi * for some reason then it is marked rejected. Once the connection is 43ea3803c1SStefan Hajnoczi * accepted, it is owned by the user process and the responsibility for cleanup 44ea3803c1SStefan Hajnoczi * falls with that user process. 45d021c344SAndy King * 46d021c344SAndy King * - It is possible that these pending sockets will never reach the connected 47d021c344SAndy King * state; in fact, we may never receive another packet after the connection 48d021c344SAndy King * request. Because of this, we must schedule a cleanup function to run in the 49d021c344SAndy King * future, after some amount of time passes where a connection should have been 50d021c344SAndy King * established. This function ensures that the socket is off all lists so it 51d021c344SAndy King * cannot be retrieved, then drops all references to the socket so it is cleaned 52d021c344SAndy King * up (sock_put() -> sk_free() -> our sk_destruct implementation). Note this 53d021c344SAndy King * function will also cleanup rejected sockets, those that reach the connected 54d021c344SAndy King * state but leave it before they have been accepted. 55d021c344SAndy King * 564192f672SStefan Hajnoczi * - Lock ordering for pending or accept queue sockets is: 574192f672SStefan Hajnoczi * 584192f672SStefan Hajnoczi * lock_sock(listener); 594192f672SStefan Hajnoczi * lock_sock_nested(pending, SINGLE_DEPTH_NESTING); 604192f672SStefan Hajnoczi * 614192f672SStefan Hajnoczi * Using explicit nested locking keeps lockdep happy since normally only one 624192f672SStefan Hajnoczi * lock of a given class may be taken at a time. 634192f672SStefan Hajnoczi * 64d021c344SAndy King * - Sockets created by user action will be cleaned up when the user process 65d021c344SAndy King * calls close(2), causing our release implementation to be called. Our release 66d021c344SAndy King * implementation will perform some cleanup then drop the last reference so our 67d021c344SAndy King * sk_destruct implementation is invoked. Our sk_destruct implementation will 68d021c344SAndy King * perform additional cleanup that's common for both types of sockets. 69d021c344SAndy King * 70d021c344SAndy King * - A socket's reference count is what ensures that the structure won't be 71d021c344SAndy King * freed. Each entry in a list (such as the "global" bound and connected tables 72d021c344SAndy King * and the listener socket's pending list and connected queue) ensures a 73d021c344SAndy King * reference. When we defer work until process context and pass a socket as our 74d021c344SAndy King * argument, we must ensure the reference count is increased to ensure the 75d021c344SAndy King * socket isn't freed before the function is run; the deferred function will 76d021c344SAndy King * then drop the reference. 773b4477d2SStefan Hajnoczi * 783b4477d2SStefan Hajnoczi * - sk->sk_state uses the TCP state constants because they are widely used by 793b4477d2SStefan Hajnoczi * other address families and exposed to userspace tools like ss(8): 803b4477d2SStefan Hajnoczi * 813b4477d2SStefan Hajnoczi * TCP_CLOSE - unconnected 823b4477d2SStefan Hajnoczi * TCP_SYN_SENT - connecting 833b4477d2SStefan Hajnoczi * TCP_ESTABLISHED - connected 843b4477d2SStefan Hajnoczi * TCP_CLOSING - disconnecting 853b4477d2SStefan Hajnoczi * TCP_LISTEN - listening 86d021c344SAndy King */ 87d021c344SAndy King 88d021c344SAndy King #include <linux/types.h> 89d021c344SAndy King #include <linux/bitops.h> 90d021c344SAndy King #include <linux/cred.h> 91d021c344SAndy King #include <linux/init.h> 92d021c344SAndy King #include <linux/io.h> 93d021c344SAndy King #include <linux/kernel.h> 94174cd4b1SIngo Molnar #include <linux/sched/signal.h> 95d021c344SAndy King #include <linux/kmod.h> 96d021c344SAndy King #include <linux/list.h> 97d021c344SAndy King #include <linux/miscdevice.h> 98d021c344SAndy King #include <linux/module.h> 99d021c344SAndy King #include <linux/mutex.h> 100d021c344SAndy King #include <linux/net.h> 101d021c344SAndy King #include <linux/poll.h> 1028236b08cSLepton Wu #include <linux/random.h> 103d021c344SAndy King #include <linux/skbuff.h> 104d021c344SAndy King #include <linux/smp.h> 105d021c344SAndy King #include <linux/socket.h> 106d021c344SAndy King #include <linux/stddef.h> 107d021c344SAndy King #include <linux/unistd.h> 108d021c344SAndy King #include <linux/wait.h> 109d021c344SAndy King #include <linux/workqueue.h> 110d021c344SAndy King #include <net/sock.h> 11182a54d0eSAsias He #include <net/af_vsock.h> 112d021c344SAndy King 113d021c344SAndy King static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr); 114d021c344SAndy King static void vsock_sk_destruct(struct sock *sk); 115d021c344SAndy King static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb); 116d021c344SAndy King 117d021c344SAndy King /* Protocol family. */ 118d021c344SAndy King static struct proto vsock_proto = { 119d021c344SAndy King .name = "AF_VSOCK", 120d021c344SAndy King .owner = THIS_MODULE, 121d021c344SAndy King .obj_size = sizeof(struct vsock_sock), 122d021c344SAndy King }; 123d021c344SAndy King 124d021c344SAndy King /* The default peer timeout indicates how long we will wait for a peer response 125d021c344SAndy King * to a control message. 126d021c344SAndy King */ 127d021c344SAndy King #define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ) 128d021c344SAndy King 129b9f2b0ffSStefano Garzarella #define VSOCK_DEFAULT_BUFFER_SIZE (1024 * 256) 130b9f2b0ffSStefano Garzarella #define VSOCK_DEFAULT_BUFFER_MAX_SIZE (1024 * 256) 131b9f2b0ffSStefano Garzarella #define VSOCK_DEFAULT_BUFFER_MIN_SIZE 128 132b9f2b0ffSStefano Garzarella 133c0cfa2d8SStefano Garzarella /* Transport used for host->guest communication */ 134c0cfa2d8SStefano Garzarella static const struct vsock_transport *transport_h2g; 135c0cfa2d8SStefano Garzarella /* Transport used for guest->host communication */ 136c0cfa2d8SStefano Garzarella static const struct vsock_transport *transport_g2h; 137c0cfa2d8SStefano Garzarella /* Transport used for DGRAM communication */ 138c0cfa2d8SStefano Garzarella static const struct vsock_transport *transport_dgram; 139*0e121905SStefano Garzarella /* Transport used for local communication */ 140*0e121905SStefano Garzarella static const struct vsock_transport *transport_local; 141d021c344SAndy King static DEFINE_MUTEX(vsock_register_mutex); 142d021c344SAndy King 143d021c344SAndy King /**** UTILS ****/ 144d021c344SAndy King 145d021c344SAndy King /* Each bound VSocket is stored in the bind hash table and each connected 146d021c344SAndy King * VSocket is stored in the connected hash table. 147d021c344SAndy King * 148d021c344SAndy King * Unbound sockets are all put on the same list attached to the end of the hash 149d021c344SAndy King * table (vsock_unbound_sockets). Bound sockets are added to the hash table in 150d021c344SAndy King * the bucket that their local address hashes to (vsock_bound_sockets(addr) 151d021c344SAndy King * represents the list that addr hashes to). 152d021c344SAndy King * 153d021c344SAndy King * Specifically, we initialize the vsock_bind_table array to a size of 154d021c344SAndy King * VSOCK_HASH_SIZE + 1 so that vsock_bind_table[0] through 155d021c344SAndy King * vsock_bind_table[VSOCK_HASH_SIZE - 1] are for bound sockets and 156d021c344SAndy King * vsock_bind_table[VSOCK_HASH_SIZE] is for unbound sockets. The hash function 157a49dd9dcSAsias He * mods with VSOCK_HASH_SIZE to ensure this. 158d021c344SAndy King */ 159d021c344SAndy King #define MAX_PORT_RETRIES 24 160d021c344SAndy King 161a49dd9dcSAsias He #define VSOCK_HASH(addr) ((addr)->svm_port % VSOCK_HASH_SIZE) 162d021c344SAndy King #define vsock_bound_sockets(addr) (&vsock_bind_table[VSOCK_HASH(addr)]) 163d021c344SAndy King #define vsock_unbound_sockets (&vsock_bind_table[VSOCK_HASH_SIZE]) 164d021c344SAndy King 165d021c344SAndy King /* XXX This can probably be implemented in a better way. */ 166d021c344SAndy King #define VSOCK_CONN_HASH(src, dst) \ 167a49dd9dcSAsias He (((src)->svm_cid ^ (dst)->svm_port) % VSOCK_HASH_SIZE) 168d021c344SAndy King #define vsock_connected_sockets(src, dst) \ 169d021c344SAndy King (&vsock_connected_table[VSOCK_CONN_HASH(src, dst)]) 170d021c344SAndy King #define vsock_connected_sockets_vsk(vsk) \ 171d021c344SAndy King vsock_connected_sockets(&(vsk)->remote_addr, &(vsk)->local_addr) 172d021c344SAndy King 17344f20980SStefan Hajnoczi struct list_head vsock_bind_table[VSOCK_HASH_SIZE + 1]; 17444f20980SStefan Hajnoczi EXPORT_SYMBOL_GPL(vsock_bind_table); 17544f20980SStefan Hajnoczi struct list_head vsock_connected_table[VSOCK_HASH_SIZE]; 17644f20980SStefan Hajnoczi EXPORT_SYMBOL_GPL(vsock_connected_table); 17744f20980SStefan Hajnoczi DEFINE_SPINLOCK(vsock_table_lock); 17844f20980SStefan Hajnoczi EXPORT_SYMBOL_GPL(vsock_table_lock); 179d021c344SAndy King 180b3a6dfe8SAsias He /* Autobind this socket to the local address if necessary. */ 181b3a6dfe8SAsias He static int vsock_auto_bind(struct vsock_sock *vsk) 182b3a6dfe8SAsias He { 183b3a6dfe8SAsias He struct sock *sk = sk_vsock(vsk); 184b3a6dfe8SAsias He struct sockaddr_vm local_addr; 185b3a6dfe8SAsias He 186b3a6dfe8SAsias He if (vsock_addr_bound(&vsk->local_addr)) 187b3a6dfe8SAsias He return 0; 188b3a6dfe8SAsias He vsock_addr_init(&local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); 189b3a6dfe8SAsias He return __vsock_bind(sk, &local_addr); 190b3a6dfe8SAsias He } 191b3a6dfe8SAsias He 192c0cfa2d8SStefano Garzarella static void vsock_init_tables(void) 193d021c344SAndy King { 194d021c344SAndy King int i; 195d021c344SAndy King 196d021c344SAndy King for (i = 0; i < ARRAY_SIZE(vsock_bind_table); i++) 197d021c344SAndy King INIT_LIST_HEAD(&vsock_bind_table[i]); 198d021c344SAndy King 199d021c344SAndy King for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++) 200d021c344SAndy King INIT_LIST_HEAD(&vsock_connected_table[i]); 201d021c344SAndy King } 202d021c344SAndy King 203d021c344SAndy King static void __vsock_insert_bound(struct list_head *list, 204d021c344SAndy King struct vsock_sock *vsk) 205d021c344SAndy King { 206d021c344SAndy King sock_hold(&vsk->sk); 207d021c344SAndy King list_add(&vsk->bound_table, list); 208d021c344SAndy King } 209d021c344SAndy King 210d021c344SAndy King static void __vsock_insert_connected(struct list_head *list, 211d021c344SAndy King struct vsock_sock *vsk) 212d021c344SAndy King { 213d021c344SAndy King sock_hold(&vsk->sk); 214d021c344SAndy King list_add(&vsk->connected_table, list); 215d021c344SAndy King } 216d021c344SAndy King 217d021c344SAndy King static void __vsock_remove_bound(struct vsock_sock *vsk) 218d021c344SAndy King { 219d021c344SAndy King list_del_init(&vsk->bound_table); 220d021c344SAndy King sock_put(&vsk->sk); 221d021c344SAndy King } 222d021c344SAndy King 223d021c344SAndy King static void __vsock_remove_connected(struct vsock_sock *vsk) 224d021c344SAndy King { 225d021c344SAndy King list_del_init(&vsk->connected_table); 226d021c344SAndy King sock_put(&vsk->sk); 227d021c344SAndy King } 228d021c344SAndy King 229d021c344SAndy King static struct sock *__vsock_find_bound_socket(struct sockaddr_vm *addr) 230d021c344SAndy King { 231d021c344SAndy King struct vsock_sock *vsk; 232d021c344SAndy King 23336c5b48bSStefano Garzarella list_for_each_entry(vsk, vsock_bound_sockets(addr), bound_table) { 23436c5b48bSStefano Garzarella if (vsock_addr_equals_addr(addr, &vsk->local_addr)) 235d021c344SAndy King return sk_vsock(vsk); 236d021c344SAndy King 23736c5b48bSStefano Garzarella if (addr->svm_port == vsk->local_addr.svm_port && 23836c5b48bSStefano Garzarella (vsk->local_addr.svm_cid == VMADDR_CID_ANY || 23936c5b48bSStefano Garzarella addr->svm_cid == VMADDR_CID_ANY)) 24036c5b48bSStefano Garzarella return sk_vsock(vsk); 24136c5b48bSStefano Garzarella } 24236c5b48bSStefano Garzarella 243d021c344SAndy King return NULL; 244d021c344SAndy King } 245d021c344SAndy King 246d021c344SAndy King static struct sock *__vsock_find_connected_socket(struct sockaddr_vm *src, 247d021c344SAndy King struct sockaddr_vm *dst) 248d021c344SAndy King { 249d021c344SAndy King struct vsock_sock *vsk; 250d021c344SAndy King 251d021c344SAndy King list_for_each_entry(vsk, vsock_connected_sockets(src, dst), 252d021c344SAndy King connected_table) { 253990454b5SReilly Grant if (vsock_addr_equals_addr(src, &vsk->remote_addr) && 254990454b5SReilly Grant dst->svm_port == vsk->local_addr.svm_port) { 255d021c344SAndy King return sk_vsock(vsk); 256d021c344SAndy King } 257d021c344SAndy King } 258d021c344SAndy King 259d021c344SAndy King return NULL; 260d021c344SAndy King } 261d021c344SAndy King 262d021c344SAndy King static void vsock_insert_unbound(struct vsock_sock *vsk) 263d021c344SAndy King { 264d021c344SAndy King spin_lock_bh(&vsock_table_lock); 265d021c344SAndy King __vsock_insert_bound(vsock_unbound_sockets, vsk); 266d021c344SAndy King spin_unlock_bh(&vsock_table_lock); 267d021c344SAndy King } 268d021c344SAndy King 269d021c344SAndy King void vsock_insert_connected(struct vsock_sock *vsk) 270d021c344SAndy King { 271d021c344SAndy King struct list_head *list = vsock_connected_sockets( 272d021c344SAndy King &vsk->remote_addr, &vsk->local_addr); 273d021c344SAndy King 274d021c344SAndy King spin_lock_bh(&vsock_table_lock); 275d021c344SAndy King __vsock_insert_connected(list, vsk); 276d021c344SAndy King spin_unlock_bh(&vsock_table_lock); 277d021c344SAndy King } 278d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_insert_connected); 279d021c344SAndy King 280d021c344SAndy King void vsock_remove_bound(struct vsock_sock *vsk) 281d021c344SAndy King { 282d021c344SAndy King spin_lock_bh(&vsock_table_lock); 283d5afa82cSSunil Muthuswamy if (__vsock_in_bound_table(vsk)) 284d021c344SAndy King __vsock_remove_bound(vsk); 285d021c344SAndy King spin_unlock_bh(&vsock_table_lock); 286d021c344SAndy King } 287d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_remove_bound); 288d021c344SAndy King 289d021c344SAndy King void vsock_remove_connected(struct vsock_sock *vsk) 290d021c344SAndy King { 291d021c344SAndy King spin_lock_bh(&vsock_table_lock); 292d5afa82cSSunil Muthuswamy if (__vsock_in_connected_table(vsk)) 293d021c344SAndy King __vsock_remove_connected(vsk); 294d021c344SAndy King spin_unlock_bh(&vsock_table_lock); 295d021c344SAndy King } 296d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_remove_connected); 297d021c344SAndy King 298d021c344SAndy King struct sock *vsock_find_bound_socket(struct sockaddr_vm *addr) 299d021c344SAndy King { 300d021c344SAndy King struct sock *sk; 301d021c344SAndy King 302d021c344SAndy King spin_lock_bh(&vsock_table_lock); 303d021c344SAndy King sk = __vsock_find_bound_socket(addr); 304d021c344SAndy King if (sk) 305d021c344SAndy King sock_hold(sk); 306d021c344SAndy King 307d021c344SAndy King spin_unlock_bh(&vsock_table_lock); 308d021c344SAndy King 309d021c344SAndy King return sk; 310d021c344SAndy King } 311d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_find_bound_socket); 312d021c344SAndy King 313d021c344SAndy King struct sock *vsock_find_connected_socket(struct sockaddr_vm *src, 314d021c344SAndy King struct sockaddr_vm *dst) 315d021c344SAndy King { 316d021c344SAndy King struct sock *sk; 317d021c344SAndy King 318d021c344SAndy King spin_lock_bh(&vsock_table_lock); 319d021c344SAndy King sk = __vsock_find_connected_socket(src, dst); 320d021c344SAndy King if (sk) 321d021c344SAndy King sock_hold(sk); 322d021c344SAndy King 323d021c344SAndy King spin_unlock_bh(&vsock_table_lock); 324d021c344SAndy King 325d021c344SAndy King return sk; 326d021c344SAndy King } 327d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_find_connected_socket); 328d021c344SAndy King 3296773b7dcSStefan Hajnoczi void vsock_remove_sock(struct vsock_sock *vsk) 3306773b7dcSStefan Hajnoczi { 3316773b7dcSStefan Hajnoczi vsock_remove_bound(vsk); 3326773b7dcSStefan Hajnoczi vsock_remove_connected(vsk); 3336773b7dcSStefan Hajnoczi } 3346773b7dcSStefan Hajnoczi EXPORT_SYMBOL_GPL(vsock_remove_sock); 3356773b7dcSStefan Hajnoczi 336d021c344SAndy King void vsock_for_each_connected_socket(void (*fn)(struct sock *sk)) 337d021c344SAndy King { 338d021c344SAndy King int i; 339d021c344SAndy King 340d021c344SAndy King spin_lock_bh(&vsock_table_lock); 341d021c344SAndy King 342d021c344SAndy King for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++) { 343d021c344SAndy King struct vsock_sock *vsk; 344d021c344SAndy King list_for_each_entry(vsk, &vsock_connected_table[i], 345d9af2d67SJulia Lawall connected_table) 346d021c344SAndy King fn(sk_vsock(vsk)); 347d021c344SAndy King } 348d021c344SAndy King 349d021c344SAndy King spin_unlock_bh(&vsock_table_lock); 350d021c344SAndy King } 351d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_for_each_connected_socket); 352d021c344SAndy King 353d021c344SAndy King void vsock_add_pending(struct sock *listener, struct sock *pending) 354d021c344SAndy King { 355d021c344SAndy King struct vsock_sock *vlistener; 356d021c344SAndy King struct vsock_sock *vpending; 357d021c344SAndy King 358d021c344SAndy King vlistener = vsock_sk(listener); 359d021c344SAndy King vpending = vsock_sk(pending); 360d021c344SAndy King 361d021c344SAndy King sock_hold(pending); 362d021c344SAndy King sock_hold(listener); 363d021c344SAndy King list_add_tail(&vpending->pending_links, &vlistener->pending_links); 364d021c344SAndy King } 365d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_add_pending); 366d021c344SAndy King 367d021c344SAndy King void vsock_remove_pending(struct sock *listener, struct sock *pending) 368d021c344SAndy King { 369d021c344SAndy King struct vsock_sock *vpending = vsock_sk(pending); 370d021c344SAndy King 371d021c344SAndy King list_del_init(&vpending->pending_links); 372d021c344SAndy King sock_put(listener); 373d021c344SAndy King sock_put(pending); 374d021c344SAndy King } 375d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_remove_pending); 376d021c344SAndy King 377d021c344SAndy King void vsock_enqueue_accept(struct sock *listener, struct sock *connected) 378d021c344SAndy King { 379d021c344SAndy King struct vsock_sock *vlistener; 380d021c344SAndy King struct vsock_sock *vconnected; 381d021c344SAndy King 382d021c344SAndy King vlistener = vsock_sk(listener); 383d021c344SAndy King vconnected = vsock_sk(connected); 384d021c344SAndy King 385d021c344SAndy King sock_hold(connected); 386d021c344SAndy King sock_hold(listener); 387d021c344SAndy King list_add_tail(&vconnected->accept_queue, &vlistener->accept_queue); 388d021c344SAndy King } 389d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_enqueue_accept); 390d021c344SAndy King 3916a2c0962SStefano Garzarella static void vsock_deassign_transport(struct vsock_sock *vsk) 3926a2c0962SStefano Garzarella { 3936a2c0962SStefano Garzarella if (!vsk->transport) 3946a2c0962SStefano Garzarella return; 3956a2c0962SStefano Garzarella 3966a2c0962SStefano Garzarella vsk->transport->destruct(vsk); 3976a2c0962SStefano Garzarella module_put(vsk->transport->module); 3986a2c0962SStefano Garzarella vsk->transport = NULL; 3996a2c0962SStefano Garzarella } 4006a2c0962SStefano Garzarella 401c0cfa2d8SStefano Garzarella /* Assign a transport to a socket and call the .init transport callback. 402c0cfa2d8SStefano Garzarella * 403c0cfa2d8SStefano Garzarella * Note: for stream socket this must be called when vsk->remote_addr is set 404c0cfa2d8SStefano Garzarella * (e.g. during the connect() or when a connection request on a listener 405c0cfa2d8SStefano Garzarella * socket is received). 406c0cfa2d8SStefano Garzarella * The vsk->remote_addr is used to decide which transport to use: 407c0cfa2d8SStefano Garzarella * - remote CID <= VMADDR_CID_HOST will use guest->host transport; 408c0cfa2d8SStefano Garzarella * - remote CID == local_cid (guest->host transport) will use guest->host 409c0cfa2d8SStefano Garzarella * transport for loopback (host->guest transports don't support loopback); 410c0cfa2d8SStefano Garzarella * - remote CID > VMADDR_CID_HOST will use host->guest transport; 411c0cfa2d8SStefano Garzarella */ 412c0cfa2d8SStefano Garzarella int vsock_assign_transport(struct vsock_sock *vsk, struct vsock_sock *psk) 413c0cfa2d8SStefano Garzarella { 414c0cfa2d8SStefano Garzarella const struct vsock_transport *new_transport; 415c0cfa2d8SStefano Garzarella struct sock *sk = sk_vsock(vsk); 416c0cfa2d8SStefano Garzarella unsigned int remote_cid = vsk->remote_addr.svm_cid; 417039fcccaSStefano Garzarella int ret; 418c0cfa2d8SStefano Garzarella 419c0cfa2d8SStefano Garzarella switch (sk->sk_type) { 420c0cfa2d8SStefano Garzarella case SOCK_DGRAM: 421c0cfa2d8SStefano Garzarella new_transport = transport_dgram; 422c0cfa2d8SStefano Garzarella break; 423c0cfa2d8SStefano Garzarella case SOCK_STREAM: 424c0cfa2d8SStefano Garzarella if (remote_cid <= VMADDR_CID_HOST || 425c0cfa2d8SStefano Garzarella (transport_g2h && 426c0cfa2d8SStefano Garzarella remote_cid == transport_g2h->get_local_cid())) 427c0cfa2d8SStefano Garzarella new_transport = transport_g2h; 428c0cfa2d8SStefano Garzarella else 429c0cfa2d8SStefano Garzarella new_transport = transport_h2g; 430c0cfa2d8SStefano Garzarella break; 431c0cfa2d8SStefano Garzarella default: 432c0cfa2d8SStefano Garzarella return -ESOCKTNOSUPPORT; 433c0cfa2d8SStefano Garzarella } 434c0cfa2d8SStefano Garzarella 435c0cfa2d8SStefano Garzarella if (vsk->transport) { 436c0cfa2d8SStefano Garzarella if (vsk->transport == new_transport) 437c0cfa2d8SStefano Garzarella return 0; 438c0cfa2d8SStefano Garzarella 439c0cfa2d8SStefano Garzarella vsk->transport->release(vsk); 4406a2c0962SStefano Garzarella vsock_deassign_transport(vsk); 441c0cfa2d8SStefano Garzarella } 442c0cfa2d8SStefano Garzarella 4436a2c0962SStefano Garzarella /* We increase the module refcnt to prevent the transport unloading 4446a2c0962SStefano Garzarella * while there are open sockets assigned to it. 4456a2c0962SStefano Garzarella */ 4466a2c0962SStefano Garzarella if (!new_transport || !try_module_get(new_transport->module)) 447c0cfa2d8SStefano Garzarella return -ENODEV; 448c0cfa2d8SStefano Garzarella 449039fcccaSStefano Garzarella ret = new_transport->init(vsk, psk); 450039fcccaSStefano Garzarella if (ret) { 451039fcccaSStefano Garzarella module_put(new_transport->module); 452039fcccaSStefano Garzarella return ret; 453039fcccaSStefano Garzarella } 454039fcccaSStefano Garzarella 455c0cfa2d8SStefano Garzarella vsk->transport = new_transport; 456c0cfa2d8SStefano Garzarella 457039fcccaSStefano Garzarella return 0; 458c0cfa2d8SStefano Garzarella } 459c0cfa2d8SStefano Garzarella EXPORT_SYMBOL_GPL(vsock_assign_transport); 460c0cfa2d8SStefano Garzarella 461c0cfa2d8SStefano Garzarella bool vsock_find_cid(unsigned int cid) 462c0cfa2d8SStefano Garzarella { 463c0cfa2d8SStefano Garzarella if (transport_g2h && cid == transport_g2h->get_local_cid()) 464c0cfa2d8SStefano Garzarella return true; 465c0cfa2d8SStefano Garzarella 466c0cfa2d8SStefano Garzarella if (transport_h2g && cid == VMADDR_CID_HOST) 467c0cfa2d8SStefano Garzarella return true; 468c0cfa2d8SStefano Garzarella 469c0cfa2d8SStefano Garzarella return false; 470c0cfa2d8SStefano Garzarella } 471c0cfa2d8SStefano Garzarella EXPORT_SYMBOL_GPL(vsock_find_cid); 472c0cfa2d8SStefano Garzarella 473d021c344SAndy King static struct sock *vsock_dequeue_accept(struct sock *listener) 474d021c344SAndy King { 475d021c344SAndy King struct vsock_sock *vlistener; 476d021c344SAndy King struct vsock_sock *vconnected; 477d021c344SAndy King 478d021c344SAndy King vlistener = vsock_sk(listener); 479d021c344SAndy King 480d021c344SAndy King if (list_empty(&vlistener->accept_queue)) 481d021c344SAndy King return NULL; 482d021c344SAndy King 483d021c344SAndy King vconnected = list_entry(vlistener->accept_queue.next, 484d021c344SAndy King struct vsock_sock, accept_queue); 485d021c344SAndy King 486d021c344SAndy King list_del_init(&vconnected->accept_queue); 487d021c344SAndy King sock_put(listener); 488d021c344SAndy King /* The caller will need a reference on the connected socket so we let 489d021c344SAndy King * it call sock_put(). 490d021c344SAndy King */ 491d021c344SAndy King 492d021c344SAndy King return sk_vsock(vconnected); 493d021c344SAndy King } 494d021c344SAndy King 495d021c344SAndy King static bool vsock_is_accept_queue_empty(struct sock *sk) 496d021c344SAndy King { 497d021c344SAndy King struct vsock_sock *vsk = vsock_sk(sk); 498d021c344SAndy King return list_empty(&vsk->accept_queue); 499d021c344SAndy King } 500d021c344SAndy King 501d021c344SAndy King static bool vsock_is_pending(struct sock *sk) 502d021c344SAndy King { 503d021c344SAndy King struct vsock_sock *vsk = vsock_sk(sk); 504d021c344SAndy King return !list_empty(&vsk->pending_links); 505d021c344SAndy King } 506d021c344SAndy King 507d021c344SAndy King static int vsock_send_shutdown(struct sock *sk, int mode) 508d021c344SAndy King { 509fe502c4aSStefano Garzarella struct vsock_sock *vsk = vsock_sk(sk); 510fe502c4aSStefano Garzarella 511c0cfa2d8SStefano Garzarella if (!vsk->transport) 512c0cfa2d8SStefano Garzarella return -ENODEV; 513c0cfa2d8SStefano Garzarella 514fe502c4aSStefano Garzarella return vsk->transport->shutdown(vsk, mode); 515d021c344SAndy King } 516d021c344SAndy King 517455f05ecSCong Wang static void vsock_pending_work(struct work_struct *work) 518d021c344SAndy King { 519d021c344SAndy King struct sock *sk; 520d021c344SAndy King struct sock *listener; 521d021c344SAndy King struct vsock_sock *vsk; 522d021c344SAndy King bool cleanup; 523d021c344SAndy King 524455f05ecSCong Wang vsk = container_of(work, struct vsock_sock, pending_work.work); 525d021c344SAndy King sk = sk_vsock(vsk); 526d021c344SAndy King listener = vsk->listener; 527d021c344SAndy King cleanup = true; 528d021c344SAndy King 529d021c344SAndy King lock_sock(listener); 5304192f672SStefan Hajnoczi lock_sock_nested(sk, SINGLE_DEPTH_NESTING); 531d021c344SAndy King 532d021c344SAndy King if (vsock_is_pending(sk)) { 533d021c344SAndy King vsock_remove_pending(listener, sk); 5341190cfdbSJorgen Hansen 5357976a11bSEric Dumazet sk_acceptq_removed(listener); 536d021c344SAndy King } else if (!vsk->rejected) { 537d021c344SAndy King /* We are not on the pending list and accept() did not reject 538d021c344SAndy King * us, so we must have been accepted by our user process. We 539d021c344SAndy King * just need to drop our references to the sockets and be on 540d021c344SAndy King * our way. 541d021c344SAndy King */ 542d021c344SAndy King cleanup = false; 543d021c344SAndy King goto out; 544d021c344SAndy King } 545d021c344SAndy King 546d021c344SAndy King /* We need to remove ourself from the global connected sockets list so 547d021c344SAndy King * incoming packets can't find this socket, and to reduce the reference 548d021c344SAndy King * count. 549d021c344SAndy King */ 550d021c344SAndy King vsock_remove_connected(vsk); 551d021c344SAndy King 5523b4477d2SStefan Hajnoczi sk->sk_state = TCP_CLOSE; 553d021c344SAndy King 554d021c344SAndy King out: 555d021c344SAndy King release_sock(sk); 556d021c344SAndy King release_sock(listener); 557d021c344SAndy King if (cleanup) 558d021c344SAndy King sock_put(sk); 559d021c344SAndy King 560d021c344SAndy King sock_put(sk); 561d021c344SAndy King sock_put(listener); 562d021c344SAndy King } 563d021c344SAndy King 564d021c344SAndy King /**** SOCKET OPERATIONS ****/ 565d021c344SAndy King 566d021c344SAndy King static int __vsock_bind_stream(struct vsock_sock *vsk, 567d021c344SAndy King struct sockaddr_vm *addr) 568d021c344SAndy King { 569a22d3251SLepton Wu static u32 port; 570d021c344SAndy King struct sockaddr_vm new_addr; 571d021c344SAndy King 5728236b08cSLepton Wu if (!port) 5738236b08cSLepton Wu port = LAST_RESERVED_PORT + 1 + 5748236b08cSLepton Wu prandom_u32_max(U32_MAX - LAST_RESERVED_PORT); 5758236b08cSLepton Wu 576d021c344SAndy King vsock_addr_init(&new_addr, addr->svm_cid, addr->svm_port); 577d021c344SAndy King 578d021c344SAndy King if (addr->svm_port == VMADDR_PORT_ANY) { 579d021c344SAndy King bool found = false; 580d021c344SAndy King unsigned int i; 581d021c344SAndy King 582d021c344SAndy King for (i = 0; i < MAX_PORT_RETRIES; i++) { 583d021c344SAndy King if (port <= LAST_RESERVED_PORT) 584d021c344SAndy King port = LAST_RESERVED_PORT + 1; 585d021c344SAndy King 586d021c344SAndy King new_addr.svm_port = port++; 587d021c344SAndy King 588d021c344SAndy King if (!__vsock_find_bound_socket(&new_addr)) { 589d021c344SAndy King found = true; 590d021c344SAndy King break; 591d021c344SAndy King } 592d021c344SAndy King } 593d021c344SAndy King 594d021c344SAndy King if (!found) 595d021c344SAndy King return -EADDRNOTAVAIL; 596d021c344SAndy King } else { 597d021c344SAndy King /* If port is in reserved range, ensure caller 598d021c344SAndy King * has necessary privileges. 599d021c344SAndy King */ 600d021c344SAndy King if (addr->svm_port <= LAST_RESERVED_PORT && 601d021c344SAndy King !capable(CAP_NET_BIND_SERVICE)) { 602d021c344SAndy King return -EACCES; 603d021c344SAndy King } 604d021c344SAndy King 605d021c344SAndy King if (__vsock_find_bound_socket(&new_addr)) 606d021c344SAndy King return -EADDRINUSE; 607d021c344SAndy King } 608d021c344SAndy King 609d021c344SAndy King vsock_addr_init(&vsk->local_addr, new_addr.svm_cid, new_addr.svm_port); 610d021c344SAndy King 611d021c344SAndy King /* Remove stream sockets from the unbound list and add them to the hash 612d021c344SAndy King * table for easy lookup by its address. The unbound list is simply an 613d021c344SAndy King * extra entry at the end of the hash table, a trick used by AF_UNIX. 614d021c344SAndy King */ 615d021c344SAndy King __vsock_remove_bound(vsk); 616d021c344SAndy King __vsock_insert_bound(vsock_bound_sockets(&vsk->local_addr), vsk); 617d021c344SAndy King 618d021c344SAndy King return 0; 619d021c344SAndy King } 620d021c344SAndy King 621d021c344SAndy King static int __vsock_bind_dgram(struct vsock_sock *vsk, 622d021c344SAndy King struct sockaddr_vm *addr) 623d021c344SAndy King { 624fe502c4aSStefano Garzarella return vsk->transport->dgram_bind(vsk, addr); 625d021c344SAndy King } 626d021c344SAndy King 627d021c344SAndy King static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr) 628d021c344SAndy King { 629d021c344SAndy King struct vsock_sock *vsk = vsock_sk(sk); 630d021c344SAndy King int retval; 631d021c344SAndy King 632d021c344SAndy King /* First ensure this socket isn't already bound. */ 633d021c344SAndy King if (vsock_addr_bound(&vsk->local_addr)) 634d021c344SAndy King return -EINVAL; 635d021c344SAndy King 636d021c344SAndy King /* Now bind to the provided address or select appropriate values if 637d021c344SAndy King * none are provided (VMADDR_CID_ANY and VMADDR_PORT_ANY). Note that 638d021c344SAndy King * like AF_INET prevents binding to a non-local IP address (in most 639c0cfa2d8SStefano Garzarella * cases), we only allow binding to a local CID. 640d021c344SAndy King */ 641c0cfa2d8SStefano Garzarella if (addr->svm_cid != VMADDR_CID_ANY && !vsock_find_cid(addr->svm_cid)) 642d021c344SAndy King return -EADDRNOTAVAIL; 643d021c344SAndy King 644d021c344SAndy King switch (sk->sk_socket->type) { 645d021c344SAndy King case SOCK_STREAM: 646d021c344SAndy King spin_lock_bh(&vsock_table_lock); 647d021c344SAndy King retval = __vsock_bind_stream(vsk, addr); 648d021c344SAndy King spin_unlock_bh(&vsock_table_lock); 649d021c344SAndy King break; 650d021c344SAndy King 651d021c344SAndy King case SOCK_DGRAM: 652d021c344SAndy King retval = __vsock_bind_dgram(vsk, addr); 653d021c344SAndy King break; 654d021c344SAndy King 655d021c344SAndy King default: 656d021c344SAndy King retval = -EINVAL; 657d021c344SAndy King break; 658d021c344SAndy King } 659d021c344SAndy King 660d021c344SAndy King return retval; 661d021c344SAndy King } 662d021c344SAndy King 663455f05ecSCong Wang static void vsock_connect_timeout(struct work_struct *work); 664455f05ecSCong Wang 665b9ca2f5fSStefano Garzarella static struct sock *__vsock_create(struct net *net, 666d021c344SAndy King struct socket *sock, 667d021c344SAndy King struct sock *parent, 668d021c344SAndy King gfp_t priority, 66911aa9c28SEric W. Biederman unsigned short type, 67011aa9c28SEric W. Biederman int kern) 671d021c344SAndy King { 672d021c344SAndy King struct sock *sk; 673d021c344SAndy King struct vsock_sock *psk; 674d021c344SAndy King struct vsock_sock *vsk; 675d021c344SAndy King 67611aa9c28SEric W. Biederman sk = sk_alloc(net, AF_VSOCK, priority, &vsock_proto, kern); 677d021c344SAndy King if (!sk) 678d021c344SAndy King return NULL; 679d021c344SAndy King 680d021c344SAndy King sock_init_data(sock, sk); 681d021c344SAndy King 682d021c344SAndy King /* sk->sk_type is normally set in sock_init_data, but only if sock is 683d021c344SAndy King * non-NULL. We make sure that our sockets always have a type by 684d021c344SAndy King * setting it here if needed. 685d021c344SAndy King */ 686d021c344SAndy King if (!sock) 687d021c344SAndy King sk->sk_type = type; 688d021c344SAndy King 689d021c344SAndy King vsk = vsock_sk(sk); 690d021c344SAndy King vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); 691d021c344SAndy King vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); 692d021c344SAndy King 693d021c344SAndy King sk->sk_destruct = vsock_sk_destruct; 694d021c344SAndy King sk->sk_backlog_rcv = vsock_queue_rcv_skb; 695d021c344SAndy King sock_reset_flag(sk, SOCK_DONE); 696d021c344SAndy King 697d021c344SAndy King INIT_LIST_HEAD(&vsk->bound_table); 698d021c344SAndy King INIT_LIST_HEAD(&vsk->connected_table); 699d021c344SAndy King vsk->listener = NULL; 700d021c344SAndy King INIT_LIST_HEAD(&vsk->pending_links); 701d021c344SAndy King INIT_LIST_HEAD(&vsk->accept_queue); 702d021c344SAndy King vsk->rejected = false; 703d021c344SAndy King vsk->sent_request = false; 704d021c344SAndy King vsk->ignore_connecting_rst = false; 705d021c344SAndy King vsk->peer_shutdown = 0; 706455f05ecSCong Wang INIT_DELAYED_WORK(&vsk->connect_work, vsock_connect_timeout); 707455f05ecSCong Wang INIT_DELAYED_WORK(&vsk->pending_work, vsock_pending_work); 708d021c344SAndy King 709d021c344SAndy King psk = parent ? vsock_sk(parent) : NULL; 710d021c344SAndy King if (parent) { 711d021c344SAndy King vsk->trusted = psk->trusted; 712d021c344SAndy King vsk->owner = get_cred(psk->owner); 713d021c344SAndy King vsk->connect_timeout = psk->connect_timeout; 714b9f2b0ffSStefano Garzarella vsk->buffer_size = psk->buffer_size; 715b9f2b0ffSStefano Garzarella vsk->buffer_min_size = psk->buffer_min_size; 716b9f2b0ffSStefano Garzarella vsk->buffer_max_size = psk->buffer_max_size; 717d021c344SAndy King } else { 718d021c344SAndy King vsk->trusted = capable(CAP_NET_ADMIN); 719d021c344SAndy King vsk->owner = get_current_cred(); 720d021c344SAndy King vsk->connect_timeout = VSOCK_DEFAULT_CONNECT_TIMEOUT; 721b9f2b0ffSStefano Garzarella vsk->buffer_size = VSOCK_DEFAULT_BUFFER_SIZE; 722b9f2b0ffSStefano Garzarella vsk->buffer_min_size = VSOCK_DEFAULT_BUFFER_MIN_SIZE; 723b9f2b0ffSStefano Garzarella vsk->buffer_max_size = VSOCK_DEFAULT_BUFFER_MAX_SIZE; 724d021c344SAndy King } 725d021c344SAndy King 726d021c344SAndy King return sk; 727d021c344SAndy King } 728d021c344SAndy King 7290d9138ffSDexuan Cui static void __vsock_release(struct sock *sk, int level) 730d021c344SAndy King { 731d021c344SAndy King if (sk) { 732d021c344SAndy King struct sock *pending; 733d021c344SAndy King struct vsock_sock *vsk; 734d021c344SAndy King 735d021c344SAndy King vsk = vsock_sk(sk); 736d021c344SAndy King pending = NULL; /* Compiler warning. */ 737d021c344SAndy King 7380d9138ffSDexuan Cui /* The release call is supposed to use lock_sock_nested() 7390d9138ffSDexuan Cui * rather than lock_sock(), if a sock lock should be acquired. 7400d9138ffSDexuan Cui */ 741c0cfa2d8SStefano Garzarella if (vsk->transport) 742fe502c4aSStefano Garzarella vsk->transport->release(vsk); 743c0cfa2d8SStefano Garzarella else if (sk->sk_type == SOCK_STREAM) 744c0cfa2d8SStefano Garzarella vsock_remove_sock(vsk); 745d021c344SAndy King 7460d9138ffSDexuan Cui /* When "level" is SINGLE_DEPTH_NESTING, use the nested 7470d9138ffSDexuan Cui * version to avoid the warning "possible recursive locking 7480d9138ffSDexuan Cui * detected". When "level" is 0, lock_sock_nested(sk, level) 7490d9138ffSDexuan Cui * is the same as lock_sock(sk). 7500d9138ffSDexuan Cui */ 7510d9138ffSDexuan Cui lock_sock_nested(sk, level); 752d021c344SAndy King sock_orphan(sk); 753d021c344SAndy King sk->sk_shutdown = SHUTDOWN_MASK; 754d021c344SAndy King 7553b7ad08bSChristophe JAILLET skb_queue_purge(&sk->sk_receive_queue); 756d021c344SAndy King 757d021c344SAndy King /* Clean up any sockets that never were accepted. */ 758d021c344SAndy King while ((pending = vsock_dequeue_accept(sk)) != NULL) { 7590d9138ffSDexuan Cui __vsock_release(pending, SINGLE_DEPTH_NESTING); 760d021c344SAndy King sock_put(pending); 761d021c344SAndy King } 762d021c344SAndy King 763d021c344SAndy King release_sock(sk); 764d021c344SAndy King sock_put(sk); 765d021c344SAndy King } 766d021c344SAndy King } 767d021c344SAndy King 768d021c344SAndy King static void vsock_sk_destruct(struct sock *sk) 769d021c344SAndy King { 770d021c344SAndy King struct vsock_sock *vsk = vsock_sk(sk); 771d021c344SAndy King 7726a2c0962SStefano Garzarella vsock_deassign_transport(vsk); 773d021c344SAndy King 774d021c344SAndy King /* When clearing these addresses, there's no need to set the family and 775d021c344SAndy King * possibly register the address family with the kernel. 776d021c344SAndy King */ 777d021c344SAndy King vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); 778d021c344SAndy King vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY); 779d021c344SAndy King 780d021c344SAndy King put_cred(vsk->owner); 781d021c344SAndy King } 782d021c344SAndy King 783d021c344SAndy King static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) 784d021c344SAndy King { 785d021c344SAndy King int err; 786d021c344SAndy King 787d021c344SAndy King err = sock_queue_rcv_skb(sk, skb); 788d021c344SAndy King if (err) 789d021c344SAndy King kfree_skb(skb); 790d021c344SAndy King 791d021c344SAndy King return err; 792d021c344SAndy King } 793d021c344SAndy King 794b9ca2f5fSStefano Garzarella struct sock *vsock_create_connected(struct sock *parent) 795b9ca2f5fSStefano Garzarella { 796b9ca2f5fSStefano Garzarella return __vsock_create(sock_net(parent), NULL, parent, GFP_KERNEL, 797b9ca2f5fSStefano Garzarella parent->sk_type, 0); 798b9ca2f5fSStefano Garzarella } 799b9ca2f5fSStefano Garzarella EXPORT_SYMBOL_GPL(vsock_create_connected); 800b9ca2f5fSStefano Garzarella 801d021c344SAndy King s64 vsock_stream_has_data(struct vsock_sock *vsk) 802d021c344SAndy King { 803fe502c4aSStefano Garzarella return vsk->transport->stream_has_data(vsk); 804d021c344SAndy King } 805d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_stream_has_data); 806d021c344SAndy King 807d021c344SAndy King s64 vsock_stream_has_space(struct vsock_sock *vsk) 808d021c344SAndy King { 809fe502c4aSStefano Garzarella return vsk->transport->stream_has_space(vsk); 810d021c344SAndy King } 811d021c344SAndy King EXPORT_SYMBOL_GPL(vsock_stream_has_space); 812d021c344SAndy King 813d021c344SAndy King static int vsock_release(struct socket *sock) 814d021c344SAndy King { 8150d9138ffSDexuan Cui __vsock_release(sock->sk, 0); 816d021c344SAndy King sock->sk = NULL; 817d021c344SAndy King sock->state = SS_FREE; 818d021c344SAndy King 819d021c344SAndy King return 0; 820d021c344SAndy King } 821d021c344SAndy King 822d021c344SAndy King static int 823d021c344SAndy King vsock_bind(struct socket *sock, struct sockaddr *addr, int addr_len) 824d021c344SAndy King { 825d021c344SAndy King int err; 826d021c344SAndy King struct sock *sk; 827d021c344SAndy King struct sockaddr_vm *vm_addr; 828d021c344SAndy King 829d021c344SAndy King sk = sock->sk; 830d021c344SAndy King 831d021c344SAndy King if (vsock_addr_cast(addr, addr_len, &vm_addr) != 0) 832d021c344SAndy King return -EINVAL; 833d021c344SAndy King 834d021c344SAndy King lock_sock(sk); 835d021c344SAndy King err = __vsock_bind(sk, vm_addr); 836d021c344SAndy King release_sock(sk); 837d021c344SAndy King 838d021c344SAndy King return err; 839d021c344SAndy King } 840d021c344SAndy King 841d021c344SAndy King static int vsock_getname(struct socket *sock, 8429b2c45d4SDenys Vlasenko struct sockaddr *addr, int peer) 843d021c344SAndy King { 844d021c344SAndy King int err; 845d021c344SAndy King struct sock *sk; 846d021c344SAndy King struct vsock_sock *vsk; 847d021c344SAndy King struct sockaddr_vm *vm_addr; 848d021c344SAndy King 849d021c344SAndy King sk = sock->sk; 850d021c344SAndy King vsk = vsock_sk(sk); 851d021c344SAndy King err = 0; 852d021c344SAndy King 853d021c344SAndy King lock_sock(sk); 854d021c344SAndy King 855d021c344SAndy King if (peer) { 856d021c344SAndy King if (sock->state != SS_CONNECTED) { 857d021c344SAndy King err = -ENOTCONN; 858d021c344SAndy King goto out; 859d021c344SAndy King } 860d021c344SAndy King vm_addr = &vsk->remote_addr; 861d021c344SAndy King } else { 862d021c344SAndy King vm_addr = &vsk->local_addr; 863d021c344SAndy King } 864d021c344SAndy King 865d021c344SAndy King if (!vm_addr) { 866d021c344SAndy King err = -EINVAL; 867d021c344SAndy King goto out; 868d021c344SAndy King } 869d021c344SAndy King 870d021c344SAndy King /* sys_getsockname() and sys_getpeername() pass us a 871d021c344SAndy King * MAX_SOCK_ADDR-sized buffer and don't set addr_len. Unfortunately 872d021c344SAndy King * that macro is defined in socket.c instead of .h, so we hardcode its 873d021c344SAndy King * value here. 874d021c344SAndy King */ 875d021c344SAndy King BUILD_BUG_ON(sizeof(*vm_addr) > 128); 876d021c344SAndy King memcpy(addr, vm_addr, sizeof(*vm_addr)); 8779b2c45d4SDenys Vlasenko err = sizeof(*vm_addr); 878d021c344SAndy King 879d021c344SAndy King out: 880d021c344SAndy King release_sock(sk); 881d021c344SAndy King return err; 882d021c344SAndy King } 883d021c344SAndy King 884d021c344SAndy King static int vsock_shutdown(struct socket *sock, int mode) 885d021c344SAndy King { 886d021c344SAndy King int err; 887d021c344SAndy King struct sock *sk; 888d021c344SAndy King 889d021c344SAndy King /* User level uses SHUT_RD (0) and SHUT_WR (1), but the kernel uses 890d021c344SAndy King * RCV_SHUTDOWN (1) and SEND_SHUTDOWN (2), so we must increment mode 891d021c344SAndy King * here like the other address families do. Note also that the 892d021c344SAndy King * increment makes SHUT_RDWR (2) into RCV_SHUTDOWN | SEND_SHUTDOWN (3), 893d021c344SAndy King * which is what we want. 894d021c344SAndy King */ 895d021c344SAndy King mode++; 896d021c344SAndy King 897d021c344SAndy King if ((mode & ~SHUTDOWN_MASK) || !mode) 898d021c344SAndy King return -EINVAL; 899d021c344SAndy King 900d021c344SAndy King /* If this is a STREAM socket and it is not connected then bail out 901d021c344SAndy King * immediately. If it is a DGRAM socket then we must first kick the 902d021c344SAndy King * socket so that it wakes up from any sleeping calls, for example 903d021c344SAndy King * recv(), and then afterwards return the error. 904d021c344SAndy King */ 905d021c344SAndy King 906d021c344SAndy King sk = sock->sk; 907d021c344SAndy King if (sock->state == SS_UNCONNECTED) { 908d021c344SAndy King err = -ENOTCONN; 909d021c344SAndy King if (sk->sk_type == SOCK_STREAM) 910d021c344SAndy King return err; 911d021c344SAndy King } else { 912d021c344SAndy King sock->state = SS_DISCONNECTING; 913d021c344SAndy King err = 0; 914d021c344SAndy King } 915d021c344SAndy King 916d021c344SAndy King /* Receive and send shutdowns are treated alike. */ 917d021c344SAndy King mode = mode & (RCV_SHUTDOWN | SEND_SHUTDOWN); 918d021c344SAndy King if (mode) { 919d021c344SAndy King lock_sock(sk); 920d021c344SAndy King sk->sk_shutdown |= mode; 921d021c344SAndy King sk->sk_state_change(sk); 922d021c344SAndy King release_sock(sk); 923d021c344SAndy King 924d021c344SAndy King if (sk->sk_type == SOCK_STREAM) { 925d021c344SAndy King sock_reset_flag(sk, SOCK_DONE); 926d021c344SAndy King vsock_send_shutdown(sk, mode); 927d021c344SAndy King } 928d021c344SAndy King } 929d021c344SAndy King 930d021c344SAndy King return err; 931d021c344SAndy King } 932d021c344SAndy King 933a11e1d43SLinus Torvalds static __poll_t vsock_poll(struct file *file, struct socket *sock, 934a11e1d43SLinus Torvalds poll_table *wait) 935d021c344SAndy King { 936a11e1d43SLinus Torvalds struct sock *sk; 937a11e1d43SLinus Torvalds __poll_t mask; 938a11e1d43SLinus Torvalds struct vsock_sock *vsk; 939a11e1d43SLinus Torvalds 940a11e1d43SLinus Torvalds sk = sock->sk; 941a11e1d43SLinus Torvalds vsk = vsock_sk(sk); 942a11e1d43SLinus Torvalds 943a11e1d43SLinus Torvalds poll_wait(file, sk_sleep(sk), wait); 944a11e1d43SLinus Torvalds mask = 0; 945d021c344SAndy King 946d021c344SAndy King if (sk->sk_err) 947d021c344SAndy King /* Signify that there has been an error on this socket. */ 948a9a08845SLinus Torvalds mask |= EPOLLERR; 949d021c344SAndy King 950d021c344SAndy King /* INET sockets treat local write shutdown and peer write shutdown as a 951a9a08845SLinus Torvalds * case of EPOLLHUP set. 952d021c344SAndy King */ 953d021c344SAndy King if ((sk->sk_shutdown == SHUTDOWN_MASK) || 954d021c344SAndy King ((sk->sk_shutdown & SEND_SHUTDOWN) && 955d021c344SAndy King (vsk->peer_shutdown & SEND_SHUTDOWN))) { 956a9a08845SLinus Torvalds mask |= EPOLLHUP; 957d021c344SAndy King } 958d021c344SAndy King 959d021c344SAndy King if (sk->sk_shutdown & RCV_SHUTDOWN || 960d021c344SAndy King vsk->peer_shutdown & SEND_SHUTDOWN) { 961a9a08845SLinus Torvalds mask |= EPOLLRDHUP; 962d021c344SAndy King } 963d021c344SAndy King 964d021c344SAndy King if (sock->type == SOCK_DGRAM) { 965d021c344SAndy King /* For datagram sockets we can read if there is something in 966d021c344SAndy King * the queue and write as long as the socket isn't shutdown for 967d021c344SAndy King * sending. 968d021c344SAndy King */ 9693ef7cf57SEric Dumazet if (!skb_queue_empty_lockless(&sk->sk_receive_queue) || 970d021c344SAndy King (sk->sk_shutdown & RCV_SHUTDOWN)) { 971a9a08845SLinus Torvalds mask |= EPOLLIN | EPOLLRDNORM; 972d021c344SAndy King } 973d021c344SAndy King 974d021c344SAndy King if (!(sk->sk_shutdown & SEND_SHUTDOWN)) 975a9a08845SLinus Torvalds mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND; 976d021c344SAndy King 977d021c344SAndy King } else if (sock->type == SOCK_STREAM) { 978fe502c4aSStefano Garzarella const struct vsock_transport *transport = vsk->transport; 979d021c344SAndy King lock_sock(sk); 980d021c344SAndy King 981d021c344SAndy King /* Listening sockets that have connections in their accept 982d021c344SAndy King * queue can be read. 983d021c344SAndy King */ 9843b4477d2SStefan Hajnoczi if (sk->sk_state == TCP_LISTEN 985d021c344SAndy King && !vsock_is_accept_queue_empty(sk)) 986a9a08845SLinus Torvalds mask |= EPOLLIN | EPOLLRDNORM; 987d021c344SAndy King 988d021c344SAndy King /* If there is something in the queue then we can read. */ 989c0cfa2d8SStefano Garzarella if (transport && transport->stream_is_active(vsk) && 990d021c344SAndy King !(sk->sk_shutdown & RCV_SHUTDOWN)) { 991d021c344SAndy King bool data_ready_now = false; 992d021c344SAndy King int ret = transport->notify_poll_in( 993d021c344SAndy King vsk, 1, &data_ready_now); 994d021c344SAndy King if (ret < 0) { 995a9a08845SLinus Torvalds mask |= EPOLLERR; 996d021c344SAndy King } else { 997d021c344SAndy King if (data_ready_now) 998a9a08845SLinus Torvalds mask |= EPOLLIN | EPOLLRDNORM; 999d021c344SAndy King 1000d021c344SAndy King } 1001d021c344SAndy King } 1002d021c344SAndy King 1003d021c344SAndy King /* Sockets whose connections have been closed, reset, or 1004d021c344SAndy King * terminated should also be considered read, and we check the 1005d021c344SAndy King * shutdown flag for that. 1006d021c344SAndy King */ 1007d021c344SAndy King if (sk->sk_shutdown & RCV_SHUTDOWN || 1008d021c344SAndy King vsk->peer_shutdown & SEND_SHUTDOWN) { 1009a9a08845SLinus Torvalds mask |= EPOLLIN | EPOLLRDNORM; 1010d021c344SAndy King } 1011d021c344SAndy King 1012d021c344SAndy King /* Connected sockets that can produce data can be written. */ 10133b4477d2SStefan Hajnoczi if (sk->sk_state == TCP_ESTABLISHED) { 1014d021c344SAndy King if (!(sk->sk_shutdown & SEND_SHUTDOWN)) { 1015d021c344SAndy King bool space_avail_now = false; 1016d021c344SAndy King int ret = transport->notify_poll_out( 1017d021c344SAndy King vsk, 1, &space_avail_now); 1018d021c344SAndy King if (ret < 0) { 1019a9a08845SLinus Torvalds mask |= EPOLLERR; 1020d021c344SAndy King } else { 1021d021c344SAndy King if (space_avail_now) 1022a9a08845SLinus Torvalds /* Remove EPOLLWRBAND since INET 1023d021c344SAndy King * sockets are not setting it. 1024d021c344SAndy King */ 1025a9a08845SLinus Torvalds mask |= EPOLLOUT | EPOLLWRNORM; 1026d021c344SAndy King 1027d021c344SAndy King } 1028d021c344SAndy King } 1029d021c344SAndy King } 1030d021c344SAndy King 1031d021c344SAndy King /* Simulate INET socket poll behaviors, which sets 1032a9a08845SLinus Torvalds * EPOLLOUT|EPOLLWRNORM when peer is closed and nothing to read, 1033d021c344SAndy King * but local send is not shutdown. 1034d021c344SAndy King */ 1035ba3169fcSStefan Hajnoczi if (sk->sk_state == TCP_CLOSE || sk->sk_state == TCP_CLOSING) { 1036d021c344SAndy King if (!(sk->sk_shutdown & SEND_SHUTDOWN)) 1037a9a08845SLinus Torvalds mask |= EPOLLOUT | EPOLLWRNORM; 1038d021c344SAndy King 1039d021c344SAndy King } 1040d021c344SAndy King 1041d021c344SAndy King release_sock(sk); 1042d021c344SAndy King } 1043d021c344SAndy King 1044d021c344SAndy King return mask; 1045d021c344SAndy King } 1046d021c344SAndy King 10471b784140SYing Xue static int vsock_dgram_sendmsg(struct socket *sock, struct msghdr *msg, 10481b784140SYing Xue size_t len) 1049d021c344SAndy King { 1050d021c344SAndy King int err; 1051d021c344SAndy King struct sock *sk; 1052d021c344SAndy King struct vsock_sock *vsk; 1053d021c344SAndy King struct sockaddr_vm *remote_addr; 1054fe502c4aSStefano Garzarella const struct vsock_transport *transport; 1055d021c344SAndy King 1056d021c344SAndy King if (msg->msg_flags & MSG_OOB) 1057d021c344SAndy King return -EOPNOTSUPP; 1058d021c344SAndy King 1059d021c344SAndy King /* For now, MSG_DONTWAIT is always assumed... */ 1060d021c344SAndy King err = 0; 1061d021c344SAndy King sk = sock->sk; 1062d021c344SAndy King vsk = vsock_sk(sk); 1063fe502c4aSStefano Garzarella transport = vsk->transport; 1064d021c344SAndy King 1065d021c344SAndy King lock_sock(sk); 1066d021c344SAndy King 1067b3a6dfe8SAsias He err = vsock_auto_bind(vsk); 1068b3a6dfe8SAsias He if (err) 1069d021c344SAndy King goto out; 1070d021c344SAndy King 1071d021c344SAndy King 1072d021c344SAndy King /* If the provided message contains an address, use that. Otherwise 1073d021c344SAndy King * fall back on the socket's remote handle (if it has been connected). 1074d021c344SAndy King */ 1075d021c344SAndy King if (msg->msg_name && 1076d021c344SAndy King vsock_addr_cast(msg->msg_name, msg->msg_namelen, 1077d021c344SAndy King &remote_addr) == 0) { 1078d021c344SAndy King /* Ensure this address is of the right type and is a valid 1079d021c344SAndy King * destination. 1080d021c344SAndy King */ 1081d021c344SAndy King 1082d021c344SAndy King if (remote_addr->svm_cid == VMADDR_CID_ANY) 1083d021c344SAndy King remote_addr->svm_cid = transport->get_local_cid(); 1084d021c344SAndy King 1085d021c344SAndy King if (!vsock_addr_bound(remote_addr)) { 1086d021c344SAndy King err = -EINVAL; 1087d021c344SAndy King goto out; 1088d021c344SAndy King } 1089d021c344SAndy King } else if (sock->state == SS_CONNECTED) { 1090d021c344SAndy King remote_addr = &vsk->remote_addr; 1091d021c344SAndy King 1092d021c344SAndy King if (remote_addr->svm_cid == VMADDR_CID_ANY) 1093d021c344SAndy King remote_addr->svm_cid = transport->get_local_cid(); 1094d021c344SAndy King 1095d021c344SAndy King /* XXX Should connect() or this function ensure remote_addr is 1096d021c344SAndy King * bound? 1097d021c344SAndy King */ 1098d021c344SAndy King if (!vsock_addr_bound(&vsk->remote_addr)) { 1099d021c344SAndy King err = -EINVAL; 1100d021c344SAndy King goto out; 1101d021c344SAndy King } 1102d021c344SAndy King } else { 1103d021c344SAndy King err = -EINVAL; 1104d021c344SAndy King goto out; 1105d021c344SAndy King } 1106d021c344SAndy King 1107d021c344SAndy King if (!transport->dgram_allow(remote_addr->svm_cid, 1108d021c344SAndy King remote_addr->svm_port)) { 1109d021c344SAndy King err = -EINVAL; 1110d021c344SAndy King goto out; 1111d021c344SAndy King } 1112d021c344SAndy King 11130f7db23aSAl Viro err = transport->dgram_enqueue(vsk, remote_addr, msg, len); 1114d021c344SAndy King 1115d021c344SAndy King out: 1116d021c344SAndy King release_sock(sk); 1117d021c344SAndy King return err; 1118d021c344SAndy King } 1119d021c344SAndy King 1120d021c344SAndy King static int vsock_dgram_connect(struct socket *sock, 1121d021c344SAndy King struct sockaddr *addr, int addr_len, int flags) 1122d021c344SAndy King { 1123d021c344SAndy King int err; 1124d021c344SAndy King struct sock *sk; 1125d021c344SAndy King struct vsock_sock *vsk; 1126d021c344SAndy King struct sockaddr_vm *remote_addr; 1127d021c344SAndy King 1128d021c344SAndy King sk = sock->sk; 1129d021c344SAndy King vsk = vsock_sk(sk); 1130d021c344SAndy King 1131d021c344SAndy King err = vsock_addr_cast(addr, addr_len, &remote_addr); 1132d021c344SAndy King if (err == -EAFNOSUPPORT && remote_addr->svm_family == AF_UNSPEC) { 1133d021c344SAndy King lock_sock(sk); 1134d021c344SAndy King vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, 1135d021c344SAndy King VMADDR_PORT_ANY); 1136d021c344SAndy King sock->state = SS_UNCONNECTED; 1137d021c344SAndy King release_sock(sk); 1138d021c344SAndy King return 0; 1139d021c344SAndy King } else if (err != 0) 1140d021c344SAndy King return -EINVAL; 1141d021c344SAndy King 1142d021c344SAndy King lock_sock(sk); 1143d021c344SAndy King 1144b3a6dfe8SAsias He err = vsock_auto_bind(vsk); 1145b3a6dfe8SAsias He if (err) 1146d021c344SAndy King goto out; 1147d021c344SAndy King 1148fe502c4aSStefano Garzarella if (!vsk->transport->dgram_allow(remote_addr->svm_cid, 1149d021c344SAndy King remote_addr->svm_port)) { 1150d021c344SAndy King err = -EINVAL; 1151d021c344SAndy King goto out; 1152d021c344SAndy King } 1153d021c344SAndy King 1154d021c344SAndy King memcpy(&vsk->remote_addr, remote_addr, sizeof(vsk->remote_addr)); 1155d021c344SAndy King sock->state = SS_CONNECTED; 1156d021c344SAndy King 1157d021c344SAndy King out: 1158d021c344SAndy King release_sock(sk); 1159d021c344SAndy King return err; 1160d021c344SAndy King } 1161d021c344SAndy King 11621b784140SYing Xue static int vsock_dgram_recvmsg(struct socket *sock, struct msghdr *msg, 11631b784140SYing Xue size_t len, int flags) 1164d021c344SAndy King { 1165fe502c4aSStefano Garzarella struct vsock_sock *vsk = vsock_sk(sock->sk); 1166fe502c4aSStefano Garzarella 1167fe502c4aSStefano Garzarella return vsk->transport->dgram_dequeue(vsk, msg, len, flags); 1168d021c344SAndy King } 1169d021c344SAndy King 1170d021c344SAndy King static const struct proto_ops vsock_dgram_ops = { 1171d021c344SAndy King .family = PF_VSOCK, 1172d021c344SAndy King .owner = THIS_MODULE, 1173d021c344SAndy King .release = vsock_release, 1174d021c344SAndy King .bind = vsock_bind, 1175d021c344SAndy King .connect = vsock_dgram_connect, 1176d021c344SAndy King .socketpair = sock_no_socketpair, 1177d021c344SAndy King .accept = sock_no_accept, 1178d021c344SAndy King .getname = vsock_getname, 1179a11e1d43SLinus Torvalds .poll = vsock_poll, 1180d021c344SAndy King .ioctl = sock_no_ioctl, 1181d021c344SAndy King .listen = sock_no_listen, 1182d021c344SAndy King .shutdown = vsock_shutdown, 1183d021c344SAndy King .setsockopt = sock_no_setsockopt, 1184d021c344SAndy King .getsockopt = sock_no_getsockopt, 1185d021c344SAndy King .sendmsg = vsock_dgram_sendmsg, 1186d021c344SAndy King .recvmsg = vsock_dgram_recvmsg, 1187d021c344SAndy King .mmap = sock_no_mmap, 1188d021c344SAndy King .sendpage = sock_no_sendpage, 1189d021c344SAndy King }; 1190d021c344SAndy King 1191380feae0SPeng Tao static int vsock_transport_cancel_pkt(struct vsock_sock *vsk) 1192380feae0SPeng Tao { 1193fe502c4aSStefano Garzarella const struct vsock_transport *transport = vsk->transport; 1194fe502c4aSStefano Garzarella 1195380feae0SPeng Tao if (!transport->cancel_pkt) 1196380feae0SPeng Tao return -EOPNOTSUPP; 1197380feae0SPeng Tao 1198380feae0SPeng Tao return transport->cancel_pkt(vsk); 1199380feae0SPeng Tao } 1200380feae0SPeng Tao 1201d021c344SAndy King static void vsock_connect_timeout(struct work_struct *work) 1202d021c344SAndy King { 1203d021c344SAndy King struct sock *sk; 1204d021c344SAndy King struct vsock_sock *vsk; 1205380feae0SPeng Tao int cancel = 0; 1206d021c344SAndy King 1207455f05ecSCong Wang vsk = container_of(work, struct vsock_sock, connect_work.work); 1208d021c344SAndy King sk = sk_vsock(vsk); 1209d021c344SAndy King 1210d021c344SAndy King lock_sock(sk); 12113b4477d2SStefan Hajnoczi if (sk->sk_state == TCP_SYN_SENT && 1212d021c344SAndy King (sk->sk_shutdown != SHUTDOWN_MASK)) { 12133b4477d2SStefan Hajnoczi sk->sk_state = TCP_CLOSE; 1214d021c344SAndy King sk->sk_err = ETIMEDOUT; 1215d021c344SAndy King sk->sk_error_report(sk); 1216380feae0SPeng Tao cancel = 1; 1217d021c344SAndy King } 1218d021c344SAndy King release_sock(sk); 1219380feae0SPeng Tao if (cancel) 1220380feae0SPeng Tao vsock_transport_cancel_pkt(vsk); 1221d021c344SAndy King 1222d021c344SAndy King sock_put(sk); 1223d021c344SAndy King } 1224d021c344SAndy King 1225d021c344SAndy King static int vsock_stream_connect(struct socket *sock, struct sockaddr *addr, 1226d021c344SAndy King int addr_len, int flags) 1227d021c344SAndy King { 1228d021c344SAndy King int err; 1229d021c344SAndy King struct sock *sk; 1230d021c344SAndy King struct vsock_sock *vsk; 1231fe502c4aSStefano Garzarella const struct vsock_transport *transport; 1232d021c344SAndy King struct sockaddr_vm *remote_addr; 1233d021c344SAndy King long timeout; 1234d021c344SAndy King DEFINE_WAIT(wait); 1235d021c344SAndy King 1236d021c344SAndy King err = 0; 1237d021c344SAndy King sk = sock->sk; 1238d021c344SAndy King vsk = vsock_sk(sk); 1239d021c344SAndy King 1240d021c344SAndy King lock_sock(sk); 1241d021c344SAndy King 1242d021c344SAndy King /* XXX AF_UNSPEC should make us disconnect like AF_INET. */ 1243d021c344SAndy King switch (sock->state) { 1244d021c344SAndy King case SS_CONNECTED: 1245d021c344SAndy King err = -EISCONN; 1246d021c344SAndy King goto out; 1247d021c344SAndy King case SS_DISCONNECTING: 1248d021c344SAndy King err = -EINVAL; 1249d021c344SAndy King goto out; 1250d021c344SAndy King case SS_CONNECTING: 1251d021c344SAndy King /* This continues on so we can move sock into the SS_CONNECTED 1252d021c344SAndy King * state once the connection has completed (at which point err 1253d021c344SAndy King * will be set to zero also). Otherwise, we will either wait 1254d021c344SAndy King * for the connection or return -EALREADY should this be a 1255d021c344SAndy King * non-blocking call. 1256d021c344SAndy King */ 1257d021c344SAndy King err = -EALREADY; 1258d021c344SAndy King break; 1259d021c344SAndy King default: 12603b4477d2SStefan Hajnoczi if ((sk->sk_state == TCP_LISTEN) || 1261d021c344SAndy King vsock_addr_cast(addr, addr_len, &remote_addr) != 0) { 1262d021c344SAndy King err = -EINVAL; 1263d021c344SAndy King goto out; 1264d021c344SAndy King } 1265d021c344SAndy King 1266c0cfa2d8SStefano Garzarella /* Set the remote address that we are connecting to. */ 1267c0cfa2d8SStefano Garzarella memcpy(&vsk->remote_addr, remote_addr, 1268c0cfa2d8SStefano Garzarella sizeof(vsk->remote_addr)); 1269c0cfa2d8SStefano Garzarella 1270c0cfa2d8SStefano Garzarella err = vsock_assign_transport(vsk, NULL); 1271c0cfa2d8SStefano Garzarella if (err) 1272c0cfa2d8SStefano Garzarella goto out; 1273c0cfa2d8SStefano Garzarella 1274c0cfa2d8SStefano Garzarella transport = vsk->transport; 1275c0cfa2d8SStefano Garzarella 1276d021c344SAndy King /* The hypervisor and well-known contexts do not have socket 1277d021c344SAndy King * endpoints. 1278d021c344SAndy King */ 1279c0cfa2d8SStefano Garzarella if (!transport || 1280c0cfa2d8SStefano Garzarella !transport->stream_allow(remote_addr->svm_cid, 1281d021c344SAndy King remote_addr->svm_port)) { 1282d021c344SAndy King err = -ENETUNREACH; 1283d021c344SAndy King goto out; 1284d021c344SAndy King } 1285d021c344SAndy King 1286b3a6dfe8SAsias He err = vsock_auto_bind(vsk); 1287b3a6dfe8SAsias He if (err) 1288d021c344SAndy King goto out; 1289d021c344SAndy King 12903b4477d2SStefan Hajnoczi sk->sk_state = TCP_SYN_SENT; 1291d021c344SAndy King 1292d021c344SAndy King err = transport->connect(vsk); 1293d021c344SAndy King if (err < 0) 1294d021c344SAndy King goto out; 1295d021c344SAndy King 1296d021c344SAndy King /* Mark sock as connecting and set the error code to in 1297d021c344SAndy King * progress in case this is a non-blocking connect. 1298d021c344SAndy King */ 1299d021c344SAndy King sock->state = SS_CONNECTING; 1300d021c344SAndy King err = -EINPROGRESS; 1301d021c344SAndy King } 1302d021c344SAndy King 1303d021c344SAndy King /* The receive path will handle all communication until we are able to 1304d021c344SAndy King * enter the connected state. Here we wait for the connection to be 1305d021c344SAndy King * completed or a notification of an error. 1306d021c344SAndy King */ 1307d021c344SAndy King timeout = vsk->connect_timeout; 1308d021c344SAndy King prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 1309d021c344SAndy King 13103b4477d2SStefan Hajnoczi while (sk->sk_state != TCP_ESTABLISHED && sk->sk_err == 0) { 1311d021c344SAndy King if (flags & O_NONBLOCK) { 1312d021c344SAndy King /* If we're not going to block, we schedule a timeout 1313d021c344SAndy King * function to generate a timeout on the connection 1314d021c344SAndy King * attempt, in case the peer doesn't respond in a 1315d021c344SAndy King * timely manner. We hold on to the socket until the 1316d021c344SAndy King * timeout fires. 1317d021c344SAndy King */ 1318d021c344SAndy King sock_hold(sk); 1319455f05ecSCong Wang schedule_delayed_work(&vsk->connect_work, timeout); 1320d021c344SAndy King 1321d021c344SAndy King /* Skip ahead to preserve error code set above. */ 1322d021c344SAndy King goto out_wait; 1323d021c344SAndy King } 1324d021c344SAndy King 1325d021c344SAndy King release_sock(sk); 1326d021c344SAndy King timeout = schedule_timeout(timeout); 1327d021c344SAndy King lock_sock(sk); 1328d021c344SAndy King 1329d021c344SAndy King if (signal_pending(current)) { 1330d021c344SAndy King err = sock_intr_errno(timeout); 13313b4477d2SStefan Hajnoczi sk->sk_state = TCP_CLOSE; 1332f7f9b5e7SClaudio Imbrenda sock->state = SS_UNCONNECTED; 1333380feae0SPeng Tao vsock_transport_cancel_pkt(vsk); 1334f7f9b5e7SClaudio Imbrenda goto out_wait; 1335d021c344SAndy King } else if (timeout == 0) { 1336d021c344SAndy King err = -ETIMEDOUT; 13373b4477d2SStefan Hajnoczi sk->sk_state = TCP_CLOSE; 1338f7f9b5e7SClaudio Imbrenda sock->state = SS_UNCONNECTED; 1339380feae0SPeng Tao vsock_transport_cancel_pkt(vsk); 1340f7f9b5e7SClaudio Imbrenda goto out_wait; 1341d021c344SAndy King } 1342d021c344SAndy King 1343d021c344SAndy King prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 1344d021c344SAndy King } 1345d021c344SAndy King 1346d021c344SAndy King if (sk->sk_err) { 1347d021c344SAndy King err = -sk->sk_err; 13483b4477d2SStefan Hajnoczi sk->sk_state = TCP_CLOSE; 1349f7f9b5e7SClaudio Imbrenda sock->state = SS_UNCONNECTED; 1350f7f9b5e7SClaudio Imbrenda } else { 1351d021c344SAndy King err = 0; 1352f7f9b5e7SClaudio Imbrenda } 1353d021c344SAndy King 1354d021c344SAndy King out_wait: 1355d021c344SAndy King finish_wait(sk_sleep(sk), &wait); 1356d021c344SAndy King out: 1357d021c344SAndy King release_sock(sk); 1358d021c344SAndy King return err; 1359d021c344SAndy King } 1360d021c344SAndy King 1361cdfbabfbSDavid Howells static int vsock_accept(struct socket *sock, struct socket *newsock, int flags, 1362cdfbabfbSDavid Howells bool kern) 1363d021c344SAndy King { 1364d021c344SAndy King struct sock *listener; 1365d021c344SAndy King int err; 1366d021c344SAndy King struct sock *connected; 1367d021c344SAndy King struct vsock_sock *vconnected; 1368d021c344SAndy King long timeout; 1369d021c344SAndy King DEFINE_WAIT(wait); 1370d021c344SAndy King 1371d021c344SAndy King err = 0; 1372d021c344SAndy King listener = sock->sk; 1373d021c344SAndy King 1374d021c344SAndy King lock_sock(listener); 1375d021c344SAndy King 1376d021c344SAndy King if (sock->type != SOCK_STREAM) { 1377d021c344SAndy King err = -EOPNOTSUPP; 1378d021c344SAndy King goto out; 1379d021c344SAndy King } 1380d021c344SAndy King 13813b4477d2SStefan Hajnoczi if (listener->sk_state != TCP_LISTEN) { 1382d021c344SAndy King err = -EINVAL; 1383d021c344SAndy King goto out; 1384d021c344SAndy King } 1385d021c344SAndy King 1386d021c344SAndy King /* Wait for children sockets to appear; these are the new sockets 1387d021c344SAndy King * created upon connection establishment. 1388d021c344SAndy King */ 1389d021c344SAndy King timeout = sock_sndtimeo(listener, flags & O_NONBLOCK); 1390d021c344SAndy King prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE); 1391d021c344SAndy King 1392d021c344SAndy King while ((connected = vsock_dequeue_accept(listener)) == NULL && 1393d021c344SAndy King listener->sk_err == 0) { 1394d021c344SAndy King release_sock(listener); 1395d021c344SAndy King timeout = schedule_timeout(timeout); 1396f7f9b5e7SClaudio Imbrenda finish_wait(sk_sleep(listener), &wait); 1397d021c344SAndy King lock_sock(listener); 1398d021c344SAndy King 1399d021c344SAndy King if (signal_pending(current)) { 1400d021c344SAndy King err = sock_intr_errno(timeout); 1401f7f9b5e7SClaudio Imbrenda goto out; 1402d021c344SAndy King } else if (timeout == 0) { 1403d021c344SAndy King err = -EAGAIN; 1404f7f9b5e7SClaudio Imbrenda goto out; 1405d021c344SAndy King } 1406d021c344SAndy King 1407d021c344SAndy King prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE); 1408d021c344SAndy King } 1409f7f9b5e7SClaudio Imbrenda finish_wait(sk_sleep(listener), &wait); 1410d021c344SAndy King 1411d021c344SAndy King if (listener->sk_err) 1412d021c344SAndy King err = -listener->sk_err; 1413d021c344SAndy King 1414d021c344SAndy King if (connected) { 14157976a11bSEric Dumazet sk_acceptq_removed(listener); 1416d021c344SAndy King 14174192f672SStefan Hajnoczi lock_sock_nested(connected, SINGLE_DEPTH_NESTING); 1418d021c344SAndy King vconnected = vsock_sk(connected); 1419d021c344SAndy King 1420d021c344SAndy King /* If the listener socket has received an error, then we should 1421d021c344SAndy King * reject this socket and return. Note that we simply mark the 1422d021c344SAndy King * socket rejected, drop our reference, and let the cleanup 1423d021c344SAndy King * function handle the cleanup; the fact that we found it in 1424d021c344SAndy King * the listener's accept queue guarantees that the cleanup 1425d021c344SAndy King * function hasn't run yet. 1426d021c344SAndy King */ 1427d021c344SAndy King if (err) { 1428d021c344SAndy King vconnected->rejected = true; 1429f7f9b5e7SClaudio Imbrenda } else { 1430d021c344SAndy King newsock->state = SS_CONNECTED; 1431d021c344SAndy King sock_graft(connected, newsock); 1432f7f9b5e7SClaudio Imbrenda } 1433f7f9b5e7SClaudio Imbrenda 1434d021c344SAndy King release_sock(connected); 1435d021c344SAndy King sock_put(connected); 1436d021c344SAndy King } 1437d021c344SAndy King 1438d021c344SAndy King out: 1439d021c344SAndy King release_sock(listener); 1440d021c344SAndy King return err; 1441d021c344SAndy King } 1442d021c344SAndy King 1443d021c344SAndy King static int vsock_listen(struct socket *sock, int backlog) 1444d021c344SAndy King { 1445d021c344SAndy King int err; 1446d021c344SAndy King struct sock *sk; 1447d021c344SAndy King struct vsock_sock *vsk; 1448d021c344SAndy King 1449d021c344SAndy King sk = sock->sk; 1450d021c344SAndy King 1451d021c344SAndy King lock_sock(sk); 1452d021c344SAndy King 1453d021c344SAndy King if (sock->type != SOCK_STREAM) { 1454d021c344SAndy King err = -EOPNOTSUPP; 1455d021c344SAndy King goto out; 1456d021c344SAndy King } 1457d021c344SAndy King 1458d021c344SAndy King if (sock->state != SS_UNCONNECTED) { 1459d021c344SAndy King err = -EINVAL; 1460d021c344SAndy King goto out; 1461d021c344SAndy King } 1462d021c344SAndy King 1463d021c344SAndy King vsk = vsock_sk(sk); 1464d021c344SAndy King 1465d021c344SAndy King if (!vsock_addr_bound(&vsk->local_addr)) { 1466d021c344SAndy King err = -EINVAL; 1467d021c344SAndy King goto out; 1468d021c344SAndy King } 1469d021c344SAndy King 1470d021c344SAndy King sk->sk_max_ack_backlog = backlog; 14713b4477d2SStefan Hajnoczi sk->sk_state = TCP_LISTEN; 1472d021c344SAndy King 1473d021c344SAndy King err = 0; 1474d021c344SAndy King 1475d021c344SAndy King out: 1476d021c344SAndy King release_sock(sk); 1477d021c344SAndy King return err; 1478d021c344SAndy King } 1479d021c344SAndy King 1480b9f2b0ffSStefano Garzarella static void vsock_update_buffer_size(struct vsock_sock *vsk, 1481b9f2b0ffSStefano Garzarella const struct vsock_transport *transport, 1482b9f2b0ffSStefano Garzarella u64 val) 1483b9f2b0ffSStefano Garzarella { 1484b9f2b0ffSStefano Garzarella if (val > vsk->buffer_max_size) 1485b9f2b0ffSStefano Garzarella val = vsk->buffer_max_size; 1486b9f2b0ffSStefano Garzarella 1487b9f2b0ffSStefano Garzarella if (val < vsk->buffer_min_size) 1488b9f2b0ffSStefano Garzarella val = vsk->buffer_min_size; 1489b9f2b0ffSStefano Garzarella 1490b9f2b0ffSStefano Garzarella if (val != vsk->buffer_size && 1491b9f2b0ffSStefano Garzarella transport && transport->notify_buffer_size) 1492b9f2b0ffSStefano Garzarella transport->notify_buffer_size(vsk, &val); 1493b9f2b0ffSStefano Garzarella 1494b9f2b0ffSStefano Garzarella vsk->buffer_size = val; 1495b9f2b0ffSStefano Garzarella } 1496b9f2b0ffSStefano Garzarella 1497d021c344SAndy King static int vsock_stream_setsockopt(struct socket *sock, 1498d021c344SAndy King int level, 1499d021c344SAndy King int optname, 1500d021c344SAndy King char __user *optval, 1501d021c344SAndy King unsigned int optlen) 1502d021c344SAndy King { 1503d021c344SAndy King int err; 1504d021c344SAndy King struct sock *sk; 1505d021c344SAndy King struct vsock_sock *vsk; 1506fe502c4aSStefano Garzarella const struct vsock_transport *transport; 1507d021c344SAndy King u64 val; 1508d021c344SAndy King 1509d021c344SAndy King if (level != AF_VSOCK) 1510d021c344SAndy King return -ENOPROTOOPT; 1511d021c344SAndy King 1512d021c344SAndy King #define COPY_IN(_v) \ 1513d021c344SAndy King do { \ 1514d021c344SAndy King if (optlen < sizeof(_v)) { \ 1515d021c344SAndy King err = -EINVAL; \ 1516d021c344SAndy King goto exit; \ 1517d021c344SAndy King } \ 1518d021c344SAndy King if (copy_from_user(&_v, optval, sizeof(_v)) != 0) { \ 1519d021c344SAndy King err = -EFAULT; \ 1520d021c344SAndy King goto exit; \ 1521d021c344SAndy King } \ 1522d021c344SAndy King } while (0) 1523d021c344SAndy King 1524d021c344SAndy King err = 0; 1525d021c344SAndy King sk = sock->sk; 1526d021c344SAndy King vsk = vsock_sk(sk); 1527fe502c4aSStefano Garzarella transport = vsk->transport; 1528d021c344SAndy King 1529d021c344SAndy King lock_sock(sk); 1530d021c344SAndy King 1531d021c344SAndy King switch (optname) { 1532d021c344SAndy King case SO_VM_SOCKETS_BUFFER_SIZE: 1533d021c344SAndy King COPY_IN(val); 1534b9f2b0ffSStefano Garzarella vsock_update_buffer_size(vsk, transport, val); 1535d021c344SAndy King break; 1536d021c344SAndy King 1537d021c344SAndy King case SO_VM_SOCKETS_BUFFER_MAX_SIZE: 1538d021c344SAndy King COPY_IN(val); 1539b9f2b0ffSStefano Garzarella vsk->buffer_max_size = val; 1540b9f2b0ffSStefano Garzarella vsock_update_buffer_size(vsk, transport, vsk->buffer_size); 1541d021c344SAndy King break; 1542d021c344SAndy King 1543d021c344SAndy King case SO_VM_SOCKETS_BUFFER_MIN_SIZE: 1544d021c344SAndy King COPY_IN(val); 1545b9f2b0ffSStefano Garzarella vsk->buffer_min_size = val; 1546b9f2b0ffSStefano Garzarella vsock_update_buffer_size(vsk, transport, vsk->buffer_size); 1547d021c344SAndy King break; 1548d021c344SAndy King 1549d021c344SAndy King case SO_VM_SOCKETS_CONNECT_TIMEOUT: { 1550fe0c72f3SArnd Bergmann struct __kernel_old_timeval tv; 1551d021c344SAndy King COPY_IN(tv); 1552d021c344SAndy King if (tv.tv_sec >= 0 && tv.tv_usec < USEC_PER_SEC && 1553d021c344SAndy King tv.tv_sec < (MAX_SCHEDULE_TIMEOUT / HZ - 1)) { 1554d021c344SAndy King vsk->connect_timeout = tv.tv_sec * HZ + 1555d021c344SAndy King DIV_ROUND_UP(tv.tv_usec, (1000000 / HZ)); 1556d021c344SAndy King if (vsk->connect_timeout == 0) 1557d021c344SAndy King vsk->connect_timeout = 1558d021c344SAndy King VSOCK_DEFAULT_CONNECT_TIMEOUT; 1559d021c344SAndy King 1560d021c344SAndy King } else { 1561d021c344SAndy King err = -ERANGE; 1562d021c344SAndy King } 1563d021c344SAndy King break; 1564d021c344SAndy King } 1565d021c344SAndy King 1566d021c344SAndy King default: 1567d021c344SAndy King err = -ENOPROTOOPT; 1568d021c344SAndy King break; 1569d021c344SAndy King } 1570d021c344SAndy King 1571d021c344SAndy King #undef COPY_IN 1572d021c344SAndy King 1573d021c344SAndy King exit: 1574d021c344SAndy King release_sock(sk); 1575d021c344SAndy King return err; 1576d021c344SAndy King } 1577d021c344SAndy King 1578d021c344SAndy King static int vsock_stream_getsockopt(struct socket *sock, 1579d021c344SAndy King int level, int optname, 1580d021c344SAndy King char __user *optval, 1581d021c344SAndy King int __user *optlen) 1582d021c344SAndy King { 1583d021c344SAndy King int err; 1584d021c344SAndy King int len; 1585d021c344SAndy King struct sock *sk; 1586d021c344SAndy King struct vsock_sock *vsk; 1587d021c344SAndy King u64 val; 1588d021c344SAndy King 1589d021c344SAndy King if (level != AF_VSOCK) 1590d021c344SAndy King return -ENOPROTOOPT; 1591d021c344SAndy King 1592d021c344SAndy King err = get_user(len, optlen); 1593d021c344SAndy King if (err != 0) 1594d021c344SAndy King return err; 1595d021c344SAndy King 1596d021c344SAndy King #define COPY_OUT(_v) \ 1597d021c344SAndy King do { \ 1598d021c344SAndy King if (len < sizeof(_v)) \ 1599d021c344SAndy King return -EINVAL; \ 1600d021c344SAndy King \ 1601d021c344SAndy King len = sizeof(_v); \ 1602d021c344SAndy King if (copy_to_user(optval, &_v, len) != 0) \ 1603d021c344SAndy King return -EFAULT; \ 1604d021c344SAndy King \ 1605d021c344SAndy King } while (0) 1606d021c344SAndy King 1607d021c344SAndy King err = 0; 1608d021c344SAndy King sk = sock->sk; 1609d021c344SAndy King vsk = vsock_sk(sk); 1610d021c344SAndy King 1611d021c344SAndy King switch (optname) { 1612d021c344SAndy King case SO_VM_SOCKETS_BUFFER_SIZE: 1613b9f2b0ffSStefano Garzarella val = vsk->buffer_size; 1614d021c344SAndy King COPY_OUT(val); 1615d021c344SAndy King break; 1616d021c344SAndy King 1617d021c344SAndy King case SO_VM_SOCKETS_BUFFER_MAX_SIZE: 1618b9f2b0ffSStefano Garzarella val = vsk->buffer_max_size; 1619d021c344SAndy King COPY_OUT(val); 1620d021c344SAndy King break; 1621d021c344SAndy King 1622d021c344SAndy King case SO_VM_SOCKETS_BUFFER_MIN_SIZE: 1623b9f2b0ffSStefano Garzarella val = vsk->buffer_min_size; 1624d021c344SAndy King COPY_OUT(val); 1625d021c344SAndy King break; 1626d021c344SAndy King 1627d021c344SAndy King case SO_VM_SOCKETS_CONNECT_TIMEOUT: { 1628fe0c72f3SArnd Bergmann struct __kernel_old_timeval tv; 1629d021c344SAndy King tv.tv_sec = vsk->connect_timeout / HZ; 1630d021c344SAndy King tv.tv_usec = 1631d021c344SAndy King (vsk->connect_timeout - 1632d021c344SAndy King tv.tv_sec * HZ) * (1000000 / HZ); 1633d021c344SAndy King COPY_OUT(tv); 1634d021c344SAndy King break; 1635d021c344SAndy King } 1636d021c344SAndy King default: 1637d021c344SAndy King return -ENOPROTOOPT; 1638d021c344SAndy King } 1639d021c344SAndy King 1640d021c344SAndy King err = put_user(len, optlen); 1641d021c344SAndy King if (err != 0) 1642d021c344SAndy King return -EFAULT; 1643d021c344SAndy King 1644d021c344SAndy King #undef COPY_OUT 1645d021c344SAndy King 1646d021c344SAndy King return 0; 1647d021c344SAndy King } 1648d021c344SAndy King 16491b784140SYing Xue static int vsock_stream_sendmsg(struct socket *sock, struct msghdr *msg, 16501b784140SYing Xue size_t len) 1651d021c344SAndy King { 1652d021c344SAndy King struct sock *sk; 1653d021c344SAndy King struct vsock_sock *vsk; 1654fe502c4aSStefano Garzarella const struct vsock_transport *transport; 1655d021c344SAndy King ssize_t total_written; 1656d021c344SAndy King long timeout; 1657d021c344SAndy King int err; 1658d021c344SAndy King struct vsock_transport_send_notify_data send_data; 1659499fde66SWANG Cong DEFINE_WAIT_FUNC(wait, woken_wake_function); 1660d021c344SAndy King 1661d021c344SAndy King sk = sock->sk; 1662d021c344SAndy King vsk = vsock_sk(sk); 1663fe502c4aSStefano Garzarella transport = vsk->transport; 1664d021c344SAndy King total_written = 0; 1665d021c344SAndy King err = 0; 1666d021c344SAndy King 1667d021c344SAndy King if (msg->msg_flags & MSG_OOB) 1668d021c344SAndy King return -EOPNOTSUPP; 1669d021c344SAndy King 1670d021c344SAndy King lock_sock(sk); 1671d021c344SAndy King 1672d021c344SAndy King /* Callers should not provide a destination with stream sockets. */ 1673d021c344SAndy King if (msg->msg_namelen) { 16743b4477d2SStefan Hajnoczi err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP; 1675d021c344SAndy King goto out; 1676d021c344SAndy King } 1677d021c344SAndy King 1678d021c344SAndy King /* Send data only if both sides are not shutdown in the direction. */ 1679d021c344SAndy King if (sk->sk_shutdown & SEND_SHUTDOWN || 1680d021c344SAndy King vsk->peer_shutdown & RCV_SHUTDOWN) { 1681d021c344SAndy King err = -EPIPE; 1682d021c344SAndy King goto out; 1683d021c344SAndy King } 1684d021c344SAndy King 1685c0cfa2d8SStefano Garzarella if (!transport || sk->sk_state != TCP_ESTABLISHED || 1686d021c344SAndy King !vsock_addr_bound(&vsk->local_addr)) { 1687d021c344SAndy King err = -ENOTCONN; 1688d021c344SAndy King goto out; 1689d021c344SAndy King } 1690d021c344SAndy King 1691d021c344SAndy King if (!vsock_addr_bound(&vsk->remote_addr)) { 1692d021c344SAndy King err = -EDESTADDRREQ; 1693d021c344SAndy King goto out; 1694d021c344SAndy King } 1695d021c344SAndy King 1696d021c344SAndy King /* Wait for room in the produce queue to enqueue our user's data. */ 1697d021c344SAndy King timeout = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT); 1698d021c344SAndy King 1699d021c344SAndy King err = transport->notify_send_init(vsk, &send_data); 1700d021c344SAndy King if (err < 0) 1701d021c344SAndy King goto out; 1702d021c344SAndy King 1703d021c344SAndy King while (total_written < len) { 1704d021c344SAndy King ssize_t written; 1705d021c344SAndy King 1706499fde66SWANG Cong add_wait_queue(sk_sleep(sk), &wait); 1707d021c344SAndy King while (vsock_stream_has_space(vsk) == 0 && 1708d021c344SAndy King sk->sk_err == 0 && 1709d021c344SAndy King !(sk->sk_shutdown & SEND_SHUTDOWN) && 1710d021c344SAndy King !(vsk->peer_shutdown & RCV_SHUTDOWN)) { 1711d021c344SAndy King 1712d021c344SAndy King /* Don't wait for non-blocking sockets. */ 1713d021c344SAndy King if (timeout == 0) { 1714d021c344SAndy King err = -EAGAIN; 1715499fde66SWANG Cong remove_wait_queue(sk_sleep(sk), &wait); 1716f7f9b5e7SClaudio Imbrenda goto out_err; 1717d021c344SAndy King } 1718d021c344SAndy King 1719d021c344SAndy King err = transport->notify_send_pre_block(vsk, &send_data); 1720f7f9b5e7SClaudio Imbrenda if (err < 0) { 1721499fde66SWANG Cong remove_wait_queue(sk_sleep(sk), &wait); 1722f7f9b5e7SClaudio Imbrenda goto out_err; 1723f7f9b5e7SClaudio Imbrenda } 1724d021c344SAndy King 1725d021c344SAndy King release_sock(sk); 1726499fde66SWANG Cong timeout = wait_woken(&wait, TASK_INTERRUPTIBLE, timeout); 1727d021c344SAndy King lock_sock(sk); 1728d021c344SAndy King if (signal_pending(current)) { 1729d021c344SAndy King err = sock_intr_errno(timeout); 1730499fde66SWANG Cong remove_wait_queue(sk_sleep(sk), &wait); 1731f7f9b5e7SClaudio Imbrenda goto out_err; 1732d021c344SAndy King } else if (timeout == 0) { 1733d021c344SAndy King err = -EAGAIN; 1734499fde66SWANG Cong remove_wait_queue(sk_sleep(sk), &wait); 1735f7f9b5e7SClaudio Imbrenda goto out_err; 1736d021c344SAndy King } 1737d021c344SAndy King } 1738499fde66SWANG Cong remove_wait_queue(sk_sleep(sk), &wait); 1739d021c344SAndy King 1740d021c344SAndy King /* These checks occur both as part of and after the loop 1741d021c344SAndy King * conditional since we need to check before and after 1742d021c344SAndy King * sleeping. 1743d021c344SAndy King */ 1744d021c344SAndy King if (sk->sk_err) { 1745d021c344SAndy King err = -sk->sk_err; 1746f7f9b5e7SClaudio Imbrenda goto out_err; 1747d021c344SAndy King } else if ((sk->sk_shutdown & SEND_SHUTDOWN) || 1748d021c344SAndy King (vsk->peer_shutdown & RCV_SHUTDOWN)) { 1749d021c344SAndy King err = -EPIPE; 1750f7f9b5e7SClaudio Imbrenda goto out_err; 1751d021c344SAndy King } 1752d021c344SAndy King 1753d021c344SAndy King err = transport->notify_send_pre_enqueue(vsk, &send_data); 1754d021c344SAndy King if (err < 0) 1755f7f9b5e7SClaudio Imbrenda goto out_err; 1756d021c344SAndy King 1757d021c344SAndy King /* Note that enqueue will only write as many bytes as are free 1758d021c344SAndy King * in the produce queue, so we don't need to ensure len is 1759d021c344SAndy King * smaller than the queue size. It is the caller's 1760d021c344SAndy King * responsibility to check how many bytes we were able to send. 1761d021c344SAndy King */ 1762d021c344SAndy King 1763d021c344SAndy King written = transport->stream_enqueue( 17640f7db23aSAl Viro vsk, msg, 1765d021c344SAndy King len - total_written); 1766d021c344SAndy King if (written < 0) { 1767d021c344SAndy King err = -ENOMEM; 1768f7f9b5e7SClaudio Imbrenda goto out_err; 1769d021c344SAndy King } 1770d021c344SAndy King 1771d021c344SAndy King total_written += written; 1772d021c344SAndy King 1773d021c344SAndy King err = transport->notify_send_post_enqueue( 1774d021c344SAndy King vsk, written, &send_data); 1775d021c344SAndy King if (err < 0) 1776f7f9b5e7SClaudio Imbrenda goto out_err; 1777d021c344SAndy King 1778d021c344SAndy King } 1779d021c344SAndy King 1780f7f9b5e7SClaudio Imbrenda out_err: 1781d021c344SAndy King if (total_written > 0) 1782d021c344SAndy King err = total_written; 1783d021c344SAndy King out: 1784d021c344SAndy King release_sock(sk); 1785d021c344SAndy King return err; 1786d021c344SAndy King } 1787d021c344SAndy King 1788d021c344SAndy King 1789d021c344SAndy King static int 17901b784140SYing Xue vsock_stream_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, 17911b784140SYing Xue int flags) 1792d021c344SAndy King { 1793d021c344SAndy King struct sock *sk; 1794d021c344SAndy King struct vsock_sock *vsk; 1795fe502c4aSStefano Garzarella const struct vsock_transport *transport; 1796d021c344SAndy King int err; 1797d021c344SAndy King size_t target; 1798d021c344SAndy King ssize_t copied; 1799d021c344SAndy King long timeout; 1800d021c344SAndy King struct vsock_transport_recv_notify_data recv_data; 1801d021c344SAndy King 1802d021c344SAndy King DEFINE_WAIT(wait); 1803d021c344SAndy King 1804d021c344SAndy King sk = sock->sk; 1805d021c344SAndy King vsk = vsock_sk(sk); 1806fe502c4aSStefano Garzarella transport = vsk->transport; 1807d021c344SAndy King err = 0; 1808d021c344SAndy King 1809d021c344SAndy King lock_sock(sk); 1810d021c344SAndy King 1811c0cfa2d8SStefano Garzarella if (!transport || sk->sk_state != TCP_ESTABLISHED) { 1812d021c344SAndy King /* Recvmsg is supposed to return 0 if a peer performs an 1813d021c344SAndy King * orderly shutdown. Differentiate between that case and when a 1814d021c344SAndy King * peer has not connected or a local shutdown occured with the 1815d021c344SAndy King * SOCK_DONE flag. 1816d021c344SAndy King */ 1817d021c344SAndy King if (sock_flag(sk, SOCK_DONE)) 1818d021c344SAndy King err = 0; 1819d021c344SAndy King else 1820d021c344SAndy King err = -ENOTCONN; 1821d021c344SAndy King 1822d021c344SAndy King goto out; 1823d021c344SAndy King } 1824d021c344SAndy King 1825d021c344SAndy King if (flags & MSG_OOB) { 1826d021c344SAndy King err = -EOPNOTSUPP; 1827d021c344SAndy King goto out; 1828d021c344SAndy King } 1829d021c344SAndy King 1830d021c344SAndy King /* We don't check peer_shutdown flag here since peer may actually shut 1831d021c344SAndy King * down, but there can be data in the queue that a local socket can 1832d021c344SAndy King * receive. 1833d021c344SAndy King */ 1834d021c344SAndy King if (sk->sk_shutdown & RCV_SHUTDOWN) { 1835d021c344SAndy King err = 0; 1836d021c344SAndy King goto out; 1837d021c344SAndy King } 1838d021c344SAndy King 1839d021c344SAndy King /* It is valid on Linux to pass in a zero-length receive buffer. This 1840d021c344SAndy King * is not an error. We may as well bail out now. 1841d021c344SAndy King */ 1842d021c344SAndy King if (!len) { 1843d021c344SAndy King err = 0; 1844d021c344SAndy King goto out; 1845d021c344SAndy King } 1846d021c344SAndy King 1847d021c344SAndy King /* We must not copy less than target bytes into the user's buffer 1848d021c344SAndy King * before returning successfully, so we wait for the consume queue to 1849d021c344SAndy King * have that much data to consume before dequeueing. Note that this 1850d021c344SAndy King * makes it impossible to handle cases where target is greater than the 1851d021c344SAndy King * queue size. 1852d021c344SAndy King */ 1853d021c344SAndy King target = sock_rcvlowat(sk, flags & MSG_WAITALL, len); 1854d021c344SAndy King if (target >= transport->stream_rcvhiwat(vsk)) { 1855d021c344SAndy King err = -ENOMEM; 1856d021c344SAndy King goto out; 1857d021c344SAndy King } 1858d021c344SAndy King timeout = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 1859d021c344SAndy King copied = 0; 1860d021c344SAndy King 1861d021c344SAndy King err = transport->notify_recv_init(vsk, target, &recv_data); 1862d021c344SAndy King if (err < 0) 1863d021c344SAndy King goto out; 1864d021c344SAndy King 1865d021c344SAndy King 1866d021c344SAndy King while (1) { 1867f7f9b5e7SClaudio Imbrenda s64 ready; 1868f7f9b5e7SClaudio Imbrenda 1869f7f9b5e7SClaudio Imbrenda prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 1870f7f9b5e7SClaudio Imbrenda ready = vsock_stream_has_data(vsk); 1871f7f9b5e7SClaudio Imbrenda 1872f7f9b5e7SClaudio Imbrenda if (ready == 0) { 1873f7f9b5e7SClaudio Imbrenda if (sk->sk_err != 0 || 1874f7f9b5e7SClaudio Imbrenda (sk->sk_shutdown & RCV_SHUTDOWN) || 1875f7f9b5e7SClaudio Imbrenda (vsk->peer_shutdown & SEND_SHUTDOWN)) { 1876f7f9b5e7SClaudio Imbrenda finish_wait(sk_sleep(sk), &wait); 1877f7f9b5e7SClaudio Imbrenda break; 1878f7f9b5e7SClaudio Imbrenda } 1879f7f9b5e7SClaudio Imbrenda /* Don't wait for non-blocking sockets. */ 1880f7f9b5e7SClaudio Imbrenda if (timeout == 0) { 1881f7f9b5e7SClaudio Imbrenda err = -EAGAIN; 1882f7f9b5e7SClaudio Imbrenda finish_wait(sk_sleep(sk), &wait); 1883f7f9b5e7SClaudio Imbrenda break; 1884f7f9b5e7SClaudio Imbrenda } 1885f7f9b5e7SClaudio Imbrenda 1886f7f9b5e7SClaudio Imbrenda err = transport->notify_recv_pre_block( 1887f7f9b5e7SClaudio Imbrenda vsk, target, &recv_data); 1888f7f9b5e7SClaudio Imbrenda if (err < 0) { 1889f7f9b5e7SClaudio Imbrenda finish_wait(sk_sleep(sk), &wait); 1890f7f9b5e7SClaudio Imbrenda break; 1891f7f9b5e7SClaudio Imbrenda } 1892f7f9b5e7SClaudio Imbrenda release_sock(sk); 1893f7f9b5e7SClaudio Imbrenda timeout = schedule_timeout(timeout); 1894f7f9b5e7SClaudio Imbrenda lock_sock(sk); 1895f7f9b5e7SClaudio Imbrenda 1896f7f9b5e7SClaudio Imbrenda if (signal_pending(current)) { 1897f7f9b5e7SClaudio Imbrenda err = sock_intr_errno(timeout); 1898f7f9b5e7SClaudio Imbrenda finish_wait(sk_sleep(sk), &wait); 1899f7f9b5e7SClaudio Imbrenda break; 1900f7f9b5e7SClaudio Imbrenda } else if (timeout == 0) { 1901f7f9b5e7SClaudio Imbrenda err = -EAGAIN; 1902f7f9b5e7SClaudio Imbrenda finish_wait(sk_sleep(sk), &wait); 1903f7f9b5e7SClaudio Imbrenda break; 1904f7f9b5e7SClaudio Imbrenda } 1905f7f9b5e7SClaudio Imbrenda } else { 1906f7f9b5e7SClaudio Imbrenda ssize_t read; 1907f7f9b5e7SClaudio Imbrenda 1908f7f9b5e7SClaudio Imbrenda finish_wait(sk_sleep(sk), &wait); 1909d021c344SAndy King 1910d021c344SAndy King if (ready < 0) { 1911f7f9b5e7SClaudio Imbrenda /* Invalid queue pair content. XXX This should 1912f7f9b5e7SClaudio Imbrenda * be changed to a connection reset in a later 1913f7f9b5e7SClaudio Imbrenda * change. 1914d021c344SAndy King */ 1915d021c344SAndy King 1916d021c344SAndy King err = -ENOMEM; 1917f7f9b5e7SClaudio Imbrenda goto out; 1918f7f9b5e7SClaudio Imbrenda } 1919d021c344SAndy King 1920d021c344SAndy King err = transport->notify_recv_pre_dequeue( 1921d021c344SAndy King vsk, target, &recv_data); 1922d021c344SAndy King if (err < 0) 1923d021c344SAndy King break; 1924d021c344SAndy King 1925d021c344SAndy King read = transport->stream_dequeue( 19260f7db23aSAl Viro vsk, msg, 1927d021c344SAndy King len - copied, flags); 1928d021c344SAndy King if (read < 0) { 1929d021c344SAndy King err = -ENOMEM; 1930d021c344SAndy King break; 1931d021c344SAndy King } 1932d021c344SAndy King 1933d021c344SAndy King copied += read; 1934d021c344SAndy King 1935d021c344SAndy King err = transport->notify_recv_post_dequeue( 1936d021c344SAndy King vsk, target, read, 1937d021c344SAndy King !(flags & MSG_PEEK), &recv_data); 1938d021c344SAndy King if (err < 0) 1939f7f9b5e7SClaudio Imbrenda goto out; 1940d021c344SAndy King 1941d021c344SAndy King if (read >= target || flags & MSG_PEEK) 1942d021c344SAndy King break; 1943d021c344SAndy King 1944d021c344SAndy King target -= read; 1945d021c344SAndy King } 1946d021c344SAndy King } 1947d021c344SAndy King 1948d021c344SAndy King if (sk->sk_err) 1949d021c344SAndy King err = -sk->sk_err; 1950d021c344SAndy King else if (sk->sk_shutdown & RCV_SHUTDOWN) 1951d021c344SAndy King err = 0; 1952d021c344SAndy King 1953dedc58e0SIan Campbell if (copied > 0) 1954d021c344SAndy King err = copied; 1955d021c344SAndy King 1956d021c344SAndy King out: 1957d021c344SAndy King release_sock(sk); 1958d021c344SAndy King return err; 1959d021c344SAndy King } 1960d021c344SAndy King 1961d021c344SAndy King static const struct proto_ops vsock_stream_ops = { 1962d021c344SAndy King .family = PF_VSOCK, 1963d021c344SAndy King .owner = THIS_MODULE, 1964d021c344SAndy King .release = vsock_release, 1965d021c344SAndy King .bind = vsock_bind, 1966d021c344SAndy King .connect = vsock_stream_connect, 1967d021c344SAndy King .socketpair = sock_no_socketpair, 1968d021c344SAndy King .accept = vsock_accept, 1969d021c344SAndy King .getname = vsock_getname, 1970a11e1d43SLinus Torvalds .poll = vsock_poll, 1971d021c344SAndy King .ioctl = sock_no_ioctl, 1972d021c344SAndy King .listen = vsock_listen, 1973d021c344SAndy King .shutdown = vsock_shutdown, 1974d021c344SAndy King .setsockopt = vsock_stream_setsockopt, 1975d021c344SAndy King .getsockopt = vsock_stream_getsockopt, 1976d021c344SAndy King .sendmsg = vsock_stream_sendmsg, 1977d021c344SAndy King .recvmsg = vsock_stream_recvmsg, 1978d021c344SAndy King .mmap = sock_no_mmap, 1979d021c344SAndy King .sendpage = sock_no_sendpage, 1980d021c344SAndy King }; 1981d021c344SAndy King 1982d021c344SAndy King static int vsock_create(struct net *net, struct socket *sock, 1983d021c344SAndy King int protocol, int kern) 1984d021c344SAndy King { 1985c0cfa2d8SStefano Garzarella struct vsock_sock *vsk; 198655f3e149SStefano Garzarella struct sock *sk; 1987c0cfa2d8SStefano Garzarella int ret; 198855f3e149SStefano Garzarella 1989d021c344SAndy King if (!sock) 1990d021c344SAndy King return -EINVAL; 1991d021c344SAndy King 19926cf1c5fcSAndy King if (protocol && protocol != PF_VSOCK) 1993d021c344SAndy King return -EPROTONOSUPPORT; 1994d021c344SAndy King 1995d021c344SAndy King switch (sock->type) { 1996d021c344SAndy King case SOCK_DGRAM: 1997d021c344SAndy King sock->ops = &vsock_dgram_ops; 1998d021c344SAndy King break; 1999d021c344SAndy King case SOCK_STREAM: 2000d021c344SAndy King sock->ops = &vsock_stream_ops; 2001d021c344SAndy King break; 2002d021c344SAndy King default: 2003d021c344SAndy King return -ESOCKTNOSUPPORT; 2004d021c344SAndy King } 2005d021c344SAndy King 2006d021c344SAndy King sock->state = SS_UNCONNECTED; 2007d021c344SAndy King 200855f3e149SStefano Garzarella sk = __vsock_create(net, sock, NULL, GFP_KERNEL, 0, kern); 200955f3e149SStefano Garzarella if (!sk) 201055f3e149SStefano Garzarella return -ENOMEM; 201155f3e149SStefano Garzarella 2012c0cfa2d8SStefano Garzarella vsk = vsock_sk(sk); 2013c0cfa2d8SStefano Garzarella 2014c0cfa2d8SStefano Garzarella if (sock->type == SOCK_DGRAM) { 2015c0cfa2d8SStefano Garzarella ret = vsock_assign_transport(vsk, NULL); 2016c0cfa2d8SStefano Garzarella if (ret < 0) { 2017c0cfa2d8SStefano Garzarella sock_put(sk); 2018c0cfa2d8SStefano Garzarella return ret; 2019c0cfa2d8SStefano Garzarella } 2020c0cfa2d8SStefano Garzarella } 2021c0cfa2d8SStefano Garzarella 2022c0cfa2d8SStefano Garzarella vsock_insert_unbound(vsk); 202355f3e149SStefano Garzarella 202455f3e149SStefano Garzarella return 0; 2025d021c344SAndy King } 2026d021c344SAndy King 2027d021c344SAndy King static const struct net_proto_family vsock_family_ops = { 2028d021c344SAndy King .family = AF_VSOCK, 2029d021c344SAndy King .create = vsock_create, 2030d021c344SAndy King .owner = THIS_MODULE, 2031d021c344SAndy King }; 2032d021c344SAndy King 2033d021c344SAndy King static long vsock_dev_do_ioctl(struct file *filp, 2034d021c344SAndy King unsigned int cmd, void __user *ptr) 2035d021c344SAndy King { 2036d021c344SAndy King u32 __user *p = ptr; 2037c0cfa2d8SStefano Garzarella u32 cid = VMADDR_CID_ANY; 2038d021c344SAndy King int retval = 0; 2039d021c344SAndy King 2040d021c344SAndy King switch (cmd) { 2041d021c344SAndy King case IOCTL_VM_SOCKETS_GET_LOCAL_CID: 2042c0cfa2d8SStefano Garzarella /* To be compatible with the VMCI behavior, we prioritize the 2043c0cfa2d8SStefano Garzarella * guest CID instead of well-know host CID (VMADDR_CID_HOST). 2044c0cfa2d8SStefano Garzarella */ 2045c0cfa2d8SStefano Garzarella if (transport_g2h) 2046c0cfa2d8SStefano Garzarella cid = transport_g2h->get_local_cid(); 2047c0cfa2d8SStefano Garzarella else if (transport_h2g) 2048c0cfa2d8SStefano Garzarella cid = transport_h2g->get_local_cid(); 2049c0cfa2d8SStefano Garzarella 2050c0cfa2d8SStefano Garzarella if (put_user(cid, p) != 0) 2051d021c344SAndy King retval = -EFAULT; 2052d021c344SAndy King break; 2053d021c344SAndy King 2054d021c344SAndy King default: 2055d021c344SAndy King pr_err("Unknown ioctl %d\n", cmd); 2056d021c344SAndy King retval = -EINVAL; 2057d021c344SAndy King } 2058d021c344SAndy King 2059d021c344SAndy King return retval; 2060d021c344SAndy King } 2061d021c344SAndy King 2062d021c344SAndy King static long vsock_dev_ioctl(struct file *filp, 2063d021c344SAndy King unsigned int cmd, unsigned long arg) 2064d021c344SAndy King { 2065d021c344SAndy King return vsock_dev_do_ioctl(filp, cmd, (void __user *)arg); 2066d021c344SAndy King } 2067d021c344SAndy King 2068d021c344SAndy King #ifdef CONFIG_COMPAT 2069d021c344SAndy King static long vsock_dev_compat_ioctl(struct file *filp, 2070d021c344SAndy King unsigned int cmd, unsigned long arg) 2071d021c344SAndy King { 2072d021c344SAndy King return vsock_dev_do_ioctl(filp, cmd, compat_ptr(arg)); 2073d021c344SAndy King } 2074d021c344SAndy King #endif 2075d021c344SAndy King 2076d021c344SAndy King static const struct file_operations vsock_device_ops = { 2077d021c344SAndy King .owner = THIS_MODULE, 2078d021c344SAndy King .unlocked_ioctl = vsock_dev_ioctl, 2079d021c344SAndy King #ifdef CONFIG_COMPAT 2080d021c344SAndy King .compat_ioctl = vsock_dev_compat_ioctl, 2081d021c344SAndy King #endif 2082d021c344SAndy King .open = nonseekable_open, 2083d021c344SAndy King }; 2084d021c344SAndy King 2085d021c344SAndy King static struct miscdevice vsock_device = { 2086d021c344SAndy King .name = "vsock", 2087d021c344SAndy King .fops = &vsock_device_ops, 2088d021c344SAndy King }; 2089d021c344SAndy King 2090c0cfa2d8SStefano Garzarella static int __init vsock_init(void) 2091d021c344SAndy King { 2092c0cfa2d8SStefano Garzarella int err = 0; 20932c4a336eSAndy King 2094c0cfa2d8SStefano Garzarella vsock_init_tables(); 20952c4a336eSAndy King 2096c0cfa2d8SStefano Garzarella vsock_proto.owner = THIS_MODULE; 20976ad0b2f7SAsias He vsock_device.minor = MISC_DYNAMIC_MINOR; 2098d021c344SAndy King err = misc_register(&vsock_device); 2099d021c344SAndy King if (err) { 2100d021c344SAndy King pr_err("Failed to register misc device\n"); 2101f6a835bbSGao feng goto err_reset_transport; 2102d021c344SAndy King } 2103d021c344SAndy King 2104d021c344SAndy King err = proto_register(&vsock_proto, 1); /* we want our slab */ 2105d021c344SAndy King if (err) { 2106d021c344SAndy King pr_err("Cannot register vsock protocol\n"); 2107f6a835bbSGao feng goto err_deregister_misc; 2108d021c344SAndy King } 2109d021c344SAndy King 2110d021c344SAndy King err = sock_register(&vsock_family_ops); 2111d021c344SAndy King if (err) { 2112d021c344SAndy King pr_err("could not register af_vsock (%d) address family: %d\n", 2113d021c344SAndy King AF_VSOCK, err); 2114d021c344SAndy King goto err_unregister_proto; 2115d021c344SAndy King } 2116d021c344SAndy King 2117d021c344SAndy King return 0; 2118d021c344SAndy King 2119d021c344SAndy King err_unregister_proto: 2120d021c344SAndy King proto_unregister(&vsock_proto); 2121f6a835bbSGao feng err_deregister_misc: 2122d021c344SAndy King misc_deregister(&vsock_device); 2123f6a835bbSGao feng err_reset_transport: 2124d021c344SAndy King return err; 2125d021c344SAndy King } 2126d021c344SAndy King 2127c0cfa2d8SStefano Garzarella static void __exit vsock_exit(void) 2128d021c344SAndy King { 2129d021c344SAndy King misc_deregister(&vsock_device); 2130d021c344SAndy King sock_unregister(AF_VSOCK); 2131d021c344SAndy King proto_unregister(&vsock_proto); 2132d021c344SAndy King } 2133d021c344SAndy King 2134daabfbcaSStefano Garzarella const struct vsock_transport *vsock_core_get_transport(struct vsock_sock *vsk) 21350b01aeb3SStefan Hajnoczi { 2136daabfbcaSStefano Garzarella return vsk->transport; 21370b01aeb3SStefan Hajnoczi } 21380b01aeb3SStefan Hajnoczi EXPORT_SYMBOL_GPL(vsock_core_get_transport); 21390b01aeb3SStefan Hajnoczi 2140c0cfa2d8SStefano Garzarella int vsock_core_register(const struct vsock_transport *t, int features) 214105e489b1SStefan Hajnoczi { 2142*0e121905SStefano Garzarella const struct vsock_transport *t_h2g, *t_g2h, *t_dgram, *t_local; 2143c0cfa2d8SStefano Garzarella int err = mutex_lock_interruptible(&vsock_register_mutex); 2144c0cfa2d8SStefano Garzarella 2145c0cfa2d8SStefano Garzarella if (err) 2146c0cfa2d8SStefano Garzarella return err; 2147c0cfa2d8SStefano Garzarella 2148c0cfa2d8SStefano Garzarella t_h2g = transport_h2g; 2149c0cfa2d8SStefano Garzarella t_g2h = transport_g2h; 2150c0cfa2d8SStefano Garzarella t_dgram = transport_dgram; 2151*0e121905SStefano Garzarella t_local = transport_local; 2152c0cfa2d8SStefano Garzarella 2153c0cfa2d8SStefano Garzarella if (features & VSOCK_TRANSPORT_F_H2G) { 2154c0cfa2d8SStefano Garzarella if (t_h2g) { 2155c0cfa2d8SStefano Garzarella err = -EBUSY; 2156c0cfa2d8SStefano Garzarella goto err_busy; 2157c0cfa2d8SStefano Garzarella } 2158c0cfa2d8SStefano Garzarella t_h2g = t; 215905e489b1SStefan Hajnoczi } 216005e489b1SStefan Hajnoczi 2161c0cfa2d8SStefano Garzarella if (features & VSOCK_TRANSPORT_F_G2H) { 2162c0cfa2d8SStefano Garzarella if (t_g2h) { 2163c0cfa2d8SStefano Garzarella err = -EBUSY; 2164c0cfa2d8SStefano Garzarella goto err_busy; 2165c0cfa2d8SStefano Garzarella } 2166c0cfa2d8SStefano Garzarella t_g2h = t; 2167c0cfa2d8SStefano Garzarella } 2168c0cfa2d8SStefano Garzarella 2169c0cfa2d8SStefano Garzarella if (features & VSOCK_TRANSPORT_F_DGRAM) { 2170c0cfa2d8SStefano Garzarella if (t_dgram) { 2171c0cfa2d8SStefano Garzarella err = -EBUSY; 2172c0cfa2d8SStefano Garzarella goto err_busy; 2173c0cfa2d8SStefano Garzarella } 2174c0cfa2d8SStefano Garzarella t_dgram = t; 2175c0cfa2d8SStefano Garzarella } 2176c0cfa2d8SStefano Garzarella 2177*0e121905SStefano Garzarella if (features & VSOCK_TRANSPORT_F_LOCAL) { 2178*0e121905SStefano Garzarella if (t_local) { 2179*0e121905SStefano Garzarella err = -EBUSY; 2180*0e121905SStefano Garzarella goto err_busy; 2181*0e121905SStefano Garzarella } 2182*0e121905SStefano Garzarella t_local = t; 2183*0e121905SStefano Garzarella } 2184*0e121905SStefano Garzarella 2185c0cfa2d8SStefano Garzarella transport_h2g = t_h2g; 2186c0cfa2d8SStefano Garzarella transport_g2h = t_g2h; 2187c0cfa2d8SStefano Garzarella transport_dgram = t_dgram; 2188*0e121905SStefano Garzarella transport_local = t_local; 2189c0cfa2d8SStefano Garzarella 2190c0cfa2d8SStefano Garzarella err_busy: 2191c0cfa2d8SStefano Garzarella mutex_unlock(&vsock_register_mutex); 2192c0cfa2d8SStefano Garzarella return err; 2193c0cfa2d8SStefano Garzarella } 2194c0cfa2d8SStefano Garzarella EXPORT_SYMBOL_GPL(vsock_core_register); 2195c0cfa2d8SStefano Garzarella 2196c0cfa2d8SStefano Garzarella void vsock_core_unregister(const struct vsock_transport *t) 2197c0cfa2d8SStefano Garzarella { 2198c0cfa2d8SStefano Garzarella mutex_lock(&vsock_register_mutex); 2199c0cfa2d8SStefano Garzarella 2200c0cfa2d8SStefano Garzarella if (transport_h2g == t) 2201c0cfa2d8SStefano Garzarella transport_h2g = NULL; 2202c0cfa2d8SStefano Garzarella 2203c0cfa2d8SStefano Garzarella if (transport_g2h == t) 2204c0cfa2d8SStefano Garzarella transport_g2h = NULL; 2205c0cfa2d8SStefano Garzarella 2206c0cfa2d8SStefano Garzarella if (transport_dgram == t) 2207c0cfa2d8SStefano Garzarella transport_dgram = NULL; 2208c0cfa2d8SStefano Garzarella 2209*0e121905SStefano Garzarella if (transport_local == t) 2210*0e121905SStefano Garzarella transport_local = NULL; 2211*0e121905SStefano Garzarella 2212c0cfa2d8SStefano Garzarella mutex_unlock(&vsock_register_mutex); 2213c0cfa2d8SStefano Garzarella } 2214c0cfa2d8SStefano Garzarella EXPORT_SYMBOL_GPL(vsock_core_unregister); 2215c0cfa2d8SStefano Garzarella 2216c0cfa2d8SStefano Garzarella module_init(vsock_init); 221705e489b1SStefan Hajnoczi module_exit(vsock_exit); 2218c1eef220SCong Wang 2219d021c344SAndy King MODULE_AUTHOR("VMware, Inc."); 2220d021c344SAndy King MODULE_DESCRIPTION("VMware Virtual Socket Family"); 22211190cfdbSJorgen Hansen MODULE_VERSION("1.0.2.0-k"); 2222d021c344SAndy King MODULE_LICENSE("GPL v2"); 2223