Changeset 1751

Show
Ignore:
Timestamp:
07/31/10 19:21:13 (6 weeks ago)
Author:
axel
Message:

branches/bmx-0.3.x/allocate.c debugMalloc/Free/Realloc: quick arm9 fix changing trailing magicNumber to char

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • branches/bmx-0.3.x/allocate.c

    r1634 r1751  
    2828 
    2929 
    30 #define MAGIC_NUMBER 0x12345678 
     30#define MAGIC_NUMBER_HEADER 0x12345678 
     31#define MAGIC_NUMBER_TRAILOR 0x12 
    3132 
    3233#if defined DEBUG_MALLOC 
     
    4041        uint32_t length; 
    4142        int32_t tag; 
    42         uint32_t magicNumber; 
     43        uint32_t magicNumberHeader; 
    4344}; 
    4445 
    45 struct chunkTrailer 
    46 { 
    47         uint32_t magicNumber; 
    48 }; 
     46typedef unsigned char magicNumberTrailor; 
     47 
    4948 
    5049 
     
    153152{ 
    154153        struct chunkHeader *walker; 
    155         struct chunkTrailer *chunkTrailer; 
     154        magicNumberTrailor *chunkTrailer; 
    156155        unsigned char *memory; 
    157156 
     
    159158        for (walker = chunkList; walker != NULL; walker = walker->next) 
    160159        { 
    161                 if (walker->magicNumber != MAGIC_NUMBER) 
     160                if (walker->magicNumberHeader != MAGIC_NUMBER_HEADER) 
    162161                { 
    163162                        dbgf( DBGL_SYS, DBGT_ERR,  
    164163                             "invalid magic number in header: %08x, malloc tag = %d",  
    165                              walker->magicNumber, walker->tag ); 
     164                             walker->magicNumberHeader, walker->tag ); 
    166165                        cleanup_all( -500073 ); 
    167166                } 
     
    169168                memory = (unsigned char *)walker; 
    170169 
    171                 chunkTrailer = (struct chunkTrailer *)(memory + sizeof(struct chunkHeader) + walker->length); 
    172  
    173                 if (chunkTrailer->magicNumber != MAGIC_NUMBER) 
    174                 { 
    175                         dbgf( DBGL_SYS, DBGT_ERR,  
    176                              "invalid magic number in trailer: %08x, malloc tag = %d",  
    177                              chunkTrailer->magicNumber, walker->tag ); 
    178                         cleanup_all( -500075 ); 
    179                 } 
    180         } 
     170                chunkTrailer = (magicNumberTrailor*)(memory + sizeof(struct chunkHeader) + walker->length); 
     171 
     172                if (*chunkTrailer != MAGIC_NUMBER_TRAILOR) 
     173{ 
     174                        dbgf(DBGL_SYS, DBGT_ERR, 
     175                                "invalid magic number in trailer: %08x, malloc tag = %d", 
     176                                *chunkTrailer, walker->tag); 
     177                        cleanup_all(-500075); 
     178                } 
     179        } 
    181180 
    182181} 
     
    208207        unsigned char *memory; 
    209208        struct chunkHeader *chunkHeader; 
    210         struct chunkTrailer *chunkTrailer; 
     209        magicNumberTrailor *chunkTrailer; 
    211210        unsigned char *chunk; 
    212211 
    213         memory = malloc(length + sizeof(struct chunkHeader) + sizeof(struct chunkTrailer)); 
     212        memory = malloc(length + sizeof(struct chunkHeader) + sizeof(magicNumberTrailor)); 
    214213 
    215214        if (memory == NULL) 
    216215        { 
    217216                dbg( DBGL_SYS, DBGT_ERR, "Cannot allocate %u bytes, malloc tag = %d",  
    218                      (unsigned int)(length + sizeof(struct chunkHeader) + sizeof(struct chunkTrailer)), tag ); 
     217                     (unsigned int)(length + sizeof(struct chunkHeader) + sizeof(magicNumberTrailor)), tag ); 
    219218                cleanup_all( -500076 ); 
    220219        } 
     
    222221        chunkHeader = (struct chunkHeader *)memory; 
    223222        chunk = memory + sizeof(struct chunkHeader); 
    224         chunkTrailer = (struct chunkTrailer *)(memory + sizeof(struct chunkHeader) + length); 
     223        chunkTrailer = (magicNumberTrailor *) (memory + sizeof (struct chunkHeader) + length); 
    225224 
    226225        chunkHeader->length = length; 
    227226        chunkHeader->tag = tag; 
    228         chunkHeader->magicNumber = MAGIC_NUMBER; 
    229  
    230         chunkTrailer->magicNumber = MAGIC_NUMBER; 
     227        chunkHeader->magicNumberHeader = MAGIC_NUMBER_HEADER; 
     228 
     229        *chunkTrailer = MAGIC_NUMBER_TRAILOR; 
    231230 
    232231        chunkHeader->next = chunkList; 
     
    249248        unsigned char *memory; 
    250249        struct chunkHeader *chunkHeader=NULL; 
    251         struct chunkTrailer *chunkTrailer; 
     250        magicNumberTrailor *chunkTrailer; 
    252251        unsigned char *result; 
    253252        uint32_t copyLength; 
     
    257256                chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader)); 
    258257 
    259                 if (chunkHeader->magicNumber != MAGIC_NUMBER) 
     258                if (chunkHeader->magicNumberHeader != MAGIC_NUMBER_HEADER) 
    260259                { 
    261260                        dbgf( DBGL_SYS, DBGT_ERR,  
    262261                             "invalid magic number in header: %08x, malloc tag = %d",  
    263                              chunkHeader->magicNumber, chunkHeader->tag ); 
     262                             chunkHeader->magicNumberHeader, chunkHeader->tag ); 
    264263                        cleanup_all( -500078 ); 
    265264                } 
    266265 
    267                 chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length); 
    268  
    269                 if (chunkTrailer->magicNumber != MAGIC_NUMBER) 
     266                chunkTrailer = (magicNumberTrailor *)(memory + chunkHeader->length); 
     267 
     268                if (*chunkTrailer != MAGIC_NUMBER_TRAILOR) 
    270269                { 
    271                         dbgf( DBGL_SYS, DBGT_ERR,  
    272                              "invalid magic number in trailer: %08x, malloc tag = %d",  
    273                              chunkTrailer->magicNumber, chunkHeader->tag ); 
    274                         cleanup_all( -500079 ); 
    275                 } 
     270                        dbgf( DBGL_SYS, DBGT_ERR, 
     271                                "invalid magic number in trailer: %08x, malloc tag = %d", 
     272                                *chunkTrailer, chunkHeader->tag); 
     273                        cleanup_all(-500079); 
     274                } 
    276275        } 
    277276 
     
    298297        unsigned char *memory; 
    299298        struct chunkHeader *chunkHeader; 
    300         struct chunkTrailer *chunkTrailer; 
     299        magicNumberTrailor *chunkTrailer; 
    301300        struct chunkHeader *walker; 
    302301        struct chunkHeader *previous; 
     
    305304        chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader)); 
    306305 
    307         if (chunkHeader->magicNumber != MAGIC_NUMBER) 
     306        if (chunkHeader->magicNumberHeader != MAGIC_NUMBER_HEADER) 
    308307        { 
    309308                dbgf( DBGL_SYS, DBGT_ERR,  
    310                      "invalid magic number in header: %08x, malloc tag = %d, free tag = %d",  
    311                      chunkHeader->magicNumber, chunkHeader->tag, tag ); 
     309                     "invalid magic number in header: %08x, malloc tag = %d, free tag = %d, malloc size = %d", 
     310                     chunkHeader->magicNumberHeader, chunkHeader->tag, tag, chunkHeader->length ); 
    312311                cleanup_all( -500080 ); 
    313312        } 
     
    325324        if (walker == NULL) 
    326325        { 
    327                 dbg( DBGL_SYS, DBGT_ERR, "Double free detected, malloc tag = %d, free tag = %d",  
    328                      chunkHeader->tag, tag ); 
     326                dbg( DBGL_SYS, DBGT_ERR, "Double free detected, malloc tag = %d, free tag = %d, malloc size = %d", 
     327                     chunkHeader->tag, tag, chunkHeader->length ); 
    329328                cleanup_all( -500081 ); 
    330329        } 
     
    337336 
    338337 
    339         chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length); 
    340  
    341         if (chunkTrailer->magicNumber != MAGIC_NUMBER) 
    342         { 
    343                 dbgf( DBGL_SYS, DBGT_ERR,  
    344                      "invalid magic number in trailer: %08x, malloc tag = %d, free tag = %d", 
    345                      chunkTrailer->magicNumber, chunkHeader->tag, tag ); 
    346                 cleanup_all( -500082 ); 
     338        chunkTrailer = (magicNumberTrailor *)(memory + chunkHeader->length); 
     339 
     340        if (*chunkTrailer != MAGIC_NUMBER_TRAILOR) 
     341{ 
     342                dbgf(DBGL_SYS, DBGT_ERR, 
     343                        "invalid magic number in trailer: %08x, malloc tag = %d, free tag = %d, malloc size = %d", 
     344                        *chunkTrailer, chunkHeader->tag, tag, chunkHeader->length); 
     345                cleanup_all(-500082); 
    347346        } 
    348347