block: Simplify blk_bio_segment_split()

		     queue_max_segment_size(q));

		     queue_max_segment_size(q));

}

}

/*

/**

 * Split the bvec @bv into segments, and update all kinds of

 * bvec_split_segs - verify whether or not a bvec should be split in the middle

 * variables.

 * @q:        [in] request queue associated with the bio associated with @bv

 * @bv:       [in] bvec to examine

 * @nsegs:    [in,out] Number of segments in the bio being built. Incremented

 *            by the number of segments from @bv that may be appended to that

 *            bio without exceeding @max_segs

 * @sectors:  [in,out] Number of sectors in the bio being built. Incremented

 *            by the number of sectors from @bv that may be appended to that

 *            bio without exceeding @max_sectors

 * @max_segs: [in] upper bound for *@nsegs

 * @max_sectors: [in] upper bound for *@sectors

 *

 * When splitting a bio, it can happen that a bvec is encountered that is too

 * big to fit in a single segment and hence that it has to be split in the

 * middle. This function verifies whether or not that should happen. The value

 * %true is returned if and only if appending the entire @bv to a bio with

 * *@nsegs segments and *@sectors sectors would make that bio unacceptable for

 * the block driver.

 */

 */

static bool bvec_split_segs(const struct request_queue *q,

static bool bvec_split_segs(const struct request_queue *q,

			    const struct bio_vec *bv, unsigned *nsegs,

			    const struct bio_vec *bv, unsigned *nsegs,

			    unsigned *sectors, unsigned max_segs)

			    unsigned *sectors, unsigned max_segs,

			    unsigned max_sectors)

{

{

	unsigned len = bv->bv_len;

	unsigned max_len = (min(max_sectors, UINT_MAX >> 9) - *sectors) << 9;

	unsigned len = min(bv->bv_len, max_len);

	unsigned total_len = 0;

	unsigned total_len = 0;

	unsigned seg_size = 0;

	unsigned seg_size = 0;

	/*

	 * Multi-page bvec may be too big to hold in one segment, so the

	 * current bvec has to be splitted as multiple segments.

	 */

	while (len && *nsegs < max_segs) {

	while (len && *nsegs < max_segs) {

		seg_size = get_max_segment_size(q, bv->bv_offset + total_len);

		seg_size = get_max_segment_size(q, bv->bv_offset + total_len);

		seg_size = min(seg_size, len);

		seg_size = min(seg_size, len);

	*sectors += total_len >> 9;

	*sectors += total_len >> 9;

	/* split in the middle of the bvec if len != 0 */

	/* tell the caller to split the bvec if it is too big to fit */

	return !!len;

	return len > 0 || bv->bv_len > max_len;

}

}

/**

/**

		if (bvprvp && bvec_gap_to_prev(q, bvprvp, bv.bv_offset))

		if (bvprvp && bvec_gap_to_prev(q, bvprvp, bv.bv_offset))

			goto split;

			goto split;

		if (sectors + (bv.bv_len >> 9) > max_sectors) {

			/*

			 * Consider this a new segment if we're splitting in

			 * the middle of this vector.

			 */

		if (nsegs < max_segs &&

		if (nsegs < max_segs &&

			    sectors < max_sectors) {

		    sectors + (bv.bv_len >> 9) <= max_sectors &&

				/* split in the middle of bvec */

		    bv.bv_offset + bv.bv_len <= PAGE_SIZE) {

				bv.bv_len = (max_sectors - sectors) << 9;

			nsegs++;

				bvec_split_segs(q, &bv, &nsegs,

			sectors += bv.bv_len >> 9;

						&sectors, max_segs);

		} else if (bvec_split_segs(q, &bv, &nsegs, &sectors, max_segs,

			}

					 max_sectors)) {

			goto split;

			goto split;

		}

		}

		if (nsegs == max_segs)

			goto split;

		bvprv = bv;

		bvprv = bv;

		bvprvp = &bvprv;

		bvprvp = &bvprv;

		if (bv.bv_offset + bv.bv_len <= PAGE_SIZE) {

			nsegs++;

			sectors += bv.bv_len >> 9;

		} else if (bvec_split_segs(q, &bv, &nsegs, &sectors,

				max_segs)) {

			goto split;

		}

	}

	}

	*segs = nsegs;

	*segs = nsegs;

	rq_for_each_bvec(bv, rq, iter)

	rq_for_each_bvec(bv, rq, iter)

		bvec_split_segs(rq->q, &bv, &nr_phys_segs, &nr_sectors,

		bvec_split_segs(rq->q, &bv, &nr_phys_segs, &nr_sectors,

				UINT_MAX);

				UINT_MAX, UINT_MAX);

	return nr_phys_segs;

	return nr_phys_segs;

}

}