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