drivers/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 #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 }