虚拟网卡驱动snull中的MAC地址问题！！！

ai_bj

在http://www.cs.fsu.edu/找的snull.c想做一个虚拟网卡。然后做成内核模块的方式。内核版本是2.6.27.5
这个是源码：
snull.c

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/init.h>
   
4. #include <linux/moduleparam.h>
   
5. 
   
6. #include <linux/sched.h>
   
7. #include <linux/kernel.h> /* printk() */
   
8. #include <linux/slab.h> /* kmalloc() */
   
9. #include <linux/errno.h>  /* error codes */
   
10. #include <linux/types.h>  /* size_t */
    
11. #include <linux/interrupt.h> /* mark_bh */
    
12. 
    
13. #include <linux/in.h>
    
14. #include <linux/netdevice.h>   /* struct device, and other headers */
    
15. #include <linux/etherdevice.h> /* eth_type_trans */
    
16. #include <linux/ip.h>          /* struct iphdr */
    
17. #include <linux/tcp.h>         /* struct tcphdr */
    
18. #include <linux/skbuff.h>
    
19. 
    
20. #include "snull.h"
    
21. 
    
22. #include <linux/in6.h>
    
23. #include <asm/checksum.h>
    
24. 
    
25. MODULE_AUTHOR("Alessandro Rubini, Jonathan Corbet");
    
26. MODULE_LICENSE("Dual BSD/GPL");
    
27. 
    
28. static int lockup = 0;
    
29. module_param(lockup, int, 0);
    
30. 
    
31. //static int timeout = SNULL_TIMEOUT;
    
32. static int timeout = 10;
    
33. module_param(timeout, int, 0);
    
34. 
    
35. 
    
36. static int use_napi = 0;
    
37. module_param(use_napi, int, 0);
    
38. 
    
39. 
    
40. struct net_device *snull_devs[2];
    
41. 
    
42. struct snull_packet {
    
43.         struct snull_packet *next;
    
44.         struct net_device *dev;
    
45.         int     datalen;
    
46.         u8 data[ETH_DATA_LEN];
    
47. };
    
48. 
    
49. int pool_size = 8;
    
50. module_param(pool_size, int, 0);
    
51. 
    
52. 
    
53. struct snull_priv {
    
54.         struct net_device_stats stats;
    
55.         int status;
    
56.         struct snull_packet *ppool;
    
57.         struct snull_packet *rx_queue;  /* List of incoming packets */
    
58.         int rx_int_enabled;
    
59.         int tx_packetlen;
    
60.         u8 *tx_packetdata;
    
61.         struct sk_buff *skb;
    
62.         spinlock_t lock;
    
63.         struct net_device *dev;
    
64.         struct napi_struct napi;
    
65. };
    
66. 
    
67. static void snull_tx_timeout(struct net_device *dev);
    
68. static void (*snull_interrupt)(int, void *, struct pt_regs *);
    
69. 
    
70. void snull_setup_pool(struct net_device *dev)
    
71. {
    
72.         struct snull_priv *priv = netdev_priv(dev);
    
73.         int i;
    
74.         struct snull_packet *pkt;
    
75. 
    
76.         priv->ppool = NULL;
    
77.         for (i = 0; i < pool_size; i++) {
    
78.                 pkt = kmalloc (sizeof (struct snull_packet), GFP_KERNEL);
    
79.                 if (pkt == NULL) {
    
80.                         printk (KERN_NOTICE "Ran out of memory allocating packet pool\n");
    
81.                         return;
    
82.                 }
    
83.                 pkt->dev = dev;
    
84.                 pkt->next = priv->ppool;
    
85.                 priv->ppool = pkt;
    
86.         }
    
87. }
    
88. 
    
89. void snull_teardown_pool(struct net_device *dev)
    
90. {
    
91.         struct snull_priv *priv = netdev_priv(dev);
    
92.         struct snull_packet *pkt;
    
93.    
    
94.         while ((pkt = priv->ppool)) {
    
95.                 priv->ppool = pkt->next;
    
96.                 kfree (pkt);
    
97.                 /* FIXME - in-flight packets ? */
    
98.         }
    
99. }   
    
