source: git/omalloc/omDebugTrack.c @ ba5e9e

spielwiese
Last change on this file since ba5e9e was 6ce030f, checked in by Oleksandr Motsak <motsak@…>, 12 years ago
removal of the $Id$ svn tag from everywhere NOTE: the git SHA1 may be used instead (only on special places) NOTE: the libraries Singular/LIB/*.lib still contain the marker due to our current use of svn
  • Property mode set to 100644
File size: 24.2 KB
Line 
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 <mylimits.h>
8#include <string.h>
9#include <omalloc/omConfig.h>
10#include <omalloc/omDerivedConfig.h>
11
12#ifdef OM_HAVE_TRACK
13#include <omalloc/omDefaultConfig.h>
14#include <omalloc/omalloc.h>
15
16/*******************************************************************
17 *
18 * Declarations
19 *
20 *******************************************************************/
21omBinPage om_JustFreedPage = NULL;
22omSpecBin 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
33struct omTrackAddr_s;
34typedef struct omTrackAddr_s omTrackAddr_t;
35typedef omTrackAddr_t * omTrackAddr;
36struct omTrackAddr_s
37{
38  void*             next;   /* reserved for page->current queue */
39  char              track;  /* > 0; determines size of header */
40  omTrackFlags_t    flags;
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
84static omError_t omDoCheckTrackAddr(omTrackAddr d_addr, void* addr, void* bin_size, omTrackFlags_t flags, char level,
85                                    omError_t report_error, OM_FLR_DECL);
86static int omCheckFlags(omTrackFlags_t flag);
87static int omCheckPattern(char* s, char p, size_t size);
88
89#define OM_TRACK_MAX 5
90static 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
114OM_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
141static 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}
149static 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}
157static 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}
167static 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}
176static 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}
185static 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}
196static 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}
205static 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
223OM_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
231  page += SIZEOF_OM_BIN_PAGE_HEADER;
232  d_addr = (omTrackAddr) ((unsigned long) page + (unsigned long) ((((unsigned long)addr - (unsigned long)page) / size)*size));
233  return d_addr;
234}
235
236size_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
243void* 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
263static 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}
281void* 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  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
367void* 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
407void 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
451omError_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
461  omCheckReturn(omDoCheckBinAddr(d_addr, 0, (flags & OM_FUSED ? OM_FUSED : (flags & OM_FKEPT ? OM_FKEPT: 0)),
462                                 level, report, OM_FLR_VAL));
463  return omDoCheckTrackAddr(d_addr, addr, bin_size, flags, level, report, OM_FLR_VAL);
464}
465
466
467static 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),
474                           omError_FreedAddrOrMemoryCorrupted);
475  omAddrCheckReturnCorrupted(omCheckFlags(d_addr->flags));
476
477  omAddrCheckReturnError(level > 1 && (flags & OM_FUSED) && omIsInKeptAddrList(d_addr), omError_FreedAddr);
478  omAddrCheckReturnError((d_addr->flags & OM_FUSED) ^ (flags & OM_FUSED), omError_FreedAddrOrMemoryCorrupted);
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);
554      omAddrCheckReturnError(!omIsKnownTopBin((omBin) bin_size, 1), omError_UnknownBin);
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);
566      omAddrCheckReturnError(size > OM_MAX_BLOCK_SIZE, omError_NotBinAddr);
567    }
568  }
569  return omError_NoError;
570}
571
572static 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
580static 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
599void 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)) return;
605
606  if (max_frames > OM_MAX_KEPT_FRAMES) max_frames = OM_MAX_KEPT_FRAMES;
607
608  fprintf(fd, " allocated at ");
609  if (! _omPrintBackTrace((void **)OM_ALLOC_FRAMES(d_addr),
610                          (d_addr->track > 1 ? max_frames : 0),
611                          fd,
612                          OM_FLR_ARG(d_addr->alloc_file, d_addr->alloc_line, d_addr->alloc_r)))
613    fprintf(fd," ??");
614  if (d_addr->track > 1)
615  {
616    if (d_addr->track > 3 && ! (d_addr->flags & OM_FUSED))
617    {
618      fprintf(fd, "\n freed at ");
619      if (! _omPrintBackTrace(OM_FREE_FRAMES(d_addr),
620                          (d_addr->track > 4 ? max_frames : 0),
621                          fd,
622                          OM_FLR_ARG(d_addr->free_file, d_addr->free_line, d_addr->free_r)))
623        fprintf(fd," ??");
624    }
625  }
626  fprintf(fd, "\n");
627  fflush(fd);
628}
629
630/*******************************************************************
631 *
632 * Misc routines for marking, etc.
633 *
634 *******************************************************************/
635int omIsStaticTrackAddr(void* addr)
636{
637  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
638  omAssume(omIsTrackAddr(addr));
639
640  return (d_addr->flags & OM_FSTATIC);
641}
642
643omBin omGetOrigSpecBinOfTrackAddr(void* addr)
644{
645  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
646  omAssume(omIsTrackAddr(addr));
647
648  if (d_addr->track > 2 && (d_addr->flags & OM_FBIN))
649  {
650    omBin bin = (omBin) d_addr->bin_size;
651    if (omIsSpecBin(bin)) return bin;
652  }
653  return NULL;
654}
655
656void omMarkAsStaticAddr(void* addr)
657{
658  if (omIsTrackAddr(addr))
659  {
660    omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
661    d_addr->flags |= OM_FSTATIC;
662  }
663}
664
665void omUnMarkAsStaticAddr(void* addr)
666{
667  if (omIsTrackAddr(addr))
668  {
669    omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
670    d_addr->flags &= ~OM_FSTATIC;
671  }
672}
673
674static void _omMarkAsStatic(void* addr)
675{
676  omTrackAddr d_addr = (omTrackAddr) addr;
677  if (!omCheckPtr(addr, omError_MaxError, OM_FLR))
678  { 
679    omAssume(omIsTrackAddr(addr) && omOutAddr_2_TrackAddr(addr) == d_addr);
680    d_addr->flags |= OM_FSTATIC;
681  } 
682}
683
684static void _omUnMarkAsStatic(void* addr)
685{
686  omTrackAddr d_addr = (omTrackAddr) addr;
687  omAssume(omIsTrackAddr(addr) && omOutAddr_2_TrackAddr(addr) == d_addr);
688  d_addr->flags &= ~OM_FSTATIC;
689}
690
691void omUnMarkMemoryAsStatic()
692{
693  omIterateTroughAddrs(0, 1, _omUnMarkAsStatic, NULL);
694}
695
696void omMarkMemoryAsStatic()
697{
698  omIterateTroughAddrs(0, 1, _omMarkAsStatic, NULL);
699}
700
701#ifdef OM_TRACK_CUSTOM
702void omSetCustomOfTrackAddr(void* addr, void* value)
703{
704  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
705  omAssume(omIsTrackAddr(addr));
706
707  if (d_addr->track > 2)
708  {
709    d_addr->custom = value;
710  }
711}
712
713void* omGetCustomOfTrackAddr(void* addr)
714{
715  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
716  omAssume(omIsTrackAddr(addr));
717
718  if (d_addr->track > 2)
719  {
720    return d_addr->custom;
721  }
722  else
723  {
724    return NULL;
725  }
726}
727#endif
728
729#endif /* OM_HAVE_TRACK */
730
731#ifndef OM_NDEBUG
732
733#ifndef OM_HAVE_TRACK
734#include <omalloc/omalloc.h>
735#endif
736
737int omIsInKeptAddrList(void* addr)
738{
739  void* ptr = om_KeptAddr;
740  int ret = 0;
741
742#ifdef OM_HAVE_TRACK
743  if (omIsTrackAddr(addr))
744    addr = omOutAddr_2_TrackAddr(addr);
745#endif
746
747  if (om_LastKeptAddr != NULL)
748    *((void**) om_LastKeptAddr) = om_AlwaysKeptAddrs;
749
750  while (ptr != NULL)
751  {
752    if (ptr == addr)
753    {
754      ret = 1; break;
755    }
756    ptr = *((void**) ptr);
757  }
758
759  if (om_LastKeptAddr != NULL)
760    *((void**) om_LastKeptAddr) = NULL;
761
762  return ret;
763}
764#endif /*!OM_NDEBUG*/
Note: See TracBrowser for help on using the repository browser.