Cleanup memory cookie manager
authorHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Wed, 29 Feb 2012 07:36:48 +0000 (08:36 +0100)
committerHenning Rogge <henning.rogge@fkie.fraunhofer.de>
Wed, 29 Feb 2012 07:36:48 +0000 (08:36 +0100)
lib/remotecontrol/src/remotecontrol.c
src/core/olsr_memcookie.c
src/core/olsr_memcookie.h
src/core/olsr_stream_socket.c
src/core/olsr_stream_socket.h
src/core/olsr_telnet.c
src/core/olsr_telnet.h
src/core/olsr_timer.c
src/core/olsr_timer.h
src/olsr_main.c

index e21cdc3..56e8241 100644 (file)
@@ -286,8 +286,13 @@ _print_memory(struct autobuf *buf) {
   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",
-        c->ci_name, (unsigned long)c->ci_size, c->ci_usage, c->ci_free_list_usage) < 0) {
+    if (abuf_appendf(buf, "%-25s (MEMORY) size: "PRINTF_SIZE_T_SPECIFIER
+        " usage: %u freelist: %u allocations: %u/%u\n",
+        c->name, c->size,
+        olsr_memcookie_get_usage(c),
+        olsr_memcookie_get_free(c),
+        olsr_memcookie_get_allocations(c),
+        olsr_memcookie_get_recycled(c)) < 0) {
       return -1;
     }
   }
index 6ef9e70..b8f384c 100644 (file)
  */
 
 #include <assert.h>
-#include <errno.h>
 #include <stdlib.h>
-#include <string.h>
 
 #include "common/list.h"
-#include "common/avl.h"
-#include "common/avl_comp.h"
 #include "olsr_memcookie.h"
 #include "olsr_logging.h"
 #include "olsr.h"
 
-struct avl_tree olsr_cookie_tree;
+struct list_entity olsr_cookies;
 
 /* remember if initialized or not */
-OLSR_SUBSYSTEM_STATE(olsr_memcookie_state);
-
-/**
- * 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;
-}
-
-/**
- * Increment usage state for a given cookie.
- * @param ci pointer to memcookie info
- */
-static inline void
-_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
-_usage_decr(struct olsr_memcookie_info *ci)
-{
-  ci->ci_usage--;
-  ci->ci_changes++;
-}
+OLSR_SUBSYSTEM_STATE(_memcookie_state);
 
 /**
  * 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)));
-
-  if (olsr_subsystem_init(&olsr_memcookie_state))
+  if (olsr_subsystem_init(&_memcookie_state))
     return;
 
-  avl_init(&olsr_cookie_tree, &avl_comp_strcasecmp, false, NULL);
+  list_init_head(&olsr_cookies);
 }
 
 /**
@@ -114,7 +71,7 @@ olsr_memcookie_cleanup(void)
 {
   struct olsr_memcookie_info *info, *iterator;
 
-  if (olsr_subsystem_cleanup(&olsr_memcookie_state))
+  if (olsr_subsystem_cleanup(&_memcookie_state))
     return;
 
   /*
@@ -127,70 +84,39 @@ olsr_memcookie_cleanup(void)
 
 /**
  * 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
+ * @param ci initialized memcookie
  */
