blk-cgroup.c 36.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * Common Block IO controller cgroup interface
 *
 * Based on ideas and code from CFQ, CFS and BFQ:
 * Copyright (C) 2003 Jens Axboe <axboe@kernel.dk>
 *
 * Copyright (C) 2008 Fabio Checconi <fabio@gandalf.sssup.it>
 *		      Paolo Valente <paolo.valente@unimore.it>
 *
 * Copyright (C) 2009 Vivek Goyal <vgoyal@redhat.com>
 * 	              Nauman Rafique <nauman@google.com>
12 13 14 15
 *
 * For policy-specific per-blkcg data:
 * Copyright (C) 2015 Paolo Valente <paolo.valente@unimore.it>
 *                    Arianna Avanzini <avanzini.arianna@gmail.com>
16 17
 */
#include <linux/ioprio.h>
18
#include <linux/kdev_t.h>
19
#include <linux/module.h>
20
#include <linux/err.h>
21
#include <linux/blkdev.h>
22
#include <linux/backing-dev.h>
23
#include <linux/slab.h>
24
#include <linux/genhd.h>
25
#include <linux/delay.h>
Tejun Heo's avatar
Tejun Heo committed
26
#include <linux/atomic.h>
27
#include <linux/ctype.h>
28
#include <linux/blk-cgroup.h>
29
#include "blk.h"
30

31 32
#define MAX_KEY_LEN 100

33 34 35 36 37 38 39 40
/*
 * blkcg_pol_mutex protects blkcg_policy[] and policy [de]activation.
 * blkcg_pol_register_mutex nests outside of it and synchronizes entire
 * policy [un]register operations including cgroup file additions /
 * removals.  Putting cgroup file registration outside blkcg_pol_mutex
 * allows grabbing it from cgroup callbacks.
 */
static DEFINE_MUTEX(blkcg_pol_register_mutex);
41
static DEFINE_MUTEX(blkcg_pol_mutex);
42

43
struct blkcg blkcg_root;
44
EXPORT_SYMBOL_GPL(blkcg_root);
45

Tejun Heo's avatar
Tejun Heo committed
46 47
struct cgroup_subsys_state * const blkcg_root_css = &blkcg_root.css;

48
static struct blkcg_policy *blkcg_policy[BLKCG_MAX_POLS];
49

50 51
static LIST_HEAD(all_blkcgs);		/* protected by blkcg_pol_mutex */

52
static bool blkcg_policy_enabled(struct request_queue *q,
53
				 const struct blkcg_policy *pol)
54 55 56 57
{
	return pol && test_bit(pol->plid, q->blkcg_pols);
}

58 59 60 61 62 63
/**
 * blkg_free - free a blkg
 * @blkg: blkg to free
 *
 * Free @blkg which may be partially allocated.
 */
64
static void blkg_free(struct blkcg_gq *blkg)
65
{
66
	int i;
67 68 69 70

	if (!blkg)
		return;

71
	for (i = 0; i < BLKCG_MAX_POLS; i++)
72 73
		if (blkg->pd[i])
			blkcg_policy[i]->pd_free_fn(blkg->pd[i]);
74

75 76
	if (blkg->blkcg != &blkcg_root)
		blk_exit_rl(&blkg->rl);
77 78 79

	blkg_rwstat_exit(&blkg->stat_ios);
	blkg_rwstat_exit(&blkg->stat_bytes);
80
	kfree(blkg);
81 82 83 84 85 86
}

/**
 * blkg_alloc - allocate a blkg
 * @blkcg: block cgroup the new blkg is associated with
 * @q: request_queue the new blkg is associated with
87
 * @gfp_mask: allocation mask to use
88
 *
89
 * Allocate a new blkg assocating @blkcg and @q.
90
 */
91 92
static struct blkcg_gq *blkg_alloc(struct blkcg *blkcg, struct request_queue *q,
				   gfp_t gfp_mask)
93
{
94
	struct blkcg_gq *blkg;
95
	int i;
96 97

	/* alloc and init base part */
98
	blkg = kzalloc_node(sizeof(*blkg), gfp_mask, q->node);
99 100 101
	if (!blkg)
		return NULL;

102 103 104 105
	if (blkg_rwstat_init(&blkg->stat_bytes, gfp_mask) ||
	    blkg_rwstat_init(&blkg->stat_ios, gfp_mask))
		goto err_free;

106
	blkg->q = q;
107
	INIT_LIST_HEAD(&blkg->q_node);
108
	blkg->blkcg = blkcg;
109
	atomic_set(&blkg->refcnt, 1);
110

111 112 113 114 115 116 117
	/* root blkg uses @q->root_rl, init rl only for !root blkgs */
	if (blkcg != &blkcg_root) {
		if (blk_init_rl(&blkg->rl, q, gfp_mask))
			goto err_free;
		blkg->rl.blkg = blkg;
	}

118
	for (i = 0; i < BLKCG_MAX_POLS; i++) {
119
		struct blkcg_policy *pol = blkcg_policy[i];
120
		struct blkg_policy_data *pd;
121

122
		if (!blkcg_policy_enabled(q, pol))
123 124 125
			continue;

		/* alloc per-policy data and attach it to blkg */
126
		pd = pol->pd_alloc_fn(gfp_mask, q->node);
127 128
		if (!pd)
			goto err_free;
129

130 131
		blkg->pd[i] = pd;
		pd->blkg = blkg;
132
		pd->plid = i;
133 134
	}

135
	return blkg;
136 137 138 139

err_free:
	blkg_free(blkg);
	return NULL;
140 141
}

142 143
struct blkcg_gq *blkg_lookup_slowpath(struct blkcg *blkcg,
				      struct request_queue *q, bool update_hint)