100. 
     
101. 
     
102. struct snull_packet *snull_get_tx_buffer(struct net_device *dev)
     
103. {
     
104.         struct snull_priv *priv = netdev_priv(dev);
     
105.         unsigned long flags;
     
106.         struct snull_packet *pkt;
     
107.    
     
108.         spin_lock_irqsave(&priv->lock, flags);
     
109.         pkt = priv->ppool;
     
110.         priv->ppool = pkt->next;
     
111.         if (priv->ppool == NULL) {
     
112.                 printk (KERN_INFO "Pool empty\n");
     
113.                 netif_stop_queue(dev);
     
114.         }
     
115.         spin_unlock_irqrestore(&priv->lock, flags);
     
116.         return pkt;
     
117. }
     
118. 
     
119. 
     
120. void snull_release_buffer(struct snull_packet *pkt)
     
121. {
     
122.         unsigned long flags;
     
123.         struct snull_priv *priv = netdev_priv(pkt->dev);
     
124.         
     
125.         spin_lock_irqsave(&priv->lock, flags);
     
126.         pkt->next = priv->ppool;
     
127.         priv->ppool = pkt;
     
128.         spin_unlock_irqrestore(&priv->lock, flags);
     
129.         if (netif_queue_stopped(pkt->dev) && pkt->next == NULL)
     
130.                 netif_wake_queue(pkt->dev);
     
131. }
     
132. 
     
133. void snull_enqueue_buf(struct net_device *dev, struct snull_packet *pkt)
     
134. {
     
135.         unsigned long flags;
     
136.         struct snull_priv *priv = netdev_priv(dev);
     
137. 
     
138.         spin_lock_irqsave(&priv->lock, flags);
     
139.         pkt->next = priv->rx_queue;  /* FIXME - misorders packets */
     
140.         priv->rx_queue = pkt;
     
141.         spin_unlock_irqrestore(&priv->lock, flags);
     
142. }
     
143. 
     
144. struct snull_packet *snull_dequeue_buf(struct net_device *dev)
     
145. {
     
146.         struct snull_priv *priv = netdev_priv(dev);
     
147.         struct snull_packet *pkt;
     
148.         unsigned long flags;
     
149. 
     
150.         spin_lock_irqsave(&priv->lock, flags);
     
151.         pkt = priv->rx_queue;
     
152.         if (pkt != NULL)
     
153.                 priv->rx_queue = pkt->next;
     
154.         spin_unlock_irqrestore(&priv->lock, flags);
     
155.         return pkt;
     
156. }
     
157. 
     
158. 
     
159. static void snull_rx_ints(struct net_device *dev, int enable)
     
160. {
     
161.         struct snull_priv *priv = netdev_priv(dev);
     
162.         priv->rx_int_enabled = enable;
     
163. }
     
164. 
     
165. 
     
166. int snull_open(struct net_device *dev)
     
167. {
     
168.         memcpy(dev->dev_addr, "\0SNUL0", ETH_ALEN);
     
169.         if (dev == snull_devs[1])
     
170.                 dev->dev_addr[ETH_ALEN-1]++; /* \0SNUL1 */
     
171.         netif_start_queue(dev);
     
172.         return 0;
     
173. }
     
174. 
     
175. int snull_release(struct net_device *dev)
     
176. {
     
177.     /* release ports, irq and such -- like fops->close */
     
178. 
     
179.         netif_stop_queue(dev); /* can't transmit any more */
     
180.         return 0;
     
181. }
     
182. 
     
183. int snull_set_mac_address(struct net_device *dev,void *p)
     
