【原创】MySQL Proxy中socketpair的使用

      学习 MySQL Proxy 0.8.3 的源码后可知，其全部事件处理线程均对全局 socketpair 的读端进行了监听，以实现通知管道的功能：threads->event_notify_fds[0] 。

int chassis_event_threads_init_thread(chassis_event_threads_t *threads, chassis_event_thread_t *event_thread, chassis *chas) {

	event_thread->event_base = event_base_new();
  ...
	// 设置当前线程监听 fd 为 socketpair 的读端 fd
	event_thread->notify_fd = dup(threads->event_notify_fds[0]);
  ...
	event_set(&(event_thread->notify_fd_event), event_thread->notify_fd, EV_READ | EV_PERSIST, chassis_event_handle, event_thread);
	event_base_set(event_thread->event_base, &(event_thread->notify_fd_event));
	event_add(&(event_thread->notify_fd_event), NULL);

	return 0;
}

该 socketpair 是在主线程初始化过程中创建的：

chassis_event_threads_t *chassis_event_threads_new() {
  ...
	threads = g_new0(chassis_event_threads_t, 1);

	/* create the ping-fds
	 *
	 * the event-thread write a byte to the ping-pipe to trigger a fd-event when
	 * something is available in the event-async-queues
	 */
	// 创建 socketpair
	if (0 != evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, threads->event_notify_fds)) {
	...
	}
  ...
	/* make both ends non-blocking */
	evutil_make_socket_nonblocking(threads->event_notify_fds[0]);
	evutil_make_socket_nonblocking(threads->event_notify_fds[1]);

	return threads;
}

其中 evutil_socketpair 实现如下（取自 libevent 1.4.13）： 

int
evutil_socketpair(int family, int type, int protocol, int fd[2])
{
#ifndef WIN32
	return socketpair(family, type, protocol, fd);
#else
	/* This code is originally from Tor.  Used with permission. */

	/* This socketpair does not work when localhost is down. So
	 * it's really not the same thing at all. But it's close enough
	 * for now, and really, when localhost is down sometimes, we
	 * have other problems too.
	 */
	int listener = -1;
	int connector = -1;
	int acceptor = -1;
	struct sockaddr_in listen_addr;
	struct sockaddr_in connect_addr;
	int size;
	int saved_errno = -1;

	if (protocol
#ifdef AF_UNIX
		|| family != AF_UNIX
#endif
		) {
		EVUTIL_SET_SOCKET_ERROR(WSAEAFNOSUPPORT);
		return -1;
	}
	if (!fd) {
		EVUTIL_SET_SOCKET_ERROR(WSAEINVAL);
		return -1;
	}

	// 创建作为listener 的socket
	listener = socket(AF_INET, type, 0);
	if (listener < 0)
		return -1;
	memset(&listen_addr, 0, sizeof(listen_addr));
	listen_addr.sin_family = AF_INET;
	listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	listen_addr.sin_port = 0;	/* kernel chooses port.	 */
	// 进行绑定，内核会分配port
	if (bind(listener, (struct sockaddr *) &listen_addr, sizeof (listen_addr)) == -1)
		goto tidy_up_and_fail;
	// 宣告开始监听连接请求
	if (listen(listener, 1) == -1)
		goto tidy_up_and_fail;

       // 创建作为connector 的socket
	connector = socket(AF_INET, type, 0);
	if (connector < 0)
		goto tidy_up_and_fail;
	/* We want to find out the port number to connect to.  */
	size = sizeof(connect_addr);
	// 获取bind 后内核为listener 分配的port ( ip 为INADDR_LOOPBACK )
	if (getsockname(listener, (struct sockaddr *) &connect_addr, &size) == -1)
		goto tidy_up_and_fail;
	if (size != sizeof (connect_addr))
		goto abort_tidy_up_and_fail;
	// 从connector 向listener 发起连接，connect_addr 为连接目的地址
	if (connect(connector, (struct sockaddr *) &connect_addr, sizeof(connect_addr)) == -1)
		goto tidy_up_and_fail;

	size = sizeof(listen_addr);
	// 在套接字listener 上accept ，函数返回后listen_addr 中为对端地址
	acceptor = accept(listener, (struct sockaddr *) &listen_addr, &size);
	if (acceptor < 0)
		goto tidy_up_and_fail;
	if (size != sizeof(listen_addr))
		goto abort_tidy_up_and_fail;
	// 关闭listener
	EVUTIL_CLOSESOCKET(listener);
	/* Now check we are talking to ourself by matching port and host on the
	   two sockets.	 */
	// 获取connect 后内核为connector 分配的地址信息-- 自动绑定功能
	if (getsockname(connector, (struct sockaddr *) &connect_addr, &size) == -1)
		goto tidy_up_and_fail;
	// 将从两侧分别获得的地址地址进行比较
	if (size != sizeof (connect_addr)
		|| listen_addr.sin_family != connect_addr.sin_family
		|| listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
		|| listen_addr.sin_port != connect_addr.sin_port)
		goto abort_tidy_up_and_fail;
	fd[0] = connector;
	fd[1] = acceptor;

	return 0;

 abort_tidy_up_and_fail:
	saved_errno = WSAECONNABORTED;
 tidy_up_and_fail:
	if (saved_errno < 0)
		saved_errno = WSAGetLastError();
	if (listener != -1)
		EVUTIL_CLOSESOCKET(listener);
	if (connector != -1)
		EVUTIL_CLOSESOCKET(connector);
	if (acceptor != -1)
		EVUTIL_CLOSESOCKET(acceptor);

	EVUTIL_SET_SOCKET_ERROR(saved_errno);
	return -1;
#endif
}

      从上述实现中可以看出，在非 WIN32 平台，直接就可以使用现成的 API 函数创建 socketpair ；在 WIN32 平台上，是通过创建两个本地 socket 相互连接建立的 socketpair 。

      实现上述功能的另外一种方式是，使用 pipe 。用法很简单，摘抄代码如下（摘自 memcached-1.4.14）：

