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