144
{
145
	struct blkcg_gq *blkg;
146

147
	/*
148 149 150 151
	 * Hint didn't match.  Look up from the radix tree.  Note that the
	 * hint can only be updated under queue_lock as otherwise @blkg
	 * could have already been removed from blkg_tree.  The caller is
	 * responsible for grabbing queue_lock if @update_hint.
152 153
	 */
	blkg = radix_tree_lookup(&blkcg->blkg_tree, q->id);
154 155 156 157 158
	if (blkg && blkg->q == q) {
		if (update_hint) {
			lockdep_assert_held(q->queue_lock);
			rcu_assign_pointer(blkcg->blkg_hint, blkg);
		}
159
		return blkg;
160
	}
161

162 163
	return NULL;
}
164
EXPORT_SYMBOL_GPL(blkg_lookup_slowpath);
165

166 167
/*
 * If @new_blkg is %NULL, this function tries to allocate a new one as
168
 * necessary using %GFP_NOWAIT.  @new_blkg is always consumed on return.
169
 */
170 171 172
static struct blkcg_gq *blkg_create(struct blkcg *blkcg,
				    struct request_queue *q,
				    struct blkcg_gq *new_blkg)
173
{
174
	struct blkcg_gq *blkg;
175
	struct bdi_writeback_congested *wb_congested;
176
	int i, ret;
177

178 179 180
	WARN_ON_ONCE(!rcu_read_lock_held());
	lockdep_assert_held(q->queue_lock);

181
	/* blkg holds a reference to blkcg */
182
	if (!css_tryget_online(&blkcg->css)) {
183
		ret = -ENODEV;
184
		goto err_free_blkg;
185
	}
186

187
	wb_congested = wb_congested_get_create(&q->backing_dev_info,
188 189
					       blkcg->css.id,
					       GFP_NOWAIT | __GFP_NOWARN);
190 191 192 193 194
	if (!wb_congested) {
		ret = -ENOMEM;
		goto err_put_css;
	}

195
	/* allocate */
196
	if (!new_blkg) {
197
		new_blkg = blkg_alloc(blkcg, q, GFP_NOWAIT | __GFP_NOWARN);
198
		if (unlikely(!new_blkg)) {
199
			ret = -ENOMEM;
200
			goto err_put_congested;
201 202 203
		}
	}
	blkg = new_blkg;
204
	blkg->wb_congested = wb_congested;
205

206
	/* link parent */
207 208 209
	if (blkcg_parent(blkcg)) {
		blkg->parent = __blkg_lookup(blkcg_parent(blkcg), q, false);
		if (WARN_ON_ONCE(!blkg->parent)) {
210
			ret = -ENODEV;
211
			goto err_put_congested;
212 213 214 215
		}
		blkg_get(blkg->parent);
	}

216 217 218 219 220
	/* invoke per-policy init */
	for (i = 0; i < BLKCG_MAX_POLS; i++) {
		struct blkcg_policy *pol = blkcg_policy[i];

		if (blkg->pd[i] && pol->pd_init_fn)
221
			pol->pd_init_fn(blkg->pd[i]);
222 223 224
	}

	/* insert */
225
	spin_lock(&blkcg->lock);
226 227 228 229
	ret = radix_tree_insert(&blkcg->blkg_tree, q->id, blkg);
	if (likely(!ret)) {
		hlist_add_head_rcu(&blkg->blkcg_node, &blkcg->blkg_list);
		list_add(&blkg->q_node, &q->blkg_list);
230 231 232 233 234

		for (i = 0; i < BLKCG_MAX_POLS; i++) {
			struct blkcg_policy *pol = blkcg_policy[i];

			if (blkg->pd[i] && pol->pd_online_fn)
235
				pol->pd_online_fn(blkg->pd[i]);
236
		}
237
	}
238
	blkg->online = true;
239
	spin_unlock(&blkcg->lock);
240

241
	if (!ret)
242
		return blkg;
243

244 245 246 247
	/* @blkg failed fully initialized, use the usual release path */
	blkg_put(blkg);
	return ERR_PTR(ret);

248 249
err_put_congested:
	wb_congested_put(wb_congested);
250
err_put_css:
251
	css_put(&blkcg->css);
252
err_free_blkg:
253
	blkg_free(new_blkg);
254
	return ERR_PTR(ret);
255
}
256

257 258 259 260 261 262
/**
 * blkg_lookup_create - lookup blkg, try to create one if not there
 * @blkcg: blkcg of interest
 * @q: request_queue of interest
 *
 * Lookup blkg for the @blkcg - @q pair.  If it doesn't exist, try to
263 264 265
 * create one.  blkg creation is performed recursively from blkcg_root such
 * that all non-root blkg's have access to the parent blkg.  This function
 * should be called under RCU read lock and @q->queue_lock.
266 267 268 269 270
 *
 * Returns pointer to the looked up or created blkg on success, ERR_PTR()
 * value on error.  If @q is dead, returns ERR_PTR(-EINVAL).  If @q is not
 * dead and bypassing, returns ERR_PTR(-EBUSY).
 */
271 272
struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
				    struct request_queue *q)
273
{
274 275 276 277 278
	struct blkcg_gq *blkg;

	WARN_ON_ONCE(!rcu_read_lock_held());
	lockdep_assert_held(q->queue_lock);

279 280 281 282 283
	/*
	 * This could be the first entry point of blkcg implementation and
	 * we shouldn't allow anything to go through for a bypassing queue.
	 */
	if (unlikely(blk_queue_bypass(q)))
284
		return ERR_PTR(blk_queue_dying(q) ? -ENODEV : -EBUSY);
285 286 287 288 289

	blkg = __blkg_lookup(blkcg, q, true);
	if (blkg)
		return blkg;

290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
	/*
	 * Create blkgs walking down from blkcg_root to @blkcg, so that all
	 * non-root blkgs have access to their parents.
	 */
	while (true) {
		struct blkcg *pos = blkcg;
		struct blkcg *parent = blkcg_parent(blkcg);

		while (parent && !__blkg_lookup(parent, q, false)) {
			pos = parent;
			parent = blkcg_parent(parent);
		}

		blkg = blkg_create(pos, q, NULL);
		if (pos == blkcg || IS_ERR(blkg))
			return blkg;
	}
307
}
308

