你了解Linux網絡驅動之一：snull

? ? ? snull是《Linux Device Drivers》中的一個網絡驅動的例子。這里引用這個例子學習Linux網絡驅動。

因為snull的源碼，網上已經更新到適合最新內核，而我自己用的還是2.6.22.6比較舊的內核。而網上好像找不到舊版的snull。因此結合《Linux Device Drivers》把最新的snull例子移植到2.6.22.6內核中。移植也相對簡單，這里也提供移植好的代碼。

估計不少網友看到《Linux Device Drivers》的網絡驅動部分，一臉懵逼，包括我自己，不理解作者設計這個例子的真正目的，盡管有配圖，仍然懵懂，甚至不知道為什么會用到6個IP地址。如圖：

其實作者的本意是想通過虛擬網卡來模擬實際的網卡和外部的網絡設備的通信來討論網絡驅動。通過其中任何一個網絡接口（sn0或sn1）發送數據，都在另一個網絡接口（sn0或sn1）接收到。

因為sn0和sn1都不在同一個網段，所以sn0和sn1之間直接互ping是不行的，這中間必須必須做點轉換。

例子：

理論上local0和remote0只能互ping，因為他們都在同一個網段：192.168.0.0，但事實上，local0在發出數據之后，local0的第3個字節最低有效位改取反，就變成了remote1，remote1的數據才能到達local1，因為他們在同一段IP。相反，local1在發出數據之后，local1的第3個字節最低有效位改取反，就變成了remote0，remote0的數據才能到達local0.

因此，在實驗之前，需要添加一些配置：

在/etc/networks文件中添加如下網段IP：

snullnet0 192.168.2.0

snullnet1 192.168.3.0

在/etc/hosts文件中添加如下IP地址

192.168.2.8 local0

192.168.2.9 remote0

192.168.3.9 local1

192.168.3.8 remote1

注意： 1. 網段IP和IP地址的第三個字節的最低有效位是相反的

2. local0和remote1第四個字節必須一樣，remote0和local1第四個字節必須一樣

3. 如果開發板上的真正網卡用了的網段IP，就不能再用于本實驗。如：我的開發板的DM9000網卡使用網段是192.168.1.0，因此本實驗不能再使用192.168.1.0作為網段，否則有沖突。

代碼： snull.c, 其中snull.h沒改動，因此不貼出來

/*
?* snull.c --? the Simple Network Utility
?*
?* Copyright (C) 2001 Alessandro Rubini and Jonathan Corbet
?* Copyright (C) 2001 O'Reilly & Associates
?*
?* The source code in this file can be freely used, adapted,
?* and redistributed in source or binary form, so long as an
?* acknowledgment appears in derived source files.? The citation
?* should list that the code comes from the book "Linux Device
?* Drivers" by Alessandro Rubini and Jonathan Corbet, published
?* by O'Reilly & Associates.? No warranty is attached;
?* we cannot take responsibility for errors or fitness for use.
?*
?* $Id: snull.c,v 1.21 2004/11/05 02:36:03 rubini Exp $
?*/

#include
#include
#include

#include
#include /* printk() */
#include /* kmalloc() */
#include ? /* error codes */
#include ? /* size_t */
#include /* mark_bh */

#include
#include ? /* struct device, and other headers */
#include /* eth_type_trans */
#include ? ? ? ? ? /* struct iphdr */
#include ? ? ? ? /* struct tcphdr */
#include

#include "snull.h"

#include
#include

MODULE_AUTHOR("Alessandro Rubini, Jonathan Corbet");
MODULE_LICENSE("Dual BSD/GPL");

/*
?* Transmitter lockup simulation, normally disabled.
?*/
static int lockup = 0;
module_param(lockup, int, 0);

static int timeout = SNULL_TIMEOUT;
module_param(timeout, int, 0);

/*
?* Do we run in NAPI mode?
?*/
static int use_napi = 0;
module_param(use_napi, int, 0);

/*
?* A structure representing an in-flight packet.
?*/
struct snull_packet {
? ? struct snull_packet *next;
? ? struct net_device *dev;
? ? int? ? datalen;
? ? u8 data[ETH_DATA_LEN];
};

int pool_size = 8;
module_param(pool_size, int, 0);

/*
?* This structure is private to each device. It is used to pass
?* packets in and out, so there is place for a packet
?*/

struct snull_priv {
? ? struct net_device_stats stats;
? ? int status;
? ? struct snull_packet *ppool;
? ? struct snull_packet *rx_queue;? /* List of incoming packets */
? ? int rx_int_enabled;
? ? int tx_packetlen;
? ? u8 *tx_packetdata;
? ? struct sk_buff *skb;
? ? spinlock_t lock;
? ? struct net_device *dev;
? ? //struct napi_struct napi;
};

static void snull_tx_timeout(struct net_device *dev);
static void (*snull_interrupt)(int, void *, struct pt_regs *);

/*
?* Set up a device's packet pool.
?*/
void snull_setup_pool(struct net_device *dev)
{
? ? struct snull_priv *priv = netdev_priv(dev);
? ? int i;
? ? struct snull_packet *pkt;

priv->ppool = NULL;
? ? for (i = 0; i < pool_size; i++) {
? ? ? ? pkt = kmalloc (sizeof (struct snull_packet), GFP_KERNEL);
? ? ? ? if (pkt == NULL) {
? ? ? ? ? ? printk (KERN_NOTICE "Ran out of memory allocating packet pool\n");
? ? ? ? ? ? return;
? ? ? ? }
? ? ? ? pkt->dev = dev;
? ? ? ? pkt->next = priv->ppool;
? ? ? ? priv->ppool = pkt;
? ? }
}

void snull_teardown_pool(struct net_device *dev)
{
? ? struct snull_priv *priv = netdev_priv(dev);
? ? struct snull_packet *pkt;
? ??
? ? while ((pkt = priv->ppool)) {
? ? ? ? priv->ppool = pkt->next;
? ? ? ? kfree (pkt);
? ? ? ? /* FIXME - in-flight packets ? */
? ? }
}? ?

/*
?* Buffer/pool management.
?*/
struct snull_packet *snull_get_tx_buffer(struct net_device *dev)
{
? ? struct snull_priv *priv = netdev_priv(dev);
? ? unsigned long flags;
? ? struct snull_packet *pkt;
? ??
? ? spin_lock_irqsave(&priv->lock, flags);
? ? pkt = priv->ppool;
? ? priv->ppool = pkt->next;
? ? if (priv->ppool == NULL) {
? ? ? ? printk (KERN_INFO "Pool empty\n");
? ? ? ? netif_stop_queue(dev);
? ? }
? ? spin_unlock_irqrestore(&priv->lock, flags);
? ? return pkt;
}

void snull_release_buffer(struct snull_packet *pkt)
{
? ? unsigned long flags;
? ? struct snull_priv *priv = netdev_priv(pkt->dev);
? ??
? ? spin_lock_irqsave(&priv->lock, flags);
? ? pkt->next = priv->ppool;
? ? priv->ppool = pkt;
? ? spin_unlock_irqrestore(&priv->lock, flags);
? ? if (netif_queue_stopped(pkt->dev) && pkt->next == NULL)
? ? ? ? netif_wake_queue(pkt->dev);

printk("snull_release_buffer\n");
}

void snull_enqueue_buf(struct net_device *dev, struct snull_packet *pkt)
{
? ? unsigned long flags;
? ? struct snull_priv *priv = netdev_priv(dev);

spin_lock_irqsave(&priv->lock, flags);
? ? pkt->next = priv->rx_queue;? /* FIXME - misorders packets */
? ? priv->rx_queue = pkt;
? ? spin_unlock_irqrestore(&priv->lock, flags);
}

struct snull_packet *snull_dequeue_buf(struct net_device *dev)
{
? ? struct snull_priv *priv = netdev_priv(dev);
? ? struct snull_packet *pkt;
? ? unsigned long flags;

spin_lock_irqsave(&priv->lock, flags);
? ? pkt = priv->rx_queue;
? ? if (pkt != NULL)
? ? ? ? priv->rx_queue = pkt->next;
? ? spin_unlock_irqrestore(&priv->lock, flags);
? ? return pkt;
}

/*
?* Enable and disable receive interrupts.
?*/
static void snull_rx_ints(struct net_device *dev, int enable)
{
? ? struct snull_priv *priv = netdev_priv(dev);
? ? priv->rx_int_enabled = enable;
}

/*
?* Open and close
?*/

int snull_open(struct net_device *dev)
{
? ? /* request_region(), request_irq(), ....? (like fops->open) */

/*?
? ? * Assign the hardware address of the board: use "\0SNULx", where
? ? * x is 0 or 1. The first byte is '\0' to avoid being a multicast
? ? * address (the first byte of multicast addrs is odd).
? ? */
? ? /* [cgw]: 分配一個假的硬件地址，真正的網卡的時候，這個地址是從網卡讀出來的 */
? ? memcpy(dev->dev_addr, "\0SNUL0", ETH_ALEN);
? ? /* [cgw]: 因為注冊了兩個虛擬網卡，第二個虛擬網卡的地址跟第一個的地址必須不一樣
? ? * 即這兩個網卡地址分別為\0SNUL0和\0SNUL1
? ? */
? ? if (dev == snull_devs[1])
? ? ? ? dev->dev_addr[ETH_ALEN-1]++; /* \0SNUL1 */
? ? /* [cgw]: 啟動發送隊列 */
? ? netif_start_queue(dev);

printk("snull_open\n");
? ??
? ? return 0;
}

