pci驱动的注册和初始化

    大家好，最近在看网络部分的代码，目前看到了网卡的初始化部分。书上讲到的内容主要是网卡驱动程序对网卡自身的初始化部分，即网卡驱动的probe函数是如何执行的，而很少讲到网卡是如何注册到系统中去的这一部分。
    现在的网卡大部分都是连接到PCI总线上的。因此，网卡驱动是如何连接到PCI总线，又是如何与网卡设备联系起来，网卡在注册的最后又是如何调用到该网卡的probe函数的，这一个过程将在后面的文章中进行描述。整个文章分成两个部分，第一部分是讲解总线、设备以及驱动三者的联系，为第二部分具体讲解PCI总线、网卡设备和驱动做一点铺垫。
    由于我在这方面也是初学，之所以想总结出来是想到在总结的过程中对自己的学习也是一个梳理的过程。所以有什么地方写得不好的，还请各位多多指正，非常感谢！也希望能在这里结识更多的朋友。

    在总结的过程中参考了下面一些资料，在此表示感谢：
[1] <Understanding Linux Network Internals>
[2] <Linux那些事儿之我是U盘>
[3] <Essential Linux Device Drivers>
[4] <Linux Device Driver> 3rd Edition.


1. 总线、设备和驱动
1.1 简单介绍
        Linux设备模型中三个很重要的概念就是总线、设备和驱动，即bus，device和driver。它们分别对应的数据结构分别为struct bus_type，struct device和struct device_driver。
        总线是处理器与一个或多个设备之间的通道，在设备模型中，所有的设备都通过总线相连。在最底层，Linux系统中的每一个设备都用device结构的一个实例来表示。而驱动则是使总线上的设备能够完成它应该完成的功能。
        在系统中有多种总线，如PCI总线、SCSI总线等。系统中的多个设备和驱动是通过总线让它们联系起来的。在bus_type中两个很重要的成员就是struct kset drivers和struct kset devices。它分别代表了连接在这个总线上的两个链，一个是设备链表，另一个则是设备驱动链表。也就是说，通过一个总线描述符，就可以找到挂载到这条总线上的设备，以及支持该总线的不同的设备驱动程序。
1.2 总线、设备与驱动的绑定
        在系统启动时，它会对每种类型的总线创建一个描述符，并将使用该总线的设备链接到该总线描述符的devices链上来。也即是说在系统初始化时，它会扫描连接了哪些设备，并且为每个设备建立一个struce device变量，然后将该变量链接到这个设备所连接的总线的描述符上去。另一方面，每当加载了一个设备驱动，则系统也会准备一个struct device_driver结构的变量，然后再将这个变量也链接到它所在总线的描述符的drivers链上去。       
        对于设备来说，在结构体struct device中有两个重要的成员，一个是struct bus_type *bus，另一个是struct device_driver *driver。bus成员就表示该设备是链接到哪一个总线上的，而driver成员就表示当前设备是由哪个驱动程序所驱动的。对于驱动程序来说，在结构体struct device_driver中也有两个成员，struct bus_type *bus和struct list_head devices，这里的bus成员也是指向这个驱动是链接到哪个总线上的，而devices这个链表则是表示当前这个驱动程序可以去进行驱动的那些设备。一个驱动程序可以支持一个或多个设备，而一个设备则只会绑定给一个驱动程序。
        对于device与device_driver之间建立联系的方式，主要有两种方式。第一种，在计算机启动的时候，总线开始扫描连接在其上的设备，为每个设备建立一个struct device变量并链接到该总线的devices链上，然后开始初始化不同的驱动程序，驱动程序到它所在的总线的devices链上去遍历每一个还没有被绑定给某个驱动的设备，然后再查看是否能够支持这种设备，如果它能够支持这种设备，则将这个设备与这个驱动联系起来。即，将这个设备的device变量加到驱动的devices链上，同时让struct device中的device_driver指向当前这个驱动。第二种则是热插拔。也即是在系统运行时插入了设备，此时内核会去查找在该bus链上注册了的device_driver，然后再将设备与驱动联系起来。设备与驱动根据什么规则联系起来，它们是如何被联系起来的代码我们将在后面的章节进行详细的描述。
