1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2014 Intel Corporation 3 */ 4 5 #include <stddef.h> 6 #include <errno.h> 7 8 #include <rte_memcpy.h> 9 10 #include "ip_frag_common.h" 11 12 /** 13 * @file 14 * RTE IPv6 Fragmentation 15 * 16 * Implementation of IPv6 fragmentation. 17 * 18 */ 19 20 static inline void 21 __fill_ipv6hdr_frag(struct rte_ipv6_hdr *dst, 22 const struct rte_ipv6_hdr *src, uint16_t len, uint16_t fofs, 23 uint32_t mf) 24 { 25 struct ipv6_extension_fragment *fh; 26 27 rte_memcpy(dst, src, sizeof(*dst)); 28 dst->payload_len = rte_cpu_to_be_16(len); 29 dst->proto = IPPROTO_FRAGMENT; 30 31 fh = (struct ipv6_extension_fragment *) ++dst; 32 fh->next_header = src->proto; 33 fh->reserved = 0; 34 fh->frag_data = rte_cpu_to_be_16(RTE_IPV6_SET_FRAG_DATA(fofs, mf)); 35 fh->id = 0; 36 } 37 38 static inline void 39 __free_fragments(struct rte_mbuf *mb[], uint32_t num) 40 { 41 uint32_t i; 42 for (i = 0; i < num; i++) 43 rte_pktmbuf_free(mb[i]); 44 } 45 46 /** 47 * IPv6 fragmentation. 48 * 49 * This function implements the fragmentation of IPv6 packets. 50 * 51 * @param pkt_in 52 * The input packet. 53 * @param pkts_out 54 * Array storing the output fragments. 55 * @param mtu_size 56 * Size in bytes of the Maximum Transfer Unit (MTU) for the outgoing IPv6 57 * datagrams. This value includes the size of the IPv6 header. 58 * @param pool_direct 59 * MBUF pool used for allocating direct buffers for the output fragments. 60 * @param pool_indirect 61 * MBUF pool used for allocating indirect buffers for the output fragments. 62 * @return 63 * Upon successful completion - number of output fragments placed 64 * in the pkts_out array. 65 * Otherwise - (-1) * <errno>. 66 */ 67 int32_t 68 rte_ipv6_fragment_packet(struct rte_mbuf *pkt_in, 69 struct rte_mbuf **pkts_out, 70 uint16_t nb_pkts_out, 71 uint16_t mtu_size, 72 struct rte_mempool *pool_direct, 73 struct rte_mempool *pool_indirect) 74 { 75 struct rte_mbuf *in_seg = NULL; 76 struct rte_ipv6_hdr *in_hdr; 77 uint32_t out_pkt_pos, in_seg_data_pos; 78 uint32_t more_in_segs; 79 uint16_t fragment_offset, frag_size; 80 uint64_t frag_bytes_remaining; 81 82 /* 83 * Formal parameter checking. 84 */ 85 if (unlikely(pkt_in == NULL) || unlikely(pkts_out == NULL) || 86 unlikely(nb_pkts_out == 0) || 87 unlikely(pool_direct == NULL) || unlikely(pool_indirect == NULL) || 88 unlikely(mtu_size < RTE_IPV6_MIN_MTU)) 89 return -EINVAL; 90 91 /* 92 * Ensure the IP payload length of all fragments (except the 93 * the last fragment) are a multiple of 8 bytes per RFC2460. 94 */ 95 96 frag_size = mtu_size - sizeof(struct rte_ipv6_hdr) - 97 sizeof(struct ipv6_extension_fragment); 98 frag_size = RTE_ALIGN_FLOOR(frag_size, RTE_IPV6_EHDR_FO_ALIGN); 99 100 /* Check that pkts_out is big enough to hold all fragments */ 101 if (unlikely (frag_size * nb_pkts_out < 102 (uint16_t)(pkt_in->pkt_len - sizeof(struct rte_ipv6_hdr)))) 103 return -EINVAL; 104 105 in_hdr = rte_pktmbuf_mtod(pkt_in, struct rte_ipv6_hdr *); 106 107 in_seg = pkt_in; 108 in_seg_data_pos = sizeof(struct rte_ipv6_hdr); 109 out_pkt_pos = 0; 110 fragment_offset = 0; 111 112 more_in_segs = 1; 113 while (likely(more_in_segs)) { 114 struct rte_mbuf *out_pkt = NULL, *out_seg_prev = NULL; 115 uint32_t more_out_segs; 116 struct rte_ipv6_hdr *out_hdr; 117 118 /* Allocate direct buffer */ 119 out_pkt = rte_pktmbuf_alloc(pool_direct); 120 if (unlikely(out_pkt == NULL)) { 121 __free_fragments(pkts_out, out_pkt_pos); 122 return -ENOMEM; 123 } 124 125 /* Reserve space for the IP header that will be built later */ 126 out_pkt->data_len = sizeof(struct rte_ipv6_hdr) + 127 sizeof(struct ipv6_extension_fragment); 128 out_pkt->pkt_len = sizeof(struct rte_ipv6_hdr) + 129 sizeof(struct ipv6_extension_fragment); 130 frag_bytes_remaining = frag_size; 131 132 out_seg_prev = out_pkt; 133 more_out_segs = 1; 134 while (likely(more_out_segs && more_in_segs)) { 135 struct rte_mbuf *out_seg = NULL; 136 uint32_t len; 137 138 /* Allocate indirect buffer */ 139 out_seg = rte_pktmbuf_alloc(pool_indirect); 140 if (unlikely(out_seg == NULL)) { 141 rte_pktmbuf_free(out_pkt); 142 __free_fragments(pkts_out, out_pkt_pos); 143 return -ENOMEM; 144 } 145 out_seg_prev->next = out_seg; 146 out_seg_prev = out_seg; 147 148 /* Prepare indirect buffer */ 149 rte_pktmbuf_attach(out_seg, in_seg); 150 len = frag_bytes_remaining; 151 if (len > (in_seg->data_len - in_seg_data_pos)) { 152 len = in_seg->data_len - in_seg_data_pos; 153 } 154 out_seg->data_off = in_seg->data_off + in_seg_data_pos; 155 out_seg->data_len = (uint16_t)len; 156 out_pkt->pkt_len = (uint16_t)(len + 157 out_pkt->pkt_len); 158 out_pkt->nb_segs += 1; 159 in_seg_data_pos += len; 160 frag_bytes_remaining -= len; 161 162 /* Current output packet (i.e. fragment) done ? */ 163 if (unlikely(frag_bytes_remaining == 0)) 164 more_out_segs = 0; 165 166 /* Current input segment done ? */ 167 if (unlikely(in_seg_data_pos == in_seg->data_len)) { 168 in_seg = in_seg->next; 169 in_seg_data_pos = 0; 170 171 if (unlikely(in_seg == NULL)) { 172 more_in_segs = 0; 173 } 174 } 175 } 176 177 /* Build the IP header */ 178 179 out_hdr = rte_pktmbuf_mtod(out_pkt, struct rte_ipv6_hdr *); 180 181 __fill_ipv6hdr_frag(out_hdr, in_hdr, 182 (uint16_t) out_pkt->pkt_len - sizeof(struct rte_ipv6_hdr), 183 fragment_offset, more_in_segs); 184 185 fragment_offset = (uint16_t)(fragment_offset + 186 out_pkt->pkt_len - sizeof(struct rte_ipv6_hdr) 187 - sizeof(struct ipv6_extension_fragment)); 188 189 /* Write the fragment to the output list */ 190 pkts_out[out_pkt_pos] = out_pkt; 191 out_pkt_pos ++; 192 } 193 194 return out_pkt_pos; 195 } 196