1
/*********************************************************
2
* Copyright (C) 2009 VMware, Inc. All rights reserved.
4
* This program is free software; you can redistribute it and/or modify it
5
* under the terms of the GNU General Public License as published by the
6
* Free Software Foundation version 2 and no later version.
8
* This program is distributed in the hope that it will be useful, but
9
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
10
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13
* You should have received a copy of the GNU General Public License along
14
* with this program; if not, write to the Free Software Foundation, Inc.,
15
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17
*********************************************************/
22
* Linux control notifications for the VMCI Stream Sockets protocol.
26
#include "driver-config.h"
28
#include <linux/socket.h>
30
#include "compat_sock.h"
35
#define PKT_FIELD(vsk, fieldName) \
36
(vsk)->notify.fieldName
38
#define VSOCK_MAX_DGRAM_RESENDS 10
42
*----------------------------------------------------------------------------
44
* VSockVmciNotifyWaitingWrite --
46
* Determines if the conditions have been met to notify a waiting writer.
49
* TRUE if a notification should be sent, FALSE otherwise.
54
*----------------------------------------------------------------------------
58
VSockVmciNotifyWaitingWrite(VSockVmciSock *vsk) // IN
60
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
64
if (!PKT_FIELD(vsk, peerWaitingWrite)) {
68
#ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
70
* When the sender blocks, we take that as a sign that the sender
71
* is faster than the receiver. To reduce the transmit rate of the
72
* sender, we delay the sending of the read notification by
73
* decreasing the writeNotifyWindow. The notification is delayed
74
* until the number of bytes used in the queue drops below the
78
if (!PKT_FIELD(vsk, peerWaitingWriteDetected)) {
79
PKT_FIELD(vsk, peerWaitingWriteDetected) = TRUE;
80
PKT_FIELD(vsk, writeNotifyWindow) -= PAGE_SIZE;
81
if (PKT_FIELD(vsk, writeNotifyWindow) <
82
PKT_FIELD(vsk, writeNotifyMinWindow)) {
83
PKT_FIELD(vsk, writeNotifyWindow) =
84
PKT_FIELD(vsk, writeNotifyMinWindow);
87
notifyLimit = vsk->consumeSize - PKT_FIELD(vsk, writeNotifyWindow);
90
#endif // VSOCK_OPTIMIZATION_FLOW_CONTROL
93
* For now we ignore the wait information and just see if the free
94
* space exceeds the notify limit. Note that improving this
95
* function to be more intelligent will not require a protocol
96
* change and will retain compatibility between endpoints with
97
* mixed versions of this function.
99
* The notifyLimit is used to delay notifications in the case where
100
* flow control is enabled. Below the test is expressed in terms of
101
* free space in the queue:
102
* if freeSpace > ConsumeSize - writeNotifyWindow then notify
103
* An alternate way of expressing this is to rewrite the expression
104
* to use the data ready in the receive queue:
105
* if writeNotifyWindow > bufferReady then notify
106
* as freeSpace == ConsumeSize - bufferReady.
108
retval = VMCIQueue_FreeSpace(vsk->consumeQ, vsk->produceQ, vsk->consumeSize) >
110
#ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
113
* Once we notify the peer, we reset the detected flag so the
114
* next wait will again cause a decrease in the window size.
117
PKT_FIELD(vsk, peerWaitingWriteDetected) = FALSE;
119
#endif // VSOCK_OPTIMIZATION_FLOW_CONTROL
128
*----------------------------------------------------------------------------
130
* VSockVmciNotifyWaitingRead --
132
v * Determines if the conditions have been met to notify a waiting reader.
135
* TRUE if a notification should be sent, FALSE otherwise.
140
*----------------------------------------------------------------------------
144
VSockVmciNotifyWaitingRead(VSockVmciSock *vsk) // IN
146
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
147
if (!PKT_FIELD(vsk, peerWaitingRead)) {
152
* For now we ignore the wait information and just see if there is any data
153
* for our peer to read. Note that improving this function to be more intelligent will
154
* not require a protocol change and will retain compatibility between
155
* endpoints with mixed versions of this function.
157
return VMCIQueue_BufReady(vsk->produceQ,
158
vsk->consumeQ, vsk->produceSize) > 0;
166
*----------------------------------------------------------------------------
168
* VSockVmciHandleWaitingRead --
170
* Handles an incoming waiting read message.
176
* May send a notification to the peer, may update socket's wait info
179
*----------------------------------------------------------------------------
183
VSockVmciHandleWaitingRead(struct sock *sk, // IN
184
VSockPacket *pkt, // IN
185
Bool bottomHalf, // IN
186
struct sockaddr_vm *dst, // IN
187
struct sockaddr_vm *src) // IN
189
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
194
PKT_FIELD(vsk, peerWaitingRead) = TRUE;
195
memcpy(&PKT_FIELD(vsk, peerWaitingReadInfo), &pkt->u.wait,
196
sizeof PKT_FIELD(vsk, peerWaitingReadInfo));
198
if (VSockVmciNotifyWaitingRead(vsk)) {
202
sent = VSOCK_SEND_WROTE_BH(dst, src) > 0;
204
sent = VSOCK_SEND_WROTE(sk) > 0;
208
PKT_FIELD(vsk, peerWaitingRead) = FALSE;
216
*----------------------------------------------------------------------------
218
* VSockVmciHandleWaitingWrite --
220
* Handles an incoming waiting write message.
226
* May send a notification to the peer, may update socket's wait info
229
*----------------------------------------------------------------------------
233
VSockVmciHandleWaitingWrite(struct sock *sk, // IN
234
VSockPacket *pkt, // IN
235
Bool bottomHalf, // IN
236
struct sockaddr_vm *dst, // IN
237
struct sockaddr_vm *src) // IN
239
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
244
PKT_FIELD(vsk, peerWaitingWrite) = TRUE;
245
memcpy(&PKT_FIELD(vsk, peerWaitingWriteInfo), &pkt->u.wait,
246
sizeof PKT_FIELD(vsk,peerWaitingWriteInfo));
248
if (VSockVmciNotifyWaitingWrite(vsk)) {
252
sent = VSOCK_SEND_READ_BH(dst, src) > 0;
254
sent = VSOCK_SEND_READ(sk) > 0;
258
PKT_FIELD(vsk, peerWaitingWrite) = FALSE;
266
*----------------------------------------------------------------------------
268
* VSockVmciHandleRead --
270
* Handles an incoming read message.
278
*----------------------------------------------------------------------------
282
VSockVmciHandleRead(struct sock *sk, // IN
283
VSockPacket *pkt, // IN: unused
284
Bool bottomHalf, // IN: unused
285
struct sockaddr_vm *dst, // IN: unused
286
struct sockaddr_vm *src) // IN: unused
288
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
292
PKT_FIELD(vsk, sentWaitingWrite) = FALSE;
295
sk->compat_sk_write_space(sk);
300
*----------------------------------------------------------------------------
302
* VSockVmciSendWaitingRead --
304
* Sends a waiting read notification to this socket's peer.
307
* TRUE if the datagram is sent successfully, FALSE otherwise.
310
* Our peer will notify us when there is data to read from our consume
313
*----------------------------------------------------------------------------
317
VSockVmciSendWaitingRead(struct sock *sk, // IN
318
uint64 roomNeeded) // IN
320
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
322
VSockWaitingInfo waitingInfo;
332
if (PKT_FIELD(vsk, sentWaitingRead)) {
336
if (PKT_FIELD(vsk, writeNotifyWindow) < vsk->consumeSize) {
337
PKT_FIELD(vsk, writeNotifyWindow) =
338
MIN(PKT_FIELD(vsk, writeNotifyWindow) + PAGE_SIZE,
342
VMCIQueue_GetPointers(vsk->consumeQ, vsk->produceQ, &tail, &head);
343
roomLeft = vsk->consumeSize - head;
344
if (roomNeeded >= roomLeft) {
345
waitingInfo.offset = roomNeeded - roomLeft;
346
waitingInfo.generation = PKT_FIELD(vsk, consumeQGeneration) + 1;
348
waitingInfo.offset = head + roomNeeded;
349
waitingInfo.generation = PKT_FIELD(vsk, consumeQGeneration);
352
ret = VSOCK_SEND_WAITING_READ(sk, &waitingInfo) > 0;
354
PKT_FIELD(vsk, sentWaitingRead) = TRUE;
364
*----------------------------------------------------------------------------
366
* VSockVmciSendWaitingWrite --
368
* Sends a waiting write notification to this socket's peer.
371
* TRUE if the datagram is sent successfully or does not need to be sent.
375
* Our peer will notify us when there is room to write in to our produce
378
*----------------------------------------------------------------------------
382
VSockVmciSendWaitingWrite(struct sock *sk, // IN
383
uint64 roomNeeded) // IN
385
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
387
VSockWaitingInfo waitingInfo;
397
if (PKT_FIELD(vsk, sentWaitingWrite)) {
401
VMCIQueue_GetPointers(vsk->produceQ, vsk->consumeQ, &tail, &head);
402
roomLeft = vsk->produceSize - tail;
403
if (roomNeeded + 1 >= roomLeft) {
404
/* Wraps around to current generation. */
405
waitingInfo.offset = roomNeeded + 1 - roomLeft;
406
waitingInfo.generation = PKT_FIELD(vsk, produceQGeneration);
408
waitingInfo.offset = tail + roomNeeded + 1;
409
waitingInfo.generation = PKT_FIELD(vsk, produceQGeneration) - 1;
412
ret = VSOCK_SEND_WAITING_WRITE(sk, &waitingInfo) > 0;
414
PKT_FIELD(vsk, sentWaitingWrite) = TRUE;
424
*----------------------------------------------------------------------------
426
* VSockVmciSendReadNotification --
428
* Sends a read notification to this socket's peer.
431
* >= 0 if the datagram is sent successfully, negative error value
437
*----------------------------------------------------------------------------
441
VSockVmciSendReadNotification(struct sock *sk) // IN
445
unsigned int retries;
455
if (VSockVmciNotifyWaitingWrite(vsk)) {
457
* Notify the peer that we have read, retrying the send on failure up to our
458
* maximum value. XXX For now we just log the failure, but later we should
459
* schedule a work item to handle the resend until it succeeds. That would
460
* require keeping track of work items in the vsk and cleaning them up upon
463
while (!(vsk->peerShutdown & RCV_SHUTDOWN) &&
465
retries < VSOCK_MAX_DGRAM_RESENDS) {
466
err = VSOCK_SEND_READ(sk);
474
if (retries >= VSOCK_MAX_DGRAM_RESENDS) {
475
Warning("unable to send read notification to peer for socket %p.\n", sk);
477
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
478
PKT_FIELD(vsk, peerWaitingWrite) = FALSE;
487
*----------------------------------------------------------------------------
489
* VSockVmciHandleWrote --
491
* Handles an incoming wrote message.
499
*----------------------------------------------------------------------------
503
VSockVmciHandleWrote(struct sock *sk, // IN
504
VSockPacket *pkt, // IN: unused
505
Bool bottomHalf, // IN: unused
506
struct sockaddr_vm *dst, // IN: unused
507
struct sockaddr_vm *src) // IN: unused
509
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
513
PKT_FIELD(vsk, sentWaitingRead) = FALSE;
516
sk->compat_sk_data_ready(sk, 0);
521
*----------------------------------------------------------------------------
523
* VSockVmciNotifyPktSocketInit --
525
* Function that is called after a socket is created and before any
526
* notify ops are used.
534
*----------------------------------------------------------------------------
538
VSockVmciNotifyPktSocketInit(struct sock *sk) // IN
543
PKT_FIELD(vsk, writeNotifyWindow) = 0;
544
PKT_FIELD(vsk, writeNotifyMinWindow) = PAGE_SIZE;
545
PKT_FIELD(vsk, peerWaitingRead) = FALSE;
546
PKT_FIELD(vsk, peerWaitingWrite) = FALSE;
547
PKT_FIELD(vsk, peerWaitingWriteDetected) = FALSE;
548
PKT_FIELD(vsk, sentWaitingRead) = FALSE;
549
PKT_FIELD(vsk, sentWaitingWrite) = FALSE;
550
PKT_FIELD(vsk, produceQGeneration) = 0;
551
PKT_FIELD(vsk, consumeQGeneration) = 0;
553
memset(&PKT_FIELD(vsk, peerWaitingReadInfo), 0,
554
sizeof PKT_FIELD(vsk, peerWaitingReadInfo));
555
memset(&PKT_FIELD(vsk, peerWaitingWriteInfo), 0,
556
sizeof PKT_FIELD(vsk, peerWaitingWriteInfo));
561
*----------------------------------------------------------------------------
563
* VSockVmciNotifyPktSocketDestruct --
565
* Function that is called when the socket is being released.
573
*----------------------------------------------------------------------------
577
VSockVmciNotifyPktSocketDestruct(struct sock *sk) // IN
584
*----------------------------------------------------------------------------
586
* VSockVmciNotifyPktPollIn --
588
* Called by the poll function to figure out if there is data to read
589
* and to setup future notifications if needed. Only called on sockets
590
* that aren't shutdown for recv.
593
* 0 on success. Negative error on failure.
598
*----------------------------------------------------------------------------
602
VSockVmciNotifyPktPollIn(struct sock *sk, // IN
604
Bool *dataReadyNow) // IN
609
ASSERT(dataReadyNow);
613
if (VSockVmciStreamHasData(vsk)) {
614
*dataReadyNow = TRUE;
617
* We can't read right now because there is nothing in the queue.
618
* Ask for notifications when there is something to read.
620
if (sk->compat_sk_state == SS_CONNECTED) {
621
if (!VSockVmciSendWaitingRead(sk, 1)) {
625
*dataReadyNow = FALSE;
633
*----------------------------------------------------------------------------
635
* VSockVmciNotifyPktPollOut
637
* Called by the poll function to figure out if there is space to write
638
* and to setup future notifications if needed. Only called on a
639
* connected socket that isn't shutdown for send.
642
* 0 on success. Negative error on failure.
647
*----------------------------------------------------------------------------
651
VSockVmciNotifyPktPollOut(struct sock *sk, // IN
653
Bool *spaceAvailNow) // IN
655
int64 produceQFreeSpace;
659
ASSERT(spaceAvailNow);
664
VSockVmciStreamHasSpace(vsk);
665
if (produceQFreeSpace > 0) {
666
*spaceAvailNow = TRUE;
668
} else if (produceQFreeSpace == 0) {
670
* This is a connected socket but we can't currently send data. Notify
671
* the peer that we are waiting if the queue is full.
672
* We only send a waiting write if the queue is full because otherwise
673
* we end up in an infinite WAITING_WRITE, READ, WAITING_WRITE, READ, etc.
674
* loop. Treat failing to send the notification as a socket error, passing
675
* that back through the mask.
677
if (!VSockVmciSendWaitingWrite(sk, 1)) {
680
*spaceAvailNow = FALSE;
688
*----------------------------------------------------------------------------
690
* VSockVmciNotifyPktRecvInit --
692
* Called at the start of a stream recv call with the socket lock held.
695
* 0 on success. Negative error on failure.
700
*----------------------------------------------------------------------------
704
VSockVmciNotifyPktRecvInit(struct sock *sk, // IN
706
VSockVmciRecvNotifyData *data) // IN
715
#ifdef VSOCK_OPTIMIZATION_WAITING_NOTIFY
716
data->consumeHead = 0;
717
data->produceTail = 0;
718
#ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
719
data->notifyOnBlock = FALSE;
721
if (PKT_FIELD(vsk, writeNotifyMinWindow) < target + 1) {
722
ASSERT(target < vsk->consumeSize);
723
PKT_FIELD(vsk, writeNotifyMinWindow) = target + 1;
724
if (PKT_FIELD(vsk, writeNotifyWindow) <
725
PKT_FIELD(vsk, writeNotifyMinWindow)) {
727
* If the current window is smaller than the new minimal
728
* window size, we need to reevaluate whether we need to
729
* notify the sender. If the number of ready bytes are
730
* smaller than the new window, we need to send a
731
* notification to the sender before we block.
734
PKT_FIELD(vsk, writeNotifyWindow) =
735
PKT_FIELD(vsk, writeNotifyMinWindow);
736
data->notifyOnBlock = TRUE;
747
*----------------------------------------------------------------------------
749
* VSockVmciNotifyPktRecvPreBlock --
751
* Called right before a socket is about to block with the socket lock
752
* held. The socket lock may have been released between the entry
753
* function and the preblock call.
755
* Note: This function may be called multiple times before the post
756
* block function is called.
759
* 0 on success. Negative error on failure.
764
*----------------------------------------------------------------------------
768
VSockVmciNotifyPktRecvPreBlock(struct sock *sk, // IN
770
VSockVmciRecvNotifyData *data) // IN
781
/* Notify our peer that we are waiting for data to read. */
782
if (!VSockVmciSendWaitingRead(sk, target)) {
787
#ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
788
if (data->notifyOnBlock) {
789
err = VSockVmciSendReadNotification(sk);
793
data->notifyOnBlock = FALSE;
802
*----------------------------------------------------------------------------
804
* VSockVmciNotifyPktRecvPreDequeue --
806
* Called right before we dequeue / peek data from a socket.
809
* 0 on success. Negative error on failure.
814
*----------------------------------------------------------------------------
818
VSockVmciNotifyPktRecvPreDequeue(struct sock *sk, // IN
820
VSockVmciRecvNotifyData *data) // IN
830
* Now consume up to len bytes from the queue. Note that since we have the
831
* socket locked we should copy at least ready bytes.
833
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
834
VMCIQueue_GetPointers(vsk->consumeQ, vsk->produceQ,
835
&data->produceTail, &data->consumeHead);
843
*----------------------------------------------------------------------------
845
* VSockVmciNotifyPktRecvPostDequeue --
847
* Called right after we dequeue / peek data from a socket.
850
* 0 on success. Negative error on failure.
855
*----------------------------------------------------------------------------
859
VSockVmciNotifyPktRecvPostDequeue(struct sock *sk, // IN
861
ssize_t copied, // IN
863
VSockVmciRecvNotifyData *data) // IN
875
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
877
* Detect a wrap-around to maintain queue generation. Note that this is
878
* safe since we hold the socket lock across the two queue pair
881
if (copied >= vsk->consumeSize - data->consumeHead) {
882
PKT_FIELD(vsk, consumeQGeneration)++;
886
err = VSockVmciSendReadNotification(sk);
897
*----------------------------------------------------------------------------
899
* VSockVmciNotifyPktSendInit --
901
* Called at the start of a stream send call with the socket lock held.
904
* 0 on success. A negative error code on failure.
908
*----------------------------------------------------------------------------
912
VSockVmciNotifyPktSendInit(struct sock *sk, // IN
913
VSockVmciSendNotifyData *data) // IN
918
#ifdef VSOCK_OPTIMIZATION_WAITING_NOTIFY
919
data->consumeHead = 0;
920
data->produceTail = 0;
928
*----------------------------------------------------------------------------
930
* VSockVmciNotifyPktSendPreBlock --
932
* Called right before a socket is about to block with the socket lock
933
* held. The socket lock may have been released between the entry
934
* function and the preblock call.
936
* Note: This function may be called multiple times before the post
937
* block function is called.
940
* 0 on success. A negative error code on failure.
945
*----------------------------------------------------------------------------
949
VSockVmciNotifyPktSendPreBlock(struct sock *sk, // IN
950
VSockVmciSendNotifyData *data) // IN
955
/* Notify our peer that we are waiting for room to write. */
956
if (!VSockVmciSendWaitingWrite(sk, 1)) {
957
return -EHOSTUNREACH;
965
*----------------------------------------------------------------------------
967
* VSockVmciNotifySendPreEnqueue --
969
* Called right before we Enqueue to a socket.
972
* 0 on success. Negative error on failure.
977
*----------------------------------------------------------------------------
981
VSockVmciNotifyPktSendPreEnqueue(struct sock *sk, // IN
982
VSockVmciSendNotifyData *data) // IN
991
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
992
VMCIQueue_GetPointers(vsk->produceQ, vsk->consumeQ,
993
&data->produceTail, &data->consumeHead);
1001
*----------------------------------------------------------------------------
1003
* VSockVmciNotifySendPostEnqueue --
1005
* Called right after we enqueue data to a socket.
1008
* 0 on success. Negative error on failure.
1013
*----------------------------------------------------------------------------
1017
VSockVmciNotifyPktSendPostEnqueue(struct sock *sk, // IN
1018
ssize_t written, // IN
1019
VSockVmciSendNotifyData *data) // IN
1023
Bool sentWrote = FALSE;
1031
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
1033
* Detect a wrap-around to maintain queue generation. Note that this is
1034
* safe since we hold the socket lock across the two queue pair
1037
if (written >= vsk->produceSize - data->produceTail) {
1038
PKT_FIELD(vsk, produceQGeneration)++;
1042
if (VSockVmciNotifyWaitingRead(vsk)) {
1044
* Notify the peer that we have written, retrying the send on failure up to
1045
* our maximum value. See the XXX comment for the corresponding piece of
1046
* code in StreamRecvmsg() for potential improvements.
1048
while (!(vsk->peerShutdown & RCV_SHUTDOWN) &&
1050
retries < VSOCK_MAX_DGRAM_RESENDS) {
1051
err = VSOCK_SEND_WROTE(sk);
1059
if (retries >= VSOCK_MAX_DGRAM_RESENDS) {
1060
Warning("unable to send wrote notification to peer for socket %p.\n", sk);
1063
#if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
1064
PKT_FIELD(vsk, peerWaitingRead) = FALSE;
1073
*----------------------------------------------------------------------------
1075
* VSockVmciNotifyPktHandlePkt
1077
* Called when a notify packet is recieved for a socket in the connected
1078
* state. Note this might be called from a bottom half.
1086
*----------------------------------------------------------------------------
1090
VSockVmciNotifyPktHandlePkt(struct sock *sk, // IN
1091
VSockPacket *pkt, // IN
1092
Bool bottomHalf, // IN
1093
struct sockaddr_vm *dst, // IN
1094
struct sockaddr_vm *src, // IN
1095
Bool *pktProcessed) // In
1097
Bool processed = FALSE;
1102
switch (pkt->type) {
1103
case VSOCK_PACKET_TYPE_WROTE:
1104
VSockVmciHandleWrote(sk, pkt, bottomHalf, dst, src);
1107
case VSOCK_PACKET_TYPE_READ:
1108
VSockVmciHandleRead(sk, pkt, bottomHalf, dst, src);
1111
case VSOCK_PACKET_TYPE_WAITING_WRITE:
1112
VSockVmciHandleWaitingWrite(sk, pkt, bottomHalf, dst, src);
1116
case VSOCK_PACKET_TYPE_WAITING_READ:
1117
VSockVmciHandleWaitingRead(sk, pkt, bottomHalf, dst, src);
1123
*pktProcessed = processed;
1127
/* Socket control packet based operations. */
1128
VSockVmciNotifyOps vSockVmciNotifyPktOps = {
1129
VSockVmciNotifyPktSocketInit,
1130
VSockVmciNotifyPktSocketDestruct,
1131
VSockVmciNotifyPktPollIn,
1132
VSockVmciNotifyPktPollOut,
1133
VSockVmciNotifyPktHandlePkt,
1134
VSockVmciNotifyPktRecvInit,
1135
VSockVmciNotifyPktRecvPreBlock,
1136
VSockVmciNotifyPktRecvPreDequeue,
1137
VSockVmciNotifyPktRecvPostDequeue,
1138
VSockVmciNotifyPktSendInit,
1139
VSockVmciNotifyPktSendPreBlock,
1140
VSockVmciNotifyPktSendPreEnqueue,
1141
VSockVmciNotifyPktSendPostEnqueue
added
removed
modules/linux/vsock/linux/notify.c