1.3 PCI总线
        PCI是一种在CPU与I/O设备之间进行高速数据传输的一种总线。有很多设备都是使用PCI总线的，网卡就是其中之一。我们在前面讲了那些总线、设备与驱动方面的知识，原因就在于网卡是连接到PCI总线上，所以PCI总线、网卡设备以及网卡驱动就成了我们研究网卡的一个很重要的线索，尤其是在网络的链路层部分。下图显示了在一个系统中PCI设备的一个框图：

        PCI子系统声明了一个bus_type结构，为pci_bus_type。它就是PCI总线的描述符。在这个变量上，链接了PCI设备以及支持PCI设备的驱动程序。
1.4 PCI设备与驱动
        PCI设备通常由一组参数唯一地标识，它们被vendorID，deviceID和class nodes所标识，即设备厂商，型号等，这些参数保存在pci_device_id结构中。每个PCI设备都会被分配一个pci_dev变量，内核就用这个数据结构来表示一个PCI设备。
        所有的PCI驱动程序都必须定义一个pci_driver结构变量，在该变量中包含了这个PCI驱动程序所提供的不同功能的函数，同时，在这个结构中也包含了一个device_driver结构，这个结构定义了PCI子系统与PCI设备之间的接口。在注册PCI驱动程序时，这个结构将被初始化，同时这个pci_driver变量会被链接到pci_bus_type中的驱动链上去。
        在pci_driver中有一个成员struct pci_device_id *id_table，它列出了这个设备驱动程序所能够处理的所有PCI设备的ID值。
1.5 PCI设备与驱动的绑定过程
        下面描述一下对于PCI设备与驱动绑定的过程。首先在系统启动的时候，PCI总线会去扫描连接到这个总线上的设备，同时为每一个设备建立一个pci_dev结构，在这个结构中有一个device成员，并将这些pci_dev结构链接到PCI总线描述符上的devices链。如下图所示：

        第二步是当PCI驱动被加载时，pci_driver结构体将被初始化，这一过程在函数pci_register_driver中：
        drv->driver.bus = &pci_bus_type;
        drv->driver.probe = pci_device_probe;
        最后会调用driver_register(&drv->driver)将这个PCI驱动挂载到总线描述符的驱动链上。同时在注册的过程中，会根据pci_driver中的id_table中的ID值去查看该驱动支持哪些设备，将这些设备挂载到pci_driver中的devices链中来。如下图所示：

        对于不同的设备，可能驱动程序也不一样，因此，对于上图中的Dev3，可能就需要另外一个驱动程序来对其进行驱动。所以当加载了Dev3的驱动程序时，其示意图如下图所示：

        上面这三个示意图就描述了总线、设备以及驱动在系统中是如何进行相互联系的。前面对于驱动注册这些函数的描述较为简单，因为网卡是一个PCI设备，因此在后面具体地讲到网卡注册时再来详细地讲解和PCI相关的注册等函数。
1.6 小结
        本部分主要讲解了总线、设备以及驱动方面的一些知识，由于网卡是一个PCI设备，因此具体地讲到了一点PCI总线、PCI设备及相应的PCI驱动方面的知识，但是由于PCI本身就是很大的一个子系统，因此这里不可能对其进行详细地讲解，在后面对网卡的分析中，将对网卡中涉及到的和PCI相关的部分进行讲解。

2. 网卡在PCI层的注册
2.1 数据结构
        前面第一章讲了总线、设备以及驱动方面的关系，也讲到了大多数网卡设备实际上是一个PCI设备。因此，本章就讲解网卡设备在注册时是如何注册到PCI总线上去的。在这里，以Intel的E100网卡驱动进行讲解。
        前面讲到每个PCI设备都由一组参数唯一地标识，这些参数保存在结构体pci_device_id中，如下所示：

