hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[S390] dasd: add hyper PAV support to DASD device driver, part 1 

Parallel access volumes (PAV) is a storage server feature, that allows
to start multiple channel programs on the same DASD in parallel. It
defines alias devices which can be used as alternative paths to the
same disk. With the old base PAV support we only needed rudimentary
functionality in the DASD device driver. As the mapping between base
and alias devices was static, we just had to export an identifier
(uid) and could leave the combining of devices to external layers
like a device mapper multipath.
Now hyper PAV removes the requirement to dedicate alias devices to
specific base devices. Instead each alias devices can be combined with
multiple base device on a per request basis. This requires full
support by the DASD device driver as now each channel program itself
has to identify the target base device.
The changes to the dasd device driver and the ECKD discipline are:
- Separate subchannel device representation (dasd_device) from block
  device representation (dasd_block). Only base devices are block
  devices.
- Gather information about base and alias devices and possible
  combinations.
- For each request decide which dasd_device should be used (base or
  alias) and build specific channel program.
- Support summary unit checks, which allow the storage server to
  upgrade / downgrade between base and hyper PAV at runtime (support
  is mandatory).

Signed-off-by: Stefan Weinhuber <wein@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
This commit is contained in:
Stefan Weinhuber 2008-01-26 14:11:23 +01:00 committed by Martin Schwidefsky
parent 0ac30be461
commit 8e09f21574
18 changed files with 3130 additions and 1733 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/s390/block/Makefile
View File

@ -2,8 +2,8 @@
# S/390 block devices # S/390 block devices
# #
dasd_eckd_mod-objs := dasd_eckd.o dasd_3990_erp.o dasd_9343_erp.o dasd_eckd_mod-objs := dasd_eckd.o dasd_3990_erp.o dasd_alias.o
dasd_fba_mod-objs := dasd_fba.o dasd_3370_erp.o dasd_9336_erp.o dasd_fba_mod-objs := dasd_fba.o
dasd_diag_mod-objs := dasd_diag.o dasd_diag_mod-objs := dasd_diag.o
dasd_mod-objs := dasd.o dasd_ioctl.o dasd_proc.o dasd_devmap.o \ dasd_mod-objs := dasd.o dasd_ioctl.o dasd_proc.o dasd_devmap.o \
dasd_genhd.o dasd_erp.o dasd_genhd.o dasd_erp.o

1714
drivers/s390/block/dasd.c
View File

File diff suppressed because it is too large Load Diff

84
drivers/s390/block/dasd_3370_erp.c
View File

@ -1,84 +0,0 @@
/*
* File...........: linux/drivers/s390/block/dasd_3370_erp.c
* Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
* Bugreports.to..: <Linux390@de.ibm.com>
* (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 2000
*
*/
#define PRINTK_HEADER "dasd_erp(3370)"
#include "dasd_int.h"
/*
* DASD_3370_ERP_EXAMINE
*
* DESCRIPTION
* Checks only for fatal/no/recover error.
* A detailed examination of the sense data is done later outside
* the interrupt handler.
*
* The logic is based on the 'IBM 3880 Storage Control Reference' manual
* 'Chapter 7. 3370 Sense Data'.
*
* RETURN VALUES
* dasd_era_none no error
* dasd_era_fatal for all fatal (unrecoverable errors)
* dasd_era_recover for all others.
*/
dasd_era_t
dasd_3370_erp_examine(struct dasd_ccw_req * cqr, struct irb * irb)
{
char *sense = irb->ecw;
/* check for successful execution first */
if (irb->scsw.cstat == 0x00 &&
irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END))
return dasd_era_none;
if (sense[0] & 0x80) { /* CMD reject */
return dasd_era_fatal;
}
if (sense[0] & 0x40) { /* Drive offline */
return dasd_era_recover;
}
if (sense[0] & 0x20) { /* Bus out parity */
return dasd_era_recover;
}
if (sense[0] & 0x10) { /* equipment check */
if (sense[1] & 0x80) {
return dasd_era_fatal;
}
return dasd_era_recover;
}
if (sense[0] & 0x08) { /* data check */
if (sense[1] & 0x80) {
return dasd_era_fatal;
}
return dasd_era_recover;
}
if (sense[0] & 0x04) { /* overrun */
if (sense[1] & 0x80) {
return dasd_era_fatal;
}
return dasd_era_recover;
}
if (sense[1] & 0x40) { /* invalid blocksize */
return dasd_era_fatal;
}
if (sense[1] & 0x04) { /* file protected */
return dasd_era_recover;
}
if (sense[1] & 0x01) { /* operation incomplete */
return dasd_era_recover;
}
if (sense[2] & 0x80) { /* check data erroor */
return dasd_era_recover;
}
if (sense[2] & 0x10) { /* Env. data present */
return dasd_era_recover;
}
/* examine the 24 byte sense data */
return dasd_era_recover;
} /* END dasd_3370_erp_examine */

358
drivers/s390/block/dasd_3990_erp.c
View File

