dhcpd-pools  2.28
ISC dhcpd lease usage analyser
xalloc.h
Go to the documentation of this file.
1 /* xalloc.h -- malloc with out-of-memory checking
2 
3  Copyright (C) 1990-2000, 2003-2004, 2006-2015 Free Software Foundation, Inc.
4 
5  This program is free software: you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; either version 3 of the License, or
8  (at your option) any later version.
9 
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  GNU General Public License for more details.
14 
15  You should have received a copy of the GNU General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 
18 #ifndef XALLOC_H_
19 #define XALLOC_H_
20 
21 #include <stddef.h>
22 
23 #include "xalloc-oversized.h"
24 
25 #ifndef _GL_INLINE_HEADER_BEGIN
26  #error "Please include config.h first."
27 #endif
29 #ifndef XALLOC_INLINE
30 # define XALLOC_INLINE _GL_INLINE
31 #endif
32 
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
36 
37 
38 #if __GNUC__ >= 3
39 # define _GL_ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
40 #else
41 # define _GL_ATTRIBUTE_MALLOC
42 #endif
43 
44 #if ! defined __clang__ && \
45  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
46 # define _GL_ATTRIBUTE_ALLOC_SIZE(args) __attribute__ ((__alloc_size__ args))
47 #else
48 # define _GL_ATTRIBUTE_ALLOC_SIZE(args)
49 #endif
50 
51 /* This function is always triggered when memory is exhausted.
52  It must be defined by the application, either explicitly
53  or by using gnulib's xalloc-die module. This is the
54  function to call when one wants the program to die because of a
55  memory allocation failure. */
56 extern _Noreturn void xalloc_die (void);
57 
58 void *xmalloc (size_t s)
60 void *xzalloc (size_t s)
62 void *xcalloc (size_t n, size_t s)
64 void *xrealloc (void *p, size_t s)
66 void *x2realloc (void *p, size_t *pn);
67 void *xmemdup (void const *p, size_t s)
69 char *xstrdup (char const *str)
71 
72 /* In the following macros, T must be an elementary or structure/union or
73  typedef'ed type, or a pointer to such a type. To apply one of the
74  following macros to a function pointer or array type, you need to typedef
75  it first and use the typedef name. */
76 
77 /* Allocate an object of type T dynamically, with error checking. */
78 /* extern t *XMALLOC (typename t); */
79 #define XMALLOC(t) ((t *) xmalloc (sizeof (t)))
80 
81 /* Allocate memory for N elements of type T, with error checking. */
82 /* extern t *XNMALLOC (size_t n, typename t); */
83 #define XNMALLOC(n, t) \
84  ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t))))
85 
86 /* Allocate an object of type T dynamically, with error checking,
87  and zero it. */
88 /* extern t *XZALLOC (typename t); */
89 #define XZALLOC(t) ((t *) xzalloc (sizeof (t)))
90 
91 /* Allocate memory for N elements of type T, with error checking,
92  and zero it. */
93 /* extern t *XCALLOC (size_t n, typename t); */
94 #define XCALLOC(n, t) \
95  ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t))))
96 
97 
98 /* Allocate an array of N objects, each with S bytes of memory,
99  dynamically, with error checking. S must be nonzero. */
100 
101 XALLOC_INLINE void *xnmalloc (size_t n, size_t s)
102  _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1, 2));
103 XALLOC_INLINE void *
104 xnmalloc (size_t n, size_t s)
105 {
106  if (xalloc_oversized (n, s))
107  xalloc_die ();
108  return xmalloc (n * s);
109 }
110 
111 /* Change the size of an allocated block of memory P to an array of N
112  objects each of S bytes, with error checking. S must be nonzero. */
113 
114 XALLOC_INLINE void *xnrealloc (void *p, size_t n, size_t s)
115  _GL_ATTRIBUTE_ALLOC_SIZE ((2, 3));
116 XALLOC_INLINE void *
117 xnrealloc (void *p, size_t n, size_t s)
118 {
119  if (xalloc_oversized (n, s))
120  xalloc_die ();
121  return xrealloc (p, n * s);
122 }
123 
124 /* If P is null, allocate a block of at least *PN such objects;
125  otherwise, reallocate P so that it contains more than *PN objects
126  each of S bytes. S must be nonzero. Set *PN to the new number of
127  objects, and return the pointer to the new block. *PN is never set
128  to zero, and the returned pointer is never null.
129 
130  Repeated reallocations are guaranteed to make progress, either by
131  allocating an initial block with a nonzero size, or by allocating a
132  larger block.
133 
134  In the following implementation, nonzero sizes are increased by a
135  factor of approximately 1.5 so that repeated reallocations have
136  O(N) overall cost rather than O(N**2) cost, but the
137  specification for this function does not guarantee that rate.
138 
139  Here is an example of use:
140 
141  int *p = NULL;
142  size_t used = 0;
143  size_t allocated = 0;
144 
145  void
146  append_int (int value)
147  {
148  if (used == allocated)
149  p = x2nrealloc (p, &allocated, sizeof *p);
150  p[used++] = value;
151  }
152 
153  This causes x2nrealloc to allocate a block of some nonzero size the
154  first time it is called.
155 
156  To have finer-grained control over the initial size, set *PN to a
157  nonzero value before calling this function with P == NULL. For
158  example:
159 
160  int *p = NULL;
161  size_t used = 0;
162  size_t allocated = 0;
163  size_t allocated1 = 1000;
164 
165  void
166  append_int (int value)
167  {
168  if (used == allocated)
169  {
170  p = x2nrealloc (p, &allocated1, sizeof *p);
171  allocated = allocated1;
172  }
173  p[used++] = value;
174  }
175 
176  */
177 
178 XALLOC_INLINE void *
179 x2nrealloc (void *p, size_t *pn, size_t s)
180 {
181  size_t n = *pn;
182 
183  if (! p)
184  {
185  if (! n)
186  {
187  /* The approximate size to use for initial small allocation
188  requests, when the invoking code specifies an old size of
189  zero. This is the largest "small" request for the GNU C
190  library malloc. */
191  enum { DEFAULT_MXFAST = 64 * sizeof (size_t) / 4 };
192 
193  n = DEFAULT_MXFAST / s;
194  n += !n;
195  }
196  }
197  else
198  {
199  /* Set N = floor (1.5 * N) + 1 so that progress is made even if N == 0.
200  Check for overflow, so that N * S stays in size_t range.
201  The check may be slightly conservative, but an exact check isn't
202  worth the trouble. */
203  if ((size_t) -1 / 3 * 2 / s <= n)
204  xalloc_die ();
205  n += n / 2 + 1;
206  }
207 
208  *pn = n;
209  return xrealloc (p, n * s);
210 }
211 
212 /* Return a pointer to a new buffer of N bytes. This is like xmalloc,
213  except it returns char *. */
214 
215 XALLOC_INLINE char *xcharalloc (size_t n)
216  _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
217 XALLOC_INLINE char *
218 xcharalloc (size_t n)
219 {
220  return XNMALLOC (n, char);
221 }
222 
223 #ifdef __cplusplus
224 }
225 
226 /* C++ does not allow conversions from void * to other pointer types
227  without a cast. Use templates to work around the problem when
228  possible. */
229 
230 template <typename T> inline T *
231 xrealloc (T *p, size_t s)
232 {
233  return (T *) xrealloc ((void *) p, s);
234 }
235 
236 template <typename T> inline T *
237 xnrealloc (T *p, size_t n, size_t s)
238 {
239  return (T *) xnrealloc ((void *) p, n, s);
240 }
241 
242 template <typename T> inline T *
243 x2realloc (T *p, size_t *pn)
244 {
245  return (T *) x2realloc ((void *) p, pn);
246 }
247 
248 template <typename T> inline T *
249 x2nrealloc (T *p, size_t *pn, size_t s)
250 {
251  return (T *) x2nrealloc ((void *) p, pn, s);
252 }
253 
254 template <typename T> inline T *
255 xmemdup (T const *p, size_t s)
256 {
257  return (T *) xmemdup ((void const *) p, s);
258 }
259 
260 #endif
261 
263 
264 #endif /* !XALLOC_H_ */
void * xmalloc(size_t s) _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE((1))
Definition: xmalloc.c:39
void void * xrealloc(void *p, size_t s) _GL_ATTRIBUTE_ALLOC_SIZE((2))
Definition: xmalloc.c:51
void * x2realloc(void *p, size_t *pn)
Definition: xmalloc.c:74
#define _Noreturn
Definition: config.h:1608
#define XNMALLOC(n, t)
Definition: xalloc.h:83
#define XALLOC_INLINE
Definition: xalloc.h:30
void * xmemdup(void const *p, size_t s) _GL_ATTRIBUTE_ALLOC_SIZE((2))
Definition: xmalloc.c:111
void * xzalloc(size_t s) _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE((1))
Definition: xmalloc.c:84
_Noreturn void xalloc_die(void)
Definition: xalloc-die.c:32
#define _GL_ATTRIBUTE_ALLOC_SIZE(args)
Definition: xalloc.h:48
XALLOC_INLINE void * xnmalloc(size_t n, size_t s) _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE((1
Definition: xalloc.h:104
XALLOC_INLINE void * xnrealloc(void *p, size_t n, size_t s) _GL_ATTRIBUTE_ALLOC_SIZE((2
Definition: xalloc.h:117
#define _GL_INLINE_HEADER_BEGIN
Definition: config.h:1720
#define xalloc_oversized(n, s)
Definition: xalloc-oversized.h:43
#define _GL_ATTRIBUTE_MALLOC
Definition: xalloc.h:41
void * xcalloc(size_t n, size_t s) _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE((1
XALLOC_INLINE void * x2nrealloc(void *p, size_t *pn, size_t s)
Definition: xalloc.h:179
char * xstrdup(char const *str) _GL_ATTRIBUTE_MALLOC
Definition: xmalloc.c:119
#define _GL_INLINE_HEADER_END
Definition: config.h:1721
Definition: time_rz.c:43
XALLOC_INLINE char * xcharalloc(size_t n) _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE((1))
Definition: xalloc.h:218