Branch data Line data Source code
1 : : /*
2 : : * Functions related to sysfs handling
3 : : */
4 : : #include <linux/kernel.h>
5 : : #include <linux/slab.h>
6 : : #include <linux/module.h>
7 : : #include <linux/bio.h>
8 : : #include <linux/blkdev.h>
9 : : #include <linux/blktrace_api.h>
10 : : #include <linux/blk-mq.h>
11 : :
12 : : #include "blk.h"
13 : : #include "blk-cgroup.h"
14 : : #include "blk-mq.h"
15 : :
16 : : struct queue_sysfs_entry {
17 : : struct attribute attr;
18 : : ssize_t (*show)(struct request_queue *, char *);
19 : : ssize_t (*store)(struct request_queue *, const char *, size_t);
20 : : };
21 : :
22 : : static ssize_t
23 : : queue_var_show(unsigned long var, char *page)
24 : : {
25 : 0 : return sprintf(page, "%lu\n", var);
26 : : }
27 : :
28 : : static ssize_t
29 : : queue_var_store(unsigned long *var, const char *page, size_t count)
30 : : {
31 : : int err;
32 : : unsigned long v;
33 : :
34 : : err = kstrtoul(page, 10, &v);
35 [ # # # # : 0 : if (err || v > UINT_MAX)
# # # # #
# # # # #
# # ]
36 : : return -EINVAL;
37 : :
38 : 0 : *var = v;
39 : :
40 : 0 : return count;
41 : : }
42 : :
43 : 0 : static ssize_t queue_requests_show(struct request_queue *q, char *page)
44 : : {
45 : 0 : return queue_var_show(q->nr_requests, (page));
46 : : }
47 : :
48 : : static ssize_t
49 : 0 : queue_requests_store(struct request_queue *q, const char *page, size_t count)
50 : : {
51 : : struct request_list *rl;
52 : : unsigned long nr;
53 : : int ret;
54 : :
55 [ # # ]: 0 : if (!q->request_fn)
56 : : return -EINVAL;
57 : :
58 : : ret = queue_var_store(&nr, page, count);
59 [ # # ]: 0 : if (ret < 0)
60 : : return ret;
61 : :
62 [ # # ]: 0 : if (nr < BLKDEV_MIN_RQ)
63 : : nr = BLKDEV_MIN_RQ;
64 : :
65 : 0 : spin_lock_irq(q->queue_lock);
66 : 0 : q->nr_requests = nr;
67 : 0 : blk_queue_congestion_threshold(q);
68 : :
69 : : /* congestion isn't cgroup aware and follows root blkcg for now */
70 : : rl = &q->root_rl;
71 : :
72 [ # # ]: 0 : if (rl->count[BLK_RW_SYNC] >= queue_congestion_on_threshold(q))
73 : : blk_set_queue_congested(q, BLK_RW_SYNC);
74 [ # # ]: 0 : else if (rl->count[BLK_RW_SYNC] < queue_congestion_off_threshold(q))
75 : : blk_clear_queue_congested(q, BLK_RW_SYNC);
76 : :
77 [ # # ]: 0 : if (rl->count[BLK_RW_ASYNC] >= queue_congestion_on_threshold(q))
78 : : blk_set_queue_congested(q, BLK_RW_ASYNC);
79 [ # # ]: 0 : else if (rl->count[BLK_RW_ASYNC] < queue_congestion_off_threshold(q))
80 : : blk_clear_queue_congested(q, BLK_RW_ASYNC);
81 : :
82 [ # # ]: 0 : blk_queue_for_each_rl(rl, q) {
83 [ # # ]: 0 : if (rl->count[BLK_RW_SYNC] >= q->nr_requests) {
84 : : blk_set_rl_full(rl, BLK_RW_SYNC);
85 : : } else {
86 : : blk_clear_rl_full(rl, BLK_RW_SYNC);
87 : 0 : wake_up(&rl->wait[BLK_RW_SYNC]);
88 : : }
89 : :
90 [ # # ]: 0 : if (rl->count[BLK_RW_ASYNC] >= q->nr_requests) {
91 : : blk_set_rl_full(rl, BLK_RW_ASYNC);
92 : : } else {
93 : : blk_clear_rl_full(rl, BLK_RW_ASYNC);
94 : 0 : wake_up(&rl->wait[BLK_RW_ASYNC]);
95 : : }
96 : : }
97 : :
98 : 0 : spin_unlock_irq(q->queue_lock);
99 : 0 : return ret;
100 : : }
101 : :
102 : 0 : static ssize_t queue_ra_show(struct request_queue *q, char *page)
103 : : {
104 : 0 : unsigned long ra_kb = q->backing_dev_info.ra_pages <<
105 : : (PAGE_CACHE_SHIFT - 10);
106 : :
107 : 0 : return queue_var_show(ra_kb, (page));
108 : : }
109 : :
110 : : static ssize_t
111 : 0 : queue_ra_store(struct request_queue *q, const char *page, size_t count)
112 : : {
113 : : unsigned long ra_kb;
114 : : ssize_t ret = queue_var_store(&ra_kb, page, count);
115 : :
116 [ # # ]: 0 : if (ret < 0)
117 : : return ret;
118 : :
119 : 0 : q->backing_dev_info.ra_pages = ra_kb >> (PAGE_CACHE_SHIFT - 10);
120 : :
121 : 0 : return ret;
122 : : }
123 : :
124 : 0 : static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
125 : : {
126 : 0 : int max_sectors_kb = queue_max_sectors(q) >> 1;
127 : :
128 : 0 : return queue_var_show(max_sectors_kb, (page));
129 : : }
130 : :
131 : 0 : static ssize_t queue_max_segments_show(struct request_queue *q, char *page)
132 : : {
133 : 0 : return queue_var_show(queue_max_segments(q), (page));
134 : : }
135 : :
136 : 0 : static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page)
137 : : {
138 : 0 : return queue_var_show(q->limits.max_integrity_segments, (page));
139 : : }
140 : :
141 : 0 : static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
142 : : {
143 [ # # ]: 0 : if (blk_queue_cluster(q))
144 : 0 : return queue_var_show(queue_max_segment_size(q), (page));
145 : :
146 : 0 : return queue_var_show(PAGE_CACHE_SIZE, (page));
147 : : }
148 : :
149 : 0 : static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
150 : : {
151 : 0 : return queue_var_show(queue_logical_block_size(q), page);
152 : : }
153 : :
154 : 0 : static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
155 : : {
156 : 0 : return queue_var_show(queue_physical_block_size(q), page);
157 : : }
158 : :
159 : 0 : static ssize_t queue_io_min_show(struct request_queue *q, char *page)
160 : : {
161 : 0 : return queue_var_show(queue_io_min(q), page);
162 : : }
163 : :
164 : 0 : static ssize_t queue_io_opt_show(struct request_queue *q, char *page)
165 : : {
166 : 0 : return queue_var_show(queue_io_opt(q), page);
167 : : }
168 : :
169 : 0 : static ssize_t queue_discard_granularity_show(struct request_queue *q, char *page)
170 : : {
171 : 0 : return queue_var_show(q->limits.discard_granularity, page);
172 : : }
173 : :
174 : 0 : static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
175 : : {
176 : 0 : return sprintf(page, "%llu\n",
177 : 0 : (unsigned long long)q->limits.max_discard_sectors << 9);
178 : : }
179 : :
180 : 0 : static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
181 : : {
182 : 0 : return queue_var_show(queue_discard_zeroes_data(q), page);
183 : : }
184 : :
185 : 0 : static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
186 : : {
187 : 0 : return sprintf(page, "%llu\n",
188 : 0 : (unsigned long long)q->limits.max_write_same_sectors << 9);
189 : : }
190 : :
191 : :
192 : : static ssize_t
193 : 0 : queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
194 : : {
195 : : unsigned long max_sectors_kb,
196 : 0 : max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
197 : : page_kb = 1 << (PAGE_CACHE_SHIFT - 10);
198 : : ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
199 : :
200 [ # # ]: 0 : if (ret < 0)
201 : : return ret;
202 : :
203 [ # # ][ # # ]: 0 : if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
204 : : return -EINVAL;
205 : :
206 : 0 : spin_lock_irq(q->queue_lock);
207 : 0 : q->limits.max_sectors = max_sectors_kb << 1;
208 : 0 : spin_unlock_irq(q->queue_lock);
209 : :
210 : 0 : return ret;
211 : : }
212 : :
213 : 0 : static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
214 : : {
215 : 0 : int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
216 : :
217 : 0 : return queue_var_show(max_hw_sectors_kb, (page));
218 : : }
219 : :
220 : : #define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
221 : : static ssize_t \
222 : : queue_show_##name(struct request_queue *q, char *page) \
223 : : { \
224 : : int bit; \
225 : : bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
226 : : return queue_var_show(neg ? !bit : bit, page); \
227 : : } \
228 : : static ssize_t \
229 : : queue_store_##name(struct request_queue *q, const char *page, size_t count) \
230 : : { \
231 : : unsigned long val; \
232 : : ssize_t ret; \
233 : : ret = queue_var_store(&val, page, count); \
234 : : if (ret < 0) \
235 : : return ret; \
236 : : if (neg) \
237 : : val = !val; \
238 : : \
239 : : spin_lock_irq(q->queue_lock); \
240 : : if (val) \
241 : : queue_flag_set(QUEUE_FLAG_##flag, q); \
242 : : else \
243 : : queue_flag_clear(QUEUE_FLAG_##flag, q); \
244 : : spin_unlock_irq(q->queue_lock); \
245 : : return ret; \
246 : : }
247 : :
248 [ # # # # ]: 0 : QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
249 [ # # # # ]: 0 : QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
250 [ # # # # ]: 0 : QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
251 : : #undef QUEUE_SYSFS_BIT_FNS
252 : :
253 : 0 : static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
254 : : {
255 : 0 : return queue_var_show((blk_queue_nomerges(q) << 1) |
256 : : blk_queue_noxmerges(q), page);
257 : : }
258 : :
259 : 0 : static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
260 : : size_t count)
261 : : {
262 : : unsigned long nm;
263 : : ssize_t ret = queue_var_store(&nm, page, count);
264 : :
265 [ # # ]: 0 : if (ret < 0)
266 : : return ret;
267 : :
268 : 0 : spin_lock_irq(q->queue_lock);
269 : : queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
270 : : queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
271 [ # # ]: 0 : if (nm == 2)
272 : : queue_flag_set(QUEUE_FLAG_NOMERGES, q);
273 [ # # ]: 0 : else if (nm)
274 : : queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
275 : 0 : spin_unlock_irq(q->queue_lock);
276 : :
277 : 0 : return ret;
278 : : }
279 : :
280 : 0 : static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
281 : : {
282 : 0 : bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
283 : 0 : bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
284 : :
285 : 0 : return queue_var_show(set << force, page);
286 : : }
287 : :
288 : : static ssize_t
289 : 0 : queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
290 : : {
291 : : ssize_t ret = -EINVAL;
292 : : #ifdef CONFIG_SMP
293 : : unsigned long val;
294 : :
295 : : ret = queue_var_store(&val, page, count);
296 [ # # ]: 0 : if (ret < 0)
297 : : return ret;
298 : :
299 : 0 : spin_lock_irq(q->queue_lock);
300 [ # # ]: 0 : if (val == 2) {
301 : : queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
302 : : queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
303 [ # # ]: 0 : } else if (val == 1) {
304 : : queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
305 : : queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
306 [ # # ]: 0 : } else if (val == 0) {
307 : : queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
308 : : queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
309 : : }
310 : 0 : spin_unlock_irq(q->queue_lock);
311 : : #endif
312 : 0 : return ret;
313 : : }
314 : :
315 : : static struct queue_sysfs_entry queue_requests_entry = {
316 : : .attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR },
317 : : .show = queue_requests_show,
318 : : .store = queue_requests_store,
319 : : };
320 : :
321 : : static struct queue_sysfs_entry queue_ra_entry = {
322 : : .attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },
323 : : .show = queue_ra_show,
324 : : .store = queue_ra_store,
325 : : };
326 : :
327 : : static struct queue_sysfs_entry queue_max_sectors_entry = {
328 : : .attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },
329 : : .show = queue_max_sectors_show,
330 : : .store = queue_max_sectors_store,
331 : : };
332 : :
333 : : static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
334 : : .attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO },
335 : : .show = queue_max_hw_sectors_show,
336 : : };
337 : :
338 : : static struct queue_sysfs_entry queue_max_segments_entry = {
339 : : .attr = {.name = "max_segments", .mode = S_IRUGO },
340 : : .show = queue_max_segments_show,
341 : : };
342 : :
343 : : static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
344 : : .attr = {.name = "max_integrity_segments", .mode = S_IRUGO },
345 : : .show = queue_max_integrity_segments_show,
346 : : };
347 : :
348 : : static struct queue_sysfs_entry queue_max_segment_size_entry = {
349 : : .attr = {.name = "max_segment_size", .mode = S_IRUGO },
350 : : .show = queue_max_segment_size_show,
351 : : };
352 : :
353 : : static struct queue_sysfs_entry queue_iosched_entry = {
354 : : .attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR },
355 : : .show = elv_iosched_show,
356 : : .store = elv_iosched_store,
357 : : };
358 : :
359 : : static struct queue_sysfs_entry queue_hw_sector_size_entry = {
360 : : .attr = {.name = "hw_sector_size", .mode = S_IRUGO },
361 : : .show = queue_logical_block_size_show,
362 : : };
363 : :
364 : : static struct queue_sysfs_entry queue_logical_block_size_entry = {
365 : : .attr = {.name = "logical_block_size", .mode = S_IRUGO },
366 : : .show = queue_logical_block_size_show,
367 : : };
368 : :
369 : : static struct queue_sysfs_entry queue_physical_block_size_entry = {
370 : : .attr = {.name = "physical_block_size", .mode = S_IRUGO },
371 : : .show = queue_physical_block_size_show,
372 : : };
373 : :
374 : : static struct queue_sysfs_entry queue_io_min_entry = {
375 : : .attr = {.name = "minimum_io_size", .mode = S_IRUGO },
376 : : .show = queue_io_min_show,
377 : : };
378 : :
379 : : static struct queue_sysfs_entry queue_io_opt_entry = {
380 : : .attr = {.name = "optimal_io_size", .mode = S_IRUGO },
381 : : .show = queue_io_opt_show,
382 : : };
383 : :
384 : : static struct queue_sysfs_entry queue_discard_granularity_entry = {
385 : : .attr = {.name = "discard_granularity", .mode = S_IRUGO },
386 : : .show = queue_discard_granularity_show,
387 : : };
388 : :
389 : : static struct queue_sysfs_entry queue_discard_max_entry = {
390 : : .attr = {.name = "discard_max_bytes", .mode = S_IRUGO },
391 : : .show = queue_discard_max_show,
392 : : };
393 : :
394 : : static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
395 : : .attr = {.name = "discard_zeroes_data", .mode = S_IRUGO },
396 : : .show = queue_discard_zeroes_data_show,
397 : : };
398 : :
399 : : static struct queue_sysfs_entry queue_write_same_max_entry = {
400 : : .attr = {.name = "write_same_max_bytes", .mode = S_IRUGO },
401 : : .show = queue_write_same_max_show,
402 : : };
403 : :
404 : : static struct queue_sysfs_entry queue_nonrot_entry = {
405 : : .attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR },
406 : : .show = queue_show_nonrot,
407 : : .store = queue_store_nonrot,
408 : : };
409 : :
410 : : static struct queue_sysfs_entry queue_nomerges_entry = {
411 : : .attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR },
412 : : .show = queue_nomerges_show,
413 : : .store = queue_nomerges_store,
414 : : };
415 : :
416 : : static struct queue_sysfs_entry queue_rq_affinity_entry = {
417 : : .attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR },
418 : : .show = queue_rq_affinity_show,
419 : : .store = queue_rq_affinity_store,
420 : : };
421 : :
422 : : static struct queue_sysfs_entry queue_iostats_entry = {
423 : : .attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR },
424 : : .show = queue_show_iostats,
425 : : .store = queue_store_iostats,
426 : : };
427 : :
428 : : static struct queue_sysfs_entry queue_random_entry = {
429 : : .attr = {.name = "add_random", .mode = S_IRUGO | S_IWUSR },
430 : : .show = queue_show_random,
431 : : .store = queue_store_random,
432 : : };
433 : :
434 : : static struct attribute *default_attrs[] = {
435 : : &queue_requests_entry.attr,
436 : : &queue_ra_entry.attr,
437 : : &queue_max_hw_sectors_entry.attr,
438 : : &queue_max_sectors_entry.attr,
439 : : &queue_max_segments_entry.attr,
440 : : &queue_max_integrity_segments_entry.attr,
441 : : &queue_max_segment_size_entry.attr,
442 : : &queue_iosched_entry.attr,
443 : : &queue_hw_sector_size_entry.attr,
444 : : &queue_logical_block_size_entry.attr,
445 : : &queue_physical_block_size_entry.attr,
446 : : &queue_io_min_entry.attr,
447 : : &queue_io_opt_entry.attr,
448 : : &queue_discard_granularity_entry.attr,
449 : : &queue_discard_max_entry.attr,
450 : : &queue_discard_zeroes_data_entry.attr,
451 : : &queue_write_same_max_entry.attr,
452 : : &queue_nonrot_entry.attr,
453 : : &queue_nomerges_entry.attr,
454 : : &queue_rq_affinity_entry.attr,
455 : : &queue_iostats_entry.attr,
456 : : &queue_random_entry.attr,
457 : : NULL,
458 : : };
459 : :
460 : : #define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
461 : :
462 : : static ssize_t
463 : 0 : queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
464 : : {
465 : : struct queue_sysfs_entry *entry = to_queue(attr);
466 : 0 : struct request_queue *q =
467 : : container_of(kobj, struct request_queue, kobj);
468 : : ssize_t res;
469 : :
470 [ # # ]: 0 : if (!entry->show)
471 : : return -EIO;
472 : 0 : mutex_lock(&q->sysfs_lock);
473 [ # # ]: 0 : if (blk_queue_dying(q)) {
474 : 0 : mutex_unlock(&q->sysfs_lock);
475 : 0 : return -ENOENT;
476 : : }
477 : 0 : res = entry->show(q, page);
478 : 0 : mutex_unlock(&q->sysfs_lock);
479 : 0 : return res;
480 : : }
481 : :
482 : : static ssize_t
483 : 0 : queue_attr_store(struct kobject *kobj, struct attribute *attr,
484 : : const char *page, size_t length)
485 : : {
486 : : struct queue_sysfs_entry *entry = to_queue(attr);
487 : : struct request_queue *q;
488 : : ssize_t res;
489 : :
490 [ # # ]: 0 : if (!entry->store)
491 : : return -EIO;
492 : :
493 : 0 : q = container_of(kobj, struct request_queue, kobj);
494 : 0 : mutex_lock(&q->sysfs_lock);
495 [ # # ]: 0 : if (blk_queue_dying(q)) {
496 : 0 : mutex_unlock(&q->sysfs_lock);
497 : 0 : return -ENOENT;
498 : : }
499 : 0 : res = entry->store(q, page, length);
500 : 0 : mutex_unlock(&q->sysfs_lock);
501 : 0 : return res;
502 : : }
503 : :
504 : 0 : static void blk_free_queue_rcu(struct rcu_head *rcu_head)
505 : : {
506 : 0 : struct request_queue *q = container_of(rcu_head, struct request_queue,
507 : : rcu_head);
508 : 0 : kmem_cache_free(blk_requestq_cachep, q);
509 : 0 : }
510 : :
511 : : /**
512 : : * blk_release_queue: - release a &struct request_queue when it is no longer needed
513 : : * @kobj: the kobj belonging to the request queue to be released
514 : : *
515 : : * Description:
516 : : * blk_release_queue is the pair to blk_init_queue() or
517 : : * blk_queue_make_request(). It should be called when a request queue is
518 : : * being released; typically when a block device is being de-registered.
519 : : * Currently, its primary task it to free all the &struct request
520 : : * structures that were allocated to the queue and the queue itself.
521 : : *
522 : : * Caveat:
523 : : * Hopefully the low level driver will have finished any
524 : : * outstanding requests first...
525 : : **/
526 : 0 : static void blk_release_queue(struct kobject *kobj)
527 : : {
528 : 0 : struct request_queue *q =
529 : : container_of(kobj, struct request_queue, kobj);
530 : :
531 : 0 : blk_sync_queue(q);
532 : :
533 : : blkcg_exit_queue(q);
534 : :
535 [ # # ]: 0 : if (q->elevator) {
536 : 0 : spin_lock_irq(q->queue_lock);
537 : 0 : ioc_clear_queue(q);
538 : 0 : spin_unlock_irq(q->queue_lock);
539 : 0 : elevator_exit(q->elevator);
540 : : }
541 : :
542 : 0 : blk_exit_rl(&q->root_rl);
543 : :
544 [ # # ]: 0 : if (q->queue_tags)
545 : 0 : __blk_queue_free_tags(q);
546 : :
547 : 0 : percpu_counter_destroy(&q->mq_usage_counter);
548 : :
549 [ # # ]: 0 : if (q->mq_ops)
550 : 0 : blk_mq_free_queue(q);
551 : :
552 : 0 : kfree(q->flush_rq);
553 : :
554 : : blk_trace_shutdown(q);
555 : :
556 : 0 : bdi_destroy(&q->backing_dev_info);
557 : :
558 : 0 : ida_simple_remove(&blk_queue_ida, q->id);
559 : 0 : call_rcu(&q->rcu_head, blk_free_queue_rcu);
560 : 0 : }
561 : :
562 : : static const struct sysfs_ops queue_sysfs_ops = {
563 : : .show = queue_attr_show,
564 : : .store = queue_attr_store,
565 : : };
566 : :
567 : : struct kobj_type blk_queue_ktype = {
568 : : .sysfs_ops = &queue_sysfs_ops,
569 : : .default_attrs = default_attrs,
570 : : .release = blk_release_queue,
571 : : };
572 : :
573 : 0 : int blk_register_queue(struct gendisk *disk)
574 : : {
575 : : int ret;
576 : : struct device *dev = disk_to_dev(disk);
577 : 0 : struct request_queue *q = disk->queue;
578 : :
579 [ # # ][ # # ]: 0 : if (WARN_ON(!q))
580 : : return -ENXIO;
581 : :
582 : : /*
583 : : * Initialization must be complete by now. Finish the initial
584 : : * bypass from queue allocation.
585 : : */
586 : 0 : blk_queue_bypass_end(q);
587 : : queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
588 : :
589 : : ret = blk_trace_init_sysfs(dev);
590 : : if (ret)
591 : : return ret;
592 : :
593 : 0 : ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
594 [ # # ]: 0 : if (ret < 0) {
595 : : blk_trace_remove_sysfs(dev);
596 : : return ret;
597 : : }
598 : :
599 : 0 : kobject_uevent(&q->kobj, KOBJ_ADD);
600 : :
601 [ # # ]: 0 : if (q->mq_ops)
602 : 0 : blk_mq_register_disk(disk);
603 : :
604 [ # # ]: 0 : if (!q->request_fn)
605 : : return 0;
606 : :
607 : 0 : ret = elv_register_queue(q);
608 [ # # ]: 0 : if (ret) {
609 : 0 : kobject_uevent(&q->kobj, KOBJ_REMOVE);
610 : 0 : kobject_del(&q->kobj);
611 : : blk_trace_remove_sysfs(dev);
612 : 0 : kobject_put(&dev->kobj);
613 : 0 : return ret;
614 : : }
615 : :
616 : : return 0;
617 : : }
618 : :
619 : 0 : void blk_unregister_queue(struct gendisk *disk)
620 : : {
621 : 0 : struct request_queue *q = disk->queue;
622 : :
623 [ # # ][ # # ]: 0 : if (WARN_ON(!q))
624 : 0 : return;
625 : :
626 [ # # ]: 0 : if (q->mq_ops)
627 : 0 : blk_mq_unregister_disk(disk);
628 : :
629 [ # # ]: 0 : if (q->request_fn)
630 : 0 : elv_unregister_queue(q);
631 : :
632 : 0 : kobject_uevent(&q->kobj, KOBJ_REMOVE);
633 : 0 : kobject_del(&q->kobj);
634 : : blk_trace_remove_sysfs(disk_to_dev(disk));
635 : 0 : kobject_put(&disk_to_dev(disk)->kobj);
636 : : }
|
