Leon_George
Leon_George

一文讲透Linux网络设备驱动框架及编写步骤

【摘要】本文阐述了网络架构模型，特别是Linux系统中网络子设备框架4层结构，反别阐述了各层的作用。重点讲解了sk_buff及net_device数据结构及其常用操作接口，最后以实际代码讲述了特定网卡的驱动编写步骤、流程和移植方法。

1、网卡设备驱动原理

1.1 OSI网络7层模型 VS TCP/IP网络4层模型

  • OSI网络7层模型：物理层—>数据链路层—>网络层—>传输层—>会话层—>表示层—>应用层。

一文讲透Linux网络设备驱动框架及编写步骤_第1张图片

OSI(Open System Interconnection，开放式通信互联)是由ISO(International Organization for Standardization，国际标准化组织)制定的标准模型。旨在将世界各地的各种计算机互联。然而，OSI模型过于庞大、复杂。参照此模型，技术人员开发了TCP/IP协议栈，简化OSI七层模型为TCP/IP四层模型。获得了更广泛的使用。

  • TCP/IP网络4层模型：应用层—>传输层—>网际层—>网络接口层

    一文讲透Linux网络设备驱动框架及编写步骤_第2张图片

  • Linux网络子系统：

    • Linux使用TCP/IP4层概念模型来设计其网络子系统。作为Linux网络设备驱动开发者，需要关心的是最底层（即网络接口层），其余各层Linux内核已经为你设计好了。

    • 作为网络接口层的任务，它对上要提供数据收发（数据传输单元sk_buff），对下要填充网络设备硬件信息（构建net_device结构体）。

    • Linux系统对网络设备驱动定义了4个层次， 这4个层次有到下分为:

      一文讲透Linux网络设备驱动框架及编写步骤_第3张图片

      1. 网络协议接口层：实现统一的数据包收发的协议。该层主要负责调用dev_queue_xmit()函数发送数据， netif_rx()函数接收数据。

        一文讲透Linux网络设备驱动框架及编写步骤_第4张图片

        当上层 ARP 或 IP 协议需要发送数据包时，它将调用网络协议接口层的 dev_queue_xmit()函数发送该数据包，同时需传递给该函数一个指向 struct sk_buff 数据 结构的指针。dev_queue_xmit()函数的原型为：

        int dev_queue_xmit (struct sk_buff * skb );

        同样地，上层对数据包的接收也通过向 netif_rx()函数传递一个 struct sk_buff 数据 结构的指针来完成。netif_rx()函数的原型为：

        /*通知内核一个报文已经收到并且封装到一个 socket 缓存中的函数
 * 返回值：大部分驱动忽略从 netif_rx 的返回值
 *		 NET_RX_SUCCESS表示报文成功接收
 *		 NET_RX_DROP    表示报文被丢弃
 *      (NET_RX_CN_LOW, NET_RX_CN_MOD, NET_RX_CN_HIGH )指出网络子系统的递增的拥塞级别
 */
int netif_rx(struct sk_buff *skb);	

/*告诉内核报文可用并且应当启动查询接口; 它只是被 NAPI 兼容的驱动使用*/
void netif_rx_schedule(dev);	

/* 以下两个函数应当只被 NAPI 兼容的驱动使用. netif_receive_skb 是对于 netif_rx
 * 的 NAPI 对等函数; 它递交一个报文给内核. 当一个 NAPI 兼容的驱动已处理完接收的报文，
 * 它应当重开中断, 并且调用netif_rx_complete 来停止查询
 */
int netif_receive_skb(struct sk_buff *skb);
void netif_rx_complete(struct net_device *dev);

      2. 网络设备接口层：通过net_device结构体来描述一个具体的网络设备的信息,实现不同的硬件的统一。它将协议与具有很多各种不同功能的硬件设备连接在一起。这一层提供了一组通用函数供底层网络设备驱动程序使用，让它们可以对高层协议栈进行操作。

        • 首先，设备驱动程序可能会通过调用 register_netdevice 或 unregister_netdevice 在内核中进行注册或注销。调用者首先填写 net_device 结构，然后传递这个结构进行注册。内核调用它的 init 函数（如果定义了这种函数），然后执行一组健全性检查，并创建一个 sysfs 条目，然后将新设备添加到设备列表中（内核中的活动设备链表）。
        • 要从协议层向设备中发送 sk_buff ，就需要使用 dev_queue_xmit 函数。这个函数可以对 sk_buff 进行排队，从而由底层设备驱动程序进行最终传输（使用 sk_buff 中引用的 net_device 或 sk_buff->dev 所定义的网络设备）。dev 结构中包含了一个名为 hard_start_xmit 的方法，其中保存有发起 sk_buff 传输所使用的驱动程序函数。
        • 报文的接收通常是使用 netif_rx 执行的。当底层设备驱动程序接收一个报文（包含在所分配的 sk_buff 中）时，就会通过调用 netif_rx 将 sk_buff 上传至网络层。然后，这个函数通过 netif_rx_schedule 将 sk_buff 在上层协议队列中进行排队，供以后进行处理。

      3. 设备驱动功能层：用来负责驱动网络设备硬件来完成各个功能，它通过hard_start_xmit() 函数启动发送操作， 并通过网络设备上的中断触发接收操作。

        • 在进行初始化时，设备驱动程序会分配一个 net_device 结构，然后使用必须的程序对其进行初始化。这些程序中有一个是 dev->hard_start_xmit ，它定义了上层应该如何对 sk_buff 排队进行传输。这个程序的参数为 sk_buff 。这个函数的操作取决于底层硬件，但是通常 sk_buff 所描述的报文都会被移动到硬件环或队列中。

        • 就像是设备无关层中所描述的一样，对于 NAPI 兼容的网络驱动程序来说，帧的接收使用了 netif_rx 和 netif_receive_skb 接口。NAPI 驱动程序会对底层硬件的能力进行一些限制。

        • net_device结构体的成员（属性和net_device_ops结构体中的函数指针）需要被设备驱动功能层赋予具体的数值和函数。对于具体的设备xxx，工程师应该编写相应的设备驱动功能层的函数，这些函数形如xxx_open()、xxx_stop()、xxx_tx()、xxx_hard_header()、xxx_get_stats()和xxx_tx_timeout()等。

          由于网络数据包的接收可由中断引发，设备驱动功能层的另一个主体部分将是中断处理函数，它负责读取硬件上接收到的数据包并传送给上层协议，因此可能包含xxx_interrupt()和xxx_rx()函数，前者完成中断类型判断等基本工作，后者则需完成数据包的生成及将其递交给上层等复杂工作。

          对于特定的设备，我们还可以定义相关的私有数据和操作，并封装为一个私有信息结构体xxx_private，让其指针赋值给net_device的私有成员。在xxx_private结构体中可包含设备的特殊属性和操作、自旋锁与信号量、定时器以及统计信息等，这都由工程师自定义。在驱动中，要用到私有数据的时候，则使用在netdevice.h中定义的接口：

          static inline void *netdev_priv(const struct net_device *dev);

          比如在驱动drivers/net/ethernet/davicom/dm9000.c的dm9000_probe()函数中，使用alloc_etherdev(sizeof(struct board_info))分配网络设备，board_info结构体就成了这个网络设备的私有数据，在其他函数中可以简单地提取这个私有数据。例如：

          static int dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev) 
{
    unsigned long flags;
    board_info_t *db = netdev_priv(dev);
    ...
}

      4. 网络设备与媒介层：网络设备与媒介层直接对应于实际的硬件设备。用来负责完成数据包发送和接收的物理实体, 设备驱动功能层的函数都在这物理上驱动的。

        • 网络设备的注册

        网络设备注册方式与字符驱动不同之处在于它没有主次设备号，并使用下面的函数注册

        int register_netdev(struct net_deivce*dev)
        • 网络设备的注销
        void unregister_netdev(struct net_device*dev)

1.2 网卡驱动的初始化

1.2.1 初始化网卡步骤

  • 1)使用alloc_netdev()来分配一个net_device结构体
  • 2)设置网卡硬件相关的寄存器
  • 3)设置net_device结构体的成员
  • 4)使用register_netdev()来注册net_device结构体

1.2.2 net_device结构体

网络设备接口层的主要功能是为千变万化的网络设备定义了统一、抽象的数据结构 net_device 结构体，以不变应万变，实现多种硬件在软件层次上的统一。 net_device 结构体在内核中指代一个网络设备，网络设备驱动程序只需通过填充 net_device 的具体成员并注册 net_device 即可实现硬件操作函数与内核的挂接。

net_device结构是Linux内核中所有网络设备的基础数据结构。包含网络适配器的硬件信息（中断、端口、驱动程序函数等）和高层网络协议的网络配置信息（IP地址、子网掩码等）。
每个net_device结构表示一个网络设备，如eth0、eth1…。这些网络设备通过dev_base线性表链接起来。内核变量dev_base表示已注册网络设备列表的入口点，它指向列表的第一个元素（eth0）。然后各元素用next字段指向下一个元素(eth1)。

使用ifconfig -a命令可以查看系统中所有已注册的网络设备。
net_device结构通过alloc_netdev函数分配，该函数需要三个参数：

  • 私有数据结构的大小
  • 设备名，如eth0，eth1等。
  • 配置例程，这些例程会初始化部分net_device字段。
  • 分配成功则返回指向net_device结构的指针，分配失败则返回NULL。

net_device 本身是一个巨型结构体，包含网络设备的属性描述和操作接口。当我们编写网络设备驱动程序时，只需要了解其中的一部分。

struct net_device
{
    char               name[IFNAMSIZ];      //网卡设备名称
    unsigned long      mem_end;             //该设备的内存结束地址
    unsigned long      mem_start;            //该设备的内存起始地址
    unsigned long      base_addr;            //该设备的内存I/O基地址
    unsigned int       irq;                  //该设备的中断号

    atomic_t             carrier_changes; 
    unsigned long        state; 
  
     struct list_head      dev_list; 		/*全局网络设备列表*/
     struct list_head      napi_list;		/*napi机制==napi设备的列表入口*/ 
     struct list_head      unreg_list;		/*注销网络设备的列表入口*/ 
     struct list_head      close_list; 		/*关闭的网络设备列表入口*/
	 ... 
     const struct net_device_ops *netdev_ops; /*网络设备的操作集函数*/
     const struct ethtool_ops   *ethtool_ops; /*网络管理工具相关函数集*/
    
    unsigned char      if_port;              //该字段仅针对多端口设备，用于指定使用的端口类型
    unsigned char      dma;                  //该设备的DMA通道
    unsigned long      state;                //网络设备和网络适配器的状态信息
    const struct header_ops   *header_ops; /*头部的相关操作函数集，比如创建、解析、缓冲等*/

    struct net_device_stats* (*get_stats)(struct net_device *dev); //获取流量的统计信息,运行ifconfig便会调用该成员函数,并返回一个net_device_stats结构体获取信息

    struct net_device_stats  stats;      //用来保存统计信息的net_device_stats结构体


    unsigned long         features;        //接口特征,     
    unsigned int          flags; //flags指网络接口标志,以IFF_开头，包括：IFF_UP（ 当设备被激活并可以开始发送数据包时， 内核设置该标志）、 IFF_AUTOMEDIA（设置设备可在多种媒介间切换）、IFF_BROADCAST（ 允许广播）、IFF_DEBUG（ 调试模式， 可用于控制printk调用的详细程度） 、 IFF_LOOPBACK（ 回环）、IFF_MULTICAST（ 允许组播） 、 IFF_NOARP（ 接口不能执行ARP,点对点接口就不需要运行 ARP） 和IFF_POINTOPOINT（ 接口连接到点到点链路） 等。


    unsigned        mtu;        //最大传输单元,也叫最大数据包
    unsigned short  type;   　　//接口的硬件类型
    unsigned short   hard_header_len;     //硬件帧头长度,在以太网设备的初始化函数中一般被赋为ETH_HLEN,即14

    unsigned char    *dev_addr;   //存放设备的MAC地址,需由驱动程序从硬件上读出
    unsigned char    broadcast[MAX_ADDR_LEN];    //存放设备的广播地址,对于以太网而言，地址长度为6个0XFF
	...
    /* Interface address info. */ 
     unsigned char         perm_addr[MAX_ADDR_LEN]; /*永久的硬件地址*/
     unsigned char         addr_assign_type; 
     unsigned char         addr_len; 				/*硬件地址长度。*/
	 ... 
         
    unsigned long    last_rx;    //接收数据包的时间戳,调用netif_rx()后赋上jiffies即可
	unsigned char    *dev_addr;	/*用于存放设备的硬件地址，驱动可能提供了设置MAC地址的接口，使用户设置的MAC地址等存入该成员(接口信息)*/
    
    #ifdef CONFIG_SYSFS 
     struct netdev_rx_queue  *_rx; 				/*接收队列*/
  
     unsigned int          num_rx_queues; 		/*接收队列数量*/
     unsigned int          real_num_rx_queues; 	/*当前活动的队列数量*/
  
 #endif 
	... 
   /* 
  * Cache lines mostly used on transmit path 
  */ 
     struct netdev_queue  *_tx  /*发送队列*/ ____cacheline_aligned_in_smp; 
     unsigned int          num_tx_queues; 		/*发送队列数量*/
     unsigned int          real_num_tx_queues; 	/*当前有效的发送队列数量。*/
     struct Qdisc          *qdisc; 
     unsigned long         tx_queue_len; 
     spinlock_t            tx_global_lock; 
     int               	   watchdog_timeo; 
	... 
     /* These may be needed for future network-power-down code. *
  
     /* 
      * trans_start here is expensive for high speed devices on S
      * please use netdev_queue->trans_start instead. 
      */ 
    unsigned long    trans_start;   //发送数据包的时间戳,当要发送的时候赋上jiffies即可

    int (*hard_start_xmit) (struct sk_buff *skb, struct net_device *dev);//数据包发送函数, 以使得驱动程序能获取从上层传递下来的数据包。

    void  (*tx_timeout) (struct net_device *dev); //发包超时处理函数，需采取重新启动数据包发送过程或重新启动硬件等策略来恢复网络设备到正常状态
    ... 
    struct phy_device   	*phydev; 			/*对应的PHY 设备*/
    struct lock_class_key 	*qdisc_tx_busylock; 
}

  • net_device结构可分为全局成员、硬件相关成员、接口相关成员、设备方法成员和公用成员等五个部分：

    1. 要全局成员

      char name[INFAMSIZ]    设备名，如：eh%d
