Memcached源码分析之memcached.c

Memcached 32869℃

作者:Calix

memcached.c 由于代码太多,在此省略了部分代码,例如UPD连接,二进制协议,某些错误输出和调试输出等,建议从main函数开始看起。

 #include "memcached.h"
//尝试从socket中读取数据的结果枚举
enum try_read_result {
    READ_DATA_RECEIVED,
    READ_NO_DATA_RECEIVED,
    READ_ERROR, /** an error occured (on the socket) (or client closed connection) */
    READ_MEMORY_ERROR /** failed to allocate more memory */
};
struct stats stats; //全局统计变量
struct settings settings; //全局配置变量
static conn *listen_conn = NULL;  //全局的监听连接对象
static int max_fds; //fds上限
static struct event_base *main_base; //主线程的event_base 对象
//向客户端发送数据的结果枚举
enum transmit_result {
    TRANSMIT_COMPLETE, /** All done writing. */
    TRANSMIT_INCOMPLETE, /** More data remaining to write. */
    TRANSMIT_SOFT_ERROR, /** Can't write any more right now. */
    TRANSMIT_HARD_ERROR /** Can't write (c->state is set to conn_closing) */
};
extern pthread_mutex_t conn_lock; //连接锁

/**
创建连接函数,参数为:
sfd 要监听的socket fd
init_state 连接的初始化状态conn_states
event_flags 监听的事件
read_buffer_size 读缓存大小
transport 监听的socket 类型
base event_base
 
每监听一个fd(listen fd和client fd)都会创建这样一个conn来保存相关信息,表示一个“连接”,
无论连接是已经连接上了,还是仅仅处于listen状态。
*/
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) {
    conn *c;
    assert(sfd >= 0 && sfd < max_fds);
    c = conns[sfd];
    if (NULL == c) {
        if (!(c = (conn *)calloc(1, sizeof(conn)))) {
            STATS_LOCK();
            stats.malloc_fails++;
            STATS_UNLOCK();
            fprintf(stderr, "Failed to allocate connection object\n");
            return NULL;
        }
        MEMCACHED_CONN_CREATE(c);
        c->rbuf = c->wbuf = 0;
        //c->xx省略部分初始化代码
        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);
        c->msglist = (struct msghdr *)malloc(sizeof(struct msghdr) * c->msgsize);
        if (c->rbuf == 0 || c->wbuf == 0 || c->ilist == 0 || c->iov == 0 ||
                c->msglist == 0 || c->suffixlist == 0) {
            conn_free(c);
            STATS_LOCK();
            stats.malloc_fails++;
            STATS_UNLOCK();
            fprintf(stderr, "Failed to allocate buffers for connection\n");
            return NULL;
        }
        STATS_LOCK();
        stats.conn_structs++;
        STATS_UNLOCK();
        c->sfd = sfd;
        conns[sfd] = c;
    }
    c->transport = transport;
    c->protocol = settings.binding_protocol;
    if (!settings.socketpath) {
        c->request_addr_size = sizeof(c->request_addr);
    } else {
        c->request_addr_size = 0;
    }
    if (transport == tcp_transport && init_state == conn_new_cmd) {
        if (getpeername(sfd, (struct sockaddr *) &c->request_addr,
                        &c->request_addr_size)) {
            perror("getpeername");
            memset(&c->request_addr, 0, sizeof(c->request_addr));
        }
    }
    if (settings.verbose > 1) {
       //省略向终端输出调试的代码
    }
    c->state = init_state;
    //c->xxx 省略部分初始化代码
    c->noreply = false;
    //创建事件,处理函数为event_handler,并把conn 连接对象传入event_handler中。
    //(主线程调用conn_new时:)在主线程,创建完listenfd后,调用此函数监听网络连接事件,此时conn对象的conn_state为conn_listening
   
    /**(建议看到worker线程调用conn_new时才看以下解析)
    (worker线程调用conn_new时)在worker线程,收到主线程丢过来的client fd时,调用此函数监听来自client fd的网络事件。
   
     也就是说,无论是主线程还是worker线程,都会调用此函数conn_new,创建conn连接对象,同时监听各自的fd。
     而且都是调用event_handler作处理,只是不一样的fd, 不一样的conn对象(即下面的(void *) c)
     进入 event_handler看看都做了啥?
    */
    event_set(&c->event, sfd, event_flags, event_handler, (void *)c);
    event_base_set(base, &c->event); //为事件设置事件基地
    c->ev_flags = event_flags;
    if (event_add(&c->event, 0) == -1) { //把事件加入监听
        perror("event_add");
        return NULL;
    }
    STATS_LOCK();
    stats.curr_conns++;
    stats.total_conns++;
    STATS_UNLOCK();
    MEMCACHED_CONN_ALLOCATE(c->sfd);
    return c;
}
//向客户端输出字符串
static void out_string(conn *c, const char *str) {
    size_t len;
    assert(c != NULL);
    if (c->noreply) {
        if (settings.verbose > 1)
            fprintf(stderr, ">%d NOREPLY %s\n", c->sfd, str);
        c->noreply = false;
        conn_set_state(c, conn_new_cmd);
        return;
    }
    if (settings.verbose > 1)
        fprintf(stderr, ">%d %s\n", c->sfd, str);
    /* Nuke a partial output... */
    c->msgcurr = 0;
    c->msgused = 0;
    c->iovused = 0;
    add_msghdr(c); //添加一个msghdr
    len = strlen(str);
    if ((len + 2) > c->wsize) {
        /* ought to be always enough. just fail for simplicity */
        str = "SERVER_ERROR output line too long";
        len = strlen(str);
    }
    memcpy(c->wbuf, str, len); //把要发送的字符串写入wbuf字段中
    memcpy(c->wbuf + len, "\r\n", 2); //添加换行回车符
    c->wbytes = len + 2;
    c->wcurr = c->wbuf;
    conn_set_state(c, conn_write); //把连接状态设置为conn_write,则状态机进入conn_write分支执行输出
    c->write_and_go = conn_new_cmd; //当状态机完成输出后要切换到的状态为conn_new_cmd
    return;
}
/**
无法分配内存时经常会调用此函数,例如内存空间已满,但又无法淘汰旧的item时,则向客户端响应一个错误
*/
static void out_of_memory(conn *c, char *ascii_error) {
    const static char error_prefix[] = "SERVER_ERROR ";
    const static int error_prefix_len = sizeof(error_prefix) - 1;
    if (c->protocol == binary_prot) {
        /* Strip off the generic error prefix; it's irrelevant in binary */
        if (!strncmp(ascii_error, error_prefix, error_prefix_len)) {
            ascii_error += error_prefix_len;
        }
        write_bin_error(c, PROTOCOL_BINARY_RESPONSE_ENOMEM, ascii_error, 0);
    } else {
        out_string(c, ascii_error);
    }
}
/*
 * 解析文本协议时,执行set/add/replace 命令并把value数据塞到item之后,调用此函数。
 * 这个函数的作用比较简单,主要是做一些收尾工作。
 *
 */
