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