@ -24,158 +24,6 @@ struct DCTL_data {
unsigned short res; /* reserved */ unsigned short res; /* reserved */
} __attribute__ ((packed)); } __attribute__ ((packed));
/*
*****************************************************************************
* SECTION ERP EXAMINATION
*****************************************************************************
*/
/*
* DASD_3990_ERP_EXAMINE_24
*
* DESCRIPTION
* Checks only for fatal (unrecoverable) error.
* A detailed examination of the sense data is done later outside
* the interrupt handler.
*
* Each bit configuration leading to an action code 2 (Exit with
* programming error or unusual condition indication)
* are handled as fatal errors.
*
* All other configurations are handled as recoverable errors.
*
* RETURN VALUES
* dasd_era_fatal for all fatal (unrecoverable errors)
* dasd_era_recover for all others.
*/
static dasd_era_t
dasd_3990_erp_examine_24(struct dasd_ccw_req * cqr, char *sense)
{
struct dasd_device *device = cqr->device;
/* check for 'Command Reject' */
if ((sense[0] & SNS0_CMD_REJECT) &&
(!(sense[2] & SNS2_ENV_DATA_PRESENT))) {
DEV_MESSAGE(KERN_ERR, device, "%s",
"EXAMINE 24: Command Reject detected - "
"fatal error");
return dasd_era_fatal;
}
/* check for 'Invalid Track Format' */
if ((sense[1] & SNS1_INV_TRACK_FORMAT) &&
(!(sense[2] & SNS2_ENV_DATA_PRESENT))) {
DEV_MESSAGE(KERN_ERR, device, "%s",
"EXAMINE 24: Invalid Track Format detected "
"- fatal error");
return dasd_era_fatal;
}
/* check for 'No Record Found' */
if (sense[1] & SNS1_NO_REC_FOUND) {
/* FIXME: fatal error ?!? */
DEV_MESSAGE(KERN_ERR, device,
"EXAMINE 24: No Record Found detected %s",
device->state <= DASD_STATE_BASIC ?
" " : "- fatal error");
return dasd_era_fatal;
}
/* return recoverable for all others */
return dasd_era_recover;
} /* END dasd_3990_erp_examine_24 */
/*
* DASD_3990_ERP_EXAMINE_32
*
* DESCRIPTION
* Checks only for fatal/no/recoverable error.
* A detailed examination of the sense data is done later outside
* the interrupt handler.
*
* RETURN VALUES
* dasd_era_none no error
* dasd_era_fatal for all fatal (unrecoverable errors)
* dasd_era_recover for recoverable others.
*/
static dasd_era_t
dasd_3990_erp_examine_32(struct dasd_ccw_req * cqr, char *sense)
{
struct dasd_device *device = cqr->device;
switch (sense[25]) {
case 0x00:
return dasd_era_none;
case 0x01:
DEV_MESSAGE(KERN_ERR, device, "%s", "EXAMINE 32: fatal error");
return dasd_era_fatal;
default:
return dasd_era_recover;
}
} /* end dasd_3990_erp_examine_32 */
/*
* DASD_3990_ERP_EXAMINE
*
* DESCRIPTION
* Checks only for fatal/no/recover error.
* A detailed examination of the sense data is done later outside
* the interrupt handler.
*
* The logic is based on the 'IBM 3990 Storage Control Reference' manual
* 'Chapter 7. Error Recovery Procedures'.
*
* RETURN VALUES
* dasd_era_none no error
* dasd_era_fatal for all fatal (unrecoverable errors)
* dasd_era_recover for all others.
*/
dasd_era_t
dasd_3990_erp_examine(struct dasd_ccw_req * cqr, struct irb * irb)
{
char *sense = irb->ecw;
dasd_era_t era = dasd_era_recover;
struct dasd_device *device = cqr->device;
/* check for successful execution first */
if (irb->scsw.cstat == 0x00 &&
irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END))
return dasd_era_none;
/* distinguish between 24 and 32 byte sense data */
if (sense[27] & DASD_SENSE_BIT_0) {
era = dasd_3990_erp_examine_24(cqr, sense);
} else {
era = dasd_3990_erp_examine_32(cqr, sense);
}
/* log the erp chain if fatal error occurred */
if ((era == dasd_era_fatal) && (device->state >= DASD_STATE_READY)) {
dasd_log_sense(cqr, irb);
}
return era;
} /* END dasd_3990_erp_examine */
/* /*
***************************************************************************** *****************************************************************************
* SECTION ERP HANDLING * SECTION ERP HANDLING
@ -206,7 +54,7 @@ dasd_3990_erp_cleanup(struct dasd_ccw_req * erp, char final_status)
{ {
struct dasd_ccw_req *cqr = erp->refers; struct dasd_ccw_req *cqr = erp->refers;
dasd_free_erp_request(erp, erp->device); dasd_free_erp_request(erp, erp->memdev);
cqr->status = final_status; cqr->status = final_status;
return cqr; return cqr;
@ -224,15 +72,17 @@ static void
dasd_3990_erp_block_queue(struct dasd_ccw_req * erp, int expires) dasd_3990_erp_block_queue(struct dasd_ccw_req * erp, int expires)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
unsigned long flags;
DEV_MESSAGE(KERN_INFO, device, DEV_MESSAGE(KERN_INFO, device,
"blocking request queue for %is", expires/HZ); "blocking request queue for %is", expires/HZ);
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
device->stopped |= DASD_STOPPED_PENDING; device->stopped |= DASD_STOPPED_PENDING;
erp->status = DASD_CQR_QUEUED; spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
erp->status = DASD_CQR_FILLED;
dasd_set_timer(device, expires); dasd_block_set_timer(device->block, expires);
} }
/* /*
@ -251,7 +101,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_int_req(struct dasd_ccw_req * erp) dasd_3990_erp_int_req(struct dasd_ccw_req * erp)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
/* first time set initial retry counter and erp_function */ /* first time set initial retry counter and erp_function */
/* and retry once without blocking queue */ /* and retry once without blocking queue */
@ -292,11 +142,14 @@ dasd_3990_erp_int_req(struct dasd_ccw_req * erp)
static void static void
dasd_3990_erp_alternate_path(struct dasd_ccw_req * erp) dasd_3990_erp_alternate_path(struct dasd_ccw_req * erp)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
__u8 opm; __u8 opm;
unsigned long flags;
/* try alternate valid path */ /* try alternate valid path */
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
opm = ccw_device_get_path_mask(device->cdev); opm = ccw_device_get_path_mask(device->cdev);
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
//FIXME: start with get_opm ? //FIXME: start with get_opm ?
if (erp->lpm == 0) if (erp->lpm == 0)
erp->lpm = LPM_ANYPATH & ~(erp->irb.esw.esw0.sublog.lpum); erp->lpm = LPM_ANYPATH & ~(erp->irb.esw.esw0.sublog.lpum);
@ -309,9 +162,8 @@ dasd_3990_erp_alternate_path(struct dasd_ccw_req * erp)
"try alternate lpm=%x (lpum=%x / opm=%x)", "try alternate lpm=%x (lpum=%x / opm=%x)",
erp->lpm, erp->irb.esw.esw0.sublog.lpum, opm); erp->lpm, erp->irb.esw.esw0.sublog.lpum, opm);
/* reset status to queued to handle the request again... */ /* reset status to submit the request again... */
if (erp->status > DASD_CQR_QUEUED) erp->status = DASD_CQR_FILLED;
erp->status = DASD_CQR_QUEUED;
erp->retries = 1; erp->retries = 1;
} else { } else {
DEV_MESSAGE(KERN_ERR, device, DEV_MESSAGE(KERN_ERR, device,
@ -320,8 +172,7 @@ dasd_3990_erp_alternate_path(struct dasd_ccw_req * erp)
erp->irb.esw.esw0.sublog.lpum, opm); erp->irb.esw.esw0.sublog.lpum, opm);
/* post request with permanent error */ /* post request with permanent error */
if (erp->status > DASD_CQR_QUEUED) erp->status = DASD_CQR_FAILED;
erp->status = DASD_CQR_FAILED;
} }
} /* end dasd_3990_erp_alternate_path */ } /* end dasd_3990_erp_alternate_path */
@ -344,14 +195,14 @@ static struct dasd_ccw_req *
dasd_3990_erp_DCTL(struct dasd_ccw_req * erp, char modifier) dasd_3990_erp_DCTL(struct dasd_ccw_req * erp, char modifier)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
struct DCTL_data *DCTL_data; struct DCTL_data *DCTL_data;
struct ccw1 *ccw; struct ccw1 *ccw;
struct dasd_ccw_req *dctl_cqr; struct dasd_ccw_req *dctl_cqr;
dctl_cqr = dasd_alloc_erp_request((char *) &erp->magic, 1, dctl_cqr = dasd_alloc_erp_request((char *) &erp->magic, 1,
sizeof (struct DCTL_data), sizeof(struct DCTL_data),
erp->device); device);
if (IS_ERR(dctl_cqr)) { if (IS_ERR(dctl_cqr)) {
DEV_MESSAGE(KERN_ERR, device, "%s", DEV_MESSAGE(KERN_ERR, device, "%s",
"Unable to allocate DCTL-CQR"); "Unable to allocate DCTL-CQR");
@ -365,13 +216,14 @@ dasd_3990_erp_DCTL(struct dasd_ccw_req * erp, char modifier)
DCTL_data->modifier = modifier; DCTL_data->modifier = modifier;
ccw = dctl_cqr->cpaddr; ccw = dctl_cqr->cpaddr;
memset(ccw, 0, sizeof (struct ccw1)); memset(ccw, 0, sizeof(struct ccw1));
ccw->cmd_code = CCW_CMD_DCTL; ccw->cmd_code = CCW_CMD_DCTL;
ccw->count = 4; ccw->count = 4;
ccw->cda = (__u32)(addr_t) DCTL_data; ccw->cda = (__u32)(addr_t) DCTL_data;
dctl_cqr->function = dasd_3990_erp_DCTL; dctl_cqr->function = dasd_3990_erp_DCTL;
dctl_cqr->refers = erp; dctl_cqr->refers = erp;
dctl_cqr->device = erp->device; dctl_cqr->startdev = device;
dctl_cqr->memdev = device;
dctl_cqr->magic = erp->magic; dctl_cqr->magic = erp->magic;
dctl_cqr->expires = 5 * 60 * HZ; dctl_cqr->expires = 5 * 60 * HZ;
dctl_cqr->retries = 2; dctl_cqr->retries = 2;
@ -435,7 +287,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_action_4(struct dasd_ccw_req * erp, char *sense) dasd_3990_erp_action_4(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
/* first time set initial retry counter and erp_function */ /* first time set initial retry counter and erp_function */
/* and retry once without waiting for state change pending */ /* and retry once without waiting for state change pending */
@ -472,7 +324,7 @@ dasd_3990_erp_action_4(struct dasd_ccw_req * erp, char *sense)
"redriving request immediately, " "redriving request immediately, "
"%d retries left", "%d retries left",
erp->retries); erp->retries);
erp->status = DASD_CQR_QUEUED; erp->status = DASD_CQR_FILLED;
} }
} }
@ -530,7 +382,7 @@ static void
dasd_3990_handle_env_data(struct dasd_ccw_req * erp, char *sense) dasd_3990_handle_env_data(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
char msg_format = (sense[7] & 0xF0); char msg_format = (sense[7] & 0xF0);
char msg_no = (sense[7] & 0x0F); char msg_no = (sense[7] & 0x0F);
@ -1157,7 +1009,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_com_rej(struct dasd_ccw_req * erp, char *sense) dasd_3990_erp_com_rej(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
erp->function = dasd_3990_erp_com_rej; erp->function = dasd_3990_erp_com_rej;
@ -1198,7 +1050,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_bus_out(struct dasd_ccw_req * erp) dasd_3990_erp_bus_out(struct dasd_ccw_req * erp)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
/* first time set initial retry counter and erp_function */ /* first time set initial retry counter and erp_function */
/* and retry once without blocking queue */ /* and retry once without blocking queue */
@ -1237,7 +1089,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_equip_check(struct dasd_ccw_req * erp, char *sense) dasd_3990_erp_equip_check(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
erp->function = dasd_3990_erp_equip_check; erp->function = dasd_3990_erp_equip_check;
@ -1279,7 +1131,6 @@ dasd_3990_erp_equip_check(struct dasd_ccw_req * erp, char *sense)
erp = dasd_3990_erp_action_5(erp); erp = dasd_3990_erp_action_5(erp);
} }
return erp; return erp;
} /* end dasd_3990_erp_equip_check */ } /* end dasd_3990_erp_equip_check */
@ -1299,7 +1150,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_data_check(struct dasd_ccw_req * erp, char *sense) dasd_3990_erp_data_check(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
erp->function = dasd_3990_erp_data_check; erp->function = dasd_3990_erp_data_check;
@ -1358,7 +1209,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_overrun(struct dasd_ccw_req * erp, char *sense) dasd_3990_erp_overrun(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
erp->function = dasd_3990_erp_overrun; erp->function = dasd_3990_erp_overrun;
@ -1387,7 +1238,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_inv_format(struct dasd_ccw_req * erp, char *sense) dasd_3990_erp_inv_format(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
erp->function = dasd_3990_erp_inv_format; erp->function = dasd_3990_erp_inv_format;
@ -1403,8 +1254,7 @@ dasd_3990_erp_inv_format(struct dasd_ccw_req * erp, char *sense)
} else { } else {
DEV_MESSAGE(KERN_ERR, device, "%s", DEV_MESSAGE(KERN_ERR, device, "%s",
"Invalid Track Format - Fatal error should have " "Invalid Track Format - Fatal error");
"been handled within the interrupt handler");
erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED); erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
} }
@ -1428,7 +1278,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_EOC(struct dasd_ccw_req * default_erp, char *sense) dasd_3990_erp_EOC(struct dasd_ccw_req * default_erp, char *sense)
{ {
struct dasd_device *device = default_erp->device; struct dasd_device *device = default_erp->startdev;
DEV_MESSAGE(KERN_ERR, device, "%s", DEV_MESSAGE(KERN_ERR, device, "%s",
"End-of-Cylinder - must never happen"); "End-of-Cylinder - must never happen");
@ -1453,7 +1303,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_env_data(struct dasd_ccw_req * erp, char *sense) dasd_3990_erp_env_data(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
erp->function = dasd_3990_erp_env_data; erp->function = dasd_3990_erp_env_data;
@ -1463,11 +1313,9 @@ dasd_3990_erp_env_data(struct dasd_ccw_req * erp, char *sense)
/* don't retry on disabled interface */ /* don't retry on disabled interface */
if (sense[7] != 0x0F) { if (sense[7] != 0x0F) {
erp = dasd_3990_erp_action_4(erp, sense); erp = dasd_3990_erp_action_4(erp, sense);
} else { } else {
erp->status = DASD_CQR_FILLED;
erp = dasd_3990_erp_cleanup(erp, DASD_CQR_IN_IO);
} }
return erp; return erp;
@ -1490,11 +1338,10 @@ static struct dasd_ccw_req *
dasd_3990_erp_no_rec(struct dasd_ccw_req * default_erp, char *sense) dasd_3990_erp_no_rec(struct dasd_ccw_req * default_erp, char *sense)
{ {
struct dasd_device *device = default_erp->device; struct dasd_device *device = default_erp->startdev;
DEV_MESSAGE(KERN_ERR, device, "%s", DEV_MESSAGE(KERN_ERR, device, "%s",
"No Record Found - Fatal error should " "No Record Found - Fatal error ");
"have been handled within the interrupt handler");
return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED); return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
@ -1517,7 +1364,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_file_prot(struct dasd_ccw_req * erp) dasd_3990_erp_file_prot(struct dasd_ccw_req * erp)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
DEV_MESSAGE(KERN_ERR, device, "%s", "File Protected"); DEV_MESSAGE(KERN_ERR, device, "%s", "File Protected");
@ -1525,6 +1372,43 @@ dasd_3990_erp_file_prot(struct dasd_ccw_req * erp)
} /* end dasd_3990_erp_file_prot */ } /* end dasd_3990_erp_file_prot */
/*
* DASD_3990_ERP_INSPECT_ALIAS
*
* DESCRIPTION
* Checks if the original request was started on an alias device.
* If yes, it modifies the original and the erp request so that
* the erp request can be started on a base device.
*
* PARAMETER
* erp pointer to the currently created default ERP
*
* RETURN VALUES
* erp pointer to the modified ERP, or NULL
*/
static struct dasd_ccw_req *dasd_3990_erp_inspect_alias(
struct dasd_ccw_req *erp)
{
struct dasd_ccw_req *cqr = erp->refers;
if (cqr->block &&
(cqr->block->base != cqr->startdev)) {
if (cqr->startdev->features & DASD_FEATURE_ERPLOG) {
DEV_MESSAGE(KERN_ERR, cqr->startdev,
"ERP on alias device for request %p,"
" recover on base device %s", cqr,
cqr->block->base->cdev->dev.bus_id);
}
dasd_eckd_reset_ccw_to_base_io(cqr);
erp->startdev = cqr->block->base;
erp->function = dasd_3990_erp_inspect_alias;
return erp;
} else
return NULL;
}
/* /*
* DASD_3990_ERP_INSPECT_24 * DASD_3990_ERP_INSPECT_24
* *
@ -1623,7 +1507,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_action_10_32(struct dasd_ccw_req * erp, char *sense) dasd_3990_erp_action_10_32(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
erp->retries = 256; erp->retries = 256;
erp->function = dasd_3990_erp_action_10_32; erp->function = dasd_3990_erp_action_10_32;
@ -1657,13 +1541,14 @@ static struct dasd_ccw_req *
dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense) dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
{ {
struct dasd_device *device = default_erp->device; struct dasd_device *device = default_erp->startdev;
__u32 cpa = 0; __u32 cpa = 0;
struct dasd_ccw_req *cqr; struct dasd_ccw_req *cqr;
struct dasd_ccw_req *erp; struct dasd_ccw_req *erp;
struct DE_eckd_data *DE_data; struct DE_eckd_data *DE_data;
struct PFX_eckd_data *PFX_data;
char *LO_data; /* LO_eckd_data_t */ char *LO_data; /* LO_eckd_data_t */
struct ccw1 *ccw; struct ccw1 *ccw, *oldccw;
DEV_MESSAGE(KERN_DEBUG, device, "%s", DEV_MESSAGE(KERN_DEBUG, device, "%s",
"Write not finished because of unexpected condition"); "Write not finished because of unexpected condition");
@ -1702,8 +1587,8 @@ dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
/* Build new ERP request including DE/LO */ /* Build new ERP request including DE/LO */
erp = dasd_alloc_erp_request((char *) &cqr->magic, erp = dasd_alloc_erp_request((char *) &cqr->magic,
2 + 1,/* DE/LO + TIC */ 2 + 1,/* DE/LO + TIC */
sizeof (struct DE_eckd_data) + sizeof(struct DE_eckd_data) +
sizeof (struct LO_eckd_data), device); sizeof(struct LO_eckd_data), device);
if (IS_ERR(erp)) { if (IS_ERR(erp)) {
DEV_MESSAGE(KERN_ERR, device, "%s", "Unable to allocate ERP"); DEV_MESSAGE(KERN_ERR, device, "%s", "Unable to allocate ERP");
@ -1712,10 +1597,16 @@ dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
/* use original DE */ /* use original DE */
DE_data = erp->data; DE_data = erp->data;
memcpy(DE_data, cqr->data, sizeof (struct DE_eckd_data)); oldccw = cqr->cpaddr;
if (oldccw->cmd_code == DASD_ECKD_CCW_PFX) {
PFX_data = cqr->data;
memcpy(DE_data, &PFX_data->define_extend,
sizeof(struct DE_eckd_data));
} else
memcpy(DE_data, cqr->data, sizeof(struct DE_eckd_data));
/* create LO */ /* create LO */
LO_data = erp->data + sizeof (struct DE_eckd_data); LO_data = erp->data + sizeof(struct DE_eckd_data);
if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) { if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
@ -1748,7 +1639,7 @@ dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
/* create DE ccw */ /* create DE ccw */
ccw = erp->cpaddr; ccw = erp->cpaddr;
memset(ccw, 0, sizeof (struct ccw1)); memset(ccw, 0, sizeof(struct ccw1));
ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT; ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT;
ccw->flags = CCW_FLAG_CC; ccw->flags = CCW_FLAG_CC;
ccw->count = 16; ccw->count = 16;
@ -1756,7 +1647,7 @@ dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
/* create LO ccw */ /* create LO ccw */
ccw++; ccw++;
memset(ccw, 0, sizeof (struct ccw1)); memset(ccw, 0, sizeof(struct ccw1));
ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD; ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD;
ccw->flags = CCW_FLAG_CC; ccw->flags = CCW_FLAG_CC;
ccw->count = 16; ccw->count = 16;
@ -1770,7 +1661,8 @@ dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
/* fill erp related fields */ /* fill erp related fields */
erp->function = dasd_3990_erp_action_1B_32; erp->function = dasd_3990_erp_action_1B_32;
erp->refers = default_erp->refers; erp->refers = default_erp->refers;
erp->device = device; erp->startdev = device;
erp->memdev = device;
erp->magic = default_erp->magic; erp->magic = default_erp->magic;
erp->expires = 0; erp->expires = 0;
erp->retries = 256; erp->retries = 256;
@ -1803,7 +1695,7 @@ static struct dasd_ccw_req *
dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense) dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense)
{ {
struct dasd_device *device = previous_erp->device; struct dasd_device *device = previous_erp->startdev;
__u32 cpa = 0; __u32 cpa = 0;
struct dasd_ccw_req *cqr; struct dasd_ccw_req *cqr;
struct dasd_ccw_req *erp; struct dasd_ccw_req *erp;
@ -1827,7 +1719,7 @@ dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense)
DEV_MESSAGE(KERN_DEBUG, device, "%s", DEV_MESSAGE(KERN_DEBUG, device, "%s",
"Imprecise ending is set - just retry"); "Imprecise ending is set - just retry");
previous_erp->status = DASD_CQR_QUEUED; previous_erp->status = DASD_CQR_FILLED;
return previous_erp; return previous_erp;
} }
@ -1850,7 +1742,7 @@ dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense)
erp = previous_erp; erp = previous_erp;
/* update the LO with the new returned sense data */ /* update the LO with the new returned sense data */
LO_data = erp->data + sizeof (struct DE_eckd_data); LO_data = erp->data + sizeof(struct DE_eckd_data);
if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) { if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
@ -1889,7 +1781,7 @@ dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense)
ccw++; /* addr of TIC ccw */ ccw++; /* addr of TIC ccw */
ccw->cda = cpa; ccw->cda = cpa;
erp->status = DASD_CQR_QUEUED; erp->status = DASD_CQR_FILLED;
return erp; return erp;
@ -1968,9 +1860,7 @@ dasd_3990_erp_compound_path(struct dasd_ccw_req * erp, char *sense)
* try further actions. */ * try further actions. */
erp->lpm = 0; erp->lpm = 0;
erp->status = DASD_CQR_NEED_ERP;
erp->status = DASD_CQR_ERROR;
} }
} }
@ -2047,7 +1937,7 @@ dasd_3990_erp_compound_config(struct dasd_ccw_req * erp, char *sense)
if ((sense[25] & DASD_SENSE_BIT_1) && (sense[26] & DASD_SENSE_BIT_2)) { if ((sense[25] & DASD_SENSE_BIT_1) && (sense[26] & DASD_SENSE_BIT_2)) {
/* set to suspended duplex state then restart */ /* set to suspended duplex state then restart */
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
DEV_MESSAGE(KERN_ERR, device, "%s", DEV_MESSAGE(KERN_ERR, device, "%s",
"Set device to suspended duplex state should be " "Set device to suspended duplex state should be "
@ -2081,28 +1971,26 @@ dasd_3990_erp_compound(struct dasd_ccw_req * erp, char *sense)
{ {
if ((erp->function == dasd_3990_erp_compound_retry) && if ((erp->function == dasd_3990_erp_compound_retry) &&
(erp->status == DASD_CQR_ERROR)) { (erp->status == DASD_CQR_NEED_ERP)) {
dasd_3990_erp_compound_path(erp, sense); dasd_3990_erp_compound_path(erp, sense);
} }
if ((erp->function == dasd_3990_erp_compound_path) && if ((erp->function == dasd_3990_erp_compound_path) &&
(erp->status == DASD_CQR_ERROR)) { (erp->status == DASD_CQR_NEED_ERP)) {
erp = dasd_3990_erp_compound_code(erp, sense); erp = dasd_3990_erp_compound_code(erp, sense);
} }
if ((erp->function == dasd_3990_erp_compound_code) && if ((erp->function == dasd_3990_erp_compound_code) &&
(erp->status == DASD_CQR_ERROR)) { (erp->status == DASD_CQR_NEED_ERP)) {
dasd_3990_erp_compound_config(erp, sense); dasd_3990_erp_compound_config(erp, sense);
} }
/* if no compound action ERP specified, the request failed */ /* if no compound action ERP specified, the request failed */
if (erp->status == DASD_CQR_ERROR) { if (erp->status == DASD_CQR_NEED_ERP)
erp->status = DASD_CQR_FAILED; erp->status = DASD_CQR_FAILED;
}
return erp; return erp;
@ -2127,7 +2015,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense) dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
erp->function = dasd_3990_erp_inspect_32; erp->function = dasd_3990_erp_inspect_32;
@ -2149,8 +2037,7 @@ dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense)
case 0x01: /* fatal error */ case 0x01: /* fatal error */
DEV_MESSAGE(KERN_ERR, device, "%s", DEV_MESSAGE(KERN_ERR, device, "%s",
"Fatal error should have been " "Retry not recommended - Fatal error");
"handled within the interrupt handler");
erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED); erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
break; break;
@ -2253,6 +2140,11 @@ dasd_3990_erp_inspect(struct dasd_ccw_req * erp)
/* already set up new ERP ! */ /* already set up new ERP ! */
char *sense = erp->refers->irb.ecw; char *sense = erp->refers->irb.ecw;
/* if this problem occured on an alias retry on base */
erp_new = dasd_3990_erp_inspect_alias(erp);
if (erp_new)
return erp_new;
/* distinguish between 24 and 32 byte sense data */ /* distinguish between 24 and 32 byte sense data */
if (sense[27] & DASD_SENSE_BIT_0) { if (sense[27] & DASD_SENSE_BIT_0) {
@ -2287,13 +2179,13 @@ static struct dasd_ccw_req *
dasd_3990_erp_add_erp(struct dasd_ccw_req * cqr) dasd_3990_erp_add_erp(struct dasd_ccw_req * cqr)
{ {
struct dasd_device *device = cqr->device; struct dasd_device *device = cqr->startdev;
struct ccw1 *ccw; struct ccw1 *ccw;
/* allocate additional request block */ /* allocate additional request block */
struct dasd_ccw_req *erp; struct dasd_ccw_req *erp;
erp = dasd_alloc_erp_request((char *) &cqr->magic, 2, 0, cqr->device); erp = dasd_alloc_erp_request((char *) &cqr->magic, 2, 0, device);
if (IS_ERR(erp)) { if (IS_ERR(erp)) {
if (cqr->retries <= 0) { if (cqr->retries <= 0) {
DEV_MESSAGE(KERN_ERR, device, "%s", DEV_MESSAGE(KERN_ERR, device, "%s",
@ -2305,7 +2197,7 @@ dasd_3990_erp_add_erp(struct dasd_ccw_req * cqr)
"Unable to allocate ERP request " "Unable to allocate ERP request "
"(%i retries left)", "(%i retries left)",
cqr->retries); cqr->retries);
dasd_set_timer(device, (HZ << 3)); dasd_block_set_timer(device->block, (HZ << 3));
} }
return cqr; return cqr;
} }
@ -2319,7 +2211,9 @@ dasd_3990_erp_add_erp(struct dasd_ccw_req * cqr)
ccw->cda = (long)(cqr->cpaddr); ccw->cda = (long)(cqr->cpaddr);
erp->function = dasd_3990_erp_add_erp; erp->function = dasd_3990_erp_add_erp;
erp->refers = cqr; erp->refers = cqr;
erp->device = cqr->device; erp->startdev = device;
erp->memdev = device;
erp->block = cqr->block;
erp->magic = cqr->magic; erp->magic = cqr->magic;
erp->expires = 0; erp->expires = 0;
erp->retries = 256; erp->retries = 256;
@ -2466,7 +2360,7 @@ static struct dasd_ccw_req *
dasd_3990_erp_further_erp(struct dasd_ccw_req *erp) dasd_3990_erp_further_erp(struct dasd_ccw_req *erp)
{ {
struct dasd_device *device = erp->device; struct dasd_device *device = erp->startdev;
char *sense = erp->irb.ecw; char *sense = erp->irb.ecw;
/* check for 24 byte sense ERP */ /* check for 24 byte sense ERP */
@ -2557,7 +2451,7 @@ dasd_3990_erp_handle_match_erp(struct dasd_ccw_req *erp_head,
struct dasd_ccw_req *erp) struct dasd_ccw_req *erp)
{ {
struct dasd_device *device = erp_head->device; struct dasd_device *device = erp_head->startdev;
struct dasd_ccw_req *erp_done = erp_head; /* finished req */ struct dasd_ccw_req *erp_done = erp_head; /* finished req */
struct dasd_ccw_req *erp_free = NULL; /* req to be freed */ struct dasd_ccw_req *erp_free = NULL; /* req to be freed */
@ -2569,13 +2463,13 @@ dasd_3990_erp_handle_match_erp(struct dasd_ccw_req *erp_head,
"original request was lost\n"); "original request was lost\n");
/* remove the request from the device queue */ /* remove the request from the device queue */
list_del(&erp_done->list); list_del(&erp_done->blocklist);
erp_free = erp_done; erp_free = erp_done;
erp_done = erp_done->refers; erp_done = erp_done->refers;
/* free the finished erp request */ /* free the finished erp request */
dasd_free_erp_request(erp_free, erp_free->device); dasd_free_erp_request(erp_free, erp_free->memdev);
} /* end while */ } /* end while */
@ -2603,7 +2497,7 @@ dasd_3990_erp_handle_match_erp(struct dasd_ccw_req *erp_head,
erp->retries, erp); erp->retries, erp);
/* handle the request again... */ /* handle the request again... */
erp->status = DASD_CQR_QUEUED; erp->status = DASD_CQR_FILLED;
} }
} else { } else {
@ -2636,9 +2530,8 @@ dasd_3990_erp_handle_match_erp(struct dasd_ccw_req *erp_head,
struct dasd_ccw_req * struct dasd_ccw_req *
dasd_3990_erp_action(struct dasd_ccw_req * cqr) dasd_3990_erp_action(struct dasd_ccw_req * cqr)
{ {
struct dasd_ccw_req *erp = NULL; struct dasd_ccw_req *erp = NULL;
struct dasd_device *device = cqr->device; struct dasd_device *device = cqr->startdev;
struct dasd_ccw_req *temp_erp = NULL; struct dasd_ccw_req *temp_erp = NULL;
if (device->features & DASD_FEATURE_ERPLOG) { if (device->features & DASD_FEATURE_ERPLOG) {
@ -2704,10 +2597,11 @@ dasd_3990_erp_action(struct dasd_ccw_req * cqr)
} }
} }
/* enqueue added ERP request */ /* enqueue ERP request if it's a new one */
if (erp->status == DASD_CQR_FILLED) { if (list_empty(&erp->blocklist)) {
erp->status = DASD_CQR_QUEUED; cqr->status = DASD_CQR_IN_ERP;
list_add(&erp->list, &device->ccw_queue); /* add erp request before the cqr */
list_add_tail(&erp->blocklist, &cqr->blocklist);
} }
return erp; return erp;

41
drivers/s390/block/dasd_9336_erp.c
View File

@ -1,41 +0,0 @@
/*
* File...........: linux/drivers/s390/block/dasd_9336_erp.c
* Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
* Bugreports.to..: <Linux390@de.ibm.com>
* (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 2000
*
*/
#define PRINTK_HEADER "dasd_erp(9336)"
#include "dasd_int.h"
/*
* DASD_9336_ERP_EXAMINE
*
* DESCRIPTION
* Checks only for fatal/no/recover error.
* A detailed examination of the sense data is done later outside
* the interrupt handler.
*
* The logic is based on the 'IBM 3880 Storage Control Reference' manual
* 'Chapter 7. 9336 Sense Data'.
*
* RETURN VALUES
* dasd_era_none no error
* dasd_era_fatal for all fatal (unrecoverable errors)
* dasd_era_recover for all others.
*/
dasd_era_t
dasd_9336_erp_examine(struct dasd_ccw_req * cqr, struct irb * irb)
{
/* check for successful execution first */
if (irb->scsw.cstat == 0x00 &&
irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END))
return dasd_era_none;
/* examine the 24 byte sense data */
return dasd_era_recover;
} /* END dasd_9336_erp_examine */

21
drivers/s390/block/dasd_9343_erp.c
View File

@ -1,21 +0,0 @@
/*
* File...........: linux/drivers/s390/block/dasd_9345_erp.c
* Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
* Bugreports.to..: <Linux390@de.ibm.com>
* (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 2000
*
*/
#define PRINTK_HEADER "dasd_erp(9343)"
#include "dasd_int.h"
dasd_era_t
dasd_9343_erp_examine(struct dasd_ccw_req * cqr, struct irb * irb)
{
if (irb->scsw.cstat == 0x00 &&
irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END))
return dasd_era_none;
return dasd_era_recover;
}

903
drivers/s390/block/dasd_alias.c Normal file
View File

@ -0,0 +1,903 @@
/*
* PAV alias management for the DASD ECKD discipline
*
* Copyright IBM Corporation, 2007
* Author(s): Stefan Weinhuber <wein@de.ibm.com>
*/
#include <linux/list.h>
#include <asm/ebcdic.h>
#include "dasd_int.h"
#include "dasd_eckd.h"
#ifdef PRINTK_HEADER
#undef PRINTK_HEADER
#endif /* PRINTK_HEADER */
#define PRINTK_HEADER "dasd(eckd):"
/*
* General concept of alias management:
* - PAV and DASD alias management is specific to the eckd discipline.
* - A device is connected to an lcu as long as the device exists.
* dasd_alias_make_device_known_to_lcu will be called wenn the
* device is checked by the eckd discipline and
* dasd_alias_disconnect_device_from_lcu will be called
* before the device is deleted.
* - The dasd_alias_add_device / dasd_alias_remove_device
* functions mark the point when a device is 'ready for service'.
* - A summary unit check is a rare occasion, but it is mandatory to
* support it. It requires some complex recovery actions before the
* devices can be used again (see dasd_alias_handle_summary_unit_check).
* - dasd_alias_get_start_dev will find an alias device that can be used
* instead of the base device and does some (very simple) load balancing.
* This is the function that gets called for each I/O, so when improving
* something, this function should get faster or better, the rest has just
* to be correct.
*/
static void summary_unit_check_handling_work(struct work_struct *);
static void lcu_update_work(struct work_struct *);
static int _schedule_lcu_update(struct alias_lcu *, struct dasd_device *);
static struct alias_root aliastree = {
.serverlist = LIST_HEAD_INIT(aliastree.serverlist),
.lock = __SPIN_LOCK_UNLOCKED(aliastree.lock),
};
static struct alias_server *_find_server(struct dasd_uid *uid)
{
struct alias_server *pos;
list_for_each_entry(pos, &aliastree.serverlist, server) {
if (!strncmp(pos->uid.vendor, uid->vendor,
sizeof(uid->vendor))
&& !strncmp(pos->uid.serial, uid->serial,
sizeof(uid->serial)))
return pos;
};
return NULL;
}
static struct alias_lcu *_find_lcu(struct alias_server *server,
struct dasd_uid *uid)
{
struct alias_lcu *pos;
list_for_each_entry(pos, &server->lculist, lcu) {
if (pos->uid.ssid == uid->ssid)
return pos;
};
return NULL;
}
static struct alias_pav_group *_find_group(struct alias_lcu *lcu,
struct dasd_uid *uid)
{
struct alias_pav_group *pos;
__u8 search_unit_addr;
/* for hyper pav there is only one group */
if (lcu->pav == HYPER_PAV) {
if (list_empty(&lcu->grouplist))
return NULL;
else
return list_first_entry(&lcu->grouplist,
struct alias_pav_group, group);
}
/* for base pav we have to find the group that matches the base */
if (uid->type == UA_BASE_DEVICE)
search_unit_addr = uid->real_unit_addr;
else
search_unit_addr = uid->base_unit_addr;
list_for_each_entry(pos, &lcu->grouplist, group) {
if (pos->uid.base_unit_addr == search_unit_addr)
return pos;
};
return NULL;
}
static struct alias_server *_allocate_server(struct dasd_uid *uid)
{
struct alias_server *server;
server = kzalloc(sizeof(*server), GFP_KERNEL);
if (!server)
return ERR_PTR(-ENOMEM);
memcpy(server->uid.vendor, uid->vendor, sizeof(uid->vendor));
memcpy(server->uid.serial, uid->serial, sizeof(uid->serial));
INIT_LIST_HEAD(&server->server);
INIT_LIST_HEAD(&server->lculist);
return server;
}
static void _free_server(struct alias_server *server)
{
kfree(server);
}
static struct alias_lcu *_allocate_lcu(struct dasd_uid *uid)
{
struct alias_lcu *lcu;
lcu = kzalloc(sizeof(*lcu), GFP_KERNEL);
if (!lcu)
return ERR_PTR(-ENOMEM);
lcu->uac = kzalloc(sizeof(*(lcu->uac)), GFP_KERNEL | GFP_DMA);
if (!lcu->uac)
goto out_err1;
lcu->rsu_cqr = kzalloc(sizeof(*lcu->rsu_cqr), GFP_KERNEL | GFP_DMA);
if (!lcu->rsu_cqr)
goto out_err2;
lcu->rsu_cqr->cpaddr = kzalloc(sizeof(struct ccw1),
GFP_KERNEL | GFP_DMA);
if (!lcu->rsu_cqr->cpaddr)
goto out_err3;
lcu->rsu_cqr->data = kzalloc(16, GFP_KERNEL | GFP_DMA);
if (!lcu->rsu_cqr->data)
goto out_err4;
memcpy(lcu->uid.vendor, uid->vendor, sizeof(uid->vendor));
memcpy(lcu->uid.serial, uid->serial, sizeof(uid->serial));
lcu->uid.ssid = uid->ssid;
lcu->pav = NO_PAV;
lcu->flags = NEED_UAC_UPDATE | UPDATE_PENDING;
INIT_LIST_HEAD(&lcu->lcu);
INIT_LIST_HEAD(&lcu->inactive_devices);
INIT_LIST_HEAD(&lcu->active_devices);
INIT_LIST_HEAD(&lcu->grouplist);
INIT_WORK(&lcu->suc_data.worker, summary_unit_check_handling_work);
INIT_DELAYED_WORK(&lcu->ruac_data.dwork, lcu_update_work);
spin_lock_init(&lcu->lock);
return lcu;
out_err4:
kfree(lcu->rsu_cqr->cpaddr);
out_err3:
kfree(lcu->rsu_cqr);
out_err2:
kfree(lcu->uac);
out_err1:
kfree(lcu);
return ERR_PTR(-ENOMEM);
}
static void _free_lcu(struct alias_lcu *lcu)
{
kfree(lcu->rsu_cqr->data);
kfree(lcu->rsu_cqr->cpaddr);
kfree(lcu->rsu_cqr);
kfree(lcu->uac);
kfree(lcu);
}
/*
* This is the function that will allocate all the server and lcu data,
* so this function must be called first for a new device.
* If the return value is 1, the lcu was already known before, if it
* is 0, this is a new lcu.
* Negative return code indicates that something went wrong (e.g. -ENOMEM)
*/
int dasd_alias_make_device_known_to_lcu(struct dasd_device *device)
{
struct dasd_eckd_private *private;
unsigned long flags;
struct alias_server *server, *newserver;
struct alias_lcu *lcu, *newlcu;
int is_lcu_known;
struct dasd_uid *uid;
private = (struct dasd_eckd_private *) device->private;
uid = &private->uid;
spin_lock_irqsave(&aliastree.lock, flags);
is_lcu_known = 1;
server = _find_server(uid);
if (!server) {
spin_unlock_irqrestore(&aliastree.lock, flags);
newserver = _allocate_server(uid);
if (IS_ERR(newserver))
return PTR_ERR(newserver);
spin_lock_irqsave(&aliastree.lock, flags);
server = _find_server(uid);
if (!server) {
list_add(&newserver->server, &aliastree.serverlist);
server = newserver;
is_lcu_known = 0;
} else {
/* someone was faster */
_free_server(newserver);
}
}
lcu = _find_lcu(server, uid);
if (!lcu) {
spin_unlock_irqrestore(&aliastree.lock, flags);
newlcu = _allocate_lcu(uid);
if (IS_ERR(newlcu))
return PTR_ERR(lcu);
spin_lock_irqsave(&aliastree.lock, flags);
lcu = _find_lcu(server, uid);
if (!lcu) {
list_add(&newlcu->lcu, &server->lculist);
lcu = newlcu;
is_lcu_known = 0;
} else {
/* someone was faster */
_free_lcu(newlcu);
}
is_lcu_known = 0;
}
spin_lock(&lcu->lock);
list_add(&device->alias_list, &lcu->inactive_devices);
private->lcu = lcu;
spin_unlock(&lcu->lock);
spin_unlock_irqrestore(&aliastree.lock, flags);
return is_lcu_known;
}
/*
* This function removes a device from the scope of alias management.
* The complicated part is to make sure that it is not in use by
* any of the workers. If necessary cancel the work.
*/
void dasd_alias_disconnect_device_from_lcu(struct dasd_device *device)
{
struct dasd_eckd_private *private;
unsigned long flags;
struct alias_lcu *lcu;
struct alias_server *server;
int was_pending;
private = (struct dasd_eckd_private *) device->private;
lcu = private->lcu;
spin_lock_irqsave(&lcu->lock, flags);
list_del_init(&device->alias_list);
/* make sure that the workers don't use this device */
if (device == lcu->suc_data.device) {
spin_unlock_irqrestore(&lcu->lock, flags);
cancel_work_sync(&lcu->suc_data.worker);
spin_lock_irqsave(&lcu->lock, flags);
if (device == lcu->suc_data.device)
lcu->suc_data.device = NULL;
}
was_pending = 0;
if (device == lcu->ruac_data.device) {
spin_unlock_irqrestore(&lcu->lock, flags);
was_pending = 1;
cancel_delayed_work_sync(&lcu->ruac_data.dwork);
spin_lock_irqsave(&lcu->lock, flags);
if (device == lcu->ruac_data.device)
lcu->ruac_data.device = NULL;
}
private->lcu = NULL;
spin_unlock_irqrestore(&lcu->lock, flags);
spin_lock_irqsave(&aliastree.lock, flags);
spin_lock(&lcu->lock);
if (list_empty(&lcu->grouplist) &&
list_empty(&lcu->active_devices) &&
list_empty(&lcu->inactive_devices)) {
list_del(&lcu->lcu);
spin_unlock(&lcu->lock);
_free_lcu(lcu);
lcu = NULL;
} else {
if (was_pending)
_schedule_lcu_update(lcu, NULL);
spin_unlock(&lcu->lock);
}
server = _find_server(&private->uid);
if (server && list_empty(&server->lculist)) {
list_del(&server->server);
_free_server(server);
}
spin_unlock_irqrestore(&aliastree.lock, flags);
}
/*
* This function assumes that the unit address configuration stored
* in the lcu is up to date and will update the device uid before
* adding it to a pav group.
*/
static int _add_device_to_lcu(struct alias_lcu *lcu,
struct dasd_device *device)
{
struct dasd_eckd_private *private;
struct alias_pav_group *group;
struct dasd_uid *uid;
private = (struct dasd_eckd_private *) device->private;
uid = &private->uid;
uid->type = lcu->uac->unit[uid->real_unit_addr].ua_type;
uid->base_unit_addr = lcu->uac->unit[uid->real_unit_addr].base_ua;
dasd_set_uid(device->cdev, &private->uid);
/* if we have no PAV anyway, we don't need to bother with PAV groups */
if (lcu->pav == NO_PAV) {
list_move(&device->alias_list, &lcu->active_devices);
return 0;
}
group = _find_group(lcu, uid);
if (!group) {
group = kzalloc(sizeof(*group), GFP_ATOMIC);
if (!group)
return -ENOMEM;
memcpy(group->uid.vendor, uid->vendor, sizeof(uid->vendor));
memcpy(group->uid.serial, uid->serial, sizeof(uid->serial));
group->uid.ssid = uid->ssid;
if (uid->type == UA_BASE_DEVICE)
group->uid.base_unit_addr = uid->real_unit_addr;
else
group->uid.base_unit_addr = uid->base_unit_addr;
INIT_LIST_HEAD(&group->group);
INIT_LIST_HEAD(&group->baselist);
INIT_LIST_HEAD(&group->aliaslist);
list_add(&group->group, &lcu->grouplist);
}
if (uid->type == UA_BASE_DEVICE)
list_move(&device->alias_list, &group->baselist);
else
list_move(&device->alias_list, &group->aliaslist);
private->pavgroup = group;
return 0;
};
static void _remove_device_from_lcu(struct alias_lcu *lcu,
struct dasd_device *device)
{
struct dasd_eckd_private *private;
struct alias_pav_group *group;
private = (struct dasd_eckd_private *) device->private;
list_move(&device->alias_list, &lcu->inactive_devices);
group = private->pavgroup;
if (!group)
return;
private->pavgroup = NULL;
if (list_empty(&group->baselist) && list_empty(&group->aliaslist)) {
list_del(&group->group);
kfree(group);
return;
}
if (group->next == device)
group->next = NULL;
};
static int read_unit_address_configuration(struct dasd_device *device,
struct alias_lcu *lcu)
{
struct dasd_psf_prssd_data *prssdp;
struct dasd_ccw_req *cqr;
struct ccw1 *ccw;
int rc;
unsigned long flags;
cqr = dasd_kmalloc_request("ECKD",
1 /* PSF */ + 1 /* RSSD */ ,
(sizeof(struct dasd_psf_prssd_data)),
device);
if (IS_ERR(cqr))
return PTR_ERR(cqr);
cqr->startdev = device;
cqr->memdev = device;
clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
cqr->retries = 10;
cqr->expires = 20 * HZ;
/* Prepare for Read Subsystem Data */
prssdp = (struct dasd_psf_prssd_data *) cqr->data;
memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
prssdp->order = PSF_ORDER_PRSSD;
prssdp->suborder = 0x0e; /* Read unit address configuration */
/* all other bytes of prssdp must be zero */
ccw = cqr->cpaddr;
ccw->cmd_code = DASD_ECKD_CCW_PSF;
ccw->count = sizeof(struct dasd_psf_prssd_data);
ccw->flags |= CCW_FLAG_CC;
ccw->cda = (__u32)(addr_t) prssdp;
/* Read Subsystem Data - feature codes */
memset(lcu->uac, 0, sizeof(*(lcu->uac)));
ccw++;
ccw->cmd_code = DASD_ECKD_CCW_RSSD;
ccw->count = sizeof(*(lcu->uac));
ccw->cda = (__u32)(addr_t) lcu->uac;
cqr->buildclk = get_clock();
cqr->status = DASD_CQR_FILLED;
/* need to unset flag here to detect race with summary unit check */
spin_lock_irqsave(&lcu->lock, flags);
lcu->flags &= ~NEED_UAC_UPDATE;
spin_unlock_irqrestore(&lcu->lock, flags);
do {
rc = dasd_sleep_on(cqr);
} while (rc && (cqr->retries > 0));
if (rc) {
spin_lock_irqsave(&lcu->lock, flags);
lcu->flags |= NEED_UAC_UPDATE;
spin_unlock_irqrestore(&lcu->lock, flags);
}
dasd_kfree_request(cqr, cqr->memdev);
return rc;
}
static int _lcu_update(struct dasd_device *refdev, struct alias_lcu *lcu)
{
unsigned long flags;
struct alias_pav_group *pavgroup, *tempgroup;
struct dasd_device *device, *tempdev;
int i, rc;
struct dasd_eckd_private *private;
spin_lock_irqsave(&lcu->lock, flags);
list_for_each_entry_safe(pavgroup, tempgroup, &lcu->grouplist, group) {
list_for_each_entry_safe(device, tempdev, &pavgroup->baselist,
alias_list) {
list_move(&device->alias_list, &lcu->active_devices);
private = (struct dasd_eckd_private *) device->private;
private->pavgroup = NULL;
}
list_for_each_entry_safe(device, tempdev, &pavgroup->aliaslist,
alias_list) {
list_move(&device->alias_list, &lcu->active_devices);
private = (struct dasd_eckd_private *) device->private;
private->pavgroup = NULL;
}
list_del(&pavgroup->group);
kfree(pavgroup);
}
spin_unlock_irqrestore(&lcu->lock, flags);
rc = read_unit_address_configuration(refdev, lcu);
if (rc)
return rc;
spin_lock_irqsave(&lcu->lock, flags);
lcu->pav = NO_PAV;
for (i = 0; i < MAX_DEVICES_PER_LCU; ++i) {
switch (lcu->uac->unit[i].ua_type) {
case UA_BASE_PAV_ALIAS:
lcu->pav = BASE_PAV;
break;
case UA_HYPER_PAV_ALIAS:
lcu->pav = HYPER_PAV;
break;
}
if (lcu->pav != NO_PAV)
break;
}
list_for_each_entry_safe(device, tempdev, &lcu->active_devices,
alias_list) {
_add_device_to_lcu(lcu, device);
}
spin_unlock_irqrestore(&lcu->lock, flags);
return 0;
}
static void lcu_update_work(struct work_struct *work)
{
struct alias_lcu *lcu;
struct read_uac_work_data *ruac_data;
struct dasd_device *device;
unsigned long flags;
int rc;
ruac_data = container_of(work, struct read_uac_work_data, dwork.work);
lcu = container_of(ruac_data, struct alias_lcu, ruac_data);
device = ruac_data->device;
rc = _lcu_update(device, lcu);
/*
* Need to check flags again, as there could have been another
* prepare_update or a new device a new device while we were still
* processing the data
*/
spin_lock_irqsave(&lcu->lock, flags);
if (rc || (lcu->flags & NEED_UAC_UPDATE)) {
DEV_MESSAGE(KERN_WARNING, device, "could not update"
" alias data in lcu (rc = %d), retry later", rc);
schedule_delayed_work(&lcu->ruac_data.dwork, 30*HZ);
} else {
lcu->ruac_data.device = NULL;
lcu->flags &= ~UPDATE_PENDING;
}
spin_unlock_irqrestore(&lcu->lock, flags);
}
static int _schedule_lcu_update(struct alias_lcu *lcu,
struct dasd_device *device)
{
struct dasd_device *usedev = NULL;
struct alias_pav_group *group;
lcu->flags |= NEED_UAC_UPDATE;
if (lcu->ruac_data.device) {
/* already scheduled or running */
return 0;
}
if (device && !list_empty(&device->alias_list))
usedev = device;
if (!usedev && !list_empty(&lcu->grouplist)) {
group = list_first_entry(&lcu->grouplist,
struct alias_pav_group, group);
if (!list_empty(&group->baselist))
usedev = list_first_entry(&group->baselist,
struct dasd_device,
alias_list);
else if (!list_empty(&group->aliaslist))
usedev = list_first_entry(&group->aliaslist,
struct dasd_device,
alias_list);
}
if (!usedev && !list_empty(&lcu->active_devices)) {
usedev = list_first_entry(&lcu->active_devices,
struct dasd_device, alias_list);
}
/*
* if we haven't found a proper device yet, give up for now, the next
* device that will be set active will trigger an lcu update
*/
if (!usedev)
return -EINVAL;
lcu->ruac_data.device = usedev;
schedule_delayed_work(&lcu->ruac_data.dwork, 0);
return 0;
}
int dasd_alias_add_device(struct dasd_device *device)
{
struct dasd_eckd_private *private;
struct alias_lcu *lcu;
unsigned long flags;
int rc;
private = (struct dasd_eckd_private *) device->private;
lcu = private->lcu;
rc = 0;
spin_lock_irqsave(&lcu->lock, flags);
if (!(lcu->flags & UPDATE_PENDING)) {
rc = _add_device_to_lcu(lcu, device);
if (rc)
lcu->flags |= UPDATE_PENDING;
}
if (lcu->flags & UPDATE_PENDING) {
list_move(&device->alias_list, &lcu->active_devices);
_schedule_lcu_update(lcu, device);
}
spin_unlock_irqrestore(&lcu->lock, flags);
return rc;
}
int dasd_alias_remove_device(struct dasd_device *device)
{
struct dasd_eckd_private *private;
struct alias_lcu *lcu;
unsigned long flags;
private = (struct dasd_eckd_private *) device->private;
lcu = private->lcu;
spin_lock_irqsave(&lcu->lock, flags);
_remove_device_from_lcu(lcu, device);
spin_unlock_irqrestore(&lcu->lock, flags);
return 0;
}
struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *base_device)
{
struct dasd_device *alias_device;
struct alias_pav_group *group;
struct alias_lcu *lcu;
struct dasd_eckd_private *private, *alias_priv;
unsigned long flags;
private = (struct dasd_eckd_private *) base_device->private;
group = private->pavgroup;
lcu = private->lcu;
if (!group || !lcu)
return NULL;
if (lcu->pav == NO_PAV ||
lcu->flags & (NEED_UAC_UPDATE | UPDATE_PENDING))
return NULL;
spin_lock_irqsave(&lcu->lock, flags);
alias_device = group->next;
if (!alias_device) {
if (list_empty(&group->aliaslist)) {
spin_unlock_irqrestore(&lcu->lock, flags);
return NULL;
} else {
alias_device = list_first_entry(&group->aliaslist,
struct dasd_device,
alias_list);
}
}
if (list_is_last(&alias_device->alias_list, &group->aliaslist))
group->next = list_first_entry(&group->aliaslist,
struct dasd_device, alias_list);
else
group->next = list_first_entry(&alias_device->alias_list,
struct dasd_device, alias_list);
spin_unlock_irqrestore(&lcu->lock, flags);
alias_priv = (struct dasd_eckd_private *) alias_device->private;
if ((alias_priv->count < private->count) && !alias_device->stopped)
return alias_device;
else
return NULL;
}
/*
* Summary unit check handling depends on the way alias devices
* are handled so it is done here rather then in dasd_eckd.c
*/
static int reset_summary_unit_check(struct alias_lcu *lcu,
struct dasd_device *device,
char reason)
{
struct dasd_ccw_req *cqr;
int rc = 0;
cqr = lcu->rsu_cqr;
strncpy((char *) &cqr->magic, "ECKD", 4);
ASCEBC((char *) &cqr->magic, 4);
cqr->cpaddr->cmd_code = DASD_ECKD_CCW_RSCK;
cqr->cpaddr->flags = 0 ;
cqr->cpaddr->count = 16;
cqr->cpaddr->cda = (__u32)(addr_t) cqr->data;
((char *)cqr->data)[0] = reason;
clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
cqr->retries = 255; /* set retry counter to enable basic ERP */
cqr->startdev = device;
cqr->memdev = device;
cqr->block = NULL;
cqr->expires = 5 * HZ;
cqr->buildclk = get_clock();
cqr->status = DASD_CQR_FILLED;
rc = dasd_sleep_on_immediatly(cqr);
return rc;
}
static void _restart_all_base_devices_on_lcu(struct alias_lcu *lcu)
{
struct alias_pav_group *pavgroup;
struct dasd_device *device;
struct dasd_eckd_private *private;
/* active and inactive list can contain alias as well as base devices */
list_for_each_entry(device, &lcu->active_devices, alias_list) {
private = (struct dasd_eckd_private *) device->private;
if (private->uid.type != UA_BASE_DEVICE)
continue;
dasd_schedule_block_bh(device->block);
dasd_schedule_device_bh(device);
}
list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
private = (struct dasd_eckd_private *) device->private;
if (private->uid.type != UA_BASE_DEVICE)
continue;
dasd_schedule_block_bh(device->block);
dasd_schedule_device_bh(device);
}
list_for_each_entry(pavgroup, &lcu->grouplist, group) {
list_for_each_entry(device, &pavgroup->baselist, alias_list) {
dasd_schedule_block_bh(device->block);
dasd_schedule_device_bh(device);
}
}
}
static void flush_all_alias_devices_on_lcu(struct alias_lcu *lcu)
{
struct alias_pav_group *pavgroup;
struct dasd_device *device, *temp;
struct dasd_eckd_private *private;
int rc;
unsigned long flags;
LIST_HEAD(active);
/*
* Problem here ist that dasd_flush_device_queue may wait
* for termination of a request to complete. We can't keep
* the lcu lock during that time, so we must assume that
* the lists may have changed.
* Idea: first gather all active alias devices in a separate list,
* then flush the first element of this list unlocked, and afterwards
* check if it is still on the list before moving it to the
* active_devices list.
*/
spin_lock_irqsave(&lcu->lock, flags);
list_for_each_entry_safe(device, temp, &lcu->active_devices,
alias_list) {
private = (struct dasd_eckd_private *) device->private;
if (private->uid.type == UA_BASE_DEVICE)
continue;
list_move(&device->alias_list, &active);
}
list_for_each_entry(pavgroup, &lcu->grouplist, group) {
list_splice_init(&pavgroup->aliaslist, &active);
}
while (!list_empty(&active)) {
device = list_first_entry(&active, struct dasd_device,
alias_list);
spin_unlock_irqrestore(&lcu->lock, flags);
rc = dasd_flush_device_queue(device);
spin_lock_irqsave(&lcu->lock, flags);
/*
* only move device around if it wasn't moved away while we
* were waiting for the flush
*/
if (device == list_first_entry(&active,
struct dasd_device, alias_list))
list_move(&device->alias_list, &lcu->active_devices);
}
spin_unlock_irqrestore(&lcu->lock, flags);
}
/*
* This function is called in interrupt context, so the
* cdev lock for device is already locked!
*/
static void _stop_all_devices_on_lcu(struct alias_lcu *lcu,
struct dasd_device *device)
{
struct alias_pav_group *pavgroup;
struct dasd_device *pos;
list_for_each_entry(pos, &lcu->active_devices, alias_list) {
if (pos != device)
spin_lock(get_ccwdev_lock(pos->cdev));
pos->stopped |= DASD_STOPPED_SU;
if (pos != device)
spin_unlock(get_ccwdev_lock(pos->cdev));
}
list_for_each_entry(pos, &lcu->inactive_devices, alias_list) {
if (pos != device)
spin_lock(get_ccwdev_lock(pos->cdev));
pos->stopped |= DASD_STOPPED_SU;
if (pos != device)
spin_unlock(get_ccwdev_lock(pos->cdev));
}
list_for_each_entry(pavgroup, &lcu->grouplist, group) {
list_for_each_entry(pos, &pavgroup->baselist, alias_list) {
if (pos != device)
spin_lock(get_ccwdev_lock(pos->cdev));
pos->stopped |= DASD_STOPPED_SU;
if (pos != device)
spin_unlock(get_ccwdev_lock(pos->cdev));
}
list_for_each_entry(pos, &pavgroup->aliaslist, alias_list) {
if (pos != device)
spin_lock(get_ccwdev_lock(pos->cdev));
pos->stopped |= DASD_STOPPED_SU;
if (pos != device)
spin_unlock(get_ccwdev_lock(pos->cdev));
}
}
}
static void _unstop_all_devices_on_lcu(struct alias_lcu *lcu)
{
struct alias_pav_group *pavgroup;
struct dasd_device *device;
unsigned long flags;
list_for_each_entry(device, &lcu->active_devices, alias_list) {
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
device->stopped &= ~DASD_STOPPED_SU;
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
}
list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
device->stopped &= ~DASD_STOPPED_SU;
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
}
list_for_each_entry(pavgroup, &lcu->grouplist, group) {
list_for_each_entry(device, &pavgroup->baselist, alias_list) {
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
device->stopped &= ~DASD_STOPPED_SU;
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
flags);
}
list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
device->stopped &= ~DASD_STOPPED_SU;
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
flags);
}
}
}
static void summary_unit_check_handling_work(struct work_struct *work)
{
struct alias_lcu *lcu;
struct summary_unit_check_work_data *suc_data;
unsigned long flags;
struct dasd_device *device;
suc_data = container_of(work, struct summary_unit_check_work_data,
worker);
lcu = container_of(suc_data, struct alias_lcu, suc_data);
device = suc_data->device;
/* 1. flush alias devices */
flush_all_alias_devices_on_lcu(lcu);
/* 2. reset summary unit check */
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
device->stopped &= ~(DASD_STOPPED_SU | DASD_STOPPED_PENDING);
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
reset_summary_unit_check(lcu, device, suc_data->reason);
spin_lock_irqsave(&lcu->lock, flags);
_unstop_all_devices_on_lcu(lcu);
_restart_all_base_devices_on_lcu(lcu);
/* 3. read new alias configuration */
_schedule_lcu_update(lcu, device);
lcu->suc_data.device = NULL;
spin_unlock_irqrestore(&lcu->lock, flags);
}
/*
* note: this will be called from int handler context (cdev locked)
*/
void dasd_alias_handle_summary_unit_check(struct dasd_device *device,
struct irb *irb)
{
struct alias_lcu *lcu;
char reason;
struct dasd_eckd_private *private;
private = (struct dasd_eckd_private *) device->private;
reason = irb->ecw[8];
DEV_MESSAGE(KERN_WARNING, device, "%s %x",
"eckd handle summary unit check: reason", reason);
lcu = private->lcu;
if (!lcu) {
DEV_MESSAGE(KERN_WARNING, device, "%s",
"device not ready to handle summary"
" unit check (no lcu structure)");
return;
}
spin_lock(&lcu->lock);
_stop_all_devices_on_lcu(lcu, device);
/* prepare for lcu_update */
private->lcu->flags |= NEED_UAC_UPDATE | UPDATE_PENDING;
/* If this device is about to be removed just return and wait for
* the next interrupt on a different device
*/
if (list_empty(&device->alias_list)) {
DEV_MESSAGE(KERN_WARNING, device, "%s",
"device is in offline processing,"
" don't do summary unit check handling");
spin_unlock(&lcu->lock);
return;
}
if (lcu->suc_data.device) {
/* already scheduled or running */
DEV_MESSAGE(KERN_WARNING, device, "%s",
"previous instance of summary unit check worker"
" still pending");
spin_unlock(&lcu->lock);
return ;
}
lcu->suc_data.reason = reason;
lcu->suc_data.device = device;
spin_unlock(&lcu->lock);
schedule_work(&lcu->suc_data.worker);
};

