Merge tag 'staging-3.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh...
[platform/adaptation/renesas_rcar/renesas_kernel.git] / block / blk-sysfs.c
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         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         if (err || v > UINT_MAX)
36                 return -EINVAL;
37
38         *var = v;
39
40         return count;
41 }
42
43 static ssize_t queue_requests_show(struct request_queue *q, char *page)
44 {
45         return queue_var_show(q->nr_requests, (page));
46 }
47
48 static ssize_t
49 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         if (!q->request_fn)
56                 return -EINVAL;
57
58         ret = queue_var_store(&nr, page, count);
59         if (ret < 0)
60                 return ret;
61
62         if (nr < BLKDEV_MIN_RQ)
63                 nr = BLKDEV_MIN_RQ;
64
65         spin_lock_irq(q->queue_lock);
66         q->nr_requests = nr;
67         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         if (rl->count[BLK_RW_SYNC] >= queue_congestion_on_threshold(q))
73                 blk_set_queue_congested(q, BLK_RW_SYNC);
74         else if (rl->count[BLK_RW_SYNC] < queue_congestion_off_threshold(q))
75                 blk_clear_queue_congested(q, BLK_RW_SYNC);
76
77         if (rl->count[BLK_RW_ASYNC] >= queue_congestion_on_threshold(q))
78                 blk_set_queue_congested(q, BLK_RW_ASYNC);
79         else if (rl->count[BLK_RW_ASYNC] < queue_congestion_off_threshold(q))
80                 blk_clear_queue_congested(q, BLK_RW_ASYNC);
81
82         blk_queue_for_each_rl(rl, q) {
83                 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                         wake_up(&rl->wait[BLK_RW_SYNC]);
88                 }
89
90                 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                         wake_up(&rl->wait[BLK_RW_ASYNC]);
95                 }
96         }
97
98         spin_unlock_irq(q->queue_lock);
99         return ret;
100 }
101
102 static ssize_t queue_ra_show(struct request_queue *q, char *page)
103 {
104         unsigned long ra_kb = q->backing_dev_info.ra_pages <<
105                                         (PAGE_CACHE_SHIFT - 10);
106
107         return queue_var_show(ra_kb, (page));
108 }
109
110 static ssize_t
111 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         if (ret < 0)
117                 return ret;
118
119         q->backing_dev_info.ra_pages = ra_kb >> (PAGE_CACHE_SHIFT - 10);
120
121         return ret;
122 }
123
124 static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
125 {
126         int max_sectors_kb = queue_max_sectors(q) >> 1;
127
128         return queue_var_show(max_sectors_kb, (page));
129 }
130
131 static ssize_t queue_max_segments_show(struct request_queue *q, char *page)
132 {
133         return queue_var_show(queue_max_segments(q), (page));
134 }
135
136 static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page)
137 {
138         return queue_var_show(q->limits.max_integrity_segments, (page));
139 }
140
141 static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
142 {
143         if (blk_queue_cluster(q))
144                 return queue_var_show(queue_max_segment_size(q), (page));
145
146         return queue_var_show(PAGE_CACHE_SIZE, (page));
147 }
148
149 static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
150 {
151         return queue_var_show(queue_logical_block_size(q), page);
152 }
153
154 static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
155 {
156         return queue_var_show(queue_physical_block_size(q), page);
157 }
158
159 static ssize_t queue_io_min_show(struct request_queue *q, char *page)
160 {
161         return queue_var_show(queue_io_min(q), page);
162 }
163
164 static ssize_t queue_io_opt_show(struct request_queue *q, char *page)
165 {
166         return queue_var_show(queue_io_opt(q), page);
167 }
168
169 static ssize_t queue_discard_granularity_show(struct request_queue *q, char *page)
170 {
171         return queue_var_show(q->limits.discard_granularity, page);
172 }
173
174 static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
175 {
176         return sprintf(page, "%llu\n",
177                        (unsigned long long)q->limits.max_discard_sectors << 9);
178 }
179
180 static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
181 {
182         return queue_var_show(queue_discard_zeroes_data(q), page);
183 }
184
185 static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
186 {
187         return sprintf(page, "%llu\n",
188                 (unsigned long long)q->limits.max_write_same_sectors << 9);
189 }
190
191
192 static ssize_t
193 queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
194 {
195         unsigned long max_sectors_kb,
196                 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         if (ret < 0)
201                 return ret;
202
203         if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
204                 return -EINVAL;
205
206         spin_lock_irq(q->queue_lock);
207         q->limits.max_sectors = max_sectors_kb << 1;
208         spin_unlock_irq(q->queue_lock);
209
210         return ret;
211 }
212
213 static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
214 {
215         int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
216
217         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 QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
249 QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
250 QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
251 #undef QUEUE_SYSFS_BIT_FNS
252
253 static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
254 {
255         return queue_var_show((blk_queue_nomerges(q) << 1) |
256                                blk_queue_noxmerges(q), page);
257 }
258
259 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         if (ret < 0)
266                 return ret;
267
268         spin_lock_irq(q->queue_lock);
269         queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
270         queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
271         if (nm == 2)
272                 queue_flag_set(QUEUE_FLAG_NOMERGES, q);
273         else if (nm)
274                 queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
275         spin_unlock_irq(q->queue_lock);
276
277         return ret;
278 }
279
280 static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
281 {
282         bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
283         bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
284
285         return queue_var_show(set << force, page);
286 }
287
288 static ssize_t
289 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         if (ret < 0)
297                 return ret;
298
299         spin_lock_irq(q->queue_lock);
300         if (val == 2) {
301                 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
302                 queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
303         } else if (val == 1) {
304                 queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
305                 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
306         } else if (val == 0) {
307                 queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
308                 queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
309         }
310         spin_unlock_irq(q->queue_lock);
311 #endif
312         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 queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
464 {
465         struct queue_sysfs_entry *entry = to_queue(attr);
466         struct request_queue *q =
467                 container_of(kobj, struct request_queue, kobj);
468         ssize_t res;
469
470         if (!entry->show)
471                 return -EIO;
472         mutex_lock(&q->sysfs_lock);
473         if (blk_queue_dying(q)) {
474                 mutex_unlock(&q->sysfs_lock);
475                 return -ENOENT;
476         }
477         res = entry->show(q, page);
478         mutex_unlock(&q->sysfs_lock);
479         return res;
480 }
481
482 static ssize_t
483 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         if (!entry->store)
491                 return -EIO;
492
493         q = container_of(kobj, struct request_queue, kobj);
494         mutex_lock(&q->sysfs_lock);
495         if (blk_queue_dying(q)) {
496                 mutex_unlock(&q->sysfs_lock);
497                 return -ENOENT;
498         }
499         res = entry->store(q, page, length);
500         mutex_unlock(&q->sysfs_lock);
501         return res;
502 }
503
504 static void blk_free_queue_rcu(struct rcu_head *rcu_head)
505 {
506         struct request_queue *q = container_of(rcu_head, struct request_queue,
507                                                rcu_head);
508         kmem_cache_free(blk_requestq_cachep, q);
509 }
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 static void blk_release_queue(struct kobject *kobj)
527 {
528         struct request_queue *q =
529                 container_of(kobj, struct request_queue, kobj);
530
531         blk_sync_queue(q);
532
533         blkcg_exit_queue(q);
534
535         if (q->elevator) {
536                 spin_lock_irq(q->queue_lock);
537                 ioc_clear_queue(q);
538                 spin_unlock_irq(q->queue_lock);
539                 elevator_exit(q->elevator);
540         }
541
542         blk_exit_rl(&q->root_rl);
543
544         if (q->queue_tags)
545                 __blk_queue_free_tags(q);
546
547         percpu_counter_destroy(&q->mq_usage_counter);
548
549         if (q->mq_ops)
550                 blk_mq_free_queue(q);
551
552         blk_trace_shutdown(q);
553
554         bdi_destroy(&q->backing_dev_info);
555
556         ida_simple_remove(&blk_queue_ida, q->id);
557         call_rcu(&q->rcu_head, blk_free_queue_rcu);
558 }
559
560 static const struct sysfs_ops queue_sysfs_ops = {
561         .show   = queue_attr_show,
562         .store  = queue_attr_store,
563 };
564
565 struct kobj_type blk_queue_ktype = {
566         .sysfs_ops      = &queue_sysfs_ops,
567         .default_attrs  = default_attrs,
568         .release        = blk_release_queue,
569 };
570
571 int blk_register_queue(struct gendisk *disk)
572 {
573         int ret;
574         struct device *dev = disk_to_dev(disk);
575         struct request_queue *q = disk->queue;
576
577         if (WARN_ON(!q))
578                 return -ENXIO;
579
580         /*
581          * Initialization must be complete by now.  Finish the initial
582          * bypass from queue allocation.
583          */
584         blk_queue_bypass_end(q);
585         queue_flag_set_unlocked(QUEUE_FLAG_INIT_DONE, q);
586
587         ret = blk_trace_init_sysfs(dev);
588         if (ret)
589                 return ret;
590
591         ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
592         if (ret < 0) {
593                 blk_trace_remove_sysfs(dev);
594                 return ret;
595         }
596
597         kobject_uevent(&q->kobj, KOBJ_ADD);
598
599         if (q->mq_ops)
600                 blk_mq_register_disk(disk);
601
602         if (!q->request_fn)
603                 return 0;
604
605         ret = elv_register_queue(q);
606         if (ret) {
607                 kobject_uevent(&q->kobj, KOBJ_REMOVE);
608                 kobject_del(&q->kobj);
609                 blk_trace_remove_sysfs(dev);
610                 kobject_put(&dev->kobj);
611                 return ret;
612         }
613
614         return 0;
615 }
616
617 void blk_unregister_queue(struct gendisk *disk)
618 {
619         struct request_queue *q = disk->queue;
620
621         if (WARN_ON(!q))
622                 return;
623
624         if (q->mq_ops)
625                 blk_mq_unregister_disk(disk);
626
627         if (q->request_fn)
628                 elv_unregister_queue(q);
629
630         kobject_uevent(&q->kobj, KOBJ_REMOVE);
631         kobject_del(&q->kobj);
632         blk_trace_remove_sysfs(disk_to_dev(disk));
633         kobject_put(&disk_to_dev(disk)->kobj);
634 }