ethtool的内核流程跟踪

嵌入式Linux 3k 字 次

这些天开始下决心写写Linux网络方面的文章。由于能力和时间有限，当前还没有对Linux的网络有深入的了解。我一开始打算从网卡基本知识到PHY寄存器，到MAC控制器，到以太网协议栈，一步一步地学习。但实际中发现不能如此，在公司不同在学校，不可能有集中的时间精力去学习的，比如，刚刚使用了iperf来测试网卡性能，又要在内核中打印出PHY芯片寄存器，而前提是要对PHY有一定了解。同时又要了解设备所处的网络拓扑，又不得不去看看交换机方面的资料。在这种情形下，似乎没有规律地做事，完全由工作需求来驱动。在做事的同时我也在记录要点，希望可以整理出主线。在业余时便将这些要点发散、整理。因此，在写文章时就已经对自己进行定位，从感性的认识上入手，慢慢去学习，去接触。比如，因工作上的需要学习了ethtool，于是以此为切入点，看看内核关于ethtool到底是怎么控制的。再比如从网卡使能到禁止跟踪相关的内核流程。

前面的文章讲了ethtool工具的源码分析，内核集成了ethtool命令的控制，所以用户空间才能如此方便地查询、设置以太网卡。本文主要讲一下内核空间ethtool的跟踪。
ethtool可以认为是一种框架，内核已经集成了，它担负着用户空间和具体网络设备驱动之间的交互，包括查询、设置网卡信息。
主要结构体在函数在include/linux/ethtool.h中定义。
控制命令结构体如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
struct ethtool_cmd {
     __u32     cmd;
     __u32     supported;     /* Features this interface supports */
     __u32     advertising;     /* Features this interface advertises */
     __u16     speed;          /* The forced speed, 10Mb, 100Mb, gigabit */
     __u8     duplex;          /* Duplex, half or full */
     __u8     port;          /* Which connector port */
     __u8     phy_address;
     __u8     transceiver;     /* Which transceiver to use */
     __u8     autoneg;     /* Enable or disable autonegotiation */
     __u8     mdio_support;
     __u32     maxtxpkt;     /* Tx pkts before generating tx int */
     __u32     maxrxpkt;     /* Rx pkts before generating rx int */
     __u16     speed_hi;
     __u8     eth_tp_mdix;
     __u8     reserved2;
     __u32     lp_advertising;     /* Features the link partner advertises */
     __u32     reserved[2];
};

当查询网卡信息时这个结构体保存着查询到的信息，比如网速、双工，是否自动协商，等。当设置网卡时，里面的字段就是用户指定的信息。这个结构体负责着信息传递的作用。
另一个重要的网络操作函数集结构体定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

