1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> 4 * Horst Hummel <Horst.Hummel@de.ibm.com> 5 * Carsten Otte <Cotte@de.ibm.com> 6 * Martin Schwidefsky <schwidefsky@de.ibm.com> 7 * Bugreports.to..: <Linux390@de.ibm.com> 8 * Copyright IBM Corp. 1999, 2009 9 * EMC Symmetrix ioctl Copyright EMC Corporation, 2008 10 * Author.........: Nigel Hislop <hislop_nigel@emc.com> 11 */ 12 13#include <linux/stddef.h> 14#include <linux/kernel.h> 15#include <linux/slab.h> 16#include <linux/hdreg.h> /* HDIO_GETGEO */ 17#include <linux/bio.h> 18#include <linux/module.h> 19#include <linux/compat.h> 20#include <linux/init.h> 21#include <linux/seq_file.h> 22#include <linux/uaccess.h> 23#include <linux/io.h> 24 25#include <asm/css_chars.h> 26#include <asm/debug.h> 27#include <asm/idals.h> 28#include <asm/ebcdic.h> 29#include <asm/cio.h> 30#include <asm/ccwdev.h> 31#include <asm/itcw.h> 32#include <asm/schid.h> 33#include <asm/chpid.h> 34 35#include "dasd_int.h" 36#include "dasd_eckd.h" 37 38/* 39 * raw track access always map to 64k in memory 40 * so it maps to 16 blocks of 4k per track 41 */ 42#define DASD_RAW_BLOCK_PER_TRACK 16 43#define DASD_RAW_BLOCKSIZE 4096 44/* 64k are 128 x 512 byte sectors */ 45#define DASD_RAW_SECTORS_PER_TRACK 128 46 47MODULE_LICENSE("GPL"); 48 49static struct dasd_discipline dasd_eckd_discipline; 50 51/* The ccw bus type uses this table to find devices that it sends to 52 * dasd_eckd_probe */ 53static struct ccw_device_id dasd_eckd_ids[] = { 54 { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3390, 0), .driver_info = 0x1}, 55 { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3390, 0), .driver_info = 0x2}, 56 { CCW_DEVICE_DEVTYPE (0x3880, 0, 0x3380, 0), .driver_info = 0x3}, 57 { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3380, 0), .driver_info = 0x4}, 58 { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3380, 0), .driver_info = 0x5}, 59 { CCW_DEVICE_DEVTYPE (0x9343, 0, 0x9345, 0), .driver_info = 0x6}, 60 { CCW_DEVICE_DEVTYPE (0x2107, 0, 0x3390, 0), .driver_info = 0x7}, 61 { CCW_DEVICE_DEVTYPE (0x2107, 0, 0x3380, 0), .driver_info = 0x8}, 62 { CCW_DEVICE_DEVTYPE (0x1750, 0, 0x3390, 0), .driver_info = 0x9}, 63 { CCW_DEVICE_DEVTYPE (0x1750, 0, 0x3380, 0), .driver_info = 0xa}, 64 { /* end of list */ }, 65}; 66 67MODULE_DEVICE_TABLE(ccw, dasd_eckd_ids); 68 69static struct ccw_driver dasd_eckd_driver; /* see below */ 70 71static void *rawpadpage; 72 73#define INIT_CQR_OK 0 74#define INIT_CQR_UNFORMATTED 1 75#define INIT_CQR_ERROR 2 76 77/* emergency request for reserve/release */ 78static struct { 79 struct dasd_ccw_req cqr; 80 struct ccw1 ccw; 81 char data[32]; 82} *dasd_reserve_req; 83static DEFINE_MUTEX(dasd_reserve_mutex); 84 85static struct { 86 struct dasd_ccw_req cqr; 87 struct ccw1 ccw[2]; 88 char data[40]; 89} *dasd_vol_info_req; 90static DEFINE_MUTEX(dasd_vol_info_mutex); 91 92struct ext_pool_exhaust_work_data { 93 struct work_struct worker; 94 struct dasd_device *device; 95 struct dasd_device *base; 96}; 97 98/* definitions for the path verification worker */ 99struct pe_handler_work_data { 100 struct work_struct worker; 101 struct dasd_device *device; 102 struct dasd_ccw_req cqr; 103 struct ccw1 ccw; 104 __u8 rcd_buffer[DASD_ECKD_RCD_DATA_SIZE]; 105 int isglobal; 106 __u8 tbvpm; 107 __u8 fcsecpm; 108}; 109static struct pe_handler_work_data *pe_handler_worker; 110static DEFINE_MUTEX(dasd_pe_handler_mutex); 111 112struct check_attention_work_data { 113 struct work_struct worker; 114 struct dasd_device *device; 115 __u8 lpum; 116}; 117 118static int dasd_eckd_ext_pool_id(struct dasd_device *); 119static int prepare_itcw(struct itcw *, unsigned int, unsigned int, int, 120 struct dasd_device *, struct dasd_device *, 121 unsigned int, int, unsigned int, unsigned int, 122 unsigned int, unsigned int); 123static int dasd_eckd_query_pprc_status(struct dasd_device *, 124 struct dasd_pprc_data_sc4 *); 125 126/* initial attempt at a probe function. this can be simplified once 127 * the other detection code is gone */ 128static int 129dasd_eckd_probe (struct ccw_device *cdev) 130{ 131 int ret; 132 133 /* set ECKD specific ccw-device options */ 134 ret = ccw_device_set_options(cdev, CCWDEV_ALLOW_FORCE | 135 CCWDEV_DO_PATHGROUP | CCWDEV_DO_MULTIPATH); 136 if (ret) { 137 DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s", 138 "dasd_eckd_probe: could not set " 139 "ccw-device options"); 140 return ret; 141 } 142 ret = dasd_generic_probe(cdev); 143 return ret; 144} 145 146static int 147dasd_eckd_set_online(struct ccw_device *cdev) 148{ 149 return dasd_generic_set_online(cdev, &dasd_eckd_discipline); 150} 151 152static const int sizes_trk0[] = { 28, 148, 84 }; 153#define LABEL_SIZE 140 154 155/* head and record addresses of count_area read in analysis ccw */ 156static const int count_area_head[] = { 0, 0, 0, 0, 1 }; 157static const int count_area_rec[] = { 1, 2, 3, 4, 1 }; 158 159static inline unsigned int 160ceil_quot(unsigned int d1, unsigned int d2) 161{ 162 return (d1 + (d2 - 1)) / d2; 163} 164 165static unsigned int 166recs_per_track(struct dasd_eckd_characteristics * rdc, 167 unsigned int kl, unsigned int dl) 168{ 169 int dn, kn; 170 171 switch (rdc->dev_type) { 172 case 0x3380: 173 if (kl) 174 return 1499 / (15 + 7 + ceil_quot(kl + 12, 32) + 175 ceil_quot(dl + 12, 32)); 176 else 177 return 1499 / (15 + ceil_quot(dl + 12, 32)); 178 case 0x3390: 179 dn = ceil_quot(dl + 6, 232) + 1; 180 if (kl) { 181 kn = ceil_quot(kl + 6, 232) + 1; 182 return 1729 / (10 + 9 + ceil_quot(kl + 6 * kn, 34) + 183 9 + ceil_quot(dl + 6 * dn, 34)); 184 } else 185 return 1729 / (10 + 9 + ceil_quot(dl + 6 * dn, 34)); 186 case 0x9345: 187 dn = ceil_quot(dl + 6, 232) + 1; 188 if (kl) { 189 kn = ceil_quot(kl + 6, 232) + 1; 190 return 1420 / (18 + 7 + ceil_quot(kl + 6 * kn, 34) + 191 ceil_quot(dl + 6 * dn, 34)); 192 } else 193 return 1420 / (18 + 7 + ceil_quot(dl + 6 * dn, 34)); 194 } 195 return 0; 196} 197 198static void set_ch_t(struct ch_t *geo, __u32 cyl, __u8 head) 199{ 200 geo->cyl = (__u16) cyl; 201 geo->head = cyl >> 16; 202 geo->head <<= 4; 203 geo->head |= head; 204} 205 206/* 207 * calculate failing track from sense data depending if 208 * it is an EAV device or not 209 */ 210static int dasd_eckd_track_from_irb(struct irb *irb, struct dasd_device *device, 211 sector_t *track) 212{ 213 struct dasd_eckd_private *private = device->private; 214 u8 *sense = NULL; 215 u32 cyl; 216 u8 head; 217 218 sense = dasd_get_sense(irb); 219 if (!sense) { 220 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 221 "ESE error no sense data\n"); 222 return -EINVAL; 223 } 224 if (!(sense[27] & DASD_SENSE_BIT_2)) { 225 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 226 "ESE error no valid track data\n"); 227 return -EINVAL; 228 } 229 230 if (sense[27] & DASD_SENSE_BIT_3) { 231 /* enhanced addressing */ 232 cyl = sense[30] << 20; 233 cyl |= (sense[31] & 0xF0) << 12; 234 cyl |= sense[28] << 8; 235 cyl |= sense[29]; 236 } else { 237 cyl = sense[29] << 8; 238 cyl |= sense[30]; 239 } 240 head = sense[31] & 0x0F; 241 *track = cyl * private->rdc_data.trk_per_cyl + head; 242 return 0; 243} 244 245static int set_timestamp(struct ccw1 *ccw, struct DE_eckd_data *data, 246 struct dasd_device *device) 247{ 248 struct dasd_eckd_private *private = device->private; 249 int rc; 250 251 rc = get_phys_clock(&data->ep_sys_time); 252 /* 253 * Ignore return code if XRC is not supported or 254 * sync clock is switched off 255 */ 256 if ((rc && !private->rdc_data.facilities.XRC_supported) || 257 rc == -EOPNOTSUPP || rc == -EACCES) 258 return 0; 259 260 /* switch on System Time Stamp - needed for XRC Support */ 261 data->ga_extended |= 0x08; /* switch on 'Time Stamp Valid' */ 262 data->ga_extended |= 0x02; /* switch on 'Extended Parameter' */ 263 264 if (ccw) { 265 ccw->count = sizeof(struct DE_eckd_data); 266 ccw->flags |= CCW_FLAG_SLI; 267 } 268 269 return rc; 270} 271 272static int 273define_extent(struct ccw1 *ccw, struct DE_eckd_data *data, unsigned int trk, 274 unsigned int totrk, int cmd, struct dasd_device *device, 275 int blksize) 276{ 277 struct dasd_eckd_private *private = device->private; 278 u16 heads, beghead, endhead; 279 u32 begcyl, endcyl; 280 int rc = 0; 281 282 if (ccw) { 283 ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT; 284 ccw->flags = 0; 285 ccw->count = 16; 286 ccw->cda = virt_to_dma32(data); 287 } 288 289 memset(data, 0, sizeof(struct DE_eckd_data)); 290 switch (cmd) { 291 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 292 case DASD_ECKD_CCW_READ_RECORD_ZERO: 293 case DASD_ECKD_CCW_READ: 294 case DASD_ECKD_CCW_READ_MT: 295 case DASD_ECKD_CCW_READ_CKD: 296 case DASD_ECKD_CCW_READ_CKD_MT: 297 case DASD_ECKD_CCW_READ_KD: 298 case DASD_ECKD_CCW_READ_KD_MT: 299 data->mask.perm = 0x1; 300 data->attributes.operation = private->attrib.operation; 301 break; 302 case DASD_ECKD_CCW_READ_COUNT: 303 data->mask.perm = 0x1; 304 data->attributes.operation = DASD_BYPASS_CACHE; 305 break; 306 case DASD_ECKD_CCW_READ_TRACK: 307 case DASD_ECKD_CCW_READ_TRACK_DATA: 308 data->mask.perm = 0x1; 309 data->attributes.operation = private->attrib.operation; 310 data->blk_size = 0; 311 break; 312 case DASD_ECKD_CCW_WRITE: 313 case DASD_ECKD_CCW_WRITE_MT: 314 case DASD_ECKD_CCW_WRITE_KD: 315 case DASD_ECKD_CCW_WRITE_KD_MT: 316 data->mask.perm = 0x02; 317 data->attributes.operation = private->attrib.operation; 318 rc = set_timestamp(ccw, data, device); 319 break; 320 case DASD_ECKD_CCW_WRITE_CKD: 321 case DASD_ECKD_CCW_WRITE_CKD_MT: 322 data->attributes.operation = DASD_BYPASS_CACHE; 323 rc = set_timestamp(ccw, data, device); 324 break; 325 case DASD_ECKD_CCW_ERASE: 326 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 327 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 328 data->mask.perm = 0x3; 329 data->mask.auth = 0x1; 330 data->attributes.operation = DASD_BYPASS_CACHE; 331 rc = set_timestamp(ccw, data, device); 332 break; 333 case DASD_ECKD_CCW_WRITE_FULL_TRACK: 334 data->mask.perm = 0x03; 335 data->attributes.operation = private->attrib.operation; 336 data->blk_size = 0; 337 break; 338 case DASD_ECKD_CCW_WRITE_TRACK_DATA: 339 data->mask.perm = 0x02; 340 data->attributes.operation = private->attrib.operation; 341 data->blk_size = blksize; 342 rc = set_timestamp(ccw, data, device); 343 break; 344 default: 345 dev_err(&device->cdev->dev, 346 "0x%x is not a known command\n", cmd); 347 break; 348 } 349 350 data->attributes.mode = 0x3; /* ECKD */ 351 352 if ((private->rdc_data.cu_type == 0x2105 || 353 private->rdc_data.cu_type == 0x2107 || 354 private->rdc_data.cu_type == 0x1750) 355 && !(private->uses_cdl && trk < 2)) 356 data->ga_extended |= 0x40; /* Regular Data Format Mode */ 357 358 heads = private->rdc_data.trk_per_cyl; 359 begcyl = trk / heads; 360 beghead = trk % heads; 361 endcyl = totrk / heads; 362 endhead = totrk % heads; 363 364 /* check for sequential prestage - enhance cylinder range */ 365 if (data->attributes.operation == DASD_SEQ_PRESTAGE || 366 data->attributes.operation == DASD_SEQ_ACCESS) { 367 368 if (endcyl + private->attrib.nr_cyl < private->real_cyl) 369 endcyl += private->attrib.nr_cyl; 370 else 371 endcyl = (private->real_cyl - 1); 372 } 373 374 set_ch_t(&data->beg_ext, begcyl, beghead); 375 set_ch_t(&data->end_ext, endcyl, endhead); 376 return rc; 377} 378 379 380static void locate_record_ext(struct ccw1 *ccw, struct LRE_eckd_data *data, 381 unsigned int trk, unsigned int rec_on_trk, 382 int count, int cmd, struct dasd_device *device, 383 unsigned int reclen, unsigned int tlf) 384{ 385 struct dasd_eckd_private *private = device->private; 386 int sector; 387 int dn, d; 388 389 if (ccw) { 390 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD_EXT; 391 ccw->flags = 0; 392 if (cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK) 393 ccw->count = 22; 394 else 395 ccw->count = 20; 396 ccw->cda = virt_to_dma32(data); 397 } 398 399 memset(data, 0, sizeof(*data)); 400 sector = 0; 401 if (rec_on_trk) { 402 switch (private->rdc_data.dev_type) { 403 case 0x3390: 404 dn = ceil_quot(reclen + 6, 232); 405 d = 9 + ceil_quot(reclen + 6 * (dn + 1), 34); 406 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8; 407 break; 408 case 0x3380: 409 d = 7 + ceil_quot(reclen + 12, 32); 410 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7; 411 break; 412 } 413 } 414 data->sector = sector; 415 /* note: meaning of count depends on the operation 416 * for record based I/O it's the number of records, but for 417 * track based I/O it's the number of tracks 418 */ 419 data->count = count; 420 switch (cmd) { 421 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 422 data->operation.orientation = 0x3; 423 data->operation.operation = 0x03; 424 break; 425 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 426 data->operation.orientation = 0x3; 427 data->operation.operation = 0x16; 428 break; 429 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 430 data->operation.orientation = 0x1; 431 data->operation.operation = 0x03; 432 data->count++; 433 break; 434 case DASD_ECKD_CCW_READ_RECORD_ZERO: 435 data->operation.orientation = 0x3; 436 data->operation.operation = 0x16; 437 data->count++; 438 break; 439 case DASD_ECKD_CCW_WRITE: 440 case DASD_ECKD_CCW_WRITE_MT: 441 case DASD_ECKD_CCW_WRITE_KD: 442 case DASD_ECKD_CCW_WRITE_KD_MT: 443 data->auxiliary.length_valid = 0x1; 444 data->length = reclen; 445 data->operation.operation = 0x01; 446 break; 447 case DASD_ECKD_CCW_WRITE_CKD: 448 case DASD_ECKD_CCW_WRITE_CKD_MT: 449 data->auxiliary.length_valid = 0x1; 450 data->length = reclen; 451 data->operation.operation = 0x03; 452 break; 453 case DASD_ECKD_CCW_WRITE_FULL_TRACK: 454 data->operation.orientation = 0x0; 455 data->operation.operation = 0x3F; 456 data->extended_operation = 0x11; 457 data->length = 0; 458 data->extended_parameter_length = 0x02; 459 if (data->count > 8) { 460 data->extended_parameter[0] = 0xFF; 461 data->extended_parameter[1] = 0xFF; 462 data->extended_parameter[1] <<= (16 - count); 463 } else { 464 data->extended_parameter[0] = 0xFF; 465 data->extended_parameter[0] <<= (8 - count); 466 data->extended_parameter[1] = 0x00; 467 } 468 data->sector = 0xFF; 469 break; 470 case DASD_ECKD_CCW_WRITE_TRACK_DATA: 471 data->auxiliary.length_valid = 0x1; 472 data->length = reclen; /* not tlf, as one might think */ 473 data->operation.operation = 0x3F; 474 data->extended_operation = 0x23; 475 break; 476 case DASD_ECKD_CCW_READ: 477 case DASD_ECKD_CCW_READ_MT: 478 case DASD_ECKD_CCW_READ_KD: 479 case DASD_ECKD_CCW_READ_KD_MT: 480 data->auxiliary.length_valid = 0x1; 481 data->length = reclen; 482 data->operation.operation = 0x06; 483 break; 484 case DASD_ECKD_CCW_READ_CKD: 485 case DASD_ECKD_CCW_READ_CKD_MT: 486 data->auxiliary.length_valid = 0x1; 487 data->length = reclen; 488 data->operation.operation = 0x16; 489 break; 490 case DASD_ECKD_CCW_READ_COUNT: 491 data->operation.operation = 0x06; 492 break; 493 case DASD_ECKD_CCW_READ_TRACK: 494 data->operation.orientation = 0x1; 495 data->operation.operation = 0x0C; 496 data->extended_parameter_length = 0; 497 data->sector = 0xFF; 498 break; 499 case DASD_ECKD_CCW_READ_TRACK_DATA: 500 data->auxiliary.length_valid = 0x1; 501 data->length = tlf; 502 data->operation.operation = 0x0C; 503 break; 504 case DASD_ECKD_CCW_ERASE: 505 data->length = reclen; 506 data->auxiliary.length_valid = 0x1; 507 data->operation.operation = 0x0b; 508 break; 509 default: 510 DBF_DEV_EVENT(DBF_ERR, device, 511 "fill LRE unknown opcode 0x%x", cmd); 512 BUG(); 513 } 514 set_ch_t(&data->seek_addr, 515 trk / private->rdc_data.trk_per_cyl, 516 trk % private->rdc_data.trk_per_cyl); 517 data->search_arg.cyl = data->seek_addr.cyl; 518 data->search_arg.head = data->seek_addr.head; 519 data->search_arg.record = rec_on_trk; 520} 521 522static int prefix_LRE(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata, 523 unsigned int trk, unsigned int totrk, int cmd, 524 struct dasd_device *basedev, struct dasd_device *startdev, 525 unsigned int format, unsigned int rec_on_trk, int count, 526 unsigned int blksize, unsigned int tlf) 527{ 528 struct dasd_eckd_private *basepriv, *startpriv; 529 struct LRE_eckd_data *lredata; 530 struct DE_eckd_data *dedata; 531 int rc = 0; 532 533 basepriv = basedev->private; 534 startpriv = startdev->private; 535 dedata = &pfxdata->define_extent; 536 lredata = &pfxdata->locate_record; 537 538 ccw->cmd_code = DASD_ECKD_CCW_PFX; 539 ccw->flags = 0; 540 if (cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK) { 541 ccw->count = sizeof(*pfxdata) + 2; 542 ccw->cda = virt_to_dma32(pfxdata); 543 memset(pfxdata, 0, sizeof(*pfxdata) + 2); 544 } else { 545 ccw->count = sizeof(*pfxdata); 546 ccw->cda = virt_to_dma32(pfxdata); 547 memset(pfxdata, 0, sizeof(*pfxdata)); 548 } 549 550 /* prefix data */ 551 if (format > 1) { 552 DBF_DEV_EVENT(DBF_ERR, basedev, 553 "PFX LRE unknown format 0x%x", format); 554 BUG(); 555 return -EINVAL; 556 } 557 pfxdata->format = format; 558 pfxdata->base_address = basepriv->conf.ned->unit_addr; 559 pfxdata->base_lss = basepriv->conf.ned->ID; 560 pfxdata->validity.define_extent = 1; 561 562 /* private uid is kept up to date, conf_data may be outdated */ 563 if (startpriv->uid.type == UA_BASE_PAV_ALIAS) 564 pfxdata->validity.verify_base = 1; 565 566 if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) { 567 pfxdata->validity.verify_base = 1; 568 pfxdata->validity.hyper_pav = 1; 569 } 570 571 rc = define_extent(NULL, dedata, trk, totrk, cmd, basedev, blksize); 572 573 /* 574 * For some commands the System Time Stamp is set in the define extent 575 * data when XRC is supported. The validity of the time stamp must be 576 * reflected in the prefix data as well. 577 */ 578 if (dedata->ga_extended & 0x08 && dedata->ga_extended & 0x02) 579 pfxdata->validity.time_stamp = 1; /* 'Time Stamp Valid' */ 580 581 if (format == 1) { 582 locate_record_ext(NULL, lredata, trk, rec_on_trk, count, cmd, 583 basedev, blksize, tlf); 584 } 585 586 return rc; 587} 588 589static int prefix(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata, 590 unsigned int trk, unsigned int totrk, int cmd, 591 struct dasd_device *basedev, struct dasd_device *startdev) 592{ 593 return prefix_LRE(ccw, pfxdata, trk, totrk, cmd, basedev, startdev, 594 0, 0, 0, 0, 0); 595} 596 597static void 598locate_record(struct ccw1 *ccw, struct LO_eckd_data *data, unsigned int trk, 599 unsigned int rec_on_trk, int no_rec, int cmd, 600 struct dasd_device * device, int reclen) 601{ 602 struct dasd_eckd_private *private = device->private; 603 int sector; 604 int dn, d; 605 606 DBF_DEV_EVENT(DBF_INFO, device, 607 "Locate: trk %d, rec %d, no_rec %d, cmd %d, reclen %d", 608 trk, rec_on_trk, no_rec, cmd, reclen); 609 610 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD; 611 ccw->flags = 0; 612 ccw->count = 16; 613 ccw->cda = virt_to_dma32(data); 614 615 memset(data, 0, sizeof(struct LO_eckd_data)); 616 sector = 0; 617 if (rec_on_trk) { 618 switch (private->rdc_data.dev_type) { 619 case 0x3390: 620 dn = ceil_quot(reclen + 6, 232); 621 d = 9 + ceil_quot(reclen + 6 * (dn + 1), 34); 622 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8; 623 break; 624 case 0x3380: 625 d = 7 + ceil_quot(reclen + 12, 32); 626 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7; 627 break; 628 } 629 } 630 data->sector = sector; 631 data->count = no_rec; 632 switch (cmd) { 633 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 634 data->operation.orientation = 0x3; 635 data->operation.operation = 0x03; 636 break; 637 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 638 data->operation.orientation = 0x3; 639 data->operation.operation = 0x16; 640 break; 641 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 642 data->operation.orientation = 0x1; 643 data->operation.operation = 0x03; 644 data->count++; 645 break; 646 case DASD_ECKD_CCW_READ_RECORD_ZERO: 647 data->operation.orientation = 0x3; 648 data->operation.operation = 0x16; 649 data->count++; 650 break; 651 case DASD_ECKD_CCW_WRITE: 652 case DASD_ECKD_CCW_WRITE_MT: 653 case DASD_ECKD_CCW_WRITE_KD: 654 case DASD_ECKD_CCW_WRITE_KD_MT: 655 data->auxiliary.last_bytes_used = 0x1; 656 data->length = reclen; 657 data->operation.operation = 0x01; 658 break; 659 case DASD_ECKD_CCW_WRITE_CKD: 660 case DASD_ECKD_CCW_WRITE_CKD_MT: 661 data->auxiliary.last_bytes_used = 0x1; 662 data->length = reclen; 663 data->operation.operation = 0x03; 664 break; 665 case DASD_ECKD_CCW_READ: 666 case DASD_ECKD_CCW_READ_MT: 667 case DASD_ECKD_CCW_READ_KD: 668 case DASD_ECKD_CCW_READ_KD_MT: 669 data->auxiliary.last_bytes_used = 0x1; 670 data->length = reclen; 671 data->operation.operation = 0x06; 672 break; 673 case DASD_ECKD_CCW_READ_CKD: 674 case DASD_ECKD_CCW_READ_CKD_MT: 675 data->auxiliary.last_bytes_used = 0x1; 676 data->length = reclen; 677 data->operation.operation = 0x16; 678 break; 679 case DASD_ECKD_CCW_READ_COUNT: 680 data->operation.operation = 0x06; 681 break; 682 case DASD_ECKD_CCW_ERASE: 683 data->length = reclen; 684 data->auxiliary.last_bytes_used = 0x1; 685 data->operation.operation = 0x0b; 686 break; 687 default: 688 DBF_DEV_EVENT(DBF_ERR, device, "unknown locate record " 689 "opcode 0x%x", cmd); 690 } 691 set_ch_t(&data->seek_addr, 692 trk / private->rdc_data.trk_per_cyl, 693 trk % private->rdc_data.trk_per_cyl); 694 data->search_arg.cyl = data->seek_addr.cyl; 695 data->search_arg.head = data->seek_addr.head; 696 data->search_arg.record = rec_on_trk; 697} 698 699/* 700 * Returns 1 if the block is one of the special blocks that needs 701 * to get read/written with the KD variant of the command. 702 * That is DASD_ECKD_READ_KD_MT instead of DASD_ECKD_READ_MT and 703 * DASD_ECKD_WRITE_KD_MT instead of DASD_ECKD_WRITE_MT. 704 * Luckily the KD variants differ only by one bit (0x08) from the 705 * normal variant. So don't wonder about code like: 706 * if (dasd_eckd_cdl_special(blk_per_trk, recid)) 707 * ccw->cmd_code |= 0x8; 708 */ 709static inline int 710dasd_eckd_cdl_special(int blk_per_trk, int recid) 711{ 712 if (recid < 3) 713 return 1; 714 if (recid < blk_per_trk) 715 return 0; 716 if (recid < 2 * blk_per_trk) 717 return 1; 718 return 0; 719} 720 721/* 722 * Returns the record size for the special blocks of the cdl format. 723 * Only returns something useful if dasd_eckd_cdl_special is true 724 * for the recid. 725 */ 726static inline int 727dasd_eckd_cdl_reclen(int recid) 728{ 729 if (recid < 3) 730 return sizes_trk0[recid]; 731 return LABEL_SIZE; 732} 733/* create unique id from private structure. */ 734static void create_uid(struct dasd_conf *conf, struct dasd_uid *uid) 735{ 736 int count; 737 738 memset(uid, 0, sizeof(struct dasd_uid)); 739 memcpy(uid->vendor, conf->ned->HDA_manufacturer, 740 sizeof(uid->vendor) - 1); 741 EBCASC(uid->vendor, sizeof(uid->vendor) - 1); 742 memcpy(uid->serial, &conf->ned->serial, 743 sizeof(uid->serial) - 1); 744 EBCASC(uid->serial, sizeof(uid->serial) - 1); 745 uid->ssid = conf->gneq->subsystemID; 746 uid->real_unit_addr = conf->ned->unit_addr; 747 if (conf->sneq) { 748 uid->type = conf->sneq->sua_flags; 749 if (uid->type == UA_BASE_PAV_ALIAS) 750 uid->base_unit_addr = conf->sneq->base_unit_addr; 751 } else { 752 uid->type = UA_BASE_DEVICE; 753 } 754 if (conf->vdsneq) { 755 for (count = 0; count < 16; count++) { 756 sprintf(uid->vduit+2*count, "%02x", 757 conf->vdsneq->uit[count]); 758 } 759 } 760} 761 762/* 763 * Generate device unique id that specifies the physical device. 764 */ 765static int dasd_eckd_generate_uid(struct dasd_device *device) 766{ 767 struct dasd_eckd_private *private = device->private; 768 unsigned long flags; 769 770 if (!private) 771 return -ENODEV; 772 if (!private->conf.ned || !private->conf.gneq) 773 return -ENODEV; 774 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 775 create_uid(&private->conf, &private->uid); 776 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 777 return 0; 778} 779 780static int dasd_eckd_get_uid(struct dasd_device *device, struct dasd_uid *uid) 781{ 782 struct dasd_eckd_private *private = device->private; 783 unsigned long flags; 784 785 if (private) { 786 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 787 *uid = private->uid; 788 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 789 return 0; 790 } 791 return -EINVAL; 792} 793 794/* 795 * compare device UID with data of a given dasd_eckd_private structure 796 * return 0 for match 797 */ 798static int dasd_eckd_compare_path_uid(struct dasd_device *device, 799 struct dasd_conf *path_conf) 800{ 801 struct dasd_uid device_uid; 802 struct dasd_uid path_uid; 803 804 create_uid(path_conf, &path_uid); 805 dasd_eckd_get_uid(device, &device_uid); 806 807 return memcmp(&device_uid, &path_uid, sizeof(struct dasd_uid)); 808} 809 810static void dasd_eckd_fill_rcd_cqr(struct dasd_device *device, 811 struct dasd_ccw_req *cqr, 812 __u8 *rcd_buffer, 813 __u8 lpm) 814{ 815 struct ccw1 *ccw; 816 /* 817 * buffer has to start with EBCDIC "V1.0" to show 818 * support for virtual device SNEQ 819 */ 820 rcd_buffer[0] = 0xE5; 821 rcd_buffer[1] = 0xF1; 822 rcd_buffer[2] = 0x4B; 823 rcd_buffer[3] = 0xF0; 824 825 ccw = cqr->cpaddr; 826 ccw->cmd_code = DASD_ECKD_CCW_RCD; 827 ccw->flags = 0; 828 ccw->cda = virt_to_dma32(rcd_buffer); 829 ccw->count = DASD_ECKD_RCD_DATA_SIZE; 830 cqr->magic = DASD_ECKD_MAGIC; 831 832 cqr->startdev = device; 833 cqr->memdev = device; 834 cqr->block = NULL; 835 cqr->expires = 10*HZ; 836 cqr->lpm = lpm; 837 cqr->retries = 256; 838 cqr->buildclk = get_tod_clock(); 839 cqr->status = DASD_CQR_FILLED; 840 set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags); 841} 842 843/* 844 * Wakeup helper for read_conf 845 * if the cqr is not done and needs some error recovery 846 * the buffer has to be re-initialized with the EBCDIC "V1.0" 847 * to show support for virtual device SNEQ 848 */ 849static void read_conf_cb(struct dasd_ccw_req *cqr, void *data) 850{ 851 struct ccw1 *ccw; 852 __u8 *rcd_buffer; 853 854 if (cqr->status != DASD_CQR_DONE) { 855 ccw = cqr->cpaddr; 856 rcd_buffer = dma32_to_virt(ccw->cda); 857 memset(rcd_buffer, 0, sizeof(*rcd_buffer)); 858 859 rcd_buffer[0] = 0xE5; 860 rcd_buffer[1] = 0xF1; 861 rcd_buffer[2] = 0x4B; 862 rcd_buffer[3] = 0xF0; 863 } 864 dasd_wakeup_cb(cqr, data); 865} 866 867static int dasd_eckd_read_conf_immediately(struct dasd_device *device, 868 struct dasd_ccw_req *cqr, 869 __u8 *rcd_buffer, 870 __u8 lpm) 871{ 872 struct ciw *ciw; 873 int rc; 874 /* 875 * sanity check: scan for RCD command in extended SenseID data 876 * some devices do not support RCD 877 */ 878 ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD); 879 if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD) 880 return -EOPNOTSUPP; 881 882 dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buffer, lpm); 883 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 884 set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags); 885 cqr->retries = 5; 886 cqr->callback = read_conf_cb; 887 rc = dasd_sleep_on_immediatly(cqr); 888 return rc; 889} 890 891static int dasd_eckd_read_conf_lpm(struct dasd_device *device, 892 void **rcd_buffer, 893 int *rcd_buffer_size, __u8 lpm) 894{ 895 struct ciw *ciw; 896 char *rcd_buf = NULL; 897 int ret; 898 struct dasd_ccw_req *cqr; 899 900 /* 901 * sanity check: scan for RCD command in extended SenseID data 902 * some devices do not support RCD 903 */ 904 ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD); 905 if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD) { 906 ret = -EOPNOTSUPP; 907 goto out_error; 908 } 909 rcd_buf = kzalloc(DASD_ECKD_RCD_DATA_SIZE, GFP_KERNEL | GFP_DMA); 910 if (!rcd_buf) { 911 ret = -ENOMEM; 912 goto out_error; 913 } 914 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* RCD */, 915 0, /* use rcd_buf as data ara */ 916 device, NULL); 917 if (IS_ERR(cqr)) { 918 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 919 "Could not allocate RCD request"); 920 ret = -ENOMEM; 921 goto out_error; 922 } 923 dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buf, lpm); 924 cqr->callback = read_conf_cb; 925 ret = dasd_sleep_on(cqr); 926 /* 927 * on success we update the user input parms 928 */ 929 dasd_sfree_request(cqr, cqr->memdev); 930 if (ret) 931 goto out_error; 932 933 *rcd_buffer_size = DASD_ECKD_RCD_DATA_SIZE; 934 *rcd_buffer = rcd_buf; 935 return 0; 936out_error: 937 kfree(rcd_buf); 938 *rcd_buffer = NULL; 939 *rcd_buffer_size = 0; 940 return ret; 941} 942 943static int dasd_eckd_identify_conf_parts(struct dasd_conf *conf) 944{ 945 946 struct dasd_sneq *sneq; 947 int i, count; 948 949 conf->ned = NULL; 950 conf->sneq = NULL; 951 conf->vdsneq = NULL; 952 conf->gneq = NULL; 953 count = conf->len / sizeof(struct dasd_sneq); 954 sneq = (struct dasd_sneq *)conf->data; 955 for (i = 0; i < count; ++i) { 956 if (sneq->flags.identifier == 1 && sneq->format == 1) 957 conf->sneq = sneq; 958 else if (sneq->flags.identifier == 1 && sneq->format == 4) 959 conf->vdsneq = (struct vd_sneq *)sneq; 960 else if (sneq->flags.identifier == 2) 961 conf->gneq = (struct dasd_gneq *)sneq; 962 else if (sneq->flags.identifier == 3 && sneq->res1 == 1) 963 conf->ned = (struct dasd_ned *)sneq; 964 sneq++; 965 } 966 if (!conf->ned || !conf->gneq) { 967 conf->ned = NULL; 968 conf->sneq = NULL; 969 conf->vdsneq = NULL; 970 conf->gneq = NULL; 971 return -EINVAL; 972 } 973 return 0; 974 975}; 976 977static unsigned char dasd_eckd_path_access(void *conf_data, int conf_len) 978{ 979 struct dasd_gneq *gneq; 980 int i, count, found; 981 982 count = conf_len / sizeof(*gneq); 983 gneq = (struct dasd_gneq *)conf_data; 984 found = 0; 985 for (i = 0; i < count; ++i) { 986 if (gneq->flags.identifier == 2) { 987 found = 1; 988 break; 989 } 990 gneq++; 991 } 992 if (found) 993 return ((char *)gneq)[18] & 0x07; 994 else 995 return 0; 996} 997 998static void dasd_eckd_store_conf_data(struct dasd_device *device, 999 struct dasd_conf_data *conf_data, int chp) 1000{ 1001 struct dasd_eckd_private *private = device->private; 1002 struct channel_path_desc_fmt0 *chp_desc; 1003 struct subchannel_id sch_id; 1004 void *cdp; 1005 1006 /* 1007 * path handling and read_conf allocate data 1008 * free it before replacing the pointer 1009 * also replace the old private->conf_data pointer 1010 * with the new one if this points to the same data 1011 */ 1012 cdp = device->path[chp].conf_data; 1013 if (private->conf.data == cdp) { 1014 private->conf.data = (void *)conf_data; 1015 dasd_eckd_identify_conf_parts(&private->conf); 1016 } 1017 ccw_device_get_schid(device->cdev, &sch_id); 1018 device->path[chp].conf_data = conf_data; 1019 device->path[chp].cssid = sch_id.cssid; 1020 device->path[chp].ssid = sch_id.ssid; 1021 chp_desc = ccw_device_get_chp_desc(device->cdev, chp); 1022 if (chp_desc) 1023 device->path[chp].chpid = chp_desc->chpid; 1024 kfree(chp_desc); 1025 kfree(cdp); 1026} 1027 1028static void dasd_eckd_clear_conf_data(struct dasd_device *device) 1029{ 1030 struct dasd_eckd_private *private = device->private; 1031 int i; 1032 1033 private->conf.data = NULL; 1034 private->conf.len = 0; 1035 for (i = 0; i < 8; i++) { 1036 kfree(device->path[i].conf_data); 1037 device->path[i].conf_data = NULL; 1038 device->path[i].cssid = 0; 1039 device->path[i].ssid = 0; 1040 device->path[i].chpid = 0; 1041 dasd_path_notoper(device, i); 1042 } 1043} 1044 1045static void dasd_eckd_read_fc_security(struct dasd_device *device) 1046{ 1047 struct dasd_eckd_private *private = device->private; 1048 u8 esm_valid; 1049 u8 esm[8]; 1050 int chp; 1051 int rc; 1052 1053 rc = chsc_scud(private->uid.ssid, (u64 *)esm, &esm_valid); 1054 if (rc) { 1055 for (chp = 0; chp < 8; chp++) 1056 device->path[chp].fc_security = 0; 1057 return; 1058 } 1059 1060 for (chp = 0; chp < 8; chp++) { 1061 if (esm_valid & (0x80 >> chp)) 1062 device->path[chp].fc_security = esm[chp]; 1063 else 1064 device->path[chp].fc_security = 0; 1065 } 1066} 1067 1068static void dasd_eckd_get_uid_string(struct dasd_conf *conf, char *print_uid) 1069{ 1070 struct dasd_uid uid; 1071 1072 create_uid(conf, &uid); 1073 snprintf(print_uid, DASD_UID_STRLEN, "%s.%s.%04x.%02x%s%s", 1074 uid.vendor, uid.serial, uid.ssid, uid.real_unit_addr, 1075 uid.vduit[0] ? "." : "", uid.vduit); 1076} 1077 1078static int dasd_eckd_check_cabling(struct dasd_device *device, 1079 void *conf_data, __u8 lpm) 1080{ 1081 char print_path_uid[DASD_UID_STRLEN], print_device_uid[DASD_UID_STRLEN]; 1082 struct dasd_eckd_private *private = device->private; 1083 struct dasd_conf path_conf; 1084 1085 path_conf.data = conf_data; 1086 path_conf.len = DASD_ECKD_RCD_DATA_SIZE; 1087 if (dasd_eckd_identify_conf_parts(&path_conf)) 1088 return 1; 1089 1090 if (dasd_eckd_compare_path_uid(device, &path_conf)) { 1091 dasd_eckd_get_uid_string(&path_conf, print_path_uid); 1092 dasd_eckd_get_uid_string(&private->conf, print_device_uid); 1093 dev_err(&device->cdev->dev, 1094 "Not all channel paths lead to the same device, path %02X leads to device %s instead of %s\n", 1095 lpm, print_path_uid, print_device_uid); 1096 return 1; 1097 } 1098 1099 return 0; 1100} 1101 1102static int dasd_eckd_read_conf(struct dasd_device *device) 1103{ 1104 void *conf_data; 1105 int conf_len, conf_data_saved; 1106 int rc, path_err, pos; 1107 __u8 lpm, opm; 1108 struct dasd_eckd_private *private; 1109 1110 private = device->private; 1111 opm = ccw_device_get_path_mask(device->cdev); 1112 conf_data_saved = 0; 1113 path_err = 0; 1114 /* get configuration data per operational path */ 1115 for (lpm = 0x80; lpm; lpm>>= 1) { 1116 if (!(lpm & opm)) 1117 continue; 1118 rc = dasd_eckd_read_conf_lpm(device, &conf_data, 1119 &conf_len, lpm); 1120 if (rc && rc != -EOPNOTSUPP) { /* -EOPNOTSUPP is ok */ 1121 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 1122 "Read configuration data returned " 1123 "error %d", rc); 1124 return rc; 1125 } 1126 if (conf_data == NULL) { 1127 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 1128 "No configuration data " 1129 "retrieved"); 1130 /* no further analysis possible */ 1131 dasd_path_add_opm(device, opm); 1132 continue; /* no error */ 1133 } 1134 /* save first valid configuration data */ 1135 if (!conf_data_saved) { 1136 /* initially clear previously stored conf_data */ 1137 dasd_eckd_clear_conf_data(device); 1138 private->conf.data = conf_data; 1139 private->conf.len = conf_len; 1140 if (dasd_eckd_identify_conf_parts(&private->conf)) { 1141 private->conf.data = NULL; 1142 private->conf.len = 0; 1143 kfree(conf_data); 1144 continue; 1145 } 1146 /* 1147 * build device UID that other path data 1148 * can be compared to it 1149 */ 1150 dasd_eckd_generate_uid(device); 1151 conf_data_saved++; 1152 } else if (dasd_eckd_check_cabling(device, conf_data, lpm)) { 1153 dasd_path_add_cablepm(device, lpm); 1154 path_err = -EINVAL; 1155 kfree(conf_data); 1156 continue; 1157 } 1158 1159 pos = pathmask_to_pos(lpm); 1160 dasd_eckd_store_conf_data(device, conf_data, pos); 1161 1162 switch (dasd_eckd_path_access(conf_data, conf_len)) { 1163 case 0x02: 1164 dasd_path_add_nppm(device, lpm); 1165 break; 1166 case 0x03: 1167 dasd_path_add_ppm(device, lpm); 1168 break; 1169 } 1170 if (!dasd_path_get_opm(device)) { 1171 dasd_path_set_opm(device, lpm); 1172 dasd_generic_path_operational(device); 1173 } else { 1174 dasd_path_add_opm(device, lpm); 1175 } 1176 } 1177 1178 return path_err; 1179} 1180 1181static u32 get_fcx_max_data(struct dasd_device *device) 1182{ 1183 struct dasd_eckd_private *private = device->private; 1184 int fcx_in_css, fcx_in_gneq, fcx_in_features; 1185 unsigned int mdc; 1186 int tpm; 1187 1188 if (dasd_nofcx) 1189 return 0; 1190 /* is transport mode supported? */ 1191 fcx_in_css = css_general_characteristics.fcx; 1192 fcx_in_gneq = private->conf.gneq->reserved2[7] & 0x04; 1193 fcx_in_features = private->features.feature[40] & 0x80; 1194 tpm = fcx_in_css && fcx_in_gneq && fcx_in_features; 1195 1196 if (!tpm) 1197 return 0; 1198 1199 mdc = ccw_device_get_mdc(device->cdev, 0); 1200 if (mdc == 0) { 1201 dev_warn(&device->cdev->dev, "Detecting the maximum supported data size for zHPF requests failed\n"); 1202 return 0; 1203 } else { 1204 return (u32)mdc * FCX_MAX_DATA_FACTOR; 1205 } 1206} 1207 1208static int verify_fcx_max_data(struct dasd_device *device, __u8 lpm) 1209{ 1210 struct dasd_eckd_private *private = device->private; 1211 unsigned int mdc; 1212 u32 fcx_max_data; 1213 1214 if (private->fcx_max_data) { 1215 mdc = ccw_device_get_mdc(device->cdev, lpm); 1216 if (mdc == 0) { 1217 dev_warn(&device->cdev->dev, 1218 "Detecting the maximum data size for zHPF " 1219 "requests failed (rc=%d) for a new path %x\n", 1220 mdc, lpm); 1221 return mdc; 1222 } 1223 fcx_max_data = (u32)mdc * FCX_MAX_DATA_FACTOR; 1224 if (fcx_max_data < private->fcx_max_data) { 1225 dev_warn(&device->cdev->dev, 1226 "The maximum data size for zHPF requests %u " 1227 "on a new path %x is below the active maximum " 1228 "%u\n", fcx_max_data, lpm, 1229 private->fcx_max_data); 1230 return -EACCES; 1231 } 1232 } 1233 return 0; 1234} 1235 1236static int rebuild_device_uid(struct dasd_device *device, 1237 struct pe_handler_work_data *data) 1238{ 1239 struct dasd_eckd_private *private = device->private; 1240 __u8 lpm, opm = dasd_path_get_opm(device); 1241 int rc = -ENODEV; 1242 1243 for (lpm = 0x80; lpm; lpm >>= 1) { 1244 if (!(lpm & opm)) 1245 continue; 1246 memset(&data->rcd_buffer, 0, sizeof(data->rcd_buffer)); 1247 memset(&data->cqr, 0, sizeof(data->cqr)); 1248 data->cqr.cpaddr = &data->ccw; 1249 rc = dasd_eckd_read_conf_immediately(device, &data->cqr, 1250 data->rcd_buffer, 1251 lpm); 1252 1253 if (rc) { 1254 if (rc == -EOPNOTSUPP) /* -EOPNOTSUPP is ok */ 1255 continue; 1256 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 1257 "Read configuration data " 1258 "returned error %d", rc); 1259 break; 1260 } 1261 memcpy(private->conf.data, data->rcd_buffer, 1262 DASD_ECKD_RCD_DATA_SIZE); 1263 if (dasd_eckd_identify_conf_parts(&private->conf)) { 1264 rc = -ENODEV; 1265 } else /* first valid path is enough */ 1266 break; 1267 } 1268 1269 if (!rc) 1270 rc = dasd_eckd_generate_uid(device); 1271 1272 return rc; 1273} 1274 1275static void dasd_eckd_path_available_action(struct dasd_device *device, 1276 struct pe_handler_work_data *data) 1277{ 1278 __u8 path_rcd_buf[DASD_ECKD_RCD_DATA_SIZE]; 1279 __u8 lpm, opm, npm, ppm, epm, hpfpm, cablepm; 1280 struct dasd_conf_data *conf_data; 1281 char print_uid[DASD_UID_STRLEN]; 1282 struct dasd_conf path_conf; 1283 unsigned long flags; 1284 int rc, pos; 1285 1286 opm = 0; 1287 npm = 0; 1288 ppm = 0; 1289 epm = 0; 1290 hpfpm = 0; 1291 cablepm = 0; 1292 1293 for (lpm = 0x80; lpm; lpm >>= 1) { 1294 if (!(lpm & data->tbvpm)) 1295 continue; 1296 memset(&data->rcd_buffer, 0, sizeof(data->rcd_buffer)); 1297 memset(&data->cqr, 0, sizeof(data->cqr)); 1298 data->cqr.cpaddr = &data->ccw; 1299 rc = dasd_eckd_read_conf_immediately(device, &data->cqr, 1300 data->rcd_buffer, 1301 lpm); 1302 if (!rc) { 1303 switch (dasd_eckd_path_access(data->rcd_buffer, 1304 DASD_ECKD_RCD_DATA_SIZE) 1305 ) { 1306 case 0x02: 1307 npm |= lpm; 1308 break; 1309 case 0x03: 1310 ppm |= lpm; 1311 break; 1312 } 1313 opm |= lpm; 1314 } else if (rc == -EOPNOTSUPP) { 1315 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 1316 "path verification: No configuration " 1317 "data retrieved"); 1318 opm |= lpm; 1319 } else if (rc == -EAGAIN) { 1320 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 1321 "path verification: device is stopped," 1322 " try again later"); 1323 epm |= lpm; 1324 } else { 1325 dev_warn(&device->cdev->dev, 1326 "Reading device feature codes failed " 1327 "(rc=%d) for new path %x\n", rc, lpm); 1328 continue; 1329 } 1330 if (verify_fcx_max_data(device, lpm)) { 1331 opm &= ~lpm; 1332 npm &= ~lpm; 1333 ppm &= ~lpm; 1334 hpfpm |= lpm; 1335 continue; 1336 } 1337 1338 /* 1339 * save conf_data for comparison after 1340 * rebuild_device_uid may have changed 1341 * the original data 1342 */ 1343 memcpy(&path_rcd_buf, data->rcd_buffer, 1344 DASD_ECKD_RCD_DATA_SIZE); 1345 path_conf.data = (void *)&path_rcd_buf; 1346 path_conf.len = DASD_ECKD_RCD_DATA_SIZE; 1347 if (dasd_eckd_identify_conf_parts(&path_conf)) { 1348 path_conf.data = NULL; 1349 path_conf.len = 0; 1350 continue; 1351 } 1352 1353 /* 1354 * compare path UID with device UID only if at least 1355 * one valid path is left 1356 * in other case the device UID may have changed and 1357 * the first working path UID will be used as device UID 1358 */ 1359 if (dasd_path_get_opm(device) && 1360 dasd_eckd_compare_path_uid(device, &path_conf)) { 1361 /* 1362 * the comparison was not successful 1363 * rebuild the device UID with at least one 1364 * known path in case a z/VM hyperswap command 1365 * has changed the device 1366 * 1367 * after this compare again 1368 * 1369 * if either the rebuild or the recompare fails 1370 * the path can not be used 1371 */ 1372 if (rebuild_device_uid(device, data) || 1373 dasd_eckd_compare_path_uid( 1374 device, &path_conf)) { 1375 dasd_eckd_get_uid_string(&path_conf, print_uid); 1376 dev_err(&device->cdev->dev, 1377 "The newly added channel path %02X " 1378 "will not be used because it leads " 1379 "to a different device %s\n", 1380 lpm, print_uid); 1381 opm &= ~lpm; 1382 npm &= ~lpm; 1383 ppm &= ~lpm; 1384 cablepm |= lpm; 1385 continue; 1386 } 1387 } 1388 1389 conf_data = kzalloc(DASD_ECKD_RCD_DATA_SIZE, GFP_KERNEL); 1390 if (conf_data) { 1391 memcpy(conf_data, data->rcd_buffer, 1392 DASD_ECKD_RCD_DATA_SIZE); 1393 } else { 1394 /* 1395 * path is operational but path config data could not 1396 * be stored due to low mem condition 1397 * add it to the error path mask and schedule a path 1398 * verification later that this could be added again 1399 */ 1400 epm |= lpm; 1401 } 1402 pos = pathmask_to_pos(lpm); 1403 dasd_eckd_store_conf_data(device, conf_data, pos); 1404 1405 /* 1406 * There is a small chance that a path is lost again between 1407 * above path verification and the following modification of 1408 * the device opm mask. We could avoid that race here by using 1409 * yet another path mask, but we rather deal with this unlikely 1410 * situation in dasd_start_IO. 1411 */ 1412 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1413 if (!dasd_path_get_opm(device) && opm) { 1414 dasd_path_set_opm(device, opm); 1415 dasd_generic_path_operational(device); 1416 } else { 1417 dasd_path_add_opm(device, opm); 1418 } 1419 dasd_path_add_nppm(device, npm); 1420 dasd_path_add_ppm(device, ppm); 1421 if (epm) { 1422 dasd_path_add_tbvpm(device, epm); 1423 dasd_device_set_timer(device, 50); 1424 } 1425 dasd_path_add_cablepm(device, cablepm); 1426 dasd_path_add_nohpfpm(device, hpfpm); 1427 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 1428 1429 dasd_path_create_kobj(device, pos); 1430 } 1431} 1432 1433static void do_pe_handler_work(struct work_struct *work) 1434{ 1435 struct pe_handler_work_data *data; 1436 struct dasd_device *device; 1437 1438 data = container_of(work, struct pe_handler_work_data, worker); 1439 device = data->device; 1440 1441 /* delay path verification until device was resumed */ 1442 if (test_bit(DASD_FLAG_SUSPENDED, &device->flags)) { 1443 schedule_work(work); 1444 return; 1445 } 1446 /* check if path verification already running and delay if so */ 1447 if (test_and_set_bit(DASD_FLAG_PATH_VERIFY, &device->flags)) { 1448 schedule_work(work); 1449 return; 1450 } 1451 1452 if (data->tbvpm) 1453 dasd_eckd_path_available_action(device, data); 1454 if (data->fcsecpm) 1455 dasd_eckd_read_fc_security(device); 1456 1457 clear_bit(DASD_FLAG_PATH_VERIFY, &device->flags); 1458 dasd_put_device(device); 1459 if (data->isglobal) 1460 mutex_unlock(&dasd_pe_handler_mutex); 1461 else 1462 kfree(data); 1463} 1464 1465static int dasd_eckd_pe_handler(struct dasd_device *device, 1466 __u8 tbvpm, __u8 fcsecpm) 1467{ 1468 struct pe_handler_work_data *data; 1469 1470 data = kzalloc(sizeof(*data), GFP_ATOMIC | GFP_DMA); 1471 if (!data) { 1472 if (mutex_trylock(&dasd_pe_handler_mutex)) { 1473 data = pe_handler_worker; 1474 data->isglobal = 1; 1475 } else { 1476 return -ENOMEM; 1477 } 1478 } 1479 INIT_WORK(&data->worker, do_pe_handler_work); 1480 dasd_get_device(device); 1481 data->device = device; 1482 data->tbvpm = tbvpm; 1483 data->fcsecpm = fcsecpm; 1484 schedule_work(&data->worker); 1485 return 0; 1486} 1487 1488static void dasd_eckd_reset_path(struct dasd_device *device, __u8 pm) 1489{ 1490 struct dasd_eckd_private *private = device->private; 1491 unsigned long flags; 1492 1493 if (!private->fcx_max_data) 1494 private->fcx_max_data = get_fcx_max_data(device); 1495 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1496 dasd_path_set_tbvpm(device, pm ? : dasd_path_get_notoperpm(device)); 1497 dasd_schedule_device_bh(device); 1498 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 1499} 1500 1501static int dasd_eckd_read_features(struct dasd_device *device) 1502{ 1503 struct dasd_eckd_private *private = device->private; 1504 struct dasd_psf_prssd_data *prssdp; 1505 struct dasd_rssd_features *features; 1506 struct dasd_ccw_req *cqr; 1507 struct ccw1 *ccw; 1508 int rc; 1509 1510 memset(&private->features, 0, sizeof(struct dasd_rssd_features)); 1511 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 1512 (sizeof(struct dasd_psf_prssd_data) + 1513 sizeof(struct dasd_rssd_features)), 1514 device, NULL); 1515 if (IS_ERR(cqr)) { 1516 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", "Could not " 1517 "allocate initialization request"); 1518 return PTR_ERR(cqr); 1519 } 1520 cqr->startdev = device; 1521 cqr->memdev = device; 1522 cqr->block = NULL; 1523 cqr->retries = 256; 1524 cqr->expires = 10 * HZ; 1525 1526 /* Prepare for Read Subsystem Data */ 1527 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 1528 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 1529 prssdp->order = PSF_ORDER_PRSSD; 1530 prssdp->suborder = 0x41; /* Read Feature Codes */ 1531 /* all other bytes of prssdp must be zero */ 1532 1533 ccw = cqr->cpaddr; 1534 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1535 ccw->count = sizeof(struct dasd_psf_prssd_data); 1536 ccw->flags |= CCW_FLAG_CC; 1537 ccw->cda = virt_to_dma32(prssdp); 1538 1539 /* Read Subsystem Data - feature codes */ 1540 features = (struct dasd_rssd_features *) (prssdp + 1); 1541 memset(features, 0, sizeof(struct dasd_rssd_features)); 1542 1543 ccw++; 1544 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 1545 ccw->count = sizeof(struct dasd_rssd_features); 1546 ccw->cda = virt_to_dma32(features); 1547 1548 cqr->buildclk = get_tod_clock(); 1549 cqr->status = DASD_CQR_FILLED; 1550 rc = dasd_sleep_on(cqr); 1551 if (rc == 0) { 1552 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 1553 features = (struct dasd_rssd_features *) (prssdp + 1); 1554 memcpy(&private->features, features, 1555 sizeof(struct dasd_rssd_features)); 1556 } else 1557 dev_warn(&device->cdev->dev, "Reading device feature codes" 1558 " failed with rc=%d\n", rc); 1559 dasd_sfree_request(cqr, cqr->memdev); 1560 return rc; 1561} 1562 1563/* Read Volume Information - Volume Storage Query */ 1564static int dasd_eckd_read_vol_info(struct dasd_device *device) 1565{ 1566 struct dasd_eckd_private *private = device->private; 1567 struct dasd_psf_prssd_data *prssdp; 1568 struct dasd_rssd_vsq *vsq; 1569 struct dasd_ccw_req *cqr; 1570 struct ccw1 *ccw; 1571 int useglobal; 1572 int rc; 1573 1574 /* This command cannot be executed on an alias device */ 1575 if (private->uid.type == UA_BASE_PAV_ALIAS || 1576 private->uid.type == UA_HYPER_PAV_ALIAS) 1577 return 0; 1578 1579 useglobal = 0; 1580 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 /* PSF + RSSD */, 1581 sizeof(*prssdp) + sizeof(*vsq), device, NULL); 1582 if (IS_ERR(cqr)) { 1583 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 1584 "Could not allocate initialization request"); 1585 mutex_lock(&dasd_vol_info_mutex); 1586 useglobal = 1; 1587 cqr = &dasd_vol_info_req->cqr; 1588 memset(cqr, 0, sizeof(*cqr)); 1589 memset(dasd_vol_info_req, 0, sizeof(*dasd_vol_info_req)); 1590 cqr->cpaddr = &dasd_vol_info_req->ccw; 1591 cqr->data = &dasd_vol_info_req->data; 1592 cqr->magic = DASD_ECKD_MAGIC; 1593 } 1594 1595 /* Prepare for Read Subsystem Data */ 1596 prssdp = cqr->data; 1597 prssdp->order = PSF_ORDER_PRSSD; 1598 prssdp->suborder = PSF_SUBORDER_VSQ; /* Volume Storage Query */ 1599 prssdp->lss = private->conf.ned->ID; 1600 prssdp->volume = private->conf.ned->unit_addr; 1601 1602 ccw = cqr->cpaddr; 1603 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1604 ccw->count = sizeof(*prssdp); 1605 ccw->flags |= CCW_FLAG_CC; 1606 ccw->cda = virt_to_dma32(prssdp); 1607 1608 /* Read Subsystem Data - Volume Storage Query */ 1609 vsq = (struct dasd_rssd_vsq *)(prssdp + 1); 1610 memset(vsq, 0, sizeof(*vsq)); 1611 1612 ccw++; 1613 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 1614 ccw->count = sizeof(*vsq); 1615 ccw->flags |= CCW_FLAG_SLI; 1616 ccw->cda = virt_to_dma32(vsq); 1617 1618 cqr->buildclk = get_tod_clock(); 1619 cqr->status = DASD_CQR_FILLED; 1620 cqr->startdev = device; 1621 cqr->memdev = device; 1622 cqr->block = NULL; 1623 cqr->retries = 256; 1624 cqr->expires = device->default_expires * HZ; 1625 /* The command might not be supported. Suppress the error output */ 1626 __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags); 1627 1628 rc = dasd_sleep_on_interruptible(cqr); 1629 if (rc == 0) { 1630 memcpy(&private->vsq, vsq, sizeof(*vsq)); 1631 } else { 1632 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 1633 "Reading the volume storage information failed with rc=%d", rc); 1634 } 1635 1636 if (useglobal) 1637 mutex_unlock(&dasd_vol_info_mutex); 1638 else 1639 dasd_sfree_request(cqr, cqr->memdev); 1640 1641 return rc; 1642} 1643 1644static int dasd_eckd_is_ese(struct dasd_device *device) 1645{ 1646 struct dasd_eckd_private *private = device->private; 1647 1648 return private->vsq.vol_info.ese; 1649} 1650 1651static int dasd_eckd_ext_pool_id(struct dasd_device *device) 1652{ 1653 struct dasd_eckd_private *private = device->private; 1654 1655 return private->vsq.extent_pool_id; 1656} 1657 1658/* 1659 * This value represents the total amount of available space. As more space is 1660 * allocated by ESE volumes, this value will decrease. 1661 * The data for this value is therefore updated on any call. 1662 */ 1663static int dasd_eckd_space_configured(struct dasd_device *device) 1664{ 1665 struct dasd_eckd_private *private = device->private; 1666 int rc; 1667 1668 rc = dasd_eckd_read_vol_info(device); 1669 1670 return rc ? : private->vsq.space_configured; 1671} 1672 1673/* 1674 * The value of space allocated by an ESE volume may have changed and is 1675 * therefore updated on any call. 1676 */ 1677static int dasd_eckd_space_allocated(struct dasd_device *device) 1678{ 1679 struct dasd_eckd_private *private = device->private; 1680 int rc; 1681 1682 rc = dasd_eckd_read_vol_info(device); 1683 1684 return rc ? : private->vsq.space_allocated; 1685} 1686 1687static int dasd_eckd_logical_capacity(struct dasd_device *device) 1688{ 1689 struct dasd_eckd_private *private = device->private; 1690 1691 return private->vsq.logical_capacity; 1692} 1693 1694static void dasd_eckd_ext_pool_exhaust_work(struct work_struct *work) 1695{ 1696 struct ext_pool_exhaust_work_data *data; 1697 struct dasd_device *device; 1698 struct dasd_device *base; 1699 1700 data = container_of(work, struct ext_pool_exhaust_work_data, worker); 1701 device = data->device; 1702 base = data->base; 1703 1704 if (!base) 1705 base = device; 1706 if (dasd_eckd_space_configured(base) != 0) { 1707 dasd_generic_space_avail(device); 1708 } else { 1709 dev_warn(&device->cdev->dev, "No space left in the extent pool\n"); 1710 DBF_DEV_EVENT(DBF_WARNING, device, "%s", "out of space"); 1711 } 1712 1713 dasd_put_device(device); 1714 kfree(data); 1715} 1716 1717static int dasd_eckd_ext_pool_exhaust(struct dasd_device *device, 1718 struct dasd_ccw_req *cqr) 1719{ 1720 struct ext_pool_exhaust_work_data *data; 1721 1722 data = kzalloc(sizeof(*data), GFP_ATOMIC); 1723 if (!data) 1724 return -ENOMEM; 1725 INIT_WORK(&data->worker, dasd_eckd_ext_pool_exhaust_work); 1726 dasd_get_device(device); 1727 data->device = device; 1728 1729 if (cqr->block) 1730 data->base = cqr->block->base; 1731 else if (cqr->basedev) 1732 data->base = cqr->basedev; 1733 else 1734 data->base = NULL; 1735 1736 schedule_work(&data->worker); 1737 1738 return 0; 1739} 1740 1741static void dasd_eckd_cpy_ext_pool_data(struct dasd_device *device, 1742 struct dasd_rssd_lcq *lcq) 1743{ 1744 struct dasd_eckd_private *private = device->private; 1745 int pool_id = dasd_eckd_ext_pool_id(device); 1746 struct dasd_ext_pool_sum eps; 1747 int i; 1748 1749 for (i = 0; i < lcq->pool_count; i++) { 1750 eps = lcq->ext_pool_sum[i]; 1751 if (eps.pool_id == pool_id) { 1752 memcpy(&private->eps, &eps, 1753 sizeof(struct dasd_ext_pool_sum)); 1754 } 1755 } 1756} 1757 1758/* Read Extent Pool Information - Logical Configuration Query */ 1759static int dasd_eckd_read_ext_pool_info(struct dasd_device *device) 1760{ 1761 struct dasd_eckd_private *private = device->private; 1762 struct dasd_psf_prssd_data *prssdp; 1763 struct dasd_rssd_lcq *lcq; 1764 struct dasd_ccw_req *cqr; 1765 struct ccw1 *ccw; 1766 int rc; 1767 1768 /* This command cannot be executed on an alias device */ 1769 if (private->uid.type == UA_BASE_PAV_ALIAS || 1770 private->uid.type == UA_HYPER_PAV_ALIAS) 1771 return 0; 1772 1773 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 /* PSF + RSSD */, 1774 sizeof(*prssdp) + sizeof(*lcq), device, NULL); 1775 if (IS_ERR(cqr)) { 1776 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 1777 "Could not allocate initialization request"); 1778 return PTR_ERR(cqr); 1779 } 1780 1781 /* Prepare for Read Subsystem Data */ 1782 prssdp = cqr->data; 1783 memset(prssdp, 0, sizeof(*prssdp)); 1784 prssdp->order = PSF_ORDER_PRSSD; 1785 prssdp->suborder = PSF_SUBORDER_LCQ; /* Logical Configuration Query */ 1786 1787 ccw = cqr->cpaddr; 1788 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1789 ccw->count = sizeof(*prssdp); 1790 ccw->flags |= CCW_FLAG_CC; 1791 ccw->cda = virt_to_dma32(prssdp); 1792 1793 lcq = (struct dasd_rssd_lcq *)(prssdp + 1); 1794 memset(lcq, 0, sizeof(*lcq)); 1795 1796 ccw++; 1797 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 1798 ccw->count = sizeof(*lcq); 1799 ccw->flags |= CCW_FLAG_SLI; 1800 ccw->cda = virt_to_dma32(lcq); 1801 1802 cqr->buildclk = get_tod_clock(); 1803 cqr->status = DASD_CQR_FILLED; 1804 cqr->startdev = device; 1805 cqr->memdev = device; 1806 cqr->block = NULL; 1807 cqr->retries = 256; 1808 cqr->expires = device->default_expires * HZ; 1809 /* The command might not be supported. Suppress the error output */ 1810 __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags); 1811 1812 rc = dasd_sleep_on_interruptible(cqr); 1813 if (rc == 0) { 1814 dasd_eckd_cpy_ext_pool_data(device, lcq); 1815 } else { 1816 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 1817 "Reading the logical configuration failed with rc=%d", rc); 1818 } 1819 1820 dasd_sfree_request(cqr, cqr->memdev); 1821 1822 return rc; 1823} 1824 1825/* 1826 * Depending on the device type, the extent size is specified either as 1827 * cylinders per extent (CKD) or size per extent (FBA) 1828 * A 1GB size corresponds to 1113cyl, and 16MB to 21cyl. 1829 */ 1830static int dasd_eckd_ext_size(struct dasd_device *device) 1831{ 1832 struct dasd_eckd_private *private = device->private; 1833 struct dasd_ext_pool_sum eps = private->eps; 1834 1835 if (!eps.flags.extent_size_valid) 1836 return 0; 1837 if (eps.extent_size.size_1G) 1838 return 1113; 1839 if (eps.extent_size.size_16M) 1840 return 21; 1841 1842 return 0; 1843} 1844 1845static int dasd_eckd_ext_pool_warn_thrshld(struct dasd_device *device) 1846{ 1847 struct dasd_eckd_private *private = device->private; 1848 1849 return private->eps.warn_thrshld; 1850} 1851 1852static int dasd_eckd_ext_pool_cap_at_warnlevel(struct dasd_device *device) 1853{ 1854 struct dasd_eckd_private *private = device->private; 1855 1856 return private->eps.flags.capacity_at_warnlevel; 1857} 1858 1859/* 1860 * Extent Pool out of space 1861 */ 1862static int dasd_eckd_ext_pool_oos(struct dasd_device *device) 1863{ 1864 struct dasd_eckd_private *private = device->private; 1865 1866 return private->eps.flags.pool_oos; 1867} 1868 1869/* 1870 * Build CP for Perform Subsystem Function - SSC. 1871 */ 1872static struct dasd_ccw_req *dasd_eckd_build_psf_ssc(struct dasd_device *device, 1873 int enable_pav) 1874{ 1875 struct dasd_ccw_req *cqr; 1876 struct dasd_psf_ssc_data *psf_ssc_data; 1877 struct ccw1 *ccw; 1878 1879 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ , 1880 sizeof(struct dasd_psf_ssc_data), 1881 device, NULL); 1882 1883 if (IS_ERR(cqr)) { 1884 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1885 "Could not allocate PSF-SSC request"); 1886 return cqr; 1887 } 1888 psf_ssc_data = (struct dasd_psf_ssc_data *)cqr->data; 1889 psf_ssc_data->order = PSF_ORDER_SSC; 1890 psf_ssc_data->suborder = 0xc0; 1891 if (enable_pav) { 1892 psf_ssc_data->suborder |= 0x08; 1893 psf_ssc_data->reserved[0] = 0x88; 1894 } 1895 ccw = cqr->cpaddr; 1896 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1897 ccw->cda = virt_to_dma32(psf_ssc_data); 1898 ccw->count = 66; 1899 1900 cqr->startdev = device; 1901 cqr->memdev = device; 1902 cqr->block = NULL; 1903 cqr->retries = 256; 1904 cqr->expires = 10*HZ; 1905 cqr->buildclk = get_tod_clock(); 1906 cqr->status = DASD_CQR_FILLED; 1907 return cqr; 1908} 1909 1910/* 1911 * Perform Subsystem Function. 1912 * It is necessary to trigger CIO for channel revalidation since this 1913 * call might change behaviour of DASD devices. 1914 */ 1915static int 1916dasd_eckd_psf_ssc(struct dasd_device *device, int enable_pav, 1917 unsigned long flags) 1918{ 1919 struct dasd_ccw_req *cqr; 1920 int rc; 1921 1922 cqr = dasd_eckd_build_psf_ssc(device, enable_pav); 1923 if (IS_ERR(cqr)) 1924 return PTR_ERR(cqr); 1925 1926 /* 1927 * set flags e.g. turn on failfast, to prevent blocking 1928 * the calling function should handle failed requests 1929 */ 1930 cqr->flags |= flags; 1931 1932 rc = dasd_sleep_on(cqr); 1933 if (!rc) 1934 /* trigger CIO to reprobe devices */ 1935 css_schedule_reprobe(); 1936 else if (cqr->intrc == -EAGAIN) 1937 rc = -EAGAIN; 1938 1939 dasd_sfree_request(cqr, cqr->memdev); 1940 return rc; 1941} 1942 1943/* 1944 * Valide storage server of current device. 1945 */ 1946static int dasd_eckd_validate_server(struct dasd_device *device, 1947 unsigned long flags) 1948{ 1949 struct dasd_eckd_private *private = device->private; 1950 int enable_pav, rc; 1951 1952 if (private->uid.type == UA_BASE_PAV_ALIAS || 1953 private->uid.type == UA_HYPER_PAV_ALIAS) 1954 return 0; 1955 if (dasd_nopav || MACHINE_IS_VM) 1956 enable_pav = 0; 1957 else 1958 enable_pav = 1; 1959 rc = dasd_eckd_psf_ssc(device, enable_pav, flags); 1960 1961 /* may be requested feature is not available on server, 1962 * therefore just report error and go ahead */ 1963 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "PSF-SSC for SSID %04x " 1964 "returned rc=%d", private->uid.ssid, rc); 1965 return rc; 1966} 1967 1968/* 1969 * worker to do a validate server in case of a lost pathgroup 1970 */ 1971static void dasd_eckd_do_validate_server(struct work_struct *work) 1972{ 1973 struct dasd_device *device = container_of(work, struct dasd_device, 1974 kick_validate); 1975 unsigned long flags = 0; 1976 1977 set_bit(DASD_CQR_FLAGS_FAILFAST, &flags); 1978 if (dasd_eckd_validate_server(device, flags) 1979 == -EAGAIN) { 1980 /* schedule worker again if failed */ 1981 schedule_work(&device->kick_validate); 1982 return; 1983 } 1984 1985 dasd_put_device(device); 1986} 1987 1988static void dasd_eckd_kick_validate_server(struct dasd_device *device) 1989{ 1990 dasd_get_device(device); 1991 /* exit if device not online or in offline processing */ 1992 if (test_bit(DASD_FLAG_OFFLINE, &device->flags) || 1993 device->state < DASD_STATE_ONLINE) { 1994 dasd_put_device(device); 1995 return; 1996 } 1997 /* queue call to do_validate_server to the kernel event daemon. */ 1998 if (!schedule_work(&device->kick_validate)) 1999 dasd_put_device(device); 2000} 2001 2002/* 2003 * return if the device is the copy relation primary if a copy relation is active 2004 */ 2005static int dasd_device_is_primary(struct dasd_device *device) 2006{ 2007 if (!device->copy) 2008 return 1; 2009 2010 if (device->copy->active->device == device) 2011 return 1; 2012 2013 return 0; 2014} 2015 2016static int dasd_eckd_alloc_block(struct dasd_device *device) 2017{ 2018 struct dasd_block *block; 2019 struct dasd_uid temp_uid; 2020 2021 if (!dasd_device_is_primary(device)) 2022 return 0; 2023 2024 dasd_eckd_get_uid(device, &temp_uid); 2025 if (temp_uid.type == UA_BASE_DEVICE) { 2026 block = dasd_alloc_block(); 2027 if (IS_ERR(block)) { 2028 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 2029 "could not allocate dasd block structure"); 2030 return PTR_ERR(block); 2031 } 2032 device->block = block; 2033 block->base = device; 2034 } 2035 return 0; 2036} 2037 2038static bool dasd_eckd_pprc_enabled(struct dasd_device *device) 2039{ 2040 struct dasd_eckd_private *private = device->private; 2041 2042 return private->rdc_data.facilities.PPRC_enabled; 2043} 2044 2045/* 2046 * Check device characteristics. 2047 * If the device is accessible using ECKD discipline, the device is enabled. 2048 */ 2049static int 2050dasd_eckd_check_characteristics(struct dasd_device *device) 2051{ 2052 struct dasd_eckd_private *private = device->private; 2053 int rc, i; 2054 int readonly; 2055 unsigned long value; 2056 2057 /* setup work queue for validate server*/ 2058 INIT_WORK(&device->kick_validate, dasd_eckd_do_validate_server); 2059 /* setup work queue for summary unit check */ 2060 INIT_WORK(&device->suc_work, dasd_alias_handle_summary_unit_check); 2061 2062 if (!ccw_device_is_pathgroup(device->cdev)) { 2063 dev_warn(&device->cdev->dev, 2064 "A channel path group could not be established\n"); 2065 return -EIO; 2066 } 2067 if (!ccw_device_is_multipath(device->cdev)) { 2068 dev_info(&device->cdev->dev, 2069 "The DASD is not operating in multipath mode\n"); 2070 } 2071 if (!private) { 2072 private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA); 2073 if (!private) { 2074 dev_warn(&device->cdev->dev, 2075 "Allocating memory for private DASD data " 2076 "failed\n"); 2077 return -ENOMEM; 2078 } 2079 device->private = private; 2080 } else { 2081 memset(private, 0, sizeof(*private)); 2082 } 2083 /* Invalidate status of initial analysis. */ 2084 private->init_cqr_status = -1; 2085 /* Set default cache operations. */ 2086 private->attrib.operation = DASD_NORMAL_CACHE; 2087 private->attrib.nr_cyl = 0; 2088 2089 /* Read Configuration Data */ 2090 rc = dasd_eckd_read_conf(device); 2091 if (rc) 2092 goto out_err1; 2093 2094 /* set some default values */ 2095 device->default_expires = DASD_EXPIRES; 2096 device->default_retries = DASD_RETRIES; 2097 device->path_thrhld = DASD_ECKD_PATH_THRHLD; 2098 device->path_interval = DASD_ECKD_PATH_INTERVAL; 2099 device->aq_timeouts = DASD_RETRIES_MAX; 2100 2101 if (private->conf.gneq) { 2102 value = 1; 2103 for (i = 0; i < private->conf.gneq->timeout.value; i++) 2104 value = 10 * value; 2105 value = value * private->conf.gneq->timeout.number; 2106 /* do not accept useless values */ 2107 if (value != 0 && value <= DASD_EXPIRES_MAX) 2108 device->default_expires = value; 2109 } 2110 2111 /* Read Device Characteristics */ 2112 rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC, 2113 &private->rdc_data, 64); 2114 if (rc) { 2115 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 2116 "Read device characteristic failed, rc=%d", rc); 2117 goto out_err1; 2118 } 2119 2120 /* setup PPRC for device from devmap */ 2121 rc = dasd_devmap_set_device_copy_relation(device->cdev, 2122 dasd_eckd_pprc_enabled(device)); 2123 if (rc) { 2124 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 2125 "copy relation setup failed, rc=%d", rc); 2126 goto out_err1; 2127 } 2128 2129 /* check if block device is needed and allocate in case */ 2130 rc = dasd_eckd_alloc_block(device); 2131 if (rc) 2132 goto out_err1; 2133 2134 /* register lcu with alias handling, enable PAV */ 2135 rc = dasd_alias_make_device_known_to_lcu(device); 2136 if (rc) 2137 goto out_err2; 2138 2139 dasd_eckd_validate_server(device, 0); 2140 2141 /* device may report different configuration data after LCU setup */ 2142 rc = dasd_eckd_read_conf(device); 2143 if (rc) 2144 goto out_err3; 2145 2146 dasd_eckd_read_fc_security(device); 2147 dasd_path_create_kobjects(device); 2148 2149 /* Read Feature Codes */ 2150 dasd_eckd_read_features(device); 2151 2152 /* Read Volume Information */ 2153 dasd_eckd_read_vol_info(device); 2154 2155 /* Read Extent Pool Information */ 2156 dasd_eckd_read_ext_pool_info(device); 2157 2158 if ((device->features & DASD_FEATURE_USERAW) && 2159 !(private->rdc_data.facilities.RT_in_LR)) { 2160 dev_err(&device->cdev->dev, "The storage server does not " 2161 "support raw-track access\n"); 2162 rc = -EINVAL; 2163 goto out_err3; 2164 } 2165 2166 /* find the valid cylinder size */ 2167 if (private->rdc_data.no_cyl == LV_COMPAT_CYL && 2168 private->rdc_data.long_no_cyl) 2169 private->real_cyl = private->rdc_data.long_no_cyl; 2170 else 2171 private->real_cyl = private->rdc_data.no_cyl; 2172 2173 private->fcx_max_data = get_fcx_max_data(device); 2174 2175 readonly = dasd_device_is_ro(device); 2176 if (readonly) 2177 set_bit(DASD_FLAG_DEVICE_RO, &device->flags); 2178 2179 dev_info(&device->cdev->dev, "New DASD %04X/%02X (CU %04X/%02X) " 2180 "with %d cylinders, %d heads, %d sectors%s\n", 2181 private->rdc_data.dev_type, 2182 private->rdc_data.dev_model, 2183 private->rdc_data.cu_type, 2184 private->rdc_data.cu_model.model, 2185 private->real_cyl, 2186 private->rdc_data.trk_per_cyl, 2187 private->rdc_data.sec_per_trk, 2188 readonly ? ", read-only device" : ""); 2189 return 0; 2190 2191out_err3: 2192 dasd_alias_disconnect_device_from_lcu(device); 2193out_err2: 2194 dasd_free_block(device->block); 2195 device->block = NULL; 2196out_err1: 2197 dasd_eckd_clear_conf_data(device); 2198 dasd_path_remove_kobjects(device); 2199 kfree(device->private); 2200 device->private = NULL; 2201 return rc; 2202} 2203 2204static void dasd_eckd_uncheck_device(struct dasd_device *device) 2205{ 2206 struct dasd_eckd_private *private = device->private; 2207 2208 if (!private) 2209 return; 2210 2211 dasd_alias_disconnect_device_from_lcu(device); 2212 private->conf.ned = NULL; 2213 private->conf.sneq = NULL; 2214 private->conf.vdsneq = NULL; 2215 private->conf.gneq = NULL; 2216 dasd_eckd_clear_conf_data(device); 2217 dasd_path_remove_kobjects(device); 2218} 2219 2220static struct dasd_ccw_req * 2221dasd_eckd_analysis_ccw(struct dasd_device *device) 2222{ 2223 struct dasd_eckd_private *private = device->private; 2224 struct eckd_count *count_data; 2225 struct LO_eckd_data *LO_data; 2226 struct dasd_ccw_req *cqr; 2227 struct ccw1 *ccw; 2228 int cplength, datasize; 2229 int i; 2230 2231 cplength = 8; 2232 datasize = sizeof(struct DE_eckd_data) + 2*sizeof(struct LO_eckd_data); 2233 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, device, 2234 NULL); 2235 if (IS_ERR(cqr)) 2236 return cqr; 2237 ccw = cqr->cpaddr; 2238 /* Define extent for the first 2 tracks. */ 2239 define_extent(ccw++, cqr->data, 0, 1, 2240 DASD_ECKD_CCW_READ_COUNT, device, 0); 2241 LO_data = cqr->data + sizeof(struct DE_eckd_data); 2242 /* Locate record for the first 4 records on track 0. */ 2243 ccw[-1].flags |= CCW_FLAG_CC; 2244 locate_record(ccw++, LO_data++, 0, 0, 4, 2245 DASD_ECKD_CCW_READ_COUNT, device, 0); 2246 2247 count_data = private->count_area; 2248 for (i = 0; i < 4; i++) { 2249 ccw[-1].flags |= CCW_FLAG_CC; 2250 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 2251 ccw->flags = 0; 2252 ccw->count = 8; 2253 ccw->cda = virt_to_dma32(count_data); 2254 ccw++; 2255 count_data++; 2256 } 2257 2258 /* Locate record for the first record on track 1. */ 2259 ccw[-1].flags |= CCW_FLAG_CC; 2260 locate_record(ccw++, LO_data++, 1, 0, 1, 2261 DASD_ECKD_CCW_READ_COUNT, device, 0); 2262 /* Read count ccw. */ 2263 ccw[-1].flags |= CCW_FLAG_CC; 2264 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 2265 ccw->flags = 0; 2266 ccw->count = 8; 2267 ccw->cda = virt_to_dma32(count_data); 2268 2269 cqr->block = NULL; 2270 cqr->startdev = device; 2271 cqr->memdev = device; 2272 cqr->retries = 255; 2273 cqr->buildclk = get_tod_clock(); 2274 cqr->status = DASD_CQR_FILLED; 2275 /* Set flags to suppress output for expected errors */ 2276 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags); 2277 2278 return cqr; 2279} 2280 2281/* differentiate between 'no record found' and any other error */ 2282static int dasd_eckd_analysis_evaluation(struct dasd_ccw_req *init_cqr) 2283{ 2284 char *sense; 2285 if (init_cqr->status == DASD_CQR_DONE) 2286 return INIT_CQR_OK; 2287 else if (init_cqr->status == DASD_CQR_NEED_ERP || 2288 init_cqr->status == DASD_CQR_FAILED) { 2289 sense = dasd_get_sense(&init_cqr->irb); 2290 if (sense && (sense[1] & SNS1_NO_REC_FOUND)) 2291 return INIT_CQR_UNFORMATTED; 2292 else 2293 return INIT_CQR_ERROR; 2294 } else 2295 return INIT_CQR_ERROR; 2296} 2297 2298/* 2299 * This is the callback function for the init_analysis cqr. It saves 2300 * the status of the initial analysis ccw before it frees it and kicks 2301 * the device to continue the startup sequence. This will call 2302 * dasd_eckd_do_analysis again (if the devices has not been marked 2303 * for deletion in the meantime). 2304 */ 2305static void dasd_eckd_analysis_callback(struct dasd_ccw_req *init_cqr, 2306 void *data) 2307{ 2308 struct dasd_device *device = init_cqr->startdev; 2309 struct dasd_eckd_private *private = device->private; 2310 2311 private->init_cqr_status = dasd_eckd_analysis_evaluation(init_cqr); 2312 dasd_sfree_request(init_cqr, device); 2313 dasd_kick_device(device); 2314} 2315 2316static int dasd_eckd_start_analysis(struct dasd_block *block) 2317{ 2318 struct dasd_ccw_req *init_cqr; 2319 2320 init_cqr = dasd_eckd_analysis_ccw(block->base); 2321 if (IS_ERR(init_cqr)) 2322 return PTR_ERR(init_cqr); 2323 init_cqr->callback = dasd_eckd_analysis_callback; 2324 init_cqr->callback_data = NULL; 2325 init_cqr->expires = 5*HZ; 2326 /* first try without ERP, so we can later handle unformatted 2327 * devices as special case 2328 */ 2329 clear_bit(DASD_CQR_FLAGS_USE_ERP, &init_cqr->flags); 2330 init_cqr->retries = 0; 2331 dasd_add_request_head(init_cqr); 2332 return -EAGAIN; 2333} 2334 2335static int dasd_eckd_end_analysis(struct dasd_block *block) 2336{ 2337 struct dasd_device *device = block->base; 2338 struct dasd_eckd_private *private = device->private; 2339 struct eckd_count *count_area; 2340 unsigned int sb, blk_per_trk; 2341 int status, i; 2342 struct dasd_ccw_req *init_cqr; 2343 2344 status = private->init_cqr_status; 2345 private->init_cqr_status = -1; 2346 if (status == INIT_CQR_ERROR) { 2347 /* try again, this time with full ERP */ 2348 init_cqr = dasd_eckd_analysis_ccw(device); 2349 dasd_sleep_on(init_cqr); 2350 status = dasd_eckd_analysis_evaluation(init_cqr); 2351 dasd_sfree_request(init_cqr, device); 2352 } 2353 2354 if (device->features & DASD_FEATURE_USERAW) { 2355 block->bp_block = DASD_RAW_BLOCKSIZE; 2356 blk_per_trk = DASD_RAW_BLOCK_PER_TRACK; 2357 block->s2b_shift = 3; 2358 goto raw; 2359 } 2360 2361 if (status == INIT_CQR_UNFORMATTED) { 2362 dev_warn(&device->cdev->dev, "The DASD is not formatted\n"); 2363 return -EMEDIUMTYPE; 2364 } else if (status == INIT_CQR_ERROR) { 2365 dev_err(&device->cdev->dev, 2366 "Detecting the DASD disk layout failed because " 2367 "of an I/O error\n"); 2368 return -EIO; 2369 } 2370 2371 private->uses_cdl = 1; 2372 /* Check Track 0 for Compatible Disk Layout */ 2373 count_area = NULL; 2374 for (i = 0; i < 3; i++) { 2375 if (private->count_area[i].kl != 4 || 2376 private->count_area[i].dl != dasd_eckd_cdl_reclen(i) - 4 || 2377 private->count_area[i].cyl != 0 || 2378 private->count_area[i].head != count_area_head[i] || 2379 private->count_area[i].record != count_area_rec[i]) { 2380 private->uses_cdl = 0; 2381 break; 2382 } 2383 } 2384 if (i == 3) 2385 count_area = &private->count_area[3]; 2386 2387 if (private->uses_cdl == 0) { 2388 for (i = 0; i < 5; i++) { 2389 if ((private->count_area[i].kl != 0) || 2390 (private->count_area[i].dl != 2391 private->count_area[0].dl) || 2392 private->count_area[i].cyl != 0 || 2393 private->count_area[i].head != count_area_head[i] || 2394 private->count_area[i].record != count_area_rec[i]) 2395 break; 2396 } 2397 if (i == 5) 2398 count_area = &private->count_area[0]; 2399 } else { 2400 if (private->count_area[3].record == 1) 2401 dev_warn(&device->cdev->dev, 2402 "Track 0 has no records following the VTOC\n"); 2403 } 2404 2405 if (count_area != NULL && count_area->kl == 0) { 2406 /* we found notthing violating our disk layout */ 2407 if (dasd_check_blocksize(count_area->dl) == 0) 2408 block->bp_block = count_area->dl; 2409 } 2410 if (block->bp_block == 0) { 2411 dev_warn(&device->cdev->dev, 2412 "The disk layout of the DASD is not supported\n"); 2413 return -EMEDIUMTYPE; 2414 } 2415 block->s2b_shift = 0; /* bits to shift 512 to get a block */ 2416 for (sb = 512; sb < block->bp_block; sb = sb << 1) 2417 block->s2b_shift++; 2418 2419 blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block); 2420 2421raw: 2422 block->blocks = ((unsigned long) private->real_cyl * 2423 private->rdc_data.trk_per_cyl * 2424 blk_per_trk); 2425 2426 dev_info(&device->cdev->dev, 2427 "DASD with %u KB/block, %lu KB total size, %u KB/track, " 2428 "%s\n", (block->bp_block >> 10), 2429 (((unsigned long) private->real_cyl * 2430 private->rdc_data.trk_per_cyl * 2431 blk_per_trk * (block->bp_block >> 9)) >> 1), 2432 ((blk_per_trk * block->bp_block) >> 10), 2433 private->uses_cdl ? 2434 "compatible disk layout" : "linux disk layout"); 2435 2436 return 0; 2437} 2438 2439static int dasd_eckd_do_analysis(struct dasd_block *block) 2440{ 2441 struct dasd_eckd_private *private = block->base->private; 2442 2443 if (private->init_cqr_status < 0) 2444 return dasd_eckd_start_analysis(block); 2445 else 2446 return dasd_eckd_end_analysis(block); 2447} 2448 2449static int dasd_eckd_basic_to_ready(struct dasd_device *device) 2450{ 2451 return dasd_alias_add_device(device); 2452}; 2453 2454static int dasd_eckd_online_to_ready(struct dasd_device *device) 2455{ 2456 if (cancel_work_sync(&device->reload_device)) 2457 dasd_put_device(device); 2458 if (cancel_work_sync(&device->kick_validate)) 2459 dasd_put_device(device); 2460 2461 return 0; 2462}; 2463 2464static int dasd_eckd_basic_to_known(struct dasd_device *device) 2465{ 2466 return dasd_alias_remove_device(device); 2467}; 2468 2469static int 2470dasd_eckd_fill_geometry(struct dasd_block *block, struct hd_geometry *geo) 2471{ 2472 struct dasd_eckd_private *private = block->base->private; 2473 2474 if (dasd_check_blocksize(block->bp_block) == 0) { 2475 geo->sectors = recs_per_track(&private->rdc_data, 2476 0, block->bp_block); 2477 } 2478 geo->cylinders = private->rdc_data.no_cyl; 2479 geo->heads = private->rdc_data.trk_per_cyl; 2480 return 0; 2481} 2482 2483/* 2484 * Build the TCW request for the format check 2485 */ 2486static struct dasd_ccw_req * 2487dasd_eckd_build_check_tcw(struct dasd_device *base, struct format_data_t *fdata, 2488 int enable_pav, struct eckd_count *fmt_buffer, 2489 int rpt) 2490{ 2491 struct dasd_eckd_private *start_priv; 2492 struct dasd_device *startdev = NULL; 2493 struct tidaw *last_tidaw = NULL; 2494 struct dasd_ccw_req *cqr; 2495 struct itcw *itcw; 2496 int itcw_size; 2497 int count; 2498 int rc; 2499 int i; 2500 2501 if (enable_pav) 2502 startdev = dasd_alias_get_start_dev(base); 2503 2504 if (!startdev) 2505 startdev = base; 2506 2507 start_priv = startdev->private; 2508 2509 count = rpt * (fdata->stop_unit - fdata->start_unit + 1); 2510 2511 /* 2512 * we're adding 'count' amount of tidaw to the itcw. 2513 * calculate the corresponding itcw_size 2514 */ 2515 itcw_size = itcw_calc_size(0, count, 0); 2516 2517 cqr = dasd_fmalloc_request(DASD_ECKD_MAGIC, 0, itcw_size, startdev); 2518 if (IS_ERR(cqr)) 2519 return cqr; 2520 2521 start_priv->count++; 2522 2523 itcw = itcw_init(cqr->data, itcw_size, ITCW_OP_READ, 0, count, 0); 2524 if (IS_ERR(itcw)) { 2525 rc = -EINVAL; 2526 goto out_err; 2527 } 2528 2529 cqr->cpaddr = itcw_get_tcw(itcw); 2530 rc = prepare_itcw(itcw, fdata->start_unit, fdata->stop_unit, 2531 DASD_ECKD_CCW_READ_COUNT_MT, base, startdev, 0, count, 2532 sizeof(struct eckd_count), 2533 count * sizeof(struct eckd_count), 0, rpt); 2534 if (rc) 2535 goto out_err; 2536 2537 for (i = 0; i < count; i++) { 2538 last_tidaw = itcw_add_tidaw(itcw, 0, fmt_buffer++, 2539 sizeof(struct eckd_count)); 2540 if (IS_ERR(last_tidaw)) { 2541 rc = -EINVAL; 2542 goto out_err; 2543 } 2544 } 2545 2546 last_tidaw->flags |= TIDAW_FLAGS_LAST; 2547 itcw_finalize(itcw); 2548 2549 cqr->cpmode = 1; 2550 cqr->startdev = startdev; 2551 cqr->memdev = startdev; 2552 cqr->basedev = base; 2553 cqr->retries = startdev->default_retries; 2554 cqr->expires = startdev->default_expires * HZ; 2555 cqr->buildclk = get_tod_clock(); 2556 cqr->status = DASD_CQR_FILLED; 2557 /* Set flags to suppress output for expected errors */ 2558 set_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags); 2559 set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags); 2560 2561 return cqr; 2562 2563out_err: 2564 dasd_sfree_request(cqr, startdev); 2565 2566 return ERR_PTR(rc); 2567} 2568 2569/* 2570 * Build the CCW request for the format check 2571 */ 2572static struct dasd_ccw_req * 2573dasd_eckd_build_check(struct dasd_device *base, struct format_data_t *fdata, 2574 int enable_pav, struct eckd_count *fmt_buffer, int rpt) 2575{ 2576 struct dasd_eckd_private *start_priv; 2577 struct dasd_eckd_private *base_priv; 2578 struct dasd_device *startdev = NULL; 2579 struct dasd_ccw_req *cqr; 2580 struct ccw1 *ccw; 2581 void *data; 2582 int cplength, datasize; 2583 int use_prefix; 2584 int count; 2585 int i; 2586 2587 if (enable_pav) 2588 startdev = dasd_alias_get_start_dev(base); 2589 2590 if (!startdev) 2591 startdev = base; 2592 2593 start_priv = startdev->private; 2594 base_priv = base->private; 2595 2596 count = rpt * (fdata->stop_unit - fdata->start_unit + 1); 2597 2598 use_prefix = base_priv->features.feature[8] & 0x01; 2599 2600 if (use_prefix) { 2601 cplength = 1; 2602 datasize = sizeof(struct PFX_eckd_data); 2603 } else { 2604 cplength = 2; 2605 datasize = sizeof(struct DE_eckd_data) + 2606 sizeof(struct LO_eckd_data); 2607 } 2608 cplength += count; 2609 2610 cqr = dasd_fmalloc_request(DASD_ECKD_MAGIC, cplength, datasize, startdev); 2611 if (IS_ERR(cqr)) 2612 return cqr; 2613 2614 start_priv->count++; 2615 data = cqr->data; 2616 ccw = cqr->cpaddr; 2617 2618 if (use_prefix) { 2619 prefix_LRE(ccw++, data, fdata->start_unit, fdata->stop_unit, 2620 DASD_ECKD_CCW_READ_COUNT, base, startdev, 1, 0, 2621 count, 0, 0); 2622 } else { 2623 define_extent(ccw++, data, fdata->start_unit, fdata->stop_unit, 2624 DASD_ECKD_CCW_READ_COUNT, startdev, 0); 2625 2626 data += sizeof(struct DE_eckd_data); 2627 ccw[-1].flags |= CCW_FLAG_CC; 2628 2629 locate_record(ccw++, data, fdata->start_unit, 0, count, 2630 DASD_ECKD_CCW_READ_COUNT, base, 0); 2631 } 2632 2633 for (i = 0; i < count; i++) { 2634 ccw[-1].flags |= CCW_FLAG_CC; 2635 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 2636 ccw->flags = CCW_FLAG_SLI; 2637 ccw->count = 8; 2638 ccw->cda = virt_to_dma32(fmt_buffer); 2639 ccw++; 2640 fmt_buffer++; 2641 } 2642 2643 cqr->startdev = startdev; 2644 cqr->memdev = startdev; 2645 cqr->basedev = base; 2646 cqr->retries = DASD_RETRIES; 2647 cqr->expires = startdev->default_expires * HZ; 2648 cqr->buildclk = get_tod_clock(); 2649 cqr->status = DASD_CQR_FILLED; 2650 /* Set flags to suppress output for expected errors */ 2651 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags); 2652 2653 return cqr; 2654} 2655 2656static struct dasd_ccw_req * 2657dasd_eckd_build_format(struct dasd_device *base, struct dasd_device *startdev, 2658 struct format_data_t *fdata, int enable_pav) 2659{ 2660 struct dasd_eckd_private *base_priv; 2661 struct dasd_eckd_private *start_priv; 2662 struct dasd_ccw_req *fcp; 2663 struct eckd_count *ect; 2664 struct ch_t address; 2665 struct ccw1 *ccw; 2666 void *data; 2667 int rpt; 2668 int cplength, datasize; 2669 int i, j; 2670 int intensity = 0; 2671 int r0_perm; 2672 int nr_tracks; 2673 int use_prefix; 2674 2675 if (enable_pav) 2676 startdev = dasd_alias_get_start_dev(base); 2677 2678 if (!startdev) 2679 startdev = base; 2680 2681 start_priv = startdev->private; 2682 base_priv = base->private; 2683 2684 rpt = recs_per_track(&base_priv->rdc_data, 0, fdata->blksize); 2685 2686 nr_tracks = fdata->stop_unit - fdata->start_unit + 1; 2687 2688 /* 2689 * fdata->intensity is a bit string that tells us what to do: 2690 * Bit 0: write record zero 2691 * Bit 1: write home address, currently not supported 2692 * Bit 2: invalidate tracks 2693 * Bit 3: use OS/390 compatible disk layout (cdl) 2694 * Bit 4: do not allow storage subsystem to modify record zero 2695 * Only some bit combinations do make sense. 2696 */ 2697 if (fdata->intensity & 0x10) { 2698 r0_perm = 0; 2699 intensity = fdata->intensity & ~0x10; 2700 } else { 2701 r0_perm = 1; 2702 intensity = fdata->intensity; 2703 } 2704 2705 use_prefix = base_priv->features.feature[8] & 0x01; 2706 2707 switch (intensity) { 2708 case 0x00: /* Normal format */ 2709 case 0x08: /* Normal format, use cdl. */ 2710 cplength = 2 + (rpt*nr_tracks); 2711 if (use_prefix) 2712 datasize = sizeof(struct PFX_eckd_data) + 2713 sizeof(struct LO_eckd_data) + 2714 rpt * nr_tracks * sizeof(struct eckd_count); 2715 else 2716 datasize = sizeof(struct DE_eckd_data) + 2717 sizeof(struct LO_eckd_data) + 2718 rpt * nr_tracks * sizeof(struct eckd_count); 2719 break; 2720 case 0x01: /* Write record zero and format track. */ 2721 case 0x09: /* Write record zero and format track, use cdl. */ 2722 cplength = 2 + rpt * nr_tracks; 2723 if (use_prefix) 2724 datasize = sizeof(struct PFX_eckd_data) + 2725 sizeof(struct LO_eckd_data) + 2726 sizeof(struct eckd_count) + 2727 rpt * nr_tracks * sizeof(struct eckd_count); 2728 else 2729 datasize = sizeof(struct DE_eckd_data) + 2730 sizeof(struct LO_eckd_data) + 2731 sizeof(struct eckd_count) + 2732 rpt * nr_tracks * sizeof(struct eckd_count); 2733 break; 2734 case 0x04: /* Invalidate track. */ 2735 case 0x0c: /* Invalidate track, use cdl. */ 2736 cplength = 3; 2737 if (use_prefix) 2738 datasize = sizeof(struct PFX_eckd_data) + 2739 sizeof(struct LO_eckd_data) + 2740 sizeof(struct eckd_count); 2741 else 2742 datasize = sizeof(struct DE_eckd_data) + 2743 sizeof(struct LO_eckd_data) + 2744 sizeof(struct eckd_count); 2745 break; 2746 default: 2747 dev_warn(&startdev->cdev->dev, 2748 "An I/O control call used incorrect flags 0x%x\n", 2749 fdata->intensity); 2750 return ERR_PTR(-EINVAL); 2751 } 2752 2753 fcp = dasd_fmalloc_request(DASD_ECKD_MAGIC, cplength, datasize, startdev); 2754 if (IS_ERR(fcp)) 2755 return fcp; 2756 2757 start_priv->count++; 2758 data = fcp->data; 2759 ccw = fcp->cpaddr; 2760 2761 switch (intensity & ~0x08) { 2762 case 0x00: /* Normal format. */ 2763 if (use_prefix) { 2764 prefix(ccw++, (struct PFX_eckd_data *) data, 2765 fdata->start_unit, fdata->stop_unit, 2766 DASD_ECKD_CCW_WRITE_CKD, base, startdev); 2767 /* grant subsystem permission to format R0 */ 2768 if (r0_perm) 2769 ((struct PFX_eckd_data *)data) 2770 ->define_extent.ga_extended |= 0x04; 2771 data += sizeof(struct PFX_eckd_data); 2772 } else { 2773 define_extent(ccw++, (struct DE_eckd_data *) data, 2774 fdata->start_unit, fdata->stop_unit, 2775 DASD_ECKD_CCW_WRITE_CKD, startdev, 0); 2776 /* grant subsystem permission to format R0 */ 2777 if (r0_perm) 2778 ((struct DE_eckd_data *) data) 2779 ->ga_extended |= 0x04; 2780 data += sizeof(struct DE_eckd_data); 2781 } 2782 ccw[-1].flags |= CCW_FLAG_CC; 2783 locate_record(ccw++, (struct LO_eckd_data *) data, 2784 fdata->start_unit, 0, rpt*nr_tracks, 2785 DASD_ECKD_CCW_WRITE_CKD, base, 2786 fdata->blksize); 2787 data += sizeof(struct LO_eckd_data); 2788 break; 2789 case 0x01: /* Write record zero + format track. */ 2790 if (use_prefix) { 2791 prefix(ccw++, (struct PFX_eckd_data *) data, 2792 fdata->start_unit, fdata->stop_unit, 2793 DASD_ECKD_CCW_WRITE_RECORD_ZERO, 2794 base, startdev); 2795 data += sizeof(struct PFX_eckd_data); 2796 } else { 2797 define_extent(ccw++, (struct DE_eckd_data *) data, 2798 fdata->start_unit, fdata->stop_unit, 2799 DASD_ECKD_CCW_WRITE_RECORD_ZERO, startdev, 0); 2800 data += sizeof(struct DE_eckd_data); 2801 } 2802 ccw[-1].flags |= CCW_FLAG_CC; 2803 locate_record(ccw++, (struct LO_eckd_data *) data, 2804 fdata->start_unit, 0, rpt * nr_tracks + 1, 2805 DASD_ECKD_CCW_WRITE_RECORD_ZERO, base, 2806 base->block->bp_block); 2807 data += sizeof(struct LO_eckd_data); 2808 break; 2809 case 0x04: /* Invalidate track. */ 2810 if (use_prefix) { 2811 prefix(ccw++, (struct PFX_eckd_data *) data, 2812 fdata->start_unit, fdata->stop_unit, 2813 DASD_ECKD_CCW_WRITE_CKD, base, startdev); 2814 data += sizeof(struct PFX_eckd_data); 2815 } else { 2816 define_extent(ccw++, (struct DE_eckd_data *) data, 2817 fdata->start_unit, fdata->stop_unit, 2818 DASD_ECKD_CCW_WRITE_CKD, startdev, 0); 2819 data += sizeof(struct DE_eckd_data); 2820 } 2821 ccw[-1].flags |= CCW_FLAG_CC; 2822 locate_record(ccw++, (struct LO_eckd_data *) data, 2823 fdata->start_unit, 0, 1, 2824 DASD_ECKD_CCW_WRITE_CKD, base, 8); 2825 data += sizeof(struct LO_eckd_data); 2826 break; 2827 } 2828 2829 for (j = 0; j < nr_tracks; j++) { 2830 /* calculate cylinder and head for the current track */ 2831 set_ch_t(&address, 2832 (fdata->start_unit + j) / 2833 base_priv->rdc_data.trk_per_cyl, 2834 (fdata->start_unit + j) % 2835 base_priv->rdc_data.trk_per_cyl); 2836 if (intensity & 0x01) { /* write record zero */ 2837 ect = (struct eckd_count *) data; 2838 data += sizeof(struct eckd_count); 2839 ect->cyl = address.cyl; 2840 ect->head = address.head; 2841 ect->record = 0; 2842 ect->kl = 0; 2843 ect->dl = 8; 2844 ccw[-1].flags |= CCW_FLAG_CC; 2845 ccw->cmd_code = DASD_ECKD_CCW_WRITE_RECORD_ZERO; 2846 ccw->flags = CCW_FLAG_SLI; 2847 ccw->count = 8; 2848 ccw->cda = virt_to_dma32(ect); 2849 ccw++; 2850 } 2851 if ((intensity & ~0x08) & 0x04) { /* erase track */ 2852 ect = (struct eckd_count *) data; 2853 data += sizeof(struct eckd_count); 2854 ect->cyl = address.cyl; 2855 ect->head = address.head; 2856 ect->record = 1; 2857 ect->kl = 0; 2858 ect->dl = 0; 2859 ccw[-1].flags |= CCW_FLAG_CC; 2860 ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD; 2861 ccw->flags = CCW_FLAG_SLI; 2862 ccw->count = 8; 2863 ccw->cda = virt_to_dma32(ect); 2864 } else { /* write remaining records */ 2865 for (i = 0; i < rpt; i++) { 2866 ect = (struct eckd_count *) data; 2867 data += sizeof(struct eckd_count); 2868 ect->cyl = address.cyl; 2869 ect->head = address.head; 2870 ect->record = i + 1; 2871 ect->kl = 0; 2872 ect->dl = fdata->blksize; 2873 /* 2874 * Check for special tracks 0-1 2875 * when formatting CDL 2876 */ 2877 if ((intensity & 0x08) && 2878 address.cyl == 0 && address.head == 0) { 2879 if (i < 3) { 2880 ect->kl = 4; 2881 ect->dl = sizes_trk0[i] - 4; 2882 } 2883 } 2884 if ((intensity & 0x08) && 2885 address.cyl == 0 && address.head == 1) { 2886 ect->kl = 44; 2887 ect->dl = LABEL_SIZE - 44; 2888 } 2889 ccw[-1].flags |= CCW_FLAG_CC; 2890 if (i != 0 || j == 0) 2891 ccw->cmd_code = 2892 DASD_ECKD_CCW_WRITE_CKD; 2893 else 2894 ccw->cmd_code = 2895 DASD_ECKD_CCW_WRITE_CKD_MT; 2896 ccw->flags = CCW_FLAG_SLI; 2897 ccw->count = 8; 2898 ccw->cda = virt_to_dma32(ect); 2899 ccw++; 2900 } 2901 } 2902 } 2903 2904 fcp->startdev = startdev; 2905 fcp->memdev = startdev; 2906 fcp->basedev = base; 2907 fcp->retries = 256; 2908 fcp->expires = startdev->default_expires * HZ; 2909 fcp->buildclk = get_tod_clock(); 2910 fcp->status = DASD_CQR_FILLED; 2911 2912 return fcp; 2913} 2914 2915/* 2916 * Wrapper function to build a CCW request depending on input data 2917 */ 2918static struct dasd_ccw_req * 2919dasd_eckd_format_build_ccw_req(struct dasd_device *base, 2920 struct format_data_t *fdata, int enable_pav, 2921 int tpm, struct eckd_count *fmt_buffer, int rpt) 2922{ 2923 struct dasd_ccw_req *ccw_req; 2924 2925 if (!fmt_buffer) { 2926 ccw_req = dasd_eckd_build_format(base, NULL, fdata, enable_pav); 2927 } else { 2928 if (tpm) 2929 ccw_req = dasd_eckd_build_check_tcw(base, fdata, 2930 enable_pav, 2931 fmt_buffer, rpt); 2932 else 2933 ccw_req = dasd_eckd_build_check(base, fdata, enable_pav, 2934 fmt_buffer, rpt); 2935 } 2936 2937 return ccw_req; 2938} 2939 2940/* 2941 * Sanity checks on format_data 2942 */ 2943static int dasd_eckd_format_sanity_checks(struct dasd_device *base, 2944 struct format_data_t *fdata) 2945{ 2946 struct dasd_eckd_private *private = base->private; 2947 2948 if (fdata->start_unit >= 2949 (private->real_cyl * private->rdc_data.trk_per_cyl)) { 2950 dev_warn(&base->cdev->dev, 2951 "Start track number %u used in formatting is too big\n", 2952 fdata->start_unit); 2953 return -EINVAL; 2954 } 2955 if (fdata->stop_unit >= 2956 (private->real_cyl * private->rdc_data.trk_per_cyl)) { 2957 dev_warn(&base->cdev->dev, 2958 "Stop track number %u used in formatting is too big\n", 2959 fdata->stop_unit); 2960 return -EINVAL; 2961 } 2962 if (fdata->start_unit > fdata->stop_unit) { 2963 dev_warn(&base->cdev->dev, 2964 "Start track %u used in formatting exceeds end track\n", 2965 fdata->start_unit); 2966 return -EINVAL; 2967 } 2968 if (dasd_check_blocksize(fdata->blksize) != 0) { 2969 dev_warn(&base->cdev->dev, 2970 "The DASD cannot be formatted with block size %u\n", 2971 fdata->blksize); 2972 return -EINVAL; 2973 } 2974 return 0; 2975} 2976 2977/* 2978 * This function will process format_data originally coming from an IOCTL 2979 */ 2980static int dasd_eckd_format_process_data(struct dasd_device *base, 2981 struct format_data_t *fdata, 2982 int enable_pav, int tpm, 2983 struct eckd_count *fmt_buffer, int rpt, 2984 struct irb *irb) 2985{ 2986 struct dasd_eckd_private *private = base->private; 2987 struct dasd_ccw_req *cqr, *n; 2988 struct list_head format_queue; 2989 struct dasd_device *device; 2990 char *sense = NULL; 2991 int old_start, old_stop, format_step; 2992 int step, retry; 2993 int rc; 2994 2995 rc = dasd_eckd_format_sanity_checks(base, fdata); 2996 if (rc) 2997 return rc; 2998 2999 INIT_LIST_HEAD(&format_queue); 3000 3001 old_start = fdata->start_unit; 3002 old_stop = fdata->stop_unit; 3003 3004 if (!tpm && fmt_buffer != NULL) { 3005 /* Command Mode / Format Check */ 3006 format_step = 1; 3007 } else if (tpm && fmt_buffer != NULL) { 3008 /* Transport Mode / Format Check */ 3009 format_step = DASD_CQR_MAX_CCW / rpt; 3010 } else { 3011 /* Normal Formatting */ 3012 format_step = DASD_CQR_MAX_CCW / 3013 recs_per_track(&private->rdc_data, 0, fdata->blksize); 3014 } 3015 3016 do { 3017 retry = 0; 3018 while (fdata->start_unit <= old_stop) { 3019 step = fdata->stop_unit - fdata->start_unit + 1; 3020 if (step > format_step) { 3021 fdata->stop_unit = 3022 fdata->start_unit + format_step - 1; 3023 } 3024 3025 cqr = dasd_eckd_format_build_ccw_req(base, fdata, 3026 enable_pav, tpm, 3027 fmt_buffer, rpt); 3028 if (IS_ERR(cqr)) { 3029 rc = PTR_ERR(cqr); 3030 if (rc == -ENOMEM) { 3031 if (list_empty(&format_queue)) 3032 goto out; 3033 /* 3034 * not enough memory available, start 3035 * requests retry after first requests 3036 * were finished 3037 */ 3038 retry = 1; 3039 break; 3040 } 3041 goto out_err; 3042 } 3043 list_add_tail(&cqr->blocklist, &format_queue); 3044 3045 if (fmt_buffer) { 3046 step = fdata->stop_unit - fdata->start_unit + 1; 3047 fmt_buffer += rpt * step; 3048 } 3049 fdata->start_unit = fdata->stop_unit + 1; 3050 fdata->stop_unit = old_stop; 3051 } 3052 3053 rc = dasd_sleep_on_queue(&format_queue); 3054 3055out_err: 3056 list_for_each_entry_safe(cqr, n, &format_queue, blocklist) { 3057 device = cqr->startdev; 3058 private = device->private; 3059 3060 if (cqr->status == DASD_CQR_FAILED) { 3061 /* 3062 * Only get sense data if called by format 3063 * check 3064 */ 3065 if (fmt_buffer && irb) { 3066 sense = dasd_get_sense(&cqr->irb); 3067 memcpy(irb, &cqr->irb, sizeof(*irb)); 3068 } 3069 rc = -EIO; 3070 } 3071 list_del_init(&cqr->blocklist); 3072 dasd_ffree_request(cqr, device); 3073 private->count--; 3074 } 3075 3076 if (rc && rc != -EIO) 3077 goto out; 3078 if (rc == -EIO) { 3079 /* 3080 * In case fewer than the expected records are on the 3081 * track, we will most likely get a 'No Record Found' 3082 * error (in command mode) or a 'File Protected' error 3083 * (in transport mode). Those particular cases shouldn't 3084 * pass the -EIO to the IOCTL, therefore reset the rc 3085 * and continue. 3086 */ 3087 if (sense && 3088 (sense[1] & SNS1_NO_REC_FOUND || 3089 sense[1] & SNS1_FILE_PROTECTED)) 3090 retry = 1; 3091 else 3092 goto out; 3093 } 3094 3095 } while (retry); 3096 3097out: 3098 fdata->start_unit = old_start; 3099 fdata->stop_unit = old_stop; 3100 3101 return rc; 3102} 3103 3104static int dasd_eckd_format_device(struct dasd_device *base, 3105 struct format_data_t *fdata, int enable_pav) 3106{ 3107 return dasd_eckd_format_process_data(base, fdata, enable_pav, 0, NULL, 3108 0, NULL); 3109} 3110 3111static bool test_and_set_format_track(struct dasd_format_entry *to_format, 3112 struct dasd_ccw_req *cqr) 3113{ 3114 struct dasd_block *block = cqr->block; 3115 struct dasd_format_entry *format; 3116 unsigned long flags; 3117 bool rc = false; 3118 3119 spin_lock_irqsave(&block->format_lock, flags); 3120 if (cqr->trkcount != atomic_read(&block->trkcount)) { 3121 /* 3122 * The number of formatted tracks has changed after request 3123 * start and we can not tell if the current track was involved. 3124 * To avoid data corruption treat it as if the current track is 3125 * involved 3126 */ 3127 rc = true; 3128 goto out; 3129 } 3130 list_for_each_entry(format, &block->format_list, list) { 3131 if (format->track == to_format->track) { 3132 rc = true; 3133 goto out; 3134 } 3135 } 3136 list_add_tail(&to_format->list, &block->format_list); 3137 3138out: 3139 spin_unlock_irqrestore(&block->format_lock, flags); 3140 return rc; 3141} 3142 3143static void clear_format_track(struct dasd_format_entry *format, 3144 struct dasd_block *block) 3145{ 3146 unsigned long flags; 3147 3148 spin_lock_irqsave(&block->format_lock, flags); 3149 atomic_inc(&block->trkcount); 3150 list_del_init(&format->list); 3151 spin_unlock_irqrestore(&block->format_lock, flags); 3152} 3153 3154/* 3155 * Callback function to free ESE format requests. 3156 */ 3157static void dasd_eckd_ese_format_cb(struct dasd_ccw_req *cqr, void *data) 3158{ 3159 struct dasd_device *device = cqr->startdev; 3160 struct dasd_eckd_private *private = device->private; 3161 struct dasd_format_entry *format = data; 3162 3163 clear_format_track(format, cqr->basedev->block); 3164 private->count--; 3165 dasd_ffree_request(cqr, device); 3166} 3167 3168static struct dasd_ccw_req * 3169dasd_eckd_ese_format(struct dasd_device *startdev, struct dasd_ccw_req *cqr, 3170 struct irb *irb) 3171{ 3172 struct dasd_eckd_private *private; 3173 struct dasd_format_entry *format; 3174 struct format_data_t fdata; 3175 unsigned int recs_per_trk; 3176 struct dasd_ccw_req *fcqr; 3177 struct dasd_device *base; 3178 struct dasd_block *block; 3179 unsigned int blksize; 3180 struct request *req; 3181 sector_t first_trk; 3182 sector_t last_trk; 3183 sector_t curr_trk; 3184 int rc; 3185 3186 req = dasd_get_callback_data(cqr); 3187 block = cqr->block; 3188 base = block->base; 3189 private = base->private; 3190 blksize = block->bp_block; 3191 recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize); 3192 format = &startdev->format_entry; 3193 3194 first_trk = blk_rq_pos(req) >> block->s2b_shift; 3195 sector_div(first_trk, recs_per_trk); 3196 last_trk = 3197 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift; 3198 sector_div(last_trk, recs_per_trk); 3199 rc = dasd_eckd_track_from_irb(irb, base, &curr_trk); 3200 if (rc) 3201 return ERR_PTR(rc); 3202 3203 if (curr_trk < first_trk || curr_trk > last_trk) { 3204 DBF_DEV_EVENT(DBF_WARNING, startdev, 3205 "ESE error track %llu not within range %llu - %llu\n", 3206 curr_trk, first_trk, last_trk); 3207 return ERR_PTR(-EINVAL); 3208 } 3209 format->track = curr_trk; 3210 /* test if track is already in formatting by another thread */ 3211 if (test_and_set_format_track(format, cqr)) { 3212 /* this is no real error so do not count down retries */ 3213 cqr->retries++; 3214 return ERR_PTR(-EEXIST); 3215 } 3216 3217 fdata.start_unit = curr_trk; 3218 fdata.stop_unit = curr_trk; 3219 fdata.blksize = blksize; 3220 fdata.intensity = private->uses_cdl ? DASD_FMT_INT_COMPAT : 0; 3221 3222 rc = dasd_eckd_format_sanity_checks(base, &fdata); 3223 if (rc) 3224 return ERR_PTR(-EINVAL); 3225 3226 /* 3227 * We're building the request with PAV disabled as we're reusing 3228 * the former startdev. 3229 */ 3230 fcqr = dasd_eckd_build_format(base, startdev, &fdata, 0); 3231 if (IS_ERR(fcqr)) 3232 return fcqr; 3233 3234 fcqr->callback = dasd_eckd_ese_format_cb; 3235 fcqr->callback_data = (void *) format; 3236 3237 return fcqr; 3238} 3239 3240/* 3241 * When data is read from an unformatted area of an ESE volume, this function 3242 * returns zeroed data and thereby mimics a read of zero data. 3243 * 3244 * The first unformatted track is the one that got the NRF error, the address is 3245 * encoded in the sense data. 3246 * 3247 * All tracks before have returned valid data and should not be touched. 3248 * All tracks after the unformatted track might be formatted or not. This is 3249 * currently not known, remember the processed data and return the remainder of 3250 * the request to the blocklayer in __dasd_cleanup_cqr(). 3251 */ 3252static int dasd_eckd_ese_read(struct dasd_ccw_req *cqr, struct irb *irb) 3253{ 3254 struct dasd_eckd_private *private; 3255 sector_t first_trk, last_trk; 3256 sector_t first_blk, last_blk; 3257 unsigned int blksize, off; 3258 unsigned int recs_per_trk; 3259 struct dasd_device *base; 3260 struct req_iterator iter; 3261 struct dasd_block *block; 3262 unsigned int skip_block; 3263 unsigned int blk_count; 3264 struct request *req; 3265 struct bio_vec bv; 3266 sector_t curr_trk; 3267 sector_t end_blk; 3268 char *dst; 3269 int rc; 3270 3271 req = (struct request *) cqr->callback_data; 3272 base = cqr->block->base; 3273 blksize = base->block->bp_block; 3274 block = cqr->block; 3275 private = base->private; 3276 skip_block = 0; 3277 blk_count = 0; 3278 3279 recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize); 3280 first_trk = first_blk = blk_rq_pos(req) >> block->s2b_shift; 3281 sector_div(first_trk, recs_per_trk); 3282 last_trk = last_blk = 3283 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift; 3284 sector_div(last_trk, recs_per_trk); 3285 rc = dasd_eckd_track_from_irb(irb, base, &curr_trk); 3286 if (rc) 3287 return rc; 3288 3289 /* sanity check if the current track from sense data is valid */ 3290 if (curr_trk < first_trk || curr_trk > last_trk) { 3291 DBF_DEV_EVENT(DBF_WARNING, base, 3292 "ESE error track %llu not within range %llu - %llu\n", 3293 curr_trk, first_trk, last_trk); 3294 return -EINVAL; 3295 } 3296 3297 /* 3298 * if not the first track got the NRF error we have to skip over valid 3299 * blocks 3300 */ 3301 if (curr_trk != first_trk) 3302 skip_block = curr_trk * recs_per_trk - first_blk; 3303 3304 /* we have no information beyond the current track */ 3305 end_blk = (curr_trk + 1) * recs_per_trk; 3306 3307 rq_for_each_segment(bv, req, iter) { 3308 dst = bvec_virt(&bv); 3309 for (off = 0; off < bv.bv_len; off += blksize) { 3310 if (first_blk + blk_count >= end_blk) { 3311 cqr->proc_bytes = blk_count * blksize; 3312 return 0; 3313 } 3314 if (dst && !skip_block) 3315 memset(dst, 0, blksize); 3316 else 3317 skip_block--; 3318 dst += blksize; 3319 blk_count++; 3320 } 3321 } 3322 return 0; 3323} 3324 3325/* 3326 * Helper function to count consecutive records of a single track. 3327 */ 3328static int dasd_eckd_count_records(struct eckd_count *fmt_buffer, int start, 3329 int max) 3330{ 3331 int head; 3332 int i; 3333 3334 head = fmt_buffer[start].head; 3335 3336 /* 3337 * There are 3 conditions where we stop counting: 3338 * - if data reoccurs (same head and record may reoccur), which may 3339 * happen due to the way DASD_ECKD_CCW_READ_COUNT works 3340 * - when the head changes, because we're iterating over several tracks 3341 * then (DASD_ECKD_CCW_READ_COUNT_MT) 3342 * - when we've reached the end of sensible data in the buffer (the 3343 * record will be 0 then) 3344 */ 3345 for (i = start; i < max; i++) { 3346 if (i > start) { 3347 if ((fmt_buffer[i].head == head && 3348 fmt_buffer[i].record == 1) || 3349 fmt_buffer[i].head != head || 3350 fmt_buffer[i].record == 0) 3351 break; 3352 } 3353 } 3354 3355 return i - start; 3356} 3357 3358/* 3359 * Evaluate a given range of tracks. Data like number of records, blocksize, 3360 * record ids, and key length are compared with expected data. 3361 * 3362 * If a mismatch occurs, the corresponding error bit is set, as well as 3363 * additional information, depending on the error. 3364 */ 3365static void dasd_eckd_format_evaluate_tracks(struct eckd_count *fmt_buffer, 3366 struct format_check_t *cdata, 3367 int rpt_max, int rpt_exp, 3368 int trk_per_cyl, int tpm) 3369{ 3370 struct ch_t geo; 3371 int max_entries; 3372 int count = 0; 3373 int trkcount; 3374 int blksize; 3375 int pos = 0; 3376 int i, j; 3377 int kl; 3378 3379 trkcount = cdata->expect.stop_unit - cdata->expect.start_unit + 1; 3380 max_entries = trkcount * rpt_max; 3381 3382 for (i = cdata->expect.start_unit; i <= cdata->expect.stop_unit; i++) { 3383 /* Calculate the correct next starting position in the buffer */ 3384 if (tpm) { 3385 while (fmt_buffer[pos].record == 0 && 3386 fmt_buffer[pos].dl == 0) { 3387 if (pos++ > max_entries) 3388 break; 3389 } 3390 } else { 3391 if (i != cdata->expect.start_unit) 3392 pos += rpt_max - count; 3393 } 3394 3395 /* Calculate the expected geo values for the current track */ 3396 set_ch_t(&geo, i / trk_per_cyl, i % trk_per_cyl); 3397 3398 /* Count and check number of records */ 3399 count = dasd_eckd_count_records(fmt_buffer, pos, pos + rpt_max); 3400 3401 if (count < rpt_exp) { 3402 cdata->result = DASD_FMT_ERR_TOO_FEW_RECORDS; 3403 break; 3404 } 3405 if (count > rpt_exp) { 3406 cdata->result = DASD_FMT_ERR_TOO_MANY_RECORDS; 3407 break; 3408 } 3409 3410 for (j = 0; j < count; j++, pos++) { 3411 blksize = cdata->expect.blksize; 3412 kl = 0; 3413 3414 /* 3415 * Set special values when checking CDL formatted 3416 * devices. 3417 */ 3418 if ((cdata->expect.intensity & 0x08) && 3419 geo.cyl == 0 && geo.head == 0) { 3420 if (j < 3) { 3421 blksize = sizes_trk0[j] - 4; 3422 kl = 4; 3423 } 3424 } 3425 if ((cdata->expect.intensity & 0x08) && 3426 geo.cyl == 0 && geo.head == 1) { 3427 blksize = LABEL_SIZE - 44; 3428 kl = 44; 3429 } 3430 3431 /* Check blocksize */ 3432 if (fmt_buffer[pos].dl != blksize) { 3433 cdata->result = DASD_FMT_ERR_BLKSIZE; 3434 goto out; 3435 } 3436 /* Check if key length is 0 */ 3437 if (fmt_buffer[pos].kl != kl) { 3438 cdata->result = DASD_FMT_ERR_KEY_LENGTH; 3439 goto out; 3440 } 3441 /* Check if record_id is correct */ 3442 if (fmt_buffer[pos].cyl != geo.cyl || 3443 fmt_buffer[pos].head != geo.head || 3444 fmt_buffer[pos].record != (j + 1)) { 3445 cdata->result = DASD_FMT_ERR_RECORD_ID; 3446 goto out; 3447 } 3448 } 3449 } 3450 3451out: 3452 /* 3453 * In case of no errors, we need to decrease by one 3454 * to get the correct positions. 3455 */ 3456 if (!cdata->result) { 3457 i--; 3458 pos--; 3459 } 3460 3461 cdata->unit = i; 3462 cdata->num_records = count; 3463 cdata->rec = fmt_buffer[pos].record; 3464 cdata->blksize = fmt_buffer[pos].dl; 3465 cdata->key_length = fmt_buffer[pos].kl; 3466} 3467 3468/* 3469 * Check the format of a range of tracks of a DASD. 3470 */ 3471static int dasd_eckd_check_device_format(struct dasd_device *base, 3472 struct format_check_t *cdata, 3473 int enable_pav) 3474{ 3475 struct dasd_eckd_private *private = base->private; 3476 struct eckd_count *fmt_buffer; 3477 struct irb irb; 3478 int rpt_max, rpt_exp; 3479 int fmt_buffer_size; 3480 int trk_per_cyl; 3481 int trkcount; 3482 int tpm = 0; 3483 int rc; 3484 3485 trk_per_cyl = private->rdc_data.trk_per_cyl; 3486 3487 /* Get maximum and expected amount of records per track */ 3488 rpt_max = recs_per_track(&private->rdc_data, 0, 512) + 1; 3489 rpt_exp = recs_per_track(&private->rdc_data, 0, cdata->expect.blksize); 3490 3491 trkcount = cdata->expect.stop_unit - cdata->expect.start_unit + 1; 3492 fmt_buffer_size = trkcount * rpt_max * sizeof(struct eckd_count); 3493 3494 fmt_buffer = kzalloc(fmt_buffer_size, GFP_KERNEL | GFP_DMA); 3495 if (!fmt_buffer) 3496 return -ENOMEM; 3497 3498 /* 3499 * A certain FICON feature subset is needed to operate in transport 3500 * mode. Additionally, the support for transport mode is implicitly 3501 * checked by comparing the buffer size with fcx_max_data. As long as 3502 * the buffer size is smaller we can operate in transport mode and 3503 * process multiple tracks. If not, only one track at once is being 3504 * processed using command mode. 3505 */ 3506 if ((private->features.feature[40] & 0x04) && 3507 fmt_buffer_size <= private->fcx_max_data) 3508 tpm = 1; 3509 3510 rc = dasd_eckd_format_process_data(base, &cdata->expect, enable_pav, 3511 tpm, fmt_buffer, rpt_max, &irb); 3512 if (rc && rc != -EIO) 3513 goto out; 3514 if (rc == -EIO) { 3515 /* 3516 * If our first attempt with transport mode enabled comes back 3517 * with an incorrect length error, we're going to retry the 3518 * check with command mode. 3519 */ 3520 if (tpm && scsw_cstat(&irb.scsw) == 0x40) { 3521 tpm = 0; 3522 rc = dasd_eckd_format_process_data(base, &cdata->expect, 3523 enable_pav, tpm, 3524 fmt_buffer, rpt_max, 3525 &irb); 3526 if (rc) 3527 goto out; 3528 } else { 3529 goto out; 3530 } 3531 } 3532 3533 dasd_eckd_format_evaluate_tracks(fmt_buffer, cdata, rpt_max, rpt_exp, 3534 trk_per_cyl, tpm); 3535 3536out: 3537 kfree(fmt_buffer); 3538 3539 return rc; 3540} 3541 3542static void dasd_eckd_handle_terminated_request(struct dasd_ccw_req *cqr) 3543{ 3544 if (cqr->retries < 0) { 3545 cqr->status = DASD_CQR_FAILED; 3546 return; 3547 } 3548 cqr->status = DASD_CQR_FILLED; 3549 if (cqr->block && (cqr->startdev != cqr->block->base)) { 3550 dasd_eckd_reset_ccw_to_base_io(cqr); 3551 cqr->startdev = cqr->block->base; 3552 cqr->lpm = dasd_path_get_opm(cqr->block->base); 3553 } 3554}; 3555 3556static dasd_erp_fn_t 3557dasd_eckd_erp_action(struct dasd_ccw_req * cqr) 3558{ 3559 struct dasd_device *device = (struct dasd_device *) cqr->startdev; 3560 struct ccw_device *cdev = device->cdev; 3561 3562 switch (cdev->id.cu_type) { 3563 case 0x3990: 3564 case 0x2105: 3565 case 0x2107: 3566 case 0x1750: 3567 return dasd_3990_erp_action; 3568 case 0x9343: 3569 case 0x3880: 3570 default: 3571 return dasd_default_erp_action; 3572 } 3573} 3574 3575static dasd_erp_fn_t 3576dasd_eckd_erp_postaction(struct dasd_ccw_req * cqr) 3577{ 3578 return dasd_default_erp_postaction; 3579} 3580 3581static void dasd_eckd_check_for_device_change(struct dasd_device *device, 3582 struct dasd_ccw_req *cqr, 3583 struct irb *irb) 3584{ 3585 char mask; 3586 char *sense = NULL; 3587 struct dasd_eckd_private *private = device->private; 3588 3589 /* first of all check for state change pending interrupt */ 3590 mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP; 3591 if ((scsw_dstat(&irb->scsw) & mask) == mask) { 3592 /* 3593 * for alias only, not in offline processing 3594 * and only if not suspended 3595 */ 3596 if (!device->block && private->lcu && 3597 device->state == DASD_STATE_ONLINE && 3598 !test_bit(DASD_FLAG_OFFLINE, &device->flags) && 3599 !test_bit(DASD_FLAG_SUSPENDED, &device->flags)) { 3600 /* schedule worker to reload device */ 3601 dasd_reload_device(device); 3602 } 3603 dasd_generic_handle_state_change(device); 3604 return; 3605 } 3606 3607 sense = dasd_get_sense(irb); 3608 if (!sense) 3609 return; 3610 3611 /* summary unit check */ 3612 if ((sense[27] & DASD_SENSE_BIT_0) && (sense[7] == 0x0D) && 3613 (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK)) { 3614 if (test_and_set_bit(DASD_FLAG_SUC, &device->flags)) { 3615 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 3616 "eckd suc: device already notified"); 3617 return; 3618 } 3619 sense = dasd_get_sense(irb); 3620 if (!sense) { 3621 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 3622 "eckd suc: no reason code available"); 3623 clear_bit(DASD_FLAG_SUC, &device->flags); 3624 return; 3625 3626 } 3627 private->suc_reason = sense[8]; 3628 DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x", 3629 "eckd handle summary unit check: reason", 3630 private->suc_reason); 3631 dasd_get_device(device); 3632 if (!schedule_work(&device->suc_work)) 3633 dasd_put_device(device); 3634 3635 return; 3636 } 3637 3638 /* service information message SIM */ 3639 if (!cqr && !(sense[27] & DASD_SENSE_BIT_0) && 3640 ((sense[6] & DASD_SIM_SENSE) == DASD_SIM_SENSE)) { 3641 dasd_3990_erp_handle_sim(device, sense); 3642 return; 3643 } 3644 3645 /* loss of device reservation is handled via base devices only 3646 * as alias devices may be used with several bases 3647 */ 3648 if (device->block && (sense[27] & DASD_SENSE_BIT_0) && 3649 (sense[7] == 0x3F) && 3650 (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK) && 3651 test_bit(DASD_FLAG_IS_RESERVED, &device->flags)) { 3652 if (device->features & DASD_FEATURE_FAILONSLCK) 3653 set_bit(DASD_FLAG_LOCK_STOLEN, &device->flags); 3654 clear_bit(DASD_FLAG_IS_RESERVED, &device->flags); 3655 dev_err(&device->cdev->dev, 3656 "The device reservation was lost\n"); 3657 } 3658} 3659 3660static int dasd_eckd_ras_sanity_checks(struct dasd_device *device, 3661 unsigned int first_trk, 3662 unsigned int last_trk) 3663{ 3664 struct dasd_eckd_private *private = device->private; 3665 unsigned int trks_per_vol; 3666 int rc = 0; 3667 3668 trks_per_vol = private->real_cyl * private->rdc_data.trk_per_cyl; 3669 3670 if (first_trk >= trks_per_vol) { 3671 dev_warn(&device->cdev->dev, 3672 "Start track number %u used in the space release command is too big\n", 3673 first_trk); 3674 rc = -EINVAL; 3675 } else if (last_trk >= trks_per_vol) { 3676 dev_warn(&device->cdev->dev, 3677 "Stop track number %u used in the space release command is too big\n", 3678 last_trk); 3679 rc = -EINVAL; 3680 } else if (first_trk > last_trk) { 3681 dev_warn(&device->cdev->dev, 3682 "Start track %u used in the space release command exceeds the end track\n", 3683 first_trk); 3684 rc = -EINVAL; 3685 } 3686 return rc; 3687} 3688 3689/* 3690 * Helper function to count the amount of involved extents within a given range 3691 * with extent alignment in mind. 3692 */ 3693static int count_exts(unsigned int from, unsigned int to, int trks_per_ext) 3694{ 3695 int cur_pos = 0; 3696 int count = 0; 3697 int tmp; 3698 3699 if (from == to) 3700 return 1; 3701 3702 /* Count first partial extent */ 3703 if (from % trks_per_ext != 0) { 3704 tmp = from + trks_per_ext - (from % trks_per_ext) - 1; 3705 if (tmp > to) 3706 tmp = to; 3707 cur_pos = tmp - from + 1; 3708 count++; 3709 } 3710 /* Count full extents */ 3711 if (to - (from + cur_pos) + 1 >= trks_per_ext) { 3712 tmp = to - ((to - trks_per_ext + 1) % trks_per_ext); 3713 count += (tmp - (from + cur_pos) + 1) / trks_per_ext; 3714 cur_pos = tmp; 3715 } 3716 /* Count last partial extent */ 3717 if (cur_pos < to) 3718 count++; 3719 3720 return count; 3721} 3722 3723static int dasd_in_copy_relation(struct dasd_device *device) 3724{ 3725 struct dasd_pprc_data_sc4 *temp; 3726 int rc; 3727 3728 if (!dasd_eckd_pprc_enabled(device)) 3729 return 0; 3730 3731 temp = kzalloc(sizeof(*temp), GFP_KERNEL); 3732 if (!temp) 3733 return -ENOMEM; 3734 3735 rc = dasd_eckd_query_pprc_status(device, temp); 3736 if (!rc) 3737 rc = temp->dev_info[0].state; 3738 3739 kfree(temp); 3740 return rc; 3741} 3742 3743/* 3744 * Release allocated space for a given range or an entire volume. 3745 */ 3746static struct dasd_ccw_req * 3747dasd_eckd_dso_ras(struct dasd_device *device, struct dasd_block *block, 3748 struct request *req, unsigned int first_trk, 3749 unsigned int last_trk, int by_extent) 3750{ 3751 struct dasd_eckd_private *private = device->private; 3752 struct dasd_dso_ras_ext_range *ras_range; 3753 struct dasd_rssd_features *features; 3754 struct dasd_dso_ras_data *ras_data; 3755 u16 heads, beg_head, end_head; 3756 int cur_to_trk, cur_from_trk; 3757 struct dasd_ccw_req *cqr; 3758 u32 beg_cyl, end_cyl; 3759 int copy_relation; 3760 struct ccw1 *ccw; 3761 int trks_per_ext; 3762 size_t ras_size; 3763 size_t size; 3764 int nr_exts; 3765 void *rq; 3766 int i; 3767 3768 if (dasd_eckd_ras_sanity_checks(device, first_trk, last_trk)) 3769 return ERR_PTR(-EINVAL); 3770 3771 copy_relation = dasd_in_copy_relation(device); 3772 if (copy_relation < 0) 3773 return ERR_PTR(copy_relation); 3774 3775 rq = req ? blk_mq_rq_to_pdu(req) : NULL; 3776 3777 features = &private->features; 3778 3779 trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl; 3780 nr_exts = 0; 3781 if (by_extent) 3782 nr_exts = count_exts(first_trk, last_trk, trks_per_ext); 3783 ras_size = sizeof(*ras_data); 3784 size = ras_size + (nr_exts * sizeof(*ras_range)); 3785 3786 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, size, device, rq); 3787 if (IS_ERR(cqr)) { 3788 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 3789 "Could not allocate RAS request"); 3790 return cqr; 3791 } 3792 3793 ras_data = cqr->data; 3794 memset(ras_data, 0, size); 3795 3796 ras_data->order = DSO_ORDER_RAS; 3797 ras_data->flags.vol_type = 0; /* CKD volume */ 3798 /* Release specified extents or entire volume */ 3799 ras_data->op_flags.by_extent = by_extent; 3800 /* 3801 * This bit guarantees initialisation of tracks within an extent that is 3802 * not fully specified, but is only supported with a certain feature 3803 * subset and for devices not in a copy relation. 3804 */ 3805 if (features->feature[56] & 0x01 && !copy_relation) 3806 ras_data->op_flags.guarantee_init = 1; 3807 3808 ras_data->lss = private->conf.ned->ID; 3809 ras_data->dev_addr = private->conf.ned->unit_addr; 3810 ras_data->nr_exts = nr_exts; 3811 3812 if (by_extent) { 3813 heads = private->rdc_data.trk_per_cyl; 3814 cur_from_trk = first_trk; 3815 cur_to_trk = first_trk + trks_per_ext - 3816 (first_trk % trks_per_ext) - 1; 3817 if (cur_to_trk > last_trk) 3818 cur_to_trk = last_trk; 3819 ras_range = (struct dasd_dso_ras_ext_range *)(cqr->data + ras_size); 3820 3821 for (i = 0; i < nr_exts; i++) { 3822 beg_cyl = cur_from_trk / heads; 3823 beg_head = cur_from_trk % heads; 3824 end_cyl = cur_to_trk / heads; 3825 end_head = cur_to_trk % heads; 3826 3827 set_ch_t(&ras_range->beg_ext, beg_cyl, beg_head); 3828 set_ch_t(&ras_range->end_ext, end_cyl, end_head); 3829 3830 cur_from_trk = cur_to_trk + 1; 3831 cur_to_trk = cur_from_trk + trks_per_ext - 1; 3832 if (cur_to_trk > last_trk) 3833 cur_to_trk = last_trk; 3834 ras_range++; 3835 } 3836 } 3837 3838 ccw = cqr->cpaddr; 3839 ccw->cda = virt_to_dma32(cqr->data); 3840 ccw->cmd_code = DASD_ECKD_CCW_DSO; 3841 ccw->count = size; 3842 3843 cqr->startdev = device; 3844 cqr->memdev = device; 3845 cqr->block = block; 3846 cqr->retries = 256; 3847 cqr->expires = device->default_expires * HZ; 3848 cqr->buildclk = get_tod_clock(); 3849 cqr->status = DASD_CQR_FILLED; 3850 3851 return cqr; 3852} 3853 3854static int dasd_eckd_release_space_full(struct dasd_device *device) 3855{ 3856 struct dasd_ccw_req *cqr; 3857 int rc; 3858 3859 cqr = dasd_eckd_dso_ras(device, NULL, NULL, 0, 0, 0); 3860 if (IS_ERR(cqr)) 3861 return PTR_ERR(cqr); 3862 3863 rc = dasd_sleep_on_interruptible(cqr); 3864 3865 dasd_sfree_request(cqr, cqr->memdev); 3866 3867 return rc; 3868} 3869 3870static int dasd_eckd_release_space_trks(struct dasd_device *device, 3871 unsigned int from, unsigned int to) 3872{ 3873 struct dasd_eckd_private *private = device->private; 3874 struct dasd_block *block = device->block; 3875 struct dasd_ccw_req *cqr, *n; 3876 struct list_head ras_queue; 3877 unsigned int device_exts; 3878 int trks_per_ext; 3879 int stop, step; 3880 int cur_pos; 3881 int rc = 0; 3882 int retry; 3883 3884 INIT_LIST_HEAD(&ras_queue); 3885 3886 device_exts = private->real_cyl / dasd_eckd_ext_size(device); 3887 trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl; 3888 3889 /* Make sure device limits are not exceeded */ 3890 step = trks_per_ext * min(device_exts, DASD_ECKD_RAS_EXTS_MAX); 3891 cur_pos = from; 3892 3893 do { 3894 retry = 0; 3895 while (cur_pos < to) { 3896 stop = cur_pos + step - 3897 ((cur_pos + step) % trks_per_ext) - 1; 3898 if (stop > to) 3899 stop = to; 3900 3901 cqr = dasd_eckd_dso_ras(device, NULL, NULL, cur_pos, stop, 1); 3902 if (IS_ERR(cqr)) { 3903 rc = PTR_ERR(cqr); 3904 if (rc == -ENOMEM) { 3905 if (list_empty(&ras_queue)) 3906 goto out; 3907 retry = 1; 3908 break; 3909 } 3910 goto err_out; 3911 } 3912 3913 spin_lock_irq(&block->queue_lock); 3914 list_add_tail(&cqr->blocklist, &ras_queue); 3915 spin_unlock_irq(&block->queue_lock); 3916 cur_pos = stop + 1; 3917 } 3918 3919 rc = dasd_sleep_on_queue_interruptible(&ras_queue); 3920 3921err_out: 3922 list_for_each_entry_safe(cqr, n, &ras_queue, blocklist) { 3923 device = cqr->startdev; 3924 private = device->private; 3925 3926 spin_lock_irq(&block->queue_lock); 3927 list_del_init(&cqr->blocklist); 3928 spin_unlock_irq(&block->queue_lock); 3929 dasd_sfree_request(cqr, device); 3930 private->count--; 3931 } 3932 } while (retry); 3933 3934out: 3935 return rc; 3936} 3937 3938static int dasd_eckd_release_space(struct dasd_device *device, 3939 struct format_data_t *rdata) 3940{ 3941 if (rdata->intensity & DASD_FMT_INT_ESE_FULL) 3942 return dasd_eckd_release_space_full(device); 3943 else if (rdata->intensity == 0) 3944 return dasd_eckd_release_space_trks(device, rdata->start_unit, 3945 rdata->stop_unit); 3946 else 3947 return -EINVAL; 3948} 3949 3950static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_single( 3951 struct dasd_device *startdev, 3952 struct dasd_block *block, 3953 struct request *req, 3954 sector_t first_rec, 3955 sector_t last_rec, 3956 sector_t first_trk, 3957 sector_t last_trk, 3958 unsigned int first_offs, 3959 unsigned int last_offs, 3960 unsigned int blk_per_trk, 3961 unsigned int blksize) 3962{ 3963 struct dasd_eckd_private *private; 3964 dma64_t *idaws; 3965 struct LO_eckd_data *LO_data; 3966 struct dasd_ccw_req *cqr; 3967 struct ccw1 *ccw; 3968 struct req_iterator iter; 3969 struct bio_vec bv; 3970 char *dst; 3971 unsigned int off; 3972 int count, cidaw, cplength, datasize; 3973 sector_t recid; 3974 unsigned char cmd, rcmd; 3975 int use_prefix; 3976 struct dasd_device *basedev; 3977 3978 basedev = block->base; 3979 private = basedev->private; 3980 if (rq_data_dir(req) == READ) 3981 cmd = DASD_ECKD_CCW_READ_MT; 3982 else if (rq_data_dir(req) == WRITE) 3983 cmd = DASD_ECKD_CCW_WRITE_MT; 3984 else 3985 return ERR_PTR(-EINVAL); 3986 3987 /* Check struct bio and count the number of blocks for the request. */ 3988 count = 0; 3989 cidaw = 0; 3990 rq_for_each_segment(bv, req, iter) { 3991 if (bv.bv_len & (blksize - 1)) 3992 /* Eckd can only do full blocks. */ 3993 return ERR_PTR(-EINVAL); 3994 count += bv.bv_len >> (block->s2b_shift + 9); 3995 if (idal_is_needed (page_address(bv.bv_page), bv.bv_len)) 3996 cidaw += bv.bv_len >> (block->s2b_shift + 9); 3997 } 3998 /* Paranoia. */ 3999 if (count != last_rec - first_rec + 1) 4000 return ERR_PTR(-EINVAL); 4001 4002 /* use the prefix command if available */ 4003 use_prefix = private->features.feature[8] & 0x01; 4004 if (use_prefix) { 4005 /* 1x prefix + number of blocks */ 4006 cplength = 2 + count; 4007 /* 1x prefix + cidaws*sizeof(long) */ 4008 datasize = sizeof(struct PFX_eckd_data) + 4009 sizeof(struct LO_eckd_data) + 4010 cidaw * sizeof(unsigned long); 4011 } else { 4012 /* 1x define extent + 1x locate record + number of blocks */ 4013 cplength = 2 + count; 4014 /* 1x define extent + 1x locate record + cidaws*sizeof(long) */ 4015 datasize = sizeof(struct DE_eckd_data) + 4016 sizeof(struct LO_eckd_data) + 4017 cidaw * sizeof(unsigned long); 4018 } 4019 /* Find out the number of additional locate record ccws for cdl. */ 4020 if (private->uses_cdl && first_rec < 2*blk_per_trk) { 4021 if (last_rec >= 2*blk_per_trk) 4022 count = 2*blk_per_trk - first_rec; 4023 cplength += count; 4024 datasize += count*sizeof(struct LO_eckd_data); 4025 } 4026 /* Allocate the ccw request. */ 4027 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, 4028 startdev, blk_mq_rq_to_pdu(req)); 4029 if (IS_ERR(cqr)) 4030 return cqr; 4031 ccw = cqr->cpaddr; 4032 /* First ccw is define extent or prefix. */ 4033 if (use_prefix) { 4034 if (prefix(ccw++, cqr->data, first_trk, 4035 last_trk, cmd, basedev, startdev) == -EAGAIN) { 4036 /* Clock not in sync and XRC is enabled. 4037 * Try again later. 4038 */ 4039 dasd_sfree_request(cqr, startdev); 4040 return ERR_PTR(-EAGAIN); 4041 } 4042 idaws = (dma64_t *)(cqr->data + sizeof(struct PFX_eckd_data)); 4043 } else { 4044 if (define_extent(ccw++, cqr->data, first_trk, 4045 last_trk, cmd, basedev, 0) == -EAGAIN) { 4046 /* Clock not in sync and XRC is enabled. 4047 * Try again later. 4048 */ 4049 dasd_sfree_request(cqr, startdev); 4050 return ERR_PTR(-EAGAIN); 4051 } 4052 idaws = (dma64_t *)(cqr->data + sizeof(struct DE_eckd_data)); 4053 } 4054 /* Build locate_record+read/write/ccws. */ 4055 LO_data = (struct LO_eckd_data *) (idaws + cidaw); 4056 recid = first_rec; 4057 if (private->uses_cdl == 0 || recid > 2*blk_per_trk) { 4058 /* Only standard blocks so there is just one locate record. */ 4059 ccw[-1].flags |= CCW_FLAG_CC; 4060 locate_record(ccw++, LO_data++, first_trk, first_offs + 1, 4061 last_rec - recid + 1, cmd, basedev, blksize); 4062 } 4063 rq_for_each_segment(bv, req, iter) { 4064 dst = bvec_virt(&bv); 4065 if (dasd_page_cache) { 4066 char *copy = kmem_cache_alloc(dasd_page_cache, 4067 GFP_DMA | __GFP_NOWARN); 4068 if (copy && rq_data_dir(req) == WRITE) 4069 memcpy(copy + bv.bv_offset, dst, bv.bv_len); 4070 if (copy) 4071 dst = copy + bv.bv_offset; 4072 } 4073 for (off = 0; off < bv.bv_len; off += blksize) { 4074 sector_t trkid = recid; 4075 unsigned int recoffs = sector_div(trkid, blk_per_trk); 4076 rcmd = cmd; 4077 count = blksize; 4078 /* Locate record for cdl special block ? */ 4079 if (private->uses_cdl && recid < 2*blk_per_trk) { 4080 if (dasd_eckd_cdl_special(blk_per_trk, recid)){ 4081 rcmd |= 0x8; 4082 count = dasd_eckd_cdl_reclen(recid); 4083 if (count < blksize && 4084 rq_data_dir(req) == READ) 4085 memset(dst + count, 0xe5, 4086 blksize - count); 4087 } 4088 ccw[-1].flags |= CCW_FLAG_CC; 4089 locate_record(ccw++, LO_data++, 4090 trkid, recoffs + 1, 4091 1, rcmd, basedev, count); 4092 } 4093 /* Locate record for standard blocks ? */ 4094 if (private->uses_cdl && recid == 2*blk_per_trk) { 4095 ccw[-1].flags |= CCW_FLAG_CC; 4096 locate_record(ccw++, LO_data++, 4097 trkid, recoffs + 1, 4098 last_rec - recid + 1, 4099 cmd, basedev, count); 4100 } 4101 /* Read/write ccw. */ 4102 ccw[-1].flags |= CCW_FLAG_CC; 4103 ccw->cmd_code = rcmd; 4104 ccw->count = count; 4105 if (idal_is_needed(dst, blksize)) { 4106 ccw->cda = virt_to_dma32(idaws); 4107 ccw->flags = CCW_FLAG_IDA; 4108 idaws = idal_create_words(idaws, dst, blksize); 4109 } else { 4110 ccw->cda = virt_to_dma32(dst); 4111 ccw->flags = 0; 4112 } 4113 ccw++; 4114 dst += blksize; 4115 recid++; 4116 } 4117 } 4118 if (blk_noretry_request(req) || 4119 block->base->features & DASD_FEATURE_FAILFAST) 4120 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 4121 cqr->startdev = startdev; 4122 cqr->memdev = startdev; 4123 cqr->block = block; 4124 cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */ 4125 cqr->lpm = dasd_path_get_ppm(startdev); 4126 cqr->retries = startdev->default_retries; 4127 cqr->buildclk = get_tod_clock(); 4128 cqr->status = DASD_CQR_FILLED; 4129 4130 /* Set flags to suppress output for expected errors */ 4131 if (dasd_eckd_is_ese(basedev)) { 4132 set_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags); 4133 set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags); 4134 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags); 4135 } 4136 4137 return cqr; 4138} 4139 4140static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_track( 4141 struct dasd_device *startdev, 4142 struct dasd_block *block, 4143 struct request *req, 4144 sector_t first_rec, 4145 sector_t last_rec, 4146 sector_t first_trk, 4147 sector_t last_trk, 4148 unsigned int first_offs, 4149 unsigned int last_offs, 4150 unsigned int blk_per_trk, 4151 unsigned int blksize) 4152{ 4153 dma64_t *idaws; 4154 struct dasd_ccw_req *cqr; 4155 struct ccw1 *ccw; 4156 struct req_iterator iter; 4157 struct bio_vec bv; 4158 char *dst, *idaw_dst; 4159 unsigned int cidaw, cplength, datasize; 4160 unsigned int tlf; 4161 sector_t recid; 4162 unsigned char cmd; 4163 struct dasd_device *basedev; 4164 unsigned int trkcount, count, count_to_trk_end; 4165 unsigned int idaw_len, seg_len, part_len, len_to_track_end; 4166 unsigned char new_track, end_idaw; 4167 sector_t trkid; 4168 unsigned int recoffs; 4169 4170 basedev = block->base; 4171 if (rq_data_dir(req) == READ) 4172 cmd = DASD_ECKD_CCW_READ_TRACK_DATA; 4173 else if (rq_data_dir(req) == WRITE) 4174 cmd = DASD_ECKD_CCW_WRITE_TRACK_DATA; 4175 else 4176 return ERR_PTR(-EINVAL); 4177 4178 /* Track based I/O needs IDAWs for each page, and not just for 4179 * 64 bit addresses. We need additional idals for pages 4180 * that get filled from two tracks, so we use the number 4181 * of records as upper limit. 4182 */ 4183 cidaw = last_rec - first_rec + 1; 4184 trkcount = last_trk - first_trk + 1; 4185 4186 /* 1x prefix + one read/write ccw per track */ 4187 cplength = 1 + trkcount; 4188 4189 datasize = sizeof(struct PFX_eckd_data) + cidaw * sizeof(unsigned long); 4190 4191 /* Allocate the ccw request. */ 4192 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, 4193 startdev, blk_mq_rq_to_pdu(req)); 4194 if (IS_ERR(cqr)) 4195 return cqr; 4196 ccw = cqr->cpaddr; 4197 /* transfer length factor: how many bytes to read from the last track */ 4198 if (first_trk == last_trk) 4199 tlf = last_offs - first_offs + 1; 4200 else 4201 tlf = last_offs + 1; 4202 tlf *= blksize; 4203 4204 if (prefix_LRE(ccw++, cqr->data, first_trk, 4205 last_trk, cmd, basedev, startdev, 4206 1 /* format */, first_offs + 1, 4207 trkcount, blksize, 4208 tlf) == -EAGAIN) { 4209 /* Clock not in sync and XRC is enabled. 4210 * Try again later. 4211 */ 4212 dasd_sfree_request(cqr, startdev); 4213 return ERR_PTR(-EAGAIN); 4214 } 4215 4216 /* 4217 * The translation of request into ccw programs must meet the 4218 * following conditions: 4219 * - all idaws but the first and the last must address full pages 4220 * (or 2K blocks on 31-bit) 4221 * - the scope of a ccw and it's idal ends with the track boundaries 4222 */ 4223 idaws = (dma64_t *)(cqr->data + sizeof(struct PFX_eckd_data)); 4224 recid = first_rec; 4225 new_track = 1; 4226 end_idaw = 0; 4227 len_to_track_end = 0; 4228 idaw_dst = NULL; 4229 idaw_len = 0; 4230 rq_for_each_segment(bv, req, iter) { 4231 dst = bvec_virt(&bv); 4232 seg_len = bv.bv_len; 4233 while (seg_len) { 4234 if (new_track) { 4235 trkid = recid; 4236 recoffs = sector_div(trkid, blk_per_trk); 4237 count_to_trk_end = blk_per_trk - recoffs; 4238 count = min((last_rec - recid + 1), 4239 (sector_t)count_to_trk_end); 4240 len_to_track_end = count * blksize; 4241 ccw[-1].flags |= CCW_FLAG_CC; 4242 ccw->cmd_code = cmd; 4243 ccw->count = len_to_track_end; 4244 ccw->cda = virt_to_dma32(idaws); 4245 ccw->flags = CCW_FLAG_IDA; 4246 ccw++; 4247 recid += count; 4248 new_track = 0; 4249 /* first idaw for a ccw may start anywhere */ 4250 if (!idaw_dst) 4251 idaw_dst = dst; 4252 } 4253 /* If we start a new idaw, we must make sure that it 4254 * starts on an IDA_BLOCK_SIZE boundary. 4255 * If we continue an idaw, we must make sure that the 4256 * current segment begins where the so far accumulated 4257 * idaw ends 4258 */ 4259 if (!idaw_dst) { 4260 if ((unsigned long)(dst) & (IDA_BLOCK_SIZE - 1)) { 4261 dasd_sfree_request(cqr, startdev); 4262 return ERR_PTR(-ERANGE); 4263 } else 4264 idaw_dst = dst; 4265 } 4266 if ((idaw_dst + idaw_len) != dst) { 4267 dasd_sfree_request(cqr, startdev); 4268 return ERR_PTR(-ERANGE); 4269 } 4270 part_len = min(seg_len, len_to_track_end); 4271 seg_len -= part_len; 4272 dst += part_len; 4273 idaw_len += part_len; 4274 len_to_track_end -= part_len; 4275 /* collected memory area ends on an IDA_BLOCK border, 4276 * -> create an idaw 4277 * idal_create_words will handle cases where idaw_len 4278 * is larger then IDA_BLOCK_SIZE 4279 */ 4280 if (!((unsigned long)(idaw_dst + idaw_len) & (IDA_BLOCK_SIZE - 1))) 4281 end_idaw = 1; 4282 /* We also need to end the idaw at track end */ 4283 if (!len_to_track_end) { 4284 new_track = 1; 4285 end_idaw = 1; 4286 } 4287 if (end_idaw) { 4288 idaws = idal_create_words(idaws, idaw_dst, 4289 idaw_len); 4290 idaw_dst = NULL; 4291 idaw_len = 0; 4292 end_idaw = 0; 4293 } 4294 } 4295 } 4296 4297 if (blk_noretry_request(req) || 4298 block->base->features & DASD_FEATURE_FAILFAST) 4299 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 4300 cqr->startdev = startdev; 4301 cqr->memdev = startdev; 4302 cqr->block = block; 4303 cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */ 4304 cqr->lpm = dasd_path_get_ppm(startdev); 4305 cqr->retries = startdev->default_retries; 4306 cqr->buildclk = get_tod_clock(); 4307 cqr->status = DASD_CQR_FILLED; 4308 4309 /* Set flags to suppress output for expected errors */ 4310 if (dasd_eckd_is_ese(basedev)) 4311 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags); 4312 4313 return cqr; 4314} 4315 4316static int prepare_itcw(struct itcw *itcw, 4317 unsigned int trk, unsigned int totrk, int cmd, 4318 struct dasd_device *basedev, 4319 struct dasd_device *startdev, 4320 unsigned int rec_on_trk, int count, 4321 unsigned int blksize, 4322 unsigned int total_data_size, 4323 unsigned int tlf, 4324 unsigned int blk_per_trk) 4325{ 4326 struct PFX_eckd_data pfxdata; 4327 struct dasd_eckd_private *basepriv, *startpriv; 4328 struct DE_eckd_data *dedata; 4329 struct LRE_eckd_data *lredata; 4330 struct dcw *dcw; 4331 4332 u32 begcyl, endcyl; 4333 u16 heads, beghead, endhead; 4334 u8 pfx_cmd; 4335 4336 int rc = 0; 4337 int sector = 0; 4338 int dn, d; 4339 4340 4341 /* setup prefix data */ 4342 basepriv = basedev->private; 4343 startpriv = startdev->private; 4344 dedata = &pfxdata.define_extent; 4345 lredata = &pfxdata.locate_record; 4346 4347 memset(&pfxdata, 0, sizeof(pfxdata)); 4348 pfxdata.format = 1; /* PFX with LRE */ 4349 pfxdata.base_address = basepriv->conf.ned->unit_addr; 4350 pfxdata.base_lss = basepriv->conf.ned->ID; 4351 pfxdata.validity.define_extent = 1; 4352 4353 /* private uid is kept up to date, conf_data may be outdated */ 4354 if (startpriv->uid.type == UA_BASE_PAV_ALIAS) 4355 pfxdata.validity.verify_base = 1; 4356 4357 if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) { 4358 pfxdata.validity.verify_base = 1; 4359 pfxdata.validity.hyper_pav = 1; 4360 } 4361 4362 switch (cmd) { 4363 case DASD_ECKD_CCW_READ_TRACK_DATA: 4364 dedata->mask.perm = 0x1; 4365 dedata->attributes.operation = basepriv->attrib.operation; 4366 dedata->blk_size = blksize; 4367 dedata->ga_extended |= 0x42; 4368 lredata->operation.orientation = 0x0; 4369 lredata->operation.operation = 0x0C; 4370 lredata->auxiliary.check_bytes = 0x01; 4371 pfx_cmd = DASD_ECKD_CCW_PFX_READ; 4372 break; 4373 case DASD_ECKD_CCW_WRITE_TRACK_DATA: 4374 dedata->mask.perm = 0x02; 4375 dedata->attributes.operation = basepriv->attrib.operation; 4376 dedata->blk_size = blksize; 4377 rc = set_timestamp(NULL, dedata, basedev); 4378 dedata->ga_extended |= 0x42; 4379 lredata->operation.orientation = 0x0; 4380 lredata->operation.operation = 0x3F; 4381 lredata->extended_operation = 0x23; 4382 lredata->auxiliary.check_bytes = 0x2; 4383 /* 4384 * If XRC is supported the System Time Stamp is set. The 4385 * validity of the time stamp must be reflected in the prefix 4386 * data as well. 4387 */ 4388 if (dedata->ga_extended & 0x08 && dedata->ga_extended & 0x02) 4389 pfxdata.validity.time_stamp = 1; /* 'Time Stamp Valid' */ 4390 pfx_cmd = DASD_ECKD_CCW_PFX; 4391 break; 4392 case DASD_ECKD_CCW_READ_COUNT_MT: 4393 dedata->mask.perm = 0x1; 4394 dedata->attributes.operation = DASD_BYPASS_CACHE; 4395 dedata->ga_extended |= 0x42; 4396 dedata->blk_size = blksize; 4397 lredata->operation.orientation = 0x2; 4398 lredata->operation.operation = 0x16; 4399 lredata->auxiliary.check_bytes = 0x01; 4400 pfx_cmd = DASD_ECKD_CCW_PFX_READ; 4401 break; 4402 default: 4403 DBF_DEV_EVENT(DBF_ERR, basedev, 4404 "prepare itcw, unknown opcode 0x%x", cmd); 4405 BUG(); 4406 break; 4407 } 4408 if (rc) 4409 return rc; 4410 4411 dedata->attributes.mode = 0x3; /* ECKD */ 4412 4413 heads = basepriv->rdc_data.trk_per_cyl; 4414 begcyl = trk / heads; 4415 beghead = trk % heads; 4416 endcyl = totrk / heads; 4417 endhead = totrk % heads; 4418 4419 /* check for sequential prestage - enhance cylinder range */ 4420 if (dedata->attributes.operation == DASD_SEQ_PRESTAGE || 4421 dedata->attributes.operation == DASD_SEQ_ACCESS) { 4422 4423 if (endcyl + basepriv->attrib.nr_cyl < basepriv->real_cyl) 4424 endcyl += basepriv->attrib.nr_cyl; 4425 else 4426 endcyl = (basepriv->real_cyl - 1); 4427 } 4428 4429 set_ch_t(&dedata->beg_ext, begcyl, beghead); 4430 set_ch_t(&dedata->end_ext, endcyl, endhead); 4431 4432 dedata->ep_format = 0x20; /* records per track is valid */ 4433 dedata->ep_rec_per_track = blk_per_trk; 4434 4435 if (rec_on_trk) { 4436 switch (basepriv->rdc_data.dev_type) { 4437 case 0x3390: 4438 dn = ceil_quot(blksize + 6, 232); 4439 d = 9 + ceil_quot(blksize + 6 * (dn + 1), 34); 4440 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8; 4441 break; 4442 case 0x3380: 4443 d = 7 + ceil_quot(blksize + 12, 32); 4444 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7; 4445 break; 4446 } 4447 } 4448 4449 if (cmd == DASD_ECKD_CCW_READ_COUNT_MT) { 4450 lredata->auxiliary.length_valid = 0; 4451 lredata->auxiliary.length_scope = 0; 4452 lredata->sector = 0xff; 4453 } else { 4454 lredata->auxiliary.length_valid = 1; 4455 lredata->auxiliary.length_scope = 1; 4456 lredata->sector = sector; 4457 } 4458 lredata->auxiliary.imbedded_ccw_valid = 1; 4459 lredata->length = tlf; 4460 lredata->imbedded_ccw = cmd; 4461 lredata->count = count; 4462 set_ch_t(&lredata->seek_addr, begcyl, beghead); 4463 lredata->search_arg.cyl = lredata->seek_addr.cyl; 4464 lredata->search_arg.head = lredata->seek_addr.head; 4465 lredata->search_arg.record = rec_on_trk; 4466 4467 dcw = itcw_add_dcw(itcw, pfx_cmd, 0, 4468 &pfxdata, sizeof(pfxdata), total_data_size); 4469 return PTR_ERR_OR_ZERO(dcw); 4470} 4471 4472static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track( 4473 struct dasd_device *startdev, 4474 struct dasd_block *block, 4475 struct request *req, 4476 sector_t first_rec, 4477 sector_t last_rec, 4478 sector_t first_trk, 4479 sector_t last_trk, 4480 unsigned int first_offs, 4481 unsigned int last_offs, 4482 unsigned int blk_per_trk, 4483 unsigned int blksize) 4484{ 4485 struct dasd_ccw_req *cqr; 4486 struct req_iterator iter; 4487 struct bio_vec bv; 4488 char *dst; 4489 unsigned int trkcount, ctidaw; 4490 unsigned char cmd; 4491 struct dasd_device *basedev; 4492 unsigned int tlf; 4493 struct itcw *itcw; 4494 struct tidaw *last_tidaw = NULL; 4495 int itcw_op; 4496 size_t itcw_size; 4497 u8 tidaw_flags; 4498 unsigned int seg_len, part_len, len_to_track_end; 4499 unsigned char new_track; 4500 sector_t recid, trkid; 4501 unsigned int offs; 4502 unsigned int count, count_to_trk_end; 4503 int ret; 4504 4505 basedev = block->base; 4506 if (rq_data_dir(req) == READ) { 4507 cmd = DASD_ECKD_CCW_READ_TRACK_DATA; 4508 itcw_op = ITCW_OP_READ; 4509 } else if (rq_data_dir(req) == WRITE) { 4510 cmd = DASD_ECKD_CCW_WRITE_TRACK_DATA; 4511 itcw_op = ITCW_OP_WRITE; 4512 } else 4513 return ERR_PTR(-EINVAL); 4514 4515 /* trackbased I/O needs address all memory via TIDAWs, 4516 * not just for 64 bit addresses. This allows us to map 4517 * each segment directly to one tidaw. 4518 * In the case of write requests, additional tidaws may 4519 * be needed when a segment crosses a track boundary. 4520 */ 4521 trkcount = last_trk - first_trk + 1; 4522 ctidaw = 0; 4523 rq_for_each_segment(bv, req, iter) { 4524 ++ctidaw; 4525 } 4526 if (rq_data_dir(req) == WRITE) 4527 ctidaw += (last_trk - first_trk); 4528 4529 /* Allocate the ccw request. */ 4530 itcw_size = itcw_calc_size(0, ctidaw, 0); 4531 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 0, itcw_size, startdev, 4532 blk_mq_rq_to_pdu(req)); 4533 if (IS_ERR(cqr)) 4534 return cqr; 4535 4536 /* transfer length factor: how many bytes to read from the last track */ 4537 if (first_trk == last_trk) 4538 tlf = last_offs - first_offs + 1; 4539 else 4540 tlf = last_offs + 1; 4541 tlf *= blksize; 4542 4543 itcw = itcw_init(cqr->data, itcw_size, itcw_op, 0, ctidaw, 0); 4544 if (IS_ERR(itcw)) { 4545 ret = -EINVAL; 4546 goto out_error; 4547 } 4548 cqr->cpaddr = itcw_get_tcw(itcw); 4549 if (prepare_itcw(itcw, first_trk, last_trk, 4550 cmd, basedev, startdev, 4551 first_offs + 1, 4552 trkcount, blksize, 4553 (last_rec - first_rec + 1) * blksize, 4554 tlf, blk_per_trk) == -EAGAIN) { 4555 /* Clock not in sync and XRC is enabled. 4556 * Try again later. 4557 */ 4558 ret = -EAGAIN; 4559 goto out_error; 4560 } 4561 len_to_track_end = 0; 4562 /* 4563 * A tidaw can address 4k of memory, but must not cross page boundaries 4564 * We can let the block layer handle this by setting 4565 * blk_queue_segment_boundary to page boundaries and 4566 * blk_max_segment_size to page size when setting up the request queue. 4567 * For write requests, a TIDAW must not cross track boundaries, because 4568 * we have to set the CBC flag on the last tidaw for each track. 4569 */ 4570 if (rq_data_dir(req) == WRITE) { 4571 new_track = 1; 4572 recid = first_rec; 4573 rq_for_each_segment(bv, req, iter) { 4574 dst = bvec_virt(&bv); 4575 seg_len = bv.bv_len; 4576 while (seg_len) { 4577 if (new_track) { 4578 trkid = recid; 4579 offs = sector_div(trkid, blk_per_trk); 4580 count_to_trk_end = blk_per_trk - offs; 4581 count = min((last_rec - recid + 1), 4582 (sector_t)count_to_trk_end); 4583 len_to_track_end = count * blksize; 4584 recid += count; 4585 new_track = 0; 4586 } 4587 part_len = min(seg_len, len_to_track_end); 4588 seg_len -= part_len; 4589 len_to_track_end -= part_len; 4590 /* We need to end the tidaw at track end */ 4591 if (!len_to_track_end) { 4592 new_track = 1; 4593 tidaw_flags = TIDAW_FLAGS_INSERT_CBC; 4594 } else 4595 tidaw_flags = 0; 4596 last_tidaw = itcw_add_tidaw(itcw, tidaw_flags, 4597 dst, part_len); 4598 if (IS_ERR(last_tidaw)) { 4599 ret = -EINVAL; 4600 goto out_error; 4601 } 4602 dst += part_len; 4603 } 4604 } 4605 } else { 4606 rq_for_each_segment(bv, req, iter) { 4607 dst = bvec_virt(&bv); 4608 last_tidaw = itcw_add_tidaw(itcw, 0x00, 4609 dst, bv.bv_len); 4610 if (IS_ERR(last_tidaw)) { 4611 ret = -EINVAL; 4612 goto out_error; 4613 } 4614 } 4615 } 4616 last_tidaw->flags |= TIDAW_FLAGS_LAST; 4617 last_tidaw->flags &= ~TIDAW_FLAGS_INSERT_CBC; 4618 itcw_finalize(itcw); 4619 4620 if (blk_noretry_request(req) || 4621 block->base->features & DASD_FEATURE_FAILFAST) 4622 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 4623 cqr->cpmode = 1; 4624 cqr->startdev = startdev; 4625 cqr->memdev = startdev; 4626 cqr->block = block; 4627 cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */ 4628 cqr->lpm = dasd_path_get_ppm(startdev); 4629 cqr->retries = startdev->default_retries; 4630 cqr->buildclk = get_tod_clock(); 4631 cqr->status = DASD_CQR_FILLED; 4632 4633 /* Set flags to suppress output for expected errors */ 4634 if (dasd_eckd_is_ese(basedev)) { 4635 set_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags); 4636 set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags); 4637 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags); 4638 } 4639 4640 return cqr; 4641out_error: 4642 dasd_sfree_request(cqr, startdev); 4643 return ERR_PTR(ret); 4644} 4645 4646static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev, 4647 struct dasd_block *block, 4648 struct request *req) 4649{ 4650 int cmdrtd, cmdwtd; 4651 int use_prefix; 4652 int fcx_multitrack; 4653 struct dasd_eckd_private *private; 4654 struct dasd_device *basedev; 4655 sector_t first_rec, last_rec; 4656 sector_t first_trk, last_trk; 4657 unsigned int first_offs, last_offs; 4658 unsigned int blk_per_trk, blksize; 4659 int cdlspecial; 4660 unsigned int data_size; 4661 struct dasd_ccw_req *cqr; 4662 4663 basedev = block->base; 4664 private = basedev->private; 4665 4666 /* Calculate number of blocks/records per track. */ 4667 blksize = block->bp_block; 4668 blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize); 4669 if (blk_per_trk == 0) 4670 return ERR_PTR(-EINVAL); 4671 /* Calculate record id of first and last block. */ 4672 first_rec = first_trk = blk_rq_pos(req) >> block->s2b_shift; 4673 first_offs = sector_div(first_trk, blk_per_trk); 4674 last_rec = last_trk = 4675 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift; 4676 last_offs = sector_div(last_trk, blk_per_trk); 4677 cdlspecial = (private->uses_cdl && first_rec < 2*blk_per_trk); 4678 4679 fcx_multitrack = private->features.feature[40] & 0x20; 4680 data_size = blk_rq_bytes(req); 4681 if (data_size % blksize) 4682 return ERR_PTR(-EINVAL); 4683 /* tpm write request add CBC data on each track boundary */ 4684 if (rq_data_dir(req) == WRITE) 4685 data_size += (last_trk - first_trk) * 4; 4686 4687 /* is read track data and write track data in command mode supported? */ 4688 cmdrtd = private->features.feature[9] & 0x20; 4689 cmdwtd = private->features.feature[12] & 0x40; 4690 use_prefix = private->features.feature[8] & 0x01; 4691 4692 cqr = NULL; 4693 if (cdlspecial || dasd_page_cache) { 4694 /* do nothing, just fall through to the cmd mode single case */ 4695 } else if ((data_size <= private->fcx_max_data) 4696 && (fcx_multitrack || (first_trk == last_trk))) { 4697 cqr = dasd_eckd_build_cp_tpm_track(startdev, block, req, 4698 first_rec, last_rec, 4699 first_trk, last_trk, 4700 first_offs, last_offs, 4701 blk_per_trk, blksize); 4702 if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) && 4703 (PTR_ERR(cqr) != -ENOMEM)) 4704 cqr = NULL; 4705 } else if (use_prefix && 4706 (((rq_data_dir(req) == READ) && cmdrtd) || 4707 ((rq_data_dir(req) == WRITE) && cmdwtd))) { 4708 cqr = dasd_eckd_build_cp_cmd_track(startdev, block, req, 4709 first_rec, last_rec, 4710 first_trk, last_trk, 4711 first_offs, last_offs, 4712 blk_per_trk, blksize); 4713 if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) && 4714 (PTR_ERR(cqr) != -ENOMEM)) 4715 cqr = NULL; 4716 } 4717 if (!cqr) 4718 cqr = dasd_eckd_build_cp_cmd_single(startdev, block, req, 4719 first_rec, last_rec, 4720 first_trk, last_trk, 4721 first_offs, last_offs, 4722 blk_per_trk, blksize); 4723 return cqr; 4724} 4725 4726static struct dasd_ccw_req *dasd_eckd_build_cp_raw(struct dasd_device *startdev, 4727 struct dasd_block *block, 4728 struct request *req) 4729{ 4730 sector_t start_padding_sectors, end_sector_offset, end_padding_sectors; 4731 unsigned int seg_len, len_to_track_end; 4732 unsigned int cidaw, cplength, datasize; 4733 sector_t first_trk, last_trk, sectors; 4734 struct dasd_eckd_private *base_priv; 4735 struct dasd_device *basedev; 4736 struct req_iterator iter; 4737 struct dasd_ccw_req *cqr; 4738 unsigned int trkcount; 4739 unsigned int size; 4740 unsigned char cmd; 4741 struct bio_vec bv; 4742 struct ccw1 *ccw; 4743 dma64_t *idaws; 4744 int use_prefix; 4745 void *data; 4746 char *dst; 4747 4748 /* 4749 * raw track access needs to be mutiple of 64k and on 64k boundary 4750 * For read requests we can fix an incorrect alignment by padding 4751 * the request with dummy pages. 4752 */ 4753 start_padding_sectors = blk_rq_pos(req) % DASD_RAW_SECTORS_PER_TRACK; 4754 end_sector_offset = (blk_rq_pos(req) + blk_rq_sectors(req)) % 4755 DASD_RAW_SECTORS_PER_TRACK; 4756 end_padding_sectors = (DASD_RAW_SECTORS_PER_TRACK - end_sector_offset) % 4757 DASD_RAW_SECTORS_PER_TRACK; 4758 basedev = block->base; 4759 if ((start_padding_sectors || end_padding_sectors) && 4760 (rq_data_dir(req) == WRITE)) { 4761 DBF_DEV_EVENT(DBF_ERR, basedev, 4762 "raw write not track aligned (%llu,%llu) req %p", 4763 start_padding_sectors, end_padding_sectors, req); 4764 return ERR_PTR(-EINVAL); 4765 } 4766 4767 first_trk = blk_rq_pos(req) / DASD_RAW_SECTORS_PER_TRACK; 4768 last_trk = (blk_rq_pos(req) + blk_rq_sectors(req) - 1) / 4769 DASD_RAW_SECTORS_PER_TRACK; 4770 trkcount = last_trk - first_trk + 1; 4771 4772 if (rq_data_dir(req) == READ) 4773 cmd = DASD_ECKD_CCW_READ_TRACK; 4774 else if (rq_data_dir(req) == WRITE) 4775 cmd = DASD_ECKD_CCW_WRITE_FULL_TRACK; 4776 else 4777 return ERR_PTR(-EINVAL); 4778 4779 /* 4780 * Raw track based I/O needs IDAWs for each page, 4781 * and not just for 64 bit addresses. 4782 */ 4783 cidaw = trkcount * DASD_RAW_BLOCK_PER_TRACK; 4784 4785 /* 4786 * struct PFX_eckd_data and struct LRE_eckd_data can have up to 2 bytes 4787 * of extended parameter. This is needed for write full track. 4788 */ 4789 base_priv = basedev->private; 4790 use_prefix = base_priv->features.feature[8] & 0x01; 4791 if (use_prefix) { 4792 cplength = 1 + trkcount; 4793 size = sizeof(struct PFX_eckd_data) + 2; 4794 } else { 4795 cplength = 2 + trkcount; 4796 size = sizeof(struct DE_eckd_data) + 4797 sizeof(struct LRE_eckd_data) + 2; 4798 } 4799 size = ALIGN(size, 8); 4800 4801 datasize = size + cidaw * sizeof(unsigned long); 4802 4803 /* Allocate the ccw request. */ 4804 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, 4805 datasize, startdev, blk_mq_rq_to_pdu(req)); 4806 if (IS_ERR(cqr)) 4807 return cqr; 4808 4809 ccw = cqr->cpaddr; 4810 data = cqr->data; 4811 4812 if (use_prefix) { 4813 prefix_LRE(ccw++, data, first_trk, last_trk, cmd, basedev, 4814 startdev, 1, 0, trkcount, 0, 0); 4815 } else { 4816 define_extent(ccw++, data, first_trk, last_trk, cmd, basedev, 0); 4817 ccw[-1].flags |= CCW_FLAG_CC; 4818 4819 data += sizeof(struct DE_eckd_data); 4820 locate_record_ext(ccw++, data, first_trk, 0, 4821 trkcount, cmd, basedev, 0, 0); 4822 } 4823 4824 idaws = (dma64_t *)(cqr->data + size); 4825 len_to_track_end = 0; 4826 if (start_padding_sectors) { 4827 ccw[-1].flags |= CCW_FLAG_CC; 4828 ccw->cmd_code = cmd; 4829 /* maximum 3390 track size */ 4830 ccw->count = 57326; 4831 /* 64k map to one track */ 4832 len_to_track_end = 65536 - start_padding_sectors * 512; 4833 ccw->cda = virt_to_dma32(idaws); 4834 ccw->flags |= CCW_FLAG_IDA; 4835 ccw->flags |= CCW_FLAG_SLI; 4836 ccw++; 4837 for (sectors = 0; sectors < start_padding_sectors; sectors += 8) 4838 idaws = idal_create_words(idaws, rawpadpage, PAGE_SIZE); 4839 } 4840 rq_for_each_segment(bv, req, iter) { 4841 dst = bvec_virt(&bv); 4842 seg_len = bv.bv_len; 4843 if (cmd == DASD_ECKD_CCW_READ_TRACK) 4844 memset(dst, 0, seg_len); 4845 if (!len_to_track_end) { 4846 ccw[-1].flags |= CCW_FLAG_CC; 4847 ccw->cmd_code = cmd; 4848 /* maximum 3390 track size */ 4849 ccw->count = 57326; 4850 /* 64k map to one track */ 4851 len_to_track_end = 65536; 4852 ccw->cda = virt_to_dma32(idaws); 4853 ccw->flags |= CCW_FLAG_IDA; 4854 ccw->flags |= CCW_FLAG_SLI; 4855 ccw++; 4856 } 4857 len_to_track_end -= seg_len; 4858 idaws = idal_create_words(idaws, dst, seg_len); 4859 } 4860 for (sectors = 0; sectors < end_padding_sectors; sectors += 8) 4861 idaws = idal_create_words(idaws, rawpadpage, PAGE_SIZE); 4862 if (blk_noretry_request(req) || 4863 block->base->features & DASD_FEATURE_FAILFAST) 4864 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 4865 cqr->startdev = startdev; 4866 cqr->memdev = startdev; 4867 cqr->block = block; 4868 cqr->expires = startdev->default_expires * HZ; 4869 cqr->lpm = dasd_path_get_ppm(startdev); 4870 cqr->retries = startdev->default_retries; 4871 cqr->buildclk = get_tod_clock(); 4872 cqr->status = DASD_CQR_FILLED; 4873 4874 return cqr; 4875} 4876 4877 4878static int 4879dasd_eckd_free_cp(struct dasd_ccw_req *cqr, struct request *req) 4880{ 4881 struct dasd_eckd_private *private; 4882 struct ccw1 *ccw; 4883 struct req_iterator iter; 4884 struct bio_vec bv; 4885 char *dst, *cda; 4886 unsigned int blksize, blk_per_trk, off; 4887 sector_t recid; 4888 int status; 4889 4890 if (!dasd_page_cache) 4891 goto out; 4892 private = cqr->block->base->private; 4893 blksize = cqr->block->bp_block; 4894 blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize); 4895 recid = blk_rq_pos(req) >> cqr->block->s2b_shift; 4896 ccw = cqr->cpaddr; 4897 /* Skip over define extent & locate record. */ 4898 ccw++; 4899 if (private->uses_cdl == 0 || recid > 2*blk_per_trk) 4900 ccw++; 4901 rq_for_each_segment(bv, req, iter) { 4902 dst = bvec_virt(&bv); 4903 for (off = 0; off < bv.bv_len; off += blksize) { 4904 /* Skip locate record. */ 4905 if (private->uses_cdl && recid <= 2*blk_per_trk) 4906 ccw++; 4907 if (dst) { 4908 if (ccw->flags & CCW_FLAG_IDA) 4909 cda = *((char **)dma32_to_virt(ccw->cda)); 4910 else 4911 cda = dma32_to_virt(ccw->cda); 4912 if (dst != cda) { 4913 if (rq_data_dir(req) == READ) 4914 memcpy(dst, cda, bv.bv_len); 4915 kmem_cache_free(dasd_page_cache, 4916 (void *)((addr_t)cda & PAGE_MASK)); 4917 } 4918 dst = NULL; 4919 } 4920 ccw++; 4921 recid++; 4922 } 4923 } 4924out: 4925 status = cqr->status == DASD_CQR_DONE; 4926 dasd_sfree_request(cqr, cqr->memdev); 4927 return status; 4928} 4929 4930/* 4931 * Modify ccw/tcw in cqr so it can be started on a base device. 4932 * 4933 * Note that this is not enough to restart the cqr! 4934 * Either reset cqr->startdev as well (summary unit check handling) 4935 * or restart via separate cqr (as in ERP handling). 4936 */ 4937void dasd_eckd_reset_ccw_to_base_io(struct dasd_ccw_req *cqr) 4938{ 4939 struct ccw1 *ccw; 4940 struct PFX_eckd_data *pfxdata; 4941 struct tcw *tcw; 4942 struct tccb *tccb; 4943 struct dcw *dcw; 4944 4945 if (cqr->cpmode == 1) { 4946 tcw = cqr->cpaddr; 4947 tccb = tcw_get_tccb(tcw); 4948 dcw = (struct dcw *)&tccb->tca[0]; 4949 pfxdata = (struct PFX_eckd_data *)&dcw->cd[0]; 4950 pfxdata->validity.verify_base = 0; 4951 pfxdata->validity.hyper_pav = 0; 4952 } else { 4953 ccw = cqr->cpaddr; 4954 pfxdata = cqr->data; 4955 if (ccw->cmd_code == DASD_ECKD_CCW_PFX) { 4956 pfxdata->validity.verify_base = 0; 4957 pfxdata->validity.hyper_pav = 0; 4958 } 4959 } 4960} 4961 4962#define DASD_ECKD_CHANQ_MAX_SIZE 4 4963 4964static struct dasd_ccw_req *dasd_eckd_build_alias_cp(struct dasd_device *base, 4965 struct dasd_block *block, 4966 struct request *req) 4967{ 4968 struct dasd_eckd_private *private; 4969 struct dasd_device *startdev; 4970 unsigned long flags; 4971 struct dasd_ccw_req *cqr; 4972 4973 startdev = dasd_alias_get_start_dev(base); 4974 if (!startdev) 4975 startdev = base; 4976 private = startdev->private; 4977 if (private->count >= DASD_ECKD_CHANQ_MAX_SIZE) 4978 return ERR_PTR(-EBUSY); 4979 4980 spin_lock_irqsave(get_ccwdev_lock(startdev->cdev), flags); 4981 private->count++; 4982 if ((base->features & DASD_FEATURE_USERAW)) 4983 cqr = dasd_eckd_build_cp_raw(startdev, block, req); 4984 else 4985 cqr = dasd_eckd_build_cp(startdev, block, req); 4986 if (IS_ERR(cqr)) 4987 private->count--; 4988 spin_unlock_irqrestore(get_ccwdev_lock(startdev->cdev), flags); 4989 return cqr; 4990} 4991 4992static int dasd_eckd_free_alias_cp(struct dasd_ccw_req *cqr, 4993 struct request *req) 4994{ 4995 struct dasd_eckd_private *private; 4996 unsigned long flags; 4997 4998 spin_lock_irqsave(get_ccwdev_lock(cqr->memdev->cdev), flags); 4999 private = cqr->memdev->private; 5000 private->count--; 5001 spin_unlock_irqrestore(get_ccwdev_lock(cqr->memdev->cdev), flags); 5002 return dasd_eckd_free_cp(cqr, req); 5003} 5004 5005static int 5006dasd_eckd_fill_info(struct dasd_device * device, 5007 struct dasd_information2_t * info) 5008{ 5009 struct dasd_eckd_private *private = device->private; 5010 5011 info->label_block = 2; 5012 info->FBA_layout = private->uses_cdl ? 0 : 1; 5013 info->format = private->uses_cdl ? DASD_FORMAT_CDL : DASD_FORMAT_LDL; 5014 info->characteristics_size = sizeof(private->rdc_data); 5015 memcpy(info->characteristics, &private->rdc_data, 5016 sizeof(private->rdc_data)); 5017 info->confdata_size = min_t(unsigned long, private->conf.len, 5018 sizeof(info->configuration_data)); 5019 memcpy(info->configuration_data, private->conf.data, 5020 info->confdata_size); 5021 return 0; 5022} 5023 5024/* 5025 * SECTION: ioctl functions for eckd devices. 5026 */ 5027 5028/* 5029 * Release device ioctl. 5030 * Buils a channel programm to releases a prior reserved 5031 * (see dasd_eckd_reserve) device. 5032 */ 5033static int 5034dasd_eckd_release(struct dasd_device *device) 5035{ 5036 struct dasd_ccw_req *cqr; 5037 int rc; 5038 struct ccw1 *ccw; 5039 int useglobal; 5040 5041 if (!capable(CAP_SYS_ADMIN)) 5042 return -EACCES; 5043 5044 useglobal = 0; 5045 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device, NULL); 5046 if (IS_ERR(cqr)) { 5047 mutex_lock(&dasd_reserve_mutex); 5048 useglobal = 1; 5049 cqr = &dasd_reserve_req->cqr; 5050 memset(cqr, 0, sizeof(*cqr)); 5051 memset(&dasd_reserve_req->ccw, 0, 5052 sizeof(dasd_reserve_req->ccw)); 5053 cqr->cpaddr = &dasd_reserve_req->ccw; 5054 cqr->data = &dasd_reserve_req->data; 5055 cqr->magic = DASD_ECKD_MAGIC; 5056 } 5057 ccw = cqr->cpaddr; 5058 ccw->cmd_code = DASD_ECKD_CCW_RELEASE; 5059 ccw->flags |= CCW_FLAG_SLI; 5060 ccw->count = 32; 5061 ccw->cda = virt_to_dma32(cqr->data); 5062 cqr->startdev = device; 5063 cqr->memdev = device; 5064 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 5065 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 5066 cqr->retries = 2; /* set retry counter to enable basic ERP */ 5067 cqr->expires = 2 * HZ; 5068 cqr->buildclk = get_tod_clock(); 5069 cqr->status = DASD_CQR_FILLED; 5070 5071 rc = dasd_sleep_on_immediatly(cqr); 5072 if (!rc) 5073 clear_bit(DASD_FLAG_IS_RESERVED, &device->flags); 5074 5075 if (useglobal) 5076 mutex_unlock(&dasd_reserve_mutex); 5077 else 5078 dasd_sfree_request(cqr, cqr->memdev); 5079 return rc; 5080} 5081 5082/* 5083 * Reserve device ioctl. 5084 * Options are set to 'synchronous wait for interrupt' and 5085 * 'timeout the request'. This leads to a terminate IO if 5086 * the interrupt is outstanding for a certain time. 5087 */ 5088static int 5089dasd_eckd_reserve(struct dasd_device *device) 5090{ 5091 struct dasd_ccw_req *cqr; 5092 int rc; 5093 struct ccw1 *ccw; 5094 int useglobal; 5095 5096 if (!capable(CAP_SYS_ADMIN)) 5097 return -EACCES; 5098 5099 useglobal = 0; 5100 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device, NULL); 5101 if (IS_ERR(cqr)) { 5102 mutex_lock(&dasd_reserve_mutex); 5103 useglobal = 1; 5104 cqr = &dasd_reserve_req->cqr; 5105 memset(cqr, 0, sizeof(*cqr)); 5106 memset(&dasd_reserve_req->ccw, 0, 5107 sizeof(dasd_reserve_req->ccw)); 5108 cqr->cpaddr = &dasd_reserve_req->ccw; 5109 cqr->data = &dasd_reserve_req->data; 5110 cqr->magic = DASD_ECKD_MAGIC; 5111 } 5112 ccw = cqr->cpaddr; 5113 ccw->cmd_code = DASD_ECKD_CCW_RESERVE; 5114 ccw->flags |= CCW_FLAG_SLI; 5115 ccw->count = 32; 5116 ccw->cda = virt_to_dma32(cqr->data); 5117 cqr->startdev = device; 5118 cqr->memdev = device; 5119 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 5120 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 5121 cqr->retries = 2; /* set retry counter to enable basic ERP */ 5122 cqr->expires = 2 * HZ; 5123 cqr->buildclk = get_tod_clock(); 5124 cqr->status = DASD_CQR_FILLED; 5125 5126 rc = dasd_sleep_on_immediatly(cqr); 5127 if (!rc) 5128 set_bit(DASD_FLAG_IS_RESERVED, &device->flags); 5129 5130 if (useglobal) 5131 mutex_unlock(&dasd_reserve_mutex); 5132 else 5133 dasd_sfree_request(cqr, cqr->memdev); 5134 return rc; 5135} 5136 5137/* 5138 * Steal lock ioctl - unconditional reserve device. 5139 * Buils a channel programm to break a device's reservation. 5140 * (unconditional reserve) 5141 */ 5142static int 5143dasd_eckd_steal_lock(struct dasd_device *device) 5144{ 5145 struct dasd_ccw_req *cqr; 5146 int rc; 5147 struct ccw1 *ccw; 5148 int useglobal; 5149 5150 if (!capable(CAP_SYS_ADMIN)) 5151 return -EACCES; 5152 5153 useglobal = 0; 5154 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device, NULL); 5155 if (IS_ERR(cqr)) { 5156 mutex_lock(&dasd_reserve_mutex); 5157 useglobal = 1; 5158 cqr = &dasd_reserve_req->cqr; 5159 memset(cqr, 0, sizeof(*cqr)); 5160 memset(&dasd_reserve_req->ccw, 0, 5161 sizeof(dasd_reserve_req->ccw)); 5162 cqr->cpaddr = &dasd_reserve_req->ccw; 5163 cqr->data = &dasd_reserve_req->data; 5164 cqr->magic = DASD_ECKD_MAGIC; 5165 } 5166 ccw = cqr->cpaddr; 5167 ccw->cmd_code = DASD_ECKD_CCW_SLCK; 5168 ccw->flags |= CCW_FLAG_SLI; 5169 ccw->count = 32; 5170 ccw->cda = virt_to_dma32(cqr->data); 5171 cqr->startdev = device; 5172 cqr->memdev = device; 5173 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 5174 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 5175 cqr->retries = 2; /* set retry counter to enable basic ERP */ 5176 cqr->expires = 2 * HZ; 5177 cqr->buildclk = get_tod_clock(); 5178 cqr->status = DASD_CQR_FILLED; 5179 5180 rc = dasd_sleep_on_immediatly(cqr); 5181 if (!rc) 5182 set_bit(DASD_FLAG_IS_RESERVED, &device->flags); 5183 5184 if (useglobal) 5185 mutex_unlock(&dasd_reserve_mutex); 5186 else 5187 dasd_sfree_request(cqr, cqr->memdev); 5188 return rc; 5189} 5190 5191/* 5192 * SNID - Sense Path Group ID 5193 * This ioctl may be used in situations where I/O is stalled due to 5194 * a reserve, so if the normal dasd_smalloc_request fails, we use the 5195 * preallocated dasd_reserve_req. 5196 */ 5197static int dasd_eckd_snid(struct dasd_device *device, 5198 void __user *argp) 5199{ 5200 struct dasd_ccw_req *cqr; 5201 int rc; 5202 struct ccw1 *ccw; 5203 int useglobal; 5204 struct dasd_snid_ioctl_data usrparm; 5205 5206 if (!capable(CAP_SYS_ADMIN)) 5207 return -EACCES; 5208 5209 if (copy_from_user(&usrparm, argp, sizeof(usrparm))) 5210 return -EFAULT; 5211 5212 useglobal = 0; 5213 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 5214 sizeof(struct dasd_snid_data), device, 5215 NULL); 5216 if (IS_ERR(cqr)) { 5217 mutex_lock(&dasd_reserve_mutex); 5218 useglobal = 1; 5219 cqr = &dasd_reserve_req->cqr; 5220 memset(cqr, 0, sizeof(*cqr)); 5221 memset(&dasd_reserve_req->ccw, 0, 5222 sizeof(dasd_reserve_req->ccw)); 5223 cqr->cpaddr = &dasd_reserve_req->ccw; 5224 cqr->data = &dasd_reserve_req->data; 5225 cqr->magic = DASD_ECKD_MAGIC; 5226 } 5227 ccw = cqr->cpaddr; 5228 ccw->cmd_code = DASD_ECKD_CCW_SNID; 5229 ccw->flags |= CCW_FLAG_SLI; 5230 ccw->count = 12; 5231 ccw->cda = virt_to_dma32(cqr->data); 5232 cqr->startdev = device; 5233 cqr->memdev = device; 5234 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 5235 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 5236 set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags); 5237 cqr->retries = 5; 5238 cqr->expires = 10 * HZ; 5239 cqr->buildclk = get_tod_clock(); 5240 cqr->status = DASD_CQR_FILLED; 5241 cqr->lpm = usrparm.path_mask; 5242 5243 rc = dasd_sleep_on_immediatly(cqr); 5244 /* verify that I/O processing didn't modify the path mask */ 5245 if (!rc && usrparm.path_mask && (cqr->lpm != usrparm.path_mask)) 5246 rc = -EIO; 5247 if (!rc) { 5248 usrparm.data = *((struct dasd_snid_data *)cqr->data); 5249 if (copy_to_user(argp, &usrparm, sizeof(usrparm))) 5250 rc = -EFAULT; 5251 } 5252 5253 if (useglobal) 5254 mutex_unlock(&dasd_reserve_mutex); 5255 else 5256 dasd_sfree_request(cqr, cqr->memdev); 5257 return rc; 5258} 5259 5260/* 5261 * Read performance statistics 5262 */ 5263static int 5264dasd_eckd_performance(struct dasd_device *device, void __user *argp) 5265{ 5266 struct dasd_psf_prssd_data *prssdp; 5267 struct dasd_rssd_perf_stats_t *stats; 5268 struct dasd_ccw_req *cqr; 5269 struct ccw1 *ccw; 5270 int rc; 5271 5272 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 5273 (sizeof(struct dasd_psf_prssd_data) + 5274 sizeof(struct dasd_rssd_perf_stats_t)), 5275 device, NULL); 5276 if (IS_ERR(cqr)) { 5277 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 5278 "Could not allocate initialization request"); 5279 return PTR_ERR(cqr); 5280 } 5281 cqr->startdev = device; 5282 cqr->memdev = device; 5283 cqr->retries = 0; 5284 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 5285 cqr->expires = 10 * HZ; 5286 5287 /* Prepare for Read Subsystem Data */ 5288 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 5289 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 5290 prssdp->order = PSF_ORDER_PRSSD; 5291 prssdp->suborder = 0x01; /* Performance Statistics */ 5292 prssdp->varies[1] = 0x01; /* Perf Statistics for the Subsystem */ 5293 5294 ccw = cqr->cpaddr; 5295 ccw->cmd_code = DASD_ECKD_CCW_PSF; 5296 ccw->count = sizeof(struct dasd_psf_prssd_data); 5297 ccw->flags |= CCW_FLAG_CC; 5298 ccw->cda = virt_to_dma32(prssdp); 5299 5300 /* Read Subsystem Data - Performance Statistics */ 5301 stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1); 5302 memset(stats, 0, sizeof(struct dasd_rssd_perf_stats_t)); 5303 5304 ccw++; 5305 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 5306 ccw->count = sizeof(struct dasd_rssd_perf_stats_t); 5307 ccw->cda = virt_to_dma32(stats); 5308 5309 cqr->buildclk = get_tod_clock(); 5310 cqr->status = DASD_CQR_FILLED; 5311 rc = dasd_sleep_on(cqr); 5312 if (rc == 0) { 5313 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 5314 stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1); 5315 if (copy_to_user(argp, stats, 5316 sizeof(struct dasd_rssd_perf_stats_t))) 5317 rc = -EFAULT; 5318 } 5319 dasd_sfree_request(cqr, cqr->memdev); 5320 return rc; 5321} 5322 5323/* 5324 * Get attributes (cache operations) 5325 * Returnes the cache attributes used in Define Extend (DE). 5326 */ 5327static int 5328dasd_eckd_get_attrib(struct dasd_device *device, void __user *argp) 5329{ 5330 struct dasd_eckd_private *private = device->private; 5331 struct attrib_data_t attrib = private->attrib; 5332 int rc; 5333 5334 if (!capable(CAP_SYS_ADMIN)) 5335 return -EACCES; 5336 if (!argp) 5337 return -EINVAL; 5338 5339 rc = 0; 5340 if (copy_to_user(argp, (long *) &attrib, 5341 sizeof(struct attrib_data_t))) 5342 rc = -EFAULT; 5343 5344 return rc; 5345} 5346 5347/* 5348 * Set attributes (cache operations) 5349 * Stores the attributes for cache operation to be used in Define Extend (DE). 5350 */ 5351static int 5352dasd_eckd_set_attrib(struct dasd_device *device, void __user *argp) 5353{ 5354 struct dasd_eckd_private *private = device->private; 5355 struct attrib_data_t attrib; 5356 5357 if (!capable(CAP_SYS_ADMIN)) 5358 return -EACCES; 5359 if (!argp) 5360 return -EINVAL; 5361 5362 if (copy_from_user(&attrib, argp, sizeof(struct attrib_data_t))) 5363 return -EFAULT; 5364 private->attrib = attrib; 5365 5366 dev_info(&device->cdev->dev, 5367 "The DASD cache mode was set to %x (%i cylinder prestage)\n", 5368 private->attrib.operation, private->attrib.nr_cyl); 5369 return 0; 5370} 5371 5372/* 5373 * Issue syscall I/O to EMC Symmetrix array. 5374 * CCWs are PSF and RSSD 5375 */ 5376static int dasd_symm_io(struct dasd_device *device, void __user *argp) 5377{ 5378 struct dasd_symmio_parms usrparm; 5379 char *psf_data, *rssd_result; 5380 struct dasd_ccw_req *cqr; 5381 struct ccw1 *ccw; 5382 char psf0, psf1; 5383 int rc; 5384 5385 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO)) 5386 return -EACCES; 5387 psf0 = psf1 = 0; 5388 5389 /* Copy parms from caller */ 5390 rc = -EFAULT; 5391 if (copy_from_user(&usrparm, argp, sizeof(usrparm))) 5392 goto out; 5393 if (is_compat_task()) { 5394 /* Make sure pointers are sane even on 31 bit. */ 5395 rc = -EINVAL; 5396 if ((usrparm.psf_data >> 32) != 0) 5397 goto out; 5398 if ((usrparm.rssd_result >> 32) != 0) 5399 goto out; 5400 usrparm.psf_data &= 0x7fffffffULL; 5401 usrparm.rssd_result &= 0x7fffffffULL; 5402 } 5403 /* at least 2 bytes are accessed and should be allocated */ 5404 if (usrparm.psf_data_len < 2) { 5405 DBF_DEV_EVENT(DBF_WARNING, device, 5406 "Symmetrix ioctl invalid data length %d", 5407 usrparm.psf_data_len); 5408 rc = -EINVAL; 5409 goto out; 5410 } 5411 /* alloc I/O data area */ 5412 psf_data = kzalloc(usrparm.psf_data_len, GFP_KERNEL | GFP_DMA); 5413 rssd_result = kzalloc(usrparm.rssd_result_len, GFP_KERNEL | GFP_DMA); 5414 if (!psf_data || !rssd_result) { 5415 rc = -ENOMEM; 5416 goto out_free; 5417 } 5418 5419 /* get syscall header from user space */ 5420 rc = -EFAULT; 5421 if (copy_from_user(psf_data, 5422 (void __user *)(unsigned long) usrparm.psf_data, 5423 usrparm.psf_data_len)) 5424 goto out_free; 5425 psf0 = psf_data[0]; 5426 psf1 = psf_data[1]; 5427 5428 /* setup CCWs for PSF + RSSD */ 5429 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2, 0, device, NULL); 5430 if (IS_ERR(cqr)) { 5431 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 5432 "Could not allocate initialization request"); 5433 rc = PTR_ERR(cqr); 5434 goto out_free; 5435 } 5436 5437 cqr->startdev = device; 5438 cqr->memdev = device; 5439 cqr->retries = 3; 5440 cqr->expires = 10 * HZ; 5441 cqr->buildclk = get_tod_clock(); 5442 cqr->status = DASD_CQR_FILLED; 5443 5444 /* Build the ccws */ 5445 ccw = cqr->cpaddr; 5446 5447 /* PSF ccw */ 5448 ccw->cmd_code = DASD_ECKD_CCW_PSF; 5449 ccw->count = usrparm.psf_data_len; 5450 ccw->flags |= CCW_FLAG_CC; 5451 ccw->cda = virt_to_dma32(psf_data); 5452 5453 ccw++; 5454 5455 /* RSSD ccw */ 5456 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 5457 ccw->count = usrparm.rssd_result_len; 5458 ccw->flags = CCW_FLAG_SLI ; 5459 ccw->cda = virt_to_dma32(rssd_result); 5460 5461 rc = dasd_sleep_on(cqr); 5462 if (rc) 5463 goto out_sfree; 5464 5465 rc = -EFAULT; 5466 if (copy_to_user((void __user *)(unsigned long) usrparm.rssd_result, 5467 rssd_result, usrparm.rssd_result_len)) 5468 goto out_sfree; 5469 rc = 0; 5470 5471out_sfree: 5472 dasd_sfree_request(cqr, cqr->memdev); 5473out_free: 5474 kfree(rssd_result); 5475 kfree(psf_data); 5476out: 5477 DBF_DEV_EVENT(DBF_WARNING, device, 5478 "Symmetrix ioctl (0x%02x 0x%02x): rc=%d", 5479 (int) psf0, (int) psf1, rc); 5480 return rc; 5481} 5482 5483static int 5484dasd_eckd_ioctl(struct dasd_block *block, unsigned int cmd, void __user *argp) 5485{ 5486 struct dasd_device *device = block->base; 5487 5488 switch (cmd) { 5489 case BIODASDGATTR: 5490 return dasd_eckd_get_attrib(device, argp); 5491 case BIODASDSATTR: 5492 return dasd_eckd_set_attrib(device, argp); 5493 case BIODASDPSRD: 5494 return dasd_eckd_performance(device, argp); 5495 case BIODASDRLSE: 5496 return dasd_eckd_release(device); 5497 case BIODASDRSRV: 5498 return dasd_eckd_reserve(device); 5499 case BIODASDSLCK: 5500 return dasd_eckd_steal_lock(device); 5501 case BIODASDSNID: 5502 return dasd_eckd_snid(device, argp); 5503 case BIODASDSYMMIO: 5504 return dasd_symm_io(device, argp); 5505 default: 5506 return -ENOTTY; 5507 } 5508} 5509 5510/* 5511 * Dump the range of CCWs into 'page' buffer 5512 * and return number of printed chars. 5513 */ 5514static void 5515dasd_eckd_dump_ccw_range(struct dasd_device *device, struct ccw1 *from, 5516 struct ccw1 *to, char *page) 5517{ 5518 int len, count; 5519 char *datap; 5520 5521 len = 0; 5522 while (from <= to) { 5523 len += sprintf(page + len, "CCW %px: %08X %08X DAT:", 5524 from, ((int *) from)[0], ((int *) from)[1]); 5525 5526 /* get pointer to data (consider IDALs) */ 5527 if (from->flags & CCW_FLAG_IDA) 5528 datap = (char *)*((addr_t *)dma32_to_virt(from->cda)); 5529 else 5530 datap = dma32_to_virt(from->cda); 5531 5532 /* dump data (max 128 bytes) */ 5533 for (count = 0; count < from->count && count < 128; count++) { 5534 if (count % 32 == 0) 5535 len += sprintf(page + len, "\n"); 5536 if (count % 8 == 0) 5537 len += sprintf(page + len, " "); 5538 if (count % 4 == 0) 5539 len += sprintf(page + len, " "); 5540 len += sprintf(page + len, "%02x", datap[count]); 5541 } 5542 len += sprintf(page + len, "\n"); 5543 from++; 5544 } 5545 if (len > 0) 5546 dev_err(&device->cdev->dev, "%s", page); 5547} 5548 5549static void 5550dasd_eckd_dump_sense_dbf(struct dasd_device *device, struct irb *irb, 5551 char *reason) 5552{ 5553 u64 *sense; 5554 u64 *stat; 5555 5556 sense = (u64 *) dasd_get_sense(irb); 5557 stat = (u64 *) &irb->scsw; 5558 if (sense) { 5559 DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : " 5560 "%016llx %016llx %016llx %016llx", 5561 reason, *stat, *((u32 *) (stat + 1)), 5562 sense[0], sense[1], sense[2], sense[3]); 5563 } else { 5564 DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : %s", 5565 reason, *stat, *((u32 *) (stat + 1)), 5566 "NO VALID SENSE"); 5567 } 5568} 5569 5570/* 5571 * Print sense data and related channel program. 5572 * Parts are printed because printk buffer is only 1024 bytes. 5573 */ 5574static void dasd_eckd_dump_sense_ccw(struct dasd_device *device, 5575 struct dasd_ccw_req *req, struct irb *irb) 5576{ 5577 struct ccw1 *first, *last, *fail, *from, *to; 5578 struct device *dev; 5579 int len, sl, sct; 5580 char *page; 5581 5582 dev = &device->cdev->dev; 5583 5584 page = (char *) get_zeroed_page(GFP_ATOMIC); 5585 if (page == NULL) { 5586 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 5587 "No memory to dump sense data\n"); 5588 return; 5589 } 5590 /* dump the sense data */ 5591 len = sprintf(page, "I/O status report:\n"); 5592 len += sprintf(page + len, 5593 "in req: %px CC:%02X FC:%02X AC:%02X SC:%02X DS:%02X CS:%02X RC:%d\n", 5594 req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw), 5595 scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw), 5596 scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw), 5597 req ? req->intrc : 0); 5598 len += sprintf(page + len, "Failing CCW: %px\n", 5599 dma32_to_virt(irb->scsw.cmd.cpa)); 5600 if (irb->esw.esw0.erw.cons) { 5601 for (sl = 0; sl < 4; sl++) { 5602 len += sprintf(page + len, "Sense(hex) %2d-%2d:", 5603 (8 * sl), ((8 * sl) + 7)); 5604 5605 for (sct = 0; sct < 8; sct++) { 5606 len += sprintf(page + len, " %02x", 5607 irb->ecw[8 * sl + sct]); 5608 } 5609 len += sprintf(page + len, "\n"); 5610 } 5611 5612 if (irb->ecw[27] & DASD_SENSE_BIT_0) { 5613 /* 24 Byte Sense Data */ 5614 sprintf(page + len, 5615 "24 Byte: %x MSG %x, %s MSGb to SYSOP\n", 5616 irb->ecw[7] >> 4, irb->ecw[7] & 0x0f, 5617 irb->ecw[1] & 0x10 ? "" : "no"); 5618 } else { 5619 /* 32 Byte Sense Data */ 5620 sprintf(page + len, 5621 "32 Byte: Format: %x Exception class %x\n", 5622 irb->ecw[6] & 0x0f, irb->ecw[22] >> 4); 5623 } 5624 } else { 5625 sprintf(page + len, "SORRY - NO VALID SENSE AVAILABLE\n"); 5626 } 5627 dev_err(dev, "%s", page); 5628 5629 if (req) { 5630 /* req == NULL for unsolicited interrupts */ 5631 /* dump the Channel Program (max 140 Bytes per line) */ 5632 /* Count CCW and print first CCWs (maximum 7) */ 5633 first = req->cpaddr; 5634 for (last = first; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++); 5635 to = min(first + 6, last); 5636 dev_err(dev, "Related CP in req: %px\n", req); 5637 dasd_eckd_dump_ccw_range(device, first, to, page); 5638 5639 /* print failing CCW area (maximum 4) */ 5640 /* scsw->cda is either valid or zero */ 5641 from = ++to; 5642 fail = dma32_to_virt(irb->scsw.cmd.cpa); /* failing CCW */ 5643 if (from < fail - 2) { 5644 from = fail - 2; /* there is a gap - print header */ 5645 dev_err(dev, "......\n"); 5646 } 5647 to = min(fail + 1, last); 5648 dasd_eckd_dump_ccw_range(device, from, to, page + len); 5649 5650 /* print last CCWs (maximum 2) */ 5651 len = 0; 5652 from = max(from, ++to); 5653 if (from < last - 1) { 5654 from = last - 1; /* there is a gap - print header */ 5655 dev_err(dev, "......\n"); 5656 } 5657 dasd_eckd_dump_ccw_range(device, from, last, page + len); 5658 } 5659 free_page((unsigned long) page); 5660} 5661 5662 5663/* 5664 * Print sense data from a tcw. 5665 */ 5666static void dasd_eckd_dump_sense_tcw(struct dasd_device *device, 5667 struct dasd_ccw_req *req, struct irb *irb) 5668{ 5669 char *page; 5670 int len, sl, sct, residual; 5671 struct tsb *tsb; 5672 u8 *sense, *rcq; 5673 5674 page = (char *) get_zeroed_page(GFP_ATOMIC); 5675 if (page == NULL) { 5676 DBF_DEV_EVENT(DBF_WARNING, device, " %s", 5677 "No memory to dump sense data"); 5678 return; 5679 } 5680 /* dump the sense data */ 5681 len = sprintf(page, "I/O status report:\n"); 5682 len += sprintf(page + len, 5683 "in req: %px CC:%02X FC:%02X AC:%02X SC:%02X DS:%02X " 5684 "CS:%02X fcxs:%02X schxs:%02X RC:%d\n", 5685 req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw), 5686 scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw), 5687 scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw), 5688 irb->scsw.tm.fcxs, 5689 (irb->scsw.tm.ifob << 7) | irb->scsw.tm.sesq, 5690 req ? req->intrc : 0); 5691 len += sprintf(page + len, "Failing TCW: %px\n", 5692 dma32_to_virt(irb->scsw.tm.tcw)); 5693 5694 tsb = NULL; 5695 sense = NULL; 5696 if (irb->scsw.tm.tcw && (irb->scsw.tm.fcxs & 0x01)) 5697 tsb = tcw_get_tsb(dma32_to_virt(irb->scsw.tm.tcw)); 5698 5699 if (tsb) { 5700 len += sprintf(page + len, "tsb->length %d\n", tsb->length); 5701 len += sprintf(page + len, "tsb->flags %x\n", tsb->flags); 5702 len += sprintf(page + len, "tsb->dcw_offset %d\n", tsb->dcw_offset); 5703 len += sprintf(page + len, "tsb->count %d\n", tsb->count); 5704 residual = tsb->count - 28; 5705 len += sprintf(page + len, "residual %d\n", residual); 5706 5707 switch (tsb->flags & 0x07) { 5708 case 1: /* tsa_iostat */ 5709 len += sprintf(page + len, "tsb->tsa.iostat.dev_time %d\n", 5710 tsb->tsa.iostat.dev_time); 5711 len += sprintf(page + len, "tsb->tsa.iostat.def_time %d\n", 5712 tsb->tsa.iostat.def_time); 5713 len += sprintf(page + len, "tsb->tsa.iostat.queue_time %d\n", 5714 tsb->tsa.iostat.queue_time); 5715 len += sprintf(page + len, "tsb->tsa.iostat.dev_busy_time %d\n", 5716 tsb->tsa.iostat.dev_busy_time); 5717 len += sprintf(page + len, "tsb->tsa.iostat.dev_act_time %d\n", 5718 tsb->tsa.iostat.dev_act_time); 5719 sense = tsb->tsa.iostat.sense; 5720 break; 5721 case 2: /* ts_ddpc */ 5722 len += sprintf(page + len, "tsb->tsa.ddpc.rc %d\n", 5723 tsb->tsa.ddpc.rc); 5724 for (sl = 0; sl < 2; sl++) { 5725 len += sprintf(page + len, 5726 "tsb->tsa.ddpc.rcq %2d-%2d: ", 5727 (8 * sl), ((8 * sl) + 7)); 5728 rcq = tsb->tsa.ddpc.rcq; 5729 for (sct = 0; sct < 8; sct++) { 5730 len += sprintf(page + len, "%02x", 5731 rcq[8 * sl + sct]); 5732 } 5733 len += sprintf(page + len, "\n"); 5734 } 5735 sense = tsb->tsa.ddpc.sense; 5736 break; 5737 case 3: /* tsa_intrg */ 5738 len += sprintf(page + len, 5739 "tsb->tsa.intrg.: not supported yet\n"); 5740 break; 5741 } 5742 5743 if (sense) { 5744 for (sl = 0; sl < 4; sl++) { 5745 len += sprintf(page + len, 5746 "Sense(hex) %2d-%2d:", 5747 (8 * sl), ((8 * sl) + 7)); 5748 for (sct = 0; sct < 8; sct++) { 5749 len += sprintf(page + len, " %02x", 5750 sense[8 * sl + sct]); 5751 } 5752 len += sprintf(page + len, "\n"); 5753 } 5754 5755 if (sense[27] & DASD_SENSE_BIT_0) { 5756 /* 24 Byte Sense Data */ 5757 sprintf(page + len, 5758 "24 Byte: %x MSG %x, %s MSGb to SYSOP\n", 5759 sense[7] >> 4, sense[7] & 0x0f, 5760 sense[1] & 0x10 ? "" : "no"); 5761 } else { 5762 /* 32 Byte Sense Data */ 5763 sprintf(page + len, 5764 "32 Byte: Format: %x Exception class %x\n", 5765 sense[6] & 0x0f, sense[22] >> 4); 5766 } 5767 } else { 5768 sprintf(page + len, "SORRY - NO VALID SENSE AVAILABLE\n"); 5769 } 5770 } else { 5771 sprintf(page + len, "SORRY - NO TSB DATA AVAILABLE\n"); 5772 } 5773 dev_err(&device->cdev->dev, "%s", page); 5774 free_page((unsigned long) page); 5775} 5776 5777static void dasd_eckd_dump_sense(struct dasd_device *device, 5778 struct dasd_ccw_req *req, struct irb *irb) 5779{ 5780 u8 *sense = dasd_get_sense(irb); 5781 5782 if (scsw_is_tm(&irb->scsw)) { 5783 /* 5784 * In some cases the 'File Protected' or 'Incorrect Length' 5785 * error might be expected and log messages shouldn't be written 5786 * then. Check if the according suppress bit is set. 5787 */ 5788 if (sense && (sense[1] & SNS1_FILE_PROTECTED) && 5789 test_bit(DASD_CQR_SUPPRESS_FP, &req->flags)) 5790 return; 5791 if (scsw_cstat(&irb->scsw) == 0x40 && 5792 test_bit(DASD_CQR_SUPPRESS_IL, &req->flags)) 5793 return; 5794 5795 dasd_eckd_dump_sense_tcw(device, req, irb); 5796 } else { 5797 /* 5798 * In some cases the 'Command Reject' or 'No Record Found' 5799 * error might be expected and log messages shouldn't be 5800 * written then. Check if the according suppress bit is set. 5801 */ 5802 if (sense && sense[0] & SNS0_CMD_REJECT && 5803 test_bit(DASD_CQR_SUPPRESS_CR, &req->flags)) 5804 return; 5805 5806 if (sense && sense[1] & SNS1_NO_REC_FOUND && 5807 test_bit(DASD_CQR_SUPPRESS_NRF, &req->flags)) 5808 return; 5809 5810 dasd_eckd_dump_sense_ccw(device, req, irb); 5811 } 5812} 5813 5814static int dasd_eckd_reload_device(struct dasd_device *device) 5815{ 5816 struct dasd_eckd_private *private = device->private; 5817 char print_uid[DASD_UID_STRLEN]; 5818 int rc, old_base; 5819 struct dasd_uid uid; 5820 unsigned long flags; 5821 5822 /* 5823 * remove device from alias handling to prevent new requests 5824 * from being scheduled on the wrong alias device 5825 */ 5826 dasd_alias_remove_device(device); 5827 5828 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 5829 old_base = private->uid.base_unit_addr; 5830 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 5831 5832 /* Read Configuration Data */ 5833 rc = dasd_eckd_read_conf(device); 5834 if (rc) 5835 goto out_err; 5836 5837 dasd_eckd_read_fc_security(device); 5838 5839 rc = dasd_eckd_generate_uid(device); 5840 if (rc) 5841 goto out_err; 5842 /* 5843 * update unit address configuration and 5844 * add device to alias management 5845 */ 5846 dasd_alias_update_add_device(device); 5847 5848 dasd_eckd_get_uid(device, &uid); 5849 5850 if (old_base != uid.base_unit_addr) { 5851 dasd_eckd_get_uid_string(&private->conf, print_uid); 5852 dev_info(&device->cdev->dev, 5853 "An Alias device was reassigned to a new base device " 5854 "with UID: %s\n", print_uid); 5855 } 5856 return 0; 5857 5858out_err: 5859 return -1; 5860} 5861 5862static int dasd_eckd_read_message_buffer(struct dasd_device *device, 5863 struct dasd_rssd_messages *messages, 5864 __u8 lpum) 5865{ 5866 struct dasd_rssd_messages *message_buf; 5867 struct dasd_psf_prssd_data *prssdp; 5868 struct dasd_ccw_req *cqr; 5869 struct ccw1 *ccw; 5870 int rc; 5871 5872 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 5873 (sizeof(struct dasd_psf_prssd_data) + 5874 sizeof(struct dasd_rssd_messages)), 5875 device, NULL); 5876 if (IS_ERR(cqr)) { 5877 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 5878 "Could not allocate read message buffer request"); 5879 return PTR_ERR(cqr); 5880 } 5881 5882 cqr->lpm = lpum; 5883retry: 5884 cqr->startdev = device; 5885 cqr->memdev = device; 5886 cqr->block = NULL; 5887 cqr->expires = 10 * HZ; 5888 set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags); 5889 /* dasd_sleep_on_immediatly does not do complex error 5890 * recovery so clear erp flag and set retry counter to 5891 * do basic erp */ 5892 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 5893 cqr->retries = 256; 5894 5895 /* Prepare for Read Subsystem Data */ 5896 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 5897 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 5898 prssdp->order = PSF_ORDER_PRSSD; 5899 prssdp->suborder = 0x03; /* Message Buffer */ 5900 /* all other bytes of prssdp must be zero */ 5901 5902 ccw = cqr->cpaddr; 5903 ccw->cmd_code = DASD_ECKD_CCW_PSF; 5904 ccw->count = sizeof(struct dasd_psf_prssd_data); 5905 ccw->flags |= CCW_FLAG_CC; 5906 ccw->flags |= CCW_FLAG_SLI; 5907 ccw->cda = virt_to_dma32(prssdp); 5908 5909 /* Read Subsystem Data - message buffer */ 5910 message_buf = (struct dasd_rssd_messages *) (prssdp + 1); 5911 memset(message_buf, 0, sizeof(struct dasd_rssd_messages)); 5912 5913 ccw++; 5914 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 5915 ccw->count = sizeof(struct dasd_rssd_messages); 5916 ccw->flags |= CCW_FLAG_SLI; 5917 ccw->cda = virt_to_dma32(message_buf); 5918 5919 cqr->buildclk = get_tod_clock(); 5920 cqr->status = DASD_CQR_FILLED; 5921 rc = dasd_sleep_on_immediatly(cqr); 5922 if (rc == 0) { 5923 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 5924 message_buf = (struct dasd_rssd_messages *) 5925 (prssdp + 1); 5926 memcpy(messages, message_buf, 5927 sizeof(struct dasd_rssd_messages)); 5928 } else if (cqr->lpm) { 5929 /* 5930 * on z/VM we might not be able to do I/O on the requested path 5931 * but instead we get the required information on any path 5932 * so retry with open path mask 5933 */ 5934 cqr->lpm = 0; 5935 goto retry; 5936 } else 5937 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 5938 "Reading messages failed with rc=%d\n" 5939 , rc); 5940 dasd_sfree_request(cqr, cqr->memdev); 5941 return rc; 5942} 5943 5944static int dasd_eckd_query_host_access(struct dasd_device *device, 5945 struct dasd_psf_query_host_access *data) 5946{ 5947 struct dasd_eckd_private *private = device->private; 5948 struct dasd_psf_query_host_access *host_access; 5949 struct dasd_psf_prssd_data *prssdp; 5950 struct dasd_ccw_req *cqr; 5951 struct ccw1 *ccw; 5952 int rc; 5953 5954 /* not available for HYPER PAV alias devices */ 5955 if (!device->block && private->lcu->pav == HYPER_PAV) 5956 return -EOPNOTSUPP; 5957 5958 /* may not be supported by the storage server */ 5959 if (!(private->features.feature[14] & 0x80)) 5960 return -EOPNOTSUPP; 5961 5962 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 5963 sizeof(struct dasd_psf_prssd_data) + 1, 5964 device, NULL); 5965 if (IS_ERR(cqr)) { 5966 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 5967 "Could not allocate read message buffer request"); 5968 return PTR_ERR(cqr); 5969 } 5970 host_access = kzalloc(sizeof(*host_access), GFP_KERNEL | GFP_DMA); 5971 if (!host_access) { 5972 dasd_sfree_request(cqr, device); 5973 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 5974 "Could not allocate host_access buffer"); 5975 return -ENOMEM; 5976 } 5977 cqr->startdev = device; 5978 cqr->memdev = device; 5979 cqr->block = NULL; 5980 cqr->retries = 256; 5981 cqr->expires = 10 * HZ; 5982 5983 /* Prepare for Read Subsystem Data */ 5984 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 5985 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 5986 prssdp->order = PSF_ORDER_PRSSD; 5987 prssdp->suborder = PSF_SUBORDER_QHA; /* query host access */ 5988 /* LSS and Volume that will be queried */ 5989 prssdp->lss = private->conf.ned->ID; 5990 prssdp->volume = private->conf.ned->unit_addr; 5991 /* all other bytes of prssdp must be zero */ 5992 5993 ccw = cqr->cpaddr; 5994 ccw->cmd_code = DASD_ECKD_CCW_PSF; 5995 ccw->count = sizeof(struct dasd_psf_prssd_data); 5996 ccw->flags |= CCW_FLAG_CC; 5997 ccw->flags |= CCW_FLAG_SLI; 5998 ccw->cda = virt_to_dma32(prssdp); 5999 6000 /* Read Subsystem Data - query host access */ 6001 ccw++; 6002 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 6003 ccw->count = sizeof(struct dasd_psf_query_host_access); 6004 ccw->flags |= CCW_FLAG_SLI; 6005 ccw->cda = virt_to_dma32(host_access); 6006 6007 cqr->buildclk = get_tod_clock(); 6008 cqr->status = DASD_CQR_FILLED; 6009 /* the command might not be supported, suppress error message */ 6010 __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags); 6011 rc = dasd_sleep_on_interruptible(cqr); 6012 if (rc == 0) { 6013 *data = *host_access; 6014 } else { 6015 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 6016 "Reading host access data failed with rc=%d\n", 6017 rc); 6018 rc = -EOPNOTSUPP; 6019 } 6020 6021 dasd_sfree_request(cqr, cqr->memdev); 6022 kfree(host_access); 6023 return rc; 6024} 6025/* 6026 * return number of grouped devices 6027 */ 6028static int dasd_eckd_host_access_count(struct dasd_device *device) 6029{ 6030 struct dasd_psf_query_host_access *access; 6031 struct dasd_ckd_path_group_entry *entry; 6032 struct dasd_ckd_host_information *info; 6033 int count = 0; 6034 int rc, i; 6035 6036 access = kzalloc(sizeof(*access), GFP_NOIO); 6037 if (!access) { 6038 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 6039 "Could not allocate access buffer"); 6040 return -ENOMEM; 6041 } 6042 rc = dasd_eckd_query_host_access(device, access); 6043 if (rc) { 6044 kfree(access); 6045 return rc; 6046 } 6047 6048 info = (struct dasd_ckd_host_information *) 6049 access->host_access_information; 6050 for (i = 0; i < info->entry_count; i++) { 6051 entry = (struct dasd_ckd_path_group_entry *) 6052 (info->entry + i * info->entry_size); 6053 if (entry->status_flags & DASD_ECKD_PG_GROUPED) 6054 count++; 6055 } 6056 6057 kfree(access); 6058 return count; 6059} 6060 6061/* 6062 * write host access information to a sequential file 6063 */ 6064static int dasd_hosts_print(struct dasd_device *device, struct seq_file *m) 6065{ 6066 struct dasd_psf_query_host_access *access; 6067 struct dasd_ckd_path_group_entry *entry; 6068 struct dasd_ckd_host_information *info; 6069 char sysplex[9] = ""; 6070 int rc, i; 6071 6072 access = kzalloc(sizeof(*access), GFP_NOIO); 6073 if (!access) { 6074 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 6075 "Could not allocate access buffer"); 6076 return -ENOMEM; 6077 } 6078 rc = dasd_eckd_query_host_access(device, access); 6079 if (rc) { 6080 kfree(access); 6081 return rc; 6082 } 6083 6084 info = (struct dasd_ckd_host_information *) 6085 access->host_access_information; 6086 for (i = 0; i < info->entry_count; i++) { 6087 entry = (struct dasd_ckd_path_group_entry *) 6088 (info->entry + i * info->entry_size); 6089 /* PGID */ 6090 seq_printf(m, "pgid %*phN\n", 11, entry->pgid); 6091 /* FLAGS */ 6092 seq_printf(m, "status_flags %02x\n", entry->status_flags); 6093 /* SYSPLEX NAME */ 6094 memcpy(&sysplex, &entry->sysplex_name, sizeof(sysplex) - 1); 6095 EBCASC(sysplex, sizeof(sysplex)); 6096 seq_printf(m, "sysplex_name %8s\n", sysplex); 6097 /* SUPPORTED CYLINDER */ 6098 seq_printf(m, "supported_cylinder %d\n", entry->cylinder); 6099 /* TIMESTAMP */ 6100 seq_printf(m, "timestamp %lu\n", (unsigned long) 6101 entry->timestamp); 6102 } 6103 kfree(access); 6104 6105 return 0; 6106} 6107 6108static struct dasd_device 6109*copy_relation_find_device(struct dasd_copy_relation *copy, 6110 char *busid) 6111{ 6112 int i; 6113 6114 for (i = 0; i < DASD_CP_ENTRIES; i++) { 6115 if (copy->entry[i].configured && 6116 strncmp(copy->entry[i].busid, busid, DASD_BUS_ID_SIZE) == 0) 6117 return copy->entry[i].device; 6118 } 6119 return NULL; 6120} 6121 6122/* 6123 * set the new active/primary device 6124 */ 6125static void copy_pair_set_active(struct dasd_copy_relation *copy, char *new_busid, 6126 char *old_busid) 6127{ 6128 int i; 6129 6130 for (i = 0; i < DASD_CP_ENTRIES; i++) { 6131 if (copy->entry[i].configured && 6132 strncmp(copy->entry[i].busid, new_busid, 6133 DASD_BUS_ID_SIZE) == 0) { 6134 copy->active = ©->entry[i]; 6135 copy->entry[i].primary = true; 6136 } else if (copy->entry[i].configured && 6137 strncmp(copy->entry[i].busid, old_busid, 6138 DASD_BUS_ID_SIZE) == 0) { 6139 copy->entry[i].primary = false; 6140 } 6141 } 6142} 6143 6144/* 6145 * The function will swap the role of a given copy pair. 6146 * During the swap operation the relation of the blockdevice is disconnected 6147 * from the old primary and connected to the new. 6148 * 6149 * IO is paused on the block queue before swap and may be resumed afterwards. 6150 */ 6151static int dasd_eckd_copy_pair_swap(struct dasd_device *device, char *prim_busid, 6152 char *sec_busid) 6153{ 6154 struct dasd_device *primary, *secondary; 6155 struct dasd_copy_relation *copy; 6156 struct dasd_block *block; 6157 struct gendisk *gdp; 6158 6159 copy = device->copy; 6160 if (!copy) 6161 return DASD_COPYPAIRSWAP_INVALID; 6162 primary = copy->active->device; 6163 if (!primary) 6164 return DASD_COPYPAIRSWAP_INVALID; 6165 /* double check if swap has correct primary */ 6166 if (strncmp(dev_name(&primary->cdev->dev), prim_busid, DASD_BUS_ID_SIZE) != 0) 6167 return DASD_COPYPAIRSWAP_PRIMARY; 6168 6169 secondary = copy_relation_find_device(copy, sec_busid); 6170 if (!secondary) 6171 return DASD_COPYPAIRSWAP_SECONDARY; 6172 6173 /* 6174 * usually the device should be quiesced for swap 6175 * for paranoia stop device and requeue requests again 6176 */ 6177 dasd_device_set_stop_bits(primary, DASD_STOPPED_PPRC); 6178 dasd_device_set_stop_bits(secondary, DASD_STOPPED_PPRC); 6179 dasd_generic_requeue_all_requests(primary); 6180 6181 /* swap DASD internal device <> block assignment */ 6182 block = primary->block; 6183 primary->block = NULL; 6184 secondary->block = block; 6185 block->base = secondary; 6186 /* set new primary device in COPY relation */ 6187 copy_pair_set_active(copy, sec_busid, prim_busid); 6188 6189 /* swap blocklayer device link */ 6190 gdp = block->gdp; 6191 dasd_add_link_to_gendisk(gdp, secondary); 6192 6193 /* re-enable device */ 6194 dasd_device_remove_stop_bits(primary, DASD_STOPPED_PPRC); 6195 dasd_device_remove_stop_bits(secondary, DASD_STOPPED_PPRC); 6196 dasd_schedule_device_bh(secondary); 6197 6198 return DASD_COPYPAIRSWAP_SUCCESS; 6199} 6200 6201/* 6202 * Perform Subsystem Function - Peer-to-Peer Remote Copy Extended Query 6203 */ 6204static int dasd_eckd_query_pprc_status(struct dasd_device *device, 6205 struct dasd_pprc_data_sc4 *data) 6206{ 6207 struct dasd_pprc_data_sc4 *pprc_data; 6208 struct dasd_psf_prssd_data *prssdp; 6209 struct dasd_ccw_req *cqr; 6210 struct ccw1 *ccw; 6211 int rc; 6212 6213 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 6214 sizeof(*prssdp) + sizeof(*pprc_data) + 1, 6215 device, NULL); 6216 if (IS_ERR(cqr)) { 6217 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 6218 "Could not allocate query PPRC status request"); 6219 return PTR_ERR(cqr); 6220 } 6221 cqr->startdev = device; 6222 cqr->memdev = device; 6223 cqr->block = NULL; 6224 cqr->retries = 256; 6225 cqr->expires = 10 * HZ; 6226 6227 /* Prepare for Read Subsystem Data */ 6228 prssdp = (struct dasd_psf_prssd_data *)cqr->data; 6229 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 6230 prssdp->order = PSF_ORDER_PRSSD; 6231 prssdp->suborder = PSF_SUBORDER_PPRCEQ; 6232 prssdp->varies[0] = PPRCEQ_SCOPE_4; 6233 pprc_data = (struct dasd_pprc_data_sc4 *)(prssdp + 1); 6234 6235 ccw = cqr->cpaddr; 6236 ccw->cmd_code = DASD_ECKD_CCW_PSF; 6237 ccw->count = sizeof(struct dasd_psf_prssd_data); 6238 ccw->flags |= CCW_FLAG_CC; 6239 ccw->flags |= CCW_FLAG_SLI; 6240 ccw->cda = virt_to_dma32(prssdp); 6241 6242 /* Read Subsystem Data - query host access */ 6243 ccw++; 6244 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 6245 ccw->count = sizeof(*pprc_data); 6246 ccw->flags |= CCW_FLAG_SLI; 6247 ccw->cda = virt_to_dma32(pprc_data); 6248 6249 cqr->buildclk = get_tod_clock(); 6250 cqr->status = DASD_CQR_FILLED; 6251 6252 rc = dasd_sleep_on_interruptible(cqr); 6253 if (rc == 0) { 6254 *data = *pprc_data; 6255 } else { 6256 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 6257 "PPRC Extended Query failed with rc=%d\n", 6258 rc); 6259 rc = -EOPNOTSUPP; 6260 } 6261 6262 dasd_sfree_request(cqr, cqr->memdev); 6263 return rc; 6264} 6265 6266/* 6267 * ECKD NOP - no operation 6268 */ 6269static int dasd_eckd_nop(struct dasd_device *device) 6270{ 6271 struct dasd_ccw_req *cqr; 6272 struct ccw1 *ccw; 6273 int rc; 6274 6275 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 1, device, NULL); 6276 if (IS_ERR(cqr)) { 6277 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 6278 "Could not allocate NOP request"); 6279 return PTR_ERR(cqr); 6280 } 6281 cqr->startdev = device; 6282 cqr->memdev = device; 6283 cqr->block = NULL; 6284 cqr->retries = 1; 6285 cqr->expires = 10 * HZ; 6286 6287 ccw = cqr->cpaddr; 6288 ccw->cmd_code = DASD_ECKD_CCW_NOP; 6289 ccw->flags |= CCW_FLAG_SLI; 6290 6291 cqr->buildclk = get_tod_clock(); 6292 cqr->status = DASD_CQR_FILLED; 6293 6294 rc = dasd_sleep_on_interruptible(cqr); 6295 if (rc != 0) { 6296 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 6297 "NOP failed with rc=%d\n", rc); 6298 rc = -EOPNOTSUPP; 6299 } 6300 dasd_sfree_request(cqr, cqr->memdev); 6301 return rc; 6302} 6303 6304static int dasd_eckd_device_ping(struct dasd_device *device) 6305{ 6306 return dasd_eckd_nop(device); 6307} 6308 6309/* 6310 * Perform Subsystem Function - CUIR response 6311 */ 6312static int 6313dasd_eckd_psf_cuir_response(struct dasd_device *device, int response, 6314 __u32 message_id, __u8 lpum) 6315{ 6316 struct dasd_psf_cuir_response *psf_cuir; 6317 int pos = pathmask_to_pos(lpum); 6318 struct dasd_ccw_req *cqr; 6319 struct ccw1 *ccw; 6320 int rc; 6321 6322 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ , 6323 sizeof(struct dasd_psf_cuir_response), 6324 device, NULL); 6325 6326 if (IS_ERR(cqr)) { 6327 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 6328 "Could not allocate PSF-CUIR request"); 6329 return PTR_ERR(cqr); 6330 } 6331 6332 psf_cuir = (struct dasd_psf_cuir_response *)cqr->data; 6333 psf_cuir->order = PSF_ORDER_CUIR_RESPONSE; 6334 psf_cuir->cc = response; 6335 psf_cuir->chpid = device->path[pos].chpid; 6336 psf_cuir->message_id = message_id; 6337 psf_cuir->cssid = device->path[pos].cssid; 6338 psf_cuir->ssid = device->path[pos].ssid; 6339 ccw = cqr->cpaddr; 6340 ccw->cmd_code = DASD_ECKD_CCW_PSF; 6341 ccw->cda = virt_to_dma32(psf_cuir); 6342 ccw->flags = CCW_FLAG_SLI; 6343 ccw->count = sizeof(struct dasd_psf_cuir_response); 6344 6345 cqr->startdev = device; 6346 cqr->memdev = device; 6347 cqr->block = NULL; 6348 cqr->retries = 256; 6349 cqr->expires = 10*HZ; 6350 cqr->buildclk = get_tod_clock(); 6351 cqr->status = DASD_CQR_FILLED; 6352 set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags); 6353 6354 rc = dasd_sleep_on(cqr); 6355 6356 dasd_sfree_request(cqr, cqr->memdev); 6357 return rc; 6358} 6359 6360/* 6361 * return configuration data that is referenced by record selector 6362 * if a record selector is specified or per default return the 6363 * conf_data pointer for the path specified by lpum 6364 */ 6365static struct dasd_conf_data *dasd_eckd_get_ref_conf(struct dasd_device *device, 6366 __u8 lpum, 6367 struct dasd_cuir_message *cuir) 6368{ 6369 struct dasd_conf_data *conf_data; 6370 int path, pos; 6371 6372 if (cuir->record_selector == 0) 6373 goto out; 6374 for (path = 0x80, pos = 0; path; path >>= 1, pos++) { 6375 conf_data = device->path[pos].conf_data; 6376 if (conf_data->gneq.record_selector == 6377 cuir->record_selector) 6378 return conf_data; 6379 } 6380out: 6381 return device->path[pathmask_to_pos(lpum)].conf_data; 6382} 6383 6384/* 6385 * This function determines the scope of a reconfiguration request by 6386 * analysing the path and device selection data provided in the CUIR request. 6387 * Returns a path mask containing CUIR affected paths for the give device. 6388 * 6389 * If the CUIR request does not contain the required information return the 6390 * path mask of the path the attention message for the CUIR request was reveived 6391 * on. 6392 */ 6393static int dasd_eckd_cuir_scope(struct dasd_device *device, __u8 lpum, 6394 struct dasd_cuir_message *cuir) 6395{ 6396 struct dasd_conf_data *ref_conf_data; 6397 unsigned long bitmask = 0, mask = 0; 6398 struct dasd_conf_data *conf_data; 6399 unsigned int pos, path; 6400 char *ref_gneq, *gneq; 6401 char *ref_ned, *ned; 6402 int tbcpm = 0; 6403 6404 /* if CUIR request does not specify the scope use the path 6405 the attention message was presented on */ 6406 if (!cuir->ned_map || 6407 !(cuir->neq_map[0] | cuir->neq_map[1] | cuir->neq_map[2])) 6408 return lpum; 6409 6410 /* get reference conf data */ 6411 ref_conf_data = dasd_eckd_get_ref_conf(device, lpum, cuir); 6412 /* reference ned is determined by ned_map field */ 6413 pos = 8 - ffs(cuir->ned_map); 6414 ref_ned = (char *)&ref_conf_data->neds[pos]; 6415 ref_gneq = (char *)&ref_conf_data->gneq; 6416 /* transfer 24 bit neq_map to mask */ 6417 mask = cuir->neq_map[2]; 6418 mask |= cuir->neq_map[1] << 8; 6419 mask |= cuir->neq_map[0] << 16; 6420 6421 for (path = 0; path < 8; path++) { 6422 /* initialise data per path */ 6423 bitmask = mask; 6424 conf_data = device->path[path].conf_data; 6425 pos = 8 - ffs(cuir->ned_map); 6426 ned = (char *) &conf_data->neds[pos]; 6427 /* compare reference ned and per path ned */ 6428 if (memcmp(ref_ned, ned, sizeof(*ned)) != 0) 6429 continue; 6430 gneq = (char *)&conf_data->gneq; 6431 /* compare reference gneq and per_path gneq under 6432 24 bit mask where mask bit 0 equals byte 7 of 6433 the gneq and mask bit 24 equals byte 31 */ 6434 while (bitmask) { 6435 pos = ffs(bitmask) - 1; 6436 if (memcmp(&ref_gneq[31 - pos], &gneq[31 - pos], 1) 6437 != 0) 6438 break; 6439 clear_bit(pos, &bitmask); 6440 } 6441 if (bitmask) 6442 continue; 6443 /* device and path match the reference values 6444 add path to CUIR scope */ 6445 tbcpm |= 0x80 >> path; 6446 } 6447 return tbcpm; 6448} 6449 6450static void dasd_eckd_cuir_notify_user(struct dasd_device *device, 6451 unsigned long paths, int action) 6452{ 6453 int pos; 6454 6455 while (paths) { 6456 /* get position of bit in mask */ 6457 pos = 8 - ffs(paths); 6458 /* get channel path descriptor from this position */ 6459 if (action == CUIR_QUIESCE) 6460 pr_warn("Service on the storage server caused path %x.%02x to go offline", 6461 device->path[pos].cssid, 6462 device->path[pos].chpid); 6463 else if (action == CUIR_RESUME) 6464 pr_info("Path %x.%02x is back online after service on the storage server", 6465 device->path[pos].cssid, 6466 device->path[pos].chpid); 6467 clear_bit(7 - pos, &paths); 6468 } 6469} 6470 6471static int dasd_eckd_cuir_remove_path(struct dasd_device *device, __u8 lpum, 6472 struct dasd_cuir_message *cuir) 6473{ 6474 unsigned long tbcpm; 6475 6476 tbcpm = dasd_eckd_cuir_scope(device, lpum, cuir); 6477 /* nothing to do if path is not in use */ 6478 if (!(dasd_path_get_opm(device) & tbcpm)) 6479 return 0; 6480 if (!(dasd_path_get_opm(device) & ~tbcpm)) { 6481 /* no path would be left if the CUIR action is taken 6482 return error */ 6483 return -EINVAL; 6484 } 6485 /* remove device from operational path mask */ 6486 dasd_path_remove_opm(device, tbcpm); 6487 dasd_path_add_cuirpm(device, tbcpm); 6488 return tbcpm; 6489} 6490 6491/* 6492 * walk through all devices and build a path mask to quiesce them 6493 * return an error if the last path to a device would be removed 6494 * 6495 * if only part of the devices are quiesced and an error 6496 * occurs no onlining necessary, the storage server will 6497 * notify the already set offline devices again 6498 */ 6499static int dasd_eckd_cuir_quiesce(struct dasd_device *device, __u8 lpum, 6500 struct dasd_cuir_message *cuir) 6501{ 6502 struct dasd_eckd_private *private = device->private; 6503 struct alias_pav_group *pavgroup, *tempgroup; 6504 struct dasd_device *dev, *n; 6505 unsigned long paths = 0; 6506 unsigned long flags; 6507 int tbcpm; 6508 6509 /* active devices */ 6510 list_for_each_entry_safe(dev, n, &private->lcu->active_devices, 6511 alias_list) { 6512 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags); 6513 tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir); 6514 spin_unlock_irqrestore(get_ccwdev_lock(dev->cdev), flags); 6515 if (tbcpm < 0) 6516 goto out_err; 6517 paths |= tbcpm; 6518 } 6519 /* inactive devices */ 6520 list_for_each_entry_safe(dev, n, &private->lcu->inactive_devices, 6521 alias_list) { 6522 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags); 6523 tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir); 6524 spin_unlock_irqrestore(get_ccwdev_lock(dev->cdev), flags); 6525 if (tbcpm < 0) 6526 goto out_err; 6527 paths |= tbcpm; 6528 } 6529 /* devices in PAV groups */ 6530 list_for_each_entry_safe(pavgroup, tempgroup, 6531 &private->lcu->grouplist, group) { 6532 list_for_each_entry_safe(dev, n, &pavgroup->baselist, 6533 alias_list) { 6534 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags); 6535 tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir); 6536 spin_unlock_irqrestore( 6537 get_ccwdev_lock(dev->cdev), flags); 6538 if (tbcpm < 0) 6539 goto out_err; 6540 paths |= tbcpm; 6541 } 6542 list_for_each_entry_safe(dev, n, &pavgroup->aliaslist, 6543 alias_list) { 6544 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags); 6545 tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir); 6546 spin_unlock_irqrestore( 6547 get_ccwdev_lock(dev->cdev), flags); 6548 if (tbcpm < 0) 6549 goto out_err; 6550 paths |= tbcpm; 6551 } 6552 } 6553 /* notify user about all paths affected by CUIR action */ 6554 dasd_eckd_cuir_notify_user(device, paths, CUIR_QUIESCE); 6555 return 0; 6556out_err: 6557 return tbcpm; 6558} 6559 6560static int dasd_eckd_cuir_resume(struct dasd_device *device, __u8 lpum, 6561 struct dasd_cuir_message *cuir) 6562{ 6563 struct dasd_eckd_private *private = device->private; 6564 struct alias_pav_group *pavgroup, *tempgroup; 6565 struct dasd_device *dev, *n; 6566 unsigned long paths = 0; 6567 int tbcpm; 6568 6569 /* 6570 * the path may have been added through a generic path event before 6571 * only trigger path verification if the path is not already in use 6572 */ 6573 list_for_each_entry_safe(dev, n, 6574 &private->lcu->active_devices, 6575 alias_list) { 6576 tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir); 6577 paths |= tbcpm; 6578 if (!(dasd_path_get_opm(dev) & tbcpm)) { 6579 dasd_path_add_tbvpm(dev, tbcpm); 6580 dasd_schedule_device_bh(dev); 6581 } 6582 } 6583 list_for_each_entry_safe(dev, n, 6584 &private->lcu->inactive_devices, 6585 alias_list) { 6586 tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir); 6587 paths |= tbcpm; 6588 if (!(dasd_path_get_opm(dev) & tbcpm)) { 6589 dasd_path_add_tbvpm(dev, tbcpm); 6590 dasd_schedule_device_bh(dev); 6591 } 6592 } 6593 /* devices in PAV groups */ 6594 list_for_each_entry_safe(pavgroup, tempgroup, 6595 &private->lcu->grouplist, 6596 group) { 6597 list_for_each_entry_safe(dev, n, 6598 &pavgroup->baselist, 6599 alias_list) { 6600 tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir); 6601 paths |= tbcpm; 6602 if (!(dasd_path_get_opm(dev) & tbcpm)) { 6603 dasd_path_add_tbvpm(dev, tbcpm); 6604 dasd_schedule_device_bh(dev); 6605 } 6606 } 6607 list_for_each_entry_safe(dev, n, 6608 &pavgroup->aliaslist, 6609 alias_list) { 6610 tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir); 6611 paths |= tbcpm; 6612 if (!(dasd_path_get_opm(dev) & tbcpm)) { 6613 dasd_path_add_tbvpm(dev, tbcpm); 6614 dasd_schedule_device_bh(dev); 6615 } 6616 } 6617 } 6618 /* notify user about all paths affected by CUIR action */ 6619 dasd_eckd_cuir_notify_user(device, paths, CUIR_RESUME); 6620 return 0; 6621} 6622 6623static void dasd_eckd_handle_cuir(struct dasd_device *device, void *messages, 6624 __u8 lpum) 6625{ 6626 struct dasd_cuir_message *cuir = messages; 6627 int response; 6628 6629 DBF_DEV_EVENT(DBF_WARNING, device, 6630 "CUIR request: %016llx %016llx %016llx %08x", 6631 ((u64 *)cuir)[0], ((u64 *)cuir)[1], ((u64 *)cuir)[2], 6632 ((u32 *)cuir)[3]); 6633 6634 if (cuir->code == CUIR_QUIESCE) { 6635 /* quiesce */ 6636 if (dasd_eckd_cuir_quiesce(device, lpum, cuir)) 6637 response = PSF_CUIR_LAST_PATH; 6638 else 6639 response = PSF_CUIR_COMPLETED; 6640 } else if (cuir->code == CUIR_RESUME) { 6641 /* resume */ 6642 dasd_eckd_cuir_resume(device, lpum, cuir); 6643 response = PSF_CUIR_COMPLETED; 6644 } else 6645 response = PSF_CUIR_NOT_SUPPORTED; 6646 6647 dasd_eckd_psf_cuir_response(device, response, 6648 cuir->message_id, lpum); 6649 DBF_DEV_EVENT(DBF_WARNING, device, 6650 "CUIR response: %d on message ID %08x", response, 6651 cuir->message_id); 6652 /* to make sure there is no attention left schedule work again */ 6653 device->discipline->check_attention(device, lpum); 6654} 6655 6656static void dasd_eckd_oos_resume(struct dasd_device *device) 6657{ 6658 struct dasd_eckd_private *private = device->private; 6659 struct alias_pav_group *pavgroup, *tempgroup; 6660 struct dasd_device *dev, *n; 6661 unsigned long flags; 6662 6663 spin_lock_irqsave(&private->lcu->lock, flags); 6664 list_for_each_entry_safe(dev, n, &private->lcu->active_devices, 6665 alias_list) { 6666 if (dev->stopped & DASD_STOPPED_NOSPC) 6667 dasd_generic_space_avail(dev); 6668 } 6669 list_for_each_entry_safe(dev, n, &private->lcu->inactive_devices, 6670 alias_list) { 6671 if (dev->stopped & DASD_STOPPED_NOSPC) 6672 dasd_generic_space_avail(dev); 6673 } 6674 /* devices in PAV groups */ 6675 list_for_each_entry_safe(pavgroup, tempgroup, 6676 &private->lcu->grouplist, 6677 group) { 6678 list_for_each_entry_safe(dev, n, &pavgroup->baselist, 6679 alias_list) { 6680 if (dev->stopped & DASD_STOPPED_NOSPC) 6681 dasd_generic_space_avail(dev); 6682 } 6683 list_for_each_entry_safe(dev, n, &pavgroup->aliaslist, 6684 alias_list) { 6685 if (dev->stopped & DASD_STOPPED_NOSPC) 6686 dasd_generic_space_avail(dev); 6687 } 6688 } 6689 spin_unlock_irqrestore(&private->lcu->lock, flags); 6690} 6691 6692static void dasd_eckd_handle_oos(struct dasd_device *device, void *messages, 6693 __u8 lpum) 6694{ 6695 struct dasd_oos_message *oos = messages; 6696 6697 switch (oos->code) { 6698 case REPO_WARN: 6699 case POOL_WARN: 6700 dev_warn(&device->cdev->dev, 6701 "Extent pool usage has reached a critical value\n"); 6702 dasd_eckd_oos_resume(device); 6703 break; 6704 case REPO_EXHAUST: 6705 case POOL_EXHAUST: 6706 dev_warn(&device->cdev->dev, 6707 "Extent pool is exhausted\n"); 6708 break; 6709 case REPO_RELIEVE: 6710 case POOL_RELIEVE: 6711 dev_info(&device->cdev->dev, 6712 "Extent pool physical space constraint has been relieved\n"); 6713 break; 6714 } 6715 6716 /* In any case, update related data */ 6717 dasd_eckd_read_ext_pool_info(device); 6718 6719 /* to make sure there is no attention left schedule work again */ 6720 device->discipline->check_attention(device, lpum); 6721} 6722 6723static void dasd_eckd_check_attention_work(struct work_struct *work) 6724{ 6725 struct check_attention_work_data *data; 6726 struct dasd_rssd_messages *messages; 6727 struct dasd_device *device; 6728 int rc; 6729 6730 data = container_of(work, struct check_attention_work_data, worker); 6731 device = data->device; 6732 messages = kzalloc(sizeof(*messages), GFP_KERNEL); 6733 if (!messages) { 6734 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 6735 "Could not allocate attention message buffer"); 6736 goto out; 6737 } 6738 rc = dasd_eckd_read_message_buffer(device, messages, data->lpum); 6739 if (rc) 6740 goto out; 6741 6742 if (messages->length == ATTENTION_LENGTH_CUIR && 6743 messages->format == ATTENTION_FORMAT_CUIR) 6744 dasd_eckd_handle_cuir(device, messages, data->lpum); 6745 if (messages->length == ATTENTION_LENGTH_OOS && 6746 messages->format == ATTENTION_FORMAT_OOS) 6747 dasd_eckd_handle_oos(device, messages, data->lpum); 6748 6749out: 6750 dasd_put_device(device); 6751 kfree(messages); 6752 kfree(data); 6753} 6754 6755static int dasd_eckd_check_attention(struct dasd_device *device, __u8 lpum) 6756{ 6757 struct check_attention_work_data *data; 6758 6759 data = kzalloc(sizeof(*data), GFP_ATOMIC); 6760 if (!data) 6761 return -ENOMEM; 6762 INIT_WORK(&data->worker, dasd_eckd_check_attention_work); 6763 dasd_get_device(device); 6764 data->device = device; 6765 data->lpum = lpum; 6766 schedule_work(&data->worker); 6767 return 0; 6768} 6769 6770static int dasd_eckd_disable_hpf_path(struct dasd_device *device, __u8 lpum) 6771{ 6772 if (~lpum & dasd_path_get_opm(device)) { 6773 dasd_path_add_nohpfpm(device, lpum); 6774 dasd_path_remove_opm(device, lpum); 6775 dev_err(&device->cdev->dev, 6776 "Channel path %02X lost HPF functionality and is disabled\n", 6777 lpum); 6778 return 1; 6779 } 6780 return 0; 6781} 6782 6783static void dasd_eckd_disable_hpf_device(struct dasd_device *device) 6784{ 6785 struct dasd_eckd_private *private = device->private; 6786 6787 dev_err(&device->cdev->dev, 6788 "High Performance FICON disabled\n"); 6789 private->fcx_max_data = 0; 6790} 6791 6792static int dasd_eckd_hpf_enabled(struct dasd_device *device) 6793{ 6794 struct dasd_eckd_private *private = device->private; 6795 6796 return private->fcx_max_data ? 1 : 0; 6797} 6798 6799static void dasd_eckd_handle_hpf_error(struct dasd_device *device, 6800 struct irb *irb) 6801{ 6802 struct dasd_eckd_private *private = device->private; 6803 6804 if (!private->fcx_max_data) { 6805 /* sanity check for no HPF, the error makes no sense */ 6806 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 6807 "Trying to disable HPF for a non HPF device"); 6808 return; 6809 } 6810 if (irb->scsw.tm.sesq == SCSW_SESQ_DEV_NOFCX) { 6811 dasd_eckd_disable_hpf_device(device); 6812 } else if (irb->scsw.tm.sesq == SCSW_SESQ_PATH_NOFCX) { 6813 if (dasd_eckd_disable_hpf_path(device, irb->esw.esw1.lpum)) 6814 return; 6815 dasd_eckd_disable_hpf_device(device); 6816 dasd_path_set_tbvpm(device, 6817 dasd_path_get_hpfpm(device)); 6818 } 6819 /* 6820 * prevent that any new I/O ist started on the device and schedule a 6821 * requeue of existing requests 6822 */ 6823 dasd_device_set_stop_bits(device, DASD_STOPPED_NOT_ACC); 6824 dasd_schedule_requeue(device); 6825} 6826 6827static unsigned int dasd_eckd_max_sectors(struct dasd_block *block) 6828{ 6829 if (block->base->features & DASD_FEATURE_USERAW) { 6830 /* 6831 * the max_blocks value for raw_track access is 256 6832 * it is higher than the native ECKD value because we 6833 * only need one ccw per track 6834 * so the max_hw_sectors are 6835 * 2048 x 512B = 1024kB = 16 tracks 6836 */ 6837 return DASD_ECKD_MAX_BLOCKS_RAW << block->s2b_shift; 6838 } 6839 6840 return DASD_ECKD_MAX_BLOCKS << block->s2b_shift; 6841} 6842 6843static struct ccw_driver dasd_eckd_driver = { 6844 .driver = { 6845 .name = "dasd-eckd", 6846 .owner = THIS_MODULE, 6847 .dev_groups = dasd_dev_groups, 6848 }, 6849 .ids = dasd_eckd_ids, 6850 .probe = dasd_eckd_probe, 6851 .remove = dasd_generic_remove, 6852 .set_offline = dasd_generic_set_offline, 6853 .set_online = dasd_eckd_set_online, 6854 .notify = dasd_generic_notify, 6855 .path_event = dasd_generic_path_event, 6856 .shutdown = dasd_generic_shutdown, 6857 .uc_handler = dasd_generic_uc_handler, 6858 .int_class = IRQIO_DAS, 6859}; 6860 6861static struct dasd_discipline dasd_eckd_discipline = { 6862 .owner = THIS_MODULE, 6863 .name = "ECKD", 6864 .ebcname = "ECKD", 6865 .check_device = dasd_eckd_check_characteristics, 6866 .uncheck_device = dasd_eckd_uncheck_device, 6867 .do_analysis = dasd_eckd_do_analysis, 6868 .pe_handler = dasd_eckd_pe_handler, 6869 .basic_to_ready = dasd_eckd_basic_to_ready, 6870 .online_to_ready = dasd_eckd_online_to_ready, 6871 .basic_to_known = dasd_eckd_basic_to_known, 6872 .max_sectors = dasd_eckd_max_sectors, 6873 .fill_geometry = dasd_eckd_fill_geometry, 6874 .start_IO = dasd_start_IO, 6875 .term_IO = dasd_term_IO, 6876 .handle_terminated_request = dasd_eckd_handle_terminated_request, 6877 .format_device = dasd_eckd_format_device, 6878 .check_device_format = dasd_eckd_check_device_format, 6879 .erp_action = dasd_eckd_erp_action, 6880 .erp_postaction = dasd_eckd_erp_postaction, 6881 .check_for_device_change = dasd_eckd_check_for_device_change, 6882 .build_cp = dasd_eckd_build_alias_cp, 6883 .free_cp = dasd_eckd_free_alias_cp, 6884 .dump_sense = dasd_eckd_dump_sense, 6885 .dump_sense_dbf = dasd_eckd_dump_sense_dbf, 6886 .fill_info = dasd_eckd_fill_info, 6887 .ioctl = dasd_eckd_ioctl, 6888 .reload = dasd_eckd_reload_device, 6889 .get_uid = dasd_eckd_get_uid, 6890 .kick_validate = dasd_eckd_kick_validate_server, 6891 .check_attention = dasd_eckd_check_attention, 6892 .host_access_count = dasd_eckd_host_access_count, 6893 .hosts_print = dasd_hosts_print, 6894 .handle_hpf_error = dasd_eckd_handle_hpf_error, 6895 .disable_hpf = dasd_eckd_disable_hpf_device, 6896 .hpf_enabled = dasd_eckd_hpf_enabled, 6897 .reset_path = dasd_eckd_reset_path, 6898 .is_ese = dasd_eckd_is_ese, 6899 .space_allocated = dasd_eckd_space_allocated, 6900 .space_configured = dasd_eckd_space_configured, 6901 .logical_capacity = dasd_eckd_logical_capacity, 6902 .release_space = dasd_eckd_release_space, 6903 .ext_pool_id = dasd_eckd_ext_pool_id, 6904 .ext_size = dasd_eckd_ext_size, 6905 .ext_pool_cap_at_warnlevel = dasd_eckd_ext_pool_cap_at_warnlevel, 6906 .ext_pool_warn_thrshld = dasd_eckd_ext_pool_warn_thrshld, 6907 .ext_pool_oos = dasd_eckd_ext_pool_oos, 6908 .ext_pool_exhaust = dasd_eckd_ext_pool_exhaust, 6909 .ese_format = dasd_eckd_ese_format, 6910 .ese_read = dasd_eckd_ese_read, 6911 .pprc_status = dasd_eckd_query_pprc_status, 6912 .pprc_enabled = dasd_eckd_pprc_enabled, 6913 .copy_pair_swap = dasd_eckd_copy_pair_swap, 6914 .device_ping = dasd_eckd_device_ping, 6915}; 6916 6917static int __init 6918dasd_eckd_init(void) 6919{ 6920 int ret; 6921 6922 ASCEBC(dasd_eckd_discipline.ebcname, 4); 6923 dasd_reserve_req = kmalloc(sizeof(*dasd_reserve_req), 6924 GFP_KERNEL | GFP_DMA); 6925 if (!dasd_reserve_req) 6926 return -ENOMEM; 6927 dasd_vol_info_req = kmalloc(sizeof(*dasd_vol_info_req), 6928 GFP_KERNEL | GFP_DMA); 6929 if (!dasd_vol_info_req) { 6930 kfree(dasd_reserve_req); 6931 return -ENOMEM; 6932 } 6933 pe_handler_worker = kmalloc(sizeof(*pe_handler_worker), 6934 GFP_KERNEL | GFP_DMA); 6935 if (!pe_handler_worker) { 6936 kfree(dasd_reserve_req); 6937 kfree(dasd_vol_info_req); 6938 return -ENOMEM; 6939 } 6940 rawpadpage = (void *)__get_free_page(GFP_KERNEL); 6941 if (!rawpadpage) { 6942 kfree(pe_handler_worker); 6943 kfree(dasd_reserve_req); 6944 kfree(dasd_vol_info_req); 6945 return -ENOMEM; 6946 } 6947 ret = ccw_driver_register(&dasd_eckd_driver); 6948 if (!ret) 6949 wait_for_device_probe(); 6950 else { 6951 kfree(pe_handler_worker); 6952 kfree(dasd_reserve_req); 6953 kfree(dasd_vol_info_req); 6954 free_page((unsigned long)rawpadpage); 6955 } 6956 return ret; 6957} 6958 6959static void __exit 6960dasd_eckd_cleanup(void) 6961{ 6962 ccw_driver_unregister(&dasd_eckd_driver); 6963 kfree(pe_handler_worker); 6964 kfree(dasd_reserve_req); 6965 free_page((unsigned long)rawpadpage); 6966} 6967 6968module_init(dasd_eckd_init); 6969module_exit(dasd_eckd_cleanup); 6970