static __init int can_dev_init(void) { int err; can_led_notifier_init(); err = rtnl_link_register(&can_link_ops); if (!err) printk(KERN_INFO MOD_DESC "\n"); return err; }
static int __init ipgre_init(void) { int err; pr_info("GRE over IPv4 tunneling driver\n"); err = register_pernet_device(&ipgre_net_ops); if (err < 0) return err; err = register_pernet_device(&ipgre_tap_net_ops); if (err < 0) goto pnet_tap_faied; err = gre_cisco_register(&ipgre_protocol); if (err < 0) { pr_info("%s: can't add protocol\n", __func__); goto add_proto_failed; } err = rtnl_link_register(&ipgre_link_ops); if (err < 0) goto rtnl_link_failed; err = rtnl_link_register(&ipgre_tap_ops); if (err < 0) goto tap_ops_failed; return 0; tap_ops_failed: rtnl_link_unregister(&ipgre_link_ops); rtnl_link_failed: gre_cisco_unregister(&ipgre_protocol); add_proto_failed: unregister_pernet_device(&ipgre_tap_net_ops); pnet_tap_faied: unregister_pernet_device(&ipgre_net_ops); return err; }
static int __init vti_init(void) { const char *msg; int err; pr_info("IPv4 over IPsec tunneling driver\n"); msg = "tunnel device"; err = register_pernet_device(&vti_net_ops); if (err < 0) goto pernet_dev_failed; msg = "tunnel protocols"; err = xfrm4_protocol_register(&vti_esp4_protocol, IPPROTO_ESP); if (err < 0) goto xfrm_proto_esp_failed; err = xfrm4_protocol_register(&vti_ah4_protocol, IPPROTO_AH); if (err < 0) goto xfrm_proto_ah_failed; err = xfrm4_protocol_register(&vti_ipcomp4_protocol, IPPROTO_COMP); if (err < 0) goto xfrm_proto_comp_failed; msg = "ipip tunnel"; err = xfrm4_tunnel_register(&ipip_handler, AF_INET); if (err < 0) { pr_info("%s: cant't register tunnel\n",__func__); goto xfrm_tunnel_failed; } msg = "netlink interface"; err = rtnl_link_register(&vti_link_ops); if (err < 0) goto rtnl_link_failed; return err; rtnl_link_failed: xfrm4_protocol_deregister(&vti_ipcomp4_protocol, IPPROTO_COMP); xfrm_tunnel_failed: xfrm4_tunnel_deregister(&ipip_handler, AF_INET); xfrm_proto_comp_failed: xfrm4_protocol_deregister(&vti_ah4_protocol, IPPROTO_AH); xfrm_proto_ah_failed: xfrm4_protocol_deregister(&vti_esp4_protocol, IPPROTO_ESP); xfrm_proto_esp_failed: unregister_pernet_device(&vti_net_ops); pernet_dev_failed: pr_err("vti init: failed to register %s\n", msg); return err; }
int ovs_internal_dev_rtnl_link_register(void) { int err; err = rtnl_link_register(&internal_dev_link_ops); if (err < 0) return err; err = ovs_vport_ops_register(&ovs_internal_vport_ops); if (err < 0) rtnl_link_unregister(&internal_dev_link_ops); return err; }
int __init br_netlink_init(void) { int err; br_mdb_init(); err = rtnl_link_register(&br_link_ops); if (err) goto out; return 0; out: br_mdb_uninit(); return err; }
static int __init vti_init(void) { int err; pr_info("IPv4 over IPSec tunneling driver\n"); err = register_pernet_device(&vti_net_ops); if (err < 0) return err; err = xfrm4_protocol_register(&vti_esp4_protocol, IPPROTO_ESP); if (err < 0) { unregister_pernet_device(&vti_net_ops); pr_info("vti init: can't register tunnel\n"); return err; } err = xfrm4_protocol_register(&vti_ah4_protocol, IPPROTO_AH); if (err < 0) { xfrm4_protocol_deregister(&vti_esp4_protocol, IPPROTO_ESP); unregister_pernet_device(&vti_net_ops); pr_info("vti init: can't register tunnel\n"); return err; } err = xfrm4_protocol_register(&vti_ipcomp4_protocol, IPPROTO_COMP); if (err < 0) { xfrm4_protocol_deregister(&vti_ah4_protocol, IPPROTO_AH); xfrm4_protocol_deregister(&vti_esp4_protocol, IPPROTO_ESP); unregister_pernet_device(&vti_net_ops); pr_info("vti init: can't register tunnel\n"); return err; } err = rtnl_link_register(&vti_link_ops); if (err < 0) goto rtnl_link_failed; return err; rtnl_link_failed: xfrm4_protocol_deregister(&vti_ipcomp4_protocol, IPPROTO_COMP); xfrm4_protocol_deregister(&vti_ah4_protocol, IPPROTO_AH); xfrm4_protocol_deregister(&vti_esp4_protocol, IPPROTO_ESP); unregister_pernet_device(&vti_net_ops); return err; }
static int __init rmnet_init(void) { int rc; rc = register_netdevice_notifier(&rmnet_dev_notifier); if (rc != 0) return rc; rc = rtnl_link_register(&rmnet_link_ops); if (rc != 0) { unregister_netdevice_notifier(&rmnet_dev_notifier); return rc; } return rc; }
static int __init vrf_init_module(void) { int rc; register_netdevice_notifier(&vrf_notifier_block); rc = rtnl_link_register(&vrf_link_ops); if (rc < 0) goto error; return 0; error: unregister_netdevice_notifier(&vrf_notifier_block); return rc; }
static int vhost_netlink_init(void) { int ret; if (vhost_drv_inited) return 0; ret = rtnl_link_register(&vhost_link_ops); if (ret) { return ret; } vhost_drv_inited = true; return 0; }
static int __init vti_init(void) { const char *msg; int err; pr_info("IPv4 over IPsec tunneling driver\n"); register_netdevice_notifier(&vti_notifier_block); msg = "tunnel device"; err = register_pernet_device(&vti_net_ops); if (err < 0) goto pernet_dev_failed; msg = "tunnel protocols"; err = xfrm4_protocol_register(&vti_esp4_protocol, IPPROTO_ESP); if (err < 0) goto xfrm_proto_esp_failed; err = xfrm4_protocol_register(&vti_ah4_protocol, IPPROTO_AH); if (err < 0) goto xfrm_proto_ah_failed; err = xfrm4_protocol_register(&vti_ipcomp4_protocol, IPPROTO_COMP); if (err < 0) goto xfrm_proto_comp_failed; msg = "netlink interface"; err = rtnl_link_register(&vti_link_ops); if (err < 0) goto rtnl_link_failed; return err; rtnl_link_failed: xfrm4_protocol_deregister(&vti_ipcomp4_protocol, IPPROTO_COMP); xfrm_proto_comp_failed: xfrm4_protocol_deregister(&vti_ah4_protocol, IPPROTO_AH); xfrm_proto_ah_failed: xfrm4_protocol_deregister(&vti_esp4_protocol, IPPROTO_ESP); xfrm_proto_esp_failed: unregister_pernet_device(&vti_net_ops); pernet_dev_failed: unregister_netdevice_notifier(&vti_notifier_block); pr_err("vti init: failed to register %s\n", msg); return err; }
int __init hsr_netlink_init(void) { int rc; rc = rtnl_link_register(&hsr_link_ops); if (rc) goto fail_rtnl_link_register; rc = genl_register_family_with_ops_groups(&hsr_genl_family, hsr_ops, hsr_mcgrps); if (rc) goto fail_genl_register_family; return 0; fail_genl_register_family: rtnl_link_unregister(&hsr_link_ops); fail_rtnl_link_register: return rc; }
static int __init ipip_init(void) { int err; pr_info("ipip: IPv4 and MPLS over IPv4 tunneling driver\n"); err = register_pernet_device(&ipip_net_ops); if (err < 0) return err; err = xfrm4_tunnel_register(&ipip_handler, AF_INET); if (err < 0) { pr_info("%s: can't register tunnel\n", __func__); goto xfrm_tunnel_ipip_failed; } #if IS_ENABLED(CONFIG_MPLS) err = xfrm4_tunnel_register(&mplsip_handler, AF_MPLS); if (err < 0) { pr_info("%s: can't register tunnel\n", __func__); goto xfrm_tunnel_mplsip_failed; } #endif err = rtnl_link_register(&ipip_link_ops); if (err < 0) goto rtnl_link_failed; out: return err; rtnl_link_failed: #if IS_ENABLED(CONFIG_MPLS) xfrm4_tunnel_deregister(&mplsip_handler, AF_INET); xfrm_tunnel_mplsip_failed: #endif xfrm4_tunnel_deregister(&ipip_handler, AF_INET); xfrm_tunnel_ipip_failed: unregister_pernet_device(&ipip_net_ops); goto out; }
static __init int deth_init(void) { int rc; printk(KERN_DEBUG "[Module %s %s loaded]\n", DRV_NAME, DRV_VERSION); rc = register_pernet_subsys(&deth_net_ops); if (rc != 0) { return rc; } rc = rtnl_link_register(&deth_link_ops); if (rc != 0) { unregister_pernet_subsys(&deth_net_ops); } return rc; }
int __init br_netlink_init(void) { int err; err = rtnl_link_register(&br_link_ops); if (err < 0) goto err1; err = __rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, br_dump_ifinfo, NULL); if (err) goto err2; err = __rtnl_register(PF_BRIDGE, RTM_SETLINK, br_rtm_setlink, NULL, NULL); if (err) goto err3; err = __rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, br_fdb_add, NULL, NULL); if (err) goto err3; err = __rtnl_register(PF_BRIDGE, RTM_DELNEIGH, br_fdb_delete, NULL, NULL); if (err) goto err3; err = __rtnl_register(PF_BRIDGE, RTM_GETNEIGH, NULL, br_fdb_dump, NULL); if (err) goto err3; return 0; err3: rtnl_unregister_all(PF_BRIDGE); err2: rtnl_link_unregister(&br_link_ops); err1: return err; }
static int __init nsim_module_init(void) { int err; err = nsim_dev_init(); if (err) return err; err = nsim_bus_init(); if (err) goto err_dev_exit; err = rtnl_link_register(&nsim_link_ops); if (err) goto err_bus_exit; return 0; err_bus_exit: nsim_bus_exit(); err_dev_exit: nsim_dev_exit(); return err; }
static __init int veth_init(void) { return rtnl_link_register(&veth_link_ops); }
int __init ipoib_netlink_init(void) { return rtnl_link_register(&ipoib_link_ops); }
static __init int nlmon_register(void) { return rtnl_link_register(&nlmon_link_ops); }
int ovs_internal_dev_rtnl_link_register(void) { return rtnl_link_register(&internal_dev_link_ops); }
static __init int vxcan_init(void) { pr_info("vxcan: Virtual CAN Tunnel driver\n"); return rtnl_link_register(&vxcan_link_ops); }
static int micveth_probe_int(micveth_info_t *veth_info, mic_ctx_t *mic_ctx) { struct net_device *dev_veth; ring_queue_t *queue; ring_desc_t *desc; ring_packet_t *packet; int idx; int err = 0; veth_info->vi_pdev = mic_ctx->bi_pdev; veth_info->vi_sbox = (uint8_t *)((unsigned long)mic_ctx->mmio.va + HOST_SBOX_BASE_ADDRESS); veth_info->vi_scratch14 = (uint32_t *)((unsigned long)mic_ctx->mmio.va + HOST_SBOX_BASE_ADDRESS + SBOX_SCRATCH14); veth_info->vi_scratch15 = (uint32_t *)((unsigned long)mic_ctx->mmio.va + HOST_SBOX_BASE_ADDRESS + SBOX_SCRATCH15); veth_info->mic_ctx = mic_ctx; mic_ctx->bi_vethinfo = (void *)veth_info; spin_lock_init(&veth_info->vi_txlock); spin_lock_init(&veth_info->vi_rxlock); if (mic_vnet_mode == VNET_MODE_POLL) INIT_DELAYED_WORK(&veth_info->vi_poll, micveth_poll); // Set the current sk_buff allocation size veth_info->vi_skb_mtu = MICVETH_MAX_PACKET_SIZE + 32; // Get the physical memory address for the ring descriptors veth_info->vi_ring.phys = mic_ctx_map_single(veth_to_ctx(veth_info), &veth_info->vi_ring.ring, sizeof(veth_ring_t)); veth_info->vi_ring.length = sizeof(veth_ring_t); queue = &veth_info->vi_ring.ring.r_tx; queue->rq_head = 0; queue->rq_tail = 0; queue->rq_length = MICVETH_TRANSFER_FIFO_SIZE; veth_info->vi_pend = 0; packet = &veth_info->vi_tx_desc[0]; for (idx = 0; idx < queue->rq_length; idx++) { desc = &queue->rq_descs[idx]; packet[idx].pd_skb = NULL; packet[idx].pd_phys = 0; packet[idx].pd_length = 0; desc->rd_phys = 0; desc->rd_length = 0; desc->rd_valid = 0; } // This is the recieve end. queue = &veth_info->vi_ring.ring.r_rx; queue->rq_head = 0; queue->rq_tail = 0; queue->rq_length = MICVETH_TRANSFER_FIFO_SIZE; packet = &veth_info->vi_rx_desc[0]; for (idx = 0; idx < queue->rq_length; idx++) { desc = &queue->rq_descs[idx]; if (!(packet[idx].pd_skb = dev_alloc_skb(veth_info->vi_skb_mtu))) return -ENOMEM; packet[idx].pd_phys = mic_ctx_map_single(veth_to_ctx(veth_info), packet[idx].pd_skb->data, veth_info->vi_skb_mtu); packet[idx].pd_length = veth_info->vi_skb_mtu; desc->rd_phys = packet[idx].pd_phys; desc->rd_length = packet[idx].pd_length; desc->rd_valid = 1; } #if LINUX_VERSION_CODE > KERNEL_VERSION(3,14,4) if ((dev_veth = alloc_netdev(sizeof(micveth_info_t), "mic%d", NET_NAME_ENUM, micveth_setup)) == NULL) { #else if ((dev_veth = alloc_netdev(sizeof(micveth_info_t), "mic%d", micveth_setup)) == NULL) { #endif return -ENOMEM; } veth_info->vi_netdev = dev_veth; dev_veth->ml_priv = veth_info; dev_veth->rtnl_link_ops = &micveth_link_ops; if ((err = register_netdev(dev_veth)) < 0) { printk("register netdev failed %d\n", err); free_netdev(dev_veth); return err; } veth_info->vi_state = VETH_STATE_INITIALIZED; return 0; } static ssize_t show_veth(struct device *dev, struct device_attribute *attr, char *buf); DEVICE_ATTR(veth, (S_IRUGO|S_IWUGO)&(~S_IWOTH), show_veth, NULL); static int micveth_init_int(int num_bds, struct device *dev) { int bd; int err = 0; micveth.lv_num_interfaces = num_bds; micveth.lv_num_clients = num_bds; micveth.lv_active_clients = 0; micveth.lv_num_links_remaining = num_bds; BUG_ON(rtnl_link_register(&micveth_link_ops)); // Allocate space for the control of each device in the system. micveth.lv_info = kmalloc(sizeof(micveth_info_t) * num_bds, GFP_KERNEL); // Initialize state mutex. Overloaded use for several fields. mutex_init(&micveth.lv_state_mutex); // Setup of timer for probeing active mic clients. When the total active board // count is zero the poll is not running. micveth.lv_pollstate = CLIENT_POLL_STOPPED; INIT_DELAYED_WORK(&micveth.lv_poll, micveth_clientpoll); init_waitqueue_head(&micveth.lv_wq); // Init each of the existing boards. for (bd = 0; bd < num_bds; bd++) { micveth_probe_int(&micveth.lv_info[bd], &mic_data.dd_bi[bd]->bi_ctx); } err = device_create_file(dev, &dev_attr_veth); return err; }
static __init int veth_init(void) { register_netdevice_notifier(&veth_notifier_block); return rtnl_link_register(&veth_link_ops); }