ibm.c

Go to the documentation of this file.

/*
 * Author(s)......: Holger Smolinski <[email protected]>
 *                  Volker Sameske <[email protected]>
 * Bugreports.to..: <[email protected]>
 * 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 <asm/uaccess.h>
#include <asm/vtoc.h>

#include "check.h"
#include "ibm.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;
}

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 sect;
    unsigned char *data;
    sector_t testsect[3];
    unsigned char temp[5];
    int found = 0;
    int i, testcount;

    /* 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(temp, data, 4);
        temp[4] = 0;
        EBCASC(temp, 4);
        put_dev_sector(sect);
        if (!strcmp(temp, "VOL1") ||
            !strcmp(temp, "LNX1") ||
            !strcmp(temp, "CMS1")) {
            if (!strcmp(temp, "VOL1")) {
                strncpy(type, label->vol.vollbl, 4);
                strncpy(name, label->vol.volid, 6);
            } else {
                strncpy(type, label->lnx.vollbl, 4);
                strncpy(name, label->lnx.volid, 6);
            }
            EBCASC(type, 4);
            EBCASC(name, 6);
            *labelsect = testsect[i];
            found = 1;
            break;
        }
    }
    if (!found)
        memset(label, 0, sizeof(*label));

    return found;
}

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,
                loff_t i_size,
                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 i_size' 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 = i_size >> 9;
        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 i_size */
        }
    }
    /* 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)
{
    struct block_device *bdev = state->bdev;
    int blocksize, res;
    loff_t i_size, offset, size;
    dasd_information2_t *info;
    struct hd_geometry *geo;
    char type[5] = {0,};
    char name[7] = {0,};
    sector_t labelsect;
    union label_t *label;

    res = 0;
    blocksize = bdev_logical_block_size(bdev);
    if (blocksize <= 0)
        goto out_exit;
    i_size = i_size_read(bdev->bd_inode);
    if (i_size == 0)
        goto out_exit;
    info = kmalloc(sizeof(dasd_information2_t), GFP_KERNEL);
    if (info == NULL)
        goto out_exit;
    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;
    if (ioctl_by_bdev(bdev, HDIO_GETGEO, (unsigned long)geo) != 0)
        goto out_freeall;
    if (ioctl_by_bdev(bdev, BIODASDINFO2, (unsigned long)info) != 0) {
        kfree(info);
        info = NULL;
    }

    if (find_label(state, info, geo, blocksize, &labelsect, name, type,
               label)) {
        if (!strncmp(type, "VOL1", 4)) {
            res = find_vol1_partitions(state, geo, blocksize, name,
                           label);
        } else if (!strncmp(type, "LNX1", 4)) {
            res = find_lnx1_partitions(state, geo, blocksize, name,
                           label, labelsect, i_size,
                           info);
        } else if (!strncmp(type, "CMS1", 4)) {
            res = find_cms1_partitions(state, geo, blocksize, name,
                           label, labelsect);
        }
    } 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 = i_size >> 9;
            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_exit:
    return res;
}