void nf_conntrack_l3proto_unregister(struct nf_conntrack_l3proto *proto) { struct net *net; BUG_ON(proto->l3proto >= AF_MAX); mutex_lock(&nf_ct_proto_mutex); BUG_ON(nf_ct_l3protos[proto->l3proto] != proto); rcu_assign_pointer(nf_ct_l3protos[proto->l3proto], &nf_conntrack_l3proto_generic); nf_ct_l3proto_unregister_sysctl(proto); mutex_unlock(&nf_ct_proto_mutex); synchronize_rcu(); /* Remove all contrack entries for this protocol */ rtnl_lock(); for_each_net(net) nf_ct_iterate_cleanup(net, kill_l3proto, proto); rtnl_unlock(); }
static int mlxsw_sp_dpipe_table_erif_counters_update(void *priv, bool enable) { struct mlxsw_sp *mlxsw_sp = priv; int i; rtnl_lock(); for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) { struct mlxsw_sp_rif *rif = mlxsw_sp_rif_by_index(mlxsw_sp, i); if (!rif) continue; if (enable) mlxsw_sp_rif_counter_alloc(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS); else mlxsw_sp_rif_counter_free(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS); } rtnl_unlock(); return 0; }
void ip_mc_drop_socket(struct sock *sk) { struct ip_mc_socklist *iml; if (sk->protinfo.af_inet.mc_list == NULL) return; rtnl_lock(); while ((iml=sk->protinfo.af_inet.mc_list) != NULL) { struct in_device *in_dev; sk->protinfo.af_inet.mc_list = iml->next; if ((in_dev = inetdev_by_index(iml->multi.imr_ifindex)) != NULL) { ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr); in_dev_put(in_dev); } sock_kfree_s(sk, iml, sizeof(*iml)); } rtnl_unlock(); }
static void enic_reset(struct work_struct *work) { struct enic *enic = container_of(work, struct enic, reset); if (!netif_running(enic->netdev)) return; rtnl_lock(); spin_lock(&enic->devcmd_lock); vnic_dev_hang_notify(enic->vdev); spin_unlock(&enic->devcmd_lock); enic_stop(enic->netdev); enic_dev_soft_reset(enic); enic_reset_mcaddrs(enic); enic_init_vnic_resources(enic); enic_open(enic->netdev); rtnl_unlock(); }
static int __init ifb_init_module(void) { int i, err; rtnl_lock(); err = __rtnl_link_register(&ifb_link_ops); if (err < 0) goto out; for (i = 0; i < numifbs && !err; i++) { err = ifb_init_one(i); cond_resched(); } if (err) __rtnl_link_unregister(&ifb_link_ops); out: rtnl_unlock(); return err; }
static ssize_t store_stp_state(struct device *d, struct device_attribute *attr, const char *buf, size_t len) { struct net_bridge *br = to_bridge(d); char *endp; unsigned long val; if (!capable(CAP_NET_ADMIN)) return -EPERM; val = simple_strtoul(buf, &endp, 0); if (endp == buf) return -EINVAL; rtnl_lock(); br_stp_set_enabled(br, val); rtnl_unlock(); return len; }
static void packet_flush_mclist(struct sock *sk) { struct packet_opt *po = pkt_sk(sk); struct packet_mclist *ml; if (!po->mclist) return; rtnl_lock(); while ((ml = po->mclist) != NULL) { struct net_device *dev; po->mclist = ml->next; if ((dev = dev_get_by_index(ml->ifindex)) != NULL) { packet_dev_mc(dev, ml, -1); dev_put(dev); } kfree(ml); } 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; rcu_read_lock(); if ((in_dev = __in_dev_get_rcu(dev)) == NULL) { rcu_read_unlock(); goto failure; } ipv4_devconf_setall(in_dev); IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0; rcu_read_unlock(); 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; }
int register_netdev(struct net_device *dev) { int err; rtnl_lock(); /* * If the name is a format string the caller wants us to * do a name allocation */ if (strchr(dev->name, '%')) { err = -EBUSY; if(dev_alloc_name(dev, dev->name)<0) goto out; } /* * Back compatibility hook. Kill this one in 2.5 */ if (dev->name[0]==0 || dev->name[0]==' ') { err = -EBUSY; if(dev_alloc_name(dev, "eth%d")<0) goto out; } err = -EIO; if (register_netdevice(dev)) goto out; err = 0; out: rtnl_unlock(); return err; }
static int __init pxa250_irda_init(void) { struct net_device *dev; int err; /* STUART */ err = request_mem_region(__PREG(STRBR), 0x24, "IrDA") ? 0 : -EBUSY; if (err) goto err_mem_1; /* FIR */ err = request_mem_region(__PREG(ICCR0), 0x1c, "IrDA") ? 0 : -EBUSY; if (err) goto err_mem_2; rtnl_lock(); dev = dev_alloc("irda%d", &err); if (dev) { dev->irq = IRQ_STUART; dev->init = pxa250_irda_net_init; dev->uninit = pxa250_irda_net_uninit; err = register_netdevice(dev); if (err) kfree(dev); else netdev = dev; } rtnl_unlock(); if (err) { release_mem_region(__PREG(ICCR0), 0x1c); err_mem_2: release_mem_region(__PREG(STRBR), 0x24); } err_mem_1: return err; }
void ieee80211_unregister_hw(struct ieee80211_hw *hw) { struct ieee80211_local *local = hw_to_local(hw); tasklet_kill(&local->tx_pending_tasklet); tasklet_kill(&local->tasklet); pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY, &local->network_latency_notifier); rtnl_lock(); /* * At this point, interface list manipulations are fine * because the driver cannot be handing us frames any * more and the tasklet is killed. */ ieee80211_remove_interfaces(local); rtnl_unlock(); cancel_work_sync(&local->reconfig_filter); ieee80211_clear_tx_pending(local); sta_info_stop(local); rate_control_deinitialize(local); if (skb_queue_len(&local->skb_queue) || skb_queue_len(&local->skb_queue_unreliable)) printk(KERN_WARNING "%s: skb_queue not empty\n", wiphy_name(local->hw.wiphy)); skb_queue_purge(&local->skb_queue); skb_queue_purge(&local->skb_queue_unreliable); destroy_workqueue(local->workqueue); wiphy_unregister(local->hw.wiphy); ieee80211_wep_free(local); ieee80211_led_exit(local); kfree(local->int_scan_req); }
void efx_ef10_sriov_fini(struct efx_nic *efx) { #ifdef CONFIG_SFC_SRIOV struct efx_ef10_nic_data *nic_data = efx->nic_data; unsigned int i; int rc; if (!nic_data->vf) { /* Remove any un-assigned orphaned VFs */ #if !defined(EFX_USE_KCOMPAT) || defined(EFX_HAVE_PCI_DEV_FLAGS_ASSIGNED) if (pci_num_vf(efx->pci_dev) && !pci_vfs_assigned(efx->pci_dev)) #endif pci_disable_sriov(efx->pci_dev); return; } /* Remove any VFs in the host */ for (i = 0; i < efx->vf_count; ++i) { struct efx_nic *vf_efx = nic_data->vf[i].efx; if (vf_efx) { efx_device_detach_sync(vf_efx); rtnl_lock(); efx_net_stop(vf_efx->net_dev); rtnl_unlock(); down_write(&vf_efx->filter_sem); vf_efx->type->filter_table_remove(vf_efx); up_write(&vf_efx->filter_sem); efx_ef10_vadaptor_free(vf_efx, EVB_PORT_ID_ASSIGNED); vf_efx->pci_dev->driver->remove(vf_efx->pci_dev); } } rc = efx_ef10_pci_sriov_disable(efx, true); if (rc) netif_dbg(efx, drv, efx->net_dev, "Disabling SRIOV was not successful rc=%d\n", rc); else netif_dbg(efx, drv, efx->net_dev, "SRIOV disabled\n"); #endif }
static int unregister_vlan_device(const char *vlan_IF_name) { struct net_device *dev = NULL; int ret; dev = dev_get_by_name(vlan_IF_name); ret = -EINVAL; if (dev) { if (dev->priv_flags & IFF_802_1Q_VLAN) { rtnl_lock(); ret = unregister_vlan_dev(VLAN_DEV_INFO(dev)->real_dev, VLAN_DEV_INFO(dev)->vlan_id); dev_put(dev); unregister_netdevice(dev); rtnl_unlock(); if (ret == 1) ret = 0; } else { printk(VLAN_ERR "%s: ERROR: Tried to remove a non-vlan device " "with VLAN code, name: %s priv_flags: %hX\n", __FUNCTION__, dev->name, dev->priv_flags); dev_put(dev); ret = -EPERM; } } else { #ifdef VLAN_DEBUG printk(VLAN_DBG "%s: WARNING: Could not find dev.\n", __FUNCTION__); #endif ret = -EINVAL; } return ret; }
static void __exit rh_release(void) { unsigned int sum = 0; int i; pr_info("rxhook (v%s) is unloaded\n", RXHOOK_VERSION); rtnl_lock(); netdev_rx_handler_unregister(rh->dev); rtnl_unlock(); kfree(rh); rh = NULL; for(i = 0; i < 10; i++) { pr_info("pps[%d] = %d\n", i, pps[i]); sum += pps[i]; } pr_info("sum: %u\n", sum); return; }
static int tun_chr_close(struct inode *inode, struct file *file) { struct tun_struct *tun = (struct tun_struct *)file->private_data; DBG(KERN_INFO "%s: tun_chr_close\n", tun->name); if (tun->flags & TUN_IFF_SET) { rtnl_lock(); dev_close(&tun->dev); rtnl_unlock(); /* Drop TX queue */ skb_queue_purge(&tun->txq); unregister_netdev(&tun->dev); } kfree(tun); file->private_data = NULL; return 0; }
/* * Write mgmt frame to this file to send it */ static ssize_t wil_write_file_txmgmt(struct file *file, const char __user *buf, size_t len, loff_t *ppos) { struct wil6210_priv *wil = file->private_data; #if 0 struct net_device *ndev = wil_to_ndev(wil); #endif struct wiphy *wiphy = wil_to_wiphy(wil); struct wireless_dev *wdev = wil_to_wdev(wil); int rc; void *frame = kmalloc(len, GFP_KERNEL); if (!frame) return -ENOMEM; if (copy_from_user(frame, buf, len)) return -EIO; #if 0 rc = wmi_set_channel(wil, 1); if (rc) return rc; rc = wmi_call(wil, WMI_RX_ON_CMDID, NULL, 0, WMI_RX_ON_DONE_EVENTID, NULL, 0, 20); if (rc) return rc; #endif rc = wil_cfg80211_mgmt_tx(wiphy, wdev, wdev->preset_chandef.chan, true, 0, frame, len, true, false, NULL); kfree(frame); wil_info(wil, "%s() -> %d\n", __func__, rc); #if 0 msleep(300); rtnl_lock(); dev_close(ndev); ndev->flags &= ~IFF_UP; rtnl_unlock(); wil_reset(wil); #endif return len; }
/* * Handle link status changes. For RNDIS_STATUS_NETWORK_CHANGE emulate link * down/up sequence. In case of RNDIS_STATUS_MEDIA_CONNECT when carrier is * present send GARP packet to network peers with netif_notify_peers(). */ static void netvsc_link_change(struct work_struct *w) { struct net_device_context *ndev_ctx = container_of(w, struct net_device_context, dwork.work); struct hv_device *device_obj = ndev_ctx->device_ctx; struct net_device *net = hv_get_drvdata(device_obj); struct netvsc_device *net_device; struct rndis_device *rdev; struct netvsc_reconfig *event = NULL; bool notify = false, reschedule = false; unsigned long flags, next_reconfig, delay; rtnl_lock(); if (ndev_ctx->start_remove) goto out_unlock; net_device = ndev_ctx->nvdev; rdev = net_device->extension; next_reconfig = ndev_ctx->last_reconfig + LINKCHANGE_INT; if (time_is_after_jiffies(next_reconfig)) { /* link_watch only sends one notification with current state * per second, avoid doing reconfig more frequently. Handle * wrap around. */ delay = next_reconfig - jiffies; delay = delay < LINKCHANGE_INT ? delay : LINKCHANGE_INT; schedule_delayed_work(&ndev_ctx->dwork, delay); goto out_unlock; } ndev_ctx->last_reconfig = jiffies; spin_lock_irqsave(&ndev_ctx->lock, flags); if (!list_empty(&ndev_ctx->reconfig_events)) { event = list_first_entry(&ndev_ctx->reconfig_events, struct netvsc_reconfig, list); list_del(&event->list); reschedule = !list_empty(&ndev_ctx->reconfig_events); }
static void __exit pxa250_irda_exit(void) { struct net_device *dev = netdev; netdev = NULL; if (dev) { rtnl_lock(); unregister_netdevice(dev); rtnl_unlock(); } release_mem_region(__PREG(ICCR0), 0x1c); release_mem_region(__PREG(STRBR), 0x24); /* * We now know that the netdevice is no longer in use, and all * references to our driver have been removed. The only structure * which may still be present is the netdevice, which will get * cleaned up by net/core/dev.c */ }
static int __init rh_init(void) { int rc = 0, err; int i; pr_info("rxhook (v%s) is loaded\n", RXHOOK_VERSION); rh = kmalloc(sizeof(struct rh_dev), GFP_KERNEL); if (rh == 0) { pr_info("fail to kmalloc: *rh_dev\n"); rc = -1; goto out; } rh->dev = dev_get_by_name(&init_net, ifname); if (!rh->dev) { pr_err("Could not find %s\n", ifname); rc = -1; goto out; } rh->cpu = smp_processor_id(); pr_info("cpuid: %d\n", rh->cpu); // register rtnl_lock(); err = netdev_rx_handler_register(rh->dev, rh_handle_frame, rh); rtnl_unlock(); if (err) { pr_err("%s failed to register rx_handler\n", ifname); } for(i = 0; i < 10; i++) pps[i] = 0; out: return rc; }
/* * Send GARP packet to network peers after migrations. * After Quick Migration, the network is not immediately operational in the * current context when receiving RNDIS_STATUS_MEDIA_CONNECT event. So, add * another netif_notify_peers() into a delayed work, otherwise GARP packet * will not be sent after quick migration, and cause network disconnection. * Also, we update the carrier status here. */ static void netvsc_link_change(void *data) { struct delayed_work *w = (struct delayed_work *)data; struct net_device_context *ndev_ctx; struct net_device *net; struct netvsc_device *net_device; struct rndis_device *rdev; bool notify, refresh = false; char *argv[] = { "/etc/init.d/network", "restart", NULL }; char *envp[] = { "HOME=/", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL }; rtnl_lock(); ndev_ctx = container_of(w, struct net_device_context, dwork); net_device = hv_get_drvdata(ndev_ctx->device_ctx); rdev = net_device->extension; net = net_device->ndev; if (rdev->link_state) { netif_carrier_off(net); notify = false; } else { netif_carrier_on(net); notify = true; if (rdev->link_change) { rdev->link_change = false; refresh = true; } } rtnl_unlock(); if (refresh) call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); if (notify) netif_notify_peers(net); }
int __init teql_init(void) #endif { int err; rtnl_lock(); the_master.dev.priv = (void*)&the_master; err = dev_alloc_name(&the_master.dev, "teql%d"); if (err < 0) return err; memcpy(the_master.qops.id, the_master.dev.name, IFNAMSIZ); the_master.dev.init = teql_master_init; err = register_netdevice(&the_master.dev); if (err == 0) { err = register_qdisc(&the_master.qops); if (err) unregister_netdevice(&the_master.dev); } rtnl_unlock(); return err; }
static int wiphy_suspend(struct device *dev, pm_message_t state) { struct cfg80211_registered_device *rdev = dev_to_rdev(dev); int ret = 0; rdev->suspend_at = get_seconds(); rtnl_lock(); if (rdev->wiphy.registered) { if (!rdev->wiphy.wowlan_config) cfg80211_leave_all(rdev); if (rdev->ops->suspend) ret = rdev_suspend(rdev, rdev->wiphy.wowlan_config); if (ret == 1) { /* Driver refuse to configure wowlan */ cfg80211_leave_all(rdev); ret = rdev_suspend(rdev, NULL); } } rtnl_unlock(); return ret; }
/* * Close down an X.25 channel. * This means flushing out any pending queues, and then restoring the * TTY line discipline to what it was before it got hooked to X.25 * (which usually is TTY again). */ static void x25_asy_close_tty(struct tty_struct *tty) { struct x25_asy *sl = tty->disc_data; int err; /* First make sure we're connected. */ if (!sl || sl->magic != X25_ASY_MAGIC) return; rtnl_lock(); if (sl->dev->flags & IFF_UP) dev_close(sl->dev); rtnl_unlock(); err = lapb_unregister(sl->dev); if (err != LAPB_OK) pr_err("x25_asy_close: lapb_unregister error: %d\n", err); tty->disc_data = NULL; sl->tty = NULL; x25_asy_free(sl); }
static struct vport *gre_tnl_create(const struct vport_parms *parms) { struct net *net = ovs_dp_get_net(parms->dp); struct net_device *dev; struct vport *vport; vport = ovs_vport_alloc(0, &ovs_gre_vport_ops, parms); if (IS_ERR(vport)) return vport; rtnl_lock(); dev = gretap_fb_dev_create(net, parms->name, NET_NAME_USER); if (IS_ERR(dev)) { rtnl_unlock(); ovs_vport_free(vport); return ERR_CAST(dev); } dev_change_flags(dev, dev->flags | IFF_UP); rtnl_unlock(); return vport; }
static int brc_add_del_port(struct net_device *dev, int port_ifindex, int add) { struct sk_buff *request; struct net_device *port; int err; port = __dev_get_by_index(&init_net, port_ifindex); if (!port) return -EINVAL; /* Save name of dev and port because there's a race between the * rtnl_unlock() and the brc_send_simple_command(). */ request = brc_make_request(add ? BRC_GENL_C_PORT_ADD : BRC_GENL_C_PORT_DEL, dev->name, port->name); if (!request) return -ENOMEM; rtnl_unlock(); err = brc_send_simple_command(request); rtnl_lock(); return err; }
static void restore_slaves(struct net_device *hsr_dev) { struct hsr_priv *hsr_priv; int i; int res; hsr_priv = netdev_priv(hsr_dev); rtnl_lock(); /* Restore promiscuity */ for (i = 0; i < HSR_MAX_SLAVE; i++) { if (!hsr_priv->slave[i]) continue; res = dev_set_promiscuity(hsr_priv->slave[i], -1); if (res) netdev_info(hsr_dev, "Cannot restore slave promiscuity (%s, %d)\n", hsr_priv->slave[i]->name, res); } rtnl_unlock(); }
static ssize_t ieee80211_if_write( struct ieee80211_sub_if_data *sdata, const char __user *userbuf, size_t count, loff_t *ppos, ssize_t (*write)(struct ieee80211_sub_if_data *, const char *, int)) { char buf[64]; ssize_t ret; if (count >= sizeof(buf)) return -E2BIG; if (copy_from_user(buf, userbuf, count)) return -EFAULT; buf[count] = '\0'; ret = -ENODEV; rtnl_lock(); ret = (*write)(sdata, buf, count); rtnl_unlock(); return ret; }
static ssize_t ieee80211_if_write( struct ieee80211_sub_if_data *sdata, const char __user *userbuf, size_t count, loff_t *ppos, ssize_t (*write)(struct ieee80211_sub_if_data *, const char *, int)) { u8 *buf; ssize_t ret = -ENODEV; buf = kzalloc(count, GFP_KERNEL); if (!buf) return -ENOMEM; if (copy_from_user(buf, userbuf, count)) return -EFAULT; rtnl_lock(); if (sdata->dev->reg_state == NETREG_REGISTERED) ret = (*write)(sdata, buf, count); rtnl_unlock(); return ret; }
static ssize_t set_phy_flash_cfg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct efx_nic *efx = pci_get_drvdata(to_pci_dev(dev)); enum efx_phy_mode old_mode, new_mode; int err; rtnl_lock(); old_mode = efx->phy_mode; if (count == 0 || *buf == '0') new_mode = old_mode & ~PHY_MODE_SPECIAL; else new_mode = PHY_MODE_SPECIAL; if (old_mode == new_mode) { err = 0; } else if (efx->state != STATE_RUNNING || netif_running(efx->net_dev)) { err = -EBUSY; } else { /* Reset the PHY, reconfigure the MAC and enable/disable * MAC stats accordingly. */ efx->phy_mode = new_mode; if (new_mode & PHY_MODE_SPECIAL) falcon_stop_nic_stats(efx); if (falcon_board(efx)->type->id == FALCON_BOARD_SFE4001) err = sfe4001_poweron(efx); else err = sfn4111t_reset(efx); if (!err) err = efx_reconfigure_port(efx); if (!(new_mode & PHY_MODE_SPECIAL)) falcon_start_nic_stats(efx); } rtnl_unlock(); return err ? err : count; }
int ieee802154_disassociate_req(struct sk_buff *skb, struct genl_info *info) { struct net_device *dev; struct ieee802154_addr addr; int ret = -EOPNOTSUPP; if ((!info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] && !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]) || !info->attrs[IEEE802154_ATTR_REASON]) return -EINVAL; dev = ieee802154_nl_get_dev(info); if (!dev) return -ENODEV; if (!ieee802154_mlme_ops(dev)->disassoc_req) goto out; if (info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]) { addr.mode = IEEE802154_ADDR_LONG; addr.extended_addr = nla_get_hwaddr( info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]); } else { addr.mode = IEEE802154_ADDR_SHORT; addr.short_addr = nla_get_shortaddr( info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]); } rtnl_lock(); addr.pan_id = dev->ieee802154_ptr->pan_id; rtnl_unlock(); ret = ieee802154_mlme_ops(dev)->disassoc_req(dev, &addr, nla_get_u8(info->attrs[IEEE802154_ATTR_REASON])); out: dev_put(dev); return ret; }