728 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * CCW device PGID and path verification I/O handling.4 *5 * Copyright IBM Corp. 2002, 20096 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>7 * Martin Schwidefsky <schwidefsky@de.ibm.com>8 * Peter Oberparleiter <peter.oberparleiter@de.ibm.com>9 */10 11#include <linux/kernel.h>12#include <linux/string.h>13#include <linux/bitops.h>14#include <linux/types.h>15#include <linux/errno.h>16#include <linux/slab.h>17#include <linux/io.h>18#include <asm/ccwdev.h>19#include <asm/cio.h>20 21#include "cio.h"22#include "cio_debug.h"23#include "device.h"24#include "io_sch.h"25 26#define PGID_RETRIES 25627#define PGID_TIMEOUT (10 * HZ)28 29static void verify_start(struct ccw_device *cdev);30 31/*32 * Process path verification data and report result.33 */34static void verify_done(struct ccw_device *cdev, int rc)35{36 struct subchannel *sch = to_subchannel(cdev->dev.parent);37 struct ccw_dev_id *id = &cdev->private->dev_id;38 int mpath = cdev->private->flags.mpath;39 int pgroup = cdev->private->flags.pgroup;40 41 if (rc)42 goto out;43 /* Ensure consistent multipathing state at device and channel. */44 if (sch->config.mp != mpath) {45 sch->config.mp = mpath;46 rc = cio_commit_config(sch);47 }48out:49 CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d "50 "vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath,51 sch->vpm);52 ccw_device_verify_done(cdev, rc);53}54 55/*56 * Create channel program to perform a NOOP.57 */58static void nop_build_cp(struct ccw_device *cdev)59{60 struct ccw_request *req = &cdev->private->req;61 struct ccw1 *cp = cdev->private->dma_area->iccws;62 63 cp->cmd_code = CCW_CMD_NOOP;64 cp->cda = 0;65 cp->count = 0;66 cp->flags = CCW_FLAG_SLI;67 req->cp = cp;68}69 70/*71 * Perform NOOP on a single path.72 */73static void nop_do(struct ccw_device *cdev)74{75 struct subchannel *sch = to_subchannel(cdev->dev.parent);76 struct ccw_request *req = &cdev->private->req;77 78 req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm &79 ~cdev->private->path_noirq_mask);80 if (!req->lpm)81 goto out_nopath;82 nop_build_cp(cdev);83 ccw_request_start(cdev);84 return;85 86out_nopath:87 verify_done(cdev, sch->vpm ? 0 : -EACCES);88}89 90/*91 * Adjust NOOP I/O status.92 */93static enum io_status nop_filter(struct ccw_device *cdev, void *data,94 struct irb *irb, enum io_status status)95{96 /* Only subchannel status might indicate a path error. */97 if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0)98 return IO_DONE;99 return status;100}101 102/*103 * Process NOOP request result for a single path.104 */105static void nop_callback(struct ccw_device *cdev, void *data, int rc)106{107 struct subchannel *sch = to_subchannel(cdev->dev.parent);108 struct ccw_request *req = &cdev->private->req;109 110 switch (rc) {111 case 0:112 sch->vpm |= req->lpm;113 break;114 case -ETIME:115 cdev->private->path_noirq_mask |= req->lpm;116 break;117 case -EACCES:118 cdev->private->path_notoper_mask |= req->lpm;119 break;120 default:121 goto err;122 }123 /* Continue on the next path. */124 req->lpm >>= 1;125 nop_do(cdev);126 return;127 128err:129 verify_done(cdev, rc);130}131 132/*133 * Create channel program to perform SET PGID on a single path.134 */135static void spid_build_cp(struct ccw_device *cdev, u8 fn)136{137 struct ccw_request *req = &cdev->private->req;138 struct ccw1 *cp = cdev->private->dma_area->iccws;139 int i = pathmask_to_pos(req->lpm);140 struct pgid *pgid = &cdev->private->dma_area->pgid[i];141 142 pgid->inf.fc = fn;143 cp->cmd_code = CCW_CMD_SET_PGID;144 cp->cda = virt_to_dma32(pgid);145 cp->count = sizeof(*pgid);146 cp->flags = CCW_FLAG_SLI;147 req->cp = cp;148}149 150static void pgid_wipeout_callback(struct ccw_device *cdev, void *data, int rc)151{152 if (rc) {153 /* We don't know the path groups' state. Abort. */154 verify_done(cdev, rc);155 return;156 }157 /*158 * Path groups have been reset. Restart path verification but159 * leave paths in path_noirq_mask out.160 */161 cdev->private->flags.pgid_unknown = 0;162 verify_start(cdev);163}164 165/*166 * Reset pathgroups and restart path verification, leave unusable paths out.167 */168static void pgid_wipeout_start(struct ccw_device *cdev)169{170 struct subchannel *sch = to_subchannel(cdev->dev.parent);171 struct ccw_dev_id *id = &cdev->private->dev_id;172 struct ccw_request *req = &cdev->private->req;173 u8 fn;174 175 CIO_MSG_EVENT(2, "wipe: device 0.%x.%04x: pvm=%02x nim=%02x\n",176 id->ssid, id->devno, cdev->private->pgid_valid_mask,177 cdev->private->path_noirq_mask);178 179 /* Initialize request data. */180 memset(req, 0, sizeof(*req));181 req->timeout = PGID_TIMEOUT;182 req->maxretries = PGID_RETRIES;183 req->lpm = sch->schib.pmcw.pam;184 req->callback = pgid_wipeout_callback;185 fn = SPID_FUNC_DISBAND;186 if (cdev->private->flags.mpath)187 fn |= SPID_FUNC_MULTI_PATH;188 spid_build_cp(cdev, fn);189 ccw_request_start(cdev);190}191 192/*193 * Perform establish/resign SET PGID on a single path.194 */195static void spid_do(struct ccw_device *cdev)196{197 struct subchannel *sch = to_subchannel(cdev->dev.parent);198 struct ccw_request *req = &cdev->private->req;199 u8 fn;200 201 /* Use next available path that is not already in correct state. */202 req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask);203 if (!req->lpm)204 goto out_nopath;205 /* Channel program setup. */206 if (req->lpm & sch->opm)207 fn = SPID_FUNC_ESTABLISH;208 else209 fn = SPID_FUNC_RESIGN;210 if (cdev->private->flags.mpath)211 fn |= SPID_FUNC_MULTI_PATH;212 spid_build_cp(cdev, fn);213 ccw_request_start(cdev);214 return;215 216out_nopath:217 if (cdev->private->flags.pgid_unknown) {218 /* At least one SPID could be partially done. */219 pgid_wipeout_start(cdev);220 return;221 }222 verify_done(cdev, sch->vpm ? 0 : -EACCES);223}224 225/*226 * Process SET PGID request result for a single path.227 */228static void spid_callback(struct ccw_device *cdev, void *data, int rc)229{230 struct subchannel *sch = to_subchannel(cdev->dev.parent);231 struct ccw_request *req = &cdev->private->req;232 233 switch (rc) {234 case 0:235 sch->vpm |= req->lpm & sch->opm;236 break;237 case -ETIME:238 cdev->private->flags.pgid_unknown = 1;239 cdev->private->path_noirq_mask |= req->lpm;240 break;241 case -EACCES:242 cdev->private->path_notoper_mask |= req->lpm;243 break;244 case -EOPNOTSUPP:245 if (cdev->private->flags.mpath) {246 /* Try without multipathing. */247 cdev->private->flags.mpath = 0;248 goto out_restart;249 }250 /* Try without pathgrouping. */251 cdev->private->flags.pgroup = 0;252 goto out_restart;253 default:254 goto err;255 }256 req->lpm >>= 1;257 spid_do(cdev);258 return;259 260out_restart:261 verify_start(cdev);262 return;263err:264 verify_done(cdev, rc);265}266 267static void spid_start(struct ccw_device *cdev)268{269 struct ccw_request *req = &cdev->private->req;270 271 /* Initialize request data. */272 memset(req, 0, sizeof(*req));273 req->timeout = PGID_TIMEOUT;274 req->maxretries = PGID_RETRIES;275 req->lpm = 0x80;276 req->singlepath = 1;277 req->callback = spid_callback;278 spid_do(cdev);279}280 281static int pgid_is_reset(struct pgid *p)282{283 char *c;284 285 for (c = (char *)p + 1; c < (char *)(p + 1); c++) {286 if (*c != 0)287 return 0;288 }289 return 1;290}291 292static int pgid_cmp(struct pgid *p1, struct pgid *p2)293{294 return memcmp((char *) p1 + 1, (char *) p2 + 1,295 sizeof(struct pgid) - 1);296}297 298/*299 * Determine pathgroup state from PGID data.300 */301static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,302 int *mismatch, u8 *reserved, u8 *reset)303{304 struct pgid *pgid = &cdev->private->dma_area->pgid[0];305 struct pgid *first = NULL;306 int lpm;307 int i;308 309 *mismatch = 0;310 *reserved = 0;311 *reset = 0;312 for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) {313 if ((cdev->private->pgid_valid_mask & lpm) == 0)314 continue;315 if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE)316 *reserved |= lpm;317 if (pgid_is_reset(pgid)) {318 *reset |= lpm;319 continue;320 }321 if (!first) {322 first = pgid;323 continue;324 }325 if (pgid_cmp(pgid, first) != 0)326 *mismatch = 1;327 }328 if (!first)329 first = &channel_subsystems[0]->global_pgid;330 *p = first;331}332 333static u8 pgid_to_donepm(struct ccw_device *cdev)334{335 struct subchannel *sch = to_subchannel(cdev->dev.parent);336 struct pgid *pgid;337 int i;338 int lpm;339 u8 donepm = 0;340 341 /* Set bits for paths which are already in the target state. */342 for (i = 0; i < 8; i++) {343 lpm = 0x80 >> i;344 if ((cdev->private->pgid_valid_mask & lpm) == 0)345 continue;346 pgid = &cdev->private->dma_area->pgid[i];347 if (sch->opm & lpm) {348 if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED)349 continue;350 } else {351 if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED)352 continue;353 }354 if (cdev->private->flags.mpath) {355 if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH)356 continue;357 } else {358 if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH)359 continue;360 }361 donepm |= lpm;362 }363 364 return donepm;365}366 367static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid)368{369 int i;370 371 for (i = 0; i < 8; i++)372 memcpy(&cdev->private->dma_area->pgid[i], pgid,373 sizeof(struct pgid));374}375 376/*377 * Process SENSE PGID data and report result.378 */379static void snid_done(struct ccw_device *cdev, int rc)380{381 struct ccw_dev_id *id = &cdev->private->dev_id;382 struct subchannel *sch = to_subchannel(cdev->dev.parent);383 struct pgid *pgid;384 int mismatch = 0;385 u8 reserved = 0;386 u8 reset = 0;387 u8 donepm;388 389 if (rc)390 goto out;391 pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset);392 if (reserved == cdev->private->pgid_valid_mask)393 rc = -EUSERS;394 else if (mismatch)395 rc = -EOPNOTSUPP;396 else {397 donepm = pgid_to_donepm(cdev);398 sch->vpm = donepm & sch->opm;399 cdev->private->pgid_reset_mask |= reset;400 cdev->private->pgid_todo_mask &=401 ~(donepm | cdev->private->path_noirq_mask);402 pgid_fill(cdev, pgid);403 }404out:405 CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x "406 "todo=%02x mism=%d rsvd=%02x reset=%02x\n", id->ssid,407 id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm,408 cdev->private->pgid_todo_mask, mismatch, reserved, reset);409 switch (rc) {410 case 0:411 if (cdev->private->flags.pgid_unknown) {412 pgid_wipeout_start(cdev);413 return;414 }415 /* Anything left to do? */416 if (cdev->private->pgid_todo_mask == 0) {417 verify_done(cdev, sch->vpm == 0 ? -EACCES : 0);418 return;419 }420 /* Perform path-grouping. */421 spid_start(cdev);422 break;423 case -EOPNOTSUPP:424 /* Path-grouping not supported. */425 cdev->private->flags.pgroup = 0;426 cdev->private->flags.mpath = 0;427 verify_start(cdev);428 break;429 default:430 verify_done(cdev, rc);431 }432}433 434/*435 * Create channel program to perform a SENSE PGID on a single path.436 */437static void snid_build_cp(struct ccw_device *cdev)438{439 struct ccw_request *req = &cdev->private->req;440 struct ccw1 *cp = cdev->private->dma_area->iccws;441 int i = pathmask_to_pos(req->lpm);442 443 /* Channel program setup. */444 cp->cmd_code = CCW_CMD_SENSE_PGID;445 cp->cda = virt_to_dma32(&cdev->private->dma_area->pgid[i]);446 cp->count = sizeof(struct pgid);447 cp->flags = CCW_FLAG_SLI;448 req->cp = cp;449}450 451/*452 * Perform SENSE PGID on a single path.453 */454static void snid_do(struct ccw_device *cdev)455{456 struct subchannel *sch = to_subchannel(cdev->dev.parent);457 struct ccw_request *req = &cdev->private->req;458 int ret;459 460 req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam &461 ~cdev->private->path_noirq_mask);462 if (!req->lpm)463 goto out_nopath;464 snid_build_cp(cdev);465 ccw_request_start(cdev);466 return;467 468out_nopath:469 if (cdev->private->pgid_valid_mask)470 ret = 0;471 else if (cdev->private->path_noirq_mask)472 ret = -ETIME;473 else474 ret = -EACCES;475 snid_done(cdev, ret);476}477 478/*479 * Process SENSE PGID request result for single path.480 */481static void snid_callback(struct ccw_device *cdev, void *data, int rc)482{483 struct ccw_request *req = &cdev->private->req;484 485 switch (rc) {486 case 0:487 cdev->private->pgid_valid_mask |= req->lpm;488 break;489 case -ETIME:490 cdev->private->flags.pgid_unknown = 1;491 cdev->private->path_noirq_mask |= req->lpm;492 break;493 case -EACCES:494 cdev->private->path_notoper_mask |= req->lpm;495 break;496 default:497 goto err;498 }499 /* Continue on the next path. */500 req->lpm >>= 1;501 snid_do(cdev);502 return;503 504err:505 snid_done(cdev, rc);506}507 508/*509 * Perform path verification.510 */511static void verify_start(struct ccw_device *cdev)512{513 struct subchannel *sch = to_subchannel(cdev->dev.parent);514 struct ccw_request *req = &cdev->private->req;515 struct ccw_dev_id *devid = &cdev->private->dev_id;516 517 sch->vpm = 0;518 sch->lpm = sch->schib.pmcw.pam;519 520 /* Initialize PGID data. */521 memset(cdev->private->dma_area->pgid, 0,522 sizeof(cdev->private->dma_area->pgid));523 cdev->private->pgid_valid_mask = 0;524 cdev->private->pgid_todo_mask = sch->schib.pmcw.pam;525 cdev->private->path_notoper_mask = 0;526 527 /* Initialize request data. */528 memset(req, 0, sizeof(*req));529 req->timeout = PGID_TIMEOUT;530 req->maxretries = PGID_RETRIES;531 req->lpm = 0x80;532 req->singlepath = 1;533 if (cdev->private->flags.pgroup) {534 CIO_TRACE_EVENT(4, "snid");535 CIO_HEX_EVENT(4, devid, sizeof(*devid));536 req->callback = snid_callback;537 snid_do(cdev);538 } else {539 CIO_TRACE_EVENT(4, "nop");540 CIO_HEX_EVENT(4, devid, sizeof(*devid));541 req->filter = nop_filter;542 req->callback = nop_callback;543 nop_do(cdev);544 }545}546 547/**548 * ccw_device_verify_start - perform path verification549 * @cdev: ccw device550 *551 * Perform an I/O on each available channel path to @cdev to determine which552 * paths are operational. The resulting path mask is stored in sch->vpm.553 * If device options specify pathgrouping, establish a pathgroup for the554 * operational paths. When finished, call ccw_device_verify_done with a555 * return code specifying the result.556 */557void ccw_device_verify_start(struct ccw_device *cdev)558{559 CIO_TRACE_EVENT(4, "vrfy");560 CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));561 /*562 * Initialize pathgroup and multipath state with target values.563 * They may change in the course of path verification.564 */565 cdev->private->flags.pgroup = cdev->private->options.pgroup;566 cdev->private->flags.mpath = cdev->private->options.mpath;567 cdev->private->flags.doverify = 0;568 cdev->private->path_noirq_mask = 0;569 verify_start(cdev);570}571 572/*573 * Process disband SET PGID request result.574 */575static void disband_callback(struct ccw_device *cdev, void *data, int rc)576{577 struct subchannel *sch = to_subchannel(cdev->dev.parent);578 struct ccw_dev_id *id = &cdev->private->dev_id;579 580 if (rc)581 goto out;582 /* Ensure consistent multipathing state at device and channel. */583 cdev->private->flags.mpath = 0;584 if (sch->config.mp) {585 sch->config.mp = 0;586 rc = cio_commit_config(sch);587 }588out:589 CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno,590 rc);591 ccw_device_disband_done(cdev, rc);592}593 594/**595 * ccw_device_disband_start - disband pathgroup596 * @cdev: ccw device597 *598 * Execute a SET PGID channel program on @cdev to disband a previously599 * established pathgroup. When finished, call ccw_device_disband_done with600 * a return code specifying the result.601 */602void ccw_device_disband_start(struct ccw_device *cdev)603{604 struct subchannel *sch = to_subchannel(cdev->dev.parent);605 struct ccw_request *req = &cdev->private->req;606 u8 fn;607 608 CIO_TRACE_EVENT(4, "disb");609 CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));610 /* Request setup. */611 memset(req, 0, sizeof(*req));612 req->timeout = PGID_TIMEOUT;613 req->maxretries = PGID_RETRIES;614 req->lpm = sch->schib.pmcw.pam & sch->opm;615 req->singlepath = 1;616 req->callback = disband_callback;617 fn = SPID_FUNC_DISBAND;618 if (cdev->private->flags.mpath)619 fn |= SPID_FUNC_MULTI_PATH;620 spid_build_cp(cdev, fn);621 ccw_request_start(cdev);622}623 624struct stlck_data {625 struct completion done;626 int rc;627};628 629static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2)630{631 struct ccw_request *req = &cdev->private->req;632 struct ccw1 *cp = cdev->private->dma_area->iccws;633 634 cp[0].cmd_code = CCW_CMD_STLCK;635 cp[0].cda = virt_to_dma32(buf1);636 cp[0].count = 32;637 cp[0].flags = CCW_FLAG_CC;638 cp[1].cmd_code = CCW_CMD_RELEASE;639 cp[1].cda = virt_to_dma32(buf2);640 cp[1].count = 32;641 cp[1].flags = 0;642 req->cp = cp;643}644 645static void stlck_callback(struct ccw_device *cdev, void *data, int rc)646{647 struct stlck_data *sdata = data;648 649 sdata->rc = rc;650 complete(&sdata->done);651}652 653/**654 * ccw_device_stlck_start - perform unconditional release655 * @cdev: ccw device656 * @data: data pointer to be passed to ccw_device_stlck_done657 * @buf1: data pointer used in channel program658 * @buf2: data pointer used in channel program659 *660 * Execute a channel program on @cdev to release an existing PGID reservation.661 */662static void ccw_device_stlck_start(struct ccw_device *cdev, void *data,663 void *buf1, void *buf2)664{665 struct subchannel *sch = to_subchannel(cdev->dev.parent);666 struct ccw_request *req = &cdev->private->req;667 668 CIO_TRACE_EVENT(4, "stlck");669 CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));670 /* Request setup. */671 memset(req, 0, sizeof(*req));672 req->timeout = PGID_TIMEOUT;673 req->maxretries = PGID_RETRIES;674 req->lpm = sch->schib.pmcw.pam & sch->opm;675 req->data = data;676 req->callback = stlck_callback;677 stlck_build_cp(cdev, buf1, buf2);678 ccw_request_start(cdev);679}680 681/*682 * Perform unconditional reserve + release.683 */684int ccw_device_stlck(struct ccw_device *cdev)685{686 struct subchannel *sch = to_subchannel(cdev->dev.parent);687 struct stlck_data data;688 u8 *buffer;689 int rc;690 691 /* Check if steal lock operation is valid for this device. */692 if (cdev->drv) {693 if (!cdev->private->options.force)694 return -EINVAL;695 }696 buffer = kzalloc(64, GFP_DMA | GFP_KERNEL);697 if (!buffer)698 return -ENOMEM;699 init_completion(&data.done);700 data.rc = -EIO;701 spin_lock_irq(&sch->lock);702 rc = cio_enable_subchannel(sch, (u32)virt_to_phys(sch));703 if (rc)704 goto out_unlock;705 /* Perform operation. */706 cdev->private->state = DEV_STATE_STEAL_LOCK;707 ccw_device_stlck_start(cdev, &data, &buffer[0], &buffer[32]);708 spin_unlock_irq(&sch->lock);709 /* Wait for operation to finish. */710 if (wait_for_completion_interruptible(&data.done)) {711 /* Got a signal. */712 spin_lock_irq(&sch->lock);713 ccw_request_cancel(cdev);714 spin_unlock_irq(&sch->lock);715 wait_for_completion(&data.done);716 }717 rc = data.rc;718 /* Check results. */719 spin_lock_irq(&sch->lock);720 cio_disable_subchannel(sch);721 cdev->private->state = DEV_STATE_BOXED;722out_unlock:723 spin_unlock_irq(&sch->lock);724 kfree(buffer);725 726 return rc;727}728