Linux TCP/IP协议栈之Socket的实现分析

数据包的接收

作者:kendo
http://www.skynet.org.cn/viewthread.php?tid=14&extra=page%3D1
Kernel:2.6.12

一、从网卡说起

这并非是一个网卡驱动分析的专门文档,只是对网卡处理数据包的流程进行一个重点的分析。这里以Intel的e100驱动为例进行分析。
大多数网卡都是一个PCI设备,PCI设备都包含了一个标准的配置寄存器,寄存器中,包含了PCI设备的厂商ID、设备ID等等信息,驱动
程序使用来描述这些寄存器的标识符。如下:

[Copy to clipboard] [ - ]
CODE:
struct pci_device_id {
        __u32 vendor, device;                /* Vendor and device ID or PCI_ANY_ID*/
        __u32 subvendor, subdevice;        /* Subsystem ID's or PCI_ANY_ID */
        __u32 class, class_mask;        /* (class,subclass,prog-if) triplet */
        kernel_ulong_t driver_data;        /* Data private to the driver */
};

这样,在驱动程序中,常常就可以看到定义一个struct pci_device_id 类型的数组,告诉内核支持不同类型的
PCI设备的列表,以e100驱动为例:

#define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {\
        PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, \
        PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }
       
static struct pci_device_id e100_id_table[] = {
        INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),
        INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),
        INTEL_8255X_ETHERNET_DEVICE(0x1031, 3),
……/*略过一大堆支持的设备*/
        { 0, }
};

在内核中,一个PCI设备,使用struct pci_driver结构来描述,
struct pci_driver {
        struct list_head node;
        char *name;
        struct module *owner;
        const struct pci_device_id *id_table;        /* must be non-NULL for probe to be called */
        int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);        /* New device inserted */
        void (*remove) (struct pci_dev *dev);        /* Device removed (NULL if not a hot-plug capable driver) */
        int  (*suspend) (struct pci_dev *dev, pm_message_t state);        /* Device suspended */
        int  (*resume) (struct pci_dev *dev);                        /* Device woken up */
        int  (*enable_wake) (struct pci_dev *dev, pci_power_t state, int enable);   /* Enable wake event */
        void (*shutdown) (struct pci_dev *dev);

        struct device_driver        driver;
        struct pci_dynids dynids;
};

因为在系统引导的时候,PCI设备已经被识别,当内核发现一个已经检测到的设备同驱动注册的id_table中的信息相匹配时,
它就会触发驱动的probe函数,以e100为例:
/*
* 定义一个名为e100_driver的PCI设备
* 1、设备的探测函数为e100_probe;
* 2、设备的id_table表为e100_id_table
*/
static struct pci_driver e100_driver = {
        .name =         DRV_NAME,
        .id_table =     e100_id_table,
        .probe =        e100_probe,
        .remove =       __devexit_p(e100_remove),
#ifdef CONFIG_PM
        .suspend =      e100_suspend,
        .resume =       e100_resume,
#endif

        .driver = {
                .shutdown = e100_shutdown,
        }

};

这样,如果系统检测到有与id_table中对应的设备时,就调用驱动的probe函数。

驱动设备在init函数中,调用pci_module_init函数初始化PCI设备e100_driver:

static int __init e100_init_module(void)
{
        if(((1 << debug) - 1) & NETIF_MSG_DRV) {
                printk(KERN_INFO PFX "%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
                printk(KERN_INFO PFX "%s\n", DRV_COPYRIGHT);
        }
        return pci_module_init(&e100_driver);
}

一切顺利的话,注册的e100_probe函数将被内核调用,这个函数完成两个重要的工作:
1、分配/初始化/注册网络设备;
2、完成PCI设备的I/O区域的分配和映射,以及完成硬件的其它初始化工作;

网络设备使用struct net_device结构来描述,这个结构非常之大,许多重要的参考书籍对它都有较为深入的描述,可以参考《Linux设备驱动程序》中网卡驱动设计的相关章节。我会在后面的内容中,对其重要的成员进行注释;

当probe函数被调用,证明已经发现了我们所支持的网卡,这样,就可以调用register_netdev函数向内核注册网络设备了,注册之前,一般会调用alloc_etherdev为以太网分析一个net_device,然后初始化它的重要成员。

除了向内核注册网络设备之外,探测函数另一项重要的工作就是需要对硬件进行初始化,比如,要访问其I/O区域,需要为I/O区域分配内存区域,然后进行映射,这一步一般的流程是:
1、request_mem_region()
2、ioremap()

对于一般的PCI设备而言,可以调用:
1、pci_request_regions()
2、ioremap()

pci_request_regions函数对PCI的6个寄存器都会调用资源分配函数进行申请(需要判断是I/O端口还是I/O内存),例如:

[Copy to clipboard] [ - ]
CODE:
int pci_request_regions(struct pci_dev *pdev, char *res_name)
{
        int i;
       
        for (i = 0; i < 6; i++)
                if(pci_request_region(pdev, i, res_name))
                        goto err_out;
        return 0;



[Copy to clipboard] [ - ]
CODE:
int pci_request_region(struct pci_dev *pdev, int bar, char *res_name)
{
        if (pci_resource_len(pdev, bar) == 0)
                return 0;
               
        if (pci_resource_flags(pdev, bar) & IORESOURCE_IO) {
                if (!request_region(pci_resource_start(pdev, bar),
                            pci_resource_len(pdev, bar), res_name))
                        goto err_out;
        }
        else if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) {
                if (!request_mem_region(pci_resource_start(pdev, bar),
                                        pci_resource_len(pdev, bar), res_name))
                        goto err_out;
        }
       
        return 0;

有了这些基础,我们来看设备的探测函数:
static int __devinit e100_probe(struct pci_dev *pdev,
        const struct pci_device_id *ent)
{
        struct net_device *netdev;
        struct nic *nic;
        int err;

        /*分配网络设备*/
        if(!(netdev = alloc_etherdev(sizeof(struct nic)))) {
                if(((1 << debug) - 1) & NETIF_MSG_PROBE)
                        printk(KERN_ERR PFX "Etherdev alloc failed, abort.\n");
                return -ENOMEM;
        }

        /*设置各成员指针函数*/
        netdev->open = e100_open;
        netdev->stop = e100_close;
        netdev->hard_start_xmit = e100_xmit_frame;
        netdev->get_stats = e100_get_stats;
        netdev->set_multicast_list = e100_set_multicast_list;
        netdev->set_mac_address = e100_set_mac_address;
        netdev->change_mtu = e100_change_mtu;
        netdev->do_ioctl = e100_do_ioctl;
        SET_ETHTOOL_OPS(netdev, &e100_ethtool_ops);
        netdev->tx_timeout = e100_tx_timeout;
        netdev->watchdog_timeo = E100_WATCHDOG_PERIOD;
        netdev->poll = e100_poll;
        netdev->weight = E100_NAPI_WEIGHT;
#ifdef CONFIG_NET_POLL_CONTROLLER
        netdev->poll_controller = e100_netpoll;
#endif
        /*设置网络设备名称*/
        strcpy(netdev->name, pci_name(pdev));

        /*取得设备私有数据结构*/
        nic = netdev_priv(netdev);
        /*网络设备指针,指向自己*/
        nic->netdev = netdev;
        /*PCIy设备指针,指向自己*/
        nic->pdev = pdev;
        nic->msg_enable = (1 << debug) - 1;
       
        /*将PCI设备的私有数据区指向网络设备*/
        pci_set_drvdata(pdev, netdev);

        /*激活PCI设备*/
        if((err = pci_enable_device(pdev))) {
                DPRINTK(PROBE, ERR, "Cannot enable PCI device, aborting.\n");
                goto err_out_free_dev;
        }

        /*判断I/O区域是否是I/O内存,如果不是,则报错退出*/
        if(!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
                DPRINTK(PROBE, ERR, "Cannot find proper PCI device "
                        "base address, aborting.\n");
                err = -ENODEV;
                goto err_out_disable_pdev;
        }

        /*分配I/O内存区域*/
        if((err = pci_request_regions(pdev, DRV_NAME))) {
                DPRINTK(PROBE, ERR, "Cannot obtain PCI resources, aborting.\n");
                goto err_out_disable_pdev;
        }

        /*
         * 告之内核自己的DMA寻址能力,这里不是很明白,因为从0xFFFFFFFF来看,本来就是内核默认的32了
         * 为什么还要调用pci_set_dma_mask来重复设置呢?可能是对ULL而非UL不是很了解吧。
         */
        if((err = pci_set_dma_mask(pdev, 0xFFFFFFFFULL))) {
                DPRINTK(PROBE, ERR, "No usable DMA configuration, aborting.\n");
                goto err_out_free_res;
        }

        SET_MODULE_OWNER(netdev);
        SET_NETDEV_DEV(netdev, &pdev->dev);

        /*分配完成后,映射I/O内存*/
        nic->csr = ioremap(pci_resource_start(pdev, 0), sizeof(struct csr));
        if(!nic->csr) {
                DPRINTK(PROBE, ERR, "Cannot map device registers, aborting.\n");
                err = -ENOMEM;
                goto err_out_free_res;
        }

        if(ent->driver_data)
                nic->flags |= ich;
        else
                nic->flags &= ~ich;

        /*设置设备私有数据结构的大部份默认参数*/
        e100_get_defaults(nic);

        /* 初始化自旋锁,锅的初始化必须在调用 hw_reset 之前执行*/
        spin_lock_init(&nic->cb_lock);
        spin_lock_init(&nic->cmd_lock);

        /* 硬件复位,通过向指定I/O端口设置复位指令实现. */
        e100_hw_reset(nic);

        /*
         * PCI网卡被BIOS配置后,某些特性可能会被屏蔽掉。比如,多数BIOS都会清掉“master”位,
         * 这导致板卡不能随意向主存中拷贝数据。pci_set_master函数数会检查是否需要设置标志位,
         * 如果需要,则会将“master”位置位。
         * PS:什么是PCI master?
         * 不同于ISA总线,PCI总线的地址总线与数据总线是分时复用的。这样做的好处是,一方面
         * 可以节省接插件的管脚数,另一方面便于实现突发数据传输。在做数据传输时,由一个PCI
         * 设备做发起者(主控,Initiator或Master),而另一个PCI设备做目标(从设备,Target或Slave)。
         * 总线上的所有时序的产生与控制,都由Master来发起。PCI总线在同一时刻只能供一对设备完成传输。
         */
        pci_set_master(pdev);

        /*添加两个内核定时器,watchdog和blink_timer*/
        init_timer(&nic->watchdog);
        nic->watchdog.function = e100_watchdog;
        nic->watchdog.data = (unsigned long)nic;
        init_timer(&nic->blink_timer);
        nic->blink_timer.function = e100_blink_led;
        nic->blink_timer.data = (unsigned long)nic;

        INIT_WORK(&nic->tx_timeout_task,
                (void (*)(void *))e100_tx_timeout_task, netdev);

        if((err = e100_alloc(nic))) {
                DPRINTK(PROBE, ERR, "Cannot alloc driver memory, aborting.\n");
                goto err_out_iounmap;
        }

        /*phy寄存器初始化*/
        e100_phy_init(nic);

        if((err = e100_eeprom_load(nic)))
                goto err_out_free;

        memcpy(netdev->dev_addr, nic->eeprom, ETH_ALEN);
        if(!is_valid_ether_addr(netdev->dev_addr)) {
                DPRINTK(PROBE, ERR, "Invalid MAC address from "
                        "EEPROM, aborting.\n");
                err = -EAGAIN;
                goto err_out_free;
        }

        /* Wol magic packet can be enabled from eeprom */
        if((nic->mac >= mac_82558_D101_A4) &&
           (nic->eeprom[eeprom_id] & eeprom_id_wol))
                nic->flags |= wol_magic;

        /* ack any pending wake events, disable PME */
        pci_enable_wake(pdev, 0, 0);

        /*注册网络设备*/
        strcpy(netdev->name, "eth%d");
        if((err = register_netdev(netdev))) {
                DPRINTK(PROBE, ERR, "Cannot register net device, aborting.\n");
                goto err_out_free;
        }

        DPRINTK(PROBE, INFO, "addr 0x%lx, irq %d, "
                "MAC addr %02X:%02X:%02X:%02X:%02X:%02X\n",
                pci_resource_start(pdev, 0), pdev->irq,
                netdev->dev_addr[0], netdev->dev_addr[1], netdev->dev_addr[2],
                netdev->dev_addr[3], netdev->dev_addr[4], netdev->dev_addr[5]);

        return 0;

err_out_free:
        e100_free(nic);
err_out_iounmap:
        iounmap(nic->csr);
err_out_free_res:
        pci_release_regions(pdev);
err_out_disable_pdev:
        pci_disable_device(pdev);
err_out_free_dev:
        pci_set_drvdata(pdev, NULL);
        free_netdev(netdev);
        return err;
}
执行到这里,探测函数的使命就完成了,在对网络设备重要成员初始化时,有:
netdev->open = e100_open;
指定了设备的open函数为e100_open,这样,当第一次使用设备,比如使用ifconfig工具的时候,open函数将被调用。

二、打开设备

在探测函数中,设置了netdev->open = e100_open; 指定了设备的open函数为e100_open:

[Copy to clipboard] [ - ]
CODE:
static int e100_open(struct net_device *netdev)
{
        struct nic *nic = netdev_priv(netdev);
        int err = 0;

        netif_carrier_off(netdev);
        if((err = e100_up(nic)))
                DPRINTK(IFUP, ERR, "Cannot open interface, aborting.\n");
        return err;
}

大多数涉及物理设备可以感知信号载波(carrier)的存在,载波的存在意味着设备可以工作
据个例子来讲:当一个用户拔掉了网线,也就意味着信号载波的消失。
netif_carrier_off:关闭载波信号;
netif_carrier_on:打开载波信号;
netif_carrier_ok:检测载波信号;

对于探测网卡网线是否连接,这一组函数被使用得较多;

接着,调用e100_up函数启动网卡,这个“启动”的过程,最重要的步骤有:
1、调用request_irq向内核注册中断;
2、调用netif_wake_queue函数来重新启动传输队例;

[Copy to clipboard] [ - ]
CODE:
static int e100_up(struct nic *nic)
{
        int err;

        if((err = e100_rx_alloc_list(nic)))
                return err;
        if((err = e100_alloc_cbs(nic)))
                goto err_rx_clean_list;
        if((err = e100_hw_init(nic)))
                goto err_clean_cbs;
        e100_set_multicast_list(nic->netdev);
        e100_start_receiver(nic, 0);
        mod_timer(&nic->watchdog, jiffies);
        if((err = request_irq(nic->pdev->irq, e100_intr, SA_SHIRQ,
                nic->netdev->name, nic->netdev)))
                goto err_no_irq;
        netif_wake_queue(nic->netdev);
        netif_poll_enable(nic->netdev);
        /* enable ints _after_ enabling poll, preventing a race between
         * disable ints+schedule */
        e100_enable_irq(nic);
        return 0;

err_no_irq:
        del_timer_sync(&nic->watchdog);
err_clean_cbs:
        e100_clean_cbs(nic);
err_rx_clean_list:
        e100_rx_clean_list(nic);
        return err;

}

这样,中断函数e100_intr将被调用;

三、网卡中断

从本质上来讲,中断,是一种电信号,当设备有某种事件发生的时候,它就会产生中断,通过总线把电信号发送给中断控制器,如果中断的线是激活的,中断控制器 就把电信号发送给处理器的某个特定引脚。处理器于是立即停止自己正在做的事,跳到内存中内核设置的中断处理程序的入口点,进行中断处理。
在内核中断处理中,会检测中断与我们刚才注册的中断号匹配,于是,注册的中断处理函数就被调用了。

当需要发/收数据,出现错误,连接状态变化等,网卡的中断信号会被触发。当接收到中断后,中断函数读取中断状态位,进行合法性判断,如判断中断信号是否是自己的等,然后,应答设备中断——OK,我已经知道了,你回去继续工作吧……
接着,它就屏蔽此中断,然后netif_rx_schedule函数接收,接收函数 会在未来某一时刻调用设备的poll函数(对这里而言,注册的是e100_poll)实现设备的轮询:

[Copy to clipboard] [ - ]
CODE:
static irqreturn_t e100_intr(int irq, void *dev_id, struct pt_regs *regs)
{
        struct net_device *netdev = dev_id;
        struct nic *nic = netdev_priv(netdev);
        u8 stat_ack = readb(&nic->csr->scb.stat_ack);

        DPRINTK(INTR, DEBUG, "stat_ack = 0x%02X\n", stat_ack);

        if(stat_ack == stat_ack_not_ours ||        /* Not our interrupt */
           stat_ack == stat_ack_not_present)        /* Hardware is ejected */
                return IRQ_NONE;

        /* Ack interrupt(s) */
        writeb(stat_ack, &nic->csr->scb.stat_ack);

        /* We hit Receive No Resource (RNR); restart RU after cleaning */
        if(stat_ack & stat_ack_rnr)
                nic->ru_running = RU_SUSPENDED;

        e100_disable_irq(nic);
        netif_rx_schedule(netdev);

        return IRQ_HANDLED;
}

对于数据包的接收而言,我们关注的是poll函数中,调用e100_rx_clean进行数据的接收:

[Copy to clipboard] [ - ]
CODE:
static int e100_poll(struct net_device *netdev, int *budget)
{
        struct nic *nic = netdev_priv(netdev);
       /*
         * netdev->quota是当前CPU能够从所有接口中接收数据包的最大数目,budget是在
         * 初始化阶段分配给接口的weight值,轮询函数必须接受二者之间的最小值。表示
         * 轮询函数本次要处理的数据包个数。
         */
        unsigned int work_to_do = min(netdev->quota, *budget);
        unsigned int work_done = 0;
        int tx_cleaned;

          /*进行数据包的接收和传输*/            
        e100_rx_clean(nic, &work_done, work_to_do);
        tx_cleaned = e100_tx_clean(nic);

         /*接收和传输完成后,就退出poll模块,重启中断*/
        /* If no Rx and Tx cleanup work was done, exit polling mode. */
        if((!tx_cleaned && (work_done == 0)) || !netif_running(netdev)) {
                netif_rx_complete(netdev);
                e100_enable_irq(nic);
                return 0;
        }

        *budget -= work_done;
        netdev->quota -= work_done;

        return 1;
}

static inline void e100_rx_clean(struct nic *nic, unsigned int *work_done,
        unsigned int work_to_do)
{
        struct rx *rx;
        int restart_required = 0;
        struct rx *rx_to_start = NULL;

        /* are we already rnr? then pay attention!!! this ensures that
         * the state machine progression never allows a start with a
         * partially cleaned list, avoiding a race between hardware
         * and rx_to_clean when in NAPI mode */
        if(RU_SUSPENDED == nic->ru_running)
                restart_required = 1;

        /* Indicate newly arrived packets */
        for(rx = nic->rx_to_clean; rx->skb; rx = nic->rx_to_clean = rx->next) {
                int err = e100_rx_indicate(nic, rx, work_done, work_to_do);
                if(-EAGAIN == err) {
                        /* hit quota so have more work to do, restart once
                         * cleanup is complete */
                        restart_required = 0;
                        break;
                } else if(-ENODATA == err)
                        break; /* No more to clean */
        }

        /* save our starting point as the place we'll restart the receiver */
        if(restart_required)
                rx_to_start = nic->rx_to_clean;

        /* Alloc new skbs to refill list */
        for(rx = nic->rx_to_use; !rx->skb; rx = nic->rx_to_use = rx->next) {
                if(unlikely(e100_rx_alloc_skb(nic, rx)))
                        break; /* Better luck next time (see watchdog) */
        }

        if(restart_required) {
                // ack the rnr?
                writeb(stat_ack_rnr, &nic->csr->scb.stat_ack);
                e100_start_receiver(nic, rx_to_start);
                if(work_done)
                        (*work_done)++;
        }
}

四、网卡的数据接收

内核如何从网卡接受数据,传统的经典过程:
1、数据到达网卡;
2、网卡产生一个中断给内核;
3、内核使用I/O指令,从网卡I/O区域中去读取数据;


我们在许多网卡驱动中,都可以在网卡的中断函数中见到这一过程。

但是,这一种方法,有一种重要的问题,就是大流量的数据来到,网卡会产生大量的中断,内核在中断上下文中,会浪费大量的资源来处理中断本身。所以,一个问 题是,“可不可以不使用中断”,这就是轮询技术,所谓NAPI技术,说来也不神秘,就是说,内核屏蔽中断,然后隔一会儿就去问网卡,“你有没有数据 啊?”……

从这个描述本身可以看到,哪果数据量少,轮询同样占用大量的不必要的CPU资源,大家各有所长吧,呵呵……

OK,另一个问题,就是从网卡的I/O区域,包括I/O寄存器或I/O内存中去读取数据,这都要CPU去读,也要占用CPU资源,“CPU从I/O区域 读,然后把它放到内存(这个内存指的是系统本身的物理内存,跟外设的内存不相干,也叫主内存)中”。于是自然地,就想到了DMA技术——让网卡直接从主内 存之间读写它们的I/O数据,CPU,这儿不干你事,自己找乐子去:
1、首先,内核在主内存中为收发数据建立一个环形的缓冲队列(通常叫DMA环形缓冲区)。
2、内核将这个缓冲区通过DMA映射,把这个队列交给网卡;
3、网卡收到数据,就直接放进这个环形缓冲区了——也就是直接放进主内存了;然后,向系统产生一个中断;
4、内核收到这个中断,就取消DMA映射,这样,内核就直接从主内存中读取数据;


——呵呵,这一个过程比传统的过程少了不少工作,因为设备直接把数据放进了主内存,不需要CPU的干预,效率是不是提高不少?

对应以上4步,来看它的具体实现:
1、分配环形DMA缓冲区
Linux内核中,用skb来描述一个缓存,所谓分配,就是建立一定数量的skb,然后把它们组织成一个双向链表;

2、建立DMA映射
内核通过调用
dma_map_single(struct device *dev,void *buffer,size_t size,enum dma_data_direction direction)
建立映射关系。
struct device *dev,描述一个设备;
buffer:把哪个地址映射给设备;也就是某一个skb——要映射全部,当然是做一个双向链表的循环即可;
size:缓存大小;
direction:映射方向——谁传给谁:一般来说,是“双向”映射,数据在设备和内存之间双向流动;

对于PCI设备而言(网卡一般是PCI的),通过另一个包裹函数pci_map_single,这样,就把buffer交给设备了!设备可以直接从里边读/取数据。

3、这一步由硬件完成;

4、取消映射
dma_unmap_single,对PCI而言,大多调用它的包裹函数pci_unmap_single,不取消的话,缓存控制权还在设备手里,要调用它,把主动权掌握在CPU手里——因为我们已经接收到数据了,应该由CPU把数据交给上层网络栈;

当然,不取消之前,通常要读一些状态位信息,诸如此类,一般是调用
dma_sync_single_for_cpu()
让CPU在取消映射前,就可以访问DMA缓冲区中的内容。

关于DMA映射的更多内容,可以参考《Linux设备驱动程序》“内存映射和DMA”章节相关内容!

OK,有了这些知识,我们就可以来看e100的代码了,它跟上面讲的步骤基本上一样的——绕了这么多圈子,就是想绕到e100上面了,呵呵!


在e100_open函数中,调用e100_up,我们前面分析它时,略过了一个重要的东东,就是环形缓冲区的建立,这一步,是通过
e100_rx_alloc_list函数调用完成的:

[Copy to clipboard] [ - ]
CODE:
static int e100_rx_alloc_list(struct nic *nic)
{
        struct rx *rx;
        unsigned int i, count = nic->params.rfds.count;

        nic->rx_to_use = nic->rx_to_clean = NULL;
        nic->ru_running = RU_UNINITIALIZED;

        /*结构struct rx用来描述一个缓冲区节点,这里分配了count个*/
        if(!(nic->rxs = kmalloc(sizeof(struct rx) * count, GFP_ATOMIC)))
                return -ENOMEM;
        memset(nic->rxs, 0, sizeof(struct rx) * count);

        /*虽然是连续分配的,不过还是遍历它,建立双向链表,然后为每一个rx的skb指针分员分配空间
        skb用来描述内核中的一个数据包,呵呵,说到重点了*/
        for(rx = nic->rxs, i = 0; i < count; rx++, i++) {
                rx->next = (i + 1 < count) ? rx + 1 : nic->rxs;
                rx->prev = (i == 0) ? nic->rxs + count - 1 : rx - 1;
                if(e100_rx_alloc_skb(nic, rx)) {                /*分配缓存*/
                        e100_rx_clean_list(nic);
                        return -ENOMEM;
                }
        }

        nic->rx_to_use = nic->rx_to_clean = nic->rxs;
        nic->ru_running = RU_SUSPENDED;

        return 0;
}



[Copy to clipboard] [ - ]
CODE:
#define RFD_BUF_LEN (sizeof(struct rfd) + VLAN_ETH_FRAME_LEN)
static inline int e100_rx_alloc_skb(struct nic *nic, struct rx *rx)
{
        /*skb缓存的分配,是通过调用系统函数dev_alloc_skb来完成的,它同内核栈中通常调用alloc_skb的区别在于,
        它是原子的,所以,通常在中断上下文中使用*/
        if(!(rx->skb = dev_alloc_skb(RFD_BUF_LEN + NET_IP_ALIGN)))
                return -ENOMEM;

        /*初始化必要的成员 */
        rx->skb->dev = nic->netdev;
        skb_reserve(rx->skb, NET_IP_ALIGN);
        /*这里在数据区之前,留了一块sizeof(struct rfd) 这么大的空间,该结构的
        一个重要作用,用来保存一些状态信息,比如,在接收数据之前,可以先通过
        它,来判断是否真有数据到达等,诸如此类*/
        memcpy(rx->skb->data, &nic->blank_rfd, sizeof(struct rfd));
        /*这是最关键的一步,建立DMA映射,把每一个缓冲区rx->skb->data都映射给了设备,缓存区节点
        rx利用dma_addr保存了每一次映射的地址,这个地址后面会被用到*/
        rx->dma_addr = pci_map_single(nic->pdev, rx->skb->data,
                RFD_BUF_LEN, PCI_DMA_BIDIRECTIONAL);

        if(pci_dma_mapping_error(rx->dma_addr)) {
                dev_kfree_skb_any(rx->skb);
                rx->skb = 0;
                rx->dma_addr = 0;
                return -ENOMEM;
        }

        /* Link the RFD to end of RFA by linking previous RFD to
         * this one, and clearing EL bit of previous.  */
        if(rx->prev->skb) {
                struct rfd *prev_rfd = (struct rfd *)rx->prev->skb->data;
                /*put_unaligned(val,ptr);用到把var放到ptr指针的地方,它能处理处理内存对齐的问题
                prev_rfd是在缓冲区开始处保存的一点空间,它的link成员,也保存了映射后的地址*/
                put_unaligned(cpu_to_le32(rx->dma_addr),
                        (u32 *)&prev_rfd->link);
                wmb();
                prev_rfd->command &= ~cpu_to_le16(cb_el);
                pci_dma_sync_single_for_device(nic->pdev, rx->prev->dma_addr,
                        sizeof(struct rfd), PCI_DMA_TODEVICE);
        }

        return 0;
}

e100_rx_alloc_list函数在一个循环中,建立了环形缓冲区,并调用e100_rx_alloc_skb为每个缓冲区分配了空间,并做了
DMA映射。这样,我们就可以来看接收数据的过程了。

前面我们讲过,中断函数中,调用netif_rx_schedule,表明使用轮询技术,系统会在未来某一时刻,调用设备的poll函数:

[Copy to clipboard] [ - ]
CODE:
static int e100_poll(struct net_device *netdev, int *budget)
{
        struct nic *nic = netdev_priv(netdev);
        unsigned int work_to_do = min(netdev->quota, *budget);
        unsigned int work_done = 0;
        int tx_cleaned;

        e100_rx_clean(nic, &work_done, work_to_do);
        tx_cleaned = e100_tx_clean(nic);

        /* If no Rx and Tx cleanup work was done, exit polling mode. */
        if((!tx_cleaned && (work_done == 0)) || !netif_running(netdev)) {
                netif_rx_complete(netdev);
                e100_enable_irq(nic);
                return 0;
        }

        *budget -= work_done;
        netdev->quota -= work_done;

        return 1;
}

目前,我们只关心rx,所以,e100_rx_clean函数就成了我们关注的对像,它用来从缓冲队列中接收全部数据(这或许是取名为clean的原因吧!):

[Copy to clipboard] [ - ]
CODE:
static inline void e100_rx_clean(struct nic *nic, unsigned int *work_done,
        unsigned int work_to_do)
{
        struct rx *rx;
        int restart_required = 0;
        struct rx *rx_to_start = NULL;

        /* are we already rnr? then pay attention!!! this ensures that
         * the state machine progression never allows a start with a
         * partially cleaned list, avoiding a race between hardware
         * and rx_to_clean when in NAPI mode */
        if(RU_SUSPENDED == nic->ru_running)
                restart_required = 1;

        /* 函数最重要的工作,就是遍历环形缓冲区,接收数据*/
        for(rx = nic->rx_to_clean; rx->skb; rx = nic->rx_to_clean = rx->next) {
                int err = e100_rx_indicate(nic, rx, work_done, work_to_do);
                if(-EAGAIN == err) {
                        /* hit quota so have more work to do, restart once
                         * cleanup is complete */
                        restart_required = 0;
                        break;
                } else if(-ENODATA == err)
                        break; /* No more to clean */
        }

        /* save our starting point as the place we'll restart the receiver */
        if(restart_required)
                rx_to_start = nic->rx_to_clean;

        /* Alloc new skbs to refill list */
        for(rx = nic->rx_to_use; !rx->skb; rx = nic->rx_to_use = rx->next) {
                if(unlikely(e100_rx_alloc_skb(nic, rx)))
                        break; /* Better luck next time (see watchdog) */
        }

        if(restart_required) {
                // ack the rnr?
                writeb(stat_ack_rnr, &nic->csr->scb.stat_ack);
                e100_start_receiver(nic, rx_to_start);
                if(work_done)
                        (*work_done)++;
        }
}



[Copy to clipboard] [ - ]
CODE:
static inline int e100_rx_indicate(struct nic *nic, struct rx *rx,
        unsigned int *work_done, unsigned int work_to_do)
{
        struct sk_buff *skb = rx->skb;
        struct rfd *rfd = (struct rfd *)skb->data;
        u16 rfd_status, actual_size;

        if(unlikely(work_done && *work_done >= work_to_do))
                return -EAGAIN;

        /* 读取数据之前,也就是取消DMA映射之前,需要先读取cb_complete 状态位,
        以确定数据是否真的准备好了,并且,rfd的actual_size中,也包含了真实的数据大小
        pci_dma_sync_single_for_cpu函数前面已经介绍过,它让CPU在取消DMA映射之前,具备
        访问DMA缓存的能力*/
        pci_dma_sync_single_for_cpu(nic->pdev, rx->dma_addr,
                sizeof(struct rfd), PCI_DMA_FROMDEVICE);
        rfd_status = le16_to_cpu(rfd->status);

        DPRINTK(RX_STATUS, DEBUG, "status=0x%04X\n", rfd_status);

        /* If data isn't ready, nothing to indicate */
        if(unlikely(!(rfd_status & cb_complete)))
                return -ENODATA;

        /* Get actual data size */
        actual_size = le16_to_cpu(rfd->actual_size) & 0x3FFF;
        if(unlikely(actual_size > RFD_BUF_LEN - sizeof(struct rfd)))
                actual_size = RFD_BUF_LEN - sizeof(struct rfd);

        /* 取消映射,因为通过DMA,网卡已经把数据放在了主内存中,这里一取消,也就意味着,
        CPU可以处理主内存中的数据了 */
        pci_unmap_single(nic->pdev, rx->dma_addr,
                RFD_BUF_LEN, PCI_DMA_FROMDEVICE);

        /* this allows for a fast restart without re-enabling interrupts */
        if(le16_to_cpu(rfd->command) & cb_el)
                nic->ru_running = RU_SUSPENDED;
       
        /*正确地设置data指针,因为最前面有一个sizeof(struct rfd)大小区域,跳过它*/
        skb_reserve(skb, sizeof(struct rfd));
        /*更新skb的tail和len指针,也是就更新接收到这么多数据的长度*/
        skb_put(skb, actual_size);
        /*设置协议位*/
        skb->protocol = eth_type_trans(skb, nic->netdev);

        if(unlikely(!(rfd_status & cb_ok))) {
                /* Don't indicate if hardware indicates errors */
                nic->net_stats.rx_dropped++;
                dev_kfree_skb_any(skb);
        } else if(actual_size > nic->netdev->mtu + VLAN_ETH_HLEN) {
                /* Don't indicate oversized frames */
                nic->rx_over_length_errors++;
                nic->net_stats.rx_dropped++;
                dev_kfree_skb_any(skb);
        } else {
                /*网卡驱动要做的最后一步,就是统计接收计数器,设置接收时间戳,然后调用netif_receive_skb,
                把数据包交给上层协议栈,自己的光荣始命也就完成了*/
                nic->net_stats.rx_packets++;
                nic->net_stats.rx_bytes += actual_size;
                nic->netdev->last_rx = jiffies;
                netif_receive_skb(skb);
                if(work_done)
                        (*work_done)++;
        }

        rx->skb = NULL;

        return 0;
}

网卡驱动执行到这里,数据接收的工作,也就处理完成了。但是,使用这一种方法的驱动,省去了网络栈中一个重要的内容,就是
“队列层”,让我们来看看,传统中断接收数据包模式下,使用netif_rx函数调用,又会发生什么。

五、队列层

1、软中断与下半部
当用中断处理的时候,为了减少中断处理的工作量,比如,一般中断处理时,需要屏蔽其它中断,如果中断处理时间过长,那么其它中断
有可能得不到及时处理,也以,有一种机制,就是把“不必马上处理”的工作,推迟一点,让它在中断处理后的某一个时刻得到处理。这就
是下半部。

下半部只是一个机制,它在Linux中,有多种实现方式,其中一种对时间要求最严格的实现方式,叫“软中断”,可以使用:

open_softirq()

来向内核注册一个软中断,
然后,在合适的时候,调用

raise_softirq_irqoff()

触发它。

如果采用中断方式接收数据(这一节就是在说中断方式接收,后面,就不用这种假设了),同样也需要软中断,可以调用

open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);

向内核注册一个名为NET_RX_SOFTIR的软中断,net_rx_action是软中断的处理函数。

然后,在驱动中断处理完后的某一个时刻,调用

raise_softirq_irqoff(NET_RX_SOFTIRQ);

触发它,这样net_rx_action将得到执行。

2、队列层
什么是队列层?通常,在网卡收发数据的时候,需要维护一个缓冲区队列,来缓存可能存在的突发数据,类似于前面的DMA环形缓冲区。
队列层中,包含了一个叫做struct softnet_data:

[Copy to clipboard] [ - ]
CODE:
struct softnet_data
{
        /*throttle 用于拥塞控制,当拥塞发生时,throttle将被设置,后续进入的数据包将被丢弃*/
        int                        throttle;
        /*netif_rx函数返回的拥塞级别*/
        int                        cng_level;
        int                        avg_blog;
        /*softnet_data 结构包含一个指向接收和传输队列的指针,input_pkt_queue成员指向准备传送
        给网络层的sk_buffs包链表的首部的指针,这个队列中的包是由netif_rx函数递交的*/
        struct sk_buff_head        input_pkt_queue;
       
        struct list_head        poll_list;
        struct net_device        *output_queue;
        struct sk_buff                *completion_queue;

        struct net_device        backlog_dev;        /* Sorry. 8) */
};

内核使用了一个同名的变量softnet_data,它是一个Per-CPU变量,每个CPU都有一个。

net/core/dev.c

[Copy to clipboard] [ - ]
CODE:
DECLARE_PER_CPU(struct softnet_data,softnet_data);



[Copy to clipboard] [ - ]
CODE:
/*
*       网络模块的核心处理模块.
*/
static int __init net_dev_init(void)
{
        int i, rc = -ENOMEM;

        BUG_ON(!dev_boot_phase);

        net_random_init();

        if (dev_proc_init())                /*初始化proc文件系统*/
                goto out;

        if (netdev_sysfs_init())        /*初始化sysfs文件系统*/
                goto out;

        /*ptype_all和ptype_base是重点,后面会详细分析,它们都是
        struct list_head类型变量,这里初始化链表成员*/
        INIT_LIST_HEAD(&ptype_all);
        for (i = 0; i < 16; i++)
                INIT_LIST_HEAD(&ptype_base[i]);

        for (i = 0; i < ARRAY_SIZE(dev_name_head); i++)
                INIT_HLIST_HEAD(&dev_name_head[i]);

        for (i = 0; i < ARRAY_SIZE(dev_index_head); i++)
                INIT_HLIST_HEAD(&dev_index_head[i]);

        /*
         *        初始化包接收队列,这里我们的重点了.
         */

        /*遍历每一个CPU,取得它的softnet_data,我们说过,它是一个struct softnet_data的Per-CPU变量*/
        for (i = 0; i < NR_CPUS; i++) {
                struct softnet_data *queue;
               
                /*取得第i个CPU的softnet_data,因为队列是包含在它里边的,所以,我会直接说,“取得队列”*/
                queue = &per_cpu(softnet_data, i);
                /*初始化队列头*/
                skb_queue_head_init(&queue->input_pkt_queue);
                queue->throttle = 0;
                queue->cng_level = 0;
                queue->avg_blog = 10; /* arbitrary non-zero */
                queue->completion_queue = NULL;
                INIT_LIST_HEAD(&queue->poll_list);
                set_bit(__LINK_STATE_START, &queue->backlog_dev.state);
                queue->backlog_dev.weight = weight_p;
                /*这里,队列中backlog_dev设备,它是一个伪网络设备,不对应任何物理设备,它的poll函数,指向了
                process_backlog,后面我们会详细分析*/
                queue->backlog_dev.poll = process_backlog;
                atomic_set(&queue->backlog_dev.refcnt, 1);
        }

#ifdef OFFLINE_SAMPLE
        samp_timer.expires = jiffies + (10 * HZ);
        add_timer(&samp_timer);
#endif

        dev_boot_phase = 0;
       
        /*注册收/发软中断*/
        open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
        open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);

        hotcpu_notifier(dev_cpu_callback, 0);
        dst_init();
        dev_mcast_init();
        rc = 0;
out:
        return rc;
}

