1 // SPDX-License-Identifier: GPL-2.0-only
3 * common code for virtio vsock
5 * Copyright (C) 2013-2015 Red Hat, Inc.
6 * Author: Asias He <asias@redhat.com>
7 * Stefan Hajnoczi <stefanha@redhat.com>
9 #include <linux/spinlock.h>
10 #include <linux/module.h>
11 #include <linux/sched/signal.h>
12 #include <linux/ctype.h>
13 #include <linux/list.h>
14 #include <linux/virtio.h>
15 #include <linux/virtio_ids.h>
16 #include <linux/virtio_config.h>
17 #include <linux/virtio_vsock.h>
18 #include <uapi/linux/vsockmon.h>
21 #include <net/af_vsock.h>
23 #define CREATE_TRACE_POINTS
24 #include <trace/events/vsock_virtio_transport_common.h>
26 /* How long to wait for graceful shutdown of a connection */
27 #define VSOCK_CLOSE_TIMEOUT (8 * HZ)
29 static const struct virtio_transport *virtio_transport_get_ops(void)
31 const struct vsock_transport *t = vsock_core_get_transport();
33 return container_of(t, struct virtio_transport, transport);
36 static struct virtio_vsock_pkt *
37 virtio_transport_alloc_pkt(struct virtio_vsock_pkt_info *info,
44 struct virtio_vsock_pkt *pkt;
47 pkt = kzalloc(sizeof(*pkt), GFP_KERNEL);
51 pkt->hdr.type = cpu_to_le16(info->type);
52 pkt->hdr.op = cpu_to_le16(info->op);
53 pkt->hdr.src_cid = cpu_to_le64(src_cid);
54 pkt->hdr.dst_cid = cpu_to_le64(dst_cid);
55 pkt->hdr.src_port = cpu_to_le32(src_port);
56 pkt->hdr.dst_port = cpu_to_le32(dst_port);
57 pkt->hdr.flags = cpu_to_le32(info->flags);
59 pkt->hdr.len = cpu_to_le32(len);
60 pkt->reply = info->reply;
63 if (info->msg && len > 0) {
64 pkt->buf = kmalloc(len, GFP_KERNEL);
67 err = memcpy_from_msg(pkt->buf, info->msg, len);
72 trace_virtio_transport_alloc_pkt(src_cid, src_port,
89 static struct sk_buff *virtio_transport_build_skb(void *opaque)
91 struct virtio_vsock_pkt *pkt = opaque;
92 struct af_vsockmon_hdr *hdr;
95 skb = alloc_skb(sizeof(*hdr) + sizeof(pkt->hdr) + pkt->len,
100 hdr = skb_put(skb, sizeof(*hdr));
102 /* pkt->hdr is little-endian so no need to byteswap here */
103 hdr->src_cid = pkt->hdr.src_cid;
104 hdr->src_port = pkt->hdr.src_port;
105 hdr->dst_cid = pkt->hdr.dst_cid;
106 hdr->dst_port = pkt->hdr.dst_port;
108 hdr->transport = cpu_to_le16(AF_VSOCK_TRANSPORT_VIRTIO);
109 hdr->len = cpu_to_le16(sizeof(pkt->hdr));
110 memset(hdr->reserved, 0, sizeof(hdr->reserved));
112 switch (le16_to_cpu(pkt->hdr.op)) {
113 case VIRTIO_VSOCK_OP_REQUEST:
114 case VIRTIO_VSOCK_OP_RESPONSE:
115 hdr->op = cpu_to_le16(AF_VSOCK_OP_CONNECT);
117 case VIRTIO_VSOCK_OP_RST:
118 case VIRTIO_VSOCK_OP_SHUTDOWN:
119 hdr->op = cpu_to_le16(AF_VSOCK_OP_DISCONNECT);
121 case VIRTIO_VSOCK_OP_RW:
122 hdr->op = cpu_to_le16(AF_VSOCK_OP_PAYLOAD);
124 case VIRTIO_VSOCK_OP_CREDIT_UPDATE:
125 case VIRTIO_VSOCK_OP_CREDIT_REQUEST:
126 hdr->op = cpu_to_le16(AF_VSOCK_OP_CONTROL);
129 hdr->op = cpu_to_le16(AF_VSOCK_OP_UNKNOWN);
133 skb_put_data(skb, &pkt->hdr, sizeof(pkt->hdr));
136 skb_put_data(skb, pkt->buf, pkt->len);
142 void virtio_transport_deliver_tap_pkt(struct virtio_vsock_pkt *pkt)
144 vsock_deliver_tap(virtio_transport_build_skb, pkt);
146 EXPORT_SYMBOL_GPL(virtio_transport_deliver_tap_pkt);
148 static int virtio_transport_send_pkt_info(struct vsock_sock *vsk,
149 struct virtio_vsock_pkt_info *info)
151 u32 src_cid, src_port, dst_cid, dst_port;
152 struct virtio_vsock_sock *vvs;
153 struct virtio_vsock_pkt *pkt;
154 u32 pkt_len = info->pkt_len;
156 src_cid = vm_sockets_get_local_cid();
157 src_port = vsk->local_addr.svm_port;
158 if (!info->remote_cid) {
159 dst_cid = vsk->remote_addr.svm_cid;
160 dst_port = vsk->remote_addr.svm_port;
162 dst_cid = info->remote_cid;
163 dst_port = info->remote_port;
168 /* we can send less than pkt_len bytes */
169 if (pkt_len > VIRTIO_VSOCK_DEFAULT_RX_BUF_SIZE)
170 pkt_len = VIRTIO_VSOCK_DEFAULT_RX_BUF_SIZE;
172 /* virtio_transport_get_credit might return less than pkt_len credit */
173 pkt_len = virtio_transport_get_credit(vvs, pkt_len);
175 /* Do not send zero length OP_RW pkt */
176 if (pkt_len == 0 && info->op == VIRTIO_VSOCK_OP_RW)
179 pkt = virtio_transport_alloc_pkt(info, pkt_len,
183 virtio_transport_put_credit(vvs, pkt_len);
187 virtio_transport_inc_tx_pkt(vvs, pkt);
189 return virtio_transport_get_ops()->send_pkt(pkt);
192 static void virtio_transport_inc_rx_pkt(struct virtio_vsock_sock *vvs,
193 struct virtio_vsock_pkt *pkt)
195 vvs->rx_bytes += pkt->len;
198 static void virtio_transport_dec_rx_pkt(struct virtio_vsock_sock *vvs,
199 struct virtio_vsock_pkt *pkt)
201 vvs->rx_bytes -= pkt->len;
202 vvs->fwd_cnt += pkt->len;
205 void virtio_transport_inc_tx_pkt(struct virtio_vsock_sock *vvs, struct virtio_vsock_pkt *pkt)
207 spin_lock_bh(&vvs->tx_lock);
208 pkt->hdr.fwd_cnt = cpu_to_le32(vvs->fwd_cnt);
209 pkt->hdr.buf_alloc = cpu_to_le32(vvs->buf_alloc);
210 spin_unlock_bh(&vvs->tx_lock);
212 EXPORT_SYMBOL_GPL(virtio_transport_inc_tx_pkt);
214 u32 virtio_transport_get_credit(struct virtio_vsock_sock *vvs, u32 credit)
218 spin_lock_bh(&vvs->tx_lock);
219 ret = vvs->peer_buf_alloc - (vvs->tx_cnt - vvs->peer_fwd_cnt);
223 spin_unlock_bh(&vvs->tx_lock);
227 EXPORT_SYMBOL_GPL(virtio_transport_get_credit);
229 void virtio_transport_put_credit(struct virtio_vsock_sock *vvs, u32 credit)
231 spin_lock_bh(&vvs->tx_lock);
232 vvs->tx_cnt -= credit;
233 spin_unlock_bh(&vvs->tx_lock);
235 EXPORT_SYMBOL_GPL(virtio_transport_put_credit);
237 static int virtio_transport_send_credit_update(struct vsock_sock *vsk,
239 struct virtio_vsock_hdr *hdr)
241 struct virtio_vsock_pkt_info info = {
242 .op = VIRTIO_VSOCK_OP_CREDIT_UPDATE,
247 return virtio_transport_send_pkt_info(vsk, &info);
251 virtio_transport_stream_do_dequeue(struct vsock_sock *vsk,
255 struct virtio_vsock_sock *vvs = vsk->trans;
256 struct virtio_vsock_pkt *pkt;
257 size_t bytes, total = 0;
260 spin_lock_bh(&vvs->rx_lock);
261 while (total < len && !list_empty(&vvs->rx_queue)) {
262 pkt = list_first_entry(&vvs->rx_queue,
263 struct virtio_vsock_pkt, list);
266 if (bytes > pkt->len - pkt->off)
267 bytes = pkt->len - pkt->off;
269 /* sk_lock is held by caller so no one else can dequeue.
270 * Unlock rx_lock since memcpy_to_msg() may sleep.
272 spin_unlock_bh(&vvs->rx_lock);
274 err = memcpy_to_msg(msg, pkt->buf + pkt->off, bytes);
278 spin_lock_bh(&vvs->rx_lock);
282 if (pkt->off == pkt->len) {
283 virtio_transport_dec_rx_pkt(vvs, pkt);
284 list_del(&pkt->list);
285 virtio_transport_free_pkt(pkt);
288 spin_unlock_bh(&vvs->rx_lock);
290 /* Send a credit pkt to peer */
291 virtio_transport_send_credit_update(vsk, VIRTIO_VSOCK_TYPE_STREAM,
303 virtio_transport_stream_dequeue(struct vsock_sock *vsk,
305 size_t len, int flags)
307 if (flags & MSG_PEEK)
310 return virtio_transport_stream_do_dequeue(vsk, msg, len);
312 EXPORT_SYMBOL_GPL(virtio_transport_stream_dequeue);
315 virtio_transport_dgram_dequeue(struct vsock_sock *vsk,
317 size_t len, int flags)
321 EXPORT_SYMBOL_GPL(virtio_transport_dgram_dequeue);
323 s64 virtio_transport_stream_has_data(struct vsock_sock *vsk)
325 struct virtio_vsock_sock *vvs = vsk->trans;
328 spin_lock_bh(&vvs->rx_lock);
329 bytes = vvs->rx_bytes;
330 spin_unlock_bh(&vvs->rx_lock);
334 EXPORT_SYMBOL_GPL(virtio_transport_stream_has_data);
336 static s64 virtio_transport_has_space(struct vsock_sock *vsk)
338 struct virtio_vsock_sock *vvs = vsk->trans;
341 bytes = vvs->peer_buf_alloc - (vvs->tx_cnt - vvs->peer_fwd_cnt);
348 s64 virtio_transport_stream_has_space(struct vsock_sock *vsk)
350 struct virtio_vsock_sock *vvs = vsk->trans;
353 spin_lock_bh(&vvs->tx_lock);
354 bytes = virtio_transport_has_space(vsk);
355 spin_unlock_bh(&vvs->tx_lock);
359 EXPORT_SYMBOL_GPL(virtio_transport_stream_has_space);
361 int virtio_transport_do_socket_init(struct vsock_sock *vsk,
362 struct vsock_sock *psk)
364 struct virtio_vsock_sock *vvs;
366 vvs = kzalloc(sizeof(*vvs), GFP_KERNEL);
373 struct virtio_vsock_sock *ptrans = psk->trans;
375 vvs->buf_size = ptrans->buf_size;
376 vvs->buf_size_min = ptrans->buf_size_min;
377 vvs->buf_size_max = ptrans->buf_size_max;
378 vvs->peer_buf_alloc = ptrans->peer_buf_alloc;
380 vvs->buf_size = VIRTIO_VSOCK_DEFAULT_BUF_SIZE;
381 vvs->buf_size_min = VIRTIO_VSOCK_DEFAULT_MIN_BUF_SIZE;
382 vvs->buf_size_max = VIRTIO_VSOCK_DEFAULT_MAX_BUF_SIZE;
385 vvs->buf_alloc = vvs->buf_size;
387 spin_lock_init(&vvs->rx_lock);
388 spin_lock_init(&vvs->tx_lock);
389 INIT_LIST_HEAD(&vvs->rx_queue);
393 EXPORT_SYMBOL_GPL(virtio_transport_do_socket_init);
395 u64 virtio_transport_get_buffer_size(struct vsock_sock *vsk)
397 struct virtio_vsock_sock *vvs = vsk->trans;
399 return vvs->buf_size;
401 EXPORT_SYMBOL_GPL(virtio_transport_get_buffer_size);
403 u64 virtio_transport_get_min_buffer_size(struct vsock_sock *vsk)
405 struct virtio_vsock_sock *vvs = vsk->trans;
407 return vvs->buf_size_min;
409 EXPORT_SYMBOL_GPL(virtio_transport_get_min_buffer_size);
411 u64 virtio_transport_get_max_buffer_size(struct vsock_sock *vsk)
413 struct virtio_vsock_sock *vvs = vsk->trans;
415 return vvs->buf_size_max;
417 EXPORT_SYMBOL_GPL(virtio_transport_get_max_buffer_size);
419 void virtio_transport_set_buffer_size(struct vsock_sock *vsk, u64 val)
421 struct virtio_vsock_sock *vvs = vsk->trans;
423 if (val > VIRTIO_VSOCK_MAX_BUF_SIZE)
424 val = VIRTIO_VSOCK_MAX_BUF_SIZE;
425 if (val < vvs->buf_size_min)
426 vvs->buf_size_min = val;
427 if (val > vvs->buf_size_max)
428 vvs->buf_size_max = val;
430 vvs->buf_alloc = val;
432 EXPORT_SYMBOL_GPL(virtio_transport_set_buffer_size);
434 void virtio_transport_set_min_buffer_size(struct vsock_sock *vsk, u64 val)
436 struct virtio_vsock_sock *vvs = vsk->trans;
438 if (val > VIRTIO_VSOCK_MAX_BUF_SIZE)
439 val = VIRTIO_VSOCK_MAX_BUF_SIZE;
440 if (val > vvs->buf_size)
442 vvs->buf_size_min = val;
444 EXPORT_SYMBOL_GPL(virtio_transport_set_min_buffer_size);
446 void virtio_transport_set_max_buffer_size(struct vsock_sock *vsk, u64 val)
448 struct virtio_vsock_sock *vvs = vsk->trans;
450 if (val > VIRTIO_VSOCK_MAX_BUF_SIZE)
451 val = VIRTIO_VSOCK_MAX_BUF_SIZE;
452 if (val < vvs->buf_size)
454 vvs->buf_size_max = val;
456 EXPORT_SYMBOL_GPL(virtio_transport_set_max_buffer_size);
459 virtio_transport_notify_poll_in(struct vsock_sock *vsk,
461 bool *data_ready_now)
463 if (vsock_stream_has_data(vsk))
464 *data_ready_now = true;
466 *data_ready_now = false;
470 EXPORT_SYMBOL_GPL(virtio_transport_notify_poll_in);
473 virtio_transport_notify_poll_out(struct vsock_sock *vsk,
475 bool *space_avail_now)
479 free_space = vsock_stream_has_space(vsk);
481 *space_avail_now = true;
482 else if (free_space == 0)
483 *space_avail_now = false;
487 EXPORT_SYMBOL_GPL(virtio_transport_notify_poll_out);
489 int virtio_transport_notify_recv_init(struct vsock_sock *vsk,
490 size_t target, struct vsock_transport_recv_notify_data *data)
494 EXPORT_SYMBOL_GPL(virtio_transport_notify_recv_init);
496 int virtio_transport_notify_recv_pre_block(struct vsock_sock *vsk,
497 size_t target, struct vsock_transport_recv_notify_data *data)
501 EXPORT_SYMBOL_GPL(virtio_transport_notify_recv_pre_block);
503 int virtio_transport_notify_recv_pre_dequeue(struct vsock_sock *vsk,
504 size_t target, struct vsock_transport_recv_notify_data *data)
508 EXPORT_SYMBOL_GPL(virtio_transport_notify_recv_pre_dequeue);
510 int virtio_transport_notify_recv_post_dequeue(struct vsock_sock *vsk,
511 size_t target, ssize_t copied, bool data_read,
512 struct vsock_transport_recv_notify_data *data)
516 EXPORT_SYMBOL_GPL(virtio_transport_notify_recv_post_dequeue);
518 int virtio_transport_notify_send_init(struct vsock_sock *vsk,
519 struct vsock_transport_send_notify_data *data)
523 EXPORT_SYMBOL_GPL(virtio_transport_notify_send_init);
525 int virtio_transport_notify_send_pre_block(struct vsock_sock *vsk,
526 struct vsock_transport_send_notify_data *data)
530 EXPORT_SYMBOL_GPL(virtio_transport_notify_send_pre_block);
532 int virtio_transport_notify_send_pre_enqueue(struct vsock_sock *vsk,
533 struct vsock_transport_send_notify_data *data)
537 EXPORT_SYMBOL_GPL(virtio_transport_notify_send_pre_enqueue);
539 int virtio_transport_notify_send_post_enqueue(struct vsock_sock *vsk,
540 ssize_t written, struct vsock_transport_send_notify_data *data)
544 EXPORT_SYMBOL_GPL(virtio_transport_notify_send_post_enqueue);
546 u64 virtio_transport_stream_rcvhiwat(struct vsock_sock *vsk)
548 struct virtio_vsock_sock *vvs = vsk->trans;
550 return vvs->buf_size;
552 EXPORT_SYMBOL_GPL(virtio_transport_stream_rcvhiwat);
554 bool virtio_transport_stream_is_active(struct vsock_sock *vsk)
558 EXPORT_SYMBOL_GPL(virtio_transport_stream_is_active);
560 bool virtio_transport_stream_allow(u32 cid, u32 port)
564 EXPORT_SYMBOL_GPL(virtio_transport_stream_allow);
566 int virtio_transport_dgram_bind(struct vsock_sock *vsk,
567 struct sockaddr_vm *addr)
571 EXPORT_SYMBOL_GPL(virtio_transport_dgram_bind);
573 bool virtio_transport_dgram_allow(u32 cid, u32 port)
577 EXPORT_SYMBOL_GPL(virtio_transport_dgram_allow);
579 int virtio_transport_connect(struct vsock_sock *vsk)
581 struct virtio_vsock_pkt_info info = {
582 .op = VIRTIO_VSOCK_OP_REQUEST,
583 .type = VIRTIO_VSOCK_TYPE_STREAM,
587 return virtio_transport_send_pkt_info(vsk, &info);
589 EXPORT_SYMBOL_GPL(virtio_transport_connect);
591 int virtio_transport_shutdown(struct vsock_sock *vsk, int mode)
593 struct virtio_vsock_pkt_info info = {
594 .op = VIRTIO_VSOCK_OP_SHUTDOWN,
595 .type = VIRTIO_VSOCK_TYPE_STREAM,
596 .flags = (mode & RCV_SHUTDOWN ?
597 VIRTIO_VSOCK_SHUTDOWN_RCV : 0) |
598 (mode & SEND_SHUTDOWN ?
599 VIRTIO_VSOCK_SHUTDOWN_SEND : 0),
603 return virtio_transport_send_pkt_info(vsk, &info);
605 EXPORT_SYMBOL_GPL(virtio_transport_shutdown);
608 virtio_transport_dgram_enqueue(struct vsock_sock *vsk,
609 struct sockaddr_vm *remote_addr,
615 EXPORT_SYMBOL_GPL(virtio_transport_dgram_enqueue);
618 virtio_transport_stream_enqueue(struct vsock_sock *vsk,
622 struct virtio_vsock_pkt_info info = {
623 .op = VIRTIO_VSOCK_OP_RW,
624 .type = VIRTIO_VSOCK_TYPE_STREAM,
630 return virtio_transport_send_pkt_info(vsk, &info);
632 EXPORT_SYMBOL_GPL(virtio_transport_stream_enqueue);
634 void virtio_transport_destruct(struct vsock_sock *vsk)
636 struct virtio_vsock_sock *vvs = vsk->trans;
640 EXPORT_SYMBOL_GPL(virtio_transport_destruct);
642 static int virtio_transport_reset(struct vsock_sock *vsk,
643 struct virtio_vsock_pkt *pkt)
645 struct virtio_vsock_pkt_info info = {
646 .op = VIRTIO_VSOCK_OP_RST,
647 .type = VIRTIO_VSOCK_TYPE_STREAM,
652 /* Send RST only if the original pkt is not a RST pkt */
653 if (pkt && le16_to_cpu(pkt->hdr.op) == VIRTIO_VSOCK_OP_RST)
656 return virtio_transport_send_pkt_info(vsk, &info);
659 /* Normally packets are associated with a socket. There may be no socket if an
660 * attempt was made to connect to a socket that does not exist.
662 static int virtio_transport_reset_no_sock(struct virtio_vsock_pkt *pkt)
664 const struct virtio_transport *t;
665 struct virtio_vsock_pkt *reply;
666 struct virtio_vsock_pkt_info info = {
667 .op = VIRTIO_VSOCK_OP_RST,
668 .type = le16_to_cpu(pkt->hdr.type),
672 /* Send RST only if the original pkt is not a RST pkt */
673 if (le16_to_cpu(pkt->hdr.op) == VIRTIO_VSOCK_OP_RST)
676 reply = virtio_transport_alloc_pkt(&info, 0,
677 le64_to_cpu(pkt->hdr.dst_cid),
678 le32_to_cpu(pkt->hdr.dst_port),
679 le64_to_cpu(pkt->hdr.src_cid),
680 le32_to_cpu(pkt->hdr.src_port));
684 t = virtio_transport_get_ops();
686 virtio_transport_free_pkt(reply);
690 return t->send_pkt(reply);
693 static void virtio_transport_wait_close(struct sock *sk, long timeout)
696 DEFINE_WAIT_FUNC(wait, woken_wake_function);
698 add_wait_queue(sk_sleep(sk), &wait);
701 if (sk_wait_event(sk, &timeout,
702 sock_flag(sk, SOCK_DONE), &wait))
704 } while (!signal_pending(current) && timeout);
706 remove_wait_queue(sk_sleep(sk), &wait);
710 static void virtio_transport_do_close(struct vsock_sock *vsk,
713 struct sock *sk = sk_vsock(vsk);
715 sock_set_flag(sk, SOCK_DONE);
716 vsk->peer_shutdown = SHUTDOWN_MASK;
717 if (vsock_stream_has_data(vsk) <= 0)
718 sk->sk_state = TCP_CLOSING;
719 sk->sk_state_change(sk);
721 if (vsk->close_work_scheduled &&
722 (!cancel_timeout || cancel_delayed_work(&vsk->close_work))) {
723 vsk->close_work_scheduled = false;
725 vsock_remove_sock(vsk);
727 /* Release refcnt obtained when we scheduled the timeout */
732 static void virtio_transport_close_timeout(struct work_struct *work)
734 struct vsock_sock *vsk =
735 container_of(work, struct vsock_sock, close_work.work);
736 struct sock *sk = sk_vsock(vsk);
741 if (!sock_flag(sk, SOCK_DONE)) {
742 (void)virtio_transport_reset(vsk, NULL);
744 virtio_transport_do_close(vsk, false);
747 vsk->close_work_scheduled = false;
753 /* User context, vsk->sk is locked */
754 static bool virtio_transport_close(struct vsock_sock *vsk)
756 struct sock *sk = &vsk->sk;
758 if (!(sk->sk_state == TCP_ESTABLISHED ||
759 sk->sk_state == TCP_CLOSING))
762 /* Already received SHUTDOWN from peer, reply with RST */
763 if ((vsk->peer_shutdown & SHUTDOWN_MASK) == SHUTDOWN_MASK) {
764 (void)virtio_transport_reset(vsk, NULL);
768 if ((sk->sk_shutdown & SHUTDOWN_MASK) != SHUTDOWN_MASK)
769 (void)virtio_transport_shutdown(vsk, SHUTDOWN_MASK);
771 if (sock_flag(sk, SOCK_LINGER) && !(current->flags & PF_EXITING))
772 virtio_transport_wait_close(sk, sk->sk_lingertime);
774 if (sock_flag(sk, SOCK_DONE)) {
779 INIT_DELAYED_WORK(&vsk->close_work,
780 virtio_transport_close_timeout);
781 vsk->close_work_scheduled = true;
782 schedule_delayed_work(&vsk->close_work, VSOCK_CLOSE_TIMEOUT);
786 void virtio_transport_release(struct vsock_sock *vsk)
788 struct virtio_vsock_sock *vvs = vsk->trans;
789 struct virtio_vsock_pkt *pkt, *tmp;
790 struct sock *sk = &vsk->sk;
791 bool remove_sock = true;
794 if (sk->sk_type == SOCK_STREAM)
795 remove_sock = virtio_transport_close(vsk);
797 list_for_each_entry_safe(pkt, tmp, &vvs->rx_queue, list) {
798 list_del(&pkt->list);
799 virtio_transport_free_pkt(pkt);
804 vsock_remove_sock(vsk);
806 EXPORT_SYMBOL_GPL(virtio_transport_release);
809 virtio_transport_recv_connecting(struct sock *sk,
810 struct virtio_vsock_pkt *pkt)
812 struct vsock_sock *vsk = vsock_sk(sk);
816 switch (le16_to_cpu(pkt->hdr.op)) {
817 case VIRTIO_VSOCK_OP_RESPONSE:
818 sk->sk_state = TCP_ESTABLISHED;
819 sk->sk_socket->state = SS_CONNECTED;
820 vsock_insert_connected(vsk);
821 sk->sk_state_change(sk);
823 case VIRTIO_VSOCK_OP_INVALID:
825 case VIRTIO_VSOCK_OP_RST:
837 virtio_transport_reset(vsk, pkt);
838 sk->sk_state = TCP_CLOSE;
840 sk->sk_error_report(sk);
845 virtio_transport_recv_connected(struct sock *sk,
846 struct virtio_vsock_pkt *pkt)
848 struct vsock_sock *vsk = vsock_sk(sk);
849 struct virtio_vsock_sock *vvs = vsk->trans;
852 switch (le16_to_cpu(pkt->hdr.op)) {
853 case VIRTIO_VSOCK_OP_RW:
854 pkt->len = le32_to_cpu(pkt->hdr.len);
857 spin_lock_bh(&vvs->rx_lock);
858 virtio_transport_inc_rx_pkt(vvs, pkt);
859 list_add_tail(&pkt->list, &vvs->rx_queue);
860 spin_unlock_bh(&vvs->rx_lock);
862 sk->sk_data_ready(sk);
864 case VIRTIO_VSOCK_OP_CREDIT_UPDATE:
865 sk->sk_write_space(sk);
867 case VIRTIO_VSOCK_OP_SHUTDOWN:
868 if (le32_to_cpu(pkt->hdr.flags) & VIRTIO_VSOCK_SHUTDOWN_RCV)
869 vsk->peer_shutdown |= RCV_SHUTDOWN;
870 if (le32_to_cpu(pkt->hdr.flags) & VIRTIO_VSOCK_SHUTDOWN_SEND)
871 vsk->peer_shutdown |= SEND_SHUTDOWN;
872 if (vsk->peer_shutdown == SHUTDOWN_MASK &&
873 vsock_stream_has_data(vsk) <= 0) {
874 sock_set_flag(sk, SOCK_DONE);
875 sk->sk_state = TCP_CLOSING;
877 if (le32_to_cpu(pkt->hdr.flags))
878 sk->sk_state_change(sk);
880 case VIRTIO_VSOCK_OP_RST:
881 virtio_transport_do_close(vsk, true);
888 virtio_transport_free_pkt(pkt);
893 virtio_transport_recv_disconnecting(struct sock *sk,
894 struct virtio_vsock_pkt *pkt)
896 struct vsock_sock *vsk = vsock_sk(sk);
898 if (le16_to_cpu(pkt->hdr.op) == VIRTIO_VSOCK_OP_RST)
899 virtio_transport_do_close(vsk, true);
903 virtio_transport_send_response(struct vsock_sock *vsk,
904 struct virtio_vsock_pkt *pkt)
906 struct virtio_vsock_pkt_info info = {
907 .op = VIRTIO_VSOCK_OP_RESPONSE,
908 .type = VIRTIO_VSOCK_TYPE_STREAM,
909 .remote_cid = le64_to_cpu(pkt->hdr.src_cid),
910 .remote_port = le32_to_cpu(pkt->hdr.src_port),
915 return virtio_transport_send_pkt_info(vsk, &info);
918 /* Handle server socket */
920 virtio_transport_recv_listen(struct sock *sk, struct virtio_vsock_pkt *pkt)
922 struct vsock_sock *vsk = vsock_sk(sk);
923 struct vsock_sock *vchild;
926 if (le16_to_cpu(pkt->hdr.op) != VIRTIO_VSOCK_OP_REQUEST) {
927 virtio_transport_reset(vsk, pkt);
931 if (sk_acceptq_is_full(sk)) {
932 virtio_transport_reset(vsk, pkt);
936 child = __vsock_create(sock_net(sk), NULL, sk, GFP_KERNEL,
939 virtio_transport_reset(vsk, pkt);
943 sk->sk_ack_backlog++;
945 lock_sock_nested(child, SINGLE_DEPTH_NESTING);
947 child->sk_state = TCP_ESTABLISHED;
949 vchild = vsock_sk(child);
950 vsock_addr_init(&vchild->local_addr, le64_to_cpu(pkt->hdr.dst_cid),
951 le32_to_cpu(pkt->hdr.dst_port));
952 vsock_addr_init(&vchild->remote_addr, le64_to_cpu(pkt->hdr.src_cid),
953 le32_to_cpu(pkt->hdr.src_port));
955 vsock_insert_connected(vchild);
956 vsock_enqueue_accept(sk, child);
957 virtio_transport_send_response(vchild, pkt);
961 sk->sk_data_ready(sk);
965 static bool virtio_transport_space_update(struct sock *sk,
966 struct virtio_vsock_pkt *pkt)
968 struct vsock_sock *vsk = vsock_sk(sk);
969 struct virtio_vsock_sock *vvs = vsk->trans;
970 bool space_available;
972 /* buf_alloc and fwd_cnt is always included in the hdr */
973 spin_lock_bh(&vvs->tx_lock);
974 vvs->peer_buf_alloc = le32_to_cpu(pkt->hdr.buf_alloc);
975 vvs->peer_fwd_cnt = le32_to_cpu(pkt->hdr.fwd_cnt);
976 space_available = virtio_transport_has_space(vsk);
977 spin_unlock_bh(&vvs->tx_lock);
978 return space_available;
981 /* We are under the virtio-vsock's vsock->rx_lock or vhost-vsock's vq->mutex
984 void virtio_transport_recv_pkt(struct virtio_vsock_pkt *pkt)
986 struct sockaddr_vm src, dst;
987 struct vsock_sock *vsk;
989 bool space_available;
991 vsock_addr_init(&src, le64_to_cpu(pkt->hdr.src_cid),
992 le32_to_cpu(pkt->hdr.src_port));
993 vsock_addr_init(&dst, le64_to_cpu(pkt->hdr.dst_cid),
994 le32_to_cpu(pkt->hdr.dst_port));
996 trace_virtio_transport_recv_pkt(src.svm_cid, src.svm_port,
997 dst.svm_cid, dst.svm_port,
998 le32_to_cpu(pkt->hdr.len),
999 le16_to_cpu(pkt->hdr.type),
1000 le16_to_cpu(pkt->hdr.op),
1001 le32_to_cpu(pkt->hdr.flags),
1002 le32_to_cpu(pkt->hdr.buf_alloc),
1003 le32_to_cpu(pkt->hdr.fwd_cnt));
1005 if (le16_to_cpu(pkt->hdr.type) != VIRTIO_VSOCK_TYPE_STREAM) {
1006 (void)virtio_transport_reset_no_sock(pkt);
1010 /* The socket must be in connected or bound table
1011 * otherwise send reset back
1013 sk = vsock_find_connected_socket(&src, &dst);
1015 sk = vsock_find_bound_socket(&dst);
1017 (void)virtio_transport_reset_no_sock(pkt);
1024 space_available = virtio_transport_space_update(sk, pkt);
1028 /* Update CID in case it has changed after a transport reset event */
1029 vsk->local_addr.svm_cid = dst.svm_cid;
1031 if (space_available)
1032 sk->sk_write_space(sk);
1034 switch (sk->sk_state) {
1036 virtio_transport_recv_listen(sk, pkt);
1037 virtio_transport_free_pkt(pkt);
1040 virtio_transport_recv_connecting(sk, pkt);
1041 virtio_transport_free_pkt(pkt);
1043 case TCP_ESTABLISHED:
1044 virtio_transport_recv_connected(sk, pkt);
1047 virtio_transport_recv_disconnecting(sk, pkt);
1048 virtio_transport_free_pkt(pkt);
1051 virtio_transport_free_pkt(pkt);
1056 /* Release refcnt obtained when we fetched this socket out of the
1057 * bound or connected list.
1063 virtio_transport_free_pkt(pkt);
1065 EXPORT_SYMBOL_GPL(virtio_transport_recv_pkt);
1067 void virtio_transport_free_pkt(struct virtio_vsock_pkt *pkt)
1072 EXPORT_SYMBOL_GPL(virtio_transport_free_pkt);
1074 MODULE_LICENSE("GPL v2");
1075 MODULE_AUTHOR("Asias He");
1076 MODULE_DESCRIPTION("common code for virtio vsock");