自学教程：C++ vlan_dev_info函数代码示例

static u32 vlan_ethtool_get_rx_csum(struct net_device *dev){	const struct vlan_dev_info *vlan = vlan_dev_info(dev);	struct net_device *real_dev = vlan->real_dev;	if (real_dev->ethtool_ops == NULL ||	    real_dev->ethtool_ops->get_rx_csum == NULL)		return 0;	return real_dev->ethtool_ops->get_rx_csum(real_dev);}

static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type){	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;	const struct net_device_ops *ops = real_dev->netdev_ops;	int rc = -EINVAL;	if (ops->ndo_fcoe_get_wwn)		rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type);	return rc;}

static int vlan_dev_fcoe_disable(struct net_device *dev){	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;	const struct net_device_ops *ops = real_dev->netdev_ops;	int rc = -EINVAL;	if (ops->ndo_fcoe_disable)		rc = ops->ndo_fcoe_disable(real_dev);	return rc;}

/* *	Create the VLAN header for an arbitrary protocol layer * *	saddr=NULL	means use device source address *	daddr=NULL	means leave destination address (eg unresolved arp) * *  This is called when the SKB is moving down the stack towards the *  physical devices. */static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev,				unsigned short type,				const void *daddr, const void *saddr,				unsigned int len){	struct vlan_hdr *vhdr;	unsigned int vhdrlen = 0;	u16 vlan_tci = 0;	int rc;	if (!(vlan_dev_info(dev)->flags & VLAN_FLAG_REORDER_HDR)) {		vhdr = (struct vlan_hdr *) skb_push(skb, VLAN_HLEN);		vlan_tci = vlan_dev_info(dev)->vlan_id;		vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb);		vhdr->h_vlan_TCI = htons(vlan_tci);		/*		 *  Set the protocol type. For a packet of type ETH_P_802_3/2 we		 *  put the length in here instead.		 */		if (type != ETH_P_802_3 && type != ETH_P_802_2)			vhdr->h_vlan_encapsulated_proto = htons(type);		else			vhdr->h_vlan_encapsulated_proto = htons(len);		skb->protocol = htons(ETH_P_8021Q);		type = ETH_P_8021Q;		vhdrlen = VLAN_HLEN;	}	/* Before delegating work to the lower layer, enter our MAC-address */	if (saddr == NULL)		saddr = dev->dev_addr;	/* Now make the underlying real hard header */	dev = vlan_dev_info(dev)->real_dev;	rc = dev_hard_header(skb, dev, type, daddr, saddr, len + vhdrlen);	if (rc > 0)		rc += vhdrlen;	return rc;}

