drivers/virtio/virtio_ring.c

   1 /* Virtio ring implementation.
   2  *
   3  *  Copyright 2007 Rusty Russell IBM Corporation
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19 #include <linux/virtio.h>
  20 #include <linux/virtio_ring.h>
  21 #include <linux/virtio_config.h>
  22 #include <linux/device.h>
  23 #include <linux/slab.h>
  24 #include <linux/module.h>
  25 #include <linux/hrtimer.h>
  26
  27 /* virtio guest is communicating with a virtual "device" that actually runs on
  28  * a host processor.  Memory barriers are used to control SMP effects. */
  29 #ifdef CONFIG_SMP
  30 /* Where possible, use SMP barriers which are more lightweight than mandatory
  31  * barriers, because mandatory barriers control MMIO effects on accesses
  32  * through relaxed memory I/O windows (which virtio-pci does not use). */
  33 #define virtio_mb(vq) \
  34         do { if ((vq)->weak_barriers) smp_mb(); else mb(); } while(0)
  35 #define virtio_rmb(vq) \
  36         do { if ((vq)->weak_barriers) smp_rmb(); else rmb(); } while(0)
  37 #define virtio_wmb(vq) \
  38         do { if ((vq)->weak_barriers) smp_wmb(); else wmb(); } while(0)
  39 #else
  40 /* We must force memory ordering even if guest is UP since host could be
  41  * running on another CPU, but SMP barriers are defined to barrier() in that
  42  * configuration. So fall back to mandatory barriers instead. */
  43 #define virtio_mb(vq) mb()
  44 #define virtio_rmb(vq) rmb()
  45 #define virtio_wmb(vq) wmb()
  46 #endif
  47
  48 #ifdef DEBUG
  49 /* For development, we want to crash whenever the ring is screwed. */
  50 #define BAD_RING(_vq, fmt, args...)                             \
  51         do {                                                    \
  52                 dev_err(&(_vq)->vq.vdev->dev,                   \
  53                         "%s:"fmt, (_vq)->vq.name, ##args);      \
  54                 BUG();                                          \
  55         } while (0)
  56 /* Caller is supposed to guarantee no reentry. */
  57 #define START_USE(_vq)                                          \
  58         do {                                                    \
  59                 if ((_vq)->in_use)                              \
  60                         panic("%s:in_use = %i\n",               \
  61                               (_vq)->vq.name, (_vq)->in_use);   \
  62                 (_vq)->in_use = __LINE__;                       \
  63         } while (0)
  64 #define END_USE(_vq) \
  65         do { BUG_ON(!(_vq)->in_use); (_vq)->in_use = 0; } while(0)
  66 #else
  67 #define BAD_RING(_vq, fmt, args...)                             \
  68         do {                                                    \
  69                 dev_err(&_vq->vq.vdev->dev,                     \
  70                         "%s:"fmt, (_vq)->vq.name, ##args);      \
  71                 (_vq)->broken = true;                           \
  72         } while (0)
  73 #define START_USE(vq)
  74 #define END_USE(vq)
  75 #endif
  76
  77 struct vring_virtqueue
  78 {
  79         struct virtqueue vq;
  80
  81         /* Actual memory layout for this queue */
  82         struct vring vring;
  83
  84         /* Can we use weak barriers? */
  85         bool weak_barriers;
  86
  87         /* Other side has made a mess, don't try any more. */
  88         bool broken;
  89
  90         /* Host supports indirect buffers */
  91         bool indirect;
  92
  93         /* Host publishes avail event idx */
  94         bool event;
  95
  96         /* Head of free buffer list. */
  97         unsigned int free_head;
  98         /* Number we've added since last sync. */
  99         unsigned int num_added;
 100
 101         /* Last used index we've seen. */
 102         u16 last_used_idx;
 103
 104         /* How to notify other side. FIXME: commonalize hcalls! */
 105         void (*notify)(struct virtqueue *vq);
 106
 107 #ifdef DEBUG
 108         /* They're supposed to lock for us. */
 109         unsigned int in_use;
 110
 111         /* Figure out if their kicks are too delayed. */
 112         bool last_add_time_valid;
 113         ktime_t last_add_time;
 114 #endif
 115
 116         /* Tokens for callbacks. */
 117         void *data[];
 118 };
 119
 120 #define to_vvq(_vq) container_of(_vq, struct vring_virtqueue, vq)
 121
 122 /* Set up an indirect table of descriptors and add it to the queue. */
 123 static int vring_add_indirect(struct vring_virtqueue *vq,
 124                               struct scatterlist sg[],
 125                               unsigned int out,
 126                               unsigned int in,
 127                               gfp_t gfp)
 128 {
 129         struct vring_desc *desc;
 130         unsigned head;
 131         int i;
 132
 133         /*
 134          * We require lowmem mappings for the descriptors because
 135          * otherwise virt_to_phys will give us bogus addresses in the
 136          * virtqueue.
 137          */
 138         gfp &= ~(__GFP_HIGHMEM | __GFP_HIGH);
 139
 140         desc = kmalloc((out + in) * sizeof(struct vring_desc), gfp);
 141         if (!desc)
 142                 return -ENOMEM;
 143
 144         /* Transfer entries from the sg list into the indirect page */
 145         for (i = 0; i < out; i++) {
 146                 desc[i].flags = VRING_DESC_F_NEXT;
 147                 desc[i].addr = sg_phys(sg);
 148                 desc[i].len = sg->length;
 149                 desc[i].next = i+1;
 150                 sg++;
 151         }
 152         for (; i < (out + in); i++) {
 153                 desc[i].flags = VRING_DESC_F_NEXT|VRING_DESC_F_WRITE;
 154                 desc[i].addr = sg_phys(sg);
 155                 desc[i].len = sg->length;
 156                 desc[i].next = i+1;
 157                 sg++;
 158         }
 159
 160         /* Last one doesn't continue. */
 161         desc[i-1].flags &= ~VRING_DESC_F_NEXT;
 162         desc[i-1].next = 0;
 163
 164         /* We're about to use a buffer */
 165         vq->vq.num_free--;
 166
 167         /* Use a single buffer which doesn't continue */
 168         head = vq->free_head;
 169         vq->vring.desc[head].flags = VRING_DESC_F_INDIRECT;
 170         vq->vring.desc[head].addr = virt_to_phys(desc);
 171         vq->vring.desc[head].len = i * sizeof(struct vring_desc);
 172
 173         /* Update free pointer */
 174         vq->free_head = vq->vring.desc[head].next;
 175
 176         return head;
 177 }
 178
 179 /**
 180  * virtqueue_add_buf - expose buffer to other end
 181  * @vq: the struct virtqueue we're talking about.
 182  * @sg: the description of the buffer(s).
 183  * @out_num: the number of sg readable by other side
 184  * @in_num: the number of sg which are writable (after readable ones)
 185  * @data: the token identifying the buffer.
 186  * @gfp: how to do memory allocations (if necessary).
 187  *
 188  * Caller must ensure we don't call this with other virtqueue operations
 189  * at the same time (except where noted).
 190  *
 191  * Returns zero or a negative error (ie. ENOSPC, ENOMEM).
 192  */
 193 int virtqueue_add_buf(struct virtqueue *_vq,
 194                       struct scatterlist sg[],
 195                       unsigned int out,
 196                       unsigned int in,
 197                       void *data,
 198                       gfp_t gfp)
 199 {
 200         struct vring_virtqueue *vq = to_vvq(_vq);
 201         unsigned int i, avail, uninitialized_var(prev);
 202         int head;
 203
 204         START_USE(vq);
 205
 206         BUG_ON(data == NULL);
 207
 208 #ifdef DEBUG
 209         {
 210                 ktime_t now = ktime_get();
 211
 212                 /* No kick or get, with .1 second between?  Warn. */
 213                 if (vq->last_add_time_valid)
 214                         WARN_ON(ktime_to_ms(ktime_sub(now, vq->last_add_time))
 215                                             > 100);
 216                 vq->last_add_time = now;
 217                 vq->last_add_time_valid = true;
 218         }
 219 #endif
 220
 221         /* If the host supports indirect descriptor tables, and we have multiple
 222          * buffers, then go indirect. FIXME: tune this threshold */
 223         if (vq->indirect && (out + in) > 1 && vq->vq.num_free) {
 224                 head = vring_add_indirect(vq, sg, out, in, gfp);
 225                 if (likely(head >= 0))
 226                         goto add_head;
 227         }
 228
 229         BUG_ON(out + in > vq->vring.num);
 230         BUG_ON(out + in == 0);
 231
 232         if (vq->vq.num_free < out + in) {
 233                 pr_debug("Can't add buf len %i - avail = %i\n",
 234                          out + in, vq->vq.num_free);
 235                 /* FIXME: for historical reasons, we force a notify here if
 236                  * there are outgoing parts to the buffer.  Presumably the
 237                  * host should service the ring ASAP. */
 238                 if (out)
 239                         vq->notify(&vq->vq);
 240                 END_USE(vq);
 241                 return -ENOSPC;
 242         }
 243
 244         /* We're about to use some buffers from the free list. */
 245         vq->vq.num_free -= out + in;
 246
 247         head = vq->free_head;
 248         for (i = vq->free_head; out; i = vq->vring.desc[i].next, out--) {
 249                 vq->vring.desc[i].flags = VRING_DESC_F_NEXT;
 250                 vq->vring.desc[i].addr = sg_phys(sg);
 251                 vq->vring.desc[i].len = sg->length;
 252                 prev = i;
 253                 sg++;
 254         }
 255         for (; in; i = vq->vring.desc[i].next, in--) {
 256                 vq->vring.desc[i].flags = VRING_DESC_F_NEXT|VRING_DESC_F_WRITE;
 257                 vq->vring.desc[i].addr = sg_phys(sg);
 258                 vq->vring.desc[i].len = sg->length;
 259                 prev = i;
 260                 sg++;
 261         }
 262         /* Last one doesn't continue. */
 263         vq->vring.desc[prev].flags &= ~VRING_DESC_F_NEXT;
 264
 265         /* Update free pointer */
 266         vq->free_head = i;
 267
 268 add_head:
 269         /* Set token. */
 270         vq->data[head] = data;
 271
 272         /* Put entry in available array (but don't update avail->idx until they
 273          * do sync). */
 274         avail = (vq->vring.avail->idx & (vq->vring.num-1));
 275         vq->vring.avail->ring[avail] = head;
 276
 277         /* Descriptors and available array need to be set before we expose the
 278          * new available array entries. */
 279         virtio_wmb(vq);
 280         vq->vring.avail->idx++;
 281         vq->num_added++;
 282
 283         /* This is very unlikely, but theoretically possible.  Kick
 284          * just in case. */
 285         if (unlikely(vq->num_added == (1 << 16) - 1))
 286                 virtqueue_kick(_vq);
 287
 288         pr_debug("Added buffer head %i to %p\n", head, vq);
 289         END_USE(vq);
 290
 291         return 0;
 292 }
 293 EXPORT_SYMBOL_GPL(virtqueue_add_buf);
 294
 295 /**
 296  * virtqueue_kick_prepare - first half of split virtqueue_kick call.
 297  * @vq: the struct virtqueue
 298  *
 299  * Instead of virtqueue_kick(), you can do:
 300  *      if (virtqueue_kick_prepare(vq))
 301  *              virtqueue_notify(vq);
 302  *
 303  * This is sometimes useful because the virtqueue_kick_prepare() needs
 304  * to be serialized, but the actual virtqueue_notify() call does not.
 305  */
 306 bool virtqueue_kick_prepare(struct virtqueue *_vq)
 307 {
 308         struct vring_virtqueue *vq = to_vvq(_vq);
 309         u16 new, old;
 310         bool needs_kick;
 311
 312         START_USE(vq);
 313         /* We need to expose available array entries before checking avail
 314          * event. */
 315         virtio_mb(vq);
 316
 317         old = vq->vring.avail->idx - vq->num_added;
 318         new = vq->vring.avail->idx;
 319         vq->num_added = 0;
 320
 321 #ifdef DEBUG
 322         if (vq->last_add_time_valid) {
 323                 WARN_ON(ktime_to_ms(ktime_sub(ktime_get(),
 324                                               vq->last_add_time)) > 100);
 325         }
 326         vq->last_add_time_valid = false;
 327 #endif
 328
 329         if (vq->event) {
 330                 needs_kick = vring_need_event(vring_avail_event(&vq->vring),
 331                                               new, old);
 332         } else {
 333                 needs_kick = !(vq->vring.used->flags & VRING_USED_F_NO_NOTIFY);
 334         }
 335         END_USE(vq);
 336         return needs_kick;
 337 }
 338 EXPORT_SYMBOL_GPL(virtqueue_kick_prepare);
 339
 340 /**
 341  * virtqueue_notify - second half of split virtqueue_kick call.
 342  * @vq: the struct virtqueue
 343  *
 344  * This does not need to be serialized.
 345  */
 346 void virtqueue_notify(struct virtqueue *_vq)
 347 {
 348         struct vring_virtqueue *vq = to_vvq(_vq);
 349
 350         /* Prod other side to tell it about changes. */
 351         vq->notify(_vq);
 352 }
 353 EXPORT_SYMBOL_GPL(virtqueue_notify);
 354
 355 /**
 356  * virtqueue_kick - update after add_buf
 357  * @vq: the struct virtqueue
 358  *
 359  * After one or more virtqueue_add_buf calls, invoke this to kick
 360  * the other side.
 361  *
 362  * Caller must ensure we don't call this with other virtqueue
 363  * operations at the same time (except where noted).
 364  */
 365 void virtqueue_kick(struct virtqueue *vq)
 366 {
 367         if (virtqueue_kick_prepare(vq))
 368                 virtqueue_notify(vq);
 369 }
 370 EXPORT_SYMBOL_GPL(virtqueue_kick);
 371
 372 static void detach_buf(struct vring_virtqueue *vq, unsigned int head)
 373 {
 374         unsigned int i;
 375
 376         /* Clear data ptr. */
 377         vq->data[head] = NULL;
 378
 379         /* Put back on free list: find end */
 380         i = head;
 381
 382         /* Free the indirect table */
 383         if (vq->vring.desc[i].flags & VRING_DESC_F_INDIRECT)
 384                 kfree(phys_to_virt(vq->vring.desc[i].addr));
 385
 386         while (vq->vring.desc[i].flags & VRING_DESC_F_NEXT) {
 387                 i = vq->vring.desc[i].next;
 388                 vq->vq.num_free++;
 389         }
 390
 391         vq->vring.desc[i].next = vq->free_head;
 392         vq->free_head = head;
 393         /* Plus final descriptor */
 394         vq->vq.num_free++;
 395 }
 396
 397 static inline bool more_used(const struct vring_virtqueue *vq)
 398 {
 399         return vq->last_used_idx != vq->vring.used->idx;
 400 }
 401
 402 /**
 403  * virtqueue_get_buf - get the next used buffer
 404  * @vq: the struct virtqueue we're talking about.
 405  * @len: the length written into the buffer
 406  *
 407  * If the driver wrote data into the buffer, @len will be set to the
 408  * amount written.  This means you don't need to clear the buffer
 409  * beforehand to ensure there's no data leakage in the case of short
 410  * writes.
 411  *
 412  * Caller must ensure we don't call this with other virtqueue
 413  * operations at the same time (except where noted).
 414  *
 415  * Returns NULL if there are no used buffers, or the "data" token
 416  * handed to virtqueue_add_buf().
 417  */
 418 void *virtqueue_get_buf(struct virtqueue *_vq, unsigned int *len)
 419 {
 420         struct vring_virtqueue *vq = to_vvq(_vq);
 421         void *ret;
 422         unsigned int i;
 423         u16 last_used;
 424
 425         START_USE(vq);
 426
 427         if (unlikely(vq->broken)) {
 428                 END_USE(vq);
 429                 return NULL;
 430         }
 431
 432         if (!more_used(vq)) {
 433                 pr_debug("No more buffers in queue\n");
 434                 END_USE(vq);
 435                 return NULL;
 436         }
 437
 438         /* Only get used array entries after they have been exposed by host. */
 439         virtio_rmb(vq);
 440
 441         last_used = (vq->last_used_idx & (vq->vring.num - 1));
 442         i = vq->vring.used->ring[last_used].id;
 443         *len = vq->vring.used->ring[last_used].len;
 444
 445         if (unlikely(i >= vq->vring.num)) {
 446                 BAD_RING(vq, "id %u out of range\n", i);
 447                 return NULL;
 448         }
 449         if (unlikely(!vq->data[i])) {
 450                 BAD_RING(vq, "id %u is not a head!\n", i);
 451                 return NULL;
 452         }
 453
 454         /* detach_buf clears data, so grab it now. */
 455         ret = vq->data[i];
 456         detach_buf(vq, i);
 457         vq->last_used_idx++;
 458         /* If we expect an interrupt for the next entry, tell host
 459          * by writing event index and flush out the write before
 460          * the read in the next get_buf call. */
 461         if (!(vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT)) {
 462                 vring_used_event(&vq->vring) = vq->last_used_idx;
 463                 virtio_mb(vq);
 464         }
 465
 466 #ifdef DEBUG
 467         vq->last_add_time_valid = false;
 468 #endif
 469
 470         END_USE(vq);
 471         return ret;
 472 }
 473 EXPORT_SYMBOL_GPL(virtqueue_get_buf);
 474
 475 /**
 476  * virtqueue_disable_cb - disable callbacks
 477  * @vq: the struct virtqueue we're talking about.
 478  *
 479  * Note that this is not necessarily synchronous, hence unreliable and only
 480  * useful as an optimization.
 481  *
 482  * Unlike other operations, this need not be serialized.
 483  */
 484 void virtqueue_disable_cb(struct virtqueue *_vq)
 485 {
 486         struct vring_virtqueue *vq = to_vvq(_vq);
 487
 488         vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
 489 }
 490 EXPORT_SYMBOL_GPL(virtqueue_disable_cb);
 491
 492 /**
 493  * virtqueue_enable_cb - restart callbacks after disable_cb.
 494  * @vq: the struct virtqueue we're talking about.
 495  *
 496  * This re-enables callbacks; it returns "false" if there are pending
 497  * buffers in the queue, to detect a possible race between the driver
 498  * checking for more work, and enabling callbacks.
 499  *
 500  * Caller must ensure we don't call this with other virtqueue
 501  * operations at the same time (except where noted).
 502  */
 503 bool virtqueue_enable_cb(struct virtqueue *_vq)
 504 {
 505         struct vring_virtqueue *vq = to_vvq(_vq);
 506
 507         START_USE(vq);
 508
 509         /* We optimistically turn back on interrupts, then check if there was
 510          * more to do. */
 511         /* Depending on the VIRTIO_RING_F_EVENT_IDX feature, we need to
 512          * either clear the flags bit or point the event index at the next
 513          * entry. Always do both to keep code simple. */
 514         vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
 515         vring_used_event(&vq->vring) = vq->last_used_idx;
 516         virtio_mb(vq);
 517         if (unlikely(more_used(vq))) {
 518                 END_USE(vq);
 519                 return false;
 520         }
 521
 522         END_USE(vq);
 523         return true;
 524 }
 525 EXPORT_SYMBOL_GPL(virtqueue_enable_cb);
 526
 527 /**
 528  * virtqueue_enable_cb_delayed - restart callbacks after disable_cb.
 529  * @vq: the struct virtqueue we're talking about.
 530  *
 531  * This re-enables callbacks but hints to the other side to delay
 532  * interrupts until most of the available buffers have been processed;
 533  * it returns "false" if there are many pending buffers in the queue,
 534  * to detect a possible race between the driver checking for more work,
 535  * and enabling callbacks.
 536  *
 537  * Caller must ensure we don't call this with other virtqueue
 538  * operations at the same time (except where noted).
 539  */
 540 bool virtqueue_enable_cb_delayed(struct virtqueue *_vq)
 541 {
 542         struct vring_virtqueue *vq = to_vvq(_vq);
 543         u16 bufs;
 544
 545         START_USE(vq);
 546
 547         /* We optimistically turn back on interrupts, then check if there was
 548          * more to do. */
 549         /* Depending on the VIRTIO_RING_F_USED_EVENT_IDX feature, we need to
 550          * either clear the flags bit or point the event index at the next
 551          * entry. Always do both to keep code simple. */
 552         vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
 553         /* TODO: tune this threshold */
 554         bufs = (u16)(vq->vring.avail->idx - vq->last_used_idx) * 3 / 4;
 555         vring_used_event(&vq->vring) = vq->last_used_idx + bufs;
 556         virtio_mb(vq);
 557         if (unlikely((u16)(vq->vring.used->idx - vq->last_used_idx) > bufs)) {
 558                 END_USE(vq);
 559                 return false;
 560         }
 561
 562         END_USE(vq);
 563         return true;
 564 }
 565 EXPORT_SYMBOL_GPL(virtqueue_enable_cb_delayed);
 566
 567 /**
 568  * virtqueue_detach_unused_buf - detach first unused buffer
 569  * @vq: the struct virtqueue we're talking about.
 570  *
 571  * Returns NULL or the "data" token handed to virtqueue_add_buf().
 572  * This is not valid on an active queue; it is useful only for device
 573  * shutdown.
 574  */
 575 void *virtqueue_detach_unused_buf(struct virtqueue *_vq)
 576 {
 577         struct vring_virtqueue *vq = to_vvq(_vq);
 578         unsigned int i;
 579         void *buf;
 580
 581         START_USE(vq);
 582
 583         for (i = 0; i < vq->vring.num; i++) {
 584                 if (!vq->data[i])
 585                         continue;
 586                 /* detach_buf clears data, so grab it now. */
 587                 buf = vq->data[i];
 588                 detach_buf(vq, i);
 589                 vq->vring.avail->idx--;
 590                 END_USE(vq);
 591                 return buf;
 592         }
 593         /* That should have freed everything. */
 594         BUG_ON(vq->vq.num_free != vq->vring.num);
 595
 596         END_USE(vq);
 597         return NULL;
 598 }
 599 EXPORT_SYMBOL_GPL(virtqueue_detach_unused_buf);
 600
 601 irqreturn_t vring_interrupt(int irq, void *_vq)
 602 {
 603         struct vring_virtqueue *vq = to_vvq(_vq);
 604
 605         if (!more_used(vq)) {
 606                 pr_debug("virtqueue interrupt with no work for %p\n", vq);
 607                 return IRQ_NONE;
 608         }
 609
 610         if (unlikely(vq->broken))
 611                 return IRQ_HANDLED;
 612
 613         pr_debug("virtqueue callback for %p (%p)\n", vq, vq->vq.callback);
 614         if (vq->vq.callback)
 615                 vq->vq.callback(&vq->vq);
 616
 617         return IRQ_HANDLED;
 618 }
 619 EXPORT_SYMBOL_GPL(vring_interrupt);
 620
 621 struct virtqueue *vring_new_virtqueue(unsigned int index,
 622                                       unsigned int num,
 623                                       unsigned int vring_align,
 624                                       struct virtio_device *vdev,
 625                                       bool weak_barriers,
 626                                       void *pages,
 627                                       void (*notify)(struct virtqueue *),
 628                                       void (*callback)(struct virtqueue *),
 629                                       const char *name)
 630 {
 631         struct vring_virtqueue *vq;
 632         unsigned int i;
 633
 634         /* We assume num is a power of 2. */
 635         if (num & (num - 1)) {
 636                 dev_warn(&vdev->dev, "Bad virtqueue length %u\n", num);
 637                 return NULL;
 638         }
 639
 640         vq = kmalloc(sizeof(*vq) + sizeof(void *)*num, GFP_KERNEL);
 641         if (!vq)
 642                 return NULL;
 643
 644         vring_init(&vq->vring, num, pages, vring_align);
 645         vq->vq.callback = callback;
 646         vq->vq.vdev = vdev;
 647         vq->vq.name = name;
 648         vq->vq.num_free = num;
 649         vq->vq.index = index;
 650         vq->notify = notify;
 651         vq->weak_barriers = weak_barriers;
 652         vq->broken = false;
 653         vq->last_used_idx = 0;
 654         vq->num_added = 0;
 655         list_add_tail(&vq->vq.list, &vdev->vqs);
 656 #ifdef DEBUG
 657         vq->in_use = false;
 658         vq->last_add_time_valid = false;
 659 #endif
 660
 661         vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC);
 662         vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
 663
 664         /* No callback?  Tell other side not to bother us. */
 665         if (!callback)
 666                 vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
 667
 668         /* Put everything in free lists. */
 669         vq->free_head = 0;
 670         for (i = 0; i < num-1; i++) {
 671                 vq->vring.desc[i].next = i+1;
 672                 vq->data[i] = NULL;
 673         }
 674         vq->data[i] = NULL;
 675
 676         return &vq->vq;
 677 }
 678 EXPORT_SYMBOL_GPL(vring_new_virtqueue);
 679
 680 void vring_del_virtqueue(struct virtqueue *vq)
 681 {
 682         list_del(&vq->list);
 683         kfree(to_vvq(vq));
 684 }
 685 EXPORT_SYMBOL_GPL(vring_del_virtqueue);
 686
 687 /* Manipulates transport-specific feature bits. */
 688 void vring_transport_features(struct virtio_device *vdev)
 689 {
 690         unsigned int i;
 691
 692         for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++) {
 693                 switch (i) {
 694                 case VIRTIO_RING_F_INDIRECT_DESC:
 695                         break;
 696                 case VIRTIO_RING_F_EVENT_IDX:
 697                         break;
 698                 default:
 699                         /* We don't understand this bit. */
 700                         clear_bit(i, vdev->features);
 701                 }
 702         }
 703 }
 704 EXPORT_SYMBOL_GPL(vring_transport_features);
 705
 706 /**
 707  * virtqueue_get_vring_size - return the size of the virtqueue's vring
 708  * @vq: the struct virtqueue containing the vring of interest.
 709  *
 710  * Returns the size of the vring.  This is mainly used for boasting to
 711  * userspace.  Unlike other operations, this need not be serialized.
 712  */
 713 unsigned int virtqueue_get_vring_size(struct virtqueue *_vq)
 714 {
 715
 716         struct vring_virtqueue *vq = to_vvq(_vq);
 717
 718         return vq->vring.num;
 719 }
 720 EXPORT_SYMBOL_GPL(virtqueue_get_vring_size);
 721
 722 MODULE_LICENSE("GPL");