309
static void blkg_destroy(struct blkcg_gq *blkg)
310
{
311
	struct blkcg *blkcg = blkg->blkcg;
312
	struct blkcg_gq *parent = blkg->parent;
313
	int i;
314

315
	lockdep_assert_held(blkg->q->queue_lock);
316
	lockdep_assert_held(&blkcg->lock);
317 318

	/* Something wrong if we are trying to remove same group twice */
319
	WARN_ON_ONCE(list_empty(&blkg->q_node));
320
	WARN_ON_ONCE(hlist_unhashed(&blkg->blkcg_node));
321

322 323 324 325
	for (i = 0; i < BLKCG_MAX_POLS; i++) {
		struct blkcg_policy *pol = blkcg_policy[i];

		if (blkg->pd[i] && pol->pd_offline_fn)
326
			pol->pd_offline_fn(blkg->pd[i]);
327
	}
328 329 330 331 332 333

	if (parent) {
		blkg_rwstat_add_aux(&parent->stat_bytes, &blkg->stat_bytes);
		blkg_rwstat_add_aux(&parent->stat_ios, &blkg->stat_ios);
	}

334 335
	blkg->online = false;

336
	radix_tree_delete(&blkcg->blkg_tree, blkg->q->id);
337
	list_del_init(&blkg->q_node);
338
	hlist_del_init_rcu(&blkg->blkcg_node);
339

340 341 342 343 344
	/*
	 * Both setting lookup hint to and clearing it from @blkg are done
	 * under queue_lock.  If it's not pointing to @blkg now, it never
	 * will.  Hint assignment itself can race safely.
	 */
345
	if (rcu_access_pointer(blkcg->blkg_hint) == blkg)
346 347
		rcu_assign_pointer(blkcg->blkg_hint, NULL);

348 349 350 351 352 353 354
	/*
	 * Put the reference taken at the time of creation so that when all
	 * queues are gone, group can be destroyed.
	 */
	blkg_put(blkg);
}

355 356 357 358
/**
 * blkg_destroy_all - destroy all blkgs associated with a request_queue
 * @q: request_queue of interest
 *
359
 * Destroy all blkgs associated with @q.
360
 */
361
static void blkg_destroy_all(struct request_queue *q)
362
{
363
	struct blkcg_gq *blkg, *n;
364

365
	lockdep_assert_held(q->queue_lock);
366

367
	list_for_each_entry_safe(blkg, n, &q->blkg_list, q_node) {
368
		struct blkcg *blkcg = blkg->blkcg;
369

370 371 372
		spin_lock(&blkcg->lock);
		blkg_destroy(blkg);
		spin_unlock(&blkcg->lock);
373
	}
374 375 376

	q->root_blkg = NULL;
	q->root_rl.blkg = NULL;
377 378
}

379 380 381 382 383 384 385 386 387
/*
 * A group is RCU protected, but having an rcu lock does not mean that one
 * can access all the fields of blkg and assume these are valid.  For
 * example, don't try to follow throtl_data and request queue links.
 *
 * Having a reference to blkg under an rcu allows accesses to only values
 * local to groups like group stats and group rate limits.
 */
void __blkg_release_rcu(struct rcu_head *rcu_head)
388
{
389
	struct blkcg_gq *blkg = container_of(rcu_head, struct blkcg_gq, rcu_head);
390

391
	/* release the blkcg and parent blkg refs this blkg has been holding */
392
	css_put(&blkg->blkcg->css);
393
	if (blkg->parent)
394
		blkg_put(blkg->parent);
395

396 397
	wb_congested_put(blkg->wb_congested);

398
	blkg_free(blkg);
399
}
400
EXPORT_SYMBOL_GPL(__blkg_release_rcu);
401

402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
/*
 * The next function used by blk_queue_for_each_rl().  It's a bit tricky
 * because the root blkg uses @q->root_rl instead of its own rl.
 */
struct request_list *__blk_queue_next_rl(struct request_list *rl,
					 struct request_queue *q)
{
	struct list_head *ent;
	struct blkcg_gq *blkg;

	/*
	 * Determine the current blkg list_head.  The first entry is
	 * root_rl which is off @q->blkg_list and mapped to the head.
	 */
	if (rl == &q->root_rl) {
		ent = &q->blkg_list;
418 419 420
		/* There are no more block groups, hence no request lists */
		if (list_empty(ent))
			return NULL;
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
	} else {
		blkg = container_of(rl, struct blkcg_gq, rl);
		ent = &blkg->q_node;
	}

	/* walk to the next list_head, skip root blkcg */
	ent = ent->next;
	if (ent == &q->root_blkg->q_node)
		ent = ent->next;
	if (ent == &q->blkg_list)
		return NULL;

	blkg = container_of(ent, struct blkcg_gq, q_node);
	return &blkg->rl;
}

437 438
static int blkcg_reset_stats(struct cgroup_subsys_state *css,
			     struct cftype *cftype, u64 val)
439
{
440
	struct blkcg *blkcg = css_to_blkcg(css);
441
	struct blkcg_gq *blkg;
442
	int i;
443

444
	mutex_lock(&blkcg_pol_mutex);
445
	spin_lock_irq(&blkcg->lock);
Tejun Heo's avatar
Tejun Heo committed
446 447 448 449 450 451

	/*
	 * Note that stat reset is racy - it doesn't synchronize against
	 * stat updates.  This is a debug feature which shouldn't exist
	 * anyway.  If you get hit by a race, retry.
	 */
452
	hlist_for_each_entry(blkg, &blkcg->blkg_list, blkcg_node) {
453 454 455
		blkg_rwstat_reset(&blkg->stat_bytes);
		blkg_rwstat_reset(&blkg->stat_ios);

456
		for (i = 0; i < BLKCG_MAX_POLS; i++) {
457
			struct blkcg_policy *pol = blkcg_policy[i];
458

459 460
			if (blkg->pd[i] && pol->pd_reset_stats_fn)
				pol->pd_reset_stats_fn(blkg->pd[i]);
461
		}
462
	}
463

464
	spin_unlock_irq(&blkcg->lock);
465
	mutex_unlock(&blkcg_pol_mutex);
466 467 468
	return 0;
}

