开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
psdev.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：11k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

psdev.c：源码内容
  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@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.  */
  20. #include <linux/module.h>
  21. #include <linux/errno.h>
  22. #include <linux/kernel.h>
  23. #include <linux/major.h>
  24. #include <linux/sched.h>
  25. #include <linux/lp.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/devfs_fs_kernel.h>
  33. #include <linux/vmalloc.h>
  34. #include <linux/fs.h>
  35. #include <linux/file.h>
  36. #include <linux/poll.h>
  37. #include <linux/init.h>
  38. #include <linux/list.h>
  39. #include <linux/smp_lock.h>
  40. #include <asm/io.h>
  41. #include <asm/segment.h>
  42. #include <asm/system.h>
  43. #include <asm/poll.h>
  44. #include <asm/uaccess.h>
  46. #include <linux/coda.h>
  47. #include <linux/coda_linux.h>
  48. #include <linux/coda_fs_i.h>
  49. #include <linux/coda_psdev.h>
  50. #include <linux/coda_proc.h>
  52. #define upc_free(r) kfree(r)
  54. /* 
  55.  * Coda stuff
  56.  */
  57. extern struct file_system_type coda_fs_type;
  59. /* statistics */
  60. int           coda_hard;         /* allows signals during upcalls */
  61. unsigned long coda_timeout = 30; /* .. secs, then signals will dequeue */
  64. struct venus_comm coda_comms[MAX_CODADEVS];
  65. kmem_cache_t *cii_cache, *cred_cache, *upc_cache;
  67. /*
  68.  * Device operations
  69.  */
  71. static unsigned int coda_psdev_poll(struct file *file, poll_table * wait)
  72. {
  73.         struct venus_comm *vcp = (struct venus_comm *) file->private_data;
  74. unsigned int mask = POLLOUT | POLLWRNORM;
  76. poll_wait(file, &vcp->vc_waitq, wait);
  77. if (!list_empty(&vcp->vc_pending))
  78.                 mask |= POLLIN | POLLRDNORM;
  80. return mask;
  81. }
  83. static int coda_psdev_ioctl(struct inode * inode, struct file * filp, 
  84.     unsigned int cmd, unsigned long arg)
  85. {
  86. unsigned int data;
  88. switch(cmd) {
  89. case CIOC_KERNEL_VERSION:
  90. data = CODA_KERNEL_VERSION;
  91. return put_user(data, (int *) arg);
  92. default:
  93. return -ENOTTY;
  94. }
  96. return 0;
  97. }
  99. /*
  100.  * Receive a message written by Venus to the psdev
  101.  */
  102.  
  103. static ssize_t coda_psdev_write(struct file *file, const char *buf, 
  104. size_t nbytes, loff_t *off)
  105. {
  106.         struct venus_comm *vcp = (struct venus_comm *) file->private_data;
  107.         struct upc_req *req = NULL;
  108.         struct upc_req *tmp;
  109. struct list_head *lh;
  110. struct coda_in_hdr hdr;
  111. ssize_t retval = 0, count = 0;
  112. int error;
  114.         /* Peek at the opcode, uniquefier */
  115. if (copy_from_user(&hdr, buf, 2 * sizeof(u_long)))
  116.         return -EFAULT;
  118. CDEBUG(D_PSDEV, "(process,opc,uniq)=(%d,%ld,%ld), nbytes %ldn", 
  119.        current->pid, hdr.opcode, hdr.unique, (long)nbytes);
  121.         if (DOWNCALL(hdr.opcode)) {
  122. struct super_block *sb = NULL;
  123.                 union outputArgs *dcbuf;
  124. int size = sizeof(*dcbuf);
  126. sb = vcp->vc_sb;
  127. if ( !sb ) {
  128. CDEBUG(D_PSDEV, "coda_psdev_write: downcall, no SB!n");
  129.                         count = nbytes;
  130.                         goto out;
  131. }
  132. CDEBUG(D_PSDEV, "handling downcalln");
  134. if  ( nbytes < sizeof(struct coda_out_hdr) ) {
  135.         printk("coda_downcall opc %ld uniq %ld, not enough!n",
  136.        hdr.opcode, hdr.unique);
  137. count = nbytes;
  138. goto out;
  139. }
  140. if ( nbytes > size ) {
  141.         printk("Coda: downcall opc %ld, uniq %ld, too much!",
  142.        hdr.opcode, hdr.unique);
  143.         nbytes = size;
  144. }
  145. CODA_ALLOC(dcbuf, union outputArgs *, nbytes);
  146. if (copy_from_user(dcbuf, buf, nbytes)) {
  147. CODA_FREE(dcbuf, nbytes);
  148. retval = -EFAULT;
  149. goto out;
  150. }
  152. /* what downcall errors does Venus handle ? */
  153. lock_kernel();
  154. error = coda_downcall(hdr.opcode, dcbuf, sb);
  155. unlock_kernel();
  157. CODA_FREE(dcbuf, nbytes);
  158. if (error) {
  159.         printk("psdev_write: coda_downcall error: %dn", error);
  160. retval = error;
  161. goto out;
  162. }
  163. count = nbytes;
  164. goto out;
  165. }
  166.         
  167. /* Look for the message on the processing queue. */
  168. lock_kernel();
  169. list_for_each(lh, &vcp->vc_processing) {
  170. tmp = list_entry(lh, struct upc_req , uc_chain);
  171. if (tmp->uc_unique == hdr.unique) {
  172. req = tmp;
  173. list_del(&req->uc_chain);
  174. break;
  175. }
  176. }
  177. unlock_kernel();
  179. if (!req) {
  180. printk("psdev_write: msg (%ld, %ld) not foundn", 
  181. hdr.opcode, hdr.unique);
  182. retval = -ESRCH;
  183. goto out;
  184. }
  186. CDEBUG(D_PSDEV,"Eureka: uniq %ld on queue!n", hdr.unique);
  188.         /* move data into response buffer. */
  189. if (req->uc_outSize < nbytes) {
  190.                 printk("psdev_write: too much cnt: %d, cnt: %ld, opc: %ld, uniq: %ld.n",
  191.        req->uc_outSize, (long)nbytes, hdr.opcode, hdr.unique);
  192. nbytes = req->uc_outSize; /* don't have more space! */
  193. }
  194.         if (copy_from_user(req->uc_data, buf, nbytes)) {
  195. req->uc_flags |= REQ_ABORT;
  196. wake_up(&req->uc_sleep);
  197. retval = -EFAULT;
  198. goto out;
  199. }
  201. /* adjust outsize. is this useful ?? */
  202.         req->uc_outSize = nbytes;
  203.         req->uc_flags |= REQ_WRITE;
  204. count = nbytes;
  206. /* Convert filedescriptor into a file handle */
  207. if (req->uc_opcode == CODA_OPEN_BY_FD) {
  208. struct coda_open_by_fd_out *outp =
  209. (struct coda_open_by_fd_out *)req->uc_data;
  210. outp->fh = fget(outp->fd);
  211. }
  213. CDEBUG(D_PSDEV, 
  214.        "Found! Count %ld for (opc,uniq)=(%ld,%ld), upc_req at %pn", 
  215.         (long)count, hdr.opcode, hdr.unique, &req);
  217.         wake_up(&req->uc_sleep);
  218. out:
  219.         return(count ? count : retval);  
  220. }
  222. /*
  223.  * Read a message from the kernel to Venus
  224.  */
  226. static ssize_t coda_psdev_read(struct file * file, char * buf, 
  227.        size_t nbytes, loff_t *off)
  228. {
  229. DECLARE_WAITQUEUE(wait, current);
  230.         struct venus_comm *vcp = (struct venus_comm *) file->private_data;
  231.         struct upc_req *req;
  232. ssize_t retval = 0, count = 0;
  234. if (nbytes == 0)
  235. return 0;
  237. lock_kernel();
  239. add_wait_queue(&vcp->vc_waitq, &wait);
  240. set_current_state(TASK_INTERRUPTIBLE);
  242. while (list_empty(&vcp->vc_pending)) {
  243. if (file->f_flags & O_NONBLOCK) {
  244. retval = -EAGAIN;
  245. break;
  246. }
  247. if (signal_pending(current)) {
  248. retval = -ERESTARTSYS;
  249. break;
  250. }
  251. schedule();
  252. }
  254. set_current_state(TASK_RUNNING);
  255. remove_wait_queue(&vcp->vc_waitq, &wait);
  257. if (retval)
  258. goto out;
  260. req = list_entry(vcp->vc_pending.next, struct upc_req,uc_chain);
  261. list_del(&req->uc_chain);
  263. /* Move the input args into userspace */
  264. count = req->uc_inSize;
  265. if (nbytes < req->uc_inSize) {
  266.                 printk ("psdev_read: Venus read %ld bytes of %d in messagen",
  267. (long)nbytes, req->uc_inSize);
  268. count = nbytes;
  269.         }
  271. if (copy_to_user(buf, req->uc_data, count))
  272.         retval = -EFAULT;
  273.         
  274. /* If request was not a signal, enqueue and don't free */
  275. if (!(req->uc_flags & REQ_ASYNC)) {
  276. req->uc_flags |= REQ_READ;
  277. list_add(&(req->uc_chain), vcp->vc_processing.prev);
  278. goto out;
  279. }
  281. CDEBUG(D_PSDEV, "vcread: signal msg (%d, %d)n", 
  282. req->uc_opcode, req->uc_unique);
  284. CODA_FREE(req->uc_data, sizeof(struct coda_in_hdr));
  285. upc_free(req);
  286. out:
  287. unlock_kernel();
  288. return (count ? count : retval);
  289. }
  291. static int coda_psdev_open(struct inode * inode, struct file * file)
  292. {
  293.         struct venus_comm *vcp;
  294. int idx;
  296. lock_kernel();
  297. idx = MINOR(inode->i_rdev);
  298. if(idx >= MAX_CODADEVS) {
  299. unlock_kernel();
  300. return -ENODEV;
  301. }
  303. vcp = &coda_comms[idx];
  304. if(vcp->vc_inuse) {
  305. unlock_kernel();
  306. return -EBUSY;
  307. }
  309. if (!vcp->vc_inuse++) {
  310. INIT_LIST_HEAD(&vcp->vc_pending);
  311. INIT_LIST_HEAD(&vcp->vc_processing);
  312. init_waitqueue_head(&vcp->vc_waitq);
  313. vcp->vc_sb = 0;
  314. vcp->vc_seq = 0;
  315. }
  317. file->private_data = vcp;
  319. CDEBUG(D_PSDEV, "device %i - inuse: %dn", idx, vcp->vc_inuse);
  321. unlock_kernel();
  322.         return 0;
  323. }
  326. static int coda_psdev_release(struct inode * inode, struct file * file)
  327. {
  328.         struct venus_comm *vcp = (struct venus_comm *) file->private_data;
  329.         struct upc_req *req;
  330. struct list_head *lh, *next;
  332. lock_kernel();
  333. if ( !vcp->vc_inuse ) {
  334. unlock_kernel();
  335. printk("psdev_release: Not open.n");
  336. return -1;
  337. }
  339. CDEBUG(D_PSDEV, "psdev_release: inuse %dn", vcp->vc_inuse);
  340. if (--vcp->vc_inuse) {
  341. unlock_kernel();
  342. return 0;
  343. }
  344.         
  345.         /* Wakeup clients so they can return. */
  346. CDEBUG(D_PSDEV, "wake up pending clientsn");
  347. lh = vcp->vc_pending.next;
  348. next = lh;
  349. while ( (lh = next) != &vcp->vc_pending) {
  350. next = lh->next;
  351. req = list_entry(lh, struct upc_req, uc_chain);
  352. /* Async requests need to be freed here */
  353. if (req->uc_flags & REQ_ASYNC) {
  354. CODA_FREE(req->uc_data, sizeof(struct coda_in_hdr));
  355. upc_free(req);
  356. continue;
  357. }
  358. req->uc_flags |= REQ_ABORT;
  359. wake_up(&req->uc_sleep);
  360.         }
  361.         
  362. lh = &vcp->vc_processing;
  363. CDEBUG(D_PSDEV, "wake up processing clientsn");
  364. while ( (lh = lh->next) != &vcp->vc_processing) {
  365. req = list_entry(lh, struct upc_req, uc_chain);
  366. req->uc_flags |= REQ_ABORT;
  367.         wake_up(&req->uc_sleep);
  368.         }
  369. CDEBUG(D_PSDEV, "Done.n");
  371. unlock_kernel();
  372. return 0;
  373. }
  376. static struct file_operations coda_psdev_fops = {
  377. owner: THIS_MODULE,
  378. read: coda_psdev_read,
  379. write: coda_psdev_write,
  380. poll: coda_psdev_poll,
  381. ioctl: coda_psdev_ioctl,
  382. open: coda_psdev_open,
  383. release: coda_psdev_release,
  384. };
  386. static devfs_handle_t devfs_handle;
  388. static int init_coda_psdev(void)
  389. {
  390. if(devfs_register_chrdev(CODA_PSDEV_MAJOR,"coda_psdev",
  391.  &coda_psdev_fops)) {
  392.               printk(KERN_ERR "coda_psdev: unable to get major %dn", 
  393.      CODA_PSDEV_MAJOR);
  394.               return -EIO;
  395. }
  396. devfs_handle = devfs_mk_dir (NULL, "coda", NULL);
  397. devfs_register_series (devfs_handle, "%u", MAX_CODADEVS, DEVFS_FL_NONE,
  398.        CODA_PSDEV_MAJOR, 0,
  399.        S_IFCHR | S_IRUSR | S_IWUSR,
  400.        &coda_psdev_fops, NULL);
  402. coda_sysctl_init();
  404. return 0;
  405. }
  408. MODULE_AUTHOR("Peter J. Braam <braam@cs.cmu.edu>");
  409. MODULE_LICENSE("GPL");
  411. static int __init init_coda(void)
  412. {
  413. int status;
  414. printk(KERN_INFO "Coda Kernel/Venus communications, v5.3.18, coda@cs.cmu.edun");
  416. status = init_coda_psdev();
  417. if ( status ) {
  418. printk("Problem (%d) in init_coda_psdevn", status);
  419. return status;
  420. }
  422. status = register_filesystem(&coda_fs_type);
  423. if (status) {
  424. printk("coda: failed to register filesystem!n");
  425. devfs_unregister(devfs_handle);
  426. devfs_unregister_chrdev(CODA_PSDEV_MAJOR,"coda_psdev");
  427. coda_sysctl_clean();
  428. }
  429. return status;
  430. }
  432. static void __exit exit_coda(void)
  433. {
  434.         int err;
  436. err = unregister_filesystem(&coda_fs_type);
  437.         if ( err != 0 ) {
  438.                 printk("coda: failed to unregister filesystemn");
  439.         }
  440. devfs_unregister(devfs_handle);
  441. devfs_unregister_chrdev(CODA_PSDEV_MAJOR, "coda_psdev");
  442. coda_sysctl_clean();
  443. }
  445. module_init(init_coda);
  446. module_exit(exit_coda);