Linux Network card driver Learning (analyzing a network-driven example of a virtual hardware)

in Linux, the network is divided into two tiers, namely the Network Stack protocol support layer, and the device driver layer that receives and sends the network protocol. Network stack is a separate part of hardware, mainly used to support TCP/IP and other protocols, the network device driver layer is connected to the network stack protocol layer and the middle layer of network hardware.

The main functions of the network device driver are:

(1) Initialization of module loading or kernel boot-related processing

(2) processing when the module is cleared

(3) Retrieval and detection of network equipment

(4) Initialization and registration of network devices

(5) Turn network devices on or off

(6) Sending network data

(7) Receiving network data

(8) Interrupt processing (when the data is sent, the hardware generates an interrupt to the kernel, telling the kernel that the data has been sent, when the network device receives the data, there will be an interrupt, tell the kernel, the data has arrived, please timely processing)

(9) Timeout processing

(10) Multicast processing

(11) Control IOCTL of network equipment

The main function of Linux network device is the initialization of network equipment, the configuration of network equipment, and the sending and receiving of data packets.

The following code is an example of a network driver for virtual hardware

2. Code

#undef pdebug/* undef it, just in case */#ifdef snull_debug# ifdef __kernel__/* This one if debugging I s on, and kernel space */# define PDEBUG (FMT, args ...) printk (kern_debug "snull:" Fmt, # # args) # Else * * this on E for user space */# define PDEBUG (FMT, args ...) fprintf (stderr, FMT, # # args) # endif#else# define Pdebug (FMT, args. .) /* Not debugging:nothing */#endif #undef pdebugg#define Pdebugg (fmt, args ...)/* nothing:it ' s a placeholder *//* these AR E The flags in the Statusword * * #define SNULL_RX_INTR 0x0001#define snull_tx_intr 0x0002/* Default Timeout period */#defin E snull_timeout 6/* in Jiffies * * #include <linux/module.h> #include <linux/sched.h> #include <linux/kerne l.h>/* PRINTK () */#include <linux/slab.h>/* KMALLOC () */#include <linux/errno.h>/* ERROR codes */#inclu De <linux/types.h> * size_t */#include <linux/interrupt.h>/mark_bh */#include <linux/in.h># Include <linux/netdevice.h&Gt /* struct device, and other headers */#include <linux/etherdevice.h>/* Eth_type_trans */#include <linux/ip.h&gt          ; /* struct IPHDR */#include <linux/tcp.h>/* struct TCPHDR */#include <linux/skbuff.h> #include <linu x/if_ether.h> #include <linux/in6.h> #include <asm/uaccess.h> #include <asm/checksum.h>static int lockup = 0;static int timeout = snull_timeout;struct Net_device snull_devs[2];//Define two devices here, one is snull0, the other is snull1// Network device structure, as net_device->privstruct snull_priv {struct net_device_stats stats;//useful statistics int status;//Network device status information, is the number of Packet length received by the network packet int rx_packetlen;//U8 *rx_packetdata;//The data received by the INT tx_packetlen;//the packet lengths sent U8 *tx_packe tdata;//sent data struct Sk_buff *skb;//socket buffer structure, the transmission of data between the network layer is through this structure to achieve spinlock_t lock;//spin lock};void Snull_tx_ti    Meout (struct net_device *dev);//network interface open function int snull_open (struct net_device *dev) {PRINTK ("call snull_open/n"); memcpy (dev->dev_addr, "/0snUL0 ", eth_alen);//Assign a hardware address, Eth_alen is the length of the hardware address of the network device netif_start_queue (dev);//Open the transmission queue for data transfer return 0;}    int snull_release (struct net_device *dev) {PRINTK ("call snull_release/n"); Netif_stop_queue (Dev); When the network interface is closed, call the Stop method, which indicates that no more data can be sent to return 0;}    packet function void Snull_rx (struct net_device *dev, int len, unsigned char *buf) {struct Sk_buff *skb;     struct Snull_priv *priv = (struct Snull_priv *) dev->priv; /* * The packet have been retrieved from the transmission * medium. Build an SKB around it, so upper layers can handle it */SKB = DEV_ALLOC_SKB (len+2);//Assign a socket buffer and initialize SKB-&G        T;data,skb->tail and Skb->head if (!SKB) {PRINTK ("Snull rx:low on Mem-packet dropped/n");        priv->stats.rx_dropped++;    Return } skb_reserve (SKB, 2);  /* Align IP on 16B boundary */memcpy (Skb_put (SKB, Len), buf, Len),//skb_put is writing data to socket buffer/* Write metadata,  And then pass to the receive level */Skb->dev = dev;  Skb->protocol = Eth_type_trans (SKB, dev);//Returns the protocol number skb->ip_summed = Checksum_unnecessary; Here does not check the number of priv->stats.rx_packets++;//received packets +1 priv->stats.rx_bytes + = len;//received packet length NETIF_RX (SKB);//Notification kernel          The package has been received and encapsulated as a socket buffer to the upper return;} /* * The typical interrupt entry point *///interrupt processing, there is no hardware in this program, therefore, there is no real hardware interrupt, just a simulated interrupt, after sending the network packet, will generate an interrupt//to notify the kernel has sent the packet, When a new packet arrives at the network interface, an interrupt occurs, notifying that the new packet has arrived void Snull_interrupt (int irq, void *dev_id, struct pt_regs *regs) {int statusword;//with    To identify whether to send or receive a new packet struct SNULL_PRIV *priv;     /* As usual, check the "device" pointer for shared handlers.    * Then assign "struct device *dev" */struct Net_device *dev = (struct net_device *) dev_id;    /* ... and check with HW if it ' s really ours */if (!dev/*paranoid*/) return;    /* Lock the device */priv = (struct Snull_priv *) dev->priv;    Spin_lock (&priv->lock); /* Retrieve statusword:real netdevices use I/o instructions */Statusword = priv->status; if (Statusword & snull_rx_intr) {//if it is receive/* Send it to SNULL_RX for handling */Snull_rx (Dev, priv->r    X_packetlen, Priv->rx_packetdata); } if (Statusword & snull_tx_intr) {//If send complete/* A transmission is over:free the SKB */priv->stats        . tx_packets++;        Priv->stats.tx_bytes + = priv->tx_packetlen; DEV_KFREE_SKB (PRIV-&GT;SKB);//release SKB Socket buffer}/* Unlock the device and we are doing */Spin_unlock (&priv->lo    CK); return;} /* * Transmit a packet (Low level interface) *///true processing of sending packets//simulating sending packets from one network to another network void Snull_hw_tx (char *buf, int len, struc T Net_device *dev) {/* * This function deals with HW details.     This interface loops * Back the packet to the other Snull interface (if any). * In other words, this function implements the Snull behaviour, * and all other procedures is rather device-indepen Dent */struct IPHDR *ih;//ip head struct net_device *dest;//target device structure, net_device stores important information of a network interface, which is the core of network driver Snull_priv *priv; U32 *saddr, *daddr;//source device address and target device address/* I am paranoid. Ain ' t I? */if (len < sizeof (struct ETHHDR) + sizeof (struct IPHDR)) {PRINTK ("snull:hmm ... packet Too short (%i octet        s)/n ", Len);    Return     }/* * Ethhdr is bytes, and the kernel arranges for IPHDR * to was aligned (i.e., ETHHDR is unaligned) */    IH = (struct IPHDR *) (buf+sizeof (struct ETHHDR));    SADDR = &ih->saddr;    DADDR = &ih->daddr; Simulate two networks on the same machine, different network segment addresses, send network packets and receive network packets ((U8 *) saddr) [2] ^= 1;    /* Change the third octet (class C) ^ is a bitwise XOR operator that makes the third part of the network address XOR with 1, because data from the same network is not forwarded */(((U8 *) daddr) [2] ^= 1;         Ih->check = 0;    /* and rebuild the checksum (IP needs it) */Ih->check = Ip_fast_csum ((unsigned char *) IH,IH-&GT;IHL); if (dev = = Snull_devs) Pdebugg ("%08x:%05i-to-%08x:%05i/n", Ntohl (IH-&GT;SADDR), Ntohs ((struct TCP    HDR *) (ih+1))->source),           Ntohl (IH-&GT;DADDR), Ntohs ((struct TCPHDR *) (ih+1))); else Pdebugg ("%08x:%05i <--%08x:%05i/n", Ntohl (IH-&GT;DADDR), Ntohs (((struct TCPHDR *) (ih+1))    dest), Ntohl (IH-&GT;SADDR), Ntohs ((struct TCPHDR *) (ih+1)),->source);  /* Ok, now the packet are ready for Transmission:first simulate A * receive interrupt on the twin device and then A * Transmission-done on the transmitting device */dest = Snull_devs + (Dev==snull_devs? 1:0);//If Dev is 0, then D    EST is 1, if Dev is 1, then dest is 0 priv = (struct Snull_priv *) dest->priv;//dest priv in target priv->status = snull_rx_intr;    Priv->rx_packetlen = Len;    Priv->rx_packetdata = BUF;    Snull_interrupt (0, dest, NULL);    Priv = (struct Snull_priv *) dev->priv;    Priv->status = Snull_tx_intr;    Priv->tx_packetlen = Len;    Priv->tx_packetdata = BUF; if (Lockup && ((priv->stats.tx_packets + 1)% lockup) = = 0) {/* Simulate a Dropped Transmit Interrupt */netif_stop_queue (dev);    Pdebug ("Simulate lockup at%ld, Txp%ld/n", jiffies, (unsigned long) priv->stats.tx_packets); } else snull_interrupt (0, Dev, NULL);} /* * Transmit a packet (called by the kernel) *///packet function int snull_tx (struct sk_buff *skb, struct net_device *dev) {int    Len    Char *data;    struct Snull_priv *priv = (struct Snull_priv *) dev->priv;        if (SKB = = NULL) {pdebug ("tint for%p, SKB%p/n", Dev, SKB);        Snull_tx_timeout (Dev);    if (SKB = = NULL) return 0; } len = Skb->len < Eth_zlen? Eth_zlen:skb->len;//eth_zlen is the length of the smallest packet sent data = skb->data;//the part of the packet that will be sent Dev->trans_start = jiffies;    Save current Send time PRIV-&GT;SKB = SKB; SNULL_HW_TX (data, Len, dev);//True send function return 0; /* Our simple device can not fail */}/* * Deal with a transmit timeout. *///calls Snull_tx_timeoutvoid Snull_tx_timeout once the Watchdog_timeo is exceeded (struct Net_devicE *dev) {PRINTK ("call snull_tx_timeout/n");    struct Snull_priv *priv = (struct Snull_priv *) dev->priv;    Pdebug ("Transmit timeout at%ld, latency%ld/n", jiffies, Jiffies-dev->trans_start);    Priv->status = Snull_tx_intr; Snull_interrupt (0, Dev, NULL);//Interrupt after timeout priv->stats.tx_errors++;//the number of errors sent netif_wake_queue (dev); To send the data again, call this function to restart the send queue return;}    /* * IOCTL commands */int snull_ioctl (struct net_device *dev, struct ifreq *rq, int cmd) {pdebug ("ioctl/n"); return 0;} /* * Return statistics to the caller */struct net_device_stats *snull_stats (struct net_device *dev) {struct SNULL_PRIV    *priv = (struct Snull_priv *) dev->priv;    Return &priv->stats;//Get statistical information}//Device initialization function int snull_init (struct net_device *dev) {PRINTK ("call snull_init/n"); /* Then, assign other fields in Dev, using Ether_setup () and some * hand assignments */ether_setup (dev); Populate some Ethernet devices in the structure of the item Dev->open = Snull_opeN    Dev->stop = Snull_release;    Dev->set_config = Snull_config;    Dev->hard_start_xmit = Snull_tx;    Dev->do_ioctl = Snull_ioctl;    Dev->get_stats = Snull_stats;    DEV-&GT;CHANGE_MTU = SNULL_CHANGE_MTU;    Dev->rebuild_header = Snull_rebuild_header;    Dev->hard_header = Snull_header;    Dev->tx_timeout = snull_tx_timeout;//timeout processing Dev->watchdog_timeo = timeout;    /* Keep the default flags, just add Noarp */dev->flags |= iff_noarp;      Dev->hard_header_cache = NULL;    /* Disable Caching */Set_module_owner (dev); /* Then, allocate the Priv field.     This encloses the statistics * and a few private fields.  *///allocates memory for priv Dev->priv = kmalloc (sizeof (struct snull_priv), gfp_kernel);    if (Dev->priv = = NULL) Return-enomem;    memset (dev->priv, 0, sizeof (struct snull_priv));    Spin_lock_init (& (struct Snull_priv *) dev->priv)->lock); ReTurn 0;} struct Net_device snull_devs[2] = {{init:snull_init,},/* init, nothing more */{init:snull_init,}};int Snul   L_init_module (void) {int i,result=0; strcpy (Snull_devs[0].name, "snull0"); the name in the//net_device struct represents the device name strcpy (snull_devs[1].name, "snull1");//defines two devices,  Snull0 and Snull1 for (i=0; i<2; i++) if (result = Register_netdev (snull_devs+i))//Register device PRINTK ("Snull:error%i registering Device/"     %s/"/n", result, snull_devs[i].name); return 0;}     void Snull_cleanup (void) {int i;  for (i=0; i<2;        i++) {kfree (SNULL_DEVS[I].PRIV);    Unregister_netdev (Snull_devs+i); } return; Module_init (Snull_init_module); Module_exit (Snull_cleanup);

Copyright NOTICE: This article for Bo Master original article, without Bo Master permission not reproduced.

Linux Network card driver Learning (analyzing a network-driven example of a virtual hardware)