2 * drivers/s390/char/tape_block.c
3 * block device frontend for tape device driver
5 * S390 and zSeries version
6 * Copyright (C) 2001,2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
7 * Author(s): Carsten Otte <cotte@de.ibm.com>
8 * Tuan Ngo-Anh <ngoanh@de.ibm.com>
9 * Martin Schwidefsky <schwidefsky@de.ibm.com>
10 * Stefan Bader <shbader@de.ibm.com>
13 #define KMSG_COMPONENT "tape"
16 #include <linux/module.h>
17 #include <linux/blkdev.h>
18 #include <linux/interrupt.h>
19 #include <linux/buffer_head.h>
20 #include <linux/kernel.h>
22 #include <asm/debug.h>
24 #define TAPE_DBF_AREA tape_core_dbf
28 #define TAPEBLOCK_MAX_SEC 100
29 #define TAPEBLOCK_MIN_REQUEUE 3
32 * 2003/11/25 Stefan Bader <shbader@de.ibm.com>
34 * In 2.5/2.6 the block device request function is very likely to be called
35 * with disabled interrupts (e.g. generic_unplug_device). So the driver can't
36 * just call any function that tries to allocate CCW requests from that con-
37 * text since it might sleep. There are two choices to work around this:
38 * a) do not allocate with kmalloc but use its own memory pool
39 * b) take requests from the queue outside that context, knowing that
40 * allocation might sleep
44 * file operation structure for tape block frontend
46 static int tapeblock_open(struct block_device
*, fmode_t
);
47 static int tapeblock_release(struct gendisk
*, fmode_t
);
48 static int tapeblock_ioctl(struct block_device
*, fmode_t
, unsigned int,
50 static int tapeblock_medium_changed(struct gendisk
*);
51 static int tapeblock_revalidate_disk(struct gendisk
*);
53 static struct block_device_operations tapeblock_fops
= {
55 .open
= tapeblock_open
,
56 .release
= tapeblock_release
,
57 .locked_ioctl
= tapeblock_ioctl
,
58 .media_changed
= tapeblock_medium_changed
,
59 .revalidate_disk
= tapeblock_revalidate_disk
,
62 static int tapeblock_major
= 0;
65 tapeblock_trigger_requeue(struct tape_device
*device
)
67 /* Protect against rescheduling. */
68 if (atomic_cmpxchg(&device
->blk_data
.requeue_scheduled
, 0, 1) != 0)
70 schedule_work(&device
->blk_data
.requeue_task
);
74 * Post finished request.
77 __tapeblock_end_request(struct tape_request
*ccw_req
, void *data
)
79 struct tape_device
*device
;
82 DBF_LH(6, "__tapeblock_end_request()\n");
84 device
= ccw_req
->device
;
85 req
= (struct request
*) data
;
86 blk_end_request_all(req
, (ccw_req
->rc
== 0) ? 0 : -EIO
);
88 /* Update position. */
89 device
->blk_data
.block_position
=
90 (blk_rq_pos(req
) + blk_rq_sectors(req
)) >> TAPEBLOCK_HSEC_S2B
;
92 /* We lost the position information due to an error. */
93 device
->blk_data
.block_position
= -1;
94 device
->discipline
->free_bread(ccw_req
);
95 if (!list_empty(&device
->req_queue
) ||
96 elv_next_request(device
->blk_data
.request_queue
))
97 tapeblock_trigger_requeue(device
);
101 * Feed the tape device CCW queue with requests supplied in a list.
104 tapeblock_start_request(struct tape_device
*device
, struct request
*req
)
106 struct tape_request
* ccw_req
;
109 DBF_LH(6, "tapeblock_start_request(%p, %p)\n", device
, req
);
111 ccw_req
= device
->discipline
->bread(device
, req
);
112 if (IS_ERR(ccw_req
)) {
113 DBF_EVENT(1, "TBLOCK: bread failed\n");
114 blk_end_request_all(req
, -EIO
);
115 return PTR_ERR(ccw_req
);
117 ccw_req
->callback
= __tapeblock_end_request
;
118 ccw_req
->callback_data
= (void *) req
;
119 ccw_req
->retries
= TAPEBLOCK_RETRIES
;
121 rc
= tape_do_io_async(device
, ccw_req
);
124 * Start/enqueueing failed. No retries in
127 blk_end_request_all(req
, -EIO
);
128 device
->discipline
->free_bread(ccw_req
);
135 * Move requests from the block device request queue to the tape device ccw
139 tapeblock_requeue(struct work_struct
*work
) {
140 struct tape_blk_data
* blkdat
;
141 struct tape_device
* device
;
142 struct request_queue
* queue
;
144 struct request
* req
;
145 struct list_head
* l
;
148 blkdat
= container_of(work
, struct tape_blk_data
, requeue_task
);
149 device
= blkdat
->device
;
153 spin_lock_irq(get_ccwdev_lock(device
->cdev
));
154 queue
= device
->blk_data
.request_queue
;
156 /* Count number of requests on ccw queue. */
158 list_for_each(l
, &device
->req_queue
)
160 spin_unlock(get_ccwdev_lock(device
->cdev
));
162 spin_lock_irq(&device
->blk_data
.request_queue_lock
);
164 !blk_queue_plugged(queue
) &&
165 elv_next_request(queue
) &&
166 nr_queued
< TAPEBLOCK_MIN_REQUEUE
168 req
= elv_next_request(queue
);
169 if (rq_data_dir(req
) == WRITE
) {
170 DBF_EVENT(1, "TBLOCK: Rejecting write request\n");
171 blkdev_dequeue_request(req
);
172 spin_unlock_irq(&device
->blk_data
.request_queue_lock
);
173 blk_end_request_all(req
, -EIO
);
174 spin_lock_irq(&device
->blk_data
.request_queue_lock
);
177 blkdev_dequeue_request(req
);
179 spin_unlock_irq(&device
->blk_data
.request_queue_lock
);
180 rc
= tapeblock_start_request(device
, req
);
181 spin_lock_irq(&device
->blk_data
.request_queue_lock
);
183 spin_unlock_irq(&device
->blk_data
.request_queue_lock
);
184 atomic_set(&device
->blk_data
.requeue_scheduled
, 0);
188 * Tape request queue function. Called from ll_rw_blk.c
191 tapeblock_request_fn(struct request_queue
*queue
)
193 struct tape_device
*device
;
195 device
= (struct tape_device
*) queue
->queuedata
;
196 DBF_LH(6, "tapeblock_request_fn(device=%p)\n", device
);
197 BUG_ON(device
== NULL
);
198 tapeblock_trigger_requeue(device
);
202 * This function is called for every new tapedevice
205 tapeblock_setup_device(struct tape_device
* device
)
207 struct tape_blk_data
* blkdat
;
208 struct gendisk
* disk
;
211 blkdat
= &device
->blk_data
;
212 blkdat
->device
= device
;
213 spin_lock_init(&blkdat
->request_queue_lock
);
214 atomic_set(&blkdat
->requeue_scheduled
, 0);
216 blkdat
->request_queue
= blk_init_queue(
217 tapeblock_request_fn
,
218 &blkdat
->request_queue_lock
220 if (!blkdat
->request_queue
)
223 elevator_exit(blkdat
->request_queue
->elevator
);
224 rc
= elevator_init(blkdat
->request_queue
, "noop");
228 blk_queue_hardsect_size(blkdat
->request_queue
, TAPEBLOCK_HSEC_SIZE
);
229 blk_queue_max_sectors(blkdat
->request_queue
, TAPEBLOCK_MAX_SEC
);
230 blk_queue_max_phys_segments(blkdat
->request_queue
, -1L);
231 blk_queue_max_hw_segments(blkdat
->request_queue
, -1L);
232 blk_queue_max_segment_size(blkdat
->request_queue
, -1L);
233 blk_queue_segment_boundary(blkdat
->request_queue
, -1L);
235 disk
= alloc_disk(1);
241 disk
->major
= tapeblock_major
;
242 disk
->first_minor
= device
->first_minor
;
243 disk
->fops
= &tapeblock_fops
;
244 disk
->private_data
= tape_get_device_reference(device
);
245 disk
->queue
= blkdat
->request_queue
;
246 set_capacity(disk
, 0);
247 sprintf(disk
->disk_name
, "btibm%d",
248 device
->first_minor
/ TAPE_MINORS_PER_DEV
);
251 blkdat
->medium_changed
= 1;
252 blkdat
->request_queue
->queuedata
= tape_get_device_reference(device
);
256 tape_get_device_reference(device
);
257 INIT_WORK(&blkdat
->requeue_task
, tapeblock_requeue
);
262 blk_cleanup_queue(blkdat
->request_queue
);
263 blkdat
->request_queue
= NULL
;
269 tapeblock_cleanup_device(struct tape_device
*device
)
271 flush_scheduled_work();
272 tape_put_device(device
);
274 if (!device
->blk_data
.disk
) {
278 del_gendisk(device
->blk_data
.disk
);
279 device
->blk_data
.disk
->private_data
=
280 tape_put_device(device
->blk_data
.disk
->private_data
);
281 put_disk(device
->blk_data
.disk
);
283 device
->blk_data
.disk
= NULL
;
285 device
->blk_data
.request_queue
->queuedata
= tape_put_device(device
);
287 blk_cleanup_queue(device
->blk_data
.request_queue
);
288 device
->blk_data
.request_queue
= NULL
;
292 * Detect number of blocks of the tape.
293 * FIXME: can we extent this to detect the blocks size as well ?
296 tapeblock_revalidate_disk(struct gendisk
*disk
)
298 struct tape_device
* device
;
299 unsigned int nr_of_blks
;
302 device
= (struct tape_device
*) disk
->private_data
;
305 if (!device
->blk_data
.medium_changed
)
308 dev_info(&device
->cdev
->dev
, "Determining the size of the recorded "
310 rc
= tape_mtop(device
, MTFSFM
, 1);
314 rc
= tape_mtop(device
, MTTELL
, 1);
318 DBF_LH(3, "Image file ends at %d\n", rc
);
321 /* This will fail for the first file. Catch the error by checking the
323 tape_mtop(device
, MTBSF
, 1);
325 rc
= tape_mtop(device
, MTTELL
, 1);
332 DBF_LH(3, "Image file starts at %d\n", rc
);
336 dev_info(&device
->cdev
->dev
, "The size of the recorded area is %i "
337 "blocks\n", nr_of_blks
);
338 set_capacity(device
->blk_data
.disk
,
339 nr_of_blks
*(TAPEBLOCK_HSEC_SIZE
/512));
341 device
->blk_data
.block_position
= 0;
342 device
->blk_data
.medium_changed
= 0;
347 tapeblock_medium_changed(struct gendisk
*disk
)
349 struct tape_device
*device
;
351 device
= (struct tape_device
*) disk
->private_data
;
352 DBF_LH(6, "tapeblock_medium_changed(%p) = %d\n",
353 device
, device
->blk_data
.medium_changed
);
355 return device
->blk_data
.medium_changed
;
359 * Block frontend tape device open function.
362 tapeblock_open(struct block_device
*bdev
, fmode_t mode
)
364 struct gendisk
* disk
= bdev
->bd_disk
;
365 struct tape_device
* device
;
368 device
= tape_get_device_reference(disk
->private_data
);
370 if (device
->required_tapemarks
) {
371 DBF_EVENT(2, "TBLOCK: missing tapemarks\n");
372 dev_warn(&device
->cdev
->dev
, "Opening the tape failed because"
373 " of missing end-of-file marks\n");
378 rc
= tape_open(device
);
382 rc
= tapeblock_revalidate_disk(disk
);
387 * Note: The reference to <device> is hold until the release function
390 tape_state_set(device
, TS_BLKUSE
);
394 tape_release(device
);
396 tape_put_device(device
);
401 * Block frontend tape device release function.
403 * Note: One reference to the tape device was made by the open function. So
404 * we just get the pointer here and release the reference.
407 tapeblock_release(struct gendisk
*disk
, fmode_t mode
)
409 struct tape_device
*device
= disk
->private_data
;
411 tape_state_set(device
, TS_IN_USE
);
412 tape_release(device
);
413 tape_put_device(device
);
419 * Support of some generic block device IOCTLs.
423 struct block_device
* bdev
,
425 unsigned int command
,
430 struct gendisk
*disk
= bdev
->bd_disk
;
431 struct tape_device
*device
;
435 device
= disk
->private_data
;
437 minor
= MINOR(bdev
->bd_dev
);
439 DBF_LH(6, "tapeblock_ioctl(0x%0x)\n", command
);
440 DBF_LH(6, "device = %d:%d\n", tapeblock_major
, minor
);
443 /* Refuse some IOCTL calls without complaining (mount). */
444 case 0x5310: /* CDROMMULTISESSION */
455 * Initialize block device frontend.
462 /* Register the tape major number to the kernel */
463 rc
= register_blkdev(tapeblock_major
, "tBLK");
467 if (tapeblock_major
== 0)
468 tapeblock_major
= rc
;
473 * Deregister major for block device frontend
478 unregister_blkdev(tapeblock_major
, "tBLK");