sfc: Don't use enums as a bitmask.

[zen-stable.git] / drivers / s390 / block / dasd_alias.c

/*
 * PAV alias management for the DASD ECKD discipline
 *
 * Copyright IBM Corporation, 2007
 * Author(s): Stefan Weinhuber <wein@de.ibm.com>
 */

#define KMSG_COMPONENT "dasd-eckd"

#include <linux/list.h>
#include <linux/slab.h>
#include <asm/ebcdic.h>
#include "dasd_int.h"
#include "dasd_eckd.h"

#ifdef PRINTK_HEADER
#undef PRINTK_HEADER
#endif                          /* PRINTK_HEADER */
#define PRINTK_HEADER "dasd(eckd):"


/*
 * General concept of alias management:
 * - PAV and DASD alias management is specific to the eckd discipline.
 * - A device is connected to an lcu as long as the device exists.
 *   dasd_alias_make_device_known_to_lcu will be called wenn the
 *   device is checked by the eckd discipline and
 *   dasd_alias_disconnect_device_from_lcu will be called
 *   before the device is deleted.
 * - The dasd_alias_add_device / dasd_alias_remove_device
 *   functions mark the point when a device is 'ready for service'.
 * - A summary unit check is a rare occasion, but it is mandatory to
 *   support it. It requires some complex recovery actions before the
 *   devices can be used again (see dasd_alias_handle_summary_unit_check).
 * - dasd_alias_get_start_dev will find an alias device that can be used
 *   instead of the base device and does some (very simple) load balancing.
 *   This is the function that gets called for each I/O, so when improving
 *   something, this function should get faster or better, the rest has just
 *   to be correct.
 */


static void summary_unit_check_handling_work(struct work_struct *);
static void lcu_update_work(struct work_struct *);
static int _schedule_lcu_update(struct alias_lcu *, struct dasd_device *);

static struct alias_root aliastree = {
        .serverlist = LIST_HEAD_INIT(aliastree.serverlist),
        .lock = __SPIN_LOCK_UNLOCKED(aliastree.lock),
};

static struct alias_server *_find_server(struct dasd_uid *uid)
{
        struct alias_server *pos;
        list_for_each_entry(pos, &aliastree.serverlist, server) {
                if (!strncmp(pos->uid.vendor, uid->vendor,
                             sizeof(uid->vendor))
                    && !strncmp(pos->uid.serial, uid->serial,
                                sizeof(uid->serial)))
                        return pos;
        };
        return NULL;
}

static struct alias_lcu *_find_lcu(struct alias_server *server,
                                   struct dasd_uid *uid)
{
        struct alias_lcu *pos;
        list_for_each_entry(pos, &server->lculist, lcu) {
                if (pos->uid.ssid == uid->ssid)
                        return pos;
        };
        return NULL;
}

static struct alias_pav_group *_find_group(struct alias_lcu *lcu,
                                           struct dasd_uid *uid)
{
        struct alias_pav_group *pos;
        __u8 search_unit_addr;

        /* for hyper pav there is only one group */
        if (lcu->pav == HYPER_PAV) {
                if (list_empty(&lcu->grouplist))
                        return NULL;
                else
                        return list_first_entry(&lcu->grouplist,
                                                struct alias_pav_group, group);
        }

        /* for base pav we have to find the group that matches the base */
        if (uid->type == UA_BASE_DEVICE)
                search_unit_addr = uid->real_unit_addr;
        else
                search_unit_addr = uid->base_unit_addr;
        list_for_each_entry(pos, &lcu->grouplist, group) {
                if (pos->uid.base_unit_addr == search_unit_addr &&
                    !strncmp(pos->uid.vduit, uid->vduit, sizeof(uid->vduit)))
                        return pos;
        };
        return NULL;
}

static struct alias_server *_allocate_server(struct dasd_uid *uid)
{
        struct alias_server *server;

        server = kzalloc(sizeof(*server), GFP_KERNEL);
        if (!server)
                return ERR_PTR(-ENOMEM);
        memcpy(server->uid.vendor, uid->vendor, sizeof(uid->vendor));
        memcpy(server->uid.serial, uid->serial, sizeof(uid->serial));
        INIT_LIST_HEAD(&server->server);
        INIT_LIST_HEAD(&server->lculist);
        return server;
}

static void _free_server(struct alias_server *server)
{
        kfree(server);
}

static struct alias_lcu *_allocate_lcu(struct dasd_uid *uid)
{
        struct alias_lcu *lcu;

