Commit | Line | Data |
---|---|---|
672fdcf0 ML |
1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef _BLK_CGROUP_PRIVATE_H | |
3 | #define _BLK_CGROUP_PRIVATE_H | |
4 | /* | |
5 | * block cgroup private header | |
6 | * | |
7 | * Based on ideas and code from CFQ, CFS and BFQ: | |
8 | * Copyright (C) 2003 Jens Axboe <axboe@kernel.dk> | |
9 | * | |
10 | * Copyright (C) 2008 Fabio Checconi <fabio@gandalf.sssup.it> | |
11 | * Paolo Valente <paolo.valente@unimore.it> | |
12 | * | |
13 | * Copyright (C) 2009 Vivek Goyal <vgoyal@redhat.com> | |
14 | * Nauman Rafique <nauman@google.com> | |
15 | */ | |
16 | ||
17 | #include <linux/blk-cgroup.h> | |
c97ab271 CH |
18 | #include <linux/cgroup.h> |
19 | #include <linux/kthread.h> | |
6b2b0459 | 20 | #include <linux/blk-mq.h> |
3b8cc629 | 21 | #include <linux/llist.h> |
c4e47bbb | 22 | #include "blk.h" |
672fdcf0 | 23 | |
dec223c9 CH |
24 | struct blkcg_gq; |
25 | struct blkg_policy_data; | |
26 | ||
27 | ||
672fdcf0 ML |
28 | /* percpu_counter batch for blkg_[rw]stats, per-cpu drift doesn't matter */ |
29 | #define BLKG_STAT_CPU_BATCH (INT_MAX / 2) | |
30 | ||
31 | #ifdef CONFIG_BLK_CGROUP | |
bbb1ebe7 CH |
32 | |
33 | enum blkg_iostat_type { | |
34 | BLKG_IOSTAT_READ, | |
35 | BLKG_IOSTAT_WRITE, | |
36 | BLKG_IOSTAT_DISCARD, | |
37 | ||
38 | BLKG_IOSTAT_NR, | |
39 | }; | |
40 | ||
41 | struct blkg_iostat { | |
42 | u64 bytes[BLKG_IOSTAT_NR]; | |
43 | u64 ios[BLKG_IOSTAT_NR]; | |
44 | }; | |
45 | ||
46 | struct blkg_iostat_set { | |
47 | struct u64_stats_sync sync; | |
3b8cc629 WL |
48 | struct blkcg_gq *blkg; |
49 | struct llist_node lnode; | |
50 | int lqueued; /* queued in llist */ | |
bbb1ebe7 CH |
51 | struct blkg_iostat cur; |
52 | struct blkg_iostat last; | |
53 | }; | |
54 | ||
55 | /* association between a blk cgroup and a request queue */ | |
56 | struct blkcg_gq { | |
a06377c5 CH |
57 | /* Pointer to the associated request_queue */ |
58 | struct request_queue *q; | |
1231039d | 59 | struct list_head q_node; |
bbb1ebe7 CH |
60 | struct hlist_node blkcg_node; |
61 | struct blkcg *blkcg; | |
62 | ||
63 | /* all non-root blkcg_gq's are guaranteed to have access to parent */ | |
64 | struct blkcg_gq *parent; | |
65 | ||
66 | /* reference count */ | |
67 | struct percpu_ref refcnt; | |
68 | ||
69 | /* is this blkg online? protected by both blkcg and q locks */ | |
70 | bool online; | |
71 | ||
72 | struct blkg_iostat_set __percpu *iostat_cpu; | |
73 | struct blkg_iostat_set iostat; | |
74 | ||
75 | struct blkg_policy_data *pd[BLKCG_MAX_POLS]; | |
2c275afe | 76 | #ifdef CONFIG_BLK_CGROUP_PUNT_BIO |
bbb1ebe7 CH |
77 | spinlock_t async_bio_lock; |
78 | struct bio_list async_bios; | |
2c275afe | 79 | #endif |
bbb1ebe7 CH |
80 | union { |
81 | struct work_struct async_bio_work; | |
82 | struct work_struct free_work; | |
83 | }; | |
84 | ||
85 | atomic_t use_delay; | |
86 | atomic64_t delay_nsec; | |
87 | atomic64_t delay_start; | |
88 | u64 last_delay; | |
89 | int last_use; | |
90 | ||
91 | struct rcu_head rcu_head; | |
92 | }; | |
93 | ||
dec223c9 CH |
94 | struct blkcg { |
95 | struct cgroup_subsys_state css; | |
96 | spinlock_t lock; | |
97 | refcount_t online_pin; | |
89ed6c9a XJ |
98 | /* If there is block congestion on this cgroup. */ |
99 | atomic_t congestion_count; | |
dec223c9 CH |
100 | |
101 | struct radix_tree_root blkg_tree; | |
102 | struct blkcg_gq __rcu *blkg_hint; | |
103 | struct hlist_head blkg_list; | |
104 | ||
105 | struct blkcg_policy_data *cpd[BLKCG_MAX_POLS]; | |
106 | ||
107 | struct list_head all_blkcgs_node; | |
3b8cc629 WL |
108 | |
109 | /* | |
110 | * List of updated percpu blkg_iostat_set's since the last flush. | |
111 | */ | |
112 | struct llist_head __percpu *lhead; | |
113 | ||
dec223c9 CH |
114 | #ifdef CONFIG_BLK_CGROUP_FC_APPID |
115 | char fc_app_id[FC_APPID_LEN]; | |
116 | #endif | |
117 | #ifdef CONFIG_CGROUP_WRITEBACK | |
118 | struct list_head cgwb_list; | |
119 | #endif | |
120 | }; | |
121 | ||
122 | static inline struct blkcg *css_to_blkcg(struct cgroup_subsys_state *css) | |
123 | { | |
124 | return css ? container_of(css, struct blkcg, css) : NULL; | |
125 | } | |
672fdcf0 ML |
126 | |
127 | /* | |
128 | * A blkcg_gq (blkg) is association between a block cgroup (blkcg) and a | |
129 | * request_queue (q). This is used by blkcg policies which need to track | |
130 | * information per blkcg - q pair. | |
131 | * | |
132 | * There can be multiple active blkcg policies and each blkg:policy pair is | |
133 | * represented by a blkg_policy_data which is allocated and freed by each | |
134 | * policy's pd_alloc/free_fn() methods. A policy can allocate private data | |
135 | * area by allocating larger data structure which embeds blkg_policy_data | |
136 | * at the beginning. | |
137 | */ | |
138 | struct blkg_policy_data { | |
139 | /* the blkg and policy id this per-policy data belongs to */ | |
140 | struct blkcg_gq *blkg; | |
141 | int plid; | |
dfd6200a | 142 | bool online; |
672fdcf0 ML |
143 | }; |
144 | ||
145 | /* | |
146 | * Policies that need to keep per-blkcg data which is independent from any | |
147 | * request_queue associated to it should implement cpd_alloc/free_fn() | |
148 | * methods. A policy can allocate private data area by allocating larger | |
149 | * data structure which embeds blkcg_policy_data at the beginning. | |
150 | * cpd_init() is invoked to let each policy handle per-blkcg data. | |
151 | */ | |
152 | struct blkcg_policy_data { | |
153 | /* the blkcg and policy id this per-policy data belongs to */ | |
154 | struct blkcg *blkcg; | |
155 | int plid; | |
156 | }; | |
157 | ||
158 | typedef struct blkcg_policy_data *(blkcg_pol_alloc_cpd_fn)(gfp_t gfp); | |
159 | typedef void (blkcg_pol_init_cpd_fn)(struct blkcg_policy_data *cpd); | |
160 | typedef void (blkcg_pol_free_cpd_fn)(struct blkcg_policy_data *cpd); | |
161 | typedef void (blkcg_pol_bind_cpd_fn)(struct blkcg_policy_data *cpd); | |
0a0b4f79 CH |
162 | typedef struct blkg_policy_data *(blkcg_pol_alloc_pd_fn)(struct gendisk *disk, |
163 | struct blkcg *blkcg, gfp_t gfp); | |
672fdcf0 ML |
164 | typedef void (blkcg_pol_init_pd_fn)(struct blkg_policy_data *pd); |
165 | typedef void (blkcg_pol_online_pd_fn)(struct blkg_policy_data *pd); | |
166 | typedef void (blkcg_pol_offline_pd_fn)(struct blkg_policy_data *pd); | |
167 | typedef void (blkcg_pol_free_pd_fn)(struct blkg_policy_data *pd); | |
168 | typedef void (blkcg_pol_reset_pd_stats_fn)(struct blkg_policy_data *pd); | |
3607849d | 169 | typedef void (blkcg_pol_stat_pd_fn)(struct blkg_policy_data *pd, |
672fdcf0 ML |
170 | struct seq_file *s); |
171 | ||
172 | struct blkcg_policy { | |
173 | int plid; | |
174 | /* cgroup files for the policy */ | |
175 | struct cftype *dfl_cftypes; | |
176 | struct cftype *legacy_cftypes; | |
177 | ||
178 | /* operations */ | |
179 | blkcg_pol_alloc_cpd_fn *cpd_alloc_fn; | |
672fdcf0 | 180 | blkcg_pol_free_cpd_fn *cpd_free_fn; |
672fdcf0 ML |
181 | |
182 | blkcg_pol_alloc_pd_fn *pd_alloc_fn; | |
183 | blkcg_pol_init_pd_fn *pd_init_fn; | |
184 | blkcg_pol_online_pd_fn *pd_online_fn; | |
185 | blkcg_pol_offline_pd_fn *pd_offline_fn; | |
186 | blkcg_pol_free_pd_fn *pd_free_fn; | |
187 | blkcg_pol_reset_pd_stats_fn *pd_reset_stats_fn; | |
188 | blkcg_pol_stat_pd_fn *pd_stat_fn; | |
189 | }; | |
190 | ||
191 | extern struct blkcg blkcg_root; | |
192 | extern bool blkcg_debug_stats; | |
193 | ||
8b8ace08 | 194 | void blkg_init_queue(struct request_queue *q); |
9823538f CH |
195 | int blkcg_init_disk(struct gendisk *disk); |
196 | void blkcg_exit_disk(struct gendisk *disk); | |
672fdcf0 ML |
197 | |
198 | /* Blkio controller policy registration */ | |
199 | int blkcg_policy_register(struct blkcg_policy *pol); | |
200 | void blkcg_policy_unregister(struct blkcg_policy *pol); | |
40e4996e CH |
201 | int blkcg_activate_policy(struct gendisk *disk, const struct blkcg_policy *pol); |
202 | void blkcg_deactivate_policy(struct gendisk *disk, | |
672fdcf0 ML |
203 | const struct blkcg_policy *pol); |
204 | ||
205 | const char *blkg_dev_name(struct blkcg_gq *blkg); | |
206 | void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg, | |
207 | u64 (*prfill)(struct seq_file *, | |
208 | struct blkg_policy_data *, int), | |
209 | const struct blkcg_policy *pol, int data, | |
210 | bool show_total); | |
211 | u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v); | |
212 | ||
213 | struct blkg_conf_ctx { | |
faffaab2 TH |
214 | char *input; |
215 | char *body; | |
672fdcf0 ML |
216 | struct block_device *bdev; |
217 | struct blkcg_gq *blkg; | |
672fdcf0 ML |
218 | }; |
219 | ||
faffaab2 TH |
220 | void blkg_conf_init(struct blkg_conf_ctx *ctx, char *input); |
221 | int blkg_conf_open_bdev(struct blkg_conf_ctx *ctx); | |
672fdcf0 | 222 | int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol, |
faffaab2 TH |
223 | struct blkg_conf_ctx *ctx); |
224 | void blkg_conf_exit(struct blkg_conf_ctx *ctx); | |
672fdcf0 | 225 | |
672fdcf0 ML |
226 | /** |
227 | * bio_issue_as_root_blkg - see if this bio needs to be issued as root blkg | |
228 | * @return: true if this bio needs to be submitted with the root blkg context. | |
229 | * | |
230 | * In order to avoid priority inversions we sometimes need to issue a bio as if | |
231 | * it were attached to the root blkg, and then backcharge to the actual owning | |
bbb1ebe7 CH |
232 | * blkg. The idea is we do bio_blkcg_css() to look up the actual context for |
233 | * the bio and attach the appropriate blkg to the bio. Then we call this helper | |
234 | * and if it is true run with the root blkg for that queue and then do any | |
672fdcf0 ML |
235 | * backcharging to the originating cgroup once the io is complete. |
236 | */ | |
237 | static inline bool bio_issue_as_root_blkg(struct bio *bio) | |
238 | { | |
239 | return (bio->bi_opf & (REQ_META | REQ_SWAP)) != 0; | |
240 | } | |
241 | ||
242 | /** | |
9a9c261e | 243 | * blkg_lookup - lookup blkg for the specified blkcg - q pair |
672fdcf0 | 244 | * @blkcg: blkcg of interest |
9a9c261e | 245 | * @q: request_queue of interest |
672fdcf0 | 246 | * |
9a9c261e | 247 | * Lookup blkg for the @blkcg - @q pair. |
4a69f325 CH |
248 | |
249 | * Must be called in a RCU critical section. | |
672fdcf0 | 250 | */ |
4a69f325 | 251 | static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, |
9a9c261e | 252 | struct request_queue *q) |
672fdcf0 ML |
253 | { |
254 | struct blkcg_gq *blkg; | |
255 | ||
256 | if (blkcg == &blkcg_root) | |
9a9c261e | 257 | return q->root_blkg; |
672fdcf0 | 258 | |
393cd8ff ML |
259 | blkg = rcu_dereference_check(blkcg->blkg_hint, |
260 | lockdep_is_held(&q->queue_lock)); | |
a06377c5 | 261 | if (blkg && blkg->q == q) |
672fdcf0 ML |
262 | return blkg; |
263 | ||
9a9c261e | 264 | blkg = radix_tree_lookup(&blkcg->blkg_tree, q->id); |
a06377c5 | 265 | if (blkg && blkg->q != q) |
4a69f325 CH |
266 | blkg = NULL; |
267 | return blkg; | |
672fdcf0 ML |
268 | } |
269 | ||
672fdcf0 ML |
270 | /** |
271 | * blkg_to_pdata - get policy private data | |
272 | * @blkg: blkg of interest | |
273 | * @pol: policy of interest | |
274 | * | |
275 | * Return pointer to private data associated with the @blkg-@pol pair. | |
276 | */ | |
277 | static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg, | |
278 | struct blkcg_policy *pol) | |
279 | { | |
280 | return blkg ? blkg->pd[pol->plid] : NULL; | |
281 | } | |
282 | ||
283 | static inline struct blkcg_policy_data *blkcg_to_cpd(struct blkcg *blkcg, | |
284 | struct blkcg_policy *pol) | |
285 | { | |
286 | return blkcg ? blkcg->cpd[pol->plid] : NULL; | |
287 | } | |
288 | ||
289 | /** | |
290 | * pdata_to_blkg - get blkg associated with policy private data | |
291 | * @pd: policy private data of interest | |
292 | * | |
293 | * @pd is policy private data. Determine the blkg it's associated with. | |
294 | */ | |
295 | static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd) | |
296 | { | |
297 | return pd ? pd->blkg : NULL; | |
298 | } | |
299 | ||
300 | static inline struct blkcg *cpd_to_blkcg(struct blkcg_policy_data *cpd) | |
301 | { | |
302 | return cpd ? cpd->blkcg : NULL; | |
303 | } | |
304 | ||
672fdcf0 ML |
305 | /** |
306 | * blkg_get - get a blkg reference | |
307 | * @blkg: blkg to get | |
308 | * | |
309 | * The caller should be holding an existing reference. | |
310 | */ | |
311 | static inline void blkg_get(struct blkcg_gq *blkg) | |
312 | { | |
313 | percpu_ref_get(&blkg->refcnt); | |
314 | } | |
315 | ||
316 | /** | |
317 | * blkg_tryget - try and get a blkg reference | |
318 | * @blkg: blkg to get | |
319 | * | |
320 | * This is for use when doing an RCU lookup of the blkg. We may be in the midst | |
321 | * of freeing this blkg, so we can only use it if the refcnt is not zero. | |
322 | */ | |
323 | static inline bool blkg_tryget(struct blkcg_gq *blkg) | |
324 | { | |
325 | return blkg && percpu_ref_tryget(&blkg->refcnt); | |
326 | } | |
327 | ||
328 | /** | |
329 | * blkg_put - put a blkg reference | |
330 | * @blkg: blkg to put | |
331 | */ | |
332 | static inline void blkg_put(struct blkcg_gq *blkg) | |
333 | { | |
334 | percpu_ref_put(&blkg->refcnt); | |
335 | } | |
336 | ||
337 | /** | |
338 | * blkg_for_each_descendant_pre - pre-order walk of a blkg's descendants | |
339 | * @d_blkg: loop cursor pointing to the current descendant | |
340 | * @pos_css: used for iteration | |
341 | * @p_blkg: target blkg to walk descendants of | |
342 | * | |
343 | * Walk @c_blkg through the descendants of @p_blkg. Must be used with RCU | |
344 | * read locked. If called under either blkcg or queue lock, the iteration | |
345 | * is guaranteed to include all and only online blkgs. The caller may | |
346 | * update @pos_css by calling css_rightmost_descendant() to skip subtree. | |
347 | * @p_blkg is included in the iteration and the first node to be visited. | |
348 | */ | |
349 | #define blkg_for_each_descendant_pre(d_blkg, pos_css, p_blkg) \ | |
350 | css_for_each_descendant_pre((pos_css), &(p_blkg)->blkcg->css) \ | |
79fcc5be | 351 | if (((d_blkg) = blkg_lookup(css_to_blkcg(pos_css), \ |
a06377c5 | 352 | (p_blkg)->q))) |
672fdcf0 ML |
353 | |
354 | /** | |
355 | * blkg_for_each_descendant_post - post-order walk of a blkg's descendants | |
356 | * @d_blkg: loop cursor pointing to the current descendant | |
357 | * @pos_css: used for iteration | |
358 | * @p_blkg: target blkg to walk descendants of | |
359 | * | |
360 | * Similar to blkg_for_each_descendant_pre() but performs post-order | |
361 | * traversal instead. Synchronization rules are the same. @p_blkg is | |
362 | * included in the iteration and the last node to be visited. | |
363 | */ | |
364 | #define blkg_for_each_descendant_post(d_blkg, pos_css, p_blkg) \ | |
365 | css_for_each_descendant_post((pos_css), &(p_blkg)->blkcg->css) \ | |
79fcc5be | 366 | if (((d_blkg) = blkg_lookup(css_to_blkcg(pos_css), \ |
a06377c5 | 367 | (p_blkg)->q))) |
672fdcf0 | 368 | |
672fdcf0 ML |
369 | static inline void blkcg_bio_issue_init(struct bio *bio) |
370 | { | |
371 | bio_issue_init(&bio->bi_issue, bio_sectors(bio)); | |
372 | } | |
373 | ||
374 | static inline void blkcg_use_delay(struct blkcg_gq *blkg) | |
375 | { | |
376 | if (WARN_ON_ONCE(atomic_read(&blkg->use_delay) < 0)) | |
377 | return; | |
378 | if (atomic_add_return(1, &blkg->use_delay) == 1) | |
89ed6c9a | 379 | atomic_inc(&blkg->blkcg->congestion_count); |
672fdcf0 ML |
380 | } |
381 | ||
382 | static inline int blkcg_unuse_delay(struct blkcg_gq *blkg) | |
383 | { | |
384 | int old = atomic_read(&blkg->use_delay); | |
385 | ||
386 | if (WARN_ON_ONCE(old < 0)) | |
387 | return 0; | |
388 | if (old == 0) | |
389 | return 0; | |
390 | ||
391 | /* | |
392 | * We do this song and dance because we can race with somebody else | |
393 | * adding or removing delay. If we just did an atomic_dec we'd end up | |
394 | * negative and we'd already be in trouble. We need to subtract 1 and | |
395 | * then check to see if we were the last delay so we can drop the | |
396 | * congestion count on the cgroup. | |
397 | */ | |
96388f57 UB |
398 | while (old && !atomic_try_cmpxchg(&blkg->use_delay, &old, old - 1)) |
399 | ; | |
672fdcf0 ML |
400 | |
401 | if (old == 0) | |
402 | return 0; | |
403 | if (old == 1) | |
89ed6c9a | 404 | atomic_dec(&blkg->blkcg->congestion_count); |
672fdcf0 ML |
405 | return 1; |
406 | } | |
407 | ||
408 | /** | |
409 | * blkcg_set_delay - Enable allocator delay mechanism with the specified delay amount | |
410 | * @blkg: target blkg | |
411 | * @delay: delay duration in nsecs | |
412 | * | |
413 | * When enabled with this function, the delay is not decayed and must be | |
414 | * explicitly cleared with blkcg_clear_delay(). Must not be mixed with | |
415 | * blkcg_[un]use_delay() and blkcg_add_delay() usages. | |
416 | */ | |
417 | static inline void blkcg_set_delay(struct blkcg_gq *blkg, u64 delay) | |
418 | { | |
419 | int old = atomic_read(&blkg->use_delay); | |
420 | ||
421 | /* We only want 1 person setting the congestion count for this blkg. */ | |
96388f57 | 422 | if (!old && atomic_try_cmpxchg(&blkg->use_delay, &old, -1)) |
89ed6c9a | 423 | atomic_inc(&blkg->blkcg->congestion_count); |
672fdcf0 ML |
424 | |
425 | atomic64_set(&blkg->delay_nsec, delay); | |
426 | } | |
427 | ||
428 | /** | |
429 | * blkcg_clear_delay - Disable allocator delay mechanism | |
430 | * @blkg: target blkg | |
431 | * | |
432 | * Disable use_delay mechanism. See blkcg_set_delay(). | |
433 | */ | |
434 | static inline void blkcg_clear_delay(struct blkcg_gq *blkg) | |
435 | { | |
436 | int old = atomic_read(&blkg->use_delay); | |
437 | ||
438 | /* We only want 1 person clearing the congestion count for this blkg. */ | |
96388f57 | 439 | if (old && atomic_try_cmpxchg(&blkg->use_delay, &old, 0)) |
89ed6c9a | 440 | atomic_dec(&blkg->blkcg->congestion_count); |
672fdcf0 ML |
441 | } |
442 | ||
6b2b0459 TH |
443 | /** |
444 | * blk_cgroup_mergeable - Determine whether to allow or disallow merges | |
445 | * @rq: request to merge into | |
446 | * @bio: bio to merge | |
447 | * | |
448 | * @bio and @rq should belong to the same cgroup and their issue_as_root should | |
449 | * match. The latter is necessary as we don't want to throttle e.g. a metadata | |
450 | * update because it happens to be next to a regular IO. | |
451 | */ | |
452 | static inline bool blk_cgroup_mergeable(struct request *rq, struct bio *bio) | |
453 | { | |
454 | return rq->bio->bi_blkg == bio->bi_blkg && | |
455 | bio_issue_as_root_blkg(rq->bio) == bio_issue_as_root_blkg(bio); | |
456 | } | |
457 | ||
672fdcf0 ML |
458 | void blk_cgroup_bio_start(struct bio *bio); |
459 | void blkcg_add_delay(struct blkcg_gq *blkg, u64 now, u64 delta); | |
460 | #else /* CONFIG_BLK_CGROUP */ | |
461 | ||
462 | struct blkg_policy_data { | |
463 | }; | |
464 | ||
465 | struct blkcg_policy_data { | |
466 | }; | |
467 | ||
468 | struct blkcg_policy { | |
469 | }; | |
470 | ||
bbb1ebe7 CH |
471 | struct blkcg { |
472 | }; | |
473 | ||
672fdcf0 | 474 | static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, void *key) { return NULL; } |
8b8ace08 | 475 | static inline void blkg_init_queue(struct request_queue *q) { } |
9823538f CH |
476 | static inline int blkcg_init_disk(struct gendisk *disk) { return 0; } |
477 | static inline void blkcg_exit_disk(struct gendisk *disk) { } | |
672fdcf0 ML |
478 | static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; } |
479 | static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { } | |
40e4996e | 480 | static inline int blkcg_activate_policy(struct gendisk *disk, |
672fdcf0 | 481 | const struct blkcg_policy *pol) { return 0; } |
40e4996e | 482 | static inline void blkcg_deactivate_policy(struct gendisk *disk, |
672fdcf0 ML |
483 | const struct blkcg_policy *pol) { } |
484 | ||
672fdcf0 ML |
485 | static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg, |
486 | struct blkcg_policy *pol) { return NULL; } | |
487 | static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd) { return NULL; } | |
672fdcf0 ML |
488 | static inline void blkg_get(struct blkcg_gq *blkg) { } |
489 | static inline void blkg_put(struct blkcg_gq *blkg) { } | |
672fdcf0 ML |
490 | static inline void blkcg_bio_issue_init(struct bio *bio) { } |
491 | static inline void blk_cgroup_bio_start(struct bio *bio) { } | |
6b2b0459 | 492 | static inline bool blk_cgroup_mergeable(struct request *rq, struct bio *bio) { return true; } |
672fdcf0 ML |
493 | |
494 | #define blk_queue_for_each_rl(rl, q) \ | |
495 | for ((rl) = &(q)->root_rl; (rl); (rl) = NULL) | |
496 | ||
672fdcf0 ML |
497 | #endif /* CONFIG_BLK_CGROUP */ |
498 | ||
499 | #endif /* _BLK_CGROUP_PRIVATE_H */ |