1 files changed, 169 insertions, 1 deletions

diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index aa0fadce9308..b10954a66939 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -126,6 +126,8 @@ struct hv_ring_buffer_info {
 
         u32 ring_datasize;              /* < ring_size */
         u32 ring_data_startoffset;
+        u32 priv_write_index;
+        u32 priv_read_index;
 };
 
 /*
@@ -151,6 +153,33 @@ hv_get_ringbuffer_availbytes(struct hv_ring_buffer_info *rbi,
         *read = dsize - *write;
 }
 
+static inline u32 hv_get_bytes_to_read(struct hv_ring_buffer_info *rbi)
+{
+        u32 read_loc, write_loc, dsize, read;
+
+        dsize = rbi->ring_datasize;
+        read_loc = rbi->ring_buffer->read_index;
+        write_loc = READ_ONCE(rbi->ring_buffer->write_index);
+
+        read = write_loc >= read_loc ? (write_loc - read_loc) :
+                (dsize - read_loc) + write_loc;
+
+        return read;
+}
+
+static inline u32 hv_get_bytes_to_write(struct hv_ring_buffer_info *rbi)
+{
+        u32 read_loc, write_loc, dsize, write;
+
+        dsize = rbi->ring_datasize;
+        read_loc = READ_ONCE(rbi->ring_buffer->read_index);
+        write_loc = rbi->ring_buffer->write_index;
+
+        write = write_loc >= read_loc ? dsize - (write_loc - read_loc) :
+                read_loc - write_loc;
+        return write;
+}
+
 /*
  * VMBUS version is 32 bit entity broken up into
  * two 16 bit quantities: major_number. minor_number.
@@ -1091,7 +1120,7 @@ int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
                         resource_size_t min, resource_size_t max,
                         resource_size_t size, resource_size_t align,
                         bool fb_overlap_ok);
-
+void vmbus_free_mmio(resource_size_t start, resource_size_t size);
 int vmbus_cpu_number_to_vp_number(int cpu_number);
 u64 hv_do_hypercall(u64 control, void *input, void *output);
 
@@ -1338,4 +1367,143 @@ extern __u32 vmbus_proto_version;
 
 int vmbus_send_tl_connect_request(const uuid_le *shv_guest_servie_id,
                                   const uuid_le *shv_host_servie_id);
+void vmbus_set_event(struct vmbus_channel *channel);
+
+/* Get the start of the ring buffer. */
+static inline void *
+hv_get_ring_buffer(struct hv_ring_buffer_info *ring_info)
+{
+        return (void *)ring_info->ring_buffer->buffer;
+}
+
+/*
+ * To optimize the flow management on the send-side,
+ * when the sender is blocked because of lack of
+ * sufficient space in the ring buffer, potential the
+ * consumer of the ring buffer can signal the producer.
+ * This is controlled by the following parameters:
+ *
+ * 1. pending_send_sz: This is the size in bytes that the
+ *    producer is trying to send.
+ * 2. The feature bit feat_pending_send_sz set to indicate if
+ *    the consumer of the ring will signal when the ring
+ *    state transitions from being full to a state where
+ *    there is room for the producer to send the pending packet.
+ */
+
+static inline  bool hv_need_to_signal_on_read(struct hv_ring_buffer_info *rbi)
+{
+        u32 cur_write_sz;
+        u32 pending_sz;
+
+        /*
+         * Issue a full memory barrier before making the signaling decision.
+         * Here is the reason for having this barrier:
+         * If the reading of the pend_sz (in this function)
+         * were to be reordered and read before we commit the new read
+         * index (in the calling function)  we could
+         * have a problem. If the host were to set the pending_sz after we
+         * have sampled pending_sz and go to sleep before we commit the
+         * read index, we could miss sending the interrupt. Issue a full
+         * memory barrier to address this.
+         */
+        virt_mb();
+
+        pending_sz = READ_ONCE(rbi->ring_buffer->pending_send_sz);
+        /* If the other end is not blocked on write don't bother. */
+        if (pending_sz == 0)
+                return false;
+
+        cur_write_sz = hv_get_bytes_to_write(rbi);
+
+        if (cur_write_sz >= pending_sz)
+                return true;
+
+        return false;
+}
+
+/*
+ * An API to support in-place processing of incoming VMBUS packets.
+ */
+#define VMBUS_PKT_TRAILER       8
+
+static inline struct vmpacket_descriptor *
+get_next_pkt_raw(struct vmbus_channel *channel)
+{
+        struct hv_ring_buffer_info *ring_info = &channel->inbound;
+        u32 read_loc = ring_info->priv_read_index;
+        void *ring_buffer = hv_get_ring_buffer(ring_info);
+        struct vmpacket_descriptor *cur_desc;
+        u32 packetlen;
+        u32 dsize = ring_info->ring_datasize;
+        u32 delta = read_loc - ring_info->ring_buffer->read_index;
+        u32 bytes_avail_toread = (hv_get_bytes_to_read(ring_info) - delta);
+
+        if (bytes_avail_toread < sizeof(struct vmpacket_descriptor))
+                return NULL;
+
+        if ((read_loc + sizeof(*cur_desc)) > dsize)
+                return NULL;
+
+        cur_desc = ring_buffer + read_loc;
+        packetlen = cur_desc->len8 << 3;
+
+        /*
+         * If the packet under consideration is wrapping around,
+         * return failure.
+         */
+        if ((read_loc + packetlen + VMBUS_PKT_TRAILER) > (dsize - 1))
+                return NULL;
+
+        return cur_desc;
+}
+
+/*
+ * A helper function to step through packets "in-place"
+ * This API is to be called after each successful call
+ * get_next_pkt_raw().
+ */
+static inline void put_pkt_raw(struct vmbus_channel *channel,
+                                struct vmpacket_descriptor *desc)
+{
+        struct hv_ring_buffer_info *ring_info = &channel->inbound;
+        u32 read_loc = ring_info->priv_read_index;
+        u32 packetlen = desc->len8 << 3;
+        u32 dsize = ring_info->ring_datasize;
+
+        if ((read_loc + packetlen + VMBUS_PKT_TRAILER) > dsize)
+                BUG();
+        /*
+         * Include the packet trailer.
+         */
+        ring_info->priv_read_index += packetlen + VMBUS_PKT_TRAILER;
+}
+
+/*
+ * This call commits the read index and potentially signals the host.
+ * Here is the pattern for using the "in-place" consumption APIs:
+ *
+ * while (get_next_pkt_raw() {
+ *      process the packet "in-place";
+ *      put_pkt_raw();
+ * }
+ * if (packets processed in place)
+ *      commit_rd_index();
+ */
+static inline void commit_rd_index(struct vmbus_channel *channel)
+{
+        struct hv_ring_buffer_info *ring_info = &channel->inbound;
+        /*
+         * Make sure all reads are done before we update the read index since
+         * the writer may start writing to the read area once the read index
+         * is updated.
+         */
+        virt_rmb();
+        ring_info->ring_buffer->read_index = ring_info->priv_read_index;
+
+        if (hv_need_to_signal_on_read(ring_info))
+                vmbus_set_event(channel);
+}
+
+
 #endif /* _HYPERV_H */