Memcached源代码分析 - Memcached源代码分析之消息回应（3）

文章列表：

《Memcached源代码分析 - Memcached源代码分析之基于Libevent的网络模型（1）》

《Memcached源代码分析 - Memcached源代码分析之命令解析（2）》

《Memcached源代码分析 - Memcached源代码分析之消息回应（3）  》

《Memcached源代码分析 - Memcached源代码分析之HashTable（4） 》

《Memcached源代码分析 - Memcached源代码分析之增删改查操作（5） 》

《Memcached源代码分析 - Memcached源代码分析之LRU算法（6）》

《Memcached源代码分析 - Memcached源代码分析之存储机制Slabs（7）》

《Memcached源代码分析 - Memcached源代码分析之总结篇（8）》

前言

上一章《Memcached源代码分析 - Memcached源代码分析之命令解析（2）》。我们花了非常大的力气去解说Memcached怎样从client读取命令，而且解析命令，然后处理命令而且向client回应消息。

这一章，我们主要来解说Memcached回应消息的技术细节。

本章前，我们先须要了解几个知识点(msghdr和iovc)。

msghdr结构：

struct msghdr {
     void *msg_name;
     socklen_t msg_namelen;
     struct iovec *msg_iov;
     size_t msg_iovlen;
     void *msg_control;
     size_t msg_controllen;
     int msg_flags;
};

iovc结构：

#include <sys/uio.h>
/* Structure for scatter/gather I/O. */
struct iovec {
    void *iov_base; /* Pointer to data. */
    size_t iov_len; /* Length of data. */
};

Memcached是通过sendmsg函数向client发送数据的，就会用到上面的结构，不了解这个结构的。建议先了解之后再继续往下看。

Memcached消息回应源代码分析

数据结构

我们继续看一下conn这个结构。

conn结构我们上一期说过，主要是存储单个client的连接详情信息。

每个client连接到Memcached都会有这么一个数据结构。

typedef struct conn conn;
struct conn {
    //....
    /* data for the mwrite state */
    //iov主要存储iov的数据结构
    //iov数据结构会在conn_new中初始化，初始化的时候，系统会分配400个iovec的结构，最高水位600个
    struct iovec *iov;
    //iov的长度
    int    iovsize;   /* number of elements allocated in iov[] */
    //iovused 这个主要记录iov使用了多少
    int    iovused;   /* number of elements used in iov[] */
 
    //msglist主要存储msghdr的列表数据结构
    //msglist数据结构在conn_new中初始化的时候。系统会分配10个结构
    struct msghdr *msglist;
    //msglist的长度。初始化为10个，最高水位100。不够用的时候会realloc。每次扩容都会扩容一倍
    int    msgsize;   /* number of elements allocated in msglist[] */
    //msglist已经使用的长度
    int    msgused;   /* number of elements used in msglist[] */
    //这个參数主要帮助记录那些msglist已经发送过了，哪些没有发送过。
    int    msgcurr;   /* element in msglist[] being transmitted now */
    int    msgbytes;  /* number of bytes in current msg */
}

我们能够看一下conn_new这种方法。这种方法应该在第一章节的时候讲到过。

这边主要看一下iov和msglist两个參数初始化的过程。

conn *conn_new(const int sfd, enum conn_states init_state,
		const int event_flags, const int read_buffer_size,
		enum network_transport transport, struct event_base *base) {
//...
		c->rbuf = c->wbuf = 0;
		c->ilist = 0;
		c->suffixlist = 0;
		c->iov = 0;
		c->msglist = 0;
		c->hdrbuf = 0;
 
		c->rsize = read_buffer_size;
		c->wsize = DATA_BUFFER_SIZE;
		c->isize = ITEM_LIST_INITIAL;
		c->suffixsize = SUFFIX_LIST_INITIAL;
		c->iovsize = IOV_LIST_INITIAL; //初始化400
		c->msgsize = MSG_LIST_INITIAL; //初始化10
		c->hdrsize = 0;
 
		c->rbuf = (char *) malloc((size_t) c->rsize);
		c->wbuf = (char *) malloc((size_t) c->wsize);
		c->ilist = (item **) malloc(sizeof(item *) * c->isize);
		c->suffixlist = (char **) malloc(sizeof(char *) * c->suffixsize);
		c->iov = (struct iovec *) malloc(sizeof(struct iovec) * c->iovsize); //初始化iov
		c->msglist = (struct msghdr *) malloc(
				sizeof(struct msghdr) * c->msgsize); //初始化msglist
//...
}