469
const char *blkg_dev_name(struct blkcg_gq *blkg)
470
{
471 472 473 474
	/* some drivers (floppy) instantiate a queue w/o disk registered */
	if (blkg->q->backing_dev_info.dev)
		return dev_name(blkg->q->backing_dev_info.dev);
	return NULL;
475
}
476
EXPORT_SYMBOL_GPL(blkg_dev_name);
477

478 479 480 481 482 483 484 485 486 487 488
/**
 * blkcg_print_blkgs - helper for printing per-blkg data
 * @sf: seq_file to print to
 * @blkcg: blkcg of interest
 * @prfill: fill function to print out a blkg
 * @pol: policy in question
 * @data: data to be passed to @prfill
 * @show_total: to print out sum of prfill return values or not
 *
 * This function invokes @prfill on each blkg of @blkcg if pd for the
 * policy specified by @pol exists.  @prfill is invoked with @sf, the
489 490 491
 * policy data and @data and the matching queue lock held.  If @show_total
 * is %true, the sum of the return values from @prfill is printed with
 * "Total" label at the end.
492 493 494 495
 *
 * This is to be used to construct print functions for
 * cftype->read_seq_string method.
 */
496
void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
497 498
		       u64 (*prfill)(struct seq_file *,
				     struct blkg_policy_data *, int),
499
		       const struct blkcg_policy *pol, int data,
500
		       bool show_total)
501
{
502
	struct blkcg_gq *blkg;
503
	u64 total = 0;
504

505
	rcu_read_lock();
506
	hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
507
		spin_lock_irq(blkg->q->queue_lock);
508
		if (blkcg_policy_enabled(blkg->q, pol))
509
			total += prfill(sf, blkg->pd[pol->plid], data);
510 511 512
		spin_unlock_irq(blkg->q->queue_lock);
	}
	rcu_read_unlock();
513 514 515 516

	if (show_total)
		seq_printf(sf, "Total %llu\n", (unsigned long long)total);
}
517
EXPORT_SYMBOL_GPL(blkcg_print_blkgs);
518 519 520 521

/**
 * __blkg_prfill_u64 - prfill helper for a single u64 value
 * @sf: seq_file to print to
522
 * @pd: policy private data of interest
523 524
 * @v: value to print
 *
525
 * Print @v to @sf for the device assocaited with @pd.
526
 */
527
u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v)
528
{
529
	const char *dname = blkg_dev_name(pd->blkg);
530 531 532 533 534 535 536

	if (!dname)
		return 0;

	seq_printf(sf, "%s %llu\n", dname, (unsigned long long)v);
	return v;
}
537
EXPORT_SYMBOL_GPL(__blkg_prfill_u64);
538 539 540 541

/**
 * __blkg_prfill_rwstat - prfill helper for a blkg_rwstat
 * @sf: seq_file to print to
542
 * @pd: policy private data of interest
543 544
 * @rwstat: rwstat to print
 *
545
 * Print @rwstat to @sf for the device assocaited with @pd.
546
 */
547
u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
548
			 const struct blkg_rwstat *rwstat)
549 550 551 552 553 554 555
{
	static const char *rwstr[] = {
		[BLKG_RWSTAT_READ]	= "Read",
		[BLKG_RWSTAT_WRITE]	= "Write",
		[BLKG_RWSTAT_SYNC]	= "Sync",
		[BLKG_RWSTAT_ASYNC]	= "Async",
	};
556
	const char *dname = blkg_dev_name(pd->blkg);
557 558 559 560 561 562 563 564
	u64 v;
	int i;

	if (!dname)
		return 0;

	for (i = 0; i < BLKG_RWSTAT_NR; i++)
		seq_printf(sf, "%s %s %llu\n", dname, rwstr[i],
565
			   (unsigned long long)atomic64_read(&rwstat->aux_cnt[i]));
566

567 568
	v = atomic64_read(&rwstat->aux_cnt[BLKG_RWSTAT_READ]) +
		atomic64_read(&rwstat->aux_cnt[BLKG_RWSTAT_WRITE]);
569 570 571
	seq_printf(sf, "%s Total %llu\n", dname, (unsigned long long)v);
	return v;
}
572
EXPORT_SYMBOL_GPL(__blkg_prfill_rwstat);
573

574 575 576
/**
 * blkg_prfill_stat - prfill callback for blkg_stat
 * @sf: seq_file to print to
577 578
 * @pd: policy private data of interest
 * @off: offset to the blkg_stat in @pd
579 580 581
 *
 * prfill callback for printing a blkg_stat.
 */
582
u64 blkg_prfill_stat(struct seq_file *sf, struct blkg_policy_data *pd, int off)
583
{
584
	return __blkg_prfill_u64(sf, pd, blkg_stat_read((void *)pd + off));
585
}
586
EXPORT_SYMBOL_GPL(blkg_prfill_stat);
587

588 589 590
/**
 * blkg_prfill_rwstat - prfill callback for blkg_rwstat
 * @sf: seq_file to print to
591 592
 * @pd: policy private data of interest
 * @off: offset to the blkg_rwstat in @pd
593 594 595
 *
 * prfill callback for printing a blkg_rwstat.
 */
596 597
u64 blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
		       int off)
598
{
599
	struct blkg_rwstat rwstat = blkg_rwstat_read((void *)pd + off);
600

601
	return __blkg_prfill_rwstat(sf, pd, &rwstat);
602
}
603
EXPORT_SYMBOL_GPL(blkg_prfill_rwstat);
604

605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
static u64 blkg_prfill_rwstat_field(struct seq_file *sf,
				    struct blkg_policy_data *pd, int off)
{
	struct blkg_rwstat rwstat = blkg_rwstat_read((void *)pd->blkg + off);

	return __blkg_prfill_rwstat(sf, pd, &rwstat);
}