int snull_release(struct net_device *dev)
{
? ? /* release ports, irq and such -- like fops->close */

netif_stop_queue(dev); /* can't transmit any more */
? ??
? ? printk("snull_release\n");
? ??
? ? return 0;
}

/*
?* Configuration changes (passed on by ifconfig)
?*/
int snull_config(struct net_device *dev, struct ifmap *map)
{
? ? if (dev->flags & IFF_UP) /* can't act on a running interface */
? ? ? ? return -EBUSY;

/* Don't allow changing the I/O address */
? ? if (map->base_addr != dev->base_addr) {
? ? ? ? printk(KERN_WARNING "snull: Can't change I/O address\n");
? ? ? ? return -EOPNOTSUPP;
? ? }

/* Allow changing the IRQ */
? ? if (map->irq != dev->irq) {
? ? ? ? dev->irq = map->irq;
? ? ? ? ? ? /* request_irq() is delayed to open-time */
? ? }

printk("snull_config\n");

/* ignore other fields */
? ? return 0;
}

/*
?* Receive a packet: retrieve, encapsulate and pass over to upper levels
?*/
void snull_rx(struct net_device *dev, struct snull_packet *pkt)
{
? ? struct sk_buff *skb;
? ? struct snull_priv *priv = netdev_priv(dev);

/*
? ? * The packet has been retrieved from the transmission
? ? * medium. Build an skb around it, so upper layers can handle it
? ? */
? ? /* [cgw]: 為接收包分配一個skb */
? ? skb = dev_alloc_skb(pkt->datalen + 2);
? ? if (!skb) {
? ? ? ? if (printk_ratelimit())
? ? ? ? ? ? printk(KERN_NOTICE "snull rx: low on mem - packet dropped\n");
? ? ? ? priv->stats.rx_dropped++;
? ? ? ? goto out;
? ? }
? ? /* [cgw]: 16字節對齊，即IP首部前是網卡硬件地址首部，其占14字節，需要為其增加2
? ? * 個字節?
? ? */
? ? skb_reserve(skb, 2); /* align IP on 16B boundary */
? ? /* [cgw]: 開辟一個數據緩沖區用于存放接收數據 */
? ? memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);

/* Write metadata, and then pass to the receive level */
? ? skb->dev = dev;
? ? if (skb->dev == snull_devs[0]) {
? ? ? ? printk("skb->dev is snull_devs[0]\n");
? ? } else {
? ? ? ? printk("skb->dev is snull_devs[1]\n");
? ? }
? ? /* [cgw]: 確定包的協議ID */
? ? skb->protocol = eth_type_trans(skb, dev);

printk("skb->protocol = %d\n", skb->protocol);
? ??
? ? skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
? ? /* [cgw]: 統計接收包數和字節數 */
? ? priv->stats.rx_packets++;
? ? priv->stats.rx_bytes += pkt->datalen;
? ? /* [cgw]: 上報應用層 */
? ? netif_rx(skb);

printk("snull_rx\n");
? ??
? out:
? ? return;
}
? ?

/*
?* The poll implementation.
?*/
//static int snull_poll(struct napi_struct *napi, int budget)
static int snull_poll(struct net_device *dev, int *budget)
{
? ? //int npackets = 0;
? ? //struct sk_buff *skb;
? ? //struct snull_priv *priv = container_of(napi, struct snull_priv, napi);
? ? //struct net_device *dev = priv->dev;
? ? //struct snull_packet *pkt;

int npackets = 0, quota = min(dev->quota, *budget);
? ? struct sk_buff *skb;
? ? struct snull_priv *priv = netdev_priv(dev);
? ? struct snull_packet *pkt;

printk("snull_poll\n");
? ??
? ? //while (npackets < budget && priv->rx_queue) {
? ? while (npackets < quota && priv->rx_queue) {
? ? ? ? pkt = snull_dequeue_buf(dev);
? ? ? ? skb = dev_alloc_skb(pkt->datalen + 2);
? ? ? ? if (! skb) {
? ? ? ? ? ? if (printk_ratelimit())
? ? ? ? ? ? ? ? printk(KERN_NOTICE "snull: packet dropped\n");
? ? ? ? ? ? priv->stats.rx_dropped++;
? ? ? ? ? ? snull_release_buffer(pkt);
? ? ? ? ? ? continue;
? ? ? ? }
? ? ? ? skb_reserve(skb, 2); /* align IP on 16B boundary */??
? ? ? ? memcpy(skb_put(skb, pkt->datalen), pkt->data, pkt->datalen);
? ? ? ? skb->dev = dev;
? ? ? ? skb->protocol = eth_type_trans(skb, dev);
? ? ? ? skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
? ? ? ? netif_receive_skb(skb);
? ? ? ??
? ? ? ? ? ? /* Maintain stats */
? ? ? ? npackets++;
? ? ? ? priv->stats.rx_packets++;
? ? ? ? priv->stats.rx_bytes += pkt->datalen;
? ? ? ? snull_release_buffer(pkt);
? ? }
? ? /* If we processed all packets, we're done; tell the kernel and reenable ints */
? ? *budget -= npackets;
? ? dev->quota -= npackets;
? ? if (! priv->rx_queue) {
? ? ? ? //napi_complete(napi);
? ? ? ? netif_rx_complete(dev);
? ? ? ? snull_rx_ints(dev, 1);
? ? ? ? return 0;
? ? }
? ? /* We couldn't process everything. */
? ? //return npackets;
? ? return 1;
}? ? ? ??
? ? ? ??
/*
?* The typical interrupt entry point
?*/
static void snull_regular_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
? ? int statusword;
? ? struct snull_priv *priv;
? ? struct snull_packet *pkt = NULL;
? ? /*
? ? * As usual, check the "device" pointer to be sure it is
? ? * really interrupting.
? ? * Then assign "struct device *dev"
? ? */
? ? struct net_device *dev = (struct net_device *)dev_id;
? ? /* ... and check with hw if it's really ours */

/* paranoid */
? ? if (!dev)
? ? ? ? return;

/* Lock the device */
? ? priv = netdev_priv(dev);
? ? spin_lock(&priv->lock);

/* [cgw]: 判斷產生的是什么類型的中斷，接收還是中斷 */
? ? /* retrieve statusword: real netdevices use I/O instructions */
? ? statusword = priv->status;
? ??
? ? printk("priv->status = %d\n", priv->status);
? ??
? ? priv->status = 0;
? ? /* [cgw]: 接收完成中斷 */
? ? if (statusword & SNULL_RX_INTR) {
? ? ? ? /* send it to snull_rx for handling */
? ? ? ? pkt = priv->rx_queue;
? ? ? ? if (pkt) {
? ? ? ? ? ? priv->rx_queue = pkt->next;
? ? ? ? ? ? /* [cgw]: 網卡接收到數據，上報給應用層 */
? ? ? ? ? ? snull_rx(dev, pkt);
? ? ? ? }
? ? }
? ? /* [cgw]: 發送完成中斷 */
? ? if (statusword & SNULL_TX_INTR) {
? ? ? ? /* [cgw]: 統計已發送的包數和總字節數，并釋放這個包的內存 */
? ? ? ? /* a transmission is over: free the skb */
? ? ? ? priv->stats.tx_packets++;
? ? ? ? priv->stats.tx_bytes += priv->tx_packetlen;
? ? ? ? dev_kfree_skb(priv->skb);
? ? }

/* Unlock the device and we are done */
? ? spin_unlock(&priv->lock);
? ? if (pkt) snull_release_buffer(pkt); /* Do this outside the lock! */

printk("snull_regular_interrupt\n");

return;
}

/*
?* A NAPI interrupt handler.
?*/
static void snull_napi_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
? ? int statusword;
? ? struct snull_priv *priv;

/*
? ? * As usual, check the "device" pointer for shared handlers.
? ? * Then assign "struct device *dev"
? ? */
? ? struct net_device *dev = (struct net_device *)dev_id;
? ? /* ... and check with hw if it's really ours */

printk("snull_napi_interrupt\n");

/* paranoid */
? ? if (!dev)
? ? ? ? return;

/* Lock the device */
? ? priv = netdev_priv(dev);
? ? spin_lock(&priv->lock);

/* retrieve statusword: real netdevices use I/O instructions */
? ? statusword = priv->status;
? ? priv->status = 0;
? ? if (statusword & SNULL_RX_INTR) {
? ? ? ? snull_rx_ints(dev, 0);? /* Disable further interrupts */
? ? ? ? //napi_schedule(&priv->napi);
? ? ? ? netif_rx_schedule(dev);
? ? }
? ? if (statusword & SNULL_TX_INTR) {
? ? ? ? ? ? /* a transmission is over: free the skb */
? ? ? ? priv->stats.tx_packets++;
? ? ? ? priv->stats.tx_bytes += priv->tx_packetlen;
? ? ? ? dev_kfree_skb(priv->skb);
? ? }

/* Unlock the device and we are done */
? ? spin_unlock(&priv->lock);
? ? return;
}

