2 * Copyright (C) 1996, 1997 Claus-Justus Heine.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; see the file COPYING. If not, write to
16 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
19 * This file contains the code that registers the zftape frontend
20 * to the ftape floppy tape driver for Linux
23 #include <linux/config.h>
24 #include <linux/module.h>
25 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/signal.h>
29 #include <linux/major.h>
30 #include <linux/slab.h>
32 #include <linux/kmod.h>
34 #include <linux/fcntl.h>
35 #include <linux/smp_lock.h>
37 #include <linux/zftape.h>
38 #include <linux/init.h>
39 #include <linux/device.h>
41 #include "../zftape/zftape-init.h"
42 #include "../zftape/zftape-read.h"
43 #include "../zftape/zftape-write.h"
44 #include "../zftape/zftape-ctl.h"
45 #include "../zftape/zftape-buffers.h"
47 MODULE_AUTHOR("(c) 1996, 1997 Claus-Justus Heine "
48 "(claus@momo.math.rwth-aachen.de)");
49 MODULE_DESCRIPTION(ZFTAPE_VERSION " - "
50 "VFS interface for the Linux floppy tape driver. "
51 "Support for QIC-113 compatible volume table "
52 "and builtin compression (lzrw3 algorithm)");
53 MODULE_SUPPORTED_DEVICE("char-major-27");
54 MODULE_LICENSE("GPL");
58 struct zft_cmpr_ops *zft_cmpr_ops = NULL;
59 const ftape_info *zft_status;
63 static unsigned long busy_flag;
65 static sigset_t orig_sigmask;
67 /* the interface to the kernel vfs layer
70 /* Note about llseek():
72 * st.c and tpqic.c update fp->f_pos but don't implment llseek() and
73 * initialize the llseek component of the file_ops struct with NULL.
74 * This means that the user will get the default seek, but the tape
75 * device will not respect the new position, but happily read from the
76 * old position. Think a zftape specific llseek() function would be
77 * better, returning -ESPIPE. TODO.
80 static int zft_open (struct inode *ino, struct file *filep);
81 static int zft_close(struct inode *ino, struct file *filep);
82 static int zft_ioctl(struct inode *ino, struct file *filep,
83 unsigned int command, unsigned long arg);
84 static int zft_mmap(struct file *filep, struct vm_area_struct *vma);
85 static ssize_t zft_read (struct file *fp, char __user *buff,
86 size_t req_len, loff_t *ppos);
87 static ssize_t zft_write(struct file *fp, const char __user *buff,
88 size_t req_len, loff_t *ppos);
90 static struct file_operations zft_cdev =
101 static struct class *zft_class;
103 /* Open floppy tape device
105 static int zft_open(struct inode *ino, struct file *filep)
108 TRACE_FUN(ft_t_flow);
110 nonseekable_open(ino, filep);
111 TRACE(ft_t_flow, "called for minor %d", iminor(ino));
112 if ( test_and_set_bit(0,&busy_flag) ) {
113 TRACE_ABORT(-EBUSY, ft_t_warn, "failed: already busy");
115 if ((iminor(ino) & ~(ZFT_MINOR_OP_MASK | FTAPE_NO_REWIND))
118 clear_bit(0,&busy_flag);
119 TRACE_ABORT(-ENXIO, ft_t_err, "failed: invalid unit nr");
121 orig_sigmask = current->blocked;
122 sigfillset(¤t->blocked);
123 result = _zft_open(iminor(ino), filep->f_flags & O_ACCMODE);
125 current->blocked = orig_sigmask; /* restore mask */
126 clear_bit(0,&busy_flag);
127 TRACE_ABORT(result, ft_t_err, "_ftape_open failed");
129 /* Mask signals that will disturb proper operation of the
130 * program that is calling.
132 current->blocked = orig_sigmask;
133 sigaddsetmask (¤t->blocked, _DO_BLOCK);
138 /* Close floppy tape device
140 static int zft_close(struct inode *ino, struct file *filep)
143 TRACE_FUN(ft_t_flow);
145 if ( !test_bit(0,&busy_flag) || iminor(ino) != zft_unit) {
146 TRACE(ft_t_err, "failed: not busy or wrong unit");
149 sigfillset(¤t->blocked);
150 result = _zft_close();
152 TRACE(ft_t_err, "_zft_close failed");
154 current->blocked = orig_sigmask; /* restore before open state */
155 clear_bit(0,&busy_flag);
159 /* Ioctl for floppy tape device
161 static int zft_ioctl(struct inode *ino, struct file *filep,
162 unsigned int command, unsigned long arg)
165 sigset_t old_sigmask;
166 TRACE_FUN(ft_t_flow);
168 if ( !test_bit(0,&busy_flag) || iminor(ino) != zft_unit || ft_failure) {
169 TRACE_ABORT(-EIO, ft_t_err,
170 "failed: not busy, failure or wrong unit");
172 old_sigmask = current->blocked; /* save mask */
173 sigfillset(¤t->blocked);
174 /* This will work as long as sizeof(void *) == sizeof(long) */
175 result = _zft_ioctl(command, (void __user *) arg);
176 current->blocked = old_sigmask; /* restore mask */
180 /* Ioctl for floppy tape device
182 static int zft_mmap(struct file *filep, struct vm_area_struct *vma)
185 sigset_t old_sigmask;
186 TRACE_FUN(ft_t_flow);
188 if ( !test_bit(0,&busy_flag) ||
189 iminor(filep->f_dentry->d_inode) != zft_unit ||
192 TRACE_ABORT(-EIO, ft_t_err,
193 "failed: not busy, failure or wrong unit");
195 old_sigmask = current->blocked; /* save mask */
196 sigfillset(¤t->blocked);
197 if ((result = ftape_mmap(vma)) >= 0) {
198 #ifndef MSYNC_BUG_WAS_FIXED
199 static struct vm_operations_struct dummy = { NULL, };
200 vma->vm_ops = &dummy;
203 current->blocked = old_sigmask; /* restore mask */
207 /* Read from floppy tape device
209 static ssize_t zft_read(struct file *fp, char __user *buff,
210 size_t req_len, loff_t *ppos)
213 sigset_t old_sigmask;
214 struct inode *ino = fp->f_dentry->d_inode;
215 TRACE_FUN(ft_t_flow);
217 TRACE(ft_t_data_flow, "called with count: %ld", (unsigned long)req_len);
218 if (!test_bit(0,&busy_flag) || iminor(ino) != zft_unit || ft_failure) {
219 TRACE_ABORT(-EIO, ft_t_err,
220 "failed: not busy, failure or wrong unit");
222 old_sigmask = current->blocked; /* save mask */
223 sigfillset(¤t->blocked);
224 result = _zft_read(buff, req_len);
225 current->blocked = old_sigmask; /* restore mask */
226 TRACE(ft_t_data_flow, "return with count: %d", result);
230 /* Write to tape device
232 static ssize_t zft_write(struct file *fp, const char __user *buff,
233 size_t req_len, loff_t *ppos)
236 sigset_t old_sigmask;
237 struct inode *ino = fp->f_dentry->d_inode;
238 TRACE_FUN(ft_t_flow);
240 TRACE(ft_t_flow, "called with count: %ld", (unsigned long)req_len);
241 if (!test_bit(0,&busy_flag) || iminor(ino) != zft_unit || ft_failure) {
242 TRACE_ABORT(-EIO, ft_t_err,
243 "failed: not busy, failure or wrong unit");
245 old_sigmask = current->blocked; /* save mask */
246 sigfillset(¤t->blocked);
247 result = _zft_write(buff, req_len);
248 current->blocked = old_sigmask; /* restore mask */
249 TRACE(ft_t_data_flow, "return with count: %d", result);
253 /* END OF VFS INTERFACE
255 *****************************************************************************/
257 /* driver/module initialization
260 /* the compression module has to call this function to hook into the zftape
263 int zft_cmpr_register(struct zft_cmpr_ops *new_ops)
265 TRACE_FUN(ft_t_flow);
267 if (zft_cmpr_ops != NULL) {
270 zft_cmpr_ops = new_ops;
275 /* lock the zft-compressor() module.
277 int zft_cmpr_lock(int try_to_load)
279 if (zft_cmpr_ops == NULL) {
282 request_module("zft-compressor");
283 if (zft_cmpr_ops == NULL) {
293 (*zft_cmpr_ops->lock)();
297 #ifdef CONFIG_ZFT_COMPRESSOR
298 extern int zft_compressor_init(void);
301 /* Called by modules package when installing the driver or by kernel
302 * during the initialization phase
304 int __init zft_init(void)
307 TRACE_FUN(ft_t_flow);
310 printk(KERN_INFO ZFTAPE_VERSION "\n");
311 if (TRACE_LEVEL >= ft_t_info) {
314 "(c) 1996, 1997 Claus-Justus Heine (claus@momo.math.rwth-aachen.de)\n"
316 "vfs interface for ftape floppy tape driver.\n"
318 "Support for QIC-113 compatible volume table, dynamic memory allocation\n"
320 "and builtin compression (lzrw3 algorithm).\n");
323 /* print a short no-nonsense boot message */
324 printk(KERN_INFO ZFTAPE_VERSION "\n");
326 TRACE(ft_t_info, "zft_init @ 0x%p", zft_init);
328 "installing zftape VFS interface for ftape driver ...");
329 TRACE_CATCH(register_chrdev(QIC117_TAPE_MAJOR, "zft", &zft_cdev),);
331 zft_class = class_create(THIS_MODULE, "zft");
332 for (i = 0; i < 4; i++) {
333 class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i), NULL, "qft%i", i);
334 class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 4), NULL, "nqft%i", i);
335 class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 16), NULL, "zqft%i", i);
336 class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 20), NULL, "nzqft%i", i);
337 class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 32), NULL, "rawqft%i", i);
338 class_device_create(zft_class, NULL, MKDEV(QIC117_TAPE_MAJOR, i + 36), NULL, "nrawrawqft%i", i);
341 #ifdef CONFIG_ZFT_COMPRESSOR
342 (void)zft_compressor_init();
344 zft_status = ftape_get_status(); /* fetch global data of ftape
351 /* Called by modules package when removing the driver
353 static void zft_exit(void)
356 TRACE_FUN(ft_t_flow);
358 if (unregister_chrdev(QIC117_TAPE_MAJOR, "zft") != 0) {
359 TRACE(ft_t_warn, "failed");
361 TRACE(ft_t_info, "successful");
363 for (i = 0; i < 4; i++) {
364 class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i));
365 class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 4));
366 class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 16));
367 class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 20));
368 class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 32));
369 class_device_destroy(zft_class, MKDEV(QIC117_TAPE_MAJOR, i + 36));
371 class_destroy(zft_class);
372 zft_uninit_mem(); /* release remaining memory, if any */
373 printk(KERN_INFO "zftape successfully unloaded.\n");
377 module_init(zft_init);
378 module_exit(zft_exit);