1 /* 2 * Functions related to sysfs handling 3 */ 4 #include <linux/kernel.h> 5 #include <linux/module.h> 6 #include <linux/bio.h> 7 #include <linux/blkdev.h> 8 #include <linux/blktrace_api.h> 9 10 #include "blk.h" 11 12 struct queue_sysfs_entry { 13 struct attribute attr; 14 ssize_t (*show)(struct request_queue *, char *); 15 ssize_t (*store)(struct request_queue *, const char *, size_t); 16 }; 17 18 static ssize_t 19 queue_var_show(unsigned long var, char *page) 20 { 21 return sprintf(page, "%lu\n", var); 22 } 23 24 static ssize_t 25 queue_var_store(unsigned long *var, const char *page, size_t count) 26 { 27 char *p = (char *) page; 28 29 *var = simple_strtoul(p, &p, 10); 30 return count; 31 } 32 33 static ssize_t queue_requests_show(struct request_queue *q, char *page) 34 { 35 return queue_var_show(q->nr_requests, (page)); 36 } 37 38 static ssize_t 39 queue_requests_store(struct request_queue *q, const char *page, size_t count) 40 { 41 struct request_list *rl = &q->rq; 42 unsigned long nr; 43 int ret; 44 45 if (!q->request_fn) 46 return -EINVAL; 47 48 ret = queue_var_store(&nr, page, count); 49 if (nr < BLKDEV_MIN_RQ) 50 nr = BLKDEV_MIN_RQ; 51 52 spin_lock_irq(q->queue_lock); 53 q->nr_requests = nr; 54 blk_queue_congestion_threshold(q); 55 56 if (rl->count[BLK_RW_SYNC] >= queue_congestion_on_threshold(q)) 57 blk_set_queue_congested(q, BLK_RW_SYNC); 58 else if (rl->count[BLK_RW_SYNC] < queue_congestion_off_threshold(q)) 59 blk_clear_queue_congested(q, BLK_RW_SYNC); 60 61 if (rl->count[BLK_RW_ASYNC] >= queue_congestion_on_threshold(q)) 62 blk_set_queue_congested(q, BLK_RW_ASYNC); 63 else if (rl->count[BLK_RW_ASYNC] < queue_congestion_off_threshold(q)) 64 blk_clear_queue_congested(q, BLK_RW_ASYNC); 65 66 if (rl->count[BLK_RW_SYNC] >= q->nr_requests) { 67 blk_set_queue_full(q, BLK_RW_SYNC); 68 } else if (rl->count[BLK_RW_SYNC]+1 <= q->nr_requests) { 69 blk_clear_queue_full(q, BLK_RW_SYNC); 70 wake_up(&rl->wait[BLK_RW_SYNC]); 71 } 72 73 if (rl->count[BLK_RW_ASYNC] >= q->nr_requests) { 74 blk_set_queue_full(q, BLK_RW_ASYNC); 75 } else if (rl->count[BLK_RW_ASYNC]+1 <= q->nr_requests) { 76 blk_clear_queue_full(q, BLK_RW_ASYNC); 77 wake_up(&rl->wait[BLK_RW_ASYNC]); 78 } 79 spin_unlock_irq(q->queue_lock); 80 return ret; 81 } 82 83 static ssize_t queue_ra_show(struct request_queue *q, char *page) 84 { 85 unsigned long ra_kb = q->backing_dev_info.ra_pages << 86 (PAGE_CACHE_SHIFT - 10); 87 88 return queue_var_show(ra_kb, (page)); 89 } 90 91 static ssize_t 92 queue_ra_store(struct request_queue *q, const char *page, size_t count) 93 { 94 unsigned long ra_kb; 95 ssize_t ret = queue_var_store(&ra_kb, page, count); 96 97 q->backing_dev_info.ra_pages = ra_kb >> (PAGE_CACHE_SHIFT - 10); 98 99 return ret; 100 } 101 102 static ssize_t queue_max_sectors_show(struct request_queue *q, char *page) 103 { 104 int max_sectors_kb = queue_max_sectors(q) >> 1; 105 106 return queue_var_show(max_sectors_kb, (page)); 107 } 108 109 static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page) 110 { 111 return queue_var_show(queue_logical_block_size(q), page); 112 } 113 114 static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page) 115 { 116 return queue_var_show(queue_physical_block_size(q), page); 117 } 118 119 static ssize_t queue_io_min_show(struct request_queue *q, char *page) 120 { 121 return queue_var_show(queue_io_min(q), page); 122 } 123 124 static ssize_t queue_io_opt_show(struct request_queue *q, char *page) 125 { 126 return queue_var_show(queue_io_opt(q), page); 127 } 128 129 static ssize_t 130 queue_max_sectors_store(struct request_queue *q, const char *page, size_t count) 131 { 132 unsigned long max_sectors_kb, 133 max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1, 134 page_kb = 1 << (PAGE_CACHE_SHIFT - 10); 135 ssize_t ret = queue_var_store(&max_sectors_kb, page, count); 136 137 if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb) 138 return -EINVAL; 139 140 spin_lock_irq(q->queue_lock); 141 q->limits.max_sectors = max_sectors_kb << 1; 142 spin_unlock_irq(q->queue_lock); 143 144 return ret; 145 } 146 147 static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page) 148 { 149 int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1; 150 151 return queue_var_show(max_hw_sectors_kb, (page)); 152 } 153 154 static ssize_t queue_nonrot_show(struct request_queue *q, char *page) 155 { 156 return queue_var_show(!blk_queue_nonrot(q), page); 157 } 158 159 static ssize_t queue_nonrot_store(struct request_queue *q, const char *page, 160 size_t count) 161 { 162 unsigned long nm; 163 ssize_t ret = queue_var_store(&nm, page, count); 164 165 spin_lock_irq(q->queue_lock); 166 if (nm) 167 queue_flag_clear(QUEUE_FLAG_NONROT, q); 168 else 169 queue_flag_set(QUEUE_FLAG_NONROT, q); 170 spin_unlock_irq(q->queue_lock); 171 172 return ret; 173 } 174 175 static ssize_t queue_nomerges_show(struct request_queue *q, char *page) 176 { 177 return queue_var_show(blk_queue_nomerges(q), page); 178 } 179 180 static ssize_t queue_nomerges_store(struct request_queue *q, const char *page, 181 size_t count) 182 { 183 unsigned long nm; 184 ssize_t ret = queue_var_store(&nm, page, count); 185 186 spin_lock_irq(q->queue_lock); 187 if (nm) 188 queue_flag_set(QUEUE_FLAG_NOMERGES, q); 189 else 190 queue_flag_clear(QUEUE_FLAG_NOMERGES, q); 191 spin_unlock_irq(q->queue_lock); 192 193 return ret; 194 } 195 196 static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page) 197 { 198 bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags); 199 200 return queue_var_show(set, page); 201 } 202 203 static ssize_t 204 queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count) 205 { 206 ssize_t ret = -EINVAL; 207 #if defined(CONFIG_USE_GENERIC_SMP_HELPERS) 208 unsigned long val; 209 210 ret = queue_var_store(&val, page, count); 211 spin_lock_irq(q->queue_lock); 212 if (val) 213 queue_flag_set(QUEUE_FLAG_SAME_COMP, q); 214 else 215 queue_flag_clear(QUEUE_FLAG_SAME_COMP, q); 216 spin_unlock_irq(q->queue_lock); 217 #endif 218 return ret; 219 } 220 221 static ssize_t queue_iostats_show(struct request_queue *q, char *page) 222 { 223 return queue_var_show(blk_queue_io_stat(q), page); 224 } 225 226 static ssize_t queue_iostats_store(struct request_queue *q, const char *page, 227 size_t count) 228 { 229 unsigned long stats; 230 ssize_t ret = queue_var_store(&stats, page, count); 231 232 spin_lock_irq(q->queue_lock); 233 if (stats) 234 queue_flag_set(QUEUE_FLAG_IO_STAT, q); 235 else 236 queue_flag_clear(QUEUE_FLAG_IO_STAT, q); 237 spin_unlock_irq(q->queue_lock); 238 239 return ret; 240 } 241 242 static struct queue_sysfs_entry queue_requests_entry = { 243 .attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR }, 244 .show = queue_requests_show, 245 .store = queue_requests_store, 246 }; 247 248 static struct queue_sysfs_entry queue_ra_entry = { 249 .attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR }, 250 .show = queue_ra_show, 251 .store = queue_ra_store, 252 }; 253 254 static struct queue_sysfs_entry queue_max_sectors_entry = { 255 .attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR }, 256 .show = queue_max_sectors_show, 257 .store = queue_max_sectors_store, 258 }; 259 260 static struct queue_sysfs_entry queue_max_hw_sectors_entry = { 261 .attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO }, 262 .show = queue_max_hw_sectors_show, 263 }; 264 265 static struct queue_sysfs_entry queue_iosched_entry = { 266 .attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR }, 267 .show = elv_iosched_show, 268 .store = elv_iosched_store, 269 }; 270 271 static struct queue_sysfs_entry queue_hw_sector_size_entry = { 272 .attr = {.name = "hw_sector_size", .mode = S_IRUGO }, 273 .show = queue_logical_block_size_show, 274 }; 275 276 static struct queue_sysfs_entry queue_logical_block_size_entry = { 277 .attr = {.name = "logical_block_size", .mode = S_IRUGO }, 278 .show = queue_logical_block_size_show, 279 }; 280 281 static struct queue_sysfs_entry queue_physical_block_size_entry = { 282 .attr = {.name = "physical_block_size", .mode = S_IRUGO }, 283 .show = queue_physical_block_size_show, 284 }; 285 286 static struct queue_sysfs_entry queue_io_min_entry = { 287 .attr = {.name = "minimum_io_size", .mode = S_IRUGO }, 288 .show = queue_io_min_show, 289 }; 290 291 static struct queue_sysfs_entry queue_io_opt_entry = { 292 .attr = {.name = "optimal_io_size", .mode = S_IRUGO }, 293 .show = queue_io_opt_show, 294 }; 295 296 static struct queue_sysfs_entry queue_nonrot_entry = { 297 .attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR }, 298 .show = queue_nonrot_show, 299 .store = queue_nonrot_store, 300 }; 301 302 static struct queue_sysfs_entry queue_nomerges_entry = { 303 .attr = {.name = "nomerges", .mode = S_IRUGO | S_IWUSR }, 304 .show = queue_nomerges_show, 305 .store = queue_nomerges_store, 306 }; 307 308 static struct queue_sysfs_entry queue_rq_affinity_entry = { 309 .attr = {.name = "rq_affinity", .mode = S_IRUGO | S_IWUSR }, 310 .show = queue_rq_affinity_show, 311 .store = queue_rq_affinity_store, 312 }; 313 314 static struct queue_sysfs_entry queue_iostats_entry = { 315 .attr = {.name = "iostats", .mode = S_IRUGO | S_IWUSR }, 316 .show = queue_iostats_show, 317 .store = queue_iostats_store, 318 }; 319 320 static struct attribute *default_attrs[] = { 321 &queue_requests_entry.attr, 322 &queue_ra_entry.attr, 323 &queue_max_hw_sectors_entry.attr, 324 &queue_max_sectors_entry.attr, 325 &queue_iosched_entry.attr, 326 &queue_hw_sector_size_entry.attr, 327 &queue_logical_block_size_entry.attr, 328 &queue_physical_block_size_entry.attr, 329 &queue_io_min_entry.attr, 330 &queue_io_opt_entry.attr, 331 &queue_nonrot_entry.attr, 332 &queue_nomerges_entry.attr, 333 &queue_rq_affinity_entry.attr, 334 &queue_iostats_entry.attr, 335 NULL, 336 }; 337 338 #define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr) 339 340 static ssize_t 341 queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page) 342 { 343 struct queue_sysfs_entry *entry = to_queue(attr); 344 struct request_queue *q = 345 container_of(kobj, struct request_queue, kobj); 346 ssize_t res; 347 348 if (!entry->show) 349 return -EIO; 350 mutex_lock(&q->sysfs_lock); 351 if (test_bit(QUEUE_FLAG_DEAD, &q->queue_flags)) { 352 mutex_unlock(&q->sysfs_lock); 353 return -ENOENT; 354 } 355 res = entry->show(q, page); 356 mutex_unlock(&q->sysfs_lock); 357 return res; 358 } 359 360 static ssize_t 361 queue_attr_store(struct kobject *kobj, struct attribute *attr, 362 const char *page, size_t length) 363 { 364 struct queue_sysfs_entry *entry = to_queue(attr); 365 struct request_queue *q; 366 ssize_t res; 367 368 if (!entry->store) 369 return -EIO; 370 371 q = container_of(kobj, struct request_queue, kobj); 372 mutex_lock(&q->sysfs_lock); 373 if (test_bit(QUEUE_FLAG_DEAD, &q->queue_flags)) { 374 mutex_unlock(&q->sysfs_lock); 375 return -ENOENT; 376 } 377 res = entry->store(q, page, length); 378 mutex_unlock(&q->sysfs_lock); 379 return res; 380 } 381 382 /** 383 * blk_cleanup_queue: - release a &struct request_queue when it is no longer needed 384 * @kobj: the kobj belonging of the request queue to be released 385 * 386 * Description: 387 * blk_cleanup_queue is the pair to blk_init_queue() or 388 * blk_queue_make_request(). It should be called when a request queue is 389 * being released; typically when a block device is being de-registered. 390 * Currently, its primary task it to free all the &struct request 391 * structures that were allocated to the queue and the queue itself. 392 * 393 * Caveat: 394 * Hopefully the low level driver will have finished any 395 * outstanding requests first... 396 **/ 397 static void blk_release_queue(struct kobject *kobj) 398 { 399 struct request_queue *q = 400 container_of(kobj, struct request_queue, kobj); 401 struct request_list *rl = &q->rq; 402 403 blk_sync_queue(q); 404 405 if (rl->rq_pool) 406 mempool_destroy(rl->rq_pool); 407 408 if (q->queue_tags) 409 __blk_queue_free_tags(q); 410 411 blk_trace_shutdown(q); 412 413 bdi_destroy(&q->backing_dev_info); 414 kmem_cache_free(blk_requestq_cachep, q); 415 } 416 417 static struct sysfs_ops queue_sysfs_ops = { 418 .show = queue_attr_show, 419 .store = queue_attr_store, 420 }; 421 422 struct kobj_type blk_queue_ktype = { 423 .sysfs_ops = &queue_sysfs_ops, 424 .default_attrs = default_attrs, 425 .release = blk_release_queue, 426 }; 427 428 int blk_register_queue(struct gendisk *disk) 429 { 430 int ret; 431 struct device *dev = disk_to_dev(disk); 432 433 struct request_queue *q = disk->queue; 434 435 if (WARN_ON(!q)) 436 return -ENXIO; 437 438 ret = blk_trace_init_sysfs(dev); 439 if (ret) 440 return ret; 441 442 ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue"); 443 if (ret < 0) 444 return ret; 445 446 kobject_uevent(&q->kobj, KOBJ_ADD); 447 448 if (!q->request_fn) 449 return 0; 450 451 ret = elv_register_queue(q); 452 if (ret) { 453 kobject_uevent(&q->kobj, KOBJ_REMOVE); 454 kobject_del(&q->kobj); 455 blk_trace_remove_sysfs(disk_to_dev(disk)); 456 return ret; 457 } 458 459 return 0; 460 } 461 462 void blk_unregister_queue(struct gendisk *disk) 463 { 464 struct request_queue *q = disk->queue; 465 466 if (WARN_ON(!q)) 467 return; 468 469 if (q->request_fn) 470 elv_unregister_queue(q); 471 472 kobject_uevent(&q->kobj, KOBJ_REMOVE); 473 kobject_del(&q->kobj); 474 blk_trace_remove_sysfs(disk_to_dev(disk)); 475 kobject_put(&disk_to_dev(disk)->kobj); 476 } 477