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

int vlan_dev_set_egress_priority(const struct net_device *dev,				 u32 skb_prio, u16 vlan_prio){	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);	struct vlan_priority_tci_mapping *mp = NULL;	struct vlan_priority_tci_mapping *np;	u32 vlan_qos = (vlan_prio << VLAN_PRIO_SHIFT) & VLAN_PRIO_MASK;	/* See if a priority mapping exists.. */	mp = vlan->egress_priority_map[skb_prio & 0xF];	while (mp) {		if (mp->priority == skb_prio) {			if (mp->vlan_qos && !vlan_qos)				vlan->nr_egress_mappings--;			else if (!mp->vlan_qos && vlan_qos)				vlan->nr_egress_mappings++;			mp->vlan_qos = vlan_qos;			return 0;		}		mp = mp->next;	}	/* Create a new mapping then. */	mp = vlan->egress_priority_map[skb_prio & 0xF];	np = kmalloc(sizeof(struct vlan_priority_tci_mapping), GFP_KERNEL);	if (!np)		return -ENOBUFS;	np->next = mp;	np->priority = skb_prio;	np->vlan_qos = vlan_qos;	/* Before inserting this element in hash table, make sure all its fields	 * are committed to memory.	 * coupled with smp_rmb() in vlan_dev_get_egress_qos_mask()	 */	smp_wmb();	vlan->egress_priority_map[skb_prio & 0xF] = np;	if (vlan_qos)		vlan->nr_egress_mappings++;	return 0;}

void unregister_vlan_dev(struct net_device *dev, struct list_head *head){	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);	struct net_device *real_dev = vlan->real_dev;	struct vlan_info *vlan_info;	struct vlan_group *grp;	u16 vlan_id = vlan->vlan_id;	ASSERT_RTNL();	vlan_info = rtnl_dereference(real_dev->vlan_info);	BUG_ON(!vlan_info);	grp = &vlan_info->grp;	grp->nr_vlan_devs--;	if (vlan->flags & VLAN_FLAG_GVRP)		vlan_gvrp_request_leave(dev);	vlan_group_set_device(grp, vlan_id, NULL);	/* Because unregister_netdevice_queue() makes sure at least one rcu	 * grace period is respected before device freeing,	 * we dont need to call synchronize_net() here.	 */	unregister_netdevice_queue(dev, head);	if (grp->nr_vlan_devs == 0)		vlan_gvrp_uninit_applicant(real_dev);	/* Take it out of our own structures, but be sure to interlock with	 * HW accelerating devices or SW vlan input packet processing if	 * VLAN is not 0 (leave it there for 802.1p).	 */	if (vlan_id)		vlan_vid_del(real_dev, vlan_id);	/* Get rid of the vlan's reference to real_dev */	dev_put(real_dev);}

static netdev_features_t vlan_dev_fix_features(struct net_device *dev,	netdev_features_t features){	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;	netdev_features_t old_features = features;	netdev_features_t lower_features;	lower_features = netdev_intersect_features((real_dev->vlan_features |						    NETIF_F_RXCSUM),						   real_dev->features);	/* Add HW_CSUM setting to preserve user ability to control	 * checksum offload on the vlan device.	 */	if (lower_features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))		lower_features |= NETIF_F_HW_CSUM;	features = netdev_intersect_features(features, lower_features);	features |= old_features & (NETIF_F_SOFT_FEATURES | NETIF_F_GSO_SOFTWARE);	features |= NETIF_F_LLTX;	return features;}

static void vlan_sync_address(struct net_device *dev,			      struct net_device *vlandev){	struct vlan_dev_priv *vlan = vlan_dev_priv(vlandev);	/* May be called without an actual change */	if (!compare_ether_addr(vlan->real_dev_addr, dev->dev_addr))		return;	/* vlan address was different from the old address and is equal to	 * the new address */	if (compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&	    !compare_ether_addr(vlandev->dev_addr, dev->dev_addr))		dev_uc_del(dev, vlandev->dev_addr);	/* vlan address was equal to the old address and is different from	 * the new address */	if (!compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&	    compare_ether_addr(vlandev->dev_addr, dev->dev_addr))		dev_uc_add(dev, vlandev->dev_addr);	memcpy(vlan->real_dev_addr, dev->dev_addr, ETH_ALEN);}