static netdev_tx_t vlan_dev_hard_start_xmit(struct sk_buff *skb,					    struct net_device *dev){	struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data);	unsigned int len;	int ret;	/* Handle non-VLAN frames if they are sent to us, for example by DHCP.	 *	 * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING	 * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs...	 */	if (#ifdef CONFIG_VLAN_8021Q_DOUBLE_TAG	    (vlan_double_tag) ||#endif	    (veth->h_vlan_proto != __constant_htons(ETH_P_8021Q) ||	     vlan_dev_info(dev)->flags & VLAN_FLAG_REORDER_HDR)) {		u16 vlan_tci;		vlan_tci = vlan_dev_info(dev)->vlan_id;		vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb);		skb = __vlan_hwaccel_put_tag(skb, vlan_tci);	}	skb->dev = vlan_dev_info(dev)->real_dev;	len = skb->len;	ret = dev_queue_xmit(skb);	if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {		struct vlan_pcpu_stats *stats;		stats = this_cpu_ptr(vlan_dev_info(dev)->vlan_pcpu_stats);		u64_stats_update_begin(&stats->syncp);		stats->tx_packets++;		stats->tx_bytes += len;		u64_stats_update_end(&stats->syncp);	} else {		this_cpu_inc(vlan_dev_info(dev)->vlan_pcpu_stats->tx_dropped);	}	return ret;}

static int vlan_ethtool_get_settings(struct net_device *dev,				     struct ethtool_cmd *cmd){	const struct vlan_dev_info *vlan = vlan_dev_info(dev);	struct net_device *real_dev = vlan->real_dev;	if (!real_dev->ethtool_ops->get_settings)		return -EOPNOTSUPP;	return real_dev->ethtool_ops->get_settings(real_dev, cmd);}

static int vlan_dev_neigh_setup(struct net_device *dev, struct neigh_parms *pa){	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;	const struct net_device_ops *ops = real_dev->netdev_ops;	int err = 0;	if (netif_device_present(real_dev) && ops->ndo_neigh_setup)		err = ops->ndo_neigh_setup(real_dev, pa);	return err;}

static void vlan_dev_change_rx_flags(struct net_device *dev, int change){	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;	if (dev->flags & IFF_UP) {		if (change & IFF_ALLMULTI)			dev_set_allmulti(real_dev, dev->flags & IFF_ALLMULTI ? 1 : -1);		if (change & IFF_PROMISC)			dev_set_promiscuity(real_dev, dev->flags & IFF_PROMISC ? 1 : -1);	}}

static int vlan_dev_fcoe_ddp_done(struct net_device *dev, u16 xid){	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;	const struct net_device_ops *ops = real_dev->netdev_ops;	int len = 0;	if (ops->ndo_fcoe_ddp_done)		len = ops->ndo_fcoe_ddp_done(real_dev, xid);	return len;}

static u32 vlan_ethtool_get_flags(struct net_device *dev){	const struct vlan_dev_info *vlan = vlan_dev_info(dev);	struct net_device *real_dev = vlan->real_dev;	if (!(real_dev->features & NETIF_F_HW_VLAN_RX) ||	    real_dev->ethtool_ops == NULL ||	    real_dev->ethtool_ops->get_flags == NULL)		return 0;	return real_dev->ethtool_ops->get_flags(real_dev);}

int vlan_proc_add_dev(struct net_device *vlandev){	struct vlan_dev_info *dev_info = vlan_dev_info(vlandev);	struct vlan_net *vn = net_generic(dev_net(vlandev), vlan_net_id);	dev_info->dent =		proc_create_data(vlandev->name, S_IFREG|S_IRUSR|S_IWUSR,				 vn->proc_vlan_dir, &vlandev_fops, vlandev);	if (!dev_info->dent)		return -ENOBUFS;	return 0;}

static int vlandev_seq_show(struct seq_file *seq, void *offset){	struct net_device *vlandev = (struct net_device *) seq->private;	const struct vlan_dev_info *dev_info = vlan_dev_info(vlandev);	struct net_device_stats *stats = &vlandev->stats;	static const char fmt[] = "%30s %12lu/n";	int i;	if (!is_vlan_dev(vlandev))		return 0;	seq_printf(seq,		   "%s  VID: %d	 REORDER_HDR: %i  dev->priv_flags: %hx/n",		   vlandev->name, dev_info->vlan_id,		   (int)(dev_info->flags & 1), vlandev->priv_flags);	seq_printf(seq, fmt, "total frames received", stats->rx_packets);	seq_printf(seq, fmt, "total bytes received", stats->rx_bytes);	seq_printf(seq, fmt, "Broadcast/Multicast Rcvd", stats->multicast);	seq_puts(seq, "/n");	seq_printf(seq, fmt, "total frames transmitted", stats->tx_packets);	seq_printf(seq, fmt, "total bytes transmitted", stats->tx_bytes);	seq_printf(seq, fmt, "total headroom inc",		   dev_info->cnt_inc_headroom_on_tx);	seq_printf(seq, fmt, "total encap on xmit",		   dev_info->cnt_encap_on_xmit);	seq_printf(seq, "Device: %s", dev_info->real_dev->name);	/* now show all PRIORITY mappings relating to this VLAN */	seq_printf(seq, "/nINGRESS priority mappings: "			"0:%u  1:%u  2:%u  3:%u  4:%u  5:%u  6:%u 7:%u/n",		   dev_info->ingress_priority_map[0],		   dev_info->ingress_priority_map[1],		   dev_info->ingress_priority_map[2],		   dev_info->ingress_priority_map[3],		   dev_info->ingress_priority_map[4],		   dev_info->ingress_priority_map[5],		   dev_info->ingress_priority_map[6],		   dev_info->ingress_priority_map[7]);	seq_printf(seq, "EGRESSS priority Mappings: ");	for (i = 0; i < 16; i++) {		const struct vlan_priority_tci_mapping *mp			= dev_info->egress_priority_map[i];		while (mp) {			seq_printf(seq, "%u:%hu ",				   mp->priority, ((mp->vlan_qos >> 13) & 0x7));			mp = mp->next;		}	}	seq_puts(seq, "/n");	return 0;}

void vlan_dev_set_ingress_priority(const struct net_device *dev,				   u32 skb_prio, u16 vlan_prio){	struct vlan_dev_info *vlan = vlan_dev_info(dev);	if (vlan->ingress_priority_map[vlan_prio & 0x7] && !skb_prio)		vlan->nr_ingress_mappings--;	else if (!vlan->ingress_priority_map[vlan_prio & 0x7] && skb_prio)		vlan->nr_ingress_mappings++;	vlan->ingress_priority_map[vlan_prio & 0x7] = skb_prio;}

static int vlan_dev_fcoe_ddp_setup(struct net_device *dev, u16 xid,				   struct scatterlist *sgl, unsigned int sgc){	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;	const struct net_device_ops *ops = real_dev->netdev_ops;	int rc = 0;	if (ops->ndo_fcoe_ddp_setup)		rc = ops->ndo_fcoe_ddp_setup(real_dev, xid, sgl, sgc);	return rc;}

static int vlan_dev_change_mtu(struct net_device *dev, int new_mtu){	/* TODO: gotta make sure the underlying layer can handle it,	 * maybe an IFF_VLAN_CAPABLE flag for devices?	 */	if (vlan_dev_info(dev)->real_dev->mtu < new_mtu)		return -ERANGE;	dev->mtu = new_mtu;	return 0;}

static int vlan_passthru_hard_header(struct sk_buff *skb, struct net_device *dev,				     unsigned short type,				     const void *daddr, const void *saddr,				     unsigned int len){	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;	if (saddr == NULL)		saddr = dev->dev_addr;	return dev_hard_header(skb, real_dev, type, daddr, saddr, len);}

static void vlan_dev_uninit(struct net_device *dev){	struct vlan_priority_tci_mapping *pm;	struct vlan_dev_info *vlan = vlan_dev_info(dev);	int i;	for (i = 0; i < ARRAY_SIZE(vlan->egress_priority_map); i++) {		while ((pm = vlan->egress_priority_map[i]) != NULL) {			vlan->egress_priority_map[i] = pm->next;			kfree(pm);		}	}}

static struct net_device_stats *vlan_dev_get_stats(struct net_device *dev){	struct net_device_stats *stats = &dev->stats;	dev_txq_stats_fold(dev, stats);	if (vlan_dev_info(dev)->vlan_rx_stats) {		struct vlan_rx_stats *p, rx = {0};		int i;		for_each_possible_cpu(i) {			p = per_cpu_ptr(vlan_dev_info(dev)->vlan_rx_stats, i);			rx.rx_packets += p->rx_packets;			rx.rx_bytes   += p->rx_bytes;			rx.rx_errors  += p->rx_errors;			rx.multicast  += p->multicast;		}		stats->rx_packets = rx.rx_packets;		stats->rx_bytes   = rx.rx_bytes;		stats->rx_errors  = rx.rx_errors;		stats->multicast  = rx.multicast;	}	return stats;}

static int vlan_dev_hwaccel_hard_start_xmit(struct sk_buff *skb,					    struct net_device *dev){	struct net_device_stats *stats = &dev->stats;	unsigned short veth_TCI;	/* Construct the second two bytes. This field looks something	 * like:	 * usr_priority: 3 bits	 (high bits)	 * CFI		 1 bit	 * VLAN ID	 12 bits (low bits)	 */	veth_TCI = vlan_dev_info(dev)->vlan_id;	veth_TCI |= vlan_dev_get_egress_qos_mask(dev, skb);	skb = __vlan_hwaccel_put_tag(skb, veth_TCI);	stats->tx_packets++;	stats->tx_bytes += skb->len;	skb->dev = vlan_dev_info(dev)->real_dev;	dev_queue_xmit(skb);	return 0;}

static int vlan_dev_hwaccel_hard_start_xmit(struct sk_buff *skb,					    struct net_device *dev){	struct net_device_stats *stats = &dev->stats;	u16 vlan_tci;	vlan_tci = vlan_dev_info(dev)->vlan_id;	vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb);		/* Start of modified by f00120964 for qos function 2012-4-2*/#ifdef CONFIG_DT_QOS	vlan_tci |= (s_dtQosMarkto8021P[(skb->mark & 0x7)] << 13);#endif    /* End of modified by f00120964 for qos function 2012-4-2*/	skb = __vlan_hwaccel_put_tag(skb, vlan_tci);	stats->tx_packets++;	stats->tx_bytes += skb->len;	skb->dev = vlan_dev_info(dev)->real_dev;	dev_queue_xmit(skb);	return NETDEV_TX_OK;}

static struct rtnl_link_stats64 *vlan_dev_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats){	if (vlan_dev_info(dev)->vlan_pcpu_stats) {		struct vlan_pcpu_stats *p;		u32 rx_errors = 0, tx_dropped = 0;		int i;		for_each_possible_cpu(i) {			u64 rxpackets, rxbytes, rxmulticast, txpackets, txbytes;			unsigned int start;			p = per_cpu_ptr(vlan_dev_info(dev)->vlan_pcpu_stats, i);			do {				start = u64_stats_fetch_begin_bh(&p->syncp);				rxpackets	= p->rx_packets;				rxbytes		= p->rx_bytes;				rxmulticast	= p->rx_multicast;				txpackets	= p->tx_packets;				txbytes		= p->tx_bytes;			} while (u64_stats_fetch_retry_bh(&p->syncp, start));			stats->rx_packets	+= rxpackets;			stats->rx_bytes		+= rxbytes;			stats->multicast	+= rxmulticast;			stats->tx_packets	+= txpackets;			stats->tx_bytes		+= txbytes;			/* rx_errors & tx_dropped are u32 */			rx_errors	+= p->rx_errors;			tx_dropped	+= p->tx_dropped;		}		stats->rx_errors  = rx_errors;		stats->tx_dropped = tx_dropped;	}	return stats;}

