/*
- * Memory management routine
- * Copyright (C) 1998 Kunihiro Ishiguro
+ * Copyright (c) 2015-16 David Lamparter, for NetDEF, Inc.
*
- * This file is part of GNU Zebra.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
*
- * GNU Zebra is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2, or (at your option) any
- * later version.
- *
- * GNU Zebra is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNU Zebra; see the file COPYING. If not, write to the Free
- * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <zebra.h>
-/* malloc.h is generally obsolete, however GNU Libc mallinfo wants it. */
-#if !defined(HAVE_STDLIB_H) || (defined(GNU_LINUX) && defined(HAVE_MALLINFO))
-#include <malloc.h>
-#endif /* !HAVE_STDLIB_H || HAVE_MALLINFO */
-#include "log.h"
-#include "memory.h"
+#include <stdlib.h>
-static void alloc_inc (int);
-static void alloc_dec (int);
-static void log_memstats(int log_priority);
-\f
-static const struct message mstr [] =
-{
- { MTYPE_THREAD, "thread" },
- { MTYPE_THREAD_MASTER, "thread_master" },
- { MTYPE_VECTOR, "vector" },
- { MTYPE_VECTOR_INDEX, "vector_index" },
- { MTYPE_IF, "interface" },
- { 0, NULL },
-};
-\f
-/* 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));
- 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
- unfortunately zlog_backtrace_sigsafe does not support syslog logging at
- this time... */
- zlog_backtrace(LOG_WARNING);
- abort();
-}
-
-/*
- * Allocate memory of a given size, to be tracked by a given type.
- * Effects: Returns a pointer to usable memory. If memory cannot
- * be allocated, aborts execution.
- */
-void *
-zmalloc (int type, size_t size)
-{
- void *memory;
-
- memory = malloc (size);
-
- if (memory == NULL)
- zerror ("malloc", type, size);
+#include "memory.h"
- alloc_inc (type);
+static struct memgroup *mg_first = NULL;
+struct memgroup **mg_insert = &mg_first;
- return memory;
-}
+DEFINE_MGROUP(LIB, "libzebra")
+DEFINE_MTYPE(LIB, TMP, "Temporary memory")
-/*
- * Allocate memory as in zmalloc, and also clear the memory.
- */
-void *
-zcalloc (int type, size_t size)
+static inline void
+mt_count_alloc (struct memtype *mt, size_t size)
{
- void *memory;
-
- memory = calloc (1, size);
-
- if (memory == NULL)
- zerror ("calloc", type, size);
+ mt->n_alloc++;
- alloc_inc (type);
-
- return memory;
+ if (mt->size == 0)
+ mt->size = size;
+ else if (mt->size != size)
+ mt->size = SIZE_VAR;
}
-/*
- * Given a pointer returned by zmalloc or zcalloc, free it and
- * return a pointer to a new size, basically acting like realloc().
- * Requires: ptr was returned by zmalloc, zcalloc, or zrealloc with the
- * same type.
- * Effects: Returns a pointer to the new memory, or aborts.
- */
-void *
-zrealloc (int type, void *ptr, size_t size)
+static inline void
+mt_count_free (struct memtype *mt)
{
- void *memory;
-
- memory = realloc (ptr, size);
- if (memory == NULL)
- zerror ("realloc", type, size);
- return memory;
+ mt->n_alloc--;
}
-/*
- * Free memory allocated by z*alloc or zstrdup.
- * Requires: ptr was returned by zmalloc, zcalloc, or zrealloc with the
- * same type.
- * Effects: The memory is freed and may no longer be referenced.
- */
-void
-zfree (int type, void *ptr)
+static inline void *
+mt_checkalloc (struct memtype *mt, void *ptr, size_t size)
{
- alloc_dec (type);
- free (ptr);
-}
-
-/*
- * Duplicate a string, counting memory usage by type.
- * Effects: The string is duplicated, and the return value must
- * eventually be passed to zfree with the same type. The function will
- * succeed or abort.
- */
-char *
-zstrdup (int type, const char *str)
-{
- void *dup;
-
- dup = strdup (str);
- if (dup == NULL)
- zerror ("strdup", type, strlen (str));
- alloc_inc (type);
- return dup;
-}
-\f
-#ifdef MEMORY_LOG
-static struct
-{
- const char *name;
- long alloc;
- unsigned long t_malloc;
- unsigned long c_malloc;
- unsigned long t_calloc;
- unsigned long c_calloc;
- unsigned long t_realloc;
- unsigned long t_free;
- unsigned long c_strdup;
-} mstat [MTYPE_MAX];
-
-static void
-mtype_log (char *func, void *memory, const char *file, int line, int type)
-{
- zlog_debug ("%s: %s %p %s %d", func, lookup (mstr, type), memory, file, line);
+ if (__builtin_expect(ptr == NULL, 0))
+ {
+ memory_oom (size, mt->name);
+ return NULL;
+ }
+ mt_count_alloc (mt, size);
+ return ptr;
}
void *
-mtype_zmalloc (const char *file, int line, int type, size_t size)
+qmalloc (struct memtype *mt, size_t size)
{
- void *memory;
-
- mstat[type].c_malloc++;
- mstat[type].t_malloc++;
-
- memory = zmalloc (type, size);
- mtype_log ("zmalloc", memory, file, line, type);
-
- return memory;
+ return mt_checkalloc (mt, malloc (size), size);
}
void *
-mtype_zcalloc (const char *file, int line, int type, size_t size)
+qcalloc (struct memtype *mt, size_t size)
{
- void *memory;
-
- mstat[type].c_calloc++;
- mstat[type].t_calloc++;
-
- memory = zcalloc (type, size);
- mtype_log ("xcalloc", memory, file, line, type);
-
- return memory;
+ return mt_checkalloc (mt, calloc (size, 1), size);
}
void *
-mtype_zrealloc (const char *file, int line, int type, void *ptr, size_t size)
-{
- void *memory;
-
- /* Realloc need before allocated pointer. */
- mstat[type].t_realloc++;
-
- memory = zrealloc (type, ptr, size);
-
- mtype_log ("xrealloc", memory, file, line, type);
-
- return memory;
-}
-
-/* Important function. */
-void
-mtype_zfree (const char *file, int line, int type, void *ptr)
-{
- mstat[type].t_free++;
-
- mtype_log ("xfree", ptr, file, line, type);
-
- zfree (type, ptr);
-}
-
-char *
-mtype_zstrdup (const char *file, int line, int type, const char *str)
+qrealloc (struct memtype *mt, void *ptr, size_t size)
{
- char *memory;
-
- mstat[type].c_strdup++;
-
- memory = zstrdup (type, str);
-
- mtype_log ("xstrdup", memory, file, line, type);
-
- return memory;
+ if (ptr)
+ mt_count_free (mt);
+ return mt_checkalloc (mt, ptr ? realloc (ptr, size) : malloc (size), size);
}
-#else
-static struct
-{
- char *name;
- long alloc;
-} mstat [MTYPE_MAX];
-#endif /* MEMORY_LOG */
-/* Increment allocation counter. */
-static void
-alloc_inc (int type)
-{
- mstat[type].alloc++;
-}
-
-/* Decrement allocation counter. */
-static void
-alloc_dec (int type)
-{
- mstat[type].alloc--;
-}
-\f
-/* Looking up memory status from vty interface. */
-#include "vector.h"
-#include "vty.h"
-#include "command.h"
-
-static void
-log_memstats(int pri)
+void *
+qstrdup (struct memtype *mt, const char *str)
{
- struct mlist *ml;
-
- for (ml = mlists; ml->list; ml++)
- {
- struct memory_list *m;
-
- zlog (NULL, pri, "Memory utilization in module %s:", ml->name);
- for (m = ml->list; m->index >= 0; m++)
- if (m->index && mstat[m->index].alloc)
- zlog (NULL, pri, " %-30s: %10ld", m->format, mstat[m->index].alloc);
- }
+ return mt_checkalloc (mt, strdup (str), strlen (str) + 1);
}
void
-log_memstats_stderr (const char *prefix)
-{
- struct mlist *ml;
- struct memory_list *m;
- int i;
- int j = 0;
-
- for (ml = mlists; ml->list; ml++)
- {
- i = 0;
-
- for (m = ml->list; m->index >= 0; m++)
- if (m->index && mstat[m->index].alloc)
- {
- if (!i)
- fprintf (stderr,
- "%s: memstats: Current memory utilization in module %s:\n",
- prefix,
- ml->name);
- fprintf (stderr,
- "%s: memstats: %-30s: %10ld%s\n",
- prefix,
- m->format,
- mstat[m->index].alloc,
- mstat[m->index].alloc < 0 ? " (REPORT THIS BUG!)" : "");
- i = j = 1;
- }
- }
-
- if (j)
- fprintf (stderr,
- "%s: memstats: NOTE: If configuration exists, utilization may be "
- "expected.\n",
- prefix);
- else
- fprintf (stderr,
- "%s: memstats: No remaining tracked memory utilization.\n",
- prefix);
-}
-
-static void
-show_separator(struct vty *vty)
-{
- vty_out (vty, "-----------------------------\r\n");
-}
-
-static int
-show_memory_vty (struct vty *vty, struct memory_list *list)
+qfree (struct memtype *mt, void *ptr)
{
- struct memory_list *m;
- int needsep = 0;
-
- for (m = list; m->index >= 0; m++)
- if (m->index == 0)
- {
- if (needsep)
- {
- show_separator (vty);
- needsep = 0;
- }
- }
- else if (mstat[m->index].alloc)
- {
- vty_out (vty, "%-30s: %10ld\r\n", m->format, mstat[m->index].alloc);
- needsep = 1;
- }
- return needsep;
+ if (ptr)
+ mt_count_free (mt);
+ free (ptr);
}
-#ifdef HAVE_MALLINFO
-static int
-show_memory_mallinfo (struct vty *vty)
+int
+qmem_walk (qmem_walk_fn *func, void *arg)
{
- struct mallinfo minfo = mallinfo();
- char buf[MTYPE_MEMSTR_LEN];
-
- vty_out (vty, "System allocator statistics:%s", VTY_NEWLINE);
- vty_out (vty, " Total heap allocated: %s%s",
- mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.arena),
- VTY_NEWLINE);
- vty_out (vty, " Holding block headers: %s%s",
- mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.hblkhd),
- VTY_NEWLINE);
- vty_out (vty, " Used small blocks: %s%s",
- mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.usmblks),
- VTY_NEWLINE);
- vty_out (vty, " Used ordinary blocks: %s%s",
- mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.uordblks),
- VTY_NEWLINE);
- vty_out (vty, " Free small blocks: %s%s",
- mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.fsmblks),
- VTY_NEWLINE);
- vty_out (vty, " Free ordinary blocks: %s%s",
- mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.fordblks),
- VTY_NEWLINE);
- vty_out (vty, " Ordinary blocks: %ld%s",
- (unsigned long)minfo.ordblks,
- VTY_NEWLINE);
- vty_out (vty, " Small blocks: %ld%s",
- (unsigned long)minfo.smblks,
- VTY_NEWLINE);
- vty_out (vty, " Holding blocks: %ld%s",
- (unsigned long)minfo.hblks,
- VTY_NEWLINE);
- vty_out (vty, "(see system documentation for 'mallinfo' for meaning)%s",
- VTY_NEWLINE);
- return 1;
-}
-#endif /* HAVE_MALLINFO */
+ struct memgroup *mg;
+ struct memtype *mt;
+ int rv;
-DEFUN (show_memory_all,
- show_memory_all_cmd,
- "show memory all",
- "Show running system information\n"
- "Memory statistics\n"
- "All memory statistics\n")
-{
- struct mlist *ml;
- int needsep = 0;
-
-#ifdef HAVE_MALLINFO
- needsep = show_memory_mallinfo (vty);
-#endif /* HAVE_MALLINFO */
-
- for (ml = mlists; ml->list; ml++)
+ for (mg = mg_first; mg; mg = mg->next)
{
- if (needsep)
- show_separator (vty);
- needsep = show_memory_vty (vty, ml->list);
+ if ((rv = func (arg, mg, NULL)))
+ return rv;
+ for (mt = mg->types; mt; mt = mt->next)
+ if ((rv = func (arg, mg, mt)))
+ return rv;
}
-
- return CMD_SUCCESS;
-}
-
-ALIAS (show_memory_all,
- show_memory_cmd,
- "show memory",
- "Show running system information\n"
- "Memory statistics\n")
-
-DEFUN (show_memory_lib,
- show_memory_lib_cmd,
- "show memory lib",
- SHOW_STR
- "Memory statistics\n"
- "Library memory\n")
-{
- show_memory_vty (vty, memory_list_lib);
- return CMD_SUCCESS;
+ return 0;
}
-DEFUN (show_memory_zebra,
- show_memory_zebra_cmd,
- "show memory zebra",
- SHOW_STR
- "Memory statistics\n"
- "Zebra memory\n")
+struct exit_dump_args
{
- show_memory_vty (vty, memory_list_zebra);
- return CMD_SUCCESS;
-}
-
-DEFUN (show_memory_rip,
- show_memory_rip_cmd,
- "show memory rip",
- SHOW_STR
- "Memory statistics\n"
- "RIP memory\n")
-{
- show_memory_vty (vty, memory_list_rip);
- return CMD_SUCCESS;
-}
-
-DEFUN (show_memory_ripng,
- show_memory_ripng_cmd,
- "show memory ripng",
- SHOW_STR
- "Memory statistics\n"
- "RIPng memory\n")
-{
- show_memory_vty (vty, memory_list_ripng);
- return CMD_SUCCESS;
-}
-
-DEFUN (show_memory_bgp,
- show_memory_bgp_cmd,
- "show memory bgp",
- SHOW_STR
- "Memory statistics\n"
- "BGP memory\n")
-{
- show_memory_vty (vty, memory_list_bgp);
- return CMD_SUCCESS;
-}
-
-DEFUN (show_memory_ospf,
- show_memory_ospf_cmd,
- "show memory ospf",
- SHOW_STR
- "Memory statistics\n"
- "OSPF memory\n")
-{
- show_memory_vty (vty, memory_list_ospf);
- return CMD_SUCCESS;
-}
-
-DEFUN (show_memory_ospf6,
- show_memory_ospf6_cmd,
- "show memory ospf6",
- SHOW_STR
- "Memory statistics\n"
- "OSPF6 memory\n")
-{
- show_memory_vty (vty, memory_list_ospf6);
- return CMD_SUCCESS;
-}
-
-DEFUN (show_memory_isis,
- show_memory_isis_cmd,
- "show memory isis",
- SHOW_STR
- "Memory statistics\n"
- "ISIS memory\n")
-{
- show_memory_vty (vty, memory_list_isis);
- return CMD_SUCCESS;
-}
+ const char *prefix;
+ int error;
+};
-void
-memory_init (void)
+static int
+qmem_exit_walker (void *arg, struct memgroup *mg, struct memtype *mt)
{
- install_element (RESTRICTED_NODE, &show_memory_cmd);
- install_element (RESTRICTED_NODE, &show_memory_all_cmd);
- install_element (RESTRICTED_NODE, &show_memory_lib_cmd);
- install_element (RESTRICTED_NODE, &show_memory_rip_cmd);
- install_element (RESTRICTED_NODE, &show_memory_ripng_cmd);
- install_element (RESTRICTED_NODE, &show_memory_bgp_cmd);
- install_element (RESTRICTED_NODE, &show_memory_ospf_cmd);
- install_element (RESTRICTED_NODE, &show_memory_ospf6_cmd);
- install_element (RESTRICTED_NODE, &show_memory_isis_cmd);
+ struct exit_dump_args *eda = arg;
- install_element (VIEW_NODE, &show_memory_cmd);
- install_element (VIEW_NODE, &show_memory_all_cmd);
- install_element (VIEW_NODE, &show_memory_lib_cmd);
- install_element (VIEW_NODE, &show_memory_rip_cmd);
- install_element (VIEW_NODE, &show_memory_ripng_cmd);
- install_element (VIEW_NODE, &show_memory_bgp_cmd);
- install_element (VIEW_NODE, &show_memory_ospf_cmd);
- install_element (VIEW_NODE, &show_memory_ospf6_cmd);
- install_element (VIEW_NODE, &show_memory_isis_cmd);
-
- install_element (ENABLE_NODE, &show_memory_cmd);
- install_element (ENABLE_NODE, &show_memory_all_cmd);
- install_element (ENABLE_NODE, &show_memory_lib_cmd);
- install_element (ENABLE_NODE, &show_memory_zebra_cmd);
- install_element (ENABLE_NODE, &show_memory_rip_cmd);
- install_element (ENABLE_NODE, &show_memory_ripng_cmd);
- install_element (ENABLE_NODE, &show_memory_bgp_cmd);
- install_element (ENABLE_NODE, &show_memory_ospf_cmd);
- install_element (ENABLE_NODE, &show_memory_ospf6_cmd);
- install_element (ENABLE_NODE, &show_memory_isis_cmd);
-}
-\f
-/* Stats querying from users */
-/* Return a pointer to a human friendly string describing
- * the byte count passed in. E.g:
- * "0 bytes", "2048 bytes", "110kB", "500MiB", "11GiB", etc.
- * Up to 4 significant figures will be given.
- * The pointer returned may be NULL (indicating an error)
- * or point to the given buffer, or point to static storage.
- */
-const char *
-mtype_memstr (char *buf, size_t len, unsigned long bytes)
-{
- unsigned int t, g, m, k;
-
- /* easy cases */
- if (!bytes)
- return "0 bytes";
- if (bytes == 1)
- return "1 byte";
-
- if (sizeof (unsigned long) >= 8)
- /* Hacked to make it not warn on ILP32 machines
- * Shift will always be 40 at runtime. See below too */
- t = bytes >> (sizeof (unsigned long) >= 8 ? 40 : 0);
- else
- t = 0;
- g = bytes >> 30;
- m = bytes >> 20;
- k = bytes >> 10;
-
- if (t > 10)
- {
- /* The shift will always be 39 at runtime.
- * Just hacked to make it not warn on 'smaller' machines.
- * Static compiler analysis should mean no extra code
- */
- if (bytes & (1UL << (sizeof (unsigned long) >= 8 ? 39 : 0)))
- t++;
- snprintf (buf, len, "%4d TiB", t);
- }
- else if (g > 10)
+ if (!mt)
{
- if (bytes & (1 << 29))
- g++;
- snprintf (buf, len, "%d GiB", g);
+ fprintf (stderr, "%s: showing active allocations in memory group %s\n",
+ eda->prefix, mg->name);
}
- else if (m > 10)
+ else if (mt->n_alloc)
{
- if (bytes & (1 << 19))
- m++;
- snprintf (buf, len, "%d MiB", m);
+ char size[32];
+ eda->error++;
+ snprintf (size, sizeof (size), "%10zu", mt->size);
+ fprintf (stderr, "%s: memstats: %-30s: %6zu * %s\n",
+ eda->prefix, mt->name, mt->n_alloc,
+ mt->size == SIZE_VAR ? "(variably sized)" : size);
}
- else if (k > 10)
- {
- if (bytes & (1 << 9))
- k++;
- snprintf (buf, len, "%d KiB", k);
- }
- else
- snprintf (buf, len, "%ld bytes", bytes);
-
- return buf;
+ return 0;
}
-unsigned long
-mtype_stats_alloc (int type)
+void
+log_memstats_stderr (const char *prefix)
{
- return mstat[type].alloc;
+ struct exit_dump_args eda = { .prefix = prefix, .error = 0 };
+ qmem_walk (qmem_exit_walker, &eda);
}
projects / mirror_frr.git / blobdiff