这样,初始化完成后,在驱动程序中,在中断处理函数中,会调用netif_rx将数据交上来,这与采用轮询技术,有本质的不同:

[Copy to clipboard] [ - ]
CODE:
int netif_rx(struct sk_buff *skb)
{
        int this_cpu;
        struct softnet_data *queue;
        unsigned long flags;

        /* if netpoll wants it, pretend we never saw it */
        if (netpoll_rx(skb))
                return NET_RX_DROP;

        /*接收时间戳未设置,设置之*/
        if (!skb->stamp.tv_sec)
                net_timestamp(&skb->stamp);

        /*
         * 这里准备将数据包放入接收队列,需要禁止本地中断,在入队操作完成后,再打开中断.
         */
        local_irq_save(flags);
        /*获取当前CPU对应的softnet_data变量*/
        this_cpu = smp_processor_id();
        queue = &__get_cpu_var(softnet_data);

        /*接收计数器累加*/
        __get_cpu_var(netdev_rx_stat).total++;
       
        /*接收队列是否已满*/
        if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
                if (queue->input_pkt_queue.qlen) {
                        if (queue->throttle)                        /*拥塞发生了,丢弃数据包*/
                                goto drop;
                       
                        /*数据包入队操作*/
enqueue:
                        dev_hold(skb->dev);                        /*累加设备引入计数器*/
                        __skb_queue_tail(&queue->input_pkt_queue, skb);                /*将数据包加入接收队列*/
#ifndef OFFLINE_SAMPLE
                        get_sample_stats(this_cpu);
#endif
                        local_irq_restore(flags);
                        return queue->cng_level;
                }

                /*
                 * 驱动程序不断地调用net_rx函数,实现接收数据包的入队操作,当qlen == 0时, 则进入这段代码,这里,如果已经被设置拥塞标志的话,则清除它,因为这里将要调用软中断,开始将数据包交给 上层了,即上层协议的接收函数将执行出队操作,拥塞自然而然也就不存在了。 */
                if (queue->throttle)
                        queue->throttle = 0;

                /*
                 * netif_rx_schedule函数完成两件重要的工作:
                 * 1、将bakclog_dev设备加入“处理数据包的设备”的链表当中;
                 * 2、触发软中断函数,进行数据包接收处理;
                 */
                netif_rx_schedule(&queue->backlog_dev);
                goto enqueue;
        }

        /*前面判断了队列是否已满,如果已满而标志未设置,设置之,并累加拥塞计数器*/
        if (!queue->throttle) {
                queue->throttle = 1;
                __get_cpu_var(netdev_rx_stat).throttled++;
        }

/*拥塞发生,累加丢包计数器,释放数据包*/
drop:
        __get_cpu_var(netdev_rx_stat).dropped++;
        local_irq_restore(flags);

        kfree_skb(skb);
        return NET_RX_DROP;
}

从 这段代码的分析中,我们可以看到,当第一个数据包被接收后,因为qlen==0,所以首先会调用netif_rx_schedule触发软中断,然后利用 goto跳转至入队。因为软中断被触发后,将执行出队操作,把数据交往上层处理。而当这个时候,又有数据包进入,即网卡中断产生,因为它的优先级高过软中 断,这样,出队操作即被中断,网卡中断程序再将被调用,netif_rx函数又再次被执行,如果队列未满,就入队返回。中断完成后,软中断的执行过程被恢 复而继续执行出队——如此生产者/消费者循环不止,生生不息……

netif_rx调用netif_rx_schedule进一步处理数据包,我们注意到:
1、前面讨论过,采用轮询技术时,同样地,也是调用netif_rx_schedule,把设备自己传递了过去;
2、这里,采用中断方式,传递的是队列中的一个“伪设备”,并且,这个伪设备的poll函数指针,指向了一个叫做process_backlog的函数;

netif_rx_schedule函数完成两件重要的工作:
1、将bakclog_dev设备加入“处理数据包的设备”的链表当中;
2、触发软中断函数,进行数据包接收处理;

这样,我们可以猜想,在软中断函数中,不论是伪设备bakclog_dev,还是真实的设备(如前面讨论过的e100),都会被软中断函数以:
dev->poll()
的形式调用,对于e100来说,poll函数的接收过程已经分析了,而对于其它所有没有采用轮询技术的网络设备来说,它们将统统调用
process_backlog函数(我觉得把它改名为pseudo-poll是否更合适一些^o^)。

OK,我想分析到这里,关于中断处理与轮询技术的差异,已经基本分析开了……

继续来看,netif_rx_schedule进一步调用__netif_rx_schedule:

[Copy to clipboard] [ - ]
CODE:
/* Try to reschedule poll. Called by irq handler. */

static inline void netif_rx_schedule(struct net_device *dev)
{
        if (netif_rx_schedule_prep(dev))
                __netif_rx_schedule(dev);
}



[Copy to clipboard] [ - ]
CODE:
/* Add interface to tail of rx poll list. This assumes that _prep has
* already been called and returned 1.
*/

static inline void __netif_rx_schedule(struct net_device *dev)
{
        unsigned long flags;

        local_irq_save(flags);
        dev_hold(dev);
        /*伪设备也好,真实的设备也罢,都被加入了队列层的设备列表*/
        list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
        if (dev->quota < 0)
                dev->quota += dev->weight;
        else
                dev->quota = dev->weight;
        /*触发软中断*/
        __raise_softirq_irqoff(NET_RX_SOFTIRQ);
        local_irq_restore(flags);
}

