Home PC Games Linux Windows Database Network Programming Server Mobile  
           
  Home \ Programming \ Linux loopback adapter Driven Design     - Android Studio interface-related settings (Linux)

- Copy and paste in Linux terminal and Vim (Linux)

- Eight kinds of techniques to solve hard problems Linux (Linux)

- Getting Started with Linux system to learn: how to install USB webcams come in raspberry (Linux)

- Java deserialization test (Programming)

- Archive log file size and redo log file size relationship (Database)

- Android media library of analysis: MediaProvider (Programming)

- MariaDB 10 Multi-source replication (Database)

- MySQL management partition table (Database)

- Five strokes to find out the IP address you want to know (Linux)

- Killall five options you might not know (Linux)

- CentOS 6.5_x64 install Oracle 11g R2 (Database)

- Each catalog Detailed Linux (Linux)

- Four levels of intrusion on Linux server and counter-measures (Linux)

- Linux Network Programming - non-blocking program (Programming)

- C ++ CBitmap, HBitmap, Bitmap difference and contact (Programming)

- Linux System Getting Started Tutorial: Installing Brother printer in Linux (Linux)

- Elasticsearch Kibana installation notes (Linux)

- 22 Port weak passwords and SSH connection program of the Linux server (Linux)

- Using DOS command to change UNIX administrator password (Linux)

 
         
  Linux loopback adapter Driven Design
     
  Add Date : 2018-11-21      
         
         
         
  Loopback adapter driver
1. The difference between the ordinary and the loopback adapter card is that he is not the actual physical virtual card, which is equivalent to the sending end and the receiving end of an ordinary card shorted together.

2. In the kernel source code of the program loopback adapter (drivers / net / loopback.c) is not given in the form of a module, but his initialize (loopback_net_init) and exit functions (loopback_dev_free) will be called to other parts of the kernel .

3. Referring to the flowchart NIC driver initialization design, which can not be assigned net_device structure alloc_etherdev function, because the function is assigned the structure of an Ethernet card, use alloc_netdev loopback adapter to assign a function to the structure. Refer to the kernel source code for others how to use this function alloc_netdev (0, "lo", loopback_setup); 0 represents the size of the first private members net_device this structure, generally choose 0, the second one is the name of the NIC, ifconfig displays name, and the third is the specific structure of the card initialization function pointer.
struct net_device * dev;
 dev = alloc_netdev (0, "lo", loopback_setup);
Eventually calls to loopback_setup function. (As for the function pointer as a parameter when how to pass parameters, it is necessary to review the C language)
4. The loopback adapter does not need to initialize the hardware. So direct registration loopback adapter structure into kernel (third step). Finally, specify the loopback adapter is registered to the network subsystem.
net-> loopback_dev = dev; this step is critical.

5. The specific initialization (loopback_setup) (second step)
 (1) base address, MAC address and interrupt numbers are need, mainly netdev_ops this structure, it contains the NIC supports.

 (2) loopback adapter supports the maximum size of the received data packet, in addition to official data, as well as the first part of the relevant network protocols.
dev-> mtu = (16 * 1024) + 20 + 20 + 12; valid data is generally defined as 16KB.

 (3) plus exclusive sign indicates loopback adapter.
dev-> flags = IFF_LOOPBACK;
,
 (4) plus configuration header structure pointer, the structure members of this structure are numerous pointer constructor function pointers Ethernet packet header.
dev-> header_ops = & eth_header_ops;
Find the ideal can be seen
extern const struct header_ops eth_header_ops;

 struct header_ops {
      int (* create) (struct sk_buff * skb, struct net_device * dev,
                  unsigned short type, const void * daddr,
                  const void * saddr, unsigned len);
      int (* parse) (const struct sk_buff * skb, unsigned char * haddr);
      int (* rebuild) (struct sk_buff * skb);
 #define HAVE_HEADER_CACHE
      int (* cache) (const struct neighbour * neigh, struct hh_cache * hh);
      void (* cache_update) (struct hh_cache * hh,
                    const struct net_device * dev,
                    const unsigned char * haddr);
 };
 6. The data transmission

static int loopback_net_xmit (struct sk_buff * skb, struct net_device * dev)
{
 skb-> protocol = eth_type_trans (skb, dev);

packets ++;
 bytes + = skb-> len;

netif_rx (skb);

 return 0;
}


 }
(1) The first parameter is the transport protocol stack to the loopback adapter packet data, the second argument is the structure of the loopback adapter.

 (2) Stop sending queue
 Notifies the upper suspend transmission data, so that data txd sent has been delivered, but does not involve hardware, so the loopback adapter can be ignored. Accordingly, data is written to register and send wake-up and the release queue can be ignored again.

 (3) Information and Statistics, show that the upper layer protocol packet sent down
skb-> protocol = eth_type_trans (skb, dev);

(4) Statistical data sent over the size and the number of packages.

bytes + = skb-> len;

netif_rx (skb);

7. Since the protocol stack from storage data packets (skb) to txd, and txd do not need to send out, and txd rxd "connected" together, so a direct call netif_rx receiving portion of the common card in the transmission section (skb) function Therefore sent simultaneously to complete the reception. Meanwhile, we see more clearly at the time of transmission can not be released skb, otherwise there is no acceptable data.

Function 8. achieve access card status

static struct net_device_stats * loopback_get_stats (struct net_device * dev)
{
 struct net_device_stats * stats = & dev-> stats;

stats-> rx_packets = packets;
 stats-> tx_packets = packets;
 stats-> rx_bytes = bytes;
 stats-> tx_bytes = bytes;

