source: git/omalloc/omDebugTrack.c @ fe7bd4

spielwiese
Last change on this file since fe7bd4 was fe7bd4, checked in by Olaf Bachmann <obachman@…>, 24 years ago
* small changes git-svn-id: file:///usr/local/Singular/svn/trunk@4581 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 22.6 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 *  Version: $Id: omDebugTrack.c,v 1.6 2000-09-12 16:02:18 obachman Exp $
7 *******************************************************************/
8#include <limits.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 *******************************************************************/
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 void*       alloc_r;
47    #endif
48    #ifdef OM_TRACK_BACKTRACE
49      #define OM_TRACK_ADDR_MEM_1 alloc_frames
50
51  /* track > 1 */
52  void*             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(((void*)&track_addr.alloc_frames-(void*)&track_addr))
93#define OM_SIZEOF_TRACK_ADDR_2  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.bin_size-(void*)&track_addr))
94#define OM_SIZEOF_TRACK_ADDR_3  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.free_line-(void*)&track_addr)+OM_MIN_SIZEOF_FRONT_PATTERN)
95#define OM_SIZEOF_TRACK_ADDR_4  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.free_frames-(void*)&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(((void*)&track_addr.OM_TRACK_ADDR_MEM_1-(void*)&track_addr))
100#define OM_SIZEOF_TRACK_ADDR_2  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.OM_TRACK_ADDR_MEM_2-(void*)&track_addr))
101#define OM_SIZEOF_TRACK_ADDR_3  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.OM_TRACK_ADDR_MEM_3-(void*)&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(((void*)&track_addr.OM_TRACK_ADDR_MEM_4-(void*)&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  ((void*) omTrackAddr_2_OutAddr(d_addr) - (void*) omTrackAddr_2_FrontPattern(d_addr))
133#define _omTrackAddr_2_BackPattern(d_addr) \
134  ((void*) ((unsigned long)d_addr + omTrackAddr_2_SizeOfTrackAddrHeader(d_addr) + _omTrack3Addr_2_OutSize(d_addr)))
135#define _omTrackAddr_2_SizeOfBackPattern(d_addr) \
136  ((void*) 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 void* omTrackAddr_2_BackPattern(omTrackAddr d_addr)
168{
169  void* 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  void* 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
243/*******************************************************************
244 * 
245 * Low level allocation/free routines: do the actual work,
246 * no checks/tests, assume that everything in
247 * environment is ok
248 * 
249 *******************************************************************/
250
251static omTrackAddr _omAllocTrackAddr(size_t d_size)
252{
253  omTrackAddr d_addr;
254  omBin bin;
255 
256  if (d_size <= OM_MAX_BLOCK_SIZE)
257    bin = omSmallSize2TrackBin(d_size);
258  else
259    bin = omGetSpecTrackBin(d_size);
260 
261  __omTypeAllocBin(omTrackAddr, d_addr, bin);
262 
263  omAssume(bin->current_page == omGetPageOfAddr(d_addr));
264
265  omSetTrackOfUsedBlocks(bin->current_page->used_blocks);
266 
267  return d_addr;
268}
269void* omAllocTrackAddr(void* bin_size, 
270                       omTrackFlags_t flags, char track, OM_FLR_DECL)
271{
272  void* o_addr;
273  size_t o_size = (flags & OM_FBIN ? ((omBin)bin_size)->sizeW << LOG_SIZEOF_LONG : 
274                   (bin_size != NULL ? OM_ALIGN_SIZE((size_t) bin_size) : OM_ALIGN_SIZE(1)));
275  omTrackAddr d_addr;
276  size_t d_size;
277  if (track <= 0) track = 1;
278  if (track >  5) track = 5;
279 
280  if ((flags & OM_FBIN) && !omIsStaticNormalBin((omBin)bin_size))
281    /* Need to set track >= 3 such that bin_size is kept: Needed
282       for om_KeptAddr */
283    track = (track > 3 ? track : 3);
284  d_size = omOutSize_2_TrackAddrSize(o_size, track);
285   
286  d_addr = _omAllocTrackAddr(d_size);
287  d_addr->next = (void*)-1;
288  d_addr->track = track;
289  d_addr->flags = flags | OM_FUSED;
290  if (om_Opts.MarkAsStatic) 
291    d_addr->flags |= OM_FSTATIC;
292
293#ifdef OM_TRACK_FILE_LINE
294  d_addr->alloc_file = f;
295  d_addr->alloc_line = (l > SHRT_MAX || l < 0 ? 0 : l);
296#endif
297#ifdef OM_TRACK_RETURN
298  d_addr->alloc_r = r;
299#endif 
300   
301  o_addr = omTrackAddr_2_OutAddr(d_addr);
302  if (track > 1)
303  {
304#ifdef OM_INTERNAL_DEBUG
305#define FROM_FRAMES 0
306#else
307#define FROM_FRAMES 2
308#endif
309
310#ifdef OM_TRACK_BACKTRACE
311    omGetBackTrace(d_addr->alloc_frames,  FROM_FRAMES, OM_MAX_KEPT_FRAMES);
312#endif 
313     
314    if (track > 2)
315    {
316      d_addr->bin_size = (flags & OM_FBIN ? bin_size : (void*) o_size);
317      omAssume(OM_ALIGN_SIZE((size_t)d_addr->bin_size) == (size_t) d_addr->bin_size);
318
319      memset(omTrackAddr_2_FrontPattern(d_addr), OM_FRONT_PATTERN, omTrackAddr_2_SizeOfFrontPattern(d_addr));
320      if (! (flags & OM_FZERO)) memset(o_addr, OM_INIT_PATTERN, o_size);
321      memset(omTrackAddr_2_BackPattern(d_addr), OM_BACK_PATTERN, omTrackAddr_2_SizeOfBackPattern(d_addr));
322
323      if (track > 3)
324      {
325#ifdef OM_TRACK_FILE_LINE
326        d_addr->free_line = -1;
327        d_addr->free_file = (char*) -1;
328#endif
329#ifdef OM_TRACK_RETURN
330        d_addr->free_r = (void*) -1;
331#endif       
332
333#ifdef OM_TRACK_BACKTRACE         
334        if (track > 4)
335          memset(&d_addr->free_frames, 0, OM_MAX_KEPT_FRAMES*SIZEOF_VOIDP);
336#endif
337      }
338    }
339  }
340  if (flags & OM_FZERO) omMemsetW(o_addr, 0, o_size >> LOG_SIZEOF_LONG);
341  return o_addr;
342}
343
344
345void* omMarkAsFreeTrackAddr(void* addr, int keep, OM_FLR_DECL)
346{
347  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
348  omAssume(omIsTrackAddr(addr));
349   
350  d_addr->next = (void*) -1;
351  if (d_addr->track > 2)
352  {
353    if (d_addr->flags & OM_FUSED)
354    {
355      memset(omTrackAddr_2_OutAddr(d_addr), OM_FREE_PATTERN, omTrackAddr_2_OutSize(d_addr));
356      if (d_addr->track > 3)
357      {
358#ifdef OM_TRACK_FILE_LINE
359        d_addr->free_line = l;
360        d_addr->free_file = f;
361#endif
362#ifdef OM_TRACK_RETURN
363        d_addr->free_r = r;
364#endif       
365       
366#ifdef OM_TRACK_BACKTRACE     
367        if (d_addr->track > 4)
368          omGetBackTrace(d_addr->free_frames,  FROM_FRAMES, OM_MAX_KEPT_FRAMES);
369#endif 
370      }
371    }
372    else
373    {
374      omAssume(d_addr->flags & OM_FKEPT);
375    }
376  }
377  d_addr->flags &= ~OM_FUSED;
378  if (keep) d_addr->flags |= OM_FKEPT;
379  else d_addr->flags &= ~OM_FKEPT;
380 
381  return(void*) d_addr;
382}
383
384void omFreeTrackAddr(void* d_addr)
385{
386  omBinPage page;
387  omBin bin;
388 
389  omAssume(omIsBinPageAddr(d_addr));
390  omAssume(d_addr != NULL && omIsTrackAddr(d_addr));
391  d_addr = omOutAddr_2_TrackAddr(d_addr);
392 
393  page = omGetBinPageOfAddr((void*) d_addr);
394  bin = omGetTopBinOfPage(page);
395  /* Ok, here is how it works:
396    1. we unset the first bit of used_blocks
397       ==> used_blocks >= 0
398    2. we do a normal free
399    3. if page of addr was freed, then om_JustFreedPage
400          is != NULL ==> nothing to be done by us
401       else
402          page is still active ==> reset first bit of used_blocks
403  */
404
405  omUnsetTrackOfUsedBlocks(page->used_blocks);
406
407  om_JustFreedPage = NULL;
408
409  __omFreeBinAddr(d_addr);
410
411  if (page != om_JustFreedPage)
412    omSetTrackOfUsedBlocks(page->used_blocks);
413  else
414  {
415    /* Still need to check wheter we need to get rid of SpecBin */
416    if (bin->last_page == NULL && ! omIsStaticTrackBin(bin))
417      omDeleteSpecBin(&bin);
418  }
419}
420
421/*******************************************************************
422 * 
423 * Checking a Track Addr
424 *
425 * 
426 *******************************************************************/
427
428omError_t omCheckTrackAddr(void* addr, void* bin_size, omTrackFlags_t flags, char level, 
429                           omError_t report, OM_FLR_DECL)
430{
431  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
432  omAssume(omIsTrackAddr(addr));
433  omAssume(! omCheckPtr(addr, 0, OM_FLR));
434
435  omAddrCheckReturnCorrupted(d_addr->track < 1 || d_addr->track > OM_TRACK_MAX);
436  omAddrCheckReturnError((flags & OM_FUSED) && omTrackAddr_2_OutAddr(d_addr) != addr, omError_FalseAddrOrMemoryCorrupted);
437
438  omCheckReturn(omDoCheckBinAddr(d_addr, 0, (flags & OM_FUSED ? OM_FUSED : (flags & OM_FKEPT ? OM_FKEPT: 0)), 
439                                 level, report, OM_FLR_VAL));
440  return omDoCheckTrackAddr(d_addr, addr, bin_size, flags, level, report, OM_FLR_VAL);
441}
442
443
444static omError_t omDoCheckTrackAddr(omTrackAddr d_addr, void* addr, void* bin_size, omTrackFlags_t flags, char level, 
445                                    omError_t report, OM_FLR_DECL) 
446{
447  if (flags & OM_FUSED)
448    omAddrCheckReturnError(d_addr->next != ((void*) -1), omError_FreedAddrOrMemoryCorrupted);
449  else
450    omAddrCheckReturnError(d_addr->next != NULL && omCheckPtr(d_addr->next, omError_MaxError, OM_FLR_VAL), 
451                           omError_FreedAddrOrMemoryCorrupted);
452  omAddrCheckReturnCorrupted(omCheckFlags(d_addr->flags));
453  omAddrCheckReturnError((d_addr->flags & OM_FUSED) ^ (flags & OM_FUSED), omError_FreedAddrOrMemoryCorrupted);
454
455  if (d_addr->track > 2)
456  {
457    if (d_addr->flags & OM_FBIN)
458    {
459      omAddrCheckReturnCorrupted(!omIsKnownTopBin((omBin) d_addr->bin_size, 1));
460    }
461    else
462    {
463      omAssume(d_addr->flags & OM_FSIZE);
464       
465      omAddrCheckReturnCorrupted(!OM_IS_ALIGNED(d_addr->bin_size));
466      omAddrCheckReturnCorrupted((size_t) d_addr->bin_size >
467                                 omSizeOfBinAddr(d_addr) 
468                                 - omTrackAddr_2_SizeOfTrackAddrHeader(d_addr)
469                                 - OM_MIN_SIZEOF_BACK_PATTERN);
470      /* Hmm .. here I'd love to have a stricter bound */
471      omAddrCheckReturnCorrupted((size_t) d_addr->bin_size < SIZEOF_OM_ALIGNMENT);
472    }
473     
474    omAddrCheckReturnError((flags & OM_FBINADDR) && !((d_addr->flags & OM_FBIN) || ((size_t) d_addr->bin_size <= OM_MAX_BLOCK_SIZE)), omError_NotBinAddr);
475     
476    omAddrCheckReturnError((flags & OM_FBIN) && ( !(d_addr->flags & OM_FBIN) || d_addr->bin_size != bin_size),omError_WrongBin);
477    if (flags & OM_FSIZE)
478    {
479      if (d_addr->flags & OM_FSIZE)
480        omAddrCheckReturnError((size_t) d_addr->bin_size != OM_ALIGN_SIZE((size_t) bin_size), omError_WrongSize);
481      else
482        omAddrCheckReturnError(omTrackAddr_2_OutSize(d_addr) < (size_t) bin_size, omError_WrongSize);
483    }
484
485    omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_FrontPattern(d_addr), OM_FRONT_PATTERN,omTrackAddr_2_SizeOfFrontPattern(d_addr)),omError_FrontPattern);
486    omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_BackPattern(d_addr), OM_BACK_PATTERN,omTrackAddr_2_SizeOfBackPattern(d_addr)),omError_BackPattern);
487    if (! (d_addr->flags & OM_FUSED))
488      omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_OutAddr(addr), OM_FREE_PATTERN, omTrackAddr_2_OutSize(d_addr)),omError_FreePattern);
489
490    if (d_addr->track > 3)
491    {
492#ifdef OM_TRACK_FILE_LINE
493      if (d_addr->flags & OM_FUSED)
494      {
495        omAddrCheckReturnCorrupted(d_addr->free_line != -1);
496        omAddrCheckReturnCorrupted(d_addr->free_file != (void*) -1);
497      }
498      else
499      {
500        omAddrCheckReturnCorrupted(d_addr->free_line < 0);
501        omAddrCheckReturnCorrupted(d_addr->free_file == (void*) -1);
502      }
503#endif
504#ifdef OM_TRACK_RETURN
505      omAddrCheckReturnCorrupted(d_addr->flags & OM_FUSED && d_addr->free_r != (void*) -1);
506#endif       
507    }
508  }
509  else
510  {
511    /* track < 2 */
512    if (flags & OM_FBIN)
513    {
514      size_t size = omTrackAddr_2_OutSize(d_addr);
515      omAddrCheckReturnError(!omIsKnownTopBin((omBin) bin_size, 1), omError_UnknownBin);
516      omAddrCheckReturnError(size < (((omBin)bin_size)->sizeW<<LOG_SIZEOF_LONG), omError_WrongBin);
517    }
518    else if (flags & OM_FSIZE && (!(flags & OM_FSLOPPY)  || bin_size > 0))
519    {
520      omAddrCheckReturnError(omTrackAddr_2_OutSize(d_addr) < (size_t) bin_size, omError_WrongSize);
521    }
522    else if (flags & OM_FBINADDR)
523    {
524      size_t size = omTrackAddr_2_OutSize(d_addr);
525      omAddrCheckReturnError(size > OM_MAX_BLOCK_SIZE, omError_NotBinAddr);
526    }
527  }
528  return omError_NoError;
529}
530     
531static int omCheckFlags(omTrackFlags_t flag)
532{
533  if (flag > OM_FMAX) return 1;
534  if (! ((flag & OM_FBIN) ^ (flag & OM_FSIZE))) return 1;
535  if (flag & OM_FUSED && flag & OM_FKEPT) return 1;
536  return 0;
537}
538
539static int omCheckPattern(char* s, char p, size_t size)
540{
541  int i;
542  for (i=0; i<size; i++)
543  {
544    if (s[i] != p) 
545      return 1;
546  }
547  return 0;
548}
549
550#ifdef OM_TRACK_BACKTRACE
551#define OM_ALLOC_FRAMES(d_addr) d_addr->alloc_frames
552#define OM_FREE_FRAMES(d_addr)  d_addr->free_frames
553#else
554#define OM_ALLOC_FRAMES(d) NULL
555#define OM_FREE_FRAMES(d)  NULL
556#endif
557
558void omPrintTrackAddrInfo(FILE* fd, void* addr)
559{
560  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
561  omAssume(d_addr->track > 0);
562 
563  fprintf(fd, " allocated at ");
564  if (! _omPrintBackTrace(OM_ALLOC_FRAMES(d_addr), 
565                          (d_addr->track > 1 ? OM_MAX_KEPT_FRAMES : 0), 
566                          fd, 
567                          OM_FLR_ARG(d_addr->alloc_file, d_addr->alloc_line, d_addr->alloc_r)))
568    fprintf(fd," ??");
569  if (d_addr->track > 1) 
570  {
571    if (d_addr->track > 3 && ! (d_addr->flags & OM_FUSED))
572    {
573      fprintf(fd, "\n freed at ");
574      if (! _omPrintBackTrace(OM_FREE_FRAMES(d_addr), 
575                          (d_addr->track > 4 ? OM_MAX_KEPT_FRAMES : 0), 
576                          fd, 
577                          OM_FLR_ARG(d_addr->free_file, d_addr->free_line, d_addr->free_r)))
578        fprintf(fd," ??");
579    }
580  }
581  fprintf(fd, "\n");
582  fflush(fd);
583}
584
585/*******************************************************************
586 * 
587 * Misc routines for marking, etc.
588 * 
589 *******************************************************************/
590int omIsStaticTrackAddr(void* addr)
591{
592  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
593  omAssume(omIsTrackAddr(addr));
594
595  return (d_addr->flags & OM_FSTATIC);
596}
597
598omBin omGetOrigSpecBinOfTrackAddr(void* addr)
599{
600  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
601  omAssume(omIsTrackAddr(addr));
602 
603  if (d_addr->track > 2 && (d_addr->flags & OM_FBIN))
604  {
605    omBin bin = (omBin) d_addr->bin_size;
606    if (! omIsStaticNormalBin(bin)) 
607      return bin;
608  }
609  return NULL;
610}
611
612void omMarkAsStaticAddr(void* addr)
613{
614  if (omIsTrackAddr(addr))
615  {
616    omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
617    d_addr->flags |= OM_FSTATIC;
618  }
619}
620
621void omUnMarkAsStaticAddr(void* addr)
622{
623  if (omIsTrackAddr(addr))
624  {
625    omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
626    d_addr->flags &= ~OM_FSTATIC;
627  }
628}
629
630static void _omMarkAsStatic(void* addr)
631{
632  omTrackAddr d_addr = (omTrackAddr) addr;
633  omAssume(omIsTrackAddr(addr) && omOutAddr_2_TrackAddr(addr) == d_addr);
634  d_addr->flags |= OM_FSTATIC;
635}
636
637static void _omUnMarkAsStatic(void* addr)
638{
639  omTrackAddr d_addr = (omTrackAddr) addr;
640  omAssume(omIsTrackAddr(addr) && omOutAddr_2_TrackAddr(addr) == d_addr);
641  d_addr->flags &= ~OM_FSTATIC;
642}
643
644void omUnMarkMemoryAsStatic()
645{
646  omIterateTroughAddrs(0, 1, _omUnMarkAsStatic, NULL);
647}
648
649void omMarkMemoryAsStatic()
650{
651  omIterateTroughAddrs(0, 1, _omMarkAsStatic, NULL);
652}
653
654#ifdef OM_TRACK_CUSTOM
655void omSetCustomOfTrackAddr(void* addr, void* value)
656{
657  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
658  omAssume(omIsTrackAddr(addr));
659 
660  if (d_addr->track > 2)
661  {
662    d_addr->custom = value;
663  }
664}
665
666void* omGetCustomOfTrackAddr(void* addr)
667{
668  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
669  omAssume(omIsTrackAddr(addr));
670 
671  if (d_addr->track > 2)
672  {
673    return d_addr->custom;
674  }
675  else
676  {
677    return NULL;
678  }
679}
680#endif
681
682#endif /* OM_HAVE_TRACK */
Note: See TracBrowser for help on using the repository browser.