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

static void __exit niit_cleanup(void) {	rtnl_lock();	unregister_netdevice(tunnel4_dev);	unregister_netdevice(tunnel6_dev);	rtnl_unlock();}

static void veth_dellink(struct net_device *dev){	struct veth_priv *priv;	struct net_device *peer;	priv = netdev_priv(dev);	peer = priv->peer;	unregister_netdevice(dev);	unregister_netdevice(peer);}

static void ip6_tnl_destroy_tunnels(struct ip6_tnl_net *ip6n){	int h;	struct ip6_tnl *t;	for (h = 0; h < HASH_SIZE; h++) {		while ((t = ip6n->tnls_r_l[h]) != NULL)			unregister_netdevice(t->dev);	}	t = ip6n->tnls_wc[0];	unregister_netdevice(t->dev);}

static void __exit ip6ip6_destroy_tunnels(void){	int h;	struct ip6_tnl *t;	for (h = 0; h < HASH_SIZE; h++) {		while ((t = tnls_r_l[h]) != NULL)			unregister_netdevice(t->dev);	}	t = tnls_wc[0];	unregister_netdevice(t->dev);}

static int vrf_newlink(struct net *src_net, struct net_device *dev,		       struct nlattr *tb[], struct nlattr *data[]){	struct net_vrf *vrf = netdev_priv(dev);	int err;	if (!data || !data[IFLA_VRF_TABLE])		return -EINVAL;	vrf->tb_id = nla_get_u32(data[IFLA_VRF_TABLE]);	if (vrf->tb_id == RT_TABLE_UNSPEC)		return -EINVAL;	dev->priv_flags |= IFF_L3MDEV_MASTER;	err = register_netdevice(dev);	if (err)		goto out;	if (add_fib_rules) {		err = vrf_add_fib_rules(dev);		if (err) {			unregister_netdevice(dev);			goto out;		}		add_fib_rules = false;	}out:	return err;}

static struct net_device *ip6mr_reg_vif(struct net *net){	struct net_device *dev;	dev = alloc_netdev(0, "pim6reg", reg_vif_setup);	if (dev == NULL)		return NULL;	dev_net_set(dev, net);	if (register_netdevice(dev)) {		free_netdev(dev);		return NULL;	}	dev->iflink = 0;	if (dev_open(dev))		goto failure;	dev_hold(dev);	return dev;failure:	/* allow the register to be completed before unregistering. */	rtnl_unlock();	rtnl_lock();	unregister_netdevice(dev);	return NULL;}

void batadv_softif_destroy(struct net_device *soft_iface){	batadv_debugfs_del_meshif(soft_iface);	batadv_sysfs_del_meshif(soft_iface);	batadv_mesh_free(soft_iface);	unregister_netdevice(soft_iface);}

void unregister_hdlc_device(struct net_device *dev){	rtnl_lock();	hdlc_proto_detach(dev_to_hdlc(dev));	unregister_netdevice(dev);	rtnl_unlock();}

int br_del_bridge(char *name){	struct net_device *dev;	struct net_bridge *br;	dev = __dev_get_by_name(name);	if (!dev)		return -ENXIO;	if (dev->hard_start_xmit != br_dev_xmit)		return -EPERM;	if (dev->flags & IFF_UP)		return -EBUSY;	br = dev->priv;	BUG_ON(&br->dev != dev);	del_ifs(br);	unregister_netdevice(dev);	kfree(br);	br_dec_use_count();	return 0;}

static voidvhost_dellink(struct net_device *dev, struct list_head *head)#endif{    struct vhost_priv *vp;#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,33))    unregister_netdevice_queue(dev, head);#else    unregister_netdevice(dev);#endif    vp = netdev_priv(dev);    if (vp) {        if (vp->vp_db_index >= 0)            vhost_priv_db[vp->vp_db_index] = NULL;        vp->vp_db_index = -1;        if (vp->vp_phys_dev) {            vhost_del_tap_phys(vp->vp_phys_dev);            vp->vp_phys_dev = NULL;        }        vp->vp_phys_name[0] = '/0';    }    if (!vhost_num_interfaces)        BUG();    vhost_num_interfaces--;    return;}

