debugmalloc.c

ssd6课程练习3的完全答案

#include <stdlib.h>
#include <string.h>
#include "debugmalloc.h"
#include "dmhelper.h"
#include <stdio.h>
/*
AUTHOR:[e-mail]
WEBSITE:http://www.herofit.cn/2007/06/13_214
*/

//not visible to our client
typedef struct memblock {
    void *p;
    int size;
    int checksum;
    char * allocatedfilename;
    int allocatedlinenumber;
    struct memblock * next;
}
memblock;

//list to track all the mblocks
static memblock * mblocks = 0;

//magicNumber,can be any value
const int MagicNumber = 0X12345678;

//caculate numbers of 1s in one int
static int checksum(int p) {
    int sum = 0;
    int bitsnum = sizeof(int) * 8;
    int andbit = 1;

    do {
        if (p & andbit) ++sum;

        andbit <<= 1;

        --bitsnum;
    } while ( bitsnum > 0);

    return sum;
};

//add new mem block node to list. Mix list operations and logics.
static void addmblock(void * ptr , size_t size, size_t checksum, char *filename, int linenumber) {
    memblock * newmb = (memblock *)malloc(sizeof(memblock));
    newmb->allocatedfilename = strdup(filename);
    newmb->allocatedlinenumber = linenumber;
    newmb->p = ptr;
    newmb->size = size;
    newmb->checksum = checksum;

    if (!mblocks)//empty list
    {
        newmb->next = 0;
    } else {
        newmb->next = mblocks;
    }

    mblocks = newmb;//new node becomes new head
};

//non-zero means valid
static memblock *  getmblock(void * ptr) {
    memblock * mbs = mblocks;

    while (mbs) {
        if (mbs->p == ptr)//found
        {
            return mbs;
        }
        mbs = mbs->next;
    }

    return 0;
};

//checksum modified?
static int isHeadOK(memblock * mb) {
    int *p = (int*)mb->p;

    if ( mb->checksum == *(p - 2))
        return 1;

    return 0;
};

static int isfence1ok(memblock * mb) {
    int *p = (int*)mb->p;

    if (mb->checksum == checksum(*(p - 1)))
        return 1;

    return 0;
}

static int isfence2ok(memblock * mb) {
    int *pbody ;
    char * vp = (char*)mb->p;
    int sum;
    vp = vp + mb->size;//add size offset
    pbody = (int *)vp;
    sum = checksum(*pbody);

    if (mb->checksum == sum)
        return 1;

    return 0;
}

//add remove mem block node from list. Mix list operations and logics.
static void delmblock(void * ptr) {
    memblock * mbs = mblocks;
    memblock * tmp;

    if (mblocks && mblocks->p == ptr)//remove head
    {
        mblocks = mblocks->next;
        free(mbs);
        //mbs = mblocks;
        return;
    }
    while (mbs && mbs->next) {
        if (mbs->next->p == ptr)//hit
        {
            tmp = mbs->next;
            mbs->next = mbs->next->next;
            free(tmp);//free everything we malloced
        }
        mbs = mbs->next;
    }
};

/* Wrappers for malloc and free */
/*

{
 int checksum;
 int fence1;//fence1
 ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
 real content here
 ''''''''''''''''''''''''''''''''''''''''''''''''
 int fence2;//fence2

}
*/

void *MyMalloc(size_t size, char *filename, int linenumber) {
    int * p;
    int * pbody;
    int cs;
    char * vp;//return value;
    p = (int *)malloc(size + 3 * sizeof(int));

    if (!p) return (void*)p;

    cs = checksum(MagicNumber);//caculate checksum
    *p = cs;//write checksum
    pbody = p + 1;//fence 1
    *pbody = MagicNumber;
    ++pbody;
    vp = (char*) pbody;
    vp += size;//skip real content
    pbody = (int *)vp;
    *pbody = MagicNumber;
    vp -= size;
    addmblock(vp, size, cs, filename, linenumber);
    return (vp);
}

void MyFree(void *ptr, char *filename, int linenumber) {

    int * const p = (int *)ptr;//const ptr
    memblock * mb = getmblock(ptr);

    //p = (int *)ptr;
    if (!mb)//error 4
    {
        error(4, filename, linenumber);
    }

    if (!isHeadOK(mb)) {
        errorfl(3, mb->allocatedfilename, mb->allocatedlinenumber, filename, linenumber);
    }

//check fence1
    if ( ! isfence1ok(mb)) {
        errorfl(1, mb->allocatedfilename, mb->allocatedlinenumber, filename, linenumber);
    }

    if (!isfence2ok(mb)) {
        errorfl(2, mb->allocatedfilename, mb->allocatedlinenumber, filename, linenumber);
    }

    //vp -= size;
    delmblock(ptr);
    free((void*)(p - 2));
}

/* returns number of bytes allocated using MyMalloc/MyFree:
 used as a debugging tool to test for memory leaks */
int AllocatedSize() {
    memblock * mbs = mblocks;
    int size = 0;

    while (mbs) {
        size += mbs->size;
        mbs = mbs->next;
    }

    return size;
}



/* Optional functions */

/* Prints a list of all allocated blocks with the
 filename/line number when they were MALLOC'd */
void PrintAllocatedBlocks() {
    memblock * mbs = mblocks;

    if (mbs) printf("Currently allocated blocks:\n");

    while (mbs) {
        PRINTBLOCK(mbs->size, mbs->allocatedfilename, mbs->allocatedlinenumber);
        mbs = mbs->next;
    }

    return;
}

/* Goes through the currently allocated blocks and checks
 to see if they are all valid.
 Returns -1 if it receives an error, 0 if all blocks are
 okay.
*/
int HeapCheck() {
    memblock * mbs = mblocks;
    char *  filename;
    int linenumber;
    int rt = 0;

    while (mbs) {
        filename = mbs->allocatedfilename;
        linenumber = mbs->allocatedlinenumber;
        //error 4,won't happen here
        /*if(!getmblock(mbs->p))//error 4
        {
            PRINTERROR(4,filename, linenumber);
            rt = -1;
            break;
        }*/

        if (!isHeadOK(mbs)) {
            PRINTERROR(3, filename, linenumber);
            rt = -1;
            break;
        }

        //check fence1
        if ( ! isfence1ok(mbs)) {
            PRINTERROR(1, filename, linenumber);
            rt = -1;
            break;
        }

        //check fence2
        if (!isfence2ok(mbs)) {
            PRINTERROR(2, filename, linenumber);
            rt = -1;
            break;
        }

        mbs = mbs->next;
    }

    return rt;
}