blk-wbt.c 19.9 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 * buffered writeback throttling. loosely based on CoDel. We can't drop
 * packets for IO scheduling, so the logic is something like this:
 *
 * - Monitor latencies in a defined window of time.
 * - If the minimum latency in the above window exceeds some target, increment
 *   scaling step and scale down queue depth by a factor of 2x. The monitoring
 *   window is then shrunk to 100 / sqrt(scaling step + 1).
 * - For any window where we don't have solid data on what the latencies
 *   look like, retain status quo.
 * - If latencies look good, decrement scaling step.
 * - If we're only doing writes, allow the scaling step to go negative. This
 *   will temporarily boost write performance, snapping back to a stable
 *   scaling step of 0 if reads show up or the heavy writers finish. Unlike
 *   positive scaling steps where we shrink the monitoring window, a negative
 *   scaling step retains the default step==0 window size.
 *
 * Copyright (C) 2016 Jens Axboe
 *
 */
#include <linux/kernel.h>
#include <linux/blk_types.h>
#include <linux/slab.h>
#include <linux/backing-dev.h>
#include <linux/swap.h>

#include "blk-wbt.h"
29
#include "blk-rq-qos.h"
30 31 32 33

#define CREATE_TRACE_POINTS
#include <trace/events/wbt.h>

34
static inline void wbt_clear_state(struct request *rq)
35
{
36
	rq->wbt_flags = 0;
37 38
}

39
static inline enum wbt_flags wbt_flags(struct request *rq)
40
{
41
	return rq->wbt_flags;
42 43
}

44
static inline bool wbt_is_tracked(struct request *rq)
45
{
46
	return rq->wbt_flags & WBT_TRACKED;
47 48
}

49
static inline bool wbt_is_read(struct request *rq)
50
{
51
	return rq->wbt_flags & WBT_READ;
52 53
}

54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
enum {
	/*
	 * Default setting, we'll scale up (to 75% of QD max) or down (min 1)
	 * from here depending on device stats
	 */
	RWB_DEF_DEPTH	= 16,

	/*
	 * 100msec window
	 */
	RWB_WINDOW_NSEC		= 100 * 1000 * 1000ULL,

	/*
	 * Disregard stats, if we don't meet this minimum
	 */
	RWB_MIN_WRITE_SAMPLES	= 3,

	/*
	 * If we have this number of consecutive windows with not enough
	 * information to scale up or down, scale up.
	 */
	RWB_UNKNOWN_BUMP	= 5,
};

static inline bool rwb_enabled(struct rq_wb *rwb)
{
80 81
	return rwb && rwb->enable_state != WBT_STATE_OFF_DEFAULT &&
		      rwb->wb_normal != 0;
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
}

static void wb_timestamp(struct rq_wb *rwb, unsigned long *var)
{
	if (rwb_enabled(rwb)) {
		const unsigned long cur = jiffies;

		if (cur != *var)
			*var = cur;
	}
}

/*
 * If a task was rate throttled in balance_dirty_pages() within the last
 * second or so, use that to indicate a higher cleaning rate.
 */
static bool wb_recent_wait(struct rq_wb *rwb)
{
100
	struct bdi_writeback *wb = &rwb->rqos.q->disk->bdi->wb;
101 102 103 104

	return time_before(jiffies, wb->dirty_sleep + HZ);
}

105 106
static inline struct rq_wait *get_rq_wait(struct rq_wb *rwb,
					  enum wbt_flags wb_acct)
107
{
108 109
	if (wb_acct & WBT_KSWAPD)
		return &rwb->rq_wait[WBT_RWQ_KSWAPD];
110 111
	else if (wb_acct & WBT_DISCARD)
		return &rwb->rq_wait[WBT_RWQ_DISCARD];
112 113

	return &rwb->rq_wait[WBT_RWQ_BG];
114 115 116 117 118 119 120 121 122
}

