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