dasd.c 75.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/*
 * File...........: linux/drivers/s390/block/dasd.c
 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
 *		    Horst Hummel <Horst.Hummel@de.ibm.com>
 *		    Carsten Otte <Cotte@de.ibm.com>
 *		    Martin Schwidefsky <schwidefsky@de.ibm.com>
 * Bugreports.to..: <Linux390@de.ibm.com>
8
 * Copyright IBM Corp. 1999, 2009
L
Linus Torvalds 已提交
9 10
 */

S
Stefan Haberland 已提交
11 12 13
#define KMSG_COMPONENT "dasd"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

L
Linus Torvalds 已提交
14 15 16 17 18 19 20
#include <linux/kmod.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/ctype.h>
#include <linux/major.h>
#include <linux/slab.h>
#include <linux/buffer_head.h>
21
#include <linux/hdreg.h>
22
#include <linux/async.h>
23
#include <linux/mutex.h>
L
Linus Torvalds 已提交
24 25 26 27

#include <asm/ccwdev.h>
#include <asm/ebcdic.h>
#include <asm/idals.h>
28
#include <asm/itcw.h>
29
#include <asm/diag.h>
L
Linus Torvalds 已提交
30 31 32 33 34 35 36 37 38 39

/* This is ugly... */
#define PRINTK_HEADER "dasd:"

#include "dasd_int.h"
/*
 * SECTION: Constant definitions to be used within this file
 */
#define DASD_CHANQ_MAX_SIZE 4

40 41 42
#define DASD_SLEEPON_START_TAG	(void *) 1
#define DASD_SLEEPON_END_TAG	(void *) 2

L
Linus Torvalds 已提交
43 44 45 46 47
/*
 * SECTION: exported variables of dasd.c
 */
debug_info_t *dasd_debug_area;
struct dasd_discipline *dasd_diag_discipline_pointer;
48
void dasd_int_handler(struct ccw_device *, unsigned long, struct irb *);
L
Linus Torvalds 已提交
49 50 51 52 53 54 55 56 57 58

MODULE_AUTHOR("Holger Smolinski <Holger.Smolinski@de.ibm.com>");
MODULE_DESCRIPTION("Linux on S/390 DASD device driver,"
		   " Copyright 2000 IBM Corporation");
MODULE_SUPPORTED_DEVICE("dasd");
MODULE_LICENSE("GPL");

/*
 * SECTION: prototypes for static functions of dasd.c
 */
59 60 61 62 63 64 65
static int  dasd_alloc_queue(struct dasd_block *);
static void dasd_setup_queue(struct dasd_block *);
static void dasd_free_queue(struct dasd_block *);
static void dasd_flush_request_queue(struct dasd_block *);
static int dasd_flush_block_queue(struct dasd_block *);
static void dasd_device_tasklet(struct dasd_device *);
static void dasd_block_tasklet(struct dasd_block *);
66
static void do_kick_device(struct work_struct *);
67
static void do_restore_device(struct work_struct *);
68
static void do_reload_device(struct work_struct *);
69
static void dasd_return_cqr_cb(struct dasd_ccw_req *, void *);
70 71
static void dasd_device_timeout(unsigned long);
static void dasd_block_timeout(unsigned long);
72
static void __dasd_process_erp(struct dasd_device *, struct dasd_ccw_req *);
L
Linus Torvalds 已提交
73 74 75 76 77

/*
 * SECTION: Operations on the device structure.
 */
static wait_queue_head_t dasd_init_waitq;
78
static wait_queue_head_t dasd_flush_wq;
79
static wait_queue_head_t generic_waitq;
L
Linus Torvalds 已提交
80 81 82 83

/*
 * Allocate memory for a new device structure.
 */
84
struct dasd_device *dasd_alloc_device(void)
L
Linus Torvalds 已提交
85 86 87
{
	struct dasd_device *device;

88 89
	device = kzalloc(sizeof(struct dasd_device), GFP_ATOMIC);
	if (!device)
L
Linus Torvalds 已提交
90 91 92 93
		return ERR_PTR(-ENOMEM);

	/* Get two pages for normal block device operations. */
	device->ccw_mem = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA, 1);
94
	if (!device->ccw_mem) {
L
Linus Torvalds 已提交
95 96 97 98 99
		kfree(device);
		return ERR_PTR(-ENOMEM);
	}
	/* Get one page for error recovery. */
	device->erp_mem = (void *) get_zeroed_page(GFP_ATOMIC | GFP_DMA);
100
	if (!device->erp_mem) {
L
Linus Torvalds 已提交
101 102 103 104 105 106 107 108
		free_pages((unsigned long) device->ccw_mem, 1);
		kfree(device);
		return ERR_PTR(-ENOMEM);
	}

	dasd_init_chunklist(&device->ccw_chunks, device->ccw_mem, PAGE_SIZE*2);
	dasd_init_chunklist(&device->erp_chunks, device->erp_mem, PAGE_SIZE);
	spin_lock_init(&device->mem_lock);
109
	atomic_set(&device->tasklet_scheduled, 0);
110
	tasklet_init(&device->tasklet,
111
		     (void (*)(unsigned long)) dasd_device_tasklet,
L
Linus Torvalds 已提交
112 113 114
		     (unsigned long) device);
	INIT_LIST_HEAD(&device->ccw_queue);
	init_timer(&device->timer);
115 116
	device->timer.function = dasd_device_timeout;
	device->timer.data = (unsigned long) device;
117
	INIT_WORK(&device->kick_work, do_kick_device);
118
	INIT_WORK(&device->restore_device, do_restore_device);
119
	INIT_WORK(&device->reload_device, do_reload_device);
L
Linus Torvalds 已提交
120 121
	device->state = DASD_STATE_NEW;
	device->target = DASD_STATE_NEW;
122
	mutex_init(&device->state_mutex);
L
Linus Torvalds 已提交
123 124 125 126 127 128 129

	return device;
}

/*
 * Free memory of a device structure.
 */
130
void dasd_free_device(struct dasd_device *device)
L
Linus Torvalds 已提交
131
{
J
Jesper Juhl 已提交
132
	kfree(device->private);
L
Linus Torvalds 已提交
133 134 135 136 137
	free_page((unsigned long) device->erp_mem);
	free_pages((unsigned long) device->ccw_mem, 1);
	kfree(device);
}

138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
/*
 * Allocate memory for a new device structure.
 */
struct dasd_block *dasd_alloc_block(void)
{
	struct dasd_block *block;

	block = kzalloc(sizeof(*block), GFP_ATOMIC);
	if (!block)
		return ERR_PTR(-ENOMEM);
	/* open_count = 0 means device online but not in use */
	atomic_set(&block->open_count, -1);

	spin_lock_init(&block->request_queue_lock);
	atomic_set(&block->tasklet_scheduled, 0);
	tasklet_init(&block->tasklet,
		     (void (*)(unsigned long)) dasd_block_tasklet,
		     (unsigned long) block);
	INIT_LIST_HEAD(&block->ccw_queue);
	spin_lock_init(&block->queue_lock);
	init_timer(&block->timer);
159 160
	block->timer.function = dasd_block_timeout;
	block->timer.data = (unsigned long) block;
161 162 163 164 165 166 167 168 169 170 171 172

	return block;
}

/*
 * Free memory of a device structure.
 */
void dasd_free_block(struct dasd_block *block)
{
	kfree(block);
}

L
Linus Torvalds 已提交
173 174 175
/*
 * Make a new device known to the system.
 */
176
static int dasd_state_new_to_known(struct dasd_device *device)
L
Linus Torvalds 已提交
177 178 179 180
{
	int rc;

	/*
181
	 * As long as the device is not in state DASD_STATE_NEW we want to
L
Linus Torvalds 已提交
182 183 184 185
	 * keep the reference count > 0.
	 */
	dasd_get_device(device);

186 187 188 189 190 191
	if (device->block) {
		rc = dasd_alloc_queue(device->block);
		if (rc) {
			dasd_put_device(device);
			return rc;
		}
L
Linus Torvalds 已提交
192 193 194 195 196 197 198 199
	}
	device->state = DASD_STATE_KNOWN;
	return 0;
}

/*
 * Let the system forget about a device.
 */
200
static int dasd_state_known_to_new(struct dasd_device *device)
L
Linus Torvalds 已提交
201
{
202 203
	/* Disable extended error reporting for this device. */
	dasd_eer_disable(device);
L
Linus Torvalds 已提交
204
	/* Forget the discipline information. */
205 206 207
	if (device->discipline) {
		if (device->discipline->uncheck_device)
			device->discipline->uncheck_device(device);
208
		module_put(device->discipline->owner);
209
	}
L
Linus Torvalds 已提交
210
	device->discipline = NULL;
211 212 213
	if (device->base_discipline)
		module_put(device->base_discipline->owner);
	device->base_discipline = NULL;
L
Linus Torvalds 已提交
214 215
	device->state = DASD_STATE_NEW;

216 217
	if (device->block)
		dasd_free_queue(device->block);
L
Linus Torvalds 已提交
218 219 220

	/* Give up reference we took in dasd_state_new_to_known. */
	dasd_put_device(device);
221
	return 0;
L
Linus Torvalds 已提交
222 223 224 225 226
}

/*
 * Request the irq line for the device.
 */
227
static int dasd_state_known_to_basic(struct dasd_device *device)
L
Linus Torvalds 已提交
228 229 230 231
{
	int rc;

	/* Allocate and register gendisk structure. */
232 233 234 235 236
	if (device->block) {
		rc = dasd_gendisk_alloc(device->block);
		if (rc)
			return rc;
	}
L
Linus Torvalds 已提交
237
	/* register 'device' debug area, used for all DBF_DEV_XXX calls */
S
Stefan Haberland 已提交
238
	device->debug_area = debug_register(dev_name(&device->cdev->dev), 4, 1,
239
					    8 * sizeof(long));
L
Linus Torvalds 已提交
240
	debug_register_view(device->debug_area, &debug_sprintf_view);
H
Horst Hummel 已提交
241
	debug_set_level(device->debug_area, DBF_WARNING);
L
Linus Torvalds 已提交
242 243 244 245 246 247 248 249 250
	DBF_DEV_EVENT(DBF_EMERG, device, "%s", "debug area created");

	device->state = DASD_STATE_BASIC;
	return 0;
}

/*
 * Release the irq line for the device. Terminate any running i/o.
 */
251
static int dasd_state_basic_to_known(struct dasd_device *device)
L
Linus Torvalds 已提交
252
{
253
	int rc;
254 255 256 257 258
	if (device->block) {
		dasd_gendisk_free(device->block);
		dasd_block_clear_timer(device->block);
	}
	rc = dasd_flush_device_queue(device);
259 260
	if (rc)
		return rc;
261
	dasd_device_clear_timer(device);
262

L
Linus Torvalds 已提交
263 264 265 266 267 268
	DBF_DEV_EVENT(DBF_EMERG, device, "%p debug area deleted", device);
	if (device->debug_area != NULL) {
		debug_unregister(device->debug_area);
		device->debug_area = NULL;
	}
	device->state = DASD_STATE_KNOWN;
269
	return 0;
L
Linus Torvalds 已提交
270 271 272 273 274 275 276 277 278 279 280
}

/*
 * Do the initial analysis. The do_analysis function may return
 * -EAGAIN in which case the device keeps the state DASD_STATE_BASIC
 * until the discipline decides to continue the startup sequence
 * by calling the function dasd_change_state. The eckd disciplines
 * uses this to start a ccw that detects the format. The completion
 * interrupt for this detection ccw uses the kernel event daemon to
 * trigger the call to dasd_change_state. All this is done in the
 * discipline code, see dasd_eckd.c.
281 282 283 284
 * After the analysis ccw is done (do_analysis returned 0) the block
 * device is setup.
 * In case the analysis returns an error, the device setup is stopped
 * (a fake disk was already added to allow formatting).
L
Linus Torvalds 已提交
285
 */
286
static int dasd_state_basic_to_ready(struct dasd_device *device)
L
Linus Torvalds 已提交
287 288
{
	int rc;
289
	struct dasd_block *block;
L
Linus Torvalds 已提交
290 291

	rc = 0;
292
	block = device->block;
293
	/* make disk known with correct capacity */
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
	if (block) {
		if (block->base->discipline->do_analysis != NULL)
			rc = block->base->discipline->do_analysis(block);
		if (rc) {
			if (rc != -EAGAIN)
				device->state = DASD_STATE_UNFMT;
			return rc;
		}
		dasd_setup_queue(block);
		set_capacity(block->gdp,
			     block->blocks << block->s2b_shift);
		device->state = DASD_STATE_READY;
		rc = dasd_scan_partitions(block);
		if (rc)
			device->state = DASD_STATE_BASIC;
	} else {
		device->state = DASD_STATE_READY;
	}
312
	return rc;
L
Linus Torvalds 已提交
313 314 315 316 317 318 319
}

/*
 * Remove device from block device layer. Destroy dirty buffers.
 * Forget format information. Check if the target level is basic
 * and if it is create fake disk for formatting.
 */
320
static int dasd_state_ready_to_basic(struct dasd_device *device)
L
Linus Torvalds 已提交
321
{
322 323
	int rc;

L
Linus Torvalds 已提交
324
	device->state = DASD_STATE_BASIC;
325 326 327 328 329 330 331 332
	if (device->block) {
		struct dasd_block *block = device->block;
		rc = dasd_flush_block_queue(block);
		if (rc) {
			device->state = DASD_STATE_READY;
			return rc;
		}
		dasd_flush_request_queue(block);
333
		dasd_destroy_partitions(block);
334 335 336 337
		block->blocks = 0;
		block->bp_block = 0;
		block->s2b_shift = 0;
	}
338
	return 0;
L
Linus Torvalds 已提交
339 340
}

341 342 343
/*
 * Back to basic.
 */
344
static int dasd_state_unfmt_to_basic(struct dasd_device *device)
345 346
{
	device->state = DASD_STATE_BASIC;
347
	return 0;
348 349
}

L
Linus Torvalds 已提交
350 351 352 353 354
/*
 * Make the device online and schedule the bottom half to start
 * the requeueing of requests from the linux request queue to the
 * ccw queue.
 */