184. {
     
185.         int i;
     
186.         struct sockaddr *addr = p;
     
187.         if(netif_running(dev))
     
188.         {
     
189.                 return -EBUSY;
     
190.         }
     
191.        
     
192.         if(!is_valid_ether_addr(addr->sa_data))
     
193.         {
     
194.                 return -EADDRNOTAVAIL;
     
195.         }
     
196.        
     
197.         memcpy(dev->dev_addr,addr->sa_data,dev->addr_len);
     
198.        
     
199.         memcpy(dev->dev_addr, "\0SNUL0", ETH_ALEN);
     
200.                 printk(KERN_ALERT "mac_open2,%s\n",dev->dev_addr);
     
201.         if (dev == snull_devs[1])
     
202.                 dev->dev_addr[ETH_ALEN-1]++; /* \0SNUL1 */
     
203.         return 0;
     
204. }
     
205. 
     
206. 
     
207. int snull_config(struct net_device *dev, struct ifmap *map)
     
208. {
     
209.                 printk(KERN_ALERT "snull_config\n");
     
210.         if (dev->flags & IFF_UP) /* can't act on a running interface */
     
211.                 return -EBUSY;
     
212. 
     
213.         /* Don't allow changing the I/O address */
     
214.         if (map->base_addr != dev->base_addr) {
     
215.                 printk(KERN_WARNING "snull: Can't change I/O address\n");
     
216.                 return -EOPNOTSUPP;
     
217.         }
     
218. 
     
219.         /* Allow changing the IRQ */
     
220.         if (map->irq != dev->irq) {
     
221.                 dev->irq = map->irq;
     
222.                 /* request_irq() is delayed to open-time */
     
223.         }
     
224. 
     
225.         /* ignore other fields */
     
226.         return 0;
     
227. }
     
228. 
     
229. void snull_rx(struct net_device *dev, struct snull_packet *pkt)
     
230. {
     
231.         struct sk_buff *skb;
     
232.         struct snull_priv *priv = netdev_priv(dev);
     
233. 
     
234.         skb = dev_alloc_skb(pkt->datalen + 2);
     
235.         if (!skb) {
     
236.                 if (printk_ratelimit())
     
237.                         printk(KERN_NOTICE "snull rx: low on mem - packet dropped\n");
     
238.                 priv->stats.rx_dropped++;
     
239.                 goto out;
     
240.         }
     
241.         skb_reserve(skb, 2); /* align IP on 16B boundary */  
     
242.         memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);
     
243. 
     
244.         /* Write metadata, and then pass to the receive level */
     
245.         skb->dev = dev;
     
246.         skb->protocol = eth_type_trans(skb, dev);
     
247.         skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
     
248.         priv->stats.rx_packets++;
     
249.         priv->stats.rx_bytes += pkt->datalen;
     
250.         netif_rx(skb);
     
251.   out:
     
252.         return;
     
253. }
     
254.    
     
255. 
     
256. /*
     
257. * The poll implementation.
     
258. */
     
259. static int snull_poll(struct napi_struct *napi, int budget)
     
260. {
     
261.         int npackets = 0;
     
262.         struct sk_buff *skb;
     
263.         struct snull_priv  *priv = container_of(napi, struct snull_priv, napi);
     
264.         struct net_device  *dev =  priv->dev;
     
265.         struct snull_packet *pkt;
     
266.    
     
267.         while (npackets < budget && priv->rx_queue) {
     
268.                 pkt = snull_dequeue_buf(dev);
     
269.                 skb = dev_alloc_skb(pkt->datalen + 2);
     
270.                 if (! skb) {
     
271.                         if (printk_ratelimit())
     
272.                                 printk(KERN_NOTICE "snull: packet dropped\n");
     
273.                         priv->stats.rx_dropped++;
     
274.                         snull_release_buffer(pkt);
     
275.                         continue;
     
276.                 }
     
277.                 skb_reserve(skb, 2); /* align IP on 16B boundary */  
     
278.                 memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);
     
279.                 skb->dev = dev;
     
280.                 skb->protocol = eth_type_trans(skb, dev);
     
281.                 skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
     
282.                 netif_receive_skb(skb);
     
283.                 /* Maintain stats */
     
284.                 npackets++;
     
285.                 priv->stats.rx_packets++;
     
286.                 priv->stats.rx_bytes += pkt->datalen;
     
287.                 snull_release_buffer(pkt);
     
288.         }
     
