2012-02-05 12:16:00 +01:00
|
|
|
/*
|
|
|
|
* Virtio SCSI HBA driver
|
|
|
|
*
|
|
|
|
* Copyright IBM Corp. 2010
|
|
|
|
* Copyright Red Hat, Inc. 2011
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
|
|
|
|
* Paolo Bonzini <pbonzini@redhat.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2013-03-12 06:04:40 +01:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/mempool.h>
|
|
|
|
#include <linux/virtio.h>
|
|
|
|
#include <linux/virtio_ids.h>
|
|
|
|
#include <linux/virtio_config.h>
|
|
|
|
#include <linux/virtio_scsi.h>
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
#include <linux/cpu.h>
|
2014-02-23 03:23:33 +01:00
|
|
|
#include <linux/blkdev.h>
|
2012-02-05 12:16:00 +01:00
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
#include <scsi/scsi_cmnd.h>
|
|
|
|
|
|
|
|
#define VIRTIO_SCSI_MEMPOOL_SZ 64
|
2012-07-05 11:06:43 +02:00
|
|
|
#define VIRTIO_SCSI_EVENT_LEN 8
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
#define VIRTIO_SCSI_VQ_BASE 2
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
/* Command queue element */
|
|
|
|
struct virtio_scsi_cmd {
|
|
|
|
struct scsi_cmnd *sc;
|
|
|
|
struct completion *comp;
|
|
|
|
union {
|
|
|
|
struct virtio_scsi_cmd_req cmd;
|
2014-02-23 03:23:33 +01:00
|
|
|
struct virtio_scsi_cmd_req_pi cmd_pi;
|
2012-02-05 12:16:00 +01:00
|
|
|
struct virtio_scsi_ctrl_tmf_req tmf;
|
|
|
|
struct virtio_scsi_ctrl_an_req an;
|
|
|
|
} req;
|
|
|
|
union {
|
|
|
|
struct virtio_scsi_cmd_resp cmd;
|
|
|
|
struct virtio_scsi_ctrl_tmf_resp tmf;
|
|
|
|
struct virtio_scsi_ctrl_an_resp an;
|
|
|
|
struct virtio_scsi_event evt;
|
|
|
|
} resp;
|
|
|
|
} ____cacheline_aligned_in_smp;
|
|
|
|
|
2012-07-05 11:06:43 +02:00
|
|
|
struct virtio_scsi_event_node {
|
|
|
|
struct virtio_scsi *vscsi;
|
|
|
|
struct virtio_scsi_event event;
|
|
|
|
struct work_struct work;
|
|
|
|
};
|
|
|
|
|
2012-06-13 16:56:32 +02:00
|
|
|
struct virtio_scsi_vq {
|
|
|
|
/* Protects vq */
|
|
|
|
spinlock_t vq_lock;
|
|
|
|
|
|
|
|
struct virtqueue *vq;
|
|
|
|
};
|
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
/*
|
|
|
|
* Per-target queue state.
|
|
|
|
*
|
|
|
|
* This struct holds the data needed by the queue steering policy. When a
|
|
|
|
* target is sent multiple requests, we need to drive them to the same queue so
|
|
|
|
* that FIFO processing order is kept. However, if a target was idle, we can
|
|
|
|
* choose a queue arbitrarily. In this case the queue is chosen according to
|
|
|
|
* the current VCPU, so the driver expects the number of request queues to be
|
|
|
|
* equal to the number of VCPUs. This makes it easy and fast to select the
|
|
|
|
* queue, and also lets the driver optimize the IRQ affinity for the virtqueues
|
|
|
|
* (each virtqueue's affinity is set to the CPU that "owns" the queue).
|
|
|
|
*
|
2014-05-08 09:23:45 +02:00
|
|
|
* tgt_lock is held to serialize reading and writing req_vq. Reading req_vq
|
|
|
|
* could be done locklessly, but we do not do it yet.
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
*
|
2014-05-08 09:23:45 +02:00
|
|
|
* Decrements of reqs are never concurrent with writes of req_vq: before the
|
|
|
|
* decrement reqs will be != 0; after the decrement the virtqueue completion
|
|
|
|
* routine will not use the req_vq so it can be changed by a new request.
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
* Thus they can happen outside the tgt_lock, provided of course we make reqs
|
|
|
|
* an atomic_t.
|
|
|
|
*/
|
2012-06-13 16:56:34 +02:00
|
|
|
struct virtio_scsi_target_state {
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
/* This spinlock never held at the same time as vq_lock. */
|
2012-06-13 16:56:34 +02:00
|
|
|
spinlock_t tgt_lock;
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
|
|
|
|
/* Count of outstanding requests. */
|
|
|
|
atomic_t reqs;
|
|
|
|
|
|
|
|
/* Currently active virtqueue for requests sent to this target. */
|
|
|
|
struct virtio_scsi_vq *req_vq;
|
2012-06-13 16:56:34 +02:00
|
|
|
};
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
/* Driver instance state */
|
|
|
|
struct virtio_scsi {
|
|
|
|
struct virtio_device *vdev;
|
2012-06-13 16:56:34 +02:00
|
|
|
|
2012-07-05 11:06:43 +02:00
|
|
|
/* Get some buffers ready for event vq */
|
|
|
|
struct virtio_scsi_event_node event_list[VIRTIO_SCSI_EVENT_LEN];
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
|
|
|
|
u32 num_queues;
|
|
|
|
|
|
|
|
/* If the affinity hint is set for virtqueues */
|
|
|
|
bool affinity_hint_set;
|
|
|
|
|
2013-04-08 15:35:49 +02:00
|
|
|
/* CPU hotplug notifier */
|
|
|
|
struct notifier_block nb;
|
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
struct virtio_scsi_vq ctrl_vq;
|
|
|
|
struct virtio_scsi_vq event_vq;
|
|
|
|
struct virtio_scsi_vq req_vqs[];
|
2012-02-05 12:16:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct kmem_cache *virtscsi_cmd_cache;
|
|
|
|
static mempool_t *virtscsi_cmd_pool;
|
|
|
|
|
|
|
|
static inline struct Scsi_Host *virtio_scsi_host(struct virtio_device *vdev)
|
|
|
|
{
|
|
|
|
return vdev->priv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtscsi_compute_resid(struct scsi_cmnd *sc, u32 resid)
|
|
|
|
{
|
|
|
|
if (!resid)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!scsi_bidi_cmnd(sc)) {
|
|
|
|
scsi_set_resid(sc, resid);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
scsi_in(sc)->resid = min(resid, scsi_in(sc)->length);
|
|
|
|
scsi_out(sc)->resid = resid - scsi_in(sc)->resid;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virtscsi_complete_cmd - finish a scsi_cmd and invoke scsi_done
|
|
|
|
*
|
|
|
|
* Called with vq_lock held.
|
|
|
|
*/
|
2013-04-08 15:31:38 +02:00
|
|
|
static void virtscsi_complete_cmd(struct virtio_scsi *vscsi, void *buf)
|
2012-02-05 12:16:00 +01:00
|
|
|
{
|
|
|
|
struct virtio_scsi_cmd *cmd = buf;
|
|
|
|
struct scsi_cmnd *sc = cmd->sc;
|
|
|
|
struct virtio_scsi_cmd_resp *resp = &cmd->resp.cmd;
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
struct virtio_scsi_target_state *tgt =
|
|
|
|
scsi_target(sc->device)->hostdata;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
dev_dbg(&sc->device->sdev_gendev,
|
|
|
|
"cmd %p response %u status %#02x sense_len %u\n",
|
|
|
|
sc, resp->response, resp->status, resp->sense_len);
|
|
|
|
|
|
|
|
sc->result = resp->status;
|
|
|
|
virtscsi_compute_resid(sc, resp->resid);
|
|
|
|
switch (resp->response) {
|
|
|
|
case VIRTIO_SCSI_S_OK:
|
|
|
|
set_host_byte(sc, DID_OK);
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_S_OVERRUN:
|
|
|
|
set_host_byte(sc, DID_ERROR);
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_S_ABORTED:
|
|
|
|
set_host_byte(sc, DID_ABORT);
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_S_BAD_TARGET:
|
|
|
|
set_host_byte(sc, DID_BAD_TARGET);
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_S_RESET:
|
|
|
|
set_host_byte(sc, DID_RESET);
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_S_BUSY:
|
|
|
|
set_host_byte(sc, DID_BUS_BUSY);
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_S_TRANSPORT_FAILURE:
|
|
|
|
set_host_byte(sc, DID_TRANSPORT_DISRUPTED);
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_S_TARGET_FAILURE:
|
|
|
|
set_host_byte(sc, DID_TARGET_FAILURE);
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_S_NEXUS_FAILURE:
|
|
|
|
set_host_byte(sc, DID_NEXUS_FAILURE);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
scmd_printk(KERN_WARNING, sc, "Unknown response %d",
|
|
|
|
resp->response);
|
|
|
|
/* fall through */
|
|
|
|
case VIRTIO_SCSI_S_FAILURE:
|
|
|
|
set_host_byte(sc, DID_ERROR);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON(resp->sense_len > VIRTIO_SCSI_SENSE_SIZE);
|
|
|
|
if (sc->sense_buffer) {
|
|
|
|
memcpy(sc->sense_buffer, resp->sense,
|
|
|
|
min_t(u32, resp->sense_len, VIRTIO_SCSI_SENSE_SIZE));
|
|
|
|
if (resp->sense_len)
|
|
|
|
set_driver_byte(sc, DRIVER_SENSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
sc->scsi_done(sc);
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
|
|
|
|
atomic_dec(&tgt->reqs);
|
2012-02-05 12:16:00 +01:00
|
|
|
}
|
|
|
|
|
2013-04-08 15:32:07 +02:00
|
|
|
static void virtscsi_vq_done(struct virtio_scsi *vscsi,
|
|
|
|
struct virtio_scsi_vq *virtscsi_vq,
|
2013-04-08 15:31:38 +02:00
|
|
|
void (*fn)(struct virtio_scsi *vscsi, void *buf))
|
2012-02-05 12:16:00 +01:00
|
|
|
{
|
|
|
|
void *buf;
|
|
|
|
unsigned int len;
|
2013-04-08 15:32:07 +02:00
|
|
|
unsigned long flags;
|
|
|
|
struct virtqueue *vq = virtscsi_vq->vq;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
2013-04-08 15:32:07 +02:00
|
|
|
spin_lock_irqsave(&virtscsi_vq->vq_lock, flags);
|
2012-02-05 12:16:00 +01:00
|
|
|
do {
|
|
|
|
virtqueue_disable_cb(vq);
|
|
|
|
while ((buf = virtqueue_get_buf(vq, &len)) != NULL)
|
2013-04-08 15:31:38 +02:00
|
|
|
fn(vscsi, buf);
|
2013-11-11 02:22:43 +01:00
|
|
|
|
|
|
|
if (unlikely(virtqueue_is_broken(vq)))
|
|
|
|
break;
|
2012-02-05 12:16:00 +01:00
|
|
|
} while (!virtqueue_enable_cb(vq));
|
2013-04-08 15:32:07 +02:00
|
|
|
spin_unlock_irqrestore(&virtscsi_vq->vq_lock, flags);
|
2012-02-05 12:16:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void virtscsi_req_done(struct virtqueue *vq)
|
|
|
|
{
|
2012-06-13 16:56:32 +02:00
|
|
|
struct Scsi_Host *sh = virtio_scsi_host(vq->vdev);
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sh);
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
int index = vq->index - VIRTIO_SCSI_VQ_BASE;
|
|
|
|
struct virtio_scsi_vq *req_vq = &vscsi->req_vqs[index];
|
|
|
|
|
|
|
|
virtscsi_vq_done(vscsi, req_vq, virtscsi_complete_cmd);
|
2012-02-05 12:16:00 +01:00
|
|
|
};
|
|
|
|
|
2013-04-08 15:31:38 +02:00
|
|
|
static void virtscsi_complete_free(struct virtio_scsi *vscsi, void *buf)
|
2012-02-05 12:16:00 +01:00
|
|
|
{
|
|
|
|
struct virtio_scsi_cmd *cmd = buf;
|
|
|
|
|
|
|
|
if (cmd->comp)
|
|
|
|
complete_all(cmd->comp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtscsi_ctrl_done(struct virtqueue *vq)
|
|
|
|
{
|
2012-06-13 16:56:32 +02:00
|
|
|
struct Scsi_Host *sh = virtio_scsi_host(vq->vdev);
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sh);
|
|
|
|
|
2013-04-08 15:32:07 +02:00
|
|
|
virtscsi_vq_done(vscsi, &vscsi->ctrl_vq, virtscsi_complete_free);
|
2012-02-05 12:16:00 +01:00
|
|
|
};
|
|
|
|
|
2012-07-05 11:06:43 +02:00
|
|
|
static int virtscsi_kick_event(struct virtio_scsi *vscsi,
|
|
|
|
struct virtio_scsi_event_node *event_node)
|
|
|
|
{
|
2012-10-16 15:26:16 +02:00
|
|
|
int err;
|
2012-07-05 11:06:43 +02:00
|
|
|
struct scatterlist sg;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2012-10-02 17:25:46 +02:00
|
|
|
sg_init_one(&sg, &event_node->event, sizeof(struct virtio_scsi_event));
|
2012-07-05 11:06:43 +02:00
|
|
|
|
|
|
|
spin_lock_irqsave(&vscsi->event_vq.vq_lock, flags);
|
|
|
|
|
2013-03-20 06:14:28 +01:00
|
|
|
err = virtqueue_add_inbuf(vscsi->event_vq.vq, &sg, 1, event_node,
|
|
|
|
GFP_ATOMIC);
|
2012-10-16 15:26:16 +02:00
|
|
|
if (!err)
|
2012-07-05 11:06:43 +02:00
|
|
|
virtqueue_kick(vscsi->event_vq.vq);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&vscsi->event_vq.vq_lock, flags);
|
|
|
|
|
2012-10-16 15:26:16 +02:00
|
|
|
return err;
|
2012-07-05 11:06:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int virtscsi_kick_event_all(struct virtio_scsi *vscsi)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < VIRTIO_SCSI_EVENT_LEN; i++) {
|
|
|
|
vscsi->event_list[i].vscsi = vscsi;
|
|
|
|
virtscsi_kick_event(vscsi, &vscsi->event_list[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtscsi_cancel_event_work(struct virtio_scsi *vscsi)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < VIRTIO_SCSI_EVENT_LEN; i++)
|
|
|
|
cancel_work_sync(&vscsi->event_list[i].work);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtscsi_handle_transport_reset(struct virtio_scsi *vscsi,
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
struct virtio_scsi_event *event)
|
2012-07-05 11:06:43 +02:00
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
struct Scsi_Host *shost = virtio_scsi_host(vscsi->vdev);
|
|
|
|
unsigned int target = event->lun[1];
|
|
|
|
unsigned int lun = (event->lun[2] << 8) | event->lun[3];
|
|
|
|
|
|
|
|
switch (event->reason) {
|
|
|
|
case VIRTIO_SCSI_EVT_RESET_RESCAN:
|
|
|
|
scsi_add_device(shost, 0, target, lun);
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_EVT_RESET_REMOVED:
|
|
|
|
sdev = scsi_device_lookup(shost, 0, target, lun);
|
|
|
|
if (sdev) {
|
|
|
|
scsi_remove_device(sdev);
|
|
|
|
scsi_device_put(sdev);
|
|
|
|
} else {
|
|
|
|
pr_err("SCSI device %d 0 %d %d not found\n",
|
|
|
|
shost->host_no, target, lun);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pr_info("Unsupport virtio scsi event reason %x\n", event->reason);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-02 17:25:48 +02:00
|
|
|
static void virtscsi_handle_param_change(struct virtio_scsi *vscsi,
|
|
|
|
struct virtio_scsi_event *event)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
struct Scsi_Host *shost = virtio_scsi_host(vscsi->vdev);
|
|
|
|
unsigned int target = event->lun[1];
|
|
|
|
unsigned int lun = (event->lun[2] << 8) | event->lun[3];
|
|
|
|
u8 asc = event->reason & 255;
|
|
|
|
u8 ascq = event->reason >> 8;
|
|
|
|
|
|
|
|
sdev = scsi_device_lookup(shost, 0, target, lun);
|
|
|
|
if (!sdev) {
|
|
|
|
pr_err("SCSI device %d 0 %d %d not found\n",
|
|
|
|
shost->host_no, target, lun);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle "Parameters changed", "Mode parameters changed", and
|
|
|
|
"Capacity data has changed". */
|
|
|
|
if (asc == 0x2a && (ascq == 0x00 || ascq == 0x01 || ascq == 0x09))
|
|
|
|
scsi_rescan_device(&sdev->sdev_gendev);
|
|
|
|
|
|
|
|
scsi_device_put(sdev);
|
|
|
|
}
|
|
|
|
|
2012-07-05 11:06:43 +02:00
|
|
|
static void virtscsi_handle_event(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct virtio_scsi_event_node *event_node =
|
|
|
|
container_of(work, struct virtio_scsi_event_node, work);
|
|
|
|
struct virtio_scsi *vscsi = event_node->vscsi;
|
|
|
|
struct virtio_scsi_event *event = &event_node->event;
|
|
|
|
|
|
|
|
if (event->event & VIRTIO_SCSI_T_EVENTS_MISSED) {
|
|
|
|
event->event &= ~VIRTIO_SCSI_T_EVENTS_MISSED;
|
|
|
|
scsi_scan_host(virtio_scsi_host(vscsi->vdev));
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (event->event) {
|
|
|
|
case VIRTIO_SCSI_T_NO_EVENT:
|
|
|
|
break;
|
|
|
|
case VIRTIO_SCSI_T_TRANSPORT_RESET:
|
|
|
|
virtscsi_handle_transport_reset(vscsi, event);
|
|
|
|
break;
|
2012-10-02 17:25:48 +02:00
|
|
|
case VIRTIO_SCSI_T_PARAM_CHANGE:
|
|
|
|
virtscsi_handle_param_change(vscsi, event);
|
|
|
|
break;
|
2012-07-05 11:06:43 +02:00
|
|
|
default:
|
|
|
|
pr_err("Unsupport virtio scsi event %x\n", event->event);
|
|
|
|
}
|
|
|
|
virtscsi_kick_event(vscsi, event_node);
|
|
|
|
}
|
|
|
|
|
2013-04-08 15:31:38 +02:00
|
|
|
static void virtscsi_complete_event(struct virtio_scsi *vscsi, void *buf)
|
2012-07-05 11:06:43 +02:00
|
|
|
{
|
|
|
|
struct virtio_scsi_event_node *event_node = buf;
|
|
|
|
|
|
|
|
INIT_WORK(&event_node->work, virtscsi_handle_event);
|
|
|
|
schedule_work(&event_node->work);
|
|
|
|
}
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
static void virtscsi_event_done(struct virtqueue *vq)
|
|
|
|
{
|
2012-06-13 16:56:32 +02:00
|
|
|
struct Scsi_Host *sh = virtio_scsi_host(vq->vdev);
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sh);
|
|
|
|
|
2013-04-08 15:32:07 +02:00
|
|
|
virtscsi_vq_done(vscsi, &vscsi->event_vq, virtscsi_complete_event);
|
2012-02-05 12:16:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2013-03-20 06:14:28 +01:00
|
|
|
* virtscsi_add_cmd - add a virtio_scsi_cmd to a virtqueue
|
|
|
|
* @vq : the struct virtqueue we're talking about
|
2012-02-05 12:16:00 +01:00
|
|
|
* @cmd : command structure
|
|
|
|
* @req_size : size of the request buffer
|
|
|
|
* @resp_size : size of the response buffer
|
|
|
|
*/
|
2013-03-20 06:14:28 +01:00
|
|
|
static int virtscsi_add_cmd(struct virtqueue *vq,
|
|
|
|
struct virtio_scsi_cmd *cmd,
|
2014-05-21 03:55:04 +02:00
|
|
|
size_t req_size, size_t resp_size)
|
2012-02-05 12:16:00 +01:00
|
|
|
{
|
|
|
|
struct scsi_cmnd *sc = cmd->sc;
|
2014-02-23 03:23:33 +01:00
|
|
|
struct scatterlist *sgs[6], req, resp;
|
2013-03-20 06:14:28 +01:00
|
|
|
struct sg_table *out, *in;
|
|
|
|
unsigned out_num = 0, in_num = 0;
|
|
|
|
|
|
|
|
out = in = NULL;
|
|
|
|
|
|
|
|
if (sc && sc->sc_data_direction != DMA_NONE) {
|
|
|
|
if (sc->sc_data_direction != DMA_FROM_DEVICE)
|
|
|
|
out = &scsi_out(sc)->table;
|
|
|
|
if (sc->sc_data_direction != DMA_TO_DEVICE)
|
|
|
|
in = &scsi_in(sc)->table;
|
|
|
|
}
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
/* Request header. */
|
2013-03-20 06:14:28 +01:00
|
|
|
sg_init_one(&req, &cmd->req, req_size);
|
|
|
|
sgs[out_num++] = &req;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
/* Data-out buffer. */
|
2014-02-23 03:23:33 +01:00
|
|
|
if (out) {
|
|
|
|
/* Place WRITE protection SGLs before Data OUT payload */
|
|
|
|
if (scsi_prot_sg_count(sc))
|
|
|
|
sgs[out_num++] = scsi_prot_sglist(sc);
|
2013-03-20 06:14:28 +01:00
|
|
|
sgs[out_num++] = out->sgl;
|
2014-02-23 03:23:33 +01:00
|
|
|
}
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
/* Response header. */
|
2013-03-20 06:14:28 +01:00
|
|
|
sg_init_one(&resp, &cmd->resp, resp_size);
|
|
|
|
sgs[out_num + in_num++] = &resp;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
/* Data-in buffer */
|
2014-02-23 03:23:33 +01:00
|
|
|
if (in) {
|
|
|
|
/* Place READ protection SGLs before Data IN payload */
|
|
|
|
if (scsi_prot_sg_count(sc))
|
|
|
|
sgs[out_num + in_num++] = scsi_prot_sglist(sc);
|
2013-03-20 06:14:28 +01:00
|
|
|
sgs[out_num + in_num++] = in->sgl;
|
2014-02-23 03:23:33 +01:00
|
|
|
}
|
2012-02-05 12:16:00 +01:00
|
|
|
|
2014-05-21 03:55:04 +02:00
|
|
|
return virtqueue_add_sgs(vq, sgs, out_num, in_num, cmd, GFP_ATOMIC);
|
2012-02-05 12:16:00 +01:00
|
|
|
}
|
|
|
|
|
2013-03-20 06:14:28 +01:00
|
|
|
static int virtscsi_kick_cmd(struct virtio_scsi_vq *vq,
|
2012-02-05 12:16:00 +01:00
|
|
|
struct virtio_scsi_cmd *cmd,
|
2014-05-21 03:55:04 +02:00
|
|
|
size_t req_size, size_t resp_size)
|
2012-02-05 12:16:00 +01:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2012-10-16 15:26:16 +02:00
|
|
|
int err;
|
|
|
|
bool needs_kick = false;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
2013-03-20 06:14:28 +01:00
|
|
|
spin_lock_irqsave(&vq->vq_lock, flags);
|
2014-05-21 03:55:04 +02:00
|
|
|
err = virtscsi_add_cmd(vq->vq, cmd, req_size, resp_size);
|
2012-10-16 15:26:16 +02:00
|
|
|
if (!err)
|
|
|
|
needs_kick = virtqueue_kick_prepare(vq->vq);
|
2012-06-13 16:56:32 +02:00
|
|
|
|
2012-06-13 16:56:33 +02:00
|
|
|
spin_unlock_irqrestore(&vq->vq_lock, flags);
|
2012-02-05 12:16:00 +01:00
|
|
|
|
2012-10-16 15:26:16 +02:00
|
|
|
if (needs_kick)
|
2012-06-13 16:56:32 +02:00
|
|
|
virtqueue_notify(vq->vq);
|
2012-10-16 15:26:16 +02:00
|
|
|
return err;
|
2012-02-05 12:16:00 +01:00
|
|
|
}
|
|
|
|
|
2014-02-23 03:23:33 +01:00
|
|
|
static void virtio_scsi_init_hdr(struct virtio_scsi_cmd_req *cmd,
|
|
|
|
struct scsi_cmnd *sc)
|
|
|
|
{
|
|
|
|
cmd->lun[0] = 1;
|
|
|
|
cmd->lun[1] = sc->device->id;
|
|
|
|
cmd->lun[2] = (sc->device->lun >> 8) | 0x40;
|
|
|
|
cmd->lun[3] = sc->device->lun & 0xff;
|
|
|
|
cmd->tag = (unsigned long)sc;
|
|
|
|
cmd->task_attr = VIRTIO_SCSI_S_SIMPLE;
|
|
|
|
cmd->prio = 0;
|
|
|
|
cmd->crn = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtio_scsi_init_hdr_pi(struct virtio_scsi_cmd_req_pi *cmd_pi,
|
|
|
|
struct scsi_cmnd *sc)
|
|
|
|
{
|
|
|
|
struct request *rq = sc->request;
|
|
|
|
struct blk_integrity *bi;
|
|
|
|
|
|
|
|
virtio_scsi_init_hdr((struct virtio_scsi_cmd_req *)cmd_pi, sc);
|
|
|
|
|
|
|
|
if (!rq || !scsi_prot_sg_count(sc))
|
|
|
|
return;
|
|
|
|
|
|
|
|
bi = blk_get_integrity(rq->rq_disk);
|
|
|
|
|
|
|
|
if (sc->sc_data_direction == DMA_TO_DEVICE)
|
|
|
|
cmd_pi->pi_bytesout = blk_rq_sectors(rq) * bi->tuple_size;
|
|
|
|
else if (sc->sc_data_direction == DMA_FROM_DEVICE)
|
|
|
|
cmd_pi->pi_bytesin = blk_rq_sectors(rq) * bi->tuple_size;
|
|
|
|
}
|
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
static int virtscsi_queuecommand(struct virtio_scsi *vscsi,
|
|
|
|
struct virtio_scsi_vq *req_vq,
|
|
|
|
struct scsi_cmnd *sc)
|
2012-02-05 12:16:00 +01:00
|
|
|
{
|
2012-06-13 16:56:34 +02:00
|
|
|
struct Scsi_Host *shost = virtio_scsi_host(vscsi->vdev);
|
2014-05-01 16:51:50 +02:00
|
|
|
struct virtio_scsi_cmd *cmd = scsi_cmd_priv(sc);
|
2014-06-13 07:38:32 +02:00
|
|
|
int req_size;
|
2014-05-01 16:51:50 +02:00
|
|
|
|
2012-06-13 16:56:34 +02:00
|
|
|
BUG_ON(scsi_sg_count(sc) > shost->sg_tablesize);
|
|
|
|
|
|
|
|
/* TODO: check feature bit and fail if unsupported? */
|
|
|
|
BUG_ON(sc->sc_data_direction == DMA_BIDIRECTIONAL);
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
dev_dbg(&sc->device->sdev_gendev,
|
|
|
|
"cmd %p CDB: %#02x\n", sc, sc->cmnd[0]);
|
|
|
|
|
|
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
|
|
cmd->sc = sc;
|
|
|
|
|
|
|
|
BUG_ON(sc->cmd_len > VIRTIO_SCSI_CDB_SIZE);
|
|
|
|
|
2014-02-23 03:23:33 +01:00
|
|
|
if (virtio_has_feature(vscsi->vdev, VIRTIO_SCSI_F_T10_PI)) {
|
|
|
|
virtio_scsi_init_hdr_pi(&cmd->req.cmd_pi, sc);
|
|
|
|
memcpy(cmd->req.cmd_pi.cdb, sc->cmnd, sc->cmd_len);
|
|
|
|
req_size = sizeof(cmd->req.cmd_pi);
|
|
|
|
} else {
|
|
|
|
virtio_scsi_init_hdr(&cmd->req.cmd, sc);
|
|
|
|
memcpy(cmd->req.cmd.cdb, sc->cmnd, sc->cmd_len);
|
|
|
|
req_size = sizeof(cmd->req.cmd);
|
|
|
|
}
|
|
|
|
|
2014-06-13 07:38:32 +02:00
|
|
|
if (virtscsi_kick_cmd(req_vq, cmd, req_size, sizeof(cmd->resp.cmd)) != 0)
|
2014-05-01 16:51:50 +02:00
|
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
return 0;
|
2012-02-05 12:16:00 +01:00
|
|
|
}
|
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
static int virtscsi_queuecommand_single(struct Scsi_Host *sh,
|
|
|
|
struct scsi_cmnd *sc)
|
|
|
|
{
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sh);
|
|
|
|
struct virtio_scsi_target_state *tgt =
|
|
|
|
scsi_target(sc->device)->hostdata;
|
|
|
|
|
|
|
|
atomic_inc(&tgt->reqs);
|
|
|
|
return virtscsi_queuecommand(vscsi, &vscsi->req_vqs[0], sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct virtio_scsi_vq *virtscsi_pick_vq(struct virtio_scsi *vscsi,
|
|
|
|
struct virtio_scsi_target_state *tgt)
|
|
|
|
{
|
|
|
|
struct virtio_scsi_vq *vq;
|
|
|
|
unsigned long flags;
|
|
|
|
u32 queue_num;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&tgt->tgt_lock, flags);
|
|
|
|
|
|
|
|
if (atomic_inc_return(&tgt->reqs) > 1)
|
2014-05-08 09:23:45 +02:00
|
|
|
vq = tgt->req_vq;
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
else {
|
|
|
|
queue_num = smp_processor_id();
|
|
|
|
while (unlikely(queue_num >= vscsi->num_queues))
|
|
|
|
queue_num -= vscsi->num_queues;
|
|
|
|
|
|
|
|
tgt->req_vq = vq = &vscsi->req_vqs[queue_num];
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&tgt->tgt_lock, flags);
|
|
|
|
return vq;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int virtscsi_queuecommand_multi(struct Scsi_Host *sh,
|
|
|
|
struct scsi_cmnd *sc)
|
|
|
|
{
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sh);
|
|
|
|
struct virtio_scsi_target_state *tgt =
|
|
|
|
scsi_target(sc->device)->hostdata;
|
|
|
|
struct virtio_scsi_vq *req_vq = virtscsi_pick_vq(vscsi, tgt);
|
|
|
|
|
|
|
|
return virtscsi_queuecommand(vscsi, req_vq, sc);
|
|
|
|
}
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
static int virtscsi_tmf(struct virtio_scsi *vscsi, struct virtio_scsi_cmd *cmd)
|
|
|
|
{
|
|
|
|
DECLARE_COMPLETION_ONSTACK(comp);
|
2012-05-04 12:32:04 +02:00
|
|
|
int ret = FAILED;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
cmd->comp = ∁
|
2013-03-20 06:14:28 +01:00
|
|
|
if (virtscsi_kick_cmd(&vscsi->ctrl_vq, cmd,
|
2014-05-21 03:55:04 +02:00
|
|
|
sizeof cmd->req.tmf, sizeof cmd->resp.tmf) < 0)
|
2012-05-04 12:32:04 +02:00
|
|
|
goto out;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
wait_for_completion(&comp);
|
2012-05-04 12:32:04 +02:00
|
|
|
if (cmd->resp.tmf.response == VIRTIO_SCSI_S_OK ||
|
|
|
|
cmd->resp.tmf.response == VIRTIO_SCSI_S_FUNCTION_SUCCEEDED)
|
|
|
|
ret = SUCCESS;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
2012-05-04 12:32:04 +02:00
|
|
|
out:
|
|
|
|
mempool_free(cmd, virtscsi_cmd_pool);
|
|
|
|
return ret;
|
2012-02-05 12:16:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int virtscsi_device_reset(struct scsi_cmnd *sc)
|
|
|
|
{
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sc->device->host);
|
|
|
|
struct virtio_scsi_cmd *cmd;
|
|
|
|
|
|
|
|
sdev_printk(KERN_INFO, sc->device, "device reset\n");
|
|
|
|
cmd = mempool_alloc(virtscsi_cmd_pool, GFP_NOIO);
|
|
|
|
if (!cmd)
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
|
|
cmd->sc = sc;
|
|
|
|
cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
|
|
|
|
.type = VIRTIO_SCSI_T_TMF,
|
|
|
|
.subtype = VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET,
|
|
|
|
.lun[0] = 1,
|
|
|
|
.lun[1] = sc->device->id,
|
|
|
|
.lun[2] = (sc->device->lun >> 8) | 0x40,
|
|
|
|
.lun[3] = sc->device->lun & 0xff,
|
|
|
|
};
|
|
|
|
return virtscsi_tmf(vscsi, cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int virtscsi_abort(struct scsi_cmnd *sc)
|
|
|
|
{
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sc->device->host);
|
|
|
|
struct virtio_scsi_cmd *cmd;
|
|
|
|
|
|
|
|
scmd_printk(KERN_INFO, sc, "abort\n");
|
|
|
|
cmd = mempool_alloc(virtscsi_cmd_pool, GFP_NOIO);
|
|
|
|
if (!cmd)
|
|
|
|
return FAILED;
|
|
|
|
|
|
|
|
memset(cmd, 0, sizeof(*cmd));
|
|
|
|
cmd->sc = sc;
|
|
|
|
cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
|
|
|
|
.type = VIRTIO_SCSI_T_TMF,
|
|
|
|
.subtype = VIRTIO_SCSI_T_TMF_ABORT_TASK,
|
|
|
|
.lun[0] = 1,
|
|
|
|
.lun[1] = sc->device->id,
|
|
|
|
.lun[2] = (sc->device->lun >> 8) | 0x40,
|
|
|
|
.lun[3] = sc->device->lun & 0xff,
|
|
|
|
.tag = (unsigned long)sc,
|
|
|
|
};
|
|
|
|
return virtscsi_tmf(vscsi, cmd);
|
|
|
|
}
|
|
|
|
|
2013-04-08 15:31:16 +02:00
|
|
|
static int virtscsi_target_alloc(struct scsi_target *starget)
|
|
|
|
{
|
|
|
|
struct virtio_scsi_target_state *tgt =
|
|
|
|
kmalloc(sizeof(*tgt), GFP_KERNEL);
|
|
|
|
if (!tgt)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
spin_lock_init(&tgt->tgt_lock);
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
atomic_set(&tgt->reqs, 0);
|
|
|
|
tgt->req_vq = NULL;
|
2013-04-08 15:31:16 +02:00
|
|
|
|
|
|
|
starget->hostdata = tgt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtscsi_target_destroy(struct scsi_target *starget)
|
|
|
|
{
|
|
|
|
struct virtio_scsi_target_state *tgt = starget->hostdata;
|
|
|
|
kfree(tgt);
|
|
|
|
}
|
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
static struct scsi_host_template virtscsi_host_template_single = {
|
|
|
|
.module = THIS_MODULE,
|
|
|
|
.name = "Virtio SCSI HBA",
|
|
|
|
.proc_name = "virtio_scsi",
|
|
|
|
.this_id = -1,
|
2014-05-01 16:51:50 +02:00
|
|
|
.cmd_size = sizeof(struct virtio_scsi_cmd),
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
.queuecommand = virtscsi_queuecommand_single,
|
|
|
|
.eh_abort_handler = virtscsi_abort,
|
|
|
|
.eh_device_reset_handler = virtscsi_device_reset,
|
|
|
|
|
|
|
|
.can_queue = 1024,
|
|
|
|
.dma_boundary = UINT_MAX,
|
|
|
|
.use_clustering = ENABLE_CLUSTERING,
|
|
|
|
.target_alloc = virtscsi_target_alloc,
|
|
|
|
.target_destroy = virtscsi_target_destroy,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct scsi_host_template virtscsi_host_template_multi = {
|
2012-02-05 12:16:00 +01:00
|
|
|
.module = THIS_MODULE,
|
|
|
|
.name = "Virtio SCSI HBA",
|
|
|
|
.proc_name = "virtio_scsi",
|
|
|
|
.this_id = -1,
|
2014-05-01 16:51:50 +02:00
|
|
|
.cmd_size = sizeof(struct virtio_scsi_cmd),
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
.queuecommand = virtscsi_queuecommand_multi,
|
2012-02-05 12:16:00 +01:00
|
|
|
.eh_abort_handler = virtscsi_abort,
|
|
|
|
.eh_device_reset_handler = virtscsi_device_reset,
|
|
|
|
|
|
|
|
.can_queue = 1024,
|
|
|
|
.dma_boundary = UINT_MAX,
|
|
|
|
.use_clustering = ENABLE_CLUSTERING,
|
2013-04-08 15:31:16 +02:00
|
|
|
.target_alloc = virtscsi_target_alloc,
|
|
|
|
.target_destroy = virtscsi_target_destroy,
|
2012-02-05 12:16:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#define virtscsi_config_get(vdev, fld) \
|
|
|
|
({ \
|
|
|
|
typeof(((struct virtio_scsi_config *)0)->fld) __val; \
|
2013-10-14 09:41:51 +02:00
|
|
|
virtio_cread(vdev, struct virtio_scsi_config, fld, &__val); \
|
2012-02-05 12:16:00 +01:00
|
|
|
__val; \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define virtscsi_config_set(vdev, fld, val) \
|
2013-10-14 09:41:51 +02:00
|
|
|
do { \
|
2012-02-05 12:16:00 +01:00
|
|
|
typeof(((struct virtio_scsi_config *)0)->fld) __val = (val); \
|
2013-10-14 09:41:51 +02:00
|
|
|
virtio_cwrite(vdev, struct virtio_scsi_config, fld, &__val); \
|
|
|
|
} while(0)
|
2012-02-05 12:16:00 +01:00
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
static void __virtscsi_set_affinity(struct virtio_scsi *vscsi, bool affinity)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
/* In multiqueue mode, when the number of cpu is equal
|
|
|
|
* to the number of request queues, we let the qeueues
|
|
|
|
* to be private to one cpu by setting the affinity hint
|
|
|
|
* to eliminate the contention.
|
|
|
|
*/
|
|
|
|
if ((vscsi->num_queues == 1 ||
|
|
|
|
vscsi->num_queues != num_online_cpus()) && affinity) {
|
|
|
|
if (vscsi->affinity_hint_set)
|
|
|
|
affinity = false;
|
|
|
|
else
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (affinity) {
|
|
|
|
i = 0;
|
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
virtqueue_set_affinity(vscsi->req_vqs[i].vq, cpu);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
vscsi->affinity_hint_set = true;
|
|
|
|
} else {
|
[SCSI] virtio-scsi: Skip setting affinity on uninitialized vq
virtscsi_init calls virtscsi_remove_vqs on err, even before initializing
the vqs. The latter calls virtscsi_set_affinity, so let's check the
pointer there before setting affinity on it.
This fixes a panic when setting device's num_queues=2 on RHEL 6.5:
qemu-system-x86_64 ... \
-device virtio-scsi-pci,id=scsi0,addr=0x13,...,num_queues=2 \
-drive file=/stor/vm/dummy.raw,id=drive-scsi-disk,... \
-device scsi-hd,drive=drive-scsi-disk,...
[ 0.354734] scsi0 : Virtio SCSI HBA
[ 0.379504] BUG: unable to handle kernel NULL pointer dereference at 0000000000000020
[ 0.380141] IP: [<ffffffff814741ef>] __virtscsi_set_affinity+0x4f/0x120
[ 0.380141] PGD 0
[ 0.380141] Oops: 0000 [#1] SMP
[ 0.380141] CPU: 0 PID: 1 Comm: swapper/0 Not tainted 3.14.0+ #5
[ 0.380141] Hardware name: Red Hat KVM, BIOS 0.5.1 01/01/2007
[ 0.380141] task: ffff88003c9f0000 ti: ffff88003c9f8000 task.ti: ffff88003c9f8000
[ 0.380141] RIP: 0010:[<ffffffff814741ef>] [<ffffffff814741ef>] __virtscsi_set_affinity+0x4f/0x120
[ 0.380141] RSP: 0000:ffff88003c9f9c08 EFLAGS: 00010256
[ 0.380141] RAX: 0000000000000000 RBX: ffff88003c3a9d40 RCX: 0000000000001070
[ 0.380141] RDX: 0000000000000002 RSI: 0000000000000000 RDI: 0000000000000000
[ 0.380141] RBP: ffff88003c9f9c28 R08: 00000000000136c0 R09: ffff88003c801c00
[ 0.380141] R10: ffffffff81475229 R11: 0000000000000008 R12: 0000000000000000
[ 0.380141] R13: ffffffff81cc7ca8 R14: ffff88003cac3d40 R15: ffff88003cac37a0
[ 0.380141] FS: 0000000000000000(0000) GS:ffff88003e400000(0000) knlGS:0000000000000000
[ 0.380141] CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
[ 0.380141] CR2: 0000000000000020 CR3: 0000000001c0e000 CR4: 00000000000006f0
[ 0.380141] Stack:
[ 0.380141] ffff88003c3a9d40 0000000000000000 ffff88003cac3d80 ffff88003cac3d40
[ 0.380141] ffff88003c9f9c48 ffffffff814742e8 ffff88003c26d000 ffff88003c26d000
[ 0.380141] ffff88003c9f9c68 ffffffff81474321 ffff88003c26d000 ffff88003c3a9d40
[ 0.380141] Call Trace:
[ 0.380141] [<ffffffff814742e8>] virtscsi_set_affinity+0x28/0x40
[ 0.380141] [<ffffffff81474321>] virtscsi_remove_vqs+0x21/0x50
[ 0.380141] [<ffffffff81475231>] virtscsi_init+0x91/0x240
[ 0.380141] [<ffffffff81365290>] ? vp_get+0x50/0x70
[ 0.380141] [<ffffffff81475544>] virtscsi_probe+0xf4/0x280
[ 0.380141] [<ffffffff81363ea5>] virtio_dev_probe+0xe5/0x140
[ 0.380141] [<ffffffff8144c669>] driver_probe_device+0x89/0x230
[ 0.380141] [<ffffffff8144c8ab>] __driver_attach+0x9b/0xa0
[ 0.380141] [<ffffffff8144c810>] ? driver_probe_device+0x230/0x230
[ 0.380141] [<ffffffff8144c810>] ? driver_probe_device+0x230/0x230
[ 0.380141] [<ffffffff8144ac1c>] bus_for_each_dev+0x8c/0xb0
[ 0.380141] [<ffffffff8144c499>] driver_attach+0x19/0x20
[ 0.380141] [<ffffffff8144bf28>] bus_add_driver+0x198/0x220
[ 0.380141] [<ffffffff8144ce9f>] driver_register+0x5f/0xf0
[ 0.380141] [<ffffffff81d27c91>] ? spi_transport_init+0x79/0x79
[ 0.380141] [<ffffffff8136403b>] register_virtio_driver+0x1b/0x30
[ 0.380141] [<ffffffff81d27d19>] init+0x88/0xd6
[ 0.380141] [<ffffffff81d27c18>] ? scsi_init_procfs+0x5b/0x5b
[ 0.380141] [<ffffffff81ce88a7>] do_one_initcall+0x7f/0x10a
[ 0.380141] [<ffffffff81ce8aa7>] kernel_init_freeable+0x14a/0x1de
[ 0.380141] [<ffffffff81ce8b3b>] ? kernel_init_freeable+0x1de/0x1de
[ 0.380141] [<ffffffff817dec20>] ? rest_init+0x80/0x80
[ 0.380141] [<ffffffff817dec29>] kernel_init+0x9/0xf0
[ 0.380141] [<ffffffff817e68fc>] ret_from_fork+0x7c/0xb0
[ 0.380141] [<ffffffff817dec20>] ? rest_init+0x80/0x80
[ 0.380141] RIP [<ffffffff814741ef>] __virtscsi_set_affinity+0x4f/0x120
[ 0.380141] RSP <ffff88003c9f9c08>
[ 0.380141] CR2: 0000000000000020
[ 0.380141] ---[ end trace 8074b70c3d5e1d73 ]---
[ 0.475018] Kernel panic - not syncing: Attempted to kill init! exitcode=0x00000009
[ 0.475018]
[ 0.475068] Kernel Offset: 0x0 from 0xffffffff81000000 (relocation range: 0xffffffff80000000-0xffffffff9fffffff)
[ 0.475068] ---[ end Kernel panic - not syncing: Attempted to kill init! exitcode=0x00000009
[jejb: checkpatch fixes]
Signed-off-by: Fam Zheng <famz@redhat.com>
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Cc: stable@vger.kernel.org
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2014-04-14 04:16:09 +02:00
|
|
|
for (i = 0; i < vscsi->num_queues; i++) {
|
|
|
|
if (!vscsi->req_vqs[i].vq)
|
|
|
|
continue;
|
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
virtqueue_set_affinity(vscsi->req_vqs[i].vq, -1);
|
[SCSI] virtio-scsi: Skip setting affinity on uninitialized vq
virtscsi_init calls virtscsi_remove_vqs on err, even before initializing
the vqs. The latter calls virtscsi_set_affinity, so let's check the
pointer there before setting affinity on it.
This fixes a panic when setting device's num_queues=2 on RHEL 6.5:
qemu-system-x86_64 ... \
-device virtio-scsi-pci,id=scsi0,addr=0x13,...,num_queues=2 \
-drive file=/stor/vm/dummy.raw,id=drive-scsi-disk,... \
-device scsi-hd,drive=drive-scsi-disk,...
[ 0.354734] scsi0 : Virtio SCSI HBA
[ 0.379504] BUG: unable to handle kernel NULL pointer dereference at 0000000000000020
[ 0.380141] IP: [<ffffffff814741ef>] __virtscsi_set_affinity+0x4f/0x120
[ 0.380141] PGD 0
[ 0.380141] Oops: 0000 [#1] SMP
[ 0.380141] CPU: 0 PID: 1 Comm: swapper/0 Not tainted 3.14.0+ #5
[ 0.380141] Hardware name: Red Hat KVM, BIOS 0.5.1 01/01/2007
[ 0.380141] task: ffff88003c9f0000 ti: ffff88003c9f8000 task.ti: ffff88003c9f8000
[ 0.380141] RIP: 0010:[<ffffffff814741ef>] [<ffffffff814741ef>] __virtscsi_set_affinity+0x4f/0x120
[ 0.380141] RSP: 0000:ffff88003c9f9c08 EFLAGS: 00010256
[ 0.380141] RAX: 0000000000000000 RBX: ffff88003c3a9d40 RCX: 0000000000001070
[ 0.380141] RDX: 0000000000000002 RSI: 0000000000000000 RDI: 0000000000000000
[ 0.380141] RBP: ffff88003c9f9c28 R08: 00000000000136c0 R09: ffff88003c801c00
[ 0.380141] R10: ffffffff81475229 R11: 0000000000000008 R12: 0000000000000000
[ 0.380141] R13: ffffffff81cc7ca8 R14: ffff88003cac3d40 R15: ffff88003cac37a0
[ 0.380141] FS: 0000000000000000(0000) GS:ffff88003e400000(0000) knlGS:0000000000000000
[ 0.380141] CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
[ 0.380141] CR2: 0000000000000020 CR3: 0000000001c0e000 CR4: 00000000000006f0
[ 0.380141] Stack:
[ 0.380141] ffff88003c3a9d40 0000000000000000 ffff88003cac3d80 ffff88003cac3d40
[ 0.380141] ffff88003c9f9c48 ffffffff814742e8 ffff88003c26d000 ffff88003c26d000
[ 0.380141] ffff88003c9f9c68 ffffffff81474321 ffff88003c26d000 ffff88003c3a9d40
[ 0.380141] Call Trace:
[ 0.380141] [<ffffffff814742e8>] virtscsi_set_affinity+0x28/0x40
[ 0.380141] [<ffffffff81474321>] virtscsi_remove_vqs+0x21/0x50
[ 0.380141] [<ffffffff81475231>] virtscsi_init+0x91/0x240
[ 0.380141] [<ffffffff81365290>] ? vp_get+0x50/0x70
[ 0.380141] [<ffffffff81475544>] virtscsi_probe+0xf4/0x280
[ 0.380141] [<ffffffff81363ea5>] virtio_dev_probe+0xe5/0x140
[ 0.380141] [<ffffffff8144c669>] driver_probe_device+0x89/0x230
[ 0.380141] [<ffffffff8144c8ab>] __driver_attach+0x9b/0xa0
[ 0.380141] [<ffffffff8144c810>] ? driver_probe_device+0x230/0x230
[ 0.380141] [<ffffffff8144c810>] ? driver_probe_device+0x230/0x230
[ 0.380141] [<ffffffff8144ac1c>] bus_for_each_dev+0x8c/0xb0
[ 0.380141] [<ffffffff8144c499>] driver_attach+0x19/0x20
[ 0.380141] [<ffffffff8144bf28>] bus_add_driver+0x198/0x220
[ 0.380141] [<ffffffff8144ce9f>] driver_register+0x5f/0xf0
[ 0.380141] [<ffffffff81d27c91>] ? spi_transport_init+0x79/0x79
[ 0.380141] [<ffffffff8136403b>] register_virtio_driver+0x1b/0x30
[ 0.380141] [<ffffffff81d27d19>] init+0x88/0xd6
[ 0.380141] [<ffffffff81d27c18>] ? scsi_init_procfs+0x5b/0x5b
[ 0.380141] [<ffffffff81ce88a7>] do_one_initcall+0x7f/0x10a
[ 0.380141] [<ffffffff81ce8aa7>] kernel_init_freeable+0x14a/0x1de
[ 0.380141] [<ffffffff81ce8b3b>] ? kernel_init_freeable+0x1de/0x1de
[ 0.380141] [<ffffffff817dec20>] ? rest_init+0x80/0x80
[ 0.380141] [<ffffffff817dec29>] kernel_init+0x9/0xf0
[ 0.380141] [<ffffffff817e68fc>] ret_from_fork+0x7c/0xb0
[ 0.380141] [<ffffffff817dec20>] ? rest_init+0x80/0x80
[ 0.380141] RIP [<ffffffff814741ef>] __virtscsi_set_affinity+0x4f/0x120
[ 0.380141] RSP <ffff88003c9f9c08>
[ 0.380141] CR2: 0000000000000020
[ 0.380141] ---[ end trace 8074b70c3d5e1d73 ]---
[ 0.475018] Kernel panic - not syncing: Attempted to kill init! exitcode=0x00000009
[ 0.475018]
[ 0.475068] Kernel Offset: 0x0 from 0xffffffff81000000 (relocation range: 0xffffffff80000000-0xffffffff9fffffff)
[ 0.475068] ---[ end Kernel panic - not syncing: Attempted to kill init! exitcode=0x00000009
[jejb: checkpatch fixes]
Signed-off-by: Fam Zheng <famz@redhat.com>
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Cc: stable@vger.kernel.org
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2014-04-14 04:16:09 +02:00
|
|
|
}
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
|
|
|
|
vscsi->affinity_hint_set = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtscsi_set_affinity(struct virtio_scsi *vscsi, bool affinity)
|
|
|
|
{
|
|
|
|
get_online_cpus();
|
|
|
|
__virtscsi_set_affinity(vscsi, affinity);
|
|
|
|
put_online_cpus();
|
|
|
|
}
|
|
|
|
|
2013-04-08 15:35:49 +02:00
|
|
|
static int virtscsi_cpu_callback(struct notifier_block *nfb,
|
|
|
|
unsigned long action, void *hcpu)
|
|
|
|
{
|
|
|
|
struct virtio_scsi *vscsi = container_of(nfb, struct virtio_scsi, nb);
|
|
|
|
switch(action) {
|
|
|
|
case CPU_ONLINE:
|
|
|
|
case CPU_ONLINE_FROZEN:
|
|
|
|
case CPU_DEAD:
|
|
|
|
case CPU_DEAD_FROZEN:
|
|
|
|
__virtscsi_set_affinity(vscsi, true);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
2012-06-13 16:56:32 +02:00
|
|
|
static void virtscsi_init_vq(struct virtio_scsi_vq *virtscsi_vq,
|
|
|
|
struct virtqueue *vq)
|
|
|
|
{
|
|
|
|
spin_lock_init(&virtscsi_vq->vq_lock);
|
|
|
|
virtscsi_vq->vq = vq;
|
|
|
|
}
|
|
|
|
|
2012-07-11 23:22:16 +02:00
|
|
|
static void virtscsi_scan(struct virtio_device *vdev)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = (struct Scsi_Host *)vdev->priv;
|
|
|
|
|
|
|
|
scsi_scan_host(shost);
|
|
|
|
}
|
|
|
|
|
2012-06-13 16:56:34 +02:00
|
|
|
static void virtscsi_remove_vqs(struct virtio_device *vdev)
|
|
|
|
{
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
struct Scsi_Host *sh = virtio_scsi_host(vdev);
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sh);
|
|
|
|
|
|
|
|
virtscsi_set_affinity(vscsi, false);
|
|
|
|
|
2012-06-13 16:56:34 +02:00
|
|
|
/* Stop all the virtqueues. */
|
|
|
|
vdev->config->reset(vdev);
|
|
|
|
|
|
|
|
vdev->config->del_vqs(vdev);
|
|
|
|
}
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
static int virtscsi_init(struct virtio_device *vdev,
|
2013-04-08 15:31:16 +02:00
|
|
|
struct virtio_scsi *vscsi)
|
2012-02-05 12:16:00 +01:00
|
|
|
{
|
|
|
|
int err;
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
u32 i;
|
|
|
|
u32 num_vqs;
|
|
|
|
vq_callback_t **callbacks;
|
|
|
|
const char **names;
|
|
|
|
struct virtqueue **vqs;
|
|
|
|
|
|
|
|
num_vqs = vscsi->num_queues + VIRTIO_SCSI_VQ_BASE;
|
|
|
|
vqs = kmalloc(num_vqs * sizeof(struct virtqueue *), GFP_KERNEL);
|
|
|
|
callbacks = kmalloc(num_vqs * sizeof(vq_callback_t *), GFP_KERNEL);
|
|
|
|
names = kmalloc(num_vqs * sizeof(char *), GFP_KERNEL);
|
|
|
|
|
|
|
|
if (!callbacks || !vqs || !names) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-06-13 16:56:34 +02:00
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
callbacks[0] = virtscsi_ctrl_done;
|
|
|
|
callbacks[1] = virtscsi_event_done;
|
|
|
|
names[0] = "control";
|
|
|
|
names[1] = "event";
|
|
|
|
for (i = VIRTIO_SCSI_VQ_BASE; i < num_vqs; i++) {
|
|
|
|
callbacks[i] = virtscsi_req_done;
|
|
|
|
names[i] = "request";
|
|
|
|
}
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
/* Discover virtqueues and write information to configuration. */
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
err = vdev->config->find_vqs(vdev, num_vqs, vqs, callbacks, names);
|
2012-02-05 12:16:00 +01:00
|
|
|
if (err)
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
goto out;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
2012-06-13 16:56:32 +02:00
|
|
|
virtscsi_init_vq(&vscsi->ctrl_vq, vqs[0]);
|
|
|
|
virtscsi_init_vq(&vscsi->event_vq, vqs[1]);
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
for (i = VIRTIO_SCSI_VQ_BASE; i < num_vqs; i++)
|
|
|
|
virtscsi_init_vq(&vscsi->req_vqs[i - VIRTIO_SCSI_VQ_BASE],
|
|
|
|
vqs[i]);
|
|
|
|
|
|
|
|
virtscsi_set_affinity(vscsi, true);
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
virtscsi_config_set(vdev, cdb_size, VIRTIO_SCSI_CDB_SIZE);
|
|
|
|
virtscsi_config_set(vdev, sense_size, VIRTIO_SCSI_SENSE_SIZE);
|
2012-06-13 16:56:34 +02:00
|
|
|
|
2012-07-05 11:06:43 +02:00
|
|
|
if (virtio_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG))
|
|
|
|
virtscsi_kick_event_all(vscsi);
|
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
err = 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(names);
|
|
|
|
kfree(callbacks);
|
|
|
|
kfree(vqs);
|
|
|
|
if (err)
|
|
|
|
virtscsi_remove_vqs(vdev);
|
2012-06-13 16:56:34 +02:00
|
|
|
return err;
|
2012-02-05 12:16:00 +01:00
|
|
|
}
|
|
|
|
|
2012-12-21 22:08:55 +01:00
|
|
|
static int virtscsi_probe(struct virtio_device *vdev)
|
2012-02-05 12:16:00 +01:00
|
|
|
{
|
|
|
|
struct Scsi_Host *shost;
|
|
|
|
struct virtio_scsi *vscsi;
|
2014-02-23 03:23:33 +01:00
|
|
|
int err, host_prot;
|
2012-06-13 16:56:34 +02:00
|
|
|
u32 sg_elems, num_targets;
|
2012-02-05 12:16:00 +01:00
|
|
|
u32 cmd_per_lun;
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
u32 num_queues;
|
|
|
|
struct scsi_host_template *hostt;
|
|
|
|
|
|
|
|
/* We need to know how many queues before we allocate. */
|
|
|
|
num_queues = virtscsi_config_get(vdev, num_queues) ? : 1;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
2012-06-13 16:56:34 +02:00
|
|
|
num_targets = virtscsi_config_get(vdev, max_target) + 1;
|
2012-02-05 12:16:00 +01:00
|
|
|
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
if (num_queues == 1)
|
|
|
|
hostt = &virtscsi_host_template_single;
|
|
|
|
else
|
|
|
|
hostt = &virtscsi_host_template_multi;
|
|
|
|
|
|
|
|
shost = scsi_host_alloc(hostt,
|
|
|
|
sizeof(*vscsi) + sizeof(vscsi->req_vqs[0]) * num_queues);
|
2012-02-05 12:16:00 +01:00
|
|
|
if (!shost)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2012-06-13 16:56:34 +02:00
|
|
|
sg_elems = virtscsi_config_get(vdev, seg_max) ?: 1;
|
2012-02-05 12:16:00 +01:00
|
|
|
shost->sg_tablesize = sg_elems;
|
|
|
|
vscsi = shost_priv(shost);
|
|
|
|
vscsi->vdev = vdev;
|
virtio-scsi: introduce multiqueue support
This patch adds queue steering to virtio-scsi. When a target is sent
multiple requests, we always drive them to the same queue so that FIFO
processing order is kept. However, if a target was idle, we can choose
a queue arbitrarily. In this case the queue is chosen according to the
current VCPU, so the driver expects the number of request queues to be
equal to the number of VCPUs. This makes it easy and fast to select
the queue, and also lets the driver optimize the IRQ affinity for the
virtqueues (each virtqueue's affinity is set to the CPU that "owns"
the queue).
The speedup comes from improving cache locality and giving CPU affinity
to the virtqueues, which is why this scheme was selected. Assuming that
the thread that is sending requests to the device is I/O-bound, it is
likely to be sleeping at the time the ISR is executed, and thus executing
the ISR on the same processor that sent the requests is cheap.
However, the kernel will not execute the ISR on the "best" processor
unless you explicitly set the affinity. This is because in practice
you will have many such I/O-bound processes and thus many otherwise
idle processors. Then the kernel will execute the ISR on a random
processor, rather than the one that is sending requests to the device.
The alternative to per-CPU virtqueues is per-target virtqueues. To
achieve the same locality, we could dynamically choose the virtqueue's
affinity based on the CPU of the last task that sent a request. This
is less appealing because we do not set the affinity directly---we only
provide a hint to the irqbalanced running in userspace. Dynamically
changing the affinity only works if the userspace applies the hint
fast enough.
Cc: linux-scsi@vger.kernel.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Reviewed-by: Asias He <asias@redhat.com>
Tested-by: Venkatesh Srinivas <venkateshs@google.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2013-04-08 15:33:25 +02:00
|
|
|
vscsi->num_queues = num_queues;
|
2012-02-05 12:16:00 +01:00
|
|
|
vdev->priv = shost;
|
|
|
|
|
2013-04-08 15:31:16 +02:00
|
|
|
err = virtscsi_init(vdev, vscsi);
|
2012-02-05 12:16:00 +01:00
|
|
|
if (err)
|
|
|
|
goto virtscsi_init_failed;
|
|
|
|
|
2013-04-08 15:35:49 +02:00
|
|
|
vscsi->nb.notifier_call = &virtscsi_cpu_callback;
|
|
|
|
err = register_hotcpu_notifier(&vscsi->nb);
|
|
|
|
if (err) {
|
|
|
|
pr_err("registering cpu notifier failed\n");
|
|
|
|
goto scsi_add_host_failed;
|
|
|
|
}
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
cmd_per_lun = virtscsi_config_get(vdev, cmd_per_lun) ?: 1;
|
|
|
|
shost->cmd_per_lun = min_t(u32, cmd_per_lun, shost->can_queue);
|
|
|
|
shost->max_sectors = virtscsi_config_get(vdev, max_sectors) ?: 0xFFFF;
|
2012-10-02 17:25:47 +02:00
|
|
|
|
|
|
|
/* LUNs > 256 are reported with format 1, so they go in the range
|
|
|
|
* 16640-32767.
|
|
|
|
*/
|
|
|
|
shost->max_lun = virtscsi_config_get(vdev, max_lun) + 1 + 0x4000;
|
2012-06-13 16:56:34 +02:00
|
|
|
shost->max_id = num_targets;
|
2012-02-05 12:16:00 +01:00
|
|
|
shost->max_channel = 0;
|
|
|
|
shost->max_cmd_len = VIRTIO_SCSI_CDB_SIZE;
|
2014-02-23 03:23:33 +01:00
|
|
|
|
|
|
|
if (virtio_has_feature(vdev, VIRTIO_SCSI_F_T10_PI)) {
|
|
|
|
host_prot = SHOST_DIF_TYPE1_PROTECTION | SHOST_DIF_TYPE2_PROTECTION |
|
|
|
|
SHOST_DIF_TYPE3_PROTECTION | SHOST_DIX_TYPE1_PROTECTION |
|
|
|
|
SHOST_DIX_TYPE2_PROTECTION | SHOST_DIX_TYPE3_PROTECTION;
|
|
|
|
|
|
|
|
scsi_host_set_prot(shost, host_prot);
|
|
|
|
scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
|
|
|
|
}
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
err = scsi_add_host(shost, &vdev->dev);
|
|
|
|
if (err)
|
|
|
|
goto scsi_add_host_failed;
|
2012-07-11 23:22:16 +02:00
|
|
|
/*
|
|
|
|
* scsi_scan_host() happens in virtscsi_scan() via virtio_driver->scan()
|
|
|
|
* after VIRTIO_CONFIG_S_DRIVER_OK has been set..
|
|
|
|
*/
|
2012-02-05 12:16:00 +01:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
scsi_add_host_failed:
|
|
|
|
vdev->config->del_vqs(vdev);
|
|
|
|
virtscsi_init_failed:
|
|
|
|
scsi_host_put(shost);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-12-21 22:08:55 +01:00
|
|
|
static void virtscsi_remove(struct virtio_device *vdev)
|
2012-02-05 12:16:00 +01:00
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = virtio_scsi_host(vdev);
|
2012-07-05 11:06:43 +02:00
|
|
|
struct virtio_scsi *vscsi = shost_priv(shost);
|
|
|
|
|
|
|
|
if (virtio_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG))
|
|
|
|
virtscsi_cancel_event_work(vscsi);
|
2012-02-05 12:16:00 +01:00
|
|
|
|
|
|
|
scsi_remove_host(shost);
|
|
|
|
|
2013-04-08 15:35:49 +02:00
|
|
|
unregister_hotcpu_notifier(&vscsi->nb);
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
virtscsi_remove_vqs(vdev);
|
|
|
|
scsi_host_put(shost);
|
|
|
|
}
|
|
|
|
|
2013-09-17 01:55:23 +02:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-02-05 12:16:00 +01:00
|
|
|
static int virtscsi_freeze(struct virtio_device *vdev)
|
|
|
|
{
|
2014-01-16 00:48:48 +01:00
|
|
|
struct Scsi_Host *sh = virtio_scsi_host(vdev);
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sh);
|
|
|
|
|
|
|
|
unregister_hotcpu_notifier(&vscsi->nb);
|
2012-02-05 12:16:00 +01:00
|
|
|
virtscsi_remove_vqs(vdev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int virtscsi_restore(struct virtio_device *vdev)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *sh = virtio_scsi_host(vdev);
|
|
|
|
struct virtio_scsi *vscsi = shost_priv(sh);
|
2014-01-16 00:48:48 +01:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = virtscsi_init(vdev, vscsi);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = register_hotcpu_notifier(&vscsi->nb);
|
|
|
|
if (err)
|
|
|
|
vdev->config->del_vqs(vdev);
|
2012-02-05 12:16:00 +01:00
|
|
|
|
2014-01-16 00:48:48 +01:00
|
|
|
return err;
|
2012-02-05 12:16:00 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static struct virtio_device_id id_table[] = {
|
|
|
|
{ VIRTIO_ID_SCSI, VIRTIO_DEV_ANY_ID },
|
|
|
|
{ 0 },
|
|
|
|
};
|
|
|
|
|
2012-07-05 11:06:43 +02:00
|
|
|
static unsigned int features[] = {
|
2012-10-02 17:25:48 +02:00
|
|
|
VIRTIO_SCSI_F_HOTPLUG,
|
|
|
|
VIRTIO_SCSI_F_CHANGE,
|
2014-02-23 03:23:33 +01:00
|
|
|
VIRTIO_SCSI_F_T10_PI,
|
2012-07-05 11:06:43 +02:00
|
|
|
};
|
|
|
|
|
2012-02-05 12:16:00 +01:00
|
|
|
static struct virtio_driver virtio_scsi_driver = {
|
2012-07-05 11:06:43 +02:00
|
|
|
.feature_table = features,
|
|
|
|
.feature_table_size = ARRAY_SIZE(features),
|
2012-02-05 12:16:00 +01:00
|
|
|
.driver.name = KBUILD_MODNAME,
|
|
|
|
.driver.owner = THIS_MODULE,
|
|
|
|
.id_table = id_table,
|
|
|
|
.probe = virtscsi_probe,
|
2012-07-11 23:22:16 +02:00
|
|
|
.scan = virtscsi_scan,
|
2013-09-17 01:55:23 +02:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-02-05 12:16:00 +01:00
|
|
|
.freeze = virtscsi_freeze,
|
|
|
|
.restore = virtscsi_restore,
|
|
|
|
#endif
|
2012-12-21 22:08:55 +01:00
|
|
|
.remove = virtscsi_remove,
|
2012-02-05 12:16:00 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init init(void)
|
|
|
|
{
|
|
|
|
int ret = -ENOMEM;
|
|
|
|
|
|
|
|
virtscsi_cmd_cache = KMEM_CACHE(virtio_scsi_cmd, 0);
|
|
|
|
if (!virtscsi_cmd_cache) {
|
2013-03-12 06:04:40 +01:00
|
|
|
pr_err("kmem_cache_create() for virtscsi_cmd_cache failed\n");
|
2012-02-05 12:16:00 +01:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
virtscsi_cmd_pool =
|
|
|
|
mempool_create_slab_pool(VIRTIO_SCSI_MEMPOOL_SZ,
|
|
|
|
virtscsi_cmd_cache);
|
|
|
|
if (!virtscsi_cmd_pool) {
|
2013-03-12 06:04:40 +01:00
|
|
|
pr_err("mempool_create() for virtscsi_cmd_pool failed\n");
|
2012-02-05 12:16:00 +01:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
ret = register_virtio_driver(&virtio_scsi_driver);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
if (virtscsi_cmd_pool) {
|
|
|
|
mempool_destroy(virtscsi_cmd_pool);
|
|
|
|
virtscsi_cmd_pool = NULL;
|
|
|
|
}
|
|
|
|
if (virtscsi_cmd_cache) {
|
|
|
|
kmem_cache_destroy(virtscsi_cmd_cache);
|
|
|
|
virtscsi_cmd_cache = NULL;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit fini(void)
|
|
|
|
{
|
|
|
|
unregister_virtio_driver(&virtio_scsi_driver);
|
|
|
|
mempool_destroy(virtscsi_cmd_pool);
|
|
|
|
kmem_cache_destroy(virtscsi_cmd_cache);
|
|
|
|
}
|
|
|
|
module_init(init);
|
|
|
|
module_exit(fini);
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(virtio, id_table);
|
|
|
|
MODULE_DESCRIPTION("Virtio SCSI HBA driver");
|
|
|
|
MODULE_LICENSE("GPL");
|