block/blk-cgroup.h

   1 #ifndef _BLK_CGROUP_H
   2 #define _BLK_CGROUP_H
   3 /*
   4  * Common Block IO controller cgroup interface
   5  *
   6  * Based on ideas and code from CFQ, CFS and BFQ:
   7  * Copyright (C) 2003 Jens Axboe <axboe@kernel.dk>
   8  *
   9  * Copyright (C) 2008 Fabio Checconi <fabio@gandalf.sssup.it>
  10  *                    Paolo Valente <paolo.valente@unimore.it>
  11  *
  12  * Copyright (C) 2009 Vivek Goyal <vgoyal@redhat.com>
  13  *                    Nauman Rafique <nauman@google.com>
  14  */
  15
  16 #include <linux/cgroup.h>
  17 #include <linux/u64_stats_sync.h>
  18 #include <linux/seq_file.h>
  19 #include <linux/radix-tree.h>
  20
  21 /* Max limits for throttle policy */
  22 #define THROTL_IOPS_MAX         UINT_MAX
  23
  24 /* CFQ specific, out here for blkcg->cfq_weight */
  25 #define CFQ_WEIGHT_MIN          10
  26 #define CFQ_WEIGHT_MAX          1000
  27 #define CFQ_WEIGHT_DEFAULT      500
  28
  29 #ifdef CONFIG_BLK_CGROUP
  30
  31 enum blkg_rwstat_type {
  32         BLKG_RWSTAT_READ,
  33         BLKG_RWSTAT_WRITE,
  34         BLKG_RWSTAT_SYNC,
  35         BLKG_RWSTAT_ASYNC,
  36
  37         BLKG_RWSTAT_NR,
  38         BLKG_RWSTAT_TOTAL = BLKG_RWSTAT_NR,
  39 };
  40
  41 struct blkcg_gq;
  42
  43 struct blkcg {
  44         struct cgroup_subsys_state      css;
  45         spinlock_t                      lock;
  46
  47         struct radix_tree_root          blkg_tree;
  48         struct blkcg_gq                 *blkg_hint;
  49         struct hlist_head               blkg_list;
  50
  51         /* for policies to test whether associated blkcg has changed */
  52         uint64_t                        id;
  53
  54         /* TODO: per-policy storage in blkcg */
  55         unsigned int                    cfq_weight;     /* belongs to cfq */
  56 };
  57
  58 struct blkg_stat {
  59         struct u64_stats_sync           syncp;
  60         uint64_t                        cnt;
  61 };
  62
  63 struct blkg_rwstat {
  64         struct u64_stats_sync           syncp;
  65         uint64_t                        cnt[BLKG_RWSTAT_NR];
  66 };
  67
  68 /*
  69  * A blkcg_gq (blkg) is association between a block cgroup (blkcg) and a
  70  * request_queue (q).  This is used by blkcg policies which need to track
  71  * information per blkcg - q pair.
  72  *
  73  * There can be multiple active blkcg policies and each has its private
  74  * data on each blkg, the size of which is determined by
  75  * blkcg_policy->pd_size.  blkcg core allocates and frees such areas
  76  * together with blkg and invokes pd_init/exit_fn() methods.
  77  *
  78  * Such private data must embed struct blkg_policy_data (pd) at the
  79  * beginning and pd_size can't be smaller than pd.
  80  */
  81 struct blkg_policy_data {
  82         /* the blkg this per-policy data belongs to */
  83         struct blkcg_gq                 *blkg;
  84
  85         /* used during policy activation */
  86         struct list_head                alloc_node;
  87 };
  88
  89 /* association between a blk cgroup and a request queue */
  90 struct blkcg_gq {
  91         /* Pointer to the associated request_queue */
  92         struct request_queue            *q;
  93         struct list_head                q_node;
  94         struct hlist_node               blkcg_node;
  95         struct blkcg                    *blkcg;
  96         /* reference count */
  97         int                             refcnt;
  98
  99         struct blkg_policy_data         *pd[BLKCG_MAX_POLS];
 100
 101         struct rcu_head                 rcu_head;
 102 };
 103
 104 typedef void (blkcg_pol_init_pd_fn)(struct blkcg_gq *blkg);
 105 typedef void (blkcg_pol_exit_pd_fn)(struct blkcg_gq *blkg);
 106 typedef void (blkcg_pol_reset_pd_stats_fn)(struct blkcg_gq *blkg);
 107
 108 struct blkcg_policy {
 109         int                             plid;
 110         /* policy specific private data size */
 111         size_t                          pd_size;
 112         /* cgroup files for the policy */
 113         struct cftype                   *cftypes;
 114
 115         /* operations */
 116         blkcg_pol_init_pd_fn            *pd_init_fn;
 117         blkcg_pol_exit_pd_fn            *pd_exit_fn;
 118         blkcg_pol_reset_pd_stats_fn     *pd_reset_stats_fn;
 119 };
 120
 121 extern struct blkcg blkcg_root;
 122
 123 struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, struct request_queue *q);
 124 struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
 125                                     struct request_queue *q);
 126 int blkcg_init_queue(struct request_queue *q);
 127 void blkcg_drain_queue(struct request_queue *q);
 128 void blkcg_exit_queue(struct request_queue *q);
 129
 130 /* Blkio controller policy registration */
 131 int blkcg_policy_register(struct blkcg_policy *pol);
 132 void blkcg_policy_unregister(struct blkcg_policy *pol);
 133 int blkcg_activate_policy(struct request_queue *q,
 134                           const struct blkcg_policy *pol);
 135 void blkcg_deactivate_policy(struct request_queue *q,
 136                              const struct blkcg_policy *pol);
 137
 138 void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
 139                        u64 (*prfill)(struct seq_file *,
 140                                      struct blkg_policy_data *, int),
 141                        const struct blkcg_policy *pol, int data,
 142                        bool show_total);
 143 u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v);
 144 u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
 145                          const struct blkg_rwstat *rwstat);
 146 u64 blkg_prfill_stat(struct seq_file *sf, struct blkg_policy_data *pd, int off);
 147 u64 blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
 148                        int off);
 149
 150 struct blkg_conf_ctx {
 151         struct gendisk                  *disk;
 152         struct blkcg_gq                 *blkg;
 153         u64                             v;
 154 };
 155
 156 int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
 157                    const char *input, struct blkg_conf_ctx *ctx);
 158 void blkg_conf_finish(struct blkg_conf_ctx *ctx);
 159
 160
 161 static inline struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup)
 162 {
 163         return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),
 164                             struct blkcg, css);
 165 }
 166
 167 static inline struct blkcg *task_blkcg(struct task_struct *tsk)
 168 {
 169         return container_of(task_subsys_state(tsk, blkio_subsys_id),
 170                             struct blkcg, css);
 171 }
 172
 173 static inline struct blkcg *bio_blkcg(struct bio *bio)
 174 {
 175         if (bio && bio->bi_css)
 176                 return container_of(bio->bi_css, struct blkcg, css);
 177         return task_blkcg(current);
 178 }
 179
 180 /**
 181  * blkg_to_pdata - get policy private data
 182  * @blkg: blkg of interest
 183  * @pol: policy of interest
 184  *
 185  * Return pointer to private data associated with the @blkg-@pol pair.
 186  */
 187 static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
 188                                                   struct blkcg_policy *pol)
 189 {
 190         return blkg ? blkg->pd[pol->plid] : NULL;
 191 }
 192
 193 /**
 194  * pdata_to_blkg - get blkg associated with policy private data
 195  * @pd: policy private data of interest
 196  *
 197  * @pd is policy private data.  Determine the blkg it's associated with.
 198  */
 199 static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd)
 200 {
 201         return pd ? pd->blkg : NULL;
 202 }
 203
 204 /**
 205  * blkg_path - format cgroup path of blkg
 206  * @blkg: blkg of interest
 207  * @buf: target buffer
 208  * @buflen: target buffer length
 209  *
 210  * Format the path of the cgroup of @blkg into @buf.
 211  */
 212 static inline int blkg_path(struct blkcg_gq *blkg, char *buf, int buflen)
 213 {
 214         int ret;
 215
 216         rcu_read_lock();
 217         ret = cgroup_path(blkg->blkcg->css.cgroup, buf, buflen);
 218         rcu_read_unlock();
 219         if (ret)
 220                 strncpy(buf, "<unavailable>", buflen);
 221         return ret;
 222 }
 223
 224 /**
 225  * blkg_get - get a blkg reference
 226  * @blkg: blkg to get
 227  *
 228  * The caller should be holding queue_lock and an existing reference.
 229  */
 230 static inline void blkg_get(struct blkcg_gq *blkg)
 231 {
 232         lockdep_assert_held(blkg->q->queue_lock);
 233         WARN_ON_ONCE(!blkg->refcnt);
 234         blkg->refcnt++;
 235 }
 236
 237 void __blkg_release(struct blkcg_gq *blkg);
 238
 239 /**
 240  * blkg_put - put a blkg reference
 241  * @blkg: blkg to put
 242  *
 243  * The caller should be holding queue_lock.
 244  */
 245 static inline void blkg_put(struct blkcg_gq *blkg)
 246 {
 247         lockdep_assert_held(blkg->q->queue_lock);
 248         WARN_ON_ONCE(blkg->refcnt <= 0);
 249         if (!--blkg->refcnt)
 250                 __blkg_release(blkg);
 251 }
 252
 253 /**
 254  * blkg_stat_add - add a value to a blkg_stat
 255  * @stat: target blkg_stat
 256  * @val: value to add
 257  *
 258  * Add @val to @stat.  The caller is responsible for synchronizing calls to
 259  * this function.
 260  */
 261 static inline void blkg_stat_add(struct blkg_stat *stat, uint64_t val)
 262 {
 263         u64_stats_update_begin(&stat->syncp);
 264         stat->cnt += val;
 265         u64_stats_update_end(&stat->syncp);
 266 }
 267
 268 /**
 269  * blkg_stat_read - read the current value of a blkg_stat
 270  * @stat: blkg_stat to read
 271  *
 272  * Read the current value of @stat.  This function can be called without
 273  * synchroniztion and takes care of u64 atomicity.
 274  */
 275 static inline uint64_t blkg_stat_read(struct blkg_stat *stat)
 276 {
 277         unsigned int start;
 278         uint64_t v;
 279
 280         do {
 281                 start = u64_stats_fetch_begin(&stat->syncp);
 282                 v = stat->cnt;
 283         } while (u64_stats_fetch_retry(&stat->syncp, start));
 284
 285         return v;
 286 }
 287
 288 /**
 289  * blkg_stat_reset - reset a blkg_stat
 290  * @stat: blkg_stat to reset
 291  */
 292 static inline void blkg_stat_reset(struct blkg_stat *stat)
 293 {
 294         stat->cnt = 0;
 295 }
 296
 297 /**
 298  * blkg_rwstat_add - add a value to a blkg_rwstat
 299  * @rwstat: target blkg_rwstat
 300  * @rw: mask of REQ_{WRITE|SYNC}
 301  * @val: value to add
 302  *
 303  * Add @val to @rwstat.  The counters are chosen according to @rw.  The
 304  * caller is responsible for synchronizing calls to this function.
 305  */
 306 static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
 307                                    int rw, uint64_t val)
 308 {
 309         u64_stats_update_begin(&rwstat->syncp);
 310
 311         if (rw & REQ_WRITE)
 312                 rwstat->cnt[BLKG_RWSTAT_WRITE] += val;
 313         else
 314                 rwstat->cnt[BLKG_RWSTAT_READ] += val;
 315         if (rw & REQ_SYNC)
 316                 rwstat->cnt[BLKG_RWSTAT_SYNC] += val;
 317         else
 318                 rwstat->cnt[BLKG_RWSTAT_ASYNC] += val;
 319
 320         u64_stats_update_end(&rwstat->syncp);
 321 }
 322
 323 /**
 324  * blkg_rwstat_read - read the current values of a blkg_rwstat
 325  * @rwstat: blkg_rwstat to read
 326  *
 327  * Read the current snapshot of @rwstat and return it as the return value.
 328  * This function can be called without synchronization and takes care of
 329  * u64 atomicity.
 330  */
 331 static inline struct blkg_rwstat blkg_rwstat_read(struct blkg_rwstat *rwstat)
 332 {
 333         unsigned int start;
 334         struct blkg_rwstat tmp;
 335
 336         do {
 337                 start = u64_stats_fetch_begin(&rwstat->syncp);
 338                 tmp = *rwstat;
 339         } while (u64_stats_fetch_retry(&rwstat->syncp, start));
 340
 341         return tmp;
 342 }
 343
 344 /**
 345  * blkg_rwstat_sum - read the total count of a blkg_rwstat
 346  * @rwstat: blkg_rwstat to read
 347  *
 348  * Return the total count of @rwstat regardless of the IO direction.  This
 349  * function can be called without synchronization and takes care of u64
 350  * atomicity.
 351  */
 352 static inline uint64_t blkg_rwstat_sum(struct blkg_rwstat *rwstat)
 353 {
 354         struct blkg_rwstat tmp = blkg_rwstat_read(rwstat);
 355
 356         return tmp.cnt[BLKG_RWSTAT_READ] + tmp.cnt[BLKG_RWSTAT_WRITE];
 357 }
 358
 359 /**
 360  * blkg_rwstat_reset - reset a blkg_rwstat
 361  * @rwstat: blkg_rwstat to reset
 362  */
 363 static inline void blkg_rwstat_reset(struct blkg_rwstat *rwstat)
 364 {
 365         memset(rwstat->cnt, 0, sizeof(rwstat->cnt));
 366 }
 367
 368 #else   /* CONFIG_BLK_CGROUP */
 369
 370 struct cgroup;
 371 struct blkcg;
 372
 373 struct blkg_policy_data {
 374 };
 375
 376 struct blkcg_gq {
 377 };
 378
 379 struct blkcg_policy {
 380 };
 381
 382 static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, void *key) { return NULL; }
 383 static inline int blkcg_init_queue(struct request_queue *q) { return 0; }
 384 static inline void blkcg_drain_queue(struct request_queue *q) { }
 385 static inline void blkcg_exit_queue(struct request_queue *q) { }
 386 static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; }
 387 static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { }
 388 static inline int blkcg_activate_policy(struct request_queue *q,
 389                                         const struct blkcg_policy *pol) { return 0; }
 390 static inline void blkcg_deactivate_policy(struct request_queue *q,
 391                                            const struct blkcg_policy *pol) { }
 392
 393 static inline struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup) { return NULL; }
 394 static inline struct blkcg *bio_blkcg(struct bio *bio) { return NULL; }
 395 static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
 396                                                   struct blkcg_policy *pol) { return NULL; }
 397 static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd) { return NULL; }
 398 static inline char *blkg_path(struct blkcg_gq *blkg) { return NULL; }
 399 static inline void blkg_get(struct blkcg_gq *blkg) { }
 400 static inline void blkg_put(struct blkcg_gq *blkg) { }
 401
 402 #endif  /* CONFIG_BLK_CGROUP */
 403 #endif  /* _BLK_CGROUP_H */