2 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
3 * Horst Hummel <Horst.Hummel@de.ibm.com>
4 * Carsten Otte <Cotte@de.ibm.com>
5 * Martin Schwidefsky <schwidefsky@de.ibm.com>
6 * Bugreports.to..: <Linux390@de.ibm.com>
7 * Copyright IBM Corp. 1999, 2009
10 #define KMSG_COMPONENT "dasd"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <linux/kmod.h>
14 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/ctype.h>
17 #include <linux/major.h>
18 #include <linux/slab.h>
19 #include <linux/hdreg.h>
20 #include <linux/async.h>
21 #include <linux/mutex.h>
22 #include <linux/debugfs.h>
23 #include <linux/seq_file.h>
24 #include <linux/vmalloc.h>
26 #include <asm/ccwdev.h>
27 #include <asm/ebcdic.h>
28 #include <asm/idals.h>
33 #define PRINTK_HEADER "dasd:"
37 * SECTION: Constant definitions to be used within this file
39 #define DASD_CHANQ_MAX_SIZE 4
41 #define DASD_DIAG_MOD "dasd_diag_mod"
44 * SECTION: exported variables of dasd.c
46 debug_info_t
*dasd_debug_area
;
47 EXPORT_SYMBOL(dasd_debug_area
);
48 static struct dentry
*dasd_debugfs_root_entry
;
49 struct dasd_discipline
*dasd_diag_discipline_pointer
;
50 EXPORT_SYMBOL(dasd_diag_discipline_pointer
);
51 void dasd_int_handler(struct ccw_device
*, unsigned long, struct irb
*);
53 MODULE_AUTHOR("Holger Smolinski <Holger.Smolinski@de.ibm.com>");
54 MODULE_DESCRIPTION("Linux on S/390 DASD device driver,"
55 " Copyright IBM Corp. 2000");
56 MODULE_SUPPORTED_DEVICE("dasd");
57 MODULE_LICENSE("GPL");
60 * SECTION: prototypes for static functions of dasd.c
62 static int dasd_alloc_queue(struct dasd_block
*);
63 static void dasd_setup_queue(struct dasd_block
*);
64 static void dasd_free_queue(struct dasd_block
*);
65 static void dasd_flush_request_queue(struct dasd_block
*);
66 static int dasd_flush_block_queue(struct dasd_block
*);
67 static void dasd_device_tasklet(struct dasd_device
*);
68 static void dasd_block_tasklet(struct dasd_block
*);
69 static void do_kick_device(struct work_struct
*);
70 static void do_restore_device(struct work_struct
*);
71 static void do_reload_device(struct work_struct
*);
72 static void do_requeue_requests(struct work_struct
*);
73 static void dasd_return_cqr_cb(struct dasd_ccw_req
*, void *);
74 static void dasd_device_timeout(unsigned long);
75 static void dasd_block_timeout(unsigned long);
76 static void __dasd_process_erp(struct dasd_device
*, struct dasd_ccw_req
*);
77 static void dasd_profile_init(struct dasd_profile
*, struct dentry
*);
78 static void dasd_profile_exit(struct dasd_profile
*);
79 static void dasd_hosts_init(struct dentry
*, struct dasd_device
*);
80 static void dasd_hosts_exit(struct dasd_device
*);
83 * SECTION: Operations on the device structure.
85 static wait_queue_head_t dasd_init_waitq
;
86 static wait_queue_head_t dasd_flush_wq
;
87 static wait_queue_head_t generic_waitq
;
88 static wait_queue_head_t shutdown_waitq
;
91 * Allocate memory for a new device structure.
93 struct dasd_device
*dasd_alloc_device(void)
95 struct dasd_device
*device
;
97 device
= kzalloc(sizeof(struct dasd_device
), GFP_ATOMIC
);
99 return ERR_PTR(-ENOMEM
);
101 /* Get two pages for normal block device operations. */
102 device
->ccw_mem
= (void *) __get_free_pages(GFP_ATOMIC
| GFP_DMA
, 1);
103 if (!device
->ccw_mem
) {
105 return ERR_PTR(-ENOMEM
);
107 /* Get one page for error recovery. */
108 device
->erp_mem
= (void *) get_zeroed_page(GFP_ATOMIC
| GFP_DMA
);
109 if (!device
->erp_mem
) {
110 free_pages((unsigned long) device
->ccw_mem
, 1);
112 return ERR_PTR(-ENOMEM
);
115 dasd_init_chunklist(&device
->ccw_chunks
, device
->ccw_mem
, PAGE_SIZE
*2);
116 dasd_init_chunklist(&device
->erp_chunks
, device
->erp_mem
, PAGE_SIZE
);
117 spin_lock_init(&device
->mem_lock
);
118 atomic_set(&device
->tasklet_scheduled
, 0);
119 tasklet_init(&device
->tasklet
,
120 (void (*)(unsigned long)) dasd_device_tasklet
,
121 (unsigned long) device
);
122 INIT_LIST_HEAD(&device
->ccw_queue
);
123 init_timer(&device
->timer
);
124 device
->timer
.function
= dasd_device_timeout
;
125 device
->timer
.data
= (unsigned long) device
;
126 INIT_WORK(&device
->kick_work
, do_kick_device
);
127 INIT_WORK(&device
->restore_device
, do_restore_device
);
128 INIT_WORK(&device
->reload_device
, do_reload_device
);
129 INIT_WORK(&device
->requeue_requests
, do_requeue_requests
);
130 device
->state
= DASD_STATE_NEW
;
131 device
->target
= DASD_STATE_NEW
;
132 mutex_init(&device
->state_mutex
);
133 spin_lock_init(&device
->profile
.lock
);
138 * Free memory of a device structure.
140 void dasd_free_device(struct dasd_device
*device
)
142 kfree(device
->private);
143 free_page((unsigned long) device
->erp_mem
);
144 free_pages((unsigned long) device
->ccw_mem
, 1);
149 * Allocate memory for a new device structure.
151 struct dasd_block
*dasd_alloc_block(void)
153 struct dasd_block
*block
;
155 block
= kzalloc(sizeof(*block
), GFP_ATOMIC
);
157 return ERR_PTR(-ENOMEM
);
158 /* open_count = 0 means device online but not in use */
159 atomic_set(&block
->open_count
, -1);
161 spin_lock_init(&block
->request_queue_lock
);
162 atomic_set(&block
->tasklet_scheduled
, 0);
163 tasklet_init(&block
->tasklet
,
164 (void (*)(unsigned long)) dasd_block_tasklet
,
165 (unsigned long) block
);
166 INIT_LIST_HEAD(&block
->ccw_queue
);
167 spin_lock_init(&block
->queue_lock
);
168 init_timer(&block
->timer
);
169 block
->timer
.function
= dasd_block_timeout
;
170 block
->timer
.data
= (unsigned long) block
;
171 spin_lock_init(&block
->profile
.lock
);
175 EXPORT_SYMBOL_GPL(dasd_alloc_block
);
178 * Free memory of a device structure.
180 void dasd_free_block(struct dasd_block
*block
)
184 EXPORT_SYMBOL_GPL(dasd_free_block
);
187 * Make a new device known to the system.
189 static int dasd_state_new_to_known(struct dasd_device
*device
)
194 * As long as the device is not in state DASD_STATE_NEW we want to
195 * keep the reference count > 0.
197 dasd_get_device(device
);
200 rc
= dasd_alloc_queue(device
->block
);
202 dasd_put_device(device
);
206 device
->state
= DASD_STATE_KNOWN
;
211 * Let the system forget about a device.
213 static int dasd_state_known_to_new(struct dasd_device
*device
)
215 /* Disable extended error reporting for this device. */
216 dasd_eer_disable(device
);
217 device
->state
= DASD_STATE_NEW
;
220 dasd_free_queue(device
->block
);
222 /* Give up reference we took in dasd_state_new_to_known. */
223 dasd_put_device(device
);
227 static struct dentry
*dasd_debugfs_setup(const char *name
,
228 struct dentry
*base_dentry
)
234 pde
= debugfs_create_dir(name
, base_dentry
);
235 if (!pde
|| IS_ERR(pde
))
241 * Request the irq line for the device.
243 static int dasd_state_known_to_basic(struct dasd_device
*device
)
245 struct dasd_block
*block
= device
->block
;
248 /* Allocate and register gendisk structure. */
250 rc
= dasd_gendisk_alloc(block
);
253 block
->debugfs_dentry
=
254 dasd_debugfs_setup(block
->gdp
->disk_name
,
255 dasd_debugfs_root_entry
);
256 dasd_profile_init(&block
->profile
, block
->debugfs_dentry
);
257 if (dasd_global_profile_level
== DASD_PROFILE_ON
)
258 dasd_profile_on(&device
->block
->profile
);
260 device
->debugfs_dentry
=
261 dasd_debugfs_setup(dev_name(&device
->cdev
->dev
),
262 dasd_debugfs_root_entry
);
263 dasd_profile_init(&device
->profile
, device
->debugfs_dentry
);
264 dasd_hosts_init(device
->debugfs_dentry
, device
);
266 /* register 'device' debug area, used for all DBF_DEV_XXX calls */
267 device
->debug_area
= debug_register(dev_name(&device
->cdev
->dev
), 4, 1,
269 debug_register_view(device
->debug_area
, &debug_sprintf_view
);
270 debug_set_level(device
->debug_area
, DBF_WARNING
);
271 DBF_DEV_EVENT(DBF_EMERG
, device
, "%s", "debug area created");
273 device
->state
= DASD_STATE_BASIC
;
279 * Release the irq line for the device. Terminate any running i/o.
281 static int dasd_state_basic_to_known(struct dasd_device
*device
)
285 if (device
->discipline
->basic_to_known
) {
286 rc
= device
->discipline
->basic_to_known(device
);
292 dasd_profile_exit(&device
->block
->profile
);
293 debugfs_remove(device
->block
->debugfs_dentry
);
294 dasd_gendisk_free(device
->block
);
295 dasd_block_clear_timer(device
->block
);
297 rc
= dasd_flush_device_queue(device
);
300 dasd_device_clear_timer(device
);
301 dasd_profile_exit(&device
->profile
);
302 dasd_hosts_exit(device
);
303 debugfs_remove(device
->debugfs_dentry
);
304 DBF_DEV_EVENT(DBF_EMERG
, device
, "%p debug area deleted", device
);
305 if (device
->debug_area
!= NULL
) {
306 debug_unregister(device
->debug_area
);
307 device
->debug_area
= NULL
;
309 device
->state
= DASD_STATE_KNOWN
;
314 * Do the initial analysis. The do_analysis function may return
315 * -EAGAIN in which case the device keeps the state DASD_STATE_BASIC
316 * until the discipline decides to continue the startup sequence
317 * by calling the function dasd_change_state. The eckd disciplines
318 * uses this to start a ccw that detects the format. The completion
319 * interrupt for this detection ccw uses the kernel event daemon to
320 * trigger the call to dasd_change_state. All this is done in the
321 * discipline code, see dasd_eckd.c.
322 * After the analysis ccw is done (do_analysis returned 0) the block
324 * In case the analysis returns an error, the device setup is stopped
325 * (a fake disk was already added to allow formatting).
327 static int dasd_state_basic_to_ready(struct dasd_device
*device
)
330 struct dasd_block
*block
;
331 struct gendisk
*disk
;
334 block
= device
->block
;
335 /* make disk known with correct capacity */
337 if (block
->base
->discipline
->do_analysis
!= NULL
)
338 rc
= block
->base
->discipline
->do_analysis(block
);
341 device
->state
= DASD_STATE_UNFMT
;
342 disk
= device
->block
->gdp
;
343 kobject_uevent(&disk_to_dev(disk
)->kobj
,
349 dasd_setup_queue(block
);
350 set_capacity(block
->gdp
,
351 block
->blocks
<< block
->s2b_shift
);
352 device
->state
= DASD_STATE_READY
;
353 rc
= dasd_scan_partitions(block
);
355 device
->state
= DASD_STATE_BASIC
;
359 device
->state
= DASD_STATE_READY
;
362 if (device
->discipline
->basic_to_ready
)
363 rc
= device
->discipline
->basic_to_ready(device
);
368 int _wait_for_empty_queues(struct dasd_device
*device
)
371 return list_empty(&device
->ccw_queue
) &&
372 list_empty(&device
->block
->ccw_queue
);
374 return list_empty(&device
->ccw_queue
);
378 * Remove device from block device layer. Destroy dirty buffers.
379 * Forget format information. Check if the target level is basic
380 * and if it is create fake disk for formatting.
382 static int dasd_state_ready_to_basic(struct dasd_device
*device
)
386 device
->state
= DASD_STATE_BASIC
;
388 struct dasd_block
*block
= device
->block
;
389 rc
= dasd_flush_block_queue(block
);
391 device
->state
= DASD_STATE_READY
;
394 dasd_flush_request_queue(block
);
395 dasd_destroy_partitions(block
);
398 block
->s2b_shift
= 0;
406 static int dasd_state_unfmt_to_basic(struct dasd_device
*device
)
408 device
->state
= DASD_STATE_BASIC
;
413 * Make the device online and schedule the bottom half to start
414 * the requeueing of requests from the linux request queue to the
418 dasd_state_ready_to_online(struct dasd_device
* device
)
420 struct gendisk
*disk
;
421 struct disk_part_iter piter
;
422 struct hd_struct
*part
;
424 device
->state
= DASD_STATE_ONLINE
;
426 dasd_schedule_block_bh(device
->block
);
427 if ((device
->features
& DASD_FEATURE_USERAW
)) {
428 disk
= device
->block
->gdp
;
429 kobject_uevent(&disk_to_dev(disk
)->kobj
, KOBJ_CHANGE
);
432 disk
= device
->block
->bdev
->bd_disk
;
433 disk_part_iter_init(&piter
, disk
, DISK_PITER_INCL_PART0
);
434 while ((part
= disk_part_iter_next(&piter
)))
435 kobject_uevent(&part_to_dev(part
)->kobj
, KOBJ_CHANGE
);
436 disk_part_iter_exit(&piter
);
442 * Stop the requeueing of requests again.
444 static int dasd_state_online_to_ready(struct dasd_device
*device
)
447 struct gendisk
*disk
;
448 struct disk_part_iter piter
;
449 struct hd_struct
*part
;
451 if (device
->discipline
->online_to_ready
) {
452 rc
= device
->discipline
->online_to_ready(device
);
457 device
->state
= DASD_STATE_READY
;
458 if (device
->block
&& !(device
->features
& DASD_FEATURE_USERAW
)) {
459 disk
= device
->block
->bdev
->bd_disk
;
460 disk_part_iter_init(&piter
, disk
, DISK_PITER_INCL_PART0
);
461 while ((part
= disk_part_iter_next(&piter
)))
462 kobject_uevent(&part_to_dev(part
)->kobj
, KOBJ_CHANGE
);
463 disk_part_iter_exit(&piter
);
469 * Device startup state changes.
471 static int dasd_increase_state(struct dasd_device
*device
)
476 if (device
->state
== DASD_STATE_NEW
&&
477 device
->target
>= DASD_STATE_KNOWN
)
478 rc
= dasd_state_new_to_known(device
);
481 device
->state
== DASD_STATE_KNOWN
&&
482 device
->target
>= DASD_STATE_BASIC
)
483 rc
= dasd_state_known_to_basic(device
);
486 device
->state
== DASD_STATE_BASIC
&&
487 device
->target
>= DASD_STATE_READY
)
488 rc
= dasd_state_basic_to_ready(device
);
491 device
->state
== DASD_STATE_UNFMT
&&
492 device
->target
> DASD_STATE_UNFMT
)
496 device
->state
== DASD_STATE_READY
&&
497 device
->target
>= DASD_STATE_ONLINE
)
498 rc
= dasd_state_ready_to_online(device
);
504 * Device shutdown state changes.
506 static int dasd_decrease_state(struct dasd_device
*device
)
511 if (device
->state
== DASD_STATE_ONLINE
&&
512 device
->target
<= DASD_STATE_READY
)
513 rc
= dasd_state_online_to_ready(device
);
516 device
->state
== DASD_STATE_READY
&&
517 device
->target
<= DASD_STATE_BASIC
)
518 rc
= dasd_state_ready_to_basic(device
);
521 device
->state
== DASD_STATE_UNFMT
&&
522 device
->target
<= DASD_STATE_BASIC
)
523 rc
= dasd_state_unfmt_to_basic(device
);
526 device
->state
== DASD_STATE_BASIC
&&
527 device
->target
<= DASD_STATE_KNOWN
)
528 rc
= dasd_state_basic_to_known(device
);
531 device
->state
== DASD_STATE_KNOWN
&&
532 device
->target
<= DASD_STATE_NEW
)
533 rc
= dasd_state_known_to_new(device
);
539 * This is the main startup/shutdown routine.
541 static void dasd_change_state(struct dasd_device
*device
)
545 if (device
->state
== device
->target
)
546 /* Already where we want to go today... */
548 if (device
->state
< device
->target
)
549 rc
= dasd_increase_state(device
);
551 rc
= dasd_decrease_state(device
);
555 device
->target
= device
->state
;
557 /* let user-space know that the device status changed */
558 kobject_uevent(&device
->cdev
->dev
.kobj
, KOBJ_CHANGE
);
560 if (device
->state
== device
->target
)
561 wake_up(&dasd_init_waitq
);
565 * Kick starter for devices that did not complete the startup/shutdown
566 * procedure or were sleeping because of a pending state.
567 * dasd_kick_device will schedule a call do do_kick_device to the kernel
570 static void do_kick_device(struct work_struct
*work
)
572 struct dasd_device
*device
= container_of(work
, struct dasd_device
, kick_work
);
573 mutex_lock(&device
->state_mutex
);
574 dasd_change_state(device
);
575 mutex_unlock(&device
->state_mutex
);
576 dasd_schedule_device_bh(device
);
577 dasd_put_device(device
);
580 void dasd_kick_device(struct dasd_device
*device
)
582 dasd_get_device(device
);
583 /* queue call to dasd_kick_device to the kernel event daemon. */
584 if (!schedule_work(&device
->kick_work
))
585 dasd_put_device(device
);
587 EXPORT_SYMBOL(dasd_kick_device
);
590 * dasd_reload_device will schedule a call do do_reload_device to the kernel
593 static void do_reload_device(struct work_struct
*work
)
595 struct dasd_device
*device
= container_of(work
, struct dasd_device
,
597 device
->discipline
->reload(device
);
598 dasd_put_device(device
);
601 void dasd_reload_device(struct dasd_device
*device
)
603 dasd_get_device(device
);
604 /* queue call to dasd_reload_device to the kernel event daemon. */
605 if (!schedule_work(&device
->reload_device
))
606 dasd_put_device(device
);
608 EXPORT_SYMBOL(dasd_reload_device
);
611 * dasd_restore_device will schedule a call do do_restore_device to the kernel
614 static void do_restore_device(struct work_struct
*work
)
616 struct dasd_device
*device
= container_of(work
, struct dasd_device
,
618 device
->cdev
->drv
->restore(device
->cdev
);
619 dasd_put_device(device
);
622 void dasd_restore_device(struct dasd_device
*device
)
624 dasd_get_device(device
);
625 /* queue call to dasd_restore_device to the kernel event daemon. */
626 if (!schedule_work(&device
->restore_device
))
627 dasd_put_device(device
);
631 * Set the target state for a device and starts the state change.
633 void dasd_set_target_state(struct dasd_device
*device
, int target
)
635 dasd_get_device(device
);
636 mutex_lock(&device
->state_mutex
);
637 /* If we are in probeonly mode stop at DASD_STATE_READY. */
638 if (dasd_probeonly
&& target
> DASD_STATE_READY
)
639 target
= DASD_STATE_READY
;
640 if (device
->target
!= target
) {
641 if (device
->state
== target
)
642 wake_up(&dasd_init_waitq
);
643 device
->target
= target
;
645 if (device
->state
!= device
->target
)
646 dasd_change_state(device
);
647 mutex_unlock(&device
->state_mutex
);
648 dasd_put_device(device
);
650 EXPORT_SYMBOL(dasd_set_target_state
);
653 * Enable devices with device numbers in [from..to].
655 static inline int _wait_for_device(struct dasd_device
*device
)
657 return (device
->state
== device
->target
);
660 void dasd_enable_device(struct dasd_device
*device
)
662 dasd_set_target_state(device
, DASD_STATE_ONLINE
);
663 if (device
->state
<= DASD_STATE_KNOWN
)
664 /* No discipline for device found. */
665 dasd_set_target_state(device
, DASD_STATE_NEW
);
666 /* Now wait for the devices to come up. */
667 wait_event(dasd_init_waitq
, _wait_for_device(device
));
669 dasd_reload_device(device
);
670 if (device
->discipline
->kick_validate
)
671 device
->discipline
->kick_validate(device
);
673 EXPORT_SYMBOL(dasd_enable_device
);
676 * SECTION: device operation (interrupt handler, start i/o, term i/o ...)
679 unsigned int dasd_global_profile_level
= DASD_PROFILE_OFF
;
681 #ifdef CONFIG_DASD_PROFILE
682 struct dasd_profile dasd_global_profile
= {
683 .lock
= __SPIN_LOCK_UNLOCKED(dasd_global_profile
.lock
),
685 static struct dentry
*dasd_debugfs_global_entry
;
688 * Add profiling information for cqr before execution.
690 static void dasd_profile_start(struct dasd_block
*block
,
691 struct dasd_ccw_req
*cqr
,
695 unsigned int counter
;
696 struct dasd_device
*device
;
698 /* count the length of the chanq for statistics */
700 if (dasd_global_profile_level
|| block
->profile
.data
)
701 list_for_each(l
, &block
->ccw_queue
)
705 spin_lock(&dasd_global_profile
.lock
);
706 if (dasd_global_profile
.data
) {
707 dasd_global_profile
.data
->dasd_io_nr_req
[counter
]++;
708 if (rq_data_dir(req
) == READ
)
709 dasd_global_profile
.data
->dasd_read_nr_req
[counter
]++;
711 spin_unlock(&dasd_global_profile
.lock
);
713 spin_lock(&block
->profile
.lock
);
714 if (block
->profile
.data
) {
715 block
->profile
.data
->dasd_io_nr_req
[counter
]++;
716 if (rq_data_dir(req
) == READ
)
717 block
->profile
.data
->dasd_read_nr_req
[counter
]++;
719 spin_unlock(&block
->profile
.lock
);
722 * We count the request for the start device, even though it may run on
723 * some other device due to error recovery. This way we make sure that
724 * we count each request only once.
726 device
= cqr
->startdev
;
727 if (device
->profile
.data
) {
728 counter
= 1; /* request is not yet queued on the start device */
729 list_for_each(l
, &device
->ccw_queue
)
733 spin_lock(&device
->profile
.lock
);
734 if (device
->profile
.data
) {
735 device
->profile
.data
->dasd_io_nr_req
[counter
]++;
736 if (rq_data_dir(req
) == READ
)
737 device
->profile
.data
->dasd_read_nr_req
[counter
]++;
739 spin_unlock(&device
->profile
.lock
);
743 * Add profiling information for cqr after execution.
746 #define dasd_profile_counter(value, index) \
748 for (index = 0; index < 31 && value >> (2+index); index++) \
752 static void dasd_profile_end_add_data(struct dasd_profile_info
*data
,
765 /* in case of an overflow, reset the whole profile */
766 if (data
->dasd_io_reqs
== UINT_MAX
) {
767 memset(data
, 0, sizeof(*data
));
768 getnstimeofday(&data
->starttod
);
770 data
->dasd_io_reqs
++;
771 data
->dasd_io_sects
+= sectors
;
773 data
->dasd_io_alias
++;
777 data
->dasd_io_secs
[sectors_ind
]++;
778 data
->dasd_io_times
[tottime_ind
]++;
779 data
->dasd_io_timps
[tottimeps_ind
]++;
780 data
->dasd_io_time1
[strtime_ind
]++;
781 data
->dasd_io_time2
[irqtime_ind
]++;
782 data
->dasd_io_time2ps
[irqtimeps_ind
]++;
783 data
->dasd_io_time3
[endtime_ind
]++;
786 data
->dasd_read_reqs
++;
787 data
->dasd_read_sects
+= sectors
;
789 data
->dasd_read_alias
++;
791 data
->dasd_read_tpm
++;
792 data
->dasd_read_secs
[sectors_ind
]++;
793 data
->dasd_read_times
[tottime_ind
]++;
794 data
->dasd_read_time1
[strtime_ind
]++;
795 data
->dasd_read_time2
[irqtime_ind
]++;
796 data
->dasd_read_time3
[endtime_ind
]++;
800 static void dasd_profile_end(struct dasd_block
*block
,
801 struct dasd_ccw_req
*cqr
,
804 long strtime
, irqtime
, endtime
, tottime
; /* in microseconds */
805 long tottimeps
, sectors
;
806 struct dasd_device
*device
;
807 int sectors_ind
, tottime_ind
, tottimeps_ind
, strtime_ind
;
808 int irqtime_ind
, irqtimeps_ind
, endtime_ind
;
810 device
= cqr
->startdev
;
811 if (!(dasd_global_profile_level
||
812 block
->profile
.data
||
813 device
->profile
.data
))
816 sectors
= blk_rq_sectors(req
);
817 if (!cqr
->buildclk
|| !cqr
->startclk
||
818 !cqr
->stopclk
|| !cqr
->endclk
||
822 strtime
= ((cqr
->startclk
- cqr
->buildclk
) >> 12);
823 irqtime
= ((cqr
->stopclk
- cqr
->startclk
) >> 12);
824 endtime
= ((cqr
->endclk
- cqr
->stopclk
) >> 12);
825 tottime
= ((cqr
->endclk
- cqr
->buildclk
) >> 12);
826 tottimeps
= tottime
/ sectors
;
828 dasd_profile_counter(sectors
, sectors_ind
);
829 dasd_profile_counter(tottime
, tottime_ind
);
830 dasd_profile_counter(tottimeps
, tottimeps_ind
);
831 dasd_profile_counter(strtime
, strtime_ind
);
832 dasd_profile_counter(irqtime
, irqtime_ind
);
833 dasd_profile_counter(irqtime
/ sectors
, irqtimeps_ind
);
834 dasd_profile_counter(endtime
, endtime_ind
);
836 spin_lock(&dasd_global_profile
.lock
);
837 if (dasd_global_profile
.data
) {
838 dasd_profile_end_add_data(dasd_global_profile
.data
,
839 cqr
->startdev
!= block
->base
,
841 rq_data_dir(req
) == READ
,
842 sectors
, sectors_ind
, tottime_ind
,
843 tottimeps_ind
, strtime_ind
,
844 irqtime_ind
, irqtimeps_ind
,
847 spin_unlock(&dasd_global_profile
.lock
);
849 spin_lock(&block
->profile
.lock
);
850 if (block
->profile
.data
)
851 dasd_profile_end_add_data(block
->profile
.data
,
852 cqr
->startdev
!= block
->base
,
854 rq_data_dir(req
) == READ
,
855 sectors
, sectors_ind
, tottime_ind
,
856 tottimeps_ind
, strtime_ind
,
857 irqtime_ind
, irqtimeps_ind
,
859 spin_unlock(&block
->profile
.lock
);
861 spin_lock(&device
->profile
.lock
);
862 if (device
->profile
.data
)
863 dasd_profile_end_add_data(device
->profile
.data
,
864 cqr
->startdev
!= block
->base
,
866 rq_data_dir(req
) == READ
,
867 sectors
, sectors_ind
, tottime_ind
,
868 tottimeps_ind
, strtime_ind
,
869 irqtime_ind
, irqtimeps_ind
,
871 spin_unlock(&device
->profile
.lock
);
874 void dasd_profile_reset(struct dasd_profile
*profile
)
876 struct dasd_profile_info
*data
;
878 spin_lock_bh(&profile
->lock
);
879 data
= profile
->data
;
881 spin_unlock_bh(&profile
->lock
);
884 memset(data
, 0, sizeof(*data
));
885 getnstimeofday(&data
->starttod
);
886 spin_unlock_bh(&profile
->lock
);
889 int dasd_profile_on(struct dasd_profile
*profile
)
891 struct dasd_profile_info
*data
;
893 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
896 spin_lock_bh(&profile
->lock
);
898 spin_unlock_bh(&profile
->lock
);
902 getnstimeofday(&data
->starttod
);
903 profile
->data
= data
;
904 spin_unlock_bh(&profile
->lock
);
908 void dasd_profile_off(struct dasd_profile
*profile
)
910 spin_lock_bh(&profile
->lock
);
911 kfree(profile
->data
);
912 profile
->data
= NULL
;
913 spin_unlock_bh(&profile
->lock
);
916 char *dasd_get_user_string(const char __user
*user_buf
, size_t user_len
)
920 buffer
= vmalloc(user_len
+ 1);
922 return ERR_PTR(-ENOMEM
);
923 if (copy_from_user(buffer
, user_buf
, user_len
) != 0) {
925 return ERR_PTR(-EFAULT
);
927 /* got the string, now strip linefeed. */
928 if (buffer
[user_len
- 1] == '\n')
929 buffer
[user_len
- 1] = 0;
931 buffer
[user_len
] = 0;
935 static ssize_t
dasd_stats_write(struct file
*file
,
936 const char __user
*user_buf
,
937 size_t user_len
, loff_t
*pos
)
941 struct seq_file
*m
= (struct seq_file
*)file
->private_data
;
942 struct dasd_profile
*prof
= m
->private;
944 if (user_len
> 65536)
946 buffer
= dasd_get_user_string(user_buf
, user_len
);
948 return PTR_ERR(buffer
);
950 str
= skip_spaces(buffer
);
952 if (strncmp(str
, "reset", 5) == 0) {
953 dasd_profile_reset(prof
);
954 } else if (strncmp(str
, "on", 2) == 0) {
955 rc
= dasd_profile_on(prof
);
959 if (prof
== &dasd_global_profile
) {
960 dasd_profile_reset(prof
);
961 dasd_global_profile_level
= DASD_PROFILE_GLOBAL_ONLY
;
963 } else if (strncmp(str
, "off", 3) == 0) {
964 if (prof
== &dasd_global_profile
)
965 dasd_global_profile_level
= DASD_PROFILE_OFF
;
966 dasd_profile_off(prof
);
974 static void dasd_stats_array(struct seq_file
*m
, unsigned int *array
)
978 for (i
= 0; i
< 32; i
++)
979 seq_printf(m
, "%u ", array
[i
]);
983 static void dasd_stats_seq_print(struct seq_file
*m
,
984 struct dasd_profile_info
*data
)
986 seq_printf(m
, "start_time %ld.%09ld\n",
987 data
->starttod
.tv_sec
, data
->starttod
.tv_nsec
);
988 seq_printf(m
, "total_requests %u\n", data
->dasd_io_reqs
);
989 seq_printf(m
, "total_sectors %u\n", data
->dasd_io_sects
);
990 seq_printf(m
, "total_pav %u\n", data
->dasd_io_alias
);
991 seq_printf(m
, "total_hpf %u\n", data
->dasd_io_tpm
);
992 seq_puts(m
, "histogram_sectors ");
993 dasd_stats_array(m
, data
->dasd_io_secs
);
994 seq_puts(m
, "histogram_io_times ");
995 dasd_stats_array(m
, data
->dasd_io_times
);
996 seq_puts(m
, "histogram_io_times_weighted ");
997 dasd_stats_array(m
, data
->dasd_io_timps
);
998 seq_puts(m
, "histogram_time_build_to_ssch ");
999 dasd_stats_array(m
, data
->dasd_io_time1
);
1000 seq_puts(m
, "histogram_time_ssch_to_irq ");
1001 dasd_stats_array(m
, data
->dasd_io_time2
);
1002 seq_puts(m
, "histogram_time_ssch_to_irq_weighted ");
1003 dasd_stats_array(m
, data
->dasd_io_time2ps
);
1004 seq_puts(m
, "histogram_time_irq_to_end ");
1005 dasd_stats_array(m
, data
->dasd_io_time3
);
1006 seq_puts(m
, "histogram_ccw_queue_length ");
1007 dasd_stats_array(m
, data
->dasd_io_nr_req
);
1008 seq_printf(m
, "total_read_requests %u\n", data
->dasd_read_reqs
);
1009 seq_printf(m
, "total_read_sectors %u\n", data
->dasd_read_sects
);
1010 seq_printf(m
, "total_read_pav %u\n", data
->dasd_read_alias
);
1011 seq_printf(m
, "total_read_hpf %u\n", data
->dasd_read_tpm
);
1012 seq_puts(m
, "histogram_read_sectors ");
1013 dasd_stats_array(m
, data
->dasd_read_secs
);
1014 seq_puts(m
, "histogram_read_times ");
1015 dasd_stats_array(m
, data
->dasd_read_times
);
1016 seq_puts(m
, "histogram_read_time_build_to_ssch ");
1017 dasd_stats_array(m
, data
->dasd_read_time1
);
1018 seq_puts(m
, "histogram_read_time_ssch_to_irq ");
1019 dasd_stats_array(m
, data
->dasd_read_time2
);
1020 seq_puts(m
, "histogram_read_time_irq_to_end ");
1021 dasd_stats_array(m
, data
->dasd_read_time3
);
1022 seq_puts(m
, "histogram_read_ccw_queue_length ");
1023 dasd_stats_array(m
, data
->dasd_read_nr_req
);
1026 static int dasd_stats_show(struct seq_file
*m
, void *v
)
1028 struct dasd_profile
*profile
;
1029 struct dasd_profile_info
*data
;
1031 profile
= m
->private;
1032 spin_lock_bh(&profile
->lock
);
1033 data
= profile
->data
;
1035 spin_unlock_bh(&profile
->lock
);
1036 seq_puts(m
, "disabled\n");
1039 dasd_stats_seq_print(m
, data
);
1040 spin_unlock_bh(&profile
->lock
);
1044 static int dasd_stats_open(struct inode
*inode
, struct file
*file
)
1046 struct dasd_profile
*profile
= inode
->i_private
;
1047 return single_open(file
, dasd_stats_show
, profile
);
1050 static const struct file_operations dasd_stats_raw_fops
= {
1051 .owner
= THIS_MODULE
,
1052 .open
= dasd_stats_open
,
1054 .llseek
= seq_lseek
,
1055 .release
= single_release
,
1056 .write
= dasd_stats_write
,
1059 static void dasd_profile_init(struct dasd_profile
*profile
,
1060 struct dentry
*base_dentry
)
1067 profile
->dentry
= NULL
;
1068 profile
->data
= NULL
;
1069 mode
= (S_IRUSR
| S_IWUSR
| S_IFREG
);
1070 pde
= debugfs_create_file("statistics", mode
, base_dentry
,
1071 profile
, &dasd_stats_raw_fops
);
1072 if (pde
&& !IS_ERR(pde
))
1073 profile
->dentry
= pde
;
1077 static void dasd_profile_exit(struct dasd_profile
*profile
)
1079 dasd_profile_off(profile
);
1080 debugfs_remove(profile
->dentry
);
1081 profile
->dentry
= NULL
;
1084 static void dasd_statistics_removeroot(void)
1086 dasd_global_profile_level
= DASD_PROFILE_OFF
;
1087 dasd_profile_exit(&dasd_global_profile
);
1088 debugfs_remove(dasd_debugfs_global_entry
);
1089 debugfs_remove(dasd_debugfs_root_entry
);
1092 static void dasd_statistics_createroot(void)
1096 dasd_debugfs_root_entry
= NULL
;
1097 pde
= debugfs_create_dir("dasd", NULL
);
1098 if (!pde
|| IS_ERR(pde
))
1100 dasd_debugfs_root_entry
= pde
;
1101 pde
= debugfs_create_dir("global", dasd_debugfs_root_entry
);
1102 if (!pde
|| IS_ERR(pde
))
1104 dasd_debugfs_global_entry
= pde
;
1105 dasd_profile_init(&dasd_global_profile
, dasd_debugfs_global_entry
);
1109 DBF_EVENT(DBF_ERR
, "%s",
1110 "Creation of the dasd debugfs interface failed");
1111 dasd_statistics_removeroot();
1116 #define dasd_profile_start(block, cqr, req) do {} while (0)
1117 #define dasd_profile_end(block, cqr, req) do {} while (0)
1119 static void dasd_statistics_createroot(void)
1124 static void dasd_statistics_removeroot(void)
1129 int dasd_stats_generic_show(struct seq_file
*m
, void *v
)
1131 seq_puts(m
, "Statistics are not activated in this kernel\n");
1135 static void dasd_profile_init(struct dasd_profile
*profile
,
1136 struct dentry
*base_dentry
)
1141 static void dasd_profile_exit(struct dasd_profile
*profile
)
1146 int dasd_profile_on(struct dasd_profile
*profile
)
1151 #endif /* CONFIG_DASD_PROFILE */
1153 static int dasd_hosts_show(struct seq_file
*m
, void *v
)
1155 struct dasd_device
*device
;
1156 int rc
= -EOPNOTSUPP
;
1158 device
= m
->private;
1159 dasd_get_device(device
);
1161 if (device
->discipline
->hosts_print
)
1162 rc
= device
->discipline
->hosts_print(device
, m
);
1164 dasd_put_device(device
);
1168 static int dasd_hosts_open(struct inode
*inode
, struct file
*file
)
1170 struct dasd_device
*device
= inode
->i_private
;
1172 return single_open(file
, dasd_hosts_show
, device
);
1175 static const struct file_operations dasd_hosts_fops
= {
1176 .owner
= THIS_MODULE
,
1177 .open
= dasd_hosts_open
,
1179 .llseek
= seq_lseek
,
1180 .release
= single_release
,
1183 static void dasd_hosts_exit(struct dasd_device
*device
)
1185 debugfs_remove(device
->hosts_dentry
);
1186 device
->hosts_dentry
= NULL
;
1189 static void dasd_hosts_init(struct dentry
*base_dentry
,
1190 struct dasd_device
*device
)
1198 mode
= S_IRUSR
| S_IFREG
;
1199 pde
= debugfs_create_file("host_access_list", mode
, base_dentry
,
1200 device
, &dasd_hosts_fops
);
1201 if (pde
&& !IS_ERR(pde
))
1202 device
->hosts_dentry
= pde
;
1206 * Allocate memory for a channel program with 'cplength' channel
1207 * command words and 'datasize' additional space. There are two
1208 * variantes: 1) dasd_kmalloc_request uses kmalloc to get the needed
1209 * memory and 2) dasd_smalloc_request uses the static ccw memory
1210 * that gets allocated for each device.
1212 struct dasd_ccw_req
*dasd_kmalloc_request(int magic
, int cplength
,
1214 struct dasd_device
*device
)
1216 struct dasd_ccw_req
*cqr
;
1219 BUG_ON(datasize
> PAGE_SIZE
||
1220 (cplength
*sizeof(struct ccw1
)) > PAGE_SIZE
);
1222 cqr
= kzalloc(sizeof(struct dasd_ccw_req
), GFP_ATOMIC
);
1224 return ERR_PTR(-ENOMEM
);
1227 cqr
->cpaddr
= kcalloc(cplength
, sizeof(struct ccw1
),
1228 GFP_ATOMIC
| GFP_DMA
);
1229 if (cqr
->cpaddr
== NULL
) {
1231 return ERR_PTR(-ENOMEM
);
1236 cqr
->data
= kzalloc(datasize
, GFP_ATOMIC
| GFP_DMA
);
1237 if (cqr
->data
== NULL
) {
1240 return ERR_PTR(-ENOMEM
);
1244 set_bit(DASD_CQR_FLAGS_USE_ERP
, &cqr
->flags
);
1245 dasd_get_device(device
);
1248 EXPORT_SYMBOL(dasd_kmalloc_request
);
1250 struct dasd_ccw_req
*dasd_smalloc_request(int magic
, int cplength
,
1252 struct dasd_device
*device
)
1254 unsigned long flags
;
1255 struct dasd_ccw_req
*cqr
;
1259 size
= (sizeof(struct dasd_ccw_req
) + 7L) & -8L;
1261 size
+= cplength
* sizeof(struct ccw1
);
1264 spin_lock_irqsave(&device
->mem_lock
, flags
);
1265 cqr
= (struct dasd_ccw_req
*)
1266 dasd_alloc_chunk(&device
->ccw_chunks
, size
);
1267 spin_unlock_irqrestore(&device
->mem_lock
, flags
);
1269 return ERR_PTR(-ENOMEM
);
1270 memset(cqr
, 0, sizeof(struct dasd_ccw_req
));
1271 data
= (char *) cqr
+ ((sizeof(struct dasd_ccw_req
) + 7L) & -8L);
1274 cqr
->cpaddr
= (struct ccw1
*) data
;
1275 data
+= cplength
*sizeof(struct ccw1
);
1276 memset(cqr
->cpaddr
, 0, cplength
*sizeof(struct ccw1
));
1281 memset(cqr
->data
, 0, datasize
);
1284 set_bit(DASD_CQR_FLAGS_USE_ERP
, &cqr
->flags
);
1285 dasd_get_device(device
);
1288 EXPORT_SYMBOL(dasd_smalloc_request
);
1291 * Free memory of a channel program. This function needs to free all the
1292 * idal lists that might have been created by dasd_set_cda and the
1293 * struct dasd_ccw_req itself.
1295 void dasd_kfree_request(struct dasd_ccw_req
*cqr
, struct dasd_device
*device
)
1299 /* Clear any idals used for the request. */
1302 clear_normalized_cda(ccw
);
1303 } while (ccw
++->flags
& (CCW_FLAG_CC
| CCW_FLAG_DC
));
1307 dasd_put_device(device
);
1309 EXPORT_SYMBOL(dasd_kfree_request
);
1311 void dasd_sfree_request(struct dasd_ccw_req
*cqr
, struct dasd_device
*device
)
1313 unsigned long flags
;
1315 spin_lock_irqsave(&device
->mem_lock
, flags
);
1316 dasd_free_chunk(&device
->ccw_chunks
, cqr
);
1317 spin_unlock_irqrestore(&device
->mem_lock
, flags
);
1318 dasd_put_device(device
);
1320 EXPORT_SYMBOL(dasd_sfree_request
);
1323 * Check discipline magic in cqr.
1325 static inline int dasd_check_cqr(struct dasd_ccw_req
*cqr
)
1327 struct dasd_device
*device
;
1331 device
= cqr
->startdev
;
1332 if (strncmp((char *) &cqr
->magic
, device
->discipline
->ebcname
, 4)) {
1333 DBF_DEV_EVENT(DBF_WARNING
, device
,
1334 " dasd_ccw_req 0x%08x magic doesn't match"
1335 " discipline 0x%08x",
1337 *(unsigned int *) device
->discipline
->name
);
1344 * Terminate the current i/o and set the request to clear_pending.
1345 * Timer keeps device runnig.
1346 * ccw_device_clear can fail if the i/o subsystem
1349 int dasd_term_IO(struct dasd_ccw_req
*cqr
)
1351 struct dasd_device
*device
;
1353 char errorstring
[ERRORLENGTH
];
1356 rc
= dasd_check_cqr(cqr
);
1360 device
= (struct dasd_device
*) cqr
->startdev
;
1361 while ((retries
< 5) && (cqr
->status
== DASD_CQR_IN_IO
)) {
1362 rc
= ccw_device_clear(device
->cdev
, (long) cqr
);
1364 case 0: /* termination successful */
1365 cqr
->status
= DASD_CQR_CLEAR_PENDING
;
1366 cqr
->stopclk
= get_tod_clock();
1368 DBF_DEV_EVENT(DBF_DEBUG
, device
,
1369 "terminate cqr %p successful",
1373 DBF_DEV_EVENT(DBF_ERR
, device
, "%s",
1374 "device gone, retry");
1377 DBF_DEV_EVENT(DBF_ERR
, device
, "%s",
1378 "I/O error, retry");
1382 * device not valid so no I/O could be running
1383 * handle CQR as termination successful
1385 cqr
->status
= DASD_CQR_CLEARED
;
1386 cqr
->stopclk
= get_tod_clock();
1388 /* no retries for invalid devices */
1390 DBF_DEV_EVENT(DBF_ERR
, device
, "%s",
1391 "EINVAL, handle as terminated");
1392 /* fake rc to success */
1396 DBF_DEV_EVENT(DBF_ERR
, device
, "%s",
1397 "device busy, retry later");
1400 /* internal error 10 - unknown rc*/
1401 snprintf(errorstring
, ERRORLENGTH
, "10 %d", rc
);
1402 dev_err(&device
->cdev
->dev
, "An error occurred in the "
1403 "DASD device driver, reason=%s\n", errorstring
);
1409 dasd_schedule_device_bh(device
);
1412 EXPORT_SYMBOL(dasd_term_IO
);
1415 * Start the i/o. This start_IO can fail if the channel is really busy.
1416 * In that case set up a timer to start the request later.
1418 int dasd_start_IO(struct dasd_ccw_req
*cqr
)
1420 struct dasd_device
*device
;
1422 char errorstring
[ERRORLENGTH
];
1425 rc
= dasd_check_cqr(cqr
);
1430 device
= (struct dasd_device
*) cqr
->startdev
;
1432 test_bit(DASD_FLAG_LOCK_STOLEN
, &cqr
->block
->base
->flags
)) ||
1433 test_bit(DASD_FLAG_LOCK_STOLEN
, &device
->flags
)) &&
1434 !test_bit(DASD_CQR_ALLOW_SLOCK
, &cqr
->flags
)) {
1435 DBF_DEV_EVENT(DBF_DEBUG
, device
, "start_IO: return request %p "
1436 "because of stolen lock", cqr
);
1437 cqr
->status
= DASD_CQR_ERROR
;
1438 cqr
->intrc
= -EPERM
;
1441 if (cqr
->retries
< 0) {
1442 /* internal error 14 - start_IO run out of retries */
1443 sprintf(errorstring
, "14 %p", cqr
);
1444 dev_err(&device
->cdev
->dev
, "An error occurred in the DASD "
1445 "device driver, reason=%s\n", errorstring
);
1446 cqr
->status
= DASD_CQR_ERROR
;
1449 cqr
->startclk
= get_tod_clock();
1450 cqr
->starttime
= jiffies
;
1452 if (!test_bit(DASD_CQR_VERIFY_PATH
, &cqr
->flags
)) {
1453 cqr
->lpm
&= dasd_path_get_opm(device
);
1455 cqr
->lpm
= dasd_path_get_opm(device
);
1457 if (cqr
->cpmode
== 1) {
1458 rc
= ccw_device_tm_start(device
->cdev
, cqr
->cpaddr
,
1459 (long) cqr
, cqr
->lpm
);
1461 rc
= ccw_device_start(device
->cdev
, cqr
->cpaddr
,
1462 (long) cqr
, cqr
->lpm
, 0);
1466 cqr
->status
= DASD_CQR_IN_IO
;
1469 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
1470 "start_IO: device busy, retry later");
1473 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
1474 "start_IO: request timeout, retry later");
1477 /* -EACCES indicates that the request used only a subset of the
1478 * available paths and all these paths are gone. If the lpm of
1479 * this request was only a subset of the opm (e.g. the ppm) then
1480 * we just do a retry with all available paths.
1481 * If we already use the full opm, something is amiss, and we
1482 * need a full path verification.
1484 if (test_bit(DASD_CQR_VERIFY_PATH
, &cqr
->flags
)) {
1485 DBF_DEV_EVENT(DBF_WARNING
, device
,
1486 "start_IO: selected paths gone (%x)",
1488 } else if (cqr
->lpm
!= dasd_path_get_opm(device
)) {
1489 cqr
->lpm
= dasd_path_get_opm(device
);
1490 DBF_DEV_EVENT(DBF_DEBUG
, device
, "%s",
1491 "start_IO: selected paths gone,"
1492 " retry on all paths");
1494 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
1495 "start_IO: all paths in opm gone,"
1496 " do path verification");
1497 dasd_generic_last_path_gone(device
);
1498 dasd_path_no_path(device
);
1499 dasd_path_set_tbvpm(device
,
1500 ccw_device_get_path_mask(
1505 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
1506 "start_IO: -ENODEV device gone, retry");
1509 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
1510 "start_IO: -EIO device gone, retry");
1513 /* most likely caused in power management context */
1514 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
1515 "start_IO: -EINVAL device currently "
1519 /* internal error 11 - unknown rc */
1520 snprintf(errorstring
, ERRORLENGTH
, "11 %d", rc
);
1521 dev_err(&device
->cdev
->dev
,
1522 "An error occurred in the DASD device driver, "
1523 "reason=%s\n", errorstring
);
1530 EXPORT_SYMBOL(dasd_start_IO
);
1533 * Timeout function for dasd devices. This is used for different purposes
1534 * 1) missing interrupt handler for normal operation
1535 * 2) delayed start of request where start_IO failed with -EBUSY
1536 * 3) timeout for missing state change interrupts
1537 * The head of the ccw queue will have status DASD_CQR_IN_IO for 1),
1538 * DASD_CQR_QUEUED for 2) and 3).
1540 static void dasd_device_timeout(unsigned long ptr
)
1542 unsigned long flags
;
1543 struct dasd_device
*device
;
1545 device
= (struct dasd_device
*) ptr
;
1546 spin_lock_irqsave(get_ccwdev_lock(device
->cdev
), flags
);
1547 /* re-activate request queue */
1548 dasd_device_remove_stop_bits(device
, DASD_STOPPED_PENDING
);
1549 spin_unlock_irqrestore(get_ccwdev_lock(device
->cdev
), flags
);
1550 dasd_schedule_device_bh(device
);
1554 * Setup timeout for a device in jiffies.
1556 void dasd_device_set_timer(struct dasd_device
*device
, int expires
)
1559 del_timer(&device
->timer
);
1561 mod_timer(&device
->timer
, jiffies
+ expires
);
1563 EXPORT_SYMBOL(dasd_device_set_timer
);
1566 * Clear timeout for a device.
1568 void dasd_device_clear_timer(struct dasd_device
*device
)
1570 del_timer(&device
->timer
);
1572 EXPORT_SYMBOL(dasd_device_clear_timer
);
1574 static void dasd_handle_killed_request(struct ccw_device
*cdev
,
1575 unsigned long intparm
)
1577 struct dasd_ccw_req
*cqr
;
1578 struct dasd_device
*device
;
1582 cqr
= (struct dasd_ccw_req
*) intparm
;
1583 if (cqr
->status
!= DASD_CQR_IN_IO
) {
1584 DBF_EVENT_DEVID(DBF_DEBUG
, cdev
,
1585 "invalid status in handle_killed_request: "
1586 "%02x", cqr
->status
);
1590 device
= dasd_device_from_cdev_locked(cdev
);
1591 if (IS_ERR(device
)) {
1592 DBF_EVENT_DEVID(DBF_DEBUG
, cdev
, "%s",
1593 "unable to get device from cdev");
1597 if (!cqr
->startdev
||
1598 device
!= cqr
->startdev
||
1599 strncmp(cqr
->startdev
->discipline
->ebcname
,
1600 (char *) &cqr
->magic
, 4)) {
1601 DBF_EVENT_DEVID(DBF_DEBUG
, cdev
, "%s",
1602 "invalid device in request");
1603 dasd_put_device(device
);
1607 /* Schedule request to be retried. */
1608 cqr
->status
= DASD_CQR_QUEUED
;
1610 dasd_device_clear_timer(device
);
1611 dasd_schedule_device_bh(device
);
1612 dasd_put_device(device
);
1615 void dasd_generic_handle_state_change(struct dasd_device
*device
)
1617 /* First of all start sense subsystem status request. */
1618 dasd_eer_snss(device
);
1620 dasd_device_remove_stop_bits(device
, DASD_STOPPED_PENDING
);
1621 dasd_schedule_device_bh(device
);
1623 dasd_schedule_block_bh(device
->block
);
1625 EXPORT_SYMBOL_GPL(dasd_generic_handle_state_change
);
1627 static int dasd_check_hpf_error(struct irb
*irb
)
1629 return (scsw_tm_is_valid_schxs(&irb
->scsw
) &&
1630 (irb
->scsw
.tm
.sesq
== SCSW_SESQ_DEV_NOFCX
||
1631 irb
->scsw
.tm
.sesq
== SCSW_SESQ_PATH_NOFCX
));
1635 * Interrupt handler for "normal" ssch-io based dasd devices.
1637 void dasd_int_handler(struct ccw_device
*cdev
, unsigned long intparm
,
1640 struct dasd_ccw_req
*cqr
, *next
;
1641 struct dasd_device
*device
;
1642 unsigned long long now
;
1643 int nrf_suppressed
= 0;
1644 int fp_suppressed
= 0;
1648 cqr
= (struct dasd_ccw_req
*) intparm
;
1650 switch (PTR_ERR(irb
)) {
1652 if (cqr
&& cqr
->status
== DASD_CQR_CLEAR_PENDING
) {
1653 device
= cqr
->startdev
;
1654 cqr
->status
= DASD_CQR_CLEARED
;
1655 dasd_device_clear_timer(device
);
1656 wake_up(&dasd_flush_wq
);
1657 dasd_schedule_device_bh(device
);
1662 DBF_EVENT_DEVID(DBF_WARNING
, cdev
, "%s: "
1663 "request timed out\n", __func__
);
1666 DBF_EVENT_DEVID(DBF_WARNING
, cdev
, "%s: "
1667 "unknown error %ld\n", __func__
,
1670 dasd_handle_killed_request(cdev
, intparm
);
1674 now
= get_tod_clock();
1675 /* check for conditions that should be handled immediately */
1677 !(scsw_dstat(&irb
->scsw
) == (DEV_STAT_CHN_END
| DEV_STAT_DEV_END
) &&
1678 scsw_cstat(&irb
->scsw
) == 0)) {
1680 memcpy(&cqr
->irb
, irb
, sizeof(*irb
));
1681 device
= dasd_device_from_cdev_locked(cdev
);
1684 /* ignore unsolicited interrupts for DIAG discipline */
1685 if (device
->discipline
== dasd_diag_discipline_pointer
) {
1686 dasd_put_device(device
);
1691 * In some cases 'File Protected' or 'No Record Found' errors
1692 * might be expected and debug log messages for the
1693 * corresponding interrupts shouldn't be written then.
1694 * Check if either of the according suppress bits is set.
1696 sense
= dasd_get_sense(irb
);
1698 fp_suppressed
= (sense
[1] & SNS1_FILE_PROTECTED
) &&
1699 test_bit(DASD_CQR_SUPPRESS_FP
, &cqr
->flags
);
1700 nrf_suppressed
= (sense
[1] & SNS1_NO_REC_FOUND
) &&
1701 test_bit(DASD_CQR_SUPPRESS_NRF
, &cqr
->flags
);
1703 if (!(fp_suppressed
|| nrf_suppressed
))
1704 device
->discipline
->dump_sense_dbf(device
, irb
, "int");
1706 if (device
->features
& DASD_FEATURE_ERPLOG
)
1707 device
->discipline
->dump_sense(device
, cqr
, irb
);
1708 device
->discipline
->check_for_device_change(device
, cqr
, irb
);
1709 dasd_put_device(device
);
1712 /* check for for attention message */
1713 if (scsw_dstat(&irb
->scsw
) & DEV_STAT_ATTENTION
) {
1714 device
= dasd_device_from_cdev_locked(cdev
);
1715 if (!IS_ERR(device
)) {
1716 device
->discipline
->check_attention(device
,
1717 irb
->esw
.esw1
.lpum
);
1718 dasd_put_device(device
);
1725 device
= (struct dasd_device
*) cqr
->startdev
;
1727 strncmp(device
->discipline
->ebcname
, (char *) &cqr
->magic
, 4)) {
1728 DBF_EVENT_DEVID(DBF_DEBUG
, cdev
, "%s",
1729 "invalid device in request");
1733 /* Check for clear pending */
1734 if (cqr
->status
== DASD_CQR_CLEAR_PENDING
&&
1735 scsw_fctl(&irb
->scsw
) & SCSW_FCTL_CLEAR_FUNC
) {
1736 cqr
->status
= DASD_CQR_CLEARED
;
1737 dasd_device_clear_timer(device
);
1738 wake_up(&dasd_flush_wq
);
1739 dasd_schedule_device_bh(device
);
1743 /* check status - the request might have been killed by dyn detach */
1744 if (cqr
->status
!= DASD_CQR_IN_IO
) {
1745 DBF_DEV_EVENT(DBF_DEBUG
, device
, "invalid status: bus_id %s, "
1746 "status %02x", dev_name(&cdev
->dev
), cqr
->status
);
1752 if (scsw_dstat(&irb
->scsw
) == (DEV_STAT_CHN_END
| DEV_STAT_DEV_END
) &&
1753 scsw_cstat(&irb
->scsw
) == 0) {
1754 /* request was completed successfully */
1755 cqr
->status
= DASD_CQR_SUCCESS
;
1757 /* Start first request on queue if possible -> fast_io. */
1758 if (cqr
->devlist
.next
!= &device
->ccw_queue
) {
1759 next
= list_entry(cqr
->devlist
.next
,
1760 struct dasd_ccw_req
, devlist
);
1762 } else { /* error */
1763 /* check for HPF error
1764 * call discipline function to requeue all requests
1765 * and disable HPF accordingly
1767 if (cqr
->cpmode
&& dasd_check_hpf_error(irb
) &&
1768 device
->discipline
->handle_hpf_error
)
1769 device
->discipline
->handle_hpf_error(device
, irb
);
1771 * If we don't want complex ERP for this request, then just
1772 * reset this and retry it in the fastpath
1774 if (!test_bit(DASD_CQR_FLAGS_USE_ERP
, &cqr
->flags
) &&
1776 if (cqr
->lpm
== dasd_path_get_opm(device
))
1777 DBF_DEV_EVENT(DBF_DEBUG
, device
,
1778 "default ERP in fastpath "
1779 "(%i retries left)",
1781 if (!test_bit(DASD_CQR_VERIFY_PATH
, &cqr
->flags
))
1782 cqr
->lpm
= dasd_path_get_opm(device
);
1783 cqr
->status
= DASD_CQR_QUEUED
;
1786 cqr
->status
= DASD_CQR_ERROR
;
1788 if (next
&& (next
->status
== DASD_CQR_QUEUED
) &&
1789 (!device
->stopped
)) {
1790 if (device
->discipline
->start_IO(next
) == 0)
1791 expires
= next
->expires
;
1794 dasd_device_set_timer(device
, expires
);
1796 dasd_device_clear_timer(device
);
1797 dasd_schedule_device_bh(device
);
1799 EXPORT_SYMBOL(dasd_int_handler
);
1801 enum uc_todo
dasd_generic_uc_handler(struct ccw_device
*cdev
, struct irb
*irb
)
1803 struct dasd_device
*device
;
1805 device
= dasd_device_from_cdev_locked(cdev
);
1809 if (test_bit(DASD_FLAG_OFFLINE
, &device
->flags
) ||
1810 device
->state
!= device
->target
||
1811 !device
->discipline
->check_for_device_change
){
1812 dasd_put_device(device
);
1815 if (device
->discipline
->dump_sense_dbf
)
1816 device
->discipline
->dump_sense_dbf(device
, irb
, "uc");
1817 device
->discipline
->check_for_device_change(device
, NULL
, irb
);
1818 dasd_put_device(device
);
1820 return UC_TODO_RETRY
;
1822 EXPORT_SYMBOL_GPL(dasd_generic_uc_handler
);
1825 * If we have an error on a dasd_block layer request then we cancel
1826 * and return all further requests from the same dasd_block as well.
1828 static void __dasd_device_recovery(struct dasd_device
*device
,
1829 struct dasd_ccw_req
*ref_cqr
)
1831 struct list_head
*l
, *n
;
1832 struct dasd_ccw_req
*cqr
;
1835 * only requeue request that came from the dasd_block layer
1837 if (!ref_cqr
->block
)
1840 list_for_each_safe(l
, n
, &device
->ccw_queue
) {
1841 cqr
= list_entry(l
, struct dasd_ccw_req
, devlist
);
1842 if (cqr
->status
== DASD_CQR_QUEUED
&&
1843 ref_cqr
->block
== cqr
->block
) {
1844 cqr
->status
= DASD_CQR_CLEARED
;
1850 * Remove those ccw requests from the queue that need to be returned
1851 * to the upper layer.
1853 static void __dasd_device_process_ccw_queue(struct dasd_device
*device
,
1854 struct list_head
*final_queue
)
1856 struct list_head
*l
, *n
;
1857 struct dasd_ccw_req
*cqr
;
1859 /* Process request with final status. */
1860 list_for_each_safe(l
, n
, &device
->ccw_queue
) {
1861 cqr
= list_entry(l
, struct dasd_ccw_req
, devlist
);
1863 /* Skip any non-final request. */
1864 if (cqr
->status
== DASD_CQR_QUEUED
||
1865 cqr
->status
== DASD_CQR_IN_IO
||
1866 cqr
->status
== DASD_CQR_CLEAR_PENDING
)
1868 if (cqr
->status
== DASD_CQR_ERROR
) {
1869 __dasd_device_recovery(device
, cqr
);
1871 /* Rechain finished requests to final queue */
1872 list_move_tail(&cqr
->devlist
, final_queue
);
1877 * the cqrs from the final queue are returned to the upper layer
1878 * by setting a dasd_block state and calling the callback function
1880 static void __dasd_device_process_final_queue(struct dasd_device
*device
,
1881 struct list_head
*final_queue
)
1883 struct list_head
*l
, *n
;
1884 struct dasd_ccw_req
*cqr
;
1885 struct dasd_block
*block
;
1886 void (*callback
)(struct dasd_ccw_req
*, void *data
);
1887 void *callback_data
;
1888 char errorstring
[ERRORLENGTH
];
1890 list_for_each_safe(l
, n
, final_queue
) {
1891 cqr
= list_entry(l
, struct dasd_ccw_req
, devlist
);
1892 list_del_init(&cqr
->devlist
);
1894 callback
= cqr
->callback
;
1895 callback_data
= cqr
->callback_data
;
1897 spin_lock_bh(&block
->queue_lock
);
1898 switch (cqr
->status
) {
1899 case DASD_CQR_SUCCESS
:
1900 cqr
->status
= DASD_CQR_DONE
;
1902 case DASD_CQR_ERROR
:
1903 cqr
->status
= DASD_CQR_NEED_ERP
;
1905 case DASD_CQR_CLEARED
:
1906 cqr
->status
= DASD_CQR_TERMINATED
;
1909 /* internal error 12 - wrong cqr status*/
1910 snprintf(errorstring
, ERRORLENGTH
, "12 %p %x02", cqr
, cqr
->status
);
1911 dev_err(&device
->cdev
->dev
,
1912 "An error occurred in the DASD device driver, "
1913 "reason=%s\n", errorstring
);
1916 if (cqr
->callback
!= NULL
)
1917 (callback
)(cqr
, callback_data
);
1919 spin_unlock_bh(&block
->queue_lock
);
1924 * Take a look at the first request on the ccw queue and check
1925 * if it reached its expire time. If so, terminate the IO.
1927 static void __dasd_device_check_expire(struct dasd_device
*device
)
1929 struct dasd_ccw_req
*cqr
;
1931 if (list_empty(&device
->ccw_queue
))
1933 cqr
= list_entry(device
->ccw_queue
.next
, struct dasd_ccw_req
, devlist
);
1934 if ((cqr
->status
== DASD_CQR_IN_IO
&& cqr
->expires
!= 0) &&
1935 (time_after_eq(jiffies
, cqr
->expires
+ cqr
->starttime
))) {
1936 if (test_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING
, &device
->flags
)) {
1938 * IO in safe offline processing should not
1939 * run out of retries
1943 if (device
->discipline
->term_IO(cqr
) != 0) {
1944 /* Hmpf, try again in 5 sec */
1945 dev_err(&device
->cdev
->dev
,
1946 "cqr %p timed out (%lus) but cannot be "
1947 "ended, retrying in 5 s\n",
1948 cqr
, (cqr
->expires
/HZ
));
1949 cqr
->expires
+= 5*HZ
;
1950 dasd_device_set_timer(device
, 5*HZ
);
1952 dev_err(&device
->cdev
->dev
,
1953 "cqr %p timed out (%lus), %i retries "
1954 "remaining\n", cqr
, (cqr
->expires
/HZ
),
1961 * return 1 when device is not eligible for IO
1963 static int __dasd_device_is_unusable(struct dasd_device
*device
,
1964 struct dasd_ccw_req
*cqr
)
1966 int mask
= ~(DASD_STOPPED_DC_WAIT
| DASD_UNRESUMED_PM
);
1968 if (test_bit(DASD_FLAG_OFFLINE
, &device
->flags
)) {
1969 /* dasd is being set offline. */
1972 if (device
->stopped
) {
1973 if (device
->stopped
& mask
) {
1974 /* stopped and CQR will not change that. */
1977 if (!test_bit(DASD_CQR_VERIFY_PATH
, &cqr
->flags
)) {
1978 /* CQR is not able to change device to
1982 /* CQR required to get device operational. */
1988 * Take a look at the first request on the ccw queue and check
1989 * if it needs to be started.
1991 static void __dasd_device_start_head(struct dasd_device
*device
)
1993 struct dasd_ccw_req
*cqr
;
1996 if (list_empty(&device
->ccw_queue
))
1998 cqr
= list_entry(device
->ccw_queue
.next
, struct dasd_ccw_req
, devlist
);
1999 if (cqr
->status
!= DASD_CQR_QUEUED
)
2001 /* if device is not usable return request to upper layer */
2002 if (__dasd_device_is_unusable(device
, cqr
)) {
2003 cqr
->intrc
= -EAGAIN
;
2004 cqr
->status
= DASD_CQR_CLEARED
;
2005 dasd_schedule_device_bh(device
);
2009 rc
= device
->discipline
->start_IO(cqr
);
2011 dasd_device_set_timer(device
, cqr
->expires
);
2012 else if (rc
== -EACCES
) {
2013 dasd_schedule_device_bh(device
);
2015 /* Hmpf, try again in 1/2 sec */
2016 dasd_device_set_timer(device
, 50);
2019 static void __dasd_device_check_path_events(struct dasd_device
*device
)
2023 if (!dasd_path_get_tbvpm(device
))
2026 if (device
->stopped
&
2027 ~(DASD_STOPPED_DC_WAIT
| DASD_UNRESUMED_PM
))
2029 rc
= device
->discipline
->verify_path(device
,
2030 dasd_path_get_tbvpm(device
));
2032 dasd_device_set_timer(device
, 50);
2034 dasd_path_clear_all_verify(device
);
2038 * Go through all request on the dasd_device request queue,
2039 * terminate them on the cdev if necessary, and return them to the
2040 * submitting layer via callback.
2042 * Make sure that all 'submitting layers' still exist when
2043 * this function is called!. In other words, when 'device' is a base
2044 * device then all block layer requests must have been removed before
2045 * via dasd_flush_block_queue.
2047 int dasd_flush_device_queue(struct dasd_device
*device
)
2049 struct dasd_ccw_req
*cqr
, *n
;
2051 struct list_head flush_queue
;
2053 INIT_LIST_HEAD(&flush_queue
);
2054 spin_lock_irq(get_ccwdev_lock(device
->cdev
));
2056 list_for_each_entry_safe(cqr
, n
, &device
->ccw_queue
, devlist
) {
2057 /* Check status and move request to flush_queue */
2058 switch (cqr
->status
) {
2059 case DASD_CQR_IN_IO
:
2060 rc
= device
->discipline
->term_IO(cqr
);
2062 /* unable to terminate requeust */
2063 dev_err(&device
->cdev
->dev
,
2064 "Flushing the DASD request queue "
2065 "failed for request %p\n", cqr
);
2066 /* stop flush processing */
2070 case DASD_CQR_QUEUED
:
2071 cqr
->stopclk
= get_tod_clock();
2072 cqr
->status
= DASD_CQR_CLEARED
;
2074 default: /* no need to modify the others */
2077 list_move_tail(&cqr
->devlist
, &flush_queue
);
2080 spin_unlock_irq(get_ccwdev_lock(device
->cdev
));
2082 * After this point all requests must be in state CLEAR_PENDING,
2083 * CLEARED, SUCCESS or ERROR. Now wait for CLEAR_PENDING to become
2084 * one of the others.
2086 list_for_each_entry_safe(cqr
, n
, &flush_queue
, devlist
)
2087 wait_event(dasd_flush_wq
,
2088 (cqr
->status
!= DASD_CQR_CLEAR_PENDING
));
2090 * Now set each request back to TERMINATED, DONE or NEED_ERP
2091 * and call the callback function of flushed requests
2093 __dasd_device_process_final_queue(device
, &flush_queue
);
2096 EXPORT_SYMBOL_GPL(dasd_flush_device_queue
);
2099 * Acquire the device lock and process queues for the device.
2101 static void dasd_device_tasklet(struct dasd_device
*device
)
2103 struct list_head final_queue
;
2105 atomic_set (&device
->tasklet_scheduled
, 0);
2106 INIT_LIST_HEAD(&final_queue
);
2107 spin_lock_irq(get_ccwdev_lock(device
->cdev
));
2108 /* Check expire time of first request on the ccw queue. */
2109 __dasd_device_check_expire(device
);
2110 /* find final requests on ccw queue */
2111 __dasd_device_process_ccw_queue(device
, &final_queue
);
2112 __dasd_device_check_path_events(device
);
2113 spin_unlock_irq(get_ccwdev_lock(device
->cdev
));
2114 /* Now call the callback function of requests with final status */
2115 __dasd_device_process_final_queue(device
, &final_queue
);
2116 spin_lock_irq(get_ccwdev_lock(device
->cdev
));
2117 /* Now check if the head of the ccw queue needs to be started. */
2118 __dasd_device_start_head(device
);
2119 spin_unlock_irq(get_ccwdev_lock(device
->cdev
));
2120 if (waitqueue_active(&shutdown_waitq
))
2121 wake_up(&shutdown_waitq
);
2122 dasd_put_device(device
);
2126 * Schedules a call to dasd_tasklet over the device tasklet.
2128 void dasd_schedule_device_bh(struct dasd_device
*device
)
2130 /* Protect against rescheduling. */
2131 if (atomic_cmpxchg (&device
->tasklet_scheduled
, 0, 1) != 0)
2133 dasd_get_device(device
);
2134 tasklet_hi_schedule(&device
->tasklet
);
2136 EXPORT_SYMBOL(dasd_schedule_device_bh
);
2138 void dasd_device_set_stop_bits(struct dasd_device
*device
, int bits
)
2140 device
->stopped
|= bits
;
2142 EXPORT_SYMBOL_GPL(dasd_device_set_stop_bits
);
2144 void dasd_device_remove_stop_bits(struct dasd_device
*device
, int bits
)
2146 device
->stopped
&= ~bits
;
2147 if (!device
->stopped
)
2148 wake_up(&generic_waitq
);
2150 EXPORT_SYMBOL_GPL(dasd_device_remove_stop_bits
);
2153 * Queue a request to the head of the device ccw_queue.
2154 * Start the I/O if possible.
2156 void dasd_add_request_head(struct dasd_ccw_req
*cqr
)
2158 struct dasd_device
*device
;
2159 unsigned long flags
;
2161 device
= cqr
->startdev
;
2162 spin_lock_irqsave(get_ccwdev_lock(device
->cdev
), flags
);
2163 cqr
->status
= DASD_CQR_QUEUED
;
2164 list_add(&cqr
->devlist
, &device
->ccw_queue
);
2165 /* let the bh start the request to keep them in order */
2166 dasd_schedule_device_bh(device
);
2167 spin_unlock_irqrestore(get_ccwdev_lock(device
->cdev
), flags
);
2169 EXPORT_SYMBOL(dasd_add_request_head
);
2172 * Queue a request to the tail of the device ccw_queue.
2173 * Start the I/O if possible.
2175 void dasd_add_request_tail(struct dasd_ccw_req
*cqr
)
2177 struct dasd_device
*device
;
2178 unsigned long flags
;
2180 device
= cqr
->startdev
;
2181 spin_lock_irqsave(get_ccwdev_lock(device
->cdev
), flags
);
2182 cqr
->status
= DASD_CQR_QUEUED
;
2183 list_add_tail(&cqr
->devlist
, &device
->ccw_queue
);
2184 /* let the bh start the request to keep them in order */
2185 dasd_schedule_device_bh(device
);
2186 spin_unlock_irqrestore(get_ccwdev_lock(device
->cdev
), flags
);
2188 EXPORT_SYMBOL(dasd_add_request_tail
);
2191 * Wakeup helper for the 'sleep_on' functions.
2193 void dasd_wakeup_cb(struct dasd_ccw_req
*cqr
, void *data
)
2195 spin_lock_irq(get_ccwdev_lock(cqr
->startdev
->cdev
));
2196 cqr
->callback_data
= DASD_SLEEPON_END_TAG
;
2197 spin_unlock_irq(get_ccwdev_lock(cqr
->startdev
->cdev
));
2198 wake_up(&generic_waitq
);
2200 EXPORT_SYMBOL_GPL(dasd_wakeup_cb
);
2202 static inline int _wait_for_wakeup(struct dasd_ccw_req
*cqr
)
2204 struct dasd_device
*device
;
2207 device
= cqr
->startdev
;
2208 spin_lock_irq(get_ccwdev_lock(device
->cdev
));
2209 rc
= (cqr
->callback_data
== DASD_SLEEPON_END_TAG
);
2210 spin_unlock_irq(get_ccwdev_lock(device
->cdev
));
2215 * checks if error recovery is necessary, returns 1 if yes, 0 otherwise.
2217 static int __dasd_sleep_on_erp(struct dasd_ccw_req
*cqr
)
2219 struct dasd_device
*device
;
2220 dasd_erp_fn_t erp_fn
;
2222 if (cqr
->status
== DASD_CQR_FILLED
)
2224 device
= cqr
->startdev
;
2225 if (test_bit(DASD_CQR_FLAGS_USE_ERP
, &cqr
->flags
)) {
2226 if (cqr
->status
== DASD_CQR_TERMINATED
) {
2227 device
->discipline
->handle_terminated_request(cqr
);
2230 if (cqr
->status
== DASD_CQR_NEED_ERP
) {
2231 erp_fn
= device
->discipline
->erp_action(cqr
);
2235 if (cqr
->status
== DASD_CQR_FAILED
)
2236 dasd_log_sense(cqr
, &cqr
->irb
);
2238 __dasd_process_erp(device
, cqr
);
2245 static int __dasd_sleep_on_loop_condition(struct dasd_ccw_req
*cqr
)
2247 if (test_bit(DASD_CQR_FLAGS_USE_ERP
, &cqr
->flags
)) {
2248 if (cqr
->refers
) /* erp is not done yet */
2250 return ((cqr
->status
!= DASD_CQR_DONE
) &&
2251 (cqr
->status
!= DASD_CQR_FAILED
));
2253 return (cqr
->status
== DASD_CQR_FILLED
);
2256 static int _dasd_sleep_on(struct dasd_ccw_req
*maincqr
, int interruptible
)
2258 struct dasd_device
*device
;
2260 struct list_head ccw_queue
;
2261 struct dasd_ccw_req
*cqr
;
2263 INIT_LIST_HEAD(&ccw_queue
);
2264 maincqr
->status
= DASD_CQR_FILLED
;
2265 device
= maincqr
->startdev
;
2266 list_add(&maincqr
->blocklist
, &ccw_queue
);
2267 for (cqr
= maincqr
; __dasd_sleep_on_loop_condition(cqr
);
2268 cqr
= list_first_entry(&ccw_queue
,
2269 struct dasd_ccw_req
, blocklist
)) {
2271 if (__dasd_sleep_on_erp(cqr
))
2273 if (cqr
->status
!= DASD_CQR_FILLED
) /* could be failed */
2275 if (test_bit(DASD_FLAG_LOCK_STOLEN
, &device
->flags
) &&
2276 !test_bit(DASD_CQR_ALLOW_SLOCK
, &cqr
->flags
)) {
2277 cqr
->status
= DASD_CQR_FAILED
;
2278 cqr
->intrc
= -EPERM
;
2281 /* Non-temporary stop condition will trigger fail fast */
2282 if (device
->stopped
& ~DASD_STOPPED_PENDING
&&
2283 test_bit(DASD_CQR_FLAGS_FAILFAST
, &cqr
->flags
) &&
2284 (!dasd_eer_enabled(device
))) {
2285 cqr
->status
= DASD_CQR_FAILED
;
2286 cqr
->intrc
= -ENOLINK
;
2290 * Don't try to start requests if device is in
2291 * offline processing, it might wait forever
2293 if (test_bit(DASD_FLAG_OFFLINE
, &device
->flags
)) {
2294 cqr
->status
= DASD_CQR_FAILED
;
2295 cqr
->intrc
= -ENODEV
;
2299 * Don't try to start requests if device is stopped
2300 * except path verification requests
2302 if (!test_bit(DASD_CQR_VERIFY_PATH
, &cqr
->flags
)) {
2303 if (interruptible
) {
2304 rc
= wait_event_interruptible(
2305 generic_waitq
, !(device
->stopped
));
2306 if (rc
== -ERESTARTSYS
) {
2307 cqr
->status
= DASD_CQR_FAILED
;
2308 maincqr
->intrc
= rc
;
2312 wait_event(generic_waitq
, !(device
->stopped
));
2315 cqr
->callback
= dasd_wakeup_cb
;
2317 cqr
->callback_data
= DASD_SLEEPON_START_TAG
;
2318 dasd_add_request_tail(cqr
);
2319 if (interruptible
) {
2320 rc
= wait_event_interruptible(
2321 generic_waitq
, _wait_for_wakeup(cqr
));
2322 if (rc
== -ERESTARTSYS
) {
2323 dasd_cancel_req(cqr
);
2324 /* wait (non-interruptible) for final status */
2325 wait_event(generic_waitq
,
2326 _wait_for_wakeup(cqr
));
2327 cqr
->status
= DASD_CQR_FAILED
;
2328 maincqr
->intrc
= rc
;
2332 wait_event(generic_waitq
, _wait_for_wakeup(cqr
));
2335 maincqr
->endclk
= get_tod_clock();
2336 if ((maincqr
->status
!= DASD_CQR_DONE
) &&
2337 (maincqr
->intrc
!= -ERESTARTSYS
))
2338 dasd_log_sense(maincqr
, &maincqr
->irb
);
2339 if (maincqr
->status
== DASD_CQR_DONE
)
2341 else if (maincqr
->intrc
)
2342 rc
= maincqr
->intrc
;
2348 static inline int _wait_for_wakeup_queue(struct list_head
*ccw_queue
)
2350 struct dasd_ccw_req
*cqr
;
2352 list_for_each_entry(cqr
, ccw_queue
, blocklist
) {
2353 if (cqr
->callback_data
!= DASD_SLEEPON_END_TAG
)
2360 static int _dasd_sleep_on_queue(struct list_head
*ccw_queue
, int interruptible
)
2362 struct dasd_device
*device
;
2363 struct dasd_ccw_req
*cqr
, *n
;
2368 list_for_each_entry_safe(cqr
, n
, ccw_queue
, blocklist
) {
2369 device
= cqr
->startdev
;
2370 if (cqr
->status
!= DASD_CQR_FILLED
) /*could be failed*/
2373 if (test_bit(DASD_FLAG_LOCK_STOLEN
, &device
->flags
) &&
2374 !test_bit(DASD_CQR_ALLOW_SLOCK
, &cqr
->flags
)) {
2375 cqr
->status
= DASD_CQR_FAILED
;
2376 cqr
->intrc
= -EPERM
;
2379 /*Non-temporary stop condition will trigger fail fast*/
2380 if (device
->stopped
& ~DASD_STOPPED_PENDING
&&
2381 test_bit(DASD_CQR_FLAGS_FAILFAST
, &cqr
->flags
) &&
2382 !dasd_eer_enabled(device
)) {
2383 cqr
->status
= DASD_CQR_FAILED
;
2384 cqr
->intrc
= -EAGAIN
;
2388 /*Don't try to start requests if device is stopped*/
2389 if (interruptible
) {
2390 rc
= wait_event_interruptible(
2391 generic_waitq
, !device
->stopped
);
2392 if (rc
== -ERESTARTSYS
) {
2393 cqr
->status
= DASD_CQR_FAILED
;
2398 wait_event(generic_waitq
, !(device
->stopped
));
2401 cqr
->callback
= dasd_wakeup_cb
;
2402 cqr
->callback_data
= DASD_SLEEPON_START_TAG
;
2403 dasd_add_request_tail(cqr
);
2406 wait_event(generic_waitq
, _wait_for_wakeup_queue(ccw_queue
));
2409 list_for_each_entry_safe(cqr
, n
, ccw_queue
, blocklist
) {
2411 * In some cases the 'File Protected' or 'Incorrect Length'
2412 * error might be expected and error recovery would be
2413 * unnecessary in these cases. Check if the according suppress
2416 sense
= dasd_get_sense(&cqr
->irb
);
2417 if (sense
&& sense
[1] & SNS1_FILE_PROTECTED
&&
2418 test_bit(DASD_CQR_SUPPRESS_FP
, &cqr
->flags
))
2420 if (scsw_cstat(&cqr
->irb
.scsw
) == 0x40 &&
2421 test_bit(DASD_CQR_SUPPRESS_IL
, &cqr
->flags
))
2425 * for alias devices simplify error recovery and
2426 * return to upper layer
2427 * do not skip ERP requests
2429 if (cqr
->startdev
!= cqr
->basedev
&& !cqr
->refers
&&
2430 (cqr
->status
== DASD_CQR_TERMINATED
||
2431 cqr
->status
== DASD_CQR_NEED_ERP
))
2434 /* normal recovery for basedev IO */
2435 if (__dasd_sleep_on_erp(cqr
))
2436 /* handle erp first */
2444 * Queue a request to the tail of the device ccw_queue and wait for
2447 int dasd_sleep_on(struct dasd_ccw_req
*cqr
)
2449 return _dasd_sleep_on(cqr
, 0);
2451 EXPORT_SYMBOL(dasd_sleep_on
);
2454 * Start requests from a ccw_queue and wait for their completion.
2456 int dasd_sleep_on_queue(struct list_head
*ccw_queue
)
2458 return _dasd_sleep_on_queue(ccw_queue
, 0);
2460 EXPORT_SYMBOL(dasd_sleep_on_queue
);
2463 * Queue a request to the tail of the device ccw_queue and wait
2464 * interruptible for it's completion.
2466 int dasd_sleep_on_interruptible(struct dasd_ccw_req
*cqr
)
2468 return _dasd_sleep_on(cqr
, 1);
2470 EXPORT_SYMBOL(dasd_sleep_on_interruptible
);
2473 * Whoa nelly now it gets really hairy. For some functions (e.g. steal lock
2474 * for eckd devices) the currently running request has to be terminated
2475 * and be put back to status queued, before the special request is added
2476 * to the head of the queue. Then the special request is waited on normally.
2478 static inline int _dasd_term_running_cqr(struct dasd_device
*device
)
2480 struct dasd_ccw_req
*cqr
;
2483 if (list_empty(&device
->ccw_queue
))
2485 cqr
= list_entry(device
->ccw_queue
.next
, struct dasd_ccw_req
, devlist
);
2486 rc
= device
->discipline
->term_IO(cqr
);
2489 * CQR terminated because a more important request is pending.
2490 * Undo decreasing of retry counter because this is
2491 * not an error case.
2497 int dasd_sleep_on_immediatly(struct dasd_ccw_req
*cqr
)
2499 struct dasd_device
*device
;
2502 device
= cqr
->startdev
;
2503 if (test_bit(DASD_FLAG_LOCK_STOLEN
, &device
->flags
) &&
2504 !test_bit(DASD_CQR_ALLOW_SLOCK
, &cqr
->flags
)) {
2505 cqr
->status
= DASD_CQR_FAILED
;
2506 cqr
->intrc
= -EPERM
;
2509 spin_lock_irq(get_ccwdev_lock(device
->cdev
));
2510 rc
= _dasd_term_running_cqr(device
);
2512 spin_unlock_irq(get_ccwdev_lock(device
->cdev
));
2515 cqr
->callback
= dasd_wakeup_cb
;
2516 cqr
->callback_data
= DASD_SLEEPON_START_TAG
;
2517 cqr
->status
= DASD_CQR_QUEUED
;
2519 * add new request as second
2520 * first the terminated cqr needs to be finished
2522 list_add(&cqr
->devlist
, device
->ccw_queue
.next
);
2524 /* let the bh start the request to keep them in order */
2525 dasd_schedule_device_bh(device
);
2527 spin_unlock_irq(get_ccwdev_lock(device
->cdev
));
2529 wait_event(generic_waitq
, _wait_for_wakeup(cqr
));
2531 if (cqr
->status
== DASD_CQR_DONE
)
2533 else if (cqr
->intrc
)
2539 dasd_schedule_device_bh(device
);
2541 dasd_schedule_block_bh(device
->block
);
2545 EXPORT_SYMBOL(dasd_sleep_on_immediatly
);
2548 * Cancels a request that was started with dasd_sleep_on_req.
2549 * This is useful to timeout requests. The request will be
2550 * terminated if it is currently in i/o.
2551 * Returns 0 if request termination was successful
2552 * negative error code if termination failed
2553 * Cancellation of a request is an asynchronous operation! The calling
2554 * function has to wait until the request is properly returned via callback.
2556 int dasd_cancel_req(struct dasd_ccw_req
*cqr
)
2558 struct dasd_device
*device
= cqr
->startdev
;
2559 unsigned long flags
;
2563 spin_lock_irqsave(get_ccwdev_lock(device
->cdev
), flags
);
2564 switch (cqr
->status
) {
2565 case DASD_CQR_QUEUED
:
2566 /* request was not started - just set to cleared */
2567 cqr
->status
= DASD_CQR_CLEARED
;
2568 if (cqr
->callback_data
== DASD_SLEEPON_START_TAG
)
2569 cqr
->callback_data
= DASD_SLEEPON_END_TAG
;
2571 case DASD_CQR_IN_IO
:
2572 /* request in IO - terminate IO and release again */
2573 rc
= device
->discipline
->term_IO(cqr
);
2575 dev_err(&device
->cdev
->dev
,
2576 "Cancelling request %p failed with rc=%d\n",
2579 cqr
->stopclk
= get_tod_clock();
2582 default: /* already finished or clear pending - do nothing */
2585 spin_unlock_irqrestore(get_ccwdev_lock(device
->cdev
), flags
);
2586 dasd_schedule_device_bh(device
);
2589 EXPORT_SYMBOL(dasd_cancel_req
);
2592 * SECTION: Operations of the dasd_block layer.
2596 * Timeout function for dasd_block. This is used when the block layer
2597 * is waiting for something that may not come reliably, (e.g. a state
2600 static void dasd_block_timeout(unsigned long ptr
)
2602 unsigned long flags
;
2603 struct dasd_block
*block
;
2605 block
= (struct dasd_block
*) ptr
;
2606 spin_lock_irqsave(get_ccwdev_lock(block
->base
->cdev
), flags
);
2607 /* re-activate request queue */
2608 dasd_device_remove_stop_bits(block
->base
, DASD_STOPPED_PENDING
);
2609 spin_unlock_irqrestore(get_ccwdev_lock(block
->base
->cdev
), flags
);
2610 dasd_schedule_block_bh(block
);
2614 * Setup timeout for a dasd_block in jiffies.
2616 void dasd_block_set_timer(struct dasd_block
*block
, int expires
)
2619 del_timer(&block
->timer
);
2621 mod_timer(&block
->timer
, jiffies
+ expires
);
2623 EXPORT_SYMBOL(dasd_block_set_timer
);
2626 * Clear timeout for a dasd_block.
2628 void dasd_block_clear_timer(struct dasd_block
*block
)
2630 del_timer(&block
->timer
);
2632 EXPORT_SYMBOL(dasd_block_clear_timer
);
2635 * Process finished error recovery ccw.
2637 static void __dasd_process_erp(struct dasd_device
*device
,
2638 struct dasd_ccw_req
*cqr
)
2640 dasd_erp_fn_t erp_fn
;
2642 if (cqr
->status
== DASD_CQR_DONE
)
2643 DBF_DEV_EVENT(DBF_NOTICE
, device
, "%s", "ERP successful");
2645 dev_err(&device
->cdev
->dev
, "ERP failed for the DASD\n");
2646 erp_fn
= device
->discipline
->erp_postaction(cqr
);
2651 * Fetch requests from the block device queue.
2653 static void __dasd_process_request_queue(struct dasd_block
*block
)
2655 struct request_queue
*queue
;
2656 struct request
*req
;
2657 struct dasd_ccw_req
*cqr
;
2658 struct dasd_device
*basedev
;
2659 unsigned long flags
;
2660 queue
= block
->request_queue
;
2661 basedev
= block
->base
;
2662 /* No queue ? Then there is nothing to do. */
2667 * We requeue request from the block device queue to the ccw
2668 * queue only in two states. In state DASD_STATE_READY the
2669 * partition detection is done and we need to requeue requests
2670 * for that. State DASD_STATE_ONLINE is normal block device
2673 if (basedev
->state
< DASD_STATE_READY
) {
2674 while ((req
= blk_fetch_request(block
->request_queue
)))
2675 __blk_end_request_all(req
, -EIO
);
2680 * if device is stopped do not fetch new requests
2681 * except failfast is active which will let requests fail
2682 * immediately in __dasd_block_start_head()
2684 if (basedev
->stopped
&& !(basedev
->features
& DASD_FEATURE_FAILFAST
))
2687 /* Now we try to fetch requests from the request queue */
2688 while ((req
= blk_peek_request(queue
))) {
2689 if (basedev
->features
& DASD_FEATURE_READONLY
&&
2690 rq_data_dir(req
) == WRITE
) {
2691 DBF_DEV_EVENT(DBF_ERR
, basedev
,
2692 "Rejecting write request %p",
2694 blk_start_request(req
);
2695 __blk_end_request_all(req
, -EIO
);
2698 if (test_bit(DASD_FLAG_ABORTALL
, &basedev
->flags
) &&
2699 (basedev
->features
& DASD_FEATURE_FAILFAST
||
2700 blk_noretry_request(req
))) {
2701 DBF_DEV_EVENT(DBF_ERR
, basedev
,
2702 "Rejecting failfast request %p",
2704 blk_start_request(req
);
2705 __blk_end_request_all(req
, -ETIMEDOUT
);
2708 cqr
= basedev
->discipline
->build_cp(basedev
, block
, req
);
2710 if (PTR_ERR(cqr
) == -EBUSY
)
2711 break; /* normal end condition */
2712 if (PTR_ERR(cqr
) == -ENOMEM
)
2713 break; /* terminate request queue loop */
2714 if (PTR_ERR(cqr
) == -EAGAIN
) {
2716 * The current request cannot be build right
2717 * now, we have to try later. If this request
2718 * is the head-of-queue we stop the device
2721 if (!list_empty(&block
->ccw_queue
))
2724 get_ccwdev_lock(basedev
->cdev
), flags
);
2725 dasd_device_set_stop_bits(basedev
,
2726 DASD_STOPPED_PENDING
);
2727 spin_unlock_irqrestore(
2728 get_ccwdev_lock(basedev
->cdev
), flags
);
2729 dasd_block_set_timer(block
, HZ
/2);
2732 DBF_DEV_EVENT(DBF_ERR
, basedev
,
2733 "CCW creation failed (rc=%ld) "
2736 blk_start_request(req
);
2737 __blk_end_request_all(req
, -EIO
);
2741 * Note: callback is set to dasd_return_cqr_cb in
2742 * __dasd_block_start_head to cover erp requests as well
2744 cqr
->callback_data
= (void *) req
;
2745 cqr
->status
= DASD_CQR_FILLED
;
2746 req
->completion_data
= cqr
;
2747 blk_start_request(req
);
2748 list_add_tail(&cqr
->blocklist
, &block
->ccw_queue
);
2749 INIT_LIST_HEAD(&cqr
->devlist
);
2750 dasd_profile_start(block
, cqr
, req
);
2754 static void __dasd_cleanup_cqr(struct dasd_ccw_req
*cqr
)
2756 struct request
*req
;
2760 req
= (struct request
*) cqr
->callback_data
;
2761 dasd_profile_end(cqr
->block
, cqr
, req
);
2762 status
= cqr
->block
->base
->discipline
->free_cp(cqr
, req
);
2765 else if (status
== 0) {
2766 if (cqr
->intrc
== -EPERM
)
2768 else if (cqr
->intrc
== -ENOLINK
||
2769 cqr
->intrc
== -ETIMEDOUT
)
2774 __blk_end_request_all(req
, error
);
2778 * Process ccw request queue.
2780 static void __dasd_process_block_ccw_queue(struct dasd_block
*block
,
2781 struct list_head
*final_queue
)
2783 struct list_head
*l
, *n
;
2784 struct dasd_ccw_req
*cqr
;
2785 dasd_erp_fn_t erp_fn
;
2786 unsigned long flags
;
2787 struct dasd_device
*base
= block
->base
;
2790 /* Process request with final status. */
2791 list_for_each_safe(l
, n
, &block
->ccw_queue
) {
2792 cqr
= list_entry(l
, struct dasd_ccw_req
, blocklist
);
2793 if (cqr
->status
!= DASD_CQR_DONE
&&
2794 cqr
->status
!= DASD_CQR_FAILED
&&
2795 cqr
->status
!= DASD_CQR_NEED_ERP
&&
2796 cqr
->status
!= DASD_CQR_TERMINATED
)
2799 if (cqr
->status
== DASD_CQR_TERMINATED
) {
2800 base
->discipline
->handle_terminated_request(cqr
);
2804 /* Process requests that may be recovered */
2805 if (cqr
->status
== DASD_CQR_NEED_ERP
) {
2806 erp_fn
= base
->discipline
->erp_action(cqr
);
2807 if (IS_ERR(erp_fn(cqr
)))
2812 /* log sense for fatal error */
2813 if (cqr
->status
== DASD_CQR_FAILED
) {
2814 dasd_log_sense(cqr
, &cqr
->irb
);
2817 /* First of all call extended error reporting. */
2818 if (dasd_eer_enabled(base
) &&
2819 cqr
->status
== DASD_CQR_FAILED
) {
2820 dasd_eer_write(base
, cqr
, DASD_EER_FATALERROR
);
2822 /* restart request */
2823 cqr
->status
= DASD_CQR_FILLED
;
2825 spin_lock_irqsave(get_ccwdev_lock(base
->cdev
), flags
);
2826 dasd_device_set_stop_bits(base
, DASD_STOPPED_QUIESCE
);
2827 spin_unlock_irqrestore(get_ccwdev_lock(base
->cdev
),
2832 /* Process finished ERP request. */
2834 __dasd_process_erp(base
, cqr
);
2838 /* Rechain finished requests to final queue */
2839 cqr
->endclk
= get_tod_clock();
2840 list_move_tail(&cqr
->blocklist
, final_queue
);
2844 static void dasd_return_cqr_cb(struct dasd_ccw_req
*cqr
, void *data
)
2846 dasd_schedule_block_bh(cqr
->block
);
2849 static void __dasd_block_start_head(struct dasd_block
*block
)
2851 struct dasd_ccw_req
*cqr
;
2853 if (list_empty(&block
->ccw_queue
))
2855 /* We allways begin with the first requests on the queue, as some
2856 * of previously started requests have to be enqueued on a
2857 * dasd_device again for error recovery.
2859 list_for_each_entry(cqr
, &block
->ccw_queue
, blocklist
) {
2860 if (cqr
->status
!= DASD_CQR_FILLED
)
2862 if (test_bit(DASD_FLAG_LOCK_STOLEN
, &block
->base
->flags
) &&
2863 !test_bit(DASD_CQR_ALLOW_SLOCK
, &cqr
->flags
)) {
2864 cqr
->status
= DASD_CQR_FAILED
;
2865 cqr
->intrc
= -EPERM
;
2866 dasd_schedule_block_bh(block
);
2869 /* Non-temporary stop condition will trigger fail fast */
2870 if (block
->base
->stopped
& ~DASD_STOPPED_PENDING
&&
2871 test_bit(DASD_CQR_FLAGS_FAILFAST
, &cqr
->flags
) &&
2872 (!dasd_eer_enabled(block
->base
))) {
2873 cqr
->status
= DASD_CQR_FAILED
;
2874 cqr
->intrc
= -ENOLINK
;
2875 dasd_schedule_block_bh(block
);
2878 /* Don't try to start requests if device is stopped */
2879 if (block
->base
->stopped
)
2882 /* just a fail safe check, should not happen */
2884 cqr
->startdev
= block
->base
;
2886 /* make sure that the requests we submit find their way back */
2887 cqr
->callback
= dasd_return_cqr_cb
;
2889 dasd_add_request_tail(cqr
);
2894 * Central dasd_block layer routine. Takes requests from the generic
2895 * block layer request queue, creates ccw requests, enqueues them on
2896 * a dasd_device and processes ccw requests that have been returned.
2898 static void dasd_block_tasklet(struct dasd_block
*block
)
2900 struct list_head final_queue
;
2901 struct list_head
*l
, *n
;
2902 struct dasd_ccw_req
*cqr
;
2904 atomic_set(&block
->tasklet_scheduled
, 0);
2905 INIT_LIST_HEAD(&final_queue
);
2906 spin_lock(&block
->queue_lock
);
2907 /* Finish off requests on ccw queue */
2908 __dasd_process_block_ccw_queue(block
, &final_queue
);
2909 spin_unlock(&block
->queue_lock
);
2910 /* Now call the callback function of requests with final status */
2911 spin_lock_irq(&block
->request_queue_lock
);
2912 list_for_each_safe(l
, n
, &final_queue
) {
2913 cqr
= list_entry(l
, struct dasd_ccw_req
, blocklist
);
2914 list_del_init(&cqr
->blocklist
);
2915 __dasd_cleanup_cqr(cqr
);
2917 spin_lock(&block
->queue_lock
);
2918 /* Get new request from the block device request queue */
2919 __dasd_process_request_queue(block
);
2920 /* Now check if the head of the ccw queue needs to be started. */
2921 __dasd_block_start_head(block
);
2922 spin_unlock(&block
->queue_lock
);
2923 spin_unlock_irq(&block
->request_queue_lock
);
2924 if (waitqueue_active(&shutdown_waitq
))
2925 wake_up(&shutdown_waitq
);
2926 dasd_put_device(block
->base
);
2929 static void _dasd_wake_block_flush_cb(struct dasd_ccw_req
*cqr
, void *data
)
2931 wake_up(&dasd_flush_wq
);
2935 * Requeue a request back to the block request queue
2936 * only works for block requests
2938 static int _dasd_requeue_request(struct dasd_ccw_req
*cqr
)
2940 struct dasd_block
*block
= cqr
->block
;
2941 struct request
*req
;
2942 unsigned long flags
;
2946 spin_lock_irqsave(&block
->request_queue_lock
, flags
);
2947 req
= (struct request
*) cqr
->callback_data
;
2948 blk_requeue_request(block
->request_queue
, req
);
2949 spin_unlock_irqrestore(&block
->request_queue_lock
, flags
);
2955 * Go through all request on the dasd_block request queue, cancel them
2956 * on the respective dasd_device, and return them to the generic
2959 static int dasd_flush_block_queue(struct dasd_block
*block
)
2961 struct dasd_ccw_req
*cqr
, *n
;
2963 struct list_head flush_queue
;
2965 INIT_LIST_HEAD(&flush_queue
);
2966 spin_lock_bh(&block
->queue_lock
);
2969 list_for_each_entry_safe(cqr
, n
, &block
->ccw_queue
, blocklist
) {
2970 /* if this request currently owned by a dasd_device cancel it */
2971 if (cqr
->status
>= DASD_CQR_QUEUED
)
2972 rc
= dasd_cancel_req(cqr
);
2975 /* Rechain request (including erp chain) so it won't be
2976 * touched by the dasd_block_tasklet anymore.
2977 * Replace the callback so we notice when the request
2978 * is returned from the dasd_device layer.
2980 cqr
->callback
= _dasd_wake_block_flush_cb
;
2981 for (i
= 0; cqr
!= NULL
; cqr
= cqr
->refers
, i
++)
2982 list_move_tail(&cqr
->blocklist
, &flush_queue
);
2984 /* moved more than one request - need to restart */
2987 spin_unlock_bh(&block
->queue_lock
);
2988 /* Now call the callback function of flushed requests */
2990 list_for_each_entry_safe(cqr
, n
, &flush_queue
, blocklist
) {
2991 wait_event(dasd_flush_wq
, (cqr
->status
< DASD_CQR_QUEUED
));
2992 /* Process finished ERP request. */
2994 spin_lock_bh(&block
->queue_lock
);
2995 __dasd_process_erp(block
->base
, cqr
);
2996 spin_unlock_bh(&block
->queue_lock
);
2997 /* restart list_for_xx loop since dasd_process_erp
2998 * might remove multiple elements */
3001 /* call the callback function */
3002 spin_lock_irq(&block
->request_queue_lock
);
3003 cqr
->endclk
= get_tod_clock();
3004 list_del_init(&cqr
->blocklist
);
3005 __dasd_cleanup_cqr(cqr
);
3006 spin_unlock_irq(&block
->request_queue_lock
);
3012 * Schedules a call to dasd_tasklet over the device tasklet.
3014 void dasd_schedule_block_bh(struct dasd_block
*block
)
3016 /* Protect against rescheduling. */
3017 if (atomic_cmpxchg(&block
->tasklet_scheduled
, 0, 1) != 0)
3019 /* life cycle of block is bound to it's base device */
3020 dasd_get_device(block
->base
);
3021 tasklet_hi_schedule(&block
->tasklet
);
3023 EXPORT_SYMBOL(dasd_schedule_block_bh
);
3027 * SECTION: external block device operations
3028 * (request queue handling, open, release, etc.)
3032 * Dasd request queue function. Called from ll_rw_blk.c
3034 static void do_dasd_request(struct request_queue
*queue
)
3036 struct dasd_block
*block
;
3038 block
= queue
->queuedata
;
3039 spin_lock(&block
->queue_lock
);
3040 /* Get new request from the block device request queue */
3041 __dasd_process_request_queue(block
);
3042 /* Now check if the head of the ccw queue needs to be started. */
3043 __dasd_block_start_head(block
);
3044 spin_unlock(&block
->queue_lock
);
3048 * Block timeout callback, called from the block layer
3050 * request_queue lock is held on entry.
3053 * BLK_EH_RESET_TIMER if the request should be left running
3054 * BLK_EH_NOT_HANDLED if the request is handled or terminated
3057 enum blk_eh_timer_return
dasd_times_out(struct request
*req
)
3059 struct dasd_ccw_req
*cqr
= req
->completion_data
;
3060 struct dasd_block
*block
= req
->q
->queuedata
;
3061 struct dasd_device
*device
;
3065 return BLK_EH_NOT_HANDLED
;
3067 device
= cqr
->startdev
? cqr
->startdev
: block
->base
;
3068 if (!device
->blk_timeout
)
3069 return BLK_EH_RESET_TIMER
;
3070 DBF_DEV_EVENT(DBF_WARNING
, device
,
3071 " dasd_times_out cqr %p status %x",
3074 spin_lock(&block
->queue_lock
);
3075 spin_lock(get_ccwdev_lock(device
->cdev
));
3077 cqr
->intrc
= -ETIMEDOUT
;
3078 if (cqr
->status
>= DASD_CQR_QUEUED
) {
3079 spin_unlock(get_ccwdev_lock(device
->cdev
));
3080 rc
= dasd_cancel_req(cqr
);
3081 } else if (cqr
->status
== DASD_CQR_FILLED
||
3082 cqr
->status
== DASD_CQR_NEED_ERP
) {
3083 cqr
->status
= DASD_CQR_TERMINATED
;
3084 spin_unlock(get_ccwdev_lock(device
->cdev
));
3085 } else if (cqr
->status
== DASD_CQR_IN_ERP
) {
3086 struct dasd_ccw_req
*searchcqr
, *nextcqr
, *tmpcqr
;
3088 list_for_each_entry_safe(searchcqr
, nextcqr
,
3089 &block
->ccw_queue
, blocklist
) {
3091 while (tmpcqr
->refers
)
3092 tmpcqr
= tmpcqr
->refers
;
3095 /* searchcqr is an ERP request for cqr */
3096 searchcqr
->retries
= -1;
3097 searchcqr
->intrc
= -ETIMEDOUT
;
3098 if (searchcqr
->status
>= DASD_CQR_QUEUED
) {
3099 spin_unlock(get_ccwdev_lock(device
->cdev
));
3100 rc
= dasd_cancel_req(searchcqr
);
3101 spin_lock(get_ccwdev_lock(device
->cdev
));
3102 } else if ((searchcqr
->status
== DASD_CQR_FILLED
) ||
3103 (searchcqr
->status
== DASD_CQR_NEED_ERP
)) {
3104 searchcqr
->status
= DASD_CQR_TERMINATED
;
3106 } else if (searchcqr
->status
== DASD_CQR_IN_ERP
) {
3108 * Shouldn't happen; most recent ERP
3109 * request is at the front of queue
3115 spin_unlock(get_ccwdev_lock(device
->cdev
));
3117 dasd_schedule_block_bh(block
);
3118 spin_unlock(&block
->queue_lock
);
3120 return rc
? BLK_EH_RESET_TIMER
: BLK_EH_NOT_HANDLED
;
3124 * Allocate and initialize request queue and default I/O scheduler.
3126 static int dasd_alloc_queue(struct dasd_block
*block
)
3128 block
->request_queue
= blk_init_queue(do_dasd_request
,
3129 &block
->request_queue_lock
);
3130 if (block
->request_queue
== NULL
)
3133 block
->request_queue
->queuedata
= block
;
3139 * Allocate and initialize request queue.
3141 static void dasd_setup_queue(struct dasd_block
*block
)
3143 struct request_queue
*q
= block
->request_queue
;
3146 if (block
->base
->features
& DASD_FEATURE_USERAW
) {
3148 * the max_blocks value for raw_track access is 256
3149 * it is higher than the native ECKD value because we
3150 * only need one ccw per track
3151 * so the max_hw_sectors are
3152 * 2048 x 512B = 1024kB = 16 tracks
3156 max
= block
->base
->discipline
->max_blocks
<< block
->s2b_shift
;
3158 queue_flag_set_unlocked(QUEUE_FLAG_NONROT
, q
);
3159 q
->limits
.max_dev_sectors
= max
;
3160 blk_queue_logical_block_size(q
, block
->bp_block
);
3161 blk_queue_max_hw_sectors(q
, max
);
3162 blk_queue_max_segments(q
, USHRT_MAX
);
3163 /* with page sized segments we can translate each segement into
3166 blk_queue_max_segment_size(q
, PAGE_SIZE
);
3167 blk_queue_segment_boundary(q
, PAGE_SIZE
- 1);
3171 * Deactivate and free request queue.
3173 static void dasd_free_queue(struct dasd_block
*block
)
3175 if (block
->request_queue
) {
3176 blk_cleanup_queue(block
->request_queue
);
3177 block
->request_queue
= NULL
;
3182 * Flush request on the request queue.
3184 static void dasd_flush_request_queue(struct dasd_block
*block
)
3186 struct request
*req
;
3188 if (!block
->request_queue
)
3191 spin_lock_irq(&block
->request_queue_lock
);
3192 while ((req
= blk_fetch_request(block
->request_queue
)))
3193 __blk_end_request_all(req
, -EIO
);
3194 spin_unlock_irq(&block
->request_queue_lock
);
3197 static int dasd_open(struct block_device
*bdev
, fmode_t mode
)
3199 struct dasd_device
*base
;
3202 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
3206 atomic_inc(&base
->block
->open_count
);
3207 if (test_bit(DASD_FLAG_OFFLINE
, &base
->flags
)) {
3212 if (!try_module_get(base
->discipline
->owner
)) {
3217 if (dasd_probeonly
) {
3218 dev_info(&base
->cdev
->dev
,
3219 "Accessing the DASD failed because it is in "
3220 "probeonly mode\n");
3225 if (base
->state
<= DASD_STATE_BASIC
) {
3226 DBF_DEV_EVENT(DBF_ERR
, base
, " %s",
3227 " Cannot open unrecognized device");
3232 if ((mode
& FMODE_WRITE
) &&
3233 (test_bit(DASD_FLAG_DEVICE_RO
, &base
->flags
) ||
3234 (base
->features
& DASD_FEATURE_READONLY
))) {
3239 dasd_put_device(base
);
3243 module_put(base
->discipline
->owner
);
3245 atomic_dec(&base
->block
->open_count
);
3246 dasd_put_device(base
);
3250 static void dasd_release(struct gendisk
*disk
, fmode_t mode
)
3252 struct dasd_device
*base
= dasd_device_from_gendisk(disk
);
3254 atomic_dec(&base
->block
->open_count
);
3255 module_put(base
->discipline
->owner
);
3256 dasd_put_device(base
);
3261 * Return disk geometry.
3263 static int dasd_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
3265 struct dasd_device
*base
;
3267 base
= dasd_device_from_gendisk(bdev
->bd_disk
);
3271 if (!base
->discipline
||
3272 !base
->discipline
->fill_geometry
) {
3273 dasd_put_device(base
);
3276 base
->discipline
->fill_geometry(base
->block
, geo
);
3277 geo
->start
= get_start_sect(bdev
) >> base
->block
->s2b_shift
;
3278 dasd_put_device(base
);
3282 const struct block_device_operations
3283 dasd_device_operations
= {
3284 .owner
= THIS_MODULE
,
3286 .release
= dasd_release
,
3287 .ioctl
= dasd_ioctl
,
3288 .compat_ioctl
= dasd_ioctl
,
3289 .getgeo
= dasd_getgeo
,
3292 /*******************************************************************************
3293 * end of block device operations
3299 #ifdef CONFIG_PROC_FS
3303 if (dasd_page_cache
!= NULL
) {
3304 kmem_cache_destroy(dasd_page_cache
);
3305 dasd_page_cache
= NULL
;
3307 dasd_gendisk_exit();
3309 if (dasd_debug_area
!= NULL
) {
3310 debug_unregister(dasd_debug_area
);
3311 dasd_debug_area
= NULL
;
3313 dasd_statistics_removeroot();
3317 * SECTION: common functions for ccw_driver use
3321 * Is the device read-only?
3322 * Note that this function does not report the setting of the
3323 * readonly device attribute, but how it is configured in z/VM.
3325 int dasd_device_is_ro(struct dasd_device
*device
)
3327 struct ccw_dev_id dev_id
;
3328 struct diag210 diag_data
;
3333 ccw_device_get_id(device
->cdev
, &dev_id
);
3334 memset(&diag_data
, 0, sizeof(diag_data
));
3335 diag_data
.vrdcdvno
= dev_id
.devno
;
3336 diag_data
.vrdclen
= sizeof(diag_data
);
3337 rc
= diag210(&diag_data
);
3338 if (rc
== 0 || rc
== 2) {
3339 return diag_data
.vrdcvfla
& 0x80;
3341 DBF_EVENT(DBF_WARNING
, "diag210 failed for dev=%04x with rc=%d",
3346 EXPORT_SYMBOL_GPL(dasd_device_is_ro
);
3348 static void dasd_generic_auto_online(void *data
, async_cookie_t cookie
)
3350 struct ccw_device
*cdev
= data
;
3353 ret
= ccw_device_set_online(cdev
);
3355 pr_warn("%s: Setting the DASD online failed with rc=%d\n",
3356 dev_name(&cdev
->dev
), ret
);
3360 * Initial attempt at a probe function. this can be simplified once
3361 * the other detection code is gone.
3363 int dasd_generic_probe(struct ccw_device
*cdev
,
3364 struct dasd_discipline
*discipline
)
3368 ret
= dasd_add_sysfs_files(cdev
);
3370 DBF_EVENT_DEVID(DBF_WARNING
, cdev
, "%s",
3371 "dasd_generic_probe: could not add "
3375 cdev
->handler
= &dasd_int_handler
;
3378 * Automatically online either all dasd devices (dasd_autodetect)
3379 * or all devices specified with dasd= parameters during
3382 if ((dasd_get_feature(cdev
, DASD_FEATURE_INITIAL_ONLINE
) > 0 ) ||
3383 (dasd_autodetect
&& dasd_busid_known(dev_name(&cdev
->dev
)) != 0))
3384 async_schedule(dasd_generic_auto_online
, cdev
);
3387 EXPORT_SYMBOL_GPL(dasd_generic_probe
);
3389 void dasd_generic_free_discipline(struct dasd_device
*device
)
3391 /* Forget the discipline information. */
3392 if (device
->discipline
) {
3393 if (device
->discipline
->uncheck_device
)
3394 device
->discipline
->uncheck_device(device
);
3395 module_put(device
->discipline
->owner
);
3396 device
->discipline
= NULL
;
3398 if (device
->base_discipline
) {
3399 module_put(device
->base_discipline
->owner
);
3400 device
->base_discipline
= NULL
;
3403 EXPORT_SYMBOL_GPL(dasd_generic_free_discipline
);
3406 * This will one day be called from a global not_oper handler.
3407 * It is also used by driver_unregister during module unload.
3409 void dasd_generic_remove(struct ccw_device
*cdev
)
3411 struct dasd_device
*device
;
3412 struct dasd_block
*block
;
3414 cdev
->handler
= NULL
;
3416 device
= dasd_device_from_cdev(cdev
);
3417 if (IS_ERR(device
)) {
3418 dasd_remove_sysfs_files(cdev
);
3421 if (test_and_set_bit(DASD_FLAG_OFFLINE
, &device
->flags
) &&
3422 !test_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING
, &device
->flags
)) {
3423 /* Already doing offline processing */
3424 dasd_put_device(device
);
3425 dasd_remove_sysfs_files(cdev
);
3429 * This device is removed unconditionally. Set offline
3430 * flag to prevent dasd_open from opening it while it is
3431 * no quite down yet.
3433 dasd_set_target_state(device
, DASD_STATE_NEW
);
3434 /* dasd_delete_device destroys the device reference. */
3435 block
= device
->block
;
3436 dasd_delete_device(device
);
3438 * life cycle of block is bound to device, so delete it after
3439 * device was safely removed
3442 dasd_free_block(block
);
3444 dasd_remove_sysfs_files(cdev
);
3446 EXPORT_SYMBOL_GPL(dasd_generic_remove
);
3449 * Activate a device. This is called from dasd_{eckd,fba}_probe() when either
3450 * the device is detected for the first time and is supposed to be used
3451 * or the user has started activation through sysfs.
3453 int dasd_generic_set_online(struct ccw_device
*cdev
,
3454 struct dasd_discipline
*base_discipline
)
3456 struct dasd_discipline
*discipline
;
3457 struct dasd_device
*device
;
3460 /* first online clears initial online feature flag */
3461 dasd_set_feature(cdev
, DASD_FEATURE_INITIAL_ONLINE
, 0);
3462 device
= dasd_create_device(cdev
);
3464 return PTR_ERR(device
);
3466 discipline
= base_discipline
;
3467 if (device
->features
& DASD_FEATURE_USEDIAG
) {
3468 if (!dasd_diag_discipline_pointer
) {
3469 /* Try to load the required module. */
3470 rc
= request_module(DASD_DIAG_MOD
);
3472 pr_warn("%s Setting the DASD online failed "
3473 "because the required module %s "
3474 "could not be loaded (rc=%d)\n",
3475 dev_name(&cdev
->dev
), DASD_DIAG_MOD
,
3477 dasd_delete_device(device
);
3481 /* Module init could have failed, so check again here after
3482 * request_module(). */
3483 if (!dasd_diag_discipline_pointer
) {
3484 pr_warn("%s Setting the DASD online failed because of missing DIAG discipline\n",
3485 dev_name(&cdev
->dev
));
3486 dasd_delete_device(device
);
3489 discipline
= dasd_diag_discipline_pointer
;
3491 if (!try_module_get(base_discipline
->owner
)) {
3492 dasd_delete_device(device
);
3495 if (!try_module_get(discipline
->owner
)) {
3496 module_put(base_discipline
->owner
);
3497 dasd_delete_device(device
);
3500 device
->base_discipline
= base_discipline
;
3501 device
->discipline
= discipline
;
3503 /* check_device will allocate block device if necessary */
3504 rc
= discipline
->check_device(device
);
3506 pr_warn("%s Setting the DASD online with discipline %s failed with rc=%i\n",
3507 dev_name(&cdev
->dev
), discipline
->name
, rc
);
3508 module_put(discipline
->owner
);
3509 module_put(base_discipline
->owner
);
3510 dasd_delete_device(device
);
3514 dasd_set_target_state(device
, DASD_STATE_ONLINE
);
3515 if (device
->state
<= DASD_STATE_KNOWN
) {
3516 pr_warn("%s Setting the DASD online failed because of a missing discipline\n",
3517 dev_name(&cdev
->dev
));
3519 dasd_set_target_state(device
, DASD_STATE_NEW
);
3521 dasd_free_block(device
->block
);
3522 dasd_delete_device(device
);
3524 pr_debug("dasd_generic device %s found\n",
3525 dev_name(&cdev
->dev
));
3527 wait_event(dasd_init_waitq
, _wait_for_device(device
));
3529 dasd_put_device(device
);
3532 EXPORT_SYMBOL_GPL(dasd_generic_set_online
);
3534 int dasd_generic_set_offline(struct ccw_device
*cdev
)
3536 struct dasd_device
*device
;
3537 struct dasd_block
*block
;
3538 int max_count
, open_count
, rc
;
3539 unsigned long flags
;
3542 spin_lock_irqsave(get_ccwdev_lock(cdev
), flags
);
3543 device
= dasd_device_from_cdev_locked(cdev
);
3544 if (IS_ERR(device
)) {
3545 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
3546 return PTR_ERR(device
);
3550 * We must make sure that this device is currently not in use.
3551 * The open_count is increased for every opener, that includes
3552 * the blkdev_get in dasd_scan_partitions. We are only interested
3553 * in the other openers.
3555 if (device
->block
) {
3556 max_count
= device
->block
->bdev
? 0 : -1;
3557 open_count
= atomic_read(&device
->block
->open_count
);
3558 if (open_count
> max_count
) {
3560 pr_warn("%s: The DASD cannot be set offline with open count %i\n",
3561 dev_name(&cdev
->dev
), open_count
);
3563 pr_warn("%s: The DASD cannot be set offline while it is in use\n",
3564 dev_name(&cdev
->dev
));
3565 clear_bit(DASD_FLAG_OFFLINE
, &device
->flags
);
3570 if (test_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING
, &device
->flags
)) {
3572 * safe offline already running
3573 * could only be called by normal offline so safe_offline flag
3574 * needs to be removed to run normal offline and kill all I/O
3576 if (test_and_set_bit(DASD_FLAG_OFFLINE
, &device
->flags
))
3577 /* Already doing normal offline processing */
3580 clear_bit(DASD_FLAG_SAFE_OFFLINE
, &device
->flags
);
3582 if (test_bit(DASD_FLAG_OFFLINE
, &device
->flags
))
3583 /* Already doing offline processing */
3587 set_bit(DASD_FLAG_OFFLINE
, &device
->flags
);
3588 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
3591 * if safe_offline called set safe_offline_running flag and
3592 * clear safe_offline so that a call to normal offline
3593 * can overrun safe_offline processing
3595 if (test_and_clear_bit(DASD_FLAG_SAFE_OFFLINE
, &device
->flags
) &&
3596 !test_and_set_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING
, &device
->flags
)) {
3598 * If we want to set the device safe offline all IO operations
3599 * should be finished before continuing the offline process
3600 * so sync bdev first and then wait for our queues to become
3603 /* sync blockdev and partitions */
3604 if (device
->block
) {
3605 rc
= fsync_bdev(device
->block
->bdev
);
3609 /* schedule device tasklet and wait for completion */
3610 dasd_schedule_device_bh(device
);
3611 rc
= wait_event_interruptible(shutdown_waitq
,
3612 _wait_for_empty_queues(device
));
3617 dasd_set_target_state(device
, DASD_STATE_NEW
);
3618 /* dasd_delete_device destroys the device reference. */
3619 block
= device
->block
;
3620 dasd_delete_device(device
);
3622 * life cycle of block is bound to device, so delete it after
3623 * device was safely removed
3626 dasd_free_block(block
);
3630 /* interrupted by signal */
3631 clear_bit(DASD_FLAG_SAFE_OFFLINE
, &device
->flags
);
3632 clear_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING
, &device
->flags
);
3633 clear_bit(DASD_FLAG_OFFLINE
, &device
->flags
);
3634 dasd_put_device(device
);
3639 dasd_put_device(device
);
3640 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
3644 EXPORT_SYMBOL_GPL(dasd_generic_set_offline
);
3646 int dasd_generic_last_path_gone(struct dasd_device
*device
)
3648 struct dasd_ccw_req
*cqr
;
3650 dev_warn(&device
->cdev
->dev
, "No operational channel path is left "
3651 "for the device\n");
3652 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s", "last path gone");
3653 /* First of all call extended error reporting. */
3654 dasd_eer_write(device
, NULL
, DASD_EER_NOPATH
);
3656 if (device
->state
< DASD_STATE_BASIC
)
3658 /* Device is active. We want to keep it. */
3659 list_for_each_entry(cqr
, &device
->ccw_queue
, devlist
)
3660 if ((cqr
->status
== DASD_CQR_IN_IO
) ||
3661 (cqr
->status
== DASD_CQR_CLEAR_PENDING
)) {
3662 cqr
->status
= DASD_CQR_QUEUED
;
3665 dasd_device_set_stop_bits(device
, DASD_STOPPED_DC_WAIT
);
3666 dasd_device_clear_timer(device
);
3667 dasd_schedule_device_bh(device
);
3670 EXPORT_SYMBOL_GPL(dasd_generic_last_path_gone
);
3672 int dasd_generic_path_operational(struct dasd_device
*device
)
3674 dev_info(&device
->cdev
->dev
, "A channel path to the device has become "
3676 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s", "path operational");
3677 dasd_device_remove_stop_bits(device
, DASD_STOPPED_DC_WAIT
);
3678 if (device
->stopped
& DASD_UNRESUMED_PM
) {
3679 dasd_device_remove_stop_bits(device
, DASD_UNRESUMED_PM
);
3680 dasd_restore_device(device
);
3683 dasd_schedule_device_bh(device
);
3685 dasd_schedule_block_bh(device
->block
);
3687 if (!device
->stopped
)
3688 wake_up(&generic_waitq
);
3692 EXPORT_SYMBOL_GPL(dasd_generic_path_operational
);
3694 int dasd_generic_notify(struct ccw_device
*cdev
, int event
)
3696 struct dasd_device
*device
;
3699 device
= dasd_device_from_cdev_locked(cdev
);
3707 dasd_path_no_path(device
);
3708 ret
= dasd_generic_last_path_gone(device
);
3712 if (dasd_path_get_opm(device
))
3713 ret
= dasd_generic_path_operational(device
);
3716 dasd_put_device(device
);
3719 EXPORT_SYMBOL_GPL(dasd_generic_notify
);
3721 void dasd_generic_path_event(struct ccw_device
*cdev
, int *path_event
)
3723 struct dasd_device
*device
;
3724 int chp
, oldopm
, hpfpm
, ifccpm
;
3726 device
= dasd_device_from_cdev_locked(cdev
);
3730 oldopm
= dasd_path_get_opm(device
);
3731 for (chp
= 0; chp
< 8; chp
++) {
3732 if (path_event
[chp
] & PE_PATH_GONE
) {
3733 dasd_path_notoper(device
, chp
);
3735 if (path_event
[chp
] & PE_PATH_AVAILABLE
) {
3736 dasd_path_available(device
, chp
);
3737 dasd_schedule_device_bh(device
);
3739 if (path_event
[chp
] & PE_PATHGROUP_ESTABLISHED
) {
3740 if (!dasd_path_is_operational(device
, chp
) &&
3741 !dasd_path_need_verify(device
, chp
)) {
3743 * we can not establish a pathgroup on an
3744 * unavailable path, so trigger a path
3745 * verification first
3747 dasd_path_available(device
, chp
);
3748 dasd_schedule_device_bh(device
);
3750 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
3751 "Pathgroup re-established\n");
3752 if (device
->discipline
->kick_validate
)
3753 device
->discipline
->kick_validate(device
);
3756 hpfpm
= dasd_path_get_hpfpm(device
);
3757 ifccpm
= dasd_path_get_ifccpm(device
);
3758 if (!dasd_path_get_opm(device
) && hpfpm
) {
3760 * device has no operational paths but at least one path is
3761 * disabled due to HPF errors
3762 * disable HPF at all and use the path(s) again
3764 if (device
->discipline
->disable_hpf
)
3765 device
->discipline
->disable_hpf(device
);
3766 dasd_device_set_stop_bits(device
, DASD_STOPPED_NOT_ACC
);
3767 dasd_path_set_tbvpm(device
, hpfpm
);
3768 dasd_schedule_device_bh(device
);
3769 dasd_schedule_requeue(device
);
3770 } else if (!dasd_path_get_opm(device
) && ifccpm
) {
3772 * device has no operational paths but at least one path is
3773 * disabled due to IFCC errors
3774 * trigger path verification on paths with IFCC errors
3776 dasd_path_set_tbvpm(device
, ifccpm
);
3777 dasd_schedule_device_bh(device
);
3779 if (oldopm
&& !dasd_path_get_opm(device
) && !hpfpm
&& !ifccpm
) {
3780 dev_warn(&device
->cdev
->dev
,
3781 "No verified channel paths remain for the device\n");
3782 DBF_DEV_EVENT(DBF_WARNING
, device
,
3783 "%s", "last verified path gone");
3784 dasd_eer_write(device
, NULL
, DASD_EER_NOPATH
);
3785 dasd_device_set_stop_bits(device
,
3786 DASD_STOPPED_DC_WAIT
);
3788 dasd_put_device(device
);
3790 EXPORT_SYMBOL_GPL(dasd_generic_path_event
);
3792 int dasd_generic_verify_path(struct dasd_device
*device
, __u8 lpm
)
3794 if (!dasd_path_get_opm(device
) && lpm
) {
3795 dasd_path_set_opm(device
, lpm
);
3796 dasd_generic_path_operational(device
);
3798 dasd_path_add_opm(device
, lpm
);
3801 EXPORT_SYMBOL_GPL(dasd_generic_verify_path
);
3804 * clear active requests and requeue them to block layer if possible
3806 static int dasd_generic_requeue_all_requests(struct dasd_device
*device
)
3808 struct list_head requeue_queue
;
3809 struct dasd_ccw_req
*cqr
, *n
;
3810 struct dasd_ccw_req
*refers
;
3813 INIT_LIST_HEAD(&requeue_queue
);
3814 spin_lock_irq(get_ccwdev_lock(device
->cdev
));
3816 list_for_each_entry_safe(cqr
, n
, &device
->ccw_queue
, devlist
) {
3817 /* Check status and move request to flush_queue */
3818 if (cqr
->status
== DASD_CQR_IN_IO
) {
3819 rc
= device
->discipline
->term_IO(cqr
);
3821 /* unable to terminate requeust */
3822 dev_err(&device
->cdev
->dev
,
3823 "Unable to terminate request %p "
3824 "on suspend\n", cqr
);
3825 spin_unlock_irq(get_ccwdev_lock(device
->cdev
));
3826 dasd_put_device(device
);
3830 list_move_tail(&cqr
->devlist
, &requeue_queue
);
3832 spin_unlock_irq(get_ccwdev_lock(device
->cdev
));
3834 list_for_each_entry_safe(cqr
, n
, &requeue_queue
, devlist
) {
3835 wait_event(dasd_flush_wq
,
3836 (cqr
->status
!= DASD_CQR_CLEAR_PENDING
));
3838 /* mark sleepon requests as ended */
3839 if (cqr
->callback_data
== DASD_SLEEPON_START_TAG
)
3840 cqr
->callback_data
= DASD_SLEEPON_END_TAG
;
3842 /* remove requests from device and block queue */
3843 list_del_init(&cqr
->devlist
);
3844 while (cqr
->refers
!= NULL
) {
3845 refers
= cqr
->refers
;
3846 /* remove the request from the block queue */
3847 list_del(&cqr
->blocklist
);
3848 /* free the finished erp request */
3849 dasd_free_erp_request(cqr
, cqr
->memdev
);
3854 * requeue requests to blocklayer will only work
3855 * for block device requests
3857 if (_dasd_requeue_request(cqr
))
3861 list_del_init(&cqr
->blocklist
);
3862 cqr
->block
->base
->discipline
->free_cp(
3863 cqr
, (struct request
*) cqr
->callback_data
);
3867 * if requests remain then they are internal request
3868 * and go back to the device queue
3870 if (!list_empty(&requeue_queue
)) {
3871 /* move freeze_queue to start of the ccw_queue */
3872 spin_lock_irq(get_ccwdev_lock(device
->cdev
));
3873 list_splice_tail(&requeue_queue
, &device
->ccw_queue
);
3874 spin_unlock_irq(get_ccwdev_lock(device
->cdev
));
3876 /* wake up generic waitqueue for eventually ended sleepon requests */
3877 wake_up(&generic_waitq
);
3881 static void do_requeue_requests(struct work_struct
*work
)
3883 struct dasd_device
*device
= container_of(work
, struct dasd_device
,
3885 dasd_generic_requeue_all_requests(device
);
3886 dasd_device_remove_stop_bits(device
, DASD_STOPPED_NOT_ACC
);
3888 dasd_schedule_block_bh(device
->block
);
3889 dasd_put_device(device
);
3892 void dasd_schedule_requeue(struct dasd_device
*device
)
3894 dasd_get_device(device
);
3895 /* queue call to dasd_reload_device to the kernel event daemon. */
3896 if (!schedule_work(&device
->requeue_requests
))
3897 dasd_put_device(device
);
3899 EXPORT_SYMBOL(dasd_schedule_requeue
);
3901 int dasd_generic_pm_freeze(struct ccw_device
*cdev
)
3903 struct dasd_device
*device
= dasd_device_from_cdev(cdev
);
3907 return PTR_ERR(device
);
3909 /* mark device as suspended */
3910 set_bit(DASD_FLAG_SUSPENDED
, &device
->flags
);
3912 if (device
->discipline
->freeze
)
3913 rc
= device
->discipline
->freeze(device
);
3915 /* disallow new I/O */
3916 dasd_device_set_stop_bits(device
, DASD_STOPPED_PM
);
3918 return dasd_generic_requeue_all_requests(device
);
3920 EXPORT_SYMBOL_GPL(dasd_generic_pm_freeze
);
3922 int dasd_generic_restore_device(struct ccw_device
*cdev
)
3924 struct dasd_device
*device
= dasd_device_from_cdev(cdev
);
3928 return PTR_ERR(device
);
3930 /* allow new IO again */
3931 dasd_device_remove_stop_bits(device
,
3932 (DASD_STOPPED_PM
| DASD_UNRESUMED_PM
));
3934 dasd_schedule_device_bh(device
);
3937 * call discipline restore function
3938 * if device is stopped do nothing e.g. for disconnected devices
3940 if (device
->discipline
->restore
&& !(device
->stopped
))
3941 rc
= device
->discipline
->restore(device
);
3942 if (rc
|| device
->stopped
)
3944 * if the resume failed for the DASD we put it in
3945 * an UNRESUMED stop state
3947 device
->stopped
|= DASD_UNRESUMED_PM
;
3950 dasd_schedule_block_bh(device
->block
);
3952 clear_bit(DASD_FLAG_SUSPENDED
, &device
->flags
);
3953 dasd_put_device(device
);
3956 EXPORT_SYMBOL_GPL(dasd_generic_restore_device
);
3958 static struct dasd_ccw_req
*dasd_generic_build_rdc(struct dasd_device
*device
,
3960 int rdc_buffer_size
,
3963 struct dasd_ccw_req
*cqr
;
3965 unsigned long *idaw
;
3967 cqr
= dasd_smalloc_request(magic
, 1 /* RDC */, rdc_buffer_size
, device
);
3970 /* internal error 13 - Allocating the RDC request failed*/
3971 dev_err(&device
->cdev
->dev
,
3972 "An error occurred in the DASD device driver, "
3973 "reason=%s\n", "13");
3978 ccw
->cmd_code
= CCW_CMD_RDC
;
3979 if (idal_is_needed(rdc_buffer
, rdc_buffer_size
)) {
3980 idaw
= (unsigned long *) (cqr
->data
);
3981 ccw
->cda
= (__u32
)(addr_t
) idaw
;
3982 ccw
->flags
= CCW_FLAG_IDA
;
3983 idaw
= idal_create_words(idaw
, rdc_buffer
, rdc_buffer_size
);
3985 ccw
->cda
= (__u32
)(addr_t
) rdc_buffer
;
3989 ccw
->count
= rdc_buffer_size
;
3990 cqr
->startdev
= device
;
3991 cqr
->memdev
= device
;
3992 cqr
->expires
= 10*HZ
;
3994 cqr
->buildclk
= get_tod_clock();
3995 cqr
->status
= DASD_CQR_FILLED
;
4000 int dasd_generic_read_dev_chars(struct dasd_device
*device
, int magic
,
4001 void *rdc_buffer
, int rdc_buffer_size
)
4004 struct dasd_ccw_req
*cqr
;
4006 cqr
= dasd_generic_build_rdc(device
, rdc_buffer
, rdc_buffer_size
,
4009 return PTR_ERR(cqr
);
4011 ret
= dasd_sleep_on(cqr
);
4012 dasd_sfree_request(cqr
, cqr
->memdev
);
4015 EXPORT_SYMBOL_GPL(dasd_generic_read_dev_chars
);
4018 * In command mode and transport mode we need to look for sense
4019 * data in different places. The sense data itself is allways
4020 * an array of 32 bytes, so we can unify the sense data access
4023 char *dasd_get_sense(struct irb
*irb
)
4025 struct tsb
*tsb
= NULL
;
4028 if (scsw_is_tm(&irb
->scsw
) && (irb
->scsw
.tm
.fcxs
== 0x01)) {
4029 if (irb
->scsw
.tm
.tcw
)
4030 tsb
= tcw_get_tsb((struct tcw
*)(unsigned long)
4032 if (tsb
&& tsb
->length
== 64 && tsb
->flags
)
4033 switch (tsb
->flags
& 0x07) {
4034 case 1: /* tsa_iostat */
4035 sense
= tsb
->tsa
.iostat
.sense
;
4037 case 2: /* tsa_ddpc */
4038 sense
= tsb
->tsa
.ddpc
.sense
;
4041 /* currently we don't use interrogate data */
4044 } else if (irb
->esw
.esw0
.erw
.cons
) {
4049 EXPORT_SYMBOL_GPL(dasd_get_sense
);
4051 void dasd_generic_shutdown(struct ccw_device
*cdev
)
4053 struct dasd_device
*device
;
4055 device
= dasd_device_from_cdev(cdev
);
4060 dasd_schedule_block_bh(device
->block
);
4062 dasd_schedule_device_bh(device
);
4064 wait_event(shutdown_waitq
, _wait_for_empty_queues(device
));
4066 EXPORT_SYMBOL_GPL(dasd_generic_shutdown
);
4068 static int __init
dasd_init(void)
4072 init_waitqueue_head(&dasd_init_waitq
);
4073 init_waitqueue_head(&dasd_flush_wq
);
4074 init_waitqueue_head(&generic_waitq
);
4075 init_waitqueue_head(&shutdown_waitq
);
4077 /* register 'common' DASD debug area, used for all DBF_XXX calls */
4078 dasd_debug_area
= debug_register("dasd", 1, 1, 8 * sizeof(long));
4079 if (dasd_debug_area
== NULL
) {
4083 debug_register_view(dasd_debug_area
, &debug_sprintf_view
);
4084 debug_set_level(dasd_debug_area
, DBF_WARNING
);
4086 DBF_EVENT(DBF_EMERG
, "%s", "debug area created");
4088 dasd_diag_discipline_pointer
= NULL
;
4090 dasd_statistics_createroot();
4092 rc
= dasd_devmap_init();
4095 rc
= dasd_gendisk_init();
4101 rc
= dasd_eer_init();
4104 #ifdef CONFIG_PROC_FS
4105 rc
= dasd_proc_init();
4112 pr_info("The DASD device driver could not be initialized\n");
4117 module_init(dasd_init
);
4118 module_exit(dasd_exit
);