289.         if (npackets < budget) {
     
290.                 napi_complete(napi);
     
291.                 snull_rx_ints(dev, 1);
     
292.         }
     
293.         return npackets;
     
294. }
     
295.             
     
296.         
     
297. static void snull_regular_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     
298. {
     
299.         int statusword;
     
300.         struct snull_priv *priv;
     
301.         struct snull_packet *pkt = NULL;
     
302. 
     
303.         struct net_device *dev = (struct net_device *)dev_id;
     
304.         /* ... and check with hw if it's really ours */
     
305. 
     
306.         /* paranoid */
     
307.         if (!dev)
     
308.                 return;
     
309. 
     
310.         /* Lock the device */
     
311.         priv = netdev_priv(dev);
     
312.         spin_lock(&priv->lock);
     
313. 
     
314.         statusword = priv->status;
     
315.         priv->status = 0;
     
316.         if (statusword & SNULL_RX_INTR) {
     
317.                 /* send it to snull_rx for handling */
     
318.                 pkt = priv->rx_queue;
     
319.                 if (pkt) {
     
320.                         priv->rx_queue = pkt->next;
     
321.                         snull_rx(dev, pkt);
     
322.                 }
     
323.         }
     
324.         if (statusword & SNULL_TX_INTR) {
     
325.                 /* a transmission is over: free the skb */
     
326.                 priv->stats.tx_packets++;
     
327.                 priv->stats.tx_bytes += priv->tx_packetlen;
     
328.                 dev_kfree_skb(priv->skb);
     
329.         }
     
330. 
     
331.         /* Unlock the device and we are done */
     
332.         spin_unlock(&priv->lock);
     
333.         if (pkt) snull_release_buffer(pkt); /* Do this outside the lock! */
     
334.         return;
     
335. }
     
336. 
     
337. 
     
338. static void snull_napi_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     
339. {
     
340.         int statusword;
     
341.         struct snull_priv *priv;
     
342. 
     
343. 
     
344.         struct net_device *dev = (struct net_device *)dev_id;
     
345. 
     
346.         if (!dev)
     
347.                 return;
     
348. 
     
349.         /* Lock the device */
     
350.         priv = netdev_priv(dev);
     
351.         spin_lock(&priv->lock);
     
352. 
     
353.         statusword = priv->status;
     
354.         priv->status = 0;
     
355.         if (statusword & SNULL_RX_INTR) {
     
356.                 snull_rx_ints(dev, 0);  /* Disable further interrupts */
     
357.                 napi_schedule(&priv->napi);
     
358.         }
     
359.         if (statusword & SNULL_TX_INTR) {
     
360.                 priv->stats.tx_packets++;
     
361.                 priv->stats.tx_bytes += priv->tx_packetlen;
     
362.                 dev_kfree_skb(priv->skb);
     
363.         }
     
364. 
     
365.         spin_unlock(&priv->lock);
     
366.         return;
     
367. }
     
368. 
     
369. 
     
370. static void snull_hw_tx(char *buf, int len, struct net_device *dev)
     
371. {
     
372. 
     
373.         struct iphdr *ih;
     
374.         struct net_device *dest;
     
375.         struct snull_priv *priv;
     
376.         u32 *saddr, *daddr;
     
377.         struct snull_packet *tx_buffer;
     
378.    
     
379.         /* I am paranoid. Ain't I? */
     
380.         if (len < sizeof(struct ethhdr) + sizeof(struct iphdr)) {
     
381.                 printk("snull: Hmm... packet too short (%i octets)\n",
     
382.                                 len);
     
383.                 return;
     
384.         }
     
385. 
     
386.         if (0) { /* enable this conditional to look at the data */
     
387.                 int i;
     
388.                 PDEBUG("len is %i\n" KERN_DEBUG "data:",len);
     
389.                 for (i=14 ; i<len; i++)
     
390.                         printk(" %02x",buf[i]&0xff);
     
391.                 printk("\n");
     
392.         }
     
393.         ih = (struct iphdr *)(buf+sizeof(struct ethhdr));
     
394.         saddr = &ih->saddr;
     
395.         daddr = &ih->daddr;
     
396. 
     
397.         ((u8 *)saddr)[2] ^= 1; /* change the third octet (class C) */
     
398.         ((u8 *)daddr)[2] ^= 1;
     
399. 
     
400.         ih->check = 0;         /* and rebuild the checksum (ip needs it) */
     
401.         ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl);
     
