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