软中断被触发,注册的net_rx_action函数将被调用:

[Copy to clipboard] [ - ]
CODE:
/*接收的软中断处理函数*/
static void net_rx_action(struct softirq_action *h)
{
        struct softnet_data *queue = &__get_cpu_var(softnet_data);
        unsigned long start_time = jiffies;
        int budget = netdev_max_backlog;

       
        local_irq_disable();
       
        /*
         * 遍历队列的设备链表,如前所述,__netif_rx_schedule已经执行了
         * list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
         * 设备bakclog_dev已经被添加进来了
         */
        while (!list_empty(&queue->poll_list)) {
                struct net_device *dev;

                if (budget <= 0 || jiffies - start_time > 1)
                        goto softnet_break;

                local_irq_enable();
               
                /*取得链表中的设备*/
                dev = list_entry(queue->poll_list.next,
                                 struct net_device, poll_list);
                netpoll_poll_lock(dev);

                /*调用设备的poll函数,处理接收数据包,这样,采用轮询技术的网卡,它的真实的poll函数将被调用,
                这就回到我们上一节讨论的e100_poll函数去了,而对于采用传统中断处理的设备,它们调用的,都将是
                bakclog_dev的process_backlog函数*/
                if (dev->quota <= 0 || dev->poll(dev, &budget)) {
                        netpoll_poll_unlock(dev);
                       
                        /*处理完成后,把设备从设备链表中删除,又重置于末尾*/
                        local_irq_disable();
                        list_del(&dev->poll_list);
                        list_add_tail(&dev->poll_list, &queue->poll_list);
                        if (dev->quota < 0)
                                dev->quota += dev->weight;
                        else
                                dev->quota = dev->weight;
                } else {
                        netpoll_poll_unlock(dev);
                        dev_put(dev);
                        local_irq_disable();
                }
        }
out:
        local_irq_enable();
        return;

softnet_break:
        __get_cpu_var(netdev_rx_stat).time_squeeze++;
        __raise_softirq_irqoff(NET_RX_SOFTIRQ);
        goto out;
}

对于dev->poll(dev, &budget)的调用,一个真实的poll函数的例子,我们已经分析过了,现在来看process_backlog,

[Copy to clipboard] [ - ]
CODE:
static int process_backlog(struct net_device *backlog_dev, int *budget)
{
        int work = 0;
        int quota = min(backlog_dev->quota, *budget);
        struct softnet_data *queue = &__get_cpu_var(softnet_data);
        unsigned long start_time = jiffies;

        backlog_dev->weight = weight_p;
       
        /*在这个循环中,执行出队操作,把数据从队列中取出来,交给netif_receive_skb,直至队列为空*/
        for (;;) {
                struct sk_buff *skb;
                struct net_device *dev;

                local_irq_disable();
                skb = __skb_dequeue(&queue->input_pkt_queue);
                if (!skb)
                        goto job_done;
                local_irq_enable();

                dev = skb->dev;

                netif_receive_skb(skb);

                dev_put(dev);

                work++;

                if (work >= quota || jiffies - start_time > 1)
                        break;

        }

        backlog_dev->quota -= work;
        *budget -= work;
        return -1;

/*当队列中的数据包被全部处理后,将执行到这里*/
job_done:
        backlog_dev->quota -= work;
        *budget -= work;

        list_del(&backlog_dev->poll_list);
        smp_mb__before_clear_bit();
        netif_poll_enable(backlog_dev);

        if (queue->throttle)
                queue->throttle = 0;
        local_irq_enable();
        return 0;
}

这个函数重要的工作,就是出队,然后调用netif_receive_skb()将数据包交给上层,这与上一节讨论的poll是一样的。这也是为什么,
在网卡驱动的编写中,采用中断技术,要调用netif_rx,而采用轮询技术,要调用netif_receive_skb啦!

到了这里,就处理完数据包与设备相关的部分了,数据包将进入上层协议栈……






1、什么是路由缓存
当数据包进入网络层后,需要做的第一件事情,就是进行路由查找,也即根据数据包的目标地址,查找需要转发的目的网关,当然,实际情况比这个要复杂,查找条件并不仅限于目的地址。

为了提高路由查找的效率,路由子系统引入了路由缓存的概念,用于某个目的地址在路由表中查找到匹配路由项后,就把目的地址对应的路由项缓存起来,可以通过route –C看到路由缓存表:

这样,下一次路由查找时,就先查缓存,没有在缓存中,再去搜索路由表。
不论进入或者是发出的数据,都要在网络层进行路由查找,查找首先在路由缓存中进行,如果命中,则查找完成,如果没有命中,则进入路由表中的查找,如果在表中查找命中,则创建相应的路由缓存项。

2、路由缓存表的组织
如前所述,整个缓存表由一条条地缓存项组成,整个表采用了hash表来组织,如下图。

从这张图中,我们可以看到许多重要的信息:

  • hash桶的大小由变量rt_hash_mask决定,它是决定路由缓存大小的重要因素;
  • 每一个hash桶的项,是由结构struct rt_hash_bucket;
  • 每一个路由缓存项,是由结构struct rtable结构描述的,它的rt_next/next成员来组织链表的;为什么是两个成员指针而不仅仅是一个next,这在后面来分析;
  • struct rtable缓存项中,还包含了一个struct dst_entry结构;


哈希桶的类型是rt_hash_bucket,该结构只包含指向缓存元素链表的一个指针和一个锁:

[Copy to clipboard] [ - ]
CODE:
struct rt_hash_bucket {
        struct rtable        *chain;
        spinlock_t        lock;
} __attribute__((__aligned__(8)));

chain成员指针自然指向下一个路由缓存项,用于链表的维护,另外,它还包含了一个自旋锁。关于锁的使用,这在后面代码分析中,可以看到。

Chain是一个struct rtable类型的指针,struct rtable用于描述一条完整的路由缓存项,它是路由子系统中,最重要的数据结构之一:

[Copy to clipboard] [ - ]
CODE:
struct rtable
{
        /*
         * 第一个成员u,被定义为一个联合体,这非常的重要,因为struct rtable被定义为每一项路由缓存,所以不可避免地在hash表中,存在冲撞的情况,rt_next指针就用来组织冲撞的链表。而另一方面, struct dst_entry结构的第一个成员struct dst_entry        *next;也指向了下一个冲撞节点struct rtable中的struct dst_entry,虽然这两个指针rt_next和dst.next的类型不同,但是它们却指向了同一内存位置(因为dst是struct rtable的第一个成员),这样,巧妙的设计,使得其很容易其享一些数据。一个指向rtable结构的指针可以安全地映射(typecast)为一个指 向dst_entry的指针,反之亦然。前面分析哈希表时,说同时用到rt_next和next两个成员指针来维护链表,就是这个道理。
         */       
        union
        {
                struct dst_entry        dst;
                struct rtable                *rt_next;
        } u;

        /*该指针指向egress设备的IP配置块。注意对送往本地的ingress报文的路由,设置的egress设备为loopback设备。*/
        struct in_device        *idev;
       
        unsigned                rt_flags;                /*路由标志*/
        __u16                        rt_type;                /*路由类型*/
        __u16                        rt_multipath_alg;        /*多路径缓存算法。该字段是根据相关路由项上配置的算法来初始化*/

        __u32                        rt_dst;                        /* 目的IP */
        __u32                        rt_src;                        /* 源IP */
        /*
Ingress设备标识。这个值是从ingress设备的net_device数据结构中得到。对本地生
成的流量(因此不是从任何接口上接收到的),该字段被设置为出设备的ifindex
字段。不要将该字段与本章后面描述的flowi数据结构fl中的iif字段混淆,对本地生
成的流量,fl中的iif字段被设置为零(loopback_dev)。
        */
        int                        rt_iif;

        /*
         * 当目的主机为直连时(即在同一链路上),rt_gateway表示目的地址。当需要通过一个网关到达目的地时,
         * rt_gateway被设置为由路由项中的下一跳网关。
         */
        __u32                        rt_gateway;

        /* 用于缓存查找的搜索key */
        struct flowi                fl;

        /* Miscellaneous cached information */
        __u32                        rt_spec_dst; /* RFC1122 specific destination */
        /*
inet_peer结构存储有关IP peer的long-living信息,IP peer是该缓存
路由项的目的IP地址对应的主机。与本地主机在最近一段时间通信的每个远端IP
地址都有一个inet_peer结构。       
        */       
        struct inet_peer        *peer; /* long-living peer info */
};

第 一个成员dst是struct dst_entry类型,它用于存储缓存路由项中独立于协议的信息,因为协议栈中除了IPV4,还有其它网络层协议,如IPV6,还要使用路由子系统。一 般是在网络层协议的缓存结构中,包含此结构,以用于存储私有信息,这里我们看到的在struct rtable中包含struct dst_entry就是一个典型的例子:

[Copy to clipboard] [ - ]
CODE:
struct dst_entry
{
        /*用于将分布在同一个哈希桶内的dst_entry实例链接在一起*/
        struct dst_entry        *next;
        /*引用计数*/
        atomic_t                __refcnt;        /* client references        */
        int                        __use;                /*该表项已经被使用的次数(即缓存查找返回该表项的次数)*/
        struct dst_entry        *child;
        struct net_device       *dev;                /*Egress设备(即将报文送达目的地的发送设备)*/
        /*
当fib_lookup API(只被IPv4使用)失败时,错误值被保存在error(用一个正值)
中,在后面的ip_error中使用该值来决定如何处理本次路由查找失败(即决定生成
哪一类ICMP消息)。       
        */
        short                        error;
        /*
         * 用于定义该dst_entry实例的可用状态:0(缺省值)表示该结构有效而且可以被使
用,2表示该结构将被删除因而不能被使用,-1被IPsec和IPv6使用但不被IPv4使
用。
         */
        short                        obsolete;
        /*
         * 标志集合(Set of flags)。DST_HOST被TCP使用,表示主机路由(即它不是到网
络或到一个广播/多播地址的路由)。DST_NOXFRM,DST_NOPOLICY和
DST_NOHASH只用于IPsec。
         */
        int                        flags;
#define DST_HOST                1
#define DST_NOXFRM                2
#define DST_NOPOLICY                4
#define DST_NOHASH                8
#define DST_BALANCED            0x10

/*
用于记录该表项上次被使用的时间戳。当缓存查找成功时更新该时间戳,垃圾回
收程序使用该时间戳来选择最合适的应当被释放的结构。
*/
        unsigned long                lastuse;
        unsigned long                expires;        /*表示该表项将过期的时间戳。*/

        unsigned short                header_len;        /* more space at head required */
        unsigned short                trailer_len;        /* space to reserve at tail */

        u32                        metrics[RTAX_MAX];
        struct dst_entry        *path;

        unsigned long                rate_last;        /* 这两个字段被用于对两种类型的ICMP消息限速。 */
        unsigned long                rate_tokens;

        struct neighbour        *neighbour;        /*neighbour是包含下一跳三层地址到二层地址映射的结构,hh是缓存的二层头。*/
        struct hh_cache                *hh;
        struct xfrm_state        *xfrm;

/*分别表示处理ingress报文和处理egress报文的函数。参见第33章“缓存查找”小节。*/
        int                        (*input)(struct sk_buff*);
        int                        (*output)(struct sk_buff*);

#ifdef CONFIG_NET_CLS_ROUTE
        __u32                        tclassid;        /*基于路由表的classifier的标签。*/
#endif

        struct  dst_ops                *ops;                /*该结构内的虚函数表(VFT)用于处理dst_entry结构。*/
        struct rcu_head                rcu_head;
               
        char                        info[0];
};

当然,结构是复杂的,可以暂时跳过其成员的含义,大约知道这个结构是拿来做什么的就可以了,我们在代码分析中,再回过头来分析其成员变量的含义。

2、缓存的初始化

明白了缓存hash表,现在来看这个表是如何被组织起来的:
net/ipv4/route.c

int __init ip_rt_init(void)
{
        ……
ipv4_dst_ops.kmem_cachep = kmem_cache_create("ip_dst_cache",
                                                     sizeof(struct rtable),
                                                     0, SLAB_HWCACHE_ALIGN,
                                                     NULL, NULL);

        if (!ipv4_dst_ops.kmem_cachep)
                panic("IP: failed to allocate ip_dst_cache\n");

        //计算出最大可需要的内存空间
        goal = num_physpages >> (26 - PAGE_SHIFT);
        if (rhash_entries)
                goal = (rhash_entries * sizeof(struct rt_hash_bucket)) >> PAGE_SHIFT;
        //该循环计算出此内存空间,需要的最大的order数
        for (order = 0; (1UL << order) < goal; order++)
                /* NOTHING */;

        do {
                //1UL << order,计算出分配的页面,再乘上页面大小,除以桶大小,计算出共可以有多少个hash桶
rt_hash_mask = (1UL << order) * PAGE_SIZE /
                        sizeof(struct rt_hash_bucket);
                while (rt_hash_mask & (rt_hash_mask - 1))
                        rt_hash_mask--;
                //分配hash表空间,它共有rt_hash_mask个桶
                rt_hash_table = (struct rt_hash_bucket *)
                        __get_free_pages(GFP_ATOMIC, order);
        } while (rt_hash_table == NULL && --order > 0);
        //上面这个while循环在分配失败后,一直尝试递减order,再尝试分配,直至分配分功或者order为0

        if (!rt_hash_table)
                panic("Failed to allocate IP route cache hash table\n");
……
}


初始化工作中,主要完成内存的计算,hash桶的空间的分配工作,这样,所有链表的链表首部就被建立起来了。整个hash表的框架就被建立起来了。当一个 缓存项需要被加入至这个表中,就根据相应的hash算法计算出hash值,然后使用rt_hash_table[hash]定位到链表的入口,利用前文所 述的struct rt_hash_bucket结构的chain成员组织链表,将其加入即可。因为我这里主要分析数据流的转发,重点是查找工作,缓存表的插入/删除/垃圾 回收等工作,就不在这里一一详细分析了。

3、缓存的查找

当数据包进入网络层后,第一个被调用的函数是ip_rcv函数:

[Copy to clipboard] [ - ]
CODE:
/* Main IP Receive routine. */
int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
{
        struct iphdr *iph;

        /* 混杂模式下,数据将被丢弃 */
        if (skb->pkt_type == PACKET_OTHERHOST)
                goto drop;

        /*更新SNMP统计修筑*/
        IP_INC_STATS_BH(IPSTATS_MIB_INRECEIVES);

/*skb_share_check用于skb的共享检查,如果有别人已经在使用了,则克隆一份给自己使用*/
        if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
                IP_INC_STATS_BH(IPSTATS_MIB_INDISCARDS);
                goto out;
        }
        /*一个正确的IP包,包长度应该大于或等于包首部长度*/
        if (!pskb_may_pull(skb, sizeof(struct iphdr)))
                goto inhdr_error;

   /*取得IP首部*/
        iph = skb->nh.iph;

        /*
         *        RFC1122: 3.1.2.2 MUST silently discard any IP frame that fails the checksum.
         *
         *        Is the datagram acceptable?
         *
         *        1.        Length at least the size of an ip header
         *        2.        Version of 4
         *        3.        Checksums correctly. [Speed optimisation for later, skip loopback checksums]
         *        4.        Doesn't have a bogus length
         */
   /*长度和版本检查*/
        if (iph->ihl < 5 || iph->version != 4)
                goto inhdr_error;
       
        if (!pskb_may_pull(skb, iph->ihl*4))
                goto inhdr_error;
/*因为如果运行不好,上边pskb_may_pull函数会进一步去调用__pskb_pull_tail函数,去以完成补全数据包的页外数据的工作,把碎片部分
的数据线性重组,所以,有必要重置iph指针,以指向正确的ip 首部*/
        iph = skb->nh.iph;

    /*校验和检查*/
        if (ip_fast_csum((u8 *)iph, iph->ihl) != 0)
                goto inhdr_error;

        {
                __u32 len = ntohs(iph->tot_len);
                if (skb->len < len || len < (iph->ihl<<2))
                        goto inhdr_error;

                /* Our transport medium may have padded the buffer out. Now we know it
                 * is IP we can trim to the true length of the frame.
                 * Note this now means skb->len holds ntohs(iph->tot_len).
                 */
                if (pskb_trim_rcsum(skb, len)) {
                        IP_INC_STATS_BH(IPSTATS_MIB_INDISCARDS);
                        goto drop;
                }
        }
/*进入Netfilter钩子,处理完后,继续执行ip_rcv_finish */
        return NF_HOOK(PF_INET, NF_IP_PRE_ROUTING, skb, dev, NULL,
                       ip_rcv_finish);

inhdr_error:
        IP_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
drop:
        kfree_skb(skb);
out:
        return NET_RX_DROP;
}

这一部份代码,简而言之,就是取得IP首部,进行合法性检查,然后调用ip_rcv_finish函数,关于Netfilter的更多内容,请参考九贱的《Linux防火墙设计与Nefilter源码分析》。

ip_rcv_finish 要做的第一件事情,就是调用ip_route_input函数进行缓存查找:

[Copy to clipboard] [ - ]
CODE:
static inline int ip_rcv_finish(struct sk_buff *skb)
{
        struct net_device *dev = skb->dev;
        struct iphdr *iph = skb->nh.iph;

        /*
         *        Initialise the virtual path cache for the packet. It describes
         *        how the packet travels inside Linux networking.
         */
        if (skb->dst == NULL) {
                if (ip_route_input(skb, iph->daddr, iph->saddr, iph->tos, dev))
                        goto drop;
        }
……

这就进入我们本章的主题了,接下来看看ip_route_input是如何进行缓存查找的。

[Copy to clipboard] [ - ]
CODE:
int ip_route_input(struct sk_buff *skb,                                        //数据包
  u32 daddr, u32 saddr,                                //目的地址和源地址
u8 tos,                                                         //TOS
struct net_device *dev)                                //输入设备
{
        struct rtable * rth;
        unsigned        hash;
        int iif = dev->ifindex;

        tos &= IPTOS_RT_MASK;
        hash = rt_hash_code(daddr, saddr ^ (iif << 5), tos);

        rcu_read_lock();
        for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
             rth = rcu_dereference(rth->u.rt_next)) {
                if (rth->fl.fl4_dst == daddr &&
                    rth->fl.fl4_src == saddr &&
                    rth->fl.iif == iif &&
                    rth->fl.oif == 0 &&
#ifdef CONFIG_IP_ROUTE_FWMARK
                    rth->fl.fl4_fwmark == skb->nfmark &&
#endif
                    rth->fl.fl4_tos == tos) {
                        rth->u.dst.lastuse = jiffies;
                        dst_hold(&rth->u.dst);
                        rth->u.dst.__use++;
                        RT_CACHE_STAT_INC(in_hit);
                        rcu_read_unlock();
                        skb->dst = (struct dst_entry*)rth;
                        return 0;
                }
                RT_CACHE_STAT_INC(in_hlist_search);
        }
        rcu_read_unlock();

        if (MULTICAST(daddr)) {
                struct in_device *in_dev;

                rcu_read_lock();
                if ((in_dev = __in_dev_get(dev)) != NULL) {
                        int our = ip_check_mc(in_dev, daddr, saddr,
                                skb->nh.iph->protocol);
                        if (our
#ifdef CONFIG_IP_MROUTE
                            || (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev))
#endif
                            ) {
                                rcu_read_unlock();
                                return ip_route_input_mc(skb, daddr, saddr,
                                                         tos, dev, our);
                        }
                }
                rcu_read_unlock();
                return -EINVAL;
        }
        return ip_route_input_slow(skb, daddr, saddr, tos, dev);
}

函数的第一个工作,就是根据目的地址、源地址、接口索引和TOS值计算hash值

[Copy to clipboard] [ - ]
CODE:
hash = rt_hash_code(daddr, saddr ^ (iif << 5), tos);

这里用到了rcu锁,关于这个锁的更多内容,可以参考其它相关资料。宏rcu_dereference在RCU读临界部份中取出一个RCU保护的指针。在需要内存屏障的体系中进行内存屏障:

[Copy to clipboard] [ - ]
CODE:
#define rcu_dereference(p)     ({ \
                                typeof(p) _________p1 = p; \
                                smp_read_barrier_depends(); \
                                (_________p1); \
                                })

于是,我们有了hash值后,就可以在hash桶中直接找到链表入口:

[Copy to clipboard] [ - ]
CODE:
struct rtable * rth;
rth = rcu_dereference(rt_hash_table[hash].chain);

如果要遍历该链表中的所有路由缓存项,就可以使用如下循环:

[Copy to clipboard] [ - ]
CODE:
        for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
             rth = rcu_dereference(rth->u.rt_next)) {
        ……
        }

遍历每一个缓存项就简单,重要的是如何将缓存中的路由特征同数据包的特征值进行匹配。
struct rtable中的fl成员,用于存储相关的路由特征值,也就是路由缓存查找匹配的关键字,它是一个struct flowi结构类型:

[Copy to clipboard] [ - ]
CODE:
struct flowi {
        /*Egress设备ID和ingress设备ID*/
        int        oif;
        int        iif;

        /*该联合的各个字段是可用于指定L3参数取值的结构。目前支持的协议为IPv4,IPv6和DECnet。*/
        union {
                struct {
                        __u32                        daddr;
                        __u32                        saddr;
                        __u32                        fwmark;
                        __u8                        tos;
                        __u8                        scope;
                } ip4_u;
               
                struct {
                        struct in6_addr                daddr;
                        struct in6_addr                saddr;
                        __u32                        flowlabel;
                } ip6_u;