数据结构关系图（iov和msglist之间的关系）：

从process_get_command開始

我们继续从process_get_command，获取memcached的缓存数据这种方法開始。

在这种方法中。我们主要看add_iov这种方法。Memcached主要是通过add_iov方法，将须要发送给client的数据装到iov和msglist结构中去的。

/* ntokens is overwritten here... shrug.. */
//处理GET请求的命令
static inline void process_get_command(conn *c, token_t *tokens, size_t ntokens,
		bool return_cas) {
	//处理GET命令
	char *key;
	size_t nkey;
	int i = 0;
	item *it;
	//&tokens[0] 是操作的方法
	//&tokens[1] 为key
	//token_t 存储了value和length
	token_t *key_token = &tokens[KEY_TOKEN];
	char *suffix;
	assert(c != NULL);
 
	do {
		//假设key的长度不为0
		while (key_token->length != 0) {
 
			key = key_token->value;
			nkey = key_token->length;
 
			//推断key的长度是否超过了最大的长度。memcache key的最大长度为250
			//这个地方须要很注意，我们在寻常的使用中。还是要注意key的字节长度的
			if (nkey > KEY_MAX_LENGTH) {
				//out_string 向外部输出数据
				out_string(c, "CLIENT_ERROR bad command line format");
				while (i-- > 0) {
					item_remove(*(c->ilist + i));
				}
				return;
			}
			//这边是从Memcached的内存存储快中去取数据
			it = item_get(key, nkey);
			if (settings.detail_enabled) {
				//状态记录，key的记录数的方法
				stats_prefix_record_get(key, nkey, NULL != it);
			}
			//假设获取到了数据
			if (it) {
				//c->ilist 存放用于向外部写数据的buf
				//假设ilist太小，则又一次分配一块内存
				if (i >= c->isize) {
					item **new_list = realloc(c->ilist,
							sizeof(item *) * c->isize * 2);
					if (new_list) {
						//存放须要向client写数据的item的列表的长度
						c->isize *= 2;
						//存放须要向client写数据的item的列表，这边支持
						c->ilist = new_list;
					} else {
						STATS_LOCK();
						stats.malloc_fails++;
						STATS_UNLOCK();
						item_remove(it);
						break;
					}
				}
 
				/*
				 * Construct the response. Each hit adds three elements to the
				 * outgoing data list:
				 *   "VALUE "
				 *   key
				 *   " " + flags + " " + data length + "\r\n" + data (with \r\n)
				 */
				//初始化返回出去的数据结构
				if (return_cas) {
					//......
				} else {
					MEMCACHED_COMMAND_GET(c->sfd, ITEM_key(it), it->nkey,
							it->nbytes, ITEM_get_cas(it));
					//将须要返回的数据填充到IOV结构中
					//命令：get userId
					//返回的结构：
					//VALUE userId 0 5
					//55555
					//END
					if (<strong><span style="color:#FF0000;">add_iov</span></strong>(c, "VALUE ", 6) != 0
							|| <strong><span style="color:#FF0000;">add_iov</span></strong>(c, ITEM_key(it), it->nkey) != 0
							|| <strong><span style="color:#FF0000;">add_iov</span></strong>(c, ITEM_suffix(it),
									it->nsuffix + it->nbytes) != 0) {
						item_remove(it);
						break;
					}
				}
 
				if (settings.verbose > 1) {
					int ii;
					fprintf(stderr, ">%d sending key ", c->sfd);
					for (ii = 0; ii < it->nkey; ++ii) {
						fprintf(stderr, "%c", key[ii]);
					}
					fprintf(stderr, "\n");
				}
 
				/* item_get() has incremented it->refcount for us */
				pthread_mutex_lock(&c->thread->stats.mutex);
				c->thread->stats.slab_stats[it->slabs_clsid].get_hits++;
				c->thread->stats.get_cmds++;
				pthread_mutex_unlock(&c->thread->stats.mutex);
				item_update(it);
				*(c->ilist + i) = it;
				i++;
 
			} else {
				pthread_mutex_lock(&c->thread->stats.mutex);
				c->thread->stats.get_misses++;
				c->thread->stats.get_cmds++;
				pthread_mutex_unlock(&c->thread->stats.mutex);
				MEMCACHED_COMMAND_GET(c->sfd, key, nkey, -1, 0);
			}
 
			key_token++;
		}
 
		/*
		 * If the command string hasn't been fully processed, get the next set
		 * of tokens.
		 */
		//假设命令行中的命令没有所有被处理，则继续下一个命令
		//一个命令行中，能够get多个元素
		if (key_token->value != NULL) {
			ntokens = tokenize_command(key_token->value, tokens, MAX_TOKENS);
			key_token = tokens;
		}
 
	} while (key_token->value != NULL);
 
	c->icurr = c->ilist;
	c->ileft = i;
	if (return_cas) {
		c->suffixcurr = c->suffixlist;
		c->suffixleft = i;
	}
 
	if (settings.verbose > 1)
		fprintf(stderr, ">%d END\n", c->sfd);
 
	/*
	 If the loop was terminated because of out-of-memory, it is not
	 reliable to add END\r\n to the buffer, because it might not end
	 in \r\n. So we send SERVER_ERROR instead.
	 */
	//加入结束标志符号
	if (key_token->value != NULL || <strong><span style="color:#FF0000;">add_iov</span></strong>(c, "END\r\n", 5) != 0
			|| (IS_UDP(c->transport) && build_udp_headers(c) != 0)) {
		out_of_memory(c, "SERVER_ERROR out of memory writing get response");
	} else {
		//将状态改动为写，这边读取到item的数据后，又開始须要往client写数据了。
 
conn_set_state(c, conn_mwrite);
		c->msgcurr = 0;
	}
}

