linux协议栈之链路层上的数据传输之网卡驱动

迷南。 2022-07-12 06:42 150阅读 0赞

文章来源：[http://blog.chinaunix.net/u1/51562/showart\_405963.html][http_blog.chinaunix.net_u1_51562_showart_405963.html]

[http://ericxiao.cublog.cn/][http_ericxiao.cublog.cn]对内核源码分析的比较详细，感谢文章作者无私奉献

本文欢迎转载!

转载请注明出处:http://ericxiao.cublog.cn/

\------------------------------------------

<<prison break>>第三季的第五集，终于在翘首企盼中姗姗来迟了，scofid用它惊人的智慧一次次化险为夷，但在邪恶的sona监狱他将如何逃脱呢？这我们不得而知，但我们可以分析Linux网络驱动来得到数据包是怎么通过物理接口的这一层“prison”束缚来达到通信目的：\-）

一：预备知识

关于I/O内存映射。

设备通过控制总线，数据总线，状态总线与CPU相连。控制总数传送控制信号，例如，网卡的启用。数据总线控制数据传输，例如，网卡发送数据，状态总数一般都是读取设备的当前状态，例如读取网卡的MAC地址。

在传统的操作中，都是通过读写设备寄存器的值来实现。但是这样耗费了CPU时钟。而且每取一次值都要读取设备寄存器，造成了效率的低下。在现代操作系统中。引用了I/O内存映射。即把寄存器的值映身到主存。对设备寄存器的操作，转换为对主存的操作，这样极大的提高了效率。

关于DMA

这是关于设备数据处理的一种方式。传统的处理方法为：当设备接收到数据，向CPU报告中断。CPU处理中断，把数据放到内存。

在现代操作系统中引入的DMA是指，设备接收到数据时，把数据放至DMA内存，再向CPU产生中断。这样节省了大量的CPU时间

关于软中断与NAPI

在现代操作系统中，对中断的处理速度要求越来越高。为了响应中断，将中断分为两部份，即上半部与下半部。上半部将数据推入处理队列，响应中断。然后再由下半部调度完成余下的任务。

NAPI是2.6新引入的一个概念，它在发生中断的时候，禁用中断。然后处理数据。之后，每隔一定的时候，它会主动向设备询用是否有数据要处理。

I/O,DMA在后续代码分析中会讨论在linux2.6.21中的实现。软中断与NAPI的详细知识将会在分析中断处理的时候，一一为你道来

[http://blog.chinaunix.net/u1/51562/showart\_405967.html][http_blog.chinaunix.net_u1_51562_showart_405967.html]

二：从网卡驱动说起。

以intel 100M 网卡驱动为例简要概述数据包的接收与发送流程。代码见（drivers/net/e100.c）

网卡是属于PCI设备，它的注册跟一般的PCI设备注册没什么两样。

static int \_\_init e100\_init\_module(void)

if(((1 << debug) - 1) & NETIF\_MSG\_DRV) \{

printk(KERN\_INFO PFX "%s, %s/n", DRV\_DESCRIPTION, DRV\_VERSION);

printk(KERN\_INFO PFX "%s/n", DRV\_COPYRIGHT);

//注册PCI

return pci\_module\_init(&e100\_driver);

其中e100\_driver对应为网卡的pci\_driver.

static struct pci\_driver e100\_driver = \{

//驱动对应的名字

.name =         DRV\_NAME,

//匹配类型

.id\_table =     e100\_id\_table,

//侦测函数

.probe =        e100\_probe,

//移除函数，设备移除时将调用此函数

.remove =       \_\_devexit\_p(e100\_remove),

\#ifdef CONFIG\_PM

.suspend =      e100\_suspend,

.resume =       e100\_resume,

\#endif

当总数探测到PCI设备符合e100\_id\_table中的参数时，将会调用e100\_probe,开始设备的初始化

在e100\_probe中：

static int \_\_devinit e100\_probe(struct pci\_dev \*pdev,

const struct pci\_device\_id \*ent)

struct net\_device \*netdev;

struct nic \*nic;

int err;

//分配net\_device并为其赋值

//alloc\_etherdev为以太网接口的net\_device分配函数。它是alloc\_netdev的封装函数

if(!(netdev = alloc\_etherdev(sizeof(struct nic)))) \{

if(((1 << debug) - 1) & NETIF\_MSG\_PROBE)

printk(KERN\_ERR PFX "Etherdev alloc failed, abort./n");

return -ENOMEM;

//对netdev中的函数指针赋初值

netdev->open = e100\_open;

netdev->stop = e100\_close;

netdev->hard\_start\_xmit = e100\_xmit\_frame;

netdev->get\_stats = e100\_get\_stats;

netdev->set\_multicast\_list = e100\_set\_multicast\_list;

netdev->set\_mac\_address = e100\_set\_mac\_address;

netdev->change\_mtu = e100\_change\_mtu;

netdev->do\_ioctl = e100\_do\_ioctl;

//支持ethtool工具时有效

SET\_ETHTOOL\_OPS(netdev, &e100\_ethtool\_ops);

netdev->tx\_timeout = e100\_tx\_timeout;

netdev->watchdog\_timeo = E100\_WATCHDOG\_PERIOD;

//轮询函数

netdev->poll = e100\_poll;

netdev->weight = E100\_NAPI\_WEIGHT;

\#ifdef CONFIG\_NET\_POLL\_CONTROLLER

netdev->poll\_controller = e100\_netpoll;

\#endif

//获得net\_device私有数据区，并对其赋值

//私有数据大小是由alloc\_etherdev（）参数中指定的

nic = netdev\_priv(netdev);

nic->netdev = netdev;

nic->pdev = pdev;

nic->msg\_enable = (1 << debug) - 1;

pci\_set\_drvdata(pdev, netdev);

//启动网卡.为之后DMA，I/O内存映射做准备

//它实际上是对PCI的控制寄存器赋值来实现的

if((err = pci\_enable\_device(pdev))) \{

DPRINTK(PROBE, ERR, "Cannot enable PCI device, aborting./n");

goto err\_out\_free\_dev;

//获取该资源相关联的标志

//如果该设备存在I/O内存，则置IORESOURCE\_MEM

if(!(pci\_resource\_flags(pdev, 0) & IORESOURCE\_MEM)) \{

DPRINTK(PROBE, ERR, "Cannot find proper PCI device "

"base address, aborting./n");

err = -ENODEV;

goto err\_out\_disable\_pdev;

//对PCI的6个寄存器都会调用资源分配函数进行申请

if((err = pci\_request\_regions(pdev, DRV\_NAME))) \{

DPRINTK(PROBE, ERR, "Cannot obtain PCI resources, aborting./n");

goto err\_out\_disable\_pdev;

//探制设备的DMA能力。如果设备支持DMA。pci\_set\_dma\_mask返回0

pci\_set\_master(pdev);

if((err = pci\_set\_dma\_mask(pdev, 0xFFFFFFFFULL))) \{

DPRINTK(PROBE, ERR, "No usable DMA configuration, aborting./n");

goto err\_out\_free\_res;

SET\_MODULE\_OWNER(netdev);

SET\_NETDEV\_DEV(netdev, &pdev->dev);

//映射设备对应的I/O。以后对设备寄存器的操作可以直接转换为对内存的操作

nic->csr = ioremap(pci\_resource\_start(pdev, 0), sizeof(struct csr));

if(!nic->csr) \{

DPRINTK(PROBE, ERR, "Cannot map device registers, aborting./n");

err = -ENOMEM;

goto err\_out\_free\_res;

if(ent->driver\_data)

nic->flags |= ich;

else

nic->flags &= ~ich;

spin\_lock\_init(&nic->cb\_lock);

spin\_lock\_init(&nic->cmd\_lock);

//设置定时器。

init\_timer(&nic->watchdog);

nic->watchdog.function = e100\_watchdog;

nic->watchdog.data = (unsigned long)nic;

init\_timer(&nic->blink\_timer);

nic->blink\_timer.function = e100\_blink\_led;

nic->blink\_timer.data = (unsigned long)nic;

//为nic->mem建立线性DMA。只是在支持ethtool的时候才有用

if((err = e100\_alloc(nic))) \{

DPRINTK(PROBE, ERR, "Cannot alloc driver memory, aborting./n");

goto err\_out\_iounmap;

//对nic成员赋初值

e100\_get\_defaults(nic);

e100\_hw\_reset(nic);

e100\_phy\_init(nic);

//读取网卡的EEPROM。其中存放着网卡的MAC地址。

//对EEPROM是通过对I/O映射内存的操作实现的，即nic->csr

if((err = e100\_eeprom\_load(nic)))

goto err\_out\_free;

//设置netdev->dev\_addr

memcpy(netdev->dev\_addr, nic->eeprom, ETH\_ALEN);

if(!is\_valid\_ether\_addr(netdev->dev\_addr)) \{

DPRINTK(PROBE, ERR, "Invalid MAC address from "

"EEPROM, aborting./n");

err = -EAGAIN;

goto err\_out\_free;

/\* Wol magic packet can be enabled from eeprom \*/

if((nic->mac >= mac\_82558\_D101\_A4) &&

(nic->eeprom\[eeprom\_id\] & eeprom\_id\_wol))

nic->flags |= wol\_magic;

pci\_enable\_wake(pdev, 0, nic->flags & (wol\_magic | e100\_asf(nic)));

//注册网络设备

if((err = register\_netdev(netdev))) \{

DPRINTK(PROBE, ERR, "Cannot register net device, aborting./n");

goto err\_out\_free;

DPRINTK(PROBE, INFO, "addr 0x%lx, irq %d, "

"MAC addr %02X:%02X:%02X:%02X:%02X:%02X/n",

pci\_resource\_start(pdev, 0), pdev->irq,

netdev->dev\_addr\[0\], netdev->dev\_addr\[1\], netdev->dev\_addr\[2\],

netdev->dev\_addr\[3\], netdev->dev\_addr\[4\], netdev->dev\_addr\[5\]);

return 0;

err\_out\_free:

e100\_free(nic);

err\_out\_iounmap:

iounmap(nic->csr);

err\_out\_free\_res:

pci\_release\_regions(pdev);

err\_out\_disable\_pdev:

pci\_disable\_device(pdev);

err\_out\_free\_dev:

pci\_set\_drvdata(pdev, NULL);

free\_netdev(netdev);

return err;

[http://blog.chinaunix.net/u1/51562/showart\_405970.html][http_blog.chinaunix.net_u1_51562_showart_405970.html]

它主要完成：对网应对应的net net\_device赋初值。并向内核调用register\_netdev完成网络设备的注册，网络设备注册我们在上一节中已经说过，这里不再赘述。

看一下net\_device中几个关键的函数：

//在设备将打开的时候，调用此函数

netdev->open = e100\_open;

//在设备停用的时候调用此函数

netdev->stop = e100\_close;

//设备发送数据的时候调用此函数

netdev->hard\_start\_xmit = e100\_xmit\_frame;

到此时，网卡的初始化工作已经完成了。之后就可以操作网卡了。

那网卡应该怎么使用呢？必须首先唤起网卡，即使之UP，例如 ifconfig eth0 up

此时，内核会根据接口名字“eth0”找到对应的net\_device.然后调用 net\_device-> open.即：e100\_open。

分析如下：

static int e100\_open(struct net\_device \*netdev)

struct nic \*nic = netdev\_priv(netdev);

int err = 0;

//网卡正在UP，关闭载波信号

netif\_carrier\_off(netdev);

if((err = e100\_up(nic)))

DPRINTK(IFUP, ERR, "Cannot open interface, aborting./n");

return err;

我们关心的是e100\_up。跟踪如下：

static int e100\_up(struct nic \*nic)

int err;

//分配收包队列

if((err = e100\_rx\_alloc\_list(nic)))

return err;

//分配控制队列

if((err = e100\_alloc\_cbs(nic)))

goto err\_rx\_clean\_list;

//硬件初始化

if((err = e100\_hw\_init(nic)))

goto err\_clean\_cbs;

//多播

e100\_set\_multicast\_list(nic->netdev);

//开始接收数据

e100\_start\_receiver(nic);

mod\_timer(&nic->watchdog, jiffies);

//注册中断例程

if((err = request\_irq(nic->pdev->irq, e100\_intr, SA\_SHIRQ,

nic->netdev->name, nic->netdev)))

goto err\_no\_irq;

//启用中断

e100\_enable\_irq(nic);

netif\_wake\_queue(nic->netdev);

return 0;

err\_no\_irq:

del\_timer\_sync(&nic->watchdog);

err\_clean\_cbs:

e100\_clean\_cbs(nic);

err\_rx\_clean\_list:

e100\_rx\_clean\_list(nic);

return err;

在此函数中，我们可以看到，它主要完成了：接立接收环形DMA缓冲区。注册了中断处理函数

关于环形DMA缓冲区接立是由e100\_rx\_alloc\_list(nic)完成的

static int e100\_rx\_alloc\_list(struct nic \*nic)

struct rx \*rx;

// nic->params.rfds.count,接收缓存的总个数

unsigned int i, count = nic->params.rfds.count;

//rx\_to\_use：正在存在数据的位置

//rx\_to\_clean：数据的初始为止。所以。数据的有限位置是从rx\_to\_use到rx\_to\_use

nic->rx\_to\_use = nic->rx\_to\_clean = NULL;

if(!(nic->rxs = kmalloc(sizeof(struct rx) \* count, GFP\_ATOMIC)))

return -ENOMEM;

memset(nic->rxs, 0, sizeof(struct rx) \* count);

//遍历并建立循环链表

for(rx = nic->rxs, i = 0; i < count; rx++, i++) \{

rx->next = (i + 1 < count) ? rx + 1 : nic->rxs;

rx->prev = (i == 0) ? nic->rxs + count - 1 : rx - 1;

if(e100\_rx\_alloc\_skb(nic, rx)) \{

e100\_rx\_clean\_list(nic);

return -ENOMEM;

//初始化起如位置为nic->rxs

nic->rx\_to\_use = nic->rx\_to\_clean = nic->rxs;

return 0;

为设备建立DMA映射的主函数为e100\_rx\_alloc\_skb().分析如下：

static inline int e100\_rx\_alloc\_skb(struct nic \*nic, struct rx \*rx)

unsigned int rx\_offset = 2; /\* u32 align protocol headers \*/

if(!(rx->skb = dev\_alloc\_skb(RFD\_BUF\_LEN + rx\_offset)))

return -ENOMEM;

/\* Align, init, and map the RFD. \*/

rx->skb->dev = nic->netdev;

//在数据存储区之前空出offset空间

skb\_reserve(rx->skb, rx\_offset);

//skb->data前部置RFD

memcpy(rx->skb->data, &nic->blank\_rfd, sizeof(struct rfd));

//DMA内存映射，映射至skb->data

rx->dma\_addr = pci\_map\_single(nic->pdev, rx->skb->data,

RFD\_BUF\_LEN, PCI\_DMA\_BIDIRECTIONAL);

/\* Link the RFD to end of RFA by linking previous RFD to

l        this one, and clearing EL bit of previous.  \*/

//初始化前一个skb中的控制信息

if(rx->prev->skb) \{

struct rfd \*prev\_rfd = (struct rfd \*)rx->prev->skb->data;

put\_unaligned(cpu\_to\_le32(rx->dma\_addr),

(u32 \*)&prev\_rfd->link);

wmb();

prev\_rfd->command &= ~cpu\_to\_le16(cb\_el);

pci\_dma\_sync\_single\_for\_device(nic->pdev, rx->prev->dma\_addr,

sizeof(struct rfd), PCI\_DMA\_TODEVICE);

return 0;

在这个函数里，主要完成了：DMA环形链表的建立。在这里涉及到了一个重要的数据结构sk\_buff.稍后再给出它的结构分析。在这里我们只要知道在skb->data里储存的是接收数据就OK了。值得一提的是，Intel 100M 网卡对接收数据的处理，跟平时遇到的网卡不一样，接收数据时会由接收控制RU写入接收信息，由此判断接收是否完全等信息。也就是我们在代码里面看到的rfd.所以，在skb->data对应的就是rfd+网络传过来的数据.

到这里，接收准备工作已经完成了。

分析一下网络设备数据结构的定义。

Linux素以优秀的网络管理能力而著称，linux为何具有这么高的效率？我们从网络设备的管理说起。

Linux为何要对网络设备单独管理呢？这是因为。协议栈很多地方都会涉及到网络设备。小至IP地址的设置。大至IP路由的更新。都离不开高效的网络设备管理。将网络设备单独管理可以提高效率！

每个网络设备，在linux中都会对应一个数据结构,net\_device。 就从这个结构说起

Linux 2。6。21中，对net\_device定义如下：

struct net\_device

//设备的名称，例如常见的“eth0”等

char          name\[IFNAMSIZ\];

//共享内存的起始，结束地址

unsigned long      mem\_end;/\* shared mem end  \*/

unsigned long      mem\_start;    /\* shared mem start    \*/

//网络设备的I/O基地址

unsigned long      base\_addr;    /\* device I/O address  \*/

//被赋予的中断号

unsigned int       irq;     /\* device IRQ number   \*/

//在多端口设备上使用哪一个端口

unsigned char      if\_port;/\* Selectable AUI, TP,..\*/

//为设备分配的DMA通道

unsigned char      dma;     /\* DMA channel         \*/

//设备的状态

unsigned long      state;

// 下一个net\_device

struct net\_device  \*next;

//初始化函数。

int           (\*init)(struct net\_device \*dev);

struct net\_device  \*next\_sched;

/\* Interface index. Unique device identifier   \*/

//设备在内核中对应的序号

int           ifindex;

int           iflink;

//获得接口状态的函数指针

struct net\_device\_stats\* (\*get\_stats)(struct net\_device \*dev);

struct iw\_statistics\*  (\*get\_wireless\_stats)(struct net\_device \*dev);

struct iw\_handler\_def \*wireless\_handlers;

struct ethtool\_ops \*ethtool\_ops;

//传输状态。检查传输是否被锁住

unsigned long      trans\_start;  /\* Time (in jiffies) of last Tx  \*/

//最使使用的时间

unsigned long      last\_rx;/\* Time of last Rx\*/

//接口标志

unsigned short         flags;   /\* interface flags (a la BSD)    \*/

unsigned short         gflags;

unsigned short          priv\_flags; /\* Like 'flags' but invisible to userspace. \*/

unsigned short          unused\_alignment\_fixer; /\* Because we need priv\_flags,

\* and we want to be 32-bit aligned.

\*/

unsigned      mtu;/\* interface MTU value      \*/

unsigned short         type;    /\* interface hardware type  \*/

unsigned short         hard\_header\_len;   /\* hardware hdr length\*/

void          \*priv;   /\* pointer to private data  \*/

struct net\_device  \*master; /\* Pointer to master device of a group,

\* which this device is member of.

\*/

/\* Interface address info. \*/

unsigned char      broadcast\[MAX\_ADDR\_LEN\];    /\* hw bcast add    \*/

unsigned char      dev\_addr\[MAX\_ADDR\_LEN\];/\* hw address\*/

unsigned char      addr\_len;/\* hardware address length  \*/

struct dev\_mc\_list\*mc\_list;/\* Multicast mac addresses  \*/

int           mc\_count;/\* Number of installed mcasts    \*/

int           promiscuity;

int           allmulti;

int           watchdog\_timeo;

struct timer\_list  watchdog\_timer;

/\* Protocol specific pointers \*/

void               \*atalk\_ptr;   /\* AppleTalk link \*/

void          \*ip\_ptr;/\* IPv4 specific data  \*/

void                    \*dn\_ptr;        /\* DECnet specific data \*/

void                    \*ip6\_ptr;       /\* IPv6 specific data \*/

void          \*ec\_ptr;/\* Econet specific data\*/

void          \*ax25\_ptr;    /\* AX.25 specific data \*/

struct list\_head   poll\_list;    /\* Link to poll list   \*/

int           quota;

int           weight;

struct Qdisc       \*qdisc;

struct Qdisc       \*qdisc\_sleeping;

struct Qdisc       \*qdisc\_ingress;

struct list\_head   qdisc\_list;

unsigned long      tx\_queue\_len;/\* Max frames per queue allowed \*/

/\* ingress path synchronizer \*/

spinlock\_t         ingress\_lock;

/\* hard\_start\_xmit synchronizer \*/

spinlock\_t         xmit\_lock;

/\* cpu id of processor entered to hard\_start\_xmit or -1,

if nobody entered there.

\*/

int           xmit\_lock\_owner;

/\* device queue lock \*/

spinlock\_t         queue\_lock;

/\* Number of references to this device \*/

atomic\_t      refcnt;

/\* delayed register/unregister \*/

struct list\_head   todo\_list;

/\* device name hash chain \*/

struct hlist\_node  name\_hlist;

/\* device index hash chain \*/

struct hlist\_node  index\_hlist;

/\* register/unregister state machine \*/

enum \{ NETREG\_UNINITIALIZED=0,

NETREG\_REGISTERING,  /\* called register\_netdevice \*/

NETREG\_REGISTERED,   /\* completed register todo \*/

NETREG\_UNREGISTERING,     /\* called unregister\_netdevice \*/

NETREG\_UNREGISTERED,/\* completed unregister todo \*/

NETREG\_RELEASED,     /\* called free\_netdev \*/

\} reg\_state;

/\* Net device features \*/

int           features;

\#define NETIF\_F\_SG     1    /\* Scatter/gather IO. \*/

\#define NETIF\_F\_IP\_CSUM     2    /\* Can checksum only TCP/UDP over IPv4. \*/

\#define NETIF\_F\_NO\_CSUM     4    /\* Does not require checksum. F.e. loopack. \*/

\#define NETIF\_F\_HW\_CSUM     8    /\* Can checksum all the packets. \*/

\#define NETIF\_F\_HIGHDMA     32   /\* Can DMA to high memory. \*/

\#define NETIF\_F\_FRAGLIST    64   /\* Scatter/gather IO. \*/

\#define NETIF\_F\_HW\_VLAN\_TX  128  /\* Transmit VLAN hw acceleration \*/

\#define NETIF\_F\_HW\_VLAN\_RX  256  /\* Receive VLAN hw acceleration \*/

\#define NETIF\_F\_HW\_VLAN\_FILTER   512  /\* Receive filtering on VLAN \*/

\#define NETIF\_F\_VLAN\_CHALLENGED  1024/\* Device cannot handle VLAN packets \*/

\#define NETIF\_F\_TSO         2048/\* Can offload TCP/IP segmentation \*/

\#define NETIF\_F\_LLTX        4096/\* LockLess TX \*/

/\* Called after device is detached from network. \*/

void          (\*uninit)(struct net\_device \*dev);

/\* Called after last user reference disappears. \*/

void          (\*destructor)(struct net\_device \*dev);

/\* Pointers to interface service routines.     \*/

//打开函数指针

int           (\*open)(struct net\_device \*dev);

//设备停用时调用此函数

int           (\*stop)(struct net\_device \*dev);

//初始化数据包的传输

int           (\*hard\_start\_xmit) (struct sk\_buff \*skb,

struct net\_device \*dev);

\#define HAVE\_NETDEV\_POLL

//轮询函数

int           (\*poll) (struct net\_device \*dev, int \*quota);

//建立硬件头信息

int           (\*hard\_header) (struct sk\_buff \*skb,

struct net\_device \*dev,

unsigned short type,

void \*daddr,

void \*saddr,

unsigned len);

//ARP解析之后，重构头部

int           (\*rebuild\_header)(struct sk\_buff \*skb);

\#define HAVE\_MULTICAST

//多播支持函数

void          (\*set\_multicast\_list)(struct net\_device \*dev);

\#define HAVE\_SET\_MAC\_ADDR

int           (\*set\_mac\_address)(struct net\_device \*dev,

void \*addr);

\#define HAVE\_PRIVATE\_IOCTL

int           (\*do\_ioctl)(struct net\_device \*dev,

struct ifreq \*ifr, int cmd);

\#define HAVE\_SET\_CONFIG

int           (\*set\_config)(struct net\_device \*dev,

struct ifmap \*map);

\#define HAVE\_HEADER\_CACHE

int           (\*hard\_header\_cache)(struct neighbour \*neigh,

struct hh\_cache \*hh);

void          (\*header\_cache\_update)(struct hh\_cache \*hh,

struct net\_device \*dev,

unsigned char \*  haddr);

\#define HAVE\_CHANGE\_MTU

int           (\*change\_mtu)(struct net\_device \*dev, int new\_mtu);

\#define HAVE\_TX\_TIMEOUT

void          (\*tx\_timeout) (struct net\_device \*dev);

void          (\*vlan\_rx\_register)(struct net\_device \*dev,

struct vlan\_group \*grp);

void          (\*vlan\_rx\_add\_vid)(struct net\_device \*dev,

unsigned short vid);

void          (\*vlan\_rx\_kill\_vid)(struct net\_device \*dev,

unsigned short vid);

int           (\*hard\_header\_parse)(struct sk\_buff \*skb,

unsigned char \*haddr);

int           (\*neigh\_setup)(struct net\_device \*dev, struct neigh\_parms \*);

int           (\*accept\_fastpath)(struct net\_device \*, struct dst\_entry\*);

\#ifdef CONFIG\_NETPOLL

int           netpoll\_rx;

\#endif

\#ifdef CONFIG\_NET\_POLL\_CONTROLLER

void                    (\*poll\_controller)(struct net\_device \*dev);

\#endif

/\* bridge stuff \*/

//对应的网桥端口（以后分析）

struct net\_bridge\_port\*br\_port;

\#ifdef CONFIG\_NET\_DIVERT

/\* this will get initialized at each interface type init routine \*/

struct divert\_blk  \*divert;

\#endif /\* CONFIG\_NET\_DIVERT \*/

/\* class/net/name entry \*/

struct class\_device    class\_dev;

/\* how much padding had been added by alloc\_netdev() \*/

int padded;

晕，太多的成员。太庞大了。不要紧，等到要使用到相应成员的时候再来解释好了。

注意到这么庞大的结构中，有个成员叫：struct net\_device  \*next,呵呵，很熟悉吧，就是用它来建立网络设备的链表。

每一个网络设备启动的时候，都会调用register\_netdev() (drivers/net/net\_init.c)

跟踪这个函数：

int register\_netdev(struct net\_device \*dev)

int err;

rtnl\_lock();

/\*

\*   If the name is a format string the caller wants us to

\*   do a name allocation

\*/

if (strchr(dev->name, '%'))

err = dev\_alloc\_name(dev, dev->name);

if (err < 0)

goto out;

/\*

\*   Back compatibility hook. Kill this one in 2.5

\*/

if (dev->name\[0\]==0 || dev->name\[0\]==' ')

err = dev\_alloc\_name(dev, "eth%d");

if (err < 0)

goto out;

err = register\_netdevice(dev);

out:

rtnl\_unlock();

return err;

跟踪至: register\_netdevice(struct net\_device \*dev)  (net/core/dev.c)

int register\_netdevice(struct net\_device \*dev)

struct hlist\_head \*head;

struct hlist\_node \*p;

int ret;

BUG\_ON(dev\_boot\_phase);

ASSERT\_RTNL();

/\* When net\_device's are persistent, this will be fatal. \*/

BUG\_ON(dev->reg\_state != NETREG\_UNINITIALIZED);

spin\_lock\_init(&dev->queue\_lock);

spin\_lock\_init(&dev->xmit\_lock);

dev->xmit\_lock\_owner = -1;

\#ifdef CONFIG\_NET\_CLS\_ACT

spin\_lock\_init(&dev->ingress\_lock);

\#endif

ret = alloc\_divert\_blk(dev);

if (ret)

goto out;

dev->iflink = -1;

/\* Init, if this function is available \*/

//如果dev -> init 被赋值，那么调用此函数

if (dev->init) \{

ret = dev->init(dev);

if (ret) \{

if (ret > 0)

ret = -EIO;

goto out\_err;

//判断name 是否合法

if (!dev\_valid\_name(dev->name)) \{

ret = -EINVAL;

goto out\_err;

//为此设备分配一个*index*

dev->ifindex = dev\_new\_index();

if (dev->iflink == -1)

dev->iflink = dev->ifindex;

/\* Check for existence of name \*/

//所有网络设备，以名字作为哈希主键存在dev\_name\_head中，该变量是一个哈希数组

//找到该名字对应的链表

//如果内核中已经含有此名字的网络设备，出错退出

head = dev\_name\_hash(dev->name);

hlist\_for\_each(p, head) \{

struct net\_device \*d

= hlist\_entry(p, struct net\_device, name\_hlist);

if (!strncmp(d->name, dev->name, IFNAMSIZ)) \{

ret = -EEXIST;

goto out\_err;

/\* Fix illegal SG+CSUM combinations. \*/

if ((dev->features & NETIF\_F\_SG) &&

!(dev->features & (NETIF\_F\_IP\_CSUM |

NETIF\_F\_NO\_CSUM |

NETIF\_F\_HW\_CSUM))) \{

printk("%s: Dropping NETIF\_F\_SG since no checksum feature./n",

dev->name);

dev->features &= ~NETIF\_F\_SG;

/\*

\*   nil rebuild\_header routine,

\*   that should be never called and used as just bug trap.

\*/

//为rebuild\_header赋默认值

if (!dev->rebuild\_header)

dev->rebuild\_header = default\_rebuild\_header;

/\*

\*   Default initial state at registry is that the

\*   device is present.

\*/

set\_bit(\_\_LINK\_STATE\_PRESENT, &dev->state);

dev->next = NULL;

dev\_init\_scheduler(dev);

write\_lock\_bh(&dev\_base\_lock);

//初始化的时候，有struct net\_device \*\*dev\_tail = &dev\_base;

//这段代码的意思实际就是：把dev加入dev\_base为首结点队链表的尾部

\*dev\_tail = dev;

dev\_tail = &dev->next;

//把此结点加入到以名字为哈希主键的链表数组dev\_name\_head中

hlist\_add\_head(&dev->name\_hlist, head);

//把此结点加到以序号为主键的链表数组dev\_index\_head中

hlist\_add\_head(&dev->index\_hlist, dev\_index\_hash(dev->ifindex));

dev\_hold(dev);

dev->reg\_state = NETREG\_REGISTERING;

write\_unlock\_bh(&dev\_base\_lock);

/\* Notify protocols, that a new device appeared. \*/

//在通知链表上发送事件

notifier\_call\_chain(&netdev\_chain, NETDEV\_REGISTER, dev);

/\* Finish registration after unlock \*/

net\_set\_todo(dev);

ret = 0;

out:

return ret;

out\_err:

free\_divert\_blk(dev);

goto out;

从此可以看出。新加入一个设备时，会插入三个位置：以名字为哈希值组织的dev\_name\_head ,以序号为主链的哈希数组dev\_index\_head.还有dev\_base.它为快速查找网络设备提供了基础。事实上。在内核中，经常要根据index找到dev. 或者根据name找到dev.我们遇到的时候再分析

到现在，我们可以在内核中顺藤摸瓜的找到每一个网络设备了。

还有很重要的。设备更改了配置，要怎么通知跟他相关的子系统呢？例如，网卡更新了IP，如何使路由得到更新？

接着往下看：

注意到上面注册代码中所调用的一个函数notifier\_call\_chain(&netdev\_chain, NETDEV\_REGISTER, dev).

该函数的作用是，在通知链表上netdev\_chain上发送NETDEV\_REGISTER消息，所有在与该通知链表关联的子系统都可以收到此消息。以此，可以快速的更新整个系统的配置消息。

以路由子系统为例，来讲述该过程：

在IPV4子系统加载的时候，加调用ip\_init(),接着调用fib\_init()，然后再调用ip\_fib\_init()

跟踪一下此函数：

void \_\_init ip\_fib\_init(void)

\#ifndef CONFIG\_IP\_MULTIPLE\_TABLES

ip\_fib\_local\_table = fib\_hash\_init(RT\_TABLE\_LOCAL);

ip\_fib\_main\_table  = fib\_hash\_init(RT\_TABLE\_MAIN);

\#else

fib\_rules\_init();

\#endif

int register\_netdevice\_notifier(struct notifier\_block \*nb)

struct net\_device \*dev;

int err;

rtnl\_lock();

//注册通知链

err = notifier\_chain\_register(&netdev\_chain, nb);

if (!err) \{

for (dev = dev\_base; dev; dev = dev->next) \{

nb->notifier\_call(nb, NETDEV\_REGISTER, dev);

if (dev->flags & IFF\_UP)

nb->notifier\_call(nb, NETDEV\_UP, dev);

rtnl\_unlock();

return err;

呵呵，它在netdev\_chain上注册了通知链，当此链上有事件发生时，会调用fib\_netdev\_notifiers中的相关信息处理，看一下fib\_netdev\_notifier的信息：

struct notifier\_block fib\_netdev\_notifier = \{

.notifier\_call =fib\_netdev\_event,

\};

OK，现在越来越具体了，如果netdev\_chain有事件，会调用fib\_netdev\_event处理。继续跟踪：

static int fib\_netdev\_event(struct notifier\_block \*this, unsigned long event, void \*ptr)

struct net\_device \*dev = ptr;

struct in\_device \*in\_dev = \_\_in\_dev\_get(dev);

//设备注销

if (event == NETDEV\_UNREGISTER) \{

fib\_disable\_ip(dev, 2);

return NOTIFY\_DONE;

if (!in\_dev)

return NOTIFY\_DONE;

switch (event) \{

//设备UP

case NETDEV\_UP:

for\_ifa(in\_dev) \{

fib\_add\_ifaddr(ifa);

\} endfor\_ifa(in\_dev);

\#ifdef CONFIG\_IP\_ROUTE\_MULTIPATH

fib\_sync\_up(dev);

\#endif

rt\_cache\_flush(-1);

break;

//设备DOWN

case NETDEV\_DOWN:

fib\_disable\_ip(dev, 0);

break;

//设备参数改变

case NETDEV\_CHANGEMTU:

case NETDEV\_CHANGE:

rt\_cache\_flush(0);

break;

return NOTIFY\_DONE;

路由部份的代码将在后续的笔记中给出。至此，整个网络设备的架构非常的清晰了！

[http_blog.chinaunix.net_u1_51562_showart_405963.html]: http://blog.chinaunix.net/u1/51562/showart_405963.html
[http_ericxiao.cublog.cn]: http://ericxiao.cublog.cn/
[http_blog.chinaunix.net_u1_51562_showart_405967.html]: http://blog.chinaunix.net/u1/51562/showart_405967.html
[http_blog.chinaunix.net_u1_51562_showart_405970.html]: http://blog.chinaunix.net/u1/51562/showart_405970.html