355
static int
L
Linus Torvalds 已提交
356 357
dasd_state_ready_to_online(struct dasd_device * device)
{
358
	int rc;
359 360 361
	struct gendisk *disk;
	struct disk_part_iter piter;
	struct hd_struct *part;
362 363 364 365 366 367

	if (device->discipline->ready_to_online) {
		rc = device->discipline->ready_to_online(device);
		if (rc)
			return rc;
	}
L
Linus Torvalds 已提交
368
	device->state = DASD_STATE_ONLINE;
369
	if (device->block) {
370
		dasd_schedule_block_bh(device->block);
371 372 373 374 375 376
		disk = device->block->bdev->bd_disk;
		disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
		while ((part = disk_part_iter_next(&piter)))
			kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE);
		disk_part_iter_exit(&piter);
	}
L
Linus Torvalds 已提交
377 378 379 380 381 382
	return 0;
}

/*
 * Stop the requeueing of requests again.
 */
383
static int dasd_state_online_to_ready(struct dasd_device *device)
L
Linus Torvalds 已提交
384
{
385
	int rc;
386 387 388
	struct gendisk *disk;
	struct disk_part_iter piter;
	struct hd_struct *part;
389 390 391 392 393 394

	if (device->discipline->online_to_ready) {
		rc = device->discipline->online_to_ready(device);
		if (rc)
			return rc;
	}
L
Linus Torvalds 已提交
395
	device->state = DASD_STATE_READY;
396 397 398 399 400 401 402
	if (device->block) {
		disk = device->block->bdev->bd_disk;
		disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
		while ((part = disk_part_iter_next(&piter)))
			kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE);
		disk_part_iter_exit(&piter);
	}
403
	return 0;
L
Linus Torvalds 已提交
404 405 406 407 408
}

/*
 * Device startup state changes.
 */
409
static int dasd_increase_state(struct dasd_device *device)
L
Linus Torvalds 已提交
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
{
	int rc;

	rc = 0;
	if (device->state == DASD_STATE_NEW &&
	    device->target >= DASD_STATE_KNOWN)
		rc = dasd_state_new_to_known(device);

	if (!rc &&
	    device->state == DASD_STATE_KNOWN &&
	    device->target >= DASD_STATE_BASIC)
		rc = dasd_state_known_to_basic(device);

	if (!rc &&
	    device->state == DASD_STATE_BASIC &&
	    device->target >= DASD_STATE_READY)
		rc = dasd_state_basic_to_ready(device);

428 429 430 431 432
	if (!rc &&
	    device->state == DASD_STATE_UNFMT &&
	    device->target > DASD_STATE_UNFMT)
		rc = -EPERM;

L
Linus Torvalds 已提交
433 434 435 436 437 438 439 440 441 442 443
	if (!rc &&
	    device->state == DASD_STATE_READY &&
	    device->target >= DASD_STATE_ONLINE)
		rc = dasd_state_ready_to_online(device);

	return rc;
}

/*
 * Device shutdown state changes.
 */
444
static int dasd_decrease_state(struct dasd_device *device)
L
Linus Torvalds 已提交
445
{
446 447 448
	int rc;

	rc = 0;
L
Linus Torvalds 已提交
449 450
	if (device->state == DASD_STATE_ONLINE &&
	    device->target <= DASD_STATE_READY)
451
		rc = dasd_state_online_to_ready(device);
452

453 454
	if (!rc &&
	    device->state == DASD_STATE_READY &&
L
Linus Torvalds 已提交
455
	    device->target <= DASD_STATE_BASIC)
456
		rc = dasd_state_ready_to_basic(device);
457

458 459
	if (!rc &&
	    device->state == DASD_STATE_UNFMT &&
460
	    device->target <= DASD_STATE_BASIC)
461
		rc = dasd_state_unfmt_to_basic(device);
462

463 464
	if (!rc &&
	    device->state == DASD_STATE_BASIC &&
L
Linus Torvalds 已提交
465
	    device->target <= DASD_STATE_KNOWN)
466
		rc = dasd_state_basic_to_known(device);
467

468 469
	if (!rc &&
	    device->state == DASD_STATE_KNOWN &&
L
Linus Torvalds 已提交
470
	    device->target <= DASD_STATE_NEW)
471
		rc = dasd_state_known_to_new(device);
L
Linus Torvalds 已提交
472

473
	return rc;
L
Linus Torvalds 已提交
474 475 476 477 478
}

/*
 * This is the main startup/shutdown routine.
 */
479
static void dasd_change_state(struct dasd_device *device)
L
Linus Torvalds 已提交
480
{
481
	int rc;
L
Linus Torvalds 已提交
482 483 484 485 486 487 488 489

	if (device->state == device->target)
		/* Already where we want to go today... */
		return;
	if (device->state < device->target)
		rc = dasd_increase_state(device);
	else
		rc = dasd_decrease_state(device);
490 491 492 493
	if (rc == -EAGAIN)
		return;
	if (rc)
		device->target = device->state;
L
Linus Torvalds 已提交
494

495
	if (device->state == device->target)
L
Linus Torvalds 已提交
496
		wake_up(&dasd_init_waitq);
497 498 499

	/* let user-space know that the device status changed */
	kobject_uevent(&device->cdev->dev.kobj, KOBJ_CHANGE);
L
Linus Torvalds 已提交
500 501 502 503 504 505 506 507
}

/*
 * Kick starter for devices that did not complete the startup/shutdown
 * procedure or were sleeping because of a pending state.
 * dasd_kick_device will schedule a call do do_kick_device to the kernel
 * event daemon.
 */
508
static void do_kick_device(struct work_struct *work)
L
Linus Torvalds 已提交
509
{
510
	struct dasd_device *device = container_of(work, struct dasd_device, kick_work);
511
	mutex_lock(&device->state_mutex);
L
Linus Torvalds 已提交
512
	dasd_change_state(device);
513
	mutex_unlock(&device->state_mutex);
514
	dasd_schedule_device_bh(device);
L
Linus Torvalds 已提交
515 516 517
	dasd_put_device(device);
}

518
void dasd_kick_device(struct dasd_device *device)
L
Linus Torvalds 已提交
519 520 521 522 523 524
{
	dasd_get_device(device);
	/* queue call to dasd_kick_device to the kernel event daemon. */
	schedule_work(&device->kick_work);
}

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
/*
 * dasd_reload_device will schedule a call do do_reload_device to the kernel
 * event daemon.
 */
static void do_reload_device(struct work_struct *work)
{
	struct dasd_device *device = container_of(work, struct dasd_device,
						  reload_device);
	device->discipline->reload(device);
	dasd_put_device(device);
}

void dasd_reload_device(struct dasd_device *device)
{
	dasd_get_device(device);
	/* queue call to dasd_reload_device to the kernel event daemon. */
	schedule_work(&device->reload_device);
}
EXPORT_SYMBOL(dasd_reload_device);

545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
/*
 * dasd_restore_device will schedule a call do do_restore_device to the kernel
 * event daemon.
 */
static void do_restore_device(struct work_struct *work)
{
	struct dasd_device *device = container_of(work, struct dasd_device,
						  restore_device);
	device->cdev->drv->restore(device->cdev);
	dasd_put_device(device);
}

void dasd_restore_device(struct dasd_device *device)
{
	dasd_get_device(device);
	/* queue call to dasd_restore_device to the kernel event daemon. */
	schedule_work(&device->restore_device);
}

L
Linus Torvalds 已提交
564 565 566
/*
 * Set the target state for a device and starts the state change.
 */
567
void dasd_set_target_state(struct dasd_device *device, int target)
L
Linus Torvalds 已提交
568
{
569
	dasd_get_device(device);
570
	mutex_lock(&device->state_mutex);
L
Linus Torvalds 已提交
571 572 573 574
	/* If we are in probeonly mode stop at DASD_STATE_READY. */
	if (dasd_probeonly && target > DASD_STATE_READY)
		target = DASD_STATE_READY;
	if (device->target != target) {
575
		if (device->state == target)
L
Linus Torvalds 已提交
576 577 578 579 580
			wake_up(&dasd_init_waitq);
		device->target = target;
	}
	if (device->state != device->target)
		dasd_change_state(device);
581 582
	mutex_unlock(&device->state_mutex);
	dasd_put_device(device);
L
Linus Torvalds 已提交
583 584 585 586 587
}

/*
 * Enable devices with device numbers in [from..to].
 */
588
static inline int _wait_for_device(struct dasd_device *device)
L
Linus Torvalds 已提交
589 590 591 592
{
	return (device->state == device->target);
}

593
void dasd_enable_device(struct dasd_device *device)
L
Linus Torvalds 已提交
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
{
	dasd_set_target_state(device, DASD_STATE_ONLINE);
	if (device->state <= DASD_STATE_KNOWN)
		/* No discipline for device found. */
		dasd_set_target_state(device, DASD_STATE_NEW);
	/* Now wait for the devices to come up. */
	wait_event(dasd_init_waitq, _wait_for_device(device));
}

/*
 * SECTION: device operation (interrupt handler, start i/o, term i/o ...)
 */
#ifdef CONFIG_DASD_PROFILE

struct dasd_profile_info_t dasd_global_profile;
unsigned int dasd_profile_level = DASD_PROFILE_OFF;

/*
 * Increments counter in global and local profiling structures.
 */
614
#define dasd_profile_counter(value, counter, block) \
L
Linus Torvalds 已提交
615 616 617 618
{ \
	int index; \
	for (index = 0; index < 31 && value >> (2+index); index++); \
	dasd_global_profile.counter[index]++; \
619
	block->profile.counter[index]++; \
L
Linus Torvalds 已提交
620 621 622 623 624
}

/*
 * Add profiling information for cqr before execution.
 */
625 626 627
static void dasd_profile_start(struct dasd_block *block,
			       struct dasd_ccw_req *cqr,
			       struct request *req)
L
Linus Torvalds 已提交
628 629 630 631 632 633 634 635 636
{
	struct list_head *l;
	unsigned int counter;

	if (dasd_profile_level != DASD_PROFILE_ON)
		return;

	/* count the length of the chanq for statistics */
	counter = 0;
637
	list_for_each(l, &block->ccw_queue)
L
Linus Torvalds 已提交
638 639 640
		if (++counter >= 31)
			break;
	dasd_global_profile.dasd_io_nr_req[counter]++;
641
	block->profile.dasd_io_nr_req[counter]++;
L
Linus Torvalds 已提交
642 643 644 645 646
}

/*
 * Add profiling information for cqr after execution.
 */
647 648 649
static void dasd_profile_end(struct dasd_block *block,
			     struct dasd_ccw_req *cqr,
			     struct request *req)
L
Linus Torvalds 已提交
650 651 652 653 654 655 656
{
	long strtime, irqtime, endtime, tottime;	/* in microseconds */
	long tottimeps, sectors;

	if (dasd_profile_level != DASD_PROFILE_ON)
		return;

657
	sectors = blk_rq_sectors(req);
L
Linus Torvalds 已提交
658 659 660 661 662 663 664 665 666 667 668 669 670
	if (!cqr->buildclk || !cqr->startclk ||
	    !cqr->stopclk || !cqr->endclk ||
	    !sectors)
		return;

	strtime = ((cqr->startclk - cqr->buildclk) >> 12);
	irqtime = ((cqr->stopclk - cqr->startclk) >> 12);
	endtime = ((cqr->endclk - cqr->stopclk) >> 12);
	tottime = ((cqr->endclk - cqr->buildclk) >> 12);
	tottimeps = tottime / sectors;

	if (!dasd_global_profile.dasd_io_reqs)
		memset(&dasd_global_profile, 0,
671
		       sizeof(struct dasd_profile_info_t));
L
Linus Torvalds 已提交
672 673 674
	dasd_global_profile.dasd_io_reqs++;
	dasd_global_profile.dasd_io_sects += sectors;

675 676 677 678 679
	if (!block->profile.dasd_io_reqs)
		memset(&block->profile, 0,
		       sizeof(struct dasd_profile_info_t));
	block->profile.dasd_io_reqs++;
	block->profile.dasd_io_sects += sectors;
L
Linus Torvalds 已提交
680

681 682 683 684 685 686 687
	dasd_profile_counter(sectors, dasd_io_secs, block);
	dasd_profile_counter(tottime, dasd_io_times, block);
	dasd_profile_counter(tottimeps, dasd_io_timps, block);
	dasd_profile_counter(strtime, dasd_io_time1, block);
	dasd_profile_counter(irqtime, dasd_io_time2, block);
	dasd_profile_counter(irqtime / sectors, dasd_io_time2ps, block);
	dasd_profile_counter(endtime, dasd_io_time3, block);
L
Linus Torvalds 已提交
688 689
}
#else
690 691
#define dasd_profile_start(block, cqr, req) do {} while (0)
#define dasd_profile_end(block, cqr, req) do {} while (0)
L
Linus Torvalds 已提交
692 693 694 695 696 697 698 699 700
#endif				/* CONFIG_DASD_PROFILE */

/*
 * Allocate memory for a channel program with 'cplength' channel
 * command words and 'datasize' additional space. There are two
 * variantes: 1) dasd_kmalloc_request uses kmalloc to get the needed
 * memory and 2) dasd_smalloc_request uses the static ccw memory
 * that gets allocated for each device.
 */
701
struct dasd_ccw_req *dasd_kmalloc_request(int magic, int cplength,
702 703
					  int datasize,
					  struct dasd_device *device)