static int vlan_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev){	struct net_device_stats *stats = &dev->stats;	struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data);	/* Handle non-VLAN frames if they are sent to us, for example by DHCP.	 *	 * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING	 * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs...	 */	if (veth->h_vlan_proto != htons(ETH_P_8021Q) ||	    vlan_dev_info(dev)->flags & VLAN_FLAG_REORDER_HDR) {		unsigned int orig_headroom = skb_headroom(skb);		u16 vlan_tci;		vlan_dev_info(dev)->cnt_encap_on_xmit++;		vlan_tci = vlan_dev_info(dev)->vlan_id;		vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb);		skb = __vlan_put_tag(skb, vlan_tci);		if (!skb) {			stats->tx_dropped++;			return NETDEV_TX_OK;		}		if (orig_headroom < VLAN_HLEN)			vlan_dev_info(dev)->cnt_inc_headroom_on_tx++;	}	stats->tx_packets++;	stats->tx_bytes += skb->len;	skb->dev = vlan_dev_info(dev)->real_dev;	dev_queue_xmit(skb);	return NETDEV_TX_OK;}

static inline struct sk_buff *vlan_check_reorder_header(struct sk_buff *skb){	if (vlan_dev_info(skb->dev)->flags & VLAN_FLAG_REORDER_HDR) {		if (skb_cow(skb, skb_headroom(skb)) < 0)			skb = NULL;		if (skb) {			/* Lifted from Gleb's VLAN code... */			memmove(skb->data - ETH_HLEN,				skb->data - VLAN_ETH_HLEN, 12);			skb->mac_header += VLAN_HLEN;		}	}	return skb;}

