Commit 4635873c authored by Ming Lei's avatar Ming Lei Committed by Martin K. Petersen
Browse files

scsi: lib/sg_pool.c: improve APIs for allocating sg pool 



sg_alloc_table_chained() currently allows the caller to provide one
preallocated SGL and returns if the requested number isn't bigger than
size of that SGL. This is used to inline an SGL for an IO request.

However, scattergather code only allows that size of the 1st preallocated
SGL to be SG_CHUNK_SIZE(128). This means a substantial amount of memory
(4KB) is claimed for the SGL for each IO request. If the I/O is small, it
would be prudent to allocate a smaller SGL.

Introduce an extra parameter to sg_alloc_table_chained() and
sg_free_table_chained() for specifying size of the preallocated SGL.

Both __sg_free_table() and __sg_alloc_table() assume that each SGL has the
same size except for the last one.  Change the code to allow both functions
to accept a variable size for the 1st preallocated SGL.

[mkp: attempted to clarify commit desc]

Cc: Christoph Hellwig <hch@lst.de>
Cc: Bart Van Assche <bvanassche@acm.org>
Cc: Ewan D. Milne <emilne@redhat.com>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Sagi Grimberg <sagi@grimberg.me>
Cc: Chuck Lever <chuck.lever@oracle.com>
Cc: netdev@vger.kernel.org
Cc: linux-nvme@lists.infradead.org
Suggested-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarMing Lei <ming.lei@redhat.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
parent ee5a1dbf

drivers/nvme/host/fc.c

+4 −3
Original line number Diff line number Diff line
@@ -2112,7 +2112,8 @@ nvme_fc_map_data(struct nvme_fc_ctrl *ctrl, struct request *rq, 


	freq->sg_table.sgl = freq->first_sgl;

	ret = sg_alloc_table_chained(&freq->sg_table,

			blk_rq_nr_phys_segments(rq), freq->sg_table.sgl);

			blk_rq_nr_phys_segments(rq), freq->sg_table.sgl,

			SG_CHUNK_SIZE);

	if (ret)

		return -ENOMEM;
@@ -2122,7 +2123,7 @@ nvme_fc_map_data(struct nvme_fc_ctrl *ctrl, struct request *rq, 
	freq->sg_cnt = fc_dma_map_sg(ctrl->lport->dev, freq->sg_table.sgl,

				op->nents, dir);

	if (unlikely(freq->sg_cnt <= 0)) {

		sg_free_table_chained(&freq->sg_table, true);

		sg_free_table_chained(&freq->sg_table, SG_CHUNK_SIZE);

		freq->sg_cnt = 0;

		return -EFAULT;

	}
@@ -2148,7 +2149,7 @@ nvme_fc_unmap_data(struct nvme_fc_ctrl *ctrl, struct request *rq, 


	nvme_cleanup_cmd(rq);



	sg_free_table_chained(&freq->sg_table, true);

	sg_free_table_chained(&freq->sg_table, SG_CHUNK_SIZE);



	freq->sg_cnt = 0;

}

drivers/nvme/host/rdma.c

+4 −3
Original line number Diff line number Diff line
@@ -1133,7 +1133,7 @@ static void nvme_rdma_unmap_data(struct nvme_rdma_queue *queue, 
				    WRITE ? DMA_TO_DEVICE : DMA_FROM_DEVICE);



	nvme_cleanup_cmd(rq);

	sg_free_table_chained(&req->sg_table, true);

	sg_free_table_chained(&req->sg_table, SG_CHUNK_SIZE);

}



static int nvme_rdma_set_sg_null(struct nvme_command *c)
@@ -1248,7 +1248,8 @@ static int nvme_rdma_map_data(struct nvme_rdma_queue *queue, 


	req->sg_table.sgl = req->first_sgl;

	ret = sg_alloc_table_chained(&req->sg_table,

			blk_rq_nr_phys_segments(rq), req->sg_table.sgl);

			blk_rq_nr_phys_segments(rq), req->sg_table.sgl,

			SG_CHUNK_SIZE);

	if (ret)

		return -ENOMEM;
@@ -1288,7 +1289,7 @@ out_unmap_sg: 
			req->nents, rq_data_dir(rq) ==

			WRITE ? DMA_TO_DEVICE : DMA_FROM_DEVICE);

out_free_table:

	sg_free_table_chained(&req->sg_table, true);

	sg_free_table_chained(&req->sg_table, SG_CHUNK_SIZE);

	return ret;

}

