2 * An implementation of a loadable kernel mode driver providing
3 * multiple kernel/user space bidirectional communications links.
5 * Author: Alan Cox <alan@lxorguk.ukuu.org.uk>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
12 * Adapted to become the Linux 2.0 Coda pseudo device
13 * Peter Braam <braam@maths.ox.ac.uk>
14 * Michael Callahan <mjc@emmy.smith.edu>
16 * Changes for Linux 2.1
17 * Copyright (c) 1997 Carnegie-Mellon University
20 #include <linux/module.h>
21 #include <linux/errno.h>
22 #include <linux/kernel.h>
23 #include <linux/major.h>
24 #include <linux/time.h>
25 #include <linux/sched.h>
26 #include <linux/slab.h>
27 #include <linux/ioport.h>
28 #include <linux/fcntl.h>
29 #include <linux/delay.h>
30 #include <linux/skbuff.h>
31 #include <linux/proc_fs.h>
32 #include <linux/vmalloc.h>
34 #include <linux/file.h>
35 #include <linux/poll.h>
36 #include <linux/init.h>
37 #include <linux/list.h>
38 #include <linux/smp_lock.h>
39 #include <linux/device.h>
41 #include <asm/system.h>
43 #include <asm/uaccess.h>
45 #include <linux/coda.h>
46 #include <linux/coda_linux.h>
47 #include <linux/coda_fs_i.h>
48 #include <linux/coda_psdev.h>
53 int coda_hard
; /* allows signals during upcalls */
54 unsigned long coda_timeout
= 30; /* .. secs, then signals will dequeue */
57 struct venus_comm coda_comms
[MAX_CODADEVS
];
58 static struct class *coda_psdev_class
;
64 static unsigned int coda_psdev_poll(struct file
*file
, poll_table
* wait
)
66 struct venus_comm
*vcp
= (struct venus_comm
*) file
->private_data
;
67 unsigned int mask
= POLLOUT
| POLLWRNORM
;
69 poll_wait(file
, &vcp
->vc_waitq
, wait
);
70 if (!list_empty(&vcp
->vc_pending
))
71 mask
|= POLLIN
| POLLRDNORM
;
76 static long coda_psdev_ioctl(struct file
* filp
, unsigned int cmd
, unsigned long arg
)
81 case CIOC_KERNEL_VERSION
:
82 data
= CODA_KERNEL_VERSION
;
83 return put_user(data
, (int __user
*) arg
);
92 * Receive a message written by Venus to the psdev
95 static ssize_t
coda_psdev_write(struct file
*file
, const char __user
*buf
,
96 size_t nbytes
, loff_t
*off
)
98 struct venus_comm
*vcp
= (struct venus_comm
*) file
->private_data
;
99 struct upc_req
*req
= NULL
;
101 struct list_head
*lh
;
102 struct coda_in_hdr hdr
;
103 ssize_t retval
= 0, count
= 0;
106 /* Peek at the opcode, uniquefier */
107 if (copy_from_user(&hdr
, buf
, 2 * sizeof(u_long
)))
110 if (DOWNCALL(hdr
.opcode
)) {
111 union outputArgs
*dcbuf
;
112 int size
= sizeof(*dcbuf
);
114 if ( nbytes
< sizeof(struct coda_out_hdr
) ) {
115 printk("coda_downcall opc %d uniq %d, not enough!\n",
116 hdr
.opcode
, hdr
.unique
);
120 if ( nbytes
> size
) {
121 printk("Coda: downcall opc %d, uniq %d, too much!",
122 hdr
.opcode
, hdr
.unique
);
125 CODA_ALLOC(dcbuf
, union outputArgs
*, nbytes
);
126 if (copy_from_user(dcbuf
, buf
, nbytes
)) {
127 CODA_FREE(dcbuf
, nbytes
);
132 /* what downcall errors does Venus handle ? */
133 error
= coda_downcall(vcp
, hdr
.opcode
, dcbuf
);
135 CODA_FREE(dcbuf
, nbytes
);
137 printk("psdev_write: coda_downcall error: %d\n", error
);
145 /* Look for the message on the processing queue. */
147 list_for_each(lh
, &vcp
->vc_processing
) {
148 tmp
= list_entry(lh
, struct upc_req
, uc_chain
);
149 if (tmp
->uc_unique
== hdr
.unique
) {
151 list_del(&req
->uc_chain
);
158 printk("psdev_write: msg (%d, %d) not found\n",
159 hdr
.opcode
, hdr
.unique
);
164 /* move data into response buffer. */
165 if (req
->uc_outSize
< nbytes
) {
166 printk("psdev_write: too much cnt: %d, cnt: %ld, opc: %d, uniq: %d.\n",
167 req
->uc_outSize
, (long)nbytes
, hdr
.opcode
, hdr
.unique
);
168 nbytes
= req
->uc_outSize
; /* don't have more space! */
170 if (copy_from_user(req
->uc_data
, buf
, nbytes
)) {
171 req
->uc_flags
|= CODA_REQ_ABORT
;
172 wake_up(&req
->uc_sleep
);
177 /* adjust outsize. is this useful ?? */
178 req
->uc_outSize
= nbytes
;
179 req
->uc_flags
|= CODA_REQ_WRITE
;
182 /* Convert filedescriptor into a file handle */
183 if (req
->uc_opcode
== CODA_OPEN_BY_FD
) {
184 struct coda_open_by_fd_out
*outp
=
185 (struct coda_open_by_fd_out
*)req
->uc_data
;
186 if (!outp
->oh
.result
)
187 outp
->fh
= fget(outp
->fd
);
190 wake_up(&req
->uc_sleep
);
192 return(count
? count
: retval
);
196 * Read a message from the kernel to Venus
199 static ssize_t
coda_psdev_read(struct file
* file
, char __user
* buf
,
200 size_t nbytes
, loff_t
*off
)
202 DECLARE_WAITQUEUE(wait
, current
);
203 struct venus_comm
*vcp
= (struct venus_comm
*) file
->private_data
;
205 ssize_t retval
= 0, count
= 0;
212 add_wait_queue(&vcp
->vc_waitq
, &wait
);
213 set_current_state(TASK_INTERRUPTIBLE
);
215 while (list_empty(&vcp
->vc_pending
)) {
216 if (file
->f_flags
& O_NONBLOCK
) {
220 if (signal_pending(current
)) {
221 retval
= -ERESTARTSYS
;
227 set_current_state(TASK_RUNNING
);
228 remove_wait_queue(&vcp
->vc_waitq
, &wait
);
233 req
= list_entry(vcp
->vc_pending
.next
, struct upc_req
,uc_chain
);
234 list_del(&req
->uc_chain
);
236 /* Move the input args into userspace */
237 count
= req
->uc_inSize
;
238 if (nbytes
< req
->uc_inSize
) {
239 printk ("psdev_read: Venus read %ld bytes of %d in message\n",
240 (long)nbytes
, req
->uc_inSize
);
244 if (copy_to_user(buf
, req
->uc_data
, count
))
247 /* If request was not a signal, enqueue and don't free */
248 if (!(req
->uc_flags
& CODA_REQ_ASYNC
)) {
249 req
->uc_flags
|= CODA_REQ_READ
;
250 list_add_tail(&(req
->uc_chain
), &vcp
->vc_processing
);
254 CODA_FREE(req
->uc_data
, sizeof(struct coda_in_hdr
));
258 return (count
? count
: retval
);
261 static int coda_psdev_open(struct inode
* inode
, struct file
* file
)
263 struct venus_comm
*vcp
;
267 if (idx
< 0 || idx
>= MAX_CODADEVS
)
273 vcp
= &coda_comms
[idx
];
274 if (!vcp
->vc_inuse
) {
277 INIT_LIST_HEAD(&vcp
->vc_pending
);
278 INIT_LIST_HEAD(&vcp
->vc_processing
);
279 init_waitqueue_head(&vcp
->vc_waitq
);
283 file
->private_data
= vcp
;
292 static int coda_psdev_release(struct inode
* inode
, struct file
* file
)
294 struct venus_comm
*vcp
= (struct venus_comm
*) file
->private_data
;
295 struct upc_req
*req
, *tmp
;
297 if (!vcp
|| !vcp
->vc_inuse
) {
298 printk("psdev_release: Not open.\n");
304 /* Wakeup clients so they can return. */
305 list_for_each_entry_safe(req
, tmp
, &vcp
->vc_pending
, uc_chain
) {
306 list_del(&req
->uc_chain
);
308 /* Async requests need to be freed here */
309 if (req
->uc_flags
& CODA_REQ_ASYNC
) {
310 CODA_FREE(req
->uc_data
, sizeof(struct coda_in_hdr
));
314 req
->uc_flags
|= CODA_REQ_ABORT
;
315 wake_up(&req
->uc_sleep
);
318 list_for_each_entry_safe(req
, tmp
, &vcp
->vc_processing
, uc_chain
) {
319 list_del(&req
->uc_chain
);
321 req
->uc_flags
|= CODA_REQ_ABORT
;
322 wake_up(&req
->uc_sleep
);
325 file
->private_data
= NULL
;
332 static const struct file_operations coda_psdev_fops
= {
333 .owner
= THIS_MODULE
,
334 .read
= coda_psdev_read
,
335 .write
= coda_psdev_write
,
336 .poll
= coda_psdev_poll
,
337 .unlocked_ioctl
= coda_psdev_ioctl
,
338 .open
= coda_psdev_open
,
339 .release
= coda_psdev_release
,
340 .llseek
= noop_llseek
,
343 static int init_coda_psdev(void)
346 if (register_chrdev(CODA_PSDEV_MAJOR
, "coda", &coda_psdev_fops
)) {
347 printk(KERN_ERR
"coda_psdev: unable to get major %d\n",
351 coda_psdev_class
= class_create(THIS_MODULE
, "coda");
352 if (IS_ERR(coda_psdev_class
)) {
353 err
= PTR_ERR(coda_psdev_class
);
356 for (i
= 0; i
< MAX_CODADEVS
; i
++)
357 device_create(coda_psdev_class
, NULL
,
358 MKDEV(CODA_PSDEV_MAJOR
, i
), NULL
, "cfs%d", i
);
363 unregister_chrdev(CODA_PSDEV_MAJOR
, "coda");
368 MODULE_AUTHOR("Jan Harkes, Peter J. Braam");
369 MODULE_DESCRIPTION("Coda Distributed File System VFS interface");
370 MODULE_ALIAS_CHARDEV_MAJOR(CODA_PSDEV_MAJOR
);
371 MODULE_LICENSE("GPL");
372 MODULE_VERSION("6.6");
374 static int __init
init_coda(void)
379 status
= coda_init_inodecache();
382 status
= init_coda_psdev();
384 printk("Problem (%d) in init_coda_psdev\n", status
);
388 status
= register_filesystem(&coda_fs_type
);
390 printk("coda: failed to register filesystem!\n");
395 for (i
= 0; i
< MAX_CODADEVS
; i
++)
396 device_destroy(coda_psdev_class
, MKDEV(CODA_PSDEV_MAJOR
, i
));
397 class_destroy(coda_psdev_class
);
398 unregister_chrdev(CODA_PSDEV_MAJOR
, "coda");
401 coda_destroy_inodecache();
406 static void __exit
exit_coda(void)
410 err
= unregister_filesystem(&coda_fs_type
);
412 printk("coda: failed to unregister filesystem\n");
414 for (i
= 0; i
< MAX_CODADEVS
; i
++)
415 device_destroy(coda_psdev_class
, MKDEV(CODA_PSDEV_MAJOR
, i
));
416 class_destroy(coda_psdev_class
);
417 unregister_chrdev(CODA_PSDEV_MAJOR
, "coda");
419 coda_destroy_inodecache();
422 module_init(init_coda
);
423 module_exit(exit_coda
);