/*
?* Transmit a packet (low level interface)
?*/
static void snull_hw_tx(char *buf, int len, struct net_device *dev)
{
? ? /*
? ? * This function deals with hw details. This interface loops
? ? * back the packet to the other snull interface (if any).
? ? * In other words, this function implements the snull behaviour,
? ? * while all other procedures are rather device-independent
? ? */
? ? struct iphdr *ih;
? ? struct net_device *dest;
? ? struct snull_priv *priv;
? ? u32 *saddr, *daddr;
? ? struct snull_packet *tx_buffer;
? ??
? ? /* I am paranoid. Ain't I? */
? ? if (len < sizeof(struct ethhdr) + sizeof(struct iphdr)) {
? ? ? ? printk("snull: Hmm... packet too short (%i octets)\n",
? ? ? ? ? ? ? ? len);
? ? ? ? return;
? ? }

/* [cgw]: 打印上層應用(即ping)要發的這個包的內容
? ? * 這個包的格式為:
? ? * 14字節以太網首部+20字節IP地址首部+20字節TCP地址首部+n字節數據
? ? */
? ??
? ? if (1) { /* enable this conditional to look at the data */
? ? ? ? int i;
? ? ? ? PDEBUG("len is %i\n" KERN_DEBUG "data:",len);
? ? ? ? /* [cgw]: 14字節以太網首部 */
? ? ? ? for (i=0 ; i<14; i++)
? ? ? ? ? ? printk(" %02x",buf[i]&0xff);
? ? ? ? printk("\n");

/* [cgw]: 20字節IP地址首部 */
? ? ? ? for (i=14 ; i<34; i++)
? ? ? ? ? ? printk(" %02x",buf[i]&0xff);
? ? ? ? printk("\n");

/* [cgw]: 20字節TCP地址首部 */
? ? ? ? for (i=34 ; i<54; i++)
? ? ? ? ? ? printk(" %02x",buf[i]&0xff);
? ? ? ? printk("\n");

/* [cgw]: n字節數據 */
? ? ? ? for (i=54 ; i? ? ? ? ? ? printk(" %02x",buf[i]&0xff);
? ? ? ? printk("\n");
? ? }
? ? /*
? ? * Ethhdr is 14 bytes, but the kernel arranges for iphdr
? ? * to be aligned (i.e., ethhdr is unaligned)
? ? */
? ? /* [cgw]: 提取本地和目標IP地址 */
? ? ih = (struct iphdr *)(buf+sizeof(struct ethhdr));
? ? saddr = &ih->saddr;
? ? daddr = &ih->daddr;
? ??
? ? printk("ih->protocol = %d is buf[23]\n", ih->protocol);
? ? printk("saddr = %d.%d.%d.%d\n", *((u8 *)saddr + 0), *((u8 *)saddr + 1), *((u8 *)saddr + 2), *((u8 *)saddr + 3));
? ? printk("daddr = %d.%d.%d.%d\n", *((u8 *)daddr + 0), *((u8 *)daddr + 1), *((u8 *)daddr + 2), *((u8 *)daddr + 3));

/* [cgw]: 改變本地和目標IP地址的第三個字節的最低位，即原來是0，則改為1，原來是1，則改為0
? ? */
? ? ((u8 *)saddr)[2] ^= 1; /* change the third octet (class C) */
? ? ((u8 *)daddr)[2] ^= 1;

/* [cgw]: 從新計算校驗，因為IP已改變 */
? ? ih->check = 0;? ? ? ? /* and rebuild the checksum (ip needs it) */
? ? ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl);

/* [cgw]: 打印更改后的IP地址，和TCP地址，
? ? */
? ? if (dev == snull_devs[0])
? ? ? ? //PDEBUGG("%08x:%05i --> %08x:%05i\n",
? ? ? ? printk("%08x:%05i --> %08x:%05i\n",
? ? ? ? ? ? ? ? ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source),
? ? ? ? ? ? ? ? ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest));
? ? else
? ? ? ? //PDEBUGG("%08x:%05i <-- %08x:%05i\n",
? ? ? ? printk("%08x:%05i <-- %08x:%05i\n",
? ? ? ? ? ? ? ? ntohl(ih->daddr),ntohs(((struct tcphdr *)(ih+1))->dest),
? ? ? ? ? ? ? ? ntohl(ih->saddr),ntohs(((struct tcphdr *)(ih+1))->source));

/*
? ? * Ok, now the packet is ready for transmission: first simulate a
? ? * receive interrupt on the twin device, then? a
? ? * transmission-done on the transmitting device
? ? */
? ? /* [cgw]: 獲得目的網卡設備 */
? ? dest = snull_devs[dev == snull_devs[0] ? 1 : 0];
? ??
? ? if (dev == snull_devs[0]) {
? ? ? ? printk("snull_devs[0]\n");
? ? } else {
? ? ? ? printk("snull_devs[1]\n");
? ? }
? ??
? ? priv = netdev_priv(dest);
? ? /* [cgw]: 取出一塊內存分配給本地網卡 */
? ? tx_buffer = snull_get_tx_buffer(dev);
? ? /* [cgw]: 設置數據包大小 */
? ? tx_buffer->datalen = len;
? ??
? ? printk("tx_buffer->datalen = %d\n", tx_buffer->datalen);

/* [cgw]: 填充發送網卡的數據 */
? ? memcpy(tx_buffer->data, buf, len);
? ? /* [cgw]: 把發送的數據直接加入到接收隊列，這里相當于本地網卡要發送的數據
? ? * 已經給目標網卡直接接收到了
? ? */
? ? snull_enqueue_buf(dest, tx_buffer);
? ? /* [cgw]: 如果接收中斷使能，這個也是模擬的接收中斷，因為上面已經模擬接收
? ? * 到數據，所以立刻產生一個中斷
? ? */
? ? if (priv->rx_int_enabled) {
? ? ? ? priv->status |= SNULL_RX_INTR;
? ? ? ? printk("priv->status = %d\n", priv->status);
? ? ? ? /* [cgw]: 執行接收中斷 */
? ? ? ? snull_interrupt(0, dest, NULL);
? ? ? ? printk("snull_interrupt(0, dest, NULL);\n");
? ? }

/* [cgw]: 獲得本地網卡的私有數據指針 */
? ? priv = netdev_priv(dev);
? ? /* [cgw]: 把本地網卡要發送的數據存到私有數據緩沖區，接著產生一個發送中斷
? ? */
? ? priv->tx_packetlen = len;
? ? priv->tx_packetdata = buf;
? ? priv->status |= SNULL_TX_INTR;
? ? if (lockup && ((priv->stats.tx_packets + 1) % lockup) == 0) {
? ? ? ? ? ? /* Simulate a dropped transmit interrupt */
? ? ? ? netif_stop_queue(dev);
? ? ? ? PDEBUG("Simulate lockup at %ld, txp %ld\n", jiffies,
? ? ? ? ? ? ? ? (unsigned long) priv->stats.tx_packets);
? ? }
? ? else {
? ? ? ? /* [cgw]: 產生一個發送中斷 */
? ? ? ? snull_interrupt(0, dev, NULL);
? ? ? ? printk("snull_interrupt(0, dev, NULL);\n");
? ? }
}

/*
?* Transmit a packet (called by the kernel)
?*/
int snull_tx(struct sk_buff *skb, struct net_device *dev)
{
? ? int len;
? ? char *data, shortpkt[ETH_ZLEN];
? ? struct snull_priv *priv = netdev_priv(dev);

/* [cgw]: 獲取上層需要發送的數據和長度 */
? ? data = skb->data;
? ? len = skb->len;

printk("skb->len = %d\n", skb->len);
? ??
? ? if (len < ETH_ZLEN) {
? ? ? ? memset(shortpkt, 0, ETH_ZLEN);
? ? ? ? memcpy(shortpkt, skb->data, skb->len);
? ? ? ? len = ETH_ZLEN;
? ? ? ? data = shortpkt;
? ? }
? ? /* [cgw]: 開始計算時間截，用于處理發送超時 */
? ? dev->trans_start = jiffies; /* save the timestamp */

/* Remember the skb, so we can free it at interrupt time */
? ? priv->skb = skb;
? ??
? ? printk("snull_tx\n");

/* actual deliver of data is device-specific, and not shown here */
? ? /* [cgw]: 模擬把數據包寫入硬件，通過硬件發送出去，但實際上不是 */
? ? snull_hw_tx(data, len, dev);

//printk("snull_tx\n");

return 0; /* Our simple device can not fail */
}

/*
?* Deal with a transmit timeout.
?*/
void snull_tx_timeout (struct net_device *dev)
{
? ? struct snull_priv *priv = netdev_priv(dev);

PDEBUG("Transmit timeout at %ld, latency %ld\n", jiffies,
? ? ? ? ? ? jiffies - dev->trans_start);
? ? ? ? /* Simulate a transmission interrupt to get things moving */
? ? priv->status = SNULL_TX_INTR;
? ? snull_interrupt(0, dev, NULL);
? ? priv->stats.tx_errors++;
? ? netif_wake_queue(dev);

printk("snull_tx_timeout\n");
? ??
? ? return;
}

/*
?* Ioctl commands?
?*/
int snull_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
? ? PDEBUG("ioctl\n");
? ? printk("ioctl\n");
? ? return 0;
}

/*
?* Return statistics to the caller
?*/
struct net_device_stats *snull_stats(struct net_device *dev)
{
? ? struct snull_priv *priv = netdev_priv(dev);

printk("snull_stats\n");
? ??
? ? return &priv->stats;
}

