blob: 2a0babc9570925b7b0259a80768c4698eeb3a25e [file] [log] [blame]
Hank Janssen3e7ee492009-07-13 16:02:34 -07001/*
2 *
3 * Copyright (c) 2009, Microsoft Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
16 * Place - Suite 330, Boston, MA 02111-1307 USA.
17 *
18 * Authors:
19 * Haiyang Zhang <haiyangz@microsoft.com>
20 * Hank Janssen <hjanssen@microsoft.com>
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -070021 * K. Y. Srinivasan <kys@microsoft.com>
Hank Janssen3e7ee492009-07-13 16:02:34 -070022 *
23 */
Hank Janssen0a466182011-03-29 13:58:47 -070024#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
Hank Janssen3e7ee492009-07-13 16:02:34 -070025
Greg Kroah-Hartmana0086dc2009-08-17 17:22:08 -070026#include <linux/kernel.h>
27#include <linux/mm.h>
Greg Kroah-Hartman46a97192011-10-04 12:29:52 -070028#include <linux/hyperv.h>
K. Y. Srinivasan3f335ea2011-05-12 19:34:15 -070029
K. Y. Srinivasan0f2a6612011-05-12 19:34:28 -070030#include "hyperv_vmbus.h"
Hank Janssen3e7ee492009-07-13 16:02:34 -070031
K. Y. Srinivasan6fdf3b22012-12-01 06:46:32 -080032void hv_begin_read(struct hv_ring_buffer_info *rbi)
33{
34 rbi->ring_buffer->interrupt_mask = 1;
35 smp_mb();
36}
37
38u32 hv_end_read(struct hv_ring_buffer_info *rbi)
39{
40 u32 read;
41 u32 write;
42
43 rbi->ring_buffer->interrupt_mask = 0;
44 smp_mb();
45
46 /*
47 * Now check to see if the ring buffer is still empty.
48 * If it is not, we raced and we need to process new
49 * incoming messages.
50 */
51 hv_get_ringbuffer_availbytes(rbi, &read, &write);
52
53 return read;
54}
55
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -080056/*
57 * When we write to the ring buffer, check if the host needs to
58 * be signaled. Here is the details of this protocol:
59 *
60 * 1. The host guarantees that while it is draining the
61 * ring buffer, it will set the interrupt_mask to
62 * indicate it does not need to be interrupted when
63 * new data is placed.
64 *
65 * 2. The host guarantees that it will completely drain
66 * the ring buffer before exiting the read loop. Further,
67 * once the ring buffer is empty, it will clear the
68 * interrupt_mask and re-check to see if new data has
69 * arrived.
70 */
71
72static bool hv_need_to_signal(u32 old_write, struct hv_ring_buffer_info *rbi)
73{
74 if (rbi->ring_buffer->interrupt_mask)
75 return false;
76
77 /*
78 * This is the only case we need to signal when the
79 * ring transitions from being empty to non-empty.
80 */
81 if (old_write == rbi->ring_buffer->read_index)
82 return true;
83
84 return false;
85}
86
Hank Janssen3e7ee492009-07-13 16:02:34 -070087
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -070088/*
89 * hv_get_next_write_location()
90 *
91 * Get the next write location for the specified ring buffer
92 *
93 */
Greg Kroah-Hartman4d643112009-07-14 15:09:36 -070094static inline u32
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -070095hv_get_next_write_location(struct hv_ring_buffer_info *ring_info)
Hank Janssen3e7ee492009-07-13 16:02:34 -070096{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -080097 u32 next = ring_info->ring_buffer->write_index;
Hank Janssen3e7ee492009-07-13 16:02:34 -070098
Hank Janssen3e7ee492009-07-13 16:02:34 -070099 return next;
100}
101
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700102/*
103 * hv_set_next_write_location()
104 *
105 * Set the next write location for the specified ring buffer
106 *
107 */
Hank Janssen3e7ee492009-07-13 16:02:34 -0700108static inline void
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700109hv_set_next_write_location(struct hv_ring_buffer_info *ring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800110 u32 next_write_location)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700111{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800112 ring_info->ring_buffer->write_index = next_write_location;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700113}
114
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700115/*
116 * hv_get_next_read_location()
117 *
118 * Get the next read location for the specified ring buffer
119 */
Greg Kroah-Hartman4d643112009-07-14 15:09:36 -0700120static inline u32
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700121hv_get_next_read_location(struct hv_ring_buffer_info *ring_info)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700122{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800123 u32 next = ring_info->ring_buffer->read_index;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700124
Hank Janssen3e7ee492009-07-13 16:02:34 -0700125 return next;
126}
127
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700128/*
129 * hv_get_next_readlocation_withoffset()
130 *
131 * Get the next read location + offset for the specified ring buffer.
132 * This allows the caller to skip
133 */
Greg Kroah-Hartman4d643112009-07-14 15:09:36 -0700134static inline u32
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700135hv_get_next_readlocation_withoffset(struct hv_ring_buffer_info *ring_info,
Haiyang Zhang1ac58642010-11-08 14:04:47 -0800136 u32 offset)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700137{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800138 u32 next = ring_info->ring_buffer->read_index;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700139
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800140 next += offset;
141 next %= ring_info->ring_datasize;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700142
143 return next;
144}
145
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700146/*
147 *
148 * hv_set_next_read_location()
149 *
150 * Set the next read location for the specified ring buffer
151 *
152 */
Hank Janssen3e7ee492009-07-13 16:02:34 -0700153static inline void
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700154hv_set_next_read_location(struct hv_ring_buffer_info *ring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800155 u32 next_read_location)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700156{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800157 ring_info->ring_buffer->read_index = next_read_location;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700158}
159
160
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700161/*
162 *
163 * hv_get_ring_buffer()
164 *
165 * Get the start of the ring buffer
166 */
Greg Kroah-Hartman8282c402009-07-14 15:06:28 -0700167static inline void *
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700168hv_get_ring_buffer(struct hv_ring_buffer_info *ring_info)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700169{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800170 return (void *)ring_info->ring_buffer->buffer;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700171}
172
173
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700174/*
175 *
176 * hv_get_ring_buffersize()
177 *
178 * Get the size of the ring buffer
179 */
Greg Kroah-Hartman4d643112009-07-14 15:09:36 -0700180static inline u32
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700181hv_get_ring_buffersize(struct hv_ring_buffer_info *ring_info)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700182{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800183 return ring_info->ring_datasize;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700184}
185
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700186/*
187 *
188 * hv_get_ring_bufferindices()
189 *
190 * Get the read and write indices as u64 of the specified ring buffer
191 *
192 */
Greg Kroah-Hartman59471432009-07-14 15:10:26 -0700193static inline u64
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700194hv_get_ring_bufferindices(struct hv_ring_buffer_info *ring_info)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700195{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800196 return (u64)ring_info->ring_buffer->write_index << 32;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700197}
198
K. Y. Srinivasan8f1136a2011-05-10 07:55:31 -0700199/*
200 *
201 * hv_copyfrom_ringbuffer()
202 *
203 * Helper routine to copy to source from ring buffer.
204 * Assume there is enough room. Handles wrap-around in src case only!!
205 *
206 */
207static u32 hv_copyfrom_ringbuffer(
208 struct hv_ring_buffer_info *ring_info,
209 void *dest,
210 u32 destlen,
211 u32 start_read_offset)
212{
213 void *ring_buffer = hv_get_ring_buffer(ring_info);
214 u32 ring_buffer_size = hv_get_ring_buffersize(ring_info);
215
216 u32 frag_len;
217
218 /* wrap-around detected at the src */
219 if (destlen > ring_buffer_size - start_read_offset) {
220 frag_len = ring_buffer_size - start_read_offset;
221
222 memcpy(dest, ring_buffer + start_read_offset, frag_len);
223 memcpy(dest + frag_len, ring_buffer, destlen - frag_len);
224 } else
225
226 memcpy(dest, ring_buffer + start_read_offset, destlen);
227
228
229 start_read_offset += destlen;
230 start_read_offset %= ring_buffer_size;
231
232 return start_read_offset;
233}
234
235
K. Y. Srinivasan75815782011-05-10 07:55:32 -0700236/*
237 *
238 * hv_copyto_ringbuffer()
239 *
240 * Helper routine to copy from source to ring buffer.
241 * Assume there is enough room. Handles wrap-around in dest case only!!
242 *
243 */
244static u32 hv_copyto_ringbuffer(
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800245 struct hv_ring_buffer_info *ring_info,
246 u32 start_write_offset,
247 void *src,
K. Y. Srinivasan75815782011-05-10 07:55:32 -0700248 u32 srclen)
249{
250 void *ring_buffer = hv_get_ring_buffer(ring_info);
251 u32 ring_buffer_size = hv_get_ring_buffersize(ring_info);
252 u32 frag_len;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700253
K. Y. Srinivasan75815782011-05-10 07:55:32 -0700254 /* wrap-around detected! */
255 if (srclen > ring_buffer_size - start_write_offset) {
256 frag_len = ring_buffer_size - start_write_offset;
257 memcpy(ring_buffer + start_write_offset, src, frag_len);
258 memcpy(ring_buffer, src + frag_len, srclen - frag_len);
259 } else
260 memcpy(ring_buffer + start_write_offset, src, srclen);
261
262 start_write_offset += srclen;
263 start_write_offset %= ring_buffer_size;
264
265 return start_write_offset;
266}
Hank Janssen3e7ee492009-07-13 16:02:34 -0700267
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700268/*
269 *
270 * hv_ringbuffer_get_debuginfo()
271 *
272 * Get various debug metrics for the specified ring buffer
273 *
274 */
K. Y. Srinivasana75b61d2011-05-10 07:55:28 -0700275void hv_ringbuffer_get_debuginfo(struct hv_ring_buffer_info *ring_info,
Greg Kroah-Hartman80682b72010-07-27 11:37:32 -0700276 struct hv_ring_buffer_debug_info *debug_info)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700277{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800278 u32 bytes_avail_towrite;
279 u32 bytes_avail_toread;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700280
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800281 if (ring_info->ring_buffer) {
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700282 hv_get_ringbuffer_availbytes(ring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800283 &bytes_avail_toread,
284 &bytes_avail_towrite);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700285
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800286 debug_info->bytes_avail_toread = bytes_avail_toread;
287 debug_info->bytes_avail_towrite = bytes_avail_towrite;
Haiyang Zhang82f8bd42010-11-08 14:04:45 -0800288 debug_info->current_read_index =
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800289 ring_info->ring_buffer->read_index;
Haiyang Zhang82f8bd42010-11-08 14:04:45 -0800290 debug_info->current_write_index =
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800291 ring_info->ring_buffer->write_index;
Haiyang Zhang82f8bd42010-11-08 14:04:45 -0800292 debug_info->current_interrupt_mask =
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800293 ring_info->ring_buffer->interrupt_mask;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700294 }
295}
296
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700297/*
298 *
299 * hv_ringbuffer_init()
300 *
301 *Initialize the ring buffer
302 *
303 */
K. Y. Srinivasan72a95cb2011-05-10 07:55:21 -0700304int hv_ringbuffer_init(struct hv_ring_buffer_info *ring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800305 void *buffer, u32 buflen)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700306{
Greg Kroah-Hartman4a1b3ac2010-07-27 11:47:08 -0700307 if (sizeof(struct hv_ring_buffer) != PAGE_SIZE)
Bill Pemberton3324fb42010-05-05 15:27:49 -0400308 return -EINVAL;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700309
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800310 memset(ring_info, 0, sizeof(struct hv_ring_buffer_info));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700311
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800312 ring_info->ring_buffer = (struct hv_ring_buffer *)buffer;
313 ring_info->ring_buffer->read_index =
314 ring_info->ring_buffer->write_index = 0;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700315
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800316 ring_info->ring_size = buflen;
317 ring_info->ring_datasize = buflen - sizeof(struct hv_ring_buffer);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700318
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800319 spin_lock_init(&ring_info->ring_lock);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700320
321 return 0;
322}
323
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700324/*
325 *
326 * hv_ringbuffer_cleanup()
327 *
328 * Cleanup the ring buffer
329 *
330 */
K. Y. Srinivasan2dba6882011-05-10 07:55:22 -0700331void hv_ringbuffer_cleanup(struct hv_ring_buffer_info *ring_info)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700332{
Hank Janssen3e7ee492009-07-13 16:02:34 -0700333}
334
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700335/*
336 *
337 * hv_ringbuffer_write()
338 *
339 * Write to the ring buffer
340 *
341 */
K. Y. Srinivasan633c4dc2011-05-10 07:55:23 -0700342int hv_ringbuffer_write(struct hv_ring_buffer_info *outring_info,
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800343 struct scatterlist *sglist, u32 sgcount, bool *signal)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700344{
C. Bartlett4408f532010-02-03 15:34:27 +0000345 int i = 0;
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800346 u32 bytes_avail_towrite;
347 u32 bytes_avail_toread;
348 u32 totalbytes_towrite = 0;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700349
Nicolas Palixb219b3f2009-07-30 17:37:23 +0200350 struct scatterlist *sg;
K. Y. Srinivasan66a60542011-05-10 07:55:33 -0700351 u32 next_write_location;
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800352 u32 old_write;
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800353 u64 prev_indices = 0;
Greg Kroah-Hartmana98f96e2009-07-15 14:55:14 -0700354 unsigned long flags;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700355
Nicolas Palixb219b3f2009-07-30 17:37:23 +0200356 for_each_sg(sglist, sg, sgcount, i)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700357 {
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800358 totalbytes_towrite += sg->length;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700359 }
360
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800361 totalbytes_towrite += sizeof(u64);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700362
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800363 spin_lock_irqsave(&outring_info->ring_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700364
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700365 hv_get_ringbuffer_availbytes(outring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800366 &bytes_avail_toread,
367 &bytes_avail_towrite);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700368
Hank Janssen3e7ee492009-07-13 16:02:34 -0700369
C. Bartlett4408f532010-02-03 15:34:27 +0000370 /* If there is only room for the packet, assume it is full. */
371 /* Otherwise, the next time around, we think the ring buffer */
Bill Pemberton454f18a2009-07-27 16:47:24 -0400372 /* is empty since the read index == write index */
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800373 if (bytes_avail_towrite <= totalbytes_towrite) {
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800374 spin_unlock_irqrestore(&outring_info->ring_lock, flags);
K. Y. Srinivasand2598f02011-08-25 09:48:58 -0700375 return -EAGAIN;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700376 }
377
Bill Pemberton454f18a2009-07-27 16:47:24 -0400378 /* Write to the ring buffer */
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700379 next_write_location = hv_get_next_write_location(outring_info);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700380
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800381 old_write = next_write_location;
382
Nicolas Palixb219b3f2009-07-30 17:37:23 +0200383 for_each_sg(sglist, sg, sgcount, i)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700384 {
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700385 next_write_location = hv_copyto_ringbuffer(outring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800386 next_write_location,
Nicolas Palixb219b3f2009-07-30 17:37:23 +0200387 sg_virt(sg),
388 sg->length);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700389 }
390
Bill Pemberton454f18a2009-07-27 16:47:24 -0400391 /* Set previous packet start */
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700392 prev_indices = hv_get_ring_bufferindices(outring_info);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700393
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700394 next_write_location = hv_copyto_ringbuffer(outring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800395 next_write_location,
396 &prev_indices,
Nicolas Palixb219b3f2009-07-30 17:37:23 +0200397 sizeof(u64));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700398
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800399 /* Issue a full memory barrier before updating the write index */
400 smp_mb();
Hank Janssen3e7ee492009-07-13 16:02:34 -0700401
Bill Pemberton454f18a2009-07-27 16:47:24 -0400402 /* Now, update the write location */
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700403 hv_set_next_write_location(outring_info, next_write_location);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700404
Hank Janssen3e7ee492009-07-13 16:02:34 -0700405
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800406 spin_unlock_irqrestore(&outring_info->ring_lock, flags);
K. Y. Srinivasan98fa8cf2012-12-01 06:46:36 -0800407
408 *signal = hv_need_to_signal(old_write, outring_info);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700409 return 0;
410}
411
412
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700413/*
414 *
415 * hv_ringbuffer_peek()
416 *
417 * Read without advancing the read index
418 *
419 */
K. Y. Srinivasana89186c2011-05-10 07:55:24 -0700420int hv_ringbuffer_peek(struct hv_ring_buffer_info *Inring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800421 void *Buffer, u32 buflen)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700422{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800423 u32 bytes_avail_towrite;
424 u32 bytes_avail_toread;
425 u32 next_read_location = 0;
Greg Kroah-Hartmana98f96e2009-07-15 14:55:14 -0700426 unsigned long flags;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700427
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800428 spin_lock_irqsave(&Inring_info->ring_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700429
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700430 hv_get_ringbuffer_availbytes(Inring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800431 &bytes_avail_toread,
432 &bytes_avail_towrite);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700433
Bill Pemberton454f18a2009-07-27 16:47:24 -0400434 /* Make sure there is something to read */
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800435 if (bytes_avail_toread < buflen) {
Hank Janssen3e7ee492009-07-13 16:02:34 -0700436
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800437 spin_unlock_irqrestore(&Inring_info->ring_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700438
K. Y. Srinivasand2598f02011-08-25 09:48:58 -0700439 return -EAGAIN;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700440 }
441
Bill Pemberton454f18a2009-07-27 16:47:24 -0400442 /* Convert to byte offset */
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700443 next_read_location = hv_get_next_read_location(Inring_info);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700444
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700445 next_read_location = hv_copyfrom_ringbuffer(Inring_info,
C. Bartlett4408f532010-02-03 15:34:27 +0000446 Buffer,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800447 buflen,
448 next_read_location);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700449
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800450 spin_unlock_irqrestore(&Inring_info->ring_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700451
452 return 0;
453}
454
455
K. Y. Srinivasanb2a5a582011-05-10 07:55:30 -0700456/*
457 *
458 * hv_ringbuffer_read()
459 *
460 * Read and advance the read index
461 *
462 */
K. Y. Srinivasan38397c82011-05-10 07:55:25 -0700463int hv_ringbuffer_read(struct hv_ring_buffer_info *inring_info, void *buffer,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800464 u32 buflen, u32 offset)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700465{
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800466 u32 bytes_avail_towrite;
467 u32 bytes_avail_toread;
468 u32 next_read_location = 0;
469 u64 prev_indices = 0;
Greg Kroah-Hartmana98f96e2009-07-15 14:55:14 -0700470 unsigned long flags;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700471
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800472 if (buflen <= 0)
Bill Pembertona16e1482010-05-05 15:27:50 -0400473 return -EINVAL;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700474
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800475 spin_lock_irqsave(&inring_info->ring_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700476
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700477 hv_get_ringbuffer_availbytes(inring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800478 &bytes_avail_toread,
479 &bytes_avail_towrite);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700480
Bill Pemberton454f18a2009-07-27 16:47:24 -0400481 /* Make sure there is something to read */
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800482 if (bytes_avail_toread < buflen) {
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800483 spin_unlock_irqrestore(&inring_info->ring_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700484
K. Y. Srinivasand2598f02011-08-25 09:48:58 -0700485 return -EAGAIN;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700486 }
487
Haiyang Zhang1ac58642010-11-08 14:04:47 -0800488 next_read_location =
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700489 hv_get_next_readlocation_withoffset(inring_info, offset);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700490
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700491 next_read_location = hv_copyfrom_ringbuffer(inring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800492 buffer,
493 buflen,
494 next_read_location);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700495
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700496 next_read_location = hv_copyfrom_ringbuffer(inring_info,
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800497 &prev_indices,
C. Bartlett4408f532010-02-03 15:34:27 +0000498 sizeof(u64),
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800499 next_read_location);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700500
Bill Pemberton454f18a2009-07-27 16:47:24 -0400501 /* Make sure all reads are done before we update the read index since */
C. Bartlett4408f532010-02-03 15:34:27 +0000502 /* the writer may start writing to the read area once the read index */
503 /*is updated */
K. Y. Srinivasanef0d5b22011-06-06 15:49:51 -0700504 smp_mb();
Hank Janssen3e7ee492009-07-13 16:02:34 -0700505
Bill Pemberton454f18a2009-07-27 16:47:24 -0400506 /* Update the read index */
K. Y. Srinivasan2b8a9122011-05-10 07:55:29 -0700507 hv_set_next_read_location(inring_info, next_read_location);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700508
Haiyang Zhangfc8c72e2010-11-08 14:04:46 -0800509 spin_unlock_irqrestore(&inring_info->ring_lock, flags);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700510
511 return 0;
512}