unsigned long state  设备状态
unsigned long base_addr  I/O基地址
unsigned int irq   中断号

    2. 硬件相关成员

      /*硬件相关字段*/
rmem_end 接受内存尾地址
 rmem-start 接受内存首地址
mem_end 发送内存尾地址
 mem_start 发送内存首地址
base_addr 网络设备的基地址（见后图）
irq 中断号
if_port 端口号
 /*物理层上的数据*/
hard_header_length 第二层包报头长度
 mtu 最大传输单元
tx_queue_len 网络设备输出队列最大长度
type 网络适配器硬件类型
addr_len 第二层地址长度
dev_addr[MAX_ADDR_LEN] 第二层地址
broadcast[MAX_ADDR_LEN] 广播地址
*mc_list 指向具有多播第二层地址的线性表
mc_count dev_mc_list中的地址数量（多播地址数）
watchdpg_timeo 超时时间（从trans_start开始，经过watchdog_timeo时间后超时）

    3. 接口相关成员

      net_device_stats 结构体定义在内核的 include/linux/netdevice.h 文件中，其中重要成员如下所示:

      struct net_device_stats
{
    unsigned long   rx_packets;     /*收到的数据包数*/
    unsigned long   tx_packets;     /*发送的数据包数    */
    unsigned long   rx_bytes;       /*收到的字节数,可以通过sk_buff结构体的成员len来获取*/       unsigned long   tx_bytes;       /*发送的字节数,可以通过sk_buff结构体的成员len来获取*/
    unsigned long   rx_errors;      /*收到的错误数据包数*/
    unsigned long   tx_errors;      /*发送的错误数据包数*/
    ... ...
}

      net_device_stats 结构体适宜包含在设备的私有信息结构体中，而其中统计信息的 修改则应该在设备驱动的与发送和接收相关的具体函数中完成，这些函数包括中断处 理程序、数据包发送函数、数据包发送超时函数和数据包接收相关函数等。我们应该 在这些函数中添加相应的代码：

      /* 发送超时函数 */ 
void xxx_tx_timeout(struct net_device *dev) 
{ 
	struct xxx_priv *priv = netdev_priv(dev); 
	... 
	priv->stats.tx_errors++; /* 发送错误包数加 1 */ 
	... 
} 

/* 中断处理函数 */ 
static void xxx_interrupt(int irq, void *dev_id, struct pt_regs *regs) 
{ 
	switch (status &ISQ_EVENT_MASK) 
	{ 
		... 
		case ISQ_TRANSMITTER_EVENT: / 
			priv->stats.tx_packets++; /* 数据包发送成功，tx_packets 信息加1 */ 
			netif_wake_queue(dev); /* 通知上层协议 */ 
			if ((status &(TX_OK | TX_LOST_CRS | TX_SQE_ERROR | 
				TX_LATE_COL | TX_16_COL)) != TX_OK) /*读取硬件上的出错标志*/ 
			{ 
				/* 根据错误的不同情况，对 net_device_stats 的不同成员加 1 */ 
				if ((status &TX_OK) == 0) 
					priv->stats.tx_errors++; 
				if (status &TX_LOST_CRS) 
					priv->stats.tx_carrier_errors++; 
				if (status &TX_SQE_ERROR)
					priv->stats.tx_heartbeat_errors++; 
				if (status &TX_LATE_COL) 
					priv->stats.tx_window_errors++; 
				if (status &TX_16_COL) 
					priv->stats.tx_aborted_errors++; 
			} 
			break; 
		case ISQ_RX_MISS_EVENT: 
			priv->stats.rx_missed_errors += (status >> 6); 
			break; 
		case ISQ_TX_COL_EVENT: 
			priv->stats.collisions += (status >> 6); 
			break; 
	} 
}

    4. 主要设备方法

      • 需要在驱动代码中实现的接口

        /*
 * 停止接口，ifconfig eth% down时调用
 * 要注意的是ifconfig是interface config的缩写，
 * 通常我们在用户空间输入:ifconfig eth0 up  会调用这里的open函数。
 * 在用户空间输入:ifconfig eth0 down  会调用这里的stop函数。
 * 在使用ifconfig向接口赋予地址时，要执行两个任务。
 * 首先，它通过ioctl(SIOCSIFADDR)(Socket I/O Control Set Interface Address)赋予地址，
 * 然后通过ioctl(SIOCSIFFLAGS)(Socket I/O Control Set Interface Flags)
 * 设置dev->flag中的IFF_UP标志以打开接口。这个调用会使得设备的open方法得到调用。
 * 类似的，在接口关闭时，ifconfig使用ioctl(SIOCSIFFLAGS)来清理IFF_UP标志，然后调用stop函数。
 */
int (*open)(struct net_device *dev); //打开接口。ifconfig激活时，接口将被打开
int (*stop)(struct net_device *dev);  

 
int  (*init)(struct  net_device *dev)
//初始化函数，该函数在register_netdev时被调用来完成对net_device结构的初始化
    
void uninit();	//注销网络设备

void destructor();	// 当网络设备的最后一个引用refcnt被删除时调用此函数
 
int (*hard_start_xmit)(struct sk_buf*skb，struct net_device *dev)
//数据发送函数
 
void (*tx_timeout)(struct net_device *dev);  
//如果数据包发送在超时时间内失败，这时该方法被调用，这个方法应该解决失败的问题，并重新开始发送数据。
  
struct net_device_stats *(*get_stats)(struct net_device *dev);  
//当应用程序需要获得接口的统计信息时，这个方法被调用。
 
int (*set_config)(struct net_device *dev, struct ifmap *map);  
//改变接口的配置，比如改变I/O端口和中断号等，现在的驱动程序通常无需该方法。
 
int (*do_ioctl)(struct net_device *dev, struct ifmap *map);  
//用来实现自定义的ioctl命令，如果不需要可以为NULL。
 
get_stats();	//获取网络设备状态信息，这些信息以net_device_stats 结构的形式返回
get_wireless_stats(); //获取无限网络设备的状态信息，这些信息以iw_statistics 结构的形式返回

void (*set_multicast_list)(struct net_device *dev)；  
//当设备的组播列表改变或设备标志改变时，该方法被调用。
 
watchdog_timeo(); //超时处理函数

        • dev_addr使用范例：

          static int moxart_set_mac_address(struct net_device *ndev, void *addr) 
{
    struct sockaddr *address = addr;
    if (!is_valid_ether_addr(address->sa_data)) {
        return -EADDRNOTAVAIL;
    }
    memcpy(ndev->dev_addr, address->sa_data, ndev->addr_len);
    moxart_update_mac_address(ndev);
    return 0;
}

        • 网络接口标志以IFF_开头，部分标志由内核来管理，其他的在接口初始化时被设置以说明设备接口的能力和特性。flages接口标志包括：

          IFF_UP			（当设备被激活并可以开始发送数据包时，内核设置该标志）
IFF_AUTOMEDIA	（设备可在多种媒介间切换）
IFF_BROADCAST	（允许广播）
IFF_DEBUG		（调试模式，可用于控制prink调用的详细程度）
IFF_LOOPBACK	（回环）
IFF_MULTICAST	（允许组播）
IFF_NOARP		（接口不能执行ARP）
IFF_POINTOPOINT	（接口连接到点到点链路）

        • 辅助成员：trans_start、last_rx，这两个时间戳记录的都是jiffies，驱动程序应维护这两个成员。

          • trans_start记录最后的数据包开始发送时的时间戳，
          • last_rx记录最后一次接收到数据包时的时间戳，

      • 不需要接口实现的接口

      //该方法根据先前检索到的源和目的硬件地址建立硬件头
int (*hard_header)(struct sk_buff *skb, struct net_device *dev, unsigned short type, void *daddr, void *saddr, unsigned len); 

//以太网的mac地址是固定的，为了高效，第一个包去询问mac地址，得到对应的mac地址后就会作为cache把mac地址保存起来。以后每次发包不用询问了，直接把包的地址拷贝出来。
int (*rebuild_header)(struct sk_buff *skb);

//如果接口支持mac地址改变，则可以实现该函数。
int (*set_mac_address)(struct net_device *dev, void *addr);  

hard_header_cache(); 	//用硬报头缓存中保存的数据填充第二层报头
header_cache_update(); 	//更改硬报头缓存中保存的第二层报头数据
hard_header_parse(); 	//从套接字缓冲区的包数据空间读取第二层报头的发送地址
change_mtu(); 			//改变mtu长度
  1. net_device相关操作函数

    1. 分配

    #define alloc_netdev(sizeof_priv, name, name_assign_type, setup) \
    alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, 1, 1)

    
- 参数

  - @	sizeof_priv：私有数据块大小。 
- @	name：设备名字
  - @	setup：回调函数，初始化设备的设备后调用此函数
  - @	txqs：分配的发送队列数量
  - @	rxqs：分配的接收队列数量

- 返回值

  - 如果申请成功的话就返回申请到的 net_device指针，失败的话就返回NULL。

- 可以看出alloc_netdev的本质是`alloc_netdev_mqs`函数

  ```c
struct net_device  * alloc_netdev_mqs ( int sizeof_priv, const char *name,\   
                    void (*setup) (struct net_device *)),
                    unsigned int  txqs, unsigned int rxqs); 
  ```

- 网络设备有多种，比如光纤分布式数据接口(FDDI)、以太网设备(Ethernet)、红外数据接口(InDA)、高性能并行接口(HPPI)、CAN 网络等。本文所讲的以太网只是其中一种，且有专门的分配函数:

  ```c
#define alloc_etherdev(sizeof_priv)  alloc_etherdev_mq(sizeof_priv, 1) 
   
  #define alloc_etherdev_mq(sizeof_priv, count) alloc_etherdev_mqs(sizeof_priv, count, count)
  ```

  - alloc_etherdev 最终依靠的是 alloc_etherdev_mqs 函数:

    ```c
  struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs, unsigned int rxqs) 
     { 
    	return alloc_netdev_mqs(sizeof_priv, "eth%d",\
                                NET_NAME_UNKNOWN,ether_setup, txqs, rxqs);
     } 
    ```

2. **初始化**

- 对于以太网设备，内核提供了`ether_setup`函数，对 net_device做初步的初始化

  ```c
void ether_setup(struct net_device *dev) 
   { 
      dev->header_ops       = ð_header_ops; 
      dev->type           = ARPHRD_ETHER; 
      dev->hard_header_len = ETH_HLEN; 
      dev->mtu              = ETH_DATA_LEN; 
      dev->addr_len         = ETH_ALEN; 
      dev->tx_queue_len     = 1000; /* Ethernet wants good queues */
      dev->flags          = IFF_BROADCAST|IFF_MULTICAST; 
      dev->priv_flags       |= IFF_TX_SKB_SHARING; 
    
      eth_broadcast_addr(dev->broadcast); 
   } 
  ```

3. **释放**

- 注销网络驱动的时候需要释放掉前面已经申请到的 net_device

  ```c
void free_netdev(struct net_device *dev);
  ```

4. **注册/注销**

- net_device申请并初始化完成以后就需要向内核注册net_device，当设备拔出或模块卸载时要注销net_device，用到以下函数

  ```c
int register_netdev(struct net_device *dev);
  void unregister_netdev(struct net_device *dev);
  ```

5. **net_device_ops**

```c
/*
@	定义在 include/linux/netdevice.h 文件中
@	net_device_ops结构体里面都是一些以“ndo_”开头的函数，这些函数就需要网络驱动编写人员去实现
@	net_device_ops 结构体 
*/
struct net_device_ops { 
      int (*ndo_init)(struct net_device *dev); /*当第一次注册网络设备的时候此函数会执行*/
      void (*ndo_uninit)(struct net_device *dev); /*卸载网络设备的时候此函数会执行*/
      int (*ndo_open)(struct net_device *dev); /*打开网络设备的时候此函数会执行，网络驱动程序需要实现此函数，非常重要*/
      int (*ndo_stop)(struct net_device *dev); 
      netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb, 
                             struct net_device *dev); /*当需要发送数据的时候此函数就会执行，此函数有一个参数为 sk_buff结构体指针，sk_buff结构体在Linux的网络驱动中非常重要，sk_buff保存了上层传递给网络驱动层的数据。也就是说，要发送出去的数据都存在了sk_buff中*/
      u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb, void *accel_priv,select_queue_fallback_t fallback); /*设备支持多传输队列的时候选择使用哪个队列*/
      void (*ndo_change_rx_flags)(struct net_device *dev, 
                                 int flags); 
      void (*ndo_set_rx_mode)(struct net_device *dev);/*此函数用于改变地址过滤列表*/ 
      int  (*ndo_set_mac_address)(struct net_device *dev,  void *addr); /*此函数用于修改网卡的 MAC 地址*/
      int  (*ndo_validate_addr)(struct net_device *dev); /*验证 MAC 地址是否合法，*/
      int  (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd); /*用户程序调用 ioctl 的时候此函数就会执行，*/
      int  (*ndo_set_config)(struct net_device *dev, struct ifmap *map); 
      int  (*ndo_change_mtu)(struct net_device *dev, int new_mtu); /*更改MTU大小。*/
      int  (*ndo_neigh_setup)(struct net_device *dev, struct neigh_parms *); 
     void  (*ndo_tx_timeout) (struct net_device *dev); /*当发送超时的时候产生会执行，一般都是网络出问题了导致发送超 */
	... 
 #ifdef CONFIG_NET_POLL_CONTROLLER 
     void (*ndo_poll_controller)(struct net_device *dev); /*使用查询方式来处理网卡数据的收发*/
     int (*ndo_netpoll_setup)(struct net_device *dev, struct netpoll_info *info); 
     void (*ndo_netpoll_cleanup)(struct net_device *dev); 
 #endif 
	... 
     int (*ndo_set_features)(struct net_device *dev, etdev_features_t features); /*修改net_device的 features属性，设置相应的硬件属性*/
	... 
 };
    • ndo_open()函数的作用是打开网络接口设备，获得设备需要的I/O地址、IRQ、DMA通道等。一般驱动函数会在此函数中做如下工作：
    • 使能网络外设时钟、申请网络所使用的环形缓冲区、初始化MAC 外设、绑定接口对应的 PHY、如果使用NAPI 的话要使能NAPI模块，通过 napi_enable函数来使能、开启PHY、调用netif_tx_start_all_queues来使能传输队列，也可能调用netif_start_queue函数。
    • ndo_stop()函数的作用是停止网络接口设备，与open()函数的作用相反。关闭网络设备的时候此函数会执行，网络驱动程序也需要实现此函数。一般驱动函数会在此函数中做如下工作：
      • 停止PHY、停止NAPI功能、停止发送功能、关闭MAC、断开PHY 连接、关闭网络时钟、释放数据缓冲区。
    • int (*ndo_start_xmit) (struct sk_buff *skb, struct net_device *dev);
      • ndo_start_xmit()函数会启动数据包的发送，当系统调用驱动程序的xmit函数时，需要向其传入一个sk_buff结构体指针，以使得驱动程序能获取从上层传递下来的数据包。
    • void (*ndo_tx_timeout) (struct net_device *dev);
      • 当数据包的发送超时时，ndo_tx_timeout()函数会被调用，该函数需采取重新启动数据包发送过程或重新启动硬件等措施来恢复网络设备到正常状态。
    • struct net_device_status* (*ndo_get_stats)(struct net_device *dev);
    • ndo_get_status()函数用于获得网络设备的状态信息，它返回一个net_device_stats结构体指针。
      • net_device_stats结构体保存了详细的网络设备流量统计信息，如发送和接收的数据包数、字节数等。
    • int (*ndo_do_ioctl) (struct net_device *dev, struct ifreq *ifr, int cmd);
      • 函数用于进行设备特定的I/O控制。
    • int (*ndo_set_config) (struct net_device *dev, struct ifmap *map);
      • 用于配置接口，也可用于改变设备的I/O地址和中断号。
    • int (*ndo_set_mac_address) (struct net_device *dev, void *adddr);
      • 用于设置设备的MAC地址。

    1. ethool_ops

    const struct ethtool_ops *ethool_ops;

    
- ethool\_ops成员函数与用户空间ethool工具的各个命令选项对应，ethool提供了网卡及网卡驱动管理能力，能够为Linux网络开发人员和管理人员提供对网卡硬件、驱动程序和网络协议栈的设置、查看以及调试等功能。

7. **header_ops**

```c
const struct header_ops *header_ops;
    • header_ops对应于硬件头部操作，主要是完成创建硬件头部和从给定的sk_buff分析出硬件头部等操作。

