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

Commit 5bed49ad authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-4.19/post-20180822' of git://git.kernel.dk/linux-block 

Pull more block updates from Jens Axboe:

 - Set of bcache fixes and changes (Coly)

 - The flush warn fix (me)

 - Small series of BFQ fixes (Paolo)

 - wbt hang fix (Ming)

 - blktrace fix (Steven)

 - blk-mq hardware queue count update fix (Jianchao)

 - Various little fixes

* tag 'for-4.19/post-20180822' of git://git.kernel.dk/linux-block: (31 commits)
  block/DAC960.c: make some arrays static const, shrinks object size
  blk-mq: sync the update nr_hw_queues with blk_mq_queue_tag_busy_iter
  blk-mq: init hctx sched after update ctx and hctx mapping
  block: remove duplicate initialization
  tracing/blktrace: Fix to allow setting same value
  pktcdvd: fix setting of 'ret' error return for a few cases
  block: change return type to bool
  block, bfq: return nbytes and not zero from struct cftype .write() method
  block, bfq: improve code of bfq_bfqq_charge_time
  block, bfq: reduce write overcharge
  block, bfq: always update the budget of an entity when needed
  block, bfq: readd missing reset of parent-entity service
  blk-wbt: fix IO hang in wbt_wait()
  block: don't warn for flush on read-only device
  bcache: add the missing comments for smp_mb()/smp_wmb()
  bcache: remove unnecessary space before ioctl function pointer arguments
  bcache: add missing SPDX header
  bcache: move open brace at end of function definitions to next line
  bcache: add static const prefix to char * array declarations
  bcache: fix code comments style
  ...
parents fe6f0ed0 1e7da865

block/bfq-cgroup.c

+2 −1
Original line number Diff line number Diff line
@@ -913,7 +913,8 @@ static ssize_t bfq_io_set_weight(struct kernfs_open_file *of, 
	if (ret)

		return ret;



	return bfq_io_set_weight_legacy(of_css(of), NULL, weight);

	ret = bfq_io_set_weight_legacy(of_css(of), NULL, weight);

	return ret ?: nbytes;

}



#ifdef CONFIG_DEBUG_BLK_CGROUP

block/bfq-iosched.c

+40 −14
Original line number Diff line number Diff line
@@ -187,11 +187,25 @@ static const int bfq_stats_min_budgets = 194; 
static const int bfq_default_max_budget = 16 * 1024;



/*

 * Async to sync throughput distribution is controlled as follows:

 * when an async request is served, the entity is charged the number

 * of sectors of the request, multiplied by the factor below

 * When a sync request is dispatched, the queue that contains that

 * request, and all the ancestor entities of that queue, are charged

 * with the number of sectors of the request. In constrast, if the

 * request is async, then the queue and its ancestor entities are

 * charged with the number of sectors of the request, multiplied by

 * the factor below. This throttles the bandwidth for async I/O,

 * w.r.t. to sync I/O, and it is done to counter the tendency of async

 * writes to steal I/O throughput to reads.

 *

 * The current value of this parameter is the result of a tuning with

 * several hardware and software configurations. We tried to find the

 * lowest value for which writes do not cause noticeable problems to

 * reads. In fact, the lower this parameter, the stabler I/O control,

 * in the following respect.  The lower this parameter is, the less

 * the bandwidth enjoyed by a group decreases

 * - when the group does writes, w.r.t. to when it does reads;

 * - when other groups do reads, w.r.t. to when they do writes.

 */

static const int bfq_async_charge_factor = 10;

static const int bfq_async_charge_factor = 3;



/* Default timeout values, in jiffies, approximating CFQ defaults. */

const int bfq_timeout = HZ / 8;
@@ -853,16 +867,7 @@ static unsigned long bfq_serv_to_charge(struct request *rq, 
	if (bfq_bfqq_sync(bfqq) || bfqq->wr_coeff > 1)

		return blk_rq_sectors(rq);



	/*

	 * If there are no weight-raised queues, then amplify service

	 * by just the async charge factor; otherwise amplify service

	 * by twice the async charge factor, to further reduce latency

	 * for weight-raised queues.

	 */

	if (bfqq->bfqd->wr_busy_queues == 0)

	return blk_rq_sectors(rq) * bfq_async_charge_factor;



	return blk_rq_sectors(rq) * 2 * bfq_async_charge_factor;

}



/**
@@ -3298,6 +3303,27 @@ void bfq_bfqq_expire(struct bfq_data *bfqd, 
		 */

	} else

		entity->service = 0;



	/*

	 * Reset the received-service counter for every parent entity.

	 * Differently from what happens with bfqq->entity.service,

	 * the resetting of this counter never needs to be postponed

	 * for parent entities. In fact, in case bfqq may have a

	 * chance to go on being served using the last, partially

	 * consumed budget, bfqq->entity.service needs to be kept,

	 * because if bfqq then actually goes on being served using

	 * the same budget, the last value of bfqq->entity.service is

	 * needed to properly decrement bfqq->entity.budget by the

	 * portion already consumed. In contrast, it is not necessary

	 * to keep entity->service for parent entities too, because

	 * the bubble up of the new value of bfqq->entity.budget will

	 * make sure that the budgets of parent entities are correct,

	 * even in case bfqq and thus parent entities go on receiving

	 * service with the same budget.

	 */

	entity = entity->parent;

	for_each_entity(entity)

		entity->service = 0;

}



