cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

dasd_devmap.c (46471B)


      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_BUS_ID_SIZE 20
     30#define DASD_MAX_PARAMS 256
     31
     32#include "dasd_int.h"
     33
     34struct kmem_cache *dasd_page_cache;
     35EXPORT_SYMBOL_GPL(dasd_page_cache);
     36
     37/*
     38 * dasd_devmap_t is used to store the features and the relation
     39 * between device number and device index. To find a dasd_devmap_t
     40 * that corresponds to a device number of a device index each
     41 * dasd_devmap_t is added to two linked lists, one to search by
     42 * the device number and one to search by the device index. As
     43 * soon as big minor numbers are available the device index list
     44 * can be removed since the device number will then be identical
     45 * to the device index.
     46 */
     47struct dasd_devmap {
     48	struct list_head list;
     49	char bus_id[DASD_BUS_ID_SIZE];
     50        unsigned int devindex;
     51        unsigned short features;
     52	struct dasd_device *device;
     53};
     54
     55/*
     56 * Parameter parsing functions for dasd= parameter. The syntax is:
     57 *   <devno>		: (0x)?[0-9a-fA-F]+
     58 *   <busid>		: [0-0a-f]\.[0-9a-f]\.(0x)?[0-9a-fA-F]+
     59 *   <feature>		: ro
     60 *   <feature_list>	: \(<feature>(:<feature>)*\)
     61 *   <devno-range>	: <devno>(-<devno>)?<feature_list>?
     62 *   <busid-range>	: <busid>(-<busid>)?<feature_list>?
     63 *   <devices>		: <devno-range>|<busid-range>
     64 *   <dasd_module>	: dasd_diag_mod|dasd_eckd_mod|dasd_fba_mod
     65 *
     66 *   <dasd>		: autodetect|probeonly|<devices>(,<devices>)*
     67 */
     68
     69int dasd_probeonly =  0;	/* is true, when probeonly mode is active */
     70int dasd_autodetect = 0;	/* is true, when autodetection is active */
     71int dasd_nopav = 0;		/* is true, when PAV is disabled */
     72EXPORT_SYMBOL_GPL(dasd_nopav);
     73int dasd_nofcx;			/* disable High Performance Ficon */
     74EXPORT_SYMBOL_GPL(dasd_nofcx);
     75
     76/*
     77 * char *dasd[] is intended to hold the ranges supplied by the dasd= statement
     78 * it is named 'dasd' to directly be filled by insmod with the comma separated
     79 * strings when running as a module.
     80 */
     81static char *dasd[DASD_MAX_PARAMS];
     82module_param_array(dasd, charp, NULL, S_IRUGO);
     83
     84/*
     85 * Single spinlock to protect devmap and servermap structures and lists.
     86 */
     87static DEFINE_SPINLOCK(dasd_devmap_lock);
     88
     89/*
     90 * Hash lists for devmap structures.
     91 */
     92static struct list_head dasd_hashlists[256];
     93int dasd_max_devindex;
     94
     95static struct dasd_devmap *dasd_add_busid(const char *, int);
     96
     97static inline int
     98dasd_hash_busid(const char *bus_id)
     99{
    100	int hash, i;
    101
    102	hash = 0;
    103	for (i = 0; (i < DASD_BUS_ID_SIZE) && *bus_id; i++, bus_id++)
    104		hash += *bus_id;
    105	return hash & 0xff;
    106}
    107
    108#ifndef MODULE
    109static int __init dasd_call_setup(char *opt)
    110{
    111	static int i __initdata;
    112	char *tmp;
    113
    114	while (i < DASD_MAX_PARAMS) {
    115		tmp = strsep(&opt, ",");
    116		if (!tmp)
    117			break;
    118
    119		dasd[i++] = tmp;
    120	}
    121
    122	return 1;
    123}
    124
    125__setup ("dasd=", dasd_call_setup);
    126#endif	/* #ifndef MODULE */
    127
    128#define	DASD_IPLDEV	"ipldev"
    129
    130/*
    131 * Read a device busid/devno from a string.
    132 */
    133static int __init dasd_busid(char *str, int *id0, int *id1, int *devno)
    134{
    135	unsigned int val;
    136	char *tok;
    137
    138	/* Interpret ipldev busid */
    139	if (strncmp(DASD_IPLDEV, str, strlen(DASD_IPLDEV)) == 0) {
    140		if (ipl_info.type != IPL_TYPE_CCW) {
    141			pr_err("The IPL device is not a CCW device\n");
    142			return -EINVAL;
    143		}
    144		*id0 = 0;
    145		*id1 = ipl_info.data.ccw.dev_id.ssid;
    146		*devno = ipl_info.data.ccw.dev_id.devno;
    147
    148		return 0;
    149	}
    150
    151	/* Old style 0xXXXX or XXXX */
    152	if (!kstrtouint(str, 16, &val)) {
    153		*id0 = *id1 = 0;
    154		if (val > 0xffff)
    155			return -EINVAL;
    156		*devno = val;
    157		return 0;
    158	}
    159
    160	/* New style x.y.z busid */
    161	tok = strsep(&str, ".");
    162	if (kstrtouint(tok, 16, &val) || val > 0xff)
    163		return -EINVAL;
    164	*id0 = val;
    165
    166	tok = strsep(&str, ".");
    167	if (kstrtouint(tok, 16, &val) || val > 0xff)
    168		return -EINVAL;
    169	*id1 = val;
    170
    171	tok = strsep(&str, ".");
    172	if (kstrtouint(tok, 16, &val) || val > 0xffff)
    173		return -EINVAL;
    174	*devno = val;
    175
    176	return 0;
    177}
    178
    179/*
    180 * Read colon separated list of dasd features.
    181 */
    182static int __init dasd_feature_list(char *str)
    183{
    184	int features, len, rc;
    185
    186	features = 0;
    187	rc = 0;
    188
    189	if (!str)
    190		return DASD_FEATURE_DEFAULT;
    191
    192	while (1) {
    193		for (len = 0;
    194		     str[len] && str[len] != ':' && str[len] != ')'; len++);
    195		if (len == 2 && !strncmp(str, "ro", 2))
    196			features |= DASD_FEATURE_READONLY;
    197		else if (len == 4 && !strncmp(str, "diag", 4))
    198			features |= DASD_FEATURE_USEDIAG;
    199		else if (len == 3 && !strncmp(str, "raw", 3))
    200			features |= DASD_FEATURE_USERAW;
    201		else if (len == 6 && !strncmp(str, "erplog", 6))
    202			features |= DASD_FEATURE_ERPLOG;
    203		else if (len == 8 && !strncmp(str, "failfast", 8))
    204			features |= DASD_FEATURE_FAILFAST;
    205		else {
    206			pr_warn("%.*s is not a supported device option\n",
    207				len, str);
    208			rc = -EINVAL;
    209		}
    210		str += len;
    211		if (*str != ':')
    212			break;
    213		str++;
    214	}
    215
    216	return rc ? : features;
    217}
    218
    219/*
    220 * Try to match the first element on the comma separated parse string
    221 * with one of the known keywords. If a keyword is found, take the approprate
    222 * action and return a pointer to the residual string. If the first element
    223 * could not be matched to any keyword then return an error code.
    224 */
    225static int __init dasd_parse_keyword(char *keyword)
    226{
    227	int length = strlen(keyword);
    228
    229	if (strncmp("autodetect", keyword, length) == 0) {
    230		dasd_autodetect = 1;
    231		pr_info("The autodetection mode has been activated\n");
    232		return 0;
    233        }
    234	if (strncmp("probeonly", keyword, length) == 0) {
    235		dasd_probeonly = 1;
    236		pr_info("The probeonly mode has been activated\n");
    237		return 0;
    238        }
    239	if (strncmp("nopav", keyword, length) == 0) {
    240		if (MACHINE_IS_VM)
    241			pr_info("'nopav' is not supported on z/VM\n");
    242		else {
    243			dasd_nopav = 1;
    244			pr_info("PAV support has be deactivated\n");
    245		}
    246		return 0;
    247	}
    248	if (strncmp("nofcx", keyword, length) == 0) {
    249		dasd_nofcx = 1;
    250		pr_info("High Performance FICON support has been "
    251			"deactivated\n");
    252		return 0;
    253	}
    254	if (strncmp("fixedbuffers", keyword, length) == 0) {
    255		if (dasd_page_cache)
    256			return 0;
    257		dasd_page_cache =
    258			kmem_cache_create("dasd_page_cache", PAGE_SIZE,
    259					  PAGE_SIZE, SLAB_CACHE_DMA,
    260					  NULL);
    261		if (!dasd_page_cache)
    262			DBF_EVENT(DBF_WARNING, "%s", "Failed to create slab, "
    263				"fixed buffer mode disabled.");
    264		else
    265			DBF_EVENT(DBF_INFO, "%s",
    266				 "turning on fixed buffer mode");
    267		return 0;
    268	}
    269
    270	return -EINVAL;
    271}
    272
    273/*
    274 * Split a string of a device range into its pieces and return the from, to, and
    275 * feature parts separately.
    276 * e.g.:
    277 * 0.0.1234-0.0.5678(ro:erplog) -> from: 0.0.1234 to: 0.0.5678 features: ro:erplog
    278 * 0.0.8765(raw) -> from: 0.0.8765 to: null features: raw
    279 * 0x4321 -> from: 0x4321 to: null features: null
    280 */
    281static int __init dasd_evaluate_range_param(char *range, char **from_str,
    282					    char **to_str, char **features_str)
    283{
    284	int rc = 0;
    285
    286	/* Do we have a range or a single device? */
    287	if (strchr(range, '-')) {
    288		*from_str = strsep(&range, "-");
    289		*to_str = strsep(&range, "(");
    290		*features_str = strsep(&range, ")");
    291	} else {
    292		*from_str = strsep(&range, "(");
    293		*features_str = strsep(&range, ")");
    294	}
    295
    296	if (*features_str && !range) {
    297		pr_warn("A closing parenthesis ')' is missing in the dasd= parameter\n");
    298		rc = -EINVAL;
    299	}
    300
    301	return rc;
    302}
    303
    304/*
    305 * Try to interprete the range string as a device number or a range of devices.
    306 * If the interpretation is successful, create the matching dasd_devmap entries.
    307 * If interpretation fails or in case of an error, return an error code.
    308 */
    309static int __init dasd_parse_range(const char *range)
    310{
    311	struct dasd_devmap *devmap;
    312	int from, from_id0, from_id1;
    313	int to, to_id0, to_id1;
    314	int features;
    315	char bus_id[DASD_BUS_ID_SIZE + 1];
    316	char *features_str = NULL;
    317	char *from_str = NULL;
    318	char *to_str = NULL;
    319	int rc = 0;
    320	char *tmp;
    321
    322	tmp = kstrdup(range, GFP_KERNEL);
    323	if (!tmp)
    324		return -ENOMEM;
    325
    326	if (dasd_evaluate_range_param(tmp, &from_str, &to_str, &features_str)) {
    327		rc = -EINVAL;
    328		goto out;
    329	}
    330
    331	if (dasd_busid(from_str, &from_id0, &from_id1, &from)) {
    332		rc = -EINVAL;
    333		goto out;
    334	}
    335
    336	to = from;
    337	to_id0 = from_id0;
    338	to_id1 = from_id1;
    339	if (to_str) {
    340		if (dasd_busid(to_str, &to_id0, &to_id1, &to)) {
    341			rc = -EINVAL;
    342			goto out;
    343		}
    344		if (from_id0 != to_id0 || from_id1 != to_id1 || from > to) {
    345			pr_err("%s is not a valid device range\n", range);
    346			rc = -EINVAL;
    347			goto out;
    348		}
    349	}
    350
    351	features = dasd_feature_list(features_str);
    352	if (features < 0) {
    353		rc = -EINVAL;
    354		goto out;
    355	}
    356	/* each device in dasd= parameter should be set initially online */
    357	features |= DASD_FEATURE_INITIAL_ONLINE;
    358	while (from <= to) {
    359		sprintf(bus_id, "%01x.%01x.%04x", from_id0, from_id1, from++);
    360		devmap = dasd_add_busid(bus_id, features);
    361		if (IS_ERR(devmap)) {
    362			rc = PTR_ERR(devmap);
    363			goto out;
    364		}
    365	}
    366
    367out:
    368	kfree(tmp);
    369
    370	return rc;
    371}
    372
    373/*
    374 * Parse parameters stored in dasd[]
    375 * The 'dasd=...' parameter allows to specify a comma separated list of
    376 * keywords and device ranges. The parameters in that list will be stored as
    377 * separate elementes in dasd[].
    378 */
    379int __init dasd_parse(void)
    380{
    381	int rc, i;
    382	char *cur;
    383
    384	rc = 0;
    385	for (i = 0; i < DASD_MAX_PARAMS; i++) {
    386		cur = dasd[i];
    387		if (!cur)
    388			break;
    389		if (*cur == '\0')
    390			continue;
    391
    392		rc = dasd_parse_keyword(cur);
    393		if (rc)
    394			rc = dasd_parse_range(cur);
    395
    396		if (rc)
    397			break;
    398	}
    399
    400	return rc;
    401}
    402
    403/*
    404 * Add a devmap for the device specified by busid. It is possible that
    405 * the devmap already exists (dasd= parameter). The order of the devices
    406 * added through this function will define the kdevs for the individual
    407 * devices.
    408 */
    409static struct dasd_devmap *
    410dasd_add_busid(const char *bus_id, int features)
    411{
    412	struct dasd_devmap *devmap, *new, *tmp;
    413	int hash;
    414
    415	new = kzalloc(sizeof(struct dasd_devmap), GFP_KERNEL);
    416	if (!new)
    417		return ERR_PTR(-ENOMEM);
    418	spin_lock(&dasd_devmap_lock);
    419	devmap = NULL;
    420	hash = dasd_hash_busid(bus_id);
    421	list_for_each_entry(tmp, &dasd_hashlists[hash], list)
    422		if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) {
    423			devmap = tmp;
    424			break;
    425		}
    426	if (!devmap) {
    427		/* This bus_id is new. */
    428		new->devindex = dasd_max_devindex++;
    429		strlcpy(new->bus_id, bus_id, DASD_BUS_ID_SIZE);
    430		new->features = features;
    431		new->device = NULL;
    432		list_add(&new->list, &dasd_hashlists[hash]);
    433		devmap = new;
    434		new = NULL;
    435	}
    436	spin_unlock(&dasd_devmap_lock);
    437	kfree(new);
    438	return devmap;
    439}
    440
    441/*
    442 * Find devmap for device with given bus_id.
    443 */
    444static struct dasd_devmap *
    445dasd_find_busid(const char *bus_id)
    446{
    447	struct dasd_devmap *devmap, *tmp;
    448	int hash;
    449
    450	spin_lock(&dasd_devmap_lock);
    451	devmap = ERR_PTR(-ENODEV);
    452	hash = dasd_hash_busid(bus_id);
    453	list_for_each_entry(tmp, &dasd_hashlists[hash], list) {
    454		if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) {
    455			devmap = tmp;
    456			break;
    457		}
    458	}
    459	spin_unlock(&dasd_devmap_lock);
    460	return devmap;
    461}
    462
    463/*
    464 * Check if busid has been added to the list of dasd ranges.
    465 */
    466int
    467dasd_busid_known(const char *bus_id)
    468{
    469	return IS_ERR(dasd_find_busid(bus_id)) ? -ENOENT : 0;
    470}
    471
    472/*
    473 * Forget all about the device numbers added so far.
    474 * This may only be called at module unload or system shutdown.
    475 */
    476static void
    477dasd_forget_ranges(void)
    478{
    479	struct dasd_devmap *devmap, *n;
    480	int i;
    481
    482	spin_lock(&dasd_devmap_lock);
    483	for (i = 0; i < 256; i++) {
    484		list_for_each_entry_safe(devmap, n, &dasd_hashlists[i], list) {
    485			BUG_ON(devmap->device != NULL);
    486			list_del(&devmap->list);
    487			kfree(devmap);
    488		}
    489	}
    490	spin_unlock(&dasd_devmap_lock);
    491}
    492
    493/*
    494 * Find the device struct by its device index.
    495 */
    496struct dasd_device *
    497dasd_device_from_devindex(int devindex)
    498{
    499	struct dasd_devmap *devmap, *tmp;
    500	struct dasd_device *device;
    501	int i;
    502
    503	spin_lock(&dasd_devmap_lock);
    504	devmap = NULL;
    505	for (i = 0; (i < 256) && !devmap; i++)
    506		list_for_each_entry(tmp, &dasd_hashlists[i], list)
    507			if (tmp->devindex == devindex) {
    508				/* Found the devmap for the device. */
    509				devmap = tmp;
    510				break;
    511			}
    512	if (devmap && devmap->device) {
    513		device = devmap->device;
    514		dasd_get_device(device);
    515	} else
    516		device = ERR_PTR(-ENODEV);
    517	spin_unlock(&dasd_devmap_lock);
    518	return device;
    519}
    520
    521/*
    522 * Return devmap for cdev. If no devmap exists yet, create one and
    523 * connect it to the cdev.
    524 */
    525static struct dasd_devmap *
    526dasd_devmap_from_cdev(struct ccw_device *cdev)
    527{
    528	struct dasd_devmap *devmap;
    529
    530	devmap = dasd_find_busid(dev_name(&cdev->dev));
    531	if (IS_ERR(devmap))
    532		devmap = dasd_add_busid(dev_name(&cdev->dev),
    533					DASD_FEATURE_DEFAULT);
    534	return devmap;
    535}
    536
    537/*
    538 * Create a dasd device structure for cdev.
    539 */
    540struct dasd_device *
    541dasd_create_device(struct ccw_device *cdev)
    542{
    543	struct dasd_devmap *devmap;
    544	struct dasd_device *device;
    545	unsigned long flags;
    546	int rc;
    547
    548	devmap = dasd_devmap_from_cdev(cdev);
    549	if (IS_ERR(devmap))
    550		return (void *) devmap;
    551
    552	device = dasd_alloc_device();
    553	if (IS_ERR(device))
    554		return device;
    555	atomic_set(&device->ref_count, 3);
    556
    557	spin_lock(&dasd_devmap_lock);
    558	if (!devmap->device) {
    559		devmap->device = device;
    560		device->devindex = devmap->devindex;
    561		device->features = devmap->features;
    562		get_device(&cdev->dev);
    563		device->cdev = cdev;
    564		rc = 0;
    565	} else
    566		/* Someone else was faster. */
    567		rc = -EBUSY;
    568	spin_unlock(&dasd_devmap_lock);
    569
    570	if (rc) {
    571		dasd_free_device(device);
    572		return ERR_PTR(rc);
    573	}
    574
    575	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
    576	dev_set_drvdata(&cdev->dev, device);
    577	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
    578
    579	device->paths_info = kset_create_and_add("paths_info", NULL,
    580						 &device->cdev->dev.kobj);
    581	if (!device->paths_info)
    582		dev_warn(&cdev->dev, "Could not create paths_info kset\n");
    583
    584	return device;
    585}
    586
    587/*
    588 * Wait queue for dasd_delete_device waits.
    589 */
    590static DECLARE_WAIT_QUEUE_HEAD(dasd_delete_wq);
    591
    592/*
    593 * Remove a dasd device structure. The passed referenced
    594 * is destroyed.
    595 */
    596void
    597dasd_delete_device(struct dasd_device *device)
    598{
    599	struct ccw_device *cdev;
    600	struct dasd_devmap *devmap;
    601	unsigned long flags;
    602
    603	/* First remove device pointer from devmap. */
    604	devmap = dasd_find_busid(dev_name(&device->cdev->dev));
    605	BUG_ON(IS_ERR(devmap));
    606	spin_lock(&dasd_devmap_lock);
    607	if (devmap->device != device) {
    608		spin_unlock(&dasd_devmap_lock);
    609		dasd_put_device(device);
    610		return;
    611	}
    612	devmap->device = NULL;
    613	spin_unlock(&dasd_devmap_lock);
    614
    615	/* Disconnect dasd_device structure from ccw_device structure. */
    616	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
    617	dev_set_drvdata(&device->cdev->dev, NULL);
    618	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
    619
    620	/*
    621	 * Drop ref_count by 3, one for the devmap reference, one for
    622	 * the cdev reference and one for the passed reference.
    623	 */
    624	atomic_sub(3, &device->ref_count);
    625
    626	/* Wait for reference counter to drop to zero. */
    627	wait_event(dasd_delete_wq, atomic_read(&device->ref_count) == 0);
    628
    629	dasd_generic_free_discipline(device);
    630
    631	kset_unregister(device->paths_info);
    632
    633	/* Disconnect dasd_device structure from ccw_device structure. */
    634	cdev = device->cdev;
    635	device->cdev = NULL;
    636
    637	/* Put ccw_device structure. */
    638	put_device(&cdev->dev);
    639
    640	/* Now the device structure can be freed. */
    641	dasd_free_device(device);
    642}
    643
    644/*
    645 * Reference counter dropped to zero. Wake up waiter
    646 * in dasd_delete_device.
    647 */
    648void
    649dasd_put_device_wake(struct dasd_device *device)
    650{
    651	wake_up(&dasd_delete_wq);
    652}
    653EXPORT_SYMBOL_GPL(dasd_put_device_wake);
    654
    655/*
    656 * Return dasd_device structure associated with cdev.
    657 * This function needs to be called with the ccw device
    658 * lock held. It can be used from interrupt context.
    659 */
    660struct dasd_device *
    661dasd_device_from_cdev_locked(struct ccw_device *cdev)
    662{
    663	struct dasd_device *device = dev_get_drvdata(&cdev->dev);
    664
    665	if (!device)
    666		return ERR_PTR(-ENODEV);
    667	dasd_get_device(device);
    668	return device;
    669}
    670
    671/*
    672 * Return dasd_device structure associated with cdev.
    673 */
    674struct dasd_device *
    675dasd_device_from_cdev(struct ccw_device *cdev)
    676{
    677	struct dasd_device *device;
    678	unsigned long flags;
    679
    680	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
    681	device = dasd_device_from_cdev_locked(cdev);
    682	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
    683	return device;
    684}
    685
    686void dasd_add_link_to_gendisk(struct gendisk *gdp, struct dasd_device *device)
    687{
    688	struct dasd_devmap *devmap;
    689
    690	devmap = dasd_find_busid(dev_name(&device->cdev->dev));
    691	if (IS_ERR(devmap))
    692		return;
    693	spin_lock(&dasd_devmap_lock);
    694	gdp->private_data = devmap;
    695	spin_unlock(&dasd_devmap_lock);
    696}
    697
    698struct dasd_device *dasd_device_from_gendisk(struct gendisk *gdp)
    699{
    700	struct dasd_device *device;
    701	struct dasd_devmap *devmap;
    702
    703	if (!gdp->private_data)
    704		return NULL;
    705	device = NULL;
    706	spin_lock(&dasd_devmap_lock);
    707	devmap = gdp->private_data;
    708	if (devmap && devmap->device) {
    709		device = devmap->device;
    710		dasd_get_device(device);
    711	}
    712	spin_unlock(&dasd_devmap_lock);
    713	return device;
    714}
    715
    716/*
    717 * SECTION: files in sysfs
    718 */
    719
    720/*
    721 * failfast controls the behaviour, if no path is available
    722 */
    723static ssize_t dasd_ff_show(struct device *dev, struct device_attribute *attr,
    724			    char *buf)
    725{
    726	struct dasd_devmap *devmap;
    727	int ff_flag;
    728
    729	devmap = dasd_find_busid(dev_name(dev));
    730	if (!IS_ERR(devmap))
    731		ff_flag = (devmap->features & DASD_FEATURE_FAILFAST) != 0;
    732	else
    733		ff_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_FAILFAST) != 0;
    734	return sysfs_emit(buf, ff_flag ? "1\n" : "0\n");
    735}
    736
    737static ssize_t dasd_ff_store(struct device *dev, struct device_attribute *attr,
    738	      const char *buf, size_t count)
    739{
    740	unsigned int val;
    741	int rc;
    742
    743	if (kstrtouint(buf, 0, &val) || val > 1)
    744		return -EINVAL;
    745
    746	rc = dasd_set_feature(to_ccwdev(dev), DASD_FEATURE_FAILFAST, val);
    747
    748	return rc ? : count;
    749}
    750
    751static DEVICE_ATTR(failfast, 0644, dasd_ff_show, dasd_ff_store);
    752
    753/*
    754 * readonly controls the readonly status of a dasd
    755 */
    756static ssize_t
    757dasd_ro_show(struct device *dev, struct device_attribute *attr, char *buf)
    758{
    759	struct dasd_devmap *devmap;
    760	struct dasd_device *device;
    761	int ro_flag = 0;
    762
    763	devmap = dasd_find_busid(dev_name(dev));
    764	if (IS_ERR(devmap))
    765		goto out;
    766
    767	ro_flag = !!(devmap->features & DASD_FEATURE_READONLY);
    768
    769	spin_lock(&dasd_devmap_lock);
    770	device = devmap->device;
    771	if (device)
    772		ro_flag |= test_bit(DASD_FLAG_DEVICE_RO, &device->flags);
    773	spin_unlock(&dasd_devmap_lock);
    774
    775out:
    776	return sysfs_emit(buf, ro_flag ? "1\n" : "0\n");
    777}
    778
    779static ssize_t
    780dasd_ro_store(struct device *dev, struct device_attribute *attr,
    781	      const char *buf, size_t count)
    782{
    783	struct ccw_device *cdev = to_ccwdev(dev);
    784	struct dasd_device *device;
    785	unsigned long flags;
    786	unsigned int val;
    787	int rc;
    788
    789	if (kstrtouint(buf, 0, &val) || val > 1)
    790		return -EINVAL;
    791
    792	rc = dasd_set_feature(cdev, DASD_FEATURE_READONLY, val);
    793	if (rc)
    794		return rc;
    795
    796	device = dasd_device_from_cdev(cdev);
    797	if (IS_ERR(device))
    798		return count;
    799
    800	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
    801	val = val || test_bit(DASD_FLAG_DEVICE_RO, &device->flags);
    802
    803	if (!device->block || !device->block->gdp ||
    804	    test_bit(DASD_FLAG_OFFLINE, &device->flags)) {
    805		spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
    806		goto out;
    807	}
    808	/* Increase open_count to avoid losing the block device */
    809	atomic_inc(&device->block->open_count);
    810	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
    811
    812	set_disk_ro(device->block->gdp, val);
    813	atomic_dec(&device->block->open_count);
    814
    815out:
    816	dasd_put_device(device);
    817
    818	return count;
    819}
    820
    821static DEVICE_ATTR(readonly, 0644, dasd_ro_show, dasd_ro_store);
    822/*
    823 * erplog controls the logging of ERP related data
    824 * (e.g. failing channel programs).
    825 */
    826static ssize_t
    827dasd_erplog_show(struct device *dev, struct device_attribute *attr, char *buf)
    828{
    829	struct dasd_devmap *devmap;
    830	int erplog;
    831
    832	devmap = dasd_find_busid(dev_name(dev));
    833	if (!IS_ERR(devmap))
    834		erplog = (devmap->features & DASD_FEATURE_ERPLOG) != 0;
    835	else
    836		erplog = (DASD_FEATURE_DEFAULT & DASD_FEATURE_ERPLOG) != 0;
    837	return sysfs_emit(buf, erplog ? "1\n" : "0\n");
    838}
    839
    840static ssize_t
    841dasd_erplog_store(struct device *dev, struct device_attribute *attr,
    842	      const char *buf, size_t count)
    843{
    844	unsigned int val;
    845	int rc;
    846
    847	if (kstrtouint(buf, 0, &val) || val > 1)
    848		return -EINVAL;
    849
    850	rc = dasd_set_feature(to_ccwdev(dev), DASD_FEATURE_ERPLOG, val);
    851
    852	return rc ? : count;
    853}
    854
    855static DEVICE_ATTR(erplog, 0644, dasd_erplog_show, dasd_erplog_store);
    856
    857/*
    858 * use_diag controls whether the driver should use diag rather than ssch
    859 * to talk to the device
    860 */
    861static ssize_t
    862dasd_use_diag_show(struct device *dev, struct device_attribute *attr, char *buf)
    863{
    864	struct dasd_devmap *devmap;
    865	int use_diag;
    866
    867	devmap = dasd_find_busid(dev_name(dev));
    868	if (!IS_ERR(devmap))
    869		use_diag = (devmap->features & DASD_FEATURE_USEDIAG) != 0;
    870	else
    871		use_diag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USEDIAG) != 0;
    872	return sprintf(buf, use_diag ? "1\n" : "0\n");
    873}
    874
    875static ssize_t
    876dasd_use_diag_store(struct device *dev, struct device_attribute *attr,
    877		    const char *buf, size_t count)
    878{
    879	struct dasd_devmap *devmap;
    880	unsigned int val;
    881	ssize_t rc;
    882
    883	devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
    884	if (IS_ERR(devmap))
    885		return PTR_ERR(devmap);
    886
    887	if (kstrtouint(buf, 0, &val) || val > 1)
    888		return -EINVAL;
    889
    890	spin_lock(&dasd_devmap_lock);
    891	/* Changing diag discipline flag is only allowed in offline state. */
    892	rc = count;
    893	if (!devmap->device && !(devmap->features & DASD_FEATURE_USERAW)) {
    894		if (val)
    895			devmap->features |= DASD_FEATURE_USEDIAG;
    896		else
    897			devmap->features &= ~DASD_FEATURE_USEDIAG;
    898	} else
    899		rc = -EPERM;
    900	spin_unlock(&dasd_devmap_lock);
    901	return rc;
    902}
    903
    904static DEVICE_ATTR(use_diag, 0644, dasd_use_diag_show, dasd_use_diag_store);
    905
    906/*
    907 * use_raw controls whether the driver should give access to raw eckd data or
    908 * operate in standard mode
    909 */
    910static ssize_t
    911dasd_use_raw_show(struct device *dev, struct device_attribute *attr, char *buf)
    912{
    913	struct dasd_devmap *devmap;
    914	int use_raw;
    915
    916	devmap = dasd_find_busid(dev_name(dev));
    917	if (!IS_ERR(devmap))
    918		use_raw = (devmap->features & DASD_FEATURE_USERAW) != 0;
    919	else
    920		use_raw = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USERAW) != 0;
    921	return sprintf(buf, use_raw ? "1\n" : "0\n");
    922}
    923
    924static ssize_t
    925dasd_use_raw_store(struct device *dev, struct device_attribute *attr,
    926		    const char *buf, size_t count)
    927{
    928	struct dasd_devmap *devmap;
    929	ssize_t rc;
    930	unsigned long val;
    931
    932	devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
    933	if (IS_ERR(devmap))
    934		return PTR_ERR(devmap);
    935
    936	if ((kstrtoul(buf, 10, &val) != 0) || val > 1)
    937		return -EINVAL;
    938
    939	spin_lock(&dasd_devmap_lock);
    940	/* Changing diag discipline flag is only allowed in offline state. */
    941	rc = count;
    942	if (!devmap->device && !(devmap->features & DASD_FEATURE_USEDIAG)) {
    943		if (val)
    944			devmap->features |= DASD_FEATURE_USERAW;
    945		else
    946			devmap->features &= ~DASD_FEATURE_USERAW;
    947	} else
    948		rc = -EPERM;
    949	spin_unlock(&dasd_devmap_lock);
    950	return rc;
    951}
    952
    953static DEVICE_ATTR(raw_track_access, 0644, dasd_use_raw_show,
    954		   dasd_use_raw_store);
    955
    956static ssize_t
    957dasd_safe_offline_store(struct device *dev, struct device_attribute *attr,
    958			const char *buf, size_t count)
    959{
    960	struct ccw_device *cdev = to_ccwdev(dev);
    961	struct dasd_device *device;
    962	unsigned long flags;
    963	int rc;
    964
    965	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
    966	device = dasd_device_from_cdev_locked(cdev);
    967	if (IS_ERR(device)) {
    968		rc = PTR_ERR(device);
    969		spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
    970		goto out;
    971	}
    972
    973	if (test_bit(DASD_FLAG_OFFLINE, &device->flags) ||
    974	    test_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING, &device->flags)) {
    975		/* Already doing offline processing */
    976		dasd_put_device(device);
    977		spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
    978		rc = -EBUSY;
    979		goto out;
    980	}
    981
    982	set_bit(DASD_FLAG_SAFE_OFFLINE, &device->flags);
    983	dasd_put_device(device);
    984	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
    985
    986	rc = ccw_device_set_offline(cdev);
    987
    988out:
    989	return rc ? rc : count;
    990}
    991
    992static DEVICE_ATTR(safe_offline, 0200, NULL, dasd_safe_offline_store);
    993
    994static ssize_t
    995dasd_access_show(struct device *dev, struct device_attribute *attr,
    996		 char *buf)
    997{
    998	struct ccw_device *cdev = to_ccwdev(dev);
    999	struct dasd_device *device;
   1000	int count;
   1001
   1002	device = dasd_device_from_cdev(cdev);
   1003	if (IS_ERR(device))
   1004		return PTR_ERR(device);
   1005
   1006	if (!device->discipline)
   1007		count = -ENODEV;
   1008	else if (!device->discipline->host_access_count)
   1009		count = -EOPNOTSUPP;
   1010	else
   1011		count = device->discipline->host_access_count(device);
   1012
   1013	dasd_put_device(device);
   1014	if (count < 0)
   1015		return count;
   1016
   1017	return sprintf(buf, "%d\n", count);
   1018}
   1019
   1020static DEVICE_ATTR(host_access_count, 0444, dasd_access_show, NULL);
   1021
   1022static ssize_t
   1023dasd_discipline_show(struct device *dev, struct device_attribute *attr,
   1024		     char *buf)
   1025{
   1026	struct dasd_device *device;
   1027	ssize_t len;
   1028
   1029	device = dasd_device_from_cdev(to_ccwdev(dev));
   1030	if (IS_ERR(device))
   1031		goto out;
   1032	else if (!device->discipline) {
   1033		dasd_put_device(device);
   1034		goto out;
   1035	} else {
   1036		len = sysfs_emit(buf, "%s\n",
   1037				 device->discipline->name);
   1038		dasd_put_device(device);
   1039		return len;
   1040	}
   1041out:
   1042	len = sysfs_emit(buf, "none\n");
   1043	return len;
   1044}
   1045
   1046static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL);
   1047
   1048static ssize_t
   1049dasd_device_status_show(struct device *dev, struct device_attribute *attr,
   1050		     char *buf)
   1051{
   1052	struct dasd_device *device;
   1053	ssize_t len;
   1054
   1055	device = dasd_device_from_cdev(to_ccwdev(dev));
   1056	if (!IS_ERR(device)) {
   1057		switch (device->state) {
   1058		case DASD_STATE_NEW:
   1059			len = sysfs_emit(buf, "new\n");
   1060			break;
   1061		case DASD_STATE_KNOWN:
   1062			len = sysfs_emit(buf, "detected\n");
   1063			break;
   1064		case DASD_STATE_BASIC:
   1065			len = sysfs_emit(buf, "basic\n");
   1066			break;
   1067		case DASD_STATE_UNFMT:
   1068			len = sysfs_emit(buf, "unformatted\n");
   1069			break;
   1070		case DASD_STATE_READY:
   1071			len = sysfs_emit(buf, "ready\n");
   1072			break;
   1073		case DASD_STATE_ONLINE:
   1074			len = sysfs_emit(buf, "online\n");
   1075			break;
   1076		default:
   1077			len = sysfs_emit(buf, "no stat\n");
   1078			break;
   1079		}
   1080		dasd_put_device(device);
   1081	} else
   1082		len = sysfs_emit(buf, "unknown\n");
   1083	return len;
   1084}
   1085
   1086static DEVICE_ATTR(status, 0444, dasd_device_status_show, NULL);
   1087
   1088static ssize_t dasd_alias_show(struct device *dev,
   1089			       struct device_attribute *attr, char *buf)
   1090{
   1091	struct dasd_device *device;
   1092	struct dasd_uid uid;
   1093
   1094	device = dasd_device_from_cdev(to_ccwdev(dev));
   1095	if (IS_ERR(device))
   1096		return sprintf(buf, "0\n");
   1097
   1098	if (device->discipline && device->discipline->get_uid &&
   1099	    !device->discipline->get_uid(device, &uid)) {
   1100		if (uid.type == UA_BASE_PAV_ALIAS ||
   1101		    uid.type == UA_HYPER_PAV_ALIAS) {
   1102			dasd_put_device(device);
   1103			return sprintf(buf, "1\n");
   1104		}
   1105	}
   1106	dasd_put_device(device);
   1107
   1108	return sprintf(buf, "0\n");
   1109}
   1110
   1111static DEVICE_ATTR(alias, 0444, dasd_alias_show, NULL);
   1112
   1113static ssize_t dasd_vendor_show(struct device *dev,
   1114				struct device_attribute *attr, char *buf)
   1115{
   1116	struct dasd_device *device;
   1117	struct dasd_uid uid;
   1118	char *vendor;
   1119
   1120	device = dasd_device_from_cdev(to_ccwdev(dev));
   1121	vendor = "";
   1122	if (IS_ERR(device))
   1123		return sysfs_emit(buf, "%s\n", vendor);
   1124
   1125	if (device->discipline && device->discipline->get_uid &&
   1126	    !device->discipline->get_uid(device, &uid))
   1127			vendor = uid.vendor;
   1128
   1129	dasd_put_device(device);
   1130
   1131	return sysfs_emit(buf, "%s\n", vendor);
   1132}
   1133
   1134static DEVICE_ATTR(vendor, 0444, dasd_vendor_show, NULL);
   1135
   1136#define UID_STRLEN ( /* vendor */ 3 + 1 + /* serial    */ 14 + 1 +\
   1137		     /* SSID   */ 4 + 1 + /* unit addr */ 2 + 1 +\
   1138		     /* vduit */ 32 + 1)
   1139
   1140static ssize_t
   1141dasd_uid_show(struct device *dev, struct device_attribute *attr, char *buf)
   1142{
   1143	struct dasd_device *device;
   1144	struct dasd_uid uid;
   1145	char uid_string[UID_STRLEN];
   1146	char ua_string[3];
   1147
   1148	device = dasd_device_from_cdev(to_ccwdev(dev));
   1149	uid_string[0] = 0;
   1150	if (IS_ERR(device))
   1151		return sysfs_emit(buf, "%s\n", uid_string);
   1152
   1153	if (device->discipline && device->discipline->get_uid &&
   1154	    !device->discipline->get_uid(device, &uid)) {
   1155		switch (uid.type) {
   1156		case UA_BASE_DEVICE:
   1157			snprintf(ua_string, sizeof(ua_string), "%02x",
   1158				 uid.real_unit_addr);
   1159			break;
   1160		case UA_BASE_PAV_ALIAS:
   1161			snprintf(ua_string, sizeof(ua_string), "%02x",
   1162				 uid.base_unit_addr);
   1163			break;
   1164		case UA_HYPER_PAV_ALIAS:
   1165			snprintf(ua_string, sizeof(ua_string), "xx");
   1166			break;
   1167		default:
   1168			/* should not happen, treat like base device */
   1169			snprintf(ua_string, sizeof(ua_string), "%02x",
   1170				 uid.real_unit_addr);
   1171			break;
   1172		}
   1173
   1174		if (strlen(uid.vduit) > 0)
   1175			snprintf(uid_string, sizeof(uid_string),
   1176				 "%s.%s.%04x.%s.%s",
   1177				 uid.vendor, uid.serial, uid.ssid, ua_string,
   1178				 uid.vduit);
   1179		else
   1180			snprintf(uid_string, sizeof(uid_string),
   1181				 "%s.%s.%04x.%s",
   1182				 uid.vendor, uid.serial, uid.ssid, ua_string);
   1183	}
   1184	dasd_put_device(device);
   1185
   1186	return sysfs_emit(buf, "%s\n", uid_string);
   1187}
   1188static DEVICE_ATTR(uid, 0444, dasd_uid_show, NULL);
   1189
   1190/*
   1191 * extended error-reporting
   1192 */
   1193static ssize_t
   1194dasd_eer_show(struct device *dev, struct device_attribute *attr, char *buf)
   1195{
   1196	struct dasd_devmap *devmap;
   1197	int eer_flag;
   1198
   1199	devmap = dasd_find_busid(dev_name(dev));
   1200	if (!IS_ERR(devmap) && devmap->device)
   1201		eer_flag = dasd_eer_enabled(devmap->device);
   1202	else
   1203		eer_flag = 0;
   1204	return sysfs_emit(buf, eer_flag ? "1\n" : "0\n");
   1205}
   1206
   1207static ssize_t
   1208dasd_eer_store(struct device *dev, struct device_attribute *attr,
   1209	       const char *buf, size_t count)
   1210{
   1211	struct dasd_device *device;
   1212	unsigned int val;
   1213	int rc = 0;
   1214
   1215	device = dasd_device_from_cdev(to_ccwdev(dev));
   1216	if (IS_ERR(device))
   1217		return PTR_ERR(device);
   1218
   1219	if (kstrtouint(buf, 0, &val) || val > 1)
   1220		return -EINVAL;
   1221
   1222	if (val)
   1223		rc = dasd_eer_enable(device);
   1224	else
   1225		dasd_eer_disable(device);
   1226
   1227	dasd_put_device(device);
   1228
   1229	return rc ? : count;
   1230}
   1231
   1232static DEVICE_ATTR(eer_enabled, 0644, dasd_eer_show, dasd_eer_store);
   1233
   1234/*
   1235 * expiration time for default requests
   1236 */
   1237static ssize_t
   1238dasd_expires_show(struct device *dev, struct device_attribute *attr, char *buf)
   1239{
   1240	struct dasd_device *device;
   1241	int len;
   1242
   1243	device = dasd_device_from_cdev(to_ccwdev(dev));
   1244	if (IS_ERR(device))
   1245		return -ENODEV;
   1246	len = sysfs_emit(buf, "%lu\n", device->default_expires);
   1247	dasd_put_device(device);
   1248	return len;
   1249}
   1250
   1251static ssize_t
   1252dasd_expires_store(struct device *dev, struct device_attribute *attr,
   1253	       const char *buf, size_t count)
   1254{
   1255	struct dasd_device *device;
   1256	unsigned long val;
   1257
   1258	device = dasd_device_from_cdev(to_ccwdev(dev));
   1259	if (IS_ERR(device))
   1260		return -ENODEV;
   1261
   1262	if ((kstrtoul(buf, 10, &val) != 0) ||
   1263	    (val > DASD_EXPIRES_MAX) || val == 0) {
   1264		dasd_put_device(device);
   1265		return -EINVAL;
   1266	}
   1267
   1268	if (val)
   1269		device->default_expires = val;
   1270
   1271	dasd_put_device(device);
   1272	return count;
   1273}
   1274
   1275static DEVICE_ATTR(expires, 0644, dasd_expires_show, dasd_expires_store);
   1276
   1277static ssize_t
   1278dasd_retries_show(struct device *dev, struct device_attribute *attr, char *buf)
   1279{
   1280	struct dasd_device *device;
   1281	int len;
   1282
   1283	device = dasd_device_from_cdev(to_ccwdev(dev));
   1284	if (IS_ERR(device))
   1285		return -ENODEV;
   1286	len = sysfs_emit(buf, "%lu\n", device->default_retries);
   1287	dasd_put_device(device);
   1288	return len;
   1289}
   1290
   1291static ssize_t
   1292dasd_retries_store(struct device *dev, struct device_attribute *attr,
   1293		   const char *buf, size_t count)
   1294{
   1295	struct dasd_device *device;
   1296	unsigned long val;
   1297
   1298	device = dasd_device_from_cdev(to_ccwdev(dev));
   1299	if (IS_ERR(device))
   1300		return -ENODEV;
   1301
   1302	if ((kstrtoul(buf, 10, &val) != 0) ||
   1303	    (val > DASD_RETRIES_MAX)) {
   1304		dasd_put_device(device);
   1305		return -EINVAL;
   1306	}
   1307
   1308	if (val)
   1309		device->default_retries = val;
   1310
   1311	dasd_put_device(device);
   1312	return count;
   1313}
   1314
   1315static DEVICE_ATTR(retries, 0644, dasd_retries_show, dasd_retries_store);
   1316
   1317static ssize_t
   1318dasd_timeout_show(struct device *dev, struct device_attribute *attr,
   1319		  char *buf)
   1320{
   1321	struct dasd_device *device;
   1322	int len;
   1323
   1324	device = dasd_device_from_cdev(to_ccwdev(dev));
   1325	if (IS_ERR(device))
   1326		return -ENODEV;
   1327	len = sysfs_emit(buf, "%lu\n", device->blk_timeout);
   1328	dasd_put_device(device);
   1329	return len;
   1330}
   1331
   1332static ssize_t
   1333dasd_timeout_store(struct device *dev, struct device_attribute *attr,
   1334		   const char *buf, size_t count)
   1335{
   1336	struct dasd_device *device;
   1337	struct request_queue *q;
   1338	unsigned long val;
   1339
   1340	device = dasd_device_from_cdev(to_ccwdev(dev));
   1341	if (IS_ERR(device) || !device->block)
   1342		return -ENODEV;
   1343
   1344	if ((kstrtoul(buf, 10, &val) != 0) ||
   1345	    val > UINT_MAX / HZ) {
   1346		dasd_put_device(device);
   1347		return -EINVAL;
   1348	}
   1349	q = device->block->request_queue;
   1350	if (!q) {
   1351		dasd_put_device(device);
   1352		return -ENODEV;
   1353	}
   1354
   1355	device->blk_timeout = val;
   1356
   1357	blk_queue_rq_timeout(q, device->blk_timeout * HZ);
   1358
   1359	dasd_put_device(device);
   1360	return count;
   1361}
   1362
   1363static DEVICE_ATTR(timeout, 0644,
   1364		   dasd_timeout_show, dasd_timeout_store);
   1365
   1366
   1367static ssize_t
   1368dasd_path_reset_store(struct device *dev, struct device_attribute *attr,
   1369		      const char *buf, size_t count)
   1370{
   1371	struct dasd_device *device;
   1372	unsigned int val;
   1373
   1374	device = dasd_device_from_cdev(to_ccwdev(dev));
   1375	if (IS_ERR(device))
   1376		return -ENODEV;
   1377
   1378	if ((kstrtouint(buf, 16, &val) != 0) || val > 0xff)
   1379		val = 0;
   1380
   1381	if (device->discipline && device->discipline->reset_path)
   1382		device->discipline->reset_path(device, (__u8) val);
   1383
   1384	dasd_put_device(device);
   1385	return count;
   1386}
   1387
   1388static DEVICE_ATTR(path_reset, 0200, NULL, dasd_path_reset_store);
   1389
   1390static ssize_t dasd_hpf_show(struct device *dev, struct device_attribute *attr,
   1391			     char *buf)
   1392{
   1393	struct dasd_device *device;
   1394	int hpf;
   1395
   1396	device = dasd_device_from_cdev(to_ccwdev(dev));
   1397	if (IS_ERR(device))
   1398		return -ENODEV;
   1399	if (!device->discipline || !device->discipline->hpf_enabled) {
   1400		dasd_put_device(device);
   1401		return sysfs_emit(buf, "%d\n", dasd_nofcx);
   1402	}
   1403	hpf = device->discipline->hpf_enabled(device);
   1404	dasd_put_device(device);
   1405	return sysfs_emit(buf, "%d\n", hpf);
   1406}
   1407
   1408static DEVICE_ATTR(hpf, 0444, dasd_hpf_show, NULL);
   1409
   1410static ssize_t dasd_reservation_policy_show(struct device *dev,
   1411					    struct device_attribute *attr,
   1412					    char *buf)
   1413{
   1414	struct dasd_devmap *devmap;
   1415	int rc = 0;
   1416
   1417	devmap = dasd_find_busid(dev_name(dev));
   1418	if (IS_ERR(devmap)) {
   1419		rc = sysfs_emit(buf, "ignore\n");
   1420	} else {
   1421		spin_lock(&dasd_devmap_lock);
   1422		if (devmap->features & DASD_FEATURE_FAILONSLCK)
   1423			rc = sysfs_emit(buf, "fail\n");
   1424		else
   1425			rc = sysfs_emit(buf, "ignore\n");
   1426		spin_unlock(&dasd_devmap_lock);
   1427	}
   1428	return rc;
   1429}
   1430
   1431static ssize_t dasd_reservation_policy_store(struct device *dev,
   1432					     struct device_attribute *attr,
   1433					     const char *buf, size_t count)
   1434{
   1435	struct ccw_device *cdev = to_ccwdev(dev);
   1436	int rc;
   1437
   1438	if (sysfs_streq("ignore", buf))
   1439		rc = dasd_set_feature(cdev, DASD_FEATURE_FAILONSLCK, 0);
   1440	else if (sysfs_streq("fail", buf))
   1441		rc = dasd_set_feature(cdev, DASD_FEATURE_FAILONSLCK, 1);
   1442	else
   1443		rc = -EINVAL;
   1444
   1445	return rc ? : count;
   1446}
   1447
   1448static DEVICE_ATTR(reservation_policy, 0644,
   1449		   dasd_reservation_policy_show, dasd_reservation_policy_store);
   1450
   1451static ssize_t dasd_reservation_state_show(struct device *dev,
   1452					   struct device_attribute *attr,
   1453					   char *buf)
   1454{
   1455	struct dasd_device *device;
   1456	int rc = 0;
   1457
   1458	device = dasd_device_from_cdev(to_ccwdev(dev));
   1459	if (IS_ERR(device))
   1460		return sysfs_emit(buf, "none\n");
   1461
   1462	if (test_bit(DASD_FLAG_IS_RESERVED, &device->flags))
   1463		rc = sysfs_emit(buf, "reserved\n");
   1464	else if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags))
   1465		rc = sysfs_emit(buf, "lost\n");
   1466	else
   1467		rc = sysfs_emit(buf, "none\n");
   1468	dasd_put_device(device);
   1469	return rc;
   1470}
   1471
   1472static ssize_t dasd_reservation_state_store(struct device *dev,
   1473					    struct device_attribute *attr,
   1474					    const char *buf, size_t count)
   1475{
   1476	struct dasd_device *device;
   1477	int rc = 0;
   1478
   1479	device = dasd_device_from_cdev(to_ccwdev(dev));
   1480	if (IS_ERR(device))
   1481		return -ENODEV;
   1482	if (sysfs_streq("reset", buf))
   1483		clear_bit(DASD_FLAG_LOCK_STOLEN, &device->flags);
   1484	else
   1485		rc = -EINVAL;
   1486	dasd_put_device(device);
   1487
   1488	if (rc)
   1489		return rc;
   1490	else
   1491		return count;
   1492}
   1493
   1494static DEVICE_ATTR(last_known_reservation_state, 0644,
   1495		   dasd_reservation_state_show, dasd_reservation_state_store);
   1496
   1497static ssize_t dasd_pm_show(struct device *dev,
   1498			      struct device_attribute *attr, char *buf)
   1499{
   1500	struct dasd_device *device;
   1501	u8 opm, nppm, cablepm, cuirpm, hpfpm, ifccpm;
   1502
   1503	device = dasd_device_from_cdev(to_ccwdev(dev));
   1504	if (IS_ERR(device))
   1505		return sprintf(buf, "0\n");
   1506
   1507	opm = dasd_path_get_opm(device);
   1508	nppm = dasd_path_get_nppm(device);
   1509	cablepm = dasd_path_get_cablepm(device);
   1510	cuirpm = dasd_path_get_cuirpm(device);
   1511	hpfpm = dasd_path_get_hpfpm(device);
   1512	ifccpm = dasd_path_get_ifccpm(device);
   1513	dasd_put_device(device);
   1514
   1515	return sprintf(buf, "%02x %02x %02x %02x %02x %02x\n", opm, nppm,
   1516		       cablepm, cuirpm, hpfpm, ifccpm);
   1517}
   1518
   1519static DEVICE_ATTR(path_masks, 0444, dasd_pm_show, NULL);
   1520
   1521/*
   1522 * threshold value for IFCC/CCC errors
   1523 */
   1524static ssize_t
   1525dasd_path_threshold_show(struct device *dev,
   1526			  struct device_attribute *attr, char *buf)
   1527{
   1528	struct dasd_device *device;
   1529	int len;
   1530
   1531	device = dasd_device_from_cdev(to_ccwdev(dev));
   1532	if (IS_ERR(device))
   1533		return -ENODEV;
   1534	len = sysfs_emit(buf, "%lu\n", device->path_thrhld);
   1535	dasd_put_device(device);
   1536	return len;
   1537}
   1538
   1539static ssize_t
   1540dasd_path_threshold_store(struct device *dev, struct device_attribute *attr,
   1541			   const char *buf, size_t count)
   1542{
   1543	struct dasd_device *device;
   1544	unsigned long flags;
   1545	unsigned long val;
   1546
   1547	device = dasd_device_from_cdev(to_ccwdev(dev));
   1548	if (IS_ERR(device))
   1549		return -ENODEV;
   1550
   1551	if (kstrtoul(buf, 10, &val) != 0 || val > DASD_THRHLD_MAX) {
   1552		dasd_put_device(device);
   1553		return -EINVAL;
   1554	}
   1555	spin_lock_irqsave(get_ccwdev_lock(to_ccwdev(dev)), flags);
   1556	device->path_thrhld = val;
   1557	spin_unlock_irqrestore(get_ccwdev_lock(to_ccwdev(dev)), flags);
   1558	dasd_put_device(device);
   1559	return count;
   1560}
   1561static DEVICE_ATTR(path_threshold, 0644, dasd_path_threshold_show,
   1562		   dasd_path_threshold_store);
   1563
   1564/*
   1565 * configure if path is disabled after IFCC/CCC error threshold is
   1566 * exceeded
   1567 */
   1568static ssize_t
   1569dasd_path_autodisable_show(struct device *dev,
   1570				   struct device_attribute *attr, char *buf)
   1571{
   1572	struct dasd_devmap *devmap;
   1573	int flag;
   1574
   1575	devmap = dasd_find_busid(dev_name(dev));
   1576	if (!IS_ERR(devmap))
   1577		flag = (devmap->features & DASD_FEATURE_PATH_AUTODISABLE) != 0;
   1578	else
   1579		flag = (DASD_FEATURE_DEFAULT &
   1580			DASD_FEATURE_PATH_AUTODISABLE) != 0;
   1581	return sysfs_emit(buf, flag ? "1\n" : "0\n");
   1582}
   1583
   1584static ssize_t
   1585dasd_path_autodisable_store(struct device *dev,
   1586				    struct device_attribute *attr,
   1587				    const char *buf, size_t count)
   1588{
   1589	unsigned int val;
   1590	int rc;
   1591
   1592	if (kstrtouint(buf, 0, &val) || val > 1)
   1593		return -EINVAL;
   1594
   1595	rc = dasd_set_feature(to_ccwdev(dev),
   1596			      DASD_FEATURE_PATH_AUTODISABLE, val);
   1597
   1598	return rc ? : count;
   1599}
   1600
   1601static DEVICE_ATTR(path_autodisable, 0644,
   1602		   dasd_path_autodisable_show,
   1603		   dasd_path_autodisable_store);
   1604/*
   1605 * interval for IFCC/CCC checks
   1606 * meaning time with no IFCC/CCC error before the error counter
   1607 * gets reset
   1608 */
   1609static ssize_t
   1610dasd_path_interval_show(struct device *dev,
   1611			struct device_attribute *attr, char *buf)
   1612{
   1613	struct dasd_device *device;
   1614	int len;
   1615
   1616	device = dasd_device_from_cdev(to_ccwdev(dev));
   1617	if (IS_ERR(device))
   1618		return -ENODEV;
   1619	len = sysfs_emit(buf, "%lu\n", device->path_interval);
   1620	dasd_put_device(device);
   1621	return len;
   1622}
   1623
   1624static ssize_t
   1625dasd_path_interval_store(struct device *dev, struct device_attribute *attr,
   1626	       const char *buf, size_t count)
   1627{
   1628	struct dasd_device *device;
   1629	unsigned long flags;
   1630	unsigned long val;
   1631
   1632	device = dasd_device_from_cdev(to_ccwdev(dev));
   1633	if (IS_ERR(device))
   1634		return -ENODEV;
   1635
   1636	if ((kstrtoul(buf, 10, &val) != 0) ||
   1637	    (val > DASD_INTERVAL_MAX) || val == 0) {
   1638		dasd_put_device(device);
   1639		return -EINVAL;
   1640	}
   1641	spin_lock_irqsave(get_ccwdev_lock(to_ccwdev(dev)), flags);
   1642	if (val)
   1643		device->path_interval = val;
   1644	spin_unlock_irqrestore(get_ccwdev_lock(to_ccwdev(dev)), flags);
   1645	dasd_put_device(device);
   1646	return count;
   1647}
   1648
   1649static DEVICE_ATTR(path_interval, 0644, dasd_path_interval_show,
   1650		   dasd_path_interval_store);
   1651
   1652static ssize_t
   1653dasd_device_fcs_show(struct device *dev, struct device_attribute *attr,
   1654		     char *buf)
   1655{
   1656	struct dasd_device *device;
   1657	int fc_sec;
   1658	int rc;
   1659
   1660	device = dasd_device_from_cdev(to_ccwdev(dev));
   1661	if (IS_ERR(device))
   1662		return -ENODEV;
   1663	fc_sec = dasd_path_get_fcs_device(device);
   1664	if (fc_sec == -EINVAL)
   1665		rc = sysfs_emit(buf, "Inconsistent\n");
   1666	else
   1667		rc = sysfs_emit(buf, "%s\n", dasd_path_get_fcs_str(fc_sec));
   1668	dasd_put_device(device);
   1669
   1670	return rc;
   1671}
   1672static DEVICE_ATTR(fc_security, 0444, dasd_device_fcs_show, NULL);
   1673
   1674static ssize_t
   1675dasd_path_fcs_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
   1676{
   1677	struct dasd_path *path = to_dasd_path(kobj);
   1678	unsigned int fc_sec = path->fc_security;
   1679
   1680	return sysfs_emit(buf, "%s\n", dasd_path_get_fcs_str(fc_sec));
   1681}
   1682
   1683static struct kobj_attribute path_fcs_attribute =
   1684	__ATTR(fc_security, 0444, dasd_path_fcs_show, NULL);
   1685
   1686#define DASD_DEFINE_ATTR(_name, _func)					\
   1687static ssize_t dasd_##_name##_show(struct device *dev,			\
   1688				   struct device_attribute *attr,	\
   1689				   char *buf)				\
   1690{									\
   1691	struct ccw_device *cdev = to_ccwdev(dev);			\
   1692	struct dasd_device *device = dasd_device_from_cdev(cdev);	\
   1693	int val = 0;							\
   1694									\
   1695	if (IS_ERR(device))						\
   1696		return -ENODEV;						\
   1697	if (device->discipline && _func)				\
   1698		val = _func(device);					\
   1699	dasd_put_device(device);					\
   1700									\
   1701	return sysfs_emit(buf, "%d\n", val);			\
   1702}									\
   1703static DEVICE_ATTR(_name, 0444, dasd_##_name##_show, NULL);		\
   1704
   1705DASD_DEFINE_ATTR(ese, device->discipline->is_ese);
   1706DASD_DEFINE_ATTR(extent_size, device->discipline->ext_size);
   1707DASD_DEFINE_ATTR(pool_id, device->discipline->ext_pool_id);
   1708DASD_DEFINE_ATTR(space_configured, device->discipline->space_configured);
   1709DASD_DEFINE_ATTR(space_allocated, device->discipline->space_allocated);
   1710DASD_DEFINE_ATTR(logical_capacity, device->discipline->logical_capacity);
   1711DASD_DEFINE_ATTR(warn_threshold, device->discipline->ext_pool_warn_thrshld);
   1712DASD_DEFINE_ATTR(cap_at_warnlevel, device->discipline->ext_pool_cap_at_warnlevel);
   1713DASD_DEFINE_ATTR(pool_oos, device->discipline->ext_pool_oos);
   1714
   1715static struct attribute * dasd_attrs[] = {
   1716	&dev_attr_readonly.attr,
   1717	&dev_attr_discipline.attr,
   1718	&dev_attr_status.attr,
   1719	&dev_attr_alias.attr,
   1720	&dev_attr_vendor.attr,
   1721	&dev_attr_uid.attr,
   1722	&dev_attr_use_diag.attr,
   1723	&dev_attr_raw_track_access.attr,
   1724	&dev_attr_eer_enabled.attr,
   1725	&dev_attr_erplog.attr,
   1726	&dev_attr_failfast.attr,
   1727	&dev_attr_expires.attr,
   1728	&dev_attr_retries.attr,
   1729	&dev_attr_timeout.attr,
   1730	&dev_attr_reservation_policy.attr,
   1731	&dev_attr_last_known_reservation_state.attr,
   1732	&dev_attr_safe_offline.attr,
   1733	&dev_attr_host_access_count.attr,
   1734	&dev_attr_path_masks.attr,
   1735	&dev_attr_path_threshold.attr,
   1736	&dev_attr_path_autodisable.attr,
   1737	&dev_attr_path_interval.attr,
   1738	&dev_attr_path_reset.attr,
   1739	&dev_attr_hpf.attr,
   1740	&dev_attr_ese.attr,
   1741	&dev_attr_fc_security.attr,
   1742	NULL,
   1743};
   1744
   1745static const struct attribute_group dasd_attr_group = {
   1746	.attrs = dasd_attrs,
   1747};
   1748
   1749static struct attribute *capacity_attrs[] = {
   1750	&dev_attr_space_configured.attr,
   1751	&dev_attr_space_allocated.attr,
   1752	&dev_attr_logical_capacity.attr,
   1753	NULL,
   1754};
   1755
   1756static const struct attribute_group capacity_attr_group = {
   1757	.name = "capacity",
   1758	.attrs = capacity_attrs,
   1759};
   1760
   1761static struct attribute *ext_pool_attrs[] = {
   1762	&dev_attr_pool_id.attr,
   1763	&dev_attr_extent_size.attr,
   1764	&dev_attr_warn_threshold.attr,
   1765	&dev_attr_cap_at_warnlevel.attr,
   1766	&dev_attr_pool_oos.attr,
   1767	NULL,
   1768};
   1769
   1770static const struct attribute_group ext_pool_attr_group = {
   1771	.name = "extent_pool",
   1772	.attrs = ext_pool_attrs,
   1773};
   1774
   1775const struct attribute_group *dasd_dev_groups[] = {
   1776	&dasd_attr_group,
   1777	&capacity_attr_group,
   1778	&ext_pool_attr_group,
   1779	NULL,
   1780};
   1781EXPORT_SYMBOL_GPL(dasd_dev_groups);
   1782
   1783/*
   1784 * Return value of the specified feature.
   1785 */
   1786int
   1787dasd_get_feature(struct ccw_device *cdev, int feature)
   1788{
   1789	struct dasd_devmap *devmap;
   1790
   1791	devmap = dasd_find_busid(dev_name(&cdev->dev));
   1792	if (IS_ERR(devmap))
   1793		return PTR_ERR(devmap);
   1794
   1795	return ((devmap->features & feature) != 0);
   1796}
   1797
   1798/*
   1799 * Set / reset given feature.
   1800 * Flag indicates whether to set (!=0) or the reset (=0) the feature.
   1801 */
   1802int
   1803dasd_set_feature(struct ccw_device *cdev, int feature, int flag)
   1804{
   1805	struct dasd_devmap *devmap;
   1806
   1807	devmap = dasd_devmap_from_cdev(cdev);
   1808	if (IS_ERR(devmap))
   1809		return PTR_ERR(devmap);
   1810
   1811	spin_lock(&dasd_devmap_lock);
   1812	if (flag)
   1813		devmap->features |= feature;
   1814	else
   1815		devmap->features &= ~feature;
   1816	if (devmap->device)
   1817		devmap->device->features = devmap->features;
   1818	spin_unlock(&dasd_devmap_lock);
   1819	return 0;
   1820}
   1821EXPORT_SYMBOL(dasd_set_feature);
   1822
   1823static struct attribute *paths_info_attrs[] = {
   1824	&path_fcs_attribute.attr,
   1825	NULL,
   1826};
   1827ATTRIBUTE_GROUPS(paths_info);
   1828
   1829static struct kobj_type path_attr_type = {
   1830	.release	= dasd_path_release,
   1831	.default_groups	= paths_info_groups,
   1832	.sysfs_ops	= &kobj_sysfs_ops,
   1833};
   1834
   1835static void dasd_path_init_kobj(struct dasd_device *device, int chp)
   1836{
   1837	device->path[chp].kobj.kset = device->paths_info;
   1838	kobject_init(&device->path[chp].kobj, &path_attr_type);
   1839}
   1840
   1841void dasd_path_create_kobj(struct dasd_device *device, int chp)
   1842{
   1843	int rc;
   1844
   1845	if (test_bit(DASD_FLAG_OFFLINE, &device->flags))
   1846		return;
   1847	if (!device->paths_info) {
   1848		dev_warn(&device->cdev->dev, "Unable to create paths objects\n");
   1849		return;
   1850	}
   1851	if (device->path[chp].in_sysfs)
   1852		return;
   1853	if (!device->path[chp].conf_data)
   1854		return;
   1855
   1856	dasd_path_init_kobj(device, chp);
   1857
   1858	rc = kobject_add(&device->path[chp].kobj, NULL, "%x.%02x",
   1859			 device->path[chp].cssid, device->path[chp].chpid);
   1860	if (rc)
   1861		kobject_put(&device->path[chp].kobj);
   1862	device->path[chp].in_sysfs = true;
   1863}
   1864EXPORT_SYMBOL(dasd_path_create_kobj);
   1865
   1866void dasd_path_create_kobjects(struct dasd_device *device)
   1867{
   1868	u8 lpm, opm;
   1869
   1870	opm = dasd_path_get_opm(device);
   1871	for (lpm = 0x80; lpm; lpm >>= 1) {
   1872		if (!(lpm & opm))
   1873			continue;
   1874		dasd_path_create_kobj(device, pathmask_to_pos(lpm));
   1875	}
   1876}
   1877EXPORT_SYMBOL(dasd_path_create_kobjects);
   1878
   1879static void dasd_path_remove_kobj(struct dasd_device *device, int chp)
   1880{
   1881	if (device->path[chp].in_sysfs) {
   1882		kobject_put(&device->path[chp].kobj);
   1883		device->path[chp].in_sysfs = false;
   1884	}
   1885}
   1886
   1887/*
   1888 * As we keep kobjects for the lifetime of a device, this function must not be
   1889 * called anywhere but in the context of offlining a device.
   1890 */
   1891void dasd_path_remove_kobjects(struct dasd_device *device)
   1892{
   1893	int i;
   1894
   1895	for (i = 0; i < 8; i++)
   1896		dasd_path_remove_kobj(device, i);
   1897}
   1898EXPORT_SYMBOL(dasd_path_remove_kobjects);
   1899
   1900int
   1901dasd_devmap_init(void)
   1902{
   1903	int i;
   1904
   1905	/* Initialize devmap structures. */
   1906	dasd_max_devindex = 0;
   1907	for (i = 0; i < 256; i++)
   1908		INIT_LIST_HEAD(&dasd_hashlists[i]);
   1909	return 0;
   1910}
   1911
   1912void
   1913dasd_devmap_exit(void)
   1914{
   1915	dasd_forget_ranges();
   1916}