drivers/staging/hv/ring_buffer.c

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