                struct {
                        __u16                        daddr;
                        __u16                        saddr;
                        __u32                        fwmark;
                        __u8                        scope;
                } dn_u;
        } nl_u;
#define fld_dst                nl_u.dn_u.daddr
#define fld_src                nl_u.dn_u.saddr
#define fld_fwmark        nl_u.dn_u.fwmark
#define fld_scope        nl_u.dn_u.scope
#define fl6_dst                nl_u.ip6_u.daddr
#define fl6_src                nl_u.ip6_u.saddr
#define fl6_flowlabel        nl_u.ip6_u.flowlabel
#define fl4_dst                nl_u.ip4_u.daddr
#define fl4_src                nl_u.ip4_u.saddr
#define fl4_fwmark        nl_u.ip4_u.fwmark
#define fl4_tos                nl_u.ip4_u.tos
#define fl4_scope        nl_u.ip4_u.scope
       
        /*L4协议*/
        __u8        proto;
        /*该变量只定义了一个标志,FLOWI_FLAG_MULTIPATHOLDROUTE,它最初用于多路径代码,但已不再被使用。*/
        __u8        flags;
#define FLOWI_FLAG_MULTIPATHOLDROUTE 0x01

/*该联合的各个字段是可用于指定L4参数取值的主要结构。目前支持的协议为TCP,UDP,ICMP,DECnet和IPsec协议套件(suite)*/
        union {
                struct {
                        __u16        sport;
                        __u16        dport;
                } ports;

                struct {
                        __u8        type;
                        __u8        code;
                } icmpt;

                struct {
                        __u16        sport;
                        __u16        dport;
                        __u8        objnum;
                        __u8        objnamel; /* Not 16 bits since max val is 16 */
                        __u8        objname[16]; /* Not zero terminated */
                } dnports;

                __u32                spi;
        } uli_u;
#define fl_ip_sport        uli_u.ports.sport
#define fl_ip_dport        uli_u.ports.dport
#define fl_icmp_type        uli_u.icmpt.type
#define fl_icmp_code        uli_u.icmpt.code
#define fl_ipsec_spi        uli_u.spi
} __attribute__((__aligned__(BITS_PER_LONG/8)));

抛开其它协议和成员,联合体成员ip4_u就是IPV4协议关心的东东了:

[Copy to clipboard] [ - ]
CODE:
                struct {
                        __u32                        daddr;
                        __u32                        saddr;
                        __u32                        fwmark;
                        __u8                        tos;
                        __u8                        scope;
                } ip4_u;

于是,在遍历路由缓存项时,就可以使用如下语句来匹配路由缓存:

[Copy to clipboard] [ - ]
CODE:
                if (rth->fl.fl4_dst == daddr &&
                    rth->fl.fl4_src == saddr &&
                    rth->fl.iif == iif &&
                    rth->fl.oif == 0 &&
#ifdef CONFIG_IP_ROUTE_FWMARK
                    rth->fl.fl4_fwmark == skb->nfmark &&
#endif
                    rth->fl.fl4_tos == tos)

分别对来源/目的地址,输入/输出设备,Netfilter防火墙的标记值和TOS值进行匹配。如果手气好,查找命中了:

[Copy to clipboard] [ - ]
CODE:
                        rth->u.dst.lastuse = jiffies;      //更新最近使用时间标记
                        dst_hold(&rth->u.dst);
                        rth->u.dst.__use++;                                //更新缓存使用记数器
                        RT_CACHE_STAT_INC(in_hit);
                        rcu_read_unlock();
                        [b]skb->dst = (struct dst_entry*)rth;        //设置skb的dst指针指向路由缓存项[/b]
                        return 0;

如果没有查到,怎么办?
当然,不是次次都能糊清一色的,如果没有命中的话,就要去查到路由表了。可以推想,网络栈在缓存查找没有命中后,会去搜索路由表,如果路由表匹配,会将由于产生的路由缓存项插入缓存表,以待下一次使用。关于路由表查找的相关内容,我会在下一章中分析。






一、sys_listen

对面向连接的协议,在调用bind(2)后,进一步调用listen(2),让套接字进入监听状态:

[Copy to clipboard] [ - ]
CODE:
int listen(int sockfd, int backlog);

backlog表示新建连接请求时,最大的未处理的积压请求数。

这里说到让套接字进入某种状态,也就是说,涉及到套接字的状态变迁,前面create和bind时,也遇到过相应的代码。

sock和sk都有相应的状态字段,先来看sock的:

[Copy to clipboard] [ - ]
CODE:
typedef enum {
        SS_FREE = 0,                        /* 套接字未分配                */
        SS_UNCONNECTED,                        /* 套接字未连接        */
        SS_CONNECTING,                        /* 套接字正在处理连接        */
        SS_CONNECTED,                        /* 套接字已连接                */
        SS_DISCONNECTING                /* 套接字正在处理关闭连接 */
} socket_state;

在创建套接字时,被初始化为SS_UNCONNECTED。

对于面向连接模式的SOCK_TREAM来讲,这样描述状态显然是不够的。这样,在sk中,使用sk_state维护了一个有限状态机来描述套接字的状态:

[Copy to clipboard] [ - ]
CODE:
enum {
  TCP_ESTABLISHED = 1,
  TCP_SYN_SENT,
  TCP_SYN_RECV,
  TCP_FIN_WAIT1,
  TCP_FIN_WAIT2,
  TCP_TIME_WAIT,
  TCP_CLOSE,
  TCP_CLOSE_WAIT,
  TCP_LAST_ACK,
  TCP_LISTEN,
  TCP_CLOSING,         /* now a valid state */

  TCP_MAX_STATES /* Leave at the end! */
};

还有一个相应的用来进行状态位运算的枚举结构:

[Copy to clipboard] [ - ]
CODE:
enum {
  TCPF_ESTABLISHED = (1 << 1),
  TCPF_SYN_SENT  = (1 << 2),
  TCPF_SYN_RECV  = (1 << 3),
  TCPF_FIN_WAIT1 = (1 << 4),
  TCPF_FIN_WAIT2 = (1 << 5),
  TCPF_TIME_WAIT = (1 << 6),
  TCPF_CLOSE     = (1 << 7),
  TCPF_CLOSE_WAIT = (1 << 8),
  TCPF_LAST_ACK  = (1 << 9),
  TCPF_LISTEN    = (1 << 10),
  TCPF_CLOSING   = (1 << 11)
};

值得一提的是,sk的状态不等于TCP的状态,虽然sk是面向协议栈,但它的状态并不能同TCP状态一一直接划等号。虽然这些状态值都用TCP-XXX来表式,但是只是因为TCP协议状态非常复杂。sk结构只是利用它的一个子集来抽像描述而已。

同样地,操作码SYS_LISTEN的任务会落到sys_listen()函数身上:

[Copy to clipboard] [ - ]
CODE:
/* Maximum queue length specifiable by listen.  */
#define SOMAXCONN        128
int sysctl_somaxconn = SOMAXCONN;

asmlinkage long sys_listen(int fd, int backlog)
{
        struct socket *sock;
        int err;
       
        if ((sock = sockfd_lookup(fd, &err)) != NULL) {
                if ((unsigned) backlog > sysctl_somaxconn)
                        backlog = sysctl_somaxconn;

                err = security_socket_listen(sock, backlog);
                if (err) {
                        sockfd_put(sock);
                        return err;
                }

                err=sock->ops->listen(sock, backlog);
                sockfd_put(sock);
        }
        return err;
}

同样地,函数会最终转向协议簇的listen函数,也就是inet_listen():

[Copy to clipboard] [ - ]
CODE:
/*
*        Move a socket into listening state.
*/
int inet_listen(struct socket *sock, int backlog)
{
        struct sock *sk = sock->sk;
        unsigned char old_state;
        int err;

        lock_sock(sk);

        err = -EINVAL;
        /* 在listen之前,sock必须为未连接状态,且只有 SOCK_STREAM 类型,才有listen(2)*/
        if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM)
                goto out;

        /* 临时保存状态机状态 */
        old_state = sk->sk_state;
        /* 只有状态机处于TCP_CLOSE 或者是TCP_LISTEN 这两种状态时,才可能对其调用listen(2) ,这个判断证明了listen(2)是可以重复调用地(当然是在转向TCP_LISTEN后没有再进行状态变迁*/
        if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN)))
                goto out;

        /* 如果接口已经处理listen状态,只修改其max_backlog,否则先调用tcp_listen_start,继续设置协议的listen状态
         */
        if (old_state != TCP_LISTEN) {
                err = tcp_listen_start(sk);
                if (err)
                        goto out;
        }
        sk->sk_max_ack_backlog = backlog;
        err = 0;

out:
        release_sock(sk);
        return err;
}

inet_listen函数在确认sock->state和sk->sk_state状态后,会进一步调用tcp_listen_start函数,最且最后设置sk_max_ack_backlog 。

tcp的tcp_listen_start函数,完成两个重要的功能,一个是初始化sk的一些相关成员变量,另一方面是切换有限状态机的状态。 sk_max_ack_backlog表示监听时最大的backlog数量,它由用户空间传递的参数决定。而sk_ack_backlog表示当前的的 backlog数量。

当tcp服务器收到一个syn报文时,它表示了一个连接请求的到达。内核使用了一个hash表来维护这个连接请求表:
struct tcp_listen_opt
{
        u8                        max_qlen_log;        /* log_2 of maximal queued SYNs */
        int                        qlen;
        int                        qlen_young;
        int                        clock_hand;
        u32                        hash_rnd;
        struct open_request        *syn_table[TCP_SYNQ_HSIZE];
};

syn_table, 是open_request结构,就是连接请求表,连中的最大项,也就是最大允许的syn报文的数量,由max_qlen_log来决定。当套接字进入listen状态,也就是说可以接收syn报文了,那么在此之前,需要先初始化这个表:

[Copy to clipboard] [ - ]
CODE:
int tcp_listen_start(struct sock *sk)
{
        struct inet_sock *inet = inet_sk(sk);                //获取inet结构指针
        struct tcp_sock *tp = tcp_sk(sk);                //获取协议指针
        struct tcp_listen_opt *lopt;
       
        //初始化sk相关成员变量
        sk->sk_max_ack_backlog = 0;
        sk->sk_ack_backlog = 0;
       
        tp->accept_queue = tp->accept_queue_tail = NULL;
        rwlock_init(&tp->syn_wait_lock);
        tcp_delack_init(tp);
       
        //初始化连接请求hash表
        lopt = kmalloc(sizeof(struct tcp_listen_opt), GFP_KERNEL);
        if (!lopt)
                return -ENOMEM;

        memset(lopt, 0, sizeof(struct tcp_listen_opt));
        //初始化hash表容量,最小为6,其实际值由sysctl_max_syn_backlog决定
        for (lopt->max_qlen_log = 6; ; lopt->max_qlen_log++)
                if ((1 << lopt->max_qlen_log) >= sysctl_max_syn_backlog)
                        break;
        get_random_bytes(&lopt->hash_rnd, 4);

        write_lock_bh(&tp->syn_wait_lock);
        tp->listen_opt = lopt;
        write_unlock_bh(&tp->syn_wait_lock);

        /* There is race window here: we announce ourselves listening,
         * but this transition is still not validated by get_port().
         * It is OK, because this socket enters to hash table only
         * after validation is complete.
         */
         /* 修改状态机状态,表示进入listen状态,根据作者注释,当宣告自己进入listening状态后,但是这个状态转换并没有得到get_port的确 认。所以需要调用get_port()函数。但是对于一点,暂时还没有完全搞明白,只有留待后面再来分析它 */
        sk->sk_state = TCP_LISTEN;
        if (!sk->sk_prot->get_port(sk, inet->num)) {
                inet->sport = htons(inet->num);

                sk_dst_reset(sk);
                sk->sk_prot->hash(sk);

                return 0;
        }

        sk->sk_state = TCP_CLOSE;
        write_lock_bh(&tp->syn_wait_lock);
        tp->listen_opt = NULL;
        write_unlock_bh(&tp->syn_wait_lock);
        kfree(lopt);
        return -EADDRINUSE;
}

在切换了有限状态机状态后,调用了

[Copy to clipboard] [ - ]
CODE:
sk->sk_prot->hash(sk);

也就是tcp_v4_hash()函数。这里涉到到另一个hash表:TCP监听hash表。

二、TCP监听hash表
所谓TCP监听表,指的就内核维护“当前有哪些套接字在监听”的一个表,当一个数据包进入TCP栈的时候,内核查询这个表中对应的sk,以找到相应的数据 结构。(因为sk是面向网络栈调用的,找到了sk,就找到了tcp_sock,就找到了inet_sock,就找到了sock,就找到了fd……就到了组 织了)。

TCP所有的hash表都用了tcp_hashinfo来封装,前面分析bind已见过它:

[Copy to clipboard] [ - ]
CODE:
extern struct tcp_hashinfo {
                 ……
        /* All sockets in TCP_LISTEN state will be in here.  This is the only
         * table where wildcard'd TCP sockets can exist.  Hash function here
         * is just local port number.
         */
        struct hlist_head __tcp_listening_hash[TCP_LHTABLE_SIZE];

                 ……
        spinlock_t __tcp_portalloc_lock;
} tcp_hashinfo;

#define tcp_listening_hash (tcp_hashinfo.__tcp_listening_hash)

函数tcp_v4_hash将一个处理监听状态下的sk加入至这个hash表:

[Copy to clipboard] [ - ]
CODE:
static void tcp_v4_hash(struct sock *sk)
{
        if (sk->sk_state != TCP_CLOSE) {
                local_bh_disable();
                __tcp_v4_hash(sk, 1);
                local_bh_enable();
        }
}

因为__tcp_v4_hash不只用于监听hash表,它也用于其它hash表,其第二个参数listen_possible为真的时候,表示处理的是监听hash表:

[Copy to clipboard] [ - ]
CODE:
static __inline__ void __tcp_v4_hash(struct sock *sk, const int listen_possible)
{
        struct hlist_head *list;
        rwlock_t *lock;

        BUG_TRAP(sk_unhashed(sk));
        if (listen_possible && sk->sk_state == TCP_LISTEN) {
                list = &tcp_listening_hash[tcp_sk_listen_hashfn(sk)];
                lock = &tcp_lhash_lock;
                tcp_listen_wlock();
        } else {
                                ……
        }
        __sk_add_node(sk, list);
        sock_prot_inc_use(sk->sk_prot);
        write_unlock(lock);
        if (listen_possible && sk->sk_state == TCP_LISTEN)
                wake_up(&tcp_lhash_wait);
}

else中的部份用于另一个hash表,暂时不管它。代表很简单,如果确认是处理的是监听hash表。则先根据sk计算一个hash值,在hash桶中找到入口。再调用__sk_add_node加入至该hash链。

tcp_sk_listen_hashfn()函数事实上是tcp_lhashfn的包裹,前面已经分析过了。

__sk_add_node()函数也就是一个简单的内核hash处理函数hlist_add_head()的包裹:

[Copy to clipboard] [ - ]
CODE:
static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list)
{
        hlist_add_head(&sk->sk_node, list);
}

小结

一个套接字的listen,主要需要做的工作有以下几件:
1、初始化sk相关的成员变量,最重要的是listen_opt,也就是连接请求hash表。
2、将sk的有限状态机转换为TCP_LISTEN,即监听状态;
3、将sk加入监听hash表;
4、设置允许的最大请求积压数,也就是sk的成员sk_max_ack_backlog的值。








第一部份 Socket套接字的创建

socket并不是TCP/IP协议的一部份。
从广义上来讲,socket是Unix/Linux抽像的进程间通讯的一种方法。网络socket通讯仅仅是其若干协议中的一类。而tcp/ip又是网络这类中的一种。
从tcp/ip的解度看socket,它更多地体现了用户API与协议栈的一个中间层接口层。用户通过调用socket API将报文递交给协议栈,或者从协议栈中接收报文件。

一、系统总入口

Linux内核为所有的与socket有关的操作的API,提供了一个统一的系统调用入口,其代码在net/socket.c中:

[Copy to clipboard] [ - ]
CODE:
asmlinkage long sys_socketcall(int call, unsigned long __user *args)
{
        unsigned long a[6];
        unsigned long a0,a1;
        int err;

        if(call<1||call>SYS_RECVMSG)
                return -EINVAL;

        /* copy_from_user should be SMP safe. */
        if (copy_from_user(a, args, nargs[call]))
                return -EFAULT;
               
        a0=a[0];
        a1=a[1];
       
        switch(call)
        {
                case SYS_SOCKET:
                        err = sys_socket(a0,a1,a[2]);
                        break;
                case SYS_BIND:
                        err = sys_bind(a0,(struct sockaddr __user *)a1, a[2]);
                        break;
                case SYS_CONNECT:
                        err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
                        break;
                case SYS_LISTEN:
                        err = sys_listen(a0,a1);
                        break;
                case SYS_ACCEPT:
                        err = sys_accept(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);
                        break;
                case SYS_GETSOCKNAME:
                        err = sys_getsockname(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);
                        break;
                case SYS_GETPEERNAME:
                        err = sys_getpeername(a0, (struct sockaddr __user *)a1, (int __user *)a[2]);
                        break;
                case SYS_SOCKETPAIR:
                        err = sys_socketpair(a0,a1, a[2], (int __user *)a[3]);
                        break;
                case SYS_SEND:
                        err = sys_send(a0, (void __user *)a1, a[2], a[3]);
                        break;
                case SYS_SENDTO:
                        err = sys_sendto(a0,(void __user *)a1, a[2], a[3],
                                         (struct sockaddr __user *)a[4], a[5]);
                        break;
                case SYS_RECV:
                        err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
                        break;
                case SYS_RECVFROM:
                        err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
                                           (struct sockaddr __user *)a[4], (int __user *)a[5]);
                        break;
                case SYS_SHUTDOWN:
                        err = sys_shutdown(a0,a1);
                        break;
                case SYS_SETSOCKOPT:
                        err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
                        break;
                case SYS_GETSOCKOPT:
                        err = sys_getsockopt(a0, a1, a[2], (char __user *)a[3], (int __user *)a[4]);
                        break;
                case SYS_SENDMSG:
                        err = sys_sendmsg(a0, (struct msghdr __user *) a1, a[2]);
                        break;
                case SYS_RECVMSG:
                        err = sys_recvmsg(a0, (struct msghdr __user *) a1, a[2]);
                        break;
                default:
                        err = -EINVAL;
                        break;
        }
        return err;
}

首先调用copy_from_user将用户态参数拷贝至数组a。但是问题在于,每个被调用的API的参数不尽相同,那么每次拷贝的字节在小如果断定?
来看其第三个参数nargs[call],其中call是操作码,后面有个大大的switch...case就是判断它。对应的操作码定义在include/linux/net.h:

[Copy to clipboard] [ - ]
CODE:
#define SYS_SOCKET        1                /* sys_socket(2)                */
#define SYS_BIND        2                /* sys_bind(2)                        */
#define SYS_CONNECT        3                /* sys_connect(2)                */
#define SYS_LISTEN        4                /* sys_listen(2)                */
#define SYS_ACCEPT        5                /* sys_accept(2)                */
#define SYS_GETSOCKNAME        6                /* sys_getsockname(2)                */
#define SYS_GETPEERNAME        7                /* sys_getpeername(2)                */
#define SYS_SOCKETPAIR        8                /* sys_socketpair(2)                */
#define SYS_SEND        9                /* sys_send(2)                        */
#define SYS_RECV        10                /* sys_recv(2)                        */
#define SYS_SENDTO        11                /* sys_sendto(2)                */
#define SYS_RECVFROM        12                /* sys_recvfrom(2)                */
#define SYS_SHUTDOWN        13                /* sys_shutdown(2)                */
#define SYS_SETSOCKOPT        14                /* sys_setsockopt(2)                */
#define SYS_GETSOCKOPT        15                /* sys_getsockopt(2)                */
#define SYS_SENDMSG        16                /* sys_sendmsg(2)                */
#define SYS_RECVMSG        17                /* sys_recvmsg(2)                */

而数组nargs则根据操作码的不同,计算对应的参数的空间大小:

