device_pgid.c

Go to the documentation of this file.

/*
 *  CCW device PGID and path verification I/O handling.
 *
 *    Copyright IBM Corp. 2002, 2009
 *    Author(s): Cornelia Huck <[email protected]>
 *       Martin Schwidefsky <[email protected]>
 *       Peter Oberparleiter <[email protected]>
 */

#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/bitops.h>
#include <asm/ccwdev.h>
#include <asm/cio.h>

#include "cio.h"
#include "cio_debug.h"
#include "device.h"
#include "io_sch.h"

#define PGID_RETRIES    256
#define PGID_TIMEOUT    (10 * HZ)

/*
 * Process path verification data and report result.
 */
static void verify_done(struct ccw_device *cdev, int rc)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_dev_id *id = &cdev->private->dev_id;
    int mpath = cdev->private->flags.mpath;
    int pgroup = cdev->private->flags.pgroup;

    if (rc)
        goto out;
    /* Ensure consistent multipathing state at device and channel. */
    if (sch->config.mp != mpath) {
        sch->config.mp = mpath;
        rc = cio_commit_config(sch);
    }
out:
    CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d "
             "vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath,
             sch->vpm);
    ccw_device_verify_done(cdev, rc);
}

/*
 * Create channel program to perform a NOOP.
 */
static void nop_build_cp(struct ccw_device *cdev)
{
    struct ccw_request *req = &cdev->private->req;
    struct ccw1 *cp = cdev->private->iccws;

    cp->cmd_code    = CCW_CMD_NOOP;
    cp->cda     = 0;
    cp->count   = 0;
    cp->flags   = CCW_FLAG_SLI;
    req->cp     = cp;
}

/*
 * Perform NOOP on a single path.
 */
static void nop_do(struct ccw_device *cdev)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_request *req = &cdev->private->req;

    /* Adjust lpm. */
    req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm);
    if (!req->lpm)
        goto out_nopath;
    nop_build_cp(cdev);
    ccw_request_start(cdev);
    return;

out_nopath:
    verify_done(cdev, sch->vpm ? 0 : -EACCES);
}

/*
 * Adjust NOOP I/O status.
 */
static enum io_status nop_filter(struct ccw_device *cdev, void *data,
                 struct irb *irb, enum io_status status)
{
    /* Only subchannel status might indicate a path error. */
    if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0)
        return IO_DONE;
    return status;
}

/*
 * Process NOOP request result for a single path.
 */
static void nop_callback(struct ccw_device *cdev, void *data, int rc)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_request *req = &cdev->private->req;

    if (rc == 0)
        sch->vpm |= req->lpm;
    else if (rc != -EACCES)
        goto err;
    req->lpm >>= 1;
    nop_do(cdev);
    return;

err:
    verify_done(cdev, rc);
}

/*
 * Create channel program to perform SET PGID on a single path.
 */
static void spid_build_cp(struct ccw_device *cdev, u8 fn)
{
    struct ccw_request *req = &cdev->private->req;
    struct ccw1 *cp = cdev->private->iccws;
    int i = 8 - ffs(req->lpm);
    struct pgid *pgid = &cdev->private->pgid[i];

    pgid->inf.fc    = fn;
    cp->cmd_code    = CCW_CMD_SET_PGID;
    cp->cda     = (u32) (addr_t) pgid;
    cp->count   = sizeof(*pgid);
    cp->flags   = CCW_FLAG_SLI;
    req->cp     = cp;
}

/*
 * Perform establish/resign SET PGID on a single path.
 */
static void spid_do(struct ccw_device *cdev)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_request *req = &cdev->private->req;
    u8 fn;

    /* Use next available path that is not already in correct state. */
    req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask);
    if (!req->lpm)
        goto out_nopath;
    /* Channel program setup. */
    if (req->lpm & sch->opm)
        fn = SPID_FUNC_ESTABLISH;
    else
        fn = SPID_FUNC_RESIGN;
    if (cdev->private->flags.mpath)
        fn |= SPID_FUNC_MULTI_PATH;
    spid_build_cp(cdev, fn);
    ccw_request_start(cdev);
    return;

out_nopath:
    verify_done(cdev, sch->vpm ? 0 : -EACCES);
}

static void verify_start(struct ccw_device *cdev);

/*
 * Process SET PGID request result for a single path.
 */
static void spid_callback(struct ccw_device *cdev, void *data, int rc)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_request *req = &cdev->private->req;

    switch (rc) {
    case 0:
        sch->vpm |= req->lpm & sch->opm;
        break;
    case -EACCES:
        break;
    case -EOPNOTSUPP:
        if (cdev->private->flags.mpath) {
            /* Try without multipathing. */
            cdev->private->flags.mpath = 0;
            goto out_restart;
        }
        /* Try without pathgrouping. */
        cdev->private->flags.pgroup = 0;
        goto out_restart;
    default:
        goto err;
    }
    req->lpm >>= 1;
    spid_do(cdev);
    return;

out_restart:
    verify_start(cdev);
    return;
