[S390] cio: split PGID settings and status
authorPeter Oberparleiter <peter.oberparleiter@de.ibm.com>
Mon, 7 Dec 2009 11:51:30 +0000 (12:51 +0100)
committerMartin Schwidefsky <sky@mschwide.boeblingen.de.ibm.com>
Mon, 7 Dec 2009 11:51:31 +0000 (12:51 +0100)
Split setting (driver wants feature enabled) and status (feature
setup was successful) for PGID related ccw device features so that
setup errors can be detected. Previously, incorrectly handled setup
errors could in rare cases lead to erratic I/O behavior and
permanently unusuable devices.

Signed-off-by: Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
arch/s390/include/asm/ccwdev.h
drivers/s390/block/dasd.c
drivers/s390/block/dasd_eckd.c
drivers/s390/char/tape_core.c
drivers/s390/cio/device_fsm.c
drivers/s390/cio/device_ops.c
drivers/s390/cio/device_pgid.c
drivers/s390/cio/io_sch.h

index 2a541955117688b23de8b40557dfd944d1dce02c..f4bd346a52d3567e6a7b33885308b28e787cac2f 100644 (file)
@@ -142,6 +142,8 @@ struct ccw1;
 extern int ccw_device_set_options_mask(struct ccw_device *, unsigned long);
 extern int ccw_device_set_options(struct ccw_device *, unsigned long);
 extern void ccw_device_clear_options(struct ccw_device *, unsigned long);
+int ccw_device_is_pathgroup(struct ccw_device *cdev);
+int ccw_device_is_multipath(struct ccw_device *cdev);
 
 /* Allow for i/o completion notification after primary interrupt status. */
 #define CCWDEV_EARLY_NOTIFICATION      0x0001
@@ -151,6 +153,8 @@ extern void ccw_device_clear_options(struct ccw_device *, unsigned long);
 #define CCWDEV_DO_PATHGROUP             0x0004
 /* Allow forced onlining of boxed devices. */
 #define CCWDEV_ALLOW_FORCE              0x0008
+/* Try to use multipath mode. */
+#define CCWDEV_DO_MULTIPATH            0x0010
 
 extern int ccw_device_start(struct ccw_device *, struct ccw1 *,
                            unsigned long, __u8, unsigned long);