L
Linus Torvalds 已提交
704 705 706 707
{
	struct dasd_ccw_req *cqr;

	/* Sanity checks */
708
	BUG_ON(datasize > PAGE_SIZE ||
709
	     (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
L
Linus Torvalds 已提交
710

711
	cqr = kzalloc(sizeof(struct dasd_ccw_req), GFP_ATOMIC);
L
Linus Torvalds 已提交
712 713 714 715
	if (cqr == NULL)
		return ERR_PTR(-ENOMEM);
	cqr->cpaddr = NULL;
	if (cplength > 0) {
716
		cqr->cpaddr = kcalloc(cplength, sizeof(struct ccw1),
L
Linus Torvalds 已提交
717 718 719 720 721 722 723 724
				      GFP_ATOMIC | GFP_DMA);
		if (cqr->cpaddr == NULL) {
			kfree(cqr);
			return ERR_PTR(-ENOMEM);
		}
	}
	cqr->data = NULL;
	if (datasize > 0) {
725
		cqr->data = kzalloc(datasize, GFP_ATOMIC | GFP_DMA);
L
Linus Torvalds 已提交
726
		if (cqr->data == NULL) {
J
Jesper Juhl 已提交
727
			kfree(cqr->cpaddr);
L
Linus Torvalds 已提交
728 729 730 731
			kfree(cqr);
			return ERR_PTR(-ENOMEM);
		}
	}
732
	cqr->magic =  magic;
L
Linus Torvalds 已提交
733 734 735 736 737
	set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
	dasd_get_device(device);
	return cqr;
}

738
struct dasd_ccw_req *dasd_smalloc_request(int magic, int cplength,
739 740
					  int datasize,
					  struct dasd_device *device)
L
Linus Torvalds 已提交
741 742 743 744 745 746 747
{
	unsigned long flags;
	struct dasd_ccw_req *cqr;
	char *data;
	int size;

	/* Sanity checks */
748
	BUG_ON(datasize > PAGE_SIZE ||
749
	     (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
L
Linus Torvalds 已提交
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774

	size = (sizeof(struct dasd_ccw_req) + 7L) & -8L;
	if (cplength > 0)
		size += cplength * sizeof(struct ccw1);
	if (datasize > 0)
		size += datasize;
	spin_lock_irqsave(&device->mem_lock, flags);
	cqr = (struct dasd_ccw_req *)
		dasd_alloc_chunk(&device->ccw_chunks, size);
	spin_unlock_irqrestore(&device->mem_lock, flags);
	if (cqr == NULL)
		return ERR_PTR(-ENOMEM);
	memset(cqr, 0, sizeof(struct dasd_ccw_req));
	data = (char *) cqr + ((sizeof(struct dasd_ccw_req) + 7L) & -8L);
	cqr->cpaddr = NULL;
	if (cplength > 0) {
		cqr->cpaddr = (struct ccw1 *) data;
		data += cplength*sizeof(struct ccw1);
		memset(cqr->cpaddr, 0, cplength*sizeof(struct ccw1));
	}
	cqr->data = NULL;
	if (datasize > 0) {
		cqr->data = data;
 		memset(cqr->data, 0, datasize);
	}
775
	cqr->magic = magic;
L
Linus Torvalds 已提交
776 777 778 779 780 781 782 783 784 785
	set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
	dasd_get_device(device);
	return cqr;
}

/*
 * Free memory of a channel program. This function needs to free all the
 * idal lists that might have been created by dasd_set_cda and the
 * struct dasd_ccw_req itself.
 */
786
void dasd_kfree_request(struct dasd_ccw_req *cqr, struct dasd_device *device)
L
Linus Torvalds 已提交
787
{
788
#ifdef CONFIG_64BIT
L
Linus Torvalds 已提交
789 790 791 792 793 794 795 796
	struct ccw1 *ccw;

	/* Clear any idals used for the request. */
	ccw = cqr->cpaddr;
	do {
		clear_normalized_cda(ccw);
	} while (ccw++->flags & (CCW_FLAG_CC | CCW_FLAG_DC));
#endif
J
Jesper Juhl 已提交
797 798
	kfree(cqr->cpaddr);
	kfree(cqr->data);
L
Linus Torvalds 已提交
799 800 801 802
	kfree(cqr);
	dasd_put_device(device);
}

803
void dasd_sfree_request(struct dasd_ccw_req *cqr, struct dasd_device *device)
L
Linus Torvalds 已提交
804 805 806 807 808 809 810 811 812 813 814 815
{
	unsigned long flags;

	spin_lock_irqsave(&device->mem_lock, flags);
	dasd_free_chunk(&device->ccw_chunks, cqr);
	spin_unlock_irqrestore(&device->mem_lock, flags);
	dasd_put_device(device);
}

/*
 * Check discipline magic in cqr.
 */
816
static inline int dasd_check_cqr(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
817 818 819 820 821
{
	struct dasd_device *device;

	if (cqr == NULL)
		return -EINVAL;
822
	device = cqr->startdev;
L
Linus Torvalds 已提交
823
	if (strncmp((char *) &cqr->magic, device->discipline->ebcname, 4)) {
S
Stefan Haberland 已提交
824
		DBF_DEV_EVENT(DBF_WARNING, device,
L
Linus Torvalds 已提交
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839
			    " dasd_ccw_req 0x%08x magic doesn't match"
			    " discipline 0x%08x",
			    cqr->magic,
			    *(unsigned int *) device->discipline->name);
		return -EINVAL;
	}
	return 0;
}

/*
 * Terminate the current i/o and set the request to clear_pending.
 * Timer keeps device runnig.
 * ccw_device_clear can fail if the i/o subsystem
 * is in a bad mood.
 */
840
int dasd_term_IO(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
841 842 843
{
	struct dasd_device *device;
	int retries, rc;
S
Stefan Haberland 已提交
844
	char errorstring[ERRORLENGTH];
L
Linus Torvalds 已提交
845 846 847 848 849 850

	/* Check the cqr */
	rc = dasd_check_cqr(cqr);
	if (rc)
		return rc;
	retries = 0;
851
	device = (struct dasd_device *) cqr->startdev;
L
Linus Torvalds 已提交
852 853 854 855
	while ((retries < 5) && (cqr->status == DASD_CQR_IN_IO)) {
		rc = ccw_device_clear(device->cdev, (long) cqr);
		switch (rc) {
		case 0:	/* termination successful */
856
			cqr->retries--;
857
			cqr->status = DASD_CQR_CLEAR_PENDING;
L
Linus Torvalds 已提交
858
			cqr->stopclk = get_clock();
859
			cqr->starttime = 0;
L
Linus Torvalds 已提交
860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877
			DBF_DEV_EVENT(DBF_DEBUG, device,
				      "terminate cqr %p successful",
				      cqr);
			break;
		case -ENODEV:
			DBF_DEV_EVENT(DBF_ERR, device, "%s",
				      "device gone, retry");
			break;
		case -EIO:
			DBF_DEV_EVENT(DBF_ERR, device, "%s",
				      "I/O error, retry");
			break;
		case -EINVAL:
		case -EBUSY:
			DBF_DEV_EVENT(DBF_ERR, device, "%s",
				      "device busy, retry later");
			break;
		default:
S
Stefan Haberland 已提交
878 879 880 881
			/* internal error 10 - unknown rc*/
			snprintf(errorstring, ERRORLENGTH, "10 %d", rc);
			dev_err(&device->cdev->dev, "An error occurred in the "
				"DASD device driver, reason=%s\n", errorstring);
L
Linus Torvalds 已提交
882 883 884 885 886
			BUG();
			break;
		}
		retries++;
	}
887
	dasd_schedule_device_bh(device);
L
Linus Torvalds 已提交
888 889 890 891 892 893 894
	return rc;
}

/*
 * Start the i/o. This start_IO can fail if the channel is really busy.
 * In that case set up a timer to start the request later.
 */
895
int dasd_start_IO(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
896 897 898
{
	struct dasd_device *device;
	int rc;
S
Stefan Haberland 已提交
899
	char errorstring[ERRORLENGTH];
L
Linus Torvalds 已提交
900 901 902

	/* Check the cqr */
	rc = dasd_check_cqr(cqr);
903 904
	if (rc) {
		cqr->intrc = rc;
L
Linus Torvalds 已提交
905
		return rc;
906
	}
907
	device = (struct dasd_device *) cqr->startdev;
L
Linus Torvalds 已提交
908
	if (cqr->retries < 0) {
S
Stefan Haberland 已提交
909 910 911 912
		/* internal error 14 - start_IO run out of retries */
		sprintf(errorstring, "14 %p", cqr);
		dev_err(&device->cdev->dev, "An error occurred in the DASD "
			"device driver, reason=%s\n", errorstring);
913
		cqr->status = DASD_CQR_ERROR;
L
Linus Torvalds 已提交
914 915 916 917 918
		return -EIO;
	}
	cqr->startclk = get_clock();
	cqr->starttime = jiffies;
	cqr->retries--;
919 920 921 922 923 924 925
	if (cqr->cpmode == 1) {
		rc = ccw_device_tm_start(device->cdev, cqr->cpaddr,
					 (long) cqr, cqr->lpm);
	} else {
		rc = ccw_device_start(device->cdev, cqr->cpaddr,
				      (long) cqr, cqr->lpm, 0);
	}
L
Linus Torvalds 已提交
926 927 928 929 930
	switch (rc) {
	case 0:
		cqr->status = DASD_CQR_IN_IO;
		break;
	case -EBUSY:
S
Stefan Haberland 已提交
931
		DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
L
Linus Torvalds 已提交
932 933 934
			      "start_IO: device busy, retry later");
		break;
	case -ETIMEDOUT:
S
Stefan Haberland 已提交
935
		DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
L
Linus Torvalds 已提交
936 937 938 939 940 941 942 943 944
			      "start_IO: request timeout, retry later");
		break;
	case -EACCES:
		/* -EACCES indicates that the request used only a
		 * subset of the available pathes and all these
		 * pathes are gone.
		 * Do a retry with all available pathes.
		 */
		cqr->lpm = LPM_ANYPATH;
S
Stefan Haberland 已提交
945
		DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
L
Linus Torvalds 已提交
946 947 948 949
			      "start_IO: selected pathes gone,"
			      " retry on all pathes");
		break;
	case -ENODEV:
950 951 952
		DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
			      "start_IO: -ENODEV device gone, retry");
		break;
L
Linus Torvalds 已提交
953
	case -EIO:
S
Stefan Haberland 已提交
954
		DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
955
			      "start_IO: -EIO device gone, retry");
L
Linus Torvalds 已提交
956
		break;
957 958 959 960 961 962
	case -EINVAL:
		/* most likely caused in power management context */
		DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
			      "start_IO: -EINVAL device currently "
			      "not accessible");
		break;
L
Linus Torvalds 已提交
963
	default:
S
Stefan Haberland 已提交
964 965 966 967 968
		/* internal error 11 - unknown rc */
		snprintf(errorstring, ERRORLENGTH, "11 %d", rc);
		dev_err(&device->cdev->dev,
			"An error occurred in the DASD device driver, "
			"reason=%s\n", errorstring);
L
Linus Torvalds 已提交
969 970 971
		BUG();
		break;
	}
972
	cqr->intrc = rc;
L
Linus Torvalds 已提交
973 974 975 976 977 978 979 980 981 982 983
	return rc;
}

/*
 * Timeout function for dasd devices. This is used for different purposes
 *  1) missing interrupt handler for normal operation
 *  2) delayed start of request where start_IO failed with -EBUSY
 *  3) timeout for missing state change interrupts
 * The head of the ccw queue will have status DASD_CQR_IN_IO for 1),
 * DASD_CQR_QUEUED for 2) and 3).
 */
984
static void dasd_device_timeout(unsigned long ptr)
L
Linus Torvalds 已提交
985 986 987 988 989 990 991
{
	unsigned long flags;
	struct dasd_device *device;

	device = (struct dasd_device *) ptr;
	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
	/* re-activate request queue */
992
	dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING);
L
Linus Torvalds 已提交
993
	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
994
	dasd_schedule_device_bh(device);
L
Linus Torvalds 已提交
995 996 997 998 999
}

/*
 * Setup timeout for a device in jiffies.
 */
1000
void dasd_device_set_timer(struct dasd_device *device, int expires)
L
Linus Torvalds 已提交
1001
{
1002 1003 1004 1005
	if (expires == 0)
		del_timer(&device->timer);
	else
		mod_timer(&device->timer, jiffies + expires);
L
Linus Torvalds 已提交
1006 1007 1008 1009 1010
}

/*
 * Clear timeout for a device.
 */
1011
void dasd_device_clear_timer(struct dasd_device *device)
L
Linus Torvalds 已提交
1012
{
1013
	del_timer(&device->timer);
L
Linus Torvalds 已提交
1014 1015
}

1016 1017
static void dasd_handle_killed_request(struct ccw_device *cdev,
				       unsigned long intparm)
L
Linus Torvalds 已提交
1018 1019 1020 1021
{
	struct dasd_ccw_req *cqr;
	struct dasd_device *device;

1022 1023
	if (!intparm)
		return;
L
Linus Torvalds 已提交
1024 1025
	cqr = (struct dasd_ccw_req *) intparm;
	if (cqr->status != DASD_CQR_IN_IO) {
1026 1027 1028
		DBF_EVENT_DEVID(DBF_DEBUG, cdev,
				"invalid status in handle_killed_request: "
				"%02x", cqr->status);
L
Linus Torvalds 已提交
1029 1030 1031
		return;
	}

S
Stefan Haberland 已提交
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
	device = dasd_device_from_cdev_locked(cdev);
	if (IS_ERR(device)) {
		DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
				"unable to get device from cdev");
		return;
	}

	if (!cqr->startdev ||
	    device != cqr->startdev ||
	    strncmp(cqr->startdev->discipline->ebcname,
		    (char *) &cqr->magic, 4)) {
1043 1044
		DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
				"invalid device in request");
S
Stefan Haberland 已提交
1045
		dasd_put_device(device);
L
Linus Torvalds 已提交
1046 1047 1048 1049 1050 1051
		return;
	}

	/* Schedule request to be retried. */
	cqr->status = DASD_CQR_QUEUED;

1052 1053
	dasd_device_clear_timer(device);
	dasd_schedule_device_bh(device);
L
Linus Torvalds 已提交
1054 1055 1056
	dasd_put_device(device);
}

1057
void dasd_generic_handle_state_change(struct dasd_device *device)
L
Linus Torvalds 已提交
1058
{
1059 1060 1061
	/* First of all start sense subsystem status request. */
	dasd_eer_snss(device);

1062
	dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING);
1063 1064 1065
	dasd_schedule_device_bh(device);
	if (device->block)
		dasd_schedule_block_bh(device->block);
L
Linus Torvalds 已提交
1066 1067 1068 1069 1070
}

/*
 * Interrupt handler for "normal" ssch-io based dasd devices.
 */
1071 1072
void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
		      struct irb *irb)
L
Linus Torvalds 已提交
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
{
	struct dasd_ccw_req *cqr, *next;
	struct dasd_device *device;
	unsigned long long now;
	int expires;

	if (IS_ERR(irb)) {
		switch (PTR_ERR(irb)) {
		case -EIO:
			break;
		case -ETIMEDOUT:
1084 1085
			DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: "
					"request timed out\n", __func__);
L
Linus Torvalds 已提交
1086 1087
			break;
		default:
1088 1089 1090
			DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: "
					"unknown error %ld\n", __func__,
					PTR_ERR(irb));
L
Linus Torvalds 已提交
1091
		}
1092
		dasd_handle_killed_request(cdev, intparm);
L
Linus Torvalds 已提交
1093 1094 1095 1096 1097
		return;
	}

	now = get_clock();

1098 1099
	/* check for unsolicited interrupts */
	cqr = (struct dasd_ccw_req *) intparm;