        lcu = kzalloc(sizeof(*lcu), GFP_KERNEL);
        if (!lcu)
                return ERR_PTR(-ENOMEM);
        lcu->uac = kzalloc(sizeof(*(lcu->uac)), GFP_KERNEL | GFP_DMA);
        if (!lcu->uac)
                goto out_err1;
        lcu->rsu_cqr = kzalloc(sizeof(*lcu->rsu_cqr), GFP_KERNEL | GFP_DMA);
        if (!lcu->rsu_cqr)
                goto out_err2;
        lcu->rsu_cqr->cpaddr = kzalloc(sizeof(struct ccw1),
                                       GFP_KERNEL | GFP_DMA);
        if (!lcu->rsu_cqr->cpaddr)
                goto out_err3;
        lcu->rsu_cqr->data = kzalloc(16, GFP_KERNEL | GFP_DMA);
        if (!lcu->rsu_cqr->data)
                goto out_err4;

        memcpy(lcu->uid.vendor, uid->vendor, sizeof(uid->vendor));
        memcpy(lcu->uid.serial, uid->serial, sizeof(uid->serial));
        lcu->uid.ssid = uid->ssid;
        lcu->pav = NO_PAV;
        lcu->flags = NEED_UAC_UPDATE | UPDATE_PENDING;
        INIT_LIST_HEAD(&lcu->lcu);
        INIT_LIST_HEAD(&lcu->inactive_devices);
        INIT_LIST_HEAD(&lcu->active_devices);
        INIT_LIST_HEAD(&lcu->grouplist);
        INIT_WORK(&lcu->suc_data.worker, summary_unit_check_handling_work);
        INIT_DELAYED_WORK(&lcu->ruac_data.dwork, lcu_update_work);
        spin_lock_init(&lcu->lock);
        init_completion(&lcu->lcu_setup);
        return lcu;

out_err4:
        kfree(lcu->rsu_cqr->cpaddr);
out_err3:
        kfree(lcu->rsu_cqr);
out_err2:
        kfree(lcu->uac);
out_err1:
        kfree(lcu);
        return ERR_PTR(-ENOMEM);
}

static void _free_lcu(struct alias_lcu *lcu)
{
        kfree(lcu->rsu_cqr->data);
        kfree(lcu->rsu_cqr->cpaddr);
        kfree(lcu->rsu_cqr);
        kfree(lcu->uac);
        kfree(lcu);
}

/*
 * This is the function that will allocate all the server and lcu data,
 * so this function must be called first for a new device.
 * If the return value is 1, the lcu was already known before, if it
 * is 0, this is a new lcu.
 * Negative return code indicates that something went wrong (e.g. -ENOMEM)
 */
int dasd_alias_make_device_known_to_lcu(struct dasd_device *device)
{
        struct dasd_eckd_private *private;
        unsigned long flags;
        struct alias_server *server, *newserver;
        struct alias_lcu *lcu, *newlcu;
        int is_lcu_known;
        struct dasd_uid uid;

        private = (struct dasd_eckd_private *) device->private;

        device->discipline->get_uid(device, &uid);
        spin_lock_irqsave(&aliastree.lock, flags);
        is_lcu_known = 1;
        server = _find_server(&uid);
        if (!server) {
                spin_unlock_irqrestore(&aliastree.lock, flags);
                newserver = _allocate_server(&uid);
                if (IS_ERR(newserver))
                        return PTR_ERR(newserver);
                spin_lock_irqsave(&aliastree.lock, flags);
                server = _find_server(&uid);
                if (!server) {
                        list_add(&newserver->server, &aliastree.serverlist);
                        server = newserver;
                        is_lcu_known = 0;
                } else {
                        /* someone was faster */
                        _free_server(newserver);
                }
        }

        lcu = _find_lcu(server, &uid);
        if (!lcu) {
                spin_unlock_irqrestore(&aliastree.lock, flags);
                newlcu = _allocate_lcu(&uid);
                if (IS_ERR(newlcu))
                        return PTR_ERR(newlcu);
                spin_lock_irqsave(&aliastree.lock, flags);
                lcu = _find_lcu(server, &uid);
                if (!lcu) {
                        list_add(&newlcu->lcu, &server->lculist);
                        lcu = newlcu;
                        is_lcu_known = 0;
                } else {
                        /* someone was faster */
                        _free_lcu(newlcu);
                }
                is_lcu_known = 0;
        }
        spin_lock(&lcu->lock);
        list_add(&device->alias_list, &lcu->inactive_devices);
        private->lcu = lcu;
        spin_unlock(&lcu->lock);
        spin_unlock_irqrestore(&aliastree.lock, flags);

        return is_lcu_known;
}

