source: git/omalloc/omDebugTrack.c @ 91c4012

spielwiese
Last change on this file since 91c4012 was 91c4012, checked in by Olaf Bachmann <obachman@…>, 24 years ago
* added omFreeBinAddr git-svn-id: file:///usr/local/Singular/svn/trunk@4543 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 21.9 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.4 2000-08-18 09:05:52 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_FILE_LINE
61      #define OM_TRACK_ADDR_MEM_3 free_line
62
63  /* track > 3 */
64  short             free_line;
65  const char*       free_file;
66    #endif
67    #ifdef OM_TRACK_RETURN
68       #ifndef OM_TRACK_ADDR_MEM_3
69       #define OM_TRACK_ADDR_MEM_3 free_r
70       #endif
71  const void*       free_r;
72    #endif
73    #ifdef OM_TRACK_BACKTRACE
74      #define OM_TRACK_ADDR_MEM_4 free_frames
75
76  /* track > 4 */
77  void*             free_frames[OM_MAX_KEPT_FRAMES];
78    #endif
79};
80
81static omError_t omDoCheckTrackAddr(omTrackAddr d_addr, void* addr, void* bin_size, omTrackFlags_t flags, char level, 
82                                    omError_t report_error, OM_FLR_DECL);
83static int omCheckFlags(omTrackFlags_t flag);
84static int omCheckPattern(char* s, char p, size_t size);
85
86#define OM_TRACK_MAX 5
87static struct omTrackAddr_s track_addr; /* this is only needed to determine OM_SIZEOF_TRACK_ADDR(i) */
88#if 0
89#define OM_SIZEOF_TRACK_ADDR_1  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.alloc_frames-(void*)&track_addr))
90#define OM_SIZEOF_TRACK_ADDR_2  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.bin_size-(void*)&track_addr))
91#define OM_SIZEOF_TRACK_ADDR_3  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.free_line-(void*)&track_addr)+OM_MIN_SIZEOF_FRONT_PATTERN)
92#define OM_SIZEOF_TRACK_ADDR_4  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.free_frames-(void*)&track_addr)+OM_MIN_SIZEOF_FRONT_PATTERN)
93#define OM_SIZEOF_TRACK_ADDR_5  OM_STRICT_ALIGN_SIZE(sizeof(struct omTrackAddr_s)+OM_MIN_SIZEOF_FRONT_PATTERN)
94#endif
95
96#define OM_SIZEOF_TRACK_ADDR_1  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.OM_TRACK_ADDR_MEM_1-(void*)&track_addr))
97#define OM_SIZEOF_TRACK_ADDR_2  OM_STRICT_ALIGN_SIZE(((void*)&track_addr.OM_TRACK_ADDR_MEM_2-(void*)&track_addr))
98#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)
99#ifdef OM_TRACK_ADDR_MEM_4
100#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)
101#else
102#define OM_SIZEOF_TRACK_ADDR_4 OM_SIZEOF_TRACK_ADDR_5
103#endif
104#define OM_SIZEOF_TRACK_ADDR_5  OM_STRICT_ALIGN_SIZE(sizeof(struct omTrackAddr_s)+OM_MIN_SIZEOF_FRONT_PATTERN)
105
106#define OM_SIZEOF_TRACK_ADDR(i)                                                                     \
107(i > 3 ?                                                                                            \
108 (i == 4 ? OM_SIZEOF_TRACK_ADDR_4 : OM_SIZEOF_TRACK_ADDR_5) :                                       \
109  (i == 3 ? OM_SIZEOF_TRACK_ADDR_3 :  (i == 2 ? OM_SIZEOF_TRACK_ADDR_2 : OM_SIZEOF_TRACK_ADDR_1)))
110
111OM_INLINE_LOCAL omTrackAddr omOutAddr_2_TrackAddr(void* addr);
112
113#define _omOutSize_2_TrackAddrSize(size, track)                                                     \
114  (size + OM_SIZEOF_TRACK_ADDR(track) + (track > 2 ? OM_MIN_SIZEOF_BACK_PATTERN : 0))
115
116#define _omTrackAddr_2_SizeOfTrackAddrHeader(d_addr) ((size_t) OM_SIZEOF_TRACK_ADDR(((omTrackAddr) (d_addr))->track))
117#define _omTrackAddr_2_OutSize(d_addr)                                                                      \
118  (((omTrackAddr) (d_addr))->track > 2 ?                                                                    \
119   omTrack3Addr_2_OutSize(d_addr) : omSizeOfBinAddr(d_addr) - omTrackAddr_2_SizeOfTrackAddrHeader(d_addr))
120#define _omTrack3Addr_2_OutSize(d_addr)                                         \
121  ((((omTrackAddr) (d_addr))->flags & OM_FBIN) ?                            \
122   (((omBin)((omTrackAddr) (d_addr))->bin_size)->sizeW) << LOG_SIZEOF_LONG :    \
123   ((size_t)((omTrackAddr) (d_addr))->bin_size))
124
125/* assume track > 2 */
126#define _omTrackAddr_2_FrontPattern(d_addr) \
127          ((void*)((unsigned long)d_addr + omTrackAddr_2_SizeOfTrackAddrHeader(d_addr) - OM_MIN_SIZEOF_FRONT_PATTERN))
128#define _omTrackAddr_2_SizeOfFrontPattern(d_addr) \
129  ((void*) omTrackAddr_2_OutAddr(d_addr) - (void*) omTrackAddr_2_FrontPattern(d_addr))
130#define _omTrackAddr_2_BackPattern(d_addr) \
131  ((void*) ((unsigned long)d_addr + omTrackAddr_2_SizeOfTrackAddrHeader(d_addr) + _omTrack3Addr_2_OutSize(d_addr)))
132#define _omTrackAddr_2_SizeOfBackPattern(d_addr) \
133  ((void*) d_addr + omSizeOfBinAddr(d_addr) - omTrackAddr_2_BackPattern(d_addr))
134#define omTrackAddr_2_OutAddr(d_addr) ((void*)((unsigned long)d_addr + omTrackAddr_2_SizeOfTrackAddrHeader(d_addr)))
135
136
137#ifdef OM_INTERNAL_DEBUG
138static size_t omTrackAddr_2_SizeOfTrackAddrHeader(omTrackAddr d_addr)
139{
140  size_t size;
141  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr && 
142           d_addr->track > 0 && d_addr->track <= 5);
143  size = _omTrackAddr_2_SizeOfTrackAddrHeader(d_addr);
144  return size;
145}
146static void* omTrackAddr_2_FrontPattern(omTrackAddr d_addr)
147{
148  void* addr;
149  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr && 
150           d_addr->track > 2 && d_addr->track <= 5);
151  addr = _omTrackAddr_2_FrontPattern(d_addr);
152  return addr;
153}
154static size_t omTrackAddr_2_SizeOfFrontPattern(omTrackAddr d_addr)
155{
156  size_t size;
157  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr && 
158           d_addr->track > 2 && d_addr->track <= 5);
159  omAssume((unsigned long) omTrackAddr_2_OutAddr(d_addr) > (unsigned long) omTrackAddr_2_FrontPattern(d_addr));
160  size = _omTrackAddr_2_SizeOfFrontPattern(d_addr);
161  omAssume(size > 0);
162  return size;
163}
164static void* omTrackAddr_2_BackPattern(omTrackAddr d_addr)
165{
166  void* addr;
167  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr && 
168           d_addr->track > 2 && d_addr->track <= 5);
169  addr = _omTrackAddr_2_BackPattern(d_addr);
170  omAssume(OM_ALIGN_SIZE((unsigned long) addr) == (unsigned long) addr);
171  return addr;
172}
173static size_t omTrackAddr_2_SizeOfBackPattern(omTrackAddr d_addr)
174{
175  size_t size;
176  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr && 
177           d_addr->track > 2 && d_addr->track <= 5);
178  size = _omTrackAddr_2_SizeOfBackPattern(d_addr);
179  omAssume(size > 0 && OM_ALIGN_SIZE(size) == size);
180  return size;
181}
182static size_t omTrack3Addr_2_OutSize(omTrackAddr d_addr)
183{
184  size_t size;
185  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr && 
186           d_addr->track > 2 && d_addr->track <= 5);
187  omAssume(d_addr->flags > 0 && d_addr->flags < OM_FMAX &&
188           ! ((d_addr->flags & OM_FBIN) && (d_addr->flags & OM_FSIZE)));
189 
190  size = _omTrack3Addr_2_OutSize(d_addr);
191  return size;
192}
193static size_t omTrackAddr_2_OutSize(omTrackAddr d_addr)
194{
195  size_t size;
196  omAssume(omIsTrackAddr(d_addr) && omOutAddr_2_TrackAddr(d_addr) == d_addr && 
197           d_addr->track > 0 && d_addr->track <= 5);
198 
199  size = _omTrackAddr_2_OutSize(d_addr);
200  return size;
201}
202static size_t omOutSize_2_TrackAddrSize(size_t size, char track)
203{
204  size_t da_size;
205  omAssume(track > 0 && track <= 5);
206  da_size = _omOutSize_2_TrackAddrSize(size, track);
207  return da_size;
208}
209#else
210#define omTrackAddr_2_SizeOfTrackAddrHeader _omTrackAddr_2_SizeOfTrackAddrHeader
211#define omTrackAddr_2_FrontPattern          _omTrackAddr_2_FrontPattern
212#define omTrackAddr_2_BackPattern           _omTrackAddr_2_BackPattern
213#define omTrack3Addr_2_OutSize              _omTrack3Addr_2_OutSize
214#define omTrackAddr_2_OutSize               _omTrackAddr_2_OutSize
215#define omOutSize_2_TrackAddrSize           _omOutSize_2_TrackAddrSize
216#define omTrackAddr_2_SizeOfFrontPattern     _omTrackAddr_2_SizeOfFrontPattern
217#define omTrackAddr_2_SizeOfBackPattern     _omTrackAddr_2_SizeOfBackPattern
218#endif
219
220OM_INLINE_LOCAL omTrackAddr omOutAddr_2_TrackAddr(void* addr)
221{
222  omTrackAddr d_addr;
223  void* page = omGetPageOfAddr(addr);
224  size_t size = omGetTopBinOfPage((omBinPage) page)->sizeW << LOG_SIZEOF_LONG;
225
226  omAssume(omIsBinPageAddr(addr));
227
228  page += SIZEOF_OM_BIN_PAGE_HEADER;
229  d_addr = (omTrackAddr) ((unsigned long) page + (unsigned long) ((((unsigned long)addr - (unsigned long)page) / size)*size));
230  return d_addr;
231}
232 
233size_t omOutSizeOfTrackAddr(void* addr)
234{
235  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
236  omAssume(omIsTrackAddr(addr));
237  return omTrackAddr_2_OutSize(d_addr);
238}
239
240/*******************************************************************
241 * 
242 * Low level allocation/free routines: do the actual work,
243 * no checks/tests, assume that everything in
244 * environment is ok
245 * 
246 *******************************************************************/
247
248static omTrackAddr _omAllocTrackAddr(size_t d_size)
249{
250  omTrackAddr d_addr;
251  omBin bin;
252 
253  if (d_size <= OM_MAX_BLOCK_SIZE)
254    bin = omSmallSize2TrackBin(d_size);
255  else
256    bin = omGetSpecTrackBin(d_size);
257 
258  __omTypeAllocBin(omTrackAddr, d_addr, bin);
259 
260  omAssume(bin->current_page == omGetPageOfAddr(d_addr));
261
262  omSetTrackOfUsedBlocks(bin->current_page->used_blocks);
263 
264  return d_addr;
265}
266void* omAllocTrackAddr(void* bin_size, 
267                       omTrackFlags_t flags, char track, OM_FLR_DECL)
268{
269  void* o_addr;
270  size_t o_size = (flags & OM_FBIN ? ((omBin)bin_size)->sizeW << LOG_SIZEOF_LONG : 
271                   (bin_size != NULL ? OM_ALIGN_SIZE((size_t) bin_size) : OM_ALIGN_SIZE(1)));
272  omTrackAddr d_addr;
273  size_t d_size;
274  if (track <= 0) track = 1;
275  if (track >  5) track = 5;
276 
277  if ((flags & OM_FBIN) && !omIsStaticNormalBin((omBin)bin_size))
278    /* Need to set track >= 3 such that bin_size is kept: Needed
279       for om_KeptAddr */
280    track = (track > 3 ? track : 3);
281  d_size = omOutSize_2_TrackAddrSize(o_size, track);
282   
283  d_addr = _omAllocTrackAddr(d_size);
284  d_addr->next = (void*)-1;
285  d_addr->track = track;
286  d_addr->flags = flags | OM_FUSED;
287  if (om_Opts.MarkAsStatic) 
288    d_addr->flags |= OM_FSTATIC;
289
290#ifdef OM_TRACK_FILE_LINE
291  d_addr->alloc_file = f;
292  d_addr->alloc_line = (l > SHRT_MAX || l < 0 ? 0 : l);
293#endif
294#ifdef OM_TRACK_RETURN
295  d_addr->alloc_r = r;
296#endif 
297   
298  o_addr = omTrackAddr_2_OutAddr(d_addr);
299  if (track > 1)
300  {
301#ifdef OM_INTERNAL_DEBUG
302#define FROM_FRAMES 0
303#else
304#define FROM_FRAMES 2
305#endif
306
307#ifdef OM_TRACK_BACKTRACE
308    omGetBackTrace(d_addr->alloc_frames,  FROM_FRAMES, OM_MAX_KEPT_FRAMES);
309#endif 
310     
311    if (track > 2)
312    {
313      d_addr->bin_size = (flags & OM_FBIN ? bin_size : (void*) o_size);
314      omAssume(OM_ALIGN_SIZE((size_t)d_addr->bin_size) == (size_t) d_addr->bin_size);
315
316      memset(omTrackAddr_2_FrontPattern(d_addr), OM_FRONT_PATTERN, omTrackAddr_2_SizeOfFrontPattern(d_addr));
317      if (! (flags & OM_FZERO)) memset(o_addr, OM_INIT_PATTERN, o_size);
318      memset(omTrackAddr_2_BackPattern(d_addr), OM_BACK_PATTERN, omTrackAddr_2_SizeOfBackPattern(d_addr));
319
320      if (track > 3)
321      {
322#ifdef OM_TRACK_FILE_LINE
323        d_addr->free_line = -1;
324        d_addr->free_file = (char*) -1;
325#endif
326#ifdef OM_TRACK_RETURN
327        d_addr->free_r = (void*) -1;
328#endif       
329
330#ifdef OM_TRACK_BACKTRACE         
331        if (track > 4)
332          memset(&d_addr->free_frames, 0, OM_MAX_KEPT_FRAMES*SIZEOF_VOIDP);
333#endif
334      }
335    }
336  }
337  if (flags & OM_FZERO) omMemsetW(o_addr, 0, o_size >> LOG_SIZEOF_LONG);
338  return o_addr;
339}
340
341
342void* omMarkAsFreeTrackAddr(void* addr, int keep, OM_FLR_DECL)
343{
344  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
345  omAssume(omIsTrackAddr(addr));
346   
347  d_addr->next = (void*) -1;
348  if (d_addr->track > 2)
349  {
350    if (d_addr->flags & OM_FUSED)
351    {
352      memset(omTrackAddr_2_OutAddr(d_addr), OM_FREE_PATTERN, omTrackAddr_2_OutSize(d_addr));
353      if (d_addr->track > 3)
354      {
355#ifdef OM_TRACK_FILE_LINE
356        d_addr->free_line = l;
357        d_addr->free_file = f;
358#endif
359#ifdef OM_TRACK_RETURN
360        d_addr->free_r = r;
361#endif       
362       
363#ifdef OM_TRACK_BACKTRACE     
364        if (d_addr->track > 4)
365          omGetBackTrace(d_addr->free_frames,  FROM_FRAMES, OM_MAX_KEPT_FRAMES);
366#endif 
367      }
368    }
369    else
370    {
371      omAssume(d_addr->flags & OM_FKEPT);
372    }
373  }
374  d_addr->flags &= ~OM_FUSED;
375  if (keep) d_addr->flags |= OM_FKEPT;
376  else d_addr->flags &= ~OM_FKEPT;
377 
378  return(void*) d_addr;
379}
380
381void omFreeTrackAddr(void* d_addr)
382{
383  omBinPage page;
384  omBin bin;
385 
386  omAssume(omIsBinPageAddr(d_addr));
387  omAssume(d_addr != NULL && omIsTrackAddr(d_addr));
388  d_addr = omOutAddr_2_TrackAddr(d_addr);
389 
390  page = omGetBinPageOfAddr((void*) d_addr);
391  bin = omGetTopBinOfPage(page);
392  /* Ok, here is how it works:
393    1. we unset the first bit of used_blocks
394       ==> used_blocks >= 0
395    2. we do a normal free
396    3. if page of addr was freed, then om_JustFreedPage
397          is != NULL ==> nothing to be done by us
398       else
399          page is still active ==> reset first bit of used_blocks
400  */
401
402  omUnsetTrackOfUsedBlocks(page->used_blocks);
403
404  om_JustFreedPage = NULL;
405
406  __omFreeBinAddr(d_addr);
407
408  if (page != om_JustFreedPage)
409    omSetTrackOfUsedBlocks(page->used_blocks);
410  else
411  {
412    /* Still need to check wheter we need to get rid of SpecBin */
413    if (bin->last_page == NULL && ! omIsStaticTrackBin(bin))
414      omDeleteSpecBin(&bin);
415  }
416}
417
418/*******************************************************************
419 * 
420 * Checking a Track Addr
421 *
422 * 
423 *******************************************************************/
424
425omError_t omCheckTrackAddr(void* addr, void* bin_size, omTrackFlags_t flags, char level, 
426                           omError_t report, OM_FLR_DECL)
427{
428  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
429  omAssume(omIsTrackAddr(addr));
430  omAssume(! omCheckPtr(addr, 0, OM_FLR));
431
432  omAddrCheckReturnCorrupted(d_addr->track < 1 || d_addr->track > OM_TRACK_MAX);
433  omAddrCheckReturnError((flags & OM_FUSED) && omTrackAddr_2_OutAddr(d_addr) != addr, omError_FalseAddrOrMemoryCorrupted);
434
435  omCheckReturn(omDoCheckBinAddr(d_addr, 0, (flags & OM_FUSED ? OM_FUSED : (flags & OM_FKEPT ? OM_FKEPT: 0)), 
436                                 level, report, OM_FLR_VAL));
437  return omDoCheckTrackAddr(d_addr, addr, bin_size, flags, level, report, OM_FLR_VAL);
438}
439
440
441static omError_t omDoCheckTrackAddr(omTrackAddr d_addr, void* addr, void* bin_size, omTrackFlags_t flags, char level, 
442                                    omError_t report, OM_FLR_DECL) 
443{
444  if (flags & OM_FUSED)
445    omAddrCheckReturnError(d_addr->next != ((void*) -1), omError_FreedAddrOrMemoryCorrupted);
446  else
447    omAddrCheckReturnError(d_addr->next != NULL && omCheckPtr(d_addr->next, omError_MaxError, OM_FLR_VAL), 
448                           omError_FreedAddrOrMemoryCorrupted);
449  omAddrCheckReturnCorrupted(omCheckFlags(d_addr->flags));
450  omAddrCheckReturnError((d_addr->flags & OM_FUSED) ^ (flags & OM_FUSED), omError_FreedAddrOrMemoryCorrupted);
451
452  if (d_addr->track > 2)
453  {
454    if (d_addr->flags & OM_FBIN)
455    {
456      omAddrCheckReturnCorrupted(!omIsKnownTopBin((omBin) d_addr->bin_size, 1));
457    }
458    else
459    {
460      omAssume(d_addr->flags & OM_FSIZE);
461       
462      omAddrCheckReturnCorrupted(!OM_IS_ALIGNED(d_addr->bin_size));
463      omAddrCheckReturnCorrupted((size_t) d_addr->bin_size >
464                                 omSizeOfBinAddr(d_addr) 
465                                 - omTrackAddr_2_SizeOfTrackAddrHeader(d_addr)
466                                 - OM_MIN_SIZEOF_BACK_PATTERN);
467      /* Hmm .. here I'd love to have a stricter bound */
468      omAddrCheckReturnCorrupted((size_t) d_addr->bin_size < SIZEOF_OM_ALIGNMENT);
469    }
470     
471    omAddrCheckReturnError((flags & OM_FBINADDR) && !((d_addr->flags & OM_FBIN) || ((size_t) d_addr->bin_size <= OM_MAX_BLOCK_SIZE)), omError_NotBinAddr);
472     
473    omAddrCheckReturnError((flags & OM_FBIN) && ( !(d_addr->flags & OM_FBIN) || d_addr->bin_size != bin_size),omError_WrongBin);
474    if (flags & OM_FSIZE)
475    {
476      if (d_addr->flags & OM_FSIZE)
477        omAddrCheckReturnError((size_t) d_addr->bin_size != OM_ALIGN_SIZE((size_t) bin_size), omError_WrongSize);
478      else
479        omAddrCheckReturnError(omTrackAddr_2_OutSize(d_addr) < (size_t) bin_size, omError_WrongSize);
480    }
481
482    omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_FrontPattern(d_addr), OM_FRONT_PATTERN,omTrackAddr_2_SizeOfFrontPattern(d_addr)),omError_FrontPattern);
483    omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_BackPattern(d_addr), OM_BACK_PATTERN,omTrackAddr_2_SizeOfBackPattern(d_addr)),omError_BackPattern);
484    if (! (d_addr->flags & OM_FUSED))
485      omAddrCheckReturnError(omCheckPattern(omTrackAddr_2_OutAddr(addr), OM_FREE_PATTERN, omTrackAddr_2_OutSize(d_addr)),omError_FreePattern);
486
487    if (d_addr->track > 3)
488    {
489#ifdef OM_TRACK_FILE_LINE
490      if (d_addr->flags & OM_FUSED)
491      {
492        omAddrCheckReturnCorrupted(d_addr->free_line != -1);
493        omAddrCheckReturnCorrupted(d_addr->free_file != (void*) -1);
494      }
495      else
496      {
497        omAddrCheckReturnCorrupted(d_addr->free_line < 0);
498        omAddrCheckReturnCorrupted(d_addr->free_file == (void*) -1);
499      }
500#endif
501#ifdef OM_TRACK_RETURN
502      omAddrCheckReturnCorrupted(d_addr->flags & OM_FUSED && d_addr->free_r != (void*) -1);
503#endif       
504    }
505  }
506  else
507  {
508      if (flags & OM_FBIN)
509      {
510        size_t size = omTrackAddr_2_OutSize(d_addr);
511        omAddrCheckReturnError(!omIsKnownTopBin((omBin) bin_size, 1), omError_UnknownBin);
512        omAddrCheckReturnError(size < (((omBin)bin_size)->sizeW<<LOG_SIZEOF_LONG), omError_WrongBin);
513      }
514      else if (flags & OM_FSIZE && (!(flags & OM_FSLOPPY)  || bin_size > 0))
515      {
516        omAddrCheckReturnError(omTrackAddr_2_OutSize(d_addr) < (size_t) bin_size, omError_WrongSize);
517      }
518  }
519  return omError_NoError;
520}
521     
522static int omCheckFlags(omTrackFlags_t flag)
523{
524  if (flag > OM_FMAX) return 1;
525  if (! ((flag & OM_FBIN) ^ (flag & OM_FSIZE))) return 1;
526  if (flag & OM_FUSED && flag & OM_FKEPT) return 1;
527  return 0;
528}
529
530static int omCheckPattern(char* s, char p, size_t size)
531{
532  int i;
533  for (i=0; i<size; i++)
534  {
535    if (s[i] != p) 
536      return 1;
537  }
538  return 0;
539}
540
541#ifdef OM_TRACK_BACKTRACE
542#define OM_ALLOC_FRAMES(d_addr) d_addr->alloc_frames
543#define OM_FREE_FRAMES(d_addr)  d_addr->free_frames
544#else
545#define OM_ALLOC_FRAMES(d) NULL
546#define OM_FREE_FRAMES(d)  NULL
547#endif
548
549void omPrintTrackAddrInfo(FILE* fd, void* addr)
550{
551  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
552  omAssume(d_addr->track > 0);
553 
554  fprintf(fd, " allocated at ");
555  if (! _omPrintBackTrace(OM_ALLOC_FRAMES(d_addr), 
556                          (d_addr->track > 1 ? OM_MAX_KEPT_FRAMES : 0), 
557                          fd, 
558                          OM_FLR_ARG(d_addr->alloc_file, d_addr->alloc_line, d_addr->alloc_r)))
559    fprintf(fd," ??");
560  if (d_addr->track > 1) 
561  {
562    if (d_addr->track > 3 && ! (d_addr->flags & OM_FUSED))
563    {
564      fprintf(fd, "\n freed at ");
565      if (! _omPrintBackTrace(OM_FREE_FRAMES(d_addr), 
566                          (d_addr->track > 4 ? OM_MAX_KEPT_FRAMES : 0), 
567                          fd, 
568                          OM_FLR_ARG(d_addr->free_file, d_addr->free_line, d_addr->free_r)))
569        fprintf(fd," ??");
570    }
571  }
572  fprintf(fd, "\n");
573  fflush(fd);
574}
575
576/*******************************************************************
577 * 
578 * Misc routines for marking, etc.
579 * 
580 *******************************************************************/
581int omIsStaticTrackAddr(void* addr)
582{
583  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
584  omAssume(omIsTrackAddr(addr));
585
586  return (d_addr->flags & OM_FSTATIC);
587}
588
589omBin omGetOrigSpecBinOfTrackAddr(void* addr)
590{
591  omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
592  omAssume(omIsTrackAddr(addr));
593 
594  if (d_addr->track > 2 && (d_addr->flags & OM_FBIN))
595  {
596    omBin bin = (omBin) d_addr->bin_size;
597    if (! omIsStaticNormalBin(bin)) 
598      return bin;
599  }
600  return NULL;
601}
602
603void omMarkAsStaticAddr(void* addr)
604{
605  if (omIsTrackAddr(addr))
606  {
607    omTrackAddr d_addr = omOutAddr_2_TrackAddr(addr);
608    d_addr->flags |= OM_FSTATIC;
609  }
610}
611
612void omUnMarkAsStaticAddr(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
621static void _omMarkAsStatic(void* addr)
622{
623  omTrackAddr d_addr = (omTrackAddr) addr;
624  omAssume(omIsTrackAddr(addr) && omOutAddr_2_TrackAddr(addr) == d_addr);
625  d_addr->flags |= OM_FSTATIC;
626}
627
628static void _omUnMarkAsStatic(void* addr)
629{
630  omTrackAddr d_addr = (omTrackAddr) addr;
631  omAssume(omIsTrackAddr(addr) && omOutAddr_2_TrackAddr(addr) == d_addr);
632  d_addr->flags &= ~OM_FSTATIC;
633}
634
635void omUnMarkMemoryAsStatic()
636{
637  omIterateTroughAddrs(0, 1, _omUnMarkAsStatic, NULL);
638}
639
640void omMarkMemoryAsStatic()
641{
642  omIterateTroughAddrs(0, 1, _omMarkAsStatic, NULL);
643}
644
645#endif /* OM_HAVE_TRACK */
Note: See TracBrowser for help on using the repository browser.