static int __init llc_init(void) { if (dev_base->next) memcpy(llc_station_mac_sa, dev_base->next->dev_addr, ETH_ALEN); else memset(llc_station_mac_sa, 0, ETH_ALEN); dev_add_pack(&llc_packet_type); dev_add_pack(&llc_tr_packet_type); return 0; }
static int __init llc_init(void) { struct net_device *dev; dev = first_net_device(&init_net); if (dev != NULL) dev = next_net_device(dev); dev_add_pack(&llc_packet_type); dev_add_pack(&llc_tr_packet_type); return 0; }
static int packet_do_bind(struct sock *sk, struct net_device *dev, int protocol) { struct packet_sock *po = pkt_sk(sk); /* * Detach an existing hook if present. */ lock_sock(sk); spin_lock(&po->bind_lock); if (po->running) { __sock_put(sk); po->running = 0; po->num = 0; spin_unlock(&po->bind_lock); dev_remove_pack(&po->prot_hook); spin_lock(&po->bind_lock); } po->num = protocol; po->prot_hook.type = protocol; po->prot_hook.dev = dev; po->ifindex = dev ? dev->ifindex : 0; if (protocol == 0) goto out_unlock; if (dev) { if (dev->flags&IFF_UP) { dev_add_pack(&po->prot_hook); sock_hold(sk); po->running = 1; } else { sk->sk_err = ENETDOWN; if (!sock_flag(sk, SOCK_DEAD)) sk->sk_error_report(sk); } } else { dev_add_pack(&po->prot_hook); sock_hold(sk); po->running = 1; } out_unlock: spin_unlock(&po->bind_lock); release_sock(sk); return 0; }
/* * Function irda_init (void) * * Protocol stack initialisation entry point. * Initialise the various components of the IrDA stack */ int __init irda_init(void) { IRDA_DEBUG(0, "%s()\n", __FUNCTION__); /* Lower layer of the stack */ irlmp_init(); irlap_init(); /* Higher layers of the stack */ iriap_init(); irttp_init(); irsock_init(); /* Add IrDA packet type (Start receiving packets) */ dev_add_pack(&irda_packet_type); /* External APIs */ #ifdef CONFIG_PROC_FS irda_proc_register(); #endif #ifdef CONFIG_SYSCTL irda_sysctl_register(); #endif /* Driver/dongle support */ irda_device_init(); return 0; }
/************************************************************ * Module init procedure. ************************************************************/ static int __init goose_init(void) { printk("--------------------------------------\n"); printk("GOOSE: Stand by.\n"); printk("GOOSE: initiating proc file systems.\n"); if (proc_fs_init() != 0) { printk("GOOSE: Fatal error in initializing proc_fs!\n"); return -1; } printk("GOOSE: initiating netlink interface.\n"); if (netlink_init() != 0) { printk("GOOSE: Fatal error in initializing netlink!\n"); return -1; } /* initialize default dev*/ def_dev = dev_get_by_name(&init_net, buf_proc_def_dev); if (def_dev == NULL) { printk("GOOSE: Can not find %s, choose another device.\n", buf_proc_def_dev); } /* register GOOSE protocol */ dev_add_pack(&goose_packet_type); /* kernel_thread(daemon, NULL, 0); */ return 0; }
/* @brief HIF GMAC init module */ int os_gmac_init(void) { hif_gmac_softc_t *sc; init_wlan(); sc = __gmac_pkt.af_packet_priv = hif_gmac_init(); sc->attach = __gmac_defer_attach; sc->detach = __gmac_detach; sc->discv = __gmac_dev_discv; dev_add_pack(&__gmac_pkt); fwd_module_init(); MpHtcInit(); if (ath_create_htc_thread(NULL) != 0) printk(KERN_ERR "%s: create thread fail\n", __func__); /* register_netdevice_notifier(&__gmac_notifier); */ return 0; }
/** * setup_bearer - setup association between InfiniBand bearer and interface */ static void setup_bearer(struct work_struct *work) { struct ib_bearer *ib_ptr = container_of(work, struct ib_bearer, setup); dev_add_pack(&ib_ptr->tipc_packet_type); }
/* Module registration */ static int __init phonet_init(void) { int err; err = phonet_device_init(); if (err) return err; err = sock_register(&phonet_proto_family); if (err) { printk(KERN_ALERT "phonet protocol family initialization failed\n"); goto err_sock; } dev_add_pack(&phonet_packet_type); phonet_sysctl_init(); err = isi_register(); if (err) goto err; return 0; err: phonet_sysctl_exit(); sock_unregister(PF_PHONET); dev_remove_pack(&phonet_packet_type); err_sock: phonet_device_exit(); return err; }
static int __init llc_init(void) { struct net_device *dev; dev = first_net_device(&init_net); if (dev != NULL) dev = next_net_device(dev); if (dev != NULL) memcpy(llc_station_mac_sa, dev->dev_addr, ETH_ALEN); else memset(llc_station_mac_sa, 0, ETH_ALEN); dev_add_pack(&llc_packet_type); dev_add_pack(&llc_tr_packet_type); return 0; }
/* * Function vlan_proto_init (pro) * * Initialize VLAN protocol layer, * */ static int __init vlan_proto_init(void) { int err; printk(VLAN_INF "%s v%u.%u %s\n", vlan_fullname, vlan_version, vlan_release, vlan_copyright); printk(VLAN_INF "Other stuff added by %s\n", vlan_buggyright); /* proc file system initialization */ err = vlan_proc_init(); if (err < 0) { printk(KERN_ERR "%s %s: can't create entry in proc filesystem!\n", __FUNCTION__, VLAN_NAME); return 1; } dev_add_pack(&vlan_packet_type); /* Register us to receive netdevice events */ register_netdevice_notifier(&vlan_notifier_block); vlan_ioctl_hook = vlan_ioctl_handler; return 0; }
static int __init af_ieee802154_init(void) { int rc = -EINVAL; rc = proto_register(&ieee802154_raw_prot, 1); if (rc) goto out; rc = proto_register(&ieee802154_dgram_prot, 1); if (rc) goto err_dgram; /* Tell SOCKET that we are alive */ rc = sock_register(&ieee802154_family_ops); if (rc) goto err_sock; dev_add_pack(&ieee802154_packet_type); rc = 0; goto out; err_sock: proto_unregister(&ieee802154_dgram_prot); err_dgram: proto_unregister(&ieee802154_raw_prot); out: return rc; }
/* * Function vlan_proto_init (pro) * * Initialize VLAN protocol layer, * */ static int __init vlan_proto_init(void) { int err; printk(VLAN_INF "%s v%s\n", vlan_fullname, vlan_version); /* proc file system initialization */ err = vlan_proc_init(); if (err < 0) { printk(KERN_ERR "%s: can't create entry in proc filesystem!\n", __FUNCTION__); return err; } dev_add_pack(&vlan_packet_type); /* Register us to receive netdevice events */ err = register_netdevice_notifier(&vlan_notifier_block); if (err < 0) { dev_remove_pack(&vlan_packet_type); vlan_proc_cleanup(); return err; } vlan_ioctl_set(vlan_ioctl_handler); return 0; }
void disable_tarp(void) { dev_add_pack(arp_packet_type); printk(KERN_INFO "[arpsec_mod] disabled\n"); printk(KERN_INFO "[arpsec_mod] kernel can now receive \"classic\" "\ "ARP packets\n"); }
//Initialize the module static int __init vrr_init(void) { /* 1. Initialize an empty routing table 2. create empty pset (tree/CLL?) 3. create empty vset (tree/CLL?) 4. create vrr_node structure 5. Initialize sysfs hooks ?? 6. Build hello packet and send to establish a proxy 7. There is probably alot more than this */ int err; unsigned long tdelay; WARN_ATOMIC; VRR_INFO("Begin init"); vrr_node_init(); vrr_data_init(); pset_state_init(); vrr_init_rcv(); err = proto_register(&vrr_proto, 1); if (err) { goto out; } /* Initialize routing/sysfs stuff here */ /* TODO: Split these into separate functions */ vrr_obj = kobject_create_and_add("vrr", kernel_kobj); if (!vrr_obj) { err = -ENOMEM; goto out; } err = sysfs_create_group(vrr_obj, &attr_group); if (err) { kobject_put(vrr_obj); } /* --- */ /* Register our sockets protocol handler */ err = sock_register(&vrr_family_ops); if (err) { goto out; } dev_add_pack(&vrr_packet_type); //start hello packet timer tdelay = jiffies + (VRR_HPKT_DELAY * HZ / 1000); mod_timer(&vrr_timer, tdelay); VRR_INFO("End init"); out: return err; }
static int packet_do_bind(struct sock *sk, struct net_device *dev, int protocol) { /* * Detach an existing hook if present. */ lock_sock(sk); spin_lock(&sk->protinfo.af_packet->bind_lock); if (sk->protinfo.af_packet->running) { dev_remove_pack(&sk->protinfo.af_packet->prot_hook); __sock_put(sk); sk->protinfo.af_packet->running = 0; } sk->num = protocol; sk->protinfo.af_packet->prot_hook.type = protocol; sk->protinfo.af_packet->prot_hook.dev = dev; sk->protinfo.af_packet->ifindex = dev ? dev->ifindex : 0; if (protocol == 0) goto out_unlock; if (dev) { if (dev->flags&IFF_UP) { dev_add_pack(&sk->protinfo.af_packet->prot_hook); sock_hold(sk); sk->protinfo.af_packet->running = 1; } else { sk->err = ENETDOWN; if (!sk->dead) sk->error_report(sk); } } else { dev_add_pack(&sk->protinfo.af_packet->prot_hook); sock_hold(sk); sk->protinfo.af_packet->running = 1; } out_unlock: spin_unlock(&sk->protinfo.af_packet->bind_lock); release_sock(sk); return 0; }
int tipc_bearer_setup(void) { int err; err = register_netdevice_notifier(¬ifier); if (err) return err; dev_add_pack(&tipc_packet_type); return 0; }
static int __init ztdeth_init(void) { skb_queue_head_init(&skbs); dev_add_pack(&ztdeth_ptype); register_netdevice_notifier(&ztdeth_nblock); dahdi_dynamic_register_driver(&ztd_eth); return 0; }
/****************************************************************************** ** Function name:DyS_dist_mac_net_device_open ** Descriptions:called when we use ifconfig up ** Input: ** Output: ** Returns: ** Created by: ** Created Date:2010/07/07 **-------------------------------------- -------------------- ** Modified by: ** Modified Date: ******************************************************************************/ int fsm_dev_open(struct net_device *dev) { /*-----------------now we need to register the special protocol_type */ fsm_core_intf_set(STRM_TO_MAC, DEV_INTF_IND, DEV_PROTO_MAC, "LTE_MAC0"); fsm_core_intf_set(STRM_TO_ETH, DEV_INTF_REQ, DEV_PROTO_SRIO, "eth0"); dev_add_pack(&pk_t); netif_start_queue(dev); fsm_core_open(); return 0; }
/****************************************************************************** ** Function name:DyS_dist_mac_net_device_open ** Descriptions:called when we use ifconfig up ** Input: ** Output: ** Returns: ** Created by: ** Created Date:2010/07/07 **-------------------------------------- -------------------- ** Modified by: ** Modified Date: ******************************************************************************/ int fsm_dev_open(struct net_device *dev) { /*-----------------now we need to register the special protocol_type */ fsm_core_intf_set(STRM_TO_IP, DEV_INTF_IND, DEV_PROTO_IP, NULL); fsm_core_intf_set(STRM_TO_PDCP, DEV_INTF_REQ, DEV_PROTO_IPADP, "LTE_PDCP0"); //fsm_core_intf_set(STRM_TO_RLC, DEV_INTF_REQ, DEV_PROTO_IPADP, "LTE_RLC0"); fsm_core_intf_set(STRM_TO_MAC, DEV_INTF_REQ, DEV_PROTO_IPADP, "LTE_MAC0"); dev_add_pack(&pk_t); netif_start_queue(dev); fsm_core_open(); return 0; }
void mpls_enable(void) { if( !mpls_forward_on ) { dev_add_pack(&mpls_uc_ptype); mpls_forward_on = 1 ; } if (SWITCHOVER_MAIN_BOARD) { MPLS_NOTIFY_SEND(enable); } }
// sniff device open function int sniff_open(struct inode *i, struct file *f){ printk("Opening IPSniff device\n"); dev_add_pack(&sniff_hook); if((rules=(filter_t *)kmalloc(sizeof(filter_t)*10,GFP_KERNEL))==NULL){ printk("Unable to allocate mem to filter\n"); return -1; } // MOD_INC_USE_COUNT; return 0; }
/* Pre IP Protocol Init */ int __init preIP_Init(void) { #ifdef PRE_IP_DEBUG printk("preIP_Init: in\n"); #endif preip_nlfd = netlink_kernel_create(&init_net, NETLINK_PREIP,1, nl_preip_receive, NULL, THIS_MODULE); if (preip_nlfd == NULL) { printk("%s: failed to create netlink socket\n",__func__); return -EBUSY; } dev_add_pack(&preIP_packet_type); return 0; }
static int packet_init (volatile struct sock *sk) { struct packet_type *p; p = malloc (sizeof (*p)); if (p == NULL) return (-ENOMEM); p->func = packet_rcv; p->type = sk->num; p->data = (void *)sk; dev_add_pack (p); /* we need to remember this somewhere. */ sk->pair = (volatile struct sock *)p; return (0); }
static int rlb_initialize(struct bonding *bond) { struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); struct packet_type *pk_type = &(BOND_ALB_INFO(bond).rlb_pkt_type); int i; size_t size; spin_lock_init(&(bond_info->rx_hashtbl_lock)); _lock_rx_hashtbl(bond); if (bond_info->rx_hashtbl != NULL) { printk (KERN_ERR "%s: RLB hash table is not NULL\n", bond->device->name); _unlock_rx_hashtbl(bond); return -1; } size = RLB_HASH_TABLE_SIZE * sizeof(struct rlb_client_info); bond_info->rx_hashtbl = kmalloc(size, GFP_KERNEL); if (bond_info->rx_hashtbl == NULL) { printk (KERN_ERR "%s: Failed to allocate" " RLB hash table\n", bond->device->name); _unlock_rx_hashtbl(bond); return -1; } bond_info->rx_hashtbl_head = RLB_NULL_INDEX; for (i=0; i<RLB_HASH_TABLE_SIZE; i++) { rlb_init_table_entry(bond_info->rx_hashtbl + i); } _unlock_rx_hashtbl(bond); /* register to receive ARPs */ /*initialize packet type*/ pk_type->type = __constant_htons(ETH_P_ARP); pk_type->dev = bond->device; pk_type->func = rlb_arp_recv; pk_type->data = (void*)1; /* understand shared skbs */ dev_add_pack(pk_type); return 0; }
int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b, struct nlattr *attr[]) { char *dev_name = strchr((const char *)b->name, ':') + 1; int hwaddr_len = b->media->hwaddr_len; u8 node_id[NODE_ID_LEN] = {0,}; struct net_device *dev; /* Find device with specified name */ dev = dev_get_by_name(net, dev_name); if (!dev) return -ENODEV; if (tipc_mtu_bad(dev, 0)) { dev_put(dev); return -EINVAL; } /* Autoconfigure own node identity if needed */ if (!tipc_own_id(net) && hwaddr_len <= NODE_ID_LEN) { memcpy(node_id, dev->dev_addr, hwaddr_len); tipc_net_init(net, node_id, 0); } if (!tipc_own_id(net)) { pr_warn("Failed to obtain node identity\n"); return -EINVAL; } /* Associate TIPC bearer with L2 bearer */ rcu_assign_pointer(b->media_ptr, dev); b->pt.dev = dev; b->pt.type = htons(ETH_P_TIPC); b->pt.func = tipc_l2_rcv_msg; dev_add_pack(&b->pt); memset(&b->bcast_addr, 0, sizeof(b->bcast_addr)); memcpy(b->bcast_addr.value, dev->broadcast, hwaddr_len); b->bcast_addr.media_id = b->media->type_id; b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT; b->mtu = dev->mtu; b->media->raw2addr(b, &b->addr, (char *)dev->dev_addr); rcu_assign_pointer(dev->tipc_ptr, b); return 0; }
static int enable_bearer(struct tipc_bearer *tb_ptr) { struct net_device *dev = dev_base; struct eth_bearer *eb_ptr = ð_bearers[0]; struct eth_bearer *stop = ð_bearers[MAX_ETH_BEARERS]; char *driver_name = strchr((const char *)tb_ptr->name, ':') + 1; /* Find device with specified name */ while (dev && dev->name && (memcmp(dev->name, driver_name, strlen(dev->name)))) { dev = dev->next; } if (!dev) return -ENODEV; /* Find Ethernet bearer for device (or create one) */ for (;(eb_ptr != stop) && eb_ptr->dev && (eb_ptr->dev != dev); eb_ptr++); if (eb_ptr == stop) return -EDQUOT; if (!eb_ptr->dev) { eb_ptr->dev = dev; eb_ptr->tipc_packet_type.type = __constant_htons(ETH_P_TIPC); eb_ptr->tipc_packet_type.dev = dev; eb_ptr->tipc_packet_type.func = recv_msg; eb_ptr->tipc_packet_type.af_packet_priv = eb_ptr; INIT_LIST_HEAD(&(eb_ptr->tipc_packet_type.list)); dev_hold(dev); dev_add_pack(&eb_ptr->tipc_packet_type); } /* Associate TIPC bearer with Ethernet bearer */ eb_ptr->bearer = tb_ptr; tb_ptr->usr_handle = (void *)eb_ptr; tb_ptr->mtu = dev->mtu; tb_ptr->blocked = 0; tb_ptr->addr.type = htonl(TIPC_MEDIA_TYPE_ETH); memcpy(&tb_ptr->addr.dev_addr, &dev->dev_addr, ETH_ALEN); return 0; }
int packet_attach(struct sock *sk, struct device *dev) { struct packet_type *p = (struct packet_type *) kmalloc(sizeof(*p), GFP_KERNEL); if (p == NULL) return(-ENOMEM); p->func = packet_rcv; p->type = sk->num; p->data = (void *)sk; p->dev = dev; dev_add_pack(p); /* * We need to remember this somewhere. */ sk->protinfo.af_packet.prot_hook = p; sk->protinfo.af_packet.bound_dev = dev; return 0; }
/** * __init module function */ static int __init init_lvwnet(void) { printk(KERN_INFO "lvwnet_node: Starting module %s now.\n", LVWNET_VERSION); if (!__params_verify()) return -EINVAL; //invalid params ethernic = find_nic(ethernic_name); if (ethernic == NULL){ printk(KERN_ALERT "lvwnet_node: ethernet interface [%s] not found.\n", ethernic_name); return -EINVAL; } spin_lock_init(&lvwnet_lock); spin_lock_init(&lvwnet_recv_lock); spin_lock_init(&lvwnet_send_reg_lock); //Setting pointers to get hw from modified mac80211 __init_sysfs(); //extern function from modified mac80211 /** convert from char to hex */ __set_ptrs_hw(); __set_ptr_skb(); printk(KERN_INFO "lvwnet_node: set as loaded (node before)\n"); lvwnet_set_loaded(); printk(KERN_INFO "lvwnet_node: set as loaded (node after)\n"); mac_strtoh(ctrl_host_addr_h, ctrl_host_addr); printk(KERN_INFO "lvwnet_node: host set as node, and controller is: [%pM]\n", ctrl_host_addr_h); printk(KERN_INFO "lvwnet_node: Registering ethertype 0x0808[lvwnet].\n"); dev_add_pack(&pkt_type_lvwnet); //dev_add_pack(&pkt_type_lvwnet_data); printk(KERN_INFO "lvwnet_node: Initializing netlink interface. (not ready yet... sorry...)\n"); send_reg_to_controller(); reg_timer_init(); return 0; }
int init_module(void) { int ret = 0; int i=0; nm_ctl_netdev = dev_get_by_name(&init_net,ctlif_name); if(nm_ctl_netdev == NULL) { printk("%s not found!\n", ctlif_name); return -1;/*定义一个值,表示找不到接口*/ } for(i=0;i<PORT_CNT;i++) { nm_dev[i]=alloc_etherdev(sizeof(struct nm_adapter)); if (nm_dev[i] == NULL) goto rollback_alloc; adapter[i] = netdev_priv(nm_dev[i]); adapter[i]->netdev = nm_dev[i]; adapter[i]->port = i; nm_dev[i]->netdev_ops = &nm_netdev_ops; memcpy(nm_dev[i]->dev_addr,"06090",5); nm_dev[i]->dev_addr[0] = 0; nm_dev[i]->dev_addr[5] = i; strcpy(nm_dev[i]->name, "nm%d"); if ((ret = register_netdev(nm_dev[i]))) goto rollback_reg; } eth_pack.dev = nm_ctl_netdev; dev_add_pack(ð_pack); rollback_alloc: rollback_reg: return 0; }
static int __init kvblade_module_init(void) { skb_queue_head_init(&skb_outq); skb_queue_head_init(&skb_inq); spin_lock_init(&lock); init_completion(&ktrendez); init_waitqueue_head(&ktwaitq); task = kthread_run(kthread, NULL, "kvblade"); if (task == NULL || IS_ERR(task)) return -EAGAIN; kobject_init_and_add(&kvblade_kobj, &kvblade_ktype_ops, NULL, "kvblade"); wait_for_completion(&ktrendez); init_completion(&ktrendez); // for exit dev_add_pack(&pt); return 0; }