/*
?* This function is called to fill up an eth header, since arp is not
?* available on the interface
?*/
int snull_rebuild_header(struct sk_buff *skb)
{
? ? struct ethhdr *eth = (struct ethhdr *) skb->data;
? ? struct net_device *dev = skb->dev;
? ??
? ? memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
? ? memcpy(eth->h_dest, dev->dev_addr, dev->addr_len);
? ? eth->h_dest[ETH_ALEN-1]? ^= 0x01;? /* dest is us xor 1 */

printk("snull_rebuild_header\n");
? ??
? ? return 0;
}

//int snull_header(struct sk_buff *skb, struct net_device *dev,
//? ? ? ? ? ? ? ? unsigned short type, const void *daddr, const void *saddr,
//? ? ? ? ? ? ? ? unsigned len)

int snull_header(struct sk_buff *skb, struct net_device *dev,
? ? ? ? ? ? ? ? unsigned short type, void *daddr, void *saddr,
? ? ? ? ? ? ? ? unsigned len)? ? ? ? ? ? ??
{
? ? struct ethhdr *eth = (struct ethhdr *)skb_push(skb,ETH_HLEN);

printk("len = %d\n", len);

printk("type = %02x\n", type); //ETH_P_IP? ? 0x0800? ? ? ? /* Internet Protocol packet? ? */

/* htons是將整型變量從主機字節順序轉變成網絡字節順序，?
? ? * 就是整數在地址空間存儲方式變為：高位字節存放在內存的低地址處
? ? */
? ? eth->h_proto = htons(type);
? ? printk("h_proto = %d\n", eth->h_proto);
? ??
? ? printk("addr_len = %d\n", dev->addr_len);
? ? printk("dev_addr = %02x.%02x.%02x.%02x.%02x.%02x\n", dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2], dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);

if (saddr) {
? ? ? ? printk("saddr = %02x.%02x.%02x.%02x.%02x.%02x\n", *((unsigned char *)saddr + 0), *((unsigned char *)saddr + 1), *((unsigned char *)saddr + 2), *((unsigned char *)saddr + 3), *((unsigned char *)saddr + 4), *((unsigned char *)saddr + 5));
? ? }

if (daddr) {
? ? ? ? printk("daddr = %02x.%02x.%02x.%02x.%02x.%02x\n", *((unsigned char *)daddr + 0), *((unsigned char *)daddr + 1), *((unsigned char *)daddr + 2), *((unsigned char *)daddr + 3), *((unsigned char *)daddr + 4), *((unsigned char *)daddr + 5));
? ? }

/* [cgw]: 上層應用要發送數據時，通過下層添加硬件地址，才能決定發送到那個目標網卡
? ? */
? ? memcpy(eth->h_source, saddr ? saddr : dev->dev_addr, dev->addr_len);
? ? memcpy(eth->h_dest,? daddr ? daddr : dev->dev_addr, dev->addr_len);
? ? printk("h_source = %02x.%02x.%02x.%02x.%02x.%02x\n", eth->h_source[0], eth->h_source[1], eth->h_source[2],eth->h_source[3], eth->h_source[4], eth->h_source[5]);
? ? printk("h_dest = %02x.%02x.%02x.%02x.%02x.%02x\n", eth->h_dest[0], eth->h_dest[1], eth->h_dest[2], eth->h_dest[3], eth->h_dest[4], eth->h_dest[5]);

/* [cgw]: 設置目標網卡硬件地址，即本地網卡和目標網卡硬件地址的最后一個字節的最低有效位
? ? * 是相反關系，即本地是\0SNUL0的話，目標就是\0SNUL1，或者本地是\0SNUL1，目標就是\0SNUL0
? ? */
? ? eth->h_dest[ETH_ALEN-1]? ^= 0x01;? /* dest is us xor 1 */
? ? printk("h_dest[ETH_ALEN-1] ^ 0x01 = %02x\n", eth->h_dest[ETH_ALEN-1]);
? ??
? ? printk("hard_header_len = %d\n", dev->hard_header_len);
? ??
? ? return (dev->hard_header_len);
}

/*
?* The "change_mtu" method is usually not needed.
?* If you need it, it must be like this.
?*/
int snull_change_mtu(struct net_device *dev, int new_mtu)
{
? ? unsigned long flags;
? ? struct snull_priv *priv = netdev_priv(dev);
? ? spinlock_t *lock = &priv->lock;
? ??
? ? /* check ranges */
? ? if ((new_mtu < 68) || (new_mtu > 1500))
? ? ? ? return -EINVAL;
? ? /*
? ? * Do anything you need, and the accept the value
? ? */
? ? spin_lock_irqsave(lock, flags);
? ? dev->mtu = new_mtu;
? ? spin_unlock_irqrestore(lock, flags);
? ? return 0; /* success */
}

#if 0
static const struct header_ops snull_header_ops = {
? ? ? ? .create? = snull_header,
? ? .rebuild = snull_rebuild_header
};

static const struct net_device_ops snull_netdev_ops = {
? ? .ndo_open? ? ? ? ? ? = snull_open,
? ? .ndo_stop? ? ? ? ? ? = snull_release,
? ? .ndo_start_xmit? ? ? = snull_tx,
? ? .ndo_do_ioctl? ? ? ? = snull_ioctl,
? ? .ndo_set_config? ? ? = snull_config,
? ? .ndo_get_stats? ? ? = snull_stats,
? ? .ndo_change_mtu? ? ? = snull_change_mtu,
? ? .ndo_tx_timeout? ? ? = snull_tx_timeout
};
#endif

/*
?* The init function (sometimes called probe).
?* It is invoked by register_netdev()
?*/
void snull_init(struct net_device *dev)
{
? ? struct snull_priv *priv;
#if 0
? ? ? ? /*
? ? * Make the usual checks: check_region(), probe irq, ...? -ENODEV
? ? * should be returned if no device found.? No resource should be
? ? * grabbed: this is done on open().?
? ? */
#endif

/*?
? ? * Then, assign other fields in dev, using ether_setup() and some
? ? * hand assignments
? ? */
? ? ether_setup(dev); /* assign some of the fields */
? ? dev->watchdog_timeo = timeout;
? ??
? ? //dev->netdev_ops = &snull_netdev_ops;
? ? //dev->header_ops = &snull_header_ops;
? ??
? ? dev->hard_header = snull_header;
? ? dev->rebuild_header = snull_rebuild_header;
? ??
? ? dev->open = snull_open;
? ? dev->stop = snull_release;
? ? dev->hard_start_xmit = snull_tx;
? ? dev->do_ioctl = snull_ioctl;
? ? dev->set_config = snull_config;
? ? dev->get_stats = snull_stats;
? ? dev->change_mtu = snull_change_mtu;
? ? dev->tx_timeout = snull_tx_timeout;
? ??
? ? /* keep the default flags, just add NOARP */
? ? dev->flags? ? ? ? ? |= IFF_NOARP;
? ? dev->features? ? ? ? |= NETIF_F_HW_CSUM;

dev->hard_header_cache = NULL;

/*
? ? * Then, initialize the priv field. This encloses the statistics
? ? * and a few private fields.
? ? */
? ? priv = netdev_priv(dev);
? ? #if 0
? ? if (use_napi) {
? ? ? ? netif_napi_add(dev, &priv->napi, snull_poll,2);
? ? }?
? ? #else
? ? if (use_napi) {
? ? ? ? dev->poll = snull_poll;
? ? ? ? dev->weight = 2;
? ? }
? ? #endif
? ? memset(priv, 0, sizeof(struct snull_priv));
? ? spin_lock_init(&priv->lock);
? ? snull_rx_ints(dev, 1);? ? ? ? /* enable receive interrupts */
? ? snull_setup_pool(dev);

printk("snull_init\n");
}

/*
?* The devices
?*/

struct net_device *snull_devs[2];

/*
?* Finally, the module stuff
?*/

void snull_cleanup(void)
{
? ? int i;
? ??
? ? for (i = 0; i < 2;? i++) {
? ? ? ? if (snull_devs[i]) {
? ? ? ? ? ? unregister_netdev(snull_devs[i]);
? ? ? ? ? ? snull_teardown_pool(snull_devs[i]);
? ? ? ? ? ? free_netdev(snull_devs[i]);
? ? ? ? }
? ? }
? ? return;
}

int snull_init_module(void)
{
? ? int result, i, ret = -ENOMEM;

snull_interrupt = use_napi ? snull_napi_interrupt : snull_regular_interrupt;
? ??
? ? /* Allocate the devices */
? ? snull_devs[0] = alloc_netdev(sizeof(struct snull_priv), "sn%d",
? ? ? ? ? ? snull_init);
? ? snull_devs[1] = alloc_netdev(sizeof(struct snull_priv), "sn%d",
? ? ? ? ? ? snull_init);
? ? if (snull_devs[0] == NULL || snull_devs[1] == NULL)
? ? ? ? goto out;

ret = -ENODEV;
? ? for (i = 0; i < 2;? i++)
? ? ? ? if ((result = register_netdev(snull_devs[i])))
? ? ? ? ? ? printk("snull: error %i registering device "%s"\n",
? ? ? ? ? ? ? ? ? ? result, snull_devs[i]->name);
? ? ? ? else
? ? ? ? ? ? ret = 0;

printk("snull_init_module\n");
? ? ? ? ? ??
? out:
? ? if (ret)?
? ? ? ? snull_cleanup();
? ? return ret;
}

module_init(snull_init_module);
module_exit(snull_cleanup);

makefile：

# Comment/uncomment the following line to disable/enable debugging
#DEBUG = y

