1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
/* Memory management routine
Copyright (C) 1998 Kunihiro Ishiguro
This file is part of GNU Zebra.
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. */
#ifndef _ZEBRA_MEMORY_H
#define _ZEBRA_MEMORY_H
#include "misc.h"
/*------------------------------------------------------------------------------
* The file "lib/memtypes.h is created automatically (in the make) from
* memtypes.c, and contains a large enum which defines all the memory type
* names.
*
* The file memtypes.c contains a number of arrays of struct memory_list, which
* map memory type names to a string, for printing. Those arrays are
* collected together in an array of struct mlist.
*/
struct memory_list /* one per memory type */
{
int index;
const char *format;
};
struct mlist { /* one per class of memory types */
struct memory_list *list;
const char *name;
};
extern struct mlist mlists[]; /* all classes of memory */
#include "lib/memtypes.h"
typedef enum MTYPE mtype_t ;
/*------------------------------------------------------------------------------
* Basic counting -- count of allocated objects of each type of memory
*
*/
struct mem_stats /* wrap in struct so can copy trivially */
{
ulong alloc[MTYPE_MAX] ;
} ;
typedef struct mem_stats mem_stats_t ;
/*------------------------------------------------------------------------------
* Option for logging memory operations.
*/
#ifdef MEMORY_LOGGER /* Takes precedence over MEMORY_TRACKER */
#undef MEMORY_LOGGER
#define MEMORY_LOGGER 1
#undef MEMORY_TRACKER
#define MEMORY_TRACKER 0
#else
#define MEMORY_LOGGER 0
#endif
/*------------------------------------------------------------------------------
* Sort out MEMORY_TRACKER -- option to keep track of memory allocation.
*
* Set to 1 if defined, but blank.
* Set to QDEBUG if not defined.
*
* Force to 0 if NO_MEMORY_TRACKER is defined and not zero.
*
* So: defaults to same as QDEBUG, but no matter what QDEBUG is set to:
*
* * can set MEMORY_TRACKER == 0 to turn off debug
* * or set MEMORY_TRACKER != 0 to turn on debug
* * or set VTY_NO_DEBUG != to force debug off
*/
#ifdef MEMORY_TRACKER /* If defined, make it 1 or 0 */
# if IS_BLANK_OPTION(MEMORY_TRACKER)
# undef MEMORY_TRACKER
# define MEMORY_TRACKER 1
# endif
#else /* If not defined, follow QDEBUG */
# define MEMORY_TRACKER QDEBUG
#endif
#ifdef NO_MEMORY_TRACKER /* Override, if defined. */
# if IS_NOT_ZERO_OPTION(VTY_NO_DEBUG)
# undef MEMORY_TRACKER
# define MEMORY_TRACKER 0
# endif
#endif
/*------------------------------------------------------------------------------
* Argument macros to make everything look much the same
*/
#if MEMORY_LOGGER
#define MEMORY_EXTRA_DATA , __FILE__, __LINE__
#define MEMORY_EXTRA_ARGS , const char* file, int line
#define MEMORY_LOGGING_ARGS file, line
#elif MEMORY_TRACKER
#define MEMORY_EXTRA_DATA , __func__
#define MEMORY_EXTRA_ARGS , const char* func
#define MEMORY_TRACKER_ARG func
#else
#define MEMORY_EXTRA_DATA
#define MEMORY_EXTRA_ARGS
#endif
#ifndef MEMORY_LOGGING_ARGS
#define MEMORY_LOGGING_ARGS "*dummy*", -1
#endif
#ifndef MEMORY_TRACKER_ARG
#define MEMORY_TRACKER_ARG "*dummy*"
#endif
enum
{
memory_logger = MEMORY_LOGGER,
memory_tracker = MEMORY_TRACKER,
} ;
/*------------------------------------------------------------------------------
* The macros used for all Quagga dynamic memory.
*/
#define XMALLOC(mtype, size) zmalloc ((mtype), (size) \
MEMORY_EXTRA_DATA)
#define XCALLOC(mtype, size) zcalloc ((mtype), (size) \
MEMORY_EXTRA_DATA)
#define XREALLOC(mtype, ptr, size) zrealloc ((mtype), (ptr), (size) \
MEMORY_EXTRA_DATA)
#define XFREE(mtype, ptr) do { zfree ((mtype), (ptr) \
MEMORY_EXTRA_DATA); \
ptr = NULL; } while (0)
#define XSTRDUP(mtype, str) zstrdup ((mtype), (str) \
MEMORY_EXTRA_DATA)
#define SIZE(t,n) (sizeof(t) * (n))
/*------------------------------------------------------------------------------
* Prototypes of memory functions
*/
extern void *zmalloc (mtype_t mtype, size_t size MEMORY_EXTRA_ARGS) ;
extern void *zcalloc (mtype_t mtype, size_t size MEMORY_EXTRA_ARGS) ;
extern void *zrealloc (mtype_t mtype, void *ptr, size_t size
MEMORY_EXTRA_ARGS) ;
extern void zfree (mtype_t mtype, void *ptr MEMORY_EXTRA_ARGS) ;
extern char *zstrdup (mtype_t mtype, const char *str MEMORY_EXTRA_ARGS) ;
extern void* mem_mmap(size_t size) ;
extern void mem_munmap(void* p, size_t size) ;
extern void memory_start(void) ;
extern void memory_init (void);
extern void memory_init_r (void);
extern void memory_finish (void);
extern void log_memstats_stderr (const char *);
/* Return number of allocations outstanding for all memory types */
extern void mem_get_stats(mem_stats_t* mst) ;
/* Return number of allocations outstanding for the given memory type */
extern ulong mem_get_alloc(mem_stats_t* mst, mtype_t mtype) ;
/* Return number of allocations outstanding for the given memory type */
extern ulong mtype_stats_alloc(mtype_t mtype) ;
/* Human friendly string for given byte count */
#define MTYPE_MEMSTR_LEN 20
extern const char *mtype_memstr (char *, size_t, ulong);
#endif /* _ZEBRA_MEMORY_H */
|