static int vlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo){	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);	struct net_device *real_dev = vlan->real_dev;	struct netpoll *netpoll;	int err = 0;	netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);	err = -ENOMEM;	if (!netpoll)		goto out;	err = __netpoll_setup(netpoll, real_dev);	if (err) {		kfree(netpoll);		goto out;	}	vlan->netpoll = netpoll;out:	return err;}

static int vlan_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd){	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;	const struct net_device_ops *ops = real_dev->netdev_ops;	struct ifreq ifrr;	int err = -EOPNOTSUPP;	strncpy(ifrr.ifr_name, real_dev->name, IFNAMSIZ);	ifrr.ifr_ifru = ifr->ifr_ifru;	switch (cmd) {	case SIOCGMIIPHY:	case SIOCGMIIREG:	case SIOCSMIIREG:		if (netif_device_present(real_dev) && ops->ndo_do_ioctl)			err = ops->ndo_do_ioctl(real_dev, &ifrr, cmd);		break;	}	if (!err)		ifr->ifr_ifru = ifrr.ifr_ifru;	return err;}

static int vlan_seq_show(struct seq_file *seq, void *v){	struct net *net = seq_file_net(seq);	struct vlan_net *vn = net_generic(net, vlan_net_id);	if (v == SEQ_START_TOKEN) {		const char *nmtype = NULL;		seq_puts(seq, "VLAN Dev name	 | VLAN ID/n");		if (vn->name_type < ARRAY_SIZE(vlan_name_type_str))		    nmtype =  vlan_name_type_str[vn->name_type];		seq_printf(seq, "Name-Type: %s/n",			   nmtype ? nmtype :  "UNKNOWN");	} else {		const struct net_device *vlandev = v;		const struct vlan_dev_priv *vlan = vlan_dev_priv(vlandev);		seq_printf(seq, "%-15s| %d  | %s/n",  vlandev->name,			   vlan->vlan_id,    vlan->real_dev->name);	}	return 0;}

int vlan_dev_set_egress_priority(const struct net_device *dev,				 u32 skb_prio, u16 vlan_prio){	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);	struct vlan_priority_tci_mapping *mp = NULL;	struct vlan_priority_tci_mapping *np;	u32 vlan_qos = (vlan_prio << VLAN_PRIO_SHIFT) & VLAN_PRIO_MASK;	/* See if a priority mapping exists.. */	mp = vlan->egress_priority_map[skb_prio & 0xF];	while (mp) {		if (mp->priority == skb_prio) {			if (mp->vlan_qos && !vlan_qos)				vlan->nr_egress_mappings--;			else if (!mp->vlan_qos && vlan_qos)				vlan->nr_egress_mappings++;			mp->vlan_qos = vlan_qos;			return 0;		}		mp = mp->next;	}	/* Create a new mapping then. */	mp = vlan->egress_priority_map[skb_prio & 0xF];	np = kmalloc(sizeof(struct vlan_priority_tci_mapping), GFP_KERNEL);	if (!np)		return -ENOBUFS;	np->next = mp;	np->priority = skb_prio;	np->vlan_qos = vlan_qos;	vlan->egress_priority_map[skb_prio & 0xF] = np;	if (vlan_qos)		vlan->nr_egress_mappings++;	return 0;}

static int vlan_dev_get_iflink(const struct net_device *dev){	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;	return real_dev->ifindex;}