-struct olsr_memcookie_info *
-olsr_memcookie_add(const char *cookie_name, size_t size)
+void
+olsr_memcookie_add(struct olsr_memcookie_info *ci)
 {
-  struct olsr_memcookie_info *ci;
-
-  assert (cookie_name);
-  ci = calloc(sizeof(struct olsr_memcookie_info), 1);
-  if (ci == NULL) {
-    return NULL;
-  }
-
-  /* Now populate the cookie info */
-  ci->ci_name = cookie_name;
-  ci->ci_node.key = ci->ci_name;
-  ci->ci_size = size;
-  ci->ci_custom_offset = sizeof(struct olsr_memory_prefix) + _calc_aligned_size(size);
-  ci->ci_min_free_count = COOKIE_FREE_LIST_THRESHOLD;
-
-  /* no custom data at this point */
-  ci->ci_total_size = ci->ci_custom_offset;
+  assert (ci->name);
+  assert (ci->size > 0);
 
   /* Init the free list */
-  list_init_head(&ci->ci_free_list);
-  list_init_head(&ci->ci_used_list);
-  list_init_head(&ci->ci_custom_list);
+  list_init_head(&ci->_free_list);
 
-  avl_insert(&olsr_cookie_tree, &ci->ci_node);
-  return ci;
+  list_add_tail(&olsr_cookies, &ci->_node);
 }
 
 /**
- * Delete a memcookie and all attached memory
+ * Delete a memcookie and all memory in the free list
  * @param ci pointer to memcookie
  */
 void
 olsr_memcookie_remove(struct olsr_memcookie_info *ci)
 {
-  struct olsr_memory_prefix *memory_entity, *iterator;
-
-  /* remove from tree */
-  avl_remove(&olsr_cookie_tree, &ci->ci_node);
+  struct list_entity *item;
 
-  /* Flush all the memory on the free list */
-  /*
-   * First make all items accessible,
-   * such that valgrind does not complain at shutdown.
-   */
+  /* remove memcookie from tree */
+  list_remove(&ci->_node);
 
   /* remove all free memory blocks */
-  OLSR_FOR_ALL_FREE_MEM(ci, memory_entity, iterator) {
-    free(memory_entity);
-  }
+  while (!list_is_empty(&ci->_free_list)) {
+    item = ci->_free_list.next;
 
-  /* free all used memory blocks */
-  OLSR_FOR_ALL_USED_MEM(ci, memory_entity, iterator) {
-    free(memory_entity->custom);
-    free(memory_entity);
+    list_remove(item);
+    free(item);
   }
-
-  free(ci);
 }
 
 /**
@@ -201,8 +127,8 @@ olsr_memcookie_remove(struct olsr_memcookie_info *ci)
 void *
 olsr_memcookie_malloc(struct olsr_memcookie_info *ci)
 {
-  struct olsr_memory_prefix *mem;
-  struct olsr_memcookie_custom *custom, *iterator;
+  struct list_entity *entity;
+  void *ptr;
 
 #if !defined REMOVE_LOG_DEBUG
   bool reuse = false;
@@ -211,52 +137,39 @@ olsr_memcookie_malloc(struct olsr_memcookie_info *ci)
   /*
    * Check first if we have reusable memory.
    */
-  if (list_is_empty(&ci->ci_free_list)) {
+  if (list_is_empty(&ci->_free_list)) {
     /*
      * No reusable memory block on the free_list.
      * Allocate a fresh one.
      */
-    mem = calloc(ci->ci_total_size, 1);
-    if (mem == NULL) {
+    ptr = calloc(1, ci->size);
+    if (ptr == NULL) {
       return NULL;
     }
+    ci->_allocated++;
   } else {
     /*
      * There is a memory block on the free list.
      * Carve it out of the list, and clean.
      */
-    mem = list_first_element(&ci->ci_free_list, mem, node);
-    list_remove(&mem->node);
+    entity = ci->_free_list.next;
+    list_remove(entity);
 
-    memset(mem, 0, ci->ci_total_size);
+    memset(entity, 0, ci->size);
 
-    ci->ci_free_list_usage--;
+    ci->_free_list_size--;
+    ci->_recycled++;
 #if !defined REMOVE_LOG_DEBUG
     reuse = true;
 #endif
   }
 
-  /* add to used list */
-  list_add_tail(&ci->ci_used_list, &mem->node);
-
-  /* handle custom initialization */
-  if (!list_is_empty(&ci->ci_custom_list)) {
-    mem->custom = ((uint8_t *)mem) + ci->ci_custom_offset;
-
-    /* call up custom init functions */
-    OLSR_FOR_ALL_CUSTOM_MEM(ci, custom, iterator) {
-      if (custom->init) {
-        custom->init(ci, mem + 1, mem->custom + custom->offset);
-      }
-    }
-  }
-
   /* Stats keeping */
-  _usage_incr(ci);
+  ci->_current_usage++;
 
-  OLSR_DEBUG(LOG_MEMCOOKIE, "MEMORY: alloc %s, %p, %lu bytes%s\n",
-             ci->ci_name, mem + 1, (unsigned long)ci->ci_size, reuse ? ", reuse" : "");
-  return mem + 1;
+  OLSR_DEBUG(LOG_MEMCOOKIE, "MEMORY: alloc %s, " PRINTF_SIZE_T_SPECIFIER " bytes%s\n",
+             ci->name, ci->size, reuse ? ", reuse" : "");
+  return ptr;
 }
 
 /**
@@ -267,217 +180,35 @@ olsr_memcookie_malloc(struct olsr_memcookie_info *ci)
 void
 olsr_memcookie_free(struct olsr_memcookie_info *ci, void *ptr)
 {
-  struct olsr_memory_prefix *mem;
+  struct list_entity *item;
 #if !defined REMOVE_LOG_DEBUG
   bool reuse = false;
 #endif
 
-  /* calculate pointer to memory prefix */
-  mem = ptr;
-  mem--;
-
-  /* remove from used_memory list */
-  list_remove(&mem->node);
-
   /*
    * 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 (mem->is_inline && ((ci->ci_free_list_usage < ci->ci_min_free_count)
-      || (ci->ci_free_list_usage < ci->ci_usage / COOKIE_FREE_LIST_THRESHOLD))) {
+  if (ci->_free_list_size < ci->min_free_count
+      || (ci->_free_list_size < ci->_current_usage / COOKIE_FREE_LIST_THRESHOLD)) {
+    item = ptr;
 
-    list_add_tail(&ci->ci_free_list, &mem->node);
+    list_add_tail(&ci->_free_list, item);
 
-    ci->ci_free_list_usage++;
+    ci->_free_list_size++;
 #if !defined REMOVE_LOG_DEBUG
     reuse = true;
 #endif
   } else {
 
     /* No interest in reusing memory. */
-    if (!mem->is_inline) {
-      free (mem->custom);
-    }
-    free(mem);
+    free(ptr);
   }
 
   /* Stats keeping */
-  _usage_decr(ci);
-
-  OLSR_DEBUG(LOG_MEMCOOKIE, "MEMORY: free %s, %p, %lu bytes%s\n",
-             ci->ci_name, ptr, (unsigned long)ci->ci_total_size, reuse ? ", reuse" : "");
-}
-
-/**
- * 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 = NULL, *custom_iterator;
-  struct olsr_memory_prefix *mem, *mem_iterator;
-  size_t old_total_size, new_total_size;
-
-  ci = avl_find_element(&olsr_cookie_tree, memcookie_name, ci, ci_node);
-  if (ci == NULL) {
-    OLSR_WARN(LOG_MEMCOOKIE, "Memory cookie '%s' does not exist, cannot add custom block '%s'\n",
-        memcookie_name, name);
-    return NULL;
-  }
-
-  custom_cookie = calloc(sizeof(struct olsr_memcookie_custom), 1);
-  if (custom_cookie == NULL) {
-    return NULL;
-  }
-  custom_cookie->name = 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_cookie->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, mem_iterator) {
-    uint8_t *new_custom;
-
-    new_custom = calloc(new_total_size, 1);
-    if (new_custom == NULL) {
-      OLSR_WARN_OOM(LOG_MEMCOOKIE);
-      return NULL;
-    }
-
-    /* copy old data */
-    if (old_total_size > 0) {
-      memmove(new_custom, mem->custom, old_total_size);
-    }
-
-    mem->is_inline = false;
-    mem->custom = new_custom;
-
-    /* call up necessary initialization */
-    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, 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_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_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_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_MEMCOOKIE, "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;
-      continue;
-    }
-
-    if (match) {
-      suffix_block += c_ptr->size;
-    }
-    else {
-      prefix_block += c_ptr->size;
-    }
-  }
-
-  /* move the custom memory back into a continous block */
-  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;
-
-  /* remove all free data blocks, they have the wrong size */
-  OLSR_FOR_ALL_FREE_MEM(ci, mem, mem_iterator) {
-    list_remove(&mem->node);
-    free(mem);
-  }
-  ci->ci_free_list_usage = 0;
+  ci->_current_usage--;
 
