/home/tai/chorist/xian-1.2/src/xnm.c

Go to the documentation of this file.

/*
 *  Copyright (C) 2006 THALES Communications
 *
 *  This file is part of XIAN software.
 *
 *  XIAN is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation.
 *
 *  XIAN software is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with XIAN software; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * ************************************************************************************************************** */
#include <linux/module.h> // needed by all the modules
#include <linux/kernel.h>
#include <linux/init.h> // for the macros
#include <linux/netdevice.h>
#include <linux/time.h>
#include "include/xian_proto.h"
#include "include/ksi.h"
MODULE_DESCRIPTION("XIAN - Module XNM : XIAN Neighbouring  Manager module");
MODULE_LICENSE("GPL");

char dev_name[IFNAMESIZ+1];
char macadd[IEEE80211_MAC_ADDR_LEN+1];

unsigned char my_mac[IEEE80211_MAC_ADDR_LEN+1]; //@MAC of the node

struct  neighbour_table *xian_table;

struct neighbour_conf{
  unsigned int freq_update;
};
struct neighbour_conf *param;
unsigned int metric = NODE_RSSI;



/************************************************************************************************************//*
 *This function check the timestamp of the active neighbors of the considered node and delete the neighbor entry 
 * from the xian_table when its timestamp is timeout in the neighbortable.
 *
 *@param* list a pointer to the neighbor_table 
 *@param timeout the value of the timeout
 *
 *@return a pointer to the neighbor_table struct corresponding to the XIAN_table of active XIAN neighbors or
 *  NULL if not found.
 ****************************************************************************************************************/
struct neighbour_table* xian_timeout( struct neighbour_table* list, long timeout)
{
  long checking_time;
  struct neighbour_table* temp;
  if (list==NULL)
  {
        return NULL;
  }
  checking_time=jiffies_to_msecs(get_jiffies_64());
// if the considered neighbour should be deleted
        if (checking_time - (list->timestamp)> timeout)
        {
        temp=list->next; // memorisation of the address of the next element
        kfree(list);
        printk("timeout of this node in the neighbour_table %s\n", list->macaddr);
        temp=xian_timeout(temp, timeout);
        return (temp);
        }
        else
        {       
        list->next = xian_timeout(list->next, timeout);
        return(list);
        } 
}

/*************************************************************************************************************/
void xian_broadcast_neighbour(char * dev_name)
{
  unsigned char mac_addr_temp[IEEE80211_MAC_ADDR_LEN+1];
  struct net_device *dev= dev_get_by_name(dev_name);
  if (dev)
    {
      
      struct ath_softc *sc= dev->priv;
      struct ieee80211com *ic = &sc->sc_ic;
      struct ieee80211_node_table *nt = &ic->ic_sta;
      struct ieee80211_node *ni;
     
      free_mac_to_broadcast();
     /* access to mad_wifi structure */       
      ATH_LOCK(sc);
      IEEE80211_NODE_LOCK(nt);
      TAILQ_FOREACH (ni, &nt->nt_node, ni_list) /* on traverse le tail queue forward */
        {          
          strcpy(mac_addr_temp,ether_sprintf(ni->ni_macaddr));
          insert_mac_to_broadcast(mac_addr_temp);  // constitution of the tab_mac_to_broadcast  
        }
      IEEE80211_NODE_UNLOCK(nt);
      ATH_UNLOCK(sc);
    }
}
XIAN_EXPORT_SYMBOL(xian_broadcast_neighbour);

/*************************************************************************************************************/
void xian_update_neighbour(char * dev_name)
{
  xian_broadcast_neighbour(dev_name); 
  xian_table= xian_timeout(xian_table, 1000);           
}
XIAN_EXPORT_SYMBOL(xian_update_neighbour);


/***************************************************************************************************************/
void xian_get_xian_neighbour (unsigned char *saddr)
{
  struct neighbour_table *temp_pt, *temp;
  temp_pt = xian_table;
  if (xian_table== NULL)
    {
      printk("adding the first node %s\n ", saddr);
      xian_table= kmalloc(sizeof(struct neighbour_table), GFP_ATOMIC);
      if (xian_table!= NULL)
      {   
      strncpy(xian_table->macaddr,saddr,IEEE80211_MAC_ADDR_LEN+1);
      xian_table->timestamp=jiffies_to_msecs(get_jiffies_64());
      xian_table->next=NULL;
      }
    }
  else
    {
      while (temp_pt!=NULL)
        {
          // if macaddr of the sending node is already contained in the xian table,the timestamp will be updated
          if (strncmp(temp_pt->macaddr,saddr,IEEE80211_MAC_ADDR_LEN+1)==0) 
            {
              temp_pt-> timestamp=  jiffies_to_msecs(get_jiffies_64());
              return;
            }
          else
            {
            // if macaddr of the sending node is not contained in the xian table, it will be added
            temp_pt=temp_pt->next;
            }
        }
      printk("adding the node with the MAC address %s to the xian table \n", saddr);
      temp= kmalloc(sizeof(struct neighbour_table), GFP_ATOMIC);          
      strncpy(temp->macaddr,saddr,IEEE80211_MAC_ADDR_LEN+1);
      temp->timestamp= jiffies_to_msecs(get_jiffies_64());
      temp->next=xian_table;
      xian_table = temp;                     
                        
}       
}
XIAN_EXPORT_SYMBOL(xian_get_xian_neighbour);