struct ethtool_ops {
     int     (*get_settings)(struct net_device *, struct ethtool_cmd *);
     int     (*set_settings)(struct net_device *, struct ethtool_cmd *);
     void     (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *);
     int     (*get_regs_len)(struct net_device *);
     void     (*get_regs)(struct net_device *, struct ethtool_regs *, void *);
     void     (*get_wol)(struct net_device *, struct ethtool_wolinfo *);
     int     (*set_wol)(struct net_device *, struct ethtool_wolinfo *);
     u32     (*get_msglevel)(struct net_device *);
     void     (*set_msglevel)(struct net_device *, u32);
     int     (*nway_reset)(struct net_device *);
     u32     (*get_link)(struct net_device *);
     int     (*get_eeprom_len)(struct net_device *);
     int     (*get_eeprom)(struct net_device *,
                     struct ethtool_eeprom *, u8 *);
     int     (*set_eeprom)(struct net_device *,
                     struct ethtool_eeprom *, u8 *);
     int     (*get_coalesce)(struct net_device *, struct ethtool_coalesce *);
     int     (*set_coalesce)(struct net_device *, struct ethtool_coalesce *);
     void     (*get_ringparam)(struct net_device *,
                    struct ethtool_ringparam *);
     int     (*set_ringparam)(struct net_device *,
                    struct ethtool_ringparam *);
     void     (*get_pauseparam)(struct net_device *,
                      struct ethtool_pauseparam*);
     int     (*set_pauseparam)(struct net_device *,
                      struct ethtool_pauseparam*);
     u32     (*get_rx_csum)(struct net_device *);
     int     (*set_rx_csum)(struct net_device *, u32);
     u32     (*get_tx_csum)(struct net_device *);
     int     (*set_tx_csum)(struct net_device *, u32);
     u32     (*get_sg)(struct net_device *);
     int     (*set_sg)(struct net_device *, u32);
     u32     (*get_tso)(struct net_device *);
     int     (*set_tso)(struct net_device *, u32);
     void     (*self_test)(struct net_device *, struct ethtool_test *, u64 *);
     void     (*get_strings)(struct net_device *, u32 stringset, u8 *);
     int     (*phys_id)(struct net_device *, u32);
     void     (*get_ethtool_stats)(struct net_device *,
                         struct ethtool_stats *, u64 *);
     int     (*begin)(struct net_device *);
     void     (*complete)(struct net_device *);
     u32     (*get_ufo)(struct net_device *);
     int     (*set_ufo)(struct net_device *, u32);
     u32     (*get_flags)(struct net_device *);
     int     (*set_flags)(struct net_device *, u32);
     u32     (*get_priv_flags)(struct net_device *);
     int     (*set_priv_flags)(struct net_device *, u32);
     int     (*get_sset_count)(struct net_device *, int);
     int     (*get_rxnfc)(struct net_device *,
                    struct ethtool_rxnfc *, void *);
     int     (*set_rxnfc)(struct net_device *, struct ethtool_rxnfc *);
     int     (*flash_device)(struct net_device *, struct ethtool_flash *);
     int     (*reset)(struct net_device *, u32 *);
     int     (*set_rx_ntuple)(struct net_device *,
                    struct ethtool_rx_ntuple *);
     int     (*get_rx_ntuple)(struct net_device *, u32 stringset, void *);
     int     (*get_rxfh_indir)(struct net_device *,
                      struct ethtool_rxfh_indir *);
     int     (*set_rxfh_indir)(struct net_device *,
                      const struct ethtool_rxfh_indir *);
};

里面的函数指针由具体的网络驱动程序来赋值。在下面将要分析到的函数，我们可以看到实际上就是调用ethtool_ops中的函数指针的。
常用的共用函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
u32 ethtool_op_get_link(struct net_device *dev);
u32 ethtool_op_get_rx_csum(struct net_device *dev);
u32 ethtool_op_get_tx_csum(struct net_device *dev);
int ethtool_op_set_tx_csum(struct net_device *dev, u32 data);
int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data);
int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data);
u32 ethtool_op_get_sg(struct net_device *dev);
int ethtool_op_set_sg(struct net_device *dev, u32 data);
u32 ethtool_op_get_tso(struct net_device *dev);
int ethtool_op_set_tso(struct net_device *dev, u32 data);
u32 ethtool_op_get_ufo(struct net_device *dev);
int ethtool_op_set_ufo(struct net_device *dev, u32 data);
u32 ethtool_op_get_flags(struct net_device *dev);
int ethtool_op_set_flags(struct net_device *dev, u32 data, u32 supported);
void ethtool_ntuple_flush(struct net_device *dev);

