UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

virtio-scsi: use virtqueue_add_sgs for command buffers 

Using the new virtqueue_add_sgs function lets us simplify the queueing
path.  In particular, all data protected by the tgt_lock is just gone
(multiqueue will find a new use for the lock).

Signed-off-by: Wanlong Gao <gaowanlong@cn.fujitsu.com>
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Asias He <asias@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Wanlong Gao 2013-03-20 15:44:28 +10:30 committed by Rusty Russell
parent 0a11cc36f7
commit 682993b4e4
1 changed files with 37 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
drivers/scsi/virtio_scsi.c
View File

@ -61,11 +61,8 @@ struct virtio_scsi_vq {
/* Per-target queue state */ /* Per-target queue state */
struct virtio_scsi_target_state { struct virtio_scsi_target_state {
/* Protects sg. Lock hierarchy is tgt_lock -> vq_lock. */ /* Never held at the same time as vq_lock. */
spinlock_t tgt_lock; spinlock_t tgt_lock;
/* For sglist construction when adding commands to the virtqueue. */
struct scatterlist sg[];
}; };
/* Driver instance state */ /* Driver instance state */
@ -353,75 +350,61 @@ static void virtscsi_event_done(struct virtqueue *vq)
spin_unlock_irqrestore(&vscsi->event_vq.vq_lock, flags); spin_unlock_irqrestore(&vscsi->event_vq.vq_lock, flags);
}; };
static void virtscsi_map_sgl(struct scatterlist *sg, unsigned int *p_idx,
struct scsi_data_buffer *sdb)
{
struct sg_table *table = &sdb->table;
struct scatterlist *sg_elem;
unsigned int idx = *p_idx;
int i;
for_each_sg(table->sgl, sg_elem, table->nents, i)
sg[idx++] = *sg_elem;
*p_idx = idx;
}
/** /**
* virtscsi_map_cmd - map a scsi_cmd to a virtqueue scatterlist * virtscsi_add_cmd - add a virtio_scsi_cmd to a virtqueue
* @vscsi : virtio_scsi state * @vq : the struct virtqueue we're talking about
* @cmd : command structure * @cmd : command structure
* @out_num : number of read-only elements
* @in_num : number of write-only elements
* @req_size : size of the request buffer * @req_size : size of the request buffer
* @resp_size : size of the response buffer * @resp_size : size of the response buffer
* * @gfp : flags to use for memory allocations
* Called with tgt_lock held.
*/ */
static void virtscsi_map_cmd(struct virtio_scsi_target_state *tgt, static int virtscsi_add_cmd(struct virtqueue *vq,
struct virtio_scsi_cmd *cmd, struct virtio_scsi_cmd *cmd,
unsigned *out_num, unsigned *in_num, size_t req_size, size_t resp_size, gfp_t gfp)
size_t req_size, size_t resp_size)
{ {
struct scsi_cmnd *sc = cmd->sc; struct scsi_cmnd *sc = cmd->sc;
struct scatterlist *sg = tgt->sg; struct scatterlist *sgs[4], req, resp;
unsigned int idx = 0; 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;
}
/* Request header. */ /* Request header. */
sg_set_buf(&sg[idx++], &cmd->req, req_size); sg_init_one(&req, &cmd->req, req_size);
sgs[out_num++] = &req;
/* Data-out buffer. */ /* Data-out buffer. */
if (sc && sc->sc_data_direction != DMA_FROM_DEVICE) if (out)
virtscsi_map_sgl(sg, &idx, scsi_out(sc)); sgs[out_num++] = out->sgl;
*out_num = idx;
/* Response header. */ /* Response header. */
sg_set_buf(&sg[idx++], &cmd->resp, resp_size); sg_init_one(&resp, &cmd->resp, resp_size);
sgs[out_num + in_num++] = &resp;
/* Data-in buffer */ /* Data-in buffer */
if (sc && sc->sc_data_direction != DMA_TO_DEVICE) if (in)
virtscsi_map_sgl(sg, &idx, scsi_in(sc)); sgs[out_num + in_num++] = in->sgl;
*in_num = idx - *out_num; return virtqueue_add_sgs(vq, sgs, out_num, in_num, cmd, gfp);
} }
static int virtscsi_kick_cmd(struct virtio_scsi_target_state *tgt, static int virtscsi_kick_cmd(struct virtio_scsi_vq *vq,
struct virtio_scsi_vq *vq,
struct virtio_scsi_cmd *cmd, struct virtio_scsi_cmd *cmd,
size_t req_size, size_t resp_size, gfp_t gfp) size_t req_size, size_t resp_size, gfp_t gfp)
{ {
unsigned int out_num, in_num;
unsigned long flags; unsigned long flags;
int err; int err;
bool needs_kick = false; bool needs_kick = false;
spin_lock_irqsave(&tgt->tgt_lock, flags); spin_lock_irqsave(&vq->vq_lock, flags);
virtscsi_map_cmd(tgt, cmd, &out_num, &in_num, req_size, resp_size); err = virtscsi_add_cmd(vq->vq, cmd, req_size, resp_size, gfp);
spin_lock(&vq->vq_lock);
err = virtqueue_add_buf(vq->vq, tgt->sg, out_num, in_num, cmd, gfp);
spin_unlock(&tgt->tgt_lock);
if (!err) if (!err)
needs_kick = virtqueue_kick_prepare(vq->vq); needs_kick = virtqueue_kick_prepare(vq->vq);
@ -435,7 +418,6 @@ static int virtscsi_kick_cmd(struct virtio_scsi_target_state *tgt,
static int virtscsi_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc) static int virtscsi_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc)
{ {
struct virtio_scsi *vscsi = shost_priv(sh); struct virtio_scsi *vscsi = shost_priv(sh);
struct virtio_scsi_target_state *tgt = vscsi->tgt[sc->device->id];
struct virtio_scsi_cmd *cmd; struct virtio_scsi_cmd *cmd;
int ret; int ret;
@ -469,7 +451,7 @@ static int virtscsi_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc)
BUG_ON(sc->cmd_len > VIRTIO_SCSI_CDB_SIZE); BUG_ON(sc->cmd_len > VIRTIO_SCSI_CDB_SIZE);
memcpy(cmd->req.cmd.cdb, sc->cmnd, sc->cmd_len); memcpy(cmd->req.cmd.cdb, sc->cmnd, sc->cmd_len);
if (virtscsi_kick_cmd(tgt, &vscsi->req_vq, cmd, if (virtscsi_kick_cmd(&vscsi->req_vq, cmd,
sizeof cmd->req.cmd, sizeof cmd->resp.cmd, sizeof cmd->req.cmd, sizeof cmd->resp.cmd,
GFP_ATOMIC) == 0) GFP_ATOMIC) == 0)
ret = 0; ret = 0;
@ -483,11 +465,10 @@ out:
static int virtscsi_tmf(struct virtio_scsi *vscsi, struct virtio_scsi_cmd *cmd) static int virtscsi_tmf(struct virtio_scsi *vscsi, struct virtio_scsi_cmd *cmd)
{ {
DECLARE_COMPLETION_ONSTACK(comp); DECLARE_COMPLETION_ONSTACK(comp);
struct virtio_scsi_target_state *tgt = vscsi->tgt[cmd->sc->device->id];
int ret = FAILED; int ret = FAILED;
cmd->comp = &comp; cmd->comp = &comp;
if (virtscsi_kick_cmd(tgt, &vscsi->ctrl_vq, cmd, if (virtscsi_kick_cmd(&vscsi->ctrl_vq, cmd,
sizeof cmd->req.tmf, sizeof cmd->resp.tmf, sizeof cmd->req.tmf, sizeof cmd->resp.tmf,
GFP_NOIO) < 0) GFP_NOIO) < 0)
goto out; goto out;
@ -588,20 +569,16 @@ static void virtscsi_init_vq(struct virtio_scsi_vq *virtscsi_vq,
} }
static struct virtio_scsi_target_state *virtscsi_alloc_tgt( static struct virtio_scsi_target_state *virtscsi_alloc_tgt(
struct virtio_device *vdev, int sg_elems) struct virtio_device *vdev)
{ {
struct virtio_scsi_target_state *tgt; struct virtio_scsi_target_state *tgt;
gfp_t gfp_mask = GFP_KERNEL; gfp_t gfp_mask = GFP_KERNEL;
/* We need extra sg elements at head and tail. */ tgt = kmalloc(sizeof(*tgt), gfp_mask);
tgt = kmalloc(sizeof(*tgt) + sizeof(tgt->sg[0]) * (sg_elems + 2),
gfp_mask);
if (!tgt) if (!tgt)
return NULL; return NULL;
spin_lock_init(&tgt->tgt_lock); spin_lock_init(&tgt->tgt_lock);
sg_init_table(tgt->sg, sg_elems + 2);
return tgt; return tgt;
} }
@ -635,7 +612,7 @@ static int virtscsi_init(struct virtio_device *vdev,
{ {
int err; int err;
struct virtqueue *vqs[3]; struct virtqueue *vqs[3];
u32 i, sg_elems; u32 i;
vq_callback_t *callbacks[] = { vq_callback_t *callbacks[] = {
virtscsi_ctrl_done, virtscsi_ctrl_done,
@ -663,11 +640,8 @@ static int virtscsi_init(struct virtio_device *vdev,
if (virtio_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG)) if (virtio_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG))
virtscsi_kick_event_all(vscsi); virtscsi_kick_event_all(vscsi);
/* We need to know how many segments before we allocate. */
sg_elems = virtscsi_config_get(vdev, seg_max) ?: 1;
for (i = 0; i < num_targets; i++) { for (i = 0; i < num_targets; i++) {
vscsi->tgt[i] = virtscsi_alloc_tgt(vdev, sg_elems); vscsi->tgt[i] = virtscsi_alloc_tgt(vdev);
if (!vscsi->tgt[i]) { if (!vscsi->tgt[i]) {
err = -ENOMEM; err = -ENOMEM;
goto out; goto out;