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
  20 enum blkio_policy_id {
  21         BLKIO_POLICY_PROP = 0,          /* Proportional Bandwidth division */
  22         BLKIO_POLICY_THROTL,            /* Throttling */
  23
  24         BLKIO_NR_POLICIES,
  25 };
  26
  27 /* Max limits for throttle policy */
  28 #define THROTL_IOPS_MAX         UINT_MAX
  29
  30 #ifdef CONFIG_BLK_CGROUP
  31
  32 /* CFQ specific, out here for blkcg->cfq_weight */
  33 #define CFQ_WEIGHT_MIN          10
  34 #define CFQ_WEIGHT_MAX          1000
  35 #define CFQ_WEIGHT_DEFAULT      500
  36
  37 /* cft->private [un]packing for stat printing */
  38 #define BLKCG_STAT_PRIV(pol, off)       (((unsigned)(pol) << 16) | (off))
  39 #define BLKCG_STAT_POL(prv)             ((unsigned)(prv) >> 16)
  40 #define BLKCG_STAT_OFF(prv)             ((unsigned)(prv) & 0xffff)
  41
  42 enum blkg_rwstat_type {
  43         BLKG_RWSTAT_READ,
  44         BLKG_RWSTAT_WRITE,
  45         BLKG_RWSTAT_SYNC,
  46         BLKG_RWSTAT_ASYNC,
  47
  48         BLKG_RWSTAT_NR,
  49         BLKG_RWSTAT_TOTAL = BLKG_RWSTAT_NR,
  50 };
  51
  52 struct blkio_cgroup {
  53         struct cgroup_subsys_state css;
  54         spinlock_t lock;
  55         struct hlist_head blkg_list;
  56
  57         /* for policies to test whether associated blkcg has changed */
  58         uint64_t id;
  59
  60         /* TODO: per-policy storage in blkio_cgroup */
  61         unsigned int cfq_weight;        /* belongs to cfq */
  62 };
  63
  64 struct blkg_stat {
  65         struct u64_stats_sync           syncp;
  66         uint64_t                        cnt;
  67 };
  68
  69 struct blkg_rwstat {
  70         struct u64_stats_sync           syncp;
  71         uint64_t                        cnt[BLKG_RWSTAT_NR];
  72 };
  73
  74 struct blkio_group_conf {
  75         u64 iops[2];
  76         u64 bps[2];
  77 };
  78
  79 /* per-blkg per-policy data */
  80 struct blkg_policy_data {
  81         /* the blkg this per-policy data belongs to */
  82         struct blkio_group *blkg;
  83
  84         /* Configuration */
  85         struct blkio_group_conf conf;
  86
  87         /* pol->pdata_size bytes of private data used by policy impl */
  88         char pdata[] __aligned(__alignof__(unsigned long long));
  89 };
  90
  91 struct blkio_group {
  92         /* Pointer to the associated request_queue */
  93         struct request_queue *q;
  94         struct list_head q_node;
  95         struct hlist_node blkcg_node;
  96         struct blkio_cgroup *blkcg;
  97         /* Store cgroup path */
  98         char path[128];
  99         /* reference count */
 100         int refcnt;
 101
 102         struct blkg_policy_data *pd[BLKIO_NR_POLICIES];
 103
 104         struct rcu_head rcu_head;
 105 };
 106
 107 typedef void (blkio_init_group_fn)(struct blkio_group *blkg);
 108 typedef void (blkio_exit_group_fn)(struct blkio_group *blkg);
 109 typedef void (blkio_reset_group_stats_fn)(struct blkio_group *blkg);
 110
 111 struct blkio_policy_ops {
 112         blkio_init_group_fn *blkio_init_group_fn;
 113         blkio_exit_group_fn *blkio_exit_group_fn;
 114         blkio_reset_group_stats_fn *blkio_reset_group_stats_fn;
 115 };
 116
 117 struct blkio_policy_type {
 118         struct list_head list;
 119         struct blkio_policy_ops ops;
 120         enum blkio_policy_id plid;
 121         size_t pdata_size;              /* policy specific private data size */
 122         struct cftype *cftypes;         /* cgroup files for the policy */
 123 };
 124
 125 extern int blkcg_init_queue(struct request_queue *q);
 126 extern void blkcg_drain_queue(struct request_queue *q);
 127 extern void blkcg_exit_queue(struct request_queue *q);
 128
 129 /* Blkio controller policy registration */
 130 extern void blkio_policy_register(struct blkio_policy_type *);
 131 extern void blkio_policy_unregister(struct blkio_policy_type *);
 132 extern void blkg_destroy_all(struct request_queue *q, bool destroy_root);
 133 extern void update_root_blkg_pd(struct request_queue *q,
 134                                 enum blkio_policy_id plid);
 135
 136 void blkcg_print_blkgs(struct seq_file *sf, struct blkio_cgroup *blkcg,
 137                        u64 (*prfill)(struct seq_file *, struct blkg_policy_data *, int),
 138                        int pol, int data, bool show_total);
 139 u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v);
 140 u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
 141                          const struct blkg_rwstat *rwstat);
 142 int blkcg_print_stat(struct cgroup *cgrp, struct cftype *cft,
 143                      struct seq_file *sf);
 144 int blkcg_print_rwstat(struct cgroup *cgrp, struct cftype *cft,
 145                        struct seq_file *sf);
 146
 147 struct blkg_conf_ctx {
 148         struct gendisk          *disk;
 149         struct blkio_group      *blkg;
 150         u64                     v;
 151 };
 152
 153 int blkg_conf_prep(struct blkio_cgroup *blkcg, const char *input,
 154                    struct blkg_conf_ctx *ctx);
 155 void blkg_conf_finish(struct blkg_conf_ctx *ctx);
 156
 157
 158 /**
 159  * blkg_to_pdata - get policy private data
 160  * @blkg: blkg of interest
 161  * @pol: policy of interest
 162  *
 163  * Return pointer to private data associated with the @blkg-@pol pair.
 164  */
 165 static inline void *blkg_to_pdata(struct blkio_group *blkg,
 166                               struct blkio_policy_type *pol)
 167 {
 168         return blkg ? blkg->pd[pol->plid]->pdata : NULL;
 169 }
 170
 171 /**
 172  * pdata_to_blkg - get blkg associated with policy private data
 173  * @pdata: policy private data of interest
 174  *
 175  * @pdata is policy private data.  Determine the blkg it's associated with.
 176  */
 177 static inline struct blkio_group *pdata_to_blkg(void *pdata)
 178 {
 179         if (pdata) {
 180                 struct blkg_policy_data *pd =
 181                         container_of(pdata, struct blkg_policy_data, pdata);
 182                 return pd->blkg;
 183         }
 184         return NULL;
 185 }
 186
 187 static inline char *blkg_path(struct blkio_group *blkg)
 188 {
 189         return blkg->path;
 190 }
 191
 192 /**
 193  * blkg_get - get a blkg reference
 194  * @blkg: blkg to get
 195  *
 196  * The caller should be holding queue_lock and an existing reference.
 197  */
 198 static inline void blkg_get(struct blkio_group *blkg)
 199 {
 200         lockdep_assert_held(blkg->q->queue_lock);
 201         WARN_ON_ONCE(!blkg->refcnt);
 202         blkg->refcnt++;
 203 }
 204
 205 void __blkg_release(struct blkio_group *blkg);
 206
 207 /**
 208  * blkg_put - put a blkg reference
 209  * @blkg: blkg to put
 210  *
 211  * The caller should be holding queue_lock.
 212  */
 213 static inline void blkg_put(struct blkio_group *blkg)
 214 {
 215         lockdep_assert_held(blkg->q->queue_lock);
 216         WARN_ON_ONCE(blkg->refcnt <= 0);
 217         if (!--blkg->refcnt)
 218                 __blkg_release(blkg);
 219 }
 220
 221 /**
 222  * blkg_stat_add - add a value to a blkg_stat
 223  * @stat: target blkg_stat
 224  * @val: value to add
 225  *
 226  * Add @val to @stat.  The caller is responsible for synchronizing calls to
 227  * this function.
 228  */
 229 static inline void blkg_stat_add(struct blkg_stat *stat, uint64_t val)
 230 {
 231         u64_stats_update_begin(&stat->syncp);
 232         stat->cnt += val;
 233         u64_stats_update_end(&stat->syncp);
 234 }
 235
 236 /**
 237  * blkg_stat_read - read the current value of a blkg_stat
 238  * @stat: blkg_stat to read
 239  *
 240  * Read the current value of @stat.  This function can be called without
 241  * synchroniztion and takes care of u64 atomicity.
 242  */
 243 static inline uint64_t blkg_stat_read(struct blkg_stat *stat)
 244 {
 245         unsigned int start;
 246         uint64_t v;
 247
 248         do {
 249                 start = u64_stats_fetch_begin(&stat->syncp);
 250                 v = stat->cnt;
 251         } while (u64_stats_fetch_retry(&stat->syncp, start));
 252
 253         return v;
 254 }
 255
 256 /**
 257  * blkg_stat_reset - reset a blkg_stat
 258  * @stat: blkg_stat to reset
 259  */
 260 static inline void blkg_stat_reset(struct blkg_stat *stat)
 261 {
 262         stat->cnt = 0;
 263 }
 264
 265 /**
 266  * blkg_rwstat_add - add a value to a blkg_rwstat
 267  * @rwstat: target blkg_rwstat
 268  * @rw: mask of REQ_{WRITE|SYNC}
 269  * @val: value to add
 270  *
 271  * Add @val to @rwstat.  The counters are chosen according to @rw.  The
 272  * caller is responsible for synchronizing calls to this function.
 273  */
 274 static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
 275                                    int rw, uint64_t val)
 276 {
 277         u64_stats_update_begin(&rwstat->syncp);
 278
 279         if (rw & REQ_WRITE)
 280                 rwstat->cnt[BLKG_RWSTAT_WRITE] += val;
 281         else
 282                 rwstat->cnt[BLKG_RWSTAT_READ] += val;
 283         if (rw & REQ_SYNC)
 284                 rwstat->cnt[BLKG_RWSTAT_SYNC] += val;
 285         else
 286                 rwstat->cnt[BLKG_RWSTAT_ASYNC] += val;
 287
 288         u64_stats_update_end(&rwstat->syncp);
 289 }
 290
 291 /**
 292  * blkg_rwstat_read - read the current values of a blkg_rwstat
 293  * @rwstat: blkg_rwstat to read
 294  *
 295  * Read the current snapshot of @rwstat and return it as the return value.
 296  * This function can be called without synchronization and takes care of
 297  * u64 atomicity.
 298  */
 299 static struct blkg_rwstat blkg_rwstat_read(struct blkg_rwstat *rwstat)
 300 {
 301         unsigned int start;
 302         struct blkg_rwstat tmp;
 303
 304         do {
 305                 start = u64_stats_fetch_begin(&rwstat->syncp);
 306                 tmp = *rwstat;
 307         } while (u64_stats_fetch_retry(&rwstat->syncp, start));
 308
 309         return tmp;
 310 }
 311
 312 /**
 313  * blkg_rwstat_sum - read the total count of a blkg_rwstat
 314  * @rwstat: blkg_rwstat to read
 315  *
 316  * Return the total count of @rwstat regardless of the IO direction.  This
 317  * function can be called without synchronization and takes care of u64
 318  * atomicity.
 319  */
 320 static inline uint64_t blkg_rwstat_sum(struct blkg_rwstat *rwstat)
 321 {
 322         struct blkg_rwstat tmp = blkg_rwstat_read(rwstat);
 323
 324         return tmp.cnt[BLKG_RWSTAT_READ] + tmp.cnt[BLKG_RWSTAT_WRITE];
 325 }
 326
 327 /**
 328  * blkg_rwstat_reset - reset a blkg_rwstat
 329  * @rwstat: blkg_rwstat to reset
 330  */
 331 static inline void blkg_rwstat_reset(struct blkg_rwstat *rwstat)
 332 {
 333         memset(rwstat->cnt, 0, sizeof(rwstat->cnt));
 334 }
 335
 336 #else
 337
 338 struct blkio_group {
 339 };
 340
 341 struct blkio_policy_type {
 342 };
 343
 344 static inline int blkcg_init_queue(struct request_queue *q) { return 0; }
 345 static inline void blkcg_drain_queue(struct request_queue *q) { }
 346 static inline void blkcg_exit_queue(struct request_queue *q) { }
 347 static inline void blkio_policy_register(struct blkio_policy_type *blkiop) { }
 348 static inline void blkio_policy_unregister(struct blkio_policy_type *blkiop) { }
 349 static inline void blkg_destroy_all(struct request_queue *q,
 350                                     bool destory_root) { }
 351 static inline void update_root_blkg_pd(struct request_queue *q,
 352                                        enum blkio_policy_id plid) { }
 353
 354 static inline void *blkg_to_pdata(struct blkio_group *blkg,
 355                                 struct blkio_policy_type *pol) { return NULL; }
 356 static inline struct blkio_group *pdata_to_blkg(void *pdata,
 357                                 struct blkio_policy_type *pol) { return NULL; }
 358 static inline char *blkg_path(struct blkio_group *blkg) { return NULL; }
 359 static inline void blkg_get(struct blkio_group *blkg) { }
 360 static inline void blkg_put(struct blkio_group *blkg) { }
 361
 362 #endif
 363
 364 #ifdef CONFIG_BLK_CGROUP
 365 extern struct blkio_cgroup blkio_root_cgroup;
 366 extern struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup);
 367 extern struct blkio_cgroup *bio_blkio_cgroup(struct bio *bio);
 368 extern struct blkio_group *blkg_lookup(struct blkio_cgroup *blkcg,
 369                                        struct request_queue *q);
 370 struct blkio_group *blkg_lookup_create(struct blkio_cgroup *blkcg,
 371                                        struct request_queue *q,
 372                                        bool for_root);
 373 #else
 374 struct cgroup;
 375 static inline struct blkio_cgroup *
 376 cgroup_to_blkio_cgroup(struct cgroup *cgroup) { return NULL; }
 377 static inline struct blkio_cgroup *
 378 bio_blkio_cgroup(struct bio *bio) { return NULL; }
 379
 380 static inline struct blkio_group *blkg_lookup(struct blkio_cgroup *blkcg,
 381                                               void *key) { return NULL; }
 382 #endif
 383 #endif /* _BLK_CGROUP_H */