1100 1101 1102
	if (!cqr || ((scsw_cc(&irb->scsw) == 1) &&
		     (scsw_fctl(&irb->scsw) & SCSW_FCTL_START_FUNC) &&
		     (scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND))) {
1103 1104
		if (cqr && cqr->status == DASD_CQR_IN_IO)
			cqr->status = DASD_CQR_QUEUED;
1105
		device = dasd_device_from_cdev_locked(cdev);
L
Linus Torvalds 已提交
1106
		if (!IS_ERR(device)) {
1107 1108 1109
			dasd_device_clear_timer(device);
			device->discipline->handle_unsolicited_interrupt(device,
									 irb);
L
Linus Torvalds 已提交
1110 1111 1112 1113 1114
			dasd_put_device(device);
		}
		return;
	}

1115 1116
	device = (struct dasd_device *) cqr->startdev;
	if (!device ||
L
Linus Torvalds 已提交
1117
	    strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
1118 1119
		DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
				"invalid device in request");
L
Linus Torvalds 已提交
1120 1121 1122 1123
		return;
	}

	/* Check for clear pending */
1124
	if (cqr->status == DASD_CQR_CLEAR_PENDING &&
1125
	    scsw_fctl(&irb->scsw) & SCSW_FCTL_CLEAR_FUNC) {
1126 1127
		cqr->status = DASD_CQR_CLEARED;
		dasd_device_clear_timer(device);
1128
		wake_up(&dasd_flush_wq);
1129
		dasd_schedule_device_bh(device);
L
Linus Torvalds 已提交
1130 1131 1132
		return;
	}

1133
	/* check status - the request might have been killed by dyn detach */
L
Linus Torvalds 已提交
1134
	if (cqr->status != DASD_CQR_IN_IO) {
S
Stefan Haberland 已提交
1135 1136
		DBF_DEV_EVENT(DBF_DEBUG, device, "invalid status: bus_id %s, "
			      "status %02x", dev_name(&cdev->dev), cqr->status);
L
Linus Torvalds 已提交
1137 1138
		return;
	}
S
Stefan Haberland 已提交
1139

1140
	next = NULL;
L
Linus Torvalds 已提交
1141
	expires = 0;
1142 1143
	if (scsw_dstat(&irb->scsw) == (DEV_STAT_CHN_END | DEV_STAT_DEV_END) &&
	    scsw_cstat(&irb->scsw) == 0) {
1144 1145
		/* request was completed successfully */
		cqr->status = DASD_CQR_SUCCESS;
L
Linus Torvalds 已提交
1146 1147
		cqr->stopclk = now;
		/* Start first request on queue if possible -> fast_io. */
1148 1149 1150
		if (cqr->devlist.next != &device->ccw_queue) {
			next = list_entry(cqr->devlist.next,
					  struct dasd_ccw_req, devlist);
L
Linus Torvalds 已提交
1151
		}
1152 1153
	} else {  /* error */
		memcpy(&cqr->irb, irb, sizeof(struct irb));
S
Stefan Haberland 已提交
1154 1155
		/* log sense for every failed I/O to s390 debugfeature */
		dasd_log_sense_dbf(cqr, irb);
1156 1157 1158
		if (device->features & DASD_FEATURE_ERPLOG) {
			dasd_log_sense(cqr, irb);
		}
S
Stefan Haberland 已提交
1159

1160 1161 1162
		/*
		 * If we don't want complex ERP for this request, then just
		 * reset this and retry it in the fastpath
1163
		 */
1164
		if (!test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags) &&
1165
		    cqr->retries > 0) {
S
Stefan Haberland 已提交
1166 1167 1168 1169 1170
			if (cqr->lpm == LPM_ANYPATH)
				DBF_DEV_EVENT(DBF_DEBUG, device,
					      "default ERP in fastpath "
					      "(%i retries left)",
					      cqr->retries);
1171 1172 1173 1174
			cqr->lpm    = LPM_ANYPATH;
			cqr->status = DASD_CQR_QUEUED;
			next = cqr;
		} else
L
Linus Torvalds 已提交
1175
			cqr->status = DASD_CQR_ERROR;
1176 1177 1178 1179 1180
	}
	if (next && (next->status == DASD_CQR_QUEUED) &&
	    (!device->stopped)) {
		if (device->discipline->start_IO(next) == 0)
			expires = next->expires;
L
Linus Torvalds 已提交
1181 1182
	}
	if (expires != 0)
1183
		dasd_device_set_timer(device, expires);
L
Linus Torvalds 已提交
1184
	else
1185 1186
		dasd_device_clear_timer(device);
	dasd_schedule_device_bh(device);
L
Linus Torvalds 已提交
1187 1188 1189
}

/*
1190 1191
 * If we have an error on a dasd_block layer request then we cancel
 * and return all further requests from the same dasd_block as well.
L
Linus Torvalds 已提交
1192
 */
1193 1194
static void __dasd_device_recovery(struct dasd_device *device,
				   struct dasd_ccw_req *ref_cqr)
L
Linus Torvalds 已提交
1195
{
1196 1197
	struct list_head *l, *n;
	struct dasd_ccw_req *cqr;
L
Linus Torvalds 已提交
1198

1199 1200 1201 1202 1203
	/*
	 * only requeue request that came from the dasd_block layer
	 */
	if (!ref_cqr->block)
		return;
L
Linus Torvalds 已提交
1204

1205 1206 1207 1208 1209 1210 1211 1212
	list_for_each_safe(l, n, &device->ccw_queue) {
		cqr = list_entry(l, struct dasd_ccw_req, devlist);
		if (cqr->status == DASD_CQR_QUEUED &&
		    ref_cqr->block == cqr->block) {
			cqr->status = DASD_CQR_CLEARED;
		}
	}
};
L
Linus Torvalds 已提交
1213 1214

/*
1215 1216
 * Remove those ccw requests from the queue that need to be returned
 * to the upper layer.
L
Linus Torvalds 已提交
1217
 */
1218 1219
static void __dasd_device_process_ccw_queue(struct dasd_device *device,
					    struct list_head *final_queue)
L
Linus Torvalds 已提交
1220 1221 1222 1223 1224 1225
{
	struct list_head *l, *n;
	struct dasd_ccw_req *cqr;

	/* Process request with final status. */
	list_for_each_safe(l, n, &device->ccw_queue) {
1226 1227
		cqr = list_entry(l, struct dasd_ccw_req, devlist);

L
Linus Torvalds 已提交
1228
		/* Stop list processing at the first non-final request. */
1229 1230 1231
		if (cqr->status == DASD_CQR_QUEUED ||
		    cqr->status == DASD_CQR_IN_IO ||
		    cqr->status == DASD_CQR_CLEAR_PENDING)
L
Linus Torvalds 已提交
1232 1233
			break;
		if (cqr->status == DASD_CQR_ERROR) {
1234
			__dasd_device_recovery(device, cqr);
1235
		}
L
Linus Torvalds 已提交
1236
		/* Rechain finished requests to final queue */
1237
		list_move_tail(&cqr->devlist, final_queue);
L
Linus Torvalds 已提交
1238 1239 1240 1241
	}
}

/*
1242 1243
 * the cqrs from the final queue are returned to the upper layer
 * by setting a dasd_block state and calling the callback function
L
Linus Torvalds 已提交
1244
 */
1245 1246
static void __dasd_device_process_final_queue(struct dasd_device *device,
					      struct list_head *final_queue)
L
Linus Torvalds 已提交
1247
{
1248
	struct list_head *l, *n;
L
Linus Torvalds 已提交
1249
	struct dasd_ccw_req *cqr;
1250
	struct dasd_block *block;
1251 1252
	void (*callback)(struct dasd_ccw_req *, void *data);
	void *callback_data;
S
Stefan Haberland 已提交
1253
	char errorstring[ERRORLENGTH];
1254

1255 1256 1257
	list_for_each_safe(l, n, final_queue) {
		cqr = list_entry(l, struct dasd_ccw_req, devlist);
		list_del_init(&cqr->devlist);
1258
		block = cqr->block;
1259 1260
		callback = cqr->callback;
		callback_data = cqr->callback_data;
1261 1262
		if (block)
			spin_lock_bh(&block->queue_lock);
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
		switch (cqr->status) {
		case DASD_CQR_SUCCESS:
			cqr->status = DASD_CQR_DONE;
			break;
		case DASD_CQR_ERROR:
			cqr->status = DASD_CQR_NEED_ERP;
			break;
		case DASD_CQR_CLEARED:
			cqr->status = DASD_CQR_TERMINATED;
			break;
		default:
S
Stefan Haberland 已提交
1274 1275 1276 1277 1278
			/* internal error 12 - wrong cqr status*/
			snprintf(errorstring, ERRORLENGTH, "12 %p %x02", cqr, cqr->status);
			dev_err(&device->cdev->dev,
				"An error occurred in the DASD device driver, "
				"reason=%s\n", errorstring);
1279
			BUG();
L
Linus Torvalds 已提交
1280
		}
1281
		if (cqr->callback != NULL)
1282
			(callback)(cqr, callback_data);
1283 1284
		if (block)
			spin_unlock_bh(&block->queue_lock);
L
Linus Torvalds 已提交
1285 1286 1287 1288 1289 1290 1291
	}
}

/*
 * Take a look at the first request on the ccw queue and check
 * if it reached its expire time. If so, terminate the IO.
 */
1292
static void __dasd_device_check_expire(struct dasd_device *device)
L
Linus Torvalds 已提交
1293 1294 1295 1296 1297
{
	struct dasd_ccw_req *cqr;

	if (list_empty(&device->ccw_queue))
		return;
1298
	cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist);
1299 1300 1301 1302
	if ((cqr->status == DASD_CQR_IN_IO && cqr->expires != 0) &&
	    (time_after_eq(jiffies, cqr->expires + cqr->starttime))) {
		if (device->discipline->term_IO(cqr) != 0) {
			/* Hmpf, try again in 5 sec */
S
Stefan Haberland 已提交
1303 1304 1305 1306
			dev_err(&device->cdev->dev,
				"cqr %p timed out (%is) but cannot be "
				"ended, retrying in 5 s\n",
				cqr, (cqr->expires/HZ));
1307 1308
			cqr->expires += 5*HZ;
			dasd_device_set_timer(device, 5*HZ);
1309
		} else {
S
Stefan Haberland 已提交
1310 1311 1312 1313
			dev_err(&device->cdev->dev,
				"cqr %p timed out (%is), %i retries "
				"remaining\n", cqr, (cqr->expires/HZ),
				cqr->retries);
L
Linus Torvalds 已提交
1314 1315 1316 1317 1318 1319 1320 1321
		}
	}
}

/*
 * Take a look at the first request on the ccw queue and check
 * if it needs to be started.
 */
1322
static void __dasd_device_start_head(struct dasd_device *device)
L
Linus Torvalds 已提交
1323 1324 1325 1326 1327 1328
{
	struct dasd_ccw_req *cqr;
	int rc;

	if (list_empty(&device->ccw_queue))
		return;
1329
	cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist);
1330 1331
	if (cqr->status != DASD_CQR_QUEUED)
		return;
1332 1333 1334 1335
	/* when device is stopped, return request to previous layer */
	if (device->stopped) {
		cqr->status = DASD_CQR_CLEARED;
		dasd_schedule_device_bh(device);
1336
		return;
1337
	}
1338 1339 1340

	rc = device->discipline->start_IO(cqr);
	if (rc == 0)
1341
		dasd_device_set_timer(device, cqr->expires);
1342
	else if (rc == -EACCES) {
1343
		dasd_schedule_device_bh(device);
1344 1345
	} else
		/* Hmpf, try again in 1/2 sec */
1346
		dasd_device_set_timer(device, 50);
1347 1348
}

L
Linus Torvalds 已提交
1349
/*
1350 1351 1352 1353 1354 1355 1356 1357
 * Go through all request on the dasd_device request queue,
 * terminate them on the cdev if necessary, and return them to the
 * submitting layer via callback.
 * Note:
 * Make sure that all 'submitting layers' still exist when
 * this function is called!. In other words, when 'device' is a base
 * device then all block layer requests must have been removed before
 * via dasd_flush_block_queue.
L
Linus Torvalds 已提交
1358
 */
1359
int dasd_flush_device_queue(struct dasd_device *device)
L
Linus Torvalds 已提交
1360
{
1361 1362
	struct dasd_ccw_req *cqr, *n;
	int rc;
L
Linus Torvalds 已提交
1363 1364 1365 1366
	struct list_head flush_queue;

	INIT_LIST_HEAD(&flush_queue);
	spin_lock_irq(get_ccwdev_lock(device->cdev));
1367
	rc = 0;
1368
	list_for_each_entry_safe(cqr, n, &device->ccw_queue, devlist) {
1369 1370 1371 1372 1373 1374
		/* Check status and move request to flush_queue */
		switch (cqr->status) {
		case DASD_CQR_IN_IO:
			rc = device->discipline->term_IO(cqr);
			if (rc) {
				/* unable to terminate requeust */
S
Stefan Haberland 已提交
1375 1376 1377
				dev_err(&device->cdev->dev,
					"Flushing the DASD request queue "
					"failed for request %p\n", cqr);
1378 1379 1380 1381 1382
				/* stop flush processing */
				goto finished;
			}
			break;
		case DASD_CQR_QUEUED:
L
Linus Torvalds 已提交
1383
			cqr->stopclk = get_clock();
1384
			cqr->status = DASD_CQR_CLEARED;
1385
			break;
1386
		default: /* no need to modify the others */
1387 1388
			break;
		}
1389
		list_move_tail(&cqr->devlist, &flush_queue);
1390 1391 1392
	}
finished:
	spin_unlock_irq(get_ccwdev_lock(device->cdev));
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
	/*
	 * After this point all requests must be in state CLEAR_PENDING,
	 * CLEARED, SUCCESS or ERROR. Now wait for CLEAR_PENDING to become
	 * one of the others.
	 */
	list_for_each_entry_safe(cqr, n, &flush_queue, devlist)
		wait_event(dasd_flush_wq,
			   (cqr->status != DASD_CQR_CLEAR_PENDING));
	/*
	 * Now set each request back to TERMINATED, DONE or NEED_ERP
	 * and call the callback function of flushed requests
	 */
	__dasd_device_process_final_queue(device, &flush_queue);
1406
	return rc;
L
Linus Torvalds 已提交
1407 1408 1409 1410 1411
}

/*
 * Acquire the device lock and process queues for the device.
 */