drivers/nvme/target/loop.c

+2 −2
Original line number Diff line number Diff line
@@ -77,7 +77,7 @@ static void nvme_loop_complete_rq(struct request *req) 
	struct nvme_loop_iod *iod = blk_mq_rq_to_pdu(req);



	nvme_cleanup_cmd(req);

	sg_free_table_chained(&iod->sg_table, true);

	sg_free_table_chained(&iod->sg_table, SG_CHUNK_SIZE);

	nvme_complete_rq(req);

}
@@ -157,7 +157,7 @@ static blk_status_t nvme_loop_queue_rq(struct blk_mq_hw_ctx *hctx, 
		iod->sg_table.sgl = iod->first_sgl;

		if (sg_alloc_table_chained(&iod->sg_table,

				blk_rq_nr_phys_segments(req),

				iod->sg_table.sgl))

				iod->sg_table.sgl, SG_CHUNK_SIZE))

			return BLK_STS_RESOURCE;



		iod->req.sg = iod->sg_table.sgl;

drivers/scsi/scsi_lib.c

+6 −4
Original line number Diff line number Diff line
@@ -541,9 +541,9 @@ static void scsi_uninit_cmd(struct scsi_cmnd *cmd) 
static void scsi_mq_free_sgtables(struct scsi_cmnd *cmd)

{

	if (cmd->sdb.table.nents)

		sg_free_table_chained(&cmd->sdb.table, true);

		sg_free_table_chained(&cmd->sdb.table, SG_CHUNK_SIZE);

	if (scsi_prot_sg_count(cmd))

		sg_free_table_chained(&cmd->prot_sdb->table, true);

		sg_free_table_chained(&cmd->prot_sdb->table, SG_CHUNK_SIZE);

}



static void scsi_mq_uninit_cmd(struct scsi_cmnd *cmd)
@@ -976,7 +976,8 @@ static blk_status_t scsi_init_sgtable(struct request *req, 
	 * If sg table allocation fails, requeue request later.

	 */

	if (unlikely(sg_alloc_table_chained(&sdb->table,

			blk_rq_nr_phys_segments(req), sdb->table.sgl)))

			blk_rq_nr_phys_segments(req), sdb->table.sgl,

			SG_CHUNK_SIZE)))

		return BLK_STS_RESOURCE;



	/*
@@ -1030,7 +1031,8 @@ blk_status_t scsi_init_io(struct scsi_cmnd *cmd) 
		ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio);



		if (sg_alloc_table_chained(&prot_sdb->table, ivecs,

				prot_sdb->table.sgl)) {

				prot_sdb->table.sgl,

				SG_CHUNK_SIZE)) {

			ret = BLK_STS_RESOURCE;

			goto out_free_sgtables;

		}

include/linux/scatterlist.h

+7 −4
Original line number Diff line number Diff line
@@ -266,10 +266,11 @@ int sg_split(struct scatterlist *in, const int in_mapped_nents, 
typedef struct scatterlist *(sg_alloc_fn)(unsigned int, gfp_t);

typedef void (sg_free_fn)(struct scatterlist *, unsigned int);



void __sg_free_table(struct sg_table *, unsigned int, bool, sg_free_fn *);

void __sg_free_table(struct sg_table *, unsigned int, unsigned int,

		     sg_free_fn *);

void sg_free_table(struct sg_table *);

int __sg_alloc_table(struct sg_table *, unsigned int, unsigned int,

		     struct scatterlist *, gfp_t, sg_alloc_fn *);

		     struct scatterlist *, unsigned int, gfp_t, sg_alloc_fn *);

int sg_alloc_table(struct sg_table *, unsigned int, gfp_t);

int __sg_alloc_table_from_pages(struct sg_table *sgt, struct page **pages,

				unsigned int n_pages, unsigned int offset,
@@ -331,9 +332,11 @@ size_t sg_zero_buffer(struct scatterlist *sgl, unsigned int nents, 
#endif



#ifdef CONFIG_SG_POOL

void sg_free_table_chained(struct sg_table *table, bool first_chunk);

void sg_free_table_chained(struct sg_table *table,

			   unsigned nents_first_chunk);

int sg_alloc_table_chained(struct sg_table *table, int nents,

			   struct scatterlist *first_chunk);

			   struct scatterlist *first_chunk,

			   unsigned nents_first_chunk);

#endif



/*

CRA Git | Maintained and supported by SUSTech CRA and CCSE