Open vSwitch系列之数据结构解析深入分析ofpbuf

/* Buffer for holding arbitrary data.  An ofpbuf is automatically reallocated
 * as necessary if it grows too large for the available memory.
 *
 * 'frame' and offset conventions:
 *
 * Network frames (aka "packets"): 'frame' MUST be set to the start of the
 *    packet, layer offsets MAY be set as appropriate for the packet.
 *    Additionally, we assume in many places that the 'frame' and 'data' are
 *    the same for packets.
 *
 * OpenFlow messages: 'frame' points to the start of the OpenFlow
 *    header, while 'l3_ofs' is the length of the OpenFlow header.
 *    When parsing, the 'data' will move past these, as data is being
 *    pulled from the OpenFlow message.
 *
 * Actions: When encoding OVS action lists, the 'frame' is used
 *    as a pointer to the beginning of the current action (see ofpact_put()).
 *
 * rconn: Reuses 'frame' as a private pointer while queuing.
 */

#ifdef DPDK_NETDEV
    struct rte_mbuf mbuf;       /* DPDK mbuf */
#else
    void *base_;                 /* First byte of allocated space. 指向内存申请的起始位置。释放内存时候此变量传给free */
    void *data_;                 /* First byte actually in use. 指向当前可用内存起始位置。最开始base_和data_ 是一样的 */
    uint32_t size_;              /* Number of bytes in use. 表示内存已经使用的字节数 当size_ = allocated时候表示内存用完。 */
#endif
    uint32_t allocated;         /* Number of bytes allocated. 表示从系统中申请的内存块大小*/
    void *frame;                /* Packet frame start, or NULL. 这个字段可参考上面注释*/
    uint16_t l2_5_ofs;          /* MPLS label stack offset from 'frame', or
                                 * UINT16_MAX 2.5层 偏移量 */
    uint16_t l3_ofs;            /* Network-level header offset from 'frame',
                                  or UINT16_MAX. 3层网络层 偏移量*/
   uint16_t l4_ofs; /* Transport-level header offset from 'frame',
                                  or UINT16_MAX. 4层传输层 偏移量*/
    enum ofpbuf_source source;  /* Source of memory allocated as 'base'. 表示该内存来自堆、栈，主要用于内存释放。取值为ofpbuf_source枚举*/
    struct list list_node;      /* Private list element for use by owner. 链表节点。 用于将多个ofpbuf关联在一起 */
};
//枚举类型
enum OVS_PACKED_ENUM ofpbuf_source {
    OFPBUF_MALLOC,              /* Obtained via malloc(). */
    OFPBUF_STACK,               /* Un-movable stack space or static buffer. */
    OFPBUF_STUB,                /* Starts on stack, may expand into heap. */
    OFPBUF_DPDK,                /* buffer data is from DPDK allocated memory.
                                   ref to build_ofpbuf() in netdev-dpdk. */
};

static void
test_sflow_main(int argc, char *argv[])
{
....
struct ofpbuf buf;
....
ofpbuf_init(&buf, MAX_RECV);
for (;;) {
    int retval;
    unixctl_server_run(server);
    ofpbuf_clear(&buf);
    do {
        retval = read(sock, ofpbuf_data(&buf), buf.allocated);
    } while (retval < 0 && errno == EINTR);
    if (retval > 0) {
       ofpbuf_put_uninit(&buf, retval);
       print_sflow(&buf);
       fflush(stdout);
    }
    if (exiting) {
        break;
    }
    poll_fd_wait(sock, POLLIN);
    unixctl_server_wait(server);
    poll_block();
  }//for exit
}

static void
ofpbuf_init__(struct ofpbuf *b, size_t allocated, enum ofpbuf_source source)
{
    b->allocated = allocated;//设置申请的内存大小 即内存块大小
    b->source = source;//内存的类型，当前实例是malloc类型
    b->frame = NULL;
    b->l2_5_ofs = b->l3_ofs = b->l4_ofs = UINT16_MAX;
    list_poison(&b->list_node);
}
static void
ofpbuf_use__(struct ofpbuf *b, void *base, size_t allocated,
             enum ofpbuf_source source)
{
    ofpbuf_set_base(b, base);//设置base
    ofpbuf_set_data(b, base);//设置data  此时base和data保存的都是内存起始位置，只不过是data会变化，base不变
    ofpbuf_set_size(b, 0);//设置已经使用的内存大小 起初为0

