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