static void rwb_wake_all(struct rq_wb *rwb)
{
	int i;

	for (i = 0; i < WBT_NUM_RWQ; i++) {
		struct rq_wait *rqw = &rwb->rq_wait[i];

123
		if (wq_has_sleeper(&rqw->wait))
124 125 126 127
			wake_up_all(&rqw->wait);
	}
}

128 129
static void wbt_rqw_done(struct rq_wb *rwb, struct rq_wait *rqw,
			 enum wbt_flags wb_acct)
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
{
	int inflight, limit;

	inflight = atomic_dec_return(&rqw->inflight);

	/*
	 * wbt got disabled with IO in flight. Wake up any potential
	 * waiters, we don't have to do more than that.
	 */
	if (unlikely(!rwb_enabled(rwb))) {
		rwb_wake_all(rwb);
		return;
	}

	/*
145 146 147
	 * For discards, our limit is always the background. For writes, if
	 * the device does write back caching, drop further down before we
	 * wake people up.
148
	 */
149 150 151
	if (wb_acct & WBT_DISCARD)
		limit = rwb->wb_background;
	else if (rwb->wc && !wb_recent_wait(rwb))
152 153 154 155 156 157 158 159 160 161
		limit = 0;
	else
		limit = rwb->wb_normal;

	/*
	 * Don't wake anyone up if we are above the normal limit.
	 */
	if (inflight && inflight >= limit)
		return;

162
	if (wq_has_sleeper(&rqw->wait)) {
163 164 165
		int diff = limit - inflight;

		if (!inflight || diff >= rwb->wb_background / 2)
J
Jens Axboe 已提交
166
			wake_up_all(&rqw->wait);
167 168 169
	}
}

170 171 172 173 174 175 176 177 178 179 180 181
static void __wbt_done(struct rq_qos *rqos, enum wbt_flags wb_acct)
{
	struct rq_wb *rwb = RQWB(rqos);
	struct rq_wait *rqw;

	if (!(wb_acct & WBT_TRACKED))
		return;

	rqw = get_rq_wait(rwb, wb_acct);
	wbt_rqw_done(rwb, rqw, wb_acct);
}

182 183 184 185
/*
 * Called on completion of a request. Note that it's also called when
 * a request is merged, when the request gets freed.
 */
186
static void wbt_done(struct rq_qos *rqos, struct request *rq)
187
{
188
	struct rq_wb *rwb = RQWB(rqos);
189

190 191
	if (!wbt_is_tracked(rq)) {
		if (rwb->sync_cookie == rq) {
192 193 194 195
			rwb->sync_issue = 0;
			rwb->sync_cookie = NULL;
		}

196
		if (wbt_is_read(rq))
197 198
			wb_timestamp(rwb, &rwb->last_comp);
	} else {
199
		WARN_ON_ONCE(rq == rwb->sync_cookie);
200
		__wbt_done(rqos, wbt_flags(rq));
201
	}
202
	wbt_clear_state(rq);
203 204
}

205
static inline bool stat_sample_valid(struct blk_rq_stat *stat)
206 207 208 209 210 211 212
{
	/*
	 * We need at least one read sample, and a minimum of
	 * RWB_MIN_WRITE_SAMPLES. We require some write samples to know
	 * that it's writes impacting us, and not just some sole read on
	 * a device that is in a lower power state.
	 */
213 214
	return (stat[READ].nr_samples >= 1 &&
		stat[WRITE].nr_samples >= RWB_MIN_WRITE_SAMPLES);
215 216 217 218
}

static u64 rwb_sync_issue_lat(struct rq_wb *rwb)
{
219
	u64 now, issue = READ_ONCE(rwb->sync_issue);
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234

	if (!issue || !rwb->sync_cookie)
		return 0;

	now = ktime_to_ns(ktime_get());
	return now - issue;
}

enum {
	LAT_OK = 1,
	LAT_UNKNOWN,
	LAT_UNKNOWN_WRITES,
	LAT_EXCEEDED,
};