1.2.3 sk_buff结构体

sk_buff 结构体非常重要，它的含义为“套接字缓冲区”，用于在 Linux 网络子系 统中的各层之间传递数据，是 Linux 网络子系统数据传递的“中枢神经”。

当发送数据包时，Linux 内核的网络处理模块必须建立一个包含要传输的数据包 的 sk_buff，然后将 sk_buff 递交给下层，各层在 sk_buff 中添加不同的协议头直至交 给网络设备发送。

同样地，当网络设备从网络媒介上接收到数据包后，它必须将接收 到的数据转换为 sk_buff 数据结构并传递给上层，各层剥去相应的协议头直至交给用 户。

一个套接字缓存由两部份组成：

  1. 报文数据：存储实际需要通过网络发送和接收的数据。
  2. 管理数据（struct sk_buff）：管理报文所需的数据，在sk_buff结构中有一个head指针指向内存中报文数据开始的位置，有一个data指针指向报文数据在内存中的具体地址。head和data之间申请有足够多的空间用来存放报文头信息。

参看 linux/skbuff.h 中的源代码，sk_buff 结构体包含的主要成员如下：

  • 定义
/*  */
struct sk_buff {
    union 
    {
        struct 
        {
             /* These two members must be first. */
             struct sk_buff *next; //指向下一个 sk_buff 结构体
             struct sk_buff *prev; //指向前一个 sk_buff 结构体
             union { 
                  ktime_t         tstamp; /*数据包接收时或准备发送时的时间戳*/
                  struct skb_mstamp skb_mstamp; 
             };
        };
        struct rb_node  rbnode; /* used in netem & tcp stack */           
    };
    struct sock         *sk; /*当前 sk_buff所属的Socket*/
    struct net_device     *dev; /*当前 sk_buff从哪个设备接收到或者发出的*/
   
    char cb[48] __aligned(8); /*cb 为控制缓冲区，不管哪个层都可以自由使用此缓冲区，用于放置私有数据。 */
   
    unsigned long   _skb_refdst; 
    void  (*destructor)(struct sk_buff *skb); /*当释放缓冲区的时候可以在此函数里面完成某些动作*/
	.... 
        
    unsigned int	len;		//数据包的总长度，数据区的长度（tail-data）与分片结构体数据区的长度之和。 
    unsigned int    data_len;   //表示分片结构体数据区的长度(len=(tail - data) + data_len) 
    __u16           mac_len;    // mac报头的长度 
    __u16           hdr_len;    // 用于clone时，表示clone的skb的头长度 
    ...
    __u32           priority;    // 当前 sk_buff 结构体的优先级，主要用于QOS
    ...
    __be16          protocol;    // 包的协议类型，标识是IP包还是ARP包还是其他数据包，可以通过 eth_type_trans()来获取
    ...
    __be16          inner_protocol;
    __u16           inner_transport_header;    
    __u16           inner_network_header;    
    __u16           inner_mac_header;    
    __u16           transport_header;   // 指向传输层包头
    __u16           network_header;     // 指向传输层包头
    __u16           mac_header;    		// 指向链路层包头
    
    /* private: */ 
     __u32               headers_end[0]; /*缓冲区的尾部*/
    
    /* public: 
     * These elements must be at the end, see alloc_skb() for details. 
     */
    sk_buff_data_t      tail;			// 缓冲区的数据包末尾位置
    sk_buff_data_t      end;    		// 缓冲区的结束地址
    unsigned char       *head,    		// 缓冲区的开始地址
    unsigned char		*data;    		// 缓冲区的数据包开始位置
	unsigned int        truesize; 
    atomic_t            users; 
};
  1. 数据缓冲区指针 head、data、tail 和 end。

head 指针指向内存中已分配的用于承载网络数据的缓冲区的起始地址;

data 指针则指向对应当前协议层有效数据的起始地址。各层的有效数据信息包含的内容都不一样：对于传输层而言，用户数据和传输层协议头属于有效数据。 l 对于网络层而言，用户数据、传输层协议头和网络层协议头是其有效数据。 l 对于数据链路层而言，用户数据、传输层协议头、网络层协议头和链路层头 部都属于有效数据。 因此，data 指针的值需随着当前拥有 sk_buff 的协议层的变化进行相应的移动。

tail 指针则指向对应当前协议层有效数据负载的结尾地址，与 data 指针对应。

end 指针指向内存中分配的数据缓冲区的结尾，与 head 指针对应。

其实，end 指针所指地 址 数 据 缓 冲 区 的 末 尾 还 包 括 一 个 skb_shared_info 结构体的空间，这个结构体 存放分隔存储的数据片段，意味着可以将数 据包的有效数据分成几片存储在不同的内存空间中。 每一个分片frags的长度上限是一页。

  • sk_buff结构体的空间

    一文讲透Linux网络设备驱动框架及编写步骤_第5张图片

  1. 长度信息 len、data_len、truesize。

len是指数据包有 效数据的长度，包括协议头和负载；

data_len 这个成员，它记录分片的 数据长度；

truesize 表示缓存区的整体长度: sizeof(struct sk_buff) + “传入 alloc_skb()或dev_alloc_skb()的长度“（但不包括结构体 skb_shared_info 的长度）。

  • sk_buff-> data数据包格式

一文讲透Linux网络设备驱动框架及编写步骤_第6张图片

  1. 套接字缓冲区操作

    1. 分配

      • 函数原型

        struct sk_buff *alloc_skb(unsigned int len, gfp_t priority);

struct sk_buff *dev_alloc_skb(unsigned len);
        • 参数：
          • len：缓冲区大小，通常以L1_CACHE_BYTES字节(对于ARM为32)对齐
          • priority：内存分配优先级，为GFP MASK宏，比如GFP_KERNEL、GFP_ATOMIC 等
        • 返回值：成功则返回分配好的sk_buff指针；失败则返回NULL。
        • 区别：
          • alloc_skb 函数分配一个缓存并且将 skb->data 和skb->tail 都初始化成 skb->head。
          • dev_alloc_skb函数表示以GFP_ATOMIC 优先级（代表分配过程不能被中断）调用 alloc_skb 的快捷方法, 并且在 skb->head 和skb->data 之间保留了一些空间用于网络层之间的优化(16 个字节)，驱动不要管它。
          • 分配成功之后，因为还没有存放具体的网络数据包，所以 sk_buff 的 data、tail 指 针都指向存储空间的起始地址 head，而 len 的大小则为 0。

    2. 释放

      • 函数原型

        void kfree_skb(struct sk_buff *skb); 	//在内核内部使用，而网络设备 驱动程序中则必须使用下面3个其一
void dev_kfree_skb(struct sk_buff *skb); //用于非中断上下文
void dev_kfree_skb_irq(struct sk_buff *skb); //用于中断上下文
void dev_kfree_skb_any(struct sk_buff *skb); //在中断和非中断上下文中皆可采用
        • 参数：
          • skb：待释放的套接字缓冲区
        • 返回值：无
        • 区别：
          • kfree_skb 由内核在内部使用，驱动应当使用其中一种变体:
          • 在非中断上下文中使用 dev_kfree_skb；
          • 在中断上下文中使用 dev_kfree_skb_irq；
          • dev_kfree_skb_any 在任何2 种情况下。

  2. 空间调整

  • 套接字缓冲区中的数据缓冲区指针移动操作包括 put（放置）、push（推）、 pull（拉）、reserve（保留）等。无前导__的函数会检查数据大小是否适合缓存, 而有前导__的函数会省略这个检查。

    • put 操作（用于在缓冲区尾部添加数据）：

      unsigned char *skb_put(struct sk_buff *skb, unsigned int len); //会检测放入缓冲区的数据
unsigned char *__skb_put(struct sk_buff *skb, unsigned int len); //不会检测放入缓冲区的数据

      • 上述函数将 tail 指针下移，增加 sk_buff 的 len 值，并返回 skb->tail 的当前值。

        一文讲透Linux网络设备驱动框架及编写步骤_第7张图片

    • push 操作（用于在数据包发送时添加头部）

      unsigned char *skb_push(struct sk_buff *skb, unsigned int len); //会检测放入缓冲区的数据
unsigned char *_ _skb_push(struct sk_buff *skb, unsigned int len); //不会检测放入缓冲区的数据

      • 在缓冲区尾部增加数据，会导致skb->tail后移len(skb->tail += len)，而skb->len会增加len的大小(skb->len += len)。通常，在设备驱动的接收数据处理中会调用此类函数。

        一文讲透Linux网络设备驱动框架及编写步骤_第8张图片

    • pull 操作（用于下层协议向上层协议移交数据包，使 data 指针指向上一层协议的协议头）

      unsigned char * skb_pull(struct sk_buff *skb, unsigned int len);

      • 从数据区头部删除数据，它会将skb->data后移len，同时保持skb->tail不变。执行skb->data -= len、skb->len -= len。

        一文讲透Linux网络设备驱动框架及编写步骤_第9张图片

    • reserve 操作（用于在存储空间 的头部预留 len 长度的空隙）

      void skb_reserve(struct sk_buff *skb, unsigned int len);
      • 它会将skb->data和skb->tail同时后移len，执行skb->data += len、skb->tail += len。

    • 使用举例

      • 分配一个全新的sk_buff，接着调用skb_reserve()腾出头部空间，之后调用skb_put()腾出数据空间，然后把数据复制进来，最后把sk_buff传给协议栈。

        skb = alloc_skb(len + headspace, GFP_KERNEL);
skb_reserve(skb, headspace);
memcpy(skb_put(skb, len), data, len);
pass_to_m_protocol(skb);

1.3 网卡驱动发包过程

在内核中,当上层要发送一个数据包时, 就会调用网络设备层里net_device数据结构的成员hard_start_xmit()将数据包发送出去。

hard_start_xmit()发包函数需要我们自己构建,该函数原型如下所示:

int (*hard_start_xmit) (struct sk_buff *skb, struct net_device *dev);

这个函数中需要涉及到sk_buff结构体,含义为(socket buffer)套接字缓冲区,用来网络各个层次之间传递数据.

发包函数处理步骤：

  • 1、把数据包发出去之前,需要使用**netif_stop_queue()**来停止上层传下来的数据包；

  • 2.1、设置寄存器，通过网络设备硬件来发送数据

  • 2.2、当数据包发出去后, 再调用dev_kfree_skb()函数来释放sk_buff,该函数原型如下:void dev_kfree_skb(struct sk_buff *skb);

  • 3、当数据包发出成功,就会进入TX接收中断函数，然后更新统计信息，调用**netif_wake_queue()**来唤醒，启动上层继续发包下来；

  • 4、若数据包发出去超时，一直进不到TX中断函数,就会调用net_device结构体的*tx_timeout超时成员函数，在该函数中更新统计信息，并调用netif_wake_queue()来唤醒。

1.4 网卡驱动收包过程

接收数据包主要是通过中断函数处理,来判断中断类型，如果等于ISQ_RECEIVER_EVENT表示为接收中断,然后进入接收数据函数,通过netif_rx()将数据上交给上层。例如，下图内核中自带的网卡驱动:/drivers/net/cs89x0.c

static irqreturn_t net_interupt(int irq, void *dev_id)
{
	struct net_device *dev = dev_id;
    struct net_local *lp;
    int ioaddr,status;
    int handler = 0;
    
    ioaddr = dev->base_addr;
    ip = netdev_priv(dev);
    
    while((status = readword(dev->base_addr,ISO_PORT))){
        if(net_debug > 4)
            printk("%s:event=%04x\n",dev->name,status);
        handled = 1;
        switch(status&ISO_EVENT_MASK){
            case ISO_RECEIVER_EVENT:	//判断是否为接收中断
                net_rx(dev);			//进入net_rx()函数，将接收的数据上交给上层
                break;
            case ISO_TRANSMITTER_EVENT:	//判断是否为发送中断
                ip->stats.tx_packets++;
                netif_wake_queue(dev);
                ...
        }
    }
}

