Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e6dc783a authored by Nicholas Bellinger's avatar Nicholas Bellinger
Browse files

virtio-scsi: Enable DIF/DIX modes in SCSI host LLD 



This patch updates virtscsi_probe() to setup necessary Scsi_Host
level protection resources. (currently hardcoded to 1)

It changes virtscsi_add_cmd() to attach outgoing / incoming
protection SGLs preceeding the data payload, and is using the
new virtio_scsi_cmd_req_pi->pi_bytes[out,in] field to signal
to signal to vhost/scsi bytes to expect for protection data.

(Add missing #include <linux/blkdev.h> for blk_integrity - sfr + nab)

Acked-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Martin K. Petersen <martin.petersen@oracle.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Hannes Reinecke <hare@suse.de>
Cc: Sagi Grimberg <sagig@dev.mellanox.co.il>
Cc: H. Peter Anvin <hpa@zytor.com>
Signed-off-by: default avatarNicholas Bellinger <nab@linux-iscsi.org>
parent 95e7c434

drivers/scsi/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -1773,6 +1773,7 @@ config SCSI_BFA_FC 
config SCSI_VIRTIO

	tristate "virtio-scsi support"

	depends on VIRTIO

	select BLK_DEV_INTEGRITY

	help

          This is the virtual HBA driver for virtio.  If the kernel will

          be used in a virtual machine, say Y or M.

drivers/scsi/virtio_scsi.c

+69 −18
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
#include <linux/virtio_config.h>

#include <linux/virtio_scsi.h>

#include <linux/cpu.h>

#include <linux/blkdev.h>

#include <scsi/scsi_host.h>

#include <scsi/scsi_device.h>

#include <scsi/scsi_cmnd.h>
@@ -37,6 +38,7 @@ struct virtio_scsi_cmd { 
	struct completion *comp;

	union {

		struct virtio_scsi_cmd_req       cmd;

		struct virtio_scsi_cmd_req_pi    cmd_pi;

		struct virtio_scsi_ctrl_tmf_req  tmf;

		struct virtio_scsi_ctrl_an_req   an;

	} req;
@@ -440,7 +442,7 @@ static int virtscsi_add_cmd(struct virtqueue *vq, 
			    size_t req_size, size_t resp_size, gfp_t gfp)

{

	struct scsi_cmnd *sc = cmd->sc;

	struct scatterlist *sgs[4], req, resp;

	struct scatterlist *sgs[6], req, resp;

	struct sg_table *out, *in;

	unsigned out_num = 0, in_num = 0;
@@ -458,16 +460,24 @@ static int virtscsi_add_cmd(struct virtqueue *vq, 
	sgs[out_num++] = &req;



	/* Data-out buffer.  */

	if (out)

	if (out) {

		/* Place WRITE protection SGLs before Data OUT payload */

		if (scsi_prot_sg_count(sc))

			sgs[out_num++] = scsi_prot_sglist(sc);

		sgs[out_num++] = out->sgl;

	}



	/* Response header.  */

	sg_init_one(&resp, &cmd->resp, resp_size);

	sgs[out_num + in_num++] = &resp;



	/* Data-in buffer */

	if (in)

	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);

		sgs[out_num + in_num++] = in->sgl;

	}



	return virtqueue_add_sgs(vq, sgs, out_num, in_num, cmd, gfp);

}
@@ -492,12 +502,44 @@ static int virtscsi_kick_cmd(struct virtio_scsi_vq *vq, 
	return err;

}



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;

}



static int virtscsi_queuecommand(struct virtio_scsi *vscsi,

				 struct virtio_scsi_vq *req_vq,

				 struct scsi_cmnd *sc)

{

	struct virtio_scsi_cmd *cmd;

	int ret;

	int ret, req_size;



	struct Scsi_Host *shost = virtio_scsi_host(vscsi->vdev);

	BUG_ON(scsi_sg_count(sc) > shost->sg_tablesize);
@@ -515,22 +557,20 @@ static int virtscsi_queuecommand(struct virtio_scsi *vscsi, 


	memset(cmd, 0, sizeof(*cmd));

	cmd->sc = sc;

	cmd->req.cmd = (struct virtio_scsi_cmd_req){

		.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,

		.task_attr = VIRTIO_SCSI_S_SIMPLE,

		.prio = 0,

		.crn = 0,

	};



	BUG_ON(sc->cmd_len > VIRTIO_SCSI_CDB_SIZE);



	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);

	}



	if (virtscsi_kick_cmd(req_vq, cmd,

			      sizeof cmd->req.cmd, sizeof cmd->resp.cmd,

	if (virtscsi_kick_cmd(req_vq, cmd, req_size, sizeof(cmd->resp.cmd),

			      GFP_ATOMIC) == 0)

		ret = 0;

	else
@@ -871,7 +911,7 @@ static int virtscsi_probe(struct virtio_device *vdev) 
{

	struct Scsi_Host *shost;

	struct virtio_scsi *vscsi;

	int err;

	int err, host_prot;

	u32 sg_elems, num_targets;

	u32 cmd_per_lun;

	u32 num_queues;
@@ -921,6 +961,16 @@ static int virtscsi_probe(struct virtio_device *vdev) 
	shost->max_id = num_targets;

	shost->max_channel = 0;

	shost->max_cmd_len = VIRTIO_SCSI_CDB_SIZE;



	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);

	}



	err = scsi_add_host(shost, &vdev->dev);

	if (err)

		goto scsi_add_host_failed;
@@ -990,6 +1040,7 @@ static struct virtio_device_id id_table[] = { 
static unsigned int features[] = {

	VIRTIO_SCSI_F_HOTPLUG,

	VIRTIO_SCSI_F_CHANGE,

	VIRTIO_SCSI_F_T10_PI,

};



static struct virtio_driver virtio_scsi_driver = {