static void complete_nread_ascii(conn *c) {
    assert(c != NULL);
    item *it = c->item;
    int comm = c->cmd;
    enum store_item_type ret;
    pthread_mutex_lock(&c->thread->stats.mutex);
    c->thread->stats.slab_stats[it->slabs_clsid].set_cmds++;
    pthread_mutex_unlock(&c->thread->stats.mutex);
    if (strncmp(ITEM_data(it) + it->nbytes - 2, "\r\n", 2) != 0) {
        out_string(c, "CLIENT_ERROR bad data chunk");
    } else {
      ret = store_item(it, comm, c);
    }
      switch (ret) {
      case STORED:
          out_string(c, "STORED");
          break;
      //省略其它
      default:
          out_string(c, "SERVER_ERROR Unhandled storage type.");
      }
    }
    //释放引用,注意仅仅是一个释放引用的逻辑,不一定把内存空间给释放掉
    //具体是否要把内存空间释放,说见item_remove和do_item_remove函数。而在此处,
    //一般都只是释放引用而已。
    item_remove(c->item); /* release the c->item reference */
    c->item = 0;
}
//重置命令处理
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->rbytes到底什么时候开始不为0了?为0的话,怎么执行这次的命令?
    回顾一下我们是怎么会调用到reset_cmd_handler这个地方:
    1)主线程监听到listen fd有连接上来,进入drive_machine的conn_listen状态,
        然后accept连接得到client fd,再dispatch_conn_new把client fd丢给某个worker线程
    2)某个worker线程收到主线程丢过来的client fd之后,把它加到那个worker线程自己的
        event_base,然后注册event_handler(event_handler主要是调drive_machine)作为事件处理函数,
        在注册event_handler的同时,初始化了一个conn对象作为drive_machine的参数,
        而这个对象中的rbytes为0。
    3)当worker线程监听的client fd第一次有命令请求过来时(注意是第一次),例如set key 0 0 4\r\n,
        worker线程的收到通知,然后陷入了event_handler再到drive_machine中去。。
        而此时,传过来的conn* c,c->state 为conn_new_cmd,而c->rbytes确实为0!!
        (再次强调是第一次有命令请求过来时)
    就在这个时候就进入reset_cmd_handler,当前你看到的这个地方了。继续分析之后做了些啥:
    4)第3)点得知,c->rbytes由此确实为0,所以在这种情况,必然会进入下面的else分支,
        状态机进入conn_waiting状态。。。。
    5)进入conn_waiting状态做了啥?就是把连接状态由conn_waiting变成conn_read,然后stop = true,退出
        状态机。没错,退出状态机了!结束本次event_handler了!这就是比较纠结之处,这次命令请求触发的
        event_handler居然只做了把状态由conn_new_cmd变成conn_read,然后再等待下次事件通知。
        (详见conn_waiting分支代码)
    6)那刚才那个命令请求怎么办?压根没有去读?例如set key 0 0 4\r\n这个命令的实质作用被忽略了吗?
        其实没有。。原因是libevent默认的是水平触发,也就是说,这个命令还没被读,下次继续触发。。。
        下次event_base会因为刚才那个命令再触发通知告诉worker线程,再次进入drive_machine,只是此时
        c->state是conn_read状态,conn_read分支才真正把这个命令执行!
    也就是说,当worker线程监听的client fd "第一次"有命令过来的时候,会触发两次event_base的通知!!
    */
    //这个rbytes大于0的情况,是当一次event中包含多个命令,
    //或者说多个\r\n时候,程序执行到第二个及以后命令的时候出现。
    if (c->rbytes > 0) {
        conn_set_state(c, conn_parse_cmd);
    } else {
        conn_set_state(c, c
            onn_waiting);
    }
}
enum store_item_type do_store_item(item *it, int comm, conn *c, const uint32_t hv) {
    char *key = ITEM_key(it);
    item *old_it = do_item_get(key, it->nkey, hv); //拿出旧的item
    enum store_item_type stored = NOT_STORED;
    item *new_it = NULL;
    int flags;
    if (old_it != NULL && comm == NREAD_ADD) {
        do_item_update(old_it); //更新item信息,其实主要是更新最近使用信息,即lru链表,。
    } else if (!old_it && (comm == NREAD_REPLACE
        || comm == NREAD_APPEND || comm == NREAD_PREPEND))
    {
    } else if (comm == NREAD_CAS) { //省略
    } else {
        if (comm == NREAD_APPEND || comm == NREAD_PREPEND) {
            if (ITEM_get_cas(it) != 0) {
                // CAS much be equal
                if (ITEM_get_cas(it) != ITEM_get_cas(old_it)) {
                    stored = EXISTS;
                }
            }
            if (stored == NOT_STORED) {
                flags = (int) strtol(ITEM_suffix(old_it), (char **) NULL, 10);
                new_it = do_item_alloc(key, it->nkey, flags, old_it->exptime, it->nbytes + old_it->nbytes - 2 /* CRLF */, hv);
                if (new_it == NULL) {
                    if (old_it != NULL)
                        do_item_remove(old_it);
                    return NOT_STORED;
                }
                if (comm == NREAD_APPEND) {
                    memcpy(ITEM_data(new_it), ITEM_data(old_it), old_it->nbytes);
                    memcpy(ITEM_data(new_it) + old_it->nbytes - 2 /* CRLF */, ITEM_data(it), it->nbytes);
                } else {
                    memcpy(ITEM_data(new_it), ITEM_data(it), it->nbytes);
                    memcpy(ITEM_data(new_it) + it->nbytes - 2 /* CRLF */, ITEM_data(old_it), old_it->nbytes);
                }
                it = new_it;
            }
        }
        //SET 命令会直接跑来这里,不仔细看还真不知道 -_-||
        /**
            会跑来这里的,NOT_STORED的都是还没执行"link"操作的情况。
            像NREAD_APPEND这些命令都是有link过的。
            至于什么是link,具体往下看。
        */
        if (stored == NOT_STORED) {
            if (old_it != NULL)
                /**
                如果要SET 的key已经存在,则用新的item覆盖新的。
                详见thread::item_replace和items::do_item_replace
                */
                item_replace(old_it, it, hv);
            else
            /**
                如果要SET 的不存在,则把item链接起来,这链接主要是做了一些关于这个item杂七
                杂八的工作,其实比较重要的两点:
                1)把item放到hash table ,作用就是为了能够很快通过key拿到item啦。
                2)插入到lru链表
                详见items::do_item_link
            */
                do_item_link(it, hv);
            c->cas = ITEM_get_cas(it);
            stored = STORED;
        }
    }
    if (old_it != NULL)
        do_item_remove(old_it); /* release our reference */
    if (new_it != NULL)
        do_item_remove(new_it);
    if (stored == STORED) {
        c->cas = ITEM_get_cas(it);
    }
    return stored;
}
static void process_update_command(conn *c, token_t *tokens, const size_t ntokens, int comm, bool handle_cas) {
    char *key;
    size_t nkey;
    unsigned int flags;
    int32_t exptime_int = 0;
    time_t exptime;
    int vlen;
    uint64_t req_cas_id=0;
    item *it;
    assert(c != NULL);
    set_noreply_maybe(c, tokens, ntokens);
    if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) {
        out_string(c, "CLIENT_ERROR bad command line format"); //key过长,out_string函数的作用是输出响应,
        //详见out_string定义处
        return;
    }
    key = tokens[KEY_TOKEN].value; //键名
    nkey = tokens[KEY_TOKEN].length; //键长度
    if (! (safe_strtoul(tokens[2].value, (uint32_t *)&flags)
           && safe_strtol(tokens[3].value, &exptime_int)
           && safe_strtol(tokens[4].value, (int32_t *)&vlen))) {
        out_string(c, "CLIENT_ERROR bad command line format");
        return;
    }
    exptime = exptime_int;
    if (exptime < 0)
        exptime = REALTIME_MAXDELTA + 1;
    if (handle_cas) {
        if (!safe_strtoull(tokens[5].value, &req_cas_id)) {
            out_string(c, "CLIENT_ERROR bad command line format");
            return;
        }
    }
    vlen += 2;
    if (vlen < 0 || vlen - 2 < 0) {
        out_string(c, "CLIENT_ERROR bad command line format");
        return;
    }
    if (settings.detail_enabled) {
        stats_prefix_record_set(key, nkey);
    }
    it = item_alloc(key, nkey, flags, realtime(exptime), vlen); //在这里执行内存分配工作。详见item_alloc
    if (it == 0) {
        //略
        return;
    }
    ITEM_set_cas(it, req_cas_id);
    c->item = it; //将item指针指向分配的item空间
    c->ritem = ITEM_data(it); //将 ritem 指向 it->data中要存放 value 的位置
    c->rlbytes = it->nbytes; //data的大小
    c->cmd = comm; //命令类型
    conn_set_state(c, conn_nread); //继续调用状态机,执行命令的另一半工作。
}
/**
这里就是对命令的解析和执行了,准确来说,这里只是执行了命令的一半,
然后根据命令类型再次改变conn_state使程序再次进入状态机,完成命令的
另一半工作
command此时的指针值等于conn的rcurr
*/
static void process_command(conn *c, char *command) {
    token_t tokens[MAX_TOKENS];
    size_t ntokens;
    int comm; //命令类型
    assert(c != NULL);
    MEMCACHED_PROCESS_COMMAND_START(c->sfd, c->rcurr, c->rbytes);
    if (settings.verbose > 1)
        fprintf(stderr, "<%d %s\n", c->sfd, command);
    c->msgcurr = 0;
    c->msgused = 0;
    c->iovused = 0;
    if (add_msghdr(c) != 0) {
        out_of_memory(c, "SERVER_ERROR out of memory preparing response");
        return;
    }
    /**
    下面这个tokenize_command是一个词法分析,把command分解成一个个token
    */
    ntokens = tokenize_command(command, tokens, MAX_TOKENS);
    //下面是对上面分解出来的token再进行语法分析,解析命令,下面的comm变量为最终解析出来命令类型
    if (ntokens >= 3 &&
        ((strcmp(tokens[COMMAND_TOKEN].value, "get") == 0) ||
         (strcmp(tokens[COMMAND_TOKEN].value, "bget") == 0))) {
        process_get_command(c, tokens, ntokens, false);
    } else if ((ntokens == 6 || ntokens == 7) &&xx//略
        //add/set/replace/prepend/append为“更新”命令,调用同一个函数执行命令。详见process_update_command定义处
        process_update_command(c, tokens, ntokens, comm, false);
    } else if ((ntokens == 7 || ntokens == 8) && (strcmp(tokens[COMMAND_TOKEN].value, "cas") == 0 && (comm = NREAD_CAS))) {
        process_update_command(c, tokens, ntokens, comm, true);
    } else if ((ntokens == 4 || ntokens == 5) && (strcmp(tokens[COMMAND_TOKEN].value, "incr") == 0)) {
        process_arithmetic_command(c, tokens, ntokens, 1);
    } else if (ntokens >= 3 && (strcmp(tokens[COMMAND_TOKEN].value, "gets") == 0)) {
        //执行get 命令
        process_get_command(c, tokens, ntokens, true);
    } else if ((ntokens == 4 || ntokens == 5) && (strcmp(tokens[COMMAND_TOKEN].value, "decr") == 0)) {
        process_arithmetic_command(c, tokens, ntokens, 0);
    } else if (ntokens >= 3 && ntokens <= 5 && (strcmp(tokens[COMMAND_TOKEN].value, "delete") == 0)) {
        //执行delete 删除命令
        process_delete_command(c, tokens, ntokens);
    }elseif{//省略其它命令。。。
    }
    return;
}
/*
 * if we have a complete line in the buffer, process it.
 */
