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