path: root/app/src/mrb.c



#include <rte_common.h>
#include <rte_mbuf.h>
#include <assert.h>
#include <marsio.h>
#include <mrapp.h>
#include <mrb_define.h>

void * marsio_buff_ctrlzone(marsio_buff_t *mr_buff, uint8_t id)
{
	assert(id < mrbuf_cz_num(mr_buff));
	return mrbuf_cz_data(mr_buff, id);
}

void * marsio_buff_ctrlzone_data(marsio_buff_t *mr_buff, uint8_t id, uint8_t *size)
{
	struct mrb_zone_idx* cz = mrbuf_cz(mr_buff, id);
	assert(id < mrbuf_cz_num(mr_buff));
	*size = cz->size;
	return mrbuf_cz_data(mr_buff, id);
}

void marsio_buff_ctrlzone_set(marsio_buff_t *mr_buff, uint8_t id, void* ptr_data, uint8_t size)
{
	struct mrb_zone_idx* cz = mrbuf_cz(mr_buff, id);
	RTE_SET_USED(cz);

	assert(id < mrbuf_cz_num(mr_buff));
	assert(size <= cz->size);
	memcpy(mrbuf_cz_data(mr_buff, id), ptr_data, size);
	return;
}

void * mr_buffer_ctrlzone(struct rte_mbuf * mr_buff, uint8_t id)
{
    assert(id < mrbuf_cz_num(mr_buff));
    return mrbuf_cz_data(mr_buff, id);
}

int marsio_buff_malloc_device(struct mr_vdev * vdev, marsio_buff_t *marsio_buff[], 
    unsigned int nr_mbufs, int socket_id, int thread_id)
{
	int ret = rte_pktmbuf_alloc_bulk(vdev->vdi->direct_pool, 
        (struct rte_mbuf **)marsio_buff, nr_mbufs);

    assert(ret == 0);
    if (thread_id == LCORE_ID_ANY) thread_id = thread_info.thread_id;
    vdev->instance->stat[thread_id].mbuf_alloc_count += nr_mbufs;
    return ret;
}

int marsio_buff_malloc_global(struct mr_instance * instance, marsio_buff_t *marsio_buff[], 
    unsigned int nr_mbufs, int socket_id, int thread_id)
{
    struct mr_vdev * vdev = &instance->vdevs[thread_id % instance->nr_vdevs];
    return marsio_buff_malloc_device(vdev, marsio_buff, nr_mbufs, socket_id, thread_id);
}

void marsio_buff_free(struct mr_instance * instance, marsio_buff_t *marsio_buff[],
    unsigned int nr_mbufs, int socket_id, int thread_id)
{
	for (int i = 0; i < nr_mbufs; i++)
	{
		mrbuf_priv(marsio_buff[i])->next = NULL;
		rte_pktmbuf_free((struct rte_mbuf *)marsio_buff[i]);
	}

    if (thread_id == LCORE_ID_ANY) thread_id = thread_info.thread_id;
    instance->stat[thread_id].mbuf_free_count += nr_mbufs;
	return;
}

void marsio_buff_append_pkt(marsio_buff_t *head, marsio_buff_t *next)
{
	marsio_buff_t *p = head;
	while (mrbuf_priv(p)->next != NULL)
	{
		p = mrbuf_priv(p)->next;
	}
	mrbuf_priv(p)->next = next;
}

void marsio_buff_append_seg(marsio_buff_t *head, marsio_buff_t *next)
{
	rte_pktmbuf_chain((struct rte_mbuf *)head, (struct rte_mbuf *)next);
}

marsio_buff_t *marsio_buff_getnext_seg(marsio_buff_t *m)
{
	return (marsio_buff_t *)(((struct rte_mbuf*)m)->next);
}

marsio_buff_t *marsio_buff_getnext_pkt(marsio_buff_t *m)
{
	return mrbuf_priv(m)->next;
}

void marsio_buff_chain_pkt(marsio_buff_t * pkt, marsio_buff_t * next)
{
    mrbuf_priv(pkt)->next = next;
}

void marsio_buff_reset(marsio_buff_t *m)
{
	struct mrb_priv_zone_t* priv_zone = mrbuf_priv(m);
	struct mrb_zone_idx* cz_first = NULL, *cz_last = NULL;
    
    /* 引用计数检查，修改报文时，不应该被其他的地方引用 */
    struct rte_mbuf * __mbuf = (struct rte_mbuf *)m;
    
    /* 断言，调试模式直接抛出异常，非调试模式返回 */
    assert(rte_mbuf_refcnt_read(__mbuf) == 1);
    if (unlikely(rte_mbuf_refcnt_read(__mbuf) != 1)) return;

	rte_pktmbuf_reset((struct rte_mbuf *)m);
	priv_zone->next = NULL;
	if (mrbuf_cz_num(m) > 0)
	{
		cz_first = mrbuf_cz(m, 0);
		cz_last = mrbuf_cz(m, mrbuf_cz_num(m) - 1);
		memset(mrbuf_cz_data(m, 0), 0, cz_last->offset + cz_last->size - cz_first->offset);
	}
	return;
}

