1
2
3
4
5
6
7
8
9
10
11
12#define KMSG_COMPONENT "tape"
13#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
14
15#include <linux/module.h>
16#include <linux/types.h>
17#include <linux/proc_fs.h>
18#include <linux/mtio.h>
19#include <linux/compat.h>
20
21#include <asm/uaccess.h>
22
23#define TAPE_DBF_AREA tape_core_dbf
24
25#include "tape.h"
26#include "tape_std.h"
27#include "tape_class.h"
28
29#define TAPECHAR_MAJOR 0
30
31
32
33
34static ssize_t tapechar_read(struct file *, char __user *, size_t, loff_t *);
35static ssize_t tapechar_write(struct file *, const char __user *, size_t, loff_t *);
36static int tapechar_open(struct inode *,struct file *);
37static int tapechar_release(struct inode *,struct file *);
38static long tapechar_ioctl(struct file *, unsigned int, unsigned long);
39#ifdef CONFIG_COMPAT
40static long tapechar_compat_ioctl(struct file *, unsigned int, unsigned long);
41#endif
42
43static const struct file_operations tape_fops =
44{
45 .owner = THIS_MODULE,
46 .read = tapechar_read,
47 .write = tapechar_write,
48 .unlocked_ioctl = tapechar_ioctl,
49#ifdef CONFIG_COMPAT
50 .compat_ioctl = tapechar_compat_ioctl,
51#endif
52 .open = tapechar_open,
53 .release = tapechar_release,
54 .llseek = no_llseek,
55};
56
57static int tapechar_major = TAPECHAR_MAJOR;
58
59
60
61
62int
63tapechar_setup_device(struct tape_device * device)
64{
65 char device_name[20];
66
67 sprintf(device_name, "ntibm%i", device->first_minor / 2);
68 device->nt = register_tape_dev(
69 &device->cdev->dev,
70 MKDEV(tapechar_major, device->first_minor),
71 &tape_fops,
72 device_name,
73 "non-rewinding"
74 );
75 device_name[0] = 'r';
76 device->rt = register_tape_dev(
77 &device->cdev->dev,
78 MKDEV(tapechar_major, device->first_minor + 1),
79 &tape_fops,
80 device_name,
81 "rewinding"
82 );
83
84 return 0;
85}
86
87void
88tapechar_cleanup_device(struct tape_device *device)
89{
90 unregister_tape_dev(&device->cdev->dev, device->rt);
91 device->rt = NULL;
92 unregister_tape_dev(&device->cdev->dev, device->nt);
93 device->nt = NULL;
94}
95
96static int
97tapechar_check_idalbuffer(struct tape_device *device, size_t block_size)
98{
99 struct idal_buffer *new;
100
101 if (device->char_data.idal_buf != NULL &&
102 device->char_data.idal_buf->size == block_size)
103 return 0;
104
105 if (block_size > MAX_BLOCKSIZE) {
106 DBF_EVENT(3, "Invalid blocksize (%zd > %d)\n",
107 block_size, MAX_BLOCKSIZE);
108 return -EINVAL;
109 }
110
111
112 new = idal_buffer_alloc(block_size, 0);
113 if (IS_ERR(new))
114 return -ENOMEM;
115
116 if (device->char_data.idal_buf != NULL)
117 idal_buffer_free(device->char_data.idal_buf);
118
119 device->char_data.idal_buf = new;
120
121 return 0;
122}
123
124
125
126
127static ssize_t
128tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
129{
130 struct tape_device *device;
131 struct tape_request *request;
132 size_t block_size;
133 int rc;
134
135 DBF_EVENT(6, "TCHAR:read\n");
136 device = (struct tape_device *) filp->private_data;
137
138
139
140
141
142
143 if(device->required_tapemarks) {
144 return tape_std_terminate_write(device);
145 }
146
147
148 if (device->char_data.block_size != 0) {
149 if (count < device->char_data.block_size) {
150 DBF_EVENT(3, "TCHAR:read smaller than block "
151 "size was requested\n");
152 return -EINVAL;
153 }
154 block_size = device->char_data.block_size;
155 } else {
156 block_size = count;
157 }
158
159 rc = tapechar_check_idalbuffer(device, block_size);
160 if (rc)
161 return rc;
162
163 DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size);
164
165 request = device->discipline->read_block(device, block_size);
166 if (IS_ERR(request))
167 return PTR_ERR(request);
168
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
174 if (idal_buffer_to_user(device->char_data.idal_buf,
175 data, rc) != 0)
176 rc = -EFAULT;
177 }
178 tape_free_request(request);
179 return rc;
180}
181
182
183
184
185static ssize_t
186tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t *ppos)
187{
188 struct tape_device *device;
189 struct tape_request *request;
190 size_t block_size;
191 size_t written;
192 int nblocks;
193 int i, rc;
194
195 DBF_EVENT(6, "TCHAR:write\n");
196 device = (struct tape_device *) filp->private_data;
197
198 if (device->char_data.block_size != 0) {
199 if (count < device->char_data.block_size) {
200 DBF_EVENT(3, "TCHAR:write smaller than block "
201 "size was requested\n");
202 return -EINVAL;
203 }
204 block_size = device->char_data.block_size;
205 nblocks = count / block_size;
206 } else {
207 block_size = count;
208 nblocks = 1;
209 }
210
211 rc = tapechar_check_idalbuffer(device, block_size);
212 if (rc)
213 return rc;
214
215 DBF_EVENT(6,"TCHAR:nbytes: %lx\n", block_size);
216 DBF_EVENT(6, "TCHAR:nblocks: %x\n", nblocks);
217
218 request = device->discipline->write_block(device, block_size);
219 if (IS_ERR(request))
220 return PTR_ERR(request);
221 rc = 0;
222 written = 0;
223 for (i = 0; i < nblocks; i++) {
224
225 if (idal_buffer_from_user(device->char_data.idal_buf,
226 data, block_size)) {
227 rc = -EFAULT;
228 break;
229 }
230 rc = tape_do_io(device, request);
231 if (rc)
232 break;
233 DBF_EVENT(6, "TCHAR:wbytes: %lx\n",
234 block_size - request->rescnt);
235 written += block_size - request->rescnt;
236 if (request->rescnt != 0)
237 break;
238 data += block_size;
239 }
240 tape_free_request(request);
241 if (rc == -ENOSPC) {
242
243
244
245
246 if (device->discipline->process_eov)
247 device->discipline->process_eov(device);
248 if (written > 0)
249 rc = 0;
250
251 }
252
253
254
255
256
257
258
259
260 if (!rc)
261 device->required_tapemarks = 2;
262
263 return rc ? rc : written;
264}
265
266
267
268
269static int
270tapechar_open (struct inode *inode, struct file *filp)
271{
272 struct tape_device *device;
273 int minor, rc;
274
275 DBF_EVENT(6, "TCHAR:open: %i:%i\n",
276 imajor(file_inode(filp)),
277 iminor(file_inode(filp)));
278
279 if (imajor(file_inode(filp)) != tapechar_major)
280 return -ENODEV;
281
282 minor = iminor(file_inode(filp));
283 device = tape_find_device(minor / TAPE_MINORS_PER_DEV);
284 if (IS_ERR(device)) {
285 DBF_EVENT(3, "TCHAR:open: tape_find_device() failed\n");
286 return PTR_ERR(device);
287 }
288
289 rc = tape_open(device);
290 if (rc == 0) {
291 filp->private_data = device;
292 nonseekable_open(inode, filp);
293 } else
294 tape_put_device(device);
295
296 return rc;
297}
298
299
300
301
302
303static int
304tapechar_release(struct inode *inode, struct file *filp)
305{
306 struct tape_device *device;
307
308 DBF_EVENT(6, "TCHAR:release: %x\n", iminor(inode));
309 device = (struct tape_device *) filp->private_data;
310
311
312
313
314
315
316 if ((iminor(inode) & 1) != 0) {
317 if (device->required_tapemarks)
318 tape_std_terminate_write(device);
319 tape_mtop(device, MTREW, 1);
320 } else {
321 if (device->required_tapemarks > 1) {
322 if (tape_mtop(device, MTWEOF, 1) == 0)
323 device->required_tapemarks--;
324 }
325 }
326
327 if (device->char_data.idal_buf != NULL) {
328 idal_buffer_free(device->char_data.idal_buf);
329 device->char_data.idal_buf = NULL;
330 }
331 tape_release(device);
332 filp->private_data = NULL;
333 tape_put_device(device);
334
335 return 0;
336}
337
338
339
340
341static int
342__tapechar_ioctl(struct tape_device *device,
343 unsigned int no, unsigned long data)
344{
345 int rc;
346
347 if (no == MTIOCTOP) {
348 struct mtop op;
349
350 if (copy_from_user(&op, (char __user *) data, sizeof(op)) != 0)
351 return -EFAULT;
352 if (op.mt_count < 0)
353 return -EINVAL;
354
355
356
357
358
359 switch (op.mt_op) {
360 case MTFSF:
361 case MTBSF:
362 case MTFSR:
363 case MTBSR:
364 case MTREW:
365 case MTOFFL:
366 case MTEOM:
367 case MTRETEN:
368 case MTBSFM:
369 case MTFSFM:
370 case MTSEEK:
371 if (device->required_tapemarks)
372 tape_std_terminate_write(device);
373 default:
374 ;
375 }
376 rc = tape_mtop(device, op.mt_op, op.mt_count);
377
378 if (op.mt_op == MTWEOF && rc == 0) {
379 if (op.mt_count > device->required_tapemarks)
380 device->required_tapemarks = 0;
381 else
382 device->required_tapemarks -= op.mt_count;
383 }
384 return rc;
385 }
386 if (no == MTIOCPOS) {
387
388 struct mtpos pos;
389
390 rc = tape_mtop(device, MTTELL, 1);
391 if (rc < 0)
392 return rc;
393 pos.mt_blkno = rc;
394 if (copy_to_user((char __user *) data, &pos, sizeof(pos)) != 0)
395 return -EFAULT;
396 return 0;
397 }
398 if (no == MTIOCGET) {
399
400 struct mtget get;
401
402 memset(&get, 0, sizeof(get));
403 get.mt_type = MT_ISUNKNOWN;
404 get.mt_resid = 0 ;
405 get.mt_dsreg =
406 ((device->char_data.block_size << MT_ST_BLKSIZE_SHIFT)
407 & MT_ST_BLKSIZE_MASK);
408
409 get.mt_gstat = 0;
410 get.mt_erreg = 0;
411 get.mt_fileno = 0;
412 get.mt_gstat = device->tape_generic_status;
413
414 if (device->medium_state == MS_LOADED) {
415 rc = tape_mtop(device, MTTELL, 1);
416
417 if (rc < 0)
418 return rc;
419
420 if (rc == 0)
421 get.mt_gstat |= GMT_BOT(~0);
422
423 get.mt_blkno = rc;
424 }
425
426 if (copy_to_user((char __user *) data, &get, sizeof(get)) != 0)
427 return -EFAULT;
428
429 return 0;
430 }
431
432 if (device->discipline->ioctl_fn == NULL)
433 return -EINVAL;
434 return device->discipline->ioctl_fn(device, no, data);
435}
436
437static long
438tapechar_ioctl(struct file *filp, unsigned int no, unsigned long data)
439{
440 struct tape_device *device;
441 long rc;
442
443 DBF_EVENT(6, "TCHAR:ioct\n");
444
445 device = (struct tape_device *) filp->private_data;
446 mutex_lock(&device->mutex);
447 rc = __tapechar_ioctl(device, no, data);
448 mutex_unlock(&device->mutex);
449 return rc;
450}
451
452#ifdef CONFIG_COMPAT
453static long
454tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data)
455{
456 struct tape_device *device = filp->private_data;
457 int rval = -ENOIOCTLCMD;
458 unsigned long argp;
459
460
461
462
463
464 argp = (unsigned long) compat_ptr(data);
465 if (device->discipline->ioctl_fn) {
466 mutex_lock(&device->mutex);
467 rval = device->discipline->ioctl_fn(device, no, argp);
468 mutex_unlock(&device->mutex);
469 if (rval == -EINVAL)
470 rval = -ENOIOCTLCMD;
471 }
472
473 return rval;
474}
475#endif
476
477
478
479
480int
481tapechar_init (void)
482{
483 dev_t dev;
484
485 if (alloc_chrdev_region(&dev, 0, 256, "tape") != 0)
486 return -1;
487
488 tapechar_major = MAJOR(dev);
489
490 return 0;
491}
492
493
494
495
496void
497tapechar_exit(void)
498{
499 unregister_chrdev_region(MKDEV(tapechar_major, 0), 256);
500}
501