/*

block/bfq-wf2q.c

+11 −11
Original line number Diff line number Diff line
@@ -130,10 +130,14 @@ static bool bfq_update_next_in_service(struct bfq_sched_data *sd, 
	if (!change_without_lookup) /* lookup needed */

		next_in_service = bfq_lookup_next_entity(sd, expiration);



	if (next_in_service)

		parent_sched_may_change = !sd->next_in_service ||

	if (next_in_service) {

		bool new_budget_triggers_change =

			bfq_update_parent_budget(next_in_service);



		parent_sched_may_change = !sd->next_in_service ||

			new_budget_triggers_change;

	}



	sd->next_in_service = next_in_service;



	if (!next_in_service)
@@ -877,15 +881,11 @@ void bfq_bfqq_charge_time(struct bfq_data *bfqd, struct bfq_queue *bfqq, 
			  unsigned long time_ms)

{

	struct bfq_entity *entity = &bfqq->entity;

	int tot_serv_to_charge = entity->service;

	unsigned int timeout_ms = jiffies_to_msecs(bfq_timeout);



	if (time_ms > 0 && time_ms < timeout_ms)

		tot_serv_to_charge =

			(bfqd->bfq_max_budget * time_ms) / timeout_ms;



	if (tot_serv_to_charge < entity->service)

		tot_serv_to_charge = entity->service;

	unsigned long timeout_ms = jiffies_to_msecs(bfq_timeout);

	unsigned long bounded_time_ms = min(time_ms, timeout_ms);

	int serv_to_charge_for_time =

		(bfqd->bfq_max_budget * bounded_time_ms) / timeout_ms;

	int tot_serv_to_charge = max(serv_to_charge_for_time, entity->service);



	/* Increase budget to avoid inconsistencies */

	if (tot_serv_to_charge > entity->budget)

block/blk-core.c

+3 −2
Original line number Diff line number Diff line
@@ -1036,7 +1036,6 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id, 
		    laptop_mode_timer_fn, 0);

	timer_setup(&q->timeout, blk_rq_timed_out_timer, 0);

	INIT_WORK(&q->timeout_work, NULL);

	INIT_LIST_HEAD(&q->queue_head);

	INIT_LIST_HEAD(&q->timeout_list);

	INIT_LIST_HEAD(&q->icq_list);

#ifdef CONFIG_BLK_CGROUP
@@ -2162,7 +2161,9 @@ static inline bool should_fail_request(struct hd_struct *part, 


static inline bool bio_check_ro(struct bio *bio, struct hd_struct *part)

{

	if (part->policy && op_is_write(bio_op(bio))) {

	const int op = bio_op(bio);



	if (part->policy && (op_is_write(op) && !op_is_flush(op))) {

		char b[BDEVNAME_SIZE];



		WARN_ONCE(1,

block/blk-mq-sched.c

+0 −44
Original line number Diff line number Diff line
@@ -462,50 +462,6 @@ static void blk_mq_sched_tags_teardown(struct request_queue *q) 
		blk_mq_sched_free_tags(set, hctx, i);

}



int blk_mq_sched_init_hctx(struct request_queue *q, struct blk_mq_hw_ctx *hctx,

			   unsigned int hctx_idx)

{

	struct elevator_queue *e = q->elevator;

	int ret;



	if (!e)

		return 0;



	ret = blk_mq_sched_alloc_tags(q, hctx, hctx_idx);

	if (ret)

		return ret;



	if (e->type->ops.mq.init_hctx) {

		ret = e->type->ops.mq.init_hctx(hctx, hctx_idx);

		if (ret) {

			blk_mq_sched_free_tags(q->tag_set, hctx, hctx_idx);

			return ret;

		}

	}



	blk_mq_debugfs_register_sched_hctx(q, hctx);



	return 0;

}



void blk_mq_sched_exit_hctx(struct request_queue *q, struct blk_mq_hw_ctx *hctx,

			    unsigned int hctx_idx)

{

	struct elevator_queue *e = q->elevator;



	if (!e)

		return;



	blk_mq_debugfs_unregister_sched_hctx(hctx);



	if (e->type->ops.mq.exit_hctx && hctx->sched_data) {

		e->type->ops.mq.exit_hctx(hctx, hctx_idx);

		hctx->sched_data = NULL;

	}



	blk_mq_sched_free_tags(q->tag_set, hctx, hctx_idx);

}



int blk_mq_init_sched(struct request_queue *q, struct elevator_type *e)

{

	struct blk_mq_hw_ctx *hctx;