mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
726 lines
18 KiB
726 lines
18 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* CCW device PGID and path verification I/O handling. |
|
* |
|
* Copyright IBM Corp. 2002, 2009 |
|
* Author(s): Cornelia Huck <[email protected]> |
|
* Martin Schwidefsky <[email protected]> |
|
* Peter Oberparleiter <[email protected]> |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/string.h> |
|
#include <linux/bitops.h> |
|
#include <linux/types.h> |
|
#include <linux/errno.h> |
|
#include <linux/slab.h> |
|
#include <asm/ccwdev.h> |
|
#include <asm/cio.h> |
|
|
|
#include "cio.h" |
|
#include "cio_debug.h" |
|
#include "device.h" |
|
#include "io_sch.h" |
|
|
|
#define PGID_RETRIES 256 |
|
#define PGID_TIMEOUT (10 * HZ) |
|
|
|
static void verify_start(struct ccw_device *cdev); |
|
|
|
/* |
|
* Process path verification data and report result. |
|
*/ |
|
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.mpath; |
|
int pgroup = cdev->private->flags.pgroup; |
|
|
|
if (rc) |
|
goto out; |
|
/* Ensure consistent multipathing state at device and channel. */ |
|
if (sch->config.mp != mpath) { |
|
sch->config.mp = mpath; |
|
rc = cio_commit_config(sch); |
|
} |
|
out: |
|
CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d " |
|
"vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath, |
|
sch->vpm); |
|
ccw_device_verify_done(cdev, rc); |
|
} |
|
|
|
/* |
|
* Create channel program to perform a NOOP. |
|
*/ |
|
static void nop_build_cp(struct ccw_device *cdev) |
|
{ |
|
struct ccw_request *req = &cdev->private->req; |
|
struct ccw1 *cp = cdev->private->dma_area->iccws; |
|
|
|
cp->cmd_code = CCW_CMD_NOOP; |
|
cp->cda = 0; |
|
cp->count = 0; |
|
cp->flags = CCW_FLAG_SLI; |
|
req->cp = cp; |
|
} |
|
|
|
/* |
|
* Perform NOOP on a single path. |
|
*/ |
|
static void nop_do(struct ccw_device *cdev) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_request *req = &cdev->private->req; |
|
|
|
req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm & |
|
~cdev->private->path_noirq_mask); |
|
if (!req->lpm) |
|
goto out_nopath; |
|
nop_build_cp(cdev); |
|
ccw_request_start(cdev); |
|
return; |
|
|
|
out_nopath: |
|
verify_done(cdev, sch->vpm ? 0 : -EACCES); |
|
} |
|
|
|
/* |
|
* Adjust NOOP I/O status. |
|
*/ |
|
static enum io_status nop_filter(struct ccw_device *cdev, void *data, |
|
struct irb *irb, enum io_status status) |
|
{ |
|
/* Only subchannel status might indicate a path error. */ |
|
if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0) |
|
return IO_DONE; |
|
return status; |
|
} |
|
|
|
/* |
|
* Process NOOP request result for a single path. |
|
*/ |
|
static void nop_callback(struct ccw_device *cdev, void *data, int rc) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_request *req = &cdev->private->req; |
|
|
|
switch (rc) { |
|
case 0: |
|
sch->vpm |= req->lpm; |
|
break; |
|
case -ETIME: |
|
cdev->private->path_noirq_mask |= req->lpm; |
|
break; |
|
case -EACCES: |
|
cdev->private->path_notoper_mask |= req->lpm; |
|
break; |
|
default: |
|
goto err; |
|
} |
|
/* Continue on the next path. */ |
|
req->lpm >>= 1; |
|
nop_do(cdev); |
|
return; |
|
|
|
err: |
|
verify_done(cdev, rc); |
|
} |
|
|
|
/* |
|
* Create channel program to perform SET PGID on a single path. |
|
*/ |
|
static void spid_build_cp(struct ccw_device *cdev, u8 fn) |
|
{ |
|
struct ccw_request *req = &cdev->private->req; |
|
struct ccw1 *cp = cdev->private->dma_area->iccws; |
|
int i = pathmask_to_pos(req->lpm); |
|
struct pgid *pgid = &cdev->private->dma_area->pgid[i]; |
|
|
|
pgid->inf.fc = fn; |
|
cp->cmd_code = CCW_CMD_SET_PGID; |
|
cp->cda = (u32) (addr_t) pgid; |
|
cp->count = sizeof(*pgid); |
|
cp->flags = CCW_FLAG_SLI; |
|
req->cp = cp; |
|
} |
|
|
|
static void pgid_wipeout_callback(struct ccw_device *cdev, void *data, int rc) |
|
{ |
|
if (rc) { |
|
/* We don't know the path groups' state. Abort. */ |
|
verify_done(cdev, rc); |
|
return; |
|
} |
|
/* |
|
* Path groups have been reset. Restart path verification but |
|
* leave paths in path_noirq_mask out. |
|
*/ |
|
cdev->private->flags.pgid_unknown = 0; |
|
verify_start(cdev); |
|
} |
|
|
|
/* |
|
* Reset pathgroups and restart path verification, leave unusable paths out. |
|
*/ |
|
static void pgid_wipeout_start(struct ccw_device *cdev) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_dev_id *id = &cdev->private->dev_id; |
|
struct ccw_request *req = &cdev->private->req; |
|
u8 fn; |
|
|
|
CIO_MSG_EVENT(2, "wipe: device 0.%x.%04x: pvm=%02x nim=%02x\n", |
|
id->ssid, id->devno, cdev->private->pgid_valid_mask, |
|
cdev->private->path_noirq_mask); |
|
|
|
/* Initialize request data. */ |
|
memset(req, 0, sizeof(*req)); |
|
req->timeout = PGID_TIMEOUT; |
|
req->maxretries = PGID_RETRIES; |
|
req->lpm = sch->schib.pmcw.pam; |
|
req->callback = pgid_wipeout_callback; |
|
fn = SPID_FUNC_DISBAND; |
|
if (cdev->private->flags.mpath) |
|
fn |= SPID_FUNC_MULTI_PATH; |
|
spid_build_cp(cdev, fn); |
|
ccw_request_start(cdev); |
|
} |
|
|
|
/* |
|
* Perform establish/resign SET PGID on a single path. |
|
*/ |
|
static void spid_do(struct ccw_device *cdev) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_request *req = &cdev->private->req; |
|
u8 fn; |
|
|
|
/* Use next available path that is not already in correct state. */ |
|
req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask); |
|
if (!req->lpm) |
|
goto out_nopath; |
|
/* Channel program setup. */ |
|
if (req->lpm & sch->opm) |
|
fn = SPID_FUNC_ESTABLISH; |
|
else |
|
fn = SPID_FUNC_RESIGN; |
|
if (cdev->private->flags.mpath) |
|
fn |= SPID_FUNC_MULTI_PATH; |
|
spid_build_cp(cdev, fn); |
|
ccw_request_start(cdev); |
|
return; |
|
|
|
out_nopath: |
|
if (cdev->private->flags.pgid_unknown) { |
|
/* At least one SPID could be partially done. */ |
|
pgid_wipeout_start(cdev); |
|
return; |
|
} |
|
verify_done(cdev, sch->vpm ? 0 : -EACCES); |
|
} |
|
|
|
/* |
|
* Process SET PGID request result for a single path. |
|
*/ |
|
static void spid_callback(struct ccw_device *cdev, void *data, int rc) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_request *req = &cdev->private->req; |
|
|
|
switch (rc) { |
|
case 0: |
|
sch->vpm |= req->lpm & sch->opm; |
|
break; |
|
case -ETIME: |
|
cdev->private->flags.pgid_unknown = 1; |
|
cdev->private->path_noirq_mask |= req->lpm; |
|
break; |
|
case -EACCES: |
|
cdev->private->path_notoper_mask |= req->lpm; |
|
break; |
|
case -EOPNOTSUPP: |
|
if (cdev->private->flags.mpath) { |
|
/* Try without multipathing. */ |
|
cdev->private->flags.mpath = 0; |
|
goto out_restart; |
|
} |
|
/* Try without pathgrouping. */ |
|
cdev->private->flags.pgroup = 0; |
|
goto out_restart; |
|
default: |
|
goto err; |
|
} |
|
req->lpm >>= 1; |
|
spid_do(cdev); |
|
return; |
|
|
|
out_restart: |
|
verify_start(cdev); |
|
return; |
|
err: |
|
verify_done(cdev, rc); |
|
} |
|
|
|
static void spid_start(struct ccw_device *cdev) |
|
{ |
|
struct ccw_request *req = &cdev->private->req; |
|
|
|
/* Initialize request data. */ |
|
memset(req, 0, sizeof(*req)); |
|
req->timeout = PGID_TIMEOUT; |
|
req->maxretries = PGID_RETRIES; |
|
req->lpm = 0x80; |
|
req->singlepath = 1; |
|
req->callback = spid_callback; |
|
spid_do(cdev); |
|
} |
|
|
|
static int pgid_is_reset(struct pgid *p) |
|
{ |
|
char *c; |
|
|
|
for (c = (char *)p + 1; c < (char *)(p + 1); c++) { |
|
if (*c != 0) |
|
return 0; |
|
} |
|
return 1; |
|
} |
|
|
|
static int pgid_cmp(struct pgid *p1, struct pgid *p2) |
|
{ |
|
return memcmp((char *) p1 + 1, (char *) p2 + 1, |
|
sizeof(struct pgid) - 1); |
|
} |
|
|
|
/* |
|
* Determine pathgroup state from PGID data. |
|
*/ |
|
static void pgid_analyze(struct ccw_device *cdev, struct pgid **p, |
|
int *mismatch, u8 *reserved, u8 *reset) |
|
{ |
|
struct pgid *pgid = &cdev->private->dma_area->pgid[0]; |
|
struct pgid *first = NULL; |
|
int lpm; |
|
int i; |
|
|
|
*mismatch = 0; |
|
*reserved = 0; |
|
*reset = 0; |
|
for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) { |
|
if ((cdev->private->pgid_valid_mask & lpm) == 0) |
|
continue; |
|
if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE) |
|
*reserved |= lpm; |
|
if (pgid_is_reset(pgid)) { |
|
*reset |= lpm; |
|
continue; |
|
} |
|
if (!first) { |
|
first = pgid; |
|
continue; |
|
} |
|
if (pgid_cmp(pgid, first) != 0) |
|
*mismatch = 1; |
|
} |
|
if (!first) |
|
first = &channel_subsystems[0]->global_pgid; |
|
*p = first; |
|
} |
|
|
|
static u8 pgid_to_donepm(struct ccw_device *cdev) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct pgid *pgid; |
|
int i; |
|
int lpm; |
|
u8 donepm = 0; |
|
|
|
/* Set bits for paths which are already in the target state. */ |
|
for (i = 0; i < 8; i++) { |
|
lpm = 0x80 >> i; |
|
if ((cdev->private->pgid_valid_mask & lpm) == 0) |
|
continue; |
|
pgid = &cdev->private->dma_area->pgid[i]; |
|
if (sch->opm & lpm) { |
|
if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED) |
|
continue; |
|
} else { |
|
if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED) |
|
continue; |
|
} |
|
if (cdev->private->flags.mpath) { |
|
if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH) |
|
continue; |
|
} else { |
|
if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH) |
|
continue; |
|
} |
|
donepm |= lpm; |
|
} |
|
|
|
return donepm; |
|
} |
|
|
|
static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid) |
|
{ |
|
int i; |
|
|
|
for (i = 0; i < 8; i++) |
|
memcpy(&cdev->private->dma_area->pgid[i], pgid, |
|
sizeof(struct pgid)); |
|
} |
|
|
|
/* |
|
* Process SENSE PGID data and report result. |
|
*/ |
|
static void snid_done(struct ccw_device *cdev, int rc) |
|
{ |
|
struct ccw_dev_id *id = &cdev->private->dev_id; |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct pgid *pgid; |
|
int mismatch = 0; |
|
u8 reserved = 0; |
|
u8 reset = 0; |
|
u8 donepm; |
|
|
|
if (rc) |
|
goto out; |
|
pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset); |
|
if (reserved == cdev->private->pgid_valid_mask) |
|
rc = -EUSERS; |
|
else if (mismatch) |
|
rc = -EOPNOTSUPP; |
|
else { |
|
donepm = pgid_to_donepm(cdev); |
|
sch->vpm = donepm & sch->opm; |
|
cdev->private->pgid_reset_mask |= reset; |
|
cdev->private->pgid_todo_mask &= |
|
~(donepm | cdev->private->path_noirq_mask); |
|
pgid_fill(cdev, pgid); |
|
} |
|
out: |
|
CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x " |
|
"todo=%02x mism=%d rsvd=%02x reset=%02x\n", id->ssid, |
|
id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm, |
|
cdev->private->pgid_todo_mask, mismatch, reserved, reset); |
|
switch (rc) { |
|
case 0: |
|
if (cdev->private->flags.pgid_unknown) { |
|
pgid_wipeout_start(cdev); |
|
return; |
|
} |
|
/* Anything left to do? */ |
|
if (cdev->private->pgid_todo_mask == 0) { |
|
verify_done(cdev, sch->vpm == 0 ? -EACCES : 0); |
|
return; |
|
} |
|
/* Perform path-grouping. */ |
|
spid_start(cdev); |
|
break; |
|
case -EOPNOTSUPP: |
|
/* Path-grouping not supported. */ |
|
cdev->private->flags.pgroup = 0; |
|
cdev->private->flags.mpath = 0; |
|
verify_start(cdev); |
|
break; |
|
default: |
|
verify_done(cdev, rc); |
|
} |
|
} |
|
|
|
/* |
|
* Create channel program to perform a SENSE PGID on a single path. |
|
*/ |
|
static void snid_build_cp(struct ccw_device *cdev) |
|
{ |
|
struct ccw_request *req = &cdev->private->req; |
|
struct ccw1 *cp = cdev->private->dma_area->iccws; |
|
int i = pathmask_to_pos(req->lpm); |
|
|
|
/* Channel program setup. */ |
|
cp->cmd_code = CCW_CMD_SENSE_PGID; |
|
cp->cda = (u32) (addr_t) &cdev->private->dma_area->pgid[i]; |
|
cp->count = sizeof(struct pgid); |
|
cp->flags = CCW_FLAG_SLI; |
|
req->cp = cp; |
|
} |
|
|
|
/* |
|
* Perform SENSE PGID on a single path. |
|
*/ |
|
static void snid_do(struct ccw_device *cdev) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_request *req = &cdev->private->req; |
|
int ret; |
|
|
|
req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & |
|
~cdev->private->path_noirq_mask); |
|
if (!req->lpm) |
|
goto out_nopath; |
|
snid_build_cp(cdev); |
|
ccw_request_start(cdev); |
|
return; |
|
|
|
out_nopath: |
|
if (cdev->private->pgid_valid_mask) |
|
ret = 0; |
|
else if (cdev->private->path_noirq_mask) |
|
ret = -ETIME; |
|
else |
|
ret = -EACCES; |
|
snid_done(cdev, ret); |
|
} |
|
|
|
/* |
|
* Process SENSE PGID request result for single path. |
|
*/ |
|
static void snid_callback(struct ccw_device *cdev, void *data, int rc) |
|
{ |
|
struct ccw_request *req = &cdev->private->req; |
|
|
|
switch (rc) { |
|
case 0: |
|
cdev->private->pgid_valid_mask |= req->lpm; |
|
break; |
|
case -ETIME: |
|
cdev->private->flags.pgid_unknown = 1; |
|
cdev->private->path_noirq_mask |= req->lpm; |
|
break; |
|
case -EACCES: |
|
cdev->private->path_notoper_mask |= req->lpm; |
|
break; |
|
default: |
|
goto err; |
|
} |
|
/* Continue on the next path. */ |
|
req->lpm >>= 1; |
|
snid_do(cdev); |
|
return; |
|
|
|
err: |
|
snid_done(cdev, rc); |
|
} |
|
|
|
/* |
|
* Perform path verification. |
|
*/ |
|
static void verify_start(struct ccw_device *cdev) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_request *req = &cdev->private->req; |
|
struct ccw_dev_id *devid = &cdev->private->dev_id; |
|
|
|
sch->vpm = 0; |
|
sch->lpm = sch->schib.pmcw.pam; |
|
|
|
/* Initialize PGID data. */ |
|
memset(cdev->private->dma_area->pgid, 0, |
|
sizeof(cdev->private->dma_area->pgid)); |
|
cdev->private->pgid_valid_mask = 0; |
|
cdev->private->pgid_todo_mask = sch->schib.pmcw.pam; |
|
cdev->private->path_notoper_mask = 0; |
|
|
|
/* Initialize request data. */ |
|
memset(req, 0, sizeof(*req)); |
|
req->timeout = PGID_TIMEOUT; |
|
req->maxretries = PGID_RETRIES; |
|
req->lpm = 0x80; |
|
req->singlepath = 1; |
|
if (cdev->private->flags.pgroup) { |
|
CIO_TRACE_EVENT(4, "snid"); |
|
CIO_HEX_EVENT(4, devid, sizeof(*devid)); |
|
req->callback = snid_callback; |
|
snid_do(cdev); |
|
} else { |
|
CIO_TRACE_EVENT(4, "nop"); |
|
CIO_HEX_EVENT(4, devid, sizeof(*devid)); |
|
req->filter = nop_filter; |
|
req->callback = nop_callback; |
|
nop_do(cdev); |
|
} |
|
} |
|
|
|
/** |
|
* ccw_device_verify_start - perform path verification |
|
* @cdev: ccw device |
|
* |
|
* Perform an I/O on each available channel path to @cdev to determine which |
|
* paths are operational. The resulting path mask is stored in sch->vpm. |
|
* If device options specify pathgrouping, establish a pathgroup for the |
|
* operational paths. When finished, call ccw_device_verify_done with a |
|
* return code specifying the result. |
|
*/ |
|
void ccw_device_verify_start(struct ccw_device *cdev) |
|
{ |
|
CIO_TRACE_EVENT(4, "vrfy"); |
|
CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id)); |
|
/* |
|
* 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; |
|
cdev->private->path_noirq_mask = 0; |
|
verify_start(cdev); |
|
} |
|
|
|
/* |
|
* Process disband SET PGID request result. |
|
*/ |
|
static void disband_callback(struct ccw_device *cdev, void *data, int rc) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_dev_id *id = &cdev->private->dev_id; |
|
|
|
if (rc) |
|
goto out; |
|
/* Ensure consistent multipathing state at device and channel. */ |
|
cdev->private->flags.mpath = 0; |
|
if (sch->config.mp) { |
|
sch->config.mp = 0; |
|
rc = cio_commit_config(sch); |
|
} |
|
out: |
|
CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno, |
|
rc); |
|
ccw_device_disband_done(cdev, rc); |
|
} |
|
|
|
/** |
|
* ccw_device_disband_start - disband pathgroup |
|
* @cdev: ccw device |
|
* |
|
* Execute a SET PGID channel program on @cdev to disband a previously |
|
* established pathgroup. When finished, call ccw_device_disband_done with |
|
* a return code specifying the result. |
|
*/ |
|
void ccw_device_disband_start(struct ccw_device *cdev) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_request *req = &cdev->private->req; |
|
u8 fn; |
|
|
|
CIO_TRACE_EVENT(4, "disb"); |
|
CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id)); |
|
/* Request setup. */ |
|
memset(req, 0, sizeof(*req)); |
|
req->timeout = PGID_TIMEOUT; |
|
req->maxretries = PGID_RETRIES; |
|
req->lpm = sch->schib.pmcw.pam & sch->opm; |
|
req->singlepath = 1; |
|
req->callback = disband_callback; |
|
fn = SPID_FUNC_DISBAND; |
|
if (cdev->private->flags.mpath) |
|
fn |= SPID_FUNC_MULTI_PATH; |
|
spid_build_cp(cdev, fn); |
|
ccw_request_start(cdev); |
|
} |
|
|
|
struct stlck_data { |
|
struct completion done; |
|
int rc; |
|
}; |
|
|
|
static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2) |
|
{ |
|
struct ccw_request *req = &cdev->private->req; |
|
struct ccw1 *cp = cdev->private->dma_area->iccws; |
|
|
|
cp[0].cmd_code = CCW_CMD_STLCK; |
|
cp[0].cda = (u32) (addr_t) buf1; |
|
cp[0].count = 32; |
|
cp[0].flags = CCW_FLAG_CC; |
|
cp[1].cmd_code = CCW_CMD_RELEASE; |
|
cp[1].cda = (u32) (addr_t) buf2; |
|
cp[1].count = 32; |
|
cp[1].flags = 0; |
|
req->cp = cp; |
|
} |
|
|
|
static void stlck_callback(struct ccw_device *cdev, void *data, int rc) |
|
{ |
|
struct stlck_data *sdata = data; |
|
|
|
sdata->rc = rc; |
|
complete(&sdata->done); |
|
} |
|
|
|
/** |
|
* ccw_device_stlck_start - perform unconditional release |
|
* @cdev: ccw device |
|
* @data: data pointer to be passed to ccw_device_stlck_done |
|
* @buf1: data pointer used in channel program |
|
* @buf2: data pointer used in channel program |
|
* |
|
* Execute a channel program on @cdev to release an existing PGID reservation. |
|
*/ |
|
static void ccw_device_stlck_start(struct ccw_device *cdev, void *data, |
|
void *buf1, void *buf2) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct ccw_request *req = &cdev->private->req; |
|
|
|
CIO_TRACE_EVENT(4, "stlck"); |
|
CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id)); |
|
/* Request setup. */ |
|
memset(req, 0, sizeof(*req)); |
|
req->timeout = PGID_TIMEOUT; |
|
req->maxretries = PGID_RETRIES; |
|
req->lpm = sch->schib.pmcw.pam & sch->opm; |
|
req->data = data; |
|
req->callback = stlck_callback; |
|
stlck_build_cp(cdev, buf1, buf2); |
|
ccw_request_start(cdev); |
|
} |
|
|
|
/* |
|
* Perform unconditional reserve + release. |
|
*/ |
|
int ccw_device_stlck(struct ccw_device *cdev) |
|
{ |
|
struct subchannel *sch = to_subchannel(cdev->dev.parent); |
|
struct stlck_data data; |
|
u8 *buffer; |
|
int rc; |
|
|
|
/* Check if steal lock operation is valid for this device. */ |
|
if (cdev->drv) { |
|
if (!cdev->private->options.force) |
|
return -EINVAL; |
|
} |
|
buffer = kzalloc(64, GFP_DMA | GFP_KERNEL); |
|
if (!buffer) |
|
return -ENOMEM; |
|
init_completion(&data.done); |
|
data.rc = -EIO; |
|
spin_lock_irq(sch->lock); |
|
rc = cio_enable_subchannel(sch, (u32) (addr_t) sch); |
|
if (rc) |
|
goto out_unlock; |
|
/* Perform operation. */ |
|
cdev->private->state = DEV_STATE_STEAL_LOCK; |
|
ccw_device_stlck_start(cdev, &data, &buffer[0], &buffer[32]); |
|
spin_unlock_irq(sch->lock); |
|
/* Wait for operation to finish. */ |
|
if (wait_for_completion_interruptible(&data.done)) { |
|
/* Got a signal. */ |
|
spin_lock_irq(sch->lock); |
|
ccw_request_cancel(cdev); |
|
spin_unlock_irq(sch->lock); |
|
wait_for_completion(&data.done); |
|
} |
|
rc = data.rc; |
|
/* Check results. */ |
|
spin_lock_irq(sch->lock); |
|
cio_disable_subchannel(sch); |
|
cdev->private->state = DEV_STATE_BOXED; |
|
out_unlock: |
|
spin_unlock_irq(sch->lock); |
|
kfree(buffer); |
|
|
|
return rc; |
|
}
|
|
|