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