/**
 * blkg_print_stat_bytes - seq_show callback for blkg->stat_bytes
 * @sf: seq_file to print to
 * @v: unused
 *
 * To be used as cftype->seq_show to print blkg->stat_bytes.
 * cftype->private must be set to the blkcg_policy.
 */
int blkg_print_stat_bytes(struct seq_file *sf, void *v)
{
	blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
			  blkg_prfill_rwstat_field, (void *)seq_cft(sf)->private,
			  offsetof(struct blkcg_gq, stat_bytes), true);
	return 0;
}
EXPORT_SYMBOL_GPL(blkg_print_stat_bytes);

/**
 * blkg_print_stat_bytes - seq_show callback for blkg->stat_ios
 * @sf: seq_file to print to
 * @v: unused
 *
 * To be used as cftype->seq_show to print blkg->stat_ios.  cftype->private
 * must be set to the blkcg_policy.
 */
int blkg_print_stat_ios(struct seq_file *sf, void *v)
{
	blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
			  blkg_prfill_rwstat_field, (void *)seq_cft(sf)->private,
			  offsetof(struct blkcg_gq, stat_ios), true);
	return 0;
}
EXPORT_SYMBOL_GPL(blkg_print_stat_ios);

static u64 blkg_prfill_rwstat_field_recursive(struct seq_file *sf,
					      struct blkg_policy_data *pd,
					      int off)
{
	struct blkg_rwstat rwstat = blkg_rwstat_recursive_sum(pd->blkg,
							      NULL, off);
	return __blkg_prfill_rwstat(sf, pd, &rwstat);
}

/**
 * blkg_print_stat_bytes_recursive - recursive version of blkg_print_stat_bytes
 * @sf: seq_file to print to
 * @v: unused
 */
int blkg_print_stat_bytes_recursive(struct seq_file *sf, void *v)
{
	blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
			  blkg_prfill_rwstat_field_recursive,
			  (void *)seq_cft(sf)->private,
			  offsetof(struct blkcg_gq, stat_bytes), true);
	return 0;
}
EXPORT_SYMBOL_GPL(blkg_print_stat_bytes_recursive);

/**
 * blkg_print_stat_ios_recursive - recursive version of blkg_print_stat_ios
 * @sf: seq_file to print to
 * @v: unused
 */
int blkg_print_stat_ios_recursive(struct seq_file *sf, void *v)
{
	blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
			  blkg_prfill_rwstat_field_recursive,
			  (void *)seq_cft(sf)->private,
			  offsetof(struct blkcg_gq, stat_ios), true);
	return 0;
}
EXPORT_SYMBOL_GPL(blkg_print_stat_ios_recursive);

686 687
/**
 * blkg_stat_recursive_sum - collect hierarchical blkg_stat
688 689 690
 * @blkg: blkg of interest
 * @pol: blkcg_policy which contains the blkg_stat
 * @off: offset to the blkg_stat in blkg_policy_data or @blkg
691
 *
692 693 694 695 696 697
 * Collect the blkg_stat specified by @blkg, @pol and @off and all its
 * online descendants and their aux counts.  The caller must be holding the
 * queue lock for online tests.
 *
 * If @pol is NULL, blkg_stat is at @off bytes into @blkg; otherwise, it is
 * at @off bytes into @blkg's blkg_policy_data of the policy.
698
 */
699 700
u64 blkg_stat_recursive_sum(struct blkcg_gq *blkg,
			    struct blkcg_policy *pol, int off)
701 702
{
	struct blkcg_gq *pos_blkg;
703
	struct cgroup_subsys_state *pos_css;
704
	u64 sum = 0;
705

706
	lockdep_assert_held(blkg->q->queue_lock);
707 708

	rcu_read_lock();
709 710 711 712 713
	blkg_for_each_descendant_pre(pos_blkg, pos_css, blkg) {
		struct blkg_stat *stat;

		if (!pos_blkg->online)
			continue;
714

715 716 717 718 719 720
		if (pol)
			stat = (void *)blkg_to_pd(pos_blkg, pol) + off;
		else
			stat = (void *)blkg + off;

		sum += blkg_stat_read(stat) + atomic64_read(&stat->aux_cnt);
721 722 723 724 725 726 727 728 729
	}
	rcu_read_unlock();

	return sum;
}
EXPORT_SYMBOL_GPL(blkg_stat_recursive_sum);

/**
 * blkg_rwstat_recursive_sum - collect hierarchical blkg_rwstat
730 731 732
 * @blkg: blkg of interest
 * @pol: blkcg_policy which contains the blkg_rwstat
 * @off: offset to the blkg_rwstat in blkg_policy_data or @blkg
733
 *
734 735 736 737 738 739
 * Collect the blkg_rwstat specified by @blkg, @pol and @off and all its
 * online descendants and their aux counts.  The caller must be holding the
 * queue lock for online tests.
 *
 * If @pol is NULL, blkg_rwstat is at @off bytes into @blkg; otherwise, it
 * is at @off bytes into @blkg's blkg_policy_data of the policy.
740
 */
741 742
struct blkg_rwstat blkg_rwstat_recursive_sum(struct blkcg_gq *blkg,
					     struct blkcg_policy *pol, int off)
743 744
{
	struct blkcg_gq *pos_blkg;
745
	struct cgroup_subsys_state *pos_css;
746
	struct blkg_rwstat sum = { };
747 748
	int i;

749
	lockdep_assert_held(blkg->q->queue_lock);
750 751

	rcu_read_lock();
752
	blkg_for_each_descendant_pre(pos_blkg, pos_css, blkg) {
753
		struct blkg_rwstat *rwstat;
754 755 756 757

		if (!pos_blkg->online)
			continue;

758 759 760 761 762
		if (pol)
			rwstat = (void *)blkg_to_pd(pos_blkg, pol) + off;
		else
			rwstat = (void *)pos_blkg + off;

763
		for (i = 0; i < BLKG_RWSTAT_NR; i++)
764 765 766
			atomic64_add(atomic64_read(&rwstat->aux_cnt[i]) +
				percpu_counter_sum_positive(&rwstat->cpu_cnt[i]),
				&sum.aux_cnt[i]);
767 768 769 770 771 772 773
	}
	rcu_read_unlock();

	return sum;
}
EXPORT_SYMBOL_GPL(blkg_rwstat_recursive_sum);