add_iov 方法

add_iov方法，主要作用：

1. 将Memcached须要发送的数据。分成N多个IOV的块

2. 将IOV块加入到msghdr的结构中去。

static int add_iov(conn *c, const void *buf, int len) {
	struct msghdr *m;
	int leftover;
	bool limit_to_mtu;
 
	assert(c != NULL);
 
	do {
		//消息数组 msglist 存储msghdr结构
		//这边是获取最新的msghdr数据结构指针
		m = &c->msglist[c->msgused - 1];
 
		/*
		 * Limit UDP packets, and the first payloads of TCP replies, to
		 * UDP_MAX_PAYLOAD_SIZE bytes.
		 */
		limit_to_mtu = IS_UDP(c->transport) || (1 == c->msgused);
 
		/* We may need to start a new msghdr if this one is full. */
		//假设msghdr结构中的iov满了。则须要使用更新的msghdr数据结构
		if (m->msg_iovlen == IOV_MAX
				|| (limit_to_mtu && c->msgbytes >= UDP_MAX_PAYLOAD_SIZE)) {
			//加入msghdr,这种方法中回去推断初始化的时候10个msghdr结构是否够用。不够用的话会扩容
			add_msghdr(c);
			//指向下一个新的msghdr数据结构
			m = &c->msglist[c->msgused - 1];
		}
 
		//确认IOV的空间大小，初始化默认是400个，水位600
		//假设IOV也不够用了。就会去扩容
		if (ensure_iov_space(c) != 0)
			return -1;
 
		/* If the fragment is too big to fit in the datagram, split it up */
		if (limit_to_mtu && len + c->msgbytes > UDP_MAX_PAYLOAD_SIZE) {
			leftover = len + c->msgbytes - UDP_MAX_PAYLOAD_SIZE;
			len -= leftover;
		} else {
			leftover = 0;
		}
 
		m = &c->msglist[c->msgused - 1];
		//m->msg_iov參数指向c->iov这个结构。
		//详细m->msg_iov怎样指向到c->iov这个结构的，须要看一下add_msghdr这种方法
		//向IOV中填充BUF
		m->msg_iov[m->msg_iovlen].iov_base = (void *) buf;
		//buf的长度
		m->msg_iov[m->msg_iovlen].iov_len = len; //填充长度
 
		c->msgbytes += len;
		c->iovused++;
		m->msg_iovlen++; //msg_iovlen + 1
 
		buf = ((char *) buf) + len;
		len = leftover;
	} while (leftover > 0);
 
	return 0;
}