235
static int latency_exceeded(struct rq_wb *rwb, struct blk_rq_stat *stat)
236
{
237
	struct backing_dev_info *bdi = rwb->rqos.q->disk->bdi;
238
	struct rq_depth *rqd = &rwb->rq_depth;
239 240 241 242 243 244 245 246 247 248 249 250 251
	u64 thislat;

	/*
	 * If our stored sync issue exceeds the window size, or it
	 * exceeds our min target AND we haven't logged any entries,
	 * flag the latency as exceeded. wbt works off completion latencies,
	 * but for a flooded device, a single sync IO can take a long time
	 * to complete after being issued. If this time exceeds our
	 * monitoring window AND we didn't see any other completions in that
	 * window, then count that sync IO as a violation of the latency.
	 */
	thislat = rwb_sync_issue_lat(rwb);
	if (thislat > rwb->cur_win_nsec ||
252
	    (thislat > rwb->min_lat_nsec && !stat[READ].nr_samples)) {
J
Jens Axboe 已提交
253
		trace_wbt_lat(bdi, thislat);
254 255 256 257 258 259 260 261 262 263 264 265 266
		return LAT_EXCEEDED;
	}

	/*
	 * No read/write mix, if stat isn't valid
	 */
	if (!stat_sample_valid(stat)) {
		/*
		 * If we had writes in this stat window and the window is
		 * current, we're only doing writes. If a task recently
		 * waited or still has writes in flights, consider us doing
		 * just writes as well.
		 */
267 268
		if (stat[WRITE].nr_samples || wb_recent_wait(rwb) ||
		    wbt_inflight(rwb))
269 270 271 272 273 274 275
			return LAT_UNKNOWN_WRITES;
		return LAT_UNKNOWN;
	}

	/*
	 * If the 'min' latency exceeds our target, step down.
	 */
276 277
	if (stat[READ].min > rwb->min_lat_nsec) {
		trace_wbt_lat(bdi, stat[READ].min);
J
Jens Axboe 已提交
278
		trace_wbt_stat(bdi, stat);
279 280 281
		return LAT_EXCEEDED;
	}

282
	if (rqd->scale_step)
J
Jens Axboe 已提交
283
		trace_wbt_stat(bdi, stat);
284 285 286 287 288 289

	return LAT_OK;
}

static void rwb_trace_step(struct rq_wb *rwb, const char *msg)
{
290
	struct backing_dev_info *bdi = rwb->rqos.q->disk->bdi;
291
	struct rq_depth *rqd = &rwb->rq_depth;
J
Jens Axboe 已提交
292

293 294
	trace_wbt_step(bdi, msg, rqd->scale_step, rwb->cur_win_nsec,
			rwb->wb_background, rwb->wb_normal, rqd->max_depth);
295 296
}

297
static void calc_wb_limits(struct rq_wb *rwb)
298
{
299 300 301 302 303 304 305 306 307 308
	if (rwb->min_lat_nsec == 0) {
		rwb->wb_normal = rwb->wb_background = 0;
	} else if (rwb->rq_depth.max_depth <= 2) {
		rwb->wb_normal = rwb->rq_depth.max_depth;
		rwb->wb_background = 1;
	} else {
		rwb->wb_normal = (rwb->rq_depth.max_depth + 1) / 2;
		rwb->wb_background = (rwb->rq_depth.max_depth + 3) / 4;
	}
}
309

310 311
static void scale_up(struct rq_wb *rwb)
{
312 313
	if (!rq_depth_scale_up(&rwb->rq_depth))
		return;
314
	calc_wb_limits(rwb);
315
	rwb->unknown_cnt = 0;
316
	rwb_wake_all(rwb);
317
	rwb_trace_step(rwb, tracepoint_string("scale up"));
318 319 320 321
}

