通过char设备模仿以太网接口//char read==eth send;char write == eth receive

Roemer

1. 
   
2. /*************************************************************************
   
3. 
   
4. Fake eth char convert
   
5. **************************************************************************/
   
6. 
   
7. #include <linux/kernel.h>
   
8. #include <linux/etherdevice.h>
   
9. #include <linux/netdevice.h>
   
10. #include <linux/moduleparam.h>
    
11. #include <linux/errno.h>
    
12. #include <linux/fcntl.h>
    
13. #include <linux/file.h>
    
14. #include <linux/proc_fs.h>
    
15. #include <linux/init.h>
    
16. #include <linux/module.h>
    
17. #include <linux/smp_lock.h>
    
18. #include <linux/device.h>
    
19. #include <linux/wait.h>
    
20. #include <linux/kmod.h>
    
21. #include <linux/cdev.h>
    
22. 
    
23. 
    
24. 
    
25. /*  MAC地址  */
    
26. 
    
27. static char vir_mac[]={0x00, 0xAA, 0xBB, 0xCC, 0xBB, 0xAA};
    
28. char *vir_mac_p = NULL;
    
29. int loop = 0;                       /* when loop=1, enable loopback mode,not write Yet :) */
    
30. 
    
31. //VIRMAC
    
32. module_param(vir_mac_p, charp, 0444);
    
33. MODULE_PARM_DESC(vir_mac_p, "MAC");
    
34. 
    
35. module_param(loop, int, 0);
    
36. MODULE_PARM_DESC(loop, "loopback mode");
    
37. 
    
38. 
    
39. 
    
40. #define ETH_BUFFER_LEN 1520
    
41. #define FAKE_IRQ       18
    
42. #define ETH_VIR_MAJOR  160
    
43. 
    
44. 
    
45. struct s_buff
    
46. {
    
47.   unsigned char buffer[ETH_BUFFER_LEN];
    
48.   unsigned int  length;
    
49. };
    
50. 
    
51. //buffer for Eth
    
52. static struct s_buff tx_buff;
    
53. static struct s_buff rx_buff;
    
54. 
    
55. 
    
56. struct vireth_priv
    
57. {
    
58. 
    
59.   struct net_device * netdev;      /* net device parameter */
    
60.   struct net_device_stats stats;   /* net statistics */
    
61.   struct sk_buff *skb;             /* free send skb*/
    
62.   struct proc_dir_entry *entry;   
    
63.   wait_queue_head_t inq;           /* send waitQ, for eth char read */
    
64.   struct semaphore sem;
    
65.   
    
66. };
    
67. 
    
68. static struct vireth_priv * dev_vireth = NULL;
    
69. 
    
70. 
    
71. 
    
72. 
    
73. 
    
74. #define  VIRETH_NAME        "vir_eth"        /* 网络设备的名字 */
    
75. 
    
76. 
    
77. static int vireth_open(struct net_device *dev);
    
78. static int vireth_release(struct net_device *dev);
    
79. static void vireth_init(struct net_device *dev);
    
80. static int vireth_xmit(struct sk_buff *skb, struct net_device *dev);
    
81. static int vireth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
    
82. static int transmit_int(int irq, void *dev_id);
    
83. static int receive_int(int irq, void *dev_id);
    
84. 
    
85. 
    
86. /************************* MII Proc interface **************************/
    
87. static int MII_read_proc(char *page, char **start, off_t off,
    
88.          int count, int *eof, void *data)
    
