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