通过获取的status标志来判断是什么中断,如果是接收中断,就进入net_rx()。

  • 收包函数处理步骤：
    • 1、使用dev_alloc_skb()来构造一个新的sk_buff；
    • 2、使用skb_reserve(rx_skb, 2) 将sk_buff缓冲区里的数据包先向后位移2字节，腾出sk_buff缓冲区里的头部空间；
    • 3、读取网络设备硬件上接收到的数据；
    • 4、使用memcpy()将数据复制到新的sk_buff里的data成员指向的地址处,可以使用skb_put()来动态扩大sk_buff结构体里中的数据区；
    • 5、使用eth_type_trans()来获取上层协议,将返回值赋给sk_buff的protocol成员里；
    • 6、然后更新统计信息，最后使用netif_rx( )来将sk_fuffer传递给上层协议中。
  • skb_put()函数
    • 原型：static inline unsigned char *skb_put(struct sk_buff *skb, unsigned int len);
    • 作用：将数据区向下扩大len字节
    • sk_buff缓冲区变化图：
    • 一文讲透Linux网络设备驱动框架及编写步骤_第10张图片

1.5 网卡驱动的注册与注销

网络设备驱动的注册与注销使用成对出现的register_netdev()和unregister_netdev() 函数完成，这两个函数的原型为：

int register_netdev(struct net_device *dev); 
void unregister_netdev(struct net_device *dev);

这两个函数都接收一个 net_device 结构体指针为参数， net_device 的生成和成员的赋值并非一定要由工程师逐个亲自动手完成，可以利 用下面的函数帮助我们填充：

struct net_device *alloc_netdev(int sizeof_priv, const char *name,  
                                void(*setup)(struct net_device*));  

struct net_device *alloc_etherdev(int sizeof_priv)
{ 
	/* 以 ether_setup 为 alloc_netdev 的 setup 参数 */ 
    return alloc_netdev(sizeof_priv, "eth%d", ether_setup); 
}

alloc_netdev()函数生成一个 net_device 结构体，对其成员赋值并返回该结构体的指针。第一个参数为设备私有成员的大小，第二个参数为设备名，第三个参数为 net_device 的 setup()函数指针。setup()函数接收的参数也为 net_device 指针，用 于预置 net_device 成员的值。

alloc_etherdev()是 alloc_netdev()针对以太网的“快捷”函数，其中的ether_setup()是由 Linux 内核提供的一个对以太网设备 net_device 结构体中公有成员 快速赋值的函数

释放 net_device 结构体 的函数为：

void free_netdev(struct net_device *dev);

1.6 NAPI

  • Linux 里面的网络数据接收也轮询和中断两种：

    1. 通常情况下，网络设备驱动以中断方式接收数据包。中断的好处就是响应快，数据量小的时候处理及时，速度、快，但是一旦当数据量大，而且都是短帧的时候会导致中断频繁发生，消耗大量的CPU处理时间在中断自身处理上。
    2. 而poll_controller()则采用纯轮询方式。轮询恰好相反，响应没有中断及时，但是在处理大量数据的时候不需要消耗过多的CPU 处理时间。

  • linux在这两个处理方式的基础上，提出了另外一种高效的网络数据接收的处理方法：NAPI(New API)：

    • 核心思想：中断（用来唤醒数据接收服务程序）+ 轮询（在接受服务程序中采用POLL的方法来轮询处理数据）
    • 其数据接收流程为：“接收中断来临->关闭接收中断->以轮询方式接收所有数据包直到收空->开启接收中断->接收中断来临……”

  • NAPI相关的操作接口

    1. 添加/移除NAPI调度

      /*初始化NAPI
@	定义在 net/core/dev.c中
@	初始化一个 napi_struct实例
@	dev：每个NAPI 必须关联一个网络设备，此参数指定NAPI要关联的网络设备。
@	napi：要初始化的 NAPI实例
@	poll： NAPI所使用的轮询函数，非常重要，一般在此轮询函数中完成网络数据接收的工作。
@	weight：NAPI默认权重(weight)，一般为NAPI_POLL_WEIGHT。 
@	返回值：无。
*/
void netif_napi_add(struct net_device *dev, struct napi_struct *napi, 
                    int (*poll)(struct napi_struct *, int), 
                    int weight);

void netif_napi_del(struct napi_struct *napi);
      • poll参数是NAPI要调度执行的轮询函数。

    2. 使能和禁止NAPI调度

       /*  使能/失能NAPI 
 @	n：要使能/失能的NAPI
 @	返回值：无。 
 */
static inline void napi_enable(struct napi_struct *n);
static inline void napi_disable(struct napi_struct *n);

    3. 调度轮询实例的运行

      /*NAPI调度 
@	n：要调度的NAPI。 
@	返回值：无。 
*/
void __napi_schedule(struct napi_struct *n) 

/*是否可以调度+调度 
@	n：要调度的NAPI。 
*/
 static inline void napi_schedule(struct napi_struct *n) 
 { 
     if (napi_schedule_prep(n)) 
         __napi_schedule(n); 
 }

    4. NAPI处理完成的时候应该调用

      /*
@	n：处理完成的NAPI。
@	返回值：无。 
*/
void napi_complete(struct napi_struct *n);

2、编写虚拟网卡驱动

虚拟网卡驱动,也就是说不需要硬件相关操作,所以就没有中断函数,我们通过linux的ping命令来实现发包,然后在发包函数中伪造一个收的ping包函数,实现能ping通任何ip地址。编写步骤：

  1. 初始化（init）

设备探测工作在init方法中进行，一般调用一个称之为probe方法的函数

初始化的主要工作时检测设备，配置和初始化硬件，最后向系统申请这些资源。此外填充该设备的dev结构，我们调用内核提供的ether_setup方法来设置一些以太网默认的设置。

流程：

（1）定义一个net_device结构体变量

（2）使用函数 alloc_netdev()分配一个 net_device 结构体变量

（3）初始化化硬件寄存器

（4）设置net_device结构体变量成员变量

（5） 使用register_netdev()注册 net_device结构体变量

  1. 打开(open)

open这个方法在网络设备驱动程序里是网络设备被激活时被调用（即设备状态由down变成up）

实际上很多在初始化的工作可以放到这里来做。比如说资源的申请，硬件的激活。如果dev->open返回非0，则硬件状态还是down，
注册中断、DMA等；设置寄存器，启动设备；启动发送队列

一般注册中断都在init中做，但在网卡驱动程序中，注册中断大部分都是放在open中注册，因为要经常关闭和重启网卡

  1. 关闭(stop)

stop方法做和open相反的工作

可以释放某些资源以减少系统负担

stop是在设备状态由up转为down时被调用

  1. 发送（hard_start_xmit）

在系统调用的驱动程序的hard_start_xmit时，发送的数据放在一个sk_buff结构中。一般的驱动程序传给硬件发出去。也有一些特殊的设备比如说loopback把数据组成一个接收数据在传送给系统或者dummy设备直接丢弃数据。如果发送成功,hard_start_xmit方法释放sk_buff。如果设备暂时无法处理，比如硬件忙，则返回1。

发包函数ndo_start_xmit 中具体要做

（1）调用函数 netif_stop_queue()停止上层下传数据。

（2）通过硬件发送数据。

（3）调用函数 dev_kfree_skb()释放 sk_buff。

（4） 发送成功进入中断时，更新统计信息，调用netif_wake_queue()，使上层继续下发数据

（5）发送超时则在net_device_ops 中的ndo_tx_timeout 函数中调用 netif_wake_queue()函数， 使上层继续下发数据。

#define dev_kfree_skb(a)	consume_skb(a)
void consume_skb(struct sk_buff *skb)
    
static inline void netif_wake_queue(struct net_device *dev);

static inline void netif_stop_queue(struct net_device *dev);
  1. 接收

驱动程序并存在一个接受方法。当有数据收到时驱动程序调用netif_rx函数将skb交交给设备无关层。

一般设备收到数据后都会产生一个中断，在中断处理程序中驱动程序申请一块sk_buff(skb)从硬件中读取数据位置到申请号的缓冲区里。

接下来填充sk_buff中的一些信息。

中断有可能是收到数据产生也可能是发送完成产生，中断处理程序要对中断类型进行判断，如果是收到数据中断则开始接收数据，如果是发送完成中断，则处理发送完成后的一些操作，比如说重启发送队列。
接收流程：
（1）使用 alloc_skb()函数极造一个 sk_buff。

（2）使用skb_reserve(sk_buff,2)把sk_buff 里数据包先后位移2 字节以腾出sk_buff里头部空间。

（3）读取网络设备硬件上接收到的数据，把数据复制到 sk_buff 的成员 data 挃针。

（4）使用eth_type_trans()函数来获取上层协议，将返回值赋给sk_buff的成员protocol。

（5）更新统计信息，最后使用netif_rx()将sk_buff上传到上层协议。

  1. 中断处理

网络接口通常支持3种类型的中断：新报文到达中断、报文发送完成中断和出错中断。中断处理程序可通过查看网卡的中断状态寄存器，来分辨出中断类型。

  • 具体代码

/*
 * 参考 drivers\net\cs89x0.c
 */

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

#include 
#include 
#include 

static struct net_device *vnet_dev;

static void emulator_rx_packet(struct sk_buff *skb, struct net_device *dev)
{
	/* 参考LDD3 */
	unsigned char *type;
	struct iphdr *ih;
	__be32 *saddr, *daddr, tmp;
	unsigned char	tmp_dev_addr[ETH_ALEN];
	struct ethhdr *ethhdr;
	
	struct sk_buff *rx_skb;
		
	/* 1.对调ethhdr结构体的"源/目的"的mac地址 */
	ethhdr = (struct ethhdr *)skb->data;
	memcpy(tmp_dev_addr, ethhdr->h_dest, ETH_ALEN);
	memcpy(ethhdr->h_dest, ethhdr->h_source, ETH_ALEN);
	memcpy(ethhdr->h_source, tmp_dev_addr, ETH_ALEN);

	/* 2.对调iphdr结构体的"源/目的"的ip地址 */    
	ih = (struct iphdr *)(skb->data + sizeof(struct ethhdr));
	saddr = &ih->saddr;
	daddr = &ih->daddr;

	tmp = *saddr;
	*saddr = *daddr;
	*daddr = tmp;
	
	/* 3.使用ip_fast_csum()来重新获取iphdr结构体的校验码*/
	ih->check = 0;		   /* and rebuild the checksum (ip needs it) */
	ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl);
	
	/* 4.设置数据类型*/
	type = skb->data + sizeof(struct ethhdr) + sizeof(struct iphdr);
	*type = 0; /*原来0x8表示发送ping包，现在0表示接收ping包 */
	
	/* 5.构造一个新的sk_buff */
	rx_skb = dev_alloc_skb(skb->len + 2);
	
	/* 6.使用skb_reserve腾出2字节头部空间*/
	skb_reserve(rx_skb, 2); /* align IP on 16B boundary */	
	
	/* 7.将之前修改好的sk_buff->data复制到新的sk_buff里 */
	memcpy(skb_put(rx_skb, skb->len), skb->data, skb->len);	//用skb_put()扩大sk_buff的数据区，避免溢出

	/* 8.设置新sk_buff的其它成员*/
	rx_skb->dev = dev;
	rx_skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
	
	/* 9.使用eth_type_trans()来获取上层协议 */
	rx_skb->protocol = eth_type_trans(rx_skb, dev);
	
	/* 10.更新接收统计信息,并向上层传递sk_fuffer收包 */
	dev->stats.rx_packets++;
	dev->stats.rx_bytes += skb->len;
    dev->last_rx = jiffies;		//收包时间戳

	// 提交sk_buff
	netif_rx(rx_skb);
}

static int virt_net_send_packet(struct sk_buff *skb, struct net_device *dev)
{
	static int cnt = 0;
	printk("virt_net_send_packet cnt = %d\n", ++cnt);

	/* 1.停止该网卡的队列，阻止上层向驱动层继续发送数据包 */
	netif_stop_queue(dev); 
	
    /* 2.真实驱动要把skb的数据写入网卡 ，但在此先通过emulator_rx_packet模拟 */
	emulator_rx_packet(skb, dev);	/* 构造一个假的sk_buff,上报 */

	/* 3.释放发送的sk_buff缓存区*/
	dev_kfree_skb (skb);
	
	/* 4.更新统计信息 */
	dev->stats.tx_packets++;
	dev->stats.tx_bytes += skb->len;
    dev->trans_start = jiffies;	//发送时间戳
	
	/* 5.数据全部发送出去后,唤醒网卡的队列 （真实网卡应在中断函数里唤醒）*/
	netif_wake_queue(dev); 
	
	return 0;
}


static const struct net_device_ops vnetdev_ops = {
	.ndo_start_xmit		= virt_net_send_packet,
};

static int virt_net_init(void)
{
	/* 1. 分配一个net_device结构体 */
	vnet_dev = alloc_netdev(0, "vnet%d", ether_setup);;  /* alloc_ether_dev */

	/* 2. 设置 */
	//vnet_dev->hard_start_xmit = virt_net_send_packet;
	vnet_dev->netdev_ops	= &vnetdev_ops;

	/* 设置MAC地址 */
    vnet_dev->dev_addr[0] = 0x08;
    vnet_dev->dev_addr[1] = 0x89;
    vnet_dev->dev_addr[2] = 0x66;
    vnet_dev->dev_addr[3] = 0x77;
    vnet_dev->dev_addr[4] = 0x88;
    vnet_dev->dev_addr[5] = 0x99;

    /* 设置下面两项才能ping通 */
	vnet_dev->flags           |= IFF_NOARP;
	vnet_dev->features        |= NETIF_F_IP_CSUM;

	/* 3. 注册 */
	//register_netdevice(vnet_dev);		//编译会出错！
	register_netdev(vnet_dev);
	
	return 0;
}

static void virt_net_exit(void)
{
	unregister_netdev(vnet_dev);
	free_netdev(vnet_dev);
}

module_init(virt_net_init);
module_exit(virt_net_exit);

MODULE_AUTHOR("[email protected]");
MODULE_LICENSE("GPL");

