Cleanup of memory cookie system. Changed name from "cookie" to "memcookie".
authorHenning Rogge <hrogge@googlemail.com>
Sun, 13 Feb 2011 12:42:37 +0000 (13:42 +0100)
committerHenning Rogge <hrogge@googlemail.com>
Sun, 13 Feb 2011 12:42:37 +0000 (13:42 +0100)
28 files changed:
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/mdns/src/olsrd_plugin.c
lib/nameservice/src/nameservice.h
lib/obamp/src/olsrd_plugin.c
lib/watchdog/src/olsrd_plugin.c
src/duplicate_set.c
src/hna_set.c
src/interfaces.c
src/linux/kernel_tunnel.c
src/lq_plugin.c
src/main.c
src/mid_set.c
src/neighbor_table.c
src/olsr_comport.c
src/olsr_comport_http.c
src/olsr_comport_txt.c
src/olsr_memcookie.c [moved from src/olsr_cookie.c with 60% similarity]
src/olsr_memcookie.h [moved from src/olsr_cookie.h with 64% similarity]
src/plugin_loader.c
src/routing_table.c
src/routing_table.h
src/scheduler.c
src/tc_set.c
src/tc_set.h

index d29b848..53b9140 100644 (file)
@@ -48,7 +48,7 @@
 #include "defs.h"               /* uint8_t, olsr_cnf */
 #include "scheduler.h"          /* olsr_start_timer() */
 #include "olsr_cfg.h"           /* olsr_cnf() */
-#include "olsr_cookie.h"        /* olsr_create_memcookie() */
+#include "olsr_memcookie.h"        /* olsr_memcookie_add() */
 #include "olsr_logging.h"
 
 /* BMF includes */
index 87e2894..3f51922 100644 (file)
@@ -43,7 +43,7 @@
 #include "ipcalc.h"
 #include "scheduler.h"
 #include "olsr.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_ip_prefix_list.h"
 #include "olsr_logging.h"
 #include "os_system.h"