1412
static void dasd_device_tasklet(struct dasd_device *device)
L
Linus Torvalds 已提交
1413 1414 1415 1416 1417 1418 1419
{
	struct list_head final_queue;

	atomic_set (&device->tasklet_scheduled, 0);
	INIT_LIST_HEAD(&final_queue);
	spin_lock_irq(get_ccwdev_lock(device->cdev));
	/* Check expire time of first request on the ccw queue. */
1420 1421 1422
	__dasd_device_check_expire(device);
	/* find final requests on ccw queue */
	__dasd_device_process_ccw_queue(device, &final_queue);
L
Linus Torvalds 已提交
1423 1424
	spin_unlock_irq(get_ccwdev_lock(device->cdev));
	/* Now call the callback function of requests with final status */
1425 1426
	__dasd_device_process_final_queue(device, &final_queue);
	spin_lock_irq(get_ccwdev_lock(device->cdev));
L
Linus Torvalds 已提交
1427
	/* Now check if the head of the ccw queue needs to be started. */
1428 1429
	__dasd_device_start_head(device);
	spin_unlock_irq(get_ccwdev_lock(device->cdev));
L
Linus Torvalds 已提交
1430 1431 1432 1433 1434 1435
	dasd_put_device(device);
}

/*
 * Schedules a call to dasd_tasklet over the device tasklet.
 */
1436
void dasd_schedule_device_bh(struct dasd_device *device)
L
Linus Torvalds 已提交
1437 1438
{
	/* Protect against rescheduling. */
1439
	if (atomic_cmpxchg (&device->tasklet_scheduled, 0, 1) != 0)
L
Linus Torvalds 已提交
1440 1441 1442 1443 1444
		return;
	dasd_get_device(device);
	tasklet_hi_schedule(&device->tasklet);
}

1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
void dasd_device_set_stop_bits(struct dasd_device *device, int bits)
{
	device->stopped |= bits;
}
EXPORT_SYMBOL_GPL(dasd_device_set_stop_bits);

void dasd_device_remove_stop_bits(struct dasd_device *device, int bits)
{
	device->stopped &= ~bits;
	if (!device->stopped)
		wake_up(&generic_waitq);
}
EXPORT_SYMBOL_GPL(dasd_device_remove_stop_bits);

L
Linus Torvalds 已提交
1459
/*
1460 1461
 * Queue a request to the head of the device ccw_queue.
 * Start the I/O if possible.
L
Linus Torvalds 已提交
1462
 */