1. struct pci_device_id {
2.         __u32 vendor, device;                /* Vendor and device ID or PCI_ANY_ID*/
3.         __u32 subvendor, subdevice;        /* Subsystem ID's or PCI_ANY_ID */
4.         __u32 class, class_mask;        /* (class,subclass,prog-if) triplet */
5.         kernel_ulong_t driver_data;        /* Data private to the driver */
6. };

        每个PCI设备驱动都有一个pci_driver变量，它描述了一个PCI驱动的信息，如下所示：

1. struct pci_driver {
2.         struct list_head node;
3.         char *name;
4.         const struct pci_device_id *id_table;        /* must be non-NULL for probe to be called */
5.         int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);        /* New device inserted */
6.         void (*remove) (struct pci_dev *dev);        /* Device removed (NULL if not a hot-plug capable driver) */
7.         int  (*suspend) (struct pci_dev *dev, pm_message_t state);        /* Device suspended */
8.         int  (*suspend_late) (struct pci_dev *dev, pm_message_t state);
9.         int  (*resume_early) (struct pci_dev *dev);
10.         int  (*resume) (struct pci_dev *dev);                        /* Device woken up */
11.         int  (*enable_wake) (struct pci_dev *dev, pci_power_t state, int enable);   /* Enable wake event */
12.         void (*shutdown) (struct pci_dev *dev);
14.         struct pci_error_handlers *err_handler;
15.         struct device_driver        driver;
16.         struct pci_dynids dynids;
18.         int multithread_probe;
19. };

        每个PCI驱动中都有一个id_table成员变量，记录了当前这个驱动所能够进行驱动的那些设备的ID值。
        对于E100网卡驱动来说，它的pci_driver变量定义为：

1. static struct pci_driver e100_driver = {
2.         .name =         DRV_NAME,
3.         .id_table =     e100_id_table,
4.         .probe =        e100_probe,
5.         .remove =       __devexit_p(e100_remove),
6. #ifdef CONFIG_PM
7.         /* Power Management hooks */
8.         .suspend =      e100_suspend,
9.         .resume =       e100_resume,
10. #endif
11.         .shutdown =     e100_shutdown,
12.         .err_handler = &e100_err_handler,
13. };

        里面e100_id_table就表示该E100驱动所能够支持的PCI设备的ID号，其定义为：

1. #define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {/
2.         PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, /
3.         PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }
4. static struct pci_device_id e100_id_table[] = {
5.         INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),
6.         INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),
7.         …
8.         { 0, }
9. };

        当PCI层检测到一个PCI设备能够被某PCI驱动所支持时（这是通过函数pci_match_one_device来进行检测的），就会调用这个PCI驱动上的probe函数，在该函数中会对该特定的PCI设备进行一些具体的初始化等操作。比如对于E100设备驱动来说，其probe函数为e100_probe。在这个函数中，会对网卡设备进行初始化。
        e100_probe主要就涉及到网卡设备net_device的初始化，我们现在先来关注一下从网卡注册一直到调用e100_probe这一个过程的整个流程。
2.2 E100初始化
        E100驱动程序的初始化是在函数e100_init_module()中的，如下：

1. static int __init e100_init_module(void)
2. {
3.         if(((1 << debug) - 1) & NETIF_MSG_DRV) {
4.                 printk(KERN_INFO PFX "%s, %s/n", DRV_DESCRIPTION, DRV_VERSION);
5.                 printk(KERN_INFO PFX "%s/n", DRV_COPYRIGHT);
6.         }
7.         return pci_register_driver(&e100_driver);
8. }

        在这个函数中，调用了pci_register_driver()函数，对e100_driver这个驱动进行注册。
2.3 PCI注册
        在前面我们已经看到，PCI的注册就是将PCI驱动程序挂载到其所在的总线的drivers链，同时扫描PCI设备，将它能够进行驱动的设备挂载到driver上的devices链表上来，这里，我们将详细地查看这整个流程的函数调用关系。
        pci_register_driver()->__pci_register_driver()  //注意：这可是2个不同的函数

