lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
Open Source and information security mailing list archives
| ||
|
Message-ID: <20221215084757.6bpkciaovrnsxoiu@sgarzare-redhat> Date: Thu, 15 Dec 2022 09:47:57 +0100 From: Stefano Garzarella <sgarzare@...hat.com> To: Bobby Eshleman <bobby.eshleman@...edance.com> Cc: Bobby Eshleman <bobbyeshleman@...il.com>, Cong Wang <cong.wang@...edance.com>, Jiang Wang <jiang.wang@...edance.com>, Krasnov Arseniy <oxffffaa@...il.com>, Stefan Hajnoczi <stefanha@...hat.com>, "Michael S. Tsirkin" <mst@...hat.com>, Jason Wang <jasowang@...hat.com>, "David S. Miller" <davem@...emloft.net>, Eric Dumazet <edumazet@...gle.com>, Jakub Kicinski <kuba@...nel.org>, Paolo Abeni <pabeni@...hat.com>, kvm@...r.kernel.org, virtualization@...ts.linux-foundation.org, netdev@...r.kernel.org, linux-kernel@...r.kernel.org Subject: Re: [PATCH net-next v8] virtio/vsock: replace virtio_vsock_pkt with sk_buff On Thu, Dec 15, 2022 at 04:36:44AM +0000, Bobby Eshleman wrote: >This commit changes virtio/vsock to use sk_buff instead of >virtio_vsock_pkt. Beyond better conforming to other net code, using >sk_buff allows vsock to use sk_buff-dependent features in the future >(such as sockmap) and improves throughput. > >This patch introduces the following performance changes: > >Tool/Config: uperf w/ 64 threads, SOCK_STREAM >Test Runs: 5, mean of results >Before: commit 95ec6bce2a0b ("Merge branch 'net-ipa-more-endpoints'") > >Test: 64KB, g2h >Before: 21.63 Gb/s >After: 25.59 Gb/s (+18%) > >Test: 16B, g2h >Before: 11.86 Mb/s >After: 17.41 Mb/s (+46%) > >Test: 64KB, h2g >Before: 2.15 Gb/s >After: 3.6 Gb/s (+67%) > >Test: 16B, h2g >Before: 14.38 Mb/s >After: 18.43 Mb/s (+28%) > >Signed-off-by: Bobby Eshleman <bobby.eshleman@...edance.com> >--- > >Testing: passed vsock_test h2g and g2h >Note2: net-next is closed, but sending out now in case more comments >roll in, as discussed here: >https://lore.kernel.org/all/Y34SoH1nFTXXLWbK@bullseye/ > >Changes in v8: >- vhost/vsock: remove unused enum >- vhost/vsock: use spin_lock_bh() instead of spin_lock() >- vsock/loopback: use __skb_dequeue instead of skb_dequeue > >Changes in v7: >- use skb_queue_empty() instead of skb_queue_empty_lockless() > >Changes in v6: >- use skb->cb instead of skb->_skb_refdst >- use lock-free __skb_queue_purge for rx_queue when rx_lock held > >Changes in v5: >- last_skb instead of skb: last_hdr->len = cpu_to_le32(last_skb->len) > >Changes in v4: >- vdso/bits.h -> linux/bits.h >- add virtio_vsock_alloc_skb() helper >- virtio/vsock: rename buf_len -> total_len >- update last_hdr->len >- fix build_skb() for vsockmon (tested) >- add queue helpers >- use spin_{unlock/lock}_bh() instead of spin_lock()/spin_unlock() >- note: I only ran a few g2h tests to check that this change > had no perf impact. The above data is still from patch > v3. > >Changes in v3: >- fix seqpacket bug >- use zero in vhost_add_used(..., 0) device doesn't write to buffer >- use xmas tree style declarations >- vsock_hdr() -> virtio_vsock_hdr() and other include file style fixes >- no skb merging >- save space by not using vsock_metadata >- use _skb_refdst instead of skb buffer space for flags >- use skb_pull() to keep track of read bytes instead of using an an > extra variable 'off' in the skb buffer space >- remove unnecessary sk_allocation assignment >- do not zero hdr needlessly >- introduce virtio_transport_skb_len() because skb->len changes now >- use spin_lock() directly on queue lock instead of sk_buff_head helpers > which use spin_lock_irqsave() (e.g., skb_dequeue) >- do not reduce buffer size to be page size divisible >- Note: the biggest performance change came from loosening the spinlock > variation and not reducing the buffer size. > >Changes in v2: >- Use alloc_skb() directly instead of sock_alloc_send_pskb() to minimize > uAPI changes. >- Do not marshal errors to -ENOMEM for non-virtio implementations. >- No longer a part of the original series >- Some code cleanup and refactoring >- Include performance stats > > drivers/vhost/vsock.c | 213 +++++------- > include/linux/virtio_vsock.h | 126 +++++-- > net/vmw_vsock/virtio_transport.c | 149 +++------ > net/vmw_vsock/virtio_transport_common.c | 422 +++++++++++++----------- > net/vmw_vsock/vsock_loopback.c | 51 +-- > 5 files changed, 495 insertions(+), 466 deletions(-) > >diff --git a/drivers/vhost/vsock.c b/drivers/vhost/vsock.c >index 5703775af129..ee0a00432cb1 100644 >--- a/drivers/vhost/vsock.c >+++ b/drivers/vhost/vsock.c >@@ -51,8 +51,7 @@ struct vhost_vsock { > struct hlist_node hash; > > struct vhost_work send_pkt_work; >- spinlock_t send_pkt_list_lock; >- struct list_head send_pkt_list; /* host->guest pending packets */ >+ struct sk_buff_head send_pkt_queue; /* host->guest pending packets */ > > atomic_t queued_replies; > >@@ -108,40 +107,33 @@ vhost_transport_do_send_pkt(struct vhost_vsock >*vsock, > vhost_disable_notify(&vsock->dev, vq); > > do { >- struct virtio_vsock_pkt *pkt; >+ struct virtio_vsock_hdr *hdr; >+ size_t iov_len, payload_len; > struct iov_iter iov_iter; >+ u32 flags_to_restore = 0; >+ struct sk_buff *skb; > unsigned out, in; > size_t nbytes; >- size_t iov_len, payload_len; > int head; >- u32 flags_to_restore = 0; > >- spin_lock_bh(&vsock->send_pkt_list_lock); >- if (list_empty(&vsock->send_pkt_list)) { >- spin_unlock_bh(&vsock->send_pkt_list_lock); >+ spin_lock_bh(&vsock->send_pkt_queue.lock); >+ skb = __skb_dequeue(&vsock->send_pkt_queue); >+ spin_unlock_bh(&vsock->send_pkt_queue.lock); Sorry for coming late, but I just commented in Paolo's reply. Here I think we can directly use the new virtio_vsock_skb_dequeue(). With that fixed, you can put my R-b: Reviewed-by: Stefano Garzarella <sgarzare@...hat.com> Below I left a little comment. >+ >+ if (!skb) { > vhost_enable_notify(&vsock->dev, vq); > break; > } > >- pkt = list_first_entry(&vsock->send_pkt_list, >- struct virtio_vsock_pkt, list); >- list_del_init(&pkt->list); >- spin_unlock_bh(&vsock->send_pkt_list_lock); >- > head = vhost_get_vq_desc(vq, vq->iov, ARRAY_SIZE(vq->iov), > &out, &in, NULL, NULL); > if (head < 0) { >- spin_lock_bh(&vsock->send_pkt_list_lock); >- list_add(&pkt->list, &vsock->send_pkt_list); >- spin_unlock_bh(&vsock->send_pkt_list_lock); >+ virtio_vsock_skb_queue_head(&vsock->send_pkt_queue, skb); > break; > } > > if (head == vq->num) { >- spin_lock_bh(&vsock->send_pkt_list_lock); >- list_add(&pkt->list, &vsock->send_pkt_list); >- spin_unlock_bh(&vsock->send_pkt_list_lock); >- >+ virtio_vsock_skb_queue_head(&vsock->send_pkt_queue, skb); > /* We cannot finish yet if more buffers snuck in while > * re-enabling notify. > */ >@@ -153,26 +145,27 @@ vhost_transport_do_send_pkt(struct vhost_vsock *vsock, > } > > if (out) { >- virtio_transport_free_pkt(pkt); >+ kfree_skb(skb); > vq_err(vq, "Expected 0 output buffers, got %u\n", out); > break; > } > > iov_len = iov_length(&vq->iov[out], in); >- if (iov_len < sizeof(pkt->hdr)) { >- virtio_transport_free_pkt(pkt); >+ if (iov_len < sizeof(*hdr)) { >+ kfree_skb(skb); > vq_err(vq, "Buffer len [%zu] too small\n", iov_len); > break; > } > > iov_iter_init(&iov_iter, READ, &vq->iov[out], in, iov_len); >- payload_len = pkt->len - pkt->off; >+ payload_len = skb->len; >+ hdr = virtio_vsock_hdr(skb); > > /* If the packet is greater than the space available in the > * buffer, we split it using multiple buffers. > */ >- if (payload_len > iov_len - sizeof(pkt->hdr)) { >- payload_len = iov_len - sizeof(pkt->hdr); >+ if (payload_len > iov_len - sizeof(*hdr)) { >+ payload_len = iov_len - sizeof(*hdr); > > /* As we are copying pieces of large packet's buffer to > * small rx buffers, headers of packets in rx queue are >@@ -185,31 +178,30 @@ vhost_transport_do_send_pkt(struct vhost_vsock *vsock, > * bits set. After initialized header will be copied to > * rx buffer, these required bits will be restored. > */ >- if (le32_to_cpu(pkt->hdr.flags) & VIRTIO_VSOCK_SEQ_EOM) { >- pkt->hdr.flags &= ~cpu_to_le32(VIRTIO_VSOCK_SEQ_EOM); >+ if (le32_to_cpu(hdr->flags) & VIRTIO_VSOCK_SEQ_EOM) { >+ hdr->flags &= ~cpu_to_le32(VIRTIO_VSOCK_SEQ_EOM); > flags_to_restore |= VIRTIO_VSOCK_SEQ_EOM; > >- if (le32_to_cpu(pkt->hdr.flags) & VIRTIO_VSOCK_SEQ_EOR) { >- pkt->hdr.flags &= ~cpu_to_le32(VIRTIO_VSOCK_SEQ_EOR); >+ if (le32_to_cpu(hdr->flags) & VIRTIO_VSOCK_SEQ_EOR) { >+ hdr->flags &= ~cpu_to_le32(VIRTIO_VSOCK_SEQ_EOR); > flags_to_restore |= VIRTIO_VSOCK_SEQ_EOR; > } > } > } > > /* Set the correct length in the header */ >- pkt->hdr.len = cpu_to_le32(payload_len); >+ hdr->len = cpu_to_le32(payload_len); > >- nbytes = copy_to_iter(&pkt->hdr, sizeof(pkt->hdr), &iov_iter); >- if (nbytes != sizeof(pkt->hdr)) { >- virtio_transport_free_pkt(pkt); >+ nbytes = copy_to_iter(hdr, sizeof(*hdr), &iov_iter); >+ if (nbytes != sizeof(*hdr)) { >+ kfree_skb(skb); > vq_err(vq, "Faulted on copying pkt hdr\n"); > break; > } > >- nbytes = copy_to_iter(pkt->buf + pkt->off, payload_len, >- &iov_iter); >+ nbytes = copy_to_iter(skb->data, payload_len, &iov_iter); > if (nbytes != payload_len) { >- virtio_transport_free_pkt(pkt); >+ kfree_skb(skb); > vq_err(vq, "Faulted on copying pkt buf\n"); > break; > } >@@ -217,31 +209,28 @@ vhost_transport_do_send_pkt(struct vhost_vsock *vsock, > /* Deliver to monitoring devices all packets that we > * will transmit. > */ >- virtio_transport_deliver_tap_pkt(pkt); >+ virtio_transport_deliver_tap_pkt(skb); > >- vhost_add_used(vq, head, sizeof(pkt->hdr) + payload_len); >+ vhost_add_used(vq, head, sizeof(*hdr) + payload_len); > added = true; > >- pkt->off += payload_len; >+ skb_pull(skb, payload_len); > total_len += payload_len; > > /* If we didn't send all the payload we can requeue the packet > * to send it with the next available buffer. > */ >- if (pkt->off < pkt->len) { >- pkt->hdr.flags |= cpu_to_le32(flags_to_restore); >+ if (skb->len > 0) { >+ hdr->flags |= cpu_to_le32(flags_to_restore); > >- /* We are queueing the same virtio_vsock_pkt to handle >+ /* We are queueing the same skb to handle > * the remaining bytes, and we want to deliver it > * to monitoring devices in the next iteration. > */ >- pkt->tap_delivered = false; >- >- spin_lock_bh(&vsock->send_pkt_list_lock); >- list_add(&pkt->list, &vsock->send_pkt_list); >- spin_unlock_bh(&vsock->send_pkt_list_lock); >+ virtio_vsock_skb_clear_tap_delivered(skb); >+ virtio_vsock_skb_queue_head(&vsock->send_pkt_queue, skb); > } else { >- if (pkt->reply) { >+ if (virtio_vsock_skb_reply(skb)) { > int val; > > val = atomic_dec_return(&vsock->queued_replies); >@@ -253,7 +242,7 @@ vhost_transport_do_send_pkt(struct vhost_vsock *vsock, > restart_tx = true; > } > >- virtio_transport_free_pkt(pkt); >+ consume_skb(skb); > } > } while(likely(!vhost_exceeds_weight(vq, ++pkts, total_len))); > if (added) >@@ -278,28 +267,26 @@ static void vhost_transport_send_pkt_work(struct vhost_work *work) > } > > static int >-vhost_transport_send_pkt(struct virtio_vsock_pkt *pkt) >+vhost_transport_send_pkt(struct sk_buff *skb) > { >+ struct virtio_vsock_hdr *hdr = virtio_vsock_hdr(skb); > struct vhost_vsock *vsock; >- int len = pkt->len; >+ int len = skb->len; > > rcu_read_lock(); > > /* Find the vhost_vsock according to guest context id */ >- vsock = vhost_vsock_get(le64_to_cpu(pkt->hdr.dst_cid)); >+ vsock = vhost_vsock_get(le64_to_cpu(hdr->dst_cid)); > if (!vsock) { > rcu_read_unlock(); >- virtio_transport_free_pkt(pkt); >+ kfree_skb(skb); > return -ENODEV; > } > >- if (pkt->reply) >+ if (virtio_vsock_skb_reply(skb)) > atomic_inc(&vsock->queued_replies); > >- spin_lock_bh(&vsock->send_pkt_list_lock); >- list_add_tail(&pkt->list, &vsock->send_pkt_list); >- spin_unlock_bh(&vsock->send_pkt_list_lock); >- >+ virtio_vsock_skb_queue_tail(&vsock->send_pkt_queue, skb); > vhost_work_queue(&vsock->dev, &vsock->send_pkt_work); > > rcu_read_unlock(); >@@ -310,10 +297,8 @@ static int > vhost_transport_cancel_pkt(struct vsock_sock *vsk) > { > struct vhost_vsock *vsock; >- struct virtio_vsock_pkt *pkt, *n; > int cnt = 0; > int ret = -ENODEV; >- LIST_HEAD(freeme); > > rcu_read_lock(); > >@@ -322,20 +307,7 @@ vhost_transport_cancel_pkt(struct vsock_sock *vsk) > if (!vsock) > goto out; > >- spin_lock_bh(&vsock->send_pkt_list_lock); >- list_for_each_entry_safe(pkt, n, &vsock->send_pkt_list, list) { >- if (pkt->vsk != vsk) >- continue; >- list_move(&pkt->list, &freeme); >- } >- spin_unlock_bh(&vsock->send_pkt_list_lock); >- >- list_for_each_entry_safe(pkt, n, &freeme, list) { >- if (pkt->reply) >- cnt++; >- list_del(&pkt->list); >- virtio_transport_free_pkt(pkt); >- } >+ cnt = virtio_transport_purge_skbs(vsk, &vsock->send_pkt_queue); > > if (cnt) { > struct vhost_virtqueue *tx_vq = &vsock->vqs[VSOCK_VQ_TX]; >@@ -352,12 +324,14 @@ vhost_transport_cancel_pkt(struct vsock_sock *vsk) > return ret; > } > >-static struct virtio_vsock_pkt * >-vhost_vsock_alloc_pkt(struct vhost_virtqueue *vq, >+static struct sk_buff * >+vhost_vsock_alloc_skb(struct vhost_virtqueue *vq, > unsigned int out, unsigned int in) > { >- struct virtio_vsock_pkt *pkt; >+ struct virtio_vsock_hdr *hdr; > struct iov_iter iov_iter; >+ struct sk_buff *skb; >+ size_t payload_len; > size_t nbytes; > size_t len; > >@@ -366,50 +340,47 @@ vhost_vsock_alloc_pkt(struct vhost_virtqueue *vq, > return NULL; > } > >- pkt = kzalloc(sizeof(*pkt), GFP_KERNEL); >- if (!pkt) >+ len = iov_length(vq->iov, out); >+ >+ /* len contains both payload and hdr */ >+ skb = virtio_vsock_alloc_skb(len, GFP_KERNEL); >+ if (!skb) > return NULL; > >- len = iov_length(vq->iov, out); > iov_iter_init(&iov_iter, WRITE, vq->iov, out, len); > >- nbytes = copy_from_iter(&pkt->hdr, sizeof(pkt->hdr), &iov_iter); >- if (nbytes != sizeof(pkt->hdr)) { >+ hdr = virtio_vsock_hdr(skb); >+ nbytes = copy_from_iter(hdr, sizeof(*hdr), &iov_iter); >+ if (nbytes != sizeof(*hdr)) { > vq_err(vq, "Expected %zu bytes for pkt->hdr, got %zu bytes\n", >- sizeof(pkt->hdr), nbytes); >- kfree(pkt); >+ sizeof(*hdr), nbytes); >+ kfree_skb(skb); > return NULL; > } > >- pkt->len = le32_to_cpu(pkt->hdr.len); >+ payload_len = le32_to_cpu(hdr->len); > > /* No payload */ >- if (!pkt->len) >- return pkt; >+ if (!payload_len) >+ return skb; > > /* The pkt is too big */ >- if (pkt->len > VIRTIO_VSOCK_MAX_PKT_BUF_SIZE) { >- kfree(pkt); >+ if (payload_len > VIRTIO_VSOCK_MAX_PKT_BUF_SIZE) { >+ kfree_skb(skb); > return NULL; > } > >- pkt->buf = kvmalloc(pkt->len, GFP_KERNEL); >- if (!pkt->buf) { >- kfree(pkt); >- return NULL; >- } >+ virtio_vsock_skb_rx_put(skb); > >- pkt->buf_len = pkt->len; >- >- nbytes = copy_from_iter(pkt->buf, pkt->len, &iov_iter); >- if (nbytes != pkt->len) { >- vq_err(vq, "Expected %u byte payload, got %zu bytes\n", >- pkt->len, nbytes); >- virtio_transport_free_pkt(pkt); >+ nbytes = copy_from_iter(skb->data, payload_len, &iov_iter); >+ if (nbytes != payload_len) { >+ vq_err(vq, "Expected %zu byte payload, got %zu bytes\n", >+ payload_len, nbytes); >+ kfree_skb(skb); > return NULL; > } > >- return pkt; >+ return skb; > } > > /* Is there space left for replies to rx packets? */ >@@ -496,9 +467,9 @@ static void vhost_vsock_handle_tx_kick(struct vhost_work *work) > poll.work); > struct vhost_vsock *vsock = container_of(vq->dev, struct vhost_vsock, > dev); >- struct virtio_vsock_pkt *pkt; > int head, pkts = 0, total_len = 0; > unsigned int out, in; >+ struct sk_buff *skb; > bool added = false; > > mutex_lock(&vq->mutex); >@@ -511,6 +482,8 @@ static void vhost_vsock_handle_tx_kick(struct vhost_work *work) > > vhost_disable_notify(&vsock->dev, vq); > do { >+ struct virtio_vsock_hdr *hdr; >+ > if (!vhost_vsock_more_replies(vsock)) { > /* Stop tx until the device processes already > * pending replies. Leave tx virtqueue >@@ -532,24 +505,26 @@ static void vhost_vsock_handle_tx_kick(struct vhost_work *work) > break; > } > >- pkt = vhost_vsock_alloc_pkt(vq, out, in); >- if (!pkt) { >+ skb = vhost_vsock_alloc_skb(vq, out, in); >+ if (!skb) { > vq_err(vq, "Faulted on pkt\n"); > continue; > } > >- total_len += sizeof(pkt->hdr) + pkt->len; >+ total_len += sizeof(*hdr) + skb->len; > > /* Deliver to monitoring devices all received packets */ >- virtio_transport_deliver_tap_pkt(pkt); >+ virtio_transport_deliver_tap_pkt(skb); >+ >+ hdr = virtio_vsock_hdr(skb); > > /* Only accept correctly addressed packets */ >- if (le64_to_cpu(pkt->hdr.src_cid) == vsock->guest_cid && >- le64_to_cpu(pkt->hdr.dst_cid) == >+ if (le64_to_cpu(hdr->src_cid) == vsock->guest_cid && >+ le64_to_cpu(hdr->dst_cid) == > vhost_transport_get_local_cid()) >- virtio_transport_recv_pkt(&vhost_transport, pkt); >+ virtio_transport_recv_pkt(&vhost_transport, skb); > else >- virtio_transport_free_pkt(pkt); >+ kfree_skb(skb); > > vhost_add_used(vq, head, 0); > added = true; >@@ -693,8 +668,7 @@ static int vhost_vsock_dev_open(struct inode *inode, struct file *file) > VHOST_VSOCK_WEIGHT, true, NULL); > > file->private_data = vsock; >- spin_lock_init(&vsock->send_pkt_list_lock); >- INIT_LIST_HEAD(&vsock->send_pkt_list); >+ skb_queue_head_init(&vsock->send_pkt_queue); > vhost_work_init(&vsock->send_pkt_work, vhost_transport_send_pkt_work); > return 0; > >@@ -760,16 +734,7 @@ static int vhost_vsock_dev_release(struct inode *inode, struct file *file) > vhost_vsock_flush(vsock); > vhost_dev_stop(&vsock->dev); > >- spin_lock_bh(&vsock->send_pkt_list_lock); >- while (!list_empty(&vsock->send_pkt_list)) { >- struct virtio_vsock_pkt *pkt; >- >- pkt = list_first_entry(&vsock->send_pkt_list, >- struct virtio_vsock_pkt, list); >- list_del_init(&pkt->list); >- virtio_transport_free_pkt(pkt); >- } >- spin_unlock_bh(&vsock->send_pkt_list_lock); >+ virtio_vsock_skb_queue_purge(&vsock->send_pkt_queue); > > vhost_dev_cleanup(&vsock->dev); > kfree(vsock->dev.vqs); >diff --git a/include/linux/virtio_vsock.h b/include/linux/virtio_vsock.h >index 35d7eedb5e8e..7ed943615271 100644 >--- a/include/linux/virtio_vsock.h >+++ b/include/linux/virtio_vsock.h >@@ -7,6 +7,106 @@ > #include <net/sock.h> > #include <net/af_vsock.h> > >+#define VIRTIO_VSOCK_SKB_HEADROOM (sizeof(struct virtio_vsock_hdr)) >+ >+struct virtio_vsock_skb_cb { >+ bool reply; >+ bool tap_delivered; >+}; >+ >+#define VIRTIO_VSOCK_SKB_CB(skb) ((struct virtio_vsock_skb_cb *)((skb)->cb)) >+ >+static inline struct virtio_vsock_hdr *virtio_vsock_hdr(struct sk_buff *skb) >+{ >+ return (struct virtio_vsock_hdr *)skb->head; >+} >+ >+static inline bool virtio_vsock_skb_reply(struct sk_buff *skb) >+{ >+ return VIRTIO_VSOCK_SKB_CB(skb)->reply; >+} >+ >+static inline void virtio_vsock_skb_set_reply(struct sk_buff *skb) >+{ >+ VIRTIO_VSOCK_SKB_CB(skb)->reply = true; >+} >+ >+static inline bool virtio_vsock_skb_tap_delivered(struct sk_buff *skb) >+{ >+ return VIRTIO_VSOCK_SKB_CB(skb)->tap_delivered; >+} >+ >+static inline void virtio_vsock_skb_set_tap_delivered(struct sk_buff *skb) >+{ >+ VIRTIO_VSOCK_SKB_CB(skb)->tap_delivered = true; >+} >+ >+static inline void virtio_vsock_skb_clear_tap_delivered(struct sk_buff *skb) >+{ >+ VIRTIO_VSOCK_SKB_CB(skb)->tap_delivered = false; >+} Maybe, we can have a single virtio_vsock_skb_set_tap_delivered(struct sk_buff *skb, bool tap_delivered) to be used in both cases. Anyway, I don't have a strong opinion on that. Thanks, Stefano
Powered by blists - more mailing lists