virtio-scsi: use virtqueue_add_sgs for command buffers (682993b4) · Commits · 戴 / test

drivers/scsi/virtio_scsi.c

+37 −63

Original line number	Diff line number	Diff line
		@@ -61,11 +61,8 @@ struct virtio_scsi_vq {

		/* Per-target queue 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;

		/* For sglist construction when adding commands to the virtqueue. */
		struct scatterlist sg[];
		};

		/* Driver instance state */
		@@ -353,75 +350,61 @@ static void virtscsi_event_done(struct virtqueue *vq)
		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
		* @vscsi : virtio_scsi state
		* virtscsi_add_cmd - add a virtio_scsi_cmd to a virtqueue
		* @vq : the struct virtqueue we're talking about
		* @cmd : command structure
		* @out_num : number of read-only elements
		* @in_num : number of write-only elements
		* @req_size : size of the request buffer
		* @resp_size : size of the response buffer
		*
		* Called with tgt_lock held.
		* @gfp : flags to use for memory allocations
		*/
		static void virtscsi_map_cmd(struct virtio_scsi_target_state *tgt,
		static int virtscsi_add_cmd(struct virtqueue *vq,
		struct virtio_scsi_cmd *cmd,
		unsigned out_num, unsigned in_num,
		size_t req_size, size_t resp_size)
		size_t req_size, size_t resp_size, gfp_t gfp)
		{
		struct scsi_cmnd *sc = cmd->sc;
		struct scatterlist *sg = tgt->sg;
		unsigned int idx = 0;
		struct scatterlist *sgs[4], req, resp;
		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. */
		sg_set_buf(&sg[idx++], &cmd->req, req_size);
		sg_init_one(&req, &cmd->req, req_size);
		sgs[out_num++] = &req;

		/* Data-out buffer. */
		if (sc && sc->sc_data_direction != DMA_FROM_DEVICE)
		virtscsi_map_sgl(sg, &idx, scsi_out(sc));

		*out_num = idx;
		if (out)
		sgs[out_num++] = out->sgl;

		/* 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 */
		if (sc && sc->sc_data_direction != DMA_TO_DEVICE)
		virtscsi_map_sgl(sg, &idx, scsi_in(sc));
		if (in)
		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,
		struct virtio_scsi_vq *vq,
		static int virtscsi_kick_cmd(struct virtio_scsi_vq *vq,
		struct virtio_scsi_cmd *cmd,
		size_t req_size, size_t resp_size, gfp_t gfp)
		{
		unsigned int out_num, in_num;
		unsigned long flags;
		int err;
		bool needs_kick = false;

		spin_lock_irqsave(&tgt->tgt_lock, flags);
		virtscsi_map_cmd(tgt, cmd, &out_num, &in_num, req_size, resp_size);

		spin_lock(&vq->vq_lock);
		err = virtqueue_add_buf(vq->vq, tgt->sg, out_num, in_num, cmd, gfp);
		spin_unlock(&tgt->tgt_lock);
		spin_lock_irqsave(&vq->vq_lock, flags);
		err = virtscsi_add_cmd(vq->vq, cmd, req_size, resp_size, gfp);
		if (!err)
		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)
		{
		struct virtio_scsi *vscsi = shost_priv(sh);
		struct virtio_scsi_target_state *tgt = vscsi->tgt[sc->device->id];
		struct virtio_scsi_cmd *cmd;
		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);
		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,
		GFP_ATOMIC) == 0)
		ret = 0;
		@@ -483,11 +465,10 @@ out:
		static int virtscsi_tmf(struct virtio_scsi vscsi, struct virtio_scsi_cmd cmd)
		{
		DECLARE_COMPLETION_ONSTACK(comp);
		struct virtio_scsi_target_state *tgt = vscsi->tgt[cmd->sc->device->id];
		int ret = FAILED;

		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,
		GFP_NOIO) < 0)
		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(
		struct virtio_device *vdev, int sg_elems)
		struct virtio_device *vdev)
		{
		struct virtio_scsi_target_state *tgt;
		gfp_t gfp_mask = GFP_KERNEL;

		/* We need extra sg elements at head and tail. */
		tgt = kmalloc(sizeof(tgt) + sizeof(tgt->sg[0]) (sg_elems + 2),
		gfp_mask);

		tgt = kmalloc(sizeof(*tgt), gfp_mask);
		if (!tgt)
		return NULL;

		spin_lock_init(&tgt->tgt_lock);
		sg_init_table(tgt->sg, sg_elems + 2);
		return tgt;
		}

		@@ -635,7 +612,7 @@ static int virtscsi_init(struct virtio_device *vdev,
		{
		int err;
		struct virtqueue *vqs[3];
		u32 i, sg_elems;
		u32 i;

		vq_callback_t *callbacks[] = {
		virtscsi_ctrl_done,
		@@ -663,11 +640,8 @@ static int virtscsi_init(struct virtio_device *vdev,
		if (virtio_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG))
		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++) {
		vscsi->tgt[i] = virtscsi_alloc_tgt(vdev, sg_elems);
		vscsi->tgt[i] = virtscsi_alloc_tgt(vdev);
		if (!vscsi->tgt[i]) {
		err = -ENOMEM;
		goto out;

Admin message