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 int tun_chr_close(struct inode *inode, struct file *file) { struct tun_struct *tun = (struct tun_struct *)file->private_data; if (!tun) return 0; DBG(KERN_INFO "%s: tun_chr_close\n", tun->name); tun_chr_fasync(-1, file, 0); rtnl_lock(); /* Detach from net device */ file->private_data = NULL; tun->attached = 0; /* Drop read queue */ skb_queue_purge(&tun->readq); if (!(tun->flags & TUN_PERSIST)) { dev_close(&tun->dev); unregister_netdevice(&tun->dev); kfree(tun); MOD_DEC_USE_COUNT; } rtnl_unlock(); return 0; }
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 void vhost_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 work pDevice->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 */ void woal_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; }
static struct 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); }