blob: 47ff695255ea649f1f0296ed7f6f602ee1d4f9ac [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/s390/char/tape_block.c
3 * block device frontend for tape device driver
4 *
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>
11 */
12
Carsten Otteab640db2009-03-26 15:24:38 +010013#define KMSG_COMPONENT "tape"
14
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/module.h>
17#include <linux/blkdev.h>
18#include <linux/interrupt.h>
19#include <linux/buffer_head.h>
Martin Schwidefskyc1637532006-12-08 15:53:57 +010020#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22#include <asm/debug.h>
23
24#define TAPE_DBF_AREA tape_core_dbf
25
26#include "tape.h"
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#define TAPEBLOCK_MAX_SEC 100
29#define TAPEBLOCK_MIN_REQUEUE 3
30
31/*
32 * 2003/11/25 Stefan Bader <shbader@de.ibm.com>
33 *
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
41 */
42
43/*
44 * file operation structure for tape block frontend
45 */
Al Viro4e999af2008-03-02 10:39:59 -050046static int tapeblock_open(struct block_device *, fmode_t);
47static int tapeblock_release(struct gendisk *, fmode_t);
48static int tapeblock_ioctl(struct block_device *, fmode_t, unsigned int,
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 unsigned long);
50static int tapeblock_medium_changed(struct gendisk *);
51static int tapeblock_revalidate_disk(struct gendisk *);
52
53static struct block_device_operations tapeblock_fops = {
54 .owner = THIS_MODULE,
Al Viro4e999af2008-03-02 10:39:59 -050055 .open = tapeblock_open,
56 .release = tapeblock_release,
57 .locked_ioctl = tapeblock_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 .media_changed = tapeblock_medium_changed,
59 .revalidate_disk = tapeblock_revalidate_disk,
60};
61
62static int tapeblock_major = 0;
63
64static void
65tapeblock_trigger_requeue(struct tape_device *device)
66{
67 /* Protect against rescheduling. */
Martin Schwidefsky973bd992006-01-06 00:19:07 -080068 if (atomic_cmpxchg(&device->blk_data.requeue_scheduled, 0, 1) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 return;
70 schedule_work(&device->blk_data.requeue_task);
71}
72
73/*
74 * Post finished request.
75 */
Heiko Carstens4d284ca2007-02-05 21:18:53 +010076static void
Linus Torvalds1da177e2005-04-16 15:20:36 -070077__tapeblock_end_request(struct tape_request *ccw_req, void *data)
78{
79 struct tape_device *device;
80 struct request *req;
81
82 DBF_LH(6, "__tapeblock_end_request()\n");
83
84 device = ccw_req->device;
85 req = (struct request *) data;
Tejun Heo40cbbb72009-04-23 11:05:19 +090086 blk_end_request_all(req, (ccw_req->rc == 0) ? 0 : -EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 if (ccw_req->rc == 0)
88 /* Update position. */
89 device->blk_data.block_position =
Tejun Heo83096eb2009-05-07 22:24:39 +090090 (blk_rq_pos(req) + blk_rq_sectors(req)) >> TAPEBLOCK_HSEC_S2B;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 else
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) ||
Tejun Heo9934c8c2009-05-08 11:54:16 +090096 blk_peek_request(device->blk_data.request_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 tapeblock_trigger_requeue(device);
98}
99
100/*
101 * Feed the tape device CCW queue with requests supplied in a list.
102 */
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100103static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104tapeblock_start_request(struct tape_device *device, struct request *req)
105{
106 struct tape_request * ccw_req;
107 int rc;
108
109 DBF_LH(6, "tapeblock_start_request(%p, %p)\n", device, req);
110
111 ccw_req = device->discipline->bread(device, req);
112 if (IS_ERR(ccw_req)) {
113 DBF_EVENT(1, "TBLOCK: bread failed\n");
Tejun Heo40cbbb72009-04-23 11:05:19 +0900114 blk_end_request_all(req, -EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 return PTR_ERR(ccw_req);
116 }
117 ccw_req->callback = __tapeblock_end_request;
118 ccw_req->callback_data = (void *) req;
119 ccw_req->retries = TAPEBLOCK_RETRIES;
120
121 rc = tape_do_io_async(device, ccw_req);
122 if (rc) {
123 /*
124 * Start/enqueueing failed. No retries in
125 * this case.
126 */
Tejun Heo40cbbb72009-04-23 11:05:19 +0900127 blk_end_request_all(req, -EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 device->discipline->free_bread(ccw_req);
129 }
130
131 return rc;
132}
133
134/*
135 * Move requests from the block device request queue to the tape device ccw
136 * queue.
137 */
138static void
Martin Schwidefskyc1637532006-12-08 15:53:57 +0100139tapeblock_requeue(struct work_struct *work) {
140 struct tape_blk_data * blkdat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 struct tape_device * device;
Jens Axboe165125e2007-07-24 09:28:11 +0200142 struct request_queue * queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 int nr_queued;
144 struct request * req;
145 struct list_head * l;
146 int rc;
147
Martin Schwidefskyc1637532006-12-08 15:53:57 +0100148 blkdat = container_of(work, struct tape_blk_data, requeue_task);
149 device = blkdat->device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 if (!device)
151 return;
152
153 spin_lock_irq(get_ccwdev_lock(device->cdev));
154 queue = device->blk_data.request_queue;
155
156 /* Count number of requests on ccw queue. */
157 nr_queued = 0;
158 list_for_each(l, &device->req_queue)
159 nr_queued++;
160 spin_unlock(get_ccwdev_lock(device->cdev));
161
Frank Munzert7a4a1cc2008-10-28 11:10:17 +0100162 spin_lock_irq(&device->blk_data.request_queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 while (
164 !blk_queue_plugged(queue) &&
Tejun Heo9934c8c2009-05-08 11:54:16 +0900165 (req = blk_fetch_request(queue)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 nr_queued < TAPEBLOCK_MIN_REQUEUE
167 ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 if (rq_data_dir(req) == WRITE) {
169 DBF_EVENT(1, "TBLOCK: Rejecting write request\n");
Frank Munzert7a4a1cc2008-10-28 11:10:17 +0100170 spin_unlock_irq(&device->blk_data.request_queue_lock);
Tejun Heo40cbbb72009-04-23 11:05:19 +0900171 blk_end_request_all(req, -EIO);
Frank Munzert7a4a1cc2008-10-28 11:10:17 +0100172 spin_lock_irq(&device->blk_data.request_queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 continue;
174 }
Michael Holzheuf71ad622008-05-30 10:03:25 +0200175 nr_queued++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 spin_unlock_irq(&device->blk_data.request_queue_lock);
177 rc = tapeblock_start_request(device, req);
178 spin_lock_irq(&device->blk_data.request_queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 }
180 spin_unlock_irq(&device->blk_data.request_queue_lock);
181 atomic_set(&device->blk_data.requeue_scheduled, 0);
182}
183
184/*
185 * Tape request queue function. Called from ll_rw_blk.c
186 */
187static void
Jens Axboe165125e2007-07-24 09:28:11 +0200188tapeblock_request_fn(struct request_queue *queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
190 struct tape_device *device;
191
192 device = (struct tape_device *) queue->queuedata;
193 DBF_LH(6, "tapeblock_request_fn(device=%p)\n", device);
Eric Sesterhenn3a8dc892006-04-01 01:28:11 +0200194 BUG_ON(device == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 tapeblock_trigger_requeue(device);
196}
197
198/*
199 * This function is called for every new tapedevice
200 */
201int
202tapeblock_setup_device(struct tape_device * device)
203{
204 struct tape_blk_data * blkdat;
205 struct gendisk * disk;
206 int rc;
207
208 blkdat = &device->blk_data;
Martin Schwidefskyc1637532006-12-08 15:53:57 +0100209 blkdat->device = device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 spin_lock_init(&blkdat->request_queue_lock);
211 atomic_set(&blkdat->requeue_scheduled, 0);
212
213 blkdat->request_queue = blk_init_queue(
214 tapeblock_request_fn,
215 &blkdat->request_queue_lock
216 );
217 if (!blkdat->request_queue)
218 return -ENOMEM;
219
220 elevator_exit(blkdat->request_queue->elevator);
221 rc = elevator_init(blkdat->request_queue, "noop");
222 if (rc)
223 goto cleanup_queue;
224
Martin K. Petersene1defc42009-05-22 17:17:49 -0400225 blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 blk_queue_max_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
227 blk_queue_max_phys_segments(blkdat->request_queue, -1L);
228 blk_queue_max_hw_segments(blkdat->request_queue, -1L);
229 blk_queue_max_segment_size(blkdat->request_queue, -1L);
230 blk_queue_segment_boundary(blkdat->request_queue, -1L);
231
232 disk = alloc_disk(1);
233 if (!disk) {
234 rc = -ENOMEM;
235 goto cleanup_queue;
236 }
237
238 disk->major = tapeblock_major;
239 disk->first_minor = device->first_minor;
240 disk->fops = &tapeblock_fops;
241 disk->private_data = tape_get_device_reference(device);
242 disk->queue = blkdat->request_queue;
243 set_capacity(disk, 0);
244 sprintf(disk->disk_name, "btibm%d",
245 device->first_minor / TAPE_MINORS_PER_DEV);
246
247 blkdat->disk = disk;
248 blkdat->medium_changed = 1;
249 blkdat->request_queue->queuedata = tape_get_device_reference(device);
250
251 add_disk(disk);
252
Martin Schwidefskyc1637532006-12-08 15:53:57 +0100253 tape_get_device_reference(device);
254 INIT_WORK(&blkdat->requeue_task, tapeblock_requeue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 return 0;
257
258cleanup_queue:
259 blk_cleanup_queue(blkdat->request_queue);
260 blkdat->request_queue = NULL;
261
262 return rc;
263}
264
265void
266tapeblock_cleanup_device(struct tape_device *device)
267{
268 flush_scheduled_work();
Martin Schwidefskyc1637532006-12-08 15:53:57 +0100269 tape_put_device(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
271 if (!device->blk_data.disk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 goto cleanup_queue;
273 }
274
275 del_gendisk(device->blk_data.disk);
276 device->blk_data.disk->private_data =
277 tape_put_device(device->blk_data.disk->private_data);
278 put_disk(device->blk_data.disk);
279
280 device->blk_data.disk = NULL;
281cleanup_queue:
282 device->blk_data.request_queue->queuedata = tape_put_device(device);
283
284 blk_cleanup_queue(device->blk_data.request_queue);
285 device->blk_data.request_queue = NULL;
286}
287
288/*
289 * Detect number of blocks of the tape.
290 * FIXME: can we extent this to detect the blocks size as well ?
291 */
292static int
293tapeblock_revalidate_disk(struct gendisk *disk)
294{
295 struct tape_device * device;
296 unsigned int nr_of_blks;
297 int rc;
298
299 device = (struct tape_device *) disk->private_data;
Eric Sesterhenn3a8dc892006-04-01 01:28:11 +0200300 BUG_ON(!device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 if (!device->blk_data.medium_changed)
303 return 0;
304
Carsten Otteab640db2009-03-26 15:24:38 +0100305 dev_info(&device->cdev->dev, "Determining the size of the recorded "
306 "area...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 rc = tape_mtop(device, MTFSFM, 1);
308 if (rc)
309 return rc;
310
311 rc = tape_mtop(device, MTTELL, 1);
312 if (rc < 0)
313 return rc;
314
315 DBF_LH(3, "Image file ends at %d\n", rc);
316 nr_of_blks = rc;
317
318 /* This will fail for the first file. Catch the error by checking the
319 * position. */
320 tape_mtop(device, MTBSF, 1);
321
322 rc = tape_mtop(device, MTTELL, 1);
323 if (rc < 0)
324 return rc;
325
326 if (rc > nr_of_blks)
327 return -EINVAL;
328
329 DBF_LH(3, "Image file starts at %d\n", rc);
330 device->bof = rc;
331 nr_of_blks -= rc;
332
Carsten Otteab640db2009-03-26 15:24:38 +0100333 dev_info(&device->cdev->dev, "The size of the recorded area is %i "
334 "blocks\n", nr_of_blks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 set_capacity(device->blk_data.disk,
336 nr_of_blks*(TAPEBLOCK_HSEC_SIZE/512));
337
338 device->blk_data.block_position = 0;
339 device->blk_data.medium_changed = 0;
340 return 0;
341}
342
343static int
344tapeblock_medium_changed(struct gendisk *disk)
345{
346 struct tape_device *device;
347
348 device = (struct tape_device *) disk->private_data;
349 DBF_LH(6, "tapeblock_medium_changed(%p) = %d\n",
350 device, device->blk_data.medium_changed);
351
352 return device->blk_data.medium_changed;
353}
354
355/*
356 * Block frontend tape device open function.
357 */
358static int
Al Viro4e999af2008-03-02 10:39:59 -0500359tapeblock_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
Al Viro4e999af2008-03-02 10:39:59 -0500361 struct gendisk * disk = bdev->bd_disk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 struct tape_device * device;
363 int rc;
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 device = tape_get_device_reference(disk->private_data);
366
367 if (device->required_tapemarks) {
368 DBF_EVENT(2, "TBLOCK: missing tapemarks\n");
Carsten Otteab640db2009-03-26 15:24:38 +0100369 dev_warn(&device->cdev->dev, "Opening the tape failed because"
370 " of missing end-of-file marks\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 rc = -EPERM;
372 goto put_device;
373 }
374
375 rc = tape_open(device);
376 if (rc)
377 goto put_device;
378
379 rc = tapeblock_revalidate_disk(disk);
380 if (rc)
381 goto release;
382
383 /*
384 * Note: The reference to <device> is hold until the release function
385 * is called.
386 */
387 tape_state_set(device, TS_BLKUSE);
388 return 0;
389
390release:
391 tape_release(device);
392 put_device:
393 tape_put_device(device);
394 return rc;
395}
396
397/*
398 * Block frontend tape device release function.
399 *
400 * Note: One reference to the tape device was made by the open function. So
401 * we just get the pointer here and release the reference.
402 */
403static int
Al Viro4e999af2008-03-02 10:39:59 -0500404tapeblock_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 struct tape_device *device = disk->private_data;
407
408 tape_state_set(device, TS_IN_USE);
409 tape_release(device);
410 tape_put_device(device);
411
412 return 0;
413}
414
415/*
416 * Support of some generic block device IOCTLs.
417 */
418static int
419tapeblock_ioctl(
Al Viro4e999af2008-03-02 10:39:59 -0500420 struct block_device * bdev,
421 fmode_t mode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 unsigned int command,
423 unsigned long arg
424) {
425 int rc;
426 int minor;
Al Viro4e999af2008-03-02 10:39:59 -0500427 struct gendisk *disk = bdev->bd_disk;
Peter Oberparleiterf9760692006-04-10 22:53:49 -0700428 struct tape_device *device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
430 rc = 0;
Eric Sesterhenn3a8dc892006-04-01 01:28:11 +0200431 BUG_ON(!disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 device = disk->private_data;
Eric Sesterhenn3a8dc892006-04-01 01:28:11 +0200433 BUG_ON(!device);
Al Viro4e999af2008-03-02 10:39:59 -0500434 minor = MINOR(bdev->bd_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436 DBF_LH(6, "tapeblock_ioctl(0x%0x)\n", command);
437 DBF_LH(6, "device = %d:%d\n", tapeblock_major, minor);
438
439 switch (command) {
440 /* Refuse some IOCTL calls without complaining (mount). */
441 case 0x5310: /* CDROMMULTISESSION */
442 rc = -EINVAL;
443 break;
444 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 rc = -EINVAL;
446 }
447
448 return rc;
449}
450
451/*
452 * Initialize block device frontend.
453 */
454int
455tapeblock_init(void)
456{
457 int rc;
458
459 /* Register the tape major number to the kernel */
460 rc = register_blkdev(tapeblock_major, "tBLK");
461 if (rc < 0)
462 return rc;
463
464 if (tapeblock_major == 0)
465 tapeblock_major = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 return 0;
467}
468
469/*
470 * Deregister major for block device frontend
471 */
472void
473tapeblock_exit(void)
474{
475 unregister_blkdev(tapeblock_major, "tBLK");
476}