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 #include <linux/kmemleak.h>
  27
  28 #ifdef DEBUG
  29 /* For development, we want to crash whenever the ring is screwed. */
  30 #define BAD_RING(_vq, fmt, args...)                             \
  31         do {                                                    \
  32                 dev_err(&(_vq)->vq.vdev->dev,                   \
  33                         "%s:"fmt, (_vq)->vq.name, ##args);      \
  34                 BUG();                                          \
  35         } while (0)
  36 /* Caller is supposed to guarantee no reentry. */
  37 #define START_USE(_vq)                                          \
  38         do {                                                    \
  39                 if ((_vq)->in_use)                              \
  40                         panic("%s:in_use = %i\n",               \
  41                               (_vq)->vq.name, (_vq)->in_use);   \
  42                 (_vq)->in_use = __LINE__;                       \
  43         } while (0)
  44 #define END_USE(_vq) \
  45         do { BUG_ON(!(_vq)->in_use); (_vq)->in_use = 0; } while(0)
  46 #else
  47 #define BAD_RING(_vq, fmt, args...)                             \
  48         do {                                                    \
  49                 dev_err(&_vq->vq.vdev->dev,                     \
  50                         "%s:"fmt, (_vq)->vq.name, ##args);      \
  51                 (_vq)->broken = true;                           \
  52         } while (0)
  53 #define START_USE(vq)
  54 #define END_USE(vq)
  55 #endif
  56
  57 struct vring_virtqueue
  58 {
  59         struct virtqueue vq;
  60
  61         /* Actual memory layout for this queue */
  62         struct vring vring;
  63
  64         /* Can we use weak barriers? */
  65         bool weak_barriers;
  66
  67         /* Other side has made a mess, don't try any more. */
  68         bool broken;
  69
  70         /* Host supports indirect buffers */
  71         bool indirect;
  72
  73         /* Host publishes avail event idx */
  74         bool event;
  75
  76         /* Head of free buffer list. */
  77         unsigned int free_head;
  78         /* Number we've added since last sync. */
  79         unsigned int num_added;
  80
  81         /* Last used index we've seen. */
  82         u16 last_used_idx;
  83
  84         /* How to notify other side. FIXME: commonalize hcalls! */
  85         bool (*notify)(struct virtqueue *vq);
  86
  87 #ifdef DEBUG
  88         /* They're supposed to lock for us. */
  89         unsigned int in_use;
  90
  91         /* Figure out if their kicks are too delayed. */
  92         bool last_add_time_valid;
  93         ktime_t last_add_time;
  94 #endif
  95
  96         /* Tokens for callbacks. */
  97         void *data[];
  98 };
  99
 100 #define to_vvq(_vq) container_of(_vq, struct vring_virtqueue, vq)
 101
 102 static inline struct scatterlist *sg_next_chained(struct scatterlist *sg,
 103                                                   unsigned int *count)
 104 {
 105         return sg_next(sg);
 106 }
 107
 108 static inline struct scatterlist *sg_next_arr(struct scatterlist *sg,
 109                                               unsigned int *count)
 110 {
 111         if (--(*count) == 0)
 112                 return NULL;
 113         return sg + 1;
 114 }
 115
 116 /* Set up an indirect table of descriptors and add it to the queue. */
 117 static inline int vring_add_indirect(struct vring_virtqueue *vq,
 118                                      struct scatterlist *sgs[],
 119                                      struct scatterlist *(*next)
 120                                        (struct scatterlist *, unsigned int *),
 121                                      unsigned int total_sg,
 122                                      unsigned int total_out,
 123                                      unsigned int total_in,
 124                                      unsigned int out_sgs,
 125                                      unsigned int in_sgs,
 126                                      gfp_t gfp)
 127 {
 128         struct vring_desc *desc;
 129         unsigned head;
 130         struct scatterlist *sg;
 131         int i, n;
 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(total_sg * sizeof(struct vring_desc), gfp);
 141         if (!desc)
 142                 return -ENOMEM;
 143
 144         /* Transfer entries from the sg lists into the indirect page */
 145         i = 0;
 146         for (n = 0; n < out_sgs; n++) {
 147                 for (sg = sgs[n]; sg; sg = next(sg, &total_out)) {
 148                         desc[i].flags = VRING_DESC_F_NEXT;
 149                         desc[i].addr = sg_phys(sg);
 150                         desc[i].len = sg->length;
 151                         desc[i].next = i+1;
 152                         i++;
 153                 }
 154         }
 155         for (; n < (out_sgs + in_sgs); n++) {
 156                 for (sg = sgs[n]; sg; sg = next(sg, &total_in)) {
 157                         desc[i].flags = VRING_DESC_F_NEXT|VRING_DESC_F_WRITE;
 158                         desc[i].addr = sg_phys(sg);
 159                         desc[i].len = sg->length;
 160                         desc[i].next = i+1;
 161                         i++;
 162                 }
 163         }
 164         BUG_ON(i != total_sg);
 165
 166         /* Last one doesn't continue. */
 167         desc[i-1].flags &= ~VRING_DESC_F_NEXT;
 168         desc[i-1].next = 0;
 169
 170         /* We're about to use a buffer */
 171         vq->vq.num_free--;
 172
 173         /* Use a single buffer which doesn't continue */
 174         head = vq->free_head;
 175         vq->vring.desc[head].flags = VRING_DESC_F_INDIRECT;
 176         vq->vring.desc[head].addr = virt_to_phys(desc);
 177         /* kmemleak gives a false positive, as it's hidden by virt_to_phys */
 178         kmemleak_ignore(desc);
 179         vq->vring.desc[head].len = i * sizeof(struct vring_desc);
 180
 181         /* Update free pointer */
 182         vq->free_head = vq->vring.desc[head].next;
 183
 184         return head;
 185 }
 186
 187 static inline int virtqueue_add(struct virtqueue *_vq,
 188                                 struct scatterlist *sgs[],
 189                                 struct scatterlist *(*next)
 190                                   (struct scatterlist *, unsigned int *),
 191                                 unsigned int total_out,
 192                                 unsigned int total_in,
 193                                 unsigned int out_sgs,
 194                                 unsigned int in_sgs,
 195                                 void *data,
 196                                 gfp_t gfp)
 197 {
 198         struct vring_virtqueue *vq = to_vvq(_vq);
 199         struct scatterlist *sg;
 200         unsigned int i, n, avail, uninitialized_var(prev), total_sg;
 201         int head;
 202
 203         START_USE(vq);
 204
 205         BUG_ON(data == NULL);
 206
 207         if (unlikely(vq->broken)) {
 208                 END_USE(vq);
 209                 return -EIO;
 210         }
 211
 212 #ifdef DEBUG
 213         {
 214                 ktime_t now = ktime_get();
 215
 216                 /* No kick or get, with .1 second between?  Warn. */
 217                 if (vq->last_add_time_valid)
 218                         WARN_ON(ktime_to_ms(ktime_sub(now, vq->last_add_time))
 219                                             > 100);
 220                 vq->last_add_time = now;
 221                 vq->last_add_time_valid = true;
 222         }
 223 #endif
 224
 225         total_sg = total_in + total_out;
 226
 227         /* If the host supports indirect descriptor tables, and we have multiple
 228          * buffers, then go indirect. FIXME: tune this threshold */
 229         if (vq->indirect && total_sg > 1 && vq->vq.num_free) {
 230                 head = vring_add_indirect(vq, sgs, next, total_sg, total_out,
 231                                           total_in,
 232                                           out_sgs, in_sgs, gfp);
 233                 if (likely(head >= 0))
 234                         goto add_head;
 235         }
 236
 237         BUG_ON(total_sg > vq->vring.num);
 238         BUG_ON(total_sg == 0);
 239
 240         if (vq->vq.num_free < total_sg) {
 241                 pr_debug("Can't add buf len %i - avail = %i\n",
 242                          total_sg, vq->vq.num_free);
 243                 /* FIXME: for historical reasons, we force a notify here if
 244                  * there are outgoing parts to the buffer.  Presumably the
 245                  * host should service the ring ASAP. */
 246                 if (out_sgs)
 247                         vq->notify(&vq->vq);
 248                 END_USE(vq);
 249                 return -ENOSPC;
 250         }
 251
 252         /* We're about to use some buffers from the free list. */
 253         vq->vq.num_free -= total_sg;
 254
 255         head = i = vq->free_head;
 256         for (n = 0; n < out_sgs; n++) {
 257                 for (sg = sgs[n]; sg; sg = next(sg, &total_out)) {
 258                         vq->vring.desc[i].flags = VRING_DESC_F_NEXT;
 259                         vq->vring.desc[i].addr = sg_phys(sg);
 260                         vq->vring.desc[i].len = sg->length;
 261                         prev = i;
 262                         i = vq->vring.desc[i].next;
 263                 }
 264         }
 265         for (; n < (out_sgs + in_sgs); n++) {
 266                 for (sg = sgs[n]; sg; sg = next(sg, &total_in)) {
 267                         vq->vring.desc[i].flags = VRING_DESC_F_NEXT|VRING_DESC_F_WRITE;
 268                         vq->vring.desc[i].addr = sg_phys(sg);
 269                         vq->vring.desc[i].len = sg->length;
 270                         prev = i;
 271                         i = vq->vring.desc[i].next;
 272                 }
 273         }
 274         /* Last one doesn't continue. */
 275         vq->vring.desc[prev].flags &= ~VRING_DESC_F_NEXT;
 276
 277         /* Update free pointer */
 278         vq->free_head = i;
 279
 280 add_head:
 281         /* Set token. */
 282         vq->data[head] = data;
 283
 284         /* Put entry in available array (but don't update avail->idx until they
 285          * do sync). */
 286         avail = (vq->vring.avail->idx & (vq->vring.num-1));
 287         vq->vring.avail->ring[avail] = head;
 288
 289         /* Descriptors and available array need to be set before we expose the
 290          * new available array entries. */
 291         virtio_wmb(vq->weak_barriers);
 292         vq->vring.avail->idx++;
 293         vq->num_added++;
 294
 295         /* This is very unlikely, but theoretically possible.  Kick
 296          * just in case. */
 297         if (unlikely(vq->num_added == (1 << 16) - 1))
 298                 virtqueue_kick(_vq);
 299
 300         pr_debug("Added buffer head %i to %p\n", head, vq);
 301         END_USE(vq);
 302
 303         return 0;
 304 }
 305
 306 /**
 307  * virtqueue_add_sgs - expose buffers to other end
 308  * @vq: the struct virtqueue we're talking about.
 309  * @sgs: array of terminated scatterlists.
 310  * @out_num: the number of scatterlists readable by other side
 311  * @in_num: the number of scatterlists which are writable (after readable ones)
 312  * @data: the token identifying the buffer.
 313  * @gfp: how to do memory allocations (if necessary).
 314  *
 315  * Caller must ensure we don't call this with other virtqueue operations
 316  * at the same time (except where noted).
 317  *
 318  * Returns zero or a negative error (ie. ENOSPC, ENOMEM, EIO).
 319  */
 320 int virtqueue_add_sgs(struct virtqueue *_vq,
 321                       struct scatterlist *sgs[],
 322                       unsigned int out_sgs,
 323                       unsigned int in_sgs,
 324                       void *data,
 325                       gfp_t gfp)
 326 {
 327         unsigned int i, total_out, total_in;
 328
 329         /* Count them first. */
 330         for (i = total_out = total_in = 0; i < out_sgs; i++) {
 331                 struct scatterlist *sg;
 332                 for (sg = sgs[i]; sg; sg = sg_next(sg))
 333                         total_out++;
 334         }
 335         for (; i < out_sgs + in_sgs; i++) {
 336                 struct scatterlist *sg;
 337                 for (sg = sgs[i]; sg; sg = sg_next(sg))
 338                         total_in++;
 339         }
 340         return virtqueue_add(_vq, sgs, sg_next_chained,
 341                              total_out, total_in, out_sgs, in_sgs, data, gfp);
 342 }
 343 EXPORT_SYMBOL_GPL(virtqueue_add_sgs);
 344
 345 /**
 346  * virtqueue_add_outbuf - expose output buffers to other end
 347  * @vq: the struct virtqueue we're talking about.
 348  * @sgs: array of scatterlists (need not be terminated!)
 349  * @num: the number of scatterlists readable by other side
 350  * @data: the token identifying the buffer.
 351  * @gfp: how to do memory allocations (if necessary).
 352  *
 353  * Caller must ensure we don't call this with other virtqueue operations
 354  * at the same time (except where noted).
 355  *
 356  * Returns zero or a negative error (ie. ENOSPC, ENOMEM, EIO).
 357  */
 358 int virtqueue_add_outbuf(struct virtqueue *vq,
 359                          struct scatterlist sg[], unsigned int num,
 360                          void *data,
 361                          gfp_t gfp)
 362 {
 363         return virtqueue_add(vq, &sg, sg_next_arr, num, 0, 1, 0, data, gfp);
 364 }
 365 EXPORT_SYMBOL_GPL(virtqueue_add_outbuf);
 366
 367 /**
 368  * virtqueue_add_inbuf - expose input buffers to other end
 369  * @vq: the struct virtqueue we're talking about.
 370  * @sgs: array of scatterlists (need not be terminated!)
 371  * @num: the number of scatterlists writable by other side
 372  * @data: the token identifying the buffer.
 373  * @gfp: how to do memory allocations (if necessary).
 374  *
 375  * Caller must ensure we don't call this with other virtqueue operations
 376  * at the same time (except where noted).
 377  *
 378  * Returns zero or a negative error (ie. ENOSPC, ENOMEM, EIO).
 379  */
 380 int virtqueue_add_inbuf(struct virtqueue *vq,
 381                         struct scatterlist sg[], unsigned int num,
 382                         void *data,
 383                         gfp_t gfp)
 384 {
 385         return virtqueue_add(vq, &sg, sg_next_arr, 0, num, 0, 1, data, gfp);
 386 }
 387 EXPORT_SYMBOL_GPL(virtqueue_add_inbuf);
 388
 389 /**
 390  * virtqueue_kick_prepare - first half of split virtqueue_kick call.
 391  * @vq: the struct virtqueue
 392  *
 393  * Instead of virtqueue_kick(), you can do:
 394  *      if (virtqueue_kick_prepare(vq))
 395  *              virtqueue_notify(vq);
 396  *
 397  * This is sometimes useful because the virtqueue_kick_prepare() needs
 398  * to be serialized, but the actual virtqueue_notify() call does not.
 399  */
 400 bool virtqueue_kick_prepare(struct virtqueue *_vq)
 401 {
 402         struct vring_virtqueue *vq = to_vvq(_vq);
 403         u16 new, old;
 404         bool needs_kick;
 405
 406         START_USE(vq);
 407         /* We need to expose available array entries before checking avail
 408          * event. */
 409         virtio_mb(vq->weak_barriers);
 410
 411         old = vq->vring.avail->idx - vq->num_added;
 412         new = vq->vring.avail->idx;
 413         vq->num_added = 0;
 414
 415 #ifdef DEBUG
 416         if (vq->last_add_time_valid) {
 417                 WARN_ON(ktime_to_ms(ktime_sub(ktime_get(),
 418                                               vq->last_add_time)) > 100);
 419         }
 420         vq->last_add_time_valid = false;
 421 #endif
 422
 423         if (vq->event) {
 424                 needs_kick = vring_need_event(vring_avail_event(&vq->vring),
 425                                               new, old);
 426         } else {
 427                 needs_kick = !(vq->vring.used->flags & VRING_USED_F_NO_NOTIFY);
 428         }
 429         END_USE(vq);
 430         return needs_kick;
 431 }
 432 EXPORT_SYMBOL_GPL(virtqueue_kick_prepare);
 433
 434 /**
 435  * virtqueue_notify - second half of split virtqueue_kick call.
 436  * @vq: the struct virtqueue
 437  *
 438  * This does not need to be serialized.
 439  *
 440  * Returns false if host notify failed or queue is broken, otherwise true.
 441  */
 442 bool virtqueue_notify(struct virtqueue *_vq)
 443 {
 444         struct vring_virtqueue *vq = to_vvq(_vq);
 445
 446         if (unlikely(vq->broken))
 447                 return false;
 448
 449         /* Prod other side to tell it about changes. */
 450         if (!vq->notify(_vq)) {
 451                 vq->broken = true;
 452                 return false;
 453         }
 454         return true;
 455 }
 456 EXPORT_SYMBOL_GPL(virtqueue_notify);
 457
 458 /**
 459  * virtqueue_kick - update after add_buf
 460  * @vq: the struct virtqueue
 461  *
 462  * After one or more virtqueue_add_* calls, invoke this to kick
 463  * the other side.
 464  *
 465  * Caller must ensure we don't call this with other virtqueue
 466  * operations at the same time (except where noted).
 467  *
 468  * Returns false if kick failed, otherwise true.
 469  */
 470 bool virtqueue_kick(struct virtqueue *vq)
 471 {
 472         if (virtqueue_kick_prepare(vq))
 473                 return virtqueue_notify(vq);
 474         return true;
 475 }
 476 EXPORT_SYMBOL_GPL(virtqueue_kick);
 477
 478 static void detach_buf(struct vring_virtqueue *vq, unsigned int head)
 479 {
 480         unsigned int i;
 481
 482         /* Clear data ptr. */
 483         vq->data[head] = NULL;
 484
 485         /* Put back on free list: find end */
 486         i = head;
 487
 488         /* Free the indirect table */
 489         if (vq->vring.desc[i].flags & VRING_DESC_F_INDIRECT)
 490                 kfree(phys_to_virt(vq->vring.desc[i].addr));
 491
 492         while (vq->vring.desc[i].flags & VRING_DESC_F_NEXT) {
 493                 i = vq->vring.desc[i].next;
 494                 vq->vq.num_free++;
 495         }
 496
 497         vq->vring.desc[i].next = vq->free_head;
 498         vq->free_head = head;
 499         /* Plus final descriptor */
 500         vq->vq.num_free++;
 501 }
 502
 503 static inline bool more_used(const struct vring_virtqueue *vq)
 504 {
 505         return vq->last_used_idx != vq->vring.used->idx;
 506 }
 507
 508 /**
 509  * virtqueue_get_buf - get the next used buffer
 510  * @vq: the struct virtqueue we're talking about.
 511  * @len: the length written into the buffer
 512  *
 513  * If the driver wrote data into the buffer, @len will be set to the
 514  * amount written.  This means you don't need to clear the buffer
 515  * beforehand to ensure there's no data leakage in the case of short
 516  * writes.
 517  *
 518  * Caller must ensure we don't call this with other virtqueue
 519  * operations at the same time (except where noted).
 520  *
 521  * Returns NULL if there are no used buffers, or the "data" token
 522  * handed to virtqueue_add_*().
 523  */
 524 void *virtqueue_get_buf(struct virtqueue *_vq, unsigned int *len)
 525 {
 526         struct vring_virtqueue *vq = to_vvq(_vq);
 527         void *ret;
 528         unsigned int i;
 529         u16 last_used;
 530
 531         START_USE(vq);
 532
 533         if (unlikely(vq->broken)) {
 534                 END_USE(vq);
 535                 return NULL;
 536         }
 537
 538         if (!more_used(vq)) {
 539                 pr_debug("No more buffers in queue\n");
 540                 END_USE(vq);
 541                 return NULL;
 542         }
 543
 544         /* Only get used array entries after they have been exposed by host. */
 545         virtio_rmb(vq->weak_barriers);
 546
 547         last_used = (vq->last_used_idx & (vq->vring.num - 1));
 548         i = vq->vring.used->ring[last_used].id;
 549         *len = vq->vring.used->ring[last_used].len;
 550
 551         if (unlikely(i >= vq->vring.num)) {
 552                 BAD_RING(vq, "id %u out of range\n", i);
 553                 return NULL;
 554         }
 555         if (unlikely(!vq->data[i])) {
 556                 BAD_RING(vq, "id %u is not a head!\n", i);
 557                 return NULL;
 558         }
 559
 560         /* detach_buf clears data, so grab it now. */
 561         ret = vq->data[i];
 562         detach_buf(vq, i);
 563         vq->last_used_idx++;
 564         /* If we expect an interrupt for the next entry, tell host
 565          * by writing event index and flush out the write before
 566          * the read in the next get_buf call. */
 567         if (!(vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT)) {
 568                 vring_used_event(&vq->vring) = vq->last_used_idx;
 569                 virtio_mb(vq->weak_barriers);
 570         }
 571
 572 #ifdef DEBUG
 573         vq->last_add_time_valid = false;
 574 #endif
 575
 576         END_USE(vq);
 577         return ret;
 578 }
 579 EXPORT_SYMBOL_GPL(virtqueue_get_buf);
 580
 581 /**
 582  * virtqueue_disable_cb - disable callbacks
 583  * @vq: the struct virtqueue we're talking about.
 584  *
 585  * Note that this is not necessarily synchronous, hence unreliable and only
 586  * useful as an optimization.
 587  *
 588  * Unlike other operations, this need not be serialized.
 589  */
 590 void virtqueue_disable_cb(struct virtqueue *_vq)
 591 {
 592         struct vring_virtqueue *vq = to_vvq(_vq);
 593
 594         vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
 595 }
 596 EXPORT_SYMBOL_GPL(virtqueue_disable_cb);
 597
 598 /**
 599  * virtqueue_enable_cb_prepare - restart callbacks after disable_cb
 600  * @vq: the struct virtqueue we're talking about.
 601  *
 602  * This re-enables callbacks; it returns current queue state
 603  * in an opaque unsigned value. This value should be later tested by
 604  * virtqueue_poll, to detect a possible race between the driver checking for
 605  * more work, and enabling callbacks.
 606  *
 607  * Caller must ensure we don't call this with other virtqueue
 608  * operations at the same time (except where noted).
 609  */
 610 unsigned virtqueue_enable_cb_prepare(struct virtqueue *_vq)
 611 {
 612         struct vring_virtqueue *vq = to_vvq(_vq);
 613         u16 last_used_idx;
 614
 615         START_USE(vq);
 616
 617         /* We optimistically turn back on interrupts, then check if there was
 618          * more to do. */
 619         /* Depending on the VIRTIO_RING_F_EVENT_IDX feature, we need to
 620          * either clear the flags bit or point the event index at the next
 621          * entry. Always do both to keep code simple. */
 622         vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
 623         vring_used_event(&vq->vring) = last_used_idx = vq->last_used_idx;
 624         END_USE(vq);
 625         return last_used_idx;
 626 }
 627 EXPORT_SYMBOL_GPL(virtqueue_enable_cb_prepare);
 628
 629 /**
 630  * virtqueue_poll - query pending used buffers
 631  * @vq: the struct virtqueue we're talking about.
 632  * @last_used_idx: virtqueue state (from call to virtqueue_enable_cb_prepare).
 633  *
 634  * Returns "true" if there are pending used buffers in the queue.
 635  *
 636  * This does not need to be serialized.
 637  */
 638 bool virtqueue_poll(struct virtqueue *_vq, unsigned last_used_idx)
 639 {
 640         struct vring_virtqueue *vq = to_vvq(_vq);
 641
 642         virtio_mb(vq->weak_barriers);
 643         return (u16)last_used_idx != vq->vring.used->idx;
 644 }
 645 EXPORT_SYMBOL_GPL(virtqueue_poll);
 646
 647 /**
 648  * virtqueue_enable_cb - restart callbacks after disable_cb.
 649  * @vq: the struct virtqueue we're talking about.
 650  *
 651  * This re-enables callbacks; it returns "false" if there are pending
 652  * buffers in the queue, to detect a possible race between the driver
 653  * checking for more work, and enabling callbacks.
 654  *
 655  * Caller must ensure we don't call this with other virtqueue
 656  * operations at the same time (except where noted).
 657  */
 658 bool virtqueue_enable_cb(struct virtqueue *_vq)
 659 {
 660         unsigned last_used_idx = virtqueue_enable_cb_prepare(_vq);
 661         return !virtqueue_poll(_vq, last_used_idx);
 662 }
 663 EXPORT_SYMBOL_GPL(virtqueue_enable_cb);
 664
 665 /**
 666  * virtqueue_enable_cb_delayed - restart callbacks after disable_cb.
 667  * @vq: the struct virtqueue we're talking about.
 668  *
 669  * This re-enables callbacks but hints to the other side to delay
 670  * interrupts until most of the available buffers have been processed;
 671  * it returns "false" if there are many pending buffers in the queue,
 672  * to detect a possible race between the driver checking for more work,
 673  * and enabling callbacks.
 674  *
 675  * Caller must ensure we don't call this with other virtqueue
 676  * operations at the same time (except where noted).
 677  */
 678 bool virtqueue_enable_cb_delayed(struct virtqueue *_vq)
 679 {
 680         struct vring_virtqueue *vq = to_vvq(_vq);
 681         u16 bufs;
 682
 683         START_USE(vq);
 684
 685         /* We optimistically turn back on interrupts, then check if there was
 686          * more to do. */
 687         /* Depending on the VIRTIO_RING_F_USED_EVENT_IDX feature, we need to
 688          * either clear the flags bit or point the event index at the next
 689          * entry. Always do both to keep code simple. */
 690         vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
 691         /* TODO: tune this threshold */
 692         bufs = (u16)(vq->vring.avail->idx - vq->last_used_idx) * 3 / 4;
 693         vring_used_event(&vq->vring) = vq->last_used_idx + bufs;
 694         virtio_mb(vq->weak_barriers);
 695         if (unlikely((u16)(vq->vring.used->idx - vq->last_used_idx) > bufs)) {
 696                 END_USE(vq);
 697                 return false;
 698         }
 699
 700         END_USE(vq);
 701         return true;
 702 }
 703 EXPORT_SYMBOL_GPL(virtqueue_enable_cb_delayed);
 704
 705 /**
 706  * virtqueue_detach_unused_buf - detach first unused buffer
 707  * @vq: the struct virtqueue we're talking about.
 708  *
 709  * Returns NULL or the "data" token handed to virtqueue_add_*().
 710  * This is not valid on an active queue; it is useful only for device
 711  * shutdown.
 712  */
 713 void *virtqueue_detach_unused_buf(struct virtqueue *_vq)
 714 {
 715         struct vring_virtqueue *vq = to_vvq(_vq);
 716         unsigned int i;
 717         void *buf;
 718
 719         START_USE(vq);
 720
 721         for (i = 0; i < vq->vring.num; i++) {
 722                 if (!vq->data[i])
 723                         continue;
 724                 /* detach_buf clears data, so grab it now. */
 725                 buf = vq->data[i];
 726                 detach_buf(vq, i);
 727                 vq->vring.avail->idx--;
 728                 END_USE(vq);
 729                 return buf;
 730         }
 731         /* That should have freed everything. */
 732         BUG_ON(vq->vq.num_free != vq->vring.num);
 733
 734         END_USE(vq);
 735         return NULL;
 736 }
 737 EXPORT_SYMBOL_GPL(virtqueue_detach_unused_buf);
 738
 739 irqreturn_t vring_interrupt(int irq, void *_vq)
 740 {
 741         struct vring_virtqueue *vq = to_vvq(_vq);
 742
 743         if (!more_used(vq)) {
 744                 pr_debug("virtqueue interrupt with no work for %p\n", vq);
 745                 return IRQ_NONE;
 746         }
 747
 748         if (unlikely(vq->broken))
 749                 return IRQ_HANDLED;
 750
 751         pr_debug("virtqueue callback for %p (%p)\n", vq, vq->vq.callback);
 752         if (vq->vq.callback)
 753                 vq->vq.callback(&vq->vq);
 754
 755         return IRQ_HANDLED;
 756 }
 757 EXPORT_SYMBOL_GPL(vring_interrupt);
 758
 759 struct virtqueue *vring_new_virtqueue(unsigned int index,
 760                                       unsigned int num,
 761                                       unsigned int vring_align,
 762                                       struct virtio_device *vdev,
 763                                       bool weak_barriers,
 764                                       void *pages,
 765                                       bool (*notify)(struct virtqueue *),
 766                                       void (*callback)(struct virtqueue *),
 767                                       const char *name)
 768 {
 769         struct vring_virtqueue *vq;
 770         unsigned int i;
 771
 772         /* We assume num is a power of 2. */
 773         if (num & (num - 1)) {
 774                 dev_warn(&vdev->dev, "Bad virtqueue length %u\n", num);
 775                 return NULL;
 776         }
 777
 778         vq = kmalloc(sizeof(*vq) + sizeof(void *)*num, GFP_KERNEL);
 779         if (!vq)
 780                 return NULL;
 781
 782         vring_init(&vq->vring, num, pages, vring_align);
 783         vq->vq.callback = callback;
 784         vq->vq.vdev = vdev;
 785         vq->vq.name = name;
 786         vq->vq.num_free = num;
 787         vq->vq.index = index;
 788         vq->notify = notify;
 789         vq->weak_barriers = weak_barriers;
 790         vq->broken = false;
 791         vq->last_used_idx = 0;
 792         vq->num_added = 0;
 793         list_add_tail(&vq->vq.list, &vdev->vqs);
 794 #ifdef DEBUG
 795         vq->in_use = false;
 796         vq->last_add_time_valid = false;
 797 #endif
 798
 799         vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC);
 800         vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
 801
 802         /* No callback?  Tell other side not to bother us. */
 803         if (!callback)
 804                 vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
 805
 806         /* Put everything in free lists. */
 807         vq->free_head = 0;
 808         for (i = 0; i < num-1; i++) {
 809                 vq->vring.desc[i].next = i+1;
 810                 vq->data[i] = NULL;
 811         }
 812         vq->data[i] = NULL;
 813
 814         return &vq->vq;
 815 }
 816 EXPORT_SYMBOL_GPL(vring_new_virtqueue);
 817
 818 void vring_del_virtqueue(struct virtqueue *vq)
 819 {
 820         list_del(&vq->list);
 821         kfree(to_vvq(vq));
 822 }
 823 EXPORT_SYMBOL_GPL(vring_del_virtqueue);
 824
 825 /* Manipulates transport-specific feature bits. */
 826 void vring_transport_features(struct virtio_device *vdev)
 827 {
 828         unsigned int i;
 829
 830         for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++) {
 831                 switch (i) {
 832                 case VIRTIO_RING_F_INDIRECT_DESC:
 833                         break;
 834                 case VIRTIO_RING_F_EVENT_IDX:
 835                         break;
 836                 default:
 837                         /* We don't understand this bit. */
 838                         clear_bit(i, vdev->features);
 839                 }
 840         }
 841 }
 842 EXPORT_SYMBOL_GPL(vring_transport_features);
 843
 844 /**
 845  * virtqueue_get_vring_size - return the size of the virtqueue's vring
 846  * @vq: the struct virtqueue containing the vring of interest.
 847  *
 848  * Returns the size of the vring.  This is mainly used for boasting to
 849  * userspace.  Unlike other operations, this need not be serialized.
 850  */
 851 unsigned int virtqueue_get_vring_size(struct virtqueue *_vq)
 852 {
 853
 854         struct vring_virtqueue *vq = to_vvq(_vq);
 855
 856         return vq->vring.num;
 857 }
 858 EXPORT_SYMBOL_GPL(virtqueue_get_vring_size);
 859
 860 bool virtqueue_is_broken(struct virtqueue *_vq)
 861 {
 862         struct vring_virtqueue *vq = to_vvq(_vq);
 863
 864         return vq->broken;
 865 }
 866 EXPORT_SYMBOL_GPL(virtqueue_is_broken);
 867
 868 /*
 869  * This should prevent the device from being used, allowing drivers to
 870  * recover.  You may need to grab appropriate locks to flush.
 871  */
 872 void virtio_break_device(struct virtio_device *dev)
 873 {
 874         struct virtqueue *_vq;
 875
 876         list_for_each_entry(_vq, &dev->vqs, list) {
 877                 struct vring_virtqueue *vq = to_vvq(_vq);
 878                 vq->broken = true;
 879         }
 880 }
 881 EXPORT_SYMBOL_GPL(virtio_break_device);
 882
 883 MODULE_LICENSE("GPL");