net/vmw_vsock/vmci_transport_notify.c

   1 /*
   2  * VMware vSockets Driver
   3  *
   4  * Copyright (C) 2009-2013 VMware, Inc. All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation version 2 and no later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  */
  15
  16 #include <linux/types.h>
  17 #include <linux/socket.h>
  18 #include <linux/stddef.h>
  19 #include <net/sock.h>
  20
  21 #include "vmci_transport_notify.h"
  22
  23 #define PKT_FIELD(vsk, field_name) (vmci_trans(vsk)->notify.pkt.field_name)
  24
  25 static bool vmci_transport_notify_waiting_write(struct vsock_sock *vsk)
  26 {
  27 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
  28         bool retval;
  29         u64 notify_limit;
  30
  31         if (!PKT_FIELD(vsk, peer_waiting_write))
  32                 return false;
  33
  34 #ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
  35         /* When the sender blocks, we take that as a sign that the sender is
  36          * faster than the receiver. To reduce the transmit rate of the sender,
  37          * we delay the sending of the read notification by decreasing the
  38          * write_notify_window. The notification is delayed until the number of
  39          * bytes used in the queue drops below the write_notify_window.
  40          */
  41
  42         if (!PKT_FIELD(vsk, peer_waiting_write_detected)) {
  43                 PKT_FIELD(vsk, peer_waiting_write_detected) = true;
  44                 if (PKT_FIELD(vsk, write_notify_window) < PAGE_SIZE) {
  45                         PKT_FIELD(vsk, write_notify_window) =
  46                             PKT_FIELD(vsk, write_notify_min_window);
  47                 } else {
  48                         PKT_FIELD(vsk, write_notify_window) -= PAGE_SIZE;
  49                         if (PKT_FIELD(vsk, write_notify_window) <
  50                             PKT_FIELD(vsk, write_notify_min_window))
  51                                 PKT_FIELD(vsk, write_notify_window) =
  52                                     PKT_FIELD(vsk, write_notify_min_window);
  53
  54                 }
  55         }
  56         notify_limit = vmci_trans(vsk)->consume_size -
  57                 PKT_FIELD(vsk, write_notify_window);
  58 #else
  59         notify_limit = 0;
  60 #endif
  61
  62         /* For now we ignore the wait information and just see if the free
  63          * space exceeds the notify limit.  Note that improving this function
  64          * to be more intelligent will not require a protocol change and will
  65          * retain compatibility between endpoints with mixed versions of this
  66          * function.
  67          *
  68          * The notify_limit is used to delay notifications in the case where
  69          * flow control is enabled. Below the test is expressed in terms of
  70          * free space in the queue: if free_space > ConsumeSize -
  71          * write_notify_window then notify An alternate way of expressing this
  72          * is to rewrite the expression to use the data ready in the receive
  73          * queue: if write_notify_window > bufferReady then notify as
  74          * free_space == ConsumeSize - bufferReady.
  75          */
  76         retval = vmci_qpair_consume_free_space(vmci_trans(vsk)->qpair) >
  77                 notify_limit;
  78 #ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
  79         if (retval) {
  80                 /*
  81                  * Once we notify the peer, we reset the detected flag so the
  82                  * next wait will again cause a decrease in the window size.
  83                  */
  84
  85                 PKT_FIELD(vsk, peer_waiting_write_detected) = false;
  86         }
  87 #endif
  88         return retval;
  89 #else
  90         return true;
  91 #endif
  92 }
  93
  94 static bool vmci_transport_notify_waiting_read(struct vsock_sock *vsk)
  95 {
  96 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
  97         if (!PKT_FIELD(vsk, peer_waiting_read))
  98                 return false;
  99
 100         /* For now we ignore the wait information and just see if there is any
 101          * data for our peer to read.  Note that improving this function to be
 102          * more intelligent will not require a protocol change and will retain
 103          * compatibility between endpoints with mixed versions of this
 104          * function.
 105          */
 106         return vmci_qpair_produce_buf_ready(vmci_trans(vsk)->qpair) > 0;
 107 #else
 108         return true;
 109 #endif
 110 }
 111
 112 static void
 113 vmci_transport_handle_waiting_read(struct sock *sk,
 114                                    struct vmci_transport_packet *pkt,
 115                                    bool bottom_half,
 116                                    struct sockaddr_vm *dst,
 117                                    struct sockaddr_vm *src)
 118 {
 119 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 120         struct vsock_sock *vsk;
 121
 122         vsk = vsock_sk(sk);
 123
 124         PKT_FIELD(vsk, peer_waiting_read) = true;
 125         memcpy(&PKT_FIELD(vsk, peer_waiting_read_info), &pkt->u.wait,
 126                sizeof(PKT_FIELD(vsk, peer_waiting_read_info)));
 127
 128         if (vmci_transport_notify_waiting_read(vsk)) {
 129                 bool sent;
 130
 131                 if (bottom_half)
 132                         sent = vmci_transport_send_wrote_bh(dst, src) > 0;
 133                 else
 134                         sent = vmci_transport_send_wrote(sk) > 0;
 135
 136                 if (sent)
 137                         PKT_FIELD(vsk, peer_waiting_read) = false;
 138         }
 139 #endif
 140 }
 141
 142 static void
 143 vmci_transport_handle_waiting_write(struct sock *sk,
 144                                     struct vmci_transport_packet *pkt,
 145                                     bool bottom_half,
 146                                     struct sockaddr_vm *dst,
 147                                     struct sockaddr_vm *src)
 148 {
 149 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 150         struct vsock_sock *vsk;
 151
 152         vsk = vsock_sk(sk);
 153
 154         PKT_FIELD(vsk, peer_waiting_write) = true;
 155         memcpy(&PKT_FIELD(vsk, peer_waiting_write_info), &pkt->u.wait,
 156                sizeof(PKT_FIELD(vsk, peer_waiting_write_info)));
 157
 158         if (vmci_transport_notify_waiting_write(vsk)) {
 159                 bool sent;
 160
 161                 if (bottom_half)
 162                         sent = vmci_transport_send_read_bh(dst, src) > 0;
 163                 else
 164                         sent = vmci_transport_send_read(sk) > 0;
 165
 166                 if (sent)
 167                         PKT_FIELD(vsk, peer_waiting_write) = false;
 168         }
 169 #endif
 170 }
 171
 172 static void
 173 vmci_transport_handle_read(struct sock *sk,
 174                            struct vmci_transport_packet *pkt,
 175                            bool bottom_half,
 176                            struct sockaddr_vm *dst, struct sockaddr_vm *src)
 177 {
 178 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 179         struct vsock_sock *vsk;
 180
 181         vsk = vsock_sk(sk);
 182         PKT_FIELD(vsk, sent_waiting_write) = false;
 183 #endif
 184
 185         sk->sk_write_space(sk);
 186 }
 187
 188 static bool send_waiting_read(struct sock *sk, u64 room_needed)
 189 {
 190 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 191         struct vsock_sock *vsk;
 192         struct vmci_transport_waiting_info waiting_info;
 193         u64 tail;
 194         u64 head;
 195         u64 room_left;
 196         bool ret;
 197
 198         vsk = vsock_sk(sk);
 199
 200         if (PKT_FIELD(vsk, sent_waiting_read))
 201                 return true;
 202
 203         if (PKT_FIELD(vsk, write_notify_window) <
 204                         vmci_trans(vsk)->consume_size)
 205                 PKT_FIELD(vsk, write_notify_window) =
 206                     min(PKT_FIELD(vsk, write_notify_window) + PAGE_SIZE,
 207                         vmci_trans(vsk)->consume_size);
 208
 209         vmci_qpair_get_consume_indexes(vmci_trans(vsk)->qpair, &tail, &head);
 210         room_left = vmci_trans(vsk)->consume_size - head;
 211         if (room_needed >= room_left) {
 212                 waiting_info.offset = room_needed - room_left;
 213                 waiting_info.generation =
 214                     PKT_FIELD(vsk, consume_q_generation) + 1;
 215         } else {
 216                 waiting_info.offset = head + room_needed;
 217                 waiting_info.generation = PKT_FIELD(vsk, consume_q_generation);
 218         }
 219
 220         ret = vmci_transport_send_waiting_read(sk, &waiting_info) > 0;
 221         if (ret)
 222                 PKT_FIELD(vsk, sent_waiting_read) = true;
 223
 224         return ret;
 225 #else
 226         return true;
 227 #endif
 228 }
 229
 230 static bool send_waiting_write(struct sock *sk, u64 room_needed)
 231 {
 232 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 233         struct vsock_sock *vsk;
 234         struct vmci_transport_waiting_info waiting_info;
 235         u64 tail;
 236         u64 head;
 237         u64 room_left;
 238         bool ret;
 239
 240         vsk = vsock_sk(sk);
 241
 242         if (PKT_FIELD(vsk, sent_waiting_write))
 243                 return true;
 244
 245         vmci_qpair_get_produce_indexes(vmci_trans(vsk)->qpair, &tail, &head);
 246         room_left = vmci_trans(vsk)->produce_size - tail;
 247         if (room_needed + 1 >= room_left) {
 248                 /* Wraps around to current generation. */
 249                 waiting_info.offset = room_needed + 1 - room_left;
 250                 waiting_info.generation = PKT_FIELD(vsk, produce_q_generation);
 251         } else {
 252                 waiting_info.offset = tail + room_needed + 1;
 253                 waiting_info.generation =
 254                     PKT_FIELD(vsk, produce_q_generation) - 1;
 255         }
 256
 257         ret = vmci_transport_send_waiting_write(sk, &waiting_info) > 0;
 258         if (ret)
 259                 PKT_FIELD(vsk, sent_waiting_write) = true;
 260
 261         return ret;
 262 #else
 263         return true;
 264 #endif
 265 }
 266
 267 static int vmci_transport_send_read_notification(struct sock *sk)
 268 {
 269         struct vsock_sock *vsk;
 270         bool sent_read;
 271         unsigned int retries;
 272         int err;
 273
 274         vsk = vsock_sk(sk);
 275         sent_read = false;
 276         retries = 0;
 277         err = 0;
 278
 279         if (vmci_transport_notify_waiting_write(vsk)) {
 280                 /* Notify the peer that we have read, retrying the send on
 281                  * failure up to our maximum value.  XXX For now we just log
 282                  * the failure, but later we should schedule a work item to
 283                  * handle the resend until it succeeds.  That would require
 284                  * keeping track of work items in the vsk and cleaning them up
 285                  * upon socket close.
 286                  */
 287                 while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
 288                        !sent_read &&
 289                        retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
 290                         err = vmci_transport_send_read(sk);
 291                         if (err >= 0)
 292                                 sent_read = true;
 293
 294                         retries++;
 295                 }
 296
 297                 if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS)
 298                         pr_err("%p unable to send read notify to peer\n", sk);
 299                 else
 300 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 301                         PKT_FIELD(vsk, peer_waiting_write) = false;
 302 #endif
 303
 304         }
 305         return err;
 306 }
 307
 308 static void
 309 vmci_transport_handle_wrote(struct sock *sk,
 310                             struct vmci_transport_packet *pkt,
 311                             bool bottom_half,
 312                             struct sockaddr_vm *dst, struct sockaddr_vm *src)
 313 {
 314 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 315         struct vsock_sock *vsk = vsock_sk(sk);
 316         PKT_FIELD(vsk, sent_waiting_read) = false;
 317 #endif
 318         sk->sk_data_ready(sk);
 319 }
 320
 321 static void vmci_transport_notify_pkt_socket_init(struct sock *sk)
 322 {
 323         struct vsock_sock *vsk = vsock_sk(sk);
 324
 325         PKT_FIELD(vsk, write_notify_window) = PAGE_SIZE;
 326         PKT_FIELD(vsk, write_notify_min_window) = PAGE_SIZE;
 327         PKT_FIELD(vsk, peer_waiting_read) = false;
 328         PKT_FIELD(vsk, peer_waiting_write) = false;
 329         PKT_FIELD(vsk, peer_waiting_write_detected) = false;
 330         PKT_FIELD(vsk, sent_waiting_read) = false;
 331         PKT_FIELD(vsk, sent_waiting_write) = false;
 332         PKT_FIELD(vsk, produce_q_generation) = 0;
 333         PKT_FIELD(vsk, consume_q_generation) = 0;
 334
 335         memset(&PKT_FIELD(vsk, peer_waiting_read_info), 0,
 336                sizeof(PKT_FIELD(vsk, peer_waiting_read_info)));
 337         memset(&PKT_FIELD(vsk, peer_waiting_write_info), 0,
 338                sizeof(PKT_FIELD(vsk, peer_waiting_write_info)));
 339 }
 340
 341 static void vmci_transport_notify_pkt_socket_destruct(struct vsock_sock *vsk)
 342 {
 343 }
 344
 345 static int
 346 vmci_transport_notify_pkt_poll_in(struct sock *sk,
 347                                   size_t target, bool *data_ready_now)
 348 {
 349         struct vsock_sock *vsk = vsock_sk(sk);
 350
 351         if (vsock_stream_has_data(vsk)) {
 352                 *data_ready_now = true;
 353         } else {
 354                 /* We can't read right now because there is nothing in the
 355                  * queue. Ask for notifications when there is something to
 356                  * read.
 357                  */
 358                 if (sk->sk_state == SS_CONNECTED) {
 359                         if (!send_waiting_read(sk, 1))
 360                                 return -1;
 361
 362                 }
 363                 *data_ready_now = false;
 364         }
 365
 366         return 0;
 367 }
 368
 369 static int
 370 vmci_transport_notify_pkt_poll_out(struct sock *sk,
 371                                    size_t target, bool *space_avail_now)
 372 {
 373         s64 produce_q_free_space;
 374         struct vsock_sock *vsk = vsock_sk(sk);
 375
 376         produce_q_free_space = vsock_stream_has_space(vsk);
 377         if (produce_q_free_space > 0) {
 378                 *space_avail_now = true;
 379                 return 0;
 380         } else if (produce_q_free_space == 0) {
 381                 /* This is a connected socket but we can't currently send data.
 382                  * Notify the peer that we are waiting if the queue is full. We
 383                  * only send a waiting write if the queue is full because
 384                  * otherwise we end up in an infinite WAITING_WRITE, READ,
 385                  * WAITING_WRITE, READ, etc. loop. Treat failing to send the
 386                  * notification as a socket error, passing that back through
 387                  * the mask.
 388                  */
 389                 if (!send_waiting_write(sk, 1))
 390                         return -1;
 391
 392                 *space_avail_now = false;
 393         }
 394
 395         return 0;
 396 }
 397
 398 static int
 399 vmci_transport_notify_pkt_recv_init(
 400                         struct sock *sk,
 401                         size_t target,
 402                         struct vmci_transport_recv_notify_data *data)
 403 {
 404         struct vsock_sock *vsk = vsock_sk(sk);
 405
 406 #ifdef VSOCK_OPTIMIZATION_WAITING_NOTIFY
 407         data->consume_head = 0;
 408         data->produce_tail = 0;
 409 #ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
 410         data->notify_on_block = false;
 411
 412         if (PKT_FIELD(vsk, write_notify_min_window) < target + 1) {
 413                 PKT_FIELD(vsk, write_notify_min_window) = target + 1;
 414                 if (PKT_FIELD(vsk, write_notify_window) <
 415                     PKT_FIELD(vsk, write_notify_min_window)) {
 416                         /* If the current window is smaller than the new
 417                          * minimal window size, we need to reevaluate whether
 418                          * we need to notify the sender. If the number of ready
 419                          * bytes are smaller than the new window, we need to
 420                          * send a notification to the sender before we block.
 421                          */
 422
 423                         PKT_FIELD(vsk, write_notify_window) =
 424                             PKT_FIELD(vsk, write_notify_min_window);
 425                         data->notify_on_block = true;
 426                 }
 427         }
 428 #endif
 429 #endif
 430
 431         return 0;
 432 }
 433
 434 static int
 435 vmci_transport_notify_pkt_recv_pre_block(
 436                                 struct sock *sk,
 437                                 size_t target,
 438                                 struct vmci_transport_recv_notify_data *data)
 439 {
 440         int err = 0;
 441
 442         /* Notify our peer that we are waiting for data to read. */
 443         if (!send_waiting_read(sk, target)) {
 444                 err = -EHOSTUNREACH;
 445                 return err;
 446         }
 447 #ifdef VSOCK_OPTIMIZATION_FLOW_CONTROL
 448         if (data->notify_on_block) {
 449                 err = vmci_transport_send_read_notification(sk);
 450                 if (err < 0)
 451                         return err;
 452
 453                 data->notify_on_block = false;
 454         }
 455 #endif
 456
 457         return err;
 458 }
 459
 460 static int
 461 vmci_transport_notify_pkt_recv_pre_dequeue(
 462                                 struct sock *sk,
 463                                 size_t target,
 464                                 struct vmci_transport_recv_notify_data *data)
 465 {
 466         struct vsock_sock *vsk = vsock_sk(sk);
 467
 468         /* Now consume up to len bytes from the queue.  Note that since we have
 469          * the socket locked we should copy at least ready bytes.
 470          */
 471 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 472         vmci_qpair_get_consume_indexes(vmci_trans(vsk)->qpair,
 473                                        &data->produce_tail,
 474                                        &data->consume_head);
 475 #endif
 476
 477         return 0;
 478 }
 479
 480 static int
 481 vmci_transport_notify_pkt_recv_post_dequeue(
 482                                 struct sock *sk,
 483                                 size_t target,
 484                                 ssize_t copied,
 485                                 bool data_read,
 486                                 struct vmci_transport_recv_notify_data *data)
 487 {
 488         struct vsock_sock *vsk;
 489         int err;
 490
 491         vsk = vsock_sk(sk);
 492         err = 0;
 493
 494         if (data_read) {
 495 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 496                 /* Detect a wrap-around to maintain queue generation.  Note
 497                  * that this is safe since we hold the socket lock across the
 498                  * two queue pair operations.
 499                  */
 500                 if (copied >=
 501                         vmci_trans(vsk)->consume_size - data->consume_head)
 502                         PKT_FIELD(vsk, consume_q_generation)++;
 503 #endif
 504
 505                 err = vmci_transport_send_read_notification(sk);
 506                 if (err < 0)
 507                         return err;
 508
 509         }
 510         return err;
 511 }
 512
 513 static int
 514 vmci_transport_notify_pkt_send_init(
 515                         struct sock *sk,
 516                         struct vmci_transport_send_notify_data *data)
 517 {
 518 #ifdef VSOCK_OPTIMIZATION_WAITING_NOTIFY
 519         data->consume_head = 0;
 520         data->produce_tail = 0;
 521 #endif
 522
 523         return 0;
 524 }
 525
 526 static int
 527 vmci_transport_notify_pkt_send_pre_block(
 528                                 struct sock *sk,
 529                                 struct vmci_transport_send_notify_data *data)
 530 {
 531         /* Notify our peer that we are waiting for room to write. */
 532         if (!send_waiting_write(sk, 1))
 533                 return -EHOSTUNREACH;
 534
 535         return 0;
 536 }
 537
 538 static int
 539 vmci_transport_notify_pkt_send_pre_enqueue(
 540                                 struct sock *sk,
 541                                 struct vmci_transport_send_notify_data *data)
 542 {
 543         struct vsock_sock *vsk = vsock_sk(sk);
 544
 545 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 546         vmci_qpair_get_produce_indexes(vmci_trans(vsk)->qpair,
 547                                        &data->produce_tail,
 548                                        &data->consume_head);
 549 #endif
 550
 551         return 0;
 552 }
 553
 554 static int
 555 vmci_transport_notify_pkt_send_post_enqueue(
 556                                 struct sock *sk,
 557                                 ssize_t written,
 558                                 struct vmci_transport_send_notify_data *data)
 559 {
 560         int err = 0;
 561         struct vsock_sock *vsk;
 562         bool sent_wrote = false;
 563         int retries = 0;
 564
 565         vsk = vsock_sk(sk);
 566
 567 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 568         /* Detect a wrap-around to maintain queue generation.  Note that this
 569          * is safe since we hold the socket lock across the two queue pair
 570          * operations.
 571          */
 572         if (written >= vmci_trans(vsk)->produce_size - data->produce_tail)
 573                 PKT_FIELD(vsk, produce_q_generation)++;
 574
 575 #endif
 576
 577         if (vmci_transport_notify_waiting_read(vsk)) {
 578                 /* Notify the peer that we have written, retrying the send on
 579                  * failure up to our maximum value. See the XXX comment for the
 580                  * corresponding piece of code in StreamRecvmsg() for potential
 581                  * improvements.
 582                  */
 583                 while (!(vsk->peer_shutdown & RCV_SHUTDOWN) &&
 584                        !sent_wrote &&
 585                        retries < VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
 586                         err = vmci_transport_send_wrote(sk);
 587                         if (err >= 0)
 588                                 sent_wrote = true;
 589
 590                         retries++;
 591                 }
 592
 593                 if (retries >= VMCI_TRANSPORT_MAX_DGRAM_RESENDS) {
 594                         pr_err("%p unable to send wrote notify to peer\n", sk);
 595                         return err;
 596                 } else {
 597 #if defined(VSOCK_OPTIMIZATION_WAITING_NOTIFY)
 598                         PKT_FIELD(vsk, peer_waiting_read) = false;
 599 #endif
 600                 }
 601         }
 602         return err;
 603 }
 604
 605 static void
 606 vmci_transport_notify_pkt_handle_pkt(
 607                         struct sock *sk,
 608                         struct vmci_transport_packet *pkt,
 609                         bool bottom_half,
 610                         struct sockaddr_vm *dst,
 611                         struct sockaddr_vm *src, bool *pkt_processed)
 612 {
 613         bool processed = false;
 614
 615         switch (pkt->type) {
 616         case VMCI_TRANSPORT_PACKET_TYPE_WROTE:
 617                 vmci_transport_handle_wrote(sk, pkt, bottom_half, dst, src);
 618                 processed = true;
 619                 break;
 620         case VMCI_TRANSPORT_PACKET_TYPE_READ:
 621                 vmci_transport_handle_read(sk, pkt, bottom_half, dst, src);
 622                 processed = true;
 623                 break;
 624         case VMCI_TRANSPORT_PACKET_TYPE_WAITING_WRITE:
 625                 vmci_transport_handle_waiting_write(sk, pkt, bottom_half,
 626                                                     dst, src);
 627                 processed = true;
 628                 break;
 629
 630         case VMCI_TRANSPORT_PACKET_TYPE_WAITING_READ:
 631                 vmci_transport_handle_waiting_read(sk, pkt, bottom_half,
 632                                                    dst, src);
 633                 processed = true;
 634                 break;
 635         }
 636
 637         if (pkt_processed)
 638                 *pkt_processed = processed;
 639 }
 640
 641 static void vmci_transport_notify_pkt_process_request(struct sock *sk)
 642 {
 643         struct vsock_sock *vsk = vsock_sk(sk);
 644
 645         PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
 646         if (vmci_trans(vsk)->consume_size <
 647                 PKT_FIELD(vsk, write_notify_min_window))
 648                 PKT_FIELD(vsk, write_notify_min_window) =
 649                         vmci_trans(vsk)->consume_size;
 650 }
 651
 652 static void vmci_transport_notify_pkt_process_negotiate(struct sock *sk)
 653 {
 654         struct vsock_sock *vsk = vsock_sk(sk);
 655
 656         PKT_FIELD(vsk, write_notify_window) = vmci_trans(vsk)->consume_size;
 657         if (vmci_trans(vsk)->consume_size <
 658                 PKT_FIELD(vsk, write_notify_min_window))
 659                 PKT_FIELD(vsk, write_notify_min_window) =
 660                         vmci_trans(vsk)->consume_size;
 661 }
 662
 663 /* Socket control packet based operations. */
 664 const struct vmci_transport_notify_ops vmci_transport_notify_pkt_ops = {
 665         vmci_transport_notify_pkt_socket_init,
 666         vmci_transport_notify_pkt_socket_destruct,
 667         vmci_transport_notify_pkt_poll_in,
 668         vmci_transport_notify_pkt_poll_out,
 669         vmci_transport_notify_pkt_handle_pkt,
 670         vmci_transport_notify_pkt_recv_init,
 671         vmci_transport_notify_pkt_recv_pre_block,
 672         vmci_transport_notify_pkt_recv_pre_dequeue,
 673         vmci_transport_notify_pkt_recv_post_dequeue,
 674         vmci_transport_notify_pkt_send_init,
 675         vmci_transport_notify_pkt_send_pre_block,
 676         vmci_transport_notify_pkt_send_pre_enqueue,
 677         vmci_transport_notify_pkt_send_post_enqueue,
 678         vmci_transport_notify_pkt_process_request,
 679         vmci_transport_notify_pkt_process_negotiate,
 680 };