[linux-2.6-block.git] / block / partitions / ibm.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
 *                  Volker Sameske <sameske@de.ibm.com>
 * Bugreports.to..: <Linux390@de.ibm.com>
 * Copyright IBM Corp. 1999, 2012
 */

#include <linux/buffer_head.h>
#include <linux/hdreg.h>
#include <linux/slab.h>
#include <asm/dasd.h>
#include <asm/ebcdic.h>
#include <linux/uaccess.h>
#include <asm/vtoc.h>
#include <linux/module.h>
#include <linux/dasd_mod.h>

#include "check.h"

union label_t {
	struct vtoc_volume_label_cdl vol;
	struct vtoc_volume_label_ldl lnx;
	struct vtoc_cms_label cms;
};

/*
 * compute the block number from a
 * cyl-cyl-head-head structure
 */
static sector_t cchh2blk(struct vtoc_cchh *ptr, struct hd_geometry *geo)
{
	sector_t cyl;
	__u16 head;

	/* decode cylinder and heads for large volumes */
	cyl = ptr->hh & 0xFFF0;
	cyl <<= 12;
	cyl |= ptr->cc;
	head = ptr->hh & 0x000F;
	return cyl * geo->heads * geo->sectors +
	       head * geo->sectors;
}

/*
 * compute the block number from a
 * cyl-cyl-head-head-block structure
 */
static sector_t cchhb2blk(struct vtoc_cchhb *ptr, struct hd_geometry *geo)
{
	sector_t cyl;
	__u16 head;

	/* decode cylinder and heads for large volumes */
	cyl = ptr->hh & 0xFFF0;
	cyl <<= 12;
	cyl |= ptr->cc;
	head = ptr->hh & 0x000F;
	return	cyl * geo->heads * geo->sectors +
		head * geo->sectors +
		ptr->b;
}

/* Volume Label Type/ID Length */
#define DASD_VOL_TYPE_LEN	4
#define DASD_VOL_ID_LEN		6

/* Volume Label Types */
#define DASD_VOLLBL_TYPE_VOL1 0
#define DASD_VOLLBL_TYPE_LNX1 1
#define DASD_VOLLBL_TYPE_CMS1 2

struct dasd_vollabel {
	char *type;
	int idx;
};

static struct dasd_vollabel dasd_vollabels[] = {
	[DASD_VOLLBL_TYPE_VOL1] = {
		.type = "VOL1",
		.idx = DASD_VOLLBL_TYPE_VOL1,
	},
	[DASD_VOLLBL_TYPE_LNX1] = {
		.type = "LNX1",
		.idx = DASD_VOLLBL_TYPE_LNX1,
	},
	[DASD_VOLLBL_TYPE_CMS1] = {
		.type = "CMS1",
		.idx = DASD_VOLLBL_TYPE_CMS1,
	},
};

static int get_label_by_type(const char *type)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(dasd_vollabels); i++) {
		if (!memcmp(type, dasd_vollabels[i].type, DASD_VOL_TYPE_LEN))
			return dasd_vollabels[i].idx;
	}

	return -1;
}

static int find_label(struct parsed_partitions *state,
		      dasd_information2_t *info,
		      struct hd_geometry *geo,
		      int blocksize,
		      sector_t *labelsect,
		      char name[],
		      char type[],
		      union label_t *label)
{
	sector_t testsect[3];
	int i, testcount;
	Sector sect;
	void *data;