测试如下：

  • 挂载驱动,可以看到net类下就有了这个网卡设备，并尝试ping自己

    一文讲透Linux网络设备驱动框架及编写步骤_第11张图片

  • 上图的ping之所以成功，并是因为我们在发包函数中伪造了一个来收包，而是因为linux中，ping自己的时候并不调用（不需要）发送函数向网络设备发送sk_buff数据包。

  • ping同网段其它地址

    一文讲透Linux网络设备驱动框架及编写步骤_第12张图片

    一文讲透Linux网络设备驱动框架及编写步骤_第13张图片

  • ping其它ip地址之所以成功，是因为我们在发包函数中利用emulator_rx_packet函数伪造了一个接收数据包，并通过netif_rx()来将收包上传给上层。

3、移植内核自带的网卡驱动程序

在移植之前，首先我们来看一下mini2440（对应的机器ID为：set machid 7CF）中，是如何支持dm9000网卡的。
进入到入口函数，找到结构体：

static struct platform_driver dm9000_driver = {
	.driver	= {
		.name    = "dm9000",
		.owner	 = THIS_MODULE,
		.pm	 = &dm9000_drv_pm_ops,
	},
	.probe   = dm9000_probe,
	.remove  = __devexit_p(dm9000_drv_remove),
};

一般是通过.name这个成员进行匹配的，搜索字符串“dm9000”，找到如下结构体（在平台文件中：arch\arm\mach-s3c24xx\Mach-mini2440.c）：

static struct platform_device mini2440_device_eth = {
	.name		= "dm9000",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(mini2440_dm9k_resource),
	.resource	= mini2440_dm9k_resource,
	.dev		= {
		.platform_data	= &mini2440_dm9k_pdata,
	},
};

然后搜索结构体mini2440_device_eth，找到：


static struct platform_device *mini2440_devices[] __initdata = {
	&s3c_device_ohci,
	&s3c_device_wdt,
	&s3c_device_i2c0,
	&s3c_device_rtc,
	&s3c_device_usbgadget,
	&mini2440_device_eth,  //在这里
	&mini2440_led1,
	&mini2440_led2,
	&mini2440_led3,
	&mini2440_led4,
	&mini2440_button_device,
	&s3c_device_nand,
	&s3c_device_sdi,
	&s3c_device_iis,
	&uda1340_codec,
	&mini2440_audio,
	&samsung_asoc_dma,
};

然后再搜索：mini2440_devices，找到：

platform_add_devices(mini2440_devices, ARRAY_SIZE(mini2440_devices));

这就是把结构体mini2440_devices添加到内核，里面的关于网卡的结构在里面，最终匹配驱动程序，就可以使用驱动程序了。
（这就是所谓的平台设备平台驱动的东西了，把可变的东西抽象出来放到平台相关的文件中定义，而我们的驱动程序，基本上是不需要改变的，它是稳定的内容，我们移植的时候，只需要把平台层可变的相关结构体加上，需要修改的资源，进行修改就可以了）。

而我们用的是smdk2440（对应的机器ID为：set machid 16a），然后我在Mach-smdk2440.c中添加以下函数：

/* 以下为[email protected] 添加
 * The DM9000 has no eeprom, and it's MAC address is set by
 * the bootloader before starting the kernel.
 */


/* DM9000AEP 10/100 ethernet controller */

#define MACH_SMDK2440_DM9K_BASE (S3C2410_CS4 + 0x300)


static struct resource smdk2440_dm9k_resource[] = {
	[0] = {
		.start = MACH_SMDK2440_DM9K_BASE,
		.end   = MACH_SMDK2440_DM9K_BASE + 3,
		.flags = IORESOURCE_MEM
	},
	[1] = {
		.start = MACH_SMDK2440_DM9K_BASE + 4,
		.end   = MACH_SMDK2440_DM9K_BASE + 7,
		.flags = IORESOURCE_MEM
	},
	[2] = {
		.start = IRQ_EINT7,
		.end   = IRQ_EINT7,
		.flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
	}
};


static struct dm9000_plat_data smdk2440_dm9k_pdata = {
	.flags		= (DM9000_PLATF_16BITONLY | DM9000_PLATF_NO_EEPROM),
};

static struct platform_device smdk2440_device_eth = {
	.name		= "dm9000",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(smdk2440_dm9k_resource),
	.resource	= smdk2440_dm9k_resource,
	.dev		= {
		.platform_data	= &smdk2440_dm9k_pdata,
	},
};

/* 以下为[email protected] 添加 */

在结构体smdk2440_devices中添加网卡成员：

static struct platform_device *smdk2440_devices[] __initdata = {
	&s3c_device_ohci,
	&s3c_device_lcd,
	&s3c_device_wdt,
	&s3c_device_i2c0,
	&s3c_device_iis,
	&smdk2440_device_eth, /* lyy:添加 */
};

添加头文件：

#include   /* 以下为[email protected] 添加*/

然后重新编译内核。成功。烧写新内核：

S3C2440A # nfs 30000000 192.168.1.101:/home/leon/nfs_root/first_fs/uImage;

S3C2440A # bootm 30000000

然后挂载网络文件系统：
mount -t nfs -o nolock 192.168.1.101:/home/leon/nfs_root/first_fs /mnt

成功挂载网络文件系统。

4、自己编写网卡驱动程序

有时候，内核自带的网卡驱动程序比较老，而我们的硬件有可能比较新，那么我们就不能使用内核的网卡驱动程序了，就需要去移植最新的网卡驱动程序，那么这种类型的，又该如何移植呢？

4.1 网络设备驱动程序的模块加载和卸载函数

int xxx_init_module(void) 
{ 
	... 
	/* 分配 net_device 结构体并对其成员赋值 */ 
	xxx_dev = alloc_netdev(sizeof(struct xxx_priv), "sn%d", xxx_init); 
	if (xxx_dev == NULL) 
	... /* 分配 net_device 失败 */ 

	/* 注册 net_device 结构体 */ 
	if ((result = register_netdev(xxx_dev))) 
	... 
} 

void xxx_cleanup(void) 
{ 
	... 
	/* 注销 net_device 结构体 */ 
	unregister_netdev(xxx_dev); 
	/* 释放 net_device 结构体 */ 
	free_netdev(xxx_dev); 
}

4.2 网络设备的初始化

网络设备的初始化主要需要完成如下几个方面的工作：

  1. 进行硬件上的准备工作，检查网络设备是否存在，如果存在，则检测设备使用的硬件资源；
  2. 进行软件接口上的准备工作，分配 net_device 结构体并对其数据和函数指针 成员赋值；
  3. 获得设备的私有信息指针并初始化其各成员的值。如果私有信息中包括自旋 锁或信号量等并发或同步机制，则需对其进行初始化。

个网络设备驱动初始化函数的模板如下所示：

void xxx_init(struct net_device *dev) 
{ 
	/*设备的私有信息结构体*/ 
	struct xxx_priv *priv; 
 
	/* 检查设备是否存在、具体硬件配置和设置设备所使用的硬件资源 */ 
	xxx_hw_init(); 
 
	/* 初始化以太网设备的公用成员 */ 
	ether_setup(dev); 
 
	/*设置设备的成员函数指针*/ 
	dev->open = xxx_open; 
	dev->stop = xxx_release; 
	dev->set_config = xxx_config; 
	dev->hard_start_xmit = xxx_tx; 
	dev->do_ioctl = xxx_ioctl; 
	dev->get_stats = xxx_stats; 
	dev->change_mtu = xxx_change_mtu; 
	dev->rebuild_header = xxx_rebuild_header; 
	dev->hard_header = xxx_header; 
	dev->tx_timeout = xxx_tx_timeout; 
	dev->watchdog_timeo = timeout; 
 
	/*如果使用 NAPI，设置 pool 函数*/ 
	if (use_napi) 
	{ 
		dev->poll = xxx_poll; 
	} 

	/* 取得私有信息，并初始化它*/ 
	priv = netdev_priv(dev);
  	... /* 初始化设备私有数据区 */ 
}

##　4.3 网络设备的打开与释放

网络设备的打开函数需要完成如下工作。

１.　 使能设备使用的硬件资源，申请 I/O 区域、中断和 DMA 通道等。

２.　 调用 Linux 内核提供的 netif_start_queue()函数，激活设备发送队列。 网络设备的关闭函数需要完成如下工作。

３.　 调用 Linux 内核提供的 netif_stop_queue()函数，停止设备传输包。

４.　释放设备所使用的 I/O 区域、中断和 DMA 资源。

Linux 内核提供的 netif_start_queue()和 netif_stop_queue()两个函数的原型为：

void netif_start_queue(struct net_device *dev);  

void netif_stop_queue (struct net_device *dev);

根据以上分析，可得出网络设备打开和释放函数的模板:

int xxx_open(struct net_device *dev) 
{ 
	/* 申请端口、IRQ 等，类似于 fops->open */ 
	ret = request_irq(dev->irq, &xxx_interrupt, 0, dev->name, dev); 
	... 
	netif_start_queue(dev); 
	... 
} 
 
int xxx_release(struct net_device *dev) 
{ 
	/* 释放端口、IRQ 等，类似于 fops->close */ 
	free_irq(dev->irq, dev); 
	... 
	netif_stop_queue(dev); /* can't transmit any more */ 
	... 
}

4.3 数据发送流程

（1）网络设备驱动程序从上层协议传递过来的 sk_buff 参数获得数据包的有效数 据和长度，将有效数据放入临时缓冲区。

（2）对于以太网，如果有效数据的长度小于以太网冲突检测所要求数据帧的最小 长度 ETH_ZLEN，则给临时缓冲区的末尾填充 0。

（3）设置硬件的寄存器，驱使网络设备进行数据发送操作。

int xxx_tx(struct sk_buff *skb, struct net_device *dev) 
{ 
	int len; 
	char *data, shortpkt[ETH_ZLEN]; 
	/* 获得有效数据指针和长度 */ 
	data = skb->data; 
	len = skb->len; 
	if (len < ETH_ZLEN) 
	{ 
		/* 如果帧长小于以太网帧最小长度，补 0 */ 
	memset(shortpkt, 0, ETH_ZLEN); 
	memcpy(shortpkt, skb->data, skb->len); 
 	len = ETH_ZLEN; 
 	data = shortpkt; 
	} 
 
	dev->trans_start = jiffies; /* 记录发送时间戳 */ 
 
	/* 设置硬件寄存器让硬件把数据包发送出去 */ 
	xxx_hw_tx(data, len, dev); 
	... 
}

当数据传输超时时，意味着当前的发送操作失败，此时，数据包发送超时处理函 数 xxx_tx_ timeout()将被调用。这个函数需要调用 Linux 内核提供的 netif_wake_queue()函数重新启动设备发送队列：

void xxx_tx_timeout(struct net_device *dev) 
{ 
	... 
	netif_wake_queue(dev); /* 重新启动设备发送队列 */ 
}

4.3 数据接收流程

网络设备接收数据的主要方法是由中断引发设备的中断处理函数，中断处理函数 判断中断类型，如果为接收中断，则读取接收到的数据，分配 sk_buffer 数据结构和数 据缓冲区，将接收到的数据复制到数据缓冲区，并调用 netif_rx()函数将 sk_buffer 传 递给上层协议。完成这一过程的函数模板：

static void xxx_interrupt(int irq, void *dev_id, struct pt_regs *regs) 
{ 
	... 
	switch (status &ISQ_EVENT_MASK) 
	{ 
		case ISQ_RECEIVER_EVENT: /* 获取数据包 */
			xxx_rx(dev); 
			break; 
			/* 其他类型的中断 */ 
	} 
} 

static void xxx_rx(struct xxx_device *dev) 
{ 
	... 
	length = get_rev_len (...); 
	/* 分配新的套接字缓冲区 */ 
	skb = dev_alloc_skb(length + 2); 
    skb_reserve(skb, 2); /* 对齐 */ 
	skb->dev = dev; 

	/* 读取硬件上接收到的数据 */ 
	insw(ioaddr + RX_FRAME_PORT, skb_put(skb, length), length >> 1); 
	if (length &1) 
		skb->data[length - 1] = inw(ioaddr + RX_FRAME_PORT); 
 
	/* 获取上层协议类型 */ 
	skb->protocol = eth_type_trans(skb, dev); 
 
	/* 把数据包交给上层 */ 
	netif_rx(skb); 
 
	/* 记录接收时间戳 */ 
	dev->last_rx = jiffies; 
	... 
}

如果是 NAPI 兼容的设备驱动，则可以通过 poll 方式接收数据包。这种情况下， 我们需要为该设备驱动提供 xxx_poll()函数:

static int xxx_poll(struct net_device *dev, int *budget) 
{ 
    //dev->quota 是当前 CPU 能够从所有接口中接收数据包的最大数目，budget 是在初始化阶段分配给接口的 weight 值
	int npackets = 0, quota = min(dev->quota, *budget); 
	struct sk_buff *skb; 
	struct xxx_priv *priv = netdev_priv(dev); 
	struct xxx_packet *pkt; 

	while (npackets < quota && priv->rx_queue) 
	{ 
		/*从队列中取出数据包*/ 
		pkt = xxx_dequeue_buf(dev); 
 
		/*接下来的处理，和中断触发的数据包接收一致*/ 
		skb = dev_alloc_skb(pkt->datalen + 2); 
		if (!skb) 
		{ 
			... 
			continue; 
		} 
		skb_reserve(skb, 2); 
		memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen); 
		skb->dev = dev; 
		skb->protocol = eth_type_trans(skb, dev); 
		/*调用 netif_receive_skb 而不是 net_rx 将数据包交给上层协议
		  这里体现出了中断处理机制和轮询机制之间的差别。
		 */ 
		netif_receive_skb(skb); 

		/*更改统计数据 */ 
		priv->stats.rx_packets++; 
		priv->stats.rx_bytes += pkt->datalen; 
		xxx_release_buffer(pkt); 
	} 
	/* 网络设备接收缓冲区中的数据包都被读取完了*/ 
	*budget -= npackets; 
	dev->quota -= npackets; 

	if (!priv->rx_queue) 
	{ 
		netif_rx_complete(dev); //把当前指定的设备从 poll 队列中清除
		xxx_enable_rx_int (…); /* 再次使能网络设备的接收中断 */ 
		return 0; 
	} 

	return 1; 
}

虽然 NAPI 兼容的设备驱动以 poll 方式接收数据包，但是仍然需要首次数据包接 收中断来触发 poll 过程。与数据包的中断接收方式不同的是，以轮询方式接收数据包 时，当第一次中断发生后，中断处理程序要禁止设备的数据包接收中断。poll 中断处理函数如下：

