blkcg: change blkg reference counting to use percpu_ref
[sfrench/cifs-2.6.git] / 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 <linux/tracehook.h>
31 #include "blk.h"
32
33 #define MAX_KEY_LEN 100
34
35 /*
36  * blkcg_pol_mutex protects blkcg_policy[] and policy [de]activation.
37  * blkcg_pol_register_mutex nests outside of it and synchronizes entire
38  * policy [un]register operations including cgroup file additions /
39  * removals.  Putting cgroup file registration outside blkcg_pol_mutex
40  * allows grabbing it from cgroup callbacks.
41  */
42 static DEFINE_MUTEX(blkcg_pol_register_mutex);
43 static DEFINE_MUTEX(blkcg_pol_mutex);
44
45 struct blkcg blkcg_root;
46 EXPORT_SYMBOL_GPL(blkcg_root);
47
48 struct cgroup_subsys_state * const blkcg_root_css = &blkcg_root.css;
49
50 static struct blkcg_policy *blkcg_policy[BLKCG_MAX_POLS];
51
52 static LIST_HEAD(all_blkcgs);           /* protected by blkcg_pol_mutex */
53
54 static bool blkcg_debug_stats = false;
55
56 static bool blkcg_policy_enabled(struct request_queue *q,
57                                  const struct blkcg_policy *pol)
58 {
59         return pol && test_bit(pol->plid, q->blkcg_pols);
60 }
61
62 /**
63  * blkg_free - free a blkg
64  * @blkg: blkg to free
65  *
66  * Free @blkg which may be partially allocated.
67  */
68 static void blkg_free(struct blkcg_gq *blkg)
69 {
70         int i;
71
72         if (!blkg)
73                 return;
74
75         for (i = 0; i < BLKCG_MAX_POLS; i++)
76                 if (blkg->pd[i])
77                         blkcg_policy[i]->pd_free_fn(blkg->pd[i]);
78
79         blkg_rwstat_exit(&blkg->stat_ios);
80         blkg_rwstat_exit(&blkg->stat_bytes);
81         kfree(blkg);
82 }
83
84 static void __blkg_release(struct rcu_head *rcu)
85 {
86         struct blkcg_gq *blkg = container_of(rcu, struct blkcg_gq, rcu_head);
87
88         percpu_ref_exit(&blkg->refcnt);
89
90         /* release the blkcg and parent blkg refs this blkg has been holding */
91         css_put(&blkg->blkcg->css);
92         if (blkg->parent)
93                 blkg_put(blkg->parent);
94
95         wb_congested_put(blkg->wb_congested);
96
97         blkg_free(blkg);
98 }
99
100 /*
101  * A group is RCU protected, but having an rcu lock does not mean that one
102  * can access all the fields of blkg and assume these are valid.  For
103  * example, don't try to follow throtl_data and request queue links.
104  *
105  * Having a reference to blkg under an rcu allows accesses to only values
106  * local to groups like group stats and group rate limits.
107  */
108 static void blkg_release(struct percpu_ref *ref)
109 {
110         struct blkcg_gq *blkg = container_of(ref, struct blkcg_gq, refcnt);
111
112         call_rcu(&blkg->rcu_head, __blkg_release);
113 }
114
115 /**
116  * blkg_alloc - allocate a blkg
117  * @blkcg: block cgroup the new blkg is associated with
118  * @q: request_queue the new blkg is associated with
119  * @gfp_mask: allocation mask to use
120  *
121  * Allocate a new blkg assocating @blkcg and @q.
122  */
123 static struct blkcg_gq *blkg_alloc(struct blkcg *blkcg, struct request_queue *q,
124                                    gfp_t gfp_mask)
125 {
126         struct blkcg_gq *blkg;
127         int i;
128
129         /* alloc and init base part */
130         blkg = kzalloc_node(sizeof(*blkg), gfp_mask, q->node);
131         if (!blkg)
132                 return NULL;
133
134         if (blkg_rwstat_init(&blkg->stat_bytes, gfp_mask) ||
135             blkg_rwstat_init(&blkg->stat_ios, gfp_mask))
136                 goto err_free;
137
138         blkg->q = q;
139         INIT_LIST_HEAD(&blkg->q_node);
140         blkg->blkcg = blkcg;
141
142         for (i = 0; i < BLKCG_MAX_POLS; i++) {
143                 struct blkcg_policy *pol = blkcg_policy[i];
144                 struct blkg_policy_data *pd;
145
146                 if (!blkcg_policy_enabled(q, pol))
147                         continue;
148
149                 /* alloc per-policy data and attach it to blkg */
150                 pd = pol->pd_alloc_fn(gfp_mask, q->node);
151                 if (!pd)
152                         goto err_free;
153
154                 blkg->pd[i] = pd;
155                 pd->blkg = blkg;
156                 pd->plid = i;
157         }
158
159         return blkg;
160
161 err_free:
162         blkg_free(blkg);
163         return NULL;
164 }
165
166 struct blkcg_gq *blkg_lookup_slowpath(struct blkcg *blkcg,
167                                       struct request_queue *q, bool update_hint)
168 {
169         struct blkcg_gq *blkg;
170
171         /*
172          * Hint didn't match.  Look up from the radix tree.  Note that the
173          * hint can only be updated under queue_lock as otherwise @blkg
174          * could have already been removed from blkg_tree.  The caller is
175          * responsible for grabbing queue_lock if @update_hint.
176          */
177         blkg = radix_tree_lookup(&blkcg->blkg_tree, q->id);
178         if (blkg && blkg->q == q) {
179                 if (update_hint) {
180                         lockdep_assert_held(&q->queue_lock);
181                         rcu_assign_pointer(blkcg->blkg_hint, blkg);
182                 }
183                 return blkg;
184         }
185
186         return NULL;
187 }
188 EXPORT_SYMBOL_GPL(blkg_lookup_slowpath);
189
190 /*
191  * If @new_blkg is %NULL, this function tries to allocate a new one as
192  * necessary using %GFP_NOWAIT.  @new_blkg is always consumed on return.
193  */
194 static struct blkcg_gq *blkg_create(struct blkcg *blkcg,
195                                     struct request_queue *q,
196                                     struct blkcg_gq *new_blkg)
197 {
198         struct blkcg_gq *blkg;
199         struct bdi_writeback_congested *wb_congested;
200         int i, ret;
201
202         WARN_ON_ONCE(!rcu_read_lock_held());
203         lockdep_assert_held(&q->queue_lock);
204
205         /* blkg holds a reference to blkcg */
206         if (!css_tryget_online(&blkcg->css)) {
207                 ret = -ENODEV;
208                 goto err_free_blkg;
209         }
210
211         wb_congested = wb_congested_get_create(q->backing_dev_info,
212                                                blkcg->css.id,
213                                                GFP_NOWAIT | __GFP_NOWARN);
214         if (!wb_congested) {
215                 ret = -ENOMEM;
216                 goto err_put_css;
217         }
218
219         /* allocate */
220         if (!new_blkg) {
221                 new_blkg = blkg_alloc(blkcg, q, GFP_NOWAIT | __GFP_NOWARN);
222                 if (unlikely(!new_blkg)) {
223                         ret = -ENOMEM;
224                         goto err_put_congested;
225                 }
226         }
227         blkg = new_blkg;
228         blkg->wb_congested = wb_congested;
229
230         /* link parent */
231         if (blkcg_parent(blkcg)) {
232                 blkg->parent = __blkg_lookup(blkcg_parent(blkcg), q, false);
233                 if (WARN_ON_ONCE(!blkg->parent)) {
234                         ret = -ENODEV;
235                         goto err_put_congested;
236                 }
237                 blkg_get(blkg->parent);
238         }
239
240         ret = percpu_ref_init(&blkg->refcnt, blkg_release, 0,
241                               GFP_NOWAIT | __GFP_NOWARN);
242         if (ret)
243                 goto err_cancel_ref;
244
245         /* invoke per-policy init */
246         for (i = 0; i < BLKCG_MAX_POLS; i++) {
247                 struct blkcg_policy *pol = blkcg_policy[i];
248
249                 if (blkg->pd[i] && pol->pd_init_fn)
250                         pol->pd_init_fn(blkg->pd[i]);
251         }
252
253         /* insert */
254         spin_lock(&blkcg->lock);
255         ret = radix_tree_insert(&blkcg->blkg_tree, q->id, blkg);
256         if (likely(!ret)) {
257                 hlist_add_head_rcu(&blkg->blkcg_node, &blkcg->blkg_list);
258                 list_add(&blkg->q_node, &q->blkg_list);
259
260                 for (i = 0; i < BLKCG_MAX_POLS; i++) {
261                         struct blkcg_policy *pol = blkcg_policy[i];
262
263                         if (blkg->pd[i] && pol->pd_online_fn)
264                                 pol->pd_online_fn(blkg->pd[i]);
265                 }
266         }
267         blkg->online = true;
268         spin_unlock(&blkcg->lock);
269
270         if (!ret)
271                 return blkg;
272
273         /* @blkg failed fully initialized, use the usual release path */
274         blkg_put(blkg);
275         return ERR_PTR(ret);
276
277 err_cancel_ref:
278         percpu_ref_exit(&blkg->refcnt);
279 err_put_congested:
280         wb_congested_put(wb_congested);
281 err_put_css:
282         css_put(&blkcg->css);
283 err_free_blkg:
284         blkg_free(new_blkg);
285         return ERR_PTR(ret);
286 }
287
288 /**
289  * __blkg_lookup_create - lookup blkg, try to create one if not there
290  * @blkcg: blkcg of interest
291  * @q: request_queue of interest
292  *
293  * Lookup blkg for the @blkcg - @q pair.  If it doesn't exist, try to
294  * create one.  blkg creation is performed recursively from blkcg_root such
295  * that all non-root blkg's have access to the parent blkg.  This function
296  * should be called under RCU read lock and @q->queue_lock.
297  *
298  * Returns the blkg or the closest blkg if blkg_create() fails as it walks
299  * down from root.
300  */
301 struct blkcg_gq *__blkg_lookup_create(struct blkcg *blkcg,
302                                       struct request_queue *q)
303 {
304         struct blkcg_gq *blkg;
305
306         WARN_ON_ONCE(!rcu_read_lock_held());
307         lockdep_assert_held(&q->queue_lock);
308
309         blkg = __blkg_lookup(blkcg, q, true);
310         if (blkg)
311                 return blkg;
312
313         /*
314          * Create blkgs walking down from blkcg_root to @blkcg, so that all
315          * non-root blkgs have access to their parents.  Returns the closest
316          * blkg to the intended blkg should blkg_create() fail.
317          */
318         while (true) {
319                 struct blkcg *pos = blkcg;
320                 struct blkcg *parent = blkcg_parent(blkcg);
321                 struct blkcg_gq *ret_blkg = q->root_blkg;
322
323                 while (parent) {
324                         blkg = __blkg_lookup(parent, q, false);
325                         if (blkg) {
326                                 /* remember closest blkg */
327                                 ret_blkg = blkg;
328                                 break;
329                         }
330                         pos = parent;
331                         parent = blkcg_parent(parent);
332                 }
333
334                 blkg = blkg_create(pos, q, NULL);
335                 if (IS_ERR(blkg))
336                         return ret_blkg;
337                 if (pos == blkcg)
338                         return blkg;
339         }
340 }
341
342 /**
343  * blkg_lookup_create - find or create a blkg
344  * @blkcg: target block cgroup
345  * @q: target request_queue
346  *
347  * This looks up or creates the blkg representing the unique pair
348  * of the blkcg and the request_queue.
349  */
350 struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
351                                     struct request_queue *q)
352 {
353         struct blkcg_gq *blkg = blkg_lookup(blkcg, q);
354
355         if (unlikely(!blkg)) {
356                 spin_lock_irq(&q->queue_lock);
357                 blkg = __blkg_lookup_create(blkcg, q);
358                 spin_unlock_irq(&q->queue_lock);
359         }
360
361         return blkg;
362 }
363
364 static void blkg_destroy(struct blkcg_gq *blkg)
365 {
366         struct blkcg *blkcg = blkg->blkcg;
367         struct blkcg_gq *parent = blkg->parent;
368         int i;
369
370         lockdep_assert_held(&blkg->q->queue_lock);
371         lockdep_assert_held(&blkcg->lock);
372
373         /* Something wrong if we are trying to remove same group twice */
374         WARN_ON_ONCE(list_empty(&blkg->q_node));
375         WARN_ON_ONCE(hlist_unhashed(&blkg->blkcg_node));
376
377         for (i = 0; i < BLKCG_MAX_POLS; i++) {
378                 struct blkcg_policy *pol = blkcg_policy[i];
379
380                 if (blkg->pd[i] && pol->pd_offline_fn)
381                         pol->pd_offline_fn(blkg->pd[i]);
382         }
383
384         if (parent) {
385                 blkg_rwstat_add_aux(&parent->stat_bytes, &blkg->stat_bytes);
386                 blkg_rwstat_add_aux(&parent->stat_ios, &blkg->stat_ios);
387         }
388
389         blkg->online = false;
390
391         radix_tree_delete(&blkcg->blkg_tree, blkg->q->id);
392         list_del_init(&blkg->q_node);
393         hlist_del_init_rcu(&blkg->blkcg_node);
394
395         /*
396          * Both setting lookup hint to and clearing it from @blkg are done
397          * under queue_lock.  If it's not pointing to @blkg now, it never
398          * will.  Hint assignment itself can race safely.
399          */
400         if (rcu_access_pointer(blkcg->blkg_hint) == blkg)
401                 rcu_assign_pointer(blkcg->blkg_hint, NULL);
402
403         /*
404          * Put the reference taken at the time of creation so that when all
405          * queues are gone, group can be destroyed.
406          */
407         percpu_ref_kill(&blkg->refcnt);
408 }
409
410 /**
411  * blkg_destroy_all - destroy all blkgs associated with a request_queue
412  * @q: request_queue of interest
413  *
414  * Destroy all blkgs associated with @q.
415  */
416 static void blkg_destroy_all(struct request_queue *q)
417 {
418         struct blkcg_gq *blkg, *n;
419
420         spin_lock_irq(&q->queue_lock);
421         list_for_each_entry_safe(blkg, n, &q->blkg_list, q_node) {
422                 struct blkcg *blkcg = blkg->blkcg;
423
424                 spin_lock(&blkcg->lock);
425                 blkg_destroy(blkg);
426                 spin_unlock(&blkcg->lock);
427         }
428
429         q->root_blkg = NULL;
430         spin_unlock_irq(&q->queue_lock);
431 }
432
433 /*
434  * A group is RCU protected, but having an rcu lock does not mean that one
435  * can access all the fields of blkg and assume these are valid.  For
436  * example, don't try to follow throtl_data and request queue links.
437  *
438  * Having a reference to blkg under an rcu allows accesses to only values
439  * local to groups like group stats and group rate limits.
440  */
441 void __blkg_release_rcu(struct rcu_head *rcu_head)
442 {
443         struct blkcg_gq *blkg = container_of(rcu_head, struct blkcg_gq, rcu_head);
444
445         /* release the blkcg and parent blkg refs this blkg has been holding */
446         css_put(&blkg->blkcg->css);
447         if (blkg->parent)
448                 blkg_put(blkg->parent);
449
450         wb_congested_put(blkg->wb_congested);
451
452         blkg_free(blkg);
453 }
454 EXPORT_SYMBOL_GPL(__blkg_release_rcu);
455
456 static int blkcg_reset_stats(struct cgroup_subsys_state *css,
457                              struct cftype *cftype, u64 val)
458 {
459         struct blkcg *blkcg = css_to_blkcg(css);
460         struct blkcg_gq *blkg;
461         int i;
462
463         mutex_lock(&blkcg_pol_mutex);
464         spin_lock_irq(&blkcg->lock);
465
466         /*
467          * Note that stat reset is racy - it doesn't synchronize against
468          * stat updates.  This is a debug feature which shouldn't exist
469          * anyway.  If you get hit by a race, retry.
470          */
471         hlist_for_each_entry(blkg, &blkcg->blkg_list, blkcg_node) {
472                 blkg_rwstat_reset(&blkg->stat_bytes);
473                 blkg_rwstat_reset(&blkg->stat_ios);
474
475                 for (i = 0; i < BLKCG_MAX_POLS; i++) {
476                         struct blkcg_policy *pol = blkcg_policy[i];
477
478                         if (blkg->pd[i] && pol->pd_reset_stats_fn)
479                                 pol->pd_reset_stats_fn(blkg->pd[i]);
480                 }
481         }
482
483         spin_unlock_irq(&blkcg->lock);
484         mutex_unlock(&blkcg_pol_mutex);
485         return 0;
486 }
487
488 const char *blkg_dev_name(struct blkcg_gq *blkg)
489 {
490         /* some drivers (floppy) instantiate a queue w/o disk registered */
491         if (blkg->q->backing_dev_info->dev)
492                 return dev_name(blkg->q->backing_dev_info->dev);
493         return NULL;
494 }
495
496 /**
497  * blkcg_print_blkgs - helper for printing per-blkg data
498  * @sf: seq_file to print to
499  * @blkcg: blkcg of interest
500  * @prfill: fill function to print out a blkg
501  * @pol: policy in question
502  * @data: data to be passed to @prfill
503  * @show_total: to print out sum of prfill return values or not
504  *
505  * This function invokes @prfill on each blkg of @blkcg if pd for the
506  * policy specified by @pol exists.  @prfill is invoked with @sf, the
507  * policy data and @data and the matching queue lock held.  If @show_total
508  * is %true, the sum of the return values from @prfill is printed with
509  * "Total" label at the end.
510  *
511  * This is to be used to construct print functions for
512  * cftype->read_seq_string method.
513  */
514 void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
515                        u64 (*prfill)(struct seq_file *,
516                                      struct blkg_policy_data *, int),
517                        const struct blkcg_policy *pol, int data,
518                        bool show_total)
519 {
520         struct blkcg_gq *blkg;
521         u64 total = 0;
522
523         rcu_read_lock();
524         hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
525                 spin_lock_irq(&blkg->q->queue_lock);
526                 if (blkcg_policy_enabled(blkg->q, pol))
527                         total += prfill(sf, blkg->pd[pol->plid], data);
528                 spin_unlock_irq(&blkg->q->queue_lock);
529         }
530         rcu_read_unlock();
531
532         if (show_total)
533                 seq_printf(sf, "Total %llu\n", (unsigned long long)total);
534 }
535 EXPORT_SYMBOL_GPL(blkcg_print_blkgs);
536
537 /**
538  * __blkg_prfill_u64 - prfill helper for a single u64 value
539  * @sf: seq_file to print to
540  * @pd: policy private data of interest
541  * @v: value to print
542  *
543  * Print @v to @sf for the device assocaited with @pd.
544  */
545 u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v)
546 {
547         const char *dname = blkg_dev_name(pd->blkg);
548
549         if (!dname)
550                 return 0;
551
552         seq_printf(sf, "%s %llu\n", dname, (unsigned long long)v);
553         return v;
554 }
555 EXPORT_SYMBOL_GPL(__blkg_prfill_u64);
556
557 /**
558  * __blkg_prfill_rwstat - prfill helper for a blkg_rwstat
559  * @sf: seq_file to print to
560  * @pd: policy private data of interest
561  * @rwstat: rwstat to print
562  *
563  * Print @rwstat to @sf for the device assocaited with @pd.
564  */
565 u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
566                          const struct blkg_rwstat *rwstat)
567 {
568         static const char *rwstr[] = {
569                 [BLKG_RWSTAT_READ]      = "Read",
570                 [BLKG_RWSTAT_WRITE]     = "Write",
571                 [BLKG_RWSTAT_SYNC]      = "Sync",
572                 [BLKG_RWSTAT_ASYNC]     = "Async",
573                 [BLKG_RWSTAT_DISCARD]   = "Discard",
574         };
575         const char *dname = blkg_dev_name(pd->blkg);
576         u64 v;
577         int i;
578
579         if (!dname)
580                 return 0;
581
582         for (i = 0; i < BLKG_RWSTAT_NR; i++)
583                 seq_printf(sf, "%s %s %llu\n", dname, rwstr[i],
584                            (unsigned long long)atomic64_read(&rwstat->aux_cnt[i]));
585
586         v = atomic64_read(&rwstat->aux_cnt[BLKG_RWSTAT_READ]) +
587                 atomic64_read(&rwstat->aux_cnt[BLKG_RWSTAT_WRITE]) +
588                 atomic64_read(&rwstat->aux_cnt[BLKG_RWSTAT_DISCARD]);
589         seq_printf(sf, "%s Total %llu\n", dname, (unsigned long long)v);
590         return v;
591 }
592 EXPORT_SYMBOL_GPL(__blkg_prfill_rwstat);
593
594 /**
595  * blkg_prfill_stat - prfill callback for blkg_stat
596  * @sf: seq_file to print to
597  * @pd: policy private data of interest
598  * @off: offset to the blkg_stat in @pd
599  *
600  * prfill callback for printing a blkg_stat.
601  */
602 u64 blkg_prfill_stat(struct seq_file *sf, struct blkg_policy_data *pd, int off)
603 {
604         return __blkg_prfill_u64(sf, pd, blkg_stat_read((void *)pd + off));
605 }
606 EXPORT_SYMBOL_GPL(blkg_prfill_stat);
607
608 /**
609  * blkg_prfill_rwstat - prfill callback for blkg_rwstat
610  * @sf: seq_file to print to
611  * @pd: policy private data of interest
612  * @off: offset to the blkg_rwstat in @pd
613  *
614  * prfill callback for printing a blkg_rwstat.
615  */
616 u64 blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
617                        int off)
618 {
619         struct blkg_rwstat rwstat = blkg_rwstat_read((void *)pd + off);
620
621         return __blkg_prfill_rwstat(sf, pd, &rwstat);
622 }
623 EXPORT_SYMBOL_GPL(blkg_prfill_rwstat);
624
625 static u64 blkg_prfill_rwstat_field(struct seq_file *sf,
626                                     struct blkg_policy_data *pd, int off)
627 {
628         struct blkg_rwstat rwstat = blkg_rwstat_read((void *)pd->blkg + off);
629
630         return __blkg_prfill_rwstat(sf, pd, &rwstat);
631 }
632
633 /**
634  * blkg_print_stat_bytes - seq_show callback for blkg->stat_bytes
635  * @sf: seq_file to print to
636  * @v: unused
637  *
638  * To be used as cftype->seq_show to print blkg->stat_bytes.
639  * cftype->private must be set to the blkcg_policy.
640  */
641 int blkg_print_stat_bytes(struct seq_file *sf, void *v)
642 {
643         blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
644                           blkg_prfill_rwstat_field, (void *)seq_cft(sf)->private,
645                           offsetof(struct blkcg_gq, stat_bytes), true);
646         return 0;
647 }
648 EXPORT_SYMBOL_GPL(blkg_print_stat_bytes);
649
650 /**
651  * blkg_print_stat_bytes - seq_show callback for blkg->stat_ios
652  * @sf: seq_file to print to
653  * @v: unused
654  *
655  * To be used as cftype->seq_show to print blkg->stat_ios.  cftype->private
656  * must be set to the blkcg_policy.
657  */
658 int blkg_print_stat_ios(struct seq_file *sf, void *v)
659 {
660         blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
661                           blkg_prfill_rwstat_field, (void *)seq_cft(sf)->private,
662                           offsetof(struct blkcg_gq, stat_ios), true);
663         return 0;
664 }
665 EXPORT_SYMBOL_GPL(blkg_print_stat_ios);
666
667 static u64 blkg_prfill_rwstat_field_recursive(struct seq_file *sf,
668                                               struct blkg_policy_data *pd,
669                                               int off)
670 {
671         struct blkg_rwstat rwstat = blkg_rwstat_recursive_sum(pd->blkg,
672                                                               NULL, off);
673         return __blkg_prfill_rwstat(sf, pd, &rwstat);
674 }
675
676 /**
677  * blkg_print_stat_bytes_recursive - recursive version of blkg_print_stat_bytes
678  * @sf: seq_file to print to
679  * @v: unused
680  */
681 int blkg_print_stat_bytes_recursive(struct seq_file *sf, void *v)
682 {
683         blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
684                           blkg_prfill_rwstat_field_recursive,
685                           (void *)seq_cft(sf)->private,
686                           offsetof(struct blkcg_gq, stat_bytes), true);
687         return 0;
688 }
689 EXPORT_SYMBOL_GPL(blkg_print_stat_bytes_recursive);
690
691 /**
692  * blkg_print_stat_ios_recursive - recursive version of blkg_print_stat_ios
693  * @sf: seq_file to print to
694  * @v: unused
695  */
696 int blkg_print_stat_ios_recursive(struct seq_file *sf, void *v)
697 {
698         blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
699                           blkg_prfill_rwstat_field_recursive,
700                           (void *)seq_cft(sf)->private,
701                           offsetof(struct blkcg_gq, stat_ios), true);
702         return 0;
703 }
704 EXPORT_SYMBOL_GPL(blkg_print_stat_ios_recursive);
705
706 /**
707  * blkg_stat_recursive_sum - collect hierarchical blkg_stat
708  * @blkg: blkg of interest
709  * @pol: blkcg_policy which contains the blkg_stat
710  * @off: offset to the blkg_stat in blkg_policy_data or @blkg
711  *
712  * Collect the blkg_stat specified by @blkg, @pol and @off and all its
713  * online descendants and their aux counts.  The caller must be holding the
714  * queue lock for online tests.
715  *
716  * If @pol is NULL, blkg_stat is at @off bytes into @blkg; otherwise, it is
717  * at @off bytes into @blkg's blkg_policy_data of the policy.
718  */
719 u64 blkg_stat_recursive_sum(struct blkcg_gq *blkg,
720                             struct blkcg_policy *pol, int off)
721 {
722         struct blkcg_gq *pos_blkg;
723         struct cgroup_subsys_state *pos_css;
724         u64 sum = 0;
725
726         lockdep_assert_held(&blkg->q->queue_lock);
727
728         rcu_read_lock();
729         blkg_for_each_descendant_pre(pos_blkg, pos_css, blkg) {
730                 struct blkg_stat *stat;
731
732                 if (!pos_blkg->online)
733                         continue;
734
735                 if (pol)
736                         stat = (void *)blkg_to_pd(pos_blkg, pol) + off;
737                 else
738                         stat = (void *)blkg + off;
739
740                 sum += blkg_stat_read(stat) + atomic64_read(&stat->aux_cnt);
741         }
742         rcu_read_unlock();
743
744         return sum;
745 }
746 EXPORT_SYMBOL_GPL(blkg_stat_recursive_sum);
747
748 /**
749  * blkg_rwstat_recursive_sum - collect hierarchical blkg_rwstat
750  * @blkg: blkg of interest
751  * @pol: blkcg_policy which contains the blkg_rwstat
752  * @off: offset to the blkg_rwstat in blkg_policy_data or @blkg
753  *
754  * Collect the blkg_rwstat specified by @blkg, @pol and @off and all its
755  * online descendants and their aux counts.  The caller must be holding the
756  * queue lock for online tests.
757  *
758  * If @pol is NULL, blkg_rwstat is at @off bytes into @blkg; otherwise, it
759  * is at @off bytes into @blkg's blkg_policy_data of the policy.
760  */
761 struct blkg_rwstat blkg_rwstat_recursive_sum(struct blkcg_gq *blkg,
762                                              struct blkcg_policy *pol, int off)
763 {
764         struct blkcg_gq *pos_blkg;
765         struct cgroup_subsys_state *pos_css;
766         struct blkg_rwstat sum = { };
767         int i;
768
769         lockdep_assert_held(&blkg->q->queue_lock);
770
771         rcu_read_lock();
772         blkg_for_each_descendant_pre(pos_blkg, pos_css, blkg) {
773                 struct blkg_rwstat *rwstat;
774
775                 if (!pos_blkg->online)
776                         continue;
777
778                 if (pol)
779                         rwstat = (void *)blkg_to_pd(pos_blkg, pol) + off;
780                 else
781                         rwstat = (void *)pos_blkg + off;
782
783                 for (i = 0; i < BLKG_RWSTAT_NR; i++)
784                         atomic64_add(atomic64_read(&rwstat->aux_cnt[i]) +
785                                 percpu_counter_sum_positive(&rwstat->cpu_cnt[i]),
786                                 &sum.aux_cnt[i]);
787         }
788         rcu_read_unlock();
789
790         return sum;
791 }
792 EXPORT_SYMBOL_GPL(blkg_rwstat_recursive_sum);
793
794 /* Performs queue bypass and policy enabled checks then looks up blkg. */
795 static struct blkcg_gq *blkg_lookup_check(struct blkcg *blkcg,
796                                           const struct blkcg_policy *pol,
797                                           struct request_queue *q)
798 {
799         WARN_ON_ONCE(!rcu_read_lock_held());
800         lockdep_assert_held(&q->queue_lock);
801
802         if (!blkcg_policy_enabled(q, pol))
803                 return ERR_PTR(-EOPNOTSUPP);
804         return __blkg_lookup(blkcg, q, true /* update_hint */);
805 }
806
807 /**
808  * blkg_conf_prep - parse and prepare for per-blkg config update
809  * @blkcg: target block cgroup
810  * @pol: target policy
811  * @input: input string
812  * @ctx: blkg_conf_ctx to be filled
813  *
814  * Parse per-blkg config update from @input and initialize @ctx with the
815  * result.  @ctx->blkg points to the blkg to be updated and @ctx->body the
816  * part of @input following MAJ:MIN.  This function returns with RCU read
817  * lock and queue lock held and must be paired with blkg_conf_finish().
818  */
819 int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
820                    char *input, struct blkg_conf_ctx *ctx)
821         __acquires(rcu) __acquires(&disk->queue->queue_lock)
822 {
823         struct gendisk *disk;
824         struct request_queue *q;
825         struct blkcg_gq *blkg;
826         unsigned int major, minor;
827         int key_len, part, ret;
828         char *body;
829
830         if (sscanf(input, "%u:%u%n", &major, &minor, &key_len) != 2)
831                 return -EINVAL;
832
833         body = input + key_len;
834         if (!isspace(*body))
835                 return -EINVAL;
836         body = skip_spaces(body);
837
838         disk = get_gendisk(MKDEV(major, minor), &part);
839         if (!disk)
840                 return -ENODEV;
841         if (part) {
842                 ret = -ENODEV;
843                 goto fail;
844         }
845
846         q = disk->queue;
847
848         rcu_read_lock();
849         spin_lock_irq(&q->queue_lock);
850
851         blkg = blkg_lookup_check(blkcg, pol, q);
852         if (IS_ERR(blkg)) {
853                 ret = PTR_ERR(blkg);
854                 goto fail_unlock;
855         }
856
857         if (blkg)
858                 goto success;
859
860         /*
861          * Create blkgs walking down from blkcg_root to @blkcg, so that all
862          * non-root blkgs have access to their parents.
863          */
864         while (true) {
865                 struct blkcg *pos = blkcg;
866                 struct blkcg *parent;
867                 struct blkcg_gq *new_blkg;
868
869                 parent = blkcg_parent(blkcg);
870                 while (parent && !__blkg_lookup(parent, q, false)) {
871                         pos = parent;
872                         parent = blkcg_parent(parent);
873                 }
874
875                 /* Drop locks to do new blkg allocation with GFP_KERNEL. */
876                 spin_unlock_irq(&q->queue_lock);
877                 rcu_read_unlock();
878
879                 new_blkg = blkg_alloc(pos, q, GFP_KERNEL);
880                 if (unlikely(!new_blkg)) {
881                         ret = -ENOMEM;
882                         goto fail;
883                 }
884
885                 rcu_read_lock();
886                 spin_lock_irq(&q->queue_lock);
887
888                 blkg = blkg_lookup_check(pos, pol, q);
889                 if (IS_ERR(blkg)) {
890                         ret = PTR_ERR(blkg);
891                         goto fail_unlock;
892                 }
893
894                 if (blkg) {
895                         blkg_free(new_blkg);
896                 } else {
897                         blkg = blkg_create(pos, q, new_blkg);
898                         if (unlikely(IS_ERR(blkg))) {
899                                 ret = PTR_ERR(blkg);
900                                 goto fail_unlock;
901                         }
902                 }
903
904                 if (pos == blkcg)
905                         goto success;
906         }
907 success:
908         ctx->disk = disk;
909         ctx->blkg = blkg;
910         ctx->body = body;
911         return 0;
912
913 fail_unlock:
914         spin_unlock_irq(&q->queue_lock);
915         rcu_read_unlock();
916 fail:
917         put_disk_and_module(disk);
918         /*
919          * If queue was bypassing, we should retry.  Do so after a
920          * short msleep().  It isn't strictly necessary but queue
921          * can be bypassing for some time and it's always nice to
922          * avoid busy looping.
923          */
924         if (ret == -EBUSY) {
925                 msleep(10);
926                 ret = restart_syscall();
927         }
928         return ret;
929 }
930
931 /**
932  * blkg_conf_finish - finish up per-blkg config update
933  * @ctx: blkg_conf_ctx intiailized by blkg_conf_prep()
934  *
935  * Finish up after per-blkg config update.  This function must be paired
936  * with blkg_conf_prep().
937  */
938 void blkg_conf_finish(struct blkg_conf_ctx *ctx)
939         __releases(&ctx->disk->queue->queue_lock) __releases(rcu)
940 {
941         spin_unlock_irq(&ctx->disk->queue->queue_lock);
942         rcu_read_unlock();
943         put_disk_and_module(ctx->disk);
944 }
945
946 static int blkcg_print_stat(struct seq_file *sf, void *v)
947 {
948         struct blkcg *blkcg = css_to_blkcg(seq_css(sf));
949         struct blkcg_gq *blkg;
950
951         rcu_read_lock();
952
953         hlist_for_each_entry_rcu(blkg, &blkcg->blkg_list, blkcg_node) {
954                 const char *dname;
955                 char *buf;
956                 struct blkg_rwstat rwstat;
957                 u64 rbytes, wbytes, rios, wios, dbytes, dios;
958                 size_t size = seq_get_buf(sf, &buf), off = 0;
959                 int i;
960                 bool has_stats = false;
961
962                 dname = blkg_dev_name(blkg);
963                 if (!dname)
964                         continue;
965
966                 /*
967                  * Hooray string manipulation, count is the size written NOT
968                  * INCLUDING THE \0, so size is now count+1 less than what we
969                  * had before, but we want to start writing the next bit from
970                  * the \0 so we only add count to buf.
971                  */
972                 off += scnprintf(buf+off, size-off, "%s ", dname);
973
974                 spin_lock_irq(&blkg->q->queue_lock);
975
976                 rwstat = blkg_rwstat_recursive_sum(blkg, NULL,
977                                         offsetof(struct blkcg_gq, stat_bytes));
978                 rbytes = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_READ]);
979                 wbytes = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_WRITE]);
980                 dbytes = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_DISCARD]);
981
982                 rwstat = blkg_rwstat_recursive_sum(blkg, NULL,
983                                         offsetof(struct blkcg_gq, stat_ios));
984                 rios = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_READ]);
985                 wios = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_WRITE]);
986                 dios = atomic64_read(&rwstat.aux_cnt[BLKG_RWSTAT_DISCARD]);
987
988                 spin_unlock_irq(&blkg->q->queue_lock);
989
990                 if (rbytes || wbytes || rios || wios) {
991                         has_stats = true;
992                         off += scnprintf(buf+off, size-off,
993                                          "rbytes=%llu wbytes=%llu rios=%llu wios=%llu dbytes=%llu dios=%llu",
994                                          rbytes, wbytes, rios, wios,
995                                          dbytes, dios);
996                 }
997
998                 if (!blkcg_debug_stats)
999                         goto next;
1000
1001                 if (atomic_read(&blkg->use_delay)) {
1002                         has_stats = true;
1003                         off += scnprintf(buf+off, size-off,
1004                                          " use_delay=%d delay_nsec=%llu",
1005                                          atomic_read(&blkg->use_delay),
1006                                         (unsigned long long)atomic64_read(&blkg->delay_nsec));
1007                 }
1008
1009                 for (i = 0; i < BLKCG_MAX_POLS; i++) {
1010                         struct blkcg_policy *pol = blkcg_policy[i];
1011                         size_t written;
1012
1013                         if (!blkg->pd[i] || !pol->pd_stat_fn)
1014                                 continue;
1015
1016                         written = pol->pd_stat_fn(blkg->pd[i], buf+off, size-off);
1017                         if (written)
1018                                 has_stats = true;
1019                         off += written;
1020                 }
1021 next:
1022                 if (has_stats) {
1023                         off += scnprintf(buf+off, size-off, "\n");
1024                         seq_commit(sf, off);
1025                 }
1026         }
1027
1028         rcu_read_unlock();
1029         return 0;
1030 }
1031
1032 static struct cftype blkcg_files[] = {
1033         {
1034                 .name = "stat",
1035                 .flags = CFTYPE_NOT_ON_ROOT,
1036                 .seq_show = blkcg_print_stat,
1037         },
1038         { }     /* terminate */
1039 };
1040
1041 static struct cftype blkcg_legacy_files[] = {
1042         {
1043                 .name = "reset_stats",
1044                 .write_u64 = blkcg_reset_stats,
1045         },
1046         { }     /* terminate */
1047 };
1048
1049 /*
1050  * blkcg destruction is a three-stage process.
1051  *
1052  * 1. Destruction starts.  The blkcg_css_offline() callback is invoked
1053  *    which offlines writeback.  Here we tie the next stage of blkg destruction
1054  *    to the completion of writeback associated with the blkcg.  This lets us
1055  *    avoid punting potentially large amounts of outstanding writeback to root
1056  *    while maintaining any ongoing policies.  The next stage is triggered when
1057  *    the nr_cgwbs count goes to zero.
1058  *
1059  * 2. When the nr_cgwbs count goes to zero, blkcg_destroy_blkgs() is called
1060  *    and handles the destruction of blkgs.  Here the css reference held by
1061  *    the blkg is put back eventually allowing blkcg_css_free() to be called.
1062  *    This work may occur in cgwb_release_workfn() on the cgwb_release
1063  *    workqueue.  Any submitted ios that fail to get the blkg ref will be
1064  *    punted to the root_blkg.
1065  *
1066  * 3. Once the blkcg ref count goes to zero, blkcg_css_free() is called.
1067  *    This finally frees the blkcg.
1068  */
1069
1070 /**
1071  * blkcg_css_offline - cgroup css_offline callback
1072  * @css: css of interest
1073  *
1074  * This function is called when @css is about to go away.  Here the cgwbs are
1075  * offlined first and only once writeback associated with the blkcg has
1076  * finished do we start step 2 (see above).
1077  */
1078 static void blkcg_css_offline(struct cgroup_subsys_state *css)
1079 {
1080         struct blkcg *blkcg = css_to_blkcg(css);
1081
1082         /* this prevents anyone from attaching or migrating to this blkcg */
1083         wb_blkcg_offline(blkcg);
1084
1085         /* put the base cgwb reference allowing step 2 to be triggered */
1086         blkcg_cgwb_put(blkcg);
1087 }
1088
1089 /**
1090  * blkcg_destroy_blkgs - responsible for shooting down blkgs
1091  * @blkcg: blkcg of interest
1092  *
1093  * blkgs should be removed while holding both q and blkcg locks.  As blkcg lock
1094  * is nested inside q lock, this function performs reverse double lock dancing.
1095  * Destroying the blkgs releases the reference held on the blkcg's css allowing
1096  * blkcg_css_free to eventually be called.
1097  *
1098  * This is the blkcg counterpart of ioc_release_fn().
1099  */
1100 void blkcg_destroy_blkgs(struct blkcg *blkcg)
1101 {
1102         spin_lock_irq(&blkcg->lock);
1103
1104         while (!hlist_empty(&blkcg->blkg_list)) {
1105                 struct blkcg_gq *blkg = hlist_entry(blkcg->blkg_list.first,
1106                                                 struct blkcg_gq, blkcg_node);
1107                 struct request_queue *q = blkg->q;
1108
1109                 if (spin_trylock(&q->queue_lock)) {
1110                         blkg_destroy(blkg);
1111                         spin_unlock(&q->queue_lock);
1112                 } else {
1113                         spin_unlock_irq(&blkcg->lock);
1114                         cpu_relax();
1115                         spin_lock_irq(&blkcg->lock);
1116                 }
1117         }
1118
1119         spin_unlock_irq(&blkcg->lock);
1120 }
1121
1122 static void blkcg_css_free(struct cgroup_subsys_state *css)
1123 {
1124         struct blkcg *blkcg = css_to_blkcg(css);
1125         int i;
1126
1127         mutex_lock(&blkcg_pol_mutex);
1128
1129         list_del(&blkcg->all_blkcgs_node);
1130
1131         for (i = 0; i < BLKCG_MAX_POLS; i++)
1132                 if (blkcg->cpd[i])
1133                         blkcg_policy[i]->cpd_free_fn(blkcg->cpd[i]);
1134
1135         mutex_unlock(&blkcg_pol_mutex);
1136
1137         kfree(blkcg);
1138 }
1139
1140 static struct cgroup_subsys_state *
1141 blkcg_css_alloc(struct cgroup_subsys_state *parent_css)
1142 {
1143         struct blkcg *blkcg;
1144         struct cgroup_subsys_state *ret;
1145         int i;
1146
1147         mutex_lock(&blkcg_pol_mutex);
1148
1149         if (!parent_css) {
1150                 blkcg = &blkcg_root;
1151         } else {
1152                 blkcg = kzalloc(sizeof(*blkcg), GFP_KERNEL);
1153                 if (!blkcg) {
1154                         ret = ERR_PTR(-ENOMEM);
1155                         goto unlock;
1156                 }
1157         }
1158
1159         for (i = 0; i < BLKCG_MAX_POLS ; i++) {
1160                 struct blkcg_policy *pol = blkcg_policy[i];
1161                 struct blkcg_policy_data *cpd;
1162
1163                 /*
1164                  * If the policy hasn't been attached yet, wait for it
1165                  * to be attached before doing anything else. Otherwise,
1166                  * check if the policy requires any specific per-cgroup
1167                  * data: if it does, allocate and initialize it.
1168                  */
1169                 if (!pol || !pol->cpd_alloc_fn)
1170                         continue;
1171
1172                 cpd = pol->cpd_alloc_fn(GFP_KERNEL);
1173                 if (!cpd) {
1174                         ret = ERR_PTR(-ENOMEM);
1175                         goto free_pd_blkcg;
1176                 }
1177                 blkcg->cpd[i] = cpd;
1178                 cpd->blkcg = blkcg;
1179                 cpd->plid = i;
1180                 if (pol->cpd_init_fn)
1181                         pol->cpd_init_fn(cpd);
1182         }
1183
1184         spin_lock_init(&blkcg->lock);
1185         INIT_RADIX_TREE(&blkcg->blkg_tree, GFP_NOWAIT | __GFP_NOWARN);
1186         INIT_HLIST_HEAD(&blkcg->blkg_list);
1187 #ifdef CONFIG_CGROUP_WRITEBACK
1188         INIT_LIST_HEAD(&blkcg->cgwb_list);
1189         refcount_set(&blkcg->cgwb_refcnt, 1);
1190 #endif
1191         list_add_tail(&blkcg->all_blkcgs_node, &all_blkcgs);
1192
1193         mutex_unlock(&blkcg_pol_mutex);
1194         return &blkcg->css;
1195
1196 free_pd_blkcg:
1197         for (i--; i >= 0; i--)
1198                 if (blkcg->cpd[i])
1199                         blkcg_policy[i]->cpd_free_fn(blkcg->cpd[i]);
1200
1201         if (blkcg != &blkcg_root)
1202                 kfree(blkcg);
1203 unlock:
1204         mutex_unlock(&blkcg_pol_mutex);
1205         return ret;
1206 }
1207
1208 /**
1209  * blkcg_init_queue - initialize blkcg part of request queue
1210  * @q: request_queue to initialize
1211  *
1212  * Called from blk_alloc_queue_node(). Responsible for initializing blkcg
1213  * part of new request_queue @q.
1214  *
1215  * RETURNS:
1216  * 0 on success, -errno on failure.
1217  */
1218 int blkcg_init_queue(struct request_queue *q)
1219 {
1220         struct blkcg_gq *new_blkg, *blkg;
1221         bool preloaded;
1222         int ret;
1223
1224         new_blkg = blkg_alloc(&blkcg_root, q, GFP_KERNEL);
1225         if (!new_blkg)
1226                 return -ENOMEM;
1227
1228         preloaded = !radix_tree_preload(GFP_KERNEL);
1229
1230         /* Make sure the root blkg exists. */
1231         rcu_read_lock();
1232         spin_lock_irq(&q->queue_lock);
1233         blkg = blkg_create(&blkcg_root, q, new_blkg);
1234         if (IS_ERR(blkg))
1235                 goto err_unlock;
1236         q->root_blkg = blkg;
1237         spin_unlock_irq(&q->queue_lock);
1238         rcu_read_unlock();
1239
1240         if (preloaded)
1241                 radix_tree_preload_end();
1242
1243         ret = blk_iolatency_init(q);
1244         if (ret)
1245                 goto err_destroy_all;
1246
1247         ret = blk_throtl_init(q);
1248         if (ret)
1249                 goto err_destroy_all;
1250         return 0;
1251
1252 err_destroy_all:
1253         blkg_destroy_all(q);
1254         return ret;
1255 err_unlock:
1256         spin_unlock_irq(&q->queue_lock);
1257         rcu_read_unlock();
1258         if (preloaded)
1259                 radix_tree_preload_end();
1260         return PTR_ERR(blkg);
1261 }
1262
1263 /**
1264  * blkcg_drain_queue - drain blkcg part of request_queue
1265  * @q: request_queue to drain
1266  *
1267  * Called from blk_drain_queue().  Responsible for draining blkcg part.
1268  */
1269 void blkcg_drain_queue(struct request_queue *q)
1270 {
1271         lockdep_assert_held(&q->queue_lock);
1272
1273         /*
1274          * @q could be exiting and already have destroyed all blkgs as
1275          * indicated by NULL root_blkg.  If so, don't confuse policies.
1276          */
1277         if (!q->root_blkg)
1278                 return;
1279
1280         blk_throtl_drain(q);
1281 }
1282
1283 /**
1284  * blkcg_exit_queue - exit and release blkcg part of request_queue
1285  * @q: request_queue being released
1286  *
1287  * Called from blk_release_queue().  Responsible for exiting blkcg part.
1288  */
1289 void blkcg_exit_queue(struct request_queue *q)
1290 {
1291         blkg_destroy_all(q);
1292         blk_throtl_exit(q);
1293 }
1294
1295 /*
1296  * We cannot support shared io contexts, as we have no mean to support
1297  * two tasks with the same ioc in two different groups without major rework
1298  * of the main cic data structures.  For now we allow a task to change
1299  * its cgroup only if it's the only owner of its ioc.
1300  */
1301 static int blkcg_can_attach(struct cgroup_taskset *tset)
1302 {
1303         struct task_struct *task;
1304         struct cgroup_subsys_state *dst_css;
1305         struct io_context *ioc;
1306         int ret = 0;
1307
1308         /* task_lock() is needed to avoid races with exit_io_context() */
1309         cgroup_taskset_for_each(task, dst_css, tset) {
1310                 task_lock(task);
1311                 ioc = task->io_context;
1312                 if (ioc && atomic_read(&ioc->nr_tasks) > 1)
1313                         ret = -EINVAL;
1314                 task_unlock(task);
1315                 if (ret)
1316                         break;
1317         }
1318         return ret;
1319 }
1320
1321 static void blkcg_bind(struct cgroup_subsys_state *root_css)
1322 {
1323         int i;
1324
1325         mutex_lock(&blkcg_pol_mutex);
1326
1327         for (i = 0; i < BLKCG_MAX_POLS; i++) {
1328                 struct blkcg_policy *pol = blkcg_policy[i];
1329                 struct blkcg *blkcg;
1330
1331                 if (!pol || !pol->cpd_bind_fn)
1332                         continue;
1333
1334                 list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node)
1335                         if (blkcg->cpd[pol->plid])
1336                                 pol->cpd_bind_fn(blkcg->cpd[pol->plid]);
1337         }
1338         mutex_unlock(&blkcg_pol_mutex);
1339 }
1340
1341 static void blkcg_exit(struct task_struct *tsk)
1342 {
1343         if (tsk->throttle_queue)
1344                 blk_put_queue(tsk->throttle_queue);
1345         tsk->throttle_queue = NULL;
1346 }
1347
1348 struct cgroup_subsys io_cgrp_subsys = {
1349         .css_alloc = blkcg_css_alloc,
1350         .css_offline = blkcg_css_offline,
1351         .css_free = blkcg_css_free,
1352         .can_attach = blkcg_can_attach,
1353         .bind = blkcg_bind,
1354         .dfl_cftypes = blkcg_files,
1355         .legacy_cftypes = blkcg_legacy_files,
1356         .legacy_name = "blkio",
1357         .exit = blkcg_exit,
1358 #ifdef CONFIG_MEMCG
1359         /*
1360          * This ensures that, if available, memcg is automatically enabled
1361          * together on the default hierarchy so that the owner cgroup can
1362          * be retrieved from writeback pages.
1363          */
1364         .depends_on = 1 << memory_cgrp_id,
1365 #endif
1366 };
1367 EXPORT_SYMBOL_GPL(io_cgrp_subsys);
1368
1369 /**
1370  * blkcg_activate_policy - activate a blkcg policy on a request_queue
1371  * @q: request_queue of interest
1372  * @pol: blkcg policy to activate
1373  *
1374  * Activate @pol on @q.  Requires %GFP_KERNEL context.  @q goes through
1375  * bypass mode to populate its blkgs with policy_data for @pol.
1376  *
1377  * Activation happens with @q bypassed, so nobody would be accessing blkgs
1378  * from IO path.  Update of each blkg is protected by both queue and blkcg
1379  * locks so that holding either lock and testing blkcg_policy_enabled() is
1380  * always enough for dereferencing policy data.
1381  *
1382  * The caller is responsible for synchronizing [de]activations and policy
1383  * [un]registerations.  Returns 0 on success, -errno on failure.
1384  */
1385 int blkcg_activate_policy(struct request_queue *q,
1386                           const struct blkcg_policy *pol)
1387 {
1388         struct blkg_policy_data *pd_prealloc = NULL;
1389         struct blkcg_gq *blkg;
1390         int ret;
1391
1392         if (blkcg_policy_enabled(q, pol))
1393                 return 0;
1394
1395         if (queue_is_mq(q))
1396                 blk_mq_freeze_queue(q);
1397 pd_prealloc:
1398         if (!pd_prealloc) {
1399                 pd_prealloc = pol->pd_alloc_fn(GFP_KERNEL, q->node);
1400                 if (!pd_prealloc) {
1401                         ret = -ENOMEM;
1402                         goto out_bypass_end;
1403                 }
1404         }
1405
1406         spin_lock_irq(&q->queue_lock);
1407
1408         list_for_each_entry(blkg, &q->blkg_list, q_node) {
1409                 struct blkg_policy_data *pd;
1410
1411                 if (blkg->pd[pol->plid])
1412                         continue;
1413
1414                 pd = pol->pd_alloc_fn(GFP_NOWAIT | __GFP_NOWARN, q->node);
1415                 if (!pd)
1416                         swap(pd, pd_prealloc);
1417                 if (!pd) {
1418                         spin_unlock_irq(&q->queue_lock);
1419                         goto pd_prealloc;
1420                 }
1421
1422                 blkg->pd[pol->plid] = pd;
1423                 pd->blkg = blkg;
1424                 pd->plid = pol->plid;
1425                 if (pol->pd_init_fn)
1426                         pol->pd_init_fn(pd);
1427         }
1428
1429         __set_bit(pol->plid, q->blkcg_pols);
1430         ret = 0;
1431
1432         spin_unlock_irq(&q->queue_lock);
1433 out_bypass_end:
1434         if (queue_is_mq(q))
1435                 blk_mq_unfreeze_queue(q);
1436         if (pd_prealloc)
1437                 pol->pd_free_fn(pd_prealloc);
1438         return ret;
1439 }
1440 EXPORT_SYMBOL_GPL(blkcg_activate_policy);
1441
1442 /**
1443  * blkcg_deactivate_policy - deactivate a blkcg policy on a request_queue
1444  * @q: request_queue of interest
1445  * @pol: blkcg policy to deactivate
1446  *
1447  * Deactivate @pol on @q.  Follows the same synchronization rules as
1448  * blkcg_activate_policy().
1449  */
1450 void blkcg_deactivate_policy(struct request_queue *q,
1451                              const struct blkcg_policy *pol)
1452 {
1453         struct blkcg_gq *blkg;
1454
1455         if (!blkcg_policy_enabled(q, pol))
1456                 return;
1457
1458         if (queue_is_mq(q))
1459                 blk_mq_freeze_queue(q);
1460
1461         spin_lock_irq(&q->queue_lock);
1462
1463         __clear_bit(pol->plid, q->blkcg_pols);
1464
1465         list_for_each_entry(blkg, &q->blkg_list, q_node) {
1466                 if (blkg->pd[pol->plid]) {
1467                         if (pol->pd_offline_fn)
1468                                 pol->pd_offline_fn(blkg->pd[pol->plid]);
1469                         pol->pd_free_fn(blkg->pd[pol->plid]);
1470                         blkg->pd[pol->plid] = NULL;
1471                 }
1472         }
1473
1474         spin_unlock_irq(&q->queue_lock);
1475
1476         if (queue_is_mq(q))
1477                 blk_mq_unfreeze_queue(q);
1478 }
1479 EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);
1480
1481 /**
1482  * blkcg_policy_register - register a blkcg policy
1483  * @pol: blkcg policy to register
1484  *
1485  * Register @pol with blkcg core.  Might sleep and @pol may be modified on
1486  * successful registration.  Returns 0 on success and -errno on failure.
1487  */
1488 int blkcg_policy_register(struct blkcg_policy *pol)
1489 {
1490         struct blkcg *blkcg;
1491         int i, ret;
1492
1493         mutex_lock(&blkcg_pol_register_mutex);
1494         mutex_lock(&blkcg_pol_mutex);
1495
1496         /* find an empty slot */
1497         ret = -ENOSPC;
1498         for (i = 0; i < BLKCG_MAX_POLS; i++)
1499                 if (!blkcg_policy[i])
1500                         break;
1501         if (i >= BLKCG_MAX_POLS) {
1502                 pr_warn("blkcg_policy_register: BLKCG_MAX_POLS too small\n");
1503                 goto err_unlock;
1504         }
1505
1506         /* Make sure cpd/pd_alloc_fn and cpd/pd_free_fn in pairs */
1507         if ((!pol->cpd_alloc_fn ^ !pol->cpd_free_fn) ||
1508                 (!pol->pd_alloc_fn ^ !pol->pd_free_fn))
1509                 goto err_unlock;
1510
1511         /* register @pol */
1512         pol->plid = i;
1513         blkcg_policy[pol->plid] = pol;
1514
1515         /* allocate and install cpd's */
1516         if (pol->cpd_alloc_fn) {
1517                 list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
1518                         struct blkcg_policy_data *cpd;
1519
1520                         cpd = pol->cpd_alloc_fn(GFP_KERNEL);
1521                         if (!cpd)
1522                                 goto err_free_cpds;
1523
1524                         blkcg->cpd[pol->plid] = cpd;
1525                         cpd->blkcg = blkcg;
1526                         cpd->plid = pol->plid;
1527                         pol->cpd_init_fn(cpd);
1528                 }
1529         }
1530
1531         mutex_unlock(&blkcg_pol_mutex);
1532
1533         /* everything is in place, add intf files for the new policy */
1534         if (pol->dfl_cftypes)
1535                 WARN_ON(cgroup_add_dfl_cftypes(&io_cgrp_subsys,
1536                                                pol->dfl_cftypes));
1537         if (pol->legacy_cftypes)
1538                 WARN_ON(cgroup_add_legacy_cftypes(&io_cgrp_subsys,
1539                                                   pol->legacy_cftypes));
1540         mutex_unlock(&blkcg_pol_register_mutex);
1541         return 0;
1542
1543 err_free_cpds:
1544         if (pol->cpd_free_fn) {
1545                 list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
1546                         if (blkcg->cpd[pol->plid]) {
1547                                 pol->cpd_free_fn(blkcg->cpd[pol->plid]);
1548                                 blkcg->cpd[pol->plid] = NULL;
1549                         }
1550                 }
1551         }
1552         blkcg_policy[pol->plid] = NULL;
1553 err_unlock:
1554         mutex_unlock(&blkcg_pol_mutex);
1555         mutex_unlock(&blkcg_pol_register_mutex);
1556         return ret;
1557 }
1558 EXPORT_SYMBOL_GPL(blkcg_policy_register);
1559
1560 /**
1561  * blkcg_policy_unregister - unregister a blkcg policy
1562  * @pol: blkcg policy to unregister
1563  *
1564  * Undo blkcg_policy_register(@pol).  Might sleep.
1565  */
1566 void blkcg_policy_unregister(struct blkcg_policy *pol)
1567 {
1568         struct blkcg *blkcg;
1569
1570         mutex_lock(&blkcg_pol_register_mutex);
1571
1572         if (WARN_ON(blkcg_policy[pol->plid] != pol))
1573                 goto out_unlock;
1574
1575         /* kill the intf files first */
1576         if (pol->dfl_cftypes)
1577                 cgroup_rm_cftypes(pol->dfl_cftypes);
1578         if (pol->legacy_cftypes)
1579                 cgroup_rm_cftypes(pol->legacy_cftypes);
1580
1581         /* remove cpds and unregister */
1582         mutex_lock(&blkcg_pol_mutex);
1583
1584         if (pol->cpd_free_fn) {
1585                 list_for_each_entry(blkcg, &all_blkcgs, all_blkcgs_node) {
1586                         if (blkcg->cpd[pol->plid]) {
1587                                 pol->cpd_free_fn(blkcg->cpd[pol->plid]);
1588                                 blkcg->cpd[pol->plid] = NULL;
1589                         }
1590                 }
1591         }
1592         blkcg_policy[pol->plid] = NULL;
1593
1594         mutex_unlock(&blkcg_pol_mutex);
1595 out_unlock:
1596         mutex_unlock(&blkcg_pol_register_mutex);
1597 }
1598 EXPORT_SYMBOL_GPL(blkcg_policy_unregister);
1599
1600 /*
1601  * Scale the accumulated delay based on how long it has been since we updated
1602  * the delay.  We only call this when we are adding delay, in case it's been a
1603  * while since we added delay, and when we are checking to see if we need to
1604  * delay a task, to account for any delays that may have occurred.
1605  */
1606 static void blkcg_scale_delay(struct blkcg_gq *blkg, u64 now)
1607 {
1608         u64 old = atomic64_read(&blkg->delay_start);
1609
1610         /*
1611          * We only want to scale down every second.  The idea here is that we
1612          * want to delay people for min(delay_nsec, NSEC_PER_SEC) in a certain
1613          * time window.  We only want to throttle tasks for recent delay that
1614          * has occurred, in 1 second time windows since that's the maximum
1615          * things can be throttled.  We save the current delay window in
1616          * blkg->last_delay so we know what amount is still left to be charged
1617          * to the blkg from this point onward.  blkg->last_use keeps track of
1618          * the use_delay counter.  The idea is if we're unthrottling the blkg we
1619          * are ok with whatever is happening now, and we can take away more of
1620          * the accumulated delay as we've already throttled enough that
1621          * everybody is happy with their IO latencies.
1622          */
1623         if (time_before64(old + NSEC_PER_SEC, now) &&
1624             atomic64_cmpxchg(&blkg->delay_start, old, now) == old) {
1625                 u64 cur = atomic64_read(&blkg->delay_nsec);
1626                 u64 sub = min_t(u64, blkg->last_delay, now - old);
1627                 int cur_use = atomic_read(&blkg->use_delay);
1628
1629                 /*
1630                  * We've been unthrottled, subtract a larger chunk of our
1631                  * accumulated delay.
1632                  */
1633                 if (cur_use < blkg->last_use)
1634                         sub = max_t(u64, sub, blkg->last_delay >> 1);
1635
1636                 /*
1637                  * This shouldn't happen, but handle it anyway.  Our delay_nsec
1638                  * should only ever be growing except here where we subtract out
1639                  * min(last_delay, 1 second), but lord knows bugs happen and I'd
1640                  * rather not end up with negative numbers.
1641                  */
1642                 if (unlikely(cur < sub)) {
1643                         atomic64_set(&blkg->delay_nsec, 0);
1644                         blkg->last_delay = 0;
1645                 } else {
1646                         atomic64_sub(sub, &blkg->delay_nsec);
1647                         blkg->last_delay = cur - sub;
1648                 }
1649                 blkg->last_use = cur_use;
1650         }
1651 }
1652
1653 /*
1654  * This is called when we want to actually walk up the hierarchy and check to
1655  * see if we need to throttle, and then actually throttle if there is some
1656  * accumulated delay.  This should only be called upon return to user space so
1657  * we're not holding some lock that would induce a priority inversion.
1658  */
1659 static void blkcg_maybe_throttle_blkg(struct blkcg_gq *blkg, bool use_memdelay)
1660 {
1661         u64 now = ktime_to_ns(ktime_get());
1662         u64 exp;
1663         u64 delay_nsec = 0;
1664         int tok;
1665
1666         while (blkg->parent) {
1667                 if (atomic_read(&blkg->use_delay)) {
1668                         blkcg_scale_delay(blkg, now);
1669                         delay_nsec = max_t(u64, delay_nsec,
1670                                            atomic64_read(&blkg->delay_nsec));
1671                 }
1672                 blkg = blkg->parent;
1673         }
1674
1675         if (!delay_nsec)
1676                 return;
1677
1678         /*
1679          * Let's not sleep for all eternity if we've amassed a huge delay.
1680          * Swapping or metadata IO can accumulate 10's of seconds worth of
1681          * delay, and we want userspace to be able to do _something_ so cap the
1682          * delays at 1 second.  If there's 10's of seconds worth of delay then
1683          * the tasks will be delayed for 1 second for every syscall.
1684          */
1685         delay_nsec = min_t(u64, delay_nsec, 250 * NSEC_PER_MSEC);
1686
1687         /*
1688          * TODO: the use_memdelay flag is going to be for the upcoming psi stuff
1689          * that hasn't landed upstream yet.  Once that stuff is in place we need
1690          * to do a psi_memstall_enter/leave if memdelay is set.
1691          */
1692
1693         exp = ktime_add_ns(now, delay_nsec);
1694         tok = io_schedule_prepare();
1695         do {
1696                 __set_current_state(TASK_KILLABLE);
1697                 if (!schedule_hrtimeout(&exp, HRTIMER_MODE_ABS))
1698                         break;
1699         } while (!fatal_signal_pending(current));
1700         io_schedule_finish(tok);
1701 }
1702
1703 /**
1704  * blkcg_maybe_throttle_current - throttle the current task if it has been marked
1705  *
1706  * This is only called if we've been marked with set_notify_resume().  Obviously
1707  * we can be set_notify_resume() for reasons other than blkcg throttling, so we
1708  * check to see if current->throttle_queue is set and if not this doesn't do
1709  * anything.  This should only ever be called by the resume code, it's not meant
1710  * to be called by people willy-nilly as it will actually do the work to
1711  * throttle the task if it is setup for throttling.
1712  */
1713 void blkcg_maybe_throttle_current(void)
1714 {
1715         struct request_queue *q = current->throttle_queue;
1716         struct cgroup_subsys_state *css;
1717         struct blkcg *blkcg;
1718         struct blkcg_gq *blkg;
1719         bool use_memdelay = current->use_memdelay;
1720
1721         if (!q)
1722                 return;
1723
1724         current->throttle_queue = NULL;
1725         current->use_memdelay = false;
1726
1727         rcu_read_lock();
1728         css = kthread_blkcg();
1729         if (css)
1730                 blkcg = css_to_blkcg(css);
1731         else
1732                 blkcg = css_to_blkcg(task_css(current, io_cgrp_id));
1733
1734         if (!blkcg)
1735                 goto out;
1736         blkg = blkg_lookup(blkcg, q);
1737         if (!blkg)
1738                 goto out;
1739         blkg = blkg_try_get(blkg);
1740         if (!blkg)
1741                 goto out;
1742         rcu_read_unlock();
1743
1744         blkcg_maybe_throttle_blkg(blkg, use_memdelay);
1745         blkg_put(blkg);
1746         blk_put_queue(q);
1747         return;
1748 out:
1749         rcu_read_unlock();
1750         blk_put_queue(q);
1751 }
1752
1753 /**
1754  * blkcg_schedule_throttle - this task needs to check for throttling
1755  * @q - the request queue IO was submitted on
1756  * @use_memdelay - do we charge this to memory delay for PSI
1757  *
1758  * This is called by the IO controller when we know there's delay accumulated
1759  * for the blkg for this task.  We do not pass the blkg because there are places
1760  * we call this that may not have that information, the swapping code for
1761  * instance will only have a request_queue at that point.  This set's the
1762  * notify_resume for the task to check and see if it requires throttling before
1763  * returning to user space.
1764  *
1765  * We will only schedule once per syscall.  You can call this over and over
1766  * again and it will only do the check once upon return to user space, and only
1767  * throttle once.  If the task needs to be throttled again it'll need to be
1768  * re-set at the next time we see the task.
1769  */
1770 void blkcg_schedule_throttle(struct request_queue *q, bool use_memdelay)
1771 {
1772         if (unlikely(current->flags & PF_KTHREAD))
1773                 return;
1774
1775         if (!blk_get_queue(q))
1776                 return;
1777
1778         if (current->throttle_queue)
1779                 blk_put_queue(current->throttle_queue);
1780         current->throttle_queue = q;
1781         if (use_memdelay)
1782                 current->use_memdelay = use_memdelay;
1783         set_notify_resume(current);
1784 }
1785
1786 /**
1787  * blkcg_add_delay - add delay to this blkg
1788  * @now - the current time in nanoseconds
1789  * @delta - how many nanoseconds of delay to add
1790  *
1791  * Charge @delta to the blkg's current delay accumulation.  This is used to
1792  * throttle tasks if an IO controller thinks we need more throttling.
1793  */
1794 void blkcg_add_delay(struct blkcg_gq *blkg, u64 now, u64 delta)
1795 {
1796         blkcg_scale_delay(blkg, now);
1797         atomic64_add(delta, &blkg->delay_nsec);
1798 }
1799
1800 module_param(blkcg_debug_stats, bool, 0644);
1801 MODULE_PARM_DESC(blkcg_debug_stats, "True if you want debug stats, false if not");