    ofpbuf_init__(b, allocated, source);
}
/* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of
* memory starting at 'base'.  'base' should be the first byte of a region
* obtained from malloc().  It will be freed (with free()) if 'b' is resized or
* freed. */
void
ofpbuf_use(struct ofpbuf *b, void *base, size_t allocated)
{
    ofpbuf_use__(b, base, allocated, OFPBUF_MALLOC);//内存类型为malloc类型
}
/* Initializes 'b' as an empty ofpbuf with an initial capacity of 'size'
* bytes. */
void
ofpbuf_init(struct ofpbuf *b, size_t size)
{
    ofpbuf_use(b, size ? xmalloc(size) : NULL, size);
}

/* Returns the byte following the last byte of data in use in 'b'.
* 返回第一个可存储数据地址 针对上图返回值是 （0x832200C + 5）
*/
static inline void *ofpbuf_tail(const struct ofpbuf *b)
{
    return (char *) ofpbuf_data(b) + ofpbuf_size(b); /* data_ 指向数据报文起始位置，即上面蓝色开始位置 */
}
/* Returns the byte following the last byte allocated for use (but not
* necessarily in use) by 'b'.
* <span style="font-family: Arial, Helvetica, sans-serif;">返回内存区最后一个字节地址  针对上图返回值为 （0x8322008 + 16）</span>
*/
static inline void *ofpbuf_end(const struct ofpbuf *b)
{
    return (char *) ofpbuf_base(b) + b->allocated; /* base_ 指向内存区起始位置 */
}
/* Returns the number of bytes of headroom in 'b', that is, the number of bytes
* of unused space in ofpbuf 'b' before the data that is in use.  (Most
* commonly, the data in a ofpbuf is at its beginning, and thus the ofpbuf's
* headroom is 0.)
* 头部剩余空间大小。 直接用data_ - base_ 就可以得到。
*/
static inline size_t ofpbuf_headroom(const struct ofpbuf *b)
{
    return (char*)ofpbuf_data(b) - (char*)ofpbuf_base(b);
}
/* Returns the number of bytes that may be appended to the tail end of ofpbuf
* 'b' before the ofpbuf must be reallocated.
* 尾部剩余空间大小。
*/
static inline size_t ofpbuf_tailroom(const struct ofpbuf *b)
{
    return (char*)ofpbuf_end(b) - (char*)ofpbuf_tail(b);
}

/* Appends 'size' bytes of data to the tail end of 'b', reallocating and
* copying its data if necessary.  Returns a pointer to the first byte of the
* new data, which is left uninitialized.
* 扩大size大小内存空间，但是不初始化
*/
void *
ofpbuf_put_uninit(struct ofpbuf *b, size_t size)
{
    void *p;
    ofpbuf_prealloc_tailroom(b, size); /* 在尾部，扩大内存 */
    p = ofpbuf_tail(b); /* 扩展内存后，保存第一个可用内存地址 */
    ofpbuf_set_size(b, ofpbuf_size(b) + size); /* 设置已用内存空间大小 */
    return p;
}
/* Appends 'size' zeroed bytes to the tail end of 'b'.  Data in 'b' is
* reallocated and copied if necessary.  Returns a pointer to the first byte of
* the data's location in the ofpbuf.
* 扩大size大小内存空间，初始化为0
*/
void *
ofpbuf_put_zeros(struct ofpbuf *b, size_t size)
{
    void *dst = ofpbuf_put_uninit(b, size);
    memset(dst, 0, size);
    return dst;
}
/* Appends the 'size' bytes of data in 'p' to the tail end of 'b'.  Data in 'b'
* is reallocated and copied if necessary.  Returns a pointer to the first
* byte of the data's location in the ofpbuf.
* 扩大size大小内存空间，用p进行初始化
*/
void *
ofpbuf_put(struct ofpbuf *b, const void *p, size_t size)
{
    void *dst = ofpbuf_put_uninit(b, size);
    memcpy(dst, p, size);
    return dst;
}