static void scale_down(struct rq_wb *rwb, bool hard_throttle)
{
322 323
	if (!rq_depth_scale_down(&rwb->rq_depth, hard_throttle))
		return;
324
	calc_wb_limits(rwb);
325
	rwb->unknown_cnt = 0;
326
	rwb_trace_step(rwb, tracepoint_string("scale down"));
327 328 329 330
}

static void rwb_arm_timer(struct rq_wb *rwb)
{
331 332 333
	struct rq_depth *rqd = &rwb->rq_depth;

	if (rqd->scale_step > 0) {
334 335 336 337 338 339 340
		/*
		 * We should speed this up, using some variant of a fast
		 * integer inverse square root calculation. Since we only do
		 * this for every window expiration, it's not a huge deal,
		 * though.
		 */
		rwb->cur_win_nsec = div_u64(rwb->win_nsec << 4,
341
					int_sqrt((rqd->scale_step + 1) << 8));
342 343 344 345 346 347 348 349
	} else {
		/*
		 * For step < 0, we don't want to increase/decrease the
		 * window size.
		 */
		rwb->cur_win_nsec = rwb->win_nsec;
	}

350
	blk_stat_activate_nsecs(rwb->cb, rwb->cur_win_nsec);
351 352
}

353
static void wb_timer_fn(struct blk_stat_callback *cb)
354
{
355
	struct rq_wb *rwb = cb->data;
356
	struct rq_depth *rqd = &rwb->rq_depth;
357 358 359
	unsigned int inflight = wbt_inflight(rwb);
	int status;

360 361 362
	if (!rwb->rqos.q->disk)
		return;

363
	status = latency_exceeded(rwb, cb->stat);
364

365 366
	trace_wbt_timer(rwb->rqos.q->disk->bdi, status, rqd->scale_step,
			inflight);
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395

	/*
	 * If we exceeded the latency target, step down. If we did not,
	 * step one level up. If we don't know enough to say either exceeded
	 * or ok, then don't do anything.
	 */
	switch (status) {
	case LAT_EXCEEDED:
		scale_down(rwb, true);
		break;
	case LAT_OK:
		scale_up(rwb);
		break;
	case LAT_UNKNOWN_WRITES:
		/*
		 * We started a the center step, but don't have a valid
		 * read/write sample, but we do have writes going on.
		 * Allow step to go negative, to increase write perf.
		 */
		scale_up(rwb);
		break;
	case LAT_UNKNOWN:
		if (++rwb->unknown_cnt < RWB_UNKNOWN_BUMP)
			break;
		/*
		 * We get here when previously scaled reduced depth, and we
		 * currently don't have a valid read/write sample. For that
		 * case, slowly return to center state (step == 0).
		 */
396
		if (rqd->scale_step > 0)
397
			scale_up(rwb);
398
		else if (rqd->scale_step < 0)
399 400 401 402 403 404 405 406 407
			scale_down(rwb, false);
		break;
	default:
		break;
	}

	/*
	 * Re-arm timer, if we have IO in flight
	 */
408
	if (rqd->scale_step || inflight)
409 410 411
		rwb_arm_timer(rwb);
}

412
static void wbt_update_limits(struct rq_wb *rwb)
413
{
414 415 416 417 418 419
	struct rq_depth *rqd = &rwb->rq_depth;

	rqd->scale_step = 0;
	rqd->scaled_max = false;

	rq_depth_calc_max_depth(rqd);
420 421 422 423 424
	calc_wb_limits(rwb);

	rwb_wake_all(rwb);
}

425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
u64 wbt_get_min_lat(struct request_queue *q)
{
	struct rq_qos *rqos = wbt_rq_qos(q);
	if (!rqos)
		return 0;
	return RQWB(rqos)->min_lat_nsec;
}

void wbt_set_min_lat(struct request_queue *q, u64 val)
{
	struct rq_qos *rqos = wbt_rq_qos(q);
	if (!rqos)
		return;
	RQWB(rqos)->min_lat_nsec = val;
	RQWB(rqos)->enable_state = WBT_STATE_ON_MANUAL;
440
	wbt_update_limits(RQWB(rqos));
441 442 443
}


