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;
}
Ejemplo n.º 2
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;
}
Ejemplo n.º 3
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;
}
Ejemplo n.º 4
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;
}
Ejemplo n.º 5
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;
}
Ejemplo n.º 6
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;
}
Ejemplo n.º 7
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;
}
Ejemplo n.º 9
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);

	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;
}
Ejemplo n.º 10
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;
}
Ejemplo n.º 11
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;
}
Ejemplo n.º 12
0
/*
 * 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;
}
Ejemplo n.º 13
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");
}
Ejemplo n.º 14
0
//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;
}
Ejemplo n.º 15
0
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;
}
Ejemplo n.º 16
0
Archivo: bearer.c Proyecto: 7799/linux
int tipc_bearer_setup(void)
{
	int err;

	err = register_netdevice_notifier(&notifier);
	if (err)
		return err;
	dev_add_pack(&tipc_packet_type);
	return 0;
}
Ejemplo n.º 17
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;
}
Ejemplo n.º 18
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;    
}
Ejemplo n.º 19
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;    
}
Ejemplo n.º 20
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);
	}
}
Ejemplo n.º 21
0
// 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;
}
Ejemplo n.º 22
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;
}
Ejemplo n.º 23
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);
}
Ejemplo n.º 24
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;
}
Ejemplo n.º 25
0
Archivo: bearer.c Proyecto: krzk/linux
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;
}
Ejemplo n.º 26
0
static int enable_bearer(struct tipc_bearer *tb_ptr)
{
	struct net_device *dev = dev_base;
	struct eth_bearer *eb_ptr = &eth_bearers[0];
	struct eth_bearer *stop = &eth_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;
}
Ejemplo n.º 27
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;	
}
Ejemplo n.º 28
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;
}
Ejemplo n.º 29
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(&eth_pack);
rollback_alloc:
	
rollback_reg:
	
    return 0;
}
Ejemplo n.º 30
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;
}