1. /**
2. * __pci_register_driver - register a new pci driver
3. * @drv: the driver structure to register
4. * @owner: owner module of drv
5. * @mod_name: module name string
6. *
7. * Adds the driver structure to the list of registered drivers.
8. * Returns a negative value on error, otherwise 0.
9. * If no error occurred, the driver remains registered even if
10. * no device was claimed during registration.
11. */       
12. int __pci_register_driver(struct pci_driver *drv, struct module *owner, const char *mod_name);
13.         //在函数中有几个初始化语句：
14.         drv->driver.name = drv->name;
15.         drv->driver.bus = &pci_bus_type;
16.         drv->driver.owner = owner;
17.         drv->driver.mod_name = mod_name;

        即是将PCI设备中的driver变量的总线指向pci_bus_type这个总线描述符，同时设置驱动的名字等。
        pci_bus_type定义如下：

1. struct bus_type pci_bus_type = {
2.         .name                = "pci",
3.         .match                = pci_bus_match,
4.         .uevent                = pci_uevent,
5.         .probe                = pci_device_probe,
6.         .remove                = pci_device_remove,
7.         .suspend        = pci_device_suspend,
8.         .suspend_late        = pci_device_suspend_late,
9.         .resume_early        = pci_device_resume_early,
10.         .resume                = pci_device_resume,
11.         .shutdown        = pci_device_shutdown,
12.         .dev_attrs        = pci_dev_attrs,
13. };

        然后再调用函数driver_register(&drv->driver);通过这个函数将这个PCI驱动中的struct device_driver driver成员变量注册到系统中去。
        pci_register_driver()->__pci_register_driver()->driver_register()
        driver_register()代码如下：

1. /**
2. *        driver_register - register driver with bus
3. *        @drv:        driver to register
4. *
5. *        We pass off most of the work to the bus_add_driver() call,
6. *        since most of the things we have to do deal with the bus
7. *        structures.
8. *
9. *        The one interesting aspect is that we setup @drv->unloaded
10. *        as a completion that gets complete when the driver reference
11. *        count reaches 0.
12. */
13. int driver_register(struct device_driver * drv)
14. {
15.         if ((drv->bus->probe && drv->probe) ||
16.             (drv->bus->remove && drv->remove) ||
17.             (drv->bus->shutdown && drv->shutdown)) {
18.                 printk(KERN_WARNING "Driver '%s' needs updating - please use bus_type methods/n", drv->name);
19.         }
20.         klist_init(&drv->klist_devices, NULL, NULL);
21.         init_completion(&drv->unloaded);
22.         return bus_add_driver(drv);
23. }

        klist_init()是为设备驱动的klist_devices成员进行初始化，这个klist_devices是一个对链表进行操作的包裹结构，它会链接这个驱动能够支持的那些设备。
        最后就调用bus_add_driver()函数。这个函数的功能就是将这个驱动加到其所在的总线的驱动链上。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()
        在bus_add_driver()函数中，最重要的是调用driver_attach()函数，其定义如下：

1. /**
2. *        driver_attach - try to bind driver to devices.
3. *        @drv:        driver.
4. *
5. *        Walk the list of devices that the bus has on it and try to
6. *        match the driver with each one.  If driver_probe_device()
7. *        returns 0 and the @dev->driver is set, we've found a
8. *        compatible pair.
9. */
10. int driver_attach(struct device_driver * drv)
11. {
12.         return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
13. }

        该函数遍历这个驱动所在的总线上的所有设备，然后将这些设备与当前驱动进行匹配，以检测这个驱动是否能够支持某个设备，也即是将设备与驱动联系起来。
        bus_for_each_dev函数是扫描在drv->bus这个总线上的所有设备，然后将每个设备以及当前驱动这两个指针传递给__driver_attach函数。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()
        __driver_attach()函数是将驱动与设备联系起来的函数。

1. static int __driver_attach(struct device * dev, void * data)
2. {
3.         struct device_driver * drv = data;
5.         /*
6.          * Lock device and try to bind to it. We drop the error
7.          * here and always return 0, because we need to keep trying
8.          * to bind to devices and some drivers will return an error
9.          * simply if it didn't support the device.
10.          *
11.          * driver_probe_device() will spit a warning if there
12.          * is an error.
13.          */
15.         if (dev->parent)        /* Needed for USB */
16.                 down(&dev->parent->sem);
17.         down(&dev->sem);
18.         if (!dev->driver)
19.                 driver_probe_device(drv, dev);
20.         up(&dev->sem);
21.         if (dev->parent)
22.                 up(&dev->parent->sem);
24.         return 0;
25. }

        在函数中有两条语句：

