Merge branch 'for-linus' of git://git.kernel.dk/linux-block

[deliverable/linux.git] / include / linux / hyperv.h

diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index eb7c0b215ba47bc0f492235b2bdd0d81f5b15c9f..b10954a66939248942021f4c8917895fe9dd098f 100644 (file)
--- 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;
 };
 
 /*
@@ -1118,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);
 
@@ -1420,4 +1422,88 @@ static inline  bool hv_need_to_signal_on_read(struct hv_ring_buffer_info *rbi)
        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 */