kernel/drivers/s390/block/dasd.c

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