?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: usb-audio: Fix an out-of-bound read in create_composite_quirks
[linux/fpc-iii.git] / net / vmw_vsock / vmci_transport.c
blobd24773552b641ca165913de5b89d22618676a757
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 #include <net/af_vsock.h>
38
39 #include "vmci_transport_notify.h"
40
41 static int vmci_transport_recv_dgram_cb(void *data, struct vmci_datagram *dg);
42 static int vmci_transport_recv_stream_cb(void *data, struct vmci_datagram *dg);
43 static void vmci_transport_peer_detach_cb(u32 sub_id,
44 const struct vmci_event_data *ed,
45 void *client_data);
46 static void vmci_transport_recv_pkt_work(struct work_struct *work);
47 static void vmci_transport_cleanup(struct work_struct *work);
48 static int vmci_transport_recv_listen(struct sock *sk,
49 struct vmci_transport_packet *pkt);
50 static int vmci_transport_recv_connecting_server(
51 struct sock *sk,
52 struct sock *pending,
53 struct vmci_transport_packet *pkt);
54 static int vmci_transport_recv_connecting_client(
55 struct sock *sk,
56 struct vmci_transport_packet *pkt);
57 static int vmci_transport_recv_connecting_client_negotiate(
58 struct sock *sk,
59 struct vmci_transport_packet *pkt);
60 static int vmci_transport_recv_connecting_client_invalid(
61 struct sock *sk,
62 struct vmci_transport_packet *pkt);
63 static int vmci_transport_recv_connected(struct sock *sk,
64 struct vmci_transport_packet *pkt);
65 static bool vmci_transport_old_proto_override(bool *old_pkt_proto);
66 static u16 vmci_transport_new_proto_supported_versions(void);
67 static bool vmci_transport_proto_to_notify_struct(struct sock *sk, u16 *proto,
68 bool old_pkt_proto);
69
70 struct vmci_transport_recv_pkt_info {
71 struct work_struct work;
72 struct sock *sk;
73 struct vmci_transport_packet pkt;
74 };
75
76 static LIST_HEAD(vmci_transport_cleanup_list);
77 static DEFINE_SPINLOCK(vmci_transport_cleanup_lock);
78 static DECLARE_WORK(vmci_transport_cleanup_work, vmci_transport_cleanup);
79
80 static struct vmci_handle vmci_transport_stream_handle = { VMCI_INVALID_ID,
81 VMCI_INVALID_ID };
82 static u32 vmci_transport_qp_resumed_sub_id = VMCI_INVALID_ID;
83
84 static int PROTOCOL_OVERRIDE = -1;
85
86 #define VMCI_TRANSPORT_DEFAULT_QP_SIZE_MIN 128
87 #define VMCI_TRANSPORT_DEFAULT_QP_SIZE 262144
88 #define VMCI_TRANSPORT_DEFAULT_QP_SIZE_MAX 262144
89
90 /* The default peer timeout indicates how long we will wait for a peer response
91 * to a control message.
92 */
93 #define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ)
94
95 /* Helper function to convert from a VMCI error code to a VSock error code. */
96
97 static 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
126 static u32 vmci_transport_peer_rid(u32 peer_cid)
127 {
128 if (VMADDR_CID_HYPERVISOR == peer_cid)
129 return VMCI_TRANSPORT_HYPERVISOR_PACKET_RID;
130
131 return VMCI_TRANSPORT_PACKET_RID;
132 }
133
134 static inline void
135 vmci_transport_packet_init(struct vmci_transport_packet *pkt,
136 struct sockaddr_vm *src,
137 struct sockaddr_vm *dst,
138 u8 type,
139 u64 size,
140 u64 mode,
141 struct vmci_transport_waiting_info *wait,
142 u16 proto,
143 struct vmci_handle handle)
144 {
145 /* We register the stream control handler as an any cid handle so we
146 * must always send from a source address of VMADDR_CID_ANY
147 */
148 pkt->dg.src = vmci_make_handle(VMADDR_CID_ANY,
149 VMCI_TRANSPORT_PACKET_RID);
150 pkt->dg.dst = vmci_make_handle(dst->svm_cid,
151 vmci_transport_peer_rid(dst->svm_cid));
152 pkt->dg.payload_size = sizeof(*pkt) - sizeof(pkt->dg);
153 pkt->version = VMCI_TRANSPORT_PACKET_VERSION;
154 pkt->type = type;
155 pkt->src_port = src->svm_port;
156 pkt->dst_port = dst->svm_port;
157 memset(&pkt->proto, 0, sizeof(pkt->proto));
158 memset(&pkt->_reserved2, 0, sizeof(pkt->_reserved2));
159
160 switch (pkt->type) {
161 case VMCI_TRANSPORT_PACKET_TYPE_INVALID:
162 pkt->u.size = 0;
163 break;
164
165 case VMCI_TRANSPORT_PACKET_TYPE_REQUEST:
166 case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE:
167 pkt->u.size = size;
168 break;
169
170 case VMCI_TRANSPORT_PACKET_TYPE_OFFER:
171 case VMCI_TRANSPORT_PACKET_TYPE_ATTACH:
172 pkt->u.handle = handle;
173 break;
174
175 case VMCI_TRANSPORT_PACKET_TYPE_WROTE:
176 case VMCI_TRANSPORT_PACKET_TYPE_READ:
177 case VMCI_TRANSPORT_PACKET_TYPE_RST:
178 pkt->u.size = 0;
179 break;
180
181 case VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN:
182 pkt->u.mode = mode;
183 break;
184
185 case VMCI_TRANSPORT_PACKET_TYPE_WAITING_READ:
186 case VMCI_TRANSPORT_PACKET_TYPE_WAITING_WRITE:
187 memcpy(&pkt->u.wait, wait, sizeof(pkt->u.wait));
188 break;
189
190 case VMCI_TRANSPORT_PACKET_TYPE_REQUEST2:
191 case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2:
192 pkt->u.size = size;
193 pkt->proto = proto;
194 break;
195 }
196 }
197
198 static inline void
199 vmci_transport_packet_get_addresses(struct vmci_transport_packet *pkt,
200 struct sockaddr_vm *local,
201 struct sockaddr_vm *remote)
202 {
203 vsock_addr_init(local, pkt->dg.dst.context, pkt->dst_port);
204 vsock_addr_init(remote, pkt->dg.src.context, pkt->src_port);
205 }
206
207 static int
208 __vmci_transport_send_control_pkt(struct vmci_transport_packet *pkt,
209 struct sockaddr_vm *src,
210 struct sockaddr_vm *dst,
211 enum vmci_transport_packet_type type,
212 u64 size,
213 u64 mode,
214 struct vmci_transport_waiting_info *wait,
215 u16 proto,
216 struct vmci_handle handle,
217 bool convert_error)
218 {
219 int err;
220
221 vmci_transport_packet_init(pkt, src, dst, type, size, mode, wait,
222 proto, handle);
223 err = vmci_datagram_send(&pkt->dg);
224 if (convert_error && (err < 0))
225 return vmci_transport_error_to_vsock_error(err);
226
227 return err;
228 }
229
230 static int
231 vmci_transport_reply_control_pkt_fast(struct vmci_transport_packet *pkt,
232 enum vmci_transport_packet_type type,
233 u64 size,
234 u64 mode,
235 struct vmci_transport_waiting_info *wait,
236 struct vmci_handle handle)
237 {
238 struct vmci_transport_packet reply;
239 struct sockaddr_vm src, dst;
240
241 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST) {
242 return 0;
243 } else {
244 vmci_transport_packet_get_addresses(pkt, &src, &dst);
245 return __vmci_transport_send_control_pkt(&reply, &src, &dst,
246 type,
247 size, mode, wait,
248 VSOCK_PROTO_INVALID,
249 handle, true);
250 }
251 }
252
253 static int
254 vmci_transport_send_control_pkt_bh(struct sockaddr_vm *src,
255 struct sockaddr_vm *dst,
256 enum vmci_transport_packet_type type,
257 u64 size,
258 u64 mode,
259 struct vmci_transport_waiting_info *wait,
260 struct vmci_handle handle)
261 {
262 /* Note that it is safe to use a single packet across all CPUs since
263 * two tasklets of the same type are guaranteed to not ever run
264 * simultaneously. If that ever changes, or VMCI stops using tasklets,
265 * we can use per-cpu packets.
266 */
267 static struct vmci_transport_packet pkt;
268
269 return __vmci_transport_send_control_pkt(&pkt, src, dst, type,
270 size, mode, wait,
271 VSOCK_PROTO_INVALID, handle,
272 false);
273 }
274
275 static int
276 vmci_transport_alloc_send_control_pkt(struct sockaddr_vm *src,
277 struct sockaddr_vm *dst,
278 enum vmci_transport_packet_type type,
279 u64 size,
280 u64 mode,
281 struct vmci_transport_waiting_info *wait,
282 u16 proto,
283 struct vmci_handle handle)
284 {
285 struct vmci_transport_packet *pkt;
286 int err;
287
288 pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
289 if (!pkt)
290 return -ENOMEM;
291
292 err = __vmci_transport_send_control_pkt(pkt, src, dst, type, size,
293 mode, wait, proto, handle,
294 true);
295 kfree(pkt);
296
297 return err;
298 }
299
300 static int
301 vmci_transport_send_control_pkt(struct sock *sk,
302 enum vmci_transport_packet_type type,
303 u64 size,
304 u64 mode,
305 struct vmci_transport_waiting_info *wait,
306 u16 proto,
307 struct vmci_handle handle)
308 {
309 struct vsock_sock *vsk;
310
311 vsk = vsock_sk(sk);
312
313 if (!vsock_addr_bound(&vsk->local_addr))
314 return -EINVAL;
315
316 if (!vsock_addr_bound(&vsk->remote_addr))
317 return -EINVAL;
318
319 return vmci_transport_alloc_send_control_pkt(&vsk->local_addr,
320 &vsk->remote_addr,
321 type, size, mode,
322 wait, proto, handle);
323 }
324
325 static int vmci_transport_send_reset_bh(struct sockaddr_vm *dst,
326 struct sockaddr_vm *src,
327 struct vmci_transport_packet *pkt)
328 {
329 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST)
330 return 0;
331 return vmci_transport_send_control_pkt_bh(
332 dst, src,
333 VMCI_TRANSPORT_PACKET_TYPE_RST, 0,
334 0, NULL, VMCI_INVALID_HANDLE);
335 }
336
337 static int vmci_transport_send_reset(struct sock *sk,
338 struct vmci_transport_packet *pkt)
339 {
340 struct sockaddr_vm *dst_ptr;
341 struct sockaddr_vm dst;
342 struct vsock_sock *vsk;
343
344 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST)
345 return 0;
346
347 vsk = vsock_sk(sk);
348
349 if (!vsock_addr_bound(&vsk->local_addr))
350 return -EINVAL;
351
352 if (vsock_addr_bound(&vsk->remote_addr)) {
353 dst_ptr = &vsk->remote_addr;
354 } else {
355 vsock_addr_init(&dst, pkt->dg.src.context,
356 pkt->src_port);
357 dst_ptr = &dst;
358 }
359 return vmci_transport_alloc_send_control_pkt(&vsk->local_addr, dst_ptr,
360 VMCI_TRANSPORT_PACKET_TYPE_RST,
361 0, 0, NULL, VSOCK_PROTO_INVALID,
362 VMCI_INVALID_HANDLE);
363 }
364
365 static int vmci_transport_send_negotiate(struct sock *sk, size_t size)
366 {
367 return vmci_transport_send_control_pkt(
368 sk,
369 VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE,
370 size, 0, NULL,
371 VSOCK_PROTO_INVALID,
372 VMCI_INVALID_HANDLE);
373 }
374
375 static int vmci_transport_send_negotiate2(struct sock *sk, size_t size,
376 u16 version)
377 {
378 return vmci_transport_send_control_pkt(
379 sk,
380 VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2,
381 size, 0, NULL, version,
382 VMCI_INVALID_HANDLE);
383 }
384
385 static int vmci_transport_send_qp_offer(struct sock *sk,
386 struct vmci_handle handle)
387 {
388 return vmci_transport_send_control_pkt(
389 sk, VMCI_TRANSPORT_PACKET_TYPE_OFFER, 0,
390 0, NULL,
391 VSOCK_PROTO_INVALID, handle);
392 }
393
394 static int vmci_transport_send_attach(struct sock *sk,
395 struct vmci_handle handle)
396 {
397 return vmci_transport_send_control_pkt(
398 sk, VMCI_TRANSPORT_PACKET_TYPE_ATTACH,
399 0, 0, NULL, VSOCK_PROTO_INVALID,
400 handle);
401 }
402
403 static int vmci_transport_reply_reset(struct vmci_transport_packet *pkt)
404 {
405 return vmci_transport_reply_control_pkt_fast(
406 pkt,
407 VMCI_TRANSPORT_PACKET_TYPE_RST,
408 0, 0, NULL,
409 VMCI_INVALID_HANDLE);
410 }
411
412 static int vmci_transport_send_invalid_bh(struct sockaddr_vm *dst,
413 struct sockaddr_vm *src)
414 {
415 return vmci_transport_send_control_pkt_bh(
416 dst, src,
417 VMCI_TRANSPORT_PACKET_TYPE_INVALID,
418 0, 0, NULL, VMCI_INVALID_HANDLE);
419 }
420
421 int vmci_transport_send_wrote_bh(struct sockaddr_vm *dst,
422 struct sockaddr_vm *src)
423 {
424 return vmci_transport_send_control_pkt_bh(
425 dst, src,
426 VMCI_TRANSPORT_PACKET_TYPE_WROTE, 0,
427 0, NULL, VMCI_INVALID_HANDLE);
428 }
429
430 int vmci_transport_send_read_bh(struct sockaddr_vm *dst,
431 struct sockaddr_vm *src)
432 {
433 return vmci_transport_send_control_pkt_bh(
434 dst, src,
435 VMCI_TRANSPORT_PACKET_TYPE_READ, 0,
436 0, NULL, VMCI_INVALID_HANDLE);
437 }
438
439 int vmci_transport_send_wrote(struct sock *sk)
440 {
441 return vmci_transport_send_control_pkt(
442 sk, VMCI_TRANSPORT_PACKET_TYPE_WROTE, 0,
443 0, NULL, VSOCK_PROTO_INVALID,
444 VMCI_INVALID_HANDLE);
445 }
446
447 int vmci_transport_send_read(struct sock *sk)
448 {
449 return vmci_transport_send_control_pkt(
450 sk, VMCI_TRANSPORT_PACKET_TYPE_READ, 0,
451 0, NULL, VSOCK_PROTO_INVALID,
452 VMCI_INVALID_HANDLE);
453 }
454
455 int vmci_transport_send_waiting_write(struct sock *sk,
456 struct vmci_transport_waiting_info *wait)
457 {
458 return vmci_transport_send_control_pkt(
459 sk, VMCI_TRANSPORT_PACKET_TYPE_WAITING_WRITE,
460 0, 0, wait, VSOCK_PROTO_INVALID,
461 VMCI_INVALID_HANDLE);
462 }
463
464 int vmci_transport_send_waiting_read(struct sock *sk,
465 struct vmci_transport_waiting_info *wait)
466 {
467 return vmci_transport_send_control_pkt(
468 sk, VMCI_TRANSPORT_PACKET_TYPE_WAITING_READ,
469 0, 0, wait, VSOCK_PROTO_INVALID,
470 VMCI_INVALID_HANDLE);
471 }
472
473 static int vmci_transport_shutdown(struct vsock_sock *vsk, int mode)
474 {
475 return vmci_transport_send_control_pkt(
476 &vsk->sk,
477 VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN,
478 0, mode, NULL,
479 VSOCK_PROTO_INVALID,
480 VMCI_INVALID_HANDLE);
481 }
482
483 static int vmci_transport_send_conn_request(struct sock *sk, size_t size)
484 {
485 return vmci_transport_send_control_pkt(sk,
486 VMCI_TRANSPORT_PACKET_TYPE_REQUEST,
487 size, 0, NULL,
488 VSOCK_PROTO_INVALID,
489 VMCI_INVALID_HANDLE);
490 }
491
492 static int vmci_transport_send_conn_request2(struct sock *sk, size_t size,
493 u16 version)
494 {
495 return vmci_transport_send_control_pkt(
496 sk, VMCI_TRANSPORT_PACKET_TYPE_REQUEST2,
497 size, 0, NULL, version,
498 VMCI_INVALID_HANDLE);
499 }
500
501 static struct sock *vmci_transport_get_pending(
502 struct sock *listener,
503 struct vmci_transport_packet *pkt)
504 {
505 struct vsock_sock *vlistener;
506 struct vsock_sock *vpending;
507 struct sock *pending;
508 struct sockaddr_vm src;
509
510 vsock_addr_init(&src, pkt->dg.src.context, pkt->src_port);
511
512 vlistener = vsock_sk(listener);
513
514 list_for_each_entry(vpending, &vlistener->pending_links,
515 pending_links) {
516 if (vsock_addr_equals_addr(&src, &vpending->remote_addr) &&
517 pkt->dst_port == vpending->local_addr.svm_port) {
518 pending = sk_vsock(vpending);
519 sock_hold(pending);
520 goto found;
521 }
522 }
523
524 pending = NULL;
525 found:
526 return pending;
527
528 }
529
530 static void vmci_transport_release_pending(struct sock *pending)
531 {
532 sock_put(pending);
533 }
534
535 /* We allow two kinds of sockets to communicate with a restricted VM: 1)
536 * trusted sockets 2) sockets from applications running as the same user as the
537 * VM (this is only true for the host side and only when using hosted products)
538 */
539
540 static bool vmci_transport_is_trusted(struct vsock_sock *vsock, u32 peer_cid)
541 {
542 return vsock->trusted ||
543 vmci_is_context_owner(peer_cid, vsock->owner->uid);
544 }
545
546 /* We allow sending datagrams to and receiving datagrams from a restricted VM
547 * only if it is trusted as described in vmci_transport_is_trusted.
548 */
549
550 static bool vmci_transport_allow_dgram(struct vsock_sock *vsock, u32 peer_cid)
551 {
552 if (VMADDR_CID_HYPERVISOR == peer_cid)
553 return true;
554
555 if (vsock->cached_peer != peer_cid) {
556 vsock->cached_peer = peer_cid;
557 if (!vmci_transport_is_trusted(vsock, peer_cid) &&
558 (vmci_context_get_priv_flags(peer_cid) &
559 VMCI_PRIVILEGE_FLAG_RESTRICTED)) {
560 vsock->cached_peer_allow_dgram = false;
561 } else {
562 vsock->cached_peer_allow_dgram = true;
563 }
564 }
565
566 return vsock->cached_peer_allow_dgram;
567 }
568
569 static int
570 vmci_transport_queue_pair_alloc(struct vmci_qp **qpair,
571 struct vmci_handle *handle,
572 u64 produce_size,
573 u64 consume_size,
574 u32 peer, u32 flags, bool trusted)
575 {
576 int err = 0;
577
578 if (trusted) {
579 /* Try to allocate our queue pair as trusted. This will only
580 * work if vsock is running in the host.
581 */
582
583 err = vmci_qpair_alloc(qpair, handle, produce_size,
584 consume_size,
585 peer, flags,
586 VMCI_PRIVILEGE_FLAG_TRUSTED);
587 if (err != VMCI_ERROR_NO_ACCESS)
588 goto out;
589
590 }
591
592 err = vmci_qpair_alloc(qpair, handle, produce_size, consume_size,
593 peer, flags, VMCI_NO_PRIVILEGE_FLAGS);
594 out:
595 if (err < 0) {
596 pr_err("Could not attach to queue pair with %d\n",
597 err);
598 err = vmci_transport_error_to_vsock_error(err);
599 }
600
601 return err;
602 }
603
604 static int
605 vmci_transport_datagram_create_hnd(u32 resource_id,
606 u32 flags,
607 vmci_datagram_recv_cb recv_cb,
608 void *client_data,
609 struct vmci_handle *out_handle)
610 {
611 int err = 0;
612
613 /* Try to allocate our datagram handler as trusted. This will only work
614 * if vsock is running in the host.
615 */
616
617 err = vmci_datagram_create_handle_priv(resource_id, flags,
618 VMCI_PRIVILEGE_FLAG_TRUSTED,
619 recv_cb,
620 client_data, out_handle);
621
622 if (err == VMCI_ERROR_NO_ACCESS)
623 err = vmci_datagram_create_handle(resource_id, flags,
624 recv_cb, client_data,
625 out_handle);
626
627 return err;
628 }
629
630 /* This is invoked as part of a tasklet that's scheduled when the VMCI
631 * interrupt fires. This is run in bottom-half context and if it ever needs to
632 * sleep it should defer that work to a work queue.
633 */
634
635 static int vmci_transport_recv_dgram_cb(void *data, struct vmci_datagram *dg)
636 {
637 struct sock *sk;
638 size_t size;
639 struct sk_buff *skb;
640 struct vsock_sock *vsk;
641
642 sk = (struct sock *)data;
643
644 /* This handler is privileged when this module is running on the host.
645 * We will get datagrams from all endpoints (even VMs that are in a
646 * restricted context). If we get one from a restricted context then
647 * the destination socket must be trusted.
648 *
649 * NOTE: We access the socket struct without holding the lock here.
650 * This is ok because the field we are interested is never modified
651 * outside of the create and destruct socket functions.
652 */
653 vsk = vsock_sk(sk);
654 if (!vmci_transport_allow_dgram(vsk, dg->src.context))
655 return VMCI_ERROR_NO_ACCESS;
656
657 size = VMCI_DG_SIZE(dg);
658
659 /* Attach the packet to the socket's receive queue as an sk_buff. */
660 skb = alloc_skb(size, GFP_ATOMIC);
661 if (!skb)
662 return VMCI_ERROR_NO_MEM;
663
664 /* sk_receive_skb() will do a sock_put(), so hold here. */
665 sock_hold(sk);
666 skb_put(skb, size);
667 memcpy(skb->data, dg, size);
668 sk_receive_skb(sk, skb, 0);
669
670 return VMCI_SUCCESS;
671 }
672
673 static bool vmci_transport_stream_allow(u32 cid, u32 port)
674 {
675 static const u32 non_socket_contexts[] = {
676 VMADDR_CID_RESERVED,
677 };
678 int i;
679
680 BUILD_BUG_ON(sizeof(cid) != sizeof(*non_socket_contexts));
681
682 for (i = 0; i < ARRAY_SIZE(non_socket_contexts); i++) {
683 if (cid == non_socket_contexts[i])
684 return false;
685 }
686
687 return true;
688 }
689
690 /* This is invoked as part of a tasklet that's scheduled when the VMCI
691 * interrupt fires. This is run in bottom-half context but it defers most of
692 * its work to the packet handling work queue.
693 */
694
695 static int vmci_transport_recv_stream_cb(void *data, struct vmci_datagram *dg)
696 {
697 struct sock *sk;
698 struct sockaddr_vm dst;
699 struct sockaddr_vm src;
700 struct vmci_transport_packet *pkt;
701 struct vsock_sock *vsk;
702 bool bh_process_pkt;
703 int err;
704
705 sk = NULL;
706 err = VMCI_SUCCESS;
707 bh_process_pkt = false;
708
709 /* Ignore incoming packets from contexts without sockets, or resources
710 * that aren't vsock implementations.
711 */
712
713 if (!vmci_transport_stream_allow(dg->src.context, -1)
714 || vmci_transport_peer_rid(dg->src.context) != dg->src.resource)
715 return VMCI_ERROR_NO_ACCESS;
716
717 if (VMCI_DG_SIZE(dg) < sizeof(*pkt))
718 /* Drop datagrams that do not contain full VSock packets. */
719 return VMCI_ERROR_INVALID_ARGS;
720
721 pkt = (struct vmci_transport_packet *)dg;
722
723 /* Find the socket that should handle this packet. First we look for a
724 * connected socket and if there is none we look for a socket bound to
725 * the destintation address.
726 */
727 vsock_addr_init(&src, pkt->dg.src.context, pkt->src_port);
728 vsock_addr_init(&dst, pkt->dg.dst.context, pkt->dst_port);
729
730 sk = vsock_find_connected_socket(&src, &dst);
731 if (!sk) {
732 sk = vsock_find_bound_socket(&dst);
733 if (!sk) {
734 /* We could not find a socket for this specified
735 * address. If this packet is a RST, we just drop it.
736 * If it is another packet, we send a RST. Note that
737 * we do not send a RST reply to RSTs so that we do not
738 * continually send RSTs between two endpoints.
739 *
740 * Note that since this is a reply, dst is src and src
741 * is dst.
742 */
743 if (vmci_transport_send_reset_bh(&dst, &src, pkt) < 0)
744 pr_err("unable to send reset\n");
745
746 err = VMCI_ERROR_NOT_FOUND;
747 goto out;
748 }
749 }
750
751 /* If the received packet type is beyond all types known to this
752 * implementation, reply with an invalid message. Hopefully this will
753 * help when implementing backwards compatibility in the future.
754 */
755 if (pkt->type >= VMCI_TRANSPORT_PACKET_TYPE_MAX) {
756 vmci_transport_send_invalid_bh(&dst, &src);
757 err = VMCI_ERROR_INVALID_ARGS;
758 goto out;
759 }
760
761 /* This handler is privileged when this module is running on the host.
762 * We will get datagram connect requests from all endpoints (even VMs
763 * that are in a restricted context). If we get one from a restricted
764 * context then the destination socket must be trusted.
765 *
766 * NOTE: We access the socket struct without holding the lock here.
767 * This is ok because the field we are interested is never modified
768 * outside of the create and destruct socket functions.
769 */
770 vsk = vsock_sk(sk);
771 if (!vmci_transport_allow_dgram(vsk, pkt->dg.src.context)) {
772 err = VMCI_ERROR_NO_ACCESS;
773 goto out;
774 }
775
776 /* We do most everything in a work queue, but let's fast path the
777 * notification of reads and writes to help data transfer performance.
778 * We can only do this if there is no process context code executing
779 * for this socket since that may change the state.
780 */
781 bh_lock_sock(sk);
782
783 if (!sock_owned_by_user(sk)) {
784 /* The local context ID may be out of date, update it. */
785 vsk->local_addr.svm_cid = dst.svm_cid;
786
787 if (sk->sk_state == SS_CONNECTED)
788 vmci_trans(vsk)->notify_ops->handle_notify_pkt(
789 sk, pkt, true, &dst, &src,
790 &bh_process_pkt);
791 }
792
793 bh_unlock_sock(sk);
794
795 if (!bh_process_pkt) {
796 struct vmci_transport_recv_pkt_info *recv_pkt_info;
797
798 recv_pkt_info = kmalloc(sizeof(*recv_pkt_info), GFP_ATOMIC);
799 if (!recv_pkt_info) {
800 if (vmci_transport_send_reset_bh(&dst, &src, pkt) < 0)
801 pr_err("unable to send reset\n");
802
803 err = VMCI_ERROR_NO_MEM;
804 goto out;
805 }
806
807 recv_pkt_info->sk = sk;
808 memcpy(&recv_pkt_info->pkt, pkt, sizeof(recv_pkt_info->pkt));
809 INIT_WORK(&recv_pkt_info->work, vmci_transport_recv_pkt_work);
810
811 schedule_work(&recv_pkt_info->work);
812 /* Clear sk so that the reference count incremented by one of
813 * the Find functions above is not decremented below. We need
814 * that reference count for the packet handler we've scheduled
815 * to run.
816 */
817 sk = NULL;
818 }
819
820 out:
821 if (sk)
822 sock_put(sk);
823
824 return err;
825 }
826
827 static void vmci_transport_handle_detach(struct sock *sk)
828 {
829 struct vsock_sock *vsk;
830
831 vsk = vsock_sk(sk);
832 if (!vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle)) {
833 sock_set_flag(sk, SOCK_DONE);
834
835 /* On a detach the peer will not be sending or receiving
836 * anymore.
837 */
838 vsk->peer_shutdown = SHUTDOWN_MASK;
839
840 /* We should not be sending anymore since the peer won't be
841 * there to receive, but we can still receive if there is data
842 * left in our consume queue.
843 */
844 if (vsock_stream_has_data(vsk) <= 0) {
845 if (sk->sk_state == SS_CONNECTING) {
846 /* The peer may detach from a queue pair while
847 * we are still in the connecting state, i.e.,
848 * if the peer VM is killed after attaching to
849 * a queue pair, but before we complete the
850 * handshake. In that case, we treat the detach
851 * event like a reset.
852 */
853
854 sk->sk_state = SS_UNCONNECTED;
855 sk->sk_err = ECONNRESET;
856 sk->sk_error_report(sk);
857 return;
858 }
859 sk->sk_state = SS_UNCONNECTED;
860 }
861 sk->sk_state_change(sk);
862 }
863 }
864
865 static void vmci_transport_peer_detach_cb(u32 sub_id,
866 const struct vmci_event_data *e_data,
867 void *client_data)
868 {
869 struct vmci_transport *trans = client_data;
870 const struct vmci_event_payload_qp *e_payload;
871
872 e_payload = vmci_event_data_const_payload(e_data);
873
874 /* XXX This is lame, we should provide a way to lookup sockets by
875 * qp_handle.
876 */
877 if (vmci_handle_is_invalid(e_payload->handle) ||
878 !vmci_handle_is_equal(trans->qp_handle, e_payload->handle))
879 return;
880
881 /* We don't ask for delayed CBs when we subscribe to this event (we
882 * pass 0 as flags to vmci_event_subscribe()). VMCI makes no
883 * guarantees in that case about what context we might be running in,
884 * so it could be BH or process, blockable or non-blockable. So we
885 * need to account for all possible contexts here.
886 */
887 spin_lock_bh(&trans->lock);
888 if (!trans->sk)
889 goto out;
890
891 /* Apart from here, trans->lock is only grabbed as part of sk destruct,
892 * where trans->sk isn't locked.
893 */
894 bh_lock_sock(trans->sk);
895
896 vmci_transport_handle_detach(trans->sk);
897
898 bh_unlock_sock(trans->sk);
899 out:
900 spin_unlock_bh(&trans->lock);
901 }
902
903 static void vmci_transport_qp_resumed_cb(u32 sub_id,
904 const struct vmci_event_data *e_data,
905 void *client_data)
906 {
907 vsock_for_each_connected_socket(vmci_transport_handle_detach);
908 }
909
910 static void vmci_transport_recv_pkt_work(struct work_struct *work)
911 {
912 struct vmci_transport_recv_pkt_info *recv_pkt_info;
913 struct vmci_transport_packet *pkt;
914 struct sock *sk;
915
916 recv_pkt_info =
917 container_of(work, struct vmci_transport_recv_pkt_info, work);
918 sk = recv_pkt_info->sk;
919 pkt = &recv_pkt_info->pkt;
920
921 lock_sock(sk);
922
923 /* The local context ID may be out of date. */
924 vsock_sk(sk)->local_addr.svm_cid = pkt->dg.dst.context;
925
926 switch (sk->sk_state) {
927 case VSOCK_SS_LISTEN:
928 vmci_transport_recv_listen(sk, pkt);
929 break;
930 case SS_CONNECTING:
931 /* Processing of pending connections for servers goes through
932 * the listening socket, so see vmci_transport_recv_listen()
933 * for that path.
934 */
935 vmci_transport_recv_connecting_client(sk, pkt);
936 break;
937 case SS_CONNECTED:
938 vmci_transport_recv_connected(sk, pkt);
939 break;
940 default:
941 /* Because this function does not run in the same context as
942 * vmci_transport_recv_stream_cb it is possible that the
943 * socket has closed. We need to let the other side know or it
944 * could be sitting in a connect and hang forever. Send a
945 * reset to prevent that.
946 */
947 vmci_transport_send_reset(sk, pkt);
948 break;
949 }
950
951 release_sock(sk);
952 kfree(recv_pkt_info);
953 /* Release reference obtained in the stream callback when we fetched
954 * this socket out of the bound or connected list.
955 */
956 sock_put(sk);
957 }
958
959 static int vmci_transport_recv_listen(struct sock *sk,
960 struct vmci_transport_packet *pkt)
961 {
962 struct sock *pending;
963 struct vsock_sock *vpending;
964 int err;
965 u64 qp_size;
966 bool old_request = false;
967 bool old_pkt_proto = false;
968
969 err = 0;
970
971 /* Because we are in the listen state, we could be receiving a packet
972 * for ourself or any previous connection requests that we received.
973 * If it's the latter, we try to find a socket in our list of pending
974 * connections and, if we do, call the appropriate handler for the
975 * state that that socket is in. Otherwise we try to service the
976 * connection request.
977 */
978 pending = vmci_transport_get_pending(sk, pkt);
979 if (pending) {
980 lock_sock(pending);
981
982 /* The local context ID may be out of date. */
983 vsock_sk(pending)->local_addr.svm_cid = pkt->dg.dst.context;
984
985 switch (pending->sk_state) {
986 case SS_CONNECTING:
987 err = vmci_transport_recv_connecting_server(sk,
988 pending,
989 pkt);
990 break;
991 default:
992 vmci_transport_send_reset(pending, pkt);
993 err = -EINVAL;
994 }
995
996 if (err < 0)
997 vsock_remove_pending(sk, pending);
998
999 release_sock(pending);
1000 vmci_transport_release_pending(pending);
1001
1002 return err;
1003 }
1004
1005 /* The listen state only accepts connection requests. Reply with a
1006 * reset unless we received a reset.
1007 */
1008
1009 if (!(pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST ||
1010 pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST2)) {
1011 vmci_transport_reply_reset(pkt);
1012 return -EINVAL;
1013 }
1014
1015 if (pkt->u.size == 0) {
1016 vmci_transport_reply_reset(pkt);
1017 return -EINVAL;
1018 }
1019
1020 /* If this socket can't accommodate this connection request, we send a
1021 * reset. Otherwise we create and initialize a child socket and reply
1022 * with a connection negotiation.
1023 */
1024 if (sk->sk_ack_backlog >= sk->sk_max_ack_backlog) {
1025 vmci_transport_reply_reset(pkt);
1026 return -ECONNREFUSED;
1027 }
1028
1029 pending = __vsock_create(sock_net(sk), NULL, sk, GFP_KERNEL,
1030 sk->sk_type, 0);
1031 if (!pending) {
1032 vmci_transport_send_reset(sk, pkt);
1033 return -ENOMEM;
1034 }
1035
1036 vpending = vsock_sk(pending);
1037
1038 vsock_addr_init(&vpending->local_addr, pkt->dg.dst.context,
1039 pkt->dst_port);
1040 vsock_addr_init(&vpending->remote_addr, pkt->dg.src.context,
1041 pkt->src_port);
1042
1043 /* If the proposed size fits within our min/max, accept it. Otherwise
1044 * propose our own size.
1045 */
1046 if (pkt->u.size >= vmci_trans(vpending)->queue_pair_min_size &&
1047 pkt->u.size <= vmci_trans(vpending)->queue_pair_max_size) {
1048 qp_size = pkt->u.size;
1049 } else {
1050 qp_size = vmci_trans(vpending)->queue_pair_size;
1051 }
1052
1053 /* Figure out if we are using old or new requests based on the
1054 * overrides pkt types sent by our peer.
1055 */
1056 if (vmci_transport_old_proto_override(&old_pkt_proto)) {
1057 old_request = old_pkt_proto;
1058 } else {
1059 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST)
1060 old_request = true;
1061 else if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST2)
1062 old_request = false;
1063
1064 }
1065
1066 if (old_request) {
1067 /* Handle a REQUEST (or override) */
1068 u16 version = VSOCK_PROTO_INVALID;
1069 if (vmci_transport_proto_to_notify_struct(
1070 pending, &version, true))
1071 err = vmci_transport_send_negotiate(pending, qp_size);
1072 else
1073 err = -EINVAL;
1074
1075 } else {
1076 /* Handle a REQUEST2 (or override) */
1077 int proto_int = pkt->proto;
1078 int pos;
1079 u16 active_proto_version = 0;
1080
1081 /* The list of possible protocols is the intersection of all
1082 * protocols the client supports ... plus all the protocols we
1083 * support.
1084 */
1085 proto_int &= vmci_transport_new_proto_supported_versions();
1086
1087 /* We choose the highest possible protocol version and use that
1088 * one.
1089 */
1090 pos = fls(proto_int);
1091 if (pos) {
1092 active_proto_version = (1 << (pos - 1));
1093 if (vmci_transport_proto_to_notify_struct(
1094 pending, &active_proto_version, false))
1095 err = vmci_transport_send_negotiate2(pending,
1096 qp_size,
1097 active_proto_version);
1098 else
1099 err = -EINVAL;
1100
1101 } else {
1102 err = -EINVAL;
1103 }
1104 }
1105
1106 if (err < 0) {
1107 vmci_transport_send_reset(sk, pkt);
1108 sock_put(pending);
1109 err = vmci_transport_error_to_vsock_error(err);
1110 goto out;
1111 }
1112
1113 vsock_add_pending(sk, pending);
1114 sk->sk_ack_backlog++;
1115
1116 pending->sk_state = SS_CONNECTING;
1117 vmci_trans(vpending)->produce_size =
1118 vmci_trans(vpending)->consume_size = qp_size;
1119 vmci_trans(vpending)->queue_pair_size = qp_size;
1120
1121 vmci_trans(vpending)->notify_ops->process_request(pending);
1122
1123 /* We might never receive another message for this socket and it's not
1124 * connected to any process, so we have to ensure it gets cleaned up
1125 * ourself. Our delayed work function will take care of that. Note
1126 * that we do not ever cancel this function since we have few
1127 * guarantees about its state when calling cancel_delayed_work().
1128 * Instead we hold a reference on the socket for that function and make
1129 * it capable of handling cases where it needs to do nothing but
1130 * release that reference.
1131 */
1132 vpending->listener = sk;
1133 sock_hold(sk);
1134 sock_hold(pending);
1135 schedule_delayed_work(&vpending->pending_work, HZ);
1136
1137 out:
1138 return err;
1139 }
1140
1141 static int
1142 vmci_transport_recv_connecting_server(struct sock *listener,
1143 struct sock *pending,
1144 struct vmci_transport_packet *pkt)
1145 {
1146 struct vsock_sock *vpending;
1147 struct vmci_handle handle;
1148 struct vmci_qp *qpair;
1149 bool is_local;
1150 u32 flags;
1151 u32 detach_sub_id;
1152 int err;
1153 int skerr;
1154
1155 vpending = vsock_sk(pending);
1156 detach_sub_id = VMCI_INVALID_ID;
1157
1158 switch (pkt->type) {
1159 case VMCI_TRANSPORT_PACKET_TYPE_OFFER:
1160 if (vmci_handle_is_invalid(pkt->u.handle)) {
1161 vmci_transport_send_reset(pending, pkt);
1162 skerr = EPROTO;
1163 err = -EINVAL;
1164 goto destroy;
1165 }
1166 break;
1167 default:
1168 /* Close and cleanup the connection. */
1169 vmci_transport_send_reset(pending, pkt);
1170 skerr = EPROTO;
1171 err = pkt->type == VMCI_TRANSPORT_PACKET_TYPE_RST ? 0 : -EINVAL;
1172 goto destroy;
1173 }
1174
1175 /* In order to complete the connection we need to attach to the offered
1176 * queue pair and send an attach notification. We also subscribe to the
1177 * detach event so we know when our peer goes away, and we do that
1178 * before attaching so we don't miss an event. If all this succeeds,
1179 * we update our state and wakeup anything waiting in accept() for a
1180 * connection.
1181 */
1182
1183 /* We don't care about attach since we ensure the other side has
1184 * attached by specifying the ATTACH_ONLY flag below.
1185 */
1186 err = vmci_event_subscribe(VMCI_EVENT_QP_PEER_DETACH,
1187 vmci_transport_peer_detach_cb,
1188 vmci_trans(vpending), &detach_sub_id);
1189 if (err < VMCI_SUCCESS) {
1190 vmci_transport_send_reset(pending, pkt);
1191 err = vmci_transport_error_to_vsock_error(err);
1192 skerr = -err;
1193 goto destroy;
1194 }
1195
1196 vmci_trans(vpending)->detach_sub_id = detach_sub_id;
1197
1198 /* Now attach to the queue pair the client created. */
1199 handle = pkt->u.handle;
1200
1201 /* vpending->local_addr always has a context id so we do not need to
1202 * worry about VMADDR_CID_ANY in this case.
1203 */
1204 is_local =
1205 vpending->remote_addr.svm_cid == vpending->local_addr.svm_cid;
1206 flags = VMCI_QPFLAG_ATTACH_ONLY;
1207 flags |= is_local ? VMCI_QPFLAG_LOCAL : 0;
1208
1209 err = vmci_transport_queue_pair_alloc(
1210 &qpair,
1211 &handle,
1212 vmci_trans(vpending)->produce_size,
1213 vmci_trans(vpending)->consume_size,
1214 pkt->dg.src.context,
1215 flags,
1216 vmci_transport_is_trusted(
1217 vpending,
1218 vpending->remote_addr.svm_cid));
1219 if (err < 0) {
1220 vmci_transport_send_reset(pending, pkt);
1221 skerr = -err;
1222 goto destroy;
1223 }
1224
1225 vmci_trans(vpending)->qp_handle = handle;
1226 vmci_trans(vpending)->qpair = qpair;
1227
1228 /* When we send the attach message, we must be ready to handle incoming
1229 * control messages on the newly connected socket. So we move the
1230 * pending socket to the connected state before sending the attach
1231 * message. Otherwise, an incoming packet triggered by the attach being
1232 * received by the peer may be processed concurrently with what happens
1233 * below after sending the attach message, and that incoming packet
1234 * will find the listening socket instead of the (currently) pending
1235 * socket. Note that enqueueing the socket increments the reference
1236 * count, so even if a reset comes before the connection is accepted,
1237 * the socket will be valid until it is removed from the queue.
1238 *
1239 * If we fail sending the attach below, we remove the socket from the
1240 * connected list and move the socket to SS_UNCONNECTED before
1241 * releasing the lock, so a pending slow path processing of an incoming
1242 * packet will not see the socket in the connected state in that case.
1243 */
1244 pending->sk_state = SS_CONNECTED;
1245
1246 vsock_insert_connected(vpending);
1247
1248 /* Notify our peer of our attach. */
1249 err = vmci_transport_send_attach(pending, handle);
1250 if (err < 0) {
1251 vsock_remove_connected(vpending);
1252 pr_err("Could not send attach\n");
1253 vmci_transport_send_reset(pending, pkt);
1254 err = vmci_transport_error_to_vsock_error(err);
1255 skerr = -err;
1256 goto destroy;
1257 }
1258
1259 /* We have a connection. Move the now connected socket from the
1260 * listener's pending list to the accept queue so callers of accept()
1261 * can find it.
1262 */
1263 vsock_remove_pending(listener, pending);
1264 vsock_enqueue_accept(listener, pending);
1265
1266 /* Callers of accept() will be be waiting on the listening socket, not
1267 * the pending socket.
1268 */
1269 listener->sk_data_ready(listener);
1270
1271 return 0;
1272
1273 destroy:
1274 pending->sk_err = skerr;
1275 pending->sk_state = SS_UNCONNECTED;
1276 /* As long as we drop our reference, all necessary cleanup will handle
1277 * when the cleanup function drops its reference and our destruct
1278 * implementation is called. Note that since the listen handler will
1279 * remove pending from the pending list upon our failure, the cleanup
1280 * function won't drop the additional reference, which is why we do it
1281 * here.
1282 */
1283 sock_put(pending);
1284
1285 return err;
1286 }
1287
1288 static int
1289 vmci_transport_recv_connecting_client(struct sock *sk,
1290 struct vmci_transport_packet *pkt)
1291 {
1292 struct vsock_sock *vsk;
1293 int err;
1294 int skerr;
1295
1296 vsk = vsock_sk(sk);
1297
1298 switch (pkt->type) {
1299 case VMCI_TRANSPORT_PACKET_TYPE_ATTACH:
1300 if (vmci_handle_is_invalid(pkt->u.handle) ||
1301 !vmci_handle_is_equal(pkt->u.handle,
1302 vmci_trans(vsk)->qp_handle)) {
1303 skerr = EPROTO;
1304 err = -EINVAL;
1305 goto destroy;
1306 }
1307
1308 /* Signify the socket is connected and wakeup the waiter in
1309 * connect(). Also place the socket in the connected table for
1310 * accounting (it can already be found since it's in the bound
1311 * table).
1312 */
1313 sk->sk_state = SS_CONNECTED;
1314 sk->sk_socket->state = SS_CONNECTED;
1315 vsock_insert_connected(vsk);
1316 sk->sk_state_change(sk);
1317
1318 break;
1319 case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE:
1320 case VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2:
1321 if (pkt->u.size == 0
1322 || pkt->dg.src.context != vsk->remote_addr.svm_cid
1323 || pkt->src_port != vsk->remote_addr.svm_port
1324 || !vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle)
1325 || vmci_trans(vsk)->qpair
1326 || vmci_trans(vsk)->produce_size != 0
1327 || vmci_trans(vsk)->consume_size != 0
1328 || vmci_trans(vsk)->detach_sub_id != VMCI_INVALID_ID) {
1329 skerr = EPROTO;
1330 err = -EINVAL;
1331
1332 goto destroy;
1333 }
1334
1335 err = vmci_transport_recv_connecting_client_negotiate(sk, pkt);
1336 if (err) {
1337 skerr = -err;
1338 goto destroy;
1339 }
1340
1341 break;
1342 case VMCI_TRANSPORT_PACKET_TYPE_INVALID:
1343 err = vmci_transport_recv_connecting_client_invalid(sk, pkt);
1344 if (err) {
1345 skerr = -err;
1346 goto destroy;
1347 }
1348
1349 break;
1350 case VMCI_TRANSPORT_PACKET_TYPE_RST:
1351 /* Older versions of the linux code (WS 6.5 / ESX 4.0) used to
1352 * continue processing here after they sent an INVALID packet.
1353 * This meant that we got a RST after the INVALID. We ignore a
1354 * RST after an INVALID. The common code doesn't send the RST
1355 * ... so we can hang if an old version of the common code
1356 * fails between getting a REQUEST and sending an OFFER back.
1357 * Not much we can do about it... except hope that it doesn't
1358 * happen.
1359 */
1360 if (vsk->ignore_connecting_rst) {
1361 vsk->ignore_connecting_rst = false;
1362 } else {
1363 skerr = ECONNRESET;
1364 err = 0;
1365 goto destroy;
1366 }
1367
1368 break;
1369 default:
1370 /* Close and cleanup the connection. */
1371 skerr = EPROTO;
1372 err = -EINVAL;
1373 goto destroy;
1374 }
1375
1376 return 0;
1377
1378 destroy:
1379 vmci_transport_send_reset(sk, pkt);
1380
1381 sk->sk_state = SS_UNCONNECTED;
1382 sk->sk_err = skerr;
1383 sk->sk_error_report(sk);
1384 return err;
1385 }
1386
1387 static int vmci_transport_recv_connecting_client_negotiate(
1388 struct sock *sk,
1389 struct vmci_transport_packet *pkt)
1390 {
1391 int err;
1392 struct vsock_sock *vsk;
1393 struct vmci_handle handle;
1394 struct vmci_qp *qpair;
1395 u32 detach_sub_id;
1396 bool is_local;
1397 u32 flags;
1398 bool old_proto = true;
1399 bool old_pkt_proto;
1400 u16 version;
1401
1402 vsk = vsock_sk(sk);
1403 handle = VMCI_INVALID_HANDLE;
1404 detach_sub_id = VMCI_INVALID_ID;
1405
1406 /* If we have gotten here then we should be past the point where old
1407 * linux vsock could have sent the bogus rst.
1408 */
1409 vsk->sent_request = false;
1410 vsk->ignore_connecting_rst = false;
1411
1412 /* Verify that we're OK with the proposed queue pair size */
1413 if (pkt->u.size < vmci_trans(vsk)->queue_pair_min_size ||
1414 pkt->u.size > vmci_trans(vsk)->queue_pair_max_size) {
1415 err = -EINVAL;
1416 goto destroy;
1417 }
1418
1419 /* At this point we know the CID the peer is using to talk to us. */
1420
1421 if (vsk->local_addr.svm_cid == VMADDR_CID_ANY)
1422 vsk->local_addr.svm_cid = pkt->dg.dst.context;
1423
1424 /* Setup the notify ops to be the highest supported version that both
1425 * the server and the client support.
1426 */
1427
1428 if (vmci_transport_old_proto_override(&old_pkt_proto)) {
1429 old_proto = old_pkt_proto;
1430 } else {
1431 if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE)
1432 old_proto = true;
1433 else if (pkt->type == VMCI_TRANSPORT_PACKET_TYPE_NEGOTIATE2)
1434 old_proto = false;
1435
1436 }
1437
1438 if (old_proto)
1439 version = VSOCK_PROTO_INVALID;
1440 else
1441 version = pkt->proto;
1442
1443 if (!vmci_transport_proto_to_notify_struct(sk, &version, old_proto)) {
1444 err = -EINVAL;
1445 goto destroy;
1446 }
1447
1448 /* Subscribe to detach events first.
1449 *
1450 * XXX We attach once for each queue pair created for now so it is easy
1451 * to find the socket (it's provided), but later we should only
1452 * subscribe once and add a way to lookup sockets by queue pair handle.
1453 */
1454 err = vmci_event_subscribe(VMCI_EVENT_QP_PEER_DETACH,
1455 vmci_transport_peer_detach_cb,
1456 vmci_trans(vsk), &detach_sub_id);
1457 if (err < VMCI_SUCCESS) {
1458 err = vmci_transport_error_to_vsock_error(err);
1459 goto destroy;
1460 }
1461
1462 /* Make VMCI select the handle for us. */
1463 handle = VMCI_INVALID_HANDLE;
1464 is_local = vsk->remote_addr.svm_cid == vsk->local_addr.svm_cid;
1465 flags = is_local ? VMCI_QPFLAG_LOCAL : 0;
1466
1467 err = vmci_transport_queue_pair_alloc(&qpair,
1468 &handle,
1469 pkt->u.size,
1470 pkt->u.size,
1471 vsk->remote_addr.svm_cid,
1472 flags,
1473 vmci_transport_is_trusted(
1474 vsk,
1475 vsk->
1476 remote_addr.svm_cid));
1477 if (err < 0)
1478 goto destroy;
1479
1480 err = vmci_transport_send_qp_offer(sk, handle);
1481 if (err < 0) {
1482 err = vmci_transport_error_to_vsock_error(err);
1483 goto destroy;
1484 }
1485
1486 vmci_trans(vsk)->qp_handle = handle;
1487 vmci_trans(vsk)->qpair = qpair;
1488
1489 vmci_trans(vsk)->produce_size = vmci_trans(vsk)->consume_size =
1490 pkt->u.size;
1491
1492 vmci_trans(vsk)->detach_sub_id = detach_sub_id;
1493
1494 vmci_trans(vsk)->notify_ops->process_negotiate(sk);
1495
1496 return 0;
1497
1498 destroy:
1499 if (detach_sub_id != VMCI_INVALID_ID)
1500 vmci_event_unsubscribe(detach_sub_id);
1501
1502 if (!vmci_handle_is_invalid(handle))
1503 vmci_qpair_detach(&qpair);
1504
1505 return err;
1506 }
1507
1508 static int
1509 vmci_transport_recv_connecting_client_invalid(struct sock *sk,
1510 struct vmci_transport_packet *pkt)
1511 {
1512 int err = 0;
1513 struct vsock_sock *vsk = vsock_sk(sk);
1514
1515 if (vsk->sent_request) {
1516 vsk->sent_request = false;
1517 vsk->ignore_connecting_rst = true;
1518
1519 err = vmci_transport_send_conn_request(
1520 sk, vmci_trans(vsk)->queue_pair_size);
1521 if (err < 0)
1522 err = vmci_transport_error_to_vsock_error(err);
1523 else
1524 err = 0;
1525
1526 }
1527
1528 return err;
1529 }
1530
1531 static int vmci_transport_recv_connected(struct sock *sk,
1532 struct vmci_transport_packet *pkt)
1533 {
1534 struct vsock_sock *vsk;
1535 bool pkt_processed = false;
1536
1537 /* In cases where we are closing the connection, it's sufficient to
1538 * mark the state change (and maybe error) and wake up any waiting
1539 * threads. Since this is a connected socket, it's owned by a user
1540 * process and will be cleaned up when the failure is passed back on
1541 * the current or next system call. Our system call implementations
1542 * must therefore check for error and state changes on entry and when
1543 * being awoken.
1544 */
1545 switch (pkt->type) {
1546 case VMCI_TRANSPORT_PACKET_TYPE_SHUTDOWN:
1547 if (pkt->u.mode) {
1548 vsk = vsock_sk(sk);
1549
1550 vsk->peer_shutdown |= pkt->u.mode;
1551 sk->sk_state_change(sk);
1552 }
1553 break;
1554
1555 case VMCI_TRANSPORT_PACKET_TYPE_RST:
1556 vsk = vsock_sk(sk);
1557 /* It is possible that we sent our peer a message (e.g a
1558 * WAITING_READ) right before we got notified that the peer had
1559 * detached. If that happens then we can get a RST pkt back
1560 * from our peer even though there is data available for us to
1561 * read. In that case, don't shutdown the socket completely but
1562 * instead allow the local client to finish reading data off
1563 * the queuepair. Always treat a RST pkt in connected mode like
1564 * a clean shutdown.
1565 */
1566 sock_set_flag(sk, SOCK_DONE);
1567 vsk->peer_shutdown = SHUTDOWN_MASK;
1568 if (vsock_stream_has_data(vsk) <= 0)
1569 sk->sk_state = SS_DISCONNECTING;
1570
1571 sk->sk_state_change(sk);
1572 break;
1573
1574 default:
1575 vsk = vsock_sk(sk);
1576 vmci_trans(vsk)->notify_ops->handle_notify_pkt(
1577 sk, pkt, false, NULL, NULL,
1578 &pkt_processed);
1579 if (!pkt_processed)
1580 return -EINVAL;
1581
1582 break;
1583 }
1584
1585 return 0;
1586 }
1587
1588 static int vmci_transport_socket_init(struct vsock_sock *vsk,
1589 struct vsock_sock *psk)
1590 {
1591 vsk->trans = kmalloc(sizeof(struct vmci_transport), GFP_KERNEL);
1592 if (!vsk->trans)
1593 return -ENOMEM;
1594
1595 vmci_trans(vsk)->dg_handle = VMCI_INVALID_HANDLE;
1596 vmci_trans(vsk)->qp_handle = VMCI_INVALID_HANDLE;
1597 vmci_trans(vsk)->qpair = NULL;
1598 vmci_trans(vsk)->produce_size = vmci_trans(vsk)->consume_size = 0;
1599 vmci_trans(vsk)->detach_sub_id = VMCI_INVALID_ID;
1600 vmci_trans(vsk)->notify_ops = NULL;
1601 INIT_LIST_HEAD(&vmci_trans(vsk)->elem);
1602 vmci_trans(vsk)->sk = &vsk->sk;
1603 spin_lock_init(&vmci_trans(vsk)->lock);
1604 if (psk) {
1605 vmci_trans(vsk)->queue_pair_size =
1606 vmci_trans(psk)->queue_pair_size;
1607 vmci_trans(vsk)->queue_pair_min_size =
1608 vmci_trans(psk)->queue_pair_min_size;
1609 vmci_trans(vsk)->queue_pair_max_size =
1610 vmci_trans(psk)->queue_pair_max_size;
1611 } else {
1612 vmci_trans(vsk)->queue_pair_size =
1613 VMCI_TRANSPORT_DEFAULT_QP_SIZE;
1614 vmci_trans(vsk)->queue_pair_min_size =
1615 VMCI_TRANSPORT_DEFAULT_QP_SIZE_MIN;
1616 vmci_trans(vsk)->queue_pair_max_size =
1617 VMCI_TRANSPORT_DEFAULT_QP_SIZE_MAX;
1618 }
1619
1620 return 0;
1621 }
1622
1623 static void vmci_transport_free_resources(struct list_head *transport_list)
1624 {
1625 while (!list_empty(transport_list)) {
1626 struct vmci_transport *transport =
1627 list_first_entry(transport_list, struct vmci_transport,
1628 elem);
1629 list_del(&transport->elem);
1630
1631 if (transport->detach_sub_id != VMCI_INVALID_ID) {
1632 vmci_event_unsubscribe(transport->detach_sub_id);
1633 transport->detach_sub_id = VMCI_INVALID_ID;
1634 }
1635
1636 if (!vmci_handle_is_invalid(transport->qp_handle)) {
1637 vmci_qpair_detach(&transport->qpair);
1638 transport->qp_handle = VMCI_INVALID_HANDLE;
1639 transport->produce_size = 0;
1640 transport->consume_size = 0;
1641 }
1642
1643 kfree(transport);
1644 }
1645 }
1646
1647 static void vmci_transport_cleanup(struct work_struct *work)
1648 {
1649 LIST_HEAD(pending);
1650
1651 spin_lock_bh(&vmci_transport_cleanup_lock);
1652 list_replace_init(&vmci_transport_cleanup_list, &pending);
1653 spin_unlock_bh(&vmci_transport_cleanup_lock);
1654 vmci_transport_free_resources(&pending);
1655 }
1656
1657 static void vmci_transport_destruct(struct vsock_sock *vsk)
1658 {
1659 /* Ensure that the detach callback doesn't use the sk/vsk
1660 * we are about to destruct.
1661 */
1662 spin_lock_bh(&vmci_trans(vsk)->lock);
1663 vmci_trans(vsk)->sk = NULL;
1664 spin_unlock_bh(&vmci_trans(vsk)->lock);
1665
1666 if (vmci_trans(vsk)->notify_ops)
1667 vmci_trans(vsk)->notify_ops->socket_destruct(vsk);
1668
1669 spin_lock_bh(&vmci_transport_cleanup_lock);
1670 list_add(&vmci_trans(vsk)->elem, &vmci_transport_cleanup_list);
1671 spin_unlock_bh(&vmci_transport_cleanup_lock);
1672 schedule_work(&vmci_transport_cleanup_work);
1673
1674 vsk->trans = NULL;
1675 }
1676
1677 static void vmci_transport_release(struct vsock_sock *vsk)
1678 {
1679 if (!vmci_handle_is_invalid(vmci_trans(vsk)->dg_handle)) {
1680 vmci_datagram_destroy_handle(vmci_trans(vsk)->dg_handle);
1681 vmci_trans(vsk)->dg_handle = VMCI_INVALID_HANDLE;
1682 }
1683 }
1684
1685 static int vmci_transport_dgram_bind(struct vsock_sock *vsk,
1686 struct sockaddr_vm *addr)
1687 {
1688 u32 port;
1689 u32 flags;
1690 int err;
1691
1692 /* VMCI will select a resource ID for us if we provide
1693 * VMCI_INVALID_ID.
1694 */
1695 port = addr->svm_port == VMADDR_PORT_ANY ?
1696 VMCI_INVALID_ID : addr->svm_port;
1697
1698 if (port <= LAST_RESERVED_PORT && !capable(CAP_NET_BIND_SERVICE))
1699 return -EACCES;
1700
1701 flags = addr->svm_cid == VMADDR_CID_ANY ?
1702 VMCI_FLAG_ANYCID_DG_HND : 0;
1703
1704 err = vmci_transport_datagram_create_hnd(port, flags,
1705 vmci_transport_recv_dgram_cb,
1706 &vsk->sk,
1707 &vmci_trans(vsk)->dg_handle);
1708 if (err < VMCI_SUCCESS)
1709 return vmci_transport_error_to_vsock_error(err);
1710 vsock_addr_init(&vsk->local_addr, addr->svm_cid,
1711 vmci_trans(vsk)->dg_handle.resource);
1712
1713 return 0;
1714 }
1715
1716 static int vmci_transport_dgram_enqueue(
1717 struct vsock_sock *vsk,
1718 struct sockaddr_vm *remote_addr,
1719 struct msghdr *msg,
1720 size_t len)
1721 {
1722 int err;
1723 struct vmci_datagram *dg;
1724
1725 if (len > VMCI_MAX_DG_PAYLOAD_SIZE)
1726 return -EMSGSIZE;
1727
1728 if (!vmci_transport_allow_dgram(vsk, remote_addr->svm_cid))
1729 return -EPERM;
1730
1731 /* Allocate a buffer for the user's message and our packet header. */
1732 dg = kmalloc(len + sizeof(*dg), GFP_KERNEL);
1733 if (!dg)
1734 return -ENOMEM;
1735
1736 memcpy_from_msg(VMCI_DG_PAYLOAD(dg), msg, len);
1737
1738 dg->dst = vmci_make_handle(remote_addr->svm_cid,
1739 remote_addr->svm_port);
1740 dg->src = vmci_make_handle(vsk->local_addr.svm_cid,
1741 vsk->local_addr.svm_port);
1742 dg->payload_size = len;
1743
1744 err = vmci_datagram_send(dg);
1745 kfree(dg);
1746 if (err < 0)
1747 return vmci_transport_error_to_vsock_error(err);
1748
1749 return err - sizeof(*dg);
1750 }
1751
1752 static int vmci_transport_dgram_dequeue(struct vsock_sock *vsk,
1753 struct msghdr *msg, size_t len,
1754 int flags)
1755 {
1756 int err;
1757 int noblock;
1758 struct vmci_datagram *dg;
1759 size_t payload_len;
1760 struct sk_buff *skb;
1761
1762 noblock = flags & MSG_DONTWAIT;
1763
1764 if (flags & MSG_OOB || flags & MSG_ERRQUEUE)
1765 return -EOPNOTSUPP;
1766
1767 /* Retrieve the head sk_buff from the socket's receive queue. */
1768 err = 0;
1769 skb = skb_recv_datagram(&vsk->sk, flags, noblock, &err);
1770 if (err)
1771 return err;
1772
1773 if (!skb)
1774 return -EAGAIN;
1775
1776 dg = (struct vmci_datagram *)skb->data;
1777 if (!dg)
1778 /* err is 0, meaning we read zero bytes. */
1779 goto out;
1780
1781 payload_len = dg->payload_size;
1782 /* Ensure the sk_buff matches the payload size claimed in the packet. */
1783 if (payload_len != skb->len - sizeof(*dg)) {
1784 err = -EINVAL;
1785 goto out;
1786 }
1787
1788 if (payload_len > len) {
1789 payload_len = len;
1790 msg->msg_flags |= MSG_TRUNC;
1791 }
1792
1793 /* Place the datagram payload in the user's iovec. */
1794 err = skb_copy_datagram_msg(skb, sizeof(*dg), msg, payload_len);
1795 if (err)
1796 goto out;
1797
1798 if (msg->msg_name) {
1799 /* Provide the address of the sender. */
1800 DECLARE_SOCKADDR(struct sockaddr_vm *, vm_addr, msg->msg_name);
1801 vsock_addr_init(vm_addr, dg->src.context, dg->src.resource);
1802 msg->msg_namelen = sizeof(*vm_addr);
1803 }
1804 err = payload_len;
1805
1806 out:
1807 skb_free_datagram(&vsk->sk, skb);
1808 return err;
1809 }
1810
1811 static bool vmci_transport_dgram_allow(u32 cid, u32 port)
1812 {
1813 if (cid == VMADDR_CID_HYPERVISOR) {
1814 /* Registrations of PBRPC Servers do not modify VMX/Hypervisor
1815 * state and are allowed.
1816 */
1817 return port == VMCI_UNITY_PBRPC_REGISTER;
1818 }
1819
1820 return true;
1821 }
1822
1823 static int vmci_transport_connect(struct vsock_sock *vsk)
1824 {
1825 int err;
1826 bool old_pkt_proto = false;
1827 struct sock *sk = &vsk->sk;
1828
1829 if (vmci_transport_old_proto_override(&old_pkt_proto) &&
1830 old_pkt_proto) {
1831 err = vmci_transport_send_conn_request(
1832 sk, vmci_trans(vsk)->queue_pair_size);
1833 if (err < 0) {
1834 sk->sk_state = SS_UNCONNECTED;
1835 return err;
1836 }
1837 } else {
1838 int supported_proto_versions =
1839 vmci_transport_new_proto_supported_versions();
1840 err = vmci_transport_send_conn_request2(
1841 sk, vmci_trans(vsk)->queue_pair_size,
1842 supported_proto_versions);
1843 if (err < 0) {
1844 sk->sk_state = SS_UNCONNECTED;
1845 return err;
1846 }
1847
1848 vsk->sent_request = true;
1849 }
1850
1851 return err;
1852 }
1853
1854 static ssize_t vmci_transport_stream_dequeue(
1855 struct vsock_sock *vsk,
1856 struct msghdr *msg,
1857 size_t len,
1858 int flags)
1859 {
1860 if (flags & MSG_PEEK)
1861 return vmci_qpair_peekv(vmci_trans(vsk)->qpair, msg, len, 0);
1862 else
1863 return vmci_qpair_dequev(vmci_trans(vsk)->qpair, msg, len, 0);
1864 }
1865
1866 static ssize_t vmci_transport_stream_enqueue(
1867 struct vsock_sock *vsk,
1868 struct msghdr *msg,
1869 size_t len)
1870 {
1871 return vmci_qpair_enquev(vmci_trans(vsk)->qpair, msg, len, 0);
1872 }
1873
1874 static s64 vmci_transport_stream_has_data(struct vsock_sock *vsk)
1875 {
1876 return vmci_qpair_consume_buf_ready(vmci_trans(vsk)->qpair);
1877 }
1878
1879 static s64 vmci_transport_stream_has_space(struct vsock_sock *vsk)
1880 {
1881 return vmci_qpair_produce_free_space(vmci_trans(vsk)->qpair);
1882 }
1883
1884 static u64 vmci_transport_stream_rcvhiwat(struct vsock_sock *vsk)
1885 {
1886 return vmci_trans(vsk)->consume_size;
1887 }
1888
1889 static bool vmci_transport_stream_is_active(struct vsock_sock *vsk)
1890 {
1891 return !vmci_handle_is_invalid(vmci_trans(vsk)->qp_handle);
1892 }
1893
1894 static u64 vmci_transport_get_buffer_size(struct vsock_sock *vsk)
1895 {
1896 return vmci_trans(vsk)->queue_pair_size;
1897 }
1898
1899 static u64 vmci_transport_get_min_buffer_size(struct vsock_sock *vsk)
1900 {
1901 return vmci_trans(vsk)->queue_pair_min_size;
1902 }
1903
1904 static u64 vmci_transport_get_max_buffer_size(struct vsock_sock *vsk)
1905 {
1906 return vmci_trans(vsk)->queue_pair_max_size;
1907 }
1908
1909 static void vmci_transport_set_buffer_size(struct vsock_sock *vsk, u64 val)
1910 {
1911 if (val < vmci_trans(vsk)->queue_pair_min_size)
1912 vmci_trans(vsk)->queue_pair_min_size = val;
1913 if (val > vmci_trans(vsk)->queue_pair_max_size)
1914 vmci_trans(vsk)->queue_pair_max_size = val;
1915 vmci_trans(vsk)->queue_pair_size = val;
1916 }
1917
1918 static void vmci_transport_set_min_buffer_size(struct vsock_sock *vsk,
1919 u64 val)
1920 {
1921 if (val > vmci_trans(vsk)->queue_pair_size)
1922 vmci_trans(vsk)->queue_pair_size = val;
1923 vmci_trans(vsk)->queue_pair_min_size = val;
1924 }
1925
1926 static void vmci_transport_set_max_buffer_size(struct vsock_sock *vsk,
1927 u64 val)
1928 {
1929 if (val < vmci_trans(vsk)->queue_pair_size)
1930 vmci_trans(vsk)->queue_pair_size = val;
1931 vmci_trans(vsk)->queue_pair_max_size = val;
1932 }
1933
1934 static int vmci_transport_notify_poll_in(
1935 struct vsock_sock *vsk,
1936 size_t target,
1937 bool *data_ready_now)
1938 {
1939 return vmci_trans(vsk)->notify_ops->poll_in(
1940 &vsk->sk, target, data_ready_now);
1941 }
1942
1943 static int vmci_transport_notify_poll_out(
1944 struct vsock_sock *vsk,
1945 size_t target,
1946 bool *space_available_now)
1947 {
1948 return vmci_trans(vsk)->notify_ops->poll_out(
1949 &vsk->sk, target, space_available_now);
1950 }
1951
1952 static int vmci_transport_notify_recv_init(
1953 struct vsock_sock *vsk,
1954 size_t target,
1955 struct vsock_transport_recv_notify_data *data)
1956 {
1957 return vmci_trans(vsk)->notify_ops->recv_init(
1958 &vsk->sk, target,
1959 (struct vmci_transport_recv_notify_data *)data);
1960 }
1961
1962 static int vmci_transport_notify_recv_pre_block(
1963 struct vsock_sock *vsk,
1964 size_t target,
1965 struct vsock_transport_recv_notify_data *data)
1966 {
1967 return vmci_trans(vsk)->notify_ops->recv_pre_block(
1968 &vsk->sk, target,
1969 (struct vmci_transport_recv_notify_data *)data);
1970 }
1971
1972 static int vmci_transport_notify_recv_pre_dequeue(
1973 struct vsock_sock *vsk,
1974 size_t target,
1975 struct vsock_transport_recv_notify_data *data)
1976 {
1977 return vmci_trans(vsk)->notify_ops->recv_pre_dequeue(
1978 &vsk->sk, target,
1979 (struct vmci_transport_recv_notify_data *)data);
1980 }
1981
1982 static int vmci_transport_notify_recv_post_dequeue(
1983 struct vsock_sock *vsk,
1984 size_t target,
1985 ssize_t copied,
1986 bool data_read,
1987 struct vsock_transport_recv_notify_data *data)
1988 {
1989 return vmci_trans(vsk)->notify_ops->recv_post_dequeue(
1990 &vsk->sk, target, copied, data_read,
1991 (struct vmci_transport_recv_notify_data *)data);
1992 }
1993
1994 static int vmci_transport_notify_send_init(
1995 struct vsock_sock *vsk,
1996 struct vsock_transport_send_notify_data *data)
1997 {
1998 return vmci_trans(vsk)->notify_ops->send_init(
1999 &vsk->sk,
2000 (struct vmci_transport_send_notify_data *)data);
2001 }
2002
2003 static int vmci_transport_notify_send_pre_block(
2004 struct vsock_sock *vsk,
2005 struct vsock_transport_send_notify_data *data)
2006 {
2007 return vmci_trans(vsk)->notify_ops->send_pre_block(
2008 &vsk->sk,
2009 (struct vmci_transport_send_notify_data *)data);
2010 }
2011
2012 static int vmci_transport_notify_send_pre_enqueue(
2013 struct vsock_sock *vsk,
2014 struct vsock_transport_send_notify_data *data)
2015 {
2016 return vmci_trans(vsk)->notify_ops->send_pre_enqueue(
2017 &vsk->sk,
2018 (struct vmci_transport_send_notify_data *)data);
2019 }
2020
2021 static int vmci_transport_notify_send_post_enqueue(
2022 struct vsock_sock *vsk,
2023 ssize_t written,
2024 struct vsock_transport_send_notify_data *data)
2025 {
2026 return vmci_trans(vsk)->notify_ops->send_post_enqueue(
2027 &vsk->sk, written,
2028 (struct vmci_transport_send_notify_data *)data);
2029 }
2030
2031 static bool vmci_transport_old_proto_override(bool *old_pkt_proto)
2032 {
2033 if (PROTOCOL_OVERRIDE != -1) {
2034 if (PROTOCOL_OVERRIDE == 0)
2035 *old_pkt_proto = true;
2036 else
2037 *old_pkt_proto = false;
2038
2039 pr_info("Proto override in use\n");
2040 return true;
2041 }
2042
2043 return false;
2044 }
2045
2046 static bool vmci_transport_proto_to_notify_struct(struct sock *sk,
2047 u16 *proto,
2048 bool old_pkt_proto)
2049 {
2050 struct vsock_sock *vsk = vsock_sk(sk);
2051
2052 if (old_pkt_proto) {
2053 if (*proto != VSOCK_PROTO_INVALID) {
2054 pr_err("Can't set both an old and new protocol\n");
2055 return false;
2056 }
2057 vmci_trans(vsk)->notify_ops = &vmci_transport_notify_pkt_ops;
2058 goto exit;
2059 }
2060
2061 switch (*proto) {
2062 case VSOCK_PROTO_PKT_ON_NOTIFY:
2063 vmci_trans(vsk)->notify_ops =
2064 &vmci_transport_notify_pkt_q_state_ops;
2065 break;
2066 default:
2067 pr_err("Unknown notify protocol version\n");
2068 return false;
2069 }
2070
2071 exit:
2072 vmci_trans(vsk)->notify_ops->socket_init(sk);
2073 return true;
2074 }
2075
2076 static u16 vmci_transport_new_proto_supported_versions(void)
2077 {
2078 if (PROTOCOL_OVERRIDE != -1)
2079 return PROTOCOL_OVERRIDE;
2080
2081 return VSOCK_PROTO_ALL_SUPPORTED;
2082 }
2083
2084 static u32 vmci_transport_get_local_cid(void)
2085 {
2086 return vmci_get_context_id();
2087 }
2088
2089 static struct vsock_transport vmci_transport = {
2090 .init = vmci_transport_socket_init,
2091 .destruct = vmci_transport_destruct,
2092 .release = vmci_transport_release,
2093 .connect = vmci_transport_connect,
2094 .dgram_bind = vmci_transport_dgram_bind,
2095 .dgram_dequeue = vmci_transport_dgram_dequeue,
2096 .dgram_enqueue = vmci_transport_dgram_enqueue,
2097 .dgram_allow = vmci_transport_dgram_allow,
2098 .stream_dequeue = vmci_transport_stream_dequeue,
2099 .stream_enqueue = vmci_transport_stream_enqueue,
2100 .stream_has_data = vmci_transport_stream_has_data,
2101 .stream_has_space = vmci_transport_stream_has_space,
2102 .stream_rcvhiwat = vmci_transport_stream_rcvhiwat,
2103 .stream_is_active = vmci_transport_stream_is_active,
2104 .stream_allow = vmci_transport_stream_allow,
2105 .notify_poll_in = vmci_transport_notify_poll_in,
2106 .notify_poll_out = vmci_transport_notify_poll_out,
2107 .notify_recv_init = vmci_transport_notify_recv_init,
2108 .notify_recv_pre_block = vmci_transport_notify_recv_pre_block,
2109 .notify_recv_pre_dequeue = vmci_transport_notify_recv_pre_dequeue,
2110 .notify_recv_post_dequeue = vmci_transport_notify_recv_post_dequeue,
2111 .notify_send_init = vmci_transport_notify_send_init,
2112 .notify_send_pre_block = vmci_transport_notify_send_pre_block,
2113 .notify_send_pre_enqueue = vmci_transport_notify_send_pre_enqueue,
2114 .notify_send_post_enqueue = vmci_transport_notify_send_post_enqueue,
2115 .shutdown = vmci_transport_shutdown,
2116 .set_buffer_size = vmci_transport_set_buffer_size,
2117 .set_min_buffer_size = vmci_transport_set_min_buffer_size,
2118 .set_max_buffer_size = vmci_transport_set_max_buffer_size,
2119 .get_buffer_size = vmci_transport_get_buffer_size,
2120 .get_min_buffer_size = vmci_transport_get_min_buffer_size,
2121 .get_max_buffer_size = vmci_transport_get_max_buffer_size,
2122 .get_local_cid = vmci_transport_get_local_cid,
2123 };
2124
2125 static int __init vmci_transport_init(void)
2126 {
2127 int err;
2128
2129 /* Create the datagram handle that we will use to send and receive all
2130 * VSocket control messages for this context.
2131 */
2132 err = vmci_transport_datagram_create_hnd(VMCI_TRANSPORT_PACKET_RID,
2133 VMCI_FLAG_ANYCID_DG_HND,
2134 vmci_transport_recv_stream_cb,
2135 NULL,
2136 &vmci_transport_stream_handle);
2137 if (err < VMCI_SUCCESS) {
2138 pr_err("Unable to create datagram handle. (%d)\n", err);
2139 return vmci_transport_error_to_vsock_error(err);
2140 }
2141
2142 err = vmci_event_subscribe(VMCI_EVENT_QP_RESUMED,
2143 vmci_transport_qp_resumed_cb,
2144 NULL, &vmci_transport_qp_resumed_sub_id);
2145 if (err < VMCI_SUCCESS) {
2146 pr_err("Unable to subscribe to resumed event. (%d)\n", err);
2147 err = vmci_transport_error_to_vsock_error(err);
2148 vmci_transport_qp_resumed_sub_id = VMCI_INVALID_ID;
2149 goto err_destroy_stream_handle;
2150 }
2151
2152 err = vsock_core_init(&vmci_transport);
2153 if (err < 0)
2154 goto err_unsubscribe;
2155
2156 return 0;
2157
2158 err_unsubscribe:
2159 vmci_event_unsubscribe(vmci_transport_qp_resumed_sub_id);
2160 err_destroy_stream_handle:
2161 vmci_datagram_destroy_handle(vmci_transport_stream_handle);
2162 return err;
2163 }
2164 module_init(vmci_transport_init);
2165
2166 static void __exit vmci_transport_exit(void)
2167 {
2168 cancel_work_sync(&vmci_transport_cleanup_work);
2169 vmci_transport_free_resources(&vmci_transport_cleanup_list);
2170
2171 if (!vmci_handle_is_invalid(vmci_transport_stream_handle)) {
2172 if (vmci_datagram_destroy_handle(
2173 vmci_transport_stream_handle) != VMCI_SUCCESS)
2174 pr_err("Couldn't destroy datagram handle\n");
2175 vmci_transport_stream_handle = VMCI_INVALID_HANDLE;
2176 }
2177
2178 if (vmci_transport_qp_resumed_sub_id != VMCI_INVALID_ID) {
2179 vmci_event_unsubscribe(vmci_transport_qp_resumed_sub_id);
2180 vmci_transport_qp_resumed_sub_id = VMCI_INVALID_ID;
2181 }
2182
2183 vsock_core_exit();
2184 }
2185 module_exit(vmci_transport_exit);
2186
2187 MODULE_AUTHOR("VMware, Inc.");
2188 MODULE_DESCRIPTION("VMCI transport for Virtual Sockets");
2189 MODULE_VERSION("1.0.3.0-k");
2190 MODULE_LICENSE("GPL v2");
2191 MODULE_ALIAS("vmware_vsock");
2192 MODULE_ALIAS_NETPROTO(PF_VSOCK);
Linux with added FPC-III support