1.         if (!dev->driver)
2.                 driver_probe_device(drv, dev);

        也即是判断当前设备是否已经注册了一个驱动，如果没有注册驱动，则调用driver_probe_device()函数。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()
        如下：

1. /**
2. * driver_probe_device - attempt to bind device & driver together
3. * @drv: driver to bind a device to
4. * @dev: device to try to bind to the driver
5. *
6. * First, we call the bus's match function, if one present, which should
7. * compare the device IDs the driver supports with the device IDs of the
8. * device. Note we don't do this ourselves because we don't know the
9. * format of the ID structures, nor what is to be considered a match and
10. * what is not.
11. *
12. * This function returns 1 if a match is found, an error if one occurs
13. * (that is not -ENODEV or -ENXIO), and 0 otherwise.
14. *
15. * This function must be called with @dev->sem held.  When called for a
16. * USB interface, @dev->parent->sem must be held as well.
17. */
18. int driver_probe_device(struct device_driver * drv, struct device * dev)
19. {
20.         struct stupid_thread_structure *data;
21.         struct task_struct *probe_task;
22.         int ret = 0;
24.         if (!device_is_registered(dev))
25.                 return -ENODEV;
26.         if (drv->bus->match && !drv->bus->match(dev, drv))
27.                 goto done;
29.         pr_debug("%s: Matched Device %s with Driver %s/n",
30.                  drv->bus->name, dev->bus_id, drv->name);
32.         data = kmalloc(sizeof(*data), GFP_KERNEL);
33.         if (!data)
34.                 return -ENOMEM;
35.         data->drv = drv;
36.         data->dev = dev;
38.         if (drv->multithread_probe) {
39.                 probe_task = kthread_run(really_probe, data,
40.                                          "probe-%s", dev->bus_id);
41.                 if (IS_ERR(probe_task))
42.                         ret = really_probe(data);
43.         } else
44.                 ret = really_probe(data);
46. done:
47.         return ret;
48. }       

        该函数首先会调用总线上的match函数，以判断当前的PCI驱动能否支持该PCI设备，如果可以，则继续往后面执行。
        drv->bus->match函数也即是pci_bus_type中的match成员变量，它为pci_bus_match函数。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->pci_bus_match()

1. /**
2. * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
3. * @dev: the PCI device structure to match against
4. * @drv: the device driver to search for matching PCI device id structures
5. *
6. * Used by a driver to check whether a PCI device present in the
7. * system is in its list of supported devices. Returns the matching
8. * pci_device_id structure or %NULL if there is no match.
9. */
10. static int pci_bus_match(struct device *dev, struct device_driver *drv)
11. {
12.         struct pci_dev *pci_dev = to_pci_dev(dev);
13.         struct pci_driver *pci_drv = to_pci_driver(drv);
14.         const struct pci_device_id *found_id;
16.         found_id = pci_match_device(pci_drv, pci_dev);
17.         if (found_id)
18.                 return 1;
20.         return 0;
21. }

        pci_bus_match函数的作用就是将PCI设备与PCI驱动进行比较以检查该驱动是否能够支持这个设备。在函数的最前面是两个宏to_pci_dev和to_pci_driver。因为在函数执行的过程中，虽然最开始传进来的是pci_driver结构与pci_dev结构，但是在执行的时候却取了这两个结构体中的device_driver和device成员变量，所以现在就要通过这两个成员变量找到之前对应的pci_driver和pci_dev结构的地址。
