lk中的cbuf

lk中默认提供cbuf给大家使用。
只要使用下面这三个函数就可create/read/write buf
void cbuf_initialize(cbuf_t *cbuf, size_t len);
size_t cbuf_read(cbuf_t *cbuf, void *_buf, size_t buflen, bool block);
size_t cbuf_write(cbuf_t *cbuf, const void *_buf, size_t len, bool canreschedule);
我们分别看一下
void cbuf_initialize(cbuf_t *cbuf, size_t len)
{
DEBUG_ASSERT(cbuf);
DEBUG_ASSERT(len > 0);
DEBUG_ASSERT(ispow2(len));


cbuf->head = 0;
cbuf->tail = 0;
cbuf->len_pow2 = log2(len);
cbuf->buf = malloc(len);
event_init(&cbuf->event, false, 0);


LTRACEF("len %zd, len_pow2 %u\n", len, cbuf->len_pow2);
}
lk中用cbuf_t 来表示cbuf，所以cbuf_initialize中主要初始化变量，需要主要的是len必须是2的指数，例如，4,8,16等。有初始化一个event来协调read/write


size_t cbuf_write(cbuf_t *cbuf, const void *_buf, size_t len, bool canreschedule)
{
const char *buf = (const char *)_buf;


LTRACEF("len %zd\n", len);


DEBUG_ASSERT(cbuf);
DEBUG_ASSERT(_buf);
DEBUG_ASSERT(len < valpow2(cbuf->len_pow2));


enter_critical_section();


size_t write_len;
size_t pos = 0;


while (pos < len && cbuf_space_avail(cbuf) > 0) {
if (cbuf->head >= cbuf->tail) {
write_len = MIN(valpow2(cbuf->len_pow2) - cbuf->head, len - pos);
} else {
write_len = MIN(cbuf->tail - cbuf->head - 1, len - pos);
}


// if it's full, abort and return how much we've written
if (write_len == 0) {
break;
}


memcpy(cbuf->buf + cbuf->head, buf + pos, write_len);


cbuf->head = INC_POINTER(cbuf, cbuf->head, write_len);
pos += write_len;
}


if (cbuf->head != cbuf->tail)
event_signal(&cbuf->event, canreschedule);


exit_critical_section();


return pos;
}
只要是pos < len && cbuf_space_avail(cbuf) > 0 成立就继续写，如果没有空间或者写完后signal 给read来读。
size_t cbuf_read(cbuf_t *cbuf, void *_buf, size_t buflen, bool block)
{
size_t ret;
char *buf = (char *)_buf;


DEBUG_ASSERT(cbuf);
DEBUG_ASSERT(_buf);


enter_critical_section();


if (block)
event_wait(&cbuf->event);


// see if there's data available
if (cbuf->tail != cbuf->head) {
size_t pos = 0;


// loop until we've read everything we need
// at most this will make two passes to deal with wraparound
while (pos < buflen && cbuf->tail != cbuf->head) {
size_t read_len;
if (cbuf->head > cbuf->tail) {
// simple case where there is no wraparound
read_len = MIN(cbuf->head - cbuf->tail, buflen - pos);
} else {
// read to the end of buffer in this pass
read_len = MIN(valpow2(cbuf->len_pow2) - cbuf->tail, buflen - pos);
}


memcpy(buf + pos, cbuf->buf + cbuf->tail, read_len);


cbuf->tail = INC_POINTER(cbuf, cbuf->tail, read_len);
pos += read_len;
}


if (cbuf->tail == cbuf->head) {
// we've emptied the buffer, unsignal the event
event_unsignal(&cbuf->event);
}


ret = pos;
} else {
DEBUG_ASSERT(!block);
ret = 0;
}


exit_critical_section();


return ret;
}


只要pos < buflen && cbuf->tail != cbuf->head就继续读，如果上一次没有写完就siganl出来让其读的话，说明是没有空间写了，这个时候
if (cbuf->tail == cbuf->head) {
// we've emptied the buffer, unsignal the event
event_unsignal(&cbuf->event);
}
event_unsignal 只有就取消了siganl，write就可以重写写了