1463
void dasd_add_request_head(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
1464 1465 1466 1467
{
	struct dasd_device *device;
	unsigned long flags;

1468
	device = cqr->startdev;
L
Linus Torvalds 已提交
1469
	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
1470 1471
	cqr->status = DASD_CQR_QUEUED;
	list_add(&cqr->devlist, &device->ccw_queue);
L
Linus Torvalds 已提交
1472
	/* let the bh start the request to keep them in order */
1473
	dasd_schedule_device_bh(device);
L
Linus Torvalds 已提交
1474 1475 1476 1477
	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
}

/*
1478 1479
 * Queue a request to the tail of the device ccw_queue.
 * Start the I/O if possible.
L
Linus Torvalds 已提交
1480
 */
1481
void dasd_add_request_tail(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
1482 1483 1484 1485
{
	struct dasd_device *device;
	unsigned long flags;

1486
	device = cqr->startdev;
L
Linus Torvalds 已提交
1487
	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
1488 1489
	cqr->status = DASD_CQR_QUEUED;
	list_add_tail(&cqr->devlist, &device->ccw_queue);
L
Linus Torvalds 已提交
1490
	/* let the bh start the request to keep them in order */
1491
	dasd_schedule_device_bh(device);
L
Linus Torvalds 已提交
1492 1493 1494 1495
	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
}

/*
1496
 * Wakeup helper for the 'sleep_on' functions.
L
Linus Torvalds 已提交
1497
 */
1498
static void dasd_wakeup_cb(struct dasd_ccw_req *cqr, void *data)
L
Linus Torvalds 已提交
1499
{
1500 1501 1502 1503
	spin_lock_irq(get_ccwdev_lock(cqr->startdev->cdev));
	cqr->callback_data = DASD_SLEEPON_END_TAG;
	spin_unlock_irq(get_ccwdev_lock(cqr->startdev->cdev));
	wake_up(&generic_waitq);
L
Linus Torvalds 已提交
1504 1505
}

1506
static inline int _wait_for_wakeup(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
1507 1508 1509 1510
{
	struct dasd_device *device;
	int rc;

1511
	device = cqr->startdev;
L
Linus Torvalds 已提交
1512
	spin_lock_irq(get_ccwdev_lock(device->cdev));
1513
	rc = (cqr->callback_data == DASD_SLEEPON_END_TAG);
L
Linus Torvalds 已提交
1514 1515 1516 1517 1518
	spin_unlock_irq(get_ccwdev_lock(device->cdev));
	return rc;
}

/*
1519
 * checks if error recovery is necessary, returns 1 if yes, 0 otherwise.
L
Linus Torvalds 已提交
1520
 */
1521
static int __dasd_sleep_on_erp(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
1522 1523
{
	struct dasd_device *device;
1524
	dasd_erp_fn_t erp_fn;
1525

1526 1527
	if (cqr->status == DASD_CQR_FILLED)
		return 0;
1528
	device = cqr->startdev;
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547
	if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) {
		if (cqr->status == DASD_CQR_TERMINATED) {
			device->discipline->handle_terminated_request(cqr);
			return 1;
		}
		if (cqr->status == DASD_CQR_NEED_ERP) {
			erp_fn = device->discipline->erp_action(cqr);
			erp_fn(cqr);
			return 1;
		}
		if (cqr->status == DASD_CQR_FAILED)
			dasd_log_sense(cqr, &cqr->irb);
		if (cqr->refers) {
			__dasd_process_erp(device, cqr);
			return 1;
		}
	}
	return 0;
}
1548

1549 1550 1551 1552 1553 1554 1555 1556 1557 1558
static int __dasd_sleep_on_loop_condition(struct dasd_ccw_req *cqr)
{
	if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) {
		if (cqr->refers) /* erp is not done yet */
			return 1;
		return ((cqr->status != DASD_CQR_DONE) &&
			(cqr->status != DASD_CQR_FAILED));
	} else
		return (cqr->status == DASD_CQR_FILLED);
}
1559

1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600
static int _dasd_sleep_on(struct dasd_ccw_req *maincqr, int interruptible)
{
	struct dasd_device *device;
	int rc;
	struct list_head ccw_queue;
	struct dasd_ccw_req *cqr;

	INIT_LIST_HEAD(&ccw_queue);
	maincqr->status = DASD_CQR_FILLED;
	device = maincqr->startdev;
	list_add(&maincqr->blocklist, &ccw_queue);
	for (cqr = maincqr;  __dasd_sleep_on_loop_condition(cqr);
	     cqr = list_first_entry(&ccw_queue,
				    struct dasd_ccw_req, blocklist)) {

		if (__dasd_sleep_on_erp(cqr))
			continue;
		if (cqr->status != DASD_CQR_FILLED) /* could be failed */
			continue;

		/* Non-temporary stop condition will trigger fail fast */
		if (device->stopped & ~DASD_STOPPED_PENDING &&
		    test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
		    (!dasd_eer_enabled(device))) {
			cqr->status = DASD_CQR_FAILED;
			continue;
		}

		/* Don't try to start requests if device is stopped */
		if (interruptible) {
			rc = wait_event_interruptible(
				generic_waitq, !(device->stopped));
			if (rc == -ERESTARTSYS) {
				cqr->status = DASD_CQR_FAILED;
				maincqr->intrc = rc;
				continue;
			}
		} else
			wait_event(generic_waitq, !(device->stopped));

		cqr->callback = dasd_wakeup_cb;
1601
		cqr->callback_data = DASD_SLEEPON_START_TAG;
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
		dasd_add_request_tail(cqr);
		if (interruptible) {
			rc = wait_event_interruptible(
				generic_waitq, _wait_for_wakeup(cqr));
			if (rc == -ERESTARTSYS) {
				dasd_cancel_req(cqr);
				/* wait (non-interruptible) for final status */
				wait_event(generic_waitq,
					   _wait_for_wakeup(cqr));
				cqr->status = DASD_CQR_FAILED;
				maincqr->intrc = rc;
				continue;
			}
		} else
			wait_event(generic_waitq, _wait_for_wakeup(cqr));
	}

	maincqr->endclk = get_clock();
	if ((maincqr->status != DASD_CQR_DONE) &&
	    (maincqr->intrc != -ERESTARTSYS))
		dasd_log_sense(maincqr, &maincqr->irb);
	if (maincqr->status == DASD_CQR_DONE)
1624
		rc = 0;
1625 1626
	else if (maincqr->intrc)
		rc = maincqr->intrc;
1627 1628
	else
		rc = -EIO;
L
Linus Torvalds 已提交
1629 1630 1631
	return rc;
}

1632 1633 1634 1635 1636 1637 1638 1639 1640
/*
 * Queue a request to the tail of the device ccw_queue and wait for
 * it's completion.
 */
int dasd_sleep_on(struct dasd_ccw_req *cqr)
{
	return _dasd_sleep_on(cqr, 0);
}

L
Linus Torvalds 已提交
1641
/*
1642 1643
 * Queue a request to the tail of the device ccw_queue and wait
 * interruptible for it's completion.
L
Linus Torvalds 已提交
1644
 */
1645
int dasd_sleep_on_interruptible(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
1646
{
1647
	return _dasd_sleep_on(cqr, 1);
L
Linus Torvalds 已提交
1648 1649 1650 1651 1652 1653 1654 1655
}

/*
 * Whoa nelly now it gets really hairy. For some functions (e.g. steal lock
 * for eckd devices) the currently running request has to be terminated
 * and be put back to status queued, before the special request is added
 * to the head of the queue. Then the special request is waited on normally.
 */
1656
static inline int _dasd_term_running_cqr(struct dasd_device *device)
L
Linus Torvalds 已提交
1657 1658 1659 1660 1661
{
	struct dasd_ccw_req *cqr;

	if (list_empty(&device->ccw_queue))
		return 0;
1662
	cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist);
1663
	return device->discipline->term_IO(cqr);
L
Linus Torvalds 已提交
1664 1665
}

1666
int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
1667 1668 1669
{
	struct dasd_device *device;
	int rc;
1670

1671
	device = cqr->startdev;
L
Linus Torvalds 已提交
1672 1673 1674 1675 1676 1677
	spin_lock_irq(get_ccwdev_lock(device->cdev));
	rc = _dasd_term_running_cqr(device);
	if (rc) {
		spin_unlock_irq(get_ccwdev_lock(device->cdev));
		return rc;
	}
1678

L
Linus Torvalds 已提交
1679
	cqr->callback = dasd_wakeup_cb;
1680
	cqr->callback_data = DASD_SLEEPON_START_TAG;
L
Linus Torvalds 已提交
1681
	cqr->status = DASD_CQR_QUEUED;
1682
	list_add(&cqr->devlist, &device->ccw_queue);
1683

L
Linus Torvalds 已提交
1684
	/* let the bh start the request to keep them in order */
1685
	dasd_schedule_device_bh(device);
1686

L
Linus Torvalds 已提交
1687 1688
	spin_unlock_irq(get_ccwdev_lock(device->cdev));

1689
	wait_event(generic_waitq, _wait_for_wakeup(cqr));
1690

1691 1692 1693 1694 1695 1696
	if (cqr->status == DASD_CQR_DONE)
		rc = 0;
	else if (cqr->intrc)
		rc = cqr->intrc;
	else
		rc = -EIO;
L
Linus Torvalds 已提交
1697 1698 1699 1700 1701 1702 1703 1704
	return rc;
}

/*
 * Cancels a request that was started with dasd_sleep_on_req.
 * This is useful to timeout requests. The request will be
 * terminated if it is currently in i/o.
 * Returns 1 if the request has been terminated.
1705 1706 1707 1708
 *	   0 if there was no need to terminate the request (not started yet)
 *	   negative error code if termination failed
 * Cancellation of a request is an asynchronous operation! The calling
 * function has to wait until the request is properly returned via callback.
L
Linus Torvalds 已提交
1709
 */
1710
int dasd_cancel_req(struct dasd_ccw_req *cqr)
L
Linus Torvalds 已提交
1711
{
1712
	struct dasd_device *device = cqr->startdev;
L
Linus Torvalds 已提交
1713 1714 1715 1716 1717 1718 1719
	unsigned long flags;
	int rc;

	rc = 0;
	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
	switch (cqr->status) {
	case DASD_CQR_QUEUED:
1720 1721
		/* request was not started - just set to cleared */
		cqr->status = DASD_CQR_CLEARED;
L
Linus Torvalds 已提交
1722 1723 1724
		break;
	case DASD_CQR_IN_IO:
		/* request in IO - terminate IO and release again */
1725 1726
		rc = device->discipline->term_IO(cqr);
		if (rc) {
S
Stefan Haberland 已提交
1727 1728 1729
			dev_err(&device->cdev->dev,
				"Cancelling request %p failed with rc=%d\n",
				cqr, rc);
1730 1731 1732
		} else {
			cqr->stopclk = get_clock();
		}
L
Linus Torvalds 已提交
1733
		break;
1734
	default: /* already finished or clear pending - do nothing */
L
Linus Torvalds 已提交
1735
		break;
1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
	}
	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
	dasd_schedule_device_bh(device);
	return rc;
}


/*
 * SECTION: Operations of the dasd_block layer.
 */

/*
 * Timeout function for dasd_block. This is used when the block layer
 * is waiting for something that may not come reliably, (e.g. a state
 * change interrupt)
 */
static void dasd_block_timeout(unsigned long ptr)
{
	unsigned long flags;
	struct dasd_block *block;

	block = (struct dasd_block *) ptr;
	spin_lock_irqsave(get_ccwdev_lock(block->base->cdev), flags);
	/* re-activate request queue */
1760
	dasd_device_remove_stop_bits(block->base, DASD_STOPPED_PENDING);
1761 1762 1763 1764 1765 1766 1767 1768 1769
	spin_unlock_irqrestore(get_ccwdev_lock(block->base->cdev), flags);
	dasd_schedule_block_bh(block);
}

/*
 * Setup timeout for a dasd_block in jiffies.
 */
void dasd_block_set_timer(struct dasd_block *block, int expires)
{
1770 1771 1772 1773
	if (expires == 0)
		del_timer(&block->timer);
	else
		mod_timer(&block->timer, jiffies + expires);
1774 1775 1776 1777 1778 1779 1780
}

/*
 * Clear timeout for a dasd_block.
 */
void dasd_block_clear_timer(struct dasd_block *block)
{
1781
	del_timer(&block->timer);
1782 1783 1784 1785 1786
}

/*
 * Process finished error recovery ccw.
 */
1787 1788
static void __dasd_process_erp(struct dasd_device *device,
			       struct dasd_ccw_req *cqr)
1789 1790 1791 1792 1793 1794
{
	dasd_erp_fn_t erp_fn;

	if (cqr->status == DASD_CQR_DONE)
		DBF_DEV_EVENT(DBF_NOTICE, device, "%s", "ERP successful");
	else
S
Stefan Haberland 已提交
1795
		dev_err(&device->cdev->dev, "ERP failed for the DASD\n");
1796 1797 1798
	erp_fn = device->discipline->erp_postaction(cqr);
	erp_fn(cqr);
}
L
Linus Torvalds 已提交
1799

1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822
/*
 * Fetch requests from the block device queue.
 */
static void __dasd_process_request_queue(struct dasd_block *block)
{
	struct request_queue *queue;
	struct request *req;
	struct dasd_ccw_req *cqr;
	struct dasd_device *basedev;
	unsigned long flags;
	queue = block->request_queue;
	basedev = block->base;
	/* No queue ? Then there is nothing to do. */
	if (queue == NULL)
		return;

	/*
	 * We requeue request from the block device queue to the ccw
	 * queue only in two states. In state DASD_STATE_READY the
	 * partition detection is done and we need to requeue requests
	 * for that. State DASD_STATE_ONLINE is normal block device
	 * operation.
	 */
1823 1824 1825
	if (basedev->state < DASD_STATE_READY) {
		while ((req = blk_fetch_request(block->request_queue)))
			__blk_end_request_all(req, -EIO);
1826
		return;
1827
	}
1828
	/* Now we try to fetch requests from the request queue */
1829
	while (!blk_queue_plugged(queue) && (req = blk_peek_request(queue))) {
1830 1831 1832 1833 1834
		if (basedev->features & DASD_FEATURE_READONLY &&
		    rq_data_dir(req) == WRITE) {
			DBF_DEV_EVENT(DBF_ERR, basedev,
				      "Rejecting write request %p",
				      req);
1835
			blk_start_request(req);
1836
			__blk_end_request_all(req, -EIO);
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853
			continue;
		}
		cqr = basedev->discipline->build_cp(basedev, block, req);
		if (IS_ERR(cqr)) {
			if (PTR_ERR(cqr) == -EBUSY)
				break;	/* normal end condition */
			if (PTR_ERR(cqr) == -ENOMEM)
				break;	/* terminate request queue loop */
			if (PTR_ERR(cqr) == -EAGAIN) {
				/*
				 * The current request cannot be build right
				 * now, we have to try later. If this request
				 * is the head-of-queue we stop the device
				 * for 1/2 second.
				 */
				if (!list_empty(&block->ccw_queue))
					break;
1854 1855 1856 1857 1858 1859
				spin_lock_irqsave(
					get_ccwdev_lock(basedev->cdev), flags);
				dasd_device_set_stop_bits(basedev,
							  DASD_STOPPED_PENDING);
				spin_unlock_irqrestore(
					get_ccwdev_lock(basedev->cdev), flags);
1860 1861 1862 1863 1864 1865 1866
				dasd_block_set_timer(block, HZ/2);
				break;
			}
			DBF_DEV_EVENT(DBF_ERR, basedev,
				      "CCW creation failed (rc=%ld) "
				      "on request %p",
				      PTR_ERR(cqr), req);
1867
			blk_start_request(req);
1868
			__blk_end_request_all(req, -EIO);
1869 1870 1871 1872 1873 1874 1875 1876
			continue;
		}
		/*
		 *  Note: callback is set to dasd_return_cqr_cb in
		 * __dasd_block_start_head to cover erp requests as well
		 */
		cqr->callback_data = (void *) req;
		cqr->status = DASD_CQR_FILLED;
1877
		blk_start_request(req);
1878 1879 1880 1881 1882 1883 1884 1885 1886
		list_add_tail(&cqr->blocklist, &block->ccw_queue);
		dasd_profile_start(block, cqr, req);
	}
}

static void __dasd_cleanup_cqr(struct dasd_ccw_req *cqr)
{
	struct request *req;
	int status;
1887
	int error = 0;
1888 1889 1890

	req = (struct request *) cqr->callback_data;
	dasd_profile_end(cqr->block, cqr, req);
1891
	status = cqr->block->base->discipline->free_cp(cqr, req);
1892 1893
	if (status <= 0)
		error = status ? status : -EIO;
1894
	__blk_end_request_all(req, error);
1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925
}

/*
 * Process ccw request queue.
 */
static void __dasd_process_block_ccw_queue(struct dasd_block *block,
					   struct list_head *final_queue)
{
	struct list_head *l, *n;
	struct dasd_ccw_req *cqr;
	dasd_erp_fn_t erp_fn;
	unsigned long flags;
	struct dasd_device *base = block->base;

restart:
	/* Process request with final status. */
	list_for_each_safe(l, n, &block->ccw_queue) {
		cqr = list_entry(l, struct dasd_ccw_req, blocklist);
		if (cqr->status != DASD_CQR_DONE &&
		    cqr->status != DASD_CQR_FAILED &&
		    cqr->status != DASD_CQR_NEED_ERP &&
		    cqr->status != DASD_CQR_TERMINATED)
			continue;

		if (cqr->status == DASD_CQR_TERMINATED) {
			base->discipline->handle_terminated_request(cqr);
			goto restart;
		}

		/*  Process requests that may be recovered */
		if (cqr->status == DASD_CQR_NEED_ERP) {
1926
			erp_fn = base->discipline->erp_action(cqr);
1927 1928
			if (IS_ERR(erp_fn(cqr)))
				continue;
1929 1930 1931
			goto restart;
		}

1932 1933 1934 1935 1936
		/* log sense for fatal error */
		if (cqr->status == DASD_CQR_FAILED) {
			dasd_log_sense(cqr, &cqr->irb);
		}

1937 1938 1939 1940 1941 1942 1943 1944 1945
		/* First of all call extended error reporting. */
		if (dasd_eer_enabled(base) &&
		    cqr->status == DASD_CQR_FAILED) {
			dasd_eer_write(base, cqr, DASD_EER_FATALERROR);

			/* restart request  */
			cqr->status = DASD_CQR_FILLED;
			cqr->retries = 255;
			spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
1946
			dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE);
1947 1948 1949 1950 1951 1952 1953
			spin_unlock_irqrestore(get_ccwdev_lock(base->cdev),
					       flags);
			goto restart;
		}

		/* Process finished ERP request. */
		if (cqr->refers) {
1954
			__dasd_process_erp(base, cqr);
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083
			goto restart;
		}

		/* Rechain finished requests to final queue */
		cqr->endclk = get_clock();
		list_move_tail(&cqr->blocklist, final_queue);
	}
}

static void dasd_return_cqr_cb(struct dasd_ccw_req *cqr, void *data)
{
	dasd_schedule_block_bh(cqr->block);
}

static void __dasd_block_start_head(struct dasd_block *block)
{
	struct dasd_ccw_req *cqr;

	if (list_empty(&block->ccw_queue))
		return;
	/* We allways begin with the first requests on the queue, as some
	 * of previously started requests have to be enqueued on a
	 * dasd_device again for error recovery.
	 */
	list_for_each_entry(cqr, &block->ccw_queue, blocklist) {
		if (cqr->status != DASD_CQR_FILLED)
			continue;
		/* Non-temporary stop condition will trigger fail fast */
		if (block->base->stopped & ~DASD_STOPPED_PENDING &&
		    test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
		    (!dasd_eer_enabled(block->base))) {
			cqr->status = DASD_CQR_FAILED;
			dasd_schedule_block_bh(block);
			continue;
		}
		/* Don't try to start requests if device is stopped */
		if (block->base->stopped)
			return;

		/* just a fail safe check, should not happen */
		if (!cqr->startdev)
			cqr->startdev = block->base;

		/* make sure that the requests we submit find their way back */
		cqr->callback = dasd_return_cqr_cb;

		dasd_add_request_tail(cqr);
	}
}

/*
 * Central dasd_block layer routine. Takes requests from the generic
 * block layer request queue, creates ccw requests, enqueues them on
 * a dasd_device and processes ccw requests that have been returned.
 */
static void dasd_block_tasklet(struct dasd_block *block)
{
	struct list_head final_queue;
	struct list_head *l, *n;
	struct dasd_ccw_req *cqr;

	atomic_set(&block->tasklet_scheduled, 0);
	INIT_LIST_HEAD(&final_queue);
	spin_lock(&block->queue_lock);
	/* Finish off requests on ccw queue */
	__dasd_process_block_ccw_queue(block, &final_queue);
	spin_unlock(&block->queue_lock);
	/* Now call the callback function of requests with final status */
	spin_lock_irq(&block->request_queue_lock);
	list_for_each_safe(l, n, &final_queue) {
		cqr = list_entry(l, struct dasd_ccw_req, blocklist);
		list_del_init(&cqr->blocklist);
		__dasd_cleanup_cqr(cqr);
	}
	spin_lock(&block->queue_lock);
	/* Get new request from the block device request queue */
	__dasd_process_request_queue(block);
	/* Now check if the head of the ccw queue needs to be started. */
	__dasd_block_start_head(block);
	spin_unlock(&block->queue_lock);
	spin_unlock_irq(&block->request_queue_lock);
	dasd_put_device(block->base);
}

static void _dasd_wake_block_flush_cb(struct dasd_ccw_req *cqr, void *data)
{
	wake_up(&dasd_flush_wq);
}

/*
 * Go through all request on the dasd_block request queue, cancel them
 * on the respective dasd_device, and return them to the generic
 * block layer.
 */
static int dasd_flush_block_queue(struct dasd_block *block)
{
	struct dasd_ccw_req *cqr, *n;
	int rc, i;
	struct list_head flush_queue;

	INIT_LIST_HEAD(&flush_queue);
	spin_lock_bh(&block->queue_lock);
	rc = 0;
restart:
	list_for_each_entry_safe(cqr, n, &block->ccw_queue, blocklist) {
		/* if this request currently owned by a dasd_device cancel it */
		if (cqr->status >= DASD_CQR_QUEUED)
			rc = dasd_cancel_req(cqr);
		if (rc < 0)
			break;
		/* Rechain request (including erp chain) so it won't be
		 * touched by the dasd_block_tasklet anymore.
		 * Replace the callback so we notice when the request
		 * is returned from the dasd_device layer.
		 */
		cqr->callback = _dasd_wake_block_flush_cb;
		for (i = 0; cqr != NULL; cqr = cqr->refers, i++)
			list_move_tail(&cqr->blocklist, &flush_queue);
		if (i > 1)
			/* moved more than one request - need to restart */
			goto restart;
	}
	spin_unlock_bh(&block->queue_lock);
	/* Now call the callback function of flushed requests */
restart_cb:
	list_for_each_entry_safe(cqr, n, &flush_queue, blocklist) {
		wait_event(dasd_flush_wq, (cqr->status < DASD_CQR_QUEUED));
		/* Process finished ERP request. */
		if (cqr->refers) {
2084
			spin_lock_bh(&block->queue_lock);
2085
			__dasd_process_erp(block->base, cqr);
2086
			spin_unlock_bh(&block->queue_lock);
2087 2088 2089 2090 2091
			/* restart list_for_xx loop since dasd_process_erp
			 * might remove multiple elements */
			goto restart_cb;
		}
		/* call the callback function */
2092
		spin_lock_irq(&block->request_queue_lock);
2093 2094 2095
		cqr->endclk = get_clock();
		list_del_init(&cqr->blocklist);
		__dasd_cleanup_cqr(cqr);
2096
		spin_unlock_irq(&block->request_queue_lock);
L
Linus Torvalds 已提交
2097 2098 2099 2100 2101
	}
	return rc;
}

/*
2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
 * Schedules a call to dasd_tasklet over the device tasklet.
 */
void dasd_schedule_block_bh(struct dasd_block *block)
{
	/* Protect against rescheduling. */
	if (atomic_cmpxchg(&block->tasklet_scheduled, 0, 1) != 0)
		return;
	/* life cycle of block is bound to it's base device */
	dasd_get_device(block->base);
	tasklet_hi_schedule(&block->tasklet);
}


/*
 * SECTION: external block device operations
 * (request queue handling, open, release, etc.)
L
Linus Torvalds 已提交
2118 2119 2120 2121 2122
 */

/*
 * Dasd request queue function. Called from ll_rw_blk.c
 */
2123
static void do_dasd_request(struct request_queue *queue)
L
Linus Torvalds 已提交
2124
{
2125
	struct dasd_block *block;
L
Linus Torvalds 已提交
2126

2127 2128
	block = queue->queuedata;
	spin_lock(&block->queue_lock);
L
Linus Torvalds 已提交
2129
	/* Get new request from the block device request queue */
2130
	__dasd_process_request_queue(block);
L
Linus Torvalds 已提交
2131
	/* Now check if the head of the ccw queue needs to be started. */
2132 2133
	__dasd_block_start_head(block);
	spin_unlock(&block->queue_lock);
L
Linus Torvalds 已提交
2134 2135 2136 2137 2138
}

/*
 * Allocate and initialize request queue and default I/O scheduler.
 */
2139
static int dasd_alloc_queue(struct dasd_block *block)
L
Linus Torvalds 已提交
2140 2141 2142
{
	int rc;

2143 2144 2145
	block->request_queue = blk_init_queue(do_dasd_request,
					       &block->request_queue_lock);
	if (block->request_queue == NULL)
L
Linus Torvalds 已提交
2146 2147
		return -ENOMEM;

2148
	block->request_queue->queuedata = block;
L
Linus Torvalds 已提交
2149

2150
	elevator_exit(block->request_queue->elevator);
2151
	block->request_queue->elevator = NULL;
2152
	rc = elevator_init(block->request_queue, "deadline");
L
Linus Torvalds 已提交
2153
	if (rc) {
2154
		blk_cleanup_queue(block->request_queue);
L
Linus Torvalds 已提交
2155 2156 2157 2158 2159 2160 2161 2162
		return rc;
	}
	return 0;
}

/*
 * Allocate and initialize request queue.
 */
2163
static void dasd_setup_queue(struct dasd_block *block)
L
Linus Torvalds 已提交
2164 2165 2166
{
	int max;

2167
	blk_queue_logical_block_size(block->request_queue, block->bp_block);
2168
	max = block->base->discipline->max_blocks << block->s2b_shift;
2169
	blk_queue_max_hw_sectors(block->request_queue, max);
2170
	blk_queue_max_segments(block->request_queue, -1L);
2171 2172 2173 2174 2175
	/* with page sized segments we can translate each segement into
	 * one idaw/tidaw
	 */
	blk_queue_max_segment_size(block->request_queue, PAGE_SIZE);
	blk_queue_segment_boundary(block->request_queue, PAGE_SIZE - 1);
2176
	blk_queue_ordered(block->request_queue, QUEUE_ORDERED_DRAIN, NULL);
L
Linus Torvalds 已提交
2177 2178 2179 2180 2181
}

/*
 * Deactivate and free request queue.
 */
2182
static void dasd_free_queue(struct dasd_block *block)
L
Linus Torvalds 已提交
2183
{
2184 2185 2186
	if (block->request_queue) {
		blk_cleanup_queue(block->request_queue);
		block->request_queue = NULL;
L
Linus Torvalds 已提交
2187 2188 2189 2190 2191 2192
	}
}

/*
 * Flush request on the request queue.
 */
2193
static void dasd_flush_request_queue(struct dasd_block *block)
L
Linus Torvalds 已提交
2194 2195 2196
{
	struct request *req;

2197
	if (!block->request_queue)
L
Linus Torvalds 已提交
2198
		return;
2199

2200
	spin_lock_irq(&block->request_queue_lock);
2201
	while ((req = blk_fetch_request(block->request_queue)))
2202
		__blk_end_request_all(req, -EIO);
2203
	spin_unlock_irq(&block->request_queue_lock);
L
Linus Torvalds 已提交
2204 2205
}

A
Al Viro 已提交
2206
static int dasd_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
2207
{
A
Al Viro 已提交
2208
	struct dasd_block *block = bdev->bd_disk->private_data;
2209
	struct dasd_device *base;
L
Linus Torvalds 已提交
2210 2211
	int rc;

2212 2213 2214 2215
	if (!block)
		return -ENODEV;

	base = block->base;
2216 2217
	atomic_inc(&block->open_count);
	if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) {
L
Linus Torvalds 已提交
2218 2219 2220 2221
		rc = -ENODEV;
		goto unlock;
	}

2222
	if (!try_module_get(base->discipline->owner)) {
L
Linus Torvalds 已提交
2223 2224 2225 2226 2227
		rc = -EINVAL;
		goto unlock;
	}

	if (dasd_probeonly) {
S
Stefan Haberland 已提交
2228 2229 2230
		dev_info(&base->cdev->dev,
			 "Accessing the DASD failed because it is in "
			 "probeonly mode\n");
L
Linus Torvalds 已提交
2231 2232 2233 2234
		rc = -EPERM;
		goto out;
	}

2235 2236
	if (base->state <= DASD_STATE_BASIC) {
		DBF_DEV_EVENT(DBF_ERR, base, " %s",
L
Linus Torvalds 已提交
2237 2238 2239 2240 2241
			      " Cannot open unrecognized device");
		rc = -ENODEV;
		goto out;
	}

2242 2243 2244 2245 2246 2247 2248
	if ((mode & FMODE_WRITE) &&
	    (test_bit(DASD_FLAG_DEVICE_RO, &base->flags) ||
	     (base->features & DASD_FEATURE_READONLY))) {
		rc = -EROFS;
		goto out;
	}

L
Linus Torvalds 已提交
2249 2250 2251
	return 0;

out:
2252
	module_put(base->discipline->owner);
L
Linus Torvalds 已提交
2253
unlock:
2254
	atomic_dec(&block->open_count);
L
Linus Torvalds 已提交
2255 2256 2257
	return rc;
}