这些函数可以由具体的驱动程序来使用，比如获取当前连接状态的ethtool_op_get_link，就有很多驱动在使用。当然至于使用哪些，由网络驱动来决定。
下面是常见的控制命令和宏定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
//支持的命令：
/* CMDs currently supported */
#define ETHTOOL_GSET          0x00000001 /* Get settings. */
#define ETHTOOL_SSET          0x00000002 /* Set settings. */
#define ETHTOOL_GDRVINFO     0x00000003 /* Get driver info. */
#define ETHTOOL_GREGS          0x00000004 /* Get NIC registers. */
#define ETHTOOL_GWOL          0x00000005 /* Get wake-on-lan options. */
#define ETHTOOL_SWOL          0x00000006 /* Set wake-on-lan options. */
#define ETHTOOL_GMSGLVL          0x00000007 /* Get driver message level */
#define ETHTOOL_SMSGLVL          0x00000008 /* Set driver msg level. */
#define ETHTOOL_NWAY_RST     0x00000009 /* Restart autonegotiation. */
#define ETHTOOL_GLINK          0x0000000a /* Get link status (ethtool_value) */
#define ETHTOOL_GEEPROM          0x0000000b /* Get EEPROM data */
#define ETHTOOL_SEEPROM          0x0000000c /* Set EEPROM data. */
#define ETHTOOL_GCOALESCE     0x0000000e /* Get coalesce config */
#define ETHTOOL_SCOALESCE     0x0000000f /* Set coalesce config. */
#define ETHTOOL_GRINGPARAM     0x00000010 /* Get ring parameters */
#define ETHTOOL_SRINGPARAM     0x00000011 /* Set ring parameters. */
#define ETHTOOL_GPAUSEPARAM     0x00000012 /* Get pause parameters */
#define ETHTOOL_SPAUSEPARAM     0x00000013 /* Set pause parameters. */
#define ETHTOOL_GRXCSUM          0x00000014 /* Get RX hw csum enable (ethtool_value) */
#define ETHTOOL_SRXCSUM          0x00000015 /* Set RX hw csum enable (ethtool_value) */
#define ETHTOOL_GTXCSUM          0x00000016 /* Get TX hw csum enable (ethtool_value) */
#define ETHTOOL_STXCSUM          0x00000017 /* Set TX hw csum enable (ethtool_value) */
 
//网卡特性
//设备支持的特性：
/* Indicates what features are supported by the interface. */
#define SUPPORTED_10baseT_Half          (1 << 0)
#define SUPPORTED_10baseT_Full          (1 << 1)
#define SUPPORTED_100baseT_Half          (1 << 2)
#define SUPPORTED_100baseT_Full          (1 << 3)
#define SUPPORTED_1000baseT_Half     (1 << 4)
#define SUPPORTED_1000baseT_Full     (1 << 5)
#define SUPPORTED_Autoneg          (1 << 6)
#define SUPPORTED_TP               (1 << 7)
#define SUPPORTED_AUI               (1 << 8)
#define SUPPORTED_MII               (1 << 9)
#define SUPPORTED_FIBRE               (1 << 10)
#define SUPPORTED_BNC               (1 << 11)
#define SUPPORTED_10000baseT_Full     (1 << 12)
#define SUPPORTED_Pause               (1 << 13)
#define SUPPORTED_Asym_Pause          (1 << 14)
#define SUPPORTED_2500baseX_Full     (1 << 15)
#define SUPPORTED_Backplane          (1 << 16)
#define SUPPORTED_1000baseKX_Full     (1 << 17)
#define SUPPORTED_10000baseKX4_Full     (1 << 18)
#define SUPPORTED_10000baseKR_Full     (1 << 19)
#define SUPPORTED_10000baseR_FEC     (1 << 20)
 