static int vlan_device_event(struct notifier_block *unused, unsigned long event,			     void *ptr){	struct net_device *dev = ptr;	struct vlan_group *grp;	struct vlan_info *vlan_info;	int i, flgs;	struct net_device *vlandev;	struct vlan_dev_priv *vlan;	LIST_HEAD(list);	if (is_vlan_dev(dev))		__vlan_device_event(dev, event);	if ((event == NETDEV_UP) &&	    (dev->features & NETIF_F_HW_VLAN_FILTER)) {		pr_info("adding VLAN 0 to HW filter on device %s/n",			dev->name);		vlan_vid_add(dev, 0);	}	vlan_info = rtnl_dereference(dev->vlan_info);	if (!vlan_info)		goto out;	grp = &vlan_info->grp;	/* It is OK that we do not hold the group lock right now,	 * as we run under the RTNL lock.	 */	switch (event) {	case NETDEV_CHANGE:		/* Propagate real device state to vlan devices */		for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			netif_stacked_transfer_operstate(dev, vlandev);		}		break;	case NETDEV_CHANGEADDR:		/* Adjust unicast filters on underlying device */		for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			flgs = vlandev->flags;			if (!(flgs & IFF_UP))				continue;			vlan_sync_address(dev, vlandev);		}		break;	case NETDEV_CHANGEMTU:		for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			if (vlandev->mtu <= dev->mtu)				continue;			dev_set_mtu(vlandev, dev->mtu);		}		break;	case NETDEV_FEAT_CHANGE:		/* Propagate device features to underlying device */		for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			vlan_transfer_features(dev, vlandev);		}		break;	case NETDEV_DOWN:		if (dev->features & NETIF_F_HW_VLAN_FILTER)			vlan_vid_del(dev, 0);		/* Put all VLANs for this dev in the down state too.  */		for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			flgs = vlandev->flags;			if (!(flgs & IFF_UP))				continue;			vlan = vlan_dev_priv(vlandev);			if (!(vlan->flags & VLAN_FLAG_LOOSE_BINDING))				dev_change_flags(vlandev, flgs & ~IFF_UP);			netif_stacked_transfer_operstate(dev, vlandev);//.........这里部分代码省略.........

int register_vlan_dev(struct net_device *dev){	struct vlan_dev_priv *vlan = vlan_dev_priv(dev);	struct net_device *real_dev = vlan->real_dev;	u16 vlan_id = vlan->vlan_id;	struct vlan_info *vlan_info;	struct vlan_group *grp;	int err;	err = vlan_vid_add(real_dev, vlan->vlan_proto, vlan_id);	if (err)		return err;	vlan_info = rtnl_dereference(real_dev->vlan_info);	/* vlan_info should be there now. vlan_vid_add took care of it */	BUG_ON(!vlan_info);	grp = &vlan_info->grp;	if (grp->nr_vlan_devs == 0) {		err = vlan_gvrp_init_applicant(real_dev);		if (err < 0)			goto out_vid_del;		err = vlan_mvrp_init_applicant(real_dev);		if (err < 0)			goto out_uninit_gvrp;	}	err = vlan_group_prealloc_vid(grp, vlan->vlan_proto, vlan_id);	if (err < 0)		goto out_uninit_mvrp;	err = register_netdevice(dev);	if (err < 0)		goto out_uninit_mvrp;	err = netdev_upper_dev_link(real_dev, dev);	if (err)		goto out_unregister_netdev;	/* Account for reference in struct vlan_dev_priv */	dev_hold(real_dev);	netif_stacked_transfer_operstate(real_dev, dev);	linkwatch_fire_event(dev); /* _MUST_ call rfc2863_policy() */	/* So, got the sucker initialized, now lets place	 * it into our local structure.	 */	vlan_group_set_device(grp, vlan->vlan_proto, vlan_id, dev);	grp->nr_vlan_devs++;	return 0;out_unregister_netdev:	unregister_netdevice(dev);out_uninit_mvrp:	if (grp->nr_vlan_devs == 0)		vlan_mvrp_uninit_applicant(real_dev);out_uninit_gvrp:	if (grp->nr_vlan_devs == 0)		vlan_gvrp_uninit_applicant(real_dev);out_vid_del:	vlan_vid_del(real_dev, vlan->vlan_proto, vlan_id);	return err;}

