drivers/net/dummy.c

/* */
This source file includes following definitions.
dummy_open
dummy_close
dummy_init
dummy_xmit
dummy_get_stats
dummy_probe
init_module
cleanup_module
   1 /* dummy.c: a dummy net driver
   2 
   3         The purpose of this driver is to provide a device to point a
   4         route through, but not to actually transmit packets.
   5 
   6         Why?  If you have a machine whose only connection is an occasional
   7         PPP/SLIP/PLIP link, you can only connect to your own hostname
   8         when the link is up.  Otherwise you have to use localhost.
   9         This isn't very consistent.
  10 
  11         One solution is to set up a dummy link using PPP/SLIP/PLIP,
  12         but this seems (to me) too much overhead for too little gain.
  13         This driver provides a small alternative. Thus you can do
  14         
  15         [when not running slip]
  16                 ifconfig dummy slip.addr.ess.here up
  17         [to go to slip]
  18                 ifconfig dummy down
  19                 dip whatever
  20 
  21         This was written by looking at Donald Becker's skeleton driver
  22         and the loopback driver.  I then threw away anything that didn't
  23         apply!  Thanks to Alan Cox for the key clue on what to do with
  24         misguided packets.
  25 
  26                         Nick Holloway, 27th May 1994
  27         [I tweaked this explanation a little but thats all]
  28                         Alan Cox, 30th May 1994
  29 */
  30 
  31 /* To have statistics (just packets sent) define this */
  32 #undef DUMMY_STATS
  33 
  34 #ifdef MODULE
  35 #include <linux/module.h>
  36 #include <linux/version.h>
  37 #endif
  38 
  39 #include <linux/kernel.h>
  40 #include <linux/sched.h>
  41 #include <linux/types.h>
  42 #include <linux/fcntl.h>
  43 #include <linux/interrupt.h>
  44 #include <linux/ptrace.h>
  45 #include <linux/ioport.h>
  46 #include <linux/in.h>
  47 #include <linux/malloc.h>
  48 #include <linux/string.h>
  49 #include <asm/system.h>
  50 #include <asm/bitops.h>
  51 #include <asm/io.h>
  52 #include <asm/dma.h>
  53 #include <linux/errno.h>
  54 
  55 #include <linux/netdevice.h>
  56 #include <linux/etherdevice.h>
  57 #include <linux/skbuff.h>
  58 
  59 static int dummy_xmit(struct sk_buff *skb, struct device *dev);
  60 #ifdef DUMMY_STATS
  61 static struct enet_statistics *dummy_get_stats(struct device *dev);
  62 #endif
  63 
  64 #ifdef MODULE
  65 static int dummy_open(struct device *dev)
     /*  */
  66 {
  67         MOD_INC_USE_COUNT;
  68         return 0;
  69 }
  70 
  71 static int dummy_close(struct device *dev)
     /*  */
  72 {
  73         MOD_DEC_USE_COUNT;
  74         return 0;
  75 }
  76 
  77 #endif
  78 
  79 
  80 int dummy_init(struct device *dev)
     /*  */
  81 {
  82 /* I commented this out as bootup is noisy enough anyway and this driver
  83    seems pretty reliable 8) 8) 8) */
  84 /*      printk ( KERN_INFO "Dummy net driver (94/05/27 v1.0)\n" ); */
  85 
  86         /* Initialize the device structure. */
  87         dev->hard_start_xmit    = dummy_xmit;
  88 
  89 #if DUMMY_STATS
  90         dev->priv = kmalloc(sizeof(struct enet_statistics), GFP_KERNEL);
  91         memset(dev->priv, 0, sizeof(struct enet_statistics));
  92         dev->get_stats          = dummy_get_stats;
  93 #endif
  94 #ifdef MODULE
  95         dev->open = &dummy_open;
  96         dev->stop = &dummy_close;
  97 #endif
  98 
  99         /* Fill in the fields of the device structure with ethernet-generic values. */
 100         ether_setup(dev);
 101         dev->flags |= IFF_NOARP;
 102 
 103         return 0;
 104 }
 105 
 106 static int
 107 dummy_xmit(struct sk_buff *skb, struct device *dev)
     /*  */
 108 {
 109 #if DUMMY_STATS
 110         struct enet_statistics *stats;
 111 #endif
 112 
 113         if (skb == NULL || dev == NULL)
 114                 return 0;
 115 
 116         dev_kfree_skb(skb, FREE_WRITE);
 117 
 118 #if DUMMY_STATS
 119         stats = (struct enet_statistics *)dev->priv;
 120         stats->tx_packets++;
 121 #endif
 122 
 123         return 0;
 124 }
 125 
 126 #if DUMMY_STATS
 127 static struct enet_statistics *
 128 dummy_get_stats(struct device *dev)
     /*  */
 129 {
 130         struct enet_statistics *stats = (struct enet_statistics*) dev->priv;
 131         return stats;
 132 }
 133 #endif
 134 
 135 #ifdef MODULE
 136 char kernel_version[] = UTS_RELEASE;
 137 
 138 static int dummy_probe(struct device *dev)
     /*  */
 139 {
 140         dummy_init(dev);
 141         return 0;
 142 }
 143 
 144 static struct device dev_dummy = {
 145         "dummy0\0   ", 
 146                 0, 0, 0, 0,
 147                 0x0, 0,
 148                 0, 0, 0, NULL, dummy_probe };
 149 
 150 int init_module(void)
     /*  */
 151 {
 152         /* Find a name for this unit */
 153         int ct= 1;
 154         
 155         while(dev_get(dev_dummy.name)!=NULL && ct<100)
 156         {
 157                 sprintf(dev_dummy.name,"dummy%d",ct);
 158                 ct++;
 159         }
 160         
 161         if (register_netdev(&dev_dummy) != 0)
 162                 return -EIO;
 163         return 0;
 164 }
 165 
 166 void cleanup_module(void)
     /*  */
 167 {
 168         if (MOD_IN_USE)
 169                 printk("dummy: device busy, remove delayed\n");
 170         else
 171         {
 172                 unregister_netdev(&dev_dummy);
 173         }
 174 }
 175 #endif /* MODULE */
/* */
root/drivers/net/dummy.c

DEFINITIONS
