//net/core/dev.c
int dev_queue_xmit(struct sk_buff *skb)
{
	struct net_device *dev = skb->dev;
	struct netdev_queue *txq;
	struct Qdisc *q;
...
	txq = netdev_pick_tx(dev, skb);
	q = rcu_dereference(txq->qdisc);

	trace_net_dev_queue(skb);
	if (q->enqueue) { ///对于VLAN设备，没有qdisc队列，参考noqueue_qdisc
		rc = __dev_xmit_skb(skb, q, dev, txq);
		goto out;
	}

	/* The device has no queue. Common case for software devices:
	   loopback, all the sorts of tunnels...

	   Really, it is unlikely that netif_tx_lock protection is necessary
	   here.  (f.e. loopback and IP tunnels are clean ignoring statistics
	   counters.)
	   However, it is possible, that they rely on protection
	   made by us here.

	   Check this and shot the lock. It is not prone from deadlocks.
	   Either shot noqueue qdisc, it is even simpler 8)
	 */
	if (dev->flags & IFF_UP) {
		int cpu = smp_processor_id(); /* ok because BHs are off */

		if (txq->xmit_lock_owner != cpu) {

			HARD_TX_LOCK(dev, txq, cpu);

			if (!netif_tx_queue_stopped(txq)) {
				rc = NET_XMIT_SUCCESS;
				if (!dev_hard_start_xmit(skb, dev, txq)) {
					HARD_TX_UNLOCK(dev, txq);
					goto out;
				}
			}
			HARD_TX_UNLOCK(dev, txq);
		} 
	}

	rc = -ENETDOWN;
	rcu_read_unlock_bh();

#define HARD_TX_LOCK(dev, txq, cpu) {			\
	if ((dev->features & NETIF_F_LLTX) == 0) {	\
		__netif_tx_lock(txq, cpu);		\
	}						\
}

static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
{
	spin_lock(&txq->_xmit_lock);
	txq->xmit_lock_owner = cpu;
}

static int vlan_dev_init(struct net_device *dev)
{
	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;
...
	/* IFF_BROADCAST|IFF_MULTICAST; ??? */
	dev->flags  = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI);
	dev->iflink = real_dev->ifindex;
	dev->state  = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) |
					  (1<<__LINK_STATE_DORMANT))) |
		      (1<<__LINK_STATE_PRESENT);

	dev->features |= real_dev->features & real_dev->vlan_features;
...

static int vlan_dev_init(struct net_device *dev)
{
	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
...
	/* IFF_BROADCAST|IFF_MULTICAST; ??? */
	dev->flags  = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
					  IFF_MASTER | IFF_SLAVE);
	dev->iflink = real_dev->ifindex;
	dev->state  = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) |
					  (1<<__LINK_STATE_DORMANT))) |
		      (1<<__LINK_STATE_PRESENT);

	dev->hw_features = NETIF_F_ALL_CSUM | NETIF_F_SG |
			   NETIF_F_FRAGLIST | NETIF_F_ALL_TSO |
			   NETIF_F_HIGHDMA | NETIF_F_SCTP_CSUM |
			   NETIF_F_ALL_FCOE;

	dev->features |= real_dev->vlan_features | NETIF_F_LLTX;

//net/core/ethtool.c
int dev_ethtool(struct net *net, struct ifreq *ifr)
{	
	case ETHTOOL_GFEATURES:
		rc = ethtool_get_features(dev, useraddr);
		break;

//ethtool-3.5
static struct feature_state *
get_features(struct cmd_context *ctx, const struct feature_defs *defs)
{
...
	if (defs->n_features) { ///内核支持ETHTOOL_GFEATURES
		state->features.cmd = ETHTOOL_GFEATURES;
		state->features.size = FEATURE_BITS_TO_BLOCKS(defs->n_features);
		err = send_ioctl(ctx, &state->features);
		if (err)
			perror("Cannot get device generic features");
		else
			allfail = 0;
	} else {
		/* We should have got VLAN tag offload flags through
		 * ETHTOOL_GFLAGS.  However, prior to Linux 2.6.37
		 * they were not exposed in this way - and since VLAN
		 * tag offload was defined and implemented by many
		 * drivers, we shouldn't assume they are off.
		 * Instead, since these feature flag values were
		 * stable, read them from sysfs.
		 */
		char buf[20]; ///从/sys/class/net/%s/features读取features
		if (get_netdev_attr(ctx, "features", buf, sizeof(buf)) > 0)
			state->off_flags |=
				strtoul(buf, NULL, 0) &
				(ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN);
	}


static int get_netdev_attr(struct cmd_context *ctx, const char *name,
		    char *buf, size_t buf_len)
{
#ifdef TEST_ETHTOOL
	errno = ENOENT;
	return -1;
#else
	char path[40 + IFNAMSIZ];
	ssize_t len;
	int fd;

	len = snprintf(path, sizeof(path), "/sys/class/net/%s/%s",
		       ctx->devname, name);
	assert(len < sizeof(path));
	fd = open(path, O_RDONLY);
	if (fd < 0)
		return fd;
	len = read(fd, buf, buf_len - 1);
	if (len >= 0)
		buf[len] = 0;
	close(fd);
	return len;
#endif
}