/*  Attach a VLAN device to a mac address (ie Ethernet Card). *  Returns 0 if the device was created or a negative error code otherwise. */static int register_vlan_device(struct net_device *real_dev, u16 vlan_id){	struct net_device *new_dev;	struct net *net = dev_net(real_dev);	struct vlan_net *vn = net_generic(net, vlan_net_id);	char name[IFNAMSIZ];	int err;	if (vlan_id >= VLAN_VID_MASK)		return -ERANGE;	err = vlan_check_real_dev(real_dev, vlan_id);	if (err < 0)		return err;	/* Gotta set up the fields for the device. */	switch (vn->name_type) {	case VLAN_NAME_TYPE_RAW_PLUS_VID:		/* name will look like:	 eth1.0005 */		snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, vlan_id);		break;	case VLAN_NAME_TYPE_PLUS_VID_NO_PAD:		/* Put our vlan.VID in the name.		 * Name will look like:	 vlan5		 */		snprintf(name, IFNAMSIZ, "vlan%i", vlan_id);		break;	case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD:		/* Put our vlan.VID in the name.		 * Name will look like:	 eth0.5		 */		snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, vlan_id);		break;	case VLAN_NAME_TYPE_PLUS_VID:		/* Put our vlan.VID in the name.		 * Name will look like:	 vlan0005		 */	default:		snprintf(name, IFNAMSIZ, "vlan%.4i", vlan_id);	}	new_dev = alloc_netdev(sizeof(struct vlan_dev_priv), name, vlan_setup);	if (new_dev == NULL)		return -ENOBUFS;	dev_net_set(new_dev, net);	/* need 4 bytes for extra VLAN header info,	 * hope the underlying device can handle it.	 */	new_dev->mtu = real_dev->mtu;	new_dev->priv_flags |= (real_dev->priv_flags & IFF_UNICAST_FLT);	vlan_dev_priv(new_dev)->vlan_id = vlan_id;	vlan_dev_priv(new_dev)->real_dev = real_dev;	vlan_dev_priv(new_dev)->dent = NULL;	vlan_dev_priv(new_dev)->flags = VLAN_FLAG_REORDER_HDR;	new_dev->rtnl_link_ops = &vlan_link_ops;	err = register_vlan_dev(new_dev);	if (err < 0)		goto out_free_newdev;	return 0;out_free_newdev:	free_netdev(new_dev);	return err;}

static int vlan_device_event(struct notifier_block *unused, unsigned long event,			     void *ptr){	struct net_device *dev = ptr;	struct vlan_group *grp;	struct vlan_info *vlan_info;	int i, flgs;	struct net_device *vlandev;	struct vlan_dev_priv *vlan;	LIST_HEAD(list);	if (is_vlan_dev(dev))		__vlan_device_event(dev, event);	if ((event == NETDEV_UP) &&	    (dev->features & NETIF_F_HW_VLAN_FILTER)) {		pr_info("adding VLAN 0 to HW filter on device %s/n",			dev->name);		vlan_vid_add(dev, 0);	}	vlan_info = rtnl_dereference(dev->vlan_info);	if (!vlan_info)		goto out;	grp = &vlan_info->grp;	switch (event) {	case NETDEV_CHANGE:				for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			netif_stacked_transfer_operstate(dev, vlandev);		}		break;	case NETDEV_CHANGEADDR:				for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			flgs = vlandev->flags;			if (!(flgs & IFF_UP))				continue;			vlan_sync_address(dev, vlandev);		}		break;	case NETDEV_CHANGEMTU:		for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			if (vlandev->mtu <= dev->mtu)				continue;			dev_set_mtu(vlandev, dev->mtu);		}		break;	case NETDEV_FEAT_CHANGE:				for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			vlan_transfer_features(dev, vlandev);		}		break;	case NETDEV_DOWN:				for (i = 0; i < VLAN_N_VID; i++) {			vlandev = vlan_group_get_device(grp, i);			if (!vlandev)				continue;			flgs = vlandev->flags;			if (!(flgs & IFF_UP))				continue;			vlan = vlan_dev_priv(vlandev);			if (!(vlan->flags & VLAN_FLAG_LOOSE_BINDING))				dev_change_flags(vlandev, flgs & ~IFF_UP);			netif_stacked_transfer_operstate(dev, vlandev);		}		break;	case NETDEV_UP:				for (i = 0; i < VLAN_N_VID; i++) {//.........这里部分代码省略.........

u16 vlan_dev_vlan_id(const struct net_device *dev){	return vlan_dev_priv(dev)->vlan_id;}

struct net_device *vlan_dev_real_dev(const struct net_device *dev){	return vlan_dev_priv(dev)->real_dev;}

bool vlan_do_receive(struct sk_buff **skbp, bool last_handler){	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 && last_handler)			skb->pkt_type = PACKET_OTHERHOST;		return false;	}	skb = *skbp = skb_share_check(skb, GFP_ATOMIC);	if (unlikely(!skb))		return false;	skb->dev = vlan_dev;	if (skb->pkt_type == PACKET_OTHERHOST) {		/*                                                                                                                                                                        */		if (!compare_ether_addr(eth_hdr(skb)->h_dest,					vlan_dev->dev_addr))			skb->pkt_type = PACKET_HOST;	}	if (!(vlan_dev_priv(vlan_dev)->flags & VLAN_FLAG_REORDER_HDR)) {		unsigned int offset = skb->data - skb_mac_header(skb);		/*                                                                                                                                                         */		skb_push(skb, offset);		skb = *skbp = vlan_insert_tag(skb, skb->vlan_tci);		if (!skb)			return false;		skb_pull(skb, offset + VLAN_HLEN);		skb_reset_mac_len(skb);	}	skb->priority = vlan_get_ingress_priority(vlan_dev, skb->vlan_tci);	skb->vlan_tci = 0;	rx_stats = this_cpu_ptr(vlan_dev_priv(vlan_dev)->vlan_pcpu_stats);	u64_stats_update_begin(&rx_stats->syncp);	rx_stats->rx_packets++;	rx_stats->rx_bytes += skb->len;	if (skb->pkt_type == PACKET_MULTICAST)		rx_stats->rx_multicast++;	u64_stats_update_end(&rx_stats->syncp);	return true;}