-  /* remove the custom data object from the list */
-  list_remove(&custom->node);
-  free (custom);
+  OLSR_DEBUG(LOG_MEMCOOKIE, "MEMORY: free %s, "PRINTF_SIZE_T_SPECIFIER" bytes%s\n",
+             ci->name, ci->size, reuse ? ", reuse" : "");
 }
index af3c0ab..8732e7b 100644 (file)
  * for locating memory corruption.
  */
 struct olsr_memcookie_info {
-  struct avl_node ci_node;
-  /* Name */
-  const char *ci_name;
+  struct list_entity _node;
 
-  /* Size of memory blocks */
-  size_t ci_size;
-
-  /* size including prefix and custom data */
-  size_t ci_total_size;
+  /* Name of cookie */
+  const char *name;
 
-  /* offset from the inline custom data block */
-  size_t ci_custom_offset;
+  /* Size of memory blocks */
+  size_t size;
 
   /*
    * minimum number of chunks the allocator will keep
    * in the free list before starting to deallocate one
    */
-  uint32_t ci_min_free_count;
-
-  /* Stats, resource usage */
-  uint32_t ci_usage;
-
-  /* Stats, resource churn */
-  uint32_t ci_changes;
+  uint32_t min_free_count;
 
-  /* list of custom additions of this memory cookie */
-  struct list_entity ci_custom_list;
-
-  /* List head for used memory blocks */
-  struct list_entity ci_used_list;
+  /** Statistics and internal bookkeeping */
 
   /* List head for recyclable blocks */
-  struct list_entity ci_free_list;
+  struct list_entity _free_list;
 
   /* Length of free list */
-  uint32_t ci_free_list_usage;
-};
-
-/* Custom addition to existing cookie */
-struct olsr_memcookie_custom {
-  struct list_entity node;
-
-  /* name of the custom extension */
-  const char *name;
-
-  /* padded (aligned) number of bytes allocated for the custom extension */
-  size_t size;
+  uint32_t _free_list_size;
 
-  /* offset in the memory array for the custom extensions */
-  size_t offset;
-
-  /**
-   * 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);
-};
+  /* Stats, resource usage */
+  uint32_t _current_usage;
 
-/* should have a length of 2*memory_alignment (4 pointers) */
-struct olsr_memory_prefix {
-  struct list_entity node;
-  uint8_t *custom;
-  uint8_t is_inline;
-  uint8_t padding[sizeof(size_t) - sizeof(uint8_t)];
+  /* Stats, allocated/recycled memory blocks */
+  uint32_t _allocated, _recycled;
 };
 
-#define OLSR_FOR_ALL_COOKIES(ci, iterator) avl_for_each_element_safe(&olsr_cookie_tree, ci, ci_node, iterator)
-#define OLSR_FOR_ALL_USED_MEM(ci, mem, iterator) list_for_each_element_safe(&ci->ci_used_list, mem, node, iterator)
-#define OLSR_FOR_ALL_FREE_MEM(ci, mem, iterator) list_for_each_element_safe(&ci->ci_free_list, mem, node, iterator)
-#define OLSR_FOR_ALL_CUSTOM_MEM(ci, custom, iterator) list_for_each_element_safe(&ci->ci_custom_list, custom, node, iterator)
+#define OLSR_FOR_ALL_COOKIES(ci, iterator) list_for_each_element_safe(&olsr_cookies, ci, _node, iterator)
 
+/* percentage of blocks kept in the free list compared to allocated blocks */
 #define COOKIE_FREE_LIST_THRESHOLD 10   /* Blocks / Percent  */
 
-extern struct avl_tree EXPORT(olsr_cookie_tree);
+extern struct list_entity EXPORT(olsr_cookies);
 
 /* Externals. */
 EXPORT void olsr_memcookie_init(void);
 EXPORT void olsr_memcookie_cleanup(void);
 
-EXPORT struct olsr_memcookie_info *olsr_memcookie_add(const char *, size_t size)
-    __attribute__((warn_unused_result));
+EXPORT void olsr_memcookie_add(struct olsr_memcookie_info *);
 EXPORT void olsr_memcookie_remove(struct olsr_memcookie_info *);
 
 EXPORT void *olsr_memcookie_malloc(struct olsr_memcookie_info *)
     __attribute__((warn_unused_result));
 EXPORT void olsr_memcookie_free(struct olsr_memcookie_info *, void *);
 
-EXPORT 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 *))
-    __attribute__((warn_unused_result));;
-
-EXPORT void olsr_memcookie_remove_custom(
-    const char *memcookie_name, struct olsr_memcookie_custom *custom);
-
 /**
- * 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
+ * @param ci pointer to memcookie info
+ * @return number of blocks currently in use
  */
