From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga03.intel.com (mga03.intel.com [143.182.124.21]) by dpdk.org (Postfix) with ESMTP id 28EFDB0BE for ; Wed, 28 May 2014 19:32:54 +0200 (CEST) Received: from azsmga001.ch.intel.com ([10.2.17.19]) by azsmga101.ch.intel.com with ESMTP; 28 May 2014 10:32:51 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="4.98,929,1392192000"; d="scan'208";a="438160192" Received: from irvmail001.ir.intel.com ([163.33.26.43]) by azsmga001.ch.intel.com with ESMTP; 28 May 2014 10:32:49 -0700 Received: from sivswdev02.ir.intel.com (sivswdev02.ir.intel.com [10.237.217.46]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id s4SHWnaR004043; Wed, 28 May 2014 18:32:49 +0100 Received: from sivswdev02.ir.intel.com (localhost [127.0.0.1]) by sivswdev02.ir.intel.com with ESMTP id s4SHWnlX031697; Wed, 28 May 2014 18:32:49 +0100 Received: (from aburakov@localhost) by sivswdev02.ir.intel.com with id s4SHWnoc031693; Wed, 28 May 2014 18:32:49 +0100 From: Anatoly Burakov To: dev@dpdk.org Date: Wed, 28 May 2014 18:32:40 +0100 Message-Id: <3b2b8b8faa75b89f0ca0eea5ff5d14401fa3dd7a.1401298292.git.anatoly.burakov@intel.com> X-Mailer: git-send-email 1.7.0.7 In-Reply-To: References: In-Reply-To: References: Subject: [dpdk-dev] [PATCH 06/13] ip_frag: renaming structures in fragmentation table to be more generic X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 28 May 2014 17:32:57 -0000 Technically, fragmentation table can work for both IPv4 and IPv6 packets, so we're renaming everything to be generic enough to make sense in IPv6 context. Signed-off-by: Anatoly Burakov --- examples/ip_reassembly/main.c | 16 ++--- lib/librte_ip_frag/ip_frag_common.h | 2 + lib/librte_ip_frag/ipv4_frag_tbl.h | 130 ++++++++++++++++++------------------ lib/librte_ip_frag/rte_ipv4_rsmbl.h | 92 ++++++++++++------------- 4 files changed, 122 insertions(+), 118 deletions(-) diff --git a/examples/ip_reassembly/main.c b/examples/ip_reassembly/main.c index 42ade5c..23ec4be 100644 --- a/examples/ip_reassembly/main.c +++ b/examples/ip_reassembly/main.c @@ -407,9 +407,9 @@ struct lcore_conf { #else lookup_struct_t * ipv6_lookup_struct; #endif - struct ipv4_frag_tbl *frag_tbl[MAX_RX_QUEUE_PER_LCORE]; + struct ip_frag_tbl *frag_tbl[MAX_RX_QUEUE_PER_LCORE]; struct rte_mempool *pool[MAX_RX_QUEUE_PER_LCORE]; - struct ipv4_frag_death_row death_row; + struct ip_frag_death_row death_row; struct mbuf_table *tx_mbufs[MAX_PORTS]; struct tx_lcore_stat tx_stat; } __rte_cache_aligned; @@ -673,8 +673,8 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint8_t portid, uint32_t queue, if (ip_flag != 0 || ip_ofs != 0) { struct rte_mbuf *mo; - struct ipv4_frag_tbl *tbl; - struct ipv4_frag_death_row *dr; + struct ip_frag_tbl *tbl; + struct ip_frag_death_row *dr; tbl = qconf->frag_tbl[queue]; dr = &qconf->death_row; @@ -684,7 +684,7 @@ l3fwd_simple_forward(struct rte_mbuf *m, uint8_t portid, uint32_t queue, m->pkt.vlan_macip.f.l3_len = sizeof(*ipv4_hdr); /* process this fragment. */ - if ((mo = ipv4_frag_mbuf(tbl, dr, m, tms, ipv4_hdr, + if ((mo = rte_ipv4_reassemble_packet(tbl, dr, m, tms, ipv4_hdr, ip_ofs, ip_flag)) == NULL) /* no packet to send out. */ return; @@ -822,7 +822,7 @@ main_loop(__attribute__((unused)) void *dummy) i, qconf, cur_tsc); } - ipv4_frag_free_death_row(&qconf->death_row, + rte_ip_frag_free_death_row(&qconf->death_row, PREFETCH_OFFSET); } } @@ -1456,7 +1456,7 @@ setup_queue_tbl(struct lcore_conf *qconf, uint32_t lcore, int socket, frag_cycles = (rte_get_tsc_hz() + MS_PER_S - 1) / MS_PER_S * max_flow_ttl; - if ((qconf->frag_tbl[queue] = ipv4_frag_tbl_create(max_flow_num, + if ((qconf->frag_tbl[queue] = rte_ip_frag_table_create(max_flow_num, IPV4_FRAG_TBL_BUCKET_ENTRIES, max_flow_num, frag_cycles, socket)) == NULL) rte_exit(EXIT_FAILURE, "ipv4_frag_tbl_create(%u) on " @@ -1501,7 +1501,7 @@ queue_dump_stat(void) "rxqueueid=%hhu frag tbl stat:\n", lcore, qconf->rx_queue_list[i].port_id, qconf->rx_queue_list[i].queue_id); - ipv4_frag_tbl_dump_stat(stdout, qconf->frag_tbl[i]); + rte_ip_frag_table_statistics_dump(stdout, qconf->frag_tbl[i]); fprintf(stdout, "TX bursts:\t%" PRIu64 "\n" "TX packets _queued:\t%" PRIu64 "\n" "TX packets dropped:\t%" PRIu64 "\n" diff --git a/lib/librte_ip_frag/ip_frag_common.h b/lib/librte_ip_frag/ip_frag_common.h index c9741c0..6d4706a 100644 --- a/lib/librte_ip_frag/ip_frag_common.h +++ b/lib/librte_ip_frag/ip_frag_common.h @@ -34,6 +34,8 @@ #ifndef _IP_FRAG_COMMON_H_ #define _IP_FRAG_COMMON_H_ +#include "rte_ip_frag.h" + /* Debug on/off */ #ifdef RTE_IP_FRAG_DEBUG diff --git a/lib/librte_ip_frag/ipv4_frag_tbl.h b/lib/librte_ip_frag/ipv4_frag_tbl.h index 5487230..fa3291d 100644 --- a/lib/librte_ip_frag/ipv4_frag_tbl.h +++ b/lib/librte_ip_frag/ipv4_frag_tbl.h @@ -43,7 +43,7 @@ */ /* - * The ipv4_frag_tbl is a simple hash table: + * The ip_frag_tbl is a simple hash table: * The basic idea is to use two hash functions and * associativity. This provides 2 * possible locations in * the hash table for each key. Sort of simplified Cuckoo hashing, @@ -64,9 +64,9 @@ #define PRIME_VALUE 0xeaad8405 -TAILQ_HEAD(ipv4_pkt_list, ipv4_frag_pkt); +TAILQ_HEAD(ip_pkt_list, ip_frag_pkt); -struct ipv4_frag_tbl_stat { +struct ip_frag_tbl_stat { uint64_t find_num; /* total # of find/insert attempts. */ uint64_t add_num; /* # of add ops. */ uint64_t del_num; /* # of del ops. */ @@ -75,7 +75,7 @@ struct ipv4_frag_tbl_stat { uint64_t fail_nospace; /* # of 'no space' add failures. */ } __rte_cache_aligned; -struct ipv4_frag_tbl { +struct ip_frag_tbl { uint64_t max_cycles; /* ttl for table entries. */ uint32_t entry_mask; /* hash value mask. */ uint32_t max_entries; /* max entries allowed. */ @@ -83,25 +83,25 @@ struct ipv4_frag_tbl { uint32_t bucket_entries; /* hash assocaitivity. */ uint32_t nb_entries; /* total size of the table. */ uint32_t nb_buckets; /* num of associativity lines. */ - struct ipv4_frag_pkt *last; /* last used entry. */ - struct ipv4_pkt_list lru; /* LRU list for table entries. */ - struct ipv4_frag_tbl_stat stat; /* statistics counters. */ - struct ipv4_frag_pkt pkt[0]; /* hash table. */ + struct ip_frag_pkt *last; /* last used entry. */ + struct ip_pkt_list lru; /* LRU list for table entries. */ + struct ip_frag_tbl_stat stat; /* statistics counters. */ + struct ip_frag_pkt pkt[0]; /* hash table. */ }; -#define IPV4_FRAG_TBL_POS(tbl, sig) \ +#define IP_FRAG_TBL_POS(tbl, sig) \ ((tbl)->pkt + ((sig) & (tbl)->entry_mask)) -#define IPV4_FRAG_HASH_FNUM 2 +#define IP_FRAG_HASH_FNUM 2 -#ifdef IPV4_FRAG_TBL_STAT -#define IPV4_FRAG_TBL_STAT_UPDATE(s, f, v) ((s)->f += (v)) +#ifdef IP_FRAG_TBL_STAT +#define IP_FRAG_TBL_STAT_UPDATE(s, f, v) ((s)->f += (v)) #else -#define IPV4_FRAG_TBL_STAT_UPDATE(s, f, v) do {} while (0) +#define IP_FRAG_TBL_STAT_UPDATE(s, f, v) do {} while (0) #endif /* IPV4_FRAG_TBL_STAT */ static inline void -ipv4_frag_hash(const struct ipv4_frag_key *key, uint32_t *v1, uint32_t *v2) +ipv4_frag_hash(const struct ip_frag_key *key, uint32_t *v1, uint32_t *v2) { uint32_t v; const uint32_t *p; @@ -125,9 +125,9 @@ ipv4_frag_hash(const struct ipv4_frag_key *key, uint32_t *v1, uint32_t *v2) * Update the table, after we finish processing it's entry. */ static inline void -ipv4_frag_inuse(struct ipv4_frag_tbl *tbl, const struct ipv4_frag_pkt *fp) +ip_frag_inuse(struct ip_frag_tbl *tbl, const struct ip_frag_pkt *fp) { - if (IPV4_FRAG_KEY_EMPTY(&fp->key)) { + if (IP_FRAG_KEY_EMPTY(&fp->key)) { TAILQ_REMOVE(&tbl->lru, fp, lru); tbl->use_entries--; } @@ -138,13 +138,13 @@ ipv4_frag_inuse(struct ipv4_frag_tbl *tbl, const struct ipv4_frag_pkt *fp) * If such entry doesn't exist, will return free and/or timed-out entry, * that can be used for that key. */ -static inline struct ipv4_frag_pkt * -ipv4_frag_lookup(struct ipv4_frag_tbl *tbl, - const struct ipv4_frag_key *key, uint64_t tms, - struct ipv4_frag_pkt **free, struct ipv4_frag_pkt **stale) +static inline struct ip_frag_pkt * +ip_frag_lookup(struct ip_frag_tbl *tbl, + const struct ip_frag_key *key, uint64_t tms, + struct ip_frag_pkt **free, struct ip_frag_pkt **stale) { - struct ipv4_frag_pkt *p1, *p2; - struct ipv4_frag_pkt *empty, *old; + struct ip_frag_pkt *p1, *p2; + struct ip_frag_pkt *empty, *old; uint64_t max_cycles; uint32_t i, assoc, sig1, sig2; @@ -154,43 +154,43 @@ ipv4_frag_lookup(struct ipv4_frag_tbl *tbl, max_cycles = tbl->max_cycles; assoc = tbl->bucket_entries; - if (tbl->last != NULL && IPV4_FRAG_KEY_CMP(&tbl->last->key, key) == 0) + if (tbl->last != NULL && IP_FRAG_KEY_CMP(&tbl->last->key, key) == 0) return (tbl->last); ipv4_frag_hash(key, &sig1, &sig2); - p1 = IPV4_FRAG_TBL_POS(tbl, sig1); - p2 = IPV4_FRAG_TBL_POS(tbl, sig2); + p1 = IP_FRAG_TBL_POS(tbl, sig1); + p2 = IP_FRAG_TBL_POS(tbl, sig2); for (i = 0; i != assoc; i++) { - IPV4_FRAG_LOG(DEBUG, "%s:%d:\n" + IP_FRAG_LOG(DEBUG, "%s:%d:\n" "tbl: %p, max_entries: %u, use_entries: %u\n" - "ipv4_frag_pkt line0: %p, index: %u from %u\n" + "ip_frag_pkt line0: %p, index: %u from %u\n" "key: <%" PRIx64 ", %#x>, start: %" PRIu64 "\n", __func__, __LINE__, tbl, tbl->max_entries, tbl->use_entries, p1, i, assoc, p1[i].key.src_dst, p1[i].key.id, p1[i].start); - if (IPV4_FRAG_KEY_CMP(&p1[i].key, key) == 0) + if (IP_FRAG_KEY_CMP(&p1[i].key, key) == 0) return (p1 + i); - else if (IPV4_FRAG_KEY_EMPTY(&p1[i].key)) + else if (IP_FRAG_KEY_EMPTY(&p1[i].key)) empty = (empty == NULL) ? (p1 + i) : empty; else if (max_cycles + p1[i].start < tms) old = (old == NULL) ? (p1 + i) : old; - IPV4_FRAG_LOG(DEBUG, "%s:%d:\n" + IP_FRAG_LOG(DEBUG, "%s:%d:\n" "tbl: %p, max_entries: %u, use_entries: %u\n" - "ipv4_frag_pkt line1: %p, index: %u from %u\n" + "ip_frag_pkt line1: %p, index: %u from %u\n" "key: <%" PRIx64 ", %#x>, start: %" PRIu64 "\n", __func__, __LINE__, tbl, tbl->max_entries, tbl->use_entries, p2, i, assoc, p2[i].key.src_dst, p2[i].key.id, p2[i].start); - if (IPV4_FRAG_KEY_CMP(&p2[i].key, key) == 0) + if (IP_FRAG_KEY_CMP(&p2[i].key, key) == 0) return (p2 + i); - else if (IPV4_FRAG_KEY_EMPTY(&p2[i].key)) + else if (IP_FRAG_KEY_EMPTY(&p2[i].key)) empty = (empty == NULL) ?( p2 + i) : empty; else if (max_cycles + p2[i].start < tms) old = (old == NULL) ? (p2 + i) : old; @@ -202,36 +202,36 @@ ipv4_frag_lookup(struct ipv4_frag_tbl *tbl, } static inline void -ipv4_frag_tbl_del(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, - struct ipv4_frag_pkt *fp) +ip_frag_tbl_del(struct ip_frag_tbl *tbl, struct ip_frag_death_row *dr, + struct ip_frag_pkt *fp) { - ipv4_frag_free(fp, dr); - IPV4_FRAG_KEY_INVALIDATE(&fp->key); + ip_frag_free(fp, dr); + IP_FRAG_KEY_INVALIDATE(&fp->key); TAILQ_REMOVE(&tbl->lru, fp, lru); tbl->use_entries--; - IPV4_FRAG_TBL_STAT_UPDATE(&tbl->stat, del_num, 1); + IP_FRAG_TBL_STAT_UPDATE(&tbl->stat, del_num, 1); } static inline void -ipv4_frag_tbl_add(struct ipv4_frag_tbl *tbl, struct ipv4_frag_pkt *fp, - const struct ipv4_frag_key *key, uint64_t tms) +ip_frag_tbl_add(struct ip_frag_tbl *tbl, struct ip_frag_pkt *fp, + const struct ip_frag_key *key, uint64_t tms) { fp->key = key[0]; - ipv4_frag_reset(fp, tms); + ip_frag_reset(fp, tms); TAILQ_INSERT_TAIL(&tbl->lru, fp, lru); tbl->use_entries++; - IPV4_FRAG_TBL_STAT_UPDATE(&tbl->stat, add_num, 1); + IP_FRAG_TBL_STAT_UPDATE(&tbl->stat, add_num, 1); } static inline void -ipv4_frag_tbl_reuse(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, - struct ipv4_frag_pkt *fp, uint64_t tms) +ip_frag_tbl_reuse(struct ip_frag_tbl *tbl, struct ip_frag_death_row *dr, + struct ip_frag_pkt *fp, uint64_t tms) { - ipv4_frag_free(fp, dr); - ipv4_frag_reset(fp, tms); + ip_frag_free(fp, dr); + ip_frag_reset(fp, tms); TAILQ_REMOVE(&tbl->lru, fp, lru); TAILQ_INSERT_TAIL(&tbl->lru, fp, lru); - IPV4_FRAG_TBL_STAT_UPDATE(&tbl->stat, reuse_num, 1); + IP_FRAG_TBL_STAT_UPDATE(&tbl->stat, reuse_num, 1); } /* @@ -239,11 +239,11 @@ ipv4_frag_tbl_reuse(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, * If such entry is not present, then allocate a new one. * If the entry is stale, then free and reuse it. */ -static inline struct ipv4_frag_pkt * -ipv4_frag_find(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, - const struct ipv4_frag_key *key, uint64_t tms) +static inline struct ip_frag_pkt * +ip_frag_find(struct ip_frag_tbl *tbl, struct ip_frag_death_row *dr, + const struct ip_frag_key *key, uint64_t tms) { - struct ipv4_frag_pkt *pkt, *free, *stale, *lru; + struct ip_frag_pkt *pkt, *free, *stale, *lru; uint64_t max_cycles; /* @@ -254,13 +254,13 @@ ipv4_frag_find(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, stale = NULL; max_cycles = tbl->max_cycles; - IPV4_FRAG_TBL_STAT_UPDATE(&tbl->stat, find_num, 1); + IP_FRAG_TBL_STAT_UPDATE(&tbl->stat, find_num, 1); - if ((pkt = ipv4_frag_lookup(tbl, key, tms, &free, &stale)) == NULL) { + if ((pkt = ip_frag_lookup(tbl, key, tms, &free, &stale)) == NULL) { /*timed-out entry, free and invalidate it*/ if (stale != NULL) { - ipv4_frag_tbl_del(tbl, dr, stale); + ip_frag_tbl_del(tbl, dr, stale); free = stale; /* @@ -272,17 +272,17 @@ ipv4_frag_find(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, tbl->max_entries <= tbl->use_entries) { lru = TAILQ_FIRST(&tbl->lru); if (max_cycles + lru->start < tms) { - ipv4_frag_tbl_del(tbl, dr, lru); + ip_frag_tbl_del(tbl, dr, lru); } else { free = NULL; - IPV4_FRAG_TBL_STAT_UPDATE(&tbl->stat, + IP_FRAG_TBL_STAT_UPDATE(&tbl->stat, fail_nospace, 1); } } /* found a free entry to reuse. */ if (free != NULL) { - ipv4_frag_tbl_add(tbl, free, key, tms); + ip_frag_tbl_add(tbl, free, key, tms); pkt = free; } @@ -292,10 +292,10 @@ ipv4_frag_find(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, * and reuse it. */ } else if (max_cycles + pkt->start < tms) { - ipv4_frag_tbl_reuse(tbl, dr, pkt, tms); + ip_frag_tbl_reuse(tbl, dr, pkt, tms); } - IPV4_FRAG_TBL_STAT_UPDATE(&tbl->stat, fail_total, (pkt == NULL)); + IP_FRAG_TBL_STAT_UPDATE(&tbl->stat, fail_total, (pkt == NULL)); tbl->last = pkt; return (pkt); @@ -319,17 +319,17 @@ ipv4_frag_find(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, * @return * The pointer to the new allocated mempool, on success. NULL on error. */ -static struct ipv4_frag_tbl * -ipv4_frag_tbl_create(uint32_t bucket_num, uint32_t bucket_entries, +static struct ip_frag_tbl * +rte_ip_frag_table_create(uint32_t bucket_num, uint32_t bucket_entries, uint32_t max_entries, uint64_t max_cycles, int socket_id) { - struct ipv4_frag_tbl *tbl; + struct ip_frag_tbl *tbl; size_t sz; uint64_t nb_entries; nb_entries = rte_align32pow2(bucket_num); nb_entries *= bucket_entries; - nb_entries *= IPV4_FRAG_HASH_FNUM; + nb_entries *= IP_FRAG_HASH_FNUM; /* check input parameters. */ if (rte_is_power_of_2(bucket_entries) == 0 || @@ -363,13 +363,13 @@ ipv4_frag_tbl_create(uint32_t bucket_num, uint32_t bucket_entries, } static inline void -ipv4_frag_tbl_destroy( struct ipv4_frag_tbl *tbl) +rte_ip_frag_table_destroy( struct ip_frag_tbl *tbl) { rte_free(tbl); } static void -ipv4_frag_tbl_dump_stat(FILE *f, const struct ipv4_frag_tbl *tbl) +rte_ip_frag_table_statistics_dump(FILE *f, const struct ip_frag_tbl *tbl) { uint64_t fail_total, fail_nospace; diff --git a/lib/librte_ip_frag/rte_ipv4_rsmbl.h b/lib/librte_ip_frag/rte_ipv4_rsmbl.h index 58ec1ee..82cb9b5 100644 --- a/lib/librte_ip_frag/rte_ipv4_rsmbl.h +++ b/lib/librte_ip_frag/rte_ipv4_rsmbl.h @@ -34,6 +34,8 @@ #ifndef _IPV4_RSMBL_H_ #define _IPV4_RSMBL_H_ +#include "ip_frag_common.h" + /** * @file * IPv4 reassemble @@ -49,7 +51,7 @@ enum { MAX_FRAG_NUM = 4, }; -struct ipv4_frag { +struct ip_frag { uint16_t ofs; uint16_t len; struct rte_mbuf *mb; @@ -58,15 +60,15 @@ struct ipv4_frag { /* * Use to uniquely indetify fragmented datagram. */ -struct ipv4_frag_key { +struct ip_frag_key { uint64_t src_dst; uint32_t id; }; -#define IPV4_FRAG_KEY_INVALIDATE(k) ((k)->src_dst = 0) -#define IPV4_FRAG_KEY_EMPTY(k) ((k)->src_dst == 0) +#define IP_FRAG_KEY_INVALIDATE(k) ((k)->src_dst = 0) +#define IP_FRAG_KEY_EMPTY(k) ((k)->src_dst == 0) -#define IPV4_FRAG_KEY_CMP(k1, k2) \ +#define IP_FRAG_KEY_CMP(k1, k2) \ (((k1)->src_dst ^ (k2)->src_dst) | ((k1)->id ^ (k2)->id)) @@ -74,37 +76,37 @@ struct ipv4_frag_key { * Fragmented packet to reassemble. * First two entries in the frags[] array are for the last and first fragments. */ -struct ipv4_frag_pkt { - TAILQ_ENTRY(ipv4_frag_pkt) lru; /* LRU list */ - struct ipv4_frag_key key; +struct ip_frag_pkt { + TAILQ_ENTRY(ip_frag_pkt) lru; /* LRU list */ + struct ip_frag_key key; uint64_t start; /* creation timestamp */ uint32_t total_size; /* expected reassembled size */ uint32_t frag_size; /* size of fragments received */ uint32_t last_idx; /* index of next entry to fill */ - struct ipv4_frag frags[MAX_FRAG_NUM]; + struct ip_frag frags[MAX_FRAG_NUM]; } __rte_cache_aligned; -struct ipv4_frag_death_row { +struct ip_frag_death_row { uint32_t cnt; struct rte_mbuf *row[MAX_PKT_BURST * (MAX_FRAG_NUM + 1)]; }; -#define IPV4_FRAG_MBUF2DR(dr, mb) ((dr)->row[(dr)->cnt++] = (mb)) +#define IP_FRAG_MBUF2DR(dr, mb) ((dr)->row[(dr)->cnt++] = (mb)) /* logging macros. */ -#ifdef IPV4_FRAG_DEBUG -#define IPV4_FRAG_LOG(lvl, fmt, args...) RTE_LOG(lvl, USER1, fmt, ##args) +#ifdef IP_FRAG_DEBUG +#define IP_FRAG_LOG(lvl, fmt, args...) RTE_LOG(lvl, USER1, fmt, ##args) #else -#define IPV4_FRAG_LOG(lvl, fmt, args...) do {} while(0) -#endif /* IPV4_FRAG_DEBUG */ +#define IP_FRAG_LOG(lvl, fmt, args...) do {} while(0) +#endif /* IP_FRAG_DEBUG */ static inline void -ipv4_frag_reset(struct ipv4_frag_pkt *fp, uint64_t tms) +ip_frag_reset(struct ip_frag_pkt *fp, uint64_t tms) { - static const struct ipv4_frag zero_frag = { + static const struct ip_frag zero_frag = { .ofs = 0, .len = 0, .mb = NULL, @@ -119,7 +121,7 @@ ipv4_frag_reset(struct ipv4_frag_pkt *fp, uint64_t tms) } static inline void -ipv4_frag_free(struct ipv4_frag_pkt *fp, struct ipv4_frag_death_row *dr) +ip_frag_free(struct ip_frag_pkt *fp, struct ip_frag_death_row *dr) { uint32_t i, k; @@ -136,7 +138,7 @@ ipv4_frag_free(struct ipv4_frag_pkt *fp, struct ipv4_frag_death_row *dr) } static inline void -ipv4_frag_free_death_row(struct ipv4_frag_death_row *dr, uint32_t prefetch) +rte_ip_frag_free_death_row(struct ip_frag_death_row *dr, uint32_t prefetch) { uint32_t i, k, n; @@ -163,7 +165,7 @@ ipv4_frag_free_death_row(struct ipv4_frag_death_row *dr, uint32_t prefetch) * chains them into one mbuf. */ static inline void -ipv4_frag_chain(struct rte_mbuf *mn, struct rte_mbuf *mp) +ip_frag_chain(struct rte_mbuf *mn, struct rte_mbuf *mp) { struct rte_mbuf *ms; @@ -188,7 +190,7 @@ ipv4_frag_chain(struct rte_mbuf *mn, struct rte_mbuf *mp) * Reassemble fragments into one packet. */ static inline struct rte_mbuf * -ipv4_frag_reassemble(const struct ipv4_frag_pkt *fp) +ipv4_frag_reassemble(const struct ip_frag_pkt *fp) { struct ipv4_hdr *ip_hdr; struct rte_mbuf *m, *prev; @@ -210,7 +212,7 @@ ipv4_frag_reassemble(const struct ipv4_frag_pkt *fp) /* previous fragment found. */ if(fp->frags[i].ofs + fp->frags[i].len == ofs) { - ipv4_frag_chain(fp->frags[i].mb, m); + ip_frag_chain(fp->frags[i].mb, m); /* update our last fragment and offset. */ m = fp->frags[i].mb; @@ -225,14 +227,14 @@ ipv4_frag_reassemble(const struct ipv4_frag_pkt *fp) } /* chain with the first fragment. */ - ipv4_frag_chain(fp->frags[FIRST_FRAG_IDX].mb, m); + ip_frag_chain(fp->frags[FIRST_FRAG_IDX].mb, m); m = fp->frags[FIRST_FRAG_IDX].mb; /* update mbuf fields for reassembled packet. */ m->ol_flags |= PKT_TX_IP_CKSUM; /* update ipv4 header for the reassmebled packet */ - ip_hdr = (struct ipv4_hdr*)(rte_pktmbuf_mtod(m, uint8_t *) + + ip_hdr = (struct ipv4_hdr *)(rte_pktmbuf_mtod(m, uint8_t *) + m->pkt.vlan_macip.f.l2_len); ip_hdr->total_length = rte_cpu_to_be_16((uint16_t)(fp->total_size + @@ -245,7 +247,7 @@ ipv4_frag_reassemble(const struct ipv4_frag_pkt *fp) } static inline struct rte_mbuf * -ipv4_frag_process(struct ipv4_frag_pkt *fp, struct ipv4_frag_death_row *dr, +ip_frag_process(struct ip_frag_pkt *fp, struct ip_frag_death_row *dr, struct rte_mbuf *mb, uint16_t ofs, uint16_t len, uint16_t more_frags) { uint32_t idx; @@ -276,7 +278,7 @@ ipv4_frag_process(struct ipv4_frag_pkt *fp, struct ipv4_frag_death_row *dr, if (idx >= sizeof (fp->frags) / sizeof (fp->frags[0])) { /* report an error. */ - IPV4_FRAG_LOG(DEBUG, "%s:%d invalid fragmented packet:\n" + IP_FRAG_LOG(DEBUG, "%s:%d invalid fragmented packet:\n" "ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, " "total_size: %u, frag_size: %u, last_idx: %u\n" "first fragment: ofs: %u, len: %u\n" @@ -290,9 +292,9 @@ ipv4_frag_process(struct ipv4_frag_pkt *fp, struct ipv4_frag_death_row *dr, fp->frags[LAST_FRAG_IDX].len); /* free all fragments, invalidate the entry. */ - ipv4_frag_free(fp, dr); - IPV4_FRAG_KEY_INVALIDATE(&fp->key); - IPV4_FRAG_MBUF2DR(dr, mb); + ip_frag_free(fp, dr); + IP_FRAG_KEY_INVALIDATE(&fp->key); + IP_FRAG_MBUF2DR(dr, mb); return (NULL); } @@ -317,7 +319,7 @@ ipv4_frag_process(struct ipv4_frag_pkt *fp, struct ipv4_frag_death_row *dr, if (mb == NULL) { /* report an error. */ - IPV4_FRAG_LOG(DEBUG, "%s:%d invalid fragmented packet:\n" + IP_FRAG_LOG(DEBUG, "%s:%d invalid fragmented packet:\n" "ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, " "total_size: %u, frag_size: %u, last_idx: %u\n" "first fragment: ofs: %u, len: %u\n" @@ -331,11 +333,11 @@ ipv4_frag_process(struct ipv4_frag_pkt *fp, struct ipv4_frag_death_row *dr, fp->frags[LAST_FRAG_IDX].len); /* free associated resources. */ - ipv4_frag_free(fp, dr); + ip_frag_free(fp, dr); } /* we are done with that entry, invalidate it. */ - IPV4_FRAG_KEY_INVALIDATE(&fp->key); + IP_FRAG_KEY_INVALIDATE(&fp->key); return (mb); } @@ -362,12 +364,12 @@ ipv4_frag_process(struct ipv4_frag_pkt *fp, struct ipv4_frag_death_row *dr, * - not all fragments of the packet are collected yet. */ static inline struct rte_mbuf * -ipv4_frag_mbuf(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, - struct rte_mbuf *mb, uint64_t tms, struct ipv4_hdr *ip_hdr, - uint16_t ip_ofs, uint16_t ip_flag) +rte_ipv4_reassemble_packet(struct ip_frag_tbl *tbl, + struct ip_frag_death_row *dr, struct rte_mbuf *mb, uint64_t tms, + struct ipv4_hdr *ip_hdr, uint16_t ip_ofs, uint16_t ip_flag) { - struct ipv4_frag_pkt *fp; - struct ipv4_frag_key key; + struct ip_frag_pkt *fp; + struct ip_frag_key key; const uint64_t *psd; uint16_t ip_len; @@ -379,7 +381,7 @@ ipv4_frag_mbuf(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, ip_len = (uint16_t)(rte_be_to_cpu_16(ip_hdr->total_length) - mb->pkt.vlan_macip.f.l3_len); - IPV4_FRAG_LOG(DEBUG, "%s:%d:\n" + IP_FRAG_LOG(DEBUG, "%s:%d:\n" "mbuf: %p, tms: %" PRIu64 ", key: <%" PRIx64 ", %#x>, ofs: %u, len: %u, flags: %#x\n" "tbl: %p, max_cycles: %" PRIu64 ", entry_mask: %#x, " @@ -390,12 +392,12 @@ ipv4_frag_mbuf(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, tbl->use_entries); /* try to find/add entry into the fragment's table. */ - if ((fp = ipv4_frag_find(tbl, dr, &key, tms)) == NULL) { - IPV4_FRAG_MBUF2DR(dr, mb); - return (NULL); + if ((fp = ip_frag_find(tbl, dr, &key, tms)) == NULL) { + IP_FRAG_MBUF2DR(dr, mb); + return NULL; } - IPV4_FRAG_LOG(DEBUG, "%s:%d:\n" + IP_FRAG_LOG(DEBUG, "%s:%d:\n" "tbl: %p, max_entries: %u, use_entries: %u\n" "ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, start: %" PRIu64 ", total_size: %u, frag_size: %u, last_idx: %u\n\n", @@ -406,10 +408,10 @@ ipv4_frag_mbuf(struct ipv4_frag_tbl *tbl, struct ipv4_frag_death_row *dr, /* process the fragmented packet. */ - mb = ipv4_frag_process(fp, dr, mb, ip_ofs, ip_len, ip_flag); - ipv4_frag_inuse(tbl, fp); + mb = ip_frag_process(fp, dr, mb, ip_ofs, ip_len, ip_flag); + ip_frag_inuse(tbl, fp); - IPV4_FRAG_LOG(DEBUG, "%s:%d:\n" + IP_FRAG_LOG(DEBUG, "%s:%d:\n" "mbuf: %p\n" "tbl: %p, max_entries: %u, use_entries: %u\n" "ipv4_frag_pkt: %p, key: <%" PRIx64 ", %#x>, start: %" PRIu64 -- 1.8.1.4