bool vlan_do_receive(struct sk_buff **skbp, bool last_handler){	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) {		/* Only the last call to vlan_do_receive() should change		 * pkt_type to PACKET_OTHERHOST		 */		if (vlan_id && last_handler)			skb->pkt_type = PACKET_OTHERHOST;		return false;	}	skb = *skbp = skb_share_check(skb, GFP_ATOMIC);	if (unlikely(!skb))		return false;	skb->dev = vlan_dev;	if (skb->pkt_type == 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;	}	if (!(vlan_dev_priv(vlan_dev)->flags & VLAN_FLAG_REORDER_HDR)) {		unsigned int offset = skb->data - skb_mac_header(skb);		/*		 * vlan_insert_tag expect skb->data pointing to mac header.		 * So change skb->data before calling it and change back to		 * original position later		 */		skb_push(skb, offset);		skb = *skbp = vlan_insert_tag(skb, skb->vlan_tci);		if (!skb)			return false;		skb_pull(skb, offset + VLAN_HLEN);		skb_reset_mac_len(skb);	}	skb->priority = vlan_get_ingress_priority(vlan_dev, skb->vlan_tci);	skb->vlan_tci = 0;	rx_stats = this_cpu_ptr(vlan_dev_priv(vlan_dev)->vlan_pcpu_stats);	u64_stats_update_begin(&rx_stats->syncp);	rx_stats->rx_packets++;	rx_stats->rx_bytes += skb->len;	if (skb->pkt_type == PACKET_MULTICAST)		rx_stats->rx_multicast++;	u64_stats_update_end(&rx_stats->syncp);	return true;}