/*
 * The first device to be registered on an LCU will have to do
 * some additional setup steps to configure that LCU on the
 * storage server. All further devices should wait with their
 * initialization until the first device is done.
 * To synchronize this work, the first device will call
 * dasd_alias_lcu_setup_complete when it is done, and all
 * other devices will wait for it with dasd_alias_wait_for_lcu_setup.
 */
void dasd_alias_lcu_setup_complete(struct dasd_device *device)
{
        struct dasd_eckd_private *private;
        unsigned long flags;
        struct alias_server *server;
        struct alias_lcu *lcu;
        struct dasd_uid uid;

        private = (struct dasd_eckd_private *) device->private;
        device->discipline->get_uid(device, &uid);
        lcu = NULL;
        spin_lock_irqsave(&aliastree.lock, flags);
        server = _find_server(&uid);
        if (server)
                lcu = _find_lcu(server, &uid);
        spin_unlock_irqrestore(&aliastree.lock, flags);
        if (!lcu) {
                DBF_EVENT_DEVID(DBF_ERR, device->cdev,
                                "could not find lcu for %04x %02x",
                                uid.ssid, uid.real_unit_addr);
                WARN_ON(1);
                return;
        }
        complete_all(&lcu->lcu_setup);
}

void dasd_alias_wait_for_lcu_setup(struct dasd_device *device)
{
        struct dasd_eckd_private *private;
        unsigned long flags;
        struct alias_server *server;
        struct alias_lcu *lcu;
        struct dasd_uid uid;

        private = (struct dasd_eckd_private *) device->private;
        device->discipline->get_uid(device, &uid);
        lcu = NULL;
        spin_lock_irqsave(&aliastree.lock, flags);
        server = _find_server(&uid);
        if (server)
                lcu = _find_lcu(server, &uid);
        spin_unlock_irqrestore(&aliastree.lock, flags);
        if (!lcu) {
                DBF_EVENT_DEVID(DBF_ERR, device->cdev,
                                "could not find lcu for %04x %02x",
                                uid.ssid, uid.real_unit_addr);
                WARN_ON(1);
                return;
        }
        wait_for_completion(&lcu->lcu_setup);
}

/*
 * This function removes a device from the scope of alias management.
 * The complicated part is to make sure that it is not in use by
 * any of the workers. If necessary cancel the work.
 */
void dasd_alias_disconnect_device_from_lcu(struct dasd_device *device)
{
        struct dasd_eckd_private *private;
        unsigned long flags;
        struct alias_lcu *lcu;
        struct alias_server *server;
        int was_pending;
        struct dasd_uid uid;

        private = (struct dasd_eckd_private *) device->private;
        lcu = private->lcu;
        /* nothing to do if already disconnected */
        if (!lcu)
                return;
        device->discipline->get_uid(device, &uid);
        spin_lock_irqsave(&lcu->lock, flags);
        list_del_init(&device->alias_list);
        /* make sure that the workers don't use this device */
        if (device == lcu->suc_data.device) {
                spin_unlock_irqrestore(&lcu->lock, flags);
                cancel_work_sync(&lcu->suc_data.worker);
                spin_lock_irqsave(&lcu->lock, flags);
                if (device == lcu->suc_data.device)
                        lcu->suc_data.device = NULL;
        }
        was_pending = 0;
        if (device == lcu->ruac_data.device) {
                spin_unlock_irqrestore(&lcu->lock, flags);
                was_pending = 1;
                cancel_delayed_work_sync(&lcu->ruac_data.dwork);
                spin_lock_irqsave(&lcu->lock, flags);
                if (device == lcu->ruac_data.device)
                        lcu->ruac_data.device = NULL;
        }
        private->lcu = NULL;
        spin_unlock_irqrestore(&lcu->lock, flags);

        spin_lock_irqsave(&aliastree.lock, flags);
        spin_lock(&lcu->lock);
        if (list_empty(&lcu->grouplist) &&
            list_empty(&lcu->active_devices) &&
            list_empty(&lcu->inactive_devices)) {
                list_del(&lcu->lcu);
                spin_unlock(&lcu->lock);
                _free_lcu(lcu);
                lcu = NULL;
        } else {
                if (was_pending)
                        _schedule_lcu_update(lcu, NULL);
                spin_unlock(&lcu->lock);
        }
        server = _find_server(&uid);
        if (server && list_empty(&server->lculist)) {
                list_del(&server->server);
                _free_server(server);
        }
        spin_unlock_irqrestore(&aliastree.lock, flags);
}

