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