static int vlan_device_event(struct notifier_block *unused, unsigned long event,			     void *ptr){	struct net_device *dev = netdev_notifier_info_to_dev(ptr);	struct vlan_group *grp;	struct vlan_info *vlan_info;	int i, flgs;	struct net_device *vlandev;	struct vlan_dev_priv *vlan;	bool last = false;	LIST_HEAD(list);	if (is_vlan_dev(dev))		__vlan_device_event(dev, event);	if ((event == NETDEV_UP) &&	    (dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) {		pr_info("adding VLAN 0 to HW filter on device %s/n",			dev->name);		vlan_vid_add(dev, htons(ETH_P_8021Q), 0);	}	vlan_info = rtnl_dereference(dev->vlan_info);	if (!vlan_info)		goto out;	grp = &vlan_info->grp;	/* It is OK that we do not hold the group lock right now,	 * as we run under the RTNL lock.	 */	switch (event) {	case NETDEV_CHANGE:		/* Propagate real device state to vlan devices */		vlan_group_for_each_dev(grp, i, vlandev)			netif_stacked_transfer_operstate(dev, vlandev);		break;	case NETDEV_CHANGEADDR:		/* Adjust unicast filters on underlying device */		vlan_group_for_each_dev(grp, i, vlandev) {			flgs = vlandev->flags;			if (!(flgs & IFF_UP))				continue;			vlan_sync_address(dev, vlandev);		}		break;	case NETDEV_CHANGEMTU:		vlan_group_for_each_dev(grp, i, vlandev) {			if (vlandev->mtu <= dev->mtu)				continue;			dev_set_mtu(vlandev, dev->mtu);		}		break;	case NETDEV_FEAT_CHANGE:		/* Propagate device features to underlying device */		vlan_group_for_each_dev(grp, i, vlandev)			vlan_transfer_features(dev, vlandev);		break;	case NETDEV_DOWN:		if (dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)			vlan_vid_del(dev, htons(ETH_P_8021Q), 0);		/* Put all VLANs for this dev in the down state too.  */		vlan_group_for_each_dev(grp, i, vlandev) {			flgs = vlandev->flags;			if (!(flgs & IFF_UP))				continue;			vlan = vlan_dev_priv(vlandev);			if (!(vlan->flags & VLAN_FLAG_LOOSE_BINDING))				dev_change_flags(vlandev, flgs & ~IFF_UP);			netif_stacked_transfer_operstate(dev, vlandev);		}

static int vlan_dev_init(struct net_device *dev){	struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;	netif_carrier_off(dev);	/* IFF_BROADCAST|IFF_MULTICAST; ??? */	dev->flags  = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI |					  IFF_MASTER | IFF_SLAVE);	dev->state  = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) |					  (1<<__LINK_STATE_DORMANT))) |		      (1<<__LINK_STATE_PRESENT);	dev->hw_features = NETIF_F_HW_CSUM | NETIF_F_SG |			   NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE |			   NETIF_F_HIGHDMA | NETIF_F_SCTP_CRC |			   NETIF_F_ALL_FCOE;	dev->features |= dev->hw_features | NETIF_F_LLTX;	dev->gso_max_size = real_dev->gso_max_size;	dev->gso_max_segs = real_dev->gso_max_segs;	if (dev->features & NETIF_F_VLAN_FEATURES)		netdev_warn(real_dev, "VLAN features are set incorrectly.  Q-in-Q configurations may not work correctly./n");	dev->vlan_features = real_dev->vlan_features & ~NETIF_F_ALL_FCOE;	/* ipv6 shared card related stuff */	dev->dev_id = real_dev->dev_id;	if (is_zero_ether_addr(dev->dev_addr)) {		ether_addr_copy(dev->dev_addr, real_dev->dev_addr);		dev->addr_assign_type = NET_ADDR_STOLEN;	}	if (is_zero_ether_addr(dev->broadcast))		memcpy(dev->broadcast, real_dev->broadcast, dev->addr_len);#if IS_ENABLED(CONFIG_FCOE)	dev->fcoe_ddp_xid = real_dev->fcoe_ddp_xid;#endif	dev->needed_headroom = real_dev->needed_headroom;	if (vlan_hw_offload_capable(real_dev->features,				    vlan_dev_priv(dev)->vlan_proto)) {		dev->header_ops      = &vlan_passthru_header_ops;		dev->hard_header_len = real_dev->hard_header_len;	} else {		dev->header_ops      = &vlan_header_ops;		dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN;	}	dev->netdev_ops = &vlan_netdev_ops;	SET_NETDEV_DEVTYPE(dev, &vlan_type);	vlan_dev_set_lockdep_class(dev, vlan_dev_get_lock_subclass(dev));	vlan_dev_priv(dev)->vlan_pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);	if (!vlan_dev_priv(dev)->vlan_pcpu_stats)		return -ENOMEM;	return 0;}

static int vlan_dev_get_lock_subclass(struct net_device *dev){	return vlan_dev_priv(dev)->nest_level;}

static void vlan_dev_set_rx_mode(struct net_device *vlan_dev){	dev_mc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);	dev_uc_sync(vlan_dev_priv(vlan_dev)->real_dev, vlan_dev);}

void vlan_dev_get_realdev_name(const struct net_device *dev, char *result){	strncpy(result, vlan_dev_priv(dev)->real_dev->name, 23);}