URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [fs/] [coda/] [psdev.c] - Blame information for rev 3

Details | Compare with Previous | View Log


/*
 *              An implementation of a loadable kernel mode driver providing
 *              multiple kernel/user space bidirectional communications links.
 *
 *              Author:         Alan Cox <alan@redhat.com>
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 *
 *              Adapted to become the Linux 2.0 Coda pseudo device
 *              Peter  Braam  <braam@maths.ox.ac.uk>
 *              Michael Callahan <mjc@emmy.smith.edu>
 *
 *              Changes for Linux 2.1
 *              Copyright (c) 1997 Carnegie-Mellon University
 */
 
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/time.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/fcntl.h>
#include <linux/delay.h>
#include <linux/skbuff.h>
#include <linux/proc_fs.h>
#include <linux/vmalloc.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/poll.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/smp_lock.h>
#include <linux/device.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/poll.h>
#include <asm/uaccess.h>
 
#include <linux/coda.h>
#include <linux/coda_linux.h>
#include <linux/coda_fs_i.h>
#include <linux/coda_psdev.h>
 
#include "coda_int.h"
 
/* statistics */
int           coda_hard;         /* allows signals during upcalls */
unsigned long coda_timeout = 30; /* .. secs, then signals will dequeue */
 
 
struct venus_comm coda_comms[MAX_CODADEVS];
static struct class *coda_psdev_class;
 
/*
 * Device operations
 */
 
static unsigned int coda_psdev_poll(struct file *file, poll_table * wait)
{
        struct venus_comm *vcp = (struct venus_comm *) file->private_data;
        unsigned int mask = POLLOUT | POLLWRNORM;
 
        poll_wait(file, &vcp->vc_waitq, wait);
        if (!list_empty(&vcp->vc_pending))
                mask |= POLLIN | POLLRDNORM;
 
        return mask;
}
 
static int coda_psdev_ioctl(struct inode * inode, struct file * filp,
                            unsigned int cmd, unsigned long arg)
{
        unsigned int data;
 
        switch(cmd) {
        case CIOC_KERNEL_VERSION:
                data = CODA_KERNEL_VERSION;
                return put_user(data, (int __user *) arg);
        default:
                return -ENOTTY;
        }
 
        return 0;
}
 
/*
 *      Receive a message written by Venus to the psdev
 */
 
static ssize_t coda_psdev_write(struct file *file, const char __user *buf,
                                size_t nbytes, loff_t *off)
{
        struct venus_comm *vcp = (struct venus_comm *) file->private_data;
        struct upc_req *req = NULL;
        struct upc_req *tmp;
        struct list_head *lh;
        struct coda_in_hdr hdr;
        ssize_t retval = 0, count = 0;
        int error;
 
        /* Peek at the opcode, uniquefier */
        if (copy_from_user(&hdr, buf, 2 * sizeof(u_long)))
                return -EFAULT;
 
        if (DOWNCALL(hdr.opcode)) {
                struct super_block *sb = NULL;
                union outputArgs *dcbuf;
                int size = sizeof(*dcbuf);
 
                sb = vcp->vc_sb;
                if ( !sb ) {
                        count = nbytes;
                        goto out;
                }
 
                if  ( nbytes < sizeof(struct coda_out_hdr) ) {
                        printk("coda_downcall opc %d uniq %d, not enough!\n",
                               hdr.opcode, hdr.unique);
                        count = nbytes;
                        goto out;
                }
                if ( nbytes > size ) {
                        printk("Coda: downcall opc %d, uniq %d, too much!",
                               hdr.opcode, hdr.unique);
                        nbytes = size;
                }
                CODA_ALLOC(dcbuf, union outputArgs *, nbytes);
                if (copy_from_user(dcbuf, buf, nbytes)) {
                        CODA_FREE(dcbuf, nbytes);
                        retval = -EFAULT;
                        goto out;
                }
 
                /* what downcall errors does Venus handle ? */
                lock_kernel();
                error = coda_downcall(hdr.opcode, dcbuf, sb);
                unlock_kernel();
 
                CODA_FREE(dcbuf, nbytes);
                if (error) {
                        printk("psdev_write: coda_downcall error: %d\n", error);
                        retval = error;
                        goto out;
                }
                count = nbytes;
                goto out;
        }
 
        /* Look for the message on the processing queue. */
        lock_kernel();
        list_for_each(lh, &vcp->vc_processing) {
                tmp = list_entry(lh, struct upc_req , uc_chain);
                if (tmp->uc_unique == hdr.unique) {
                        req = tmp;
                        list_del(&req->uc_chain);
                        break;
                }
        }
        unlock_kernel();
 
        if (!req) {
                printk("psdev_write: msg (%d, %d) not found\n",
                        hdr.opcode, hdr.unique);
                retval = -ESRCH;
                goto out;
        }
 
        /* move data into response buffer. */
        if (req->uc_outSize < nbytes) {
                printk("psdev_write: too much cnt: %d, cnt: %ld, opc: %d, uniq: %d.\n",
                       req->uc_outSize, (long)nbytes, hdr.opcode, hdr.unique);
                nbytes = req->uc_outSize; /* don't have more space! */
        }
        if (copy_from_user(req->uc_data, buf, nbytes)) {
                req->uc_flags |= REQ_ABORT;
                wake_up(&req->uc_sleep);
                retval = -EFAULT;
                goto out;
        }
 
        /* adjust outsize. is this useful ?? */
        req->uc_outSize = nbytes;
        req->uc_flags |= REQ_WRITE;
        count = nbytes;
 
        /* Convert filedescriptor into a file handle */
        if (req->uc_opcode == CODA_OPEN_BY_FD) {
                struct coda_open_by_fd_out *outp =
                        (struct coda_open_by_fd_out *)req->uc_data;
                if (!outp->oh.result)
                        outp->fh = fget(outp->fd);
        }
 
        wake_up(&req->uc_sleep);
out:
        return(count ? count : retval);
}
 