774 775 776
/**
 * blkg_conf_prep - parse and prepare for per-blkg config update
 * @blkcg: target block cgroup
777
 * @pol: target policy
778 779 780 781
 * @input: input string
 * @ctx: blkg_conf_ctx to be filled
 *
 * Parse per-blkg config update from @input and initialize @ctx with the
782 783 784
 * result.  @ctx->blkg points to the blkg to be updated and @ctx->body the
 * part of @input following MAJ:MIN.  This function returns with RCU read
 * lock and queue lock held and must be paired with blkg_conf_finish().
785
 */
786
int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
787
		   char *input, struct blkg_conf_ctx *ctx)
788
	__acquires(rcu) __acquires(disk->queue->queue_lock)
789
{
790
	struct gendisk *disk;
791
	struct blkcg_gq *blkg;
792
	struct module *owner;
793
	unsigned int major, minor;
794 795
	int key_len, part, ret;
	char *body;
796

797
	if (sscanf(input, "%u:%u%n", &major, &minor, &key_len) != 2)
798
		return -EINVAL;
799

800 801 802 803 804
	body = input + key_len;
	if (!isspace(*body))
		return -EINVAL;
	body = skip_spaces(body);

805
	disk = get_gendisk(MKDEV(major, minor), &part);
806
	if (!disk)
807
		return -ENODEV;
808
	if (part) {
809
		owner = disk->fops->owner;
810
		put_disk(disk);
811
		module_put(owner);
812
		return -ENODEV;
813
	}
814 815

	rcu_read_lock();
816
	spin_lock_irq(disk->queue->queue_lock);
817

818
	if (blkcg_policy_enabled(disk->queue, pol))
819
		blkg = blkg_lookup_create(blkcg, disk->queue);
820
	else
821
		blkg = ERR_PTR(-EOPNOTSUPP);
822

823 824
	if (IS_ERR(blkg)) {
		ret = PTR_ERR(blkg);
825
		rcu_read_unlock();
826
		spin_unlock_irq(disk->queue->queue_lock);
827
		owner = disk->fops->owner;
828
		put_disk(disk);
829
		module_put(owner);
830 831 832 833 834 835 836 837 838
		/*
		 * If queue was bypassing, we should retry.  Do so after a
		 * short msleep().  It isn't strictly necessary but queue
		 * can be bypassing for some time and it's always nice to
		 * avoid busy looping.
		 */
		if (ret == -EBUSY) {
			msleep(10);
			ret = restart_syscall();
839
		}
840
		return ret;
841
	}
842 843 844

	ctx->disk = disk;
	ctx->blkg = blkg;
845
	ctx->body = body;
846
	return 0;
847
}
848
EXPORT_SYMBOL_GPL(blkg_conf_prep);
849

850 851 852 853 854 855 856
/**
 * blkg_conf_finish - finish up per-blkg config update
 * @ctx: blkg_conf_ctx intiailized by blkg_conf_prep()
 *
 * Finish up after per-blkg config update.  This function must be paired
 * with blkg_conf_prep().
 */
857
void blkg_conf_finish(struct blkg_conf_ctx *ctx)
858
	__releases(ctx->disk->queue->queue_lock) __releases(rcu)
859
{
860 861
	struct module *owner;

862
	spin_unlock_irq(ctx->disk->queue->queue_lock);
863
	rcu_read_unlock();
864
	owner = ctx->disk->fops->owner;
865
	put_disk(ctx->disk);
866
	module_put(owner);
867
}
868
EXPORT_SYMBOL_GPL(blkg_conf_finish);
869

870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
static int blkcg_print_stat(struct seq_file *sf, void *v)
{
	struct blkcg *blkcg = css_to_blkcg(seq_css(sf));
	struct blkcg_gq *blkg;

	rcu_read_lock();

	hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
		const char *dname;
		struct blkg_rwstat rwstat;
		u64 rbytes, wbytes, rios, wios;

		dname = blkg_dev_name(blkg);
		if (!dname)
			continue;

		spin_lock_irq(blkg->q->queue_lock);

		rwstat = blkg_rwstat_recursive_sum(blkg, NULL,
					offsetof(struct blkcg_gq, stat_bytes));
		rbytes = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_READ]);
		wbytes = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_WRITE]);

		rwstat = blkg_rwstat_recursive_sum(blkg, NULL,
					offsetof(struct blkcg_gq, stat_ios));
		rios = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_READ]);
		wios = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_WRITE]);

		spin_unlock_irq(blkg->q->queue_lock);

		if (rbytes || wbytes || rios || wios)
			seq_printf(sf, "%s rbytes=%llu wbytes=%llu rios=%llu wios=%llu\n",
				   dname, rbytes, wbytes, rios, wios);
	}

	rcu_read_unlock();
	return 0;
}

909
static struct cftype blkcg_files[] = {
910 911
	{
		.name = "stat",
912
		.flags = CFTYPE_NOT_ON_ROOT,
913 914 915 916 917
		.seq_show = blkcg_print_stat,
	},
	{ }	/* terminate */
};

918
static struct cftype blkcg_legacy_files[] = {
919 920
	{
		.name = "reset_stats",
921
		.write_u64 = blkcg_reset_stats,
922
	},
923
	{ }	/* terminate */
924 925
};

926
/**
927
 * blkcg_css_offline - cgroup css_offline callback
928
 * @css: css of interest
929
 *
930 931
 * This function is called when @css is about to go away and responsible
 * for shooting down all blkgs associated with @css.  blkgs should be
932 933 934 935 936
 * removed while holding both q and blkcg locks.  As blkcg lock is nested
 * inside q lock, this function performs reverse double lock dancing.
 *
 * This is the blkcg counterpart of ioc_release_fn().
 */