402. 
     
403.         if (dev == snull_devs[0])
     
404.                 PDEBUGG("%08x:%05i --> %08x:%05i\n",
     
405.                                 ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source),
     
406.                                 ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest));
     
407.         else
     
408.                 PDEBUGG("%08x:%05i <-- %08x:%05i\n",
     
409.                                 ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest),
     
410.                                 ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source));
     
411. 
     
412.         dest = snull_devs[dev == snull_devs[0] ? 1 : 0];
     
413.         priv = netdev_priv(dest);
     
414.         tx_buffer = snull_get_tx_buffer(dev);
     
415.         tx_buffer->datalen = len;
     
416.         memcpy(tx_buffer->data, buf, len);
     
417.         snull_enqueue_buf(dest, tx_buffer);
     
418.         if (priv->rx_int_enabled) {
     
419.                 priv->status |= SNULL_RX_INTR;
     
420.                 snull_interrupt(0, dest, NULL);
     
421.         }
     
422. 
     
423.         priv = netdev_priv(dev);
     
424.         priv->tx_packetlen = len;
     
425.         priv->tx_packetdata = buf;
     
426.         priv->status |= SNULL_TX_INTR;
     
427.         if (lockup && ((priv->stats.tx_packets + 1) % lockup) == 0) {
     
428.                 /* Simulate a dropped transmit interrupt */
     
429.                 netif_stop_queue(dev);
     
430.                 PDEBUG("Simulate lockup at %ld, txp %ld\n", jiffies,
     
431.                                 (unsigned long) priv->stats.tx_packets);
     
432.         }
     
433.         else
     
434.                 snull_interrupt(0, dev, NULL);
     
435. }
     
436. 
     
437. int snull_tx(struct sk_buff *skb, struct net_device *dev)
     
438. {
     
439.         int len;
     
440.         char *data, shortpkt[ETH_ZLEN];
     
441.         struct snull_priv *priv = netdev_priv(dev);
     
442.         
     
443.         data = skb->data;
     
444.         len = skb->len;
     
445.         if (len < ETH_ZLEN) {
     
446.                 memset(shortpkt, 0, ETH_ZLEN);
     
447.                 memcpy(shortpkt, skb->data, skb->len);
     
448.                 len = ETH_ZLEN;
     
449.                 data = shortpkt;
     
450.         }
     
451.         dev->trans_start = jiffies; /* save the timestamp */
     
452. 
     
453.         priv->skb = skb;
     
454. 
     
455.         snull_hw_tx(data, len, dev);
     
456. 
     
457.         return 0; /* Our simple device can not fail */
     
458. }
     
459. 
     
460. /*
     
461. * Deal with a transmit timeout.
     
462. */
     
463. void snull_tx_timeout (struct net_device *dev)
     
464. {
     
465.         struct snull_priv *priv = netdev_priv(dev);
     
466. 
     
467.         PDEBUG("Transmit timeout at %ld, latency %ld\n", jiffies,
     
468.                         jiffies - dev->trans_start);
     
469.         /* Simulate a transmission interrupt to get things moving */
     
470.         priv->status = SNULL_TX_INTR;
     
471.         snull_interrupt(0, dev, NULL);
     
472.         priv->stats.tx_errors++;
     
473.         netif_wake_queue(dev);
     
474.         return;
     
475. }
     
476. 
     
477. 
     
478. int snull_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
     