/****************************************************************************************************/
typedef struct
{
  /* Linux task structure of thread */
  struct task_struct *thread;
  /* semaphore needed on start and creation of thread */
  struct semaphore   startstop_sem;
  /* flag to tell thread whether to die or not */
  int terminate;
  /* queue thread is waiting on */
  struct wait_queue *queue;
  /* process id of the thread */
  pid_t pid;
  void *data;
}my_threads;

/* prototype of our function thread */
void thread_neighbour(my_threads *thread);

/* prototype to create a new thread */
static void launch_thread(void (*func),void *data, my_threads *thread);

/* prototype to kill a running thread */
static void kill_thread(my_threads *thread);

/* the variable that contains the thread data */
my_threads neighbour_kthread;

/* create a new kernel thread */
static void launch_thread(void (*func),void *data, my_threads *thread)
{
  init_MUTEX_LOCKED(&thread->startstop_sem);
  thread->data=data;

  /* create the new thread */
  kernel_thread(func, (void *)thread, 0);
  
  /* wait till it has reached the setup_thread routine */
  down(&thread->startstop_sem);
}

static void kill_thread(my_threads *thread)
{
  if (thread->thread == NULL)
    {
      //printk("[XIAN Metric MANAGER] Killing non existing thread!\n");
      return;
    }
  
  /* get the global lock to prevent a race in the
     fall-asleep phase of the thread */
  init_MUTEX_LOCKED(&thread->startstop_sem);
  
#ifdef __alpha
  /* on Alpha platfrom we need to do a memory barrier
     here to be sure that the flags are visible on
     all CPUs. This is not portable, we should e.g.
     use atomic_t here for passing the information.
  */
  mb();
#endif
  
  /* set flag to request thread termination */
  thread->terminate = 1;
#ifdef __alpha
  /* on Alpha platfrom we need to do a memory barrier
     here to be sure that the flags are visible on
     all CPUs. This is not portable, we should e.g.
     use atomic_t here for passing the information.
  */
  mb();
#endif
  kill_proc(SIGKILL, thread->pid, 1);
  
  /* block till thread terminated */
  down(&thread->startstop_sem);
}

static void setup_thread(my_threads *thread)
{
  /* lock the kernel */
  lock_kernel();
  
  /* fill in thread structure */
  thread->thread = current;
  
  /* set signal mask to what we want to respond */
  siginitsetinv(&current->blocked, sigmask(SIGKILL)|sigmask(SIGINT)|sigmask(SIGTERM));
  
  /* initialise wait queue */
  thread->queue = NULL;
  
  /* initialise termination flag */
  thread->terminate = 0;
  
  /* let others run */
  unlock_kernel();
  
  /* tell the creator that we are ready and let him run */
  up(&thread->startstop_sem);
  
}

static void leave_thread(my_threads *thread)
{
  /* we are terminating */
  
  /* lock the kernel, the exit will unlock it */
  thread->thread = NULL;
#ifdef __alpha
  mb();
#endif
  /* notify the kill_thread() routine that we are terminating. */
  up(&thread->startstop_sem);
}

/****************************************************************/
void thread_neighbour(my_threads *thread)
{
 
  struct neighbour_conf *report_config;
  unsigned int jiffies;
  report_config= (struct neighbour_conf *)thread->data;
  jiffies= ((HZ * (report_config->freq_update) +999) / 1000)+1;
  printk("XNM KThread wake up\n");
  setup_thread(thread);
  printk(" XIAN Neighbouring Manager : updated of lists of XIAN active neighbours every %d\n ", report_config->freq_update);
  while(1)
      {
        if (report_config->freq_update >0)
          { 
            set_current_state(TASK_UNINTERRUPTIBLE);
            jiffies= schedule_timeout(jiffies);
            xian_update_neighbour("ath0");          
          }
        if (thread->terminate)
          {
            /* we received a request to terminate ourself */
            break;
          }
      }
  /* in case of terminaison of the thread */
    leave_thread(thread);
}


/*************************************************************/
void treatment_neighbour(unsigned char *saddr, struct metric_msg *metric){
 
   xian_get_xian_neighbour(saddr);
   
}
EXPORT_SYMBOL(treatment_neighbour);

/************************************************************************************************************************/
void config(unsigned int metric)
{
  int freq=500; //millisecond  frequency og the xian message containing the metric
  void (*pf)(unsigned char * saddr, struct metric_msg *metric);
  pf=&treatment_neighbour;  
  strcpy(my_mac, "FF:FF:FF:FF:FF:FF");
  register_id(metric, metric, "ath0", my_mac, freq, pf);  
}


/************************************************************************************************************************
MODULE XIAN NEIGHBOUR
************************************************************************************************************************/

int xian_neighbour_init(void)
{
  xian_table=NULL;
  param=kmalloc(sizeof(struct neighbour_conf), GFP_KERNEL);
  param-> freq_update=2000; // frequency of the update of the neighbour table and tab_mac_to_broadcast 
  printk(KERN_ALERT "Init  XIAN XNM (XIAN Neighbouring Manager module)\n");
  
  // first polling to constitute the tab_mac_to_broadcast
  xian_broadcast_neighbour("ath0"); 
 
  // update of the tab_mac_to_broadcast (thread 1)
  launch_thread(thread_neighbour, param, & neighbour_kthread);     
    
  // configuration of the metric with its frequency and the invoked treatment at the reception (thread 2)
  config(metric);  
  return(0);
 
}


void xian_neighbour_exit(void)
{
  kill_thread(&neighbour_kthread);
  printk(KERN_ALERT "Unload XIAN XNM (XIAN Neighbouring Manager module)\n");
  unregister_id(metric, metric);   
  kfree (xian_table);
  kfree(param);
}

module_init(xian_neighbour_init);
module_exit(xian_neighbour_exit);

---