/* Returns the number of bytes that may be appended to the tail end of ofpbuf
* 'b' before the ofpbuf must be reallocated.
* 返回可用内存空间，即上图中白色空间大小
*/
static inline size_t ofpbuf_tailroom(const struct ofpbuf *b)
{
    return (char*)ofpbuf_end(b) - (char*)ofpbuf_tail(b);
}
/* Reallocates 'b' so that it has exactly 'new_headroom' and 'new_tailroom'
* bytes of headroom and tailroom, respectively.
* 内存扩充函数  我们只关注malloc的内存 即红色部分
*/
static void
ofpbuf_resize__(struct ofpbuf *b, size_t new_headroom, size_t new_tailroom)
{
    void *new_base, *new_data;
    size_t new_allocated;
    new_allocated = new_headroom + ofpbuf_size(b) + new_tailroom;
    switch (b->source) {
    case OFPBUF_DPDK:
        OVS_NOT_REACHED();
        case OFPBUF_MALLOC:
        if (new_headroom == ofpbuf_headroom(b)) {//调用realloc申请内存
           new_base = xrealloc(ofpbuf_base(b), new_allocated);
        } else {
            new_base = xmalloc(new_allocated);//调用malloc申请内存并且修改ofpbuf中相关数据
            ofpbuf_copy__(b, new_base, new_headroom, new_tailroom); /* 将数据复制到新的内存空间中 需要注意头部剩余空间和使用空间。*/
            free(ofpbuf_base(b));
        }
        break;</span>
    case OFPBUF_STACK:
        OVS_NOT_REACHED();
    case OFPBUF_STUB:
        b->source = OFPBUF_MALLOC;
        new_base = xmalloc(new_allocated);
        ofpbuf_copy__(b, new_base, new_headroom, new_tailroom);
        break;
    default:
        OVS_NOT_REACHED();
    }
    // 重新设置allocated和base_ 指针
    b->allocated = new_allocated;
    ofpbuf_set_base(b, new_base);
    // 重新设置data_ 指针
    new_data = (char *) new_base + new_headroom;
    if (ofpbuf_data(b) != new_data) {
        if (b->frame) {
            uintptr_t data_delta = (char *) new_data - (char *) ofpbuf_data(b);
            b->frame = (char *) b->frame + data_delta;
        }
        ofpbuf_set_data(b, new_data);
    }
}
/* Ensures that 'b' has room for at least 'size' bytes at its tail end,
* reallocating and copying its data if necessary.  Its headroom, if any, is
* preserved.
* 尾部扩充内存 首先需要判断剩余内存是否满足需求，如果size大于剩余可用空间则需要重新申请内存
* 为了避免内存碎片和快速申请，每次至少申请64字节
*/
void
ofpbuf_prealloc_tailroom(struct ofpbuf *b, size_t size)
{
    if (size > ofpbuf_tailroom(b)) {
        ofpbuf_resize__(b, ofpbuf_headroom(b), MAX(size, 64));
    }
}

/* Removes 'size' bytes from the head end of 'b', which must contain at least
* 'size' bytes of data.  Returns the first byte of data removed. */
static inline void *ofpbuf_pull(struct ofpbuf *b, size_t size)
{
    void *data = ofpbuf_data(b);
    ovs_assert(ofpbuf_size(b) >= size);
    ofpbuf_set_data(b, (char*)ofpbuf_data(b) + size);
    ofpbuf_set_size(b, ofpbuf_size(b) - size);
    return data;
}

/* Frees memory that 'b' points to. */
void
ofpbuf_uninit(struct ofpbuf *b)
{
    if (b) {
        if (b->source == OFPBUF_MALLOC) {
            free(ofpbuf_base(b));
        }
        ovs_assert(b->source != OFPBUF_DPDK);
    }
}