[Copy to clipboard] [ - ]
CODE:
/* Argument list sizes for sys_socketcall */
#define AL(x) ((x) * sizeof(unsigned long))
static unsigned char nargs[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
                                AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
                                AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
#undef AL

当拷贝完成参数后,就进入一个switch...case...判断操作码,跳转至对应的系统接口。

二、 sys_socket函数

操作码SYS_SOCKET是由sys_socket()实现的:

[Copy to clipboard] [ - ]
CODE:
asmlinkage long sys_socket(int family, int type, int protocol)
{
        int retval;
        struct socket *sock;

        retval = sock_create(family, type, protocol, &sock);
        if (retval < 0)
                goto out;

        retval = sock_map_fd(sock);
        if (retval < 0)
                goto out_release;

out:
        /* It may be already another descriptor 8) Not kernel problem. */
        return retval;

out_release:
        sock_release(sock);
        return retval;
}

在分析这段代码之间,首先来看,创建一个Socket,对内核而言,究竟意味着什么?究竟需要内核干什么事?

当用户空间要创建一个socke接口时,会调用API函数:

[Copy to clipboard] [ - ]
CODE:
int socket(int domain, int type, int protocol);

函数,其三个参数分别表示协议族、协议类型(面向连接或无连接)以及协议。

对于用户态而言,一个Scoket,就是一个特殊的,已经打开的文件。为了对socket抽像出文件的概念,内核中为socket定义了一个专门的文件系统类型sockfs:
static struct vfsmount *sock_mnt;

[Copy to clipboard] [ - ]
CODE:
static struct file_system_type sock_fs_type = {
        .name =                "sockfs",
        .get_sb =        sockfs_get_sb,
        .kill_sb =        kill_anon_super,
};

在模块初始化的时候,安装该文件系统:

[Copy to clipboard] [ - ]
CODE:
void __init sock_init(void)
{
        ……
        register_filesystem(&sock_fs_type);
        sock_mnt = kern_mount(&sock_fs_type);       
}

稍后还要回来继续分析安装中的一点细节。

有了文件系统后,对内核而言,创建一个socket,就是在sockfs文件系统中创建一个文件节点(inode),并建立起为了实现socket功能所 需的一整套数据结构,包括struct inode和struct socket结构。struct socket结构在内核中,就代表了一个"Socket",当一个struct socket数据结构被分配空间后,再将其与一个已打开的文件“建立映射关系”。这样,用户态就可以用抽像的文件的概念来操作socket了——当然,由 于网络的特殊性,至少就目前而言,这种抽像,并不如其它模块的抽像那么完美。

这里socket的实现,和文件系统密切相关。这里就不再分析Linux的文件系统了,这里只分配与socket相关的一些细节,其它的都一一跳过,呵呵,希望也能有水平再写一篇《Linux文件系统的设计与实现简析》。

文件系统struct vfsmount中有一个成员指针mnt_sb指向该文件系统的超级块,而超级块结构struct super_lock有一个重要的成员s_op指向了超级块的操作函数表,其中有函数指针alloc_inode()即为在给定的超级块下创建并初始化一 个新的索引节点对像。也就是调用:

[Copy to clipboard] [ - ]
CODE:
sock_mnt->mnt_sb->s_op->alloc_inode(sock_mnt->mnt_sb);

当然,连同相关的处理细节一起,这一操作被层层封装至一个上层函数 new_inode()。

那如何分配一个struct socket结构呢?如前所述,一个socket总是与一个inode密切相关的。当然,在inode中,设置一个socket成员,是完全可行的,但是 这貌似浪费了空间——毕竟,更多的文件系统没有socket这个东东。所以,内核引入了另一个socket_alloc结构:

[Copy to clipboard] [ - ]
CODE:
struct socket_alloc {
        struct socket socket;
        struct inode vfs_inode;
};

显而易见,该结构实现了inode和socket的封装。已经一个inode,可以通过宏SOCKET_I来获取与之对应的socket:
sock = SOCKET_I(inode);

static inline struct socket *SOCKET_I(struct inode *inode)
{
        return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
}

但是,这样做,也同时意味着,在分配一个inode后,必须再分配一个socket_alloc结构,并实现对应的封装。否则,container_of又能到哪儿去找到socket呢?现在来简要地看一个这个流程——这是文件系统安装中的一个重要步骤:

[Copy to clipboard] [ - ]
CODE:
struct vfsmount *kern_mount(struct file_system_type *type)
{
        return do_kern_mount(type->name, 0, type->name, NULL);
}



[Copy to clipboard] [ - ]
CODE:
struct vfsmount *
do_kern_mount(const char *fstype, int flags, const char *name, void *data)
{
        struct file_system_type *type = get_fs_type(fstype);
        struct super_block *sb = ERR_PTR(-ENOMEM);
                ……
                sb = type->get_sb(type, flags, name, data);
                ……
               mnt->mnt_sb = sb;
               ……
}

do_kern_mount函数中,先根据注册的文件系统类型,调用get_fs_type获取之,也就是我们之前注册的sock_fs_type,然后调用它的get_sb成员函数指针,获取相应的超级块sb。最后,调置文件系统的超级块成员指针,使之指向对应的值。
这里get_sb函数指针,指向之前初始化的sockfs_get_sb()函数。
static struct super_block *sockfs_get_sb(struct file_system_type *fs_type,
        int flags, const char *dev_name, void *data)
{
        return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC);
}

注意其第三个参数sockfs_ops,它封装了sockfs的功能函数表:

[Copy to clipboard] [ - ]
CODE:
static struct super_operations sockfs_ops = {
        .alloc_inode =        sock_alloc_inode,
        .destroy_inode =sock_destroy_inode,
        .statfs =        simple_statfs,
};



[Copy to clipboard] [ - ]
CODE:
struct super_block *
get_sb_pseudo(struct file_system_type *fs_type, char *name,
        struct super_operations *ops, unsigned long magic)
{
        struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
                ……
       
                s->s_op = ops ? ops : &default_ops;
}

这里就是先获取/分配一个超级块,然后初始化超级块的各成员,包括s_op,我们前面提到过它,它封装了对应的功能函数表。这里s_op自然就指向了sockfs_ops。那前面提到的new_inode()函数分配inode时调用的:

[Copy to clipboard] [ - ]
CODE:
sock_mnt->mnt_sb->s_op->alloc_inode(sock_mnt->mnt_sb);

这个alloc_inode函数指针也就是sockfs_ops的sock_alloc_inode()函数——转了一大圈,终于指到它了。
来看看sock_alloc_inode是如何分配一个inode节点的:

[Copy to clipboard] [ - ]
CODE:
static struct inode *sock_alloc_inode(struct super_block *sb)
{
        struct socket_alloc *ei;
        ei = (struct socket_alloc *)kmem_cache_alloc(sock_inode_cachep, SLAB_KERNEL);
        if (!ei)
                return NULL;
        init_waitqueue_head(&ei->socket.wait);
       
        ei->socket.fasync_list = NULL;
        ei->socket.state = SS_UNCONNECTED;
        ei->socket.flags = 0;
        ei->socket.ops = NULL;
        ei->socket.sk = NULL;
        ei->socket.file = NULL;
        ei->socket.flags = 0;

        return &ei->vfs_inode;
}

函数先分配了一个用于封装socket和inode的ei,然后在高速缓存中为之申请了一块空间。这样,inode和socket就同时都被分配了。接下来初始化socket的各个成员,这些成员,在后面都会一一提到。

[Copy to clipboard] [ - ]
CODE:
/**
*  struct socket - general BSD socket
*  @state: socket state (%SS_CONNECTED, etc)
*  @flags: socket flags (%SOCK_ASYNC_NOSPACE, etc)
*  @ops: protocol specific socket operations
*  @fasync_list: Asynchronous wake up list
*  @file: File back pointer for gc
*  @sk: internal networking protocol agnostic socket representation
*  @wait: wait queue for several uses
*  @type: socket type (%SOCK_STREAM, etc)
*/
struct socket {
        socket_state                state;
        unsigned long                flags;
        struct proto_ops        *ops;
        struct fasync_struct        *fasync_list;
        struct file                *file;
        struct sock                *sk;
        wait_queue_head_t        wait;
        short                        type;
};

OK,至目前为止,分配inode、socket以及两者如何关联,都已一一分析了。
最后一个关键问题,就是如何把socket与一个已打开的文件,建立映射关系。

在内核中,用struct file结构描述一个已经打开的文件,指向该结构的指针内核中通常用file或filp来描述。我们知道,内核中,可以通过全局项current来获得当 前进程,它是一个struct task_struct类型的指针。tastk_struct有一个成员:
struct files_struct *files;
指向一个已打开的文件。当然,由于一个进程可能打开多个文件,所以,struct files_struct结构有
struct file * fd_array[NR_OPEN_DEFAULT];
成员,这是个数组,以文件描述符为下标,即current->files->fd[fd],可以找到与当前进程指定文件描述符的文件。

有了这些基础,如果要把一个socket与一个已打开的文件建立映射,首先要做的就是为socket分配一个struct file,并申请分配一个相应的文件描述符fd。因为socket并不支持open方法(前面说socket的文件界面的抽像并不完美,这应该是一个佐证 吧?),所以不能期望用户界面通过调用open() API来分配一个struct file,而是通过调用get_empty_filp来获取:

[Copy to clipboard] [ - ]
CODE:
struct file *file = get_empty_filp();

同样地:

[Copy to clipboard] [ - ]
CODE:
int fd;
fd = get_unused_fd();

获取一个空间的文件描述符

然后,让current的files指针的fd数组的fd索引项指向该file:

[Copy to clipboard] [ - ]
CODE:
void fastcall fd_install(unsigned int fd, struct file * file)
{
        struct files_struct *files = current->files;
        spin_lock(&files->file_lock);
        if (unlikely(files->fd[fd] != NULL))
                BUG();
        files->fd[fd] = file;
        spin_unlock(&files->file_lock);
}

OK, 做到这一步,有了一个文件描述符fd和一个打开的文件file,它们与当前进程相连,但是好像与创建的socket并无任何瓜葛。要做的映射还是没有进 展。struct file或者文件描述述fd或current都没有任何能够与inode或者是socket相关的东东。这需要一个中间的桥梁,目录项:struct dentry结构。
因为一个文件都有与其对应的目录项:
struct file {
        struct list_head        f_list;
        struct dentry                *f_dentry;
……

而一个目录项:
struct dentry {
……
        struct inode *d_inode;                /* Where the name belongs to - NULL is
                                         * negative */

d_inode成员指向了与之对应的inode节点……

而之前已经创建了一个inode节点和与之对应的socket。
所以,现在要做的,就是:
“先为当前文件分配一个对应的目录项,再将已创建的inode节点安装至该目录项”
这样,一个完成的映射关系:
进程、文件描述符、打开文件、目录项、inode节点、socket就完整地串起来了。

基本要分析的一些前导的东东都一一罗列了,虽然已尽量避免陷入文件系统的细节分析,但是还是不可避免地进入其中,因为它们关系实现太紧密了。现在可以来看套接字的创建过程了:

[Copy to clipboard] [ - ]
CODE:
asmlinkage long sys_socket(int family, int type, int protocol)
{
        int retval;
        struct socket *sock;

        retval = sock_create(family, type, protocol, &sock);
        if (retval < 0)
                goto out;

        retval = sock_map_fd(sock);
        if (retval < 0)
                goto out_release;

out:
        /* It may be already another descriptor 8) Not kernel problem. */
        return retval;

out_release:
        sock_release(sock);
        return retval;
}



[Copy to clipboard] [ - ]
CODE:
int sock_create(int family, int type, int protocol, struct socket **res)
{
        return __sock_create(family, type, protocol, res, 0);
}

三、af_inet协议簇的协议封装

接下来,函数调用之前已经注的inet_family_ops的函数指针create,也就是inet_create()函数,前面,可以说一个通用的 socket已经创建好了,这里要完成与协议本身相关的一些创建socket的工作。这一部份的工作比较复杂,还是先来看看af_inet.c中的模块初 始化时候,做了哪些与此相关的工作。

要引入的第一个数据结构是struct inet_protosw,它封装了一个协议类型(如SOCK_STREAM、SOCK_DGRAM等)与ip协议中对应的传输层协议:

[Copy to clipboard] [ - ]
CODE:
/* This is used to register socket interfaces for IP protocols.  */
struct inet_protosw {
        struct list_head list;

        /* These two fields form the lookup key.  */
        unsigned short         type;           /* This is the 2nd argument to socket(2). */
        int                 protocol; /* This is the L4 protocol number.  */

        struct proto         *prot;
        struct proto_ops *ops;
  
        int              capability; /* Which (if any) capability do
                                      * we need to use this socket
                                      * interface?
                                      */
        char             no_check;   /* checksum on rcv/xmit/none? */
        unsigned char         flags;      /* See INET_PROTOSW_* below.  */
};
#define INET_PROTOSW_REUSE 0x01             /* Are ports automatically reusable? */
#define INET_PROTOSW_PERMANENT 0x02  /* Permanent protocols are unremovable. */

type 是协议类型,对于ipv4而言,就是SOCK_STREAM、SOCK_DGRAM或者是SOCK_RAW之一。protocol是传输层的协议号。 prot用于描述一个具体的传输层协议,而ops指向对应的当前协议类型的操作函数集。针对不同的协议类型,定义了不同的ops:

[Copy to clipboard] [ - ]
CODE:
struct proto_ops inet_stream_ops = {
        .family =        PF_INET,
        .owner =        THIS_MODULE,
        .release =        inet_release,
        .bind =                inet_bind,
        .connect =        inet_stream_connect,
        .socketpair =        sock_no_socketpair,
        .accept =        inet_accept,
        .getname =        inet_getname,
        .poll =                tcp_poll,
        .ioctl =        inet_ioctl,
        .listen =        inet_listen,
        .shutdown =        inet_shutdown,
        .setsockopt =        sock_common_setsockopt,
        .getsockopt =        sock_common_getsockopt,
        .sendmsg =        inet_sendmsg,
        .recvmsg =        sock_common_recvmsg,
        .mmap =                sock_no_mmap,
        .sendpage =        tcp_sendpage
};



[Copy to clipboard] [ - ]
CODE:
struct proto_ops inet_dgram_ops = {
        .family =        PF_INET,
        .owner =        THIS_MODULE,
        .release =        inet_release,
        .bind =                inet_bind,
        .connect =        inet_dgram_connect,
        .socketpair =        sock_no_socketpair,
        .accept =        sock_no_accept,
        .getname =        inet_getname,
        .poll =                udp_poll,
        .ioctl =        inet_ioctl,
        .listen =        sock_no_listen,
        .shutdown =        inet_shutdown,
        .setsockopt =        sock_common_setsockopt,
        .getsockopt =        sock_common_getsockopt,
        .sendmsg =        inet_sendmsg,
        .recvmsg =        sock_common_recvmsg,
        .mmap =                sock_no_mmap,
        .sendpage =        inet_sendpage,
};



[Copy to clipboard] [ - ]
CODE:
/*
* For SOCK_RAW sockets; should be the same as inet_dgram_ops but without
* udp_poll
*/
static struct proto_ops inet_sockraw_ops = {
        .family =        PF_INET,
        .owner =        THIS_MODULE,
        .release =        inet_release,
        .bind =                inet_bind,
        .connect =        inet_dgram_connect,
        .socketpair =        sock_no_socketpair,
        .accept =        sock_no_accept,
        .getname =        inet_getname,
        .poll =                datagram_poll,
        .ioctl =        inet_ioctl,
        .listen =        sock_no_listen,
        .shutdown =        inet_shutdown,
        .setsockopt =        sock_common_setsockopt,
        .getsockopt =        sock_common_getsockopt,
        .sendmsg =        inet_sendmsg,
        .recvmsg =        sock_common_recvmsg,
        .mmap =                sock_no_mmap,
        .sendpage =        inet_sendpage,
};

从各个函数指针的名称,我们就可以大约知道它们是做什么事的了。进一步进以看到,它们的函数指针指向的函数差不多都是相同的。除了一些细节上的区别,例如后面两种协议类型并不支持listen。

socket() API第二个参数是协议类型,第三个参数是该协议类型下的协议——不过对于ipv4而言,它们都是一一对应的。但是从抽像封装的角度看,数据结构的设计本 身应该满足一个协议类型下边,可能存在多个不同的协议,即一对多的情况。而一一对应,仅是它们的特例:

[Copy to clipboard] [ - ]
CODE:
/* Upon startup we insert all the elements in inetsw_array[] into
* the linked list inetsw.
*/
static struct inet_protosw inetsw_array[] =
{
        {
                .type =       SOCK_STREAM,
                .protocol =   IPPROTO_TCP,
                .prot =       &tcp_prot,
                .ops =        &inet_stream_ops,
                .capability = -1,
                .no_check =   0,
                .flags =      INET_PROTOSW_PERMANENT,
        },

        {
                .type =       SOCK_DGRAM,
                .protocol =   IPPROTO_UDP,
                .prot =       &udp_prot,
                .ops =        &inet_dgram_ops,
                .capability = -1,
                .no_check =   UDP_CSUM_DEFAULT,
                .flags =      INET_PROTOSW_PERMANENT,
       },
        

       {
               .type =       SOCK_RAW,
               .protocol =   IPPROTO_IP,        /* wild card */
               .prot =       &raw_prot,
               .ops =        &inet_sockraw_ops,
               .capability = CAP_NET_RAW,
               .no_check =   UDP_CSUM_DEFAULT,
               .flags =      INET_PROTOSW_REUSE,
       }
};

数 组的每一个元素,就是支持的一种协议名称,例如IPOROTO_TCP,但是由于IPV4本身协议类型跟协议是一一对应的,所以没有更多的.type= SOCK_xxx了。这样数组实现了对PF_INET协议族下支持的协议类型,以及协议类型下边的协议进行了封装,虽然事实上它们是一一对应的关系,不过 理论上,完全可能存在一对多的可能。

数组内,封装的一个具体的协议,由struct proto结构来描述:

[Copy to clipboard] [ - ]
CODE:
/* Networking protocol blocks we attach to sockets.
* socket layer -> transport layer interface
* transport -> network interface is defined by struct inet_proto
*/
struct proto {
        void                        (*close)(struct sock *sk,
                                        long timeout);
        int                        (*connect)(struct sock *sk,
                                        struct sockaddr *uaddr,
                                        int addr_len);
        int                        (*disconnect)(struct sock *sk, int flags);

        struct sock *                (*accept) (struct sock *sk, int flags, int *err);

        int                        (*ioctl)(struct sock *sk, int cmd,
                                         unsigned long arg);
        int                        (*init)(struct sock *sk);
        int                        (*destroy)(struct sock *sk);
        void                        (*shutdown)(struct sock *sk, int how);
        int                        (*setsockopt)(struct sock *sk, int level,
                                        int optname, char __user *optval,
                                        int optlen);
        int                        (*getsockopt)(struct sock *sk, int level,
                                        int optname, char __user *optval,
                                        int __user *option);           
        int                        (*sendmsg)(struct kiocb *iocb, struct sock *sk,
                                           struct msghdr *msg, size_t len);
        int                        (*recvmsg)(struct kiocb *iocb, struct sock *sk,
                                           struct msghdr *msg,
                                        size_t len, int noblock, int flags,
                                        int *addr_len);
        int                        (*sendpage)(struct sock *sk, struct page *page,
                                        int offset, size_t size, int flags);
        int                        (*bind)(struct sock *sk,
                                        struct sockaddr *uaddr, int addr_len);

        int                        (*backlog_rcv) (struct sock *sk,
                                                struct sk_buff *skb);

        /* Keeping track of sk's, looking them up, and port selection methods. */
        void                        (*hash)(struct sock *sk);
        void                        (*unhash)(struct sock *sk);
        int                        (*get_port)(struct sock *sk, unsigned short snum);

        /* Memory pressure */
        void                        (*enter_memory_pressure)(void);
        atomic_t                *memory_allocated;        /* Current allocated memory. */
        atomic_t                *sockets_allocated;        /* Current number of sockets. */
        /*
         * Pressure flag: try to collapse.
         * Technical note: it is used by multiple contexts non atomically.
         * All the sk_stream_mem_schedule() is of this nature: accounting
         * is strict, actions are advisory and have some latency.
         */
        int                        *memory_pressure;
        int                        *sysctl_mem;
        int                        *sysctl_wmem;
        int                        *sysctl_rmem;
        int                        max_header;

        kmem_cache_t                *slab;
        unsigned int                obj_size;

        struct module                *owner;

        char                        name[32];

        struct list_head        node;