//设备宣称所支持的特性(此处待继续学习)
/* Indicates what features are advertised by the interface. */
#define ADVERTISED_10baseT_Half          (1 << 0)
#define ADVERTISED_10baseT_Full          (1 << 1)
#define ADVERTISED_100baseT_Half     (1 << 2)
#define ADVERTISED_100baseT_Full     (1 << 3)
#define ADVERTISED_1000baseT_Half     (1 << 4)
#define ADVERTISED_1000baseT_Full     (1 << 5)
#define ADVERTISED_Autoneg          (1 << 6)
#define ADVERTISED_TP               (1 << 7)
#define ADVERTISED_AUI               (1 << 8)
#define ADVERTISED_MII               (1 << 9)
#define ADVERTISED_FIBRE          (1 << 10)
#define ADVERTISED_BNC               (1 << 11)
#define ADVERTISED_10000baseT_Full     (1 << 12)
#define ADVERTISED_Pause          (1 << 13)
#define ADVERTISED_Asym_Pause          (1 << 14)
#define ADVERTISED_2500baseX_Full     (1 << 15)
#define ADVERTISED_Backplane          (1 << 16)
#define ADVERTISED_1000baseKX_Full     (1 << 17)
#define ADVERTISED_10000baseKX4_Full     (1 << 18)
#define ADVERTISED_10000baseKR_Full     (1 << 19)
#define ADVERTISED_10000baseR_FEC     (1 << 20)
 
// 速度
/* The forced speed, 10Mb, 100Mb, gigabit, 2.5Gb, 10GbE. */
#define SPEED_10          10
#define SPEED_100          100
#define SPEED_1000          1000
#define SPEED_2500          2500
#define SPEED_10000          10000
 
// 双工
/* Duplex, half or full. */
#define DUPLEX_HALF          0x00
#define DUPLEX_FULL          0x01
 
// 端口类型
/* Which connector port. */
#define PORT_TP               0x00 //双绞线
#define PORT_AUI          0x01
#define PORT_MII          0x02
#define PORT_FIBRE          0x03
#define PORT_BNC          0x04
#define PORT_DA               0x05
#define PORT_NONE          0xef
#define PORT_OTHER          0xff
 
// 自动协商
/* Enable or disable autonegotiation.  If this is set to enable,
* the forced link modes above are completely ignored.
*/
#define AUTONEG_DISABLE          0x00
#define AUTONEG_ENABLE          0x01

ethtool的关键函数为dev_ethtool，在该函数中根据不同的命令调用不同的函数。函数如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
/* The main entry point in this file.  Called from net/core/dev.c */
 