A
Al Viro 已提交
2258
static int dasd_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
2259
{
2260
	struct dasd_block *block = disk->private_data;
L
Linus Torvalds 已提交
2261

2262 2263
	atomic_dec(&block->open_count);
	module_put(block->base->discipline->owner);
L
Linus Torvalds 已提交
2264 2265 2266
	return 0;
}

2267 2268 2269
/*
 * Return disk geometry.
 */
2270
static int dasd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
2271
{
2272 2273
	struct dasd_block *block;
	struct dasd_device *base;
2274

2275 2276
	block = bdev->bd_disk->private_data;
	if (!block)
2277
		return -ENODEV;
2278
	base = block->base;
2279

2280 2281
	if (!base->discipline ||
	    !base->discipline->fill_geometry)
2282 2283
		return -EINVAL;

2284 2285
	base->discipline->fill_geometry(block, geo);
	geo->start = get_start_sect(bdev) >> block->s2b_shift;
2286 2287 2288
	return 0;
}

2289
const struct block_device_operations
L
Linus Torvalds 已提交
2290 2291
dasd_device_operations = {
	.owner		= THIS_MODULE,
A
Al Viro 已提交
2292 2293
	.open		= dasd_open,
	.release	= dasd_release,
2294 2295
	.ioctl		= dasd_ioctl,
	.compat_ioctl	= dasd_ioctl,
2296
	.getgeo		= dasd_getgeo,
L
Linus Torvalds 已提交
2297 2298
};

2299 2300 2301
/*******************************************************************************
 * end of block device operations
 */
L
Linus Torvalds 已提交
2302 2303 2304 2305 2306 2307 2308

static void
dasd_exit(void)
{
#ifdef CONFIG_PROC_FS
	dasd_proc_exit();
#endif
2309
	dasd_eer_exit();
2310 2311 2312 2313
        if (dasd_page_cache != NULL) {
		kmem_cache_destroy(dasd_page_cache);
		dasd_page_cache = NULL;
	}
L
Linus Torvalds 已提交
2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325
	dasd_gendisk_exit();
	dasd_devmap_exit();
	if (dasd_debug_area != NULL) {
		debug_unregister(dasd_debug_area);
		dasd_debug_area = NULL;
	}
}

/*
 * SECTION: common functions for ccw_driver use
 */

2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353
/*
 * Is the device read-only?
 * Note that this function does not report the setting of the
 * readonly device attribute, but how it is configured in z/VM.
 */
int dasd_device_is_ro(struct dasd_device *device)
{
	struct ccw_dev_id dev_id;
	struct diag210 diag_data;
	int rc;

	if (!MACHINE_IS_VM)
		return 0;
	ccw_device_get_id(device->cdev, &dev_id);
	memset(&diag_data, 0, sizeof(diag_data));
	diag_data.vrdcdvno = dev_id.devno;
	diag_data.vrdclen = sizeof(diag_data);
	rc = diag210(&diag_data);
	if (rc == 0 || rc == 2) {
		return diag_data.vrdcvfla & 0x80;
	} else {
		DBF_EVENT(DBF_WARNING, "diag210 failed for dev=%04x with rc=%d",
			  dev_id.devno, rc);
		return 0;
	}
}
EXPORT_SYMBOL_GPL(dasd_device_is_ro);

2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
static void dasd_generic_auto_online(void *data, async_cookie_t cookie)
{
	struct ccw_device *cdev = data;
	int ret;

	ret = ccw_device_set_online(cdev);
	if (ret)
		pr_warning("%s: Setting the DASD online failed with rc=%d\n",
			   dev_name(&cdev->dev), ret);
}

2365 2366 2367 2368
/*
 * Initial attempt at a probe function. this can be simplified once
 * the other detection code is gone.
 */
2369 2370
int dasd_generic_probe(struct ccw_device *cdev,
		       struct dasd_discipline *discipline)
L
Linus Torvalds 已提交
2371 2372 2373 2374 2375
{
	int ret;

	ret = dasd_add_sysfs_files(cdev);
	if (ret) {
2376 2377 2378
		DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s",
				"dasd_generic_probe: could not add "
				"sysfs entries");
2379
		return ret;
L
Linus Torvalds 已提交
2380
	}
2381
	cdev->handler = &dasd_int_handler;
L
Linus Torvalds 已提交
2382

2383 2384 2385 2386 2387 2388
	/*
	 * Automatically online either all dasd devices (dasd_autodetect)
	 * or all devices specified with dasd= parameters during
	 * initial probe.
	 */
	if ((dasd_get_feature(cdev, DASD_FEATURE_INITIAL_ONLINE) > 0 ) ||
2389
	    (dasd_autodetect && dasd_busid_known(dev_name(&cdev->dev)) != 0))
2390
		async_schedule(dasd_generic_auto_online, cdev);
2391
	return 0;
L
Linus Torvalds 已提交
2392 2393
}

2394 2395 2396 2397
/*
 * This will one day be called from a global not_oper handler.
 * It is also used by driver_unregister during module unload.
 */
2398
void dasd_generic_remove(struct ccw_device *cdev)
L
Linus Torvalds 已提交
2399 2400
{
	struct dasd_device *device;
2401
	struct dasd_block *block;
L
Linus Torvalds 已提交
2402

2403 2404
	cdev->handler = NULL;

L
Linus Torvalds 已提交
2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
	dasd_remove_sysfs_files(cdev);
	device = dasd_device_from_cdev(cdev);
	if (IS_ERR(device))
		return;
	if (test_and_set_bit(DASD_FLAG_OFFLINE, &device->flags)) {
		/* Already doing offline processing */
		dasd_put_device(device);
		return;
	}
	/*
	 * This device is removed unconditionally. Set offline
	 * flag to prevent dasd_open from opening it while it is
	 * no quite down yet.
	 */
	dasd_set_target_state(device, DASD_STATE_NEW);
	/* dasd_delete_device destroys the device reference. */
2421 2422
	block = device->block;
	device->block = NULL;
L
Linus Torvalds 已提交
2423
	dasd_delete_device(device);
2424 2425 2426 2427 2428 2429
	/*
	 * life cycle of block is bound to device, so delete it after
	 * device was safely removed
	 */
	if (block)
		dasd_free_block(block);
L
Linus Torvalds 已提交
2430 2431
}

2432 2433
/*
 * Activate a device. This is called from dasd_{eckd,fba}_probe() when either
L
Linus Torvalds 已提交
2434
 * the device is detected for the first time and is supposed to be used
2435 2436
 * or the user has started activation through sysfs.
 */
2437 2438
int dasd_generic_set_online(struct ccw_device *cdev,
			    struct dasd_discipline *base_discipline)
L
Linus Torvalds 已提交
2439
{
2440
	struct dasd_discipline *discipline;
L
Linus Torvalds 已提交
2441
	struct dasd_device *device;
2442
	int rc;
2443

2444 2445
	/* first online clears initial online feature flag */
	dasd_set_feature(cdev, DASD_FEATURE_INITIAL_ONLINE, 0);
L
Linus Torvalds 已提交
2446 2447 2448 2449
	device = dasd_create_device(cdev);
	if (IS_ERR(device))
		return PTR_ERR(device);

2450
	discipline = base_discipline;
2451
	if (device->features & DASD_FEATURE_USEDIAG) {
L
Linus Torvalds 已提交
2452
	  	if (!dasd_diag_discipline_pointer) {
S
Stefan Haberland 已提交
2453 2454 2455
			pr_warning("%s Setting the DASD online failed because "
				   "of missing DIAG discipline\n",
				   dev_name(&cdev->dev));
L
Linus Torvalds 已提交
2456 2457 2458 2459 2460
			dasd_delete_device(device);
			return -ENODEV;
		}
		discipline = dasd_diag_discipline_pointer;
	}
2461 2462 2463 2464 2465 2466 2467 2468 2469 2470
	if (!try_module_get(base_discipline->owner)) {
		dasd_delete_device(device);
		return -EINVAL;
	}
	if (!try_module_get(discipline->owner)) {
		module_put(base_discipline->owner);
		dasd_delete_device(device);
		return -EINVAL;
	}
	device->base_discipline = base_discipline;
L
Linus Torvalds 已提交
2471 2472
	device->discipline = discipline;

2473
	/* check_device will allocate block device if necessary */
L
Linus Torvalds 已提交
2474 2475
	rc = discipline->check_device(device);
	if (rc) {
S
Stefan Haberland 已提交
2476 2477 2478
		pr_warning("%s Setting the DASD online with discipline %s "
			   "failed with rc=%i\n",
			   dev_name(&cdev->dev), discipline->name, rc);
2479 2480
		module_put(discipline->owner);
		module_put(base_discipline->owner);
L
Linus Torvalds 已提交
2481 2482 2483 2484 2485 2486
		dasd_delete_device(device);
		return rc;
	}

	dasd_set_target_state(device, DASD_STATE_ONLINE);
	if (device->state <= DASD_STATE_KNOWN) {
S
Stefan Haberland 已提交
2487 2488
		pr_warning("%s Setting the DASD online failed because of a "
			   "missing discipline\n", dev_name(&cdev->dev));
L
Linus Torvalds 已提交
2489 2490
		rc = -ENODEV;
		dasd_set_target_state(device, DASD_STATE_NEW);
2491 2492
		if (device->block)
			dasd_free_block(device->block);
L
Linus Torvalds 已提交
2493 2494 2495
		dasd_delete_device(device);
	} else
		pr_debug("dasd_generic device %s found\n",
2496
				dev_name(&cdev->dev));
S
Stefan Haberland 已提交
2497 2498 2499

	wait_event(dasd_init_waitq, _wait_for_device(device));

L
Linus Torvalds 已提交
2500 2501 2502 2503
	dasd_put_device(device);
	return rc;
}

