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 #include <linux/ioprio.h>
  14 #include <linux/kdev_t.h>
  15 #include <linux/module.h>
  16 #include <linux/err.h>
  17 #include <linux/blkdev.h>
  18 #include <linux/slab.h>
  19 #include <linux/genhd.h>
  20 #include <linux/delay.h>
  21 #include <linux/atomic.h>
  22 #include "blk-cgroup.h"
  23 #include "blk.h"
  24
  25 #define MAX_KEY_LEN 100
  26
  27 static DEFINE_MUTEX(blkcg_pol_mutex);
  28 static DEFINE_MUTEX(all_q_mutex);
  29 static LIST_HEAD(all_q_list);
  30
  31 struct blkio_cgroup blkio_root_cgroup = { .cfq_weight = 2 * CFQ_WEIGHT_DEFAULT };
  32 EXPORT_SYMBOL_GPL(blkio_root_cgroup);
  33
  34 static struct blkio_policy_type *blkio_policy[BLKCG_MAX_POLS];
  35
  36 struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
  37 {
  38         return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),
  39                             struct blkio_cgroup, css);
  40 }
  41 EXPORT_SYMBOL_GPL(cgroup_to_blkio_cgroup);
  42
  43 static struct blkio_cgroup *task_blkio_cgroup(struct task_struct *tsk)
  44 {
  45         return container_of(task_subsys_state(tsk, blkio_subsys_id),
  46                             struct blkio_cgroup, css);
  47 }
  48
  49 struct blkio_cgroup *bio_blkio_cgroup(struct bio *bio)
  50 {
  51         if (bio && bio->bi_css)
  52                 return container_of(bio->bi_css, struct blkio_cgroup, css);
  53         return task_blkio_cgroup(current);
  54 }
  55 EXPORT_SYMBOL_GPL(bio_blkio_cgroup);
  56
  57 static bool blkcg_policy_enabled(struct request_queue *q,
  58                                  const struct blkio_policy_type *pol)
  59 {
  60         return pol && test_bit(pol->plid, q->blkcg_pols);
  61 }
  62
  63 static size_t blkg_pd_size(const struct blkio_policy_type *pol)
  64 {
  65         return sizeof(struct blkg_policy_data) + pol->pdata_size;
  66 }
  67
  68 /**
  69  * blkg_free - free a blkg
  70  * @blkg: blkg to free
  71  *
  72  * Free @blkg which may be partially allocated.
  73  */
  74 static void blkg_free(struct blkio_group *blkg)
  75 {
  76         int i;
  77
  78         if (!blkg)
  79                 return;
  80
  81         for (i = 0; i < BLKCG_MAX_POLS; i++) {
  82                 struct blkio_policy_type *pol = blkio_policy[i];
  83                 struct blkg_policy_data *pd = blkg->pd[i];
  84
  85                 if (!pd)
  86                         continue;
  87
  88                 if (pol && pol->ops.blkio_exit_group_fn)
  89                         pol->ops.blkio_exit_group_fn(blkg);
  90
  91                 kfree(pd);
  92         }
  93
  94         kfree(blkg);
  95 }
  96
  97 /**
  98  * blkg_alloc - allocate a blkg
  99  * @blkcg: block cgroup the new blkg is associated with
 100  * @q: request_queue the new blkg is associated with
 101  *
 102  * Allocate a new blkg assocating @blkcg and @q.
 103  */
 104 static struct blkio_group *blkg_alloc(struct blkio_cgroup *blkcg,
 105                                       struct request_queue *q)
 106 {
 107         struct blkio_group *blkg;
 108         int i;
 109
 110         /* alloc and init base part */
 111         blkg = kzalloc_node(sizeof(*blkg), GFP_ATOMIC, q->node);
 112         if (!blkg)
 113                 return NULL;
 114
 115         blkg->q = q;
 116         INIT_LIST_HEAD(&blkg->q_node);
 117         blkg->blkcg = blkcg;
 118         blkg->refcnt = 1;
 119         cgroup_path(blkcg->css.cgroup, blkg->path, sizeof(blkg->path));
 120
 121         for (i = 0; i < BLKCG_MAX_POLS; i++) {
 122                 struct blkio_policy_type *pol = blkio_policy[i];
 123                 struct blkg_policy_data *pd;
 124
 125                 if (!blkcg_policy_enabled(q, pol))
 126                         continue;
 127
 128                 /* alloc per-policy data and attach it to blkg */
 129                 pd = kzalloc_node(blkg_pd_size(pol), GFP_ATOMIC, q->node);
 130                 if (!pd) {
 131                         blkg_free(blkg);
 132                         return NULL;
 133                 }
 134
 135                 blkg->pd[i] = pd;
 136                 pd->blkg = blkg;
 137         }
 138
 139         /* invoke per-policy init */
 140         for (i = 0; i < BLKCG_MAX_POLS; i++) {
 141                 struct blkio_policy_type *pol = blkio_policy[i];
 142
 143                 if (blkcg_policy_enabled(blkg->q, pol))
 144                         pol->ops.blkio_init_group_fn(blkg);
 145         }
 146
 147         return blkg;
 148 }
 149
 150 static struct blkio_group *__blkg_lookup(struct blkio_cgroup *blkcg,
 151                                          struct request_queue *q)
 152 {
 153         struct blkio_group *blkg;
 154         struct hlist_node *n;
 155
 156         hlist_for_each_entry_rcu(blkg, n, &blkcg->blkg_list, blkcg_node)
 157                 if (blkg->q == q)
 158                         return blkg;
 159         return NULL;
 160 }
 161
 162 /**
 163  * blkg_lookup - lookup blkg for the specified blkcg - q pair
 164  * @blkcg: blkcg of interest
 165  * @q: request_queue of interest
 166  *
 167  * Lookup blkg for the @blkcg - @q pair.  This function should be called
 168  * under RCU read lock and is guaranteed to return %NULL if @q is bypassing
 169  * - see blk_queue_bypass_start() for details.
 170  */
 171 struct blkio_group *blkg_lookup(struct blkio_cgroup *blkcg,
 172                                 struct request_queue *q)
 173 {
 174         WARN_ON_ONCE(!rcu_read_lock_held());
 175
 176         if (unlikely(blk_queue_bypass(q)))
 177                 return NULL;
 178         return __blkg_lookup(blkcg, q);
 179 }
 180 EXPORT_SYMBOL_GPL(blkg_lookup);
 181
 182 struct blkio_group *blkg_lookup_create(struct blkio_cgroup *blkcg,
 183                                        struct request_queue *q,
 184                                        bool for_root)
 185         __releases(q->queue_lock) __acquires(q->queue_lock)
 186 {
 187         struct blkio_group *blkg;
 188
 189         WARN_ON_ONCE(!rcu_read_lock_held());
 190         lockdep_assert_held(q->queue_lock);
 191
 192         /*
 193          * This could be the first entry point of blkcg implementation and
 194          * we shouldn't allow anything to go through for a bypassing queue.
 195          */
 196         if (unlikely(blk_queue_bypass(q)) && !for_root)
 197                 return ERR_PTR(blk_queue_dead(q) ? -EINVAL : -EBUSY);
 198
 199         blkg = __blkg_lookup(blkcg, q);
 200         if (blkg)
 201                 return blkg;
 202
 203         /* blkg holds a reference to blkcg */
 204         if (!css_tryget(&blkcg->css))
 205                 return ERR_PTR(-EINVAL);
 206
 207         /*
 208          * Allocate and initialize.
 209          */
 210         blkg = blkg_alloc(blkcg, q);
 211
 212         /* did alloc fail? */
 213         if (unlikely(!blkg)) {
 214                 blkg = ERR_PTR(-ENOMEM);
 215                 goto out;
 216         }
 217
 218         /* insert */
 219         spin_lock(&blkcg->lock);
 220         hlist_add_head_rcu(&blkg->blkcg_node, &blkcg->blkg_list);
 221         list_add(&blkg->q_node, &q->blkg_list);
 222         spin_unlock(&blkcg->lock);
 223 out:
 224         return blkg;
 225 }
 226 EXPORT_SYMBOL_GPL(blkg_lookup_create);
 227
 228 static void blkg_destroy(struct blkio_group *blkg)
 229 {
 230         struct request_queue *q = blkg->q;
 231         struct blkio_cgroup *blkcg = blkg->blkcg;
 232
 233         lockdep_assert_held(q->queue_lock);
 234         lockdep_assert_held(&blkcg->lock);
 235
 236         /* Something wrong if we are trying to remove same group twice */
 237         WARN_ON_ONCE(list_empty(&blkg->q_node));
 238         WARN_ON_ONCE(hlist_unhashed(&blkg->blkcg_node));
 239         list_del_init(&blkg->q_node);
 240         hlist_del_init_rcu(&blkg->blkcg_node);
 241
 242         /*
 243          * Put the reference taken at the time of creation so that when all
 244          * queues are gone, group can be destroyed.
 245          */
 246         blkg_put(blkg);
 247 }
 248
 249 /**
 250  * blkg_destroy_all - destroy all blkgs associated with a request_queue
 251  * @q: request_queue of interest
 252  * @destroy_root: whether to destroy root blkg or not
 253  *
 254  * Destroy blkgs associated with @q.  If @destroy_root is %true, all are
 255  * destroyed; otherwise, root blkg is left alone.
 256  */
 257 void blkg_destroy_all(struct request_queue *q, bool destroy_root)
 258 {
 259         struct blkio_group *blkg, *n;
 260
 261         spin_lock_irq(q->queue_lock);
 262
 263         list_for_each_entry_safe(blkg, n, &q->blkg_list, q_node) {
 264                 struct blkio_cgroup *blkcg = blkg->blkcg;
 265
 266                 /* skip root? */
 267                 if (!destroy_root && blkg->blkcg == &blkio_root_cgroup)
 268                         continue;
 269
 270                 spin_lock(&blkcg->lock);
 271                 blkg_destroy(blkg);
 272                 spin_unlock(&blkcg->lock);
 273         }
 274
 275         spin_unlock_irq(q->queue_lock);
 276 }
 277 EXPORT_SYMBOL_GPL(blkg_destroy_all);
 278
 279 static void blkg_rcu_free(struct rcu_head *rcu_head)
 280 {
 281         blkg_free(container_of(rcu_head, struct blkio_group, rcu_head));
 282 }
 283
 284 void __blkg_release(struct blkio_group *blkg)
 285 {
 286         /* release the extra blkcg reference this blkg has been holding */
 287         css_put(&blkg->blkcg->css);
 288
 289         /*
 290          * A group is freed in rcu manner. But having an rcu lock does not
 291          * mean that one can access all the fields of blkg and assume these
 292          * are valid. For example, don't try to follow throtl_data and
 293          * request queue links.
 294          *
 295          * Having a reference to blkg under an rcu allows acess to only
 296          * values local to groups like group stats and group rate limits
 297          */
 298         call_rcu(&blkg->rcu_head, blkg_rcu_free);
 299 }
 300 EXPORT_SYMBOL_GPL(__blkg_release);
 301
 302 static int
 303 blkiocg_reset_stats(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 304 {
 305         struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);
 306         struct blkio_group *blkg;
 307         struct hlist_node *n;
 308         int i;
 309
 310         mutex_lock(&blkcg_pol_mutex);
 311         spin_lock_irq(&blkcg->lock);
 312
 313         /*
 314          * Note that stat reset is racy - it doesn't synchronize against
 315          * stat updates.  This is a debug feature which shouldn't exist
 316          * anyway.  If you get hit by a race, retry.
 317          */
 318         hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
 319                 for (i = 0; i < BLKCG_MAX_POLS; i++) {
 320                         struct blkio_policy_type *pol = blkio_policy[i];
 321
 322                         if (blkcg_policy_enabled(blkg->q, pol) &&
 323                             pol->ops.blkio_reset_group_stats_fn)
 324                                 pol->ops.blkio_reset_group_stats_fn(blkg);
 325                 }
 326         }
 327
 328         spin_unlock_irq(&blkcg->lock);
 329         mutex_unlock(&blkcg_pol_mutex);
 330         return 0;
 331 }
 332
 333 static const char *blkg_dev_name(struct blkio_group *blkg)
 334 {
 335         /* some drivers (floppy) instantiate a queue w/o disk registered */
 336         if (blkg->q->backing_dev_info.dev)
 337                 return dev_name(blkg->q->backing_dev_info.dev);
 338         return NULL;
 339 }
 340
 341 /**
 342  * blkcg_print_blkgs - helper for printing per-blkg data
 343  * @sf: seq_file to print to
 344  * @blkcg: blkcg of interest
 345  * @prfill: fill function to print out a blkg
 346  * @pol: policy in question
 347  * @data: data to be passed to @prfill
 348  * @show_total: to print out sum of prfill return values or not
 349  *
 350  * This function invokes @prfill on each blkg of @blkcg if pd for the
 351  * policy specified by @pol exists.  @prfill is invoked with @sf, the
 352  * policy data and @data.  If @show_total is %true, the sum of the return
 353  * values from @prfill is printed with "Total" label at the end.
 354  *
 355  * This is to be used to construct print functions for
 356  * cftype->read_seq_string method.
 357  */
 358 void blkcg_print_blkgs(struct seq_file *sf, struct blkio_cgroup *blkcg,
 359                        u64 (*prfill)(struct seq_file *, void *, int),
 360                        const struct blkio_policy_type *pol, int data,
 361                        bool show_total)
 362 {
 363         struct blkio_group *blkg;
 364         struct hlist_node *n;
 365         u64 total = 0;
 366
 367         spin_lock_irq(&blkcg->lock);
 368         hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node)
 369                 if (blkcg_policy_enabled(blkg->q, pol))
 370                         total += prfill(sf, blkg->pd[pol->plid]->pdata, data);
 371         spin_unlock_irq(&blkcg->lock);
 372
 373         if (show_total)
 374                 seq_printf(sf, "Total %llu\n", (unsigned long long)total);
 375 }
 376 EXPORT_SYMBOL_GPL(blkcg_print_blkgs);
 377
 378 /**
 379  * __blkg_prfill_u64 - prfill helper for a single u64 value
 380  * @sf: seq_file to print to
 381  * @pdata: policy private data of interest
 382  * @v: value to print
 383  *
 384  * Print @v to @sf for the device assocaited with @pdata.
 385  */
 386 u64 __blkg_prfill_u64(struct seq_file *sf, void *pdata, u64 v)
 387 {
 388         const char *dname = blkg_dev_name(pdata_to_blkg(pdata));
 389
 390         if (!dname)
 391                 return 0;
 392
 393         seq_printf(sf, "%s %llu\n", dname, (unsigned long long)v);
 394         return v;
 395 }
 396 EXPORT_SYMBOL_GPL(__blkg_prfill_u64);
 397
 398 /**
 399  * __blkg_prfill_rwstat - prfill helper for a blkg_rwstat
 400  * @sf: seq_file to print to
 401  * @pdata: policy private data of interest
 402  * @rwstat: rwstat to print
 403  *
 404  * Print @rwstat to @sf for the device assocaited with @pdata.
 405  */
 406 u64 __blkg_prfill_rwstat(struct seq_file *sf, void *pdata,
 407                          const struct blkg_rwstat *rwstat)
 408 {
 409         static const char *rwstr[] = {
 410                 [BLKG_RWSTAT_READ]      = "Read",
 411                 [BLKG_RWSTAT_WRITE]     = "Write",
 412                 [BLKG_RWSTAT_SYNC]      = "Sync",
 413                 [BLKG_RWSTAT_ASYNC]     = "Async",
 414         };
 415         const char *dname = blkg_dev_name(pdata_to_blkg(pdata));
 416         u64 v;
 417         int i;
 418
 419         if (!dname)
 420                 return 0;
 421
 422         for (i = 0; i < BLKG_RWSTAT_NR; i++)
 423                 seq_printf(sf, "%s %s %llu\n", dname, rwstr[i],
 424                            (unsigned long long)rwstat->cnt[i]);
 425
 426         v = rwstat->cnt[BLKG_RWSTAT_READ] + rwstat->cnt[BLKG_RWSTAT_WRITE];
 427         seq_printf(sf, "%s Total %llu\n", dname, (unsigned long long)v);
 428         return v;
 429 }
 430
 431 /**
 432  * blkg_prfill_stat - prfill callback for blkg_stat
 433  * @sf: seq_file to print to
 434  * @pdata: policy private data of interest
 435  * @off: offset to the blkg_stat in @pdata
 436  *
 437  * prfill callback for printing a blkg_stat.
 438  */
 439 u64 blkg_prfill_stat(struct seq_file *sf, void *pdata, int off)
 440 {
 441         return __blkg_prfill_u64(sf, pdata, blkg_stat_read(pdata + off));
 442 }
 443 EXPORT_SYMBOL_GPL(blkg_prfill_stat);
 444
 445 /**
 446  * blkg_prfill_rwstat - prfill callback for blkg_rwstat
 447  * @sf: seq_file to print to
 448  * @pdata: policy private data of interest
 449  * @off: offset to the blkg_rwstat in @pdata
 450  *
 451  * prfill callback for printing a blkg_rwstat.
 452  */
 453 u64 blkg_prfill_rwstat(struct seq_file *sf, void *pdata, int off)
 454 {
 455         struct blkg_rwstat rwstat = blkg_rwstat_read(pdata + off);
 456
 457         return __blkg_prfill_rwstat(sf, pdata, &rwstat);
 458 }
 459 EXPORT_SYMBOL_GPL(blkg_prfill_rwstat);
 460
 461 /**
 462  * blkg_conf_prep - parse and prepare for per-blkg config update
 463  * @blkcg: target block cgroup
 464  * @pol: target policy
 465  * @input: input string
 466  * @ctx: blkg_conf_ctx to be filled
 467  *
 468  * Parse per-blkg config update from @input and initialize @ctx with the
 469  * result.  @ctx->blkg points to the blkg to be updated and @ctx->v the new
 470  * value.  This function returns with RCU read lock and queue lock held and
 471  * must be paired with blkg_conf_finish().
 472  */
 473 int blkg_conf_prep(struct blkio_cgroup *blkcg,
 474                    const struct blkio_policy_type *pol, const char *input,
 475                    struct blkg_conf_ctx *ctx)
 476         __acquires(rcu) __acquires(disk->queue->queue_lock)
 477 {
 478         struct gendisk *disk;
 479         struct blkio_group *blkg;
 480         unsigned int major, minor;
 481         unsigned long long v;
 482         int part, ret;
 483
 484         if (sscanf(input, "%u:%u %llu", &major, &minor, &v) != 3)
 485                 return -EINVAL;
 486
 487         disk = get_gendisk(MKDEV(major, minor), &part);
 488         if (!disk || part)
 489                 return -EINVAL;
 490
 491         rcu_read_lock();
 492         spin_lock_irq(disk->queue->queue_lock);
 493
 494         if (blkcg_policy_enabled(disk->queue, pol))
 495                 blkg = blkg_lookup_create(blkcg, disk->queue, false);
 496         else
 497                 blkg = ERR_PTR(-EINVAL);
 498
 499         if (IS_ERR(blkg)) {
 500                 ret = PTR_ERR(blkg);
 501                 rcu_read_unlock();
 502                 spin_unlock_irq(disk->queue->queue_lock);
 503                 put_disk(disk);
 504                 /*
 505                  * If queue was bypassing, we should retry.  Do so after a
 506                  * short msleep().  It isn't strictly necessary but queue
 507                  * can be bypassing for some time and it's always nice to
 508                  * avoid busy looping.
 509                  */
 510                 if (ret == -EBUSY) {
 511                         msleep(10);
 512                         ret = restart_syscall();
 513                 }
 514                 return ret;
 515         }
 516
 517         ctx->disk = disk;
 518         ctx->blkg = blkg;
 519         ctx->v = v;
 520         return 0;
 521 }
 522 EXPORT_SYMBOL_GPL(blkg_conf_prep);
 523
 524 /**
 525  * blkg_conf_finish - finish up per-blkg config update
 526  * @ctx: blkg_conf_ctx intiailized by blkg_conf_prep()
 527  *
 528  * Finish up after per-blkg config update.  This function must be paired
 529  * with blkg_conf_prep().
 530  */
 531 void blkg_conf_finish(struct blkg_conf_ctx *ctx)
 532         __releases(ctx->disk->queue->queue_lock) __releases(rcu)
 533 {
 534         spin_unlock_irq(ctx->disk->queue->queue_lock);
 535         rcu_read_unlock();
 536         put_disk(ctx->disk);
 537 }
 538 EXPORT_SYMBOL_GPL(blkg_conf_finish);
 539
 540 struct cftype blkio_files[] = {
 541         {
 542                 .name = "reset_stats",
 543                 .write_u64 = blkiocg_reset_stats,
 544         },
 545         { }     /* terminate */
 546 };
 547
 548 /**
 549  * blkiocg_pre_destroy - cgroup pre_destroy callback
 550  * @cgroup: cgroup of interest
 551  *
 552  * This function is called when @cgroup is about to go away and responsible
 553  * for shooting down all blkgs associated with @cgroup.  blkgs should be
 554  * removed while holding both q and blkcg locks.  As blkcg lock is nested
 555  * inside q lock, this function performs reverse double lock dancing.
 556  *
 557  * This is the blkcg counterpart of ioc_release_fn().
 558  */
 559 static int blkiocg_pre_destroy(struct cgroup *cgroup)
 560 {
 561         struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);
 562
 563         spin_lock_irq(&blkcg->lock);
 564
 565         while (!hlist_empty(&blkcg->blkg_list)) {
 566                 struct blkio_group *blkg = hlist_entry(blkcg->blkg_list.first,
 567                                                 struct blkio_group, blkcg_node);
 568                 struct request_queue *q = blkg->q;
 569
 570                 if (spin_trylock(q->queue_lock)) {
 571                         blkg_destroy(blkg);
 572                         spin_unlock(q->queue_lock);
 573                 } else {
 574                         spin_unlock_irq(&blkcg->lock);
 575                         cpu_relax();
 576                         spin_lock_irq(&blkcg->lock);
 577                 }
 578         }
 579
 580         spin_unlock_irq(&blkcg->lock);
 581         return 0;
 582 }
 583
 584 static void blkiocg_destroy(struct cgroup *cgroup)
 585 {
 586         struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);
 587
 588         if (blkcg != &blkio_root_cgroup)
 589                 kfree(blkcg);
 590 }
 591
 592 static struct cgroup_subsys_state *blkiocg_create(struct cgroup *cgroup)
 593 {
 594         static atomic64_t id_seq = ATOMIC64_INIT(0);
 595         struct blkio_cgroup *blkcg;
 596         struct cgroup *parent = cgroup->parent;
 597
 598         if (!parent) {
 599                 blkcg = &blkio_root_cgroup;
 600                 goto done;
 601         }
 602
 603         blkcg = kzalloc(sizeof(*blkcg), GFP_KERNEL);
 604         if (!blkcg)
 605                 return ERR_PTR(-ENOMEM);
 606
 607         blkcg->cfq_weight = CFQ_WEIGHT_DEFAULT;
 608         blkcg->id = atomic64_inc_return(&id_seq); /* root is 0, start from 1 */
 609 done:
 610         spin_lock_init(&blkcg->lock);
 611         INIT_HLIST_HEAD(&blkcg->blkg_list);
 612
 613         return &blkcg->css;
 614 }
 615
 616 /**
 617  * blkcg_init_queue - initialize blkcg part of request queue
 618  * @q: request_queue to initialize
 619  *
 620  * Called from blk_alloc_queue_node(). Responsible for initializing blkcg
 621  * part of new request_queue @q.
 622  *
 623  * RETURNS:
 624  * 0 on success, -errno on failure.
 625  */
 626 int blkcg_init_queue(struct request_queue *q)
 627 {
 628         int ret;
 629
 630         might_sleep();
 631
 632         ret = blk_throtl_init(q);
 633         if (ret)
 634                 return ret;
 635
 636         mutex_lock(&all_q_mutex);
 637         INIT_LIST_HEAD(&q->all_q_node);
 638         list_add_tail(&q->all_q_node, &all_q_list);
 639         mutex_unlock(&all_q_mutex);
 640
 641         return 0;
 642 }
 643
 644 /**
 645  * blkcg_drain_queue - drain blkcg part of request_queue
 646  * @q: request_queue to drain
 647  *
 648  * Called from blk_drain_queue().  Responsible for draining blkcg part.
 649  */
 650 void blkcg_drain_queue(struct request_queue *q)
 651 {
 652         lockdep_assert_held(q->queue_lock);
 653
 654         blk_throtl_drain(q);
 655 }
 656
 657 /**
 658  * blkcg_exit_queue - exit and release blkcg part of request_queue
 659  * @q: request_queue being released
 660  *
 661  * Called from blk_release_queue().  Responsible for exiting blkcg part.
 662  */
 663 void blkcg_exit_queue(struct request_queue *q)
 664 {
 665         mutex_lock(&all_q_mutex);
 666         list_del_init(&q->all_q_node);
 667         mutex_unlock(&all_q_mutex);
 668
 669         blkg_destroy_all(q, true);
 670
 671         blk_throtl_exit(q);
 672 }
 673
 674 /*
 675  * We cannot support shared io contexts, as we have no mean to support
 676  * two tasks with the same ioc in two different groups without major rework
 677  * of the main cic data structures.  For now we allow a task to change
 678  * its cgroup only if it's the only owner of its ioc.
 679  */
 680 static int blkiocg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
 681 {
 682         struct task_struct *task;
 683         struct io_context *ioc;
 684         int ret = 0;
 685
 686         /* task_lock() is needed to avoid races with exit_io_context() */
 687         cgroup_taskset_for_each(task, cgrp, tset) {
 688                 task_lock(task);
 689                 ioc = task->io_context;
 690                 if (ioc && atomic_read(&ioc->nr_tasks) > 1)
 691                         ret = -EINVAL;
 692                 task_unlock(task);
 693                 if (ret)
 694                         break;
 695         }
 696         return ret;
 697 }
 698
 699 struct cgroup_subsys blkio_subsys = {
 700         .name = "blkio",
 701         .create = blkiocg_create,
 702         .can_attach = blkiocg_can_attach,
 703         .pre_destroy = blkiocg_pre_destroy,
 704         .destroy = blkiocg_destroy,
 705         .subsys_id = blkio_subsys_id,
 706         .base_cftypes = blkio_files,
 707         .module = THIS_MODULE,
 708 };
 709 EXPORT_SYMBOL_GPL(blkio_subsys);
 710
 711 /**
 712  * blkcg_activate_policy - activate a blkcg policy on a request_queue
 713  * @q: request_queue of interest
 714  * @pol: blkcg policy to activate
 715  *
 716  * Activate @pol on @q.  Requires %GFP_KERNEL context.  @q goes through
 717  * bypass mode to populate its blkgs with policy_data for @pol.
 718  *
 719  * Activation happens with @q bypassed, so nobody would be accessing blkgs
 720  * from IO path.  Update of each blkg is protected by both queue and blkcg
 721  * locks so that holding either lock and testing blkcg_policy_enabled() is
 722  * always enough for dereferencing policy data.
 723  *
 724  * The caller is responsible for synchronizing [de]activations and policy
 725  * [un]registerations.  Returns 0 on success, -errno on failure.
 726  */
 727 int blkcg_activate_policy(struct request_queue *q,
 728                           const struct blkio_policy_type *pol)
 729 {
 730         LIST_HEAD(pds);
 731         struct blkio_group *blkg;
 732         struct blkg_policy_data *pd, *n;
 733         int cnt = 0, ret;
 734
 735         if (blkcg_policy_enabled(q, pol))
 736                 return 0;
 737
 738         blk_queue_bypass_start(q);
 739
 740         /* make sure the root blkg exists and count the existing blkgs */
 741         spin_lock_irq(q->queue_lock);
 742
 743         rcu_read_lock();
 744         blkg = blkg_lookup_create(&blkio_root_cgroup, q, true);
 745         rcu_read_unlock();
 746
 747         if (IS_ERR(blkg)) {
 748                 ret = PTR_ERR(blkg);
 749                 goto out_unlock;
 750         }
 751         q->root_blkg = blkg;
 752
 753         list_for_each_entry(blkg, &q->blkg_list, q_node)
 754                 cnt++;
 755
 756         spin_unlock_irq(q->queue_lock);
 757
 758         /* allocate policy_data for all existing blkgs */
 759         while (cnt--) {
 760                 pd = kzalloc_node(blkg_pd_size(pol), GFP_KERNEL, q->node);
 761                 if (!pd) {
 762                         ret = -ENOMEM;
 763                         goto out_free;
 764                 }
 765                 list_add_tail(&pd->alloc_node, &pds);
 766         }
 767
 768         /*
 769          * Install the allocated pds.  With @q bypassing, no new blkg
 770          * should have been created while the queue lock was dropped.
 771          */
 772         spin_lock_irq(q->queue_lock);
 773
 774         list_for_each_entry(blkg, &q->blkg_list, q_node) {
 775                 if (WARN_ON(list_empty(&pds))) {
 776                         /* umm... this shouldn't happen, just abort */
 777                         ret = -ENOMEM;
 778                         goto out_unlock;
 779                 }
 780                 pd = list_first_entry(&pds, struct blkg_policy_data, alloc_node);
 781                 list_del_init(&pd->alloc_node);
 782
 783                 /* grab blkcg lock too while installing @pd on @blkg */
 784                 spin_lock(&blkg->blkcg->lock);
 785
 786                 blkg->pd[pol->plid] = pd;
 787                 pd->blkg = blkg;
 788                 pol->ops.blkio_init_group_fn(blkg);
 789
 790                 spin_unlock(&blkg->blkcg->lock);
 791         }
 792
 793         __set_bit(pol->plid, q->blkcg_pols);
 794         ret = 0;
 795 out_unlock:
 796         spin_unlock_irq(q->queue_lock);
 797 out_free:
 798         blk_queue_bypass_end(q);
 799         list_for_each_entry_safe(pd, n, &pds, alloc_node)
 800                 kfree(pd);
 801         return ret;
 802 }
 803 EXPORT_SYMBOL_GPL(blkcg_activate_policy);
 804
 805 /**
 806  * blkcg_deactivate_policy - deactivate a blkcg policy on a request_queue
 807  * @q: request_queue of interest
 808  * @pol: blkcg policy to deactivate
 809  *
 810  * Deactivate @pol on @q.  Follows the same synchronization rules as
 811  * blkcg_activate_policy().
 812  */
 813 void blkcg_deactivate_policy(struct request_queue *q,
 814                              const struct blkio_policy_type *pol)
 815 {
 816         struct blkio_group *blkg;
 817
 818         if (!blkcg_policy_enabled(q, pol))
 819                 return;
 820
 821         blk_queue_bypass_start(q);
 822         spin_lock_irq(q->queue_lock);
 823
 824         __clear_bit(pol->plid, q->blkcg_pols);
 825
 826         list_for_each_entry(blkg, &q->blkg_list, q_node) {
 827                 /* grab blkcg lock too while removing @pd from @blkg */
 828                 spin_lock(&blkg->blkcg->lock);
 829
 830                 if (pol->ops.blkio_exit_group_fn)
 831                         pol->ops.blkio_exit_group_fn(blkg);
 832
 833                 kfree(blkg->pd[pol->plid]);
 834                 blkg->pd[pol->plid] = NULL;
 835
 836                 spin_unlock(&blkg->blkcg->lock);
 837         }
 838
 839         spin_unlock_irq(q->queue_lock);
 840         blk_queue_bypass_end(q);
 841 }
 842 EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);
 843
 844 /**
 845  * blkio_policy_register - register a blkcg policy
 846  * @blkiop: blkcg policy to register
 847  *
 848  * Register @blkiop with blkcg core.  Might sleep and @blkiop may be
 849  * modified on successful registration.  Returns 0 on success and -errno on
 850  * failure.
 851  */
 852 int blkio_policy_register(struct blkio_policy_type *blkiop)
 853 {
 854         int i, ret;
 855
 856         mutex_lock(&blkcg_pol_mutex);
 857
 858         /* find an empty slot */
 859         ret = -ENOSPC;
 860         for (i = 0; i < BLKCG_MAX_POLS; i++)
 861                 if (!blkio_policy[i])
 862                         break;
 863         if (i >= BLKCG_MAX_POLS)
 864                 goto out_unlock;
 865
 866         /* register and update blkgs */
 867         blkiop->plid = i;
 868         blkio_policy[i] = blkiop;
 869
 870         /* everything is in place, add intf files for the new policy */
 871         if (blkiop->cftypes)
 872                 WARN_ON(cgroup_add_cftypes(&blkio_subsys, blkiop->cftypes));
 873         ret = 0;
 874 out_unlock:
 875         mutex_unlock(&blkcg_pol_mutex);
 876         return ret;
 877 }
 878 EXPORT_SYMBOL_GPL(blkio_policy_register);
 879
 880 /**
 881  * blkiop_policy_unregister - unregister a blkcg policy
 882  * @blkiop: blkcg policy to unregister
 883  *
 884  * Undo blkio_policy_register(@blkiop).  Might sleep.
 885  */
 886 void blkio_policy_unregister(struct blkio_policy_type *blkiop)
 887 {
 888         mutex_lock(&blkcg_pol_mutex);
 889
 890         if (WARN_ON(blkio_policy[blkiop->plid] != blkiop))
 891                 goto out_unlock;
 892
 893         /* kill the intf files first */
 894         if (blkiop->cftypes)
 895                 cgroup_rm_cftypes(&blkio_subsys, blkiop->cftypes);
 896
 897         /* unregister and update blkgs */
 898         blkio_policy[blkiop->plid] = NULL;
 899 out_unlock:
 900         mutex_unlock(&blkcg_pol_mutex);
 901 }
 902 EXPORT_SYMBOL_GPL(blkio_policy_unregister);