1 /* 2 * PAV alias management for the DASD ECKD discipline 3 * 4 * Copyright IBM Corp. 2007 5 * Author(s): Stefan Weinhuber <wein@de.ibm.com> 6 */ 7 8 #define KMSG_COMPONENT "dasd-eckd" 9 10 #include <linux/list.h> 11 #include <linux/slab.h> 12 #include <asm/ebcdic.h> 13 #include "dasd_int.h" 14 #include "dasd_eckd.h" 15 16 #ifdef PRINTK_HEADER 17 #undef PRINTK_HEADER 18 #endif /* PRINTK_HEADER */ 19 #define PRINTK_HEADER "dasd(eckd):" 20 21 22 /* 23 * General concept of alias management: 24 * - PAV and DASD alias management is specific to the eckd discipline. 25 * - A device is connected to an lcu as long as the device exists. 26 * dasd_alias_make_device_known_to_lcu will be called wenn the 27 * device is checked by the eckd discipline and 28 * dasd_alias_disconnect_device_from_lcu will be called 29 * before the device is deleted. 30 * - The dasd_alias_add_device / dasd_alias_remove_device 31 * functions mark the point when a device is 'ready for service'. 32 * - A summary unit check is a rare occasion, but it is mandatory to 33 * support it. It requires some complex recovery actions before the 34 * devices can be used again (see dasd_alias_handle_summary_unit_check). 35 * - dasd_alias_get_start_dev will find an alias device that can be used 36 * instead of the base device and does some (very simple) load balancing. 37 * This is the function that gets called for each I/O, so when improving 38 * something, this function should get faster or better, the rest has just 39 * to be correct. 40 */ 41 42 43 static void summary_unit_check_handling_work(struct work_struct *); 44 static void lcu_update_work(struct work_struct *); 45 static int _schedule_lcu_update(struct alias_lcu *, struct dasd_device *); 46 47 static struct alias_root aliastree = { 48 .serverlist = LIST_HEAD_INIT(aliastree.serverlist), 49 .lock = __SPIN_LOCK_UNLOCKED(aliastree.lock), 50 }; 51 52 static struct alias_server *_find_server(struct dasd_uid *uid) 53 { 54 struct alias_server *pos; 55 list_for_each_entry(pos, &aliastree.serverlist, server) { 56 if (!strncmp(pos->uid.vendor, uid->vendor, 57 sizeof(uid->vendor)) 58 && !strncmp(pos->uid.serial, uid->serial, 59 sizeof(uid->serial))) 60 return pos; 61 } 62 return NULL; 63 } 64 65 static struct alias_lcu *_find_lcu(struct alias_server *server, 66 struct dasd_uid *uid) 67 { 68 struct alias_lcu *pos; 69 list_for_each_entry(pos, &server->lculist, lcu) { 70 if (pos->uid.ssid == uid->ssid) 71 return pos; 72 } 73 return NULL; 74 } 75 76 static struct alias_pav_group *_find_group(struct alias_lcu *lcu, 77 struct dasd_uid *uid) 78 { 79 struct alias_pav_group *pos; 80 __u8 search_unit_addr; 81 82 /* for hyper pav there is only one group */ 83 if (lcu->pav == HYPER_PAV) { 84 if (list_empty(&lcu->grouplist)) 85 return NULL; 86 else 87 return list_first_entry(&lcu->grouplist, 88 struct alias_pav_group, group); 89 } 90 91 /* for base pav we have to find the group that matches the base */ 92 if (uid->type == UA_BASE_DEVICE) 93 search_unit_addr = uid->real_unit_addr; 94 else 95 search_unit_addr = uid->base_unit_addr; 96 list_for_each_entry(pos, &lcu->grouplist, group) { 97 if (pos->uid.base_unit_addr == search_unit_addr && 98 !strncmp(pos->uid.vduit, uid->vduit, sizeof(uid->vduit))) 99 return pos; 100 } 101 return NULL; 102 } 103 104 static struct alias_server *_allocate_server(struct dasd_uid *uid) 105 { 106 struct alias_server *server; 107 108 server = kzalloc(sizeof(*server), GFP_KERNEL); 109 if (!server) 110 return ERR_PTR(-ENOMEM); 111 memcpy(server->uid.vendor, uid->vendor, sizeof(uid->vendor)); 112 memcpy(server->uid.serial, uid->serial, sizeof(uid->serial)); 113 INIT_LIST_HEAD(&server->server); 114 INIT_LIST_HEAD(&server->lculist); 115 return server; 116 } 117 118 static void _free_server(struct alias_server *server) 119 { 120 kfree(server); 121 } 122 123 static struct alias_lcu *_allocate_lcu(struct dasd_uid *uid) 124 { 125 struct alias_lcu *lcu; 126 127 lcu = kzalloc(sizeof(*lcu), GFP_KERNEL); 128 if (!lcu) 129 return ERR_PTR(-ENOMEM); 130 lcu->uac = kzalloc(sizeof(*(lcu->uac)), GFP_KERNEL | GFP_DMA); 131 if (!lcu->uac) 132 goto out_err1; 133 lcu->rsu_cqr = kzalloc(sizeof(*lcu->rsu_cqr), GFP_KERNEL | GFP_DMA); 134 if (!lcu->rsu_cqr) 135 goto out_err2; 136 lcu->rsu_cqr->cpaddr = kzalloc(sizeof(struct ccw1), 137 GFP_KERNEL | GFP_DMA); 138 if (!lcu->rsu_cqr->cpaddr) 139 goto out_err3; 140 lcu->rsu_cqr->data = kzalloc(16, GFP_KERNEL | GFP_DMA); 141 if (!lcu->rsu_cqr->data) 142 goto out_err4; 143 144 memcpy(lcu->uid.vendor, uid->vendor, sizeof(uid->vendor)); 145 memcpy(lcu->uid.serial, uid->serial, sizeof(uid->serial)); 146 lcu->uid.ssid = uid->ssid; 147 lcu->pav = NO_PAV; 148 lcu->flags = NEED_UAC_UPDATE | UPDATE_PENDING; 149 INIT_LIST_HEAD(&lcu->lcu); 150 INIT_LIST_HEAD(&lcu->inactive_devices); 151 INIT_LIST_HEAD(&lcu->active_devices); 152 INIT_LIST_HEAD(&lcu->grouplist); 153 INIT_WORK(&lcu->suc_data.worker, summary_unit_check_handling_work); 154 INIT_DELAYED_WORK(&lcu->ruac_data.dwork, lcu_update_work); 155 spin_lock_init(&lcu->lock); 156 init_completion(&lcu->lcu_setup); 157 return lcu; 158 159 out_err4: 160 kfree(lcu->rsu_cqr->cpaddr); 161 out_err3: 162 kfree(lcu->rsu_cqr); 163 out_err2: 164 kfree(lcu->uac); 165 out_err1: 166 kfree(lcu); 167 return ERR_PTR(-ENOMEM); 168 } 169 170 static void _free_lcu(struct alias_lcu *lcu) 171 { 172 kfree(lcu->rsu_cqr->data); 173 kfree(lcu->rsu_cqr->cpaddr); 174 kfree(lcu->rsu_cqr); 175 kfree(lcu->uac); 176 kfree(lcu); 177 } 178 179 /* 180 * This is the function that will allocate all the server and lcu data, 181 * so this function must be called first for a new device. 182 * If the return value is 1, the lcu was already known before, if it 183 * is 0, this is a new lcu. 184 * Negative return code indicates that something went wrong (e.g. -ENOMEM) 185 */ 186 int dasd_alias_make_device_known_to_lcu(struct dasd_device *device) 187 { 188 struct dasd_eckd_private *private; 189 unsigned long flags; 190 struct alias_server *server, *newserver; 191 struct alias_lcu *lcu, *newlcu; 192 struct dasd_uid uid; 193 194 private = (struct dasd_eckd_private *) device->private; 195 196 device->discipline->get_uid(device, &uid); 197 spin_lock_irqsave(&aliastree.lock, flags); 198 server = _find_server(&uid); 199 if (!server) { 200 spin_unlock_irqrestore(&aliastree.lock, flags); 201 newserver = _allocate_server(&uid); 202 if (IS_ERR(newserver)) 203 return PTR_ERR(newserver); 204 spin_lock_irqsave(&aliastree.lock, flags); 205 server = _find_server(&uid); 206 if (!server) { 207 list_add(&newserver->server, &aliastree.serverlist); 208 server = newserver; 209 } else { 210 /* someone was faster */ 211 _free_server(newserver); 212 } 213 } 214 215 lcu = _find_lcu(server, &uid); 216 if (!lcu) { 217 spin_unlock_irqrestore(&aliastree.lock, flags); 218 newlcu = _allocate_lcu(&uid); 219 if (IS_ERR(newlcu)) 220 return PTR_ERR(newlcu); 221 spin_lock_irqsave(&aliastree.lock, flags); 222 lcu = _find_lcu(server, &uid); 223 if (!lcu) { 224 list_add(&newlcu->lcu, &server->lculist); 225 lcu = newlcu; 226 } else { 227 /* someone was faster */ 228 _free_lcu(newlcu); 229 } 230 } 231 spin_lock(&lcu->lock); 232 list_add(&device->alias_list, &lcu->inactive_devices); 233 private->lcu = lcu; 234 spin_unlock(&lcu->lock); 235 spin_unlock_irqrestore(&aliastree.lock, flags); 236 237 return 0; 238 } 239 240 /* 241 * This function removes a device from the scope of alias management. 242 * The complicated part is to make sure that it is not in use by 243 * any of the workers. If necessary cancel the work. 244 */ 245 void dasd_alias_disconnect_device_from_lcu(struct dasd_device *device) 246 { 247 struct dasd_eckd_private *private; 248 unsigned long flags; 249 struct alias_lcu *lcu; 250 struct alias_server *server; 251 int was_pending; 252 struct dasd_uid uid; 253 254 private = (struct dasd_eckd_private *) device->private; 255 lcu = private->lcu; 256 /* nothing to do if already disconnected */ 257 if (!lcu) 258 return; 259 device->discipline->get_uid(device, &uid); 260 spin_lock_irqsave(&lcu->lock, flags); 261 list_del_init(&device->alias_list); 262 /* make sure that the workers don't use this device */ 263 if (device == lcu->suc_data.device) { 264 spin_unlock_irqrestore(&lcu->lock, flags); 265 cancel_work_sync(&lcu->suc_data.worker); 266 spin_lock_irqsave(&lcu->lock, flags); 267 if (device == lcu->suc_data.device) { 268 dasd_put_device(device); 269 lcu->suc_data.device = NULL; 270 } 271 } 272 was_pending = 0; 273 if (device == lcu->ruac_data.device) { 274 spin_unlock_irqrestore(&lcu->lock, flags); 275 was_pending = 1; 276 cancel_delayed_work_sync(&lcu->ruac_data.dwork); 277 spin_lock_irqsave(&lcu->lock, flags); 278 if (device == lcu->ruac_data.device) { 279 dasd_put_device(device); 280 lcu->ruac_data.device = NULL; 281 } 282 } 283 private->lcu = NULL; 284 spin_unlock_irqrestore(&lcu->lock, flags); 285 286 spin_lock_irqsave(&aliastree.lock, flags); 287 spin_lock(&lcu->lock); 288 if (list_empty(&lcu->grouplist) && 289 list_empty(&lcu->active_devices) && 290 list_empty(&lcu->inactive_devices)) { 291 list_del(&lcu->lcu); 292 spin_unlock(&lcu->lock); 293 _free_lcu(lcu); 294 lcu = NULL; 295 } else { 296 if (was_pending) 297 _schedule_lcu_update(lcu, NULL); 298 spin_unlock(&lcu->lock); 299 } 300 server = _find_server(&uid); 301 if (server && list_empty(&server->lculist)) { 302 list_del(&server->server); 303 _free_server(server); 304 } 305 spin_unlock_irqrestore(&aliastree.lock, flags); 306 } 307 308 /* 309 * This function assumes that the unit address configuration stored 310 * in the lcu is up to date and will update the device uid before 311 * adding it to a pav group. 312 */ 313 314 static int _add_device_to_lcu(struct alias_lcu *lcu, 315 struct dasd_device *device, 316 struct dasd_device *pos) 317 { 318 319 struct dasd_eckd_private *private; 320 struct alias_pav_group *group; 321 struct dasd_uid uid; 322 unsigned long flags; 323 324 private = (struct dasd_eckd_private *) device->private; 325 326 /* only lock if not already locked */ 327 if (device != pos) 328 spin_lock_irqsave_nested(get_ccwdev_lock(device->cdev), flags, 329 CDEV_NESTED_SECOND); 330 private->uid.type = lcu->uac->unit[private->uid.real_unit_addr].ua_type; 331 private->uid.base_unit_addr = 332 lcu->uac->unit[private->uid.real_unit_addr].base_ua; 333 uid = private->uid; 334 335 if (device != pos) 336 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 337 338 /* if we have no PAV anyway, we don't need to bother with PAV groups */ 339 if (lcu->pav == NO_PAV) { 340 list_move(&device->alias_list, &lcu->active_devices); 341 return 0; 342 } 343 344 group = _find_group(lcu, &uid); 345 if (!group) { 346 group = kzalloc(sizeof(*group), GFP_ATOMIC); 347 if (!group) 348 return -ENOMEM; 349 memcpy(group->uid.vendor, uid.vendor, sizeof(uid.vendor)); 350 memcpy(group->uid.serial, uid.serial, sizeof(uid.serial)); 351 group->uid.ssid = uid.ssid; 352 if (uid.type == UA_BASE_DEVICE) 353 group->uid.base_unit_addr = uid.real_unit_addr; 354 else 355 group->uid.base_unit_addr = uid.base_unit_addr; 356 memcpy(group->uid.vduit, uid.vduit, sizeof(uid.vduit)); 357 INIT_LIST_HEAD(&group->group); 358 INIT_LIST_HEAD(&group->baselist); 359 INIT_LIST_HEAD(&group->aliaslist); 360 list_add(&group->group, &lcu->grouplist); 361 } 362 if (uid.type == UA_BASE_DEVICE) 363 list_move(&device->alias_list, &group->baselist); 364 else 365 list_move(&device->alias_list, &group->aliaslist); 366 private->pavgroup = group; 367 return 0; 368 }; 369 370 static void _remove_device_from_lcu(struct alias_lcu *lcu, 371 struct dasd_device *device) 372 { 373 struct dasd_eckd_private *private; 374 struct alias_pav_group *group; 375 376 private = (struct dasd_eckd_private *) device->private; 377 list_move(&device->alias_list, &lcu->inactive_devices); 378 group = private->pavgroup; 379 if (!group) 380 return; 381 private->pavgroup = NULL; 382 if (list_empty(&group->baselist) && list_empty(&group->aliaslist)) { 383 list_del(&group->group); 384 kfree(group); 385 return; 386 } 387 if (group->next == device) 388 group->next = NULL; 389 }; 390 391 static int 392 suborder_not_supported(struct dasd_ccw_req *cqr) 393 { 394 char *sense; 395 char reason; 396 char msg_format; 397 char msg_no; 398 399 sense = dasd_get_sense(&cqr->irb); 400 if (!sense) 401 return 0; 402 403 reason = sense[0]; 404 msg_format = (sense[7] & 0xF0); 405 msg_no = (sense[7] & 0x0F); 406 407 /* command reject, Format 0 MSG 4 - invalid parameter */ 408 if ((reason == 0x80) && (msg_format == 0x00) && (msg_no == 0x04)) 409 return 1; 410 411 return 0; 412 } 413 414 static int read_unit_address_configuration(struct dasd_device *device, 415 struct alias_lcu *lcu) 416 { 417 struct dasd_psf_prssd_data *prssdp; 418 struct dasd_ccw_req *cqr; 419 struct ccw1 *ccw; 420 int rc; 421 unsigned long flags; 422 423 cqr = dasd_kmalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 424 (sizeof(struct dasd_psf_prssd_data)), 425 device); 426 if (IS_ERR(cqr)) 427 return PTR_ERR(cqr); 428 cqr->startdev = device; 429 cqr->memdev = device; 430 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 431 cqr->retries = 10; 432 cqr->expires = 20 * HZ; 433 434 /* Prepare for Read Subsystem Data */ 435 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 436 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 437 prssdp->order = PSF_ORDER_PRSSD; 438 prssdp->suborder = 0x0e; /* Read unit address configuration */ 439 /* all other bytes of prssdp must be zero */ 440 441 ccw = cqr->cpaddr; 442 ccw->cmd_code = DASD_ECKD_CCW_PSF; 443 ccw->count = sizeof(struct dasd_psf_prssd_data); 444 ccw->flags |= CCW_FLAG_CC; 445 ccw->cda = (__u32)(addr_t) prssdp; 446 447 /* Read Subsystem Data - feature codes */ 448 memset(lcu->uac, 0, sizeof(*(lcu->uac))); 449 450 ccw++; 451 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 452 ccw->count = sizeof(*(lcu->uac)); 453 ccw->cda = (__u32)(addr_t) lcu->uac; 454 455 cqr->buildclk = get_tod_clock(); 456 cqr->status = DASD_CQR_FILLED; 457 458 /* need to unset flag here to detect race with summary unit check */ 459 spin_lock_irqsave(&lcu->lock, flags); 460 lcu->flags &= ~NEED_UAC_UPDATE; 461 spin_unlock_irqrestore(&lcu->lock, flags); 462 463 do { 464 rc = dasd_sleep_on(cqr); 465 if (rc && suborder_not_supported(cqr)) 466 return -EOPNOTSUPP; 467 } while (rc && (cqr->retries > 0)); 468 if (rc) { 469 spin_lock_irqsave(&lcu->lock, flags); 470 lcu->flags |= NEED_UAC_UPDATE; 471 spin_unlock_irqrestore(&lcu->lock, flags); 472 } 473 dasd_kfree_request(cqr, cqr->memdev); 474 return rc; 475 } 476 477 static int _lcu_update(struct dasd_device *refdev, struct alias_lcu *lcu) 478 { 479 unsigned long flags; 480 struct alias_pav_group *pavgroup, *tempgroup; 481 struct dasd_device *device, *tempdev; 482 int i, rc; 483 struct dasd_eckd_private *private; 484 485 spin_lock_irqsave(&lcu->lock, flags); 486 list_for_each_entry_safe(pavgroup, tempgroup, &lcu->grouplist, group) { 487 list_for_each_entry_safe(device, tempdev, &pavgroup->baselist, 488 alias_list) { 489 list_move(&device->alias_list, &lcu->active_devices); 490 private = (struct dasd_eckd_private *) device->private; 491 private->pavgroup = NULL; 492 } 493 list_for_each_entry_safe(device, tempdev, &pavgroup->aliaslist, 494 alias_list) { 495 list_move(&device->alias_list, &lcu->active_devices); 496 private = (struct dasd_eckd_private *) device->private; 497 private->pavgroup = NULL; 498 } 499 list_del(&pavgroup->group); 500 kfree(pavgroup); 501 } 502 spin_unlock_irqrestore(&lcu->lock, flags); 503 504 rc = read_unit_address_configuration(refdev, lcu); 505 if (rc) 506 return rc; 507 508 /* need to take cdev lock before lcu lock */ 509 spin_lock_irqsave_nested(get_ccwdev_lock(refdev->cdev), flags, 510 CDEV_NESTED_FIRST); 511 spin_lock(&lcu->lock); 512 lcu->pav = NO_PAV; 513 for (i = 0; i < MAX_DEVICES_PER_LCU; ++i) { 514 switch (lcu->uac->unit[i].ua_type) { 515 case UA_BASE_PAV_ALIAS: 516 lcu->pav = BASE_PAV; 517 break; 518 case UA_HYPER_PAV_ALIAS: 519 lcu->pav = HYPER_PAV; 520 break; 521 } 522 if (lcu->pav != NO_PAV) 523 break; 524 } 525 526 list_for_each_entry_safe(device, tempdev, &lcu->active_devices, 527 alias_list) { 528 _add_device_to_lcu(lcu, device, refdev); 529 } 530 spin_unlock(&lcu->lock); 531 spin_unlock_irqrestore(get_ccwdev_lock(refdev->cdev), flags); 532 return 0; 533 } 534 535 static void lcu_update_work(struct work_struct *work) 536 { 537 struct alias_lcu *lcu; 538 struct read_uac_work_data *ruac_data; 539 struct dasd_device *device; 540 unsigned long flags; 541 int rc; 542 543 ruac_data = container_of(work, struct read_uac_work_data, dwork.work); 544 lcu = container_of(ruac_data, struct alias_lcu, ruac_data); 545 device = ruac_data->device; 546 rc = _lcu_update(device, lcu); 547 /* 548 * Need to check flags again, as there could have been another 549 * prepare_update or a new device a new device while we were still 550 * processing the data 551 */ 552 spin_lock_irqsave(&lcu->lock, flags); 553 if ((rc && (rc != -EOPNOTSUPP)) || (lcu->flags & NEED_UAC_UPDATE)) { 554 DBF_DEV_EVENT(DBF_WARNING, device, "could not update" 555 " alias data in lcu (rc = %d), retry later", rc); 556 if (!schedule_delayed_work(&lcu->ruac_data.dwork, 30*HZ)) 557 dasd_put_device(device); 558 } else { 559 dasd_put_device(device); 560 lcu->ruac_data.device = NULL; 561 lcu->flags &= ~UPDATE_PENDING; 562 } 563 spin_unlock_irqrestore(&lcu->lock, flags); 564 } 565 566 static int _schedule_lcu_update(struct alias_lcu *lcu, 567 struct dasd_device *device) 568 { 569 struct dasd_device *usedev = NULL; 570 struct alias_pav_group *group; 571 572 lcu->flags |= NEED_UAC_UPDATE; 573 if (lcu->ruac_data.device) { 574 /* already scheduled or running */ 575 return 0; 576 } 577 if (device && !list_empty(&device->alias_list)) 578 usedev = device; 579 580 if (!usedev && !list_empty(&lcu->grouplist)) { 581 group = list_first_entry(&lcu->grouplist, 582 struct alias_pav_group, group); 583 if (!list_empty(&group->baselist)) 584 usedev = list_first_entry(&group->baselist, 585 struct dasd_device, 586 alias_list); 587 else if (!list_empty(&group->aliaslist)) 588 usedev = list_first_entry(&group->aliaslist, 589 struct dasd_device, 590 alias_list); 591 } 592 if (!usedev && !list_empty(&lcu->active_devices)) { 593 usedev = list_first_entry(&lcu->active_devices, 594 struct dasd_device, alias_list); 595 } 596 /* 597 * if we haven't found a proper device yet, give up for now, the next 598 * device that will be set active will trigger an lcu update 599 */ 600 if (!usedev) 601 return -EINVAL; 602 dasd_get_device(usedev); 603 lcu->ruac_data.device = usedev; 604 if (!schedule_delayed_work(&lcu->ruac_data.dwork, 0)) 605 dasd_put_device(usedev); 606 return 0; 607 } 608 609 int dasd_alias_add_device(struct dasd_device *device) 610 { 611 struct dasd_eckd_private *private; 612 struct alias_lcu *lcu; 613 unsigned long flags; 614 int rc; 615 616 private = (struct dasd_eckd_private *) device->private; 617 lcu = private->lcu; 618 rc = 0; 619 620 /* need to take cdev lock before lcu lock */ 621 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 622 spin_lock(&lcu->lock); 623 if (!(lcu->flags & UPDATE_PENDING)) { 624 rc = _add_device_to_lcu(lcu, device, device); 625 if (rc) 626 lcu->flags |= UPDATE_PENDING; 627 } 628 if (lcu->flags & UPDATE_PENDING) { 629 list_move(&device->alias_list, &lcu->active_devices); 630 _schedule_lcu_update(lcu, device); 631 } 632 spin_unlock(&lcu->lock); 633 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 634 return rc; 635 } 636 637 int dasd_alias_update_add_device(struct dasd_device *device) 638 { 639 struct dasd_eckd_private *private; 640 private = (struct dasd_eckd_private *) device->private; 641 private->lcu->flags |= UPDATE_PENDING; 642 return dasd_alias_add_device(device); 643 } 644 645 int dasd_alias_remove_device(struct dasd_device *device) 646 { 647 struct dasd_eckd_private *private; 648 struct alias_lcu *lcu; 649 unsigned long flags; 650 651 private = (struct dasd_eckd_private *) device->private; 652 lcu = private->lcu; 653 /* nothing to do if already removed */ 654 if (!lcu) 655 return 0; 656 spin_lock_irqsave(&lcu->lock, flags); 657 _remove_device_from_lcu(lcu, device); 658 spin_unlock_irqrestore(&lcu->lock, flags); 659 return 0; 660 } 661 662 struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *base_device) 663 { 664 665 struct dasd_device *alias_device; 666 struct alias_pav_group *group; 667 struct alias_lcu *lcu; 668 struct dasd_eckd_private *private, *alias_priv; 669 unsigned long flags; 670 671 private = (struct dasd_eckd_private *) base_device->private; 672 group = private->pavgroup; 673 lcu = private->lcu; 674 if (!group || !lcu) 675 return NULL; 676 if (lcu->pav == NO_PAV || 677 lcu->flags & (NEED_UAC_UPDATE | UPDATE_PENDING)) 678 return NULL; 679 if (unlikely(!(private->features.feature[8] & 0x01))) { 680 /* 681 * PAV enabled but prefix not, very unlikely 682 * seems to be a lost pathgroup 683 * use base device to do IO 684 */ 685 DBF_DEV_EVENT(DBF_ERR, base_device, "%s", 686 "Prefix not enabled with PAV enabled\n"); 687 return NULL; 688 } 689 690 spin_lock_irqsave(&lcu->lock, flags); 691 alias_device = group->next; 692 if (!alias_device) { 693 if (list_empty(&group->aliaslist)) { 694 spin_unlock_irqrestore(&lcu->lock, flags); 695 return NULL; 696 } else { 697 alias_device = list_first_entry(&group->aliaslist, 698 struct dasd_device, 699 alias_list); 700 } 701 } 702 if (list_is_last(&alias_device->alias_list, &group->aliaslist)) 703 group->next = list_first_entry(&group->aliaslist, 704 struct dasd_device, alias_list); 705 else 706 group->next = list_first_entry(&alias_device->alias_list, 707 struct dasd_device, alias_list); 708 spin_unlock_irqrestore(&lcu->lock, flags); 709 alias_priv = (struct dasd_eckd_private *) alias_device->private; 710 if ((alias_priv->count < private->count) && !alias_device->stopped && 711 !test_bit(DASD_FLAG_OFFLINE, &alias_device->flags)) 712 return alias_device; 713 else 714 return NULL; 715 } 716 717 /* 718 * Summary unit check handling depends on the way alias devices 719 * are handled so it is done here rather then in dasd_eckd.c 720 */ 721 static int reset_summary_unit_check(struct alias_lcu *lcu, 722 struct dasd_device *device, 723 char reason) 724 { 725 struct dasd_ccw_req *cqr; 726 int rc = 0; 727 struct ccw1 *ccw; 728 729 cqr = lcu->rsu_cqr; 730 strncpy((char *) &cqr->magic, "ECKD", 4); 731 ASCEBC((char *) &cqr->magic, 4); 732 ccw = cqr->cpaddr; 733 ccw->cmd_code = DASD_ECKD_CCW_RSCK; 734 ccw->flags = CCW_FLAG_SLI; 735 ccw->count = 16; 736 ccw->cda = (__u32)(addr_t) cqr->data; 737 ((char *)cqr->data)[0] = reason; 738 739 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 740 cqr->retries = 255; /* set retry counter to enable basic ERP */ 741 cqr->startdev = device; 742 cqr->memdev = device; 743 cqr->block = NULL; 744 cqr->expires = 5 * HZ; 745 cqr->buildclk = get_tod_clock(); 746 cqr->status = DASD_CQR_FILLED; 747 748 rc = dasd_sleep_on_immediatly(cqr); 749 return rc; 750 } 751 752 static void _restart_all_base_devices_on_lcu(struct alias_lcu *lcu) 753 { 754 struct alias_pav_group *pavgroup; 755 struct dasd_device *device; 756 struct dasd_eckd_private *private; 757 unsigned long flags; 758 759 /* active and inactive list can contain alias as well as base devices */ 760 list_for_each_entry(device, &lcu->active_devices, alias_list) { 761 private = (struct dasd_eckd_private *) device->private; 762 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 763 if (private->uid.type != UA_BASE_DEVICE) { 764 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), 765 flags); 766 continue; 767 } 768 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 769 dasd_schedule_block_bh(device->block); 770 dasd_schedule_device_bh(device); 771 } 772 list_for_each_entry(device, &lcu->inactive_devices, alias_list) { 773 private = (struct dasd_eckd_private *) device->private; 774 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 775 if (private->uid.type != UA_BASE_DEVICE) { 776 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), 777 flags); 778 continue; 779 } 780 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 781 dasd_schedule_block_bh(device->block); 782 dasd_schedule_device_bh(device); 783 } 784 list_for_each_entry(pavgroup, &lcu->grouplist, group) { 785 list_for_each_entry(device, &pavgroup->baselist, alias_list) { 786 dasd_schedule_block_bh(device->block); 787 dasd_schedule_device_bh(device); 788 } 789 } 790 } 791 792 static void flush_all_alias_devices_on_lcu(struct alias_lcu *lcu) 793 { 794 struct alias_pav_group *pavgroup; 795 struct dasd_device *device, *temp; 796 struct dasd_eckd_private *private; 797 int rc; 798 unsigned long flags; 799 LIST_HEAD(active); 800 801 /* 802 * Problem here ist that dasd_flush_device_queue may wait 803 * for termination of a request to complete. We can't keep 804 * the lcu lock during that time, so we must assume that 805 * the lists may have changed. 806 * Idea: first gather all active alias devices in a separate list, 807 * then flush the first element of this list unlocked, and afterwards 808 * check if it is still on the list before moving it to the 809 * active_devices list. 810 */ 811 812 spin_lock_irqsave(&lcu->lock, flags); 813 list_for_each_entry_safe(device, temp, &lcu->active_devices, 814 alias_list) { 815 private = (struct dasd_eckd_private *) device->private; 816 if (private->uid.type == UA_BASE_DEVICE) 817 continue; 818 list_move(&device->alias_list, &active); 819 } 820 821 list_for_each_entry(pavgroup, &lcu->grouplist, group) { 822 list_splice_init(&pavgroup->aliaslist, &active); 823 } 824 while (!list_empty(&active)) { 825 device = list_first_entry(&active, struct dasd_device, 826 alias_list); 827 spin_unlock_irqrestore(&lcu->lock, flags); 828 rc = dasd_flush_device_queue(device); 829 spin_lock_irqsave(&lcu->lock, flags); 830 /* 831 * only move device around if it wasn't moved away while we 832 * were waiting for the flush 833 */ 834 if (device == list_first_entry(&active, 835 struct dasd_device, alias_list)) { 836 list_move(&device->alias_list, &lcu->active_devices); 837 private = (struct dasd_eckd_private *) device->private; 838 private->pavgroup = NULL; 839 } 840 } 841 spin_unlock_irqrestore(&lcu->lock, flags); 842 } 843 844 static void __stop_device_on_lcu(struct dasd_device *device, 845 struct dasd_device *pos) 846 { 847 /* If pos == device then device is already locked! */ 848 if (pos == device) { 849 dasd_device_set_stop_bits(pos, DASD_STOPPED_SU); 850 return; 851 } 852 spin_lock(get_ccwdev_lock(pos->cdev)); 853 dasd_device_set_stop_bits(pos, DASD_STOPPED_SU); 854 spin_unlock(get_ccwdev_lock(pos->cdev)); 855 } 856 857 /* 858 * This function is called in interrupt context, so the 859 * cdev lock for device is already locked! 860 */ 861 static void _stop_all_devices_on_lcu(struct alias_lcu *lcu, 862 struct dasd_device *device) 863 { 864 struct alias_pav_group *pavgroup; 865 struct dasd_device *pos; 866 867 list_for_each_entry(pos, &lcu->active_devices, alias_list) 868 __stop_device_on_lcu(device, pos); 869 list_for_each_entry(pos, &lcu->inactive_devices, alias_list) 870 __stop_device_on_lcu(device, pos); 871 list_for_each_entry(pavgroup, &lcu->grouplist, group) { 872 list_for_each_entry(pos, &pavgroup->baselist, alias_list) 873 __stop_device_on_lcu(device, pos); 874 list_for_each_entry(pos, &pavgroup->aliaslist, alias_list) 875 __stop_device_on_lcu(device, pos); 876 } 877 } 878 879 static void _unstop_all_devices_on_lcu(struct alias_lcu *lcu) 880 { 881 struct alias_pav_group *pavgroup; 882 struct dasd_device *device; 883 unsigned long flags; 884 885 list_for_each_entry(device, &lcu->active_devices, alias_list) { 886 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 887 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU); 888 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 889 } 890 891 list_for_each_entry(device, &lcu->inactive_devices, alias_list) { 892 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 893 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU); 894 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 895 } 896 897 list_for_each_entry(pavgroup, &lcu->grouplist, group) { 898 list_for_each_entry(device, &pavgroup->baselist, alias_list) { 899 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 900 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU); 901 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), 902 flags); 903 } 904 list_for_each_entry(device, &pavgroup->aliaslist, alias_list) { 905 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 906 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU); 907 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), 908 flags); 909 } 910 } 911 } 912 913 static void summary_unit_check_handling_work(struct work_struct *work) 914 { 915 struct alias_lcu *lcu; 916 struct summary_unit_check_work_data *suc_data; 917 unsigned long flags; 918 struct dasd_device *device; 919 920 suc_data = container_of(work, struct summary_unit_check_work_data, 921 worker); 922 lcu = container_of(suc_data, struct alias_lcu, suc_data); 923 device = suc_data->device; 924 925 /* 1. flush alias devices */ 926 flush_all_alias_devices_on_lcu(lcu); 927 928 /* 2. reset summary unit check */ 929 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 930 dasd_device_remove_stop_bits(device, 931 (DASD_STOPPED_SU | DASD_STOPPED_PENDING)); 932 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 933 reset_summary_unit_check(lcu, device, suc_data->reason); 934 935 spin_lock_irqsave(&lcu->lock, flags); 936 _unstop_all_devices_on_lcu(lcu); 937 _restart_all_base_devices_on_lcu(lcu); 938 /* 3. read new alias configuration */ 939 _schedule_lcu_update(lcu, device); 940 lcu->suc_data.device = NULL; 941 dasd_put_device(device); 942 spin_unlock_irqrestore(&lcu->lock, flags); 943 } 944 945 /* 946 * note: this will be called from int handler context (cdev locked) 947 */ 948 void dasd_alias_handle_summary_unit_check(struct dasd_device *device, 949 struct irb *irb) 950 { 951 struct alias_lcu *lcu; 952 char reason; 953 struct dasd_eckd_private *private; 954 char *sense; 955 956 private = (struct dasd_eckd_private *) device->private; 957 958 sense = dasd_get_sense(irb); 959 if (sense) { 960 reason = sense[8]; 961 DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x", 962 "eckd handle summary unit check: reason", reason); 963 } else { 964 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 965 "eckd handle summary unit check:" 966 " no reason code available"); 967 return; 968 } 969 970 lcu = private->lcu; 971 if (!lcu) { 972 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 973 "device not ready to handle summary" 974 " unit check (no lcu structure)"); 975 return; 976 } 977 spin_lock(&lcu->lock); 978 _stop_all_devices_on_lcu(lcu, device); 979 /* prepare for lcu_update */ 980 private->lcu->flags |= NEED_UAC_UPDATE | UPDATE_PENDING; 981 /* If this device is about to be removed just return and wait for 982 * the next interrupt on a different device 983 */ 984 if (list_empty(&device->alias_list)) { 985 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 986 "device is in offline processing," 987 " don't do summary unit check handling"); 988 spin_unlock(&lcu->lock); 989 return; 990 } 991 if (lcu->suc_data.device) { 992 /* already scheduled or running */ 993 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 994 "previous instance of summary unit check worker" 995 " still pending"); 996 spin_unlock(&lcu->lock); 997 return ; 998 } 999 lcu->suc_data.reason = reason; 1000 lcu->suc_data.device = device; 1001 dasd_get_device(device); 1002 spin_unlock(&lcu->lock); 1003 if (!schedule_work(&lcu->suc_data.worker)) 1004 dasd_put_device(device); 1005 }; 1006