2504
int dasd_generic_set_offline(struct ccw_device *cdev)
L
Linus Torvalds 已提交
2505 2506
{
	struct dasd_device *device;
2507
	struct dasd_block *block;
2508
	int max_count, open_count;
L
Linus Torvalds 已提交
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523

	device = dasd_device_from_cdev(cdev);
	if (IS_ERR(device))
		return PTR_ERR(device);
	if (test_and_set_bit(DASD_FLAG_OFFLINE, &device->flags)) {
		/* Already doing offline processing */
		dasd_put_device(device);
		return 0;
	}
	/*
	 * We must make sure that this device is currently not in use.
	 * The open_count is increased for every opener, that includes
	 * the blkdev_get in dasd_scan_partitions. We are only interested
	 * in the other openers.
	 */
2524
	if (device->block) {
2525 2526
		max_count = device->block->bdev ? 0 : -1;
		open_count = atomic_read(&device->block->open_count);
2527 2528
		if (open_count > max_count) {
			if (open_count > 0)
S
Stefan Haberland 已提交
2529 2530 2531
				pr_warning("%s: The DASD cannot be set offline "
					   "with open count %i\n",
					   dev_name(&cdev->dev), open_count);
2532
			else
S
Stefan Haberland 已提交
2533 2534 2535
				pr_warning("%s: The DASD cannot be set offline "
					   "while it is in use\n",
					   dev_name(&cdev->dev));
2536 2537 2538 2539
			clear_bit(DASD_FLAG_OFFLINE, &device->flags);
			dasd_put_device(device);
			return -EBUSY;
		}
L
Linus Torvalds 已提交
2540 2541 2542
	}
	dasd_set_target_state(device, DASD_STATE_NEW);
	/* dasd_delete_device destroys the device reference. */
2543 2544
	block = device->block;
	device->block = NULL;
L
Linus Torvalds 已提交
2545
	dasd_delete_device(device);
2546 2547 2548 2549 2550 2551
	/*
	 * life cycle of block is bound to device, so delete it after
	 * device was safely removed
	 */
	if (block)
		dasd_free_block(block);
L
Linus Torvalds 已提交
2552 2553 2554
	return 0;
}

2555
int dasd_generic_notify(struct ccw_device *cdev, int event)
L
Linus Torvalds 已提交
2556 2557 2558 2559 2560
{
	struct dasd_device *device;
	struct dasd_ccw_req *cqr;
	int ret;

2561
	device = dasd_device_from_cdev_locked(cdev);
L
Linus Torvalds 已提交
2562 2563 2564 2565 2566
	if (IS_ERR(device))
		return 0;
	ret = 0;
	switch (event) {
	case CIO_GONE:
2567
	case CIO_BOXED:
L
Linus Torvalds 已提交
2568
	case CIO_NO_PATH:
2569 2570 2571
		/* First of all call extended error reporting. */
		dasd_eer_write(device, NULL, DASD_EER_NOPATH);

L
Linus Torvalds 已提交
2572 2573 2574
		if (device->state < DASD_STATE_BASIC)
			break;
		/* Device is active. We want to keep it. */
2575 2576 2577 2578 2579
		list_for_each_entry(cqr, &device->ccw_queue, devlist)
			if (cqr->status == DASD_CQR_IN_IO) {
				cqr->status = DASD_CQR_QUEUED;
				cqr->retries++;
			}
2580
		dasd_device_set_stop_bits(device, DASD_STOPPED_DC_WAIT);
2581 2582
		dasd_device_clear_timer(device);
		dasd_schedule_device_bh(device);
L
Linus Torvalds 已提交
2583 2584 2585 2586
		ret = 1;
		break;
	case CIO_OPER:
		/* FIXME: add a sanity check. */
2587
		dasd_device_remove_stop_bits(device, DASD_STOPPED_DC_WAIT);
2588
		if (device->stopped & DASD_UNRESUMED_PM) {
2589
			dasd_device_remove_stop_bits(device, DASD_UNRESUMED_PM);
2590 2591 2592 2593
			dasd_restore_device(device);
			ret = 1;
			break;
		}
2594 2595 2596
		dasd_schedule_device_bh(device);
		if (device->block)
			dasd_schedule_block_bh(device->block);
L
Linus Torvalds 已提交
2597 2598 2599 2600 2601 2602 2603
		ret = 1;
		break;
	}
	dasd_put_device(device);
	return ret;
}

2604 2605 2606 2607 2608 2609 2610 2611 2612 2613
int dasd_generic_pm_freeze(struct ccw_device *cdev)
{
	struct dasd_ccw_req *cqr, *n;
	int rc;
	struct list_head freeze_queue;
	struct dasd_device *device = dasd_device_from_cdev(cdev);

	if (IS_ERR(device))
		return PTR_ERR(device);
	/* disallow new I/O  */
2614
	dasd_device_set_stop_bits(device, DASD_STOPPED_PM);
2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664
	/* clear active requests */
	INIT_LIST_HEAD(&freeze_queue);
	spin_lock_irq(get_ccwdev_lock(cdev));
	rc = 0;
	list_for_each_entry_safe(cqr, n, &device->ccw_queue, devlist) {
		/* Check status and move request to flush_queue */
		if (cqr->status == DASD_CQR_IN_IO) {
			rc = device->discipline->term_IO(cqr);
			if (rc) {
				/* unable to terminate requeust */
				dev_err(&device->cdev->dev,
					"Unable to terminate request %p "
					"on suspend\n", cqr);
				spin_unlock_irq(get_ccwdev_lock(cdev));
				dasd_put_device(device);
				return rc;
			}
		}
		list_move_tail(&cqr->devlist, &freeze_queue);
	}

	spin_unlock_irq(get_ccwdev_lock(cdev));

	list_for_each_entry_safe(cqr, n, &freeze_queue, devlist) {
		wait_event(dasd_flush_wq,
			   (cqr->status != DASD_CQR_CLEAR_PENDING));
		if (cqr->status == DASD_CQR_CLEARED)
			cqr->status = DASD_CQR_QUEUED;
	}
	/* move freeze_queue to start of the ccw_queue */
	spin_lock_irq(get_ccwdev_lock(cdev));
	list_splice_tail(&freeze_queue, &device->ccw_queue);
	spin_unlock_irq(get_ccwdev_lock(cdev));

	if (device->discipline->freeze)
		rc = device->discipline->freeze(device);

	dasd_put_device(device);
	return rc;
}
EXPORT_SYMBOL_GPL(dasd_generic_pm_freeze);

int dasd_generic_restore_device(struct ccw_device *cdev)
{
	struct dasd_device *device = dasd_device_from_cdev(cdev);
	int rc = 0;

	if (IS_ERR(device))
		return PTR_ERR(device);

2665
	/* allow new IO again */
2666 2667
	dasd_device_remove_stop_bits(device,
				     (DASD_STOPPED_PM | DASD_UNRESUMED_PM));
2668

2669 2670
	dasd_schedule_device_bh(device);

2671 2672 2673 2674 2675
	/*
	 * call discipline restore function
	 * if device is stopped do nothing e.g. for disconnected devices
	 */
	if (device->discipline->restore && !(device->stopped))
2676
		rc = device->discipline->restore(device);
2677
	if (rc || device->stopped)
2678 2679 2680 2681 2682
		/*
		 * if the resume failed for the DASD we put it in
		 * an UNRESUMED stop state
		 */
		device->stopped |= DASD_UNRESUMED_PM;
2683

2684 2685 2686
	if (device->block)
		dasd_schedule_block_bh(device->block);

2687
	dasd_put_device(device);
2688
	return 0;
2689 2690 2691
}
EXPORT_SYMBOL_GPL(dasd_generic_restore_device);

H
Heiko Carstens 已提交
2692 2693 2694
static struct dasd_ccw_req *dasd_generic_build_rdc(struct dasd_device *device,
						   void *rdc_buffer,
						   int rdc_buffer_size,
2695
						   int magic)
2696 2697 2698
{
	struct dasd_ccw_req *cqr;
	struct ccw1 *ccw;
2699
	unsigned long *idaw;
2700 2701 2702 2703

	cqr = dasd_smalloc_request(magic, 1 /* RDC */, rdc_buffer_size, device);

	if (IS_ERR(cqr)) {
S
Stefan Haberland 已提交
2704 2705 2706 2707
		/* internal error 13 - Allocating the RDC request failed*/
		dev_err(&device->cdev->dev,
			 "An error occurred in the DASD device driver, "
			 "reason=%s\n", "13");
2708 2709 2710 2711 2712
		return cqr;
	}

	ccw = cqr->cpaddr;
	ccw->cmd_code = CCW_CMD_RDC;
2713 2714 2715 2716 2717 2718 2719 2720 2721
	if (idal_is_needed(rdc_buffer, rdc_buffer_size)) {
		idaw = (unsigned long *) (cqr->data);
		ccw->cda = (__u32)(addr_t) idaw;
		ccw->flags = CCW_FLAG_IDA;
		idaw = idal_create_words(idaw, rdc_buffer, rdc_buffer_size);
	} else {
		ccw->cda = (__u32)(addr_t) rdc_buffer;
		ccw->flags = 0;
	}
2722

2723
	ccw->count = rdc_buffer_size;
2724 2725
	cqr->startdev = device;
	cqr->memdev = device;
2726
	cqr->expires = 10*HZ;
2727
	cqr->retries = 256;
2728 2729 2730 2731 2732 2733
	cqr->buildclk = get_clock();
	cqr->status = DASD_CQR_FILLED;
	return cqr;
}


2734
int dasd_generic_read_dev_chars(struct dasd_device *device, int magic,
2735
				void *rdc_buffer, int rdc_buffer_size)
2736 2737 2738 2739
{
	int ret;
	struct dasd_ccw_req *cqr;

2740
	cqr = dasd_generic_build_rdc(device, rdc_buffer, rdc_buffer_size,
2741 2742 2743 2744 2745
				     magic);
	if (IS_ERR(cqr))
		return PTR_ERR(cqr);

	ret = dasd_sleep_on(cqr);
2746
	dasd_sfree_request(cqr, cqr->memdev);
2747 2748
	return ret;
}
C
Cornelia Huck 已提交
2749
EXPORT_SYMBOL_GPL(dasd_generic_read_dev_chars);
2750

2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784
/*
 *   In command mode and transport mode we need to look for sense
 *   data in different places. The sense data itself is allways
 *   an array of 32 bytes, so we can unify the sense data access
 *   for both modes.
 */
char *dasd_get_sense(struct irb *irb)
{
	struct tsb *tsb = NULL;
	char *sense = NULL;

	if (scsw_is_tm(&irb->scsw) && (irb->scsw.tm.fcxs == 0x01)) {
		if (irb->scsw.tm.tcw)
			tsb = tcw_get_tsb((struct tcw *)(unsigned long)
					  irb->scsw.tm.tcw);
		if (tsb && tsb->length == 64 && tsb->flags)
			switch (tsb->flags & 0x07) {
			case 1:	/* tsa_iostat */
				sense = tsb->tsa.iostat.sense;
				break;
			case 2: /* tsa_ddpc */
				sense = tsb->tsa.ddpc.sense;
				break;
			default:
				/* currently we don't use interrogate data */
				break;
			}
	} else if (irb->esw.esw0.erw.cons) {
		sense = irb->ecw;
	}
	return sense;
}
EXPORT_SYMBOL_GPL(dasd_get_sense);

2785
static int __init dasd_init(void)
L
Linus Torvalds 已提交
2786 2787 2788 2789
{
	int rc;

	init_waitqueue_head(&dasd_init_waitq);
2790
	init_waitqueue_head(&dasd_flush_wq);
2791
	init_waitqueue_head(&generic_waitq);
L
Linus Torvalds 已提交
2792 2793

	/* register 'common' DASD debug area, used for all DBF_XXX calls */
2794
	dasd_debug_area = debug_register("dasd", 1, 1, 8 * sizeof(long));
L
Linus Torvalds 已提交
2795 2796 2797 2798 2799
	if (dasd_debug_area == NULL) {
		rc = -ENOMEM;
		goto failed;
	}
	debug_register_view(dasd_debug_area, &debug_sprintf_view);
H
Horst Hummel 已提交
2800
	debug_set_level(dasd_debug_area, DBF_WARNING);
L
Linus Torvalds 已提交
2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814

	DBF_EVENT(DBF_EMERG, "%s", "debug area created");

	dasd_diag_discipline_pointer = NULL;

	rc = dasd_devmap_init();
	if (rc)
		goto failed;
	rc = dasd_gendisk_init();
	if (rc)
		goto failed;
	rc = dasd_parse();
	if (rc)
		goto failed;
2815 2816 2817
	rc = dasd_eer_init();
	if (rc)
		goto failed;
L
Linus Torvalds 已提交
2818 2819 2820 2821 2822 2823 2824 2825
#ifdef CONFIG_PROC_FS
	rc = dasd_proc_init();
	if (rc)
		goto failed;
#endif

	return 0;
failed:
S
Stefan Haberland 已提交
2826
	pr_info("The DASD device driver could not be initialized\n");
L
Linus Torvalds 已提交
2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839
	dasd_exit();
	return rc;
}

module_init(dasd_init);
module_exit(dasd_exit);

EXPORT_SYMBOL(dasd_debug_area);
EXPORT_SYMBOL(dasd_diag_discipline_pointer);

EXPORT_SYMBOL(dasd_add_request_head);
EXPORT_SYMBOL(dasd_add_request_tail);
EXPORT_SYMBOL(dasd_cancel_req);
2840 2841
EXPORT_SYMBOL(dasd_device_clear_timer);
EXPORT_SYMBOL(dasd_block_clear_timer);
L
Linus Torvalds 已提交
2842 2843 2844 2845 2846
EXPORT_SYMBOL(dasd_enable_device);
EXPORT_SYMBOL(dasd_int_handler);
EXPORT_SYMBOL(dasd_kfree_request);
EXPORT_SYMBOL(dasd_kick_device);
EXPORT_SYMBOL(dasd_kmalloc_request);
2847 2848
EXPORT_SYMBOL(dasd_schedule_device_bh);
EXPORT_SYMBOL(dasd_schedule_block_bh);
L
Linus Torvalds 已提交
2849
EXPORT_SYMBOL(dasd_set_target_state);
2850 2851
EXPORT_SYMBOL(dasd_device_set_timer);
EXPORT_SYMBOL(dasd_block_set_timer);
L
Linus Torvalds 已提交
2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864
EXPORT_SYMBOL(dasd_sfree_request);
EXPORT_SYMBOL(dasd_sleep_on);
EXPORT_SYMBOL(dasd_sleep_on_immediatly);
EXPORT_SYMBOL(dasd_sleep_on_interruptible);
EXPORT_SYMBOL(dasd_smalloc_request);
EXPORT_SYMBOL(dasd_start_IO);
EXPORT_SYMBOL(dasd_term_IO);

EXPORT_SYMBOL_GPL(dasd_generic_probe);
EXPORT_SYMBOL_GPL(dasd_generic_remove);
EXPORT_SYMBOL_GPL(dasd_generic_notify);
EXPORT_SYMBOL_GPL(dasd_generic_set_online);
EXPORT_SYMBOL_GPL(dasd_generic_set_offline);
2865 2866 2867 2868
EXPORT_SYMBOL_GPL(dasd_generic_handle_state_change);
EXPORT_SYMBOL_GPL(dasd_flush_device_queue);
EXPORT_SYMBOL_GPL(dasd_alloc_block);
EXPORT_SYMBOL_GPL(dasd_free_block);