415 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>4 * Volker Sameske <sameske@de.ibm.com>5 * Bugreports.to..: <Linux390@de.ibm.com>6 * Copyright IBM Corp. 1999, 20127 */8 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>14#include <linux/uaccess.h>15#include <asm/vtoc.h>16#include <linux/module.h>17#include <linux/dasd_mod.h>18 19#include "check.h"20 21union label_t {22 struct vtoc_volume_label_cdl vol;23 struct vtoc_volume_label_ldl lnx;24 struct vtoc_cms_label cms;25};26 27/*28 * compute the block number from a29 * cyl-cyl-head-head structure30 */31static sector_t cchh2blk(struct vtoc_cchh *ptr, struct hd_geometry *geo)32{33 sector_t cyl;34 __u16 head;35 36 /* decode cylinder and heads for large volumes */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;43}44 45/*46 * compute the block number from a47 * cyl-cyl-head-head-block structure48 */49static sector_t cchhb2blk(struct vtoc_cchhb *ptr, struct hd_geometry *geo)50{51 sector_t cyl;52 __u16 head;53 54 /* decode cylinder and heads for large volumes */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 +61 ptr->b;62}63 64/* Volume Label Type/ID Length */65#define DASD_VOL_TYPE_LEN 466#define DASD_VOL_ID_LEN 667 68/* Volume Label Types */69#define DASD_VOLLBL_TYPE_VOL1 070#define DASD_VOLLBL_TYPE_LNX1 171#define DASD_VOLLBL_TYPE_CMS1 272 73struct dasd_vollabel {74 char *type;75 int idx;76};77 78static 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 93static int get_label_by_type(const char *type)94{95 int i;96 97 for (i = 0; i < ARRAY_SIZE(dasd_vollabels); i++) {98 if (!memcmp(type, dasd_vollabels[i].type, DASD_VOL_TYPE_LEN))99 return dasd_vollabels[i].idx;100 }101 102 return -1;103}104 105static 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{114 sector_t testsect[3];115 int i, testcount;116 Sector sect;117 void *data;118 119 /* There a three places where we may find a valid label:120 * - on an ECKD disk it's block 2121 * - on an FBA disk it's block 1122 * - on an CMS formatted FBA disk it is sector 1, even if the block size123 * 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 we125 * 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 else132 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], §);142 if (data == NULL)143 continue;144 memcpy(label, data, sizeof(*label));145 memcpy(type, data, DASD_VOL_TYPE_LEN);146 EBCASC(type, DASD_VOL_TYPE_LEN);147 put_dev_sector(sect);148 switch (get_label_by_type(type)) {149 case DASD_VOLLBL_TYPE_VOL1:150 memcpy(name, label->vol.volid, DASD_VOL_ID_LEN);151 EBCASC(name, DASD_VOL_ID_LEN);152 *labelsect = testsect[i];153 return 1;154 case DASD_VOLLBL_TYPE_LNX1:155 case DASD_VOLLBL_TYPE_CMS1:156 memcpy(name, label->lnx.volid, DASD_VOL_ID_LEN);157 EBCASC(name, DASD_VOL_ID_LEN);158 *labelsect = testsect[i];159 return 1;160 default:161 break;162 }163 }164 165 return 0;166}167 168static 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 format1187 * and format8 labels188 */189 secperblk = blocksize >> 9;190 blk = cchhb2blk(&label->vol.vtoc, geo) + 1;191 counter = 0;192 data = read_part_sector(state, blk * secperblk, §);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, §);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, §);221 }222 strlcat(state->pp_buf, "\n", PAGE_SIZE);223 224 if (!data)225 return -1;226 227 return 1;228}229 230static 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,236 sector_t nr_sectors,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 check251 * 'size based on geo == size based on nr_sectors' is true, then252 * we can safely assume that we know the formatted size of253 * the disk, otherwise we need additional information254 * that we can only get from a real DASD device.255 */256 geo_size = geo->cylinders * geo->heads257 * geo->sectors * secperblk;258 size = nr_sectors;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;267 /* else keep size based on nr_sectors */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 277static 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 disk290 */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 byte305 * and the DIAG discipline is used, then the CMS label is found306 * in sector 1 instead of block 1. However, the partition is307 * still supposed to start in block 2.308 */309 if (labelsect == 1)310 offset = 2 * secperblk;311 else312 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 322/*323 * This is the main function, called by check.c324 */325int ibm_partition(struct parsed_partitions *state)326{327 int (*fn)(struct gendisk *disk, dasd_information2_t *info);328 struct gendisk *disk = state->disk;329 struct block_device *bdev = disk->part0;330 int blocksize, res;331 loff_t offset, size;332 sector_t nr_sectors;333 dasd_information2_t *info;334 struct hd_geometry *geo;335 char type[DASD_VOL_TYPE_LEN + 1] = "";336 char name[DASD_VOL_ID_LEN + 1] = "";337 sector_t labelsect;338 union label_t *label;339 340 res = 0;341 if (!disk->fops->getgeo)342 goto out_exit;343 fn = symbol_get(dasd_biodasdinfo);344 blocksize = bdev_logical_block_size(bdev);345 if (blocksize <= 0)346 goto out_symbol;347 nr_sectors = bdev_nr_sectors(bdev);348 if (nr_sectors == 0)349 goto out_symbol;350 info = kmalloc(sizeof(dasd_information2_t), GFP_KERNEL);351 if (info == NULL)352 goto out_symbol;353 geo = kmalloc(sizeof(struct hd_geometry), GFP_KERNEL);354 if (geo == NULL)355 goto out_nogeo;356 label = kmalloc(sizeof(union label_t), GFP_KERNEL);357 if (label == NULL)358 goto out_nolab;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))362 goto out_freeall;363 if (!fn || fn(disk, info)) {364 kfree(info);365 info = NULL;366 }367 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:371 res = find_vol1_partitions(state, geo, blocksize, name,372 label);373 break;374 case DASD_VOLLBL_TYPE_LNX1:375 res = find_lnx1_partitions(state, geo, blocksize, name,376 label, labelsect, nr_sectors,377 info);378 break;379 case DASD_VOLLBL_TYPE_CMS1:380 res = find_cms1_partitions(state, geo, blocksize, name,381 label, labelsect);382 break;383 }384 } else if (info) {385 /*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 valid389 * label. If it has the LDL format, then we simply define a390 * partition as if it had an LNX1 label.391 */392 res = 1;393 if (info->format == DASD_FORMAT_LDL) {394 strlcat(state->pp_buf, "(nonl)", PAGE_SIZE);395 size = nr_sectors;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 } else401 res = 0;402 403out_freeall:404 kfree(label);405out_nolab:406 kfree(geo);407out_nogeo:408 kfree(info);409out_symbol:410 if (fn)411 symbol_put(dasd_biodasdinfo);412out_exit:413 return res;414}415