	/* There a three places where we may find a valid label:
	 * - on an ECKD disk it's block 2
	 * - on an FBA disk it's block 1
	 * - on an CMS formatted FBA disk it is sector 1, even if the block size
	 *   is larger than 512 bytes (possible if the DIAG discipline is used)
	 * If we have a valid info structure, then we know exactly which case we
	 * have, otherwise we just search through all possebilities.
	 */
	if (info) {
		if ((info->cu_type == 0x6310 && info->dev_type == 0x9336) ||
		    (info->cu_type == 0x3880 && info->dev_type == 0x3370))
			testsect[0] = info->label_block;
		else
			testsect[0] = info->label_block * (blocksize >> 9);
		testcount = 1;
	} else {
		testsect[0] = 1;
		testsect[1] = (blocksize >> 9);
		testsect[2] = 2 * (blocksize >> 9);
		testcount = 3;
	}
	for (i = 0; i < testcount; ++i) {
		data = read_part_sector(state, testsect[i], &sect);
		if (data == NULL)
			continue;
		memcpy(label, data, sizeof(*label));
		memcpy(type, data, DASD_VOL_TYPE_LEN);
		EBCASC(type, DASD_VOL_TYPE_LEN);
		put_dev_sector(sect);
		switch (get_label_by_type(type)) {
		case DASD_VOLLBL_TYPE_VOL1:
			memcpy(name, label->vol.volid, DASD_VOL_ID_LEN);
			EBCASC(name, DASD_VOL_ID_LEN);
			*labelsect = testsect[i];
			return 1;
		case DASD_VOLLBL_TYPE_LNX1:
		case DASD_VOLLBL_TYPE_CMS1:
			memcpy(name, label->lnx.volid, DASD_VOL_ID_LEN);
			EBCASC(name, DASD_VOL_ID_LEN);
			*labelsect = testsect[i];
			return 1;
		default:
			break;
		}
	}

	return 0;
}

static int find_vol1_partitions(struct parsed_partitions *state,
				struct hd_geometry *geo,
				int blocksize,
				char name[],
				union label_t *label)
{
	sector_t blk;
	int counter;
	char tmp[64];
	Sector sect;
	unsigned char *data;
	loff_t offset, size;
	struct vtoc_format1_label f1;
	int secperblk;

	snprintf(tmp, sizeof(tmp), "VOL1/%8s:", name);
	strlcat(state->pp_buf, tmp, PAGE_SIZE);
	/*
	 * get start of VTOC from the disk label and then search for format1
	 * and format8 labels
	 */
	secperblk = blocksize >> 9;
	blk = cchhb2blk(&label->vol.vtoc, geo) + 1;
	counter = 0;
	data = read_part_sector(state, blk * secperblk, &sect);
	while (data != NULL) {
		memcpy(&f1, data, sizeof(struct vtoc_format1_label));
		put_dev_sector(sect);
		/* skip FMT4 / FMT5 / FMT7 labels */
		if (f1.DS1FMTID == _ascebc['4']
		    || f1.DS1FMTID == _ascebc['5']
		    || f1.DS1FMTID == _ascebc['7']
		    || f1.DS1FMTID == _ascebc['9']) {
			blk++;
			data = read_part_sector(state, blk * secperblk, &sect);
			continue;
		}
		/* only FMT1 and 8 labels valid at this point */
		if (f1.DS1FMTID != _ascebc['1'] &&
		    f1.DS1FMTID != _ascebc['8'])
			break;
		/* OK, we got valid partition data */
		offset = cchh2blk(&f1.DS1EXT1.llimit, geo);
		size  = cchh2blk(&f1.DS1EXT1.ulimit, geo) -
			offset + geo->sectors;
		offset *= secperblk;
		size *= secperblk;
		if (counter >= state->limit)
			break;
		put_partition(state, counter + 1, offset, size);
		counter++;
		blk++;
		data = read_part_sector(state, blk * secperblk, &sect);
	}
	strlcat(state->pp_buf, "\n", PAGE_SIZE);

	if (!data)
		return -1;

	return 1;
}