err:
    verify_done(cdev, rc);
}

static void spid_start(struct ccw_device *cdev)
{
    struct ccw_request *req = &cdev->private->req;

    /* Initialize request data. */
    memset(req, 0, sizeof(*req));
    req->timeout    = PGID_TIMEOUT;
    req->maxretries = PGID_RETRIES;
    req->lpm    = 0x80;
    req->singlepath = 1;
    req->callback   = spid_callback;
    spid_do(cdev);
}

static int pgid_is_reset(struct pgid *p)
{
    char *c;

    for (c = (char *)p + 1; c < (char *)(p + 1); c++) {
        if (*c != 0)
            return 0;
    }
    return 1;
}

static int pgid_cmp(struct pgid *p1, struct pgid *p2)
{
    return memcmp((char *) p1 + 1, (char *) p2 + 1,
              sizeof(struct pgid) - 1);
}

/*
 * Determine pathgroup state from PGID data.
 */
static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,
             int *mismatch, int *reserved, u8 *reset)
{
    struct pgid *pgid = &cdev->private->pgid[0];
    struct pgid *first = NULL;
    int lpm;
    int i;

    *mismatch = 0;
    *reserved = 0;
    *reset = 0;
    for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) {
        if ((cdev->private->pgid_valid_mask & lpm) == 0)
            continue;
        if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE)
            *reserved = 1;
        if (pgid_is_reset(pgid)) {
            *reset |= lpm;
            continue;
        }
        if (!first) {
            first = pgid;
            continue;
        }
        if (pgid_cmp(pgid, first) != 0)
            *mismatch = 1;
    }
    if (!first)
        first = &channel_subsystems[0]->global_pgid;
    *p = first;
}

static u8 pgid_to_donepm(struct ccw_device *cdev)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct pgid *pgid;
    int i;
    int lpm;
    u8 donepm = 0;

    /* Set bits for paths which are already in the target state. */
    for (i = 0; i < 8; i++) {
        lpm = 0x80 >> i;
        if ((cdev->private->pgid_valid_mask & lpm) == 0)
            continue;
        pgid = &cdev->private->pgid[i];
        if (sch->opm & lpm) {
            if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED)
                continue;
        } else {
            if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED)
                continue;
        }
        if (cdev->private->flags.mpath) {
            if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH)
                continue;
        } else {
            if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH)
                continue;
        }
        donepm |= lpm;
    }

    return donepm;
}

static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid)
{
    int i;

    for (i = 0; i < 8; i++)
        memcpy(&cdev->private->pgid[i], pgid, sizeof(struct pgid));
}

/*
 * Process SENSE PGID data and report result.
 */
static void snid_done(struct ccw_device *cdev, int rc)
{
    struct ccw_dev_id *id = &cdev->private->dev_id;
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct pgid *pgid;
    int mismatch = 0;
    int reserved = 0;
    u8 reset = 0;
    u8 donepm;

    if (rc)
        goto out;
    pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset);
    if (reserved)
        rc = -EUSERS;
    else if (mismatch)
        rc = -EOPNOTSUPP;
    else {
        donepm = pgid_to_donepm(cdev);
        sch->vpm = donepm & sch->opm;
        cdev->private->pgid_todo_mask &= ~donepm;
        cdev->private->pgid_reset_mask |= reset;
        pgid_fill(cdev, pgid);
    }
out:
    CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x "
              "todo=%02x mism=%d rsvd=%d reset=%02x\n", id->ssid,
              id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm,
              cdev->private->pgid_todo_mask, mismatch, reserved, reset);
    switch (rc) {
    case 0:
        /* Anything left to do? */
        if (cdev->private->pgid_todo_mask == 0) {
            verify_done(cdev, sch->vpm == 0 ? -EACCES : 0);
            return;
        }
        /* Perform path-grouping. */
        spid_start(cdev);
        break;
    case -EOPNOTSUPP:
        /* Path-grouping not supported. */
        cdev->private->flags.pgroup = 0;
        cdev->private->flags.mpath = 0;
        verify_start(cdev);
        break;
    default:
        verify_done(cdev, rc);
    }
}

/*
 * Create channel program to perform a SENSE PGID on a single path.
 */
static void snid_build_cp(struct ccw_device *cdev)
{
    struct ccw_request *req = &cdev->private->req;
    struct ccw1 *cp = cdev->private->iccws;
    int i = 8 - ffs(req->lpm);

    /* Channel program setup. */
    cp->cmd_code    = CCW_CMD_SENSE_PGID;
    cp->cda     = (u32) (addr_t) &cdev->private->pgid[i];
    cp->count   = sizeof(struct pgid);
    cp->flags   = CCW_FLAG_SLI;
    req->cp     = cp;
}

/*
 * Perform SENSE PGID on a single path.
 */
static void snid_do(struct ccw_device *cdev)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_request *req = &cdev->private->req;

    /* Adjust lpm if paths are not set in pam. */
    req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam);
    if (!req->lpm)
        goto out_nopath;
    snid_build_cp(cdev);
    ccw_request_start(cdev);
    return;