static int vlan_dev_stop(struct net_device *dev){	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;	dev_mc_unsync(real_dev, dev);	dev_unicast_unsync(real_dev, dev);	if (dev->flags & IFF_ALLMULTI)		dev_set_allmulti(real_dev, -1);	if (dev->flags & IFF_PROMISC)		dev_set_promiscuity(real_dev, -1);	if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr))		dev_unicast_delete(real_dev, dev->dev_addr, dev->addr_len);	return 0;}

static u32 vlan_dev_fix_features(struct net_device *dev, u32 features){	struct net_device *real_dev = vlan_dev_info(dev)->real_dev;	u32 old_features = features;	features &= real_dev->features;	features &= real_dev->vlan_features;	features |= old_features & NETIF_F_SOFT_FEATURES;	if (dev_ethtool_get_rx_csum(real_dev))		features |= NETIF_F_RXCSUM;	features |= NETIF_F_LLTX;	return features;}

static inline u16vlan_dev_get_egress_qos_mask(struct net_device *dev, struct sk_buff *skb){	struct vlan_priority_tci_mapping *mp;	mp = vlan_dev_info(dev)->egress_priority_map[(skb->priority & 0xF)];	while (mp) {		if (mp->priority == skb->priority) {			return mp->vlan_qos; /* This should already be shifted					      * to mask correctly with the					      * VLAN's TCI */		}		mp = mp->next;	}	return 0;}