        struct {
                int inuse;
                u8  __pad[SMP_CACHE_BYTES - sizeof(int)];
        } stats[NR_CPUS];
};

以TCP协议为例,TCP协议的sokcet操作函数都被封装在这里了。

[Copy to clipboard] [ - ]
CODE:
struct proto tcp_prot = {
        .name                        = "TCP",
        .owner                        = THIS_MODULE,
        .close                        = tcp_close,
        .connect                = tcp_v4_connect,
        .disconnect                = tcp_disconnect,
        .accept                        = tcp_accept,
        .ioctl                        = tcp_ioctl,
        .init                        = tcp_v4_init_sock,
        .destroy                = tcp_v4_destroy_sock,
        .shutdown                = tcp_shutdown,
        .setsockopt                = tcp_setsockopt,
        .getsockopt                = tcp_getsockopt,
        .sendmsg                = tcp_sendmsg,
        .recvmsg                = tcp_recvmsg,
        .backlog_rcv                = tcp_v4_do_rcv,
        .hash                        = tcp_v4_hash,
        .unhash                        = tcp_unhash,
        .get_port                = tcp_v4_get_port,
        .enter_memory_pressure        = tcp_enter_memory_pressure,
        .sockets_allocated        = &tcp_sockets_allocated,
        .memory_allocated        = &tcp_memory_allocated,
        .memory_pressure        = &tcp_memory_pressure,
        .sysctl_mem                = sysctl_tcp_mem,
        .sysctl_wmem                = sysctl_tcp_wmem,
        .sysctl_rmem                = sysctl_tcp_rmem,
        .max_header                = MAX_TCP_HEADER,
        .obj_size                = sizeof(struct tcp_sock),
};








四、分配struct sock(sk)

浏览到这里,看完了PF_INET的协议簇、协议类型和协议(也就是socket调用的三个参数)的封装关系,它们通过了两个数据结构inet_protosw、struct proto来描述,被一个数组inetsw_array所封装。接下来看它的初始化工作:

[Copy to clipboard] [ - ]
CODE:
static struct list_head inetsw[SOCK_MAX];
static int __init inet_init(void)
{
……
        /* Register the socket-side information for inet_create. */
        for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
                INIT_LIST_HEAD(r);

        for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
                inet_register_protosw(q);
……
}

inetsw是一个数组,其每一个元素,都是一个链表首部,前面一个循环初始化之。后一个循环就值得注意了,也就是函数
inet_register_protosw:

[Copy to clipboard] [ - ]
CODE:
void inet_register_protosw(struct inet_protosw *p)
{
        struct list_head *lh;
        struct inet_protosw *answer;
        int protocol = p->protocol;
        struct list_head *last_perm;

        spin_lock_bh(&inetsw_lock);

        if (p->type >= SOCK_MAX)
                goto out_illegal;

        /* If we are trying to override a permanent protocol, bail. */
        answer = NULL;
        last_perm = &inetsw[p->type];
        list_for_each(lh, &inetsw[p->type]) {
                answer = list_entry(lh, struct inet_protosw, list);

                /* Check only the non-wild match. */
                if (INET_PROTOSW_PERMANENT & answer->flags) {
                        if (protocol == answer->protocol)
                                break;
                        last_perm = lh;
                }

                answer = NULL;
        }
        if (answer)
                goto out_permanent;

        /* Add the new entry after the last permanent entry if any, so that
         * the new entry does not override a permanent entry when matched with
         * a wild-card protocol. But it is allowed to override any existing
         * non-permanent entry.  This means that when we remove this entry, the
         * system automatically returns to the old behavior.
         */
        list_add_rcu(&p->list, last_perm);
out:
        spin_unlock_bh(&inetsw_lock);

        synchronize_net();

        return;

out_permanent:
        printk(KERN_ERR "Attempt to override permanent protocol %d.\n",
               protocol);
        goto out;

out_illegal:
        printk(KERN_ERR
               "Ignoring attempt to register invalid socket type %d.\n",
               p->type);
        goto out;
}

这 个函数完成的工作,就是把inetsw_array数组中,相同的协议类型下边的协议,加入到inetsw对应的协议类型的链表中去。因为事实上一对一的 关系,所以这个函数要简单得多:因为不存在其它成员,所以每一次list_entry都为空值,所以不存在覆盖和追加的情况,直接调用 list_add_rcu(&p->list, last_perm);把协议类型节点(struct inet_protosw 类型的数组的某个元素)添加到链表(链表首部本身是一个数组,数组索引是协议对应的协议类型的值)的第一个成员。

来做一个假设,如果SOCK_STREAM协议类型下边还有另一个协议,IPPROTO_123,那么inetsw_array数组中就会多出一个元素:

[Copy to clipboard] [ - ]
CODE:
        {
                .type =       SOCK_STREAM,
                .protocol =   IPPROTO_123,
                .prot =       &123_prot,
                ……
        },

这样,当遍历inetsw_array,再次进入inet_register_protosw函数后,因为SOCK_STREAM类型下已经注册了IPPROTO_TCP,所以,

[Copy to clipboard] [ - ]
CODE:
        list_for_each(lh, &inetsw[p->type]) {
                answer = list_entry(lh, struct inet_protosw, list);

                /* Check only the non-wild match. */
                if (INET_PROTOSW_PERMANENT & answer->flags) {
                        if (protocol == answer->protocol)        /* 已经注册了相同协议号,退出循环,因为没有置answer为NULL,所以后面会直接退出函数 */
                                break;
                        last_perm = lh;                                /* 移动位置指针,指向链表中最后一个元素 */
                }

                answer = NULL;
        }

这个循环, answer就会指向之前注册的TCP的链表节点,然后根据标志,如果是INET_PROTOSW_PERMANENT,则last_perm指向链表中 最后一个节点,也就是TCP,之后同样的道理,再把123追加到TCP之后,如果是INET_PROTOSW_REUSE,因为位置指针 last_perm没有移动,则之前注册的元素会被覆盖。

OK,绕了这么大一圈子,了解了协议的封装及链表的注册。现在回到inet_create中来:

[Copy to clipboard] [ - ]
CODE:
/*
*        Create an inet socket.
*/

static int inet_create(struct socket *sock, int protocol)
{
        struct sock *sk;
        struct list_head *p;
        struct inet_protosw *answer;
        struct inet_sock *inet;
        struct proto *answer_prot;
        unsigned char answer_flags;
        char answer_no_check;
        int err;
       
        sock->state = SS_UNCONNECTED;

socket的初始状态设置为“未连接”,这意味着面向连接的协议类型,如tcp,在使用之前必须建立连接修改状态位。

[Copy to clipboard] [ - ]
CODE:
        answer = NULL;
        rcu_read_lock();
        list_for_each_rcu(p, &inetsw[sock->type]) {
                answer = list_entry(p, struct inet_protosw, list);

                /* Check the non-wild match. */
                if (protocol == answer->protocol) {
                        if (protocol != IPPROTO_IP)
                                break;
                } else {
                        /* Check for the two wild cases. */
                        if (IPPROTO_IP == protocol) {
                                protocol = answer->protocol;
                                break;
                        }
                        if (IPPROTO_IP == answer->protocol)
                                break;
                }
                answer = NULL;
        }

这 个循环,根据socket(2)调用的protocol,把之前在链表中注册的协议节点找出来一个问题是,因为一一对应关系的存在,用户态调用 socket(2)的时候,常常第三个参数直接就置0了。也就是这里protocol 为 0。那内核又如何处理这一默认值呢?也就是 protocol != answer->protocol,而是被 if (IPPROTO_IP == protocol) 所匹配了。这样,将protocol置为链表中第一个协议。而当循环结束时,answer自然也是指向这个链表中的第一个注册节点。以刚才的例子, SOCK_STREAM下同时注册了TCP和123,那么这里默认就取TCP了。当然,把123在inetsw_array数组中的位置调前,那么就默认 取123了。

[Copy to clipboard] [ - ]
CODE:
        err = -ESOCKTNOSUPPORT;
        if (!answer)
                goto out_rcu_unlock;
        err = -EPERM;
        if (answer->capability > 0 && !capable(answer->capability))
                goto out_rcu_unlock;
        err = -EPROTONOSUPPORT;
        if (!protocol)
                goto out_rcu_unlock;
        /* 找到了组织,将创建的socket的ops函数指针集,指向协议类型的。例如创建的是SOCK_STREAM,那么就指向了inet_stream_ops */
        sock->ops = answer->ops;
        /* answer_prot指针指向了当前要创建的socket的协议类型下边的协议,如上例,它就是IPPROTO_TCP的tcp_prot结构 */
        answer_prot = answer->prot;
        answer_no_check = answer->no_check;
        answer_flags = answer->flags;
        rcu_read_unlock();

        BUG_TRAP(answer_prot->slab != NULL);

接下来一个重要的工作,就是为socket分配一个sock,并初始化它:

[Copy to clipboard] [ - ]
CODE:
        err = -ENOBUFS;
        sk = sk_alloc(PF_INET, GFP_KERNEL, answer_prot, 1);
        if (sk == NULL)
                goto out;

        err = 0;
        sk->sk_no_check = answer_no_check;
        if (INET_PROTOSW_REUSE & answer_flags)
                sk->sk_reuse = 1;

        inet = inet_sk(sk);

        if (SOCK_RAW == sock->type) {
                inet->num = protocol;
                if (IPPROTO_RAW == protocol)
                        inet->hdrincl = 1;
        }

        if (ipv4_config.no_pmtu_disc)
                inet->pmtudisc = IP_PMTUDISC_DONT;
        else
                inet->pmtudisc = IP_PMTUDISC_WANT;

        inet->id = 0;

        sock_init_data(sock, sk);

        sk->sk_destruct           = inet_sock_destruct;
        sk->sk_family           = PF_INET;
        sk->sk_protocol           = protocol;
        sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;

        inet->uc_ttl        = -1;
        inet->mc_loop        = 1;
        inet->mc_ttl        = 1;
        inet->mc_index        = 0;
        inet->mc_list        = NULL;

#ifdef INET_REFCNT_DEBUG
        atomic_inc(&inet_sock_nr);
#endif

        if (inet->num) {
                /* It assumes that any protocol which allows
                 * the user to assign a number at socket
                 * creation time automatically
                 * shares.
                 */
                inet->sport = htons(inet->num);
                /* Add to protocol hash chains. */
                sk->sk_prot->hash(sk);
        }

        if (sk->sk_prot->init) {
                err = sk->sk_prot->init(sk);
                if (err)
                        sk_common_release(sk);
        }
out:
        return err;
out_rcu_unlock:
        rcu_read_unlock();
        goto out;
}

虽然create的代码就到这儿了,不过要说清楚sk的分配,还得费上大力气。
每一个Socket套接字,都有一个对应的struct socket结构来描述(内核中一般使用名称为sock),但是同时又一个struct sock结构(内核中一般使用名称为sk)。两者之间是一一对应的关系。在后面的sock_init_data函数中,可以看到

[Copy to clipboard] [ - ]
CODE:
sk->sk_socket                =        sock;
sock->sk        =        sk;

这样的代码。

socket结构和sock结构实际上是同一个事物的两个方面。不妨说,socket结构是面向进程和系统调用界面的侧面,而sock结构则是面向底层驱 动程序的侧面。设计者把socket套接字中,与文件系统关系比较密切的那一部份放在socket结构中,而把与通信关系比较密切的那一部份,则单独成为 一个数结结构,那就是sock结构。由于这两部份逻辑上本来就是一体的,所以要通过指针互相指向对方,形成一对一的关系。

再暂时回到inet_init中来,初始化工作中,有如下代码:

[Copy to clipboard] [ - ]
CODE:
        rc = proto_register(&tcp_prot, 1);
        if (rc)
                goto out;

        rc = proto_register(&udp_prot, 1);
        if (rc)
                goto out_unregister_tcp_proto;

        rc = proto_register(&raw_prot, 1);
        if (rc)
                goto out_unregister_udp_proto;

这里为每个protocol都调用了proto_register函数,其重要功能之一,就是根据协议的obj_size成员的大小,为协议创建高速缓存:

[Copy to clipboard] [ - ]
CODE:
static DEFINE_RWLOCK(proto_list_lock);
static LIST_HEAD(proto_list);

int proto_register(struct proto *prot, int alloc_slab)
{
        int rc = -ENOBUFS;

        if (alloc_slab) {
        /* 可以看到,函数最重要的功能就是根据prot的obj_size成员的大小,为协议创建高速缓存 */       
                prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
                if (prot->slab == NULL) {
                        printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
                               prot->name);
                        goto out;
                }
        }

        /* 顺便看到它的另一个重要的功能,是维护一个以proto_list为首的链表 */
        write_lock(&proto_list_lock);
        list_add(&prot->node, &proto_list);
        write_unlock(&proto_list_lock);
        rc = 0;
out:
        return rc;
}

这里要注意的是:prot->obj_size的大小,它它非仅仅是一个sk的大小!!!以TCP为例:.obj_size = sizeof(struct tcp_sock)。稍后再来分析这个东东。

回到inet_create()函数中来,其调用sk_alloc()分配一个sk:

[Copy to clipboard] [ - ]
CODE:
sk = sk_alloc(PF_INET, GFP_KERNEL, answer_prot, 1);



[Copy to clipboard] [ - ]
CODE:
struct sock *sk_alloc(int family, int priority, struct proto *prot, int zero_it)
{
        struct sock *sk = NULL;
        kmem_cache_t *slab = prot->slab;

        if (slab != NULL)
                sk = kmem_cache_alloc(slab, priority);
        else
                sk = kmalloc(prot->obj_size, priority);

        if (sk) {
                if (zero_it) {
                        memset(sk, 0, prot->obj_size);
                        sk->sk_family = family;
                        /*
                         * See comment in struct sock definition to understand
                         * why we need sk_prot_creator -acme
                         */
                        sk->sk_prot = sk->sk_prot_creator = prot;
                        ……

在之前创建的高速缓存中申请分配一个slab缓存项。并清零。然后设置协议族、并把sk中的sk_prot与对应的协议关联起来。

五、初始化sk

分配完成sk后,另一个重要的功能就是初始化它,sk的成员相当复杂,其主要的初始化工作是在函数sock_init_data()中完成的:

[Copy to clipboard] [ - ]
CODE:
void sock_init_data(struct socket *sock, struct sock *sk)
{
        /* 初始化其三个队列 */
        skb_queue_head_init(&sk->sk_receive_queue);
        skb_queue_head_init(&sk->sk_write_queue);
        skb_queue_head_init(&sk->sk_error_queue);

        sk->sk_send_head        =        NULL;

        /* 初始化数据包发送定时器 */
        init_timer(&sk->sk_timer);
       
        sk->sk_allocation        =        GFP_KERNEL;
        sk->sk_rcvbuf                =        sysctl_rmem_default;
        sk->sk_sndbuf                =        sysctl_wmem_default;
        sk->sk_state                =        TCP_CLOSE;
        /* 指向对应的socket结构 */
        sk->sk_socket                =        sock;

        sock_set_flag(sk, SOCK_ZAPPED);

        if(sock)
        {
                sk->sk_type        =        sock->type;
                sk->sk_sleep        =        &sock->wait;
                /* 回指对应的scok结构 */
                sock->sk        =        sk;
        } else
                sk->sk_sleep        =        NULL;

        rwlock_init(&sk->sk_dst_lock);
        rwlock_init(&sk->sk_callback_lock);

        sk->sk_state_change        =        sock_def_wakeup;
        sk->sk_data_ready        =        sock_def_readable;
        sk->sk_write_space        =        sock_def_write_space;
        sk->sk_error_report        =        sock_def_error_report;
        sk->sk_destruct                =        sock_def_destruct;

        sk->sk_sndmsg_page        =        NULL;
        sk->sk_sndmsg_off        =        0;

        sk->sk_peercred.pid         =        0;
        sk->sk_peercred.uid        =        -1;
        sk->sk_peercred.gid        =        -1;
        sk->sk_write_pending        =        0;
        sk->sk_rcvlowat                =        1;
        sk->sk_rcvtimeo                =        MAX_SCHEDULE_TIMEOUT;
        sk->sk_sndtimeo                =        MAX_SCHEDULE_TIMEOUT;

        sk->sk_stamp.tv_sec     = -1L;
        sk->sk_stamp.tv_usec    = -1L;

        atomic_set(&sk->sk_refcnt, 1);
}

sock结构中,有三个重要的双向队列,分别是sk_receive_queue、sk_write_queue和sk_error_queue。从它们的名字就可以看出来其作用了。
队列并非采用通用的list_head来维护,而是使用skb_buffer队列:

[Copy to clipboard] [ - ]
CODE:
struct sk_buff_head {
        /* These two members must be first. */
        struct sk_buff        *next;
        struct sk_buff        *prev;

        __u32                qlen;
        spinlock_t        lock;
};

这样,队列中指向的每一个skb_buffer,就是一个数据包,分别是接收、发送和投递错误。

剩余的就是初始化其它成员变量了。后面再来专门分析这些成员的作用。

inet_create函数中,除了初始化sk成员的值,还有一部份代码,是初始化一个inet的东东:

[Copy to clipboard] [ - ]
CODE:
                inet = inet_sk(sk);
        inet->uc_ttl        = -1;
        inet->mc_loop        = 1;
        inet->mc_ttl        = 1;
        inet->mc_index        = 0;
        inet->mc_list        = NULL;

inet是一个struct inet_sock结构类型,来看它的定义:

[Copy to clipboard] [ - ]
CODE:
struct inet_sock {
        /* sk and pinet6 has to be the first two members of inet_sock */
        struct sock                sk;
               ……
}

只留意它的第一个成员就足够了。

我们说sock是面向用户态调用,而sk是面向内核驱动调用的,那sk是如何与协议栈交互的呢?对于每一个类型的协议,为了与sk联系起来,都定义了一个struct XXX_sock结构,XXX是协议名,例如:

[Copy to clipboard] [ - ]
CODE:
struct tcp_sock {
        /* inet_sock has to be the first member of tcp_sock */
        struct inet_sock        inet;
        int        tcp_header_len;        /* Bytes of tcp header to send                */
        ……
}

struct udp_sock {
        /* inet_sock has to be the first member */
        struct inet_sock inet;
        int                 pending;        /* Any pending frames ? */
        unsigned int         corkflag;        /* Cork is required */
          __u16                 encap_type;        /* Is this an Encapsulation socket? */
        /*
         * Following member retains the infomation to create a UDP header
         * when the socket is uncorked.
         */
        __u16                 len;                /* total length of pending frames */
};

struct raw_sock {
        /* inet_sock has to be the first member */
        struct inet_sock   inet;
        struct icmp_filter filter;
};

很明显,它们的结构定构是“af_inet一般属性+自己的私有属性”,因为它们的第一个成员总是inet。

呵呵,现在回头来照一下起初在af_inet.c中,封装协议注册的时候,size成员,对于tcp而言:
.obj_size                = sizeof(struct tcp_sock),
其它协议类似。

以obj_size来确定每个slab缓存项分配的大小,所以,我们就可说,每次申请分配的,实际上是一个struct XXX_sock结构大小的结构。因为都是定义于上层结构的第一个成员,可以使用强制类型转换来使用这块分配的内存空间。例如:

[Copy to clipboard] [ - ]
CODE:
inet = inet_sk(sk);

static inline struct inet_sock *inet_sk(const struct sock *sk)
{
        return (struct inet_sock *)sk;
}

struct tcp_sock *tp = tcp_sk(sk);

static inline struct tcp_sock *tcp_sk(const struct sock *sk)
{
        return (struct tcp_sock *)sk;
}

OK,inet_create()运行完,一个socket套接字基本上就创建完毕了,剩下的就是与文件系统挂钩,回到最初的 sys_socket()函数中来,它在调用完sock_create()后,紧接着调用sock_map_fd()函数:

[Copy to clipboard] [ - ]
CODE:
int sock_map_fd(struct socket *sock)
{
        int fd;
        struct qstr this;
        char name[32];

        /*
         *        Find a file descriptor suitable for return to the user.
         */

        fd = get_unused_fd();
        if (fd >= 0) {
                struct file *file = get_empty_filp();

                if (!file) {
                        put_unused_fd(fd);
                        fd = -ENFILE;
                        goto out;
                }

                sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino);
                this.name = name;
                this.len = strlen(name);
                this.hash = SOCK_INODE(sock)->i_ino;

                file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this);
                if (!file->f_dentry) {
                        put_filp(file);
                        put_unused_fd(fd);
                        fd = -ENOMEM;
                        goto out;
                }
                file->f_dentry->d_op = &sockfs_dentry_operations;
                d_add(file->f_dentry, SOCK_INODE(sock));
                file->f_vfsmnt = mntget(sock_mnt);
                file->f_mapping = file->f_dentry->d_inode->i_mapping;

                sock->file = file;
                file->f_op = SOCK_INODE(sock)->i_fop = &socket_file_ops;
                file->f_mode = FMODE_READ | FMODE_WRITE;
                file->f_flags = O_RDWR;
                file->f_pos = 0;
                fd_install(fd, file);
        }

out:
        return fd;
}

这个函数的核心思想,在一开始, 就已经分析过了。从进程的角度来讲,一个socket套接字就是一个特殊的,已打开的文件。前面分配好一个socket后,这里要做的就是将它与文件系统 拉上亲戚关系。首先获取一个空闲的文件描述符号和file结构。然后在文件系统中分配一个目录项(d_alloc),使其指向已经分配的inode节点 (d_add),然后把其目录项挂在sockfs文件系统的根目录之下。并且把目录项的指针d_op设置成指向 sockfs_dentry_operati,这个数据结构通过函数指针提供他与文件路径有关的操作:

[Copy to clipboard] [ - ]
CODE:
static struct dentry_operations sockfs_dentry_operations = {
        .d_delete =        sockfs_delete_dentry,
};

最后一步,就是将file结构中的f_op和sock结构中的i_fop都指向socket_file_ops,它是一个函数指针集,指向了socket面向文件系统的用户态调用的一些接口函数:

[Copy to clipboard] [ - ]
CODE:
static struct file_operations socket_file_ops = {
        .owner =        THIS_MODULE,
        .llseek =        no_llseek,
        .aio_read =        sock_aio_read,
        .aio_write =        sock_aio_write,
        .poll =                sock_poll,
        .unlocked_ioctl = sock_ioctl,
        .mmap =                sock_mmap,
        .open =                sock_no_open,        /* special open code to disallow open via /proc */
        .release =        sock_close,
        .fasync =        sock_fasync,
        .readv =        sock_readv,
        .writev =        sock_writev,
        .sendpage =        sock_sendpage
};

OK,到这里,整个socket套接字的创建工作,就宣告完成了。


写到这里,可以为socket的创建下一个小结了:
1、所谓创建socket,对内核而言,最重要的工作就是分配sock与sk;
2、sock面向上层系统调用,主要是与文件系统交互。通过进程的current指针的files,结合创建socket时返回的文件描符述,可以找到内 核中对应的struct file,再根据file的f_dentry可以找到对应的目录项,而目录项struct dentry中,有d_inode指针,指向与sock封装在一起的inode。sock又与sk指针互指,一一对应。在这串结构中,有两个重要的函数集 指针,一个是文件系统struct file中的f_op指针,它指向了,对应的用户态调用的read,write等操调用,但不支持open,另一个是struct socket结构,即sock的ops指针,它在inet_create()中被置为
sock->ops = answer->ops;
指向具体协议类型的ops;例如,inet_stream_ops、inet_dgram_ops或者是inet_sockraw_ops等等。它用来支持上层的socket的其它API调用。
3、sk面向内核协议栈,协议栈与它的接口数据结构是struct protoname_sock,该结构中包含了一般性的inet结构和自己的私有成员,struct inet_sock的第一个成员就是一个sk指针,而分配的sk,实际上空间大小是struct protoname_sock,所以,这三者可以通过强制类型转换来获取需要的指针。
4、由于水平有限,文件系统的一些细节被我跳过了,sk中的大多数成员变量的作用,也被我跳出过了。呵呵,还好,终于还是把这块流程给初步分析出来了。另外,当时写的时候,没有想到会写这么长,大大超出了每贴的字限制。所以,每个小节内容跟标题可能会有点对不上号。








第二部份 Socket的bind(2),绑定地址

1、bind(2)

当创建了一个Socket套接字后,对于服务器来说,接下来的工作,就是调用bind(2)为服务器指明本地址、协议端口号,常常可以看到这样的代码:
strut sockaddr_in sin;

sin.sin_family = AF_INET;
sin.sin_addr.s_addr = xxx;
sin.sin_port = xxx;

bind(sock, (struct sockaddr *)&sin, sizeof(sin));

从这个系统调用中,可以知道当进行SYS_BIND 操作的时候,:
1、对于AF_INET协议簇来讲,其地址格式是strut sockaddr_in,而对于socket来讲,strut sockaddr 结构表示的地址格式实现了更高层次
的抽像,因为每种协议长簇的地址不一定是相同的,所以,系统调用的第三个参数得指明该协议簇的地址格式的长度。

2、进行bind(2)系统调用时,除了地址长度外,还得向内核提供:sock描述符、协议簇名称、本地地址、端口这些参数;

2、sys_bind()
操作SYS_BIND 是由sys_bind()实现的:

asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
{
        struct socket *sock;
        char address[MAX_SOCK_ADDR];
        int err;

        if((sock = sockfd_lookup(fd,&err))!=NULL)
        {
                if((err=move_addr_to_kernel(umyaddr,addrlen,address))>=0) {
                        err = security_socket_bind(sock, (struct sockaddr *)address, addrlen);
                        if (err) {
                                sockfd_put(sock);
                                return err;
                        }
                        err = sock->ops->bind(sock, (struct sockaddr *)address, addrlen);
                }
                sockfd_put(sock);
        }                       
        return err;
}

在socket的创建中,已经反复分析了socket与文件系统的关系,现在已知socket的描述符号,要找出与之相关的socket结构,应该是件容易的事情:

struct socket *sockfd_lookup(int fd, int *err)
{
        struct file *file;
        struct inode *inode;
        struct socket *sock;

