/*

redis里的回调函数

*/

#include<stdio.h>

#include<stdlib.h>

static void zmalloc_default_oom(size_t size)

{

    printf("zmalloc_default_oom\n");

    fprintf(stderr, "zmalloc: Out of memory trying to allocate %d bytes\n",size);

    fflush(stderr);

}

static void (*zmalloc_oom_handler)(size_t) = zmalloc_default_oom;

void zmalloc_set_oom_handler(void (*oom_handler)(size_t))

{

    printf("zmalloc_set_oom_handler\n");

    zmalloc_oom_handler = oom_handler;

}

void redisOutOfMemoryHandler(size_t allocation_size)

{

    printf("redisOutOfMemoryHandler------:%d\n",allocation_size);

}

int main(void)

{

    //zmalloc_set_oom_handler(redisOutOfMemoryHandler);

    zmalloc_oom_handler();

    getchar();

    return ;

}

int main(void)

{

    zmalloc_set_oom_handler(redisOutOfMemoryHandler);

    zmalloc_oom_handler();

    getchar();

    return ;

}

int main(int argc, char **argv)

{

    struct timeval tv;

    /* We need to initialize our libraries, and the server configuration. */

#ifdef INIT_SETPROCTITLE_REPLACEMENT

    //初始化参数

    spt_init(argc, argv);

#endif

    setlocale(LC_COLLATE,"");

    /*

    zmalloc_enable_thread_safeness()

    开启了内存分配管理的线程安全变量，当内存分配时，

    redis会统计一个总内存分配量，这是一个共享资源，

    所以需要原子性操作，在redis的内存分配代码里，

    当需要原子操作时，就需要打开线程安全变量。

    */

    zmalloc_enable_thread_safeness();

    /*

    zmalloc_set_oom_handler()

    是一个内存分配错误处理，

    当无法得到需要的内存量时，

    会调用redisOutOfMemoryHandler函数。

    */

    zmalloc_set_oom_handler(redisOutOfMemoryHandler);

    srand(time(NULL)^getpid());

    gettimeofday(&tv,NULL);

    dictSetHashFunctionSeed(tv.tv_sec^tv.tv_usec^getpid());

    server.sentinel_mode = checkForSentinelMode(argc,argv);

    initServerConfig();

    ..........

}

zmalloc_set_oom_handler注册回调函数

redisOutOfMemoryHandler主要是个log日志打印，即在内存分配失败的时候触发回调函数，打印log。

void *zmalloc(size_t size) {

    void *ptr = malloc(size+PREFIX_SIZE);

    if (!ptr) zmalloc_oom_handler(size);

#ifdef HAVE_MALLOC_SIZE

    update_zmalloc_stat_alloc(zmalloc_size(ptr));

    return ptr;

#else

    *((size_t*)ptr) = size;

    update_zmalloc_stat_alloc(size+PREFIX_SIZE);

    return (char*)ptr+PREFIX_SIZE;

#endif

}

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

/* Log levels */

#define REDIS_DEBUG 0

#define REDIS_VERBOSE 1

#define REDIS_NOTICE 2

#define REDIS_WARNING 3

#define REDIS_MAX_LOGMSG_LEN    1024 /* 默认信息长度 */

void redisLogRaw(int level, const char *msg);

void redisLog(int level, const char *fmt, ...);

/*

verbosity表示开启log的级别

需要写log的时候，log级别小于等于verbosity写log

否则不会写log

*/

struct redisServer {

    int verbosity;                  /* 日志级别*/

    char *logfile;                  /* Path of log file */

};

struct redisServer server; /* server global state */

void redisLog(int level, const char *fmt, ...)

{

    //如果level级别大于verbosity则不打印

    if (level> server.verbosity)

    {

        return;

    }

    va_list ap;

    char msg[REDIS_MAX_LOGMSG_LEN];

    va_start(ap, fmt);

    vsnprintf(msg, sizeof(msg), fmt, ap);

    va_end(ap);

    redisLogRaw(level,msg);

}

void redisLogRaw(int level, const char *msg)

{

#if 1

    FILE *fp;

    char buf[];

//  int rawmode = (level & REDIS_LOG_RAW);

    //int log_to_stdout = server.logfile[0] == '\0';

    //level &= 0xff; /* clear flags */

    //if (level < server.verbosity) return;

    if(server.logfile != NULL)

    {

        fp=fopen(server.logfile,"a");

    }

    else

    {

        fp=stdout;

    }

    int off;

//  struct timeval tv;

    //gettimeofday(&tv,NULL);

    //off = strftime(buf,sizeof(buf),"%d %b %H:%M:%S.",localtime(&tv.tv_sec));

    //snprintf(buf+off,sizeof(buf)-off,"%03d",(int)tv.tv_usec/1000);

    //fprintf(fp,"[%d] %s %c %s\n",(int)getpid(),buf,c[level],msg);

    fprintf(fp," %s\n",msg);

    fflush(fp);

    if(server.logfile != NULL)

    {

        fclose(fp);

    }

#endif

}

int main(void)

{

    server.verbosity=;

    server.logfile=NULL;

    redisLog(,"11111111\n");

    redisLog(,"22222\n");

    redisLog(,"333\n");

    getchar();

    return ;

}