2 * Functions related to sysfs handling
4 #include <linux/kernel.h>
5 #include <linux/slab.h>
6 #include <linux/module.h>
8 #include <linux/blkdev.h>
9 #include <linux/blktrace_api.h>
13 struct queue_sysfs_entry
{
14 struct attribute attr
;
15 ssize_t (*show
)(struct request_queue
*, char *);
16 ssize_t (*store
)(struct request_queue
*, const char *, size_t);
20 queue_var_show(unsigned long var
, char *page
)
22 return sprintf(page
, "%lu\n", var
);
26 queue_var_store(unsigned long *var
, const char *page
, size_t count
)
28 char *p
= (char *) page
;
30 *var
= simple_strtoul(p
, &p
, 10);
34 static ssize_t
queue_requests_show(struct request_queue
*q
, char *page
)
36 return queue_var_show(q
->nr_requests
, (page
));
40 queue_requests_store(struct request_queue
*q
, const char *page
, size_t count
)
42 struct request_list
*rl
= &q
->rq
;
49 ret
= queue_var_store(&nr
, page
, count
);
50 if (nr
< BLKDEV_MIN_RQ
)
53 spin_lock_irq(q
->queue_lock
);
55 blk_queue_congestion_threshold(q
);
57 if (rl
->count
[BLK_RW_SYNC
] >= queue_congestion_on_threshold(q
))
58 blk_set_queue_congested(q
, BLK_RW_SYNC
);
59 else if (rl
->count
[BLK_RW_SYNC
] < queue_congestion_off_threshold(q
))
60 blk_clear_queue_congested(q
, BLK_RW_SYNC
);
62 if (rl
->count
[BLK_RW_ASYNC
] >= queue_congestion_on_threshold(q
))
63 blk_set_queue_congested(q
, BLK_RW_ASYNC
);
64 else if (rl
->count
[BLK_RW_ASYNC
] < queue_congestion_off_threshold(q
))
65 blk_clear_queue_congested(q
, BLK_RW_ASYNC
);
67 if (rl
->count
[BLK_RW_SYNC
] >= q
->nr_requests
) {
68 blk_set_queue_full(q
, BLK_RW_SYNC
);
70 blk_clear_queue_full(q
, BLK_RW_SYNC
);
71 wake_up(&rl
->wait
[BLK_RW_SYNC
]);
74 if (rl
->count
[BLK_RW_ASYNC
] >= q
->nr_requests
) {
75 blk_set_queue_full(q
, BLK_RW_ASYNC
);
77 blk_clear_queue_full(q
, BLK_RW_ASYNC
);
78 wake_up(&rl
->wait
[BLK_RW_ASYNC
]);
80 spin_unlock_irq(q
->queue_lock
);
84 static ssize_t
queue_ra_show(struct request_queue
*q
, char *page
)
86 unsigned long ra_kb
= q
->backing_dev_info
.ra_pages
<<
87 (PAGE_CACHE_SHIFT
- 10);
89 return queue_var_show(ra_kb
, (page
));
93 queue_ra_store(struct request_queue
*q
, const char *page
, size_t count
)
96 ssize_t ret
= queue_var_store(&ra_kb
, page
, count
);
98 q
->backing_dev_info
.ra_pages
= ra_kb
>> (PAGE_CACHE_SHIFT
- 10);
103 static ssize_t
queue_max_sectors_show(struct request_queue
*q
, char *page
)
105 int max_sectors_kb
= queue_max_sectors(q
) >> 1;
107 return queue_var_show(max_sectors_kb
, (page
));
110 static ssize_t
queue_max_segments_show(struct request_queue
*q
, char *page
)
112 return queue_var_show(queue_max_segments(q
), (page
));
115 static ssize_t
queue_max_integrity_segments_show(struct request_queue
*q
, char *page
)
117 return queue_var_show(q
->limits
.max_integrity_segments
, (page
));
120 static ssize_t
queue_max_segment_size_show(struct request_queue
*q
, char *page
)
122 if (blk_queue_cluster(q
))
123 return queue_var_show(queue_max_segment_size(q
), (page
));
125 return queue_var_show(PAGE_CACHE_SIZE
, (page
));
128 static ssize_t
queue_logical_block_size_show(struct request_queue
*q
, char *page
)
130 return queue_var_show(queue_logical_block_size(q
), page
);
133 static ssize_t
queue_physical_block_size_show(struct request_queue
*q
, char *page
)
135 return queue_var_show(queue_physical_block_size(q
), page
);
138 static ssize_t
queue_io_min_show(struct request_queue
*q
, char *page
)
140 return queue_var_show(queue_io_min(q
), page
);
143 static ssize_t
queue_io_opt_show(struct request_queue
*q
, char *page
)
145 return queue_var_show(queue_io_opt(q
), page
);
148 static ssize_t
queue_discard_granularity_show(struct request_queue
*q
, char *page
)
150 return queue_var_show(q
->limits
.discard_granularity
, page
);
153 static ssize_t
queue_discard_max_show(struct request_queue
*q
, char *page
)
155 return sprintf(page
, "%llu\n",
156 (unsigned long long)q
->limits
.max_discard_sectors
<< 9);
159 static ssize_t
queue_discard_zeroes_data_show(struct request_queue
*q
, char *page
)
161 return queue_var_show(queue_discard_zeroes_data(q
), page
);
165 queue_max_sectors_store(struct request_queue
*q
, const char *page
, size_t count
)
167 unsigned long max_sectors_kb
,
168 max_hw_sectors_kb
= queue_max_hw_sectors(q
) >> 1,
169 page_kb
= 1 << (PAGE_CACHE_SHIFT
- 10);
170 ssize_t ret
= queue_var_store(&max_sectors_kb
, page
, count
);
172 if (max_sectors_kb
> max_hw_sectors_kb
|| max_sectors_kb
< page_kb
)
175 spin_lock_irq(q
->queue_lock
);
176 q
->limits
.max_sectors
= max_sectors_kb
<< 1;
177 spin_unlock_irq(q
->queue_lock
);
182 static ssize_t
queue_max_hw_sectors_show(struct request_queue
*q
, char *page
)
184 int max_hw_sectors_kb
= queue_max_hw_sectors(q
) >> 1;
186 return queue_var_show(max_hw_sectors_kb
, (page
));
189 #define QUEUE_SYSFS_BIT_FNS(name, flag, neg) \
191 queue_show_##name(struct request_queue *q, char *page) \
194 bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags); \
195 return queue_var_show(neg ? !bit : bit, page); \
198 queue_store_##name(struct request_queue *q, const char *page, size_t count) \
202 ret = queue_var_store(&val, page, count); \
206 spin_lock_irq(q->queue_lock); \
208 queue_flag_set(QUEUE_FLAG_##flag, q); \
210 queue_flag_clear(QUEUE_FLAG_##flag, q); \
211 spin_unlock_irq(q->queue_lock); \
215 QUEUE_SYSFS_BIT_FNS(nonrot
, NONROT
, 1);
216 QUEUE_SYSFS_BIT_FNS(random
, ADD_RANDOM
, 0);
217 QUEUE_SYSFS_BIT_FNS(iostats
, IO_STAT
, 0);
218 #undef QUEUE_SYSFS_BIT_FNS
220 static ssize_t
queue_nomerges_show(struct request_queue
*q
, char *page
)
222 return queue_var_show((blk_queue_nomerges(q
) << 1) |
223 blk_queue_noxmerges(q
), page
);
226 static ssize_t
queue_nomerges_store(struct request_queue
*q
, const char *page
,
230 ssize_t ret
= queue_var_store(&nm
, page
, count
);
232 spin_lock_irq(q
->queue_lock
);
233 queue_flag_clear(QUEUE_FLAG_NOMERGES
, q
);
234 queue_flag_clear(QUEUE_FLAG_NOXMERGES
, q
);
236 queue_flag_set(QUEUE_FLAG_NOMERGES
, q
);
238 queue_flag_set(QUEUE_FLAG_NOXMERGES
, q
);
239 spin_unlock_irq(q
->queue_lock
);
244 static ssize_t
queue_rq_affinity_show(struct request_queue
*q
, char *page
)
246 bool set
= test_bit(QUEUE_FLAG_SAME_COMP
, &q
->queue_flags
);
247 bool force
= test_bit(QUEUE_FLAG_SAME_FORCE
, &q
->queue_flags
);
249 return queue_var_show(set
<< force
, page
);
253 queue_rq_affinity_store(struct request_queue
*q
, const char *page
, size_t count
)
255 ssize_t ret
= -EINVAL
;
256 #if defined(CONFIG_USE_GENERIC_SMP_HELPERS)
259 ret
= queue_var_store(&val
, page
, count
);
260 spin_lock_irq(q
->queue_lock
);
262 queue_flag_set(QUEUE_FLAG_SAME_COMP
, q
);
263 queue_flag_set(QUEUE_FLAG_SAME_FORCE
, q
);
264 } else if (val
== 1) {
265 queue_flag_set(QUEUE_FLAG_SAME_COMP
, q
);
266 queue_flag_clear(QUEUE_FLAG_SAME_FORCE
, q
);
267 } else if (val
== 0) {
268 queue_flag_clear(QUEUE_FLAG_SAME_COMP
, q
);
269 queue_flag_clear(QUEUE_FLAG_SAME_FORCE
, q
);
271 spin_unlock_irq(q
->queue_lock
);
276 static struct queue_sysfs_entry queue_requests_entry
= {
277 .attr
= {.name
= "nr_requests", .mode
= S_IRUGO
| S_IWUSR
},
278 .show
= queue_requests_show
,
279 .store
= queue_requests_store
,
282 static struct queue_sysfs_entry queue_ra_entry
= {
283 .attr
= {.name
= "read_ahead_kb", .mode
= S_IRUGO
| S_IWUSR
},
284 .show
= queue_ra_show
,
285 .store
= queue_ra_store
,
288 static struct queue_sysfs_entry queue_max_sectors_entry
= {
289 .attr
= {.name
= "max_sectors_kb", .mode
= S_IRUGO
| S_IWUSR
},
290 .show
= queue_max_sectors_show
,
291 .store
= queue_max_sectors_store
,
294 static struct queue_sysfs_entry queue_max_hw_sectors_entry
= {
295 .attr
= {.name
= "max_hw_sectors_kb", .mode
= S_IRUGO
},
296 .show
= queue_max_hw_sectors_show
,
299 static struct queue_sysfs_entry queue_max_segments_entry
= {
300 .attr
= {.name
= "max_segments", .mode
= S_IRUGO
},
301 .show
= queue_max_segments_show
,
304 static struct queue_sysfs_entry queue_max_integrity_segments_entry
= {
305 .attr
= {.name
= "max_integrity_segments", .mode
= S_IRUGO
},
306 .show
= queue_max_integrity_segments_show
,
309 static struct queue_sysfs_entry queue_max_segment_size_entry
= {
310 .attr
= {.name
= "max_segment_size", .mode
= S_IRUGO
},
311 .show
= queue_max_segment_size_show
,
314 static struct queue_sysfs_entry queue_iosched_entry
= {
315 .attr
= {.name
= "scheduler", .mode
= S_IRUGO
| S_IWUSR
},
316 .show
= elv_iosched_show
,
317 .store
= elv_iosched_store
,
320 static struct queue_sysfs_entry queue_hw_sector_size_entry
= {
321 .attr
= {.name
= "hw_sector_size", .mode
= S_IRUGO
},
322 .show
= queue_logical_block_size_show
,
325 static struct queue_sysfs_entry queue_logical_block_size_entry
= {
326 .attr
= {.name
= "logical_block_size", .mode
= S_IRUGO
},
327 .show
= queue_logical_block_size_show
,
330 static struct queue_sysfs_entry queue_physical_block_size_entry
= {
331 .attr
= {.name
= "physical_block_size", .mode
= S_IRUGO
},
332 .show
= queue_physical_block_size_show
,
335 static struct queue_sysfs_entry queue_io_min_entry
= {
336 .attr
= {.name
= "minimum_io_size", .mode
= S_IRUGO
},
337 .show
= queue_io_min_show
,
340 static struct queue_sysfs_entry queue_io_opt_entry
= {
341 .attr
= {.name
= "optimal_io_size", .mode
= S_IRUGO
},
342 .show
= queue_io_opt_show
,
345 static struct queue_sysfs_entry queue_discard_granularity_entry
= {
346 .attr
= {.name
= "discard_granularity", .mode
= S_IRUGO
},
347 .show
= queue_discard_granularity_show
,
350 static struct queue_sysfs_entry queue_discard_max_entry
= {
351 .attr
= {.name
= "discard_max_bytes", .mode
= S_IRUGO
},
352 .show
= queue_discard_max_show
,
355 static struct queue_sysfs_entry queue_discard_zeroes_data_entry
= {
356 .attr
= {.name
= "discard_zeroes_data", .mode
= S_IRUGO
},
357 .show
= queue_discard_zeroes_data_show
,
360 static struct queue_sysfs_entry queue_nonrot_entry
= {
361 .attr
= {.name
= "rotational", .mode
= S_IRUGO
| S_IWUSR
},
362 .show
= queue_show_nonrot
,
363 .store
= queue_store_nonrot
,
366 static struct queue_sysfs_entry queue_nomerges_entry
= {
367 .attr
= {.name
= "nomerges", .mode
= S_IRUGO
| S_IWUSR
},
368 .show
= queue_nomerges_show
,
369 .store
= queue_nomerges_store
,
372 static struct queue_sysfs_entry queue_rq_affinity_entry
= {
373 .attr
= {.name
= "rq_affinity", .mode
= S_IRUGO
| S_IWUSR
},
374 .show
= queue_rq_affinity_show
,
375 .store
= queue_rq_affinity_store
,
378 static struct queue_sysfs_entry queue_iostats_entry
= {
379 .attr
= {.name
= "iostats", .mode
= S_IRUGO
| S_IWUSR
},
380 .show
= queue_show_iostats
,
381 .store
= queue_store_iostats
,
384 static struct queue_sysfs_entry queue_random_entry
= {
385 .attr
= {.name
= "add_random", .mode
= S_IRUGO
| S_IWUSR
},
386 .show
= queue_show_random
,
387 .store
= queue_store_random
,
390 static struct attribute
*default_attrs
[] = {
391 &queue_requests_entry
.attr
,
392 &queue_ra_entry
.attr
,
393 &queue_max_hw_sectors_entry
.attr
,
394 &queue_max_sectors_entry
.attr
,
395 &queue_max_segments_entry
.attr
,
396 &queue_max_integrity_segments_entry
.attr
,
397 &queue_max_segment_size_entry
.attr
,
398 &queue_iosched_entry
.attr
,
399 &queue_hw_sector_size_entry
.attr
,
400 &queue_logical_block_size_entry
.attr
,
401 &queue_physical_block_size_entry
.attr
,
402 &queue_io_min_entry
.attr
,
403 &queue_io_opt_entry
.attr
,
404 &queue_discard_granularity_entry
.attr
,
405 &queue_discard_max_entry
.attr
,
406 &queue_discard_zeroes_data_entry
.attr
,
407 &queue_nonrot_entry
.attr
,
408 &queue_nomerges_entry
.attr
,
409 &queue_rq_affinity_entry
.attr
,
410 &queue_iostats_entry
.attr
,
411 &queue_random_entry
.attr
,
415 #define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
418 queue_attr_show(struct kobject
*kobj
, struct attribute
*attr
, char *page
)
420 struct queue_sysfs_entry
*entry
= to_queue(attr
);
421 struct request_queue
*q
=
422 container_of(kobj
, struct request_queue
, kobj
);
427 mutex_lock(&q
->sysfs_lock
);
428 if (test_bit(QUEUE_FLAG_DEAD
, &q
->queue_flags
)) {
429 mutex_unlock(&q
->sysfs_lock
);
432 res
= entry
->show(q
, page
);
433 mutex_unlock(&q
->sysfs_lock
);
438 queue_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
439 const char *page
, size_t length
)
441 struct queue_sysfs_entry
*entry
= to_queue(attr
);
442 struct request_queue
*q
;
448 q
= container_of(kobj
, struct request_queue
, kobj
);
449 mutex_lock(&q
->sysfs_lock
);
450 if (test_bit(QUEUE_FLAG_DEAD
, &q
->queue_flags
)) {
451 mutex_unlock(&q
->sysfs_lock
);
454 res
= entry
->store(q
, page
, length
);
455 mutex_unlock(&q
->sysfs_lock
);
460 * blk_release_queue: - release a &struct request_queue when it is no longer needed
461 * @kobj: the kobj belonging to the request queue to be released
464 * blk_release_queue is the pair to blk_init_queue() or
465 * blk_queue_make_request(). It should be called when a request queue is
466 * being released; typically when a block device is being de-registered.
467 * Currently, its primary task it to free all the &struct request
468 * structures that were allocated to the queue and the queue itself.
471 * Hopefully the low level driver will have finished any
472 * outstanding requests first...
474 static void blk_release_queue(struct kobject
*kobj
)
476 struct request_queue
*q
=
477 container_of(kobj
, struct request_queue
, kobj
);
478 struct request_list
*rl
= &q
->rq
;
483 elevator_exit(q
->elevator
);
488 mempool_destroy(rl
->rq_pool
);
491 __blk_queue_free_tags(q
);
493 blk_throtl_release(q
);
494 blk_trace_shutdown(q
);
496 bdi_destroy(&q
->backing_dev_info
);
497 kmem_cache_free(blk_requestq_cachep
, q
);
500 static const struct sysfs_ops queue_sysfs_ops
= {
501 .show
= queue_attr_show
,
502 .store
= queue_attr_store
,
505 struct kobj_type blk_queue_ktype
= {
506 .sysfs_ops
= &queue_sysfs_ops
,
507 .default_attrs
= default_attrs
,
508 .release
= blk_release_queue
,
511 int blk_register_queue(struct gendisk
*disk
)
514 struct device
*dev
= disk_to_dev(disk
);
515 struct request_queue
*q
= disk
->queue
;
520 ret
= blk_trace_init_sysfs(dev
);
524 ret
= kobject_add(&q
->kobj
, kobject_get(&dev
->kobj
), "%s", "queue");
526 blk_trace_remove_sysfs(dev
);
530 kobject_uevent(&q
->kobj
, KOBJ_ADD
);
535 ret
= elv_register_queue(q
);
537 kobject_uevent(&q
->kobj
, KOBJ_REMOVE
);
538 kobject_del(&q
->kobj
);
539 blk_trace_remove_sysfs(dev
);
540 kobject_put(&dev
->kobj
);
547 void blk_unregister_queue(struct gendisk
*disk
)
549 struct request_queue
*q
= disk
->queue
;
555 elv_unregister_queue(q
);
557 kobject_uevent(&q
->kobj
, KOBJ_REMOVE
);
558 kobject_del(&q
->kobj
);
559 blk_trace_remove_sysfs(disk_to_dev(disk
));
560 kobject_put(&disk_to_dev(disk
)->kobj
);