static void xxx_poll_interrupt(int irq, void *dev_id, struct pt_regs *regs) 
{ 
	switch (status &ISQ_EVENT_MASK) 
	{ 
	case ISQ_RECEIVER_EVENT:
        .../* 获取数据包 */ 
		xxx_disable_rx_int(...); /* 禁止接收中断 */ 
		netif_rx_schedule(dev); 
		break;
    .../* 其他类型的中断 */ 
	} 
}

上述代码的 netif_rx_schedule()函数被轮询方式驱动的中断程序调用，将设 备的 poll 方法添加到网络层的 poll 处理队列中，排队并且准备接收数据包，最终触发 一个 NET_RX_SOFTIRQ 软中断，通知网络层接收数据包。下图为 NAPI 驱动 程序各部分的调用关系：

一文讲透Linux网络设备驱动框架及编写步骤_第14张图片

4.4 网络连接状态

网络设备驱动程序中往往设置一个定时器来对链路状态进行周期性地检查。当定 时器到期之后，在定时器处理函数中读取物理设备的相关寄存器获得载波状态，从而 更新设备的连接状态。

网络设备驱动可以通过 netif_carrier_on()和 netif_carrier_off()函数改变或通知内核网络设备的连接状态。此外，函数 netif_carrier_ok() 可用于向调用者返回链路上的载波信号是否存在。

void netif_carrier_on(struct net_device *dev); 
void netif_carrier_off(struct net_device *dev); 
int netif_carrier_ok(struct net_device *dev);

以下代码显示了网络设备驱动用定时器周期检查链路状态：

static void xxx_timer(unsigned long data) 
{ 
	struct net_device *dev = (struct net_device*)data; 
	u16 link; 
	...
    if (!(dev->flags &IFF_UP)) 
	{ 
		goto set_timer; 
	}
	/* 获得物理上的连接状态 */ 
	if (link = xxx_chk_link(dev)) //读取网络适配器硬件的相关寄存器以获得链路连接状态
	{ 
		if (!(dev->flags &IFF_RUNNING)) 
		{ 
			netif_carrier_on(dev); 
			dev->flags |= IFF_RUNNING; 
			printk(KERN_DEBUG "%s: link up\n", dev->name); 
		} 
	} 
	else 	
	{ 
		if (dev->flags &IFF_RUNNING) 
		{ 
			netif_carrier_off(dev); 
			dev->flags &= ~IFF_RUNNING; 
			printk(KERN_DEBUG "%s: link down\n", dev->name); 
		} 
	} 
 
	set_timer: 
	priv->timer.expires = jiffies + 1 * HZ; 
	priv->timer.data = (unsigned long)dev; 
	priv->timer.function = &xxx_timer; /* timer handler */ 
	add_timer(&priv->timer); 
}

从上述源代码还可以看出，定时器处理函数会不停地利用第 31～35 行代 码启动新的定时器以实现周期检测的目的。那么最初启动定时器的地方在哪里呢？很 显然，它最适合在设备的打开函数中完成：

 static int xxx_open(struct net_device *dev) 
{ 
	struct xxx_priv *priv = (struct xxx_priv*)dev->priv; 
 
	... 
 	priv->timer.expires = jiffies + 3 * HZ; 
 	priv->timer.data = (unsigned long)dev; 
 	priv->timer.function = &xxx_timer; /* timer handler */ 
 	add_timer(&priv->timer); 
 	...
}

5. CS8900 网卡设备驱动实例分析

当 CS8900 处于 I/O 模式下时（这里所说的 CS8900 处于 I/O 模式并非意味着它一定位于 CPU 的 I/O 空间，实 际上，CS8900 I/O 模式下的寄存器仍然映射 ARM 处理器的内存空间。因此， 我们直接通过读/写寄存器地址ioremap()之后的虚拟地址即可），可以通过以 下几个 PacketPage 空间内的寄存器来控制 CS8900 的行为（括号内给出的是寄存器地 址相对于 PacketPage 基地址的偏移）:

寄存器 作用
LINECTL(0112H) 决定 CS8900 的基本配置和物理接口，可选择使用 10BASE-T 接口、AUI 接口或者自动选择。
RXCTL(0104H) 控制 CS8900 接收特定数据包，控制是否接收多播、广播和单播包。
RXCFG(0102H) RXCFG 控制 CS8900 接收到特定数据包后引发接收中断，并控制是否使用接收 DMA 和 CRC 校验。
BUSCT(0116H) BUSCT 可控制芯片的工作模式、DMA 方式、是否使能外部中断引脚。
BUSST(0138H) 标志网络设备的发送状态，如设备是否准备好发送。
ISQ(0120H) 网卡芯片的中断状态寄存器

在 I/O 模式下，CS8900 发送数据包的步骤如下：

（1）向控制寄存器 TXCMD 寄存器写入发送命令write_reg(TXCMD, send_cmd);。

（2）将发送数据长度写入 TXLENG 寄存器write_reg(TXLENG, send_len)。

（3）读取 PacketPage 空间内的 BUSST 寄存器，确定其第 8 位被设置为 Rdy4TxNOW，即设备处于准备发送状态reg(BusST)&0x100。

（4）将要发送的数据循环写入 PORT0 寄存器write_reg(PORT0, data)。

（5）将数据组织为以太网帧并添加填充位和 CRC 校验信息，然后将数据转化为比特流传送到网络媒介。

在 I/O 模式下，CS8900 接收数据包的方法如下：

（1）接收到网络适配器产生的中断，查询相对于 I/O 基地址偏移 0008H 中断状态 队列端口，判断中断类型为接收中断。

（2）读 PORT0 寄存器依次获得接收状态 rxStatus、接收数据长度 rxLength。

（3）循环继续对 PORT0 寄存器读取 rxLength 次，获得整个数据包。

（4）驱动程序进行数据包处理并传递给上层。

对于一种网络设备的驱动而言，工程师主要需完成设备驱动功能层的设计。在 16.2～ 16.8节已经给出了设备驱动功能层主要数据结构和函数的设计模板，因此，在编写CS8900 的这些数据结构和函数时，实际要完成的工作就是用具体的针对 CS8900 的操作来填充模 板，具体包括以下工作：

  1. 填充 CS8900 的私有信息结构体，把 CS8900 特定的数据放入这个私有结构体中。在 CS8900 驱动程序中，这个数据结构为 struct net_local。

    在 CS8900 的设备驱动程序中，核心数据结构 net_device 以全局变量的方式定义， 其数个成员的初始值都被置为空，私有信息结构体为 net_local：

    static struct net_device dev_cs89x0 = 
{ 
	"", 
 	0, 0, 0, 0, 
 	0, 0, 
 	0, 0, 0, NULL, NULL 
};

struct net_local 
{ 
	struct net_device_stats stats; /* 网络设备状态结构体 */ 
	int chip_type; /* 区分芯片类型：CS89x0 */ 
	char chip_revision; /* 芯片版本字母，如"A" */ 
	int send_cmd; /* 发送命令: TX_NOW, TX_AFTER_381 或 TX_AFTER_ALL */ 
	... 
    spinlock_t lock; /* 并发控制自旋锁 */ 
};

    当芯片的版本字母不同时，net_local 结构体中记录的 send_cmd 命令将不同。例如， 同样是 CS8900 网卡，若芯片版本字母为大于等于“F”，则发送命令为 TX_NOW，而 对于 CS8900A，发送命令为 TX_AFTER_ALL。

  2. 填充设备初始化模板，初始化 net_device 结构体，将其注册入内核。net_device 的注册与注销在模块加载与注销函数中完成。在 CS8900 驱动程序中，与此相关的函数有：

    struct net_device * _ _init cs89x0_probe(int unit);

int cs89x0_probe1(struct net_device *dev, int ioaddr, int modular); 

int init_module(void);  

void cleanup_module(void);

    设备的初始化由 net_device 结构体中的 init()函数完成，这个函数将在 net_device 被注册时自动被调用。init()函数在 CS8900 网卡的驱动程序中对应 于 cs89x0_probe()函数：

    int __init cs89x0_probe(struct net_device *dev) 
{ 
	int i; 
 
	SET_MODULE_OWNER(dev); 
	DPRINTK(1, "cs89x0:cs89x0_probe(0x%x)\n", base_addr); 

	BWSCON = (BWSCON & ~(BWSCON_ST3 | BWSCON_WS3 | BWSCON_DW3)) | 
				(BWSCON_ST3 | BWSCON_WS3 | BWSCON_DW(3, BWSCON_DW_16)); 
	BANKCON3= BANKCON_Tacs0 | BANKCON_Tcos4 | BANKCON_Tacc14 | 
				BANKCON_Toch1 | BANKCON_Tcah4 | BANKCON_Tacp6 | BANKCON_PMC1; 
 
	set_external_irq(IRQ_CS8900, EXT_RISING_EDGE, GPIO_PULLUP_DIS); 

 	for (i = 0; netcard_portlist[i]; i++) 
    { 
 		if (cs89x0_probe1(dev, netcard_portlist[i]) == 0) //验证网卡的存在，并获取 CS8900所使用的硬件资源
			return 0; 
	} 
	printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected." 
       "Be sure to disable PnP with SETUP\n"); 
	return -ENODEV; 
}


static unsigned int netcard_portlist[] __initdata = 
{ 
    vCS8900_BASE + 0x300,	//假设硬件平台中网卡的基地址为 vCS8900_BASE + 0x300
    0
}; 

/*
 *上述 cs89x0_probe1()函数的流程如下。
 *（1）第 8～20 行分配设备的私有信息结构体内存并初始化，若分配失败，则直接跳入第 78 行的代码返回。
 *（2）第 24～26 行从寄存器中读取芯片的具体类型。
 *（3）第 27～32 行判断芯片类型，若不是 CS8900 则直接跳入第 77 行的代码，释放私有信息结构体并返回。
 *（4）当芯片类型为 CS8900 时，第 34～69 行完成 net_device 设备结构体的初始化，赋值其属性和函数指针。
 */

static int __init cs89x0_probe1(struct net_device *dev, int ioaddr)
{ 
	struct net_local *lp; 
	unsigned rev_type = 0; 
	int ret; 
 
 	/* 初始化设备结构体私有信息 */ 
 	if (dev->priv == NULL) 
	{ 
 		dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL); 
		if (dev->priv == 0) 
		{ 
			ret = - ENOMEM; 
			goto before_kmalloc; 
		} 
	lp = (struct net_local*)dev->priv; 
	memset(lp, 0, sizeof(*lp)); 
	spin_lock_init(&lp->lock); 
	} 
	lp = (struct net_local*)dev->priv; 

	dev->base_addr = ioaddr; 
	/* 读取芯片类型 */ 
	rev_type = readreg(dev, PRODUCT_ID_ADD); 
	lp->chip_type = rev_type &~REVISON_BITS;
 	lp->chip_revision = ((rev_type &REVISON_BITS) >> 8) + 'A';30 
	if (lp->chip_type != CS8900) 
	{ 
		printk(_ _FILE_ _ ": wrong device driver!\n"); 
		ret = - ENODEV; 
		goto after_kmalloc;
	} 
	/* 根据芯片类型和版本确定正确的发送命令 */ 
	lp->send_cmd = TX_AFTER_ALL; 
	if (lp->chip_type == CS8900 && lp->chip_revision >= 'F') 
		lp->send_cmd = TX_NOW; 

	reset_chip(dev); 

	lp->adapter_cnf = A_CNF_10B_T | A_CNF_MEDIA_10B_T; 
	lp->auto_neg_cnf = EE_AUTO_NEG_ENABLE;
	printk(KERN_INFO "cs89x0 media %s%s", (lp->adapter_cnf &A_CNF_10B_T) ? "RJ-45": "", (lp->adapter_cnf &A_CNF_AUI) ? "AUI" : ""); 

 	/* 设置 CS8900 的 MAC 地址 */ 
	dev->dev_addr[0] = 0x00; 
	dev->dev_addr[1] = 0x00; 
	dev->dev_addr[2] = 0xc0; 
	dev->dev_addr[3] = 0xff; 
	dev->dev_addr[4] = 0xee; 
	dev->dev_addr[5] = 0x08; 
 	set_mac_address(dev, dev->dev_addr); 
 
	/* 设置设备中断号 */ 
	dev->irq = IRQ_LAN; 
	printk(", IRQ %d", dev->irq); 
 
	/* 填充设备结构体的成员函数指针 */ 
	dev->open = net_open; 
	dev->stop = net_close; 
	dev->tx_timeout = net_timeout; 
	dev->watchdog_timeo = 3 * HZ; 
	dev->hard_start_xmit = net_send_packet; 
	dev->get_stats = net_get_stats; 
	dev->set_multicast_list = set_multicast_list; 
	dev->set_mac_address = set_mac_address; 
 
	/* 填充以太网公用数据和函数指针 */ 
	ether_setup(dev); 

	printk("\n"); 
	DPRINTK(1, "cs89x0_probe1() successful\n"); 
	return 0;
  	after_kmalloc: kfree(dev->priv); 
	before_kmalloc: return ret; 
} 


static int __init init_cs8900a_s3c2410(void) 
{ 
	struct net_local *lp; 
	int ret = 0; 
 
	dev_cs89x0.irq = irq; 
	dev_cs89x0.base_addr = io; 
	dev_cs89x0.init = cs89x0_probe; //在使用 register_netdev()函数注net_device 设备结构体时，cs89x0_probe()函数会被自动调用以完成 net_device 结构体的初始化。
	dev_cs89x0.priv = kmalloc(sizeof(struct net_local), GFP_KERNEL); 
	if (dev_cs89x0.priv == 0) 
	{ 
		printk(KERN_ERR "cs89x0.c: Out of memory.\n"); 
		return - ENOMEM; 
	} 
	memset(dev_cs89x0.priv, 0, sizeof(struct net_local)); 
	lp = (struct net_local*)dev_cs89x0.priv; 
    
 	//为 CS8900 网卡申请了 NETCARD_IO_EXTENT大小的I/O 地址区域
	request_region(dev_cs89x0.base_addr, NETCARD_IO_EXTENT, "cs8900a");
    spin_lock_init(&lp->lock); 
 
	/* 设置物理接口的正确类型*/ 
	if (!strcmp(media, "rj45")) 
	lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T; 
	else if (!strcmp(media, "aui")) 
		lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI; 
	else if (!strcmp(media, "bnc")) 
		lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2; 
	else 
		lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T; 
 
	if (duplex == - 1) 
		lp->auto_neg_cnf = AUTO_NEG_ENABLE; 
 
	if (io == 0) 
	{ 
		printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n"); 
		printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n"); 
		ret = - EPERM; 
		goto out; 
	} 
 	//net_device 设备结构体的注册
	if (register_netdev(&dev_cs89x0) != 0) 
	{ 
		printk(KERN_ERR "cs89x0.c: No card found at 0x%x\n", io); 
		ret = - ENXIO; 
		goto out; 
	} 
out: if (ret) 
		kfree(dev_cs89x0.priv); 
	return ret; 
} 