444 445 446 447 448 449 450 451 452 453 454 455 456 457
static bool close_io(struct rq_wb *rwb)
{
	const unsigned long now = jiffies;

	return time_before(now, rwb->last_issue + HZ / 10) ||
		time_before(now, rwb->last_comp + HZ / 10);
}

#define REQ_HIPRIO	(REQ_SYNC | REQ_META | REQ_PRIO)

static inline unsigned int get_limit(struct rq_wb *rwb, unsigned long rw)
{
	unsigned int limit;

458 459 460 461 462 463 464
	/*
	 * If we got disabled, just return UINT_MAX. This ensures that
	 * we'll properly inc a new IO, and dec+wakeup at the end.
	 */
	if (!rwb_enabled(rwb))
		return UINT_MAX;

465 466 467
	if ((rw & REQ_OP_MASK) == REQ_OP_DISCARD)
		return rwb->wb_background;

468 469
	/*
	 * At this point we know it's a buffered write. If this is
W
weiping zhang 已提交
470
	 * kswapd trying to free memory, or REQ_SYNC is set, then
471 472 473 474 475 476
	 * it's WB_SYNC_ALL writeback, and we'll use the max limit for
	 * that. If the write is marked as a background write, then use
	 * the idle limit, or go to normal if we haven't had competing
	 * IO for a bit.
	 */
	if ((rw & REQ_HIPRIO) || wb_recent_wait(rwb) || current_is_kswapd())
477
		limit = rwb->rq_depth.max_depth;
478 479 480 481 482 483 484 485 486 487 488 489
	else if ((rw & REQ_BACKGROUND) || close_io(rwb)) {
		/*
		 * If less than 100ms since we completed unrelated IO,
		 * limit us to half the depth for background writeback.
		 */
		limit = rwb->wb_background;
	} else
		limit = rwb->wb_normal;

	return limit;
}

J
Jens Axboe 已提交
490 491
struct wbt_wait_data {
	struct rq_wb *rwb;
492
	enum wbt_flags wb_acct;
J
Jens Axboe 已提交
493 494 495
	unsigned long rw;
};

496
static bool wbt_inflight_cb(struct rq_wait *rqw, void *private_data)
J
Jens Axboe 已提交
497
{
498 499 500
	struct wbt_wait_data *data = private_data;
	return rq_wait_inc_below(rqw, get_limit(data->rwb, data->rw));
}
J
Jens Axboe 已提交
501

502 503 504 505
static void wbt_cleanup_cb(struct rq_wait *rqw, void *private_data)
{
	struct wbt_wait_data *data = private_data;
	wbt_rqw_done(data->rwb, rqw, data->wb_acct);
J
Jens Axboe 已提交
506 507
}

508 509 510 511
/*
 * Block if we will exceed our limit, or if we are currently waiting for
 * the timer to kick off queuing again.
 */
512
static void __wbt_wait(struct rq_wb *rwb, enum wbt_flags wb_acct,
513
		       unsigned long rw)
514
{
515
	struct rq_wait *rqw = get_rq_wait(rwb, wb_acct);
J
Jens Axboe 已提交
516 517
	struct wbt_wait_data data = {
		.rwb = rwb,
518
		.wb_acct = wb_acct,
J
Jens Axboe 已提交
519 520
		.rw = rw,
	};
521

522
	rq_qos_wait(rqw, &data, wbt_inflight_cb, wbt_cleanup_cb);
523 524
}

525
static inline bool wbt_should_throttle(struct bio *bio)
526
{
527 528 529 530 531 532 533 534
	switch (bio_op(bio)) {
	case REQ_OP_WRITE:
		/*
		 * Don't throttle WRITE_ODIRECT
		 */
		if ((bio->bi_opf & (REQ_SYNC | REQ_IDLE)) ==
		    (REQ_SYNC | REQ_IDLE))
			return false;
535
		fallthrough;
536 537 538
	case REQ_OP_DISCARD:
		return true;
	default:
539
		return false;
540
	}
541 542
}