/*
 * This function assumes that the unit address configuration stored
 * in the lcu is up to date and will update the device uid before
 * adding it to a pav group.
 */

static int _add_device_to_lcu(struct alias_lcu *lcu,
                              struct dasd_device *device,
                              struct dasd_device *pos)
{

        struct dasd_eckd_private *private;
        struct alias_pav_group *group;
        struct dasd_uid uid;
        unsigned long flags;

        private = (struct dasd_eckd_private *) device->private;

        /* only lock if not already locked */
        if (device != pos)
                spin_lock_irqsave_nested(get_ccwdev_lock(device->cdev), flags,
                                         CDEV_NESTED_SECOND);
        private->uid.type = lcu->uac->unit[private->uid.real_unit_addr].ua_type;
        private->uid.base_unit_addr =
                lcu->uac->unit[private->uid.real_unit_addr].base_ua;
        uid = private->uid;

        if (device != pos)
                spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);

        /* if we have no PAV anyway, we don't need to bother with PAV groups */
        if (lcu->pav == NO_PAV) {
                list_move(&device->alias_list, &lcu->active_devices);
                return 0;
        }

        group = _find_group(lcu, &uid);
        if (!group) {
                group = kzalloc(sizeof(*group), GFP_ATOMIC);
                if (!group)
                        return -ENOMEM;
                memcpy(group->uid.vendor, uid.vendor, sizeof(uid.vendor));
                memcpy(group->uid.serial, uid.serial, sizeof(uid.serial));
                group->uid.ssid = uid.ssid;
                if (uid.type == UA_BASE_DEVICE)
                        group->uid.base_unit_addr = uid.real_unit_addr;
                else
                        group->uid.base_unit_addr = uid.base_unit_addr;
                memcpy(group->uid.vduit, uid.vduit, sizeof(uid.vduit));
                INIT_LIST_HEAD(&group->group);
                INIT_LIST_HEAD(&group->baselist);
                INIT_LIST_HEAD(&group->aliaslist);
                list_add(&group->group, &lcu->grouplist);
        }
        if (uid.type == UA_BASE_DEVICE)
                list_move(&device->alias_list, &group->baselist);
        else
                list_move(&device->alias_list, &group->aliaslist);
        private->pavgroup = group;
        return 0;
};

static void _remove_device_from_lcu(struct alias_lcu *lcu,
                                    struct dasd_device *device)
{
        struct dasd_eckd_private *private;
        struct alias_pav_group *group;

        private = (struct dasd_eckd_private *) device->private;
        list_move(&device->alias_list, &lcu->inactive_devices);
        group = private->pavgroup;
        if (!group)
                return;
        private->pavgroup = NULL;
        if (list_empty(&group->baselist) && list_empty(&group->aliaslist)) {
                list_del(&group->group);
                kfree(group);
                return;
        }
        if (group->next == device)
                group->next = NULL;
};

static int read_unit_address_configuration(struct dasd_device *device,
                                           struct alias_lcu *lcu)
{
        struct dasd_psf_prssd_data *prssdp;
        struct dasd_ccw_req *cqr;
        struct ccw1 *ccw;
        int rc;
        unsigned long flags;

