SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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/seq_file.h>
  15 #include <linux/kdev_t.h>
  16 #include <linux/module.h>
  17 #include <linux/err.h>
  18 #include <linux/blkdev.h>
  19 #include "blk-cgroup.h"
  20
  21 #define MAX_KEY_LEN 100
  22
  23 static DEFINE_SPINLOCK(blkio_list_lock);
  24 static LIST_HEAD(blkio_list);
  25
  26 struct blkio_cgroup blkio_root_cgroup = { .weight = 2*BLKIO_WEIGHT_DEFAULT };
  27 EXPORT_SYMBOL_GPL(blkio_root_cgroup);
  28
  29 static struct cgroup_subsys_state *blkiocg_create(struct cgroup_subsys *,
  30                                                   struct cgroup *);
  31 static int blkiocg_can_attach(struct cgroup_subsys *, struct cgroup *,
  32                               struct task_struct *, bool);
  33 static void blkiocg_attach(struct cgroup_subsys *, struct cgroup *,
  34                            struct cgroup *, struct task_struct *, bool);
  35 static void blkiocg_destroy(struct cgroup_subsys *, struct cgroup *);
  36 static int blkiocg_populate(struct cgroup_subsys *, struct cgroup *);
  37
  38 struct cgroup_subsys blkio_subsys = {
  39         .name = "blkio",
  40         .create = blkiocg_create,
  41         .can_attach = blkiocg_can_attach,
  42         .attach = blkiocg_attach,
  43         .destroy = blkiocg_destroy,
  44         .populate = blkiocg_populate,
  45 #ifdef CONFIG_BLK_CGROUP
  46         /* note: blkio_subsys_id is otherwise defined in blk-cgroup.h */
  47         .subsys_id = blkio_subsys_id,
  48 #endif
  49         .use_id = 1,
  50         .module = THIS_MODULE,
  51 };
  52 EXPORT_SYMBOL_GPL(blkio_subsys);
  53
  54 struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)
  55 {
  56         return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),
  57                             struct blkio_cgroup, css);
  58 }
  59 EXPORT_SYMBOL_GPL(cgroup_to_blkio_cgroup);
  60
  61 void blkio_group_init(struct blkio_group *blkg)
  62 {
  63         spin_lock_init(&blkg->stats_lock);
  64 }
  65 EXPORT_SYMBOL_GPL(blkio_group_init);
  66
  67 /*
  68  * Add to the appropriate stat variable depending on the request type.
  69  * This should be called with the blkg->stats_lock held.
  70  */
  71 static void blkio_add_stat(uint64_t *stat, uint64_t add, bool direction,
  72                                 bool sync)
  73 {
  74         if (direction)
  75                 stat[BLKIO_STAT_WRITE] += add;
  76         else
  77                 stat[BLKIO_STAT_READ] += add;
  78         if (sync)
  79                 stat[BLKIO_STAT_SYNC] += add;
  80         else
  81                 stat[BLKIO_STAT_ASYNC] += add;
  82 }
  83
  84 /*
  85  * Decrements the appropriate stat variable if non-zero depending on the
  86  * request type. Panics on value being zero.
  87  * This should be called with the blkg->stats_lock held.
  88  */
  89 static void blkio_check_and_dec_stat(uint64_t *stat, bool direction, bool sync)
  90 {
  91         if (direction) {
  92                 BUG_ON(stat[BLKIO_STAT_WRITE] == 0);
  93                 stat[BLKIO_STAT_WRITE]--;
  94         } else {
  95                 BUG_ON(stat[BLKIO_STAT_READ] == 0);
  96                 stat[BLKIO_STAT_READ]--;
  97         }
  98         if (sync) {
  99                 BUG_ON(stat[BLKIO_STAT_SYNC] == 0);
 100                 stat[BLKIO_STAT_SYNC]--;
 101         } else {
 102                 BUG_ON(stat[BLKIO_STAT_ASYNC] == 0);
 103                 stat[BLKIO_STAT_ASYNC]--;
 104         }
 105 }
 106
 107 #ifdef CONFIG_DEBUG_BLK_CGROUP
 108 /* This should be called with the blkg->stats_lock held. */
 109 static void blkio_set_start_group_wait_time(struct blkio_group *blkg,
 110                                                 struct blkio_group *curr_blkg)
 111 {
 112         if (blkio_blkg_waiting(&blkg->stats))
 113                 return;
 114         if (blkg == curr_blkg)
 115                 return;
 116         blkg->stats.start_group_wait_time = sched_clock();
 117         blkio_mark_blkg_waiting(&blkg->stats);
 118 }
 119
 120 /* This should be called with the blkg->stats_lock held. */
 121 static void blkio_update_group_wait_time(struct blkio_group_stats *stats)
 122 {
 123         unsigned long long now;
 124
 125         if (!blkio_blkg_waiting(stats))
 126                 return;
 127
 128         now = sched_clock();
 129         if (time_after64(now, stats->start_group_wait_time))
 130                 stats->group_wait_time += now - stats->start_group_wait_time;
 131         blkio_clear_blkg_waiting(stats);
 132 }
 133
 134 /* This should be called with the blkg->stats_lock held. */
 135 static void blkio_end_empty_time(struct blkio_group_stats *stats)
 136 {
 137         unsigned long long now;
 138
 139         if (!blkio_blkg_empty(stats))
 140                 return;
 141
 142         now = sched_clock();
 143         if (time_after64(now, stats->start_empty_time))
 144                 stats->empty_time += now - stats->start_empty_time;
 145         blkio_clear_blkg_empty(stats);
 146 }
 147
 148 void blkiocg_update_set_idle_time_stats(struct blkio_group *blkg)
 149 {
 150         unsigned long flags;
 151
 152         spin_lock_irqsave(&blkg->stats_lock, flags);
 153         BUG_ON(blkio_blkg_idling(&blkg->stats));
 154         blkg->stats.start_idle_time = sched_clock();
 155         blkio_mark_blkg_idling(&blkg->stats);
 156         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 157 }
 158 EXPORT_SYMBOL_GPL(blkiocg_update_set_idle_time_stats);
 159
 160 void blkiocg_update_idle_time_stats(struct blkio_group *blkg)
 161 {
 162         unsigned long flags;
 163         unsigned long long now;
 164         struct blkio_group_stats *stats;
 165
 166         spin_lock_irqsave(&blkg->stats_lock, flags);
 167         stats = &blkg->stats;
 168         if (blkio_blkg_idling(stats)) {
 169                 now = sched_clock();
 170                 if (time_after64(now, stats->start_idle_time))
 171                         stats->idle_time += now - stats->start_idle_time;
 172                 blkio_clear_blkg_idling(stats);
 173         }
 174         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 175 }
 176 EXPORT_SYMBOL_GPL(blkiocg_update_idle_time_stats);
 177
 178 void blkiocg_update_set_active_queue_stats(struct blkio_group *blkg)
 179 {
 180         unsigned long flags;
 181         struct blkio_group_stats *stats;
 182
 183         spin_lock_irqsave(&blkg->stats_lock, flags);
 184         stats = &blkg->stats;
 185         stats->avg_queue_size_sum +=
 186                         stats->stat_arr[BLKIO_STAT_QUEUED][BLKIO_STAT_READ] +
 187                         stats->stat_arr[BLKIO_STAT_QUEUED][BLKIO_STAT_WRITE];
 188         stats->avg_queue_size_samples++;
 189         blkio_update_group_wait_time(stats);
 190         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 191 }
 192 EXPORT_SYMBOL_GPL(blkiocg_update_set_active_queue_stats);
 193 #else
 194 static inline void blkio_set_start_group_wait_time(struct blkio_group *blkg,
 195                                         struct blkio_group *curr_blkg) {}
 196 static inline void blkio_end_empty_time(struct blkio_group_stats *stats) {}
 197 #endif
 198
 199 void blkiocg_update_request_add_stats(struct blkio_group *blkg,
 200                         struct blkio_group *curr_blkg, bool direction,
 201                         bool sync)
 202 {
 203         unsigned long flags;
 204
 205         spin_lock_irqsave(&blkg->stats_lock, flags);
 206         blkio_add_stat(blkg->stats.stat_arr[BLKIO_STAT_QUEUED], 1, direction,
 207                         sync);
 208         blkio_end_empty_time(&blkg->stats);
 209         blkio_set_start_group_wait_time(blkg, curr_blkg);
 210         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 211 }
 212 EXPORT_SYMBOL_GPL(blkiocg_update_request_add_stats);
 213
 214 void blkiocg_update_request_remove_stats(struct blkio_group *blkg,
 215                                                 bool direction, bool sync)
 216 {
 217         unsigned long flags;
 218
 219         spin_lock_irqsave(&blkg->stats_lock, flags);
 220         blkio_check_and_dec_stat(blkg->stats.stat_arr[BLKIO_STAT_QUEUED],
 221                                         direction, sync);
 222         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 223 }
 224 EXPORT_SYMBOL_GPL(blkiocg_update_request_remove_stats);
 225
 226 void blkiocg_update_timeslice_used(struct blkio_group *blkg, unsigned long time)
 227 {
 228         unsigned long flags;
 229
 230         spin_lock_irqsave(&blkg->stats_lock, flags);
 231         blkg->stats.time += time;
 232         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 233 }
 234 EXPORT_SYMBOL_GPL(blkiocg_update_timeslice_used);
 235
 236 void blkiocg_set_start_empty_time(struct blkio_group *blkg, bool ignore)
 237 {
 238         unsigned long flags;
 239         struct blkio_group_stats *stats;
 240
 241         spin_lock_irqsave(&blkg->stats_lock, flags);
 242         stats = &blkg->stats;
 243
 244         if (stats->stat_arr[BLKIO_STAT_QUEUED][BLKIO_STAT_READ] ||
 245                         stats->stat_arr[BLKIO_STAT_QUEUED][BLKIO_STAT_WRITE]) {
 246                 spin_unlock_irqrestore(&blkg->stats_lock, flags);
 247                 return;
 248         }
 249
 250         /*
 251          * If ignore is set, we do not panic on the empty flag being set
 252          * already. This is to avoid cases where there are superfluous timeslice
 253          * complete events (for eg., forced_dispatch in CFQ) when no IOs are
 254          * served which could result in triggering the empty check incorrectly.
 255          */
 256         BUG_ON(!ignore && blkio_blkg_empty(stats));
 257         stats->start_empty_time = sched_clock();
 258         blkio_mark_blkg_empty(stats);
 259         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 260 }
 261 EXPORT_SYMBOL_GPL(blkiocg_set_start_empty_time);
 262
 263 void blkiocg_update_dispatch_stats(struct blkio_group *blkg,
 264                                 uint64_t bytes, bool direction, bool sync)
 265 {
 266         struct blkio_group_stats *stats;
 267         unsigned long flags;
 268
 269         spin_lock_irqsave(&blkg->stats_lock, flags);
 270         stats = &blkg->stats;
 271         stats->sectors += bytes >> 9;
 272         blkio_add_stat(stats->stat_arr[BLKIO_STAT_SERVICED], 1, direction,
 273                         sync);
 274         blkio_add_stat(stats->stat_arr[BLKIO_STAT_SERVICE_BYTES], bytes,
 275                         direction, sync);
 276         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 277 }
 278 EXPORT_SYMBOL_GPL(blkiocg_update_dispatch_stats);
 279
 280 void blkiocg_update_completion_stats(struct blkio_group *blkg,
 281         uint64_t start_time, uint64_t io_start_time, bool direction, bool sync)
 282 {
 283         struct blkio_group_stats *stats;
 284         unsigned long flags;
 285         unsigned long long now = sched_clock();
 286
 287         spin_lock_irqsave(&blkg->stats_lock, flags);
 288         stats = &blkg->stats;
 289         if (time_after64(now, io_start_time))
 290                 blkio_add_stat(stats->stat_arr[BLKIO_STAT_SERVICE_TIME],
 291                                 now - io_start_time, direction, sync);
 292         if (time_after64(io_start_time, start_time))
 293                 blkio_add_stat(stats->stat_arr[BLKIO_STAT_WAIT_TIME],
 294                                 io_start_time - start_time, direction, sync);
 295         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 296 }
 297 EXPORT_SYMBOL_GPL(blkiocg_update_completion_stats);
 298
 299 void blkiocg_update_io_merged_stats(struct blkio_group *blkg, bool direction,
 300                                         bool sync)
 301 {
 302         unsigned long flags;
 303
 304         spin_lock_irqsave(&blkg->stats_lock, flags);
 305         blkio_add_stat(blkg->stats.stat_arr[BLKIO_STAT_MERGED], 1, direction,
 306                         sync);
 307         spin_unlock_irqrestore(&blkg->stats_lock, flags);
 308 }
 309 EXPORT_SYMBOL_GPL(blkiocg_update_io_merged_stats);
 310
 311 void blkiocg_add_blkio_group(struct blkio_cgroup *blkcg,
 312                         struct blkio_group *blkg, void *key, dev_t dev)
 313 {
 314         unsigned long flags;
 315
 316         spin_lock_irqsave(&blkcg->lock, flags);
 317         rcu_assign_pointer(blkg->key, key);
 318         blkg->blkcg_id = css_id(&blkcg->css);
 319         hlist_add_head_rcu(&blkg->blkcg_node, &blkcg->blkg_list);
 320         spin_unlock_irqrestore(&blkcg->lock, flags);
 321 #ifdef CONFIG_DEBUG_BLK_CGROUP
 322         /* Need to take css reference ? */
 323         cgroup_path(blkcg->css.cgroup, blkg->path, sizeof(blkg->path));
 324 #endif
 325         blkg->dev = dev;
 326 }
 327 EXPORT_SYMBOL_GPL(blkiocg_add_blkio_group);
 328
 329 static void __blkiocg_del_blkio_group(struct blkio_group *blkg)
 330 {
 331         hlist_del_init_rcu(&blkg->blkcg_node);
 332         blkg->blkcg_id = 0;
 333 }
 334
 335 /*
 336  * returns 0 if blkio_group was still on cgroup list. Otherwise returns 1
 337  * indicating that blk_group was unhashed by the time we got to it.
 338  */
 339 int blkiocg_del_blkio_group(struct blkio_group *blkg)
 340 {
 341         struct blkio_cgroup *blkcg;
 342         unsigned long flags;
 343         struct cgroup_subsys_state *css;
 344         int ret = 1;
 345
 346         rcu_read_lock();
 347         css = css_lookup(&blkio_subsys, blkg->blkcg_id);
 348         if (!css)
 349                 goto out;
 350
 351         blkcg = container_of(css, struct blkio_cgroup, css);
 352         spin_lock_irqsave(&blkcg->lock, flags);
 353         if (!hlist_unhashed(&blkg->blkcg_node)) {
 354                 __blkiocg_del_blkio_group(blkg);
 355                 ret = 0;
 356         }
 357         spin_unlock_irqrestore(&blkcg->lock, flags);
 358 out:
 359         rcu_read_unlock();
 360         return ret;
 361 }
 362 EXPORT_SYMBOL_GPL(blkiocg_del_blkio_group);
 363
 364 /* called under rcu_read_lock(). */
 365 struct blkio_group *blkiocg_lookup_group(struct blkio_cgroup *blkcg, void *key)
 366 {
 367         struct blkio_group *blkg;
 368         struct hlist_node *n;
 369         void *__key;
 370
 371         hlist_for_each_entry_rcu(blkg, n, &blkcg->blkg_list, blkcg_node) {
 372                 __key = blkg->key;
 373                 if (__key == key)
 374                         return blkg;
 375         }
 376
 377         return NULL;
 378 }
 379 EXPORT_SYMBOL_GPL(blkiocg_lookup_group);
 380
 381 #define SHOW_FUNCTION(__VAR)                                            \
 382 static u64 blkiocg_##__VAR##_read(struct cgroup *cgroup,                \
 383                                        struct cftype *cftype)           \
 384 {                                                                       \
 385         struct blkio_cgroup *blkcg;                                     \
 386                                                                         \
 387         blkcg = cgroup_to_blkio_cgroup(cgroup);                         \
 388         return (u64)blkcg->__VAR;                                       \
 389 }
 390
 391 SHOW_FUNCTION(weight);
 392 #undef SHOW_FUNCTION
 393
 394 static int
 395 blkiocg_weight_write(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 396 {
 397         struct blkio_cgroup *blkcg;
 398         struct blkio_group *blkg;
 399         struct hlist_node *n;
 400         struct blkio_policy_type *blkiop;
 401
 402         if (val < BLKIO_WEIGHT_MIN || val > BLKIO_WEIGHT_MAX)
 403                 return -EINVAL;
 404
 405         blkcg = cgroup_to_blkio_cgroup(cgroup);
 406         spin_lock(&blkio_list_lock);
 407         spin_lock_irq(&blkcg->lock);
 408         blkcg->weight = (unsigned int)val;
 409         hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
 410                 list_for_each_entry(blkiop, &blkio_list, list)
 411                         blkiop->ops.blkio_update_group_weight_fn(blkg,
 412                                         blkcg->weight);
 413         }
 414         spin_unlock_irq(&blkcg->lock);
 415         spin_unlock(&blkio_list_lock);
 416         return 0;
 417 }
 418
 419 static int
 420 blkiocg_reset_stats(struct cgroup *cgroup, struct cftype *cftype, u64 val)
 421 {
 422         struct blkio_cgroup *blkcg;
 423         struct blkio_group *blkg;
 424         struct blkio_group_stats *stats;
 425         struct hlist_node *n;
 426         uint64_t queued[BLKIO_STAT_TOTAL];
 427         int i;
 428 #ifdef CONFIG_DEBUG_BLK_CGROUP
 429         bool idling, waiting, empty;
 430         unsigned long long now = sched_clock();
 431 #endif
 432
 433         blkcg = cgroup_to_blkio_cgroup(cgroup);
 434         spin_lock_irq(&blkcg->lock);
 435         hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {
 436                 spin_lock(&blkg->stats_lock);
 437                 stats = &blkg->stats;
 438 #ifdef CONFIG_DEBUG_BLK_CGROUP
 439                 idling = blkio_blkg_idling(stats);
 440                 waiting = blkio_blkg_waiting(stats);
 441                 empty = blkio_blkg_empty(stats);
 442 #endif
 443                 for (i = 0; i < BLKIO_STAT_TOTAL; i++)
 444                         queued[i] = stats->stat_arr[BLKIO_STAT_QUEUED][i];
 445                 memset(stats, 0, sizeof(struct blkio_group_stats));
 446                 for (i = 0; i < BLKIO_STAT_TOTAL; i++)
 447                         stats->stat_arr[BLKIO_STAT_QUEUED][i] = queued[i];
 448 #ifdef CONFIG_DEBUG_BLK_CGROUP
 449                 if (idling) {
 450                         blkio_mark_blkg_idling(stats);
 451                         stats->start_idle_time = now;
 452                 }
 453                 if (waiting) {
 454                         blkio_mark_blkg_waiting(stats);
 455                         stats->start_group_wait_time = now;
 456                 }
 457                 if (empty) {
 458                         blkio_mark_blkg_empty(stats);
 459                         stats->start_empty_time = now;
 460                 }
 461 #endif
 462                 spin_unlock(&blkg->stats_lock);
 463         }
 464         spin_unlock_irq(&blkcg->lock);
 465         return 0;
 466 }
 467
 468 static void blkio_get_key_name(enum stat_sub_type type, dev_t dev, char *str,
 469                                 int chars_left, bool diskname_only)
 470 {
 471         snprintf(str, chars_left, "%d:%d", MAJOR(dev), MINOR(dev));
 472         chars_left -= strlen(str);
 473         if (chars_left <= 0) {
 474                 printk(KERN_WARNING
 475                         "Possibly incorrect cgroup stat display format");
 476                 return;
 477         }
 478         if (diskname_only)
 479                 return;
 480         switch (type) {
 481         case BLKIO_STAT_READ:
 482                 strlcat(str, " Read", chars_left);
 483                 break;
 484         case BLKIO_STAT_WRITE:
 485                 strlcat(str, " Write", chars_left);
 486                 break;
 487         case BLKIO_STAT_SYNC:
 488                 strlcat(str, " Sync", chars_left);
 489                 break;
 490         case BLKIO_STAT_ASYNC:
 491                 strlcat(str, " Async", chars_left);
 492                 break;
 493         case BLKIO_STAT_TOTAL:
 494                 strlcat(str, " Total", chars_left);
 495                 break;
 496         default:
 497                 strlcat(str, " Invalid", chars_left);
 498         }
 499 }
 500
 501 static uint64_t blkio_fill_stat(char *str, int chars_left, uint64_t val,
 502                                 struct cgroup_map_cb *cb, dev_t dev)
 503 {
 504         blkio_get_key_name(0, dev, str, chars_left, true);
 505         cb->fill(cb, str, val);
 506         return val;
 507 }
 508
 509 /* This should be called with blkg->stats_lock held */
 510 static uint64_t blkio_get_stat(struct blkio_group *blkg,
 511                 struct cgroup_map_cb *cb, dev_t dev, enum stat_type type)
 512 {
 513         uint64_t disk_total;
 514         char key_str[MAX_KEY_LEN];
 515         enum stat_sub_type sub_type;
 516
 517         if (type == BLKIO_STAT_TIME)
 518                 return blkio_fill_stat(key_str, MAX_KEY_LEN - 1,
 519                                         blkg->stats.time, cb, dev);
 520         if (type == BLKIO_STAT_SECTORS)
 521                 return blkio_fill_stat(key_str, MAX_KEY_LEN - 1,
 522                                         blkg->stats.sectors, cb, dev);
 523 #ifdef CONFIG_DEBUG_BLK_CGROUP
 524         if (type == BLKIO_STAT_AVG_QUEUE_SIZE) {
 525                 uint64_t sum = blkg->stats.avg_queue_size_sum;
 526                 uint64_t samples = blkg->stats.avg_queue_size_samples;
 527                 if (samples)
 528                         do_div(sum, samples);
 529                 else
 530                         sum = 0;
 531                 return blkio_fill_stat(key_str, MAX_KEY_LEN - 1, sum, cb, dev);
 532         }
 533         if (type == BLKIO_STAT_GROUP_WAIT_TIME)
 534                 return blkio_fill_stat(key_str, MAX_KEY_LEN - 1,
 535                                         blkg->stats.group_wait_time, cb, dev);
 536         if (type == BLKIO_STAT_IDLE_TIME)
 537                 return blkio_fill_stat(key_str, MAX_KEY_LEN - 1,
 538                                         blkg->stats.idle_time, cb, dev);
 539         if (type == BLKIO_STAT_EMPTY_TIME)
 540                 return blkio_fill_stat(key_str, MAX_KEY_LEN - 1,
 541                                         blkg->stats.empty_time, cb, dev);
 542         if (type == BLKIO_STAT_DEQUEUE)
 543                 return blkio_fill_stat(key_str, MAX_KEY_LEN - 1,
 544                                         blkg->stats.dequeue, cb, dev);
 545 #endif
 546
 547         for (sub_type = BLKIO_STAT_READ; sub_type < BLKIO_STAT_TOTAL;
 548                         sub_type++) {
 549                 blkio_get_key_name(sub_type, dev, key_str, MAX_KEY_LEN, false);
 550                 cb->fill(cb, key_str, blkg->stats.stat_arr[type][sub_type]);
 551         }
 552         disk_total = blkg->stats.stat_arr[type][BLKIO_STAT_READ] +
 553                         blkg->stats.stat_arr[type][BLKIO_STAT_WRITE];
 554         blkio_get_key_name(BLKIO_STAT_TOTAL, dev, key_str, MAX_KEY_LEN, false);
 555         cb->fill(cb, key_str, disk_total);
 556         return disk_total;
 557 }
 558
 559 #define SHOW_FUNCTION_PER_GROUP(__VAR, type, show_total)                \
 560 static int blkiocg_##__VAR##_read(struct cgroup *cgroup,                \
 561                 struct cftype *cftype, struct cgroup_map_cb *cb)        \
 562 {                                                                       \
 563         struct blkio_cgroup *blkcg;                                     \
 564         struct blkio_group *blkg;                                       \
 565         struct hlist_node *n;                                           \
 566         uint64_t cgroup_total = 0;                                      \
 567                                                                         \
 568         if (!cgroup_lock_live_group(cgroup))                            \
 569                 return -ENODEV;                                         \
 570                                                                         \
 571         blkcg = cgroup_to_blkio_cgroup(cgroup);                         \
 572         rcu_read_lock();                                                \
 573         hlist_for_each_entry_rcu(blkg, n, &blkcg->blkg_list, blkcg_node) {\
 574                 if (blkg->dev) {                                        \
 575                         spin_lock_irq(&blkg->stats_lock);               \
 576                         cgroup_total += blkio_get_stat(blkg, cb,        \
 577                                                 blkg->dev, type);       \
 578                         spin_unlock_irq(&blkg->stats_lock);             \
 579                 }                                                       \
 580         }                                                               \
 581         if (show_total)                                                 \
 582                 cb->fill(cb, "Total", cgroup_total);                    \
 583         rcu_read_unlock();                                              \
 584         cgroup_unlock();                                                \
 585         return 0;                                                       \
 586 }
 587
 588 SHOW_FUNCTION_PER_GROUP(time, BLKIO_STAT_TIME, 0);
 589 SHOW_FUNCTION_PER_GROUP(sectors, BLKIO_STAT_SECTORS, 0);
 590 SHOW_FUNCTION_PER_GROUP(io_service_bytes, BLKIO_STAT_SERVICE_BYTES, 1);
 591 SHOW_FUNCTION_PER_GROUP(io_serviced, BLKIO_STAT_SERVICED, 1);
 592 SHOW_FUNCTION_PER_GROUP(io_service_time, BLKIO_STAT_SERVICE_TIME, 1);
 593 SHOW_FUNCTION_PER_GROUP(io_wait_time, BLKIO_STAT_WAIT_TIME, 1);
 594 SHOW_FUNCTION_PER_GROUP(io_merged, BLKIO_STAT_MERGED, 1);
 595 SHOW_FUNCTION_PER_GROUP(io_queued, BLKIO_STAT_QUEUED, 1);
 596 #ifdef CONFIG_DEBUG_BLK_CGROUP
 597 SHOW_FUNCTION_PER_GROUP(dequeue, BLKIO_STAT_DEQUEUE, 0);
 598 SHOW_FUNCTION_PER_GROUP(avg_queue_size, BLKIO_STAT_AVG_QUEUE_SIZE, 0);
 599 SHOW_FUNCTION_PER_GROUP(group_wait_time, BLKIO_STAT_GROUP_WAIT_TIME, 0);
 600 SHOW_FUNCTION_PER_GROUP(idle_time, BLKIO_STAT_IDLE_TIME, 0);
 601 SHOW_FUNCTION_PER_GROUP(empty_time, BLKIO_STAT_EMPTY_TIME, 0);
 602 #endif
 603 #undef SHOW_FUNCTION_PER_GROUP
 604
 605 #ifdef CONFIG_DEBUG_BLK_CGROUP
 606 void blkiocg_update_dequeue_stats(struct blkio_group *blkg,
 607                         unsigned long dequeue)
 608 {
 609         blkg->stats.dequeue += dequeue;
 610 }
 611 EXPORT_SYMBOL_GPL(blkiocg_update_dequeue_stats);
 612 #endif
 613
 614 struct cftype blkio_files[] = {
 615         {
 616                 .name = "weight",
 617                 .read_u64 = blkiocg_weight_read,
 618                 .write_u64 = blkiocg_weight_write,
 619         },
 620         {
 621                 .name = "time",
 622                 .read_map = blkiocg_time_read,
 623         },
 624         {
 625                 .name = "sectors",
 626                 .read_map = blkiocg_sectors_read,
 627         },
 628         {
 629                 .name = "io_service_bytes",
 630                 .read_map = blkiocg_io_service_bytes_read,
 631         },
 632         {
 633                 .name = "io_serviced",
 634                 .read_map = blkiocg_io_serviced_read,
 635         },
 636         {
 637                 .name = "io_service_time",
 638                 .read_map = blkiocg_io_service_time_read,
 639         },
 640         {
 641                 .name = "io_wait_time",
 642                 .read_map = blkiocg_io_wait_time_read,
 643         },
 644         {
 645                 .name = "io_merged",
 646                 .read_map = blkiocg_io_merged_read,
 647         },
 648         {
 649                 .name = "io_queued",
 650                 .read_map = blkiocg_io_queued_read,
 651         },
 652         {
 653                 .name = "reset_stats",
 654                 .write_u64 = blkiocg_reset_stats,
 655         },
 656 #ifdef CONFIG_DEBUG_BLK_CGROUP
 657         {
 658                 .name = "avg_queue_size",
 659                 .read_map = blkiocg_avg_queue_size_read,
 660         },
 661         {
 662                 .name = "group_wait_time",
 663                 .read_map = blkiocg_group_wait_time_read,
 664         },
 665         {
 666                 .name = "idle_time",
 667                 .read_map = blkiocg_idle_time_read,
 668         },
 669         {
 670                 .name = "empty_time",
 671                 .read_map = blkiocg_empty_time_read,
 672         },
 673         {
 674                 .name = "dequeue",
 675                 .read_map = blkiocg_dequeue_read,
 676         },
 677 #endif
 678 };
 679
 680 static int blkiocg_populate(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 681 {
 682         return cgroup_add_files(cgroup, subsys, blkio_files,
 683                                 ARRAY_SIZE(blkio_files));
 684 }
 685
 686 static void blkiocg_destroy(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 687 {
 688         struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);
 689         unsigned long flags;
 690         struct blkio_group *blkg;
 691         void *key;
 692         struct blkio_policy_type *blkiop;
 693
 694         rcu_read_lock();
 695 remove_entry:
 696         spin_lock_irqsave(&blkcg->lock, flags);
 697
 698         if (hlist_empty(&blkcg->blkg_list)) {
 699                 spin_unlock_irqrestore(&blkcg->lock, flags);
 700                 goto done;
 701         }
 702
 703         blkg = hlist_entry(blkcg->blkg_list.first, struct blkio_group,
 704                                 blkcg_node);
 705         key = rcu_dereference(blkg->key);
 706         __blkiocg_del_blkio_group(blkg);
 707
 708         spin_unlock_irqrestore(&blkcg->lock, flags);
 709
 710         /*
 711          * This blkio_group is being unlinked as associated cgroup is going
 712          * away. Let all the IO controlling policies know about this event.
 713          *
 714          * Currently this is static call to one io controlling policy. Once
 715          * we have more policies in place, we need some dynamic registration
 716          * of callback function.
 717          */
 718         spin_lock(&blkio_list_lock);
 719         list_for_each_entry(blkiop, &blkio_list, list)
 720                 blkiop->ops.blkio_unlink_group_fn(key, blkg);
 721         spin_unlock(&blkio_list_lock);
 722         goto remove_entry;
 723 done:
 724         free_css_id(&blkio_subsys, &blkcg->css);
 725         rcu_read_unlock();
 726         if (blkcg != &blkio_root_cgroup)
 727                 kfree(blkcg);
 728 }
 729
 730 static struct cgroup_subsys_state *
 731 blkiocg_create(struct cgroup_subsys *subsys, struct cgroup *cgroup)
 732 {
 733         struct blkio_cgroup *blkcg, *parent_blkcg;
 734
 735         if (!cgroup->parent) {
 736                 blkcg = &blkio_root_cgroup;
 737                 goto done;
 738         }
 739
 740         /* Currently we do not support hierarchy deeper than two level (0,1) */
 741         parent_blkcg = cgroup_to_blkio_cgroup(cgroup->parent);
 742         if (css_depth(&parent_blkcg->css) > 0)
 743                 return ERR_PTR(-EINVAL);
 744
 745         blkcg = kzalloc(sizeof(*blkcg), GFP_KERNEL);
 746         if (!blkcg)
 747                 return ERR_PTR(-ENOMEM);
 748
 749         blkcg->weight = BLKIO_WEIGHT_DEFAULT;
 750 done:
 751         spin_lock_init(&blkcg->lock);
 752         INIT_HLIST_HEAD(&blkcg->blkg_list);
 753
 754         return &blkcg->css;
 755 }
 756
 757 /*
 758  * We cannot support shared io contexts, as we have no mean to support
 759  * two tasks with the same ioc in two different groups without major rework
 760  * of the main cic data structures.  For now we allow a task to change
 761  * its cgroup only if it's the only owner of its ioc.
 762  */
 763 static int blkiocg_can_attach(struct cgroup_subsys *subsys,
 764                                 struct cgroup *cgroup, struct task_struct *tsk,
 765                                 bool threadgroup)
 766 {
 767         struct io_context *ioc;
 768         int ret = 0;
 769
 770         /* task_lock() is needed to avoid races with exit_io_context() */
 771         task_lock(tsk);
 772         ioc = tsk->io_context;
 773         if (ioc && atomic_read(&ioc->nr_tasks) > 1)
 774                 ret = -EINVAL;
 775         task_unlock(tsk);
 776
 777         return ret;
 778 }
 779
 780 static void blkiocg_attach(struct cgroup_subsys *subsys, struct cgroup *cgroup,
 781                                 struct cgroup *prev, struct task_struct *tsk,
 782                                 bool threadgroup)
 783 {
 784         struct io_context *ioc;
 785
 786         task_lock(tsk);
 787         ioc = tsk->io_context;
 788         if (ioc)
 789                 ioc->cgroup_changed = 1;
 790         task_unlock(tsk);
 791 }
 792
 793 void blkio_policy_register(struct blkio_policy_type *blkiop)
 794 {
 795         spin_lock(&blkio_list_lock);
 796         list_add_tail(&blkiop->list, &blkio_list);
 797         spin_unlock(&blkio_list_lock);
 798 }
 799 EXPORT_SYMBOL_GPL(blkio_policy_register);
 800
 801 void blkio_policy_unregister(struct blkio_policy_type *blkiop)
 802 {
 803         spin_lock(&blkio_list_lock);
 804         list_del_init(&blkiop->list);
 805         spin_unlock(&blkio_list_lock);
 806 }
 807 EXPORT_SYMBOL_GPL(blkio_policy_unregister);
 808
 809 static int __init init_cgroup_blkio(void)
 810 {
 811         return cgroup_load_subsys(&blkio_subsys);
 812 }
 813
 814 static void __exit exit_cgroup_blkio(void)
 815 {
 816         cgroup_unload_subsys(&blkio_subsys);
 817 }
 818
 819 module_init(init_cgroup_blkio);
 820 module_exit(exit_cgroup_blkio);
 821 MODULE_LICENSE("GPL");