/*
 *      Read a message from the kernel to Venus
 */
 
static ssize_t coda_psdev_read(struct file * file, char __user * buf,
                               size_t nbytes, loff_t *off)
{
        DECLARE_WAITQUEUE(wait, current);
        struct venus_comm *vcp = (struct venus_comm *) file->private_data;
        struct upc_req *req;
        ssize_t retval = 0, count = 0;
 
        if (nbytes == 0)
                return 0;
 
        lock_kernel();
 
        add_wait_queue(&vcp->vc_waitq, &wait);
        set_current_state(TASK_INTERRUPTIBLE);
 
        while (list_empty(&vcp->vc_pending)) {
                if (file->f_flags & O_NONBLOCK) {
                        retval = -EAGAIN;
                        break;
                }
                if (signal_pending(current)) {
                        retval = -ERESTARTSYS;
                        break;
                }
                schedule();
        }
 
        set_current_state(TASK_RUNNING);
        remove_wait_queue(&vcp->vc_waitq, &wait);
 
        if (retval)
                goto out;
 
        req = list_entry(vcp->vc_pending.next, struct upc_req,uc_chain);
        list_del(&req->uc_chain);
 
        /* Move the input args into userspace */
        count = req->uc_inSize;
        if (nbytes < req->uc_inSize) {
                printk ("psdev_read: Venus read %ld bytes of %d in message\n",
                        (long)nbytes, req->uc_inSize);
                count = nbytes;
        }
 
        if (copy_to_user(buf, req->uc_data, count))
                retval = -EFAULT;
 
        /* If request was not a signal, enqueue and don't free */
        if (!(req->uc_flags & REQ_ASYNC)) {
                req->uc_flags |= REQ_READ;
                list_add_tail(&(req->uc_chain), &vcp->vc_processing);
                goto out;
        }
 
        CODA_FREE(req->uc_data, sizeof(struct coda_in_hdr));
        kfree(req);
out:
        unlock_kernel();
        return (count ? count : retval);
}
 
