block/blk-cgroup.c

   1 /*
   2  * Common Block IO controller cgroup interface
   3  *
   4  * Based on ideas and code from CFQ, CFS and BFQ:
   5  * Copyright (C) 2003 Jens Axboe <axboe@kernel.dk>
   6  *
   7  * Copyright (C) 2008 Fabio Checconi <fabio@gandalf.sssup.it>
   8  *                    Paolo Valente <paolo.valente@unimore.it>
   9  *
  10  * Copyright (C) 2009 Vivek Goyal <vgoyal@redhat.com>
  11  *                    Nauman Rafique <nauman@google.com>
  12  *
  13  * For policy-specific per-blkcg data:
  14  * Copyright (C) 2015 Paolo Valente <paolo.valente@unimore.it>
  15  *                    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/sched/signal.h>
  21 #include <linux/err.h>
  22 #include <linux/blkdev.h>
  23 #include <linux/backing-dev.h>
  24 #include <linux/slab.h>
  25 #include <linux/genhd.h>
  26 #include <linux/delay.h>
  27 #include <linux/atomic.h>
  28 #include <linux/ctype.h>
  29 #include <linux/blk-cgroup.h>
  30 #include "blk.h"
  31
  32 #define MAX_KEY_LEN 100
  33
  34 /*
  35  * blkcg_pol_mutex protects blkcg_policy[] and policy [de]activation.
  36  * blkcg_pol_register_mutex nests outside of it and synchronizes entire
  37  * policy [un]register operations including cgroup file additions /
  38  * removals.  Putting cgroup file registration outside blkcg_pol_mutex
  39  * allows grabbing it from cgroup callbacks.
  40  */
  41 static DEFINE_MUTEX(blkcg_pol_register_mutex);
  42 static DEFINE_MUTEX(blkcg_pol_mutex);
  43
  44 struct blkcg blkcg_root;
  45 EXPORT_SYMBOL_GPL(blkcg_root);
  46
  47 struct cgroup_subsys_state * const blkcg_root_css = &blkcg_root.css;
  48
  49 static struct blkcg_policy *blkcg_policy[BLKCG_MAX_POLS];
  50
  51 static LIST_HEAD(all_blkcgs);           /* protected by blkcg_pol_mutex */
  52
  53 static bool blkcg_policy_enabled(struct request_queue *q,
  54                                  const struct blkcg_policy *pol)
  55 {
  56         return pol && test_bit(pol->plid, q->blkcg_pols);
  57 }
  58
  59 /**
  60  * blkg_free - free a blkg
  61  * @blkg: blkg to free
  62  *
  63  * Free @blkg which may be partially allocated.
  64  */
  65 static void blkg_free(struct blkcg_gq *blkg)
  66 {
  67         int i;
  68
  69         if (!blkg)
  70                 return;
  71
  72         for (i = 0; i < BLKCG_MAX_POLS; i++)
  73                 if (blkg->pd[i])
  74                         blkcg_policy[i]->pd_free_fn(blkg->pd[i]);
  75
  76         if (blkg->blkcg != &blkcg_root)
  77                 blk_exit_rl(&blkg->rl);
  78
  79         blkg_rwstat_exit(&blkg->stat_ios);
  80         blkg_rwstat_exit(&blkg->stat_bytes);
  81         kfree(blkg);
  82 }
  83
  84 /**
  85  * blkg_alloc - allocate a blkg
  86  * @blkcg: block cgroup the new blkg is associated with
  87  * @q: request_queue the new blkg is associated with
  88  * @gfp_mask: allocation mask to use
  89  *
  90  * Allocate a new blkg assocating @blkcg and @q.
  91  */
  92 static struct blkcg_gq *blkg_alloc(struct blkcg *blkcg, struct request_queue *q,
  93                                    gfp_t gfp_mask)
  94 {
  95         struct blkcg_gq *blkg;
  96         int i;
  97
  98         /* alloc and init base part */
  99         blkg = kzalloc_node(sizeof(*blkg), gfp_mask, q->node);
 100         if (!blkg)
 101                 return NULL;
 102
 103         if (blkg_rwstat_init(&blkg->stat_bytes, gfp_mask) ||
 104             blkg_rwstat_init(&blkg->stat_ios, gfp_mask))
 105                 goto err_free;
 106
 107         blkg->q = q;
 108         INIT_LIST_HEAD(&blkg->q_node);
 109         blkg->blkcg = blkcg;
 110         atomic_set(&blkg->refcnt, 1);
 111
 112         /* root blkg uses @q->root_rl, init rl only for !root blkgs */
 113         if (blkcg != &blkcg_root) {
 114                 if (blk_init_rl(&blkg->rl, q, gfp_mask))
 115                         goto err_free;
 116                 blkg->rl.blkg = blkg;
 117         }
 118
 119         for (i = 0; i < BLKCG_MAX_POLS; i++) {
 120                 struct blkcg_policy *pol = blkcg_policy[i];
 121                 struct blkg_policy_data *pd;
 122
 123                 if (!blkcg_policy_enabled(q, pol))
 124                         continue;
 125
 126                 /* alloc per-policy data and attach it to blkg */
 127                 pd = pol->pd_alloc_fn(gfp_mask, q->node);
 128                 if (!pd)
 129                         goto err_free;
 130
 131                 blkg->pd[i] = pd;
 132                 pd->blkg = blkg;
 133                 pd->plid = i;
 134         }
 135
 136         return blkg;
 137
 138 err_free:
 139         blkg_free(blkg);
 140         return NULL;
 141 }
 142
 143 struct blkcg_gq *blkg_lookup_slowpath(struct blkcg *blkcg,
 144                                       struct request_queue *q, bool update_hint)
 145 {
 146         struct blkcg_gq *blkg;
 147
 148         /*
 149          * Hint didn't match.  Look up from the radix tree.  Note that the
 150          * hint can only be updated under queue_lock as otherwise @blkg
 151          * could have already been removed from blkg_tree.  The caller is
 152          * responsible for grabbing queue_lock if @update_hint.
 153          */
 154         blkg = radix_tree_lookup(&blkcg->blkg_tree, q->id);
 155         if (blkg && blkg->q == q) {
 156                 if (update_hint) {
 157                         lockdep_assert_held(q->queue_lock);
 158                         rcu_assign_pointer(blkcg->blkg_hint, blkg);
 159                 }
 160                 return blkg;
 161         }
 162
 163         return NULL;
 164 }
 165 EXPORT_SYMBOL_GPL(blkg_lookup_slowpath);
 166
 167 /*
 168  * If gfp mask allows blocking, this function temporarily drops rcu and queue
 169  * locks to allocate memory.
 170  */
 171 static struct blkcg_gq *blkg_create(struct blkcg *blkcg,
 172                                     struct request_queue *q, gfp_t gfp,
 173                                     const struct blkcg_policy *pol)
 174 {
 175         struct blkcg_gq *blkg = NULL;
 176         struct bdi_writeback_congested *wb_congested;
 177         int i, ret;
 178         const bool drop_locks = gfpflags_allow_blocking(gfp);
 179         bool preloaded = false;
 180
 181         WARN_ON_ONCE(!rcu_read_lock_held());
 182         lockdep_assert_held(q->queue_lock);
 183
 184         /* blkg holds a reference to blkcg */
 185         if (!css_tryget_online(&blkcg->css)) {
 186                 ret = -ENODEV;
 187                 goto err_free_blkg;
 188         }
 189
 190         if (drop_locks) {
 191                 spin_unlock_irq(q->queue_lock);
 192                 rcu_read_unlock();
 193         }
 194
 195         wb_congested = wb_congested_get_create(q->backing_dev_info,
 196                                                blkcg->css.id, gfp);
 197         blkg = blkg_alloc(blkcg, q, gfp);
 198
 199         if (drop_locks) {
 200                 preloaded = !radix_tree_preload(gfp);
 201                 rcu_read_lock();
 202                 spin_lock_irq(q->queue_lock);
 203         }
 204
 205         if (unlikely(!wb_congested || !blkg)) {
 206                 ret = -ENOMEM;
 207                 goto err_put;
 208         }
 209
 210         blkg->wb_congested = wb_congested;
 211
 212         if (pol) {
 213                 WARN_ON(!drop_locks);
 214
 215                 if (!blkcg_policy_enabled(q, pol)) {
 216                         ret = -EOPNOTSUPP;
 217                         goto err_put;
 218                 }
 219
 220                 /*
 221                  * This could be the first entry point of blkcg implementation
 222                  * and we shouldn't allow anything to go through for a bypassing
 223                  * queue.
 224                  */
 225                 if (unlikely(blk_queue_bypass(q))) {
 226                         ret = blk_queue_dying(q) ? -ENODEV : -EBUSY;
 227                         goto err_put;
 228                 }
 229         }
 230
 231         /* link parent */
 232         if (blkcg_parent(blkcg)) {
 233                 blkg->parent = __blkg_lookup(blkcg_parent(blkcg), q, false);
 234                 if (WARN_ON_ONCE(!blkg->parent)) {
 235                         ret = -ENODEV;
 236                         goto err_put;
 237                 }
 238                 blkg_get(blkg->parent);
 239         }
 240
 241         /* invoke per-policy init */
 242         for (i = 0; i < BLKCG_MAX_POLS; i++) {
 243                 struct blkcg_policy *pol = blkcg_policy[i];
 244
 245                 if (blkg->pd[i] && pol->pd_init_fn)
 246                         pol->pd_init_fn(blkg->pd[i]);
 247         }
 248
 249         /* insert */
 250         spin_lock(&blkcg->lock);
 251         ret = radix_tree_insert(&blkcg->blkg_tree, q->id, blkg);
 252         if (likely(!ret)) {
 253                 hlist_add_head_rcu(&blkg->blkcg_node, &blkcg->blkg_list);
 254                 list_add(&blkg->q_node, &q->blkg_list);
 255
 256                 for (i = 0; i < BLKCG_MAX_POLS; i++) {
 257                         struct blkcg_policy *pol = blkcg_policy[i];
 258
 259                         if (blkg->pd[i] && pol->pd_online_fn)
 260                                 pol->pd_online_fn(blkg->pd[i]);
 261                 }
 262         }
 263
 264         if (preloaded)
 265                 radix_tree_preload_end();
 266         blkg->online = true;
 267         spin_unlock(&blkcg->lock);
 268
 269         if (!ret)
 270                 return blkg;
 271
 272         /* @blkg failed fully initialized, use the usual release path */
 273         blkg_put(blkg);
 274         return ERR_PTR(ret);
 275
 276 err_put:
 277         if (preloaded)
 278                 radix_tree_preload_end();
 279         if (wb_congested)
 280                 wb_congested_put(wb_congested);
 281         css_put(&blkcg->css);
 282 err_free_blkg:
 283         blkg_free(blkg);
 284         return ERR_PTR(ret);
 285 }
 286
 287 /**
 288  * __blkg_lookup_create - lookup blkg, try to create one if not there
 289  * @blkcg: blkcg of interest
 290  * @q: request_queue of interest
 291  * @gfp: gfp mask
 292  * @pol: blkcg policy (optional)
 293  *
 294  * Lookup blkg for the @blkcg - @q pair.  If it doesn't exist, try to
 295  * create one.  blkg creation is performed recursively from blkcg_root such
 296  * that all non-root blkg's have access to the parent blkg.  This function
 297  * should be called under RCU read lock and @q->queue_lock.
 298  *
 299  * When gfp mask allows blocking, rcu and queue locks may be dropped for
 300  * allocating memory. In this case, the locks will be reacquired on return.
 301  *
 302  * Returns pointer to the looked up or created blkg on success, ERR_PTR()
 303  * value on error.  If @q is dead, returns ERR_PTR(-EINVAL).  If @q is not
 304  * dead and bypassing, returns ERR_PTR(-EBUSY).
 305  */
 306 struct blkcg_gq *__blkg_lookup_create(struct blkcg *blkcg,
 307                                       struct request_queue *q, gfp_t gfp,
 308                                       const struct blkcg_policy *pol)
 309 {
 310         struct blkcg_gq *blkg;
 311
 312         WARN_ON_ONCE(!rcu_read_lock_held());
 313         lockdep_assert_held(q->queue_lock);
 314
 315         blkg = __blkg_lookup(blkcg, q, true);
 316         if (blkg)
 317                 return blkg;
 318
 319         /*
 320          * Create blkgs walking down from blkcg_root to @blkcg, so that all
 321          * non-root blkgs have access to their parents.
 322          */
 323         while (true) {
 324                 struct blkcg *pos = blkcg;
 325                 struct blkcg *parent = blkcg_parent(blkcg);
 326
 327                 while (parent && !__blkg_lookup(parent, q, false)) {
 328                         pos = parent;
 329                         parent = blkcg_parent(parent);
 330                 }
 331
 332                 blkg = blkg_create(pos, q, gfp, pol);
 333                 if (pos == blkcg || IS_ERR(blkg))
 334                         return blkg;
 335         }
 336 }
 337
 338 /**
 339  * blkg_lookup_create - lookup blkg, try to create one if not there
 340  *
 341  * Performs an initial queue bypass check and then passes control to
 342  * __blkg_lookup_create().
 343  */
 344 struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
 345                                     struct request_queue *q, gfp_t gfp,
 346                                     const struct blkcg_policy *pol)
 347 {
 348         WARN_ON_ONCE(!rcu_read_lock_held());
 349         lockdep_assert_held(q->queue_lock);
 350
 351         /*
 352          * This could be the first entry point of blkcg implementation and
 353          * we shouldn't allow anything to go through for a bypassing queue.
 354          */
 355         if (unlikely(blk_queue_bypass(q)))
 356                 return ERR_PTR(blk_queue_dying(q) ? -ENODEV : -EBUSY);
 357
 358         return __blkg_lookup_create(blkcg, q, gfp, pol);
 359 }
 360
 361 static void blkg_destroy(struct blkcg_gq *blkg)
 362 {
 363         struct blkcg *blkcg = blkg->blkcg;
 364         struct blkcg_gq *parent = blkg->parent;
 365         int i;
 366
 367         lockdep_assert_held(blkg->q->queue_lock);
 368         lockdep_assert_held(&blkcg->lock);
 369
 370         /* Something wrong if we are trying to remove same group twice */
 371         WARN_ON_ONCE(list_empty(&blkg->q_node));
 372         WARN_ON_ONCE(hlist_unhashed(&blkg->blkcg_node));
 373
 374         for (i = 0; i < BLKCG_MAX_POLS; i++) {
 375                 struct blkcg_policy *pol = blkcg_policy[i];
 376
 377                 if (blkg->pd[i] && pol->pd_offline_fn)
 378                         pol->pd_offline_fn(blkg->pd[i]);
 379         }
 380
 381         if (parent) {
 382                 blkg_rwstat_add_aux(&parent->stat_bytes, &blkg->stat_bytes);
 383                 blkg_rwstat_add_aux(&parent->stat_ios, &blkg->stat_ios);
 384         }
 385
 386         blkg->online = false;
 387
 388         radix_tree_delete(&blkcg->blkg_tree, blkg->q->id);
 389         list_del_init(&blkg->q_node);
 390         hlist_del_init_rcu(&blkg->blkcg_node);
 391
 392         /*
 393          * Both setting lookup hint to and clearing it from @blkg are done
 394          * under queue_lock.  If it's not pointing to @blkg now, it never
 395          * will.  Hint assignment itself can race safely.
 396          */
 397         if (rcu_access_pointer(blkcg->blkg_hint) == blkg)
 398                 rcu_assign_pointer(blkcg->blkg_hint, NULL);
 399
 400         /*
 401          * Put the reference taken at the time of creation so that when all
 402          * queues are gone, group can be destroyed.
 403          */
 404         blkg_put(blkg);
 405 }
 406
 407 /**
 408  * blkg_destroy_all - destroy all blkgs associated with a request_queue
 409  * @q: request_queue of interest
 410  *
 411  * Destroy all blkgs associated with @q.
 412  */
 413 static void blkg_destroy_all(struct request_queue *q)
 414 {
 415         struct blkcg_gq *blkg, *n;
 416
 417         lockdep_assert_held(q->queue_lock);
 418
 419         list_for_each_entry_safe(blkg, n, &q->blkg_list, q_node) {
 420                 struct blkcg *blkcg = blkg->blkcg;
 421
 422                 spin_lock(&blkcg->lock);
 423                 blkg_destroy(blkg);
 424                 spin_unlock(&blkcg->lock);
 425         }
 426
 427         q->root_blkg = NULL;
 428         q->root_rl.blkg = NULL;
 429 }
 430
 431 /*
 432  * A group is RCU protected, but having an rcu lock does not mean that one
 433  * can access all the fields of blkg and assume these are valid.  For
 434  * example, don't try to follow throtl_data and request queue links.
 435  *
 436  * Having a reference to blkg under an rcu allows accesses to only values
 437  * local to groups like group stats and group rate limits.
 438  */
 439 void __blkg_release_rcu(struct rcu_head *rcu_head)
 440 {
 441         struct blkcg_gq *blkg = container_of(rcu_head, struct blkcg_gq, rcu_head);
 442
 443         /* release the blkcg and parent blkg refs this blkg has been holding */
 444         css_put(&blkg->blkcg->css);
 445         if (blkg->parent)
 446                 blkg_put(blkg->parent);
 447
 448         wb_congested_put(blkg->wb_congested);
 449
 450         blkg_free(blkg);
 451 }
 452 EXPORT_SYMBOL_GPL(__blkg_release_rcu);
 453
 454 /*
 455  * The next function used by blk_queue_for_each_rl().  It's a bit tricky
 456  * because the root blkg uses @q->root_rl instead of its own rl.
 457  */
 458 struct request_list *__blk_queue_next_rl(struct request_list *rl,
 459                                          struct request_queue *q)
 460 {
 461         struct list_head *ent;
 462         struct blkcg_gq *blkg;
 463
 464         /*
 465          * Determine the current blkg list_head.  The first entry is
 466          * root_rl which is off @q->blkg_list and mapped to the head.
 467          */
 468         if (rl == &q->root_rl) {
 469                 ent = &q->blkg_list;
 470                 /* There are no more block groups, hence no request lists */
 471                 if (list_empty(ent))
 472                         return NULL;
 473         } else {
 474                 blkg = container_of(rl, struct blkcg_gq, rl);
 475                 ent = &blkg->q_node;
 476         }
 477
 478         /* walk to the next list_head, skip root blkcg */
 479         ent = ent->next;
 480         if (ent == &q->root_blkg->q_node)
 481                 ent = ent->next;
 482         if (ent == &q->blkg_list)
 483                 return NULL;
 484
 485         blkg = container_of(ent, struct blkcg_gq, q_node);
 486         return &blkg->rl;
 487 }
 488
 489 static int blkcg_reset_stats(struct cgroup_subsys_state *css,
 490                              struct cftype *cftype, u64 val)
 491 {
 492         struct blkcg *blkcg = css_to_blkcg(css);
 493         struct blkcg_gq *blkg;
 494         int i;
 495
 496         mutex_lock(&blkcg_pol_mutex);
 497         spin_lock_irq(&blkcg->lock);
 498
 499         /*
 500          * Note that stat reset is racy - it doesn't synchronize against
 501          * stat updates.  This is a debug feature which shouldn't exist
 502          * anyway.  If you get hit by a race, retry.
 503          */
 504         hlist_for_each_entry(blkg, &blkcg->blkg_list, blkcg_node) {
 505                 blkg_rwstat_reset(&blkg->stat_bytes);
 506                 blkg_rwstat_reset(&blkg->stat_ios);
 507
 508                 for (i = 0; i < BLKCG_MAX_POLS; i++) {
 509                         struct blkcg_policy *pol = blkcg_policy[i];
 510
 511                         if (blkg->pd[i] && pol->pd_reset_stats_fn)
 512                                 pol->pd_reset_stats_fn(blkg->pd[i]);
 513                 }
 514         }
 515
 516         spin_unlock_irq(&blkcg->lock);
 517         mutex_unlock(&blkcg_pol_mutex);
 518         return 0;
 519 }
 520
 521 const char *blkg_dev_name(struct blkcg_gq *blkg)
 522 {
 523         /* some drivers (floppy) instantiate a queue w/o disk registered */
 524         if (blkg->q->backing_dev_info->dev)
 525                 return dev_name(blkg->q->backing_dev_info->dev);
 526         return NULL;
 527 }
 528 EXPORT_SYMBOL_GPL(blkg_dev_name);
 529
 530 /**
 531  * blkcg_print_blkgs - helper for printing per-blkg data
 532  * @sf: seq_file to print to
 533  * @blkcg: blkcg of interest
 534  * @prfill: fill function to print out a blkg
 535  * @pol: policy in question
 536  * @data: data to be passed to @prfill
 537  * @show_total: to print out sum of prfill return values or not
 538  *
 539  * This function invokes @prfill on each blkg of @blkcg if pd for the
 540  * policy specified by @pol exists.  @prfill is invoked with @sf, the
 541  * policy data and @data and the matching queue lock held.  If @show_total
 542  * is %true, the sum of the return values from @prfill is printed with
 543  * "Total" label at the end.
 544  *
 545  * This is to be used to construct print functions for
 546  * cftype->read_seq_string method.
 547  */
 548 void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
 549                        u64 (*prfill)(struct seq_file *,
 550                                      struct blkg_policy_data *, int),
 551                        const struct blkcg_policy *pol, int data,
 552                        bool show_total)
 553 {
 554         struct blkcg_gq *blkg;
 555         u64 total = 0;
 556
 557         rcu_read_lock();
 558         hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
 559                 spin_lock_irq(blkg->q->queue_lock);
 560                 if (blkcg_policy_enabled(blkg->q, pol))
 561                         total += prfill(sf, blkg->pd[pol->plid], data);
 562                 spin_unlock_irq(blkg->q->queue_lock);
 563         }
 564         rcu_read_unlock();
 565
 566         if (show_total)
 567                 seq_printf(sf, "Total %llu\n", (unsigned long long)total);
 568 }
 569 EXPORT_SYMBOL_GPL(blkcg_print_blkgs);
 570
 571 /**
 572  * __blkg_prfill_u64 - prfill helper for a single u64 value
 573  * @sf: seq_file to print to
 574  * @pd: policy private data of interest
 575  * @v: value to print
 576  *
 577  * Print @v to @sf for the device assocaited with @pd.
 578  */
 579 u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v)
 580 {
 581         const char *dname = blkg_dev_name(pd->blkg);
 582
 583         if (!dname)
 584                 return 0;
 585
 586         seq_printf(sf, "%s %llu\n", dname, (unsigned long long)v);
 587         return v;
 588 }
 589 EXPORT_SYMBOL_GPL(__blkg_prfill_u64);
 590
 591 /**
 592  * __blkg_prfill_rwstat - prfill helper for a blkg_rwstat
 593  * @sf: seq_file to print to
 594  * @pd: policy private data of interest
 595  * @rwstat: rwstat to print
 596  *
 597  * Print @rwstat to @sf for the device assocaited with @pd.
 598  */
 599 u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
 600                          const struct blkg_rwstat *rwstat)
 601 {
 602         static const char *rwstr[] = {
 603                 [BLKG_RWSTAT_READ]      = "Read",
 604                 [BLKG_RWSTAT_WRITE]     = "Write",
 605                 [BLKG_RWSTAT_SYNC]      = "Sync",
 606                 [BLKG_RWSTAT_ASYNC]     = "Async",
 607         };
 608         const char *dname = blkg_dev_name(pd->blkg);
 609         u64 v;
 610         int i;
 611
 612         if (!dname)
 613                 return 0;
 614
 615         for (i = 0; i < BLKG_RWSTAT_NR; i++)
 616                 seq_printf(sf, "%s %s %llu\n", dname, rwstr[i],
 617                            (unsigned long long)atomic64_read(&rwstat->aux_cnt[i]));
 618
 619         v = atomic64_read(&rwstat->aux_cnt[BLKG_RWSTAT_READ]) +
 620                 atomic64_read(&rwstat->aux_cnt[BLKG_RWSTAT_WRITE]);
 621         seq_printf(sf, "%s Total %llu\n", dname, (unsigned long long)v);
 622         return v;
 623 }
 624 EXPORT_SYMBOL_GPL(__blkg_prfill_rwstat);
 625
 626 /**
 627  * blkg_prfill_stat - prfill callback for blkg_stat
 628  * @sf: seq_file to print to
 629  * @pd: policy private data of interest
 630  * @off: offset to the blkg_stat in @pd
 631  *
 632  * prfill callback for printing a blkg_stat.
 633  */
 634 u64 blkg_prfill_stat(struct seq_file *sf, struct blkg_policy_data *pd, int off)
 635 {
 636         return __blkg_prfill_u64(sf, pd, blkg_stat_read((void *)pd + off));
 637 }
 638 EXPORT_SYMBOL_GPL(blkg_prfill_stat);
 639
 640 /**
 641  * blkg_prfill_rwstat - prfill callback for blkg_rwstat
 642  * @sf: seq_file to print to
 643  * @pd: policy private data of interest
 644  * @off: offset to the blkg_rwstat in @pd
 645  *
 646  * prfill callback for printing a blkg_rwstat.
 647  */
 648 u64 blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
 649                        int off)
 650 {
 651         struct blkg_rwstat rwstat = blkg_rwstat_read((void *)pd + off);
 652
 653         return __blkg_prfill_rwstat(sf, pd, &rwstat);
 654 }
 655 EXPORT_SYMBOL_GPL(blkg_prfill_rwstat);
 656
 657 static u64 blkg_prfill_rwstat_field(struct seq_file *sf,
 658                                     struct blkg_policy_data *pd, int off)
 659 {
 660         struct blkg_rwstat rwstat = blkg_rwstat_read((void *)pd->blkg + off);
 661
 662         return __blkg_prfill_rwstat(sf, pd, &rwstat);
 663 }
 664
 665 /**
 666  * blkg_print_stat_bytes - seq_show callback for blkg->stat_bytes
 667  * @sf: seq_file to print to
 668  * @v: unused
 669  *
 670  * To be used as cftype->seq_show to print blkg->stat_bytes.
 671  * cftype->private must be set to the blkcg_policy.
 672  */
 673 int blkg_print_stat_bytes(struct seq_file *sf, void *v)
 674 {
 675         blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
 676                           blkg_prfill_rwstat_field, (void *)seq_cft(sf)->private,
 677                           offsetof(struct blkcg_gq, stat_bytes), true);
 678         return 0;
 679 }
 680 EXPORT_SYMBOL_GPL(blkg_print_stat_bytes);
 681
 682 /**
 683  * blkg_print_stat_bytes - seq_show callback for blkg->stat_ios
 684  * @sf: seq_file to print to
 685  * @v: unused
 686  *
 687  * To be used as cftype->seq_show to print blkg->stat_ios.  cftype->private
 688  * must be set to the blkcg_policy.
 689  */
 690 int blkg_print_stat_ios(struct seq_file *sf, void *v)
 691 {
 692         blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
 693                           blkg_prfill_rwstat_field, (void *)seq_cft(sf)->private,
 694                           offsetof(struct blkcg_gq, stat_ios), true);
 695         return 0;
 696 }
 697 EXPORT_SYMBOL_GPL(blkg_print_stat_ios);
 698
 699 static u64 blkg_prfill_rwstat_field_recursive(struct seq_file *sf,
 700                                               struct blkg_policy_data *pd,
 701                                               int off)
 702 {
 703         struct blkg_rwstat rwstat = blkg_rwstat_recursive_sum(pd->blkg,
 704                                                               NULL, off);
 705         return __blkg_prfill_rwstat(sf, pd, &rwstat);
 706 }
 707
 708 /**
 709  * blkg_print_stat_bytes_recursive - recursive version of blkg_print_stat_bytes
 710  * @sf: seq_file to print to
 711  * @v: unused
 712  */
 713 int blkg_print_stat_bytes_recursive(struct seq_file *sf, void *v)
 714 {
 715         blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
 716                           blkg_prfill_rwstat_field_recursive,
 717                           (void *)seq_cft(sf)->private,
 718                           offsetof(struct blkcg_gq, stat_bytes), true);
 719         return 0;
 720 }
 721 EXPORT_SYMBOL_GPL(blkg_print_stat_bytes_recursive);
 722
 723 /**
 724  * blkg_print_stat_ios_recursive - recursive version of blkg_print_stat_ios
 725  * @sf: seq_file to print to
 726  * @v: unused
 727  */
 728 int blkg_print_stat_ios_recursive(struct seq_file *sf, void *v)
 729 {
 730         blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
 731                           blkg_prfill_rwstat_field_recursive,
 732                           (void *)seq_cft(sf)->private,
 733                           offsetof(struct blkcg_gq, stat_ios), true);
 734         return 0;
 735 }
 736 EXPORT_SYMBOL_GPL(blkg_print_stat_ios_recursive);
 737
 738 /**
 739  * blkg_stat_recursive_sum - collect hierarchical blkg_stat
 740  * @blkg: blkg of interest
 741  * @pol: blkcg_policy which contains the blkg_stat
 742  * @off: offset to the blkg_stat in blkg_policy_data or @blkg
 743  *
 744  * Collect the blkg_stat specified by @blkg, @pol and @off and all its
 745  * online descendants and their aux counts.  The caller must be holding the
 746  * queue lock for online tests.
 747  *
 748  * If @pol is NULL, blkg_stat is at @off bytes into @blkg; otherwise, it is
 749  * at @off bytes into @blkg's blkg_policy_data of the policy.
 750  */
 751 u64 blkg_stat_recursive_sum(struct blkcg_gq *blkg,
 752                             struct blkcg_policy *pol, int off)
 753 {
 754         struct blkcg_gq *pos_blkg;
 755         struct cgroup_subsys_state *pos_css;
 756         u64 sum = 0;
 757
 758         lockdep_assert_held(blkg->q->queue_lock);
 759
 760         rcu_read_lock();
 761         blkg_for_each_descendant_pre(pos_blkg, pos_css, blkg) {
 762                 struct blkg_stat *stat;
 763
 764                 if (!pos_blkg->online)
 765                         continue;
 766
 767                 if (pol)
 768                         stat = (void *)blkg_to_pd(pos_blkg, pol) + off;
 769                 else
 770                         stat = (void *)blkg + off;
 771
 772                 sum += blkg_stat_read(stat) + atomic64_read(&stat->aux_cnt);
 773         }
 774         rcu_read_unlock();
 775
 776         return sum;
 777 }
 778 EXPORT_SYMBOL_GPL(blkg_stat_recursive_sum);
 779
 780 /**
 781  * blkg_rwstat_recursive_sum - collect hierarchical blkg_rwstat
 782  * @blkg: blkg of interest
 783  * @pol: blkcg_policy which contains the blkg_rwstat
 784  * @off: offset to the blkg_rwstat in blkg_policy_data or @blkg
 785  *
 786  * Collect the blkg_rwstat specified by @blkg, @pol and @off and all its
 787  * online descendants and their aux counts.  The caller must be holding the
 788  * queue lock for online tests.
 789  *
 790  * If @pol is NULL, blkg_rwstat is at @off bytes into @blkg; otherwise, it
 791  * is at @off bytes into @blkg's blkg_policy_data of the policy.
 792  */
 793 struct blkg_rwstat blkg_rwstat_recursive_sum(struct blkcg_gq *blkg,
 794                                              struct blkcg_policy *pol, int off)
 795 {
 796         struct blkcg_gq *pos_blkg;
 797         struct cgroup_subsys_state *pos_css;
 798         struct blkg_rwstat sum = { };
 799         int i;
 800
 801         lockdep_assert_held(blkg->q->queue_lock);
 802
 803         rcu_read_lock();
 804         blkg_for_each_descendant_pre(pos_blkg, pos_css, blkg) {
 805                 struct blkg_rwstat *rwstat;
 806
 807                 if (!pos_blkg->online)
 808                         continue;
 809
 810                 if (pol)
 811                         rwstat = (void *)blkg_to_pd(pos_blkg, pol) + off;
 812                 else
 813                         rwstat = (void *)pos_blkg + off;
 814
 815                 for (i = 0; i < BLKG_RWSTAT_NR; i++)
 816                         atomic64_add(atomic64_read(&rwstat->aux_cnt[i]) +
 817                                 percpu_counter_sum_positive(&rwstat->cpu_cnt[i]),
 818                                 &sum.aux_cnt[i]);
 819         }
 820         rcu_read_unlock();
 821
 822         return sum;
 823 }
 824 EXPORT_SYMBOL_GPL(blkg_rwstat_recursive_sum);
 825
 826 /**
 827  * blkg_conf_prep - parse and prepare for per-blkg config update
 828  * @blkcg: target block cgroup
 829  * @pol: target policy
 830  * @input: input string
 831  * @ctx: blkg_conf_ctx to be filled
 832  *
 833  * Parse per-blkg config update from @input and initialize @ctx with the
 834  * result.  @ctx->blkg points to the blkg to be updated and @ctx->body the
 835  * part of @input following MAJ:MIN.  This function returns with RCU read
 836  * lock and queue lock held and must be paired with blkg_conf_finish().
 837  */
 838 int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
 839                    char *input, struct blkg_conf_ctx *ctx)
 840         __acquires(rcu) __acquires(disk->queue->queue_lock)
 841 {
 842         struct gendisk *disk;
 843         struct blkcg_gq *blkg;
 844         struct module *owner;
 845         unsigned int major, minor;
 846         int key_len, part, ret;
 847         char *body;
 848
 849         if (sscanf(input, "%u:%u%n", &major, &minor, &key_len) != 2)
 850                 return -EINVAL;
 851
 852         body = input + key_len;
 853         if (!isspace(*body))
 854                 return -EINVAL;
 855         body = skip_spaces(body);
 856
 857         disk = get_gendisk(MKDEV(major, minor), &part);
 858         if (!disk)
 859                 return -ENODEV;
 860         if (part) {
 861                 owner = disk->fops->owner;
 862                 put_disk(disk);
 863                 module_put(owner);
 864                 return -ENODEV;
 865         }
 866
 867         rcu_read_lock();
 868         spin_lock_irq(disk->queue->queue_lock);
 869
 870         if (blkcg_policy_enabled(disk->queue, pol))
 871                 blkg = blkg_lookup_create(blkcg, disk->queue, GFP_KERNEL, pol);
 872         else
 873                 blkg = ERR_PTR(-EOPNOTSUPP);
 874
 875         if (IS_ERR(blkg)) {
 876                 ret = PTR_ERR(blkg);
 877                 rcu_read_unlock();
 878                 spin_unlock_irq(disk->queue->queue_lock);
 879                 owner = disk->fops->owner;
 880                 put_disk(disk);
 881                 module_put(owner);
 882                 /*
 883                  * If queue was bypassing, we should retry.  Do so after a
 884                  * short msleep().  It isn't strictly necessary but queue
 885                  * can be bypassing for some time and it's always nice to
 886                  * avoid busy looping.
 887                  */
 888                 if (ret == -EBUSY) {
 889                         msleep(10);
 890                         ret = restart_syscall();
 891                 }
 892                 return ret;
 893         }
 894
 895         ctx->disk = disk;
 896         ctx->blkg = blkg;
 897         ctx->body = body;
 898         return 0;
 899 }
 900 EXPORT_SYMBOL_GPL(blkg_conf_prep);
 901
 902 /**
 903  * blkg_conf_finish - finish up per-blkg config update
 904  * @ctx: blkg_conf_ctx intiailized by blkg_conf_prep()
 905  *
 906  * Finish up after per-blkg config update.  This function must be paired
 907  * with blkg_conf_prep().
 908  */
 909 void blkg_conf_finish(struct blkg_conf_ctx *ctx)
 910         __releases(ctx->disk->queue->queue_lock) __releases(rcu)
 911 {
 912         struct module *owner;
 913
 914         spin_unlock_irq(ctx->disk->queue->queue_lock);
 915         rcu_read_unlock();
 916         owner = ctx->disk->fops->owner;
 917         put_disk(ctx->disk);
 918         module_put(owner);
 919 }
 920 EXPORT_SYMBOL_GPL(blkg_conf_finish);
 921
 922 static int blkcg_print_stat(struct seq_file *sf, void *v)
 923 {
 924         struct blkcg *blkcg = css_to_blkcg(seq_css(sf));
 925         struct blkcg_gq *blkg;
 926
 927         rcu_read_lock();
 928
 929         hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
 930                 const char *dname;
 931                 struct blkg_rwstat rwstat;
 932                 u64 rbytes, wbytes, rios, wios;
 933
 934                 dname = blkg_dev_name(blkg);
 935                 if (!dname)
 936                         continue;
 937
 938                 spin_lock_irq(blkg->q->queue_lock);
 939
 940                 rwstat = blkg_rwstat_recursive_sum(blkg, NULL,
 941                                         offsetof(struct blkcg_gq, stat_bytes));
 942                 rbytes = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_READ]);
 943                 wbytes = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_WRITE]);
 944
 945                 rwstat = blkg_rwstat_recursive_sum(blkg, NULL,
 946                                         offsetof(struct blkcg_gq, stat_ios));
 947                 rios = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_READ]);
 948                 wios = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_WRITE]);
 949
 950                 spin_unlock_irq(blkg->q->queue_lock);
 951
 952                 if (rbytes || wbytes || rios || wios)
 953                         seq_printf(sf, "%s rbytes=%llu wbytes=%llu rios=%llu wios=%llu\n",
 954                                    dname, rbytes, wbytes, rios, wios);
 955         }
 956
 957         rcu_read_unlock();
 958         return 0;
 959 }
 960
 961 static struct cftype blkcg_files[] = {
 962         {
 963                 .name = "stat",
 964                 .flags = CFTYPE_NOT_ON_ROOT,
 965                 .seq_show = blkcg_print_stat,
 966         },
 967         { }     /* terminate */
 968 };
 969
 970 static struct cftype blkcg_legacy_files[] = {
 971         {
 972                 .name = "reset_stats",
 973                 .write_u64 = blkcg_reset_stats,
 974         },
 975         { }     /* terminate */
 976 };
 977
 978 /**
 979  * blkcg_css_offline - cgroup css_offline callback
 980  * @css: css of interest
 981  *
 982  * This function is called when @css is about to go away and responsible
 983  * for shooting down all blkgs associated with @css.  blkgs should be
 984  * removed while holding both q and blkcg locks.  As blkcg lock is nested
 985  * inside q lock, this function performs reverse double lock dancing.
 986  *
 987  * This is the blkcg counterpart of ioc_release_fn().
 988  */
 989 static void blkcg_css_offline(struct cgroup_subsys_state *css)
 990 {
 991         struct blkcg *blkcg = css_to_blkcg(css);
 992
 993         spin_lock_irq(&blkcg->lock);
 994
 995         while (!hlist_empty(&blkcg->blkg_list)) {
 996                 struct blkcg_gq *blkg = hlist_entry(blkcg->blkg_list.first,
 997                                                 struct blkcg_gq, blkcg_node);
 998                 struct request_queue *q = blkg->q;
 999
1000                 if (spin_trylock(q->queue_lock)) {
1001                         blkg_destroy(blkg);
1002                         spin_unlock(q->queue_lock);
1003                 } else {
1004                         spin_unlock_irq(&blkcg->lock);
1005                         cpu_relax();
1006                         spin_lock_irq(&blkcg->lock);
1007                 }
1008         }
1009
1010         spin_unlock_irq(&blkcg->lock);
1011
1012         wb_blkcg_offline(blkcg);
1013 }
1014
1015 static void blkcg_css_free(struct cgroup_subsys_state *css)
1016 {
1017         struct blkcg *blkcg = css_to_blkcg(css);
1018         int i;
1019
1020         mutex_lock(&blkcg_pol_mutex);
1021
1022         list_del(&blkcg->all_blkcgs_node);
1023
1024         for (i = 0; i < BLKCG_MAX_POLS; i++)
1025                 if (blkcg->cpd[i])
1026                         blkcg_policy[i]->cpd_free_fn(blkcg->cpd[i]);
1027
1028         mutex_unlock(&blkcg_pol_mutex);
1029
1030         kfree(blkcg);
1031 }
1032
1033 static struct cgroup_subsys_state *
1034 blkcg_css_alloc(struct cgroup_subsys_state *parent_css)
1035 {
1036         struct blkcg *blkcg;
1037         struct cgroup_subsys_state *ret;
1038         int i;
1039
1040         mutex_lock(&blkcg_pol_mutex);
1041
1042         if (!parent_css) {
1043                 blkcg = &blkcg_root;
1044         } else {
1045                 blkcg = kzalloc(sizeof(*blkcg), GFP_KERNEL);
1046                 if (!blkcg) {
1047                         ret = ERR_PTR(-ENOMEM);
1048                         goto free_blkcg;
1049                 }
1050         }
1051
1052         for (i = 0; i < BLKCG_MAX_POLS ; i++) {
1053                 struct blkcg_policy *pol = blkcg_policy[i];
1054                 struct blkcg_policy_data *cpd;
1055
1056                 /*
1057                  * If the policy hasn't been attached yet, wait for it
1058                  * to be attached before doing anything else. Otherwise,
1059                  * check if the policy requires any specific per-cgroup
1060                  * data: if it does, allocate and initialize it.
1061                  */
1062                 if (!pol || !pol->cpd_alloc_fn)
1063                         continue;
1064
1065                 cpd = pol->cpd_alloc_fn(GFP_KERNEL);
1066                 if (!cpd) {
1067                         ret = ERR_PTR(-ENOMEM);
1068                         goto free_pd_blkcg;
1069                 }
1070                 blkcg->cpd[i] = cpd;
1071                 cpd->blkcg = blkcg;
1072                 cpd->plid = i;
1073                 if (pol->cpd_init_fn)
1074                         pol->cpd_init_fn(cpd);
1075         }
1076
1077         spin_lock_init(&blkcg->lock);
1078         INIT_RADIX_TREE(&blkcg->blkg_tree, GFP_NOWAIT | __GFP_NOWARN);
1079         INIT_HLIST_HEAD(&blkcg->blkg_list);
1080 #ifdef CONFIG_CGROUP_WRITEBACK
1081         INIT_LIST_HEAD(&blkcg->cgwb_list);
1082 #endif
1083         list_add_tail(&blkcg->all_blkcgs_node, &all_blkcgs);
1084
1085         mutex_unlock(&blkcg_pol_mutex);
1086         return &blkcg->css;
1087
1088 free_pd_blkcg:
1089         for (i--; i >= 0; i--)
1090                 if (blkcg->cpd[i])
1091                         blkcg_policy[i]->cpd_free_fn(blkcg->cpd[i]);
1092 free_blkcg:
1093         kfree(blkcg);
1094         mutex_unlock(&blkcg_pol_mutex);
1095         return ret;
1096 }
1097
1098 /**
1099  * blkcg_init_queue - initialize blkcg part of request queue
1100  * @q: request_queue to initialize
1101  *
1102  * Called from blk_alloc_queue_node(). Responsible for initializing blkcg
1103  * part of new request_queue @q.
1104  *
1105  * RETURNS:
1106  * 0 on success, -errno on failure.
1107  */
1108 int blkcg_init_queue(struct request_queue *q)
1109 {
1110         struct blkcg_gq *blkg;
1111         int ret;
1112
1113         rcu_read_lock();
1114         spin_lock_irq(q->queue_lock);
1115         blkg = __blkg_lookup_create(&blkcg_root, q, GFP_KERNEL, NULL);
1116         spin_unlock_irq(q->queue_lock);
1117         rcu_read_unlock();
1118
1119         if (IS_ERR(blkg))
1120                 return PTR_ERR(blkg);
1121
1122         q->root_blkg = blkg;
1123         q->root_rl.blkg = blkg;
1124
1125         ret = blk_throtl_init(q);
1126         if (ret) {
1127                 spin_lock_irq(q->queue_lock);
1128                 blkg_destroy_all(q);
1129                 spin_unlock_irq(q->queue_lock);
1130         }
1131         return ret;
1132 }
1133
1134 /**
1135  * blkcg_drain_queue - drain blkcg part of request_queue
1136  * @q: request_queue to drain
1137  *
1138  * Called from blk_drain_queue().  Responsible for draining blkcg part.
1139  */
1140 void blkcg_drain_queue(struct request_queue *q)
1141 {
1142         lockdep_assert_held(q->queue_lock);
1143
1144         /*
1145          * @q could be exiting and already have destroyed all blkgs as
1146          * indicated by NULL root_blkg.  If so, don't confuse policies.
1147          */
1148         if (!q->root_blkg)
1149                 return;
1150
1151         blk_throtl_drain(q);
1152 }
1153
1154 /**
1155  * blkcg_exit_queue - exit and release blkcg part of request_queue
1156  * @q: request_queue being released
1157  *
1158  * Called from blk_release_queue().  Responsible for exiting blkcg part.
1159  */
1160 void blkcg_exit_queue(struct request_queue *q)
1161 {
1162         spin_lock_irq(q->queue_lock);
1163         blkg_destroy_all(q);
1164         spin_unlock_irq(q->queue_lock);
1165
1166         blk_throtl_exit(q);
1167 }
1168
1169 /*
1170  * We cannot support shared io contexts, as we have no mean to support
1171  * two tasks with the same ioc in two different groups without major rework
1172  * of the main cic data structures.  For now we allow a task to change
1173  * its cgroup only if it's the only owner of its ioc.
1174  */
1175 static int blkcg_can_attach(struct cgroup_taskset *tset)
1176 {
1177         struct task_struct *task;
1178         struct cgroup_subsys_state *dst_css;
1179         struct io_context *ioc;
1180         int ret = 0;
1181
1182         /* task_lock() is needed to avoid races with exit_io_context() */
1183         cgroup_taskset_for_each(task, dst_css, tset) {
1184                 task_lock(task);
1185                 ioc = task->io_context;
1186                 if (ioc && atomic_read(&ioc->nr_tasks) > 1)
1187                         ret = -EINVAL;
1188                 task_unlock(task);
1189                 if (ret)
1190                         break;
1191         }
1192         return ret;
1193 }
1194
1195 static void blkcg_bind(struct cgroup_subsys_state *root_css)
1196 {
1197         int i;
1198
1199         mutex_lock(&blkcg_pol_mutex);
1200
1201         for (i = 0; i < BLKCG_MAX_POLS; i++) {
1202                 struct blkcg_policy *pol = blkcg_policy[i];
1203                 struct blkcg *blkcg;
1204
1205                 if (!pol || !pol->cpd_bind_fn)
1206                         continue;
1207
1208                 list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node)
1209                         if (blkcg->cpd[pol->plid])
1210                                 pol->cpd_bind_fn(blkcg->cpd[pol->plid]);
1211         }
1212         mutex_unlock(&blkcg_pol_mutex);
1213 }
1214
1215 struct cgroup_subsys io_cgrp_subsys = {
1216         .css_alloc = blkcg_css_alloc,
1217         .css_offline = blkcg_css_offline,
1218         .css_free = blkcg_css_free,
1219         .can_attach = blkcg_can_attach,
1220         .bind = blkcg_bind,
1221         .dfl_cftypes = blkcg_files,
1222         .legacy_cftypes = blkcg_legacy_files,
1223         .legacy_name = "blkio",
1224 #ifdef CONFIG_MEMCG
1225         /*
1226          * This ensures that, if available, memcg is automatically enabled
1227          * together on the default hierarchy so that the owner cgroup can
1228          * be retrieved from writeback pages.
1229          */
1230         .depends_on = 1 << memory_cgrp_id,
1231 #endif
1232 };
1233 EXPORT_SYMBOL_GPL(io_cgrp_subsys);
1234
1235 /**
1236  * blkcg_activate_policy - activate a blkcg policy on a request_queue
1237  * @q: request_queue of interest
1238  * @pol: blkcg policy to activate
1239  *
1240  * Activate @pol on @q.  Requires %GFP_KERNEL context.  @q goes through
1241  * bypass mode to populate its blkgs with policy_data for @pol.
1242  *
1243  * Activation happens with @q bypassed, so nobody would be accessing blkgs
1244  * from IO path.  Update of each blkg is protected by both queue and blkcg
1245  * locks so that holding either lock and testing blkcg_policy_enabled() is
1246  * always enough for dereferencing policy data.
1247  *
1248  * The caller is responsible for synchronizing [de]activations and policy
1249  * [un]registerations.  Returns 0 on success, -errno on failure.
1250  */
1251 int blkcg_activate_policy(struct request_queue *q,
1252                           const struct blkcg_policy *pol)
1253 {
1254         struct blkg_policy_data *pd_prealloc = NULL;
1255         struct blkcg_gq *blkg;
1256         int ret;
1257
1258         if (blkcg_policy_enabled(q, pol))
1259                 return 0;
1260
1261         if (q->mq_ops)
1262                 blk_mq_freeze_queue(q);
1263         else
1264                 blk_queue_bypass_start(q);
1265 pd_prealloc:
1266         if (!pd_prealloc) {
1267                 pd_prealloc = pol->pd_alloc_fn(GFP_KERNEL, q->node);
1268                 if (!pd_prealloc) {
1269                         ret = -ENOMEM;
1270                         goto out_bypass_end;
1271                 }
1272         }
1273
1274         spin_lock_irq(q->queue_lock);
1275
1276         list_for_each_entry(blkg, &q->blkg_list, q_node) {
1277                 struct blkg_policy_data *pd;
1278
1279                 if (blkg->pd[pol->plid])
1280                         continue;
1281
1282                 pd = pol->pd_alloc_fn(GFP_NOWAIT | __GFP_NOWARN, q->node);
1283                 if (!pd)
1284                         swap(pd, pd_prealloc);
1285                 if (!pd) {
1286                         spin_unlock_irq(q->queue_lock);
1287                         goto pd_prealloc;
1288                 }
1289
1290                 blkg->pd[pol->plid] = pd;
1291                 pd->blkg = blkg;
1292                 pd->plid = pol->plid;
1293                 if (pol->pd_init_fn)
1294                         pol->pd_init_fn(pd);
1295         }
1296
1297         __set_bit(pol->plid, q->blkcg_pols);
1298         ret = 0;
1299
1300         spin_unlock_irq(q->queue_lock);
1301 out_bypass_end:
1302         if (q->mq_ops)
1303                 blk_mq_unfreeze_queue(q);
1304         else
1305                 blk_queue_bypass_end(q);
1306         if (pd_prealloc)
1307                 pol->pd_free_fn(pd_prealloc);
1308         return ret;
1309 }
1310 EXPORT_SYMBOL_GPL(blkcg_activate_policy);
1311
1312 /**
1313  * blkcg_deactivate_policy - deactivate a blkcg policy on a request_queue
1314  * @q: request_queue of interest
1315  * @pol: blkcg policy to deactivate
1316  *
1317  * Deactivate @pol on @q.  Follows the same synchronization rules as
1318  * blkcg_activate_policy().
1319  */
1320 void blkcg_deactivate_policy(struct request_queue *q,
1321                              const struct blkcg_policy *pol)
1322 {
1323         struct blkcg_gq *blkg;
1324
1325         if (!blkcg_policy_enabled(q, pol))
1326                 return;
1327
1328         if (q->mq_ops)
1329                 blk_mq_freeze_queue(q);
1330         else
1331                 blk_queue_bypass_start(q);
1332
1333         spin_lock_irq(q->queue_lock);
1334
1335         __clear_bit(pol->plid, q->blkcg_pols);
1336
1337         list_for_each_entry(blkg, &q->blkg_list, q_node) {
1338                 /* grab blkcg lock too while removing @pd from @blkg */
1339                 spin_lock(&blkg->blkcg->lock);
1340
1341                 if (blkg->pd[pol->plid]) {
1342                         if (pol->pd_offline_fn)
1343                                 pol->pd_offline_fn(blkg->pd[pol->plid]);
1344                         pol->pd_free_fn(blkg->pd[pol->plid]);
1345                         blkg->pd[pol->plid] = NULL;
1346                 }
1347
1348                 spin_unlock(&blkg->blkcg->lock);
1349         }
1350
1351         spin_unlock_irq(q->queue_lock);
1352
1353         if (q->mq_ops)
1354                 blk_mq_unfreeze_queue(q);
1355         else
1356                 blk_queue_bypass_end(q);
1357 }
1358 EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);
1359
1360 /**
1361  * blkcg_policy_register - register a blkcg policy
1362  * @pol: blkcg policy to register
1363  *
1364  * Register @pol with blkcg core.  Might sleep and @pol may be modified on
1365  * successful registration.  Returns 0 on success and -errno on failure.
1366  */
1367 int blkcg_policy_register(struct blkcg_policy *pol)
1368 {
1369         struct blkcg *blkcg;
1370         int i, ret;
1371
1372         mutex_lock(&blkcg_pol_register_mutex);
1373         mutex_lock(&blkcg_pol_mutex);
1374
1375         /* find an empty slot */
1376         ret = -ENOSPC;
1377         for (i = 0; i < BLKCG_MAX_POLS; i++)
1378                 if (!blkcg_policy[i])
1379                         break;
1380         if (i >= BLKCG_MAX_POLS)
1381                 goto err_unlock;
1382
1383         /* register @pol */
1384         pol->plid = i;
1385         blkcg_policy[pol->plid] = pol;
1386
1387         /* allocate and install cpd's */
1388         if (pol->cpd_alloc_fn) {
1389                 list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
1390                         struct blkcg_policy_data *cpd;
1391
1392                         cpd = pol->cpd_alloc_fn(GFP_KERNEL);
1393                         if (!cpd)
1394                                 goto err_free_cpds;
1395
1396                         blkcg->cpd[pol->plid] = cpd;
1397                         cpd->blkcg = blkcg;
1398                         cpd->plid = pol->plid;
1399                         pol->cpd_init_fn(cpd);
1400                 }
1401         }
1402
1403         mutex_unlock(&blkcg_pol_mutex);
1404
1405         /* everything is in place, add intf files for the new policy */
1406         if (pol->dfl_cftypes)
1407                 WARN_ON(cgroup_add_dfl_cftypes(&io_cgrp_subsys,
1408                                                pol->dfl_cftypes));
1409         if (pol->legacy_cftypes)
1410                 WARN_ON(cgroup_add_legacy_cftypes(&io_cgrp_subsys,
1411                                                   pol->legacy_cftypes));
1412         mutex_unlock(&blkcg_pol_register_mutex);
1413         return 0;
1414
1415 err_free_cpds:
1416         if (pol->cpd_alloc_fn) {
1417                 list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
1418                         if (blkcg->cpd[pol->plid]) {
1419                                 pol->cpd_free_fn(blkcg->cpd[pol->plid]);
1420                                 blkcg->cpd[pol->plid] = NULL;
1421                         }
1422                 }
1423         }
1424         blkcg_policy[pol->plid] = NULL;
1425 err_unlock:
1426         mutex_unlock(&blkcg_pol_mutex);
1427         mutex_unlock(&blkcg_pol_register_mutex);
1428         return ret;
1429 }
1430 EXPORT_SYMBOL_GPL(blkcg_policy_register);
1431
1432 /**
1433  * blkcg_policy_unregister - unregister a blkcg policy
1434  * @pol: blkcg policy to unregister
1435  *
1436  * Undo blkcg_policy_register(@pol).  Might sleep.
1437  */
1438 void blkcg_policy_unregister(struct blkcg_policy *pol)
1439 {
1440         struct blkcg *blkcg;
1441
1442         mutex_lock(&blkcg_pol_register_mutex);
1443
1444         if (WARN_ON(blkcg_policy[pol->plid] != pol))
1445                 goto out_unlock;
1446
1447         /* kill the intf files first */
1448         if (pol->dfl_cftypes)
1449                 cgroup_rm_cftypes(pol->dfl_cftypes);
1450         if (pol->legacy_cftypes)
1451                 cgroup_rm_cftypes(pol->legacy_cftypes);
1452
1453         /* remove cpds and unregister */
1454         mutex_lock(&blkcg_pol_mutex);
1455
1456         if (pol->cpd_alloc_fn) {
1457                 list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
1458                         if (blkcg->cpd[pol->plid]) {
1459                                 pol->cpd_free_fn(blkcg->cpd[pol->plid]);
1460                                 blkcg->cpd[pol->plid] = NULL;
1461                         }
1462                 }
1463         }
1464         blkcg_policy[pol->plid] = NULL;
1465
1466         mutex_unlock(&blkcg_pol_mutex);
1467 out_unlock:
1468         mutex_unlock(&blkcg_pol_register_mutex);
1469 }
1470 EXPORT_SYMBOL_GPL(blkcg_policy_unregister);