xref: /openbmc/linux/drivers/s390/block/dasd_devmap.c (revision e511167e)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
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  * Copyright IBM Corp. 1999,2001
9  *
10  * Device mapping and dasd= parameter parsing functions. All devmap
11  * functions may not be called from interrupt context. In particular
12  * dasd_get_device is a no-no from interrupt context.
13  *
14  */
15 
16 #define KMSG_COMPONENT "dasd"
17 
18 #include <linux/ctype.h>
19 #include <linux/init.h>
20 #include <linux/module.h>
21 #include <linux/slab.h>
22 
23 #include <asm/debug.h>
24 #include <linux/uaccess.h>
25 #include <asm/ipl.h>
26 
27 /* This is ugly... */
28 #define PRINTK_HEADER "dasd_devmap:"
29 #define DASD_MAX_PARAMS 256
30 
31 #include "dasd_int.h"
32 
33 struct kmem_cache *dasd_page_cache;
34 EXPORT_SYMBOL_GPL(dasd_page_cache);
35 
36 /*
37  * dasd_devmap_t is used to store the features and the relation
38  * between device number and device index. To find a dasd_devmap_t
39  * that corresponds to a device number of a device index each
40  * dasd_devmap_t is added to two linked lists, one to search by
41  * the device number and one to search by the device index. As
42  * soon as big minor numbers are available the device index list
43  * can be removed since the device number will then be identical
44  * to the device index.
45  */
46 struct dasd_devmap {
47 	struct list_head list;
48 	char bus_id[DASD_BUS_ID_SIZE];
49         unsigned int devindex;
50         unsigned short features;
51 	struct dasd_device *device;
52 	struct dasd_copy_relation *copy;
53 	unsigned int aq_mask;
54 };
55 
56 /*
57  * Parameter parsing functions for dasd= parameter. The syntax is:
58  *   <devno>		: (0x)?[0-9a-fA-F]+
59  *   <busid>		: [0-0a-f]\.[0-9a-f]\.(0x)?[0-9a-fA-F]+
60  *   <feature>		: ro
61  *   <feature_list>	: \(<feature>(:<feature>)*\)
62  *   <devno-range>	: <devno>(-<devno>)?<feature_list>?
63  *   <busid-range>	: <busid>(-<busid>)?<feature_list>?
64  *   <devices>		: <devno-range>|<busid-range>
65  *   <dasd_module>	: dasd_diag_mod|dasd_eckd_mod|dasd_fba_mod
66  *
67  *   <dasd>		: autodetect|probeonly|<devices>(,<devices>)*
68  */
69 
70 int dasd_probeonly =  0;	/* is true, when probeonly mode is active */
71 int dasd_autodetect = 0;	/* is true, when autodetection is active */
72 int dasd_nopav = 0;		/* is true, when PAV is disabled */
73 EXPORT_SYMBOL_GPL(dasd_nopav);
74 int dasd_nofcx;			/* disable High Performance Ficon */
75 EXPORT_SYMBOL_GPL(dasd_nofcx);
76 
77 /*
78  * char *dasd[] is intended to hold the ranges supplied by the dasd= statement
79  * it is named 'dasd' to directly be filled by insmod with the comma separated
80  * strings when running as a module.
81  */
82 static char *dasd[DASD_MAX_PARAMS];
83 module_param_array(dasd, charp, NULL, S_IRUGO);
84 
85 /*
86  * Single spinlock to protect devmap and servermap structures and lists.
87  */
88 static DEFINE_SPINLOCK(dasd_devmap_lock);
89 
90 /*
91  * Hash lists for devmap structures.
92  */
93 static struct list_head dasd_hashlists[256];
94 int dasd_max_devindex;
95 
96 static struct dasd_devmap *dasd_add_busid(const char *, int);
97 
98 static inline int
dasd_hash_busid(const char * bus_id)99 dasd_hash_busid(const char *bus_id)
100 {
101 	int hash, i;
102 
103 	hash = 0;
104 	for (i = 0; (i < DASD_BUS_ID_SIZE) && *bus_id; i++, bus_id++)
105 		hash += *bus_id;
106 	return hash & 0xff;
107 }
108 
109 #ifndef MODULE
dasd_call_setup(char * opt)110 static int __init dasd_call_setup(char *opt)
111 {
112 	static int i __initdata;
113 	char *tmp;
114 
115 	while (i < DASD_MAX_PARAMS) {
116 		tmp = strsep(&opt, ",");
117 		if (!tmp)
118 			break;
119 
120 		dasd[i++] = tmp;
121 	}
122 
123 	return 1;
124 }
125 
126 __setup ("dasd=", dasd_call_setup);
127 #endif	/* #ifndef MODULE */
128 
129 #define	DASD_IPLDEV	"ipldev"
130 
131 /*
132  * Read a device busid/devno from a string.
133  */
dasd_busid(char * str,int * id0,int * id1,int * devno)134 static int dasd_busid(char *str, int *id0, int *id1, int *devno)
135 {
136 	unsigned int val;
137 	char *tok;
138 
139 	/* Interpret ipldev busid */
140 	if (strncmp(DASD_IPLDEV, str, strlen(DASD_IPLDEV)) == 0) {
141 		if (ipl_info.type != IPL_TYPE_CCW) {
142 			pr_err("The IPL device is not a CCW device\n");
143 			return -EINVAL;
144 		}
145 		*id0 = 0;
146 		*id1 = ipl_info.data.ccw.dev_id.ssid;
147 		*devno = ipl_info.data.ccw.dev_id.devno;
148 
149 		return 0;
150 	}
151 
152 	/* Old style 0xXXXX or XXXX */
153 	if (!kstrtouint(str, 16, &val)) {
154 		*id0 = *id1 = 0;
155 		if (val > 0xffff)
156 			return -EINVAL;
157 		*devno = val;
158 		return 0;
159 	}
160 
161 	/* New style x.y.z busid */
162 	tok = strsep(&str, ".");
163 	if (kstrtouint(tok, 16, &val) || val > 0xff)
164 		return -EINVAL;
165 	*id0 = val;
166 
167 	tok = strsep(&str, ".");
168 	if (kstrtouint(tok, 16, &val) || val > 0xff)
169 		return -EINVAL;
170 	*id1 = val;
171 
172 	tok = strsep(&str, ".");
173 	if (kstrtouint(tok, 16, &val) || val > 0xffff)
174 		return -EINVAL;
175 	*devno = val;
176 
177 	return 0;
178 }
179 
180 /*
181  * Read colon separated list of dasd features.
182  */
dasd_feature_list(char * str)183 static int __init dasd_feature_list(char *str)
184 {
185 	int features, len, rc;
186 
187 	features = 0;
188 	rc = 0;
189 
190 	if (!str)
191 		return DASD_FEATURE_DEFAULT;
192 
193 	while (1) {
194 		for (len = 0;
195 		     str[len] && str[len] != ':' && str[len] != ')'; len++);
196 		if (len == 2 && !strncmp(str, "ro", 2))
197 			features |= DASD_FEATURE_READONLY;
198 		else if (len == 4 && !strncmp(str, "diag", 4))
199 			features |= DASD_FEATURE_USEDIAG;
200 		else if (len == 3 && !strncmp(str, "raw", 3))
201 			features |= DASD_FEATURE_USERAW;
202 		else if (len == 6 && !strncmp(str, "erplog", 6))
203 			features |= DASD_FEATURE_ERPLOG;
204 		else if (len == 8 && !strncmp(str, "failfast", 8))
205 			features |= DASD_FEATURE_FAILFAST;
206 		else {
207 			pr_warn("%.*s is not a supported device option\n",
208 				len, str);
209 			rc = -EINVAL;
210 		}
211 		str += len;
212 		if (*str != ':')
213 			break;
214 		str++;
215 	}
216 
217 	return rc ? : features;
218 }
219 
220 /*
221  * Try to match the first element on the comma separated parse string
222  * with one of the known keywords. If a keyword is found, take the approprate
223  * action and return a pointer to the residual string. If the first element
224  * could not be matched to any keyword then return an error code.
225  */
dasd_parse_keyword(char * keyword)226 static int __init dasd_parse_keyword(char *keyword)
227 {
228 	int length = strlen(keyword);
229 
230 	if (strncmp("autodetect", keyword, length) == 0) {
231 		dasd_autodetect = 1;
232 		pr_info("The autodetection mode has been activated\n");
233 		return 0;
234         }
235 	if (strncmp("probeonly", keyword, length) == 0) {
236 		dasd_probeonly = 1;
237 		pr_info("The probeonly mode has been activated\n");
238 		return 0;
239         }
240 	if (strncmp("nopav", keyword, length) == 0) {
241 		if (MACHINE_IS_VM)
242 			pr_info("'nopav' is not supported on z/VM\n");
243 		else {
244 			dasd_nopav = 1;
245 			pr_info("PAV support has be deactivated\n");
246 		}
247 		return 0;
248 	}
249 	if (strncmp("nofcx", keyword, length) == 0) {
250 		dasd_nofcx = 1;
251 		pr_info("High Performance FICON support has been "
252 			"deactivated\n");
253 		return 0;
254 	}
255 	if (strncmp("fixedbuffers", keyword, length) == 0) {
256 		if (dasd_page_cache)
257 			return 0;
258 		dasd_page_cache =
259 			kmem_cache_create("dasd_page_cache", PAGE_SIZE,
260 					  PAGE_SIZE, SLAB_CACHE_DMA,
261 					  NULL);
262 		if (!dasd_page_cache)
263 			DBF_EVENT(DBF_WARNING, "%s", "Failed to create slab, "
264 				"fixed buffer mode disabled.");
265 		else
266 			DBF_EVENT(DBF_INFO, "%s",
267 				 "turning on fixed buffer mode");
268 		return 0;
269 	}
270 
271 	return -EINVAL;
272 }
273 
274 /*
275  * Split a string of a device range into its pieces and return the from, to, and
276  * feature parts separately.
277  * e.g.:
278  * 0.0.1234-0.0.5678(ro:erplog) -> from: 0.0.1234 to: 0.0.5678 features: ro:erplog
279  * 0.0.8765(raw) -> from: 0.0.8765 to: null features: raw
280  * 0x4321 -> from: 0x4321 to: null features: null
281  */
dasd_evaluate_range_param(char * range,char ** from_str,char ** to_str,char ** features_str)282 static int __init dasd_evaluate_range_param(char *range, char **from_str,
283 					    char **to_str, char **features_str)
284 {
285 	int rc = 0;
286 
287 	/* Do we have a range or a single device? */
288 	if (strchr(range, '-')) {
289 		*from_str = strsep(&range, "-");
290 		*to_str = strsep(&range, "(");
291 		*features_str = strsep(&range, ")");
292 	} else {
293 		*from_str = strsep(&range, "(");
294 		*features_str = strsep(&range, ")");
295 	}
296 
297 	if (*features_str && !range) {
298 		pr_warn("A closing parenthesis ')' is missing in the dasd= parameter\n");
299 		rc = -EINVAL;
300 	}
301 
302 	return rc;
303 }
304 
305 /*
306  * Try to interprete the range string as a device number or a range of devices.
307  * If the interpretation is successful, create the matching dasd_devmap entries.
308  * If interpretation fails or in case of an error, return an error code.
309  */
dasd_parse_range(const char * range)310 static int __init dasd_parse_range(const char *range)
311 {
312 	struct dasd_devmap *devmap;
313 	int from, from_id0, from_id1;
314 	int to, to_id0, to_id1;
315 	int features;
316 	char bus_id[DASD_BUS_ID_SIZE + 1];
317 	char *features_str = NULL;
318 	char *from_str = NULL;
319 	char *to_str = NULL;
320 	int rc = 0;
321 	char *tmp;
322 
323 	tmp = kstrdup(range, GFP_KERNEL);
324 	if (!tmp)
325 		return -ENOMEM;
326 
327 	if (dasd_evaluate_range_param(tmp, &from_str, &to_str, &features_str)) {
328 		rc = -EINVAL;
329 		goto out;
330 	}
331 
332 	if (dasd_busid(from_str, &from_id0, &from_id1, &from)) {
333 		rc = -EINVAL;
334 		goto out;
335 	}
336 
337 	to = from;
338 	to_id0 = from_id0;
339 	to_id1 = from_id1;
340 	if (to_str) {
341 		if (dasd_busid(to_str, &to_id0, &to_id1, &to)) {
342 			rc = -EINVAL;
343 			goto out;
344 		}
345 		if (from_id0 != to_id0 || from_id1 != to_id1 || from > to) {
346 			pr_err("%s is not a valid device range\n", range);
347 			rc = -EINVAL;
348 			goto out;
349 		}
350 	}
351 
352 	features = dasd_feature_list(features_str);
353 	if (features < 0) {
354 		rc = -EINVAL;
355 		goto out;
356 	}
357 	/* each device in dasd= parameter should be set initially online */
358 	features |= DASD_FEATURE_INITIAL_ONLINE;
359 	while (from <= to) {
360 		sprintf(bus_id, "%01x.%01x.%04x", from_id0, from_id1, from++);
361 		devmap = dasd_add_busid(bus_id, features);
362 		if (IS_ERR(devmap)) {
363 			rc = PTR_ERR(devmap);
364 			goto out;
365 		}
366 	}
367 
368 out:
369 	kfree(tmp);
370 
371 	return rc;
372 }
373 
374 /*
375  * Parse parameters stored in dasd[]
376  * The 'dasd=...' parameter allows to specify a comma separated list of
377  * keywords and device ranges. The parameters in that list will be stored as
378  * separate elementes in dasd[].
379  */
dasd_parse(void)380 int __init dasd_parse(void)
381 {
382 	int rc, i;
383 	char *cur;
384 
385 	rc = 0;
386 	for (i = 0; i < DASD_MAX_PARAMS; i++) {
387 		cur = dasd[i];
388 		if (!cur)
389 			break;
390 		if (*cur == '\0')
391 			continue;
392 
393 		rc = dasd_parse_keyword(cur);
394 		if (rc)
395 			rc = dasd_parse_range(cur);
396 
397 		if (rc)
398 			break;
399 	}
400 
401 	return rc;
402 }
403 
404 /*
405  * Add a devmap for the device specified by busid. It is possible that
406  * the devmap already exists (dasd= parameter). The order of the devices
407  * added through this function will define the kdevs for the individual
408  * devices.
409  */
410 static struct dasd_devmap *
dasd_add_busid(const char * bus_id,int features)411 dasd_add_busid(const char *bus_id, int features)
412 {
413 	struct dasd_devmap *devmap, *new, *tmp;
414 	int hash;
415 
416 	new = kzalloc(sizeof(struct dasd_devmap), GFP_KERNEL);
417 	if (!new)
418 		return ERR_PTR(-ENOMEM);
419 	spin_lock(&dasd_devmap_lock);
420 	devmap = NULL;
421 	hash = dasd_hash_busid(bus_id);
422 	list_for_each_entry(tmp, &dasd_hashlists[hash], list)
423 		if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) {
424 			devmap = tmp;
425 			break;
426 		}
427 	if (!devmap) {
428 		/* This bus_id is new. */
429 		new->devindex = dasd_max_devindex++;
430 		strscpy(new->bus_id, bus_id, DASD_BUS_ID_SIZE);
431 		new->features = features;
432 		new->device = NULL;
433 		list_add(&new->list, &dasd_hashlists[hash]);
434 		devmap = new;
435 		new = NULL;
436 	}
437 	spin_unlock(&dasd_devmap_lock);
438 	kfree(new);
439 	return devmap;
440 }
441 
442 static struct dasd_devmap *
dasd_find_busid_locked(const char * bus_id)443 dasd_find_busid_locked(const char *bus_id)
444 {
445 	struct dasd_devmap *devmap, *tmp;
446 	int hash;
447 
448 	devmap = ERR_PTR(-ENODEV);
449 	hash = dasd_hash_busid(bus_id);
450 	list_for_each_entry(tmp, &dasd_hashlists[hash], list) {
451 		if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) {
452 			devmap = tmp;
453 			break;
454 		}
455 	}
456 	return devmap;
457 }
458 
459 /*
460  * Find devmap for device with given bus_id.
461  */
462 static struct dasd_devmap *
dasd_find_busid(const char * bus_id)463 dasd_find_busid(const char *bus_id)
464 {
465 	struct dasd_devmap *devmap;
466 
467 	spin_lock(&dasd_devmap_lock);
468 	devmap = dasd_find_busid_locked(bus_id);
469 	spin_unlock(&dasd_devmap_lock);
470 	return devmap;
471 }
472 
473 /*
474  * Check if busid has been added to the list of dasd ranges.
475  */
476 int
dasd_busid_known(const char * bus_id)477 dasd_busid_known(const char *bus_id)
478 {
479 	return IS_ERR(dasd_find_busid(bus_id)) ? -ENOENT : 0;
480 }
481 
482 /*
483  * Forget all about the device numbers added so far.
484  * This may only be called at module unload or system shutdown.
485  */
486 static void
dasd_forget_ranges(void)487 dasd_forget_ranges(void)
488 {
489 	struct dasd_devmap *devmap, *n;
490 	int i;
491 
492 	spin_lock(&dasd_devmap_lock);
493 	for (i = 0; i < 256; i++) {
494 		list_for_each_entry_safe(devmap, n, &dasd_hashlists[i], list) {
495 			BUG_ON(devmap->device != NULL);
496 			list_del(&devmap->list);
497 			kfree(devmap);
498 		}
499 	}
500 	spin_unlock(&dasd_devmap_lock);
501 }
502 
503 /*
504  * Find the device struct by its device index.
505  */
506 struct dasd_device *
dasd_device_from_devindex(int devindex)507 dasd_device_from_devindex(int devindex)
508 {
509 	struct dasd_devmap *devmap, *tmp;
510 	struct dasd_device *device;
511 	int i;
512 
513 	spin_lock(&dasd_devmap_lock);
514 	devmap = NULL;
515 	for (i = 0; (i < 256) && !devmap; i++)
516 		list_for_each_entry(tmp, &dasd_hashlists[i], list)
517 			if (tmp->devindex == devindex) {
518 				/* Found the devmap for the device. */
519 				devmap = tmp;
520 				break;
521 			}
522 	if (devmap && devmap->device) {
523 		device = devmap->device;
524 		dasd_get_device(device);
525 	} else
526 		device = ERR_PTR(-ENODEV);
527 	spin_unlock(&dasd_devmap_lock);
528 	return device;
529 }
530 
531 /*
532  * Return devmap for cdev. If no devmap exists yet, create one and
533  * connect it to the cdev.
534  */
535 static struct dasd_devmap *
dasd_devmap_from_cdev(struct ccw_device * cdev)536 dasd_devmap_from_cdev(struct ccw_device *cdev)
537 {
538 	struct dasd_devmap *devmap;
539 
540 	devmap = dasd_find_busid(dev_name(&cdev->dev));
541 	if (IS_ERR(devmap))
542 		devmap = dasd_add_busid(dev_name(&cdev->dev),
543 					DASD_FEATURE_DEFAULT);
544 	return devmap;
545 }
546 
547 /*
548  * Create a dasd device structure for cdev.
549  */
550 struct dasd_device *
dasd_create_device(struct ccw_device * cdev)551 dasd_create_device(struct ccw_device *cdev)
552 {
553 	struct dasd_devmap *devmap;
554 	struct dasd_device *device;
555 	unsigned long flags;
556 	int rc;
557 
558 	devmap = dasd_devmap_from_cdev(cdev);
559 	if (IS_ERR(devmap))
560 		return (void *) devmap;
561 
562 	device = dasd_alloc_device();
563 	if (IS_ERR(device))
564 		return device;
565 	atomic_set(&device->ref_count, 3);
566 
567 	spin_lock(&dasd_devmap_lock);
568 	if (!devmap->device) {
569 		devmap->device = device;
570 		device->devindex = devmap->devindex;
571 		device->features = devmap->features;
572 		get_device(&cdev->dev);
573 		device->cdev = cdev;
574 		rc = 0;
575 	} else
576 		/* Someone else was faster. */
577 		rc = -EBUSY;
578 	spin_unlock(&dasd_devmap_lock);
579 
580 	if (rc) {
581 		dasd_free_device(device);
582 		return ERR_PTR(rc);
583 	}
584 
585 	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
586 	dev_set_drvdata(&cdev->dev, device);
587 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
588 
589 	device->paths_info = kset_create_and_add("paths_info", NULL,
590 						 &device->cdev->dev.kobj);
591 	if (!device->paths_info)
592 		dev_warn(&cdev->dev, "Could not create paths_info kset\n");
593 
594 	return device;
595 }
596 
597 /*
598  * allocate a PPRC data structure and call the discipline function to fill
599  */
dasd_devmap_get_pprc_status(struct dasd_device * device,struct dasd_pprc_data_sc4 ** data)600 static int dasd_devmap_get_pprc_status(struct dasd_device *device,
601 				       struct dasd_pprc_data_sc4 **data)
602 {
603 	struct dasd_pprc_data_sc4 *temp;
604 
605 	if (!device->discipline || !device->discipline->pprc_status) {
606 		dev_warn(&device->cdev->dev, "Unable to query copy relation status\n");
607 		return -EOPNOTSUPP;
608 	}
609 	temp = kzalloc(sizeof(*temp), GFP_KERNEL);
610 	if (!temp)
611 		return -ENOMEM;
612 
613 	/* get PPRC information from storage */
614 	if (device->discipline->pprc_status(device, temp)) {
615 		dev_warn(&device->cdev->dev, "Error during copy relation status query\n");
616 		kfree(temp);
617 		return -EINVAL;
618 	}
619 	*data = temp;
620 
621 	return 0;
622 }
623 
624 /*
625  * find an entry in a PPRC device_info array by a given UID
626  * depending on the primary/secondary state of the device it has to be
627  * matched with the respective fields
628  */
dasd_devmap_entry_from_pprc_data(struct dasd_pprc_data_sc4 * data,struct dasd_uid uid,bool primary)629 static int dasd_devmap_entry_from_pprc_data(struct dasd_pprc_data_sc4 *data,
630 					    struct dasd_uid uid,
631 					    bool primary)
632 {
633 	int i;
634 
635 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
636 		if (primary) {
637 			if (data->dev_info[i].prim_cu_ssid == uid.ssid &&
638 			    data->dev_info[i].primary == uid.real_unit_addr)
639 				return i;
640 		} else {
641 			if (data->dev_info[i].sec_cu_ssid == uid.ssid &&
642 			    data->dev_info[i].secondary == uid.real_unit_addr)
643 				return i;
644 		}
645 	}
646 	return -1;
647 }
648 
649 /*
650  * check the consistency of a specified copy relation by checking
651  * the following things:
652  *
653  *   - is the given device part of a copy pair setup
654  *   - does the state of the device match the state in the PPRC status data
655  *   - does the device UID match with the UID in the PPRC status data
656  *   - to prevent misrouted IO check if the given device is present in all
657  *     related PPRC status data
658  */
dasd_devmap_check_copy_relation(struct dasd_device * device,struct dasd_copy_entry * entry,struct dasd_pprc_data_sc4 * data,struct dasd_copy_relation * copy)659 static int dasd_devmap_check_copy_relation(struct dasd_device *device,
660 					   struct dasd_copy_entry *entry,
661 					   struct dasd_pprc_data_sc4 *data,
662 					   struct dasd_copy_relation *copy)
663 {
664 	struct dasd_pprc_data_sc4 *tmp_dat;
665 	struct dasd_device *tmp_dev;
666 	struct dasd_uid uid;
667 	int i, j;
668 
669 	if (!device->discipline || !device->discipline->get_uid ||
670 	    device->discipline->get_uid(device, &uid))
671 		return 1;
672 
673 	i = dasd_devmap_entry_from_pprc_data(data, uid, entry->primary);
674 	if (i < 0) {
675 		dev_warn(&device->cdev->dev, "Device not part of a copy relation\n");
676 		return 1;
677 	}
678 
679 	/* double check which role the current device has */
680 	if (entry->primary) {
681 		if (data->dev_info[i].flags & 0x80) {
682 			dev_warn(&device->cdev->dev, "Copy pair secondary is setup as primary\n");
683 			return 1;
684 		}
685 		if (data->dev_info[i].prim_cu_ssid != uid.ssid ||
686 		    data->dev_info[i].primary != uid.real_unit_addr) {
687 			dev_warn(&device->cdev->dev,
688 				 "Primary device %s does not match copy pair status primary device %04x\n",
689 				 dev_name(&device->cdev->dev),
690 				 data->dev_info[i].prim_cu_ssid |
691 				 data->dev_info[i].primary);
692 			return 1;
693 		}
694 	} else {
695 		if (!(data->dev_info[i].flags & 0x80)) {
696 			dev_warn(&device->cdev->dev, "Copy pair primary is setup as secondary\n");
697 			return 1;
698 		}
699 		if (data->dev_info[i].sec_cu_ssid != uid.ssid ||
700 		    data->dev_info[i].secondary != uid.real_unit_addr) {
701 			dev_warn(&device->cdev->dev,
702 				 "Secondary device %s does not match copy pair status secondary device %04x\n",
703 				 dev_name(&device->cdev->dev),
704 				 data->dev_info[i].sec_cu_ssid |
705 				 data->dev_info[i].secondary);
706 			return 1;
707 		}
708 	}
709 
710 	/*
711 	 * the current device has to be part of the copy relation of all
712 	 * entries to prevent misrouted IO to another copy pair
713 	 */
714 	for (j = 0; j < DASD_CP_ENTRIES; j++) {
715 		if (entry == &copy->entry[j])
716 			tmp_dev = device;
717 		else
718 			tmp_dev = copy->entry[j].device;
719 
720 		if (!tmp_dev)
721 			continue;
722 
723 		if (dasd_devmap_get_pprc_status(tmp_dev, &tmp_dat))
724 			return 1;
725 
726 		if (dasd_devmap_entry_from_pprc_data(tmp_dat, uid, entry->primary) < 0) {
727 			dev_warn(&tmp_dev->cdev->dev,
728 				 "Copy pair relation does not contain device: %s\n",
729 				 dev_name(&device->cdev->dev));
730 			kfree(tmp_dat);
731 			return 1;
732 		}
733 		kfree(tmp_dat);
734 	}
735 	return 0;
736 }
737 
738 /* delete device from copy relation entry */
dasd_devmap_delete_copy_relation_device(struct dasd_device * device)739 static void dasd_devmap_delete_copy_relation_device(struct dasd_device *device)
740 {
741 	struct dasd_copy_relation *copy;
742 	int i;
743 
744 	if (!device->copy)
745 		return;
746 
747 	copy = device->copy;
748 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
749 		if (copy->entry[i].device == device)
750 			copy->entry[i].device = NULL;
751 	}
752 	dasd_put_device(device);
753 	device->copy = NULL;
754 }
755 
756 /*
757  * read all required information for a copy relation setup and setup the device
758  * accordingly
759  */
dasd_devmap_set_device_copy_relation(struct ccw_device * cdev,bool pprc_enabled)760 int dasd_devmap_set_device_copy_relation(struct ccw_device *cdev,
761 					 bool pprc_enabled)
762 {
763 	struct dasd_pprc_data_sc4 *data = NULL;
764 	struct dasd_copy_entry *entry = NULL;
765 	struct dasd_copy_relation *copy;
766 	struct dasd_devmap *devmap;
767 	struct dasd_device *device;
768 	int i, rc = 0;
769 
770 	devmap = dasd_devmap_from_cdev(cdev);
771 	if (IS_ERR(devmap))
772 		return PTR_ERR(devmap);
773 
774 	device = devmap->device;
775 	if (!device)
776 		return -ENODEV;
777 
778 	copy = devmap->copy;
779 	/* no copy pair setup for this device */
780 	if (!copy)
781 		goto out;
782 
783 	rc = dasd_devmap_get_pprc_status(device, &data);
784 	if (rc)
785 		return rc;
786 
787 	/* print error if PPRC is requested but not enabled on storage server */
788 	if (!pprc_enabled) {
789 		dev_err(&cdev->dev, "Copy relation not enabled on storage server\n");
790 		rc = -EINVAL;
791 		goto out;
792 	}
793 
794 	if (!data->dev_info[0].state) {
795 		dev_warn(&device->cdev->dev, "Copy pair setup requested for device not in copy relation\n");
796 		rc = -EINVAL;
797 		goto out;
798 	}
799 	/* find entry */
800 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
801 		if (copy->entry[i].configured &&
802 		    strncmp(dev_name(&cdev->dev),
803 			    copy->entry[i].busid, DASD_BUS_ID_SIZE) == 0) {
804 			entry = &copy->entry[i];
805 			break;
806 		}
807 	}
808 	if (!entry) {
809 		dev_warn(&device->cdev->dev, "Copy relation entry not found\n");
810 		rc = -EINVAL;
811 		goto out;
812 	}
813 	/* check if the copy relation is valid */
814 	if (dasd_devmap_check_copy_relation(device, entry, data, copy)) {
815 		dev_warn(&device->cdev->dev, "Copy relation faulty\n");
816 		rc = -EINVAL;
817 		goto out;
818 	}
819 
820 	dasd_get_device(device);
821 	copy->entry[i].device = device;
822 	device->copy = copy;
823 out:
824 	kfree(data);
825 	return rc;
826 }
827 EXPORT_SYMBOL_GPL(dasd_devmap_set_device_copy_relation);
828 
829 /*
830  * Wait queue for dasd_delete_device waits.
831  */
832 static DECLARE_WAIT_QUEUE_HEAD(dasd_delete_wq);
833 
834 /*
835  * Remove a dasd device structure. The passed referenced
836  * is destroyed.
837  */
838 void
dasd_delete_device(struct dasd_device * device)839 dasd_delete_device(struct dasd_device *device)
840 {
841 	struct ccw_device *cdev;
842 	struct dasd_devmap *devmap;
843 	unsigned long flags;
844 
845 	/* First remove device pointer from devmap. */
846 	devmap = dasd_find_busid(dev_name(&device->cdev->dev));
847 	BUG_ON(IS_ERR(devmap));
848 	spin_lock(&dasd_devmap_lock);
849 	if (devmap->device != device) {
850 		spin_unlock(&dasd_devmap_lock);
851 		dasd_put_device(device);
852 		return;
853 	}
854 	devmap->device = NULL;
855 	spin_unlock(&dasd_devmap_lock);
856 
857 	/* Disconnect dasd_device structure from ccw_device structure. */
858 	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
859 	dev_set_drvdata(&device->cdev->dev, NULL);
860 	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
861 
862 	/* Removve copy relation */
863 	dasd_devmap_delete_copy_relation_device(device);
864 	/*
865 	 * Drop ref_count by 3, one for the devmap reference, one for
866 	 * the cdev reference and one for the passed reference.
867 	 */
868 	atomic_sub(3, &device->ref_count);
869 
870 	/* Wait for reference counter to drop to zero. */
871 	wait_event(dasd_delete_wq, atomic_read(&device->ref_count) == 0);
872 
873 	dasd_generic_free_discipline(device);
874 
875 	kset_unregister(device->paths_info);
876 
877 	/* Disconnect dasd_device structure from ccw_device structure. */
878 	cdev = device->cdev;
879 	device->cdev = NULL;
880 
881 	/* Put ccw_device structure. */
882 	put_device(&cdev->dev);
883 
884 	/* Now the device structure can be freed. */
885 	dasd_free_device(device);
886 }
887 
888 /*
889  * Reference counter dropped to zero. Wake up waiter
890  * in dasd_delete_device.
891  */
892 void
dasd_put_device_wake(struct dasd_device * device)893 dasd_put_device_wake(struct dasd_device *device)
894 {
895 	wake_up(&dasd_delete_wq);
896 }
897 EXPORT_SYMBOL_GPL(dasd_put_device_wake);
898 
899 /*
900  * Return dasd_device structure associated with cdev.
901  * This function needs to be called with the ccw device
902  * lock held. It can be used from interrupt context.
903  */
904 struct dasd_device *
dasd_device_from_cdev_locked(struct ccw_device * cdev)905 dasd_device_from_cdev_locked(struct ccw_device *cdev)
906 {
907 	struct dasd_device *device = dev_get_drvdata(&cdev->dev);
908 
909 	if (!device)
910 		return ERR_PTR(-ENODEV);
911 	dasd_get_device(device);
912 	return device;
913 }
914 
915 /*
916  * Return dasd_device structure associated with cdev.
917  */
918 struct dasd_device *
dasd_device_from_cdev(struct ccw_device * cdev)919 dasd_device_from_cdev(struct ccw_device *cdev)
920 {
921 	struct dasd_device *device;
922 	unsigned long flags;
923 
924 	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
925 	device = dasd_device_from_cdev_locked(cdev);
926 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
927 	return device;
928 }
929 
dasd_add_link_to_gendisk(struct gendisk * gdp,struct dasd_device * device)930 void dasd_add_link_to_gendisk(struct gendisk *gdp, struct dasd_device *device)
931 {
932 	struct dasd_devmap *devmap;
933 
934 	devmap = dasd_find_busid(dev_name(&device->cdev->dev));
935 	if (IS_ERR(devmap))
936 		return;
937 	spin_lock(&dasd_devmap_lock);
938 	gdp->private_data = devmap;
939 	spin_unlock(&dasd_devmap_lock);
940 }
941 EXPORT_SYMBOL(dasd_add_link_to_gendisk);
942 
dasd_device_from_gendisk(struct gendisk * gdp)943 struct dasd_device *dasd_device_from_gendisk(struct gendisk *gdp)
944 {
945 	struct dasd_device *device;
946 	struct dasd_devmap *devmap;
947 
948 	if (!gdp->private_data)
949 		return NULL;
950 	device = NULL;
951 	spin_lock(&dasd_devmap_lock);
952 	devmap = gdp->private_data;
953 	if (devmap && devmap->device) {
954 		device = devmap->device;
955 		dasd_get_device(device);
956 	}
957 	spin_unlock(&dasd_devmap_lock);
958 	return device;
959 }
960 
961 /*
962  * SECTION: files in sysfs
963  */
964 
965 /*
966  * failfast controls the behaviour, if no path is available
967  */
dasd_ff_show(struct device * dev,struct device_attribute * attr,char * buf)968 static ssize_t dasd_ff_show(struct device *dev, struct device_attribute *attr,
969 			    char *buf)
970 {
971 	struct dasd_devmap *devmap;
972 	int ff_flag;
973 
974 	devmap = dasd_find_busid(dev_name(dev));
975 	if (!IS_ERR(devmap))
976 		ff_flag = (devmap->features & DASD_FEATURE_FAILFAST) != 0;
977 	else
978 		ff_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_FAILFAST) != 0;
979 	return sysfs_emit(buf, ff_flag ? "1\n" : "0\n");
980 }
981 
dasd_ff_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)982 static ssize_t dasd_ff_store(struct device *dev, struct device_attribute *attr,
983 	      const char *buf, size_t count)
984 {
985 	unsigned int val;
986 	int rc;
987 
988 	if (kstrtouint(buf, 0, &val) || val > 1)
989 		return -EINVAL;
990 
991 	rc = dasd_set_feature(to_ccwdev(dev), DASD_FEATURE_FAILFAST, val);
992 
993 	return rc ? : count;
994 }
995 
996 static DEVICE_ATTR(failfast, 0644, dasd_ff_show, dasd_ff_store);
997 
998 /*
999  * readonly controls the readonly status of a dasd
1000  */
1001 static ssize_t
dasd_ro_show(struct device * dev,struct device_attribute * attr,char * buf)1002 dasd_ro_show(struct device *dev, struct device_attribute *attr, char *buf)
1003 {
1004 	struct dasd_devmap *devmap;
1005 	struct dasd_device *device;
1006 	int ro_flag = 0;
1007 
1008 	devmap = dasd_find_busid(dev_name(dev));
1009 	if (IS_ERR(devmap))
1010 		goto out;
1011 
1012 	ro_flag = !!(devmap->features & DASD_FEATURE_READONLY);
1013 
1014 	spin_lock(&dasd_devmap_lock);
1015 	device = devmap->device;
1016 	if (device)
1017 		ro_flag |= test_bit(DASD_FLAG_DEVICE_RO, &device->flags);
1018 	spin_unlock(&dasd_devmap_lock);
1019 
1020 out:
1021 	return sysfs_emit(buf, ro_flag ? "1\n" : "0\n");
1022 }
1023 
1024 static ssize_t
dasd_ro_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1025 dasd_ro_store(struct device *dev, struct device_attribute *attr,
1026 	      const char *buf, size_t count)
1027 {
1028 	struct ccw_device *cdev = to_ccwdev(dev);
1029 	struct dasd_device *device;
1030 	unsigned long flags;
1031 	unsigned int val;
1032 	int rc;
1033 
1034 	if (kstrtouint(buf, 0, &val) || val > 1)
1035 		return -EINVAL;
1036 
1037 	rc = dasd_set_feature(cdev, DASD_FEATURE_READONLY, val);
1038 	if (rc)
1039 		return rc;
1040 
1041 	device = dasd_device_from_cdev(cdev);
1042 	if (IS_ERR(device))
1043 		return count;
1044 
1045 	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1046 	val = val || test_bit(DASD_FLAG_DEVICE_RO, &device->flags);
1047 
1048 	if (!device->block || !device->block->gdp ||
1049 	    test_bit(DASD_FLAG_OFFLINE, &device->flags)) {
1050 		spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1051 		goto out;
1052 	}
1053 	/* Increase open_count to avoid losing the block device */
1054 	atomic_inc(&device->block->open_count);
1055 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1056 
1057 	set_disk_ro(device->block->gdp, val);
1058 	atomic_dec(&device->block->open_count);
1059 
1060 out:
1061 	dasd_put_device(device);
1062 
1063 	return count;
1064 }
1065 
1066 static DEVICE_ATTR(readonly, 0644, dasd_ro_show, dasd_ro_store);
1067 /*
1068  * erplog controls the logging of ERP related data
1069  * (e.g. failing channel programs).
1070  */
1071 static ssize_t
dasd_erplog_show(struct device * dev,struct device_attribute * attr,char * buf)1072 dasd_erplog_show(struct device *dev, struct device_attribute *attr, char *buf)
1073 {
1074 	struct dasd_devmap *devmap;
1075 	int erplog;
1076 
1077 	devmap = dasd_find_busid(dev_name(dev));
1078 	if (!IS_ERR(devmap))
1079 		erplog = (devmap->features & DASD_FEATURE_ERPLOG) != 0;
1080 	else
1081 		erplog = (DASD_FEATURE_DEFAULT & DASD_FEATURE_ERPLOG) != 0;
1082 	return sysfs_emit(buf, erplog ? "1\n" : "0\n");
1083 }
1084 
1085 static ssize_t
dasd_erplog_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1086 dasd_erplog_store(struct device *dev, struct device_attribute *attr,
1087 	      const char *buf, size_t count)
1088 {
1089 	unsigned int val;
1090 	int rc;
1091 
1092 	if (kstrtouint(buf, 0, &val) || val > 1)
1093 		return -EINVAL;
1094 
1095 	rc = dasd_set_feature(to_ccwdev(dev), DASD_FEATURE_ERPLOG, val);
1096 
1097 	return rc ? : count;
1098 }
1099 
1100 static DEVICE_ATTR(erplog, 0644, dasd_erplog_show, dasd_erplog_store);
1101 
1102 /*
1103  * use_diag controls whether the driver should use diag rather than ssch
1104  * to talk to the device
1105  */
1106 static ssize_t
dasd_use_diag_show(struct device * dev,struct device_attribute * attr,char * buf)1107 dasd_use_diag_show(struct device *dev, struct device_attribute *attr, char *buf)
1108 {
1109 	struct dasd_devmap *devmap;
1110 	int use_diag;
1111 
1112 	devmap = dasd_find_busid(dev_name(dev));
1113 	if (!IS_ERR(devmap))
1114 		use_diag = (devmap->features & DASD_FEATURE_USEDIAG) != 0;
1115 	else
1116 		use_diag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USEDIAG) != 0;
1117 	return sprintf(buf, use_diag ? "1\n" : "0\n");
1118 }
1119 
1120 static ssize_t
dasd_use_diag_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1121 dasd_use_diag_store(struct device *dev, struct device_attribute *attr,
1122 		    const char *buf, size_t count)
1123 {
1124 	struct dasd_devmap *devmap;
1125 	unsigned int val;
1126 	ssize_t rc;
1127 
1128 	devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
1129 	if (IS_ERR(devmap))
1130 		return PTR_ERR(devmap);
1131 
1132 	if (kstrtouint(buf, 0, &val) || val > 1)
1133 		return -EINVAL;
1134 
1135 	spin_lock(&dasd_devmap_lock);
1136 	/* Changing diag discipline flag is only allowed in offline state. */
1137 	rc = count;
1138 	if (!devmap->device && !(devmap->features & DASD_FEATURE_USERAW)) {
1139 		if (val)
1140 			devmap->features |= DASD_FEATURE_USEDIAG;
1141 		else
1142 			devmap->features &= ~DASD_FEATURE_USEDIAG;
1143 	} else
1144 		rc = -EPERM;
1145 	spin_unlock(&dasd_devmap_lock);
1146 	return rc;
1147 }
1148 
1149 static DEVICE_ATTR(use_diag, 0644, dasd_use_diag_show, dasd_use_diag_store);
1150 
1151 /*
1152  * use_raw controls whether the driver should give access to raw eckd data or
1153  * operate in standard mode
1154  */
1155 static ssize_t
dasd_use_raw_show(struct device * dev,struct device_attribute * attr,char * buf)1156 dasd_use_raw_show(struct device *dev, struct device_attribute *attr, char *buf)
1157 {
1158 	struct dasd_devmap *devmap;
1159 	int use_raw;
1160 
1161 	devmap = dasd_find_busid(dev_name(dev));
1162 	if (!IS_ERR(devmap))
1163 		use_raw = (devmap->features & DASD_FEATURE_USERAW) != 0;
1164 	else
1165 		use_raw = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USERAW) != 0;
1166 	return sprintf(buf, use_raw ? "1\n" : "0\n");
1167 }
1168 
1169 static ssize_t
dasd_use_raw_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1170 dasd_use_raw_store(struct device *dev, struct device_attribute *attr,
1171 		    const char *buf, size_t count)
1172 {
1173 	struct dasd_devmap *devmap;
1174 	ssize_t rc;
1175 	unsigned long val;
1176 
1177 	devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
1178 	if (IS_ERR(devmap))
1179 		return PTR_ERR(devmap);
1180 
1181 	if ((kstrtoul(buf, 10, &val) != 0) || val > 1)
1182 		return -EINVAL;
1183 
1184 	spin_lock(&dasd_devmap_lock);
1185 	/* Changing diag discipline flag is only allowed in offline state. */
1186 	rc = count;
1187 	if (!devmap->device && !(devmap->features & DASD_FEATURE_USEDIAG)) {
1188 		if (val)
1189 			devmap->features |= DASD_FEATURE_USERAW;
1190 		else
1191 			devmap->features &= ~DASD_FEATURE_USERAW;
1192 	} else
1193 		rc = -EPERM;
1194 	spin_unlock(&dasd_devmap_lock);
1195 	return rc;
1196 }
1197 
1198 static DEVICE_ATTR(raw_track_access, 0644, dasd_use_raw_show,
1199 		   dasd_use_raw_store);
1200 
1201 static ssize_t
dasd_safe_offline_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1202 dasd_safe_offline_store(struct device *dev, struct device_attribute *attr,
1203 			const char *buf, size_t count)
1204 {
1205 	struct ccw_device *cdev = to_ccwdev(dev);
1206 	struct dasd_device *device;
1207 	unsigned long flags;
1208 	int rc;
1209 
1210 	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1211 	device = dasd_device_from_cdev_locked(cdev);
1212 	if (IS_ERR(device)) {
1213 		rc = PTR_ERR(device);
1214 		spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1215 		goto out;
1216 	}
1217 
1218 	if (test_bit(DASD_FLAG_OFFLINE, &device->flags) ||
1219 	    test_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING, &device->flags)) {
1220 		/* Already doing offline processing */
1221 		dasd_put_device(device);
1222 		spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1223 		rc = -EBUSY;
1224 		goto out;
1225 	}
1226 
1227 	set_bit(DASD_FLAG_SAFE_OFFLINE, &device->flags);
1228 	dasd_put_device(device);
1229 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1230 
1231 	rc = ccw_device_set_offline(cdev);
1232 
1233 out:
1234 	return rc ? rc : count;
1235 }
1236 
1237 static DEVICE_ATTR(safe_offline, 0200, NULL, dasd_safe_offline_store);
1238 
1239 static ssize_t
dasd_access_show(struct device * dev,struct device_attribute * attr,char * buf)1240 dasd_access_show(struct device *dev, struct device_attribute *attr,
1241 		 char *buf)
1242 {
1243 	struct ccw_device *cdev = to_ccwdev(dev);
1244 	struct dasd_device *device;
1245 	int count;
1246 
1247 	device = dasd_device_from_cdev(cdev);
1248 	if (IS_ERR(device))
1249 		return PTR_ERR(device);
1250 
1251 	if (!device->discipline)
1252 		count = -ENODEV;
1253 	else if (!device->discipline->host_access_count)
1254 		count = -EOPNOTSUPP;
1255 	else
1256 		count = device->discipline->host_access_count(device);
1257 
1258 	dasd_put_device(device);
1259 	if (count < 0)
1260 		return count;
1261 
1262 	return sprintf(buf, "%d\n", count);
1263 }
1264 
1265 static DEVICE_ATTR(host_access_count, 0444, dasd_access_show, NULL);
1266 
1267 static ssize_t
dasd_discipline_show(struct device * dev,struct device_attribute * attr,char * buf)1268 dasd_discipline_show(struct device *dev, struct device_attribute *attr,
1269 		     char *buf)
1270 {
1271 	struct dasd_device *device;
1272 	ssize_t len;
1273 
1274 	device = dasd_device_from_cdev(to_ccwdev(dev));
1275 	if (IS_ERR(device))
1276 		goto out;
1277 	else if (!device->discipline) {
1278 		dasd_put_device(device);
1279 		goto out;
1280 	} else {
1281 		len = sysfs_emit(buf, "%s\n",
1282 				 device->discipline->name);
1283 		dasd_put_device(device);
1284 		return len;
1285 	}
1286 out:
1287 	len = sysfs_emit(buf, "none\n");
1288 	return len;
1289 }
1290 
1291 static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL);
1292 
1293 static ssize_t
dasd_device_status_show(struct device * dev,struct device_attribute * attr,char * buf)1294 dasd_device_status_show(struct device *dev, struct device_attribute *attr,
1295 		     char *buf)
1296 {
1297 	struct dasd_device *device;
1298 	ssize_t len;
1299 
1300 	device = dasd_device_from_cdev(to_ccwdev(dev));
1301 	if (!IS_ERR(device)) {
1302 		switch (device->state) {
1303 		case DASD_STATE_NEW:
1304 			len = sysfs_emit(buf, "new\n");
1305 			break;
1306 		case DASD_STATE_KNOWN:
1307 			len = sysfs_emit(buf, "detected\n");
1308 			break;
1309 		case DASD_STATE_BASIC:
1310 			len = sysfs_emit(buf, "basic\n");
1311 			break;
1312 		case DASD_STATE_UNFMT:
1313 			len = sysfs_emit(buf, "unformatted\n");
1314 			break;
1315 		case DASD_STATE_READY:
1316 			len = sysfs_emit(buf, "ready\n");
1317 			break;
1318 		case DASD_STATE_ONLINE:
1319 			len = sysfs_emit(buf, "online\n");
1320 			break;
1321 		default:
1322 			len = sysfs_emit(buf, "no stat\n");
1323 			break;
1324 		}
1325 		dasd_put_device(device);
1326 	} else
1327 		len = sysfs_emit(buf, "unknown\n");
1328 	return len;
1329 }
1330 
1331 static DEVICE_ATTR(status, 0444, dasd_device_status_show, NULL);
1332 
dasd_alias_show(struct device * dev,struct device_attribute * attr,char * buf)1333 static ssize_t dasd_alias_show(struct device *dev,
1334 			       struct device_attribute *attr, char *buf)
1335 {
1336 	struct dasd_device *device;
1337 	struct dasd_uid uid;
1338 
1339 	device = dasd_device_from_cdev(to_ccwdev(dev));
1340 	if (IS_ERR(device))
1341 		return sprintf(buf, "0\n");
1342 
1343 	if (device->discipline && device->discipline->get_uid &&
1344 	    !device->discipline->get_uid(device, &uid)) {
1345 		if (uid.type == UA_BASE_PAV_ALIAS ||
1346 		    uid.type == UA_HYPER_PAV_ALIAS) {
1347 			dasd_put_device(device);
1348 			return sprintf(buf, "1\n");
1349 		}
1350 	}
1351 	dasd_put_device(device);
1352 
1353 	return sprintf(buf, "0\n");
1354 }
1355 
1356 static DEVICE_ATTR(alias, 0444, dasd_alias_show, NULL);
1357 
dasd_vendor_show(struct device * dev,struct device_attribute * attr,char * buf)1358 static ssize_t dasd_vendor_show(struct device *dev,
1359 				struct device_attribute *attr, char *buf)
1360 {
1361 	struct dasd_device *device;
1362 	struct dasd_uid uid;
1363 	char *vendor;
1364 
1365 	device = dasd_device_from_cdev(to_ccwdev(dev));
1366 	vendor = "";
1367 	if (IS_ERR(device))
1368 		return sysfs_emit(buf, "%s\n", vendor);
1369 
1370 	if (device->discipline && device->discipline->get_uid &&
1371 	    !device->discipline->get_uid(device, &uid))
1372 			vendor = uid.vendor;
1373 
1374 	dasd_put_device(device);
1375 
1376 	return sysfs_emit(buf, "%s\n", vendor);
1377 }
1378 
1379 static DEVICE_ATTR(vendor, 0444, dasd_vendor_show, NULL);
1380 
1381 static ssize_t
dasd_uid_show(struct device * dev,struct device_attribute * attr,char * buf)1382 dasd_uid_show(struct device *dev, struct device_attribute *attr, char *buf)
1383 {
1384 	char uid_string[DASD_UID_STRLEN];
1385 	struct dasd_device *device;
1386 	struct dasd_uid uid;
1387 	char ua_string[3];
1388 
1389 	device = dasd_device_from_cdev(to_ccwdev(dev));
1390 	uid_string[0] = 0;
1391 	if (IS_ERR(device))
1392 		return sysfs_emit(buf, "%s\n", uid_string);
1393 
1394 	if (device->discipline && device->discipline->get_uid &&
1395 	    !device->discipline->get_uid(device, &uid)) {
1396 		switch (uid.type) {
1397 		case UA_BASE_DEVICE:
1398 			snprintf(ua_string, sizeof(ua_string), "%02x",
1399 				 uid.real_unit_addr);
1400 			break;
1401 		case UA_BASE_PAV_ALIAS:
1402 			snprintf(ua_string, sizeof(ua_string), "%02x",
1403 				 uid.base_unit_addr);
1404 			break;
1405 		case UA_HYPER_PAV_ALIAS:
1406 			snprintf(ua_string, sizeof(ua_string), "xx");
1407 			break;
1408 		default:
1409 			/* should not happen, treat like base device */
1410 			snprintf(ua_string, sizeof(ua_string), "%02x",
1411 				 uid.real_unit_addr);
1412 			break;
1413 		}
1414 
1415 		if (strlen(uid.vduit) > 0)
1416 			snprintf(uid_string, sizeof(uid_string),
1417 				 "%s.%s.%04x.%s.%s",
1418 				 uid.vendor, uid.serial, uid.ssid, ua_string,
1419 				 uid.vduit);
1420 		else
1421 			snprintf(uid_string, sizeof(uid_string),
1422 				 "%s.%s.%04x.%s",
1423 				 uid.vendor, uid.serial, uid.ssid, ua_string);
1424 	}
1425 	dasd_put_device(device);
1426 
1427 	return sysfs_emit(buf, "%s\n", uid_string);
1428 }
1429 static DEVICE_ATTR(uid, 0444, dasd_uid_show, NULL);
1430 
1431 /*
1432  * extended error-reporting
1433  */
1434 static ssize_t
dasd_eer_show(struct device * dev,struct device_attribute * attr,char * buf)1435 dasd_eer_show(struct device *dev, struct device_attribute *attr, char *buf)
1436 {
1437 	struct dasd_devmap *devmap;
1438 	int eer_flag;
1439 
1440 	devmap = dasd_find_busid(dev_name(dev));
1441 	if (!IS_ERR(devmap) && devmap->device)
1442 		eer_flag = dasd_eer_enabled(devmap->device);
1443 	else
1444 		eer_flag = 0;
1445 	return sysfs_emit(buf, eer_flag ? "1\n" : "0\n");
1446 }
1447 
1448 static ssize_t
dasd_eer_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1449 dasd_eer_store(struct device *dev, struct device_attribute *attr,
1450 	       const char *buf, size_t count)
1451 {
1452 	struct dasd_device *device;
1453 	unsigned int val;
1454 	int rc = 0;
1455 
1456 	device = dasd_device_from_cdev(to_ccwdev(dev));
1457 	if (IS_ERR(device))
1458 		return PTR_ERR(device);
1459 
1460 	if (kstrtouint(buf, 0, &val) || val > 1)
1461 		return -EINVAL;
1462 
1463 	if (val)
1464 		rc = dasd_eer_enable(device);
1465 	else
1466 		dasd_eer_disable(device);
1467 
1468 	dasd_put_device(device);
1469 
1470 	return rc ? : count;
1471 }
1472 
1473 static DEVICE_ATTR(eer_enabled, 0644, dasd_eer_show, dasd_eer_store);
1474 
1475 /*
1476  * aq_mask controls if the DASD should be quiesced on certain triggers
1477  * The aq_mask attribute is interpreted as bitmap of the DASD_EER_* triggers.
1478  */
dasd_aq_mask_show(struct device * dev,struct device_attribute * attr,char * buf)1479 static ssize_t dasd_aq_mask_show(struct device *dev, struct device_attribute *attr,
1480 				 char *buf)
1481 {
1482 	struct dasd_devmap *devmap;
1483 	unsigned int aq_mask = 0;
1484 
1485 	devmap = dasd_find_busid(dev_name(dev));
1486 	if (!IS_ERR(devmap))
1487 		aq_mask = devmap->aq_mask;
1488 
1489 	return sysfs_emit(buf, "%d\n", aq_mask);
1490 }
1491 
dasd_aq_mask_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1492 static ssize_t dasd_aq_mask_store(struct device *dev, struct device_attribute *attr,
1493 				  const char *buf, size_t count)
1494 {
1495 	struct dasd_devmap *devmap;
1496 	unsigned int val;
1497 
1498 	if (kstrtouint(buf, 0, &val) || val > DASD_EER_VALID)
1499 		return -EINVAL;
1500 
1501 	devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
1502 	if (IS_ERR(devmap))
1503 		return PTR_ERR(devmap);
1504 
1505 	spin_lock(&dasd_devmap_lock);
1506 	devmap->aq_mask = val;
1507 	if (devmap->device)
1508 		devmap->device->aq_mask = devmap->aq_mask;
1509 	spin_unlock(&dasd_devmap_lock);
1510 
1511 	return count;
1512 }
1513 
1514 static DEVICE_ATTR(aq_mask, 0644, dasd_aq_mask_show, dasd_aq_mask_store);
1515 
1516 /*
1517  * aq_requeue controls if requests are returned to the blocklayer on quiesce
1518  * or if requests are only not started
1519  */
dasd_aqr_show(struct device * dev,struct device_attribute * attr,char * buf)1520 static ssize_t dasd_aqr_show(struct device *dev, struct device_attribute *attr,
1521 			     char *buf)
1522 {
1523 	struct dasd_devmap *devmap;
1524 	int flag;
1525 
1526 	devmap = dasd_find_busid(dev_name(dev));
1527 	if (!IS_ERR(devmap))
1528 		flag = (devmap->features & DASD_FEATURE_REQUEUEQUIESCE) != 0;
1529 	else
1530 		flag = (DASD_FEATURE_DEFAULT &
1531 			DASD_FEATURE_REQUEUEQUIESCE) != 0;
1532 	return sysfs_emit(buf, "%d\n", flag);
1533 }
1534 
dasd_aqr_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1535 static ssize_t dasd_aqr_store(struct device *dev, struct device_attribute *attr,
1536 			      const char *buf, size_t count)
1537 {
1538 	bool val;
1539 	int rc;
1540 
1541 	if (kstrtobool(buf, &val))
1542 		return -EINVAL;
1543 
1544 	rc = dasd_set_feature(to_ccwdev(dev), DASD_FEATURE_REQUEUEQUIESCE, val);
1545 
1546 	return rc ? : count;
1547 }
1548 
1549 static DEVICE_ATTR(aq_requeue, 0644, dasd_aqr_show, dasd_aqr_store);
1550 
1551 /*
1552  * aq_timeouts controls how much retries have to time out until
1553  * a device gets autoquiesced
1554  */
1555 static ssize_t
dasd_aq_timeouts_show(struct device * dev,struct device_attribute * attr,char * buf)1556 dasd_aq_timeouts_show(struct device *dev, struct device_attribute *attr,
1557 		      char *buf)
1558 {
1559 	struct dasd_device *device;
1560 	int len;
1561 
1562 	device = dasd_device_from_cdev(to_ccwdev(dev));
1563 	if (IS_ERR(device))
1564 		return -ENODEV;
1565 	len = sysfs_emit(buf, "%u\n", device->aq_timeouts);
1566 	dasd_put_device(device);
1567 	return len;
1568 }
1569 
1570 static ssize_t
dasd_aq_timeouts_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1571 dasd_aq_timeouts_store(struct device *dev, struct device_attribute *attr,
1572 		       const char *buf, size_t count)
1573 {
1574 	struct dasd_device *device;
1575 	unsigned int val;
1576 
1577 	device = dasd_device_from_cdev(to_ccwdev(dev));
1578 	if (IS_ERR(device))
1579 		return -ENODEV;
1580 
1581 	if ((kstrtouint(buf, 10, &val) != 0) ||
1582 	    val > DASD_RETRIES_MAX || val == 0) {
1583 		dasd_put_device(device);
1584 		return -EINVAL;
1585 	}
1586 
1587 	if (val)
1588 		device->aq_timeouts = val;
1589 
1590 	dasd_put_device(device);
1591 	return count;
1592 }
1593 
1594 static DEVICE_ATTR(aq_timeouts, 0644, dasd_aq_timeouts_show,
1595 		   dasd_aq_timeouts_store);
1596 
1597 /*
1598  * expiration time for default requests
1599  */
1600 static ssize_t
dasd_expires_show(struct device * dev,struct device_attribute * attr,char * buf)1601 dasd_expires_show(struct device *dev, struct device_attribute *attr, char *buf)
1602 {
1603 	struct dasd_device *device;
1604 	int len;
1605 
1606 	device = dasd_device_from_cdev(to_ccwdev(dev));
1607 	if (IS_ERR(device))
1608 		return -ENODEV;
1609 	len = sysfs_emit(buf, "%lu\n", device->default_expires);
1610 	dasd_put_device(device);
1611 	return len;
1612 }
1613 
1614 static ssize_t
dasd_expires_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1615 dasd_expires_store(struct device *dev, struct device_attribute *attr,
1616 	       const char *buf, size_t count)
1617 {
1618 	struct dasd_device *device;
1619 	unsigned long val;
1620 
1621 	device = dasd_device_from_cdev(to_ccwdev(dev));
1622 	if (IS_ERR(device))
1623 		return -ENODEV;
1624 
1625 	if ((kstrtoul(buf, 10, &val) != 0) ||
1626 	    (val > DASD_EXPIRES_MAX) || val == 0) {
1627 		dasd_put_device(device);
1628 		return -EINVAL;
1629 	}
1630 
1631 	if (val)
1632 		device->default_expires = val;
1633 
1634 	dasd_put_device(device);
1635 	return count;
1636 }
1637 
1638 static DEVICE_ATTR(expires, 0644, dasd_expires_show, dasd_expires_store);
1639 
1640 static ssize_t
dasd_retries_show(struct device * dev,struct device_attribute * attr,char * buf)1641 dasd_retries_show(struct device *dev, struct device_attribute *attr, char *buf)
1642 {
1643 	struct dasd_device *device;
1644 	int len;
1645 
1646 	device = dasd_device_from_cdev(to_ccwdev(dev));
1647 	if (IS_ERR(device))
1648 		return -ENODEV;
1649 	len = sysfs_emit(buf, "%lu\n", device->default_retries);
1650 	dasd_put_device(device);
1651 	return len;
1652 }
1653 
1654 static ssize_t
dasd_retries_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1655 dasd_retries_store(struct device *dev, struct device_attribute *attr,
1656 		   const char *buf, size_t count)
1657 {
1658 	struct dasd_device *device;
1659 	unsigned long val;
1660 
1661 	device = dasd_device_from_cdev(to_ccwdev(dev));
1662 	if (IS_ERR(device))
1663 		return -ENODEV;
1664 
1665 	if ((kstrtoul(buf, 10, &val) != 0) ||
1666 	    (val > DASD_RETRIES_MAX)) {
1667 		dasd_put_device(device);
1668 		return -EINVAL;
1669 	}
1670 
1671 	if (val)
1672 		device->default_retries = val;
1673 
1674 	dasd_put_device(device);
1675 	return count;
1676 }
1677 
1678 static DEVICE_ATTR(retries, 0644, dasd_retries_show, dasd_retries_store);
1679 
1680 static ssize_t
dasd_timeout_show(struct device * dev,struct device_attribute * attr,char * buf)1681 dasd_timeout_show(struct device *dev, struct device_attribute *attr,
1682 		  char *buf)
1683 {
1684 	struct dasd_device *device;
1685 	int len;
1686 
1687 	device = dasd_device_from_cdev(to_ccwdev(dev));
1688 	if (IS_ERR(device))
1689 		return -ENODEV;
1690 	len = sysfs_emit(buf, "%lu\n", device->blk_timeout);
1691 	dasd_put_device(device);
1692 	return len;
1693 }
1694 
1695 static ssize_t
dasd_timeout_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1696 dasd_timeout_store(struct device *dev, struct device_attribute *attr,
1697 		   const char *buf, size_t count)
1698 {
1699 	struct dasd_device *device;
1700 	unsigned long val;
1701 
1702 	device = dasd_device_from_cdev(to_ccwdev(dev));
1703 	if (IS_ERR(device) || !device->block)
1704 		return -ENODEV;
1705 
1706 	if ((kstrtoul(buf, 10, &val) != 0) ||
1707 	    val > UINT_MAX / HZ) {
1708 		dasd_put_device(device);
1709 		return -EINVAL;
1710 	}
1711 	if (!device->block->gdp) {
1712 		dasd_put_device(device);
1713 		return -ENODEV;
1714 	}
1715 
1716 	device->blk_timeout = val;
1717 	blk_queue_rq_timeout(device->block->gdp->queue, val * HZ);
1718 
1719 	dasd_put_device(device);
1720 	return count;
1721 }
1722 
1723 static DEVICE_ATTR(timeout, 0644,
1724 		   dasd_timeout_show, dasd_timeout_store);
1725 
1726 
1727 static ssize_t
dasd_path_reset_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1728 dasd_path_reset_store(struct device *dev, struct device_attribute *attr,
1729 		      const char *buf, size_t count)
1730 {
1731 	struct dasd_device *device;
1732 	unsigned int val;
1733 
1734 	device = dasd_device_from_cdev(to_ccwdev(dev));
1735 	if (IS_ERR(device))
1736 		return -ENODEV;
1737 
1738 	if ((kstrtouint(buf, 16, &val) != 0) || val > 0xff)
1739 		val = 0;
1740 
1741 	if (device->discipline && device->discipline->reset_path)
1742 		device->discipline->reset_path(device, (__u8) val);
1743 
1744 	dasd_put_device(device);
1745 	return count;
1746 }
1747 
1748 static DEVICE_ATTR(path_reset, 0200, NULL, dasd_path_reset_store);
1749 
dasd_hpf_show(struct device * dev,struct device_attribute * attr,char * buf)1750 static ssize_t dasd_hpf_show(struct device *dev, struct device_attribute *attr,
1751 			     char *buf)
1752 {
1753 	struct dasd_device *device;
1754 	int hpf;
1755 
1756 	device = dasd_device_from_cdev(to_ccwdev(dev));
1757 	if (IS_ERR(device))
1758 		return -ENODEV;
1759 	if (!device->discipline || !device->discipline->hpf_enabled) {
1760 		dasd_put_device(device);
1761 		return sysfs_emit(buf, "%d\n", dasd_nofcx);
1762 	}
1763 	hpf = device->discipline->hpf_enabled(device);
1764 	dasd_put_device(device);
1765 	return sysfs_emit(buf, "%d\n", hpf);
1766 }
1767 
1768 static DEVICE_ATTR(hpf, 0444, dasd_hpf_show, NULL);
1769 
dasd_reservation_policy_show(struct device * dev,struct device_attribute * attr,char * buf)1770 static ssize_t dasd_reservation_policy_show(struct device *dev,
1771 					    struct device_attribute *attr,
1772 					    char *buf)
1773 {
1774 	struct dasd_devmap *devmap;
1775 	int rc = 0;
1776 
1777 	devmap = dasd_find_busid(dev_name(dev));
1778 	if (IS_ERR(devmap)) {
1779 		rc = sysfs_emit(buf, "ignore\n");
1780 	} else {
1781 		spin_lock(&dasd_devmap_lock);
1782 		if (devmap->features & DASD_FEATURE_FAILONSLCK)
1783 			rc = sysfs_emit(buf, "fail\n");
1784 		else
1785 			rc = sysfs_emit(buf, "ignore\n");
1786 		spin_unlock(&dasd_devmap_lock);
1787 	}
1788 	return rc;
1789 }
1790 
dasd_reservation_policy_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1791 static ssize_t dasd_reservation_policy_store(struct device *dev,
1792 					     struct device_attribute *attr,
1793 					     const char *buf, size_t count)
1794 {
1795 	struct ccw_device *cdev = to_ccwdev(dev);
1796 	int rc;
1797 
1798 	if (sysfs_streq("ignore", buf))
1799 		rc = dasd_set_feature(cdev, DASD_FEATURE_FAILONSLCK, 0);
1800 	else if (sysfs_streq("fail", buf))
1801 		rc = dasd_set_feature(cdev, DASD_FEATURE_FAILONSLCK, 1);
1802 	else
1803 		rc = -EINVAL;
1804 
1805 	return rc ? : count;
1806 }
1807 
1808 static DEVICE_ATTR(reservation_policy, 0644,
1809 		   dasd_reservation_policy_show, dasd_reservation_policy_store);
1810 
dasd_reservation_state_show(struct device * dev,struct device_attribute * attr,char * buf)1811 static ssize_t dasd_reservation_state_show(struct device *dev,
1812 					   struct device_attribute *attr,
1813 					   char *buf)
1814 {
1815 	struct dasd_device *device;
1816 	int rc = 0;
1817 
1818 	device = dasd_device_from_cdev(to_ccwdev(dev));
1819 	if (IS_ERR(device))
1820 		return sysfs_emit(buf, "none\n");
1821 
1822 	if (test_bit(DASD_FLAG_IS_RESERVED, &device->flags))
1823 		rc = sysfs_emit(buf, "reserved\n");
1824 	else if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags))
1825 		rc = sysfs_emit(buf, "lost\n");
1826 	else
1827 		rc = sysfs_emit(buf, "none\n");
1828 	dasd_put_device(device);
1829 	return rc;
1830 }
1831 
dasd_reservation_state_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1832 static ssize_t dasd_reservation_state_store(struct device *dev,
1833 					    struct device_attribute *attr,
1834 					    const char *buf, size_t count)
1835 {
1836 	struct dasd_device *device;
1837 	int rc = 0;
1838 
1839 	device = dasd_device_from_cdev(to_ccwdev(dev));
1840 	if (IS_ERR(device))
1841 		return -ENODEV;
1842 	if (sysfs_streq("reset", buf))
1843 		clear_bit(DASD_FLAG_LOCK_STOLEN, &device->flags);
1844 	else
1845 		rc = -EINVAL;
1846 	dasd_put_device(device);
1847 
1848 	if (rc)
1849 		return rc;
1850 	else
1851 		return count;
1852 }
1853 
1854 static DEVICE_ATTR(last_known_reservation_state, 0644,
1855 		   dasd_reservation_state_show, dasd_reservation_state_store);
1856 
dasd_pm_show(struct device * dev,struct device_attribute * attr,char * buf)1857 static ssize_t dasd_pm_show(struct device *dev,
1858 			      struct device_attribute *attr, char *buf)
1859 {
1860 	struct dasd_device *device;
1861 	u8 opm, nppm, cablepm, cuirpm, hpfpm, ifccpm;
1862 
1863 	device = dasd_device_from_cdev(to_ccwdev(dev));
1864 	if (IS_ERR(device))
1865 		return sprintf(buf, "0\n");
1866 
1867 	opm = dasd_path_get_opm(device);
1868 	nppm = dasd_path_get_nppm(device);
1869 	cablepm = dasd_path_get_cablepm(device);
1870 	cuirpm = dasd_path_get_cuirpm(device);
1871 	hpfpm = dasd_path_get_hpfpm(device);
1872 	ifccpm = dasd_path_get_ifccpm(device);
1873 	dasd_put_device(device);
1874 
1875 	return sprintf(buf, "%02x %02x %02x %02x %02x %02x\n", opm, nppm,
1876 		       cablepm, cuirpm, hpfpm, ifccpm);
1877 }
1878 
1879 static DEVICE_ATTR(path_masks, 0444, dasd_pm_show, NULL);
1880 
1881 /*
1882  * threshold value for IFCC/CCC errors
1883  */
1884 static ssize_t
dasd_path_threshold_show(struct device * dev,struct device_attribute * attr,char * buf)1885 dasd_path_threshold_show(struct device *dev,
1886 			  struct device_attribute *attr, char *buf)
1887 {
1888 	struct dasd_device *device;
1889 	int len;
1890 
1891 	device = dasd_device_from_cdev(to_ccwdev(dev));
1892 	if (IS_ERR(device))
1893 		return -ENODEV;
1894 	len = sysfs_emit(buf, "%lu\n", device->path_thrhld);
1895 	dasd_put_device(device);
1896 	return len;
1897 }
1898 
1899 static ssize_t
dasd_path_threshold_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1900 dasd_path_threshold_store(struct device *dev, struct device_attribute *attr,
1901 			   const char *buf, size_t count)
1902 {
1903 	struct dasd_device *device;
1904 	unsigned long flags;
1905 	unsigned long val;
1906 
1907 	device = dasd_device_from_cdev(to_ccwdev(dev));
1908 	if (IS_ERR(device))
1909 		return -ENODEV;
1910 
1911 	if (kstrtoul(buf, 10, &val) != 0 || val > DASD_THRHLD_MAX) {
1912 		dasd_put_device(device);
1913 		return -EINVAL;
1914 	}
1915 	spin_lock_irqsave(get_ccwdev_lock(to_ccwdev(dev)), flags);
1916 	device->path_thrhld = val;
1917 	spin_unlock_irqrestore(get_ccwdev_lock(to_ccwdev(dev)), flags);
1918 	dasd_put_device(device);
1919 	return count;
1920 }
1921 static DEVICE_ATTR(path_threshold, 0644, dasd_path_threshold_show,
1922 		   dasd_path_threshold_store);
1923 
1924 /*
1925  * configure if path is disabled after IFCC/CCC error threshold is
1926  * exceeded
1927  */
1928 static ssize_t
dasd_path_autodisable_show(struct device * dev,struct device_attribute * attr,char * buf)1929 dasd_path_autodisable_show(struct device *dev,
1930 				   struct device_attribute *attr, char *buf)
1931 {
1932 	struct dasd_devmap *devmap;
1933 	int flag;
1934 
1935 	devmap = dasd_find_busid(dev_name(dev));
1936 	if (!IS_ERR(devmap))
1937 		flag = (devmap->features & DASD_FEATURE_PATH_AUTODISABLE) != 0;
1938 	else
1939 		flag = (DASD_FEATURE_DEFAULT &
1940 			DASD_FEATURE_PATH_AUTODISABLE) != 0;
1941 	return sysfs_emit(buf, flag ? "1\n" : "0\n");
1942 }
1943 
1944 static ssize_t
dasd_path_autodisable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1945 dasd_path_autodisable_store(struct device *dev,
1946 				    struct device_attribute *attr,
1947 				    const char *buf, size_t count)
1948 {
1949 	unsigned int val;
1950 	int rc;
1951 
1952 	if (kstrtouint(buf, 0, &val) || val > 1)
1953 		return -EINVAL;
1954 
1955 	rc = dasd_set_feature(to_ccwdev(dev),
1956 			      DASD_FEATURE_PATH_AUTODISABLE, val);
1957 
1958 	return rc ? : count;
1959 }
1960 
1961 static DEVICE_ATTR(path_autodisable, 0644,
1962 		   dasd_path_autodisable_show,
1963 		   dasd_path_autodisable_store);
1964 /*
1965  * interval for IFCC/CCC checks
1966  * meaning time with no IFCC/CCC error before the error counter
1967  * gets reset
1968  */
1969 static ssize_t
dasd_path_interval_show(struct device * dev,struct device_attribute * attr,char * buf)1970 dasd_path_interval_show(struct device *dev,
1971 			struct device_attribute *attr, char *buf)
1972 {
1973 	struct dasd_device *device;
1974 	int len;
1975 
1976 	device = dasd_device_from_cdev(to_ccwdev(dev));
1977 	if (IS_ERR(device))
1978 		return -ENODEV;
1979 	len = sysfs_emit(buf, "%lu\n", device->path_interval);
1980 	dasd_put_device(device);
1981 	return len;
1982 }
1983 
1984 static ssize_t
dasd_path_interval_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1985 dasd_path_interval_store(struct device *dev, struct device_attribute *attr,
1986 	       const char *buf, size_t count)
1987 {
1988 	struct dasd_device *device;
1989 	unsigned long flags;
1990 	unsigned long val;
1991 
1992 	device = dasd_device_from_cdev(to_ccwdev(dev));
1993 	if (IS_ERR(device))
1994 		return -ENODEV;
1995 
1996 	if ((kstrtoul(buf, 10, &val) != 0) ||
1997 	    (val > DASD_INTERVAL_MAX) || val == 0) {
1998 		dasd_put_device(device);
1999 		return -EINVAL;
2000 	}
2001 	spin_lock_irqsave(get_ccwdev_lock(to_ccwdev(dev)), flags);
2002 	if (val)
2003 		device->path_interval = val;
2004 	spin_unlock_irqrestore(get_ccwdev_lock(to_ccwdev(dev)), flags);
2005 	dasd_put_device(device);
2006 	return count;
2007 }
2008 
2009 static DEVICE_ATTR(path_interval, 0644, dasd_path_interval_show,
2010 		   dasd_path_interval_store);
2011 
2012 static ssize_t
dasd_device_fcs_show(struct device * dev,struct device_attribute * attr,char * buf)2013 dasd_device_fcs_show(struct device *dev, struct device_attribute *attr,
2014 		     char *buf)
2015 {
2016 	struct dasd_device *device;
2017 	int fc_sec;
2018 	int rc;
2019 
2020 	device = dasd_device_from_cdev(to_ccwdev(dev));
2021 	if (IS_ERR(device))
2022 		return -ENODEV;
2023 	fc_sec = dasd_path_get_fcs_device(device);
2024 	if (fc_sec == -EINVAL)
2025 		rc = sysfs_emit(buf, "Inconsistent\n");
2026 	else
2027 		rc = sysfs_emit(buf, "%s\n", dasd_path_get_fcs_str(fc_sec));
2028 	dasd_put_device(device);
2029 
2030 	return rc;
2031 }
2032 static DEVICE_ATTR(fc_security, 0444, dasd_device_fcs_show, NULL);
2033 
2034 static ssize_t
dasd_path_fcs_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)2035 dasd_path_fcs_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
2036 {
2037 	struct dasd_path *path = to_dasd_path(kobj);
2038 	unsigned int fc_sec = path->fc_security;
2039 
2040 	return sysfs_emit(buf, "%s\n", dasd_path_get_fcs_str(fc_sec));
2041 }
2042 
2043 static struct kobj_attribute path_fcs_attribute =
2044 	__ATTR(fc_security, 0444, dasd_path_fcs_show, NULL);
2045 
2046 /*
2047  * print copy relation in the form
2048  * primary,secondary[1] primary,secondary[2], ...
2049  */
2050 static ssize_t
dasd_copy_pair_show(struct device * dev,struct device_attribute * attr,char * buf)2051 dasd_copy_pair_show(struct device *dev,
2052 		    struct device_attribute *attr, char *buf)
2053 {
2054 	char prim_busid[DASD_BUS_ID_SIZE];
2055 	struct dasd_copy_relation *copy;
2056 	struct dasd_devmap *devmap;
2057 	int len = 0;
2058 	int i;
2059 
2060 	devmap = dasd_find_busid(dev_name(dev));
2061 	if (IS_ERR(devmap))
2062 		return -ENODEV;
2063 
2064 	if (!devmap->copy)
2065 		return -ENODEV;
2066 
2067 	copy = devmap->copy;
2068 	/* find primary */
2069 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
2070 		if (copy->entry[i].configured && copy->entry[i].primary) {
2071 			strscpy(prim_busid, copy->entry[i].busid,
2072 				DASD_BUS_ID_SIZE);
2073 			break;
2074 		}
2075 	}
2076 	if (i == DASD_CP_ENTRIES)
2077 		goto out;
2078 
2079 	/* print all secondary */
2080 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
2081 		if (copy->entry[i].configured && !copy->entry[i].primary)
2082 			len += sysfs_emit_at(buf, len, "%s,%s ", prim_busid,
2083 					     copy->entry[i].busid);
2084 	}
2085 
2086 	len += sysfs_emit_at(buf, len, "\n");
2087 out:
2088 	return len;
2089 }
2090 
dasd_devmap_set_copy_relation(struct dasd_devmap * devmap,struct dasd_copy_relation * copy,char * busid,bool primary)2091 static int dasd_devmap_set_copy_relation(struct dasd_devmap *devmap,
2092 					 struct dasd_copy_relation *copy,
2093 					 char *busid, bool primary)
2094 {
2095 	int i;
2096 
2097 	/* find free entry */
2098 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
2099 		/* current bus_id already included, nothing to do */
2100 		if (copy->entry[i].configured &&
2101 		    strncmp(copy->entry[i].busid, busid, DASD_BUS_ID_SIZE) == 0)
2102 			return 0;
2103 
2104 		if (!copy->entry[i].configured)
2105 			break;
2106 	}
2107 	if (i == DASD_CP_ENTRIES)
2108 		return -EINVAL;
2109 
2110 	copy->entry[i].configured = true;
2111 	strscpy(copy->entry[i].busid, busid, DASD_BUS_ID_SIZE);
2112 	if (primary) {
2113 		copy->active = &copy->entry[i];
2114 		copy->entry[i].primary = true;
2115 	}
2116 	if (!devmap->copy)
2117 		devmap->copy = copy;
2118 
2119 	return 0;
2120 }
2121 
dasd_devmap_del_copy_relation(struct dasd_copy_relation * copy,char * busid)2122 static void dasd_devmap_del_copy_relation(struct dasd_copy_relation *copy,
2123 					  char *busid)
2124 {
2125 	int i;
2126 
2127 	spin_lock(&dasd_devmap_lock);
2128 	/* find entry */
2129 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
2130 		if (copy->entry[i].configured &&
2131 		    strncmp(copy->entry[i].busid, busid, DASD_BUS_ID_SIZE) == 0)
2132 			break;
2133 	}
2134 	if (i == DASD_CP_ENTRIES || !copy->entry[i].configured) {
2135 		spin_unlock(&dasd_devmap_lock);
2136 		return;
2137 	}
2138 
2139 	copy->entry[i].configured = false;
2140 	memset(copy->entry[i].busid, 0, DASD_BUS_ID_SIZE);
2141 	if (copy->active == &copy->entry[i]) {
2142 		copy->active = NULL;
2143 		copy->entry[i].primary = false;
2144 	}
2145 	spin_unlock(&dasd_devmap_lock);
2146 }
2147 
dasd_devmap_clear_copy_relation(struct device * dev)2148 static int dasd_devmap_clear_copy_relation(struct device *dev)
2149 {
2150 	struct dasd_copy_relation *copy;
2151 	struct dasd_devmap *devmap;
2152 	int i, rc = 1;
2153 
2154 	devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
2155 	if (IS_ERR(devmap))
2156 		return 1;
2157 
2158 	spin_lock(&dasd_devmap_lock);
2159 	if (!devmap->copy)
2160 		goto out;
2161 
2162 	copy = devmap->copy;
2163 	/* first check if all secondary devices are offline*/
2164 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
2165 		if (!copy->entry[i].configured)
2166 			continue;
2167 
2168 		if (copy->entry[i].device == copy->active->device)
2169 			continue;
2170 
2171 		if (copy->entry[i].device)
2172 			goto out;
2173 	}
2174 	/* clear all devmap entries */
2175 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
2176 		if (strlen(copy->entry[i].busid) == 0)
2177 			continue;
2178 		if (copy->entry[i].device) {
2179 			dasd_put_device(copy->entry[i].device);
2180 			copy->entry[i].device->copy = NULL;
2181 			copy->entry[i].device = NULL;
2182 		}
2183 		devmap = dasd_find_busid_locked(copy->entry[i].busid);
2184 		devmap->copy = NULL;
2185 		memset(copy->entry[i].busid, 0, DASD_BUS_ID_SIZE);
2186 	}
2187 	kfree(copy);
2188 	rc = 0;
2189 out:
2190 	spin_unlock(&dasd_devmap_lock);
2191 	return rc;
2192 }
2193 
2194 /*
2195  * parse BUSIDs from a copy pair
2196  */
dasd_devmap_parse_busid(const char * buf,char * prim_busid,char * sec_busid)2197 static int dasd_devmap_parse_busid(const char *buf, char *prim_busid,
2198 				   char *sec_busid)
2199 {
2200 	char *primary, *secondary, *tmp, *pt;
2201 	int id0, id1, id2;
2202 
2203 	pt =  kstrdup(buf, GFP_KERNEL);
2204 	tmp = pt;
2205 	if (!tmp)
2206 		return -ENOMEM;
2207 
2208 	primary = strsep(&tmp, ",");
2209 	if (!primary) {
2210 		kfree(pt);
2211 		return -EINVAL;
2212 	}
2213 	secondary = strsep(&tmp, ",");
2214 	if (!secondary) {
2215 		kfree(pt);
2216 		return -EINVAL;
2217 	}
2218 	if (dasd_busid(primary, &id0, &id1, &id2)) {
2219 		kfree(pt);
2220 		return -EINVAL;
2221 	}
2222 	sprintf(prim_busid, "%01x.%01x.%04x", id0, id1, id2);
2223 	if (dasd_busid(secondary, &id0, &id1, &id2)) {
2224 		kfree(pt);
2225 		return -EINVAL;
2226 	}
2227 	sprintf(sec_busid, "%01x.%01x.%04x", id0, id1, id2);
2228 	kfree(pt);
2229 
2230 	return 0;
2231 }
2232 
dasd_copy_pair_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2233 static ssize_t dasd_copy_pair_store(struct device *dev,
2234 				    struct device_attribute *attr,
2235 				    const char *buf, size_t count)
2236 {
2237 	struct dasd_devmap *prim_devmap, *sec_devmap;
2238 	char prim_busid[DASD_BUS_ID_SIZE];
2239 	char sec_busid[DASD_BUS_ID_SIZE];
2240 	struct dasd_copy_relation *copy;
2241 	struct dasd_device *device;
2242 	bool pprc_enabled;
2243 	int rc;
2244 
2245 	if (strncmp(buf, "clear", strlen("clear")) == 0) {
2246 		if (dasd_devmap_clear_copy_relation(dev))
2247 			return -EINVAL;
2248 		return count;
2249 	}
2250 
2251 	rc = dasd_devmap_parse_busid(buf, prim_busid, sec_busid);
2252 	if (rc)
2253 		return rc;
2254 
2255 	if (strncmp(dev_name(dev), prim_busid, DASD_BUS_ID_SIZE) != 0 &&
2256 	    strncmp(dev_name(dev), sec_busid, DASD_BUS_ID_SIZE) != 0)
2257 		return -EINVAL;
2258 
2259 	/* allocate primary devmap if needed */
2260 	prim_devmap = dasd_find_busid(prim_busid);
2261 	if (IS_ERR(prim_devmap)) {
2262 		prim_devmap = dasd_add_busid(prim_busid, DASD_FEATURE_DEFAULT);
2263 		if (IS_ERR(prim_devmap))
2264 			return PTR_ERR(prim_devmap);
2265 	}
2266 
2267 	/* allocate secondary devmap if needed */
2268 	sec_devmap = dasd_find_busid(sec_busid);
2269 	if (IS_ERR(sec_devmap)) {
2270 		sec_devmap = dasd_add_busid(sec_busid, DASD_FEATURE_DEFAULT);
2271 		if (IS_ERR(sec_devmap))
2272 			return PTR_ERR(sec_devmap);
2273 	}
2274 
2275 	/* setting copy relation is only allowed for offline secondary */
2276 	if (sec_devmap->device)
2277 		return -EINVAL;
2278 
2279 	if (prim_devmap->copy) {
2280 		copy = prim_devmap->copy;
2281 	} else if (sec_devmap->copy) {
2282 		copy = sec_devmap->copy;
2283 	} else {
2284 		copy = kzalloc(sizeof(*copy), GFP_KERNEL);
2285 		if (!copy)
2286 			return -ENOMEM;
2287 	}
2288 	spin_lock(&dasd_devmap_lock);
2289 	rc = dasd_devmap_set_copy_relation(prim_devmap, copy, prim_busid, true);
2290 	if (rc) {
2291 		spin_unlock(&dasd_devmap_lock);
2292 		return rc;
2293 	}
2294 	rc = dasd_devmap_set_copy_relation(sec_devmap, copy, sec_busid, false);
2295 	if (rc) {
2296 		spin_unlock(&dasd_devmap_lock);
2297 		return rc;
2298 	}
2299 	spin_unlock(&dasd_devmap_lock);
2300 
2301 	/* if primary device is already online call device setup directly */
2302 	if (prim_devmap->device && !prim_devmap->device->copy) {
2303 		device = prim_devmap->device;
2304 		if (device->discipline->pprc_enabled) {
2305 			pprc_enabled = device->discipline->pprc_enabled(device);
2306 			rc = dasd_devmap_set_device_copy_relation(device->cdev,
2307 								  pprc_enabled);
2308 		} else {
2309 			rc = -EOPNOTSUPP;
2310 		}
2311 	}
2312 	if (rc) {
2313 		dasd_devmap_del_copy_relation(copy, prim_busid);
2314 		dasd_devmap_del_copy_relation(copy, sec_busid);
2315 		count = rc;
2316 	}
2317 
2318 	return count;
2319 }
2320 static DEVICE_ATTR(copy_pair, 0644, dasd_copy_pair_show,
2321 		   dasd_copy_pair_store);
2322 
2323 static ssize_t
dasd_copy_role_show(struct device * dev,struct device_attribute * attr,char * buf)2324 dasd_copy_role_show(struct device *dev,
2325 		    struct device_attribute *attr, char *buf)
2326 {
2327 	struct dasd_copy_relation *copy;
2328 	struct dasd_device *device;
2329 	int len, i;
2330 
2331 	device = dasd_device_from_cdev(to_ccwdev(dev));
2332 	if (IS_ERR(device))
2333 		return -ENODEV;
2334 
2335 	if (!device->copy) {
2336 		len = sysfs_emit(buf, "none\n");
2337 		goto out;
2338 	}
2339 	copy = device->copy;
2340 	/* only the active device is primary */
2341 	if (copy->active->device == device) {
2342 		len = sysfs_emit(buf, "primary\n");
2343 		goto out;
2344 	}
2345 	for (i = 0; i < DASD_CP_ENTRIES; i++) {
2346 		if (copy->entry[i].device == device) {
2347 			len = sysfs_emit(buf, "secondary\n");
2348 			goto out;
2349 		}
2350 	}
2351 	/* not in the list, no COPY role */
2352 	len = sysfs_emit(buf, "none\n");
2353 out:
2354 	dasd_put_device(device);
2355 	return len;
2356 }
2357 static DEVICE_ATTR(copy_role, 0444, dasd_copy_role_show, NULL);
2358 
dasd_device_ping(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2359 static ssize_t dasd_device_ping(struct device *dev,
2360 				struct device_attribute *attr,
2361 				const char *buf, size_t count)
2362 {
2363 	struct dasd_device *device;
2364 	size_t rc;
2365 
2366 	device = dasd_device_from_cdev(to_ccwdev(dev));
2367 	if (IS_ERR(device))
2368 		return -ENODEV;
2369 
2370 	/*
2371 	 * do not try during offline processing
2372 	 * early check only
2373 	 * the sleep_on function itself checks for offline
2374 	 * processing again
2375 	 */
2376 	if (test_bit(DASD_FLAG_OFFLINE, &device->flags)) {
2377 		rc = -EBUSY;
2378 		goto out;
2379 	}
2380 	if (!device->discipline || !device->discipline->device_ping) {
2381 		rc = -EOPNOTSUPP;
2382 		goto out;
2383 	}
2384 	rc = device->discipline->device_ping(device);
2385 	if (!rc)
2386 		rc = count;
2387 out:
2388 	dasd_put_device(device);
2389 	return rc;
2390 }
2391 static DEVICE_ATTR(ping, 0200, NULL, dasd_device_ping);
2392 
2393 #define DASD_DEFINE_ATTR(_name, _func)					\
2394 static ssize_t dasd_##_name##_show(struct device *dev,			\
2395 				   struct device_attribute *attr,	\
2396 				   char *buf)				\
2397 {									\
2398 	struct ccw_device *cdev = to_ccwdev(dev);			\
2399 	struct dasd_device *device = dasd_device_from_cdev(cdev);	\
2400 	int val = 0;							\
2401 									\
2402 	if (IS_ERR(device))						\
2403 		return -ENODEV;						\
2404 	if (device->discipline && _func)				\
2405 		val = _func(device);					\
2406 	dasd_put_device(device);					\
2407 									\
2408 	return sysfs_emit(buf, "%d\n", val);			\
2409 }									\
2410 static DEVICE_ATTR(_name, 0444, dasd_##_name##_show, NULL);		\
2411 
2412 DASD_DEFINE_ATTR(ese, device->discipline->is_ese);
2413 DASD_DEFINE_ATTR(extent_size, device->discipline->ext_size);
2414 DASD_DEFINE_ATTR(pool_id, device->discipline->ext_pool_id);
2415 DASD_DEFINE_ATTR(space_configured, device->discipline->space_configured);
2416 DASD_DEFINE_ATTR(space_allocated, device->discipline->space_allocated);
2417 DASD_DEFINE_ATTR(logical_capacity, device->discipline->logical_capacity);
2418 DASD_DEFINE_ATTR(warn_threshold, device->discipline->ext_pool_warn_thrshld);
2419 DASD_DEFINE_ATTR(cap_at_warnlevel, device->discipline->ext_pool_cap_at_warnlevel);
2420 DASD_DEFINE_ATTR(pool_oos, device->discipline->ext_pool_oos);
2421 
2422 static struct attribute * dasd_attrs[] = {
2423 	&dev_attr_readonly.attr,
2424 	&dev_attr_discipline.attr,
2425 	&dev_attr_status.attr,
2426 	&dev_attr_alias.attr,
2427 	&dev_attr_vendor.attr,
2428 	&dev_attr_uid.attr,
2429 	&dev_attr_use_diag.attr,
2430 	&dev_attr_raw_track_access.attr,
2431 	&dev_attr_eer_enabled.attr,
2432 	&dev_attr_erplog.attr,
2433 	&dev_attr_failfast.attr,
2434 	&dev_attr_expires.attr,
2435 	&dev_attr_retries.attr,
2436 	&dev_attr_timeout.attr,
2437 	&dev_attr_reservation_policy.attr,
2438 	&dev_attr_last_known_reservation_state.attr,
2439 	&dev_attr_safe_offline.attr,
2440 	&dev_attr_host_access_count.attr,
2441 	&dev_attr_path_masks.attr,
2442 	&dev_attr_path_threshold.attr,
2443 	&dev_attr_path_autodisable.attr,
2444 	&dev_attr_path_interval.attr,
2445 	&dev_attr_path_reset.attr,
2446 	&dev_attr_hpf.attr,
2447 	&dev_attr_ese.attr,
2448 	&dev_attr_fc_security.attr,
2449 	&dev_attr_copy_pair.attr,
2450 	&dev_attr_copy_role.attr,
2451 	&dev_attr_ping.attr,
2452 	&dev_attr_aq_mask.attr,
2453 	&dev_attr_aq_requeue.attr,
2454 	&dev_attr_aq_timeouts.attr,
2455 	NULL,
2456 };
2457 
2458 static const struct attribute_group dasd_attr_group = {
2459 	.attrs = dasd_attrs,
2460 };
2461 
2462 static struct attribute *capacity_attrs[] = {
2463 	&dev_attr_space_configured.attr,
2464 	&dev_attr_space_allocated.attr,
2465 	&dev_attr_logical_capacity.attr,
2466 	NULL,
2467 };
2468 
2469 static const struct attribute_group capacity_attr_group = {
2470 	.name = "capacity",
2471 	.attrs = capacity_attrs,
2472 };
2473 
2474 static struct attribute *ext_pool_attrs[] = {
2475 	&dev_attr_pool_id.attr,
2476 	&dev_attr_extent_size.attr,
2477 	&dev_attr_warn_threshold.attr,
2478 	&dev_attr_cap_at_warnlevel.attr,
2479 	&dev_attr_pool_oos.attr,
2480 	NULL,
2481 };
2482 
2483 static const struct attribute_group ext_pool_attr_group = {
2484 	.name = "extent_pool",
2485 	.attrs = ext_pool_attrs,
2486 };
2487 
2488 const struct attribute_group *dasd_dev_groups[] = {
2489 	&dasd_attr_group,
2490 	&capacity_attr_group,
2491 	&ext_pool_attr_group,
2492 	NULL,
2493 };
2494 EXPORT_SYMBOL_GPL(dasd_dev_groups);
2495 
2496 /*
2497  * Return value of the specified feature.
2498  */
2499 int
dasd_get_feature(struct ccw_device * cdev,int feature)2500 dasd_get_feature(struct ccw_device *cdev, int feature)
2501 {
2502 	struct dasd_devmap *devmap;
2503 
2504 	devmap = dasd_find_busid(dev_name(&cdev->dev));
2505 	if (IS_ERR(devmap))
2506 		return PTR_ERR(devmap);
2507 
2508 	return ((devmap->features & feature) != 0);
2509 }
2510 
2511 /*
2512  * Set / reset given feature.
2513  * Flag indicates whether to set (!=0) or the reset (=0) the feature.
2514  */
2515 int
dasd_set_feature(struct ccw_device * cdev,int feature,int flag)2516 dasd_set_feature(struct ccw_device *cdev, int feature, int flag)
2517 {
2518 	struct dasd_devmap *devmap;
2519 
2520 	devmap = dasd_devmap_from_cdev(cdev);
2521 	if (IS_ERR(devmap))
2522 		return PTR_ERR(devmap);
2523 
2524 	spin_lock(&dasd_devmap_lock);
2525 	if (flag)
2526 		devmap->features |= feature;
2527 	else
2528 		devmap->features &= ~feature;
2529 	if (devmap->device)
2530 		devmap->device->features = devmap->features;
2531 	spin_unlock(&dasd_devmap_lock);
2532 	return 0;
2533 }
2534 EXPORT_SYMBOL(dasd_set_feature);
2535 
2536 static struct attribute *paths_info_attrs[] = {
2537 	&path_fcs_attribute.attr,
2538 	NULL,
2539 };
2540 ATTRIBUTE_GROUPS(paths_info);
2541 
2542 static struct kobj_type path_attr_type = {
2543 	.release	= dasd_path_release,
2544 	.default_groups	= paths_info_groups,
2545 	.sysfs_ops	= &kobj_sysfs_ops,
2546 };
2547 
dasd_path_init_kobj(struct dasd_device * device,int chp)2548 static void dasd_path_init_kobj(struct dasd_device *device, int chp)
2549 {
2550 	device->path[chp].kobj.kset = device->paths_info;
2551 	kobject_init(&device->path[chp].kobj, &path_attr_type);
2552 }
2553 
dasd_path_create_kobj(struct dasd_device * device,int chp)2554 void dasd_path_create_kobj(struct dasd_device *device, int chp)
2555 {
2556 	int rc;
2557 
2558 	if (test_bit(DASD_FLAG_OFFLINE, &device->flags))
2559 		return;
2560 	if (!device->paths_info) {
2561 		dev_warn(&device->cdev->dev, "Unable to create paths objects\n");
2562 		return;
2563 	}
2564 	if (device->path[chp].in_sysfs)
2565 		return;
2566 	if (!device->path[chp].conf_data)
2567 		return;
2568 
2569 	dasd_path_init_kobj(device, chp);
2570 
2571 	rc = kobject_add(&device->path[chp].kobj, NULL, "%x.%02x",
2572 			 device->path[chp].cssid, device->path[chp].chpid);
2573 	if (rc)
2574 		kobject_put(&device->path[chp].kobj);
2575 	device->path[chp].in_sysfs = true;
2576 }
2577 EXPORT_SYMBOL(dasd_path_create_kobj);
2578 
dasd_path_create_kobjects(struct dasd_device * device)2579 void dasd_path_create_kobjects(struct dasd_device *device)
2580 {
2581 	u8 lpm, opm;
2582 
2583 	opm = dasd_path_get_opm(device);
2584 	for (lpm = 0x80; lpm; lpm >>= 1) {
2585 		if (!(lpm & opm))
2586 			continue;
2587 		dasd_path_create_kobj(device, pathmask_to_pos(lpm));
2588 	}
2589 }
2590 EXPORT_SYMBOL(dasd_path_create_kobjects);
2591 
dasd_path_remove_kobj(struct dasd_device * device,int chp)2592 static void dasd_path_remove_kobj(struct dasd_device *device, int chp)
2593 {
2594 	if (device->path[chp].in_sysfs) {
2595 		kobject_put(&device->path[chp].kobj);
2596 		device->path[chp].in_sysfs = false;
2597 	}
2598 }
2599 
2600 /*
2601  * As we keep kobjects for the lifetime of a device, this function must not be
2602  * called anywhere but in the context of offlining a device.
2603  */
dasd_path_remove_kobjects(struct dasd_device * device)2604 void dasd_path_remove_kobjects(struct dasd_device *device)
2605 {
2606 	int i;
2607 
2608 	for (i = 0; i < 8; i++)
2609 		dasd_path_remove_kobj(device, i);
2610 }
2611 EXPORT_SYMBOL(dasd_path_remove_kobjects);
2612 
2613 int
dasd_devmap_init(void)2614 dasd_devmap_init(void)
2615 {
2616 	int i;
2617 
2618 	/* Initialize devmap structures. */
2619 	dasd_max_devindex = 0;
2620 	for (i = 0; i < 256; i++)
2621 		INIT_LIST_HEAD(&dasd_hashlists[i]);
2622 	return 0;
2623 }
2624 
2625 void
dasd_devmap_exit(void)2626 dasd_devmap_exit(void)
2627 {
2628 	dasd_forget_ranges();
2629 }
2630