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