 return stats;
}

NIC status information can be obtained from this structure
/ * The main device statistics structure * /
 struct rtnl_link_stats64 {
      __u64 rx_packets; / * total packets received * /
      __u64 tx_packets; / * total packets transmitted * /
      __u64 rx_bytes; / * total bytes received * /
      __u64 tx_bytes; / * total bytes transmitted * /
      __u64 rx_errors; / * bad packets received * /
      __u64 tx_errors; / * packet transmit problems * /
      __u64 rx_dropped; / * no space in linux buffers * /
      __u64 tx_dropped; / * no space available in linux * /
      __u64 multicast; / * multicast packets received * /
      __u64 collisions;

      / * Detailed rx_errors: * /
      __u64 rx_length_errors;
      __u64 rx_over_errors; / * receiver ring buff overflow * /
      __u64 rx_crc_errors; / * recved pkt with crc error * /
      __u64 rx_frame_errors; / * recv'd frame alignment error * /
      __u64 rx_fifo_errors; / * recv'r fifo overrun * /
      __u64 rx_missed_errors; / * receiver missed packet * /

      / * Detailed tx_errors * /
      __u64 tx_aborted_errors;
      __u64 tx_carrier_errors;
      __u64 tx_fifo_errors;
      __u64 tx_heartbeat_errors;
      __u64 tx_window_errors;

      / * For cslip etc * /
      __u64 rx_compressed;
      __u64 tx_compressed;
 };
This is mainly four members
 stats-> rx_packets = packets;
      stats-> tx_packets = packets;
      stats-> rx_bytes = bytes;
      stats-> tx_bytes = bytes;
. stats so members can define a struct net_device_stats stats point to a parameter passed in the time of rewriting the loopback adapter structure; in fact, they can override this function to obtain the status, because struct net_device * dev is a member of the struct net_device_stats stats also need to pay attention only to the members of the four members of the stats can be.

9. When exiting the drive is to cancel the registration of the structure. To achieve the purpose of cancellation of the card.

static __net_exit void loopback_net_exit (struct net * net)
{
 struct net_device * dev = net-> loopback_dev;

unregister_netdev (dev);
}

The following is sample code

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include
#include
#include

#include
#include
#include
#include
#include
#include
#include
#include / * For the statistics structure. * /
#include / * For ARPHRD_ETHER * /
#include
#include
#include
#include
#include

unsigned long packets = 0;
unsigned long bytes = 0;

// Struct net_device * dev;

static __net_exit void loopback_net_exit (struct net * net)
{
 struct net_device * dev = net-> loopback_dev;

unregister_netdev (dev);
}


static int loopback_net_xmit (struct sk_buff * skb, struct net_device * dev)
{
 skb-> protocol = eth_type_trans (skb, dev);

packets ++;
 bytes + = skb-> len;

netif_rx (skb);

 return 0;
}


static struct net_device_stats * loopback_get_stats (struct net_device * dev)
{
 struct net_device_stats * stats = & dev-> stats;

stats-> rx_packets = packets;
 stats-> tx_packets = packets;
 stats-> rx_bytes = bytes;
 stats-> tx_bytes = bytes;

 return stats;
}


static const struct net_device_ops loopback_ops =
{
 .ndo_start_xmit = loopback_net_xmit,
 .ndo_get_stats = loopback_get_stats,
};


/ *
 * The loopback device is special. There is only one instance
 * Per network namespace.
 * /
static void loopback_setup (struct net_device * dev)
{
 dev-> mtu = (16 * 1024) + 20 + 20 + 12;
 dev-> flags = IFF_LOOPBACK;
 dev-> header_ops = & eth_header_ops;
 dev-> netdev_ops = & loopback_ops;
}

/ * Setup and register the loopback device. * /
static int loopback_net_init (struct net * net)
{
 struct net_device * dev;
 //1.
 dev = alloc_netdev (0, "lo", loopback_setup);

// 4.
 register_netdev (dev);

 net-> loopback_dev = dev;

return 0;
}

/ * Registered in net / core / dev.c * /
struct pernet_operations __net_initdata loopback_net_ops = {
 .init = loopback_net_init,
 .exit = loopback_net_exit,
};
     
         
         
         
  More:      
 
- Linux operating system set up to effectively prevent ARP attacks (Linux)
- GRUB2 boot Ubuntu Manual (Linux)
- Oracle 12CIN-memory in table spaces (Database)
- How to add two-factor authentication for Linux systems SSH (Linux)
- MySQL 5.6 database code changes (Database)
- Close and limit unused ports computer server security protection (Linux)
- Linux dual physical network card set to a virtual NIC (Linux)
- Hive start being given: Found class jline.Terminal, but interface was expected (Database)
- Interesting example of Linux Sort command (Linux)
- 5 fast Node.js application performance tips (Programming)
- Use Ansible installation NGINX and NGINX Plus (Server)
- CentOS 6.6 install JDK7 (Linux)
- Configuring a Linux operating system security management services (Linux)
- How to Install 3.16.7 CKT2 kernel in Ubuntu 14.10, Ubuntu 14.04 and its derivative versions (Linux)
- MogileFS system installation configuration example (Server)
- How to improve the performance of Ruby On Rails (Linux)
- Android Studio Getting Started Hello World (Programming)
- CentOS 6.5 installation and deployment SVN 1.8.10 (Linux)
- Ubuntu How to install and upgrade Linux Kernel 3.15 (Linux)
- VirtualBox virtual machine to install Linux (Linux)
     
           
     
  CopyRight 2002-2022 newfreesoft.com, All Rights Reserved.