static void _ _exit cleanup_cs8900a_s3c2410(void) 
{ 
	if (dev_cs89x0.priv != NULL) 
	{ 
		/* 释放私有信息结构体 */ 
		unregister_netdev(&dev_cs89x0); 
		outw(PP_ChipID, dev_cs89x0.base_addr + ADD_PORT); 
		kfree(dev_cs89x0.priv); 
		dev_cs89x0.priv = NULL; 
		/* 释放 CS8900 申请的 I/O 地址区域 */ 
        release_region(dev_cs89x0.base_addr, NETCARD_IO_EXTENT); 
	} 
}

    上述函数第 8～11 行设置 S3C2410A ARM 处理器的片选，第 13行设置 ARM 与 CS8900 网卡对应的中断，第 15～18 行循环检索 netcard_portlist[ ]数组中定义的基地址处 是否存在 CS8900 网卡

  3. 填充设备发送数据包函数模板，把真实的数据包发送硬件操作填充入 xxx_tx() 函数，并填充发送超时函数 xxx_tx_timeout()。当发送数据包超时时，CS8900 驱动程序的数据包发送超时函数将被调用，它重 新启动设备发送队列。在初始化函数中，CS8900 的数据包发送函数指针 hard_ start_xmit 被赋值为 CS8900 驱动程序中的 net_send_packet()，这个函数完成硬件发送序列。具体代码如下：

static int net_send_packet(struct sk_buff *skb, struct net_device  *dev)
{
    struct net_local *lp = (struct net_local*)dev->priv; 
 
	writereg(dev, PP_BusCTL, 0x0); 
	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ); 
 
	spin_lock_irq(&lp->lock);/* 使用自旋锁阻止多个数据包被同时写入硬件*/ 
	netif_stop_queue(dev); 
 
	/* 初始化硬件发送序列 */ 
	writeword(dev, TX_CMD_PORT, lp->send_cmd); 
	writeword(dev, TX_LEN_PORT, skb->len); 
 
	/* 检测硬件是否处于发送 READY 状态 */ 
	if ((readreg(dev, PP_BusST) &READY_FOR_TX_NOW) == 0) 
	{ 
		spin_unlock_irq(&lp->lock); 
		DPRINTK(1, "cs89x0: Tx buffer not free!\n"); 
		return 1; 
	} 
 
	writeblock(dev, skb->data, skb->len);	/* 将数据写入硬件 */ 
 
	spin_unlock_irq(&lp->lock); 	/* 解锁自旋锁 */ 
	dev->trans_start = jiffies; 	/* 记录发送开始的时间戳 */ 
	dev_kfree_skb(skb); 			/* 释放 sk_buff 和数据缓冲区 */ 
 
	return 0; 
}

static void net_timeout(struct net_device *dev)
{ 
	DPRINTK(1, "%s: transmit timed out, %s?\n", dev->name,
		tx_done(dev) ? "IRQ conflict ?" : "network cable problem"); 
 
	net_close(dev); //停止网卡
	writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET); //网卡硬复位
	net_open(dev); //再次启动网卡
}

  1. 填充设备驱动程序的中断处理程序 xxx_interrupt()和具体的数据包接收函数 xxx_rx()，填入真实的硬件操作。在 CS8900 驱动程序中，与此相关的函数有：

    irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{ 
	struct net_device *dev = dev_id; 
	struct net_local *lp; 
	int ioaddr, status; 
 
	ioaddr = dev->base_addr; 
	lp = (struct net_local*)dev->priv; 
 
	/* 读取中断事件类型 */ 
	while ((status = readword(dev, ISQ_PORT))) 
	{ 
		DPRINTK(4, "%s: event=%04x\n", dev->name, status); 
		switch (status &ISQ_EVENT_MASK) 
		{ 
			case ISQ_RECEIVER_EVENT: 
				/* 获得数据包 */ 
				net_rx(dev); 
				break; 
			... /* 其他类型中断 */ 
		} 
	} 
} 


static void net_rx(struct net_device *dev)
{
    struct net_local *lp = (struct net_local*)dev->priv; 
	struct sk_buff *skb; 
	int status, length; 
 
	int ioaddr = dev->base_addr; 
 
	status = inw(ioaddr + RX_FRAME_PORT); 
	if ((status &RX_OK) == 0) 
	{ 
		count_rx_errors(status, lp); 
		return ; 
	} 
 
	length = inw(ioaddr + RX_FRAME_PORT);/* 读取接收数据包的长度 */ 
 
	/* 分配新的套接字缓冲区和数据缓冲区 */ 
	skb = dev_alloc_skb(length + 2); 
	if (skb == NULL) 
	{ 
		lp->stats.rx_dropped++; /* 分配失败，统计被丢弃的包数 */ 
		return ; 
	} 
	skb_reserve(skb, 2); 
	skb->len = length; 
	skb->dev = dev;
	readblock(dev, skb->data, skb->len); /* 从硬件中读取数据包放入数据缓冲区 */
    skb->protocol = eth_type_trans(skb, dev);/* 解析收到数据包的网络层协议类型 */ 
 
	netif_rx(skb); /* 传递给上层协议 */ 
 
	dev->last_rx = jiffies; /* 记录最后收到数据包的时间戳 */ 
	/* 统计接收数据包数和接收字节数 */ 
	lp->stats.rx_packets++; 
	lp->stats.rx_bytes += length; 
}

  2. 填充设备打开 xxx_open()与释放 xxx_release()函数代码。在 CS8900 驱动程序 中，与此相关的函数有：

int net_open(struct net_device *dev);  

int net_close(struct net_device *dev);
  1. 填充设备配置与数据统计的具体代码，填充返回设备冲突的 xxx_stats()函数。

6. 网卡驱动移植一般步骤

拿到一块新的网卡，一般厂家会有自带的驱动程序给你，你所要做的就是以下几个事情：

  1. 根据网卡与开发板的连接方式确定网卡的内存映射地址iobase，也即确定网卡的片选信号所连接的CPU内存的哪一个bank（nGCS？），然后根据网卡内存的大小，在网卡驱动的初始化函数中调用ioremap()进行地址重映射；
  2. 根据网卡与开发板的硬件连接图确定中断号，并在初始化函数中利于request_irq()函数，向内核申请中断（确定中断触发方式、中断处理函数等）；
  3. 根据网卡datasheet查看网卡的读写时序和位宽参数，设置开发板相应的内存控制寄存器BWSCON和BANKCON*。
  4. 将它拷贝到内核源代码的相关目录并修改该目录下的Makefile文件以添加修改后的网卡驱动目标文件。假设我们已经改好的网卡驱动程序为：dm9dev9000c.c，编译也没有错误。
cp dm9dev9000c.c /home/leon/linux-3.4.2/drivers/net/ethernet/davicom/

修改该目录Makefile文件：

#
# Makefile for the Davicom device drivers.
#

#obj-$(CONFIG_DM9000) += dm9000.o
obj-$(CONFIG_DM9000) += dm9dev9000c.o

  1. 重新编译内核，烧写新的uImage文件到开发板中，看看是否可以挂载网络根文件系统或者可以设置IP地址及ping通网络。如果可以成功挂载网络根文件系统，所以网卡移植是成功的。

    nfs 30000000 192.168.1.101:/work/nfs_root/uImage_net_new; 

bootm 30000000
    
mount -t nfs -o nolock,vers=2 192.168.1.101:/work/nfs_root/fs_mini_mdev_new /mnt

  • 我们也可以设置开机直接挂载网络根文件系统，这样就可以直接开机启动网络根文件系统了。

    • uboot中设置：

      set bootargs console=ttySAC0,115200 root=/dev/nfs nfsroot=192.168.1.101:/home/leon/nfs_root/first_fs ip=192.168.1.50:192.168.1.101:192.168.1.1:255.255.255.0::eth0:off
    
save

tftp 30000000 uImage

bootm 30000000

ip=192.168.1.50：为单板ip，

192.168.1.101：为服务器ip，

192.168.1.1为网关，

255.255.255.0为子网掩码

if (skb == NULL) 
{ 
	lp->stats.rx_dropped++; /* 分配失败，统计被丢弃的包数 */ 
	return ; 
} 
skb_reserve(skb, 2); 
skb->len = length; 
skb->dev = dev;
readblock(dev, skb->data, skb->len); /* 从硬件中读取数据包放入数据缓冲区 */
   skb->protocol = eth_type_trans(skb, dev);/* 解析收到数据包的网络层协议类型 */ 

netif_rx(skb); /* 传递给上层协议 */ 

dev->last_rx = jiffies; /* 记录最后收到数据包的时间戳 */ 
/* 统计接收数据包数和接收字节数 */ 
lp->stats.rx_packets++; 
lp->stats.rx_bytes += length;

}




5.  **填充设备打开 xxx_open()与释放 xxx_release()函数代码**。在 CS8900 驱动程序 中，与此相关的函数有：