89. {
    
90.   #if 0
    
91.      int length;
    
92.      
    
93.      if (down_interruptible(&dev_vireth->sem))
    
94.      {
    
95.         return -ERESTARTSYS;
    
96.      }
    
97.      //
    
98.      while( 0 == tx_buff.length )
    
99.      {
    
100.          up(&dev_vireth->sem);
     
101.          //sleep
     
102.          if( wait_event_interruptible(dev_vireth->inq,(0 != tx_buff.length)) )
     
103.          {
     
104.            return -ERESTARTSYS;
     
105.          }
     
106.       
     
107.          if (down_interruptible(&dev_vireth->sem))
     
108.          {
     
109.            return -ERESTARTSYS;
     
110.          }
     
111.      }   
     
112.    
     
113.      memcpy(page,tx_buff.buffer,tx_buff.length );
     
114.      length = tx_buff.length;
     
115.      tx_buff.length = 0;
     
116.      
     
117.      up(&dev_vireth->sem);
     
118.      *eof = 1;
     
119.      
     
120.      transmit_int(FAKE_IRQ,dev_vireth);
     
121.      //printk("#### %d##\n",length);
     
122.    
     
123.       return length;
     
124.    #endif
     
125.    ////////////
     
126.    *eof = 1;
     
127.    return 0;
     
128. }
     
129. 
     
130. static int MII_write_proc(struct file *file, const char *buffer,
     
131.          unsigned long count, void *data)
     
132. {
     
133.   #if 0
     
134.   
     
135.     if(count > ETH_BUFFER_LEN)
     
136.     {
     
137.       printk("Error input len\n");
     
138.       return -1;
     
139.     }
     
140.    
     
141.     memcpy(rx_buff.buffer, buffer, count);
     
142.     rx_buff.length = count;
     
143.     receive_int(FAKE_IRQ,dev_vireth);
     
144.    
     
145.     return count;
     
146.   
     
147.   #endif
     
148.   ///////////////
     
149.   return 0;
     
150. }   
     
151. 
     
152. 
     
153. /************************* fake interrupt**************************/
     
154. 
     
155. static int receive_int(int irq, void *dev_id)
     
156. {
     
157.   struct sk_buff *skb;
     
158.   //struct vireth_priv *priv = netdev_priv(dev);
     
159. 
     
160.   /*
     
161.    * The packet has been retrieved from the transmission
     
162.    * medium. Build an skb around it, so upper layers can handle it
     
163.    */
     
164.   skb = dev_alloc_skb(rx_buff.length + 4);
     
165.   if (!skb)
     
166.   {
     
167.     if (printk_ratelimit())
     
168.     { printk(KERN_NOTICE "snull rx: low on mem - packet dropped\n");}
     
169.      dev_vireth->stats.rx_dropped++;
     
170.        goto out;
     
171.   }
     
172.   skb_reserve(skb, 2); /* align IP on 16B boundary */  
     
173.   
     
174.   memcpy(skb_put(skb, rx_buff.length), rx_buff.buffer, rx_buff.length);
     
175.   
     
176.   /* Write metadata, and then pass to the receive level */
     
177.   skb->protocol = eth_type_trans(skb, dev_vireth->netdev);
     
178.   //skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
     
179.   dev_vireth->stats.rx_packets++;
     
180.   dev_vireth->stats.rx_bytes += rx_buff.length;
     
181.   netif_rx(skb);
     
182. 
     
183. out:
     
184.   return 0;
     
185. }
     
186. 
     
187. 
     
188. //send finished
     
189.   static int transmit_int(int irq, void *dev_id)
     
190. {
     
191.      dev_kfree_skb(dev_vireth->skb);
     
192.      netif_wake_queue(dev_vireth->netdev);      
     
193.      return 0;
     
194. }
     
195. 
     
196. 
     
197. 
     
198. /*************************Eth  interface **************************/
     
199. static int vireth_open(struct net_device *dev)
     
200. {   
     
201.    /* 启动发送队列 */
     
202.   netif_start_queue(dev);
     
203.   return 0;
     
204. }
     
205. 
     
206. 
     
207. static int vireth_release(struct net_device *dev)
     
208. {    /* 停止发送队列 */
     
209.   netif_stop_queue(dev);  /* can't transmit any more */
     
210.   return 0;
     
211. }
     
212. 
     
213. 
     
214. //copy from skb to buffer
     
215. static int vireth_write_packet(struct sk_buff *skb, struct net_device *dev)
     
