]> git.proxmox.com Git - mirror_frr.git/blame - lib/memory.c
HACKING: rename to HACKING.md in prep for conversion to MarkDown
[mirror_frr.git] / lib / memory.c
CommitLineData
718e3744 1/*
2 * Memory management routine
3 * Copyright (C) 1998 Kunihiro Ishiguro
4 *
5 * This file is part of GNU Zebra.
6 *
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
10 * later version.
11 *
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with GNU Zebra; see the file COPYING. If not, write to the Free
19 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20 * 02111-1307, USA.
21 */
22
23#include <zebra.h>
d09552d0 24/* malloc.h is generally obsolete, however GNU Libc mallinfo wants it. */
74176d22 25#if !defined(HAVE_STDLIB_H) || (defined(GNU_LINUX) && defined(HAVE_MALLINFO))
41be32bf 26#include <malloc.h>
d09552d0 27#endif /* !HAVE_STDLIB_H || HAVE_MALLINFO */
718e3744 28
29#include "log.h"
30#include "memory.h"
31
f858e49b 32static void alloc_inc (int);
33static void alloc_dec (int);
7fa25ff6 34static void log_memstats(int log_priority);
6b0655a2 35
1423c809 36static const struct message mstr [] =
718e3744 37{
38 { MTYPE_THREAD, "thread" },
39 { MTYPE_THREAD_MASTER, "thread_master" },
40 { MTYPE_VECTOR, "vector" },
41 { MTYPE_VECTOR_INDEX, "vector_index" },
42 { MTYPE_IF, "interface" },
43 { 0, NULL },
44};
6b0655a2 45
718e3744 46/* Fatal memory allocation error occured. */
8cc4198f 47static void __attribute__ ((noreturn))
718e3744 48zerror (const char *fname, int type, size_t size)
49{
7fa25ff6 50 zlog_err ("%s : can't allocate memory for `%s' size %d: %s\n",
6099b3b5 51 fname, lookup (mstr, type), (int) size, safe_strerror(errno));
7fa25ff6 52 log_memstats(LOG_WARNING);
48d6c69b 53 /* N.B. It might be preferable to call zlog_backtrace_sigsafe here, since
063ee52a 54 that function should definitely be safe in an OOM condition. But
48d6c69b 55 unfortunately zlog_backtrace_sigsafe does not support syslog logging at
063ee52a 56 this time... */
57 zlog_backtrace(LOG_WARNING);
7fa25ff6 58 abort();
718e3744 59}
60
b1679387
GT
61/*
62 * Allocate memory of a given size, to be tracked by a given type.
63 * Effects: Returns a pointer to usable memory. If memory cannot
64 * be allocated, aborts execution.
65 */
718e3744 66void *
67zmalloc (int type, size_t size)
68{
69 void *memory;
70
71 memory = malloc (size);
72
73 if (memory == NULL)
74 zerror ("malloc", type, size);
75
76 alloc_inc (type);
77
78 return memory;
79}
80
b1679387
GT
81/*
82 * Allocate memory as in zmalloc, and also clear the memory.
83 */
718e3744 84void *
85zcalloc (int type, size_t size)
86{
87 void *memory;
88
89 memory = calloc (1, size);
90
91 if (memory == NULL)
92 zerror ("calloc", type, size);
93
94 alloc_inc (type);
95
96 return memory;
97}
98
b1679387
GT
99/*
100 * Given a pointer returned by zmalloc or zcalloc, free it and
101 * return a pointer to a new size, basically acting like realloc().
102 * Requires: ptr was returned by zmalloc, zcalloc, or zrealloc with the
103 * same type.
104 * Effects: Returns a pointer to the new memory, or aborts.
105 */
718e3744 106void *
107zrealloc (int type, void *ptr, size_t size)
108{
109 void *memory;
110
111 memory = realloc (ptr, size);
112 if (memory == NULL)
113 zerror ("realloc", type, size);
cca85d27
CH
114 if (ptr == NULL)
115 alloc_inc (type);
116
718e3744 117 return memory;
118}
119
b1679387
GT
120/*
121 * Free memory allocated by z*alloc or zstrdup.
122 * Requires: ptr was returned by zmalloc, zcalloc, or zrealloc with the
123 * same type.
124 * Effects: The memory is freed and may no longer be referenced.
125 */
718e3744 126void
127zfree (int type, void *ptr)
128{
cca85d27
CH
129 if (ptr != NULL)
130 {
131 alloc_dec (type);
132 free (ptr);
133 }
718e3744 134}
135
b1679387
GT
136/*
137 * Duplicate a string, counting memory usage by type.
138 * Effects: The string is duplicated, and the return value must
139 * eventually be passed to zfree with the same type. The function will
140 * succeed or abort.
141 */
718e3744 142char *
b04c699e 143zstrdup (int type, const char *str)
718e3744 144{
145 void *dup;
146
147 dup = strdup (str);
148 if (dup == NULL)
149 zerror ("strdup", type, strlen (str));
150 alloc_inc (type);
151 return dup;
152}
6b0655a2 153
718e3744 154#ifdef MEMORY_LOG
f858e49b 155static struct
718e3744 156{
b04c699e 157 const char *name;
228da428 158 long alloc;
718e3744 159 unsigned long t_malloc;
160 unsigned long c_malloc;
161 unsigned long t_calloc;
162 unsigned long c_calloc;
163 unsigned long t_realloc;
164 unsigned long t_free;
165 unsigned long c_strdup;
166} mstat [MTYPE_MAX];
167
f858e49b 168static void
718e3744 169mtype_log (char *func, void *memory, const char *file, int line, int type)
170{
b9e7028f 171 zlog_debug ("%s: %s %p %s %d", func, lookup (mstr, type), memory, file, line);
718e3744 172}
173
174void *
175mtype_zmalloc (const char *file, int line, int type, size_t size)
176{
177 void *memory;
178
179 mstat[type].c_malloc++;
180 mstat[type].t_malloc++;
181
182 memory = zmalloc (type, size);
183 mtype_log ("zmalloc", memory, file, line, type);
184
185 return memory;
186}
187
188void *
189mtype_zcalloc (const char *file, int line, int type, size_t size)
190{
191 void *memory;
192
193 mstat[type].c_calloc++;
194 mstat[type].t_calloc++;
195
196 memory = zcalloc (type, size);
197 mtype_log ("xcalloc", memory, file, line, type);
198
199 return memory;
200}
201
202void *
203mtype_zrealloc (const char *file, int line, int type, void *ptr, size_t size)
204{
205 void *memory;
206
207 /* Realloc need before allocated pointer. */
208 mstat[type].t_realloc++;
209
210 memory = zrealloc (type, ptr, size);
211
212 mtype_log ("xrealloc", memory, file, line, type);
213
214 return memory;
215}
216
217/* Important function. */
218void
219mtype_zfree (const char *file, int line, int type, void *ptr)
220{
221 mstat[type].t_free++;
222
223 mtype_log ("xfree", ptr, file, line, type);
224
225 zfree (type, ptr);
226}
227
228char *
b04c699e 229mtype_zstrdup (const char *file, int line, int type, const char *str)
718e3744 230{
231 char *memory;
232
233 mstat[type].c_strdup++;
234
235 memory = zstrdup (type, str);
236
237 mtype_log ("xstrdup", memory, file, line, type);
238
239 return memory;
240}
241#else
f858e49b 242static struct
718e3744 243{
244 char *name;
228da428 245 long alloc;
718e3744 246} mstat [MTYPE_MAX];
228da428 247#endif /* MEMORY_LOG */
718e3744 248
249/* Increment allocation counter. */
f858e49b 250static void
718e3744 251alloc_inc (int type)
252{
253 mstat[type].alloc++;
254}
255
256/* Decrement allocation counter. */
f858e49b 257static void
718e3744 258alloc_dec (int type)
259{
260 mstat[type].alloc--;
261}
6b0655a2 262
718e3744 263/* Looking up memory status from vty interface. */
264#include "vector.h"
265#include "vty.h"
266#include "command.h"
267
7fa25ff6 268static void
269log_memstats(int pri)
270{
271 struct mlist *ml;
272
273 for (ml = mlists; ml->list; ml++)
274 {
275 struct memory_list *m;
276
277 zlog (NULL, pri, "Memory utilization in module %s:", ml->name);
278 for (m = ml->list; m->index >= 0; m++)
279 if (m->index && mstat[m->index].alloc)
2fd2fd5d 280 zlog (NULL, pri, " %-30s: %10ld", m->format, mstat[m->index].alloc);
7fa25ff6 281 }
282}
283
228da428
CC
284void
285log_memstats_stderr (const char *prefix)
286{
287 struct mlist *ml;
288 struct memory_list *m;
289 int i;
290 int j = 0;
291
292 for (ml = mlists; ml->list; ml++)
293 {
294 i = 0;
295
296 for (m = ml->list; m->index >= 0; m++)
297 if (m->index && mstat[m->index].alloc)
298 {
299 if (!i)
300 fprintf (stderr,
301 "%s: memstats: Current memory utilization in module %s:\n",
302 prefix,
303 ml->name);
304 fprintf (stderr,
305 "%s: memstats: %-30s: %10ld%s\n",
306 prefix,
307 m->format,
308 mstat[m->index].alloc,
309 mstat[m->index].alloc < 0 ? " (REPORT THIS BUG!)" : "");
310 i = j = 1;
311 }
312 }
313
314 if (j)
315 fprintf (stderr,
316 "%s: memstats: NOTE: If configuration exists, utilization may be "
317 "expected.\n",
318 prefix);
319 else
320 fprintf (stderr,
321 "%s: memstats: No remaining tracked memory utilization.\n",
322 prefix);
323}
324
24065a3d 325static void
326show_separator(struct vty *vty)
718e3744 327{
24065a3d 328 vty_out (vty, "-----------------------------\r\n");
329}
718e3744 330
24065a3d 331static int
718e3744 332show_memory_vty (struct vty *vty, struct memory_list *list)
333{
334 struct memory_list *m;
24065a3d 335 int needsep = 0;
718e3744 336
337 for (m = list; m->index >= 0; m++)
338 if (m->index == 0)
24065a3d 339 {
340 if (needsep)
341 {
342 show_separator (vty);
343 needsep = 0;
344 }
345 }
346 else if (mstat[m->index].alloc)
347 {
348 vty_out (vty, "%-30s: %10ld\r\n", m->format, mstat[m->index].alloc);
349 needsep = 1;
350 }
351 return needsep;
718e3744 352}
353
41be32bf
PJ
354#ifdef HAVE_MALLINFO
355static int
356show_memory_mallinfo (struct vty *vty)
357{
358 struct mallinfo minfo = mallinfo();
359 char buf[MTYPE_MEMSTR_LEN];
360
361 vty_out (vty, "System allocator statistics:%s", VTY_NEWLINE);
362 vty_out (vty, " Total heap allocated: %s%s",
363 mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.arena),
364 VTY_NEWLINE);
365 vty_out (vty, " Holding block headers: %s%s",
366 mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.hblkhd),
367 VTY_NEWLINE);
368 vty_out (vty, " Used small blocks: %s%s",
369 mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.usmblks),
370 VTY_NEWLINE);
371 vty_out (vty, " Used ordinary blocks: %s%s",
372 mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.uordblks),
373 VTY_NEWLINE);
374 vty_out (vty, " Free small blocks: %s%s",
375 mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.fsmblks),
376 VTY_NEWLINE);
377 vty_out (vty, " Free ordinary blocks: %s%s",
378 mtype_memstr (buf, MTYPE_MEMSTR_LEN, minfo.fordblks),
379 VTY_NEWLINE);
380 vty_out (vty, " Ordinary blocks: %ld%s",
381 (unsigned long)minfo.ordblks,
382 VTY_NEWLINE);
383 vty_out (vty, " Small blocks: %ld%s",
384 (unsigned long)minfo.smblks,
385 VTY_NEWLINE);
386 vty_out (vty, " Holding blocks: %ld%s",
387 (unsigned long)minfo.hblks,
388 VTY_NEWLINE);
389 vty_out (vty, "(see system documentation for 'mallinfo' for meaning)%s",
390 VTY_NEWLINE);
391 return 1;
392}
393#endif /* HAVE_MALLINFO */
394
0d05fa51
DS
395DEFUN (show_memory,
396 show_memory_cmd,
397 "show memory",
718e3744 398 "Show running system information\n"
0d05fa51 399 "Memory statistics\n")
718e3744 400{
7fa25ff6 401 struct mlist *ml;
24065a3d 402 int needsep = 0;
41be32bf
PJ
403
404#ifdef HAVE_MALLINFO
405 needsep = show_memory_mallinfo (vty);
406#endif /* HAVE_MALLINFO */
407
7fa25ff6 408 for (ml = mlists; ml->list; ml++)
409 {
24065a3d 410 if (needsep)
411 show_separator (vty);
412 needsep = show_memory_vty (vty, ml->list);
7fa25ff6 413 }
718e3744 414
415 return CMD_SUCCESS;
416}
417
9e867fe6 418
12e41d03
DL
419DEFUN (show_memory_pim,
420 show_memory_pim_cmd,
421 "show memory pim",
422 SHOW_STR
423 "Memory statistics\n"
424 "PIM memory\n")
425{
426 show_memory_vty (vty, memory_list_pim);
427 return CMD_SUCCESS;
428}
429
718e3744 430void
f858e49b 431memory_init (void)
718e3744 432{
62687ff1 433 install_element (RESTRICTED_NODE, &show_memory_cmd);
62687ff1 434
718e3744 435 install_element (VIEW_NODE, &show_memory_cmd);
718e3744 436
437 install_element (ENABLE_NODE, &show_memory_cmd);
718e3744 438}
6b0655a2 439
41be32bf
PJ
440/* Stats querying from users */
441/* Return a pointer to a human friendly string describing
442 * the byte count passed in. E.g:
443 * "0 bytes", "2048 bytes", "110kB", "500MiB", "11GiB", etc.
444 * Up to 4 significant figures will be given.
445 * The pointer returned may be NULL (indicating an error)
446 * or point to the given buffer, or point to static storage.
447 */
448const char *
449mtype_memstr (char *buf, size_t len, unsigned long bytes)
450{
6896f650
DS
451 unsigned int m, k;
452
41be32bf
PJ
453 /* easy cases */
454 if (!bytes)
455 return "0 bytes";
456 if (bytes == 1)
457 return "1 byte";
6896f650
DS
458
459 /*
460 * When we pass the 2gb barrier mallinfo() can no longer report
461 * correct data so it just does something odd...
462 * Reporting like Terrabytes of data. Which makes users...
463 * edgy.. yes edgy that's the term for it.
464 * So let's just give up gracefully
465 */
466 if (bytes > 0x7fffffff)
467 return "> 2GB";
468
41be32bf
PJ
469 m = bytes >> 20;
470 k = bytes >> 10;
6896f650
DS
471
472 if (m > 10)
41be32bf
PJ
473 {
474 if (bytes & (1 << 19))
475 m++;
476 snprintf (buf, len, "%d MiB", m);
477 }
478 else if (k > 10)
479 {
480 if (bytes & (1 << 9))
481 k++;
482 snprintf (buf, len, "%d KiB", k);
483 }
484 else
485 snprintf (buf, len, "%ld bytes", bytes);
486
487 return buf;
488}
489
490unsigned long
491mtype_stats_alloc (int type)
492{
493 return mstat[type].alloc;
494}