aboutsummaryrefslogtreecommitdiffstats
path: root/net/vmw_vsock
diff options
context:
space:
mode:
Diffstat (limited to 'net/vmw_vsock')
-rw-r--r--net/vmw_vsock/Kconfig28
-rw-r--r--net/vmw_vsock/Makefile7
-rw-r--r--net/vmw_vsock/af_vsock.c2012
-rw-r--r--net/vmw_vsock/af_vsock.h175
-rw-r--r--net/vmw_vsock/vmci_transport.c2155
-rw-r--r--net/vmw_vsock/vmci_transport.h139
-rw-r--r--net/vmw_vsock/vmci_transport_notify.c680
-rw-r--r--net/vmw_vsock/vmci_transport_notify.h83
-rw-r--r--net/vmw_vsock/vmci_transport_notify_qstate.c438
-rw-r--r--net/vmw_vsock/vsock_addr.c86
-rw-r--r--net/vmw_vsock/vsock_addr.h32
11 files changed, 5835 insertions, 0 deletions
diff --git a/net/vmw_vsock/Kconfig b/net/vmw_vsock/Kconfig
new file mode 100644
index 000000000000..b5fa7e40cdcb
--- /dev/null
+++ b/net/vmw_vsock/Kconfig
@@ -0,0 +1,28 @@
1#
2# Vsock protocol
3#
4
5config VSOCKETS
6 tristate "Virtual Socket protocol"
7 help
8 Virtual Socket Protocol is a socket protocol similar to TCP/IP
9 allowing comunication between Virtual Machines and hypervisor
10 or host.
11
12 You should also select one or more hypervisor-specific transports
13 below.
14
15 To compile this driver as a module, choose M here: the module
16 will be called vsock. If unsure, say N.
17
18config VMWARE_VMCI_VSOCKETS
19 tristate "VMware VMCI transport for Virtual Sockets"
20 depends on VSOCKETS && VMWARE_VMCI
21 help
22 This module implements a VMCI transport for Virtual Sockets.
23
24 Enable this transport if your Virtual Machine runs on a VMware
25 hypervisor.
26
27 To compile this driver as a module, choose M here: the module
28 will be called vmw_vsock_vmci_transport. If unsure, say N.
diff --git a/net/vmw_vsock/Makefile b/net/vmw_vsock/Makefile
new file mode 100644
index 000000000000..2ce52d70f224
--- /dev/null
+++ b/net/vmw_vsock/Makefile
@@ -0,0 +1,7 @@
1obj-$(CONFIG_VSOCKETS) += vsock.o
2obj-$(CONFIG_VMWARE_VMCI_VSOCKETS) += vmw_vsock_vmci_transport.o
3
4vsock-y += af_vsock.o vsock_addr.o
5
6vmw_vsock_vmci_transport-y += vmci_transport.o vmci_transport_notify.o \
7 vmci_transport_notify_qstate.o
diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c
new file mode 100644
index 000000000000..ca511c4f388a
--- /dev/null
+++ b/net/vmw_vsock/af_vsock.c
@@ -0,0 +1,2012 @@
1/*
2 * VMware vSockets Driver
3 *
4 * Copyright (C) 2007-2013 VMware, Inc. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16/* Implementation notes:
17 *
18 * - There are two kinds of sockets: those created by user action (such as
19 * calling socket(2)) and those created by incoming connection request packets.
20 *
21 * - There are two "global" tables, one for bound sockets (sockets that have
22 * specified an address that they are responsible for) and one for connected
23 * sockets (sockets that have established a connection with another socket).
24 * These tables are "global" in that all sockets on the system are placed
25 * within them. - Note, though, that the bound table contains an extra entry
26 * for a list of unbound sockets and SOCK_DGRAM sockets will always remain in
27 * that list. The bound table is used solely for lookup of sockets when packets
28 * are received and that's not necessary for SOCK_DGRAM sockets since we create
29 * a datagram handle for each and need not perform a lookup. Keeping SOCK_DGRAM
30 * sockets out of the bound hash buckets will reduce the chance of collisions
31 * when looking for SOCK_STREAM sockets and prevents us from having to check the
32 * socket type in the hash table lookups.
33 *
34 * - Sockets created by user action will either be "client" sockets that
35 * initiate a connection or "server" sockets that listen for connections; we do
36 * not support simultaneous connects (two "client" sockets connecting).
37 *
38 * - "Server" sockets are referred to as listener sockets throughout this
39 * implementation because they are in the SS_LISTEN state. When a connection
40 * request is received (the second kind of socket mentioned above), we create a
41 * new socket and refer to it as a pending socket. These pending sockets are
42 * placed on the pending connection list of the listener socket. When future
43 * packets are received for the address the listener socket is bound to, we
44 * check if the source of the packet is from one that has an existing pending
45 * connection. If it does, we process the packet for the pending socket. When
46 * that socket reaches the connected state, it is removed from the listener
47 * socket's pending list and enqueued in the listener socket's accept queue.
48 * Callers of accept(2) will accept connected sockets from the listener socket's
49 * accept queue. If the socket cannot be accepted for some reason then it is
50 * marked rejected. Once the connection is accepted, it is owned by the user
51 * process and the responsibility for cleanup falls with that user process.
52 *
53 * - It is possible that these pending sockets will never reach the connected
54 * state; in fact, we may never receive another packet after the connection
55 * request. Because of this, we must schedule a cleanup function to run in the
56 * future, after some amount of time passes where a connection should have been
57 * established. This function ensures that the socket is off all lists so it
58 * cannot be retrieved, then drops all references to the socket so it is cleaned
59 * up (sock_put() -> sk_free() -> our sk_destruct implementation). Note this
60 * function will also cleanup rejected sockets, those that reach the connected
61 * state but leave it before they have been accepted.
62 *
63 * - Sockets created by user action will be cleaned up when the user process
64 * calls close(2), causing our release implementation to be called. Our release
65 * implementation will perform some cleanup then drop the last reference so our
66 * sk_destruct implementation is invoked. Our sk_destruct implementation will
67 * perform additional cleanup that's common for both types of sockets.
68 *
69 * - A socket's reference count is what ensures that the structure won't be
70 * freed. Each entry in a list (such as the "global" bound and connected tables
71 * and the listener socket's pending list and connected queue) ensures a
72 * reference. When we defer work until process context and pass a socket as our
73 * argument, we must ensure the reference count is increased to ensure the
74 * socket isn't freed before the function is run; the deferred function will
75 * then drop the reference.
76 */
77
78#include <linux/types.h>
79#include <linux/bitops.h>
80#include <linux/cred.h>
81#include <linux/init.h>
82#include <linux/io.h>
83#include <linux/kernel.h>
84#include <linux/kmod.h>
85#include <linux/list.h>
86#include <linux/miscdevice.h>
87#include <linux/module.h>
88#include <linux/mutex.h>
89#include <linux/net.h>
90#include <linux/poll.h>
91#include <linux/skbuff.h>
92#include <linux/smp.h>
93#include <linux/socket.h>
94#include <linux/stddef.h>
95#include <linux/unistd.h>
96#include <linux/wait.h>
97#include <linux/workqueue.h>
98#include <net/sock.h>
99
100#include "af_vsock.h"
101
102static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr);
103static void vsock_sk_destruct(struct sock *sk);
104static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
105
106/* Protocol family. */
107static struct proto vsock_proto = {
108 .name = "AF_VSOCK",
109 .owner = THIS_MODULE,
110 .obj_size = sizeof(struct vsock_sock),
111};
112
113/* The default peer timeout indicates how long we will wait for a peer response
114 * to a control message.
115 */
116#define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ)
117
118#define SS_LISTEN 255
119
120static const struct vsock_transport *transport;
121static DEFINE_MUTEX(vsock_register_mutex);
122
123/**** EXPORTS ****/
124
125/* Get the ID of the local context. This is transport dependent. */
126
127int vm_sockets_get_local_cid(void)
128{
129 return transport->get_local_cid();
130}
131EXPORT_SYMBOL_GPL(vm_sockets_get_local_cid);
132
133/**** UTILS ****/
134
135/* Each bound VSocket is stored in the bind hash table and each connected
136 * VSocket is stored in the connected hash table.
137 *
138 * Unbound sockets are all put on the same list attached to the end of the hash
139 * table (vsock_unbound_sockets). Bound sockets are added to the hash table in
140 * the bucket that their local address hashes to (vsock_bound_sockets(addr)
141 * represents the list that addr hashes to).
142 *
143 * Specifically, we initialize the vsock_bind_table array to a size of
144 * VSOCK_HASH_SIZE + 1 so that vsock_bind_table[0] through
145 * vsock_bind_table[VSOCK_HASH_SIZE - 1] are for bound sockets and
146 * vsock_bind_table[VSOCK_HASH_SIZE] is for unbound sockets. The hash function
147 * mods with VSOCK_HASH_SIZE - 1 to ensure this.
148 */
149#define VSOCK_HASH_SIZE 251
150#define MAX_PORT_RETRIES 24
151
152#define VSOCK_HASH(addr) ((addr)->svm_port % (VSOCK_HASH_SIZE - 1))
153#define vsock_bound_sockets(addr) (&vsock_bind_table[VSOCK_HASH(addr)])
154#define vsock_unbound_sockets (&vsock_bind_table[VSOCK_HASH_SIZE])
155
156/* XXX This can probably be implemented in a better way. */
157#define VSOCK_CONN_HASH(src, dst) \
158 (((src)->svm_cid ^ (dst)->svm_port) % (VSOCK_HASH_SIZE - 1))
159#define vsock_connected_sockets(src, dst) \
160 (&vsock_connected_table[VSOCK_CONN_HASH(src, dst)])
161#define vsock_connected_sockets_vsk(vsk) \
162 vsock_connected_sockets(&(vsk)->remote_addr, &(vsk)->local_addr)
163
164static struct list_head vsock_bind_table[VSOCK_HASH_SIZE + 1];
165static struct list_head vsock_connected_table[VSOCK_HASH_SIZE];
166static DEFINE_SPINLOCK(vsock_table_lock);
167
168static __init void vsock_init_tables(void)
169{
170 int i;
171
172 for (i = 0; i < ARRAY_SIZE(vsock_bind_table); i++)
173 INIT_LIST_HEAD(&vsock_bind_table[i]);
174
175 for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++)
176 INIT_LIST_HEAD(&vsock_connected_table[i]);
177}
178
179static void __vsock_insert_bound(struct list_head *list,
180 struct vsock_sock *vsk)
181{
182 sock_hold(&vsk->sk);
183 list_add(&vsk->bound_table, list);
184}
185
186static void __vsock_insert_connected(struct list_head *list,
187 struct vsock_sock *vsk)
188{
189 sock_hold(&vsk->sk);
190 list_add(&vsk->connected_table, list);
191}
192
193static void __vsock_remove_bound(struct vsock_sock *vsk)
194{
195 list_del_init(&vsk->bound_table);
196 sock_put(&vsk->sk);
197}
198
199static void __vsock_remove_connected(struct vsock_sock *vsk)
200{
201 list_del_init(&vsk->connected_table);
202 sock_put(&vsk->sk);
203}
204
205static struct sock *__vsock_find_bound_socket(struct sockaddr_vm *addr)
206{
207 struct vsock_sock *vsk;
208
209 list_for_each_entry(vsk, vsock_bound_sockets(addr), bound_table)
210 if (vsock_addr_equals_addr_any(addr, &vsk->local_addr))
211 return sk_vsock(vsk);
212
213 return NULL;
214}
215
216static struct sock *__vsock_find_connected_socket(struct sockaddr_vm *src,
217 struct sockaddr_vm *dst)
218{
219 struct vsock_sock *vsk;
220
221 list_for_each_entry(vsk, vsock_connected_sockets(src, dst),
222 connected_table) {
223 if (vsock_addr_equals_addr(src, &vsk->remote_addr)
224 && vsock_addr_equals_addr(dst, &vsk->local_addr)) {
225 return sk_vsock(vsk);
226 }
227 }
228
229 return NULL;
230}
231
232static bool __vsock_in_bound_table(struct vsock_sock *vsk)
233{
234 return !list_empty(&vsk->bound_table);
235}
236
237static bool __vsock_in_connected_table(struct vsock_sock *vsk)
238{
239 return !list_empty(&vsk->connected_table);
240}
241
242static void vsock_insert_unbound(struct vsock_sock *vsk)
243{
244 spin_lock_bh(&vsock_table_lock);
245 __vsock_insert_bound(vsock_unbound_sockets, vsk);
246 spin_unlock_bh(&vsock_table_lock);
247}
248
249void vsock_insert_connected(struct vsock_sock *vsk)
250{
251 struct list_head *list = vsock_connected_sockets(
252 &vsk->remote_addr, &vsk->local_addr);
253
254 spin_lock_bh(&vsock_table_lock);
255 __vsock_insert_connected(list, vsk);
256 spin_unlock_bh(&vsock_table_lock);
257}
258EXPORT_SYMBOL_GPL(vsock_insert_connected);
259
260void vsock_remove_bound(struct vsock_sock *vsk)
261{
262 spin_lock_bh(&vsock_table_lock);
263 __vsock_remove_bound(vsk);
264 spin_unlock_bh(&vsock_table_lock);
265}
266EXPORT_SYMBOL_GPL(vsock_remove_bound);
267
268void vsock_remove_connected(struct vsock_sock *vsk)
269{
270 spin_lock_bh(&vsock_table_lock);
271 __vsock_remove_connected(vsk);
272 spin_unlock_bh(&vsock_table_lock);
273}
274EXPORT_SYMBOL_GPL(vsock_remove_connected);
275
276struct sock *vsock_find_bound_socket(struct sockaddr_vm *addr)
277{
278 struct sock *sk;
279
280 spin_lock_bh(&vsock_table_lock);
281 sk = __vsock_find_bound_socket(addr);
282 if (sk)
283 sock_hold(sk);
284
285 spin_unlock_bh(&vsock_table_lock);
286
287 return sk;
288}
289EXPORT_SYMBOL_GPL(vsock_find_bound_socket);
290
291struct sock *vsock_find_connected_socket(struct sockaddr_vm *src,
292 struct sockaddr_vm *dst)
293{
294 struct sock *sk;
295
296 spin_lock_bh(&vsock_table_lock);
297 sk = __vsock_find_connected_socket(src, dst);
298 if (sk)
299 sock_hold(sk);
300
301 spin_unlock_bh(&vsock_table_lock);
302
303 return sk;
304}
305EXPORT_SYMBOL_GPL(vsock_find_connected_socket);
306
307static bool vsock_in_bound_table(struct vsock_sock *vsk)
308{
309 bool ret;
310
311 spin_lock_bh(&vsock_table_lock);
312 ret = __vsock_in_bound_table(vsk);
313 spin_unlock_bh(&vsock_table_lock);
314
315 return ret;
316}
317
318static bool vsock_in_connected_table(struct vsock_sock *vsk)
319{
320 bool ret;
321
322 spin_lock_bh(&vsock_table_lock);
323 ret = __vsock_in_connected_table(vsk);
324 spin_unlock_bh(&vsock_table_lock);
325
326 return ret;
327}
328
329void vsock_for_each_connected_socket(void (*fn)(struct sock *sk))
330{
331 int i;
332
333 spin_lock_bh(&vsock_table_lock);
334
335 for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++) {
336 struct vsock_sock *vsk;
337 list_for_each_entry(vsk, &vsock_connected_table[i],
338 connected_table);
339 fn(sk_vsock(vsk));
340 }
341
342 spin_unlock_bh(&vsock_table_lock);
343}
344EXPORT_SYMBOL_GPL(vsock_for_each_connected_socket);
345
346void vsock_add_pending(struct sock *listener, struct sock *pending)
347{
348 struct vsock_sock *vlistener;
349 struct vsock_sock *vpending;
350
351 vlistener = vsock_sk(listener);
352 vpending = vsock_sk(pending);
353
354 sock_hold(pending);
355 sock_hold(listener);
356 list_add_tail(&vpending->pending_links, &vlistener->pending_links);
357}
358EXPORT_SYMBOL_GPL(vsock_add_pending);
359
360void vsock_remove_pending(struct sock *listener, struct sock *pending)
361{
362 struct vsock_sock *vpending = vsock_sk(pending);
363
364 list_del_init(&vpending->pending_links);
365 sock_put(listener);
366 sock_put(pending);
367}
368EXPORT_SYMBOL_GPL(vsock_remove_pending);
369
370void vsock_enqueue_accept(struct sock *listener, struct sock *connected)
371{
372 struct vsock_sock *vlistener;
373 struct vsock_sock *vconnected;
374
375 vlistener = vsock_sk(listener);
376 vconnected = vsock_sk(connected);
377
378 sock_hold(connected);
379 sock_hold(listener);
380 list_add_tail(&vconnected->accept_queue, &vlistener->accept_queue);
381}
382EXPORT_SYMBOL_GPL(vsock_enqueue_accept);
383
384static struct sock *vsock_dequeue_accept(struct sock *listener)
385{
386 struct vsock_sock *vlistener;
387 struct vsock_sock *vconnected;
388
389 vlistener = vsock_sk(listener);
390
391 if (list_empty(&vlistener->accept_queue))
392 return NULL;
393
394 vconnected = list_entry(vlistener->accept_queue.next,
395 struct vsock_sock, accept_queue);
396
397 list_del_init(&vconnected->accept_queue);
398 sock_put(listener);
399 /* The caller will need a reference on the connected socket so we let
400 * it call sock_put().
401 */
402
403 return sk_vsock(vconnected);
404}
405
406static bool vsock_is_accept_queue_empty(struct sock *sk)
407{
408 struct vsock_sock *vsk = vsock_sk(sk);
409 return list_empty(&vsk->accept_queue);
410}
411
412static bool vsock_is_pending(struct sock *sk)
413{
414 struct vsock_sock *vsk = vsock_sk(sk);
415 return !list_empty(&vsk->pending_links);
416}
417
418static int vsock_send_shutdown(struct sock *sk, int mode)
419{
420 return transport->shutdown(vsock_sk(sk), mode);
421}
422
423void vsock_pending_work(struct work_struct *work)
424{
425 struct sock *sk;
426 struct sock *listener;
427 struct vsock_sock *vsk;
428 bool cleanup;
429
430 vsk = container_of(work, struct vsock_sock, dwork.work);
431 sk = sk_vsock(vsk);
432 listener = vsk->listener;
433 cleanup = true;
434
435 lock_sock(listener);
436 lock_sock(sk);
437
438 if (vsock_is_pending(sk)) {
439 vsock_remove_pending(listener, sk);
440 } else if (!vsk->rejected) {
441 /* We are not on the pending list and accept() did not reject
442 * us, so we must have been accepted by our user process. We
443 * just need to drop our references to the sockets and be on
444 * our way.
445 */
446 cleanup = false;
447 goto out;
448 }
449
450 listener->sk_ack_backlog--;
451
452 /* We need to remove ourself from the global connected sockets list so
453 * incoming packets can't find this socket, and to reduce the reference
454 * count.
455 */
456 if (vsock_in_connected_table(vsk))
457 vsock_remove_connected(vsk);
458
459 sk->sk_state = SS_FREE;
460
461out:
462 release_sock(sk);
463 release_sock(listener);
464 if (cleanup)
465 sock_put(sk);
466
467 sock_put(sk);
468 sock_put(listener);
469}
470EXPORT_SYMBOL_GPL(vsock_pending_work);
471
472/**** SOCKET OPERATIONS ****/
473
474static int __vsock_bind_stream(struct vsock_sock *vsk,
475 struct sockaddr_vm *addr)
476{
477 static u32 port = LAST_RESERVED_PORT + 1;
478 struct sockaddr_vm new_addr;
479
480 vsock_addr_init(&new_addr, addr->svm_cid, addr->svm_port);
481
482 if (addr->svm_port == VMADDR_PORT_ANY) {
483 bool found = false;
484 unsigned int i;
485
486 for (i = 0; i < MAX_PORT_RETRIES; i++) {
487 if (port <= LAST_RESERVED_PORT)
488 port = LAST_RESERVED_PORT + 1;
489
490 new_addr.svm_port = port++;
491
492 if (!__vsock_find_bound_socket(&new_addr)) {
493 found = true;
494 break;
495 }
496 }
497
498 if (!found)
499 return -EADDRNOTAVAIL;
500 } else {
501 /* If port is in reserved range, ensure caller
502 * has necessary privileges.
503 */
504 if (addr->svm_port <= LAST_RESERVED_PORT &&
505 !capable(CAP_NET_BIND_SERVICE)) {
506 return -EACCES;
507 }
508
509 if (__vsock_find_bound_socket(&new_addr))
510 return -EADDRINUSE;
511 }
512
513 vsock_addr_init(&vsk->local_addr, new_addr.svm_cid, new_addr.svm_port);
514
515 /* Remove stream sockets from the unbound list and add them to the hash
516 * table for easy lookup by its address. The unbound list is simply an
517 * extra entry at the end of the hash table, a trick used by AF_UNIX.
518 */
519 __vsock_remove_bound(vsk);
520 __vsock_insert_bound(vsock_bound_sockets(&vsk->local_addr), vsk);
521
522 return 0;
523}
524
525static int __vsock_bind_dgram(struct vsock_sock *vsk,
526 struct sockaddr_vm *addr)
527{
528 return transport->dgram_bind(vsk, addr);
529}
530
531static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr)
532{
533 struct vsock_sock *vsk = vsock_sk(sk);
534 u32 cid;
535 int retval;
536
537 /* First ensure this socket isn't already bound. */
538 if (vsock_addr_bound(&vsk->local_addr))
539 return -EINVAL;
540
541 /* Now bind to the provided address or select appropriate values if
542 * none are provided (VMADDR_CID_ANY and VMADDR_PORT_ANY). Note that
543 * like AF_INET prevents binding to a non-local IP address (in most
544 * cases), we only allow binding to the local CID.
545 */
546 cid = transport->get_local_cid();
547 if (addr->svm_cid != cid && addr->svm_cid != VMADDR_CID_ANY)
548 return -EADDRNOTAVAIL;
549
550 switch (sk->sk_socket->type) {
551 case SOCK_STREAM:
552 spin_lock_bh(&vsock_table_lock);
553 retval = __vsock_bind_stream(vsk, addr);
554 spin_unlock_bh(&vsock_table_lock);
555 break;
556
557 case SOCK_DGRAM:
558 retval = __vsock_bind_dgram(vsk, addr);
559 break;
560
561 default:
562 retval = -EINVAL;
563 break;
564 }
565
566 return retval;
567}
568
569struct sock *__vsock_create(struct net *net,
570 struct socket *sock,
571 struct sock *parent,
572 gfp_t priority,
573 unsigned short type)
574{
575 struct sock *sk;
576 struct vsock_sock *psk;
577 struct vsock_sock *vsk;
578
579 sk = sk_alloc(net, AF_VSOCK, priority, &vsock_proto);
580 if (!sk)
581 return NULL;
582
583 sock_init_data(sock, sk);
584
585 /* sk->sk_type is normally set in sock_init_data, but only if sock is
586 * non-NULL. We make sure that our sockets always have a type by
587 * setting it here if needed.
588 */
589 if (!sock)
590 sk->sk_type = type;
591
592 vsk = vsock_sk(sk);
593 vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
594 vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
595
596 sk->sk_destruct = vsock_sk_destruct;
597 sk->sk_backlog_rcv = vsock_queue_rcv_skb;
598 sk->sk_state = 0;
599 sock_reset_flag(sk, SOCK_DONE);
600
601 INIT_LIST_HEAD(&vsk->bound_table);
602 INIT_LIST_HEAD(&vsk->connected_table);
603 vsk->listener = NULL;
604 INIT_LIST_HEAD(&vsk->pending_links);
605 INIT_LIST_HEAD(&vsk->accept_queue);
606 vsk->rejected = false;
607 vsk->sent_request = false;
608 vsk->ignore_connecting_rst = false;
609 vsk->peer_shutdown = 0;
610
611 psk = parent ? vsock_sk(parent) : NULL;
612 if (parent) {
613 vsk->trusted = psk->trusted;
614 vsk->owner = get_cred(psk->owner);
615 vsk->connect_timeout = psk->connect_timeout;
616 } else {
617 vsk->trusted = capable(CAP_NET_ADMIN);
618 vsk->owner = get_current_cred();
619 vsk->connect_timeout = VSOCK_DEFAULT_CONNECT_TIMEOUT;
620 }
621
622 if (transport->init(vsk, psk) < 0) {
623 sk_free(sk);
624 return NULL;
625 }
626
627 if (sock)
628 vsock_insert_unbound(vsk);
629
630 return sk;
631}
632EXPORT_SYMBOL_GPL(__vsock_create);
633
634static void __vsock_release(struct sock *sk)
635{
636 if (sk) {
637 struct sk_buff *skb;
638 struct sock *pending;
639 struct vsock_sock *vsk;
640
641 vsk = vsock_sk(sk);
642 pending = NULL; /* Compiler warning. */
643
644 if (vsock_in_bound_table(vsk))
645 vsock_remove_bound(vsk);
646
647 if (vsock_in_connected_table(vsk))
648 vsock_remove_connected(vsk);
649
650 transport->release(vsk);
651
652 lock_sock(sk);
653 sock_orphan(sk);
654 sk->sk_shutdown = SHUTDOWN_MASK;
655
656 while ((skb = skb_dequeue(&sk->sk_receive_queue)))
657 kfree_skb(skb);
658
659 /* Clean up any sockets that never were accepted. */
660 while ((pending = vsock_dequeue_accept(sk)) != NULL) {
661 __vsock_release(pending);
662 sock_put(pending);
663 }
664
665 release_sock(sk);
666 sock_put(sk);
667 }
668}
669
670static void vsock_sk_destruct(struct sock *sk)
671{
672 struct vsock_sock *vsk = vsock_sk(sk);
673
674 transport->destruct(vsk);
675
676 /* When clearing these addresses, there's no need to set the family and
677 * possibly register the address family with the kernel.
678 */
679 vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
680 vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
681
682 put_cred(vsk->owner);
683}
684
685static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
686{
687 int err;
688
689 err = sock_queue_rcv_skb(sk, skb);
690 if (err)
691 kfree_skb(skb);
692
693 return err;
694}
695
696s64 vsock_stream_has_data(struct vsock_sock *vsk)
697{
698 return transport->stream_has_data(vsk);
699}
700EXPORT_SYMBOL_GPL(vsock_stream_has_data);
701
702s64 vsock_stream_has_space(struct vsock_sock *vsk)
703{
704 return transport->stream_has_space(vsk);
705}
706EXPORT_SYMBOL_GPL(vsock_stream_has_space);
707
708static int vsock_release(struct socket *sock)
709{
710 __vsock_release(sock->sk);
711 sock->sk = NULL;
712 sock->state = SS_FREE;
713
714 return 0;
715}
716
717static int
718vsock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
719{
720 int err;
721 struct sock *sk;
722 struct sockaddr_vm *vm_addr;
723
724 sk = sock->sk;
725
726 if (vsock_addr_cast(addr, addr_len, &vm_addr) != 0)
727 return -EINVAL;
728
729 lock_sock(sk);
730 err = __vsock_bind(sk, vm_addr);
731 release_sock(sk);
732
733 return err;
734}
735
736static int vsock_getname(struct socket *sock,
737 struct sockaddr *addr, int *addr_len, int peer)
738{
739 int err;
740 struct sock *sk;
741 struct vsock_sock *vsk;
742 struct sockaddr_vm *vm_addr;
743
744 sk = sock->sk;
745 vsk = vsock_sk(sk);
746 err = 0;
747
748 lock_sock(sk);
749
750 if (peer) {
751 if (sock->state != SS_CONNECTED) {
752 err = -ENOTCONN;
753 goto out;
754 }
755 vm_addr = &vsk->remote_addr;
756 } else {
757 vm_addr = &vsk->local_addr;
758 }
759
760 if (!vm_addr) {
761 err = -EINVAL;
762 goto out;
763 }
764
765 /* sys_getsockname() and sys_getpeername() pass us a
766 * MAX_SOCK_ADDR-sized buffer and don't set addr_len. Unfortunately
767 * that macro is defined in socket.c instead of .h, so we hardcode its
768 * value here.
769 */
770 BUILD_BUG_ON(sizeof(*vm_addr) > 128);
771 memcpy(addr, vm_addr, sizeof(*vm_addr));
772 *addr_len = sizeof(*vm_addr);
773
774out:
775 release_sock(sk);
776 return err;
777}
778
779static int vsock_shutdown(struct socket *sock, int mode)
780{
781 int err;
782 struct sock *sk;
783
784 /* User level uses SHUT_RD (0) and SHUT_WR (1), but the kernel uses
785 * RCV_SHUTDOWN (1) and SEND_SHUTDOWN (2), so we must increment mode
786 * here like the other address families do. Note also that the
787 * increment makes SHUT_RDWR (2) into RCV_SHUTDOWN | SEND_SHUTDOWN (3),
788 * which is what we want.
789 */
790 mode++;
791
792 if ((mode & ~SHUTDOWN_MASK) || !mode)
793 return -EINVAL;
794
795 /* If this is a STREAM socket and it is not connected then bail out
796 * immediately. If it is a DGRAM socket then we must first kick the
797 * socket so that it wakes up from any sleeping calls, for example
798 * recv(), and then afterwards return the error.
799 */
800
801 sk = sock->sk;
802 if (sock->state == SS_UNCONNECTED) {
803 err = -ENOTCONN;
804 if (sk->sk_type == SOCK_STREAM)
805 return err;
806 } else {
807 sock->state = SS_DISCONNECTING;
808 err = 0;
809 }
810
811 /* Receive and send shutdowns are treated alike. */
812 mode = mode & (RCV_SHUTDOWN | SEND_SHUTDOWN);
813 if (mode) {
814 lock_sock(sk);
815 sk->sk_shutdown |= mode;
816 sk->sk_state_change(sk);
817 release_sock(sk);
818
819 if (sk->sk_type == SOCK_STREAM) {
820 sock_reset_flag(sk, SOCK_DONE);
821 vsock_send_shutdown(sk, mode);
822 }
823 }
824
825 return err;
826}
827
828static unsigned int vsock_poll(struct file *file, struct socket *sock,
829 poll_table *wait)
830{
831 struct sock *sk;
832 unsigned int mask;
833 struct vsock_sock *vsk;
834
835 sk = sock->sk;
836 vsk = vsock_sk(sk);
837
838 poll_wait(file, sk_sleep(sk), wait);
839 mask = 0;
840
841 if (sk->sk_err)
842 /* Signify that there has been an error on this socket. */
843 mask |= POLLERR;
844
845 /* INET sockets treat local write shutdown and peer write shutdown as a
846 * case of POLLHUP set.
847 */
848 if ((sk->sk_shutdown == SHUTDOWN_MASK) ||
849 ((sk->sk_shutdown & SEND_SHUTDOWN) &&
850 (vsk->peer_shutdown & SEND_SHUTDOWN))) {
851 mask |= POLLHUP;
852 }
853
854 if (sk->sk_shutdown & RCV_SHUTDOWN ||
855 vsk->peer_shutdown & SEND_SHUTDOWN) {
856 mask |= POLLRDHUP;
857 }
858
859 if (sock->type == SOCK_DGRAM) {
860 /* For datagram sockets we can read if there is something in
861 * the queue and write as long as the socket isn't shutdown for
862 * sending.
863 */
864 if (!skb_queue_empty(&sk->sk_receive_queue) ||
865 (sk->sk_shutdown & RCV_SHUTDOWN)) {
866 mask |= POLLIN | POLLRDNORM;
867 }
868
869 if (!(sk->sk_shutdown & SEND_SHUTDOWN))
870 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
871
872 } else if (sock->type == SOCK_STREAM) {
873 lock_sock(sk);
874
875 /* Listening sockets that have connections in their accept
876 * queue can be read.
877 */
878 if (sk->sk_state == SS_LISTEN
879 && !vsock_is_accept_queue_empty(sk))
880 mask |= POLLIN | POLLRDNORM;
881
882 /* If there is something in the queue then we can read. */
883 if (transport->stream_is_active(vsk) &&
884 !(sk->sk_shutdown & RCV_SHUTDOWN)) {
885 bool data_ready_now = false;
886 int ret = transport->notify_poll_in(
887 vsk, 1, &data_ready_now);
888 if (ret < 0) {
889 mask |= POLLERR;
890 } else {
891 if (data_ready_now)
892 mask |= POLLIN | POLLRDNORM;
893
894 }
895 }
896
897 /* Sockets whose connections have been closed, reset, or
898 * terminated should also be considered read, and we check the
899 * shutdown flag for that.
900 */
901 if (sk->sk_shutdown & RCV_SHUTDOWN ||
902 vsk->peer_shutdown & SEND_SHUTDOWN) {
903 mask |= POLLIN | POLLRDNORM;
904 }
905
906 /* Connected sockets that can produce data can be written. */
907 if (sk->sk_state == SS_CONNECTED) {
908 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
909 bool space_avail_now = false;
910 int ret = transport->notify_poll_out(
911 vsk, 1, &space_avail_now);
912 if (ret < 0) {
913 mask |= POLLERR;
914 } else {
915 if (space_avail_now)
916 /* Remove POLLWRBAND since INET
917 * sockets are not setting it.
918 */
919 mask |= POLLOUT | POLLWRNORM;
920
921 }
922 }
923 }
924
925 /* Simulate INET socket poll behaviors, which sets
926 * POLLOUT|POLLWRNORM when peer is closed and nothing to read,
927 * but local send is not shutdown.
928 */
929 if (sk->sk_state == SS_UNCONNECTED) {
930 if (!(sk->sk_shutdown & SEND_SHUTDOWN))
931 mask |= POLLOUT | POLLWRNORM;
932
933 }
934
935 release_sock(sk);
936 }
937
938 return mask;
939}
940
941static int vsock_dgram_sendmsg(struct kiocb *kiocb, struct socket *sock,
942 struct msghdr *msg, size_t len)
943{
944 int err;
945 struct sock *sk;
946 struct vsock_sock *vsk;
947 struct sockaddr_vm *remote_addr;
948
949 if (msg->msg_flags & MSG_OOB)
950 return -EOPNOTSUPP;
951
952 /* For now, MSG_DONTWAIT is always assumed... */
953 err = 0;
954 sk = sock->sk;
955 vsk = vsock_sk(sk);
956
957 lock_sock(sk);
958
959 if (!vsock_addr_bound(&vsk->local_addr)) {
960 struct sockaddr_vm local_addr;
961
962 vsock_addr_init(&local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
963 err = __vsock_bind(sk, &local_addr);
964 if (err != 0)
965 goto out;
966
967 }
968
969 /* If the provided message contains an address, use that. Otherwise
970 * fall back on the socket's remote handle (if it has been connected).
971 */
972 if (msg->msg_name &&
973 vsock_addr_cast(msg->msg_name, msg->msg_namelen,
974 &remote_addr) == 0) {
975 /* Ensure this address is of the right type and is a valid
976 * destination.
977 */
978
979 if (remote_addr->svm_cid == VMADDR_CID_ANY)
980 remote_addr->svm_cid = transport->get_local_cid();
981
982 if (!vsock_addr_bound(remote_addr)) {
983 err = -EINVAL;
984 goto out;
985 }
986 } else if (sock->state == SS_CONNECTED) {
987 remote_addr = &vsk->remote_addr;
988
989 if (remote_addr->svm_cid == VMADDR_CID_ANY)
990 remote_addr->svm_cid = transport->get_local_cid();
991
992 /* XXX Should connect() or this function ensure remote_addr is
993 * bound?
994 */
995 if (!vsock_addr_bound(&vsk->remote_addr)) {
996 err = -EINVAL;
997 goto out;
998 }
999 } else {
1000 err = -EINVAL;
1001 goto out;
1002 }
1003
1004 if (!transport->dgram_allow(remote_addr->svm_cid,
1005 remote_addr->svm_port)) {
1006 err = -EINVAL;
1007 goto out;
1008 }
1009
1010 err = transport->dgram_enqueue(vsk, remote_addr, msg->msg_iov, len);
1011
1012out:
1013 release_sock(sk);
1014 return err;
1015}
1016
1017static int vsock_dgram_connect(struct socket *sock,
1018 struct sockaddr *addr, int addr_len, int flags)
1019{
1020 int err;
1021 struct sock *sk;
1022 struct vsock_sock *vsk;
1023 struct sockaddr_vm *remote_addr;
1024
1025 sk = sock->sk;
1026 vsk = vsock_sk(sk);
1027
1028 err = vsock_addr_cast(addr, addr_len, &remote_addr);
1029 if (err == -EAFNOSUPPORT && remote_addr->svm_family == AF_UNSPEC) {
1030 lock_sock(sk);
1031 vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY,
1032 VMADDR_PORT_ANY);
1033 sock->state = SS_UNCONNECTED;
1034 release_sock(sk);
1035 return 0;
1036 } else if (err != 0)
1037 return -EINVAL;
1038
1039 lock_sock(sk);
1040
1041 if (!vsock_addr_bound(&vsk->local_addr)) {
1042 struct sockaddr_vm local_addr;
1043
1044 vsock_addr_init(&local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
1045 err = __vsock_bind(sk, &local_addr);
1046 if (err != 0)
1047 goto out;
1048
1049 }
1050
1051 if (!transport->dgram_allow(remote_addr->svm_cid,
1052 remote_addr->svm_port)) {
1053 err = -EINVAL;
1054 goto out;
1055 }
1056
1057 memcpy(&vsk->remote_addr, remote_addr, sizeof(vsk->remote_addr));
1058 sock->state = SS_CONNECTED;
1059
1060out:
1061 release_sock(sk);
1062 return err;
1063}
1064
1065static int vsock_dgram_recvmsg(struct kiocb *kiocb, struct socket *sock,
1066 struct msghdr *msg, size_t len, int flags)
1067{
1068 return transport->dgram_dequeue(kiocb, vsock_sk(sock->sk), msg, len,
1069 flags);
1070}
1071
1072static const struct proto_ops vsock_dgram_ops = {
1073 .family = PF_VSOCK,
1074 .owner = THIS_MODULE,
1075 .release = vsock_release,
1076 .bind = vsock_bind,
1077 .connect = vsock_dgram_connect,
1078 .socketpair = sock_no_socketpair,
1079 .accept = sock_no_accept,
1080 .getname = vsock_getname,
1081 .poll = vsock_poll,
1082 .ioctl = sock_no_ioctl,
1083 .listen = sock_no_listen,
1084 .shutdown = vsock_shutdown,
1085 .setsockopt = sock_no_setsockopt,
1086 .getsockopt = sock_no_getsockopt,
1087 .sendmsg = vsock_dgram_sendmsg,
1088 .recvmsg = vsock_dgram_recvmsg,
1089 .mmap = sock_no_mmap,
1090 .sendpage = sock_no_sendpage,
1091};
1092
1093static void vsock_connect_timeout(struct work_struct *work)
1094{
1095 struct sock *sk;
1096 struct vsock_sock *vsk;
1097
1098 vsk = container_of(work, struct vsock_sock, dwork.work);
1099 sk = sk_vsock(vsk);
1100
1101 lock_sock(sk);
1102 if (sk->sk_state == SS_CONNECTING &&
1103 (sk->sk_shutdown != SHUTDOWN_MASK)) {
1104 sk->sk_state = SS_UNCONNECTED;
1105 sk->sk_err = ETIMEDOUT;
1106 sk->sk_error_report(sk);
1107 }
1108 release_sock(sk);
1109
1110 sock_put(sk);
1111}
1112
1113static int vsock_stream_connect(struct socket *sock, struct sockaddr *addr,
1114 int addr_len, int flags)
1115{
1116 int err;
1117 struct sock *sk;
1118 struct vsock_sock *vsk;
1119 struct sockaddr_vm *remote_addr;
1120 long timeout;
1121 DEFINE_WAIT(wait);
1122
1123 err = 0;
1124 sk = sock->sk;
1125 vsk = vsock_sk(sk);
1126
1127 lock_sock(sk);
1128
1129 /* XXX AF_UNSPEC should make us disconnect like AF_INET. */
1130 switch (sock->state) {
1131 case SS_CONNECTED:
1132 err = -EISCONN;
1133 goto out;
1134 case SS_DISCONNECTING:
1135 err = -EINVAL;
1136 goto out;
1137 case SS_CONNECTING:
1138 /* This continues on so we can move sock into the SS_CONNECTED
1139 * state once the connection has completed (at which point err
1140 * will be set to zero also). Otherwise, we will either wait
1141 * for the connection or return -EALREADY should this be a
1142 * non-blocking call.
1143 */
1144 err = -EALREADY;
1145 break;
1146 default:
1147 if ((sk->sk_state == SS_LISTEN) ||
1148 vsock_addr_cast(addr, addr_len, &remote_addr) != 0) {
1149 err = -EINVAL;
1150 goto out;
1151 }
1152
1153 /* The hypervisor and well-known contexts do not have socket
1154 * endpoints.
1155 */
1156 if (!transport->stream_allow(remote_addr->svm_cid,
1157 remote_addr->svm_port)) {
1158 err = -ENETUNREACH;
1159 goto out;
1160 }
1161
1162 /* Set the remote address that we are connecting to. */
1163 memcpy(&vsk->remote_addr, remote_addr,
1164 sizeof(vsk->remote_addr));
1165
1166 /* Autobind this socket to the local address if necessary. */
1167 if (!vsock_addr_bound(&vsk->local_addr)) {
1168 struct sockaddr_vm local_addr;
1169
1170 vsock_addr_init(&local_addr, VMADDR_CID_ANY,
1171 VMADDR_PORT_ANY);
1172 err = __vsock_bind(sk, &local_addr);
1173 if (err != 0)
1174 goto out;
1175
1176 }
1177
1178 sk->sk_state = SS_CONNECTING;
1179
1180 err = transport->connect(vsk);
1181 if (err < 0)
1182 goto out;
1183
1184 /* Mark sock as connecting and set the error code to in
1185 * progress in case this is a non-blocking connect.
1186 */
1187 sock->state = SS_CONNECTING;
1188 err = -EINPROGRESS;
1189 }
1190
1191 /* The receive path will handle all communication until we are able to
1192 * enter the connected state. Here we wait for the connection to be
1193 * completed or a notification of an error.
1194 */
1195 timeout = vsk->connect_timeout;
1196 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1197
1198 while (sk->sk_state != SS_CONNECTED && sk->sk_err == 0) {
1199 if (flags & O_NONBLOCK) {
1200 /* If we're not going to block, we schedule a timeout
1201 * function to generate a timeout on the connection
1202 * attempt, in case the peer doesn't respond in a
1203 * timely manner. We hold on to the socket until the
1204 * timeout fires.
1205 */
1206 sock_hold(sk);
1207 INIT_DELAYED_WORK(&vsk->dwork,
1208 vsock_connect_timeout);
1209 schedule_delayed_work(&vsk->dwork, timeout);
1210
1211 /* Skip ahead to preserve error code set above. */
1212 goto out_wait;
1213 }
1214
1215 release_sock(sk);
1216 timeout = schedule_timeout(timeout);
1217 lock_sock(sk);
1218
1219 if (signal_pending(current)) {
1220 err = sock_intr_errno(timeout);
1221 goto out_wait_error;
1222 } else if (timeout == 0) {
1223 err = -ETIMEDOUT;
1224 goto out_wait_error;
1225 }
1226
1227 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1228 }
1229
1230 if (sk->sk_err) {
1231 err = -sk->sk_err;
1232 goto out_wait_error;
1233 } else
1234 err = 0;
1235
1236out_wait:
1237 finish_wait(sk_sleep(sk), &wait);
1238out:
1239 release_sock(sk);
1240 return err;
1241
1242out_wait_error:
1243 sk->sk_state = SS_UNCONNECTED;
1244 sock->state = SS_UNCONNECTED;
1245 goto out_wait;
1246}
1247
1248static int vsock_accept(struct socket *sock, struct socket *newsock, int flags)
1249{
1250 struct sock *listener;
1251 int err;
1252 struct sock *connected;
1253 struct vsock_sock *vconnected;
1254 long timeout;
1255 DEFINE_WAIT(wait);
1256
1257 err = 0;
1258 listener = sock->sk;
1259
1260 lock_sock(listener);
1261
1262 if (sock->type != SOCK_STREAM) {
1263 err = -EOPNOTSUPP;
1264 goto out;
1265 }
1266
1267 if (listener->sk_state != SS_LISTEN) {
1268 err = -EINVAL;
1269 goto out;
1270 }
1271
1272 /* Wait for children sockets to appear; these are the new sockets
1273 * created upon connection establishment.
1274 */
1275 timeout = sock_sndtimeo(listener, flags & O_NONBLOCK);
1276 prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE);
1277
1278 while ((connected = vsock_dequeue_accept(listener)) == NULL &&
1279 listener->sk_err == 0) {
1280 release_sock(listener);
1281 timeout = schedule_timeout(timeout);
1282 lock_sock(listener);
1283
1284 if (signal_pending(current)) {
1285 err = sock_intr_errno(timeout);
1286 goto out_wait;
1287 } else if (timeout == 0) {
1288 err = -EAGAIN;
1289 goto out_wait;
1290 }
1291
1292 prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE);
1293 }
1294
1295 if (listener->sk_err)
1296 err = -listener->sk_err;
1297
1298 if (connected) {
1299 listener->sk_ack_backlog--;
1300
1301 lock_sock(connected);
1302 vconnected = vsock_sk(connected);
1303
1304 /* If the listener socket has received an error, then we should
1305 * reject this socket and return. Note that we simply mark the
1306 * socket rejected, drop our reference, and let the cleanup
1307 * function handle the cleanup; the fact that we found it in
1308 * the listener's accept queue guarantees that the cleanup
1309 * function hasn't run yet.
1310 */
1311 if (err) {
1312 vconnected->rejected = true;
1313 release_sock(connected);
1314 sock_put(connected);
1315 goto out_wait;
1316 }
1317
1318 newsock->state = SS_CONNECTED;
1319 sock_graft(connected, newsock);
1320 release_sock(connected);
1321 sock_put(connected);
1322 }
1323
1324out_wait:
1325 finish_wait(sk_sleep(listener), &wait);
1326out:
1327 release_sock(listener);
1328 return err;
1329}
1330
1331static int vsock_listen(struct socket *sock, int backlog)
1332{
1333 int err;
1334 struct sock *sk;
1335 struct vsock_sock *vsk;
1336
1337 sk = sock->sk;
1338
1339 lock_sock(sk);
1340
1341 if (sock->type != SOCK_STREAM) {
1342 err = -EOPNOTSUPP;
1343 goto out;
1344 }
1345
1346 if (sock->state != SS_UNCONNECTED) {
1347 err = -EINVAL;
1348 goto out;
1349 }
1350
1351 vsk = vsock_sk(sk);
1352
1353 if (!vsock_addr_bound(&vsk->local_addr)) {
1354 err = -EINVAL;
1355 goto out;
1356 }
1357
1358 sk->sk_max_ack_backlog = backlog;
1359 sk->sk_state = SS_LISTEN;
1360
1361 err = 0;
1362
1363out:
1364 release_sock(sk);
1365 return err;
1366}
1367
1368static int vsock_stream_setsockopt(struct socket *sock,
1369 int level,
1370 int optname,
1371 char __user *optval,
1372 unsigned int optlen)
1373{
1374 int err;
1375 struct sock *sk;
1376 struct vsock_sock *vsk;
1377 u64 val;
1378
1379 if (level != AF_VSOCK)
1380 return -ENOPROTOOPT;
1381
1382#define COPY_IN(_v) \
1383 do { \
1384 if (optlen < sizeof(_v)) { \
1385 err = -EINVAL; \
1386 goto exit; \
1387 } \
1388 if (copy_from_user(&_v, optval, sizeof(_v)) != 0) { \
1389 err = -EFAULT; \
1390 goto exit; \
1391 } \
1392 } while (0)
1393
1394 err = 0;
1395 sk = sock->sk;
1396 vsk = vsock_sk(sk);
1397
1398 lock_sock(sk);
1399
1400 switch (optname) {
1401 case SO_VM_SOCKETS_BUFFER_SIZE:
1402 COPY_IN(val);
1403 transport->set_buffer_size(vsk, val);
1404 break;
1405
1406 case SO_VM_SOCKETS_BUFFER_MAX_SIZE:
1407 COPY_IN(val);
1408 transport->set_max_buffer_size(vsk, val);
1409 break;
1410
1411 case SO_VM_SOCKETS_BUFFER_MIN_SIZE:
1412 COPY_IN(val);
1413 transport->set_min_buffer_size(vsk, val);
1414 break;
1415
1416 case SO_VM_SOCKETS_CONNECT_TIMEOUT: {
1417 struct timeval tv;
1418 COPY_IN(tv);
1419 if (tv.tv_sec >= 0 && tv.tv_usec < USEC_PER_SEC &&
1420 tv.tv_sec < (MAX_SCHEDULE_TIMEOUT / HZ - 1)) {
1421 vsk->connect_timeout = tv.tv_sec * HZ +
1422 DIV_ROUND_UP(tv.tv_usec, (1000000 / HZ));
1423 if (vsk->connect_timeout == 0)
1424 vsk->connect_timeout =
1425 VSOCK_DEFAULT_CONNECT_TIMEOUT;
1426
1427 } else {
1428 err = -ERANGE;
1429 }
1430 break;
1431 }
1432
1433 default:
1434 err = -ENOPROTOOPT;
1435 break;
1436 }
1437
1438#undef COPY_IN
1439
1440exit:
1441 release_sock(sk);
1442 return err;
1443}
1444
1445static int vsock_stream_getsockopt(struct socket *sock,
1446 int level, int optname,
1447 char __user *optval,
1448 int __user *optlen)
1449{
1450 int err;
1451 int len;
1452 struct sock *sk;
1453 struct vsock_sock *vsk;
1454 u64 val;
1455
1456 if (level != AF_VSOCK)
1457 return -ENOPROTOOPT;
1458
1459 err = get_user(len, optlen);
1460 if (err != 0)
1461 return err;
1462
1463#define COPY_OUT(_v) \
1464 do { \
1465 if (len < sizeof(_v)) \
1466 return -EINVAL; \
1467 \
1468 len = sizeof(_v); \
1469 if (copy_to_user(optval, &_v, len) != 0) \
1470 return -EFAULT; \
1471 \
1472 } while (0)
1473
1474 err = 0;
1475 sk = sock->sk;
1476 vsk = vsock_sk(sk);
1477
1478 switch (optname) {
1479 case SO_VM_SOCKETS_BUFFER_SIZE:
1480 val = transport->get_buffer_size(vsk);
1481 COPY_OUT(val);
1482 break;
1483
1484 case SO_VM_SOCKETS_BUFFER_MAX_SIZE:
1485 val = transport->get_max_buffer_size(vsk);
1486 COPY_OUT(val);
1487 break;
1488
1489 case SO_VM_SOCKETS_BUFFER_MIN_SIZE:
1490 val = transport->get_min_buffer_size(vsk);
1491 COPY_OUT(val);
1492 break;
1493
1494 case SO_VM_SOCKETS_CONNECT_TIMEOUT: {
1495 struct timeval tv;
1496 tv.tv_sec = vsk->connect_timeout / HZ;
1497 tv.tv_usec =
1498 (vsk->connect_timeout -
1499 tv.tv_sec * HZ) * (1000000 / HZ);
1500 COPY_OUT(tv);
1501 break;
1502 }
1503 default:
1504 return -ENOPROTOOPT;
1505 }
1506
1507 err = put_user(len, optlen);
1508 if (err != 0)
1509 return -EFAULT;
1510
1511#undef COPY_OUT
1512
1513 return 0;
1514}
1515
1516static int vsock_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
1517 struct msghdr *msg, size_t len)
1518{
1519 struct sock *sk;
1520 struct vsock_sock *vsk;
1521 ssize_t total_written;
1522 long timeout;
1523 int err;
1524 struct vsock_transport_send_notify_data send_data;
1525
1526 DEFINE_WAIT(wait);
1527
1528 sk = sock->sk;
1529 vsk = vsock_sk(sk);
1530 total_written = 0;
1531 err = 0;
1532
1533 if (msg->msg_flags & MSG_OOB)
1534 return -EOPNOTSUPP;
1535
1536 lock_sock(sk);
1537
1538 /* Callers should not provide a destination with stream sockets. */
1539 if (msg->msg_namelen) {
1540 err = sk->sk_state == SS_CONNECTED ? -EISCONN : -EOPNOTSUPP;
1541 goto out;
1542 }
1543
1544 /* Send data only if both sides are not shutdown in the direction. */
1545 if (sk->sk_shutdown & SEND_SHUTDOWN ||
1546 vsk->peer_shutdown & RCV_SHUTDOWN) {
1547 err = -EPIPE;
1548 goto out;
1549 }
1550
1551 if (sk->sk_state != SS_CONNECTED ||
1552 !vsock_addr_bound(&vsk->local_addr)) {
1553 err = -ENOTCONN;
1554 goto out;
1555 }
1556
1557 if (!vsock_addr_bound(&vsk->remote_addr)) {
1558 err = -EDESTADDRREQ;
1559 goto out;
1560 }
1561
1562 /* Wait for room in the produce queue to enqueue our user's data. */
1563 timeout = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1564
1565 err = transport->notify_send_init(vsk, &send_data);
1566 if (err < 0)
1567 goto out;
1568
1569 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1570
1571 while (total_written < len) {
1572 ssize_t written;
1573
1574 while (vsock_stream_has_space(vsk) == 0 &&
1575 sk->sk_err == 0 &&
1576 !(sk->sk_shutdown & SEND_SHUTDOWN) &&
1577 !(vsk->peer_shutdown & RCV_SHUTDOWN)) {
1578
1579 /* Don't wait for non-blocking sockets. */
1580 if (timeout == 0) {
1581 err = -EAGAIN;
1582 goto out_wait;
1583 }
1584
1585 err = transport->notify_send_pre_block(vsk, &send_data);
1586 if (err < 0)
1587 goto out_wait;
1588
1589 release_sock(sk);
1590 timeout = schedule_timeout(timeout);
1591 lock_sock(sk);
1592 if (signal_pending(current)) {
1593 err = sock_intr_errno(timeout);
1594 goto out_wait;
1595 } else if (timeout == 0) {
1596 err = -EAGAIN;
1597 goto out_wait;
1598 }
1599
1600 prepare_to_wait(sk_sleep(sk), &wait,
1601 TASK_INTERRUPTIBLE);
1602 }
1603
1604 /* These checks occur both as part of and after the loop
1605 * conditional since we need to check before and after
1606 * sleeping.
1607 */
1608 if (sk->sk_err) {
1609 err = -sk->sk_err;
1610 goto out_wait;
1611 } else if ((sk->sk_shutdown & SEND_SHUTDOWN) ||
1612 (vsk->peer_shutdown & RCV_SHUTDOWN)) {
1613 err = -EPIPE;
1614 goto out_wait;
1615 }
1616
1617 err = transport->notify_send_pre_enqueue(vsk, &send_data);
1618 if (err < 0)
1619 goto out_wait;
1620
1621 /* Note that enqueue will only write as many bytes as are free
1622 * in the produce queue, so we don't need to ensure len is
1623 * smaller than the queue size. It is the caller's
1624 * responsibility to check how many bytes we were able to send.
1625 */
1626
1627 written = transport->stream_enqueue(
1628 vsk, msg->msg_iov,
1629 len - total_written);
1630 if (written < 0) {
1631 err = -ENOMEM;
1632 goto out_wait;
1633 }
1634
1635 total_written += written;
1636
1637 err = transport->notify_send_post_enqueue(
1638 vsk, written, &send_data);
1639 if (err < 0)
1640 goto out_wait;
1641
1642 }
1643
1644out_wait:
1645 if (total_written > 0)
1646 err = total_written;
1647 finish_wait(sk_sleep(sk), &wait);
1648out:
1649 release_sock(sk);
1650 return err;
1651}
1652
1653
1654static int
1655vsock_stream_recvmsg(struct kiocb *kiocb,
1656 struct socket *sock,
1657 struct msghdr *msg, size_t len, int flags)
1658{
1659 struct sock *sk;
1660 struct vsock_sock *vsk;
1661 int err;
1662 size_t target;
1663 ssize_t copied;
1664 long timeout;
1665 struct vsock_transport_recv_notify_data recv_data;
1666
1667 DEFINE_WAIT(wait);
1668
1669 sk = sock->sk;
1670 vsk = vsock_sk(sk);
1671 err = 0;
1672
1673 lock_sock(sk);
1674
1675 if (sk->sk_state != SS_CONNECTED) {
1676 /* Recvmsg is supposed to return 0 if a peer performs an
1677 * orderly shutdown. Differentiate between that case and when a
1678 * peer has not connected or a local shutdown occured with the
1679 * SOCK_DONE flag.
1680 */
1681 if (sock_flag(sk, SOCK_DONE))
1682 err = 0;
1683 else
1684 err = -ENOTCONN;
1685
1686 goto out;
1687 }
1688
1689 if (flags & MSG_OOB) {
1690 err = -EOPNOTSUPP;
1691 goto out;
1692 }
1693
1694 /* We don't check peer_shutdown flag here since peer may actually shut
1695 * down, but there can be data in the queue that a local socket can
1696 * receive.
1697 */
1698 if (sk->sk_shutdown & RCV_SHUTDOWN) {
1699 err = 0;
1700 goto out;
1701 }
1702
1703 /* It is valid on Linux to pass in a zero-length receive buffer. This
1704 * is not an error. We may as well bail out now.
1705 */
1706 if (!len) {
1707 err = 0;
1708 goto out;
1709 }
1710
1711 /* We must not copy less than target bytes into the user's buffer
1712 * before returning successfully, so we wait for the consume queue to
1713 * have that much data to consume before dequeueing. Note that this
1714 * makes it impossible to handle cases where target is greater than the
1715 * queue size.
1716 */
1717 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
1718 if (target >= transport->stream_rcvhiwat(vsk)) {
1719 err = -ENOMEM;
1720 goto out;
1721 }
1722 timeout = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
1723 copied = 0;
1724
1725 err = transport->notify_recv_init(vsk, target, &recv_data);
1726 if (err < 0)
1727 goto out;
1728
1729 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1730
1731 while (1) {
1732 s64 ready = vsock_stream_has_data(vsk);
1733
1734 if (ready < 0) {
1735 /* Invalid queue pair content. XXX This should be
1736 * changed to a connection reset in a later change.
1737 */
1738
1739 err = -ENOMEM;
1740 goto out_wait;
1741 } else if (ready > 0) {
1742 ssize_t read;
1743
1744 err = transport->notify_recv_pre_dequeue(
1745 vsk, target, &recv_data);
1746 if (err < 0)
1747 break;
1748
1749 read = transport->stream_dequeue(
1750 vsk, msg->msg_iov,
1751 len - copied, flags);
1752 if (read < 0) {
1753 err = -ENOMEM;
1754 break;
1755 }
1756
1757 copied += read;
1758
1759 err = transport->notify_recv_post_dequeue(
1760 vsk, target, read,
1761 !(flags & MSG_PEEK), &recv_data);
1762 if (err < 0)
1763 goto out_wait;
1764
1765 if (read >= target || flags & MSG_PEEK)
1766 break;
1767
1768 target -= read;
1769 } else {
1770 if (sk->sk_err != 0 || (sk->sk_shutdown & RCV_SHUTDOWN)
1771 || (vsk->peer_shutdown & SEND_SHUTDOWN)) {
1772 break;
1773 }
1774 /* Don't wait for non-blocking sockets. */
1775 if (timeout == 0) {
1776 err = -EAGAIN;
1777 break;
1778 }
1779
1780 err = transport->notify_recv_pre_block(
1781 vsk, target, &recv_data);
1782 if (err < 0)
1783 break;
1784
1785 release_sock(sk);
1786 timeout = schedule_timeout(timeout);
1787 lock_sock(sk);
1788
1789 if (signal_pending(current)) {
1790 err = sock_intr_errno(timeout);
1791 break;
1792 } else if (timeout == 0) {
1793 err = -EAGAIN;
1794 break;
1795 }
1796
1797 prepare_to_wait(sk_sleep(sk), &wait,
1798 TASK_INTERRUPTIBLE);
1799 }
1800 }
1801
1802 if (sk->sk_err)
1803 err = -sk->sk_err;
1804 else if (sk->sk_shutdown & RCV_SHUTDOWN)
1805 err = 0;
1806
1807 if (copied > 0) {
1808 /* We only do these additional bookkeeping/notification steps
1809 * if we actually copied something out of the queue pair
1810 * instead of just peeking ahead.
1811 */
1812
1813 if (!(flags & MSG_PEEK)) {
1814 /* If the other side has shutdown for sending and there
1815 * is nothing more to read, then modify the socket
1816 * state.
1817 */
1818 if (vsk->peer_shutdown & SEND_SHUTDOWN) {
1819 if (vsock_stream_has_data(vsk) <= 0) {
1820 sk->sk_state = SS_UNCONNECTED;
1821 sock_set_flag(sk, SOCK_DONE);
1822 sk->sk_state_change(sk);
1823 }
1824 }
1825 }
1826 err = copied;
1827 }
1828
1829out_wait:
1830 finish_wait(sk_sleep(sk), &wait);
1831out:
1832 release_sock(sk);
1833 return err;
1834}
1835
1836static const struct proto_ops vsock_stream_ops = {
1837 .family = PF_VSOCK,
1838 .owner = THIS_MODULE,
1839 .release = vsock_release,
1840 .bind = vsock_bind,
1841 .connect = vsock_stream_connect,
1842 .socketpair = sock_no_socketpair,
1843 .accept = vsock_accept,
1844 .getname = vsock_getname,
1845 .poll = vsock_poll,
1846 .ioctl = sock_no_ioctl,
1847 .listen = vsock_listen,
1848 .shutdown = vsock_shutdown,
1849 .setsockopt = vsock_stream_setsockopt,
1850 .getsockopt = vsock_stream_getsockopt,
1851 .sendmsg = vsock_stream_sendmsg,
1852 .recvmsg = vsock_stream_recvmsg,
1853 .mmap = sock_no_mmap,
1854 .sendpage = sock_no_sendpage,
1855};
1856
1857static int vsock_create(struct net *net, struct socket *sock,
1858 int protocol, int kern)
1859{
1860 if (!sock)
1861 return -EINVAL;
1862
1863 if (protocol && protocol != PF_VSOCK)
1864 return -EPROTONOSUPPORT;
1865
1866 switch (sock->type) {
1867 case SOCK_DGRAM:
1868 sock->ops = &vsock_dgram_ops;
1869 break;
1870 case SOCK_STREAM:
1871 sock->ops = &vsock_stream_ops;
1872 break;
1873 default:
1874 return -ESOCKTNOSUPPORT;
1875 }
1876
1877 sock->state = SS_UNCONNECTED;
1878
1879 return __vsock_create(net, sock, NULL, GFP_KERNEL, 0) ? 0 : -ENOMEM;
1880}
1881
1882static const struct net_proto_family vsock_family_ops = {
1883 .family = AF_VSOCK,
1884 .create = vsock_create,
1885 .owner = THIS_MODULE,
1886};
1887
1888static long vsock_dev_do_ioctl(struct file *filp,
1889 unsigned int cmd, void __user *ptr)
1890{
1891 u32 __user *p = ptr;
1892 int retval = 0;
1893
1894 switch (cmd) {
1895 case IOCTL_VM_SOCKETS_GET_LOCAL_CID:
1896 if (put_user(transport->get_local_cid(), p) != 0)
1897 retval = -EFAULT;
1898 break;
1899
1900 default:
1901 pr_err("Unknown ioctl %d\n", cmd);
1902 retval = -EINVAL;
1903 }
1904
1905 return retval;
1906}
1907
1908static long vsock_dev_ioctl(struct file *filp,
1909 unsigned int cmd, unsigned long arg)
1910{
1911 return vsock_dev_do_ioctl(filp, cmd, (void __user *)arg);
1912}
1913
1914#ifdef CONFIG_COMPAT
1915static long vsock_dev_compat_ioctl(struct file *filp,
1916 unsigned int cmd, unsigned long arg)
1917{
1918 return vsock_dev_do_ioctl(filp, cmd, compat_ptr(arg));
1919}
1920#endif
1921
1922static const struct file_operations vsock_device_ops = {
1923 .owner = THIS_MODULE,
1924 .unlocked_ioctl = vsock_dev_ioctl,
1925#ifdef CONFIG_COMPAT
1926 .compat_ioctl = vsock_dev_compat_ioctl,
1927#endif
1928 .open = nonseekable_open,
1929};
1930
1931static struct miscdevice vsock_device = {
1932 .name = "vsock",
1933 .minor = MISC_DYNAMIC_MINOR,
1934 .fops = &vsock_device_ops,
1935};
1936
1937static int __vsock_core_init(void)
1938{
1939 int err;
1940
1941 vsock_init_tables();
1942
1943 err = misc_register(&vsock_device);
1944 if (err) {
1945 pr_err("Failed to register misc device\n");
1946 return -ENOENT;
1947 }
1948
1949 err = proto_register(&vsock_proto, 1); /* we want our slab */
1950 if (err) {
1951 pr_err("Cannot register vsock protocol\n");
1952 goto err_misc_deregister;
1953 }
1954
1955 err = sock_register(&vsock_family_ops);
1956 if (err) {
1957 pr_err("could not register af_vsock (%d) address family: %d\n",
1958 AF_VSOCK, err);
1959 goto err_unregister_proto;
1960 }
1961
1962 return 0;
1963
1964err_unregister_proto:
1965 proto_unregister(&vsock_proto);
1966err_misc_deregister:
1967 misc_deregister(&vsock_device);
1968 return err;
1969}
1970
1971int vsock_core_init(const struct vsock_transport *t)
1972{
1973 int retval = mutex_lock_interruptible(&vsock_register_mutex);
1974 if (retval)
1975 return retval;
1976
1977 if (transport) {
1978 retval = -EBUSY;
1979 goto out;
1980 }
1981
1982 transport = t;
1983 retval = __vsock_core_init();
1984 if (retval)
1985 transport = NULL;
1986
1987out:
1988 mutex_unlock(&vsock_register_mutex);
1989 return retval;
1990}
1991EXPORT_SYMBOL_GPL(vsock_core_init);
1992
1993void vsock_core_exit(void)
1994{
1995 mutex_lock(&vsock_register_mutex);
1996
1997 misc_deregister(&vsock_device);
1998 sock_unregister(AF_VSOCK);
1999 proto_unregister(&vsock_proto);
2000
2001 /* We do not want the assignment below re-ordered. */
2002 mb();
2003 transport = NULL;
2004
2005 mutex_unlock(&vsock_register_mutex);
2006}
2007EXPORT_SYMBOL_GPL(vsock_core_exit);
2008
2009MODULE_AUTHOR("VMware, Inc.");
2010MODULE_DESCRIPTION("VMware Virtual Socket Family");
2011MODULE_VERSION("1.0.0.0-k");
2012MODULE_LICENSE("GPL v2");
diff --git a/net/vmw_vsock/af_vsock.h b/net/vmw_vsock/af_vsock.h
new file mode 100644
index 000000000000..7d64d3609ec9
--- /dev/null
+++ b/net/vmw_vsock/af_vsock.h
@@ -0,0 +1,175 @@
1/*
2 * VMware vSockets Driver
3 *
4 * Copyright (C) 2007-2013 VMware, Inc. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16#ifndef __AF_VSOCK_H__
17#define __AF_VSOCK_H__
18
19#include <linux/kernel.h>
20#include <linux/workqueue.h>
21#include <linux/vm_sockets.h>
22
23#include "vsock_addr.h"
24
25#define LAST_RESERVED_PORT 1023
26
27#define vsock_sk(__sk) ((struct vsock_sock *)__sk)
28#define sk_vsock(__vsk) (&(__vsk)->sk)
29
30struct vsock_sock {
31 /* sk must be the first member. */
32 struct sock sk;
33 struct sockaddr_vm local_addr;
34 struct sockaddr_vm remote_addr;
35 /* Links for the global tables of bound and connected sockets. */
36 struct list_head bound_table;
37 struct list_head connected_table;
38 /* Accessed without the socket lock held. This means it can never be
39 * modified outsided of socket create or destruct.
40 */
41 bool trusted;
42 bool cached_peer_allow_dgram; /* Dgram communication allowed to
43 * cached peer?
44 */
45 u32 cached_peer; /* Context ID of last dgram destination check. */
46 const struct cred *owner;
47 /* Rest are SOCK_STREAM only. */
48 long connect_timeout;
49 /* Listening socket that this came from. */
50 struct sock *listener;
51 /* Used for pending list and accept queue during connection handshake.
52 * The listening socket is the head for both lists. Sockets created
53 * for connection requests are placed in the pending list until they
54 * are connected, at which point they are put in the accept queue list
55 * so they can be accepted in accept(). If accept() cannot accept the
56 * connection, it is marked as rejected so the cleanup function knows
57 * to clean up the socket.
58 */
59 struct list_head pending_links;
60 struct list_head accept_queue;
61 bool rejected;
62 struct delayed_work dwork;
63 u32 peer_shutdown;
64 bool sent_request;
65 bool ignore_connecting_rst;
66
67 /* Private to transport. */
68 void *trans;
69};
70
71s64 vsock_stream_has_data(struct vsock_sock *vsk);
72s64 vsock_stream_has_space(struct vsock_sock *vsk);
73void vsock_pending_work(struct work_struct *work);
74struct sock *__vsock_create(struct net *net,
75 struct socket *sock,
76 struct sock *parent,
77 gfp_t priority, unsigned short type);
78
79/**** TRANSPORT ****/
80
81struct vsock_transport_recv_notify_data {
82 u64 data1; /* Transport-defined. */
83 u64 data2; /* Transport-defined. */
84 bool notify_on_block;
85};
86
87struct vsock_transport_send_notify_data {
88 u64 data1; /* Transport-defined. */
89 u64 data2; /* Transport-defined. */
90};
91
92struct vsock_transport {
93 /* Initialize/tear-down socket. */
94 int (*init)(struct vsock_sock *, struct vsock_sock *);
95 void (*destruct)(struct vsock_sock *);
96 void (*release)(struct vsock_sock *);
97
98 /* Connections. */
99 int (*connect)(struct vsock_sock *);
100
101 /* DGRAM. */
102 int (*dgram_bind)(struct vsock_sock *, struct sockaddr_vm *);
103 int (*dgram_dequeue)(struct kiocb *kiocb, struct vsock_sock *vsk,
104 struct msghdr *msg, size_t len, int flags);
105 int (*dgram_enqueue)(struct vsock_sock *, struct sockaddr_vm *,
106 struct iovec *, size_t len);
107 bool (*dgram_allow)(u32 cid, u32 port);
108
109 /* STREAM. */
110 /* TODO: stream_bind() */
111 ssize_t (*stream_dequeue)(struct vsock_sock *, struct iovec *,
112 size_t len, int flags);
113 ssize_t (*stream_enqueue)(struct vsock_sock *, struct iovec *,
114 size_t len);
115 s64 (*stream_has_data)(struct vsock_sock *);
116 s64 (*stream_has_space)(struct vsock_sock *);
117 u64 (*stream_rcvhiwat)(struct vsock_sock *);
118 bool (*stream_is_active)(struct vsock_sock *);
119 bool (*stream_allow)(u32 cid, u32 port);
120
121 /* Notification. */
122 int (*notify_poll_in)(struct vsock_sock *, size_t, bool *);
123 int (*notify_poll_out)(struct vsock_sock *, size_t, bool *);
124 int (*notify_recv_init)(struct vsock_sock *, size_t,
125 struct vsock_transport_recv_notify_data *);
126 int (*notify_recv_pre_block)(struct vsock_sock *, size_t,
127 struct vsock_transport_recv_notify_data *);
128 int (*notify_recv_pre_dequeue)(struct vsock_sock *, size_t,
129 struct vsock_transport_recv_notify_data *);
130 int (*notify_recv_post_dequeue)(struct vsock_sock *, size_t,
131 ssize_t, bool, struct vsock_transport_recv_notify_data *);
132 int (*notify_send_init)(struct vsock_sock *,
133 struct vsock_transport_send_notify_data *);
134 int (*notify_send_pre_block)(struct vsock_sock *,
135 struct vsock_transport_send_notify_data *);
136 int (*notify_send_pre_enqueue)(struct vsock_sock *,
137 struct vsock_transport_send_notify_data *);
138 int (*notify_send_post_enqueue)(struct vsock_sock *, ssize_t,
139 struct vsock_transport_send_notify_data *);
140
141 /* Shutdown. */
142 int (*shutdown)(struct vsock_sock *, int);
143
144 /* Buffer sizes. */
145 void (*set_buffer_size)(struct vsock_sock *, u64);
146 void (*set_min_buffer_size)(struct vsock_sock *, u64);
147 void (*set_max_buffer_size)(struct vsock_sock *, u64);
148 u64 (*get_buffer_size)(struct vsock_sock *);
149 u64 (*get_min_buffer_size)(struct vsock_sock *);
150 u64 (*get_max_buffer_size)(struct vsock_sock *);
151
152 /* Addressing. */
153 u32 (*get_local_cid)(void);
154};
155
156/**** CORE ****/
157
158int vsock_core_init(const struct vsock_transport *t);
159void vsock_core_exit(void);
160
161/**** UTILS ****/
162
163void vsock_release_pending(struct sock *pending);
164void vsock_add_pending(struct sock *listener, struct sock *pending);
165void vsock_remove_pending(struct sock *listener, struct sock *pending);
166void vsock_enqueue_accept(struct sock *listener, struct sock *connected);
167void vsock_insert_connected(struct vsock_sock *vsk);
168void vsock_remove_bound(struct vsock_sock *vsk);
169void vsock_remove_connected(struct vsock_sock *vsk);
170struct sock *vsock_find_bound_socket(struct sockaddr_vm *addr);
171struct sock *vsock_find_connected_socket(struct sockaddr_vm *src,
172 struct sockaddr_vm *dst);
173void vsock_for_each_connected_socket(void (*fn)(struct sock *sk));
174
175#endif /* __AF_VSOCK_H__ */
diff --git a/net/vmw_vsock/vmci_transport.c b/net/vmw_vsock/vmci_transport.c
new file mode 100644
index 000000000000..a70ace83a153
--- /dev/null
+++ b/net/vmw_vsock/vmci_transport.c
@@ -0,0 +1,2155 @@
1/*
2 * VMware vSockets Driver
3 *
4 * Copyright (C) 2007-2013 VMware, Inc. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16#include <linux/types.h>
17#include <linux/bitops.h>
18#include <linux/cred.h>
19#include <linux/init.h>
20#include <linux/io.h>
21#include <linux/kernel.h>
22#include <linux/kmod.h>
23#include <linux/list.h>
24#include <linux/miscdevice.h>
25#include <linux/module.h>
26#include <linux/mutex.h>
27#include <linux/net.h>
28#include <linux/poll.h>
29#include <linux/skbuff.h>
30#include <linux/smp.h>
31#include <linux/socket.h>
32#include <linux/stddef.h>
33#include <linux/unistd.h>
34#include <linux/wait.h>
35#include <linux/workqueue.h>
36#include <net/sock.h>
37
38#include "af_vsock.h"
39#include "vmci_transport_notify.h"
40
41static int vmci_transport_recv_dgram_cb(void *data, struct vmci_datagram *dg);
42static int vmci_transport_recv_stream_cb(void *data, struct vmci_datagram *dg);
43static void vmci_transport_peer_attach_cb(u32 sub_id,
44 const struct vmci_event_data *ed,
45 void *client_data);
46static void vmci_transport_peer_detach_cb(u32 sub_id,
47 const struct vmci_event_data *ed,
48 void *client_data);
49static void vmci_transport_recv_pkt_work(struct work_struct *work);
50static int vmci_transport_recv_listen(struct sock *sk,
51 struct vmci_transport_packet *pkt);
52static int vmci_transport_recv_connecting_server(
53 struct sock *sk,
54 struct sock *pending,
55 struct vmci_transport_packet *pkt);
56static int vmci_transport_recv_connecting_client(
57 struct sock *sk,
58 struct vmci_transport_packet *pkt);
59static int vmci_transport_recv_connecting_client_negotiate(
60 struct sock *sk,
61 struct vmci_transport_packet *pkt);
62static int vmci_transport_recv_connecting_client_invalid(
63 struct sock *sk,
64 struct vmci_transport_packet *pkt);
65static int vmci_transport_recv_connected(struct sock *sk,
66 struct vmci_transport_packet *pkt);
67static bool vmci_transport_old_proto_override(bool *old_pkt_proto);
68static u16 vmci_transport_new_proto_supported_versions(void);
69static bool vmci_transport_proto_to_notify_struct(struct sock *sk, u16 *proto,
70 bool old_pkt_proto);
71
72struct vmci_transport_recv_pkt_info {
73 struct work_struct work;
74 struct sock *sk;
75 struct vmci_transport_packet pkt;
76};
77
78static struct vmci_handle vmci_transport_stream_handle = { VMCI_INVALID_ID,
79 VMCI_INVALID_ID };
80static u32 vmci_transport_qp_resumed_sub_id = VMCI_INVALID_ID;
81
82static int PROTOCOL_OVERRIDE = -1;
83
84#define VMCI_TRANSPORT_DEFAULT_QP_SIZE_MIN 128
85#define VMCI_TRANSPORT_DEFAULT_QP_SIZE 262144
86#define VMCI_TRANSPORT_DEFAULT_QP_SIZE_MAX 262144
87
88/* The default peer timeout indicates how long we will wait for a peer response
89 * to a control message.
90 */
91#define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ)
92
93#define SS_LISTEN 255
94
95/* Helper function to convert from a VMCI error code to a VSock error code. */
96
97static s32 vmci_transport_error_to_vsock_error(s32 vmci_error)
98{
99 int err;
100
101 switch (vmci_error) {
102 case VMCI_ERROR_NO_MEM:
103 err = ENOMEM;
104 break;
105 case VMCI_ERROR_DUPLICATE_ENTRY:
106 case VMCI_ERROR_ALREADY_EXISTS:
107 err = EADDRINUSE;
108 break;
109 case VMCI_ERROR_NO_ACCESS:
110 err = EPERM;
111 break;
112 case VMCI_ERROR_NO_RESOURCES:
113 err = ENOBUFS;
114 break;
115 case VMCI_ERROR_INVALID_RESOURCE:
116 err = EHOSTUNREACH;
117 break;
118 case VMCI_ERROR_INVALID_ARGS:
119 default:
120 err = EINVAL;
121 }
122
123 return err > 0 ? -err : err;
124}
125
126static inline void
127vmci_transport_packet_init(struct vmci_transport_packet *pkt,
128 struct sockaddr_vm *src,
129 struct sockaddr_vm *dst,
130 u8 type,
131 u64 size,
132 u64 mode,
133 struct vmci_transport_waiting_info *wait,
134 u16 proto,
135 struct vmci_handle handle)
136{
137 /* We register the stream control handler as an any cid handle so we
138 * must always send from a source address of VMADDR_CID_ANY
139 */
140 pkt->dg.src = vmci_make_handle(VMADDR_CID_ANY,
141 VMCI_TRANSPORT_PACKET_RID);
142 pkt->dg.dst = vmci_make_handle(dst->svm_cid,
143 VMCI_TRANSPORT_PACKET_RID);
144 pkt->dg.payload_size = sizeof(*pkt) - sizeof(pkt->dg);
145 pkt->version = VMCI_TRANSPORT_PACKET_VERSION;
146 pkt->type = type;
147 pkt->src_port = src->svm_port;
148 pkt->dst_port = dst->svm_port;
149 memset(&pkt->proto, 0, sizeof(pkt->proto));
150 memset(&pkt->_reserved2, 0, sizeof(pkt->_reserved2));
151
152 switch (pkt->type) {
153 case VMCI_TRANSPORT_PACKET_TYPE_INVALID:
154 pkt->u.size = 0;
155 break;
156
157 case VMCI_TRANSPORT_PACKET_TYPE_REQUEST:
158 case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE:
159 pkt->u.size = size;
160 break;
161
162 case VMCI_TRANSPORT_PACKET_TYPE_OFFER:
163 case VMCI_TRANSPORT_PACKET_TYPE_ATTACH:
164 pkt->u.handle = handle;
165 break;
166
167 case VMCI_TRANSPORT_PACKET_TYPE_WROTE:
168 case VMCI_TRANSPORT_PACKET_TYPE_READ:
169 case VMCI_TRANSPORT_PACKET_TYPE_RST:
170 pkt->u.size = 0;
171 break;
172
173 case VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN:
174 pkt->u.mode = mode;
175 break;
176
177 case VMCI_TRANSPORT_PACKET_TYPE_WAITING_READ:
178 case VMCI_TRANSPORT_PACKET_TYPE_WAITING_WRITE:
179 memcpy(&pkt->u.wait, wait, sizeof(pkt->u.wait));
180 break;
181
182 case VMCI_TRANSPORT_PACKET_TYPE_REQUEST2:
183 case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2:
184 pkt->u.size = size;
185 pkt->proto = proto;
186 break;
187 }
188}
189
190static inline void
191vmci_transport_packet_get_addresses(struct vmci_transport_packet *pkt,
192 struct sockaddr_vm *local,
193 struct sockaddr_vm *remote)
194{
195 vsock_addr_init(local, pkt->dg.dst.context, pkt->dst_port);
196 vsock_addr_init(remote, pkt->dg.src.context, pkt->src_port);
197}
198
199static int
200__vmci_transport_send_control_pkt(struct vmci_transport_packet *pkt,
201 struct sockaddr_vm *src,
202 struct sockaddr_vm *dst,
203 enum vmci_transport_packet_type type,
204 u64 size,
205 u64 mode,
206 struct vmci_transport_waiting_info *wait,
207 u16 proto,
208 struct vmci_handle handle,
209 bool convert_error)
210{
211 int err;
212
213 vmci_transport_packet_init(pkt, src, dst, type, size, mode, wait,
214 proto, handle);
215 err = vmci_datagram_send(&pkt->dg);
216 if (convert_error && (err < 0))
217 return vmci_transport_error_to_vsock_error(err);
218
219 return err;
220}
221
222static int
223vmci_transport_reply_control_pkt_fast(struct vmci_transport_packet *pkt,
224 enum vmci_transport_packet_type type,
225 u64 size,
226 u64 mode,
227 struct vmci_transport_waiting_info *wait,
228 struct vmci_handle handle)
229{
230 struct vmci_transport_packet reply;
231 struct sockaddr_vm src, dst;
232
233 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST) {
234 return 0;
235 } else {
236 vmci_transport_packet_get_addresses(pkt, &src, &dst);
237 return __vmci_transport_send_control_pkt(&reply, &src, &dst,
238 type,
239 size, mode, wait,
240 VSOCK_PROTO_INVALID,
241 handle, true);
242 }
243}
244
245static int
246vmci_transport_send_control_pkt_bh(struct sockaddr_vm *src,
247 struct sockaddr_vm *dst,
248 enum vmci_transport_packet_type type,
249 u64 size,
250 u64 mode,
251 struct vmci_transport_waiting_info *wait,
252 struct vmci_handle handle)
253{
254 /* Note that it is safe to use a single packet across all CPUs since
255 * two tasklets of the same type are guaranteed to not ever run
256 * simultaneously. If that ever changes, or VMCI stops using tasklets,
257 * we can use per-cpu packets.
258 */
259 static struct vmci_transport_packet pkt;
260
261 return __vmci_transport_send_control_pkt(&pkt, src, dst, type,
262 size, mode, wait,
263 VSOCK_PROTO_INVALID, handle,
264 false);
265}
266
267static int
268vmci_transport_send_control_pkt(struct sock *sk,
269 enum vmci_transport_packet_type type,
270 u64 size,
271 u64 mode,
272 struct vmci_transport_waiting_info *wait,
273 u16 proto,
274 struct vmci_handle handle)
275{
276 struct vmci_transport_packet *pkt;
277 struct vsock_sock *vsk;
278 int err;
279
280 vsk = vsock_sk(sk);
281
282 if (!vsock_addr_bound(&vsk->local_addr))
283 return -EINVAL;
284
285 if (!vsock_addr_bound(&vsk->remote_addr))
286 return -EINVAL;
287
288 pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
289 if (!pkt)
290 return -ENOMEM;
291
292 err = __vmci_transport_send_control_pkt(pkt, &vsk->local_addr,
293 &vsk->remote_addr, type, size,
294 mode, wait, proto, handle,
295 true);
296 kfree(pkt);
297
298 return err;
299}
300
301static int vmci_transport_send_reset_bh(struct sockaddr_vm *dst,
302 struct sockaddr_vm *src,
303 struct vmci_transport_packet *pkt)
304{
305 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST)
306 return 0;
307 return vmci_transport_send_control_pkt_bh(
308 dst, src,
309 VMCI_TRANSPORT_PACKET_TYPE_RST, 0,
310 0, NULL, VMCI_INVALID_HANDLE);
311}
312
313static int vmci_transport_send_reset(struct sock *sk,
314 struct vmci_transport_packet *pkt)
315{
316 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST)
317 return 0;
318 return vmci_transport_send_control_pkt(sk,
319 VMCI_TRANSPORT_PACKET_TYPE_RST,
320 0, 0, NULL, VSOCK_PROTO_INVALID,
321 VMCI_INVALID_HANDLE);
322}
323
324static int vmci_transport_send_negotiate(struct sock *sk, size_t size)
325{
326 return vmci_transport_send_control_pkt(
327 sk,
328 VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE,
329 size, 0, NULL,
330 VSOCK_PROTO_INVALID,
331 VMCI_INVALID_HANDLE);
332}
333
334static int vmci_transport_send_negotiate2(struct sock *sk, size_t size,
335 u16 version)
336{
337 return vmci_transport_send_control_pkt(
338 sk,
339 VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2,
340 size, 0, NULL, version,
341 VMCI_INVALID_HANDLE);
342}
343
344static int vmci_transport_send_qp_offer(struct sock *sk,
345 struct vmci_handle handle)
346{
347 return vmci_transport_send_control_pkt(
348 sk, VMCI_TRANSPORT_PACKET_TYPE_OFFER, 0,
349 0, NULL,
350 VSOCK_PROTO_INVALID, handle);
351}
352
353static int vmci_transport_send_attach(struct sock *sk,
354 struct vmci_handle handle)
355{
356 return vmci_transport_send_control_pkt(
357 sk, VMCI_TRANSPORT_PACKET_TYPE_ATTACH,
358 0, 0, NULL, VSOCK_PROTO_INVALID,
359 handle);
360}
361
362static int vmci_transport_reply_reset(struct vmci_transport_packet *pkt)
363{
364 return vmci_transport_reply_control_pkt_fast(
365 pkt,
366 VMCI_TRANSPORT_PACKET_TYPE_RST,
367 0, 0, NULL,
368 VMCI_INVALID_HANDLE);
369}
370
371static int vmci_transport_send_invalid_bh(struct sockaddr_vm *dst,
372 struct sockaddr_vm *src)
373{
374 return vmci_transport_send_control_pkt_bh(
375 dst, src,
376 VMCI_TRANSPORT_PACKET_TYPE_INVALID,
377 0, 0, NULL, VMCI_INVALID_HANDLE);
378}
379
380int vmci_transport_send_wrote_bh(struct sockaddr_vm *dst,
381 struct sockaddr_vm *src)
382{
383 return vmci_transport_send_control_pkt_bh(
384 dst, src,
385 VMCI_TRANSPORT_PACKET_TYPE_WROTE, 0,
386 0, NULL, VMCI_INVALID_HANDLE);
387}
388
389int vmci_transport_send_read_bh(struct sockaddr_vm *dst,
390 struct sockaddr_vm *src)
391{
392 return vmci_transport_send_control_pkt_bh(
393 dst, src,
394 VMCI_TRANSPORT_PACKET_TYPE_READ, 0,
395 0, NULL, VMCI_INVALID_HANDLE);
396}
397
398int vmci_transport_send_wrote(struct sock *sk)
399{
400 return vmci_transport_send_control_pkt(
401 sk, VMCI_TRANSPORT_PACKET_TYPE_WROTE, 0,
402 0, NULL, VSOCK_PROTO_INVALID,
403 VMCI_INVALID_HANDLE);
404}
405
406int vmci_transport_send_read(struct sock *sk)
407{
408 return vmci_transport_send_control_pkt(
409 sk, VMCI_TRANSPORT_PACKET_TYPE_READ, 0,
410 0, NULL, VSOCK_PROTO_INVALID,
411 VMCI_INVALID_HANDLE);
412}
413
414int vmci_transport_send_waiting_write(struct sock *sk,
415 struct vmci_transport_waiting_info *wait)
416{
417 return vmci_transport_send_control_pkt(
418 sk, VMCI_TRANSPORT_PACKET_TYPE_WAITING_WRITE,
419 0, 0, wait, VSOCK_PROTO_INVALID,
420 VMCI_INVALID_HANDLE);
421}
422
423int vmci_transport_send_waiting_read(struct sock *sk,
424 struct vmci_transport_waiting_info *wait)
425{
426 return vmci_transport_send_control_pkt(
427 sk, VMCI_TRANSPORT_PACKET_TYPE_WAITING_READ,
428 0, 0, wait, VSOCK_PROTO_INVALID,
429 VMCI_INVALID_HANDLE);
430}
431
432static int vmci_transport_shutdown(struct vsock_sock *vsk, int mode)
433{
434 return vmci_transport_send_control_pkt(
435 &vsk->sk,
436 VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN,
437 0, mode, NULL,
438 VSOCK_PROTO_INVALID,
439 VMCI_INVALID_HANDLE);
440}
441
442static int vmci_transport_send_conn_request(struct sock *sk, size_t size)
443{
444 return vmci_transport_send_control_pkt(sk,
445 VMCI_TRANSPORT_PACKET_TYPE_REQUEST,
446 size, 0, NULL,
447 VSOCK_PROTO_INVALID,
448 VMCI_INVALID_HANDLE);
449}
450
451static int vmci_transport_send_conn_request2(struct sock *sk, size_t size,
452 u16 version)
453{
454 return vmci_transport_send_control_pkt(
455 sk, VMCI_TRANSPORT_PACKET_TYPE_REQUEST2,
456 size, 0, NULL, version,
457 VMCI_INVALID_HANDLE);
458}
459
460static struct sock *vmci_transport_get_pending(
461 struct sock *listener,
462 struct vmci_transport_packet *pkt)
463{
464 struct vsock_sock *vlistener;
465 struct vsock_sock *vpending;
466 struct sock *pending;
467
468 vlistener = vsock_sk(listener);
469
470 list_for_each_entry(vpending, &vlistener->pending_links,
471 pending_links) {
472 struct sockaddr_vm src;
473 struct sockaddr_vm dst;
474
475 vsock_addr_init(&src, pkt->dg.src.context, pkt->src_port);
476 vsock_addr_init(&dst, pkt->dg.dst.context, pkt->dst_port);
477
478 if (vsock_addr_equals_addr(&src, &vpending->remote_addr) &&
479 vsock_addr_equals_addr(&dst, &vpending->local_addr)) {
480 pending = sk_vsock(vpending);
481 sock_hold(pending);
482 goto found;
483 }
484 }
485
486 pending = NULL;
487found:
488 return pending;
489
490}
491
492static void vmci_transport_release_pending(struct sock *pending)
493{
494 sock_put(pending);
495}
496
497/* We allow two kinds of sockets to communicate with a restricted VM: 1)
498 * trusted sockets 2) sockets from applications running as the same user as the
499 * VM (this is only true for the host side and only when using hosted products)
500 */
501
502static bool vmci_transport_is_trusted(struct vsock_sock *vsock, u32 peer_cid)
503{
504 return vsock->trusted ||
505 vmci_is_context_owner(peer_cid, vsock->owner->uid);
506}
507
508/* We allow sending datagrams to and receiving datagrams from a restricted VM
509 * only if it is trusted as described in vmci_transport_is_trusted.
510 */
511
512static bool vmci_transport_allow_dgram(struct vsock_sock *vsock, u32 peer_cid)
513{
514 if (vsock->cached_peer != peer_cid) {
515 vsock->cached_peer = peer_cid;
516 if (!vmci_transport_is_trusted(vsock, peer_cid) &&
517 (vmci_context_get_priv_flags(peer_cid) &
518 VMCI_PRIVILEGE_FLAG_RESTRICTED)) {
519 vsock->cached_peer_allow_dgram = false;
520 } else {
521 vsock->cached_peer_allow_dgram = true;
522 }
523 }
524
525 return vsock->cached_peer_allow_dgram;
526}
527
528static int
529vmci_transport_queue_pair_alloc(struct vmci_qp **qpair,
530 struct vmci_handle *handle,
531 u64 produce_size,
532 u64 consume_size,
533 u32 peer, u32 flags, bool trusted)
534{
535 int err = 0;
536
537 if (trusted) {
538 /* Try to allocate our queue pair as trusted. This will only
539 * work if vsock is running in the host.
540 */
541
542 err = vmci_qpair_alloc(qpair, handle, produce_size,
543 consume_size,
544 peer, flags,
545 VMCI_PRIVILEGE_FLAG_TRUSTED);
546 if (err != VMCI_ERROR_NO_ACCESS)
547 goto out;
548
549 }
550
551 err = vmci_qpair_alloc(qpair, handle, produce_size, consume_size,
552 peer, flags, VMCI_NO_PRIVILEGE_FLAGS);
553out:
554 if (err < 0) {
555 pr_err("Could not attach to queue pair with %d\n",
556 err);
557 err = vmci_transport_error_to_vsock_error(err);
558 }
559
560 return err;
561}
562
563static int
564vmci_transport_datagram_create_hnd(u32 resource_id,
565 u32 flags,
566 vmci_datagram_recv_cb recv_cb,
567 void *client_data,
568 struct vmci_handle *out_handle)
569{
570 int err = 0;
571
572 /* Try to allocate our datagram handler as trusted. This will only work
573 * if vsock is running in the host.
574 */
575
576 err = vmci_datagram_create_handle_priv(resource_id, flags,
577 VMCI_PRIVILEGE_FLAG_TRUSTED,
578 recv_cb,
579 client_data, out_handle);
580
581 if (err == VMCI_ERROR_NO_ACCESS)
582 err = vmci_datagram_create_handle(resource_id, flags,
583 recv_cb, client_data,
584 out_handle);
585
586 return err;
587}
588
589/* This is invoked as part of a tasklet that's scheduled when the VMCI
590 * interrupt fires. This is run in bottom-half context and if it ever needs to
591 * sleep it should defer that work to a work queue.
592 */
593
594static int vmci_transport_recv_dgram_cb(void *data, struct vmci_datagram *dg)
595{
596 struct sock *sk;
597 size_t size;
598 struct sk_buff *skb;
599 struct vsock_sock *vsk;
600
601 sk = (struct sock *)data;
602
603 /* This handler is privileged when this module is running on the host.
604 * We will get datagrams from all endpoints (even VMs that are in a
605 * restricted context). If we get one from a restricted context then
606 * the destination socket must be trusted.
607 *
608 * NOTE: We access the socket struct without holding the lock here.
609 * This is ok because the field we are interested is never modified
610 * outside of the create and destruct socket functions.
611 */
612 vsk = vsock_sk(sk);
613 if (!vmci_transport_allow_dgram(vsk, dg->src.context))
614 return VMCI_ERROR_NO_ACCESS;
615
616 size = VMCI_DG_SIZE(dg);
617
618 /* Attach the packet to the socket's receive queue as an sk_buff. */
619 skb = alloc_skb(size, GFP_ATOMIC);
620 if (skb) {
621 /* sk_receive_skb() will do a sock_put(), so hold here. */
622 sock_hold(sk);
623 skb_put(skb, size);
624 memcpy(skb->data, dg, size);
625 sk_receive_skb(sk, skb, 0);
626 }
627
628 return VMCI_SUCCESS;
629}
630
631static bool vmci_transport_stream_allow(u32 cid, u32 port)
632{
633 static const u32 non_socket_contexts[] = {
634 VMADDR_CID_HYPERVISOR,
635 VMADDR_CID_RESERVED,
636 };
637 int i;
638
639 BUILD_BUG_ON(sizeof(cid) != sizeof(*non_socket_contexts));
640
641 for (i = 0; i < ARRAY_SIZE(non_socket_contexts); i++) {
642 if (cid == non_socket_contexts[i])
643 return false;
644 }
645
646 return true;
647}
648
649/* This is invoked as part of a tasklet that's scheduled when the VMCI
650 * interrupt fires. This is run in bottom-half context but it defers most of
651 * its work to the packet handling work queue.
652 */
653
654static int vmci_transport_recv_stream_cb(void *data, struct vmci_datagram *dg)
655{
656 struct sock *sk;
657 struct sockaddr_vm dst;
658 struct sockaddr_vm src;
659 struct vmci_transport_packet *pkt;
660 struct vsock_sock *vsk;
661 bool bh_process_pkt;
662 int err;
663
664 sk = NULL;
665 err = VMCI_SUCCESS;
666 bh_process_pkt = false;
667
668 /* Ignore incoming packets from contexts without sockets, or resources
669 * that aren't vsock implementations.
670 */
671
672 if (!vmci_transport_stream_allow(dg->src.context, -1)
673 || VMCI_TRANSPORT_PACKET_RID != dg->src.resource)
674 return VMCI_ERROR_NO_ACCESS;
675
676 if (VMCI_DG_SIZE(dg) < sizeof(*pkt))
677 /* Drop datagrams that do not contain full VSock packets. */
678 return VMCI_ERROR_INVALID_ARGS;
679
680 pkt = (struct vmci_transport_packet *)dg;
681
682 /* Find the socket that should handle this packet. First we look for a
683 * connected socket and if there is none we look for a socket bound to
684 * the destintation address.
685 */
686 vsock_addr_init(&src, pkt->dg.src.context, pkt->src_port);
687 vsock_addr_init(&dst, pkt->dg.dst.context, pkt->dst_port);
688
689 sk = vsock_find_connected_socket(&src, &dst);
690 if (!sk) {
691 sk = vsock_find_bound_socket(&dst);
692 if (!sk) {
693 /* We could not find a socket for this specified
694 * address. If this packet is a RST, we just drop it.
695 * If it is another packet, we send a RST. Note that
696 * we do not send a RST reply to RSTs so that we do not
697 * continually send RSTs between two endpoints.
698 *
699 * Note that since this is a reply, dst is src and src
700 * is dst.
701 */
702 if (vmci_transport_send_reset_bh(&dst, &src, pkt) < 0)
703 pr_err("unable to send reset\n");
704
705 err = VMCI_ERROR_NOT_FOUND;
706 goto out;
707 }
708 }
709
710 /* If the received packet type is beyond all types known to this
711 * implementation, reply with an invalid message. Hopefully this will
712 * help when implementing backwards compatibility in the future.
713 */
714 if (pkt->type >= VMCI_TRANSPORT_PACKET_TYPE_MAX) {
715 vmci_transport_send_invalid_bh(&dst, &src);
716 err = VMCI_ERROR_INVALID_ARGS;
717 goto out;
718 }
719
720 /* This handler is privileged when this module is running on the host.
721 * We will get datagram connect requests from all endpoints (even VMs
722 * that are in a restricted context). If we get one from a restricted
723 * context then the destination socket must be trusted.
724 *
725 * NOTE: We access the socket struct without holding the lock here.
726 * This is ok because the field we are interested is never modified
727 * outside of the create and destruct socket functions.
728 */
729 vsk = vsock_sk(sk);
730 if (!vmci_transport_allow_dgram(vsk, pkt->dg.src.context)) {
731 err = VMCI_ERROR_NO_ACCESS;
732 goto out;
733 }
734
735 /* We do most everything in a work queue, but let's fast path the
736 * notification of reads and writes to help data transfer performance.
737 * We can only do this if there is no process context code executing
738 * for this socket since that may change the state.
739 */
740 bh_lock_sock(sk);
741
742 if (!sock_owned_by_user(sk) && sk->sk_state == SS_CONNECTED)
743 vmci_trans(vsk)->notify_ops->handle_notify_pkt(
744 sk, pkt, true, &dst, &src,
745 &bh_process_pkt);
746
747 bh_unlock_sock(sk);
748
749 if (!bh_process_pkt) {
750 struct vmci_transport_recv_pkt_info *recv_pkt_info;
751
752 recv_pkt_info = kmalloc(sizeof(*recv_pkt_info), GFP_ATOMIC);
753 if (!recv_pkt_info) {
754 if (vmci_transport_send_reset_bh(&dst, &src, pkt) < 0)
755 pr_err("unable to send reset\n");
756
757 err = VMCI_ERROR_NO_MEM;
758 goto out;
759 }
760
761 recv_pkt_info->sk = sk;
762 memcpy(&recv_pkt_info->pkt, pkt, sizeof(recv_pkt_info->pkt));
763 INIT_WORK(&recv_pkt_info->work, vmci_transport_recv_pkt_work);
764
765 schedule_work(&recv_pkt_info->work);
766 /* Clear sk so that the reference count incremented by one of
767 * the Find functions above is not decremented below. We need
768 * that reference count for the packet handler we've scheduled
769 * to run.
770 */
771 sk = NULL;
772 }
773
774out:
775 if (sk)
776 sock_put(sk);
777
778 return err;
779}
780
781static void vmci_transport_peer_attach_cb(u32 sub_id,
782 const struct vmci_event_data *e_data,
783 void *client_data)
784{
785 struct sock *sk = client_data;
786 const struct vmci_event_payload_qp *e_payload;
787 struct vsock_sock *vsk;
788
789 e_payload = vmci_event_data_const_payload(e_data);
790
791 vsk = vsock_sk(sk);
792
793 /* We don't ask for delayed CBs when we subscribe to this event (we
794 * pass 0 as flags to vmci_event_subscribe()). VMCI makes no
795 * guarantees in that case about what context we might be running in,
796 * so it could be BH or process, blockable or non-blockable. So we
797 * need to account for all possible contexts here.
798 */
799 local_bh_disable();
800 bh_lock_sock(sk);
801
802 /* XXX This is lame, we should provide a way to lookup sockets by
803 * qp_handle.
804 */
805 if (vmci_handle_is_equal(vmci_trans(vsk)->qp_handle,
806 e_payload->handle)) {
807 /* XXX This doesn't do anything, but in the future we may want
808 * to set a flag here to verify the attach really did occur and
809 * we weren't just sent a datagram claiming it was.
810 */
811 goto out;
812 }
813
814out:
815 bh_unlock_sock(sk);
816 local_bh_enable();
817}
818
819static void vmci_transport_handle_detach(struct sock *sk)
820{
821 struct vsock_sock *vsk;
822
823 vsk = vsock_sk(sk);
824 if (!vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle)) {
825 sock_set_flag(sk, SOCK_DONE);
826
827 /* On a detach the peer will not be sending or receiving
828 * anymore.
829 */
830 vsk->peer_shutdown = SHUTDOWN_MASK;
831
832 /* We should not be sending anymore since the peer won't be
833 * there to receive, but we can still receive if there is data
834 * left in our consume queue.
835 */
836 if (vsock_stream_has_data(vsk) <= 0) {
837 if (sk->sk_state == SS_CONNECTING) {
838 /* The peer may detach from a queue pair while
839 * we are still in the connecting state, i.e.,
840 * if the peer VM is killed after attaching to
841 * a queue pair, but before we complete the
842 * handshake. In that case, we treat the detach
843 * event like a reset.
844 */
845
846 sk->sk_state = SS_UNCONNECTED;
847 sk->sk_err = ECONNRESET;
848 sk->sk_error_report(sk);
849 return;
850 }
851 sk->sk_state = SS_UNCONNECTED;
852 }
853 sk->sk_state_change(sk);
854 }
855}
856
857static void vmci_transport_peer_detach_cb(u32 sub_id,
858 const struct vmci_event_data *e_data,
859 void *client_data)
860{
861 struct sock *sk = client_data;
862 const struct vmci_event_payload_qp *e_payload;
863 struct vsock_sock *vsk;
864
865 e_payload = vmci_event_data_const_payload(e_data);
866 vsk = vsock_sk(sk);
867 if (vmci_handle_is_invalid(e_payload->handle))
868 return;
869
870 /* Same rules for locking as for peer_attach_cb(). */
871 local_bh_disable();
872 bh_lock_sock(sk);
873
874 /* XXX This is lame, we should provide a way to lookup sockets by
875 * qp_handle.
876 */
877 if (vmci_handle_is_equal(vmci_trans(vsk)->qp_handle,
878 e_payload->handle))
879 vmci_transport_handle_detach(sk);
880
881 bh_unlock_sock(sk);
882 local_bh_enable();
883}
884
885static void vmci_transport_qp_resumed_cb(u32 sub_id,
886 const struct vmci_event_data *e_data,
887 void *client_data)
888{
889 vsock_for_each_connected_socket(vmci_transport_handle_detach);
890}
891
892static void vmci_transport_recv_pkt_work(struct work_struct *work)
893{
894 struct vmci_transport_recv_pkt_info *recv_pkt_info;
895 struct vmci_transport_packet *pkt;
896 struct sock *sk;
897
898 recv_pkt_info =
899 container_of(work, struct vmci_transport_recv_pkt_info, work);
900 sk = recv_pkt_info->sk;
901 pkt = &recv_pkt_info->pkt;
902
903 lock_sock(sk);
904
905 switch (sk->sk_state) {
906 case SS_LISTEN:
907 vmci_transport_recv_listen(sk, pkt);
908 break;
909 case SS_CONNECTING:
910 /* Processing of pending connections for servers goes through
911 * the listening socket, so see vmci_transport_recv_listen()
912 * for that path.
913 */
914 vmci_transport_recv_connecting_client(sk, pkt);
915 break;
916 case SS_CONNECTED:
917 vmci_transport_recv_connected(sk, pkt);
918 break;
919 default:
920 /* Because this function does not run in the same context as
921 * vmci_transport_recv_stream_cb it is possible that the
922 * socket has closed. We need to let the other side know or it
923 * could be sitting in a connect and hang forever. Send a
924 * reset to prevent that.
925 */
926 vmci_transport_send_reset(sk, pkt);
927 goto out;
928 }
929
930out:
931 release_sock(sk);
932 kfree(recv_pkt_info);
933 /* Release reference obtained in the stream callback when we fetched
934 * this socket out of the bound or connected list.
935 */
936 sock_put(sk);
937}
938
939static int vmci_transport_recv_listen(struct sock *sk,
940 struct vmci_transport_packet *pkt)
941{
942 struct sock *pending;
943 struct vsock_sock *vpending;
944 int err;
945 u64 qp_size;
946 bool old_request = false;
947 bool old_pkt_proto = false;
948
949 err = 0;
950
951 /* Because we are in the listen state, we could be receiving a packet
952 * for ourself or any previous connection requests that we received.
953 * If it's the latter, we try to find a socket in our list of pending
954 * connections and, if we do, call the appropriate handler for the
955 * state that that socket is in. Otherwise we try to service the
956 * connection request.
957 */
958 pending = vmci_transport_get_pending(sk, pkt);
959 if (pending) {
960 lock_sock(pending);
961 switch (pending->sk_state) {
962 case SS_CONNECTING:
963 err = vmci_transport_recv_connecting_server(sk,
964 pending,
965 pkt);
966 break;
967 default:
968 vmci_transport_send_reset(pending, pkt);
969 err = -EINVAL;
970 }
971
972 if (err < 0)
973 vsock_remove_pending(sk, pending);
974
975 release_sock(pending);
976 vmci_transport_release_pending(pending);
977
978 return err;
979 }
980
981 /* The listen state only accepts connection requests. Reply with a
982 * reset unless we received a reset.
983 */
984
985 if (!(pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST ||
986 pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST2)) {
987 vmci_transport_reply_reset(pkt);
988 return -EINVAL;
989 }
990
991 if (pkt->u.size == 0) {
992 vmci_transport_reply_reset(pkt);
993 return -EINVAL;
994 }
995
996 /* If this socket can't accommodate this connection request, we send a
997 * reset. Otherwise we create and initialize a child socket and reply
998 * with a connection negotiation.
999 */
1000 if (sk->sk_ack_backlog >= sk->sk_max_ack_backlog) {
1001 vmci_transport_reply_reset(pkt);
1002 return -ECONNREFUSED;
1003 }
1004
1005 pending = __vsock_create(sock_net(sk), NULL, sk, GFP_KERNEL,
1006 sk->sk_type);
1007 if (!pending) {
1008 vmci_transport_send_reset(sk, pkt);
1009 return -ENOMEM;
1010 }
1011
1012 vpending = vsock_sk(pending);
1013
1014 vsock_addr_init(&vpending->local_addr, pkt->dg.dst.context,
1015 pkt->dst_port);
1016 vsock_addr_init(&vpending->remote_addr, pkt->dg.src.context,
1017 pkt->src_port);
1018
1019 /* If the proposed size fits within our min/max, accept it. Otherwise
1020 * propose our own size.
1021 */
1022 if (pkt->u.size >= vmci_trans(vpending)->queue_pair_min_size &&
1023 pkt->u.size <= vmci_trans(vpending)->queue_pair_max_size) {
1024 qp_size = pkt->u.size;
1025 } else {
1026 qp_size = vmci_trans(vpending)->queue_pair_size;
1027 }
1028
1029 /* Figure out if we are using old or new requests based on the
1030 * overrides pkt types sent by our peer.
1031 */
1032 if (vmci_transport_old_proto_override(&old_pkt_proto)) {
1033 old_request = old_pkt_proto;
1034 } else {
1035 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST)
1036 old_request = true;
1037 else if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST2)
1038 old_request = false;
1039
1040 }
1041
1042 if (old_request) {
1043 /* Handle a REQUEST (or override) */
1044 u16 version = VSOCK_PROTO_INVALID;
1045 if (vmci_transport_proto_to_notify_struct(
1046 pending, &version, true))
1047 err = vmci_transport_send_negotiate(pending, qp_size);
1048 else
1049 err = -EINVAL;
1050
1051 } else {
1052 /* Handle a REQUEST2 (or override) */
1053 int proto_int = pkt->proto;
1054 int pos;
1055 u16 active_proto_version = 0;
1056
1057 /* The list of possible protocols is the intersection of all
1058 * protocols the client supports ... plus all the protocols we
1059 * support.
1060 */
1061 proto_int &= vmci_transport_new_proto_supported_versions();
1062
1063 /* We choose the highest possible protocol version and use that
1064 * one.
1065 */
1066 pos = fls(proto_int);
1067 if (pos) {
1068 active_proto_version = (1 << (pos - 1));
1069 if (vmci_transport_proto_to_notify_struct(
1070 pending, &active_proto_version, false))
1071 err = vmci_transport_send_negotiate2(pending,
1072 qp_size,
1073 active_proto_version);
1074 else
1075 err = -EINVAL;
1076
1077 } else {
1078 err = -EINVAL;
1079 }
1080 }
1081
1082 if (err < 0) {
1083 vmci_transport_send_reset(sk, pkt);
1084 sock_put(pending);
1085 err = vmci_transport_error_to_vsock_error(err);
1086 goto out;
1087 }
1088
1089 vsock_add_pending(sk, pending);
1090 sk->sk_ack_backlog++;
1091
1092 pending->sk_state = SS_CONNECTING;
1093 vmci_trans(vpending)->produce_size =
1094 vmci_trans(vpending)->consume_size = qp_size;
1095 vmci_trans(vpending)->queue_pair_size = qp_size;
1096
1097 vmci_trans(vpending)->notify_ops->process_request(pending);
1098
1099 /* We might never receive another message for this socket and it's not
1100 * connected to any process, so we have to ensure it gets cleaned up
1101 * ourself. Our delayed work function will take care of that. Note
1102 * that we do not ever cancel this function since we have few
1103 * guarantees about its state when calling cancel_delayed_work().
1104 * Instead we hold a reference on the socket for that function and make
1105 * it capable of handling cases where it needs to do nothing but
1106 * release that reference.
1107 */
1108 vpending->listener = sk;
1109 sock_hold(sk);
1110 sock_hold(pending);
1111 INIT_DELAYED_WORK(&vpending->dwork, vsock_pending_work);
1112 schedule_delayed_work(&vpending->dwork, HZ);
1113
1114out:
1115 return err;
1116}
1117
1118static int
1119vmci_transport_recv_connecting_server(struct sock *listener,
1120 struct sock *pending,
1121 struct vmci_transport_packet *pkt)
1122{
1123 struct vsock_sock *vpending;
1124 struct vmci_handle handle;
1125 struct vmci_qp *qpair;
1126 bool is_local;
1127 u32 flags;
1128 u32 detach_sub_id;
1129 int err;
1130 int skerr;
1131
1132 vpending = vsock_sk(pending);
1133 detach_sub_id = VMCI_INVALID_ID;
1134
1135 switch (pkt->type) {
1136 case VMCI_TRANSPORT_PACKET_TYPE_OFFER:
1137 if (vmci_handle_is_invalid(pkt->u.handle)) {
1138 vmci_transport_send_reset(pending, pkt);
1139 skerr = EPROTO;
1140 err = -EINVAL;
1141 goto destroy;
1142 }
1143 break;
1144 default:
1145 /* Close and cleanup the connection. */
1146 vmci_transport_send_reset(pending, pkt);
1147 skerr = EPROTO;
1148 err = pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST ? 0 : -EINVAL;
1149 goto destroy;
1150 }
1151
1152 /* In order to complete the connection we need to attach to the offered
1153 * queue pair and send an attach notification. We also subscribe to the
1154 * detach event so we know when our peer goes away, and we do that
1155 * before attaching so we don't miss an event. If all this succeeds,
1156 * we update our state and wakeup anything waiting in accept() for a
1157 * connection.
1158 */
1159
1160 /* We don't care about attach since we ensure the other side has
1161 * attached by specifying the ATTACH_ONLY flag below.
1162 */
1163 err = vmci_event_subscribe(VMCI_EVENT_QP_PEER_DETACH,
1164 vmci_transport_peer_detach_cb,
1165 pending, &detach_sub_id);
1166 if (err < VMCI_SUCCESS) {
1167 vmci_transport_send_reset(pending, pkt);
1168 err = vmci_transport_error_to_vsock_error(err);
1169 skerr = -err;
1170 goto destroy;
1171 }
1172
1173 vmci_trans(vpending)->detach_sub_id = detach_sub_id;
1174
1175 /* Now attach to the queue pair the client created. */
1176 handle = pkt->u.handle;
1177
1178 /* vpending->local_addr always has a context id so we do not need to
1179 * worry about VMADDR_CID_ANY in this case.
1180 */
1181 is_local =
1182 vpending->remote_addr.svm_cid == vpending->local_addr.svm_cid;
1183 flags = VMCI_QPFLAG_ATTACH_ONLY;
1184 flags |= is_local ? VMCI_QPFLAG_LOCAL : 0;
1185
1186 err = vmci_transport_queue_pair_alloc(
1187 &qpair,
1188 &handle,
1189 vmci_trans(vpending)->produce_size,
1190 vmci_trans(vpending)->consume_size,
1191 pkt->dg.src.context,
1192 flags,
1193 vmci_transport_is_trusted(
1194 vpending,
1195 vpending->remote_addr.svm_cid));
1196 if (err < 0) {
1197 vmci_transport_send_reset(pending, pkt);
1198 skerr = -err;
1199 goto destroy;
1200 }
1201
1202 vmci_trans(vpending)->qp_handle = handle;
1203 vmci_trans(vpending)->qpair = qpair;
1204
1205 /* When we send the attach message, we must be ready to handle incoming
1206 * control messages on the newly connected socket. So we move the
1207 * pending socket to the connected state before sending the attach
1208 * message. Otherwise, an incoming packet triggered by the attach being
1209 * received by the peer may be processed concurrently with what happens
1210 * below after sending the attach message, and that incoming packet
1211 * will find the listening socket instead of the (currently) pending
1212 * socket. Note that enqueueing the socket increments the reference
1213 * count, so even if a reset comes before the connection is accepted,
1214 * the socket will be valid until it is removed from the queue.
1215 *
1216 * If we fail sending the attach below, we remove the socket from the
1217 * connected list and move the socket to SS_UNCONNECTED before
1218 * releasing the lock, so a pending slow path processing of an incoming
1219 * packet will not see the socket in the connected state in that case.
1220 */
1221 pending->sk_state = SS_CONNECTED;
1222
1223 vsock_insert_connected(vpending);
1224
1225 /* Notify our peer of our attach. */
1226 err = vmci_transport_send_attach(pending, handle);
1227 if (err < 0) {
1228 vsock_remove_connected(vpending);
1229 pr_err("Could not send attach\n");
1230 vmci_transport_send_reset(pending, pkt);
1231 err = vmci_transport_error_to_vsock_error(err);
1232 skerr = -err;
1233 goto destroy;
1234 }
1235
1236 /* We have a connection. Move the now connected socket from the
1237 * listener's pending list to the accept queue so callers of accept()
1238 * can find it.
1239 */
1240 vsock_remove_pending(listener, pending);
1241 vsock_enqueue_accept(listener, pending);
1242
1243 /* Callers of accept() will be be waiting on the listening socket, not
1244 * the pending socket.
1245 */
1246 listener->sk_state_change(listener);
1247
1248 return 0;
1249
1250destroy:
1251 pending->sk_err = skerr;
1252 pending->sk_state = SS_UNCONNECTED;
1253 /* As long as we drop our reference, all necessary cleanup will handle
1254 * when the cleanup function drops its reference and our destruct
1255 * implementation is called. Note that since the listen handler will
1256 * remove pending from the pending list upon our failure, the cleanup
1257 * function won't drop the additional reference, which is why we do it
1258 * here.
1259 */
1260 sock_put(pending);
1261
1262 return err;
1263}
1264
1265static int
1266vmci_transport_recv_connecting_client(struct sock *sk,
1267 struct vmci_transport_packet *pkt)
1268{
1269 struct vsock_sock *vsk;
1270 int err;
1271 int skerr;
1272
1273 vsk = vsock_sk(sk);
1274
1275 switch (pkt->type) {
1276 case VMCI_TRANSPORT_PACKET_TYPE_ATTACH:
1277 if (vmci_handle_is_invalid(pkt->u.handle) ||
1278 !vmci_handle_is_equal(pkt->u.handle,
1279 vmci_trans(vsk)->qp_handle)) {
1280 skerr = EPROTO;
1281 err = -EINVAL;
1282 goto destroy;
1283 }
1284
1285 /* Signify the socket is connected and wakeup the waiter in
1286 * connect(). Also place the socket in the connected table for
1287 * accounting (it can already be found since it's in the bound
1288 * table).
1289 */
1290 sk->sk_state = SS_CONNECTED;
1291 sk->sk_socket->state = SS_CONNECTED;
1292 vsock_insert_connected(vsk);
1293 sk->sk_state_change(sk);
1294
1295 break;
1296 case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE:
1297 case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2:
1298 if (pkt->u.size == 0
1299 || pkt->dg.src.context != vsk->remote_addr.svm_cid
1300 || pkt->src_port != vsk->remote_addr.svm_port
1301 || !vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle)
1302 || vmci_trans(vsk)->qpair
1303 || vmci_trans(vsk)->produce_size != 0
1304 || vmci_trans(vsk)->consume_size != 0
1305 || vmci_trans(vsk)->attach_sub_id != VMCI_INVALID_ID
1306 || vmci_trans(vsk)->detach_sub_id != VMCI_INVALID_ID) {
1307 skerr = EPROTO;
1308 err = -EINVAL;
1309
1310 goto destroy;
1311 }
1312
1313 err = vmci_transport_recv_connecting_client_negotiate(sk, pkt);
1314 if (err) {
1315 skerr = -err;
1316 goto destroy;
1317 }
1318
1319 break;
1320 case VMCI_TRANSPORT_PACKET_TYPE_INVALID:
1321 err = vmci_transport_recv_connecting_client_invalid(sk, pkt);
1322 if (err) {
1323 skerr = -err;
1324 goto destroy;
1325 }
1326
1327 break;
1328 case VMCI_TRANSPORT_PACKET_TYPE_RST:
1329 /* Older versions of the linux code (WS 6.5 / ESX 4.0) used to
1330 * continue processing here after they sent an INVALID packet.
1331 * This meant that we got a RST after the INVALID. We ignore a
1332 * RST after an INVALID. The common code doesn't send the RST
1333 * ... so we can hang if an old version of the common code
1334 * fails between getting a REQUEST and sending an OFFER back.
1335 * Not much we can do about it... except hope that it doesn't
1336 * happen.
1337 */
1338 if (vsk->ignore_connecting_rst) {
1339 vsk->ignore_connecting_rst = false;
1340 } else {
1341 skerr = ECONNRESET;
1342 err = 0;
1343 goto destroy;
1344 }
1345
1346 break;
1347 default:
1348 /* Close and cleanup the connection. */
1349 skerr = EPROTO;
1350 err = -EINVAL;
1351 goto destroy;
1352 }
1353
1354 return 0;
1355
1356destroy:
1357 vmci_transport_send_reset(sk, pkt);
1358
1359 sk->sk_state = SS_UNCONNECTED;
1360 sk->sk_err = skerr;
1361 sk->sk_error_report(sk);
1362 return err;
1363}
1364
1365static int vmci_transport_recv_connecting_client_negotiate(
1366 struct sock *sk,
1367 struct vmci_transport_packet *pkt)
1368{
1369 int err;
1370 struct vsock_sock *vsk;
1371 struct vmci_handle handle;
1372 struct vmci_qp *qpair;
1373 u32 attach_sub_id;
1374 u32 detach_sub_id;
1375 bool is_local;
1376 u32 flags;
1377 bool old_proto = true;
1378 bool old_pkt_proto;
1379 u16 version;
1380
1381 vsk = vsock_sk(sk);
1382 handle = VMCI_INVALID_HANDLE;
1383 attach_sub_id = VMCI_INVALID_ID;
1384 detach_sub_id = VMCI_INVALID_ID;
1385
1386 /* If we have gotten here then we should be past the point where old
1387 * linux vsock could have sent the bogus rst.
1388 */
1389 vsk->sent_request = false;
1390 vsk->ignore_connecting_rst = false;
1391
1392 /* Verify that we're OK with the proposed queue pair size */
1393 if (pkt->u.size < vmci_trans(vsk)->queue_pair_min_size ||
1394 pkt->u.size > vmci_trans(vsk)->queue_pair_max_size) {
1395 err = -EINVAL;
1396 goto destroy;
1397 }
1398
1399 /* At this point we know the CID the peer is using to talk to us. */
1400
1401 if (vsk->local_addr.svm_cid == VMADDR_CID_ANY)
1402 vsk->local_addr.svm_cid = pkt->dg.dst.context;
1403
1404 /* Setup the notify ops to be the highest supported version that both
1405 * the server and the client support.
1406 */
1407
1408 if (vmci_transport_old_proto_override(&old_pkt_proto)) {
1409 old_proto = old_pkt_proto;
1410 } else {
1411 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE)
1412 old_proto = true;
1413 else if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2)
1414 old_proto = false;
1415
1416 }
1417
1418 if (old_proto)
1419 version = VSOCK_PROTO_INVALID;
1420 else
1421 version = pkt->proto;
1422
1423 if (!vmci_transport_proto_to_notify_struct(sk, &version, old_proto)) {
1424 err = -EINVAL;
1425 goto destroy;
1426 }
1427
1428 /* Subscribe to attach and detach events first.
1429 *
1430 * XXX We attach once for each queue pair created for now so it is easy
1431 * to find the socket (it's provided), but later we should only
1432 * subscribe once and add a way to lookup sockets by queue pair handle.
1433 */
1434 err = vmci_event_subscribe(VMCI_EVENT_QP_PEER_ATTACH,
1435 vmci_transport_peer_attach_cb,
1436 sk, &attach_sub_id);
1437 if (err < VMCI_SUCCESS) {
1438 err = vmci_transport_error_to_vsock_error(err);
1439 goto destroy;
1440 }
1441
1442 err = vmci_event_subscribe(VMCI_EVENT_QP_PEER_DETACH,
1443 vmci_transport_peer_detach_cb,
1444 sk, &detach_sub_id);
1445 if (err < VMCI_SUCCESS) {
1446 err = vmci_transport_error_to_vsock_error(err);
1447 goto destroy;
1448 }
1449
1450 /* Make VMCI select the handle for us. */
1451 handle = VMCI_INVALID_HANDLE;
1452 is_local = vsk->remote_addr.svm_cid == vsk->local_addr.svm_cid;
1453 flags = is_local ? VMCI_QPFLAG_LOCAL : 0;
1454
1455 err = vmci_transport_queue_pair_alloc(&qpair,
1456 &handle,
1457 pkt->u.size,
1458 pkt->u.size,
1459 vsk->remote_addr.svm_cid,
1460 flags,
1461 vmci_transport_is_trusted(
1462 vsk,
1463 vsk->
1464 remote_addr.svm_cid));
1465 if (err < 0)
1466 goto destroy;
1467
1468 err = vmci_transport_send_qp_offer(sk, handle);
1469 if (err < 0) {
1470 err = vmci_transport_error_to_vsock_error(err);
1471 goto destroy;
1472 }
1473
1474 vmci_trans(vsk)->qp_handle = handle;
1475 vmci_trans(vsk)->qpair = qpair;
1476
1477 vmci_trans(vsk)->produce_size = vmci_trans(vsk)->consume_size =
1478 pkt->u.size;
1479
1480 vmci_trans(vsk)->attach_sub_id = attach_sub_id;
1481 vmci_trans(vsk)->detach_sub_id = detach_sub_id;
1482
1483 vmci_trans(vsk)->notify_ops->process_negotiate(sk);
1484
1485 return 0;
1486
1487destroy:
1488 if (attach_sub_id != VMCI_INVALID_ID)
1489 vmci_event_unsubscribe(attach_sub_id);
1490
1491 if (detach_sub_id != VMCI_INVALID_ID)
1492 vmci_event_unsubscribe(detach_sub_id);
1493
1494 if (!vmci_handle_is_invalid(handle))
1495 vmci_qpair_detach(&qpair);
1496
1497 return err;
1498}
1499
1500static int
1501vmci_transport_recv_connecting_client_invalid(struct sock *sk,
1502 struct vmci_transport_packet *pkt)
1503{
1504 int err = 0;
1505 struct vsock_sock *vsk = vsock_sk(sk);
1506
1507 if (vsk->sent_request) {
1508 vsk->sent_request = false;
1509 vsk->ignore_connecting_rst = true;
1510
1511 err = vmci_transport_send_conn_request(
1512 sk, vmci_trans(vsk)->queue_pair_size);
1513 if (err < 0)
1514 err = vmci_transport_error_to_vsock_error(err);
1515 else
1516 err = 0;
1517
1518 }
1519
1520 return err;
1521}
1522
1523static int vmci_transport_recv_connected(struct sock *sk,
1524 struct vmci_transport_packet *pkt)
1525{
1526 struct vsock_sock *vsk;
1527 bool pkt_processed = false;
1528
1529 /* In cases where we are closing the connection, it's sufficient to
1530 * mark the state change (and maybe error) and wake up any waiting
1531 * threads. Since this is a connected socket, it's owned by a user
1532 * process and will be cleaned up when the failure is passed back on
1533 * the current or next system call. Our system call implementations
1534 * must therefore check for error and state changes on entry and when
1535 * being awoken.
1536 */
1537 switch (pkt->type) {
1538 case VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN:
1539 if (pkt->u.mode) {
1540 vsk = vsock_sk(sk);
1541
1542 vsk->peer_shutdown |= pkt->u.mode;
1543 sk->sk_state_change(sk);
1544 }
1545 break;
1546
1547 case VMCI_TRANSPORT_PACKET_TYPE_RST:
1548 vsk = vsock_sk(sk);
1549 /* It is possible that we sent our peer a message (e.g a
1550 * WAITING_READ) right before we got notified that the peer had
1551 * detached. If that happens then we can get a RST pkt back
1552 * from our peer even though there is data available for us to
1553 * read. In that case, don't shutdown the socket completely but
1554 * instead allow the local client to finish reading data off
1555 * the queuepair. Always treat a RST pkt in connected mode like
1556 * a clean shutdown.
1557 */
1558 sock_set_flag(sk, SOCK_DONE);
1559 vsk->peer_shutdown = SHUTDOWN_MASK;
1560 if (vsock_stream_has_data(vsk) <= 0)
1561 sk->sk_state = SS_DISCONNECTING;
1562
1563 sk->sk_state_change(sk);
1564 break;
1565
1566 default:
1567 vsk = vsock_sk(sk);
1568 vmci_trans(vsk)->notify_ops->handle_notify_pkt(
1569 sk, pkt, false, NULL, NULL,
1570 &pkt_processed);
1571 if (!pkt_processed)
1572 return -EINVAL;
1573
1574 break;
1575 }
1576
1577 return 0;
1578}
1579
1580static int vmci_transport_socket_init(struct vsock_sock *vsk,
1581 struct vsock_sock *psk)
1582{
1583 vsk->trans = kmalloc(sizeof(struct vmci_transport), GFP_KERNEL);
1584 if (!vsk->trans)
1585 return -ENOMEM;
1586
1587 vmci_trans(vsk)->dg_handle = VMCI_INVALID_HANDLE;
1588 vmci_trans(vsk)->qp_handle = VMCI_INVALID_HANDLE;
1589 vmci_trans(vsk)->qpair = NULL;
1590 vmci_trans(vsk)->produce_size = vmci_trans(vsk)->consume_size = 0;
1591 vmci_trans(vsk)->attach_sub_id = vmci_trans(vsk)->detach_sub_id =
1592 VMCI_INVALID_ID;
1593 vmci_trans(vsk)->notify_ops = NULL;
1594 if (psk) {
1595 vmci_trans(vsk)->queue_pair_size =
1596 vmci_trans(psk)->queue_pair_size;
1597 vmci_trans(vsk)->queue_pair_min_size =
1598 vmci_trans(psk)->queue_pair_min_size;
1599 vmci_trans(vsk)->queue_pair_max_size =
1600 vmci_trans(psk)->queue_pair_max_size;
1601 } else {
1602 vmci_trans(vsk)->queue_pair_size =
1603 VMCI_TRANSPORT_DEFAULT_QP_SIZE;
1604 vmci_trans(vsk)->queue_pair_min_size =
1605 VMCI_TRANSPORT_DEFAULT_QP_SIZE_MIN;
1606 vmci_trans(vsk)->queue_pair_max_size =
1607 VMCI_TRANSPORT_DEFAULT_QP_SIZE_MAX;
1608 }
1609
1610 return 0;
1611}
1612
1613static void vmci_transport_destruct(struct vsock_sock *vsk)
1614{
1615 if (vmci_trans(vsk)->attach_sub_id != VMCI_INVALID_ID) {
1616 vmci_event_unsubscribe(vmci_trans(vsk)->attach_sub_id);
1617 vmci_trans(vsk)->attach_sub_id = VMCI_INVALID_ID;
1618 }
1619
1620 if (vmci_trans(vsk)->detach_sub_id != VMCI_INVALID_ID) {
1621 vmci_event_unsubscribe(vmci_trans(vsk)->detach_sub_id);
1622 vmci_trans(vsk)->detach_sub_id = VMCI_INVALID_ID;
1623 }
1624
1625 if (!vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle)) {
1626 vmci_qpair_detach(&vmci_trans(vsk)->qpair);
1627 vmci_trans(vsk)->qp_handle = VMCI_INVALID_HANDLE;
1628 vmci_trans(vsk)->produce_size = 0;
1629 vmci_trans(vsk)->consume_size = 0;
1630 }
1631
1632 if (vmci_trans(vsk)->notify_ops)
1633 vmci_trans(vsk)->notify_ops->socket_destruct(vsk);
1634
1635 kfree(vsk->trans);
1636 vsk->trans = NULL;
1637}
1638
1639static void vmci_transport_release(struct vsock_sock *vsk)
1640{
1641 if (!vmci_handle_is_invalid(vmci_trans(vsk)->dg_handle)) {
1642 vmci_datagram_destroy_handle(vmci_trans(vsk)->dg_handle);
1643 vmci_trans(vsk)->dg_handle = VMCI_INVALID_HANDLE;
1644 }
1645}
1646
1647static int vmci_transport_dgram_bind(struct vsock_sock *vsk,
1648 struct sockaddr_vm *addr)
1649{
1650 u32 port;
1651 u32 flags;
1652 int err;
1653
1654 /* VMCI will select a resource ID for us if we provide
1655 * VMCI_INVALID_ID.
1656 */
1657 port = addr->svm_port == VMADDR_PORT_ANY ?
1658 VMCI_INVALID_ID : addr->svm_port;
1659
1660 if (port <= LAST_RESERVED_PORT && !capable(CAP_NET_BIND_SERVICE))
1661 return -EACCES;
1662
1663 flags = addr->svm_cid == VMADDR_CID_ANY ?
1664 VMCI_FLAG_ANYCID_DG_HND : 0;
1665
1666 err = vmci_transport_datagram_create_hnd(port, flags,
1667 vmci_transport_recv_dgram_cb,
1668 &vsk->sk,
1669 &vmci_trans(vsk)->dg_handle);
1670 if (err < VMCI_SUCCESS)
1671 return vmci_transport_error_to_vsock_error(err);
1672 vsock_addr_init(&vsk->local_addr, addr->svm_cid,
1673 vmci_trans(vsk)->dg_handle.resource);
1674
1675 return 0;
1676}
1677
1678static int vmci_transport_dgram_enqueue(
1679 struct vsock_sock *vsk,
1680 struct sockaddr_vm *remote_addr,
1681 struct iovec *iov,
1682 size_t len)
1683{
1684 int err;
1685 struct vmci_datagram *dg;
1686
1687 if (len > VMCI_MAX_DG_PAYLOAD_SIZE)
1688 return -EMSGSIZE;
1689
1690 if (!vmci_transport_allow_dgram(vsk, remote_addr->svm_cid))
1691 return -EPERM;
1692
1693 /* Allocate a buffer for the user's message and our packet header. */
1694 dg = kmalloc(len + sizeof(*dg), GFP_KERNEL);
1695 if (!dg)
1696 return -ENOMEM;
1697
1698 memcpy_fromiovec(VMCI_DG_PAYLOAD(dg), iov, len);
1699
1700 dg->dst = vmci_make_handle(remote_addr->svm_cid,
1701 remote_addr->svm_port);
1702 dg->src = vmci_make_handle(vsk->local_addr.svm_cid,
1703 vsk->local_addr.svm_port);
1704 dg->payload_size = len;
1705
1706 err = vmci_datagram_send(dg);
1707 kfree(dg);
1708 if (err < 0)
1709 return vmci_transport_error_to_vsock_error(err);
1710
1711 return err - sizeof(*dg);
1712}
1713
1714static int vmci_transport_dgram_dequeue(struct kiocb *kiocb,
1715 struct vsock_sock *vsk,
1716 struct msghdr *msg, size_t len,
1717 int flags)
1718{
1719 int err;
1720 int noblock;
1721 struct vmci_datagram *dg;
1722 size_t payload_len;
1723 struct sk_buff *skb;
1724
1725 noblock = flags & MSG_DONTWAIT;
1726
1727 if (flags & MSG_OOB || flags & MSG_ERRQUEUE)
1728 return -EOPNOTSUPP;
1729
1730 /* Retrieve the head sk_buff from the socket's receive queue. */
1731 err = 0;
1732 skb = skb_recv_datagram(&vsk->sk, flags, noblock, &err);
1733 if (err)
1734 return err;
1735
1736 if (!skb)
1737 return -EAGAIN;
1738
1739 dg = (struct vmci_datagram *)skb->data;
1740 if (!dg)
1741 /* err is 0, meaning we read zero bytes. */
1742 goto out;
1743
1744 payload_len = dg->payload_size;
1745 /* Ensure the sk_buff matches the payload size claimed in the packet. */
1746 if (payload_len != skb->len - sizeof(*dg)) {
1747 err = -EINVAL;
1748 goto out;
1749 }
1750
1751 if (payload_len > len) {
1752 payload_len = len;
1753 msg->msg_flags |= MSG_TRUNC;
1754 }
1755
1756 /* Place the datagram payload in the user's iovec. */
1757 err = skb_copy_datagram_iovec(skb, sizeof(*dg), msg->msg_iov,
1758 payload_len);
1759 if (err)
1760 goto out;
1761
1762 msg->msg_namelen = 0;
1763 if (msg->msg_name) {
1764 struct sockaddr_vm *vm_addr;
1765
1766 /* Provide the address of the sender. */
1767 vm_addr = (struct sockaddr_vm *)msg->msg_name;
1768 vsock_addr_init(vm_addr, dg->src.context, dg->src.resource);
1769 msg->msg_namelen = sizeof(*vm_addr);
1770 }
1771 err = payload_len;
1772
1773out:
1774 skb_free_datagram(&vsk->sk, skb);
1775 return err;
1776}
1777
1778static bool vmci_transport_dgram_allow(u32 cid, u32 port)
1779{
1780 if (cid == VMADDR_CID_HYPERVISOR) {
1781 /* Registrations of PBRPC Servers do not modify VMX/Hypervisor
1782 * state and are allowed.
1783 */
1784 return port == VMCI_UNITY_PBRPC_REGISTER;
1785 }
1786
1787 return true;
1788}
1789
1790static int vmci_transport_connect(struct vsock_sock *vsk)
1791{
1792 int err;
1793 bool old_pkt_proto = false;
1794 struct sock *sk = &vsk->sk;
1795
1796 if (vmci_transport_old_proto_override(&old_pkt_proto) &&
1797 old_pkt_proto) {
1798 err = vmci_transport_send_conn_request(
1799 sk, vmci_trans(vsk)->queue_pair_size);
1800 if (err < 0) {
1801 sk->sk_state = SS_UNCONNECTED;
1802 return err;
1803 }
1804 } else {
1805 int supported_proto_versions =
1806 vmci_transport_new_proto_supported_versions();
1807 err = vmci_transport_send_conn_request2(
1808 sk, vmci_trans(vsk)->queue_pair_size,
1809 supported_proto_versions);
1810 if (err < 0) {
1811 sk->sk_state = SS_UNCONNECTED;
1812 return err;
1813 }
1814
1815 vsk->sent_request = true;
1816 }
1817
1818 return err;
1819}
1820
1821static ssize_t vmci_transport_stream_dequeue(
1822 struct vsock_sock *vsk,
1823 struct iovec *iov,
1824 size_t len,
1825 int flags)
1826{
1827 if (flags & MSG_PEEK)
1828 return vmci_qpair_peekv(vmci_trans(vsk)->qpair, iov, len, 0);
1829 else
1830 return vmci_qpair_dequev(vmci_trans(vsk)->qpair, iov, len, 0);
1831}
1832
1833static ssize_t vmci_transport_stream_enqueue(
1834 struct vsock_sock *vsk,
1835 struct iovec *iov,
1836 size_t len)
1837{
1838 return vmci_qpair_enquev(vmci_trans(vsk)->qpair, iov, len, 0);
1839}
1840
1841static s64 vmci_transport_stream_has_data(struct vsock_sock *vsk)
1842{
1843 return vmci_qpair_consume_buf_ready(vmci_trans(vsk)->qpair);
1844}
1845
1846static s64 vmci_transport_stream_has_space(struct vsock_sock *vsk)
1847{
1848 return vmci_qpair_produce_free_space(vmci_trans(vsk)->qpair);
1849}
1850
1851static u64 vmci_transport_stream_rcvhiwat(struct vsock_sock *vsk)
1852{
1853 return vmci_trans(vsk)->consume_size;
1854}
1855
1856static bool vmci_transport_stream_is_active(struct vsock_sock *vsk)
1857{
1858 return !vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle);
1859}
1860
1861static u64 vmci_transport_get_buffer_size(struct vsock_sock *vsk)
1862{
1863 return vmci_trans(vsk)->queue_pair_size;
1864}
1865
1866static u64 vmci_transport_get_min_buffer_size(struct vsock_sock *vsk)
1867{
1868 return vmci_trans(vsk)->queue_pair_min_size;
1869}
1870
1871static u64 vmci_transport_get_max_buffer_size(struct vsock_sock *vsk)
1872{
1873 return vmci_trans(vsk)->queue_pair_max_size;
1874}
1875
1876static void vmci_transport_set_buffer_size(struct vsock_sock *vsk, u64 val)
1877{
1878 if (val < vmci_trans(vsk)->queue_pair_min_size)
1879 vmci_trans(vsk)->queue_pair_min_size = val;
1880 if (val > vmci_trans(vsk)->queue_pair_max_size)
1881 vmci_trans(vsk)->queue_pair_max_size = val;
1882 vmci_trans(vsk)->queue_pair_size = val;
1883}
1884
1885static void vmci_transport_set_min_buffer_size(struct vsock_sock *vsk,
1886 u64 val)
1887{
1888 if (val > vmci_trans(vsk)->queue_pair_size)
1889 vmci_trans(vsk)->queue_pair_size = val;
1890 vmci_trans(vsk)->queue_pair_min_size = val;
1891}
1892
1893static void vmci_transport_set_max_buffer_size(struct vsock_sock *vsk,
1894 u64 val)
1895{
1896 if (val < vmci_trans(vsk)->queue_pair_size)
1897 vmci_trans(vsk)->queue_pair_size = val;
1898 vmci_trans(vsk)->queue_pair_max_size = val;
1899}
1900
1901static int vmci_transport_notify_poll_in(
1902 struct vsock_sock *vsk,
1903 size_t target,
1904 bool *data_ready_now)
1905{
1906 return vmci_trans(vsk)->notify_ops->poll_in(
1907 &vsk->sk, target, data_ready_now);
1908}
1909
1910static int vmci_transport_notify_poll_out(
1911 struct vsock_sock *vsk,
1912 size_t target,
1913 bool *space_available_now)
1914{
1915 return vmci_trans(vsk)->notify_ops->poll_out(
1916 &vsk->sk, target, space_available_now);
1917}
1918
1919static int vmci_transport_notify_recv_init(
1920 struct vsock_sock *vsk,
1921 size_t target,
1922 struct vsock_transport_recv_notify_data *data)
1923{
1924 return vmci_trans(vsk)->notify_ops->recv_init(
1925 &vsk->sk, target,
1926 (struct vmci_transport_recv_notify_data *)data);
1927}
1928
1929static int vmci_transport_notify_recv_pre_block(
1930 struct vsock_sock *vsk,
1931 size_t target,
1932 struct vsock_transport_recv_notify_data *data)
1933{
1934 return vmci_trans(vsk)->notify_ops->recv_pre_block(
1935 &vsk->sk, target,
1936 (struct vmci_transport_recv_notify_data *)data);
1937}
1938
1939static int vmci_transport_notify_recv_pre_dequeue(
1940 struct vsock_sock *vsk,
1941 size_t target,
1942 struct vsock_transport_recv_notify_data *data)
1943{
1944 return vmci_trans(vsk)->notify_ops->recv_pre_dequeue(
1945 &vsk->sk, target,
1946 (struct vmci_transport_recv_notify_data *)data);
1947}
1948
1949static int vmci_transport_notify_recv_post_dequeue(
1950 struct vsock_sock *vsk,
1951 size_t target,
1952 ssize_t copied,
1953 bool data_read,
1954 struct vsock_transport_recv_notify_data *data)
1955{
1956 return vmci_trans(vsk)->notify_ops->recv_post_dequeue(
1957 &vsk->sk, target, copied, data_read,
1958 (struct vmci_transport_recv_notify_data *)data);
1959}
1960
1961static int vmci_transport_notify_send_init(
1962 struct vsock_sock *vsk,
1963 struct vsock_transport_send_notify_data *data)
1964{
1965 return vmci_trans(vsk)->notify_ops->send_init(
1966 &vsk->sk,
1967 (struct vmci_transport_send_notify_data *)data);
1968}
1969
1970static int vmci_transport_notify_send_pre_block(
1971 struct vsock_sock *vsk,
1972 struct vsock_transport_send_notify_data *data)
1973{
1974 return vmci_trans(vsk)->notify_ops->send_pre_block(
1975 &vsk->sk,
1976 (struct vmci_transport_send_notify_data *)data);
1977}
1978
1979static int vmci_transport_notify_send_pre_enqueue(
1980 struct vsock_sock *vsk,
1981 struct vsock_transport_send_notify_data *data)
1982{
1983 return vmci_trans(vsk)->notify_ops->send_pre_enqueue(
1984 &vsk->sk,
1985 (struct vmci_transport_send_notify_data *)data);
1986}
1987
1988static int vmci_transport_notify_send_post_enqueue(
1989 struct vsock_sock *vsk,
1990 ssize_t written,
1991 struct vsock_transport_send_notify_data *data)
1992{
1993 return vmci_trans(vsk)->notify_ops->send_post_enqueue(
1994 &vsk->sk, written,
1995 (struct vmci_transport_send_notify_data *)data);
1996}
1997
1998static bool vmci_transport_old_proto_override(bool *old_pkt_proto)
1999{
2000 if (PROTOCOL_OVERRIDE != -1) {
2001 if (PROTOCOL_OVERRIDE == 0)
2002 *old_pkt_proto = true;
2003 else
2004 *old_pkt_proto = false;
2005
2006 pr_info("Proto override in use\n");
2007 return true;
2008 }
2009
2010 return false;
2011}
2012
2013static bool vmci_transport_proto_to_notify_struct(struct sock *sk,
2014 u16 *proto,
2015 bool old_pkt_proto)
2016{
2017 struct vsock_sock *vsk = vsock_sk(sk);
2018
2019 if (old_pkt_proto) {
2020 if (*proto != VSOCK_PROTO_INVALID) {
2021 pr_err("Can't set both an old and new protocol\n");
2022 return false;
2023 }
2024 vmci_trans(vsk)->notify_ops = &vmci_transport_notify_pkt_ops;
2025 goto exit;
2026 }
2027
2028 switch (*proto) {
2029 case VSOCK_PROTO_PKT_ON_NOTIFY:
2030 vmci_trans(vsk)->notify_ops =
2031 &vmci_transport_notify_pkt_q_state_ops;
2032 break;
2033 default:
2034 pr_err("Unknown notify protocol version\n");
2035 return false;
2036 }
2037
2038exit:
2039 vmci_trans(vsk)->notify_ops->socket_init(sk);
2040 return true;
2041}
2042
2043static u16 vmci_transport_new_proto_supported_versions(void)
2044{
2045 if (PROTOCOL_OVERRIDE != -1)
2046 return PROTOCOL_OVERRIDE;
2047
2048 return VSOCK_PROTO_ALL_SUPPORTED;
2049}
2050
2051static u32 vmci_transport_get_local_cid(void)
2052{
2053 return vmci_get_context_id();
2054}
2055
2056static struct vsock_transport vmci_transport = {
2057 .init = vmci_transport_socket_init,
2058 .destruct = vmci_transport_destruct,
2059 .release = vmci_transport_release,
2060 .connect = vmci_transport_connect,
2061 .dgram_bind = vmci_transport_dgram_bind,
2062 .dgram_dequeue = vmci_transport_dgram_dequeue,
2063 .dgram_enqueue = vmci_transport_dgram_enqueue,
2064 .dgram_allow = vmci_transport_dgram_allow,
2065 .stream_dequeue = vmci_transport_stream_dequeue,
2066 .stream_enqueue = vmci_transport_stream_enqueue,
2067 .stream_has_data = vmci_transport_stream_has_data,
2068 .stream_has_space = vmci_transport_stream_has_space,
2069 .stream_rcvhiwat = vmci_transport_stream_rcvhiwat,
2070 .stream_is_active = vmci_transport_stream_is_active,
2071 .stream_allow = vmci_transport_stream_allow,
2072 .notify_poll_in = vmci_transport_notify_poll_in,
2073 .notify_poll_out = vmci_transport_notify_poll_out,
2074 .notify_recv_init = vmci_transport_notify_recv_init,
2075 .notify_recv_pre_block = vmci_transport_notify_recv_pre_block,
2076 .notify_recv_pre_dequeue = vmci_transport_notify_recv_pre_dequeue,
2077 .notify_recv_post_dequeue = vmci_transport_notify_recv_post_dequeue,
2078 .notify_send_init = vmci_transport_notify_send_init,
2079 .notify_send_pre_block = vmci_transport_notify_send_pre_block,
2080 .notify_send_pre_enqueue = vmci_transport_notify_send_pre_enqueue,
2081 .notify_send_post_enqueue = vmci_transport_notify_send_post_enqueue,
2082 .shutdown = vmci_transport_shutdown,
2083 .set_buffer_size = vmci_transport_set_buffer_size,
2084 .set_min_buffer_size = vmci_transport_set_min_buffer_size,
2085 .set_max_buffer_size = vmci_transport_set_max_buffer_size,
2086 .get_buffer_size = vmci_transport_get_buffer_size,
2087 .get_min_buffer_size = vmci_transport_get_min_buffer_size,
2088 .get_max_buffer_size = vmci_transport_get_max_buffer_size,
2089 .get_local_cid = vmci_transport_get_local_cid,
2090};
2091
2092static int __init vmci_transport_init(void)
2093{
2094 int err;
2095
2096 /* Create the datagram handle that we will use to send and receive all
2097 * VSocket control messages for this context.
2098 */
2099 err = vmci_transport_datagram_create_hnd(VMCI_TRANSPORT_PACKET_RID,
2100 VMCI_FLAG_ANYCID_DG_HND,
2101 vmci_transport_recv_stream_cb,
2102 NULL,
2103 &vmci_transport_stream_handle);
2104 if (err < VMCI_SUCCESS) {
2105 pr_err("Unable to create datagram handle. (%d)\n", err);
2106 return vmci_transport_error_to_vsock_error(err);
2107 }
2108
2109 err = vmci_event_subscribe(VMCI_EVENT_QP_RESUMED,
2110 vmci_transport_qp_resumed_cb,
2111 NULL, &vmci_transport_qp_resumed_sub_id);
2112 if (err < VMCI_SUCCESS) {
2113 pr_err("Unable to subscribe to resumed event. (%d)\n", err);
2114 err = vmci_transport_error_to_vsock_error(err);
2115 vmci_transport_qp_resumed_sub_id = VMCI_INVALID_ID;
2116 goto err_destroy_stream_handle;
2117 }
2118
2119 err = vsock_core_init(&vmci_transport);
2120 if (err < 0)
2121 goto err_unsubscribe;
2122
2123 return 0;
2124
2125err_unsubscribe:
2126 vmci_event_unsubscribe(vmci_transport_qp_resumed_sub_id);
2127err_destroy_stream_handle:
2128 vmci_datagram_destroy_handle(vmci_transport_stream_handle);
2129 return err;
2130}
2131module_init(vmci_transport_init);
2132
2133static void __exit vmci_transport_exit(void)
2134{
2135 if (!vmci_handle_is_invalid(vmci_transport_stream_handle)) {
2136 if (vmci_datagram_destroy_handle(
2137 vmci_transport_stream_handle) != VMCI_SUCCESS)
2138 pr_err("Couldn't destroy datagram handle\n");
2139 vmci_transport_stream_handle = VMCI_INVALID_HANDLE;
2140 }
2141
2142 if (vmci_transport_qp_resumed_sub_id != VMCI_INVALID_ID) {
2143 vmci_event_unsubscribe(vmci_transport_qp_resumed_sub_id);
2144 vmci_transport_qp_resumed_sub_id = VMCI_INVALID_ID;
2145 }
2146
2147 vsock_core_exit();
2148}
2149module_exit(vmci_transport_exit);
2150
2151MODULE_AUTHOR("VMware, Inc.");
2152MODULE_DESCRIPTION("VMCI transport for Virtual Sockets");
2153MODULE_LICENSE("GPL v2");
2154MODULE_ALIAS("vmware_vsock");
2155MODULE_ALIAS_NETPROTO(PF_VSOCK);
diff --git a/net/vmw_vsock/vmci_transport.h b/net/vmw_vsock/vmci_transport.h
new file mode 100644
index 000000000000..1bf991803ec0
--- /dev/null
+++ b/net/vmw_vsock/vmci_transport.h
@@ -0,0 +1,139 @@
1/*
2 * VMware vSockets Driver
3 *
4 * Copyright (C) 2013 VMware, Inc. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16#ifndef _VMCI_TRANSPORT_H_
17#define _VMCI_TRANSPORT_H_
18
19#include <linux/vmw_vmci_defs.h>
20#include <linux/vmw_vmci_api.h>
21
22#include "vsock_addr.h"
23#include "af_vsock.h"
24
25/* If the packet format changes in a release then this should change too. */
26#define VMCI_TRANSPORT_PACKET_VERSION 1
27
28/* The resource ID on which control packets are sent. */
29#define VMCI_TRANSPORT_PACKET_RID 1
30
31#define VSOCK_PROTO_INVALID 0
32#define VSOCK_PROTO_PKT_ON_NOTIFY (1 << 0)
33#define VSOCK_PROTO_ALL_SUPPORTED (VSOCK_PROTO_PKT_ON_NOTIFY)
34
35#define vmci_trans(_vsk) ((struct vmci_transport *)((_vsk)->trans))
36
37enum vmci_transport_packet_type {
38 VMCI_TRANSPORT_PACKET_TYPE_INVALID = 0,
39 VMCI_TRANSPORT_PACKET_TYPE_REQUEST,
40 VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE,
41 VMCI_TRANSPORT_PACKET_TYPE_OFFER,
42 VMCI_TRANSPORT_PACKET_TYPE_ATTACH,
43 VMCI_TRANSPORT_PACKET_TYPE_WROTE,
44 VMCI_TRANSPORT_PACKET_TYPE_READ,
45 VMCI_TRANSPORT_PACKET_TYPE_RST,
46 VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN,
47 VMCI_TRANSPORT_PACKET_TYPE_WAITING_WRITE,
48 VMCI_TRANSPORT_PACKET_TYPE_WAITING_READ,
49 VMCI_TRANSPORT_PACKET_TYPE_REQUEST2,
50 VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2,
51 VMCI_TRANSPORT_PACKET_TYPE_MAX
52};
53
54struct vmci_transport_waiting_info {
55 u64 generation;
56 u64 offset;
57};
58
59/* Control packet type for STREAM sockets. DGRAMs have no control packets nor
60 * special packet header for data packets, they are just raw VMCI DGRAM
61 * messages. For STREAMs, control packets are sent over the control channel
62 * while data is written and read directly from queue pairs with no packet
63 * format.
64 */
65struct vmci_transport_packet {
66 struct vmci_datagram dg;
67 u8 version;
68 u8 type;
69 u16 proto;
70 u32 src_port;
71 u32 dst_port;
72 u32 _reserved2;
73 union {
74 u64 size;
75 u64 mode;
76 struct vmci_handle handle;
77 struct vmci_transport_waiting_info wait;
78 } u;
79};
80
81struct vmci_transport_notify_pkt {
82 u64 write_notify_window;
83 u64 write_notify_min_window;
84 bool peer_waiting_read;
85 bool peer_waiting_write;
86 bool peer_waiting_write_detected;
87 bool sent_waiting_read;
88 bool sent_waiting_write;
89 struct vmci_transport_waiting_info peer_waiting_read_info;
90 struct vmci_transport_waiting_info peer_waiting_write_info;
91 u64 produce_q_generation;
92 u64 consume_q_generation;
93};
94
95struct vmci_transport_notify_pkt_q_state {
96 u64 write_notify_window;
97 u64 write_notify_min_window;
98 bool peer_waiting_write;
99 bool peer_waiting_write_detected;
100};
101
102union vmci_transport_notify {
103 struct vmci_transport_notify_pkt pkt;
104 struct vmci_transport_notify_pkt_q_state pkt_q_state;
105};
106
107/* Our transport-specific data. */
108struct vmci_transport {
109 /* For DGRAMs. */
110 struct vmci_handle dg_handle;
111 /* For STREAMs. */
112 struct vmci_handle qp_handle;
113 struct vmci_qp *qpair;
114 u64 produce_size;
115 u64 consume_size;
116 u64 queue_pair_size;
117 u64 queue_pair_min_size;
118 u64 queue_pair_max_size;
119 u32 attach_sub_id;
120 u32 detach_sub_id;
121 union vmci_transport_notify notify;
122 struct vmci_transport_notify_ops *notify_ops;
123};
124
125int vmci_transport_register(void);
126void vmci_transport_unregister(void);
127
128int vmci_transport_send_wrote_bh(struct sockaddr_vm *dst,
129 struct sockaddr_vm *src);
130int vmci_transport_send_read_bh(struct sockaddr_vm *dst,
131 struct sockaddr_vm *src);
132int vmci_transport_send_wrote(struct sock *sk);
133int vmci_transport_send_read(struct sock *sk);
134int vmci_transport_send_waiting_write(struct sock *sk,
135 struct vmci_transport_waiting_info *wait);
136int vmci_transport_send_waiting_read(struct sock *sk,
137 struct vmci_transport_waiting_info *wait);
138
139#endif
diff --git a/net/vmw_vsock/vmci_transport_notify.c b/net/vmw_vsock/vmci_transport_notify.c
new file mode 100644
index 000000000000..9a730744e7bc
--- /dev/null
+++ b/net/vmw_vsock/vmci_transport_notify.c
@@ -0,0 +1,680 @@
1/*
2 * VMware vSockets Driver
3 *
4 * Copyright (C) 2009-2013 VMware, Inc. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16#include <linux/types.h>
17#include <linux/socket.h>
18#include <linux/stddef.h>
19#include <net/sock.h>
20
21#include "vmci_transport_notify.h"
22
23#define PKT_FIELD(vsk, field_name) (vmci_trans(vsk)->notify.pkt.field_name)
24
25static bool vmci_transport_notify_waiting_write(struct vsock_sock *vsk)
26{
27#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
28 bool retval;
29 u64 notify_limit;
30
31 if (!PKT_FIELD(vsk, peer_waiting_write))
32 return false;
33
34#ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
35 /* When the sender blocks, we take that as a sign that the sender is
36 * faster than the receiver. To reduce the transmit rate of the sender,
37 * we delay the sending of the read notification by decreasing the
38 * write_notify_window. The notification is delayed until the number of
39 * bytes used in the queue drops below the write_notify_window.
40 */
41
42 if (!PKT_FIELD(vsk, peer_waiting_write_detected)) {
43 PKT_FIELD(vsk, peer_waiting_write_detected) = true;
44 if (PKT_FIELD(vsk, write_notify_window) < PAGE_SIZE) {
45 PKT_FIELD(vsk, write_notify_window) =
46 PKT_FIELD(vsk, write_notify_min_window);
47 } else {
48 PKT_FIELD(vsk, write_notify_window) -= PAGE_SIZE;
49 if (PKT_FIELD(vsk, write_notify_window) <
50 PKT_FIELD(vsk, write_notify_min_window))
51 PKT_FIELD(vsk, write_notify_window) =
52 PKT_FIELD(vsk, write_notify_min_window);
53
54 }
55 }
56 notify_limit = vmci_trans(vsk)->consume_size -
57 PKT_FIELD(vsk, write_notify_window);
58#else
59 notify_limit = 0;
60#endif
61
62 /* For now we ignore the wait information and just see if the free
63 * space exceeds the notify limit. Note that improving this function
64 * to be more intelligent will not require a protocol change and will
65 * retain compatibility between endpoints with mixed versions of this
66 * function.
67 *
68 * The notify_limit is used to delay notifications in the case where
69 * flow control is enabled. Below the test is expressed in terms of
70 * free space in the queue: if free_space > ConsumeSize -
71 * write_notify_window then notify An alternate way of expressing this
72 * is to rewrite the expression to use the data ready in the receive
73 * queue: if write_notify_window > bufferReady then notify as
74 * free_space == ConsumeSize - bufferReady.
75 */
76 retval = vmci_qpair_consume_free_space(vmci_trans(vsk)->qpair) >
77 notify_limit;
78#ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
79 if (retval) {
80 /*
81 * Once we notify the peer, we reset the detected flag so the
82 * next wait will again cause a decrease in the window size.
83 */
84
85 PKT_FIELD(vsk, peer_waiting_write_detected) = false;
86 }
87#endif
88 return retval;
89#else
90 return true;
91#endif
92}
93
94static bool vmci_transport_notify_waiting_read(struct vsock_sock *vsk)
95{
96#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
97 if (!PKT_FIELD(vsk, peer_waiting_read))
98 return false;
99
100 /* For now we ignore the wait information and just see if there is any
101 * data for our peer to read. Note that improving this function to be
102 * more intelligent will not require a protocol change and will retain
103 * compatibility between endpoints with mixed versions of this
104 * function.
105 */
106 return vmci_qpair_produce_buf_ready(vmci_trans(vsk)->qpair) > 0;
107#else
108 return true;
109#endif
110}
111
112static void
113vmci_transport_handle_waiting_read(struct sock *sk,
114 struct vmci_transport_packet *pkt,
115 bool bottom_half,
116 struct sockaddr_vm *dst,
117 struct sockaddr_vm *src)
118{
119#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
120 struct vsock_sock *vsk;
121
122 vsk = vsock_sk(sk);
123
124 PKT_FIELD(vsk, peer_waiting_read) = true;
125 memcpy(&PKT_FIELD(vsk, peer_waiting_read_info), &pkt->u.wait,
126 sizeof(PKT_FIELD(vsk, peer_waiting_read_info)));
127
128 if (vmci_transport_notify_waiting_read(vsk)) {
129 bool sent;
130
131 if (bottom_half)
132 sent = vmci_transport_send_wrote_bh(dst, src) > 0;
133 else
134 sent = vmci_transport_send_wrote(sk) > 0;
135
136 if (sent)
137 PKT_FIELD(vsk, peer_waiting_read) = false;
138 }
139#endif
140}
141
142static void
143vmci_transport_handle_waiting_write(struct sock *sk,
144 struct vmci_transport_packet *pkt,
145 bool bottom_half,
146 struct sockaddr_vm *dst,
147 struct sockaddr_vm *src)
148{
149#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
150 struct vsock_sock *vsk;
151
152 vsk = vsock_sk(sk);
153
154 PKT_FIELD(vsk, peer_waiting_write) = true;
155 memcpy(&PKT_FIELD(vsk, peer_waiting_write_info), &pkt->u.wait,
156 sizeof(PKT_FIELD(vsk, peer_waiting_write_info)));
157
158 if (vmci_transport_notify_waiting_write(vsk)) {
159 bool sent;
160
161 if (bottom_half)
162 sent = vmci_transport_send_read_bh(dst, src) > 0;
163 else
164 sent = vmci_transport_send_read(sk) > 0;
165
166 if (sent)
167 PKT_FIELD(vsk, peer_waiting_write) = false;
168 }
169#endif
170}
171
172static void
173vmci_transport_handle_read(struct sock *sk,
174 struct vmci_transport_packet *pkt,
175 bool bottom_half,
176 struct sockaddr_vm *dst, struct sockaddr_vm *src)
177{
178#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
179 struct vsock_sock *vsk;
180
181 vsk = vsock_sk(sk);
182 PKT_FIELD(vsk, sent_waiting_write) = false;
183#endif
184
185 sk->sk_write_space(sk);
186}
187
188static bool send_waiting_read(struct sock *sk, u64 room_needed)
189{
190#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
191 struct vsock_sock *vsk;
192 struct vmci_transport_waiting_info waiting_info;
193 u64 tail;
194 u64 head;
195 u64 room_left;
196 bool ret;
197
198 vsk = vsock_sk(sk);
199
200 if (PKT_FIELD(vsk, sent_waiting_read))
201 return true;
202
203 if (PKT_FIELD(vsk, write_notify_window) <
204 vmci_trans(vsk)->consume_size)
205 PKT_FIELD(vsk, write_notify_window) =
206 min(PKT_FIELD(vsk, write_notify_window) + PAGE_SIZE,
207 vmci_trans(vsk)->consume_size);
208
209 vmci_qpair_get_consume_indexes(vmci_trans(vsk)->qpair, &tail, &head);
210 room_left = vmci_trans(vsk)->consume_size - head;
211 if (room_needed >= room_left) {
212 waiting_info.offset = room_needed - room_left;
213 waiting_info.generation =
214 PKT_FIELD(vsk, consume_q_generation) + 1;
215 } else {
216 waiting_info.offset = head + room_needed;
217 waiting_info.generation = PKT_FIELD(vsk, consume_q_generation);
218 }
219
220 ret = vmci_transport_send_waiting_read(sk, &waiting_info) > 0;
221 if (ret)
222 PKT_FIELD(vsk, sent_waiting_read) = true;
223
224 return ret;
225#else
226 return true;
227#endif
228}
229
230static bool send_waiting_write(struct sock *sk, u64 room_needed)
231{
232#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
233 struct vsock_sock *vsk;
234 struct vmci_transport_waiting_info waiting_info;
235 u64 tail;
236 u64 head;
237 u64 room_left;
238 bool ret;
239
240 vsk = vsock_sk(sk);
241
242 if (PKT_FIELD(vsk, sent_waiting_write))
243 return true;
244
245 vmci_qpair_get_produce_indexes(vmci_trans(vsk)->qpair, &tail, &head);
246 room_left = vmci_trans(vsk)->produce_size - tail;
247 if (room_needed + 1 >= room_left) {
248 /* Wraps around to current generation. */
249 waiting_info.offset = room_needed + 1 - room_left;
250 waiting_info.generation = PKT_FIELD(vsk, produce_q_generation);
251 } else {
252 waiting_info.offset = tail + room_needed + 1;
253 waiting_info.generation =
254 PKT_FIELD(vsk, produce_q_generation) - 1;
255 }
256
257 ret = vmci_transport_send_waiting_write(sk, &waiting_info) > 0;
258 if (ret)
259 PKT_FIELD(vsk, sent_waiting_write) = true;
260
261 return ret;
262#else
263 return true;
264#endif
265}
266
267static int vmci_transport_send_read_notification(struct sock *sk)
268{
269 struct vsock_sock *vsk;
270 bool sent_read;
271 unsigned int retries;
272 int err;
273
274 vsk = vsock_sk(sk);
275 sent_read = false;
276 retries = 0;
277 err = 0;
278
279 if (vmci_transport_notify_waiting_write(vsk)) {
280 /* Notify the peer that we have read, retrying the send on
281 * failure up to our maximum value. XXX For now we just log
282 * the failure, but later we should schedule a work item to
283 * handle the resend until it succeeds. That would require
284 * keeping track of work items in the vsk and cleaning them up
285 * upon socket close.
286 */
287 while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
288 !sent_read &&
289 retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
290 err = vmci_transport_send_read(sk);
291 if (err >= 0)
292 sent_read = true;
293
294 retries++;
295 }
296
297 if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS)
298 pr_err("%p unable to send read notify to peer\n", sk);
299 else
300#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
301 PKT_FIELD(vsk, peer_waiting_write) = false;
302#endif
303
304 }
305 return err;
306}
307
308static void
309vmci_transport_handle_wrote(struct sock *sk,
310 struct vmci_transport_packet *pkt,
311 bool bottom_half,
312 struct sockaddr_vm *dst, struct sockaddr_vm *src)
313{
314#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
315 struct vsock_sock *vsk = vsock_sk(sk);
316 PKT_FIELD(vsk, sent_waiting_read) = false;
317#endif
318 sk->sk_data_ready(sk, 0);
319}
320
321static void vmci_transport_notify_pkt_socket_init(struct sock *sk)
322{
323 struct vsock_sock *vsk = vsock_sk(sk);
324
325 PKT_FIELD(vsk, write_notify_window) = PAGE_SIZE;
326 PKT_FIELD(vsk, write_notify_min_window) = PAGE_SIZE;
327 PKT_FIELD(vsk, peer_waiting_read) = false;
328 PKT_FIELD(vsk, peer_waiting_write) = false;
329 PKT_FIELD(vsk, peer_waiting_write_detected) = false;
330 PKT_FIELD(vsk, sent_waiting_read) = false;
331 PKT_FIELD(vsk, sent_waiting_write) = false;
332 PKT_FIELD(vsk, produce_q_generation) = 0;
333 PKT_FIELD(vsk, consume_q_generation) = 0;
334
335 memset(&PKT_FIELD(vsk, peer_waiting_read_info), 0,
336 sizeof(PKT_FIELD(vsk, peer_waiting_read_info)));
337 memset(&PKT_FIELD(vsk, peer_waiting_write_info), 0,
338 sizeof(PKT_FIELD(vsk, peer_waiting_write_info)));
339}
340
341static void vmci_transport_notify_pkt_socket_destruct(struct vsock_sock *vsk)
342{
343}
344
345static int
346vmci_transport_notify_pkt_poll_in(struct sock *sk,
347 size_t target, bool *data_ready_now)
348{
349 struct vsock_sock *vsk = vsock_sk(sk);
350
351 if (vsock_stream_has_data(vsk)) {
352 *data_ready_now = true;
353 } else {
354 /* We can't read right now because there is nothing in the
355 * queue. Ask for notifications when there is something to
356 * read.
357 */
358 if (sk->sk_state == SS_CONNECTED) {
359 if (!send_waiting_read(sk, 1))
360 return -1;
361
362 }
363 *data_ready_now = false;
364 }
365
366 return 0;
367}
368
369static int
370vmci_transport_notify_pkt_poll_out(struct sock *sk,
371 size_t target, bool *space_avail_now)
372{
373 s64 produce_q_free_space;
374 struct vsock_sock *vsk = vsock_sk(sk);
375
376 produce_q_free_space = vsock_stream_has_space(vsk);
377 if (produce_q_free_space > 0) {
378 *space_avail_now = true;
379 return 0;
380 } else if (produce_q_free_space == 0) {
381 /* This is a connected socket but we can't currently send data.
382 * Notify the peer that we are waiting if the queue is full. We
383 * only send a waiting write if the queue is full because
384 * otherwise we end up in an infinite WAITING_WRITE, READ,
385 * WAITING_WRITE, READ, etc. loop. Treat failing to send the
386 * notification as a socket error, passing that back through
387 * the mask.
388 */
389 if (!send_waiting_write(sk, 1))
390 return -1;
391
392 *space_avail_now = false;
393 }
394
395 return 0;
396}
397
398static int
399vmci_transport_notify_pkt_recv_init(
400 struct sock *sk,
401 size_t target,
402 struct vmci_transport_recv_notify_data *data)
403{
404 struct vsock_sock *vsk = vsock_sk(sk);
405
406#ifdef VSOCK_OPTIMIZATION_WAITING_NOTIFY
407 data->consume_head = 0;
408 data->produce_tail = 0;
409#ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
410 data->notify_on_block = false;
411
412 if (PKT_FIELD(vsk, write_notify_min_window) < target + 1) {
413 PKT_FIELD(vsk, write_notify_min_window) = target + 1;
414 if (PKT_FIELD(vsk, write_notify_window) <
415 PKT_FIELD(vsk, write_notify_min_window)) {
416 /* If the current window is smaller than the new
417 * minimal window size, we need to reevaluate whether
418 * we need to notify the sender. If the number of ready
419 * bytes are smaller than the new window, we need to
420 * send a notification to the sender before we block.
421 */
422
423 PKT_FIELD(vsk, write_notify_window) =
424 PKT_FIELD(vsk, write_notify_min_window);
425 data->notify_on_block = true;
426 }
427 }
428#endif
429#endif
430
431 return 0;
432}
433
434static int
435vmci_transport_notify_pkt_recv_pre_block(
436 struct sock *sk,
437 size_t target,
438 struct vmci_transport_recv_notify_data *data)
439{
440 int err = 0;
441
442 /* Notify our peer that we are waiting for data to read. */
443 if (!send_waiting_read(sk, target)) {
444 err = -EHOSTUNREACH;
445 return err;
446 }
447#ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
448 if (data->notify_on_block) {
449 err = vmci_transport_send_read_notification(sk);
450 if (err < 0)
451 return err;
452
453 data->notify_on_block = false;
454 }
455#endif
456
457 return err;
458}
459
460static int
461vmci_transport_notify_pkt_recv_pre_dequeue(
462 struct sock *sk,
463 size_t target,
464 struct vmci_transport_recv_notify_data *data)
465{
466 struct vsock_sock *vsk = vsock_sk(sk);
467
468 /* Now consume up to len bytes from the queue. Note that since we have
469 * the socket locked we should copy at least ready bytes.
470 */
471#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
472 vmci_qpair_get_consume_indexes(vmci_trans(vsk)->qpair,
473 &data->produce_tail,
474 &data->consume_head);
475#endif
476
477 return 0;
478}
479
480static int
481vmci_transport_notify_pkt_recv_post_dequeue(
482 struct sock *sk,
483 size_t target,
484 ssize_t copied,
485 bool data_read,
486 struct vmci_transport_recv_notify_data *data)
487{
488 struct vsock_sock *vsk;
489 int err;
490
491 vsk = vsock_sk(sk);
492 err = 0;
493
494 if (data_read) {
495#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
496 /* Detect a wrap-around to maintain queue generation. Note
497 * that this is safe since we hold the socket lock across the
498 * two queue pair operations.
499 */
500 if (copied >=
501 vmci_trans(vsk)->consume_size - data->consume_head)
502 PKT_FIELD(vsk, consume_q_generation)++;
503#endif
504
505 err = vmci_transport_send_read_notification(sk);
506 if (err < 0)
507 return err;
508
509 }
510 return err;
511}
512
513static int
514vmci_transport_notify_pkt_send_init(
515 struct sock *sk,
516 struct vmci_transport_send_notify_data *data)
517{
518#ifdef VSOCK_OPTIMIZATION_WAITING_NOTIFY
519 data->consume_head = 0;
520 data->produce_tail = 0;
521#endif
522
523 return 0;
524}
525
526static int
527vmci_transport_notify_pkt_send_pre_block(
528 struct sock *sk,
529 struct vmci_transport_send_notify_data *data)
530{
531 /* Notify our peer that we are waiting for room to write. */
532 if (!send_waiting_write(sk, 1))
533 return -EHOSTUNREACH;
534
535 return 0;
536}
537
538static int
539vmci_transport_notify_pkt_send_pre_enqueue(
540 struct sock *sk,
541 struct vmci_transport_send_notify_data *data)
542{
543 struct vsock_sock *vsk = vsock_sk(sk);
544
545#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
546 vmci_qpair_get_produce_indexes(vmci_trans(vsk)->qpair,
547 &data->produce_tail,
548 &data->consume_head);
549#endif
550
551 return 0;
552}
553
554static int
555vmci_transport_notify_pkt_send_post_enqueue(
556 struct sock *sk,
557 ssize_t written,
558 struct vmci_transport_send_notify_data *data)
559{
560 int err = 0;
561 struct vsock_sock *vsk;
562 bool sent_wrote = false;
563 int retries = 0;
564
565 vsk = vsock_sk(sk);
566
567#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
568 /* Detect a wrap-around to maintain queue generation. Note that this
569 * is safe since we hold the socket lock across the two queue pair
570 * operations.
571 */
572 if (written >= vmci_trans(vsk)->produce_size - data->produce_tail)
573 PKT_FIELD(vsk, produce_q_generation)++;
574
575#endif
576
577 if (vmci_transport_notify_waiting_read(vsk)) {
578 /* Notify the peer that we have written, retrying the send on
579 * failure up to our maximum value. See the XXX comment for the
580 * corresponding piece of code in StreamRecvmsg() for potential
581 * improvements.
582 */
583 while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
584 !sent_wrote &&
585 retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
586 err = vmci_transport_send_wrote(sk);
587 if (err >= 0)
588 sent_wrote = true;
589
590 retries++;
591 }
592
593 if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
594 pr_err("%p unable to send wrote notify to peer\n", sk);
595 return err;
596 } else {
597#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
598 PKT_FIELD(vsk, peer_waiting_read) = false;
599#endif
600 }
601 }
602 return err;
603}
604
605static void
606vmci_transport_notify_pkt_handle_pkt(
607 struct sock *sk,
608 struct vmci_transport_packet *pkt,
609 bool bottom_half,
610 struct sockaddr_vm *dst,
611 struct sockaddr_vm *src, bool *pkt_processed)
612{
613 bool processed = false;
614
615 switch (pkt->type) {
616 case VMCI_TRANSPORT_PACKET_TYPE_WROTE:
617 vmci_transport_handle_wrote(sk, pkt, bottom_half, dst, src);
618 processed = true;
619 break;
620 case VMCI_TRANSPORT_PACKET_TYPE_READ:
621 vmci_transport_handle_read(sk, pkt, bottom_half, dst, src);
622 processed = true;
623 break;
624 case VMCI_TRANSPORT_PACKET_TYPE_WAITING_WRITE:
625 vmci_transport_handle_waiting_write(sk, pkt, bottom_half,
626 dst, src);
627 processed = true;
628 break;
629
630 case VMCI_TRANSPORT_PACKET_TYPE_WAITING_READ:
631 vmci_transport_handle_waiting_read(sk, pkt, bottom_half,
632 dst, src);
633 processed = true;
634 break;
635 }
636
637 if (pkt_processed)
638 *pkt_processed = processed;
639}
640
641static void vmci_transport_notify_pkt_process_request(struct sock *sk)
642{
643 struct vsock_sock *vsk = vsock_sk(sk);
644
645 PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
646 if (vmci_trans(vsk)->consume_size <
647 PKT_FIELD(vsk, write_notify_min_window))
648 PKT_FIELD(vsk, write_notify_min_window) =
649 vmci_trans(vsk)->consume_size;
650}
651
652static void vmci_transport_notify_pkt_process_negotiate(struct sock *sk)
653{
654 struct vsock_sock *vsk = vsock_sk(sk);
655
656 PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
657 if (vmci_trans(vsk)->consume_size <
658 PKT_FIELD(vsk, write_notify_min_window))
659 PKT_FIELD(vsk, write_notify_min_window) =
660 vmci_trans(vsk)->consume_size;
661}
662
663/* Socket control packet based operations. */
664struct vmci_transport_notify_ops vmci_transport_notify_pkt_ops = {
665 vmci_transport_notify_pkt_socket_init,
666 vmci_transport_notify_pkt_socket_destruct,
667 vmci_transport_notify_pkt_poll_in,
668 vmci_transport_notify_pkt_poll_out,
669 vmci_transport_notify_pkt_handle_pkt,
670 vmci_transport_notify_pkt_recv_init,
671 vmci_transport_notify_pkt_recv_pre_block,
672 vmci_transport_notify_pkt_recv_pre_dequeue,
673 vmci_transport_notify_pkt_recv_post_dequeue,
674 vmci_transport_notify_pkt_send_init,
675 vmci_transport_notify_pkt_send_pre_block,
676 vmci_transport_notify_pkt_send_pre_enqueue,
677 vmci_transport_notify_pkt_send_post_enqueue,
678 vmci_transport_notify_pkt_process_request,
679 vmci_transport_notify_pkt_process_negotiate,
680};
diff --git a/net/vmw_vsock/vmci_transport_notify.h b/net/vmw_vsock/vmci_transport_notify.h
new file mode 100644
index 000000000000..7df793249b6c
--- /dev/null
+++ b/net/vmw_vsock/vmci_transport_notify.h
@@ -0,0 +1,83 @@
1/*
2 * VMware vSockets Driver
3 *
4 * Copyright (C) 2009-2013 VMware, Inc. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16#ifndef __VMCI_TRANSPORT_NOTIFY_H__
17#define __VMCI_TRANSPORT_NOTIFY_H__
18
19#include <linux/types.h>
20#include <linux/vmw_vmci_defs.h>
21#include <linux/vmw_vmci_api.h>
22#include <linux/vm_sockets.h>
23
24#include "vmci_transport.h"
25
26/* Comment this out to compare with old protocol. */
27#define VSOCK_OPTIMIZATION_WAITING_NOTIFY 1
28#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
29/* Comment this out to remove flow control for "new" protocol */
30#define VSOCK_OPTIMIZATION_FLOW_CONTROL 1
31#endif
32
33#define VMCI_TRANSPORT_MAX_DGRAM_RESENDS 10
34
35struct vmci_transport_recv_notify_data {
36 u64 consume_head;
37 u64 produce_tail;
38 bool notify_on_block;
39};
40
41struct vmci_transport_send_notify_data {
42 u64 consume_head;
43 u64 produce_tail;
44};
45
46/* Socket notification callbacks. */
47struct vmci_transport_notify_ops {
48 void (*socket_init) (struct sock *sk);
49 void (*socket_destruct) (struct vsock_sock *vsk);
50 int (*poll_in) (struct sock *sk, size_t target,
51 bool *data_ready_now);
52 int (*poll_out) (struct sock *sk, size_t target,
53 bool *space_avail_now);
54 void (*handle_notify_pkt) (struct sock *sk,
55 struct vmci_transport_packet *pkt,
56 bool bottom_half, struct sockaddr_vm *dst,
57 struct sockaddr_vm *src,
58 bool *pkt_processed);
59 int (*recv_init) (struct sock *sk, size_t target,
60 struct vmci_transport_recv_notify_data *data);
61 int (*recv_pre_block) (struct sock *sk, size_t target,
62 struct vmci_transport_recv_notify_data *data);
63 int (*recv_pre_dequeue) (struct sock *sk, size_t target,
64 struct vmci_transport_recv_notify_data *data);
65 int (*recv_post_dequeue) (struct sock *sk, size_t target,
66 ssize_t copied, bool data_read,
67 struct vmci_transport_recv_notify_data *data);
68 int (*send_init) (struct sock *sk,
69 struct vmci_transport_send_notify_data *data);
70 int (*send_pre_block) (struct sock *sk,
71 struct vmci_transport_send_notify_data *data);
72 int (*send_pre_enqueue) (struct sock *sk,
73 struct vmci_transport_send_notify_data *data);
74 int (*send_post_enqueue) (struct sock *sk, ssize_t written,
75 struct vmci_transport_send_notify_data *data);
76 void (*process_request) (struct sock *sk);
77 void (*process_negotiate) (struct sock *sk);
78};
79
80extern struct vmci_transport_notify_ops vmci_transport_notify_pkt_ops;
81extern struct vmci_transport_notify_ops vmci_transport_notify_pkt_q_state_ops;
82
83#endif /* __VMCI_TRANSPORT_NOTIFY_H__ */
diff --git a/net/vmw_vsock/vmci_transport_notify_qstate.c b/net/vmw_vsock/vmci_transport_notify_qstate.c
new file mode 100644
index 000000000000..622bd7aa1016
--- /dev/null
+++ b/net/vmw_vsock/vmci_transport_notify_qstate.c
@@ -0,0 +1,438 @@
1/*
2 * VMware vSockets Driver
3 *
4 * Copyright (C) 2009-2013 VMware, Inc. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16#include <linux/types.h>
17#include <linux/socket.h>
18#include <linux/stddef.h>
19#include <net/sock.h>
20
21#include "vmci_transport_notify.h"
22
23#define PKT_FIELD(vsk, field_name) \
24 (vmci_trans(vsk)->notify.pkt_q_state.field_name)
25
26static bool vmci_transport_notify_waiting_write(struct vsock_sock *vsk)
27{
28 bool retval;
29 u64 notify_limit;
30
31 if (!PKT_FIELD(vsk, peer_waiting_write))
32 return false;
33
34 /* When the sender blocks, we take that as a sign that the sender is
35 * faster than the receiver. To reduce the transmit rate of the sender,
36 * we delay the sending of the read notification by decreasing the
37 * write_notify_window. The notification is delayed until the number of
38 * bytes used in the queue drops below the write_notify_window.
39 */
40
41 if (!PKT_FIELD(vsk, peer_waiting_write_detected)) {
42 PKT_FIELD(vsk, peer_waiting_write_detected) = true;
43 if (PKT_FIELD(vsk, write_notify_window) < PAGE_SIZE) {
44 PKT_FIELD(vsk, write_notify_window) =
45 PKT_FIELD(vsk, write_notify_min_window);
46 } else {
47 PKT_FIELD(vsk, write_notify_window) -= PAGE_SIZE;
48 if (PKT_FIELD(vsk, write_notify_window) <
49 PKT_FIELD(vsk, write_notify_min_window))
50 PKT_FIELD(vsk, write_notify_window) =
51 PKT_FIELD(vsk, write_notify_min_window);
52
53 }
54 }
55 notify_limit = vmci_trans(vsk)->consume_size -
56 PKT_FIELD(vsk, write_notify_window);
57
58 /* The notify_limit is used to delay notifications in the case where
59 * flow control is enabled. Below the test is expressed in terms of
60 * free space in the queue: if free_space > ConsumeSize -
61 * write_notify_window then notify An alternate way of expressing this
62 * is to rewrite the expression to use the data ready in the receive
63 * queue: if write_notify_window > bufferReady then notify as
64 * free_space == ConsumeSize - bufferReady.
65 */
66
67 retval = vmci_qpair_consume_free_space(vmci_trans(vsk)->qpair) >
68 notify_limit;
69
70 if (retval) {
71 /* Once we notify the peer, we reset the detected flag so the
72 * next wait will again cause a decrease in the window size.
73 */
74
75 PKT_FIELD(vsk, peer_waiting_write_detected) = false;
76 }
77 return retval;
78}
79
80static void
81vmci_transport_handle_read(struct sock *sk,
82 struct vmci_transport_packet *pkt,
83 bool bottom_half,
84 struct sockaddr_vm *dst, struct sockaddr_vm *src)
85{
86 sk->sk_write_space(sk);
87}
88
89static void
90vmci_transport_handle_wrote(struct sock *sk,
91 struct vmci_transport_packet *pkt,
92 bool bottom_half,
93 struct sockaddr_vm *dst, struct sockaddr_vm *src)
94{
95 sk->sk_data_ready(sk, 0);
96}
97
98static void vsock_block_update_write_window(struct sock *sk)
99{
100 struct vsock_sock *vsk = vsock_sk(sk);
101
102 if (PKT_FIELD(vsk, write_notify_window) < vmci_trans(vsk)->consume_size)
103 PKT_FIELD(vsk, write_notify_window) =
104 min(PKT_FIELD(vsk, write_notify_window) + PAGE_SIZE,
105 vmci_trans(vsk)->consume_size);
106}
107
108static int vmci_transport_send_read_notification(struct sock *sk)
109{
110 struct vsock_sock *vsk;
111 bool sent_read;
112 unsigned int retries;
113 int err;
114
115 vsk = vsock_sk(sk);
116 sent_read = false;
117 retries = 0;
118 err = 0;
119
120 if (vmci_transport_notify_waiting_write(vsk)) {
121 /* Notify the peer that we have read, retrying the send on
122 * failure up to our maximum value. XXX For now we just log
123 * the failure, but later we should schedule a work item to
124 * handle the resend until it succeeds. That would require
125 * keeping track of work items in the vsk and cleaning them up
126 * upon socket close.
127 */
128 while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
129 !sent_read &&
130 retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
131 err = vmci_transport_send_read(sk);
132 if (err >= 0)
133 sent_read = true;
134
135 retries++;
136 }
137
138 if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS && !sent_read)
139 pr_err("%p unable to send read notification to peer\n",
140 sk);
141 else
142 PKT_FIELD(vsk, peer_waiting_write) = false;
143
144 }
145 return err;
146}
147
148static void vmci_transport_notify_pkt_socket_init(struct sock *sk)
149{
150 struct vsock_sock *vsk = vsock_sk(sk);
151
152 PKT_FIELD(vsk, write_notify_window) = PAGE_SIZE;
153 PKT_FIELD(vsk, write_notify_min_window) = PAGE_SIZE;
154 PKT_FIELD(vsk, peer_waiting_write) = false;
155 PKT_FIELD(vsk, peer_waiting_write_detected) = false;
156}
157
158static void vmci_transport_notify_pkt_socket_destruct(struct vsock_sock *vsk)
159{
160 PKT_FIELD(vsk, write_notify_window) = PAGE_SIZE;
161 PKT_FIELD(vsk, write_notify_min_window) = PAGE_SIZE;
162 PKT_FIELD(vsk, peer_waiting_write) = false;
163 PKT_FIELD(vsk, peer_waiting_write_detected) = false;
164}
165
166static int
167vmci_transport_notify_pkt_poll_in(struct sock *sk,
168 size_t target, bool *data_ready_now)
169{
170 struct vsock_sock *vsk = vsock_sk(sk);
171
172 if (vsock_stream_has_data(vsk)) {
173 *data_ready_now = true;
174 } else {
175 /* We can't read right now because there is nothing in the
176 * queue. Ask for notifications when there is something to
177 * read.
178 */
179 if (sk->sk_state == SS_CONNECTED)
180 vsock_block_update_write_window(sk);
181 *data_ready_now = false;
182 }
183
184 return 0;
185}
186
187static int
188vmci_transport_notify_pkt_poll_out(struct sock *sk,
189 size_t target, bool *space_avail_now)
190{
191 s64 produce_q_free_space;
192 struct vsock_sock *vsk = vsock_sk(sk);
193
194 produce_q_free_space = vsock_stream_has_space(vsk);
195 if (produce_q_free_space > 0) {
196 *space_avail_now = true;
197 return 0;
198 } else if (produce_q_free_space == 0) {
199 /* This is a connected socket but we can't currently send data.
200 * Nothing else to do.
201 */
202 *space_avail_now = false;
203 }
204
205 return 0;
206}
207
208static int
209vmci_transport_notify_pkt_recv_init(
210 struct sock *sk,
211 size_t target,
212 struct vmci_transport_recv_notify_data *data)
213{
214 struct vsock_sock *vsk = vsock_sk(sk);
215
216 data->consume_head = 0;
217 data->produce_tail = 0;
218 data->notify_on_block = false;
219
220 if (PKT_FIELD(vsk, write_notify_min_window) < target + 1) {
221 PKT_FIELD(vsk, write_notify_min_window) = target + 1;
222 if (PKT_FIELD(vsk, write_notify_window) <
223 PKT_FIELD(vsk, write_notify_min_window)) {
224 /* If the current window is smaller than the new
225 * minimal window size, we need to reevaluate whether
226 * we need to notify the sender. If the number of ready
227 * bytes are smaller than the new window, we need to
228 * send a notification to the sender before we block.
229 */
230
231 PKT_FIELD(vsk, write_notify_window) =
232 PKT_FIELD(vsk, write_notify_min_window);
233 data->notify_on_block = true;
234 }
235 }
236
237 return 0;
238}
239
240static int
241vmci_transport_notify_pkt_recv_pre_block(
242 struct sock *sk,
243 size_t target,
244 struct vmci_transport_recv_notify_data *data)
245{
246 int err = 0;
247
248 vsock_block_update_write_window(sk);
249
250 if (data->notify_on_block) {
251 err = vmci_transport_send_read_notification(sk);
252 if (err < 0)
253 return err;
254 data->notify_on_block = false;
255 }
256
257 return err;
258}
259
260static int
261vmci_transport_notify_pkt_recv_post_dequeue(
262 struct sock *sk,
263 size_t target,
264 ssize_t copied,
265 bool data_read,
266 struct vmci_transport_recv_notify_data *data)
267{
268 struct vsock_sock *vsk;
269 int err;
270 bool was_full = false;
271 u64 free_space;
272
273 vsk = vsock_sk(sk);
274 err = 0;
275
276 if (data_read) {
277 smp_mb();
278
279 free_space =
280 vmci_qpair_consume_free_space(vmci_trans(vsk)->qpair);
281 was_full = free_space == copied;
282
283 if (was_full)
284 PKT_FIELD(vsk, peer_waiting_write) = true;
285
286 err = vmci_transport_send_read_notification(sk);
287 if (err < 0)
288 return err;
289
290 /* See the comment in
291 * vmci_transport_notify_pkt_send_post_enqueue().
292 */
293 sk->sk_data_ready(sk, 0);
294 }
295
296 return err;
297}
298
299static int
300vmci_transport_notify_pkt_send_init(
301 struct sock *sk,
302 struct vmci_transport_send_notify_data *data)
303{
304 data->consume_head = 0;
305 data->produce_tail = 0;
306
307 return 0;
308}
309
310static int
311vmci_transport_notify_pkt_send_post_enqueue(
312 struct sock *sk,
313 ssize_t written,
314 struct vmci_transport_send_notify_data *data)
315{
316 int err = 0;
317 struct vsock_sock *vsk;
318 bool sent_wrote = false;
319 bool was_empty;
320 int retries = 0;
321
322 vsk = vsock_sk(sk);
323
324 smp_mb();
325
326 was_empty =
327 vmci_qpair_produce_buf_ready(vmci_trans(vsk)->qpair) == written;
328 if (was_empty) {
329 while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
330 !sent_wrote &&
331 retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
332 err = vmci_transport_send_wrote(sk);
333 if (err >= 0)
334 sent_wrote = true;
335
336 retries++;
337 }
338 }
339
340 if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS && !sent_wrote) {
341 pr_err("%p unable to send wrote notification to peer\n",
342 sk);
343 return err;
344 }
345
346 return err;
347}
348
349static void
350vmci_transport_notify_pkt_handle_pkt(
351 struct sock *sk,
352 struct vmci_transport_packet *pkt,
353 bool bottom_half,
354 struct sockaddr_vm *dst,
355 struct sockaddr_vm *src, bool *pkt_processed)
356{
357 bool processed = false;
358
359 switch (pkt->type) {
360 case VMCI_TRANSPORT_PACKET_TYPE_WROTE:
361 vmci_transport_handle_wrote(sk, pkt, bottom_half, dst, src);
362 processed = true;
363 break;
364 case VMCI_TRANSPORT_PACKET_TYPE_READ:
365 vmci_transport_handle_read(sk, pkt, bottom_half, dst, src);
366 processed = true;
367 break;
368 }
369
370 if (pkt_processed)
371 *pkt_processed = processed;
372}
373
374static void vmci_transport_notify_pkt_process_request(struct sock *sk)
375{
376 struct vsock_sock *vsk = vsock_sk(sk);
377
378 PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
379 if (vmci_trans(vsk)->consume_size <
380 PKT_FIELD(vsk, write_notify_min_window))
381 PKT_FIELD(vsk, write_notify_min_window) =
382 vmci_trans(vsk)->consume_size;
383}
384
385static void vmci_transport_notify_pkt_process_negotiate(struct sock *sk)
386{
387 struct vsock_sock *vsk = vsock_sk(sk);
388
389 PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
390 if (vmci_trans(vsk)->consume_size <
391 PKT_FIELD(vsk, write_notify_min_window))
392 PKT_FIELD(vsk, write_notify_min_window) =
393 vmci_trans(vsk)->consume_size;
394}
395
396static int
397vmci_transport_notify_pkt_recv_pre_dequeue(
398 struct sock *sk,
399 size_t target,
400 struct vmci_transport_recv_notify_data *data)
401{
402 return 0; /* NOP for QState. */
403}
404
405static int
406vmci_transport_notify_pkt_send_pre_block(
407 struct sock *sk,
408 struct vmci_transport_send_notify_data *data)
409{
410 return 0; /* NOP for QState. */
411}
412
413static int
414vmci_transport_notify_pkt_send_pre_enqueue(
415 struct sock *sk,
416 struct vmci_transport_send_notify_data *data)
417{
418 return 0; /* NOP for QState. */
419}
420
421/* Socket always on control packet based operations. */
422struct vmci_transport_notify_ops vmci_transport_notify_pkt_q_state_ops = {
423 vmci_transport_notify_pkt_socket_init,
424 vmci_transport_notify_pkt_socket_destruct,
425 vmci_transport_notify_pkt_poll_in,
426 vmci_transport_notify_pkt_poll_out,
427 vmci_transport_notify_pkt_handle_pkt,
428 vmci_transport_notify_pkt_recv_init,
429 vmci_transport_notify_pkt_recv_pre_block,
430 vmci_transport_notify_pkt_recv_pre_dequeue,
431 vmci_transport_notify_pkt_recv_post_dequeue,
432 vmci_transport_notify_pkt_send_init,
433 vmci_transport_notify_pkt_send_pre_block,
434 vmci_transport_notify_pkt_send_pre_enqueue,
435 vmci_transport_notify_pkt_send_post_enqueue,
436 vmci_transport_notify_pkt_process_request,
437 vmci_transport_notify_pkt_process_negotiate,
438};
diff --git a/net/vmw_vsock/vsock_addr.c b/net/vmw_vsock/vsock_addr.c
new file mode 100644
index 000000000000..b7df1aea7c59
--- /dev/null
+++ b/net/vmw_vsock/vsock_addr.c
@@ -0,0 +1,86 @@
1/*
2 * VMware vSockets Driver
3 *
4 * Copyright (C) 2007-2012 VMware, Inc. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16#include <linux/types.h>
17#include <linux/socket.h>
18#include <linux/stddef.h>
19#include <net/sock.h>
20
21#include "vsock_addr.h"
22
23void vsock_addr_init(struct sockaddr_vm *addr, u32 cid, u32 port)
24{
25 memset(addr, 0, sizeof(*addr));
26 addr->svm_family = AF_VSOCK;
27 addr->svm_cid = cid;
28 addr->svm_port = port;
29}
30EXPORT_SYMBOL_GPL(vsock_addr_init);
31
32int vsock_addr_validate(const struct sockaddr_vm *addr)
33{
34 if (!addr)
35 return -EFAULT;
36
37 if (addr->svm_family != AF_VSOCK)
38 return -EAFNOSUPPORT;
39
40 if (addr->svm_zero[0] != 0)
41 return -EINVAL;
42
43 return 0;
44}
45EXPORT_SYMBOL_GPL(vsock_addr_validate);
46
47bool vsock_addr_bound(const struct sockaddr_vm *addr)
48{
49 return addr->svm_port != VMADDR_PORT_ANY;
50}
51EXPORT_SYMBOL_GPL(vsock_addr_bound);
52
53void vsock_addr_unbind(struct sockaddr_vm *addr)
54{
55 vsock_addr_init(addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
56}
57EXPORT_SYMBOL_GPL(vsock_addr_unbind);
58
59bool vsock_addr_equals_addr(const struct sockaddr_vm *addr,
60 const struct sockaddr_vm *other)
61{
62 return addr->svm_cid == other->svm_cid &&
63 addr->svm_port == other->svm_port;
64}
65EXPORT_SYMBOL_GPL(vsock_addr_equals_addr);
66
67bool vsock_addr_equals_addr_any(const struct sockaddr_vm *addr,
68 const struct sockaddr_vm *other)
69{
70 return (addr->svm_cid == VMADDR_CID_ANY ||
71 other->svm_cid == VMADDR_CID_ANY ||
72 addr->svm_cid == other->svm_cid) &&
73 addr->svm_port == other->svm_port;
74}
75EXPORT_SYMBOL_GPL(vsock_addr_equals_addr_any);
76
77int vsock_addr_cast(const struct sockaddr *addr,
78 size_t len, struct sockaddr_vm **out_addr)
79{
80 if (len < sizeof(**out_addr))
81 return -EFAULT;
82
83 *out_addr = (struct sockaddr_vm *)addr;
84 return vsock_addr_validate(*out_addr);
85}
86EXPORT_SYMBOL_GPL(vsock_addr_cast);
diff --git a/net/vmw_vsock/vsock_addr.h b/net/vmw_vsock/vsock_addr.h
new file mode 100644
index 000000000000..cdfbcefdf843
--- /dev/null
+++ b/net/vmw_vsock/vsock_addr.h
@@ -0,0 +1,32 @@
1/*
2 * VMware vSockets Driver
3 *
4 * Copyright (C) 2007-2013 VMware, Inc. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation version 2 and no later version.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 */
15
16#ifndef _VSOCK_ADDR_H_
17#define _VSOCK_ADDR_H_
18
19#include <linux/vm_sockets.h>
20
21void vsock_addr_init(struct sockaddr_vm *addr, u32 cid, u32 port);
22int vsock_addr_validate(const struct sockaddr_vm *addr);
23bool vsock_addr_bound(const struct sockaddr_vm *addr);
24void vsock_addr_unbind(struct sockaddr_vm *addr);
25bool vsock_addr_equals_addr(const struct sockaddr_vm *addr,
26 const struct sockaddr_vm *other);
27bool vsock_addr_equals_addr_any(const struct sockaddr_vm *addr,
28 const struct sockaddr_vm *other);
29int vsock_addr_cast(const struct sockaddr *addr, size_t len,
30 struct sockaddr_vm **out_addr);
31
32#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-22 06:13:01 -0500