static int coda_psdev_open(struct inode * inode, struct file * file)
{
        struct venus_comm *vcp;
        int idx, err;
 
        idx = iminor(inode);
        if (idx < 0 || idx >= MAX_CODADEVS)
                return -ENODEV;
 
        lock_kernel();
 
        err = -EBUSY;
        vcp = &coda_comms[idx];
        if (!vcp->vc_inuse) {
                vcp->vc_inuse++;
 
                INIT_LIST_HEAD(&vcp->vc_pending);
                INIT_LIST_HEAD(&vcp->vc_processing);
                init_waitqueue_head(&vcp->vc_waitq);
                vcp->vc_sb = NULL;
                vcp->vc_seq = 0;
 
                file->private_data = vcp;
                err = 0;
        }
 
        unlock_kernel();
        return err;
}
 
 
static int coda_psdev_release(struct inode * inode, struct file * file)
{
        struct venus_comm *vcp = (struct venus_comm *) file->private_data;
        struct upc_req *req, *tmp;
 
        if (!vcp || !vcp->vc_inuse ) {
                printk("psdev_release: Not open.\n");
                return -1;
        }
 
        lock_kernel();
 
        /* Wakeup clients so they can return. */
        list_for_each_entry_safe(req, tmp, &vcp->vc_pending, uc_chain) {
                list_del(&req->uc_chain);
 
                /* Async requests need to be freed here */
                if (req->uc_flags & REQ_ASYNC) {
                        CODA_FREE(req->uc_data, sizeof(struct coda_in_hdr));
                        kfree(req);
                        continue;
                }
                req->uc_flags |= REQ_ABORT;
                wake_up(&req->uc_sleep);
        }
 
        list_for_each_entry_safe(req, tmp, &vcp->vc_processing, uc_chain) {
                list_del(&req->uc_chain);
 
                req->uc_flags |= REQ_ABORT;
                wake_up(&req->uc_sleep);
        }
 
        file->private_data = NULL;
        vcp->vc_inuse--;
        unlock_kernel();
        return 0;
}
 
 
static const struct file_operations coda_psdev_fops = {
        .owner          = THIS_MODULE,
        .read           = coda_psdev_read,
        .write          = coda_psdev_write,
        .poll           = coda_psdev_poll,
        .ioctl          = coda_psdev_ioctl,
        .open           = coda_psdev_open,
        .release        = coda_psdev_release,
};
 
static int init_coda_psdev(void)
{
        int i, err = 0;
        if (register_chrdev(CODA_PSDEV_MAJOR, "coda", &coda_psdev_fops)) {
              printk(KERN_ERR "coda_psdev: unable to get major %d\n",
                     CODA_PSDEV_MAJOR);
              return -EIO;
        }
        coda_psdev_class = class_create(THIS_MODULE, "coda");
        if (IS_ERR(coda_psdev_class)) {
                err = PTR_ERR(coda_psdev_class);
                goto out_chrdev;
        }
        for (i = 0; i < MAX_CODADEVS; i++)
                class_device_create(coda_psdev_class, NULL,
                                MKDEV(CODA_PSDEV_MAJOR,i), NULL, "cfs%d", i);
        coda_sysctl_init();
        goto out;
 
out_chrdev:
        unregister_chrdev(CODA_PSDEV_MAJOR, "coda");
out:
        return err;
}
 
MODULE_AUTHOR("Jan Harkes, Peter J. Braam");
MODULE_DESCRIPTION("Coda Distributed File System VFS interface");
MODULE_ALIAS_CHARDEV_MAJOR(CODA_PSDEV_MAJOR);
MODULE_LICENSE("GPL");
#ifdef CONFIG_CODA_FS_OLD_API
MODULE_VERSION("5.3.21");
#else
MODULE_VERSION("6.6");
#endif
 
static int __init init_coda(void)
{
        int status;
        int i;
 
        status = coda_init_inodecache();
        if (status)
                goto out2;
        status = init_coda_psdev();
        if ( status ) {
                printk("Problem (%d) in init_coda_psdev\n", status);
                goto out1;
        }
 
        status = register_filesystem(&coda_fs_type);
        if (status) {
                printk("coda: failed to register filesystem!\n");
                goto out;
        }
        return 0;
out:
        for (i = 0; i < MAX_CODADEVS; i++)
                class_device_destroy(coda_psdev_class, MKDEV(CODA_PSDEV_MAJOR, i));
        class_destroy(coda_psdev_class);
        unregister_chrdev(CODA_PSDEV_MAJOR, "coda");
        coda_sysctl_clean();
out1:
        coda_destroy_inodecache();
out2:
        return status;
}
 