static int hostap_disable_hostapd(PSDevice pDevice, int rtnl_locked){    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: disabling hostapd mode/n", pDevice->dev->name);    if (pDevice->apdev && pDevice->apdev->name && pDevice->apdev->name[0]) {		if (rtnl_locked)			unregister_netdevice(pDevice->apdev);		else			unregister_netdev(pDevice->apdev);            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: Netdevice %s unregistered/n",		       pDevice->dev->name, pDevice->apdev->name);	}	kfree(pDevice->apdev);	pDevice->apdev = NULL;    pDevice->bEnable8021x = false;    pDevice->bEnableHostWEP = false;    pDevice->bEncryptionEnable = false;//4.2007-0118-03,<Add> by EinsnLiu//execute some clear workpDevice->pMgmt->byCSSPK=KEY_CTL_NONE;pDevice->pMgmt->byCSSGK=KEY_CTL_NONE;KeyvInitTable(&pDevice->sKey,pDevice->PortOffset);	return 0;}

void softif_destroy(struct net_device *soft_iface){	debugfs_del_meshif(soft_iface);	sysfs_del_meshif(soft_iface);	mesh_free(soft_iface);	unregister_netdevice(soft_iface);}

/** *  @brief This function removes an virtual interface. * *  @param handle    A pointer to the moal_handle structure * *  @return        N/A */voidwoal_remove_virtual_interface(moal_handle *handle){	moal_private *priv = NULL;	int vir_intf = 0;	int i = 0;	ENTER();	rtnl_lock();	for (i = 0; i < handle->priv_num; i++) {		priv = handle->priv[i];		if (priv) {			if (priv->bss_virtual) {				PRINTM(MCMND, "Remove virtual interface %s/n",				       priv->netdev->name);#ifdef CONFIG_PROC_FS#ifdef PROC_DEBUG				/* Remove proc debug */				woal_debug_remove(priv);#endif /* PROC_DEBUG */				woal_proc_remove(priv);#endif /* CONFIG_PROC_FS */				netif_device_detach(priv->netdev);				if (priv->netdev->reg_state ==				    NETREG_REGISTERED)					unregister_netdevice(priv->netdev);				handle->priv[i] = NULL;				vir_intf++;			}		}	}	rtnl_unlock();	handle->priv_num -= vir_intf;	LEAVE();}

void cleanup_module(void) {	rtnl_lock();	unregister_qdisc(&the_master.qops);	unregister_netdevice(&the_master.dev);	rtnl_unlock();}

static struct net_device *ipmr_reg_vif(void){    struct net_device *dev;    struct in_device *in_dev;    dev = alloc_netdev(sizeof(struct net_device_stats), "pimreg",                       reg_vif_setup);    if (dev == NULL)        return NULL;    if (register_netdevice(dev)) {        free_netdev(dev);        return NULL;    }    dev->iflink = 0;    if ((in_dev = inetdev_init(dev)) == NULL)        goto failure;    in_dev->cnf.rp_filter = 0;    if (dev_open(dev))        goto failure;    return dev;failure:    unregister_netdevice(dev);    return NULL;}

static struct net_device *ipmr_reg_vif(void){	struct net_device *dev;	struct in_device *in_dev;	dev = alloc_netdev(sizeof(struct net_device_stats), "pimreg",			   reg_vif_setup);	if (dev == NULL)		return NULL;	if (register_netdevice(dev)) {		free_netdev(dev);		return NULL;	}	dev->iflink = 0;	if ((in_dev = inetdev_init(dev)) == NULL)		goto failure;	in_dev->cnf.rp_filter = 0;	if (dev_open(dev))		goto failure;	return dev;failure:	/* allow the register to be completed before unregistering. */	rtnl_unlock();	rtnl_lock();	unregister_netdevice(dev);	return NULL;}

void cleanup_module(void){	if ( inet_del_protocol(&ipip_protocol) < 0 )		printk(KERN_INFO "ipip close: can't remove protocol/n");	unregister_netdevice(&ipip_fb_tunnel_dev);}

/* * del_virtual_intf: remove the virtual interface determined by dev */int mwifiex_del_virtual_intf(struct wiphy *wiphy, struct net_device *dev){	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);#ifdef CONFIG_DEBUG_FS	mwifiex_dev_debugfs_remove(priv);#endif	if (!netif_queue_stopped(priv->netdev))		netif_stop_queue(priv->netdev);	if (netif_carrier_ok(priv->netdev))		netif_carrier_off(priv->netdev);	if (dev->reg_state == NETREG_REGISTERED)		unregister_netdevice(dev);	if (dev->reg_state == NETREG_UNREGISTERED)		free_netdev(dev);	/* Clear the priv in adapter */	priv->netdev = NULL;	priv->media_connected = false;	priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;	return 0;}

staticstruct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v){	struct net_device  *dev;	dev = __dev_get_by_name(net, "tunl0");	if (dev) {		const struct net_device_ops *ops = dev->netdev_ops;		int err;		struct ifreq ifr;		struct ip_tunnel_parm p;		struct in_device  *in_dev;		memset(&p, 0, sizeof(p));		p.iph.daddr = v->vifc_rmt_addr.s_addr;		p.iph.saddr = v->vifc_lcl_addr.s_addr;		p.iph.version = 4;		p.iph.ihl = 5;		p.iph.protocol = IPPROTO_IPIP;		sprintf(p.name, "dvmrp%d", v->vifc_vifi);		ifr.ifr_ifru.ifru_data = (__force void __user *)&p;		if (ops->ndo_do_ioctl) {			mm_segment_t oldfs = get_fs();			set_fs(KERNEL_DS);			err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);			set_fs(oldfs);		} else			err = -EOPNOTSUPP;		dev = NULL;		if (err == 0 &&		    (dev = __dev_get_by_name(net, p.name)) != NULL) {			dev->flags |= IFF_MULTICAST;			in_dev = __in_dev_get_rtnl(dev);			if (in_dev == NULL)				goto failure;			ipv4_devconf_setall(in_dev);			IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;			if (dev_open(dev))				goto failure;			dev_hold(dev);		}	}	return dev;failure:	/* allow the register to be completed before unregistering. */	rtnl_unlock();	rtnl_lock();	unregister_netdevice(dev);	return NULL;}

int qtnf_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev){	struct net_device *netdev =  wdev->netdev;	struct qtnf_vif *vif;	if (WARN_ON(!netdev))		return -EFAULT;	vif = qtnf_netdev_get_priv(wdev->netdev);	if (qtnf_cmd_send_del_intf(vif))		pr_err("VIF%u.%u: failed to delete VIF/n", vif->mac->macid,		       vif->vifid);	/* Stop data */	netif_tx_stop_all_queues(netdev);	if (netif_carrier_ok(netdev))		netif_carrier_off(netdev);	if (netdev->reg_state == NETREG_REGISTERED)		unregister_netdevice(netdev);	vif->netdev->ieee80211_ptr = NULL;	vif->netdev = NULL;	vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;	eth_zero_addr(vif->mac_addr);	return 0;}

int lowpan_register_netdevice(struct net_device *dev,			      enum lowpan_lltypes lltype){	int i, ret;	dev->addr_len = EUI64_ADDR_LEN;	dev->type = ARPHRD_6LOWPAN;	dev->mtu = IPV6_MIN_MTU;	dev->priv_flags |= IFF_NO_QUEUE;	lowpan_dev(dev)->lltype = lltype;	spin_lock_init(&lowpan_dev(dev)->ctx.lock);	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++)		lowpan_dev(dev)->ctx.table[i].id = i;	dev->ndisc_ops = &lowpan_ndisc_ops;	ret = register_netdevice(dev);	if (ret < 0)		return ret;	ret = lowpan_dev_debugfs_init(dev);	if (ret < 0)		unregister_netdevice(dev);	return ret;}