static int find_lnx1_partitions(struct parsed_partitions *state,
				struct hd_geometry *geo,
				int blocksize,
				char name[],
				union label_t *label,
				sector_t labelsect,
				sector_t nr_sectors,
				dasd_information2_t *info)
{
	loff_t offset, geo_size, size;
	char tmp[64];
	int secperblk;

	snprintf(tmp, sizeof(tmp), "LNX1/%8s:", name);
	strlcat(state->pp_buf, tmp, PAGE_SIZE);
	secperblk = blocksize >> 9;
	if (label->lnx.ldl_version == 0xf2) {
		size = label->lnx.formatted_blocks * secperblk;
	} else {
		/*
		 * Formated w/o large volume support. If the sanity check
		 * 'size based on geo == size based on nr_sectors' is true, then
		 * we can safely assume that we know the formatted size of
		 * the disk, otherwise we need additional information
		 * that we can only get from a real DASD device.
		 */
		geo_size = geo->cylinders * geo->heads
			* geo->sectors * secperblk;
		size = nr_sectors;
		if (size != geo_size) {
			if (!info) {
				strlcat(state->pp_buf, "\n", PAGE_SIZE);
				return 1;
			}
			if (!strcmp(info->type, "ECKD"))
				if (geo_size < size)
					size = geo_size;
			/* else keep size based on nr_sectors */
		}
	}
	/* first and only partition starts in the first block after the label */
	offset = labelsect + secperblk;
	put_partition(state, 1, offset, size - offset);
	strlcat(state->pp_buf, "\n", PAGE_SIZE);
	return 1;
}

static int find_cms1_partitions(struct parsed_partitions *state,
				struct hd_geometry *geo,
				int blocksize,
				char name[],
				union label_t *label,
				sector_t labelsect)
{
	loff_t offset, size;
	char tmp[64];
	int secperblk;

	/*
	 * VM style CMS1 labeled disk
	 */
	blocksize = label->cms.block_size;
	secperblk = blocksize >> 9;
	if (label->cms.disk_offset != 0) {
		snprintf(tmp, sizeof(tmp), "CMS1/%8s(MDSK):", name);
		strlcat(state->pp_buf, tmp, PAGE_SIZE);
		/* disk is reserved minidisk */
		offset = label->cms.disk_offset * secperblk;
		size = (label->cms.block_count - 1) * secperblk;
	} else {
		snprintf(tmp, sizeof(tmp), "CMS1/%8s:", name);
		strlcat(state->pp_buf, tmp, PAGE_SIZE);
		/*
		 * Special case for FBA devices:
		 * If an FBA device is CMS formatted with blocksize > 512 byte
		 * and the DIAG discipline is used, then the CMS label is found
		 * in sector 1 instead of block 1. However, the partition is
		 * still supposed to start in block 2.
		 */
		if (labelsect == 1)
			offset = 2 * secperblk;
		else
			offset = labelsect + secperblk;
		size = label->cms.block_count * secperblk;
	}

	put_partition(state, 1, offset, size-offset);
	strlcat(state->pp_buf, "\n", PAGE_SIZE);
	return 1;
}


/*
 * This is the main function, called by check.c
 */
