9f2f57e119c3e3529e350e219a4e947c02e6e874
[blender-staging.git] / intern / guardedalloc / intern / mallocn.c
1 /**
2  * $Id$
3  * ***** BEGIN GPL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * The Original Code is: all of this file.
23  *
24  * Contributor(s): none yet.
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 /**
30
31  * $Id$
32  * Copyright (C) 2001 NaN Technologies B.V.
33  * Guarded memory allocation, and boundary-write detection.
34  */
35
36 #include <stdlib.h>
37 #include <string.h>     /* memcpy */
38 #include <stdarg.h>
39 #include <sys/types.h>
40 /* Blame Microsoft for LLP64 and no inttypes.h, quick workaround needed: */
41 #if defined(WIN64)
42 #define SIZET_FORMAT "%I64u"
43 #define SIZET_ARG(a) ((unsigned long long)(a))
44 #else
45 #define SIZET_FORMAT "%lu"
46 #define SIZET_ARG(a) ((unsigned long)(a))
47 #endif
48
49 /* mmap exception */
50 #if defined(WIN32)
51 #include "mmap_win.h"
52 #else
53 #include <sys/mman.h>
54 #endif
55
56 #include "MEM_guardedalloc.h"
57
58 /* Only for debugging:
59  * lets you count the allocations so as to find the allocator of unfreed memory
60  * in situations where the leak is pradictable */
61
62 // #define DEBUG_MEMCOUNTER
63
64 #ifdef DEBUG_MEMCOUNTER
65 #define DEBUG_MEMCOUNTER_ERROR_VAL 0 /* set this to the value that isnt being freed */
66 static int _mallocn_count = 0;
67
68 /* breakpoint here */
69 static void memcount_raise(const char *name)
70 {
71         fprintf(stderr, "%s: memcount-leak, %d\n", name, _mallocn_count);
72 }
73 #endif
74
75 /* --------------------------------------------------------------------- */
76 /* Data definition                                                       */
77 /* --------------------------------------------------------------------- */
78 /* all memory chunks are put in linked lists */
79 typedef struct localLink
80 {
81         struct localLink *next,*prev;
82 } localLink;
83
84 typedef struct localListBase 
85 {
86         void *first, *last;
87 } localListBase;
88
89         /* note: keep this struct aligned (e.g., irix/gcc) - Hos */
90 typedef struct MemHead {
91         int tag1;
92         size_t len;
93         struct MemHead *next,*prev;
94         const char * name;
95         const char * nextname;
96         int tag2;
97         int mmap;       /* if true, memory was mmapped */
98 #ifdef DEBUG_MEMCOUNTER
99         int _count;
100 #endif
101 } MemHead;
102
103 typedef struct MemTail {
104         int tag3, pad;
105 } MemTail;
106
107
108 /* --------------------------------------------------------------------- */
109 /* local functions                                                       */
110 /* --------------------------------------------------------------------- */
111
112 static void addtail(volatile localListBase *listbase, void *vlink);
113 static void remlink(volatile localListBase *listbase, void *vlink);
114 static void rem_memblock(MemHead *memh);
115 static void MemorY_ErroR(const char *block, const char *error);
116 static const char *check_memlist(MemHead *memh);
117
118 /* --------------------------------------------------------------------- */
119 /* locally used defines                                                  */
120 /* --------------------------------------------------------------------- */
121
122 #if defined( __sgi) || defined (__sun) || defined (__sun__) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || (defined (__APPLE__) && !defined(__LITTLE_ENDIAN__))
123 #define MAKE_ID(a,b,c,d) ( (int)(a)<<24 | (int)(b)<<16 | (c)<<8 | (d) )
124 #else
125 #define MAKE_ID(a,b,c,d) ( (int)(d)<<24 | (int)(c)<<16 | (b)<<8 | (a) )
126 #endif
127
128 #define MEMTAG1 MAKE_ID('M', 'E', 'M', 'O')
129 #define MEMTAG2 MAKE_ID('R', 'Y', 'B', 'L')
130 #define MEMTAG3 MAKE_ID('O', 'C', 'K', '!')
131 #define MEMFREE MAKE_ID('F', 'R', 'E', 'E')
132
133 #define MEMNEXT(x) ((MemHead *)(((char *) x) - ((char *) & (((MemHead *)0)->next))))
134         
135 /* --------------------------------------------------------------------- */
136 /* vars                                                                  */
137 /* --------------------------------------------------------------------- */
138         
139
140 static volatile int totblock= 0;
141 static volatile uintptr_t mem_in_use= 0, mmap_in_use= 0;
142
143 static volatile struct localListBase _membase;
144 static volatile struct localListBase *membase = &_membase;
145 static void (*error_callback)(const char *) = NULL;
146 static void (*thread_lock_callback)(void) = NULL;
147 static void (*thread_unlock_callback)(void) = NULL;
148
149 static int malloc_debug_memset= 0;
150
151 #ifdef malloc
152 #undef malloc
153 #endif
154
155 #ifdef calloc
156 #undef calloc
157 #endif
158
159 #ifdef free
160 #undef free
161 #endif
162
163
164 /* --------------------------------------------------------------------- */
165 /* implementation                                                        */
166 /* --------------------------------------------------------------------- */
167
168 static void print_error(const char *str, ...)
169 {
170         char buf[1024];
171         va_list ap;
172
173         va_start(ap, str);
174         vsprintf(buf, str, ap);
175         va_end(ap);
176
177         if (error_callback) error_callback(buf);
178 }
179
180 static void mem_lock_thread()
181 {
182         if (thread_lock_callback)
183                 thread_lock_callback();
184 }
185
186 static void mem_unlock_thread()
187 {
188         if (thread_unlock_callback)
189                 thread_unlock_callback();
190 }
191
192 int MEM_check_memory_integrity()
193 {
194         const char* err_val = NULL;
195         MemHead* listend;
196         /* check_memlist starts from the front, and runs until it finds
197          * the requested chunk. For this test, that's the last one. */
198         listend = membase->last;
199         
200         err_val = check_memlist(listend);
201
202         if (err_val == 0) return 0;
203         return 1;
204 }
205
206
207 void MEM_set_error_callback(void (*func)(const char *))
208 {
209         error_callback = func;
210 }
211
212 void MEM_set_lock_callback(void (*lock)(void), void (*unlock)(void))
213 {
214         thread_lock_callback = lock;
215         thread_unlock_callback = unlock;
216 }
217
218 void MEM_set_memory_debug(void)
219 {
220         malloc_debug_memset= 1;
221 }
222
223 size_t MEM_allocN_len(void *vmemh)
224 {
225         if (vmemh) {
226                 MemHead *memh= vmemh;
227         
228                 memh--;
229                 return memh->len;
230         } else
231                 return 0;
232 }
233
234 void *MEM_dupallocN(void *vmemh)
235 {
236         void *newp= NULL;
237         
238         if (vmemh) {
239                 MemHead *memh= vmemh;
240                 memh--;
241                 
242                 if(memh->mmap)
243                         newp= MEM_mapallocN(memh->len, "dupli_mapalloc");
244                 else
245                         newp= MEM_mallocN(memh->len, "dupli_alloc");
246
247                 if (newp == NULL) return NULL;
248
249                 memcpy(newp, vmemh, memh->len);
250         }
251
252         return newp;
253 }
254
255 void *MEM_reallocN(void *vmemh, size_t len)
256 {
257         void *newp= NULL;
258         
259         if (vmemh) {
260                 MemHead *memh= vmemh;
261                 memh--;
262
263                 newp= MEM_mallocN(len, memh->name);
264                 if(newp) {
265                         if(len < memh->len)
266                                 memcpy(newp, vmemh, len);
267                         else
268                                 memcpy(newp, vmemh, memh->len);
269                 }
270
271                 MEM_freeN(vmemh);
272         }
273
274         return newp;
275 }
276
277 static void make_memhead_header(MemHead *memh, size_t len, const char *str)
278 {
279         MemTail *memt;
280         
281         memh->tag1 = MEMTAG1;
282         memh->name = str;
283         memh->nextname = 0;
284         memh->len = len;
285         memh->mmap = 0;
286         memh->tag2 = MEMTAG2;
287         
288         memt = (MemTail *)(((char *) memh) + sizeof(MemHead) + len);
289         memt->tag3 = MEMTAG3;
290         
291         addtail(membase,&memh->next);
292         if (memh->next) memh->nextname = MEMNEXT(memh->next)->name;
293         
294         totblock++;
295         mem_in_use += len;
296 }
297
298 void *MEM_mallocN(size_t len, const char *str)
299 {
300         MemHead *memh;
301
302         mem_lock_thread();
303
304         len = (len + 3 ) & ~3;  /* allocate in units of 4 */
305         
306         memh= (MemHead *)malloc(len+sizeof(MemHead)+sizeof(MemTail));
307
308         if(memh) {
309                 make_memhead_header(memh, len, str);
310                 mem_unlock_thread();
311                 if(malloc_debug_memset && len)
312                         memset(memh+1, 255, len);
313
314 #ifdef DEBUG_MEMCOUNTER
315                 if(_mallocn_count==DEBUG_MEMCOUNTER_ERROR_VAL)
316                         memcount_raise("MEM_mallocN");
317                 memh->_count= _mallocn_count++;
318 #endif
319                 return (++memh);
320         }
321         mem_unlock_thread();
322         print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total %u\n", SIZET_ARG(len), str, mem_in_use);
323         return NULL;
324 }
325
326 void *MEM_callocN(size_t len, const char *str)
327 {
328         MemHead *memh;
329
330         mem_lock_thread();
331
332         len = (len + 3 ) & ~3;  /* allocate in units of 4 */
333
334         memh= (MemHead *)calloc(len+sizeof(MemHead)+sizeof(MemTail),1);
335
336         if(memh) {
337                 make_memhead_header(memh, len, str);
338                 mem_unlock_thread();
339 #ifdef DEBUG_MEMCOUNTER
340                 if(_mallocn_count==DEBUG_MEMCOUNTER_ERROR_VAL)
341                         memcount_raise("MEM_callocN");
342                 memh->_count= _mallocn_count++;
343 #endif
344                 return (++memh);
345         }
346         mem_unlock_thread();
347         print_error("Calloc returns null: len=" SIZET_FORMAT " in %s, total %u\n", SIZET_ARG(len), str, mem_in_use);
348         return 0;
349 }
350
351 /* note; mmap returns zero'd memory */
352 void *MEM_mapallocN(size_t len, const char *str)
353 {
354         MemHead *memh;
355
356         mem_lock_thread();
357         
358         len = (len + 3 ) & ~3;  /* allocate in units of 4 */
359         
360 #ifdef __sgi
361         {
362 #include <fcntl.h>
363
364           int fd;
365           fd = open("/dev/zero", O_RDWR);
366
367           memh= mmap(0, len+sizeof(MemHead)+sizeof(MemTail),
368                      PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
369           close(fd);
370         }
371 #else
372         memh= mmap(0, len+sizeof(MemHead)+sizeof(MemTail),
373                    PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
374 #endif
375
376         if(memh!=(MemHead *)-1) {
377                 make_memhead_header(memh, len, str);
378                 memh->mmap= 1;
379                 mmap_in_use += len;
380                 mem_unlock_thread();
381 #ifdef DEBUG_MEMCOUNTER
382                 if(_mallocn_count==DEBUG_MEMCOUNTER_ERROR_VAL)
383                         memcount_raise("MEM_mapallocN");
384                 memh->_count= _mallocn_count++;
385 #endif
386                 return (++memh);
387         }
388         else {
389                 mem_unlock_thread();
390                 print_error("Mapalloc returns null, fallback to regular malloc: len=" SIZET_FORMAT " in %s, total %u\n", SIZET_ARG(len), str, mmap_in_use);
391                 return MEM_callocN(len, str);
392         }
393 }
394
395 /* Memory statistics print */
396 typedef struct MemPrintBlock {
397         const char *name;
398         uintptr_t len;
399         int items;
400 } MemPrintBlock;
401
402 static int compare_name(const void *p1, const void *p2)
403 {
404         const MemPrintBlock *pb1= (const MemPrintBlock*)p1;
405         const MemPrintBlock *pb2= (const MemPrintBlock*)p2;
406
407         return strcmp(pb1->name, pb2->name);
408 }
409
410 static int compare_len(const void *p1, const void *p2)
411 {
412         const MemPrintBlock *pb1= (const MemPrintBlock*)p1;
413         const MemPrintBlock *pb2= (const MemPrintBlock*)p2;
414
415         if(pb1->len < pb2->len)
416                 return 1;
417         else if(pb1->len == pb2->len)
418                 return 0;
419         else
420                 return -1;
421 }
422
423 void MEM_printmemlist_stats()
424 {
425         MemHead *membl;
426         MemPrintBlock *pb, *printblock;
427         int totpb, a, b;
428
429         mem_lock_thread();
430
431         /* put memory blocks into array */
432         printblock= malloc(sizeof(MemPrintBlock)*totblock);
433
434         pb= printblock;
435         totpb= 0;
436
437         membl = membase->first;
438         if (membl) membl = MEMNEXT(membl);
439
440         while(membl) {
441                 pb->name= membl->name;
442                 pb->len= membl->len;
443                 pb->items= 1;
444
445                 totpb++;
446                 pb++;
447
448                 if(membl->next)
449                         membl= MEMNEXT(membl->next);
450                 else break;
451         }
452
453         /* sort by name and add together blocks with the same name */
454         qsort(printblock, totpb, sizeof(MemPrintBlock), compare_name);
455         for(a=0, b=0; a<totpb; a++) {
456                 if(a == b) {
457                         continue;
458                 }
459                 else if(strcmp(printblock[a].name, printblock[b].name) == 0) {
460                         printblock[b].len += printblock[a].len;
461                         printblock[b].items++;
462                 }
463                 else {
464                         b++;
465                         memcpy(&printblock[b], &printblock[a], sizeof(MemPrintBlock));
466                 }
467         }
468         totpb= b+1;
469
470         /* sort by length and print */
471         qsort(printblock, totpb, sizeof(MemPrintBlock), compare_len);
472         printf("\ntotal memory len: %.3f MB\n", (double)mem_in_use/(double)(1024*1024));
473         printf(" ITEMS TOTAL-MiB AVERAGE-KiB TYPE\n");
474         for(a=0, pb=printblock; a<totpb; a++, pb++)
475                 printf("%6d (%8.3f  %8.3f) %s\n", pb->items, (double)pb->len/(double)(1024*1024), (double)pb->len/1024.0/(double)pb->items, pb->name);
476
477         free(printblock);
478         
479         mem_unlock_thread();
480
481 #if 0 /* GLIBC only */
482         malloc_stats();
483 #endif
484 }
485
486 /* Prints in python syntax for easy */
487 static void MEM_printmemlist_internal( int pydict )
488 {
489         MemHead *membl;
490
491         mem_lock_thread();
492
493         membl = membase->first;
494         if (membl) membl = MEMNEXT(membl);
495         
496         if (pydict) {
497                 print_error("# membase_debug.py\n");
498                 print_error("membase = [\\\n");
499         }
500         while(membl) {
501                 if (pydict) {
502                         fprintf(stderr, "{'len':" SIZET_FORMAT ", 'name':'''%s''', 'pointer':'%p'},\\\n", SIZET_ARG(membl->len), membl->name, membl+1);
503                 } else {
504 #ifdef DEBUG_MEMCOUNTER
505                         print_error("%s len: " SIZET_FORMAT " %p, count: %d\n", membl->name, SIZET_ARG(membl->len), membl+1, membl->_count);
506 #else
507                         print_error("%s len: " SIZET_FORMAT " %p\n", membl->name, SIZET_ARG(membl->len), membl+1);
508 #endif
509                 }
510                 if(membl->next)
511                         membl= MEMNEXT(membl->next);
512                 else break;
513         }
514         if (pydict) {
515                 fprintf(stderr, "]\n\n");
516                 fprintf(stderr,
517 "mb_userinfo = {}\n"
518 "totmem = 0\n"
519 "for mb_item in membase:\n"
520 "\tmb_item_user_size = mb_userinfo.setdefault(mb_item['name'], [0,0])\n"
521 "\tmb_item_user_size[0] += 1 # Add a user\n"
522 "\tmb_item_user_size[1] += mb_item['len'] # Increment the size\n"
523 "\ttotmem += mb_item['len']\n"
524 "print '(membase) items:', len(membase), '| unique-names:', len(mb_userinfo), '| total-mem:', totmem\n"
525 "mb_userinfo_sort = mb_userinfo.items()\n"
526 "for sort_name, sort_func in (('size', lambda a: -a[1][1]), ('users', lambda a: -a[1][0]), ('name', lambda a: a[0])):\n"
527 "\tprint '\\nSorting by:', sort_name\n"
528 "\tmb_userinfo_sort.sort(key = sort_func)\n"
529 "\tfor item in mb_userinfo_sort:\n"
530 "\t\tprint 'name:%%s, users:%%i, len:%%i' %% (item[0], item[1][0], item[1][1])\n"
531                 );
532         }
533         
534         mem_unlock_thread();
535 }
536
537 void MEM_callbackmemlist(void (*func)(void*)) {
538         MemHead *membl;
539
540         mem_lock_thread();
541
542         membl = membase->first;
543         if (membl) membl = MEMNEXT(membl);
544
545         while(membl) {
546                 func(membl+1);
547                 if(membl->next)
548                         membl= MEMNEXT(membl->next);
549                 else break;
550         }
551
552         mem_unlock_thread();
553 }
554
555 short MEM_testN(void *vmemh) {
556         MemHead *membl;
557
558         mem_lock_thread();
559
560         membl = membase->first;
561         if (membl) membl = MEMNEXT(membl);
562
563         while(membl) {
564                 if (vmemh == membl+1) {
565                         mem_unlock_thread();
566                         return 1;
567                 }
568
569                 if(membl->next)
570                         membl= MEMNEXT(membl->next);
571                 else break;
572         }
573
574         mem_unlock_thread();
575
576         print_error("Memoryblock %p: pointer not in memlist\n", vmemh);
577         return 0;
578 }
579
580 void MEM_printmemlist( void ) {
581         MEM_printmemlist_internal(0);
582 }
583 void MEM_printmemlist_pydict( void ) {
584         MEM_printmemlist_internal(1);
585 }
586
587 short MEM_freeN(void *vmemh)            /* anders compileertie niet meer */
588 {
589         short error = 0;
590         MemTail *memt;
591         MemHead *memh= vmemh;
592         const char *name;
593
594         if (memh == NULL){
595                 MemorY_ErroR("free","attempt to free NULL pointer");
596                 /* print_error(err_stream, "%d\n", (memh+4000)->tag1); */
597                 return(-1);
598         }
599
600         if(sizeof(intptr_t)==8) {
601                 if (((intptr_t) memh) & 0x7) {
602                         MemorY_ErroR("free","attempt to free illegal pointer");
603                         return(-1);
604                 }
605         }
606         else {
607                 if (((intptr_t) memh) & 0x3) {
608                         MemorY_ErroR("free","attempt to free illegal pointer");
609                         return(-1);
610                 }
611         }
612         
613         memh--;
614         if(memh->tag1 == MEMFREE && memh->tag2 == MEMFREE) {
615                 MemorY_ErroR(memh->name,"double free");
616                 return(-1);
617         }
618
619         mem_lock_thread();
620         if ((memh->tag1 == MEMTAG1) && (memh->tag2 == MEMTAG2) && ((memh->len & 0x3) == 0)) {
621                 memt = (MemTail *)(((char *) memh) + sizeof(MemHead) + memh->len);
622                 if (memt->tag3 == MEMTAG3){
623                         
624                         memh->tag1 = MEMFREE;
625                         memh->tag2 = MEMFREE;
626                         memt->tag3 = MEMFREE;
627                         /* after tags !!! */
628                         rem_memblock(memh);
629
630                         mem_unlock_thread();
631                         
632                         return(0);
633                 }
634                 error = 2;
635                 MemorY_ErroR(memh->name,"end corrupt");
636                 name = check_memlist(memh);
637                 if (name != 0){
638                         if (name != memh->name) MemorY_ErroR(name,"is also corrupt");
639                 }
640         } else{
641                 error = -1;
642                 name = check_memlist(memh);
643                 if (name == 0)
644                         MemorY_ErroR("free","pointer not in memlist");
645                 else
646                         MemorY_ErroR(name,"error in header");
647         }
648
649         totblock--;
650         /* here a DUMP should happen */
651
652         mem_unlock_thread();
653
654         return(error);
655 }
656
657 /* --------------------------------------------------------------------- */
658 /* local functions                                                       */
659 /* --------------------------------------------------------------------- */
660
661 static void addtail(volatile localListBase *listbase, void *vlink)
662 {
663         struct localLink *link= vlink;
664
665         if (link == 0) return;
666         if (listbase == 0) return;
667
668         link->next = 0;
669         link->prev = listbase->last;
670
671         if (listbase->last) ((struct localLink *)listbase->last)->next = link;
672         if (listbase->first == 0) listbase->first = link;
673         listbase->last = link;
674 }
675
676 static void remlink(volatile localListBase *listbase, void *vlink)
677 {
678         struct localLink *link= vlink;
679
680         if (link == 0) return;
681         if (listbase == 0) return;
682
683         if (link->next) link->next->prev = link->prev;
684         if (link->prev) link->prev->next = link->next;
685
686         if (listbase->last == link) listbase->last = link->prev;
687         if (listbase->first == link) listbase->first = link->next;
688 }
689
690 static void rem_memblock(MemHead *memh)
691 {
692     remlink(membase,&memh->next);
693     if (memh->prev) {
694         if (memh->next) 
695                         MEMNEXT(memh->prev)->nextname = MEMNEXT(memh->next)->name;
696         else 
697                         MEMNEXT(memh->prev)->nextname = NULL;
698     }
699
700     totblock--;
701     mem_in_use -= memh->len;
702    
703     if(memh->mmap) {
704         mmap_in_use -= memh->len;
705         if (munmap(memh, memh->len + sizeof(MemHead) + sizeof(MemTail)))
706             printf("Couldn't unmap memory %s\n", memh->name);
707     }   
708         else {
709                 if(malloc_debug_memset && memh->len)
710                         memset(memh+1, 255, memh->len);
711         free(memh);
712         }
713 }
714
715 static void MemorY_ErroR(const char *block, const char *error)
716 {
717         print_error("Memoryblock %s: %s\n",block, error);
718 }
719
720 static const char *check_memlist(MemHead *memh)
721 {
722         MemHead *forw,*back,*forwok,*backok;
723         const char *name;
724
725         forw = membase->first;
726         if (forw) forw = MEMNEXT(forw);
727         forwok = 0;
728         while(forw){
729                 if (forw->tag1 != MEMTAG1 || forw->tag2 != MEMTAG2) break;
730                 forwok = forw;
731                 if (forw->next) forw = MEMNEXT(forw->next);
732                 else forw = 0;
733         }
734
735         back = (MemHead *) membase->last;
736         if (back) back = MEMNEXT(back);
737         backok = 0;
738         while(back){
739                 if (back->tag1 != MEMTAG1 || back->tag2 != MEMTAG2) break;
740                 backok = back;
741                 if (back->prev) back = MEMNEXT(back->prev);
742                 else back = 0;
743         }
744
745         if (forw != back) return ("MORE THAN 1 MEMORYBLOCK CORRUPT");
746
747         if (forw == 0 && back == 0){
748                 /* geen foute headers gevonden dan maar op zoek naar memblock*/
749
750                 forw = membase->first;
751                 if (forw) forw = MEMNEXT(forw);
752                 forwok = 0;
753                 while(forw){
754                         if (forw == memh) break;
755                         if (forw->tag1 != MEMTAG1 || forw->tag2 != MEMTAG2) break;
756                         forwok = forw;
757                         if (forw->next) forw = MEMNEXT(forw->next);
758                         else forw = 0;
759                 }
760                 if (forw == 0) return (0);
761
762                 back = (MemHead *) membase->last;
763                 if (back) back = MEMNEXT(back);
764                 backok = 0;
765                 while(back){
766                         if (back == memh) break;
767                         if (back->tag1 != MEMTAG1 || back->tag2 != MEMTAG2) break;
768                         backok = back;
769                         if (back->prev) back = MEMNEXT(back->prev);
770                         else back = 0;
771                 }
772         }
773
774         if (forwok) name = forwok->nextname;
775         else name = "No name found";
776
777         if (forw == memh){
778                 /* voor alle zekerheid wordt dit block maar uit de lijst gehaald */
779                 if (forwok){
780                         if (backok){
781                                 forwok->next = (MemHead *)&backok->next;
782                                 backok->prev = (MemHead *)&forwok->next;
783                                 forwok->nextname = backok->name;
784                         } else{
785                                 forwok->next = 0;
786                                 membase->last = (struct localLink *) &forwok->next; 
787 /*                              membase->last = (struct Link *) &forwok->next; */
788                         }
789                 } else{
790                         if (backok){
791                                 backok->prev = 0;
792                                 membase->first = &backok->next;
793                         } else{
794                                 membase->first = membase->last = 0;
795                         }
796                 }
797         } else{
798                 MemorY_ErroR(name,"Additional error in header");
799                 return("Additional error in header");
800         }
801
802         return(name);
803 }
804
805 uintptr_t MEM_get_memory_in_use(void)
806 {
807         uintptr_t _mem_in_use;
808
809         mem_lock_thread();
810         _mem_in_use= mem_in_use;
811         mem_unlock_thread();
812
813         return _mem_in_use;
814 }
815
816 uintptr_t MEM_get_mapped_memory_in_use(void)
817 {
818         uintptr_t _mmap_in_use;
819
820         mem_lock_thread();
821         _mmap_in_use= mmap_in_use;
822         mem_unlock_thread();
823
824         return _mmap_in_use;
825 }
826
827 int MEM_get_memory_blocks_in_use(void)
828 {
829         int _totblock;
830
831         mem_lock_thread();
832         _totblock= totblock;
833         mem_unlock_thread();
834
835         return _totblock;
836 }
837
838 /* eof */