        cqr = dasd_kmalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */,
                                   (sizeof(struct dasd_psf_prssd_data)),
                                   device);
        if (IS_ERR(cqr))
                return PTR_ERR(cqr);
        cqr->startdev = device;
        cqr->memdev = device;
        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
        cqr->retries = 10;
        cqr->expires = 20 * HZ;

        /* Prepare for Read Subsystem Data */
        prssdp = (struct dasd_psf_prssd_data *) cqr->data;
        memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
        prssdp->order = PSF_ORDER_PRSSD;
        prssdp->suborder = 0x0e;        /* Read unit address configuration */
        /* all other bytes of prssdp must be zero */

        ccw = cqr->cpaddr;
        ccw->cmd_code = DASD_ECKD_CCW_PSF;
        ccw->count = sizeof(struct dasd_psf_prssd_data);
        ccw->flags |= CCW_FLAG_CC;
        ccw->cda = (__u32)(addr_t) prssdp;

        /* Read Subsystem Data - feature codes */
        memset(lcu->uac, 0, sizeof(*(lcu->uac)));

        ccw++;
        ccw->cmd_code = DASD_ECKD_CCW_RSSD;
        ccw->count = sizeof(*(lcu->uac));
        ccw->cda = (__u32)(addr_t) lcu->uac;

        cqr->buildclk = get_clock();
        cqr->status = DASD_CQR_FILLED;

        /* need to unset flag here to detect race with summary unit check */
        spin_lock_irqsave(&lcu->lock, flags);
        lcu->flags &= ~NEED_UAC_UPDATE;
        spin_unlock_irqrestore(&lcu->lock, flags);

        do {
                rc = dasd_sleep_on(cqr);
        } while (rc && (cqr->retries > 0));
        if (rc) {
                spin_lock_irqsave(&lcu->lock, flags);
                lcu->flags |= NEED_UAC_UPDATE;
                spin_unlock_irqrestore(&lcu->lock, flags);
        }
        dasd_kfree_request(cqr, cqr->memdev);
        return rc;
}

static int _lcu_update(struct dasd_device *refdev, struct alias_lcu *lcu)
{
        unsigned long flags;
        struct alias_pav_group *pavgroup, *tempgroup;
        struct dasd_device *device, *tempdev;
        int i, rc;
        struct dasd_eckd_private *private;

        spin_lock_irqsave(&lcu->lock, flags);
        list_for_each_entry_safe(pavgroup, tempgroup, &lcu->grouplist, group) {
                list_for_each_entry_safe(device, tempdev, &pavgroup->baselist,
                                         alias_list) {
                        list_move(&device->alias_list, &lcu->active_devices);
                        private = (struct dasd_eckd_private *) device->private;
                        private->pavgroup = NULL;
                }
                list_for_each_entry_safe(device, tempdev, &pavgroup->aliaslist,
                                         alias_list) {
                        list_move(&device->alias_list, &lcu->active_devices);
                        private = (struct dasd_eckd_private *) device->private;
                        private->pavgroup = NULL;
                }
                list_del(&pavgroup->group);
                kfree(pavgroup);
        }
        spin_unlock_irqrestore(&lcu->lock, flags);

        rc = read_unit_address_configuration(refdev, lcu);
        if (rc)
                return rc;

        /* need to take cdev lock before lcu lock */
        spin_lock_irqsave_nested(get_ccwdev_lock(refdev->cdev), flags,
                                 CDEV_NESTED_FIRST);
        spin_lock(&lcu->lock);
        lcu->pav = NO_PAV;
        for (i = 0; i < MAX_DEVICES_PER_LCU; ++i) {
                switch (lcu->uac->unit[i].ua_type) {
                case UA_BASE_PAV_ALIAS:
                        lcu->pav = BASE_PAV;
                        break;
                case UA_HYPER_PAV_ALIAS:
                        lcu->pav = HYPER_PAV;
                        break;
                }
                if (lcu->pav != NO_PAV)
                        break;
        }

        list_for_each_entry_safe(device, tempdev, &lcu->active_devices,
                                 alias_list) {
                _add_device_to_lcu(lcu, device, refdev);
        }
        spin_unlock(&lcu->lock);
        spin_unlock_irqrestore(get_ccwdev_lock(refdev->cdev), flags);
        return 0;
}

static void lcu_update_work(struct work_struct *work)
{
        struct alias_lcu *lcu;
        struct read_uac_work_data *ruac_data;
        struct dasd_device *device;
        unsigned long flags;
        int rc;

        ruac_data = container_of(work, struct read_uac_work_data, dwork.work);
        lcu = container_of(ruac_data, struct alias_lcu, ruac_data);
        device = ruac_data->device;
        rc = _lcu_update(device, lcu);
        /*
         * Need to check flags again, as there could have been another
         * prepare_update or a new device a new device while we were still
         * processing the data
         */
        spin_lock_irqsave(&lcu->lock, flags);
        if (rc || (lcu->flags & NEED_UAC_UPDATE)) {
                DBF_DEV_EVENT(DBF_WARNING, device, "could not update"
                            " alias data in lcu (rc = %d), retry later", rc);
                schedule_delayed_work(&lcu->ruac_data.dwork, 30*HZ);
        } else {
                lcu->ruac_data.device = NULL;
                lcu->flags &= ~UPDATE_PENDING;
        }
        spin_unlock_irqrestore(&lcu->lock, flags);
}