char *marsio_buff_mtod(marsio_buff_t *m)
{
	return rte_pktmbuf_mtod((struct rte_mbuf *)m, char *);
}

uint32_t marsio_buff_buflen(marsio_buff_t *m)
{
	return rte_pktmbuf_pkt_len((struct rte_mbuf *)m);
}

uint32_t marsio_buff_datalen(marsio_buff_t *m)
{
	return rte_pktmbuf_data_len((struct rte_mbuf *)m);
}

char *marsio_buff_prepend(marsio_buff_t *m, uint16_t len)
{
    /* 引用计数检查，修改报文时，不应该被其他的地方引用 */
    struct rte_mbuf * __mbuf = (struct rte_mbuf *)m;
    if (unlikely(rte_mbuf_refcnt_read(__mbuf) != 1)) return NULL;

	return rte_pktmbuf_prepend((struct rte_mbuf *)m, len);
}

char *marsio_buff_append(marsio_buff_t *m, uint16_t len)
{
    /* 引用计数检查，修改报文时，不应该被其他的地方引用 */
    struct rte_mbuf * __mbuf = (struct rte_mbuf *)m;
    if (unlikely(rte_mbuf_refcnt_read(__mbuf) != 1)) return NULL;

	return rte_pktmbuf_append((struct rte_mbuf *)m, len);
}

char *marsio_buff_adj(marsio_buff_t *m, uint16_t len)
{
    /* 引用计数检查，修改报文时，不应该被其他的地方引用 */
    struct rte_mbuf * __mbuf = (struct rte_mbuf *)m;
    if (unlikely(rte_mbuf_refcnt_read(__mbuf) != 1)) return NULL;

	return rte_pktmbuf_adj((struct rte_mbuf *)m, len);
}

int marsio_buff_trim(marsio_buff_t *m, uint16_t len)
{
    /* 引用计数检查，修改报文时，不应该被其他的地方引用 */
    struct rte_mbuf * __mbuf = (struct rte_mbuf *)m;
    if (unlikely(rte_mbuf_refcnt_read(__mbuf) != 1)) return -1;

	return rte_pktmbuf_trim((struct rte_mbuf *)m, len);
}

struct rte_mbuf * __pktmbuf_alloc(struct mr_instance * instance, int socket_id, int thread_id)
{
    struct rte_mbuf * __mbuf = NULL;
    marsio_buff_malloc_global(instance, (marsio_buff_t **)&__mbuf, 1, socket_id, thread_id);
    return __mbuf;
}

marsio_buff_t * marsio_buff_clone_deep(struct mr_instance * instance,
    marsio_buff_t * md, int socket_id, int thread_id)
{
    struct rte_mbuf *__mc, *__mi, **__prev;
    struct rte_mbuf * __md = (struct rte_mbuf *)md;

    uint32_t pktlen;
    uint8_t nseg;

    if (unlikely((__mc = __pktmbuf_alloc(instance, socket_id, thread_id)) == NULL))
        return NULL;

    __mi = __mc;
    __prev = &__mi->next;
    pktlen = __md->pkt_len;
    nseg = 0;

    do {
        nseg++;

        uint16_t __md_datalen = rte_pktmbuf_data_len(__md);
        void * __md_data = rte_pktmbuf_mtod(__md, void *);
        void * __mi_data = rte_pktmbuf_append(__mi, __md_datalen);
        rte_memcpy(__mi_data, __md_data, __md_datalen);
        
        *__prev = __mi;
        __prev = &__mi->next;

    } while ((md = __md->next) != NULL &&
        (__mi = __pktmbuf_alloc(instance, socket_id, thread_id)) != NULL);

    *__prev = NULL;
    __mc->nb_segs = nseg;
    __mc->pkt_len = pktlen;

    /* Allocation of new indirect segment failed */
    if (unlikely(__mi == NULL)) {
        rte_pktmbuf_free(__mc);
        return NULL;
    }

    __rte_mbuf_sanity_check(__mc, 1);
    return (marsio_buff_t *)__mc;
}

uint16_t marsio_buff_headroom(const marsio_buff_t *m)
{
	return rte_pktmbuf_headroom((const struct rte_mbuf *)m);
}

uint16_t marsio_buff_tailroom(const marsio_buff_t *m)
{
	return rte_pktmbuf_tailroom((const struct rte_mbuf *)m);
}

uint32_t marsio_get_pkt_type(marsio_buff_t *m)
{
	return ((struct rte_mbuf *)m)->packet_type;
}

void marsio_pktmbuf_dump(FILE *f, const marsio_buff_t *m, unsigned dump_len)
{
	rte_pktmbuf_dump(f, (const struct rte_mbuf *)m, dump_len);
}