543 544 545 546
static enum wbt_flags bio_to_wbt_flags(struct rq_wb *rwb, struct bio *bio)
{
	enum wbt_flags flags = 0;

547 548 549
	if (!rwb_enabled(rwb))
		return 0;

550 551
	if (bio_op(bio) == REQ_OP_READ) {
		flags = WBT_READ;
552
	} else if (wbt_should_throttle(bio)) {
553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
		if (current_is_kswapd())
			flags |= WBT_KSWAPD;
		if (bio_op(bio) == REQ_OP_DISCARD)
			flags |= WBT_DISCARD;
		flags |= WBT_TRACKED;
	}
	return flags;
}

static void wbt_cleanup(struct rq_qos *rqos, struct bio *bio)
{
	struct rq_wb *rwb = RQWB(rqos);
	enum wbt_flags flags = bio_to_wbt_flags(rwb, bio);
	__wbt_done(rqos, flags);
}

569 570 571 572 573
/*
 * May sleep, if we have exceeded the writeback limits. Caller can pass
 * in an irq held spinlock, if it holds one when calling this function.
 * If we do sleep, we'll release and re-grab it.
 */
574
static void wbt_wait(struct rq_qos *rqos, struct bio *bio)
575
{
576
	struct rq_wb *rwb = RQWB(rqos);
577
	enum wbt_flags flags;
578

579
	flags = bio_to_wbt_flags(rwb, bio);
M
Ming Lei 已提交
580
	if (!(flags & WBT_TRACKED)) {
581
		if (flags & WBT_READ)
582
			wb_timestamp(rwb, &rwb->last_issue);
583
		return;
584 585
	}

586
	__wbt_wait(rwb, flags, bio->bi_opf);
587

588
	if (!blk_stat_is_active(rwb->cb))
589
		rwb_arm_timer(rwb);
590
}
591

592 593 594 595
static void wbt_track(struct rq_qos *rqos, struct request *rq, struct bio *bio)
{
	struct rq_wb *rwb = RQWB(rqos);
	rq->wbt_flags |= bio_to_wbt_flags(rwb, bio);
596 597
}

598
static void wbt_issue(struct rq_qos *rqos, struct request *rq)
599
{
600 601
	struct rq_wb *rwb = RQWB(rqos);

602 603 604 605
	if (!rwb_enabled(rwb))
		return;

	/*
606 607 608 609 610
	 * Track sync issue, in case it takes a long time to complete. Allows us
	 * to react quicker, if a sync IO takes a long time to complete. Note
	 * that this is just a hint. The request can go away when it completes,
	 * so it's important we never dereference it. We only use the address to
	 * compare with, which is why we store the sync_issue time locally.
611
	 */
612 613
	if (wbt_is_read(rq) && !rwb->sync_issue) {
		rwb->sync_cookie = rq;
614
		rwb->sync_issue = rq->io_start_time_ns;
615 616 617
	}
}

618
static void wbt_requeue(struct rq_qos *rqos, struct request *rq)
619
{
620
	struct rq_wb *rwb = RQWB(rqos);
621 622
	if (!rwb_enabled(rwb))
		return;
623
	if (rq == rwb->sync_cookie) {
624 625 626 627 628
		rwb->sync_issue = 0;
		rwb->sync_cookie = NULL;
	}
}

629
void wbt_set_write_cache(struct request_queue *q, bool write_cache_on)
630
{
631 632 633
	struct rq_qos *rqos = wbt_rq_qos(q);
	if (rqos)
		RQWB(rqos)->wc = write_cache_on;
634 635
}

636 637 638 639 640
/*
 * Enable wbt if defaults are configured that way
 */