int dev_ethtool(struct net *net, struct ifreq *ifr)
{
    struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
    void __user *useraddr = ifr->ifr_data;
    u32 ethcmd;
    int rc;
    unsigned long old_features;
 
    if (!dev || !netif_device_present(dev))
        return -ENODEV;
 
    if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
        return -EFAULT;
 
    if (!dev->ethtool_ops) {
        /* ETHTOOL_GDRVINFO does not require any driver support.
         * It is also unprivileged and does not change anything,
         * so we can take a shortcut to it. */
        if (ethcmd == ETHTOOL_GDRVINFO)
            return ethtool_get_drvinfo(dev, useraddr);
        else
            return -EOPNOTSUPP;
    }
 
    /* Allow some commands to be done by anyone */
    switch (ethcmd) {
    case ETHTOOL_GSET:
    case ETHTOOL_GDRVINFO:
    case ETHTOOL_GMSGLVL:
    case ETHTOOL_GCOALESCE:
    case ETHTOOL_GRINGPARAM:
    case ETHTOOL_GPAUSEPARAM:
    case ETHTOOL_GRXCSUM:
    case ETHTOOL_GTXCSUM:
    case ETHTOOL_GSG:
    case ETHTOOL_GSTRINGS:
    case ETHTOOL_GTSO:
    case ETHTOOL_GPERMADDR:
    case ETHTOOL_GUFO:
    case ETHTOOL_GGSO:
    case ETHTOOL_GGRO:
    case ETHTOOL_GFLAGS:
    case ETHTOOL_GPFLAGS:
    case ETHTOOL_GRXFH:
    case ETHTOOL_GRXRINGS:
    case ETHTOOL_GRXCLSRLCNT:
    case ETHTOOL_GRXCLSRULE:
    case ETHTOOL_GRXCLSRLALL:
        break;
    default:
        if (!capable(CAP_NET_ADMIN))
            return -EPERM;
    }
 
    if (dev->ethtool_ops->begin) {
        rc = dev->ethtool_ops->begin(dev);
        if (rc  < 0)
            return rc;
    }
    old_features = dev->features;
 
    switch (ethcmd) {
    case ETHTOOL_GSET:
        rc = ethtool_get_settings(dev, useraddr);
        break;
    case ETHTOOL_SSET:
        rc = ethtool_set_settings(dev, useraddr);
        break;
    case ETHTOOL_GDRVINFO:
        rc = ethtool_get_drvinfo(dev, useraddr);
        break;
    case ETHTOOL_GREGS:
        rc = ethtool_get_regs(dev, useraddr);
        break;
    case ETHTOOL_GWOL:
        rc = ethtool_get_wol(dev, useraddr);
        break;
    case ETHTOOL_SWOL:
        rc = ethtool_set_wol(dev, useraddr);
        break;
    case ETHTOOL_GMSGLVL:
        rc = ethtool_get_value(dev, useraddr, ethcmd,
                       dev->ethtool_ops->get_msglevel);
        break;
    case ETHTOOL_SMSGLVL:
        rc = ethtool_set_value_void(dev, useraddr,
                       dev->ethtool_ops->set_msglevel);
        break;
    case ETHTOOL_NWAY_RST:
        rc = ethtool_nway_reset(dev);
        break;
    case ETHTOOL_GLINK:
        rc = ethtool_get_value(dev, useraddr, ethcmd,
                       dev->ethtool_ops->get_link);
        break;
    case ETHTOOL_GEEPROM:
        rc = ethtool_get_eeprom(dev, useraddr);
        break;
    case ETHTOOL_SEEPROM:
        rc = ethtool_set_eeprom(dev, useraddr);
        break;
    case ETHTOOL_GCOALESCE:
        rc = ethtool_get_coalesce(dev, useraddr);
        break;
    case ETHTOOL_SCOALESCE:
        rc = ethtool_set_coalesce(dev, useraddr);
        break;
    case ETHTOOL_GRINGPARAM:
        rc = ethtool_get_ringparam(dev, useraddr);
        break;
    case ETHTOOL_SRINGPARAM:
        rc = ethtool_set_ringparam(dev, useraddr);
        break;
    case ETHTOOL_GPAUSEPARAM:
        rc = ethtool_get_pauseparam(dev, useraddr);
        break;
    case ETHTOOL_SPAUSEPARAM:
        rc = ethtool_set_pauseparam(dev, useraddr);
        break;
    case ETHTOOL_GRXCSUM:
        rc = ethtool_get_value(dev, useraddr, ethcmd,
                       (dev->ethtool_ops->get_rx_csum ?
                    dev->ethtool_ops->get_rx_csum :
                    ethtool_op_get_rx_csum));
        break;
    case ETHTOOL_SRXCSUM:
        rc = ethtool_set_rx_csum(dev, useraddr);
        break;
    case ETHTOOL_GTXCSUM:
        rc = ethtool_get_value(dev, useraddr, ethcmd,
                       (dev->ethtool_ops->get_tx_csum ?
                    dev->ethtool_ops->get_tx_csum :
                    ethtool_op_get_tx_csum));
        break;
    case ETHTOOL_STXCSUM:
        rc = ethtool_set_tx_csum(dev, useraddr);
        break;
    case ETHTOOL_GSG:
        rc = ethtool_get_value(dev, useraddr, ethcmd,
                       (dev->ethtool_ops->get_sg ?
                    dev->ethtool_ops->get_sg :
                    ethtool_op_get_sg));
        break;
    case ETHTOOL_SSG:
        rc = ethtool_set_sg(dev, useraddr);
        break;
    case ETHTOOL_GTSO:
        rc = ethtool_get_value(dev, useraddr, ethcmd,
                       (dev->ethtool_ops->get_tso ?
                    dev->ethtool_ops->get_tso :
                    ethtool_op_get_tso));
        break;
    case ETHTOOL_STSO:
        rc = ethtool_set_tso(dev, useraddr);
        break;
    case ETHTOOL_TEST:
        rc = ethtool_self_test(dev, useraddr);
        break;
    case ETHTOOL_GSTRINGS:
        rc = ethtool_get_strings(dev, useraddr);
        break;
    case ETHTOOL_PHYS_ID:
        rc = ethtool_phys_id(dev, useraddr);
        break;
    default:
        rc = -EOPNOTSUPP;
    }
 
    if (dev->ethtool_ops->complete)
        dev->ethtool_ops->complete(dev);
 
    if (old_features != dev->features)
        netdev_features_change(dev);
 
    return rc;
}

