diff options
Diffstat (limited to 'src/pal')
-rwxr-xr-x | src/pal/linux/CRing.h | 98 | ||||
-rwxr-xr-x | src/pal/linux/mbuf.cpp | 425 | ||||
-rwxr-xr-x | src/pal/linux/mbuf.h | 192 | ||||
-rwxr-xr-x | src/pal/linux/pal_utl.cpp | 29 | ||||
-rwxr-xr-x | src/pal/linux/pal_utl.h | 70 | ||||
-rwxr-xr-x | src/pal/linux/sanb_atomic.h | 175 | ||||
-rwxr-xr-x | src/pal/linux_dpdk/CRing.h | 89 | ||||
-rwxr-xr-x | src/pal/linux_dpdk/dpdk180/rte_config.h | 234 | ||||
-rwxr-xr-x | src/pal/linux_dpdk/mbuf.cpp | 75 | ||||
-rwxr-xr-x | src/pal/linux_dpdk/mbuf.h | 83 | ||||
-rwxr-xr-x | src/pal/linux_dpdk/pal_utl.cpp | 29 | ||||
-rwxr-xr-x | src/pal/linux_dpdk/pal_utl.h | 45 | ||||
-rwxr-xr-x | src/pal/linux_dpdk/x86_64-default-linuxapp-gcc/include/rte_config.h | 72 |
13 files changed, 1616 insertions, 0 deletions
diff --git a/src/pal/linux/CRing.h b/src/pal/linux/CRing.h new file mode 100755 index 00000000..cf69422e --- /dev/null +++ b/src/pal/linux/CRing.h @@ -0,0 +1,98 @@ +#ifndef C_RING_H +#define C_RING_H +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + + +#include <assert.h> +#include <stdint.h> +#include <string> +#include <queue> + + + +typedef std::queue<void *> my_stl_queue_t; + +class CRingSp { +public: + CRingSp(){ + m_queue=0; + } + + bool Create(std::string name, + uint16_t cnt, + int socket_id){ + m_queue = new my_stl_queue_t(); + assert(m_queue); + return(true); + } + + void Delete(void){ + if (m_queue) { + delete m_queue ; + m_queue=0; + } + } + + int Enqueue(void *obj){ + m_queue->push(obj); + return (0); + } + + int Dequeue(void * & obj){ + if ( !m_queue->empty() ){ + obj= m_queue->front(); + m_queue->pop(); + return (0); + }else{ + return (1); + } + } + + bool isFull(void){ + return (false); + } + + bool isEmpty(void){ + return ( m_queue->empty() ?true:false); + } + +private: + my_stl_queue_t * m_queue; +}; + +template <class T> +class CTRingSp : public CRingSp { +public: + int Enqueue(T *obj){ + return ( CRingSp::Enqueue((void*)obj) ); + } + + int Dequeue(T * & obj){ + return (CRingSp::Dequeue(*((void **)&obj))); + } +}; + + + + +#endif + diff --git a/src/pal/linux/mbuf.cpp b/src/pal/linux/mbuf.cpp new file mode 100755 index 00000000..7eca8fd5 --- /dev/null +++ b/src/pal/linux/mbuf.cpp @@ -0,0 +1,425 @@ +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "mbuf.h" +#include <stdio.h> +#include <assert.h> +#include <stdlib.h> +#include <ctype.h> +#include "sanb_atomic.h" + + +#define RTE_MBUF_TO_BADDR(mb) (((struct rte_mbuf *)(mb)) + 1) +#define RTE_MBUF_FROM_BADDR(ba) (((struct rte_mbuf *)(ba)) - 1) + + +void rte_pktmbuf_detach(struct rte_mbuf *m); + + + +void utl_rte_check(rte_mempool_t * mp){ + assert(mp->magic == MAGIC0); + assert(mp->magic2 == MAGIC2); +} + +void utl_rte_pktmbuf_check(struct rte_mbuf *m){ + utl_rte_check(m->pool); + assert(m->magic == MAGIC0); + assert(m->magic2== MAGIC2); +} + +rte_mempool_t * utl_rte_mempool_create_non_pkt(const char *name, + unsigned n, + unsigned elt_size, + unsigned cache_size, + uint32_t _id , + int socket_id){ + rte_mempool_t * p=new rte_mempool_t(); + assert(p); + p->elt_size =elt_size; + p->size=n; + p->magic=MAGIC0; + p->magic2=MAGIC2; + return p; +} + +rte_mempool_t * utl_rte_mempool_create(const char *name, + unsigned n, + unsigned elt_size, + unsigned cache_size, + uint32_t _id, + int socket_id + ){ + + rte_mempool_t * p=new rte_mempool_t(); + assert(p); + p->size=n; + p->elt_size =elt_size; + p->magic=MAGIC0; + p->magic2=MAGIC2; + return p; +} + + +uint16_t rte_mbuf_refcnt_update(rte_mbuf_t *m, int16_t value) +{ + utl_rte_pktmbuf_check(m); + uint32_t a=sanb_atomic_add_return_32_old(&m->refcnt_reserved,1); + return (a); +} + + + + +void rte_pktmbuf_reset(struct rte_mbuf *m) +{ + utl_rte_pktmbuf_check(m); + m->next = NULL; + m->pkt_len = 0; + m->nb_segs = 1; + m->in_port = 0xff; + m->refcnt_reserved=1; + + #if RTE_PKTMBUF_HEADROOM > 0 + m->data_off = (RTE_PKTMBUF_HEADROOM <= m->buf_len) ? + RTE_PKTMBUF_HEADROOM : m->buf_len; + #else + m->data_off = RTE_PKTMBUF_HEADROOM ; + #endif + + m->data_len = 0; +} + + +rte_mbuf_t *rte_pktmbuf_alloc(rte_mempool_t *mp){ + + uint16_t buf_len; + + utl_rte_check(mp); + + buf_len = mp->elt_size ; + + rte_mbuf_t *m =(rte_mbuf_t *)malloc(buf_len ); + assert(m); + + m->magic = MAGIC0; + m->magic2 = MAGIC2; + m->pool = mp; + m->refcnt_reserved =0; + + m->buf_len = buf_len; + m->buf_addr =(char *)((char *)m+sizeof(rte_mbuf_t)+RTE_PKTMBUF_HEADROOM) ; + + rte_pktmbuf_reset(m); + return (m); +} + + + +void rte_pktmbuf_free_seg(rte_mbuf_t *m){ + + utl_rte_pktmbuf_check(m); + uint32_t old=sanb_atomic_dec2zero32(&m->refcnt_reserved); + if (old == 1) { + struct rte_mbuf *md = RTE_MBUF_FROM_BADDR(m->buf_addr); + + if ( md != m ) { + rte_pktmbuf_detach(m); + if (rte_mbuf_refcnt_update(md, -1) == 0) + free(md); + } + + free(m); + } +} + + + +void rte_pktmbuf_free(rte_mbuf_t *m){ + + rte_mbuf_t *m_next; + + utl_rte_pktmbuf_check(m); + + while (m != NULL) { + m_next = m->next; + rte_pktmbuf_free_seg(m); + m = m_next; + } +} + +static inline struct rte_mbuf *rte_pktmbuf_lastseg(struct rte_mbuf *m) +{ + struct rte_mbuf *m2 = (struct rte_mbuf *)m; + utl_rte_pktmbuf_check(m); + + + while (m2->next != NULL) + m2 = m2->next; + return m2; +} + +static inline uint16_t rte_pktmbuf_headroom(const struct rte_mbuf *m) +{ + return m->data_off; +} + +static inline uint16_t rte_pktmbuf_tailroom(const struct rte_mbuf *m) +{ + return (uint16_t)(m->buf_len - rte_pktmbuf_headroom(m) - + m->data_len); +} + + +char *rte_pktmbuf_append(struct rte_mbuf *m, uint16_t len) +{ + void *tail; + struct rte_mbuf *m_last; + utl_rte_pktmbuf_check(m); + + + m_last = rte_pktmbuf_lastseg(m); + if (len > rte_pktmbuf_tailroom(m_last)) + return NULL; + + tail = (char*) m_last->buf_addr + m_last->data_len; + m_last->data_len = (uint16_t)(m_last->data_len + len); + m->pkt_len = (m->pkt_len + len); + return (char*) tail; +} + + +char *rte_pktmbuf_adj(struct rte_mbuf *m, uint16_t len) +{ + utl_rte_pktmbuf_check(m); + + if (len > m->data_len) + return NULL; + + m->data_len = (uint16_t)(m->data_len - len); + m->data_off += len; + m->pkt_len = (m->pkt_len - len); + return (char *)m->buf_addr + m->data_off; +} + + +int rte_pktmbuf_trim(struct rte_mbuf *m, uint16_t len) +{ + struct rte_mbuf *m_last; + utl_rte_pktmbuf_check(m); + + m_last = rte_pktmbuf_lastseg(m); + if (len > m_last->data_len) + return -1; + + m_last->data_len = (uint16_t)(m_last->data_len - len); + m->pkt_len = (m->pkt_len - len); + return 0; +} + + +static void +rte_pktmbuf_hexdump(const void *buf, unsigned int len) +{ + unsigned int i, out, ofs; + const unsigned char *data = (unsigned char *)buf; +#define LINE_LEN 80 + char line[LINE_LEN]; + + printf(" dump data at 0x%p, len=%u\n", data, len); + ofs = 0; + while (ofs < len) { + out = snprintf(line, LINE_LEN, " %08X", ofs); + for (i = 0; ofs+i < len && i < 16; i++) + out += snprintf(line+out, LINE_LEN - out, " %02X", + data[ofs+i]&0xff); + for (; i <= 16; i++) + out += snprintf(line+out, LINE_LEN - out, " "); + for (i = 0; ofs < len && i < 16; i++, ofs++) { + unsigned char c = data[ofs]; + if (!isascii(c) || !isprint(c)) + c = '.'; + out += snprintf(line+out, LINE_LEN - out, "%c", c); + } + printf("%s\n", line); + } +} + + +int rte_mempool_sc_get(struct rte_mempool *mp, void **obj_p){ + utl_rte_check(mp); + uint16_t buf_len; + buf_len = mp->elt_size ; + *obj_p=(void *)::malloc(buf_len); + return (0); +} + +void rte_mempool_sp_put(struct rte_mempool *mp, void *obj){ + free(obj); +} + + +void rte_exit(int exit_code, const char *format, ...){ + exit(exit_code); +} + + + +void +rte_pktmbuf_dump(const struct rte_mbuf *m, unsigned dump_len) +{ + unsigned int len; + unsigned nb_segs; + + + printf("dump mbuf at 0x%p, phys=0x%p, buf_len=%u\n", + m, m->buf_addr, (unsigned)m->buf_len); + printf(" pkt_len=%u, nb_segs=%u, " + "in_port=%u\n", m->pkt_len, + (unsigned)m->nb_segs, (unsigned)m->in_port); + nb_segs = m->nb_segs; + + while (m && nb_segs != 0) { + + printf(" segment at 0x%p, data=0x%p, data_len=%u\n", + m, m->buf_addr, (unsigned)m->data_len); + len = dump_len; + if (len > m->data_len) + len = m->data_len; + if (len != 0) + rte_pktmbuf_hexdump(m->buf_addr, len); + dump_len -= len; + m = m->next; + nb_segs --; + } +} + + +rte_mbuf_t * utl_rte_pktmbuf_add_after2(rte_mbuf_t *m1,rte_mbuf_t *m2){ + utl_rte_pktmbuf_check(m1); + utl_rte_pktmbuf_check(m2); + + m1->next=m2; + m1->pkt_len += m2->data_len; + m1->nb_segs = m2->nb_segs + 1; + return (m1); +} + + + +void rte_pktmbuf_attach(struct rte_mbuf *mi, struct rte_mbuf *md) +{ + + rte_mbuf_refcnt_update(md, 1); + mi->buf_addr = md->buf_addr; + mi->buf_len = md->buf_len; + mi->data_off = md->data_off; + + mi->next = NULL; + mi->pkt_len = mi->data_len; + mi->nb_segs = 1; +} + +void rte_pktmbuf_detach(struct rte_mbuf *m) +{ + const struct rte_mempool *mp = m->pool; + void *buf = RTE_MBUF_TO_BADDR(m); + uint32_t buf_len = mp->elt_size - sizeof(*m); + + m->buf_addr = buf; + m->buf_len = (uint16_t)buf_len; + + #if RTE_PKTMBUF_HEADROOM > 0 + m->data_off = (RTE_PKTMBUF_HEADROOM <= m->buf_len) ? + RTE_PKTMBUF_HEADROOM : m->buf_len; + #else + m->data_off = RTE_PKTMBUF_HEADROOM ; + #endif + + + m->data_len = 0; +} + + + + + +rte_mbuf_t * utl_rte_pktmbuf_add_after(rte_mbuf_t *m1,rte_mbuf_t *m2){ + + utl_rte_pktmbuf_check(m1); + utl_rte_pktmbuf_check(m2); + + rte_mbuf_refcnt_update(m2,1); + m1->next=m2; + m1->pkt_len += m2->data_len; + m1->nb_segs = m2->nb_segs + 1; + return (m1); +} + + +uint64_t rte_rand(void){ + return ( rand() ); +} + + + + + +#ifdef ONLY_A_TEST + + +#define CONST_NB_MBUF 2048 +#define CONST_MBUF_SIZE (2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM) + + +void test_pkt_mbuf(){ + + rte_mempool_t * mp1=utl_rte_mempool_create("big-const", + CONST_NB_MBUF, + CONST_MBUF_SIZE, + 32); + rte_mbuf_t * m1 = rte_pktmbuf_alloc(mp1); + rte_mbuf_t * m2 = rte_pktmbuf_alloc(mp1); + + char *p=rte_pktmbuf_append(m1, 10); + int i; + + for (i=0; i<10;i++) { + p[i]=i; + } + + p=rte_pktmbuf_append(m2, 10); + + for (i=0; i<10;i++) { + p[i]=0x55+i; + } + + rte_pktmbuf_dump(m1, m1->pkt_len); + rte_pktmbuf_dump(m2, m1->pkt_len); + + rte_pktmbuf_free(m1); + rte_pktmbuf_free(m2); +} + + + + +#endif diff --git a/src/pal/linux/mbuf.h b/src/pal/linux/mbuf.h new file mode 100755 index 00000000..693b095a --- /dev/null +++ b/src/pal/linux/mbuf.h @@ -0,0 +1,192 @@ +#ifndef MBUF_H +#define MBUF_H +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + + +#include <stdint.h> +#include <string.h> + +#define MAGIC0 0xAABBCCDD +#define MAGIC2 0x11223344 + +struct rte_mempool { + uint32_t magic; + uint32_t elt_size; + uint32_t magic2; + uint32_t _id; + int size; +}; + + + + +struct rte_mbuf { + uint32_t magic; + struct rte_mempool *pool; /**< Pool from which mbuf was allocated. */ + void *buf_addr; /**< Virtual address of segment buffer. */ + uint16_t buf_len; /**< Length of segment buffer. */ + uint16_t data_off; + + struct rte_mbuf *next; /**< Next segment of scattered packet. */ + uint16_t data_len; /**< Amount of data in segment buffer. */ + + /* these fields are valid for first segment only */ + uint8_t nb_segs; /**< Number of segments. */ + uint8_t in_port; /**< Input port. */ + uint32_t pkt_len; /**< Total pkt len: sum of all segment data_len. */ + + uint32_t magic2; + uint32_t refcnt_reserved; /**< Do not use this field */ +} ; + + +typedef struct rte_mbuf rte_mbuf_t; + +typedef struct rte_mempool rte_mempool_t; + +#define RTE_PKTMBUF_HEADROOM 0 + +rte_mempool_t * utl_rte_mempool_create(const char *name, + unsigned n, + unsigned elt_size, + unsigned cache_size, + uint32_t _id , + int socket_id + ); + +rte_mempool_t * utl_rte_mempool_create_non_pkt(const char *name, + unsigned n, + unsigned elt_size, + unsigned cache_size, + uint32_t _id , + int socket_id); + +inline unsigned rte_mempool_count(rte_mempool_t *mp){ + return (10); +} + + + +void rte_pktmbuf_free(rte_mbuf_t *m); + +rte_mbuf_t *rte_pktmbuf_alloc(rte_mempool_t *mp); + +char *rte_pktmbuf_append(rte_mbuf_t *m, uint16_t len); + +char *rte_pktmbuf_adj(struct rte_mbuf *m, uint16_t len); + +int rte_pktmbuf_trim(rte_mbuf_t *m, uint16_t len); + +void rte_pktmbuf_attach(struct rte_mbuf *mi, struct rte_mbuf *md); + + + + +void rte_pktmbuf_free_seg(rte_mbuf_t *m); + +uint16_t rte_mbuf_refcnt_update(rte_mbuf_t *m, int16_t value); + +rte_mbuf_t * utl_rte_pktmbuf_add_after(rte_mbuf_t *m1,rte_mbuf_t *m2); +rte_mbuf_t * utl_rte_pktmbuf_add_after2(rte_mbuf_t *m1,rte_mbuf_t *m2); + +void rte_pktmbuf_dump(const struct rte_mbuf *m, unsigned dump_len); + + +int rte_mempool_sc_get(struct rte_mempool *mp, void **obj_p); + +void rte_mempool_sp_put(struct rte_mempool *mp, void *obj); + +inline int rte_mempool_get(struct rte_mempool *mp, void **obj_p){ + return (rte_mempool_sc_get(mp, obj_p)); +} + +inline void rte_mempool_put(struct rte_mempool *mp, void *obj){ + rte_mempool_sp_put(mp, obj); +} + + +static inline void * +rte_memcpy(void *dst, const void *src, size_t n) +{ + return (memcpy(dst, src, n)); +} + + + +void rte_exit(int exit_code, const char *format, ...); + +static inline unsigned +rte_lcore_to_socket_id(unsigned lcore_id){ + return (0); +} + +#define rte_pktmbuf_mtod(m, t) ((t)((char *)(m)->buf_addr + (m)->data_off)) + +/** + * A macro that returns the length of the packet. + * + * The value can be read or assigned. + * + * @param m + * The packet mbuf. + */ +#define rte_pktmbuf_pkt_len(m) ((m)->pkt_len) + +/** + * A macro that returns the length of the segment. + * + * The value can be read or assigned. + * + * @param m + * The packet mbuf. + */ +#define rte_pktmbuf_data_len(m) ((m)->data_len) + + +uint64_t rte_rand(void); + + +static inline void utl_rte_pktmbuf_add_last(rte_mbuf_t *m,rte_mbuf_t *m_last){ + + //there could be 2 cases supported + //1. one mbuf + //2. two mbug where last is indirect + + if ( m->next == NULL ) { + utl_rte_pktmbuf_add_after2(m,m_last); + }else{ + m->next->next=m_last; + m->pkt_len += m_last->data_len; + m->nb_segs = 3; + } +} + + + + +#define __rte_cache_aligned + +#define CACHE_LINE_SIZE 64 + +#define SOCKET_ID_ANY 0 + +#endif diff --git a/src/pal/linux/pal_utl.cpp b/src/pal/linux/pal_utl.cpp new file mode 100755 index 00000000..de864dbd --- /dev/null +++ b/src/pal/linux/pal_utl.cpp @@ -0,0 +1,29 @@ +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include <stdlib.h> +#include <stdio.h> +#include "pal_utl.h" + + + + + diff --git a/src/pal/linux/pal_utl.h b/src/pal/linux/pal_utl.h new file mode 100755 index 00000000..38152850 --- /dev/null +++ b/src/pal/linux/pal_utl.h @@ -0,0 +1,70 @@ +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +#ifndef PAL_UTL_H +#define PAL_UTL_H + +#include <stdint.h> + +#define PAL_MSB(x) (((x) >> 8) & 0xff) /* most signif byte of 2-byte integer */ +#define PAL_LSB(x) ((x) & 0xff) /* least signif byte of 2-byte integer*/ +#define PAL_MSW(x) (((x) >> 16) & 0xffff) /* most signif word of 2-word integer */ +#define PAL_LSW(x) ((x) & 0xffff) /* least signif byte of 2-word integer*/ + +/* swap the MSW with the LSW of a 32 bit integer */ +#define PAL_WORDSWAP(x) (PAL_MSW(x) | (PAL_LSW(x) << 16)) + +#define PAL_LLSB(x) ((x) & 0xff) /* 32bit word byte/word swap macros */ +#define PAL_LNLSB(x) (((x) >> 8) & 0xff) +#define PAL_LNMSB(x) (((x) >> 16) & 0xff) +#define PAL_LMSB(x) (((x) >> 24) & 0xff) +#define PAL_LONGSWAP(x) ((PAL_LLSB(x) << 24) | \ + (PAL_LNLSB(x) << 16)| \ + (PAL_LNMSB(x) << 8) | \ + (PAL_LMSB(x))) + +#define PAL_NTOHL(x) ((uint32_t)(PAL_LONGSWAP((uint32_t)x))) +#define PAL_NTOHS(x) ((uint16_t)(((PAL_MSB((uint16_t)x))) | (PAL_LSB((uint16_t)x) << 8))) + +#define PAL_HTONS(x) (PAL_NTOHS(x)) +#define PAL_HTONL(x) (PAL_NTOHL(x)) + +static inline uint64_t pal_ntohl64(uint64_t x){ + uint32_t high=(uint32_t)((x&0xffffffff00000000ULL)>>32); + uint32_t low=(uint32_t)((x&0xffffffff)); + uint64_t res=((uint64_t)(PAL_LONGSWAP(low)))<<32 | PAL_LONGSWAP(high); + return (res); +} + +#define PAL_NTOHLL(x) (pal_ntohl64(x)) + + +#define unlikely(a) (a) +#define likely(a) (a) + +static inline void rte_pause (void) +{ +} + + + +#endif + + diff --git a/src/pal/linux/sanb_atomic.h b/src/pal/linux/sanb_atomic.h new file mode 100755 index 00000000..8d24f8f4 --- /dev/null +++ b/src/pal/linux/sanb_atomic.h @@ -0,0 +1,175 @@ +#ifndef SANB_ATOMIC_ +#define SANB_ATOMIC_ +#include <stdlib.h> + +#define FORCE_NON_INILINE __attribute__((noinline)) + +static inline void sanb_smp_store_memory_barrier (void) +{ + asm volatile ("sfence":::"memory"); +} + +static inline void sanb_smp_load_memory_barrier (void) +{ + asm volatile ("lfence":::"memory"); +} + +static inline void sanb_smp_memory_barrier (void) +{ + asm volatile ("mfence":::"memory"); +} + + +static inline bool +sanb_atomic_compare_and_set_32 (uint32_t old_value, uint32_t new_value, + volatile uint32_t *addr) +{ + long result; +#if __WORDSIZE == 64 || defined(__x86_64__) + asm volatile (" lock cmpxchgl %2, 0(%3);" /* do the atomic operation */ + " sete %b0;" /* on success the ZF=1, copy that to */ + /* the low order byte of %eax (AKA %al)*/ + " movzbq %b0, %0;"/* zero extend %al to all of %eax */ + : "=a" (result) + : "0" (old_value), "q" (new_value), "r" (addr) + : "memory" ); +#else + asm volatile (" lock cmpxchgl %2, 0(%3);" /* do the atomic operation */ + " sete %b0;" /* on success the ZF=1, copy that to */ + /* the low order byte of %eax (AKA %al)*/ + " movzbl %b0, %0;"/* zero extend %al to all of %eax */ + : "=a" (result) + : "0" (old_value), "q" (new_value), "r" (addr) + : "memory" ); +#endif + return (bool)result; +} + + + +/* + * FIXME: on some processors the cmpxchg8b() instruction does not exist. On + * those processors this will cause a seg-fault. The only way to implement + * this operation on such a processor is to use a global lock. + */ +static inline bool +sanb_atomic_compare_and_set_64 (uint64_t old_value, uint64_t new_value, + volatile void *ptr) +{ + volatile uint64_t *addr = (volatile uint64_t *)ptr; +#if __WORDSIZE == 64 || defined(__x86_64__) + uint64_t prev; + asm volatile (" lock cmpxchgq %2, 0(%3);" /* do the atomic operation */ + : "=a" (prev) /* result will be stored in RAX */ + : "0" (old_value), "q" (new_value), "r" (addr) + : "memory"); + return (bool) (prev == old_value); +#else + uint64_t result; + asm volatile (" movl 0(%2), %%ebx;" /* load ECX:EBX with new_value */ + " movl 4(%2), %%ecx;" + " lock cmpxchg8b 0(%3);" /* do the atomic operation */ + " sete %b0;\n" /* on success the ZF=1, copy that to */ + /* the low order byte of %eax (AKA %al)*/ + " movzbl %b0, %0;"/* zero extend %al to all of %eax */ + : "=A" (result) /* result will be stored in EDX:EAX */ + : "0" (old_value), "r" (&new_value), "r" (addr) + : "memory", "ecx", "ebx" ); + return (bool) result; +#endif +} + + +static inline void +sanb_atomic_add_32 (volatile uint32_t *addr, uint32_t increment) +{ + asm volatile (" lock addl %0, 0(%1);" + : + : "q" (increment), "r" (addr) + : "memory" ); +} + + +static inline void +sanb_atomic_subtract_32 (volatile uint32_t *addr, uint32_t decrement) +{ + asm volatile (" lock subl %0, 0(%1);" + : + : "q" (decrement), "r" (addr) + : "memory" ); +} + + +/* + * It is not possible to do an atomic 64 bit add in 32-bit mode. Fortunately + * it is possible to do a 64-bit cmpxchg, so we can use that to implement a + * 64-bit atomic_add. + */ +static inline void +sanb_atomic_add_64 (volatile void *ptr, uint64_t increment) +{ + volatile uint64_t *addr = (volatile uint64_t *)ptr; + uint64_t original; + + do { + original = *addr; + } while (!sanb_atomic_compare_and_set_64(original, original + increment, addr)); +} + + + +static inline uint32_t sanb_atomic_dec2zero32(volatile void *ptr){ + volatile uint32_t *addr = (volatile uint32_t *)ptr; + uint32_t original; + do { + original = *addr; + } while (!sanb_atomic_compare_and_set_32(original, original ? (original - 1):0, addr)); + return (original); +} + + + +static inline uint32_t +sanb_atomic_add_return_32_old (volatile uint32_t *addr, uint32_t increment) +{ + uint32_t original; + + asm volatile (" lock xaddl %1, 0(%2);" + : "=r" (original) + : "0" (increment), "q" (addr) + : "memory" ); + return original ; +} + + +static inline uint64_t +sanb_atomic_add_return_64_old (volatile void *ptr, uint64_t increment) +{ + volatile uint64_t *addr = (volatile uint64_t *)ptr; + uint64_t original; + + do { + original = *addr; + } while (!sanb_atomic_compare_and_set_64(original, original + increment, addr)); + return original ; +} + + + +static inline void* +sanb_mem_read_ptr(void **v) { + + volatile void **p=(volatile void **)v; + return ((void *)(*p)); +} + +static inline void +sanb_mem_write_ptr(void **v,void *value) { + + volatile void **p=(volatile void **)v; + *p = value; +} + + + +#endif diff --git a/src/pal/linux_dpdk/CRing.h b/src/pal/linux_dpdk/CRing.h new file mode 100755 index 00000000..8325c1b6 --- /dev/null +++ b/src/pal/linux_dpdk/CRing.h @@ -0,0 +1,89 @@ +#ifndef C_RING_H +#define C_RING_H +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + + +#include <assert.h> +#include <stdint.h> +#include <string> +#include <rte_ring.h> + + + +class CRingSp { +public: + CRingSp(){ + m_ring=0; + } + + bool Create(std::string name, + uint16_t cnt, + int socket_id){ + m_ring=rte_ring_create((char *)name.c_str(), + cnt, + socket_id, + RING_F_SP_ENQ | RING_F_SC_DEQ); + assert(m_ring); + return(true); + } + + void Delete(void){ + // can't free the memory of DPDK, it is from reserve memory + } + + int Enqueue(void *obj){ + return (rte_ring_sp_enqueue(m_ring,obj)); + } + + int Dequeue(void * & obj){ + return(rte_ring_mc_dequeue(m_ring,(void **)&obj)); + } + + bool isFull(void){ + return ( rte_ring_full(m_ring)?true:false ); + } + + bool isEmpty(void){ + return ( rte_ring_empty(m_ring)?true:false ); + } + +private: + struct rte_ring * m_ring; +}; + +template <class T> +class CTRingSp : public CRingSp { +public: + int Enqueue(T *obj){ + return ( CRingSp::Enqueue((void*)obj) ); + } + + int Dequeue(T * & obj){ + return (CRingSp::Dequeue(*((void **)&obj))); + } +}; + + + + +#endif + diff --git a/src/pal/linux_dpdk/dpdk180/rte_config.h b/src/pal/linux_dpdk/dpdk180/rte_config.h new file mode 100755 index 00000000..68dd7a7b --- /dev/null +++ b/src/pal/linux_dpdk/dpdk180/rte_config.h @@ -0,0 +1,234 @@ +#ifndef __RTE_CONFIG_H +#define __RTE_CONFIG_H +#undef RTE_EXEC_ENV +#define RTE_EXEC_ENV "linuxapp" +#undef RTE_EXEC_ENV_LINUXAPP +#define RTE_EXEC_ENV_LINUXAPP 1 +#undef RTE_FORCE_INTRINSICS +#undef RTE_BUILD_SHARED_LIB +#undef RTE_BUILD_COMBINE_LIBS +#undef RTE_LIBNAME +#define RTE_LIBNAME "intel_dpdk" +#undef RTE_LIBRTE_EAL +#define RTE_LIBRTE_EAL 1 +#undef RTE_MAX_LCORE +#define RTE_MAX_LCORE 32 +#undef RTE_MAX_NUMA_NODES +#define RTE_MAX_NUMA_NODES 8 +#undef RTE_MAX_MEMSEG +#define RTE_MAX_MEMSEG 256 +#undef RTE_MAX_MEMZONE +#define RTE_MAX_MEMZONE 2560 +#undef RTE_MAX_TAILQ +#define RTE_MAX_TAILQ 32 +#undef RTE_LOG_LEVEL +#define RTE_LOG_LEVEL 8 +#undef RTE_LOG_HISTORY +#define RTE_LOG_HISTORY 256 +#undef RTE_LIBEAL_USE_HPET +#undef RTE_EAL_ALLOW_INV_SOCKET_ID +#undef RTE_EAL_ALWAYS_PANIC_ON_ERROR +#undef RTE_EAL_IGB_UIO +#define RTE_EAL_IGB_UIO 1 +#undef RTE_EAL_VFIO +#define RTE_EAL_VFIO 1 +#undef RTE_PCI_CONFIG +#undef RTE_PCI_EXTENDED_TAG +#define RTE_PCI_EXTENDED_TAG "" +#undef RTE_PCI_MAX_READ_REQUEST_SIZE +#define RTE_PCI_MAX_READ_REQUEST_SIZE 0 +#undef RTE_LIBRTE_EAL_LINUXAPP +#define RTE_LIBRTE_EAL_LINUXAPP 1 +#undef RTE_LIBRTE_EAL_VMWARE_TSC_MAP_SUPPORT +#define RTE_LIBRTE_EAL_VMWARE_TSC_MAP_SUPPORT 1 +#undef RTE_LIBRTE_KVARGS +#define RTE_LIBRTE_KVARGS 1 +#undef RTE_LIBRTE_ETHER +#define RTE_LIBRTE_ETHER 1 +#undef RTE_LIBRTE_ETHDEV_DEBUG +#undef RTE_MAX_ETHPORTS +#define RTE_MAX_ETHPORTS 32 +#undef RTE_LIBRTE_IEEE1588 +#undef RTE_ETHDEV_QUEUE_STAT_CNTRS +#define RTE_ETHDEV_QUEUE_STAT_CNTRS 16 +#undef RTE_NIC_BYPASS +#undef RTE_LIBRTE_EM_PMD +#define RTE_LIBRTE_EM_PMD 1 +#undef RTE_LIBRTE_IGB_PMD +#define RTE_LIBRTE_IGB_PMD 1 +#undef RTE_LIBRTE_E1000_DEBUG_INIT +#undef RTE_LIBRTE_E1000_DEBUG_RX +#undef RTE_LIBRTE_E1000_DEBUG_TX +#undef RTE_LIBRTE_E1000_DEBUG_TX_FREE +#undef RTE_LIBRTE_E1000_DEBUG_DRIVER +#undef RTE_LIBRTE_E1000_PF_DISABLE_STRIP_CRC +#undef RTE_LIBRTE_IXGBE_PMD +#define RTE_LIBRTE_IXGBE_PMD 1 +#undef RTE_LIBRTE_IXGBE_DEBUG_INIT +#undef RTE_LIBRTE_IXGBE_DEBUG_RX +#undef RTE_LIBRTE_IXGBE_DEBUG_TX +#undef RTE_LIBRTE_IXGBE_DEBUG_TX_FREE +#undef RTE_LIBRTE_IXGBE_DEBUG_DRIVER +#undef RTE_LIBRTE_IXGBE_PF_DISABLE_STRIP_CRC +#undef RTE_LIBRTE_IXGBE_RX_ALLOW_BULK_ALLOC +#define RTE_LIBRTE_IXGBE_RX_ALLOW_BULK_ALLOC 1 +#undef RTE_IXGBE_INC_VECTOR +#define RTE_IXGBE_INC_VECTOR 1 +#undef RTE_IXGBE_RX_OLFLAGS_ENABLE +#define RTE_IXGBE_RX_OLFLAGS_ENABLE 1 +#undef RTE_LIBRTE_I40E_PMD +#define RTE_LIBRTE_I40E_PMD 1 +#undef RTE_LIBRTE_I40E_DEBUG_INIT +#undef RTE_LIBRTE_I40E_DEBUG_RX +#undef RTE_LIBRTE_I40E_DEBUG_TX +#undef RTE_LIBRTE_I40E_DEBUG_TX_FREE +#undef RTE_LIBRTE_I40E_DEBUG_DRIVER +#undef RTE_LIBRTE_I40E_RX_ALLOW_BULK_ALLOC +#define RTE_LIBRTE_I40E_RX_ALLOW_BULK_ALLOC 1 +#undef RTE_LIBRTE_I40E_16BYTE_RX_DESC +#undef RTE_LIBRTE_I40E_QUEUE_NUM_PER_VF +#define RTE_LIBRTE_I40E_QUEUE_NUM_PER_VF 4 +#undef RTE_LIBRTE_I40E_QUEUE_NUM_PER_VM +#define RTE_LIBRTE_I40E_QUEUE_NUM_PER_VM 4 +#undef RTE_LIBRTE_I40E_ITR_INTERVAL +#define RTE_LIBRTE_I40E_ITR_INTERVAL -1 +#undef RTE_LIBRTE_ENIC_PMD +#define RTE_LIBRTE_ENIC_PMD 1 +#undef RTE_LIBRTE_VIRTIO_PMD +#define RTE_LIBRTE_VIRTIO_PMD 1 +#undef RTE_LIBRTE_VIRTIO_DEBUG_INIT +#undef RTE_LIBRTE_VIRTIO_DEBUG_RX +#undef RTE_LIBRTE_VIRTIO_DEBUG_TX +#undef RTE_LIBRTE_VIRTIO_DEBUG_DRIVER +#undef RTE_LIBRTE_VIRTIO_DEBUG_DUMP +#undef RTE_LIBRTE_VMXNET3_PMD +#define RTE_LIBRTE_VMXNET3_PMD 1 +#undef RTE_LIBRTE_VMXNET3_DEBUG_INIT +#undef RTE_LIBRTE_VMXNET3_DEBUG_RX +#undef RTE_LIBRTE_VMXNET3_DEBUG_TX +#undef RTE_LIBRTE_VMXNET3_DEBUG_TX_FREE +#undef RTE_LIBRTE_VMXNET3_DEBUG_DRIVER +#undef RTE_LIBRTE_PMD_RING +#define RTE_LIBRTE_PMD_RING 1 +#undef RTE_PMD_RING_MAX_RX_RINGS +#define RTE_PMD_RING_MAX_RX_RINGS 16 +#undef RTE_PMD_RING_MAX_TX_RINGS +#define RTE_PMD_RING_MAX_TX_RINGS 16 +#undef RTE_LIBRTE_PMD_PCAP +#undef RTE_LIBRTE_PMD_BOND +#define RTE_LIBRTE_PMD_BOND 1 +#undef RTE_LIBRTE_PMD_AF_PACKET +#define RTE_LIBRTE_PMD_AF_PACKET 1 +#undef RTE_LIBRTE_PMD_XENVIRT +#undef RTE_PMD_PACKET_PREFETCH +#define RTE_PMD_PACKET_PREFETCH 1 +#undef RTE_LIBRTE_RING +#define RTE_LIBRTE_RING 1 +#undef RTE_LIBRTE_RING_DEBUG +#undef RTE_RING_SPLIT_PROD_CONS +#undef RTE_LIBRTE_MEMPOOL +#define RTE_LIBRTE_MEMPOOL 1 +#undef RTE_MEMPOOL_CACHE_MAX_SIZE +#define RTE_MEMPOOL_CACHE_MAX_SIZE 512 +#undef RTE_LIBRTE_MEMPOOL_DEBUG +#undef RTE_LIBRTE_MBUF +#define RTE_LIBRTE_MBUF 1 +#undef RTE_LIBRTE_MBUF_DEBUG +#undef RTE_MBUF_REFCNT +#define RTE_MBUF_REFCNT 1 +#undef RTE_MBUF_REFCNT_ATOMIC +#define RTE_MBUF_REFCNT_ATOMIC 1 +#undef RTE_PKTMBUF_HEADROOM +#define RTE_PKTMBUF_HEADROOM 0 +#undef RTE_LIBRTE_TIMER +#define RTE_LIBRTE_TIMER 1 +#undef RTE_LIBRTE_TIMER_DEBUG +#undef RTE_LIBRTE_MALLOC +#define RTE_LIBRTE_MALLOC 1 +#undef RTE_LIBRTE_MALLOC_DEBUG +#undef RTE_MALLOC_MEMZONE_SIZE +#define RTE_MALLOC_MEMZONE_SIZE 11M +#undef RTE_LIBRTE_CFGFILE +#define RTE_LIBRTE_CFGFILE 1 +#undef RTE_LIBRTE_CMDLINE +#define RTE_LIBRTE_CMDLINE 1 +#undef RTE_LIBRTE_CMDLINE_DEBUG +#undef RTE_LIBRTE_HASH +#define RTE_LIBRTE_HASH 1 +#undef RTE_LIBRTE_HASH_DEBUG +#undef RTE_LIBRTE_LPM +#define RTE_LIBRTE_LPM 1 +#undef RTE_LIBRTE_LPM_DEBUG +#undef RTE_LIBRTE_ACL +#define RTE_LIBRTE_ACL 1 +#undef RTE_LIBRTE_ACL_DEBUG +#undef RTE_LIBRTE_ACL_STANDALONE +#undef RTE_LIBRTE_POWER +#define RTE_LIBRTE_POWER 1 +#undef RTE_LIBRTE_POWER_DEBUG +#undef RTE_MAX_LCORE_FREQS +#define RTE_MAX_LCORE_FREQS 64 +#undef RTE_LIBRTE_NET +#define RTE_LIBRTE_NET 1 +#undef RTE_LIBRTE_IP_FRAG +#define RTE_LIBRTE_IP_FRAG 1 +#undef RTE_LIBRTE_IP_FRAG_DEBUG +#undef RTE_LIBRTE_IP_FRAG_MAX_FRAG +#define RTE_LIBRTE_IP_FRAG_MAX_FRAG 4 +#undef RTE_LIBRTE_IP_FRAG_TBL_STAT +#undef RTE_LIBRTE_METER +#define RTE_LIBRTE_METER 1 +#undef RTE_LIBRTE_SCHED +#define RTE_LIBRTE_SCHED 1 +#undef RTE_SCHED_RED +#undef RTE_SCHED_COLLECT_STATS +#undef RTE_SCHED_SUBPORT_TC_OV +#undef RTE_SCHED_PORT_N_GRINDERS +#define RTE_SCHED_PORT_N_GRINDERS 8 +#undef RTE_LIBRTE_DISTRIBUTOR +#define RTE_LIBRTE_DISTRIBUTOR 1 +#undef RTE_LIBRTE_PORT +#define RTE_LIBRTE_PORT 1 +#undef RTE_LIBRTE_TABLE +#define RTE_LIBRTE_TABLE 1 +#undef RTE_LIBRTE_PIPELINE +#define RTE_LIBRTE_PIPELINE 1 +#undef RTE_LIBRTE_KNI +#define RTE_LIBRTE_KNI 1 +#undef RTE_KNI_KO_DEBUG +#undef RTE_KNI_VHOST +#undef RTE_KNI_VHOST_MAX_CACHE_SIZE +#define RTE_KNI_VHOST_MAX_CACHE_SIZE 1024 +#undef RTE_KNI_VHOST_VNET_HDR_EN +#undef RTE_KNI_VHOST_DEBUG_RX +#undef RTE_KNI_VHOST_DEBUG_TX +#undef RTE_LIBRTE_VHOST +#undef RTE_LIBRTE_VHOST_DEBUG +#undef RTE_LIBRTE_XEN_DOM0 +#undef RTE_INSECURE_FUNCTION_WARNING +#undef RTE_APP_TEST +#define RTE_APP_TEST 1 +#undef RTE_TEST_PMD +#define RTE_TEST_PMD 1 +#undef RTE_TEST_PMD_RECORD_CORE_CYCLES +#undef RTE_TEST_PMD_RECORD_BURST_STATS +#undef RTE_MACHINE +#define RTE_MACHINE "native" +#undef RTE_ARCH +#define RTE_ARCH "x86_64" +#undef RTE_ARCH_X86_64 +#define RTE_ARCH_X86_64 1 +#undef RTE_ARCH_64 +#define RTE_ARCH_64 1 +#undef RTE_TOOLCHAIN +#define RTE_TOOLCHAIN "gcc" +#undef RTE_TOOLCHAIN_GCC +#define RTE_TOOLCHAIN_GCC 1 + +//#define RTE_LIBRTE_IXGBE_DEBUG_INIT +//#define RTE_LIBRTE_IXGBE_DEBUG_RX +//#define RTE_LIBRTE_IXGBE_DEBUG_TX +//#define RTE_LIBRTE_IXGBE_DEBUG_TX_FREE +//#define RTE_LIBRTE_IXGBE_DEBUG_DRIVER + +#endif /* __RTE_CONFIG_H */ diff --git a/src/pal/linux_dpdk/mbuf.cpp b/src/pal/linux_dpdk/mbuf.cpp new file mode 100755 index 00000000..dd78617f --- /dev/null +++ b/src/pal/linux_dpdk/mbuf.cpp @@ -0,0 +1,75 @@ +#include "mbuf.h" + +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + + +rte_mempool_t * utl_rte_mempool_create(const char *name, + unsigned n, + unsigned elt_size, + unsigned cache_size, + uint32_t _id, + uint32_t socket_id ){ + char buffer[100]; + sprintf(buffer,"%s-%d",name,socket_id); + + rte_mempool_t * res= + rte_mempool_create(buffer, n, + elt_size, cache_size, + sizeof(struct rte_pktmbuf_pool_private), + rte_pktmbuf_pool_init, NULL, + rte_pktmbuf_init, NULL, + socket_id, 0); + if (res == NULL){ + printf(" ERROR there is not enough huge-pages memory in your system \n"); + rte_exit(EXIT_FAILURE, "Cannot init mbuf pool %s\n",name); + } + return res; +} + +rte_mempool_t * utl_rte_mempool_create_non_pkt(const char *name, + unsigned n, + unsigned elt_size, + unsigned cache_size, + uint32_t _id , + int socket_id){ + char buffer[100]; + sprintf(buffer,"%s-%d",name,socket_id); + + rte_mempool_t * res= + rte_mempool_create(buffer, n, + elt_size, + cache_size, + 0, + NULL, NULL, + NULL, NULL, + socket_id, 0); + if (res == NULL) { + printf(" ERROR there is not enough huge-pages memory in your system \n"); + rte_exit(EXIT_FAILURE, "Cannot init nodes mbuf pool %s\n",name); + } + return res; +} + + + + + diff --git a/src/pal/linux_dpdk/mbuf.h b/src/pal/linux_dpdk/mbuf.h new file mode 100755 index 00000000..cde01077 --- /dev/null +++ b/src/pal/linux_dpdk/mbuf.h @@ -0,0 +1,83 @@ +#ifndef MBUF_H +#define MBUF_H +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + + +#include <stdint.h> +#include <rte_mbuf.h> +#include <rte_random.h> + +typedef struct rte_mbuf rte_mbuf_t; + +typedef struct rte_mempool rte_mempool_t; + +rte_mempool_t * utl_rte_mempool_create(const char *name, + unsigned n, + unsigned elt_size, + unsigned cache_size, + uint32_t _id, + uint32_t socket_id ); + +rte_mempool_t * utl_rte_mempool_create_non_pkt(const char *name, + unsigned n, + unsigned elt_size, + unsigned cache_size, + uint32_t _id , + int socket_id); + + +static inline rte_mbuf_t * utl_rte_pktmbuf_add_after(rte_mbuf_t *m1,rte_mbuf_t *m2){ + + rte_mbuf_refcnt_update(m2,1); + m1->next=m2; + + m1->pkt_len += m2->data_len; + m1->nb_segs = m2->nb_segs + 1; + return (m1); +} + +static inline rte_mbuf_t * utl_rte_pktmbuf_add_after2(rte_mbuf_t *m1,rte_mbuf_t *m2){ + + m1->next=m2; + m1->pkt_len += m2->data_len; + m1->nb_segs = m2->nb_segs + 1; + return (m1); +} + +static inline void utl_rte_pktmbuf_add_last(rte_mbuf_t *m,rte_mbuf_t *m_last){ + + //there could be 2 cases supported + //1. one mbuf + //2. two mbug where last is indirect + + if ( m->next == NULL ) { + utl_rte_pktmbuf_add_after2(m,m_last); + }else{ + m->next->next=m_last; + m->pkt_len += m_last->data_len; + m->nb_segs = 3; + } +} + + + +#endif diff --git a/src/pal/linux_dpdk/pal_utl.cpp b/src/pal/linux_dpdk/pal_utl.cpp new file mode 100755 index 00000000..de864dbd --- /dev/null +++ b/src/pal/linux_dpdk/pal_utl.cpp @@ -0,0 +1,29 @@ +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include <stdlib.h> +#include <stdio.h> +#include "pal_utl.h" + + + + + diff --git a/src/pal/linux_dpdk/pal_utl.h b/src/pal/linux_dpdk/pal_utl.h new file mode 100755 index 00000000..13403e6c --- /dev/null +++ b/src/pal/linux_dpdk/pal_utl.h @@ -0,0 +1,45 @@ +/* + Hanoh Haim + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +#ifndef PAL_UTL_H +#define PAL_UTL_H + +#include <stdint.h> +#include <rte_byteorder.h> +#include <rte_memcpy.h> + +#define PAL_WORDSWAP(x) rte_bswap16(x) + + +#define PAL_NTOHL(x) ( (uint32_t)( rte_bswap32(x) ) ) +#define PAL_NTOHS(x) ( (uint16_t)( rte_bswap16(x) ) ) + +#define PAL_HTONS(x) (PAL_NTOHS(x)) +#define PAL_HTONL(x) (PAL_NTOHL(x)) + +#define pal_ntohl64(x) rte_bswap64(x) + +#define PAL_NTOHLL(x) ( rte_bswap64(x) ) + + + +#endif + + diff --git a/src/pal/linux_dpdk/x86_64-default-linuxapp-gcc/include/rte_config.h b/src/pal/linux_dpdk/x86_64-default-linuxapp-gcc/include/rte_config.h new file mode 100755 index 00000000..fdb5b994 --- /dev/null +++ b/src/pal/linux_dpdk/x86_64-default-linuxapp-gcc/include/rte_config.h @@ -0,0 +1,72 @@ +#define RTE_EXEC_ENV "linuxapp" +#define RTE_EXEC_ENV_LINUXAPP 1 +#define RTE_MACHINE "native" +#define RTE_ARCH "x86_64" +#define RTE_ARCH_X86_64 1 +#define RTE_TOOLCHAIN "gcc" +#define RTE_TOOLCHAIN_GCC 1 +#undef RTE_LIBC +#undef RTE_LIBC_NEWLIB_SRC +#undef RTE_LIBC_NEWLIB_BIN +#undef RTE_LIBC_NETINCS +#undef RTE_LIBGLOSS +#define RTE_LIBRTE_EAL 1 +#define RTE_MAX_LCORE 32 +#define RTE_MAX_NUMA_NODES 8 +#define RTE_MAX_MEMSEG 32 +#define RTE_MAX_MEMZONE 512 +#define RTE_MAX_TAILQ 32 +#define RTE_LOG_LEVEL 8 +#define RTE_LOG_HISTORY 256 +#undef RTE_LIBEAL_USE_HPET +#undef RTE_EAL_ALLOW_INV_SOCKET_ID +#undef RTE_EAL_ALWAYS_PANIC_ON_ERROR +#define RTE_LIBRTE_EAL_LINUXAPP 1 +#undef RTE_LIBRTE_EAL_BAREMETAL +#define RTE_LIBRTE_ETHER 1 +#undef RTE_LIBRTE_ETHDEV_DEBUG +#define RTE_MAX_ETHPORTS 32 +#undef RTE_LIBRTE_IEEE1588 +#define RTE_LIBRTE_IGB_PMD 1 +#undef RTE_LIBRTE_IGB_DEBUG_INIT +#undef RTE_LIBRTE_IGB_DEBUG_RX +#undef RTE_LIBRTE_IGB_DEBUG_TX +#undef RTE_LIBRTE_IGB_DEBUG_TX_FREE +#undef RTE_LIBRTE_IGB_DEBUG_DRIVER +#define RTE_LIBRTE_IXGBE_PMD 1 +#undef RTE_LIBRTE_IXGBE_DEBUG_INIT +#undef RTE_LIBRTE_IXGBE_DEBUG_RX +#undef RTE_LIBRTE_IXGBE_DEBUG_TX +#undef RTE_LIBRTE_IXGBE_DEBUG_TX_FREE +#undef RTE_LIBRTE_IXGBE_DEBUG_DRIVER +#define RTE_PMD_PACKET_PREFETCH 1 +#define RTE_LIBRTE_RING 1 +#undef RTE_LIBRTE_RING_DEBUG +#define RTE_LIBRTE_MEMPOOL 1 +#define RTE_MEMPOOL_CACHE_MAX_SIZE 512 +#undef RTE_LIBRTE_MEMPOOL_DEBUG +#define RTE_LIBRTE_MBUF 1 +#undef RTE_LIBRTE_MBUF_DEBUG +#define RTE_MBUF_SCATTER_GATHER 1 +#define RTE_MBUF_REFCNT_ATOMIC 1 +#define RTE_PKTMBUF_HEADROOM 0 +#define RTE_LIBRTE_TIMER 1 +#undef RTE_LIBRTE_TIMER_DEBUG +#define RTE_LIBRTE_MALLOC 1 +#undef RTE_LIBRTE_MALLOC_DEBUG +#define RTE_MALLOC_MEMZONE_SIZE 11M +#define RTE_MALLOC_PER_NUMA_NODE 1 +#define RTE_LIBRTE_CMDLINE 1 +#define RTE_LIBRTE_HASH 1 +#undef RTE_LIBRTE_HASH_DEBUG +#undef RTE_LIBRTE_HASH_USE_MEMZONE +#define RTE_LIBRTE_LPM 1 +#undef RTE_LIBRTE_LPM_DEBUG +#define RTE_LIBRTE_NET 1 +#define RTE_APP_TEST 1 +#define RTE_APP_CHKINCS 1 +#define RTE_TEST_PMD 1 +#undef RTE_TEST_PMD_RECORD_CORE_CYCLES +#undef RTE_TEST_PMD_RECORD_BURST_STATS +#undef RTE_LIBRTE_GCOV +#undef RTE_INSECURE_FUNCTION_WARNING |