Simplification of timer and memory cookie interface.
authorHenning Rogge <hrogge@googlemail.com>
Tue, 10 Aug 2010 17:03:30 +0000 (19:03 +0200)
committerHenning Rogge <hrogge@googlemail.com>
Tue, 10 Aug 2010 17:03:30 +0000 (19:03 +0200)
Timer have their own creation routine now, cookies are only for memory.

41 files changed:
lib/arprefresh/src/olsrd_arprefresh.c
lib/bmf/src/olsrd_plugin.c
lib/cl_roam/src/cl_roam.c
lib/debuginfo/src/olsrd_debuginfo.c
lib/dyn_gw/src/olsrd_dyn_gw.c
lib/dyn_gw_plain/src/olsrd_dyn_gw_plain.c
lib/lq_etx_ff/src/lq_plugin_etx_ff.c
lib/nameservice/src/mapwrite.c
lib/nameservice/src/nameservice.c
lib/obamp/src/obamp.c
lib/quagga/src/olsrd_plugin.c
lib/secure/src/olsrd_secure.c
lib/watchdog/src/olsrd_plugin.c
src/duplicate_set.c
src/hna_set.c
src/ifnet.h
src/interfaces.c
src/interfaces.h
src/link_set.c
src/lq_plugin.c
src/main.c
src/mid_set.c
src/neighbor_table.c
src/net_olsr.c
src/net_olsr.h
src/olsr.c
src/olsr.h
src/olsr_comport.c
src/olsr_comport_http.c
src/olsr_comport_txt.c
src/olsr_cookie.c
src/olsr_cookie.h
src/olsr_spf.c
src/olsr_spf.h
src/plugin_loader.c
src/routing_table.c
src/scheduler.c
src/scheduler.h
src/tc_set.c
src/tc_set.h
src/unix/ifnet.c

index 903f395..b6f4cb3 100644 (file)
@@ -100,7 +100,7 @@ typedef struct {
 } __attribute__ ((packed)) arprefresh_buf;
 
 static int arprefresh_sockfd = -1;
-static struct olsr_cookie_info *arp_event_timer_cookie;
+static struct olsr_timer_info *arp_event_timer_info;
 
 /**
  * Scheduled event to fetch gathered packets and update the ARP cache
@@ -167,7 +167,8 @@ int
 olsrd_plugin_init(void)
 {
   int ret = 0;
-  arp_event_timer_cookie = olsr_alloc_cookie("Arprefresh: event", OLSR_COOKIE_TYPE_TIMER);
+  arp_event_timer_info = olsr_alloc_timerinfo("Arprefresh: event", &olsr_arp_event, true);
+
   if (AF_INET == olsr_cnf->ip_version) {
     struct sock_fprog filter;
     struct sock_filter BPF_code[] = {
@@ -196,7 +197,7 @@ olsrd_plugin_init(void)
         0 <= set_nonblocking(arprefresh_sockfd) &&
         0 <= setsockopt(arprefresh_sockfd, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter))) {
       /* Register the ARP refresh event */