# Add your debugging flag (or not) to CFLAGS
ifeq ($(DEBUG),y)
? DEBFLAGS = -O -g -DSBULL_DEBUG # "-O" is needed to expand inlines
else
? DEBFLAGS = -O2
endif

EXTRA_CFLAGS += $(DEBFLAGS)
EXTRA_CFLAGS += -I..

ifneq ($(KERNELRELEASE),)
# call from kernel build system

obj-m? ? := snull.o

else

KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD? ? ? := $(shell pwd)

default:
? ? $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

endif

運行：

# insmod snull.ko
snull_init
snull_init
snull_stats
snull_stats
snull_init_module
# ifconfig sn0 local0
snull_open
snull_stats
# ifconfig sn1 local1
snull_open
snull_stats
# ping -c 1 remote0
PING remote0 (192.168.2.9): 56 data bytes
len = 84
type = 800
h_proto = 8
addr_len = 6
dev_addr = 00.53.4e.55.4c.30
daddr = 00.53.4e.55.4c.30
h_source = 00.53.4e.55.4c.30
h_dest = 00.53.4e.55.4c.30
h_dest[ETH_ALEN-1] ^ 0x01 = 31
hard_header_len = 14
skb->len = 98
snull_tx
?00 53 4e 55 4c 31 00 53 4e 55 4c 30 08 00
?45 00 00 54 00 00 40 00 40 01 b5 47 c0 a8 02 08 c0 a8 02 09
?08 00 d0 0e 09 03 00 00 bc e8 62 05 00 00 00 00 00 00 00 00
?00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
ih->protocol = 1 is buf[23]
saddr = 192.168.2.8
daddr = 192.168.2.9
c0a80308:02048 --> c0a80309:53262
snull_devs[0]
tx_buffer->datalen = 98
priv->status = 1
priv->status = 1
skb->dev is snull_devs[1]
skb->protocol = 8
snull_rx
snull_release_buffer
snull_regular_interrupt
snull_interrupt(0, dest, NULL);
priv->status = 2
snull_regular_interrupt
snull_interrupt(0, dev, NULL);
len = 84
type = 800
h_proto = 8
addr_len = 6
dev_addr = 00.53.4e.55.4c.31
daddr = 00.53.4e.55.4c.31
h_source = 00.53.4e.55.4c.31
h_dest = 00.53.4e.55.4c.31
h_dest[ETH_ALEN-1] ^ 0x01 = 30
hard_header_len = 14
skb->len = 98
snull_tx
?00 53 4e 55 4c 30 00 53 4e 55 4c 31 08 00
?45 00 00 54 a0 17 00 00 40 01 53 30 c0 a8 03 09 c0 a8 03 08
?00 00 d8 0e 09 03 00 00 bc e8 62 05 00 00 00 00 00 00 00 00
?00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
ih->protocol = 1 is buf[23]
saddr = 192.168.3.9
daddr = 192.168.3.8
c0a80208:55310 <-- c0a80209:00000
snull_devs[1]
tx_buffer->datalen = 98
priv->status = 1
priv->status = 1
skb->dev is snull_devs[0]
skb->protocol = 8
snull_rx
snull_release_buffer
snull_regular_interrupt
snull_interrupt(0, dest, NULL);
priv->status = 2
snull_regular_interrupt
snull_interrupt(0, dev, NULL);
64 bytes from 192.168.2.9: seq=0 ttl=64 time=159.673 ms

--- remote0 ping statistics ---
1 packets transmitted, 1 packets received, 0% packet loss
round-trip min/avg/max = 159.673/159.673/159.673 ms

分析現象：

1.當執行ping命令后，驅動首先會調用snull_header

printk("len = %d\n", len);

printk("type = %02x\n", type); //ETH_P_IP? ? 0x0800? ? ? ? /* Internet Protocol packet? ? */

因為應用層要發送數據包了，所以要為這個數據包添加硬件地址，即以太網地址首部，才能通過網卡發送出去。

2.? 然后內核會通過調用snull_tx發送數據包，snull_tx調用了snull_hw_tx，在這里更改本地IP為目標IP，并把本地要發的數據直接拷貝給目標網卡，代表目標網卡以接收到數據，并觸發接收完成中斷，向應用層上報數據，接著觸發發送完成中斷，表示數據已經發送到目標網卡。

3. 數據包分析：

static void snull_hw_tx(char *buf, int len, struct net_device *dev)

這里的buf為應用層要發送的數據包，數據包格式為：14字節以太網首部+20字節IP地址首部+20字節TCP地址首部+n字節數據

/* [cgw]: 14字節以太網首部 */
? ? ? ? for (i=0 ; i<14; i++)
? ? ? ? ? ? printk(" %02x",buf[i]&0xff);
? ? ? ? printk("\n");

/* [cgw]: 20字節IP地址首部 */
? ? ? ? for (i=14 ; i<34; i++)
? ? ? ? ? ? printk(" %02x",buf[i]&0xff);
? ? ? ? printk("\n");

/* [cgw]: 20字節TCP地址首部 */
? ? ? ? for (i=34 ; i<54; i++)
? ? ? ? ? ? printk(" %02x",buf[i]&0xff);
? ? ? ? printk("\n");

