ethtool的内核流程跟踪

最新推荐文章于 2024-07-12 15:58:29 发布

李迟

最新推荐文章于 2024-07-12 15:58:29 发布

阅读量6.1k

点赞数 2

分类专栏： GNU/Linux 网络 Linux内核(驱动)移植及研究 Linux网络

本文链接：https://blog.csdn.net/subfate/article/details/44746001

版权

GNU/Linux 同时被 3 个专栏收录

110 篇文章 21 订阅

订阅专栏

Linux内核(驱动)移植及研究

36 篇文章 13 订阅

订阅专栏

网络

22 篇文章 6 订阅

订阅专栏

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

前面的文章讲了ethtool工具的源码分析，内核集成了ethtool命令的控制，所以用户空间才能如此方便地查询、设置以太网卡。本文主要讲一下内核空间ethtool的跟踪。

整体来讲，这个过程大约是这样的：

ethtool可以认为是一种框架，内核已经集成了，它担负着用户空间和具体网络设备驱动之间的交互，包括查询、设置网卡信息。

主要结构体在函数在include/linux/ethtool.h中定义。

控制命令结构体如下：

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];
};

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

另一个重要的网络操作函数集结构体定义如下：

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中的函数指针的。

常用的共用函数：

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，就有很多驱动在使用。当然至于使用哪些，由网络驱动来决定。

下面是常见的控制命令和宏定义：

//支持的命令：
/* 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，在该函数中根据不同的命令调用不同的函数。函数如下：

/* 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：

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：

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。所有的命令控制过程大多是如此。

设置网卡信息：

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导出，以便其它模块也可以使用，如获取当前连接状态的函数：

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定义如下：

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也就可以使用了。

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定义：

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探测函数中进行赋值：

	
/*
 * 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日着手写

李迟

关注

2
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
ethtool的内核流程跟踪

这些天开始下决心写写Linux网络方面的文章。由于能力和时间有限，当前还没有对Linux的网络有深入的了解。我一开始打算从网卡基本知识到PHY寄存器，到MAC控制器，到以太网协议栈，一步一步地学习。但实际中发现不能如此，在公司不同在学校，不可能有集中的时间精力去学习的，比如，刚刚使用了iperf来测试网卡性能，又要在内核中打印出PHY芯片寄存器，而前提是要对PHY有一定了解。同时又要了解设备所处的网络拓扑，又不得不去看看交换机方面的资料。在这种情形下，似乎没有规律地做事，完全由工作需求来驱动。在做事的同时我
复制链接

扫一扫

专栏目录