add_msghdr 方法 msghdr扩容

在add_iov方法中，我们能够看到。当IOV块加入满了之后，会调用这种方法扩容msgdhr的个数。

这种方法主要两个作用：

1. 检查c->msglist列表长度是否够用。

2. 使用最新的c->msglist中的一个msghdr元素，而且将msghdr->msg_iov指向c->iov最新未使用的那个iov的指针地址。

static int add_msghdr(conn *c) {
	//c->msglist 这个列表用来存储msghdr结构
	struct msghdr *msg;
 
	assert(c != NULL);
 
	//假设msglist的长度和已经使用的长度相等的时候，说明msglist已经用完了，须要扩容
	if (c->msgsize == c->msgused) {
		//扩容两倍
		msg = realloc(c->msglist, c->msgsize * 2 * sizeof(struct msghdr));
		if (!msg) {
			STATS_LOCK();
			stats.malloc_fails++;
			STATS_UNLOCK();
			return -1;
		}
		c->msglist = msg; //将c->msglist指向当前新的列表
		c->msgsize *= 2; //size也会跟着添加
	}
 
	//msg又一次指向未使用的msghdr指针位置
	msg = c->msglist + c->msgused;
 
	/* this wipes msg_iovlen, msg_control, msg_controllen, and
	 msg_flags, the last 3 of which aren't defined on solaris: */
	//将新的msghdr块初始化设置为0
	memset(msg, 0, sizeof(struct msghdr));
 
	//新的msghdr的msg_iov指向 struct iovec *iov结构
	msg->msg_iov = &c->iov[c->iovused];
 
	if (IS_UDP(c->transport) && c->request_addr_size > 0) {
		msg->msg_name = &c->request_addr;
		msg->msg_namelen = c->request_addr_size;
	}
 
	c->msgbytes = 0;
	c->msgused++;
 
	if (IS_UDP(c->transport)) {
		/* Leave room for the UDP header, which we'll fill in later. */
		return add_iov(c, NULL, UDP_HEADER_SIZE);
	}
 
	return 0;
}

ensure_iov_space 方法 IOV扩容

这种方法主要检查c->iov是否还有剩余空间。假设不够用了。则扩容2倍。

static int ensure_iov_space(conn *c) {
	assert(c != NULL);
 
	//假设IOV也使用完了....IOV，分配新的IOV
	if (c->iovused >= c->iovsize) {
		int i, iovnum;
		struct iovec *new_iov = (struct iovec *) realloc(c->iov,
				(c->iovsize * 2) * sizeof(struct iovec));
		if (!new_iov) {
			STATS_LOCK();
			stats.malloc_fails++;
			STATS_UNLOCK();
			return -1;
		}
		c->iov = new_iov;
		c->iovsize *= 2; //扩容两倍
 
		/* Point all the msghdr structures at the new list. */
		for (i = 0, iovnum = 0; i < c->msgused; i++) {
			c->msglist[i].msg_iov = &c->iov[iovnum];
			iovnum += c->msglist[i].msg_iovlen;
		}
	}
 
	return 0;
}

conn_mwrite