```c
int net_open(struct net_device *dev);  

int net_close(struct net_device *dev);
  1. 填充设备配置与数据统计的具体代码，填充返回设备冲突的 xxx_stats()函数。

6. 网卡驱动移植一般步骤

拿到一块新的网卡，一般厂家会有自带的驱动程序给你，你所要做的就是以下几个事情：

  1. 根据网卡与开发板的连接方式确定网卡的内存映射地址iobase，也即确定网卡的片选信号所连接的CPU内存的哪一个bank（nGCS？），然后根据网卡内存的大小，在网卡驱动的初始化函数中调用ioremap()进行地址重映射；
  2. 根据网卡与开发板的硬件连接图确定中断号，并在初始化函数中利于request_irq()函数，向内核申请中断（确定中断触发方式、中断处理函数等）；
  3. 根据网卡datasheet查看网卡的读写时序和位宽参数，设置开发板相应的内存控制寄存器BWSCON和BANKCON*。
  4. 将它拷贝到内核源代码的相关目录并修改该目录下的Makefile文件以添加修改后的网卡驱动目标文件。假设我们已经改好的网卡驱动程序为：dm9dev9000c.c，编译也没有错误。
cp dm9dev9000c.c /home/leon/linux-3.4.2/drivers/net/ethernet/davicom/

修改该目录Makefile文件：

#
# Makefile for the Davicom device drivers.
#

#obj-$(CONFIG_DM9000) += dm9000.o
obj-$(CONFIG_DM9000) += dm9dev9000c.o

  1. 重新编译内核，烧写新的uImage文件到开发板中，看看是否可以挂载网络根文件系统或者可以设置IP地址及ping通网络。如果可以成功挂载网络根文件系统，所以网卡移植是成功的。

    nfs 30000000 192.168.1.101:/work/nfs_root/uImage_net_new; 

bootm 30000000
    
mount -t nfs -o nolock,vers=2 192.168.1.101:/work/nfs_root/fs_mini_mdev_new /mnt

  • 我们也可以设置开机直接挂载网络根文件系统，这样就可以直接开机启动网络根文件系统了。

    • uboot中设置：

      set bootargs console=ttySAC0,115200 root=/dev/nfs nfsroot=192.168.1.101:/home/leon/nfs_root/first_fs ip=192.168.1.50:192.168.1.101:192.168.1.1:255.255.255.0::eth0:off
    
save

tftp 30000000 uImage

bootm 30000000

ip=192.168.1.50：为单板ip，

192.168.1.101：为服务器ip，

192.168.1.1为网关，

255.255.255.0为子网掩码

你可能感兴趣的:(Linux3.4.2驱动开发,linux,网络,驱动开发,网卡驱动,网卡驱动移植)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 2023-04-17|篮球女孩 长一木
    1小学抑或初中阶段，在课外书了解到她的故事。“篮球女孩”。当时佩服她的顽强，也对生命多了一丝敬畏。今天刚好在公众号看到，长大后的“篮球女孩”。佩服之余又满是心疼。网络侵删祝那素未蒙面的女孩，未来一切顺遂。
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1） 算法大师 华为od面试python算法前端
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 《在战“疫”中成长致敬生活》观后感 梅子刘的刀
    （作者：周晨）今天上午，我看了“我是接班人”网络大课堂《在战役中成长致敬生活》。有很多人拿出自己攒下的钱，默默地捐给了武汉，有几千块钱的、有几万块钱的，也有十几万块钱的。连小朋友也把自己的压岁钱捐给了武汉。有名环卫工人把自己五年的积蓄全部捐给了武汉。有名外卖小哥为医护人员买鞋子送吃的。还有已经治愈出院的新型肺炎病人捐了400毫升的血浆。还有位叫大树的叔叔，虽然他没有钱，但是他地里有蔬菜，捐了几大卡
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • 中原焦点团队网络初中级30期阴丽丽坚持分享第三百八十八次2022.10.18分享 约练次数（74） 咨询师（6） 来访者（53） 观察者（15） 阴丽丽
    今天是忙碌的一天，一早起来，总想着找点把事情弄完，可总也弄不完。就这样弄着吧！孩子的事，自己的事都在那里搁置着，不想做，有点欧！今天总体还不错，只是在下午起床时走神了俩小时，也算是给自己的放松吧！今日难得1.儿子乖巧、听话，努力配合，一天下来也是忙忙碌碌，这真的很难得！2.儿子今天录的视频被班主任认可，这真的很难得3.我今天早上做核酸时，自己把教案整了一下，这真的很难得
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • 多子女家庭问题 3e5c5362403c
    杨宁宁焦点解决网络初17中19坚持分享589天（2021.3.20）本周约练我1次，总计166次，读书打卡第256天案例督导收获：【家有老大篇】被爱与高期待下的独舞家里的第一个孩子往往集万千宠爱于一身。爸爸妈妈、爷爷奶奶、姥姥姥爷的目光都聚焦在他的身上。在这种光环下长大的孩子，就如小皇帝一般，衣来伸手、饭来张口。拥有爱的同时，也意味着拥有了更高的被期待，父母会花血本给你报各种各样的早教班，给你买各
  • 父母教育孩子的方式，将影响孩子一生 树英教育
    为什么有些孩子总是充满自信与快乐？独立、有主见又坚强？而有些孩子却自卑、胆怯，软弱又过度依赖父母？为什么有些孩子总是健康、阳光又富于创造力？而有些孩子却悲观、孤僻又思想空乏？一个孩子的行为取决于孩子的思想，思想取决于环境和自己的认知，认知取决于教育。父母是孩子人生中的第一位教育者，父母养育孩子的方式，将决定他们人生的高度，影响他们的一生。网络图，侵权即删优秀的父母就像园丁，既要浇水施肥，又要修剪杂
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • Linux sh命令 fengyehongWorld Linuxlinux
    目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容
  • Linux vi常用命令 fengyehongWorld Linuxlinux
    参考资料viコマンド（vimコマンド）リファレンス目录一.保存系命令二.删除系命令三.移动系命令四.复制粘贴系命令一.保存系命令⏹保存并退出:wq⏹强制保存并退出:wq!⏹退出(文件未编辑):q⏹强制退出(忽略已编辑内容):q!⏹另存为:w新文件名二.删除系命令⏹删除当前行dd⏹清空整个文档gg：移动到文档顶部dG：删除到最后一行ggdG三.移动系命令⏹移动到文档顶部gg⏹移动到文档底部#方式1G
  • 2024.9.6 Python，华为笔试题总结，字符串格式化，字符串操作，广度优先搜索解决公司组织绩效互评问题，无向图 RaidenQ python华为leetcode算法力扣广度优先无向图
    1.字符串格式化name="Alice"age=30formatted_string="Name:{},Age:{}".format(name,age)print(formatted_string)或者name="Alice"age=30formatted_string=f"Name:{name},Age:{age}"print(formatted_string)2.网络健康检查第一行有两个整数m
  • 戴容容 中原焦点团队.网络初级第33期,坚持分享第19天 2022年3月9日 TessDai
    《每个人眼中的世界都是不同的》“一千个人眼里有一千个哈姆雷特”世界是多元的,每个人都有自己的道理,人人按照自己的理解去看待这个世界的人和物.我们如此,其他人也是如此.因此,任何事情,我们要放下自己以为的真理,去理解他人认为的真理,只有同频方能共振.孩子在慢慢长大的过程中慢慢学会独立,甚至对抗.尤其当孩子处于青春期的时候,他们开始有很多自己独立的想法,和一些特立独行的做法,家长常常会觉得不可思议,觉
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通 学习3人组 大数据大数据
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
  • 网络通信流程 记得开心一点啊 服务器网络运维
    目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Linux查看服务器日志 TPBoreas 运维linux运维
    一、tail这个是我最常用的一种查看方式用法如下：tail-n10test.log查询日志尾部最后10行的日志;tail-n+10test.log查询10行之后的所有日志;tail-fn10test.log循环实时查看最后1000行记录(最常用的)一般还会配合着grep用，(实时抓包)例如:tail-fn1000test.log|grep'关键字'（动态抓包）tail-fn1000test.log
  • java工厂模式 3213213333332132 java抽象工厂
    工厂模式有 1、工厂方法 2、抽象工厂方法。 下面我的实现是抽象工厂方法, 给所有具体的产品类定一个通用的接口。 package 工厂模式; /** * 航天飞行接口 * * @Description * @author FuJianyong * 2015-7-14下午02:42:05 */ public interface SpaceF
  • nginx频率限制+python测试 ronin47 nginx 频率 python
           部分内容参考：http://www.abc3210.com/2013/web_04/82.shtml 首先说一下遇到这个问题是因为网站被攻击，阿里云报警，想到要限制一下访问频率，而不是限制ip（限制ip的方案稍后给出）。nginx连接资源被吃空返回状态码是502，添加本方案限制后返回599，与正常状态码区别开。步骤如下：
  • java线程和线程池的使用 dyy_gusi ThreadPoolthreadRunnabletimer
    java线程和线程池 一、创建多线程的方式     java多线程很常见，如何使用多线程，如何创建线程，java中有两种方式，第一种是让自己的类实现Runnable接口，第二种是让自己的类继承Thread类。其实Thread类自己也是实现了Runnable接口。具体使用实例如下： 1、通过实现Runnable接口方式 1 2
  • Linux 171815164 linux
    ubuntu kernel http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.1.2-unstable/ 安卓sdk代理 mirrors.neusoft.edu.cn        80 输入法和jdk sudo apt-get install fcitx su
  • Tomcat JDBC Connection Pool g21121 Connection
           Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。        Tomcat Jdbc P
  • 敲代码的一点想法 永夜-极光 java随笔感想
                  入门学习java编程已经半年了,一路敲代码下来,现在也才1w+行代码量,也就菜鸟水准吧,但是在整个学习过程中,我一直在想,为什么很多培训老师,网上的文章都是要我们背一些代码?比如学习Arraylist的时候,教师就让我们先参考源代码写一遍,然
  • jvm指令集 程序员是怎么炼成的 jvm 指令集
    转自：http://blog.csdn.net/hudashi/article/details/7062675#comments       将值推送至栈顶时 const ldc  push   load指令 const系列 该系列命令主要负责把简单的数值类型送到栈顶。(从常量池或者局部变量push到栈顶时均使用) 0x02 &nbs
  • Oracle字符集的查看查询和Oracle字符集的设置修改 aijuans oracle
    本文主要讨论以下几个部分：如何查看查询oracle字符集、 修改设置字符集以及常见的oracle utf8字符集和oracle exp 字符集问题。 一、什么是Oracle字符集 Oracle字符集是一个字节数据的解释的符号集合,有大小之分,有相互的包容关系。ORACLE 支持国家语言的体系结构允许你使用本地化语言来存储，处理，检索数据。它使数据库工具，错误消息，排序次序，日期，时间，货
  • png在Ie6下透明度处理方法 antonyup_2006 css浏览器FirebugIE
    由于之前到深圳现场支撑上线，当时为了解决个控件下载，我机器上的IE8老报个错，不得以把ie8卸载掉，换个Ie6,问题解决了，今天出差回来，用ie6登入另一个正在开发的系统，遇到了Png图片的问题，当然升级到ie8(ie8自带的开发人员工具调试前端页面JS之类的还是比较方便的，和FireBug一样，呵呵)，这个问题就解决了，但稍微做了下这个问题的处理。 我们知道PNG是图像文件存储格式，查询资
  • 表查询常用命令高级查询方法(二) 百合不是茶 oracle分页查询分组查询联合查询
    ----------------------------------------------------分组查询 group by    having   --平均工资和最高工资   select avg(sal)平均工资,max(sal)  from emp ;  --每个部门的平均工资和最高工资
  • uploadify3.1版本参数使用详解 bijian1013 JavaScriptuploadify3.1
    使用：     绑定的界面元素<input id='gallery'type='file'/>$("#gallery").uploadify({设置参数，参数如下}); 设置的属性： id: jQuery(this).attr('id'),//绑定的input的ID langFile: 'http://ww
  • 精通Oracle10编程SQL(17)使用ORACLE系统包 bijian1013 oracle数据库plsql
    /* *使用ORACLE系统包 */ --1.DBMS_OUTPUT --ENABLE:用于激活过程PUT,PUT_LINE,NEW_LINE,GET_LINE和GET_LINES的调用 --语法：DBMS_OUTPUT.enable(buffer_size in integer default 20000); --DISABLE:用于禁止对过程PUT,PUT_LINE,NEW
  • 【JVM一】JVM垃圾回收日志 bit1129 垃圾回收
    将JVM垃圾回收的日志记录下来，对于分析垃圾回收的运行状态，进而调整内存分配(年轻代，老年代，永久代的内存分配)等是很有意义的。JVM与垃圾回收日志相关的参数包括： -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -Xloggc -XX:+PrintGC 通
  • Toast使用 白糖_ toast
    Android中的Toast是一种简易的消息提示框，toast提示框不能被用户点击，toast会根据用户设置的显示时间后自动消失。     创建Toast 两个方法创建Toast makeText(Context context, int resId, int duration)     参数：context是toast显示在
  • angular.identity boyitech AngularJSAngularJS API
    angular.identiy 描述: 返回它第一参数的函数. 此函数多用于函数是编程. 使用方法: angular.identity(value); 参数详解: Param Type Details value * to be returned. 返回值: 传入的value 实例代码: <!DOCTYPE HTML>
  • java-两整数相除，求循环节 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class CircleDigitsInDivision { /** * 题目：求循环节，若整除则返回NULL，否则返回char*指向循环节。先写思路。函数原型：char*get_circle_digits(unsigned k,unsigned j)
  • Java 日期 周 年 Chen.H javaC++cC#
    /** * java日期操作(月末、周末等的日期操作) * * @author * */ public class DateUtil { /** */ /** * 取得某天相加(减)後的那一天 * * @param date * @param num *
  • [高考与专业]欢迎广大高中毕业生加入自动控制与计算机应用专业 comsci 计算机
          不知道现在的高校还设置这个宽口径专业没有,自动控制与计算机应用专业,我就是这个专业毕业的,这个专业的课程非常多,既要学习自动控制方面的课程,也要学习计算机专业的课程,对数学也要求比较高.....如果有这个专业,欢迎大家报考...毕业出来之后,就业的途径非常广.....      以后
  • 分层查询（Hierarchical Queries） daizj oracle递归查询层次查询
    Hierarchical Queries If a table contains hierarchical data, then you can select rows in a hierarchical order using the hierarchical query clause: hierarchical_query_clause::= start with condi
  • 数据迁移 daysinsun 数据迁移
    最近公司在重构一个医疗系统，原来的系统是两个.Net系统，现需要重构到java中。数据库分别为SQL Server和Mysql，现需要将数据库统一为Hana数据库，发现了几个问题，但最后通过努力都解决了。 1、原本通过Hana的数据迁移工具把数据是可以迁移过去的，在MySQl里面的字段为TEXT类型的到Hana里面就存储不了了，最后不得不更改为clob。 2、在数据插入的时候有些字段特别长
  • C语言学习二进制的表示示例 dcj3sjt126com cbasic
    进制的表示示例 # include <stdio.h> int main(void) { int i = 0x32C; printf("i = %d\n", i); /* printf的用法 %d表示以十进制输出 %x或%X表示以十六进制的输出 %o表示以八进制输出 */ return 0; }
  • NsTimer 和 UITableViewCell 之间的控制 dcj3sjt126com ios
    情况是这样的: 一个UITableView, 每个Cell的内容是我自定义的 viewA viewA上面有很多的动画, 我需要添加NSTimer来做动画, 由于TableView的复用机制, 我添加的动画会不断开启, 没有停止, 动画会执行越来越多.   解决办法: 在配置cell的时候开始动画, 然后在cell结束显示的时候停止动画   查找cell结束显示的代理
  • MySql中case when then 的使用 fanxiaolong casewhenthenend
    select "主键", "项目编号", "项目名称","项目创建时间", "项目状态","部门名称","创建人" union (select pp.id as "主键", pp.project_number as &
  • Ehcache（01）——简介、基本操作 234390216 cacheehcache简介CacheManagercrud
    Ehcache简介 目录 1       CacheManager 1.1      构造方法构建 1.2      静态方法构建 2       Cache 2.1&
  • 最容易懂的javascript闭包学习入门 jackyrong JavaScript
    http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。 下面就是我的学习笔记，对于Javascript初学者应该是很有用的。 一、变量的作用域 要理解闭包，首先必须理解Javascript特殊
  • 提升网站转化率的四步优化方案 php教程分享 数据结构PHP数据挖掘Google活动
    网站开发完成后,我们在进行网站优化最关键的问题就是如何提高整体的转化率，这也是营销策略里最最重要的方面之一，并且也是网站综合运营实例的结果。文中分享了四大优化策略：调查、研究、优化、评估，这四大策略可以很好地帮助用户设计出高效的优化方案。 PHP开发的网站优化一个网站最关键和棘手的是，如何提高整体的转化率，这是任何营销策略里最重要的方面之一，而提升网站转化率是网站综合运营实力的结果。今天，我就分
  • web开发里什么是HTML5的WebSocket？ naruto1990 Webhtml5浏览器socket
    当前火起来的HTML5语言里面，很多学者们都还没有完全了解这语言的效果情况，我最喜欢的Web开发技术就是正迅速变得流行的 WebSocket API。WebSocket 提供了一个受欢迎的技术，以替代我们过去几年一直在用的Ajax技术。这个新的API提供了一个方法，从客户端使用简单的语法有效地推动消息到服务器。让我们看一看6个HTML5教程介绍里 的 WebSocket API：它可用于客户端、服
  • Socket初步编程——简单实现群聊 Everyday都不同 socket网络编程初步认识
    初次接触到socket网络编程，也参考了网络上众前辈的文章。尝试自己也写了一下，记录下过程吧：   服务端：（接收客户端消息并把它们打印出来）   public class SocketServer { private List<Socket> socketList = new ArrayList<Socket>(); public s
  • 面试：Hashtable与HashMap的区别（结合线程） toknowme
    昨天去了某钱公司面试，面试过程中被问道 Hashtable与HashMap的区别？当时就是回答了一点，Hashtable是线程安全的，HashMap是线程不安全的，说白了，就是Hashtable是的同步的，HashMap不是同步的，需要额外的处理一下。   今天就动手写了一个例子，直接看代码吧 package com.learn.lesson001; import java
  • MVC设计模式的总结 xp9802 设计模式mvc框架IOC
    随着Web应用的商业逻辑包含逐渐复杂的公式分析计算、决策支持等，使客户机越 来越不堪重负，因此将系统的商业分离出来。单独形成一部分，这样三层结构产生了。 其中‘层’是逻辑上的划分。 三层体系结构是将整个系统划分为如图2.1所示的结构[3] （1）表现层（Presentation layer）：包含表示代码、用户交互GUI、数据验证。 该层用于向客户端用户提供GUI交互，它允许用户
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他