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