index aaccc8ecfa8f1bebc953d5e06fdde31094dc96fd..58ffbd1d04a16193b82e670223c61499ae941a8f 100644 (file)
@@ -2208,13 +2208,6 @@ int dasd_generic_probe(struct ccw_device *cdev,
 {
        int ret;
 
-       ret = ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP);
-       if (ret) {
-               DBF_EVENT(DBF_WARNING,
-                      "dasd_generic_probe: could not set ccw-device options "
-                      "for %s\n", dev_name(&cdev->dev));
-               return ret;
-       }
        ret = dasd_add_sysfs_files(cdev);
        if (ret) {
                DBF_EVENT(DBF_WARNING,
index 417b97cd3f9495cee6ba74116dcfaa0bb836d9f2..a8ec0731609ed0288488e3dd984626f7e790f4dc 100644 (file)
@@ -86,7 +86,8 @@ dasd_eckd_probe (struct ccw_device *cdev)
        int ret;
 
        /* set ECKD specific ccw-device options */
-       ret = ccw_device_set_options(cdev, CCWDEV_ALLOW_FORCE);
+       ret = ccw_device_set_options(cdev, CCWDEV_ALLOW_FORCE |
+                                    CCWDEV_DO_PATHGROUP | CCWDEV_DO_MULTIPATH);
        if (ret) {
                DBF_EVENT(DBF_WARNING,
                       "dasd_eckd_probe: could not set ccw-device options "
@@ -1090,6 +1091,15 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
        struct dasd_block *block;
        int is_known, rc;
 
+       if (!ccw_device_is_pathgroup(device->cdev)) {
+               dev_warn(&device->cdev->dev,
+                        "A channel path group could not be established\n");
+               return -EIO;
+       }
+       if (!ccw_device_is_multipath(device->cdev)) {
+               dev_info(&device->cdev->dev,
+                        "The DASD is not operating in multipath mode\n");
+       }
        private = (struct dasd_eckd_private *) device->private;
        if (!private) {
                private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA);
index 5cd31e0716473940fc426262884d293d5eb00d93..27503a778fcbd19f25c7e0e8380f1b613e7f97f7 100644 (file)
@@ -579,7 +579,8 @@ tape_generic_probe(struct ccw_device *cdev)
        device = tape_alloc_device();
        if (IS_ERR(device))
                return -ENODEV;
-       ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP);
+       ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP |
+                                    CCWDEV_DO_MULTIPATH);
        ret = sysfs_create_group(&cdev->dev.kobj, &tape_attr_group);
        if (ret) {
                tape_put_device(device);
index 349d8c52c0d0e3a89131c0ef1a5987fba8f00a2e..d6e315dc0f9856aa7ad15e36a91cb83110459669 100644 (file)
@@ -601,7 +601,7 @@ ccw_device_offline(struct ccw_device *cdev)
        if (cdev->private->state != DEV_STATE_ONLINE)
                return -EINVAL;
        /* Are we doing path grouping? */
-       if (!cdev->private->options.pgroup) {
+       if (!cdev->private->flags.pgroup) {
                /* No, set state offline immediately. */
                ccw_device_done(cdev, DEV_STATE_OFFLINE);
                return 0;
index 5ab90ec4231884f712d14fd042c95b92944b4d3e..d4be16acebe483edb33b6b020882394107e3ba9a 100644 (file)
@@ -46,6 +46,7 @@ int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
        cdev->private->options.repall = (flags & CCWDEV_REPORT_ALL) != 0;
        cdev->private->options.pgroup = (flags & CCWDEV_DO_PATHGROUP) != 0;
        cdev->private->options.force = (flags & CCWDEV_ALLOW_FORCE) != 0;
+       cdev->private->options.mpath = (flags & CCWDEV_DO_MULTIPATH) != 0;
        return 0;
 }
 
@@ -74,6 +75,7 @@ int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
        cdev->private->options.repall |= (flags & CCWDEV_REPORT_ALL) != 0;
        cdev->private->options.pgroup |= (flags & CCWDEV_DO_PATHGROUP) != 0;
        cdev->private->options.force |= (flags & CCWDEV_ALLOW_FORCE) != 0;
+       cdev->private->options.mpath |= (flags & CCWDEV_DO_MULTIPATH) != 0;
        return 0;
 }
 
@@ -90,8 +92,33 @@ void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
        cdev->private->options.repall &= (flags & CCWDEV_REPORT_ALL) == 0;
        cdev->private->options.pgroup &= (flags & CCWDEV_DO_PATHGROUP) == 0;
        cdev->private->options.force &= (flags & CCWDEV_ALLOW_FORCE) == 0;
+       cdev->private->options.mpath &= (flags & CCWDEV_DO_MULTIPATH) == 0;
 }
 
+/**
+ * ccw_device_is_pathgroup - determine if paths to this device are grouped
+ * @cdev: ccw device
+ *
+ * Return non-zero if there is a path group, zero otherwise.
+ */
+int ccw_device_is_pathgroup(struct ccw_device *cdev)
+{
+       return cdev->private->flags.pgroup;
+}
+EXPORT_SYMBOL(ccw_device_is_pathgroup);
+
+/**
+ * ccw_device_is_multipath - determine if device is operating in multipath mode
+ * @cdev: ccw device
+ *
+ * Return non-zero if device is operating in multipath mode, zero otherwise.
+ */
+int ccw_device_is_multipath(struct ccw_device *cdev)
+{
+       return cdev->private->flags.mpath;
+}
+EXPORT_SYMBOL(ccw_device_is_multipath);
+
 /**
  * ccw_device_clear() - terminate I/O request processing
  * @cdev: target ccw device
index ce493144b054a758782229f672c2609b06a40e06..3323042ba755427e162a0dc3f0f078a570f6e187 100644 (file)
@@ -30,8 +30,8 @@ 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.pgid_single;
-       int pgroup = cdev->private->options.pgroup;
+       int mpath = cdev->private->flags.mpath;
+       int pgroup = cdev->private->flags.pgroup;
 
        if (rc)
                goto out;
@@ -150,7 +150,7 @@ static void spid_do(struct ccw_device *cdev)
                fn = SPID_FUNC_ESTABLISH;
        else
                fn = SPID_FUNC_RESIGN;
-       if (!cdev->private->flags.pgid_single)
+       if (cdev->private->flags.mpath)
                fn |= SPID_FUNC_MULTI_PATH;
        spid_build_cp(cdev, fn);
        ccw_request_start(cdev);
@@ -177,13 +177,13 @@ static void spid_callback(struct ccw_device *cdev, void *data, int rc)
        case -EACCES:
                break;
        case -EOPNOTSUPP:
-               if (!cdev->private->flags.pgid_single) {
+               if (cdev->private->flags.mpath) {
                        /* Try without multipathing. */
-                       cdev->private->flags.pgid_single = 1;
+                       cdev->private->flags.mpath = 0;
                        goto out_restart;
                }
                /* Try without pathgrouping. */
-               cdev->private->options.pgroup = 0;
+               cdev->private->flags.pgroup = 0;
                goto out_restart;
        default:
                goto err;
@@ -374,7 +374,7 @@ static void verify_start(struct ccw_device *cdev)
        req->timeout    = PGID_TIMEOUT;
        req->maxretries = PGID_RETRIES;
        req->lpm        = 0x80;
-       if (cdev->private->options.pgroup) {
+       if (cdev->private->flags.pgroup) {
                req->callback   = spid_callback;
                spid_do(cdev);
        } else {
@@ -400,10 +400,17 @@ void ccw_device_verify_start(struct ccw_device *cdev)
        CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
        if (!cdev->private->flags.pgid_rdy) {
                /* No pathgrouping possible. */
-               cdev->private->options.pgroup = 0;
-               cdev->private->flags.pgid_single = 1;
-       } else
-               cdev->private->flags.pgid_single = 0;
+               cdev->private->flags.pgroup = 0;
+               cdev->private->flags.mpath = 0;
+       } else {
+               /*
+                * 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);
 }
@@ -419,7 +426,7 @@ static void disband_callback(struct ccw_device *cdev, void *data, int rc)
        if (rc)
                goto out;
        /* Ensure consistent multipathing state at device and channel. */
-       cdev->private->flags.pgid_single = 1;
+       cdev->private->flags.mpath = 0;
        if (sch->config.mp) {
                sch->config.mp = 0;
                rc = cio_commit_config(sch);
@@ -453,7 +460,7 @@ void ccw_device_disband_start(struct ccw_device *cdev)
        req->lpm        = sch->schib.pmcw.pam & sch->opm;
        req->callback   = disband_callback;
        fn = SPID_FUNC_DISBAND;
-       if (!cdev->private->flags.pgid_single)
+       if (cdev->private->flags.mpath)
                fn |= SPID_FUNC_MULTI_PATH;
        spid_build_cp(cdev, fn);
        ccw_request_start(cdev);
index 8942dc092d0a5be53a6b5368144da30776dd4140..b387c80d1888ad6313aaed2a917afc2c71e1fe4c 100644 (file)
@@ -156,9 +156,9 @@ struct ccw_device_private {
                unsigned int repall:1;  /* report every interrupt status */
                unsigned int pgroup:1;  /* do path grouping */
                unsigned int force:1;   /* allow forced online */
+               unsigned int mpath:1;   /* do multipathing */
        } __attribute__ ((packed)) options;
        struct {
-               unsigned int pgid_single:1; /* use single path for Set PGID */
                unsigned int esid:1;        /* Ext. SenseID supported by HW */
                unsigned int dosense:1;     /* delayed SENSE required */
                unsigned int doverify:1;    /* delayed path verification */
@@ -167,6 +167,8 @@ struct ccw_device_private {
                unsigned int fake_irb:1;    /* deliver faked irb */
                unsigned int resuming:1;    /* recognition while resume */
                unsigned int pgid_rdy:1;    /* pgids are ready */
+               unsigned int pgroup:1;      /* pathgroup is set up */
+               unsigned int mpath:1;       /* multipathing is set up */
        } __attribute__((packed)) flags;
        unsigned long intparm;  /* user interruption parameter */
        struct qdio_irq *qdio_data;