1 /* 2 * File...........: linux/drivers/s390/block/dasd.c 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 */ 10 11 #define KMSG_COMPONENT "dasd" 12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 13 14 #include <linux/kernel_stat.h> 15 #include <linux/kmod.h> 16 #include <linux/init.h> 17 #include <linux/interrupt.h> 18 #include <linux/ctype.h> 19 #include <linux/major.h> 20 #include <linux/slab.h> 21 #include <linux/buffer_head.h> 22 #include <linux/hdreg.h> 23 #include <linux/async.h> 24 #include <linux/mutex.h> 25 26 #include <asm/ccwdev.h> 27 #include <asm/ebcdic.h> 28 #include <asm/idals.h> 29 #include <asm/itcw.h> 30 #include <asm/diag.h> 31 32 /* This is ugly... */ 33 #define PRINTK_HEADER "dasd:" 34 35 #include "dasd_int.h" 36 /* 37 * SECTION: Constant definitions to be used within this file 38 */ 39 #define DASD_CHANQ_MAX_SIZE 4 40 41 #define DASD_SLEEPON_START_TAG (void *) 1 42 #define DASD_SLEEPON_END_TAG (void *) 2 43 44 /* 45 * SECTION: exported variables of dasd.c 46 */ 47 debug_info_t *dasd_debug_area; 48 struct dasd_discipline *dasd_diag_discipline_pointer; 49 void dasd_int_handler(struct ccw_device *, unsigned long, struct irb *); 50 51 MODULE_AUTHOR("Holger Smolinski <Holger.Smolinski@de.ibm.com>"); 52 MODULE_DESCRIPTION("Linux on S/390 DASD device driver," 53 " Copyright 2000 IBM Corporation"); 54 MODULE_SUPPORTED_DEVICE("dasd"); 55 MODULE_LICENSE("GPL"); 56 57 /* 58 * SECTION: prototypes for static functions of dasd.c 59 */ 60 static int dasd_alloc_queue(struct dasd_block *); 61 static void dasd_setup_queue(struct dasd_block *); 62 static void dasd_free_queue(struct dasd_block *); 63 static void dasd_flush_request_queue(struct dasd_block *); 64 static int dasd_flush_block_queue(struct dasd_block *); 65 static void dasd_device_tasklet(struct dasd_device *); 66 static void dasd_block_tasklet(struct dasd_block *); 67 static void do_kick_device(struct work_struct *); 68 static void do_restore_device(struct work_struct *); 69 static void do_reload_device(struct work_struct *); 70 static void dasd_return_cqr_cb(struct dasd_ccw_req *, void *); 71 static void dasd_device_timeout(unsigned long); 72 static void dasd_block_timeout(unsigned long); 73 static void __dasd_process_erp(struct dasd_device *, struct dasd_ccw_req *); 74 75 /* 76 * SECTION: Operations on the device structure. 77 */ 78 static wait_queue_head_t dasd_init_waitq; 79 static wait_queue_head_t dasd_flush_wq; 80 static wait_queue_head_t generic_waitq; 81 82 /* 83 * Allocate memory for a new device structure. 84 */ 85 struct dasd_device *dasd_alloc_device(void) 86 { 87 struct dasd_device *device; 88 89 device = kzalloc(sizeof(struct dasd_device), GFP_ATOMIC); 90 if (!device) 91 return ERR_PTR(-ENOMEM); 92 93 /* Get two pages for normal block device operations. */ 94 device->ccw_mem = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA, 1); 95 if (!device->ccw_mem) { 96 kfree(device); 97 return ERR_PTR(-ENOMEM); 98 } 99 /* Get one page for error recovery. */ 100 device->erp_mem = (void *) get_zeroed_page(GFP_ATOMIC | GFP_DMA); 101 if (!device->erp_mem) { 102 free_pages((unsigned long) device->ccw_mem, 1); 103 kfree(device); 104 return ERR_PTR(-ENOMEM); 105 } 106 107 dasd_init_chunklist(&device->ccw_chunks, device->ccw_mem, PAGE_SIZE*2); 108 dasd_init_chunklist(&device->erp_chunks, device->erp_mem, PAGE_SIZE); 109 spin_lock_init(&device->mem_lock); 110 atomic_set(&device->tasklet_scheduled, 0); 111 tasklet_init(&device->tasklet, 112 (void (*)(unsigned long)) dasd_device_tasklet, 113 (unsigned long) device); 114 INIT_LIST_HEAD(&device->ccw_queue); 115 init_timer(&device->timer); 116 device->timer.function = dasd_device_timeout; 117 device->timer.data = (unsigned long) device; 118 INIT_WORK(&device->kick_work, do_kick_device); 119 INIT_WORK(&device->restore_device, do_restore_device); 120 INIT_WORK(&device->reload_device, do_reload_device); 121 device->state = DASD_STATE_NEW; 122 device->target = DASD_STATE_NEW; 123 mutex_init(&device->state_mutex); 124 125 return device; 126 } 127 128 /* 129 * Free memory of a device structure. 130 */ 131 void dasd_free_device(struct dasd_device *device) 132 { 133 kfree(device->private); 134 free_page((unsigned long) device->erp_mem); 135 free_pages((unsigned long) device->ccw_mem, 1); 136 kfree(device); 137 } 138 139 /* 140 * Allocate memory for a new device structure. 141 */ 142 struct dasd_block *dasd_alloc_block(void) 143 { 144 struct dasd_block *block; 145 146 block = kzalloc(sizeof(*block), GFP_ATOMIC); 147 if (!block) 148 return ERR_PTR(-ENOMEM); 149 /* open_count = 0 means device online but not in use */ 150 atomic_set(&block->open_count, -1); 151 152 spin_lock_init(&block->request_queue_lock); 153 atomic_set(&block->tasklet_scheduled, 0); 154 tasklet_init(&block->tasklet, 155 (void (*)(unsigned long)) dasd_block_tasklet, 156 (unsigned long) block); 157 INIT_LIST_HEAD(&block->ccw_queue); 158 spin_lock_init(&block->queue_lock); 159 init_timer(&block->timer); 160 block->timer.function = dasd_block_timeout; 161 block->timer.data = (unsigned long) block; 162 163 return block; 164 } 165 166 /* 167 * Free memory of a device structure. 168 */ 169 void dasd_free_block(struct dasd_block *block) 170 { 171 kfree(block); 172 } 173 174 /* 175 * Make a new device known to the system. 176 */ 177 static int dasd_state_new_to_known(struct dasd_device *device) 178 { 179 int rc; 180 181 /* 182 * As long as the device is not in state DASD_STATE_NEW we want to 183 * keep the reference count > 0. 184 */ 185 dasd_get_device(device); 186 187 if (device->block) { 188 rc = dasd_alloc_queue(device->block); 189 if (rc) { 190 dasd_put_device(device); 191 return rc; 192 } 193 } 194 device->state = DASD_STATE_KNOWN; 195 return 0; 196 } 197 198 /* 199 * Let the system forget about a device. 200 */ 201 static int dasd_state_known_to_new(struct dasd_device *device) 202 { 203 /* Disable extended error reporting for this device. */ 204 dasd_eer_disable(device); 205 /* Forget the discipline information. */ 206 if (device->discipline) { 207 if (device->discipline->uncheck_device) 208 device->discipline->uncheck_device(device); 209 module_put(device->discipline->owner); 210 } 211 device->discipline = NULL; 212 if (device->base_discipline) 213 module_put(device->base_discipline->owner); 214 device->base_discipline = NULL; 215 device->state = DASD_STATE_NEW; 216 217 if (device->block) 218 dasd_free_queue(device->block); 219 220 /* Give up reference we took in dasd_state_new_to_known. */ 221 dasd_put_device(device); 222 return 0; 223 } 224 225 /* 226 * Request the irq line for the device. 227 */ 228 static int dasd_state_known_to_basic(struct dasd_device *device) 229 { 230 int rc; 231 232 /* Allocate and register gendisk structure. */ 233 if (device->block) { 234 rc = dasd_gendisk_alloc(device->block); 235 if (rc) 236 return rc; 237 } 238 /* register 'device' debug area, used for all DBF_DEV_XXX calls */ 239 device->debug_area = debug_register(dev_name(&device->cdev->dev), 4, 1, 240 8 * sizeof(long)); 241 debug_register_view(device->debug_area, &debug_sprintf_view); 242 debug_set_level(device->debug_area, DBF_WARNING); 243 DBF_DEV_EVENT(DBF_EMERG, device, "%s", "debug area created"); 244 245 device->state = DASD_STATE_BASIC; 246 return 0; 247 } 248 249 /* 250 * Release the irq line for the device. Terminate any running i/o. 251 */ 252 static int dasd_state_basic_to_known(struct dasd_device *device) 253 { 254 int rc; 255 if (device->block) { 256 dasd_gendisk_free(device->block); 257 dasd_block_clear_timer(device->block); 258 } 259 rc = dasd_flush_device_queue(device); 260 if (rc) 261 return rc; 262 dasd_device_clear_timer(device); 263 264 DBF_DEV_EVENT(DBF_EMERG, device, "%p debug area deleted", device); 265 if (device->debug_area != NULL) { 266 debug_unregister(device->debug_area); 267 device->debug_area = NULL; 268 } 269 device->state = DASD_STATE_KNOWN; 270 return 0; 271 } 272 273 /* 274 * Do the initial analysis. The do_analysis function may return 275 * -EAGAIN in which case the device keeps the state DASD_STATE_BASIC 276 * until the discipline decides to continue the startup sequence 277 * by calling the function dasd_change_state. The eckd disciplines 278 * uses this to start a ccw that detects the format. The completion 279 * interrupt for this detection ccw uses the kernel event daemon to 280 * trigger the call to dasd_change_state. All this is done in the 281 * discipline code, see dasd_eckd.c. 282 * After the analysis ccw is done (do_analysis returned 0) the block 283 * device is setup. 284 * In case the analysis returns an error, the device setup is stopped 285 * (a fake disk was already added to allow formatting). 286 */ 287 static int dasd_state_basic_to_ready(struct dasd_device *device) 288 { 289 int rc; 290 struct dasd_block *block; 291 292 rc = 0; 293 block = device->block; 294 /* make disk known with correct capacity */ 295 if (block) { 296 if (block->base->discipline->do_analysis != NULL) 297 rc = block->base->discipline->do_analysis(block); 298 if (rc) { 299 if (rc != -EAGAIN) 300 device->state = DASD_STATE_UNFMT; 301 return rc; 302 } 303 dasd_setup_queue(block); 304 set_capacity(block->gdp, 305 block->blocks << block->s2b_shift); 306 device->state = DASD_STATE_READY; 307 rc = dasd_scan_partitions(block); 308 if (rc) 309 device->state = DASD_STATE_BASIC; 310 } else { 311 device->state = DASD_STATE_READY; 312 } 313 return rc; 314 } 315 316 /* 317 * Remove device from block device layer. Destroy dirty buffers. 318 * Forget format information. Check if the target level is basic 319 * and if it is create fake disk for formatting. 320 */ 321 static int dasd_state_ready_to_basic(struct dasd_device *device) 322 { 323 int rc; 324 325 device->state = DASD_STATE_BASIC; 326 if (device->block) { 327 struct dasd_block *block = device->block; 328 rc = dasd_flush_block_queue(block); 329 if (rc) { 330 device->state = DASD_STATE_READY; 331 return rc; 332 } 333 dasd_flush_request_queue(block); 334 dasd_destroy_partitions(block); 335 block->blocks = 0; 336 block->bp_block = 0; 337 block->s2b_shift = 0; 338 } 339 return 0; 340 } 341 342 /* 343 * Back to basic. 344 */ 345 static int dasd_state_unfmt_to_basic(struct dasd_device *device) 346 { 347 device->state = DASD_STATE_BASIC; 348 return 0; 349 } 350 351 /* 352 * Make the device online and schedule the bottom half to start 353 * the requeueing of requests from the linux request queue to the 354 * ccw queue. 355 */ 356 static int 357 dasd_state_ready_to_online(struct dasd_device * device) 358 { 359 int rc; 360 struct gendisk *disk; 361 struct disk_part_iter piter; 362 struct hd_struct *part; 363 364 if (device->discipline->ready_to_online) { 365 rc = device->discipline->ready_to_online(device); 366 if (rc) 367 return rc; 368 } 369 device->state = DASD_STATE_ONLINE; 370 if (device->block) { 371 dasd_schedule_block_bh(device->block); 372 disk = device->block->bdev->bd_disk; 373 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0); 374 while ((part = disk_part_iter_next(&piter))) 375 kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE); 376 disk_part_iter_exit(&piter); 377 } 378 return 0; 379 } 380 381 /* 382 * Stop the requeueing of requests again. 383 */ 384 static int dasd_state_online_to_ready(struct dasd_device *device) 385 { 386 int rc; 387 struct gendisk *disk; 388 struct disk_part_iter piter; 389 struct hd_struct *part; 390 391 if (device->discipline->online_to_ready) { 392 rc = device->discipline->online_to_ready(device); 393 if (rc) 394 return rc; 395 } 396 device->state = DASD_STATE_READY; 397 if (device->block) { 398 disk = device->block->bdev->bd_disk; 399 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0); 400 while ((part = disk_part_iter_next(&piter))) 401 kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE); 402 disk_part_iter_exit(&piter); 403 } 404 return 0; 405 } 406 407 /* 408 * Device startup state changes. 409 */ 410 static int dasd_increase_state(struct dasd_device *device) 411 { 412 int rc; 413 414 rc = 0; 415 if (device->state == DASD_STATE_NEW && 416 device->target >= DASD_STATE_KNOWN) 417 rc = dasd_state_new_to_known(device); 418 419 if (!rc && 420 device->state == DASD_STATE_KNOWN && 421 device->target >= DASD_STATE_BASIC) 422 rc = dasd_state_known_to_basic(device); 423 424 if (!rc && 425 device->state == DASD_STATE_BASIC && 426 device->target >= DASD_STATE_READY) 427 rc = dasd_state_basic_to_ready(device); 428 429 if (!rc && 430 device->state == DASD_STATE_UNFMT && 431 device->target > DASD_STATE_UNFMT) 432 rc = -EPERM; 433 434 if (!rc && 435 device->state == DASD_STATE_READY && 436 device->target >= DASD_STATE_ONLINE) 437 rc = dasd_state_ready_to_online(device); 438 439 return rc; 440 } 441 442 /* 443 * Device shutdown state changes. 444 */ 445 static int dasd_decrease_state(struct dasd_device *device) 446 { 447 int rc; 448 449 rc = 0; 450 if (device->state == DASD_STATE_ONLINE && 451 device->target <= DASD_STATE_READY) 452 rc = dasd_state_online_to_ready(device); 453 454 if (!rc && 455 device->state == DASD_STATE_READY && 456 device->target <= DASD_STATE_BASIC) 457 rc = dasd_state_ready_to_basic(device); 458 459 if (!rc && 460 device->state == DASD_STATE_UNFMT && 461 device->target <= DASD_STATE_BASIC) 462 rc = dasd_state_unfmt_to_basic(device); 463 464 if (!rc && 465 device->state == DASD_STATE_BASIC && 466 device->target <= DASD_STATE_KNOWN) 467 rc = dasd_state_basic_to_known(device); 468 469 if (!rc && 470 device->state == DASD_STATE_KNOWN && 471 device->target <= DASD_STATE_NEW) 472 rc = dasd_state_known_to_new(device); 473 474 return rc; 475 } 476 477 /* 478 * This is the main startup/shutdown routine. 479 */ 480 static void dasd_change_state(struct dasd_device *device) 481 { 482 int rc; 483 484 if (device->state == device->target) 485 /* Already where we want to go today... */ 486 return; 487 if (device->state < device->target) 488 rc = dasd_increase_state(device); 489 else 490 rc = dasd_decrease_state(device); 491 if (rc == -EAGAIN) 492 return; 493 if (rc) 494 device->target = device->state; 495 496 if (device->state == device->target) 497 wake_up(&dasd_init_waitq); 498 499 /* let user-space know that the device status changed */ 500 kobject_uevent(&device->cdev->dev.kobj, KOBJ_CHANGE); 501 } 502 503 /* 504 * Kick starter for devices that did not complete the startup/shutdown 505 * procedure or were sleeping because of a pending state. 506 * dasd_kick_device will schedule a call do do_kick_device to the kernel 507 * event daemon. 508 */ 509 static void do_kick_device(struct work_struct *work) 510 { 511 struct dasd_device *device = container_of(work, struct dasd_device, kick_work); 512 mutex_lock(&device->state_mutex); 513 dasd_change_state(device); 514 mutex_unlock(&device->state_mutex); 515 dasd_schedule_device_bh(device); 516 dasd_put_device(device); 517 } 518 519 void dasd_kick_device(struct dasd_device *device) 520 { 521 dasd_get_device(device); 522 /* queue call to dasd_kick_device to the kernel event daemon. */ 523 schedule_work(&device->kick_work); 524 } 525 526 /* 527 * dasd_reload_device will schedule a call do do_reload_device to the kernel 528 * event daemon. 529 */ 530 static void do_reload_device(struct work_struct *work) 531 { 532 struct dasd_device *device = container_of(work, struct dasd_device, 533 reload_device); 534 device->discipline->reload(device); 535 dasd_put_device(device); 536 } 537 538 void dasd_reload_device(struct dasd_device *device) 539 { 540 dasd_get_device(device); 541 /* queue call to dasd_reload_device to the kernel event daemon. */ 542 schedule_work(&device->reload_device); 543 } 544 EXPORT_SYMBOL(dasd_reload_device); 545 546 /* 547 * dasd_restore_device will schedule a call do do_restore_device to the kernel 548 * event daemon. 549 */ 550 static void do_restore_device(struct work_struct *work) 551 { 552 struct dasd_device *device = container_of(work, struct dasd_device, 553 restore_device); 554 device->cdev->drv->restore(device->cdev); 555 dasd_put_device(device); 556 } 557 558 void dasd_restore_device(struct dasd_device *device) 559 { 560 dasd_get_device(device); 561 /* queue call to dasd_restore_device to the kernel event daemon. */ 562 schedule_work(&device->restore_device); 563 } 564 565 /* 566 * Set the target state for a device and starts the state change. 567 */ 568 void dasd_set_target_state(struct dasd_device *device, int target) 569 { 570 dasd_get_device(device); 571 mutex_lock(&device->state_mutex); 572 /* If we are in probeonly mode stop at DASD_STATE_READY. */ 573 if (dasd_probeonly && target > DASD_STATE_READY) 574 target = DASD_STATE_READY; 575 if (device->target != target) { 576 if (device->state == target) 577 wake_up(&dasd_init_waitq); 578 device->target = target; 579 } 580 if (device->state != device->target) 581 dasd_change_state(device); 582 mutex_unlock(&device->state_mutex); 583 dasd_put_device(device); 584 } 585 586 /* 587 * Enable devices with device numbers in [from..to]. 588 */ 589 static inline int _wait_for_device(struct dasd_device *device) 590 { 591 return (device->state == device->target); 592 } 593 594 void dasd_enable_device(struct dasd_device *device) 595 { 596 dasd_set_target_state(device, DASD_STATE_ONLINE); 597 if (device->state <= DASD_STATE_KNOWN) 598 /* No discipline for device found. */ 599 dasd_set_target_state(device, DASD_STATE_NEW); 600 /* Now wait for the devices to come up. */ 601 wait_event(dasd_init_waitq, _wait_for_device(device)); 602 } 603 604 /* 605 * SECTION: device operation (interrupt handler, start i/o, term i/o ...) 606 */ 607 #ifdef CONFIG_DASD_PROFILE 608 609 struct dasd_profile_info_t dasd_global_profile; 610 unsigned int dasd_profile_level = DASD_PROFILE_OFF; 611 612 /* 613 * Increments counter in global and local profiling structures. 614 */ 615 #define dasd_profile_counter(value, counter, block) \ 616 { \ 617 int index; \ 618 for (index = 0; index < 31 && value >> (2+index); index++); \ 619 dasd_global_profile.counter[index]++; \ 620 block->profile.counter[index]++; \ 621 } 622 623 /* 624 * Add profiling information for cqr before execution. 625 */ 626 static void dasd_profile_start(struct dasd_block *block, 627 struct dasd_ccw_req *cqr, 628 struct request *req) 629 { 630 struct list_head *l; 631 unsigned int counter; 632 633 if (dasd_profile_level != DASD_PROFILE_ON) 634 return; 635 636 /* count the length of the chanq for statistics */ 637 counter = 0; 638 list_for_each(l, &block->ccw_queue) 639 if (++counter >= 31) 640 break; 641 dasd_global_profile.dasd_io_nr_req[counter]++; 642 block->profile.dasd_io_nr_req[counter]++; 643 } 644 645 /* 646 * Add profiling information for cqr after execution. 647 */ 648 static void dasd_profile_end(struct dasd_block *block, 649 struct dasd_ccw_req *cqr, 650 struct request *req) 651 { 652 long strtime, irqtime, endtime, tottime; /* in microseconds */ 653 long tottimeps, sectors; 654 655 if (dasd_profile_level != DASD_PROFILE_ON) 656 return; 657 658 sectors = blk_rq_sectors(req); 659 if (!cqr->buildclk || !cqr->startclk || 660 !cqr->stopclk || !cqr->endclk || 661 !sectors) 662 return; 663 664 strtime = ((cqr->startclk - cqr->buildclk) >> 12); 665 irqtime = ((cqr->stopclk - cqr->startclk) >> 12); 666 endtime = ((cqr->endclk - cqr->stopclk) >> 12); 667 tottime = ((cqr->endclk - cqr->buildclk) >> 12); 668 tottimeps = tottime / sectors; 669 670 if (!dasd_global_profile.dasd_io_reqs) 671 memset(&dasd_global_profile, 0, 672 sizeof(struct dasd_profile_info_t)); 673 dasd_global_profile.dasd_io_reqs++; 674 dasd_global_profile.dasd_io_sects += sectors; 675 676 if (!block->profile.dasd_io_reqs) 677 memset(&block->profile, 0, 678 sizeof(struct dasd_profile_info_t)); 679 block->profile.dasd_io_reqs++; 680 block->profile.dasd_io_sects += sectors; 681 682 dasd_profile_counter(sectors, dasd_io_secs, block); 683 dasd_profile_counter(tottime, dasd_io_times, block); 684 dasd_profile_counter(tottimeps, dasd_io_timps, block); 685 dasd_profile_counter(strtime, dasd_io_time1, block); 686 dasd_profile_counter(irqtime, dasd_io_time2, block); 687 dasd_profile_counter(irqtime / sectors, dasd_io_time2ps, block); 688 dasd_profile_counter(endtime, dasd_io_time3, block); 689 } 690 #else 691 #define dasd_profile_start(block, cqr, req) do {} while (0) 692 #define dasd_profile_end(block, cqr, req) do {} while (0) 693 #endif /* CONFIG_DASD_PROFILE */ 694 695 /* 696 * Allocate memory for a channel program with 'cplength' channel 697 * command words and 'datasize' additional space. There are two 698 * variantes: 1) dasd_kmalloc_request uses kmalloc to get the needed 699 * memory and 2) dasd_smalloc_request uses the static ccw memory 700 * that gets allocated for each device. 701 */ 702 struct dasd_ccw_req *dasd_kmalloc_request(int magic, int cplength, 703 int datasize, 704 struct dasd_device *device) 705 { 706 struct dasd_ccw_req *cqr; 707 708 /* Sanity checks */ 709 BUG_ON(datasize > PAGE_SIZE || 710 (cplength*sizeof(struct ccw1)) > PAGE_SIZE); 711 712 cqr = kzalloc(sizeof(struct dasd_ccw_req), GFP_ATOMIC); 713 if (cqr == NULL) 714 return ERR_PTR(-ENOMEM); 715 cqr->cpaddr = NULL; 716 if (cplength > 0) { 717 cqr->cpaddr = kcalloc(cplength, sizeof(struct ccw1), 718 GFP_ATOMIC | GFP_DMA); 719 if (cqr->cpaddr == NULL) { 720 kfree(cqr); 721 return ERR_PTR(-ENOMEM); 722 } 723 } 724 cqr->data = NULL; 725 if (datasize > 0) { 726 cqr->data = kzalloc(datasize, GFP_ATOMIC | GFP_DMA); 727 if (cqr->data == NULL) { 728 kfree(cqr->cpaddr); 729 kfree(cqr); 730 return ERR_PTR(-ENOMEM); 731 } 732 } 733 cqr->magic = magic; 734 set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 735 dasd_get_device(device); 736 return cqr; 737 } 738 739 struct dasd_ccw_req *dasd_smalloc_request(int magic, int cplength, 740 int datasize, 741 struct dasd_device *device) 742 { 743 unsigned long flags; 744 struct dasd_ccw_req *cqr; 745 char *data; 746 int size; 747 748 size = (sizeof(struct dasd_ccw_req) + 7L) & -8L; 749 if (cplength > 0) 750 size += cplength * sizeof(struct ccw1); 751 if (datasize > 0) 752 size += datasize; 753 spin_lock_irqsave(&device->mem_lock, flags); 754 cqr = (struct dasd_ccw_req *) 755 dasd_alloc_chunk(&device->ccw_chunks, size); 756 spin_unlock_irqrestore(&device->mem_lock, flags); 757 if (cqr == NULL) 758 return ERR_PTR(-ENOMEM); 759 memset(cqr, 0, sizeof(struct dasd_ccw_req)); 760 data = (char *) cqr + ((sizeof(struct dasd_ccw_req) + 7L) & -8L); 761 cqr->cpaddr = NULL; 762 if (cplength > 0) { 763 cqr->cpaddr = (struct ccw1 *) data; 764 data += cplength*sizeof(struct ccw1); 765 memset(cqr->cpaddr, 0, cplength*sizeof(struct ccw1)); 766 } 767 cqr->data = NULL; 768 if (datasize > 0) { 769 cqr->data = data; 770 memset(cqr->data, 0, datasize); 771 } 772 cqr->magic = magic; 773 set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 774 dasd_get_device(device); 775 return cqr; 776 } 777 778 /* 779 * Free memory of a channel program. This function needs to free all the 780 * idal lists that might have been created by dasd_set_cda and the 781 * struct dasd_ccw_req itself. 782 */ 783 void dasd_kfree_request(struct dasd_ccw_req *cqr, struct dasd_device *device) 784 { 785 #ifdef CONFIG_64BIT 786 struct ccw1 *ccw; 787 788 /* Clear any idals used for the request. */ 789 ccw = cqr->cpaddr; 790 do { 791 clear_normalized_cda(ccw); 792 } while (ccw++->flags & (CCW_FLAG_CC | CCW_FLAG_DC)); 793 #endif 794 kfree(cqr->cpaddr); 795 kfree(cqr->data); 796 kfree(cqr); 797 dasd_put_device(device); 798 } 799 800 void dasd_sfree_request(struct dasd_ccw_req *cqr, struct dasd_device *device) 801 { 802 unsigned long flags; 803 804 spin_lock_irqsave(&device->mem_lock, flags); 805 dasd_free_chunk(&device->ccw_chunks, cqr); 806 spin_unlock_irqrestore(&device->mem_lock, flags); 807 dasd_put_device(device); 808 } 809 810 /* 811 * Check discipline magic in cqr. 812 */ 813 static inline int dasd_check_cqr(struct dasd_ccw_req *cqr) 814 { 815 struct dasd_device *device; 816 817 if (cqr == NULL) 818 return -EINVAL; 819 device = cqr->startdev; 820 if (strncmp((char *) &cqr->magic, device->discipline->ebcname, 4)) { 821 DBF_DEV_EVENT(DBF_WARNING, device, 822 " dasd_ccw_req 0x%08x magic doesn't match" 823 " discipline 0x%08x", 824 cqr->magic, 825 *(unsigned int *) device->discipline->name); 826 return -EINVAL; 827 } 828 return 0; 829 } 830 831 /* 832 * Terminate the current i/o and set the request to clear_pending. 833 * Timer keeps device runnig. 834 * ccw_device_clear can fail if the i/o subsystem 835 * is in a bad mood. 836 */ 837 int dasd_term_IO(struct dasd_ccw_req *cqr) 838 { 839 struct dasd_device *device; 840 int retries, rc; 841 char errorstring[ERRORLENGTH]; 842 843 /* Check the cqr */ 844 rc = dasd_check_cqr(cqr); 845 if (rc) 846 return rc; 847 retries = 0; 848 device = (struct dasd_device *) cqr->startdev; 849 while ((retries < 5) && (cqr->status == DASD_CQR_IN_IO)) { 850 rc = ccw_device_clear(device->cdev, (long) cqr); 851 switch (rc) { 852 case 0: /* termination successful */ 853 cqr->retries--; 854 cqr->status = DASD_CQR_CLEAR_PENDING; 855 cqr->stopclk = get_clock(); 856 cqr->starttime = 0; 857 DBF_DEV_EVENT(DBF_DEBUG, device, 858 "terminate cqr %p successful", 859 cqr); 860 break; 861 case -ENODEV: 862 DBF_DEV_EVENT(DBF_ERR, device, "%s", 863 "device gone, retry"); 864 break; 865 case -EIO: 866 DBF_DEV_EVENT(DBF_ERR, device, "%s", 867 "I/O error, retry"); 868 break; 869 case -EINVAL: 870 case -EBUSY: 871 DBF_DEV_EVENT(DBF_ERR, device, "%s", 872 "device busy, retry later"); 873 break; 874 default: 875 /* internal error 10 - unknown rc*/ 876 snprintf(errorstring, ERRORLENGTH, "10 %d", rc); 877 dev_err(&device->cdev->dev, "An error occurred in the " 878 "DASD device driver, reason=%s\n", errorstring); 879 BUG(); 880 break; 881 } 882 retries++; 883 } 884 dasd_schedule_device_bh(device); 885 return rc; 886 } 887 888 /* 889 * Start the i/o. This start_IO can fail if the channel is really busy. 890 * In that case set up a timer to start the request later. 891 */ 892 int dasd_start_IO(struct dasd_ccw_req *cqr) 893 { 894 struct dasd_device *device; 895 int rc; 896 char errorstring[ERRORLENGTH]; 897 898 /* Check the cqr */ 899 rc = dasd_check_cqr(cqr); 900 if (rc) { 901 cqr->intrc = rc; 902 return rc; 903 } 904 device = (struct dasd_device *) cqr->startdev; 905 if (cqr->retries < 0) { 906 /* internal error 14 - start_IO run out of retries */ 907 sprintf(errorstring, "14 %p", cqr); 908 dev_err(&device->cdev->dev, "An error occurred in the DASD " 909 "device driver, reason=%s\n", errorstring); 910 cqr->status = DASD_CQR_ERROR; 911 return -EIO; 912 } 913 cqr->startclk = get_clock(); 914 cqr->starttime = jiffies; 915 cqr->retries--; 916 if (!test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) { 917 cqr->lpm &= device->path_data.opm; 918 if (!cqr->lpm) 919 cqr->lpm = device->path_data.opm; 920 } 921 if (cqr->cpmode == 1) { 922 rc = ccw_device_tm_start(device->cdev, cqr->cpaddr, 923 (long) cqr, cqr->lpm); 924 } else { 925 rc = ccw_device_start(device->cdev, cqr->cpaddr, 926 (long) cqr, cqr->lpm, 0); 927 } 928 switch (rc) { 929 case 0: 930 cqr->status = DASD_CQR_IN_IO; 931 break; 932 case -EBUSY: 933 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 934 "start_IO: device busy, retry later"); 935 break; 936 case -ETIMEDOUT: 937 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 938 "start_IO: request timeout, retry later"); 939 break; 940 case -EACCES: 941 /* -EACCES indicates that the request used only a subset of the 942 * available paths and all these paths are gone. If the lpm of 943 * this request was only a subset of the opm (e.g. the ppm) then 944 * we just do a retry with all available paths. 945 * If we already use the full opm, something is amiss, and we 946 * need a full path verification. 947 */ 948 if (test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) { 949 DBF_DEV_EVENT(DBF_WARNING, device, 950 "start_IO: selected paths gone (%x)", 951 cqr->lpm); 952 } else if (cqr->lpm != device->path_data.opm) { 953 cqr->lpm = device->path_data.opm; 954 DBF_DEV_EVENT(DBF_DEBUG, device, "%s", 955 "start_IO: selected paths gone," 956 " retry on all paths"); 957 } else { 958 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 959 "start_IO: all paths in opm gone," 960 " do path verification"); 961 dasd_generic_last_path_gone(device); 962 device->path_data.opm = 0; 963 device->path_data.ppm = 0; 964 device->path_data.npm = 0; 965 device->path_data.tbvpm = 966 ccw_device_get_path_mask(device->cdev); 967 } 968 break; 969 case -ENODEV: 970 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 971 "start_IO: -ENODEV device gone, retry"); 972 break; 973 case -EIO: 974 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 975 "start_IO: -EIO device gone, retry"); 976 break; 977 case -EINVAL: 978 /* most likely caused in power management context */ 979 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 980 "start_IO: -EINVAL device currently " 981 "not accessible"); 982 break; 983 default: 984 /* internal error 11 - unknown rc */ 985 snprintf(errorstring, ERRORLENGTH, "11 %d", rc); 986 dev_err(&device->cdev->dev, 987 "An error occurred in the DASD device driver, " 988 "reason=%s\n", errorstring); 989 BUG(); 990 break; 991 } 992 cqr->intrc = rc; 993 return rc; 994 } 995 996 /* 997 * Timeout function for dasd devices. This is used for different purposes 998 * 1) missing interrupt handler for normal operation 999 * 2) delayed start of request where start_IO failed with -EBUSY 1000 * 3) timeout for missing state change interrupts 1001 * The head of the ccw queue will have status DASD_CQR_IN_IO for 1), 1002 * DASD_CQR_QUEUED for 2) and 3). 1003 */ 1004 static void dasd_device_timeout(unsigned long ptr) 1005 { 1006 unsigned long flags; 1007 struct dasd_device *device; 1008 1009 device = (struct dasd_device *) ptr; 1010 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1011 /* re-activate request queue */ 1012 dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING); 1013 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 1014 dasd_schedule_device_bh(device); 1015 } 1016 1017 /* 1018 * Setup timeout for a device in jiffies. 1019 */ 1020 void dasd_device_set_timer(struct dasd_device *device, int expires) 1021 { 1022 if (expires == 0) 1023 del_timer(&device->timer); 1024 else 1025 mod_timer(&device->timer, jiffies + expires); 1026 } 1027 1028 /* 1029 * Clear timeout for a device. 1030 */ 1031 void dasd_device_clear_timer(struct dasd_device *device) 1032 { 1033 del_timer(&device->timer); 1034 } 1035 1036 static void dasd_handle_killed_request(struct ccw_device *cdev, 1037 unsigned long intparm) 1038 { 1039 struct dasd_ccw_req *cqr; 1040 struct dasd_device *device; 1041 1042 if (!intparm) 1043 return; 1044 cqr = (struct dasd_ccw_req *) intparm; 1045 if (cqr->status != DASD_CQR_IN_IO) { 1046 DBF_EVENT_DEVID(DBF_DEBUG, cdev, 1047 "invalid status in handle_killed_request: " 1048 "%02x", cqr->status); 1049 return; 1050 } 1051 1052 device = dasd_device_from_cdev_locked(cdev); 1053 if (IS_ERR(device)) { 1054 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s", 1055 "unable to get device from cdev"); 1056 return; 1057 } 1058 1059 if (!cqr->startdev || 1060 device != cqr->startdev || 1061 strncmp(cqr->startdev->discipline->ebcname, 1062 (char *) &cqr->magic, 4)) { 1063 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s", 1064 "invalid device in request"); 1065 dasd_put_device(device); 1066 return; 1067 } 1068 1069 /* Schedule request to be retried. */ 1070 cqr->status = DASD_CQR_QUEUED; 1071 1072 dasd_device_clear_timer(device); 1073 dasd_schedule_device_bh(device); 1074 dasd_put_device(device); 1075 } 1076 1077 void dasd_generic_handle_state_change(struct dasd_device *device) 1078 { 1079 /* First of all start sense subsystem status request. */ 1080 dasd_eer_snss(device); 1081 1082 dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING); 1083 dasd_schedule_device_bh(device); 1084 if (device->block) 1085 dasd_schedule_block_bh(device->block); 1086 } 1087 1088 /* 1089 * Interrupt handler for "normal" ssch-io based dasd devices. 1090 */ 1091 void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm, 1092 struct irb *irb) 1093 { 1094 struct dasd_ccw_req *cqr, *next; 1095 struct dasd_device *device; 1096 unsigned long long now; 1097 int expires; 1098 1099 kstat_cpu(smp_processor_id()).irqs[IOINT_DAS]++; 1100 if (IS_ERR(irb)) { 1101 switch (PTR_ERR(irb)) { 1102 case -EIO: 1103 break; 1104 case -ETIMEDOUT: 1105 DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: " 1106 "request timed out\n", __func__); 1107 break; 1108 default: 1109 DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: " 1110 "unknown error %ld\n", __func__, 1111 PTR_ERR(irb)); 1112 } 1113 dasd_handle_killed_request(cdev, intparm); 1114 return; 1115 } 1116 1117 now = get_clock(); 1118 1119 /* check for unsolicited interrupts */ 1120 cqr = (struct dasd_ccw_req *) intparm; 1121 if (!cqr || ((scsw_cc(&irb->scsw) == 1) && 1122 (scsw_fctl(&irb->scsw) & SCSW_FCTL_START_FUNC) && 1123 ((scsw_stctl(&irb->scsw) == SCSW_STCTL_STATUS_PEND) || 1124 (scsw_stctl(&irb->scsw) == (SCSW_STCTL_STATUS_PEND | 1125 SCSW_STCTL_ALERT_STATUS))))) { 1126 if (cqr && cqr->status == DASD_CQR_IN_IO) 1127 cqr->status = DASD_CQR_QUEUED; 1128 if (cqr) 1129 memcpy(&cqr->irb, irb, sizeof(*irb)); 1130 device = dasd_device_from_cdev_locked(cdev); 1131 if (IS_ERR(device)) 1132 return; 1133 /* ignore unsolicited interrupts for DIAG discipline */ 1134 if (device->discipline == dasd_diag_discipline_pointer) { 1135 dasd_put_device(device); 1136 return; 1137 } 1138 device->discipline->dump_sense_dbf(device, irb, 1139 "unsolicited"); 1140 if ((device->features & DASD_FEATURE_ERPLOG)) 1141 device->discipline->dump_sense(device, cqr, 1142 irb); 1143 dasd_device_clear_timer(device); 1144 device->discipline->handle_unsolicited_interrupt(device, 1145 irb); 1146 dasd_put_device(device); 1147 return; 1148 } 1149 1150 device = (struct dasd_device *) cqr->startdev; 1151 if (!device || 1152 strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) { 1153 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s", 1154 "invalid device in request"); 1155 return; 1156 } 1157 1158 /* Check for clear pending */ 1159 if (cqr->status == DASD_CQR_CLEAR_PENDING && 1160 scsw_fctl(&irb->scsw) & SCSW_FCTL_CLEAR_FUNC) { 1161 cqr->status = DASD_CQR_CLEARED; 1162 dasd_device_clear_timer(device); 1163 wake_up(&dasd_flush_wq); 1164 dasd_schedule_device_bh(device); 1165 return; 1166 } 1167 1168 /* check status - the request might have been killed by dyn detach */ 1169 if (cqr->status != DASD_CQR_IN_IO) { 1170 DBF_DEV_EVENT(DBF_DEBUG, device, "invalid status: bus_id %s, " 1171 "status %02x", dev_name(&cdev->dev), cqr->status); 1172 return; 1173 } 1174 1175 next = NULL; 1176 expires = 0; 1177 if (scsw_dstat(&irb->scsw) == (DEV_STAT_CHN_END | DEV_STAT_DEV_END) && 1178 scsw_cstat(&irb->scsw) == 0) { 1179 /* request was completed successfully */ 1180 cqr->status = DASD_CQR_SUCCESS; 1181 cqr->stopclk = now; 1182 /* Start first request on queue if possible -> fast_io. */ 1183 if (cqr->devlist.next != &device->ccw_queue) { 1184 next = list_entry(cqr->devlist.next, 1185 struct dasd_ccw_req, devlist); 1186 } 1187 } else { /* error */ 1188 memcpy(&cqr->irb, irb, sizeof(struct irb)); 1189 /* log sense for every failed I/O to s390 debugfeature */ 1190 dasd_log_sense_dbf(cqr, irb); 1191 if (device->features & DASD_FEATURE_ERPLOG) { 1192 dasd_log_sense(cqr, irb); 1193 } 1194 1195 /* 1196 * If we don't want complex ERP for this request, then just 1197 * reset this and retry it in the fastpath 1198 */ 1199 if (!test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags) && 1200 cqr->retries > 0) { 1201 if (cqr->lpm == device->path_data.opm) 1202 DBF_DEV_EVENT(DBF_DEBUG, device, 1203 "default ERP in fastpath " 1204 "(%i retries left)", 1205 cqr->retries); 1206 if (!test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) 1207 cqr->lpm = device->path_data.opm; 1208 cqr->status = DASD_CQR_QUEUED; 1209 next = cqr; 1210 } else 1211 cqr->status = DASD_CQR_ERROR; 1212 } 1213 if (next && (next->status == DASD_CQR_QUEUED) && 1214 (!device->stopped)) { 1215 if (device->discipline->start_IO(next) == 0) 1216 expires = next->expires; 1217 } 1218 if (expires != 0) 1219 dasd_device_set_timer(device, expires); 1220 else 1221 dasd_device_clear_timer(device); 1222 dasd_schedule_device_bh(device); 1223 } 1224 1225 enum uc_todo dasd_generic_uc_handler(struct ccw_device *cdev, struct irb *irb) 1226 { 1227 struct dasd_device *device; 1228 1229 device = dasd_device_from_cdev_locked(cdev); 1230 1231 if (IS_ERR(device)) 1232 goto out; 1233 if (test_bit(DASD_FLAG_OFFLINE, &device->flags) || 1234 device->state != device->target || 1235 !device->discipline->handle_unsolicited_interrupt){ 1236 dasd_put_device(device); 1237 goto out; 1238 } 1239 1240 dasd_device_clear_timer(device); 1241 device->discipline->handle_unsolicited_interrupt(device, irb); 1242 dasd_put_device(device); 1243 out: 1244 return UC_TODO_RETRY; 1245 } 1246 EXPORT_SYMBOL_GPL(dasd_generic_uc_handler); 1247 1248 /* 1249 * If we have an error on a dasd_block layer request then we cancel 1250 * and return all further requests from the same dasd_block as well. 1251 */ 1252 static void __dasd_device_recovery(struct dasd_device *device, 1253 struct dasd_ccw_req *ref_cqr) 1254 { 1255 struct list_head *l, *n; 1256 struct dasd_ccw_req *cqr; 1257 1258 /* 1259 * only requeue request that came from the dasd_block layer 1260 */ 1261 if (!ref_cqr->block) 1262 return; 1263 1264 list_for_each_safe(l, n, &device->ccw_queue) { 1265 cqr = list_entry(l, struct dasd_ccw_req, devlist); 1266 if (cqr->status == DASD_CQR_QUEUED && 1267 ref_cqr->block == cqr->block) { 1268 cqr->status = DASD_CQR_CLEARED; 1269 } 1270 } 1271 }; 1272 1273 /* 1274 * Remove those ccw requests from the queue that need to be returned 1275 * to the upper layer. 1276 */ 1277 static void __dasd_device_process_ccw_queue(struct dasd_device *device, 1278 struct list_head *final_queue) 1279 { 1280 struct list_head *l, *n; 1281 struct dasd_ccw_req *cqr; 1282 1283 /* Process request with final status. */ 1284 list_for_each_safe(l, n, &device->ccw_queue) { 1285 cqr = list_entry(l, struct dasd_ccw_req, devlist); 1286 1287 /* Stop list processing at the first non-final request. */ 1288 if (cqr->status == DASD_CQR_QUEUED || 1289 cqr->status == DASD_CQR_IN_IO || 1290 cqr->status == DASD_CQR_CLEAR_PENDING) 1291 break; 1292 if (cqr->status == DASD_CQR_ERROR) { 1293 __dasd_device_recovery(device, cqr); 1294 } 1295 /* Rechain finished requests to final queue */ 1296 list_move_tail(&cqr->devlist, final_queue); 1297 } 1298 } 1299 1300 /* 1301 * the cqrs from the final queue are returned to the upper layer 1302 * by setting a dasd_block state and calling the callback function 1303 */ 1304 static void __dasd_device_process_final_queue(struct dasd_device *device, 1305 struct list_head *final_queue) 1306 { 1307 struct list_head *l, *n; 1308 struct dasd_ccw_req *cqr; 1309 struct dasd_block *block; 1310 void (*callback)(struct dasd_ccw_req *, void *data); 1311 void *callback_data; 1312 char errorstring[ERRORLENGTH]; 1313 1314 list_for_each_safe(l, n, final_queue) { 1315 cqr = list_entry(l, struct dasd_ccw_req, devlist); 1316 list_del_init(&cqr->devlist); 1317 block = cqr->block; 1318 callback = cqr->callback; 1319 callback_data = cqr->callback_data; 1320 if (block) 1321 spin_lock_bh(&block->queue_lock); 1322 switch (cqr->status) { 1323 case DASD_CQR_SUCCESS: 1324 cqr->status = DASD_CQR_DONE; 1325 break; 1326 case DASD_CQR_ERROR: 1327 cqr->status = DASD_CQR_NEED_ERP; 1328 break; 1329 case DASD_CQR_CLEARED: 1330 cqr->status = DASD_CQR_TERMINATED; 1331 break; 1332 default: 1333 /* internal error 12 - wrong cqr status*/ 1334 snprintf(errorstring, ERRORLENGTH, "12 %p %x02", cqr, cqr->status); 1335 dev_err(&device->cdev->dev, 1336 "An error occurred in the DASD device driver, " 1337 "reason=%s\n", errorstring); 1338 BUG(); 1339 } 1340 if (cqr->callback != NULL) 1341 (callback)(cqr, callback_data); 1342 if (block) 1343 spin_unlock_bh(&block->queue_lock); 1344 } 1345 } 1346 1347 /* 1348 * Take a look at the first request on the ccw queue and check 1349 * if it reached its expire time. If so, terminate the IO. 1350 */ 1351 static void __dasd_device_check_expire(struct dasd_device *device) 1352 { 1353 struct dasd_ccw_req *cqr; 1354 1355 if (list_empty(&device->ccw_queue)) 1356 return; 1357 cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist); 1358 if ((cqr->status == DASD_CQR_IN_IO && cqr->expires != 0) && 1359 (time_after_eq(jiffies, cqr->expires + cqr->starttime))) { 1360 if (device->discipline->term_IO(cqr) != 0) { 1361 /* Hmpf, try again in 5 sec */ 1362 dev_err(&device->cdev->dev, 1363 "cqr %p timed out (%lus) but cannot be " 1364 "ended, retrying in 5 s\n", 1365 cqr, (cqr->expires/HZ)); 1366 cqr->expires += 5*HZ; 1367 dasd_device_set_timer(device, 5*HZ); 1368 } else { 1369 dev_err(&device->cdev->dev, 1370 "cqr %p timed out (%lus), %i retries " 1371 "remaining\n", cqr, (cqr->expires/HZ), 1372 cqr->retries); 1373 } 1374 } 1375 } 1376 1377 /* 1378 * Take a look at the first request on the ccw queue and check 1379 * if it needs to be started. 1380 */ 1381 static void __dasd_device_start_head(struct dasd_device *device) 1382 { 1383 struct dasd_ccw_req *cqr; 1384 int rc; 1385 1386 if (list_empty(&device->ccw_queue)) 1387 return; 1388 cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist); 1389 if (cqr->status != DASD_CQR_QUEUED) 1390 return; 1391 /* when device is stopped, return request to previous layer 1392 * exception: only the disconnect or unresumed bits are set and the 1393 * cqr is a path verification request 1394 */ 1395 if (device->stopped && 1396 !(!(device->stopped & ~(DASD_STOPPED_DC_WAIT | DASD_UNRESUMED_PM)) 1397 && test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags))) { 1398 cqr->intrc = -EAGAIN; 1399 cqr->status = DASD_CQR_CLEARED; 1400 dasd_schedule_device_bh(device); 1401 return; 1402 } 1403 1404 rc = device->discipline->start_IO(cqr); 1405 if (rc == 0) 1406 dasd_device_set_timer(device, cqr->expires); 1407 else if (rc == -EACCES) { 1408 dasd_schedule_device_bh(device); 1409 } else 1410 /* Hmpf, try again in 1/2 sec */ 1411 dasd_device_set_timer(device, 50); 1412 } 1413 1414 static void __dasd_device_check_path_events(struct dasd_device *device) 1415 { 1416 int rc; 1417 1418 if (device->path_data.tbvpm) { 1419 if (device->stopped & ~(DASD_STOPPED_DC_WAIT | 1420 DASD_UNRESUMED_PM)) 1421 return; 1422 rc = device->discipline->verify_path( 1423 device, device->path_data.tbvpm); 1424 if (rc) 1425 dasd_device_set_timer(device, 50); 1426 else 1427 device->path_data.tbvpm = 0; 1428 } 1429 }; 1430 1431 /* 1432 * Go through all request on the dasd_device request queue, 1433 * terminate them on the cdev if necessary, and return them to the 1434 * submitting layer via callback. 1435 * Note: 1436 * Make sure that all 'submitting layers' still exist when 1437 * this function is called!. In other words, when 'device' is a base 1438 * device then all block layer requests must have been removed before 1439 * via dasd_flush_block_queue. 1440 */ 1441 int dasd_flush_device_queue(struct dasd_device *device) 1442 { 1443 struct dasd_ccw_req *cqr, *n; 1444 int rc; 1445 struct list_head flush_queue; 1446 1447 INIT_LIST_HEAD(&flush_queue); 1448 spin_lock_irq(get_ccwdev_lock(device->cdev)); 1449 rc = 0; 1450 list_for_each_entry_safe(cqr, n, &device->ccw_queue, devlist) { 1451 /* Check status and move request to flush_queue */ 1452 switch (cqr->status) { 1453 case DASD_CQR_IN_IO: 1454 rc = device->discipline->term_IO(cqr); 1455 if (rc) { 1456 /* unable to terminate requeust */ 1457 dev_err(&device->cdev->dev, 1458 "Flushing the DASD request queue " 1459 "failed for request %p\n", cqr); 1460 /* stop flush processing */ 1461 goto finished; 1462 } 1463 break; 1464 case DASD_CQR_QUEUED: 1465 cqr->stopclk = get_clock(); 1466 cqr->status = DASD_CQR_CLEARED; 1467 break; 1468 default: /* no need to modify the others */ 1469 break; 1470 } 1471 list_move_tail(&cqr->devlist, &flush_queue); 1472 } 1473 finished: 1474 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 1475 /* 1476 * After this point all requests must be in state CLEAR_PENDING, 1477 * CLEARED, SUCCESS or ERROR. Now wait for CLEAR_PENDING to become 1478 * one of the others. 1479 */ 1480 list_for_each_entry_safe(cqr, n, &flush_queue, devlist) 1481 wait_event(dasd_flush_wq, 1482 (cqr->status != DASD_CQR_CLEAR_PENDING)); 1483 /* 1484 * Now set each request back to TERMINATED, DONE or NEED_ERP 1485 * and call the callback function of flushed requests 1486 */ 1487 __dasd_device_process_final_queue(device, &flush_queue); 1488 return rc; 1489 } 1490 1491 /* 1492 * Acquire the device lock and process queues for the device. 1493 */ 1494 static void dasd_device_tasklet(struct dasd_device *device) 1495 { 1496 struct list_head final_queue; 1497 1498 atomic_set (&device->tasklet_scheduled, 0); 1499 INIT_LIST_HEAD(&final_queue); 1500 spin_lock_irq(get_ccwdev_lock(device->cdev)); 1501 /* Check expire time of first request on the ccw queue. */ 1502 __dasd_device_check_expire(device); 1503 /* find final requests on ccw queue */ 1504 __dasd_device_process_ccw_queue(device, &final_queue); 1505 __dasd_device_check_path_events(device); 1506 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 1507 /* Now call the callback function of requests with final status */ 1508 __dasd_device_process_final_queue(device, &final_queue); 1509 spin_lock_irq(get_ccwdev_lock(device->cdev)); 1510 /* Now check if the head of the ccw queue needs to be started. */ 1511 __dasd_device_start_head(device); 1512 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 1513 dasd_put_device(device); 1514 } 1515 1516 /* 1517 * Schedules a call to dasd_tasklet over the device tasklet. 1518 */ 1519 void dasd_schedule_device_bh(struct dasd_device *device) 1520 { 1521 /* Protect against rescheduling. */ 1522 if (atomic_cmpxchg (&device->tasklet_scheduled, 0, 1) != 0) 1523 return; 1524 dasd_get_device(device); 1525 tasklet_hi_schedule(&device->tasklet); 1526 } 1527 1528 void dasd_device_set_stop_bits(struct dasd_device *device, int bits) 1529 { 1530 device->stopped |= bits; 1531 } 1532 EXPORT_SYMBOL_GPL(dasd_device_set_stop_bits); 1533 1534 void dasd_device_remove_stop_bits(struct dasd_device *device, int bits) 1535 { 1536 device->stopped &= ~bits; 1537 if (!device->stopped) 1538 wake_up(&generic_waitq); 1539 } 1540 EXPORT_SYMBOL_GPL(dasd_device_remove_stop_bits); 1541 1542 /* 1543 * Queue a request to the head of the device ccw_queue. 1544 * Start the I/O if possible. 1545 */ 1546 void dasd_add_request_head(struct dasd_ccw_req *cqr) 1547 { 1548 struct dasd_device *device; 1549 unsigned long flags; 1550 1551 device = cqr->startdev; 1552 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1553 cqr->status = DASD_CQR_QUEUED; 1554 list_add(&cqr->devlist, &device->ccw_queue); 1555 /* let the bh start the request to keep them in order */ 1556 dasd_schedule_device_bh(device); 1557 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 1558 } 1559 1560 /* 1561 * Queue a request to the tail of the device ccw_queue. 1562 * Start the I/O if possible. 1563 */ 1564 void dasd_add_request_tail(struct dasd_ccw_req *cqr) 1565 { 1566 struct dasd_device *device; 1567 unsigned long flags; 1568 1569 device = cqr->startdev; 1570 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1571 cqr->status = DASD_CQR_QUEUED; 1572 list_add_tail(&cqr->devlist, &device->ccw_queue); 1573 /* let the bh start the request to keep them in order */ 1574 dasd_schedule_device_bh(device); 1575 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 1576 } 1577 1578 /* 1579 * Wakeup helper for the 'sleep_on' functions. 1580 */ 1581 static void dasd_wakeup_cb(struct dasd_ccw_req *cqr, void *data) 1582 { 1583 spin_lock_irq(get_ccwdev_lock(cqr->startdev->cdev)); 1584 cqr->callback_data = DASD_SLEEPON_END_TAG; 1585 spin_unlock_irq(get_ccwdev_lock(cqr->startdev->cdev)); 1586 wake_up(&generic_waitq); 1587 } 1588 1589 static inline int _wait_for_wakeup(struct dasd_ccw_req *cqr) 1590 { 1591 struct dasd_device *device; 1592 int rc; 1593 1594 device = cqr->startdev; 1595 spin_lock_irq(get_ccwdev_lock(device->cdev)); 1596 rc = (cqr->callback_data == DASD_SLEEPON_END_TAG); 1597 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 1598 return rc; 1599 } 1600 1601 /* 1602 * checks if error recovery is necessary, returns 1 if yes, 0 otherwise. 1603 */ 1604 static int __dasd_sleep_on_erp(struct dasd_ccw_req *cqr) 1605 { 1606 struct dasd_device *device; 1607 dasd_erp_fn_t erp_fn; 1608 1609 if (cqr->status == DASD_CQR_FILLED) 1610 return 0; 1611 device = cqr->startdev; 1612 if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) { 1613 if (cqr->status == DASD_CQR_TERMINATED) { 1614 device->discipline->handle_terminated_request(cqr); 1615 return 1; 1616 } 1617 if (cqr->status == DASD_CQR_NEED_ERP) { 1618 erp_fn = device->discipline->erp_action(cqr); 1619 erp_fn(cqr); 1620 return 1; 1621 } 1622 if (cqr->status == DASD_CQR_FAILED) 1623 dasd_log_sense(cqr, &cqr->irb); 1624 if (cqr->refers) { 1625 __dasd_process_erp(device, cqr); 1626 return 1; 1627 } 1628 } 1629 return 0; 1630 } 1631 1632 static int __dasd_sleep_on_loop_condition(struct dasd_ccw_req *cqr) 1633 { 1634 if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) { 1635 if (cqr->refers) /* erp is not done yet */ 1636 return 1; 1637 return ((cqr->status != DASD_CQR_DONE) && 1638 (cqr->status != DASD_CQR_FAILED)); 1639 } else 1640 return (cqr->status == DASD_CQR_FILLED); 1641 } 1642 1643 static int _dasd_sleep_on(struct dasd_ccw_req *maincqr, int interruptible) 1644 { 1645 struct dasd_device *device; 1646 int rc; 1647 struct list_head ccw_queue; 1648 struct dasd_ccw_req *cqr; 1649 1650 INIT_LIST_HEAD(&ccw_queue); 1651 maincqr->status = DASD_CQR_FILLED; 1652 device = maincqr->startdev; 1653 list_add(&maincqr->blocklist, &ccw_queue); 1654 for (cqr = maincqr; __dasd_sleep_on_loop_condition(cqr); 1655 cqr = list_first_entry(&ccw_queue, 1656 struct dasd_ccw_req, blocklist)) { 1657 1658 if (__dasd_sleep_on_erp(cqr)) 1659 continue; 1660 if (cqr->status != DASD_CQR_FILLED) /* could be failed */ 1661 continue; 1662 1663 /* Non-temporary stop condition will trigger fail fast */ 1664 if (device->stopped & ~DASD_STOPPED_PENDING && 1665 test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) && 1666 (!dasd_eer_enabled(device))) { 1667 cqr->status = DASD_CQR_FAILED; 1668 continue; 1669 } 1670 1671 /* Don't try to start requests if device is stopped */ 1672 if (interruptible) { 1673 rc = wait_event_interruptible( 1674 generic_waitq, !(device->stopped)); 1675 if (rc == -ERESTARTSYS) { 1676 cqr->status = DASD_CQR_FAILED; 1677 maincqr->intrc = rc; 1678 continue; 1679 } 1680 } else 1681 wait_event(generic_waitq, !(device->stopped)); 1682 1683 cqr->callback = dasd_wakeup_cb; 1684 cqr->callback_data = DASD_SLEEPON_START_TAG; 1685 dasd_add_request_tail(cqr); 1686 if (interruptible) { 1687 rc = wait_event_interruptible( 1688 generic_waitq, _wait_for_wakeup(cqr)); 1689 if (rc == -ERESTARTSYS) { 1690 dasd_cancel_req(cqr); 1691 /* wait (non-interruptible) for final status */ 1692 wait_event(generic_waitq, 1693 _wait_for_wakeup(cqr)); 1694 cqr->status = DASD_CQR_FAILED; 1695 maincqr->intrc = rc; 1696 continue; 1697 } 1698 } else 1699 wait_event(generic_waitq, _wait_for_wakeup(cqr)); 1700 } 1701 1702 maincqr->endclk = get_clock(); 1703 if ((maincqr->status != DASD_CQR_DONE) && 1704 (maincqr->intrc != -ERESTARTSYS)) 1705 dasd_log_sense(maincqr, &maincqr->irb); 1706 if (maincqr->status == DASD_CQR_DONE) 1707 rc = 0; 1708 else if (maincqr->intrc) 1709 rc = maincqr->intrc; 1710 else 1711 rc = -EIO; 1712 return rc; 1713 } 1714 1715 /* 1716 * Queue a request to the tail of the device ccw_queue and wait for 1717 * it's completion. 1718 */ 1719 int dasd_sleep_on(struct dasd_ccw_req *cqr) 1720 { 1721 return _dasd_sleep_on(cqr, 0); 1722 } 1723 1724 /* 1725 * Queue a request to the tail of the device ccw_queue and wait 1726 * interruptible for it's completion. 1727 */ 1728 int dasd_sleep_on_interruptible(struct dasd_ccw_req *cqr) 1729 { 1730 return _dasd_sleep_on(cqr, 1); 1731 } 1732 1733 /* 1734 * Whoa nelly now it gets really hairy. For some functions (e.g. steal lock 1735 * for eckd devices) the currently running request has to be terminated 1736 * and be put back to status queued, before the special request is added 1737 * to the head of the queue. Then the special request is waited on normally. 1738 */ 1739 static inline int _dasd_term_running_cqr(struct dasd_device *device) 1740 { 1741 struct dasd_ccw_req *cqr; 1742 1743 if (list_empty(&device->ccw_queue)) 1744 return 0; 1745 cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist); 1746 return device->discipline->term_IO(cqr); 1747 } 1748 1749 int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr) 1750 { 1751 struct dasd_device *device; 1752 int rc; 1753 1754 device = cqr->startdev; 1755 spin_lock_irq(get_ccwdev_lock(device->cdev)); 1756 rc = _dasd_term_running_cqr(device); 1757 if (rc) { 1758 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 1759 return rc; 1760 } 1761 1762 cqr->callback = dasd_wakeup_cb; 1763 cqr->callback_data = DASD_SLEEPON_START_TAG; 1764 cqr->status = DASD_CQR_QUEUED; 1765 list_add(&cqr->devlist, &device->ccw_queue); 1766 1767 /* let the bh start the request to keep them in order */ 1768 dasd_schedule_device_bh(device); 1769 1770 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 1771 1772 wait_event(generic_waitq, _wait_for_wakeup(cqr)); 1773 1774 if (cqr->status == DASD_CQR_DONE) 1775 rc = 0; 1776 else if (cqr->intrc) 1777 rc = cqr->intrc; 1778 else 1779 rc = -EIO; 1780 return rc; 1781 } 1782 1783 /* 1784 * Cancels a request that was started with dasd_sleep_on_req. 1785 * This is useful to timeout requests. The request will be 1786 * terminated if it is currently in i/o. 1787 * Returns 1 if the request has been terminated. 1788 * 0 if there was no need to terminate the request (not started yet) 1789 * negative error code if termination failed 1790 * Cancellation of a request is an asynchronous operation! The calling 1791 * function has to wait until the request is properly returned via callback. 1792 */ 1793 int dasd_cancel_req(struct dasd_ccw_req *cqr) 1794 { 1795 struct dasd_device *device = cqr->startdev; 1796 unsigned long flags; 1797 int rc; 1798 1799 rc = 0; 1800 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1801 switch (cqr->status) { 1802 case DASD_CQR_QUEUED: 1803 /* request was not started - just set to cleared */ 1804 cqr->status = DASD_CQR_CLEARED; 1805 break; 1806 case DASD_CQR_IN_IO: 1807 /* request in IO - terminate IO and release again */ 1808 rc = device->discipline->term_IO(cqr); 1809 if (rc) { 1810 dev_err(&device->cdev->dev, 1811 "Cancelling request %p failed with rc=%d\n", 1812 cqr, rc); 1813 } else { 1814 cqr->stopclk = get_clock(); 1815 } 1816 break; 1817 default: /* already finished or clear pending - do nothing */ 1818 break; 1819 } 1820 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 1821 dasd_schedule_device_bh(device); 1822 return rc; 1823 } 1824 1825 1826 /* 1827 * SECTION: Operations of the dasd_block layer. 1828 */ 1829 1830 /* 1831 * Timeout function for dasd_block. This is used when the block layer 1832 * is waiting for something that may not come reliably, (e.g. a state 1833 * change interrupt) 1834 */ 1835 static void dasd_block_timeout(unsigned long ptr) 1836 { 1837 unsigned long flags; 1838 struct dasd_block *block; 1839 1840 block = (struct dasd_block *) ptr; 1841 spin_lock_irqsave(get_ccwdev_lock(block->base->cdev), flags); 1842 /* re-activate request queue */ 1843 dasd_device_remove_stop_bits(block->base, DASD_STOPPED_PENDING); 1844 spin_unlock_irqrestore(get_ccwdev_lock(block->base->cdev), flags); 1845 dasd_schedule_block_bh(block); 1846 } 1847 1848 /* 1849 * Setup timeout for a dasd_block in jiffies. 1850 */ 1851 void dasd_block_set_timer(struct dasd_block *block, int expires) 1852 { 1853 if (expires == 0) 1854 del_timer(&block->timer); 1855 else 1856 mod_timer(&block->timer, jiffies + expires); 1857 } 1858 1859 /* 1860 * Clear timeout for a dasd_block. 1861 */ 1862 void dasd_block_clear_timer(struct dasd_block *block) 1863 { 1864 del_timer(&block->timer); 1865 } 1866 1867 /* 1868 * Process finished error recovery ccw. 1869 */ 1870 static void __dasd_process_erp(struct dasd_device *device, 1871 struct dasd_ccw_req *cqr) 1872 { 1873 dasd_erp_fn_t erp_fn; 1874 1875 if (cqr->status == DASD_CQR_DONE) 1876 DBF_DEV_EVENT(DBF_NOTICE, device, "%s", "ERP successful"); 1877 else 1878 dev_err(&device->cdev->dev, "ERP failed for the DASD\n"); 1879 erp_fn = device->discipline->erp_postaction(cqr); 1880 erp_fn(cqr); 1881 } 1882 1883 /* 1884 * Fetch requests from the block device queue. 1885 */ 1886 static void __dasd_process_request_queue(struct dasd_block *block) 1887 { 1888 struct request_queue *queue; 1889 struct request *req; 1890 struct dasd_ccw_req *cqr; 1891 struct dasd_device *basedev; 1892 unsigned long flags; 1893 queue = block->request_queue; 1894 basedev = block->base; 1895 /* No queue ? Then there is nothing to do. */ 1896 if (queue == NULL) 1897 return; 1898 1899 /* 1900 * We requeue request from the block device queue to the ccw 1901 * queue only in two states. In state DASD_STATE_READY the 1902 * partition detection is done and we need to requeue requests 1903 * for that. State DASD_STATE_ONLINE is normal block device 1904 * operation. 1905 */ 1906 if (basedev->state < DASD_STATE_READY) { 1907 while ((req = blk_fetch_request(block->request_queue))) 1908 __blk_end_request_all(req, -EIO); 1909 return; 1910 } 1911 /* Now we try to fetch requests from the request queue */ 1912 while (!blk_queue_plugged(queue) && (req = blk_peek_request(queue))) { 1913 if (basedev->features & DASD_FEATURE_READONLY && 1914 rq_data_dir(req) == WRITE) { 1915 DBF_DEV_EVENT(DBF_ERR, basedev, 1916 "Rejecting write request %p", 1917 req); 1918 blk_start_request(req); 1919 __blk_end_request_all(req, -EIO); 1920 continue; 1921 } 1922 cqr = basedev->discipline->build_cp(basedev, block, req); 1923 if (IS_ERR(cqr)) { 1924 if (PTR_ERR(cqr) == -EBUSY) 1925 break; /* normal end condition */ 1926 if (PTR_ERR(cqr) == -ENOMEM) 1927 break; /* terminate request queue loop */ 1928 if (PTR_ERR(cqr) == -EAGAIN) { 1929 /* 1930 * The current request cannot be build right 1931 * now, we have to try later. If this request 1932 * is the head-of-queue we stop the device 1933 * for 1/2 second. 1934 */ 1935 if (!list_empty(&block->ccw_queue)) 1936 break; 1937 spin_lock_irqsave( 1938 get_ccwdev_lock(basedev->cdev), flags); 1939 dasd_device_set_stop_bits(basedev, 1940 DASD_STOPPED_PENDING); 1941 spin_unlock_irqrestore( 1942 get_ccwdev_lock(basedev->cdev), flags); 1943 dasd_block_set_timer(block, HZ/2); 1944 break; 1945 } 1946 DBF_DEV_EVENT(DBF_ERR, basedev, 1947 "CCW creation failed (rc=%ld) " 1948 "on request %p", 1949 PTR_ERR(cqr), req); 1950 blk_start_request(req); 1951 __blk_end_request_all(req, -EIO); 1952 continue; 1953 } 1954 /* 1955 * Note: callback is set to dasd_return_cqr_cb in 1956 * __dasd_block_start_head to cover erp requests as well 1957 */ 1958 cqr->callback_data = (void *) req; 1959 cqr->status = DASD_CQR_FILLED; 1960 blk_start_request(req); 1961 list_add_tail(&cqr->blocklist, &block->ccw_queue); 1962 dasd_profile_start(block, cqr, req); 1963 } 1964 } 1965 1966 static void __dasd_cleanup_cqr(struct dasd_ccw_req *cqr) 1967 { 1968 struct request *req; 1969 int status; 1970 int error = 0; 1971 1972 req = (struct request *) cqr->callback_data; 1973 dasd_profile_end(cqr->block, cqr, req); 1974 status = cqr->block->base->discipline->free_cp(cqr, req); 1975 if (status <= 0) 1976 error = status ? status : -EIO; 1977 __blk_end_request_all(req, error); 1978 } 1979 1980 /* 1981 * Process ccw request queue. 1982 */ 1983 static void __dasd_process_block_ccw_queue(struct dasd_block *block, 1984 struct list_head *final_queue) 1985 { 1986 struct list_head *l, *n; 1987 struct dasd_ccw_req *cqr; 1988 dasd_erp_fn_t erp_fn; 1989 unsigned long flags; 1990 struct dasd_device *base = block->base; 1991 1992 restart: 1993 /* Process request with final status. */ 1994 list_for_each_safe(l, n, &block->ccw_queue) { 1995 cqr = list_entry(l, struct dasd_ccw_req, blocklist); 1996 if (cqr->status != DASD_CQR_DONE && 1997 cqr->status != DASD_CQR_FAILED && 1998 cqr->status != DASD_CQR_NEED_ERP && 1999 cqr->status != DASD_CQR_TERMINATED) 2000 continue; 2001 2002 if (cqr->status == DASD_CQR_TERMINATED) { 2003 base->discipline->handle_terminated_request(cqr); 2004 goto restart; 2005 } 2006 2007 /* Process requests that may be recovered */ 2008 if (cqr->status == DASD_CQR_NEED_ERP) { 2009 erp_fn = base->discipline->erp_action(cqr); 2010 if (IS_ERR(erp_fn(cqr))) 2011 continue; 2012 goto restart; 2013 } 2014 2015 /* log sense for fatal error */ 2016 if (cqr->status == DASD_CQR_FAILED) { 2017 dasd_log_sense(cqr, &cqr->irb); 2018 } 2019 2020 /* First of all call extended error reporting. */ 2021 if (dasd_eer_enabled(base) && 2022 cqr->status == DASD_CQR_FAILED) { 2023 dasd_eer_write(base, cqr, DASD_EER_FATALERROR); 2024 2025 /* restart request */ 2026 cqr->status = DASD_CQR_FILLED; 2027 cqr->retries = 255; 2028 spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags); 2029 dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE); 2030 spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), 2031 flags); 2032 goto restart; 2033 } 2034 2035 /* Process finished ERP request. */ 2036 if (cqr->refers) { 2037 __dasd_process_erp(base, cqr); 2038 goto restart; 2039 } 2040 2041 /* Rechain finished requests to final queue */ 2042 cqr->endclk = get_clock(); 2043 list_move_tail(&cqr->blocklist, final_queue); 2044 } 2045 } 2046 2047 static void dasd_return_cqr_cb(struct dasd_ccw_req *cqr, void *data) 2048 { 2049 dasd_schedule_block_bh(cqr->block); 2050 } 2051 2052 static void __dasd_block_start_head(struct dasd_block *block) 2053 { 2054 struct dasd_ccw_req *cqr; 2055 2056 if (list_empty(&block->ccw_queue)) 2057 return; 2058 /* We allways begin with the first requests on the queue, as some 2059 * of previously started requests have to be enqueued on a 2060 * dasd_device again for error recovery. 2061 */ 2062 list_for_each_entry(cqr, &block->ccw_queue, blocklist) { 2063 if (cqr->status != DASD_CQR_FILLED) 2064 continue; 2065 /* Non-temporary stop condition will trigger fail fast */ 2066 if (block->base->stopped & ~DASD_STOPPED_PENDING && 2067 test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) && 2068 (!dasd_eer_enabled(block->base))) { 2069 cqr->status = DASD_CQR_FAILED; 2070 dasd_schedule_block_bh(block); 2071 continue; 2072 } 2073 /* Don't try to start requests if device is stopped */ 2074 if (block->base->stopped) 2075 return; 2076 2077 /* just a fail safe check, should not happen */ 2078 if (!cqr->startdev) 2079 cqr->startdev = block->base; 2080 2081 /* make sure that the requests we submit find their way back */ 2082 cqr->callback = dasd_return_cqr_cb; 2083 2084 dasd_add_request_tail(cqr); 2085 } 2086 } 2087 2088 /* 2089 * Central dasd_block layer routine. Takes requests from the generic 2090 * block layer request queue, creates ccw requests, enqueues them on 2091 * a dasd_device and processes ccw requests that have been returned. 2092 */ 2093 static void dasd_block_tasklet(struct dasd_block *block) 2094 { 2095 struct list_head final_queue; 2096 struct list_head *l, *n; 2097 struct dasd_ccw_req *cqr; 2098 2099 atomic_set(&block->tasklet_scheduled, 0); 2100 INIT_LIST_HEAD(&final_queue); 2101 spin_lock(&block->queue_lock); 2102 /* Finish off requests on ccw queue */ 2103 __dasd_process_block_ccw_queue(block, &final_queue); 2104 spin_unlock(&block->queue_lock); 2105 /* Now call the callback function of requests with final status */ 2106 spin_lock_irq(&block->request_queue_lock); 2107 list_for_each_safe(l, n, &final_queue) { 2108 cqr = list_entry(l, struct dasd_ccw_req, blocklist); 2109 list_del_init(&cqr->blocklist); 2110 __dasd_cleanup_cqr(cqr); 2111 } 2112 spin_lock(&block->queue_lock); 2113 /* Get new request from the block device request queue */ 2114 __dasd_process_request_queue(block); 2115 /* Now check if the head of the ccw queue needs to be started. */ 2116 __dasd_block_start_head(block); 2117 spin_unlock(&block->queue_lock); 2118 spin_unlock_irq(&block->request_queue_lock); 2119 dasd_put_device(block->base); 2120 } 2121 2122 static void _dasd_wake_block_flush_cb(struct dasd_ccw_req *cqr, void *data) 2123 { 2124 wake_up(&dasd_flush_wq); 2125 } 2126 2127 /* 2128 * Go through all request on the dasd_block request queue, cancel them 2129 * on the respective dasd_device, and return them to the generic 2130 * block layer. 2131 */ 2132 static int dasd_flush_block_queue(struct dasd_block *block) 2133 { 2134 struct dasd_ccw_req *cqr, *n; 2135 int rc, i; 2136 struct list_head flush_queue; 2137 2138 INIT_LIST_HEAD(&flush_queue); 2139 spin_lock_bh(&block->queue_lock); 2140 rc = 0; 2141 restart: 2142 list_for_each_entry_safe(cqr, n, &block->ccw_queue, blocklist) { 2143 /* if this request currently owned by a dasd_device cancel it */ 2144 if (cqr->status >= DASD_CQR_QUEUED) 2145 rc = dasd_cancel_req(cqr); 2146 if (rc < 0) 2147 break; 2148 /* Rechain request (including erp chain) so it won't be 2149 * touched by the dasd_block_tasklet anymore. 2150 * Replace the callback so we notice when the request 2151 * is returned from the dasd_device layer. 2152 */ 2153 cqr->callback = _dasd_wake_block_flush_cb; 2154 for (i = 0; cqr != NULL; cqr = cqr->refers, i++) 2155 list_move_tail(&cqr->blocklist, &flush_queue); 2156 if (i > 1) 2157 /* moved more than one request - need to restart */ 2158 goto restart; 2159 } 2160 spin_unlock_bh(&block->queue_lock); 2161 /* Now call the callback function of flushed requests */ 2162 restart_cb: 2163 list_for_each_entry_safe(cqr, n, &flush_queue, blocklist) { 2164 wait_event(dasd_flush_wq, (cqr->status < DASD_CQR_QUEUED)); 2165 /* Process finished ERP request. */ 2166 if (cqr->refers) { 2167 spin_lock_bh(&block->queue_lock); 2168 __dasd_process_erp(block->base, cqr); 2169 spin_unlock_bh(&block->queue_lock); 2170 /* restart list_for_xx loop since dasd_process_erp 2171 * might remove multiple elements */ 2172 goto restart_cb; 2173 } 2174 /* call the callback function */ 2175 spin_lock_irq(&block->request_queue_lock); 2176 cqr->endclk = get_clock(); 2177 list_del_init(&cqr->blocklist); 2178 __dasd_cleanup_cqr(cqr); 2179 spin_unlock_irq(&block->request_queue_lock); 2180 } 2181 return rc; 2182 } 2183 2184 /* 2185 * Schedules a call to dasd_tasklet over the device tasklet. 2186 */ 2187 void dasd_schedule_block_bh(struct dasd_block *block) 2188 { 2189 /* Protect against rescheduling. */ 2190 if (atomic_cmpxchg(&block->tasklet_scheduled, 0, 1) != 0) 2191 return; 2192 /* life cycle of block is bound to it's base device */ 2193 dasd_get_device(block->base); 2194 tasklet_hi_schedule(&block->tasklet); 2195 } 2196 2197 2198 /* 2199 * SECTION: external block device operations 2200 * (request queue handling, open, release, etc.) 2201 */ 2202 2203 /* 2204 * Dasd request queue function. Called from ll_rw_blk.c 2205 */ 2206 static void do_dasd_request(struct request_queue *queue) 2207 { 2208 struct dasd_block *block; 2209 2210 block = queue->queuedata; 2211 spin_lock(&block->queue_lock); 2212 /* Get new request from the block device request queue */ 2213 __dasd_process_request_queue(block); 2214 /* Now check if the head of the ccw queue needs to be started. */ 2215 __dasd_block_start_head(block); 2216 spin_unlock(&block->queue_lock); 2217 } 2218 2219 /* 2220 * Allocate and initialize request queue and default I/O scheduler. 2221 */ 2222 static int dasd_alloc_queue(struct dasd_block *block) 2223 { 2224 int rc; 2225 2226 block->request_queue = blk_init_queue(do_dasd_request, 2227 &block->request_queue_lock); 2228 if (block->request_queue == NULL) 2229 return -ENOMEM; 2230 2231 block->request_queue->queuedata = block; 2232 2233 elevator_exit(block->request_queue->elevator); 2234 block->request_queue->elevator = NULL; 2235 rc = elevator_init(block->request_queue, "deadline"); 2236 if (rc) { 2237 blk_cleanup_queue(block->request_queue); 2238 return rc; 2239 } 2240 return 0; 2241 } 2242 2243 /* 2244 * Allocate and initialize request queue. 2245 */ 2246 static void dasd_setup_queue(struct dasd_block *block) 2247 { 2248 int max; 2249 2250 blk_queue_logical_block_size(block->request_queue, block->bp_block); 2251 max = block->base->discipline->max_blocks << block->s2b_shift; 2252 blk_queue_max_hw_sectors(block->request_queue, max); 2253 blk_queue_max_segments(block->request_queue, -1L); 2254 /* with page sized segments we can translate each segement into 2255 * one idaw/tidaw 2256 */ 2257 blk_queue_max_segment_size(block->request_queue, PAGE_SIZE); 2258 blk_queue_segment_boundary(block->request_queue, PAGE_SIZE - 1); 2259 } 2260 2261 /* 2262 * Deactivate and free request queue. 2263 */ 2264 static void dasd_free_queue(struct dasd_block *block) 2265 { 2266 if (block->request_queue) { 2267 blk_cleanup_queue(block->request_queue); 2268 block->request_queue = NULL; 2269 } 2270 } 2271 2272 /* 2273 * Flush request on the request queue. 2274 */ 2275 static void dasd_flush_request_queue(struct dasd_block *block) 2276 { 2277 struct request *req; 2278 2279 if (!block->request_queue) 2280 return; 2281 2282 spin_lock_irq(&block->request_queue_lock); 2283 while ((req = blk_fetch_request(block->request_queue))) 2284 __blk_end_request_all(req, -EIO); 2285 spin_unlock_irq(&block->request_queue_lock); 2286 } 2287 2288 static int dasd_open(struct block_device *bdev, fmode_t mode) 2289 { 2290 struct dasd_block *block = bdev->bd_disk->private_data; 2291 struct dasd_device *base; 2292 int rc; 2293 2294 if (!block) 2295 return -ENODEV; 2296 2297 base = block->base; 2298 atomic_inc(&block->open_count); 2299 if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) { 2300 rc = -ENODEV; 2301 goto unlock; 2302 } 2303 2304 if (!try_module_get(base->discipline->owner)) { 2305 rc = -EINVAL; 2306 goto unlock; 2307 } 2308 2309 if (dasd_probeonly) { 2310 dev_info(&base->cdev->dev, 2311 "Accessing the DASD failed because it is in " 2312 "probeonly mode\n"); 2313 rc = -EPERM; 2314 goto out; 2315 } 2316 2317 if (base->state <= DASD_STATE_BASIC) { 2318 DBF_DEV_EVENT(DBF_ERR, base, " %s", 2319 " Cannot open unrecognized device"); 2320 rc = -ENODEV; 2321 goto out; 2322 } 2323 2324 if ((mode & FMODE_WRITE) && 2325 (test_bit(DASD_FLAG_DEVICE_RO, &base->flags) || 2326 (base->features & DASD_FEATURE_READONLY))) { 2327 rc = -EROFS; 2328 goto out; 2329 } 2330 2331 return 0; 2332 2333 out: 2334 module_put(base->discipline->owner); 2335 unlock: 2336 atomic_dec(&block->open_count); 2337 return rc; 2338 } 2339 2340 static int dasd_release(struct gendisk *disk, fmode_t mode) 2341 { 2342 struct dasd_block *block = disk->private_data; 2343 2344 atomic_dec(&block->open_count); 2345 module_put(block->base->discipline->owner); 2346 return 0; 2347 } 2348 2349 /* 2350 * Return disk geometry. 2351 */ 2352 static int dasd_getgeo(struct block_device *bdev, struct hd_geometry *geo) 2353 { 2354 struct dasd_block *block; 2355 struct dasd_device *base; 2356 2357 block = bdev->bd_disk->private_data; 2358 if (!block) 2359 return -ENODEV; 2360 base = block->base; 2361 2362 if (!base->discipline || 2363 !base->discipline->fill_geometry) 2364 return -EINVAL; 2365 2366 base->discipline->fill_geometry(block, geo); 2367 geo->start = get_start_sect(bdev) >> block->s2b_shift; 2368 return 0; 2369 } 2370 2371 const struct block_device_operations 2372 dasd_device_operations = { 2373 .owner = THIS_MODULE, 2374 .open = dasd_open, 2375 .release = dasd_release, 2376 .ioctl = dasd_ioctl, 2377 .compat_ioctl = dasd_ioctl, 2378 .getgeo = dasd_getgeo, 2379 }; 2380 2381 /******************************************************************************* 2382 * end of block device operations 2383 */ 2384 2385 static void 2386 dasd_exit(void) 2387 { 2388 #ifdef CONFIG_PROC_FS 2389 dasd_proc_exit(); 2390 #endif 2391 dasd_eer_exit(); 2392 if (dasd_page_cache != NULL) { 2393 kmem_cache_destroy(dasd_page_cache); 2394 dasd_page_cache = NULL; 2395 } 2396 dasd_gendisk_exit(); 2397 dasd_devmap_exit(); 2398 if (dasd_debug_area != NULL) { 2399 debug_unregister(dasd_debug_area); 2400 dasd_debug_area = NULL; 2401 } 2402 } 2403 2404 /* 2405 * SECTION: common functions for ccw_driver use 2406 */ 2407 2408 /* 2409 * Is the device read-only? 2410 * Note that this function does not report the setting of the 2411 * readonly device attribute, but how it is configured in z/VM. 2412 */ 2413 int dasd_device_is_ro(struct dasd_device *device) 2414 { 2415 struct ccw_dev_id dev_id; 2416 struct diag210 diag_data; 2417 int rc; 2418 2419 if (!MACHINE_IS_VM) 2420 return 0; 2421 ccw_device_get_id(device->cdev, &dev_id); 2422 memset(&diag_data, 0, sizeof(diag_data)); 2423 diag_data.vrdcdvno = dev_id.devno; 2424 diag_data.vrdclen = sizeof(diag_data); 2425 rc = diag210(&diag_data); 2426 if (rc == 0 || rc == 2) { 2427 return diag_data.vrdcvfla & 0x80; 2428 } else { 2429 DBF_EVENT(DBF_WARNING, "diag210 failed for dev=%04x with rc=%d", 2430 dev_id.devno, rc); 2431 return 0; 2432 } 2433 } 2434 EXPORT_SYMBOL_GPL(dasd_device_is_ro); 2435 2436 static void dasd_generic_auto_online(void *data, async_cookie_t cookie) 2437 { 2438 struct ccw_device *cdev = data; 2439 int ret; 2440 2441 ret = ccw_device_set_online(cdev); 2442 if (ret) 2443 pr_warning("%s: Setting the DASD online failed with rc=%d\n", 2444 dev_name(&cdev->dev), ret); 2445 } 2446 2447 /* 2448 * Initial attempt at a probe function. this can be simplified once 2449 * the other detection code is gone. 2450 */ 2451 int dasd_generic_probe(struct ccw_device *cdev, 2452 struct dasd_discipline *discipline) 2453 { 2454 int ret; 2455 2456 ret = dasd_add_sysfs_files(cdev); 2457 if (ret) { 2458 DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s", 2459 "dasd_generic_probe: could not add " 2460 "sysfs entries"); 2461 return ret; 2462 } 2463 cdev->handler = &dasd_int_handler; 2464 2465 /* 2466 * Automatically online either all dasd devices (dasd_autodetect) 2467 * or all devices specified with dasd= parameters during 2468 * initial probe. 2469 */ 2470 if ((dasd_get_feature(cdev, DASD_FEATURE_INITIAL_ONLINE) > 0 ) || 2471 (dasd_autodetect && dasd_busid_known(dev_name(&cdev->dev)) != 0)) 2472 async_schedule(dasd_generic_auto_online, cdev); 2473 return 0; 2474 } 2475 2476 /* 2477 * This will one day be called from a global not_oper handler. 2478 * It is also used by driver_unregister during module unload. 2479 */ 2480 void dasd_generic_remove(struct ccw_device *cdev) 2481 { 2482 struct dasd_device *device; 2483 struct dasd_block *block; 2484 2485 cdev->handler = NULL; 2486 2487 dasd_remove_sysfs_files(cdev); 2488 device = dasd_device_from_cdev(cdev); 2489 if (IS_ERR(device)) 2490 return; 2491 if (test_and_set_bit(DASD_FLAG_OFFLINE, &device->flags)) { 2492 /* Already doing offline processing */ 2493 dasd_put_device(device); 2494 return; 2495 } 2496 /* 2497 * This device is removed unconditionally. Set offline 2498 * flag to prevent dasd_open from opening it while it is 2499 * no quite down yet. 2500 */ 2501 dasd_set_target_state(device, DASD_STATE_NEW); 2502 /* dasd_delete_device destroys the device reference. */ 2503 block = device->block; 2504 device->block = NULL; 2505 dasd_delete_device(device); 2506 /* 2507 * life cycle of block is bound to device, so delete it after 2508 * device was safely removed 2509 */ 2510 if (block) 2511 dasd_free_block(block); 2512 } 2513 2514 /* 2515 * Activate a device. This is called from dasd_{eckd,fba}_probe() when either 2516 * the device is detected for the first time and is supposed to be used 2517 * or the user has started activation through sysfs. 2518 */ 2519 int dasd_generic_set_online(struct ccw_device *cdev, 2520 struct dasd_discipline *base_discipline) 2521 { 2522 struct dasd_discipline *discipline; 2523 struct dasd_device *device; 2524 int rc; 2525 2526 /* first online clears initial online feature flag */ 2527 dasd_set_feature(cdev, DASD_FEATURE_INITIAL_ONLINE, 0); 2528 device = dasd_create_device(cdev); 2529 if (IS_ERR(device)) 2530 return PTR_ERR(device); 2531 2532 discipline = base_discipline; 2533 if (device->features & DASD_FEATURE_USEDIAG) { 2534 if (!dasd_diag_discipline_pointer) { 2535 pr_warning("%s Setting the DASD online failed because " 2536 "of missing DIAG discipline\n", 2537 dev_name(&cdev->dev)); 2538 dasd_delete_device(device); 2539 return -ENODEV; 2540 } 2541 discipline = dasd_diag_discipline_pointer; 2542 } 2543 if (!try_module_get(base_discipline->owner)) { 2544 dasd_delete_device(device); 2545 return -EINVAL; 2546 } 2547 if (!try_module_get(discipline->owner)) { 2548 module_put(base_discipline->owner); 2549 dasd_delete_device(device); 2550 return -EINVAL; 2551 } 2552 device->base_discipline = base_discipline; 2553 device->discipline = discipline; 2554 2555 /* check_device will allocate block device if necessary */ 2556 rc = discipline->check_device(device); 2557 if (rc) { 2558 pr_warning("%s Setting the DASD online with discipline %s " 2559 "failed with rc=%i\n", 2560 dev_name(&cdev->dev), discipline->name, rc); 2561 module_put(discipline->owner); 2562 module_put(base_discipline->owner); 2563 dasd_delete_device(device); 2564 return rc; 2565 } 2566 2567 dasd_set_target_state(device, DASD_STATE_ONLINE); 2568 if (device->state <= DASD_STATE_KNOWN) { 2569 pr_warning("%s Setting the DASD online failed because of a " 2570 "missing discipline\n", dev_name(&cdev->dev)); 2571 rc = -ENODEV; 2572 dasd_set_target_state(device, DASD_STATE_NEW); 2573 if (device->block) 2574 dasd_free_block(device->block); 2575 dasd_delete_device(device); 2576 } else 2577 pr_debug("dasd_generic device %s found\n", 2578 dev_name(&cdev->dev)); 2579 2580 wait_event(dasd_init_waitq, _wait_for_device(device)); 2581 2582 dasd_put_device(device); 2583 return rc; 2584 } 2585 2586 int dasd_generic_set_offline(struct ccw_device *cdev) 2587 { 2588 struct dasd_device *device; 2589 struct dasd_block *block; 2590 int max_count, open_count; 2591 2592 device = dasd_device_from_cdev(cdev); 2593 if (IS_ERR(device)) 2594 return PTR_ERR(device); 2595 if (test_and_set_bit(DASD_FLAG_OFFLINE, &device->flags)) { 2596 /* Already doing offline processing */ 2597 dasd_put_device(device); 2598 return 0; 2599 } 2600 /* 2601 * We must make sure that this device is currently not in use. 2602 * The open_count is increased for every opener, that includes 2603 * the blkdev_get in dasd_scan_partitions. We are only interested 2604 * in the other openers. 2605 */ 2606 if (device->block) { 2607 max_count = device->block->bdev ? 0 : -1; 2608 open_count = atomic_read(&device->block->open_count); 2609 if (open_count > max_count) { 2610 if (open_count > 0) 2611 pr_warning("%s: The DASD cannot be set offline " 2612 "with open count %i\n", 2613 dev_name(&cdev->dev), open_count); 2614 else 2615 pr_warning("%s: The DASD cannot be set offline " 2616 "while it is in use\n", 2617 dev_name(&cdev->dev)); 2618 clear_bit(DASD_FLAG_OFFLINE, &device->flags); 2619 dasd_put_device(device); 2620 return -EBUSY; 2621 } 2622 } 2623 dasd_set_target_state(device, DASD_STATE_NEW); 2624 /* dasd_delete_device destroys the device reference. */ 2625 block = device->block; 2626 device->block = NULL; 2627 dasd_delete_device(device); 2628 /* 2629 * life cycle of block is bound to device, so delete it after 2630 * device was safely removed 2631 */ 2632 if (block) 2633 dasd_free_block(block); 2634 return 0; 2635 } 2636 2637 int dasd_generic_last_path_gone(struct dasd_device *device) 2638 { 2639 struct dasd_ccw_req *cqr; 2640 2641 dev_warn(&device->cdev->dev, "No operational channel path is left " 2642 "for the device\n"); 2643 DBF_DEV_EVENT(DBF_WARNING, device, "%s", "last path gone"); 2644 /* First of all call extended error reporting. */ 2645 dasd_eer_write(device, NULL, DASD_EER_NOPATH); 2646 2647 if (device->state < DASD_STATE_BASIC) 2648 return 0; 2649 /* Device is active. We want to keep it. */ 2650 list_for_each_entry(cqr, &device->ccw_queue, devlist) 2651 if ((cqr->status == DASD_CQR_IN_IO) || 2652 (cqr->status == DASD_CQR_CLEAR_PENDING)) { 2653 cqr->status = DASD_CQR_QUEUED; 2654 cqr->retries++; 2655 } 2656 dasd_device_set_stop_bits(device, DASD_STOPPED_DC_WAIT); 2657 dasd_device_clear_timer(device); 2658 dasd_schedule_device_bh(device); 2659 return 1; 2660 } 2661 EXPORT_SYMBOL_GPL(dasd_generic_last_path_gone); 2662 2663 int dasd_generic_path_operational(struct dasd_device *device) 2664 { 2665 dev_info(&device->cdev->dev, "A channel path to the device has become " 2666 "operational\n"); 2667 DBF_DEV_EVENT(DBF_WARNING, device, "%s", "path operational"); 2668 dasd_device_remove_stop_bits(device, DASD_STOPPED_DC_WAIT); 2669 if (device->stopped & DASD_UNRESUMED_PM) { 2670 dasd_device_remove_stop_bits(device, DASD_UNRESUMED_PM); 2671 dasd_restore_device(device); 2672 return 1; 2673 } 2674 dasd_schedule_device_bh(device); 2675 if (device->block) 2676 dasd_schedule_block_bh(device->block); 2677 return 1; 2678 } 2679 EXPORT_SYMBOL_GPL(dasd_generic_path_operational); 2680 2681 int dasd_generic_notify(struct ccw_device *cdev, int event) 2682 { 2683 struct dasd_device *device; 2684 int ret; 2685 2686 device = dasd_device_from_cdev_locked(cdev); 2687 if (IS_ERR(device)) 2688 return 0; 2689 ret = 0; 2690 switch (event) { 2691 case CIO_GONE: 2692 case CIO_BOXED: 2693 case CIO_NO_PATH: 2694 device->path_data.opm = 0; 2695 device->path_data.ppm = 0; 2696 device->path_data.npm = 0; 2697 ret = dasd_generic_last_path_gone(device); 2698 break; 2699 case CIO_OPER: 2700 ret = 1; 2701 if (device->path_data.opm) 2702 ret = dasd_generic_path_operational(device); 2703 break; 2704 } 2705 dasd_put_device(device); 2706 return ret; 2707 } 2708 2709 void dasd_generic_path_event(struct ccw_device *cdev, int *path_event) 2710 { 2711 int chp; 2712 __u8 oldopm, eventlpm; 2713 struct dasd_device *device; 2714 2715 device = dasd_device_from_cdev_locked(cdev); 2716 if (IS_ERR(device)) 2717 return; 2718 for (chp = 0; chp < 8; chp++) { 2719 eventlpm = 0x80 >> chp; 2720 if (path_event[chp] & PE_PATH_GONE) { 2721 oldopm = device->path_data.opm; 2722 device->path_data.opm &= ~eventlpm; 2723 device->path_data.ppm &= ~eventlpm; 2724 device->path_data.npm &= ~eventlpm; 2725 if (oldopm && !device->path_data.opm) 2726 dasd_generic_last_path_gone(device); 2727 } 2728 if (path_event[chp] & PE_PATH_AVAILABLE) { 2729 device->path_data.opm &= ~eventlpm; 2730 device->path_data.ppm &= ~eventlpm; 2731 device->path_data.npm &= ~eventlpm; 2732 device->path_data.tbvpm |= eventlpm; 2733 dasd_schedule_device_bh(device); 2734 } 2735 } 2736 dasd_put_device(device); 2737 } 2738 EXPORT_SYMBOL_GPL(dasd_generic_path_event); 2739 2740 int dasd_generic_verify_path(struct dasd_device *device, __u8 lpm) 2741 { 2742 if (!device->path_data.opm && lpm) { 2743 device->path_data.opm = lpm; 2744 dasd_generic_path_operational(device); 2745 } else 2746 device->path_data.opm |= lpm; 2747 return 0; 2748 } 2749 EXPORT_SYMBOL_GPL(dasd_generic_verify_path); 2750 2751 2752 int dasd_generic_pm_freeze(struct ccw_device *cdev) 2753 { 2754 struct dasd_ccw_req *cqr, *n; 2755 int rc; 2756 struct list_head freeze_queue; 2757 struct dasd_device *device = dasd_device_from_cdev(cdev); 2758 2759 if (IS_ERR(device)) 2760 return PTR_ERR(device); 2761 /* disallow new I/O */ 2762 dasd_device_set_stop_bits(device, DASD_STOPPED_PM); 2763 /* clear active requests */ 2764 INIT_LIST_HEAD(&freeze_queue); 2765 spin_lock_irq(get_ccwdev_lock(cdev)); 2766 rc = 0; 2767 list_for_each_entry_safe(cqr, n, &device->ccw_queue, devlist) { 2768 /* Check status and move request to flush_queue */ 2769 if (cqr->status == DASD_CQR_IN_IO) { 2770 rc = device->discipline->term_IO(cqr); 2771 if (rc) { 2772 /* unable to terminate requeust */ 2773 dev_err(&device->cdev->dev, 2774 "Unable to terminate request %p " 2775 "on suspend\n", cqr); 2776 spin_unlock_irq(get_ccwdev_lock(cdev)); 2777 dasd_put_device(device); 2778 return rc; 2779 } 2780 } 2781 list_move_tail(&cqr->devlist, &freeze_queue); 2782 } 2783 2784 spin_unlock_irq(get_ccwdev_lock(cdev)); 2785 2786 list_for_each_entry_safe(cqr, n, &freeze_queue, devlist) { 2787 wait_event(dasd_flush_wq, 2788 (cqr->status != DASD_CQR_CLEAR_PENDING)); 2789 if (cqr->status == DASD_CQR_CLEARED) 2790 cqr->status = DASD_CQR_QUEUED; 2791 } 2792 /* move freeze_queue to start of the ccw_queue */ 2793 spin_lock_irq(get_ccwdev_lock(cdev)); 2794 list_splice_tail(&freeze_queue, &device->ccw_queue); 2795 spin_unlock_irq(get_ccwdev_lock(cdev)); 2796 2797 if (device->discipline->freeze) 2798 rc = device->discipline->freeze(device); 2799 2800 dasd_put_device(device); 2801 return rc; 2802 } 2803 EXPORT_SYMBOL_GPL(dasd_generic_pm_freeze); 2804 2805 int dasd_generic_restore_device(struct ccw_device *cdev) 2806 { 2807 struct dasd_device *device = dasd_device_from_cdev(cdev); 2808 int rc = 0; 2809 2810 if (IS_ERR(device)) 2811 return PTR_ERR(device); 2812 2813 /* allow new IO again */ 2814 dasd_device_remove_stop_bits(device, 2815 (DASD_STOPPED_PM | DASD_UNRESUMED_PM)); 2816 2817 dasd_schedule_device_bh(device); 2818 2819 /* 2820 * call discipline restore function 2821 * if device is stopped do nothing e.g. for disconnected devices 2822 */ 2823 if (device->discipline->restore && !(device->stopped)) 2824 rc = device->discipline->restore(device); 2825 if (rc || device->stopped) 2826 /* 2827 * if the resume failed for the DASD we put it in 2828 * an UNRESUMED stop state 2829 */ 2830 device->stopped |= DASD_UNRESUMED_PM; 2831 2832 if (device->block) 2833 dasd_schedule_block_bh(device->block); 2834 2835 dasd_put_device(device); 2836 return 0; 2837 } 2838 EXPORT_SYMBOL_GPL(dasd_generic_restore_device); 2839 2840 static struct dasd_ccw_req *dasd_generic_build_rdc(struct dasd_device *device, 2841 void *rdc_buffer, 2842 int rdc_buffer_size, 2843 int magic) 2844 { 2845 struct dasd_ccw_req *cqr; 2846 struct ccw1 *ccw; 2847 unsigned long *idaw; 2848 2849 cqr = dasd_smalloc_request(magic, 1 /* RDC */, rdc_buffer_size, device); 2850 2851 if (IS_ERR(cqr)) { 2852 /* internal error 13 - Allocating the RDC request failed*/ 2853 dev_err(&device->cdev->dev, 2854 "An error occurred in the DASD device driver, " 2855 "reason=%s\n", "13"); 2856 return cqr; 2857 } 2858 2859 ccw = cqr->cpaddr; 2860 ccw->cmd_code = CCW_CMD_RDC; 2861 if (idal_is_needed(rdc_buffer, rdc_buffer_size)) { 2862 idaw = (unsigned long *) (cqr->data); 2863 ccw->cda = (__u32)(addr_t) idaw; 2864 ccw->flags = CCW_FLAG_IDA; 2865 idaw = idal_create_words(idaw, rdc_buffer, rdc_buffer_size); 2866 } else { 2867 ccw->cda = (__u32)(addr_t) rdc_buffer; 2868 ccw->flags = 0; 2869 } 2870 2871 ccw->count = rdc_buffer_size; 2872 cqr->startdev = device; 2873 cqr->memdev = device; 2874 cqr->expires = 10*HZ; 2875 cqr->retries = 256; 2876 cqr->buildclk = get_clock(); 2877 cqr->status = DASD_CQR_FILLED; 2878 return cqr; 2879 } 2880 2881 2882 int dasd_generic_read_dev_chars(struct dasd_device *device, int magic, 2883 void *rdc_buffer, int rdc_buffer_size) 2884 { 2885 int ret; 2886 struct dasd_ccw_req *cqr; 2887 2888 cqr = dasd_generic_build_rdc(device, rdc_buffer, rdc_buffer_size, 2889 magic); 2890 if (IS_ERR(cqr)) 2891 return PTR_ERR(cqr); 2892 2893 ret = dasd_sleep_on(cqr); 2894 dasd_sfree_request(cqr, cqr->memdev); 2895 return ret; 2896 } 2897 EXPORT_SYMBOL_GPL(dasd_generic_read_dev_chars); 2898 2899 /* 2900 * In command mode and transport mode we need to look for sense 2901 * data in different places. The sense data itself is allways 2902 * an array of 32 bytes, so we can unify the sense data access 2903 * for both modes. 2904 */ 2905 char *dasd_get_sense(struct irb *irb) 2906 { 2907 struct tsb *tsb = NULL; 2908 char *sense = NULL; 2909 2910 if (scsw_is_tm(&irb->scsw) && (irb->scsw.tm.fcxs == 0x01)) { 2911 if (irb->scsw.tm.tcw) 2912 tsb = tcw_get_tsb((struct tcw *)(unsigned long) 2913 irb->scsw.tm.tcw); 2914 if (tsb && tsb->length == 64 && tsb->flags) 2915 switch (tsb->flags & 0x07) { 2916 case 1: /* tsa_iostat */ 2917 sense = tsb->tsa.iostat.sense; 2918 break; 2919 case 2: /* tsa_ddpc */ 2920 sense = tsb->tsa.ddpc.sense; 2921 break; 2922 default: 2923 /* currently we don't use interrogate data */ 2924 break; 2925 } 2926 } else if (irb->esw.esw0.erw.cons) { 2927 sense = irb->ecw; 2928 } 2929 return sense; 2930 } 2931 EXPORT_SYMBOL_GPL(dasd_get_sense); 2932 2933 static int __init dasd_init(void) 2934 { 2935 int rc; 2936 2937 init_waitqueue_head(&dasd_init_waitq); 2938 init_waitqueue_head(&dasd_flush_wq); 2939 init_waitqueue_head(&generic_waitq); 2940 2941 /* register 'common' DASD debug area, used for all DBF_XXX calls */ 2942 dasd_debug_area = debug_register("dasd", 1, 1, 8 * sizeof(long)); 2943 if (dasd_debug_area == NULL) { 2944 rc = -ENOMEM; 2945 goto failed; 2946 } 2947 debug_register_view(dasd_debug_area, &debug_sprintf_view); 2948 debug_set_level(dasd_debug_area, DBF_WARNING); 2949 2950 DBF_EVENT(DBF_EMERG, "%s", "debug area created"); 2951 2952 dasd_diag_discipline_pointer = NULL; 2953 2954 rc = dasd_devmap_init(); 2955 if (rc) 2956 goto failed; 2957 rc = dasd_gendisk_init(); 2958 if (rc) 2959 goto failed; 2960 rc = dasd_parse(); 2961 if (rc) 2962 goto failed; 2963 rc = dasd_eer_init(); 2964 if (rc) 2965 goto failed; 2966 #ifdef CONFIG_PROC_FS 2967 rc = dasd_proc_init(); 2968 if (rc) 2969 goto failed; 2970 #endif 2971 2972 return 0; 2973 failed: 2974 pr_info("The DASD device driver could not be initialized\n"); 2975 dasd_exit(); 2976 return rc; 2977 } 2978 2979 module_init(dasd_init); 2980 module_exit(dasd_exit); 2981 2982 EXPORT_SYMBOL(dasd_debug_area); 2983 EXPORT_SYMBOL(dasd_diag_discipline_pointer); 2984 2985 EXPORT_SYMBOL(dasd_add_request_head); 2986 EXPORT_SYMBOL(dasd_add_request_tail); 2987 EXPORT_SYMBOL(dasd_cancel_req); 2988 EXPORT_SYMBOL(dasd_device_clear_timer); 2989 EXPORT_SYMBOL(dasd_block_clear_timer); 2990 EXPORT_SYMBOL(dasd_enable_device); 2991 EXPORT_SYMBOL(dasd_int_handler); 2992 EXPORT_SYMBOL(dasd_kfree_request); 2993 EXPORT_SYMBOL(dasd_kick_device); 2994 EXPORT_SYMBOL(dasd_kmalloc_request); 2995 EXPORT_SYMBOL(dasd_schedule_device_bh); 2996 EXPORT_SYMBOL(dasd_schedule_block_bh); 2997 EXPORT_SYMBOL(dasd_set_target_state); 2998 EXPORT_SYMBOL(dasd_device_set_timer); 2999 EXPORT_SYMBOL(dasd_block_set_timer); 3000 EXPORT_SYMBOL(dasd_sfree_request); 3001 EXPORT_SYMBOL(dasd_sleep_on); 3002 EXPORT_SYMBOL(dasd_sleep_on_immediatly); 3003 EXPORT_SYMBOL(dasd_sleep_on_interruptible); 3004 EXPORT_SYMBOL(dasd_smalloc_request); 3005 EXPORT_SYMBOL(dasd_start_IO); 3006 EXPORT_SYMBOL(dasd_term_IO); 3007 3008 EXPORT_SYMBOL_GPL(dasd_generic_probe); 3009 EXPORT_SYMBOL_GPL(dasd_generic_remove); 3010 EXPORT_SYMBOL_GPL(dasd_generic_notify); 3011 EXPORT_SYMBOL_GPL(dasd_generic_set_online); 3012 EXPORT_SYMBOL_GPL(dasd_generic_set_offline); 3013 EXPORT_SYMBOL_GPL(dasd_generic_handle_state_change); 3014 EXPORT_SYMBOL_GPL(dasd_flush_device_queue); 3015 EXPORT_SYMBOL_GPL(dasd_alloc_block); 3016 EXPORT_SYMBOL_GPL(dasd_free_block); 3017