某人曾提醒我要多读源代码，我就选了libevent 2.1.8稳定版的源代码来读。
读了一会，纯看源代码里面的东西，还挺无聊的。所以我就开始，便看他们的编程教程：
http://www.wangafu.net/~nickm/libevent-book/
然后每遇到实现，我就跑去源代码中看别人怎么做到的。
这样还是比较有趣的，一个一个小目标的去做，直到这个事情是为什么而做。
我之前，已经把编程的指导粗略看过一边，也是边犯困边看，再开始看源代码，昨天睡了十次八次，才看了很小的一部分。
这样太慢了，而且很无聊。所以换了这样的方式，省去细枝末节，按功能来进行逐个翻看。
下面是我个人做这个事的笔记
ps：这里面前面代码里面有数字，是代码的数字，可以参考我之前的设置LXR来查看这些源代码，会比较方便。
如何设置log messag：
可以通过以下的接口：
Interface #define EVENT_LOG_DEBUG 0 #define EVENT_LOG_MSG 1 #define EVENT_LOG_WARN 2 #define EVENT_LOG_ERR 3 typedef void (*event_log_cb)(int severity, const char *msg); void event_set_log_callback(event_log_cb cb);
上面的宏定义，是一个severity的等级，下面的是写日记的回调函数。下面是将这个回调函数设置到eventbase里面的。让我们来看看这些函数都是怎么写的。
0719 /** 0720 A callback function used to intercept Libevent‘s log messages. 0721 0722 @see event_set_log_callback 0723 */ 0724 typedef void (*event_log_cb)(int severity, const char *msg);
这是它原本的定义，只是一个原型的定义。它在/include/event2/event.h和/log.c中，都会被引用到：
在头文件event.h的引用，也是一个函数原型：
0725 /** 0726 Redirect Libevent‘s log messages. 0727 0728 @param cb a function taking two arguments: an integer severity between 0729 EVENT_LOG_DEBUG and EVENT_LOG_ERR, and a string. If cb is NULL, 0730 then the default log is used. 0731 0732 NOTE: The function you provide *must not* call any other libevent 0733 functionality. Doing so can produce undefined behavior. 0734 */ 0735 EVENT2_EXPORT_SYMBOL 0736 void event_set_log_callback(event_log_cb cb);
在log.c当中，有两处的引用：
0219 static event_log_cb log_fn = NULL;
0221 void
0222 event_set_log_callback(event_log_cb cb)
0223 {
0224 log_fn = cb;
0225 }
这里的代码也很明显，就是设置了一个函数，我继续深挖，它这个函数long_fn，是如何决定它作为记录的函数的？
挖下还是会有的，就在同一个文件当中，有一个 event_log 的函数，用于决定运用哪个函数：我们设置的log_fn 还是 fprintf
0227 static void
0228 event_log(int severity, const char *msg)
0229 {
0230 if (log_fn)
0231 log_fn(severity, msg);
0232 else {
0233 const char *severity_str;
0234 switch (severity) {
0235 case EVENT_LOG_DEBUG:
0236 severity_str = "debug";
0237 break;
0238 case EVENT_LOG_MSG:
0239 severity_str = "msg";
0240 break;
0241 case EVENT_LOG_WARN:
0242 severity_str = "warn";
0243 break;
0244 case EVENT_LOG_ERR:
0245 severity_str = "err";
0246 break;
0247 default:
0248 severity_str = "???";
0249 break;
0250 }
0251 (void)fprintf(stderr, "[%s] %s\n", severity_str, msg);
0252 }
0253 }
要注意的是，在一个用户提供的 eent_log_cb 的回调函数里面，调用libevent的函数，是不安全的。比如说，你要在回调函数里面将错误信息写socket，就不要使用libevent的buffervent这些功能，会产生怪异的，并且难以调试的错误。
This restriction may be removed for some functions in a future version of Libevent.
默认情况下，debug logs 是不会启用的。需要通过以下接口，才能够打开他们：
Interface #define EVENT_DBG_NONE 0 #define EVENT_DBG_ALL 0xffffffffu void event_enable_debug_logging(ev_uint32_t which);
这个函数的用法，就是使用 event_enable_debug_logging 这个函数，设置调试的等级为上面的两个等级之间的其中一个。可以是没有调试信息 EVENT_DBG_NONE 或者是所有的它i傲视信息 EVENT_DBG_ALL
event_enable_debug_logging 函数的定义是在/log.c里面：
0085 event_enable_debug_logging(ev_uint32_t which)
0086 {
0087 #ifdef EVENT_DEBUG_LOGGING_ENABLED
0088 event_debug_logging_mask_ = which;
0089 #endif
0090 }
0044 #if !defined(EVENT__DISABLE_DEBUG_MODE) || defined(USE_DEBUG)
0045 #define EVENT_DEBUG_LOGGING_ENABLED
0046 #endif
0073 ev_uint32_t event_debug_logging_mask_ = DEFAULT_MASK;
0065 #ifdef EVENT_DEBUG_LOGGING_ENABLED
0066 #ifdef USE_DEBUG
0067 #define DEFAULT_MASK EVENT_DBG_ALL
0068 #else
0069 #define DEFAULT_MASK 0
0070 #endif
在这里，event_enable_debug_logging 的函数的行为，是根据 EVENT_DEBUG_LOGGING_ENABLED 来进行抉择的。
event_debug_logging_mask_ 也是根据 EVENT_DEBUG_LOGGING_ENABLED 来进行决定DEFAULT_MASK 是0 还是所有。
EVENT_DEBUG_LOGGING_ENABLED 的定义， 是根据 EVENT__DISABLE_DEBUG_MODE 宏和 USE_DEBUG宏来决定的。
这两个宏，在配置文件中是没有的，那么，只要我们在编译的时候，不设置EVENT__DISABLE_DEBUG_MODE 或者是自己设置了USER_DEBUG，就可以有这些功能，也就是，默认是会有这些功能的。
如何处理致命的错误：
可以使用自己的错误处理函数来处理致命的错误：
Interface typedef void (*event_fatal_cb)(int err); void event_set_fatal_callback(event_fatal_cb cb);
首先，你需要定义一个新的函数，这个函数是Libevent出现致命错误的时候，进行调用的，函数的原型就是 event_fatal_cb。然后再使用event_set_fatal_callback来进行设置。
首先来看一下：event_fatal_cb 的定义和引用的情况：
// /include/event2/event.h
0738 /**
0739 A function to be called if Libevent encounters a fatal internal error.
0740
0741 @see event_set_fatal_callback
0742 */
0743 typedef void (*event_fatal_cb)(int err);
0745 /**
0746 Override Libevent‘s behavior in the event of a fatal internal error.
0747
0748 By default, Libevent will call exit(1) if a programming error makes it
0749 impossible to continue correct operation. This function allows you to supply
0750 another callback instead. Note that if the function is ever invoked,
0751 something is wrong with your program, or with Libevent: any subsequent calls
0752 to Libevent may result in undefined behavior.
0753
0754 Libevent will (almost) always log an EVENT_LOG_ERR message before calling
0755 this function; look at the last log message to see why Libevent has died.
0756 */
0757 EVENT2_EXPORT_SYMBOL
0758 void event_set_fatal_callback(event_fatal_cb cb);
// /log.c
0063 static event_fatal_cb fatal_fn = NULL;
0092 void
0093 event_set_fatal_callback(event_fatal_cb cb)
0094 {
0095 fatal_fn = cb;
0096 }
但是， 在这里， 默认行为就是不处理。
0063 static event_fatal_cb fatal_fn = NULL;
Memory management
默认情况下，Libevent使用C语言库的内存分配函数来进行分配。可以用下面的接口来进行自定义：
// //mm-internal.h 0035 #ifndef EVENT__DISABLE_MM_REPLACEMENT 0036 /* Internal use only: Memory allocation functions. We give them nice short 0037 * mm_names for our own use, but make sure that the symbols have longer names 0038 * so they don‘t conflict with other libraries (like, say, libmm). */ 0039 0040 /** Allocate uninitialized memory. 0041 * 0042 * @return On success, return a pointer to sz newly allocated bytes. 0043 * On failure, set errno to ENOMEM and return NULL. 0044 * If the argument sz is 0, simply return NULL. 0045 */ 0046 void *event_mm_malloc_(size_t sz); 0047 0048 /** Allocate memory initialized to zero. 0049 * 0050 * @return On success, return a pointer to (count * size) newly allocated 0051 * bytes, initialized to zero. 0052 * On failure, or if the product would result in an integer overflow, 0053 * set errno to ENOMEM and return NULL. 0054 * If either arguments are 0, simply return NULL. 0055 */ 0056 void *event_mm_calloc_(size_t count, size_t size); 0057 0058 /** Duplicate a string. 0059 * 0060 * @return On success, return a pointer to a newly allocated duplicate 0061 * of a string. 0062 * Set errno to ENOMEM and return NULL if a memory allocation error 0063 * occurs (or would occur) in the process. 0064 * If the argument str is NULL, set errno to EINVAL and return NULL. 0065 */ 0066 char *event_mm_strdup_(const char *str); 0067 0068 void *event_mm_realloc_(void *p, size_t sz); 0069 void event_mm_free_(void *p); 0070 #define mm_malloc(sz) event_mm_malloc_(sz) 0071 #define mm_calloc(count, size) event_mm_calloc_((count), (size)) 0072 #define mm_strdup(s) event_mm_strdup_(s) 0073 #define mm_realloc(p, sz) event_mm_realloc_((p), (sz)) 0074 #define mm_free(p) event_mm_free_(p) 0075 #else 0076 #define mm_malloc(sz) malloc(sz) 0077 #define mm_calloc(n, sz) calloc((n), (sz)) 0078 #define mm_strdup(s) strdup(s) 0079 #define mm_realloc(p, sz) realloc((p), (sz)) 0080 #define mm_free(p) free(p) 0081 #endif
取决于 EVENT__DISABLE_MM_REPLACEMENT 的定义，这个定义可以在 /WIN32-Code/nmake/event2/event-config.h下面
/* Define if libevent should not allow replacing the mm functions */ /* #undef EVENT__DISABLE_MM_REPLACEMENT */
定义了这个，就会在建造的时候，无法代替这些内存分配函数。
如果没有定义，那么就会定义下面这几个函数的接口：
void *event_mm_malloc_(size_t sz); void *event_mm_calloc_(size_t count, size_t size); char *event_mm_strdup_(const char *str); void *event_mm_realloc_(void *p, size_t sz); void event_mm_free_(void *p);
这些函数的定义，也都在/event.c下面
malloc
3432 void *
3433 event_mm_malloc_(size_t sz)
3434 {
3435 if (sz == 0)
3436 return NULL;
3437
3438 if (mm_malloc_fn_)
3439 return mm_malloc_fn_(sz);
3440 else
3441 return malloc(sz);
3442 }
calloc函数
3444 void *
3445 event_mm_calloc_(size_t count, size_t size)
3446 {
3447 if (count == 0 || size == 0)
3448 return NULL;
3449
3450 if (mm_malloc_fn_) {
3451 size_t sz = count * size;
3452 void *p = NULL;
3453 if (count > EV_SIZE_MAX / size)
3454 goto error;
3455 p = mm_malloc_fn_(sz);
3456 if (p)
3457 return memset(p, 0, sz);
3458 } else {
3459 void *p = calloc(count, size);
3460 #ifdef _WIN32
3461 /* Windows calloc doesn‘t reliably set ENOMEM */
3462 if (p == NULL)
3463 goto error;
3464 #endif
3465 return p;
3466 }
3467
3468 error:
3469 errno = ENOMEM;
3470 return NULL;
3471 }
strdup的函数，作用是复制一个字符串
3473 char *
3474 event_mm_strdup_(const char *str)
3475 {
3476 if (!str) {
3477 errno = EINVAL;
3478 return NULL;
3479 }
3480
3481 if (mm_malloc_fn_) {
3482 size_t ln = strlen(str);
3483 void *p = NULL;
3484 if (ln == EV_SIZE_MAX)
3485 goto error;
3486 p = mm_malloc_fn_(ln+1);
3487 if (p)
3488 return memcpy(p, str, ln+1);
3489 } else
3490 #ifdef _WIN32
3491 return _strdup(str);
3492 #else
3493 return strdup(str);
3494 #endif
3495
3496 error:
3497 errno = ENOMEM;
3498 return NULL;
3499 }
这两个函数realloc和free函数
3501 void *
3502 event_mm_realloc_(void *ptr, size_t sz)
3503 {
3504 if (mm_realloc_fn_)
3505 return mm_realloc_fn_(ptr, sz);
3506 else
3507 return realloc(ptr, sz);
3508 }
3509
3510 void
3511 event_mm_free_(void *ptr)
3512 {
3513 if (mm_free_fn_)
3514 mm_free_fn_(ptr);
3515 else
3516 free(ptr);
3517 }
不定义的话， 就可以替换 ，使用下面的接口来进行替换
Interface
void event_set_mem_functions(void *(*malloc_fn)(size_t sz),
void *(*realloc_fn)(void *ptr, size_t sz),
void (*free_fn)(void *ptr));
在上面的实现的基础上，如何实现这个函数，就会比较简单了。只要设置代面里面的 mm_*_fn 就好了
3519 void
3520 event_set_mem_functions(void *(*malloc_fn)(size_t sz),
3521 void *(*realloc_fn)(void *ptr, size_t sz),
3522 void (*free_fn)(void *ptr))
3523 {
3524 mm_malloc_fn_ = malloc_fn;
3525 mm_realloc_fn_ = realloc_fn;
3526 mm_free_fn_ = free_fn;
3527 }
要注意的是，内存分享函数，是会影响所有需要allocate，resize，或free的函数功能的。因此，必须要在任何这些Libevent函数之前。来进行设置。否则，就会一半是用默认的，一半用自己的。
自定义的分配函数，必须是要返回内存的alignment得和C的标准库里面的一样。
你的分配函数必须要正确处理realloc(NULL, sz) 正确，处理方式就是malloc(sz)。
必须要处理realloc(ptr, 0) 的方式为 free(ptr)
free函数不需要处理free(NULL)
不需要处理malloc(0)
内存分配函数必须是threadsafe的
如果替换了malloc，也请使用替换的free来进行释放，因为Libevent会使用这些函数来进行分配和回收。
Locks and threading
多线程的程序，多个线程不可能总是安全的去访问同一个数据。
Libevent 结构一般可以用三种方式来在多个线程中进行工作：
1、一些结构体固有的单个进程的：也就是说，它们都是不能够被多个进程来进行同时访问的
2、一些结构体是可选的locked的：你可以告诉Libevent，哪些object是需要多个进程访问。
3、一些结构体总是被锁上的，因为Libevent总是访问使用锁来进行访问它的。
为了能够在Libevent进行上所，你必须告诉Libevent使用哪个Lock函数。这必须在使用任何函数之前先设置好这个。
如果你使用的是pthreads库，那么你就是幸运的。因为在那个库里面，有与定义的函数，可以用来设置Libevent来使用right pthreads。
接口如下：
Interface #ifdef _EVENT_HAVE_PTHREADS int evthread_use_pthreads(void); #define EVTHREAD_USE_PTHREADS_IMPLEMENTED #endif
这些函数的定义和说明如下：
// /include/event2/thread.h 0209 /** Sets up Libevent for use with Pthreads locking and thread ID functions. 0210 Unavailable if Libevent is not build for use with pthreads. Requires 0211 libraries to link against Libevent_pthreads as well as Libevent. 0212 0213 @return 0 on success, -1 on failure. */ 0214 EVENT2_EXPORT_SYMBOL 0215 int evthread_use_pthreads(void);
// /evthread_pthread.c
0163 int
0164 evthread_use_pthreads(void)
0165 {
0166 struct evthread_lock_callbacks cbs = {
0167 EVTHREAD_LOCK_API_VERSION,
0168 EVTHREAD_LOCKTYPE_RECURSIVE,
0169 evthread_posix_lock_alloc,
0170 evthread_posix_lock_free,
0171 evthread_posix_lock,
0172 evthread_posix_unlock
0173 };
0174 struct evthread_condition_callbacks cond_cbs = {
0175 EVTHREAD_CONDITION_API_VERSION,
0176 evthread_posix_cond_alloc,
0177 evthread_posix_cond_free,
0178 evthread_posix_cond_signal,
0179 evthread_posix_cond_wait
0180 };
0181 /* Set ourselves up to get recursive locks. */
0182 if (pthread_mutexattr_init(&attr_recursive))
0183 return -1;
0184 if (pthread_mutexattr_settype(&attr_recursive, PTHREAD_MUTEX_RECURSIVE))
0185 return -1;
0186
0187 evthread_set_lock_callbacks(&cbs);
0188 evthread_set_condition_callbacks(&cond_cbs);
0189 evthread_set_id_callback(evthread_posix_get_id);
0190 return 0;
0191 }
在这个 evthread_use_pthreads 函数当中它做了如下的事情：
struct evthread_lock_callbacks 这个结构体，是用来描述一个多线程库的接口的，这会被用于进行上锁：
0091 /** This structure describes the interface a threading library uses for
0092 * locking. It‘s used to tell evthread_set_lock_callbacks() how to use
0093 * locking on this platform.
0094 */
0095 struct evthread_lock_callbacks {
0096 /** The current version of the locking API. Set this to
0097 * EVTHREAD_LOCK_API_VERSION */
0098 int lock_api_version;
0099 /** Which kinds of locks does this version of the locking API
0100 * support? A bitfield of EVTHREAD_LOCKTYPE_RECURSIVE and
0101 * EVTHREAD_LOCKTYPE_READWRITE.
0102 *
0103 * (Note that RECURSIVE locks are currently mandatory, and
0104 * READWRITE locks are not currently used.)
0105 **/
0106 unsigned supported_locktypes;
0107 /** Function to allocate and initialize new lock of type ‘locktype‘.
0108 * Returns NULL on failure. */
0109 void *(*alloc)(unsigned locktype);
0110 /** Funtion to release all storage held in ‘lock‘, which was created
0111 * with type ‘locktype‘. */
0112 void (*free)(void *lock, unsigned locktype);
0113 /** Acquire an already-allocated lock at ‘lock‘ with mode ‘mode‘.
0114 * Returns 0 on success, and nonzero on failure. */
0115 int (*lock)(unsigned mode, void *lock);
0116 /** Release a lock at ‘lock‘ using mode ‘mode‘. Returns 0 on success,
0117 * and nonzero on failure. */
0118 int (*unlock)(unsigned mode, void *lock);
0119 };
另外一个结构体是struct evthread_condition_callbacks， 这个结构体是用来描写一个线程库的接口用来作条件变量，这是用来告诉 evthread_set_condition_callbacks 要怎么使用locking 在这个平台上：