937
static void blkcg_css_offline(struct cgroup_subsys_state *css)
938
{
939
	struct blkcg *blkcg = css_to_blkcg(css);
940

941
	spin_lock_irq(&blkcg->lock);
942

943
	while (!hlist_empty(&blkcg->blkg_list)) {
944 945
		struct blkcg_gq *blkg = hlist_entry(blkcg->blkg_list.first,
						struct blkcg_gq, blkcg_node);
946
		struct request_queue *q = blkg->q;
947

948 949 950 951 952 953
		if (spin_trylock(q->queue_lock)) {
			blkg_destroy(blkg);
			spin_unlock(q->queue_lock);
		} else {
			spin_unlock_irq(&blkcg->lock);
			cpu_relax();
954
			spin_lock_irq(&blkcg->lock);
955
		}
956
	}
957

958
	spin_unlock_irq(&blkcg->lock);
959 960

	wb_blkcg_offline(blkcg);
961 962
}

963
static void blkcg_css_free(struct cgroup_subsys_state *css)
964
{
965
	struct blkcg *blkcg = css_to_blkcg(css);
966
	int i;
967

968
	mutex_lock(&blkcg_pol_mutex);
969

970 971
	list_del(&blkcg->all_blkcgs_node);

972
	for (i = 0; i < BLKCG_MAX_POLS; i++)
973 974 975 976 977
		if (blkcg->cpd[i])
			blkcg_policy[i]->cpd_free_fn(blkcg->cpd[i]);

	mutex_unlock(&blkcg_pol_mutex);

978
	kfree(blkcg);
979 980
}

981 982
static struct cgroup_subsys_state *
blkcg_css_alloc(struct cgroup_subsys_state *parent_css)
983
{
984
	struct blkcg *blkcg;
985 986
	struct cgroup_subsys_state *ret;
	int i;
987

988 989
	mutex_lock(&blkcg_pol_mutex);

990
	if (!parent_css) {
991
		blkcg = &blkcg_root;
992 993 994 995 996 997
	} else {
		blkcg = kzalloc(sizeof(*blkcg), GFP_KERNEL);
		if (!blkcg) {
			ret = ERR_PTR(-ENOMEM);
			goto free_blkcg;
		}
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
	}

	for (i = 0; i < BLKCG_MAX_POLS ; i++) {
		struct blkcg_policy *pol = blkcg_policy[i];
		struct blkcg_policy_data *cpd;

		/*
		 * If the policy hasn't been attached yet, wait for it
		 * to be attached before doing anything else. Otherwise,
		 * check if the policy requires any specific per-cgroup
		 * data: if it does, allocate and initialize it.
		 */
1010
		if (!pol || !pol->cpd_alloc_fn)
1011 1012
			continue;

1013
		cpd = pol->cpd_alloc_fn(GFP_KERNEL);
1014 1015 1016 1017
		if (!cpd) {
			ret = ERR_PTR(-ENOMEM);
			goto free_pd_blkcg;
		}
1018 1019
		blkcg->cpd[i] = cpd;
		cpd->blkcg = blkcg;
1020
		cpd->plid = i;
1021 1022
		if (pol->cpd_init_fn)
			pol->cpd_init_fn(cpd);
1023
	}
1024 1025

	spin_lock_init(&blkcg->lock);
1026
	INIT_RADIX_TREE(&blkcg->blkg_tree, GFP_NOWAIT | __GFP_NOWARN);
1027
	INIT_HLIST_HEAD(&blkcg->blkg_list);
1028 1029 1030
#ifdef CONFIG_CGROUP_WRITEBACK
	INIT_LIST_HEAD(&blkcg->cgwb_list);
#endif
1031 1032 1033
	list_add_tail(&blkcg->all_blkcgs_node, &all_blkcgs);

	mutex_unlock(&blkcg_pol_mutex);
1034
	return &blkcg->css;
1035 1036 1037

free_pd_blkcg:
	for (i--; i >= 0; i--)
1038 1039
		if (blkcg->cpd[i])
			blkcg_policy[i]->cpd_free_fn(blkcg->cpd[i]);
1040 1041
free_blkcg:
	kfree(blkcg);
1042
	mutex_unlock(&blkcg_pol_mutex);
1043
	return ret;
1044 1045
}

1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
/**
 * blkcg_init_queue - initialize blkcg part of request queue
 * @q: request_queue to initialize
 *
 * Called from blk_alloc_queue_node(). Responsible for initializing blkcg
 * part of new request_queue @q.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
int blkcg_init_queue(struct request_queue *q)
{
1058 1059 1060 1061 1062 1063 1064 1065 1066
	struct blkcg_gq *new_blkg, *blkg;
	bool preloaded;
	int ret;

	new_blkg = blkg_alloc(&blkcg_root, q, GFP_KERNEL);
	if (!new_blkg)
		return -ENOMEM;

	preloaded = !radix_tree_preload(GFP_KERNEL);
1067

1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
	/*
	 * Make sure the root blkg exists and count the existing blkgs.  As
	 * @q is bypassing at this point, blkg_lookup_create() can't be
	 * used.  Open code insertion.
	 */
	rcu_read_lock();
	spin_lock_irq(q->queue_lock);
	blkg = blkg_create(&blkcg_root, q, new_blkg);
	spin_unlock_irq(q->queue_lock);
	rcu_read_unlock();

	if (preloaded)
		radix_tree_preload_end();

	if (IS_ERR(blkg)) {
1083
		blkg_free(new_blkg);
1084 1085 1086 1087 1088
		return PTR_ERR(blkg);
	}

	q->root_blkg = blkg;
	q->root_rl.blkg = blkg;
1089

1090 1091 1092 1093 1094 1095 1096
	ret = blk_throtl_init(q);
	if (ret) {
		spin_lock_irq(q->queue_lock);
		blkg_destroy_all(q);
		spin_unlock_irq(q->queue_lock);
	}
	return ret;
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
}

/**
 * blkcg_drain_queue - drain blkcg part of request_queue
 * @q: request_queue to drain
 *
 * Called from blk_drain_queue().  Responsible for draining blkcg part.
 */