conn_mwrite状态在drive_machine这种方法中。

主要就是向client写数据了。

从上面的add_iov方法中，我们知道Memcached会将须要待发送的数据写入c->msglist结构中。

真正写数据的方法是transmit。

//drive_machine方法
		//这个conn_mwrite是向client写数据
		case conn_mwrite:
			if (IS_UDP(c->transport) && c->msgcurr == 0
					&& build_udp_headers(c) != 0) {
				if (settings.verbose > 0)
					fprintf(stderr, "Failed to build UDP headers\n");
				conn_set_state(c, conn_closing);
				break;
			}
			//transmit这种方法很重要，主要向client写数据的操作都在这种方法中进行
			//返回transmit_result枚举类型。用于推断是否写成功，假设失败，则关闭连接
			switch (transmit(c)) {
 
			//假设向client发送数据成功
			case TRANSMIT_COMPLETE:
				if (c->state == conn_mwrite) {
					conn_release_items(c);
					/* XXX:  I don't know why this wasn't the general case */
					if (c->protocol == binary_prot) {
						conn_set_state(c, c->write_and_go);
					} else {
						//这边是TCP的状态
						//状态又会切回到conn_new_cmd这个状态
						//conn_new_cmd主要是继续解析c->rbuf容器中剩余的命令參数
						conn_set_state(c, conn_new_cmd);
					}
				} else if (c->state == conn_write) {
					if (c->write_and_free) {
						free(c->write_and_free);
						c->write_and_free = 0;
					}
					conn_set_state(c, c->write_and_go);
				} else {
					if (settings.verbose > 0)
						fprintf(stderr, "Unexpected state %d\n", c->state);
					conn_set_state(c, conn_closing);
				}
				break;

transmit 方法

这种方法主要作用：向client发送数据

//这种方法主要向client写数据
//假设数据没有发送完，则会一直循环conn_mwrite这个状态，直到数据发送完毕为止
static enum transmit_result transmit(conn *c) {
	assert(c != NULL);
 
	//每次发送之前，都会来校验前一次的数据是否发送完了
	//假设前一次的msghdr结构体内的数据已经发送完了，则c->msgcurr指针就会往后移动一位，
	//移动到下一个等待发送的msghdr结构体指针上
	//c->msgcurr初始值为：0
	if (c->msgcurr < c->msgused && c->msglist[c->msgcurr].msg_iovlen == 0) {
		/* Finished writing the current msg; advance to the next. */
		c->msgcurr++;
	}
 
	//假设c->msgcurr（已发送）小于c->msgused（已使用），则就能够知道还没发送完，则须要继续发送
	//假设c->msgcurr（已发送）等于c->msgused（已使用），则说明已经发送完了。返回TRANSMIT_COMPLETE状态
	if (c->msgcurr < c->msgused) {
		ssize_t res;
 
		//从c->msglist取出一个待发送的msghdr结构
		struct msghdr *m = &c->msglist[c->msgcurr];
		//向client发送数据
		res = sendmsg(c->sfd, m, 0);
		//发送成功的情况
		if (res > 0) {
			pthread_mutex_lock(&c->thread->stats.mutex);
			c->thread->stats.bytes_written += res;
			pthread_mutex_unlock(&c->thread->stats.mutex);
 
			/* We've written some of the data. Remove the completed
			 iovec entries from the list of pending writes. */
			//这边会检查发送了多少
			while (m->msg_iovlen > 0 && res >= m->msg_iov->iov_len) {
				res -= m->msg_iov->iov_len;
				m->msg_iovlen--;
				m->msg_iov++;
			}
 
			/* Might have written just part of the last iovec entry;
			 adjust it so the next write will do the rest. */
			if (res > 0) {
				m->msg_iov->iov_base = (caddr_t) m->msg_iov->iov_base + res;
				m->msg_iov->iov_len -= res;
			}
			return TRANSMIT_INCOMPLETE;
		}
		//发送失败的情况
		if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
			if (!update_event(c, EV_WRITE | EV_PERSIST)) {
				if (settings.verbose > 0)
					fprintf(stderr, "Couldn't update event\n");
				conn_set_state(c, conn_closing);
				return TRANSMIT_HARD_ERROR;
			}
			return TRANSMIT_SOFT_ERROR;
		}
		/* if res == 0 or res == -1 and error is not EAGAIN or EWOULDBLOCK,
		 we have a real error, on which we close the connection */
		if (settings.verbose > 0)
			perror("Failed to write, and not due to blocking");
 
		if (IS_UDP(c->transport))
			conn_set_state(c, conn_read);
		else
			conn_set_state(c, conn_closing);
		return TRANSMIT_HARD_ERROR;
	} else {
		return TRANSMIT_COMPLETE;
	}
}