void wbt_enable_default(struct request_queue *q)
{
641
	struct rq_qos *rqos = wbt_rq_qos(q);
642

643
	/* Throttling already enabled? */
644 645 646
	if (rqos) {
		if (RQWB(rqos)->enable_state == WBT_STATE_OFF_DEFAULT)
			RQWB(rqos)->enable_state = WBT_STATE_ON_DEFAULT;
647
		return;
648
	}
649 650

	/* Queue not registered? Maybe shutting down... */
651
	if (!blk_queue_registered(q))
652 653
		return;

J
Jens Axboe 已提交
654
	if (queue_is_mq(q) && IS_ENABLED(CONFIG_BLK_WBT_MQ))
655 656 657 658
		wbt_init(q);
}
EXPORT_SYMBOL_GPL(wbt_enable_default);

659 660 661 662 663 664 665 666 667 668 669 670
u64 wbt_default_latency_nsec(struct request_queue *q)
{
	/*
	 * We default to 2msec for non-rotational storage, and 75msec
	 * for rotational storage.
	 */
	if (blk_queue_nonrot(q))
		return 2000000ULL;
	else
		return 75000000ULL;
}

J
Jens Axboe 已提交
671 672
static int wbt_data_dir(const struct request *rq)
{
673 674 675 676
	const int op = req_op(rq);

	if (op == REQ_OP_READ)
		return READ;
677
	else if (op_is_write(op))
678 679 680 681
		return WRITE;

	/* don't account */
	return -1;
J
Jens Axboe 已提交
682 683
}

684 685 686
static void wbt_queue_depth_changed(struct rq_qos *rqos)
{
	RQWB(rqos)->rq_depth.queue_depth = blk_queue_depth(rqos->q);
687
	wbt_update_limits(RQWB(rqos));
688 689
}

690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
static void wbt_exit(struct rq_qos *rqos)
{
	struct rq_wb *rwb = RQWB(rqos);
	struct request_queue *q = rqos->q;

	blk_stat_remove_callback(q, rwb->cb);
	blk_stat_free_callback(rwb->cb);
	kfree(rwb);
}

/*
 * Disable wbt, if enabled by default.
 */
void wbt_disable_default(struct request_queue *q)
{
	struct rq_qos *rqos = wbt_rq_qos(q);
	struct rq_wb *rwb;
	if (!rqos)
		return;
	rwb = RQWB(rqos);
710 711
	if (rwb->enable_state == WBT_STATE_ON_DEFAULT) {
		blk_stat_deactivate(rwb->cb);
712
		rwb->enable_state = WBT_STATE_OFF_DEFAULT;
713
	}
714
}
715
EXPORT_SYMBOL_GPL(wbt_disable_default);
716

717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
#ifdef CONFIG_BLK_DEBUG_FS
static int wbt_curr_win_nsec_show(void *data, struct seq_file *m)
{
	struct rq_qos *rqos = data;
	struct rq_wb *rwb = RQWB(rqos);

	seq_printf(m, "%llu\n", rwb->cur_win_nsec);
	return 0;
}

static int wbt_enabled_show(void *data, struct seq_file *m)
{
	struct rq_qos *rqos = data;
	struct rq_wb *rwb = RQWB(rqos);

	seq_printf(m, "%d\n", rwb->enable_state);
	return 0;
}

static int wbt_id_show(void *data, struct seq_file *m)
{
	struct rq_qos *rqos = data;

	seq_printf(m, "%u\n", rqos->id);
	return 0;
}

static int wbt_inflight_show(void *data, struct seq_file *m)
{
	struct rq_qos *rqos = data;
	struct rq_wb *rwb = RQWB(rqos);
	int i;

	for (i = 0; i < WBT_NUM_RWQ; i++)
		seq_printf(m, "%d: inflight %d\n", i,
			   atomic_read(&rwb->rq_wait[i].inflight));
	return 0;
}

