drivers/s390/cio/device_pgid.c

   1 /*
   2  *  CCW device PGID and path verification I/O handling.
   3  *
   4  *    Copyright IBM Corp. 2002,2009
   5  *    Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
   6  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
   7  *               Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/string.h>
  12 #include <linux/types.h>
  13 #include <linux/errno.h>
  14 #include <linux/bitops.h>
  15 #include <asm/ccwdev.h>
  16 #include <asm/cio.h>
  17
  18 #include "cio.h"
  19 #include "cio_debug.h"
  20 #include "device.h"
  21 #include "io_sch.h"
  22
  23 #define PGID_RETRIES    256
  24 #define PGID_TIMEOUT    (10 * HZ)
  25
  26 /*
  27  * Process path verification data and report result.
  28  */
  29 static void verify_done(struct ccw_device *cdev, int rc)
  30 {
  31         struct subchannel *sch = to_subchannel(cdev->dev.parent);
  32         struct ccw_dev_id *id = &cdev->private->dev_id;
  33         int mpath = cdev->private->flags.mpath;
  34         int pgroup = cdev->private->flags.pgroup;
  35
  36         if (rc)
  37                 goto out;
  38         /* Ensure consistent multipathing state at device and channel. */
  39         if (sch->config.mp != mpath) {
  40                 sch->config.mp = mpath;
  41                 rc = cio_commit_config(sch);
  42         }
  43 out:
  44         CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d "
  45                          "vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath,
  46                          sch->vpm);
  47         ccw_device_verify_done(cdev, rc);
  48 }
  49
  50 /*
  51  * Create channel program to perform a NOOP.
  52  */
  53 static void nop_build_cp(struct ccw_device *cdev)
  54 {
  55         struct ccw_request *req = &cdev->private->req;
  56         struct ccw1 *cp = cdev->private->iccws;
  57
  58         cp->cmd_code    = CCW_CMD_NOOP;
  59         cp->cda         = 0;
  60         cp->count       = 0;
  61         cp->flags       = CCW_FLAG_SLI;
  62         req->cp         = cp;
  63 }
  64
  65 /*
  66  * Perform NOOP on a single path.
  67  */
  68 static void nop_do(struct ccw_device *cdev)
  69 {
  70         struct subchannel *sch = to_subchannel(cdev->dev.parent);
  71         struct ccw_request *req = &cdev->private->req;
  72
  73         /* Adjust lpm. */
  74         req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm);
  75         if (!req->lpm)
  76                 goto out_nopath;
  77         nop_build_cp(cdev);
  78         ccw_request_start(cdev);
  79         return;
  80
  81 out_nopath:
  82         verify_done(cdev, sch->vpm ? 0 : -EACCES);
  83 }
  84
  85 /*
  86  * Adjust NOOP I/O status.
  87  */
  88 static enum io_status nop_filter(struct ccw_device *cdev, void *data,
  89                                  struct irb *irb, enum io_status status)
  90 {
  91         /* Only subchannel status might indicate a path error. */
  92         if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0)
  93                 return IO_DONE;
  94         return status;
  95 }
  96
  97 /*
  98  * Process NOOP request result for a single path.
  99  */
 100 static void nop_callback(struct ccw_device *cdev, void *data, int rc)
 101 {
 102         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 103         struct ccw_request *req = &cdev->private->req;
 104
 105         if (rc == 0)
 106                 sch->vpm |= req->lpm;
 107         else if (rc != -EACCES)
 108                 goto err;
 109         req->lpm >>= 1;
 110         nop_do(cdev);
 111         return;
 112
 113 err:
 114         verify_done(cdev, rc);
 115 }
 116
 117 /*
 118  * Create channel program to perform SET PGID on a single path.
 119  */
 120 static void spid_build_cp(struct ccw_device *cdev, u8 fn)
 121 {
 122         struct ccw_request *req = &cdev->private->req;
 123         struct ccw1 *cp = cdev->private->iccws;
 124         int i = 8 - ffs(req->lpm);
 125         struct pgid *pgid = &cdev->private->pgid[i];
 126
 127         pgid->inf.fc    = fn;
 128         cp->cmd_code    = CCW_CMD_SET_PGID;
 129         cp->cda         = (u32) (addr_t) pgid;
 130         cp->count       = sizeof(*pgid);
 131         cp->flags       = CCW_FLAG_SLI;
 132         req->cp         = cp;
 133 }
 134
 135 /*
 136  * Perform establish/resign SET PGID on a single path.
 137  */
 138 static void spid_do(struct ccw_device *cdev)
 139 {
 140         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 141         struct ccw_request *req = &cdev->private->req;
 142         u8 fn;
 143
 144         /* Use next available path that is not already in correct state. */
 145         req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask);
 146         if (!req->lpm)
 147                 goto out_nopath;
 148         /* Channel program setup. */
 149         if (req->lpm & sch->opm)
 150                 fn = SPID_FUNC_ESTABLISH;
 151         else
 152                 fn = SPID_FUNC_RESIGN;
 153         if (cdev->private->flags.mpath)
 154                 fn |= SPID_FUNC_MULTI_PATH;
 155         spid_build_cp(cdev, fn);
 156         ccw_request_start(cdev);
 157         return;
 158
 159 out_nopath:
 160         verify_done(cdev, sch->vpm ? 0 : -EACCES);
 161 }
 162
 163 static void verify_start(struct ccw_device *cdev);
 164
 165 /*
 166  * Process SET PGID request result for a single path.
 167  */
 168 static void spid_callback(struct ccw_device *cdev, void *data, int rc)
 169 {
 170         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 171         struct ccw_request *req = &cdev->private->req;
 172
 173         switch (rc) {
 174         case 0:
 175                 sch->vpm |= req->lpm & sch->opm;
 176                 break;
 177         case -EACCES:
 178                 break;
 179         case -EOPNOTSUPP:
 180                 if (cdev->private->flags.mpath) {
 181                         /* Try without multipathing. */
 182                         cdev->private->flags.mpath = 0;
 183                         goto out_restart;
 184                 }
 185                 /* Try without pathgrouping. */
 186                 cdev->private->flags.pgroup = 0;
 187                 goto out_restart;
 188         default:
 189                 goto err;
 190         }
 191         req->lpm >>= 1;
 192         spid_do(cdev);
 193         return;
 194
 195 out_restart:
 196         verify_start(cdev);
 197         return;
 198 err:
 199         verify_done(cdev, rc);
 200 }
 201
 202 static void spid_start(struct ccw_device *cdev)
 203 {
 204         struct ccw_request *req = &cdev->private->req;
 205
 206         /* Initialize request data. */
 207         memset(req, 0, sizeof(*req));
 208         req->timeout    = PGID_TIMEOUT;
 209         req->maxretries = PGID_RETRIES;
 210         req->lpm        = 0x80;
 211         req->callback   = spid_callback;
 212         spid_do(cdev);
 213 }
 214
 215 static int pgid_cmp(struct pgid *p1, struct pgid *p2)
 216 {
 217         return memcmp((char *) p1 + 1, (char *) p2 + 1,
 218                       sizeof(struct pgid) - 1);
 219 }
 220
 221 /*
 222  * Determine pathgroup state from PGID data.
 223  */
 224 static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,
 225                          int *mismatch, int *reserved, int *reset)
 226 {
 227         struct pgid *pgid = &cdev->private->pgid[0];
 228         struct pgid *first = NULL;
 229         int lpm;
 230         int i;
 231
 232         *mismatch = 0;
 233         *reserved = 0;
 234         *reset = 0;
 235         for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) {
 236                 if ((cdev->private->pgid_valid_mask & lpm) == 0)
 237                         continue;
 238                 if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE)
 239                         *reserved = 1;
 240                 if (pgid->inf.ps.state1 == SNID_STATE1_RESET) {
 241                         /* A PGID was reset. */
 242                         *reset = 1;
 243                         continue;
 244                 }
 245                 if (!first) {
 246                         first = pgid;
 247                         continue;
 248                 }
 249                 if (pgid_cmp(pgid, first) != 0)
 250                         *mismatch = 1;
 251         }
 252         if (!first)
 253                 first = &channel_subsystems[0]->global_pgid;
 254         *p = first;
 255 }
 256
 257 static u8 pgid_to_donepm(struct ccw_device *cdev)
 258 {
 259         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 260         struct pgid *pgid;
 261         int i;
 262         int lpm;
 263         u8 donepm = 0;
 264
 265         /* Set bits for paths which are already in the target state. */
 266         for (i = 0; i < 8; i++) {
 267                 lpm = 0x80 >> i;
 268                 if ((cdev->private->pgid_valid_mask & lpm) == 0)
 269                         continue;
 270                 pgid = &cdev->private->pgid[i];
 271                 if (sch->opm & lpm) {
 272                         if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED)
 273                                 continue;
 274                 } else {
 275                         if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED)
 276                                 continue;
 277                 }
 278                 if (cdev->private->flags.mpath) {
 279                         if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH)
 280                                 continue;
 281                 } else {
 282                         if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH)
 283                                 continue;
 284                 }
 285                 donepm |= lpm;
 286         }
 287
 288         return donepm;
 289 }
 290
 291 static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid)
 292 {
 293         int i;
 294
 295         for (i = 0; i < 8; i++)
 296                 memcpy(&cdev->private->pgid[i], pgid, sizeof(struct pgid));
 297 }
 298
 299 /*
 300  * Process SENSE PGID data and report result.
 301  */
 302 static void snid_done(struct ccw_device *cdev, int rc)
 303 {
 304         struct ccw_dev_id *id = &cdev->private->dev_id;
 305         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 306         struct pgid *pgid;
 307         int mismatch = 0;
 308         int reserved = 0;
 309         int reset = 0;
 310         u8 donepm;
 311
 312         if (rc)
 313                 goto out;
 314         pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset);
 315         if (reserved)
 316                 rc = -EUSERS;
 317         else if (mismatch)
 318                 rc = -EOPNOTSUPP;
 319         else {
 320                 donepm = pgid_to_donepm(cdev);
 321                 sch->vpm = donepm & sch->opm;
 322                 cdev->private->pgid_todo_mask &= ~donepm;
 323                 pgid_fill(cdev, pgid);
 324         }
 325 out:
 326         CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x "
 327                       "todo=%02x mism=%d rsvd=%d reset=%d\n", id->ssid,
 328                       id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm,
 329                       cdev->private->pgid_todo_mask, mismatch, reserved, reset);
 330         switch (rc) {
 331         case 0:
 332                 /* Anything left to do? */
 333                 if (cdev->private->pgid_todo_mask == 0) {
 334                         verify_done(cdev, sch->vpm == 0 ? -EACCES : 0);
 335                         return;
 336                 }
 337                 /* Perform path-grouping. */
 338                 spid_start(cdev);
 339                 break;
 340         case -EOPNOTSUPP:
 341                 /* Path-grouping not supported. */
 342                 cdev->private->flags.pgroup = 0;
 343                 cdev->private->flags.mpath = 0;
 344                 verify_start(cdev);
 345                 break;
 346         default:
 347                 verify_done(cdev, rc);
 348         }
 349 }
 350
 351 /*
 352  * Create channel program to perform a SENSE PGID on a single path.
 353  */
 354 static void snid_build_cp(struct ccw_device *cdev)
 355 {
 356         struct ccw_request *req = &cdev->private->req;
 357         struct ccw1 *cp = cdev->private->iccws;
 358         int i = 8 - ffs(req->lpm);
 359
 360         /* Channel program setup. */
 361         cp->cmd_code    = CCW_CMD_SENSE_PGID;
 362         cp->cda         = (u32) (addr_t) &cdev->private->pgid[i];
 363         cp->count       = sizeof(struct pgid);
 364         cp->flags       = CCW_FLAG_SLI;
 365         req->cp         = cp;
 366 }
 367
 368 /*
 369  * Perform SENSE PGID on a single path.
 370  */
 371 static void snid_do(struct ccw_device *cdev)
 372 {
 373         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 374         struct ccw_request *req = &cdev->private->req;
 375
 376         /* Adjust lpm if paths are not set in pam. */
 377         req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam);
 378         if (!req->lpm)
 379                 goto out_nopath;
 380         snid_build_cp(cdev);
 381         ccw_request_start(cdev);
 382         return;
 383
 384 out_nopath:
 385         snid_done(cdev, cdev->private->pgid_valid_mask ? 0 : -EACCES);
 386 }
 387
 388 /*
 389  * Process SENSE PGID request result for single path.
 390  */
 391 static void snid_callback(struct ccw_device *cdev, void *data, int rc)
 392 {
 393         struct ccw_request *req = &cdev->private->req;
 394
 395         if (rc == 0)
 396                 cdev->private->pgid_valid_mask |= req->lpm;
 397         else if (rc != -EACCES)
 398                 goto err;
 399         req->lpm >>= 1;
 400         snid_do(cdev);
 401         return;
 402
 403 err:
 404         snid_done(cdev, rc);
 405 }
 406
 407 /*
 408  * Perform path verification.
 409  */
 410 static void verify_start(struct ccw_device *cdev)
 411 {
 412         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 413         struct ccw_request *req = &cdev->private->req;
 414         struct ccw_dev_id *devid = &cdev->private->dev_id;
 415
 416         sch->vpm = 0;
 417         sch->lpm = sch->schib.pmcw.pam;
 418         /* Initialize request data. */
 419         memset(req, 0, sizeof(*req));
 420         req->timeout    = PGID_TIMEOUT;
 421         req->maxretries = PGID_RETRIES;
 422         req->lpm        = 0x80;
 423         if (cdev->private->flags.pgroup) {
 424                 CIO_TRACE_EVENT(4, "snid");
 425                 CIO_HEX_EVENT(4, devid, sizeof(*devid));
 426                 req->callback   = snid_callback;
 427                 snid_do(cdev);
 428         } else {
 429                 CIO_TRACE_EVENT(4, "nop");
 430                 CIO_HEX_EVENT(4, devid, sizeof(*devid));
 431                 req->filter     = nop_filter;
 432                 req->callback   = nop_callback;
 433                 nop_do(cdev);
 434         }
 435 }
 436
 437 /**
 438  * ccw_device_verify_start - perform path verification
 439  * @cdev: ccw device
 440  *
 441  * Perform an I/O on each available channel path to @cdev to determine which
 442  * paths are operational. The resulting path mask is stored in sch->vpm.
 443  * If device options specify pathgrouping, establish a pathgroup for the
 444  * operational paths. When finished, call ccw_device_verify_done with a
 445  * return code specifying the result.
 446  */
 447 void ccw_device_verify_start(struct ccw_device *cdev)
 448 {
 449         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 450
 451         CIO_TRACE_EVENT(4, "vrfy");
 452         CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
 453         /* Initialize PGID data. */
 454         memset(cdev->private->pgid, 0, sizeof(cdev->private->pgid));
 455         cdev->private->pgid_valid_mask = 0;
 456         cdev->private->pgid_todo_mask = sch->schib.pmcw.pam;
 457         /*
 458          * Initialize pathgroup and multipath state with target values.
 459          * They may change in the course of path verification.
 460          */
 461         cdev->private->flags.pgroup = cdev->private->options.pgroup;
 462         cdev->private->flags.mpath = cdev->private->options.mpath;
 463         cdev->private->flags.doverify = 0;
 464         verify_start(cdev);
 465 }
 466
 467 /*
 468  * Process disband SET PGID request result.
 469  */
 470 static void disband_callback(struct ccw_device *cdev, void *data, int rc)
 471 {
 472         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 473         struct ccw_dev_id *id = &cdev->private->dev_id;
 474
 475         if (rc)
 476                 goto out;
 477         /* Ensure consistent multipathing state at device and channel. */
 478         cdev->private->flags.mpath = 0;
 479         if (sch->config.mp) {
 480                 sch->config.mp = 0;
 481                 rc = cio_commit_config(sch);
 482         }
 483 out:
 484         CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno,
 485                       rc);
 486         ccw_device_disband_done(cdev, rc);
 487 }
 488
 489 /**
 490  * ccw_device_disband_start - disband pathgroup
 491  * @cdev: ccw device
 492  *
 493  * Execute a SET PGID channel program on @cdev to disband a previously
 494  * established pathgroup. When finished, call ccw_device_disband_done with
 495  * a return code specifying the result.
 496  */
 497 void ccw_device_disband_start(struct ccw_device *cdev)
 498 {
 499         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 500         struct ccw_request *req = &cdev->private->req;
 501         u8 fn;
 502
 503         CIO_TRACE_EVENT(4, "disb");
 504         CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
 505         /* Request setup. */
 506         memset(req, 0, sizeof(*req));
 507         req->timeout    = PGID_TIMEOUT;
 508         req->maxretries = PGID_RETRIES;
 509         req->lpm        = sch->schib.pmcw.pam & sch->opm;
 510         req->callback   = disband_callback;
 511         fn = SPID_FUNC_DISBAND;
 512         if (cdev->private->flags.mpath)
 513                 fn |= SPID_FUNC_MULTI_PATH;
 514         spid_build_cp(cdev, fn);
 515         ccw_request_start(cdev);
 516 }
 517
 518 static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2)
 519 {
 520         struct ccw_request *req = &cdev->private->req;
 521         struct ccw1 *cp = cdev->private->iccws;
 522
 523         cp[0].cmd_code = CCW_CMD_STLCK;
 524         cp[0].cda = (u32) (addr_t) buf1;
 525         cp[0].count = 32;
 526         cp[0].flags = CCW_FLAG_CC;
 527         cp[1].cmd_code = CCW_CMD_RELEASE;
 528         cp[1].cda = (u32) (addr_t) buf2;
 529         cp[1].count = 32;
 530         cp[1].flags = 0;
 531         req->cp = cp;
 532 }
 533
 534 static void stlck_callback(struct ccw_device *cdev, void *data, int rc)
 535 {
 536         ccw_device_stlck_done(cdev, data, rc);
 537 }
 538
 539 /**
 540  * ccw_device_stlck_start - perform unconditional release
 541  * @cdev: ccw device
 542  * @data: data pointer to be passed to ccw_device_stlck_done
 543  * @buf1: data pointer used in channel program
 544  * @buf2: data pointer used in channel program
 545  *
 546  * Execute a channel program on @cdev to release an existing PGID reservation.
 547  * When finished, call ccw_device_stlck_done with a return code specifying the
 548  * result.
 549  */
 550 void ccw_device_stlck_start(struct ccw_device *cdev, void *data, void *buf1,
 551                             void *buf2)
 552 {
 553         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 554         struct ccw_request *req = &cdev->private->req;
 555
 556         CIO_TRACE_EVENT(4, "stlck");
 557         CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
 558         /* Request setup. */
 559         memset(req, 0, sizeof(*req));
 560         req->timeout    = PGID_TIMEOUT;
 561         req->maxretries = PGID_RETRIES;
 562         req->lpm        = sch->schib.pmcw.pam & sch->opm;
 563         req->data       = data;
 564         req->callback   = stlck_callback;
 565         stlck_build_cp(cdev, buf1, buf2);
 566         ccw_request_start(cdev);
 567 }
 568