conn_shrink 方法

当数据发送成功后。会跳转到conn_new_cmd这个状态继续处理，然后进入reset_cmd_handler方法，然后进入conn_shrink方法。

conn_shrink主要是用于检查buf的大小，是否超过了预定的水位，假设超过了，则须要又一次realloc。

//又一次设置命令handler
static void reset_cmd_handler(conn *c) {
	c->cmd = -1;
	c->substate = bin_no_state;
	if (c->item != NULL) {
		item_remove(c->item);
		c->item = NULL;
	}
	conn_shrink(c); //这种方法是检查c->rbuf容器的大小
	//假设剩余未解析的命令 > 0的话，继续跳转到conn_parse_cmd解析命令
	if (c->rbytes > 0) {
		conn_set_state(c, conn_parse_cmd);
	} else {
		//假设命令都解析完毕了。则继续等待新的数据到来
		conn_set_state(c, conn_waiting);
	}
}

//检查rbuf的大小
static void conn_shrink(conn *c) {
	assert(c != NULL);
 
	if (IS_UDP(c->transport))
		return;
 
	//假设bufsize大于READ_BUFFER_HIGHWAT（8192）的时候须要又一次处理
	//DATA_BUFFER_SIZE等于2048，所以我们能够看到之前的代码中对rbuf最多仅仅能进行4次recalloc
	if (c->rsize > READ_BUFFER_HIGHWAT && c->rbytes < DATA_BUFFER_SIZE) {
		char *newbuf;
 
		if (c->rcurr != c->rbuf)
			memmove(c->rbuf, c->rcurr, (size_t) c->rbytes); //内存移动
 
		newbuf = (char *) realloc((void *) c->rbuf, DATA_BUFFER_SIZE);
 
		if (newbuf) {
			c->rbuf = newbuf;
			c->rsize = DATA_BUFFER_SIZE;
		}
		/* TODO check other branch... */
		c->rcurr = c->rbuf;
	}
 
	if (c->isize > ITEM_LIST_HIGHWAT) {
		item **newbuf = (item**) realloc((void *) c->ilist,
				ITEM_LIST_INITIAL * sizeof(c->ilist[0]));
		if (newbuf) {
			c->ilist = newbuf;
			c->isize = ITEM_LIST_INITIAL;
		}
		/* TODO check error condition? */
	}
 
	//假设大于c->msglist的水位了。则又一次realloc
	if (c->msgsize > MSG_LIST_HIGHWAT) {
		struct msghdr *newbuf = (struct msghdr *) realloc((void *) c->msglist,
				MSG_LIST_INITIAL * sizeof(c->msglist[0]));
		if (newbuf) {
			c->msglist = newbuf;
			c->msgsize = MSG_LIST_INITIAL;
		}
		/* TODO check error condition? */
	}
 
	//假设大于c->iovsize的水位了，则又一次realloc
	if (c->iovsize > IOV_LIST_HIGHWAT) {
		struct iovec *newbuf = (struct iovec *) realloc((void *) c->iov,
				IOV_LIST_INITIAL * sizeof(c->iov[0]));
		if (newbuf) {
			c->iov = newbuf;
			c->iovsize = IOV_LIST_INITIAL;
		}
		/* TODO check return value */
	}
}