Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * File...........: linux/drivers/s390/block/dasd_proc.c | |
3 | * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> | |
4 | * Horst Hummel <Horst.Hummel@de.ibm.com> | |
5 | * Carsten Otte <Cotte@de.ibm.com> | |
6 | * Martin Schwidefsky <schwidefsky@de.ibm.com> | |
7 | * Bugreports.to..: <Linux390@de.ibm.com> | |
8 | * (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999-2002 | |
9 | * | |
10 | * /proc interface for the dasd driver. | |
11 | * | |
1da177e4 LT |
12 | */ |
13 | ||
fc19f381 SH |
14 | #define KMSG_COMPONENT "dasd" |
15 | ||
1da177e4 | 16 | #include <linux/ctype.h> |
e7d2860b | 17 | #include <linux/string.h> |
1da177e4 LT |
18 | #include <linux/seq_file.h> |
19 | #include <linux/vmalloc.h> | |
66a464db | 20 | #include <linux/proc_fs.h> |
1da177e4 LT |
21 | |
22 | #include <asm/debug.h> | |
23 | #include <asm/uaccess.h> | |
24 | ||
25 | /* This is ugly... */ | |
26 | #define PRINTK_HEADER "dasd_proc:" | |
27 | ||
28 | #include "dasd_int.h" | |
29 | ||
30 | static struct proc_dir_entry *dasd_proc_root_entry = NULL; | |
31 | static struct proc_dir_entry *dasd_devices_entry = NULL; | |
32 | static struct proc_dir_entry *dasd_statistics_entry = NULL; | |
33 | ||
3d62149f | 34 | #ifdef CONFIG_DASD_PROFILE |
4d284cac | 35 | static char * |
1da177e4 LT |
36 | dasd_get_user_string(const char __user *user_buf, size_t user_len) |
37 | { | |
38 | char *buffer; | |
39 | ||
40 | buffer = kmalloc(user_len + 1, GFP_KERNEL); | |
41 | if (buffer == NULL) | |
42 | return ERR_PTR(-ENOMEM); | |
43 | if (copy_from_user(buffer, user_buf, user_len) != 0) { | |
44 | kfree(buffer); | |
45 | return ERR_PTR(-EFAULT); | |
46 | } | |
47 | /* got the string, now strip linefeed. */ | |
48 | if (buffer[user_len - 1] == '\n') | |
49 | buffer[user_len - 1] = 0; | |
50 | else | |
51 | buffer[user_len] = 0; | |
52 | return buffer; | |
53 | } | |
3d62149f | 54 | #endif /* CONFIG_DASD_PROFILE */ |
1da177e4 LT |
55 | |
56 | static int | |
57 | dasd_devices_show(struct seq_file *m, void *v) | |
58 | { | |
59 | struct dasd_device *device; | |
8e09f215 | 60 | struct dasd_block *block; |
1da177e4 LT |
61 | char *substr; |
62 | ||
63 | device = dasd_device_from_devindex((unsigned long) v - 1); | |
64 | if (IS_ERR(device)) | |
65 | return 0; | |
8e09f215 SW |
66 | if (device->block) |
67 | block = device->block; | |
a5e23839 SW |
68 | else { |
69 | dasd_put_device(device); | |
8e09f215 | 70 | return 0; |
a5e23839 | 71 | } |
1da177e4 | 72 | /* Print device number. */ |
2a0217d5 | 73 | seq_printf(m, "%s", dev_name(&device->cdev->dev)); |
1da177e4 | 74 | /* Print discipline string. */ |
294001a8 | 75 | if (device->discipline != NULL) |
1da177e4 LT |
76 | seq_printf(m, "(%s)", device->discipline->name); |
77 | else | |
78 | seq_printf(m, "(none)"); | |
79 | /* Print kdev. */ | |
8e09f215 | 80 | if (block->gdp) |
1da177e4 | 81 | seq_printf(m, " at (%3d:%6d)", |
f331c029 TH |
82 | MAJOR(disk_devt(block->gdp)), |
83 | MINOR(disk_devt(block->gdp))); | |
1da177e4 LT |
84 | else |
85 | seq_printf(m, " at (???:??????)"); | |
86 | /* Print device name. */ | |
8e09f215 SW |
87 | if (block->gdp) |
88 | seq_printf(m, " is %-8s", block->gdp->disk_name); | |
1da177e4 LT |
89 | else |
90 | seq_printf(m, " is ????????"); | |
91 | /* Print devices features. */ | |
c6eb7b77 | 92 | substr = (device->features & DASD_FEATURE_READONLY) ? "(ro)" : " "; |
1da177e4 LT |
93 | seq_printf(m, "%4s: ", substr); |
94 | /* Print device status information. */ | |
294001a8 | 95 | switch (device->state) { |
1da177e4 LT |
96 | case DASD_STATE_NEW: |
97 | seq_printf(m, "new"); | |
98 | break; | |
99 | case DASD_STATE_KNOWN: | |
100 | seq_printf(m, "detected"); | |
101 | break; | |
102 | case DASD_STATE_BASIC: | |
103 | seq_printf(m, "basic"); | |
104 | break; | |
90f0094d | 105 | case DASD_STATE_UNFMT: |
b707dbe6 | 106 | seq_printf(m, "unformatted"); |
90f0094d | 107 | break; |
1da177e4 LT |
108 | case DASD_STATE_READY: |
109 | case DASD_STATE_ONLINE: | |
110 | seq_printf(m, "active "); | |
8e09f215 | 111 | if (dasd_check_blocksize(block->bp_block)) |
1da177e4 LT |
112 | seq_printf(m, "n/f "); |
113 | else | |
114 | seq_printf(m, | |
b44b0ab3 | 115 | "at blocksize: %d, %lld blocks, %lld MB", |
8e09f215 SW |
116 | block->bp_block, block->blocks, |
117 | ((block->bp_block >> 9) * | |
118 | block->blocks) >> 11); | |
1da177e4 LT |
119 | break; |
120 | default: | |
121 | seq_printf(m, "no stat"); | |
122 | break; | |
123 | } | |
124 | dasd_put_device(device); | |
125 | if (dasd_probeonly) | |
126 | seq_printf(m, "(probeonly)"); | |
127 | seq_printf(m, "\n"); | |
128 | return 0; | |
129 | } | |
130 | ||
131 | static void *dasd_devices_start(struct seq_file *m, loff_t *pos) | |
132 | { | |
133 | if (*pos >= dasd_max_devindex) | |
134 | return NULL; | |
135 | return (void *)((unsigned long) *pos + 1); | |
136 | } | |
137 | ||
138 | static void *dasd_devices_next(struct seq_file *m, void *v, loff_t *pos) | |
139 | { | |
140 | ++*pos; | |
141 | return dasd_devices_start(m, pos); | |
142 | } | |
143 | ||
144 | static void dasd_devices_stop(struct seq_file *m, void *v) | |
145 | { | |
146 | } | |
147 | ||
5c81cdbe | 148 | static const struct seq_operations dasd_devices_seq_ops = { |
1da177e4 LT |
149 | .start = dasd_devices_start, |
150 | .next = dasd_devices_next, | |
151 | .stop = dasd_devices_stop, | |
152 | .show = dasd_devices_show, | |
153 | }; | |
154 | ||
155 | static int dasd_devices_open(struct inode *inode, struct file *file) | |
156 | { | |
157 | return seq_open(file, &dasd_devices_seq_ops); | |
158 | } | |
159 | ||
d54b1fdb | 160 | static const struct file_operations dasd_devices_file_ops = { |
8b594007 | 161 | .owner = THIS_MODULE, |
1da177e4 LT |
162 | .open = dasd_devices_open, |
163 | .read = seq_read, | |
164 | .llseek = seq_lseek, | |
165 | .release = seq_release, | |
166 | }; | |
167 | ||
4d284cac | 168 | static int |
1da177e4 LT |
169 | dasd_calc_metrics(char *page, char **start, off_t off, |
170 | int count, int *eof, int len) | |
171 | { | |
172 | len = (len > off) ? len - off : 0; | |
173 | if (len > count) | |
174 | len = count; | |
175 | if (len < count) | |
176 | *eof = 1; | |
177 | *start = page + off; | |
178 | return len; | |
179 | } | |
180 | ||
3d62149f | 181 | #ifdef CONFIG_DASD_PROFILE |
4d284cac | 182 | static char * |
2bf373b3 | 183 | dasd_statistics_array(char *str, unsigned int *array, int factor) |
1da177e4 LT |
184 | { |
185 | int i; | |
186 | ||
187 | for (i = 0; i < 32; i++) { | |
2bf373b3 | 188 | str += sprintf(str, "%7d ", array[i] / factor); |
1da177e4 LT |
189 | if (i == 15) |
190 | str += sprintf(str, "\n"); | |
191 | } | |
192 | str += sprintf(str,"\n"); | |
193 | return str; | |
194 | } | |
3d62149f | 195 | #endif /* CONFIG_DASD_PROFILE */ |
1da177e4 LT |
196 | |
197 | static int | |
198 | dasd_statistics_read(char *page, char **start, off_t off, | |
199 | int count, int *eof, void *data) | |
200 | { | |
201 | unsigned long len; | |
202 | #ifdef CONFIG_DASD_PROFILE | |
203 | struct dasd_profile_info_t *prof; | |
204 | char *str; | |
2bf373b3 | 205 | int factor; |
1da177e4 LT |
206 | |
207 | /* check for active profiling */ | |
208 | if (dasd_profile_level == DASD_PROFILE_OFF) { | |
209 | len = sprintf(page, "Statistics are off - they might be " | |
210 | "switched on using 'echo set on > " | |
211 | "/proc/dasd/statistics'\n"); | |
212 | return dasd_calc_metrics(page, start, off, count, eof, len); | |
213 | } | |
214 | ||
215 | prof = &dasd_global_profile; | |
fbfecd37 | 216 | /* prevent counter 'overflow' on output */ |
2bf373b3 SH |
217 | for (factor = 1; (prof->dasd_io_reqs / factor) > 9999999; |
218 | factor *= 10); | |
1da177e4 LT |
219 | |
220 | str = page; | |
221 | str += sprintf(str, "%d dasd I/O requests\n", prof->dasd_io_reqs); | |
2bf373b3 | 222 | str += sprintf(str, "with %u sectors(512B each)\n", |
1da177e4 | 223 | prof->dasd_io_sects); |
2bf373b3 | 224 | str += sprintf(str, "Scale Factor is %d\n", factor); |
1da177e4 LT |
225 | str += sprintf(str, |
226 | " __<4 ___8 __16 __32 __64 _128 " | |
227 | " _256 _512 __1k __2k __4k __8k " | |
228 | " _16k _32k _64k 128k\n"); | |
229 | str += sprintf(str, | |
230 | " _256 _512 __1M __2M __4M __8M " | |
231 | " _16M _32M _64M 128M 256M 512M " | |
232 | " __1G __2G __4G " " _>4G\n"); | |
233 | ||
234 | str += sprintf(str, "Histogram of sizes (512B secs)\n"); | |
2bf373b3 | 235 | str = dasd_statistics_array(str, prof->dasd_io_secs, factor); |
1da177e4 | 236 | str += sprintf(str, "Histogram of I/O times (microseconds)\n"); |
2bf373b3 | 237 | str = dasd_statistics_array(str, prof->dasd_io_times, factor); |
1da177e4 | 238 | str += sprintf(str, "Histogram of I/O times per sector\n"); |
2bf373b3 | 239 | str = dasd_statistics_array(str, prof->dasd_io_timps, factor); |
1da177e4 | 240 | str += sprintf(str, "Histogram of I/O time till ssch\n"); |
2bf373b3 | 241 | str = dasd_statistics_array(str, prof->dasd_io_time1, factor); |
1da177e4 | 242 | str += sprintf(str, "Histogram of I/O time between ssch and irq\n"); |
2bf373b3 | 243 | str = dasd_statistics_array(str, prof->dasd_io_time2, factor); |
1da177e4 LT |
244 | str += sprintf(str, "Histogram of I/O time between ssch " |
245 | "and irq per sector\n"); | |
2bf373b3 | 246 | str = dasd_statistics_array(str, prof->dasd_io_time2ps, factor); |
1da177e4 | 247 | str += sprintf(str, "Histogram of I/O time between irq and end\n"); |
2bf373b3 | 248 | str = dasd_statistics_array(str, prof->dasd_io_time3, factor); |
1da177e4 | 249 | str += sprintf(str, "# of req in chanq at enqueuing (1..32) \n"); |
2bf373b3 | 250 | str = dasd_statistics_array(str, prof->dasd_io_nr_req, factor); |
1da177e4 LT |
251 | len = str - page; |
252 | #else | |
253 | len = sprintf(page, "Statistics are not activated in this kernel\n"); | |
254 | #endif | |
255 | return dasd_calc_metrics(page, start, off, count, eof, len); | |
256 | } | |
257 | ||
258 | static int | |
259 | dasd_statistics_write(struct file *file, const char __user *user_buf, | |
260 | unsigned long user_len, void *data) | |
261 | { | |
262 | #ifdef CONFIG_DASD_PROFILE | |
263 | char *buffer, *str; | |
264 | ||
265 | if (user_len > 65536) | |
266 | user_len = 65536; | |
267 | buffer = dasd_get_user_string(user_buf, user_len); | |
268 | if (IS_ERR(buffer)) | |
269 | return PTR_ERR(buffer); | |
fc19f381 | 270 | DBF_EVENT(DBF_DEBUG, "/proc/dasd/statictics: '%s'\n", buffer); |
1da177e4 LT |
271 | |
272 | /* check for valid verbs */ | |
e7d2860b | 273 | str = skip_spaces(buffer); |
1da177e4 LT |
274 | if (strncmp(str, "set", 3) == 0 && isspace(str[3])) { |
275 | /* 'set xxx' was given */ | |
e7d2860b | 276 | str = skip_spaces(str + 4); |
1da177e4 LT |
277 | if (strcmp(str, "on") == 0) { |
278 | /* switch on statistics profiling */ | |
279 | dasd_profile_level = DASD_PROFILE_ON; | |
fc19f381 SH |
280 | pr_info("The statistics feature has been switched " |
281 | "on\n"); | |
1da177e4 LT |
282 | } else if (strcmp(str, "off") == 0) { |
283 | /* switch off and reset statistics profiling */ | |
284 | memset(&dasd_global_profile, | |
285 | 0, sizeof (struct dasd_profile_info_t)); | |
286 | dasd_profile_level = DASD_PROFILE_OFF; | |
fc19f381 SH |
287 | pr_info("The statistics feature has been switched " |
288 | "off\n"); | |
1da177e4 LT |
289 | } else |
290 | goto out_error; | |
291 | } else if (strncmp(str, "reset", 5) == 0) { | |
292 | /* reset the statistics */ | |
293 | memset(&dasd_global_profile, 0, | |
294 | sizeof (struct dasd_profile_info_t)); | |
fc19f381 | 295 | pr_info("The statistics have been reset\n"); |
1da177e4 LT |
296 | } else |
297 | goto out_error; | |
298 | kfree(buffer); | |
299 | return user_len; | |
300 | out_error: | |
fc19f381 SH |
301 | pr_warning("%s is not a supported value for /proc/dasd/statistics\n", |
302 | str); | |
1da177e4 LT |
303 | kfree(buffer); |
304 | return -EINVAL; | |
305 | #else | |
fc19f381 | 306 | pr_warning("/proc/dasd/statistics: is not activated in this kernel\n"); |
1da177e4 LT |
307 | return user_len; |
308 | #endif /* CONFIG_DASD_PROFILE */ | |
309 | } | |
310 | ||
7220fe8b HH |
311 | /* |
312 | * Create dasd proc-fs entries. | |
313 | * In case creation failed, cleanup and return -ENOENT. | |
314 | */ | |
1da177e4 LT |
315 | int |
316 | dasd_proc_init(void) | |
317 | { | |
c74c120a | 318 | dasd_proc_root_entry = proc_mkdir("dasd", NULL); |
7220fe8b HH |
319 | if (!dasd_proc_root_entry) |
320 | goto out_nodasd; | |
8b594007 DL |
321 | dasd_devices_entry = proc_create("devices", |
322 | S_IFREG | S_IRUGO | S_IWUSR, | |
323 | dasd_proc_root_entry, | |
324 | &dasd_devices_file_ops); | |
7220fe8b HH |
325 | if (!dasd_devices_entry) |
326 | goto out_nodevices; | |
1da177e4 LT |
327 | dasd_statistics_entry = create_proc_entry("statistics", |
328 | S_IFREG | S_IRUGO | S_IWUSR, | |
329 | dasd_proc_root_entry); | |
7220fe8b HH |
330 | if (!dasd_statistics_entry) |
331 | goto out_nostatistics; | |
1da177e4 LT |
332 | dasd_statistics_entry->read_proc = dasd_statistics_read; |
333 | dasd_statistics_entry->write_proc = dasd_statistics_write; | |
1da177e4 | 334 | return 0; |
7220fe8b HH |
335 | |
336 | out_nostatistics: | |
337 | remove_proc_entry("devices", dasd_proc_root_entry); | |
338 | out_nodevices: | |
c74c120a | 339 | remove_proc_entry("dasd", NULL); |
7220fe8b HH |
340 | out_nodasd: |
341 | return -ENOENT; | |
1da177e4 LT |
342 | } |
343 | ||
344 | void | |
345 | dasd_proc_exit(void) | |
346 | { | |
347 | remove_proc_entry("devices", dasd_proc_root_entry); | |
348 | remove_proc_entry("statistics", dasd_proc_root_entry); | |
c74c120a | 349 | remove_proc_entry("dasd", NULL); |
1da177e4 | 350 | } |