/** Jeff: this function should be called under ioctl (rtnl_lock is accquired) while* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)*/int rtw_change_ifname(_adapter *padapter, const char *ifname){	struct net_device *pnetdev;	struct net_device *cur_pnetdev;	struct rereg_nd_name_data *rereg_priv;	int ret;	if(!padapter)		goto error;	cur_pnetdev = padapter->pnetdev;	rereg_priv = &padapter->rereg_nd_name_priv;	//free the old_pnetdev	if(rereg_priv->old_pnetdev) {		free_netdev(rereg_priv->old_pnetdev);		rereg_priv->old_pnetdev = NULL;	}#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))	if(!rtnl_is_locked())		unregister_netdev(cur_pnetdev);	else#endif		unregister_netdevice(cur_pnetdev);	rereg_priv->old_pnetdev=cur_pnetdev;	pnetdev = rtw_init_netdev(padapter);	if (!pnetdev)  {		ret = -1;		goto error;	}	SET_NETDEV_DEV(pnetdev, dvobj_to_dev(adapter_to_dvobj(padapter)));	rtw_init_netdev_name(pnetdev, ifname);	_rtw_memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))	if(!rtnl_is_locked())		ret = register_netdev(pnetdev);	else#endif		ret = register_netdevice(pnetdev);	if ( ret != 0) {		RT_TRACE(_module_hci_intfs_c_,_drv_err_,("register_netdev() failed/n"));		goto error;	}	return 0;error:	return -1;}

static void veth_dellink(struct net_device *dev){	struct veth_priv *priv;	struct net_device *peer;	priv = netdev_priv(dev);	peer = priv->peer;	if (!list_empty(&priv->list))		list_del(&priv->list);	priv = netdev_priv(peer);	if (!list_empty(&priv->list))		list_del(&priv->list);	unregister_netdevice(dev);	unregister_netdevice(peer);}

void __exit sit_cleanup(void){	inet_del_protocol(&sit_protocol, IPPROTO_IPV6);	rtnl_lock();	sit_destroy_tunnels();	unregister_netdevice(ipip6_fb_tunnel_dev);	rtnl_unlock();}

static void __exit sit_cleanup(void){	xfrm4_tunnel_deregister(&sit_handler, AF_INET6);	rtnl_lock();	sit_destroy_tunnels();	unregister_netdevice(ipip6_fb_tunnel_dev);	rtnl_unlock();}

void unregister_hdlc_device(hdlc_device *hdlc){	if (hdlc_to_dev(hdlc)->name==NULL)		return;		/* device not registered */	destroy_pvc_list(hdlc);	unregister_netdevice(hdlc_to_dev(hdlc));	MOD_DEC_USE_COUNT;}

void sn_release_netdev(struct sn_device *dev){	rtnl_lock();	/* it is possible that the netdev has already been unregistered */	if (dev && dev->netdev && dev->netdev->reg_state == NETREG_REGISTERED)		unregister_netdevice(dev->netdev);	rtnl_unlock();}

static void internal_dev_destroy(struct vport *vport){	struct netdev_vport *netdev_vport = netdev_vport_priv(vport);	netif_stop_queue(netdev_vport->dev);	dev_set_promiscuity(netdev_vport->dev, -1);		unregister_netdevice(netdev_vport->dev);}

static void internal_dev_destroy(struct vport *vport){	struct netdev_vport *netdev_vport = netdev_vport_priv(vport);	netif_stop_queue(netdev_vport->dev);	dev_set_promiscuity(netdev_vport->dev, -1);	/* unregister_netdevice() waits for an RCU grace period. */	unregister_netdevice(netdev_vport->dev);}