static int _schedule_lcu_update(struct alias_lcu *lcu,
                                struct dasd_device *device)
{
        struct dasd_device *usedev = NULL;
        struct alias_pav_group *group;

        lcu->flags |= NEED_UAC_UPDATE;
        if (lcu->ruac_data.device) {
                /* already scheduled or running */
                return 0;
        }
        if (device && !list_empty(&device->alias_list))
                usedev = device;

        if (!usedev && !list_empty(&lcu->grouplist)) {
                group = list_first_entry(&lcu->grouplist,
                                         struct alias_pav_group, group);
                if (!list_empty(&group->baselist))
                        usedev = list_first_entry(&group->baselist,
                                                  struct dasd_device,
                                                  alias_list);
                else if (!list_empty(&group->aliaslist))
                        usedev = list_first_entry(&group->aliaslist,
                                                  struct dasd_device,
                                                  alias_list);
        }
        if (!usedev && !list_empty(&lcu->active_devices)) {
                usedev = list_first_entry(&lcu->active_devices,
                                          struct dasd_device, alias_list);
        }
        /*
         * if we haven't found a proper device yet, give up for now, the next
         * device that will be set active will trigger an lcu update
         */
        if (!usedev)
                return -EINVAL;
        lcu->ruac_data.device = usedev;
        schedule_delayed_work(&lcu->ruac_data.dwork, 0);
        return 0;
}

int dasd_alias_add_device(struct dasd_device *device)
{
        struct dasd_eckd_private *private;
        struct alias_lcu *lcu;
        unsigned long flags;
        int rc;

        private = (struct dasd_eckd_private *) device->private;
        lcu = private->lcu;
        rc = 0;

        /* need to take cdev lock before lcu lock */
        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
        spin_lock(&lcu->lock);
        if (!(lcu->flags & UPDATE_PENDING)) {
                rc = _add_device_to_lcu(lcu, device, device);
                if (rc)
                        lcu->flags |= UPDATE_PENDING;
        }
        if (lcu->flags & UPDATE_PENDING) {
                list_move(&device->alias_list, &lcu->active_devices);
                _schedule_lcu_update(lcu, device);
        }
        spin_unlock(&lcu->lock);
        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
        return rc;
}

int dasd_alias_update_add_device(struct dasd_device *device)
{
        struct dasd_eckd_private *private;
        private = (struct dasd_eckd_private *) device->private;
        private->lcu->flags |= UPDATE_PENDING;
        return dasd_alias_add_device(device);
}

int dasd_alias_remove_device(struct dasd_device *device)
{
        struct dasd_eckd_private *private;
        struct alias_lcu *lcu;
        unsigned long flags;

        private = (struct dasd_eckd_private *) device->private;
        lcu = private->lcu;
        /* nothing to do if already removed */
        if (!lcu)
                return 0;
        spin_lock_irqsave(&lcu->lock, flags);
        _remove_device_from_lcu(lcu, device);
        spin_unlock_irqrestore(&lcu->lock, flags);
        return 0;
}

struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *base_device)
{

        struct dasd_device *alias_device;
        struct alias_pav_group *group;
        struct alias_lcu *lcu;
        struct dasd_eckd_private *private, *alias_priv;
        unsigned long flags;

        private = (struct dasd_eckd_private *) base_device->private;
        group = private->pavgroup;
        lcu = private->lcu;
        if (!group || !lcu)
                return NULL;
        if (lcu->pav == NO_PAV ||
            lcu->flags & (NEED_UAC_UPDATE | UPDATE_PENDING))
                return NULL;

        spin_lock_irqsave(&lcu->lock, flags);
        alias_device = group->next;
        if (!alias_device) {
                if (list_empty(&group->aliaslist)) {
                        spin_unlock_irqrestore(&lcu->lock, flags);
                        return NULL;
                } else {
                        alias_device = list_first_entry(&group->aliaslist,
                                                        struct dasd_device,
                                                        alias_list);
                }
        }
        if (list_is_last(&alias_device->alias_list, &group->aliaslist))
                group->next = list_first_entry(&group->aliaslist,
                                               struct dasd_device, alias_list);
        else
                group->next = list_first_entry(&alias_device->alias_list,
                                               struct dasd_device, alias_list);
        spin_unlock_irqrestore(&lcu->lock, flags);
        alias_priv = (struct dasd_eckd_private *) alias_device->private;
        if ((alias_priv->count < private->count) && !alias_device->stopped)
                return alias_device;
        else
                return NULL;
}