out_nopath:
    snid_done(cdev, cdev->private->pgid_valid_mask ? 0 : -EACCES);
}

/*
 * Process SENSE PGID request result for single path.
 */
static void snid_callback(struct ccw_device *cdev, void *data, int rc)
{
    struct ccw_request *req = &cdev->private->req;

    if (rc == 0)
        cdev->private->pgid_valid_mask |= req->lpm;
    else if (rc != -EACCES)
        goto err;
    req->lpm >>= 1;
    snid_do(cdev);
    return;

err:
    snid_done(cdev, rc);
}

/*
 * Perform path verification.
 */
static void verify_start(struct ccw_device *cdev)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_request *req = &cdev->private->req;
    struct ccw_dev_id *devid = &cdev->private->dev_id;

    sch->vpm = 0;
    sch->lpm = sch->schib.pmcw.pam;
    /* Initialize request data. */
    memset(req, 0, sizeof(*req));
    req->timeout    = PGID_TIMEOUT;
    req->maxretries = PGID_RETRIES;
    req->lpm    = 0x80;
    req->singlepath = 1;
    if (cdev->private->flags.pgroup) {
        CIO_TRACE_EVENT(4, "snid");
        CIO_HEX_EVENT(4, devid, sizeof(*devid));
        req->callback   = snid_callback;
        snid_do(cdev);
    } else {
        CIO_TRACE_EVENT(4, "nop");
        CIO_HEX_EVENT(4, devid, sizeof(*devid));
        req->filter = nop_filter;
        req->callback   = nop_callback;
        nop_do(cdev);
    }
}

void ccw_device_verify_start(struct ccw_device *cdev)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);

    CIO_TRACE_EVENT(4, "vrfy");
    CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
    /* Initialize PGID data. */
    memset(cdev->private->pgid, 0, sizeof(cdev->private->pgid));
    cdev->private->pgid_valid_mask = 0;
    cdev->private->pgid_todo_mask = sch->schib.pmcw.pam;
    /*
     * Initialize pathgroup and multipath state with target values.
     * They may change in the course of path verification.
     */
    cdev->private->flags.pgroup = cdev->private->options.pgroup;
    cdev->private->flags.mpath = cdev->private->options.mpath;
    cdev->private->flags.doverify = 0;
    verify_start(cdev);
}

/*
 * Process disband SET PGID request result.
 */
static void disband_callback(struct ccw_device *cdev, void *data, int rc)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_dev_id *id = &cdev->private->dev_id;

    if (rc)
        goto out;
    /* Ensure consistent multipathing state at device and channel. */
    cdev->private->flags.mpath = 0;
    if (sch->config.mp) {
        sch->config.mp = 0;
        rc = cio_commit_config(sch);
    }
out:
    CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno,
              rc);
    ccw_device_disband_done(cdev, rc);
}

void ccw_device_disband_start(struct ccw_device *cdev)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_request *req = &cdev->private->req;
    u8 fn;

    CIO_TRACE_EVENT(4, "disb");
    CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
    /* Request setup. */
    memset(req, 0, sizeof(*req));
    req->timeout    = PGID_TIMEOUT;
    req->maxretries = PGID_RETRIES;
    req->lpm    = sch->schib.pmcw.pam & sch->opm;
    req->singlepath = 1;
    req->callback   = disband_callback;
    fn = SPID_FUNC_DISBAND;
    if (cdev->private->flags.mpath)
        fn |= SPID_FUNC_MULTI_PATH;
    spid_build_cp(cdev, fn);
    ccw_request_start(cdev);
}

static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2)
{
    struct ccw_request *req = &cdev->private->req;
    struct ccw1 *cp = cdev->private->iccws;

    cp[0].cmd_code = CCW_CMD_STLCK;
    cp[0].cda = (u32) (addr_t) buf1;
    cp[0].count = 32;
    cp[0].flags = CCW_FLAG_CC;
    cp[1].cmd_code = CCW_CMD_RELEASE;
    cp[1].cda = (u32) (addr_t) buf2;
    cp[1].count = 32;
    cp[1].flags = 0;
    req->cp = cp;
}

static void stlck_callback(struct ccw_device *cdev, void *data, int rc)
{
    ccw_device_stlck_done(cdev, data, rc);
}

void ccw_device_stlck_start(struct ccw_device *cdev, void *data, void *buf1,
                void *buf2)
{
    struct subchannel *sch = to_subchannel(cdev->dev.parent);
    struct ccw_request *req = &cdev->private->req;

    CIO_TRACE_EVENT(4, "stlck");
    CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
    /* Request setup. */
    memset(req, 0, sizeof(*req));
    req->timeout    = PGID_TIMEOUT;
    req->maxretries = PGID_RETRIES;
    req->lpm    = sch->schib.pmcw.pam & sch->opm;
    req->data   = data;
    req->callback   = stlck_callback;
    stlck_build_cp(cdev, buf1, buf2);
    ccw_request_start(cdev);
}