dev_ethtool函数是被dev_ioctl函数(位于net/core/dev.c)调用的，dev_ioctl是网络设备的ioctl总入口函数，ethtool用到的SIOCETHTOOL命令，实际是其中的一个命令分支，而如ETHTOOL_GSET之类的命令，是dev_ethtool函数的中命令。这两类的命令层次是十分明显的。dev_ioctl：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
{
    /*
     *    See which interface the caller is talking about.
     */
 
    switch (cmd) {
 
    case SIOCETHTOOL:
        dev_load(net, ifr.ifr_name);
        rtnl_lock();
        ret = dev_ethtool(net, &ifr);
        rtnl_unlock();
        if (!ret) {
            if (colon)
                *colon = ':';
            if (copy_to_user(arg, &ifr,
                     sizeof(struct ifreq)))
                ret = -EFAULT;
        }
        return ret;
    }
}

获取网卡信息的控制命令为ETHTOOL_GSET，调用的函数为ethtool_get_settings：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
{
    struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
    int err;
 
    if (!dev->ethtool_ops->get_settings)
        return -EOPNOTSUPP;
 
    err = dev->ethtool_ops->get_settings(dev, &cmd);
    if (err < 0)
        return err;
 
    if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
        return -EFAULT;
    return 0;
}

而该函数实际调用的是ethtool_ops结构体中的get_settings。所有的命令控制过程大多是如此。
设置网卡信息：

1
2
3
4
5
6
7
8
9
10
11
12
static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
{
    struct ethtool_cmd cmd;
 
    if (!dev->ethtool_ops->set_settings)
        return -EOPNOTSUPP;
 
    if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
        return -EFAULT;
 
    return dev->ethtool_ops->set_settings(dev, &cmd);
}

常用的公共函数使用EXPORT_SYMBOL导出，以便其它模块也可以使用，如获取当前连接状态的函数：

1
2
3
4
5
u32 ethtool_op_get_link(struct net_device *dev)
{
    return netif_carrier_ok(dev) ? 1 : 0;
}
EXPORT_SYMBOL(ethtool_op_get_link);

以Intel网卡驱动igb为例看看如何使用ethtool_ops。igb驱动代码位于drivers/net/igb。与ethtool有关的代码在igb_ethtool.c文件。ethtool_ops定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
static const struct ethtool_ops igb_ethtool_ops = {
    .get_settings           = igb_get_settings,
    .set_settings           = igb_set_settings,
    .get_drvinfo            = igb_get_drvinfo,
    .get_regs_len           = igb_get_regs_len,
    .get_regs               = igb_get_regs,
    .get_wol                = igb_get_wol,
    .set_wol                = igb_set_wol,
    .get_msglevel           = igb_get_msglevel,
    .set_msglevel           = igb_set_msglevel,
    .nway_reset             = igb_nway_reset,
    .get_link               = igb_get_link,
    .get_eeprom_len         = igb_get_eeprom_len,
    .get_eeprom             = igb_get_eeprom,
    .set_eeprom             = igb_set_eeprom,
    .get_ringparam          = igb_get_ringparam,
    .set_ringparam          = igb_set_ringparam,
    .get_pauseparam         = igb_get_pauseparam,
    .set_pauseparam         = igb_set_pauseparam,
    .get_rx_csum            = igb_get_rx_csum,
    .set_rx_csum            = igb_set_rx_csum,
    .get_tx_csum            = igb_get_tx_csum,
    .set_tx_csum            = igb_set_tx_csum,
    .get_sg                 = ethtool_op_get_sg,
    .set_sg                 = ethtool_op_set_sg,
    .get_tso                = ethtool_op_get_tso,
    .set_tso                = igb_set_tso,
    .self_test              = igb_diag_test,
    .get_strings            = igb_get_strings,
    .phys_id                = igb_phys_id,
    .get_sset_count         = igb_get_sset_count,
    .get_ethtool_stats      = igb_get_ethtool_stats,
    .get_coalesce           = igb_get_coalesce,
    .set_coalesce           = igb_set_coalesce,
};