/*
 * Summary unit check handling depends on the way alias devices
 * are handled so it is done here rather then in dasd_eckd.c
 */
static int reset_summary_unit_check(struct alias_lcu *lcu,
                                    struct dasd_device *device,
                                    char reason)
{
        struct dasd_ccw_req *cqr;
        int rc = 0;
        struct ccw1 *ccw;

        cqr = lcu->rsu_cqr;
        strncpy((char *) &cqr->magic, "ECKD", 4);
        ASCEBC((char *) &cqr->magic, 4);
        ccw = cqr->cpaddr;
        ccw->cmd_code = DASD_ECKD_CCW_RSCK;
        ccw->flags = 0 ;
        ccw->count = 16;
        ccw->cda = (__u32)(addr_t) cqr->data;
        ((char *)cqr->data)[0] = reason;

        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
        cqr->retries = 255;     /* set retry counter to enable basic ERP */
        cqr->startdev = device;
        cqr->memdev = device;
        cqr->block = NULL;
        cqr->expires = 5 * HZ;
        cqr->buildclk = get_clock();
        cqr->status = DASD_CQR_FILLED;

        rc = dasd_sleep_on_immediatly(cqr);
        return rc;
}

static void _restart_all_base_devices_on_lcu(struct alias_lcu *lcu)
{
        struct alias_pav_group *pavgroup;
        struct dasd_device *device;
        struct dasd_eckd_private *private;
        unsigned long flags;

        /* active and inactive list can contain alias as well as base devices */
        list_for_each_entry(device, &lcu->active_devices, alias_list) {
                private = (struct dasd_eckd_private *) device->private;
                spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
                if (private->uid.type != UA_BASE_DEVICE) {
                        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
                                               flags);
                        continue;
                }
                spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
                dasd_schedule_block_bh(device->block);
                dasd_schedule_device_bh(device);
        }
        list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
                private = (struct dasd_eckd_private *) device->private;
                spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
                if (private->uid.type != UA_BASE_DEVICE) {
                        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
                                               flags);
                        continue;
                }
                spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
                dasd_schedule_block_bh(device->block);
                dasd_schedule_device_bh(device);
        }
        list_for_each_entry(pavgroup, &lcu->grouplist, group) {
                list_for_each_entry(device, &pavgroup->baselist, alias_list) {
                        dasd_schedule_block_bh(device->block);
                        dasd_schedule_device_bh(device);
                }
        }
}

static void flush_all_alias_devices_on_lcu(struct alias_lcu *lcu)
{
        struct alias_pav_group *pavgroup;
        struct dasd_device *device, *temp;
        struct dasd_eckd_private *private;
        int rc;
        unsigned long flags;
        LIST_HEAD(active);

        /*
         * Problem here ist that dasd_flush_device_queue may wait
         * for termination of a request to complete. We can't keep
         * the lcu lock during that time, so we must assume that
         * the lists may have changed.
         * Idea: first gather all active alias devices in a separate list,
         * then flush the first element of this list unlocked, and afterwards
         * check if it is still on the list before moving it to the
         * active_devices list.
         */

        spin_lock_irqsave(&lcu->lock, flags);
        list_for_each_entry_safe(device, temp, &lcu->active_devices,
                                 alias_list) {
                private = (struct dasd_eckd_private *) device->private;
                if (private->uid.type == UA_BASE_DEVICE)
                        continue;
                list_move(&device->alias_list, &active);
        }

        list_for_each_entry(pavgroup, &lcu->grouplist, group) {
                list_splice_init(&pavgroup->aliaslist, &active);
        }
        while (!list_empty(&active)) {
                device = list_first_entry(&active, struct dasd_device,
                                          alias_list);
                spin_unlock_irqrestore(&lcu->lock, flags);
                rc = dasd_flush_device_queue(device);
                spin_lock_irqsave(&lcu->lock, flags);
                /*
                 * only move device around if it wasn't moved away while we
                 * were waiting for the flush
                 */
                if (device == list_first_entry(&active,
                                               struct dasd_device, alias_list))
                        list_move(&device->alias_list, &lcu->active_devices);
        }
        spin_unlock_irqrestore(&lcu->lock, flags);
}

static void __stop_device_on_lcu(struct dasd_device *device,
                                 struct dasd_device *pos)
{
        /* If pos == device then device is already locked! */
        if (pos == device) {
                dasd_device_set_stop_bits(pos, DASD_STOPPED_SU);
                return;
        }
        spin_lock(get_ccwdev_lock(pos->cdev));
        dasd_device_set_stop_bits(pos, DASD_STOPPED_SU);
        spin_unlock(get_ccwdev_lock(pos->cdev));
}

