int odp_packet_has_error(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
if (packet_parse_not_complete(pkt_hdr))
packet_parse_layer(pkt_hdr, LAYER_ALL);
return odp_packet_hdr(pkt)->p.error_flags.all != 0;
}
int odp_packet_has_error(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
return odp_packet_hdr(pkt)->error_flags.all != 0;
}
void odp_packet_print(odp_packet_t pkt)
{
int max_len = 512;
char str[max_len];
int len = 0;
int n = max_len-1;
odp_packet_hdr_t *hdr = odp_packet_hdr(pkt);
len += snprintf(&str[len], n-len, "Packet ");
len += odp_buffer_snprint(&str[len], n-len, (odp_buffer_t) pkt);
len += snprintf(&str[len], n-len,
" input_flags 0x%x\n", hdr->input_flags.all);
len += snprintf(&str[len], n-len,
" error_flags 0x%x\n", hdr->error_flags.all);
len += snprintf(&str[len], n-len,
" output_flags 0x%x\n", hdr->output_flags.all);
len += snprintf(&str[len], n-len,
" frame_offset %u\n", hdr->frame_offset);
len += snprintf(&str[len], n-len,
" l2_offset %u\n", hdr->l2_offset);
len += snprintf(&str[len], n-len,
" l3_offset %u\n", hdr->l3_offset);
len += snprintf(&str[len], n-len,
" l4_offset %u\n", hdr->l4_offset);
len += snprintf(&str[len], n-len,
" frame_len %u\n", hdr->frame_len);
len += snprintf(&str[len], n-len,
" input %u\n", hdr->input);
str[len] = '\0';
printf("\n%s\n", str);
}
int odp_eth_rx_burst(pktio_entry_t *pktio_entry, odp_packet_t *rx_pkts,
unsigned int nb_pkts)
{
int nb_rx;
struct odp_eth_dev *dev;
uint8_t port_id = pktio_entry->s.pkt_odp.portid;
uint16_t queue_id = pktio_entry->s.pkt_odp.queueid;
dev = &odp_eth_devices[port_id];
if (pktio_cls_enabled(pktio_entry, queue_id)) {
odp_packet_t tmpbuf[64];
odp_packet_t onepkt;
odp_packet_hdr_t *pkt_hdr;
odp_pktio_t id;
int i, j;
if (nb_pkts > 64)
nb_pkts = 64;
nb_rx = (*dev->rx_pkt_burst)(dev->data->rx_queues[queue_id],
(void **)tmpbuf, nb_pkts);
if (odp_unlikely(nb_rx <= 0))
return nb_rx;
id = pktio_entry->s.handle;
for (i = 0, j = 0; i < nb_rx; i++) {
onepkt = tmpbuf[i];
pkt_hdr = odp_packet_hdr(onepkt);
pkt_hdr->input = id;
packet_parse_reset(pkt_hdr);
packet_parse_l2(pkt_hdr);
if (0 > _odp_packet_classifier(pktio_entry,
queue_id, onepkt)) {
rx_pkts[j++] = onepkt;
}
}
nb_rx = j;
} else {
nb_rx = (*dev->rx_pkt_burst)(dev->data->rx_queues[queue_id],
(void **)rx_pkts, nb_pkts);
}
#ifdef ODP_ETHDEV_RXTX_CALLBACKS
struct odp_eth_rxtx_callback *cb = dev->post_rx_burst_cbs[queue_id];
if (odp_unlikely(cb)) {
do {
nb_rx = cb->fn.rx(port_id, queue_id,
(void **)rx_pkts, nb_rx, nb_pkts,
cb->param);
cb = cb->next;
} while (cb);
}
#endif
return nb_rx;
}
odp_bool_t odp_packet_drop_eligible(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
if (packet_parse_not_complete(pkt_hdr))
packet_parse_layer(pkt_hdr, LAYER_ALL);
return !pkt_hdr->p.input_flags.nodrop;
}
void odp_packet_color_set(odp_packet_t pkt, odp_packet_color_t color)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
if (packet_parse_not_complete(pkt_hdr))
packet_parse_layer(pkt_hdr, LAYER_ALL);
pkt_hdr->p.input_flags.color = color;
}
void odp_packet_shaper_len_adjust_set(odp_packet_t pkt, int8_t adj)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
if (packet_parse_not_complete(pkt_hdr))
packet_parse_layer(pkt_hdr, LAYER_ALL);
pkt_hdr->p.output_flags.shaper_len_adj = adj;
}
int odp_packet_has_l2_error(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
/* L2 parsing is always done by default and hence
no additional check is required */
return pkt_hdr->p.error_flags.frame_len
| pkt_hdr->p.error_flags.snap_len
| pkt_hdr->p.error_flags.l2_chksum;
}
int odp_packet_has_l3_error(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
if (pkt_hdr->p.parsed_layers < LAYER_L3)
packet_parse_layer(pkt_hdr, LAYER_L3);
return pkt_hdr->p.error_flags.ip_err;
}
int odp_packet_has_l4_error(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
if (pkt_hdr->p.parsed_layers < LAYER_L4)
packet_parse_layer(pkt_hdr, LAYER_L4);
return pkt_hdr->p.error_flags.tcp_err | pkt_hdr->p.error_flags.udp_err;
}
static inline void update_in_packet(odp_buffer_hdr_t *buf_hdr,
odp_pktio_t pktin)
{
if (!buf_hdr)
return;
odp_buffer_t buf = hdr_to_odp_buf(buf_hdr);
odp_packet_t pkt = odp_packet_from_buffer(buf);
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
size_t len = odp_packet_get_len(pkt);
pkt_hdr->input = pktin;
odp_packet_parse(pkt, len, 0);
}
int odp_packet_copy(odp_packet_t pkt_dst, odp_packet_t pkt_src)
{
odp_packet_hdr_t *const pkt_hdr_dst = odp_packet_hdr(pkt_dst);
odp_packet_hdr_t *const pkt_hdr_src = odp_packet_hdr(pkt_src);
const size_t start_offset = ODP_FIELD_SIZEOF(odp_packet_hdr_t, buf_hdr);
uint8_t *start_src;
uint8_t *start_dst;
size_t len;
if (pkt_dst == ODP_PACKET_INVALID || pkt_src == ODP_PACKET_INVALID)
return -1;
if (pkt_hdr_dst->buf_hdr.size <
pkt_hdr_src->frame_len + pkt_hdr_src->frame_offset)
return -1;
/* Copy packet header */
start_dst = (uint8_t *)pkt_hdr_dst + start_offset;
start_src = (uint8_t *)pkt_hdr_src + start_offset;
len = ODP_OFFSETOF(odp_packet_hdr_t, buf_data) - start_offset;
memcpy(start_dst, start_src, len);
/* Copy frame payload */
start_dst = (uint8_t *)odp_packet_start(pkt_dst);
start_src = (uint8_t *)odp_packet_start(pkt_src);
len = pkt_hdr_src->frame_len;
memcpy(start_dst, start_src, len);
/* Copy useful things from the buffer header */
pkt_hdr_dst->buf_hdr.cur_offset = pkt_hdr_src->buf_hdr.cur_offset;
/* Create a copy of the scatter list */
odp_buffer_copy_scatter(odp_buffer_from_packet(pkt_dst),
odp_buffer_from_packet(pkt_src));
return 0;
}
void odp_packet_init(odp_packet_t pkt)
{
odp_packet_hdr_t *const pkt_hdr = odp_packet_hdr(pkt);
const size_t start_offset = ODP_FIELD_SIZEOF(odp_packet_hdr_t, buf_hdr);
uint8_t *start;
size_t len;
start = (uint8_t *)pkt_hdr + start_offset;
len = ODP_OFFSETOF(odp_packet_hdr_t, buf_data) - start_offset;
memset(start, 0, len);
pkt_hdr->l2_offset = ODP_PACKET_OFFSET_INVALID;
pkt_hdr->l3_offset = ODP_PACKET_OFFSET_INVALID;
pkt_hdr->l4_offset = ODP_PACKET_OFFSET_INVALID;
}
static int loopback_recv(pktio_entry_t *pktio_entry, odp_packet_t pkts[],
unsigned len)
{
int nbr, i, j;
odp_buffer_hdr_t *hdr_tbl[QUEUE_MULTI_MAX];
queue_entry_t *qentry;
odp_packet_hdr_t *pkt_hdr;
odp_packet_t pkt;
nbr = 0;
qentry = queue_to_qentry(pktio_entry->s.pkt_loop.loopq);
nbr = queue_deq_multi(qentry, hdr_tbl, len);
if (pktio_cls_enabled(pktio_entry)) {
for (i = 0, j = 0; i < nbr; i++) {
pkt = _odp_packet_from_buffer(odp_hdr_to_buf
(hdr_tbl[i]));
pkt_hdr = odp_packet_hdr(pkt);
packet_parse_reset(pkt_hdr);
packet_parse_l2(pkt_hdr);
if (0 > _odp_packet_classifier(pktio_entry, pkt))
pkts[j++] = pkt;
}
nbr = j;
} else {
for (i = 0; i < nbr; ++i) {
pkts[i] = _odp_packet_from_buffer(odp_hdr_to_buf
(hdr_tbl[i]));
pkt_hdr = odp_packet_hdr(pkts[i]);
packet_parse_reset(pkt_hdr);
packet_parse_l2(pkt_hdr);
}
}
return nbr;
}
int odp_packet_has_flow_hash(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
return pkt_hdr->p.input_flags.flow_hash;
}
void odp_packet_set_len(odp_packet_t pkt, size_t len)
{
odp_packet_hdr(pkt)->frame_len = len;
}
size_t odp_packet_get_len(odp_packet_t pkt)
{
return odp_packet_hdr(pkt)->frame_len;
}
void odp_packet_has_ts_clr(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
pkt_hdr->p.input_flags.timestamp = 0;
}
void odp_packet_has_flow_hash_clr(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
pkt_hdr->p.input_flags.flow_hash = 0;
}
int odp_packet_has_l2(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
return pkt_hdr->p.input_flags.l2;
}
uint8_t *odp_packet_start(odp_packet_t pkt)
{
return odp_packet_buf_addr(pkt) + odp_packet_hdr(pkt)->frame_offset;
}
void odp_packet_set_l2_offset(odp_packet_t pkt, size_t offset)
{
odp_packet_hdr(pkt)->l2_offset = offset;
}
size_t odp_packet_l3_offset(odp_packet_t pkt)
{
return odp_packet_hdr(pkt)->l3_offset;
}
int odp_packet_has_ts(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
return pkt_hdr->p.input_flags.timestamp;
}
void *odp_packet_get_ctx(odp_packet_t pkt)
{
return (void *)(intptr_t)odp_packet_hdr(pkt)->user_ctx;
}
int odp_packet_has_eth(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
return pkt_hdr->p.input_flags.eth;
}
void odp_pktio_set_input(odp_packet_t pkt, odp_pktio_t pktio)
{
odp_packet_hdr(pkt)->input = pktio;
}
odp_pktio_t odp_pktio_get_input(odp_packet_t pkt)
{
return odp_packet_hdr(pkt)->input;
}
int odp_packet_has_jumbo(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
return pkt_hdr->p.input_flags.jumbo;
}
static inline unsigned pkt_mmap_v2_rx(pktio_entry_t *pktio_entry,
pkt_sock_mmap_t *pkt_sock,
odp_packet_t pkt_table[], unsigned len,
unsigned char if_mac[])
{
union frame_map ppd;
odp_time_t ts_val;
odp_time_t *ts = NULL;
unsigned frame_num, next_frame_num;
uint8_t *pkt_buf;
int pkt_len;
struct ethhdr *eth_hdr;
unsigned i;
unsigned nb_rx;
struct ring *ring;
int ret;
if (pktio_entry->s.config.pktin.bit.ts_all ||
pktio_entry->s.config.pktin.bit.ts_ptp)
ts = &ts_val;
ring = &pkt_sock->rx_ring;
frame_num = ring->frame_num;
for (i = 0, nb_rx = 0; i < len; i++) {
odp_packet_hdr_t *hdr;
odp_packet_hdr_t parsed_hdr;
odp_pool_t pool = pkt_sock->pool;
int num;
if (!mmap_rx_kernel_ready(ring->rd[frame_num].iov_base))
break;
if (ts != NULL)
ts_val = odp_time_global();
ppd.raw = ring->rd[frame_num].iov_base;
next_frame_num = (frame_num + 1) % ring->rd_num;
pkt_buf = (uint8_t *)ppd.raw + ppd.v2->tp_h.tp_mac;
pkt_len = ppd.v2->tp_h.tp_snaplen;
/* Don't receive packets sent by ourselves */
eth_hdr = (struct ethhdr *)pkt_buf;
if (odp_unlikely(ethaddrs_equal(if_mac,
eth_hdr->h_source))) {
mmap_rx_user_ready(ppd.raw); /* drop */
frame_num = next_frame_num;
continue;
}
if (ppd.v2->tp_h.tp_status & TP_STATUS_VLAN_VALID)
pkt_buf = pkt_mmap_vlan_insert(pkt_buf,
ppd.v2->tp_h.tp_mac,
ppd.v2->tp_h.tp_vlan_tci,
&pkt_len);
if (pktio_cls_enabled(pktio_entry)) {
if (cls_classify_packet(pktio_entry, pkt_buf, pkt_len,
pkt_len, &pool, &parsed_hdr)) {
mmap_rx_user_ready(ppd.raw); /* drop */
frame_num = next_frame_num;
continue;
}
}
num = packet_alloc_multi(pool, pkt_len, &pkt_table[nb_rx], 1);
if (odp_unlikely(num != 1)) {
pkt_table[nb_rx] = ODP_PACKET_INVALID;
mmap_rx_user_ready(ppd.raw); /* drop */
frame_num = next_frame_num;
continue;
}
hdr = odp_packet_hdr(pkt_table[nb_rx]);
ret = odp_packet_copy_from_mem(pkt_table[nb_rx], 0,
pkt_len, pkt_buf);
if (ret != 0) {
odp_packet_free(pkt_table[nb_rx]);
mmap_rx_user_ready(ppd.raw); /* drop */
frame_num = next_frame_num;
continue;
}
hdr->input = pktio_entry->s.handle;
if (pktio_cls_enabled(pktio_entry))
copy_packet_cls_metadata(&parsed_hdr, hdr);
else
packet_parse_l2(&hdr->p, pkt_len);
packet_set_ts(hdr, ts);
mmap_rx_user_ready(ppd.raw);
frame_num = next_frame_num;
nb_rx++;
}
ring->frame_num = frame_num;
return nb_rx;
}
