1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2014 Intel Corporation 3 */ 4 5 #ifndef _RTE_IP_FRAG_H_ 6 #define _RTE_IP_FRAG_H_ 7 8 /** 9 * @file 10 * RTE IP Fragmentation and Reassembly 11 * 12 * Implementation of IP packet fragmentation and reassembly. 13 */ 14 15 #ifdef __cplusplus 16 extern "C" { 17 #endif 18 19 #include <stdint.h> 20 #include <stdio.h> 21 22 #include <rte_config.h> 23 #include <rte_malloc.h> 24 #include <rte_memory.h> 25 #include <rte_ip.h> 26 #include <rte_byteorder.h> 27 28 struct rte_mbuf; 29 30 /** death row size (in packets) */ 31 #define RTE_IP_FRAG_DEATH_ROW_LEN 32 32 33 /** death row size in mbufs */ 34 #define RTE_IP_FRAG_DEATH_ROW_MBUF_LEN \ 35 (RTE_IP_FRAG_DEATH_ROW_LEN * (RTE_LIBRTE_IP_FRAG_MAX_FRAG + 1)) 36 37 /** mbuf death row (packets to be freed) */ 38 struct rte_ip_frag_death_row { 39 uint32_t cnt; /**< number of mbufs currently on death row */ 40 struct rte_mbuf *row[RTE_IP_FRAG_DEATH_ROW_MBUF_LEN]; 41 /**< mbufs to be freed */ 42 }; 43 44 /** 45 * Create a new IP fragmentation table. 46 * 47 * @param bucket_num 48 * Number of buckets in the hash table. 49 * @param bucket_entries 50 * Number of entries per bucket (e.g. hash associativity). 51 * Should be power of two. 52 * @param max_entries 53 * Maximum number of entries that could be stored in the table. 54 * The value should be less or equal then bucket_num * bucket_entries. 55 * @param max_cycles 56 * Maximum TTL in cycles for each fragmented packet. 57 * @param socket_id 58 * The *socket_id* argument is the socket identifier in the case of 59 * NUMA. The value can be *SOCKET_ID_ANY* if there is no NUMA constraints. 60 * @return 61 * The pointer to the new allocated fragmentation table, on success. NULL on error. 62 */ 63 struct rte_ip_frag_tbl * rte_ip_frag_table_create(uint32_t bucket_num, 64 uint32_t bucket_entries, uint32_t max_entries, 65 uint64_t max_cycles, int socket_id); 66 67 /** 68 * Free allocated IP fragmentation table. 69 * 70 * @param tbl 71 * Fragmentation table to free. 72 */ 73 void 74 rte_ip_frag_table_destroy(struct rte_ip_frag_tbl *tbl); 75 76 /** 77 * This function implements the fragmentation of IPv6 packets. 78 * 79 * @param pkt_in 80 * The input packet. 81 * @param pkts_out 82 * Array storing the output fragments. 83 * @param nb_pkts_out 84 * Number of fragments. 85 * @param mtu_size 86 * Size in bytes of the Maximum Transfer Unit (MTU) for the outgoing IPv6 87 * datagrams. This value includes the size of the IPv6 header. 88 * @param pool_direct 89 * MBUF pool used for allocating direct buffers for the output fragments. 90 * @param pool_indirect 91 * MBUF pool used for allocating indirect buffers for the output fragments. 92 * @return 93 * Upon successful completion - number of output fragments placed 94 * in the pkts_out array. 95 * Otherwise - (-1) * errno. 96 */ 97 int32_t 98 rte_ipv6_fragment_packet(struct rte_mbuf *pkt_in, 99 struct rte_mbuf **pkts_out, 100 uint16_t nb_pkts_out, 101 uint16_t mtu_size, 102 struct rte_mempool *pool_direct, 103 struct rte_mempool *pool_indirect); 104 105 /** 106 * This function implements reassembly of fragmented IPv6 packets. 107 * Incoming mbuf should have its l2_len/l3_len fields setup correctly. 108 * 109 * @param tbl 110 * Table where to lookup/add the fragmented packet. 111 * @param dr 112 * Death row to free buffers to 113 * @param mb 114 * Incoming mbuf with IPv6 fragment. 115 * @param tms 116 * Fragment arrival timestamp. 117 * @param ip_hdr 118 * Pointer to the IPv6 header. 119 * @param frag_hdr 120 * Pointer to the IPv6 fragment extension header. 121 * @return 122 * Pointer to mbuf for reassembled packet, or NULL if: 123 * - an error occurred. 124 * - not all fragments of the packet are collected yet. 125 */ 126 struct rte_mbuf *rte_ipv6_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl, 127 struct rte_ip_frag_death_row *dr, 128 struct rte_mbuf *mb, uint64_t tms, struct rte_ipv6_hdr *ip_hdr, 129 struct rte_ipv6_fragment_ext *frag_hdr); 130 131 /** 132 * Return a pointer to the packet's fragment header, if found. 133 * It only looks at the extension header that's right after the fixed IPv6 134 * header, and doesn't follow the whole chain of extension headers. 135 * 136 * @param hdr 137 * Pointer to the IPv6 header. 138 * @return 139 * Pointer to the IPv6 fragment extension header, or NULL if it's not 140 * present. 141 */ 142 static inline struct rte_ipv6_fragment_ext * 143 rte_ipv6_frag_get_ipv6_fragment_header(struct rte_ipv6_hdr *hdr) 144 { 145 if (hdr->proto == IPPROTO_FRAGMENT) { 146 return (struct rte_ipv6_fragment_ext *) ++hdr; 147 } 148 else 149 return NULL; 150 } 151 152 /** 153 * IPv4 fragmentation. 154 * 155 * This function implements the fragmentation of IPv4 packets. 156 * 157 * @param pkt_in 158 * The input packet. 159 * @param pkts_out 160 * Array storing the output fragments. 161 * @param nb_pkts_out 162 * Number of fragments. 163 * @param mtu_size 164 * Size in bytes of the Maximum Transfer Unit (MTU) for the outgoing IPv4 165 * datagrams. This value includes the size of the IPv4 header. 166 * @param pool_direct 167 * MBUF pool used for allocating direct buffers for the output fragments. 168 * @param pool_indirect 169 * MBUF pool used for allocating indirect buffers for the output fragments. 170 * @return 171 * Upon successful completion - number of output fragments placed 172 * in the pkts_out array. 173 * Otherwise - (-1) * errno. 174 */ 175 int32_t rte_ipv4_fragment_packet(struct rte_mbuf *pkt_in, 176 struct rte_mbuf **pkts_out, 177 uint16_t nb_pkts_out, uint16_t mtu_size, 178 struct rte_mempool *pool_direct, 179 struct rte_mempool *pool_indirect); 180 181 /** 182 * This function implements reassembly of fragmented IPv4 packets. 183 * Incoming mbufs should have its l2_len/l3_len fields setup correctly. 184 * 185 * @param tbl 186 * Table where to lookup/add the fragmented packet. 187 * @param dr 188 * Death row to free buffers to 189 * @param mb 190 * Incoming mbuf with IPv4 fragment. 191 * @param tms 192 * Fragment arrival timestamp. 193 * @param ip_hdr 194 * Pointer to the IPV4 header inside the fragment. 195 * @return 196 * Pointer to mbuf for reassembled packet, or NULL if: 197 * - an error occurred. 198 * - not all fragments of the packet are collected yet. 199 */ 200 struct rte_mbuf * rte_ipv4_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl, 201 struct rte_ip_frag_death_row *dr, 202 struct rte_mbuf *mb, uint64_t tms, struct rte_ipv4_hdr *ip_hdr); 203 204 /** 205 * Check if the IPv4 packet is fragmented 206 * 207 * @param hdr 208 * IPv4 header of the packet 209 * @return 210 * 1 if fragmented, 0 if not fragmented 211 */ 212 static inline int 213 rte_ipv4_frag_pkt_is_fragmented(const struct rte_ipv4_hdr *hdr) 214 { 215 uint16_t flag_offset, ip_flag, ip_ofs; 216 217 flag_offset = rte_be_to_cpu_16(hdr->fragment_offset); 218 ip_ofs = (uint16_t)(flag_offset & RTE_IPV4_HDR_OFFSET_MASK); 219 ip_flag = (uint16_t)(flag_offset & RTE_IPV4_HDR_MF_FLAG); 220 221 return ip_flag != 0 || ip_ofs != 0; 222 } 223 224 /** 225 * Free mbufs on a given death row. 226 * 227 * @param dr 228 * Death row to free mbufs in. 229 * @param prefetch 230 * How many buffers to prefetch before freeing. 231 */ 232 void rte_ip_frag_free_death_row(struct rte_ip_frag_death_row *dr, 233 uint32_t prefetch); 234 235 236 /** 237 * Dump fragmentation table statistics to file. 238 * 239 * @param f 240 * File to dump statistics to 241 * @param tbl 242 * Fragmentation table to dump statistics from 243 */ 244 void 245 rte_ip_frag_table_statistics_dump(FILE * f, const struct rte_ip_frag_tbl *tbl); 246 247 /** 248 * Delete expired fragments 249 * 250 * @param tbl 251 * Table to delete expired fragments from 252 * @param dr 253 * Death row to free buffers to 254 * @param tms 255 * Current timestamp 256 */ 257 __rte_experimental 258 void 259 rte_ip_frag_table_del_expired_entries(struct rte_ip_frag_tbl *tbl, 260 struct rte_ip_frag_death_row *dr, uint64_t tms); 261 262 /**@{@name Obsolete macros, kept here for compatibility reasons. 263 * Will be deprecated/removed in future DPDK releases. 264 */ 265 /** Obsolete */ 266 #define IP_FRAG_DEATH_ROW_LEN RTE_IP_FRAG_DEATH_ROW_LEN 267 /** Obsolete */ 268 #define IP_FRAG_DEATH_ROW_MBUF_LEN RTE_IP_FRAG_DEATH_ROW_MBUF_LEN 269 /** Obsolete */ 270 #define ipv6_extension_fragment rte_ipv6_fragment_ext 271 /**@}*/ 272 273 #ifdef __cplusplus 274 } 275 #endif 276 277 #endif /* _RTE_IP_FRAG_H_ */ 278