/*
 * This function is called in interrupt context, so the
 * cdev lock for device is already locked!
 */
static void _stop_all_devices_on_lcu(struct alias_lcu *lcu,
                                     struct dasd_device *device)
{
        struct alias_pav_group *pavgroup;
        struct dasd_device *pos;

        list_for_each_entry(pos, &lcu->active_devices, alias_list)
                __stop_device_on_lcu(device, pos);
        list_for_each_entry(pos, &lcu->inactive_devices, alias_list)
                __stop_device_on_lcu(device, pos);
        list_for_each_entry(pavgroup, &lcu->grouplist, group) {
                list_for_each_entry(pos, &pavgroup->baselist, alias_list)
                        __stop_device_on_lcu(device, pos);
                list_for_each_entry(pos, &pavgroup->aliaslist, alias_list)
                        __stop_device_on_lcu(device, pos);
        }
}

static void _unstop_all_devices_on_lcu(struct alias_lcu *lcu)
{
        struct alias_pav_group *pavgroup;
        struct dasd_device *device;
        unsigned long flags;

        list_for_each_entry(device, &lcu->active_devices, alias_list) {
                spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
                dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
                spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
        }

        list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
                spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
                dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
                spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
        }

        list_for_each_entry(pavgroup, &lcu->grouplist, group) {
                list_for_each_entry(device, &pavgroup->baselist, alias_list) {
                        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
                        dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
                        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
                                               flags);
                }
                list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
                        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
                        dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
                        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
                                               flags);
                }
        }
}

static void summary_unit_check_handling_work(struct work_struct *work)
{
        struct alias_lcu *lcu;
        struct summary_unit_check_work_data *suc_data;
        unsigned long flags;
        struct dasd_device *device;

        suc_data = container_of(work, struct summary_unit_check_work_data,
                                worker);
        lcu = container_of(suc_data, struct alias_lcu, suc_data);
        device = suc_data->device;

        /* 1. flush alias devices */
        flush_all_alias_devices_on_lcu(lcu);

        /* 2. reset summary unit check */
        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
        dasd_device_remove_stop_bits(device,
                                     (DASD_STOPPED_SU | DASD_STOPPED_PENDING));
        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
        reset_summary_unit_check(lcu, device, suc_data->reason);

        spin_lock_irqsave(&lcu->lock, flags);
        _unstop_all_devices_on_lcu(lcu);
        _restart_all_base_devices_on_lcu(lcu);
        /* 3. read new alias configuration */
        _schedule_lcu_update(lcu, device);
        lcu->suc_data.device = NULL;
        spin_unlock_irqrestore(&lcu->lock, flags);
}

/*
 * note: this will be called from int handler context (cdev locked)
 */
void dasd_alias_handle_summary_unit_check(struct dasd_device *device,
                                          struct irb *irb)
{
        struct alias_lcu *lcu;
        char reason;
        struct dasd_eckd_private *private;
        char *sense;

        private = (struct dasd_eckd_private *) device->private;

        sense = dasd_get_sense(irb);
        if (sense) {
                reason = sense[8];
                DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x",
                            "eckd handle summary unit check: reason", reason);
        } else {
                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                            "eckd handle summary unit check:"
                            " no reason code available");
                return;
        }

        lcu = private->lcu;
        if (!lcu) {
                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                            "device not ready to handle summary"
                            " unit check (no lcu structure)");
                return;
        }
        spin_lock(&lcu->lock);
        _stop_all_devices_on_lcu(lcu, device);
        /* prepare for lcu_update */
        private->lcu->flags |= NEED_UAC_UPDATE | UPDATE_PENDING;
        /* If this device is about to be removed just return and wait for
         * the next interrupt on a different device
         */
        if (list_empty(&device->alias_list)) {
                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                            "device is in offline processing,"
                            " don't do summary unit check handling");
                spin_unlock(&lcu->lock);
                return;
        }
        if (lcu->suc_data.device) {
                /* already scheduled or running */
                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                            "previous instance of summary unit check worker"
                            " still pending");
                spin_unlock(&lcu->lock);
                return ;
        }
        lcu->suc_data.reason = reason;
        lcu->suc_data.device = device;
        spin_unlock(&lcu->lock);
        schedule_work(&lcu->suc_data.worker);
};