1
2
3
4
5
6
7
8
9
10#define KMSG_COMPONENT "cio"
11#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
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>
19
20#include <asm/uaccess.h>
21#include <asm/cio.h>
22#include <asm/ipl.h>
23
24#include "blacklist.h"
25#include "cio.h"
26#include "cio_debug.h"
27#include "css.h"
28#include "device.h"
29
30
31
32
33
34
35
36
37
38
39#define __BL_DEV_WORDS ((__MAX_SUBCHANNEL + (8*sizeof(long) - 1)) / \
40 (8*sizeof(long)))
41static unsigned long bl_dev[__MAX_SSID + 1][__BL_DEV_WORDS];
42typedef enum {add, free} range_action;
43
44
45
46
47
48static int blacklist_range(range_action action, unsigned int from_ssid,
49 unsigned int to_ssid, unsigned int from,
50 unsigned int to, int msgtrigger)
51{
52 if ((from_ssid > to_ssid) || ((from_ssid == to_ssid) && (from > to))) {
53 if (msgtrigger)
54 pr_warn("0.%x.%04x to 0.%x.%04x is not a valid range for cio_ignore\n",
55 from_ssid, from, to_ssid, to);
56
57 return 1;
58 }
59
60 while ((from_ssid < to_ssid) || ((from_ssid == to_ssid) &&
61 (from <= to))) {
62 if (action == add)
63 set_bit(from, bl_dev[from_ssid]);
64 else
65 clear_bit(from, bl_dev[from_ssid]);
66 from++;
67 if (from > __MAX_SUBCHANNEL) {
68 from_ssid++;
69 from = 0;
70 }
71 }
72
73 return 0;
74}
75
76static int pure_hex(char **cp, unsigned int *val, int min_digit,
77 int max_digit, int max_val)
78{
79 int diff;
80
81 diff = 0;
82 *val = 0;
83
84 while (diff <= max_digit) {
85 int value = hex_to_bin(**cp);
86
87 if (value < 0)
88 break;
89 *val = *val * 16 + value;
90 (*cp)++;
91 diff++;
92 }
93
94 if ((diff < min_digit) || (diff > max_digit) || (*val > max_val))
95 return 1;
96
97 return 0;
98}
99
100static int parse_busid(char *str, unsigned int *cssid, unsigned int *ssid,
101 unsigned int *devno, int msgtrigger)
102{
103 char *str_work;
104 int val, rc, ret;
105
106 rc = 1;
107
108 if (*str == '\0')
109 goto out;
110
111
112 str_work = str;
113 val = simple_strtoul(str, &str_work, 16);
114
115 if (*str_work == '\0') {
116 if (val <= __MAX_SUBCHANNEL) {
117 *devno = val;
118 *ssid = 0;
119 *cssid = 0;
120 rc = 0;
121 }
122 goto out;
123 }
124
125
126 str_work = str;
127 ret = pure_hex(&str_work, cssid, 1, 2, __MAX_CSSID);
128 if (ret || (str_work[0] != '.'))
129 goto out;
130 str_work++;
131 ret = pure_hex(&str_work, ssid, 1, 1, __MAX_SSID);
132 if (ret || (str_work[0] != '.'))
133 goto out;
134 str_work++;
135 ret = pure_hex(&str_work, devno, 4, 4, __MAX_SUBCHANNEL);
136 if (ret || (str_work[0] != '\0'))
137 goto out;
138
139 rc = 0;
140out:
141 if (rc && msgtrigger)
142 pr_warn("%s is not a valid device for the cio_ignore kernel parameter\n",
143 str);
144
145 return rc;
146}
147
148static int blacklist_parse_parameters(char *str, range_action action,
149 int msgtrigger)
150{
151 unsigned int from_cssid, to_cssid, from_ssid, to_ssid, from, to;
152 int rc, totalrc;
153 char *parm;
154 range_action ra;
155
156 totalrc = 0;
157
158 while ((parm = strsep(&str, ","))) {
159 rc = 0;
160 ra = action;
161 if (*parm == '!') {
162 if (ra == add)
163 ra = free;
164 else
165 ra = add;
166 parm++;
167 }
168 if (strcmp(parm, "all") == 0) {
169 from_cssid = 0;
170 from_ssid = 0;
171 from = 0;
172 to_cssid = __MAX_CSSID;
173 to_ssid = __MAX_SSID;
174 to = __MAX_SUBCHANNEL;
175 } else if (strcmp(parm, "ipldev") == 0) {
176 if (ipl_info.type == IPL_TYPE_CCW) {
177 from_cssid = 0;
178 from_ssid = ipl_info.data.ccw.dev_id.ssid;
179 from = ipl_info.data.ccw.dev_id.devno;
180 } else if (ipl_info.type == IPL_TYPE_FCP ||
181 ipl_info.type == IPL_TYPE_FCP_DUMP) {
182 from_cssid = 0;
183 from_ssid = ipl_info.data.fcp.dev_id.ssid;
184 from = ipl_info.data.fcp.dev_id.devno;
185 } else {
186 continue;
187 }
188 to_cssid = from_cssid;
189 to_ssid = from_ssid;
190 to = from;
191 } else if (strcmp(parm, "condev") == 0) {
192 if (console_devno == -1)
193 continue;
194
195 from_cssid = to_cssid = 0;
196 from_ssid = to_ssid = 0;
197 from = to = console_devno;
198 } else {
199 rc = parse_busid(strsep(&parm, "-"), &from_cssid,
200 &from_ssid, &from, msgtrigger);
201 if (!rc) {
202 if (parm != NULL)
203 rc = parse_busid(parm, &to_cssid,
204 &to_ssid, &to,
205 msgtrigger);
206 else {
207 to_cssid = from_cssid;
208 to_ssid = from_ssid;
209 to = from;
210 }
211 }
212 }
213 if (!rc) {
214 rc = blacklist_range(ra, from_ssid, to_ssid, from, to,
215 msgtrigger);
216 if (rc)
217 totalrc = -EINVAL;
218 } else
219 totalrc = -EINVAL;
220 }
221
222 return totalrc;
223}
224
225static int __init
226blacklist_setup (char *str)
227{
228 CIO_MSG_EVENT(6, "Reading blacklist parameters\n");
229 if (blacklist_parse_parameters(str, add, 1))
230 return 0;
231 return 1;
232}
233
234__setup ("cio_ignore=", blacklist_setup);
235
236
237
238
239
240
241
242
243
244int
245is_blacklisted (int ssid, int devno)
246{
247 return test_bit (devno, bl_dev[ssid]);
248}
249
250#ifdef CONFIG_PROC_FS
251
252
253
254
255static int blacklist_parse_proc_parameters(char *buf)
256{
257 int rc;
258 char *parm;
259
260 parm = strsep(&buf, " ");
261
262 if (strcmp("free", parm) == 0) {
263 rc = blacklist_parse_parameters(buf, free, 0);
264 css_schedule_eval_all_unreg(0);
265 } else if (strcmp("add", parm) == 0)
266 rc = blacklist_parse_parameters(buf, add, 0);
267 else if (strcmp("purge", parm) == 0)
268 return ccw_purge_blacklisted();
269 else
270 return -EINVAL;
271
272
273 return rc;
274}
275
276
277struct ccwdev_iter {
278 int devno;
279 int ssid;
280 int in_range;
281};
282
283static void *
284cio_ignore_proc_seq_start(struct seq_file *s, loff_t *offset)
285{
286 struct ccwdev_iter *iter = s->private;
287
288 if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1))
289 return NULL;
290 memset(iter, 0, sizeof(*iter));
291 iter->ssid = *offset / (__MAX_SUBCHANNEL + 1);
292 iter->devno = *offset % (__MAX_SUBCHANNEL + 1);
293 return iter;
294}
295
296static void
297cio_ignore_proc_seq_stop(struct seq_file *s, void *it)
298{
299}
300
301static void *
302cio_ignore_proc_seq_next(struct seq_file *s, void *it, loff_t *offset)
303{
304 struct ccwdev_iter *iter;
305
306 if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1))
307 return NULL;
308 iter = it;
309 if (iter->devno == __MAX_SUBCHANNEL) {
310 iter->devno = 0;
311 iter->ssid++;
312 if (iter->ssid > __MAX_SSID)
313 return NULL;
314 } else
315 iter->devno++;
316 (*offset)++;
317 return iter;
318}
319
320static int
321cio_ignore_proc_seq_show(struct seq_file *s, void *it)
322{
323 struct ccwdev_iter *iter;
324
325 iter = it;
326 if (!is_blacklisted(iter->ssid, iter->devno))
327
328 return 0;
329 if (!iter->in_range) {
330
331 if ((iter->devno == __MAX_SUBCHANNEL) ||
332 !is_blacklisted(iter->ssid, iter->devno + 1)) {
333
334 seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno);
335 return 0;
336 }
337 iter->in_range = 1;
338 seq_printf(s, "0.%x.%04x-", iter->ssid, iter->devno);
339 return 0;
340 }
341 if ((iter->devno == __MAX_SUBCHANNEL) ||
342 !is_blacklisted(iter->ssid, iter->devno + 1)) {
343
344 iter->in_range = 0;
345 seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno);
346 }
347 return 0;
348}
349
350static ssize_t
351cio_ignore_write(struct file *file, const char __user *user_buf,
352 size_t user_len, loff_t *offset)
353{
354 char *buf;
355 ssize_t rc, ret, i;
356
357 if (*offset)
358 return -EINVAL;
359 if (user_len > 65536)
360 user_len = 65536;
361 buf = vzalloc(user_len + 1);
362 if (buf == NULL)
363 return -ENOMEM;
364
365 if (strncpy_from_user (buf, user_buf, user_len) < 0) {
366 rc = -EFAULT;
367 goto out_free;
368 }
369
370 i = user_len - 1;
371 while ((i >= 0) && (isspace(buf[i]) || (buf[i] == 0))) {
372 buf[i] = '\0';
373 i--;
374 }
375 ret = blacklist_parse_proc_parameters(buf);
376 if (ret)
377 rc = ret;
378 else
379 rc = user_len;
380
381out_free:
382 vfree (buf);
383 return rc;
384}
385
386static const struct seq_operations cio_ignore_proc_seq_ops = {
387 .start = cio_ignore_proc_seq_start,
388 .stop = cio_ignore_proc_seq_stop,
389 .next = cio_ignore_proc_seq_next,
390 .show = cio_ignore_proc_seq_show,
391};
392
393static int
394cio_ignore_proc_open(struct inode *inode, struct file *file)
395{
396 return seq_open_private(file, &cio_ignore_proc_seq_ops,
397 sizeof(struct ccwdev_iter));
398}
399
400static const struct file_operations cio_ignore_proc_fops = {
401 .open = cio_ignore_proc_open,
402 .read = seq_read,
403 .llseek = seq_lseek,
404 .release = seq_release_private,
405 .write = cio_ignore_write,
406};
407
408static int
409cio_ignore_proc_init (void)
410{
411 struct proc_dir_entry *entry;
412
413 entry = proc_create("cio_ignore", S_IFREG | S_IRUGO | S_IWUSR, NULL,
414 &cio_ignore_proc_fops);
415 if (!entry)
416 return -ENOENT;
417 return 0;
418}
419
420__initcall (cio_ignore_proc_init);
421
422#endif
423