479. {
     
480.         PDEBUG("ioctl\n");
     
481.         return 0;
     
482. }
     
483. 
     
484. struct net_device_stats *snull_stats(struct net_device *dev)
     
485. {
     
486.         struct snull_priv *priv = netdev_priv(dev);
     
487.         return &priv->stats;
     
488. }
     
489. 
     
490. 
     
491. int snull_rebuild_header(struct sk_buff *skb)
     
492. {
     
493.         struct ethhdr *eth = (struct ethhdr *) skb->data;
     
494.         struct net_device *dev = skb->dev;
     
495.    
     
496.         memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
     
497.         memcpy(eth->h_dest, dev->dev_addr, dev->addr_len);
     
498.         eth->h_dest[ETH_ALEN-1]   ^= 0x01;   /* dest is us xor 1 */
     
499.         return 0;
     
500. }
     
501. 
     
502. 
     
503. int snull_header(struct sk_buff *skb, struct net_device *dev,
     
504.                  unsigned short type, const void *daddr, const void *saddr,
     
505.                 unsigned int len)
     
506. {
     
507.         struct ethhdr *eth = (struct ethhdr *)skb_push(skb,ETH_HLEN);
     
508. 
     
509.         eth->h_proto = htons(type);
     
510.         memcpy(eth->h_source, saddr ? saddr : dev->dev_addr, dev->addr_len);
     
511.         memcpy(eth->h_dest,   daddr ? daddr : dev->dev_addr, dev->addr_len);
     
512.         eth->h_dest[ETH_ALEN-1]   ^= 0x01;   /* dest is us xor 1 */
     
513.         return (dev->hard_header_len);
     
514. }
     
515. 
     
516. 
     
517. int snull_change_mtu(struct net_device *dev, int new_mtu)
     
518. {
     
519.         unsigned long flags;
     
520.         struct snull_priv *priv = netdev_priv(dev);
     
521.         spinlock_t *lock = &priv->lock;
     
522.    
     
523.         /* check ranges */
     
524.         if ((new_mtu < 68) || (new_mtu > 1500))
     
525.                 return -EINVAL;
     
526. 
     
527.         spin_lock_irqsave(lock, flags);
     
528.         dev->mtu = new_mtu;
     
529.         spin_unlock_irqrestore(lock, flags);
     
530.         return 0; /* success */
     
531. }
     
532. 
     
533. static const struct header_ops snull_header_ops = {
     
534.         .create  = snull_header,
     
535.         .rebuild = snull_rebuild_header,
     
536.         .cache   = NULL,  /* disable caching */
     
537. };
     
538. 
     
539. 
     
540. void snull_init(struct net_device *dev)
     
541. {
     
542.                 printk(KERN_ALERT "call snull_init\n");
     
543.         struct snull_priv *priv;
     
544. #if 0
     
545. 
     
546. #endif
     
547. 
     
548.         ether_setup(dev); /* assign some of the fields */
     
549. 
     
550.         dev->open = snull_open,
     
551.         dev->stop = snull_release,
     
552.         dev->set_config = snull_config,
     
553.         dev->hard_start_xmit = snull_tx,
     
554. //        dev->do_ioctl = snull_ioctl,
     
555.         dev->get_stats = snull_stats,
     
556.         dev->change_mtu = snull_change_mtu,
     
557.         dev->tx_timeout = snull_tx_timeout,
     
558.                 dev->set_mac_address = snull_set_mac_address;
     
559. //        dev->netdev_ops      = &snull_netdev_ops;
     
560.         dev->header_ops      = &snull_header_ops;
     
561.         dev->watchdog_timeo = timeout;
     
562.         /* keep the default flags, just add NOARP */
     
563.         dev->flags           |= IFF_NOARP;
     
564.         dev->features        |= NETIF_F_NO_CSUM;
     
565.         /*
     
566.          * Then, initialize the priv field. This encloses the statistics
     
567.          * and a few private fields.
     
568.          */
     
569.         priv = netdev_priv(dev);
     
570.         memset(priv, 0, sizeof(struct snull_priv));
     
571.         priv->dev = dev;
     
572.         netif_napi_add(dev, &priv->napi, snull_poll, 2);
     
573.         /* The last parameter above is the NAPI "weight". */
     
574.         spin_lock_init(&priv->lock);
     
575.         snull_rx_ints(dev, 1);          /* enable receive interrupts */
     
576.         snull_setup_pool(dev);
     
577. }
     