-static inline void *
-olsr_memcookie_get_custom(struct olsr_memcookie_custom *custom, void *ptr) {
-  struct olsr_memory_prefix *mem;
+static INLINE uint32_t
+olsr_memcookie_get_usage(struct olsr_memcookie_info *ci) {
+  return ci->_current_usage;
+}
 
-  /* get to the prefix memory structure */
-  mem = ptr;
-  mem--;
+/**
+ * @param ci pointer to memcookie info
+ * @return number of blocks currently in free list
+ */
+static INLINE uint32_t
+olsr_memcookie_get_free(struct olsr_memcookie_info *ci) {
+  return ci->_free_list_size;
+}
 
-  return mem->custom + custom->offset;
+/**
+ * @param ci pointer to memcookie info
+ * @return total number of allocations during runtime
+ */
+static INLINE uint32_t
+olsr_memcookie_get_allocations(struct olsr_memcookie_info *ci) {
+  return ci->_allocated;
 }
 
 /**
- * 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
+ * @param ci pointer to memcookie info
+ * @return total number of allocations during runtime
  */
-static inline void
-olsr_memcookie_set_minfree(struct olsr_memcookie_info *ci, uint32_t min_free)
-{
-  ci->ci_min_free_count = min_free;
+static INLINE uint32_t
+olsr_memcookie_get_recycled(struct olsr_memcookie_info *ci) {
+  return ci->_recycled;
 }
 
 #endif /* _OLSR_MEMCOOKIE_H */
index 7d9d6eb..fbc90fa 100644 (file)
@@ -72,7 +72,11 @@ static void _cb_timeout_handler(void *);
 struct list_entity olsr_stream_head;
 
 /* server socket */
-static struct olsr_memcookie_info *connection_cookie;
+static struct olsr_memcookie_info connection_cookie = {
+  .name = "stream socket connection",
+  .size = sizeof(struct olsr_stream_session)
+};
+
 static struct olsr_timer_info connection_timeout = {
   .name = "stream socket timout",
   .callback = _cb_timeout_handler,
@@ -83,25 +87,15 @@ OLSR_SUBSYSTEM_STATE(_stream_state);
 
 /**
  * Initialize the stream socket handlers
- * @return -1 if an error happened, 0 otherwise.
  */
-int
+void
 olsr_stream_init(void) {
-  if (olsr_subsystem_is_initialized(&_stream_state))
-    return 0;
-
-  connection_cookie = olsr_memcookie_add("stream socket connections",
-      sizeof(struct olsr_stream_session));
-  if (connection_cookie == NULL) {
-    OLSR_WARN_OOM(LOG_SOCKET_STREAM);
-    return -1;
-  }
+  if (olsr_subsystem_init(&_stream_state))
+    return;
 
+  olsr_memcookie_add(&connection_cookie);
   olsr_timer_add(&connection_timeout);
-
   list_init_head(&olsr_stream_head);
-  olsr_subsystem_init(&_stream_state);
-  return 0;
 }
 
 /**
@@ -120,7 +114,7 @@ olsr_stream_cleanup(void) {
     olsr_stream_remove(comport, true);
   }
 
-  olsr_memcookie_remove(connection_cookie);
+  olsr_memcookie_remove(&connection_cookie);
   olsr_timer_remove(&connection_timeout);
 }
 
@@ -175,7 +169,7 @@ olsr_stream_add(struct olsr_stream_socket *stream_socket,
   memcpy(&stream_socket->local_socket, local, sizeof(stream_socket->local_socket));
 
   if (stream_socket->config.memcookie == NULL) {
-    stream_socket->config.memcookie = connection_cookie;
+    stream_socket->config.memcookie = &connection_cookie;
   }
   if (stream_socket->config.allowed_sessions == 0) {
     stream_socket->config.allowed_sessions = 10;
@@ -427,7 +421,7 @@ _apply_managed_socket(struct olsr_stream_managed *managed,
   /* copy configuration */
   memcpy(&stream->config, &managed->config, sizeof(stream->config));
   if (stream->config.memcookie == NULL) {
-    stream->config.memcookie = connection_cookie;
+    stream->config.memcookie = &connection_cookie;
   }
   return 0;
 }
index 181bd43..f9ed614 100644 (file)
@@ -191,7 +191,7 @@ struct olsr_stream_managed_config {
   uint16_t port;
 };
 
-EXPORT int olsr_stream_init(void) __attribute__((warn_unused_result));
+EXPORT void olsr_stream_init(void);
 EXPORT void olsr_stream_cleanup(void);
 
 EXPORT int olsr_stream_add(struct olsr_stream_socket *,
index b0bf488..c9816ee 100644 (file)
@@ -86,8 +86,11 @@ static struct olsr_telnet_command _builtin[] = {
 OLSR_SUBSYSTEM_STATE(_telnet_state);
 
 /* telnet session handling */
-static struct olsr_memcookie_info *_telnet_memcookie;
 static struct olsr_stream_managed _telnet_managed;
+static struct olsr_memcookie_info _telnet_memcookie = {
+  .name = "telnet session",
+  .size = sizeof(struct olsr_telnet_session),
+};
 static struct olsr_timer_info _telnet_repeat_timerinfo = {
   .name = "txt repeat timer",
   .callback = _cb_telnet_repeat_timer,
@@ -98,21 +101,15 @@ struct avl_tree telnet_cmd_tree;
 
 /**
  * Initialize telnet subsystem
- * @return 0 if initialized successfully, -1 otherwise
  */
-int
+void
 olsr_telnet_init(void) {
   size_t i;
 
-  if (olsr_subsystem_is_initialized(&_telnet_state))
-    return 0;
-
-  _telnet_memcookie = olsr_memcookie_add("telnet session",
-      sizeof(struct olsr_telnet_session));
-  if (_telnet_memcookie == NULL) {
-    return -1;
-  }
+  if (olsr_subsystem_init(&_telnet_state))
+    return;
 
+  olsr_memcookie_add(&_telnet_memcookie);
   olsr_timer_add(&_telnet_repeat_timerinfo );
 
   cfg_schema_add_section(olsr_cfg_get_schema(), &telnet_section,
@@ -122,7 +119,7 @@ olsr_telnet_init(void) {
   _telnet_managed.config.session_timeout = 120000; /* 120 seconds */
   _telnet_managed.config.maximum_input_buffer = 4096;
   _telnet_managed.config.allowed_sessions = 3;
-  _telnet_managed.config.memcookie = _telnet_memcookie;
+  _telnet_managed.config.memcookie = &_telnet_memcookie;
   _telnet_managed.config.init = _cb_telnet_init;
   _telnet_managed.config.cleanup = _cb_telnet_cleanup;
   _telnet_managed.config.receive_data = _cb_telnet_receive_data;
@@ -133,9 +130,6 @@ olsr_telnet_init(void) {
   for (i=0; i<ARRAYSIZE(_builtin); i++) {
     olsr_telnet_add(&_builtin[i]);
   }
-
-  olsr_subsystem_init(&_telnet_state);
-  return 0;
 }
 
 /**
@@ -148,7 +142,7 @@ olsr_telnet_cleanup(void) {
 
   olsr_stream_remove_managed(&_telnet_managed, true);
   cfg_schema_remove_section(olsr_cfg_get_schema(), &telnet_section);
-  olsr_memcookie_remove(_telnet_memcookie);
+  olsr_memcookie_remove(&_telnet_memcookie);
 }
 
 /**
index a1a3ff9..e7eb728 100644 (file)
@@ -88,7 +88,7 @@ struct olsr_telnet_command {
 #define FOR_ALL_TELNET_COMMANDS(cmd, ptr) avl_for_each_element_safe(&telnet_cmd_tree, cmd, node, ptr)
 EXPORT struct avl_tree telnet_cmd_tree;
 
-EXPORT int olsr_telnet_init(void) __attribute__((warn_unused_result));
+EXPORT void olsr_telnet_init(void);
 EXPORT void olsr_telnet_cleanup(void);
 
 EXPORT int olsr_telnet_add(struct olsr_telnet_command *command);
index 6aff306..663eba8 100644 (file)
@@ -58,7 +58,10 @@ static uint64_t _timer_last_run;        /* remember the last timeslot walk */
 
 /* Memory cookie for the timer manager */
 struct list_entity timerinfo_list;
-static struct olsr_memcookie_info *_timer_mem_cookie = NULL;
+static struct olsr_memcookie_info _timer_mem_cookie = {
+  .name = "timer entry",
+  .size = sizeof(struct olsr_timer_entry),
+};
 
 /* remember if initialized or not */
 OLSR_SUBSYSTEM_STATE(_timer_state);
@@ -70,13 +73,13 @@ static uint64_t calc_jitter(uint64_t rel_time, uint8_t jitter_pct, unsigned int
  * Initialize timer scheduler subsystem
  * @return -1 if an error happened, 0 otherwise
  */
-int
+void
 olsr_timer_init(void)
 {
   int idx;
 
-  if (olsr_subsystem_is_initialized(&_timer_state))
-    return 0;
+  if (olsr_subsystem_init(&_timer_state))
+    return;
 
   OLSR_INFO(LOG_SOCKET, "Initializing scheduler.\n");
 
@@ -90,17 +93,10 @@ olsr_timer_init(void)
    */
   _timer_last_run = olsr_clock_getNow();
 
-  /* Allocate a cookie for the block based memory manager. */
-  _timer_mem_cookie = olsr_memcookie_add("timer_entry", sizeof(struct olsr_timer_entry));
-  if (_timer_mem_cookie == NULL) {
-    OLSR_WARN_OOM(LOG_SOCKET);
-    return -1;
-  }
+  /* initialize a cookie for the block based memory manager. */
+  olsr_memcookie_add(&_timer_mem_cookie);
 
   list_init_head(&timerinfo_list);
-
-  olsr_subsystem_init(&_timer_state);
-  return 0;
 }
 
 /**
@@ -134,7 +130,7 @@ olsr_timer_cleanup(void)
   }
 
   /* release memory cookie for timers */
-  olsr_memcookie_remove(_timer_mem_cookie);
+  olsr_memcookie_remove(&_timer_mem_cookie);
 }
 
 /**
@@ -189,7 +185,7 @@ olsr_timer_start(uint64_t rel_time,
   assert(rel_time);
   assert(jitter_pct <= 100);
 
-  timer = olsr_memcookie_malloc(_timer_mem_cookie);
+  timer = olsr_memcookie_malloc(&_timer_mem_cookie);
 
   /*
    * Compute random numbers only once.
@@ -251,7 +247,7 @@ olsr_timer_stop(struct olsr_timer_entry *timer)
   timer->timer_info->changes++;
 
   if (!timer->timer_in_callback) {
-    olsr_memcookie_free(_timer_mem_cookie, timer);
+    olsr_memcookie_free(&_timer_mem_cookie, timer);
   }
 }
 
@@ -331,7 +327,7 @@ olsr_timer_set(struct olsr_timer_entry **timer_ptr,
 void
 olsr_timer_walk(void)
 {
-  int total_timers_walked = 0, total_timers_fired = 0;
+  int timers_walked = 0, timers_fired = 0;
   int wheel_slot_walks = 0;
 
   /*
@@ -341,8 +337,6 @@ olsr_timer_walk(void)
    */
   while ((_timer_last_run <= olsr_clock_getNow()) && (wheel_slot_walks < TIMER_WHEEL_SLOTS)) {
     struct list_entity tmp_head_node;
-    /* keep some statistics */
-    unsigned int timers_walked = 0, timers_fired = 0;
 
     /* Get the hash slot for this clocktick */
     struct list_entity *timer_head_node;
@@ -398,7 +392,7 @@ olsr_timer_walk(void)
         }
         else {
           /* free memory */
-          olsr_memcookie_free(_timer_mem_cookie, timer);
+          olsr_memcookie_free(&_timer_mem_cookie, timer);
         }
 
         timers_fired++;
@@ -410,18 +404,15 @@ olsr_timer_walk(void)
      */
     list_merge(timer_head_node, &tmp_head_node);
 
-    /* keep some statistics */
-    total_timers_walked += timers_walked;
-    total_timers_fired += timers_fired;
-
     /* Increment the time slot and wheel slot walk iteration */
     _timer_last_run++;
     wheel_slot_walks++;
   }
 
   OLSR_DEBUG(LOG_TIMER, "TIMER: processed %4u/%d clockwheel slots, "
-             "timers walked %4u/%u, timers fired %u\n",
-             wheel_slot_walks, TIMER_WHEEL_SLOTS, total_timers_walked, _timer_mem_cookie->ci_usage, total_timers_fired);
+             "timers walked %u, timers fired %u\n",
+             wheel_slot_walks, TIMER_WHEEL_SLOTS,
+             timers_walked, timers_fired);
 
   /*
    * If the scheduler has slipped and we have walked all wheel slots,
index fdc1534..ab51c50 100644 (file)
@@ -117,7 +117,7 @@ struct olsr_timer_entry {
 EXPORT extern struct list_entity timerinfo_list;
 #define OLSR_FOR_ALL_TIMERS(ti, iterator) list_for_each_element_safe(&timerinfo_list, ti, node, iterator)
 
-EXPORT int olsr_timer_init(void) __attribute__((warn_unused_result));
+EXPORT void olsr_timer_init(void);
 EXPORT void olsr_timer_cleanup(void);
 EXPORT void olsr_timer_walk(void);
 
index 49f446f..ffcccb8 100644 (file)
@@ -231,14 +231,10 @@ main(int argc, char **argv) {
   if (olsr_clock_init()) {
     goto olsrd_cleanup;
   }
-  if (olsr_timer_init()) {
-    goto olsrd_cleanup;
-  }
+  olsr_timer_init();
   olsr_socket_init();
   olsr_packet_init();
-  if (olsr_stream_init()) {
-    goto olsrd_cleanup;
-  }
+  olsr_stream_init();
 
   /* activate os-specific code */
   if (os_system_init()) {
@@ -261,9 +257,7 @@ main(int argc, char **argv) {
   }
 
   /* activate telnet and http */
-  if (olsr_telnet_init()) {
-    goto olsrd_cleanup;
-  }
+  olsr_telnet_init();
   olsr_http_init();
 
   /* activate custom additions to framework */