int ibm_partition(struct parsed_partitions *state)
{
	int (*fn)(struct gendisk *disk, dasd_information2_t *info);
	struct gendisk *disk = state->disk;
	struct block_device *bdev = disk->part0;
	int blocksize, res;
	loff_t offset, size;
	sector_t nr_sectors;
	dasd_information2_t *info;
	struct hd_geometry *geo;
	char type[DASD_VOL_TYPE_LEN + 1] = "";
	char name[DASD_VOL_ID_LEN + 1] = "";
	sector_t labelsect;
	union label_t *label;

	res = 0;
	if (!disk->fops->getgeo)
		goto out_exit;
	fn = symbol_get(dasd_biodasdinfo);
	blocksize = bdev_logical_block_size(bdev);
	if (blocksize <= 0)
		goto out_symbol;
	nr_sectors = bdev_nr_sectors(bdev);
	if (nr_sectors == 0)
		goto out_symbol;
	info = kmalloc(sizeof(dasd_information2_t), GFP_KERNEL);
	if (info == NULL)
		goto out_symbol;
	geo = kmalloc(sizeof(struct hd_geometry), GFP_KERNEL);
	if (geo == NULL)
		goto out_nogeo;
	label = kmalloc(sizeof(union label_t), GFP_KERNEL);
	if (label == NULL)
		goto out_nolab;
	/* set start if not filled by getgeo function e.g. virtblk */
	geo->start = get_start_sect(bdev);
	if (disk->fops->getgeo(bdev, geo))
		goto out_freeall;
	if (!fn || fn(disk, info)) {
		kfree(info);
		info = NULL;
	}

	if (find_label(state, info, geo, blocksize, &labelsect, name, type, label)) {
		switch (get_label_by_type(type)) {
		case DASD_VOLLBL_TYPE_VOL1:
			res = find_vol1_partitions(state, geo, blocksize, name,
						   label);
			break;
		case DASD_VOLLBL_TYPE_LNX1:
			res = find_lnx1_partitions(state, geo, blocksize, name,
						   label, labelsect, nr_sectors,
						   info);
			break;
		case DASD_VOLLBL_TYPE_CMS1:
			res = find_cms1_partitions(state, geo, blocksize, name,
						   label, labelsect);
			break;
		}
	} else if (info) {
		/*
		 * ugly but needed for backward compatibility:
		 * If the block device is a DASD (i.e. BIODASDINFO2 works),
		 * then we claim it in any case, even though it has no valid
		 * label. If it has the LDL format, then we simply define a
		 * partition as if it had an LNX1 label.
		 */
		res = 1;
		if (info->format == DASD_FORMAT_LDL) {
			strlcat(state->pp_buf, "(nonl)", PAGE_SIZE);
			size = nr_sectors;
			offset = (info->label_block + 1) * (blocksize >> 9);
			put_partition(state, 1, offset, size-offset);
			strlcat(state->pp_buf, "\n", PAGE_SIZE);
		}
	} else
		res = 0;

out_freeall:
	kfree(label);
out_nolab:
	kfree(geo);
out_nogeo:
	kfree(info);
out_symbol:
	if (fn)
		symbol_put(dasd_biodasdinfo);
out_exit:
	return res;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4	2	/*
1da177e4 LT	3	* Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
	4	* Volker Sameske <sameske@de.ibm.com>
	5	* Bugreports.to..: <Linux390@de.ibm.com>
46e88947	6	* Copyright IBM Corp. 1999, 2012
1da177e4 LT	7	*/
1da177e4 LT	8
1da177e4 LT	9	#include <linux/buffer_head.h>
	10	#include <linux/hdreg.h>
	11	#include <linux/slab.h>
	12	#include <asm/dasd.h>
	13	#include <asm/ebcdic.h>
7c0f6ba6	14	#include <linux/uaccess.h>
1da177e4	15	#include <asm/vtoc.h>
26d7e28e SH	16	#include <linux/module.h>
26d7e28e SH	17	#include <linux/dasd_mod.h>
1da177e4 LT	18
1da177e4 LT	19	#include "check.h"
1da177e4	20
46e88947 SW	21	union label_t {
	22	struct vtoc_volume_label_cdl vol;
	23	struct vtoc_volume_label_ldl lnx;
	24	struct vtoc_cms_label cms;
	25	};
	26
1da177e4	27	/*
ef1597d5	28	* compute the block number from a
1da177e4 LT	29	* cyl-cyl-head-head structure
1da177e4 LT	30	*/
46e88947 SW	31	static sector_t cchh2blk(struct vtoc_cchh ptr, struct hd_geometry geo)
46e88947 SW	32	{
b44b0ab3 SW	33	sector_t cyl;
	34	__u16 head;
	35
46e88947	36	/* decode cylinder and heads for large volumes */
b44b0ab3 SW	37	cyl = ptr->hh & 0xFFF0;
	38	cyl <<= 12;
	39	cyl \|= ptr->cc;
	40	head = ptr->hh & 0x000F;
	41	return cyl * geo->heads * geo->sectors +
	42	head * geo->sectors;
1da177e4 LT	43	}
1da177e4 LT	44
1da177e4	45	/*
ef1597d5	46	* compute the block number from a
1da177e4 LT	47	* cyl-cyl-head-head-block structure
1da177e4 LT	48	*/
46e88947 SW	49	static sector_t cchhb2blk(struct vtoc_cchhb ptr, struct hd_geometry geo)
46e88947 SW	50	{
b44b0ab3 SW	51	sector_t cyl;
	52	__u16 head;
	53
46e88947	54	/* decode cylinder and heads for large volumes */
b44b0ab3 SW	55	cyl = ptr->hh & 0xFFF0;
	56	cyl <<= 12;
	57	cyl \|= ptr->cc;
	58	head = ptr->hh & 0x000F;
	59	return cyl * geo->heads * geo->sectors +
	60	head * geo->sectors +
1da177e4 LT	61	ptr->b;
	62	}
	63
a31281ac JH	64	/* Volume Label Type/ID Length */
	65	#define DASD_VOL_TYPE_LEN 4
	66	#define DASD_VOL_ID_LEN 6
	67
f5f43aae JH	68	/* Volume Label Types */
	69	#define DASD_VOLLBL_TYPE_VOL1 0
	70	#define DASD_VOLLBL_TYPE_LNX1 1
	71	#define DASD_VOLLBL_TYPE_CMS1 2
	72
	73	struct dasd_vollabel {
	74	char *type;
	75	int idx;
	76	};
	77
	78	static struct dasd_vollabel dasd_vollabels[] = {
	79	[DASD_VOLLBL_TYPE_VOL1] = {
	80	.type = "VOL1",
	81	.idx = DASD_VOLLBL_TYPE_VOL1,
	82	},
	83	[DASD_VOLLBL_TYPE_LNX1] = {
	84	.type = "LNX1",
	85	.idx = DASD_VOLLBL_TYPE_LNX1,
	86	},
	87	[DASD_VOLLBL_TYPE_CMS1] = {
	88	.type = "CMS1",
	89	.idx = DASD_VOLLBL_TYPE_CMS1,
	90	},
	91	};
	92
	93	static int get_label_by_type(const char *type)
	94	{
	95	int i;
	96
	97	for (i = 0; i < ARRAY_SIZE(dasd_vollabels); i++) {
a31281ac	98	if (!memcmp(type, dasd_vollabels[i].type, DASD_VOL_TYPE_LEN))
f5f43aae JH	99	return dasd_vollabels[i].idx;
	100	}
	101
	102	return -1;
	103	}
	104
46e88947 SW	105	static int find_label(struct parsed_partitions *state,
	106	dasd_information2_t *info,
	107	struct hd_geometry *geo,
	108	int blocksize,
	109	sector_t *labelsect,
	110	char name[],
	111	char type[],
	112	union label_t *label)
	113	{
46e88947	114	sector_t testsect[3];
46e88947	115	int i, testcount;
f5f43aae JH	116	Sector sect;
f5f43aae JH	117	void *data;
46e88947 SW	118
	119	/* There a three places where we may find a valid label:
	120	* - on an ECKD disk it's block 2
	121	* - on an FBA disk it's block 1
	122	* - on an CMS formatted FBA disk it is sector 1, even if the block size
	123	* is larger than 512 bytes (possible if the DIAG discipline is used)
	124	* If we have a valid info structure, then we know exactly which case we
	125	* have, otherwise we just search through all possebilities.
	126	*/
	127	if (info) {
	128	if ((info->cu_type == 0x6310 && info->dev_type == 0x9336) \|\|
	129	(info->cu_type == 0x3880 && info->dev_type == 0x3370))
	130	testsect[0] = info->label_block;
	131	else
	132	testsect[0] = info->label_block * (blocksize >> 9);
	133	testcount = 1;
	134	} else {
	135	testsect[0] = 1;
	136	testsect[1] = (blocksize >> 9);
	137	testsect[2] = 2 * (blocksize >> 9);
	138	testcount = 3;
	139	}
	140	for (i = 0; i < testcount; ++i) {
	141	data = read_part_sector(state, testsect[i], &sect);
	142	if (data == NULL)
	143	continue;
	144	memcpy(label, data, sizeof(*label));
a31281ac JH	145	memcpy(type, data, DASD_VOL_TYPE_LEN);
a31281ac JH	146	EBCASC(type, DASD_VOL_TYPE_LEN);
46e88947	147	put_dev_sector(sect);
f5f43aae JH	148	switch (get_label_by_type(type)) {
f5f43aae JH	149	case DASD_VOLLBL_TYPE_VOL1:
a31281ac JH	150	memcpy(name, label->vol.volid, DASD_VOL_ID_LEN);
a31281ac JH	151	EBCASC(name, DASD_VOL_ID_LEN);
46e88947	152	*labelsect = testsect[i];
f5f43aae JH	153	return 1;
	154	case DASD_VOLLBL_TYPE_LNX1:
	155	case DASD_VOLLBL_TYPE_CMS1:
a31281ac JH	156	memcpy(name, label->lnx.volid, DASD_VOL_ID_LEN);
a31281ac JH	157	EBCASC(name, DASD_VOL_ID_LEN);
f5f43aae JH	158	*labelsect = testsect[i];
	159	return 1;
	160	default:
46e88947 SW	161	break;
	162	}
	163	}
46e88947	164
f5f43aae	165	return 0;
46e88947 SW	166	}
	167
	168	static int find_vol1_partitions(struct parsed_partitions *state,
	169	struct hd_geometry *geo,
	170	int blocksize,
	171	char name[],
	172	union label_t *label)
	173	{
	174	sector_t blk;
	175	int counter;
	176	char tmp[64];
	177	Sector sect;
	178	unsigned char *data;
	179	loff_t offset, size;
	180	struct vtoc_format1_label f1;
	181	int secperblk;
	182
	183	snprintf(tmp, sizeof(tmp), "VOL1/%8s:", name);
	184	strlcat(state->pp_buf, tmp, PAGE_SIZE);
	185	/*
	186	* get start of VTOC from the disk label and then search for format1
	187	* and format8 labels
	188	*/
	189	secperblk = blocksize >> 9;
	190	blk = cchhb2blk(&label->vol.vtoc, geo) + 1;
	191	counter = 0;
	192	data = read_part_sector(state, blk * secperblk, &sect);
	193	while (data != NULL) {
	194	memcpy(&f1, data, sizeof(struct vtoc_format1_label));
	195	put_dev_sector(sect);
	196	/* skip FMT4 / FMT5 / FMT7 labels */
	197	if (f1.DS1FMTID == _ascebc['4']
	198	\|\| f1.DS1FMTID == _ascebc['5']
	199	\|\| f1.DS1FMTID == _ascebc['7']
	200	\|\| f1.DS1FMTID == _ascebc['9']) {
	201	blk++;
	202	data = read_part_sector(state, blk * secperblk, &sect);
	203	continue;
	204	}
	205	/* only FMT1 and 8 labels valid at this point */
	206	if (f1.DS1FMTID != _ascebc['1'] &&
	207	f1.DS1FMTID != _ascebc['8'])
	208	break;
	209	/* OK, we got valid partition data */
	210	offset = cchh2blk(&f1.DS1EXT1.llimit, geo);
	211	size = cchh2blk(&f1.DS1EXT1.ulimit, geo) -
	212	offset + geo->sectors;
	213	offset *= secperblk;
	214	size *= secperblk;
	215	if (counter >= state->limit)
	216	break;
	217	put_partition(state, counter + 1, offset, size);
	218	counter++;
	219	blk++;
	220	data = read_part_sector(state, blk * secperblk, &sect);
	221	}
	222	strlcat(state->pp_buf, "\n", PAGE_SIZE);
	223
	224	if (!data)
	225	return -1;
	226
	227	return 1;
	228	}
	229
230	static int find_lnx1_partitions(struct parsed_partitions *state,
231	struct hd_geometry *geo,
232	int blocksize,
233	char name[],
234	union label_t *label,
235	sector_t labelsect,
97eeb5fc	236	sector_t nr_sectors,
46e88947 SW	237	dasd_information2_t *info)
	238	{
	239	loff_t offset, geo_size, size;
	240	char tmp[64];
	241	int secperblk;
	242
	243	snprintf(tmp, sizeof(tmp), "LNX1/%8s:", name);
	244	strlcat(state->pp_buf, tmp, PAGE_SIZE);
	245	secperblk = blocksize >> 9;
	246	if (label->lnx.ldl_version == 0xf2) {
	247	size = label->lnx.formatted_blocks * secperblk;
	248	} else {
	249	/*
	250	* Formated w/o large volume support. If the sanity check
97eeb5fc	251	* 'size based on geo == size based on nr_sectors' is true, then
46e88947 SW	252	* we can safely assume that we know the formatted size of
	253	* the disk, otherwise we need additional information
	254	* that we can only get from a real DASD device.
	255	*/
	256	geo_size = geo->cylinders * geo->heads
	257	* geo->sectors * secperblk;
97eeb5fc	258	size = nr_sectors;
46e88947 SW	259	if (size != geo_size) {
	260	if (!info) {
	261	strlcat(state->pp_buf, "\n", PAGE_SIZE);
	262	return 1;
	263	}
	264	if (!strcmp(info->type, "ECKD"))
	265	if (geo_size < size)
	266	size = geo_size;
97eeb5fc	267	/* else keep size based on nr_sectors */
46e88947 SW	268	}
	269	}
	270	/* first and only partition starts in the first block after the label */
	271	offset = labelsect + secperblk;
	272	put_partition(state, 1, offset, size - offset);
	273	strlcat(state->pp_buf, "\n", PAGE_SIZE);
	274	return 1;
	275	}
	276
	277	static int find_cms1_partitions(struct parsed_partitions *state,
	278	struct hd_geometry *geo,
	279	int blocksize,
	280	char name[],
	281	union label_t *label,
	282	sector_t labelsect)
	283	{
	284	loff_t offset, size;
	285	char tmp[64];
	286	int secperblk;
	287
	288	/*
	289	* VM style CMS1 labeled disk
	290	*/
	291	blocksize = label->cms.block_size;
	292	secperblk = blocksize >> 9;
	293	if (label->cms.disk_offset != 0) {
	294	snprintf(tmp, sizeof(tmp), "CMS1/%8s(MDSK):", name);
	295	strlcat(state->pp_buf, tmp, PAGE_SIZE);
	296	/* disk is reserved minidisk */
	297	offset = label->cms.disk_offset * secperblk;
	298	size = (label->cms.block_count - 1) * secperblk;
	299	} else {
	300	snprintf(tmp, sizeof(tmp), "CMS1/%8s:", name);
	301	strlcat(state->pp_buf, tmp, PAGE_SIZE);
	302	/*
	303	* Special case for FBA devices:
	304	* If an FBA device is CMS formatted with blocksize > 512 byte
	305	* and the DIAG discipline is used, then the CMS label is found
	306	* in sector 1 instead of block 1. However, the partition is
	307	* still supposed to start in block 2.
	308	*/
	309	if (labelsect == 1)
	310	offset = 2 * secperblk;
	311	else
	312	offset = labelsect + secperblk;
	313	size = label->cms.block_count * secperblk;
	314	}
	315
	316	put_partition(state, 1, offset, size-offset);
	317	strlcat(state->pp_buf, "\n", PAGE_SIZE);
	318	return 1;
	319	}
	320
	321
1da177e4	322	/*
46e88947	323	* This is the main function, called by check.c
1da177e4	324	*/
1493bf21	325	int ibm_partition(struct parsed_partitions *state)
1da177e4	326	{
26d7e28e	327	int (fn)(struct gendisk disk, dasd_information2_t *info);
a08aa9bc CH	328	struct gendisk *disk = state->disk;
a08aa9bc CH	329	struct block_device *bdev = disk->part0;
b44b0ab3	330	int blocksize, res;
97eeb5fc CH	331	loff_t offset, size;
97eeb5fc CH	332	sector_t nr_sectors;
bf1a95a2	333	dasd_information2_t *info;
1da177e4	334	struct hd_geometry *geo;
a31281ac JH	335	char type[DASD_VOL_TYPE_LEN + 1] = "";
a31281ac JH	336	char name[DASD_VOL_ID_LEN + 1] = "";
cffab6bc	337	sector_t labelsect;
46e88947	338	union label_t *label;
1da177e4	339
57881dd9	340	res = 0;
26d7e28e SH	341	if (!disk->fops->getgeo)
	342	goto out_exit;
	343	fn = symbol_get(dasd_biodasdinfo);
e1defc4f	344	blocksize = bdev_logical_block_size(bdev);
90f0094d	345	if (blocksize <= 0)
26d7e28e	346	goto out_symbol;
97eeb5fc CH	347	nr_sectors = bdev_nr_sectors(bdev);
97eeb5fc CH	348	if (nr_sectors == 0)
26d7e28e	349	goto out_symbol;
bf1a95a2 SH	350	info = kmalloc(sizeof(dasd_information2_t), GFP_KERNEL);
bf1a95a2 SH	351	if (info == NULL)
26d7e28e	352	goto out_symbol;
bf1a95a2 SH	353	geo = kmalloc(sizeof(struct hd_geometry), GFP_KERNEL);
bf1a95a2 SH	354	if (geo == NULL)
1da177e4	355	goto out_nogeo;
bf1a95a2 SH	356	label = kmalloc(sizeof(union label_t), GFP_KERNEL);
bf1a95a2 SH	357	if (label == NULL)
56dc6a88	358	goto out_nolab;
26d7e28e SH	359	/* set start if not filled by getgeo function e.g. virtblk */
	360	geo->start = get_start_sect(bdev);
	361	if (disk->fops->getgeo(bdev, geo))
57881dd9	362	goto out_freeall;
7370997d	363	if (!fn \|\| fn(disk, info)) {
46e88947 SW	364	kfree(info);
46e88947 SW	365	info = NULL;
b44b0ab3	366	}
57881dd9	367
f5f43aae JH	368	if (find_label(state, info, geo, blocksize, &labelsect, name, type, label)) {
	369	switch (get_label_by_type(type)) {
	370	case DASD_VOLLBL_TYPE_VOL1:
46e88947 SW	371	res = find_vol1_partitions(state, geo, blocksize, name,
46e88947 SW	372	label);
f5f43aae JH	373	break;
f5f43aae JH	374	case DASD_VOLLBL_TYPE_LNX1:
46e88947	375	res = find_lnx1_partitions(state, geo, blocksize, name,
97eeb5fc	376	label, labelsect, nr_sectors,
46e88947	377	info);
f5f43aae JH	378	break;
f5f43aae JH	379	case DASD_VOLLBL_TYPE_CMS1:
46e88947 SW	380	res = find_cms1_partitions(state, geo, blocksize, name,
46e88947 SW	381	label, labelsect);
f5f43aae	382	break;
b44b0ab3	383	}
46e88947	384	} else if (info) {
1da177e4	385	/*
46e88947 SW	386	* ugly but needed for backward compatibility:
	387	* If the block device is a DASD (i.e. BIODASDINFO2 works),
	388	* then we claim it in any case, even though it has no valid
	389	* label. If it has the LDL format, then we simply define a
	390	* partition as if it had an LNX1 label.
1da177e4	391	*/
46e88947 SW	392	res = 1;
	393	if (info->format == DASD_FORMAT_LDL) {
	394	strlcat(state->pp_buf, "(nonl)", PAGE_SIZE);
97eeb5fc	395	size = nr_sectors;
46e88947 SW	396	offset = (info->label_block + 1) * (blocksize >> 9);
	397	put_partition(state, 1, offset, size-offset);
	398	strlcat(state->pp_buf, "\n", PAGE_SIZE);
	399	}
	400	} else
	401	res = 0;
ef1597d5	402
57881dd9	403	out_freeall:
56dc6a88 PO	404	kfree(label);
56dc6a88 PO	405	out_nolab:
1da177e4 LT	406	kfree(geo);
	407	out_nogeo:
	408	kfree(info);
26d7e28e	409	out_symbol:
7370997d CH	410	if (fn)
7370997d CH	411	symbol_put(dasd_biodasdinfo);
57881dd9 S	412	out_exit:
57881dd9 S	413	return res;
1da177e4	414	}