94
drivers/s390/block/dasd_devmap.c
View File

@ -48,22 +48,6 @@ struct dasd_devmap {
struct dasd_uid uid; struct dasd_uid uid;
}; };
/*
* dasd_server_ssid_map contains a globally unique storage server subsystem ID.
* dasd_server_ssid_list contains the list of all subsystem IDs accessed by
* the DASD device driver.
*/
struct dasd_server_ssid_map {
struct list_head list;
struct system_id {
char vendor[4];
char serial[15];
__u16 ssid;
} sid;
};
static struct list_head dasd_server_ssid_list;
/* /*
* Parameter parsing functions for dasd= parameter. The syntax is: * Parameter parsing functions for dasd= parameter. The syntax is:
* <devno> : (0x)?[0-9a-fA-F]+ * <devno> : (0x)?[0-9a-fA-F]+
@ -721,8 +705,9 @@ dasd_ro_store(struct device *dev, struct device_attribute *attr,
devmap->features &= ~DASD_FEATURE_READONLY; devmap->features &= ~DASD_FEATURE_READONLY;
if (devmap->device) if (devmap->device)
devmap->device->features = devmap->features; devmap->device->features = devmap->features;
if (devmap->device && devmap->device->gdp) if (devmap->device && devmap->device->block
set_disk_ro(devmap->device->gdp, val); && devmap->device->block->gdp)
set_disk_ro(devmap->device->block->gdp, val);
spin_unlock(&dasd_devmap_lock); spin_unlock(&dasd_devmap_lock);
return count; return count;
} }
@ -893,12 +878,16 @@ dasd_alias_show(struct device *dev, struct device_attribute *attr, char *buf)
devmap = dasd_find_busid(dev->bus_id); devmap = dasd_find_busid(dev->bus_id);
spin_lock(&dasd_devmap_lock); spin_lock(&dasd_devmap_lock);
if (!IS_ERR(devmap)) if (IS_ERR(devmap) || strlen(devmap->uid.vendor) == 0) {
alias = devmap->uid.alias; spin_unlock(&dasd_devmap_lock);
return sprintf(buf, "0\n");
}
if (devmap->uid.type == UA_BASE_PAV_ALIAS ||
devmap->uid.type == UA_HYPER_PAV_ALIAS)
alias = 1;
else else
alias = 0; alias = 0;
spin_unlock(&dasd_devmap_lock); spin_unlock(&dasd_devmap_lock);
return sprintf(buf, alias ? "1\n" : "0\n"); return sprintf(buf, alias ? "1\n" : "0\n");
} }
@ -930,19 +919,36 @@ static ssize_t
dasd_uid_show(struct device *dev, struct device_attribute *attr, char *buf) dasd_uid_show(struct device *dev, struct device_attribute *attr, char *buf)
{ {
struct dasd_devmap *devmap; struct dasd_devmap *devmap;
char uid[UID_STRLEN]; char uid_string[UID_STRLEN];
char ua_string[3];
struct dasd_uid *uid;
devmap = dasd_find_busid(dev->bus_id); devmap = dasd_find_busid(dev->bus_id);
spin_lock(&dasd_devmap_lock); spin_lock(&dasd_devmap_lock);
if (!IS_ERR(devmap) && strlen(devmap->uid.vendor) > 0) if (IS_ERR(devmap) || strlen(devmap->uid.vendor) == 0) {
snprintf(uid, sizeof(uid), "%s.%s.%04x.%02x", spin_unlock(&dasd_devmap_lock);
devmap->uid.vendor, devmap->uid.serial, return sprintf(buf, "\n");
devmap->uid.ssid, devmap->uid.unit_addr); }
else uid = &devmap->uid;
uid[0] = 0; switch (uid->type) {
case UA_BASE_DEVICE:
sprintf(ua_string, "%02x", uid->real_unit_addr);
break;
case UA_BASE_PAV_ALIAS:
sprintf(ua_string, "%02x", uid->base_unit_addr);
break;
case UA_HYPER_PAV_ALIAS:
sprintf(ua_string, "xx");
break;
default:
/* should not happen, treat like base device */
sprintf(ua_string, "%02x", uid->real_unit_addr);
break;
}
snprintf(uid_string, sizeof(uid_string), "%s.%s.%04x.%s",
uid->vendor, uid->serial, uid->ssid, ua_string);
spin_unlock(&dasd_devmap_lock); spin_unlock(&dasd_devmap_lock);
return snprintf(buf, PAGE_SIZE, "%s\n", uid_string);
return snprintf(buf, PAGE_SIZE, "%s\n", uid);
} }
static DEVICE_ATTR(uid, 0444, dasd_uid_show, NULL); static DEVICE_ATTR(uid, 0444, dasd_uid_show, NULL);
@ -1040,39 +1046,16 @@ int
dasd_set_uid(struct ccw_device *cdev, struct dasd_uid *uid) dasd_set_uid(struct ccw_device *cdev, struct dasd_uid *uid)
{ {
struct dasd_devmap *devmap; struct dasd_devmap *devmap;
struct dasd_server_ssid_map *srv, *tmp;
devmap = dasd_find_busid(cdev->dev.bus_id); devmap = dasd_find_busid(cdev->dev.bus_id);
if (IS_ERR(devmap)) if (IS_ERR(devmap))
return PTR_ERR(devmap); return PTR_ERR(devmap);
/* generate entry for server_ssid_map */
srv = (struct dasd_server_ssid_map *)
kzalloc(sizeof(struct dasd_server_ssid_map), GFP_KERNEL);
if (!srv)
return -ENOMEM;
strncpy(srv->sid.vendor, uid->vendor, sizeof(srv->sid.vendor) - 1);
strncpy(srv->sid.serial, uid->serial, sizeof(srv->sid.serial) - 1);
srv->sid.ssid = uid->ssid;
/* server is already contained ? */
spin_lock(&dasd_devmap_lock); spin_lock(&dasd_devmap_lock);
devmap->uid = *uid; devmap->uid = *uid;
list_for_each_entry(tmp, &dasd_server_ssid_list, list) {
if (!memcmp(&srv->sid, &tmp->sid,
sizeof(struct system_id))) {
kfree(srv);
srv = NULL;
break;
}
}
/* add servermap to serverlist */
if (srv)
list_add(&srv->list, &dasd_server_ssid_list);
spin_unlock(&dasd_devmap_lock); spin_unlock(&dasd_devmap_lock);
return (srv ? 1 : 0); return 0;
} }
EXPORT_SYMBOL_GPL(dasd_set_uid); EXPORT_SYMBOL_GPL(dasd_set_uid);
@ -1138,9 +1121,6 @@ dasd_devmap_init(void)
dasd_max_devindex = 0; dasd_max_devindex = 0;
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
INIT_LIST_HEAD(&dasd_hashlists[i]); INIT_LIST_HEAD(&dasd_hashlists[i]);
/* Initialize servermap structure. */
INIT_LIST_HEAD(&dasd_server_ssid_list);
return 0; return 0;
} }

