block/scsi: Provide a limit on the number of integrity segments (13f05c8d) · Commits · 戴 / test

block/blk-integrity.c

+72 −21

Original line number	Original line	Diff line number	Diff line
	@@ -32,24 +32,37 @@ static struct kmem_cache *integrity_cachep;

	/**		/**
	* blk_rq_count_integrity_sg - Count number of integrity scatterlist elements		* blk_rq_count_integrity_sg - Count number of integrity scatterlist elements
	* @rq: request with integrity metadata attached		* @q: request queue
			* @bio: bio with integrity metadata attached
	*		*
	* Description: Returns the number of elements required in a		* Description: Returns the number of elements required in a
	* scatterlist corresponding to the integrity metadata in a request.		* scatterlist corresponding to the integrity metadata in a bio.
	*/		*/
	int blk_rq_count_integrity_sg(struct request *rq)		int blk_rq_count_integrity_sg(struct request_queue q, struct bio bio)
	{		{
	struct bio_vec iv, ivprv;		struct bio_vec iv, ivprv = NULL;
	struct req_iterator iter;		unsigned int segments = 0;
	unsigned int segments;		unsigned int seg_size = 0;
			unsigned int i = 0;

	ivprv = NULL;		bio_for_each_integrity_vec(iv, bio, i) {
	segments = 0;

	rq_for_each_integrity_segment(iv, rq, iter) {		if (ivprv) {
			if (!BIOVEC_PHYS_MERGEABLE(ivprv, iv))
			goto new_segment;

			if (!BIOVEC_SEG_BOUNDARY(q, ivprv, iv))
			goto new_segment;

			if (seg_size + iv->bv_len > queue_max_segment_size(q))
			goto new_segment;

	if (!ivprv \|\| !BIOVEC_PHYS_MERGEABLE(ivprv, iv))		seg_size += iv->bv_len;
			} else {
			new_segment:
	segments++;		segments++;
			seg_size = iv->bv_len;
			}

	ivprv = iv;		ivprv = iv;
	}		}
	@@ -60,30 +73,34 @@ EXPORT_SYMBOL(blk_rq_count_integrity_sg);

	/**		/**
	* blk_rq_map_integrity_sg - Map integrity metadata into a scatterlist		* blk_rq_map_integrity_sg - Map integrity metadata into a scatterlist
	* @rq: request with integrity metadata attached		* @q: request queue
			* @bio: bio with integrity metadata attached
	* @sglist: target scatterlist		* @sglist: target scatterlist
	*		*
	* Description: Map the integrity vectors in request into a		* Description: Map the integrity vectors in request into a
	* scatterlist. The scatterlist must be big enough to hold all		* scatterlist. The scatterlist must be big enough to hold all
	* elements. I.e. sized using blk_rq_count_integrity_sg().		* elements. I.e. sized using blk_rq_count_integrity_sg().
	*/		*/
	int blk_rq_map_integrity_sg(struct request rq, struct scatterlist sglist)		int blk_rq_map_integrity_sg(struct request_queue q, struct bio bio,
			struct scatterlist *sglist)
	{		{
	struct bio_vec iv, ivprv;		struct bio_vec iv, ivprv = NULL;
	struct req_iterator iter;		struct scatterlist *sg = NULL;
	struct scatterlist *sg;		unsigned int segments = 0;
	unsigned int segments;		unsigned int i = 0;

	ivprv = NULL;		bio_for_each_integrity_vec(iv, bio, i) {
	sg = NULL;
	segments = 0;

	rq_for_each_integrity_segment(iv, rq, iter) {

	if (ivprv) {		if (ivprv) {
	if (!BIOVEC_PHYS_MERGEABLE(ivprv, iv))		if (!BIOVEC_PHYS_MERGEABLE(ivprv, iv))
	goto new_segment;		goto new_segment;

			if (!BIOVEC_SEG_BOUNDARY(q, ivprv, iv))
			goto new_segment;

			if (sg->length + iv->bv_len > queue_max_segment_size(q))
			goto new_segment;

	sg->length += iv->bv_len;		sg->length += iv->bv_len;
	} else {		} else {
	new_segment:		new_segment:
	@@ -162,6 +179,40 @@ int blk_integrity_compare(struct gendisk gd1, struct gendisk gd2)
	}		}
	EXPORT_SYMBOL(blk_integrity_compare);		EXPORT_SYMBOL(blk_integrity_compare);

			int blk_integrity_merge_rq(struct request_queue q, struct request req,
			struct request *next)
			{
			if (blk_integrity_rq(req) != blk_integrity_rq(next))
			return -1;

			if (req->nr_integrity_segments + next->nr_integrity_segments >
			q->limits.max_integrity_segments)
			return -1;

			return 0;
			}
			EXPORT_SYMBOL(blk_integrity_merge_rq);

			int blk_integrity_merge_bio(struct request_queue q, struct request req,
			struct bio *bio)
			{
			int nr_integrity_segs;
			struct bio *next = bio->bi_next;

			bio->bi_next = NULL;
			nr_integrity_segs = blk_rq_count_integrity_sg(q, bio);
			bio->bi_next = next;

			if (req->nr_integrity_segments + nr_integrity_segs >
			q->limits.max_integrity_segments)
			return -1;

			req->nr_integrity_segments += nr_integrity_segs;

			return 0;
			}
			EXPORT_SYMBOL(blk_integrity_merge_bio);

	struct integrity_sysfs_entry {		struct integrity_sysfs_entry {
	struct attribute attr;		struct attribute attr;
	ssize_t (show)(struct blk_integrity , char *);		ssize_t (show)(struct blk_integrity , char *);

block/blk-merge.c

+14 −9

Original line number	Original line	Diff line number	Diff line
	@@ -205,12 +205,11 @@ static inline int ll_new_hw_segment(struct request_queue *q,
	{		{
	int nr_phys_segs = bio_phys_segments(q, bio);		int nr_phys_segs = bio_phys_segments(q, bio);

	if (req->nr_phys_segments + nr_phys_segs > queue_max_segments(q)) {		if (req->nr_phys_segments + nr_phys_segs > queue_max_segments(q))
	req->cmd_flags \|= REQ_NOMERGE;		goto no_merge;
	if (req == q->last_merge)
	q->last_merge = NULL;		if (bio_integrity(bio) && blk_integrity_merge_bio(q, req, bio))
	return 0;		goto no_merge;
	}

	/*		/*
	* This will form the start of a new hw segment. Bump both		* This will form the start of a new hw segment. Bump both
	@@ -218,6 +217,12 @@ static inline int ll_new_hw_segment(struct request_queue *q,
	*/		*/
	req->nr_phys_segments += nr_phys_segs;		req->nr_phys_segments += nr_phys_segs;
	return 1;		return 1;

			no_merge:
			req->cmd_flags \|= REQ_NOMERGE;
			if (req == q->last_merge)
			q->last_merge = NULL;
			return 0;
	}		}

	int ll_back_merge_fn(struct request_queue q, struct request req,		int ll_back_merge_fn(struct request_queue q, struct request req,
	@@ -301,6 +306,9 @@ static int ll_merge_requests_fn(struct request_queue q, struct request req,
	if (total_phys_segments > queue_max_segments(q))		if (total_phys_segments > queue_max_segments(q))
	return 0;		return 0;

			if (blk_integrity_rq(req) && blk_integrity_merge_rq(q, req, next))
			return 0;

	/* Merge is OK... */		/* Merge is OK... */
	req->nr_phys_segments = total_phys_segments;		req->nr_phys_segments = total_phys_segments;
	return 1;		return 1;
	@@ -372,9 +380,6 @@ static int attempt_merge(struct request_queue q, struct request req,
	\|\| next->special)		\|\| next->special)
	return 0;		return 0;

	if (blk_integrity_rq(req) != blk_integrity_rq(next))
	return 0;

	/*		/*
	* If we are allowed to merge, then append bio list		* If we are allowed to merge, then append bio list
	* from next to rq and release next. merge_requests_fn		* from next to rq and release next. merge_requests_fn

block/blk-settings.c

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -111,6 +111,7 @@ EXPORT_SYMBOL_GPL(blk_queue_lld_busy);
	void blk_set_default_limits(struct queue_limits *lim)		void blk_set_default_limits(struct queue_limits *lim)
	{		{
	lim->max_segments = BLK_MAX_SEGMENTS;		lim->max_segments = BLK_MAX_SEGMENTS;
			lim->max_integrity_segments = 0;
	lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;		lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
	lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;		lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;
	lim->max_sectors = BLK_DEF_MAX_SECTORS;		lim->max_sectors = BLK_DEF_MAX_SECTORS;
	@@ -509,6 +510,8 @@ int blk_stack_limits(struct queue_limits t, struct queue_limits b,
	b->seg_boundary_mask);		b->seg_boundary_mask);

	t->max_segments = min_not_zero(t->max_segments, b->max_segments);		t->max_segments = min_not_zero(t->max_segments, b->max_segments);
			t->max_integrity_segments = min_not_zero(t->max_integrity_segments,
			b->max_integrity_segments);

	t->max_segment_size = min_not_zero(t->max_segment_size,		t->max_segment_size = min_not_zero(t->max_segment_size,
	b->max_segment_size);		b->max_segment_size);

block/blk-sysfs.c

+11 −0

Original line number	Original line	Diff line number	Diff line
	@@ -112,6 +112,11 @@ static ssize_t queue_max_segments_show(struct request_queue q, char page)
	return queue_var_show(queue_max_segments(q), (page));		return queue_var_show(queue_max_segments(q), (page));
	}		}

			static ssize_t queue_max_integrity_segments_show(struct request_queue q, char page)
			{
			return queue_var_show(q->limits.max_integrity_segments, (page));
			}

	static ssize_t queue_max_segment_size_show(struct request_queue q, char page)		static ssize_t queue_max_segment_size_show(struct request_queue q, char page)
	{		{
	if (test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags))		if (test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags))
	@@ -288,6 +293,11 @@ static struct queue_sysfs_entry queue_max_segments_entry = {
	.show = queue_max_segments_show,		.show = queue_max_segments_show,
	};		};

			static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
			.attr = {.name = "max_integrity_segments", .mode = S_IRUGO },
			.show = queue_max_integrity_segments_show,
			};

	static struct queue_sysfs_entry queue_max_segment_size_entry = {		static struct queue_sysfs_entry queue_max_segment_size_entry = {
	.attr = {.name = "max_segment_size", .mode = S_IRUGO },		.attr = {.name = "max_segment_size", .mode = S_IRUGO },
	.show = queue_max_segment_size_show,		.show = queue_max_segment_size_show,
	@@ -375,6 +385,7 @@ static struct attribute *default_attrs[] = {
	&queue_max_hw_sectors_entry.attr,		&queue_max_hw_sectors_entry.attr,
	&queue_max_sectors_entry.attr,		&queue_max_sectors_entry.attr,
	&queue_max_segments_entry.attr,		&queue_max_segments_entry.attr,
			&queue_max_integrity_segments_entry.attr,
	&queue_max_segment_size_entry.attr,		&queue_max_segment_size_entry.attr,
	&queue_iosched_entry.attr,		&queue_iosched_entry.attr,
	&queue_hw_sector_size_entry.attr,		&queue_hw_sector_size_entry.attr,

block/blk.h

+0 −8

Original line number	Original line	Diff line number	Diff line
	@@ -132,14 +132,6 @@ static inline int queue_congestion_off_threshold(struct request_queue *q)
	return q->nr_congestion_off;		return q->nr_congestion_off;
	}		}

	#if defined(CONFIG_BLK_DEV_INTEGRITY)

	#define rq_for_each_integrity_segment(bvl, _rq, _iter) \
	__rq_for_each_bio(_iter.bio, _rq) \
	bip_for_each_vec(bvl, _iter.bio->bi_integrity, _iter.i)

	#endif /* BLK_DEV_INTEGRITY */

	static inline int blk_cpu_to_group(int cpu)		static inline int blk_cpu_to_group(int cpu)
	{		{
	#ifdef CONFIG_SCHED_MC		#ifdef CONFIG_SCHED_MC

Admin message