/* [cgw]: n字節數據 */
? ? ? ? for (i=54 ; i? ? ? ? ? ? printk(" %02x",buf[i]&0xff);
? ? ? ? printk("\n");

打印結果：

00 53 4e 55 4c 30 00 53 4e 55 4c 31 08 00 //14字節以太網首部 45 00 00 54 a0 17 00 00 40 01 53 30 c0 a8 03 09 c0 a8 03 08 //20字節IP地址首部 00 00 d8 0e 09 03 00 00 bc e8 62 05 00 00 00 00 00 00 00 00 //20字節TCP地址首部 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 //n字節數據

其中：00 53 4e 55 4c 30 就硬件地址\0SNUL0的ASCII碼，00 53 4e 55 4c 31 就硬件地址\0SNUL1的ASCII碼。
c0 a8 02 08表示本地IP地址local0：192.168.2.8， c0 a8 02 09表示本地IP地址remote0：192.168.2.9。

代表 00 53 4e 55 4c 31 00 53 4e 55 4c 30 08 00 的結構體是：

1 struct ethhdr {2 unsigned char h_dest[ETH_ALEN]; /* destination eth addr */3 unsigned char h_source[ETH_ALEN]; /* source ether addr */4 __be16 h_proto; /* packet type ID field */5 } __attribute__((packed));

即h_ptoto = 0x08 （0x0800,經過htons轉換為0x08）

代表45 00 00 54 00 00 40 00 40 01 b5 47 c0 a8 02 08 c0 a8 02 09的結構體是：

struct iphdr {
#if defined(__LITTLE_ENDIAN_BITFIELD)
? ? __u8? ? ihl:4,
? ? ? ? version:4;
#elif defined (__BIG_ENDIAN_BITFIELD)
? ? __u8? ? version:4,
? ? ? ? ? ihl:4;
#else
#error? ? "Please fix "
#endif
? ? __u8? ? tos;
? ? __be16? ? tot_len;
? ? __be16? ? id;
? ? __be16? ? frag_off;
? ? __u8? ? ttl;
? ? __u8? ? protocol;
? ? __sum16? ? check;
? ? __be32? ? saddr;
? ? __be32? ? daddr;
? ? /*The options start here. */
};

代表 08 00 d0 0e 09 03 00 00 bc e8 62 05 00 00 00 00 00 00 00 00 的結構體是：

struct tcphdr {
? ? __be16? ? source;
? ? __be16? ? dest;
? ? __be32? ? seq;
? ? __be32? ? ack_seq;
#if defined(__LITTLE_ENDIAN_BITFIELD)
? ? __u16? ? res1:4,
? ? ? ? doff:4,
? ? ? ? fin:1,
? ? ? ? syn:1,
? ? ? ? rst:1,
? ? ? ? psh:1,
? ? ? ? ack:1,
? ? ? ? urg:1,
? ? ? ? ece:1,
? ? ? ? cwr:1;
#elif defined(__BIG_ENDIAN_BITFIELD)
? ? __u16? ? doff:4,
? ? ? ? res1:4,
? ? ? ? cwr:1,
? ? ? ? ece:1,
? ? ? ? urg:1,
? ? ? ? ack:1,
? ? ? ? psh:1,
? ? ? ? rst:1,
? ? ? ? syn:1,
? ? ? ? fin:1;
#else
#error? ? "Adjust your defines"
#endif? ??
? ? __be16? ? window;
? ? __sum16? ? check;
? ? __be16? ? urg_ptr;
};

NAPI

NAPI的全稱是“NEW API”。

要使用NAPI功能，只要在加載snull.ko的添加一句use_napi=1就行了

如：#insmod snull.ko use_napi=1

NAPI有什么作用？

NAPI是一種使用輪詢（poll）的方式去接收數據。如當系統需要接收一大坨數據時，數據量比較大時，這個時候數據的接收就不應該在中斷中進行。即產生接收完成中斷后，立即禁止中斷，通知內核調用poll，輪詢接收數據，接收完成后，再使能接收中斷。這樣大大提高系統的性能。

在驅動初始化時：分配好poll函數

1 if (use_napi) {2 dev->poll = snull_poll;3 dev->weight = 2;4 }

在接收中斷中

if (statusword & SNULL_RX_INTR) {
? ? ? ? /* send it to snull_rx for handling */
? ? ? ? pkt = priv->rx_queue;
? ? ? ? if (pkt) {
? ? ? ? ? ? priv->rx_queue = pkt->next;
? ? ? ? ? ? /* [cgw]: 網卡接收到數據，上報給應用層 */
? ? ? ? ? ? snull_rx(dev, pkt);
? ? ? ? }
? ? }

改為

1 if (statusword & SNULL_RX_INTR) {2 snull_rx_ints(dev, 0); /* Disable further interrupts */3 //napi_schedule(&priv->napi);4 netif_rx_schedule(dev);5 }

在中斷中，直接通知內核調用snull_poll即可，snull_poll輪詢接收數據，并上報給應用層。

閱讀全文

驅動(84267) 驅動(84267)
Linux(206513) Linux(206513)

linux系統和驅動中按鍵驅動的編寫詳解

滿足各種各樣的需求。出身FPGA的工程師們也必須擁抱這些變化，不僅僅要精通FPGA開發，還需要了解其他方面的知識。比如基于zynq的開發者，就需要了解arm，linux驅動以及linux系統。做深度學習加速的還需要了解深度學習網絡以及網絡壓縮等知識。學習這些知識會讓你的

2020-11-21 11:03:55

3025

從網絡啟動linux系統如何做調試

從網絡啟動 linux 系統的唯一目的就是為了調試！不管是為了調試 linux 系統還是 linux 下的驅動。

2022-10-09 15:23:29

1255

Linux驅動開發:字符設備驅動開發理論

大部分學習者的最終目的就是學習 Linux驅動開發，Linux中的外設驅動可以分為：字符設備驅動、塊設備驅動和網絡設備驅動。

2022-10-26 09:53:36

679

一文全面了解linux相關知識

今天浩道跟大家分享linux實用場景相關的實例，助你全面了解linux相關知識。

2023-01-29 11:09:09

374

Linux內核的作用

Linux操作系統是當今世界上最為廣泛使用的開源操作系統之一，內核則是一個操作系統的核心和靈魂所在。對于一名Linux驅動開發者來說，了解Linux內核的運行機制和Linux內核提供的一些關鍵功能（如虛擬內存管理、進程管理、文件系統、網絡協議棧等）都是我們日常工作和學習的重點。

2023-07-06 11:46:41

1046

Linux 入門十法

啟動 U 盤。如何使用從 U 盤啟動一個 “實時 Linux” 可提供完整的 Linux 發行版環境。雖然數據存儲與你安裝到硬盤驅動器的系統略有不同，但其它的所有內容都與你在 Linux 桌面上所期望

2020-05-14 11:18:34

Linux網絡驅動的接口函數

Linux 網絡驅動詳解

2019-04-08 06:40:36

Linux下LED燈驅動原理

不同的是，在 Linux 下編寫驅動要符合 Linux的驅動框架。41.1.1 地址映射在編寫驅動之前，我們需要先簡單了解一下 MMU 這個神器， MMU 全稱叫做 MemoryManage Unit，也就是內存管理單元。在老版本的 Linux 中要求處理器必須有 MMU，但是現在Linux 內核已經支

2021-12-15 09:11:24

Linux入門之一：LInux系統環境及命令使用

Internet 網絡，并經過全世界各地計算機愛好者的共同努力下，現已成為今天世界上使用最多的一種UNIX 類操作系統，并且使用人數還在迅猛增長。 LInux常見桌面發行版本：RedHat 、Debian

2012-05-26 15:31:08

Linux基礎

一：嵌入式c語言：Linux基礎　　Linux操作系統的概念、安裝方法，詳細了解Linux下的目錄結構、基本命令、編輯器VI ,編譯器GCC，調試器GDB和 Make 項目管理工具, Shell

2017-08-03 09:46:54

Linux常見的命令有哪些

。3.2 Linux常見命令本節對進行嵌入式Linux開發經常會用到的一些操作和相關命令，進一步加深對Linux的了解。命令是Linux最重要的人機交互界面之一，學習和掌握Linux命

2021-10-28 10:06:50

Linux怎么調用系統底層驅動的

，但是你要學習內核，你首先要會用Linux，知道Linux是如何操作，繼而才能了解Linux怎么調用系統底層驅動的。當時的我只是知道Linux是獨立于Windows的另一個操作系統...

2021-11-05 07:20:55

Linux新手要了解的十個知識點

/doc。5.在Linux系統下，所有的目錄顯示在單一目錄樹下(有別于DOS系統的驅動器標識)。這意味著所有的物理設備上的所有文件和目錄都合并在單一的目錄樹下。6.在配置文件里，以#打頭的行是注釋行

2016-04-02 16:22:37

Linux是如何操作的

，但是你要學習內核，你首先要會用Linux，知道Linux是如何操作，繼而才能了解Linux怎么調用系統底層驅動的。當時的我只是知道Linux是獨立于Windows的另一個操作系統。但是由于其...

2021-11-05 07:43:41

Linux設備驅動程序開發 - Linux設備驅動類型

O***oy觀點：本帖子您應該學到的知識點就是，什么是字符型設備，塊型設備，網絡設備，和mtd設備驅動的特點。大家可以根據該帖子提出的觀點，baidu，google進行擴展閱讀。　 Linux設備

2016-04-16 14:31:57

Linux資料幫你理清思路

的套接字編程及并發控制，想想都激動。如果你有這些本事，可以試著往暴雪投簡歷，為他們寫服務器后臺，想一想全球的魔獸都運行在你的服務器軟件上?！　?b class="flag-6" style="color: red">Linux內核 TCP/IP協議棧 – 深入了解TCP/IP

2018-11-30 16:33:43

linux學習之路（學linux必看）

論上來說是最好的。如果你專注于Linux服務器，如網絡管理，架站，那么CentOS是你的選擇。LFS，終極黑客顯擺工具，完全從源代碼安裝，編譯系統。安裝前你得到的只有一份文檔，你要做的就是照文檔你的說明，一

2018-05-03 14:09:32

linux的網絡驅動

目前正在學習linux下飛思卡爾imx6q_sabre的ARM A9開發板的網絡驅動，學的云里霧里的，哪位高手幫忙指點一下，最好從代碼的角度來說。上層用戶發送數據通建立socket、經過協議棧、經過網卡發送到網絡上，大概都需要哪些函數接口，芯片內部的網絡支持驅動通常在哪個目錄下？

2013-08-22 15:23:40

linux的網絡設備驅動之alloc_etherdev

linux網絡設備驅動之alloc_etherdev

2020-06-19 11:22:23

linux要怎么學習

2020-06-09 04:35:41

一文帶你深入了解linux驅動

根本都不知道這個佛是哪一路神仙。那今天我們就先帶大家來深入了解下嵌入式開發中至關重要的一環：linux驅動。在學習驅動之前，我們首先來了解下操作系統。 # 操作系統OPERATING SYSTEM

2020-04-15 09:59:21

一文讓你了解無線傳感器網絡

的發展，而且無線傳感器技術結合了嵌入式系統技術、傳感器技術、現代網絡以及無線通信技術，所以它本身也是一個熱點的研究領域。今天我們就來了解下無線傳感器網絡。無線傳感器網絡（WSN）是一種分布式傳感網絡

2018-11-09 16:21:19

了解嵌入式系統學習的步驟

問題了解線程的概念能夠編寫簡單的多線程程序編寫一個多線程程序 8、嵌入式 Linux 網絡編程網絡基礎知識嵌入式Linux中TCP/IP網絡結構 socket 編程常用 API函數分析Ping

2013-02-25 09:51:20

你都了解哪些Zigbee術語？

2021-05-20 07:12:05

驅動程序的基礎知識

Linux 已成為最流行的操作系統之一，因此開發專有設備驅動程序的興趣也在穩步增長。本文最初將幫助您了解驅動程序的基礎知識，并為熟悉 Linux 內核的漫長旅程做好準備。涵蓋了基于各種 Linux 子系統

2021-12-24 08:15:32

Mini Linux

Mini Linux EMMC

2023-03-28 13:06:25

[分享資料]linux設備驅動開發詳解_宋寶華

`一、看威武霸氣的封面作者：宋寶華二、讀讀簡介，看看適合你嗎？這是一本介紹Linux設備驅動開發理論、框架與實例的書，《Linux設備驅動開發詳解（第2版）》基于LDD6410開發板，以

2015-09-11 23:36:44

[轉]搞嵌入式驅動開發一年多的感觸

的做好類似的工作，你應該去看些其它的什么東西;二是你一定至少要在工作的開發環境中使用linux作為你的平時工作平臺，而不要使用虛擬機和服務期，因為你只有完全了解了linux的使用，你才可以為它開發符合它規則的項目。本文轉自網絡，感謝原作者辛苦分享

2019-02-19 10:01:35

【下載】精通Linux設備驅動程序開發+UNIX網絡編程

　網絡接口卡第16章　Linux無線設備驅動第17章　存儲技術設備第18章　嵌入式Linux第19章　用戶空間的驅動程序第20章　其他設備和驅動程序第21章　調試設備驅動程序第22章　維護與發布第23章

2017-06-05 18:38:10

為你的 Linux 服務器加把鎖

80 或 8080 端口。總之一句話，不確定的話，就關了它先。在一個最簡單的，沒有做過任何額外更改的 Linux 服務器上，你會看到 SSH、 RPC 和 NTPdate 運行在它們的公開端口上。不要

2016-12-31 11:01:17

什么是linux設備驅動看了就知道

想要深入理解linux設備驅動，你必須明確以下幾個問題：· 應用程序、庫、內核、驅動程序的關系· 設備類型· 設備文件、主設備號與從設備號· 驅動程序與應用程序的區別· 用戶態與內核態· Linux驅動程序功能

2021-04-06 06:50:40

介紹學習Linux的一些建議

一個適合你的Linux發行版本：目前全球有超過1百多個Linux發行版本，在國內也能找到十幾個常見版本。如何選擇請根據你的需求和能力，Redhat Linux 和Debian Linux是網絡

2018-08-18 02:17:57

作為一個新人，如何學習嵌入式linux

應用，之間并沒有一個界線，有底層經驗，再去做應用，你會感覺很踏實。有了業務經驗，你再了解一下底層，很快就可以組成一個團隊?；氐皆趺磳W的問題上。嵌入式Linux底層系統包含哪些東西？不要急，舉一個例子你

2015-02-04 11:09:10

作為一個新人，怎樣學習嵌入式Linux？

專家。 4. 其實，做底層還是做應用，之間并沒有一個界線，有底層經驗，再去做應用，你會感覺很踏實。有了業務經驗，你再了解一下底層，很快就可以組成一個團隊。回到怎么學的問題上。嵌入式Linux底層

2014-08-25 16:33:45

分享給你一些實用的Linux技巧

某個東西為什么出錯時，sar命令會有用。它可以讓你看看 CPU, 內存, 網絡, 等的統計信息。使用 dmesg 來查看一些硬件或驅動程序的信息或問題。

2016-08-29 09:43:46

分享給你一些實用的Linux技巧

某個東西為什么出錯時，sar命令會有用。它可以讓你看看 CPU, 內存, 網絡, 等的統計信息。使用 dmesg 來查看一些硬件或驅動程序的信息或問題。

2016-08-21 17:13:05

單片機知識是Linux驅動開發的基礎之一

，你寫個main()就可以了，然后調用各種庫，進行傻瓜式操作。這些好用的工具，封裝了很多技術細節，使得我們沒法了解裸機、單片機的本質。以后我們會使用新一套的方法來進行單片機的開發。新一套的方法，我們后面

2018-03-06 17:41:24

發燒友與您分享一些實用的Linux技巧

用。它可以讓你看看 CPU, 內存, 網絡, 等的統計信息。深圳專業嵌入式實訓QQ754634522使用 dmesg 來查看一些硬件或驅動程序的信息或問題。

2014-04-09 10:23:51

如何學習LINUX驅動開發？

如何學習LINUX驅動開發？很多朋友認為Linux驅動開發學起來很難，如何學習linux驅動開發？下面筆者就說說我的學習經驗吧。 1. 學會寫簡單的makefile 2. 編一

2014-05-07 11:59:53

如何學習LINUX驅動開發？

2014-05-07 12:17:27

如何學習Linux

分：LINUX驅動開發驅動開發是嵌入式Linux開發難度最高的內容，也是目前嵌入式行業最緊缺的人才之一。本課程介紹嵌入式Linux驅動開發相關概念及開發流程，了解驅動開發的關鍵技術點，重點講解嵌入式

2017-10-10 15:06:32

如何學習linux設備驅動

就可驗證，當你按照手里的經典著作，如：Alessandro的《linux設備驅動程序》，編寫驅動時，發現并不能夠成功的在你的linux平臺上編譯通過、或不能正常執行，原因就在于你用的內核和書里的不一

2011-07-06 13:12:29

如何編譯linux驅動模塊

在嵌入式系統應用中，嵌入式linux是非常重要的一個方面，而linux驅動編譯又是嵌入式linux中至關重要的一個環節。下面，本文將詳細講解如何編譯linux驅動模塊。首先，我們要了解一下模塊

2021-11-04 08:45:37

嵌入式LINUX應該學什么？做驅動還是做應用

行業、IPTV行業、手機行業，你了解行業的需求所以，當領導的人，多是做應用的，顯然，就職位來講，做應用的市場需求肯定比做驅動的多。3. 做驅動，其實我不想稱為“做驅動”，而是想稱為“做底層

2014-08-07 00:04:32

嵌入式Linux了解

，但是你要學習內核，你首先要會用Linux，知道Linux是如何操作，繼而才能了解Linux怎么調用系統底層驅動的。當時的我只是知道Linux是獨立于Windows的另一個操作系統。但是由于其開源免費的...

2021-11-05 09:05:08

嵌入式Linux網絡驅動程序的體系結構和實現原理是什么

嵌入式Linux網絡驅動程序是什么嵌入式Linux網絡驅動程序的體系結構和實現原理如何將設備驅動模塊編譯進內核

2021-04-26 06:03:26

嵌入式Linux網絡驅動程序的實現原理是什么？

嵌入式Linux網絡驅動程序的結構是如何構成的？嵌入式Linux網絡驅動程序的實現原理是什么？如何將設備驅動模塊編譯進內核里？

2021-06-04 06:25:40

嵌入式Linux驅動程序開發大概了解

1.嵌入式Linux驅動程序開發嵌入式Linux驅動程序開發包羅萬象，基本上每個點都要大概了解一下。1.1軟件工具Makefile必須要掌握一些，至于Kconfig太簡單了只是個配置文件算不上程序

2021-11-02 10:17:37

嵌入式Linux初學者快速了解和入門

PS: 本文轉載于網絡，具體出處不明。為了方便廣大嵌入式 Linux 初學者快速了解和入門，同時也記錄一下，故轉載原文，僅用于學習和交流，感謝原作者！從上圖可以知道：① 組成：嵌入式Linux系統

2021-11-05 06:12:28

嵌入式Linux系統開發學習步驟，深圳嵌入式Linux培訓高薪一路相伴

協議、socket編程、TCP網絡編程、UDP網絡編程、Web編程開發等方面入手，全面了解Linux網絡應用程序開發。重點學習網絡編程相關API，熟練掌握TCP協議服務器的編程方法和并發服務器的實現

2015-11-25 17:23:50

嵌入式Linux過程

2021-11-05 06:46:15

嵌入式linux入門學習書籍推薦

的選擇?！　〉诹骸渡钊肜斫?b class="flag-6" style="color: red">LINUX網絡內幕》　　一本講解網絡子系統實現的書，通過這本書，我們可以了解到Linux內核是如何實現復雜的網絡功能的。第七：《LINUX內核情景分析》要想把自己打造成高手

2015-10-08 09:17:16

嵌入式linux入門學習書籍推薦　

，是一本介紹Linux虛擬內存管理機制的書。如果你希望深入的研究Linux的內存管理子系統，仔細的研讀這本書無疑是最好的選擇?！　〉诹骸渡钊肜斫?b class="flag-6" style="color: red">LINUX網絡內幕》　　一本講解網絡子系統實現的書

2015-10-18 10:13:53

徐工告訴你嵌入式都要學習哪些東西？

到模擬電路知識，這是區別好手與菜鳥的不同之處之一。　　10）Linux 下的匯編要學，這樣你才能真正了解你寫的程序是如何在一個特定的硬件上跑的。這是區別好手與菜鳥的不同之處之二。　　11）TCP

2014-11-10 14:49:10

總結了些關于linux學習什么的一些課程設置

跟文件系統制作過程3、根文件系統介紹4. nfs文件服務器系統搭建第七部分：LINUX驅動開發驅動開發是嵌入式Linux開發難度最高的內容，也是目前嵌入式行業最緊缺的人才之一。本課程介紹嵌入式

2017-07-29 15:07:59

總結分享linux系統驅動怎么學

的話，也是要花時間去了解那些類、控件的。如果你想學習底層系統，這是我的專長，倒是可以說一點。在回答這個問題之前，我先回答：不少人問我，到底是學驅動還是學應用？我只能說憑興趣，并且驅動和應用并不是截然

2020-11-11 09:45:57

成為一名嵌入式Linux開發工程師需要學習哪些知識？

過程中使用非常廣泛，通過Linux網絡發展、TCP/IP協議、socket編程、TCP網絡編程、UDP網絡編程、Web編程開發等方面入手，全面了解Linux網絡應用程序開發。重點學習網絡編程相關API，熟練掌握

2013-11-05 11:23:16

成為一名嵌入式Linux開發工程師需要學習哪些知識？

2014-04-15 09:35:36

成為一名嵌入式Linux開發工程師需要學習哪些知識？

2016-05-23 10:15:05

成為一名嵌入式Linux開發工程師需要學習哪些知識？

高級字符設備、塊設備、網絡設備、USB設備等驅動開發，在工作中能獨立勝任底層驅動開發?！　∫陨暇褪橇谐龅年P于一名合格嵌入式Linux開發工程師所必學的理論知識，其實，作為一個嵌入式開發人員，專業知識

2014-06-05 11:31:47

成為一名嵌入式Linux開發工程師需要學習哪些知識？

2015-11-13 10:04:20

搞Linux設備驅動，你應該明白這幾個問題

想要深入理解linux設備驅動，你必須明確以下幾個問題：· 應用程序、庫、內核、驅動程序的關系· 設備類型· 設備文件、主設備號與從設備號· 驅動程序與應用程序的區別· 用戶態與內核態· Linux

2017-12-01 16:04:04

搞Linux設備驅動，你應該明白這幾個問題

搞Linux設備驅動，你應該明白這幾個問題想要深入理解linux設備驅動，你必須明確以下幾個問題：· 應用程序、庫、內核、驅動程序的關系· 設備類型· 設備文件、主設備號與從設備號· 驅動

2017-04-07 09:10:33

搞Linux設備驅動，你應該明白這幾個問題~

2017-03-23 10:40:34

搞Linux設備驅動，你應該明白這幾個問題~

2017-03-25 18:55:10

新手求助 linux 驅動

本人菜鳥一枚，正在學習嵌入式linux，老師交個任務，要求寫一個用戶程序對內存空間地址的讀寫的linux驅動程序?？催^一些驅動的原理，主要是定義一些功能跟函數，還有注冊設備。但對具體的操作不是太了解，比方說需要哪些編譯軟件，調試軟件，還有代碼應該注意什么等等，求高人指點

2013-04-09 16:30:26

是否有一個標準的Linux驅動程序為EZUB-FX3提供Linux網絡接口？

我們正在考慮使用EZUB-FX3芯片進行設計。我們希望使用Linux以太網接口與設計進行通信，該接口與EZUB-FX3交換數據包。是否有一個標準的Linux驅動程序為EZUB-FX3提供Linux

2019-02-25 11:00:15

談談學習嵌入式linux驅動的小竅門

的驅動程序是項目成功的關鍵，那么嵌入式linux驅動如何學呢?那我就來談談學習嵌入式linux驅動的小竅門，這可是珍藏版哦。首先嵌入式linux驅動你要了解，驅動和linux是兩碼事，就拿一個lcd來說，我...

2021-11-04 06:23:01

阿爾法Linux

阿爾法Linux ATK-IMX6F800E8GD512M-B 6~24V

2023-03-28 13:06:25

面對不斷升級的內核，我們該如何學習LINUX設備驅動？

的經典著作，如：Alessandro的《linux設備驅動程序》，編寫驅動時，發現并不能夠成功的在你的linux平臺上編譯通過、或不能正常執行。你的朋友會告訴你，你用的內核和書里的不一致。那該怎么辦呢

2018-09-29 11:04:26

頻率和時序，你是否真的了解呢？

影響內存的關鍵因素是哪些？頻率和時序，你是否真的了解呢？時序與頻率有什么區別？哪個對內存性能影響大？

2021-06-18 07:15:39

基于USB設備的Linux網絡驅動程序開發

介紹Linux 的體系結構及其網絡子系統，并結合USB 設備在Linux 下的訪問機制，給出了一種USB 網絡驅動程序的設計方法。該設計方法充分利用Linux 網絡子系統和USB總線提供的支持

2009-08-11 11:23:49

嵌入式Linux網絡驅動程序的開發及實現原理

分析Linux 網絡驅動程序體系結構的基礎上，結合利用Linux2.6.18 內核在FS2410 開發板上移植編寫CS8900A 網卡驅動程序的實例，重點討論了嵌入式Linux 網絡驅動程序的實現原理，并詳細分

2009-09-03 11:46:32

基于BF533的Linux網絡驅動程序

在分析Linux網絡驅動程序體系結構的基礎上，結合Linux2.6.18內核在ADSP鄄BF533開發板上移植編寫CS8900A網卡驅動程序的實例，重點討論了嵌入式Linux網絡驅動程序的實現原理，并詳細分析

2010-12-25 16:22:46

Linux服務器網卡驅動安裝及問題排除

Linux服務器網卡驅動安裝及問題排除網卡是Linux服務器中最重要網絡設備。據統計，Linux網絡故障有35％在物理層、25％在數據鏈路層、

2010-01-11 11:51:02

1223

嵌入式Linux網絡驅動程序開發設計

嵌入式Linux網絡驅動程序的開發及實現原理引言隨著人們對開放源代碼軟件熱情的日益增高，Linux作為一個功能強大而穩定的開源操作系統，越來越受到成千上

2010-05-17 09:31:29

957

《Linux設備驅動開發詳解》第23章、Linux設備驅動的移植

《Linux設備驅動開發詳解》第23章、Linux設備驅動的移植

2017-10-27 10:58:13

《Linux設備驅動開發詳解》第16章、Linux網絡設備驅動

《Linux設備驅動開發詳解》第16章、Linux網絡設備驅動

2017-10-27 11:17:06

《Linux設備驅動開發詳解》第13章、Linux塊設備驅動

《Linux設備驅動開發詳解》第13章、Linux塊設備驅動

2017-10-27 11:24:39

《Linux設備驅動開發詳解》第7章、Linux設備驅動中的并發控制

《Linux設備驅動開發詳解》第7章、Linux設備驅動中的并發控制

2017-10-27 11:37:45

Linux系統網絡驅動程序的編寫

驅動程序編寫一.Linux系統設備驅動程序概述 1.1 Linux設備驅動程序分類 1.2 編寫驅動程序的一些基本概念二.Linux系統網絡設備驅動程序 2.1 網絡驅動程序的結構 2.2 網絡驅動程序的基本方法 2.3 網絡驅動程序中用到的數據結構 2.4 常用的系統支持三。編寫Linux網絡驅動程序中

2017-11-07 10:40:30

Linux設備驅動程序基礎知識的了解

了解Linux設備驅動程序的基礎知識，重點關注設備節點，內核框架，虛擬文件??系統和內核模塊。提出了一個簡單的內核模塊實現。

2018-11-26 06:51:00

2886

需要了解Linux V4L2的驅動架構

video4linux2(V4L2)是Linux內核中關于視頻設備的中間驅動層，向上為Linux應用程序訪問視頻設備提供了通用接口，向下為linux中設備驅動程序開發提供了統一的V4L2框架。

2019-04-28 17:29:13

890

學會安裝Linux的網絡驅動

Linux系統多用于服務器上，Linux非常牢固的支持網絡。在Linux,網絡分為兩個層，分別是網絡堆棧協議支持層，以及接收和發送網絡協議的設備驅動程序層。網絡堆棧是硬件中獨立出來的部分，主要用來支持TCP/IP等多種協議，而網絡設備驅動層是連接網絡堆棧協議層和網絡硬件的中間層。

2019-04-29 14:26:45

678

你對Linux總線設備驅動框架是否了解

Linux的設備驅動模型，或者說，Linux的設備驅動框架，都是同一個意思。應該這樣理解，（Linux的設備）驅動框架，即某類設備對應的驅動的框架。

2019-05-05 15:13:44

583

Linux ALSA聲卡驅動之一：移動設備中的ALSA（ASoC）

Codec驅動與SoC CPU的底層耦合過于緊密，這種不理想會導致代碼的重復，例如，僅是wm8731的驅動，當時Linux中有分別針對4個平臺的驅動代碼。

2019-05-06 15:34:35

1552

你了解過Linux字符設備驅動框架？

字符設備是Linux三大設備之一(另外兩種是塊設備，網絡設備)，字符設備就是字節流形式通訊的I/O設備,絕大部分設備都是字符設備，常見的字符設備包括鼠標、鍵盤、顯示器、串口等等，當我們執行ls -l /dev的時候，就能看到大量的設備文件，c就是字符設備，b就是塊設備，

2019-05-08 14:28:51

341

LINUX內核與驅動的最新編譯方法

在linux源碼樹的驅動目錄增加自己的驅動目錄，比如：現在新增一個網絡設備驅動

2019-05-08 14:42:57

1620

Linux ALSA聲卡驅動之一：ALSA架構簡介

ALSA是Advanced Linux Sound Architecture 的縮寫，目前已經成為了linux的主流音頻體系結構，想了解更多的關于ALSA的這一開源項目的信息和知識

2019-05-10 13:44:27

1373

米爾科技Linux設備驅動研究淺談

、usb設備、網絡設備、pci設備等linux設備驅動的架構和框架中各個復雜數據架構和函數的關系，并講解了linux驅動開發的大量實例，使讀者能夠獨立開發各類linux設備驅動。

2019-11-25 09:32:41

1748

從串口驅動到Linux驅動模型

。從理論到實踐。以便讀者能對OS原理有更深入的了解和更具體的掌握。在具體分析之前。我們必須對串口。驅動。和Linux操作系統有一定的了解。這一階段我們有三個問題需要解決： 1.什么是Linux操作系統。 2.什么是Linux設備驅動。 3.關于串口的種種。要了解這些概

2020-11-04 14:50:31

2396

學Linux驅動：建議先了解總線驅動模型

[導讀] Linux設備林林總總，嵌入式開發一個繞不開的話題就是設備驅動開發，在做具體設備驅動開發之前，有必要對Linux設驅動模型有一個相...

2022-02-07 11:04:51

如何在Linux下使用TC優雅的實現網絡限流

TC 是 Linux 下提供的流量控制工具，也是 Cilium/eBPF 等網絡組件的核心基礎設施之一。

2022-12-26 10:06:50

410

linux安裝網卡驅動教程

在Linux系統中安裝網卡驅動是一個比較基礎的操作，下面我將為你詳細講解如何安裝網卡驅動。第一步，檢查網卡型號和驅動支持情況：首先，你需要確定你的網卡型號，并查看該網卡型號在Linux系統中的驅動

2023-11-17 11:11:11

1197

如何解決Linux系統中的網絡連接問題？

決Linux系統中的網絡連接問題。首先，讓我們了解一下網絡連接問題的常見原因。這些原因包括但不限于錯誤的網絡配置、網絡故障、防火墻設置、DNS問題、硬件故障以及驅動程序問題。在解決網絡連接問題之前，請確保您的硬件和網絡設置是正常工作的，例

2024-01-12 15:17:46

173

已全部加載完成

搜索歷史

你了解Linux網絡驅動之一：snull

評論