578. 
     
579. 
     
580. void snull_cleanup(void)
     
581. {
     
582.         int i;
     
583.    
     
584.         for (i = 0; i < 2;  i++) {
     
585.                 if (snull_devs[i]) {
     
586.                         unregister_netdev(snull_devs[i]);
     
587.                         snull_teardown_pool(snull_devs[i]);
     
588.                         free_netdev(snull_devs[i]);
     
589.                 }
     
590.         }
     
591.         return;
     
592. }
     
593. 
     
594. 
     
595. 
     
596. 
     
597. int snull_init_module(void)
     
598. {
     
599.         int result, i, ret = -ENOMEM;
     
600. 
     
601.         snull_interrupt = use_napi ? snull_napi_interrupt : snull_regular_interrupt;
     
602. 
     
603.         /* Allocate the devices */
     
604.         snull_devs[0] = alloc_netdev(sizeof(struct snull_priv), "sn%d",
     
605.                         snull_init);
     
606.         snull_devs[1] = alloc_netdev(sizeof(struct snull_priv), "sn%d",
     
607.                         snull_init);
     
608.         if (snull_devs[0] == NULL || snull_devs[1] == NULL)
     
609.                 goto out;
     
610. 
     
611.         ret = -ENODEV;
     
612.         for (i = 0; i < 2;  i++)
     
613.                 if ((result = register_netdev(snull_devs[i])))
     
614.                         printk("snull: error %i registering device \"%s\"\n",
     
615.                                         result, snull_devs[i]->name);
     
616.                 else
     
617.                         ret = 0;
     
618.    out:
     
619.         if (ret)
     
620.                 snull_cleanup();
     
621.         return ret;
     
622. }
     
623. 
     
624. 
     
625. module_init(snull_init_module);
     
626. module_exit(snull_cleanup);
     
627. 
     

复制代码

现在的问题是，每次在insmod snull.ko后，sn0\sn1的MAC地址都是00:00:00:00:00:00
我的理解是用ifconfig sn0 up，会调用snull_open，然后函数里面会给sn0赋值MAC地址。可是这个不行，是我的理解有问题么？

后来发现，需要ifconfig sn0 hw ether 00:12:34:56:78:90这样，sn0才会调用snull_open赋值MAC地址。

请问问题出在哪儿了？各位大侠~~~

ai_bj

这个是snull.h

1. 
   
2. 
   
3. #undef PDEBUG             /* undef it, just in case */
   
4. #ifdef SNULL_DEBUG
   
5. #  ifdef __KERNEL__
   
6. /* This one if debugging is on, and kernel space */
   
7. #    define PDEBUG(fmt, args...) printk( KERN_DEBUG "snull: " fmt, ## args)
   
8. #  else
   
9. /* This one for user space */
   
10. #    define PDEBUG(fmt, args...) fprintf(stderr, fmt, ## args)
    
11. #  endif
    
12. #else
    
13. #  define PDEBUG(fmt, args...) /* not debugging: nothing */
    
14. #endif
    
15. 
    
16. #undef PDEBUGG
    
17. #define PDEBUGG(fmt, args...) /* nothing: it's a placeholder */
    
18. 
    
19. #define SNULL_RX_INTR 0x0001
    
20. #define SNULL_TX_INTR 0x0002
    
21. 
    
22. /* Default timeout period */
    
23. #define SNULL_TIMEOUT 5   /* In jiffies */
    
24. 
    
25. extern struct net_device *snull_devs[];
    

复制代码

txgc_wm

http://blog.chinaunix.net/uid-25885064-id-3077098.html  可以参考这个博客！