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