#define        to_pci_dev(n) container_of(n, struct pci_dev, dev)
#define        to_pci_driver(drv) container_of(drv,struct pci_driver, driver)
        这两个宏在<Linux Device Driver> 3rd书上有相应的讲解，这里也就是找到E100的pci_driver：e100_driver以及该网卡设备的pci_dev结构。现在就要对它们进行比较以看它们之间是否能够联系起来。这是通过函数pci_match_device实现的。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->pci_bus_match()->pci_match_device()

1. /**
2. * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
3. * @drv: the PCI driver to match against
4. * @dev: the PCI device structure to match against
5. *
6. * Used by a driver to check whether a PCI device present in the
7. * system is in its list of supported devices.  Returns the matching
8. * pci_device_id structure or %NULL if there is no match.
9. */
10. const struct pci_device_id *pci_match_device(struct pci_driver *drv,
11.                                              struct pci_dev *dev)
12. {
13.         struct pci_dynid *dynid;
15.         /* Look at the dynamic ids first, before the static ones */
16.         spin_lock(&drv->dynids.lock);
17.         list_for_each_entry(dynid, &drv->dynids.list, node) {
18.                 if (pci_match_one_device(&dynid->id, dev)) {
19.                         spin_unlock(&drv->dynids.lock);
20.                         return &dynid->id;
21.                 }
22.         }
23.         spin_unlock(&drv->dynids.lock);
25.         return pci_match_id(drv->id_table, dev);
26. }

        pci_match_one_driver函数的作用是将一个PCI设备与PCI驱动进行比较，以查看它们是否相匹配。如果相匹配，则返回匹配的pci_device_id结构体指针。
        此时，如果该PCI驱动已经找到了一个可以想符的PCI设备，则返回，然后再退回到之前的driver_probe_device函数中。在该函数最后将调用really_probe函数。将device_driver与device结构体指针作为参数传递到这个函数中。下面几行是调用驱动或者总线的probe函数来扫描设备。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->really_probe()
        在函数really_probe()中：

1.         if (dev->bus->probe) {
2.                 ret = dev->bus->probe(dev);
3.                 if (ret)
4.                         goto probe_failed;
5.         } else if (drv->probe) {
6.                 ret = drv->probe(dev);
7.                 if (ret)
8.                         goto probe_failed;
9.         }

        此时的dev->bus为pci_bus_type，其probe函数则对应为：pci_device_probe。
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->really_probe()->pci_device_probe()
        同样，在该函数中会获得当前的PCI设备的pci_dev结构体指针以及PCI驱动程序的pci_driver结构体指针。分别使用宏to_pci_dev和to_pci_driver。最后则调用函数__pci_device_probe。在该函数中还会调用函数pci_call_probe，这是最后的函数
        pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->really_probe()->pci_device_probe()->__pci_device_probe()->pci_call_probe()
        在函数pci_call_probe里有一条语句：

1. static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
2.                           const struct pci_device_id *id)
3. {
4.         int error;
5. /*  省略  */
6.         error = drv->probe(dev, id);

        在此处就调用了pci_driver的probe函数，对于这里的E100驱动来说，它的probe函数是最开始注册的e100_probe函数，在该函数中会完成对网卡设备net_device的初始化等操作。

1.         pci_register_driver()->__pci_register_driver()->driver_register()->bus_add_driver()->driver_attach()->__driver_attach()->driver_probe_device()->really_probe()->pci_device_probe()->__pci_device_probe()->pci_call_probe()->e100_probe()

        到这里，我们对网卡驱动的PCI层的初始化分析就告一个段落了，剩下的部分就是网卡驱动对网卡设备本身的初始化等操作。

2.4 函数调用流程图
        在这里，为网卡在PCI层的注册画了一个函数调用的流程图，能够更直观地展现网卡从注册到调用其自身的网卡初始化的这一个函数调用过程。

文笔实在不行，写了一个下午加晚上，才写这么点。希望能够对初学者有一点用吧。因为我最开始在看网卡驱动的时候，就是迷惑加载了网卡之后是如何调用到该网卡的probe函数的。所以就仔细地看了一下里面的源码。

这里主要还是起一个梳理的作用，很多代码也没有进一步地深入分析。不过对于网络架构来说，首先将整个调用的流程掌握了，对后面的理解也就更加方便了。