2 * S/390 common I/O routines -- blacklisting of specific devices
4 * Copyright IBM Corp. 1999, 2002
5 * Author(s): Ingo Adlung (adlung@de.ibm.com)
6 * Cornelia Huck (cornelia.huck@de.ibm.com)
7 * Arnd Bergmann (arndb@de.ibm.com)
10 #define KMSG_COMPONENT "cio"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <linux/init.h>
14 #include <linux/vmalloc.h>
15 #include <linux/proc_fs.h>
16 #include <linux/seq_file.h>
17 #include <linux/ctype.h>
18 #include <linux/device.h>
21 #include <asm/uaccess.h>
23 #include "blacklist.h"
25 #include "cio_debug.h"
30 * "Blacklisting" of certain devices:
31 * Device numbers given in the commandline as cio_ignore=... won't be known
34 * These can be single devices or ranges of devices
37 /* 65536 bits for each set to indicate if a devno is blacklisted or not */
38 #define __BL_DEV_WORDS ((__MAX_SUBCHANNEL + (8*sizeof(long) - 1)) / \
40 static unsigned long bl_dev
[__MAX_SSID
+ 1][__BL_DEV_WORDS
];
41 typedef enum {add
, free
} range_action
;
44 * Function: blacklist_range
45 * (Un-)blacklist the devices from-to
47 static int blacklist_range(range_action action
, unsigned int from_ssid
,
48 unsigned int to_ssid
, unsigned int from
,
49 unsigned int to
, int msgtrigger
)
51 if ((from_ssid
> to_ssid
) || ((from_ssid
== to_ssid
) && (from
> to
))) {
53 pr_warning("0.%x.%04x to 0.%x.%04x is not a valid "
54 "range for cio_ignore\n", from_ssid
, from
,
60 while ((from_ssid
< to_ssid
) || ((from_ssid
== to_ssid
) &&
63 set_bit(from
, bl_dev
[from_ssid
]);
65 clear_bit(from
, bl_dev
[from_ssid
]);
67 if (from
> __MAX_SUBCHANNEL
) {
76 static int pure_hex(char **cp
, unsigned int *val
, int min_digit
,
77 int max_digit
, int max_val
)
84 while (diff
<= max_digit
) {
85 int value
= hex_to_bin(**cp
);
89 *val
= *val
* 16 + value
;
94 if ((diff
< min_digit
) || (diff
> max_digit
) || (*val
> max_val
))
100 static int parse_busid(char *str
, unsigned int *cssid
, unsigned int *ssid
,
101 unsigned int *devno
, int msgtrigger
)
113 val
= simple_strtoul(str
, &str_work
, 16);
115 if (*str_work
== '\0') {
116 if (val
<= __MAX_SUBCHANNEL
) {
127 ret
= pure_hex(&str_work
, cssid
, 1, 2, __MAX_CSSID
);
128 if (ret
|| (str_work
[0] != '.'))
131 ret
= pure_hex(&str_work
, ssid
, 1, 1, __MAX_SSID
);
132 if (ret
|| (str_work
[0] != '.'))
135 ret
= pure_hex(&str_work
, devno
, 4, 4, __MAX_SUBCHANNEL
);
136 if (ret
|| (str_work
[0] != '\0'))
141 if (rc
&& msgtrigger
)
142 pr_warning("%s is not a valid device for the cio_ignore "
143 "kernel parameter\n", str
);
148 static int blacklist_parse_parameters(char *str
, range_action action
,
151 unsigned int from_cssid
, to_cssid
, from_ssid
, to_ssid
, from
, to
;
158 while ((parm
= strsep(&str
, ","))) {
168 if (strcmp(parm
, "all") == 0) {
172 to_cssid
= __MAX_CSSID
;
173 to_ssid
= __MAX_SSID
;
174 to
= __MAX_SUBCHANNEL
;
176 rc
= parse_busid(strsep(&parm
, "-"), &from_cssid
,
177 &from_ssid
, &from
, msgtrigger
);
180 rc
= parse_busid(parm
, &to_cssid
,
184 to_cssid
= from_cssid
;
191 rc
= blacklist_range(ra
, from_ssid
, to_ssid
, from
, to
,
203 blacklist_setup (char *str
)
205 CIO_MSG_EVENT(6, "Reading blacklist parameters\n");
206 if (blacklist_parse_parameters(str
, add
, 1))
211 __setup ("cio_ignore=", blacklist_setup
);
213 /* Checking if devices are blacklisted */
216 * Function: is_blacklisted
217 * Returns 1 if the given devicenumber can be found in the blacklist,
219 * Used by validate_subchannel()
222 is_blacklisted (int ssid
, int devno
)
224 return test_bit (devno
, bl_dev
[ssid
]);
227 #ifdef CONFIG_PROC_FS
229 * Function: blacklist_parse_proc_parameters
230 * parse the stuff which is piped to /proc/cio_ignore
232 static int blacklist_parse_proc_parameters(char *buf
)
237 parm
= strsep(&buf
, " ");
239 if (strcmp("free", parm
) == 0)
240 rc
= blacklist_parse_parameters(buf
, free
, 0);
241 else if (strcmp("add", parm
) == 0)
242 rc
= blacklist_parse_parameters(buf
, add
, 0);
243 else if (strcmp("purge", parm
) == 0)
244 return ccw_purge_blacklisted();
248 css_schedule_reprobe();
253 /* Iterator struct for all devices. */
261 cio_ignore_proc_seq_start(struct seq_file
*s
, loff_t
*offset
)
263 struct ccwdev_iter
*iter
= s
->private;
265 if (*offset
>= (__MAX_SUBCHANNEL
+ 1) * (__MAX_SSID
+ 1))
267 memset(iter
, 0, sizeof(*iter
));
268 iter
->ssid
= *offset
/ (__MAX_SUBCHANNEL
+ 1);
269 iter
->devno
= *offset
% (__MAX_SUBCHANNEL
+ 1);
274 cio_ignore_proc_seq_stop(struct seq_file
*s
, void *it
)
279 cio_ignore_proc_seq_next(struct seq_file
*s
, void *it
, loff_t
*offset
)
281 struct ccwdev_iter
*iter
;
283 if (*offset
>= (__MAX_SUBCHANNEL
+ 1) * (__MAX_SSID
+ 1))
286 if (iter
->devno
== __MAX_SUBCHANNEL
) {
289 if (iter
->ssid
> __MAX_SSID
)
298 cio_ignore_proc_seq_show(struct seq_file
*s
, void *it
)
300 struct ccwdev_iter
*iter
;
303 if (!is_blacklisted(iter
->ssid
, iter
->devno
))
304 /* Not blacklisted, nothing to output. */
306 if (!iter
->in_range
) {
307 /* First device in range. */
308 if ((iter
->devno
== __MAX_SUBCHANNEL
) ||
309 !is_blacklisted(iter
->ssid
, iter
->devno
+ 1))
310 /* Singular device. */
311 return seq_printf(s
, "0.%x.%04x\n",
312 iter
->ssid
, iter
->devno
);
314 return seq_printf(s
, "0.%x.%04x-", iter
->ssid
, iter
->devno
);
316 if ((iter
->devno
== __MAX_SUBCHANNEL
) ||
317 !is_blacklisted(iter
->ssid
, iter
->devno
+ 1)) {
318 /* Last device in range. */
320 return seq_printf(s
, "0.%x.%04x\n", iter
->ssid
, iter
->devno
);
326 cio_ignore_write(struct file
*file
, const char __user
*user_buf
,
327 size_t user_len
, loff_t
*offset
)
334 if (user_len
> 65536)
336 buf
= vzalloc(user_len
+ 1); /* maybe better use the stack? */
340 if (strncpy_from_user (buf
, user_buf
, user_len
) < 0) {
346 while ((i
>= 0) && (isspace(buf
[i
]) || (buf
[i
] == 0))) {
350 ret
= blacklist_parse_proc_parameters(buf
);
361 static const struct seq_operations cio_ignore_proc_seq_ops
= {
362 .start
= cio_ignore_proc_seq_start
,
363 .stop
= cio_ignore_proc_seq_stop
,
364 .next
= cio_ignore_proc_seq_next
,
365 .show
= cio_ignore_proc_seq_show
,
369 cio_ignore_proc_open(struct inode
*inode
, struct file
*file
)
371 return seq_open_private(file
, &cio_ignore_proc_seq_ops
,
372 sizeof(struct ccwdev_iter
));
375 static const struct file_operations cio_ignore_proc_fops
= {
376 .open
= cio_ignore_proc_open
,
379 .release
= seq_release_private
,
380 .write
= cio_ignore_write
,
384 cio_ignore_proc_init (void)
386 struct proc_dir_entry
*entry
;
388 entry
= proc_create("cio_ignore", S_IFREG
| S_IRUGO
| S_IWUSR
, NULL
,
389 &cio_ignore_proc_fops
);
395 __initcall (cio_ignore_proc_init
);
397 #endif /* CONFIG_PROC_FS */