@@ -100,7 +100,7 @@ struct guest_client {
   float last_seen;
   pthread_t ping_thread;
   pthread_t ping_thread_add;
-  struct olsr_cookie_info *arping_timer_cookie;
+  struct olsr_memcookie_info *arping_timer_cookie;
   char ping_thread_done;
   struct timer_entry *arping_timer;
   int remaing_announcements;
index 7e4fe90..34156c8 100644 (file)
@@ -127,8 +127,8 @@ 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_msg_mem = NULL;
-static struct olsr_cookie_info *statistics_pkt_mem = NULL;
+static struct olsr_memcookie_info *statistics_msg_mem = NULL;
+static struct olsr_memcookie_info *statistics_pkt_mem = NULL;
 
 static struct olsr_timer_info *statistics_timer = NULL;
 
@@ -192,10 +192,10 @@ debuginfo_enable(void)
   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_create_memcookie("debuginfo msgstat",
+  statistics_msg_mem = olsr_memcookie_add("debuginfo msgstat",
       sizeof(struct debug_msgtraffic) + sizeof(struct debug_msgtraffic_count) * traffic_slots);
 
-  statistics_pkt_mem = olsr_create_memcookie("debuginfo pktstat",
+  statistics_pkt_mem = olsr_memcookie_add("debuginfo pktstat",
       sizeof(struct debug_pkttraffic) + sizeof(struct debug_pkttraffic_count) * traffic_slots);
 
   memset(&total_msg_traffic, 0, sizeof(total_msg_traffic));
@@ -212,7 +212,7 @@ static struct debug_msgtraffic *get_msgtraffic_entry(union olsr_ip_addr *ip) {
   struct debug_msgtraffic *tr;
   tr = (struct debug_msgtraffic *) avl_find(&stat_msg_tree, ip);
   if (tr == NULL) {
-    tr = olsr_cookie_malloc(statistics_msg_mem);
+    tr = olsr_memcookie_malloc(statistics_msg_mem);
 
     memcpy(&tr->ip, ip, sizeof(union olsr_ip_addr));
     tr->node.key = &tr->ip;
@@ -226,7 +226,7 @@ static struct debug_pkttraffic *get_pkttraffic_entry(union olsr_ip_addr *ip, str
   struct debug_pkttraffic *tr;
   tr = (struct debug_pkttraffic *) avl_find(&stat_pkt_tree, ip);
   if (tr == NULL) {
-    tr = olsr_cookie_malloc(statistics_pkt_mem);
+    tr = olsr_memcookie_malloc(statistics_pkt_mem);
 
     memcpy(&tr->ip, ip, sizeof(union olsr_ip_addr));
     tr->node.key = &tr->ip;
@@ -273,7 +273,7 @@ update_statistics_ptr(void *data __attribute__ ((unused)))
       /* no traffic left, cleanup ! */
 
       avl_delete(&stat_msg_tree, &msg->node);
-      olsr_cookie_free(statistics_msg_mem, msg);
+      olsr_memcookie_free(statistics_msg_mem, msg);
     }
   }
 
@@ -299,7 +299,7 @@ update_statistics_ptr(void *data __attribute__ ((unused)))
 
       avl_delete(&stat_pkt_tree, &pkt->node);
       free(pkt->int_name);
-      olsr_cookie_free(statistics_pkt_mem, pkt);
+      olsr_memcookie_free(statistics_pkt_mem, pkt);
     }
   }
 }
@@ -530,7 +530,7 @@ debuginfo_pktstat(struct comport_connection *con,
 }
 
 static INLINE bool debuginfo_print_cookies_mem(struct autobuf *buf) {
-  struct olsr_cookie_info *c, *iterator;
+  struct olsr_memcookie_info *c, *iterator;
 
   OLSR_FOR_ALL_COOKIES(c, iterator) {
     if (abuf_appendf(buf, "%-25s (MEMORY) size: %lu usage: %u freelist: %u\n",
index a820953..b2c420a 100644 (file)
@@ -49,7 +49,7 @@
 #include "defs.h"
 #include "ipcalc.h"
 #include "scheduler.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_ip_prefix_list.h"
 #include "olsr_logging.h"
 
index b29ba17..30b0b45 100644 (file)
@@ -44,7 +44,7 @@
 #include "ipcalc.h"
 #include "scheduler.h"
 #include "olsr.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_ip_prefix_list.h"
 #include "olsr_logging.h"
 
index 1ab1b21..dcd7a33 100644 (file)
@@ -48,7 +48,7 @@
 #include "defs.h"               /* uint8_t, olsr_cnf */
 #include "scheduler.h"          /* olsr_start_timer() */
 #include "olsr_cfg.h"           /* olsr_cnf() */
-#include "olsr_cookie.h"        /* olsr_create_memcookie() */
+#include "olsr_memcookie.h"        /* olsr_memcookie_add() */
 
 /* BMF includes */
 #include "mdns.h"               /* InitBmf(), CloseBmf() */
@@ -58,7 +58,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_memcookie_info *prune_packet_history_timer_cookie;
 
 void olsr_plugin_exit(void);
 
@@ -97,7 +97,7 @@ olsrd_plugin_init(void)
   //add_ifchgf(&InterfaceChange);
 
   /* create the cookie */
-  //prune_packet_history_timer_cookie = olsr_create_memcookie("BMF: Prune Packet History", OLSR_COOKIE_TYPE_TIMER);
+  //prune_packet_history_timer_cookie = olsr_memcookie_add("BMF: Prune Packet History", OLSR_COOKIE_TYPE_TIMER);
 
   /* Register the duplicate registration pruning process */
   //olsr_start_timer(3 * MSEC_PER_SEC, 0, OLSR_TIMER_PERIODIC,
index e7eee11..2e6db22 100644 (file)
@@ -120,7 +120,7 @@ struct db_entry {
 extern struct name_entry *my_names;
 extern struct list_entity latlon_list[HASHSIZE];
 extern float my_lat, my_lon;
-extern struct olsr_cookie_info *map_poll_timer_cookie;
+extern struct olsr_memcookie_info *map_poll_timer_cookie;
 
 void olsr_expire_write_file_timer(void *);
 void olsr_namesvc_delete_db_entry(struct db_entry *);
index 5c90303..a4b0508 100644 (file)
@@ -52,7 +52,7 @@
 #include "defs.h"               /* uint8_t, olsr_cnf */
 #include "scheduler.h"          /* olsr_start_timer() */
 #include "olsr_cfg.h"           /* olsr_cnf() */
-#include "olsr_cookie.h"        /* olsr_create_memcookie() */
+#include "olsr_memcookie.h"        /* olsr_memcookie_add() */
 
 /* OBAMP includes */
 #include "obamp.h"
index be42db6..3a02d1a 100644 (file)
@@ -50,7 +50,7 @@
 #include "olsr.h"
 #include "defs.h"
 #include "scheduler.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_logging.h"
 
 #include "plugin.h"
index a40a948..bd1f3ea 100644 (file)
@@ -46,7 +46,7 @@
 #include "mid_set.h"
 #include "scheduler.h"
 #include "olsr_time.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_logging.h"
 
 #include <stdlib.h>
@@ -55,7 +55,7 @@ struct avl_tree forward_set, processing_set;
 
 /* Some cookies for stats keeping */
 static struct olsr_timer_info *duplicate_timer_info = NULL;
-static struct olsr_cookie_info *duplicate_mem_cookie = NULL;
+static struct olsr_memcookie_info *duplicate_mem_cookie = NULL;
 
 int
 olsr_seqno_diff(uint16_t reference, uint16_t other)
@@ -78,7 +78,7 @@ olsr_create_duplicate_entry(union olsr_ip_addr *ip, uint16_t seqnr)
 {
   struct dup_entry *entry;
 
-  entry = olsr_cookie_malloc(duplicate_mem_cookie);
+  entry = olsr_memcookie_malloc(duplicate_mem_cookie);
   if (entry != NULL) {
     memcpy(&entry->ip, ip, olsr_cnf->ip_version == AF_INET ? sizeof(entry->ip.v4) : sizeof(entry->ip.v6));
     entry->seqnr = seqnr;
@@ -96,7 +96,7 @@ olsr_delete_duplicate_entry(struct dup_entry *entry)
   entry->tree = NULL;
   olsr_stop_timer(entry->validity_timer);
   entry->validity_timer = NULL;
-  olsr_cookie_free(duplicate_mem_cookie, entry);
+  olsr_memcookie_free(duplicate_mem_cookie, entry);
 }
 
 static void
@@ -121,7 +121,7 @@ olsr_init_duplicate_set(void)
    */
   duplicate_timer_info = olsr_alloc_timerinfo("Duplicate Set", &olsr_expire_duplicate_entry, false);
 
-  duplicate_mem_cookie = olsr_create_memcookie("dup_entry", sizeof(struct dup_entry));
+  duplicate_mem_cookie = olsr_memcookie_add("dup_entry", sizeof(struct dup_entry));
 }
 
 
index 76b7673..d7f9029 100644 (file)
@@ -52,7 +52,7 @@
 
 /* Some cookies for stats keeping */
 static struct olsr_timer_info *hna_net_timer_info = NULL;
-static struct olsr_cookie_info *hna_net_mem_cookie = NULL;
+static struct olsr_memcookie_info *hna_net_mem_cookie = NULL;
 
 static void olsr_expire_hna_net_entry(void *context);
 
@@ -66,7 +66,7 @@ olsr_init_hna_set(void)
 
   hna_net_timer_info = olsr_alloc_timerinfo("HNA Network", &olsr_expire_hna_net_entry, false);
 
-  hna_net_mem_cookie = olsr_create_memcookie("hna_net", sizeof(struct hna_net));
+  hna_net_mem_cookie = olsr_memcookie_add("hna_net", sizeof(struct hna_net));
 }
 
 /**
@@ -99,7 +99,7 @@ static struct hna_net *
 olsr_add_hna_net(struct tc_entry *tc, const struct olsr_ip_prefix *prefix)
 {
   /* Add the net */
-  struct hna_net *new_net = olsr_cookie_malloc(hna_net_mem_cookie);
+  struct hna_net *new_net = olsr_memcookie_malloc(hna_net_mem_cookie);
 
   /* Fill struct */
   new_net->hna_prefix = *prefix;
@@ -143,7 +143,7 @@ olsr_delete_hna_net(struct hna_net *hna_net)
   /*
    * Unlock and free.
    */
-  olsr_cookie_free(hna_net_mem_cookie, hna_net);
+  olsr_memcookie_free(hna_net_mem_cookie, hna_net);
 }
 
 /**
index 160c484..7af5793 100644 (file)
@@ -73,8 +73,8 @@ static struct ifchgf *ifchgf_list = NULL;
 
 
 /* Some cookies for stats keeping */
-static struct olsr_cookie_info *interface_mem_cookie = NULL;
-static struct olsr_cookie_info *interface_lost_mem_cookie = NULL;
+static struct olsr_memcookie_info *interface_mem_cookie = NULL;
+static struct olsr_memcookie_info *interface_lost_mem_cookie = NULL;
 
 static struct olsr_timer_info *interface_poll_timerinfo = NULL;
 static struct olsr_timer_info *hello_gen_timerinfo = NULL;
@@ -99,9 +99,9 @@ init_interfaces(void)
   /*
    * Get some cookies for getting stats to ease troubleshooting.
    */
-  interface_mem_cookie = olsr_create_memcookie("Interface", sizeof(struct interface));
+  interface_mem_cookie = olsr_memcookie_add("Interface", sizeof(struct interface));
 
-  interface_lost_mem_cookie = olsr_create_memcookie("Interface lost", sizeof(struct interface_lost));
+  interface_lost_mem_cookie = olsr_memcookie_add("Interface lost", sizeof(struct interface_lost));
 
   interface_poll_timerinfo = olsr_alloc_timerinfo("Interface Polling", &check_interface_updates, true);
   hello_gen_timerinfo = olsr_alloc_timerinfo("Hello Generation", &generate_hello, true);
@@ -128,7 +128,7 @@ static void remove_lost_interface_ip(struct interface_lost *lost) {
   OLSR_DEBUG(LOG_INTERFACE, "Remove %s from lost interface list\n",
       olsr_ip_to_string(&buf, &lost->ip));
   avl_delete(&interface_lost_tree, &lost->node);
-  olsr_cookie_free(interface_lost_mem_cookie, lost);
+  olsr_memcookie_free(interface_lost_mem_cookie, lost);
 }
 
 static void add_lost_interface_ip(union olsr_ip_addr *ip, uint32_t hello_timeout) {
@@ -137,7 +137,7 @@ static void add_lost_interface_ip(union olsr_ip_addr *ip, uint32_t hello_timeout
   struct ipaddr_str buf;
 #endif
 
-  lost = olsr_cookie_malloc(interface_lost_mem_cookie);
+  lost = olsr_memcookie_malloc(interface_lost_mem_cookie);
   lost->node.key = &lost->ip;
   lost->ip = *ip;
   lost->valid_until = olsr_getTimestamp(hello_timeout * 2);
@@ -177,11 +177,11 @@ struct interface *
 add_interface(struct olsr_if_config *iface) {
   struct interface *ifp;
 
-  ifp = olsr_cookie_malloc(interface_mem_cookie);
+  ifp = olsr_memcookie_malloc(interface_mem_cookie);
   ifp->int_name = iface->name;
 
   if ((os_init_interface(ifp, iface))) {
-    olsr_cookie_free(interface_mem_cookie, ifp);
+    olsr_memcookie_free(interface_mem_cookie, ifp);
     return NULL;
   }
 
@@ -499,7 +499,7 @@ unlock_interface(struct interface *ifp)
 
   /* Free memory */
   free(ifp->int_name);
-  olsr_cookie_free(interface_mem_cookie, ifp);
+  olsr_memcookie_free(interface_mem_cookie, ifp);
 }
 
 
index 0515fa1..2e7a943 100644 (file)
@@ -41,7 +41,7 @@
 
 #include "defs.h"
 #include "olsr_types.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_logging.h"
 #include "ipcalc.h"
 #include "os_net.h"
@@ -72,13 +72,13 @@ static const char DEV_IPV4_TUNNEL[IFNAMSIZ] = TUNNEL_ENDPOINT_IF;
 static const char DEV_IPV6_TUNNEL[IFNAMSIZ] = TUNNEL_ENDPOINT_IF6;
 
 static bool store_iptunnel_state;
-static struct olsr_cookie_info *tunnel_cookie;
+static struct olsr_memcookie_info *tunnel_cookie;
 static struct avl_tree tunnel_tree;
 
 int os_iptunnel_init(void) {
   const char *dev = olsr_cnf->ip_version == AF_INET ? DEV_IPV4_TUNNEL : DEV_IPV6_TUNNEL;
 
-  tunnel_cookie = olsr_create_memcookie("iptunnel", sizeof(struct olsr_iptunnel_entry));
+  tunnel_cookie = olsr_memcookie_add("iptunnel", sizeof(struct olsr_iptunnel_entry));
   avl_init(&tunnel_tree, avl_comp_default, false, NULL);
 
   store_iptunnel_state = os_is_interface_up(dev);
@@ -106,7 +106,7 @@ void os_iptunnel_cleanup(void) {
     os_interface_set_state(olsr_cnf->ip_version == AF_INET ? DEV_IPV4_TUNNEL : DEV_IPV6_TUNNEL, false);
   }
 
-  olsr_cleanup_memcookie(tunnel_cookie);
+  olsr_memcookie_remove(tunnel_cookie);
 }
 
 /**
@@ -254,7 +254,7 @@ struct olsr_iptunnel_entry *os_iptunnel_add_ipip(union olsr_ip_addr *target, boo
     /* set originator IP for tunnel */
     olsr_os_ifip(if_idx, &olsr_cnf->router_id, true);
 
-    t = olsr_cookie_malloc(tunnel_cookie);
+    t = olsr_memcookie_malloc(tunnel_cookie);
     memcpy(&t->target, target, sizeof(*target));
     t->node.key = &t->target;
 
@@ -297,7 +297,7 @@ static void internal_olsr_os_del_ipip_tunnel(struct olsr_iptunnel_entry *t, bool
 
   avl_delete(&tunnel_tree, &t->node);
   if (!cleanup) {
-    olsr_cookie_free(tunnel_cookie, t);
+    olsr_memcookie_free(tunnel_cookie, t);
   }
 }
 
index 7535eb5..1fe10c8 100644 (file)
@@ -45,7 +45,7 @@
 #include "olsr_spf.h"
 #include "lq_packet.h"
 #include "olsr.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "common/avl.h"
 #include "common/string.h"
 #include "olsr_logging.h"
@@ -55,9 +55,9 @@
 
 struct lq_handler *active_lq_handler = NULL;
 
-static struct olsr_cookie_info *tc_edge_mem_cookie = NULL;
-static struct olsr_cookie_info *lq_hello_neighbor_mem_cookie = NULL;
-static struct olsr_cookie_info *link_entry_mem_cookie = NULL;
+static struct olsr_memcookie_info *tc_edge_mem_cookie = NULL;
+static struct olsr_memcookie_info *lq_hello_neighbor_mem_cookie = NULL;
+static struct olsr_memcookie_info *link_entry_mem_cookie = NULL;
 
 void
 init_lq_handler(void)
@@ -69,13 +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_create_memcookie("tc_edge", active_lq_handler->size_tc_edge);
+  tc_edge_mem_cookie = olsr_memcookie_add("tc_edge", active_lq_handler->size_tc_edge);
 
   lq_hello_neighbor_mem_cookie =
-      olsr_create_memcookie("lq_hello_neighbor", active_lq_handler->size_lq_hello_neighbor);
+      olsr_memcookie_add("lq_hello_neighbor", active_lq_handler->size_lq_hello_neighbor);
 
   link_entry_mem_cookie =
-      olsr_create_memcookie("link_entry", active_lq_handler->size_link_entry);
+      olsr_memcookie_add("link_entry", active_lq_handler->size_link_entry);
 
   if (active_lq_handler->initialize) {
     active_lq_handler->initialize();
@@ -386,7 +386,7 @@ olsr_malloc_tc_edge_entry(void)
 {
   struct tc_edge_entry *t;
 
-  t = olsr_cookie_malloc(tc_edge_mem_cookie);
+  t = olsr_memcookie_malloc(tc_edge_mem_cookie);
   if (active_lq_handler->clear_tc_edge_entry)
     active_lq_handler->clear_tc_edge_entry(t);
   return t;
@@ -405,7 +405,7 @@ olsr_malloc_lq_hello_neighbor(void)
 {
   struct lq_hello_neighbor *h;
 
-  h = olsr_cookie_malloc(lq_hello_neighbor_mem_cookie);
+  h = olsr_memcookie_malloc(lq_hello_neighbor_mem_cookie);
   if (active_lq_handler->clear_lq_hello_neighbor)
     active_lq_handler->clear_lq_hello_neighbor(h);
   return h;
@@ -424,7 +424,7 @@ olsr_malloc_link_entry(void)
 {
   struct link_entry *h;
 
-  h = olsr_cookie_malloc(link_entry_mem_cookie);
+  h = olsr_memcookie_malloc(link_entry_mem_cookie);
   if (active_lq_handler->clear_link_entry)
     active_lq_handler->clear_link_entry(h);
   return h;
@@ -440,7 +440,7 @@ olsr_malloc_link_entry(void)
 void
 olsr_free_link_entry(struct link_entry *link)
 {
-  olsr_cookie_free(link_entry_mem_cookie, link);
+  olsr_memcookie_free(link_entry_mem_cookie, link);
 }
 
 /**
@@ -453,7 +453,7 @@ olsr_free_link_entry(struct link_entry *link)
 void
 olsr_free_lq_hello_neighbor(struct lq_hello_neighbor *neigh)
 {
-  olsr_cookie_free(lq_hello_neighbor_mem_cookie, neigh);
+  olsr_memcookie_free(lq_hello_neighbor_mem_cookie, neigh);
 }
 
 /**
@@ -466,7 +466,7 @@ olsr_free_lq_hello_neighbor(struct lq_hello_neighbor *neigh)
 void
 olsr_free_tc_edge_entry(struct tc_edge_entry *edge)
 {
-  olsr_cookie_free(tc_edge_mem_cookie, edge);
+  olsr_memcookie_free(tc_edge_mem_cookie, edge);
 }
 
 /**
index 3e13853..0cb748f 100644 (file)
@@ -239,7 +239,7 @@ main(int argc, char *argv[])
 #endif
 
   /* initialize cookie system */
-  olsr_cookie_init();
+  olsr_memcookie_init();
 
   /* Initialize timers and scheduler part */
   olsr_init_timers();
@@ -593,7 +593,7 @@ olsr_shutdown(void)
   olsr_callback_cleanup();
 
   /* Free cookies and memory pools attached. */
-  olsr_cookie_cleanup();
+  olsr_memcookie_cleanup();
 
   /* Reset os_specific global options */
   os_cleanup();
index 16cb8ce..c620479 100644 (file)
@@ -48,7 +48,7 @@
 #include "link_set.h"
 #include "tc_set.h"
 #include "net_olsr.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_logging.h"
 #include "olsr_protocol.h"
 
@@ -62,7 +62,7 @@ static void olsr_expire_mid_entries(void *context);
 struct avl_tree mid_tree;
 
 /* validity timer of MID entries */
-static struct olsr_cookie_info *mid_address_mem_cookie = NULL;
+static struct olsr_memcookie_info *mid_address_mem_cookie = NULL;
 static struct olsr_timer_info *mid_validity_timer_info = NULL;
 
 /**
@@ -80,7 +80,7 @@ olsr_init_mid_set(void)
    */
   mid_validity_timer_info = olsr_alloc_timerinfo("MID validity", &olsr_expire_mid_entries, false);
 
-  mid_address_mem_cookie = olsr_create_memcookie("MID address", sizeof(struct mid_entry));
+  mid_address_mem_cookie = olsr_memcookie_add("MID address", sizeof(struct mid_entry));
 }
 
 /**
@@ -241,7 +241,7 @@ olsr_insert_mid_entry(const union olsr_ip_addr *main_addr,
   tc = olsr_locate_tc_entry(main_addr);
   assert(tc);
 
-  alias = olsr_cookie_malloc(mid_address_mem_cookie);
+  alias = olsr_memcookie_malloc(mid_address_mem_cookie);
   alias->mid_alias_addr = *alias_addr;
   alias->mid_tc = tc;
 
@@ -392,7 +392,7 @@ olsr_delete_mid_entry(struct mid_entry *alias)
    */
   avl_delete(&mid_tree, &alias->mid_node);
 
-  olsr_cookie_free(mid_address_mem_cookie, alias);
+  olsr_memcookie_free(mid_address_mem_cookie, alias);
 }
 
 /**
index a5881a9..fd0d940 100644 (file)
@@ -57,9 +57,9 @@ struct avl_tree nbr_tree;
 struct avl_tree nbr2_tree;
 
 /* 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_memcookie_info *nbr2_mem_cookie = NULL;
+static struct olsr_memcookie_info *nbr_mem_cookie = NULL;
+static struct olsr_memcookie_info *nbr_connector_mem_cookie = NULL;
 
 /* neighbor connection validity timer */
 static struct olsr_timer_info *nbr_connector_timer_info = NULL;
@@ -78,11 +78,11 @@ olsr_init_neighbor_table(void)
   avl_init(&nbr2_tree, avl_comp_default, false, NULL);
 
   nbr_connector_timer_info = olsr_alloc_timerinfo("Neighbor connector", &olsr_expire_nbr_con, false);
-  nbr_connector_mem_cookie = olsr_create_memcookie("Neighbor connector", sizeof(struct nbr_con));
+  nbr_connector_mem_cookie = olsr_memcookie_add("Neighbor connector", sizeof(struct nbr_con));
 
-  nbr_mem_cookie = olsr_create_memcookie("1-Hop Neighbor", sizeof(struct nbr_entry));
+  nbr_mem_cookie = olsr_memcookie_add("1-Hop Neighbor", sizeof(struct nbr_entry));
 
-  nbr2_mem_cookie = olsr_create_memcookie("2-Hop Neighbor", sizeof(struct nbr2_entry));
+  nbr2_mem_cookie = olsr_memcookie_add("2-Hop Neighbor", sizeof(struct nbr2_entry));
 }
 
 /**
@@ -109,7 +109,7 @@ olsr_add_nbr_entry(const union olsr_ip_addr *addr)
 
   OLSR_DEBUG(LOG_NEIGHTABLE, "Add 1-hop neighbor: %s\n", olsr_ip_to_string(&buf, addr));
 
-  nbr = olsr_cookie_malloc(nbr_mem_cookie);
+  nbr = olsr_memcookie_malloc(nbr_mem_cookie);
 
   /* Set address, willingness and status */
   nbr->nbr_addr = *addr;
@@ -175,7 +175,7 @@ olsr_delete_nbr_entry(struct nbr_entry *nbr)
   /* Remove from global neighbor tree */
   avl_delete(&nbr_tree, &nbr->nbr_node);
 
-  olsr_cookie_free(nbr_mem_cookie, nbr);
+  olsr_memcookie_free(nbr_mem_cookie, nbr);
 
   changes_neighborhood = true;
   changes_topology = true;
@@ -278,7 +278,7 @@ olsr_add_nbr2_entry(const union olsr_ip_addr *addr) {
 
   OLSR_DEBUG(LOG_2NEIGH, "Adding 2 hop neighbor %s\n", olsr_ip_to_string(&buf, addr));
 
-  nbr2 = olsr_cookie_malloc(nbr2_mem_cookie);
+  nbr2 = olsr_memcookie_malloc(nbr2_mem_cookie);
 
   /* Init neighbor connector subtree */
   avl_init(&nbr2->con_tree, avl_comp_default, false, NULL);
@@ -317,7 +317,7 @@ olsr_delete_nbr2_entry(struct nbr2_entry *nbr2) {
   /* Remove from global neighbor tree */
   avl_delete(&nbr2_tree, &nbr2->nbr2_node);
 
-  olsr_cookie_free(nbr2_mem_cookie, nbr2);
+  olsr_memcookie_free(nbr2_mem_cookie, nbr2);
   changes_neighborhood = true;
 }
 
@@ -366,7 +366,7 @@ olsr_link_nbr_nbr2(struct nbr_entry *nbr, const union olsr_ip_addr *nbr2_addr, u
    */
   nbr2 = olsr_add_nbr2_entry(nbr2_addr);
 
-  connector = olsr_cookie_malloc(nbr_connector_mem_cookie);
+  connector = olsr_memcookie_malloc(nbr_connector_mem_cookie);
 
   connector->nbr = nbr;
   connector->nbr2 = nbr2;
@@ -396,7 +396,7 @@ internal_delete_nbr_con(struct nbr_con *connector) {
   avl_delete(&connector->nbr->con_tree, &connector->nbr_tree_node);
   avl_delete(&connector->nbr2->con_tree, &connector->nbr2_tree_node);
 
-  olsr_cookie_free(nbr_connector_mem_cookie, connector);
+  olsr_memcookie_free(nbr_connector_mem_cookie, connector);
 }
 
 /**
index f9d1515..75da7f6 100644 (file)
@@ -53,7 +53,7 @@
 #include "olsr_logging.h"
 #include "olsr_cfg.h"
 #include "scheduler.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "common/autobuf.h"
 #include "common/avl.h"
 #include "common/list.h"
@@ -77,7 +77,7 @@ struct list_entity olsr_comport_head;
 static int comsocket_http = 0;
 static int comsocket_txt = 0;
 
-static struct olsr_cookie_info *connection_cookie;
+static struct olsr_memcookie_info *connection_cookie;
 static struct olsr_timer_info *connection_timeout;
 
 /* counter for open connections */
@@ -95,7 +95,7 @@ static void olsr_com_timeout_handler(void *);
 void
 olsr_com_init(bool failfast) {
   connection_cookie =
-      olsr_create_memcookie("comport connections", sizeof(struct comport_connection));
+      olsr_memcookie_add("comport connections", sizeof(struct comport_connection));
 
   connection_timeout = olsr_alloc_timerinfo("comport timout",
       &olsr_com_timeout_handler, false);
@@ -228,7 +228,7 @@ olsr_com_parse_request(int fd, void *data __attribute__ ((unused)), unsigned int
     return;
   }
 
-  con = olsr_cookie_malloc(connection_cookie);
+  con = olsr_memcookie_malloc(connection_cookie);
   abuf_init(&con->in, 1024);
   abuf_init(&con->out, 0);
 
@@ -296,7 +296,7 @@ olsr_com_cleanup_session(struct comport_connection *con) {
   abuf_free(&con->in);
   abuf_free(&con->out);
 
-  olsr_cookie_free(connection_cookie, con);
+  olsr_memcookie_free(connection_cookie, con);
 }
 
 static void
index b6c0783..e6ceb09 100644 (file)
@@ -47,7 +47,7 @@
 #include "common/avl_olsr_comp.h"
 #include "common/string.h"
 #include "olsr_logging.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_comport.h"
 #include "olsr_comport_http.h"
 #include "olsr_comport_txt.h"
@@ -59,7 +59,7 @@
 static const char HTTP_VERSION[] = "HTTP/1.0";
 static const char TELNET_PATH[] = "/telnet/";
 
-static struct olsr_cookie_info *htmlsite_cookie;
+static struct olsr_memcookie_info *htmlsite_cookie;
 struct avl_tree http_handler_tree;
 
 /**Response types */
@@ -146,7 +146,7 @@ void
 olsr_com_init_http(void) {
   avl_init(&http_handler_tree, &avl_comp_strcasecmp, false, NULL);
 
-  htmlsite_cookie = olsr_create_memcookie("comport http sites", sizeof(struct olsr_html_site));
+  htmlsite_cookie = olsr_memcookie_add("comport http sites", sizeof(struct olsr_html_site));
 
   /* activate telnet gateway */
   olsr_com_add_htmlhandler(olsr_com_html2telnet_gate, TELNET_PATH);
@@ -167,7 +167,7 @@ struct olsr_html_site *
 olsr_com_add_htmlsite(const char *path, const char *content, size_t length) {
   struct olsr_html_site *site;
 
-  site = olsr_cookie_malloc(htmlsite_cookie);
+  site = olsr_memcookie_malloc(htmlsite_cookie);
   site->node.key = strdup(path);
 
   site->static_site = true;
@@ -183,7 +183,7 @@ olsr_com_add_htmlhandler(void(*sitehandler)(struct comport_connection *con, stru
     const char *path) {
   struct olsr_html_site *site;
 
-  site = olsr_cookie_malloc(htmlsite_cookie);
+  site = olsr_memcookie_malloc(htmlsite_cookie);
   site->node.key = strdup(path);
 
   site->static_site = false;
@@ -197,7 +197,7 @@ void
 olsr_com_remove_htmlsite(struct olsr_html_site *site) {
   avl_delete(&http_handler_tree, &site->node);
   free(site->node.key);
-  olsr_cookie_free(htmlsite_cookie, site);
+  olsr_memcookie_free(htmlsite_cookie, site);
 }
 
 void
index 0641636..649cd29 100644 (file)
@@ -44,7 +44,7 @@
 
 #include "olsr_cfg.h"
 #include "olsr_logging.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_ip_acl.h"
 #include "olsr.h"
 #include "ipcalc.h"
@@ -64,7 +64,7 @@ struct txt_repeat_data {
 };
 
 static struct avl_tree txt_normal_tree, txt_help_tree;
-static struct olsr_cookie_info *txtcommand_cookie;
+static struct olsr_memcookie_info *txtcommand_cookie;
 static struct olsr_timer_info *txt_repeat_timerinfo;
 
 static void olsr_txt_repeat_timer(void *data);
@@ -134,7 +134,7 @@ 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_create_memcookie("comport txt commands", sizeof(struct olsr_txtcommand));
+  txtcommand_cookie = olsr_memcookie_add("comport txt commands", sizeof(struct olsr_txtcommand));
 
   txt_repeat_timerinfo = olsr_alloc_timerinfo("txt repeat timer", olsr_txt_repeat_timer, true);
 
@@ -156,7 +156,7 @@ struct olsr_txtcommand *
 olsr_com_add_normal_txtcommand (const char *command, olsr_txthandler handler) {
   struct olsr_txtcommand *txt;
 
-  txt = olsr_cookie_malloc(txtcommand_cookie);
+  txt = olsr_memcookie_malloc(txtcommand_cookie);
   txt->node.key = strdup(command);
   txt->handler = handler;
 
@@ -168,7 +168,7 @@ struct olsr_txtcommand *
 olsr_com_add_help_txtcommand (const char *command, olsr_txthandler handler) {
   struct olsr_txtcommand *txt;
 
-  txt = olsr_cookie_malloc(txtcommand_cookie);
+  txt = olsr_memcookie_malloc(txtcommand_cookie);
   txt->node.key = strdup(command);
   txt->handler = handler;
 
@@ -179,13 +179,13 @@ olsr_com_add_help_txtcommand (const char *command, olsr_txthandler handler) {
 void olsr_com_remove_normal_txtcommand (struct olsr_txtcommand *cmd) {
   avl_delete(&txt_normal_tree, &cmd->node);
   free(cmd->node.key);
-  olsr_cookie_free(txtcommand_cookie, cmd);
+  olsr_memcookie_free(txtcommand_cookie, cmd);
 }
 
 void olsr_com_remove_help_txtcommand (struct olsr_txtcommand *cmd) {
   avl_delete(&txt_help_tree, &cmd->node);
   free(cmd->node.key);
-  olsr_cookie_free(txtcommand_cookie, cmd);
+  olsr_memcookie_free(txtcommand_cookie, cmd);
 }
 
 enum olsr_txtcommand_result
similarity index 60%
rename from src/olsr_cookie.c
rename to src/olsr_memcookie.c
index 41bcc4b..84ac172 100644 (file)
@@ -41,7 +41,7 @@
 
 #include "olsr.h"
 #include "defs.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "olsr_logging.h"
 #include "common/list.h"
 
 
 struct avl_tree olsr_cookie_tree;
 
-static inline size_t calc_aligned_size(size_t size) {
+/**
+ * Align a byte size correctly to "two size_t" units
+ * @param size number of bytes for an unaligned block
+ * @return number of bytes including padding for alignment
+ */
+static inline size_t
+calc_aligned_size(size_t size) {
   static const size_t add = sizeof(size_t) * 2 - 1;
   static const size_t mask = ~(sizeof(size_t)*2 - 1);
 
   return (size + add) & mask;
 }
 
-void olsr_cookie_init(void) {
+/**
+ * Increment usage state for a given cookie.
+ * @param ci pointer to memcookie info
+ */
+static inline void
+olsr_cookie_usage_incr(struct olsr_memcookie_info *ci)
+{
+  ci->ci_usage++;
+  ci->ci_changes++;
+}
+
+/**
+ * Decrement usage state for a given cookie.
+ * @param ci pointer to memcookie info
+ */
+static inline void
+olsr_cookie_usage_decr(struct olsr_memcookie_info *ci)
+{
+  ci->ci_usage--;
+  ci->ci_changes++;
+}
+
+/**
+ * Initialize the memory cookie system
+ */
+void
+olsr_memcookie_init(void) {
   /* check size of memory prefix */
   assert (sizeof(struct olsr_memory_prefix)
       == calc_aligned_size(sizeof(struct olsr_memory_prefix)));
@@ -66,18 +98,35 @@ void olsr_cookie_init(void) {
   avl_init(&olsr_cookie_tree, &avl_comp_strcasecmp, false, NULL);
 }
 
-/*
- * Allocate a cookie for the next available cookie id.
+/**
+ * Cleanup the memory cookie system
  */
-struct olsr_cookie_info *
-olsr_create_memcookie(const char *cookie_name, size_t size)
+void
+olsr_memcookie_cleanup(void)
 {
-  struct olsr_cookie_info *ci;
+  struct olsr_memcookie_info *info, *iterator;
 
-  assert (cookie_name);
-  assert (size > 9);
+  /*
+   * Walk the full index range and kill 'em all.
+   */
+  OLSR_FOR_ALL_COOKIES(info, iterator) {
+    olsr_memcookie_remove(info);
+  }
+}
+
+/**
+ * Allocate a new memcookie.
+ * @param cookie_name id of the cookie
+ * @param size number of bytes to allocate for each cookie
+ * @return memcookie_info pointer
+ */
+struct olsr_memcookie_info *
+olsr_memcookie_add(const char *cookie_name, size_t size)
+{
+  struct olsr_memcookie_info *ci;
 
-  ci = olsr_malloc(sizeof(struct olsr_cookie_info), "memory cookie");
+  assert (cookie_name);
+  ci = olsr_malloc(sizeof(struct olsr_memcookie_info), "memory cookie");
 
   /* Now populate the cookie info */
   ci->ci_name = olsr_strdup(cookie_name);
@@ -98,11 +147,12 @@ olsr_create_memcookie(const char *cookie_name, size_t size)
   return ci;
 }
 
-/*
- * Free a cookie that is no longer being used.
+/**
+ * Delete a memcookie and all attached memory
+ * @param ci pointer to memcookie
  */
 void
-olsr_cleanup_memcookie(struct olsr_cookie_info *ci)
+olsr_memcookie_remove(struct olsr_memcookie_info *ci)
 {
   struct olsr_memory_prefix *memory_entity, *iterator;
 
@@ -132,61 +182,16 @@ olsr_cleanup_memcookie(struct olsr_cookie_info *ci)
   free(ci);
 }
 
-/*
- * Flush all cookies. This is really only called upon shutdown.
- */
-void
-olsr_cookie_cleanup(void)
-{
-  struct olsr_cookie_info *info, *iterator;
-
-  /*
-   * Walk the full index range and kill 'em all.
-   */
-  OLSR_FOR_ALL_COOKIES(info, iterator) {
-    olsr_cleanup_memcookie(info);
-  }
-}
-
-/*
- * 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.
- */
-static inline void
-olsr_cookie_usage_incr(struct olsr_cookie_info *ci)
-{
-  ci->ci_usage++;
-  ci->ci_changes++;
-}
-
-/*
- * Decrement usage state for a given cookie.
- */
-static inline void
-olsr_cookie_usage_decr(struct olsr_cookie_info *ci)
-{
-  ci->ci_usage--;
-  ci->ci_changes++;
-}
-
-/*
+/**
  * Allocate a fixed amount of memory based on a passed in cookie type.
+ * @param ci pointer to memcookie info
+ * @return allocated memory
  */
 void *
-olsr_cookie_malloc(struct olsr_cookie_info *ci)
+olsr_memcookie_malloc(struct olsr_memcookie_info *ci)
 {
   struct olsr_memory_prefix *mem;
-  struct olsr_cookie_custom *custom, *iterator;
+  struct olsr_memcookie_custom *custom, *iterator;
 
 #if !defined REMOVE_LOG_DEBUG
   bool reuse = false;
@@ -240,15 +245,15 @@ olsr_cookie_malloc(struct olsr_cookie_info *ci)
   return mem + 1;
 }
 
-/*
+/**
  * Free a memory block owned by a given cookie.
- * Run some corruption checks.
+ * @param ci pointer to memcookie info
+ * @param ptr pointer to memory block
  */
 void
-olsr_cookie_free(struct olsr_cookie_info *ci, void *ptr)
+olsr_memcookie_free(struct olsr_memcookie_info *ci, void *ptr)
 {
   struct olsr_memory_prefix *mem;
-  struct olsr_cookie_custom *custom, *iterator;
 #if !defined REMOVE_LOG_DEBUG
   bool reuse = false;
 #endif
@@ -257,13 +262,6 @@ olsr_cookie_free(struct olsr_cookie_info *ci, void *ptr)
   mem = ptr;
   mem--;
 
-  /* call up custom cleanup */
-  OLSR_FOR_ALL_CUSTOM_MEM(ci, custom, iterator) {
-    if (custom->cleanup) {
-      custom->cleanup(ci, ptr, mem->custom + custom->offset);
-    }
-  }
-
   /* remove from used_memory list */
   list_remove(&mem->node);
 
@@ -297,68 +295,121 @@ olsr_cookie_free(struct olsr_cookie_info *ci, void *ptr)
              ci->ci_name, ptr, (unsigned long)ci->ci_total_size, reuse ? ", reuse" : "");
 }
 
-struct olsr_cookie_custom *
-olsr_alloc_cookie_custom(struct olsr_cookie_info *ci, size_t size, const char *name,
-    void (*init)(struct olsr_cookie_info *, void *, void *),
-    void (*cleanup)(struct olsr_cookie_info *, void *, void *)) {
-  struct olsr_cookie_custom *custom;
-  struct olsr_memory_prefix *mem, *iterator;
+/**
+ * Add a custom memory section to an existing memcookie.
+ *
+ * Calling this function will call the specified init() callback and
+ * the move() callback of all existing custom extensions of this memcookie
+ * for every existing piece of allocated memory of the memcookie.
+ *
+ * @param memcookie_name name of memory cookie to be extended
+ * @param name name of custom addition for the memory cookie
+ * @param size number of bytes needed for custom addition
+ * @param init callback of the custom memcookie manager which is called every
+ *   times a new memcookie instance is allocated. Parameters are the memcookie_info
+ *   object, a pointer to the allocated memory and a pointer to the custom
+ *   part of the memory object.
+ * @param move callback of the custom memcookie manager which is called every
+ *   times the memory of the custom extension changes (because of adding/removal of
+ *   other custom extensions). Parameters are the memcookie_info object, a pointer to
+ *   the allocated memory, a pointer to the old position of the custom extension and
+ *   a pointer to the new custom extension.
+ * @return custom memory cookie
+ */
+struct olsr_memcookie_custom *
+olsr_memcookie_add_custom(const char *memcookie_name, const char *name, size_t size,
+    void (*init)(struct olsr_memcookie_info *, void *, void *),
+    void (*move)(struct olsr_memcookie_info *, void *, void *)) {
+  struct olsr_memcookie_info *ci;
+  struct olsr_memcookie_custom *custom_cookie;
+  struct olsr_memcookie_custom *custom, *custom_iterator;
+  struct olsr_memory_prefix *mem, *mem_iterator;
   size_t old_total_size, new_total_size;
 
-  custom = olsr_malloc(sizeof(struct olsr_cookie_custom), name);
-  custom->name = strdup(name);
-  custom->size = calc_aligned_size(size);
-  custom->init = init;
-  custom->cleanup = cleanup;
+  ci = avl_find_element(&olsr_cookie_tree, memcookie_name, ci, ci_node);
+  if (ci == NULL) {
+    OLSR_WARN(LOG_COOKIE, "Memory cookie '%s' does not exist, cannot add custom block '%s'\n",
+        memcookie_name, name);
+    return NULL;
+  }
+
+  custom_cookie = olsr_malloc(sizeof(struct olsr_memcookie_custom), name);
+  custom_cookie->name = strdup(name);
+  custom_cookie->size = calc_aligned_size(size);
+  custom_cookie->init = init;
+  custom_cookie->move = move;
 
   /* recalculate custom data block size */
   old_total_size = ci->ci_total_size - ci->ci_custom_offset;
-  new_total_size = old_total_size + custom->size;
+  new_total_size = old_total_size + custom_cookie->size;
 
-  custom->offset = old_total_size;
-  ci->ci_total_size += custom->size;
+  custom_cookie->offset = old_total_size;
+  ci->ci_total_size += custom_cookie->size;
 
   /* reallocate custom data blocks on used memory blocks*/
-  OLSR_FOR_ALL_USED_MEM(ci, mem, iterator) {
-    uint8_t *custom_ptr;
+  OLSR_FOR_ALL_USED_MEM(ci, mem, mem_iterator) {
+    uint8_t *new_custom;
 
-    custom_ptr = olsr_malloc(new_total_size, ci->ci_name);
+    new_custom = olsr_malloc(new_total_size, ci->ci_name);
 
     /* copy old data */
     if (old_total_size > 0) {
-      memcpy(custom_ptr, mem->custom, old_total_size);
+      memmove(new_custom, mem->custom, old_total_size);
     }
 
     mem->is_inline = false;
-    mem->custom = custom_ptr;
+    mem->custom = new_custom;
 
     /* call up necessary initialization */
-    init(ci, mem + 1, custom_ptr + old_total_size);
+    if (custom->init) {
+      custom->init(ci, mem + 1, new_custom + old_total_size);
+    }
+
+    /* inform the custom cookie managers that their memory has moved */
+    OLSR_FOR_ALL_CUSTOM_MEM(ci, custom, custom_iterator) {
+      if (custom->move) {
+        custom->move(ci, mem+1, new_custom + custom->offset);
+      }
+    }
   }
 
   /* remove all free data blocks, they have the wrong size */
-  OLSR_FOR_ALL_FREE_MEM(ci, mem, iterator) {
+  OLSR_FOR_ALL_FREE_MEM(ci, mem, mem_iterator) {
     list_remove(&mem->node);
     free(mem);
   }
   ci->ci_free_list_usage = 0;
 
   /* add the custom data object to the list */
-  list_add_tail(&ci->ci_custom_list, &custom->node);
-  return custom;
+  list_add_tail(&ci->ci_custom_list, &custom_cookie->node);
+  return custom_cookie;
 }
 
+/**
+ * Remove a custom addition to a memcookie
+ * @param memcookie_name name of memcookie
+ * @param custom pointer to custom memcookie
+ */
 void
-olsr_free_cookie_custom(struct olsr_cookie_info *ci, struct olsr_cookie_custom *custom) {
+olsr_memcookie_remove_custom(const char*memcookie_name, struct olsr_memcookie_custom *custom) {
+  struct olsr_memcookie_info *ci;
   struct olsr_memory_prefix *mem, *mem_iterator;
-  struct olsr_cookie_custom *c_ptr, *c_iterator;
+  struct olsr_memcookie_custom *c_ptr, *c_iterator;
   size_t prefix_block, suffix_block;
   bool match;
 
+  ci = avl_find_element(&olsr_cookie_tree, memcookie_name, ci, ci_node);
+  if (ci == NULL) {
+    OLSR_WARN(LOG_COOKIE, "Memory cookie '%s' does not exist, cannot remove custom block '%s'\n",
+        memcookie_name, custom->name);
+    return;
+  }
+
   prefix_block = 0;
   suffix_block = 0;
   match = false;
 
+  /* calculate size of (not) modified custom data block */
   OLSR_FOR_ALL_CUSTOM_MEM(ci, c_ptr, c_iterator) {
     if (c_ptr == custom) {
       match = true;
@@ -367,7 +418,6 @@ olsr_free_cookie_custom(struct olsr_cookie_info *ci, struct olsr_cookie_custom *
 
     if (match) {
       suffix_block += c_ptr->size;
-      c_ptr->offset -= custom->size;
     }
     else {
       prefix_block += c_ptr->size;
@@ -378,6 +428,23 @@ olsr_free_cookie_custom(struct olsr_cookie_info *ci, struct olsr_cookie_custom *
   if (suffix_block > 0) {
     OLSR_FOR_ALL_USED_MEM(ci, mem, mem_iterator) {
       memmove(mem->custom + prefix_block, mem->custom + prefix_block + custom->size, suffix_block);
+
+      /* recalculate offsets of moved blocks and inform callbacks */
+      OLSR_FOR_ALL_CUSTOM_MEM(ci, c_ptr, c_iterator) {
+        if (c_ptr == custom) {
+          match = true;
+          continue;
+        }
+
+        if (match) {
+          c_ptr->offset -= custom->size;
+
+          if (c_ptr->move) {
+            c_ptr->move(ci, mem+1, mem->custom + c_ptr->offset);
+          }
+        }
+      }
+
     }
   }
   ci->ci_total_size -= custom->size;
@@ -395,6 +462,7 @@ olsr_free_cookie_custom(struct olsr_cookie_info *ci, struct olsr_cookie_custom *
   free (custom);
 }
 
+
 /*
  * Local Variables:
  * c-basic-offset: 2
similarity index 64%
rename from src/olsr_cookie.h
rename to src/olsr_memcookie.h
index 4bdd582..08ab1db 100644 (file)
@@ -55,7 +55,7 @@ extern struct avl_tree EXPORT(olsr_cookie_tree);
  * It is used for tracking resource usage in the system and also
  * for locating memory corruption.
  */
-struct olsr_cookie_info {
+struct olsr_memcookie_info {
   struct avl_node ci_node;
   /* Name */
   char *ci_name;
@@ -95,19 +95,39 @@ struct olsr_cookie_info {
 };
 
 /* Custom addition to existing cookie */
-struct olsr_cookie_custom {
+struct olsr_memcookie_custom {
   struct list_entity node;
 
+  /* name of the custom extension */
   char *name;
 
+  /* padded (aligned) number of bytes allocated for the custom extension */
   size_t size;
+
+  /* offset in the memory array for the custom extensions */
   size_t offset;
 
-  void (*init)(struct olsr_cookie_info *, void *, void *);
-  void (*cleanup)(struct olsr_cookie_info *, void *, void *);
+  /**
+   * Called every times a new instance of memory is allocated
+   * @param ci pointer to memcookie_info
+   * @param ptr pointer to allocated memory
+   * @param c_ptr pointer to custom memory section
+   */
+  void (*init)(struct olsr_memcookie_info *ci, void *ptr, void *c_ptr);
+
+  /**
+   * Called every times the custom memory section is moved
+   *
+   * Content of the custom memory section will already have been copied.
+   *
+   * @param ci pointer to memcookie info
+   * @param ptr pointer to allocated memory
+   * @param c_ptr pointer to new position of the custom memory section
+   */
+  void (*move)(struct olsr_memcookie_info *ci, void *ptr, void *c_ptr);
 };
 
-/* should have a length of 2*memory_alignment */
+/* should have a length of 2*memory_alignment (4 pointers) */
 struct olsr_memory_prefix {
   struct list_entity node;
   uint8_t *custom;
@@ -123,29 +143,31 @@ struct olsr_memory_prefix {
 #define COOKIE_FREE_LIST_THRESHOLD 10   /* Blocks / Percent  */
 
 /* Externals. */
-void olsr_cookie_init(void);
-void olsr_cookie_cleanup(void);
-
-struct olsr_cookie_info *EXPORT(olsr_create_memcookie) (const char *, size_t size);
-void EXPORT(olsr_cleanup_memcookie)(struct olsr_cookie_info *);
+void olsr_memcookie_init(void);
+void olsr_memcookie_cleanup(void);
 
-void EXPORT(olsr_cookie_set_min_free)(struct olsr_cookie_info *, uint32_t);
+struct olsr_memcookie_info *EXPORT(olsr_memcookie_add) (const char *, size_t size);
+void EXPORT(olsr_memcookie_remove)(struct olsr_memcookie_info *);
 
-void *EXPORT(olsr_cookie_malloc) (struct olsr_cookie_info *);
-void EXPORT(olsr_cookie_free) (struct olsr_cookie_info *, void *);
+void *EXPORT(olsr_memcookie_malloc) (struct olsr_memcookie_info *);
+void EXPORT(olsr_memcookie_free) (struct olsr_memcookie_info *, void *);
 
-struct olsr_cookie_custom *EXPORT(olsr_alloc_cookie_custom)(
-    struct olsr_cookie_info *ci, size_t size, const char *name,
-    void (*init)(struct olsr_cookie_info *, void *, void *),
-    void (*cleanup)(struct olsr_cookie_info *, void *, void *));
+struct olsr_memcookie_custom *EXPORT(olsr_memcookie_add_custom)(
+    const char *memcookie_name, const char *name, size_t size,
+    void (*init)(struct olsr_memcookie_info *, void *, void *),
+    void (*move)(struct olsr_memcookie_info *, void *, void *));
 
-void EXPORT(olsr_free_cookie_custom)(
-    struct olsr_cookie_info *ci, struct olsr_cookie_custom *custom);
+void EXPORT(olsr_memcookie_remove_custom)(
+    const char *memcookie_name, struct olsr_memcookie_custom *custom);
 
-/* inline function to access memory of custom data */
-static inline void *EXPORT(olsr_cookie_get_custom)(
-    struct olsr_cookie_custom *custom,
-    void *ptr) {
+/**
+ * Get pointer to custom memory part of a cookie instance
+ * @param custom pointer to custom memcookie info
+ * @param ptr pointer to memory block
+ * @return pointer to custom memory block
+ */
+static inline void *
+olsr_memcookie_get_custom(struct olsr_memcookie_custom *custom, void *ptr) {
   struct olsr_memory_prefix *mem;
 
   /* get to the prefix memory structure */
@@ -155,6 +177,18 @@ static inline void *EXPORT(olsr_cookie_get_custom)(
   return mem->custom + custom->offset;
 }
 
+/**
+ * Set the minimum number of free allocated blocks for a memcookie that
+ * will be kept back by the cookie_manager
+ * @param ci
+ * @param min_free
+ */
+static inline void
+olsr_memcookie_set_minfree(struct olsr_memcookie_info *ci, uint32_t min_free)
+{
+  ci->ci_min_free_count = min_free;
+}
+
 #endif /* _OLSR_COOKIE_H */
 
 /*
index 4e1b349..394a986 100644 (file)
@@ -47,7 +47,7 @@
 #include "olsr_logging.h"
 #include "common/avl.h"
 #include "common/list.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 
 #include <dlfcn.h>
 #include <errno.h>
@@ -60,7 +60,7 @@ static struct olsr_plugin *olsr_load_legacy_plugin(const char *, void *);
 struct avl_tree plugin_tree;
 static bool plugin_tree_initialized = false;
 
-static struct olsr_cookie_info *plugin_mem_cookie = NULL;
+static struct olsr_memcookie_info *plugin_mem_cookie = NULL;
 
 static int olsr_internal_unload_plugin(struct olsr_plugin *plugin, bool cleanup);
 
@@ -88,7 +88,7 @@ olsr_hookup_plugin(struct olsr_plugin *pl_def) {
  */
 void
 olsr_init_pluginsystem(void) {
-  plugin_mem_cookie = olsr_create_memcookie("Plugin handle", sizeof(struct olsr_plugin));
+  plugin_mem_cookie = olsr_memcookie_add("Plugin handle", sizeof(struct olsr_plugin));
 
   /* could already be initialized */
   if (!plugin_tree_initialized) {
@@ -235,7 +235,7 @@ olsr_load_legacy_plugin(const char *libname, void *dlhandle) {
   OLSR_DEBUG(LOG_PLUGINS, "Got plugin %s, version: %d - OK\n", libname, plugin_interface_version);
 
   /* initialize plugin structure */
-  plugin = (struct olsr_plugin *)olsr_cookie_malloc(plugin_mem_cookie);
+  plugin = (struct olsr_plugin *)olsr_memcookie_malloc(plugin_mem_cookie);
   /* SOT: Hacked away the funny plugin check which fails if pathname is included */
   if (strrchr(libname, '/')) libname = strrchr(libname, '/') + 1;
   plugin->name = libname;
@@ -338,7 +338,7 @@ olsr_internal_unload_plugin(struct olsr_plugin *plugin, bool cleanup) {
    * modern plugins
    */
   if (legacy) {
-    olsr_cookie_free(plugin_mem_cookie, plugin);
+    olsr_memcookie_free(plugin_mem_cookie, plugin);
   }
   return false;
 }
index 04b1b86..4cd7a35 100644 (file)
@@ -56,8 +56,8 @@
 #include <assert.h>
 
 /* Cookies */
-struct olsr_cookie_info *rt_mem_cookie = NULL;
-struct olsr_cookie_info *rtp_mem_cookie = NULL; /* Maybe static */
+struct olsr_memcookie_info *rt_mem_cookie = NULL;
+struct olsr_memcookie_info *rtp_mem_cookie = NULL; /* Maybe static */
 
 /*
  * Sven-Ola: if the current internet gateway is switched, the
@@ -92,8 +92,8 @@ olsr_init_routing_table(void)
   /*
    * Get some cookies for memory stats and memory recycling.
    */
-  rt_mem_cookie = olsr_create_memcookie("rt_entry", sizeof(struct rt_entry));
-  rtp_mem_cookie = olsr_create_memcookie("rt_path", sizeof(struct rt_path));
+  rt_mem_cookie = olsr_memcookie_add("rt_entry", sizeof(struct rt_entry));
+  rtp_mem_cookie = olsr_memcookie_add("rt_path", sizeof(struct rt_path));
 }
 
 /**
@@ -149,7 +149,7 @@ olsr_update_rt_path(struct rt_path *rtp, struct tc_entry *tc, struct link_entry
 static struct rt_entry *
 olsr_alloc_rt_entry(struct olsr_ip_prefix *prefix)
 {
-  struct rt_entry *rt = olsr_cookie_malloc(rt_mem_cookie);
+  struct rt_entry *rt = olsr_memcookie_malloc(rt_mem_cookie);
   if (!rt) {
     return NULL;
   }
@@ -175,7 +175,7 @@ olsr_alloc_rt_entry(struct olsr_ip_prefix *prefix)
 static struct rt_path *
 olsr_alloc_rt_path(struct tc_entry *tc, struct olsr_ip_prefix *prefix, uint8_t origin)
 {
-  struct rt_path *rtp = olsr_cookie_malloc(rtp_mem_cookie);
+  struct rt_path *rtp = olsr_memcookie_malloc(rtp_mem_cookie);
 
   if (!rtp) {
     return NULL;
@@ -299,7 +299,7 @@ olsr_delete_rt_path(struct rt_path *rtp)
     current_inetgw = NULL;
   }
 
-  olsr_cookie_free(rtp_mem_cookie, rtp);
+  olsr_memcookie_free(rtp_mem_cookie, rtp);
 }
 
 /**
index 0ee40bd..6bf6330 100644 (file)
@@ -48,7 +48,7 @@
 #include <net/route.h>
 #include "hna_set.h"
 #include "link_set.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "common/avl.h"
 #include "common/list.h"
 
@@ -159,7 +159,7 @@ union olsr_kernel_route {
 
 extern struct avl_tree EXPORT(routingtree);
 extern unsigned int routingtree_version;
-extern struct olsr_cookie_info *rt_mem_cookie;
+extern struct olsr_memcookie_info *rt_mem_cookie;
 
 void olsr_init_routing_table(void);
 
index 762a385..566165f 100644 (file)
@@ -48,7 +48,7 @@
 #include "scheduler.h"
 #include "link_set.h"
 #include "olsr.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "os_net.h"
 #include "os_time.h"
 #include "olsr_logging.h"
@@ -64,8 +64,8 @@ static uint32_t timer_last_run;        /* remember the last timeslot walk */
 
 /* 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_cookie = NULL;
+static struct olsr_memcookie_info *timer_mem_cookie = NULL;
+static struct olsr_memcookie_info *timerinfo_cookie = NULL;
 
 /* Head of all OLSR used sockets */
 static struct list_entity socket_head;
@@ -166,7 +166,7 @@ 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_cookie);
+  ti = olsr_memcookie_malloc(timerinfo_cookie);
   ti->name = strdup(name);
   ti->node.key = ti->name;
   ti->callback = callback;
@@ -565,10 +565,10 @@ olsr_init_timers(void)
   timer_last_run = now_times;
 
   /* Allocate a cookie for the block based memory manager. */
-  timer_mem_cookie = olsr_create_memcookie("timer_entry", sizeof(struct timer_entry));
+  timer_mem_cookie = olsr_memcookie_add("timer_entry", sizeof(struct timer_entry));
 
   avl_init(&timerinfo_tree, avl_comp_strcasecmp, false, NULL);
-  timerinfo_cookie = olsr_create_memcookie("timerinfo", sizeof(struct olsr_timer_info));
+  timerinfo_cookie = olsr_memcookie_add("timerinfo", sizeof(struct olsr_timer_info));
 }
 
 /**
@@ -645,7 +645,7 @@ walk_timers(uint32_t * last_run)
         }
         else {
           /* free memory */
-          olsr_cookie_free(timer_mem_cookie, timer);
+          olsr_memcookie_free(timer_mem_cookie, timer);
         }
 
         timers_fired++;
@@ -704,11 +704,11 @@ olsr_flush_timers(void)
   OLSR_FOR_ALL_TIMERS(ti, iterator) {
     avl_delete(&timerinfo_tree, &ti->node);
     free(ti->name);
-    olsr_cookie_free(timerinfo_cookie, ti);
+    olsr_memcookie_free(timerinfo_cookie, ti);
   }
 
   /* release memory cookie for timers */
-  olsr_cleanup_memcookie(timerinfo_cookie);
+  olsr_memcookie_remove(timerinfo_cookie);
 }
 
 /**
@@ -810,7 +810,7 @@ olsr_start_timer(unsigned int rel_time,
   assert(rel_time);
   assert(jitter_pct <= 100);
 
-  timer = olsr_cookie_malloc(timer_mem_cookie);
+  timer = olsr_memcookie_malloc(timer_mem_cookie);
 
   /*
    * Compute random numbers only once.
@@ -875,7 +875,7 @@ olsr_stop_timer(struct timer_entry *timer)
   timer->timer_info->changes++;
 
   if (!timer->timer_in_callback) {
-    olsr_cookie_free(timer_mem_cookie, timer);
+    olsr_memcookie_free(timer_mem_cookie, timer);
   }
 }
 
index 531f99b..bc2360c 100644 (file)
@@ -58,7 +58,7 @@ struct avl_tree tc_tree;
 struct tc_entry *tc_myself = NULL;     /* Shortcut to ourselves */
 
 /* Some cookies for stats keeping */
-struct olsr_cookie_info *tc_mem_cookie = NULL;
+struct olsr_memcookie_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;
 
@@ -92,7 +92,7 @@ olsr_add_tc_entry(const union olsr_ip_addr *adr)
 
   OLSR_DEBUG(LOG_TC, "TC: add entry %s\n", olsr_ip_to_string(&buf, adr));
 
-  tc = olsr_cookie_malloc(tc_mem_cookie);
+  tc = olsr_memcookie_malloc(tc_mem_cookie);
   if (!tc) {
     return NULL;
   }
@@ -142,7 +142,7 @@ olsr_init_tc(void)
   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_create_memcookie("tc_entry", sizeof(struct tc_entry));
+  tc_mem_cookie = olsr_memcookie_add("tc_entry", sizeof(struct tc_entry));
 }
 
 /**
@@ -254,7 +254,7 @@ olsr_delete_tc_entry(struct tc_entry *tc)
   olsr_flush_hna_nets(tc);
 
   avl_delete(&tc_tree, &tc->vertex_node);
-  olsr_cookie_free(tc_mem_cookie, tc);
+  olsr_memcookie_free(tc_mem_cookie, tc);
 }
 
 /**
index 664e5b3..889b694 100644 (file)
@@ -47,7 +47,7 @@
 #include "olsr_protocol.h"
 #include "lq_packet.h"
 #include "scheduler.h"
-#include "olsr_cookie.h"
+#include "olsr_memcookie.h"
 #include "duplicate_set.h"
 
 /*
@@ -114,7 +114,7 @@ struct tc_entry {
 extern struct avl_tree EXPORT(tc_tree);
 extern struct tc_entry *tc_myself;
 
-extern struct olsr_cookie_info *EXPORT(tc_mem_cookie);
+extern struct olsr_memcookie_info *EXPORT(tc_mem_cookie);
 
 void olsr_init_tc(void);
 void olsr_change_myself_tc(void);