216. {
     
217.   //lock char read
     
218.    if(down_interruptible(&dev_vireth->sem))
     
219.    {
     
220.      return 1;
     
221.    }
     
222.    //still have pack int TX buffer
     
223.    if(tx_buff.length !=0 )
     
224.    {
     
225.      up(&dev_vireth->sem);
     
226.      return 1;
     
227.    }
     
228.    memcpy(tx_buff.buffer, skb->data, skb->len);  
     
229.    tx_buff.length = skb->len;
     
230. 
     
231.    up(&dev_vireth->sem);
     
232.    wake_up_interruptible(&dev_vireth->inq);
     
233.      
     
234.    return 0;
     
235. }
     
236. 
     
237. 
     
238. static int vireth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
     
239. {
     
240.   int rc = 0;
     
241. 
     
242.   switch (cmd)
     
243.   {
     
244.     default:
     
245.       rc = -ENOSYS;
     
246.       break;
     
247.   }
     
248. 
     
249.   return rc;
     
250. }
     
251. 
     
252. //call by up layer
     
253. static int vireth_xmit(struct sk_buff *skb, struct net_device *dev)
     
254. {
     
255.   struct vireth_priv * priv = (struct vireth_priv *)netdev_priv(dev);
     
256.   int rc;
     
257. 
     
258.   netif_stop_queue(dev);
     
259. 
     
260.   if (vireth_write_packet(skb, dev))
     
261.   {
     
262.     priv->stats.tx_dropped++;
     
263.     rc = 1;
     
264.   }
     
265.   else
     
266.   {
     
267.     priv->stats.tx_packets++;
     
268.     priv->stats.tx_bytes += skb->len;
     
269.         priv->skb = skb;
     
270.     dev->trans_start = jiffies;         /* save the timestamp */
     
271. 
     
272.     rc = 0;
     
273.   }
     
274. 
     
275.   return rc;
     
276. }
     
277. 
     
278. 
     
279. static struct net_device_stats *vireth_get_stats(struct net_device *dev)
     
280. {
     
281.    struct vireth_priv * priv = (struct vireth_priv *)netdev_priv(dev);
     
282. 
     
283.    return &(priv->stats);
     
284. }
     
285. 
     
286. /* fake multicast ability */
     
287. static void set_multicast_list(struct net_device *dev)
     
288. {
     
289.   return;
     
290. }
     
291. 
     
292. static int set_mac_address(struct net_device *dev, void* addr)
     
293. {
     
294.   struct sockaddr *address = addr;
     
295. 
     
296.   if (!is_valid_ether_addr(address->sa_data))
     
297.   {
     
298.     return -EADDRNOTAVAIL;
     
299.   }
     
300. 
     
301.   memcpy(dev->dev_addr, address->sa_data, dev->addr_len);
     
302.   printk("%s: Setting MAC address to %pM\n", dev->name,  dev->dev_addr);
     
303. 
     
304.   return 0;
     
305. }
     
306. 
     
307. 
     
308. 
     
309. static const struct net_device_ops vireth_netdev_ops = {
     
310.   .ndo_open               = vireth_open,
     
311.   .ndo_stop               = vireth_release,
     
312.   .ndo_do_ioctl           = vireth_ioctl,
     
313.   .ndo_get_stats          = vireth_get_stats,
     
314.   .ndo_start_xmit         = vireth_xmit,
     
315.   .ndo_set_multicast_list = set_multicast_list,
     
316.   .ndo_set_mac_address  = set_mac_address,
     
317. };
     
318. 
     
319. /************************char dev ************************/
     
320. 
     
321. static struct cdev vireth_cdev;
     
322. 
     
323. static int vireth_char_open(struct inode * inode, struct file * filp)
     
324. {
     
325.   return 0;
     
326. }
     
327. 
     
328. 
     
329. static int vireth_char_release(struct inode * inode, struct file * filp)
     
330. {
     
331.   return 0;
     
332. }
     
333. 
     
334. static int vireth_char_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
     
335. {
     
336.     switch(cmd)
     
337.     {
     
338.        default:
     
339.            return -EINVAL;
     
340.     }
     
341.    
     
342.     return 0;
     
343. }
     