bool vlan_hwaccel_do_receive(struct sk_buff **skbp){	struct sk_buff *skb = *skbp;	u16 vlan_id = skb->vlan_tci & VLAN_VID_MASK;	struct net_device *vlan_dev;	struct vlan_pcpu_stats *rx_stats;	vlan_dev = vlan_find_dev(skb->dev, vlan_id);	if (!vlan_dev) {		if (vlan_id)			skb->pkt_type = PACKET_OTHERHOST;		return false;	}	skb = *skbp = skb_share_check(skb, GFP_ATOMIC);	if (unlikely(!skb))		return false;	skb->dev = vlan_dev;	skb->priority = vlan_get_ingress_priority(vlan_dev, skb->vlan_tci);	skb->vlan_tci = 0;	rx_stats = this_cpu_ptr(vlan_dev_info(vlan_dev)->vlan_pcpu_stats);	u64_stats_update_begin(&rx_stats->syncp);	rx_stats->rx_packets++;	rx_stats->rx_bytes += skb->len;	switch (skb->pkt_type) {	case PACKET_BROADCAST:		break;	case PACKET_MULTICAST:		rx_stats->rx_multicast++;		break;	case PACKET_OTHERHOST:		/* Our lower layer thinks this is not local, let's make sure.		 * This allows the VLAN to have a different MAC than the		 * underlying device, and still route correctly. */		if (!compare_ether_addr(eth_hdr(skb)->h_dest,					vlan_dev->dev_addr))			skb->pkt_type = PACKET_HOST;		break;	}	u64_stats_update_end(&rx_stats->syncp);	return true;}

static int vlan_dev_open(struct net_device *dev){	struct vlan_dev_info *vlan = vlan_dev_info(dev);	struct net_device *real_dev = vlan->real_dev;	int err;	if (!(real_dev->flags & IFF_UP) &&	    !(vlan->flags & VLAN_FLAG_LOOSE_BINDING))		return -ENETDOWN;	if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr)) {		err = dev_uc_add(real_dev, dev->dev_addr);		if (err < 0)			goto out;	}	if (dev->flags & IFF_ALLMULTI) {		err = dev_set_allmulti(real_dev, 1);		if (err < 0)			goto del_unicast;	}	if (dev->flags & IFF_PROMISC) {		err = dev_set_promiscuity(real_dev, 1);		if (err < 0)			goto clear_allmulti;	}	memcpy(vlan->real_dev_addr, real_dev->dev_addr, ETH_ALEN);	if (vlan->flags & VLAN_FLAG_GVRP)		vlan_gvrp_request_join(dev);	if (netif_carrier_ok(real_dev))		netif_carrier_on(dev);	return 0;clear_allmulti:	if (dev->flags & IFF_ALLMULTI)		dev_set_allmulti(real_dev, -1);del_unicast:	if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr))		dev_uc_del(real_dev, dev->dev_addr);out:	netif_carrier_off(dev);	return err;}