static void __exit exit_coda(void)
{
        int err, i;
 
        err = unregister_filesystem(&coda_fs_type);
        if ( err != 0 ) {
                printk("coda: failed to unregister filesystem\n");
        }
        for (i = 0; i < MAX_CODADEVS; i++)
                class_device_destroy(coda_psdev_class, MKDEV(CODA_PSDEV_MAJOR, i));
        class_destroy(coda_psdev_class);
        unregister_chrdev(CODA_PSDEV_MAJOR, "coda");
        coda_sysctl_clean();
        coda_destroy_inodecache();
}
 
module_init(init_coda);
module_exit(exit_coda);
 

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [fs/] [coda/] [psdev.c] - Blame information for rev 3

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
2			`* An implementation of a loadable kernel mode driver providing`
3			`* multiple kernel/user space bidirectional communications links.`
4			`*`
5			`* Author: Alan Cox <alan@redhat.com>`
6			`*`
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.`
11			`*`
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>`
15			`*`
16			`* Changes for Linux 2.1`
17			`* Copyright (c) 1997 Carnegie-Mellon University`
18			`*/`
19
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/slab.h>`
26			`#include <linux/ioport.h>`
27			`#include <linux/fcntl.h>`
28			`#include <linux/delay.h>`
29			`#include <linux/skbuff.h>`
30			`#include <linux/proc_fs.h>`
31			`#include <linux/vmalloc.h>`
32			`#include <linux/fs.h>`
33			`#include <linux/file.h>`
34			`#include <linux/poll.h>`
35			`#include <linux/init.h>`
36			`#include <linux/list.h>`
37			`#include <linux/smp_lock.h>`
38			`#include <linux/device.h>`
39			`#include <asm/io.h>`
40			`#include <asm/system.h>`
41			`#include <asm/poll.h>`
42			`#include <asm/uaccess.h>`
43
44			`#include <linux/coda.h>`
45			`#include <linux/coda_linux.h>`
46			`#include <linux/coda_fs_i.h>`
47			`#include <linux/coda_psdev.h>`
48
49			`#include "coda_int.h"`
50
51			`/* statistics */`
52			`int coda_hard; /* allows signals during upcalls */`
53			`unsigned long coda_timeout = 30; /* .. secs, then signals will dequeue */`
54
55
56			`struct venus_comm coda_comms[MAX_CODADEVS];`
57			`static struct class *coda_psdev_class;`
58
59			`/*`
60			`* Device operations`
61			`*/`
62
63			`static unsigned int coda_psdev_poll(struct file file, poll_table wait)`
64			`{`
65			`struct venus_comm vcp = (struct venus_comm ) file->private_data;`
66			`unsigned int mask = POLLOUT \| POLLWRNORM;`
67
68			`poll_wait(file, &vcp->vc_waitq, wait);`
69			`if (!list_empty(&vcp->vc_pending))`
70			`mask \|= POLLIN \| POLLRDNORM;`
71
72			`return mask;`
73			`}`
74
75			`static int coda_psdev_ioctl(struct inode * inode, struct file * filp,`
76			`unsigned int cmd, unsigned long arg)`
77			`{`
78			`unsigned int data;`
79
80			`switch(cmd) {`
81			`case CIOC_KERNEL_VERSION:`
82			`data = CODA_KERNEL_VERSION;`
83			`return put_user(data, (int __user *) arg);`
84			`default:`
85			`return -ENOTTY;`
86			`}`
87
88			`return 0;`
89			`}`
90
91			`/*`
92			`* Receive a message written by Venus to the psdev`
93			`*/`
94
95			`static ssize_t coda_psdev_write(struct file file, const char __user buf,`
96			`size_t nbytes, loff_t *off)`
97			`{`
98			`struct venus_comm vcp = (struct venus_comm ) file->private_data;`
99			`struct upc_req *req = NULL;`
100			`struct upc_req *tmp;`
101			`struct list_head *lh;`
102			`struct coda_in_hdr hdr;`
103			`ssize_t retval = 0, count = 0;`
104			`int error;`
105
106			`/* Peek at the opcode, uniquefier */`
107			`if (copy_from_user(&hdr, buf, 2 * sizeof(u_long)))`
108			`return -EFAULT;`
109
110			`if (DOWNCALL(hdr.opcode)) {`
111			`struct super_block *sb = NULL;`
112			`union outputArgs *dcbuf;`
113			`int size = sizeof(*dcbuf);`
114
115			`sb = vcp->vc_sb;`
116			`if ( !sb ) {`
117			`count = nbytes;`
118			`goto out;`
119			`}`
120
121			`if ( nbytes < sizeof(struct coda_out_hdr) ) {`
122			`printk("coda_downcall opc %d uniq %d, not enough!\n",`
123			`hdr.opcode, hdr.unique);`
124			`count = nbytes;`
125			`goto out;`
126			`}`
127			`if ( nbytes > size ) {`
128			`printk("Coda: downcall opc %d, uniq %d, too much!",`
129			`hdr.opcode, hdr.unique);`
130			`nbytes = size;`
131			`}`
132			`CODA_ALLOC(dcbuf, union outputArgs *, nbytes);`
133			`if (copy_from_user(dcbuf, buf, nbytes)) {`
134			`CODA_FREE(dcbuf, nbytes);`
135			`retval = -EFAULT;`
136			`goto out;`
137			`}`
138
139			`/* what downcall errors does Venus handle ? */`
140			`lock_kernel();`
141			`error = coda_downcall(hdr.opcode, dcbuf, sb);`
142			`unlock_kernel();`
143
144			`CODA_FREE(dcbuf, nbytes);`
145			`if (error) {`
146			`printk("psdev_write: coda_downcall error: %d\n", error);`
147			`retval = error;`
148			`goto out;`
149			`}`
150			`count = nbytes;`
151			`goto out;`
152			`}`
153
154			`/* Look for the message on the processing queue. */`
155			`lock_kernel();`
156			`list_for_each(lh, &vcp->vc_processing) {`
157			`tmp = list_entry(lh, struct upc_req , uc_chain);`
158			`if (tmp->uc_unique == hdr.unique) {`
159			`req = tmp;`
160			`list_del(&req->uc_chain);`
161			`break;`
162			`}`
163			`}`
164			`unlock_kernel();`
165
166			`if (!req) {`
167			`printk("psdev_write: msg (%d, %d) not found\n",`
168			`hdr.opcode, hdr.unique);`
169			`retval = -ESRCH;`
170			`goto out;`
171			`}`
172
173			`/* move data into response buffer. */`
174			`if (req->uc_outSize < nbytes) {`
175			`printk("psdev_write: too much cnt: %d, cnt: %ld, opc: %d, uniq: %d.\n",`
176			`req->uc_outSize, (long)nbytes, hdr.opcode, hdr.unique);`
177			`nbytes = req->uc_outSize; /* don't have more space! */`
178			`}`
179			`if (copy_from_user(req->uc_data, buf, nbytes)) {`
180			`req->uc_flags \|= REQ_ABORT;`
181			`wake_up(&req->uc_sleep);`
182			`retval = -EFAULT;`
183			`goto out;`
184			`}`
185
186			`/* adjust outsize. is this useful ?? */`
187			`req->uc_outSize = nbytes;`
188			`req->uc_flags \|= REQ_WRITE;`
189			`count = nbytes;`
190
191			`/* Convert filedescriptor into a file handle */`
192			`if (req->uc_opcode == CODA_OPEN_BY_FD) {`
193			`struct coda_open_by_fd_out *outp =`
194			`(struct coda_open_by_fd_out *)req->uc_data;`
195			`if (!outp->oh.result)`
196			`outp->fh = fget(outp->fd);`
197			`}`
198
199			`wake_up(&req->uc_sleep);`
200			`out:`
201			`return(count ? count : retval);`
202			`}`
203
204			`/*`
205			`* Read a message from the kernel to Venus`
206			`*/`
207
208			`static ssize_t coda_psdev_read(struct file * file, char __user * buf,`
209			`size_t nbytes, loff_t *off)`
210			`{`
211			`DECLARE_WAITQUEUE(wait, current);`
212			`struct venus_comm vcp = (struct venus_comm ) file->private_data;`
213			`struct upc_req *req;`
214			`ssize_t retval = 0, count = 0;`
215
216			`if (nbytes == 0)`
217			`return 0;`
218
219			`lock_kernel();`
220
221			`add_wait_queue(&vcp->vc_waitq, &wait);`
222			`set_current_state(TASK_INTERRUPTIBLE);`
223
224			`while (list_empty(&vcp->vc_pending)) {`
225			`if (file->f_flags & O_NONBLOCK) {`
226			`retval = -EAGAIN;`
227			`break;`
228			`}`
229			`if (signal_pending(current)) {`
230			`retval = -ERESTARTSYS;`
231			`break;`
232			`}`
233			`schedule();`
234			`}`
235
236			`set_current_state(TASK_RUNNING);`
237			`remove_wait_queue(&vcp->vc_waitq, &wait);`
238
239			`if (retval)`
240			`goto out;`
241
242			`req = list_entry(vcp->vc_pending.next, struct upc_req,uc_chain);`
243			`list_del(&req->uc_chain);`
244
245			`/* Move the input args into userspace */`
246			`count = req->uc_inSize;`
247			`if (nbytes < req->uc_inSize) {`
248			`printk ("psdev_read: Venus read %ld bytes of %d in message\n",`
249			`(long)nbytes, req->uc_inSize);`
250			`count = nbytes;`
251			`}`
252
253			`if (copy_to_user(buf, req->uc_data, count))`
254			`retval = -EFAULT;`
255
256			`/* If request was not a signal, enqueue and don't free */`
257			`if (!(req->uc_flags & REQ_ASYNC)) {`
258			`req->uc_flags \|= REQ_READ;`
259			`list_add_tail(&(req->uc_chain), &vcp->vc_processing);`
260			`goto out;`
261			`}`
262
263			`CODA_FREE(req->uc_data, sizeof(struct coda_in_hdr));`
264			`kfree(req);`
265			`out:`
266			`unlock_kernel();`
267			`return (count ? count : retval);`
268			`}`
269
270			`static int coda_psdev_open(struct inode * inode, struct file * file)`
271			`{`
272			`struct venus_comm *vcp;`
273			`int idx, err;`
274
275			`idx = iminor(inode);`
276			`if (idx < 0 \|\| idx >= MAX_CODADEVS)`
277			`return -ENODEV;`
278
279			`lock_kernel();`
280
281			`err = -EBUSY;`
282			`vcp = &coda_comms[idx];`
283			`if (!vcp->vc_inuse) {`
284			`vcp->vc_inuse++;`
285
286			`INIT_LIST_HEAD(&vcp->vc_pending);`
287			`INIT_LIST_HEAD(&vcp->vc_processing);`
288			`init_waitqueue_head(&vcp->vc_waitq);`
289			`vcp->vc_sb = NULL;`
290			`vcp->vc_seq = 0;`
291
292			`file->private_data = vcp;`
293			`err = 0;`
294			`}`
295
296			`unlock_kernel();`
297			`return err;`
298			`}`
299
300
301			`static int coda_psdev_release(struct inode * inode, struct file * file)`
302			`{`
303			`struct venus_comm vcp = (struct venus_comm ) file->private_data;`
304			`struct upc_req req, tmp;`
305
306			`if (!vcp \|\| !vcp->vc_inuse ) {`
307			`printk("psdev_release: Not open.\n");`
308			`return -1;`
309			`}`
310
311			`lock_kernel();`
312
313			`/* Wakeup clients so they can return. */`
314			`list_for_each_entry_safe(req, tmp, &vcp->vc_pending, uc_chain) {`
315			`list_del(&req->uc_chain);`
316
317			`/* Async requests need to be freed here */`
318			`if (req->uc_flags & REQ_ASYNC) {`
319			`CODA_FREE(req->uc_data, sizeof(struct coda_in_hdr));`
320			`kfree(req);`
321			`continue;`
322			`}`
323			`req->uc_flags \|= REQ_ABORT;`
324			`wake_up(&req->uc_sleep);`
325			`}`
326
327			`list_for_each_entry_safe(req, tmp, &vcp->vc_processing, uc_chain) {`
328			`list_del(&req->uc_chain);`
329
330			`req->uc_flags \|= REQ_ABORT;`
331			`wake_up(&req->uc_sleep);`
332			`}`
333
334			`file->private_data = NULL;`
335			`vcp->vc_inuse--;`
336			`unlock_kernel();`
337			`return 0;`
338			`}`
339
340
341			`static const struct file_operations coda_psdev_fops = {`
342			`.owner = THIS_MODULE,`
343			`.read = coda_psdev_read,`
344			`.write = coda_psdev_write,`
345			`.poll = coda_psdev_poll,`
346			`.ioctl = coda_psdev_ioctl,`
347			`.open = coda_psdev_open,`
348			`.release = coda_psdev_release,`
349			`};`
350
351			`static int init_coda_psdev(void)`
352			`{`
353			`int i, err = 0;`
354			`if (register_chrdev(CODA_PSDEV_MAJOR, "coda", &coda_psdev_fops)) {`
355			`printk(KERN_ERR "coda_psdev: unable to get major %d\n",`
356			`CODA_PSDEV_MAJOR);`
357			`return -EIO;`
358			`}`
359			`coda_psdev_class = class_create(THIS_MODULE, "coda");`
360			`if (IS_ERR(coda_psdev_class)) {`
361			`err = PTR_ERR(coda_psdev_class);`
362			`goto out_chrdev;`
363			`}`
364			`for (i = 0; i < MAX_CODADEVS; i++)`
365			`class_device_create(coda_psdev_class, NULL,`
366			`MKDEV(CODA_PSDEV_MAJOR,i), NULL, "cfs%d", i);`
367			`coda_sysctl_init();`
368			`goto out;`
369
370			`out_chrdev:`
371			`unregister_chrdev(CODA_PSDEV_MAJOR, "coda");`
372			`out:`
373			`return err;`
374			`}`
375
376			`MODULE_AUTHOR("Jan Harkes, Peter J. Braam");`
377			`MODULE_DESCRIPTION("Coda Distributed File System VFS interface");`
378			`MODULE_ALIAS_CHARDEV_MAJOR(CODA_PSDEV_MAJOR);`
379			`MODULE_LICENSE("GPL");`
380			`#ifdef CONFIG_CODA_FS_OLD_API`
381			`MODULE_VERSION("5.3.21");`
382			`#else`
383			`MODULE_VERSION("6.6");`
384			`#endif`
385
386			`static int __init init_coda(void)`
387			`{`
388			`int status;`
389			`int i;`
390
391			`status = coda_init_inodecache();`
392			`if (status)`
393			`goto out2;`
394			`status = init_coda_psdev();`
395			`if ( status ) {`
396			`printk("Problem (%d) in init_coda_psdev\n", status);`
397			`goto out1;`
398			`}`
399
400			`status = register_filesystem(&coda_fs_type);`
401			`if (status) {`
402			`printk("coda: failed to register filesystem!\n");`
403			`goto out;`
404			`}`
405			`return 0;`
406			`out:`
407			`for (i = 0; i < MAX_CODADEVS; i++)`
408			`class_device_destroy(coda_psdev_class, MKDEV(CODA_PSDEV_MAJOR, i));`
409			`class_destroy(coda_psdev_class);`
410			`unregister_chrdev(CODA_PSDEV_MAJOR, "coda");`
411			`coda_sysctl_clean();`
412			`out1:`
413			`coda_destroy_inodecache();`
414			`out2:`
415			`return status;`
416			`}`
417
418			`static void __exit exit_coda(void)`
419			`{`
420			`int err, i;`
421
422			`err = unregister_filesystem(&coda_fs_type);`
423			`if ( err != 0 ) {`
424			`printk("coda: failed to unregister filesystem\n");`
425			`}`
426			`for (i = 0; i < MAX_CODADEVS; i++)`
427			`class_device_destroy(coda_psdev_class, MKDEV(CODA_PSDEV_MAJOR, i));`
428			`class_destroy(coda_psdev_class);`
429			`unregister_chrdev(CODA_PSDEV_MAJOR, "coda");`
430			`coda_sysctl_clean();`
431			`coda_destroy_inodecache();`
432			`}`
433
434			`module_init(init_coda);`
435			`module_exit(exit_coda);`
436