/* * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> *		    Horst Hummel <Horst.Hummel@de.ibm.com> *		    Carsten Otte <Cotte@de.ibm.com> *		    Martin Schwidefsky <schwidefsky@de.ibm.com> * Bugreports.to..: <Linux390@de.ibm.com> * Copyright IBM Corp. 1999,2001 * * Device mapping and dasd= parameter parsing functions. All devmap * functions may not be called from interrupt context. In particular * dasd_get_device is a no-no from interrupt context. * */ #define KMSG_COMPONENT "dasd" #include <linux/ctype.h>#include <linux/init.h>#include <linux/module.h>#include <linux/slab.h> #include <asm/debug.h>#include <asm/uaccess.h>#include <asm/ipl.h> /* This is ugly... */#define PRINTK_HEADER "dasd_devmap:"#define DASD_BUS_ID_SIZE 20 #include "dasd_int.h" struct kmem_cache *dasd_page_cache;EXPORT_SYMBOL_GPL(dasd_page_cache); /* * dasd_devmap_t is used to store the features and the relation * between device number and device index. To find a dasd_devmap_t * that corresponds to a device number of a device index each * dasd_devmap_t is added to two linked lists, one to search by * the device number and one to search by the device index. As * soon as big minor numbers are available the device index list * can be removed since the device number will then be identical * to the device index. */struct dasd_devmap {	struct list_head list;	char bus_id[DASD_BUS_ID_SIZE];        unsigned int devindex;        unsigned short features;	struct dasd_device *device;}; /* * Parameter parsing functions for dasd= parameter. The syntax is: *   <devno>		: (0x)?[0-9a-fA-F]+ *   <busid>		: [0-0a-f]\.[0-9a-f]\.(0x)?[0-9a-fA-F]+ *   <feature>		: ro *   <feature_list>	: \(<feature>(:<feature>)*\) *   <devno-range>	: <devno>(-<devno>)?<feature_list>? *   <busid-range>	: <busid>(-<busid>)?<feature_list>? *   <devices>		: <devno-range>|<busid-range> *   <dasd_module>	: dasd_diag_mod|dasd_eckd_mod|dasd_fba_mod * *   <dasd>		: autodetect|probeonly|<devices>(,<devices>)* */ int dasd_probeonly =  0;	/* is true, when probeonly mode is active */int dasd_autodetect = 0;	/* is true, when autodetection is active */int dasd_nopav = 0;		/* is true, when PAV is disabled */EXPORT_SYMBOL_GPL(dasd_nopav);int dasd_nofcx;			/* disable High Performance Ficon */EXPORT_SYMBOL_GPL(dasd_nofcx); /* * char *dasd[] is intended to hold the ranges supplied by the dasd= statement * it is named 'dasd' to directly be filled by insmod with the comma separated * strings when running as a module. */static char *dasd[256];module_param_array(dasd, charp, NULL, 0); /* * Single spinlock to protect devmap and servermap structures and lists. */static DEFINE_SPINLOCK(dasd_devmap_lock); /* * Hash lists for devmap structures. */static struct list_head dasd_hashlists[256];int dasd_max_devindex; static struct dasd_devmap *dasd_add_busid(const char *, int); static inline intdasd_hash_busid(const char *bus_id){	int hash, i; 	hash = 0;	for (i = 0; (i < DASD_BUS_ID_SIZE) && *bus_id; i++, bus_id++)		hash += *bus_id;	return hash & 0xff;} #ifndef MODULE/* * The parameter parsing functions for builtin-drivers are called * before kmalloc works. Store the pointers to the parameters strings * into dasd[] for later processing. */static int __initdasd_call_setup(char *str){	static int count = 0; 	if (count < 256)		dasd[count++] = str;	return 1;} __setup ("dasd=", dasd_call_setup);#endif	/* #ifndef MODULE */ #define	DASD_IPLDEV	"ipldev" /* * Read a device busid/devno from a string. */static int dasd_busid(char **str, int *id0, int *id1, int *devno){	int val, old_style; 	/* Interpret ipldev busid */	if (strncmp(DASD_IPLDEV, *str, strlen(DASD_IPLDEV)) == 0) {		if (ipl_info.type != IPL_TYPE_CCW) {			pr_err("The IPL device is not a CCW device\n");			return -EINVAL;		}		*id0 = 0;		*id1 = ipl_info.data.ccw.dev_id.ssid;		*devno = ipl_info.data.ccw.dev_id.devno;		*str += strlen(DASD_IPLDEV); 		return 0;	}	/* check for leading '0x' */	old_style = 0;	if ((*str)[0] == '0' && (*str)[1] == 'x') {		*str += 2;		old_style = 1;	}	if (!isxdigit((*str)[0]))	/* We require at least one hex digit */		return -EINVAL;	val = simple_strtoul(*str, str, 16);	if (old_style || (*str)[0] != '.') {		*id0 = *id1 = 0;		if (val < 0 || val > 0xffff)			return -EINVAL;		*devno = val;		return 0;	}	/* New style x.y.z busid */	if (val < 0 || val > 0xff)		return -EINVAL;	*id0 = val;	(*str)++;	if (!isxdigit((*str)[0]))	/* We require at least one hex digit */		return -EINVAL;	val = simple_strtoul(*str, str, 16);	if (val < 0 || val > 0xff || (*str)++[0] != '.')		return -EINVAL;	*id1 = val;	if (!isxdigit((*str)[0]))	/* We require at least one hex digit */		return -EINVAL;	val = simple_strtoul(*str, str, 16);	if (val < 0 || val > 0xffff)		return -EINVAL;	*devno = val;	return 0;} /* * Read colon separated list of dasd features. Currently there is * only one: "ro" for read-only devices. The default feature set * is empty (value 0). */static intdasd_feature_list(char *str, char **endp){	int features, len, rc; 	rc = 0;	if (*str != '(') {		*endp = str;		return DASD_FEATURE_DEFAULT;	}	str++;	features = 0; 	while (1) {		for (len = 0;		     str[len] && str[len] != ':' && str[len] != ')'; len++);		if (len == 2 && !strncmp(str, "ro", 2))			features |= DASD_FEATURE_READONLY;		else if (len == 4 && !strncmp(str, "diag", 4))			features |= DASD_FEATURE_USEDIAG;		else if (len == 3 && !strncmp(str, "raw", 3))			features |= DASD_FEATURE_USERAW;		else if (len == 6 && !strncmp(str, "erplog", 6))			features |= DASD_FEATURE_ERPLOG;		else if (len == 8 && !strncmp(str, "failfast", 8))			features |= DASD_FEATURE_FAILFAST;		else {			pr_warning("%*s is not a supported device option\n",				   len, str);			rc = -EINVAL;		}		str += len;		if (*str != ':')			break;		str++;	}	if (*str != ')') {		pr_warning("A closing parenthesis ')' is missing in the "			   "dasd= parameter\n");		rc = -EINVAL;	} else		str++;	*endp = str;	if (rc != 0)		return rc;	return features;} /* * Try to match the first element on the comma separated parse string * with one of the known keywords. If a keyword is found, take the approprate * action and return a pointer to the residual string. If the first element * could not be matched to any keyword then return an error code. */static char *dasd_parse_keyword( char *parsestring ) { 	char *nextcomma, *residual_str;	int length; 	nextcomma = strchr(parsestring,',');	if (nextcomma) {		length = nextcomma - parsestring;		residual_str = nextcomma + 1;	} else {		length = strlen(parsestring);		residual_str = parsestring + length;        }	if (strncmp("autodetect", parsestring, length) == 0) {		dasd_autodetect = 1;		pr_info("The autodetection mode has been activated\n");                return residual_str;        }	if (strncmp("probeonly", parsestring, length) == 0) {		dasd_probeonly = 1;		pr_info("The probeonly mode has been activated\n");                return residual_str;        }	if (strncmp("nopav", parsestring, length) == 0) {		if (MACHINE_IS_VM)			pr_info("'nopav' is not supported on z/VM\n");		else {			dasd_nopav = 1;			pr_info("PAV support has be deactivated\n");		}		return residual_str;	}	if (strncmp("nofcx", parsestring, length) == 0) {		dasd_nofcx = 1;		pr_info("High Performance FICON support has been "			"deactivated\n");		return residual_str;	}	if (strncmp("fixedbuffers", parsestring, length) == 0) {		if (dasd_page_cache)			return residual_str;		dasd_page_cache =			kmem_cache_create("dasd_page_cache", PAGE_SIZE,					  PAGE_SIZE, SLAB_CACHE_DMA,					  NULL);		if (!dasd_page_cache)			DBF_EVENT(DBF_WARNING, "%s", "Failed to create slab, "				"fixed buffer mode disabled.");		else			DBF_EVENT(DBF_INFO, "%s",				 "turning on fixed buffer mode");                return residual_str;        }	return ERR_PTR(-EINVAL);} /* * Try to interprete the first element on the comma separated parse string * as a device number or a range of devices. If the interpretation is * successful, create the matching dasd_devmap entries and return a pointer * to the residual string. * If interpretation fails or in case of an error, return an error code. */static char *dasd_parse_range( char *parsestring ) { 	struct dasd_devmap *devmap;	int from, from_id0, from_id1;	int to, to_id0, to_id1;	int features, rc;	char bus_id[DASD_BUS_ID_SIZE+1], *str; 	str = parsestring;	rc = dasd_busid(&str, &from_id0, &from_id1, &from);	if (rc == 0) {		to = from;		to_id0 = from_id0;		to_id1 = from_id1;		if (*str == '-') {			str++;			rc = dasd_busid(&str, &to_id0, &to_id1, &to);		}	}	if (rc == 0 &&	    (from_id0 != to_id0 || from_id1 != to_id1 || from > to))		rc = -EINVAL;	if (rc) {		pr_err("%s is not a valid device range\n", parsestring);		return ERR_PTR(rc);	}	features = dasd_feature_list(str, &str);	if (features < 0)		return ERR_PTR(-EINVAL);	/* each device in dasd= parameter should be set initially online */	features |= DASD_FEATURE_INITIAL_ONLINE;	while (from <= to) {		sprintf(bus_id, "%01x.%01x.%04x",			from_id0, from_id1, from++);		devmap = dasd_add_busid(bus_id, features);		if (IS_ERR(devmap))			return (char *)devmap;	}	if (*str == ',')		return str + 1;	if (*str == '\0')		return str;	pr_warning("The dasd= parameter value %s has an invalid ending\n",		   str);	return ERR_PTR(-EINVAL);} static char *dasd_parse_next_element( char *parsestring ) {	char * residual_str;	residual_str = dasd_parse_keyword(parsestring);	if (!IS_ERR(residual_str))		return residual_str;	residual_str = dasd_parse_range(parsestring);	return residual_str;} /* * Parse parameters stored in dasd[] * The 'dasd=...' parameter allows to specify a comma separated list of * keywords and device ranges. When the dasd driver is build into the kernel, * the complete list will be stored as one element of the dasd[] array. * When the dasd driver is build as a module, then the list is broken into * it's elements and each dasd[] entry contains one element. */intdasd_parse(void){	int rc, i;	char *parsestring; 	rc = 0;	for (i = 0; i < 256; i++) {		if (dasd[i] == NULL)			break;		parsestring = dasd[i];		/* loop over the comma separated list in the parsestring */		while (*parsestring) {			parsestring = dasd_parse_next_element(parsestring);			if(IS_ERR(parsestring)) {				rc = PTR_ERR(parsestring);				break;			}		}		if (rc) {			DBF_EVENT(DBF_ALERT, "%s", "invalid range found");			break;		}	}	return rc;} /* * Add a devmap for the device specified by busid. It is possible that * the devmap already exists (dasd= parameter). The order of the devices * added through this function will define the kdevs for the individual * devices. */static struct dasd_devmap *dasd_add_busid(const char *bus_id, int features){	struct dasd_devmap *devmap, *new, *tmp;	int hash; 	new = kzalloc(sizeof(struct dasd_devmap), GFP_KERNEL);	if (!new)		return ERR_PTR(-ENOMEM);	spin_lock(&dasd_devmap_lock);	devmap = NULL;	hash = dasd_hash_busid(bus_id);	list_for_each_entry(tmp, &dasd_hashlists[hash], list)		if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) {			devmap = tmp;			break;		}	if (!devmap) {		/* This bus_id is new. */		new->devindex = dasd_max_devindex++;		strncpy(new->bus_id, bus_id, DASD_BUS_ID_SIZE);		new->features = features;		new->device = NULL;		list_add(&new->list, &dasd_hashlists[hash]);		devmap = new;		new = NULL;	}	spin_unlock(&dasd_devmap_lock);	kfree(new);	return devmap;} /* * Find devmap for device with given bus_id. */static struct dasd_devmap *dasd_find_busid(const char *bus_id){	struct dasd_devmap *devmap, *tmp;	int hash; 	spin_lock(&dasd_devmap_lock);	devmap = ERR_PTR(-ENODEV);	hash = dasd_hash_busid(bus_id);	list_for_each_entry(tmp, &dasd_hashlists[hash], list) {		if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) {			devmap = tmp;			break;		}	}	spin_unlock(&dasd_devmap_lock);	return devmap;} /* * Check if busid has been added to the list of dasd ranges. */intdasd_busid_known(const char *bus_id){	return IS_ERR(dasd_find_busid(bus_id)) ? -ENOENT : 0;} /* * Forget all about the device numbers added so far. * This may only be called at module unload or system shutdown. */static voiddasd_forget_ranges(void){	struct dasd_devmap *devmap, *n;	int i; 	spin_lock(&dasd_devmap_lock);	for (i = 0; i < 256; i++) {		list_for_each_entry_safe(devmap, n, &dasd_hashlists[i], list) {			BUG_ON(devmap->device != NULL);			list_del(&devmap->list);			kfree(devmap);		}	}	spin_unlock(&dasd_devmap_lock);} /* * Find the device struct by its device index. */struct dasd_device *dasd_device_from_devindex(int devindex){	struct dasd_devmap *devmap, *tmp;	struct dasd_device *device;	int i; 

Lines 1–500 of 1529. Load more