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