igb支持的函数(即ethtool工具可以使用的参数)很多。像get_sg，就直接使用了ethtool.c定义的ethtool_op_get_sg，其它大部分则自定义实现。igb_ethtool_ops在igb_set_ethtool_ops被调用，而igb_set_ethtool_ops则在igb的探测函数igb_probe中被调用，这样，当驱动运行时，ethtool也就可以使用了。

1
2
3
4
void igb_set_ethtool_ops(struct net_device *netdev)
{
    SET_ETHTOOL_OPS(netdev, &igb_ethtool_ops);
}

实际上就是将igb_ethtool_ops赋值给net_device结构体的ethtool_ops指针，从而使得ethtool.c中对应的函数指针可以被调用。比如dev->ethtool_ops->get_settings。 再看一下dm9000的使用，ethtool_ops定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static const struct ethtool_ops dm9000_ethtool_ops = {
    .get_drvinfo        = dm9000_get_drvinfo,
    .get_settings        = dm9000_get_settings,
    .set_settings        = dm9000_set_settings,
    .get_msglevel        = dm9000_get_msglevel,
    .set_msglevel        = dm9000_set_msglevel,
    .nway_reset        = dm9000_nway_reset,
    .get_link        = dm9000_get_link,
    .get_wol        = dm9000_get_wol,
    .set_wol        = dm9000_set_wol,
     .get_eeprom_len        = dm9000_get_eeprom_len,
     .get_eeprom        = dm9000_get_eeprom,
     .set_eeprom        = dm9000_set_eeprom,
    .get_rx_csum        = dm9000_get_rx_csum,
    .set_rx_csum        = dm9000_set_rx_csum,
    .get_tx_csum        = ethtool_op_get_tx_csum,
    .set_tx_csum        = dm9000_set_tx_csum,
};

从上述结构体赋值可以看到，igb驱动支持的命令要比dm9000多很多。
同样在dm9000探测函数中进行赋值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
    
/*
 * Search DM9000 board, allocate space and register it
 */
static int __devinit
dm9000_probe(struct platform_device *pdev)
{
    struct dm9000_plat_data *pdata = pdev->dev.platform_data;
    struct board_info *db;    /* Point a board information structure */
    struct net_device *ndev;
    const unsigned char *mac_src;
    int ret = 0;
    int iosize;
    int i;
    u32 id_val;
 
    /* Init network device */
    ndev = alloc_etherdev(sizeof(struct board_info));
    if (!ndev) {
        dev_err(&pdev->dev, "could not allocate device.\n");
        return -ENOMEM;
    }
 
    SET_NETDEV_DEV(ndev, &pdev->dev);
 
    dev_dbg(&pdev->dev, "dm9000_probe()\n");
 
    /* setup board info structure */
    db = netdev_priv(ndev);
 
    db->dev = &pdev->dev;
    db->ndev = ndev;
    // ...
    ndev->netdev_ops    = &dm9000_netdev_ops;
    ndev->watchdog_timeo    = msecs_to_jiffies(watchdog);
    ndev->ethtool_ops    = &dm9000_ethtool_ops;
    
    // ...
}

2015年3月29日 着手写