1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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#include <linux/uio.h>
30
31#include "hyperv_vmbus.h"
32
33void hv_begin_read(struct hv_ring_buffer_info *rbi)
34{
35 rbi->ring_buffer->interrupt_mask = 1;
36 mb();
37}
38
39u32 hv_end_read(struct hv_ring_buffer_info *rbi)
40{
41 u32 read;
42 u32 write;
43
44 rbi->ring_buffer->interrupt_mask = 0;
45 mb();
46
47
48
49
50
51
52 hv_get_ringbuffer_availbytes(rbi, &read, &write);
53
54 return read;
55}
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73static bool hv_need_to_signal(u32 old_write, struct hv_ring_buffer_info *rbi)
74{
75 mb();
76 if (rbi->ring_buffer->interrupt_mask)
77 return false;
78
79
80 rmb();
81
82
83
84
85 if (old_write == rbi->ring_buffer->read_index)
86 return true;
87
88 return false;
89}
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106static bool hv_need_to_signal_on_read(struct hv_ring_buffer_info *rbi)
107{
108 u32 cur_write_sz;
109 u32 r_size;
110 u32 write_loc;
111 u32 read_loc = rbi->ring_buffer->read_index;
112 u32 pending_sz;
113
114
115
116
117
118
119
120
121
122
123
124
125 mb();
126
127 pending_sz = rbi->ring_buffer->pending_send_sz;
128 write_loc = rbi->ring_buffer->write_index;
129
130 if (pending_sz == 0)
131 return false;
132
133 r_size = rbi->ring_datasize;
134 cur_write_sz = write_loc >= read_loc ? r_size - (write_loc - read_loc) :
135 read_loc - write_loc;
136
137 if (cur_write_sz >= pending_sz)
138 return true;
139
140 return false;
141}
142
143
144static inline u32
145hv_get_next_write_location(struct hv_ring_buffer_info *ring_info)
146{
147 u32 next = ring_info->ring_buffer->write_index;
148
149 return next;
150}
151
152
153static inline void
154hv_set_next_write_location(struct hv_ring_buffer_info *ring_info,
155 u32 next_write_location)
156{
157 ring_info->ring_buffer->write_index = next_write_location;
158}
159
160
161static inline u32
162hv_get_next_read_location(struct hv_ring_buffer_info *ring_info)
163{
164 u32 next = ring_info->ring_buffer->read_index;
165
166 return next;
167}
168
169
170
171
172
173static inline u32
174hv_get_next_readlocation_withoffset(struct hv_ring_buffer_info *ring_info,
175 u32 offset)
176{
177 u32 next = ring_info->ring_buffer->read_index;
178
179 next += offset;
180 next %= ring_info->ring_datasize;
181
182 return next;
183}
184
185
186static inline void
187hv_set_next_read_location(struct hv_ring_buffer_info *ring_info,
188 u32 next_read_location)
189{
190 ring_info->ring_buffer->read_index = next_read_location;
191}
192
193
194
195static inline void *
196hv_get_ring_buffer(struct hv_ring_buffer_info *ring_info)
197{
198 return (void *)ring_info->ring_buffer->buffer;
199}
200
201
202
203static inline u32
204hv_get_ring_buffersize(struct hv_ring_buffer_info *ring_info)
205{
206 return ring_info->ring_datasize;
207}
208
209
210static inline u64
211hv_get_ring_bufferindices(struct hv_ring_buffer_info *ring_info)
212{
213 return (u64)ring_info->ring_buffer->write_index << 32;
214}
215
216
217
218
219
220static u32 hv_copyfrom_ringbuffer(
221 struct hv_ring_buffer_info *ring_info,
222 void *dest,
223 u32 destlen,
224 u32 start_read_offset)
225{
226 void *ring_buffer = hv_get_ring_buffer(ring_info);
227 u32 ring_buffer_size = hv_get_ring_buffersize(ring_info);
228
229 u32 frag_len;
230
231
232 if (destlen > ring_buffer_size - start_read_offset) {
233 frag_len = ring_buffer_size - start_read_offset;
234
235 memcpy(dest, ring_buffer + start_read_offset, frag_len);
236 memcpy(dest + frag_len, ring_buffer, destlen - frag_len);
237 } else
238
239 memcpy(dest, ring_buffer + start_read_offset, destlen);
240
241
242 start_read_offset += destlen;
243 start_read_offset %= ring_buffer_size;
244
245 return start_read_offset;
246}
247
248
249
250
251
252
253static u32 hv_copyto_ringbuffer(
254 struct hv_ring_buffer_info *ring_info,
255 u32 start_write_offset,
256 void *src,
257 u32 srclen)
258{
259 void *ring_buffer = hv_get_ring_buffer(ring_info);
260 u32 ring_buffer_size = hv_get_ring_buffersize(ring_info);
261 u32 frag_len;
262
263
264 if (srclen > ring_buffer_size - start_write_offset) {
265 frag_len = ring_buffer_size - start_write_offset;
266 memcpy(ring_buffer + start_write_offset, src, frag_len);
267 memcpy(ring_buffer, src + frag_len, srclen - frag_len);
268 } else
269 memcpy(ring_buffer + start_write_offset, src, srclen);
270
271 start_write_offset += srclen;
272 start_write_offset %= ring_buffer_size;
273
274 return start_write_offset;
275}
276
277
278void hv_ringbuffer_get_debuginfo(struct hv_ring_buffer_info *ring_info,
279 struct hv_ring_buffer_debug_info *debug_info)
280{
281 u32 bytes_avail_towrite;
282 u32 bytes_avail_toread;
283
284 if (ring_info->ring_buffer) {
285 hv_get_ringbuffer_availbytes(ring_info,
286 &bytes_avail_toread,
287 &bytes_avail_towrite);
288
289 debug_info->bytes_avail_toread = bytes_avail_toread;
290 debug_info->bytes_avail_towrite = bytes_avail_towrite;
291 debug_info->current_read_index =
292 ring_info->ring_buffer->read_index;
293 debug_info->current_write_index =
294 ring_info->ring_buffer->write_index;
295 debug_info->current_interrupt_mask =
296 ring_info->ring_buffer->interrupt_mask;
297 }
298}
299
300
301int hv_ringbuffer_init(struct hv_ring_buffer_info *ring_info,
302 void *buffer, u32 buflen)
303{
304 if (sizeof(struct hv_ring_buffer) != PAGE_SIZE)
305 return -EINVAL;
306
307 memset(ring_info, 0, sizeof(struct hv_ring_buffer_info));
308
309 ring_info->ring_buffer = (struct hv_ring_buffer *)buffer;
310 ring_info->ring_buffer->read_index =
311 ring_info->ring_buffer->write_index = 0;
312
313
314 ring_info->ring_buffer->feature_bits.value = 1;
315
316 ring_info->ring_size = buflen;
317 ring_info->ring_datasize = buflen - sizeof(struct hv_ring_buffer);
318
319 spin_lock_init(&ring_info->ring_lock);
320
321 return 0;
322}
323
324
325void hv_ringbuffer_cleanup(struct hv_ring_buffer_info *ring_info)
326{
327}
328
329
330int hv_ringbuffer_write(struct hv_ring_buffer_info *outring_info,
331 struct kvec *kv_list, u32 kv_count, bool *signal, bool lock)
332{
333 int i = 0;
334 u32 bytes_avail_towrite;
335 u32 bytes_avail_toread;
336 u32 totalbytes_towrite = 0;
337
338 u32 next_write_location;
339 u32 old_write;
340 u64 prev_indices = 0;
341 unsigned long flags = 0;
342
343 for (i = 0; i < kv_count; i++)
344 totalbytes_towrite += kv_list[i].iov_len;
345
346 totalbytes_towrite += sizeof(u64);
347
348 if (lock)
349 spin_lock_irqsave(&outring_info->ring_lock, flags);
350
351 hv_get_ringbuffer_availbytes(outring_info,
352 &bytes_avail_toread,
353 &bytes_avail_towrite);
354
355
356
357
358
359
360 if (bytes_avail_towrite <= totalbytes_towrite) {
361 if (lock)
362 spin_unlock_irqrestore(&outring_info->ring_lock, flags);
363 return -EAGAIN;
364 }
365
366
367 next_write_location = hv_get_next_write_location(outring_info);
368
369 old_write = next_write_location;
370
371 for (i = 0; i < kv_count; i++) {
372 next_write_location = hv_copyto_ringbuffer(outring_info,
373 next_write_location,
374 kv_list[i].iov_base,
375 kv_list[i].iov_len);
376 }
377
378
379 prev_indices = hv_get_ring_bufferindices(outring_info);
380
381 next_write_location = hv_copyto_ringbuffer(outring_info,
382 next_write_location,
383 &prev_indices,
384 sizeof(u64));
385
386
387 mb();
388
389
390 hv_set_next_write_location(outring_info, next_write_location);
391
392
393 if (lock)
394 spin_unlock_irqrestore(&outring_info->ring_lock, flags);
395
396 *signal = hv_need_to_signal(old_write, outring_info);
397 return 0;
398}
399
400int hv_ringbuffer_read(struct hv_ring_buffer_info *inring_info,
401 void *buffer, u32 buflen, u32 *buffer_actual_len,
402 u64 *requestid, bool *signal, bool raw)
403{
404 u32 bytes_avail_towrite;
405 u32 bytes_avail_toread;
406 u32 next_read_location = 0;
407 u64 prev_indices = 0;
408 struct vmpacket_descriptor desc;
409 u32 offset;
410 u32 packetlen;
411 int ret = 0;
412
413 if (buflen <= 0)
414 return -EINVAL;
415
416
417 *buffer_actual_len = 0;
418 *requestid = 0;
419
420 hv_get_ringbuffer_availbytes(inring_info,
421 &bytes_avail_toread,
422 &bytes_avail_towrite);
423
424
425 if (bytes_avail_toread < sizeof(desc)) {
426
427
428
429
430 return ret;
431 }
432
433 next_read_location = hv_get_next_read_location(inring_info);
434 next_read_location = hv_copyfrom_ringbuffer(inring_info, &desc,
435 sizeof(desc),
436 next_read_location);
437
438 offset = raw ? 0 : (desc.offset8 << 3);
439 packetlen = (desc.len8 << 3) - offset;
440 *buffer_actual_len = packetlen;
441 *requestid = desc.trans_id;
442
443 if (bytes_avail_toread < packetlen + offset)
444 return -EAGAIN;
445
446 if (packetlen > buflen)
447 return -ENOBUFS;
448
449 next_read_location =
450 hv_get_next_readlocation_withoffset(inring_info, offset);
451
452 next_read_location = hv_copyfrom_ringbuffer(inring_info,
453 buffer,
454 packetlen,
455 next_read_location);
456
457 next_read_location = hv_copyfrom_ringbuffer(inring_info,
458 &prev_indices,
459 sizeof(u64),
460 next_read_location);
461
462
463
464
465
466
467 mb();
468
469
470 hv_set_next_read_location(inring_info, next_read_location);
471
472 *signal = hv_need_to_signal_on_read(inring_info);
473
474 return ret;
475}
476