344. 
     
345. //eth out put packet
     
346. static ssize_t vireth_char_read(struct file * file, char __user * buf, size_t count, loff_t *ppos)
     
347. {
     
348.     int length;
     
349.     unsigned long ret;
     
350.      
     
351.      if (down_interruptible(&dev_vireth->sem))
     
352.      {
     
353.         return -ERESTARTSYS;
     
354.      }
     
355.      //
     
356.      while( 0 == tx_buff.length )
     
357.      {
     
358.          up(&dev_vireth->sem);
     
359.          //sleep
     
360.          if( wait_event_interruptible(dev_vireth->inq,(0 != tx_buff.length)) )
     
361.          {
     
362.            return -ERESTARTSYS;
     
363.          }
     
364.       
     
365.          if (down_interruptible(&dev_vireth->sem))
     
366.          {
     
367.            return -ERESTARTSYS;
     
368.          }
     
369.      }   
     
370.    
     
371.      ret = copy_to_user(buf,tx_buff.buffer,tx_buff.length );
     
372.      length = tx_buff.length;
     
373.      tx_buff.length = 0;
     
374.      
     
375.      up(&dev_vireth->sem);   
     
376.      
     
377.      transmit_int(FAKE_IRQ,dev_vireth);
     
378.      //printk("#### %d##\n",length);
     
379.    
     
380.      return length;
     
381.   
     
382. }
     
383. 
     
384. static ssize_t vireth_char_write(struct file * file, const char __user * buf, size_t count,
     
385.        loff_t *ppos)
     
386. {
     
387.     unsigned long ret;
     
388.     if(count > ETH_BUFFER_LEN)
     
389.     {
     
390.        printk("Error input len\n");
     
391.        return -1;
     
392.     }
     
393.    
     
394.     ret = copy_from_user(rx_buff.buffer, buf, count);
     
395.     rx_buff.length = count;
     
396.     receive_int(FAKE_IRQ,dev_vireth);
     
397.    
     
398.     return count;
     
399. }
     
400. 
     
401. 
     
402. static struct file_operations vireth_char_fops = {
     
403.   .llseek     = NULL,
     
404.   .read       = vireth_char_read,
     
405.   .write      = vireth_char_write,
     
406.   .ioctl      = vireth_char_ioctl,
     
407.   .open       = vireth_char_open,
     
408.   .release    = vireth_char_release,
     
409.   .fasync     = NULL,
     
410. };
     
411. 
     
412. 
     
413. static int __init vireth_char_init(void)
     
414. {
     
415.     int ret;
     
416.     int devno = MKDEV(ETH_VIR_MAJOR,0);
     
417.    
     
418.     printk("Vireth version:%s %s\n",__DATE__,__TIME__);
     
419.             
     
420.     cdev_init(&vireth_cdev, &vireth_char_fops);
     
421.     vireth_cdev.owner = THIS_MODULE;
     
422.     ret = cdev_add(&vireth_cdev, devno, 1);
     
423.     if(ret)
     
424.     {        
     
425.        return ret;  
     
426.     }
     
427.    
     
428.     return 0;
     
429. }
     
430. 
     
431. static void __exit vireth_char_exit(void)
     
432. {
     
433.     cdev_del(&vireth_cdev);
     
434. }
     
435. 
     
436. /*************************eth  init **************************/
     
437. 
     
438. static void vireth_init(struct net_device *dev)
     
439. {
     
440.   struct vireth_priv * priv = NULL;
     
441. 
     
442.   ether_setup(dev);
     
443.   dev->netdev_ops  = &vireth_netdev_ops;
     
444. 
     
445.   dev->watchdog_timeo = 3*HZ;   
     
446.   dev->irq = FAKE_IRQ;//no use
     
447.   
     
448.   memcpy(dev->dev_addr, vir_mac, ETH_ALEN);
     
449. 
     
450.   priv = (struct vireth_priv *)netdev_priv(dev);
     
451.   dev_vireth = priv;
     
452.   
     
453.   priv->netdev = dev;
     
454. 
     
455. }
     