static int try_read_command(conn *c) {
    assert(c != NULL);
    assert(c->rcurr <= (c->rbuf + c->rsize));
    assert(c->rbytes > 0);
   //省略掉UDP和二进制协议的逻辑
    if (c->protocol == binary_prot) {
    } else {
        char *el, *cont;
        if (c->rbytes == 0) //读buffer没有待解析的数据
            return 0;
        el = memchr(c->rcurr, '\n', c->rbytes); //找第一个命令的末尾,即换行符
        if (!el) {
            if (c->rbytes > 1024) {
                char *ptr = c->rcurr;
                while (*ptr == ' ') { /* ignore leading whitespaces */
                    ++ptr;
                }
                if (ptr - c->rcurr > 100 ||
                    (strncmp(ptr, "get ", 4) && strncmp(ptr, "gets ", 5))) {
                    conn_set_state(c, conn_closing);
                    return 1;
                }
            }
            /*
            如果没有找到换行符,则说明读到的数据还不足以成为一个完整的命令,
            返回0
            */
            return 0;
        }
        cont = el + 1; //下一个命令的开头
        /*
        下面这个if的作用是把el指向当前命令最后一个有效字符的下一个字符,即\r
        目的是为了在命令后面插上一个\0,字符串结束符。
        例如 GET abc\r\n******,变成GET abc\0\n*****,这样以后读出的字符串就是一个命令。
        */
        if ((el - c->rcurr) > 1 && *(el - 1) == '\r') {
            el--;
        }
        *el = '\0';
        assert(cont <= (c->rcurr + c->rbytes));
        c->last_cmd_time = current_time;
        process_command(c, c->rcurr); //执行命令。分析详见process_command
        //当前命令执行完之后,把当前指针rcurr指向 下一个命令的开头,并调用rbytes(剩余未处理字节数大小)
        //逻辑上相当于把已处理的命令去掉。
        c->rbytes -= (cont - c->rcurr);
        c->rcurr = cont;
        assert(c->rcurr <= (c->rbuf + c->rsize));
    }
    return 1;
}
static enum try_read_result try_read_network(conn *c) {
    enum try_read_result gotdata = READ_NO_DATA_RECEIVED;
    int res;
    int num_allocs = 0;
    assert(c != NULL);
    if (c->rcurr != c->rbuf) {
        if (c->rbytes != 0) /* otherwise there's nothing to copy */
            memmove(c->rbuf, c->rcurr, c->rbytes);
        c->rcurr = c->rbuf;
    }
    while (1) {
        if (c->rbytes >= c->rsize) {//读buffer空间扩充
            if (num_allocs == 4) {
                return gotdata;
            }
            ++num_allocs;
            char *new_rbuf = realloc(c->rbuf, c->rsize * 2);
            if (!new_rbuf) {
               //失败的情况,省略
            }
            c->rcurr = c->rbuf = new_rbuf;
            c->rsize *= 2;
        }
        int avail = c->rsize - c->rbytes; //读buffer的空间还剩余多少大小可以用
        res = read(c->sfd, c->rbuf + c->rbytes, avail); //往剩下的可用的地方里塞
        if (res > 0) {
            pthread_mutex_lock(&c->thread->stats.mutex);
            c->thread->stats.bytes_read += res;
            pthread_mutex_unlock(&c->thread->stats.mutex);
            gotdata = READ_DATA_RECEIVED;
            /**
            rbytes是当前指针rcurr至读buffer末尾的数据大小,这里可简单地理解为对rbytes的初始化。
            */
            c->rbytes += res;
            if (res == avail) { //可能还没读完,此时读buffer可用空间满了,那么下次循环会进行读buffer空间扩充
                continue;
            } else {
                break; //socket的可读数据都读完了
            }
        }
        if (res == 0) {
            return READ_ERROR;
        }
        if (res == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                break;
            }
            return READ_ERROR;
        }
    }
    return gotdata;
}
/**
通过状态机的方式处理网络请求/命令,后面的代码可以看到,
实质这里是根据
1)不同的conn连接对象,包括来自主线程的监听listen fd的连接或来自worker线程监听的client fd的连接
2)或者说是conn连接不同的状态,例如主线程监听listen fd连接通常是conn_listenning状态,
   而worker线程监听的client fd的连接 可能是conn_new_cmd,conn_read等状态
来进行不同的业务处理
*/
static void drive_machine(conn *c) {
    bool stop = false;
    int sfd;
    socklen_t addrlen;
    struct sockaddr_storage addr;
    int nreqs = settings.reqs_per_event; //每个连接可处理的最大请求数
    int res;
    const char *str;
#ifdef HAVE_ACCEPT4
    static int use_accept4 = 1;
#else
    static int use_accept4 = 0;
#endif
    assert(c != NULL);
    /**
     这里是事件被触发后处理业务逻辑的核心
     这个while循环里面有一个巨大的switch case,根据连接对象 conn当前
     的连接状态conn_state,进入不同的case,而每个case可能会改变conn的连接状态,
     也就是说在这个while+switch中,conn会不断的发生状态转移,最后被分发到合适的case上作处理。
     可以理解为,这里是一个有向图,每个case是一个顶点,有些case通过改变conn对象的连接状态让程序在
     下一次循环中进入另一个case,几次循环后程序最终进入到“无出度的顶点”然后结束状态机,
     这里的无出度的顶点就是带设置stop=true的case分支
    */
    while (!stop) {
        switch(c->state) {
        case conn_listening: //此case只有当listen fd有事件到达后触发主线程执行
            sfd = accept(c->sfd, (struct sockaddr *)&addr, &addrlen); //accept,得到client fd
            if (sfd == -1) {
            } else {
                /**
                accept成功后,调用dispatch_conn_new,把client fd交给 worker线程处理
                必须注意dispatch_conn_new 函数第二个参数:init_state,也就是
                创建连接对象的初始化状态,通过主线程分发给worker线程的client fd,最终
                建立的连接对象初始化状态为conn_new_cmd (当然这里只说的是TCP socket的情况,UDP socket暂不作分析)
                */
                dispatch_conn_new(sfd, conn_new_cmd, EV_READ | EV_PERSIST,
                                     DATA_BUFFER_SIZE, tcp_transport);
            }
            stop = true;
            break;
        case conn_waiting: //等待数据
            if (!update_event(c, EV_READ | EV_PERSIST)) {
                if (settings.verbose > 0)
                    fprintf(stderr, "Couldn't update event\n");
                conn_set_state(c, conn_closing);
                break;
            }
            conn_set_state(c, conn_read);  
            stop = true;
            break;
        case conn_read: //执行读数据
            res = IS_UDP(c->transport) ? try_read_udp(c) : try_read_network(c); //从网络上读取数据
            switch (res) {
            case READ_NO_DATA_RECEIVED:
                conn_set_state(c, conn_waiting); //没有数据再继续等待
                break;
            case READ_DATA_RECEIVED: //成功接收数据则进入conn_parse_cmd分支,解析命令
                conn_set_state(c, conn_parse_cmd);
                break;
            case READ_ERROR:
                conn_set_state(c, conn_closing);
                break;
            case READ_MEMORY_ERROR: /* Failed to allocate more memory */
                /* State already set by try_read_network */
                break;
            }
            break;
        case conn_parse_cmd :
            /**
            try_read_network后,到达conn_parse_cmd状态,但try_read_network并不确保每次到达
            的数据都足够一个完整的cmd(ascii协议情况下往往是没有"\r\n",即回车换行),
            所以下面的try_read_command之所以叫try就是这个原因,
            当读到的数据还不够成为一个cmd的时候,返回0,conn继续进入conn_waiting状态等待更多的数据到达。
            */
            if (try_read_command(c) == 0) {
                /* wee need more data! */
                conn_set_state(c, conn_waiting);
            }
            break;
        case conn_new_cmd:
            /* Only process nreqs at a time to avoid starving other
               connections */
            /*
             这里的reqs是请求的意思,其实叫“命令”更准确。一次event发生,有可能包含多个命令,
             从client fd里面read到的一次数据,不能保证这个数据只是包含一个命令,有可能是多个
             命令数据堆在一起的一次事件通知。这个nreqs是用来控制一次event最多能处理多少个命令。
            */
            --nreqs;
            if (nreqs >= 0) {
                /**
                准备执行命令。为什么叫reset cmd,reset_cmd_handler其实做了一些解析执行命令之前
                的初始化动下一个,都会重新进入这个case作。而像上面说的,一次event有可能有多个命令,每执行一个命令,如果还有
                 conn_new_cmd,reset一下再执行下一个命令。
                */
                reset_cmd_handler(c);
            } else {
                //省略
                stop = true;
            }
            break;
        case conn_nread:
            /**
            由process_update_command执行后进入此状态,process_update_command函数只执行了add/set/replace 等命令的一半,
            剩下的一半由这里完成。
            在这插一下memcached的命令解析协议,add/set/replace等这种写类型的命令,分为两块,或者说要有两次的“回车”,
            如:
            1)set key 0 0 4\r\n
            2)haha\r\n
            第1)行是命令,第2)行是数据块。
            例如如果是上面的set命令,process_update_command只完成了第1)行,分配了item空间,但还没有把value塞到对应的
            item中去。因此,在这一半要完成的动作就是把第2)行代表value的数据读出来,塞到刚拿到的item空间中去
            */
            /*
            下面的rlbytes字段表示要读的value数据还剩下多少字节
            如果是第一次由process_update_command进入到此,rlbytes此时在process_update_command中被初始化为item->nbytes,
            即value的总字节数,由第1)行命令中声明,即上面例子第1)行的"4"
            */
            if (c->rlbytes == 0) {
                /**
                如果要读value数据的都读完了,就调用complete_nread完成收尾工作,程序会跟着complete_nread进入下一个
                状态。所以执行完complete_nread会break;
                */
                complete_nread(c);
                break;
            }
            //如果还有数据没读完,继续往下执行。可知,下面的动作就是继续从buffer中读value数据往item中的data的value位置塞。
            /* Check if rbytes < 0, to prevent crash */
            if (c->rlbytes < 0) {
                if (settings.verbose) {
                    fprintf(stderr, "Invalid rlbytes to read: len %d\n", c->rlbytes);
                }
                conn_set_state(c, conn_closing);
                break;
            }
            /* first check if we have leftovers in the conn_read buffer */
            if (c->rbytes > 0) {
                /**
                取rbytes与rlbytes中最小的值。
                为啥?
                因为这里我们的目的是剩下的还没读的value的字节,而rlbytes代表的是还剩下的字节数
                如果rlbytes比rbytes小,只读rlbytes长度就够了,rbytes中多出来的部分不是我们这个时候想要的
                如果rbytes比rlbytes小,即使你要rlbytes这么多,但buffer中没有这么多给你读。
                */
                int tocopy = c->rbytes > c->rlbytes ? c->rlbytes : c->rbytes;
                if (c->ritem != c->rcurr) {
                    memmove(c->ritem, c->rcurr, tocopy); //往分配的item中塞,即为key设置value的过程
                }
                c->ritem += tocopy;
                c->rlbytes -= tocopy;
                c->rcurr += tocopy;
                c->rbytes -= tocopy;
                if (c->rlbytes == 0) {
                    break;
                }
            }
            //这里往往是我们先前读到buffer的数据还没足够的情况下,从socket中读。
            /* now try reading from the socket */
            res = read(c->sfd, c->ritem, c->rlbytes);//往分配的item中塞,即为key设置value的过程
            if (res > 0) {
                pthread_mutex_lock(&c->thread->stats.mutex);
                c->thread->stats.bytes_read += res;
                pthread_mutex_unlock(&c->thread->stats.mutex);
                if (c->rcurr == c->ritem) {
                    c->rcurr += res;
                }
                c->ritem += res;
                c->rlbytes -= res;
                break;
            }
            if (res == 0) { /* end of stream */
                conn_set_state(c, conn_closing);
                break;
            }
            if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
                if (!update_event(c, EV_READ | EV_PERSIST)) {
                    if (settings.verbose > 0)
                        fprintf(stderr, "Couldn't update event\n");
                    conn_set_state(c, conn_closing);
                    break;
                }
                stop = true;
                break;
            }
            /* otherwise we have a real error, on which we close the connection */
            if (settings.verbose > 0) {
            }
            conn_set_state(c, conn_closing);
            break;
        case conn_swallow:
            //省略
            conn_set_state(c, conn_closing);
            break;
        case conn_write:
            if (c->iovused == 0 || (IS_UDP(c->transport) && c->iovused == 1)) {
                if (add_iov(c, c->wcurr, c->wbytes) != 0) {
                }
            }
            /* fall through... */ //直接进入conn_mwrite分支
        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;
          }
            switch (transmit(c)) { //执行transmit发送数据到客户端
            case TRANSMIT_COMPLETE:
                if (c->state == conn_mwrite) {
                    conn_release_items(c);
                    if(c->protocol == binary_prot) {
                        conn_set_state(c, c->write_and_go);
                    } else {
                        conn_set_state(c, conn_new_cmd); //重新回到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;
            case TRANSMIT_INCOMPLETE:
            case TRANSMIT_HARD_ERROR:
                break; /* Continue in state machine. */
            case TRANSMIT_SOFT_ERROR:
                stop = true;
                break;
            }
            break;
        case conn_closing:
            if (IS_UDP(c->transport))
                conn_cleanup(c);
            else
                conn_close(c);
            stop = true;
            break;
        case conn_closed:
            /* This only happens if dormando is an idiot. */
            abort();
            break;
        case conn_max_state:
            assert(false);
            break;
        }
    }
    return;
}
//事件处理器主要调用drive_machine状态机执行事件处理
void event_handler(const int fd, const short which, void *arg) {
    conn *c;
    c = (conn *)arg;
    assert(c != NULL);
    c->which = which;
    if (fd != c->sfd) {
        if (settings.verbose > 0)
            fprintf(stderr, "Catastrophic: event fd doesn't match conn fd!\n");
        conn_close(c);
        return;
    }
    drive_machine(c); //调用drive_machine处理事件发生后的业务逻辑。
    return;
}
//创建socket
static int new_socket(struct addrinfo *ai) {
    int sfd;
    int flags;
    if ((sfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) == -1) {
        return -1;
    }
    if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 ||
        fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
        perror("setting O_NONBLOCK");
        close(sfd);
        return -1;
    }
    return sfd;
}
static int server_sockets(int port, enum network_transport transport,
                          FILE *portnumber_file) {
    if (settings.inter == NULL) { //如果没有指定ip
        return server_socket(settings.inter, port, transport, portnumber_file);
    } else {
        //省略指定的情况
        return ret;
    }
}
//main函数
int main (int argc, char **argv) {
    //省略一些变量定义,下面使用到时会说明
    settings_init(); //初始化配置
    setbuf(stderr, NULL);
    //memcached启动时指定的启动参数配置,在此省略
    while (-1 != (c = getopt(argc, argv, xxx
    }
    if (hash_init(hash_type) != 0) { //哈希算法初始化
        fprintf(stderr, "Failed to initialize hash_algorithm!\n");
        exit(EX_USAGE);
    }
   //身份验证的代码
    if (getuid() == 0 || geteuid() == 0) {
    }
   //以常驻进程方式运行
    if (do_daemonize) {
        if (daemonize(maxcore, settings.verbose) == -1) {
        }
    }

    main_base = event_init(); //全局的main_base变量
    stats_init(); //初始化全局统计
    assoc_init(settings.hashpower_init); //初始化哈希表
    conn_init(); //初始化连接对象,配置
    slabs_init(settings.maxbytes, settings.factor, preallocate); //初始化slabs,这里会对一些内存管理进行初始化
    //初始化主线程,参数是worker线程个数,和当前主线程的event_base
    thread_init(settings.num_threads, main_base);
    if (start_assoc_maintenance_thread() == -1) {//启动哈希表维护线程,详见assoc::start_assoc_maintenance_thread
        exit(EXIT_FAILURE);
    }
    /**
    如果开启了slab可重分配,则启动slab维护线程
    注意slab维护线程(下面简称s)与哈希表维护线程(下面简称哈)逻辑上不一样的地方:
    s是只要用户开启了slab_reassign,那么启动memcached服务的时候这个线程就同时启动的
    而哈虽然一开始就启动了,但是处理睡眠态,在需要的时候,memcached才发送信息唤醒。
    详见assoc::start_assoc_maintenance_thread和slabs::start_slab_maintenance_thread
    */
    if (settings.slab_reassign &&
        start_slab_maintenance_thread() == -1) {
        exit(EXIT_FAILURE);
    }
    init_lru_crawler(); //初始化item爬虫
     //这里省略unix socket监听方式和UDP的代码
    /* 
        睡眠一下,只是提供一定的时候让socket打开而已
     */
    usleep(1000);
    if (stats.curr_conns + stats.reserved_fds >= settings.maxconns - 1) {
        fprintf(stderr, "Maxconns setting is too low, use -c to increase.\n");
        exit(EXIT_FAILURE);
    }
    if (pid_file != NULL) {
        save_pid(pid_file); //创建pid文件
    }
    drop_privileges();
   //进入事件循环
    if (event_base_loop(main_base, 0) != 0) {
        retval = EXIT_FAILURE;
    }
    stop_assoc_maintenance_thread(); //进程退出之前停止哈希表维护线程
    //进程退出的收尾工作
    return retval;
}

转载请注明:Calix » Memcached源码分析之memcached.c

喜欢 (2)or分享 (0)
发表我的评论
取消评论
表情

亲~ 写下昵称哦~

  • 昵称 (必填)
  • 网址
(1)个小伙伴在吐槽
  1. if (res == avail) { //可能还没读完,此时读buffer可用空间满了,那么下次循环会进行读buffer空 这儿是不是写错了? 看着貌似不对劲啊!
    superhosts2016-01-06 15:05 回复