static int wbt_min_lat_nsec_show(void *data, struct seq_file *m)
{
	struct rq_qos *rqos = data;
	struct rq_wb *rwb = RQWB(rqos);

	seq_printf(m, "%lu\n", rwb->min_lat_nsec);
	return 0;
}

static int wbt_unknown_cnt_show(void *data, struct seq_file *m)
{
	struct rq_qos *rqos = data;
	struct rq_wb *rwb = RQWB(rqos);

	seq_printf(m, "%u\n", rwb->unknown_cnt);
	return 0;
}

static int wbt_normal_show(void *data, struct seq_file *m)
{
	struct rq_qos *rqos = data;
	struct rq_wb *rwb = RQWB(rqos);

	seq_printf(m, "%u\n", rwb->wb_normal);
	return 0;
}

static int wbt_background_show(void *data, struct seq_file *m)
{
	struct rq_qos *rqos = data;
	struct rq_wb *rwb = RQWB(rqos);

	seq_printf(m, "%u\n", rwb->wb_background);
	return 0;
}

static const struct blk_mq_debugfs_attr wbt_debugfs_attrs[] = {
	{"curr_win_nsec", 0400, wbt_curr_win_nsec_show},
	{"enabled", 0400, wbt_enabled_show},
	{"id", 0400, wbt_id_show},
	{"inflight", 0400, wbt_inflight_show},
	{"min_lat_nsec", 0400, wbt_min_lat_nsec_show},
	{"unknown_cnt", 0400, wbt_unknown_cnt_show},
	{"wb_normal", 0400, wbt_normal_show},
	{"wb_background", 0400, wbt_background_show},
	{},
};
#endif

805 806 807
static struct rq_qos_ops wbt_rqos_ops = {
	.throttle = wbt_wait,
	.issue = wbt_issue,
808
	.track = wbt_track,
809 810
	.requeue = wbt_requeue,
	.done = wbt_done,
811
	.cleanup = wbt_cleanup,
812
	.queue_depth_changed = wbt_queue_depth_changed,
813
	.exit = wbt_exit,
814 815 816
#ifdef CONFIG_BLK_DEBUG_FS
	.debugfs_attrs = wbt_debugfs_attrs,
#endif
817 818
};

J
Jens Axboe 已提交
819
int wbt_init(struct request_queue *q)
820 821 822 823 824 825 826 827
{
	struct rq_wb *rwb;
	int i;

	rwb = kzalloc(sizeof(*rwb), GFP_KERNEL);
	if (!rwb)
		return -ENOMEM;

J
Jens Axboe 已提交
828
	rwb->cb = blk_stat_alloc_callback(wb_timer_fn, wbt_data_dir, 2, rwb);
829 830 831 832 833
	if (!rwb->cb) {
		kfree(rwb);
		return -ENOMEM;
	}

834 835
	for (i = 0; i < WBT_NUM_RWQ; i++)
		rq_wait_init(&rwb->rq_wait[i]);
836

837 838 839
	rwb->rqos.id = RQ_QOS_WBT;
	rwb->rqos.ops = &wbt_rqos_ops;
	rwb->rqos.q = q;
840 841
	rwb->last_comp = rwb->last_issue = jiffies;
	rwb->win_nsec = RWB_WINDOW_NSEC;
842
	rwb->enable_state = WBT_STATE_ON_DEFAULT;
843 844
	rwb->wc = 1;
	rwb->rq_depth.default_depth = RWB_DEF_DEPTH;
845 846

	/*
847
	 * Assign rwb and add the stats callback.
848
	 */
849
	rq_qos_add(q, &rwb->rqos);
850
	blk_stat_add_callback(q, rwb->cb);
851

852
	rwb->min_lat_nsec = wbt_default_latency_nsec(q);
853

854
	wbt_queue_depth_changed(&rwb->rqos);
855
	wbt_set_write_cache(q, test_bit(QUEUE_FLAG_WC, &q->queue_flags));
856 857 858

	return 0;
}