void thread_init(int nthreads, struct event_base *main_base) {
...
    // nthreads 为创建的工作线程数
    for (i = 0; i < nthreads; i++) {
        int fds[2];
        if (pipe(fds)) {  // 使用pipe 作为工作线程获取任务的通道
            perror("Can't create notify pipe");
            exit(1);
        }

        threads[i].notify_receive_fd = fds[0];  // 读端
        threads[i].notify_send_fd = fds[1];  // 写端

        // 设置用于每个工作线程的libevent 相关信息并创建CQ 结构
        setup_thread(&threads[i]);
        ...
    }

    /* Create threads after we've done all the libevent setup. */
    // 创建工作线程
    for (i = 0; i < nthreads; i++) {
        create_worker(worker_libevent, &threads[i]);
    }
...
}

       至于用哪种更好，大家自己思考~~

====== 更新 2013-11-11 ======

      最近写 Modb 代码时，想要利用上面的线程间通信机制，所以使用了相对简单的 pipe 实现方案，但在 windows 下调试时总会遇到  “Unknown error 10038” 错误。查阅相关文档后发现，结论是  windows 下不能将 pipe 和 select 一起使用，因为会认为 pipe 不是一个合法的 socket 句柄，然后 linux 下是没有这个问题的。
解决方案：

• 通过 socket 模拟 pipe 的实现；
• 使用上面的 socketpair 实现；

      网上找到一份“为了 windows 上能够对 pipe 句柄进行 select” 而采用 socket 模拟 pipe 的 实现 。代码留存如下：

int pipe(int fildes[2])
{
    int tcp1, tcp2;
    sockaddr_in name;
    memset(&name, 0, sizeof(name));
    name.sin_family = AF_INET;
    name.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    int namelen = sizeof(name);
    tcp1 = tcp2 = -1;

    int tcp = socket(AF_INET, SOCK_STREAM, 0);
    if (tcp == -1){
        goto clean;
    }
    if (bind(tcp, (sockaddr*)&name, namelen) == -1){
        goto clean;
    }
    if (listen(tcp, 5) == -1){
        goto clean;
    }
    if (getsockname(tcp, (sockaddr*)&name, &namelen) == -1){
        goto clean;
    }
    tcp1 = socket(AF_INET, SOCK_STREAM, 0);
    if (tcp1 == -1){
        goto clean;
    }
    if (-1 == connect(tcp1, (sockaddr*)&name, namelen)){
        goto clean;
    }

    tcp2 = accept(tcp, (sockaddr*)&name, &namelen);
    if (tcp2 == -1){
        goto clean;
    }
    if (closesocket(tcp) == -1){
        goto clean;
    }
    fildes[0] = tcp1;
    fildes[1] = tcp2;
    return 0;
clean:
    if (tcp != -1){
        closesocket(tcp);
    }
    if (tcp2 != -1){
        closesocket(tcp2);
    }
    if (tcp1 != -1){
        closesocket(tcp1);
    }
    return -1;
}

原文作者指出有如下缺点： 

• 效率低下（是否所有其他实现方式都比基于 socket 的方式高效？）
• 占用了两个 TCP 端口（pipe 不会占用端口）
• accept 的返回值未必就是 tcp1 连接过来的（多线程或者别的进程在干预）， 所以最好通过发送数据进行确认（这个比较严重，在有多个连接同时进入的时候确实无法保证当前连接时正确的）
• 由于不是匿名的， 所以可以在 netstat 里面看到（看到又怎样？）

优点只有一个, 可以使用 select 调用。

      将该 pipe 实现和上面的 socketpair 的实现进行对比，发现两者根本就是同一个东东，并且 pipe 的实现没有 libevent 中 socketpair 实现写的好。所以 pipe 实现的作者指出的那些缺点，本人持保留意见。看客自己斟酌。

补充：由于上面的 socketpair 是基于  INADDR_LOOPBACK 的，所以如果 lo 必须处于 up 状态才行。