        if (!(file = fget(fd)))
        {
                *err = -EBADF;
                return NULL;
        }

        inode = file->f_dentry->d_inode;
        if (!S_ISSOCK(inode->i_mode)) {
                *err = -ENOTSOCK;
                fput(file);
                return NULL;
        }

        sock = SOCKET_I(inode);
        if (sock->file != file) {
                printk(KERN_ERR "socki_lookup: socket file changed!\n");
                sock->file = file;
        }
        return sock;
}

fget从当前进程的files指针中,根据sock对应的描述符号,找到已打开的文件file,再根据文件的目录项中的inode,利用inode与 sock被封装在同一个结构中的事实,调用宏SOCKET_I找到待查的sock结构。最后做一个小小的判断,因为正常情况下,sock的file指针是 回指与之相关的file。

接下来的工作是把用户态的地址拷贝至内核中来:
int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr)
{
        if(ulen<0||ulen>MAX_SOCK_ADDR)
                return -EINVAL;
        if(ulen==0)
                return 0;
        if(copy_from_user(kaddr,uaddr,ulen))
                return -EFAULT;
        return 0;
}

bind(2)第三个参数必须存在的原因之一,copy_from_user必须知道拷贝的字节长度。

因为sock的ops函数指针集,在创建之初,就指向了对应的协议类型,例如如果类型是SOCK_STREAM,那么它就指向inetsw_array[0].ops。也就是inet_stream_ops:
struct proto_ops inet_stream_ops = {
        .family =        PF_INET,
        ……
        .bind =                inet_bind,
        ……
};

sys_bind()在做完了一个通用的socket bind应该做的事情,包括查找对应sock结构,拷贝地址。就调用对应协议族的对应协议类型的bind函数,也就是inet_bind。
3、inet_bind
说bind(2)的最重要的作用,就是为套接字绑定地址和端口,那么要分析inet_bind()之前,要搞清楚的一件事情就是,这个绑定,是绑定到哪儿?或者说,是绑定到内核的哪个数据结构的哪个成员变量上面??
有三个地方是可以考虑的:socket结构,包括sock和sk,inet结构,以及protoname_sock结构。绑定在socket结构上是可行 的,这样可以实现最高层面上的抽像,但是因为每一类协议簇socket的地址及端口表现形式差异很大,这样就得引入专门的转换处理功能。绑定在 protoname_sock也是可行的,但是却是最笨拙的,因为例如tcp和udp,它们的地址及端口表现形式是一样的,这样就浪费了空间,加大了代码 处理量。所以,inet做为一个协议类型的抽像,是最理想的地方了,再来回顾一下它的定义:

[Copy to clipboard] [ - ]
CODE:
struct inet_sock {
        ……
        /* Socket demultiplex comparisons on incoming packets. */
        __u32                        daddr;                /* Foreign IPv4 addr */
        __u32                        rcv_saddr;        /* Bound local IPv4 addr */
        __u16                        dport;                /* Destination port */
        __u16                        num;                /* Local port */
        __u32                        saddr;                /* Sending source */
        ……
};

去掉了其它成员,保留了与地址及端口相关的成员变量,从注释中,可以清楚地了解它们的作用。所以,我们说的bind(2)之绑定,主要就是对这几个成员变量赋值的过程了。

[Copy to clipboard] [ - ]
CODE:
int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
{
        /* 获取地址参数 */
        struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
        /* 获取sock对应的sk */
        struct sock *sk = sock->sk;
        /* 获取sk对应的inet */
        struct inet_sock *inet = inet_sk(sk);
        /* 这个临时变量用来保存用户态传递下来的端口参数 */
        unsigned short snum;
        int chk_addr_ret;
        int err;

        /* 如果协议簇对应的协议自身还有bind函数,调用之,例如SOCK_RAW就还有一个raw_bind */
        if (sk->sk_prot->bind) {
                err = sk->sk_prot->bind(sk, uaddr, addr_len);
                goto out;
        }
        /* 校验地址长度 */
        err = -EINVAL;
        if (addr_len < sizeof(struct sockaddr_in))
                goto out;

        /* 判断地址类型:广播?多播?单播? */
        chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr);
       
        /* ipv4有一个ip_nonlocal_bind标志,表示是否绑定非本地址IP地址,可以通过
         * cat /proc/sys/net/ipv4/ip_nonlocal_bind查看到。它用来解决某些服务绑定
         * 动态IP地址的情况。作者在注释中已有详细说明:
         * Not specified by any standard per-se, however it breaks too
         * many applications when removed.  It is unfortunate since
         * allowing applications to make a non-local bind solves
         * several problems with systems using dynamic addressing.
         * (ie. your servers still start up even if your ISDN link
         *  is temporarily down)
         * 这里判断,用来确认如果没有开启“绑定非本地址IP”,地址值及类型是正确的
         */
        err = -EADDRNOTAVAIL;
        if (!sysctl_ip_nonlocal_bind &&
            !inet->freebind &&
            addr->sin_addr.s_addr != INADDR_ANY &&
            chk_addr_ret != RTN_LOCAL &&
            chk_addr_ret != RTN_MULTICAST &&
            chk_addr_ret != RTN_BROADCAST)
                goto out;
       
        /* 获取协议端口号 */
        snum = ntohs(addr->sin_port);
        err = -EACCES;
        /* 校验当前进程有没有使用低于1024端口的能力 */
        if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
                goto out;

        /*      We keep a pair of addresses. rcv_saddr is the one
         *      used by hash lookups, and saddr is used for transmit.
         *
         *      In the BSD API these are the same except where it
         *      would be illegal to use them (multicast/broadcast) in
         *      which case the sending device address is used.
         */
        lock_sock(sk);

        /* 检查socket是否已经被绑定过了:用了两个检查项,一个是sk状态,另一个是是否已经绑定过端口了
        当然地址本来就可以为0,所以,不能做为检查项 */
        err = -EINVAL;
        if (sk->sk_state != TCP_CLOSE || inet->num)
                goto out_release_sock;
       
        /* 绑定inet的接收地址(地址服务绑定地址)和来源地址为用户态指定地址 */
        inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;
        /* 若地址类型为广播或多播,则将地址置0,表示直接使用网络设备 */
        if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
                inet->saddr = 0;  /* Use device */

        /*
         * 调用协议的get_port函数,确认是否可绑定端口,若可以,则绑定在inet->num之上,注意,这里虽然没有
         * 把inet传过去,但是第一个参数sk,它本身和inet是可以互相转化的
         */
        if (sk->sk_prot->get_port(sk, snum)) {
                inet->saddr = inet->rcv_saddr = 0;
                err = -EADDRINUSE;
                goto out_release_sock;
        }
       
        /* 如果端口和地址可以绑定,置标志位 */
        if (inet->rcv_saddr)
                sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
        if (snum)
                sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
        /* inet的sport(来源端口)成员也置为绑定端口 */
        inet->sport = htons(inet->num);
        inet->daddr = 0;
        inet->dport = 0;
        sk_dst_reset(sk);
        err = 0;
out_release_sock:
        release_sock(sk);
out:
        return err;
}

上述分析中,忽略的第一个细节是capable()函数调用,它是 Linux 安全模块(LSM)的一部份,简单地讲其用来对权限做出检查,
检查是否有权对指定的资源进行操作。这里它的参数是CAP_NET_BIND_SERVICE,表示的含义是:

[Copy to clipboard] [ - ]
CODE:
/* Allows binding to TCP/UDP sockets below 1024 */
/* Allows binding to ATM VCIs below 32 */

#define CAP_NET_BIND_SERVICE 10

另一个就是协议的端口绑定,调用了协议的get_port函数,如果是SOCK_STREAM的TCP 协议,那么它就是tcp_v4_get_port()函数。

4、协议端口的绑定

要分配这个函数,还是得先绕一些基本的东东。这里涉及到内核中提供hash链表的操作的API。可以参考其它相关资料。
http://www.ibm.com/developerwork ... /l-chain/index.html
这里讲了链表的实现,顺道提了一个hash链表,觉得写得还不错,收藏一下。

对于TCP已注册的端口,是采用一个hash表来维护的。hash桶用struct tcp_bind_hashbucket结构来表示:

[Copy to clipboard] [ - ]
CODE:
struct tcp_bind_hashbucket {
        spinlock_t                lock;
        struct hlist_head        chain;
};

hash表中的每一个hash节点,用struct tcp_bind_hashbucket结构来表示:
struct tcp_bind_bucket {

[Copy to clipboard] [ - ]
CODE:
        unsigned short                port;                        /* 节点中绑定的端口 */
        signed short                fastreuse;
        struct hlist_node        node;
        struct hlist_head        owners;
};

tcp_hashinfo的hash表信息,都集中封装在结构tcp_hashinfo当中,而维护已注册端口,只是它其中一部份:

[Copy to clipboard] [ - ]
CODE:
extern struct tcp_hashinfo {
        ……

        /* Ok, let's try this, I give up, we do need a local binding
         * TCP hash as well as the others for fast bind/connect.
         */
        struct tcp_bind_hashbucket *__tcp_bhash;

        int __tcp_bhash_size;
        ……
} tcp_hashinfo;

#define tcp_bhash        (tcp_hashinfo.__tcp_bhash)
#define tcp_bhash_size        (tcp_hashinfo.__tcp_bhash_size)

其使用的hash函数是tcp_bhashfn:

[Copy to clipboard] [ - ]
CODE:
/* These are AF independent. */
static __inline__ int tcp_bhashfn(__u16 lport)
{
        return (lport & (tcp_bhash_size - 1));
}

这样,如果要取得某个端口对应的hash链的首部hash桶节点的话,可以使用:

[Copy to clipboard] [ - ]
CODE:
struct tcp_bind_hashbucket *head;
head = &tcp_bhash[tcp_bhashfn(snum)];

如果要新绑定一个端口,就是先创建一个struct tcp_bind_hashbucket结构的hash节点,然后把它插入到对应的
hash链中去:

[Copy to clipboard] [ - ]
CODE:
struct tcp_bind_bucket *tb;

tb = tcp_bucket_create(head, snum);

struct tcp_bind_bucket *tcp_bucket_create(struct tcp_bind_hashbucket *head,
                                          unsigned short snum)
{
        struct tcp_bind_bucket *tb = kmem_cache_alloc(tcp_bucket_cachep,
                                                      SLAB_ATOMIC);
        if (tb) {
                tb->port = snum;
                tb->fastreuse = 0;
                INIT_HLIST_HEAD(&tb->owners);
                hlist_add_head(&tb->node, &head->chain);
        }
        return tb;
}

另外,sk中,还级护了一个类似的hash链表,同时需要调用tcp_bind_hash()函数把hash节点插入进去:

[Copy to clipboard] [ - ]
CODE:
struct sock {
        struct sock_common        __sk_common;
#define sk_bind_node                __sk_common.skc_bind_node
        ……
}



[Copy to clipboard] [ - ]
CODE:
/* @skc_bind_node: bind hash linkage for various protocol lookup tables */
struct sock_common {
        struct hlist_node        skc_bind_node;
        ……
}



[Copy to clipboard] [ - ]
CODE:
if (!tcp_sk(sk)->bind_hash)
        tcp_bind_hash(sk, tb, snum);
       
void tcp_bind_hash(struct sock *sk, struct tcp_bind_bucket *tb,
                   unsigned short snum)
{
        inet_sk(sk)->num = snum;
        sk_add_bind_node(sk, &tb->owners);
        tcp_sk(sk)->bind_hash = tb;
}

这里,就顺道绑定了inet的num成员变量,并置协议的bind_hash指针为当前分配的hash节点。而sk_add_bind_node函数,
就是一个插入hash表节点的过程:

[Copy to clipboard] [ - ]
CODE:
static __inline__ void sk_add_bind_node(struct sock *sk,
                                        struct hlist_head *list)
{
        hlist_add_head(&sk->sk_bind_node, list);
}

如果要遍历hash表的话,例如在插入之前,先判断端口是否已经在hash表当中了。就可以调用:

[Copy to clipboard] [ - ]
CODE:
#define tb_for_each(tb, node, head) hlist_for_each_entry(tb, node, head, node)

struct tcp_bind_hashbucket *head;
struct tcp_bind_bucket *tb;

head = &tcp_bhash[tcp_bhashfn(snum)];
spin_lock(&head->lock);
tb_for_each(tb, node, &head->chain)
        if (tb->port == snum)
                found,do_something;

有了这些基础知识,再来看tcp_v4_get_port()的实现,就要容易得多了:

[Copy to clipboard] [ - ]
CODE:
static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
{
        struct tcp_bind_hashbucket *head;
        struct hlist_node *node;
        struct tcp_bind_bucket *tb;
        int ret;

        local_bh_disable();
       
        /* 如果端口值为0,意味着让系统从本地可用端口用选择一个,并置snum为分配的值 */
        if (!snum) {
                int low = sysctl_local_port_range[0];
                int high = sysctl_local_port_range[1];
                int remaining = (high - low) + 1;
                int rover;

                spin_lock(&tcp_portalloc_lock);
                if (tcp_port_rover < low)
                        rover = low;
                else
                        rover = tcp_port_rover;
                do {
                        rover++;
                        if (rover > high)
                                rover = low;
                        head = &tcp_bhash[tcp_bhashfn(rover)];
                        spin_lock(&head->lock);
                        tb_for_each(tb, node, &head->chain)
                                if (tb->port == rover)
                                        goto next;
                        break;
                next:
                        spin_unlock(&head->lock);
                } while (--remaining > 0);
                tcp_port_rover = rover;
                spin_unlock(&tcp_portalloc_lock);

                /* Exhausted local port range during search? */
                ret = 1;
                if (remaining <= 0)
                        goto fail;

                /* OK, here is the one we will use.  HEAD is
                 * non-NULL and we hold it's mutex.
                 */
                snum = rover;
        } else {
                /* 否则,就在hash表中,查找端口是否已经存在 */
                head = &tcp_bhash[tcp_bhashfn(snum)];
                spin_lock(&head->lock);
                tb_for_each(tb, node, &head->chain)
                        if (tb->port == snum)
                                goto tb_found;
        }
        tb = NULL;
        goto tb_not_found;
tb_found:
        /*  稍后有对应的代码:第一次分配tb后,会调用tcp_bind_hash加入至相应的sk,这里先做一个判断,来确定这一步工作是否进行过*/
        if (!hlist_empty(&tb->owners)) {
/* socket的SO_REUSEADDR 选项,用来确定是否允许本地地址重用,例如同时启动多个服务器、多个套接字绑定至同一端口等等,sk_reuse成员对应其值,因为如果一个绑定的 hash节点已经存在,而且不允许重用的话,那么则表示因冲突导致出错,调用tcp_bind_conflict来处理之 */
                if (sk->sk_reuse > 1)
                        goto success;
                if (tb->fastreuse > 0 &&
                    sk->sk_reuse && sk->sk_state != TCP_LISTEN) {
                        goto success;
                } else {
                        ret = 1;
                        if (tcp_bind_conflict(sk, tb))
                                goto fail_unlock;
                }
        }
tb_not_found:
        /* 如果不存在,则分配hash节点,绑定端口 */
        ret = 1;
        if (!tb && (tb = tcp_bucket_create(head, snum)) == NULL)
                goto fail_unlock;
        if (hlist_empty(&tb->owners)) {
                if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
                        tb->fastreuse = 1;
                else
                        tb->fastreuse = 0;
        } else if (tb->fastreuse &&
                   (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
                tb->fastreuse = 0;
success:
        if (!tcp_sk(sk)->bind_hash)
                tcp_bind_hash(sk, tb, snum);
        BUG_TRAP(tcp_sk(sk)->bind_hash == tb);
        ret = 0;

fail_unlock:
        spin_unlock(&head->lock);
fail:
        local_bh_enable();
        return ret;
}

到这里,可以为这部份下一个小结了,所谓绑定,就是:
1、设置内核中inet相关变量成员的值,以待后用;
2、协议中,如TCP协议,记录绑定的协议端口的信息,采用hash链表存储,sk中也同时维护了这么一个链表。两者的区别应该是
前者给协议用。后者给socket用。








Linux TCP/IP协议栈之Socket的实现分析(五 Connect客户端发起连接请求)  




1、sys_connect

对于客户端来说,当创建了一个套接字后,就可以连接它了。

[Copy to clipboard] [ - ]
CODE:
                case SYS_CONNECT:
                        err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
                        break;



[Copy to clipboard] [ - ]
CODE:
asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen)
{
        struct socket *sock;
        char address[MAX_SOCK_ADDR];
        int err;

        sock = sockfd_lookup(fd, &err);
        if (!sock)
                goto out;
        err = move_addr_to_kernel(uservaddr, addrlen, address);
        if (err < 0)
                goto out_put;

        err = security_socket_connect(sock, (struct sockaddr *)address, addrlen);
        if (err)
                goto out_put;

        err = sock->ops->connect(sock, (struct sockaddr *) address, addrlen,
                                 sock->file->f_flags);
out_put:
        sockfd_put(sock);
out:
        return err;
}

跟其它操作类似,sys_connect接着调用inet_connect:

[Copy to clipboard] [ - ]
CODE:
/*
*        Connect to a remote host. There is regrettably still a little
*        TCP 'magic' in here.
*/
int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
                        int addr_len, int flags)
{
        struct sock *sk = sock->sk;
        int err;
        long timeo;

        lock_sock(sk);

        if (uaddr->sa_family == AF_UNSPEC) {
                err = sk->sk_prot->disconnect(sk, flags);
                sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
                goto out;
        }

提交的协议簇不正确,则断开连接。

[Copy to clipboard] [ - ]
CODE:
        switch (sock->state) {
        default:
                err = -EINVAL;
                goto out;
        case SS_CONNECTED:
                err = -EISCONN;
                goto out;
        case SS_CONNECTING:
                err = -EALREADY;
                /* Fall out of switch with err, set for this state */
                break;

socket处于不正确的连接状态,返回相应的错误值。

[Copy to clipboard] [ - ]
CODE:
        case SS_UNCONNECTED:
                err = -EISCONN;
                if (sk->sk_state != TCP_CLOSE)
                        goto out;
                /*调用协议的连接函数*/
                err = sk->sk_prot->connect(sk, uaddr, addr_len);
                if (err < 0)
                        goto out;
                /*协议方面的工作已经处理完成了,但是自己的一切工作还没有完成,所以切换至正在连接中*/
                  sock->state = SS_CONNECTING;

                /* Just entered SS_CONNECTING state; the only
                 * difference is that return value in non-blocking
                 * case is EINPROGRESS, rather than EALREADY.
                 */
                err = -EINPROGRESS;
                break;
        }

对于TCP的实际的连接,是通过调用tcp_v4_connect()函数来实现的。

二、tcp_v4_connect函数
对于TCP协议来说,其连接,实际上就是发送一个SYN报文,在服务器的应到到来时,回答它一个ack报文,也就是完成三次握手中的第一和第三次。

要发送SYN报文,也就是说,需要有完整的来源/目的地址,来源/目的端口,目的地址/端口由用户态提交,但是问题是没有自己的地址和端口,因为并没有调用过bind(2),一台主机,对于端口,可以像sys_bind()那样,从本地未用端口中动态分配一个,那地址呢?因为一台主机可能会存在多个IP地址,如果随机动态选择,那么有可能选择一个错误的来源地址,将不能正确地到达目的地址。换句话说,来源地址的选择,是与路由相关的。

调用路由查找的核心函数ip_route_output_slow(),在没有提供来源地址的情况下,会根据实际情况,调用inet_select_addr()函数来选择一个合适的。同时,如果路由查找命中,会生成一个相应的路由缓存项,这个缓存项,不但对当前发送SYN报文有意义,对于后续的所有数据包,都可以起到一个加速路由查找的作用。这一任务,是通过ip_route_connect()函数完成的,它返回相应的路由缓存项(也就是说,来源地址也在其中了):

[Copy to clipboard] [ - ]
CODE:
static inline int ip_route_connect(struct rtable **rp, u32 dst,
                                   u32 src, u32 tos, int oif, u8 protocol,
                                   u16 sport, u16 dport, struct sock *sk)
{
        struct flowi fl = { .oif = oif,
                            .nl_u = { .ip4_u = { .daddr = dst,
                                                 .saddr = src,
                                                 .tos   = tos } },
                            .proto = protocol,
                            .uli_u = { .ports =
                                       { .sport = sport,
                                         .dport = dport } } };

        int err;
        if (!dst || !src) {
                err = __ip_route_output_key(rp, &fl);
                if (err)
                        return err;
                fl.fl4_dst = (*rp)->rt_dst;
                fl.fl4_src = (*rp)->rt_src;
                ip_rt_put(*rp);
                *rp = NULL;
        }
        return ip_route_output_flow(rp, &fl, sk, 0);
}

首先,构建一个搜索keyfl,在搜索要素中,来源地址/端口是不存在的。所以,当通过__ip_route_output_key进行查找时,第一次是不会命中缓存的。__ip_route_output_key将继续调用ip_route_output_slow()函数,在路由表中搜索,并返回一个合适的来源地址,并且生成一个路由缓存项。
路由查找的更多细节,我会在另一个贴子中来分析。

[Copy to clipboard] [ - ]
CODE:
/* This will initiate an outgoing connection. */
int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
        struct inet_sock *inet = inet_sk(sk);
        struct tcp_sock *tp = tcp_sk(sk);
        struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
        struct rtable *rt;
        u32 daddr, nexthop;
        int tmp;
        int err;

        if (addr_len < sizeof(struct sockaddr_in))
                return -EINVAL;

        if (usin->sin_family != AF_INET)
                return -EAFNOSUPPORT;

校验地址长度和协议簇。

[Copy to clipboard] [ - ]
CODE:
nexthop = daddr = usin->sin_addr.s_addr;

将下一跳地址和目的地址的临时变量都暂时设为用户提交的地址。

[Copy to clipboard] [ - ]
CODE:
        if (inet->opt && inet->opt->srr) {
                if (!daddr)
                        return -EINVAL;
                nexthop = inet->opt->faddr;
        }

如果使用了来源地址路由,选择一个合适的下一跳地址。

[Copy to clipboard] [ - ]
CODE:
        tmp = ip_route_connect(&rt, nexthop, inet->saddr,
                               RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
                               IPPROTO_TCP,
                               inet->sport, usin->sin_port, sk);
        if (tmp < 0)
                return tmp;

        if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
                ip_rt_put(rt);
                return -ENETUNREACH;
        }

