blob: 31566c55adfe18b7140c127bc87284a5a4353053 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/s390/char/tape_char.c
3 * character device frontend for tape device driver
4 *
5 * S390 and zSeries version
Michael Holzheucced1dd2007-02-05 21:18:26 +01006 * Copyright IBM Corp. 2001,2006
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Author(s): Carsten Otte <cotte@de.ibm.com>
8 * Michael Holzheu <holzheu@de.ibm.com>
9 * Tuan Ngo-Anh <ngoanh@de.ibm.com>
10 * Martin Schwidefsky <schwidefsky@de.ibm.com>
11 */
12
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/module.h>
14#include <linux/types.h>
15#include <linux/proc_fs.h>
16#include <linux/mtio.h>
Jonathan Corbet764a4a82008-05-15 10:01:17 -060017#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
19#include <asm/uaccess.h>
20
21#define TAPE_DBF_AREA tape_core_dbf
22
23#include "tape.h"
24#include "tape_std.h"
25#include "tape_class.h"
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#define TAPECHAR_MAJOR 0 /* get dynamic major */
28
29/*
30 * file operation structure for tape character frontend
31 */
32static ssize_t tapechar_read(struct file *, char __user *, size_t, loff_t *);
33static ssize_t tapechar_write(struct file *, const char __user *, size_t, loff_t *);
34static int tapechar_open(struct inode *,struct file *);
35static int tapechar_release(struct inode *,struct file *);
36static int tapechar_ioctl(struct inode *, struct file *, unsigned int,
37 unsigned long);
Christoph Hellwigf042e0f2006-01-09 20:52:07 -080038static long tapechar_compat_ioctl(struct file *, unsigned int,
39 unsigned long);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Arjan van de Vend54b1fd2007-02-12 00:55:34 -080041static const struct file_operations tape_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -070042{
43 .owner = THIS_MODULE,
44 .read = tapechar_read,
45 .write = tapechar_write,
46 .ioctl = tapechar_ioctl,
Christoph Hellwigf042e0f2006-01-09 20:52:07 -080047 .compat_ioctl = tapechar_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 .open = tapechar_open,
49 .release = tapechar_release,
50};
51
52static int tapechar_major = TAPECHAR_MAJOR;
53
54/*
55 * This function is called for every new tapedevice
56 */
57int
58tapechar_setup_device(struct tape_device * device)
59{
60 char device_name[20];
61
62 sprintf(device_name, "ntibm%i", device->first_minor / 2);
63 device->nt = register_tape_dev(
64 &device->cdev->dev,
65 MKDEV(tapechar_major, device->first_minor),
66 &tape_fops,
67 device_name,
68 "non-rewinding"
69 );
70 device_name[0] = 'r';
71 device->rt = register_tape_dev(
72 &device->cdev->dev,
73 MKDEV(tapechar_major, device->first_minor + 1),
74 &tape_fops,
75 device_name,
76 "rewinding"
77 );
78
79 return 0;
80}
81
82void
83tapechar_cleanup_device(struct tape_device *device)
84{
Michael Holzheu92bf4352008-04-17 07:46:05 +020085 unregister_tape_dev(&device->cdev->dev, device->rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 device->rt = NULL;
Michael Holzheu92bf4352008-04-17 07:46:05 +020087 unregister_tape_dev(&device->cdev->dev, device->nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 device->nt = NULL;
89}
90
Heiko Carstens4d284ca2007-02-05 21:18:53 +010091static int
Linus Torvalds1da177e2005-04-16 15:20:36 -070092tapechar_check_idalbuffer(struct tape_device *device, size_t block_size)
93{
94 struct idal_buffer *new;
95
96 if (device->char_data.idal_buf != NULL &&
97 device->char_data.idal_buf->size == block_size)
98 return 0;
99
100 if (block_size > MAX_BLOCKSIZE) {
101 DBF_EVENT(3, "Invalid blocksize (%zd > %d)\n",
102 block_size, MAX_BLOCKSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 return -EINVAL;
104 }
105
106 /* The current idal buffer is not correct. Allocate a new one. */
107 new = idal_buffer_alloc(block_size, 0);
Julien Brunel0983e562008-08-21 19:46:30 +0200108 if (IS_ERR(new))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 return -ENOMEM;
110
111 if (device->char_data.idal_buf != NULL)
112 idal_buffer_free(device->char_data.idal_buf);
113
114 device->char_data.idal_buf = new;
115
116 return 0;
117}
118
119/*
120 * Tape device read function
121 */
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100122static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
124{
125 struct tape_device *device;
126 struct tape_request *request;
127 size_t block_size;
128 int rc;
129
130 DBF_EVENT(6, "TCHAR:read\n");
131 device = (struct tape_device *) filp->private_data;
132
133 /*
134 * If the tape isn't terminated yet, do it now. And since we then
135 * are at the end of the tape there wouldn't be anything to read
136 * anyways. So we return immediatly.
137 */
138 if(device->required_tapemarks) {
139 return tape_std_terminate_write(device);
140 }
141
142 /* Find out block size to use */
143 if (device->char_data.block_size != 0) {
144 if (count < device->char_data.block_size) {
145 DBF_EVENT(3, "TCHAR:read smaller than block "
146 "size was requested\n");
147 return -EINVAL;
148 }
149 block_size = device->char_data.block_size;
150 } else {
151 block_size = count;
152 }
153
154 rc = tapechar_check_idalbuffer(device, block_size);
155 if (rc)
156 return rc;
157
158#ifdef CONFIG_S390_TAPE_BLOCK
159 /* Changes position. */
160 device->blk_data.medium_changed = 1;
161#endif
162
163 DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size);
164 /* Let the discipline build the ccw chain. */
165 request = device->discipline->read_block(device, block_size);
166 if (IS_ERR(request))
167 return PTR_ERR(request);
168 /* Execute it. */
169 rc = tape_do_io(device, request);
170 if (rc == 0) {
171 rc = block_size - request->rescnt;
172 DBF_EVENT(6, "TCHAR:rbytes: %x\n", rc);
173 filp->f_pos += rc;
174 /* Copy data from idal buffer to user space. */
175 if (idal_buffer_to_user(device->char_data.idal_buf,
176 data, rc) != 0)
177 rc = -EFAULT;
178 }
179 tape_free_request(request);
180 return rc;
181}
182
183/*
184 * Tape device write function
185 */
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100186static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t *ppos)
188{
189 struct tape_device *device;
190 struct tape_request *request;
191 size_t block_size;
192 size_t written;
193 int nblocks;
194 int i, rc;
195
196 DBF_EVENT(6, "TCHAR:write\n");
197 device = (struct tape_device *) filp->private_data;
198 /* Find out block size and number of blocks */
199 if (device->char_data.block_size != 0) {
200 if (count < device->char_data.block_size) {
201 DBF_EVENT(3, "TCHAR:write smaller than block "
202 "size was requested\n");
203 return -EINVAL;
204 }
205 block_size = device->char_data.block_size;
206 nblocks = count / block_size;
207 } else {
208 block_size = count;
209 nblocks = 1;
210 }
211
212 rc = tapechar_check_idalbuffer(device, block_size);
213 if (rc)
214 return rc;
215
216#ifdef CONFIG_S390_TAPE_BLOCK
217 /* Changes position. */
218 device->blk_data.medium_changed = 1;
219#endif
220
221 DBF_EVENT(6,"TCHAR:nbytes: %lx\n", block_size);
222 DBF_EVENT(6, "TCHAR:nblocks: %x\n", nblocks);
223 /* Let the discipline build the ccw chain. */
224 request = device->discipline->write_block(device, block_size);
225 if (IS_ERR(request))
226 return PTR_ERR(request);
227 rc = 0;
228 written = 0;
229 for (i = 0; i < nblocks; i++) {
230 /* Copy data from user space to idal buffer. */
231 if (idal_buffer_from_user(device->char_data.idal_buf,
232 data, block_size)) {
233 rc = -EFAULT;
234 break;
235 }
236 rc = tape_do_io(device, request);
237 if (rc)
238 break;
239 DBF_EVENT(6, "TCHAR:wbytes: %lx\n",
240 block_size - request->rescnt);
241 filp->f_pos += block_size - request->rescnt;
242 written += block_size - request->rescnt;
243 if (request->rescnt != 0)
244 break;
245 data += block_size;
246 }
247 tape_free_request(request);
248 if (rc == -ENOSPC) {
249 /*
250 * Ok, the device has no more space. It has NOT written
251 * the block.
252 */
253 if (device->discipline->process_eov)
254 device->discipline->process_eov(device);
255 if (written > 0)
256 rc = 0;
257
258 }
259
260 /*
261 * After doing a write we always need two tapemarks to correctly
262 * terminate the tape (one to terminate the file, the second to
263 * flag the end of recorded data.
264 * Since process_eov positions the tape in front of the written
265 * tapemark it doesn't hurt to write two marks again.
266 */
267 if (!rc)
268 device->required_tapemarks = 2;
269
270 return rc ? rc : written;
271}
272
273/*
274 * Character frontend tape device open function.
275 */
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100276static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277tapechar_open (struct inode *inode, struct file *filp)
278{
279 struct tape_device *device;
280 int minor, rc;
281
282 DBF_EVENT(6, "TCHAR:open: %i:%i\n",
Josef Sipek49522c92006-12-08 02:37:34 -0800283 imajor(filp->f_path.dentry->d_inode),
284 iminor(filp->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
Josef Sipek49522c92006-12-08 02:37:34 -0800286 if (imajor(filp->f_path.dentry->d_inode) != tapechar_major)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 return -ENODEV;
288
Jonathan Corbet764a4a82008-05-15 10:01:17 -0600289 lock_kernel();
Josef Sipek49522c92006-12-08 02:37:34 -0800290 minor = iminor(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 device = tape_get_device(minor / TAPE_MINORS_PER_DEV);
292 if (IS_ERR(device)) {
293 DBF_EVENT(3, "TCHAR:open: tape_get_device() failed\n");
Jonathan Corbet764a4a82008-05-15 10:01:17 -0600294 rc = PTR_ERR(device);
295 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 }
297
298
299 rc = tape_open(device);
300 if (rc == 0) {
301 filp->private_data = device;
Jonathan Corbet764a4a82008-05-15 10:01:17 -0600302 rc = nonseekable_open(inode, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 }
Jonathan Corbet764a4a82008-05-15 10:01:17 -0600304 else
305 tape_put_device(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Jonathan Corbet764a4a82008-05-15 10:01:17 -0600307out:
308 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 return rc;
310}
311
312/*
313 * Character frontend tape device release function.
314 */
315
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100316static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317tapechar_release(struct inode *inode, struct file *filp)
318{
319 struct tape_device *device;
320
321 DBF_EVENT(6, "TCHAR:release: %x\n", iminor(inode));
322 device = (struct tape_device *) filp->private_data;
323
324 /*
325 * If this is the rewinding tape minor then rewind. In that case we
326 * write all required tapemarks. Otherwise only one to terminate the
327 * file.
328 */
329 if ((iminor(inode) & 1) != 0) {
330 if (device->required_tapemarks)
331 tape_std_terminate_write(device);
332 tape_mtop(device, MTREW, 1);
333 } else {
334 if (device->required_tapemarks > 1) {
335 if (tape_mtop(device, MTWEOF, 1) == 0)
336 device->required_tapemarks--;
337 }
338 }
339
340 if (device->char_data.idal_buf != NULL) {
341 idal_buffer_free(device->char_data.idal_buf);
342 device->char_data.idal_buf = NULL;
343 }
344 tape_release(device);
345 filp->private_data = tape_put_device(device);
346
347 return 0;
348}
349
350/*
351 * Tape device io controls.
352 */
353static int
354tapechar_ioctl(struct inode *inp, struct file *filp,
355 unsigned int no, unsigned long data)
356{
357 struct tape_device *device;
358 int rc;
359
360 DBF_EVENT(6, "TCHAR:ioct\n");
361
362 device = (struct tape_device *) filp->private_data;
363
364 if (no == MTIOCTOP) {
365 struct mtop op;
366
367 if (copy_from_user(&op, (char __user *) data, sizeof(op)) != 0)
368 return -EFAULT;
369 if (op.mt_count < 0)
370 return -EINVAL;
371
372 /*
373 * Operations that change tape position should write final
374 * tapemarks.
375 */
376 switch (op.mt_op) {
377 case MTFSF:
378 case MTBSF:
379 case MTFSR:
380 case MTBSR:
381 case MTREW:
382 case MTOFFL:
383 case MTEOM:
384 case MTRETEN:
385 case MTBSFM:
386 case MTFSFM:
387 case MTSEEK:
388#ifdef CONFIG_S390_TAPE_BLOCK
389 device->blk_data.medium_changed = 1;
390#endif
391 if (device->required_tapemarks)
392 tape_std_terminate_write(device);
393 default:
394 ;
395 }
396 rc = tape_mtop(device, op.mt_op, op.mt_count);
397
398 if (op.mt_op == MTWEOF && rc == 0) {
399 if (op.mt_count > device->required_tapemarks)
400 device->required_tapemarks = 0;
401 else
402 device->required_tapemarks -= op.mt_count;
403 }
404 return rc;
405 }
406 if (no == MTIOCPOS) {
407 /* MTIOCPOS: query the tape position. */
408 struct mtpos pos;
409
410 rc = tape_mtop(device, MTTELL, 1);
411 if (rc < 0)
412 return rc;
413 pos.mt_blkno = rc;
414 if (copy_to_user((char __user *) data, &pos, sizeof(pos)) != 0)
415 return -EFAULT;
416 return 0;
417 }
418 if (no == MTIOCGET) {
419 /* MTIOCGET: query the tape drive status. */
420 struct mtget get;
421
422 memset(&get, 0, sizeof(get));
423 get.mt_type = MT_ISUNKNOWN;
424 get.mt_resid = 0 /* device->devstat.rescnt */;
425 get.mt_dsreg = device->tape_state;
426 /* FIXME: mt_gstat, mt_erreg, mt_fileno */
427 get.mt_gstat = 0;
428 get.mt_erreg = 0;
429 get.mt_fileno = 0;
430 get.mt_gstat = device->tape_generic_status;
431
432 if (device->medium_state == MS_LOADED) {
433 rc = tape_mtop(device, MTTELL, 1);
434
435 if (rc < 0)
436 return rc;
437
438 if (rc == 0)
439 get.mt_gstat |= GMT_BOT(~0);
440
441 get.mt_blkno = rc;
442 }
443
444 if (copy_to_user((char __user *) data, &get, sizeof(get)) != 0)
445 return -EFAULT;
446
447 return 0;
448 }
449 /* Try the discipline ioctl function. */
450 if (device->discipline->ioctl_fn == NULL)
451 return -EINVAL;
452 return device->discipline->ioctl_fn(device, no, data);
453}
454
Christoph Hellwigf042e0f2006-01-09 20:52:07 -0800455static long
456tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data)
457{
458 struct tape_device *device = filp->private_data;
459 int rval = -ENOIOCTLCMD;
460
461 if (device->discipline->ioctl_fn) {
462 lock_kernel();
463 rval = device->discipline->ioctl_fn(device, no, data);
464 unlock_kernel();
465 if (rval == -EINVAL)
466 rval = -ENOIOCTLCMD;
467 }
468
469 return rval;
470}
471
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472/*
473 * Initialize character device frontend.
474 */
475int
476tapechar_init (void)
477{
478 dev_t dev;
479
480 if (alloc_chrdev_region(&dev, 0, 256, "tape") != 0)
481 return -1;
482
483 tapechar_major = MAJOR(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 return 0;
486}
487
488/*
489 * cleanup
490 */
491void
492tapechar_exit(void)
493{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 unregister_chrdev_region(MKDEV(tapechar_major, 0), 256);
495}