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