进行路由查找,并校验返回的路由的类型,TCP是不被允许使用多播和广播的。

[Copy to clipboard] [ - ]
CODE:
        if (!inet->opt || !inet->opt->srr)
                daddr = rt->rt_dst;

更新目的地址临时变量——使用路由查找后返回的值。

[Copy to clipboard] [ - ]
CODE:
        if (!inet->saddr)
                inet->saddr = rt->rt_src;
        inet->rcv_saddr = inet->saddr;

如果还没有设置源地址,和本地发送地址,则使用路由中返回的值。

[Copy to clipboard] [ - ]
CODE:
        if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
                /* Reset inherited state */
                tp->rx_opt.ts_recent           = 0;
                tp->rx_opt.ts_recent_stamp = 0;
                tp->write_seq                   = 0;
        }

        if (sysctl_tcp_tw_recycle &&
            !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
                struct inet_peer *peer = rt_get_peer(rt);

                /* VJ's idea. We save last timestamp seen from
                 * the destination in peer table, when entering state TIME-WAIT
                 * and initialize rx_opt.ts_recent from it, when trying new connection.
                 */

                if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
                        tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
                        tp->rx_opt.ts_recent = peer->tcp_ts;
                }
        }

这个更新初始状态方面的内容,还没有去分析它。

[Copy to clipboard] [ - ]
CODE:
        inet->dport = usin->sin_port;
        inet->daddr = daddr;

保存目的地址及端口。

[Copy to clipboard] [ - ]
CODE:
        tp->ext_header_len = 0;
        if (inet->opt)
                tp->ext_header_len = inet->opt->optlen;



[Copy to clipboard] [ - ]
CODE:
tp->rx_opt.mss_clamp = 536;

设置最小允许的mss值

[Copy to clipboard] [ - ]
CODE:
tcp_set_state(sk, TCP_SYN_SENT);

套接字状态被置为TCP_SYN_SENT,

[Copy to clipboard] [ - ]
CODE:
        err = tcp_v4_hash_connect(sk);
        if (err)
                goto failure;

动态选择一个本地端口,并加入hash表,与bind(2)选择端口类似。

[Copy to clipboard] [ - ]
CODE:
        err = ip_route_newports(&rt, inet->sport, inet->dport, sk);
        if (err)
                goto failure;

        /* OK, now commit destination to socket.  */
        __sk_dst_set(sk, &rt->u.dst);
        tcp_v4_setup_caps(sk, &rt->u.dst);

因为本地端口已经改变,使用新端口,重新查找路由,并用新的路由缓存项更新sk中保存的路由缓存项。

[Copy to clipboard] [ - ]
CODE:
        if (!tp->write_seq)
                tp->write_seq = secure_tcp_sequence_number(inet->saddr,
                                                           inet->daddr,
                                                           inet->sport,
                                                           usin->sin_port);

为TCP报文计算一个seq值(实际使用的值是tp->write_seq+1)。

inet->id = tp->write_seq ^ jiffies;

[Copy to clipboard] [ - ]
CODE:
        err = tcp_connect(sk);
        rt = NULL;
        if (err)
                goto failure;

        return 0;

tp_connect()函数用来根据sk中的信息,构建一个完成的syn报文,并将它发送出去。在分析tcp栈的实现时再来分析它。

根据TCP协议,接下来的问题是,
1、可能收到了服务器的应答,则要回送一个ack报文;
2、如果超时还没有应答,则使用超时重发定时器;














一、tcp栈的三次握手简述

进一步的分析,都是以tcp协议为例,因为udp要相对简单得多,分析完tcp,udp的基本已经被覆盖了。

这里主要是分析socket,但是因为它将与tcp/udp传输层交互,所以不可避免地接触到这一层面的代码,这里只是摘取其主要流程的一些代码片段,以更好地分析accept的实现过程。

当套接字进入LISTEN后,意味着服务器端已经可以接收来自客户端的请求。当一个syn包到达后,服务器认为它是一个tcp 请求报文,根据tcp
协议,TCP网络栈将会自动应答它一个syn+ack报文,并且将它放入syn_table这个hash表中,静静地等待客户端第三次握手报文的来到。一个tcp的syn报文进入tcp堆栈后,会按以下函数调用,最终进入tcp_v4_conn_request:

[Copy to clipboard] [ - ]
CODE:
tcp_v4_rcv
        ->tcp_v4_do_rcv
                ->tcp_rcv_state_process
                        ->tp->af_specific->conn_request

tcp_ipv4.c中,tcp_v4_init_sock初始化时,有

tp->af_specific = &ipv4_specific;

[Copy to clipboard] [ - ]
CODE:
struct tcp_func ipv4_specific = {
        .queue_xmit        =        ip_queue_xmit,
        .send_check        =        tcp_v4_send_check,
        .rebuild_header        =        tcp_v4_rebuild_header,
        .conn_request        =        tcp_v4_conn_request,
        .syn_recv_sock        =        tcp_v4_syn_recv_sock,
        .remember_stamp        =        tcp_v4_remember_stamp,
        .net_header_len        =        sizeof(struct iphdr),
        .setsockopt        =        ip_setsockopt,
        .getsockopt        =        ip_getsockopt,
        .addr2sockaddr        =        v4_addr2sockaddr,
        .sockaddr_len        =        sizeof(struct sockaddr_in),
};

所以af_specific->conn_request实际指向的是tcp_v4_conn_request:

[Copy to clipboard] [ - ]
CODE:
int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
{
        struct open_request *req;
        ……
        /* 分配一个连接请求 */
        req = tcp_openreq_alloc();
        if (!req)
                goto drop;
        ……       
        /* 根据数据包的实际要素,如来源/目的地址等,初始化它*/
        tcp_openreq_init(req, &tmp_opt, skb);

        req->af.v4_req.loc_addr = daddr;
        req->af.v4_req.rmt_addr = saddr;
        req->af.v4_req.opt = tcp_v4_save_options(sk, skb);
        req->class = &or_ipv4;               
        ……
        /* 回送一个syn+ack的二次握手报文 */
        if (tcp_v4_send_synack(sk, req, dst))
                goto drop_and_free;

        if (want_cookie) {
                ……
        } else {
                /* 将连接请求req加入连接监听表syn_table */
                tcp_v4_synq_add(sk, req);
        }
        return 0;       
}

syn_table在前面分析的时候已经反复看到了。它的作用就是记录syn请求报文,构建一个hash表。这里调用的tcp_v4_synq_add()就完成了将请求添加进该表的操作:

[Copy to clipboard] [ - ]
CODE:
static void tcp_v4_synq_add(struct sock *sk, struct open_request *req)
{
        struct tcp_sock *tp = tcp_sk(sk);
        struct tcp_listen_opt *lopt = tp->listen_opt;
        /* 计算一个hash值 */
        u32 h = tcp_v4_synq_hash(req->af.v4_req.rmt_addr, req->rmt_port, lopt->hash_rnd);

        req->expires = jiffies + TCP_TIMEOUT_INIT;
        req->retrans = 0;
        req->sk = NULL;
        /*指针移到hash链的未尾*/
        req->dl_next = lopt->syn_table[h];

        write_lock(&tp->syn_wait_lock);
        /*加入当前节点*/
        lopt->syn_table[h] = req;
        write_unlock(&tp->syn_wait_lock);

        tcp_synq_added(sk);
}

这样,所以的syn请求都被放入这个表中,留待第三次ack的到来的匹配。当第三次ack来到后,会进入下列函数:

[Copy to clipboard] [ - ]
CODE:
tcp_v4_rcv
        ->tcp_v4_do_rcv



[Copy to clipboard] [ - ]
CODE:
int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
        ……
       
        if (sk->sk_state == TCP_LISTEN) {
                struct sock *nsk = tcp_v4_hnd_req(sk, skb);
        ……
}

因为目前sk还是TCP_LISTEN状态,所以会进入tcp_v4_hnd_req:

[Copy to clipboard] [ - ]
CODE:
static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
{
        struct tcphdr *th = skb->h.th;
        struct iphdr *iph = skb->nh.iph;
        struct tcp_sock *tp = tcp_sk(sk);
        struct sock *nsk;
        struct open_request **prev;
        /* Find possible connection requests. */
        struct open_request *req = tcp_v4_search_req(tp, &prev, th->source,
                                                     iph->saddr, iph->daddr);
        if (req)
                return tcp_check_req(sk, skb, req, prev);
        ……
}

tcp_v4_search_req就是查找匹配syn_table表:

[Copy to clipboard] [ - ]
CODE:
static struct open_request *tcp_v4_search_req(struct tcp_sock *tp,
                                              struct open_request ***prevp,
                                              __u16 rport,
                                              __u32 raddr, __u32 laddr)
{
        struct tcp_listen_opt *lopt = tp->listen_opt;
        struct open_request *req, **prev;

        for (prev = &lopt->syn_table[tcp_v4_synq_hash(raddr, rport, lopt->hash_rnd)];
             (req = *prev) != NULL;
             prev = &req->dl_next) {
                if (req->rmt_port == rport &&
                    req->af.v4_req.rmt_addr == raddr &&
                    req->af.v4_req.loc_addr == laddr &&
                    TCP_INET_FAMILY(req->class->family)) {
                        BUG_TRAP(!req->sk);
                        *prevp = prev;
                        break;
                }
        }

        return req;
}

hash表的查找还是比较简单的,调用tcp_v4_synq_hash计算出hash值,找到hash链入口,遍历该链即可。

排除超时等意外因素,刚才加入hash表的req会被找到,这样,tcp_check_req()函数将会被继续调用:

[Copy to clipboard] [ - ]
CODE:
struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
                           struct open_request *req,
                           struct open_request **prev)
{
        ……
        tcp_acceptq_queue(sk, req, child);
        ……
}

req被找到,表明三次握手已经完成,连接已经成功建立,tcp_check_req最终将调用tcp_acceptq_queue(),把这个建立好的连接加入至tp->accept_queue队列,等待用户调用accept(2)来读取之。

[Copy to clipboard] [ - ]
CODE:
static inline void tcp_acceptq_queue(struct sock *sk, struct open_request *req,
                                         struct sock *child)
{
        struct tcp_sock *tp = tcp_sk(sk);

        req->sk = child;
        sk_acceptq_added(sk);

        if (!tp->accept_queue_tail) {
                tp->accept_queue = req;
        } else {
                tp->accept_queue_tail->dl_next = req;
        }
        tp->accept_queue_tail = req;
        req->dl_next = NULL;
}

二、sys_accept
如上,当listen(2)调用准备就绪的时候,服务器可以通过调用accept(2)接受或等待(注意这个“或等待”是相当的重要)连接队列中的第一个请求:

[Copy to clipboard] [ - ]
CODE:
int accept(int s, struct sockaddr * addr ,socklen_t *addrlen);

accept (2)调用,只是针对有连接模式。socket一旦经过listen(2)调用进入监听状态后,就被动地调用accept(2),接受来自客户端的连接请 求。accept(2)调用是阻塞的,也就是说如果没有连接请求到达,它会去睡觉,等到连接请求到来后(或者是超时),才会返回。同样地,操作码 SYS_ACCEPT对应的是函数sys_accept:

[Copy to clipboard] [ - ]
CODE:
asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, int __user *upeer_addrlen)
{
        struct socket *sock, *newsock;
        int err, len;
        char address[MAX_SOCK_ADDR];

        sock = sockfd_lookup(fd, &err);
        if (!sock)
                goto out;

        err = -ENFILE;
        if (!(newsock = sock_alloc()))
                goto out_put;

        newsock->type = sock->type;
        newsock->ops = sock->ops;

        err = security_socket_accept(sock, newsock);
        if (err)
                goto out_release;

        /*
         * We don't need try_module_get here, as the listening socket (sock)
         * has the protocol module (sock->ops->owner) held.
         */
        __module_get(newsock->ops->owner);

        err = sock->ops->accept(sock, newsock, sock->file->f_flags);
        if (err < 0)
                goto out_release;

        if (upeer_sockaddr) {
                if(newsock->ops->getname(newsock, (struct sockaddr *)address, &len, 2)<0) {
                        err = -ECONNABORTED;
                        goto out_release;
                }
                err = move_addr_to_user(address, len, upeer_sockaddr, upeer_addrlen);
                if (err < 0)
                        goto out_release;
        }

        /* File flags are not inherited via accept() unlike another OSes. */

        if ((err = sock_map_fd(newsock)) < 0)
                goto out_release;

        security_socket_post_accept(sock, newsock);

out_put:
        sockfd_put(sock);
out:
        return err;
out_release:
        sock_release(newsock);
        goto out_put;
}

代码稍长了点,逐步来分析它。

一个socket,经过listen(2)设置成server套接字后,就永远不会再与任何客户端套接字建立连接了。因为一旦它接受了一个连接请求,就会 创建出一个新的socket,新的socket用来描述新到达的连接,而原先的server套接字并无改变,并且还可以通过下一次accept(2)调用 再创建一个新的出来,就像母鸡下蛋一样,“只取蛋,不杀鸡”,server 套接字永远保持接受新的连接请求的能力。

函数先通过sockfd_lookup(),根据fd,找到对应的sock,然后通过sock_alloc分配一个新的sock。接着就调用协议簇的accept()函数:

[Copy to clipboard] [ - ]
CODE:
/*
*        Accept a pending connection. The TCP layer now gives BSD semantics.
*/

int inet_accept(struct socket *sock, struct socket *newsock, int flags)
{
        struct sock *sk1 = sock->sk;
        int err = -EINVAL;
        struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err);

        if (!sk2)
                goto do_err;

        lock_sock(sk2);

        BUG_TRAP((1 << sk2->sk_state) &
                 (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE));

        sock_graft(sk2, newsock);

        newsock->state = SS_CONNECTED;
        err = 0;
        release_sock(sk2);
do_err:
        return err;
}

函数第一步工作是调用协议的accept函数,然后调用sock_graft()函数,接下来,设置新的套接字的状态为SS_CONNECTED。

[Copy to clipboard] [ - ]
CODE:
/*
*        This will accept the next outstanding connection.
*/

struct sock *tcp_accept(struct sock *sk, int flags, int *err)
{
        struct tcp_sock *tp = tcp_sk(sk);
        struct open_request *req;
        struct sock *newsk;
        int error;

        lock_sock(sk);

        /* We need to make sure that this socket is listening,
         * and that it has something pending.
         */
        error = -EINVAL;
        if (sk->sk_state != TCP_LISTEN)
                goto out;

        /* Find already established connection */
        if (!tp->accept_queue) {
                long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);

                /* If this is a non blocking socket don't sleep */
                error = -EAGAIN;
                if (!timeo)
                        goto out;

                error = wait_for_connect(sk, timeo);
                if (error)
                        goto out;
        }

        req = tp->accept_queue;
        if ((tp->accept_queue = req->dl_next) == NULL)
                tp->accept_queue_tail = NULL;

        newsk = req->sk;
        sk_acceptq_removed(sk);
        tcp_openreq_fastfree(req);
        BUG_TRAP(newsk->sk_state != TCP_SYN_RECV);
        release_sock(sk);
        return newsk;

out:
        release_sock(sk);
        *err = error;
        return NULL;
}

tcp_accept()函数,当发现tp->accept_queue准备就绪后,就直接调用

[Copy to clipboard] [ - ]
CODE:
        req = tp->accept_queue;
        if ((tp->accept_queue = req->dl_next) == NULL)
                tp->accept_queue_tail = NULL;

        newsk = req->sk;

出队,并取得相应的sk。
否则,就在获取超时时间后,调用wait_for_connect等待连接的到来。这也是说,强调“或等待”的原因所在了。

OK,继续回到inet_accept中来,当取得一个就绪的连接的sk(sk2)后,先校验其状态,再调用sock_graft()函数。

在sys_accept中,已经调用了sock_alloc,分配了一个新的socket结构(即newsock),但sock_alloc必竟不是sock_create,它并不能为newsock分配一个对应的sk。所以这个套接字并不完整。
另一方面,当一个连接到达到,根据客户端的请求,产生了一个新的sk(即sk2,但这个分配过程没有深入tcp栈去分析其实现,只分析了它对应的req入队的代码)。呵呵,将两者一关联,就OK了,这就是sock_graft的任务:

[Copy to clipboard] [ - ]
CODE:
static inline void sock_graft(struct sock *sk, struct socket *parent)
{
        write_lock_bh(&sk->sk_callback_lock);
        sk->sk_sleep = &parent->wait;
        parent->sk = sk;
        sk->sk_socket = parent;
        write_unlock_bh(&sk->sk_callback_lock);
}

这样,一对一的联系就建立起来了。这个为accept分配的新的socket也大功告成了。接下来将其状态切换为SS_CONNECTED,表示已连接就绪,可以来读取数据了——如果有的话。

顺便提一下,新的sk的分配,是在:
]tcp_v4_rcv
        ->tcp_v4_do_rcv
                     ->tcp_check_req
                              ->tp->af_specific->syn_recv_sock(sk, skb, req, NULL);
即tcp_v4_syn_recv_sock函数,其又调用tcp_create_openreq_child()来分配的。

[Copy to clipboard] [ - ]
CODE:
struct sock *tcp_create_openreq_child(struct sock *sk, struct open_request *req, struct sk_buff *skb)
{
        /* allocate the newsk from the same slab of the master sock,
         * if not, at sk_free time we'll try to free it from the wrong
         * slabcache (i.e. is it TCPv4 or v6?), this is handled thru sk->sk_prot -acme */
        struct sock *newsk = sk_alloc(PF_INET, GFP_ATOMIC, sk->sk_prot, 0);

        if(newsk != NULL) {
                          ……
                         memcpy(newsk, sk, sizeof(struct tcp_sock));
                         newsk->sk_state = TCP_SYN_RECV;
                          ……
}

等到分析tcp栈的实现的时候,再来仔细分析它。但是这里新的sk的有限状态机被切换至了 TCP_SYN_RECV(按我的想法,似乎应进入establshed才对呀,是不是哪儿看漏了,只有看了后头的代码再来印证了)

回到sys_accept中来,如果调用者要求返回各户端的地址,则调用新的sk的getname函数指针,也就是inet_getname:

[Copy to clipboard] [ - ]
CODE:
/*
*        This does both peername and sockname.
*/
int inet_getname(struct socket *sock, struct sockaddr *uaddr,
                        int *uaddr_len, int peer)
{
        struct sock *sk                = sock->sk;
        struct inet_sock *inet        = inet_sk(sk);
        struct sockaddr_in *sin        = (struct sockaddr_in *)uaddr;

        sin->sin_family = AF_INET;
        if (peer) {
                if (!inet->dport ||
                    (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) &&
                     peer == 1))
                        return -ENOTCONN;
                sin->sin_port = inet->dport;
                sin->sin_addr.s_addr = inet->daddr;
        } else {
                __u32 addr = inet->rcv_saddr;
                if (!addr)
                        addr = inet->saddr;
                sin->sin_port = inet->sport;
                sin->sin_addr.s_addr = addr;
        }
        memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
        *uaddr_len = sizeof(*sin);
        return 0;
}

函数的工作是构建珍上struct sockaddr_in 结构出来,接着在sys_accept中,调用move_addr_to_user()函数来拷贝至用户空间:

[Copy to clipboard] [ - ]
CODE:
int move_addr_to_user(void *kaddr, int klen, void __user *uaddr, int __user *ulen)
{
        int err;
        int len;

        if((err=get_user(len, ulen)))
                return err;
        if(len>klen)
                len=klen;
        if(len<0 || len> MAX_SOCK_ADDR)
                return -EINVAL;
        if(len)
        {
                if(copy_to_user(uaddr,kaddr,len))
                        return -EFAULT;
        }
        /*
         *        "fromlen shall refer to the value before truncation.."
         *                        1003.1g
         */
        return __put_user(klen, ulen);
}

也就是调用copy_to_user的过程了。

sys_accept的最后一步工作,是将新的socket结构,与文件系统挂钩:

[Copy to clipboard] [ - ]
CODE:
        if ((err = sock_map_fd(newsock)) < 0)
                goto out_release;

函数sock_map_fd在创建socket中已经见过了。

小结:
accept有几件事情要做
1、要accept,需要三次握手完成,连接请求入tp->accept_queue队列(新为客户端分析的sk,也在其中),其才能出队;
2、为accept分配一个sokcet结构,并将其与新的sk关联;
3、如果调用时,需要获取客户端地址,即第二个参数不为NULL,则从新的sk中,取得其想的葫芦;
4、将新的socket结构与文件系统挂钩;




转自:http://blog.163.com/s_xli1/


你可能感兴趣的:(Linux TCP/IP协议栈之Socket的实现分析)