~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/block/blk-cgroup.h

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include <linux/blkdev.h>
 21 #include <linux/atomic.h>
 22 
 23 /* Max limits for throttle policy */
 24 #define THROTL_IOPS_MAX         UINT_MAX
 25 
 26 /* CFQ specific, out here for blkcg->cfq_weight */
 27 #define CFQ_WEIGHT_MIN          10
 28 #define CFQ_WEIGHT_MAX          1000
 29 #define CFQ_WEIGHT_DEFAULT      500
 30 
 31 #ifdef CONFIG_BLK_CGROUP
 32 
 33 enum blkg_rwstat_type {
 34         BLKG_RWSTAT_READ,
 35         BLKG_RWSTAT_WRITE,
 36         BLKG_RWSTAT_SYNC,
 37         BLKG_RWSTAT_ASYNC,
 38 
 39         BLKG_RWSTAT_NR,
 40         BLKG_RWSTAT_TOTAL = BLKG_RWSTAT_NR,
 41 };
 42 
 43 struct blkcg_gq;
 44 
 45 struct blkcg {
 46         struct cgroup_subsys_state      css;
 47         spinlock_t                      lock;
 48 
 49         struct radix_tree_root          blkg_tree;
 50         struct blkcg_gq                 *blkg_hint;
 51         struct hlist_head               blkg_list;
 52 
 53         /* for policies to test whether associated blkcg has changed */
 54         uint64_t                        id;
 55 
 56         /* TODO: per-policy storage in blkcg */
 57         unsigned int                    cfq_weight;     /* belongs to cfq */
 58         unsigned int                    cfq_leaf_weight;
 59 };
 60 
 61 struct blkg_stat {
 62         struct u64_stats_sync           syncp;
 63         uint64_t                        cnt;
 64 };
 65 
 66 struct blkg_rwstat {
 67         struct u64_stats_sync           syncp;
 68         uint64_t                        cnt[BLKG_RWSTAT_NR];
 69 };
 70 
 71 /*
 72  * A blkcg_gq (blkg) is association between a block cgroup (blkcg) and a
 73  * request_queue (q).  This is used by blkcg policies which need to track
 74  * information per blkcg - q pair.
 75  *
 76  * There can be multiple active blkcg policies and each has its private
 77  * data on each blkg, the size of which is determined by
 78  * blkcg_policy->pd_size.  blkcg core allocates and frees such areas
 79  * together with blkg and invokes pd_init/exit_fn() methods.
 80  *
 81  * Such private data must embed struct blkg_policy_data (pd) at the
 82  * beginning and pd_size can't be smaller than pd.
 83  */
 84 struct blkg_policy_data {
 85         /* the blkg and policy id this per-policy data belongs to */
 86         struct blkcg_gq                 *blkg;
 87         int                             plid;
 88 
 89         /* used during policy activation */
 90         struct list_head                alloc_node;
 91 };
 92 
 93 /* association between a blk cgroup and a request queue */
 94 struct blkcg_gq {
 95         /* Pointer to the associated request_queue */
 96         struct request_queue            *q;
 97         struct list_head                q_node;
 98         struct hlist_node               blkcg_node;
 99         struct blkcg                    *blkcg;
100 
101         /* all non-root blkcg_gq's are guaranteed to have access to parent */
102         struct blkcg_gq                 *parent;
103 
104         /* request allocation list for this blkcg-q pair */
105         struct request_list             rl;
106 
107         /* reference count */
108         atomic_t                        refcnt;
109 
110         /* is this blkg online? protected by both blkcg and q locks */
111         bool                            online;
112 
113         struct blkg_policy_data         *pd[BLKCG_MAX_POLS];
114 
115         struct rcu_head                 rcu_head;
116 };
117 
118 typedef void (blkcg_pol_init_pd_fn)(struct blkcg_gq *blkg);
119 typedef void (blkcg_pol_online_pd_fn)(struct blkcg_gq *blkg);
120 typedef void (blkcg_pol_offline_pd_fn)(struct blkcg_gq *blkg);
121 typedef void (blkcg_pol_exit_pd_fn)(struct blkcg_gq *blkg);
122 typedef void (blkcg_pol_reset_pd_stats_fn)(struct blkcg_gq *blkg);
123 
124 struct blkcg_policy {
125         int                             plid;
126         /* policy specific private data size */
127         size_t                          pd_size;
128         /* cgroup files for the policy */
129         struct cftype                   *cftypes;
130 
131         /* operations */
132         blkcg_pol_init_pd_fn            *pd_init_fn;
133         blkcg_pol_online_pd_fn          *pd_online_fn;
134         blkcg_pol_offline_pd_fn         *pd_offline_fn;
135         blkcg_pol_exit_pd_fn            *pd_exit_fn;
136         blkcg_pol_reset_pd_stats_fn     *pd_reset_stats_fn;
137 };
138 
139 extern struct blkcg blkcg_root;
140 
141 struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, struct request_queue *q);
142 struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
143                                     struct request_queue *q);
144 int blkcg_init_queue(struct request_queue *q);
145 void blkcg_drain_queue(struct request_queue *q);
146 void blkcg_exit_queue(struct request_queue *q);
147 
148 /* Blkio controller policy registration */
149 int blkcg_policy_register(struct blkcg_policy *pol);
150 void blkcg_policy_unregister(struct blkcg_policy *pol);
151 int blkcg_activate_policy(struct request_queue *q,
152                           const struct blkcg_policy *pol);
153 void blkcg_deactivate_policy(struct request_queue *q,
154                              const struct blkcg_policy *pol);
155 
156 void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
157                        u64 (*prfill)(struct seq_file *,
158                                      struct blkg_policy_data *, int),
159                        const struct blkcg_policy *pol, int data,
160                        bool show_total);
161 u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v);
162 u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
163                          const struct blkg_rwstat *rwstat);
164 u64 blkg_prfill_stat(struct seq_file *sf, struct blkg_policy_data *pd, int off);
165 u64 blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
166                        int off);
167 
168 u64 blkg_stat_recursive_sum(struct blkg_policy_data *pd, int off);
169 struct blkg_rwstat blkg_rwstat_recursive_sum(struct blkg_policy_data *pd,
170                                              int off);
171 
172 struct blkg_conf_ctx {
173         struct gendisk                  *disk;
174         struct blkcg_gq                 *blkg;
175         u64                             v;
176 };
177 
178 int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
179                    const char *input, struct blkg_conf_ctx *ctx);
180 void blkg_conf_finish(struct blkg_conf_ctx *ctx);
181 
182 
183 static inline struct blkcg *css_to_blkcg(struct cgroup_subsys_state *css)
184 {
185         return css ? container_of(css, struct blkcg, css) : NULL;
186 }
187 
188 static inline struct blkcg *task_blkcg(struct task_struct *tsk)
189 {
190         return css_to_blkcg(task_css(tsk, blkio_subsys_id));
191 }
192 
193 static inline struct blkcg *bio_blkcg(struct bio *bio)
194 {
195         if (bio && bio->bi_css)
196                 return css_to_blkcg(bio->bi_css);
197         return task_blkcg(current);
198 }
199 
200 /**
201  * blkcg_parent - get the parent of a blkcg
202  * @blkcg: blkcg of interest
203  *
204  * Return the parent blkcg of @blkcg.  Can be called anytime.
205  */
206 static inline struct blkcg *blkcg_parent(struct blkcg *blkcg)
207 {
208         return css_to_blkcg(css_parent(&blkcg->css));
209 }
210 
211 /**
212  * blkg_to_pdata - get policy private data
213  * @blkg: blkg of interest
214  * @pol: policy of interest
215  *
216  * Return pointer to private data associated with the @blkg-@pol pair.
217  */
218 static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
219                                                   struct blkcg_policy *pol)
220 {
221         return blkg ? blkg->pd[pol->plid] : NULL;
222 }
223 
224 /**
225  * pdata_to_blkg - get blkg associated with policy private data
226  * @pd: policy private data of interest
227  *
228  * @pd is policy private data.  Determine the blkg it's associated with.
229  */
230 static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd)
231 {
232         return pd ? pd->blkg : NULL;
233 }
234 
235 /**
236  * blkg_path - format cgroup path of blkg
237  * @blkg: blkg of interest
238  * @buf: target buffer
239  * @buflen: target buffer length
240  *
241  * Format the path of the cgroup of @blkg into @buf.
242  */
243 static inline int blkg_path(struct blkcg_gq *blkg, char *buf, int buflen)
244 {
245         int ret;
246 
247         ret = cgroup_path(blkg->blkcg->css.cgroup, buf, buflen);
248         if (ret)
249                 strncpy(buf, "<unavailable>", buflen);
250         return ret;
251 }
252 
253 /**
254  * blkg_get - get a blkg reference
255  * @blkg: blkg to get
256  *
257  * The caller should be holding an existing reference.
258  */
259 static inline void blkg_get(struct blkcg_gq *blkg)
260 {
261         WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
262         atomic_inc(&blkg->refcnt);
263 }
264 
265 void __blkg_release_rcu(struct rcu_head *rcu);
266 
267 /**
268  * blkg_put - put a blkg reference
269  * @blkg: blkg to put
270  */
271 static inline void blkg_put(struct blkcg_gq *blkg)
272 {
273         WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
274         if (atomic_dec_and_test(&blkg->refcnt))
275                 call_rcu(&blkg->rcu_head, __blkg_release_rcu);
276 }
277 
278 struct blkcg_gq *__blkg_lookup(struct blkcg *blkcg, struct request_queue *q,
279                                bool update_hint);
280 
281 /**
282  * blkg_for_each_descendant_pre - pre-order walk of a blkg's descendants
283  * @d_blkg: loop cursor pointing to the current descendant
284  * @pos_css: used for iteration
285  * @p_blkg: target blkg to walk descendants of
286  *
287  * Walk @c_blkg through the descendants of @p_blkg.  Must be used with RCU
288  * read locked.  If called under either blkcg or queue lock, the iteration
289  * is guaranteed to include all and only online blkgs.  The caller may
290  * update @pos_css by calling css_rightmost_descendant() to skip subtree.
291  * @p_blkg is included in the iteration and the first node to be visited.
292  */
293 #define blkg_for_each_descendant_pre(d_blkg, pos_css, p_blkg)           \
294         css_for_each_descendant_pre((pos_css), &(p_blkg)->blkcg->css)   \
295                 if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
296                                               (p_blkg)->q, false)))
297 
298 /**
299  * blkg_for_each_descendant_post - post-order walk of a blkg's descendants
300  * @d_blkg: loop cursor pointing to the current descendant
301  * @pos_css: used for iteration
302  * @p_blkg: target blkg to walk descendants of
303  *
304  * Similar to blkg_for_each_descendant_pre() but performs post-order
305  * traversal instead.  Synchronization rules are the same.  @p_blkg is
306  * included in the iteration and the last node to be visited.
307  */
308 #define blkg_for_each_descendant_post(d_blkg, pos_css, p_blkg)          \
309         css_for_each_descendant_post((pos_css), &(p_blkg)->blkcg->css)  \
310                 if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
311                                               (p_blkg)->q, false)))
312 
313 /**
314  * blk_get_rl - get request_list to use
315  * @q: request_queue of interest
316  * @bio: bio which will be attached to the allocated request (may be %NULL)
317  *
318  * The caller wants to allocate a request from @q to use for @bio.  Find
319  * the request_list to use and obtain a reference on it.  Should be called
320  * under queue_lock.  This function is guaranteed to return non-%NULL
321  * request_list.
322  */
323 static inline struct request_list *blk_get_rl(struct request_queue *q,
324                                               struct bio *bio)
325 {
326         struct blkcg *blkcg;
327         struct blkcg_gq *blkg;
328 
329         rcu_read_lock();
330 
331         blkcg = bio_blkcg(bio);
332 
333         /* bypass blkg lookup and use @q->root_rl directly for root */
334         if (blkcg == &blkcg_root)
335                 goto root_rl;
336 
337         /*
338          * Try to use blkg->rl.  blkg lookup may fail under memory pressure
339          * or if either the blkcg or queue is going away.  Fall back to
340          * root_rl in such cases.
341          */
342         blkg = blkg_lookup_create(blkcg, q);
343         if (unlikely(IS_ERR(blkg)))
344                 goto root_rl;
345 
346         blkg_get(blkg);
347         rcu_read_unlock();
348         return &blkg->rl;
349 root_rl:
350         rcu_read_unlock();
351         return &q->root_rl;
352 }
353 
354 /**
355  * blk_put_rl - put request_list
356  * @rl: request_list to put
357  *
358  * Put the reference acquired by blk_get_rl().  Should be called under
359  * queue_lock.
360  */
361 static inline void blk_put_rl(struct request_list *rl)
362 {
363         /* root_rl may not have blkg set */
364         if (rl->blkg && rl->blkg->blkcg != &blkcg_root)
365                 blkg_put(rl->blkg);
366 }
367 
368 /**
369  * blk_rq_set_rl - associate a request with a request_list
370  * @rq: request of interest
371  * @rl: target request_list
372  *
373  * Associate @rq with @rl so that accounting and freeing can know the
374  * request_list @rq came from.
375  */
376 static inline void blk_rq_set_rl(struct request *rq, struct request_list *rl)
377 {
378         rq->rl = rl;
379 }
380 
381 /**
382  * blk_rq_rl - return the request_list a request came from
383  * @rq: request of interest
384  *
385  * Return the request_list @rq is allocated from.
386  */
387 static inline struct request_list *blk_rq_rl(struct request *rq)
388 {
389         return rq->rl;
390 }
391 
392 struct request_list *__blk_queue_next_rl(struct request_list *rl,
393                                          struct request_queue *q);
394 /**
395  * blk_queue_for_each_rl - iterate through all request_lists of a request_queue
396  *
397  * Should be used under queue_lock.
398  */
399 #define blk_queue_for_each_rl(rl, q)    \
400         for ((rl) = &(q)->root_rl; (rl); (rl) = __blk_queue_next_rl((rl), (q)))
401 
402 static inline void blkg_stat_init(struct blkg_stat *stat)
403 {
404         u64_stats_init(&stat->syncp);
405 }
406 
407 /**
408  * blkg_stat_add - add a value to a blkg_stat
409  * @stat: target blkg_stat
410  * @val: value to add
411  *
412  * Add @val to @stat.  The caller is responsible for synchronizing calls to
413  * this function.
414  */
415 static inline void blkg_stat_add(struct blkg_stat *stat, uint64_t val)
416 {
417         u64_stats_update_begin(&stat->syncp);
418         stat->cnt += val;
419         u64_stats_update_end(&stat->syncp);
420 }
421 
422 /**
423  * blkg_stat_read - read the current value of a blkg_stat
424  * @stat: blkg_stat to read
425  *
426  * Read the current value of @stat.  This function can be called without
427  * synchroniztion and takes care of u64 atomicity.
428  */
429 static inline uint64_t blkg_stat_read(struct blkg_stat *stat)
430 {
431         unsigned int start;
432         uint64_t v;
433 
434         do {
435                 start = u64_stats_fetch_begin_bh(&stat->syncp);
436                 v = stat->cnt;
437         } while (u64_stats_fetch_retry_bh(&stat->syncp, start));
438 
439         return v;
440 }
441 
442 /**
443  * blkg_stat_reset - reset a blkg_stat
444  * @stat: blkg_stat to reset
445  */
446 static inline void blkg_stat_reset(struct blkg_stat *stat)
447 {
448         stat->cnt = 0;
449 }
450 
451 /**
452  * blkg_stat_merge - merge a blkg_stat into another
453  * @to: the destination blkg_stat
454  * @from: the source
455  *
456  * Add @from's count to @to.
457  */
458 static inline void blkg_stat_merge(struct blkg_stat *to, struct blkg_stat *from)
459 {
460         blkg_stat_add(to, blkg_stat_read(from));
461 }
462 
463 static inline void blkg_rwstat_init(struct blkg_rwstat *rwstat)
464 {
465         u64_stats_init(&rwstat->syncp);
466 }
467 
468 /**
469  * blkg_rwstat_add - add a value to a blkg_rwstat
470  * @rwstat: target blkg_rwstat
471  * @rw: mask of REQ_{WRITE|SYNC}
472  * @val: value to add
473  *
474  * Add @val to @rwstat.  The counters are chosen according to @rw.  The
475  * caller is responsible for synchronizing calls to this function.
476  */
477 static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
478                                    int rw, uint64_t val)
479 {
480         u64_stats_update_begin(&rwstat->syncp);
481 
482         if (rw & REQ_WRITE)
483                 rwstat->cnt[BLKG_RWSTAT_WRITE] += val;
484         else
485                 rwstat->cnt[BLKG_RWSTAT_READ] += val;
486         if (rw & REQ_SYNC)
487                 rwstat->cnt[BLKG_RWSTAT_SYNC] += val;
488         else
489                 rwstat->cnt[BLKG_RWSTAT_ASYNC] += val;
490 
491         u64_stats_update_end(&rwstat->syncp);
492 }
493 
494 /**
495  * blkg_rwstat_read - read the current values of a blkg_rwstat
496  * @rwstat: blkg_rwstat to read
497  *
498  * Read the current snapshot of @rwstat and return it as the return value.
499  * This function can be called without synchronization and takes care of
500  * u64 atomicity.
501  */
502 static inline struct blkg_rwstat blkg_rwstat_read(struct blkg_rwstat *rwstat)
503 {
504         unsigned int start;
505         struct blkg_rwstat tmp;
506 
507         do {
508                 start = u64_stats_fetch_begin_bh(&rwstat->syncp);
509                 tmp = *rwstat;
510         } while (u64_stats_fetch_retry_bh(&rwstat->syncp, start));
511 
512         return tmp;
513 }
514 
515 /**
516  * blkg_rwstat_total - read the total count of a blkg_rwstat
517  * @rwstat: blkg_rwstat to read
518  *
519  * Return the total count of @rwstat regardless of the IO direction.  This
520  * function can be called without synchronization and takes care of u64
521  * atomicity.
522  */
523 static inline uint64_t blkg_rwstat_total(struct blkg_rwstat *rwstat)
524 {
525         struct blkg_rwstat tmp = blkg_rwstat_read(rwstat);
526 
527         return tmp.cnt[BLKG_RWSTAT_READ] + tmp.cnt[BLKG_RWSTAT_WRITE];
528 }
529 
530 /**
531  * blkg_rwstat_reset - reset a blkg_rwstat
532  * @rwstat: blkg_rwstat to reset
533  */
534 static inline void blkg_rwstat_reset(struct blkg_rwstat *rwstat)
535 {
536         memset(rwstat->cnt, 0, sizeof(rwstat->cnt));
537 }
538 
539 /**
540  * blkg_rwstat_merge - merge a blkg_rwstat into another
541  * @to: the destination blkg_rwstat
542  * @from: the source
543  *
544  * Add @from's counts to @to.
545  */
546 static inline void blkg_rwstat_merge(struct blkg_rwstat *to,
547                                      struct blkg_rwstat *from)
548 {
549         struct blkg_rwstat v = blkg_rwstat_read(from);
550         int i;
551 
552         u64_stats_update_begin(&to->syncp);
553         for (i = 0; i < BLKG_RWSTAT_NR; i++)
554                 to->cnt[i] += v.cnt[i];
555         u64_stats_update_end(&to->syncp);
556 }
557 
558 #else   /* CONFIG_BLK_CGROUP */
559 
560 struct cgroup;
561 struct blkcg;
562 
563 struct blkg_policy_data {
564 };
565 
566 struct blkcg_gq {
567 };
568 
569 struct blkcg_policy {
570 };
571 
572 static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, void *key) { return NULL; }
573 static inline int blkcg_init_queue(struct request_queue *q) { return 0; }
574 static inline void blkcg_drain_queue(struct request_queue *q) { }
575 static inline void blkcg_exit_queue(struct request_queue *q) { }
576 static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; }
577 static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { }
578 static inline int blkcg_activate_policy(struct request_queue *q,
579                                         const struct blkcg_policy *pol) { return 0; }
580 static inline void blkcg_deactivate_policy(struct request_queue *q,
581                                            const struct blkcg_policy *pol) { }
582 
583 static inline struct blkcg *bio_blkcg(struct bio *bio) { return NULL; }
584 
585 static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
586                                                   struct blkcg_policy *pol) { return NULL; }
587 static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd) { return NULL; }
588 static inline char *blkg_path(struct blkcg_gq *blkg) { return NULL; }
589 static inline void blkg_get(struct blkcg_gq *blkg) { }
590 static inline void blkg_put(struct blkcg_gq *blkg) { }
591 
592 static inline struct request_list *blk_get_rl(struct request_queue *q,
593                                               struct bio *bio) { return &q->root_rl; }
594 static inline void blk_put_rl(struct request_list *rl) { }
595 static inline void blk_rq_set_rl(struct request *rq, struct request_list *rl) { }
596 static inline struct request_list *blk_rq_rl(struct request *rq) { return &rq->q->root_rl; }
597 
598 #define blk_queue_for_each_rl(rl, q)    \
599         for ((rl) = &(q)->root_rl; (rl); (rl) = NULL)
600 
601 #endif  /* CONFIG_BLK_CGROUP */
602 #endif  /* _BLK_CGROUP_H */
603 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp