Major update

      bgpd/bgp_advertise.c
      bgpd/bgp_advertise.h

        The adj_in and adj_out objects are now put on a list based
        on the peer to whom the route belongs.

	The adj_in and adj_out objects also now point to the bgp_node
	which they are routes for.

        This substantially reduces the work needed to shut down a peer.

      bgpd/bgp_damp.c

        Changes to adj_in and adj_out forced small change to macros
        used in bgp_damp.c to manage its lists.

      bgpd/bgp_debug.c

        Replaced direct access to vty->node by the required vty_get_node().

      bgpd/bgp_dump.c

        Changes to the names of fields in bgp_info structures.

      bgpd/bgp_engine.h

        Modified the debug and trace functions.

      bgpd/bgp_fsm.c

        Make use of sockunion2str() consistent with common usage.

        Improved some documentation.

      bgpd/bgp_main.c

        Use the newly extended qpn_add_hook_function() facility.

      bgpd/bgp_mplsvpn.c

        Changes to the names of fields in bgp_info structures.

      bgpd/bgp_msg_read.c

        Bug fix: correct handling of capability code length.

        Improvement: better casting in calculation of message length.

      bgpd/bgp_msg_write.c

        Bug fix: correct byte ordering of bgp_id in open message.

      bgpd/bgp_network.c

        Bug fix: correct handling of incoming connections.

        Takes advantage of improvements in sockunion.c.

      bgpd/bgp_nexthop.c

        Changes to the names of fields in bgp_info structures.

      bgpd/bgp_open_state.c

        Remove mistaken #include of memtypes.h

      bgpd/bgp_packet.c

        Improvements to handling of withdrawing routes for peers.

      bgpd/bgp_peer.c

        Tidying up the state of peers as they are enabled and disabled.
        Improvements to handling of withdrawing routes for peers.

      bgpd/bgp_peer.h

        Adding list bases for lists of routes originated by the peer.

      bgpd/bgp_peer_index.c

        Bug fix: correct freeing of peer indexes.

      bgpd/bgp_route.c

        Implement lists of bgp_info based in the owning peer.  Adjust
        for name changes to bgp_info fields.

        Reimplemented all the clearing functions to use the lists of
        items that belong to the peer -- rather than searching route
        tables for stuff to withdraw.

        Changed work queue handling for added/changed routes, so
        that queues run through existing items, rather than having
        queues of auxiliary items -- lower memory overhead.

      bgpd/bgp_route.h

        Added fields to bgp_info to allow all bgp_info originated by
        each peer to live on lists based in the peer.  And changed the
        name of existing fields to avoid confusion.

      bgpd/bgp_routemap.c

        Removing redundant code and fixing a memory leak.

      bgpd/bgp_table.h

        Based work queue for added/changed routes directly in the
        table, rather than having auxiliary structures.

      bgpd/bgp_vty.c

        Use vty_get_node() and vty_set_node() rather than direct
        access to the vty field.

      bgpd/bgpd.c

        Implement changes to route clearing.

      bgpd/bgpd.h

        Changes to work queue handling.

      lib/buffer.c

        Changes to allow embedded buffer structures.

      lib/buffer.h

        Moved struct buffer here so that could have embedded buffer
        structurs.

      lib/command.c

        Substantial tidy up and document exercise.

        Restructured the top level command processing and finding
        of descriptions and command completion.

        Removal of unpleasant messing around with the insides of
        vector structures.

        Movement of some command actions to vty.c.

        Uses uty.h to pick up the "private" functions from vty.c
        et al.

      lib/command.h

        Moved the "node" values to node_type.h, so that can use an
        enum node_type in places where cannot include command.h.

      lib/command_queue.c

        Updated to cope with the called command changing the node
        value.

        Improved handling of revoked commands, so the the command
        line handler does not get stuck waiting for a command to
        complete which has been revoked !

      lib/command_queue.h

        Improved message format.

      lib/if.c

        Use vty_set_node().

      lib/keychain.c

        Use vty_set_node().

  new lib/keystroke.c
  new lib/keystroke.h

        New code to implement a keystroke FIFO.

        This moves some complexity out of the command handler.

        The handling of mixtures of escapes and Telnet IACs is
        tightened up.

        It would be possible to extend this to, say, UTF-8.

        Regularises the "stealing" of keystrokes for the "--more--"
        output handling... which was a bit hit and miss.

  new lib/list_util.c
  new lib/list_util.h

        New code to implement various forms of linked list,
        where the list pointers are embedded in structures.

      lib/log.c

        Changed the handling of log messages, so that all types
        of log output (except syslog) use the same message buffer
        scheme, and the message is constructed once and once
        only.

        Changes to the handling of VTY_LOCK() etc.

        Uses uty.h to pick up the "private" functions from vty.c
	et al.

      lib/log.h

        Changes to the buffering of log messages.

  new lib/mem_tracker.c

        New code to track memory allocation/deallocation, for
        debug purposes.

      lib/memory.c
      lib/memory.h

        Updated to allow the use of the mem_tracker.

      lib/memtypes.awk

        Made the memtypes into a named enum MTYPE.

      lib/memtypes.c

        Various new memory types.

      lib/mqueue.c
      lib/mqueue.h

        Add mqueue_finish function for close-down.

      lib/network.c
      lib/network.h

        Added non-blocking read_nb() and write_nb().

  new lib/node_type.h

        As above.

      lib/plist.c

        Remove vty_puts() which wasn't a good idea.

      lib/qlib_init.c

        Added qps_init() to first stage and mqueue_finish to
        finish.

      lib/qpnexus.c
      lib/qpnexus.h

        More flexible hooks for in_thread_init and in_thread_final.

      lib/qpselect.c
      lib/qpselect.h

        Added qps_start_up() to build the required maps once and
        for all.

        Added qdebug to control the debug checks and validation.

        Improved validation and test functions.

  new lib/qstring.c
  new lib/qstring.h

        New code for limited flexible string handling.

      lib/qtimers.c

        Added qdebug to control the debug checks and validation.

      lib/routemap.c

        Use vty_set_node().

      lib/sockunion.c
      lib/sockunion.h

        Tidied up and regularised the handling of sin_len and
        sin6_len.

        Created common function for setting port into socket.

        Created common function for initialisation/allocation of
        new sockunion.

        Reduced various functions by using common sub-functions.
        Rationalised some code.

        Added sockunion_listen() and sockunion_new_sockaddr().
        Renamed sockunion_new() to sockunion_new_prefix().

        Improved some logging messages.

        Added documentation.

  new lib/uty.h

        Functions etc. used only by vty/command/log/vty_io and
        vty_cli.

      lib/vector.c
      lib/vector.h

        Added vector_t type.

        Removed VECTOR_INDEX, vector_only_wrapper_free() and
        vector_only_index_free() -- following improvement of
        code in command.c.

        Added vector_set_min_length(), vector_set_new_min_length()
        and vector_length() functions.

  new lib/vio_fifo.c
  new lib/vio_fifo.h

        New code to manage simple FIFO of indefinite length.

      lib/vty.c
      lib/vty.h

        Reworked.  Broken into vty.c, vty_io.c and vty_cli.c.

  new lib/vty_cli.c
  new lib/vty_cli.h

        CLI handling parts of the vty family.

  new lib/vty_io.c
  new lib/vty_io.h

        I/O parts of the vty family.

      lib/workqueue.h

        Introduced tyedefs for the various call-back entries.

  new tests/test-list_util.c

        Tests for the list-util stuff.

      vtysh/vtysh.c

        Small change to interface for cmd_execute_command()

1 files changed, 312 insertions, 110 deletions

diff --git a/lib/memory.c b/lib/memory.c
index e11a5e4a..f68dd298 100644
--- a/lib/memory.c
+++ b/lib/memory.c
@@ -31,13 +31,13 @@
 #include "qpthreads.h"
 
 /* Needs to be qpthread safe.  The system malloc etc are already
- * thread safe, but we need to protect the stats */
+ * thread safe, but we need to protect the stats
+ */
 static qpt_mutex_t memory_mutex;
-#define LOCK qpt_mutex_lock(&memory_mutex);
+
+#define LOCK   qpt_mutex_lock(&memory_mutex);
 #define UNLOCK qpt_mutex_unlock(&memory_mutex);
 
-static void alloc_inc (int);
-static void alloc_dec (int);
 static void log_memstats(int log_priority);
 
 static const struct message mstr [] =
@@ -50,12 +50,57 @@ static const struct message mstr [] =
   { 0, NULL },
 };
 
+/* If using the mem_tracker, include it now.                            */
+
+typedef struct mem_tracker* mem_tracker ;
+struct mem_tracker
+{
+  uint64_t  malloc_count ;
+  uint64_t  realloc_count ;
+  uint64_t  free_count ;
+
+  uint32_t  tracked_count ;
+  size_t    tracked_size ;
+
+  uint32_t  tracked_max_count ;
+  size_t    tracked_max_size ;
+} ;
+
+static void
+mem_tracker_zeroise(struct mem_tracker* mem)
+{
+  memset(mem, 0, sizeof(struct mem_tracker)) ;
+} ;
+
+#ifdef MEMORY_TRACKER
+#include "mem_tracker.c"
+#endif
+
+/*==============================================================================
+ * Keeping track of number of allocated objects of given type
+ */
+
+static struct mstat
+{
+  struct
+  {
+    char *name ;
+    long alloc ;
+  } mt[MTYPE_MAX] ;
+} mstat ;
+
+/*==============================================================================
+ * Memory allocation functions.
+ *
+ * NB: failure to allocate is FATAL -- so no need to test return value.
+ */
+
 /* Fatal memory allocation error occured. */
 static void __attribute__ ((noreturn))
 zerror (const char *fname, int type, size_t size)
 {
   zlog_err ("%s : can't allocate memory for `%s' size %d: %s\n",
-	    fname, lookup (mstr, type), (int) size, safe_strerror(errno));
+            fname, lookup (mstr, type), (int) size, safe_strerror(errno));
   log_memstats(LOG_WARNING);
   /* N.B. It might be preferable to call zlog_backtrace_sigsafe here, since
      that function should definitely be safe in an OOM condition.  But
@@ -65,72 +110,145 @@ zerror (const char *fname, int type, size_t size)
   abort();
 }
 
-/* Memory allocation. */
+/*------------------------------------------------------------------------------
+ * Memory allocation.
+ */
 void *
-zmalloc (int type, size_t size)
+zmalloc (enum MTYPE mtype, size_t size  MEMORY_TRACKER_NAME)
 {
   void *memory;
 
+  LOCK ;
+
   memory = malloc (size);
 
   if (memory == NULL)
-    zerror ("malloc", type, size);
-
-  alloc_inc (type);
+    {
+      UNLOCK ;
+      zerror ("malloc", mtype, size);   /* NO RETURN !  */
+    }
+  else
+    {
+      mstat.mt[mtype].alloc++;
+#ifdef MEMORY_TRACKER
+      mem_md_malloc(mtype, memory, size, name) ;
+#endif
+      UNLOCK ;
+    } ;
 
   return memory;
 }
 
-/* Memory allocation with num * size with cleared. */
+/*------------------------------------------------------------------------------
+ * Memory allocation zeroising the allocated area.
+ */
 void *
-zcalloc (int type, size_t size)
+zcalloc (enum MTYPE mtype, size_t size  MEMORY_TRACKER_NAME)
 {
   void *memory;
 
+  LOCK ;
+
   memory = calloc (1, size);
 
   if (memory == NULL)
-    zerror ("calloc", type, size);
-
-  alloc_inc (type);
+    {
+      UNLOCK ;
+      zerror ("calloc", mtype, size);   /* NO RETURN !  */
+    }
+  else
+    {
+      mstat.mt[mtype].alloc++;
+#ifdef MEMORY_TRACKER
+      mem_md_malloc(mtype, memory, size, name) ;
+#endif
+      UNLOCK ;
+    } ;
 
   return memory;
 }
 
-/* Memory reallocation. */
+/*------------------------------------------------------------------------------
+ * Memory reallocation.
+ */
 void *
-zrealloc (int type, void *ptr, size_t size)
+zrealloc (enum MTYPE mtype, void *ptr, size_t size  MEMORY_TRACKER_NAME)
 {
   void *memory;
 
+  LOCK ;
+
   memory = realloc (ptr, size);
   if (memory == NULL)
-    zerror ("realloc", type, size);
+    {
+      UNLOCK ;
+      zerror ("realloc", mtype, size);  /* NO RETURN !  */
+    }
+  else
+    {
+      if (ptr == NULL)
+        mstat.mt[mtype].alloc++;
+#ifdef MEMORY_TRACKER
+      mem_md_realloc(mtype, ptr, memory, size, name) ;
+#endif
+      UNLOCK ;
+    } ;
+
   return memory;
-}
+} ;
 
-/* Memory free. */
+/*------------------------------------------------------------------------------
+ * Memory free.
+ */
 void
-zfree (int type, void *ptr)
+zfree (enum MTYPE mtype, void *ptr)
 {
-  alloc_dec (type);
+  LOCK ;
+
   free (ptr);
-}
 
-/* String duplication. */
+  mstat.mt[mtype].alloc--;
+#ifdef MEMORY_TRACKER
+  mem_md_free(mtype, ptr) ;
+#endif
+
+  UNLOCK ;
+} ;
+
+/*------------------------------------------------------------------------------
+ * String duplication.
+ */
 char *
-zstrdup (int type, const char *str)
+zstrdup (enum MTYPE mtype, const char *str  MEMORY_TRACKER_NAME)
 {
   void *dup;
 
+  LOCK ;
+
   dup = strdup (str);
   if (dup == NULL)
-    zerror ("strdup", type, strlen (str));
-  alloc_inc (type);
+    {
+      UNLOCK ;
+      zerror ("strdup", mtype, strlen (str));  /* NO RETURN !  */
+    }
+  else
+    {
+      mstat.mt[mtype].alloc++;
+#ifdef MEMORY_TRACKER
+      mem_md_malloc(mtype, dup, strlen(str)+1, name) ;
+#endif
+      UNLOCK ;
+    } ;
+
   return dup;
 }
 
+/*==============================================================================
+ * Memory allocation with built in logging
+ */
+
 #ifdef MEMORY_LOG
+
 static struct
 {
   const char *name;
@@ -142,10 +260,11 @@ static struct
   unsigned long t_realloc;
   unsigned long t_free;
   unsigned long c_strdup;
-} mstat [MTYPE_MAX];
+} mlog_stat [MTYPE_MAX];
 
 static void
-mtype_log (char *func, void *memory, const char *file, int line, int type)
+mtype_log (char *func, void *memory, const char *file, int line,
+                                                                enum MTYPE type)
 {
   zlog_debug ("%s: %s %p %s %d", func, lookup (mstr, type), memory, file, line);
 }
@@ -156,8 +275,8 @@ mtype_zmalloc (const char *file, int line, int type, size_t size)
   void *memory;
 
   LOCK
-  mstat[type].c_malloc++;
-  mstat[type].t_malloc++;
+  mlog_stat[type].c_malloc++;
+  mlog_stat[type].t_malloc++;
   UNLOCK
 
   memory = zmalloc (type, size);
@@ -167,13 +286,13 @@ mtype_zmalloc (const char *file, int line, int type, size_t size)
 }
 
 void *
-mtype_zcalloc (const char *file, int line, int type, size_t size)
+mtype_zcalloc (const char *file, int line, enum MTYPE type, size_t size)
 {
   void *memory;
 
   LOCK
-  mstat[type].c_calloc++;
-  mstat[type].t_calloc++;
+  mlog_stat[type].c_calloc++;
+  mlog_stat[type].t_calloc++;
   UNLOCK
 
   memory = zcalloc (type, size);
@@ -183,13 +302,14 @@ mtype_zcalloc (const char *file, int line, int type, size_t size)
 }
 
 void *
-mtype_zrealloc (const char *file, int line, int type, void *ptr, size_t size)
+mtype_zrealloc (const char *file, int line, enum MTYPE type, void *ptr,
+                                                                    size_t size)
 {
   void *memory;
 
   /* Realloc need before allocated pointer. */
   LOCK
-  mstat[type].t_realloc++;
+  mlog_stat[type].t_realloc++;
   UNLOCK
 
   memory = zrealloc (type, ptr, size);
@@ -201,10 +321,10 @@ mtype_zrealloc (const char *file, int line, int type, void *ptr, size_t size)
 
 /* Important function. */
 void
-mtype_zfree (const char *file, int line, int type, void *ptr)
+mtype_zfree (const char *file, int line, enum MTYPE type, void *ptr)
 {
   LOCK
-  mstat[type].t_free++;
+  mlog_stat[type].t_free++;
   UNLOCK
 
   mtype_log ("xfree", ptr, file, line, type);
@@ -213,12 +333,12 @@ mtype_zfree (const char *file, int line, int type, void *ptr)
 }
 
 char *
-mtype_zstrdup (const char *file, int line, int type, const char *str)
+mtype_zstrdup (const char *file, int line, enum MTYPE type, const char *str)
 {
   char *memory;
 
   LOCK
-  mstat[type].c_strdup++;
+  mlog_stat[type].c_strdup++;
   UNLOCK
 
   memory = zstrdup (type, str);
@@ -227,31 +347,11 @@ mtype_zstrdup (const char *file, int line, int type, const char *str)
 
   return memory;
 }
-#else
-static struct
-{
-  char *name;
-  long alloc;
-} mstat [MTYPE_MAX];
-#endif /* MEMORY_LOG */
-
-/* Increment allocation counter. */
-static void
-alloc_inc (int type)
-{
-  LOCK
-  mstat[type].alloc++;
-  UNLOCK
-}
+#endif
 
-/* Decrement allocation counter. */
-static void
-alloc_dec (int type)
-{
-  LOCK
-  mstat[type].alloc--;
-  UNLOCK
-}
+/*==============================================================================
+ * Showing memory allocation
+ */
 
 /* Looking up memory status from vty interface. */
 #include "vector.h"
@@ -261,8 +361,13 @@ alloc_dec (int type)
 static void
 log_memstats(int pri)
 {
+  struct mstat mst ;
   struct mlist *ml;
 
+  LOCK ;
+  mst = mstat ;
+  UNLOCK ;
+
   for (ml = mlists; ml->list; ml++)
     {
       struct memory_list *m;
@@ -270,7 +375,7 @@ log_memstats(int pri)
       zlog (NULL, pri, "Memory utilization in module %s:", ml->name);
       for (m = ml->list; m->index >= 0; m++)
         {
-        unsigned long alloc = mtype_stats_alloc(m->index);
+        unsigned long alloc = mst.mt[m->index].alloc ;
 	if (m->index && alloc)
 	  zlog (NULL, pri, "  %-30s: %10ld", m->format, alloc);
         }
@@ -280,17 +385,22 @@ log_memstats(int pri)
 void
 log_memstats_stderr (const char *prefix)
 {
+  struct mstat mst ;
   struct mlist *ml;
   struct memory_list *m;
   int i;
   int j = 0;
 
+  LOCK ;
+  mst = mstat ;
+  UNLOCK ;
+
   for (ml = mlists; ml->list; ml++)
     {
       i = 0;
       for (m = ml->list; m->index >= 0; m++)
         {
-          unsigned long alloc = mtype_stats_alloc(m->index);
+          unsigned long alloc = mst.mt[m->index].alloc ;
           if (m->index && alloc)
             {
               if (!i)
@@ -321,37 +431,99 @@ log_memstats_stderr (const char *prefix)
 }
 
 static void
-show_separator(struct vty *vty)
+show_memory_type_vty (struct vty *vty, const char* name,
+                                struct mem_tracker* mt, long int alloc, int sep)
 {
-  vty_out (vty, "-----------------------------\r\n");
-}
+  if (sep)
+    vty_out (vty, "-----------------------------%s", VTY_NEWLINE) ;
+
+    vty_out (vty, "%-30s:", name) ;
+#ifdef MEMORY_TRACKER
+    show_memory_tracker_detail(vty, mt, alloc) ;
+#else
+    vty_out (vty, " %10ld", alloc) ;
+#endif
+    vty_out (vty, "%s", VTY_NEWLINE);
+} ;
 
 static int
-show_memory_vty (struct vty *vty, struct memory_list *list)
+show_memory_vty (struct vty *vty, struct memory_list *m, struct mlist* ml,
+                                                                    int needsep)
 {
-  struct memory_list *m;
-  int needsep = 0;
+  int notempty = 0 ;
 
-  for (m = list; m->index >= 0; m++)
-    if (m->index == 0)
-      {
-	if (needsep)
-	  {
-	    show_separator (vty);
-	    needsep = 0;
-	  }
-      }
-    else
-      {
-        unsigned long alloc = mtype_stats_alloc(m->index);
-        if (alloc)
-          {
-            vty_out (vty, "%-30s: %10ld\r\n", m->format, alloc);
-            needsep = 1;
-          }
-      }
-  return needsep;
-}
+  long int      alloc ;
+
+  struct mstat        mst ;
+  struct mem_tracker  mem_tot ;
+  struct mem_tracker  mem_one ;
+  struct mem_tracker* mt ;
+
+#ifdef MEMORY_TRACKER
+  struct mem_type_tracker mem_tt ;
+#endif
+
+  LOCK ;
+  mst    = mstat ;
+#ifdef MEMORY_TRACKER
+  mem_tt = mem_type_tracker ;
+#endif
+  UNLOCK ;
+
+  mem_tracker_zeroise(&mem_tot) ;
+  mem_tracker_zeroise(&mem_one) ;
+
+  if ((m == NULL) && (ml != NULL))
+    m = (ml++)->list ;
+
+  while (m != NULL)
+    {
+      if (m->index <= 0)
+        {
+          needsep = notempty ;
+          if (m->index < 0)
+            {
+              if (ml == NULL)
+                m = NULL ;
+              else
+                m = (ml++)->list ;
+            }
+          else
+            ++m ;
+        }
+      else
+        {
+          alloc = mst.mt[m->index].alloc ;
+#ifdef MEMORY_TRACKER
+          mt = &(mem_tt.mt[m->index]) ;
+#else
+          mt = &mem_one ;
+          mt->tracked_count = alloc ;
+#endif
+
+          mem_tot.malloc_count      += mt->malloc_count ;
+          mem_tot.free_count        += mt->free_count ;
+          mem_tot.realloc_count     += mt->realloc_count ;
+          mem_tot.tracked_count     += mt->tracked_count ;
+          mem_tot.tracked_max_count += mt->tracked_max_count ;
+          mem_tot.tracked_size      += mt->tracked_size ;
+          mem_tot.tracked_max_size  += mt->tracked_max_size ;
+
+          if (alloc || mt->tracked_count)
+            {
+              show_memory_type_vty(vty, m->format, mt, alloc, needsep) ;
+              needsep  = 0 ;
+              notempty = 1 ;
+            } ;
+
+          ++m ;
+       } ;
+    } ;
+
+  show_memory_type_vty(vty, "Total", &mem_tot, mem_tot.tracked_count, notempty);
+
+  return 1 ;
+} ;
 
 #ifdef HAVE_MALLINFO
 static int
@@ -390,10 +562,40 @@ show_memory_mallinfo (struct vty *vty)
            VTY_NEWLINE);
   vty_out (vty, "(see system documentation for 'mallinfo' for meaning)%s",
            VTY_NEWLINE);
+
   return 1;
 }
 #endif /* HAVE_MALLINFO */
 
+
+DEFUN_CALL (show_memory_summary,
+       show_memory_summary_cmd,
+       "show memory summary",
+       "Show running system information\n"
+       "Memory statistics\n"
+       "Summary memory statistics\n")
+{
+#ifdef MEMORY_TRACKER
+  show_memory_tracker_summary(vty) ;
+#else
+  long alloc = 0 ;
+  int  mtype ;
+
+# ifdef HAVE_MALLINFO
+  show_memory_mallinfo (vty);
+# endif /* HAVE_MALLINFO */
+
+  LOCK ;
+  for (mtype = 1 ; mtype < MTYPE_MAX ; ++mtype)
+    alloc += mstat[mtype] ;
+  UNLOCK
+  vty_out(vty, "%ld items allocated%s", alloc, VTY_NEWLINE) ;
+
+#endif /* MEMORY_TRACKER */
+
+  return CMD_SUCCESS;
+}
+
 DEFUN_CALL (show_memory_all,
        show_memory_all_cmd,
        "show memory all",
@@ -401,19 +603,16 @@ DEFUN_CALL (show_memory_all,
        "Memory statistics\n"
        "All memory statistics\n")
 {
-  struct mlist *ml;
   int needsep = 0;
 
 #ifdef HAVE_MALLINFO
-  needsep = show_memory_mallinfo (vty);
+  needsep  |= show_memory_mallinfo (vty);
 #endif /* HAVE_MALLINFO */
+#ifdef MEMORY_TRACKER
+  needsep |= show_memory_tracker_summary(vty) ;
+#endif
 
-  for (ml = mlists; ml->list; ml++)
-    {
-      if (needsep)
-	show_separator (vty);
-      needsep = show_memory_vty (vty, ml->list);
-    }
+  show_memory_vty (vty, NULL, mlists, needsep);
 
   return CMD_SUCCESS;
 }
@@ -431,7 +630,7 @@ DEFUN_CALL (show_memory_lib,
        "Memory statistics\n"
        "Library memory\n")
 {
-  show_memory_vty (vty, memory_list_lib);
+  show_memory_vty (vty, memory_list_lib, NULL, 0);
   return CMD_SUCCESS;
 }
 
@@ -442,7 +641,7 @@ DEFUN_CALL (show_memory_zebra,
        "Memory statistics\n"
        "Zebra memory\n")
 {
-  show_memory_vty (vty, memory_list_zebra);
+  show_memory_vty (vty, memory_list_zebra, NULL, 0);
   return CMD_SUCCESS;
 }
 
@@ -453,7 +652,7 @@ DEFUN_CALL (show_memory_rip,
        "Memory statistics\n"
        "RIP memory\n")
 {
-  show_memory_vty (vty, memory_list_rip);
+  show_memory_vty (vty, memory_list_rip, NULL, 0);
   return CMD_SUCCESS;
 }
 
@@ -464,7 +663,7 @@ DEFUN_CALL (show_memory_ripng,
        "Memory statistics\n"
        "RIPng memory\n")
 {
-  show_memory_vty (vty, memory_list_ripng);
+  show_memory_vty (vty, memory_list_ripng, NULL, 0);
   return CMD_SUCCESS;
 }
 
@@ -475,7 +674,7 @@ DEFUN_CALL (show_memory_bgp,
        "Memory statistics\n"
        "BGP memory\n")
 {
-  show_memory_vty (vty, memory_list_bgp);
+  show_memory_vty (vty, memory_list_bgp, NULL, 0);
   return CMD_SUCCESS;
 }
 
@@ -486,7 +685,7 @@ DEFUN_CALL (show_memory_ospf,
        "Memory statistics\n"
        "OSPF memory\n")
 {
-  show_memory_vty (vty, memory_list_ospf);
+  show_memory_vty (vty, memory_list_ospf, NULL, 0);
   return CMD_SUCCESS;
 }
 
@@ -497,7 +696,7 @@ DEFUN_CALL (show_memory_ospf6,
        "Memory statistics\n"
        "OSPF6 memory\n")
 {
-  show_memory_vty (vty, memory_list_ospf6);
+  show_memory_vty (vty, memory_list_ospf6, NULL, 0);
   return CMD_SUCCESS;
 }
 
@@ -508,7 +707,7 @@ DEFUN_CALL (show_memory_isis,
        "Memory statistics\n"
        "ISIS memory\n")
 {
-  show_memory_vty (vty, memory_list_isis);
+  show_memory_vty (vty, memory_list_isis, NULL, 0);
   return CMD_SUCCESS;
 }
 
@@ -529,6 +728,7 @@ memory_finish (void)
 void
 memory_init (void)
 {
+  install_element (RESTRICTED_NODE, &show_memory_summary_cmd);
   install_element (RESTRICTED_NODE, &show_memory_cmd);
   install_element (RESTRICTED_NODE, &show_memory_all_cmd);
   install_element (RESTRICTED_NODE, &show_memory_lib_cmd);
@@ -539,6 +739,7 @@ memory_init (void)
   install_element (RESTRICTED_NODE, &show_memory_ospf6_cmd);
   install_element (RESTRICTED_NODE, &show_memory_isis_cmd);
 
+  install_element (VIEW_NODE, &show_memory_summary_cmd);
   install_element (VIEW_NODE, &show_memory_cmd);
   install_element (VIEW_NODE, &show_memory_all_cmd);
   install_element (VIEW_NODE, &show_memory_lib_cmd);
@@ -549,6 +750,7 @@ memory_init (void)
   install_element (VIEW_NODE, &show_memory_ospf6_cmd);
   install_element (VIEW_NODE, &show_memory_isis_cmd);
 
+  install_element (ENABLE_NODE, &show_memory_summary_cmd);
   install_element (ENABLE_NODE, &show_memory_cmd);
   install_element (ENABLE_NODE, &show_memory_all_cmd);
   install_element (ENABLE_NODE, &show_memory_lib_cmd);
@@ -625,11 +827,11 @@ mtype_memstr (char *buf, size_t len, unsigned long bytes)
 }
 
 unsigned long
-mtype_stats_alloc (int type)
+mtype_stats_alloc (enum MTYPE type)
 {
   unsigned long result;
   LOCK
-  result = mstat[type].alloc;
+  result = mstat.mt[type].alloc;
   UNLOCK
   return result;
 }