456. 
     
457. inline char ascTochar(char s)
     
458. {
     
459.          if( ('0'<= s) && ( s<='9') )
     
460.          {
     
461.                    return (s-'0');
     
462.          }
     
463.          
     
464.          else if( ('a'<= s) && (s<='f') )
     
465.          {
     
466.                    return (s-'a'+10);
     
467.          }
     
468.          else if( ('A'<= s) && (s<='F') )
     
469.          {
     
470.                    return (s-'A'+10);
     
471.          }
     
472.          else
     
473.          {
     
474.                   return 0;
     
475.          }
     
476.          
     
477. }
     
478. 
     
479. static int __init vireth_init_module(void)
     
480. {
     
481.   int rc = 0;
     
482.   int i;
     
483.   
     
484.   struct net_device  *net_dev = NULL;
     
485.   
     
486.   printk("Input MAC:%s\n",vir_mac_p);
     
487.   if(vir_mac_p)
     
488.   {
     
489.           for(i=0;i<6;i++)
     
490.           {
     
491.                    vir_mac[i] = ascTochar( *(vir_mac_p+i*2) )<<4;
     
492.                    vir_mac[i] |=ascTochar( *(vir_mac_p+i*2+1) );
     
493.           }
     
494.   }
     
495.   //
     
496.   printk("active MAC: ");
     
497.   for(i=0;i<6;i++)
     
498.   {
     
499.           printk("%02X:",vir_mac[i]);
     
500.   }
     
501.   printk("\n");
     
502.   
     
503.   /* alloc net dev */
     
504.   net_dev = alloc_netdev(sizeof(struct vireth_priv), VIRETH_NAME, vireth_init);
     
505.   if (!net_dev)
     
506.   {
     
507.     //log(KERN_ERR "no enough memory!\n");
     
508.     rc = -1;
     
509.     goto ERROR0;
     
510.   }
     
511. 
     
512.   /* got a name for eth*/
     
513.   rc = dev_alloc_name(net_dev, VIRETH_NAME);
     
514.   if (rc < 0)
     
515.     {
     
516.     //log(KERN_INFO "failed to alloc device name %s\n", VIRETH_NAME);
     
517.     goto ERROR0;
     
518.   }
     
519. 
     
520.   rc = register_netdev(net_dev);
     
521.   if (rc < 0)
     
522.   {
     
523.     goto ERROR0;
     
524.   }
     
525.   
     
526. 
     
527.   dev_vireth->entry = create_proc_entry("VIR_ETH_MII_DATA", 0, NULL);
     
528.   if (dev_vireth->entry == NULL)
     
529.     {
     
530.       return -ENOMEM;
     
531.     }
     
532.   dev_vireth->entry->read_proc = MII_read_proc;
     
533.   dev_vireth->entry->write_proc = MII_write_proc;
     
534.   dev_vireth->entry->data = NULL;
     
535.   
     
536.   init_waitqueue_head(&dev_vireth->inq);
     
537.   init_MUTEX(&dev_vireth->sem);
     
538.   
     
539.   vireth_char_init();
     
540. 
     
541.   return rc;
     
542. 
     
543. ERROR0:
     
544.   
     
545.   free_netdev(net_dev);
     
546.   return rc;
     
547. }
     
548. 
     
549. 
     
550. static void __exit vireth_cleanup_module(void)
     
551. {
     
552.     unregister_netdev(dev_vireth->netdev);
     
553.     remove_proc_entry("VIR_ETH_MII_DATA", NULL);
     
554.     free_netdev(dev_vireth->netdev);
     
555.     vireth_char_exit();  
     
556. }
     
557. 
     
558. module_init(vireth_init_module);
     
559. module_exit(vireth_cleanup_module);
     
560. 
     
561. MODULE_AUTHOR("roemer");
     
562. MODULE_DESCRIPTION("virtual ETH driver");
     
563. MODULE_LICENSE("GPL");
     

复制代码