-      olsr_start_timer(2 * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC, &olsr_arp_event, NULL, arp_event_timer_cookie);
+      olsr_start_timer(2 * MSEC_PER_SEC, 0, NULL, arp_event_timer_info);
       ret = 1;
     } else {
       OLSR_WARN(LOG_PLUGINS, "*** ARPREFRESH: Cannot create non-blocking filtering packet socket: %s\n", strerror(errno));
index ff97be9..ffe33b5 100644 (file)
@@ -60,7 +60,7 @@
 static void __attribute__ ((constructor)) my_init(void);
 static void __attribute__ ((destructor)) my_fini(void);
 
-static struct olsr_cookie_info *prune_packet_history_timer_cookie;
+static struct olsr_timer_info *prune_packet_history_timer_info;
 
 void olsr_plugin_exit(void);
 
@@ -105,10 +105,11 @@ olsrd_plugin_init(void)
   add_ifchgf(&InterfaceChange);
 
   /* create the cookie */
-  prune_packet_history_timer_cookie = olsr_alloc_cookie("BMF: Prune Packet History", OLSR_COOKIE_TYPE_TIMER);
+  prune_packet_history_timer_info =
+      olsr_alloc_timerinfo("BMF: Prune Packet History", &PrunePacketHistory, true);
 
   /* Register the duplicate registration pruning process */
-  olsr_start_timer(3 * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC, &PrunePacketHistory, NULL, prune_packet_history_timer_cookie);
+  olsr_start_timer(3 * MSEC_PER_SEC, 0, NULL, prune_packet_history_timer_info);
 
 
   return InitBmf(NULL);
index fb69819..d664a2d 100644 (file)
 #define PLUGIN_INTERFACE_VERSION 5
 
 static int has_inet_gateway;
-static struct olsr_cookie_info *event_timer_cookie1;
-static struct olsr_cookie_info *event_timer_cookie2;
+static struct olsr_timer_info *event_timer_info1;
+static struct olsr_timer_info *event_timer_info2;
+static struct olsr_timer_info *arping_timer_info;
 static union olsr_ip_addr gw_netmask;
 
+static void check_ping_result(void *foo);
+
 /**
  * Plugin interface version
  * Used by main olsrd to check plugin interface version
@@ -143,13 +146,8 @@ void update_routes_now(void) {
 
   OLSR_INFO(LOG_PLUGINS, "Forcing recalculation of routing-table\n");
 
-  //sets timer to zero
-
-
-  spf_backoff_timer = NULL;
-  ///printf("timer stopped\n");
   //actual calculation
-  olsr_calculate_routing_table();
+  olsr_calculate_routing_table(true);
   //printf("updated\n");
 }
 
@@ -316,12 +314,13 @@ int olsrd_plugin_init(void) {
   has_inet_gateway = 0;
 
   /* create the cookie */
-  event_timer_cookie1 = olsr_alloc_cookie("cl roam: Event1", OLSR_COOKIE_TYPE_TIMER);
-  event_timer_cookie2 = olsr_alloc_cookie("cl roam: Event2", OLSR_COOKIE_TYPE_TIMER);
+  event_timer_info1 = olsr_alloc_timerinfo("cl roam: Event1", &olsr_event1, true);
+  event_timer_info2 = olsr_alloc_timerinfo("cl roam: Event2", &olsr_event2, true);
+  arping_timer_info = olsr_alloc_timerinfo("cl roam: Maybe add something", &check_ping_result, true);
 
   /* Register the GW check */
-  olsr_start_timer(1 * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC, &olsr_event1, NULL, event_timer_cookie1);
-  olsr_start_timer(20 * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC, &olsr_event2, NULL, event_timer_cookie2);
+  olsr_start_timer(1 * MSEC_PER_SEC, 0, NULL, event_timer_info1);
+  olsr_start_timer(20 * MSEC_PER_SEC, 0, NULL, event_timer_info2);
 
   /* register functions with olsrd */
   // somehow my cool new message.....
@@ -422,10 +421,8 @@ static void check_for_route(struct guest_client * host) {
 
     //printf("maybe add something\n");
     if (host->arping_timer_cookie == NULL)
-      host->arping_timer_cookie = olsr_alloc_cookie("cl roam: Maybe add something", OLSR_COOKIE_TYPE_TIMER);
     //printf("timer started\n");
-    host->arping_timer = olsr_start_timer(250, 5, OLSR_TIMER_PERIODIC, &check_ping_result, host,
-        host->arping_timer_cookie);
+    host->arping_timer = olsr_start_timer(250, 5, host, arping_timer_info);
     rc = pthread_create(&(host->ping_thread_add), NULL, ping_thread, (void *) host);
   } else if ((host->last_seen > 60.0) && host->is_announced) {
     char route_command[50];
index 4c35b10..d979969 100644 (file)
@@ -120,10 +120,11 @@ static struct avl_tree stat_msg_tree, stat_pkt_tree;
 static struct debug_msgtraffic_count total_msg_traffic;
 static struct debug_pkttraffic_count total_pkt_traffic;
 
-static struct olsr_cookie_info *statistics_timer = NULL;
 static struct olsr_cookie_info *statistics_msg_mem = NULL;
 static struct olsr_cookie_info *statistics_pkt_mem = NULL;
 
+static struct olsr_timer_info *statistics_timer = NULL;
+
 static union olsr_ip_addr total_ip_addr;
 
 int
@@ -195,15 +196,13 @@ olsrd_plugin_init(void)
     commands[i].cmd->acl = &allowed_nets;
   }
 
-  statistics_timer = olsr_alloc_cookie("debuginfo timer", OLSR_COOKIE_TYPE_TIMER);
-  olsr_start_timer(traffic_interval * 1000, 0, true, &update_statistics_ptr, NULL, statistics_timer);
+  statistics_timer = olsr_alloc_timerinfo("debuginfo timer", &update_statistics_ptr, true);
+  olsr_start_timer(traffic_interval * 1000, 0, NULL, statistics_timer);
 
-  statistics_msg_mem = olsr_alloc_cookie("debuginfo msgstat", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(statistics_msg_mem,
+  statistics_msg_mem = olsr_alloc_cookie("debuginfo msgstat",
       sizeof(struct debug_msgtraffic) + sizeof(struct debug_msgtraffic_count) * traffic_slots);
 
-  statistics_pkt_mem = olsr_alloc_cookie("debuginfo pktstat", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(statistics_pkt_mem,
+  statistics_pkt_mem = olsr_alloc_cookie("debuginfo pktstat",
       sizeof(struct debug_pkttraffic) + sizeof(struct debug_pkttraffic_count) * traffic_slots);
 
   memset(&total_msg_traffic, 0, sizeof(total_msg_traffic));
@@ -540,33 +539,26 @@ debuginfo_pktstat(struct comport_connection *con,
   return CONTINUE;
 }
 
-static INLINE bool debuginfo_print_cookies_mem(struct autobuf *buf, const char *format) {
+static INLINE bool debuginfo_print_cookies_mem(struct autobuf *buf) {
   struct olsr_cookie_info *c;
   struct list_iterator iterator;
 
   OLSR_FOR_ALL_COOKIES(c, iterator) {
-    if (c == NULL || c->ci_type != OLSR_COOKIE_TYPE_MEMORY) {
-      continue;
-    }
-    if (abuf_appendf(buf, format,
-        c->ci_name == NULL ? "Unknown" : c->ci_name,
-        (unsigned long)c->ci_size, c->ci_usage, c->ci_free_list_usage) < 0) {
+    if (abuf_appendf(buf, "%-25s (MEMORY) size: %lu usage: %u freelist: %u\n",
+        c->ci_name, (unsigned long)c->ci_size, c->ci_usage, c->ci_free_list_usage) < 0) {
       return true;
     }
   }
   return false;
 }
 
-static INLINE bool debuginfo_print_cookies_timer(struct autobuf *buf, const char *format) {
-  struct olsr_cookie_info *c;
+static INLINE bool debuginfo_print_cookies_timer(struct autobuf *buf) {
+  struct olsr_timer_info *t;
   struct list_iterator iterator;
 
-  OLSR_FOR_ALL_COOKIES(c, iterator) {
-    if (c == NULL || c->ci_type != OLSR_COOKIE_TYPE_TIMER) {
-      continue;
-    }
-    if (abuf_appendf(buf, format, c->ci_name == NULL ? "Unknown" : c->ci_name,
-                       c->ci_usage, c->ci_changes) < 0) {
+  OLSR_FOR_ALL_TIMERS(t, iterator) {
+    if (abuf_appendf(buf, "%-25s (TIMER) usage: %u changes: %u\n",
+        t->name, t->usage, t->changes) < 0) {
       return true;
     }
   }
@@ -581,7 +573,7 @@ debuginfo_cookies(struct comport_connection *con,
     return ABUF_ERROR;
   }
 
-  if (debuginfo_print_cookies_mem(&con->out, "%-25s (MEMORY) size: %lu usage: %u freelist: %u\n")) {
+  if (debuginfo_print_cookies_mem(&con->out)) {
     return ABUF_ERROR;
   }
 
@@ -589,7 +581,7 @@ debuginfo_cookies(struct comport_connection *con,
     return ABUF_ERROR;
   }
 
-  if (debuginfo_print_cookies_timer(&con->out, "%-25s (TIMER) usage: %u changes: %u\n")) {
+  if (debuginfo_print_cookies_timer(&con->out)) {
     return ABUF_ERROR;
   }
   return CONTINUE;
index caf7297..a820953 100644 (file)
@@ -192,7 +192,7 @@ olsrd_get_plugin_parameters(const struct olsrd_plugin_parameters **params, int *
   *size = ARRAYSIZE(plugin_parameters);
 }
 
-static struct olsr_cookie_info *doing_hna_timer_cookie;
+static struct olsr_timer_info *doing_hna_timer_info;
 
 /**
  *Do initialization here
@@ -223,10 +223,10 @@ olsrd_plugin_init(void)
   pthread_create(&ping_thread, NULL, (void *(*)(void *))looped_checks, NULL);
 
   /* create the cookie */
-  doing_hna_timer_cookie = olsr_alloc_cookie("DynGW: Doing HNS", OLSR_COOKIE_TYPE_TIMER);
+  doing_hna_timer_info = olsr_alloc_timerinfo("DynGW: Doing HNS", &olsr_event_doing_hna, true);
 
   /* Register the GW check */
-  olsr_start_timer(3 * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC, &olsr_event_doing_hna, NULL, doing_hna_timer_cookie);
+  olsr_start_timer(3 * MSEC_PER_SEC, 0, NULL, doing_hna_timer_info);
 
   return 1;
 }
index cb2a999..b29ba17 100644 (file)
@@ -58,7 +58,7 @@
 #define PLUGIN_INTERFACE_VERSION 5
 
 static int has_inet_gateway;
-static struct olsr_cookie_info *event_timer_cookie;
+static struct olsr_timer_info *event_timer_info;
 static union olsr_ip_addr gw_net;
 static union olsr_ip_addr gw_netmask;
 
@@ -102,10 +102,10 @@ olsrd_plugin_init(void)
   }
 
   /* create the cookie */
-  event_timer_cookie = olsr_alloc_cookie("DynGW Plain: Event", OLSR_COOKIE_TYPE_TIMER);
+  event_timer_info = olsr_alloc_timerinfo("DynGW Plain: Event", &olsr_event, true);
 
   /* Register the GW check */
-  olsr_start_timer(3 * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC, &olsr_event, NULL, event_timer_cookie);
+  olsr_start_timer(3 * MSEC_PER_SEC, 0, NULL, event_timer_info);
 
   return 1;
 }
index e051b67..22cb693 100644 (file)
@@ -88,7 +88,7 @@ static int lq_etxff_get_linkentry_data(struct link_entry *, int);
 static const char *lq_etxff_print_cost(olsr_linkcost cost, char *buffer, size_t bufsize);
 static const char *lq_etxff_print_link_entry_lq(struct link_entry *entry, int index, char *buffer, size_t bufsize);
 
-static struct olsr_cookie_info *default_lq_ff_timer_cookie = NULL;
+static struct olsr_timer_info *default_lq_ff_timer_info = NULL;
 
 OLSR_PLUGIN6_NP() {
   .descr = PLUGIN_DESCR,
@@ -270,8 +270,8 @@ lq_etxff_initialize(void)
 {
   /* Some cookies for stats keeping */
   olsr_packetparser_add_function(&lq_etxff_packet_parser);
-  default_lq_ff_timer_cookie = olsr_alloc_cookie("Default Freifunk LQ", OLSR_COOKIE_TYPE_TIMER);
-  lq_etxff_timer_struct = olsr_start_timer(1000, 0, OLSR_TIMER_PERIODIC, &lq_etxff_timer, NULL, default_lq_ff_timer_cookie);
+  default_lq_ff_timer_info = olsr_alloc_timerinfo("Default Freifunk LQ",  &lq_etxff_timer, true);
+  lq_etxff_timer_struct = olsr_start_timer(1000, 0, NULL, default_lq_ff_timer_info);
 }
 
 static void
index e618d3f..90e8417 100644 (file)
@@ -60,6 +60,7 @@
 #include "mapwrite.h"
 
 static char my_latlon_str[48];
+static struct olsr_timer_info *map_poll_timer_info;
 
 /**
  * lookup a nodes position
@@ -232,7 +233,8 @@ mapwrite_init(const char *fifoname)
       OLSR_WARN(LOG_PLUGINS, "mkfifo(%s): %s", fifoname, strerror(errno));
       return false;
     } else {
-      olsr_start_timer(800, 5, OLSR_TIMER_PERIODIC, &mapwrite_poll, NULL, map_poll_timer_cookie);
+      map_poll_timer_info = olsr_alloc_timerinfo("Nameservice: mapwrite", &mapwrite_poll, true);
+      olsr_start_timer(800, 5, NULL, map_poll_timer_info);
     }
   }
   return true;
index eb338c3..03704cb 100644 (file)
@@ -76,6 +76,7 @@
 #include "mapwrite.h"
 #include "common/string.h"
 
+static void olsr_nameservice_expire_db_timer(void *context);
 
 /* config parameters */
 static char my_hosts_file[MAX_FILE + 1];
@@ -94,10 +95,10 @@ static char my_macs_change_script[MAX_FILE + 1];
 static char latlon_in_file[MAX_FILE + 1];
 static char my_latlon_file[MAX_FILE + 1];
 float my_lat = 0.0, my_lon = 0.0;
-static struct olsr_cookie_info *msg_gen_timer_cookie;
-static struct olsr_cookie_info *write_file_timer_cookie;
-static struct olsr_cookie_info *db_timer_cookie;
-struct olsr_cookie_info *map_poll_timer_cookie;
+
+static struct olsr_timer_info *msg_gen_timer_cookie;
+static struct olsr_timer_info *write_file_timer_cookie;
+static struct olsr_timer_info *db_timer_cookie;
 
 /* the databases (using hashing)
  * for hostnames, service_lines and dns-servers
@@ -199,10 +200,12 @@ name_constructor(void)
     list_init_head(&latlon_list[i]);
   }
 
-  msg_gen_timer_cookie = olsr_alloc_cookie("Nameservice: message gen", OLSR_COOKIE_TYPE_TIMER);
-  write_file_timer_cookie = olsr_alloc_cookie("Nameservice: write file", OLSR_COOKIE_TYPE_TIMER);
-  db_timer_cookie = olsr_alloc_cookie("Nameservice: DB", OLSR_COOKIE_TYPE_TIMER);
-  map_poll_timer_cookie = olsr_alloc_cookie("Nameservice: map poll", OLSR_COOKIE_TYPE_TIMER);
+  msg_gen_timer_cookie =
+      olsr_alloc_timerinfo("Nameservice: message gen", &olsr_namesvc_gen, true);
+  write_file_timer_cookie =
+      olsr_alloc_timerinfo("Nameservice: write file", &olsr_expire_write_file_timer, false);
+  db_timer_cookie =
+      olsr_alloc_timerinfo("Nameservice: DB", &olsr_nameservice_expire_db_timer, false);
 }
 
 
@@ -425,7 +428,7 @@ name_init(void)
 
   /* periodic message generation */
   msg_gen_timer = olsr_start_timer(my_interval * MSEC_PER_SEC, EMISSION_JITTER,
-                                   OLSR_TIMER_PERIODIC, &olsr_namesvc_gen, NULL, msg_gen_timer_cookie);
+                                   NULL, msg_gen_timer_cookie);
 
   mapwrite_init(my_latlon_file);
 
@@ -566,8 +569,7 @@ olsr_start_write_file_timer(void)
     return;
   }
 
-  write_file_timer = olsr_start_timer(5 * MSEC_PER_SEC, 5, OLSR_TIMER_ONESHOT,
-                                      olsr_expire_write_file_timer, NULL, write_file_timer_cookie);
+  write_file_timer = olsr_start_timer(5 * MSEC_PER_SEC, 5, NULL, write_file_timer_cookie);
 }
 
 /*
@@ -953,7 +955,7 @@ insert_new_name_in_list(union olsr_ip_addr *originator,
       decap_namemsg(from_packet, &entry->names, this_table_changed);
 
       olsr_set_timer(&entry->db_timer, vtime,
-                     OLSR_NAMESVC_DB_JITTER, OLSR_TIMER_ONESHOT, &olsr_nameservice_expire_db_timer, entry, db_timer_cookie);
+                     OLSR_NAMESVC_DB_JITTER, entry, db_timer_cookie);
 
       entry_found = true;
     }
@@ -972,7 +974,7 @@ insert_new_name_in_list(union olsr_ip_addr *originator,
     entry->originator = *originator;
 
     olsr_set_timer(&entry->db_timer, vtime,
-                   OLSR_LINK_LOSS_JITTER, OLSR_TIMER_ONESHOT, &olsr_nameservice_expire_db_timer, entry, db_timer_cookie);
+                   OLSR_LINK_LOSS_JITTER, entry, db_timer_cookie);
 
     entry->names = NULL;
 
index 7ff7829..ef54fd0 100644 (file)
@@ -1623,12 +1623,12 @@ InitOBAMP(void)
 
 
 
-  struct olsr_cookie_info *OBAMP_alive_gen_timer_cookie = NULL;
-  struct olsr_cookie_info *purge_nodes_timer_cookie = NULL;
-  struct olsr_cookie_info *mesh_create_timer_cookie = NULL;
-  struct olsr_cookie_info *tree_create_timer_cookie = NULL;
-  struct olsr_cookie_info *outer_tree_create_timer_cookie = NULL;
-  struct olsr_cookie_info *unsolicited_tree_destroy_timer_cookie = NULL;
+  struct olsr_timer_info *OBAMP_alive_gen_timer_cookie = NULL;
+  struct olsr_timer_info *purge_nodes_timer_cookie = NULL;
+  struct olsr_timer_info *mesh_create_timer_cookie = NULL;
+  struct olsr_timer_info *tree_create_timer_cookie = NULL;
+  struct olsr_timer_info *outer_tree_create_timer_cookie = NULL;
+  struct olsr_timer_info *unsolicited_tree_destroy_timer_cookie = NULL;
 
   if (olsr_cnf->ip_version == AF_INET6) {
     OLSR_ERROR(LOG_PLUGINS, "OBAMP does not support IPv6 at the moment.");
@@ -1655,12 +1655,18 @@ InitOBAMP(void)
   list_init_head(&ListOfObampNodes);
 
 //OLSR cookies stuff for timers
-  OBAMP_alive_gen_timer_cookie = olsr_alloc_cookie("OBAMP Alive Generation", OLSR_COOKIE_TYPE_TIMER);
-  purge_nodes_timer_cookie = olsr_alloc_cookie("purge nodes Generation", OLSR_COOKIE_TYPE_TIMER);
-  mesh_create_timer_cookie = olsr_alloc_cookie("mesh create Generation", OLSR_COOKIE_TYPE_TIMER);
-  tree_create_timer_cookie = olsr_alloc_cookie("tree create Generation", OLSR_COOKIE_TYPE_TIMER);
-  outer_tree_create_timer_cookie = olsr_alloc_cookie("outer tree create Generation", OLSR_COOKIE_TYPE_TIMER);
-  unsolicited_tree_destroy_timer_cookie = olsr_alloc_cookie("tree destroy Generation", OLSR_COOKIE_TYPE_TIMER);
+  OBAMP_alive_gen_timer_cookie =
+      olsr_alloc_timerinfo("OBAMP Alive Generation", &obamp_alive_gen, true);
+  purge_nodes_timer_cookie =
+      olsr_alloc_timerinfo("purge nodes Generation", &purge_nodes, true);
+  mesh_create_timer_cookie =
+      olsr_alloc_timerinfo("mesh create Generation", &mesh_create, true);
+  tree_create_timer_cookie =
+      olsr_alloc_timerinfo("tree create Generation", &tree_create, true);
+  outer_tree_create_timer_cookie =
+      olsr_alloc_timerinfo("outer tree create Generation", &outer_tree_create, true);
+  unsolicited_tree_destroy_timer_cookie =
+      olsr_alloc_timerinfo("tree destroy Generation", &unsolicited_tree_destroy, true);
 
 
 //Tells OLSR to launch olsr_parser when the packets for this plugin arrive
@@ -1668,32 +1674,32 @@ InitOBAMP(void)
 
 // start to send alive messages to appear in other joined lists
   OBAMP_alive_timer =
-    olsr_start_timer(OBAMP_ALIVE_EIVAL * MSEC_PER_SEC, OBAMP_JITTER, OLSR_TIMER_PERIODIC, &obamp_alive_gen, NULL,
+    olsr_start_timer(OBAMP_ALIVE_EIVAL * MSEC_PER_SEC, OBAMP_JITTER, NULL,
                      OBAMP_alive_gen_timer_cookie);
 
 // start timer to purge nodes from list in softstate fashion
   purge_nodes_timer =
-    olsr_start_timer(_Texpire_timer_ * MSEC_PER_SEC, OBAMP_JITTER, OLSR_TIMER_PERIODIC, &purge_nodes, NULL,
+    olsr_start_timer(_Texpire_timer_ * MSEC_PER_SEC, OBAMP_JITTER, NULL,
                      purge_nodes_timer_cookie);
 
 //start timer to create mesh
   mesh_create_timer =
-    olsr_start_timer(OBAMP_MESH_CREATE_IVAL * MSEC_PER_SEC, OBAMP_JITTER, OLSR_TIMER_PERIODIC, &mesh_create, NULL,
+    olsr_start_timer(OBAMP_MESH_CREATE_IVAL * MSEC_PER_SEC, OBAMP_JITTER, NULL,
                      mesh_create_timer_cookie);
 
 //start timer for tree create procedure
   tree_create_timer =
-    olsr_start_timer(OBAMP_TREE_CREATE_IVAL * MSEC_PER_SEC, OBAMP_JITTER, OLSR_TIMER_PERIODIC, &tree_create, NULL,
+    olsr_start_timer(OBAMP_TREE_CREATE_IVAL * MSEC_PER_SEC, OBAMP_JITTER, NULL,
                      tree_create_timer_cookie);
 
 //start timer for tree create procedure
   outer_tree_create_timer =
-    olsr_start_timer(OBAMP_OUTER_TREE_CREATE_IVAL * MSEC_PER_SEC, OBAMP_JITTER, OLSR_TIMER_PERIODIC, &outer_tree_create, NULL,
+    olsr_start_timer(OBAMP_OUTER_TREE_CREATE_IVAL * MSEC_PER_SEC, OBAMP_JITTER, NULL,
                      tree_create_timer_cookie);
 
 //start timer for tree create procedure
   unsolicited_tree_destroy_timer =
-    olsr_start_timer(30 * MSEC_PER_SEC, OBAMP_JITTER, OLSR_TIMER_PERIODIC, &unsolicited_tree_destroy, NULL,
+    olsr_start_timer(30 * MSEC_PER_SEC, OBAMP_JITTER, NULL,
                      unsolicited_tree_destroy_timer_cookie);
 
 //Create udp server socket for OBAMP signalling and register it to the scheduler
index 6247925..b732818 100644 (file)
@@ -43,7 +43,7 @@ static set_plugin_parameter set_exportroutes;
 static set_plugin_parameter set_distance;
 static set_plugin_parameter set_localpref;
 
-static struct olsr_cookie_info *event_timer_cookie;
+static struct olsr_timer_info *event_timer_info;
 
 int
 olsrd_plugin_interface_version(void)
@@ -138,9 +138,9 @@ olsrd_plugin_init(void)
     return 1;
   }
 
-  event_timer_cookie = olsr_alloc_cookie("Quagga: Event", OLSR_COOKIE_TYPE_TIMER);
+  event_timer_info = olsr_alloc_timerinfo("Quagga: Event", &zebra_parse, true);
 
-  olsr_start_timer(1 * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC, &zebra_parse, NULL, event_timer_cookie);
+  olsr_start_timer(1 * MSEC_PER_SEC, 0, NULL, event_timer_info);
 
   return 0;
 }
index 9dc8835..4d19432 100644 (file)
@@ -162,7 +162,7 @@ static int check_timestamp(struct interface *olsr_if_config, const union olsr_ip
 static struct stamp *lookup_timestamp_entry(const union olsr_ip_addr *);
 static int read_key_from_file(const char *);
 
-static struct olsr_cookie_info *timeout_timestamps_timer_cookie;
+static struct olsr_timer_info *timeout_timestamps_timer_info;
 
 /**
  *Do initialization here
@@ -203,10 +203,10 @@ secure_plugin_init(void)
   olsr_preprocessor_add_function(&secure_preprocessor);
 
   /* create the cookie */
-  timeout_timestamps_timer_cookie = olsr_alloc_cookie("Secure: Timeout Timestamps", OLSR_COOKIE_TYPE_TIMER);
+  timeout_timestamps_timer_info = olsr_alloc_timerinfo("Secure: Timeout Timestamps", &timeout_timestamps, true);
 
   /* Register timeout - poll every 2 seconds */
-  olsr_start_timer(2 * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC, &timeout_timestamps, NULL, timeout_timestamps_timer_cookie);
+  olsr_start_timer(2 * MSEC_PER_SEC, 0, NULL, timeout_timestamps_timer_info);
 
   return 1;
 }
index 66e7fc7..be42db6 100644 (file)
@@ -61,7 +61,7 @@
 #include <time.h>
 #define PLUGIN_INTERFACE_VERSION 5
 
-static struct olsr_cookie_info *watchdog_timer_cookie;
+static struct olsr_timer_info *watchdog_timer_info;
 
 static char watchdog_filename[FILENAME_MAX + 1] = "/tmp/olsr.watchdog";
 static int watchdog_interval = 5;
@@ -129,11 +129,11 @@ int
 olsrd_plugin_init(void)
 {
   /* create the cookie */
-  watchdog_timer_cookie = olsr_alloc_cookie("Watchdog: write alive-file", OLSR_COOKIE_TYPE_TIMER);
+  watchdog_timer_info = olsr_alloc_timerinfo("Watchdog: write alive-file",
+      &olsr_watchdog_write_alivefile, true);
 
-  /* Register the GW check */
-  olsr_start_timer(watchdog_interval * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC,
-                   &olsr_watchdog_write_alivefile, NULL, watchdog_timer_cookie);
+  /* Register the watchdog check */
+  olsr_start_timer(watchdog_interval * MSEC_PER_SEC, 0, NULL, watchdog_timer_info);
 
   return 1;
 }
index 982a737..fb96d66 100644 (file)
@@ -54,7 +54,7 @@
 struct avl_tree forward_set, processing_set;
 
 /* Some cookies for stats keeping */
-static struct olsr_cookie_info *duplicate_timer_cookie = NULL;
+static struct olsr_timer_info *duplicate_timer_info = NULL;
 static struct olsr_cookie_info *duplicate_mem_cookie = NULL;
 
 int
@@ -73,23 +73,6 @@ olsr_seqno_diff(uint16_t reference, uint16_t other)
   return diff;
 }
 
-void
-olsr_init_duplicate_set(void)
-{
-  OLSR_INFO(LOG_DUPLICATE_SET, "Initialize duplicate set...\n");
-
-  avl_init(&forward_set, avl_comp_default, false, NULL);
-  avl_init(&processing_set, avl_comp_default, false, NULL);
-
-  /*
-   * Get some cookies for getting stats to ease troubleshooting.
-   */
-  duplicate_timer_cookie = olsr_alloc_cookie("Duplicate Set", OLSR_COOKIE_TYPE_TIMER);
-
-  duplicate_mem_cookie = olsr_alloc_cookie("dup_entry", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(duplicate_mem_cookie, sizeof(struct dup_entry));
-}
-
 static struct dup_entry *
 olsr_create_duplicate_entry(union olsr_ip_addr *ip, uint16_t seqnr)
 {
@@ -125,6 +108,23 @@ olsr_expire_duplicate_entry(void *context)
   olsr_delete_duplicate_entry(entry);
 }
 
+void
+olsr_init_duplicate_set(void)
+{
+  OLSR_INFO(LOG_DUPLICATE_SET, "Initialize duplicate set...\n");
+
+  avl_init(&forward_set, avl_comp_default, false, NULL);
+  avl_init(&processing_set, avl_comp_default, false, NULL);
+
+  /*
+   * Get some cookies for getting stats to ease troubleshooting.
+   */
+  duplicate_timer_info = olsr_alloc_timerinfo("Duplicate Set", &olsr_expire_duplicate_entry, false);
+
+  duplicate_mem_cookie = olsr_alloc_cookie("dup_entry", sizeof(struct dup_entry));
+}
+
+
 /**
  * Clean up the house. Called during shutdown.
  */
@@ -171,7 +171,7 @@ olsr_is_duplicate_message(struct olsr_message *m, bool forwarding, enum duplicat
       avl_insert(tree, &entry->avl);
       entry->tree = tree;
       entry->validity_timer = olsr_start_timer(DUPLICATE_CLEANUP_INTERVAL, DUPLICATE_CLEANUP_JITTER,
-                                               OLSR_TIMER_ONESHOT, &olsr_expire_duplicate_entry, entry, duplicate_timer_cookie);
+                                               entry, duplicate_timer_info);
     }
 
     *status = NEW_OLSR_MESSAGE;
@@ -181,7 +181,7 @@ olsr_is_duplicate_message(struct olsr_message *m, bool forwarding, enum duplicat
   /*
    * Refresh timer.
    */
-  olsr_change_timer(entry->validity_timer, DUPLICATE_CLEANUP_INTERVAL, DUPLICATE_CLEANUP_JITTER, OLSR_TIMER_ONESHOT);
+  olsr_change_timer(entry->validity_timer, DUPLICATE_CLEANUP_INTERVAL, DUPLICATE_CLEANUP_JITTER);
 
   diff = olsr_seqno_diff(m->seqno, entry->seqnr);
 
index 8aa69cf..b75f953 100644 (file)
 #include "olsr_logging.h"
 
 /* Some cookies for stats keeping */
-static struct olsr_cookie_info *hna_net_timer_cookie = NULL;
+static struct olsr_timer_info *hna_net_timer_info = NULL;
 static struct olsr_cookie_info *hna_net_mem_cookie = NULL;
 
+static void olsr_expire_hna_net_entry(void *context);
+
 /**
  * Initialize the HNA set
  */
@@ -62,10 +64,9 @@ olsr_init_hna_set(void)
 {
   OLSR_INFO(LOG_HNA, "Initialize HNA set...\n");
 
-  hna_net_timer_cookie = olsr_alloc_cookie("HNA Network", OLSR_COOKIE_TYPE_TIMER);
+  hna_net_timer_info = olsr_alloc_timerinfo("HNA Network", &olsr_expire_hna_net_entry, false);
 
-  hna_net_mem_cookie = olsr_alloc_cookie("hna_net", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(hna_net_mem_cookie, sizeof(struct hna_net));
+  hna_net_mem_cookie = olsr_alloc_cookie("hna_net", sizeof(struct hna_net));
 }
 
 /**
@@ -223,7 +224,7 @@ olsr_update_hna_entry(const union olsr_ip_addr *gw, const struct olsr_ip_prefix
    * Start, or refresh the timer, whatever is appropriate.
    */
   olsr_set_timer(&net_entry->hna_net_timer, vtime,
-                 OLSR_HNA_NET_JITTER, OLSR_TIMER_ONESHOT, &olsr_expire_hna_net_entry, net_entry, hna_net_timer_cookie);
+                 OLSR_HNA_NET_JITTER, net_entry, hna_net_timer_info);
 }
 
 /**
index 7ee4300..ccd0767 100644 (file)
@@ -59,7 +59,7 @@ int
   set_flag(char *, short);
 #endif
 
-struct interface *os_init_interface(struct olsr_if_config *);
+int os_init_interface(struct interface *, struct olsr_if_config *);
 int chk_if_changed(struct olsr_if_config *);
 
 #ifdef WIN32
index e4885d1..38db049 100644 (file)
@@ -76,15 +76,11 @@ static struct ifchgf *ifchgf_list = NULL;
 
 
 /* Some cookies for stats keeping */
-struct olsr_cookie_info *interface_mem_cookie = NULL;
-struct olsr_cookie_info *interface_poll_timer_cookie = NULL;
-struct olsr_cookie_info *interface_lost_mem_cookie = NULL;
+static struct olsr_cookie_info *interface_mem_cookie = NULL;
+static struct olsr_cookie_info *interface_lost_mem_cookie = NULL;
 
-struct olsr_cookie_info *hello_gen_timer_cookie = NULL;
-struct olsr_cookie_info *tc_gen_timer_cookie = NULL;
-struct olsr_cookie_info *mid_gen_timer_cookie = NULL;
-struct olsr_cookie_info *hna_gen_timer_cookie = NULL;
-struct olsr_cookie_info *buffer_hold_timer_cookie = NULL;
+static struct olsr_timer_info *interface_poll_timerinfo = NULL;
+static struct olsr_timer_info *hello_gen_timerinfo = NULL;
 
 static void check_interface_updates(void *);
 
@@ -106,19 +102,12 @@ init_interfaces(void)
   /*
    * Get some cookies for getting stats to ease troubleshooting.
    */
-  interface_mem_cookie = olsr_alloc_cookie("Interface", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(interface_mem_cookie, sizeof(struct interface));
+  interface_mem_cookie = olsr_alloc_cookie("Interface", sizeof(struct interface));
 
-  interface_lost_mem_cookie = olsr_alloc_cookie("Interface lost", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(interface_lost_mem_cookie, sizeof(struct interface_lost));
+  interface_lost_mem_cookie = olsr_alloc_cookie("Interface lost", sizeof(struct interface_lost));
 
-  interface_poll_timer_cookie = olsr_alloc_cookie("Interface Polling", OLSR_COOKIE_TYPE_TIMER);
-  buffer_hold_timer_cookie = olsr_alloc_cookie("Buffer Hold", OLSR_COOKIE_TYPE_TIMER);
-
-  hello_gen_timer_cookie = olsr_alloc_cookie("Hello Generation", OLSR_COOKIE_TYPE_TIMER);
-  tc_gen_timer_cookie = olsr_alloc_cookie("TC Generation", OLSR_COOKIE_TYPE_TIMER);
-  mid_gen_timer_cookie = olsr_alloc_cookie("MID Generation", OLSR_COOKIE_TYPE_TIMER);
-  hna_gen_timer_cookie = olsr_alloc_cookie("HNA Generation", OLSR_COOKIE_TYPE_TIMER);
+  interface_poll_timerinfo = olsr_alloc_timerinfo("Interface Polling", &check_interface_updates, true);
+  hello_gen_timerinfo = olsr_alloc_timerinfo("Hello Generation", &generate_hello, true);
 
   OLSR_INFO(LOG_INTERFACE, "\n ---- Interface configuration ---- \n\n");
 
@@ -129,7 +118,7 @@ init_interfaces(void)
 
   /* Kick a periodic timer for the network interface update function */
   olsr_start_timer(olsr_cnf->nic_chgs_pollrate, 5,
-                   OLSR_TIMER_PERIODIC, &check_interface_updates, NULL, interface_poll_timer_cookie);
+                   NULL, interface_poll_timerinfo);
 
   return (!list_is_empty(&interface_head));
 }
@@ -193,7 +182,9 @@ struct interface *
 add_interface(struct olsr_if_config *iface) {
   struct interface *ifp;
 
-  if ((ifp = os_init_interface(iface)) == NULL) {
+  ifp = olsr_cookie_malloc(interface_mem_cookie);
+  if ((os_init_interface(ifp, iface))) {
+    olsr_cookie_free(interface_mem_cookie, ifp);
     return NULL;
   }
 
@@ -265,7 +256,7 @@ add_interface(struct olsr_if_config *iface) {
    */
   ifp->hello_gen_timer =
     olsr_start_timer(iface->cnf->hello_params.emission_interval,
-                     HELLO_JITTER, OLSR_TIMER_PERIODIC, &generate_hello, ifp, hello_gen_timer_cookie);
+                     HELLO_JITTER, ifp, hello_gen_timerinfo);
   ifp->hello_interval = iface->cnf->hello_params.emission_interval;
   ifp->hello_validity = iface->cnf->hello_params.validity_time;
 
index 8f0f775..17d0a5e 100644 (file)
@@ -215,14 +215,6 @@ int del_ifchgf(ifchg_cb_func f);
 void lock_interface(struct interface *);
 void unlock_interface(struct interface *);
 
-extern struct olsr_cookie_info *interface_mem_cookie;
-extern struct olsr_cookie_info *interface_poll_timer_cookie;    /* Maybe static */
-extern struct olsr_cookie_info *hello_gen_timer_cookie;
-extern struct olsr_cookie_info *tc_gen_timer_cookie;
-extern struct olsr_cookie_info *mid_gen_timer_cookie;
-extern struct olsr_cookie_info *hna_gen_timer_cookie;
-extern struct olsr_cookie_info *buffer_hold_timer_cookie;
-
 #endif
 
 /*
index 3414fa7..bbbfd31 100644 (file)
 
 #include <assert.h>
 
+static void olsr_expire_link_entry(void *context);
+static void olsr_expire_link_loss_timer(void *context);
+static void olsr_expire_link_sym_timer(void *context);
+
 /* head node for all link sets */
 struct list_entity link_entry_head;
 
-static struct olsr_cookie_info *link_dead_timer_cookie = NULL;
-static struct olsr_cookie_info *link_loss_timer_cookie = NULL;
-static struct olsr_cookie_info *link_sym_timer_cookie = NULL;
+static struct olsr_timer_info *link_dead_timer_info = NULL;
+static struct olsr_timer_info *link_loss_timer_info = NULL;
+static struct olsr_timer_info *link_sym_timer_info = NULL;
 
 bool link_changes;                     /* is set if changes occur in MPRS set */
 
@@ -87,9 +91,9 @@ olsr_init_link_set(void)
   /* Init list head */
   list_init_head(&link_entry_head);
 
-  link_dead_timer_cookie = olsr_alloc_cookie("Link dead", OLSR_COOKIE_TYPE_TIMER);
-  link_loss_timer_cookie = olsr_alloc_cookie("Link loss", OLSR_COOKIE_TYPE_TIMER);
-  link_sym_timer_cookie = olsr_alloc_cookie("Link SYM", OLSR_COOKIE_TYPE_TIMER);
+  link_dead_timer_info = olsr_alloc_timerinfo("Link dead", &olsr_expire_link_entry, false);
+  link_loss_timer_info = olsr_alloc_timerinfo("Link loss", &olsr_expire_link_loss_timer, true);
+  link_sym_timer_info = olsr_alloc_timerinfo("Link SYM", &olsr_expire_link_sym_timer, false);
 
 }
 
@@ -284,7 +288,7 @@ olsr_expire_link_loss_timer(void *context)
   olsr_lq_hello_handler(link, true);
 
   /* next timeout in 1.0 x htime */
-  olsr_change_timer(link->link_loss_timer, link->loss_helloint, OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC);
+  olsr_change_timer(link->link_loss_timer, link->loss_helloint, OLSR_LINK_LOSS_JITTER);
 }
 
 /**
@@ -342,7 +346,7 @@ static void
 olsr_set_link_timer(struct link_entry *link, unsigned int rel_timer)
 {
   olsr_set_timer(&link->link_timer, rel_timer, OLSR_LINK_JITTER,
-                 OLSR_TIMER_ONESHOT, &olsr_expire_link_entry, link, link_dead_timer_cookie);
+                 link, link_dead_timer_info);
 }
 
 /**
@@ -412,7 +416,7 @@ add_link_entry(const union olsr_ip_addr *local,
   link->loss_helloint = htime;
 
   olsr_set_timer(&link->link_loss_timer, htime + htime / 2,
-                 OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC, &olsr_expire_link_loss_timer, link, link_loss_timer_cookie);
+                 OLSR_LINK_LOSS_JITTER, link, link_loss_timer_info);
 
   set_loss_link_multiplier(link);
 
@@ -543,7 +547,7 @@ update_link_entry(const union olsr_ip_addr *local,
 
     /* L_SYM_time = current time + validity time */
     olsr_set_timer(&entry->link_sym_timer, message->comm->vtime,
-                   OLSR_LINK_SYM_JITTER, OLSR_TIMER_ONESHOT, &olsr_expire_link_sym_timer, entry, link_sym_timer_cookie);
+                   OLSR_LINK_SYM_JITTER, entry, link_sym_timer_info);
 
     /* L_time = L_SYM_time + NEIGHB_HOLD_TIME */
     olsr_set_link_timer(entry, message->comm->vtime + NEIGHB_HOLD_TIME);
@@ -725,7 +729,7 @@ olsr_update_packet_loss(struct link_entry *entry)
 
   /* timeout for the first lost packet is 1.5 x htime */
   olsr_set_timer(&entry->link_loss_timer, entry->loss_helloint + entry->loss_helloint / 2,
-                 OLSR_LINK_LOSS_JITTER, OLSR_TIMER_PERIODIC, &olsr_expire_link_loss_timer, entry, link_loss_timer_cookie);
+                 OLSR_LINK_LOSS_JITTER, entry, link_loss_timer_info);
 }
 
 void
index e20548d..105cac0 100644 (file)
@@ -69,14 +69,13 @@ init_lq_handler(void)
 
   OLSR_INFO(LOG_LQ_PLUGINS, "Initializing LQ handler %s...\n", active_lq_handler->name);
 
-  tc_edge_mem_cookie = olsr_alloc_cookie("tc_edge", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(tc_edge_mem_cookie, active_lq_handler->size_tc_edge);
+  tc_edge_mem_cookie = olsr_alloc_cookie("tc_edge", active_lq_handler->size_tc_edge);
 
-  lq_hello_neighbor_mem_cookie = olsr_alloc_cookie("lq_hello_neighbor", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(lq_hello_neighbor_mem_cookie, active_lq_handler->size_lq_hello_neighbor);
+  lq_hello_neighbor_mem_cookie =
+      olsr_alloc_cookie("lq_hello_neighbor", active_lq_handler->size_lq_hello_neighbor);
 
-  link_entry_mem_cookie = olsr_alloc_cookie("link_entry", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(link_entry_mem_cookie, active_lq_handler->size_link_entry);
+  link_entry_mem_cookie =
+      olsr_alloc_cookie("link_entry", active_lq_handler->size_link_entry);
 
   if (active_lq_handler->initialize) {
     active_lq_handler->initialize();
index 438f3ee..5d65ac2 100644 (file)
@@ -122,7 +122,10 @@ int
 main(int argc, char *argv[])
 {
   /* Some cookies for stats keeping */
-  static struct olsr_cookie_info *pulse_timer_cookie = NULL;
+  static struct olsr_timer_info *pulse_timer_info = NULL;
+  static struct olsr_timer_info *tc_gen_timer_info = NULL;
+  static struct olsr_timer_info *mid_gen_timer_info = NULL;
+  static struct olsr_timer_info *hna_gen_timer_info = NULL;
 
   char conf_file_name[FILENAME_MAX];
   char parse_msg[FILENAME_MAX + 256];
@@ -235,6 +238,11 @@ main(int argc, char *argv[])
   /* Initialize timers and scheduler part */
   olsr_init_timers();
 
+  pulse_timer_info = olsr_alloc_timerinfo("Stdout pulse", &generate_stdout_pulse, true);
+  tc_gen_timer_info = olsr_alloc_timerinfo("TC generation", &olsr_output_lq_tc, true);
+  mid_gen_timer_info = olsr_alloc_timerinfo("MID generation", &generate_mid, true);
+  hna_gen_timer_info = olsr_alloc_timerinfo("HNA generation", &generate_hna, true);
+
   /* initialize plugin system */
   olsr_init_pluginsystem();
   olsr_plugins_init(true);
@@ -251,6 +259,9 @@ main(int argc, char *argv[])
   /* Initialize net */
   init_net();
 
+  /* Initialize SPF */
+  olsr_init_spf();
+
 #ifndef WIN32
   /* Disable redirects globally */
   disable_redirects_global(olsr_cnf->ip_version);
@@ -354,8 +365,7 @@ main(int argc, char *argv[])
 
 #if !defined WINCE
   if (olsr_cnf->log_target_stderr > 0 && isatty(STDOUT_FILENO)) {
-    pulse_timer_cookie = olsr_alloc_cookie("Pulse", OLSR_COOKIE_TYPE_TIMER);
-    olsr_start_timer(STDOUT_PULSE_INT, 0, OLSR_TIMER_PERIODIC, &generate_stdout_pulse, NULL, pulse_timer_cookie);
+    olsr_start_timer(STDOUT_PULSE_INT, 0, NULL, pulse_timer_info);
   }
 #endif
 
@@ -412,14 +422,11 @@ main(int argc, char *argv[])
   link_changes = false;
 
   tc_gen_timer =
-    olsr_start_timer(olsr_cnf->tc_params.emission_interval,
-                     TC_JITTER, OLSR_TIMER_PERIODIC, &olsr_output_lq_tc, NULL, tc_gen_timer_cookie);
+    olsr_start_timer(olsr_cnf->tc_params.emission_interval, TC_JITTER, NULL, tc_gen_timer_info);
   mid_gen_timer =
-    olsr_start_timer(olsr_cnf->mid_params.emission_interval,
-                     MID_JITTER, OLSR_TIMER_PERIODIC, &generate_mid, NULL, mid_gen_timer_cookie);
+    olsr_start_timer(olsr_cnf->mid_params.emission_interval, MID_JITTER, NULL, mid_gen_timer_info);
   hna_gen_timer =
-    olsr_start_timer(olsr_cnf->hna_params.emission_interval,
-                     HNA_JITTER, OLSR_TIMER_PERIODIC, &generate_hna, NULL, hna_gen_timer_cookie);
+    olsr_start_timer(olsr_cnf->hna_params.emission_interval, HNA_JITTER, NULL, hna_gen_timer_info);
 
   /* enable default plugins */
   olsr_plugins_enable(PLUGIN_TYPE_DEFAULT, true);
@@ -604,7 +611,7 @@ olsr_shutdown(void)
   olsr_log_cleanup();
 
   /* Free cookies and memory pools attached. */
-  olsr_delete_all_cookies();
+  olsr_cookie_cleanup();
 
   /* Flush config */
   olsr_free_cfg(olsr_cnf);
index e9368c2..8f79760 100644 (file)
 #include <stdlib.h>
 
 static struct mid_entry *olsr_lookup_mid_entry(const union olsr_ip_addr *);
+static void olsr_expire_mid_entries(void *context);
 
 /* Root of the MID tree */
 struct avl_tree mid_tree;
 
-/* Some cookies for stats keeping */
-static struct olsr_cookie_info *mid_validity_timer_cookie = NULL;
+/* validity timer of MID entries */
 static struct olsr_cookie_info *mid_address_mem_cookie = NULL;
+static struct olsr_timer_info *mid_validity_timer_info = NULL;
 
 /**
  * Initialize the MID set
@@ -77,10 +78,9 @@ olsr_init_mid_set(void)
   /*
    * Get some cookies for getting stats to ease troubleshooting.
    */
-  mid_validity_timer_cookie = olsr_alloc_cookie("MID validity", OLSR_COOKIE_TYPE_TIMER);
+  mid_validity_timer_info = olsr_alloc_timerinfo("MID validity", &olsr_expire_mid_entries, false);
 
-  mid_address_mem_cookie = olsr_alloc_cookie("MID address", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(mid_address_mem_cookie, sizeof(struct mid_entry));
+  mid_address_mem_cookie = olsr_alloc_cookie("MID address", sizeof(struct mid_entry));
 }
 
 /**
@@ -108,13 +108,7 @@ olsr_expire_mid_entries(void *context)
 static void
 olsr_set_mid_timer(struct mid_entry *mid, uint32_t rel_timer)
 {
-  if (mid->mid_timer) {
-    olsr_change_timer(mid->mid_timer, rel_timer, OLSR_MID_JITTER, OLSR_TIMER_ONESHOT);
-  }
-  else {
-    mid->mid_timer = olsr_start_timer(rel_timer, OLSR_MID_JITTER, OLSR_TIMER_ONESHOT,
-        &olsr_expire_mid_entries, mid, mid_validity_timer_cookie);
-  }
+  olsr_set_timer(&mid->mid_timer, rel_timer, OLSR_MID_JITTER, mid, mid_validity_timer_info);
 }
 
 /**
index c594840..2d74726 100644 (file)
 struct avl_tree nbr_tree;
 struct avl_tree nbr2_tree;
 
-/* Some cookies for stats keeping */
+/* memory management */
 static struct olsr_cookie_info *nbr2_mem_cookie = NULL;
 static struct olsr_cookie_info *nbr_mem_cookie = NULL;
-
 static struct olsr_cookie_info *nbr_connector_mem_cookie = NULL;
-static struct olsr_cookie_info *nbr_connector_timer_cookie = NULL;
+
+/* neighbor connection validity timer */
+static struct olsr_timer_info *nbr_connector_timer_info = NULL;
 
 static void olsr_expire_nbr_con(void *);
 static void internal_delete_nbr_con(struct nbr_con *connector);
@@ -76,15 +77,12 @@ olsr_init_neighbor_table(void)
   avl_init(&nbr_tree, avl_comp_default, false, NULL);
   avl_init(&nbr2_tree, avl_comp_default, false, NULL);
 
-  nbr_connector_timer_cookie = olsr_alloc_cookie("Neighbor connector", OLSR_COOKIE_TYPE_TIMER);
-  nbr_connector_mem_cookie = olsr_alloc_cookie("Neighbor connector", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(nbr_connector_mem_cookie, sizeof(struct nbr_con));
+  nbr_connector_timer_info = olsr_alloc_timerinfo("Neighbor connector", &olsr_expire_nbr_con, false);
+  nbr_connector_mem_cookie = olsr_alloc_cookie("Neighbor connector", sizeof(struct nbr_con));
 
-  nbr_mem_cookie = olsr_alloc_cookie("1-Hop Neighbor", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(nbr_mem_cookie, sizeof(struct nbr_entry));
+  nbr_mem_cookie = olsr_alloc_cookie("1-Hop Neighbor", sizeof(struct nbr_entry));
 
-  nbr2_mem_cookie = olsr_alloc_cookie("2-Hop Neighbor", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(nbr2_mem_cookie, sizeof(struct nbr2_entry));
+  nbr2_mem_cookie = olsr_alloc_cookie("2-Hop Neighbor", sizeof(struct nbr2_entry));
 }
 
 /**
@@ -361,7 +359,7 @@ olsr_link_nbr_nbr2(struct nbr_entry *nbr, const union olsr_ip_addr *nbr2_addr, u
    */
   connector = olsr_lookup_nbr_con_entry(nbr, nbr2_addr);
   if (connector) {
-    olsr_change_timer(connector->nbr2_con_timer, vtime, OLSR_NBR2_LIST_JITTER, OLSR_TIMER_ONESHOT);
+    olsr_change_timer(connector->nbr2_con_timer, vtime, OLSR_NBR2_LIST_JITTER);
     return connector;
   }
 
@@ -383,7 +381,7 @@ olsr_link_nbr_nbr2(struct nbr_entry *nbr, const union olsr_ip_addr *nbr2_addr, u
   connector->path_linkcost = LINK_COST_BROKEN;
 
   connector->nbr2_con_timer = olsr_start_timer(vtime, OLSR_NBR2_LIST_JITTER,
-      OLSR_TIMER_ONESHOT, &olsr_expire_nbr_con, connector, nbr_connector_timer_cookie);
+      connector, nbr_connector_timer_info);
 
   return connector;
 }
index 01d70f2..a7cb49f 100644 (file)
@@ -54,6 +54,7 @@
 #include <errno.h>
 
 static void olsr_add_invalid_address(const union olsr_ip_addr *);
+static void olsr_expire_buffer_timer(void *context);
 
 #if 0                           // WIN32
 #define perror(x) WinSockPError(x)
@@ -87,6 +88,9 @@ static const char *const deny_ipv6_defaults[] = {
   NULL
 };
 
+/* buffer writeback timer */
+struct olsr_timer_info *buffer_hold_timer_info;
+
 /*
  * Converts each invalid IP-address from string to network byte order
  * and adds it to the invalid list.
@@ -111,6 +115,63 @@ init_net(void)
     }
     olsr_add_invalid_address(&addr);
   }
+
+  buffer_hold_timer_info = olsr_alloc_timerinfo("Buffer writeback", olsr_expire_buffer_timer, false);
+}
+
+/**
+ * Wrapper for the timer callback.
+ */
+static void
+olsr_expire_buffer_timer(void *context)
+{
+  struct interface *ifn;
+
+  ifn = (struct interface *)context;
+
+  /*
+   * Clear the pointer to indicate that this timer has
+   * been expired and needs to be restarted in case there
+   * will be another message queued in the future.
+   */
+  ifn->buffer_hold_timer = NULL;
+
+  /*
+   * Do we have something to emit ?
+   */
+  if (!net_output_pending(ifn)) {
+    return;
+  }
+
+  OLSR_DEBUG(LOG_NETWORKING, "Buffer Holdtimer for %s timed out, sending data.\n", ifn->int_name);
+
+  net_output(ifn);
+}
+
+/*
+ * set_buffer_timer
+ *
+ * Kick a hold-down timer which defers building of a message.
+ * This has the desired effect that olsr messages get bigger.
+ */
+void
+set_buffer_timer(struct interface *ifn)
+{
+
+  /*
+   * Bail if there is already a timer running.
+   */
+  if (ifn->buffer_hold_timer) {
+    return;
+  }
+
+  /*
+   * This is the first message since the last time this interface has
+   * been drained. Flush the buffer in second or so.
+   */
+  ifn->buffer_hold_timer =
+    olsr_start_timer(OLSR_BUFFER_HOLD_TIME, OLSR_BUFFER_HOLD_JITTER,
+                     ifn, buffer_hold_timer_info);
 }
 
 void
index 0cafd77..0bfb8af 100644 (file)
@@ -65,6 +65,8 @@ struct filter_entry {
 
 void init_net(void);
 
+void set_buffer_timer(struct interface *ifn);
+
 void deinit_netfilters(void);
 
 int net_add_buffer(struct interface *);
index 92487db..6307480 100644 (file)
@@ -162,7 +162,7 @@ olsr_process_changes(void)
 
   /* calculate the routing table */
   if (changes_neighborhood || changes_topology || changes_hna) {
-    olsr_calculate_routing_table();
+    olsr_calculate_routing_table(false);
   }
 
   olsr_print_link_set();
@@ -206,7 +206,7 @@ void
 olsr_init_tables(void)
 {
   /* Some cookies for stats keeping */
-  static struct olsr_cookie_info *periodic_spf_timer_cookie = NULL;
+  static struct olsr_timer_info *periodic_spf_timer_info = NULL;
 
   changes_topology = false;
   changes_neighborhood = false;
@@ -235,9 +235,9 @@ olsr_init_tables(void)
 
   /* Start periodic SPF and RIB recalculation */
   if (olsr_cnf->lq_dinter > 0) {
-    periodic_spf_timer_cookie = olsr_alloc_cookie("Periodic SPF", OLSR_COOKIE_TYPE_TIMER);
+    periodic_spf_timer_info = olsr_alloc_timerinfo("Periodic SPF", &olsr_trigger_forced_update, true);
     olsr_start_timer(olsr_cnf->lq_dinter, 5,
-                     OLSR_TIMER_PERIODIC, &olsr_trigger_forced_update, NULL, periodic_spf_timer_cookie);
+                     NULL, periodic_spf_timer_info);
   }
 }
 
@@ -362,92 +362,35 @@ olsr_forward_message(struct olsr_message *msg, uint8_t *binary, struct interface
   return 1;
 }
 
-/**
- * Wrapper for the timer callback.
- */
 static void
-olsr_expire_buffer_timer(void *context)
+olsr_update_willingness(void *foo __attribute__ ((unused)))
 {
-  struct interface *ifn;
-
-  ifn = (struct interface *)context;
-
-  /*
-   * Clear the pointer to indicate that this timer has
-   * been expired and needs to be restarted in case there
-   * will be another message queued in the future.
-   */
-  ifn->buffer_hold_timer = NULL;
-
-  /*
-   * Do we have something to emit ?
-   */
-  if (!net_output_pending(ifn)) {
-    return;
-  }
-
-  OLSR_DEBUG(LOG_NETWORKING, "Buffer Holdtimer for %s timed out, sending data.\n", ifn->int_name);
-
-  net_output(ifn);
-}
+  int tmp_will = olsr_cnf->willingness;
 
-/*
- * set_buffer_timer
- *
- * Kick a hold-down timer which defers building of a message.
- * This has the desired effect that olsr messages get bigger.
- */
-void
-set_buffer_timer(struct interface *ifn)
-{
+  /* Re-calculate willingness */
+  olsr_cnf->willingness = olsr_calculate_willingness();
 
-  /*
-   * Bail if there is already a timer running.
-   */
-  if (ifn->buffer_hold_timer) {
-    return;
+  if (tmp_will != olsr_cnf->willingness) {
+    OLSR_INFO(LOG_MAIN, "Local willingness updated: old %d new %d\n", tmp_will, olsr_cnf->willingness);
   }
-
-  /*
-   * This is the first message since the last time this interface has
-   * been drained. Flush the buffer in second or so.
-   */
-  ifn->buffer_hold_timer =
-    olsr_start_timer(OLSR_BUFFER_HOLD_TIME, OLSR_BUFFER_HOLD_JITTER,
-                     OLSR_TIMER_ONESHOT, &olsr_expire_buffer_timer, ifn, buffer_hold_timer_cookie);
 }
 
 void
 olsr_init_willingness(void)
 {
   /* Some cookies for stats keeping */
-  static struct olsr_cookie_info *willingness_timer_cookie = NULL;
+  static struct olsr_timer_info *willingness_timer_info = NULL;
 
   if (olsr_cnf->willingness_auto) {
     OLSR_INFO(LOG_MAIN, "Initialize automatic willingness...\n");
     /* Run it first and then periodic. */
     olsr_update_willingness(NULL);
 
-    willingness_timer_cookie = olsr_alloc_cookie("Update Willingness", OLSR_COOKIE_TYPE_TIMER);
-    olsr_start_timer(olsr_cnf->will_int, 5,
-                     OLSR_TIMER_PERIODIC, &olsr_update_willingness, NULL, willingness_timer_cookie);
+    willingness_timer_info = olsr_alloc_timerinfo("Update Willingness", &olsr_update_willingness, true);
+    olsr_start_timer(olsr_cnf->will_int, 5, NULL, willingness_timer_info);
   }
 }
 
-static void
-olsr_update_willingness(void *foo __attribute__ ((unused)))
-{
-  int tmp_will = olsr_cnf->willingness;
-
-  /* Re-calculate willingness */
-  olsr_cnf->willingness = olsr_calculate_willingness();
-
-  if (tmp_will != olsr_cnf->willingness) {
-    OLSR_INFO(LOG_MAIN, "Local willingness updated: old %d new %d\n", tmp_will, olsr_cnf->willingness);
-  }
-}
-
-
 /**
  *Calculate this nodes willingness to act as a MPR
  *based on either a fixed value or the power status
index 94067ae..fd74c25 100644 (file)
@@ -69,9 +69,6 @@ int
   olsr_forward_message(struct olsr_message *, uint8_t *binary, struct interface *, union olsr_ip_addr *);
 
 void
-  set_buffer_timer(struct interface *);
-
-void
   olsr_init_tables(void);
 
 void
index 4d93c1e..56f2248 100644 (file)
@@ -77,7 +77,7 @@ static int comsocket_http = 0;
 static int comsocket_txt = 0;
 
 static struct olsr_cookie_info *connection_cookie;
-static struct olsr_cookie_info *connection_timeout;
+static struct olsr_timer_info *connection_timeout;
 
 /* counter for open connections */
 static int connection_http_count;
@@ -92,13 +92,11 @@ static void olsr_com_cleanup_session(struct comport_connection *con);
 static void olsr_com_timeout_handler(void *);
 
 void olsr_com_init(bool failfast) {
-  connection_cookie = olsr_alloc_cookie("comport connections",
-      OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(connection_cookie,
-      sizeof(struct comport_connection));
+  connection_cookie =
+      olsr_alloc_cookie("comport connections", sizeof(struct comport_connection));
 
-  connection_timeout = olsr_alloc_cookie("comport timout",
-      OLSR_COOKIE_TYPE_TIMER);
+  connection_timeout = olsr_alloc_timerinfo("comport timout",
+      &olsr_com_timeout_handler, false);
 
   connection_http_count = 0;
   connection_txt_count = 0;
@@ -266,8 +264,7 @@ static void olsr_com_parse_request(int fd, void *data __attribute__ ((unused)),
   OLSR_DEBUG(LOG_COMPORT, "Got connection through socket %d from %s.\n",
       sock, olsr_ip_to_string(&buf, &con->addr));
 
-  con->timeout = olsr_start_timer(con->timeout_value, 0, false,
-      &olsr_com_timeout_handler, con, connection_timeout);
+  con->timeout = olsr_start_timer(con->timeout_value, 0, con, connection_timeout);
 
   add_olsr_socket(sock, &olsr_com_parse_connection, NULL, con, SP_PR_READ
       | SP_PR_WRITE);
index c61fbea..6441882 100644 (file)
@@ -146,8 +146,7 @@ void
 olsr_com_init_http(void) {
   avl_init(&http_handler_tree, &avl_comp_strcasecmp, false, NULL);
 
-  htmlsite_cookie = olsr_alloc_cookie("comport http sites", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(htmlsite_cookie, sizeof(struct olsr_html_site));
+  htmlsite_cookie = olsr_alloc_cookie("comport http sites", sizeof(struct olsr_html_site));
 
   /* activate telnet gateway */
   olsr_com_add_htmlhandler(olsr_com_html2telnet_gate, TELNET_PATH);
index 95704a8..1a721c4 100644 (file)
@@ -63,7 +63,10 @@ struct txt_repeat_data {
 };
 
 static struct avl_tree txt_normal_tree, txt_help_tree;
-static struct olsr_cookie_info *txtcommand_cookie, *txt_repeattimer_cookie;
+static struct olsr_cookie_info *txtcommand_cookie;
+static struct olsr_timer_info *txt_repeat_timerinfo;
+
+static void olsr_txt_repeat_timer(void *data);
 
 static enum olsr_txtcommand_result olsr_txtcmd_quit(
     struct comport_connection *con, const char *cmd, const char *param);
@@ -127,10 +130,9 @@ olsr_com_init_txt(void) {
   avl_init(&txt_normal_tree, &avl_comp_strcasecmp, false, NULL);
   avl_init(&txt_help_tree, &avl_comp_strcasecmp, false, NULL);
 
-  txtcommand_cookie = olsr_alloc_cookie("comport txt commands", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(txtcommand_cookie, sizeof(struct olsr_txtcommand));
+  txtcommand_cookie = olsr_alloc_cookie("comport txt commands", sizeof(struct olsr_txtcommand));
 
-  txt_repeattimer_cookie = olsr_alloc_cookie("txt repeat timer", OLSR_COOKIE_TYPE_TIMER);
+  txt_repeat_timerinfo = olsr_alloc_timerinfo("txt repeat timer", olsr_txt_repeat_timer, true);
 
   for (i=0; i < ARRAYSIZE(txt_internal_names); i++) {
     txt_internal_normalcmd[i] = olsr_com_add_normal_txtcommand(txt_internal_names[i], txt_internal_handlers[i]);
@@ -312,7 +314,7 @@ void olsr_com_parse_txt(struct comport_connection *con,
   }
 
   /* reset timeout */
-  olsr_change_timer(con->timeout, con->timeout_value, 0, false);
+  olsr_change_timer(con->timeout, con->timeout_value, 0);
 
   /* print prompt */
   if (processedCommand && con->state == INTERACTIVE && con->show_echo) {
@@ -441,7 +443,7 @@ olsr_txtcmd_repeat(struct comport_connection *con,
 
   interval = atoi(param);
 
-  timer = olsr_start_timer(interval * 1000, 0, true, &olsr_txt_repeat_timer, con, txt_repeattimer_cookie);
+  timer = olsr_start_timer(interval * 1000, 0, con, txt_repeat_timerinfo);
   con->stop_handler = olsr_txt_repeat_stophandler;
   con->stop_data[0] = timer;
   con->stop_data[1] = strdup(ptr);
index 7ad37be..5a7a119 100644 (file)
@@ -61,10 +61,8 @@ void olsr_cookie_init(void) {
  * Allocate a cookie for the next available cookie id.
  */
 struct olsr_cookie_info *
-olsr_alloc_cookie(const char *cookie_name, enum olsr_cookie_type cookie_type)
+olsr_alloc_cookie(const char *cookie_name, size_t size)
 {
-  static uint16_t next_brand_id = 1;
-
   struct olsr_cookie_info *ci;
 
   assert (cookie_name);
@@ -72,60 +70,53 @@ olsr_alloc_cookie(const char *cookie_name, enum olsr_cookie_type cookie_type)
   ci = olsr_malloc(sizeof(struct olsr_cookie_info), "new cookie");
 
   /* Now populate the cookie info */
-  ci->ci_type = cookie_type;
   ci->ci_name = olsr_strdup(cookie_name);
-
-  ci->node.key = ci->ci_name;
+  ci->ci_node.key = ci->ci_name;
+  ci->ci_size = size;
+  ci->ci_min_free_count = COOKIE_FREE_LIST_THRESHOLD;
 
   /* Init the free list */
-  if (cookie_type == OLSR_COOKIE_TYPE_MEMORY) {
-    list_init_head(&ci->ci_free_list);
-    VALGRIND_CREATE_MEMPOOL(ci, 0, 1);
+  list_init_head(&ci->ci_free_list);
+  VALGRIND_CREATE_MEMPOOL(ci, 0, 1);
 
-    ci->ci_membrand = next_brand_id++;
-  }
-  else {
-    ci->ci_membrand = 0;
-  }
-
-  avl_insert(&olsr_cookie_tree, &ci->node);
+  avl_insert(&olsr_cookie_tree, &ci->ci_node);
   return ci;
 }
 
 /*
  * Free a cookie that is no longer being used.
  */
-static void
+void
 olsr_free_cookie(struct olsr_cookie_info *ci)
 {
   struct list_entity *memory_list;
 
+  /* can only be called if not in use anymore */
+  assert(ci->ci_usage == 0);
+
   /* remove from tree */
-  avl_delete(&olsr_cookie_tree, &ci->node);
+  avl_delete(&olsr_cookie_tree, &ci->ci_node);
 
   /* Free name */
   free(ci->ci_name);
 
   /* Flush all the memory on the free list */
-  if (ci->ci_type == OLSR_COOKIE_TYPE_MEMORY) {
-
-    /*
-     * First make all items accessible,
-     * such that valgrind does not complain at shutdown.
-     */
-    if (!list_is_empty(&ci->ci_free_list)) {
-      for (memory_list = ci->ci_free_list.next; memory_list != &ci->ci_free_list; memory_list = memory_list->next) {
-        VALGRIND_MAKE_MEM_DEFINED(memory_list, ci->ci_size);
-      }
+  /*
+   * First make all items accessible,
+   * such that valgrind does not complain at shutdown.
+   */
+  if (!list_is_empty(&ci->ci_free_list)) {
+    for (memory_list = ci->ci_free_list.next; memory_list != &ci->ci_free_list; memory_list = memory_list->next) {
+      VALGRIND_MAKE_MEM_DEFINED(memory_list, ci->ci_size);
     }
+  }
 
-    while (!list_is_empty(&ci->ci_free_list)) {
-      memory_list = ci->ci_free_list.next;
-      list_remove(memory_list);
-      free(memory_list);
-    }
-    VALGRIND_DESTROY_MEMPOOL(ci);
+  while (!list_is_empty(&ci->ci_free_list)) {
+    memory_list = ci->ci_free_list.next;
+    list_remove(memory_list);
+    free(memory_list);
   }
+  VALGRIND_DESTROY_MEMPOOL(ci);
 
   free(ci);
 }
@@ -134,7 +125,7 @@ olsr_free_cookie(struct olsr_cookie_info *ci)
  * Flush all cookies. This is really only called upon shutdown.
  */
 void
-olsr_delete_all_cookies(void)
+olsr_cookie_cleanup(void)
 {
   struct olsr_cookie_info *info;
   struct list_iterator iterator;
@@ -143,23 +134,14 @@ olsr_delete_all_cookies(void)
    * Walk the full index range and kill 'em all.
    */
   OLSR_FOR_ALL_COOKIES(info, iterator) {
-    olsr_free_cookie(info);
-  }
-}
+    if (info->ci_usage > 0) {
+      OLSR_WARN(LOG_COOKIE, "Free cookie %s: %d chunks still in use !\n", info->ci_name, info->ci_usage);
 
-/*
- * Set the size for fixed block allocations.
- * This is only allowed for memory cookies.
- */
-void
-olsr_cookie_set_memory_size(struct olsr_cookie_info *ci, size_t size)
-{
-  if (!ci) {
-    return;
+      /* set usage to 0 */
+      info->ci_usage = 0;
+    }
+    olsr_free_cookie(info);
   }
-
-  assert(ci->ci_type == OLSR_COOKIE_TYPE_MEMORY);
-  ci->ci_size = size;
 }
 
 /*
@@ -169,17 +151,7 @@ olsr_cookie_set_memory_size(struct olsr_cookie_info *ci, size_t size)
 void
 olsr_cookie_set_memory_clear(struct olsr_cookie_info *ci, bool clear)
 {
-  if (!ci) {
-    return;
-  }
-
-  assert(ci->ci_type == OLSR_COOKIE_TYPE_MEMORY);
-
-  if (!clear) {
-    ci->ci_flags |= COOKIE_NO_MEMCLEAR;
-  } else {
-    ci->ci_flags &= ~COOKIE_NO_MEMCLEAR;
-  }
+  ci->ci_no_memclear = !clear;
 }
 
 /*
@@ -190,23 +162,24 @@ olsr_cookie_set_memory_clear(struct olsr_cookie_info *ci, bool clear)
 void
 olsr_cookie_set_memory_poison(struct olsr_cookie_info *ci, bool poison)
 {
-  if (!ci) {
-    return;
-  }
-
-  assert(ci->ci_type == OLSR_COOKIE_TYPE_MEMORY);
+  ci->ci_poison = poison;
+}
 
-  if (poison) {
-    ci->ci_flags |= COOKIE_MEMPOISON;
-  } else {
-    ci->ci_flags &= ~COOKIE_MEMPOISON;
-  }
+/*
+ * Set if a returned memory block shall be cleared after returning to
+ * the free pool. This is only allowed for memory cookies.
+ */
+void
+olsr_cookie_set_min_free(struct olsr_cookie_info *ci, uint32_t min_free)
+{
+  ci->ci_min_free_count = min_free;
 }
 
+
 /*
  * Increment usage state for a given cookie.
  */
-void
+static inline void
 olsr_cookie_usage_incr(struct olsr_cookie_info *ci)
 {
   ci->ci_usage++;
@@ -216,7 +189,7 @@ olsr_cookie_usage_incr(struct olsr_cookie_info *ci)
 /*
  * Decrement usage state for a given cookie.
  */
-void
+static inline void
 olsr_cookie_usage_decr(struct olsr_cookie_info *ci)
 {
   ci->ci_usage--;
@@ -230,12 +203,10 @@ void *
 olsr_cookie_malloc(struct olsr_cookie_info *ci)
 {
   void *ptr;
-  struct olsr_cookie_mem_brand *branding;
   struct list_entity *free_list_node;
 #if !defined REMOVE_LOG_DEBUG
   bool reuse = false;
 #endif
-  size_t size;
 
   /*
    * Check first if we have reusable memory.
@@ -246,14 +217,13 @@ olsr_cookie_malloc(struct olsr_cookie_info *ci)
      * No reusable memory block on the free_list.
      * Allocate a fresh one.
      */
-    size = ci->ci_size + sizeof(struct olsr_cookie_mem_brand);
-    ptr = olsr_malloc(size, ci->ci_name);
+    ptr = olsr_malloc(ci->ci_size, ci->ci_name);
 
     /*
      * Poison the memory for debug purposes ?
      */
-    if (ci->ci_flags & COOKIE_MEMPOISON) {
-      memset(ptr, COOKIE_MEMPOISON_PATTERN, size);
+    if (ci->ci_poison) {
+      memset(ptr, COOKIE_MEMPOISON_PATTERN, ci->ci_size);
     }
 
   } else {
@@ -287,12 +257,12 @@ olsr_cookie_malloc(struct olsr_cookie_info *ci)
     /*
      * Reset the memory unless the caller has told us so.
      */
-    if (!(ci->ci_flags & COOKIE_NO_MEMCLEAR)) {
+    if (!ci->ci_no_memclear) {
 
       /*
        * Poison the memory for debug purposes ?
        */
-      if (ci->ci_flags & COOKIE_MEMPOISON) {
+      if (ci->ci_poison) {
         memset(ptr, COOKIE_MEMPOISON_PATTERN, ci->ci_size);
       } else {
         memset(ptr, 0, ci->ci_size);
@@ -305,16 +275,6 @@ olsr_cookie_malloc(struct olsr_cookie_info *ci)
 #endif
   }
 
-  /*
-   * Now brand mark the end of the memory block with a short signature
-   * indicating presence of a cookie. This will be checked against
-   * When the block is freed to detect corruption.
-   */
-  branding = (struct olsr_cookie_mem_brand *)
-    (ARM_NOWARN_ALIGN((unsigned char *)ptr + ci->ci_size));
-  memcpy(&branding->cmb_sig, "cookie", 6);
-  branding->id = ci->ci_membrand;
-
   /* Stats keeping */
   olsr_cookie_usage_incr(ci);
 
@@ -336,28 +296,14 @@ olsr_cookie_free(struct olsr_cookie_info *ci, void *ptr)
 #if !defined REMOVE_LOG_DEBUG
   bool reuse = false;
 #endif
-  struct olsr_cookie_mem_brand *branding = (struct olsr_cookie_mem_brand *)
-    (ARM_NOWARN_ALIGN((unsigned char *)ptr + ci->ci_size));
-
-  /*
-   * Verify if there has been a memory overrun, or
-   * the wrong owner is trying to free this.
-   */
-
-  if (!(memcmp(&branding->cmb_sig, "cookie", 6) == 0 && branding->id == ci->ci_membrand)) {
-    OLSR_ERROR(LOG_COOKIE, "Memory corruption at end of '%s' cookie\n", ci->ci_name);
-    olsr_exit(1);
-  }
-
-  /* Kill the brand */
-  memset(branding, 0, sizeof(*branding));
 
   /*
    * Rather than freeing the memory right away, try to reuse at a later
    * point. Keep at least ten percent of the active used blocks or at least
    * ten blocks on the free list.
    */
-  if ((ci->ci_free_list_usage < COOKIE_FREE_LIST_THRESHOLD) || (ci->ci_free_list_usage < ci->ci_usage / COOKIE_FREE_LIST_THRESHOLD)) {
+  if ((ci->ci_free_list_usage < ci->ci_min_free_count)
+      || (ci->ci_free_list_usage < ci->ci_usage / COOKIE_FREE_LIST_THRESHOLD)) {
 
     free_list_node = (struct list_entity *)ptr;
     list_init_node(free_list_node);
index 76c7852..6d0d24b 100644 (file)
@@ -39,6 +39,8 @@
  *
  */
 
+#include <stdint.h>
+
 #include "olsr_types.h"
 #include "common/list.h"
 #include "common/avl.h"
 #ifndef _OLSR_COOKIE_H
 #define _OLSR_COOKIE_H
 
-extern struct avl_tree olsr_cookie_tree;
-
-enum olsr_cookie_type {
-  OLSR_COOKIE_TYPE_MIN,
-  OLSR_COOKIE_TYPE_MEMORY,
-  OLSR_COOKIE_TYPE_TIMER,
-  OLSR_COOKIE_TYPE_MAX
-};
+extern struct avl_tree EXPORT(olsr_cookie_tree);
 
 /*
  * This is a cookie. A cookie is a tool aimed for olsrd developers.
@@ -61,53 +56,55 @@ enum olsr_cookie_type {
  * for locating memory corruption.
  */
 struct olsr_cookie_info {
-  struct avl_node node;
-  char *ci_name;                       /* Name */
-  enum olsr_cookie_type ci_type;       /* Type of cookie */
-  unsigned int ci_flags;               /* Misc. flags */
-  unsigned int ci_usage;               /* Stats, resource usage */
-  unsigned int ci_changes;             /* Stats, resource churn */
-
-  /* only for memory cookies */
-  size_t ci_size;                      /* Fixed size for block allocations */
-  struct list_entity ci_free_list;       /* List head for recyclable blocks */
-  unsigned int ci_free_list_usage;     /* Length of free list */
-  uint16_t ci_membrand;
-};
+  struct avl_node ci_node;
+  /* Name */
+  char *ci_name;
 
-#define OLSR_FOR_ALL_COOKIES(ci, iterator) avl_for_each_element_safe(&olsr_cookie_tree, ci, node, iterator.loop, iterator.safe)
+  /* Size of memory blocks */
+  size_t ci_size;
 
-/* Cookie flags */
-#define COOKIE_NO_MEMCLEAR  ( 1 << 0)   /* Do not clear memory */
-#define COOKIE_MEMPOISON    ( 2 << 0)   /* Poison memory pattern */
+  /* flags */
+  bool ci_poison;
+  bool ci_no_memclear;
 
-#define COOKIE_MEMPOISON_PATTERN  0xa6  /* Pattern to spoil memory */
-#define COOKIE_FREE_LIST_THRESHOLD 10   /* Blocks / Percent  */
+  /*
+   * minimum number of chunks the allocator will keep
+   * in the free list before starting to deallocate one
+   */
+  uint32_t ci_min_free_count;
 
-/*
- * Small brand which gets appended on the end of every block allocation.
- * Helps to detect memory corruption, like overruns, double frees.
- */
-struct olsr_cookie_mem_brand {
-  char cmb_sig[6];
-  uint16_t id;
+  /* Stats, resource usage */
+  uint32_t ci_usage;
+
+  /* Stats, resource churn */
+  uint32_t ci_changes;
+
+  /* List head for recyclable blocks */
+  struct list_entity ci_free_list;
+
+  /* Length of free list */
+  uint32_t ci_free_list_usage;
 };
 
+#define OLSR_FOR_ALL_COOKIES(ci, iterator) avl_for_each_element_safe(&olsr_cookie_tree, ci, ci_node, iterator.loop, iterator.safe)
+
+#define COOKIE_MEMPOISON_PATTERN  0xa6  /* Pattern to spoil memory */
+#define COOKIE_FREE_LIST_THRESHOLD 10   /* Blocks / Percent  */
+
 /* Externals. */
 void olsr_cookie_init(void);
-struct olsr_cookie_info *EXPORT(olsr_alloc_cookie) (const char *, enum olsr_cookie_type);
-void olsr_delete_all_cookies(void);
-void EXPORT(olsr_cookie_set_memory_size) (struct olsr_cookie_info *, size_t);
+void olsr_cookie_cleanup(void);
+
+struct olsr_cookie_info *EXPORT(olsr_alloc_cookie) (const char *, size_t size);
+void EXPORT(olsr_free_cookie)(struct olsr_cookie_info *);
+
 void EXPORT(olsr_cookie_set_memory_clear) (struct olsr_cookie_info *, bool);
 void EXPORT(olsr_cookie_set_memory_poison) (struct olsr_cookie_info *, bool);
-void EXPORT(olsr_cookie_usage_incr) (struct olsr_cookie_info *);
-void EXPORT(olsr_cookie_usage_decr) (struct olsr_cookie_info *);
+void EXPORT(olsr_cookie_set_min_free)(struct olsr_cookie_info *, uint32_t);
 
 void *EXPORT(olsr_cookie_malloc) (struct olsr_cookie_info *);
 void EXPORT(olsr_cookie_free) (struct olsr_cookie_info *, void *);
 
-struct olsr_cookie_info *EXPORT(olsr_cookie_get) (int i);
-
 #endif /* _OLSR_COOKIE_H */
 
 /*
index 4b47efd..cf1e6b9 100644 (file)
@@ -49,6 +49,7 @@
 #include "process_routes.h"
 #include "olsr_logging.h"
 
+struct olsr_timer_info *spf_backoff_timer_info = NULL;
 struct timer_entry *spf_backoff_timer = NULL;
 
 /*
@@ -275,7 +276,12 @@ olsr_expire_spf_backoff(void *context __attribute__ ((unused)))
 }
 
 void
-olsr_calculate_routing_table(void)
+olsr_init_spf(void) {
+  spf_backoff_timer_info = olsr_alloc_timerinfo("SPF backoff", olsr_expire_spf_backoff, false);
+}
+
+void
+olsr_calculate_routing_table(bool force)
 {
 #ifdef SPF_PROFILING
   struct timeval t1, t2, t3, t4, t5, spf_init, spf_run, route, kernel, total;
@@ -291,12 +297,12 @@ olsr_calculate_routing_table(void)
   struct list_iterator iterator;
 
   /* We are done if our backoff timer is running */
-  if (spf_backoff_timer) {
+  if (!force && spf_backoff_timer != NULL) {
     return;
   }
-  spf_backoff_timer =
-    olsr_start_timer(OLSR_SPF_BACKOFF_TIME, OLSR_SPF_BACKOFF_JITTER,
-                     OLSR_TIMER_ONESHOT, &olsr_expire_spf_backoff, NULL, spf_backoff_timer_cookie);
+
+  olsr_set_timer(&spf_backoff_timer, OLSR_SPF_BACKOFF_TIME, OLSR_SPF_BACKOFF_JITTER,
+      NULL, spf_backoff_timer_info);
 
 #ifdef SPF_PROFILING
   gettimeofday(&t1, NULL);
index cb38e9a..a63dd5c 100644 (file)
 #ifndef _OLSR_SPF_H
 #define _OLSR_SPF_H
 
+#include "defs.h"
+
 #define OLSR_SPF_BACKOFF_TIME  (1*1000) /* milliseconds */
 #define OLSR_SPF_BACKOFF_JITTER 5       /* percent */
 
-void olsr_calculate_routing_table(void);
-extern struct timer_entry *spf_backoff_timer;
+void olsr_init_spf(void);
+void olsr_calculate_routing_table(bool);
 
 #endif
 
index 3f5caf6..93796a1 100644 (file)
@@ -94,8 +94,7 @@ struct olsr_plugin *olsr_get_plugin(const char *libname) {
 
 void
 olsr_init_pluginsystem(void) {
-  plugin_mem_cookie = olsr_alloc_cookie("Plugin handle", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(plugin_mem_cookie, sizeof(struct olsr_plugin));
+  plugin_mem_cookie = olsr_alloc_cookie("Plugin handle", sizeof(struct olsr_plugin));
 
   /* could already be initialized */
   if (!plugin_tree_initialized) {
index 7cdbef9..1eece28 100644 (file)
@@ -92,11 +92,8 @@ olsr_init_routing_table(void)
   /*
    * Get some cookies for memory stats and memory recycling.
    */
-  rt_mem_cookie = olsr_alloc_cookie("rt_entry", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(rt_mem_cookie, sizeof(struct rt_entry));
-
-  rtp_mem_cookie = olsr_alloc_cookie("rt_path", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(rtp_mem_cookie, sizeof(struct rt_path));
+  rt_mem_cookie = olsr_alloc_cookie("rt_entry", sizeof(struct rt_entry));
+  rtp_mem_cookie = olsr_alloc_cookie("rt_path", sizeof(struct rt_path));
 }
 
 /**
index c830184..823bb73 100644 (file)
  *
  */
 
+#include <sys/times.h>
+#include <unistd.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#include "common/avl.h"
+#include "common/avl_olsr_comp.h"
 #include "scheduler.h"
 #include "log.h"
 #include "link_set.h"
 #include "net_os.h"
 #include "olsr_logging.h"
 
-#include <sys/times.h>
-
-#include <unistd.h>
-#include <assert.h>
-#include <stdlib.h>
-
 /* Timer data, global. Externed in scheduler.h */
 uint32_t now_times;                    /* relative time compared to startup (in milliseconds */
 struct timeval first_tv;               /* timevalue during startup */
@@ -62,8 +63,10 @@ struct timeval last_tv;                /* timevalue used for last olsr_times() c
 static struct list_entity timer_wheel[TIMER_WHEEL_SLOTS];
 static uint32_t timer_last_run;        /* remember the last timeslot walk */
 
-/* Memory cookie for the block based memory manager */
+/* Memory cookie for the timer manager */
+struct avl_tree timerinfo_tree;
 static struct olsr_cookie_info *timer_mem_cookie = NULL;
+static struct olsr_cookie_info *timerinfo_coookie = NULL;
 
 /* Head of all OLSR used sockets */
 static struct list_entity socket_head;
@@ -160,6 +163,21 @@ olsr_isTimedOut(uint32_t s)
   return now_times - s <= (1u << 31);
 }
 
+struct olsr_timer_info *
+olsr_alloc_timerinfo(const char *name, timer_cb_func callback, bool periodic) {
+  struct olsr_timer_info *ti;
+
+  ti = olsr_cookie_malloc(timerinfo_coookie);
+  ti->name = strdup(name);
+  ti->node.key = ti->name;
+  ti->callback = callback;
+  ti->periodic = periodic;
+
+  avl_insert(&timerinfo_tree, &ti->node);
+  return ti;
+}
+
+
 /**
  * Add a socket and handler to the socketset
  * beeing used in the main select(2) loop
@@ -549,10 +567,12 @@ olsr_init_timers(void)
    */
   timer_last_run = now_times;
 
-  /* Allocate a cookie for the block based memeory manager. */
-  timer_mem_cookie = olsr_alloc_cookie("timer_entry", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(timer_mem_cookie, sizeof(struct timer_entry));
+  /* Allocate a cookie for the block based memory manager. */
+  timer_mem_cookie = olsr_alloc_cookie("timer_entry", sizeof(struct timer_entry));
   olsr_cookie_set_memory_clear(timer_mem_cookie, false);
+
+  avl_init(&timerinfo_tree, avl_comp_strcasecmp, false, NULL);
+  timerinfo_coookie = olsr_alloc_cookie("timerinfo", sizeof(struct olsr_timer_info));
 }
 
 /**
@@ -601,16 +621,16 @@ walk_timers(uint32_t * last_run)
 
       /* Ready to fire ? */
       if (TIMED_OUT(timer->timer_clock)) {
-
         OLSR_DEBUG(LOG_SCHEDULER, "TIMER: fire %s timer %p, ctx %p, "
                    "at clocktick %u (%s)\n",
-                   timer->timer_cookie->ci_name,
+                   timer->timer_info->name,
                    timer, timer->timer_cb_context, (unsigned int)*last_run, olsr_wallclock_string());
 
         /* This timer is expired, call into the provided callback function */
         timer->timer_in_callback = true;
-        timer->timer_cb(timer->timer_cb_context);
+        timer->timer_info->callback(timer->timer_cb_context);
         timer->timer_in_callback = false;
+        timer->timer_info->changes++;
 
         /* Only act on actually running timers */
         if (timer->timer_running) {
@@ -621,7 +641,7 @@ walk_timers(uint32_t * last_run)
           if (timer->timer_period) {
             /* For periodical timers, rehash the random number and restart */
             timer->timer_random = random();
-            olsr_change_timer(timer, timer->timer_period, timer->timer_jitter_pct, OLSR_TIMER_PERIODIC);
+            olsr_change_timer(timer, timer->timer_period, timer->timer_jitter_pct);
           } else {
             /* Singleshot timers are stopped */
             olsr_stop_timer(timer);
@@ -774,12 +794,11 @@ olsr_clock_string(uint32_t clk)
  */
 struct timer_entry *
 olsr_start_timer(unsigned int rel_time,
-                 uint8_t jitter_pct, bool periodical, timer_cb_func cb_func, void *context, struct olsr_cookie_info *ci)
+                 uint8_t jitter_pct, void *context, struct olsr_timer_info *ti)
 {
   struct timer_entry *timer;
 
-  assert(ci != 0);          /* we want timer cookies everywhere */
-  assert(cb_func);
+  assert(ti != 0);          /* we want timer cookies everywhere */
 
   timer = olsr_cookie_malloc(timer_mem_cookie);
 
@@ -792,17 +811,17 @@ olsr_start_timer(unsigned int rel_time,
 
   /* Fill entry */
   timer->timer_clock = calc_jitter(rel_time, jitter_pct, timer->timer_random);
-  timer->timer_cb = cb_func;
   timer->timer_cb_context = context;
   timer->timer_jitter_pct = jitter_pct;
   timer->timer_running = true;
 
   /* The cookie is used for debugging to traceback the originator */
-  timer->timer_cookie = ci;
-  olsr_cookie_usage_incr(ci);
+  timer->timer_info = ti;
+  ti->usage++;
+  ti->changes++;
 
   /* Singleshot or periodical timer ? */
-  timer->timer_period = periodical ? rel_time : 0;
+  timer->timer_period = ti->periodic ? rel_time : 0;
 
   /*
    * Now insert in the respective timer_wheel slot.
@@ -810,7 +829,7 @@ olsr_start_timer(unsigned int rel_time,
   list_add_before(&timer_wheel[timer->timer_clock & TIMER_WHEEL_MASK], &timer->timer_list);
 
   OLSR_DEBUG(LOG_SCHEDULER, "TIMER: start %s timer %p firing in %s, ctx %p\n",
-             ci->ci_name, timer, olsr_clock_string(timer->timer_clock), context);
+             ti->name, timer, olsr_clock_string(timer->timer_clock), context);
 
   return timer;
 }
@@ -829,11 +848,11 @@ olsr_stop_timer(struct timer_entry *timer)
     return;
   }
 
-  assert(timer->timer_cookie);     /* we want timer cookies everywhere */
+  assert(timer->timer_info);     /* we want timer cookies everywhere */
   assert(timer->timer_list.next != NULL && timer->timer_list.prev != NULL);
 
   OLSR_DEBUG(LOG_SCHEDULER, "TIMER: stop %s timer %p, ctx %p\n",
-             timer->timer_cookie->ci_name, timer, timer->timer_cb_context);
+             timer->timer_info->name, timer, timer->timer_cb_context);
 
 
   /*
@@ -841,7 +860,8 @@ olsr_stop_timer(struct timer_entry *timer)
    */
   list_remove(&timer->timer_list);
   timer->timer_running = false;
-  olsr_cookie_usage_decr(timer->timer_cookie);
+  timer->timer_info->usage--;
+  timer->timer_info->changes++;
 
   if (!timer->timer_in_callback) {
     olsr_cookie_free(timer_mem_cookie, timer);
@@ -857,17 +877,17 @@ olsr_stop_timer(struct timer_entry *timer)
  * @return nada
  */
 void
-olsr_change_timer(struct timer_entry *timer, unsigned int rel_time, uint8_t jitter_pct, bool periodical)
+olsr_change_timer(struct timer_entry *timer, unsigned int rel_time, uint8_t jitter_pct)
 {
   /* Sanity check. */
   if (!timer) {
     return;
   }
 
-  assert(timer->timer_cookie);     /* we want timer cookies everywhere */
+  assert(timer->timer_info);     /* we want timer cookies everywhere */
 
   /* Singleshot or periodical timer ? */
-  timer->timer_period = periodical ? rel_time : 0;
+  timer->timer_period = timer->timer_info->periodic ? rel_time : 0;
 
   timer->timer_clock = calc_jitter(rel_time, jitter_pct, timer->timer_random);
   timer->timer_jitter_pct = jitter_pct;
@@ -880,7 +900,8 @@ olsr_change_timer(struct timer_entry *timer, unsigned int rel_time, uint8_t jitt
   list_add_before(&timer_wheel[timer->timer_clock & TIMER_WHEEL_MASK], &timer->timer_list);
 
   OLSR_DEBUG(LOG_SCHEDULER, "TIMER: change %s timer %p, firing to %s, ctx %p\n",
-             timer->timer_cookie->ci_name, timer, olsr_clock_string(timer->timer_clock), timer->timer_cb_context);
+             timer->timer_info->name, timer,
+             olsr_clock_string(timer->timer_clock), timer->timer_cb_context);
 }
 
 /*
@@ -892,9 +913,9 @@ olsr_change_timer(struct timer_entry *timer, unsigned int rel_time, uint8_t jitt
 void
 olsr_set_timer(struct timer_entry **timer_ptr,
                unsigned int rel_time,
-               uint8_t jitter_pct, bool periodical, timer_cb_func cb_func, void *context, struct olsr_cookie_info *cookie)
+               uint8_t jitter_pct, void *context, struct olsr_timer_info *ti)
 {
-  assert(cookie);          /* we want timer cookies everywhere */
+  assert(ti);          /* we want timer cookies everywhere */
   if (rel_time == 0) {
     /* No good future time provided, kill it. */
     olsr_stop_timer(*timer_ptr);
@@ -902,10 +923,10 @@ olsr_set_timer(struct timer_entry **timer_ptr,
   }
   else if ((*timer_ptr) == NULL) {
     /* No timer running, kick it. */
-    *timer_ptr = olsr_start_timer(rel_time, jitter_pct, periodical, cb_func, context, cookie);
+    *timer_ptr = olsr_start_timer(rel_time, jitter_pct, context, ti);
   }
   else {
-    olsr_change_timer(*timer_ptr, rel_time, jitter_pct, periodical);
+    olsr_change_timer(*timer_ptr, rel_time, jitter_pct);
   }
 }
 
index d7dc138..dd512c4 100644 (file)
@@ -45,6 +45,7 @@
 
 #include "olsr_time.h"
 #include "common/list.h"
+#include "common/avl.h"
 
 #include "olsr_types.h"
 
 
 typedef void (*timer_cb_func) (void *); /* callback function */
 
+struct olsr_timer_info {
+  /* node of timerinfo tree */
+  struct avl_node node;
+
+  /* name of this timer class */
+  char *name;
+
+  /* callback function */
+  timer_cb_func callback;
+
+  /* true if this is a class of periodic timers */
+  bool periodic;
+
+  /* Stats, resource usage */
+  uint32_t usage;
+
+  /* Stats, resource churn */
+  uint32_t changes;
+};
+
+#define OLSR_FOR_ALL_TIMERS(ti, iterator) avl_for_each_element_safe(&timerinfo_tree, ti, node, iterator.loop, iterator.safe)
+
 /*
  * Our timer implementation is a based on individual timers arranged in
  * a double linked list hanging of hash containers called a timer wheel slot.
@@ -66,27 +89,46 @@ typedef void (*timer_cb_func) (void *); /* callback function */
  * which causes the timer to run forever until manually stopped.
  */
 struct timer_entry {
-  struct list_entity timer_list;         /* Wheel membership */
-  uint32_t timer_clock;                /* when timer shall fire (absolute time) */
-  unsigned int timer_period;           /* set for periodical timers (relative time) */
-  struct olsr_cookie_info *timer_cookie;       /* used for diag stuff */
-  uint8_t timer_jitter_pct;            /* the jitter expressed in percent */
-  bool timer_running;                  /* misc flags */
-  bool timer_in_callback;              /* true if callback is active */
-  unsigned int timer_random;           /* cache random() result for performance reasons */
-  timer_cb_func timer_cb;              /* callback function */
-  void *timer_cb_context;              /* context pointer */
-};
+  /* Wheel membership */
+  struct list_entity timer_list;
+
+  /* backpointer to timer info */
+  struct olsr_timer_info *timer_info;
 
-#define OLSR_TIMER_ONESHOT    0 /* One shot timer */
-#define OLSR_TIMER_PERIODIC   1 /* Periodic timer */
+  /* when timer shall fire (absolute internal timerstamp) */
+  uint32_t timer_clock;
+
+  /* timeperiod between two timer events for periodical timers */
+  uint32_t timer_period;           /* set for periodical timers (relative time) */
+
+  /* the jitter expressed in percent */
+  uint8_t timer_jitter_pct;
+
+  /* true if timer is running at the moment */
+  bool timer_running;
+
+  /* true if timer is in callback at the moment */
+  bool timer_in_callback;
+
+  /* cache random() result for performance reasons */
+  unsigned int timer_random;
+
+  /* context pointer */
+  void *timer_cb_context;
+};
 
 /* Timers */
+extern struct avl_tree EXPORT(timerinfo_tree);
+
 void olsr_init_timers(void);
 void olsr_flush_timers(void);
-void EXPORT(olsr_set_timer) (struct timer_entry **, unsigned int, uint8_t, bool, timer_cb_func, void *, struct olsr_cookie_info *);
-struct timer_entry *EXPORT(olsr_start_timer) (unsigned int, uint8_t, bool, timer_cb_func, void *, struct olsr_cookie_info *);
-void olsr_change_timer(struct timer_entry *, unsigned int, uint8_t, bool);
+struct olsr_timer_info *olsr_alloc_timerinfo(const char *name, timer_cb_func callback, bool periodic);
+
+void EXPORT(olsr_set_timer) (struct timer_entry **, uint32_t, uint8_t,
+    void *, struct olsr_timer_info *);
+struct timer_entry *EXPORT(olsr_start_timer) (uint32_t, uint8_t,
+    void *, struct olsr_timer_info *);
+void olsr_change_timer(struct timer_entry *, uint32_t, uint8_t);
 void EXPORT(olsr_stop_timer) (struct timer_entry *);
 
 /* Printing timestamps */
index e0d7347..f3b5d22 100644 (file)
 #include "olsr_logging.h"
 
 static bool delete_outdated_tc_edges(struct tc_entry *);
+static void olsr_expire_tc_entry(void *context);
+static void olsr_expire_tc_edge_gc(void *context);
 
 /* Root of the link state database */
 struct avl_tree tc_tree;
 struct tc_entry *tc_myself = NULL;     /* Shortcut to ourselves */
 
 /* Some cookies for stats keeping */
-static struct olsr_cookie_info *tc_edge_gc_timer_cookie = NULL;
-static struct olsr_cookie_info *tc_validity_timer_cookie = NULL;
-struct olsr_cookie_info *spf_backoff_timer_cookie = NULL;
-struct olsr_cookie_info *tc_mem_cookie = NULL;
+static struct olsr_cookie_info *tc_mem_cookie = NULL;
+static struct olsr_timer_info *tc_edge_gc_timer_info = NULL;
+static struct olsr_timer_info *tc_validity_timer_info = NULL;
 
 static uint32_t relevantTcCount = 0;
 
@@ -138,12 +139,10 @@ olsr_init_tc(void)
   /*
    * Get some cookies for getting stats to ease troubleshooting.
    */
-  tc_edge_gc_timer_cookie = olsr_alloc_cookie("TC edge GC", OLSR_COOKIE_TYPE_TIMER);
-  tc_validity_timer_cookie = olsr_alloc_cookie("TC validity", OLSR_COOKIE_TYPE_TIMER);
-  spf_backoff_timer_cookie = olsr_alloc_cookie("SPF backoff", OLSR_COOKIE_TYPE_TIMER);
+  tc_edge_gc_timer_info = olsr_alloc_timerinfo("TC edge GC", olsr_expire_tc_edge_gc, false);
+  tc_validity_timer_info = olsr_alloc_timerinfo("TC validity", &olsr_expire_tc_entry, false);
 
-  tc_mem_cookie = olsr_alloc_cookie("tc_entry", OLSR_COOKIE_TYPE_MEMORY);
-  olsr_cookie_set_memory_size(tc_mem_cookie, sizeof(struct tc_entry));
+  tc_mem_cookie = olsr_alloc_cookie("tc_entry", sizeof(struct tc_entry));
 }
 
 /**
@@ -486,7 +485,7 @@ olsr_delete_tc_edge_entry(struct tc_edge_entry *tc_edge)
 
   if (was_real && tc_inv != tc_myself && tc_inv->virtual) {
     /* mark tc_entry to be gone in one ms */
-    olsr_set_timer(&tc_inv->validity_timer, 1, 0, false, &olsr_expire_tc_entry, tc, tc_validity_timer_cookie);
+    olsr_set_timer(&tc_inv->validity_timer, 1, 0, tc, tc_validity_timer_info);
   }
 }
 
@@ -839,7 +838,7 @@ olsr_input_tc(struct olsr_message * msg,
    */
   assert(msg);
   olsr_set_timer(&tc->validity_timer, msg->vtime,
-                 OLSR_TC_VTIME_JITTER, OLSR_TIMER_ONESHOT, &olsr_expire_tc_entry, tc, tc_validity_timer_cookie);
+                 OLSR_TC_VTIME_JITTER, tc, tc_validity_timer_info);
 
   if (borderSet) {
 
@@ -854,7 +853,7 @@ olsr_input_tc(struct olsr_message * msg,
      * all edges belonging to a multipart neighbor set will arrive.
      */
     olsr_set_timer(&tc->edge_gc_timer, OLSR_TC_EDGE_GC_TIME,
-                   OLSR_TC_EDGE_GC_JITTER, OLSR_TIMER_ONESHOT, &olsr_expire_tc_edge_gc, tc, tc_edge_gc_timer_cookie);
+                   OLSR_TC_EDGE_GC_JITTER, tc, tc_edge_gc_timer_info);
   }
 }
 
index d2c7a34..7e7c513 100644 (file)
@@ -113,8 +113,6 @@ struct tc_entry {
 
 extern struct avl_tree EXPORT(tc_tree);
 extern struct tc_entry *tc_myself;
-extern struct olsr_cookie_info *tc_mem_cookie;
-extern struct olsr_cookie_info *spf_backoff_timer_cookie;
 
 void olsr_init_tc(void);
 void olsr_change_myself_tc(void);
index 73f5e07..a07b1f9 100644 (file)
@@ -304,10 +304,9 @@ if_basename(const char *name)
  *@param so the socket to use for ioctls
  *
  */
-struct interface *
-os_init_interface(struct olsr_if_config *iface)
+int
+os_init_interface(struct interface *ifp, struct olsr_if_config *iface)
 {
-  struct interface *ifp;
   struct ifreq ifr;
   const char *ifr_basename;
   int int_flags;
@@ -319,7 +318,7 @@ os_init_interface(struct olsr_if_config *iface)
    * Sanity check.
    */
   assert (iface->interf == NULL);
-  ifp = olsr_cookie_malloc(interface_mem_cookie);
+  assert (ifp);
 
    /*
    * Setup query block.
@@ -332,25 +331,25 @@ os_init_interface(struct olsr_if_config *iface)
   /* Get flags (and check if interface exists) */
   if (ioctl(olsr_cnf->ioctl_s, SIOCGIFFLAGS, &ifr) < 0) {
     OLSR_DEBUG(LOG_INTERFACE, "\tNo such interface!\n");
-    goto cleanup;
+    return -1;
   }
 
   int_flags = ifr.ifr_flags;
   if ((int_flags & IFF_UP) == 0) {
     OLSR_DEBUG(LOG_INTERFACE, "\tInterface not up - skipping it...\n");
-    goto cleanup;
+    return -1;
   }
 
   /* Check broadcast */
   if (olsr_cnf->ip_version == AF_INET && !iface->cnf->ipv4_broadcast.v4.s_addr &&       /* Skip if fixed bcast */
       (int_flags & IFF_BROADCAST) == 0) {
     OLSR_DEBUG(LOG_INTERFACE, "\tNo broadcast - skipping\n");
-    goto cleanup;
+    return -1;
   }
 
   if (int_flags & IFF_LOOPBACK) {
     OLSR_DEBUG(LOG_INTERFACE, "\tThis is a loopback interface - skipping it...\n");
-    goto cleanup;
+    return -1;
   }
 
   ifr_basename = if_basename(ifr.ifr_name);
@@ -391,7 +390,7 @@ os_init_interface(struct olsr_if_config *iface)
         OLSR_DEBUG(LOG_INTERFACE, "\tCould not find global IPv6 address for %s\n", ifr.ifr_name);
       else
         OLSR_DEBUG(LOG_INTERFACE, "\tCould not find an IPv6 address for %s\n", ifr.ifr_name);
-      goto cleanup;
+      return -1;
     }
 
     OLSR_DEBUG(LOG_INTERFACE, "\tAddress: %s\n", ip6_to_string(&buf, &ifp->int_src.v6.sin6_addr));
@@ -420,7 +419,7 @@ os_init_interface(struct olsr_if_config *iface)
     /* Get interface address (IPv4) */
     if (ioctl(olsr_cnf->ioctl_s, SIOCGIFADDR, &ifr) < 0) {
       OLSR_WARN(LOG_INTERFACE, "\tCould not get address of interface - skipping it\n");
-      goto cleanup;
+      return -1;
     }
 
     ifp->int_src.v4 = *(struct sockaddr_in *)(ARM_NOWARN_ALIGN(&ifr.ifr_addr));
@@ -433,7 +432,7 @@ os_init_interface(struct olsr_if_config *iface)
       /* Autodetect */
       if (ioctl(olsr_cnf->ioctl_s, SIOCGIFBRDADDR, &ifr) < 0) {
         OLSR_WARN(LOG_INTERFACE, "%s: ioctl (get broadaddr) failed", ifr.ifr_name);
-        goto cleanup;
+        return -1;
       }
 
       ifp->int_multicast.v4 = *(struct sockaddr_in *)(ARM_NOWARN_ALIGN(&ifr.ifr_broadaddr));
@@ -492,11 +491,7 @@ os_init_interface(struct olsr_if_config *iface)
 #if 0
   ifp->gen_properties = NULL;
 #endif
-  return ifp;
-
-cleanup:
-  olsr_cookie_free(interface_mem_cookie, ifp);
-  return NULL;
+  return 0;
 }
 
 /*