void blkcg_drain_queue(struct request_queue *q)
{
	lockdep_assert_held(q->queue_lock);

1109 1110 1111 1112 1113 1114 1115
	/*
	 * @q could be exiting and already have destroyed all blkgs as
	 * indicated by NULL root_blkg.  If so, don't confuse policies.
	 */
	if (!q->root_blkg)
		return;

1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
	blk_throtl_drain(q);
}

/**
 * blkcg_exit_queue - exit and release blkcg part of request_queue
 * @q: request_queue being released
 *
 * Called from blk_release_queue().  Responsible for exiting blkcg part.
 */
void blkcg_exit_queue(struct request_queue *q)
{
1127
	spin_lock_irq(q->queue_lock);
1128
	blkg_destroy_all(q);
1129 1130
	spin_unlock_irq(q->queue_lock);

1131 1132 1133
	blk_throtl_exit(q);
}

1134 1135 1136 1137 1138 1139
/*
 * We cannot support shared io contexts, as we have no mean to support
 * two tasks with the same ioc in two different groups without major rework
 * of the main cic data structures.  For now we allow a task to change
 * its cgroup only if it's the only owner of its ioc.
 */
1140
static int blkcg_can_attach(struct cgroup_taskset *tset)
1141
{
1142
	struct task_struct *task;
1143
	struct cgroup_subsys_state *dst_css;
1144 1145 1146 1147
	struct io_context *ioc;
	int ret = 0;

	/* task_lock() is needed to avoid races with exit_io_context() */
1148
	cgroup_taskset_for_each(task, dst_css, tset) {
1149 1150 1151 1152 1153 1154 1155 1156
		task_lock(task);
		ioc = task->io_context;
		if (ioc && atomic_read(&ioc->nr_tasks) > 1)
			ret = -EINVAL;
		task_unlock(task);
		if (ret)
			break;
	}
1157 1158 1159
	return ret;
}

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
static void blkcg_bind(struct cgroup_subsys_state *root_css)
{
	int i;

	mutex_lock(&blkcg_pol_mutex);

	for (i = 0; i < BLKCG_MAX_POLS; i++) {
		struct blkcg_policy *pol = blkcg_policy[i];
		struct blkcg *blkcg;

		if (!pol || !pol->cpd_bind_fn)
			continue;

		list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node)
			if (blkcg->cpd[pol->plid])
				pol->cpd_bind_fn(blkcg->cpd[pol->plid]);
	}
	mutex_unlock(&blkcg_pol_mutex);
}

1180
struct cgroup_subsys io_cgrp_subsys = {
1181 1182 1183
	.css_alloc = blkcg_css_alloc,
	.css_offline = blkcg_css_offline,
	.css_free = blkcg_css_free,
1184
	.can_attach = blkcg_can_attach,
1185
	.bind = blkcg_bind,
1186
	.dfl_cftypes = blkcg_files,
1187
	.legacy_cftypes = blkcg_legacy_files,
1188
	.legacy_name = "blkio",
1189 1190 1191 1192 1193 1194 1195 1196
#ifdef CONFIG_MEMCG
	/*
	 * This ensures that, if available, memcg is automatically enabled
	 * together on the default hierarchy so that the owner cgroup can
	 * be retrieved from writeback pages.
	 */
	.depends_on = 1 << memory_cgrp_id,
#endif
1197
};
1198
EXPORT_SYMBOL_GPL(io_cgrp_subsys);
1199

1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
/**
 * blkcg_activate_policy - activate a blkcg policy on a request_queue
 * @q: request_queue of interest
 * @pol: blkcg policy to activate
 *
 * Activate @pol on @q.  Requires %GFP_KERNEL context.  @q goes through
 * bypass mode to populate its blkgs with policy_data for @pol.
 *
 * Activation happens with @q bypassed, so nobody would be accessing blkgs
 * from IO path.  Update of each blkg is protected by both queue and blkcg
 * locks so that holding either lock and testing blkcg_policy_enabled() is
 * always enough for dereferencing policy data.
 *
 * The caller is responsible for synchronizing [de]activations and policy
 * [un]registerations.  Returns 0 on success, -errno on failure.
 */
int blkcg_activate_policy(struct request_queue *q,
1217
			  const struct blkcg_policy *pol)
1218
{
1219
	struct blkg_policy_data *pd_prealloc = NULL;
1220
	struct blkcg_gq *blkg;
1221
	int ret;
1222 1223 1224 1225

	if (blkcg_policy_enabled(q, pol))
		return 0;

1226 1227 1228 1229 1230
	if (q->mq_ops) {
		blk_mq_freeze_queue(q);
		blk_mq_quiesce_queue(q);
	} else
		blk_queue_bypass_start(q);
1231 1232
pd_prealloc:
	if (!pd_prealloc) {
1233
		pd_prealloc = pol->pd_alloc_fn(GFP_KERNEL, q->node);
1234
		if (!pd_prealloc) {
1235
			ret = -ENOMEM;
1236
			goto out_bypass_end;
1237 1238 1239 1240 1241 1242
		}
	}

	spin_lock_irq(q->queue_lock);

	list_for_each_entry(blkg, &q->blkg_list, q_node) {
1243 1244 1245 1246
		struct blkg_policy_data *pd;

		if (blkg->pd[pol->plid])
			continue;
1247

1248
		pd = pol->pd_alloc_fn(GFP_NOWAIT | __GFP_NOWARN, q->node);
1249 1250 1251 1252 1253 1254
		if (!pd)
			swap(pd, pd_prealloc);
		if (!pd) {
			spin_unlock_irq(q->queue_lock);
			goto pd_prealloc;
		}
1255 1256 1257

		blkg->pd[pol->plid] = pd;
		pd->blkg = blkg;
1258
		pd->plid = pol->plid;
1259
		if (pol->pd_init_fn)
1260
			pol->pd_init_fn(pd);
1261 1262 1263 1264
	}

	__set_bit(pol->plid, q->blkcg_pols);
	ret = 0;
1265

Tejun Heo's avatar