My Project  debian-1:4.1.1-p2+ds-4build2
omDebugTrack.c
Go to the documentation of this file.
1 /*******************************************************************
2  * File: omDebug.c
3  * Purpose: implementation of main omDebug functions
4  * Author: obachman@mathematik.uni-kl.de (Olaf Bachmann)
5  * Created: 11/99
6  *******************************************************************/
7 #include <limits.h>
8 #include <string.h>
9 #include "omConfig.h"
10 #include "omDerivedConfig.h"
11 
12 #ifdef OM_HAVE_TRACK
13 #include "omDefaultConfig.h"
14 #include "omalloc.h"
15 
16 /*******************************************************************
17  *
18  * Declarations
19  *
20  *******************************************************************/
21 omBinPage om_JustFreedPage = NULL;
22 omSpecBin om_SpecTrackBin = NULL;
23 
24 /* number of bytes for padding before addr: needs to > 0 and a multiple of OM_SIZEOF_STRICT_ALIGNMENT */
25 #ifndef OM_MIN_SIZEOF_FRONT_PATTERN
26 #define OM_MIN_SIZEOF_FRONT_PATTERN (OM_MIN_SIZEWOF_FRONT_PATTERN*SIZEOF_STRICT_ALIGNMENT)
27 #endif
28 /* number of bytes for padding after addr: needs to be a multiple of OM_SIZEOF_STRICT_ALIGNMENT */
29 #ifndef OM_MIN_SIZEOF_BACK_PATTERN
30 #define OM_MIN_SIZEOF_BACK_PATTERN (OM_MIN_SIZEWOF_BACK_PATTERN*SIZEOF_STRICT_ALIGNMENT)
31 #endif
32 
33 struct omTrackAddr_s;
34 typedef struct omTrackAddr_s omTrackAddr_t;
35 typedef omTrackAddr_t * omTrackAddr;
36 struct omTrackAddr_s
37 {
38  void* next; /* reserved for page->current queue */
39  char track; /* > 0; determines size of header */
41  #ifdef OM_TRACK_FILE_LINE
42  short alloc_line;
43  const char* alloc_file;
44  #endif
45  #ifdef OM_TRACK_RETURN
46  const char* alloc_r;
47  #endif
48  #ifdef OM_TRACK_BACKTRACE
49  #define OM_TRACK_ADDR_MEM_1 alloc_frames
50 
51  /* track > 1 */
52  char* alloc_frames[OM_MAX_KEPT_FRAMES];
53  #else
54  #define OM_TRACK_ADDR_MEM_1 bin_size
55  #endif
56  #define OM_TRACK_ADDR_MEM_2 bin_size
57 
58  /* track > 2 */
59  void* bin_size;
60  #ifdef OM_TRACK_CUSTOM
61  void* custom;
62  #endif
63  #ifdef OM_TRACK_FILE_LINE
64  #define OM_TRACK_ADDR_MEM_3 free_line
65 
66  /* track > 3 */
67  short free_line;
68  const char* free_file;
69  #endif
70  #ifdef OM_TRACK_RETURN
71  #ifndef OM_TRACK_ADDR_MEM_3
72  #define OM_TRACK_ADDR_MEM_3 free_r
73  #endif
74  const void* free_r;
75  #endif
76  #ifdef OM_TRACK_BACKTRACE
77  #define OM_TRACK_ADDR_MEM_4 free_frames
78 
79  /* track > 4 */
80  void* free_frames[OM_MAX_KEPT_FRAMES];
81  #endif
82 };
83 
84 static omError_t omDoCheckTrackAddr(omTrackAddr d_addr, void* addr, void* bin_size, omTrackFlags_t flags, char level,
85  omError_t report_error, OM_FLR_DECL);
86 static int omCheckFlags(omTrackFlags_t flag);
87 static int omCheckPattern(char* s, char p, size_t size);
88 
89 #define OM_TRACK_MAX 5
90 static struct omTrackAddr_s track_addr; /* this is only needed to determine OM_SIZEOF_TRACK_ADDR(i) */
91 #if 0
92 #define OM_SIZEOF_TRACK_ADDR_1 OM_STRICT_ALIGN_SIZE(((char*)&track_addr.alloc_frames-(char*)&track_addr))
93 #define OM_SIZEOF_TRACK_ADDR_2 OM_STRICT_ALIGN_SIZE(((char*)&track_addr.bin_size-(char*)&track_addr))
94 #define OM_SIZEOF_TRACK_ADDR_3 OM_STRICT_ALIGN_SIZE(((char*)&track_addr.free_line-(char*)&track_addr)+OM_MIN_SIZEOF_FRONT_PATTERN)
95 #define OM_SIZEOF_TRACK_ADDR_4 OM_STRICT_ALIGN_SIZE(((char*)&track_addr.free_frames-(char*)&track_addr)+OM_MIN_SIZEOF_FRONT_PATTERN)
96 #define OM_SIZEOF_TRACK_ADDR_5 OM_STRICT_ALIGN_SIZE(sizeof(struct omTrackAddr_s)+OM_MIN_SIZEOF_FRONT_PATTERN)
97 #endif
98 
99 #define OM_SIZEOF_TRACK_ADDR_1 OM_STRICT_ALIGN_SIZE(((char*)&track_addr.OM_TRACK_ADDR_MEM_1-(char*)&track_addr))
100 #define OM_SIZEOF_TRACK_ADDR_2 OM_STRICT_ALIGN_SIZE(((char*)&track_addr.OM_TRACK_ADDR_MEM_2-(char*)&track_addr))
101 #define OM_SIZEOF_TRACK_ADDR_3 OM_STRICT_ALIGN_SIZE(((char*)&track_addr.OM_TRACK_ADDR_MEM_3-(char*)&track_addr)+OM_MIN_SIZEOF_FRONT_PATTERN)
102 #ifdef OM_TRACK_ADDR_MEM_4
103 #define OM_SIZEOF_TRACK_ADDR_4 OM_STRICT_ALIGN_SIZE(((char*)&track_addr.OM_TRACK_ADDR_MEM_4-(char*)&track_addr)+OM_MIN_SIZEOF_FRONT_PATTERN)
104 #else
105 #define OM_SIZEOF_TRACK_ADDR_4 OM_SIZEOF_TRACK_ADDR_5
106 #endif
107 #define OM_SIZEOF_TRACK_ADDR_5 OM_STRICT_ALIGN_SIZE(sizeof(struct omTrackAddr_s)+OM_MIN_SIZEOF_FRONT_PATTERN)
108 
109 #define OM_SIZEOF_TRACK_ADDR(i) \
110 (i > 3 ? \
111  (i == 4 ? OM_SIZEOF_TRACK_ADDR_4 : OM_SIZEOF_TRACK_ADDR_5) : \
112  (i == 3 ? OM_SIZEOF_TRACK_ADDR_3 : (i == 2 ? OM_SIZEOF_TRACK_ADDR_2 : OM_SIZEOF_TRACK_ADDR_1)))
113 
114 OM_INLINE_LOCAL omTrackAddr omOutAddr_2_TrackAddr(void* addr);
115 
116 #define _omOutSize_2_TrackAddrSize(size, track) \
117  (size + OM_SIZEOF_TRACK_ADDR(track) + (track > 2 ? OM_MIN_SIZEOF_BACK_PATTERN : 0))
118 
119 #define _omTrackAddr_2_SizeOfTrackAddrHeader(d_addr) ((size_t) OM_SIZEOF_TRACK_ADDR(((omTrackAddr) (d_addr))->track))
120 #define _omTrackAddr_2_OutSize(d_addr) \
121  (((omTrackAddr) (d_addr))->track > 2 ? \
122  omTrack3Addr_2_OutSize(d_addr) : omSizeOfBinAddr(d_addr) - omTrackAddr_2_SizeOfTrackAddrHeader(d_addr))
123 #define _omTrack3Addr_2_OutSize(d_addr) \
124  ((((omTrackAddr) (d_addr))->flags & OM_FBIN) ? \
125  (((omBin)((omTrackAddr) (d_addr))->bin_size)->sizeW) << LOG_SIZEOF_LONG : \
126  ((size_t)((omTrackAddr) (d_addr))->bin_size))
127 
128 /* assume track > 2 */
129 #define _omTrackAddr_2_FrontPattern(d_addr) \
130  ((void*)((unsigned long)d_addr + omTrackAddr_2_SizeOfTrackAddrHeader(d_addr) - OM_MIN_SIZEOF_FRONT_PATTERN))
131 #define _omTrackAddr_2_SizeOfFrontPattern(d_addr) \
132  ((char*) omTrackAddr_2_OutAddr(d_addr) - (char*) omTrackAddr_2_FrontPattern(d_addr))
133 #define _omTrackAddr_2_BackPattern(d_addr) \
134  ((char*) ((unsigned long)d_addr + omTrackAddr_2_SizeOfTrackAddrHeader(d_addr) + _omTrack3Addr_2_OutSize(d_addr)))
135 #define _omTrackAddr_2_SizeOfBackPattern(d_addr) \
136  ((char*) d_addr + omSizeOfBinAddr(d_addr) - omTrackAddr_2_BackPattern(d_addr))
137 #define omTrackAddr_2_OutAddr(d_addr) ((void*)((unsigned long)d_addr + omTrackAddr_2_SizeOfTrackAddrHeader(d_addr)))
138 
139 
140 #ifdef OM_INTERNAL_DEBUG
141 static size_t omTrackAddr_2_SizeOfTrackAddrHeader(omTrackAddr d_addr)
142 {
143  size_t size;
144  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr &&
145  d_addr->track > 0 && d_addr->track <= 5);
146  size = _omTrackAddr_2_SizeOfTrackAddrHeader(d_addr);
147  return size;
148 }
149 static void* omTrackAddr_2_FrontPattern(omTrackAddr d_addr)
150 {
151  void* addr;
152  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr &&
153  d_addr->track > 2 && d_addr->track <= 5);
154  addr = _omTrackAddr_2_FrontPattern(d_addr);
155  return addr;
156 }
157 static size_t omTrackAddr_2_SizeOfFrontPattern(omTrackAddr d_addr)
158 {
159  size_t size;
160  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr &&
161  d_addr->track > 2 && d_addr->track <= 5);
162  omAssume((unsigned long) omTrackAddr_2_OutAddr(d_addr) > (unsigned long) omTrackAddr_2_FrontPattern(d_addr));
163  size = _omTrackAddr_2_SizeOfFrontPattern(d_addr);
164  omAssume(size > 0);
165  return size;
166 }
167 static char* omTrackAddr_2_BackPattern(omTrackAddr d_addr)
168 {
169  char* addr;
170  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr &&
171  d_addr->track > 2 && d_addr->track <= 5);
172  addr = _omTrackAddr_2_BackPattern(d_addr);
173  omAssume(OM_ALIGN_SIZE((unsigned long) addr) == (unsigned long) addr);
174  return addr;
175 }
176 static size_t omTrackAddr_2_SizeOfBackPattern(omTrackAddr d_addr)
177 {
178  size_t size;
179  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr &&
180  d_addr->track > 2 && d_addr->track <= 5);
181  size = _omTrackAddr_2_SizeOfBackPattern(d_addr);
182  omAssume(size > 0 && OM_ALIGN_SIZE(size) == size);
183  return size;
184 }
185 static size_t omTrack3Addr_2_OutSize(omTrackAddr d_addr)
186 {
187  size_t size;
188  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr &&
189  d_addr->track > 2 && d_addr->track <= 5);
190  omAssume(d_addr->flags > 0 && d_addr->flags < OM_FMAX &&
191  ! ((d_addr->flags & OM_FBIN) && (d_addr->flags & OM_FSIZE)));
192 
193  size = _omTrack3Addr_2_OutSize(d_addr);
194  return size;
195 }
196 static size_t omTrackAddr_2_OutSize(omTrackAddr d_addr)
197 {
198  size_t size;
199  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr &&
200  d_addr->track > 0 && d_addr->track <= 5);
201 
202  size = _omTrackAddr_2_OutSize(d_addr);
203  return size;
204 }
205 static size_t omOutSize_2_TrackAddrSize(size_t size, char track)
206 {
207  size_t da_size;
208  omAssume(track > 0 && track <= 5);
209  da_size = _omOutSize_2_TrackAddrSize(size, track);
210  return da_size;
211 }
212 #else
213 #define omTrackAddr_2_SizeOfTrackAddrHeader _omTrackAddr_2_SizeOfTrackAddrHeader
214 #define omTrackAddr_2_FrontPattern _omTrackAddr_2_FrontPattern
215 #define omTrackAddr_2_BackPattern _omTrackAddr_2_BackPattern
216 #define omTrack3Addr_2_OutSize _omTrack3Addr_2_OutSize
217 #define omTrackAddr_2_OutSize _omTrackAddr_2_OutSize
218 #define omOutSize_2_TrackAddrSize _omOutSize_2_TrackAddrSize
219 #define omTrackAddr_2_SizeOfFrontPattern _omTrackAddr_2_SizeOfFrontPattern
220 #define omTrackAddr_2_SizeOfBackPattern _omTrackAddr_2_SizeOfBackPattern
221 #endif
222 
223 OM_INLINE_LOCAL omTrackAddr omOutAddr_2_TrackAddr(void* addr)
224 {
225  omTrackAddr d_addr;
226  char* page = omGetPageOfAddr(addr);
227  size_t size = omGetTopBinOfPage((omBinPage) page)->sizeW << LOG_SIZEOF_LONG;
228 
229  omAssume(omIsBinPageAddr(addr));
230 
232  d_addr = (omTrackAddr) ((unsigned long) page + (unsigned long) ((((unsigned long)addr - (unsigned long)page) / size)*size));
233  return d_addr;
234 }
235 
236 size_t omOutSizeOfTrackAddr(void* addr)
237 {
238  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
239  omAssume(omIsTrackAddr(addr));
240  return omTrackAddr_2_OutSize(d_addr);
241 }
242 
243 void* omAddr_2_OutAddr(void* addr)
244 {
245  if (omIsTrackAddr(addr))
246  {
247  return omTrackAddr_2_OutAddr(omOutAddr_2_TrackAddr(addr));
248  }
249  else
250  {
251  return addr;
252  }
253 }
254 
255 /*******************************************************************
256  *
257  * Low level allocation/free routines: do the actual work,
258  * no checks/tests, assume that everything in
259  * environment is ok
260  *
261  *******************************************************************/
262 
263 static omTrackAddr _omAllocTrackAddr(size_t d_size)
264 {
265  omTrackAddr d_addr;
266  omBin bin;
267 
268  if (d_size <= OM_MAX_BLOCK_SIZE)
269  bin = omSmallSize2TrackBin(d_size);
270  else
271  bin = omGetSpecTrackBin(d_size);
272 
273  __omTypeAllocBin(omTrackAddr, d_addr, bin);
274 
275  omAssume(bin->current_page == omGetPageOfAddr(d_addr));
276 
277  omSetTrackOfUsedBlocks(bin->current_page->used_blocks);
278 
279  return d_addr;
280 }
281 void* omAllocTrackAddr(void* bin_size,
282  omTrackFlags_t flags, char track, OM_FLR_DECL)
283 {
284  void* o_addr;
285  size_t o_size = (flags & OM_FBIN ? ((omBin)bin_size)->sizeW << LOG_SIZEOF_LONG :
286  (bin_size != NULL ? OM_ALIGN_SIZE((size_t) bin_size) : OM_ALIGN_SIZE(1)));
287  omTrackAddr d_addr;
288  size_t d_size;
289  if (track <= 0) track = 1;
290  else if (track > 5) track = 5;
291 
292  if ((flags & OM_FBIN) && !omIsStaticNormalBin((omBin)bin_size))
293  /* Need to set track >= 3 such that bin_size is kept: Needed
294  for om_KeptAddr */
295  track = (track > 3 ? track : 3);
296  d_size = omOutSize_2_TrackAddrSize(o_size, track);
297 
298  d_addr = _omAllocTrackAddr(d_size);
299  d_addr->next = (void*)-1;
300  d_addr->track = track;
301  d_addr->flags = flags | OM_FUSED;
302  if (om_Opts.MarkAsStatic)
303  d_addr->flags |= OM_FSTATIC;
304 
305 #ifdef OM_TRACK_FILE_LINE
306  d_addr->alloc_file = f;
307  d_addr->alloc_line = (l > SHRT_MAX || l < 0 ? 0 : l);
308 #endif
309 #ifdef OM_TRACK_RETURN
310  d_addr->alloc_r = r;
311 #endif
312 
313  o_addr = omTrackAddr_2_OutAddr(d_addr);
314  if (track > 1)
315  {
316 #ifdef OM_INTERNAL_DEBUG
317 #define FROM_FRAMES 0
318 #else
319 #define FROM_FRAMES 2
320 #endif
321 
322 #ifdef OM_TRACK_BACKTRACE
323  omGetBackTrace((void **)d_addr->alloc_frames, FROM_FRAMES, OM_MAX_KEPT_FRAMES);
324 #endif
325 
326  if (track > 2)
327  {
328  if (flags & OM_FBIN && ((omBin) bin_size)->sticky)
329  {
330  d_addr->bin_size = (void*)(((omBin) bin_size)->sizeW<<LOG_SIZEOF_LONG);
331  d_addr->flags &= ~OM_FBIN;
332  d_addr->flags |= OM_FSIZE;
333  }
334  else
335  d_addr->bin_size = (flags & OM_FBIN ? bin_size : (void*) o_size);
336  omAssume(OM_ALIGN_SIZE((size_t)d_addr->bin_size) == (size_t) d_addr->bin_size);
337 
338  memset(omTrackAddr_2_FrontPattern(d_addr), OM_FRONT_PATTERN, omTrackAddr_2_SizeOfFrontPattern(d_addr));
339  if (! (flags & OM_FZERO)) memset(o_addr, OM_INIT_PATTERN, o_size);
340  memset(omTrackAddr_2_BackPattern(d_addr), OM_BACK_PATTERN, omTrackAddr_2_SizeOfBackPattern(d_addr));
341 
342 #ifdef OM_TRACK_CUSTOM
343  d_addr->custom = NULL;
344 #endif
345  if (track > 3)
346  {
347 #ifdef OM_TRACK_FILE_LINE
348  d_addr->free_line = -1;
349  d_addr->free_file = (char*) -1;
350 #endif
351 #ifdef OM_TRACK_RETURN
352  d_addr->free_r = (void*) -1;
353 #endif
354 
355 #ifdef OM_TRACK_BACKTRACE
356  if (track > 4)
357  memset(&d_addr->free_frames, 0, OM_MAX_KEPT_FRAMES*SIZEOF_VOIDP);
358 #endif
359  }
360  }
361  }
362  if (flags & OM_FZERO) omMemsetW(o_addr, 0, o_size >> LOG_SIZEOF_LONG);
363  return o_addr;
364 }
365 
366 
367 void* omMarkAsFreeTrackAddr(void* addr, int keep, omTrackFlags_t *flags, OM_FLR_DECL)
368 {
369  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
370  omAssume(omIsTrackAddr(addr));
371 
372  d_addr->next = (void*) -1;
373  if (d_addr->track > 2)
374  {
375  if (d_addr->flags & OM_FUSED)
376  {
377  memset(omTrackAddr_2_OutAddr(d_addr), OM_FREE_PATTERN, omTrackAddr_2_OutSize(d_addr));
378  if (d_addr->track > 3)
379  {
380 #ifdef OM_TRACK_FILE_LINE
381  d_addr->free_line = l;
382  d_addr->free_file = f;
383 #endif
384 #ifdef OM_TRACK_RETURN
385  d_addr->free_r = r;
386 #endif
387 
388 #ifdef OM_TRACK_BACKTRACE
389  if (d_addr->track > 4)
390  omGetBackTrace(d_addr->free_frames, FROM_FRAMES, OM_MAX_KEPT_FRAMES);
391 #endif
392  }
393  }
394  else
395  {
396  omAssume(d_addr->flags & OM_FKEPT);
397  }
398  }
399  if (d_addr->flags & OM_FKEEP) *flags |= OM_FKEEP;
400  d_addr->flags &= ~OM_FUSED;
401  if (keep) d_addr->flags |= OM_FKEPT;
402  else d_addr->flags &= ~OM_FKEPT;
403 
404  return(void*) d_addr;
405 }
406 
407 void omFreeTrackAddr(void* d_addr)
408 {
409  omBinPage page;
410  omBin bin;
411 
412  omAssume(omIsBinPageAddr(d_addr));
413  omAssume(d_addr != NULL && omIsTrackAddr(d_addr));
414  d_addr = omOutAddr_2_TrackAddr(d_addr);
415 
416  page = omGetBinPageOfAddr((void*) d_addr);
417  bin = omGetTopBinOfPage(page);
418  /* Ok, here is how it works:
419  1. we unset the first bit of used_blocks
420  ==> used_blocks >= 0
421  2. we do a normal free
422  3. if page of addr was freed, then om_JustFreedPage
423  is != NULL ==> nothing to be done by us
424  else
425  page is still active ==> reset first bit of used_blocks
426  */
427 
428  omUnsetTrackOfUsedBlocks(page->used_blocks);
429 
430  om_JustFreedPage = NULL;
431 
432  __omFreeBinAddr(d_addr);
433 
434  if (page != om_JustFreedPage)
435  omSetTrackOfUsedBlocks(page->used_blocks);
436  else
437  {
438  /* Still need to check wheter we need to get rid of SpecBin */
439  if (bin->last_page == NULL && ! omIsStaticTrackBin(bin))
440  omDeleteSpecBin(&bin);
441  }
442 }
443 
444 /*******************************************************************
445  *
446  * Checking a Track Addr
447  *
448  *
449  *******************************************************************/
450 
451 omError_t omCheckTrackAddr(void* addr, void* bin_size, omTrackFlags_t flags, char level,
452  omError_t report, OM_FLR_DECL)
453 {
454  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
455  omAssume(omIsTrackAddr(addr));
456  omAssume(! omCheckPtr(addr, 0, OM_FLR));
457 
458  omAddrCheckReturnCorrupted(d_addr->track < 1 || d_addr->track > OM_TRACK_MAX);
459  omAddrCheckReturnError((flags & OM_FUSED) && omTrackAddr_2_OutAddr(d_addr) != addr, omError_FalseAddrOrMemoryCorrupted);
460 
462  level, report, OM_FLR_VAL));
463  return omDoCheckTrackAddr(d_addr, addr, bin_size, flags, level, report, OM_FLR_VAL);
464 }
465 
466 
467 static omError_t omDoCheckTrackAddr(omTrackAddr d_addr, void* addr, void* bin_size, omTrackFlags_t flags, char level,
468  omError_t report, OM_FLR_DECL)
469 {
470  if (flags & OM_FUSED)
471  omAddrCheckReturnError(d_addr->next != ((void*) -1), omError_FreedAddrOrMemoryCorrupted);
472  else
473  omAddrCheckReturnError(d_addr->next != NULL && omCheckPtr(d_addr->next, omError_MaxError, OM_FLR_VAL),
475  omAddrCheckReturnCorrupted(omCheckFlags(d_addr->flags));
476 
479 
480  if (flags & OM_FBINADDR && flags & OM_FSIZE)
481  omAddrCheckReturnError(omTrackAddr_2_OutSize(d_addr) != (size_t) bin_size, omError_WrongSize);
482 
483  if (d_addr->track > 2)
484  {
485  if (d_addr->flags & OM_FBIN)
486  {
487  omAddrCheckReturnCorrupted(!omIsKnownTopBin((omBin) d_addr->bin_size, 1));
488  }
489  else
490  {
491  omAssume(d_addr->flags & OM_FSIZE);
492 
493  omAddrCheckReturnCorrupted(!OM_IS_ALIGNED(d_addr->bin_size));
494  omAddrCheckReturnCorrupted((size_t) d_addr->bin_size >
495  omSizeOfBinAddr(d_addr)
496  - omTrackAddr_2_SizeOfTrackAddrHeader(d_addr)
497  - OM_MIN_SIZEOF_BACK_PATTERN);
498  /* Hmm .. here I'd love to have a stricter bound */
499  omAddrCheckReturnCorrupted((size_t) d_addr->bin_size < SIZEOF_OM_ALIGNMENT);
500  }
501 
502  omAddrCheckReturnError((flags & OM_FBINADDR) && !((d_addr->flags & OM_FBIN) || ((size_t) d_addr->bin_size <= OM_MAX_BLOCK_SIZE)), omError_NotBinAddr);
503 
504  if (flags & OM_FBIN)
505  {
506  if (d_addr->flags & OM_FBIN)
507  omAddrCheckReturnError(((omBin) d_addr->bin_size)->sizeW != ((omBin) bin_size)->sizeW, omError_WrongBin);
508  else
509  omAddrCheckReturnError((((omBin) bin_size)->sizeW << LOG_SIZEOF_LONG) != OM_ALIGN_SIZE((size_t) d_addr->bin_size), omError_WrongBin);
510  }
511  else if (flags & OM_FSIZE)
512  {
513  if (d_addr->flags & OM_FBIN)
514  {
515  omAddrCheckReturnError((((omBin) d_addr->bin_size)->sizeW << LOG_SIZEOF_LONG) < ((size_t) bin_size), omError_WrongSize);
516  }
517  else
518  {
519  omAddrCheckReturnError((size_t) d_addr->bin_size < (size_t) bin_size, omError_WrongSize);
520  }
521  }
522 
523  omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_FrontPattern(d_addr), OM_FRONT_PATTERN,omTrackAddr_2_SizeOfFrontPattern(d_addr)),omError_FrontPattern);
524  omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_BackPattern(d_addr), OM_BACK_PATTERN,omTrackAddr_2_SizeOfBackPattern(d_addr)),omError_BackPattern);
525  if (! (d_addr->flags & OM_FUSED))
526  omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_OutAddr(addr), OM_FREE_PATTERN, omTrackAddr_2_OutSize(d_addr)),omError_FreePattern);
527 
528  if (d_addr->track > 3)
529  {
530 #ifdef OM_TRACK_FILE_LINE
531  if (d_addr->flags & OM_FUSED)
532  {
533  omAddrCheckReturnCorrupted(d_addr->free_line != -1);
534  omAddrCheckReturnCorrupted(d_addr->free_file != (void*) -1);
535  }
536  else
537  {
538  omAddrCheckReturnCorrupted(d_addr->free_line < 0);
539  omAddrCheckReturnCorrupted(d_addr->free_file == (void*) -1);
540  }
541 #endif
542 #ifdef OM_TRACK_RETURN
543  omAddrCheckReturnCorrupted((d_addr->flags & OM_FUSED)
544  && (d_addr->free_r != (void*) -1));
545 #endif
546  }
547  }
548  else
549  {
550  /* track < 2 */
551  if (flags & OM_FBIN)
552  {
553  size_t size = omTrackAddr_2_OutSize(d_addr);
555  omAddrCheckReturnError(size < (((omBin)bin_size)->sizeW<<LOG_SIZEOF_LONG), omError_WrongBin);
556  }
557  else if (flags & OM_FSIZE
558  && (!(flags & OM_FSLOPPY)
559  || (size_t)bin_size > 0))
560  {
561  omAddrCheckReturnError(omTrackAddr_2_OutSize(d_addr) < (size_t) bin_size, omError_WrongSize);
562  }
563  else if (flags & OM_FBINADDR)
564  {
565  size_t size = omTrackAddr_2_OutSize(d_addr);
567  }
568  }
569  return omError_NoError;
570 }
571 
572 static int omCheckFlags(omTrackFlags_t flag)
573 {
574  if (flag > OM_FMAX) return 1;
575  if (! ((flag & OM_FBIN) ^ (flag & OM_FSIZE))) return 1;
576  if (flag & OM_FUSED && flag & OM_FKEPT) return 1;
577  return 0;
578 }
579 
580 static int omCheckPattern(char* s, char p, size_t size)
581 {
582  int i;
583  for (i=0; i<size; i++)
584  {
585  if (s[i] != p)
586  return 1;
587  }
588  return 0;
589 }
590 
591 #ifdef OM_TRACK_BACKTRACE
592 #define OM_ALLOC_FRAMES(d_addr) d_addr->alloc_frames
593 #define OM_FREE_FRAMES(d_addr) d_addr->free_frames
594 #else
595 #define OM_ALLOC_FRAMES(d) NULL
596 #define OM_FREE_FRAMES(d) NULL
597 #endif
598 
599 void omPrintTrackAddrInfo(FILE* fd, void* addr, int max_frames)
600 {
601  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
602  omAssume(d_addr->track > 0);
603  if (max_frames <= 0) return;
604  if (! (d_addr->flags & OM_FUSED))
605  {
606  fputs(" freed\n",fd);
607  return;
608  }
609 
610  if (max_frames > OM_MAX_KEPT_FRAMES) max_frames = OM_MAX_KEPT_FRAMES;
611 
612  fputs(" allocated at ",fd);
613  if (! _omPrintBackTrace((void **)OM_ALLOC_FRAMES(d_addr),
614  (d_addr->track > 1 ? max_frames : 0),
615  fd,
616  OM_FLR_ARG(d_addr->alloc_file, d_addr->alloc_line, d_addr->alloc_r)))
617  fputs(" ??",fd);
618  if (d_addr->track > 1)
619  {
620  if (d_addr->track > 3 && ! (d_addr->flags & OM_FUSED))
621  {
622  fputs("\n freed at ",fd);
623  if (! _omPrintBackTrace(OM_FREE_FRAMES(d_addr),
624  (d_addr->track > 4 ? max_frames : 0),
625  fd,
626  OM_FLR_ARG(d_addr->free_file, d_addr->free_line, d_addr->free_r)))
627  fputs(" ??",fd);
628  }
629  }
630  fputc('\n',fd);
631  fflush(fd);
632 }
633 
634 /*******************************************************************
635  *
636  * Misc routines for marking, etc.
637  *
638  *******************************************************************/
639 int omIsStaticTrackAddr(void* addr)
640 {
641  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
642  omAssume(omIsTrackAddr(addr));
643 
644  return (d_addr->flags & OM_FSTATIC);
645 }
646 
647 omBin omGetOrigSpecBinOfTrackAddr(void* addr)
648 {
649  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
650  omAssume(omIsTrackAddr(addr));
651 
652  if (d_addr->track > 2 && (d_addr->flags & OM_FBIN))
653  {
654  omBin bin = (omBin) d_addr->bin_size;
655  if (omIsSpecBin(bin)) return bin;
656  }
657  return NULL;
658 }
659 
660 void omMarkAsStaticAddr(void* addr)
661 {
662  if (omIsTrackAddr(addr))
663  {
664  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
665  d_addr->flags |= OM_FSTATIC;
666  }
667 }
668 
669 void omUnMarkAsStaticAddr(void* addr)
670 {
671  if (omIsTrackAddr(addr))
672  {
673  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
674  d_addr->flags &= ~OM_FSTATIC;
675  }
676 }
677 
678 static void _omMarkAsStatic(void* addr)
679 {
680  omTrackAddr d_addr = (omTrackAddr) addr;
681  if (!omCheckPtr(addr, omError_MaxError, OM_FLR))
682  {
683  omAssume(omIsTrackAddr(addr) && omOutAddr_2_TrackAddr(addr) == d_addr);
684  d_addr->flags |= OM_FSTATIC;
685  }
686 }
687 
688 static void _omUnMarkAsStatic(void* addr)
689 {
690  omTrackAddr d_addr = (omTrackAddr) addr;
691  omAssume(omIsTrackAddr(addr) && omOutAddr_2_TrackAddr(addr) == d_addr);
692  d_addr->flags &= ~OM_FSTATIC;
693 }
694 
696 {
697  omIterateTroughAddrs(0, 1, _omUnMarkAsStatic, NULL);
698 }
699 
701 {
702  omIterateTroughAddrs(0, 1, _omMarkAsStatic, NULL);
703 }
704 
705 #ifdef OM_TRACK_CUSTOM
706 void omSetCustomOfTrackAddr(void* addr, void* value)
707 {
708  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
709  omAssume(omIsTrackAddr(addr));
710 
711  if (d_addr->track > 2)
712  {
713  d_addr->custom = value;
714  }
715 }
716 
717 void* omGetCustomOfTrackAddr(void* addr)
718 {
719  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
720  omAssume(omIsTrackAddr(addr));
721 
722  if (d_addr->track > 2)
723  {
724  return d_addr->custom;
725  }
726  else
727  {
728  return NULL;
729  }
730 }
731 #endif
732 
733 #endif /* OM_HAVE_TRACK */
734 
735 #ifndef OM_NDEBUG
736 
737 #ifndef OM_HAVE_TRACK
738 #include "omalloc.h"
739 #endif
740 
741 int omIsInKeptAddrList(void* addr)
742 {
743  void* ptr = om_KeptAddr;
744  int ret = 0;
745 
746 #ifdef OM_HAVE_TRACK
747  if (omIsTrackAddr(addr))
748  addr = omOutAddr_2_TrackAddr(addr);
749 #endif
750 
751  if (om_LastKeptAddr != NULL)
752  *((void**) om_LastKeptAddr) = om_AlwaysKeptAddrs;
753 
754  while (ptr != NULL)
755  {
756  if (ptr == addr)
757  {
758  ret = 1; break;
759  }
760  ptr = *((void**) ptr);
761  }
762 
763  if (om_LastKeptAddr != NULL)
764  *((void**) om_LastKeptAddr) = NULL;
765 
766  return ret;
767 }
768 #endif /*!OM_NDEBUG*/
omError_FrontPattern
@ omError_FrontPattern
Definition: omError.h:48
om_AlwaysKeptAddrs
void * om_AlwaysKeptAddrs
Definition: omDebug.c:31
omalloc.h
omError_BackPattern
@ omError_BackPattern
Definition: omError.h:47
omMemsetW
#define omMemsetW(P1, W, L)
Definition: omMemOps.h:161
omTrackFlags_t
unsigned short omTrackFlags_t
Definition: omDebug.h:45
f
FILE * f
Definition: checklibs.c:9
omIsInKeptAddrList
int omIsInKeptAddrList(void *addr)
Definition: omDebugTrack.c:741
OM_FBIN
#define OM_FBIN
Definition: omDebug.h:32
omDeleteSpecBin
#define omDeleteSpecBin(bin_ptr)
Definition: omBin.h:15
omDoCheckBinAddr
omError_t omDoCheckBinAddr(void *addr, void *bin_size, omTrackFlags_t flags, char level, omError_t report, OM_FLR_DECL)
Definition: omDebugCheck.c:198
omIsStaticTrackAddr
#define omIsStaticTrackAddr(addr)
Definition: omDebug.h:150
omGetBackTrace
#define omGetBackTrace(bt, s, max)
Definition: omGetBackTrace.h:15
omAddrCheckReturnError
#define omAddrCheckReturnError(cond, error)
Definition: omDebug.h:186
omIsTrackAddr
#define omIsTrackAddr(addr)
Definition: omDebug.h:12
omIsStaticTrackBin
#define omIsStaticTrackBin(bin)
Definition: omBin.h:56
omError_FreePattern
@ omError_FreePattern
Definition: omError.h:46
OM_FKEPT
#define OM_FKEPT
Definition: omDebug.h:35
__omFreeBinAddr
#define __omFreeBinAddr(addr)
Definition: omAllocPrivate.h:163
level
int level(const CanonicalForm &f)
Definition: canonicalform.h:324
omUnMarkAsStaticAddr
void omUnMarkAsStaticAddr(void *addr)
omIsSpecBin
#define omIsSpecBin(bin)
Definition: omBin.h:47
flags
int status int void size_t count int const void size_t count const char int flags
Definition: si_signals.h:73
omCheckReturn
#define omCheckReturn(cond)
Definition: omDebug.h:170
next
ListNode * next
Definition: janet.h:31
omAssume
#define omAssume(x)
Definition: omError.h:85
i
int i
Definition: cfEzgcd.cc:125
omIsBinPageAddr
#define omIsBinPageAddr(addr)
Definition: omBinPage.h:68
OM_MAX_BLOCK_SIZE
#define OM_MAX_BLOCK_SIZE
Definition: omTables.c:31
omSpecBin
omSpecBin_t * omSpecBin
Definition: omStructs.h:30
OM_FBINADDR
#define OM_FBINADDR
Definition: omDebug.h:40
SIZEOF_OM_BIN_PAGE_HEADER
#define SIZEOF_OM_BIN_PAGE_HEADER
Definition: omAllocPrivate.h:31
OM_FZERO
#define OM_FZERO
Definition: omDebug.h:37
omError_WrongBin
@ omError_WrongBin
Definition: omError.h:38
omError_FalseAddrOrMemoryCorrupted
@ omError_FalseAddrOrMemoryCorrupted
Definition: omError.h:34
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
omCheckPtr
omError_t omCheckPtr(const void *ptr, omError_t report, OM_FLR_DECL)
Definition: omDebugCheck.c:136
_omPrintBackTrace
int _omPrintBackTrace(void **bt, int max, FILE *fd, OM_FLR_DECL)
Definition: omRet2Info.c:200
omError_NoError
@ omError_NoError
Definition: omError.h:27
__omTypeAllocBin
#define __omTypeAllocBin(type, addr, bin)
Definition: omAllocPrivate.h:143
omError_FreedAddr
@ omError_FreedAddr
Definition: omError.h:36
OM_FMAX
#define OM_FMAX
Definition: omDebug.h:44
omError_WrongSize
@ omError_WrongSize
Definition: omError.h:35
omGetBinPageOfAddr
#define omGetBinPageOfAddr(addr)
Definition: omBinPage.h:22
OM_FUSED
#define OM_FUSED
Definition: omDebug.h:34
omMarkMemoryAsStatic
void omMarkMemoryAsStatic()
omGetTopBinOfPage
#define omGetTopBinOfPage(page)
Definition: omAllocPrivate.h:65
omError_FreedAddrOrMemoryCorrupted
@ omError_FreedAddrOrMemoryCorrupted
Definition: omError.h:37
omBin
omBin_t * omBin
Definition: omStructs.h:12
omUnMarkMemoryAsStatic
void omUnMarkMemoryAsStatic()
omGetPageOfAddr
#define omGetPageOfAddr(addr)
Definition: omBinPage.h:19
OM_FSTATIC
#define OM_FSTATIC
Definition: omDebug.h:36
omError_UnknownBin
@ omError_UnknownBin
Definition: omError.h:39
omMarkAsStaticAddr
void omMarkAsStaticAddr(void *addr)
om_Opts
omOpts_t om_Opts
Definition: omOpts.c:11
omIsKnownTopBin
#define omIsKnownTopBin(bin, normal_bin)
Definition: omBin.h:55
omIterateTroughAddrs
void omIterateTroughAddrs(int normal, int track, void(*CallBackUsed)(void *), void(*CallBackFree)(void *))
Definition: omDebugCheck.c:503
NULL
#define NULL
Definition: omList.c:10
omError_NotBinAddr
@ omError_NotBinAddr
Definition: omError.h:40
omIsStaticNormalBin
#define omIsStaticNormalBin(bin)
Definition: omBin.h:43
OM_FSLOPPY
#define OM_FSLOPPY
Definition: omDebug.h:39
l
int l
Definition: cfEzgcd.cc:93
OM_FSIZE
#define OM_FSIZE
Definition: omDebug.h:33
omError_MaxError
@ omError_MaxError
Definition: omError.h:51
omAddr_2_OutAddr
void * omAddr_2_OutAddr(void *addr)
omAddrCheckReturnCorrupted
#define omAddrCheckReturnCorrupted(cond)
Definition: omDebug.h:188
om_KeptAddr
void * om_KeptAddr
Definition: omDebug.c:28
OM_FKEEP
#define OM_FKEEP
Definition: omDebug.h:41
p
int p
Definition: cfModGcd.cc:4019
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
om_LastKeptAddr
void * om_LastKeptAddr
Definition: omDebug.c:30
fd
int status int fd
Definition: si_signals.h:59
omError_t
enum omError_e omError_t
Definition: omError.h:44
if
if(yy_init)
Definition: libparse.cc:1418
omBinPage
omBinPage_t * omBinPage
Definition: omStructs.h:16
omSizeOfBinAddr
#define omSizeOfBinAddr(addr)
Definition: omAllocPrivate.h:97