1 /* 2 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> 3 * Horst Hummel <Horst.Hummel@de.ibm.com> 4 * Carsten Otte <Cotte@de.ibm.com> 5 * Martin Schwidefsky <schwidefsky@de.ibm.com> 6 * Bugreports.to..: <Linux390@de.ibm.com> 7 * Copyright IBM Corp. 1999, 2009 8 */ 9 10 #define KMSG_COMPONENT "dasd" 11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 12 13 #include <linux/kmod.h> 14 #include <linux/init.h> 15 #include <linux/interrupt.h> 16 #include <linux/ctype.h> 17 #include <linux/major.h> 18 #include <linux/slab.h> 19 #include <linux/hdreg.h> 20 #include <linux/async.h> 21 #include <linux/mutex.h> 22 #include <linux/debugfs.h> 23 #include <linux/seq_file.h> 24 #include <linux/vmalloc.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_DIAG_MOD "dasd_diag_mod" 42 43 /* 44 * SECTION: exported variables of dasd.c 45 */ 46 debug_info_t *dasd_debug_area; 47 EXPORT_SYMBOL(dasd_debug_area); 48 static struct dentry *dasd_debugfs_root_entry; 49 struct dasd_discipline *dasd_diag_discipline_pointer; 50 EXPORT_SYMBOL(dasd_diag_discipline_pointer); 51 void dasd_int_handler(struct ccw_device *, unsigned long, struct irb *); 52 53 MODULE_AUTHOR("Holger Smolinski <Holger.Smolinski@de.ibm.com>"); 54 MODULE_DESCRIPTION("Linux on S/390 DASD device driver," 55 " Copyright IBM Corp. 2000"); 56 MODULE_SUPPORTED_DEVICE("dasd"); 57 MODULE_LICENSE("GPL"); 58 59 /* 60 * SECTION: prototypes for static functions of dasd.c 61 */ 62 static int dasd_alloc_queue(struct dasd_block *); 63 static void dasd_setup_queue(struct dasd_block *); 64 static void dasd_free_queue(struct dasd_block *); 65 static void dasd_flush_request_queue(struct dasd_block *); 66 static int dasd_flush_block_queue(struct dasd_block *); 67 static void dasd_device_tasklet(struct dasd_device *); 68 static void dasd_block_tasklet(struct dasd_block *); 69 static void do_kick_device(struct work_struct *); 70 static void do_restore_device(struct work_struct *); 71 static void do_reload_device(struct work_struct *); 72 static void dasd_return_cqr_cb(struct dasd_ccw_req *, void *); 73 static void dasd_device_timeout(unsigned long); 74 static void dasd_block_timeout(unsigned long); 75 static void __dasd_process_erp(struct dasd_device *, struct dasd_ccw_req *); 76 static void dasd_profile_init(struct dasd_profile *, struct dentry *); 77 static void dasd_profile_exit(struct dasd_profile *); 78 static void dasd_hosts_init(struct dentry *, struct dasd_device *); 79 static void dasd_hosts_exit(struct dasd_device *); 80 81 /* 82 * SECTION: Operations on the device structure. 83 */ 84 static wait_queue_head_t dasd_init_waitq; 85 static wait_queue_head_t dasd_flush_wq; 86 static wait_queue_head_t generic_waitq; 87 static wait_queue_head_t shutdown_waitq; 88 89 /* 90 * Allocate memory for a new device structure. 91 */ 92 struct dasd_device *dasd_alloc_device(void) 93 { 94 struct dasd_device *device; 95 96 device = kzalloc(sizeof(struct dasd_device), GFP_ATOMIC); 97 if (!device) 98 return ERR_PTR(-ENOMEM); 99 100 /* Get two pages for normal block device operations. */ 101 device->ccw_mem = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA, 1); 102 if (!device->ccw_mem) { 103 kfree(device); 104 return ERR_PTR(-ENOMEM); 105 } 106 /* Get one page for error recovery. */ 107 device->erp_mem = (void *) get_zeroed_page(GFP_ATOMIC | GFP_DMA); 108 if (!device->erp_mem) { 109 free_pages((unsigned long) device->ccw_mem, 1); 110 kfree(device); 111 return ERR_PTR(-ENOMEM); 112 } 113 114 dasd_init_chunklist(&device->ccw_chunks, device->ccw_mem, PAGE_SIZE*2); 115 dasd_init_chunklist(&device->erp_chunks, device->erp_mem, PAGE_SIZE); 116 spin_lock_init(&device->mem_lock); 117 atomic_set(&device->tasklet_scheduled, 0); 118 tasklet_init(&device->tasklet, 119 (void (*)(unsigned long)) dasd_device_tasklet, 120 (unsigned long) device); 121 INIT_LIST_HEAD(&device->ccw_queue); 122 init_timer(&device->timer); 123 device->timer.function = dasd_device_timeout; 124 device->timer.data = (unsigned long) device; 125 INIT_WORK(&device->kick_work, do_kick_device); 126 INIT_WORK(&device->restore_device, do_restore_device); 127 INIT_WORK(&device->reload_device, do_reload_device); 128 device->state = DASD_STATE_NEW; 129 device->target = DASD_STATE_NEW; 130 mutex_init(&device->state_mutex); 131 spin_lock_init(&device->profile.lock); 132 return device; 133 } 134 135 /* 136 * Free memory of a device structure. 137 */ 138 void dasd_free_device(struct dasd_device *device) 139 { 140 kfree(device->private); 141 free_page((unsigned long) device->erp_mem); 142 free_pages((unsigned long) device->ccw_mem, 1); 143 kfree(device); 144 } 145 146 /* 147 * Allocate memory for a new device structure. 148 */ 149 struct dasd_block *dasd_alloc_block(void) 150 { 151 struct dasd_block *block; 152 153 block = kzalloc(sizeof(*block), GFP_ATOMIC); 154 if (!block) 155 return ERR_PTR(-ENOMEM); 156 /* open_count = 0 means device online but not in use */ 157 atomic_set(&block->open_count, -1); 158 159 spin_lock_init(&block->request_queue_lock); 160 atomic_set(&block->tasklet_scheduled, 0); 161 tasklet_init(&block->tasklet, 162 (void (*)(unsigned long)) dasd_block_tasklet, 163 (unsigned long) block); 164 INIT_LIST_HEAD(&block->ccw_queue); 165 spin_lock_init(&block->queue_lock); 166 init_timer(&block->timer); 167 block->timer.function = dasd_block_timeout; 168 block->timer.data = (unsigned long) block; 169 spin_lock_init(&block->profile.lock); 170 171 return block; 172 } 173 EXPORT_SYMBOL_GPL(dasd_alloc_block); 174 175 /* 176 * Free memory of a device structure. 177 */ 178 void dasd_free_block(struct dasd_block *block) 179 { 180 kfree(block); 181 } 182 EXPORT_SYMBOL_GPL(dasd_free_block); 183 184 /* 185 * Make a new device known to the system. 186 */ 187 static int dasd_state_new_to_known(struct dasd_device *device) 188 { 189 int rc; 190 191 /* 192 * As long as the device is not in state DASD_STATE_NEW we want to 193 * keep the reference count > 0. 194 */ 195 dasd_get_device(device); 196 197 if (device->block) { 198 rc = dasd_alloc_queue(device->block); 199 if (rc) { 200 dasd_put_device(device); 201 return rc; 202 } 203 } 204 device->state = DASD_STATE_KNOWN; 205 return 0; 206 } 207 208 /* 209 * Let the system forget about a device. 210 */ 211 static int dasd_state_known_to_new(struct dasd_device *device) 212 { 213 /* Disable extended error reporting for this device. */ 214 dasd_eer_disable(device); 215 /* Forget the discipline information. */ 216 if (device->discipline) { 217 if (device->discipline->uncheck_device) 218 device->discipline->uncheck_device(device); 219 module_put(device->discipline->owner); 220 } 221 device->discipline = NULL; 222 if (device->base_discipline) 223 module_put(device->base_discipline->owner); 224 device->base_discipline = NULL; 225 device->state = DASD_STATE_NEW; 226 227 if (device->block) 228 dasd_free_queue(device->block); 229 230 /* Give up reference we took in dasd_state_new_to_known. */ 231 dasd_put_device(device); 232 return 0; 233 } 234 235 static struct dentry *dasd_debugfs_setup(const char *name, 236 struct dentry *base_dentry) 237 { 238 struct dentry *pde; 239 240 if (!base_dentry) 241 return NULL; 242 pde = debugfs_create_dir(name, base_dentry); 243 if (!pde || IS_ERR(pde)) 244 return NULL; 245 return pde; 246 } 247 248 /* 249 * Request the irq line for the device. 250 */ 251 static int dasd_state_known_to_basic(struct dasd_device *device) 252 { 253 struct dasd_block *block = device->block; 254 int rc = 0; 255 256 /* Allocate and register gendisk structure. */ 257 if (block) { 258 rc = dasd_gendisk_alloc(block); 259 if (rc) 260 return rc; 261 block->debugfs_dentry = 262 dasd_debugfs_setup(block->gdp->disk_name, 263 dasd_debugfs_root_entry); 264 dasd_profile_init(&block->profile, block->debugfs_dentry); 265 if (dasd_global_profile_level == DASD_PROFILE_ON) 266 dasd_profile_on(&device->block->profile); 267 } 268 device->debugfs_dentry = 269 dasd_debugfs_setup(dev_name(&device->cdev->dev), 270 dasd_debugfs_root_entry); 271 dasd_profile_init(&device->profile, device->debugfs_dentry); 272 dasd_hosts_init(device->debugfs_dentry, device); 273 274 /* register 'device' debug area, used for all DBF_DEV_XXX calls */ 275 device->debug_area = debug_register(dev_name(&device->cdev->dev), 4, 1, 276 8 * sizeof(long)); 277 debug_register_view(device->debug_area, &debug_sprintf_view); 278 debug_set_level(device->debug_area, DBF_WARNING); 279 DBF_DEV_EVENT(DBF_EMERG, device, "%s", "debug area created"); 280 281 device->state = DASD_STATE_BASIC; 282 283 return rc; 284 } 285 286 /* 287 * Release the irq line for the device. Terminate any running i/o. 288 */ 289 static int dasd_state_basic_to_known(struct dasd_device *device) 290 { 291 int rc; 292 293 if (device->discipline->basic_to_known) { 294 rc = device->discipline->basic_to_known(device); 295 if (rc) 296 return rc; 297 } 298 299 if (device->block) { 300 dasd_profile_exit(&device->block->profile); 301 debugfs_remove(device->block->debugfs_dentry); 302 dasd_gendisk_free(device->block); 303 dasd_block_clear_timer(device->block); 304 } 305 rc = dasd_flush_device_queue(device); 306 if (rc) 307 return rc; 308 dasd_device_clear_timer(device); 309 dasd_profile_exit(&device->profile); 310 dasd_hosts_exit(device); 311 debugfs_remove(device->debugfs_dentry); 312 DBF_DEV_EVENT(DBF_EMERG, device, "%p debug area deleted", device); 313 if (device->debug_area != NULL) { 314 debug_unregister(device->debug_area); 315 device->debug_area = NULL; 316 } 317 device->state = DASD_STATE_KNOWN; 318 return 0; 319 } 320 321 /* 322 * Do the initial analysis. The do_analysis function may return 323 * -EAGAIN in which case the device keeps the state DASD_STATE_BASIC 324 * until the discipline decides to continue the startup sequence 325 * by calling the function dasd_change_state. The eckd disciplines 326 * uses this to start a ccw that detects the format. The completion 327 * interrupt for this detection ccw uses the kernel event daemon to 328 * trigger the call to dasd_change_state. All this is done in the 329 * discipline code, see dasd_eckd.c. 330 * After the analysis ccw is done (do_analysis returned 0) the block 331 * device is setup. 332 * In case the analysis returns an error, the device setup is stopped 333 * (a fake disk was already added to allow formatting). 334 */ 335 static int dasd_state_basic_to_ready(struct dasd_device *device) 336 { 337 int rc; 338 struct dasd_block *block; 339 340 rc = 0; 341 block = device->block; 342 /* make disk known with correct capacity */ 343 if (block) { 344 if (block->base->discipline->do_analysis != NULL) 345 rc = block->base->discipline->do_analysis(block); 346 if (rc) { 347 if (rc != -EAGAIN) { 348 device->state = DASD_STATE_UNFMT; 349 goto out; 350 } 351 return rc; 352 } 353 dasd_setup_queue(block); 354 set_capacity(block->gdp, 355 block->blocks << block->s2b_shift); 356 device->state = DASD_STATE_READY; 357 rc = dasd_scan_partitions(block); 358 if (rc) { 359 device->state = DASD_STATE_BASIC; 360 return rc; 361 } 362 } else { 363 device->state = DASD_STATE_READY; 364 } 365 out: 366 if (device->discipline->basic_to_ready) 367 rc = device->discipline->basic_to_ready(device); 368 return rc; 369 } 370 371 static inline 372 int _wait_for_empty_queues(struct dasd_device *device) 373 { 374 if (device->block) 375 return list_empty(&device->ccw_queue) && 376 list_empty(&device->block->ccw_queue); 377 else 378 return list_empty(&device->ccw_queue); 379 } 380 381 /* 382 * Remove device from block device layer. Destroy dirty buffers. 383 * Forget format information. Check if the target level is basic 384 * and if it is create fake disk for formatting. 385 */ 386 static int dasd_state_ready_to_basic(struct dasd_device *device) 387 { 388 int rc; 389 390 device->state = DASD_STATE_BASIC; 391 if (device->block) { 392 struct dasd_block *block = device->block; 393 rc = dasd_flush_block_queue(block); 394 if (rc) { 395 device->state = DASD_STATE_READY; 396 return rc; 397 } 398 dasd_flush_request_queue(block); 399 dasd_destroy_partitions(block); 400 block->blocks = 0; 401 block->bp_block = 0; 402 block->s2b_shift = 0; 403 } 404 return 0; 405 } 406 407 /* 408 * Back to basic. 409 */ 410 static int dasd_state_unfmt_to_basic(struct dasd_device *device) 411 { 412 device->state = DASD_STATE_BASIC; 413 return 0; 414 } 415 416 /* 417 * Make the device online and schedule the bottom half to start 418 * the requeueing of requests from the linux request queue to the 419 * ccw queue. 420 */ 421 static int 422 dasd_state_ready_to_online(struct dasd_device * device) 423 { 424 struct gendisk *disk; 425 struct disk_part_iter piter; 426 struct hd_struct *part; 427 428 device->state = DASD_STATE_ONLINE; 429 if (device->block) { 430 dasd_schedule_block_bh(device->block); 431 if ((device->features & DASD_FEATURE_USERAW)) { 432 disk = device->block->gdp; 433 kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE); 434 return 0; 435 } 436 disk = device->block->bdev->bd_disk; 437 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0); 438 while ((part = disk_part_iter_next(&piter))) 439 kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE); 440 disk_part_iter_exit(&piter); 441 } 442 return 0; 443 } 444 445 /* 446 * Stop the requeueing of requests again. 447 */ 448 static int dasd_state_online_to_ready(struct dasd_device *device) 449 { 450 int rc; 451 struct gendisk *disk; 452 struct disk_part_iter piter; 453 struct hd_struct *part; 454 455 if (device->discipline->online_to_ready) { 456 rc = device->discipline->online_to_ready(device); 457 if (rc) 458 return rc; 459 } 460 461 device->state = DASD_STATE_READY; 462 if (device->block && !(device->features & DASD_FEATURE_USERAW)) { 463 disk = device->block->bdev->bd_disk; 464 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0); 465 while ((part = disk_part_iter_next(&piter))) 466 kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE); 467 disk_part_iter_exit(&piter); 468 } 469 return 0; 470 } 471 472 /* 473 * Device startup state changes. 474 */ 475 static int dasd_increase_state(struct dasd_device *device) 476 { 477 int rc; 478 479 rc = 0; 480 if (device->state == DASD_STATE_NEW && 481 device->target >= DASD_STATE_KNOWN) 482 rc = dasd_state_new_to_known(device); 483 484 if (!rc && 485 device->state == DASD_STATE_KNOWN && 486 device->target >= DASD_STATE_BASIC) 487 rc = dasd_state_known_to_basic(device); 488 489 if (!rc && 490 device->state == DASD_STATE_BASIC && 491 device->target >= DASD_STATE_READY) 492 rc = dasd_state_basic_to_ready(device); 493 494 if (!rc && 495 device->state == DASD_STATE_UNFMT && 496 device->target > DASD_STATE_UNFMT) 497 rc = -EPERM; 498 499 if (!rc && 500 device->state == DASD_STATE_READY && 501 device->target >= DASD_STATE_ONLINE) 502 rc = dasd_state_ready_to_online(device); 503 504 return rc; 505 } 506 507 /* 508 * Device shutdown state changes. 509 */ 510 static int dasd_decrease_state(struct dasd_device *device) 511 { 512 int rc; 513 514 rc = 0; 515 if (device->state == DASD_STATE_ONLINE && 516 device->target <= DASD_STATE_READY) 517 rc = dasd_state_online_to_ready(device); 518 519 if (!rc && 520 device->state == DASD_STATE_READY && 521 device->target <= DASD_STATE_BASIC) 522 rc = dasd_state_ready_to_basic(device); 523 524 if (!rc && 525 device->state == DASD_STATE_UNFMT && 526 device->target <= DASD_STATE_BASIC) 527 rc = dasd_state_unfmt_to_basic(device); 528 529 if (!rc && 530 device->state == DASD_STATE_BASIC && 531 device->target <= DASD_STATE_KNOWN) 532 rc = dasd_state_basic_to_known(device); 533 534 if (!rc && 535 device->state == DASD_STATE_KNOWN && 536 device->target <= DASD_STATE_NEW) 537 rc = dasd_state_known_to_new(device); 538 539 return rc; 540 } 541 542 /* 543 * This is the main startup/shutdown routine. 544 */ 545 static void dasd_change_state(struct dasd_device *device) 546 { 547 int rc; 548 549 if (device->state == device->target) 550 /* Already where we want to go today... */ 551 return; 552 if (device->state < device->target) 553 rc = dasd_increase_state(device); 554 else 555 rc = dasd_decrease_state(device); 556 if (rc == -EAGAIN) 557 return; 558 if (rc) 559 device->target = device->state; 560 561 /* let user-space know that the device status changed */ 562 kobject_uevent(&device->cdev->dev.kobj, KOBJ_CHANGE); 563 564 if (device->state == device->target) 565 wake_up(&dasd_init_waitq); 566 } 567 568 /* 569 * Kick starter for devices that did not complete the startup/shutdown 570 * procedure or were sleeping because of a pending state. 571 * dasd_kick_device will schedule a call do do_kick_device to the kernel 572 * event daemon. 573 */ 574 static void do_kick_device(struct work_struct *work) 575 { 576 struct dasd_device *device = container_of(work, struct dasd_device, kick_work); 577 mutex_lock(&device->state_mutex); 578 dasd_change_state(device); 579 mutex_unlock(&device->state_mutex); 580 dasd_schedule_device_bh(device); 581 dasd_put_device(device); 582 } 583 584 void dasd_kick_device(struct dasd_device *device) 585 { 586 dasd_get_device(device); 587 /* queue call to dasd_kick_device to the kernel event daemon. */ 588 if (!schedule_work(&device->kick_work)) 589 dasd_put_device(device); 590 } 591 EXPORT_SYMBOL(dasd_kick_device); 592 593 /* 594 * dasd_reload_device will schedule a call do do_reload_device to the kernel 595 * event daemon. 596 */ 597 static void do_reload_device(struct work_struct *work) 598 { 599 struct dasd_device *device = container_of(work, struct dasd_device, 600 reload_device); 601 device->discipline->reload(device); 602 dasd_put_device(device); 603 } 604 605 void dasd_reload_device(struct dasd_device *device) 606 { 607 dasd_get_device(device); 608 /* queue call to dasd_reload_device to the kernel event daemon. */ 609 if (!schedule_work(&device->reload_device)) 610 dasd_put_device(device); 611 } 612 EXPORT_SYMBOL(dasd_reload_device); 613 614 /* 615 * dasd_restore_device will schedule a call do do_restore_device to the kernel 616 * event daemon. 617 */ 618 static void do_restore_device(struct work_struct *work) 619 { 620 struct dasd_device *device = container_of(work, struct dasd_device, 621 restore_device); 622 device->cdev->drv->restore(device->cdev); 623 dasd_put_device(device); 624 } 625 626 void dasd_restore_device(struct dasd_device *device) 627 { 628 dasd_get_device(device); 629 /* queue call to dasd_restore_device to the kernel event daemon. */ 630 if (!schedule_work(&device->restore_device)) 631 dasd_put_device(device); 632 } 633 634 /* 635 * Set the target state for a device and starts the state change. 636 */ 637 void dasd_set_target_state(struct dasd_device *device, int target) 638 { 639 dasd_get_device(device); 640 mutex_lock(&device->state_mutex); 641 /* If we are in probeonly mode stop at DASD_STATE_READY. */ 642 if (dasd_probeonly && target > DASD_STATE_READY) 643 target = DASD_STATE_READY; 644 if (device->target != target) { 645 if (device->state == target) 646 wake_up(&dasd_init_waitq); 647 device->target = target; 648 } 649 if (device->state != device->target) 650 dasd_change_state(device); 651 mutex_unlock(&device->state_mutex); 652 dasd_put_device(device); 653 } 654 EXPORT_SYMBOL(dasd_set_target_state); 655 656 /* 657 * Enable devices with device numbers in [from..to]. 658 */ 659 static inline int _wait_for_device(struct dasd_device *device) 660 { 661 return (device->state == device->target); 662 } 663 664 void dasd_enable_device(struct dasd_device *device) 665 { 666 dasd_set_target_state(device, DASD_STATE_ONLINE); 667 if (device->state <= DASD_STATE_KNOWN) 668 /* No discipline for device found. */ 669 dasd_set_target_state(device, DASD_STATE_NEW); 670 /* Now wait for the devices to come up. */ 671 wait_event(dasd_init_waitq, _wait_for_device(device)); 672 673 dasd_reload_device(device); 674 if (device->discipline->kick_validate) 675 device->discipline->kick_validate(device); 676 } 677 EXPORT_SYMBOL(dasd_enable_device); 678 679 /* 680 * SECTION: device operation (interrupt handler, start i/o, term i/o ...) 681 */ 682 683 unsigned int dasd_global_profile_level = DASD_PROFILE_OFF; 684 685 #ifdef CONFIG_DASD_PROFILE 686 struct dasd_profile dasd_global_profile = { 687 .lock = __SPIN_LOCK_UNLOCKED(dasd_global_profile.lock), 688 }; 689 static struct dentry *dasd_debugfs_global_entry; 690 691 /* 692 * Add profiling information for cqr before execution. 693 */ 694 static void dasd_profile_start(struct dasd_block *block, 695 struct dasd_ccw_req *cqr, 696 struct request *req) 697 { 698 struct list_head *l; 699 unsigned int counter; 700 struct dasd_device *device; 701 702 /* count the length of the chanq for statistics */ 703 counter = 0; 704 if (dasd_global_profile_level || block->profile.data) 705 list_for_each(l, &block->ccw_queue) 706 if (++counter >= 31) 707 break; 708 709 spin_lock(&dasd_global_profile.lock); 710 if (dasd_global_profile.data) { 711 dasd_global_profile.data->dasd_io_nr_req[counter]++; 712 if (rq_data_dir(req) == READ) 713 dasd_global_profile.data->dasd_read_nr_req[counter]++; 714 } 715 spin_unlock(&dasd_global_profile.lock); 716 717 spin_lock(&block->profile.lock); 718 if (block->profile.data) { 719 block->profile.data->dasd_io_nr_req[counter]++; 720 if (rq_data_dir(req) == READ) 721 block->profile.data->dasd_read_nr_req[counter]++; 722 } 723 spin_unlock(&block->profile.lock); 724 725 /* 726 * We count the request for the start device, even though it may run on 727 * some other device due to error recovery. This way we make sure that 728 * we count each request only once. 729 */ 730 device = cqr->startdev; 731 if (device->profile.data) { 732 counter = 1; /* request is not yet queued on the start device */ 733 list_for_each(l, &device->ccw_queue) 734 if (++counter >= 31) 735 break; 736 } 737 spin_lock(&device->profile.lock); 738 if (device->profile.data) { 739 device->profile.data->dasd_io_nr_req[counter]++; 740 if (rq_data_dir(req) == READ) 741 device->profile.data->dasd_read_nr_req[counter]++; 742 } 743 spin_unlock(&device->profile.lock); 744 } 745 746 /* 747 * Add profiling information for cqr after execution. 748 */ 749 750 #define dasd_profile_counter(value, index) \ 751 { \ 752 for (index = 0; index < 31 && value >> (2+index); index++) \ 753 ; \ 754 } 755 756 static void dasd_profile_end_add_data(struct dasd_profile_info *data, 757 int is_alias, 758 int is_tpm, 759 int is_read, 760 long sectors, 761 int sectors_ind, 762 int tottime_ind, 763 int tottimeps_ind, 764 int strtime_ind, 765 int irqtime_ind, 766 int irqtimeps_ind, 767 int endtime_ind) 768 { 769 /* in case of an overflow, reset the whole profile */ 770 if (data->dasd_io_reqs == UINT_MAX) { 771 memset(data, 0, sizeof(*data)); 772 getnstimeofday(&data->starttod); 773 } 774 data->dasd_io_reqs++; 775 data->dasd_io_sects += sectors; 776 if (is_alias) 777 data->dasd_io_alias++; 778 if (is_tpm) 779 data->dasd_io_tpm++; 780 781 data->dasd_io_secs[sectors_ind]++; 782 data->dasd_io_times[tottime_ind]++; 783 data->dasd_io_timps[tottimeps_ind]++; 784 data->dasd_io_time1[strtime_ind]++; 785 data->dasd_io_time2[irqtime_ind]++; 786 data->dasd_io_time2ps[irqtimeps_ind]++; 787 data->dasd_io_time3[endtime_ind]++; 788 789 if (is_read) { 790 data->dasd_read_reqs++; 791 data->dasd_read_sects += sectors; 792 if (is_alias) 793 data->dasd_read_alias++; 794 if (is_tpm) 795 data->dasd_read_tpm++; 796 data->dasd_read_secs[sectors_ind]++; 797 data->dasd_read_times[tottime_ind]++; 798 data->dasd_read_time1[strtime_ind]++; 799 data->dasd_read_time2[irqtime_ind]++; 800 data->dasd_read_time3[endtime_ind]++; 801 } 802 } 803 804 static void dasd_profile_end(struct dasd_block *block, 805 struct dasd_ccw_req *cqr, 806 struct request *req) 807 { 808 long strtime, irqtime, endtime, tottime; /* in microseconds */ 809 long tottimeps, sectors; 810 struct dasd_device *device; 811 int sectors_ind, tottime_ind, tottimeps_ind, strtime_ind; 812 int irqtime_ind, irqtimeps_ind, endtime_ind; 813 814 device = cqr->startdev; 815 if (!(dasd_global_profile_level || 816 block->profile.data || 817 device->profile.data)) 818 return; 819 820 sectors = blk_rq_sectors(req); 821 if (!cqr->buildclk || !cqr->startclk || 822 !cqr->stopclk || !cqr->endclk || 823 !sectors) 824 return; 825 826 strtime = ((cqr->startclk - cqr->buildclk) >> 12); 827 irqtime = ((cqr->stopclk - cqr->startclk) >> 12); 828 endtime = ((cqr->endclk - cqr->stopclk) >> 12); 829 tottime = ((cqr->endclk - cqr->buildclk) >> 12); 830 tottimeps = tottime / sectors; 831 832 dasd_profile_counter(sectors, sectors_ind); 833 dasd_profile_counter(tottime, tottime_ind); 834 dasd_profile_counter(tottimeps, tottimeps_ind); 835 dasd_profile_counter(strtime, strtime_ind); 836 dasd_profile_counter(irqtime, irqtime_ind); 837 dasd_profile_counter(irqtime / sectors, irqtimeps_ind); 838 dasd_profile_counter(endtime, endtime_ind); 839 840 spin_lock(&dasd_global_profile.lock); 841 if (dasd_global_profile.data) { 842 dasd_profile_end_add_data(dasd_global_profile.data, 843 cqr->startdev != block->base, 844 cqr->cpmode == 1, 845 rq_data_dir(req) == READ, 846 sectors, sectors_ind, tottime_ind, 847 tottimeps_ind, strtime_ind, 848 irqtime_ind, irqtimeps_ind, 849 endtime_ind); 850 } 851 spin_unlock(&dasd_global_profile.lock); 852 853 spin_lock(&block->profile.lock); 854 if (block->profile.data) 855 dasd_profile_end_add_data(block->profile.data, 856 cqr->startdev != block->base, 857 cqr->cpmode == 1, 858 rq_data_dir(req) == READ, 859 sectors, sectors_ind, tottime_ind, 860 tottimeps_ind, strtime_ind, 861 irqtime_ind, irqtimeps_ind, 862 endtime_ind); 863 spin_unlock(&block->profile.lock); 864 865 spin_lock(&device->profile.lock); 866 if (device->profile.data) 867 dasd_profile_end_add_data(device->profile.data, 868 cqr->startdev != block->base, 869 cqr->cpmode == 1, 870 rq_data_dir(req) == READ, 871 sectors, sectors_ind, tottime_ind, 872 tottimeps_ind, strtime_ind, 873 irqtime_ind, irqtimeps_ind, 874 endtime_ind); 875 spin_unlock(&device->profile.lock); 876 } 877 878 void dasd_profile_reset(struct dasd_profile *profile) 879 { 880 struct dasd_profile_info *data; 881 882 spin_lock_bh(&profile->lock); 883 data = profile->data; 884 if (!data) { 885 spin_unlock_bh(&profile->lock); 886 return; 887 } 888 memset(data, 0, sizeof(*data)); 889 getnstimeofday(&data->starttod); 890 spin_unlock_bh(&profile->lock); 891 } 892 893 int dasd_profile_on(struct dasd_profile *profile) 894 { 895 struct dasd_profile_info *data; 896 897 data = kzalloc(sizeof(*data), GFP_KERNEL); 898 if (!data) 899 return -ENOMEM; 900 spin_lock_bh(&profile->lock); 901 if (profile->data) { 902 spin_unlock_bh(&profile->lock); 903 kfree(data); 904 return 0; 905 } 906 getnstimeofday(&data->starttod); 907 profile->data = data; 908 spin_unlock_bh(&profile->lock); 909 return 0; 910 } 911 912 void dasd_profile_off(struct dasd_profile *profile) 913 { 914 spin_lock_bh(&profile->lock); 915 kfree(profile->data); 916 profile->data = NULL; 917 spin_unlock_bh(&profile->lock); 918 } 919 920 char *dasd_get_user_string(const char __user *user_buf, size_t user_len) 921 { 922 char *buffer; 923 924 buffer = vmalloc(user_len + 1); 925 if (buffer == NULL) 926 return ERR_PTR(-ENOMEM); 927 if (copy_from_user(buffer, user_buf, user_len) != 0) { 928 vfree(buffer); 929 return ERR_PTR(-EFAULT); 930 } 931 /* got the string, now strip linefeed. */ 932 if (buffer[user_len - 1] == '\n') 933 buffer[user_len - 1] = 0; 934 else 935 buffer[user_len] = 0; 936 return buffer; 937 } 938 939 static ssize_t dasd_stats_write(struct file *file, 940 const char __user *user_buf, 941 size_t user_len, loff_t *pos) 942 { 943 char *buffer, *str; 944 int rc; 945 struct seq_file *m = (struct seq_file *)file->private_data; 946 struct dasd_profile *prof = m->private; 947 948 if (user_len > 65536) 949 user_len = 65536; 950 buffer = dasd_get_user_string(user_buf, user_len); 951 if (IS_ERR(buffer)) 952 return PTR_ERR(buffer); 953 954 str = skip_spaces(buffer); 955 rc = user_len; 956 if (strncmp(str, "reset", 5) == 0) { 957 dasd_profile_reset(prof); 958 } else if (strncmp(str, "on", 2) == 0) { 959 rc = dasd_profile_on(prof); 960 if (rc) 961 goto out; 962 rc = user_len; 963 if (prof == &dasd_global_profile) { 964 dasd_profile_reset(prof); 965 dasd_global_profile_level = DASD_PROFILE_GLOBAL_ONLY; 966 } 967 } else if (strncmp(str, "off", 3) == 0) { 968 if (prof == &dasd_global_profile) 969 dasd_global_profile_level = DASD_PROFILE_OFF; 970 dasd_profile_off(prof); 971 } else 972 rc = -EINVAL; 973 out: 974 vfree(buffer); 975 return rc; 976 } 977 978 static void dasd_stats_array(struct seq_file *m, unsigned int *array) 979 { 980 int i; 981 982 for (i = 0; i < 32; i++) 983 seq_printf(m, "%u ", array[i]); 984 seq_putc(m, '\n'); 985 } 986 987 static void dasd_stats_seq_print(struct seq_file *m, 988 struct dasd_profile_info *data) 989 { 990 seq_printf(m, "start_time %ld.%09ld\n", 991 data->starttod.tv_sec, data->starttod.tv_nsec); 992 seq_printf(m, "total_requests %u\n", data->dasd_io_reqs); 993 seq_printf(m, "total_sectors %u\n", data->dasd_io_sects); 994 seq_printf(m, "total_pav %u\n", data->dasd_io_alias); 995 seq_printf(m, "total_hpf %u\n", data->dasd_io_tpm); 996 seq_puts(m, "histogram_sectors "); 997 dasd_stats_array(m, data->dasd_io_secs); 998 seq_puts(m, "histogram_io_times "); 999 dasd_stats_array(m, data->dasd_io_times); 1000 seq_puts(m, "histogram_io_times_weighted "); 1001 dasd_stats_array(m, data->dasd_io_timps); 1002 seq_puts(m, "histogram_time_build_to_ssch "); 1003 dasd_stats_array(m, data->dasd_io_time1); 1004 seq_puts(m, "histogram_time_ssch_to_irq "); 1005 dasd_stats_array(m, data->dasd_io_time2); 1006 seq_puts(m, "histogram_time_ssch_to_irq_weighted "); 1007 dasd_stats_array(m, data->dasd_io_time2ps); 1008 seq_puts(m, "histogram_time_irq_to_end "); 1009 dasd_stats_array(m, data->dasd_io_time3); 1010 seq_puts(m, "histogram_ccw_queue_length "); 1011 dasd_stats_array(m, data->dasd_io_nr_req); 1012 seq_printf(m, "total_read_requests %u\n", data->dasd_read_reqs); 1013 seq_printf(m, "total_read_sectors %u\n", data->dasd_read_sects); 1014 seq_printf(m, "total_read_pav %u\n", data->dasd_read_alias); 1015 seq_printf(m, "total_read_hpf %u\n", data->dasd_read_tpm); 1016 seq_puts(m, "histogram_read_sectors "); 1017 dasd_stats_array(m, data->dasd_read_secs); 1018 seq_puts(m, "histogram_read_times "); 1019 dasd_stats_array(m, data->dasd_read_times); 1020 seq_puts(m, "histogram_read_time_build_to_ssch "); 1021 dasd_stats_array(m, data->dasd_read_time1); 1022 seq_puts(m, "histogram_read_time_ssch_to_irq "); 1023 dasd_stats_array(m, data->dasd_read_time2); 1024 seq_puts(m, "histogram_read_time_irq_to_end "); 1025 dasd_stats_array(m, data->dasd_read_time3); 1026 seq_puts(m, "histogram_read_ccw_queue_length "); 1027 dasd_stats_array(m, data->dasd_read_nr_req); 1028 } 1029 1030 static int dasd_stats_show(struct seq_file *m, void *v) 1031 { 1032 struct dasd_profile *profile; 1033 struct dasd_profile_info *data; 1034 1035 profile = m->private; 1036 spin_lock_bh(&profile->lock); 1037 data = profile->data; 1038 if (!data) { 1039 spin_unlock_bh(&profile->lock); 1040 seq_puts(m, "disabled\n"); 1041 return 0; 1042 } 1043 dasd_stats_seq_print(m, data); 1044 spin_unlock_bh(&profile->lock); 1045 return 0; 1046 } 1047 1048 static int dasd_stats_open(struct inode *inode, struct file *file) 1049 { 1050 struct dasd_profile *profile = inode->i_private; 1051 return single_open(file, dasd_stats_show, profile); 1052 } 1053 1054 static const struct file_operations dasd_stats_raw_fops = { 1055 .owner = THIS_MODULE, 1056 .open = dasd_stats_open, 1057 .read = seq_read, 1058 .llseek = seq_lseek, 1059 .release = single_release, 1060 .write = dasd_stats_write, 1061 }; 1062 1063 static void dasd_profile_init(struct dasd_profile *profile, 1064 struct dentry *base_dentry) 1065 { 1066 umode_t mode; 1067 struct dentry *pde; 1068 1069 if (!base_dentry) 1070 return; 1071 profile->dentry = NULL; 1072 profile->data = NULL; 1073 mode = (S_IRUSR | S_IWUSR | S_IFREG); 1074 pde = debugfs_create_file("statistics", mode, base_dentry, 1075 profile, &dasd_stats_raw_fops); 1076 if (pde && !IS_ERR(pde)) 1077 profile->dentry = pde; 1078 return; 1079 } 1080 1081 static void dasd_profile_exit(struct dasd_profile *profile) 1082 { 1083 dasd_profile_off(profile); 1084 debugfs_remove(profile->dentry); 1085 profile->dentry = NULL; 1086 } 1087 1088 static void dasd_statistics_removeroot(void) 1089 { 1090 dasd_global_profile_level = DASD_PROFILE_OFF; 1091 dasd_profile_exit(&dasd_global_profile); 1092 debugfs_remove(dasd_debugfs_global_entry); 1093 debugfs_remove(dasd_debugfs_root_entry); 1094 } 1095 1096 static void dasd_statistics_createroot(void) 1097 { 1098 struct dentry *pde; 1099 1100 dasd_debugfs_root_entry = NULL; 1101 pde = debugfs_create_dir("dasd", NULL); 1102 if (!pde || IS_ERR(pde)) 1103 goto error; 1104 dasd_debugfs_root_entry = pde; 1105 pde = debugfs_create_dir("global", dasd_debugfs_root_entry); 1106 if (!pde || IS_ERR(pde)) 1107 goto error; 1108 dasd_debugfs_global_entry = pde; 1109 dasd_profile_init(&dasd_global_profile, dasd_debugfs_global_entry); 1110 return; 1111 1112 error: 1113 DBF_EVENT(DBF_ERR, "%s", 1114 "Creation of the dasd debugfs interface failed"); 1115 dasd_statistics_removeroot(); 1116 return; 1117 } 1118 1119 #else 1120 #define dasd_profile_start(block, cqr, req) do {} while (0) 1121 #define dasd_profile_end(block, cqr, req) do {} while (0) 1122 1123 static void dasd_statistics_createroot(void) 1124 { 1125 return; 1126 } 1127 1128 static void dasd_statistics_removeroot(void) 1129 { 1130 return; 1131 } 1132 1133 int dasd_stats_generic_show(struct seq_file *m, void *v) 1134 { 1135 seq_puts(m, "Statistics are not activated in this kernel\n"); 1136 return 0; 1137 } 1138 1139 static void dasd_profile_init(struct dasd_profile *profile, 1140 struct dentry *base_dentry) 1141 { 1142 return; 1143 } 1144 1145 static void dasd_profile_exit(struct dasd_profile *profile) 1146 { 1147 return; 1148 } 1149 1150 int dasd_profile_on(struct dasd_profile *profile) 1151 { 1152 return 0; 1153 } 1154 1155 #endif /* CONFIG_DASD_PROFILE */ 1156 1157 static int dasd_hosts_show(struct seq_file *m, void *v) 1158 { 1159 struct dasd_device *device; 1160 int rc = -EOPNOTSUPP; 1161 1162 device = m->private; 1163 dasd_get_device(device); 1164 1165 if (device->discipline->hosts_print) 1166 rc = device->discipline->hosts_print(device, m); 1167 1168 dasd_put_device(device); 1169 return rc; 1170 } 1171 1172 static int dasd_hosts_open(struct inode *inode, struct file *file) 1173 { 1174 struct dasd_device *device = inode->i_private; 1175 1176 return single_open(file, dasd_hosts_show, device); 1177 } 1178 1179 static const struct file_operations dasd_hosts_fops = { 1180 .owner = THIS_MODULE, 1181 .open = dasd_hosts_open, 1182 .read = seq_read, 1183 .llseek = seq_lseek, 1184 .release = single_release, 1185 }; 1186 1187 static void dasd_hosts_exit(struct dasd_device *device) 1188 { 1189 debugfs_remove(device->hosts_dentry); 1190 device->hosts_dentry = NULL; 1191 } 1192 1193 static void dasd_hosts_init(struct dentry *base_dentry, 1194 struct dasd_device *device) 1195 { 1196 struct dentry *pde; 1197 umode_t mode; 1198 1199 if (!base_dentry) 1200 return; 1201 1202 mode = S_IRUSR | S_IFREG; 1203 pde = debugfs_create_file("host_access_list", mode, base_dentry, 1204 device, &dasd_hosts_fops); 1205 if (pde && !IS_ERR(pde)) 1206 device->hosts_dentry = pde; 1207 } 1208 1209 /* 1210 * Allocate memory for a channel program with 'cplength' channel 1211 * command words and 'datasize' additional space. There are two 1212 * variantes: 1) dasd_kmalloc_request uses kmalloc to get the needed 1213 * memory and 2) dasd_smalloc_request uses the static ccw memory 1214 * that gets allocated for each device. 1215 */ 1216 struct dasd_ccw_req *dasd_kmalloc_request(int magic, int cplength, 1217 int datasize, 1218 struct dasd_device *device) 1219 { 1220 struct dasd_ccw_req *cqr; 1221 1222 /* Sanity checks */ 1223 BUG_ON(datasize > PAGE_SIZE || 1224 (cplength*sizeof(struct ccw1)) > PAGE_SIZE); 1225 1226 cqr = kzalloc(sizeof(struct dasd_ccw_req), GFP_ATOMIC); 1227 if (cqr == NULL) 1228 return ERR_PTR(-ENOMEM); 1229 cqr->cpaddr = NULL; 1230 if (cplength > 0) { 1231 cqr->cpaddr = kcalloc(cplength, sizeof(struct ccw1), 1232 GFP_ATOMIC | GFP_DMA); 1233 if (cqr->cpaddr == NULL) { 1234 kfree(cqr); 1235 return ERR_PTR(-ENOMEM); 1236 } 1237 } 1238 cqr->data = NULL; 1239 if (datasize > 0) { 1240 cqr->data = kzalloc(datasize, GFP_ATOMIC | GFP_DMA); 1241 if (cqr->data == NULL) { 1242 kfree(cqr->cpaddr); 1243 kfree(cqr); 1244 return ERR_PTR(-ENOMEM); 1245 } 1246 } 1247 cqr->magic = magic; 1248 set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 1249 dasd_get_device(device); 1250 return cqr; 1251 } 1252 EXPORT_SYMBOL(dasd_kmalloc_request); 1253 1254 struct dasd_ccw_req *dasd_smalloc_request(int magic, int cplength, 1255 int datasize, 1256 struct dasd_device *device) 1257 { 1258 unsigned long flags; 1259 struct dasd_ccw_req *cqr; 1260 char *data; 1261 int size; 1262 1263 size = (sizeof(struct dasd_ccw_req) + 7L) & -8L; 1264 if (cplength > 0) 1265 size += cplength * sizeof(struct ccw1); 1266 if (datasize > 0) 1267 size += datasize; 1268 spin_lock_irqsave(&device->mem_lock, flags); 1269 cqr = (struct dasd_ccw_req *) 1270 dasd_alloc_chunk(&device->ccw_chunks, size); 1271 spin_unlock_irqrestore(&device->mem_lock, flags); 1272 if (cqr == NULL) 1273 return ERR_PTR(-ENOMEM); 1274 memset(cqr, 0, sizeof(struct dasd_ccw_req)); 1275 data = (char *) cqr + ((sizeof(struct dasd_ccw_req) + 7L) & -8L); 1276 cqr->cpaddr = NULL; 1277 if (cplength > 0) { 1278 cqr->cpaddr = (struct ccw1 *) data; 1279 data += cplength*sizeof(struct ccw1); 1280 memset(cqr->cpaddr, 0, cplength*sizeof(struct ccw1)); 1281 } 1282 cqr->data = NULL; 1283 if (datasize > 0) { 1284 cqr->data = data; 1285 memset(cqr->data, 0, datasize); 1286 } 1287 cqr->magic = magic; 1288 set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 1289 dasd_get_device(device); 1290 return cqr; 1291 } 1292 EXPORT_SYMBOL(dasd_smalloc_request); 1293 1294 /* 1295 * Free memory of a channel program. This function needs to free all the 1296 * idal lists that might have been created by dasd_set_cda and the 1297 * struct dasd_ccw_req itself. 1298 */ 1299 void dasd_kfree_request(struct dasd_ccw_req *cqr, struct dasd_device *device) 1300 { 1301 struct ccw1 *ccw; 1302 1303 /* Clear any idals used for the request. */ 1304 ccw = cqr->cpaddr; 1305 do { 1306 clear_normalized_cda(ccw); 1307 } while (ccw++->flags & (CCW_FLAG_CC | CCW_FLAG_DC)); 1308 kfree(cqr->cpaddr); 1309 kfree(cqr->data); 1310 kfree(cqr); 1311 dasd_put_device(device); 1312 } 1313 EXPORT_SYMBOL(dasd_kfree_request); 1314 1315 void dasd_sfree_request(struct dasd_ccw_req *cqr, struct dasd_device *device) 1316 { 1317 unsigned long flags; 1318 1319 spin_lock_irqsave(&device->mem_lock, flags); 1320 dasd_free_chunk(&device->ccw_chunks, cqr); 1321 spin_unlock_irqrestore(&device->mem_lock, flags); 1322 dasd_put_device(device); 1323 } 1324 EXPORT_SYMBOL(dasd_sfree_request); 1325 1326 /* 1327 * Check discipline magic in cqr. 1328 */ 1329 static inline int dasd_check_cqr(struct dasd_ccw_req *cqr) 1330 { 1331 struct dasd_device *device; 1332 1333 if (cqr == NULL) 1334 return -EINVAL; 1335 device = cqr->startdev; 1336 if (strncmp((char *) &cqr->magic, device->discipline->ebcname, 4)) { 1337 DBF_DEV_EVENT(DBF_WARNING, device, 1338 " dasd_ccw_req 0x%08x magic doesn't match" 1339 " discipline 0x%08x", 1340 cqr->magic, 1341 *(unsigned int *) device->discipline->name); 1342 return -EINVAL; 1343 } 1344 return 0; 1345 } 1346 1347 /* 1348 * Terminate the current i/o and set the request to clear_pending. 1349 * Timer keeps device runnig. 1350 * ccw_device_clear can fail if the i/o subsystem 1351 * is in a bad mood. 1352 */ 1353 int dasd_term_IO(struct dasd_ccw_req *cqr) 1354 { 1355 struct dasd_device *device; 1356 int retries, rc; 1357 char errorstring[ERRORLENGTH]; 1358 1359 /* Check the cqr */ 1360 rc = dasd_check_cqr(cqr); 1361 if (rc) 1362 return rc; 1363 retries = 0; 1364 device = (struct dasd_device *) cqr->startdev; 1365 while ((retries < 5) && (cqr->status == DASD_CQR_IN_IO)) { 1366 rc = ccw_device_clear(device->cdev, (long) cqr); 1367 switch (rc) { 1368 case 0: /* termination successful */ 1369 cqr->status = DASD_CQR_CLEAR_PENDING; 1370 cqr->stopclk = get_tod_clock(); 1371 cqr->starttime = 0; 1372 DBF_DEV_EVENT(DBF_DEBUG, device, 1373 "terminate cqr %p successful", 1374 cqr); 1375 break; 1376 case -ENODEV: 1377 DBF_DEV_EVENT(DBF_ERR, device, "%s", 1378 "device gone, retry"); 1379 break; 1380 case -EIO: 1381 DBF_DEV_EVENT(DBF_ERR, device, "%s", 1382 "I/O error, retry"); 1383 break; 1384 case -EINVAL: 1385 /* 1386 * device not valid so no I/O could be running 1387 * handle CQR as termination successful 1388 */ 1389 cqr->status = DASD_CQR_CLEARED; 1390 cqr->stopclk = get_tod_clock(); 1391 cqr->starttime = 0; 1392 /* no retries for invalid devices */ 1393 cqr->retries = -1; 1394 DBF_DEV_EVENT(DBF_ERR, device, "%s", 1395 "EINVAL, handle as terminated"); 1396 /* fake rc to success */ 1397 rc = 0; 1398 break; 1399 case -EBUSY: 1400 DBF_DEV_EVENT(DBF_ERR, device, "%s", 1401 "device busy, retry later"); 1402 break; 1403 default: 1404 /* internal error 10 - unknown rc*/ 1405 snprintf(errorstring, ERRORLENGTH, "10 %d", rc); 1406 dev_err(&device->cdev->dev, "An error occurred in the " 1407 "DASD device driver, reason=%s\n", errorstring); 1408 BUG(); 1409 break; 1410 } 1411 retries++; 1412 } 1413 dasd_schedule_device_bh(device); 1414 return rc; 1415 } 1416 EXPORT_SYMBOL(dasd_term_IO); 1417 1418 /* 1419 * Start the i/o. This start_IO can fail if the channel is really busy. 1420 * In that case set up a timer to start the request later. 1421 */ 1422 int dasd_start_IO(struct dasd_ccw_req *cqr) 1423 { 1424 struct dasd_device *device; 1425 int rc; 1426 char errorstring[ERRORLENGTH]; 1427 1428 /* Check the cqr */ 1429 rc = dasd_check_cqr(cqr); 1430 if (rc) { 1431 cqr->intrc = rc; 1432 return rc; 1433 } 1434 device = (struct dasd_device *) cqr->startdev; 1435 if (((cqr->block && 1436 test_bit(DASD_FLAG_LOCK_STOLEN, &cqr->block->base->flags)) || 1437 test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags)) && 1438 !test_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags)) { 1439 DBF_DEV_EVENT(DBF_DEBUG, device, "start_IO: return request %p " 1440 "because of stolen lock", cqr); 1441 cqr->status = DASD_CQR_ERROR; 1442 cqr->intrc = -EPERM; 1443 return -EPERM; 1444 } 1445 if (cqr->retries < 0) { 1446 /* internal error 14 - start_IO run out of retries */ 1447 sprintf(errorstring, "14 %p", cqr); 1448 dev_err(&device->cdev->dev, "An error occurred in the DASD " 1449 "device driver, reason=%s\n", errorstring); 1450 cqr->status = DASD_CQR_ERROR; 1451 return -EIO; 1452 } 1453 cqr->startclk = get_tod_clock(); 1454 cqr->starttime = jiffies; 1455 cqr->retries--; 1456 if (!test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) { 1457 cqr->lpm &= device->path_data.opm; 1458 if (!cqr->lpm) 1459 cqr->lpm = device->path_data.opm; 1460 } 1461 if (cqr->cpmode == 1) { 1462 rc = ccw_device_tm_start(device->cdev, cqr->cpaddr, 1463 (long) cqr, cqr->lpm); 1464 } else { 1465 rc = ccw_device_start(device->cdev, cqr->cpaddr, 1466 (long) cqr, cqr->lpm, 0); 1467 } 1468 switch (rc) { 1469 case 0: 1470 cqr->status = DASD_CQR_IN_IO; 1471 break; 1472 case -EBUSY: 1473 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1474 "start_IO: device busy, retry later"); 1475 break; 1476 case -ETIMEDOUT: 1477 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1478 "start_IO: request timeout, retry later"); 1479 break; 1480 case -EACCES: 1481 /* -EACCES indicates that the request used only a subset of the 1482 * available paths and all these paths are gone. If the lpm of 1483 * this request was only a subset of the opm (e.g. the ppm) then 1484 * we just do a retry with all available paths. 1485 * If we already use the full opm, something is amiss, and we 1486 * need a full path verification. 1487 */ 1488 if (test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) { 1489 DBF_DEV_EVENT(DBF_WARNING, device, 1490 "start_IO: selected paths gone (%x)", 1491 cqr->lpm); 1492 } else if (cqr->lpm != device->path_data.opm) { 1493 cqr->lpm = device->path_data.opm; 1494 DBF_DEV_EVENT(DBF_DEBUG, device, "%s", 1495 "start_IO: selected paths gone," 1496 " retry on all paths"); 1497 } else { 1498 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1499 "start_IO: all paths in opm gone," 1500 " do path verification"); 1501 dasd_generic_last_path_gone(device); 1502 device->path_data.opm = 0; 1503 device->path_data.ppm = 0; 1504 device->path_data.npm = 0; 1505 device->path_data.tbvpm = 1506 ccw_device_get_path_mask(device->cdev); 1507 } 1508 break; 1509 case -ENODEV: 1510 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1511 "start_IO: -ENODEV device gone, retry"); 1512 break; 1513 case -EIO: 1514 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1515 "start_IO: -EIO device gone, retry"); 1516 break; 1517 case -EINVAL: 1518 /* most likely caused in power management context */ 1519 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1520 "start_IO: -EINVAL device currently " 1521 "not accessible"); 1522 break; 1523 default: 1524 /* internal error 11 - unknown rc */ 1525 snprintf(errorstring, ERRORLENGTH, "11 %d", rc); 1526 dev_err(&device->cdev->dev, 1527 "An error occurred in the DASD device driver, " 1528 "reason=%s\n", errorstring); 1529 BUG(); 1530 break; 1531 } 1532 cqr->intrc = rc; 1533 return rc; 1534 } 1535 EXPORT_SYMBOL(dasd_start_IO); 1536 1537 /* 1538 * Timeout function for dasd devices. This is used for different purposes 1539 * 1) missing interrupt handler for normal operation 1540 * 2) delayed start of request where start_IO failed with -EBUSY 1541 * 3) timeout for missing state change interrupts 1542 * The head of the ccw queue will have status DASD_CQR_IN_IO for 1), 1543 * DASD_CQR_QUEUED for 2) and 3). 1544 */ 1545 static void dasd_device_timeout(unsigned long ptr) 1546 { 1547 unsigned long flags; 1548 struct dasd_device *device; 1549 1550 device = (struct dasd_device *) ptr; 1551 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1552 /* re-activate request queue */ 1553 dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING); 1554 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 1555 dasd_schedule_device_bh(device); 1556 } 1557 1558 /* 1559 * Setup timeout for a device in jiffies. 1560 */ 1561 void dasd_device_set_timer(struct dasd_device *device, int expires) 1562 { 1563 if (expires == 0) 1564 del_timer(&device->timer); 1565 else 1566 mod_timer(&device->timer, jiffies + expires); 1567 } 1568 EXPORT_SYMBOL(dasd_device_set_timer); 1569 1570 /* 1571 * Clear timeout for a device. 1572 */ 1573 void dasd_device_clear_timer(struct dasd_device *device) 1574 { 1575 del_timer(&device->timer); 1576 } 1577 EXPORT_SYMBOL(dasd_device_clear_timer); 1578 1579 static void dasd_handle_killed_request(struct ccw_device *cdev, 1580 unsigned long intparm) 1581 { 1582 struct dasd_ccw_req *cqr; 1583 struct dasd_device *device; 1584 1585 if (!intparm) 1586 return; 1587 cqr = (struct dasd_ccw_req *) intparm; 1588 if (cqr->status != DASD_CQR_IN_IO) { 1589 DBF_EVENT_DEVID(DBF_DEBUG, cdev, 1590 "invalid status in handle_killed_request: " 1591 "%02x", cqr->status); 1592 return; 1593 } 1594 1595 device = dasd_device_from_cdev_locked(cdev); 1596 if (IS_ERR(device)) { 1597 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s", 1598 "unable to get device from cdev"); 1599 return; 1600 } 1601 1602 if (!cqr->startdev || 1603 device != cqr->startdev || 1604 strncmp(cqr->startdev->discipline->ebcname, 1605 (char *) &cqr->magic, 4)) { 1606 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s", 1607 "invalid device in request"); 1608 dasd_put_device(device); 1609 return; 1610 } 1611 1612 /* Schedule request to be retried. */ 1613 cqr->status = DASD_CQR_QUEUED; 1614 1615 dasd_device_clear_timer(device); 1616 dasd_schedule_device_bh(device); 1617 dasd_put_device(device); 1618 } 1619 1620 void dasd_generic_handle_state_change(struct dasd_device *device) 1621 { 1622 /* First of all start sense subsystem status request. */ 1623 dasd_eer_snss(device); 1624 1625 dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING); 1626 dasd_schedule_device_bh(device); 1627 if (device->block) 1628 dasd_schedule_block_bh(device->block); 1629 } 1630 EXPORT_SYMBOL_GPL(dasd_generic_handle_state_change); 1631 1632 /* 1633 * Interrupt handler for "normal" ssch-io based dasd devices. 1634 */ 1635 void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm, 1636 struct irb *irb) 1637 { 1638 struct dasd_ccw_req *cqr, *next; 1639 struct dasd_device *device; 1640 unsigned long long now; 1641 int nrf_suppressed = 0; 1642 int fp_suppressed = 0; 1643 u8 *sense = NULL; 1644 int expires; 1645 1646 if (IS_ERR(irb)) { 1647 switch (PTR_ERR(irb)) { 1648 case -EIO: 1649 break; 1650 case -ETIMEDOUT: 1651 DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: " 1652 "request timed out\n", __func__); 1653 break; 1654 default: 1655 DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: " 1656 "unknown error %ld\n", __func__, 1657 PTR_ERR(irb)); 1658 } 1659 dasd_handle_killed_request(cdev, intparm); 1660 return; 1661 } 1662 1663 now = get_tod_clock(); 1664 cqr = (struct dasd_ccw_req *) intparm; 1665 /* check for conditions that should be handled immediately */ 1666 if (!cqr || 1667 !(scsw_dstat(&irb->scsw) == (DEV_STAT_CHN_END | DEV_STAT_DEV_END) && 1668 scsw_cstat(&irb->scsw) == 0)) { 1669 if (cqr) 1670 memcpy(&cqr->irb, irb, sizeof(*irb)); 1671 device = dasd_device_from_cdev_locked(cdev); 1672 if (IS_ERR(device)) 1673 return; 1674 /* ignore unsolicited interrupts for DIAG discipline */ 1675 if (device->discipline == dasd_diag_discipline_pointer) { 1676 dasd_put_device(device); 1677 return; 1678 } 1679 1680 /* 1681 * In some cases 'File Protected' or 'No Record Found' errors 1682 * might be expected and debug log messages for the 1683 * corresponding interrupts shouldn't be written then. 1684 * Check if either of the according suppress bits is set. 1685 */ 1686 sense = dasd_get_sense(irb); 1687 if (sense) { 1688 fp_suppressed = (sense[1] & SNS1_FILE_PROTECTED) && 1689 test_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags); 1690 nrf_suppressed = (sense[1] & SNS1_NO_REC_FOUND) && 1691 test_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags); 1692 } 1693 if (!(fp_suppressed || nrf_suppressed)) 1694 device->discipline->dump_sense_dbf(device, irb, "int"); 1695 1696 if (device->features & DASD_FEATURE_ERPLOG) 1697 device->discipline->dump_sense(device, cqr, irb); 1698 device->discipline->check_for_device_change(device, cqr, irb); 1699 dasd_put_device(device); 1700 } 1701 1702 /* check for for attention message */ 1703 if (scsw_dstat(&irb->scsw) & DEV_STAT_ATTENTION) { 1704 device = dasd_device_from_cdev_locked(cdev); 1705 device->discipline->check_attention(device, irb->esw.esw1.lpum); 1706 dasd_put_device(device); 1707 } 1708 1709 if (!cqr) 1710 return; 1711 1712 device = (struct dasd_device *) cqr->startdev; 1713 if (!device || 1714 strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) { 1715 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s", 1716 "invalid device in request"); 1717 return; 1718 } 1719 1720 /* Check for clear pending */ 1721 if (cqr->status == DASD_CQR_CLEAR_PENDING && 1722 scsw_fctl(&irb->scsw) & SCSW_FCTL_CLEAR_FUNC) { 1723 cqr->status = DASD_CQR_CLEARED; 1724 dasd_device_clear_timer(device); 1725 wake_up(&dasd_flush_wq); 1726 dasd_schedule_device_bh(device); 1727 return; 1728 } 1729 1730 /* check status - the request might have been killed by dyn detach */ 1731 if (cqr->status != DASD_CQR_IN_IO) { 1732 DBF_DEV_EVENT(DBF_DEBUG, device, "invalid status: bus_id %s, " 1733 "status %02x", dev_name(&cdev->dev), cqr->status); 1734 return; 1735 } 1736 1737 next = NULL; 1738 expires = 0; 1739 if (scsw_dstat(&irb->scsw) == (DEV_STAT_CHN_END | DEV_STAT_DEV_END) && 1740 scsw_cstat(&irb->scsw) == 0) { 1741 /* request was completed successfully */ 1742 cqr->status = DASD_CQR_SUCCESS; 1743 cqr->stopclk = now; 1744 /* Start first request on queue if possible -> fast_io. */ 1745 if (cqr->devlist.next != &device->ccw_queue) { 1746 next = list_entry(cqr->devlist.next, 1747 struct dasd_ccw_req, devlist); 1748 } 1749 } else { /* error */ 1750 /* 1751 * If we don't want complex ERP for this request, then just 1752 * reset this and retry it in the fastpath 1753 */ 1754 if (!test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags) && 1755 cqr->retries > 0) { 1756 if (cqr->lpm == device->path_data.opm) 1757 DBF_DEV_EVENT(DBF_DEBUG, device, 1758 "default ERP in fastpath " 1759 "(%i retries left)", 1760 cqr->retries); 1761 if (!test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) 1762 cqr->lpm = device->path_data.opm; 1763 cqr->status = DASD_CQR_QUEUED; 1764 next = cqr; 1765 } else 1766 cqr->status = DASD_CQR_ERROR; 1767 } 1768 if (next && (next->status == DASD_CQR_QUEUED) && 1769 (!device->stopped)) { 1770 if (device->discipline->start_IO(next) == 0) 1771 expires = next->expires; 1772 } 1773 if (expires != 0) 1774 dasd_device_set_timer(device, expires); 1775 else 1776 dasd_device_clear_timer(device); 1777 dasd_schedule_device_bh(device); 1778 } 1779 EXPORT_SYMBOL(dasd_int_handler); 1780 1781 enum uc_todo dasd_generic_uc_handler(struct ccw_device *cdev, struct irb *irb) 1782 { 1783 struct dasd_device *device; 1784 1785 device = dasd_device_from_cdev_locked(cdev); 1786 1787 if (IS_ERR(device)) 1788 goto out; 1789 if (test_bit(DASD_FLAG_OFFLINE, &device->flags) || 1790 device->state != device->target || 1791 !device->discipline->check_for_device_change){ 1792 dasd_put_device(device); 1793 goto out; 1794 } 1795 if (device->discipline->dump_sense_dbf) 1796 device->discipline->dump_sense_dbf(device, irb, "uc"); 1797 device->discipline->check_for_device_change(device, NULL, irb); 1798 dasd_put_device(device); 1799 out: 1800 return UC_TODO_RETRY; 1801 } 1802 EXPORT_SYMBOL_GPL(dasd_generic_uc_handler); 1803 1804 /* 1805 * If we have an error on a dasd_block layer request then we cancel 1806 * and return all further requests from the same dasd_block as well. 1807 */ 1808 static void __dasd_device_recovery(struct dasd_device *device, 1809 struct dasd_ccw_req *ref_cqr) 1810 { 1811 struct list_head *l, *n; 1812 struct dasd_ccw_req *cqr; 1813 1814 /* 1815 * only requeue request that came from the dasd_block layer 1816 */ 1817 if (!ref_cqr->block) 1818 return; 1819 1820 list_for_each_safe(l, n, &device->ccw_queue) { 1821 cqr = list_entry(l, struct dasd_ccw_req, devlist); 1822 if (cqr->status == DASD_CQR_QUEUED && 1823 ref_cqr->block == cqr->block) { 1824 cqr->status = DASD_CQR_CLEARED; 1825 } 1826 } 1827 }; 1828 1829 /* 1830 * Remove those ccw requests from the queue that need to be returned 1831 * to the upper layer. 1832 */ 1833 static void __dasd_device_process_ccw_queue(struct dasd_device *device, 1834 struct list_head *final_queue) 1835 { 1836 struct list_head *l, *n; 1837 struct dasd_ccw_req *cqr; 1838 1839 /* Process request with final status. */ 1840 list_for_each_safe(l, n, &device->ccw_queue) { 1841 cqr = list_entry(l, struct dasd_ccw_req, devlist); 1842 1843 /* Skip any non-final request. */ 1844 if (cqr->status == DASD_CQR_QUEUED || 1845 cqr->status == DASD_CQR_IN_IO || 1846 cqr->status == DASD_CQR_CLEAR_PENDING) 1847 continue; 1848 if (cqr->status == DASD_CQR_ERROR) { 1849 __dasd_device_recovery(device, cqr); 1850 } 1851 /* Rechain finished requests to final queue */ 1852 list_move_tail(&cqr->devlist, final_queue); 1853 } 1854 } 1855 1856 /* 1857 * the cqrs from the final queue are returned to the upper layer 1858 * by setting a dasd_block state and calling the callback function 1859 */ 1860 static void __dasd_device_process_final_queue(struct dasd_device *device, 1861 struct list_head *final_queue) 1862 { 1863 struct list_head *l, *n; 1864 struct dasd_ccw_req *cqr; 1865 struct dasd_block *block; 1866 void (*callback)(struct dasd_ccw_req *, void *data); 1867 void *callback_data; 1868 char errorstring[ERRORLENGTH]; 1869 1870 list_for_each_safe(l, n, final_queue) { 1871 cqr = list_entry(l, struct dasd_ccw_req, devlist); 1872 list_del_init(&cqr->devlist); 1873 block = cqr->block; 1874 callback = cqr->callback; 1875 callback_data = cqr->callback_data; 1876 if (block) 1877 spin_lock_bh(&block->queue_lock); 1878 switch (cqr->status) { 1879 case DASD_CQR_SUCCESS: 1880 cqr->status = DASD_CQR_DONE; 1881 break; 1882 case DASD_CQR_ERROR: 1883 cqr->status = DASD_CQR_NEED_ERP; 1884 break; 1885 case DASD_CQR_CLEARED: 1886 cqr->status = DASD_CQR_TERMINATED; 1887 break; 1888 default: 1889 /* internal error 12 - wrong cqr status*/ 1890 snprintf(errorstring, ERRORLENGTH, "12 %p %x02", cqr, cqr->status); 1891 dev_err(&device->cdev->dev, 1892 "An error occurred in the DASD device driver, " 1893 "reason=%s\n", errorstring); 1894 BUG(); 1895 } 1896 if (cqr->callback != NULL) 1897 (callback)(cqr, callback_data); 1898 if (block) 1899 spin_unlock_bh(&block->queue_lock); 1900 } 1901 } 1902 1903 /* 1904 * Take a look at the first request on the ccw queue and check 1905 * if it reached its expire time. If so, terminate the IO. 1906 */ 1907 static void __dasd_device_check_expire(struct dasd_device *device) 1908 { 1909 struct dasd_ccw_req *cqr; 1910 1911 if (list_empty(&device->ccw_queue)) 1912 return; 1913 cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist); 1914 if ((cqr->status == DASD_CQR_IN_IO && cqr->expires != 0) && 1915 (time_after_eq(jiffies, cqr->expires + cqr->starttime))) { 1916 if (test_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING, &device->flags)) { 1917 /* 1918 * IO in safe offline processing should not 1919 * run out of retries 1920 */ 1921 cqr->retries++; 1922 } 1923 if (device->discipline->term_IO(cqr) != 0) { 1924 /* Hmpf, try again in 5 sec */ 1925 dev_err(&device->cdev->dev, 1926 "cqr %p timed out (%lus) but cannot be " 1927 "ended, retrying in 5 s\n", 1928 cqr, (cqr->expires/HZ)); 1929 cqr->expires += 5*HZ; 1930 dasd_device_set_timer(device, 5*HZ); 1931 } else { 1932 dev_err(&device->cdev->dev, 1933 "cqr %p timed out (%lus), %i retries " 1934 "remaining\n", cqr, (cqr->expires/HZ), 1935 cqr->retries); 1936 } 1937 } 1938 } 1939 1940 /* 1941 * return 1 when device is not eligible for IO 1942 */ 1943 static int __dasd_device_is_unusable(struct dasd_device *device, 1944 struct dasd_ccw_req *cqr) 1945 { 1946 int mask = ~(DASD_STOPPED_DC_WAIT | DASD_UNRESUMED_PM); 1947 1948 if (test_bit(DASD_FLAG_OFFLINE, &device->flags)) { 1949 /* dasd is being set offline. */ 1950 return 1; 1951 } 1952 if (device->stopped) { 1953 if (device->stopped & mask) { 1954 /* stopped and CQR will not change that. */ 1955 return 1; 1956 } 1957 if (!test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) { 1958 /* CQR is not able to change device to 1959 * operational. */ 1960 return 1; 1961 } 1962 /* CQR required to get device operational. */ 1963 } 1964 return 0; 1965 } 1966 1967 /* 1968 * Take a look at the first request on the ccw queue and check 1969 * if it needs to be started. 1970 */ 1971 static void __dasd_device_start_head(struct dasd_device *device) 1972 { 1973 struct dasd_ccw_req *cqr; 1974 int rc; 1975 1976 if (list_empty(&device->ccw_queue)) 1977 return; 1978 cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist); 1979 if (cqr->status != DASD_CQR_QUEUED) 1980 return; 1981 /* if device is not usable return request to upper layer */ 1982 if (__dasd_device_is_unusable(device, cqr)) { 1983 cqr->intrc = -EAGAIN; 1984 cqr->status = DASD_CQR_CLEARED; 1985 dasd_schedule_device_bh(device); 1986 return; 1987 } 1988 1989 rc = device->discipline->start_IO(cqr); 1990 if (rc == 0) 1991 dasd_device_set_timer(device, cqr->expires); 1992 else if (rc == -EACCES) { 1993 dasd_schedule_device_bh(device); 1994 } else 1995 /* Hmpf, try again in 1/2 sec */ 1996 dasd_device_set_timer(device, 50); 1997 } 1998 1999 static void __dasd_device_check_path_events(struct dasd_device *device) 2000 { 2001 int rc; 2002 2003 if (device->path_data.tbvpm) { 2004 if (device->stopped & ~(DASD_STOPPED_DC_WAIT | 2005 DASD_UNRESUMED_PM)) 2006 return; 2007 rc = device->discipline->verify_path( 2008 device, device->path_data.tbvpm); 2009 if (rc) 2010 dasd_device_set_timer(device, 50); 2011 else 2012 device->path_data.tbvpm = 0; 2013 } 2014 }; 2015 2016 /* 2017 * Go through all request on the dasd_device request queue, 2018 * terminate them on the cdev if necessary, and return them to the 2019 * submitting layer via callback. 2020 * Note: 2021 * Make sure that all 'submitting layers' still exist when 2022 * this function is called!. In other words, when 'device' is a base 2023 * device then all block layer requests must have been removed before 2024 * via dasd_flush_block_queue. 2025 */ 2026 int dasd_flush_device_queue(struct dasd_device *device) 2027 { 2028 struct dasd_ccw_req *cqr, *n; 2029 int rc; 2030 struct list_head flush_queue; 2031 2032 INIT_LIST_HEAD(&flush_queue); 2033 spin_lock_irq(get_ccwdev_lock(device->cdev)); 2034 rc = 0; 2035 list_for_each_entry_safe(cqr, n, &device->ccw_queue, devlist) { 2036 /* Check status and move request to flush_queue */ 2037 switch (cqr->status) { 2038 case DASD_CQR_IN_IO: 2039 rc = device->discipline->term_IO(cqr); 2040 if (rc) { 2041 /* unable to terminate requeust */ 2042 dev_err(&device->cdev->dev, 2043 "Flushing the DASD request queue " 2044 "failed for request %p\n", cqr); 2045 /* stop flush processing */ 2046 goto finished; 2047 } 2048 break; 2049 case DASD_CQR_QUEUED: 2050 cqr->stopclk = get_tod_clock(); 2051 cqr->status = DASD_CQR_CLEARED; 2052 break; 2053 default: /* no need to modify the others */ 2054 break; 2055 } 2056 list_move_tail(&cqr->devlist, &flush_queue); 2057 } 2058 finished: 2059 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 2060 /* 2061 * After this point all requests must be in state CLEAR_PENDING, 2062 * CLEARED, SUCCESS or ERROR. Now wait for CLEAR_PENDING to become 2063 * one of the others. 2064 */ 2065 list_for_each_entry_safe(cqr, n, &flush_queue, devlist) 2066 wait_event(dasd_flush_wq, 2067 (cqr->status != DASD_CQR_CLEAR_PENDING)); 2068 /* 2069 * Now set each request back to TERMINATED, DONE or NEED_ERP 2070 * and call the callback function of flushed requests 2071 */ 2072 __dasd_device_process_final_queue(device, &flush_queue); 2073 return rc; 2074 } 2075 EXPORT_SYMBOL_GPL(dasd_flush_device_queue); 2076 2077 /* 2078 * Acquire the device lock and process queues for the device. 2079 */ 2080 static void dasd_device_tasklet(struct dasd_device *device) 2081 { 2082 struct list_head final_queue; 2083 2084 atomic_set (&device->tasklet_scheduled, 0); 2085 INIT_LIST_HEAD(&final_queue); 2086 spin_lock_irq(get_ccwdev_lock(device->cdev)); 2087 /* Check expire time of first request on the ccw queue. */ 2088 __dasd_device_check_expire(device); 2089 /* find final requests on ccw queue */ 2090 __dasd_device_process_ccw_queue(device, &final_queue); 2091 __dasd_device_check_path_events(device); 2092 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 2093 /* Now call the callback function of requests with final status */ 2094 __dasd_device_process_final_queue(device, &final_queue); 2095 spin_lock_irq(get_ccwdev_lock(device->cdev)); 2096 /* Now check if the head of the ccw queue needs to be started. */ 2097 __dasd_device_start_head(device); 2098 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 2099 if (waitqueue_active(&shutdown_waitq)) 2100 wake_up(&shutdown_waitq); 2101 dasd_put_device(device); 2102 } 2103 2104 /* 2105 * Schedules a call to dasd_tasklet over the device tasklet. 2106 */ 2107 void dasd_schedule_device_bh(struct dasd_device *device) 2108 { 2109 /* Protect against rescheduling. */ 2110 if (atomic_cmpxchg (&device->tasklet_scheduled, 0, 1) != 0) 2111 return; 2112 dasd_get_device(device); 2113 tasklet_hi_schedule(&device->tasklet); 2114 } 2115 EXPORT_SYMBOL(dasd_schedule_device_bh); 2116 2117 void dasd_device_set_stop_bits(struct dasd_device *device, int bits) 2118 { 2119 device->stopped |= bits; 2120 } 2121 EXPORT_SYMBOL_GPL(dasd_device_set_stop_bits); 2122 2123 void dasd_device_remove_stop_bits(struct dasd_device *device, int bits) 2124 { 2125 device->stopped &= ~bits; 2126 if (!device->stopped) 2127 wake_up(&generic_waitq); 2128 } 2129 EXPORT_SYMBOL_GPL(dasd_device_remove_stop_bits); 2130 2131 /* 2132 * Queue a request to the head of the device ccw_queue. 2133 * Start the I/O if possible. 2134 */ 2135 void dasd_add_request_head(struct dasd_ccw_req *cqr) 2136 { 2137 struct dasd_device *device; 2138 unsigned long flags; 2139 2140 device = cqr->startdev; 2141 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 2142 cqr->status = DASD_CQR_QUEUED; 2143 list_add(&cqr->devlist, &device->ccw_queue); 2144 /* let the bh start the request to keep them in order */ 2145 dasd_schedule_device_bh(device); 2146 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 2147 } 2148 EXPORT_SYMBOL(dasd_add_request_head); 2149 2150 /* 2151 * Queue a request to the tail of the device ccw_queue. 2152 * Start the I/O if possible. 2153 */ 2154 void dasd_add_request_tail(struct dasd_ccw_req *cqr) 2155 { 2156 struct dasd_device *device; 2157 unsigned long flags; 2158 2159 device = cqr->startdev; 2160 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 2161 cqr->status = DASD_CQR_QUEUED; 2162 list_add_tail(&cqr->devlist, &device->ccw_queue); 2163 /* let the bh start the request to keep them in order */ 2164 dasd_schedule_device_bh(device); 2165 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 2166 } 2167 EXPORT_SYMBOL(dasd_add_request_tail); 2168 2169 /* 2170 * Wakeup helper for the 'sleep_on' functions. 2171 */ 2172 void dasd_wakeup_cb(struct dasd_ccw_req *cqr, void *data) 2173 { 2174 spin_lock_irq(get_ccwdev_lock(cqr->startdev->cdev)); 2175 cqr->callback_data = DASD_SLEEPON_END_TAG; 2176 spin_unlock_irq(get_ccwdev_lock(cqr->startdev->cdev)); 2177 wake_up(&generic_waitq); 2178 } 2179 EXPORT_SYMBOL_GPL(dasd_wakeup_cb); 2180 2181 static inline int _wait_for_wakeup(struct dasd_ccw_req *cqr) 2182 { 2183 struct dasd_device *device; 2184 int rc; 2185 2186 device = cqr->startdev; 2187 spin_lock_irq(get_ccwdev_lock(device->cdev)); 2188 rc = (cqr->callback_data == DASD_SLEEPON_END_TAG); 2189 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 2190 return rc; 2191 } 2192 2193 /* 2194 * checks if error recovery is necessary, returns 1 if yes, 0 otherwise. 2195 */ 2196 static int __dasd_sleep_on_erp(struct dasd_ccw_req *cqr) 2197 { 2198 struct dasd_device *device; 2199 dasd_erp_fn_t erp_fn; 2200 2201 if (cqr->status == DASD_CQR_FILLED) 2202 return 0; 2203 device = cqr->startdev; 2204 if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) { 2205 if (cqr->status == DASD_CQR_TERMINATED) { 2206 device->discipline->handle_terminated_request(cqr); 2207 return 1; 2208 } 2209 if (cqr->status == DASD_CQR_NEED_ERP) { 2210 erp_fn = device->discipline->erp_action(cqr); 2211 erp_fn(cqr); 2212 return 1; 2213 } 2214 if (cqr->status == DASD_CQR_FAILED) 2215 dasd_log_sense(cqr, &cqr->irb); 2216 if (cqr->refers) { 2217 __dasd_process_erp(device, cqr); 2218 return 1; 2219 } 2220 } 2221 return 0; 2222 } 2223 2224 static int __dasd_sleep_on_loop_condition(struct dasd_ccw_req *cqr) 2225 { 2226 if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) { 2227 if (cqr->refers) /* erp is not done yet */ 2228 return 1; 2229 return ((cqr->status != DASD_CQR_DONE) && 2230 (cqr->status != DASD_CQR_FAILED)); 2231 } else 2232 return (cqr->status == DASD_CQR_FILLED); 2233 } 2234 2235 static int _dasd_sleep_on(struct dasd_ccw_req *maincqr, int interruptible) 2236 { 2237 struct dasd_device *device; 2238 int rc; 2239 struct list_head ccw_queue; 2240 struct dasd_ccw_req *cqr; 2241 2242 INIT_LIST_HEAD(&ccw_queue); 2243 maincqr->status = DASD_CQR_FILLED; 2244 device = maincqr->startdev; 2245 list_add(&maincqr->blocklist, &ccw_queue); 2246 for (cqr = maincqr; __dasd_sleep_on_loop_condition(cqr); 2247 cqr = list_first_entry(&ccw_queue, 2248 struct dasd_ccw_req, blocklist)) { 2249 2250 if (__dasd_sleep_on_erp(cqr)) 2251 continue; 2252 if (cqr->status != DASD_CQR_FILLED) /* could be failed */ 2253 continue; 2254 if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags) && 2255 !test_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags)) { 2256 cqr->status = DASD_CQR_FAILED; 2257 cqr->intrc = -EPERM; 2258 continue; 2259 } 2260 /* Non-temporary stop condition will trigger fail fast */ 2261 if (device->stopped & ~DASD_STOPPED_PENDING && 2262 test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) && 2263 (!dasd_eer_enabled(device))) { 2264 cqr->status = DASD_CQR_FAILED; 2265 cqr->intrc = -ENOLINK; 2266 continue; 2267 } 2268 /* 2269 * Don't try to start requests if device is stopped 2270 * except path verification requests 2271 */ 2272 if (!test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) { 2273 if (interruptible) { 2274 rc = wait_event_interruptible( 2275 generic_waitq, !(device->stopped)); 2276 if (rc == -ERESTARTSYS) { 2277 cqr->status = DASD_CQR_FAILED; 2278 maincqr->intrc = rc; 2279 continue; 2280 } 2281 } else 2282 wait_event(generic_waitq, !(device->stopped)); 2283 } 2284 if (!cqr->callback) 2285 cqr->callback = dasd_wakeup_cb; 2286 2287 cqr->callback_data = DASD_SLEEPON_START_TAG; 2288 dasd_add_request_tail(cqr); 2289 if (interruptible) { 2290 rc = wait_event_interruptible( 2291 generic_waitq, _wait_for_wakeup(cqr)); 2292 if (rc == -ERESTARTSYS) { 2293 dasd_cancel_req(cqr); 2294 /* wait (non-interruptible) for final status */ 2295 wait_event(generic_waitq, 2296 _wait_for_wakeup(cqr)); 2297 cqr->status = DASD_CQR_FAILED; 2298 maincqr->intrc = rc; 2299 continue; 2300 } 2301 } else 2302 wait_event(generic_waitq, _wait_for_wakeup(cqr)); 2303 } 2304 2305 maincqr->endclk = get_tod_clock(); 2306 if ((maincqr->status != DASD_CQR_DONE) && 2307 (maincqr->intrc != -ERESTARTSYS)) 2308 dasd_log_sense(maincqr, &maincqr->irb); 2309 if (maincqr->status == DASD_CQR_DONE) 2310 rc = 0; 2311 else if (maincqr->intrc) 2312 rc = maincqr->intrc; 2313 else 2314 rc = -EIO; 2315 return rc; 2316 } 2317 2318 static inline int _wait_for_wakeup_queue(struct list_head *ccw_queue) 2319 { 2320 struct dasd_ccw_req *cqr; 2321 2322 list_for_each_entry(cqr, ccw_queue, blocklist) { 2323 if (cqr->callback_data != DASD_SLEEPON_END_TAG) 2324 return 0; 2325 } 2326 2327 return 1; 2328 } 2329 2330 static int _dasd_sleep_on_queue(struct list_head *ccw_queue, int interruptible) 2331 { 2332 struct dasd_device *device; 2333 struct dasd_ccw_req *cqr, *n; 2334 u8 *sense = NULL; 2335 int rc; 2336 2337 retry: 2338 list_for_each_entry_safe(cqr, n, ccw_queue, blocklist) { 2339 device = cqr->startdev; 2340 if (cqr->status != DASD_CQR_FILLED) /*could be failed*/ 2341 continue; 2342 2343 if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags) && 2344 !test_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags)) { 2345 cqr->status = DASD_CQR_FAILED; 2346 cqr->intrc = -EPERM; 2347 continue; 2348 } 2349 /*Non-temporary stop condition will trigger fail fast*/ 2350 if (device->stopped & ~DASD_STOPPED_PENDING && 2351 test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) && 2352 !dasd_eer_enabled(device)) { 2353 cqr->status = DASD_CQR_FAILED; 2354 cqr->intrc = -EAGAIN; 2355 continue; 2356 } 2357 2358 /*Don't try to start requests if device is stopped*/ 2359 if (interruptible) { 2360 rc = wait_event_interruptible( 2361 generic_waitq, !device->stopped); 2362 if (rc == -ERESTARTSYS) { 2363 cqr->status = DASD_CQR_FAILED; 2364 cqr->intrc = rc; 2365 continue; 2366 } 2367 } else 2368 wait_event(generic_waitq, !(device->stopped)); 2369 2370 if (!cqr->callback) 2371 cqr->callback = dasd_wakeup_cb; 2372 cqr->callback_data = DASD_SLEEPON_START_TAG; 2373 dasd_add_request_tail(cqr); 2374 } 2375 2376 wait_event(generic_waitq, _wait_for_wakeup_queue(ccw_queue)); 2377 2378 rc = 0; 2379 list_for_each_entry_safe(cqr, n, ccw_queue, blocklist) { 2380 /* 2381 * In some cases the 'File Protected' or 'Incorrect Length' 2382 * error might be expected and error recovery would be 2383 * unnecessary in these cases. Check if the according suppress 2384 * bit is set. 2385 */ 2386 sense = dasd_get_sense(&cqr->irb); 2387 if (sense && sense[1] & SNS1_FILE_PROTECTED && 2388 test_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags)) 2389 continue; 2390 if (scsw_cstat(&cqr->irb.scsw) == 0x40 && 2391 test_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags)) 2392 continue; 2393 2394 /* 2395 * for alias devices simplify error recovery and 2396 * return to upper layer 2397 * do not skip ERP requests 2398 */ 2399 if (cqr->startdev != cqr->basedev && !cqr->refers && 2400 (cqr->status == DASD_CQR_TERMINATED || 2401 cqr->status == DASD_CQR_NEED_ERP)) 2402 return -EAGAIN; 2403 2404 /* normal recovery for basedev IO */ 2405 if (__dasd_sleep_on_erp(cqr)) 2406 /* handle erp first */ 2407 goto retry; 2408 } 2409 2410 return 0; 2411 } 2412 2413 /* 2414 * Queue a request to the tail of the device ccw_queue and wait for 2415 * it's completion. 2416 */ 2417 int dasd_sleep_on(struct dasd_ccw_req *cqr) 2418 { 2419 return _dasd_sleep_on(cqr, 0); 2420 } 2421 EXPORT_SYMBOL(dasd_sleep_on); 2422 2423 /* 2424 * Start requests from a ccw_queue and wait for their completion. 2425 */ 2426 int dasd_sleep_on_queue(struct list_head *ccw_queue) 2427 { 2428 return _dasd_sleep_on_queue(ccw_queue, 0); 2429 } 2430 EXPORT_SYMBOL(dasd_sleep_on_queue); 2431 2432 /* 2433 * Queue a request to the tail of the device ccw_queue and wait 2434 * interruptible for it's completion. 2435 */ 2436 int dasd_sleep_on_interruptible(struct dasd_ccw_req *cqr) 2437 { 2438 return _dasd_sleep_on(cqr, 1); 2439 } 2440 EXPORT_SYMBOL(dasd_sleep_on_interruptible); 2441 2442 /* 2443 * Whoa nelly now it gets really hairy. For some functions (e.g. steal lock 2444 * for eckd devices) the currently running request has to be terminated 2445 * and be put back to status queued, before the special request is added 2446 * to the head of the queue. Then the special request is waited on normally. 2447 */ 2448 static inline int _dasd_term_running_cqr(struct dasd_device *device) 2449 { 2450 struct dasd_ccw_req *cqr; 2451 int rc; 2452 2453 if (list_empty(&device->ccw_queue)) 2454 return 0; 2455 cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist); 2456 rc = device->discipline->term_IO(cqr); 2457 if (!rc) 2458 /* 2459 * CQR terminated because a more important request is pending. 2460 * Undo decreasing of retry counter because this is 2461 * not an error case. 2462 */ 2463 cqr->retries++; 2464 return rc; 2465 } 2466 2467 int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr) 2468 { 2469 struct dasd_device *device; 2470 int rc; 2471 2472 device = cqr->startdev; 2473 if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags) && 2474 !test_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags)) { 2475 cqr->status = DASD_CQR_FAILED; 2476 cqr->intrc = -EPERM; 2477 return -EIO; 2478 } 2479 spin_lock_irq(get_ccwdev_lock(device->cdev)); 2480 rc = _dasd_term_running_cqr(device); 2481 if (rc) { 2482 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 2483 return rc; 2484 } 2485 cqr->callback = dasd_wakeup_cb; 2486 cqr->callback_data = DASD_SLEEPON_START_TAG; 2487 cqr->status = DASD_CQR_QUEUED; 2488 /* 2489 * add new request as second 2490 * first the terminated cqr needs to be finished 2491 */ 2492 list_add(&cqr->devlist, device->ccw_queue.next); 2493 2494 /* let the bh start the request to keep them in order */ 2495 dasd_schedule_device_bh(device); 2496 2497 spin_unlock_irq(get_ccwdev_lock(device->cdev)); 2498 2499 wait_event(generic_waitq, _wait_for_wakeup(cqr)); 2500 2501 if (cqr->status == DASD_CQR_DONE) 2502 rc = 0; 2503 else if (cqr->intrc) 2504 rc = cqr->intrc; 2505 else 2506 rc = -EIO; 2507 2508 /* kick tasklets */ 2509 dasd_schedule_device_bh(device); 2510 if (device->block) 2511 dasd_schedule_block_bh(device->block); 2512 2513 return rc; 2514 } 2515 EXPORT_SYMBOL(dasd_sleep_on_immediatly); 2516 2517 /* 2518 * Cancels a request that was started with dasd_sleep_on_req. 2519 * This is useful to timeout requests. The request will be 2520 * terminated if it is currently in i/o. 2521 * Returns 0 if request termination was successful 2522 * negative error code if termination failed 2523 * Cancellation of a request is an asynchronous operation! The calling 2524 * function has to wait until the request is properly returned via callback. 2525 */ 2526 int dasd_cancel_req(struct dasd_ccw_req *cqr) 2527 { 2528 struct dasd_device *device = cqr->startdev; 2529 unsigned long flags; 2530 int rc; 2531 2532 rc = 0; 2533 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 2534 switch (cqr->status) { 2535 case DASD_CQR_QUEUED: 2536 /* request was not started - just set to cleared */ 2537 cqr->status = DASD_CQR_CLEARED; 2538 if (cqr->callback_data == DASD_SLEEPON_START_TAG) 2539 cqr->callback_data = DASD_SLEEPON_END_TAG; 2540 break; 2541 case DASD_CQR_IN_IO: 2542 /* request in IO - terminate IO and release again */ 2543 rc = device->discipline->term_IO(cqr); 2544 if (rc) { 2545 dev_err(&device->cdev->dev, 2546 "Cancelling request %p failed with rc=%d\n", 2547 cqr, rc); 2548 } else { 2549 cqr->stopclk = get_tod_clock(); 2550 } 2551 break; 2552 default: /* already finished or clear pending - do nothing */ 2553 break; 2554 } 2555 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 2556 dasd_schedule_device_bh(device); 2557 return rc; 2558 } 2559 EXPORT_SYMBOL(dasd_cancel_req); 2560 2561 /* 2562 * SECTION: Operations of the dasd_block layer. 2563 */ 2564 2565 /* 2566 * Timeout function for dasd_block. This is used when the block layer 2567 * is waiting for something that may not come reliably, (e.g. a state 2568 * change interrupt) 2569 */ 2570 static void dasd_block_timeout(unsigned long ptr) 2571 { 2572 unsigned long flags; 2573 struct dasd_block *block; 2574 2575 block = (struct dasd_block *) ptr; 2576 spin_lock_irqsave(get_ccwdev_lock(block->base->cdev), flags); 2577 /* re-activate request queue */ 2578 dasd_device_remove_stop_bits(block->base, DASD_STOPPED_PENDING); 2579 spin_unlock_irqrestore(get_ccwdev_lock(block->base->cdev), flags); 2580 dasd_schedule_block_bh(block); 2581 } 2582 2583 /* 2584 * Setup timeout for a dasd_block in jiffies. 2585 */ 2586 void dasd_block_set_timer(struct dasd_block *block, int expires) 2587 { 2588 if (expires == 0) 2589 del_timer(&block->timer); 2590 else 2591 mod_timer(&block->timer, jiffies + expires); 2592 } 2593 EXPORT_SYMBOL(dasd_block_set_timer); 2594 2595 /* 2596 * Clear timeout for a dasd_block. 2597 */ 2598 void dasd_block_clear_timer(struct dasd_block *block) 2599 { 2600 del_timer(&block->timer); 2601 } 2602 EXPORT_SYMBOL(dasd_block_clear_timer); 2603 2604 /* 2605 * Process finished error recovery ccw. 2606 */ 2607 static void __dasd_process_erp(struct dasd_device *device, 2608 struct dasd_ccw_req *cqr) 2609 { 2610 dasd_erp_fn_t erp_fn; 2611 2612 if (cqr->status == DASD_CQR_DONE) 2613 DBF_DEV_EVENT(DBF_NOTICE, device, "%s", "ERP successful"); 2614 else 2615 dev_err(&device->cdev->dev, "ERP failed for the DASD\n"); 2616 erp_fn = device->discipline->erp_postaction(cqr); 2617 erp_fn(cqr); 2618 } 2619 2620 /* 2621 * Fetch requests from the block device queue. 2622 */ 2623 static void __dasd_process_request_queue(struct dasd_block *block) 2624 { 2625 struct request_queue *queue; 2626 struct request *req; 2627 struct dasd_ccw_req *cqr; 2628 struct dasd_device *basedev; 2629 unsigned long flags; 2630 queue = block->request_queue; 2631 basedev = block->base; 2632 /* No queue ? Then there is nothing to do. */ 2633 if (queue == NULL) 2634 return; 2635 2636 /* 2637 * We requeue request from the block device queue to the ccw 2638 * queue only in two states. In state DASD_STATE_READY the 2639 * partition detection is done and we need to requeue requests 2640 * for that. State DASD_STATE_ONLINE is normal block device 2641 * operation. 2642 */ 2643 if (basedev->state < DASD_STATE_READY) { 2644 while ((req = blk_fetch_request(block->request_queue))) 2645 __blk_end_request_all(req, -EIO); 2646 return; 2647 } 2648 2649 /* 2650 * if device is stopped do not fetch new requests 2651 * except failfast is active which will let requests fail 2652 * immediately in __dasd_block_start_head() 2653 */ 2654 if (basedev->stopped && !(basedev->features & DASD_FEATURE_FAILFAST)) 2655 return; 2656 2657 /* Now we try to fetch requests from the request queue */ 2658 while ((req = blk_peek_request(queue))) { 2659 if (basedev->features & DASD_FEATURE_READONLY && 2660 rq_data_dir(req) == WRITE) { 2661 DBF_DEV_EVENT(DBF_ERR, basedev, 2662 "Rejecting write request %p", 2663 req); 2664 blk_start_request(req); 2665 __blk_end_request_all(req, -EIO); 2666 continue; 2667 } 2668 if (test_bit(DASD_FLAG_ABORTALL, &basedev->flags) && 2669 (basedev->features & DASD_FEATURE_FAILFAST || 2670 blk_noretry_request(req))) { 2671 DBF_DEV_EVENT(DBF_ERR, basedev, 2672 "Rejecting failfast request %p", 2673 req); 2674 blk_start_request(req); 2675 __blk_end_request_all(req, -ETIMEDOUT); 2676 continue; 2677 } 2678 cqr = basedev->discipline->build_cp(basedev, block, req); 2679 if (IS_ERR(cqr)) { 2680 if (PTR_ERR(cqr) == -EBUSY) 2681 break; /* normal end condition */ 2682 if (PTR_ERR(cqr) == -ENOMEM) 2683 break; /* terminate request queue loop */ 2684 if (PTR_ERR(cqr) == -EAGAIN) { 2685 /* 2686 * The current request cannot be build right 2687 * now, we have to try later. If this request 2688 * is the head-of-queue we stop the device 2689 * for 1/2 second. 2690 */ 2691 if (!list_empty(&block->ccw_queue)) 2692 break; 2693 spin_lock_irqsave( 2694 get_ccwdev_lock(basedev->cdev), flags); 2695 dasd_device_set_stop_bits(basedev, 2696 DASD_STOPPED_PENDING); 2697 spin_unlock_irqrestore( 2698 get_ccwdev_lock(basedev->cdev), flags); 2699 dasd_block_set_timer(block, HZ/2); 2700 break; 2701 } 2702 DBF_DEV_EVENT(DBF_ERR, basedev, 2703 "CCW creation failed (rc=%ld) " 2704 "on request %p", 2705 PTR_ERR(cqr), req); 2706 blk_start_request(req); 2707 __blk_end_request_all(req, -EIO); 2708 continue; 2709 } 2710 /* 2711 * Note: callback is set to dasd_return_cqr_cb in 2712 * __dasd_block_start_head to cover erp requests as well 2713 */ 2714 cqr->callback_data = (void *) req; 2715 cqr->status = DASD_CQR_FILLED; 2716 req->completion_data = cqr; 2717 blk_start_request(req); 2718 list_add_tail(&cqr->blocklist, &block->ccw_queue); 2719 INIT_LIST_HEAD(&cqr->devlist); 2720 dasd_profile_start(block, cqr, req); 2721 } 2722 } 2723 2724 static void __dasd_cleanup_cqr(struct dasd_ccw_req *cqr) 2725 { 2726 struct request *req; 2727 int status; 2728 int error = 0; 2729 2730 req = (struct request *) cqr->callback_data; 2731 dasd_profile_end(cqr->block, cqr, req); 2732 status = cqr->block->base->discipline->free_cp(cqr, req); 2733 if (status < 0) 2734 error = status; 2735 else if (status == 0) { 2736 if (cqr->intrc == -EPERM) 2737 error = -EBADE; 2738 else if (cqr->intrc == -ENOLINK || 2739 cqr->intrc == -ETIMEDOUT) 2740 error = cqr->intrc; 2741 else 2742 error = -EIO; 2743 } 2744 __blk_end_request_all(req, error); 2745 } 2746 2747 /* 2748 * Process ccw request queue. 2749 */ 2750 static void __dasd_process_block_ccw_queue(struct dasd_block *block, 2751 struct list_head *final_queue) 2752 { 2753 struct list_head *l, *n; 2754 struct dasd_ccw_req *cqr; 2755 dasd_erp_fn_t erp_fn; 2756 unsigned long flags; 2757 struct dasd_device *base = block->base; 2758 2759 restart: 2760 /* Process request with final status. */ 2761 list_for_each_safe(l, n, &block->ccw_queue) { 2762 cqr = list_entry(l, struct dasd_ccw_req, blocklist); 2763 if (cqr->status != DASD_CQR_DONE && 2764 cqr->status != DASD_CQR_FAILED && 2765 cqr->status != DASD_CQR_NEED_ERP && 2766 cqr->status != DASD_CQR_TERMINATED) 2767 continue; 2768 2769 if (cqr->status == DASD_CQR_TERMINATED) { 2770 base->discipline->handle_terminated_request(cqr); 2771 goto restart; 2772 } 2773 2774 /* Process requests that may be recovered */ 2775 if (cqr->status == DASD_CQR_NEED_ERP) { 2776 erp_fn = base->discipline->erp_action(cqr); 2777 if (IS_ERR(erp_fn(cqr))) 2778 continue; 2779 goto restart; 2780 } 2781 2782 /* log sense for fatal error */ 2783 if (cqr->status == DASD_CQR_FAILED) { 2784 dasd_log_sense(cqr, &cqr->irb); 2785 } 2786 2787 /* First of all call extended error reporting. */ 2788 if (dasd_eer_enabled(base) && 2789 cqr->status == DASD_CQR_FAILED) { 2790 dasd_eer_write(base, cqr, DASD_EER_FATALERROR); 2791 2792 /* restart request */ 2793 cqr->status = DASD_CQR_FILLED; 2794 cqr->retries = 255; 2795 spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags); 2796 dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE); 2797 spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), 2798 flags); 2799 goto restart; 2800 } 2801 2802 /* Process finished ERP request. */ 2803 if (cqr->refers) { 2804 __dasd_process_erp(base, cqr); 2805 goto restart; 2806 } 2807 2808 /* Rechain finished requests to final queue */ 2809 cqr->endclk = get_tod_clock(); 2810 list_move_tail(&cqr->blocklist, final_queue); 2811 } 2812 } 2813 2814 static void dasd_return_cqr_cb(struct dasd_ccw_req *cqr, void *data) 2815 { 2816 dasd_schedule_block_bh(cqr->block); 2817 } 2818 2819 static void __dasd_block_start_head(struct dasd_block *block) 2820 { 2821 struct dasd_ccw_req *cqr; 2822 2823 if (list_empty(&block->ccw_queue)) 2824 return; 2825 /* We allways begin with the first requests on the queue, as some 2826 * of previously started requests have to be enqueued on a 2827 * dasd_device again for error recovery. 2828 */ 2829 list_for_each_entry(cqr, &block->ccw_queue, blocklist) { 2830 if (cqr->status != DASD_CQR_FILLED) 2831 continue; 2832 if (test_bit(DASD_FLAG_LOCK_STOLEN, &block->base->flags) && 2833 !test_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags)) { 2834 cqr->status = DASD_CQR_FAILED; 2835 cqr->intrc = -EPERM; 2836 dasd_schedule_block_bh(block); 2837 continue; 2838 } 2839 /* Non-temporary stop condition will trigger fail fast */ 2840 if (block->base->stopped & ~DASD_STOPPED_PENDING && 2841 test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) && 2842 (!dasd_eer_enabled(block->base))) { 2843 cqr->status = DASD_CQR_FAILED; 2844 cqr->intrc = -ENOLINK; 2845 dasd_schedule_block_bh(block); 2846 continue; 2847 } 2848 /* Don't try to start requests if device is stopped */ 2849 if (block->base->stopped) 2850 return; 2851 2852 /* just a fail safe check, should not happen */ 2853 if (!cqr->startdev) 2854 cqr->startdev = block->base; 2855 2856 /* make sure that the requests we submit find their way back */ 2857 cqr->callback = dasd_return_cqr_cb; 2858 2859 dasd_add_request_tail(cqr); 2860 } 2861 } 2862 2863 /* 2864 * Central dasd_block layer routine. Takes requests from the generic 2865 * block layer request queue, creates ccw requests, enqueues them on 2866 * a dasd_device and processes ccw requests that have been returned. 2867 */ 2868 static void dasd_block_tasklet(struct dasd_block *block) 2869 { 2870 struct list_head final_queue; 2871 struct list_head *l, *n; 2872 struct dasd_ccw_req *cqr; 2873 2874 atomic_set(&block->tasklet_scheduled, 0); 2875 INIT_LIST_HEAD(&final_queue); 2876 spin_lock(&block->queue_lock); 2877 /* Finish off requests on ccw queue */ 2878 __dasd_process_block_ccw_queue(block, &final_queue); 2879 spin_unlock(&block->queue_lock); 2880 /* Now call the callback function of requests with final status */ 2881 spin_lock_irq(&block->request_queue_lock); 2882 list_for_each_safe(l, n, &final_queue) { 2883 cqr = list_entry(l, struct dasd_ccw_req, blocklist); 2884 list_del_init(&cqr->blocklist); 2885 __dasd_cleanup_cqr(cqr); 2886 } 2887 spin_lock(&block->queue_lock); 2888 /* Get new request from the block device request queue */ 2889 __dasd_process_request_queue(block); 2890 /* Now check if the head of the ccw queue needs to be started. */ 2891 __dasd_block_start_head(block); 2892 spin_unlock(&block->queue_lock); 2893 spin_unlock_irq(&block->request_queue_lock); 2894 if (waitqueue_active(&shutdown_waitq)) 2895 wake_up(&shutdown_waitq); 2896 dasd_put_device(block->base); 2897 } 2898 2899 static void _dasd_wake_block_flush_cb(struct dasd_ccw_req *cqr, void *data) 2900 { 2901 wake_up(&dasd_flush_wq); 2902 } 2903 2904 /* 2905 * Requeue a request back to the block request queue 2906 * only works for block requests 2907 */ 2908 static int _dasd_requeue_request(struct dasd_ccw_req *cqr) 2909 { 2910 struct dasd_block *block = cqr->block; 2911 struct request *req; 2912 unsigned long flags; 2913 2914 if (!block) 2915 return -EINVAL; 2916 spin_lock_irqsave(&block->queue_lock, flags); 2917 req = (struct request *) cqr->callback_data; 2918 blk_requeue_request(block->request_queue, req); 2919 spin_unlock_irqrestore(&block->queue_lock, flags); 2920 2921 return 0; 2922 } 2923 2924 /* 2925 * Go through all request on the dasd_block request queue, cancel them 2926 * on the respective dasd_device, and return them to the generic 2927 * block layer. 2928 */ 2929 static int dasd_flush_block_queue(struct dasd_block *block) 2930 { 2931 struct dasd_ccw_req *cqr, *n; 2932 int rc, i; 2933 struct list_head flush_queue; 2934 2935 INIT_LIST_HEAD(&flush_queue); 2936 spin_lock_bh(&block->queue_lock); 2937 rc = 0; 2938 restart: 2939 list_for_each_entry_safe(cqr, n, &block->ccw_queue, blocklist) { 2940 /* if this request currently owned by a dasd_device cancel it */ 2941 if (cqr->status >= DASD_CQR_QUEUED) 2942 rc = dasd_cancel_req(cqr); 2943 if (rc < 0) 2944 break; 2945 /* Rechain request (including erp chain) so it won't be 2946 * touched by the dasd_block_tasklet anymore. 2947 * Replace the callback so we notice when the request 2948 * is returned from the dasd_device layer. 2949 */ 2950 cqr->callback = _dasd_wake_block_flush_cb; 2951 for (i = 0; cqr != NULL; cqr = cqr->refers, i++) 2952 list_move_tail(&cqr->blocklist, &flush_queue); 2953 if (i > 1) 2954 /* moved more than one request - need to restart */ 2955 goto restart; 2956 } 2957 spin_unlock_bh(&block->queue_lock); 2958 /* Now call the callback function of flushed requests */ 2959 restart_cb: 2960 list_for_each_entry_safe(cqr, n, &flush_queue, blocklist) { 2961 wait_event(dasd_flush_wq, (cqr->status < DASD_CQR_QUEUED)); 2962 /* Process finished ERP request. */ 2963 if (cqr->refers) { 2964 spin_lock_bh(&block->queue_lock); 2965 __dasd_process_erp(block->base, cqr); 2966 spin_unlock_bh(&block->queue_lock); 2967 /* restart list_for_xx loop since dasd_process_erp 2968 * might remove multiple elements */ 2969 goto restart_cb; 2970 } 2971 /* call the callback function */ 2972 spin_lock_irq(&block->request_queue_lock); 2973 cqr->endclk = get_tod_clock(); 2974 list_del_init(&cqr->blocklist); 2975 __dasd_cleanup_cqr(cqr); 2976 spin_unlock_irq(&block->request_queue_lock); 2977 } 2978 return rc; 2979 } 2980 2981 /* 2982 * Schedules a call to dasd_tasklet over the device tasklet. 2983 */ 2984 void dasd_schedule_block_bh(struct dasd_block *block) 2985 { 2986 /* Protect against rescheduling. */ 2987 if (atomic_cmpxchg(&block->tasklet_scheduled, 0, 1) != 0) 2988 return; 2989 /* life cycle of block is bound to it's base device */ 2990 dasd_get_device(block->base); 2991 tasklet_hi_schedule(&block->tasklet); 2992 } 2993 EXPORT_SYMBOL(dasd_schedule_block_bh); 2994 2995 2996 /* 2997 * SECTION: external block device operations 2998 * (request queue handling, open, release, etc.) 2999 */ 3000 3001 /* 3002 * Dasd request queue function. Called from ll_rw_blk.c 3003 */ 3004 static void do_dasd_request(struct request_queue *queue) 3005 { 3006 struct dasd_block *block; 3007 3008 block = queue->queuedata; 3009 spin_lock(&block->queue_lock); 3010 /* Get new request from the block device request queue */ 3011 __dasd_process_request_queue(block); 3012 /* Now check if the head of the ccw queue needs to be started. */ 3013 __dasd_block_start_head(block); 3014 spin_unlock(&block->queue_lock); 3015 } 3016 3017 /* 3018 * Block timeout callback, called from the block layer 3019 * 3020 * request_queue lock is held on entry. 3021 * 3022 * Return values: 3023 * BLK_EH_RESET_TIMER if the request should be left running 3024 * BLK_EH_NOT_HANDLED if the request is handled or terminated 3025 * by the driver. 3026 */ 3027 enum blk_eh_timer_return dasd_times_out(struct request *req) 3028 { 3029 struct dasd_ccw_req *cqr = req->completion_data; 3030 struct dasd_block *block = req->q->queuedata; 3031 struct dasd_device *device; 3032 int rc = 0; 3033 3034 if (!cqr) 3035 return BLK_EH_NOT_HANDLED; 3036 3037 device = cqr->startdev ? cqr->startdev : block->base; 3038 if (!device->blk_timeout) 3039 return BLK_EH_RESET_TIMER; 3040 DBF_DEV_EVENT(DBF_WARNING, device, 3041 " dasd_times_out cqr %p status %x", 3042 cqr, cqr->status); 3043 3044 spin_lock(&block->queue_lock); 3045 spin_lock(get_ccwdev_lock(device->cdev)); 3046 cqr->retries = -1; 3047 cqr->intrc = -ETIMEDOUT; 3048 if (cqr->status >= DASD_CQR_QUEUED) { 3049 spin_unlock(get_ccwdev_lock(device->cdev)); 3050 rc = dasd_cancel_req(cqr); 3051 } else if (cqr->status == DASD_CQR_FILLED || 3052 cqr->status == DASD_CQR_NEED_ERP) { 3053 cqr->status = DASD_CQR_TERMINATED; 3054 spin_unlock(get_ccwdev_lock(device->cdev)); 3055 } else if (cqr->status == DASD_CQR_IN_ERP) { 3056 struct dasd_ccw_req *searchcqr, *nextcqr, *tmpcqr; 3057 3058 list_for_each_entry_safe(searchcqr, nextcqr, 3059 &block->ccw_queue, blocklist) { 3060 tmpcqr = searchcqr; 3061 while (tmpcqr->refers) 3062 tmpcqr = tmpcqr->refers; 3063 if (tmpcqr != cqr) 3064 continue; 3065 /* searchcqr is an ERP request for cqr */ 3066 searchcqr->retries = -1; 3067 searchcqr->intrc = -ETIMEDOUT; 3068 if (searchcqr->status >= DASD_CQR_QUEUED) { 3069 spin_unlock(get_ccwdev_lock(device->cdev)); 3070 rc = dasd_cancel_req(searchcqr); 3071 spin_lock(get_ccwdev_lock(device->cdev)); 3072 } else if ((searchcqr->status == DASD_CQR_FILLED) || 3073 (searchcqr->status == DASD_CQR_NEED_ERP)) { 3074 searchcqr->status = DASD_CQR_TERMINATED; 3075 rc = 0; 3076 } else if (searchcqr->status == DASD_CQR_IN_ERP) { 3077 /* 3078 * Shouldn't happen; most recent ERP 3079 * request is at the front of queue 3080 */ 3081 continue; 3082 } 3083 break; 3084 } 3085 spin_unlock(get_ccwdev_lock(device->cdev)); 3086 } 3087 dasd_schedule_block_bh(block); 3088 spin_unlock(&block->queue_lock); 3089 3090 return rc ? BLK_EH_RESET_TIMER : BLK_EH_NOT_HANDLED; 3091 } 3092 3093 /* 3094 * Allocate and initialize request queue and default I/O scheduler. 3095 */ 3096 static int dasd_alloc_queue(struct dasd_block *block) 3097 { 3098 block->request_queue = blk_init_queue(do_dasd_request, 3099 &block->request_queue_lock); 3100 if (block->request_queue == NULL) 3101 return -ENOMEM; 3102 3103 block->request_queue->queuedata = block; 3104 3105 return 0; 3106 } 3107 3108 /* 3109 * Allocate and initialize request queue. 3110 */ 3111 static void dasd_setup_queue(struct dasd_block *block) 3112 { 3113 int max; 3114 3115 if (block->base->features & DASD_FEATURE_USERAW) { 3116 /* 3117 * the max_blocks value for raw_track access is 256 3118 * it is higher than the native ECKD value because we 3119 * only need one ccw per track 3120 * so the max_hw_sectors are 3121 * 2048 x 512B = 1024kB = 16 tracks 3122 */ 3123 max = 2048; 3124 } else { 3125 max = block->base->discipline->max_blocks << block->s2b_shift; 3126 } 3127 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, block->request_queue); 3128 block->request_queue->limits.max_dev_sectors = max; 3129 blk_queue_logical_block_size(block->request_queue, 3130 block->bp_block); 3131 blk_queue_max_hw_sectors(block->request_queue, max); 3132 blk_queue_max_segments(block->request_queue, -1L); 3133 /* with page sized segments we can translate each segement into 3134 * one idaw/tidaw 3135 */ 3136 blk_queue_max_segment_size(block->request_queue, PAGE_SIZE); 3137 blk_queue_segment_boundary(block->request_queue, PAGE_SIZE - 1); 3138 } 3139 3140 /* 3141 * Deactivate and free request queue. 3142 */ 3143 static void dasd_free_queue(struct dasd_block *block) 3144 { 3145 if (block->request_queue) { 3146 blk_cleanup_queue(block->request_queue); 3147 block->request_queue = NULL; 3148 } 3149 } 3150 3151 /* 3152 * Flush request on the request queue. 3153 */ 3154 static void dasd_flush_request_queue(struct dasd_block *block) 3155 { 3156 struct request *req; 3157 3158 if (!block->request_queue) 3159 return; 3160 3161 spin_lock_irq(&block->request_queue_lock); 3162 while ((req = blk_fetch_request(block->request_queue))) 3163 __blk_end_request_all(req, -EIO); 3164 spin_unlock_irq(&block->request_queue_lock); 3165 } 3166 3167 static int dasd_open(struct block_device *bdev, fmode_t mode) 3168 { 3169 struct dasd_device *base; 3170 int rc; 3171 3172 base = dasd_device_from_gendisk(bdev->bd_disk); 3173 if (!base) 3174 return -ENODEV; 3175 3176 atomic_inc(&base->block->open_count); 3177 if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) { 3178 rc = -ENODEV; 3179 goto unlock; 3180 } 3181 3182 if (!try_module_get(base->discipline->owner)) { 3183 rc = -EINVAL; 3184 goto unlock; 3185 } 3186 3187 if (dasd_probeonly) { 3188 dev_info(&base->cdev->dev, 3189 "Accessing the DASD failed because it is in " 3190 "probeonly mode\n"); 3191 rc = -EPERM; 3192 goto out; 3193 } 3194 3195 if (base->state <= DASD_STATE_BASIC) { 3196 DBF_DEV_EVENT(DBF_ERR, base, " %s", 3197 " Cannot open unrecognized device"); 3198 rc = -ENODEV; 3199 goto out; 3200 } 3201 3202 if ((mode & FMODE_WRITE) && 3203 (test_bit(DASD_FLAG_DEVICE_RO, &base->flags) || 3204 (base->features & DASD_FEATURE_READONLY))) { 3205 rc = -EROFS; 3206 goto out; 3207 } 3208 3209 dasd_put_device(base); 3210 return 0; 3211 3212 out: 3213 module_put(base->discipline->owner); 3214 unlock: 3215 atomic_dec(&base->block->open_count); 3216 dasd_put_device(base); 3217 return rc; 3218 } 3219 3220 static void dasd_release(struct gendisk *disk, fmode_t mode) 3221 { 3222 struct dasd_device *base = dasd_device_from_gendisk(disk); 3223 if (base) { 3224 atomic_dec(&base->block->open_count); 3225 module_put(base->discipline->owner); 3226 dasd_put_device(base); 3227 } 3228 } 3229 3230 /* 3231 * Return disk geometry. 3232 */ 3233 static int dasd_getgeo(struct block_device *bdev, struct hd_geometry *geo) 3234 { 3235 struct dasd_device *base; 3236 3237 base = dasd_device_from_gendisk(bdev->bd_disk); 3238 if (!base) 3239 return -ENODEV; 3240 3241 if (!base->discipline || 3242 !base->discipline->fill_geometry) { 3243 dasd_put_device(base); 3244 return -EINVAL; 3245 } 3246 base->discipline->fill_geometry(base->block, geo); 3247 geo->start = get_start_sect(bdev) >> base->block->s2b_shift; 3248 dasd_put_device(base); 3249 return 0; 3250 } 3251 3252 const struct block_device_operations 3253 dasd_device_operations = { 3254 .owner = THIS_MODULE, 3255 .open = dasd_open, 3256 .release = dasd_release, 3257 .ioctl = dasd_ioctl, 3258 .compat_ioctl = dasd_ioctl, 3259 .getgeo = dasd_getgeo, 3260 }; 3261 3262 /******************************************************************************* 3263 * end of block device operations 3264 */ 3265 3266 static void 3267 dasd_exit(void) 3268 { 3269 #ifdef CONFIG_PROC_FS 3270 dasd_proc_exit(); 3271 #endif 3272 dasd_eer_exit(); 3273 if (dasd_page_cache != NULL) { 3274 kmem_cache_destroy(dasd_page_cache); 3275 dasd_page_cache = NULL; 3276 } 3277 dasd_gendisk_exit(); 3278 dasd_devmap_exit(); 3279 if (dasd_debug_area != NULL) { 3280 debug_unregister(dasd_debug_area); 3281 dasd_debug_area = NULL; 3282 } 3283 dasd_statistics_removeroot(); 3284 } 3285 3286 /* 3287 * SECTION: common functions for ccw_driver use 3288 */ 3289 3290 /* 3291 * Is the device read-only? 3292 * Note that this function does not report the setting of the 3293 * readonly device attribute, but how it is configured in z/VM. 3294 */ 3295 int dasd_device_is_ro(struct dasd_device *device) 3296 { 3297 struct ccw_dev_id dev_id; 3298 struct diag210 diag_data; 3299 int rc; 3300 3301 if (!MACHINE_IS_VM) 3302 return 0; 3303 ccw_device_get_id(device->cdev, &dev_id); 3304 memset(&diag_data, 0, sizeof(diag_data)); 3305 diag_data.vrdcdvno = dev_id.devno; 3306 diag_data.vrdclen = sizeof(diag_data); 3307 rc = diag210(&diag_data); 3308 if (rc == 0 || rc == 2) { 3309 return diag_data.vrdcvfla & 0x80; 3310 } else { 3311 DBF_EVENT(DBF_WARNING, "diag210 failed for dev=%04x with rc=%d", 3312 dev_id.devno, rc); 3313 return 0; 3314 } 3315 } 3316 EXPORT_SYMBOL_GPL(dasd_device_is_ro); 3317 3318 static void dasd_generic_auto_online(void *data, async_cookie_t cookie) 3319 { 3320 struct ccw_device *cdev = data; 3321 int ret; 3322 3323 ret = ccw_device_set_online(cdev); 3324 if (ret) 3325 pr_warn("%s: Setting the DASD online failed with rc=%d\n", 3326 dev_name(&cdev->dev), ret); 3327 } 3328 3329 /* 3330 * Initial attempt at a probe function. this can be simplified once 3331 * the other detection code is gone. 3332 */ 3333 int dasd_generic_probe(struct ccw_device *cdev, 3334 struct dasd_discipline *discipline) 3335 { 3336 int ret; 3337 3338 ret = dasd_add_sysfs_files(cdev); 3339 if (ret) { 3340 DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s", 3341 "dasd_generic_probe: could not add " 3342 "sysfs entries"); 3343 return ret; 3344 } 3345 cdev->handler = &dasd_int_handler; 3346 3347 /* 3348 * Automatically online either all dasd devices (dasd_autodetect) 3349 * or all devices specified with dasd= parameters during 3350 * initial probe. 3351 */ 3352 if ((dasd_get_feature(cdev, DASD_FEATURE_INITIAL_ONLINE) > 0 ) || 3353 (dasd_autodetect && dasd_busid_known(dev_name(&cdev->dev)) != 0)) 3354 async_schedule(dasd_generic_auto_online, cdev); 3355 return 0; 3356 } 3357 EXPORT_SYMBOL_GPL(dasd_generic_probe); 3358 3359 /* 3360 * This will one day be called from a global not_oper handler. 3361 * It is also used by driver_unregister during module unload. 3362 */ 3363 void dasd_generic_remove(struct ccw_device *cdev) 3364 { 3365 struct dasd_device *device; 3366 struct dasd_block *block; 3367 3368 cdev->handler = NULL; 3369 3370 device = dasd_device_from_cdev(cdev); 3371 if (IS_ERR(device)) { 3372 dasd_remove_sysfs_files(cdev); 3373 return; 3374 } 3375 if (test_and_set_bit(DASD_FLAG_OFFLINE, &device->flags) && 3376 !test_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING, &device->flags)) { 3377 /* Already doing offline processing */ 3378 dasd_put_device(device); 3379 dasd_remove_sysfs_files(cdev); 3380 return; 3381 } 3382 /* 3383 * This device is removed unconditionally. Set offline 3384 * flag to prevent dasd_open from opening it while it is 3385 * no quite down yet. 3386 */ 3387 dasd_set_target_state(device, DASD_STATE_NEW); 3388 /* dasd_delete_device destroys the device reference. */ 3389 block = device->block; 3390 dasd_delete_device(device); 3391 /* 3392 * life cycle of block is bound to device, so delete it after 3393 * device was safely removed 3394 */ 3395 if (block) 3396 dasd_free_block(block); 3397 3398 dasd_remove_sysfs_files(cdev); 3399 } 3400 EXPORT_SYMBOL_GPL(dasd_generic_remove); 3401 3402 /* 3403 * Activate a device. This is called from dasd_{eckd,fba}_probe() when either 3404 * the device is detected for the first time and is supposed to be used 3405 * or the user has started activation through sysfs. 3406 */ 3407 int dasd_generic_set_online(struct ccw_device *cdev, 3408 struct dasd_discipline *base_discipline) 3409 { 3410 struct dasd_discipline *discipline; 3411 struct dasd_device *device; 3412 int rc; 3413 3414 /* first online clears initial online feature flag */ 3415 dasd_set_feature(cdev, DASD_FEATURE_INITIAL_ONLINE, 0); 3416 device = dasd_create_device(cdev); 3417 if (IS_ERR(device)) 3418 return PTR_ERR(device); 3419 3420 discipline = base_discipline; 3421 if (device->features & DASD_FEATURE_USEDIAG) { 3422 if (!dasd_diag_discipline_pointer) { 3423 /* Try to load the required module. */ 3424 rc = request_module(DASD_DIAG_MOD); 3425 if (rc) { 3426 pr_warn("%s Setting the DASD online failed " 3427 "because the required module %s " 3428 "could not be loaded (rc=%d)\n", 3429 dev_name(&cdev->dev), DASD_DIAG_MOD, 3430 rc); 3431 dasd_delete_device(device); 3432 return -ENODEV; 3433 } 3434 } 3435 /* Module init could have failed, so check again here after 3436 * request_module(). */ 3437 if (!dasd_diag_discipline_pointer) { 3438 pr_warn("%s Setting the DASD online failed because of missing DIAG discipline\n", 3439 dev_name(&cdev->dev)); 3440 dasd_delete_device(device); 3441 return -ENODEV; 3442 } 3443 discipline = dasd_diag_discipline_pointer; 3444 } 3445 if (!try_module_get(base_discipline->owner)) { 3446 dasd_delete_device(device); 3447 return -EINVAL; 3448 } 3449 if (!try_module_get(discipline->owner)) { 3450 module_put(base_discipline->owner); 3451 dasd_delete_device(device); 3452 return -EINVAL; 3453 } 3454 device->base_discipline = base_discipline; 3455 device->discipline = discipline; 3456 3457 /* check_device will allocate block device if necessary */ 3458 rc = discipline->check_device(device); 3459 if (rc) { 3460 pr_warn("%s Setting the DASD online with discipline %s failed with rc=%i\n", 3461 dev_name(&cdev->dev), discipline->name, rc); 3462 module_put(discipline->owner); 3463 module_put(base_discipline->owner); 3464 dasd_delete_device(device); 3465 return rc; 3466 } 3467 3468 dasd_set_target_state(device, DASD_STATE_ONLINE); 3469 if (device->state <= DASD_STATE_KNOWN) { 3470 pr_warn("%s Setting the DASD online failed because of a missing discipline\n", 3471 dev_name(&cdev->dev)); 3472 rc = -ENODEV; 3473 dasd_set_target_state(device, DASD_STATE_NEW); 3474 if (device->block) 3475 dasd_free_block(device->block); 3476 dasd_delete_device(device); 3477 } else 3478 pr_debug("dasd_generic device %s found\n", 3479 dev_name(&cdev->dev)); 3480 3481 wait_event(dasd_init_waitq, _wait_for_device(device)); 3482 3483 dasd_put_device(device); 3484 return rc; 3485 } 3486 EXPORT_SYMBOL_GPL(dasd_generic_set_online); 3487 3488 int dasd_generic_set_offline(struct ccw_device *cdev) 3489 { 3490 struct dasd_device *device; 3491 struct dasd_block *block; 3492 int max_count, open_count, rc; 3493 3494 rc = 0; 3495 device = dasd_device_from_cdev(cdev); 3496 if (IS_ERR(device)) 3497 return PTR_ERR(device); 3498 3499 /* 3500 * We must make sure that this device is currently not in use. 3501 * The open_count is increased for every opener, that includes 3502 * the blkdev_get in dasd_scan_partitions. We are only interested 3503 * in the other openers. 3504 */ 3505 if (device->block) { 3506 max_count = device->block->bdev ? 0 : -1; 3507 open_count = atomic_read(&device->block->open_count); 3508 if (open_count > max_count) { 3509 if (open_count > 0) 3510 pr_warn("%s: The DASD cannot be set offline with open count %i\n", 3511 dev_name(&cdev->dev), open_count); 3512 else 3513 pr_warn("%s: The DASD cannot be set offline while it is in use\n", 3514 dev_name(&cdev->dev)); 3515 clear_bit(DASD_FLAG_OFFLINE, &device->flags); 3516 dasd_put_device(device); 3517 return -EBUSY; 3518 } 3519 } 3520 3521 if (test_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING, &device->flags)) { 3522 /* 3523 * safe offline already running 3524 * could only be called by normal offline so safe_offline flag 3525 * needs to be removed to run normal offline and kill all I/O 3526 */ 3527 if (test_and_set_bit(DASD_FLAG_OFFLINE, &device->flags)) { 3528 /* Already doing normal offline processing */ 3529 dasd_put_device(device); 3530 return -EBUSY; 3531 } else 3532 clear_bit(DASD_FLAG_SAFE_OFFLINE, &device->flags); 3533 3534 } else 3535 if (test_bit(DASD_FLAG_OFFLINE, &device->flags)) { 3536 /* Already doing offline processing */ 3537 dasd_put_device(device); 3538 return -EBUSY; 3539 } 3540 3541 /* 3542 * if safe_offline called set safe_offline_running flag and 3543 * clear safe_offline so that a call to normal offline 3544 * can overrun safe_offline processing 3545 */ 3546 if (test_and_clear_bit(DASD_FLAG_SAFE_OFFLINE, &device->flags) && 3547 !test_and_set_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING, &device->flags)) { 3548 /* 3549 * If we want to set the device safe offline all IO operations 3550 * should be finished before continuing the offline process 3551 * so sync bdev first and then wait for our queues to become 3552 * empty 3553 */ 3554 /* sync blockdev and partitions */ 3555 rc = fsync_bdev(device->block->bdev); 3556 if (rc != 0) 3557 goto interrupted; 3558 3559 /* schedule device tasklet and wait for completion */ 3560 dasd_schedule_device_bh(device); 3561 rc = wait_event_interruptible(shutdown_waitq, 3562 _wait_for_empty_queues(device)); 3563 if (rc != 0) 3564 goto interrupted; 3565 } 3566 3567 set_bit(DASD_FLAG_OFFLINE, &device->flags); 3568 dasd_set_target_state(device, DASD_STATE_NEW); 3569 /* dasd_delete_device destroys the device reference. */ 3570 block = device->block; 3571 dasd_delete_device(device); 3572 /* 3573 * life cycle of block is bound to device, so delete it after 3574 * device was safely removed 3575 */ 3576 if (block) 3577 dasd_free_block(block); 3578 return 0; 3579 3580 interrupted: 3581 /* interrupted by signal */ 3582 clear_bit(DASD_FLAG_SAFE_OFFLINE, &device->flags); 3583 clear_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING, &device->flags); 3584 clear_bit(DASD_FLAG_OFFLINE, &device->flags); 3585 dasd_put_device(device); 3586 return rc; 3587 } 3588 EXPORT_SYMBOL_GPL(dasd_generic_set_offline); 3589 3590 int dasd_generic_last_path_gone(struct dasd_device *device) 3591 { 3592 struct dasd_ccw_req *cqr; 3593 3594 dev_warn(&device->cdev->dev, "No operational channel path is left " 3595 "for the device\n"); 3596 DBF_DEV_EVENT(DBF_WARNING, device, "%s", "last path gone"); 3597 /* First of all call extended error reporting. */ 3598 dasd_eer_write(device, NULL, DASD_EER_NOPATH); 3599 3600 if (device->state < DASD_STATE_BASIC) 3601 return 0; 3602 /* Device is active. We want to keep it. */ 3603 list_for_each_entry(cqr, &device->ccw_queue, devlist) 3604 if ((cqr->status == DASD_CQR_IN_IO) || 3605 (cqr->status == DASD_CQR_CLEAR_PENDING)) { 3606 cqr->status = DASD_CQR_QUEUED; 3607 cqr->retries++; 3608 } 3609 dasd_device_set_stop_bits(device, DASD_STOPPED_DC_WAIT); 3610 dasd_device_clear_timer(device); 3611 dasd_schedule_device_bh(device); 3612 return 1; 3613 } 3614 EXPORT_SYMBOL_GPL(dasd_generic_last_path_gone); 3615 3616 int dasd_generic_path_operational(struct dasd_device *device) 3617 { 3618 dev_info(&device->cdev->dev, "A channel path to the device has become " 3619 "operational\n"); 3620 DBF_DEV_EVENT(DBF_WARNING, device, "%s", "path operational"); 3621 dasd_device_remove_stop_bits(device, DASD_STOPPED_DC_WAIT); 3622 if (device->stopped & DASD_UNRESUMED_PM) { 3623 dasd_device_remove_stop_bits(device, DASD_UNRESUMED_PM); 3624 dasd_restore_device(device); 3625 return 1; 3626 } 3627 dasd_schedule_device_bh(device); 3628 if (device->block) 3629 dasd_schedule_block_bh(device->block); 3630 3631 if (!device->stopped) 3632 wake_up(&generic_waitq); 3633 3634 return 1; 3635 } 3636 EXPORT_SYMBOL_GPL(dasd_generic_path_operational); 3637 3638 int dasd_generic_notify(struct ccw_device *cdev, int event) 3639 { 3640 struct dasd_device *device; 3641 int ret; 3642 3643 device = dasd_device_from_cdev_locked(cdev); 3644 if (IS_ERR(device)) 3645 return 0; 3646 ret = 0; 3647 switch (event) { 3648 case CIO_GONE: 3649 case CIO_BOXED: 3650 case CIO_NO_PATH: 3651 device->path_data.opm = 0; 3652 device->path_data.ppm = 0; 3653 device->path_data.npm = 0; 3654 ret = dasd_generic_last_path_gone(device); 3655 break; 3656 case CIO_OPER: 3657 ret = 1; 3658 if (device->path_data.opm) 3659 ret = dasd_generic_path_operational(device); 3660 break; 3661 } 3662 dasd_put_device(device); 3663 return ret; 3664 } 3665 EXPORT_SYMBOL_GPL(dasd_generic_notify); 3666 3667 void dasd_generic_path_event(struct ccw_device *cdev, int *path_event) 3668 { 3669 int chp; 3670 __u8 oldopm, eventlpm; 3671 struct dasd_device *device; 3672 3673 device = dasd_device_from_cdev_locked(cdev); 3674 if (IS_ERR(device)) 3675 return; 3676 for (chp = 0; chp < 8; chp++) { 3677 eventlpm = 0x80 >> chp; 3678 if (path_event[chp] & PE_PATH_GONE) { 3679 oldopm = device->path_data.opm; 3680 device->path_data.opm &= ~eventlpm; 3681 device->path_data.ppm &= ~eventlpm; 3682 device->path_data.npm &= ~eventlpm; 3683 if (oldopm && !device->path_data.opm) { 3684 dev_warn(&device->cdev->dev, 3685 "No verified channel paths remain " 3686 "for the device\n"); 3687 DBF_DEV_EVENT(DBF_WARNING, device, 3688 "%s", "last verified path gone"); 3689 dasd_eer_write(device, NULL, DASD_EER_NOPATH); 3690 dasd_device_set_stop_bits(device, 3691 DASD_STOPPED_DC_WAIT); 3692 } 3693 } 3694 if (path_event[chp] & PE_PATH_AVAILABLE) { 3695 device->path_data.opm &= ~eventlpm; 3696 device->path_data.ppm &= ~eventlpm; 3697 device->path_data.npm &= ~eventlpm; 3698 device->path_data.tbvpm |= eventlpm; 3699 dasd_schedule_device_bh(device); 3700 } 3701 if (path_event[chp] & PE_PATHGROUP_ESTABLISHED) { 3702 if (!(device->path_data.opm & eventlpm) && 3703 !(device->path_data.tbvpm & eventlpm)) { 3704 /* 3705 * we can not establish a pathgroup on an 3706 * unavailable path, so trigger a path 3707 * verification first 3708 */ 3709 device->path_data.tbvpm |= eventlpm; 3710 dasd_schedule_device_bh(device); 3711 } 3712 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 3713 "Pathgroup re-established\n"); 3714 if (device->discipline->kick_validate) 3715 device->discipline->kick_validate(device); 3716 } 3717 } 3718 dasd_put_device(device); 3719 } 3720 EXPORT_SYMBOL_GPL(dasd_generic_path_event); 3721 3722 int dasd_generic_verify_path(struct dasd_device *device, __u8 lpm) 3723 { 3724 if (!device->path_data.opm && lpm) { 3725 device->path_data.opm = lpm; 3726 dasd_generic_path_operational(device); 3727 } else 3728 device->path_data.opm |= lpm; 3729 return 0; 3730 } 3731 EXPORT_SYMBOL_GPL(dasd_generic_verify_path); 3732 3733 3734 int dasd_generic_pm_freeze(struct ccw_device *cdev) 3735 { 3736 struct dasd_device *device = dasd_device_from_cdev(cdev); 3737 struct list_head freeze_queue; 3738 struct dasd_ccw_req *cqr, *n; 3739 struct dasd_ccw_req *refers; 3740 int rc; 3741 3742 if (IS_ERR(device)) 3743 return PTR_ERR(device); 3744 3745 /* mark device as suspended */ 3746 set_bit(DASD_FLAG_SUSPENDED, &device->flags); 3747 3748 if (device->discipline->freeze) 3749 rc = device->discipline->freeze(device); 3750 3751 /* disallow new I/O */ 3752 dasd_device_set_stop_bits(device, DASD_STOPPED_PM); 3753 3754 /* clear active requests and requeue them to block layer if possible */ 3755 INIT_LIST_HEAD(&freeze_queue); 3756 spin_lock_irq(get_ccwdev_lock(cdev)); 3757 rc = 0; 3758 list_for_each_entry_safe(cqr, n, &device->ccw_queue, devlist) { 3759 /* Check status and move request to flush_queue */ 3760 if (cqr->status == DASD_CQR_IN_IO) { 3761 rc = device->discipline->term_IO(cqr); 3762 if (rc) { 3763 /* unable to terminate requeust */ 3764 dev_err(&device->cdev->dev, 3765 "Unable to terminate request %p " 3766 "on suspend\n", cqr); 3767 spin_unlock_irq(get_ccwdev_lock(cdev)); 3768 dasd_put_device(device); 3769 return rc; 3770 } 3771 } 3772 list_move_tail(&cqr->devlist, &freeze_queue); 3773 } 3774 spin_unlock_irq(get_ccwdev_lock(cdev)); 3775 3776 list_for_each_entry_safe(cqr, n, &freeze_queue, devlist) { 3777 wait_event(dasd_flush_wq, 3778 (cqr->status != DASD_CQR_CLEAR_PENDING)); 3779 if (cqr->status == DASD_CQR_CLEARED) 3780 cqr->status = DASD_CQR_QUEUED; 3781 3782 /* requeue requests to blocklayer will only work for 3783 block device requests */ 3784 if (_dasd_requeue_request(cqr)) 3785 continue; 3786 3787 /* remove requests from device and block queue */ 3788 list_del_init(&cqr->devlist); 3789 while (cqr->refers != NULL) { 3790 refers = cqr->refers; 3791 /* remove the request from the block queue */ 3792 list_del(&cqr->blocklist); 3793 /* free the finished erp request */ 3794 dasd_free_erp_request(cqr, cqr->memdev); 3795 cqr = refers; 3796 } 3797 if (cqr->block) 3798 list_del_init(&cqr->blocklist); 3799 cqr->block->base->discipline->free_cp( 3800 cqr, (struct request *) cqr->callback_data); 3801 } 3802 3803 /* 3804 * if requests remain then they are internal request 3805 * and go back to the device queue 3806 */ 3807 if (!list_empty(&freeze_queue)) { 3808 /* move freeze_queue to start of the ccw_queue */ 3809 spin_lock_irq(get_ccwdev_lock(cdev)); 3810 list_splice_tail(&freeze_queue, &device->ccw_queue); 3811 spin_unlock_irq(get_ccwdev_lock(cdev)); 3812 } 3813 dasd_put_device(device); 3814 return rc; 3815 } 3816 EXPORT_SYMBOL_GPL(dasd_generic_pm_freeze); 3817 3818 int dasd_generic_restore_device(struct ccw_device *cdev) 3819 { 3820 struct dasd_device *device = dasd_device_from_cdev(cdev); 3821 int rc = 0; 3822 3823 if (IS_ERR(device)) 3824 return PTR_ERR(device); 3825 3826 /* allow new IO again */ 3827 dasd_device_remove_stop_bits(device, 3828 (DASD_STOPPED_PM | DASD_UNRESUMED_PM)); 3829 3830 dasd_schedule_device_bh(device); 3831 3832 /* 3833 * call discipline restore function 3834 * if device is stopped do nothing e.g. for disconnected devices 3835 */ 3836 if (device->discipline->restore && !(device->stopped)) 3837 rc = device->discipline->restore(device); 3838 if (rc || device->stopped) 3839 /* 3840 * if the resume failed for the DASD we put it in 3841 * an UNRESUMED stop state 3842 */ 3843 device->stopped |= DASD_UNRESUMED_PM; 3844 3845 if (device->block) 3846 dasd_schedule_block_bh(device->block); 3847 3848 clear_bit(DASD_FLAG_SUSPENDED, &device->flags); 3849 dasd_put_device(device); 3850 return 0; 3851 } 3852 EXPORT_SYMBOL_GPL(dasd_generic_restore_device); 3853 3854 static struct dasd_ccw_req *dasd_generic_build_rdc(struct dasd_device *device, 3855 void *rdc_buffer, 3856 int rdc_buffer_size, 3857 int magic) 3858 { 3859 struct dasd_ccw_req *cqr; 3860 struct ccw1 *ccw; 3861 unsigned long *idaw; 3862 3863 cqr = dasd_smalloc_request(magic, 1 /* RDC */, rdc_buffer_size, device); 3864 3865 if (IS_ERR(cqr)) { 3866 /* internal error 13 - Allocating the RDC request failed*/ 3867 dev_err(&device->cdev->dev, 3868 "An error occurred in the DASD device driver, " 3869 "reason=%s\n", "13"); 3870 return cqr; 3871 } 3872 3873 ccw = cqr->cpaddr; 3874 ccw->cmd_code = CCW_CMD_RDC; 3875 if (idal_is_needed(rdc_buffer, rdc_buffer_size)) { 3876 idaw = (unsigned long *) (cqr->data); 3877 ccw->cda = (__u32)(addr_t) idaw; 3878 ccw->flags = CCW_FLAG_IDA; 3879 idaw = idal_create_words(idaw, rdc_buffer, rdc_buffer_size); 3880 } else { 3881 ccw->cda = (__u32)(addr_t) rdc_buffer; 3882 ccw->flags = 0; 3883 } 3884 3885 ccw->count = rdc_buffer_size; 3886 cqr->startdev = device; 3887 cqr->memdev = device; 3888 cqr->expires = 10*HZ; 3889 cqr->retries = 256; 3890 cqr->buildclk = get_tod_clock(); 3891 cqr->status = DASD_CQR_FILLED; 3892 return cqr; 3893 } 3894 3895 3896 int dasd_generic_read_dev_chars(struct dasd_device *device, int magic, 3897 void *rdc_buffer, int rdc_buffer_size) 3898 { 3899 int ret; 3900 struct dasd_ccw_req *cqr; 3901 3902 cqr = dasd_generic_build_rdc(device, rdc_buffer, rdc_buffer_size, 3903 magic); 3904 if (IS_ERR(cqr)) 3905 return PTR_ERR(cqr); 3906 3907 ret = dasd_sleep_on(cqr); 3908 dasd_sfree_request(cqr, cqr->memdev); 3909 return ret; 3910 } 3911 EXPORT_SYMBOL_GPL(dasd_generic_read_dev_chars); 3912 3913 /* 3914 * In command mode and transport mode we need to look for sense 3915 * data in different places. The sense data itself is allways 3916 * an array of 32 bytes, so we can unify the sense data access 3917 * for both modes. 3918 */ 3919 char *dasd_get_sense(struct irb *irb) 3920 { 3921 struct tsb *tsb = NULL; 3922 char *sense = NULL; 3923 3924 if (scsw_is_tm(&irb->scsw) && (irb->scsw.tm.fcxs == 0x01)) { 3925 if (irb->scsw.tm.tcw) 3926 tsb = tcw_get_tsb((struct tcw *)(unsigned long) 3927 irb->scsw.tm.tcw); 3928 if (tsb && tsb->length == 64 && tsb->flags) 3929 switch (tsb->flags & 0x07) { 3930 case 1: /* tsa_iostat */ 3931 sense = tsb->tsa.iostat.sense; 3932 break; 3933 case 2: /* tsa_ddpc */ 3934 sense = tsb->tsa.ddpc.sense; 3935 break; 3936 default: 3937 /* currently we don't use interrogate data */ 3938 break; 3939 } 3940 } else if (irb->esw.esw0.erw.cons) { 3941 sense = irb->ecw; 3942 } 3943 return sense; 3944 } 3945 EXPORT_SYMBOL_GPL(dasd_get_sense); 3946 3947 void dasd_generic_shutdown(struct ccw_device *cdev) 3948 { 3949 struct dasd_device *device; 3950 3951 device = dasd_device_from_cdev(cdev); 3952 if (IS_ERR(device)) 3953 return; 3954 3955 if (device->block) 3956 dasd_schedule_block_bh(device->block); 3957 3958 dasd_schedule_device_bh(device); 3959 3960 wait_event(shutdown_waitq, _wait_for_empty_queues(device)); 3961 } 3962 EXPORT_SYMBOL_GPL(dasd_generic_shutdown); 3963 3964 static int __init dasd_init(void) 3965 { 3966 int rc; 3967 3968 init_waitqueue_head(&dasd_init_waitq); 3969 init_waitqueue_head(&dasd_flush_wq); 3970 init_waitqueue_head(&generic_waitq); 3971 init_waitqueue_head(&shutdown_waitq); 3972 3973 /* register 'common' DASD debug area, used for all DBF_XXX calls */ 3974 dasd_debug_area = debug_register("dasd", 1, 1, 8 * sizeof(long)); 3975 if (dasd_debug_area == NULL) { 3976 rc = -ENOMEM; 3977 goto failed; 3978 } 3979 debug_register_view(dasd_debug_area, &debug_sprintf_view); 3980 debug_set_level(dasd_debug_area, DBF_WARNING); 3981 3982 DBF_EVENT(DBF_EMERG, "%s", "debug area created"); 3983 3984 dasd_diag_discipline_pointer = NULL; 3985 3986 dasd_statistics_createroot(); 3987 3988 rc = dasd_devmap_init(); 3989 if (rc) 3990 goto failed; 3991 rc = dasd_gendisk_init(); 3992 if (rc) 3993 goto failed; 3994 rc = dasd_parse(); 3995 if (rc) 3996 goto failed; 3997 rc = dasd_eer_init(); 3998 if (rc) 3999 goto failed; 4000 #ifdef CONFIG_PROC_FS 4001 rc = dasd_proc_init(); 4002 if (rc) 4003 goto failed; 4004 #endif 4005 4006 return 0; 4007 failed: 4008 pr_info("The DASD device driver could not be initialized\n"); 4009 dasd_exit(); 4010 return rc; 4011 } 4012 4013 module_init(dasd_init); 4014 module_exit(dasd_exit); 4015