xref: /openbmc/linux/drivers/hv/ring_buffer.c (revision 33be96e4) 
1 /*
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>
21  *   K. Y. Srinivasan <kys@microsoft.com>
22  *
23  */
24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 
26 #include <linux/kernel.h>
27 #include <linux/mm.h>
28 #include <linux/hyperv.h>
29 
30 #include "hyperv_vmbus.h"
31 
32 
33 /*
34  * hv_get_next_write_location()
35  *
36  * Get the next write location for the specified ring buffer
37  *
38  */
39 static inline u32
40 hv_get_next_write_location(struct hv_ring_buffer_info *ring_info)
41 {
42 	u32 next = ring_info->ring_buffer->write_index;
43 
44 	return next;
45 }
46 
47 /*
48  * hv_set_next_write_location()
49  *
50  * Set the next write location for the specified ring buffer
51  *
52  */
53 static inline void
54 hv_set_next_write_location(struct hv_ring_buffer_info *ring_info,
55 		     u32 next_write_location)
56 {
57 	ring_info->ring_buffer->write_index = next_write_location;
58 }
59 
60 /*
61  * hv_get_next_read_location()
62  *
63  * Get the next read location for the specified ring buffer
64  */
65 static inline u32
66 hv_get_next_read_location(struct hv_ring_buffer_info *ring_info)
67 {
68 	u32 next = ring_info->ring_buffer->read_index;
69 
70 	return next;
71 }
72 
73 /*
74  * hv_get_next_readlocation_withoffset()
75  *
76  * Get the next read location + offset for the specified ring buffer.
77  * This allows the caller to skip
78  */
79 static inline u32
80 hv_get_next_readlocation_withoffset(struct hv_ring_buffer_info *ring_info,
81 				 u32 offset)
82 {
83 	u32 next = ring_info->ring_buffer->read_index;
84 
85 	next += offset;
86 	next %= ring_info->ring_datasize;
87 
88 	return next;
89 }
90 
91 /*
92  *
93  * hv_set_next_read_location()
94  *
95  * Set the next read location for the specified ring buffer
96  *
97  */
98 static inline void
99 hv_set_next_read_location(struct hv_ring_buffer_info *ring_info,
100 		    u32 next_read_location)
101 {
102 	ring_info->ring_buffer->read_index = next_read_location;
103 }
104 
105 
106 /*
107  *
108  * hv_get_ring_buffer()
109  *
110  * Get the start of the ring buffer
111  */
112 static inline void *
113 hv_get_ring_buffer(struct hv_ring_buffer_info *ring_info)
114 {
115 	return (void *)ring_info->ring_buffer->buffer;
116 }
117 
118 
119 /*
120  *
121  * hv_get_ring_buffersize()
122  *
123  * Get the size of the ring buffer
124  */
125 static inline u32
126 hv_get_ring_buffersize(struct hv_ring_buffer_info *ring_info)
127 {
128 	return ring_info->ring_datasize;
129 }
130 
131 /*
132  *
133  * hv_get_ring_bufferindices()
134  *
135  * Get the read and write indices as u64 of the specified ring buffer
136  *
137  */
138 static inline u64
139 hv_get_ring_bufferindices(struct hv_ring_buffer_info *ring_info)
140 {
141 	return (u64)ring_info->ring_buffer->write_index << 32;
142 }
143 
144 /*
145  *
146  * hv_copyfrom_ringbuffer()
147  *
148  * Helper routine to copy to source from ring buffer.
149  * Assume there is enough room. Handles wrap-around in src case only!!
150  *
151  */
152 static u32 hv_copyfrom_ringbuffer(
153 	struct hv_ring_buffer_info	*ring_info,
154 	void				*dest,
155 	u32				destlen,
156 	u32				start_read_offset)
157 {
158 	void *ring_buffer = hv_get_ring_buffer(ring_info);
159 	u32 ring_buffer_size = hv_get_ring_buffersize(ring_info);
160 
161 	u32 frag_len;
162 
163 	/* wrap-around detected at the src */
164 	if (destlen > ring_buffer_size - start_read_offset) {
165 		frag_len = ring_buffer_size - start_read_offset;
166 
167 		memcpy(dest, ring_buffer + start_read_offset, frag_len);
168 		memcpy(dest + frag_len, ring_buffer, destlen - frag_len);
169 	} else
170 
171 		memcpy(dest, ring_buffer + start_read_offset, destlen);
172 
173 
174 	start_read_offset += destlen;
175 	start_read_offset %= ring_buffer_size;
176 
177 	return start_read_offset;
178 }
179 
180 
181 /*
182  *
183  * hv_copyto_ringbuffer()
184  *
185  * Helper routine to copy from source to ring buffer.
186  * Assume there is enough room. Handles wrap-around in dest case only!!
187  *
188  */
189 static u32 hv_copyto_ringbuffer(
190 	struct hv_ring_buffer_info	*ring_info,
191 	u32				start_write_offset,
192 	void				*src,
193 	u32				srclen)
194 {
195 	void *ring_buffer = hv_get_ring_buffer(ring_info);
196 	u32 ring_buffer_size = hv_get_ring_buffersize(ring_info);
197 	u32 frag_len;
198 
199 	/* wrap-around detected! */
200 	if (srclen > ring_buffer_size - start_write_offset) {
201 		frag_len = ring_buffer_size - start_write_offset;
202 		memcpy(ring_buffer + start_write_offset, src, frag_len);
203 		memcpy(ring_buffer, src + frag_len, srclen - frag_len);
204 	} else
205 		memcpy(ring_buffer + start_write_offset, src, srclen);
206 
207 	start_write_offset += srclen;
208 	start_write_offset %= ring_buffer_size;
209 
210 	return start_write_offset;
211 }
212 
213 /*
214  *
215  * hv_ringbuffer_get_debuginfo()
216  *
217  * Get various debug metrics for the specified ring buffer
218  *
219  */
220 void hv_ringbuffer_get_debuginfo(struct hv_ring_buffer_info *ring_info,
221 			    struct hv_ring_buffer_debug_info *debug_info)
222 {
223 	u32 bytes_avail_towrite;
224 	u32 bytes_avail_toread;
225 
226 	if (ring_info->ring_buffer) {
227 		hv_get_ringbuffer_availbytes(ring_info,
228 					&bytes_avail_toread,
229 					&bytes_avail_towrite);
230 
231 		debug_info->bytes_avail_toread = bytes_avail_toread;
232 		debug_info->bytes_avail_towrite = bytes_avail_towrite;
233 		debug_info->current_read_index =
234 			ring_info->ring_buffer->read_index;
235 		debug_info->current_write_index =
236 			ring_info->ring_buffer->write_index;
237 		debug_info->current_interrupt_mask =
238 			ring_info->ring_buffer->interrupt_mask;
239 	}
240 }
241 
242 
243 /*
244  *
245  * hv_get_ringbuffer_interrupt_mask()
246  *
247  * Get the interrupt mask for the specified ring buffer
248  *
249  */
250 u32 hv_get_ringbuffer_interrupt_mask(struct hv_ring_buffer_info *rbi)
251 {
252 	return rbi->ring_buffer->interrupt_mask;
253 }
254 
255 /*
256  *
257  * hv_ringbuffer_init()
258  *
259  *Initialize the ring buffer
260  *
261  */
262 int hv_ringbuffer_init(struct hv_ring_buffer_info *ring_info,
263 		   void *buffer, u32 buflen)
264 {
265 	if (sizeof(struct hv_ring_buffer) != PAGE_SIZE)
266 		return -EINVAL;
267 
268 	memset(ring_info, 0, sizeof(struct hv_ring_buffer_info));
269 
270 	ring_info->ring_buffer = (struct hv_ring_buffer *)buffer;
271 	ring_info->ring_buffer->read_index =
272 		ring_info->ring_buffer->write_index = 0;
273 
274 	ring_info->ring_size = buflen;
275 	ring_info->ring_datasize = buflen - sizeof(struct hv_ring_buffer);
276 
277 	spin_lock_init(&ring_info->ring_lock);
278 
279 	return 0;
280 }
281 
282 /*
283  *
284  * hv_ringbuffer_cleanup()
285  *
286  * Cleanup the ring buffer
287  *
288  */
289 void hv_ringbuffer_cleanup(struct hv_ring_buffer_info *ring_info)
290 {
291 }
292 
293 /*
294  *
295  * hv_ringbuffer_write()
296  *
297  * Write to the ring buffer
298  *
299  */
300 int hv_ringbuffer_write(struct hv_ring_buffer_info *outring_info,
301 		    struct scatterlist *sglist, u32 sgcount)
302 {
303 	int i = 0;
304 	u32 bytes_avail_towrite;
305 	u32 bytes_avail_toread;
306 	u32 totalbytes_towrite = 0;
307 
308 	struct scatterlist *sg;
309 	u32 next_write_location;
310 	u64 prev_indices = 0;
311 	unsigned long flags;
312 
313 	for_each_sg(sglist, sg, sgcount, i)
314 	{
315 		totalbytes_towrite += sg->length;
316 	}
317 
318 	totalbytes_towrite += sizeof(u64);
319 
320 	spin_lock_irqsave(&outring_info->ring_lock, flags);
321 
322 	hv_get_ringbuffer_availbytes(outring_info,
323 				&bytes_avail_toread,
324 				&bytes_avail_towrite);
325 
326 
327 	/* If there is only room for the packet, assume it is full. */
328 	/* Otherwise, the next time around, we think the ring buffer */
329 	/* is empty since the read index == write index */
330 	if (bytes_avail_towrite <= totalbytes_towrite) {
331 		spin_unlock_irqrestore(&outring_info->ring_lock, flags);
332 		return -EAGAIN;
333 	}
334 
335 	/* Write to the ring buffer */
336 	next_write_location = hv_get_next_write_location(outring_info);
337 
338 	for_each_sg(sglist, sg, sgcount, i)
339 	{
340 		next_write_location = hv_copyto_ringbuffer(outring_info,
341 						     next_write_location,
342 						     sg_virt(sg),
343 						     sg->length);
344 	}
345 
346 	/* Set previous packet start */
347 	prev_indices = hv_get_ring_bufferindices(outring_info);
348 
349 	next_write_location = hv_copyto_ringbuffer(outring_info,
350 					     next_write_location,
351 					     &prev_indices,
352 					     sizeof(u64));
353 
354 	/* Make sure we flush all writes before updating the writeIndex */
355 	smp_wmb();
356 
357 	/* Now, update the write location */
358 	hv_set_next_write_location(outring_info, next_write_location);
359 
360 
361 	spin_unlock_irqrestore(&outring_info->ring_lock, flags);
362 	return 0;
363 }
364 
365 
366 /*
367  *
368  * hv_ringbuffer_peek()
369  *
370  * Read without advancing the read index
371  *
372  */
373 int hv_ringbuffer_peek(struct hv_ring_buffer_info *Inring_info,
374 		   void *Buffer, u32 buflen)
375 {
376 	u32 bytes_avail_towrite;
377 	u32 bytes_avail_toread;
378 	u32 next_read_location = 0;
379 	unsigned long flags;
380 
381 	spin_lock_irqsave(&Inring_info->ring_lock, flags);
382 
383 	hv_get_ringbuffer_availbytes(Inring_info,
384 				&bytes_avail_toread,
385 				&bytes_avail_towrite);
386 
387 	/* Make sure there is something to read */
388 	if (bytes_avail_toread < buflen) {
389 
390 		spin_unlock_irqrestore(&Inring_info->ring_lock, flags);
391 
392 		return -EAGAIN;
393 	}
394 
395 	/* Convert to byte offset */
396 	next_read_location = hv_get_next_read_location(Inring_info);
397 
398 	next_read_location = hv_copyfrom_ringbuffer(Inring_info,
399 						Buffer,
400 						buflen,
401 						next_read_location);
402 
403 	spin_unlock_irqrestore(&Inring_info->ring_lock, flags);
404 
405 	return 0;
406 }
407 
408 
409 /*
410  *
411  * hv_ringbuffer_read()
412  *
413  * Read and advance the read index
414  *
415  */
416 int hv_ringbuffer_read(struct hv_ring_buffer_info *inring_info, void *buffer,
417 		   u32 buflen, u32 offset)
418 {
419 	u32 bytes_avail_towrite;
420 	u32 bytes_avail_toread;
421 	u32 next_read_location = 0;
422 	u64 prev_indices = 0;
423 	unsigned long flags;
424 
425 	if (buflen <= 0)
426 		return -EINVAL;
427 
428 	spin_lock_irqsave(&inring_info->ring_lock, flags);
429 
430 	hv_get_ringbuffer_availbytes(inring_info,
431 				&bytes_avail_toread,
432 				&bytes_avail_towrite);
433 
434 	/* Make sure there is something to read */
435 	if (bytes_avail_toread < buflen) {
436 		spin_unlock_irqrestore(&inring_info->ring_lock, flags);
437 
438 		return -EAGAIN;
439 	}
440 
441 	next_read_location =
442 		hv_get_next_readlocation_withoffset(inring_info, offset);
443 
444 	next_read_location = hv_copyfrom_ringbuffer(inring_info,
445 						buffer,
446 						buflen,
447 						next_read_location);
448 
449 	next_read_location = hv_copyfrom_ringbuffer(inring_info,
450 						&prev_indices,
451 						sizeof(u64),
452 						next_read_location);
453 
454 	/* Make sure all reads are done before we update the read index since */
455 	/* the writer may start writing to the read area once the read index */
456 	/*is updated */
457 	smp_mb();
458 
459 	/* Update the read index */
460 	hv_set_next_read_location(inring_info, next_read_location);
461 
462 	spin_unlock_irqrestore(&inring_info->ring_lock, flags);
463 
464 	return 0;
465 }
466