1 // SPDX-License-Identifier: GPL-2.0 2 /* 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, 2012 7 */ 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 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 27 /* 28 * compute the block number from a 29 * cyl-cyl-head-head structure 30 */ cchh2blk(struct vtoc_cchh * ptr,struct hd_geometry * geo)31 static 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 a 47 * cyl-cyl-head-head-block structure 48 */ cchhb2blk(struct vtoc_cchhb * ptr,struct hd_geometry * geo)49 static 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 4 66 #define DASD_VOL_ID_LEN 6 67 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 get_label_by_type(const char * type)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++) { 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 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)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 { 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 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], §); 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 find_vol1_partitions(struct parsed_partitions * state,struct hd_geometry * geo,int blocksize,char name[],union label_t * label)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, §); 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 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)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, 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 check 251 * 'size based on geo == size based on nr_sectors' is true, then 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; 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 find_cms1_partitions(struct parsed_partitions * state,struct hd_geometry * geo,int blocksize,char name[],union label_t * label,sector_t labelsect)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 322 /* 323 * This is the main function, called by check.c 324 */ ibm_partition(struct parsed_partitions * state)325 int 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 valid 389 * label. If it has the LDL format, then we simply define a 390 * 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 } else 401 res = 0; 402 403 out_freeall: 404 kfree(label); 405 out_nolab: 406 kfree(geo); 407 out_nogeo: 408 kfree(info); 409 out_symbol: 410 if (fn) 411 symbol_put(dasd_biodasdinfo); 412 out_exit: 413 return res; 414 } 415