107
drivers/s390/block/dasd_diag.c
View File

@ -142,7 +142,7 @@ dasd_diag_erp(struct dasd_device *device)
int rc; int rc;
mdsk_term_io(device); mdsk_term_io(device);
rc = mdsk_init_io(device, device->bp_block, 0, NULL); rc = mdsk_init_io(device, device->block->bp_block, 0, NULL);
if (rc) if (rc)
DEV_MESSAGE(KERN_WARNING, device, "DIAG ERP unsuccessful, " DEV_MESSAGE(KERN_WARNING, device, "DIAG ERP unsuccessful, "
"rc=%d", rc); "rc=%d", rc);
@ -158,11 +158,11 @@ dasd_start_diag(struct dasd_ccw_req * cqr)
struct dasd_diag_req *dreq; struct dasd_diag_req *dreq;
int rc; int rc;
device = cqr->device; device = cqr->startdev;
if (cqr->retries < 0) { if (cqr->retries < 0) {
DEV_MESSAGE(KERN_WARNING, device, "DIAG start_IO: request %p " DEV_MESSAGE(KERN_WARNING, device, "DIAG start_IO: request %p "
"- no retry left)", cqr); "- no retry left)", cqr);
cqr->status = DASD_CQR_FAILED; cqr->status = DASD_CQR_ERROR;
return -EIO; return -EIO;
} }
private = (struct dasd_diag_private *) device->private; private = (struct dasd_diag_private *) device->private;
@ -184,7 +184,7 @@ dasd_start_diag(struct dasd_ccw_req * cqr)
switch (rc) { switch (rc) {
case 0: /* Synchronous I/O finished successfully */ case 0: /* Synchronous I/O finished successfully */
cqr->stopclk = get_clock(); cqr->stopclk = get_clock();
cqr->status = DASD_CQR_DONE; cqr->status = DASD_CQR_SUCCESS;
/* Indicate to calling function that only a dasd_schedule_bh() /* Indicate to calling function that only a dasd_schedule_bh()
and no timer is needed */ and no timer is needed */
rc = -EACCES; rc = -EACCES;
@ -209,12 +209,12 @@ dasd_diag_term_IO(struct dasd_ccw_req * cqr)
{ {
struct dasd_device *device; struct dasd_device *device;
device = cqr->device; device = cqr->startdev;
mdsk_term_io(device); mdsk_term_io(device);
mdsk_init_io(device, device->bp_block, 0, NULL); mdsk_init_io(device, device->block->bp_block, 0, NULL);
cqr->status = DASD_CQR_CLEAR; cqr->status = DASD_CQR_CLEAR_PENDING;
cqr->stopclk = get_clock(); cqr->stopclk = get_clock();
dasd_schedule_bh(device); dasd_schedule_device_bh(device);
return 0; return 0;
} }
@ -247,7 +247,7 @@ dasd_ext_handler(__u16 code)
return; return;
} }
cqr = (struct dasd_ccw_req *) ip; cqr = (struct dasd_ccw_req *) ip;
device = (struct dasd_device *) cqr->device; device = (struct dasd_device *) cqr->startdev;
if (strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) { if (strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
DEV_MESSAGE(KERN_WARNING, device, DEV_MESSAGE(KERN_WARNING, device,
" magic number of dasd_ccw_req 0x%08X doesn't" " magic number of dasd_ccw_req 0x%08X doesn't"
@ -260,10 +260,10 @@ dasd_ext_handler(__u16 code)
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
/* Check for a pending clear operation */ /* Check for a pending clear operation */
if (cqr->status == DASD_CQR_CLEAR) { if (cqr->status == DASD_CQR_CLEAR_PENDING) {
cqr->status = DASD_CQR_QUEUED; cqr->status = DASD_CQR_CLEARED;
dasd_clear_timer(device); dasd_device_clear_timer(device);
dasd_schedule_bh(device); dasd_schedule_device_bh(device);
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
return; return;
} }
@ -272,11 +272,11 @@ dasd_ext_handler(__u16 code)
expires = 0; expires = 0;
if (status == 0) { if (status == 0) {
cqr->status = DASD_CQR_DONE; cqr->status = DASD_CQR_SUCCESS;
/* Start first request on queue if possible -> fast_io. */ /* Start first request on queue if possible -> fast_io. */
if (!list_empty(&device->ccw_queue)) { if (!list_empty(&device->ccw_queue)) {
next = list_entry(device->ccw_queue.next, next = list_entry(device->ccw_queue.next,
struct dasd_ccw_req, list); struct dasd_ccw_req, devlist);
if (next->status == DASD_CQR_QUEUED) { if (next->status == DASD_CQR_QUEUED) {
rc = dasd_start_diag(next); rc = dasd_start_diag(next);
if (rc == 0) if (rc == 0)
@ -296,10 +296,10 @@ dasd_ext_handler(__u16 code)
} }
if (expires != 0) if (expires != 0)
dasd_set_timer(device, expires); dasd_device_set_timer(device, expires);
else else
dasd_clear_timer(device); dasd_device_clear_timer(device);
dasd_schedule_bh(device); dasd_schedule_device_bh(device);
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
} }
@ -309,6 +309,7 @@ dasd_ext_handler(__u16 code)
static int static int
dasd_diag_check_device(struct dasd_device *device) dasd_diag_check_device(struct dasd_device *device)
{ {
struct dasd_block *block;
struct dasd_diag_private *private; struct dasd_diag_private *private;
struct dasd_diag_characteristics *rdc_data; struct dasd_diag_characteristics *rdc_data;
struct dasd_diag_bio bio; struct dasd_diag_bio bio;
@ -328,6 +329,16 @@ dasd_diag_check_device(struct dasd_device *device)
ccw_device_get_id(device->cdev, &private->dev_id); ccw_device_get_id(device->cdev, &private->dev_id);
device->private = (void *) private; device->private = (void *) private;
} }
block = dasd_alloc_block();
if (IS_ERR(block)) {
DEV_MESSAGE(KERN_WARNING, device, "%s",
"could not allocate dasd block structure");
kfree(device->private);
return PTR_ERR(block);
}
device->block = block;
block->base = device;
/* Read Device Characteristics */ /* Read Device Characteristics */
rdc_data = (void *) &(private->rdc_data); rdc_data = (void *) &(private->rdc_data);
rdc_data->dev_nr = private->dev_id.devno; rdc_data->dev_nr = private->dev_id.devno;
@ -409,14 +420,14 @@ dasd_diag_check_device(struct dasd_device *device)
sizeof(DASD_DIAG_CMS1)) == 0) { sizeof(DASD_DIAG_CMS1)) == 0) {
/* get formatted blocksize from label block */ /* get formatted blocksize from label block */
bsize = (unsigned int) label->block_size; bsize = (unsigned int) label->block_size;
device->blocks = (unsigned long) label->block_count; block->blocks = (unsigned long) label->block_count;
} else } else
device->blocks = end_block; block->blocks = end_block;
device->bp_block = bsize; block->bp_block = bsize;
device->s2b_shift = 0; /* bits to shift 512 to get a block */ block->s2b_shift = 0; /* bits to shift 512 to get a block */
for (sb = 512; sb < bsize; sb = sb << 1) for (sb = 512; sb < bsize; sb = sb << 1)
device->s2b_shift++; block->s2b_shift++;
rc = mdsk_init_io(device, device->bp_block, 0, NULL); rc = mdsk_init_io(device, block->bp_block, 0, NULL);
if (rc) { if (rc) {
DEV_MESSAGE(KERN_WARNING, device, "DIAG initialization " DEV_MESSAGE(KERN_WARNING, device, "DIAG initialization "
"failed (rc=%d)", rc); "failed (rc=%d)", rc);
@ -424,9 +435,9 @@ dasd_diag_check_device(struct dasd_device *device)
} else { } else {
DEV_MESSAGE(KERN_INFO, device, DEV_MESSAGE(KERN_INFO, device,
"(%ld B/blk): %ldkB", "(%ld B/blk): %ldkB",
(unsigned long) device->bp_block, (unsigned long) block->bp_block,
(unsigned long) (device->blocks << (unsigned long) (block->blocks <<
device->s2b_shift) >> 1); block->s2b_shift) >> 1);
} }
out: out:
free_page((long) label); free_page((long) label);
@ -436,22 +447,16 @@ out:
/* Fill in virtual disk geometry for device. Return zero on success, non-zero /* Fill in virtual disk geometry for device. Return zero on success, non-zero
* otherwise. */ * otherwise. */
static int static int
dasd_diag_fill_geometry(struct dasd_device *device, struct hd_geometry *geo) dasd_diag_fill_geometry(struct dasd_block *block, struct hd_geometry *geo)
{ {
if (dasd_check_blocksize(device->bp_block) != 0) if (dasd_check_blocksize(block->bp_block) != 0)
return -EINVAL; return -EINVAL;
geo->cylinders = (device->blocks << device->s2b_shift) >> 10; geo->cylinders = (block->blocks << block->s2b_shift) >> 10;
geo->heads = 16; geo->heads = 16;
geo->sectors = 128 >> device->s2b_shift; geo->sectors = 128 >> block->s2b_shift;
return 0; return 0;
} }
static dasd_era_t
dasd_diag_examine_error(struct dasd_ccw_req * cqr, struct irb * stat)
{
return dasd_era_fatal;
}
static dasd_erp_fn_t static dasd_erp_fn_t
dasd_diag_erp_action(struct dasd_ccw_req * cqr) dasd_diag_erp_action(struct dasd_ccw_req * cqr)
{ {
@ -466,8 +471,9 @@ dasd_diag_erp_postaction(struct dasd_ccw_req * cqr)
/* Create DASD request from block device request. Return pointer to new /* Create DASD request from block device request. Return pointer to new
* request on success, ERR_PTR otherwise. */ * request on success, ERR_PTR otherwise. */
static struct dasd_ccw_req * static struct dasd_ccw_req *dasd_diag_build_cp(struct dasd_device *memdev,
dasd_diag_build_cp(struct dasd_device * device, struct request *req) struct dasd_block *block,
struct request *req)
{ {
struct dasd_ccw_req *cqr; struct dasd_ccw_req *cqr;
struct dasd_diag_req *dreq; struct dasd_diag_req *dreq;
@ -486,17 +492,17 @@ dasd_diag_build_cp(struct dasd_device * device, struct request *req)
rw_cmd = MDSK_WRITE_REQ; rw_cmd = MDSK_WRITE_REQ;
else else
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
blksize = device->bp_block; blksize = block->bp_block;
/* Calculate record id of first and last block. */ /* Calculate record id of first and last block. */
first_rec = req->sector >> device->s2b_shift; first_rec = req->sector >> block->s2b_shift;
last_rec = (req->sector + req->nr_sectors - 1) >> device->s2b_shift; last_rec = (req->sector + req->nr_sectors - 1) >> block->s2b_shift;
/* Check struct bio and count the number of blocks for the request. */ /* Check struct bio and count the number of blocks for the request. */
count = 0; count = 0;
rq_for_each_segment(bv, req, iter) { rq_for_each_segment(bv, req, iter) {
if (bv->bv_len & (blksize - 1)) if (bv->bv_len & (blksize - 1))
/* Fba can only do full blocks. */ /* Fba can only do full blocks. */
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
count += bv->bv_len >> (device->s2b_shift + 9); count += bv->bv_len >> (block->s2b_shift + 9);
} }
/* Paranoia. */ /* Paranoia. */
if (count != last_rec - first_rec + 1) if (count != last_rec - first_rec + 1)
@ -505,7 +511,7 @@ dasd_diag_build_cp(struct dasd_device * device, struct request *req)
datasize = sizeof(struct dasd_diag_req) + datasize = sizeof(struct dasd_diag_req) +
count*sizeof(struct dasd_diag_bio); count*sizeof(struct dasd_diag_bio);
cqr = dasd_smalloc_request(dasd_diag_discipline.name, 0, cqr = dasd_smalloc_request(dasd_diag_discipline.name, 0,
datasize, device); datasize, memdev);
if (IS_ERR(cqr)) if (IS_ERR(cqr))
return cqr; return cqr;
@ -529,7 +535,9 @@ dasd_diag_build_cp(struct dasd_device * device, struct request *req)
cqr->buildclk = get_clock(); cqr->buildclk = get_clock();
if (req->cmd_flags & REQ_FAILFAST) if (req->cmd_flags & REQ_FAILFAST)
set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
cqr->device = device; cqr->startdev = memdev;
cqr->memdev = memdev;
cqr->block = block;
cqr->expires = DIAG_TIMEOUT; cqr->expires = DIAG_TIMEOUT;
cqr->status = DASD_CQR_FILLED; cqr->status = DASD_CQR_FILLED;
return cqr; return cqr;
@ -543,10 +551,15 @@ dasd_diag_free_cp(struct dasd_ccw_req *cqr, struct request *req)
int status; int status;
status = cqr->status == DASD_CQR_DONE; status = cqr->status == DASD_CQR_DONE;
dasd_sfree_request(cqr, cqr->device); dasd_sfree_request(cqr, cqr->memdev);
return status; return status;
} }
static void dasd_diag_handle_terminated_request(struct dasd_ccw_req *cqr)
{
cqr->status = DASD_CQR_FILLED;
};
/* Fill in IOCTL data for device. */ /* Fill in IOCTL data for device. */
static int static int
dasd_diag_fill_info(struct dasd_device * device, dasd_diag_fill_info(struct dasd_device * device,
@ -583,7 +596,7 @@ static struct dasd_discipline dasd_diag_discipline = {
.fill_geometry = dasd_diag_fill_geometry, .fill_geometry = dasd_diag_fill_geometry,
.start_IO = dasd_start_diag, .start_IO = dasd_start_diag,
.term_IO = dasd_diag_term_IO, .term_IO = dasd_diag_term_IO,
.examine_error = dasd_diag_examine_error, .handle_terminated_request = dasd_diag_handle_terminated_request,
.erp_action = dasd_diag_erp_action, .erp_action = dasd_diag_erp_action,
.erp_postaction = dasd_diag_erp_postaction, .erp_postaction = dasd_diag_erp_postaction,
.build_cp = dasd_diag_build_cp, .build_cp = dasd_diag_build_cp,

781
drivers/s390/block/dasd_eckd.c
View File

File diff suppressed because it is too large Load Diff

125
drivers/s390/block/dasd_eckd.h
View File

@ -39,6 +39,8 @@
#define DASD_ECKD_CCW_READ_CKD_MT 0x9e #define DASD_ECKD_CCW_READ_CKD_MT 0x9e
#define DASD_ECKD_CCW_WRITE_CKD_MT 0x9d #define DASD_ECKD_CCW_WRITE_CKD_MT 0x9d
#define DASD_ECKD_CCW_RESERVE 0xB4 #define DASD_ECKD_CCW_RESERVE 0xB4
#define DASD_ECKD_CCW_PFX 0xE7
#define DASD_ECKD_CCW_RSCK 0xF9
/* /*
* Perform Subsystem Function / Sub-Orders * Perform Subsystem Function / Sub-Orders
@ -137,6 +139,25 @@ struct LO_eckd_data {
__u16 length; __u16 length;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Prefix data for format 0x00 and 0x01 */
struct PFX_eckd_data {
unsigned char format;
struct {
unsigned char define_extend:1;
unsigned char time_stamp:1;
unsigned char verify_base:1;
unsigned char hyper_pav:1;
unsigned char reserved:4;
} __attribute__ ((packed)) validity;
__u8 base_address;
__u8 aux;
__u8 base_lss;
__u8 reserved[7];
struct DE_eckd_data define_extend;
struct LO_eckd_data locate_record;
__u8 LO_extended_data[4];
} __attribute__ ((packed));
struct dasd_eckd_characteristics { struct dasd_eckd_characteristics {
__u16 cu_type; __u16 cu_type;
struct { struct {
@ -254,7 +275,9 @@ struct dasd_eckd_confdata {
} __attribute__ ((packed)) ned; } __attribute__ ((packed)) ned;
struct { struct {
unsigned char flags; /* byte 0 */ unsigned char flags; /* byte 0 */
unsigned char res2[7]; /* byte 1- 7 */ unsigned char res1; /* byte 1 */
__u16 format; /* byte 2-3 */
unsigned char res2[4]; /* byte 4-7 */
unsigned char sua_flags; /* byte 8 */ unsigned char sua_flags; /* byte 8 */
__u8 base_unit_addr; /* byte 9 */ __u8 base_unit_addr; /* byte 9 */
unsigned char res3[22]; /* byte 10-31 */ unsigned char res3[22]; /* byte 10-31 */
@ -343,6 +366,11 @@ struct dasd_eckd_path {
__u8 npm; __u8 npm;
}; };
struct dasd_rssd_features {
char feature[256];
} __attribute__((packed));
/* /*
* Perform Subsystem Function - Prepare for Read Subsystem Data * Perform Subsystem Function - Prepare for Read Subsystem Data
*/ */
@ -365,4 +393,99 @@ struct dasd_psf_ssc_data {
unsigned char reserved[59]; unsigned char reserved[59];
} __attribute__((packed)); } __attribute__((packed));
/*
* some structures and definitions for alias handling
*/
struct dasd_unit_address_configuration {
struct {
char ua_type;
char base_ua;
} unit[256];
} __attribute__((packed));
#define MAX_DEVICES_PER_LCU 256
/* flags on the LCU */
#define NEED_UAC_UPDATE 0x01
#define UPDATE_PENDING 0x02
enum pavtype {NO_PAV, BASE_PAV, HYPER_PAV};
struct alias_root {
struct list_head serverlist;
spinlock_t lock;
};
struct alias_server {
struct list_head server;
struct dasd_uid uid;
struct list_head lculist;
};
struct summary_unit_check_work_data {
char reason;
struct dasd_device *device;
struct work_struct worker;
};
struct read_uac_work_data {
struct dasd_device *device;
struct delayed_work dwork;
};
struct alias_lcu {
struct list_head lcu;
struct dasd_uid uid;
enum pavtype pav;
char flags;
spinlock_t lock;
struct list_head grouplist;
struct list_head active_devices;
struct list_head inactive_devices;
struct dasd_unit_address_configuration *uac;
struct summary_unit_check_work_data suc_data;
struct read_uac_work_data ruac_data;
struct dasd_ccw_req *rsu_cqr;
};
struct alias_pav_group {
struct list_head group;
struct dasd_uid uid;
struct alias_lcu *lcu;
struct list_head baselist;
struct list_head aliaslist;
struct dasd_device *next;
};
struct dasd_eckd_private {
struct dasd_eckd_characteristics rdc_data;
struct dasd_eckd_confdata conf_data;
struct dasd_eckd_path path_data;
struct eckd_count count_area[5];
int init_cqr_status;
int uses_cdl;
struct attrib_data_t attrib; /* e.g. cache operations */
struct dasd_rssd_features features;
/* alias managemnet */
struct dasd_uid uid;
struct alias_pav_group *pavgroup;
struct alias_lcu *lcu;
int count;
};
int dasd_alias_make_device_known_to_lcu(struct dasd_device *);
void dasd_alias_disconnect_device_from_lcu(struct dasd_device *);
int dasd_alias_add_device(struct dasd_device *);
int dasd_alias_remove_device(struct dasd_device *);
struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *);
void dasd_alias_handle_summary_unit_check(struct dasd_device *, struct irb *);
void dasd_eckd_reset_ccw_to_base_io(struct dasd_ccw_req *);
#endif /* DASD_ECKD_H */ #endif /* DASD_ECKD_H */

11
drivers/s390/block/dasd_eer.c
View File

@ -336,7 +336,7 @@ static void dasd_eer_write_snss_trigger(struct dasd_device *device,
unsigned long flags; unsigned long flags;
struct eerbuffer *eerb; struct eerbuffer *eerb;
snss_rc = (cqr->status == DASD_CQR_FAILED) ? -EIO : 0; snss_rc = (cqr->status == DASD_CQR_DONE) ? 0 : -EIO;
if (snss_rc) if (snss_rc)
data_size = 0; data_size = 0;
else else
@ -404,10 +404,11 @@ void dasd_eer_snss(struct dasd_device *device)
set_bit(DASD_FLAG_EER_SNSS, &device->flags); set_bit(DASD_FLAG_EER_SNSS, &device->flags);
return; return;
} }
/* cdev is already locked, can't use dasd_add_request_head */
clear_bit(DASD_FLAG_EER_SNSS, &device->flags); clear_bit(DASD_FLAG_EER_SNSS, &device->flags);
cqr->status = DASD_CQR_QUEUED; cqr->status = DASD_CQR_QUEUED;
list_add(&cqr->list, &device->ccw_queue); list_add(&cqr->devlist, &device->ccw_queue);
dasd_schedule_bh(device); dasd_schedule_device_bh(device);
} }
/* /*
@ -415,7 +416,7 @@ void dasd_eer_snss(struct dasd_device *device)
*/ */
static void dasd_eer_snss_cb(struct dasd_ccw_req *cqr, void *data) static void dasd_eer_snss_cb(struct dasd_ccw_req *cqr, void *data)
{ {
struct dasd_device *device = cqr->device; struct dasd_device *device = cqr->startdev;
unsigned long flags; unsigned long flags;
dasd_eer_write(device, cqr, DASD_EER_STATECHANGE); dasd_eer_write(device, cqr, DASD_EER_STATECHANGE);
@ -458,7 +459,7 @@ int dasd_eer_enable(struct dasd_device *device)
if (!cqr) if (!cqr)
return -ENOMEM; return -ENOMEM;
cqr->device = device; cqr->startdev = device;
cqr->retries = 255; cqr->retries = 255;
cqr->expires = 10 * HZ; cqr->expires = 10 * HZ;
clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);

25
drivers/s390/block/dasd_erp.c
View File

@ -46,6 +46,8 @@ dasd_alloc_erp_request(char *magic, int cplength, int datasize,
if (cqr == NULL) if (cqr == NULL)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
memset(cqr, 0, sizeof(struct dasd_ccw_req)); memset(cqr, 0, sizeof(struct dasd_ccw_req));
INIT_LIST_HEAD(&cqr->devlist);
INIT_LIST_HEAD(&cqr->blocklist);
data = (char *) cqr + ((sizeof(struct dasd_ccw_req) + 7L) & -8L); data = (char *) cqr + ((sizeof(struct dasd_ccw_req) + 7L) & -8L);
cqr->cpaddr = NULL; cqr->cpaddr = NULL;
if (cplength > 0) { if (cplength > 0) {
@ -66,7 +68,7 @@ dasd_alloc_erp_request(char *magic, int cplength, int datasize,
} }
void void
dasd_free_erp_request(struct dasd_ccw_req * cqr, struct dasd_device * device) dasd_free_erp_request(struct dasd_ccw_req *cqr, struct dasd_device * device)
{ {
unsigned long flags; unsigned long flags;
@ -81,11 +83,11 @@ dasd_free_erp_request(struct dasd_ccw_req * cqr, struct dasd_device * device)
* dasd_default_erp_action just retries the current cqr * dasd_default_erp_action just retries the current cqr
*/ */
struct dasd_ccw_req * struct dasd_ccw_req *
dasd_default_erp_action(struct dasd_ccw_req * cqr) dasd_default_erp_action(struct dasd_ccw_req *cqr)
{ {
struct dasd_device *device; struct dasd_device *device;
device = cqr->device; device = cqr->startdev;
/* just retry - there is nothing to save ... I got no sense data.... */ /* just retry - there is nothing to save ... I got no sense data.... */
if (cqr->retries > 0) { if (cqr->retries > 0) {
@ -93,12 +95,12 @@ dasd_default_erp_action(struct dasd_ccw_req * cqr)
"default ERP called (%i retries left)", "default ERP called (%i retries left)",
cqr->retries); cqr->retries);
cqr->lpm = LPM_ANYPATH; cqr->lpm = LPM_ANYPATH;
cqr->status = DASD_CQR_QUEUED; cqr->status = DASD_CQR_FILLED;
} else { } else {
DEV_MESSAGE (KERN_WARNING, device, "%s", DEV_MESSAGE (KERN_WARNING, device, "%s",
"default ERP called (NO retry left)"); "default ERP called (NO retry left)");
cqr->status = DASD_CQR_FAILED; cqr->status = DASD_CQR_FAILED;
cqr->stopclk = get_clock (); cqr->stopclk = get_clock();
} }
return cqr; return cqr;
} /* end dasd_default_erp_action */ } /* end dasd_default_erp_action */
@ -117,15 +119,12 @@ dasd_default_erp_action(struct dasd_ccw_req * cqr)
* RETURN VALUES * RETURN VALUES
* cqr pointer to the original CQR * cqr pointer to the original CQR
*/ */
struct dasd_ccw_req * struct dasd_ccw_req *dasd_default_erp_postaction(struct dasd_ccw_req *cqr)
dasd_default_erp_postaction(struct dasd_ccw_req * cqr)
{ {
struct dasd_device *device;
int success; int success;
BUG_ON(cqr->refers == NULL || cqr->function == NULL); BUG_ON(cqr->refers == NULL || cqr->function == NULL);
device = cqr->device;
success = cqr->status == DASD_CQR_DONE; success = cqr->status == DASD_CQR_DONE;
/* free all ERPs - but NOT the original cqr */ /* free all ERPs - but NOT the original cqr */
@ -133,10 +132,10 @@ dasd_default_erp_postaction(struct dasd_ccw_req * cqr)
struct dasd_ccw_req *refers; struct dasd_ccw_req *refers;
refers = cqr->refers; refers = cqr->refers;
/* remove the request from the device queue */ /* remove the request from the block queue */
list_del(&cqr->list); list_del(&cqr->blocklist);
/* free the finished erp request */ /* free the finished erp request */
dasd_free_erp_request(cqr, device); dasd_free_erp_request(cqr, cqr->memdev);
cqr = refers; cqr = refers;
} }
@ -157,7 +156,7 @@ dasd_log_sense(struct dasd_ccw_req *cqr, struct irb *irb)
{ {
struct dasd_device *device; struct dasd_device *device;
device = cqr->device; device = cqr->startdev;
/* dump sense data */ /* dump sense data */
if (device->discipline && device->discipline->dump_sense) if (device->discipline && device->discipline->dump_sense)
device->discipline->dump_sense(device, cqr, irb); device->discipline->dump_sense(device, cqr, irb);

119
drivers/s390/block/dasd_fba.c
View File

@ -117,6 +117,7 @@ locate_record(struct ccw1 * ccw, struct LO_fba_data *data, int rw,
static int static int
dasd_fba_check_characteristics(struct dasd_device *device) dasd_fba_check_characteristics(struct dasd_device *device)
{ {
struct dasd_block *block;
struct dasd_fba_private *private; struct dasd_fba_private *private;
struct ccw_device *cdev = device->cdev; struct ccw_device *cdev = device->cdev;
void *rdc_data; void *rdc_data;
@ -133,6 +134,16 @@ dasd_fba_check_characteristics(struct dasd_device *device)
} }
device->private = (void *) private; device->private = (void *) private;
} }
block = dasd_alloc_block();
if (IS_ERR(block)) {
DEV_MESSAGE(KERN_WARNING, device, "%s",
"could not allocate dasd block structure");
kfree(device->private);
return PTR_ERR(block);
}
device->block = block;
block->base = device;
/* Read Device Characteristics */ /* Read Device Characteristics */
rdc_data = (void *) &(private->rdc_data); rdc_data = (void *) &(private->rdc_data);
rc = dasd_generic_read_dev_chars(device, "FBA ", &rdc_data, 32); rc = dasd_generic_read_dev_chars(device, "FBA ", &rdc_data, 32);
@ -155,60 +166,37 @@ dasd_fba_check_characteristics(struct dasd_device *device)
return 0; return 0;
} }
static int static int dasd_fba_do_analysis(struct dasd_block *block)
dasd_fba_do_analysis(struct dasd_device *device)
{ {
struct dasd_fba_private *private; struct dasd_fba_private *private;
int sb, rc; int sb, rc;
private = (struct dasd_fba_private *) device->private; private = (struct dasd_fba_private *) block->base->private;
rc = dasd_check_blocksize(private->rdc_data.blk_size); rc = dasd_check_blocksize(private->rdc_data.blk_size);
if (rc) { if (rc) {
DEV_MESSAGE(KERN_INFO, device, "unknown blocksize %d", DEV_MESSAGE(KERN_INFO, block->base, "unknown blocksize %d",
private->rdc_data.blk_size); private->rdc_data.blk_size);
return rc; return rc;
} }
device->blocks = private->rdc_data.blk_bdsa; block->blocks = private->rdc_data.blk_bdsa;
device->bp_block = private->rdc_data.blk_size; block->bp_block = private->rdc_data.blk_size;
device->s2b_shift = 0; /* bits to shift 512 to get a block */ block->s2b_shift = 0; /* bits to shift 512 to get a block */
for (sb = 512; sb < private->rdc_data.blk_size; sb = sb << 1) for (sb = 512; sb < private->rdc_data.blk_size; sb = sb << 1)
device->s2b_shift++; block->s2b_shift++;
return 0; return 0;
} }
static int static int dasd_fba_fill_geometry(struct dasd_block *block,
dasd_fba_fill_geometry(struct dasd_device *device, struct hd_geometry *geo) struct hd_geometry *geo)
{ {
if (dasd_check_blocksize(device->bp_block) != 0) if (dasd_check_blocksize(block->bp_block) != 0)
return -EINVAL; return -EINVAL;
geo->cylinders = (device->blocks << device->s2b_shift) >> 10; geo->cylinders = (block->blocks << block->s2b_shift) >> 10;
geo->heads = 16; geo->heads = 16;
geo->sectors = 128 >> device->s2b_shift; geo->sectors = 128 >> block->s2b_shift;
return 0; return 0;
} }
static dasd_era_t
dasd_fba_examine_error(struct dasd_ccw_req * cqr, struct irb * irb)
{
struct dasd_device *device;
struct ccw_device *cdev;
device = (struct dasd_device *) cqr->device;
if (irb->scsw.cstat == 0x00 &&
irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END))
return dasd_era_none;
cdev = device->cdev;
switch (cdev->id.dev_type) {
case 0x3370:
return dasd_3370_erp_examine(cqr, irb);
case 0x9336:
return dasd_9336_erp_examine(cqr, irb);
default:
return dasd_era_recover;
}
}
static dasd_erp_fn_t static dasd_erp_fn_t
dasd_fba_erp_action(struct dasd_ccw_req * cqr) dasd_fba_erp_action(struct dasd_ccw_req * cqr)
{ {
@ -221,13 +209,34 @@ dasd_fba_erp_postaction(struct dasd_ccw_req * cqr)
if (cqr->function == dasd_default_erp_action) if (cqr->function == dasd_default_erp_action)
return dasd_default_erp_postaction; return dasd_default_erp_postaction;
DEV_MESSAGE(KERN_WARNING, cqr->device, "unknown ERP action %p", DEV_MESSAGE(KERN_WARNING, cqr->startdev, "unknown ERP action %p",
cqr->function); cqr->function);
return NULL; return NULL;
} }
static struct dasd_ccw_req * static void dasd_fba_handle_unsolicited_interrupt(struct dasd_device *device,
dasd_fba_build_cp(struct dasd_device * device, struct request *req) struct irb *irb)
{
char mask;
/* first of all check for state change pending interrupt */
mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP;
if ((irb->scsw.dstat & mask) == mask) {
dasd_generic_handle_state_change(device);
return;
}
/* check for unsolicited interrupts */
DEV_MESSAGE(KERN_DEBUG, device, "%s",
"unsolicited interrupt received");
device->discipline->dump_sense(device, NULL, irb);
dasd_schedule_device_bh(device);
return;
};
static struct dasd_ccw_req *dasd_fba_build_cp(struct dasd_device * memdev,
struct dasd_block *block,
struct request *req)
{ {
struct dasd_fba_private *private; struct dasd_fba_private *private;
unsigned long *idaws; unsigned long *idaws;
@ -242,17 +251,17 @@ dasd_fba_build_cp(struct dasd_device * device, struct request *req)
unsigned int blksize, off; unsigned int blksize, off;
unsigned char cmd; unsigned char cmd;
private = (struct dasd_fba_private *) device->private; private = (struct dasd_fba_private *) block->base->private;
if (rq_data_dir(req) == READ) { if (rq_data_dir(req) == READ) {
cmd = DASD_FBA_CCW_READ; cmd = DASD_FBA_CCW_READ;
} else if (rq_data_dir(req) == WRITE) { } else if (rq_data_dir(req) == WRITE) {
cmd = DASD_FBA_CCW_WRITE; cmd = DASD_FBA_CCW_WRITE;
} else } else
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
blksize = device->bp_block; blksize = block->bp_block;
/* Calculate record id of first and last block. */ /* Calculate record id of first and last block. */
first_rec = req->sector >> device->s2b_shift; first_rec = req->sector >> block->s2b_shift;
last_rec = (req->sector + req->nr_sectors - 1) >> device->s2b_shift; last_rec = (req->sector + req->nr_sectors - 1) >> block->s2b_shift;
/* Check struct bio and count the number of blocks for the request. */ /* Check struct bio and count the number of blocks for the request. */
count = 0; count = 0;
cidaw = 0; cidaw = 0;
@ -260,7 +269,7 @@ dasd_fba_build_cp(struct dasd_device * device, struct request *req)
if (bv->bv_len & (blksize - 1)) if (bv->bv_len & (blksize - 1))
/* Fba can only do full blocks. */ /* Fba can only do full blocks. */
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
count += bv->bv_len >> (device->s2b_shift + 9); count += bv->bv_len >> (block->s2b_shift + 9);
#if defined(CONFIG_64BIT) #if defined(CONFIG_64BIT)
if (idal_is_needed (page_address(bv->bv_page), bv->bv_len)) if (idal_is_needed (page_address(bv->bv_page), bv->bv_len))
cidaw += bv->bv_len / blksize; cidaw += bv->bv_len / blksize;
@ -284,13 +293,13 @@ dasd_fba_build_cp(struct dasd_device * device, struct request *req)
} }
/* Allocate the ccw request. */ /* Allocate the ccw request. */
cqr = dasd_smalloc_request(dasd_fba_discipline.name, cqr = dasd_smalloc_request(dasd_fba_discipline.name,
cplength, datasize, device); cplength, datasize, memdev);
if (IS_ERR(cqr)) if (IS_ERR(cqr))
return cqr; return cqr;
ccw = cqr->cpaddr; ccw = cqr->cpaddr;
/* First ccw is define extent. */ /* First ccw is define extent. */
define_extent(ccw++, cqr->data, rq_data_dir(req), define_extent(ccw++, cqr->data, rq_data_dir(req),
device->bp_block, req->sector, req->nr_sectors); block->bp_block, req->sector, req->nr_sectors);
/* Build locate_record + read/write ccws. */ /* Build locate_record + read/write ccws. */
idaws = (unsigned long *) (cqr->data + sizeof(struct DE_fba_data)); idaws = (unsigned long *) (cqr->data + sizeof(struct DE_fba_data));
LO_data = (struct LO_fba_data *) (idaws + cidaw); LO_data = (struct LO_fba_data *) (idaws + cidaw);
@ -326,7 +335,7 @@ dasd_fba_build_cp(struct dasd_device * device, struct request *req)
ccw[-1].flags |= CCW_FLAG_CC; ccw[-1].flags |= CCW_FLAG_CC;
} }
ccw->cmd_code = cmd; ccw->cmd_code = cmd;
ccw->count = device->bp_block; ccw->count = block->bp_block;
if (idal_is_needed(dst, blksize)) { if (idal_is_needed(dst, blksize)) {
ccw->cda = (__u32)(addr_t) idaws; ccw->cda = (__u32)(addr_t) idaws;
ccw->flags = CCW_FLAG_IDA; ccw->flags = CCW_FLAG_IDA;
@ -342,7 +351,9 @@ dasd_fba_build_cp(struct dasd_device * device, struct request *req)
} }
if (req->cmd_flags & REQ_FAILFAST) if (req->cmd_flags & REQ_FAILFAST)
set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
cqr->device = device; cqr->startdev = memdev;
cqr->memdev = memdev;
cqr->block = block;
cqr->expires = 5 * 60 * HZ; /* 5 minutes */ cqr->expires = 5 * 60 * HZ; /* 5 minutes */
cqr->retries = 32; cqr->retries = 32;
cqr->buildclk = get_clock(); cqr->buildclk = get_clock();
@ -363,8 +374,8 @@ dasd_fba_free_cp(struct dasd_ccw_req *cqr, struct request *req)
if (!dasd_page_cache) if (!dasd_page_cache)
goto out; goto out;
private = (struct dasd_fba_private *) cqr->device->private; private = (struct dasd_fba_private *) cqr->block->base->private;
blksize = cqr->device->bp_block; blksize = cqr->block->bp_block;
ccw = cqr->cpaddr; ccw = cqr->cpaddr;
/* Skip over define extent & locate record. */ /* Skip over define extent & locate record. */
ccw++; ccw++;
@ -394,10 +405,15 @@ dasd_fba_free_cp(struct dasd_ccw_req *cqr, struct request *req)
} }
out: out:
status = cqr->status == DASD_CQR_DONE; status = cqr->status == DASD_CQR_DONE;
dasd_sfree_request(cqr, cqr->device); dasd_sfree_request(cqr, cqr->memdev);
return status; return status;
} }
static void dasd_fba_handle_terminated_request(struct dasd_ccw_req *cqr)
{
cqr->status = DASD_CQR_FILLED;
};
static int static int
dasd_fba_fill_info(struct dasd_device * device, dasd_fba_fill_info(struct dasd_device * device,
struct dasd_information2_t * info) struct dasd_information2_t * info)
@ -546,9 +562,10 @@ static struct dasd_discipline dasd_fba_discipline = {
.fill_geometry = dasd_fba_fill_geometry, .fill_geometry = dasd_fba_fill_geometry,
.start_IO = dasd_start_IO, .start_IO = dasd_start_IO,
.term_IO = dasd_term_IO, .term_IO = dasd_term_IO,
.examine_error = dasd_fba_examine_error, .handle_terminated_request = dasd_fba_handle_terminated_request,
.erp_action = dasd_fba_erp_action, .erp_action = dasd_fba_erp_action,
.erp_postaction = dasd_fba_erp_postaction, .erp_postaction = dasd_fba_erp_postaction,
.handle_unsolicited_interrupt = dasd_fba_handle_unsolicited_interrupt,
.build_cp = dasd_fba_build_cp, .build_cp = dasd_fba_build_cp,
.free_cp = dasd_fba_free_cp, .free_cp = dasd_fba_free_cp,
.dump_sense = dasd_fba_dump_sense, .dump_sense = dasd_fba_dump_sense,

76
drivers/s390/block/dasd_genhd.c
View File

@ -25,14 +25,15 @@
/* /*
* Allocate and register gendisk structure for device. * Allocate and register gendisk structure for device.
*/ */
int int dasd_gendisk_alloc(struct dasd_block *block)
dasd_gendisk_alloc(struct dasd_device *device)
{ {
struct gendisk *gdp; struct gendisk *gdp;
struct dasd_device *base;
int len; int len;
/* Make sure the minor for this device exists. */ /* Make sure the minor for this device exists. */
if (device->devindex >= DASD_PER_MAJOR) base = block->base;
if (base->devindex >= DASD_PER_MAJOR)
return -EBUSY; return -EBUSY;
gdp = alloc_disk(1 << DASD_PARTN_BITS); gdp = alloc_disk(1 << DASD_PARTN_BITS);
@ -41,9 +42,9 @@ dasd_gendisk_alloc(struct dasd_device *device)
/* Initialize gendisk structure. */ /* Initialize gendisk structure. */
gdp->major = DASD_MAJOR; gdp->major = DASD_MAJOR;
gdp->first_minor = device->devindex << DASD_PARTN_BITS; gdp->first_minor = base->devindex << DASD_PARTN_BITS;
gdp->fops = &dasd_device_operations; gdp->fops = &dasd_device_operations;
gdp->driverfs_dev = &device->cdev->dev; gdp->driverfs_dev = &base->cdev->dev;
/* /*
* Set device name. * Set device name.
@ -53,53 +54,51 @@ dasd_gendisk_alloc(struct dasd_device *device)
* dasdaaaa - dasdzzzz : 456976 devices, added up = 475252 * dasdaaaa - dasdzzzz : 456976 devices, added up = 475252
*/ */
len = sprintf(gdp->disk_name, "dasd"); len = sprintf(gdp->disk_name, "dasd");
if (device->devindex > 25) { if (base->devindex > 25) {
if (device->devindex > 701) { if (base->devindex > 701) {
if (device->devindex > 18277) if (base->devindex > 18277)
len += sprintf(gdp->disk_name + len, "%c", len += sprintf(gdp->disk_name + len, "%c",
'a'+(((device->devindex-18278) 'a'+(((base->devindex-18278)
/17576)%26)); /17576)%26));
len += sprintf(gdp->disk_name + len, "%c", len += sprintf(gdp->disk_name + len, "%c",
'a'+(((device->devindex-702)/676)%26)); 'a'+(((base->devindex-702)/676)%26));
} }
len += sprintf(gdp->disk_name + len, "%c", len += sprintf(gdp->disk_name + len, "%c",
'a'+(((device->devindex-26)/26)%26)); 'a'+(((base->devindex-26)/26)%26));
} }
len += sprintf(gdp->disk_name + len, "%c", 'a'+(device->devindex%26)); len += sprintf(gdp->disk_name + len, "%c", 'a'+(base->devindex%26));
if (device->features & DASD_FEATURE_READONLY) if (block->base->features & DASD_FEATURE_READONLY)
set_disk_ro(gdp, 1); set_disk_ro(gdp, 1);
gdp->private_data = device; gdp->private_data = block;
gdp->queue = device->request_queue; gdp->queue = block->request_queue;
device->gdp = gdp; block->gdp = gdp;
set_capacity(device->gdp, 0); set_capacity(block->gdp, 0);
add_disk(device->gdp); add_disk(block->gdp);
return 0; return 0;
} }
/* /*
* Unregister and free gendisk structure for device. * Unregister and free gendisk structure for device.
*/ */
void void dasd_gendisk_free(struct dasd_block *block)
dasd_gendisk_free(struct dasd_device *device)
{ {
if (device->gdp) { if (block->gdp) {
del_gendisk(device->gdp); del_gendisk(block->gdp);
device->gdp->queue = NULL; block->gdp->queue = NULL;
put_disk(device->gdp); put_disk(block->gdp);
device->gdp = NULL; block->gdp = NULL;
} }
} }
/* /*
* Trigger a partition detection. * Trigger a partition detection.
*/ */
int int dasd_scan_partitions(struct dasd_block *block)
dasd_scan_partitions(struct dasd_device * device)
{ {
struct block_device *bdev; struct block_device *bdev;
bdev = bdget_disk(device->gdp, 0); bdev = bdget_disk(block->gdp, 0);
if (!bdev || blkdev_get(bdev, FMODE_READ, 1) < 0) if (!bdev || blkdev_get(bdev, FMODE_READ, 1) < 0)
return -ENODEV; return -ENODEV;
/* /*
@ -117,7 +116,7 @@ dasd_scan_partitions(struct dasd_device * device)
* is why the assignment to device->bdev is done AFTER * is why the assignment to device->bdev is done AFTER
* the BLKRRPART ioctl. * the BLKRRPART ioctl.
*/ */
device->bdev = bdev; block->bdev = bdev;
return 0; return 0;
} }
@ -125,8 +124,7 @@ dasd_scan_partitions(struct dasd_device * device)
* Remove all inodes in the system for a device, delete the * Remove all inodes in the system for a device, delete the
* partitions and make device unusable by setting its size to zero. * partitions and make device unusable by setting its size to zero.
*/ */
void void dasd_destroy_partitions(struct dasd_block *block)
dasd_destroy_partitions(struct dasd_device * device)
{ {
/* The two structs have 168/176 byte on 31/64 bit. */ /* The two structs have 168/176 byte on 31/64 bit. */
struct blkpg_partition bpart; struct blkpg_partition bpart;
@ -137,8 +135,8 @@ dasd_destroy_partitions(struct dasd_device * device)
* Get the bdev pointer from the device structure and clear * Get the bdev pointer from the device structure and clear
* device->bdev to lower the offline open_count limit again. * device->bdev to lower the offline open_count limit again.
*/ */
bdev = device->bdev; bdev = block->bdev;
device->bdev = NULL; block->bdev = NULL;
/* /*
* See fs/partition/check.c:delete_partition * See fs/partition/check.c:delete_partition
@ -149,17 +147,16 @@ dasd_destroy_partitions(struct dasd_device * device)
memset(&barg, 0, sizeof(struct blkpg_ioctl_arg)); memset(&barg, 0, sizeof(struct blkpg_ioctl_arg));
barg.data = (void __force __user *) &bpart; barg.data = (void __force __user *) &bpart;
barg.op = BLKPG_DEL_PARTITION; barg.op = BLKPG_DEL_PARTITION;
for (bpart.pno = device->gdp->minors - 1; bpart.pno > 0; bpart.pno--) for (bpart.pno = block->gdp->minors - 1; bpart.pno > 0; bpart.pno--)
ioctl_by_bdev(bdev, BLKPG, (unsigned long) &barg); ioctl_by_bdev(bdev, BLKPG, (unsigned long) &barg);
invalidate_partition(device->gdp, 0); invalidate_partition(block->gdp, 0);
/* Matching blkdev_put to the blkdev_get in dasd_scan_partitions. */ /* Matching blkdev_put to the blkdev_get in dasd_scan_partitions. */
blkdev_put(bdev); blkdev_put(bdev);
set_capacity(device->gdp, 0); set_capacity(block->gdp, 0);
} }
int int dasd_gendisk_init(void)
dasd_gendisk_init(void)
{ {
int rc; int rc;
@ -174,8 +171,7 @@ dasd_gendisk_init(void)
return 0; return 0;
} }
void void dasd_gendisk_exit(void)
dasd_gendisk_exit(void)
{ {
unregister_blkdev(DASD_MAJOR, "dasd"); unregister_blkdev(DASD_MAJOR, "dasd");
} }

207
drivers/s390/block/dasd_int.h
View File

@ -64,13 +64,7 @@
* SECTION: Type definitions * SECTION: Type definitions
*/ */
struct dasd_device; struct dasd_device;
struct dasd_block;
typedef enum {
dasd_era_fatal = -1, /* no chance to recover */
dasd_era_none = 0, /* don't recover, everything alright */
dasd_era_msg = 1, /* don't recover, just report... */
dasd_era_recover = 2 /* recovery action recommended */
} dasd_era_t;
/* BIT DEFINITIONS FOR SENSE DATA */ /* BIT DEFINITIONS FOR SENSE DATA */
#define DASD_SENSE_BIT_0 0x80 #define DASD_SENSE_BIT_0 0x80
@ -151,19 +145,22 @@ do { \
struct dasd_ccw_req { struct dasd_ccw_req {
unsigned int magic; /* Eye catcher */ unsigned int magic; /* Eye catcher */
struct list_head list; /* list_head for request queueing. */ struct list_head devlist; /* for dasd_device request queue */
struct list_head blocklist; /* for dasd_block request queue */
/* Where to execute what... */ /* Where to execute what... */
struct dasd_device *device; /* device the request is for */ struct dasd_block *block; /* the originating block device */
struct dasd_device *memdev; /* the device used to allocate this */
struct dasd_device *startdev; /* device the request is started on */
struct ccw1 *cpaddr; /* address of channel program */ struct ccw1 *cpaddr; /* address of channel program */
char status; /* status of this request */ char status; /* status of this request */
short retries; /* A retry counter */ short retries; /* A retry counter */
unsigned long flags; /* flags of this request */ unsigned long flags; /* flags of this request */
/* ... and how */ /* ... and how */
unsigned long starttime; /* jiffies time of request start */ unsigned long starttime; /* jiffies time of request start */
int expires; /* expiration period in jiffies */ int expires; /* expiration period in jiffies */
char lpm; /* logical path mask */ char lpm; /* logical path mask */
void *data; /* pointer to data area */ void *data; /* pointer to data area */
/* these are important for recovering erroneous requests */ /* these are important for recovering erroneous requests */
@ -178,20 +175,27 @@ struct dasd_ccw_req {
unsigned long long endclk; /* TOD-clock of request termination */ unsigned long long endclk; /* TOD-clock of request termination */
/* Callback that is called after reaching final status. */ /* Callback that is called after reaching final status. */
void (*callback)(struct dasd_ccw_req *, void *data); void (*callback)(struct dasd_ccw_req *, void *data);
void *callback_data; void *callback_data;
}; };
/* /*
* dasd_ccw_req -> status can be: * dasd_ccw_req -> status can be:
*/ */
#define DASD_CQR_FILLED 0x00 /* request is ready to be processed */ #define DASD_CQR_FILLED 0x00 /* request is ready to be processed */
#define DASD_CQR_QUEUED 0x01 /* request is queued to be processed */ #define DASD_CQR_DONE 0x01 /* request is completed successfully */
#define DASD_CQR_IN_IO 0x02 /* request is currently in IO */ #define DASD_CQR_NEED_ERP 0x02 /* request needs recovery action */
#define DASD_CQR_DONE 0x03 /* request is completed successfully */ #define DASD_CQR_IN_ERP 0x03 /* request is in recovery */
#define DASD_CQR_ERROR 0x04 /* request is completed with error */ #define DASD_CQR_FAILED 0x04 /* request is finally failed */
#define DASD_CQR_FAILED 0x05 /* request is finally failed */ #define DASD_CQR_TERMINATED 0x05 /* request was stopped by driver */
#define DASD_CQR_CLEAR 0x06 /* request is clear pending */
#define DASD_CQR_QUEUED 0x80 /* request is queued to be processed */
#define DASD_CQR_IN_IO 0x81 /* request is currently in IO */
#define DASD_CQR_ERROR 0x82 /* request is completed with error */
#define DASD_CQR_CLEAR_PENDING 0x83 /* request is clear pending */
#define DASD_CQR_CLEARED 0x84 /* request was cleared */
#define DASD_CQR_SUCCESS 0x85 /* request was successfull */
/* per dasd_ccw_req flags */ /* per dasd_ccw_req flags */
#define DASD_CQR_FLAGS_USE_ERP 0 /* use ERP for this request */ #define DASD_CQR_FLAGS_USE_ERP 0 /* use ERP for this request */
@ -214,52 +218,71 @@ struct dasd_discipline {
struct list_head list; /* used for list of disciplines */ struct list_head list; /* used for list of disciplines */
/* /*
* Device recognition functions. check_device is used to verify * Device recognition functions. check_device is used to verify
* the sense data and the information returned by read device * the sense data and the information returned by read device
* characteristics. It returns 0 if the discipline can be used * characteristics. It returns 0 if the discipline can be used
* for the device in question. * for the device in question. uncheck_device is called during
* do_analysis is used in the step from device state "basic" to * device shutdown to deregister a device from its discipline.
* state "accept". It returns 0 if the device can be made ready, */
* it returns -EMEDIUMTYPE if the device can't be made ready or int (*check_device) (struct dasd_device *);
* -EAGAIN if do_analysis started a ccw that needs to complete void (*uncheck_device) (struct dasd_device *);
* before the analysis may be repeated.
*/
int (*check_device)(struct dasd_device *);
int (*do_analysis) (struct dasd_device *);
/* /*
* Device operation functions. build_cp creates a ccw chain for * do_analysis is used in the step from device state "basic" to
* a block device request, start_io starts the request and * state "accept". It returns 0 if the device can be made ready,
* term_IO cancels it (e.g. in case of a timeout). format_device * it returns -EMEDIUMTYPE if the device can't be made ready or
* returns a ccw chain to be used to format the device. * -EAGAIN if do_analysis started a ccw that needs to complete
*/ * before the analysis may be repeated.
*/
int (*do_analysis) (struct dasd_block *);
/*
* Last things to do when a device is set online, and first things
* when it is set offline.
*/
int (*ready_to_online) (struct dasd_device *);
int (*online_to_ready) (struct dasd_device *);
/*
* Device operation functions. build_cp creates a ccw chain for
* a block device request, start_io starts the request and
* term_IO cancels it (e.g. in case of a timeout). format_device
* returns a ccw chain to be used to format the device.
* handle_terminated_request allows to examine a cqr and prepare
* it for retry.
*/
struct dasd_ccw_req *(*build_cp) (struct dasd_device *, struct dasd_ccw_req *(*build_cp) (struct dasd_device *,
struct dasd_block *,
struct request *); struct request *);
int (*start_IO) (struct dasd_ccw_req *); int (*start_IO) (struct dasd_ccw_req *);
int (*term_IO) (struct dasd_ccw_req *); int (*term_IO) (struct dasd_ccw_req *);
void (*handle_terminated_request) (struct dasd_ccw_req *);
struct dasd_ccw_req *(*format_device) (struct dasd_device *, struct dasd_ccw_req *(*format_device) (struct dasd_device *,
struct format_data_t *); struct format_data_t *);
int (*free_cp) (struct dasd_ccw_req *, struct request *); int (*free_cp) (struct dasd_ccw_req *, struct request *);
/*
* Error recovery functions. examine_error() returns a value that /*
* indicates what to do for an error condition. If examine_error() * Error recovery functions. examine_error() returns a value that
* indicates what to do for an error condition. If examine_error()
* returns 'dasd_era_recover' erp_action() is called to create a * returns 'dasd_era_recover' erp_action() is called to create a
* special error recovery ccw. erp_postaction() is called after * special error recovery ccw. erp_postaction() is called after
* an error recovery ccw has finished its execution. dump_sense * an error recovery ccw has finished its execution. dump_sense
* is called for every error condition to print the sense data * is called for every error condition to print the sense data
* to the console. * to the console.
*/ */
dasd_era_t(*examine_error) (struct dasd_ccw_req *, struct irb *);
dasd_erp_fn_t(*erp_action) (struct dasd_ccw_req *); dasd_erp_fn_t(*erp_action) (struct dasd_ccw_req *);
dasd_erp_fn_t(*erp_postaction) (struct dasd_ccw_req *); dasd_erp_fn_t(*erp_postaction) (struct dasd_ccw_req *);
void (*dump_sense) (struct dasd_device *, struct dasd_ccw_req *, void (*dump_sense) (struct dasd_device *, struct dasd_ccw_req *,
struct irb *); struct irb *);
void (*handle_unsolicited_interrupt) (struct dasd_device *,
struct irb *);
/* i/o control functions. */ /* i/o control functions. */
int (*fill_geometry) (struct dasd_device *, struct hd_geometry *); int (*fill_geometry) (struct dasd_block *, struct hd_geometry *);
int (*fill_info) (struct dasd_device *, struct dasd_information2_t *); int (*fill_info) (struct dasd_device *, struct dasd_information2_t *);
int (*ioctl) (struct dasd_device *, unsigned int, void __user *); int (*ioctl) (struct dasd_block *, unsigned int, void __user *);
}; };
extern struct dasd_discipline *dasd_diag_discipline_pointer; extern struct dasd_discipline *dasd_diag_discipline_pointer;
@ -267,12 +290,18 @@ extern struct dasd_discipline *dasd_diag_discipline_pointer;
/* /*
* Unique identifier for dasd device. * Unique identifier for dasd device.
*/ */
#define UA_NOT_CONFIGURED 0x00
#define UA_BASE_DEVICE 0x01
#define UA_BASE_PAV_ALIAS 0x02
#define UA_HYPER_PAV_ALIAS 0x03
struct dasd_uid { struct dasd_uid {
__u8 alias; __u8 type;
char vendor[4]; char vendor[4];
char serial[15]; char serial[15];
__u16 ssid; __u16 ssid;
__u8 unit_addr; __u8 real_unit_addr;
__u8 base_unit_addr;
}; };
/* /*
@ -293,14 +322,9 @@ struct dasd_uid {
struct dasd_device { struct dasd_device {
/* Block device stuff. */ /* Block device stuff. */
struct gendisk *gdp; struct dasd_block *block;
struct request_queue *request_queue;
spinlock_t request_queue_lock;
struct block_device *bdev;
unsigned int devindex; unsigned int devindex;
unsigned long blocks; /* size of volume in blocks */
unsigned int bp_block; /* bytes per block */
unsigned int s2b_shift; /* log2 (bp_block/512) */
unsigned long flags; /* per device flags */ unsigned long flags; /* per device flags */
unsigned short features; /* copy of devmap-features (read-only!) */ unsigned short features; /* copy of devmap-features (read-only!) */
@ -316,9 +340,8 @@ struct dasd_device {
int state, target; int state, target;
int stopped; /* device (ccw_device_start) was stopped */ int stopped; /* device (ccw_device_start) was stopped */
/* Open and reference count. */ /* reference count. */
atomic_t ref_count; atomic_t ref_count;
atomic_t open_count;
/* ccw queue and memory for static ccw/erp buffers. */ /* ccw queue and memory for static ccw/erp buffers. */
struct list_head ccw_queue; struct list_head ccw_queue;
@ -337,20 +360,45 @@ struct dasd_device {
struct ccw_device *cdev; struct ccw_device *cdev;
/* hook for alias management */
struct list_head alias_list;
};
struct dasd_block {
/* Block device stuff. */
struct gendisk *gdp;
struct request_queue *request_queue;
spinlock_t request_queue_lock;
struct block_device *bdev;
atomic_t open_count;
unsigned long blocks; /* size of volume in blocks */
unsigned int bp_block; /* bytes per block */
unsigned int s2b_shift; /* log2 (bp_block/512) */
struct dasd_device *base;
struct list_head ccw_queue;
spinlock_t queue_lock;
atomic_t tasklet_scheduled;
struct tasklet_struct tasklet;
struct timer_list timer;
#ifdef CONFIG_DASD_PROFILE #ifdef CONFIG_DASD_PROFILE
struct dasd_profile_info_t profile; struct dasd_profile_info_t profile;
#endif #endif
}; };
/* reasons why device (ccw_device_start) was stopped */ /* reasons why device (ccw_device_start) was stopped */
#define DASD_STOPPED_NOT_ACC 1 /* not accessible */ #define DASD_STOPPED_NOT_ACC 1 /* not accessible */
#define DASD_STOPPED_QUIESCE 2 /* Quiesced */ #define DASD_STOPPED_QUIESCE 2 /* Quiesced */
#define DASD_STOPPED_PENDING 4 /* long busy */ #define DASD_STOPPED_PENDING 4 /* long busy */
#define DASD_STOPPED_DC_WAIT 8 /* disconnected, wait */ #define DASD_STOPPED_DC_WAIT 8 /* disconnected, wait */
#define DASD_STOPPED_DC_EIO 16 /* disconnected, return -EIO */ #define DASD_STOPPED_SU 16 /* summary unit check handling */
/* per device flags */ /* per device flags */
#define DASD_FLAG_DSC_ERROR 2 /* return -EIO when disconnected */
#define DASD_FLAG_OFFLINE 3 /* device is in offline processing */ #define DASD_FLAG_OFFLINE 3 /* device is in offline processing */
#define DASD_FLAG_EER_SNSS 4 /* A SNSS is required */ #define DASD_FLAG_EER_SNSS 4 /* A SNSS is required */
#define DASD_FLAG_EER_IN_USE 5 /* A SNSS request is running */ #define DASD_FLAG_EER_IN_USE 5 /* A SNSS request is running */
@ -489,6 +537,9 @@ dasd_kmalloc_set_cda(struct ccw1 *ccw, void *cda, struct dasd_device *device)
struct dasd_device *dasd_alloc_device(void); struct dasd_device *dasd_alloc_device(void);
void dasd_free_device(struct dasd_device *); void dasd_free_device(struct dasd_device *);
struct dasd_block *dasd_alloc_block(void);
void dasd_free_block(struct dasd_block *);
void dasd_enable_device(struct dasd_device *); void dasd_enable_device(struct dasd_device *);
void dasd_set_target_state(struct dasd_device *, int); void dasd_set_target_state(struct dasd_device *, int);
void dasd_kick_device(struct dasd_device *); void dasd_kick_device(struct dasd_device *);
@ -497,18 +548,23 @@ void dasd_add_request_head(struct dasd_ccw_req *);
void dasd_add_request_tail(struct dasd_ccw_req *); void dasd_add_request_tail(struct dasd_ccw_req *);
int dasd_start_IO(struct dasd_ccw_req *); int dasd_start_IO(struct dasd_ccw_req *);
int dasd_term_IO(struct dasd_ccw_req *); int dasd_term_IO(struct dasd_ccw_req *);
void dasd_schedule_bh(struct dasd_device *); void dasd_schedule_device_bh(struct dasd_device *);
void dasd_schedule_block_bh(struct dasd_block *);
int dasd_sleep_on(struct dasd_ccw_req *); int dasd_sleep_on(struct dasd_ccw_req *);
int dasd_sleep_on_immediatly(struct dasd_ccw_req *); int dasd_sleep_on_immediatly(struct dasd_ccw_req *);
int dasd_sleep_on_interruptible(struct dasd_ccw_req *); int dasd_sleep_on_interruptible(struct dasd_ccw_req *);
void dasd_set_timer(struct dasd_device *, int); void dasd_device_set_timer(struct dasd_device *, int);
void dasd_clear_timer(struct dasd_device *); void dasd_device_clear_timer(struct dasd_device *);
void dasd_block_set_timer(struct dasd_block *, int);
void dasd_block_clear_timer(struct dasd_block *);
int dasd_cancel_req(struct dasd_ccw_req *); int dasd_cancel_req(struct dasd_ccw_req *);
int dasd_flush_device_queue(struct dasd_device *);
int dasd_generic_probe (struct ccw_device *, struct dasd_discipline *); int dasd_generic_probe (struct ccw_device *, struct dasd_discipline *);
void dasd_generic_remove (struct ccw_device *cdev); void dasd_generic_remove (struct ccw_device *cdev);
int dasd_generic_set_online(struct ccw_device *, struct dasd_discipline *); int dasd_generic_set_online(struct ccw_device *, struct dasd_discipline *);
int dasd_generic_set_offline (struct ccw_device *cdev); int dasd_generic_set_offline (struct ccw_device *cdev);
int dasd_generic_notify(struct ccw_device *, int); int dasd_generic_notify(struct ccw_device *, int);
void dasd_generic_handle_state_change(struct dasd_device *);
int dasd_generic_read_dev_chars(struct dasd_device *, char *, void **, int); int dasd_generic_read_dev_chars(struct dasd_device *, char *, void **, int);
@ -542,10 +598,10 @@ int dasd_busid_known(char *);
/* externals in dasd_gendisk.c */ /* externals in dasd_gendisk.c */
int dasd_gendisk_init(void); int dasd_gendisk_init(void);
void dasd_gendisk_exit(void); void dasd_gendisk_exit(void);
int dasd_gendisk_alloc(struct dasd_device *); int dasd_gendisk_alloc(struct dasd_block *);
void dasd_gendisk_free(struct dasd_device *); void dasd_gendisk_free(struct dasd_block *);
int dasd_scan_partitions(struct dasd_device *); int dasd_scan_partitions(struct dasd_block *);
void dasd_destroy_partitions(struct dasd_device *); void dasd_destroy_partitions(struct dasd_block *);
/* externals in dasd_ioctl.c */ /* externals in dasd_ioctl.c */
int dasd_ioctl(struct inode *, struct file *, unsigned int, unsigned long); int dasd_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
@ -563,20 +619,9 @@ struct dasd_ccw_req *dasd_alloc_erp_request(char *, int, int,
void dasd_free_erp_request(struct dasd_ccw_req *, struct dasd_device *); void dasd_free_erp_request(struct dasd_ccw_req *, struct dasd_device *);
void dasd_log_sense(struct dasd_ccw_req *, struct irb *); void dasd_log_sense(struct dasd_ccw_req *, struct irb *);
/* externals in dasd_3370_erp.c */
dasd_era_t dasd_3370_erp_examine(struct dasd_ccw_req *, struct irb *);
/* externals in dasd_3990_erp.c */ /* externals in dasd_3990_erp.c */
dasd_era_t dasd_3990_erp_examine(struct dasd_ccw_req *, struct irb *);
struct dasd_ccw_req *dasd_3990_erp_action(struct dasd_ccw_req *); struct dasd_ccw_req *dasd_3990_erp_action(struct dasd_ccw_req *);
/* externals in dasd_9336_erp.c */
dasd_era_t dasd_9336_erp_examine(struct dasd_ccw_req *, struct irb *);
/* externals in dasd_9336_erp.c */
dasd_era_t dasd_9343_erp_examine(struct dasd_ccw_req *, struct irb *);
struct dasd_ccw_req *dasd_9343_erp_action(struct dasd_ccw_req *);
/* externals in dasd_eer.c */ /* externals in dasd_eer.c */
#ifdef CONFIG_DASD_EER #ifdef CONFIG_DASD_EER
int dasd_eer_init(void); int dasd_eer_init(void);

172
drivers/s390/block/dasd_ioctl.c
View File

@ -38,15 +38,15 @@ dasd_ioctl_api_version(void __user *argp)
static int static int
dasd_ioctl_enable(struct block_device *bdev) dasd_ioctl_enable(struct block_device *bdev)
{ {
struct dasd_device *device = bdev->bd_disk->private_data; struct dasd_block *block = bdev->bd_disk->private_data;
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EACCES; return -EACCES;
dasd_enable_device(device); dasd_enable_device(block->base);
/* Formatting the dasd device can change the capacity. */ /* Formatting the dasd device can change the capacity. */
mutex_lock(&bdev->bd_mutex); mutex_lock(&bdev->bd_mutex);
i_size_write(bdev->bd_inode, (loff_t)get_capacity(device->gdp) << 9); i_size_write(bdev->bd_inode, (loff_t)get_capacity(block->gdp) << 9);
mutex_unlock(&bdev->bd_mutex); mutex_unlock(&bdev->bd_mutex);
return 0; return 0;
} }
@ -58,7 +58,7 @@ dasd_ioctl_enable(struct block_device *bdev)
static int static int
dasd_ioctl_disable(struct block_device *bdev) dasd_ioctl_disable(struct block_device *bdev)
{ {
struct dasd_device *device = bdev->bd_disk->private_data; struct dasd_block *block = bdev->bd_disk->private_data;
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EACCES; return -EACCES;
@ -71,7 +71,7 @@ dasd_ioctl_disable(struct block_device *bdev)
* using the BIODASDFMT ioctl. Therefore the correct state for the * using the BIODASDFMT ioctl. Therefore the correct state for the
* device is DASD_STATE_BASIC that allows to do basic i/o. * device is DASD_STATE_BASIC that allows to do basic i/o.
*/ */
dasd_set_target_state(device, DASD_STATE_BASIC); dasd_set_target_state(block->base, DASD_STATE_BASIC);
/* /*
* Set i_size to zero, since read, write, etc. check against this * Set i_size to zero, since read, write, etc. check against this
* value. * value.
@ -85,19 +85,19 @@ dasd_ioctl_disable(struct block_device *bdev)
/* /*
* Quiesce device. * Quiesce device.
*/ */
static int static int dasd_ioctl_quiesce(struct dasd_block *block)
dasd_ioctl_quiesce(struct dasd_device *device)
{ {
unsigned long flags; unsigned long flags;
struct dasd_device *base;
base = block->base;
if (!capable (CAP_SYS_ADMIN)) if (!capable (CAP_SYS_ADMIN))
return -EACCES; return -EACCES;
DEV_MESSAGE (KERN_DEBUG, device, "%s", DEV_MESSAGE(KERN_DEBUG, base, "%s", "Quiesce IO on device");
"Quiesce IO on device"); spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); base->stopped |= DASD_STOPPED_QUIESCE;
device->stopped |= DASD_STOPPED_QUIESCE; spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
return 0; return 0;
} }
@ -105,22 +105,21 @@ dasd_ioctl_quiesce(struct dasd_device *device)
/* /*
* Quiesce device. * Quiesce device.
*/ */
static int static int dasd_ioctl_resume(struct dasd_block *block)
dasd_ioctl_resume(struct dasd_device *device)
{ {
unsigned long flags; unsigned long flags;
struct dasd_device *base;
base = block->base;
if (!capable (CAP_SYS_ADMIN)) if (!capable (CAP_SYS_ADMIN))
return -EACCES; return -EACCES;
DEV_MESSAGE (KERN_DEBUG, device, "%s", DEV_MESSAGE(KERN_DEBUG, base, "%s", "resume IO on device");
"resume IO on device"); spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
base->stopped &= ~DASD_STOPPED_QUIESCE;
spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); dasd_schedule_block_bh(block);
device->stopped &= ~DASD_STOPPED_QUIESCE;
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
dasd_schedule_bh (device);
return 0; return 0;
} }
@ -130,22 +129,23 @@ dasd_ioctl_resume(struct dasd_device *device)
* commands to format a single unit of the device. In terms of the ECKD * commands to format a single unit of the device. In terms of the ECKD
* devices this means CCWs are generated to format a single track. * devices this means CCWs are generated to format a single track.
*/ */
static int static int dasd_format(struct dasd_block *block, struct format_data_t *fdata)
dasd_format(struct dasd_device * device, struct format_data_t * fdata)
{ {
struct dasd_ccw_req *cqr; struct dasd_ccw_req *cqr;
struct dasd_device *base;
int rc; int rc;
if (device->discipline->format_device == NULL) base = block->base;
if (base->discipline->format_device == NULL)
return -EPERM; return -EPERM;
if (device->state != DASD_STATE_BASIC) { if (base->state != DASD_STATE_BASIC) {
DEV_MESSAGE(KERN_WARNING, device, "%s", DEV_MESSAGE(KERN_WARNING, base, "%s",
"dasd_format: device is not disabled! "); "dasd_format: device is not disabled! ");
return -EBUSY; return -EBUSY;
} }
DBF_DEV_EVENT(DBF_NOTICE, device, DBF_DEV_EVENT(DBF_NOTICE, base,
"formatting units %d to %d (%d B blocks) flags %d", "formatting units %d to %d (%d B blocks) flags %d",
fdata->start_unit, fdata->start_unit,
fdata->stop_unit, fdata->blksize, fdata->intensity); fdata->stop_unit, fdata->blksize, fdata->intensity);
@ -156,20 +156,20 @@ dasd_format(struct dasd_device * device, struct format_data_t * fdata)
* enabling the device later. * enabling the device later.
*/ */
if (fdata->start_unit == 0) { if (fdata->start_unit == 0) {
struct block_device *bdev = bdget_disk(device->gdp, 0); struct block_device *bdev = bdget_disk(block->gdp, 0);
bdev->bd_inode->i_blkbits = blksize_bits(fdata->blksize); bdev->bd_inode->i_blkbits = blksize_bits(fdata->blksize);
bdput(bdev); bdput(bdev);
} }
while (fdata->start_unit <= fdata->stop_unit) { while (fdata->start_unit <= fdata->stop_unit) {
cqr = device->discipline->format_device(device, fdata); cqr = base->discipline->format_device(base, fdata);
if (IS_ERR(cqr)) if (IS_ERR(cqr))
return PTR_ERR(cqr); return PTR_ERR(cqr);
rc = dasd_sleep_on_interruptible(cqr); rc = dasd_sleep_on_interruptible(cqr);
dasd_sfree_request(cqr, cqr->device); dasd_sfree_request(cqr, cqr->memdev);
if (rc) { if (rc) {
if (rc != -ERESTARTSYS) if (rc != -ERESTARTSYS)
DEV_MESSAGE(KERN_ERR, device, DEV_MESSAGE(KERN_ERR, base,
" Formatting of unit %d failed " " Formatting of unit %d failed "
"with rc = %d", "with rc = %d",
fdata->start_unit, rc); fdata->start_unit, rc);
@ -186,7 +186,7 @@ dasd_format(struct dasd_device * device, struct format_data_t * fdata)
static int static int
dasd_ioctl_format(struct block_device *bdev, void __user *argp) dasd_ioctl_format(struct block_device *bdev, void __user *argp)
{ {
struct dasd_device *device = bdev->bd_disk->private_data; struct dasd_block *block = bdev->bd_disk->private_data;
struct format_data_t fdata; struct format_data_t fdata;
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
@ -194,51 +194,47 @@ dasd_ioctl_format(struct block_device *bdev, void __user *argp)
if (!argp) if (!argp)
return -EINVAL; return -EINVAL;
if (device->features & DASD_FEATURE_READONLY) if (block->base->features & DASD_FEATURE_READONLY)
return -EROFS; return -EROFS;
if (copy_from_user(&fdata, argp, sizeof(struct format_data_t))) if (copy_from_user(&fdata, argp, sizeof(struct format_data_t)))
return -EFAULT; return -EFAULT;
if (bdev != bdev->bd_contains) { if (bdev != bdev->bd_contains) {
DEV_MESSAGE(KERN_WARNING, device, "%s", DEV_MESSAGE(KERN_WARNING, block->base, "%s",
"Cannot low-level format a partition"); "Cannot low-level format a partition");
return -EINVAL; return -EINVAL;
} }
return dasd_format(device, &fdata); return dasd_format(block, &fdata);
} }
#ifdef CONFIG_DASD_PROFILE #ifdef CONFIG_DASD_PROFILE
/* /*
* Reset device profile information * Reset device profile information
*/ */
static int static int dasd_ioctl_reset_profile(struct dasd_block *block)
dasd_ioctl_reset_profile(struct dasd_device *device)
{ {
memset(&device->profile, 0, sizeof (struct dasd_profile_info_t)); memset(&block->profile, 0, sizeof(struct dasd_profile_info_t));
return 0; return 0;
} }
/* /*
* Return device profile information * Return device profile information
*/ */
static int static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
dasd_ioctl_read_profile(struct dasd_device *device, void __user *argp)
{ {
if (dasd_profile_level == DASD_PROFILE_OFF) if (dasd_profile_level == DASD_PROFILE_OFF)
return -EIO; return -EIO;
if (copy_to_user(argp, &device->profile, if (copy_to_user(argp, &block->profile,
sizeof (struct dasd_profile_info_t))) sizeof(struct dasd_profile_info_t)))
return -EFAULT; return -EFAULT;
return 0; return 0;
} }
#else #else
static int static int dasd_ioctl_reset_profile(struct dasd_block *block)
dasd_ioctl_reset_profile(struct dasd_device *device)
{ {
return -ENOSYS; return -ENOSYS;
} }
static int static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
dasd_ioctl_read_profile(struct dasd_device *device, void __user *argp)
{ {
return -ENOSYS; return -ENOSYS;
} }
@ -247,87 +243,88 @@ dasd_ioctl_read_profile(struct dasd_device *device, void __user *argp)
/* /*
* Return dasd information. Used for BIODASDINFO and BIODASDINFO2. * Return dasd information. Used for BIODASDINFO and BIODASDINFO2.
*/ */
static int static int dasd_ioctl_information(struct dasd_block *block,
dasd_ioctl_information(struct dasd_device *device, unsigned int cmd, void __user *argp)
unsigned int cmd, void __user *argp)
{ {
struct dasd_information2_t *dasd_info; struct dasd_information2_t *dasd_info;
unsigned long flags; unsigned long flags;
int rc; int rc;
struct dasd_device *base;
struct ccw_device *cdev; struct ccw_device *cdev;
struct ccw_dev_id dev_id; struct ccw_dev_id dev_id;
if (!device->discipline->fill_info) base = block->base;
if (!base->discipline->fill_info)
return -EINVAL; return -EINVAL;
dasd_info = kzalloc(sizeof(struct dasd_information2_t), GFP_KERNEL); dasd_info = kzalloc(sizeof(struct dasd_information2_t), GFP_KERNEL);
if (dasd_info == NULL) if (dasd_info == NULL)
return -ENOMEM; return -ENOMEM;
rc = device->discipline->fill_info(device, dasd_info); rc = base->discipline->fill_info(base, dasd_info);
if (rc) { if (rc) {
kfree(dasd_info); kfree(dasd_info);
return rc; return rc;
} }
cdev = device->cdev; cdev = base->cdev;
ccw_device_get_id(cdev, &dev_id); ccw_device_get_id(cdev, &dev_id);
dasd_info->devno = dev_id.devno; dasd_info->devno = dev_id.devno;
dasd_info->schid = _ccw_device_get_subchannel_number(device->cdev); dasd_info->schid = _ccw_device_get_subchannel_number(base->cdev);
dasd_info->cu_type = cdev->id.cu_type; dasd_info->cu_type = cdev->id.cu_type;
dasd_info->cu_model = cdev->id.cu_model; dasd_info->cu_model = cdev->id.cu_model;
dasd_info->dev_type = cdev->id.dev_type; dasd_info->dev_type = cdev->id.dev_type;
dasd_info->dev_model = cdev->id.dev_model; dasd_info->dev_model = cdev->id.dev_model;
dasd_info->status = device->state; dasd_info->status = base->state;
/* /*
* The open_count is increased for every opener, that includes * The open_count is increased for every opener, that includes
* the blkdev_get in dasd_scan_partitions. * the blkdev_get in dasd_scan_partitions.
* This must be hidden from user-space. * This must be hidden from user-space.
*/ */
dasd_info->open_count = atomic_read(&device->open_count); dasd_info->open_count = atomic_read(&block->open_count);
if (!device->bdev) if (!block->bdev)
dasd_info->open_count++; dasd_info->open_count++;
/* /*
* check if device is really formatted * check if device is really formatted
* LDL / CDL was returned by 'fill_info' * LDL / CDL was returned by 'fill_info'
*/ */
if ((device->state < DASD_STATE_READY) || if ((base->state < DASD_STATE_READY) ||
(dasd_check_blocksize(device->bp_block))) (dasd_check_blocksize(block->bp_block)))
dasd_info->format = DASD_FORMAT_NONE; dasd_info->format = DASD_FORMAT_NONE;
dasd_info->features |= dasd_info->features |=
((device->features & DASD_FEATURE_READONLY) != 0); ((base->features & DASD_FEATURE_READONLY) != 0);
if (device->discipline) if (base->discipline)
memcpy(dasd_info->type, device->discipline->name, 4); memcpy(dasd_info->type, base->discipline->name, 4);
else else
memcpy(dasd_info->type, "none", 4); memcpy(dasd_info->type, "none", 4);
if (device->request_queue->request_fn) { if (block->request_queue->request_fn) {
struct list_head *l; struct list_head *l;
#ifdef DASD_EXTENDED_PROFILING #ifdef DASD_EXTENDED_PROFILING
{ {
struct list_head *l; struct list_head *l;
spin_lock_irqsave(&device->lock, flags); spin_lock_irqsave(&block->lock, flags);
list_for_each(l, &device->request_queue->queue_head) list_for_each(l, &block->request_queue->queue_head)
dasd_info->req_queue_len++; dasd_info->req_queue_len++;
spin_unlock_irqrestore(&device->lock, flags); spin_unlock_irqrestore(&block->lock, flags);
} }
#endif /* DASD_EXTENDED_PROFILING */ #endif /* DASD_EXTENDED_PROFILING */
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
list_for_each(l, &device->ccw_queue) list_for_each(l, &base->ccw_queue)
dasd_info->chanq_len++; dasd_info->chanq_len++;
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), spin_unlock_irqrestore(get_ccwdev_lock(base->cdev),
flags); flags);
} }
rc = 0; rc = 0;
if (copy_to_user(argp, dasd_info, if (copy_to_user(argp, dasd_info,
((cmd == (unsigned int) BIODASDINFO2) ? ((cmd == (unsigned int) BIODASDINFO2) ?
sizeof (struct dasd_information2_t) : sizeof(struct dasd_information2_t) :
sizeof (struct dasd_information_t)))) sizeof(struct dasd_information_t))))
rc = -EFAULT; rc = -EFAULT;
kfree(dasd_info); kfree(dasd_info);
return rc; return rc;
@ -339,7 +336,7 @@ dasd_ioctl_information(struct dasd_device *device,
static int static int
dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp) dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp)
{ {
struct dasd_device *device = bdev->bd_disk->private_data; struct dasd_block *block = bdev->bd_disk->private_data;
int intval; int intval;
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
@ -351,11 +348,10 @@ dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp)
return -EFAULT; return -EFAULT;
set_disk_ro(bdev->bd_disk, intval); set_disk_ro(bdev->bd_disk, intval);
return dasd_set_feature(device->cdev, DASD_FEATURE_READONLY, intval); return dasd_set_feature(block->base->cdev, DASD_FEATURE_READONLY, intval);
} }
static int static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
dasd_ioctl_readall_cmb(struct dasd_device *device, unsigned int cmd,
unsigned long arg) unsigned long arg)
{ {
struct cmbdata __user *argp = (void __user *) arg; struct cmbdata __user *argp = (void __user *) arg;
@ -363,7 +359,7 @@ dasd_ioctl_readall_cmb(struct dasd_device *device, unsigned int cmd,
struct cmbdata data; struct cmbdata data;
int ret; int ret;
ret = cmf_readall(device->cdev, &data); ret = cmf_readall(block->base->cdev, &data);
if (!ret && copy_to_user(argp, &data, min(size, sizeof(*argp)))) if (!ret && copy_to_user(argp, &data, min(size, sizeof(*argp))))
return -EFAULT; return -EFAULT;
return ret; return ret;
@ -374,10 +370,10 @@ dasd_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
struct block_device *bdev = inode->i_bdev; struct block_device *bdev = inode->i_bdev;
struct dasd_device *device = bdev->bd_disk->private_data; struct dasd_block *block = bdev->bd_disk->private_data;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
if (!device) if (!block)
return -ENODEV; return -ENODEV;
if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) { if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) {
@ -391,33 +387,33 @@ dasd_ioctl(struct inode *inode, struct file *file,
case BIODASDENABLE: case BIODASDENABLE:
return dasd_ioctl_enable(bdev); return dasd_ioctl_enable(bdev);
case BIODASDQUIESCE: case BIODASDQUIESCE:
return dasd_ioctl_quiesce(device); return dasd_ioctl_quiesce(block);
case BIODASDRESUME: case BIODASDRESUME:
return dasd_ioctl_resume(device); return dasd_ioctl_resume(block);
case BIODASDFMT: case BIODASDFMT:
return dasd_ioctl_format(bdev, argp); return dasd_ioctl_format(bdev, argp);
case BIODASDINFO: case BIODASDINFO:
return dasd_ioctl_information(device, cmd, argp); return dasd_ioctl_information(block, cmd, argp);
case BIODASDINFO2: case BIODASDINFO2:
return dasd_ioctl_information(device, cmd, argp); return dasd_ioctl_information(block, cmd, argp);
case BIODASDPRRD: case BIODASDPRRD:
return dasd_ioctl_read_profile(device, argp); return dasd_ioctl_read_profile(block, argp);
case BIODASDPRRST: case BIODASDPRRST:
return dasd_ioctl_reset_profile(device); return dasd_ioctl_reset_profile(block);
case BLKROSET: case BLKROSET:
return dasd_ioctl_set_ro(bdev, argp); return dasd_ioctl_set_ro(bdev, argp);
case DASDAPIVER: case DASDAPIVER:
return dasd_ioctl_api_version(argp); return dasd_ioctl_api_version(argp);
case BIODASDCMFENABLE: case BIODASDCMFENABLE:
return enable_cmf(device->cdev); return enable_cmf(block->base->cdev);
case BIODASDCMFDISABLE: case BIODASDCMFDISABLE:
return disable_cmf(device->cdev); return disable_cmf(block->base->cdev);
case BIODASDREADALLCMB: case BIODASDREADALLCMB:
return dasd_ioctl_readall_cmb(device, cmd, arg); return dasd_ioctl_readall_cmb(block, cmd, arg);
default: default:
/* if the discipline has an ioctl method try it. */ /* if the discipline has an ioctl method try it. */
if (device->discipline->ioctl) { if (block->base->discipline->ioctl) {
int rval = device->discipline->ioctl(device, cmd, argp); int rval = block->base->discipline->ioctl(block, cmd, argp);
if (rval != -ENOIOCTLCMD) if (rval != -ENOIOCTLCMD)
return rval; return rval;
} }

21
drivers/s390/block/dasd_proc.c
View File

@ -54,11 +54,16 @@ static int
dasd_devices_show(struct seq_file *m, void *v) dasd_devices_show(struct seq_file *m, void *v)
{ {
struct dasd_device *device; struct dasd_device *device;
struct dasd_block *block;
char *substr; char *substr;
device = dasd_device_from_devindex((unsigned long) v - 1); device = dasd_device_from_devindex((unsigned long) v - 1);
if (IS_ERR(device)) if (IS_ERR(device))
return 0; return 0;
if (device->block)
block = device->block;
else
return 0;
/* Print device number. */ /* Print device number. */
seq_printf(m, "%s", device->cdev->dev.bus_id); seq_printf(m, "%s", device->cdev->dev.bus_id);
/* Print discipline string. */ /* Print discipline string. */
@ -67,14 +72,14 @@ dasd_devices_show(struct seq_file *m, void *v)
else else
seq_printf(m, "(none)"); seq_printf(m, "(none)");
/* Print kdev. */ /* Print kdev. */
if (device->gdp) if (block->gdp)
seq_printf(m, " at (%3d:%6d)", seq_printf(m, " at (%3d:%6d)",
device->gdp->major, device->gdp->first_minor); block->gdp->major, block->gdp->first_minor);
else else
seq_printf(m, " at (???:??????)"); seq_printf(m, " at (???:??????)");
/* Print device name. */ /* Print device name. */
if (device->gdp) if (block->gdp)
seq_printf(m, " is %-8s", device->gdp->disk_name); seq_printf(m, " is %-8s", block->gdp->disk_name);
else else
seq_printf(m, " is ????????"); seq_printf(m, " is ????????");
/* Print devices features. */ /* Print devices features. */
@ -100,14 +105,14 @@ dasd_devices_show(struct seq_file *m, void *v)
case DASD_STATE_READY: case DASD_STATE_READY:
case DASD_STATE_ONLINE: case DASD_STATE_ONLINE:
seq_printf(m, "active "); seq_printf(m, "active ");
if (dasd_check_blocksize(device->bp_block)) if (dasd_check_blocksize(block->bp_block))
seq_printf(m, "n/f "); seq_printf(m, "n/f ");
else else
seq_printf(m, seq_printf(m,
"at blocksize: %d, %ld blocks, %ld MB", "at blocksize: %d, %ld blocks, %ld MB",
device->bp_block, device->blocks, block->bp_block, block->blocks,
((device->bp_block >> 9) * ((block->bp_block >> 9) *
device->blocks) >> 11); block->blocks) >> 11);
break; break;
default: default:
seq_printf(m, "no stat"); seq_printf(m, "no stat");