[COMMIT] branch api-next updated. v1.10.1.0-31-g093fb17
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, api-next has been updated
via 093fb17ce654532dc1e6c379aa13a3dbab9407d6 (commit)
via 2b9f90dc54c5d699083970cbd359db4f137faa31 (commit)
via 072b5ca9ad3f17d70c20bb7d03020ec7a219f698 (commit)
via aa7a1822660eaeecd6f69c525abdc4a21d428716 (commit)
via 2fc98f7ba2fdcf7df0f04b171bc4bdd65b8cf980 (commit)
via 39738abf195e2d3af75133f4ec418614b86e770c (commit)
via c3f73eadd8eafb8e8167d5403d69527b896f9de6 (commit)
via 7da43047a614ce4c030878ee8bef31725c7b71ef (commit)
via bde29f1382ed76fa6b8450b67a249ab2c8c83323 (commit)
via 41ab23c89799de4db4de5c3910b70e80f3a7d8f9 (commit)
via 4cf18bb4f799e6601c20e54fafbdb58da538de89 (commit)
via 793c4b15275fd7e6c30bf348f236e778b9bfee02 (commit)
via 46684cc1f1cdc33b7b223687e063f458b6c7bf02 (commit)
via 8ab5804ea8bd430fd7cd0bd0edae316918b976d7 (commit)
via 33bd749de8128afbb6b5bcad5ef6bea5a2667178 (commit)
via 99b863c804fe38bd919d3b9c2f6dad5ddabf1aaa (commit)
via 8d10e64603e67620084cb92648707550110d7bbe (commit)
via 72634d86988e33ac38dd1ecda2cc4e8a156307ed (commit)
via 341d3029f797ebb2bcf0fa6089c3463eea73e1cc (commit)
via 69717806018f61af84645ff458e3dc69a13d747e (commit)
via b78d235b8fe23b423bf6e7a3c65abbfb7efa4af8 (commit)
via 193bbc8eafa14932f342476a44687237be512148 (commit)
via 165897bfd094d824e2dd83c968ad9fde28146ef9 (commit)
via 4e4ae44b527a9a0635a219eb19e1ffa425c2186a (commit)
via 72b2a7212b6afb2d011e537202611e5566584aea (commit)
via 5567e30f8eabcfe32497b0ed858a5f76f9d764a4 (commit)
via 50029e34c284559b942e6b6b8c56f230eca4f01f (commit)
via aded65c62d9ad5e65c6181588d90d1b99f5c8726 (commit)
via cea088594ea8f951d8716ab071c4052b018f2c19 (commit)
via 1d0d1a1e1b98ebbe2c6dbdb1aae23a704c1dac47 (commit)
via 28026f1ddee3f33da7935055a3f87bcc053035fb (commit)
via 4f621a5acb7e6657e8eb4d17a6fe664e30fda714 (commit)
from 5db841fb0b0b3e705c3a10345df3d2c41bc0ef5b (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 093fb17ce654532dc1e6c379aa13a3dbab9407d6
Merge: 5db841f 2b9f90d
Author: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Date: Thu Jun 16 22:42:38 2016 +0300
Merge branch 'master' into api-next
-----------------------------------------------------------------------
Summary of changes:
CHANGELOG | 165 +++++
configure.ac | 6 +-
doc/{helper-guide/Doxyfile => Doxyfile_common} | 13 -
doc/Makefile.am | 8 +-
doc/application-api-guide/Doxyfile | 50 +-
doc/m4/configure.m4 | 1 +
.../.gitignore | 0
doc/platform-api-guide/Doxyfile | 19 +
.../Makefile.am | 1 -
doc/process-guide/.gitignore | 1 +
doc/process-guide/Makefile.am | 27 +-
doc/users-guide/Makefile.am | 3 +-
example/timer/.gitignore | 3 +
example/timer/Makefile.am | 14 +-
example/timer/odp_timer_simple.c | 157 +++++
helper/include/odp/helper/chksum.h | 2 +-
helper/linux.c | 15 +-
helper/test/thread.c | 2 +-
include/odp/api/spec/version.h | 2 +-
.../include/odp/api/plat/timer_types.h | 2 +-
.../include/odp_classification_inlines.h | 36 +-
.../include/odp_classification_internal.h | 5 +-
.../linux-generic/include/odp_packet_internal.h | 72 ++-
.../linux-generic/include/odp_packet_io_internal.h | 23 +-
platform/linux-generic/include/odp_schedule_if.h | 12 +-
.../include/odp_schedule_ordered_internal.h | 5 +-
platform/linux-generic/odp_classification.c | 28 +-
platform/linux-generic/odp_packet.c | 241 +++----
platform/linux-generic/odp_packet_flags.c | 53 +-
platform/linux-generic/odp_packet_io.c | 147 +++--
platform/linux-generic/odp_queue.c | 32 +-
platform/linux-generic/odp_schedule.c | 80 ++-
platform/linux-generic/odp_schedule_ordered.c | 18 +-
platform/linux-generic/odp_schedule_sp.c | 707 ++++++++++++++++++++-
platform/linux-generic/pktio/dpdk.c | 13 +-
platform/linux-generic/pktio/ipc.c | 2 +-
platform/linux-generic/pktio/loop.c | 33 +-
platform/linux-generic/pktio/netmap.c | 10 +-
platform/linux-generic/pktio/pcap.c | 6 +-
platform/linux-generic/pktio/socket.c | 6 +-
platform/linux-generic/pktio/socket_mmap.c | 6 +-
platform/linux-generic/pktio/tap.c | 2 +-
test/validation/pktio/pktio.c | 23 +-
test/validation/scheduler/scheduler.c | 267 ++++----
test/validation/timer/timer.c | 33 +-
test/validation/traffic_mngr/traffic_mngr.c | 16 +
46 files changed, 1771 insertions(+), 596 deletions(-)
copy doc/{helper-guide/Doxyfile => Doxyfile_common} (64%)
copy doc/{application-api-guide => platform-api-guide}/.gitignore (100%)
create mode 100644 doc/platform-api-guide/Doxyfile
copy doc/{helper-guide => platform-api-guide}/Makefile.am (78%)
create mode 100644 example/timer/odp_timer_simple.c
hooks/post-receive
--
7 years, 10 months
- 1
- 0
[COMMIT] branch master updated. v1.10.1.0-19-g2b9f90d
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 2b9f90dc54c5d699083970cbd359db4f137faa31 (commit)
via 072b5ca9ad3f17d70c20bb7d03020ec7a219f698 (commit)
via aa7a1822660eaeecd6f69c525abdc4a21d428716 (commit)
from 2fc98f7ba2fdcf7df0f04b171bc4bdd65b8cf980 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 2b9f90dc54c5d699083970cbd359db4f137faa31
Author: Matias Elo <matias.elo(a)nokia.com>
Date: Thu Jun 16 16:07:31 2016 +0300
linux-gen: pktio loop: improve classifying segmented packets
Make sure there is enough data for the packet parser in the
case of a segmented packet.
Signed-off-by: Matias Elo <matias.elo(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/pktio/loop.c b/platform/linux-generic/pktio/loop.c
index 645521a..dce33e5 100644
--- a/platform/linux-generic/pktio/loop.c
+++ b/platform/linux-generic/pktio/loop.c
@@ -87,12 +87,24 @@ static int loopback_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
odp_packet_t new_pkt;
odp_pool_t new_pool;
uint8_t *pkt_addr;
+ uint8_t buf[PACKET_PARSE_SEG_LEN];
int ret;
-
- pkt_addr = odp_packet_data(pkt);
+ uint32_t seg_len = odp_packet_seg_len(pkt);
+
+ /* Make sure there is enough data for the packet
+ * parser in the case of a segmented packet. */
+ if (odp_unlikely(seg_len < PACKET_PARSE_SEG_LEN &&
+ pkt_len > PACKET_PARSE_SEG_LEN)) {
+ odp_packet_copy_to_mem(pkt, 0,
+ PACKET_PARSE_SEG_LEN,
+ buf);
+ seg_len = PACKET_PARSE_SEG_LEN;
+ pkt_addr = buf;
+ } else {
+ pkt_addr = odp_packet_data(pkt);
+ }
ret = cls_classify_packet(pktio_entry, pkt_addr,
- pkt_len,
- odp_packet_seg_len(pkt),
+ pkt_len, seg_len,
&new_pool, &parsed_hdr);
if (ret) {
failed++;
commit 072b5ca9ad3f17d70c20bb7d03020ec7a219f698
Author: Matias Elo <matias.elo(a)nokia.com>
Date: Thu Jun 16 16:07:30 2016 +0300
linux-gen: packet: use packet_parser_t type argument with parser functions
Modify packet parser functions to utilize new
packet_parser_t structure.
Renamed the main parser function _odp_parse_common() to
packet_parse_common(). packet_parse_common() now takes
also segment length as argument.
Signed-off-by: Matias Elo <matias.elo(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_classification_internal.h b/platform/linux-generic/include/odp_classification_internal.h
index d6d6904..78eaac9 100644
--- a/platform/linux-generic/include/odp_classification_internal.h
+++ b/platform/linux-generic/include/odp_classification_internal.h
@@ -47,8 +47,9 @@ Start function for Packet Classifier
This function calls Classifier module internal functions for a given packet and
selects destination queue and packet pool based on selected PMR and CoS.
**/
-int cls_classify_packet(pktio_entry_t *entry, const uint8_t *base, uint16_t len,
- odp_pool_t *pool, odp_packet_hdr_t *pkt_hdr);
+int cls_classify_packet(pktio_entry_t *entry, const uint8_t *base,
+ uint16_t pkt_len, uint32_t seg_len, odp_pool_t *pool,
+ odp_packet_hdr_t *pkt_hdr);
/**
Packet IO classifier init
diff --git a/platform/linux-generic/include/odp_packet_internal.h b/platform/linux-generic/include/odp_packet_internal.h
index 71a2ab1..eedb416 100644
--- a/platform/linux-generic/include/odp_packet_internal.h
+++ b/platform/linux-generic/include/odp_packet_internal.h
@@ -29,6 +29,9 @@ extern "C" {
#define PACKET_JUMBO_LEN (9 * 1024)
+/** Minimum segment length expected by packet_parse_common() */
+#define PACKET_PARSE_SEG_LEN 96
+
/**
* Packet input & protocol flags
*/
@@ -287,9 +290,9 @@ static inline void packet_set_len(odp_packet_hdr_t *pkt_hdr, uint32_t len)
pkt_hdr->frame_len = len;
}
-static inline int packet_parse_l2_not_done(odp_packet_hdr_t *pkt_hdr)
+static inline int packet_parse_l2_not_done(packet_parser_t *prs)
{
- return !pkt_hdr->p.input_flags.parsed_l2;
+ return !prs->input_flags.parsed_l2;
}
static inline int packet_parse_not_complete(odp_packet_hdr_t *pkt_hdr)
@@ -303,7 +306,7 @@ void _odp_packet_copy_md_to_packet(odp_packet_t srcpkt, odp_packet_t dstpkt);
odp_packet_t packet_alloc(odp_pool_t pool_hdl, uint32_t len, int parse);
/* Fill in parser metadata for L2 */
-void packet_parse_l2(odp_packet_hdr_t *pkt_hdr);
+void packet_parse_l2(packet_parser_t *prs, uint32_t frame_len);
/* Perform full packet parse */
int packet_parse_full(odp_packet_hdr_t *pkt_hdr);
@@ -340,7 +343,8 @@ static inline void packet_set_ts(odp_packet_hdr_t *pkt_hdr, odp_time_t *ts)
}
}
-int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *parseptr);
+int packet_parse_common(packet_parser_t *pkt_hdr, const uint8_t *ptr,
+ uint32_t pkt_len, uint32_t seg_len);
int _odp_cls_parse(odp_packet_hdr_t *pkt_hdr, const uint8_t *parseptr);
diff --git a/platform/linux-generic/odp_classification.c b/platform/linux-generic/odp_classification.c
index 752348c..0602a62 100644
--- a/platform/linux-generic/odp_classification.c
+++ b/platform/linux-generic/odp_classification.c
@@ -799,7 +799,8 @@ static inline cos_t *cls_select_cos(pktio_entry_t *entry,
*
* @param pktio_entry Ingress pktio
* @param base Packet data
- * @param len Packet length
+ * @param pkt_len Packet length
+ * @param seg_leg Segment length
* @param pool[out] Packet pool
* @param pkt_hdr[out] Packet header
*
@@ -809,15 +810,16 @@ static inline cos_t *cls_select_cos(pktio_entry_t *entry,
*
* @note *base is not released
*/
-int cls_classify_packet(pktio_entry_t *entry, const uint8_t *base, uint16_t len,
- odp_pool_t *pool, odp_packet_hdr_t *pkt_hdr)
+int cls_classify_packet(pktio_entry_t *entry, const uint8_t *base,
+ uint16_t pkt_len, uint32_t seg_len, odp_pool_t *pool,
+ odp_packet_hdr_t *pkt_hdr)
{
cos_t *cos;
packet_parse_reset(pkt_hdr);
- packet_set_len(pkt_hdr, len);
+ packet_set_len(pkt_hdr, pkt_len);
- _odp_parse_common(pkt_hdr, base);
+ packet_parse_common(&pkt_hdr->p, base, pkt_len, seg_len);
cos = cls_select_cos(entry, base, pkt_hdr);
if (cos == NULL)
diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c
index 991a648..c319833 100644
--- a/platform/linux-generic/odp_packet.c
+++ b/platform/linux-generic/odp_packet.c
@@ -992,8 +992,8 @@ void _odp_packet_copy_md_to_packet(odp_packet_t srcpkt, odp_packet_t dstpkt)
/**
* Parser helper function for IPv4
*/
-static inline uint8_t parse_ipv4(odp_packet_hdr_t *pkt_hdr,
- const uint8_t **parseptr, uint32_t *offset)
+static inline uint8_t parse_ipv4(packet_parser_t *prs, const uint8_t **parseptr,
+ uint32_t *offset, uint32_t frame_len)
{
const odph_ipv4hdr_t *ipv4 = (const odph_ipv4hdr_t *)*parseptr;
uint8_t ver = ODPH_IPV4HDR_VER(ipv4->ver_ihl);
@@ -1001,12 +1001,12 @@ static inline uint8_t parse_ipv4(odp_packet_hdr_t *pkt_hdr,
uint16_t frag_offset;
uint32_t dstaddr = odp_be_to_cpu_32(ipv4->dst_addr);
- pkt_hdr->p.l3_len = odp_be_to_cpu_16(ipv4->tot_len);
+ prs->l3_len = odp_be_to_cpu_16(ipv4->tot_len);
if (odp_unlikely(ihl < ODPH_IPV4HDR_IHL_MIN) ||
odp_unlikely(ver != 4) ||
- (pkt_hdr->p.l3_len > pkt_hdr->frame_len - *offset)) {
- pkt_hdr->p.error_flags.ip_err = 1;
+ (prs->l3_len > frame_len - *offset)) {
+ prs->error_flags.ip_err = 1;
return 0;
}
@@ -1014,7 +1014,7 @@ static inline uint8_t parse_ipv4(odp_packet_hdr_t *pkt_hdr,
*parseptr += ihl * 4;
if (odp_unlikely(ihl > ODPH_IPV4HDR_IHL_MIN))
- pkt_hdr->p.input_flags.ipopt = 1;
+ prs->input_flags.ipopt = 1;
/* A packet is a fragment if:
* "more fragments" flag is set (all fragments except the last)
@@ -1023,11 +1023,11 @@ static inline uint8_t parse_ipv4(odp_packet_hdr_t *pkt_hdr,
*/
frag_offset = odp_be_to_cpu_16(ipv4->frag_offset);
if (odp_unlikely(ODPH_IPV4HDR_IS_FRAGMENT(frag_offset)))
- pkt_hdr->p.input_flags.ipfrag = 1;
+ prs->input_flags.ipfrag = 1;
/* Handle IPv4 broadcast / multicast */
- pkt_hdr->p.input_flags.ip_bcast = (dstaddr == 0xffffffff);
- pkt_hdr->p.input_flags.ip_mcast = (dstaddr >> 28) == 0xd;
+ prs->input_flags.ip_bcast = (dstaddr == 0xffffffff);
+ prs->input_flags.ip_mcast = (dstaddr >> 28) == 0xd;
return ipv4->proto;
}
@@ -1035,26 +1035,27 @@ static inline uint8_t parse_ipv4(odp_packet_hdr_t *pkt_hdr,
/**
* Parser helper function for IPv6
*/
-static inline uint8_t parse_ipv6(odp_packet_hdr_t *pkt_hdr,
- const uint8_t **parseptr, uint32_t *offset)
+static inline uint8_t parse_ipv6(packet_parser_t *prs, const uint8_t **parseptr,
+ uint32_t *offset, uint32_t frame_len,
+ uint32_t seg_len)
{
const odph_ipv6hdr_t *ipv6 = (const odph_ipv6hdr_t *)*parseptr;
const odph_ipv6hdr_ext_t *ipv6ext;
uint32_t dstaddr0 = odp_be_to_cpu_32(ipv6->dst_addr[0]);
- pkt_hdr->p.l3_len = odp_be_to_cpu_16(ipv6->payload_len) +
+ prs->l3_len = odp_be_to_cpu_16(ipv6->payload_len) +
ODPH_IPV6HDR_LEN;
/* Basic sanity checks on IPv6 header */
if ((odp_be_to_cpu_32(ipv6->ver_tc_flow) >> 28) != 6 ||
- pkt_hdr->p.l3_len > pkt_hdr->frame_len - *offset) {
- pkt_hdr->p.error_flags.ip_err = 1;
+ prs->l3_len > frame_len - *offset) {
+ prs->error_flags.ip_err = 1;
return 0;
}
/* IPv6 broadcast / multicast flags */
- pkt_hdr->p.input_flags.ip_mcast = (dstaddr0 & 0xff000000) == 0xff000000;
- pkt_hdr->p.input_flags.ip_bcast = 0;
+ prs->input_flags.ip_mcast = (dstaddr0 & 0xff000000) == 0xff000000;
+ prs->input_flags.ip_bcast = 0;
/* Skip past IPv6 header */
*offset += sizeof(odph_ipv6hdr_t);
@@ -1063,7 +1064,7 @@ static inline uint8_t parse_ipv6(odp_packet_hdr_t *pkt_hdr,
/* Skip past any IPv6 extension headers */
if (ipv6->next_hdr == ODPH_IPPROTO_HOPOPTS ||
ipv6->next_hdr == ODPH_IPPROTO_ROUTE) {
- pkt_hdr->p.input_flags.ipopt = 1;
+ prs->input_flags.ipopt = 1;
do {
ipv6ext = (const odph_ipv6hdr_ext_t *)*parseptr;
@@ -1073,23 +1074,23 @@ static inline uint8_t parse_ipv6(odp_packet_hdr_t *pkt_hdr,
*parseptr += extlen;
} while ((ipv6ext->next_hdr == ODPH_IPPROTO_HOPOPTS ||
ipv6ext->next_hdr == ODPH_IPPROTO_ROUTE) &&
- *offset < pkt_hdr->frame_len);
+ *offset < seg_len);
- if (*offset >= pkt_hdr->p.l3_offset +
+ if (*offset >= prs->l3_offset +
odp_be_to_cpu_16(ipv6->payload_len)) {
- pkt_hdr->p.error_flags.ip_err = 1;
+ prs->error_flags.ip_err = 1;
return 0;
}
if (ipv6ext->next_hdr == ODPH_IPPROTO_FRAG)
- pkt_hdr->p.input_flags.ipfrag = 1;
+ prs->input_flags.ipfrag = 1;
return ipv6ext->next_hdr;
}
if (odp_unlikely(ipv6->next_hdr == ODPH_IPPROTO_FRAG)) {
- pkt_hdr->p.input_flags.ipopt = 1;
- pkt_hdr->p.input_flags.ipfrag = 1;
+ prs->input_flags.ipopt = 1;
+ prs->input_flags.ipfrag = 1;
}
return ipv6->next_hdr;
@@ -1098,18 +1099,18 @@ static inline uint8_t parse_ipv6(odp_packet_hdr_t *pkt_hdr,
/**
* Parser helper function for TCP
*/
-static inline void parse_tcp(odp_packet_hdr_t *pkt_hdr,
+static inline void parse_tcp(packet_parser_t *prs,
const uint8_t **parseptr, uint32_t *offset)
{
const odph_tcphdr_t *tcp = (const odph_tcphdr_t *)*parseptr;
if (tcp->hl < sizeof(odph_tcphdr_t) / sizeof(uint32_t))
- pkt_hdr->p.error_flags.tcp_err = 1;
+ prs->error_flags.tcp_err = 1;
else if ((uint32_t)tcp->hl * 4 > sizeof(odph_tcphdr_t))
- pkt_hdr->p.input_flags.tcpopt = 1;
+ prs->input_flags.tcpopt = 1;
- pkt_hdr->p.l4_len = pkt_hdr->p.l3_len +
- pkt_hdr->p.l3_offset - pkt_hdr->p.l4_offset;
+ prs->l4_len = prs->l3_len +
+ prs->l3_offset - prs->l4_offset;
if (offset)
*offset += (uint32_t)tcp->hl * 4;
@@ -1119,19 +1120,19 @@ static inline void parse_tcp(odp_packet_hdr_t *pkt_hdr,
/**
* Parser helper function for UDP
*/
-static inline void parse_udp(odp_packet_hdr_t *pkt_hdr,
+static inline void parse_udp(packet_parser_t *prs,
const uint8_t **parseptr, uint32_t *offset)
{
const odph_udphdr_t *udp = (const odph_udphdr_t *)*parseptr;
uint32_t udplen = odp_be_to_cpu_16(udp->length);
if (udplen < sizeof(odph_udphdr_t) ||
- udplen > (pkt_hdr->p.l3_len +
- pkt_hdr->p.l4_offset - pkt_hdr->p.l3_offset)) {
- pkt_hdr->p.error_flags.udp_err = 1;
+ udplen > (prs->l3_len +
+ prs->l4_offset - prs->l3_offset)) {
+ prs->error_flags.udp_err = 1;
}
- pkt_hdr->p.l4_len = udplen;
+ prs->l4_len = udplen;
if (offset)
*offset += sizeof(odph_udphdr_t);
@@ -1141,43 +1142,49 @@ static inline void parse_udp(odp_packet_hdr_t *pkt_hdr,
/**
* Initialize L2 related parser flags and metadata
*/
-void packet_parse_l2(odp_packet_hdr_t *pkt_hdr)
+void packet_parse_l2(packet_parser_t *prs, uint32_t frame_len)
{
/* Packet alloc or reset have already init other offsets and flags */
/* We only support Ethernet for now */
- pkt_hdr->p.input_flags.eth = 1;
+ prs->input_flags.eth = 1;
/* Detect jumbo frames */
- if (pkt_hdr->frame_len > ODPH_ETH_LEN_MAX)
- pkt_hdr->p.input_flags.jumbo = 1;
+ if (frame_len > ODPH_ETH_LEN_MAX)
+ prs->input_flags.jumbo = 1;
/* Assume valid L2 header, no CRC/FCS check in SW */
- pkt_hdr->p.input_flags.l2 = 1;
+ prs->input_flags.l2 = 1;
- pkt_hdr->p.input_flags.parsed_l2 = 1;
+ prs->input_flags.parsed_l2 = 1;
}
-int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
+/**
+ * Parse common packet headers
+ *
+ * The function expects at least PACKET_PARSE_SEG_LEN bytes of data to be
+ * available from the ptr.
+ */
+int packet_parse_common(packet_parser_t *prs, const uint8_t *ptr,
+ uint32_t frame_len, uint32_t seg_len)
{
const odph_ethhdr_t *eth;
const odph_vlanhdr_t *vlan;
uint16_t ethtype;
- uint32_t offset, seglen;
+ uint32_t offset;
uint8_t ip_proto = 0;
const uint8_t *parseptr;
uint16_t macaddr0, macaddr2, macaddr4;
offset = sizeof(odph_ethhdr_t);
- if (packet_parse_l2_not_done(pkt_hdr))
- packet_parse_l2(pkt_hdr);
+ if (packet_parse_l2_not_done(prs))
+ packet_parse_l2(prs, frame_len);
- eth = ptr ? (const odph_ethhdr_t *)ptr :
- (odph_ethhdr_t *)packet_map(pkt_hdr, 0, &seglen);
+ eth = (const odph_ethhdr_t *)ptr;
/* Handle Ethernet broadcast/multicast addresses */
macaddr0 = odp_be_to_cpu_16(*((const uint16_t *)(const void *)eth));
- pkt_hdr->p.input_flags.eth_mcast = (macaddr0 & 0x0100) == 0x0100;
+ prs->input_flags.eth_mcast = (macaddr0 & 0x0100) == 0x0100;
if (macaddr0 == 0xffff) {
macaddr2 =
@@ -1186,10 +1193,10 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
macaddr4 =
odp_be_to_cpu_16(*((const uint16_t *)
(const void *)eth + 2));
- pkt_hdr->p.input_flags.eth_bcast =
+ prs->input_flags.eth_bcast =
(macaddr2 == 0xffff) && (macaddr4 == 0xffff);
} else {
- pkt_hdr->p.input_flags.eth_bcast = 0;
+ prs->input_flags.eth_bcast = 0;
}
/* Get Ethertype */
@@ -1198,9 +1205,9 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
/* Check for SNAP vs. DIX */
if (ethtype < ODPH_ETH_LEN_MAX) {
- pkt_hdr->p.input_flags.snap = 1;
- if (ethtype > pkt_hdr->frame_len - offset) {
- pkt_hdr->p.error_flags.snap_len = 1;
+ prs->input_flags.snap = 1;
+ if (ethtype > frame_len - offset) {
+ prs->error_flags.snap_len = 1;
goto parse_exit;
}
ethtype = odp_be_to_cpu_16(*((const uint16_t *)
@@ -1211,8 +1218,8 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
/* Parse the VLAN header(s), if present */
if (ethtype == ODPH_ETHTYPE_VLAN_OUTER) {
- pkt_hdr->p.input_flags.vlan_qinq = 1;
- pkt_hdr->p.input_flags.vlan = 1;
+ prs->input_flags.vlan_qinq = 1;
+ prs->input_flags.vlan = 1;
vlan = (const odph_vlanhdr_t *)parseptr;
ethtype = odp_be_to_cpu_16(vlan->type);
@@ -1221,7 +1228,7 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
}
if (ethtype == ODPH_ETHTYPE_VLAN) {
- pkt_hdr->p.input_flags.vlan = 1;
+ prs->input_flags.vlan = 1;
vlan = (const odph_vlanhdr_t *)parseptr;
ethtype = odp_be_to_cpu_16(vlan->type);
offset += sizeof(odph_vlanhdr_t);
@@ -1229,71 +1236,76 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
}
/* Set l3_offset+flag only for known ethtypes */
- pkt_hdr->p.input_flags.l3 = 1;
- pkt_hdr->p.l3_offset = offset;
+ prs->input_flags.l3 = 1;
+ prs->l3_offset = offset;
/* Parse Layer 3 headers */
switch (ethtype) {
case ODPH_ETHTYPE_IPV4:
- pkt_hdr->p.input_flags.ipv4 = 1;
- ip_proto = parse_ipv4(pkt_hdr, &parseptr, &offset);
+ prs->input_flags.ipv4 = 1;
+ ip_proto = parse_ipv4(prs, &parseptr, &offset, frame_len);
break;
case ODPH_ETHTYPE_IPV6:
- pkt_hdr->p.input_flags.ipv6 = 1;
- ip_proto = parse_ipv6(pkt_hdr, &parseptr, &offset);
+ prs->input_flags.ipv6 = 1;
+ ip_proto = parse_ipv6(prs, &parseptr, &offset, frame_len,
+ seg_len);
break;
case ODPH_ETHTYPE_ARP:
- pkt_hdr->p.input_flags.arp = 1;
+ prs->input_flags.arp = 1;
ip_proto = 255; /* Reserved invalid by IANA */
break;
default:
- pkt_hdr->p.input_flags.l3 = 0;
- pkt_hdr->p.l3_offset = ODP_PACKET_OFFSET_INVALID;
+ prs->input_flags.l3 = 0;
+ prs->l3_offset = ODP_PACKET_OFFSET_INVALID;
ip_proto = 255; /* Reserved invalid by IANA */
}
/* Set l4_offset+flag only for known ip_proto */
- pkt_hdr->p.input_flags.l4 = 1;
- pkt_hdr->p.l4_offset = offset;
+ prs->input_flags.l4 = 1;
+ prs->l4_offset = offset;
/* Parse Layer 4 headers */
switch (ip_proto) {
case ODPH_IPPROTO_ICMP:
- pkt_hdr->p.input_flags.icmp = 1;
+ prs->input_flags.icmp = 1;
break;
case ODPH_IPPROTO_TCP:
- pkt_hdr->p.input_flags.tcp = 1;
- parse_tcp(pkt_hdr, &parseptr, NULL);
+ if (odp_unlikely(offset + ODPH_TCPHDR_LEN > seg_len))
+ return -1;
+ prs->input_flags.tcp = 1;
+ parse_tcp(prs, &parseptr, NULL);
break;
case ODPH_IPPROTO_UDP:
- pkt_hdr->p.input_flags.udp = 1;
- parse_udp(pkt_hdr, &parseptr, NULL);
+ if (odp_unlikely(offset + ODPH_UDPHDR_LEN > seg_len))
+ return -1;
+ prs->input_flags.udp = 1;
+ parse_udp(prs, &parseptr, NULL);
break;
case ODPH_IPPROTO_AH:
- pkt_hdr->p.input_flags.ipsec = 1;
- pkt_hdr->p.input_flags.ipsec_ah = 1;
+ prs->input_flags.ipsec = 1;
+ prs->input_flags.ipsec_ah = 1;
break;
case ODPH_IPPROTO_ESP:
- pkt_hdr->p.input_flags.ipsec = 1;
- pkt_hdr->p.input_flags.ipsec_esp = 1;
+ prs->input_flags.ipsec = 1;
+ prs->input_flags.ipsec_esp = 1;
break;
default:
- pkt_hdr->p.input_flags.l4 = 0;
- pkt_hdr->p.l4_offset = ODP_PACKET_OFFSET_INVALID;
+ prs->input_flags.l4 = 0;
+ prs->l4_offset = ODP_PACKET_OFFSET_INVALID;
break;
}
parse_exit:
- pkt_hdr->p.input_flags.parsed_all = 1;
- return pkt_hdr->p.error_flags.all != 0;
+ prs->input_flags.parsed_all = 1;
+ return prs->error_flags.all != 0;
}
/**
@@ -1301,5 +1313,9 @@ parse_exit:
*/
int packet_parse_full(odp_packet_hdr_t *pkt_hdr)
{
- return _odp_parse_common(pkt_hdr, NULL);
+ uint32_t seg_len;
+ void *base = packet_map(pkt_hdr, 0, &seg_len);
+
+ return packet_parse_common(&pkt_hdr->p, base, pkt_hdr->frame_len,
+ seg_len);
}
diff --git a/platform/linux-generic/pktio/dpdk.c b/platform/linux-generic/pktio/dpdk.c
index e9d7aa4..245ff7b 100644
--- a/platform/linux-generic/pktio/dpdk.c
+++ b/platform/linux-generic/pktio/dpdk.c
@@ -724,7 +724,8 @@ static inline int mbuf_to_pkt(pktio_entry_t *pktio_entry,
if (pktio_cls_enabled(pktio_entry)) {
if (cls_classify_packet(pktio_entry,
(const uint8_t *)buf,
- pkt_len, &pool, &parsed_hdr))
+ pkt_len, pkt_len, &pool,
+ &parsed_hdr))
goto fail;
}
pkt = packet_alloc(pool, pkt_len, 1);
@@ -744,7 +745,7 @@ static inline int mbuf_to_pkt(pktio_entry_t *pktio_entry,
if (pktio_cls_enabled(pktio_entry))
copy_packet_cls_metadata(&parsed_hdr, pkt_hdr);
else
- packet_parse_l2(pkt_hdr);
+ packet_parse_l2(&pkt_hdr->p, pkt_len);
if (mbuf->ol_flags & PKT_RX_RSS_HASH)
odp_packet_flow_hash_set(pkt, mbuf->hash.rss);
diff --git a/platform/linux-generic/pktio/loop.c b/platform/linux-generic/pktio/loop.c
index a19c2dd..645521a 100644
--- a/platform/linux-generic/pktio/loop.c
+++ b/platform/linux-generic/pktio/loop.c
@@ -77,7 +77,11 @@ static int loopback_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
}
for (i = 0; i < nbr; i++) {
+ uint32_t pkt_len;
+
pkt = _odp_packet_from_buffer(odp_hdr_to_buf(hdr_tbl[i]));
+ pkt_len = odp_packet_len(pkt);
+
if (pktio_cls_enabled(pktio_entry)) {
odp_packet_t new_pkt;
@@ -87,7 +91,8 @@ static int loopback_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
pkt_addr = odp_packet_data(pkt);
ret = cls_classify_packet(pktio_entry, pkt_addr,
- odp_packet_len(pkt),
+ pkt_len,
+ odp_packet_seg_len(pkt),
&new_pool, &parsed_hdr);
if (ret) {
failed++;
@@ -113,11 +118,11 @@ static int loopback_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
if (pktio_cls_enabled(pktio_entry))
copy_packet_cls_metadata(&parsed_hdr, pkt_hdr);
else
- packet_parse_l2(pkt_hdr);
+ packet_parse_l2(&pkt_hdr->p, pkt_len);
packet_set_ts(pkt_hdr, ts);
- pktio_entry->s.stats.in_octets += odp_packet_len(pkt);
+ pktio_entry->s.stats.in_octets += pkt_len;
pkts[num_rx++] = pkt;
}
diff --git a/platform/linux-generic/pktio/netmap.c b/platform/linux-generic/pktio/netmap.c
index 6bfbe84..847250b 100644
--- a/platform/linux-generic/pktio/netmap.c
+++ b/platform/linux-generic/pktio/netmap.c
@@ -610,7 +610,7 @@ static inline int netmap_pkt_to_odp(pktio_entry_t *pktio_entry,
if (pktio_cls_enabled(pktio_entry)) {
if (cls_classify_packet(pktio_entry, (const uint8_t *)buf, len,
- &pool, &parsed_hdr))
+ len, &pool, &parsed_hdr))
return -1;
}
pkt = packet_alloc(pool, len, 1);
@@ -630,7 +630,7 @@ static inline int netmap_pkt_to_odp(pktio_entry_t *pktio_entry,
if (pktio_cls_enabled(pktio_entry))
copy_packet_cls_metadata(&parsed_hdr, pkt_hdr);
else
- packet_parse_l2(pkt_hdr);
+ packet_parse_l2(&pkt_hdr->p, len);
packet_set_ts(pkt_hdr, ts);
diff --git a/platform/linux-generic/pktio/pcap.c b/platform/linux-generic/pktio/pcap.c
index c967e70..2fb2a5b 100644
--- a/platform/linux-generic/pktio/pcap.c
+++ b/platform/linux-generic/pktio/pcap.c
@@ -262,7 +262,7 @@ static int pcapif_recv_pkt(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
break;
}
- packet_parse_l2(pkt_hdr);
+ packet_parse_l2(&pkt_hdr->p, pkt_len);
pktio_entry->s.stats.in_octets += pkt_hdr->frame_len;
packet_set_ts(pkt_hdr, ts);
diff --git a/platform/linux-generic/pktio/socket.c b/platform/linux-generic/pktio/socket.c
index b116145..8f86dda 100644
--- a/platform/linux-generic/pktio/socket.c
+++ b/platform/linux-generic/pktio/socket.c
@@ -664,7 +664,7 @@ static int sock_mmsg_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
continue;
if (cls_classify_packet(pktio_entry, base, pkt_len,
- &pool, &parsed_hdr))
+ pkt_len, &pool, &parsed_hdr))
continue;
pkt = packet_alloc(pool, pkt_len, 1);
if (pkt == ODP_PACKET_INVALID)
@@ -724,7 +724,7 @@ static int sock_mmsg_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
odp_packet_pull_tail(pkt_table[i],
odp_packet_len(pkt_table[i]) -
msgvec[i].msg_len);
- packet_parse_l2(pkt_hdr);
+ packet_parse_l2(&pkt_hdr->p, pkt_hdr->frame_len);
packet_set_ts(pkt_hdr, ts);
pkt_hdr->input = pktio_entry->s.handle;
diff --git a/platform/linux-generic/pktio/socket_mmap.c b/platform/linux-generic/pktio/socket_mmap.c
index 30c44e9..420cd26 100644
--- a/platform/linux-generic/pktio/socket_mmap.c
+++ b/platform/linux-generic/pktio/socket_mmap.c
@@ -199,7 +199,7 @@ static inline unsigned pkt_mmap_v2_rx(pktio_entry_t *pktio_entry,
if (pktio_cls_enabled(pktio_entry)) {
if (cls_classify_packet(pktio_entry, pkt_buf, pkt_len,
- &pool, &parsed_hdr)) {
+ pkt_len, &pool, &parsed_hdr)) {
mmap_rx_user_ready(ppd.raw); /* drop */
frame_num = next_frame_num;
continue;
@@ -226,7 +226,7 @@ static inline unsigned pkt_mmap_v2_rx(pktio_entry_t *pktio_entry,
if (pktio_cls_enabled(pktio_entry))
copy_packet_cls_metadata(&parsed_hdr, hdr);
else
- packet_parse_l2(hdr);
+ packet_parse_l2(&hdr->p, pkt_len);
packet_set_ts(hdr, ts);
diff --git a/platform/linux-generic/pktio/tap.c b/platform/linux-generic/pktio/tap.c
index 975ad25..8ba7bed 100644
--- a/platform/linux-generic/pktio/tap.c
+++ b/platform/linux-generic/pktio/tap.c
@@ -197,7 +197,7 @@ static odp_packet_t pack_odp_pkt(pktio_entry_t *pktio_entry, const void *data,
}
pkt_hdr = odp_packet_hdr(pkt);
- packet_parse_l2(pkt_hdr);
+ packet_parse_l2(&pkt_hdr->p, len);
packet_set_ts(pkt_hdr, ts);
pkt_hdr->input = pktio_entry->s.handle;
commit aa7a1822660eaeecd6f69c525abdc4a21d428716
Author: Matias Elo <matias.elo(a)nokia.com>
Date: Thu Jun 16 16:07:29 2016 +0300
linux-gen: packet: add packet parser structure
Collect odp_packet_hdr_t members set by the packet parser
inside a common structure packet_parser_t.
Signed-off-by: Matias Elo <matias.elo(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_classification_inlines.h b/platform/linux-generic/include/odp_classification_inlines.h
index 08300f5..611d706 100644
--- a/platform/linux-generic/include/odp_classification_inlines.h
+++ b/platform/linux-generic/include/odp_classification_inlines.h
@@ -47,9 +47,9 @@ static inline int verify_pmr_ip_proto(const uint8_t *pkt_addr,
{
const odph_ipv4hdr_t *ip;
uint8_t proto;
- if (!pkt_hdr->input_flags.ipv4)
+ if (!pkt_hdr->p.input_flags.ipv4)
return 0;
- ip = (const odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
+ ip = (const odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->p.l3_offset);
proto = ip->proto;
if (term_value->match.value == (proto & term_value->match.mask))
return 1;
@@ -63,9 +63,9 @@ static inline int verify_pmr_ipv4_saddr(const uint8_t *pkt_addr,
{
const odph_ipv4hdr_t *ip;
uint32_t ipaddr;
- if (!pkt_hdr->input_flags.ipv4)
+ if (!pkt_hdr->p.input_flags.ipv4)
return 0;
- ip = (const odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
+ ip = (const odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->p.l3_offset);
ipaddr = odp_be_to_cpu_32(ip->src_addr);
if (term_value->match.value == (ipaddr & term_value->match.mask))
return 1;
@@ -79,9 +79,9 @@ static inline int verify_pmr_ipv4_daddr(const uint8_t *pkt_addr,
{
const odph_ipv4hdr_t *ip;
uint32_t ipaddr;
- if (!pkt_hdr->input_flags.ipv4)
+ if (!pkt_hdr->p.input_flags.ipv4)
return 0;
- ip = (const odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
+ ip = (const odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->p.l3_offset);
ipaddr = odp_be_to_cpu_32(ip->dst_addr);
if (term_value->match.value == (ipaddr & term_value->match.mask))
return 1;
@@ -95,9 +95,9 @@ static inline int verify_pmr_tcp_sport(const uint8_t *pkt_addr,
{
uint16_t sport;
const odph_tcphdr_t *tcp;
- if (!pkt_hdr->input_flags.tcp)
+ if (!pkt_hdr->p.input_flags.tcp)
return 0;
- tcp = (const odph_tcphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
+ tcp = (const odph_tcphdr_t *)(pkt_addr + pkt_hdr->p.l4_offset);
sport = odp_be_to_cpu_16(tcp->src_port);
if (term_value->match.value == (sport & term_value->match.mask))
return 1;
@@ -111,9 +111,9 @@ static inline int verify_pmr_tcp_dport(const uint8_t *pkt_addr,
{
uint16_t dport;
const odph_tcphdr_t *tcp;
- if (!pkt_hdr->input_flags.tcp)
+ if (!pkt_hdr->p.input_flags.tcp)
return 0;
- tcp = (const odph_tcphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
+ tcp = (const odph_tcphdr_t *)(pkt_addr + pkt_hdr->p.l4_offset);
dport = odp_be_to_cpu_16(tcp->dst_port);
if (term_value->match.value == (dport & term_value->match.mask))
return 1;
@@ -127,9 +127,9 @@ static inline int verify_pmr_udp_dport(const uint8_t *pkt_addr,
{
uint16_t dport;
const odph_udphdr_t *udp;
- if (!pkt_hdr->input_flags.udp)
+ if (!pkt_hdr->p.input_flags.udp)
return 0;
- udp = (const odph_udphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
+ udp = (const odph_udphdr_t *)(pkt_addr + pkt_hdr->p.l4_offset);
dport = odp_be_to_cpu_16(udp->dst_port);
if (term_value->match.value == (dport & term_value->match.mask))
return 1;
@@ -144,9 +144,9 @@ static inline int verify_pmr_udp_sport(const uint8_t *pkt_addr,
uint16_t sport;
const odph_udphdr_t *udp;
- if (!pkt_hdr->input_flags.udp)
+ if (!pkt_hdr->p.input_flags.udp)
return 0;
- udp = (const odph_udphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
+ udp = (const odph_udphdr_t *)(pkt_addr + pkt_hdr->p.l4_offset);
sport = odp_be_to_cpu_16(udp->src_port);
if (term_value->match.value == (sport & term_value->match.mask))
return 1;
@@ -165,7 +165,7 @@ static inline int verify_pmr_dmac(const uint8_t *pkt_addr,
if (!packet_hdr_has_eth(pkt_hdr))
return 0;
- eth = (const odph_ethhdr_t *)(pkt_addr + pkt_hdr->l2_offset);
+ eth = (const odph_ethhdr_t *)(pkt_addr + pkt_hdr->p.l2_offset);
memcpy(&dmac_be, eth->dst.addr, ODPH_ETHADDR_LEN);
dmac = odp_be_to_cpu_64(dmac_be);
/* since we are converting a 48 bit ethernet address from BE to cpu
@@ -217,13 +217,13 @@ static inline int verify_pmr_ipsec_spi(const uint8_t *pkt_addr,
{
uint32_t spi;
- pkt_addr += pkt_hdr->l4_offset;
+ pkt_addr += pkt_hdr->p.l4_offset;
- if (pkt_hdr->input_flags.ipsec_ah) {
+ if (pkt_hdr->p.input_flags.ipsec_ah) {
const odph_ahhdr_t *ahhdr = (const odph_ahhdr_t *)pkt_addr;
spi = odp_be_to_cpu_32(ahhdr->spi);
- } else if (pkt_hdr->input_flags.ipsec_esp) {
+ } else if (pkt_hdr->p.input_flags.ipsec_esp) {
const odph_esphdr_t *esphdr = (const odph_esphdr_t *)pkt_addr;
spi = odp_be_to_cpu_32(esphdr->spi);
diff --git a/platform/linux-generic/include/odp_packet_internal.h b/platform/linux-generic/include/odp_packet_internal.h
index a84a6f8..71a2ab1 100644
--- a/platform/linux-generic/include/odp_packet_internal.h
+++ b/platform/linux-generic/include/odp_packet_internal.h
@@ -128,6 +128,23 @@ ODP_STATIC_ASSERT(sizeof(output_flags_t) == sizeof(uint32_t),
"OUTPUT_FLAGS_SIZE_ERROR");
/**
+ * Packet parser metadata
+ */
+typedef struct {
+ input_flags_t input_flags;
+ error_flags_t error_flags;
+ output_flags_t output_flags;
+
+ uint32_t l2_offset; /**< offset to L2 hdr, e.g. Eth */
+ uint32_t l3_offset; /**< offset to L3 hdr, e.g. IPv4, IPv6 */
+ uint32_t l4_offset; /**< offset to L4 hdr (TCP, UDP, SCTP, also ICMP) */
+
+ uint32_t l3_len; /**< Layer 3 length */
+ uint32_t l4_len; /**< Layer 4 length */
+
+} packet_parser_t;
+
+/**
* Internal Packet header
*
* To optimize fast path performance this struct is not initialized to zero in
@@ -139,13 +156,7 @@ typedef struct {
odp_buffer_hdr_t buf_hdr;
/* Following members are initialized by packet_init() */
- input_flags_t input_flags;
- error_flags_t error_flags;
- output_flags_t output_flags;
-
- uint32_t l2_offset; /**< offset to L2 hdr, e.g. Eth */
- uint32_t l3_offset; /**< offset to L3 hdr, e.g. IPv4, IPv6 */
- uint32_t l4_offset; /**< offset to L4 hdr (TCP, UDP, SCTP, also ICMP) */
+ packet_parser_t p;
uint32_t frame_len;
uint32_t headroom;
@@ -154,9 +165,6 @@ typedef struct {
odp_pktio_t input;
/* Members below are not initialized by packet_init() */
- uint32_t l3_len; /**< Layer 3 length */
- uint32_t l4_len; /**< Layer 4 length */
-
odp_queue_t dst_queue; /**< Classifier destination queue */
uint32_t flow_hash; /**< Flow hash value */
@@ -180,18 +188,14 @@ static inline odp_packet_hdr_t *odp_packet_hdr(odp_packet_t pkt)
static inline void copy_packet_parser_metadata(odp_packet_hdr_t *src_hdr,
odp_packet_hdr_t *dst_hdr)
{
- dst_hdr->input_flags = src_hdr->input_flags;
- dst_hdr->error_flags = src_hdr->error_flags;
- dst_hdr->output_flags = src_hdr->output_flags;
-
- dst_hdr->l2_offset = src_hdr->l2_offset;
- dst_hdr->l3_offset = src_hdr->l3_offset;
- dst_hdr->l4_offset = src_hdr->l4_offset;
-
- dst_hdr->l3_len = src_hdr->l3_len;
- dst_hdr->l4_len = src_hdr->l4_len;
+ dst_hdr->p = src_hdr->p;
+}
- dst_hdr->dst_queue = src_hdr->dst_queue;
+static inline void copy_packet_cls_metadata(odp_packet_hdr_t *src_hdr,
+ odp_packet_hdr_t *dst_hdr)
+{
+ dst_hdr->p = src_hdr->p;
+ dst_hdr->dst_queue = src_hdr->dst_queue;
}
static inline void *packet_map(odp_packet_hdr_t *pkt_hdr,
@@ -285,12 +289,12 @@ static inline void packet_set_len(odp_packet_hdr_t *pkt_hdr, uint32_t len)
static inline int packet_parse_l2_not_done(odp_packet_hdr_t *pkt_hdr)
{
- return !pkt_hdr->input_flags.parsed_l2;
+ return !pkt_hdr->p.input_flags.parsed_l2;
}
static inline int packet_parse_not_complete(odp_packet_hdr_t *pkt_hdr)
{
- return !pkt_hdr->input_flags.parsed_all;
+ return !pkt_hdr->p.input_flags.parsed_all;
}
/* Forward declarations */
@@ -315,24 +319,24 @@ odp_packet_t _odp_packet_from_buffer(odp_buffer_t buf);
static inline int packet_hdr_has_l2(odp_packet_hdr_t *pkt_hdr)
{
- return pkt_hdr->input_flags.l2;
+ return pkt_hdr->p.input_flags.l2;
}
static inline void packet_hdr_has_l2_set(odp_packet_hdr_t *pkt_hdr, int val)
{
- pkt_hdr->input_flags.l2 = val;
+ pkt_hdr->p.input_flags.l2 = val;
}
static inline int packet_hdr_has_eth(odp_packet_hdr_t *pkt_hdr)
{
- return pkt_hdr->input_flags.eth;
+ return pkt_hdr->p.input_flags.eth;
}
static inline void packet_set_ts(odp_packet_hdr_t *pkt_hdr, odp_time_t *ts)
{
if (ts != NULL) {
pkt_hdr->timestamp = *ts;
- pkt_hdr->input_flags.timestamp = 1;
+ pkt_hdr->p.input_flags.timestamp = 1;
}
}
diff --git a/platform/linux-generic/odp_classification.c b/platform/linux-generic/odp_classification.c
index d2cc081..752348c 100644
--- a/platform/linux-generic/odp_classification.c
+++ b/platform/linux-generic/odp_classification.c
@@ -776,7 +776,7 @@ static inline cos_t *cls_select_cos(pktio_entry_t *entry,
packet_parse_full(pkt_hdr);
/* Return error cos for error packet */
- if (pkt_hdr->error_flags.all)
+ if (pkt_hdr->p.error_flags.all)
return cls->error_cos;
/* Calls all the PMRs attached at the PKTIO level*/
for (i = 0; i < odp_atomic_load_u32(&default_cos->s.num_rule); i++) {
@@ -827,7 +827,7 @@ int cls_classify_packet(pktio_entry_t *entry, const uint8_t *base, uint16_t len,
return -EFAULT;
*pool = cos->s.pool->s.pool_hdl;
- pkt_hdr->input_flags.dst_queue = 1;
+ pkt_hdr->p.input_flags.dst_queue = 1;
pkt_hdr->dst_queue = cos->s.queue->s.handle;
return 0;
@@ -841,12 +841,12 @@ cos_t *match_qos_l3_cos(pmr_l3_cos_t *l3_cos, const uint8_t *pkt_addr,
const odph_ipv4hdr_t *ipv4;
const odph_ipv6hdr_t *ipv6;
- if (hdr->input_flags.l3 && hdr->input_flags.ipv4) {
- ipv4 = (const odph_ipv4hdr_t *)(pkt_addr + hdr->l3_offset);
+ if (hdr->p.input_flags.l3 && hdr->p.input_flags.ipv4) {
+ ipv4 = (const odph_ipv4hdr_t *)(pkt_addr + hdr->p.l3_offset);
dscp = ODPH_IPV4HDR_DSCP(ipv4->tos);
cos = l3_cos->cos[dscp];
- } else if (hdr->input_flags.l3 && hdr->input_flags.ipv6) {
- ipv6 = (const odph_ipv6hdr_t *)(pkt_addr + hdr->l3_offset);
+ } else if (hdr->p.input_flags.l3 && hdr->p.input_flags.ipv6) {
+ ipv6 = (const odph_ipv6hdr_t *)(pkt_addr + hdr->p.l3_offset);
dscp = ODPH_IPV6HDR_DSCP(ipv6->ver_tc_flow);
cos = l3_cos->cos[dscp];
}
@@ -862,9 +862,9 @@ cos_t *match_qos_l2_cos(pmr_l2_cos_t *l2_cos, const uint8_t *pkt_addr,
const odph_vlanhdr_t *vlan;
uint16_t qos;
- if (packet_hdr_has_l2(hdr) && hdr->input_flags.vlan &&
+ if (packet_hdr_has_l2(hdr) && hdr->p.input_flags.vlan &&
packet_hdr_has_eth(hdr)) {
- eth = (const odph_ethhdr_t *)(pkt_addr + hdr->l2_offset);
+ eth = (const odph_ethhdr_t *)(pkt_addr + hdr->p.l2_offset);
vlan = (const odph_vlanhdr_t *)(eth + 1);
qos = odp_be_to_cpu_16(vlan->tci);
qos = ((qos >> 13) & 0x07);
diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c
index 2868736..991a648 100644
--- a/platform/linux-generic/odp_packet.c
+++ b/platform/linux-generic/odp_packet.c
@@ -28,19 +28,19 @@
static inline void packet_parse_disable(odp_packet_hdr_t *pkt_hdr)
{
- pkt_hdr->input_flags.parsed_l2 = 1;
- pkt_hdr->input_flags.parsed_all = 1;
+ pkt_hdr->p.input_flags.parsed_l2 = 1;
+ pkt_hdr->p.input_flags.parsed_all = 1;
}
void packet_parse_reset(odp_packet_hdr_t *pkt_hdr)
{
/* Reset parser metadata before new parse */
- pkt_hdr->error_flags.all = 0;
- pkt_hdr->input_flags.all = 0;
- pkt_hdr->output_flags.all = 0;
- pkt_hdr->l2_offset = 0;
- pkt_hdr->l3_offset = ODP_PACKET_OFFSET_INVALID;
- pkt_hdr->l4_offset = ODP_PACKET_OFFSET_INVALID;
+ pkt_hdr->p.error_flags.all = 0;
+ pkt_hdr->p.input_flags.all = 0;
+ pkt_hdr->p.output_flags.all = 0;
+ pkt_hdr->p.l2_offset = 0;
+ pkt_hdr->p.l3_offset = ODP_PACKET_OFFSET_INVALID;
+ pkt_hdr->p.l4_offset = ODP_PACKET_OFFSET_INVALID;
}
/**
@@ -49,13 +49,13 @@ void packet_parse_reset(odp_packet_hdr_t *pkt_hdr)
static void packet_init(pool_entry_t *pool, odp_packet_hdr_t *pkt_hdr,
size_t size, int parse)
{
- pkt_hdr->input_flags.all = 0;
- pkt_hdr->output_flags.all = 0;
- pkt_hdr->error_flags.all = 0;
+ pkt_hdr->p.input_flags.all = 0;
+ pkt_hdr->p.output_flags.all = 0;
+ pkt_hdr->p.error_flags.all = 0;
- pkt_hdr->l2_offset = 0;
- pkt_hdr->l3_offset = ODP_PACKET_OFFSET_INVALID;
- pkt_hdr->l4_offset = ODP_PACKET_OFFSET_INVALID;
+ pkt_hdr->p.l2_offset = 0;
+ pkt_hdr->p.l3_offset = ODP_PACKET_OFFSET_INVALID;
+ pkt_hdr->p.l4_offset = ODP_PACKET_OFFSET_INVALID;
/* Disable lazy parsing on user allocated packets */
if (!parse)
@@ -431,7 +431,7 @@ void *odp_packet_l2_ptr(odp_packet_t pkt, uint32_t *len)
if (!packet_hdr_has_l2(pkt_hdr))
return NULL;
- return packet_map(pkt_hdr, pkt_hdr->l2_offset, len);
+ return packet_map(pkt_hdr, pkt_hdr->p.l2_offset, len);
}
uint32_t odp_packet_l2_offset(odp_packet_t pkt)
@@ -440,7 +440,7 @@ uint32_t odp_packet_l2_offset(odp_packet_t pkt)
if (!packet_hdr_has_l2(pkt_hdr))
return ODP_PACKET_OFFSET_INVALID;
- return pkt_hdr->l2_offset;
+ return pkt_hdr->p.l2_offset;
}
int odp_packet_l2_offset_set(odp_packet_t pkt, uint32_t offset)
@@ -451,7 +451,7 @@ int odp_packet_l2_offset_set(odp_packet_t pkt, uint32_t offset)
return -1;
packet_hdr_has_l2_set(pkt_hdr, 1);
- pkt_hdr->l2_offset = offset;
+ pkt_hdr->p.l2_offset = offset;
return 0;
}
@@ -461,7 +461,7 @@ void *odp_packet_l3_ptr(odp_packet_t pkt, uint32_t *len)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- return packet_map(pkt_hdr, pkt_hdr->l3_offset, len);
+ return packet_map(pkt_hdr, pkt_hdr->p.l3_offset, len);
}
uint32_t odp_packet_l3_offset(odp_packet_t pkt)
@@ -470,7 +470,7 @@ uint32_t odp_packet_l3_offset(odp_packet_t pkt)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- return pkt_hdr->l3_offset;
+ return pkt_hdr->p.l3_offset;
}
int odp_packet_l3_offset_set(odp_packet_t pkt, uint32_t offset)
@@ -482,7 +482,7 @@ int odp_packet_l3_offset_set(odp_packet_t pkt, uint32_t offset)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- pkt_hdr->l3_offset = offset;
+ pkt_hdr->p.l3_offset = offset;
return 0;
}
@@ -492,7 +492,7 @@ void *odp_packet_l4_ptr(odp_packet_t pkt, uint32_t *len)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- return packet_map(pkt_hdr, pkt_hdr->l4_offset, len);
+ return packet_map(pkt_hdr, pkt_hdr->p.l4_offset, len);
}
uint32_t odp_packet_l4_offset(odp_packet_t pkt)
@@ -501,7 +501,7 @@ uint32_t odp_packet_l4_offset(odp_packet_t pkt)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- return pkt_hdr->l4_offset;
+ return pkt_hdr->p.l4_offset;
}
int odp_packet_l4_offset_set(odp_packet_t pkt, uint32_t offset)
@@ -513,7 +513,7 @@ int odp_packet_l4_offset_set(odp_packet_t pkt, uint32_t offset)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- pkt_hdr->l4_offset = offset;
+ pkt_hdr->p.l4_offset = offset;
return 0;
}
@@ -529,7 +529,7 @@ void odp_packet_flow_hash_set(odp_packet_t pkt, uint32_t flow_hash)
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
pkt_hdr->flow_hash = flow_hash;
- pkt_hdr->input_flags.flow_hash = 1;
+ pkt_hdr->p.input_flags.flow_hash = 1;
}
odp_time_t odp_packet_ts(odp_packet_t pkt)
@@ -544,7 +544,7 @@ void odp_packet_ts_set(odp_packet_t pkt, odp_time_t timestamp)
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
pkt_hdr->timestamp = timestamp;
- pkt_hdr->input_flags.timestamp = 1;
+ pkt_hdr->p.input_flags.timestamp = 1;
}
int odp_packet_is_segmented(odp_packet_t pkt)
@@ -929,19 +929,19 @@ void odp_packet_print(odp_packet_t 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%" PRIx64 "\n", hdr->input_flags.all);
- len += snprintf(&str[len], n - len,
- " error_flags 0x%" PRIx32 "\n", hdr->error_flags.all);
+ len += snprintf(&str[len], n - len, " input_flags 0x%" PRIx64 "\n",
+ hdr->p.input_flags.all);
+ len += snprintf(&str[len], n - len, " error_flags 0x%" PRIx32 "\n",
+ hdr->p.error_flags.all);
len += snprintf(&str[len], n - len,
" output_flags 0x%" PRIx32 "\n",
- hdr->output_flags.all);
+ hdr->p.output_flags.all);
len += snprintf(&str[len], n - len,
- " l2_offset %" PRIu32 "\n", hdr->l2_offset);
+ " l2_offset %" PRIu32 "\n", hdr->p.l2_offset);
len += snprintf(&str[len], n - len,
- " l3_offset %" PRIu32 "\n", hdr->l3_offset);
+ " l3_offset %" PRIu32 "\n", hdr->p.l3_offset);
len += snprintf(&str[len], n - len,
- " l4_offset %" PRIu32 "\n", hdr->l4_offset);
+ " l4_offset %" PRIu32 "\n", hdr->p.l4_offset);
len += snprintf(&str[len], n - len,
" frame_len %" PRIu32 "\n", hdr->frame_len);
len += snprintf(&str[len], n - len,
@@ -972,6 +972,7 @@ void _odp_packet_copy_md_to_packet(odp_packet_t srcpkt, odp_packet_t dstpkt)
odp_packet_hdr_t *dsthdr = odp_packet_hdr(dstpkt);
dsthdr->input = srchdr->input;
+ dsthdr->dst_queue = srchdr->dst_queue;
dsthdr->buf_hdr.buf_u64 = srchdr->buf_hdr.buf_u64;
if (dsthdr->buf_hdr.uarea_addr != NULL &&
srchdr->buf_hdr.uarea_addr != NULL)
@@ -1000,12 +1001,12 @@ static inline uint8_t parse_ipv4(odp_packet_hdr_t *pkt_hdr,
uint16_t frag_offset;
uint32_t dstaddr = odp_be_to_cpu_32(ipv4->dst_addr);
- pkt_hdr->l3_len = odp_be_to_cpu_16(ipv4->tot_len);
+ pkt_hdr->p.l3_len = odp_be_to_cpu_16(ipv4->tot_len);
if (odp_unlikely(ihl < ODPH_IPV4HDR_IHL_MIN) ||
odp_unlikely(ver != 4) ||
- (pkt_hdr->l3_len > pkt_hdr->frame_len - *offset)) {
- pkt_hdr->error_flags.ip_err = 1;
+ (pkt_hdr->p.l3_len > pkt_hdr->frame_len - *offset)) {
+ pkt_hdr->p.error_flags.ip_err = 1;
return 0;
}
@@ -1013,7 +1014,7 @@ static inline uint8_t parse_ipv4(odp_packet_hdr_t *pkt_hdr,
*parseptr += ihl * 4;
if (odp_unlikely(ihl > ODPH_IPV4HDR_IHL_MIN))
- pkt_hdr->input_flags.ipopt = 1;
+ pkt_hdr->p.input_flags.ipopt = 1;
/* A packet is a fragment if:
* "more fragments" flag is set (all fragments except the last)
@@ -1022,11 +1023,11 @@ static inline uint8_t parse_ipv4(odp_packet_hdr_t *pkt_hdr,
*/
frag_offset = odp_be_to_cpu_16(ipv4->frag_offset);
if (odp_unlikely(ODPH_IPV4HDR_IS_FRAGMENT(frag_offset)))
- pkt_hdr->input_flags.ipfrag = 1;
+ pkt_hdr->p.input_flags.ipfrag = 1;
/* Handle IPv4 broadcast / multicast */
- pkt_hdr->input_flags.ip_bcast = (dstaddr == 0xffffffff);
- pkt_hdr->input_flags.ip_mcast = (dstaddr >> 28) == 0xd;
+ pkt_hdr->p.input_flags.ip_bcast = (dstaddr == 0xffffffff);
+ pkt_hdr->p.input_flags.ip_mcast = (dstaddr >> 28) == 0xd;
return ipv4->proto;
}
@@ -1041,19 +1042,19 @@ static inline uint8_t parse_ipv6(odp_packet_hdr_t *pkt_hdr,
const odph_ipv6hdr_ext_t *ipv6ext;
uint32_t dstaddr0 = odp_be_to_cpu_32(ipv6->dst_addr[0]);
- pkt_hdr->l3_len = odp_be_to_cpu_16(ipv6->payload_len) +
+ pkt_hdr->p.l3_len = odp_be_to_cpu_16(ipv6->payload_len) +
ODPH_IPV6HDR_LEN;
/* Basic sanity checks on IPv6 header */
if ((odp_be_to_cpu_32(ipv6->ver_tc_flow) >> 28) != 6 ||
- pkt_hdr->l3_len > pkt_hdr->frame_len - *offset) {
- pkt_hdr->error_flags.ip_err = 1;
+ pkt_hdr->p.l3_len > pkt_hdr->frame_len - *offset) {
+ pkt_hdr->p.error_flags.ip_err = 1;
return 0;
}
/* IPv6 broadcast / multicast flags */
- pkt_hdr->input_flags.ip_mcast = (dstaddr0 & 0xff000000) == 0xff000000;
- pkt_hdr->input_flags.ip_bcast = 0;
+ pkt_hdr->p.input_flags.ip_mcast = (dstaddr0 & 0xff000000) == 0xff000000;
+ pkt_hdr->p.input_flags.ip_bcast = 0;
/* Skip past IPv6 header */
*offset += sizeof(odph_ipv6hdr_t);
@@ -1062,7 +1063,7 @@ static inline uint8_t parse_ipv6(odp_packet_hdr_t *pkt_hdr,
/* Skip past any IPv6 extension headers */
if (ipv6->next_hdr == ODPH_IPPROTO_HOPOPTS ||
ipv6->next_hdr == ODPH_IPPROTO_ROUTE) {
- pkt_hdr->input_flags.ipopt = 1;
+ pkt_hdr->p.input_flags.ipopt = 1;
do {
ipv6ext = (const odph_ipv6hdr_ext_t *)*parseptr;
@@ -1074,21 +1075,21 @@ static inline uint8_t parse_ipv6(odp_packet_hdr_t *pkt_hdr,
ipv6ext->next_hdr == ODPH_IPPROTO_ROUTE) &&
*offset < pkt_hdr->frame_len);
- if (*offset >= pkt_hdr->l3_offset +
+ if (*offset >= pkt_hdr->p.l3_offset +
odp_be_to_cpu_16(ipv6->payload_len)) {
- pkt_hdr->error_flags.ip_err = 1;
+ pkt_hdr->p.error_flags.ip_err = 1;
return 0;
}
if (ipv6ext->next_hdr == ODPH_IPPROTO_FRAG)
- pkt_hdr->input_flags.ipfrag = 1;
+ pkt_hdr->p.input_flags.ipfrag = 1;
return ipv6ext->next_hdr;
}
if (odp_unlikely(ipv6->next_hdr == ODPH_IPPROTO_FRAG)) {
- pkt_hdr->input_flags.ipopt = 1;
- pkt_hdr->input_flags.ipfrag = 1;
+ pkt_hdr->p.input_flags.ipopt = 1;
+ pkt_hdr->p.input_flags.ipfrag = 1;
}
return ipv6->next_hdr;
@@ -1103,12 +1104,12 @@ static inline void parse_tcp(odp_packet_hdr_t *pkt_hdr,
const odph_tcphdr_t *tcp = (const odph_tcphdr_t *)*parseptr;
if (tcp->hl < sizeof(odph_tcphdr_t) / sizeof(uint32_t))
- pkt_hdr->error_flags.tcp_err = 1;
+ pkt_hdr->p.error_flags.tcp_err = 1;
else if ((uint32_t)tcp->hl * 4 > sizeof(odph_tcphdr_t))
- pkt_hdr->input_flags.tcpopt = 1;
+ pkt_hdr->p.input_flags.tcpopt = 1;
- pkt_hdr->l4_len = pkt_hdr->l3_len +
- pkt_hdr->l3_offset - pkt_hdr->l4_offset;
+ pkt_hdr->p.l4_len = pkt_hdr->p.l3_len +
+ pkt_hdr->p.l3_offset - pkt_hdr->p.l4_offset;
if (offset)
*offset += (uint32_t)tcp->hl * 4;
@@ -1125,12 +1126,12 @@ static inline void parse_udp(odp_packet_hdr_t *pkt_hdr,
uint32_t udplen = odp_be_to_cpu_16(udp->length);
if (udplen < sizeof(odph_udphdr_t) ||
- udplen > (pkt_hdr->l3_len +
- pkt_hdr->l4_offset - pkt_hdr->l3_offset)) {
- pkt_hdr->error_flags.udp_err = 1;
+ udplen > (pkt_hdr->p.l3_len +
+ pkt_hdr->p.l4_offset - pkt_hdr->p.l3_offset)) {
+ pkt_hdr->p.error_flags.udp_err = 1;
}
- pkt_hdr->l4_len = udplen;
+ pkt_hdr->p.l4_len = udplen;
if (offset)
*offset += sizeof(odph_udphdr_t);
@@ -1145,16 +1146,16 @@ void packet_parse_l2(odp_packet_hdr_t *pkt_hdr)
/* Packet alloc or reset have already init other offsets and flags */
/* We only support Ethernet for now */
- pkt_hdr->input_flags.eth = 1;
+ pkt_hdr->p.input_flags.eth = 1;
/* Detect jumbo frames */
if (pkt_hdr->frame_len > ODPH_ETH_LEN_MAX)
- pkt_hdr->input_flags.jumbo = 1;
+ pkt_hdr->p.input_flags.jumbo = 1;
/* Assume valid L2 header, no CRC/FCS check in SW */
- pkt_hdr->input_flags.l2 = 1;
+ pkt_hdr->p.input_flags.l2 = 1;
- pkt_hdr->input_flags.parsed_l2 = 1;
+ pkt_hdr->p.input_flags.parsed_l2 = 1;
}
int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
@@ -1176,7 +1177,7 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
/* Handle Ethernet broadcast/multicast addresses */
macaddr0 = odp_be_to_cpu_16(*((const uint16_t *)(const void *)eth));
- pkt_hdr->input_flags.eth_mcast = (macaddr0 & 0x0100) == 0x0100;
+ pkt_hdr->p.input_flags.eth_mcast = (macaddr0 & 0x0100) == 0x0100;
if (macaddr0 == 0xffff) {
macaddr2 =
@@ -1185,10 +1186,10 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
macaddr4 =
odp_be_to_cpu_16(*((const uint16_t *)
(const void *)eth + 2));
- pkt_hdr->input_flags.eth_bcast =
+ pkt_hdr->p.input_flags.eth_bcast =
(macaddr2 == 0xffff) && (macaddr4 == 0xffff);
} else {
- pkt_hdr->input_flags.eth_bcast = 0;
+ pkt_hdr->p.input_flags.eth_bcast = 0;
}
/* Get Ethertype */
@@ -1197,9 +1198,9 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
/* Check for SNAP vs. DIX */
if (ethtype < ODPH_ETH_LEN_MAX) {
- pkt_hdr->input_flags.snap = 1;
+ pkt_hdr->p.input_flags.snap = 1;
if (ethtype > pkt_hdr->frame_len - offset) {
- pkt_hdr->error_flags.snap_len = 1;
+ pkt_hdr->p.error_flags.snap_len = 1;
goto parse_exit;
}
ethtype = odp_be_to_cpu_16(*((const uint16_t *)
@@ -1210,8 +1211,8 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
/* Parse the VLAN header(s), if present */
if (ethtype == ODPH_ETHTYPE_VLAN_OUTER) {
- pkt_hdr->input_flags.vlan_qinq = 1;
- pkt_hdr->input_flags.vlan = 1;
+ pkt_hdr->p.input_flags.vlan_qinq = 1;
+ pkt_hdr->p.input_flags.vlan = 1;
vlan = (const odph_vlanhdr_t *)parseptr;
ethtype = odp_be_to_cpu_16(vlan->type);
@@ -1220,7 +1221,7 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
}
if (ethtype == ODPH_ETHTYPE_VLAN) {
- pkt_hdr->input_flags.vlan = 1;
+ pkt_hdr->p.input_flags.vlan = 1;
vlan = (const odph_vlanhdr_t *)parseptr;
ethtype = odp_be_to_cpu_16(vlan->type);
offset += sizeof(odph_vlanhdr_t);
@@ -1228,71 +1229,71 @@ int _odp_parse_common(odp_packet_hdr_t *pkt_hdr, const uint8_t *ptr)
}
/* Set l3_offset+flag only for known ethtypes */
- pkt_hdr->input_flags.l3 = 1;
- pkt_hdr->l3_offset = offset;
+ pkt_hdr->p.input_flags.l3 = 1;
+ pkt_hdr->p.l3_offset = offset;
/* Parse Layer 3 headers */
switch (ethtype) {
case ODPH_ETHTYPE_IPV4:
- pkt_hdr->input_flags.ipv4 = 1;
+ pkt_hdr->p.input_flags.ipv4 = 1;
ip_proto = parse_ipv4(pkt_hdr, &parseptr, &offset);
break;
case ODPH_ETHTYPE_IPV6:
- pkt_hdr->input_flags.ipv6 = 1;
+ pkt_hdr->p.input_flags.ipv6 = 1;
ip_proto = parse_ipv6(pkt_hdr, &parseptr, &offset);
break;
case ODPH_ETHTYPE_ARP:
- pkt_hdr->input_flags.arp = 1;
+ pkt_hdr->p.input_flags.arp = 1;
ip_proto = 255; /* Reserved invalid by IANA */
break;
default:
- pkt_hdr->input_flags.l3 = 0;
- pkt_hdr->l3_offset = ODP_PACKET_OFFSET_INVALID;
+ pkt_hdr->p.input_flags.l3 = 0;
+ pkt_hdr->p.l3_offset = ODP_PACKET_OFFSET_INVALID;
ip_proto = 255; /* Reserved invalid by IANA */
}
/* Set l4_offset+flag only for known ip_proto */
- pkt_hdr->input_flags.l4 = 1;
- pkt_hdr->l4_offset = offset;
+ pkt_hdr->p.input_flags.l4 = 1;
+ pkt_hdr->p.l4_offset = offset;
/* Parse Layer 4 headers */
switch (ip_proto) {
case ODPH_IPPROTO_ICMP:
- pkt_hdr->input_flags.icmp = 1;
+ pkt_hdr->p.input_flags.icmp = 1;
break;
case ODPH_IPPROTO_TCP:
- pkt_hdr->input_flags.tcp = 1;
+ pkt_hdr->p.input_flags.tcp = 1;
parse_tcp(pkt_hdr, &parseptr, NULL);
break;
case ODPH_IPPROTO_UDP:
- pkt_hdr->input_flags.udp = 1;
+ pkt_hdr->p.input_flags.udp = 1;
parse_udp(pkt_hdr, &parseptr, NULL);
break;
case ODPH_IPPROTO_AH:
- pkt_hdr->input_flags.ipsec = 1;
- pkt_hdr->input_flags.ipsec_ah = 1;
+ pkt_hdr->p.input_flags.ipsec = 1;
+ pkt_hdr->p.input_flags.ipsec_ah = 1;
break;
case ODPH_IPPROTO_ESP:
- pkt_hdr->input_flags.ipsec = 1;
- pkt_hdr->input_flags.ipsec_esp = 1;
+ pkt_hdr->p.input_flags.ipsec = 1;
+ pkt_hdr->p.input_flags.ipsec_esp = 1;
break;
default:
- pkt_hdr->input_flags.l4 = 0;
- pkt_hdr->l4_offset = ODP_PACKET_OFFSET_INVALID;
+ pkt_hdr->p.input_flags.l4 = 0;
+ pkt_hdr->p.l4_offset = ODP_PACKET_OFFSET_INVALID;
break;
}
parse_exit:
- pkt_hdr->input_flags.parsed_all = 1;
- return pkt_hdr->error_flags.all != 0;
+ pkt_hdr->p.input_flags.parsed_all = 1;
+ return pkt_hdr->p.error_flags.all != 0;
}
/**
diff --git a/platform/linux-generic/odp_packet_flags.c b/platform/linux-generic/odp_packet_flags.c
index 3acdc53..b88324c 100644
--- a/platform/linux-generic/odp_packet_flags.c
+++ b/platform/linux-generic/odp_packet_flags.c
@@ -7,26 +7,27 @@
#include <odp/api/packet_flags.h>
#include <odp_packet_internal.h>
-#define retflag(p, x) do { \
- odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(p); \
- if (packet_parse_not_complete(pkt_hdr)) \
- packet_parse_full(pkt_hdr); \
- return pkt_hdr->x; \
+#define retflag(pkt, x) do { \
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt); \
+ if (packet_parse_not_complete(pkt_hdr)) \
+ packet_parse_full(pkt_hdr); \
+ return pkt_hdr->p.x; \
} while (0)
-#define setflag(p, x, v) do { \
- odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(p); \
- if (packet_parse_not_complete(pkt_hdr)) \
- packet_parse_full(pkt_hdr); \
- pkt_hdr->x = v & 1; \
+#define setflag(pkt, x, v) do { \
+ odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt); \
+ if (packet_parse_not_complete(pkt_hdr)) \
+ packet_parse_full(pkt_hdr); \
+ pkt_hdr->p.x = v & 1; \
} while (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;
+ return odp_packet_hdr(pkt)->p.error_flags.all != 0;
}
/* Get Input Flags */
@@ -35,7 +36,7 @@ int odp_packet_has_l2(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- return pkt_hdr->input_flags.l2;
+ return pkt_hdr->p.input_flags.l2;
}
int odp_packet_has_l2_error(odp_packet_t pkt)
@@ -43,9 +44,9 @@ 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->error_flags.frame_len
- | pkt_hdr->error_flags.snap_len
- | pkt_hdr->error_flags.l2_chksum;
+ 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(odp_packet_t pkt)
@@ -60,7 +61,7 @@ int odp_packet_has_l3_error(odp_packet_t pkt)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- return pkt_hdr->error_flags.ip_err;
+ return pkt_hdr->p.error_flags.ip_err;
}
int odp_packet_has_l4(odp_packet_t pkt)
@@ -75,14 +76,14 @@ int odp_packet_has_l4_error(odp_packet_t pkt)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- return pkt_hdr->error_flags.tcp_err | pkt_hdr->error_flags.udp_err;
+ return pkt_hdr->p.error_flags.tcp_err | pkt_hdr->p.error_flags.udp_err;
}
int odp_packet_has_eth(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- return pkt_hdr->input_flags.eth;
+ return pkt_hdr->p.input_flags.eth;
}
int odp_packet_has_eth_bcast(odp_packet_t pkt)
@@ -99,7 +100,7 @@ int odp_packet_has_jumbo(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- return pkt_hdr->input_flags.jumbo;
+ return pkt_hdr->p.input_flags.jumbo;
}
int odp_packet_has_vlan(odp_packet_t pkt)
@@ -176,14 +177,14 @@ int odp_packet_has_flow_hash(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- return pkt_hdr->input_flags.flow_hash;
+ return pkt_hdr->p.input_flags.flow_hash;
}
int odp_packet_has_ts(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- return pkt_hdr->input_flags.timestamp;
+ return pkt_hdr->p.input_flags.timestamp;
}
odp_packet_color_t odp_packet_color(odp_packet_t pkt)
@@ -198,7 +199,7 @@ void odp_packet_color_set(odp_packet_t pkt, odp_packet_color_t color)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- pkt_hdr->input_flags.color = color;
+ pkt_hdr->p.input_flags.color = color;
}
odp_bool_t odp_packet_drop_eligible(odp_packet_t pkt)
@@ -208,7 +209,7 @@ odp_bool_t odp_packet_drop_eligible(odp_packet_t pkt)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- return !pkt_hdr->input_flags.nodrop;
+ return !pkt_hdr->p.input_flags.nodrop;
}
void odp_packet_drop_eligible_set(odp_packet_t pkt, odp_bool_t drop)
@@ -228,7 +229,7 @@ void odp_packet_shaper_len_adjust_set(odp_packet_t pkt, int8_t adj)
if (packet_parse_not_complete(pkt_hdr))
packet_parse_full(pkt_hdr);
- pkt_hdr->output_flags.shaper_len_adj = adj;
+ pkt_hdr->p.output_flags.shaper_len_adj = adj;
}
/* Set Input Flags */
@@ -342,12 +343,12 @@ void odp_packet_has_flow_hash_clr(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- pkt_hdr->input_flags.flow_hash = 0;
+ pkt_hdr->p.input_flags.flow_hash = 0;
}
void odp_packet_has_ts_clr(odp_packet_t pkt)
{
odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
- pkt_hdr->input_flags.timestamp = 0;
+ pkt_hdr->p.input_flags.timestamp = 0;
}
diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c
index 90ecdac..5b202e7 100644
--- a/platform/linux-generic/odp_packet_io.c
+++ b/platform/linux-generic/odp_packet_io.c
@@ -564,7 +564,7 @@ static inline int pktin_recv_buf(odp_pktin_queue_t queue,
buf = _odp_packet_to_buffer(pkt);
buf_hdr = odp_buf_to_hdr(buf);
- if (pkt_hdr->input_flags.dst_queue) {
+ if (pkt_hdr->p.input_flags.dst_queue) {
queue_entry_t *dst_queue;
int ret;
diff --git a/platform/linux-generic/pktio/dpdk.c b/platform/linux-generic/pktio/dpdk.c
index 85bb07c..e9d7aa4 100644
--- a/platform/linux-generic/pktio/dpdk.c
+++ b/platform/linux-generic/pktio/dpdk.c
@@ -742,7 +742,7 @@ static inline int mbuf_to_pkt(pktio_entry_t *pktio_entry,
pkt_hdr->input = pktio_entry->s.handle;
if (pktio_cls_enabled(pktio_entry))
- copy_packet_parser_metadata(&parsed_hdr, pkt_hdr);
+ copy_packet_cls_metadata(&parsed_hdr, pkt_hdr);
else
packet_parse_l2(pkt_hdr);
diff --git a/platform/linux-generic/pktio/ipc.c b/platform/linux-generic/pktio/ipc.c
index bd74f11..e0d4ab9 100644
--- a/platform/linux-generic/pktio/ipc.c
+++ b/platform/linux-generic/pktio/ipc.c
@@ -571,7 +571,7 @@ static int ipc_pktio_recv_lockless(pktio_entry_t *pktio_entry,
memcpy(pkt_data, remote_pkt_data, phdr.frame_len);
/* Copy packets L2, L3 parsed offsets and size */
- copy_packet_parser_metadata(&phdr, odp_packet_hdr(pkt));
+ copy_packet_cls_metadata(&phdr, odp_packet_hdr(pkt));
odp_packet_hdr(pkt)->frame_len = phdr.frame_len;
odp_packet_hdr(pkt)->headroom = phdr.headroom;
diff --git a/platform/linux-generic/pktio/loop.c b/platform/linux-generic/pktio/loop.c
index effad9a..a19c2dd 100644
--- a/platform/linux-generic/pktio/loop.c
+++ b/platform/linux-generic/pktio/loop.c
@@ -111,7 +111,7 @@ static int loopback_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
pkt_hdr->input = pktio_entry->s.handle;
if (pktio_cls_enabled(pktio_entry))
- copy_packet_parser_metadata(&parsed_hdr, pkt_hdr);
+ copy_packet_cls_metadata(&parsed_hdr, pkt_hdr);
else
packet_parse_l2(pkt_hdr);
diff --git a/platform/linux-generic/pktio/netmap.c b/platform/linux-generic/pktio/netmap.c
index 457ea53..6bfbe84 100644
--- a/platform/linux-generic/pktio/netmap.c
+++ b/platform/linux-generic/pktio/netmap.c
@@ -628,7 +628,7 @@ static inline int netmap_pkt_to_odp(pktio_entry_t *pktio_entry,
pkt_hdr->input = pktio_entry->s.handle;
if (pktio_cls_enabled(pktio_entry))
- copy_packet_parser_metadata(&parsed_hdr, pkt_hdr);
+ copy_packet_cls_metadata(&parsed_hdr, pkt_hdr);
else
packet_parse_l2(pkt_hdr);
diff --git a/platform/linux-generic/pktio/socket.c b/platform/linux-generic/pktio/socket.c
index e07b6ad..b116145 100644
--- a/platform/linux-generic/pktio/socket.c
+++ b/platform/linux-generic/pktio/socket.c
@@ -678,7 +678,7 @@ static int sock_mmsg_recv(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
continue;
}
pkt_hdr->input = pktio_entry->s.handle;
- copy_packet_parser_metadata(&parsed_hdr, pkt_hdr);
+ copy_packet_cls_metadata(&parsed_hdr, pkt_hdr);
packet_set_ts(pkt_hdr, ts);
pkt_table[nb_rx++] = pkt;
diff --git a/platform/linux-generic/pktio/socket_mmap.c b/platform/linux-generic/pktio/socket_mmap.c
index 720004c..30c44e9 100644
--- a/platform/linux-generic/pktio/socket_mmap.c
+++ b/platform/linux-generic/pktio/socket_mmap.c
@@ -224,7 +224,7 @@ static inline unsigned pkt_mmap_v2_rx(pktio_entry_t *pktio_entry,
hdr->input = pktio_entry->s.handle;
if (pktio_cls_enabled(pktio_entry))
- copy_packet_parser_metadata(&parsed_hdr, hdr);
+ copy_packet_cls_metadata(&parsed_hdr, hdr);
else
packet_parse_l2(hdr);
-----------------------------------------------------------------------
Summary of changes:
.../include/odp_classification_inlines.h | 36 +--
.../include/odp_classification_internal.h | 5 +-
.../linux-generic/include/odp_packet_internal.h | 68 +++---
platform/linux-generic/odp_classification.c | 28 +--
platform/linux-generic/odp_packet.c | 241 +++++++++++----------
platform/linux-generic/odp_packet_flags.c | 53 ++---
platform/linux-generic/odp_packet_io.c | 2 +-
platform/linux-generic/pktio/dpdk.c | 7 +-
platform/linux-generic/pktio/ipc.c | 2 +-
platform/linux-generic/pktio/loop.c | 29 ++-
platform/linux-generic/pktio/netmap.c | 6 +-
platform/linux-generic/pktio/pcap.c | 2 +-
platform/linux-generic/pktio/socket.c | 6 +-
platform/linux-generic/pktio/socket_mmap.c | 6 +-
platform/linux-generic/pktio/tap.c | 2 +-
15 files changed, 270 insertions(+), 223 deletions(-)
hooks/post-receive
--
7 years, 10 months
- 1
- 0
[COMMIT] branch master updated. v1.10.1.0-16-g2fc98f7
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 2fc98f7ba2fdcf7df0f04b171bc4bdd65b8cf980 (commit)
via 39738abf195e2d3af75133f4ec418614b86e770c (commit)
via c3f73eadd8eafb8e8167d5403d69527b896f9de6 (commit)
via 7da43047a614ce4c030878ee8bef31725c7b71ef (commit)
via bde29f1382ed76fa6b8450b67a249ab2c8c83323 (commit)
via 41ab23c89799de4db4de5c3910b70e80f3a7d8f9 (commit)
from 4cf18bb4f799e6601c20e54fafbdb58da538de89 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 2fc98f7ba2fdcf7df0f04b171bc4bdd65b8cf980
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Wed Jun 15 13:44:20 2016 +0300
linux-gen: sched: add pktio_stop_finalize to scheduler interface
Added pktio_stop_finalize() and related STOP_PENDING and
CLOSE_PENDING pktio states. When a scheduled pktio interface is
stopped, it's moved into STOP_PENDING state until the scheduler
responses with a stop_finalize call. While stop is pending, interface
may be closed and thus moved into CLOSE_PENDING state.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_packet_io_internal.h b/platform/linux-generic/include/odp_packet_io_internal.h
index 28610c1..bdf6316 100644
--- a/platform/linux-generic/include/odp_packet_io_internal.h
+++ b/platform/linux-generic/include/odp_packet_io_internal.h
@@ -125,11 +125,22 @@ struct pktio_entry {
_ipc_pktio_t ipc; /**< IPC pktio data */
};
enum {
- PKTIO_STATE_FREE = 0, /**< Not allocated */
- PKTIO_STATE_ALLOCATED, /**< Allocated, open in progress */
- PKTIO_STATE_OPENED, /**< Open completed */
- PKTIO_STATE_STARTED, /**< Start completed */
- PKTIO_STATE_STOPPED /**< Stop completed */
+ /* Not allocated */
+ PKTIO_STATE_FREE = 0,
+ /* Close pending on scheduler response. Next state after this
+ * is PKTIO_STATE_FREE. */
+ PKTIO_STATE_CLOSE_PENDING,
+ /* Open in progress.
+ Marker for all active states following under. */
+ PKTIO_STATE_ACTIVE,
+ /* Open completed */
+ PKTIO_STATE_OPENED,
+ /* Start completed */
+ PKTIO_STATE_STARTED,
+ /* Stop pending on scheduler response */
+ PKTIO_STATE_STOP_PENDING,
+ /* Stop completed */
+ PKTIO_STATE_STOPPED
} state;
odp_pktio_config_t config; /**< Device configuration */
classifier_t cls; /**< classifier linked with this pktio*/
diff --git a/platform/linux-generic/include/odp_schedule_if.h b/platform/linux-generic/include/odp_schedule_if.h
index 029a767..13cdfb3 100644
--- a/platform/linux-generic/include/odp_schedule_if.h
+++ b/platform/linux-generic/include/odp_schedule_if.h
@@ -61,6 +61,7 @@ extern const schedule_fn_t *sched_fn;
/* Interface for the scheduler */
int sched_cb_pktin_poll(int pktio_index, int num_queue, int index[]);
+void sched_cb_pktio_stop_finalize(int pktio_index);
int sched_cb_num_pktio(void);
int sched_cb_num_queues(void);
int sched_cb_queue_prio(uint32_t queue_index);
diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c
index 518b53e..90ecdac 100644
--- a/platform/linux-generic/odp_packet_io.c
+++ b/platform/linux-generic/odp_packet_io.c
@@ -163,7 +163,7 @@ static odp_pktio_t alloc_lock_pktio_entry(void)
if (is_free(entry)) {
odp_pktio_t hdl;
- entry->s.state = PKTIO_STATE_ALLOCATED;
+ entry->s.state = PKTIO_STATE_ACTIVE;
init_pktio_entry(entry);
hdl = _odp_cast_scalar(odp_pktio_t, i + 1);
return hdl; /* return with entry locked! */
@@ -275,12 +275,22 @@ odp_pktio_t odp_pktio_open(const char *name, odp_pool_t pool,
static int _pktio_close(pktio_entry_t *entry)
{
int ret;
+ int state = entry->s.state;
+
+ if (state != PKTIO_STATE_OPENED &&
+ state != PKTIO_STATE_STOPPED &&
+ state != PKTIO_STATE_STOP_PENDING)
+ return -1;
ret = entry->s.ops->close(entry);
if (ret)
return -1;
- entry->s.state = PKTIO_STATE_FREE;
+ if (state == PKTIO_STATE_STOP_PENDING)
+ entry->s.state = PKTIO_STATE_CLOSE_PENDING;
+ else
+ entry->s.state = PKTIO_STATE_FREE;
+
return 0;
}
@@ -346,6 +356,11 @@ int odp_pktio_close(odp_pktio_t hdl)
if (entry == NULL)
return -1;
+ if (entry->s.state == PKTIO_STATE_STARTED) {
+ ODP_DBG("Missing odp_pktio_stop() before close.\n");
+ return -1;
+ }
+
if (entry->s.state == PKTIO_STATE_STOPPED)
flush_in_queues(entry);
@@ -357,11 +372,10 @@ int odp_pktio_close(odp_pktio_t hdl)
entry->s.num_in_queue = 0;
entry->s.num_out_queue = 0;
- if (!is_free(entry)) {
- res = _pktio_close(entry);
- if (res)
- ODP_ABORT("unable to close pktio\n");
- }
+ res = _pktio_close(entry);
+ if (res)
+ ODP_ABORT("unable to close pktio\n");
+
unlock_entry(entry);
return 0;
@@ -465,13 +479,20 @@ int odp_pktio_start(odp_pktio_t hdl)
static int _pktio_stop(pktio_entry_t *entry)
{
int res = 0;
+ odp_pktin_mode_t mode = entry->s.param.in_mode;
if (entry->s.state != PKTIO_STATE_STARTED)
return -1;
if (entry->s.ops->stop)
res = entry->s.ops->stop(entry);
- if (!res)
+
+ if (res)
+ return -1;
+
+ if (mode == ODP_PKTIN_MODE_SCHED)
+ entry->s.state = PKTIO_STATE_STOP_PENDING;
+ else
entry->s.state = PKTIO_STATE_STOPPED;
return res;
@@ -508,7 +529,7 @@ odp_pktio_t odp_pktio_lookup(const char *name)
lock_entry(entry);
- if (!is_free(entry) &&
+ if (entry->s.state >= PKTIO_STATE_ACTIVE &&
strncmp(entry->s.name, name, sizeof(entry->s.name)) == 0)
hdl = _odp_cast_scalar(odp_pktio_t, i + 1);
@@ -670,17 +691,13 @@ int sched_cb_pktin_poll(int pktio_index, int num_queue, int index[])
int num, idx;
pktio_entry_t *entry;
entry = pktio_entry_by_index(pktio_index);
+ int state = entry->s.state;
- if (odp_unlikely(is_free(entry))) {
- ODP_ERR("Bad pktio entry\n");
- return -1;
- }
-
- /* Temporarely needed for odp_pktio_inq_remdef() */
- if (odp_unlikely(entry->s.num_in_queue == 0))
- return -1;
+ if (odp_unlikely(state != PKTIO_STATE_STARTED)) {
+ if (state < PKTIO_STATE_ACTIVE ||
+ state == PKTIO_STATE_STOP_PENDING)
+ return -1;
- if (entry->s.state != PKTIO_STATE_STARTED) {
ODP_DBG("interface not started\n");
return 0;
}
@@ -708,6 +725,30 @@ int sched_cb_pktin_poll(int pktio_index, int num_queue, int index[])
return 0;
}
+void sched_cb_pktio_stop_finalize(int pktio_index)
+{
+ int state;
+ pktio_entry_t *entry = pktio_entry_by_index(pktio_index);
+
+ lock_entry(entry);
+
+ state = entry->s.state;
+
+ if (state != PKTIO_STATE_STOP_PENDING &&
+ state != PKTIO_STATE_CLOSE_PENDING) {
+ unlock_entry(entry);
+ ODP_ERR("Not in a pending state %i\n", state);
+ return;
+ }
+
+ if (state == PKTIO_STATE_STOP_PENDING)
+ entry->s.state = PKTIO_STATE_STOPPED;
+ else
+ entry->s.state = PKTIO_STATE_FREE;
+
+ unlock_entry(entry);
+}
+
int sched_cb_num_pktio(void)
{
return ODP_CONFIG_PKTIO_ENTRIES;
@@ -977,8 +1018,10 @@ void odp_pktio_print(odp_pktio_t hdl)
" state %s\n",
entry->s.state == PKTIO_STATE_STARTED ? "start" :
(entry->s.state == PKTIO_STATE_STOPPED ? "stop" :
+ (entry->s.state == PKTIO_STATE_STOP_PENDING ?
+ "stop pending" :
(entry->s.state == PKTIO_STATE_OPENED ? "opened" :
- "unknown")));
+ "unknown"))));
memset(addr, 0, sizeof(addr));
odp_pktio_mac_addr(hdl, addr, ETH_ALEN);
len += snprintf(&str[len], n - len,
diff --git a/platform/linux-generic/odp_schedule.c b/platform/linux-generic/odp_schedule.c
index 3aaf696..8765f48 100644
--- a/platform/linux-generic/odp_schedule.c
+++ b/platform/linux-generic/odp_schedule.c
@@ -49,6 +49,9 @@ ODP_STATIC_ASSERT((ODP_SCHED_PRIO_NORMAL > 0) &&
/* Maximum number of packet input queues per command */
#define MAX_PKTIN 8
+/* Maximum number of packet IO interfaces */
+#define NUM_PKTIO ODP_CONFIG_PKTIO_ENTRIES
+
/* Mask of queues per priority */
typedef uint8_t pri_mask_t;
@@ -86,6 +89,10 @@ typedef struct {
int prio;
} queue[ODP_CONFIG_QUEUES];
+ struct {
+ int num;
+ } pktio[NUM_PKTIO];
+
} sched_global_t;
/* Schedule command */
@@ -419,6 +426,8 @@ static void schedule_pktio_start(int pktio_index, int num_in_queue,
if (num_in_queue > MAX_PKTIN)
ODP_ABORT("Too many input queues for scheduler\n");
+ sched->pktio[pktio_index].num = num_in_queue;
+
/* Create a pktio poll command per queue */
for (i = 0; i < num_in_queue; i++) {
buf = odp_buffer_alloc(sched->pool);
@@ -445,14 +454,19 @@ static void schedule_pktio_start(int pktio_index, int num_in_queue,
}
}
-static void schedule_pktio_stop(sched_cmd_t *sched_cmd)
+static int schedule_pktio_stop(sched_cmd_t *sched_cmd)
{
- int idx = poll_cmd_queue_idx(sched_cmd->pktio_index,
- sched_cmd->index[0]);
+ int num;
+ int pktio_index = sched_cmd->pktio_index;
+ int idx = poll_cmd_queue_idx(pktio_index, sched_cmd->index[0]);
odp_spinlock_lock(&sched->poll_cmd_lock);
sched->poll_cmd[idx].num--;
+ sched->pktio[pktio_index].num--;
+ num = sched->pktio[pktio_index].num;
odp_spinlock_unlock(&sched->poll_cmd_lock);
+
+ return num;
}
static void schedule_release_atomic(void)
@@ -643,6 +657,7 @@ static int do_schedule(odp_queue_t *out_queue, odp_event_t out_ev[],
for (i = 0; i < POLL_CMD_QUEUES; i++, id++) {
odp_queue_t cmd_queue;
+ int pktio_index;
if (id == POLL_CMD_QUEUES)
id = 0;
@@ -662,12 +677,18 @@ static int do_schedule(odp_queue_t *out_queue, odp_event_t out_ev[],
if (sched_cmd->cmd != SCHED_CMD_POLL_PKTIN)
ODP_ABORT("Bad poll command\n");
+ pktio_index = sched_cmd->pktio_index;
+
/* Poll packet input */
- if (sched_cb_pktin_poll(sched_cmd->pktio_index,
+ if (sched_cb_pktin_poll(pktio_index,
sched_cmd->num,
sched_cmd->index)) {
- /* Stop scheduling the pktio */
- schedule_pktio_stop(sched_cmd);
+ /* Pktio stopped or closed. Remove poll command and call
+ * stop_finalize when all commands of the pktio has
+ * been removed. */
+ if (schedule_pktio_stop(sched_cmd) == 0)
+ sched_cb_pktio_stop_finalize(pktio_index);
+
odp_buffer_free(buf);
} else {
/* Continue scheduling the pktio */
diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c
index 0a21b2c..0973239 100644
--- a/platform/linux-generic/odp_schedule_sp.c
+++ b/platform/linux-generic/odp_schedule_sp.c
@@ -408,10 +408,15 @@ static int schedule_multi(odp_queue_t *from, uint64_t wait,
cmd = sched_cmd(NUM_PRIO);
if (cmd && cmd->s.type == CMD_PKTIO) {
- sched_cb_pktin_poll(cmd->s.index, cmd->s.num_pktin,
- cmd->s.pktin_idx);
+ if (sched_cb_pktin_poll(cmd->s.index, cmd->s.num_pktin,
+ cmd->s.pktin_idx)) {
+ /* Pktio stopped or closed. */
+ sched_cb_pktio_stop_finalize(cmd->s.index);
+ } else {
+ /* Continue polling pktio. */
+ add_tail(cmd);
+ }
- add_tail(cmd);
/* run wait parameter checks under */
cmd = NULL;
}
commit 39738abf195e2d3af75133f4ec418614b86e770c
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Wed Jun 15 13:44:19 2016 +0300
test: pktio: improve start_stop test
Added schedule call after pktio_stop/close to expose
potential errors in a pending stop/close in scheduler.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/validation/pktio/pktio.c b/test/validation/pktio/pktio.c
index 4fa8b6f..5922ba5 100644
--- a/test/validation/pktio/pktio.c
+++ b/test/validation/pktio/pktio.c
@@ -336,7 +336,7 @@ static odp_pktio_t create_pktio(int iface_idx, odp_pktin_mode_t imode,
pktio_param.out_mode = omode;
pktio = odp_pktio_open(iface, pool[iface_idx], &pktio_param);
- CU_ASSERT(pktio != ODP_PKTIO_INVALID);
+ CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
CU_ASSERT(odp_pktio_to_u64(pktio) !=
odp_pktio_to_u64(ODP_PKTIO_INVALID));
@@ -1510,6 +1510,7 @@ void pktio_test_statistics_counters(void)
void pktio_test_start_stop(void)
{
odp_pktio_t pktio[MAX_NUM_IFACES];
+ odp_pktio_t pktio_in;
odp_packet_t pkt;
odp_packet_t tx_pkt[1000];
uint32_t pkt_seq[1000];
@@ -1588,11 +1589,11 @@ void pktio_test_start_stop(void)
if (num_ifaces > 1)
- alloc = create_packets(tx_pkt, pkt_seq, 1000, pktio[0],
- pktio[1]);
+ pktio_in = pktio[1];
else
- alloc = create_packets(tx_pkt, pkt_seq, 1000, pktio[0],
- pktio[0]);
+ pktio_in = pktio[0];
+
+ alloc = create_packets(tx_pkt, pkt_seq, 1000, pktio[0], pktio_in);
/* send */
for (pkts = 0; pkts != alloc; ) {
@@ -1622,6 +1623,13 @@ void pktio_test_start_stop(void)
CU_ASSERT(odp_pktio_stop(pktio[i]) == 0);
CU_ASSERT(odp_pktio_close(pktio[i]) == 0);
}
+
+ /* Verify that a schedule call after stop and close does not generate
+ errors. */
+ ev = odp_schedule(NULL, wait);
+ CU_ASSERT(ev == ODP_EVENT_INVALID);
+ if (ev != ODP_EVENT_INVALID)
+ odp_event_free(ev);
}
/*
commit c3f73eadd8eafb8e8167d5403d69527b896f9de6
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Wed Jun 15 13:44:18 2016 +0300
test: validation: add missing pktio_stop calls
When pktio_start has been called, pktio_stop must be called
before pktio_close.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/validation/pktio/pktio.c b/test/validation/pktio/pktio.c
index 8f66880..4fa8b6f 100644
--- a/test/validation/pktio/pktio.c
+++ b/test/validation/pktio/pktio.c
@@ -1801,8 +1801,11 @@ void pktio_test_send_failure(void)
odp_packet_free(pkt_tbl[i]);
}
- if (pktio_rx != pktio_tx)
+ if (pktio_rx != pktio_tx) {
+ CU_ASSERT(odp_pktio_stop(pktio_rx) == 0);
CU_ASSERT(odp_pktio_close(pktio_rx) == 0);
+ }
+ CU_ASSERT(odp_pktio_stop(pktio_tx) == 0);
CU_ASSERT(odp_pktio_close(pktio_tx) == 0);
CU_ASSERT(odp_pool_destroy(pkt_pool) == 0);
}
diff --git a/test/validation/traffic_mngr/traffic_mngr.c b/test/validation/traffic_mngr/traffic_mngr.c
index ce9d038..0645370 100644
--- a/test/validation/traffic_mngr/traffic_mngr.c
+++ b/test/validation/traffic_mngr/traffic_mngr.c
@@ -2089,6 +2089,9 @@ int traffic_mngr_suite_term(void)
if (odp_pool_destroy(pools[iface]) != 0)
return -1;
+ if (odp_pktio_stop(pktios[iface]) != 0)
+ return -1;
+
if (odp_pktio_close(pktios[iface]) != 0)
return -1;
}
commit 7da43047a614ce4c030878ee8bef31725c7b71ef
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Wed Jun 15 13:44:17 2016 +0300
linux-gen: sched: use pktio index in scheduler interface
Replaced pktio handle with pktio index in scheduler interface.
Indexes are used in implementation internal interfaces for
performance reasons.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_schedule_if.h b/platform/linux-generic/include/odp_schedule_if.h
index 86a117f..029a767 100644
--- a/platform/linux-generic/include/odp_schedule_if.h
+++ b/platform/linux-generic/include/odp_schedule_if.h
@@ -12,7 +12,6 @@ extern "C" {
#endif
#include <odp/api/queue.h>
-#include <odp/api/packet_io.h>
#include <odp/api/schedule.h>
/* Constants defined by the scheduler. These should be converted into interface
@@ -21,7 +20,7 @@ extern "C" {
/* Number of ordered locks per queue */
#define SCHEDULE_ORDERED_LOCKS_PER_QUEUE 2
-typedef void (*schedule_pktio_start_fn_t)(odp_pktio_t pktio, int num_in_queue,
+typedef void (*schedule_pktio_start_fn_t)(int pktio_index, int num_in_queue,
int in_queue_idx[]);
typedef int (*schedule_thr_add_fn_t)(odp_schedule_group_t group, int thr);
typedef int (*schedule_thr_rem_fn_t)(odp_schedule_group_t group, int thr);
diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c
index 9dff9f6..518b53e 100644
--- a/platform/linux-generic/odp_packet_io.c
+++ b/platform/linux-generic/odp_packet_io.c
@@ -456,7 +456,7 @@ int odp_pktio_start(odp_pktio_t hdl)
}
}
- sched_fn->pktio_start(hdl, num, index);
+ sched_fn->pktio_start(pktio_to_id(hdl), num, index);
}
return res;
diff --git a/platform/linux-generic/odp_schedule.c b/platform/linux-generic/odp_schedule.c
index f572468..3aaf696 100644
--- a/platform/linux-generic/odp_schedule.c
+++ b/platform/linux-generic/odp_schedule.c
@@ -98,7 +98,6 @@ typedef struct {
};
struct {
- odp_pktio_t pktio;
int pktio_index;
int num;
int index[MAX_PKTIN];
@@ -404,12 +403,12 @@ static void schedule_destroy_queue(uint32_t queue_index)
sched->queue[queue_index].prio = 0;
}
-static int poll_cmd_queue_idx(odp_pktio_t pktio, int in_queue_idx)
+static int poll_cmd_queue_idx(int pktio_index, int in_queue_idx)
{
- return (POLL_CMD_QUEUES - 1) & (odp_pktio_index(pktio) ^ in_queue_idx);
+ return (POLL_CMD_QUEUES - 1) & (pktio_index ^ in_queue_idx);
}
-static void schedule_pktio_start(odp_pktio_t pktio, int num_in_queue,
+static void schedule_pktio_start(int pktio_index, int num_in_queue,
int in_queue_idx[])
{
odp_buffer_t buf;
@@ -429,12 +428,11 @@ static void schedule_pktio_start(odp_pktio_t pktio, int num_in_queue,
sched_cmd = odp_buffer_addr(buf);
sched_cmd->cmd = SCHED_CMD_POLL_PKTIN;
- sched_cmd->pktio = pktio;
- sched_cmd->pktio_index = odp_pktio_index(pktio);
+ sched_cmd->pktio_index = pktio_index;
sched_cmd->num = 1;
sched_cmd->index[0] = in_queue_idx[i];
- idx = poll_cmd_queue_idx(pktio, in_queue_idx[i]);
+ idx = poll_cmd_queue_idx(pktio_index, in_queue_idx[i]);
odp_spinlock_lock(&sched->poll_cmd_lock);
sched->poll_cmd[idx].num++;
@@ -449,7 +447,8 @@ static void schedule_pktio_start(odp_pktio_t pktio, int num_in_queue,
static void schedule_pktio_stop(sched_cmd_t *sched_cmd)
{
- int idx = poll_cmd_queue_idx(sched_cmd->pktio, sched_cmd->index[0]);
+ int idx = poll_cmd_queue_idx(sched_cmd->pktio_index,
+ sched_cmd->index[0]);
odp_spinlock_lock(&sched->poll_cmd_lock);
sched->poll_cmd[idx].num--;
diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c
index 7162c7b..0a21b2c 100644
--- a/platform/linux-generic/odp_schedule_sp.c
+++ b/platform/linux-generic/odp_schedule_sp.c
@@ -7,6 +7,7 @@
#include <string.h>
#include <odp/api/ticketlock.h>
#include <odp/api/thread.h>
+#include <odp/api/time.h>
#include <odp/api/schedule.h>
#include <odp_schedule_if.h>
#include <odp_debug_internal.h>
@@ -340,16 +341,15 @@ static int ord_enq_multi(uint32_t queue_index, void *buf_hdr[], int num,
return 0;
}
-static void pktio_start(odp_pktio_t pktio, int num, int pktin_idx[])
+static void pktio_start(int pktio_index, int num, int pktin_idx[])
{
- int pi, i;
+ int i;
sched_cmd_t *cmd;
- ODP_DBG("pktio:%" PRIu64 ", %i pktin queues %i\n",
- odp_pktio_to_u64(pktio), num, pktin_idx[0]);
+ ODP_DBG("pktio index: %i, %i pktin queues %i\n",
+ pktio_index, num, pktin_idx[0]);
- pi = odp_pktio_index(pktio);
- cmd = &sched_global.pktio_cmd[pi];
+ cmd = &sched_global.pktio_cmd[pktio_index];
if (num > NUM_PKTIN)
ODP_ABORT("Supports only %i pktin queues per interface\n",
commit bde29f1382ed76fa6b8450b67a249ab2c8c83323
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Wed Jun 15 13:44:16 2016 +0300
linux-gen: sched: call pktio_start only once
Pktio calls the scheduler interface function pktio_start
once per odp_pktio_start(). Scheduler handles internally
creation of multiple poll commands.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c
index 0e47533..9dff9f6 100644
--- a/platform/linux-generic/odp_packet_io.c
+++ b/platform/linux-generic/odp_packet_io.c
@@ -444,17 +444,19 @@ int odp_pktio_start(odp_pktio_t hdl)
if (mode == ODP_PKTIN_MODE_SCHED) {
unsigned i;
+ unsigned num = entry->s.num_in_queue;
+ int index[num];
- for (i = 0; i < entry->s.num_in_queue; i++) {
- int index = i;
+ for (i = 0; i < num; i++) {
+ index[i] = i;
if (entry->s.in_queue[i].queue == ODP_QUEUE_INVALID) {
ODP_ERR("No input queue\n");
return -1;
}
-
- sched_fn->pktio_start(hdl, 1, &index);
}
+
+ sched_fn->pktio_start(hdl, num, index);
}
return res;
diff --git a/platform/linux-generic/odp_schedule.c b/platform/linux-generic/odp_schedule.c
index 3b97909..f572468 100644
--- a/platform/linux-generic/odp_schedule.c
+++ b/platform/linux-generic/odp_schedule.c
@@ -417,33 +417,34 @@ static void schedule_pktio_start(odp_pktio_t pktio, int num_in_queue,
odp_queue_t queue;
int i, idx;
- buf = odp_buffer_alloc(sched->pool);
-
- if (buf == ODP_BUFFER_INVALID)
- ODP_ABORT("Sched pool empty\n");
-
- sched_cmd = odp_buffer_addr(buf);
- sched_cmd->cmd = SCHED_CMD_POLL_PKTIN;
- sched_cmd->pktio = pktio;
- sched_cmd->pktio_index = odp_pktio_index(pktio);
- sched_cmd->num = num_in_queue;
-
if (num_in_queue > MAX_PKTIN)
ODP_ABORT("Too many input queues for scheduler\n");
- for (i = 0; i < num_in_queue; i++)
- sched_cmd->index[i] = in_queue_idx[i];
+ /* Create a pktio poll command per queue */
+ for (i = 0; i < num_in_queue; i++) {
+ buf = odp_buffer_alloc(sched->pool);
- idx = poll_cmd_queue_idx(pktio, in_queue_idx[0]);
+ if (buf == ODP_BUFFER_INVALID)
+ ODP_ABORT("Sched pool empty\n");
- odp_spinlock_lock(&sched->poll_cmd_lock);
- sched->poll_cmd[idx].num++;
- odp_spinlock_unlock(&sched->poll_cmd_lock);
+ sched_cmd = odp_buffer_addr(buf);
+ sched_cmd->cmd = SCHED_CMD_POLL_PKTIN;
+ sched_cmd->pktio = pktio;
+ sched_cmd->pktio_index = odp_pktio_index(pktio);
+ sched_cmd->num = 1;
+ sched_cmd->index[0] = in_queue_idx[i];
+
+ idx = poll_cmd_queue_idx(pktio, in_queue_idx[i]);
- queue = sched->poll_cmd[idx].queue;
+ odp_spinlock_lock(&sched->poll_cmd_lock);
+ sched->poll_cmd[idx].num++;
+ odp_spinlock_unlock(&sched->poll_cmd_lock);
- if (odp_queue_enq(queue, odp_buffer_to_event(buf)))
- ODP_ABORT("schedule_pktio_start failed\n");
+ queue = sched->poll_cmd[idx].queue;
+
+ if (odp_queue_enq(queue, odp_buffer_to_event(buf)))
+ ODP_ABORT("schedule_pktio_start failed\n");
+ }
}
static void schedule_pktio_stop(sched_cmd_t *sched_cmd)
commit 41ab23c89799de4db4de5c3910b70e80f3a7d8f9
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Wed Jun 15 13:44:15 2016 +0300
linux-gen: pktio: simplify state handling
Removed 'int taken', so that 'enum state' is the only
variable which holds pktio entry state. Added PKTIO_ prefix
for better name space protection and code readability.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_packet_io_internal.h b/platform/linux-generic/include/odp_packet_io_internal.h
index 53683b3..28610c1 100644
--- a/platform/linux-generic/include/odp_packet_io_internal.h
+++ b/platform/linux-generic/include/odp_packet_io_internal.h
@@ -109,7 +109,6 @@ struct pktio_entry {
/* These two locks together lock the whole pktio device */
odp_ticketlock_t rxl; /**< RX ticketlock */
odp_ticketlock_t txl; /**< TX ticketlock */
- int taken; /**< is entry taken(1) or free(0) */
int cls_enabled; /**< is classifier enabled */
odp_pktio_t handle; /**< pktio handle */
union {
@@ -126,10 +125,11 @@ struct pktio_entry {
_ipc_pktio_t ipc; /**< IPC pktio data */
};
enum {
- STATE_OPENED = 0, /**< After open() */
- STATE_STARTED, /**< After start() */
- STATE_STOPPED /**< Same as OPENED, but only happens
- after STARTED */
+ PKTIO_STATE_FREE = 0, /**< Not allocated */
+ PKTIO_STATE_ALLOCATED, /**< Allocated, open in progress */
+ PKTIO_STATE_OPENED, /**< Open completed */
+ PKTIO_STATE_STARTED, /**< Start completed */
+ PKTIO_STATE_STOPPED /**< Stop completed */
} state;
odp_pktio_config_t config; /**< Device configuration */
classifier_t cls; /**< classifier linked with this pktio*/
@@ -171,8 +171,6 @@ typedef struct {
pktio_entry_t entries[ODP_CONFIG_PKTIO_ENTRIES];
} pktio_table_t;
-int is_free(pktio_entry_t *entry);
-
typedef struct pktio_if_ops {
const char *name;
void (*print)(pktio_entry_t *pktio_entry);
diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c
index 8d88aa3..0e47533 100644
--- a/platform/linux-generic/odp_packet_io.c
+++ b/platform/linux-generic/odp_packet_io.c
@@ -104,19 +104,9 @@ int odp_pktio_init_local(void)
return 0;
}
-int is_free(pktio_entry_t *entry)
+static inline int is_free(pktio_entry_t *entry)
{
- return (entry->s.taken == 0);
-}
-
-static void set_free(pktio_entry_t *entry)
-{
- entry->s.taken = 0;
-}
-
-static void set_taken(pktio_entry_t *entry)
-{
- entry->s.taken = 1;
+ return (entry->s.state == PKTIO_STATE_FREE);
}
static void lock_entry(pktio_entry_t *entry)
@@ -153,7 +143,6 @@ static void init_out_queues(pktio_entry_t *entry)
static void init_pktio_entry(pktio_entry_t *entry)
{
- set_taken(entry);
pktio_cls_enabled_set(entry, 0);
init_in_queues(entry);
@@ -174,6 +163,7 @@ static odp_pktio_t alloc_lock_pktio_entry(void)
if (is_free(entry)) {
odp_pktio_t hdl;
+ entry->s.state = PKTIO_STATE_ALLOCATED;
init_pktio_entry(entry);
hdl = _odp_cast_scalar(odp_pktio_t, i + 1);
return hdl; /* return with entry locked! */
@@ -228,13 +218,13 @@ static odp_pktio_t setup_pktio_entry(const char *name, odp_pool_t pool,
}
if (ret != 0) {
- set_free(pktio_entry);
+ pktio_entry->s.state = PKTIO_STATE_FREE;
hdl = ODP_PKTIO_INVALID;
ODP_ERR("Unable to init any I/O type.\n");
} else {
snprintf(pktio_entry->s.name,
sizeof(pktio_entry->s.name), "%s", name);
- pktio_entry->s.state = STATE_OPENED;
+ pktio_entry->s.state = PKTIO_STATE_OPENED;
}
unlock_entry(pktio_entry);
@@ -290,7 +280,7 @@ static int _pktio_close(pktio_entry_t *entry)
if (ret)
return -1;
- set_free(entry);
+ entry->s.state = PKTIO_STATE_FREE;
return 0;
}
@@ -356,7 +346,7 @@ int odp_pktio_close(odp_pktio_t hdl)
if (entry == NULL)
return -1;
- if (entry->s.state == STATE_STOPPED)
+ if (entry->s.state == PKTIO_STATE_STOPPED)
flush_in_queues(entry);
lock_entry(entry);
@@ -412,7 +402,7 @@ int odp_pktio_config(odp_pktio_t hdl, const odp_pktio_config_t *config)
}
lock_entry(entry);
- if (entry->s.state == STATE_STARTED) {
+ if (entry->s.state == PKTIO_STATE_STARTED) {
unlock_entry(entry);
ODP_DBG("pktio %s: not stopped\n", entry->s.name);
return -1;
@@ -439,14 +429,14 @@ int odp_pktio_start(odp_pktio_t hdl)
return -1;
lock_entry(entry);
- if (entry->s.state == STATE_STARTED) {
+ if (entry->s.state == PKTIO_STATE_STARTED) {
unlock_entry(entry);
return -1;
}
if (entry->s.ops->start)
res = entry->s.ops->start(entry);
if (!res)
- entry->s.state = STATE_STARTED;
+ entry->s.state = PKTIO_STATE_STARTED;
unlock_entry(entry);
@@ -474,13 +464,13 @@ static int _pktio_stop(pktio_entry_t *entry)
{
int res = 0;
- if (entry->s.state != STATE_STARTED)
+ if (entry->s.state != PKTIO_STATE_STARTED)
return -1;
if (entry->s.ops->stop)
res = entry->s.ops->stop(entry);
if (!res)
- entry->s.state = STATE_STOPPED;
+ entry->s.state = PKTIO_STATE_STOPPED;
return res;
}
@@ -688,7 +678,7 @@ int sched_cb_pktin_poll(int pktio_index, int num_queue, int index[])
if (odp_unlikely(entry->s.num_in_queue == 0))
return -1;
- if (entry->s.state != STATE_STARTED) {
+ if (entry->s.state != PKTIO_STATE_STARTED) {
ODP_DBG("interface not started\n");
return 0;
}
@@ -765,7 +755,7 @@ int odp_pktio_promisc_mode_set(odp_pktio_t hdl, odp_bool_t enable)
ODP_DBG("already freed pktio\n");
return -1;
}
- if (entry->s.state == STATE_STARTED) {
+ if (entry->s.state == PKTIO_STATE_STARTED) {
unlock_entry(entry);
return -1;
}
@@ -983,10 +973,10 @@ void odp_pktio_print(odp_pktio_t hdl)
" type %s\n", entry->s.ops->name);
len += snprintf(&str[len], n - len,
" state %s\n",
- entry->s.state == STATE_STARTED ? "start" :
- (entry->s.state == STATE_STOPPED ? "stop" :
- (entry->s.state == STATE_OPENED ? "opened" :
- "unknown")));
+ entry->s.state == PKTIO_STATE_STARTED ? "start" :
+ (entry->s.state == PKTIO_STATE_STOPPED ? "stop" :
+ (entry->s.state == PKTIO_STATE_OPENED ? "opened" :
+ "unknown")));
memset(addr, 0, sizeof(addr));
odp_pktio_mac_addr(hdl, addr, ETH_ALEN);
len += snprintf(&str[len], n - len,
@@ -1031,7 +1021,7 @@ int odp_pktio_term_global(void)
continue;
lock_entry(pktio_entry);
- if (pktio_entry->s.state == STATE_STARTED) {
+ if (pktio_entry->s.state == PKTIO_STATE_STARTED) {
ret = _pktio_stop(pktio_entry);
if (ret)
ODP_ABORT("unable to stop pktio %s\n",
@@ -1155,7 +1145,7 @@ int odp_pktin_queue_config(odp_pktio_t pktio,
return -1;
}
- if (entry->s.state == STATE_STARTED) {
+ if (entry->s.state == PKTIO_STATE_STARTED) {
ODP_DBG("pktio %s: not stopped\n", entry->s.name);
return -1;
}
@@ -1268,7 +1258,7 @@ int odp_pktout_queue_config(odp_pktio_t pktio,
return -1;
}
- if (entry->s.state == STATE_STARTED) {
+ if (entry->s.state == PKTIO_STATE_STARTED) {
ODP_DBG("pktio %s: not stopped\n", entry->s.name);
return -1;
}
diff --git a/platform/linux-generic/pktio/dpdk.c b/platform/linux-generic/pktio/dpdk.c
index 2225dfe..85bb07c 100644
--- a/platform/linux-generic/pktio/dpdk.c
+++ b/platform/linux-generic/pktio/dpdk.c
@@ -349,7 +349,7 @@ static int dpdk_close(pktio_entry_t *pktio_entry)
rte_pktmbuf_free(pkt_dpdk->rx_cache[i].s.pkt[idx++]);
}
- if (pktio_entry->s.state != STATE_OPENED)
+ if (pktio_entry->s.state != PKTIO_STATE_OPENED)
rte_eth_dev_close(pkt_dpdk->port_id);
return 0;
@@ -814,7 +814,7 @@ static int dpdk_recv(pktio_entry_t *pktio_entry, int index,
int i;
unsigned cache_idx;
- if (odp_unlikely(pktio_entry->s.state != STATE_STARTED))
+ if (odp_unlikely(pktio_entry->s.state != PKTIO_STATE_STARTED))
return 0;
if (!pkt_dpdk->lockless_rx)
@@ -881,7 +881,7 @@ static int dpdk_send(pktio_entry_t *pktio_entry, int index,
int i;
int mbufs;
- if (odp_unlikely(pktio_entry->s.state != STATE_STARTED))
+ if (odp_unlikely(pktio_entry->s.state != PKTIO_STATE_STARTED))
return 0;
if (!pktio_entry->s.pkt_dpdk.lockless_tx)
diff --git a/platform/linux-generic/pktio/netmap.c b/platform/linux-generic/pktio/netmap.c
index 4ea0d4a..457ea53 100644
--- a/platform/linux-generic/pktio/netmap.c
+++ b/platform/linux-generic/pktio/netmap.c
@@ -703,7 +703,7 @@ static int netmap_recv(pktio_entry_t *pktio_entry, int index,
int max_fd = 0;
fd_set empty_rings;
- if (odp_unlikely(pktio_entry->s.state != STATE_STARTED))
+ if (odp_unlikely(pktio_entry->s.state != PKTIO_STATE_STARTED))
return 0;
FD_ZERO(&empty_rings);
@@ -758,7 +758,7 @@ static int netmap_send(pktio_entry_t *pktio_entry, int index,
unsigned slot_id;
char *buf;
- if (odp_unlikely(pktio_entry->s.state != STATE_STARTED))
+ if (odp_unlikely(pktio_entry->s.state != PKTIO_STATE_STARTED))
return 0;
/* Only one netmap tx ring per pktout queue */
diff --git a/platform/linux-generic/pktio/pcap.c b/platform/linux-generic/pktio/pcap.c
index b719849..c967e70 100644
--- a/platform/linux-generic/pktio/pcap.c
+++ b/platform/linux-generic/pktio/pcap.c
@@ -216,7 +216,7 @@ static int pcapif_recv_pkt(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
odp_ticketlock_lock(&pktio_entry->s.rxl);
- if (pktio_entry->s.state != STATE_STARTED || !pcap->rx) {
+ if (pktio_entry->s.state != PKTIO_STATE_STARTED || !pcap->rx) {
odp_ticketlock_unlock(&pktio_entry->s.rxl);
return 0;
}
@@ -311,7 +311,7 @@ static int pcapif_send_pkt(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
odp_ticketlock_lock(&pktio_entry->s.txl);
- if (pktio_entry->s.state != STATE_STARTED) {
+ if (pktio_entry->s.state != PKTIO_STATE_STARTED) {
odp_ticketlock_unlock(&pktio_entry->s.txl);
return 0;
}
-----------------------------------------------------------------------
Summary of changes:
.../linux-generic/include/odp_packet_io_internal.h | 23 ++--
platform/linux-generic/include/odp_schedule_if.h | 4 +-
platform/linux-generic/odp_packet_io.c | 135 +++++++++++++--------
platform/linux-generic/odp_schedule.c | 77 +++++++-----
platform/linux-generic/odp_schedule_sp.c | 23 ++--
platform/linux-generic/pktio/dpdk.c | 6 +-
platform/linux-generic/pktio/netmap.c | 4 +-
platform/linux-generic/pktio/pcap.c | 4 +-
test/validation/pktio/pktio.c | 23 +++-
test/validation/traffic_mngr/traffic_mngr.c | 3 +
10 files changed, 193 insertions(+), 109 deletions(-)
hooks/post-receive
--
7 years, 10 months
- 1
- 0
[COMMIT] branch master updated. v1.10.1.0-10-g4cf18bb
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 4cf18bb4f799e6601c20e54fafbdb58da538de89 (commit)
from 793c4b15275fd7e6c30bf348f236e778b9bfee02 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 4cf18bb4f799e6601c20e54fafbdb58da538de89
Author: Bill Fischofer <bill.fischofer(a)linaro.org>
Date: Thu Jun 9 19:09:28 2016 -0500
linux-generic: timer: correct definition of ODP_TIMEOUT_INVALID
Resolve bug https://bugs.linaro.org/show_bug.cgi?id=2316 by changing the
typedef of ODP_TIMEOUT_INVALID to be 0xffffffff to be consistent with other
buffer types. This enables pool 0 to be used as a timeout pool.
Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp/api/plat/timer_types.h b/platform/linux-generic/include/odp/api/plat/timer_types.h
index 93ea162..68d6f6f 100644
--- a/platform/linux-generic/include/odp/api/plat/timer_types.h
+++ b/platform/linux-generic/include/odp/api/plat/timer_types.h
@@ -36,7 +36,7 @@ typedef ODP_HANDLE_T(odp_timer_t);
typedef ODP_HANDLE_T(odp_timeout_t);
-#define ODP_TIMEOUT_INVALID _odp_cast_scalar(odp_timeout_t, 0)
+#define ODP_TIMEOUT_INVALID _odp_cast_scalar(odp_timeout_t, 0xffffffff)
/**
* @}
-----------------------------------------------------------------------
Summary of changes:
platform/linux-generic/include/odp/api/plat/timer_types.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
hooks/post-receive
--
7 years, 10 months
- 1
- 0
[COMMIT] branch master updated. v1.10.1.0-9-g793c4b1
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 793c4b15275fd7e6c30bf348f236e778b9bfee02 (commit)
via 46684cc1f1cdc33b7b223687e063f458b6c7bf02 (commit)
from 8ab5804ea8bd430fd7cd0bd0edae316918b976d7 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 793c4b15275fd7e6c30bf348f236e778b9bfee02
Author: Mike Holmes <mike.holmes(a)linaro.org>
Date: Mon Jun 13 15:37:34 2016 -0400
doc: separate pure API guide and implementation guide
It should be possible to generate the pure API specification guide, this
patch achieves that
Copy the application guide to form a platform specific guide.
The application guide is now ONLY the public specification.
The new platform guide includes the additional definitions specific to
odp-linux and it can contain platform specific notes and other
documentation as needed
Signed-off-by: Mike Holmes <mike.holmes(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/configure.ac b/configure.ac
index 3851ebd..c87755b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -183,7 +183,9 @@ DX_INIT_DOXYGEN($PACKAGE_NAME,
${srcdir}/doc/application-api-guide/Doxyfile,
${builddir}/doc/application-api-guide/output,
${srcdir}/doc/helper-guide/Doxyfile,
- ${builddir}/doc/helper-guide/output)
+ ${builddir}/doc/helper-guide/output,
+ ${srcdir}/doc/platform-api-guide/Doxyfile,
+ ${builddir}/doc/platform-api-guide/output)
##########################################################################
# Enable/disable ODP_DEBUG_PRINT
diff --git a/doc/application-api-guide/Doxyfile b/doc/Doxyfile_common
similarity index 56%
copy from doc/application-api-guide/Doxyfile
copy to doc/Doxyfile_common
index 97731b2..5955853 100644
--- a/doc/application-api-guide/Doxyfile
+++ b/doc/Doxyfile_common
@@ -1,6 +1,3 @@
-PROJECT_NAME = "API Reference Manual for $(WITH_PLATFORM)"
-PROJECT_NUMBER = $(VERSION)
-PROJECT_LOGO = $(SRCDIR)/doc/images/ODP-Logo-HQ.svg
QUIET = YES
OUTPUT_DIRECTORY = $(DOCDIR)
FULL_PATH_NAMES = NO
@@ -10,10 +7,6 @@ TYPEDEF_HIDES_STRUCT = NO
EXTRACT_STATIC = YES
SORT_MEMBER_DOCS = NO
WARN_NO_PARAMDOC = YES
-INPUT = $(SRCDIR)/doc/application-api-guide \
- $(SRCDIR)/include \
- $(SRCDIR)/platform/$(WITH_PLATFORM)/include/odp \
- $(SRCDIR)/platform/$(WITH_PLATFORM)/arch/$(WITH_ARCH)
FILE_PATTERNS = *.h odp*.c *.dox
RECURSIVE = YES
SOURCE_BROWSER = YES
@@ -27,7 +20,6 @@ CLASS_DIAGRAMS = NO
HAVE_DOT = YES
CALL_GRAPH = YES
DOT_MULTI_TARGETS = NO
-EXAMPLE_PATH = $(SRCDIR)/example $(SRCDIR)/platform $(SRCDIR)
EXAMPLE_PATTERNS = *.c
EXAMPLE_RECURSIVE = YES
IMAGE_PATH = $(SRCDIR)/doc/images
@@ -36,13 +28,5 @@ LAYOUT_FILE = $(SRCDIR)/doc/doxygenlayout.xml
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = YES
EXPAND_ONLY_PREDEF = YES
-PREDEFINED = __GNUC__ \
- __attribute__(x)= \
- ODP_ALIGNED(x)= \
- __BIG_ENDIAN_BITFIELD \
- __LITTLE_ENDIAN_BITFIELD \
- __x86_64__ \
- ODP_PACKED \
- "ODP_HANDLE_T(type)=odp_handle_t type"
INTERNAL_DOCS = YES
DOT_IMAGE_FORMAT = svg
diff --git a/doc/Makefile.am b/doc/Makefile.am
index cf67c42..d49d84b 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -1,4 +1,4 @@
-SUBDIRS = application-api-guide helper-guide
+SUBDIRS = application-api-guide helper-guide platform-api-guide
if user_guide
SUBDIRS += implementers-guide users-guide process-guide
@@ -7,4 +7,5 @@ endif
EXTRA_DIST = \
$(top_srcdir)/doc/doxygenlayout.xml \
$(top_srcdir)/doc/odpdoxygen.css \
- $(top_srcdir)/doc/glossary.adoc
+ $(top_srcdir)/doc/glossary.adoc \
+ $(top_srcdir)/doc/Doxyfile_common
diff --git a/doc/application-api-guide/Doxyfile b/doc/application-api-guide/Doxyfile
index 97731b2..9cb183c 100644
--- a/doc/application-api-guide/Doxyfile
+++ b/doc/application-api-guide/Doxyfile
@@ -1,48 +1,12 @@
-PROJECT_NAME = "API Reference Manual for $(WITH_PLATFORM)"
+@INCLUDE = $(SRCDIR)/doc/Doxyfile_common
+
+PROJECT_NAME = "API Reference Manual"
PROJECT_NUMBER = $(VERSION)
PROJECT_LOGO = $(SRCDIR)/doc/images/ODP-Logo-HQ.svg
-QUIET = YES
-OUTPUT_DIRECTORY = $(DOCDIR)
-FULL_PATH_NAMES = NO
-JAVADOC_AUTOBRIEF = YES
-OPTIMIZE_OUTPUT_FOR_C = YES
-TYPEDEF_HIDES_STRUCT = NO
-EXTRACT_STATIC = YES
-SORT_MEMBER_DOCS = NO
-WARN_NO_PARAMDOC = YES
INPUT = $(SRCDIR)/doc/application-api-guide \
- $(SRCDIR)/include \
- $(SRCDIR)/platform/$(WITH_PLATFORM)/include/odp \
- $(SRCDIR)/platform/$(WITH_PLATFORM)/arch/$(WITH_ARCH)
-FILE_PATTERNS = *.h odp*.c *.dox
-RECURSIVE = YES
-SOURCE_BROWSER = YES
-REFERENCED_BY_RELATION = YES
-REFERENCES_RELATION = YES
-ALPHABETICAL_INDEX = NO
-QHP_NAMESPACE =
-GENERATE_TREEVIEW = YES
-PAPER_TYPE = a4wide
-CLASS_DIAGRAMS = NO
-HAVE_DOT = YES
-CALL_GRAPH = YES
-DOT_MULTI_TARGETS = NO
-EXAMPLE_PATH = $(SRCDIR)/example $(SRCDIR)/platform $(SRCDIR)
-EXAMPLE_PATTERNS = *.c
-EXAMPLE_RECURSIVE = YES
-IMAGE_PATH = $(SRCDIR)/doc/images
-HTML_EXTRA_STYLESHEET = $(SRCDIR)/doc/odpdoxygen.css
-LAYOUT_FILE = $(SRCDIR)/doc/doxygenlayout.xml
-ENABLE_PREPROCESSING = YES
-MACRO_EXPANSION = YES
-EXPAND_ONLY_PREDEF = YES
+ $(SRCDIR)/include
+EXCLUDE_PATTERNS = drv* odp_drv.h
+EXAMPLE_PATH = $(SRCDIR)/example $(SRCDIR)
PREDEFINED = __GNUC__ \
- __attribute__(x)= \
- ODP_ALIGNED(x)= \
- __BIG_ENDIAN_BITFIELD \
- __LITTLE_ENDIAN_BITFIELD \
- __x86_64__ \
- ODP_PACKED \
"ODP_HANDLE_T(type)=odp_handle_t type"
-INTERNAL_DOCS = YES
-DOT_IMAGE_FORMAT = svg
+WARNINGS = NO
diff --git a/doc/m4/configure.m4 b/doc/m4/configure.m4
index 183c929..ed9451d 100644
--- a/doc/m4/configure.m4
+++ b/doc/m4/configure.m4
@@ -40,5 +40,6 @@ AC_CONFIG_FILES([doc/application-api-guide/Makefile
doc/helper-guide/Makefile
doc/implementers-guide/Makefile
doc/Makefile
+ doc/platform-api-guide/Makefile
doc/process-guide/Makefile
doc/users-guide/Makefile])
diff --git a/doc/platform-api-guide/.gitignore b/doc/platform-api-guide/.gitignore
new file mode 100644
index 0000000..53752db
--- /dev/null
+++ b/doc/platform-api-guide/.gitignore
@@ -0,0 +1 @@
+output
diff --git a/doc/platform-api-guide/Doxyfile b/doc/platform-api-guide/Doxyfile
new file mode 100644
index 0000000..b87b7b2
--- /dev/null
+++ b/doc/platform-api-guide/Doxyfile
@@ -0,0 +1,19 @@
+@INCLUDE = $(SRCDIR)/doc/Doxyfile_common
+
+PROJECT_NAME = "API Reference Manual for $(WITH_PLATFORM)"
+PROJECT_NUMBER = $(VERSION)
+PROJECT_LOGO = $(SRCDIR)/doc/images/ODP-Logo-HQ.svg
+INPUT = $(SRCDIR)/doc/application-api-guide \
+ $(SRCDIR)/doc/platform-api-guide \
+ $(SRCDIR)/include \
+ $(SRCDIR)/platform/$(WITH_PLATFORM)/include/odp \
+ $(SRCDIR)/platform/$(WITH_PLATFORM)/arch/$(WITH_ARCH)
+EXAMPLE_PATH = $(SRCDIR)/example $(SRCDIR)/platform $(SRCDIR)
+PREDEFINED = __GNUC__ \
+ __attribute__(x)= \
+ ODP_ALIGNED(x)= \
+ __BIG_ENDIAN_BITFIELD \
+ __LITTLE_ENDIAN_BITFIELD \
+ __x86_64__ \
+ ODP_PACKED \
+ "ODP_HANDLE_T(type)=odp_handle_t type"
diff --git a/doc/platform-api-guide/Makefile.am b/doc/platform-api-guide/Makefile.am
new file mode 100644
index 0000000..a04c254
--- /dev/null
+++ b/doc/platform-api-guide/Makefile.am
@@ -0,0 +1,5 @@
+EXTRA_DIST = \
+ Doxyfile
+
+clean-local:
+ rm -rf output
commit 46684cc1f1cdc33b7b223687e063f458b6c7bf02
Author: Mike Holmes <mike.holmes(a)linaro.org>
Date: Mon Jun 13 15:37:33 2016 -0400
doc: fix distribution build cases
Signed-off-by: Mike Holmes <mike.holmes(a)linaro.org>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/doc/Makefile.am b/doc/Makefile.am
index 7e312e0..cf67c42 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -6,4 +6,5 @@ endif
EXTRA_DIST = \
$(top_srcdir)/doc/doxygenlayout.xml \
- $(top_srcdir)/doc/odpdoxygen.css
+ $(top_srcdir)/doc/odpdoxygen.css \
+ $(top_srcdir)/doc/glossary.adoc
diff --git a/doc/users-guide/Makefile.am b/doc/users-guide/Makefile.am
index 00a07d7..a01c717 100644
--- a/doc/users-guide/Makefile.am
+++ b/doc/users-guide/Makefile.am
@@ -35,7 +35,8 @@ IMAGES = $(top_srcdir)/doc/images/overview.svg \
$(top_srcdir)/doc/images/timeout_fsm.svg \
$(top_srcdir)/doc/images/timer_fsm.svg \
$(top_srcdir)/doc/images/tm_hierarchy.svg \
- $(top_srcdir)/doc/images/tm_node.svg
+ $(top_srcdir)/doc/images/tm_node.svg \
+ $(top_srcdir)/doc/images/pktin_sched_cls.svg
if HAVE_MSCGEN
IMAGES += $(top_srcdir)/doc/images/resource_management.svg
-----------------------------------------------------------------------
Summary of changes:
configure.ac | 4 +-
doc/{helper-guide/Doxyfile => Doxyfile_common} | 13 ------
doc/Makefile.am | 6 ++-
doc/application-api-guide/Doxyfile | 50 +++-------------------
doc/m4/configure.m4 | 1 +
.../.gitignore | 0
doc/platform-api-guide/Doxyfile | 19 ++++++++
.../Makefile.am | 1 -
doc/users-guide/Makefile.am | 3 +-
9 files changed, 36 insertions(+), 61 deletions(-)
copy doc/{helper-guide/Doxyfile => Doxyfile_common} (64%)
copy doc/{application-api-guide => platform-api-guide}/.gitignore (100%)
create mode 100644 doc/platform-api-guide/Doxyfile
copy doc/{helper-guide => platform-api-guide}/Makefile.am (78%)
hooks/post-receive
--
7 years, 10 months
- 1
- 0
[COMMIT] branch master updated. v1.10.1.0-7-g8ab5804
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 8ab5804ea8bd430fd7cd0bd0edae316918b976d7 (commit)
via 33bd749de8128afbb6b5bcad5ef6bea5a2667178 (commit)
via 99b863c804fe38bd919d3b9c2f6dad5ddabf1aaa (commit)
via 8d10e64603e67620084cb92648707550110d7bbe (commit)
via 72634d86988e33ac38dd1ecda2cc4e8a156307ed (commit)
via 341d3029f797ebb2bcf0fa6089c3463eea73e1cc (commit)
via 69717806018f61af84645ff458e3dc69a13d747e (commit)
from b78d235b8fe23b423bf6e7a3c65abbfb7efa4af8 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 8ab5804ea8bd430fd7cd0bd0edae316918b976d7
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Thu Jun 9 15:56:03 2016 +0300
linux-gen: sched: SP scheduler implementation
This is initial implementation of strict priority scheduler.
SP scheduler will not be optimized for throughput, but for low
latency processing of high priority events. Implementation may
have limited support on various scheduler features (e.g. ordered
queues) and low number of priorities, groups, etc.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c
index 9f1ef16..7162c7b 100644
--- a/platform/linux-generic/odp_schedule_sp.c
+++ b/platform/linux-generic/odp_schedule_sp.c
@@ -5,26 +5,173 @@
*/
#include <string.h>
+#include <odp/api/ticketlock.h>
+#include <odp/api/thread.h>
#include <odp/api/schedule.h>
#include <odp_schedule_if.h>
#include <odp_debug_internal.h>
+#include <odp_align_internal.h>
+#include <odp_config_internal.h>
+
+/* Dummy pool */
+#include <odp/api/pool.h>
+
+#define NUM_QUEUE ODP_CONFIG_QUEUES
+#define NUM_PKTIO ODP_CONFIG_PKTIO_ENTRIES
+#define NUM_PRIO 3
+#define NUM_STATIC_GROUP 3
+#define NUM_GROUP (NUM_STATIC_GROUP + 9)
+#define NUM_PKTIN 32
+#define LOWEST_QUEUE_PRIO (NUM_PRIO - 2)
+#define PKTIN_PRIO (NUM_PRIO - 1)
+#define CMD_QUEUE 0
+#define CMD_PKTIO 1
+#define ROUNDUP_CACHE(x) ODP_CACHE_LINE_SIZE_ROUNDUP(x)
+#define GROUP_ALL ODP_SCHED_GROUP_ALL
+#define GROUP_WORKER ODP_SCHED_GROUP_WORKER
+#define GROUP_CONTROL ODP_SCHED_GROUP_CONTROL
+
+struct sched_cmd_t;
+
+struct sched_cmd_s {
+ struct sched_cmd_t *next;
+ uint32_t index;
+ int type;
+ int prio;
+ int group;
+ int init;
+ int num_pktin;
+ int pktin_idx[NUM_PKTIN];
+};
+
+typedef struct sched_cmd_t {
+ struct sched_cmd_s s;
+ uint8_t pad[ROUNDUP_CACHE(sizeof(struct sched_cmd_s)) -
+ sizeof(struct sched_cmd_s)];
+} sched_cmd_t ODP_ALIGNED_CACHE;
+
+struct prio_queue_s {
+ odp_ticketlock_t lock;
+ sched_cmd_t *head;
+ sched_cmd_t *tail;
+};
+
+typedef struct prio_queue_t {
+ struct prio_queue_s s;
+ uint8_t pad[ROUNDUP_CACHE(sizeof(struct prio_queue_s)) -
+ sizeof(struct prio_queue_s)];
+} prio_queue_t ODP_ALIGNED_CACHE;
+
+struct sched_group_s {
+ odp_ticketlock_t lock;
+
+ struct {
+ char name[ODP_SCHED_GROUP_NAME_LEN + 1];
+ odp_thrmask_t mask;
+ int allocated;
+ } group[NUM_GROUP];
+};
+
+typedef struct sched_group_t {
+ struct sched_group_s s;
+ uint8_t pad[ROUNDUP_CACHE(sizeof(struct sched_group_s)) -
+ sizeof(struct sched_group_s)];
+} sched_group_t ODP_ALIGNED_CACHE;
+
+typedef struct {
+ sched_cmd_t queue_cmd[NUM_QUEUE];
+ sched_cmd_t pktio_cmd[NUM_PKTIO];
+ prio_queue_t prio_queue[NUM_PRIO];
+ sched_group_t sched_group;
+} sched_global_t;
+
+typedef struct {
+ sched_cmd_t *cmd;
+ int pause;
+ int thr_id;
+} sched_local_t;
+
+static sched_global_t sched_global;
+static __thread sched_local_t sched_local;
+
+/* Dummy pool */
+static odp_pool_t dummy_pool;
static int init_global(void)
{
- ODP_DBG("Schedule SP init ...\n");
+ int i;
+ odp_pool_param_t params;
+ sched_group_t *sched_group = &sched_global.sched_group;
+
+ ODP_DBG("Using SP scheduler\n");
+
+ memset(&sched_global, 0, sizeof(sched_global_t));
+
+ for (i = 0; i < NUM_QUEUE; i++) {
+ sched_global.queue_cmd[i].s.type = CMD_QUEUE;
+ sched_global.queue_cmd[i].s.index = i;
+ }
+
+ for (i = 0; i < NUM_PKTIO; i++) {
+ sched_global.pktio_cmd[i].s.type = CMD_PKTIO;
+ sched_global.pktio_cmd[i].s.index = i;
+ sched_global.pktio_cmd[i].s.prio = PKTIN_PRIO;
+ }
+
+ for (i = 0; i < NUM_PRIO; i++)
+ odp_ticketlock_init(&sched_global.prio_queue[i].s.lock);
- ODP_ABORT("Not implemented.");
+ odp_ticketlock_init(&sched_group->s.lock);
+
+ strncpy(sched_group->s.group[GROUP_ALL].name, "__group_all",
+ ODP_SCHED_GROUP_NAME_LEN);
+ odp_thrmask_zero(&sched_group->s.group[GROUP_ALL].mask);
+ sched_group->s.group[GROUP_ALL].allocated = 1;
+
+ strncpy(sched_group->s.group[GROUP_WORKER].name, "__group_worker",
+ ODP_SCHED_GROUP_NAME_LEN);
+ odp_thrmask_zero(&sched_group->s.group[GROUP_WORKER].mask);
+ sched_group->s.group[GROUP_WORKER].allocated = 1;
+
+ strncpy(sched_group->s.group[GROUP_CONTROL].name, "__group_control",
+ ODP_SCHED_GROUP_NAME_LEN);
+ odp_thrmask_zero(&sched_group->s.group[GROUP_CONTROL].mask);
+ sched_group->s.group[GROUP_CONTROL].allocated = 1;
+
+ /* REMOVE dummy pool after a bug has been fixed in pool or timer code.
+ * If scheduler does not create a pool, timer validation test fails !!!
+ */
+ odp_pool_param_init(¶ms);
+ params.buf.size = 48;
+ params.buf.align = 0;
+ params.buf.num = NUM_QUEUE + NUM_PKTIO;
+ params.type = ODP_POOL_BUFFER;
+ dummy_pool = odp_pool_create("dummy_sched_pool", ¶ms);
return 0;
}
static int init_local(void)
{
+ memset(&sched_local, 0, sizeof(sched_local_t));
+ sched_local.thr_id = odp_thread_id();
+
return 0;
}
static int term_global(void)
{
+ int qi;
+
+ for (qi = 0; qi < NUM_QUEUE; qi++) {
+ if (sched_global.queue_cmd[qi].s.init) {
+ /* todo: dequeue until empty ? */
+ sched_cb_queue_destroy_finalize(qi);
+ }
+ }
+
+ odp_pool_destroy(dummy_pool);
+
return 0;
}
@@ -33,15 +180,516 @@ static int term_local(void)
return 0;
}
+static int thr_add(odp_schedule_group_t group, int thr)
+{
+ sched_group_t *sched_group = &sched_global.sched_group;
+
+ if (group < 0 || group >= NUM_GROUP)
+ return -1;
+
+ odp_ticketlock_lock(&sched_group->s.lock);
+
+ if (!sched_group->s.group[group].allocated) {
+ odp_ticketlock_unlock(&sched_group->s.lock);
+ return -1;
+ }
+
+ odp_thrmask_set(&sched_group->s.group[group].mask, thr);
+
+ odp_ticketlock_unlock(&sched_group->s.lock);
+
+ return 0;
+}
+
+static int thr_rem(odp_schedule_group_t group, int thr)
+{
+ sched_group_t *sched_group = &sched_global.sched_group;
+
+ if (group < 0 || group >= NUM_GROUP)
+ return -1;
+
+ odp_ticketlock_lock(&sched_group->s.lock);
+
+ if (!sched_group->s.group[group].allocated) {
+ odp_ticketlock_unlock(&sched_group->s.lock);
+ return -1;
+ }
+
+ odp_thrmask_clr(&sched_group->s.group[group].mask, thr);
+
+ odp_ticketlock_unlock(&sched_group->s.lock);
+
+ return 0;
+}
+
+static int num_grps(void)
+{
+ return NUM_GROUP - NUM_STATIC_GROUP;
+}
+
+static int init_queue(uint32_t qi, const odp_schedule_param_t *sched_param)
+{
+ sched_group_t *sched_group = &sched_global.sched_group;
+ odp_schedule_group_t group = sched_param->group;
+ int prio = 0;
+
+ if (group < 0 || group >= NUM_GROUP)
+ return -1;
+
+ if (!sched_group->s.group[group].allocated)
+ return -1;
+
+ if (sched_param->prio > 0)
+ prio = LOWEST_QUEUE_PRIO;
+
+ sched_global.queue_cmd[qi].s.prio = prio;
+ sched_global.queue_cmd[qi].s.group = group;
+ sched_global.queue_cmd[qi].s.init = 1;
+
+ return 0;
+}
+
+static void destroy_queue(uint32_t qi)
+{
+ sched_global.queue_cmd[qi].s.prio = 0;
+ sched_global.queue_cmd[qi].s.group = 0;
+ sched_global.queue_cmd[qi].s.init = 0;
+}
+
+static inline void add_tail(sched_cmd_t *cmd)
+{
+ prio_queue_t *prio_queue;
+
+ prio_queue = &sched_global.prio_queue[cmd->s.prio];
+ cmd->s.next = NULL;
+
+ odp_ticketlock_lock(&prio_queue->s.lock);
+
+ if (prio_queue->s.head == NULL)
+ prio_queue->s.head = cmd;
+ else
+ prio_queue->s.tail->s.next = cmd;
+
+ prio_queue->s.tail = cmd;
+
+ odp_ticketlock_unlock(&prio_queue->s.lock);
+}
+
+static inline sched_cmd_t *rem_head(int prio)
+{
+ prio_queue_t *prio_queue;
+ sched_cmd_t *cmd;
+
+ prio_queue = &sched_global.prio_queue[prio];
+
+ odp_ticketlock_lock(&prio_queue->s.lock);
+
+ if (prio_queue->s.head == NULL) {
+ cmd = NULL;
+ } else {
+ sched_group_t *sched_group = &sched_global.sched_group;
+
+ cmd = prio_queue->s.head;
+
+ /* Remove head cmd only if thread belongs to the
+ * scheduler group. Otherwise continue to the next priority
+ * queue. */
+ if (odp_thrmask_isset(&sched_group->s.group[cmd->s.group].mask,
+ sched_local.thr_id))
+ prio_queue->s.head = cmd->s.next;
+ else
+ cmd = NULL;
+ }
+
+ odp_ticketlock_unlock(&prio_queue->s.lock);
+
+ return cmd;
+}
+
+static int sched_queue(uint32_t qi)
+{
+ sched_cmd_t *cmd;
+
+ cmd = &sched_global.queue_cmd[qi];
+ add_tail(cmd);
+
+ return 0;
+}
+
+static int ord_enq(uint32_t queue_index, void *buf_hdr, int sustain, int *ret)
+{
+ (void)queue_index;
+ (void)buf_hdr;
+ (void)sustain;
+ (void)ret;
+
+ /* didn't consume the events */
+ return 0;
+}
+
+static int ord_enq_multi(uint32_t queue_index, void *buf_hdr[], int num,
+ int sustain, int *ret)
+{
+ (void)queue_index;
+ (void)buf_hdr;
+ (void)num;
+ (void)sustain;
+ (void)ret;
+
+ /* didn't consume the events */
+ return 0;
+}
+
+static void pktio_start(odp_pktio_t pktio, int num, int pktin_idx[])
+{
+ int pi, i;
+ sched_cmd_t *cmd;
+
+ ODP_DBG("pktio:%" PRIu64 ", %i pktin queues %i\n",
+ odp_pktio_to_u64(pktio), num, pktin_idx[0]);
+
+ pi = odp_pktio_index(pktio);
+ cmd = &sched_global.pktio_cmd[pi];
+
+ if (num > NUM_PKTIN)
+ ODP_ABORT("Supports only %i pktin queues per interface\n",
+ NUM_PKTIN);
+
+ for (i = 0; i < num; i++)
+ cmd->s.pktin_idx[i] = pktin_idx[i];
+
+ cmd->s.num_pktin = num;
+
+ add_tail(cmd);
+}
+
+static inline sched_cmd_t *sched_cmd(int num_prio)
+{
+ int prio;
+
+ for (prio = 0; prio < num_prio; prio++) {
+ sched_cmd_t *cmd = rem_head(prio);
+
+ if (cmd)
+ return cmd;
+ }
+
+ return NULL;
+}
+
+static uint64_t schedule_wait_time(uint64_t ns)
+{
+ return ns;
+}
+
+static int schedule_multi(odp_queue_t *from, uint64_t wait,
+ odp_event_t events[], int max_events)
+{
+ (void)max_events;
+ int update_t1 = 1;
+
+ if (sched_local.cmd) {
+ /* Continue scheduling if queue is not empty */
+ if (sched_cb_queue_empty(sched_local.cmd->s.index) == 0)
+ add_tail(sched_local.cmd);
+
+ sched_local.cmd = NULL;
+ }
+
+ if (odp_unlikely(sched_local.pause))
+ return 0;
+
+ while (1) {
+ sched_cmd_t *cmd;
+ uint32_t qi;
+ int num;
+ odp_time_t t1;
+
+ cmd = sched_cmd(NUM_PRIO);
+
+ if (cmd && cmd->s.type == CMD_PKTIO) {
+ sched_cb_pktin_poll(cmd->s.index, cmd->s.num_pktin,
+ cmd->s.pktin_idx);
+
+ add_tail(cmd);
+ /* run wait parameter checks under */
+ cmd = NULL;
+ }
+
+ if (cmd == NULL) {
+ /* All priority queues are empty */
+ if (wait == ODP_SCHED_NO_WAIT)
+ return 0;
+
+ if (wait == ODP_SCHED_WAIT)
+ continue;
+
+ if (update_t1) {
+ t1 = odp_time_sum(odp_time_local(),
+ odp_time_local_from_ns(wait));
+ update_t1 = 0;
+ continue;
+ }
+
+ if (odp_time_cmp(odp_time_local(), t1) < 0)
+ continue;
+
+ return 0;
+ }
+
+ qi = cmd->s.index;
+ num = sched_cb_queue_deq_multi(qi, events, 1);
+
+ if (num > 0) {
+ sched_local.cmd = cmd;
+
+ if (from)
+ *from = sched_cb_queue_handle(qi);
+
+ return num;
+ }
+
+ if (num < 0) {
+ /* Destroyed queue */
+ sched_cb_queue_destroy_finalize(qi);
+ continue;
+ }
+
+ if (num == 0) {
+ /* Remove empty queue from scheduling. A dequeue
+ * operation to on an already empty queue moves
+ * it to NOTSCHED state and sched_queue() will
+ * be called on next enqueue. */
+ continue;
+ }
+ }
+}
+
+static odp_event_t schedule(odp_queue_t *from, uint64_t wait)
+{
+ odp_event_t ev;
+
+ if (schedule_multi(from, wait, &ev, 1) > 0)
+ return ev;
+
+ return ODP_EVENT_INVALID;
+}
+
+static void schedule_pause(void)
+{
+ sched_local.pause = 1;
+}
+
+static void schedule_resume(void)
+{
+ sched_local.pause = 0;
+}
+
+static void schedule_release_atomic(void)
+{
+}
+
+static void schedule_release_ordered(void)
+{
+}
+
+static void schedule_prefetch(int num)
+{
+ (void)num;
+}
+
+static int schedule_num_prio(void)
+{
+ /* Lowest priority is used for pktin polling and is internal
+ * to the scheduler */
+ return NUM_PRIO - 1;
+}
+
+static odp_schedule_group_t schedule_group_create(const char *name,
+ const odp_thrmask_t *thrmask)
+{
+ odp_schedule_group_t group = ODP_SCHED_GROUP_INVALID;
+ sched_group_t *sched_group = &sched_global.sched_group;
+ int i;
+
+ odp_ticketlock_lock(&sched_group->s.lock);
+
+ for (i = NUM_STATIC_GROUP; i < NUM_GROUP; i++) {
+ if (!sched_group->s.group[i].allocated) {
+ strncpy(sched_group->s.group[i].name, name,
+ ODP_SCHED_GROUP_NAME_LEN);
+ odp_thrmask_copy(&sched_group->s.group[i].mask,
+ thrmask);
+ sched_group->s.group[i].allocated = 1;
+ group = i;
+ break;
+ }
+ }
+
+ odp_ticketlock_unlock(&sched_group->s.lock);
+
+ return group;
+}
+
+static int schedule_group_destroy(odp_schedule_group_t group)
+{
+ sched_group_t *sched_group = &sched_global.sched_group;
+
+ if (group < NUM_STATIC_GROUP || group >= NUM_GROUP)
+ return -1;
+
+ odp_ticketlock_lock(&sched_group->s.lock);
+
+ if (!sched_group->s.group[group].allocated) {
+ odp_ticketlock_unlock(&sched_group->s.lock);
+ return -1;
+ }
+
+ memset(&sched_group->s.group[group], 0,
+ sizeof(sched_group->s.group[0]));
+
+ odp_ticketlock_unlock(&sched_group->s.lock);
+
+ return 0;
+}
+
+static odp_schedule_group_t schedule_group_lookup(const char *name)
+{
+ odp_schedule_group_t group = ODP_SCHED_GROUP_INVALID;
+ sched_group_t *sched_group = &sched_global.sched_group;
+ int i;
+
+ odp_ticketlock_lock(&sched_group->s.lock);
+
+ for (i = NUM_STATIC_GROUP; i < NUM_GROUP; i++) {
+ if (sched_group->s.group[i].allocated &&
+ strcmp(sched_group->s.group[i].name, name) == 0) {
+ group = i;
+ break;
+ }
+ }
+
+ odp_ticketlock_unlock(&sched_group->s.lock);
+ return group;
+}
+
+static int schedule_group_join(odp_schedule_group_t group,
+ const odp_thrmask_t *thrmask)
+{
+ sched_group_t *sched_group = &sched_global.sched_group;
+
+ if (group < 0 || group >= NUM_GROUP)
+ return -1;
+
+ odp_ticketlock_lock(&sched_group->s.lock);
+
+ if (!sched_group->s.group[group].allocated) {
+ odp_ticketlock_unlock(&sched_group->s.lock);
+ return -1;
+ }
+
+ odp_thrmask_or(&sched_group->s.group[group].mask,
+ &sched_group->s.group[group].mask,
+ thrmask);
+
+ odp_ticketlock_unlock(&sched_group->s.lock);
+
+ return 0;
+}
+
+static int schedule_group_leave(odp_schedule_group_t group,
+ const odp_thrmask_t *thrmask)
+{
+ sched_group_t *sched_group = &sched_global.sched_group;
+ odp_thrmask_t *all = &sched_group->s.group[GROUP_ALL].mask;
+ odp_thrmask_t not;
+
+ if (group < 0 || group >= NUM_GROUP)
+ return -1;
+
+ odp_ticketlock_lock(&sched_group->s.lock);
+
+ if (!sched_group->s.group[group].allocated) {
+ odp_ticketlock_unlock(&sched_group->s.lock);
+ return -1;
+ }
+
+ odp_thrmask_xor(¬, thrmask, all);
+ odp_thrmask_and(&sched_group->s.group[group].mask,
+ &sched_group->s.group[group].mask,
+ ¬);
+
+ odp_ticketlock_unlock(&sched_group->s.lock);
+
+ return 0;
+}
+
+static int schedule_group_thrmask(odp_schedule_group_t group,
+ odp_thrmask_t *thrmask)
+{
+ sched_group_t *sched_group = &sched_global.sched_group;
+
+ if (group < 0 || group >= NUM_GROUP)
+ return -1;
+
+ odp_ticketlock_lock(&sched_group->s.lock);
+
+ if (!sched_group->s.group[group].allocated) {
+ odp_ticketlock_unlock(&sched_group->s.lock);
+ return -1;
+ }
+
+ *thrmask = sched_group->s.group[group].mask;
+
+ odp_ticketlock_unlock(&sched_group->s.lock);
+
+ return 0;
+}
+
+static int schedule_group_info(odp_schedule_group_t group,
+ odp_schedule_group_info_t *info)
+{
+ sched_group_t *sched_group = &sched_global.sched_group;
+
+ if (group < 0 || group >= NUM_GROUP)
+ return -1;
+
+ odp_ticketlock_lock(&sched_group->s.lock);
+
+ if (!sched_group->s.group[group].allocated) {
+ odp_ticketlock_unlock(&sched_group->s.lock);
+ return -1;
+ }
+
+ info->name = sched_group->s.group[group].name;
+ info->thrmask = sched_group->s.group[group].mask;
+
+ odp_ticketlock_unlock(&sched_group->s.lock);
+
+ return 0;
+}
+
+static void schedule_order_lock(unsigned lock_index)
+{
+ (void)lock_index;
+}
+
+static void schedule_order_unlock(unsigned lock_index)
+{
+ (void)lock_index;
+}
+
/* Fill in scheduler interface */
const schedule_fn_t schedule_sp_fn = {
- .pktio_start = NULL,
- .thr_add = NULL,
- .thr_rem = NULL,
- .num_grps = NULL,
- .init_queue = NULL,
- .destroy_queue = NULL,
- .sched_queue = NULL,
+ .pktio_start = pktio_start,
+ .thr_add = thr_add,
+ .thr_rem = thr_rem,
+ .num_grps = num_grps,
+ .init_queue = init_queue,
+ .destroy_queue = destroy_queue,
+ .sched_queue = sched_queue,
+ .ord_enq = ord_enq,
+ .ord_enq_multi = ord_enq_multi,
.init_global = init_global,
.term_global = term_global,
.init_local = init_local,
@@ -50,22 +698,22 @@ const schedule_fn_t schedule_sp_fn = {
/* Fill in scheduler API calls */
const schedule_api_t schedule_sp_api = {
- .schedule_wait_time = NULL,
- .schedule = NULL,
- .schedule_multi = NULL,
- .schedule_pause = NULL,
- .schedule_resume = NULL,
- .schedule_release_atomic = NULL,
- .schedule_release_ordered = NULL,
- .schedule_prefetch = NULL,
- .schedule_num_prio = NULL,
- .schedule_group_create = NULL,
- .schedule_group_destroy = NULL,
- .schedule_group_lookup = NULL,
- .schedule_group_join = NULL,
- .schedule_group_leave = NULL,
- .schedule_group_thrmask = NULL,
- .schedule_group_info = NULL,
- .schedule_order_lock = NULL,
- .schedule_order_unlock = NULL
+ .schedule_wait_time = schedule_wait_time,
+ .schedule = schedule,
+ .schedule_multi = schedule_multi,
+ .schedule_pause = schedule_pause,
+ .schedule_resume = schedule_resume,
+ .schedule_release_atomic = schedule_release_atomic,
+ .schedule_release_ordered = schedule_release_ordered,
+ .schedule_prefetch = schedule_prefetch,
+ .schedule_num_prio = schedule_num_prio,
+ .schedule_group_create = schedule_group_create,
+ .schedule_group_destroy = schedule_group_destroy,
+ .schedule_group_lookup = schedule_group_lookup,
+ .schedule_group_join = schedule_group_join,
+ .schedule_group_leave = schedule_group_leave,
+ .schedule_group_thrmask = schedule_group_thrmask,
+ .schedule_group_info = schedule_group_info,
+ .schedule_order_lock = schedule_order_lock,
+ .schedule_order_unlock = schedule_order_unlock
};
commit 33bd749de8128afbb6b5bcad5ef6bea5a2667178
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Thu Jun 9 15:56:02 2016 +0300
vald: sched: bug corrections
Corrected bugs found during SP scheduler development. Scheduler
context (pause-resume) handling and drainging is now consistent
over all tests cases. Previously, some test cases returned with
scheduler context locked (didn't pause and drain before exiting
the loop). Added ASSERT_FATALs to limit error propagation, when
test application could not continue correct operation.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/validation/scheduler/scheduler.c b/test/validation/scheduler/scheduler.c
index ca04591..316370d 100644
--- a/test/validation/scheduler/scheduler.c
+++ b/test/validation/scheduler/scheduler.c
@@ -10,19 +10,19 @@
#define MAX_WORKERS_THREADS 32
#define MAX_ORDERED_LOCKS 2
-#define MSG_POOL_SIZE (4 * 1024 * 1024)
+#define MSG_POOL_SIZE (64 * 1024)
#define QUEUES_PER_PRIO 16
#define BUF_SIZE 64
-#define TEST_NUM_BUFS 100
+#define BUFS_PER_QUEUE 100
+#define BUFS_PER_QUEUE_EXCL 10000
#define BURST_BUF_SIZE 4
-#define NUM_BUFS_EXCL 10000
#define NUM_BUFS_PAUSE 1000
#define NUM_BUFS_BEFORE_PAUSE 10
+#define NUM_GROUPS 2
#define GLOBALS_SHM_NAME "test_globals"
#define MSG_POOL_NAME "msg_pool"
#define QUEUE_CTX_POOL_NAME "queue_ctx_pool"
-#define SHM_MSG_POOL_NAME "shm_msg_pool"
#define SHM_THR_ARGS_NAME "shm_thr_args"
#define ONE_Q 1
@@ -47,7 +47,6 @@
#define CHAOS_DEBUG (CHAOS_NUM_ROUNDS < 1000)
#define CHAOS_PTR_TO_NDX(p) ((uint64_t)(uint32_t)(uintptr_t)p)
#define CHAOS_NDX_TO_PTR(n) ((void *)(uintptr_t)n)
-#define CHAOS_WAIT_FAIL (5 * ODP_TIME_SEC_IN_NS)
#define ODP_WAIT_TOLERANCE (60 * ODP_TIME_MSEC_IN_NS)
@@ -63,7 +62,6 @@ typedef struct {
odp_queue_t handle;
char name[ODP_QUEUE_NAME_LEN];
} chaos_q[CHAOS_NUM_QUEUES];
- odp_atomic_u32_t chaos_pending_event_count;
} test_globals_t;
typedef struct {
@@ -99,6 +97,20 @@ typedef struct {
odp_pool_t pool;
odp_pool_t queue_ctx_pool;
+static int drain_queues(void)
+{
+ odp_event_t ev;
+ uint64_t wait = odp_schedule_wait_time(100 * ODP_TIME_MSEC_IN_NS);
+ int ret = 0;
+
+ while ((ev = odp_schedule(NULL, wait)) != ODP_EVENT_INVALID) {
+ odp_event_free(ev);
+ ret++;
+ }
+
+ return ret;
+}
+
static int exit_schedule_loop(void)
{
odp_event_t ev;
@@ -112,6 +124,8 @@ static int exit_schedule_loop(void)
ret++;
}
+ odp_schedule_resume();
+
return ret;
}
@@ -249,8 +263,7 @@ void scheduler_test_groups(void)
{
odp_pool_t p;
odp_pool_param_t params;
- odp_queue_param_t qp;
- odp_queue_t queue_grp1, queue_grp2, from;
+ odp_queue_t queue_grp1, queue_grp2;
odp_buffer_t buf;
odp_event_t ev;
uint32_t *u32;
@@ -339,7 +352,6 @@ void scheduler_test_groups(void)
CU_ASSERT(odp_thrmask_isset(&testmask, thr_id));
/* Now verify scheduler adherence to groups */
- odp_queue_param_init(&qp);
odp_pool_param_init(¶ms);
params.buf.size = 100;
params.buf.align = 0;
@@ -351,6 +363,13 @@ void scheduler_test_groups(void)
CU_ASSERT_FATAL(p != ODP_POOL_INVALID);
for (i = 0; i < 3; i++) {
+ odp_queue_param_t qp;
+ odp_queue_t queue, from;
+ odp_schedule_group_t mygrp[NUM_GROUPS];
+ odp_queue_t queue_grp[NUM_GROUPS];
+ int num = NUM_GROUPS;
+
+ odp_queue_param_init(&qp);
qp.type = ODP_QUEUE_TYPE_SCHED;
qp.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qp.sched.sync = sync[i];
@@ -369,7 +388,9 @@ void scheduler_test_groups(void)
u32[0] = MAGIC1;
ev = odp_buffer_to_event(buf);
- if (!(CU_ASSERT(odp_queue_enq(queue_grp1, ev) == 0)))
+ rc = odp_queue_enq(queue_grp1, ev);
+ CU_ASSERT(rc == 0);
+ if (rc)
odp_buffer_free(buf);
/* Now create and populate a queue in group 2 */
@@ -385,58 +406,70 @@ void scheduler_test_groups(void)
u32[0] = MAGIC2;
ev = odp_buffer_to_event(buf);
- if (!(CU_ASSERT(odp_queue_enq(queue_grp2, ev) == 0)))
+ rc = odp_queue_enq(queue_grp2, ev);
+ CU_ASSERT(rc == 0);
+ if (rc)
odp_buffer_free(buf);
- /* Scheduler should give us the event from Group 2 */
- ev = odp_schedule(&from, ODP_SCHED_WAIT);
- CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
- CU_ASSERT_FATAL(from == queue_grp2);
-
- buf = odp_buffer_from_event(ev);
- u32 = odp_buffer_addr(buf);
-
- CU_ASSERT_FATAL(u32[0] == MAGIC2);
-
- odp_buffer_free(buf);
-
- /* Scheduler should not return anything now since we're
- * not in Group 1 and Queue 2 is empty. Do this several
- * times to confirm.
- */
-
- for (j = 0; j < 10; j++) {
- ev = odp_schedule(&from, ODP_SCHED_NO_WAIT);
- CU_ASSERT_FATAL(ev == ODP_EVENT_INVALID)
- }
-
- /* Now join group 1 and verify we can get the event */
- rc = odp_schedule_group_join(mygrp1, &mymask);
- CU_ASSERT_FATAL(rc == 0);
+ /* Swap between two groups. Application should serve both
+ * groups to avoid potential head of line blocking in
+ * scheduler. */
+ mygrp[0] = mygrp1;
+ mygrp[1] = mygrp2;
+ queue_grp[0] = queue_grp1;
+ queue_grp[1] = queue_grp2;
+ j = 0;
+
+ /* Ensure that each test run starts from mygrp1 */
+ odp_schedule_group_leave(mygrp1, &mymask);
+ odp_schedule_group_leave(mygrp2, &mymask);
+ odp_schedule_group_join(mygrp1, &mymask);
+
+ while (num) {
+ queue = queue_grp[j];
+ ev = odp_schedule(&from, ODP_SCHED_NO_WAIT);
+
+ if (ev == ODP_EVENT_INVALID) {
+ /* change group */
+ rc = odp_schedule_group_leave(mygrp[j],
+ &mymask);
+ CU_ASSERT_FATAL(rc == 0);
+
+ j = (j + 1) % NUM_GROUPS;
+ rc = odp_schedule_group_join(mygrp[j],
+ &mymask);
+ CU_ASSERT_FATAL(rc == 0);
+ continue;
+ }
- /* Tell scheduler we're about to request an event.
- * Not needed, but a convenient place to test this API.
- */
- odp_schedule_prefetch(1);
+ CU_ASSERT_FATAL(from == queue);
- /* Now get the event from Queue 1 */
- ev = odp_schedule(&from, ODP_SCHED_WAIT);
- CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
- CU_ASSERT_FATAL(from == queue_grp1);
+ buf = odp_buffer_from_event(ev);
+ u32 = odp_buffer_addr(buf);
- buf = odp_buffer_from_event(ev);
- u32 = odp_buffer_addr(buf);
+ if (from == queue_grp1) {
+ /* CU_ASSERT_FATAL needs these brackets */
+ CU_ASSERT_FATAL(u32[0] == MAGIC1);
+ } else {
+ CU_ASSERT_FATAL(u32[0] == MAGIC2);
+ }
- CU_ASSERT_FATAL(u32[0] == MAGIC1);
+ odp_buffer_free(buf);
- odp_buffer_free(buf);
+ /* Tell scheduler we're about to request an event.
+ * Not needed, but a convenient place to test this API.
+ */
+ odp_schedule_prefetch(1);
- /* Leave group 1 for next pass */
- rc = odp_schedule_group_leave(mygrp1, &mymask);
- CU_ASSERT_FATAL(rc == 0);
+ num--;
+ }
- /* We must release order before destroying queues */
- odp_schedule_release_ordered();
+ /* Release schduler context and leave groups */
+ odp_schedule_group_join(mygrp1, &mymask);
+ odp_schedule_group_join(mygrp2, &mymask);
+ CU_ASSERT(exit_schedule_loop() == 0);
+ odp_schedule_group_leave(mygrp1, &mymask);
+ odp_schedule_group_leave(mygrp2, &mymask);
/* Done with queues for this round */
CU_ASSERT_FATAL(odp_queue_destroy(queue_grp1) == 0);
@@ -474,10 +507,12 @@ static int chaos_thread(void *arg)
start_time = odp_time_local();
/* Run the test */
- wait = odp_schedule_wait_time(CHAOS_WAIT_FAIL);
- for (i = 0; i < CHAOS_NUM_ROUNDS * CHAOS_NUM_EVENTS; i++) {
+ wait = odp_schedule_wait_time(5 * ODP_TIME_MSEC_IN_NS);
+ for (i = 0; i < CHAOS_NUM_ROUNDS; i++) {
ev = odp_schedule(&from, wait);
- CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
+ if (ev == ODP_EVENT_INVALID)
+ continue;
+
cbuf = odp_buffer_addr(odp_buffer_from_event(ev));
CU_ASSERT_FATAL(cbuf != NULL);
if (CHAOS_DEBUG)
@@ -495,33 +530,14 @@ static int chaos_thread(void *arg)
globals->
chaos_q[cbuf->seqno++ % CHAOS_NUM_QUEUES].handle,
ev);
- CU_ASSERT(rc == 0);
+ CU_ASSERT_FATAL(rc == 0);
}
if (CHAOS_DEBUG)
printf("Thread %d completed %d rounds...terminating\n",
odp_thread_id(), CHAOS_NUM_EVENTS);
- /* Thread complete--drain locally cached scheduled events */
- odp_schedule_pause();
-
- while (odp_atomic_load_u32(&globals->chaos_pending_event_count) > 0) {
- ev = odp_schedule(&from, ODP_SCHED_NO_WAIT);
- if (ev == ODP_EVENT_INVALID)
- break;
- odp_atomic_dec_u32(&globals->chaos_pending_event_count);
- cbuf = odp_buffer_addr(odp_buffer_from_event(ev));
- if (CHAOS_DEBUG)
- printf("Thread %d drained event %" PRIu64
- " seq %" PRIu64
- " from Q %s\n",
- odp_thread_id(), cbuf->evno, cbuf->seqno,
- globals->
- chaos_q
- [CHAOS_PTR_TO_NDX(odp_queue_context(from))].
- name);
- odp_event_free(ev);
- }
+ exit_schedule_loop();
end_time = odp_time_local();
diff = odp_time_diff(end_time, start_time);
@@ -529,7 +545,7 @@ static int chaos_thread(void *arg)
printf("Thread %d ends, elapsed time = %" PRIu64 "us\n",
odp_thread_id(), odp_time_to_ns(diff) / 1000);
- return CU_get_number_of_failures();
+ return 0;
}
static void chaos_run(unsigned int qtype)
@@ -539,24 +555,21 @@ static void chaos_run(unsigned int qtype)
odp_queue_param_t qp;
odp_buffer_t buf;
chaos_buf *cbuf;
- odp_event_t ev;
test_globals_t *globals;
thread_args_t *args;
odp_shm_t shm;
- odp_queue_t from;
int i, rc;
- uint64_t wait;
odp_schedule_sync_t sync[] = {ODP_SCHED_SYNC_PARALLEL,
ODP_SCHED_SYNC_ATOMIC,
ODP_SCHED_SYNC_ORDERED};
- const unsigned num_sync = (sizeof(sync) / sizeof(sync[0]));
+ const unsigned num_sync = (sizeof(sync) / sizeof(odp_schedule_sync_t));
const char *const qtypes[] = {"parallel", "atomic", "ordered"};
/* Set up the scheduling environment */
shm = odp_shm_lookup(GLOBALS_SHM_NAME);
CU_ASSERT_FATAL(shm != ODP_SHM_INVALID);
globals = odp_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL_FATAL(shm);
+ CU_ASSERT_PTR_NOT_NULL_FATAL(globals);
shm = odp_shm_lookup(SHM_THR_ARGS_NAME);
CU_ASSERT_FATAL(shm != ODP_SHM_INVALID);
@@ -580,7 +593,7 @@ static void chaos_run(unsigned int qtype)
qp.sched.group = ODP_SCHED_GROUP_ALL;
for (i = 0; i < CHAOS_NUM_QUEUES; i++) {
- uint32_t ndx = qtype == num_sync ? i % num_sync : qtype;
+ uint32_t ndx = (qtype == num_sync ? i % num_sync : qtype);
qp.sched.sync = sync[ndx];
snprintf(globals->chaos_q[i].name,
@@ -598,8 +611,6 @@ static void chaos_run(unsigned int qtype)
}
/* Now populate the queues with the initial seed elements */
- odp_atomic_init_u32(&globals->chaos_pending_event_count, 0);
-
for (i = 0; i < CHAOS_NUM_EVENTS; i++) {
buf = odp_buffer_alloc(pool);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
@@ -610,7 +621,6 @@ static void chaos_run(unsigned int qtype)
globals->chaos_q[i % CHAOS_NUM_QUEUES].handle,
odp_buffer_to_event(buf));
CU_ASSERT_FATAL(rc == 0);
- odp_atomic_inc_u32(&globals->chaos_pending_event_count);
}
/* Run the test */
@@ -621,26 +631,8 @@ static void chaos_run(unsigned int qtype)
printf("Thread %d returning from chaos threads..cleaning up\n",
odp_thread_id());
- /* Cleanup: Drain queues, free events */
- wait = odp_schedule_wait_time(CHAOS_WAIT_FAIL);
- while (odp_atomic_fetch_dec_u32(
- &globals->chaos_pending_event_count) > 0) {
- ev = odp_schedule(&from, wait);
- CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
- cbuf = odp_buffer_addr(odp_buffer_from_event(ev));
- if (CHAOS_DEBUG)
- printf("Draining event %" PRIu64
- " seq %" PRIu64 " from Q %s...\n",
- cbuf->evno,
- cbuf->seqno,
- globals->
- chaos_q
- [CHAOS_PTR_TO_NDX(odp_queue_context(from))].
- name);
- odp_event_free(ev);
- }
-
- odp_schedule_release_ordered();
+ drain_queues();
+ exit_schedule_loop();
for (i = 0; i < CHAOS_NUM_QUEUES; i++) {
if (CHAOS_DEBUG)
@@ -683,6 +675,7 @@ static int schedule_common_(void *arg)
buf_contents *bctx, *bctx_cpy;
odp_pool_t pool;
int locked;
+ int num;
globals = args->globals;
sync = args->sync;
@@ -697,7 +690,7 @@ static int schedule_common_(void *arg)
odp_event_t ev;
odp_buffer_t buf, buf_cpy;
odp_queue_t from = ODP_QUEUE_INVALID;
- int num = 0;
+ num = 0;
odp_ticketlock_lock(&globals->lock);
if (globals->buf_count == 0) {
@@ -711,6 +704,7 @@ static int schedule_common_(void *arg)
ev_cpy[BURST_BUF_SIZE];
odp_buffer_t buf_cpy[BURST_BUF_SIZE];
int j;
+
num = odp_schedule_multi(&from, ODP_SCHED_NO_WAIT,
events, BURST_BUF_SIZE);
CU_ASSERT(num >= 0);
@@ -764,9 +758,10 @@ static int schedule_common_(void *arg)
odp_event_free(events[j]);
} else {
ev = odp_schedule(&from, ODP_SCHED_NO_WAIT);
- buf = odp_buffer_from_event(ev);
- if (buf == ODP_BUFFER_INVALID)
+ if (ev == ODP_EVENT_INVALID)
continue;
+
+ buf = odp_buffer_from_event(ev);
num = 1;
if (sync == ODP_SCHED_SYNC_ORDERED) {
int ndx;
@@ -803,7 +798,7 @@ static int schedule_common_(void *arg)
if (args->enable_excl_atomic) {
locked = odp_spinlock_trylock(&globals->atomic_lock);
- CU_ASSERT(locked == 1);
+ CU_ASSERT(locked != 0);
CU_ASSERT(from != ODP_QUEUE_INVALID);
if (locked) {
int cnt;
@@ -824,6 +819,7 @@ static int schedule_common_(void *arg)
odp_schedule_release_ordered();
odp_ticketlock_lock(&globals->lock);
+
globals->buf_count -= num;
if (globals->buf_count < 0) {
@@ -885,7 +881,15 @@ static int schedule_common_(void *arg)
if (locked)
odp_ticketlock_unlock(&globals->lock);
- return CU_get_number_of_failures();
+ /* Clear scheduler atomic / ordered context between tests */
+ num = exit_schedule_loop();
+
+ CU_ASSERT(num == 0);
+
+ if (num)
+ printf("\nDROPPED %i events\n\n", num);
+
+ return 0;
}
static void fill_queues(thread_args_t *args)
@@ -897,6 +901,7 @@ static void fill_queues(thread_args_t *args)
int buf_count = 0;
test_globals_t *globals;
char name[32];
+ int ret;
globals = args->globals;
sync = args->sync;
@@ -924,7 +929,7 @@ static void fill_queues(thread_args_t *args)
"sched_%d_%d_o", i, j);
break;
default:
- CU_ASSERT(0);
+ CU_ASSERT_FATAL(0);
break;
}
@@ -944,7 +949,11 @@ static void fill_queues(thread_args_t *args)
odp_buffer_addr(buf);
bctx->sequence = qctx->sequence++;
}
- if (!(CU_ASSERT(odp_queue_enq(queue, ev) == 0)))
+
+ ret = odp_queue_enq(queue, ev);
+ CU_ASSERT_FATAL(ret == 0);
+
+ if (ret)
odp_buffer_free(buf);
else
buf_count++;
@@ -1000,17 +1009,16 @@ static void schedule_common(odp_schedule_sync_t sync, int num_queues,
globals = odp_shm_addr(shm);
CU_ASSERT_PTR_NOT_NULL_FATAL(globals);
+ memset(&args, 0, sizeof(thread_args_t));
args.globals = globals;
args.sync = sync;
args.num_queues = num_queues;
args.num_prio = num_prio;
- args.num_bufs = TEST_NUM_BUFS;
+ args.num_bufs = BUFS_PER_QUEUE;
args.num_workers = 1;
args.enable_schd_multi = enable_schd_multi;
args.enable_excl_atomic = 0; /* Not needed with a single CPU */
- /* resume scheduling in case it was paused */
- odp_schedule_resume();
fill_queues(&args);
schedule_common_(&args);
@@ -1041,16 +1049,13 @@ static void parallel_execute(odp_schedule_sync_t sync, int num_queues,
args->num_queues = num_queues;
args->num_prio = num_prio;
if (enable_excl_atomic)
- args->num_bufs = NUM_BUFS_EXCL;
+ args->num_bufs = BUFS_PER_QUEUE_EXCL;
else
- args->num_bufs = TEST_NUM_BUFS;
+ args->num_bufs = BUFS_PER_QUEUE;
args->num_workers = globals->num_workers;
args->enable_schd_multi = enable_schd_multi;
args->enable_excl_atomic = enable_excl_atomic;
- /* disable receive events for main thread */
- exit_schedule_loop();
-
fill_queues(args);
/* Create and launch worker threads */
@@ -1262,12 +1267,10 @@ void scheduler_test_pause_resume(void)
odp_queue_t from;
int i;
int local_bufs = 0;
-
- /* resume scheduling in case it was paused */
- odp_schedule_resume();
+ int ret;
queue = odp_queue_lookup("sched_0_0_n");
- CU_ASSERT(queue != ODP_QUEUE_INVALID);
+ CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
pool = odp_pool_lookup(MSG_POOL_NAME);
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
@@ -1276,13 +1279,17 @@ void scheduler_test_pause_resume(void)
buf = odp_buffer_alloc(pool);
CU_ASSERT_FATAL(buf != ODP_BUFFER_INVALID);
ev = odp_buffer_to_event(buf);
- if (odp_queue_enq(queue, ev))
+ ret = odp_queue_enq(queue, ev);
+ CU_ASSERT(ret == 0);
+
+ if (ret)
odp_buffer_free(buf);
}
for (i = 0; i < NUM_BUFS_BEFORE_PAUSE; i++) {
from = ODP_QUEUE_INVALID;
ev = odp_schedule(&from, ODP_SCHED_WAIT);
+ CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
CU_ASSERT(from == queue);
buf = odp_buffer_from_event(ev);
odp_buffer_free(buf);
@@ -1312,9 +1319,9 @@ void scheduler_test_pause_resume(void)
odp_buffer_free(buf);
}
- CU_ASSERT(exit_schedule_loop() == 0);
+ ret = exit_schedule_loop();
- odp_schedule_resume();
+ CU_ASSERT(ret == 0);
}
static int create_queues(void)
@@ -1466,7 +1473,7 @@ int scheduler_suite_init(void)
odp_pool_param_init(¶ms);
params.buf.size = BUF_SIZE;
params.buf.align = 0;
- params.buf.num = MSG_POOL_SIZE / BUF_SIZE;
+ params.buf.num = MSG_POOL_SIZE;
params.type = ODP_POOL_BUFFER;
pool = odp_pool_create(MSG_POOL_NAME, ¶ms);
commit 99b863c804fe38bd919d3b9c2f6dad5ddabf1aaa
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Thu Jun 9 15:56:01 2016 +0300
vald: timer: add missing pool param init calls
Added missing pool parameter init calls.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/validation/timer/timer.c b/test/validation/timer/timer.c
index ef31eba..33eb478 100644
--- a/test/validation/timer/timer.c
+++ b/test/validation/timer/timer.c
@@ -60,14 +60,15 @@ void timer_test_timeout_pool_alloc(void)
odp_event_t ev;
int index;
char wrong_type = 0;
- odp_pool_param_t params = {
- .tmo = {
- .num = num,
- },
- .type = ODP_POOL_TIMEOUT,
- };
+ odp_pool_param_t params;
+
+ odp_pool_param_init(¶ms);
+ params.type = ODP_POOL_TIMEOUT;
+ params.tmo.num = num;
pool = odp_pool_create("timeout_pool_alloc", ¶ms);
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
odp_pool_print(pool);
/* Try to allocate num items from the pool */
@@ -100,14 +101,14 @@ void timer_test_timeout_pool_free(void)
{
odp_pool_t pool;
odp_timeout_t tmo;
- odp_pool_param_t params = {
- .tmo = {
- .num = 1,
- },
- .type = ODP_POOL_TIMEOUT,
- };
+ odp_pool_param_t params;
+
+ odp_pool_param_init(¶ms);
+ params.type = ODP_POOL_TIMEOUT;
+ params.tmo.num = 1;
pool = odp_pool_create("timeout_pool_free", ¶ms);
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
odp_pool_print(pool);
/* Allocate the only timeout from the pool */
@@ -140,8 +141,10 @@ void timer_test_odp_timer_cancel(void)
odp_timer_set_t rc;
uint64_t tick;
- params.tmo.num = 1;
+ odp_pool_param_init(¶ms);
params.type = ODP_POOL_TIMEOUT;
+ params.tmo.num = 1;
+
pool = odp_pool_create("tmo_pool_for_cancel", ¶ms);
if (pool == ODP_POOL_INVALID)
@@ -476,8 +479,10 @@ void timer_test_odp_timer_all(void)
num_workers = 1;
/* Create timeout pools */
- params.tmo.num = (NTIMERS + 1) * num_workers;
+ odp_pool_param_init(¶ms);
params.type = ODP_POOL_TIMEOUT;
+ params.tmo.num = (NTIMERS + 1) * num_workers;
+
tbp = odp_pool_create("tmo_pool", ¶ms);
if (tbp == ODP_POOL_INVALID)
CU_FAIL_FATAL("Timeout pool create failed");
commit 8d10e64603e67620084cb92648707550110d7bbe
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Thu Jun 9 15:56:00 2016 +0300
linux-gen: pktio: added debug prints
Added couple of debug prints for easier pktio debug.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c
index 416a361..8d88aa3 100644
--- a/platform/linux-generic/odp_packet_io.c
+++ b/platform/linux-generic/odp_packet_io.c
@@ -677,7 +677,6 @@ int sched_cb_pktin_poll(int pktio_index, int num_queue, int index[])
odp_buffer_hdr_t *hdr_tbl[QUEUE_MULTI_MAX];
int num, idx;
pktio_entry_t *entry;
-
entry = pktio_entry_by_index(pktio_index);
if (odp_unlikely(is_free(entry))) {
@@ -689,8 +688,10 @@ int sched_cb_pktin_poll(int pktio_index, int num_queue, int index[])
if (odp_unlikely(entry->s.num_in_queue == 0))
return -1;
- if (entry->s.state != STATE_STARTED)
+ if (entry->s.state != STATE_STARTED) {
+ ODP_DBG("interface not started\n");
return 0;
+ }
for (idx = 0; idx < num_queue; idx++) {
queue_entry_t *qentry;
diff --git a/platform/linux-generic/pktio/loop.c b/platform/linux-generic/pktio/loop.c
index 75f6a0a..effad9a 100644
--- a/platform/linux-generic/pktio/loop.c
+++ b/platform/linux-generic/pktio/loop.c
@@ -151,9 +151,13 @@ static int loopback_send(pktio_entry_t *pktio_entry, int index ODP_UNUSED,
qentry = queue_to_qentry(pktio_entry->s.pkt_loop.loopq);
ret = queue_enq_multi(qentry, hdr_tbl, len, 0);
+
if (ret > 0) {
pktio_entry->s.stats.out_ucast_pkts += ret;
pktio_entry->s.stats.out_octets += bytes;
+ } else {
+ ODP_DBG("queue enqueue failed %i\n", ret);
+ return -1;
}
odp_ticketlock_unlock(&pktio_entry->s.txl);
commit 72634d86988e33ac38dd1ecda2cc4e8a156307ed
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Thu Jun 9 15:55:59 2016 +0300
linux-gen: sched: add sched_cb_queue_empty call
Added a new scheduler interface function, which may be used
to control empty queue scheduling. SP scheduler uses this
to ensure that empty queues are not stored into scheduler
queues.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_schedule_if.h b/platform/linux-generic/include/odp_schedule_if.h
index 0d82d84..86a117f 100644
--- a/platform/linux-generic/include/odp_schedule_if.h
+++ b/platform/linux-generic/include/odp_schedule_if.h
@@ -71,6 +71,7 @@ int sched_cb_queue_is_atomic(uint32_t queue_index);
odp_queue_t sched_cb_queue_handle(uint32_t queue_index);
void sched_cb_queue_destroy_finalize(uint32_t queue_index);
int sched_cb_queue_deq_multi(uint32_t queue_index, odp_event_t ev[], int num);
+int sched_cb_queue_empty(uint32_t queue_index);
/* API functions */
typedef struct {
diff --git a/platform/linux-generic/odp_queue.c b/platform/linux-generic/odp_queue.c
index e11c912..f3e589e 100644
--- a/platform/linux-generic/odp_queue.c
+++ b/platform/linux-generic/odp_queue.c
@@ -745,3 +745,29 @@ int sched_cb_queue_deq_multi(uint32_t queue_index, odp_event_t ev[], int num)
return ret;
}
+
+int sched_cb_queue_empty(uint32_t queue_index)
+{
+ queue_entry_t *queue = get_qentry(queue_index);
+ int ret = 0;
+
+ LOCK(&queue->s.lock);
+
+ if (odp_unlikely(queue->s.status < QUEUE_STATUS_READY)) {
+ /* Bad queue, or queue has been destroyed. */
+ UNLOCK(&queue->s.lock);
+ return -1;
+ }
+
+ if (queue->s.head == NULL) {
+ /* Already empty queue. Update status. */
+ if (queue->s.status == QUEUE_STATUS_SCHED)
+ queue->s.status = QUEUE_STATUS_NOTSCHED;
+
+ ret = 1;
+ }
+
+ UNLOCK(&queue->s.lock);
+
+ return ret;
+}
commit 341d3029f797ebb2bcf0fa6089c3463eea73e1cc
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Thu Jun 9 15:55:58 2016 +0300
linux-gen: sched: add ordered enq to schedule_fn_t
Added ordered enqueue functions to scheduler interface.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_schedule_if.h b/platform/linux-generic/include/odp_schedule_if.h
index 538d792..0d82d84 100644
--- a/platform/linux-generic/include/odp_schedule_if.h
+++ b/platform/linux-generic/include/odp_schedule_if.h
@@ -31,6 +31,11 @@ typedef int (*schedule_init_queue_fn_t)(uint32_t queue_index,
);
typedef void (*schedule_destroy_queue_fn_t)(uint32_t queue_index);
typedef int (*schedule_sched_queue_fn_t)(uint32_t queue_index);
+typedef int (*schedule_ord_enq_fn_t)(uint32_t queue_index, void *buf_hdr,
+ int sustain, int *ret);
+typedef int (*schedule_ord_enq_multi_fn_t)(uint32_t queue_index,
+ void *buf_hdr[], int num,
+ int sustain, int *ret);
typedef int (*schedule_init_global_fn_t)(void);
typedef int (*schedule_term_global_fn_t)(void);
typedef int (*schedule_init_local_fn_t)(void);
@@ -44,6 +49,8 @@ typedef struct schedule_fn_t {
schedule_init_queue_fn_t init_queue;
schedule_destroy_queue_fn_t destroy_queue;
schedule_sched_queue_fn_t sched_queue;
+ schedule_ord_enq_fn_t ord_enq;
+ schedule_ord_enq_multi_fn_t ord_enq_multi;
schedule_init_global_fn_t init_global;
schedule_term_global_fn_t term_global;
schedule_init_local_fn_t init_local;
diff --git a/platform/linux-generic/include/odp_schedule_ordered_internal.h b/platform/linux-generic/include/odp_schedule_ordered_internal.h
index acd62bc..0ffbe3a 100644
--- a/platform/linux-generic/include/odp_schedule_ordered_internal.h
+++ b/platform/linux-generic/include/odp_schedule_ordered_internal.h
@@ -13,10 +13,9 @@ extern "C" {
#define SUSTAIN_ORDER 1
-int schedule_ordered_queue_enq(queue_entry_t *queue, odp_buffer_hdr_t *buf_hdr,
+int schedule_ordered_queue_enq(uint32_t queue_index, void *p_buf_hdr,
int sustain, int *ret);
-int schedule_ordered_queue_enq_multi(queue_entry_t *queue,
- odp_buffer_hdr_t *buf_hdr[],
+int schedule_ordered_queue_enq_multi(uint32_t queue_index, void *p_buf_hdr[],
int num, int sustain, int *ret);
#ifdef __cplusplus
diff --git a/platform/linux-generic/odp_queue.c b/platform/linux-generic/odp_queue.c
index 58404d9..e11c912 100644
--- a/platform/linux-generic/odp_queue.c
+++ b/platform/linux-generic/odp_queue.c
@@ -397,7 +397,7 @@ int queue_enq(queue_entry_t *queue, odp_buffer_hdr_t *buf_hdr, int sustain)
{
int ret;
- if (schedule_ordered_queue_enq(queue, buf_hdr, sustain, &ret))
+ if (sched_fn->ord_enq(queue->s.index, buf_hdr, sustain, &ret))
return ret;
LOCK(&queue->s.lock);
@@ -436,8 +436,8 @@ int queue_enq_multi(queue_entry_t *queue, odp_buffer_hdr_t *buf_hdr[],
tail = buf_hdr[num - 1];
buf_hdr[num - 1]->next = NULL;
- if (schedule_ordered_queue_enq_multi(queue, buf_hdr, num, sustain,
- &ret))
+ if (sched_fn->ord_enq_multi(queue->s.index, (void **)buf_hdr, num,
+ sustain, &ret))
return ret;
/* Handle unordered enqueues */
diff --git a/platform/linux-generic/odp_schedule.c b/platform/linux-generic/odp_schedule.c
index b8d0d2a..3b97909 100644
--- a/platform/linux-generic/odp_schedule.c
+++ b/platform/linux-generic/odp_schedule.c
@@ -22,6 +22,7 @@
#include <odp/api/thrmask.h>
#include <odp_config_internal.h>
#include <odp_schedule_internal.h>
+#include <odp_schedule_ordered_internal.h>
#ifdef _ODP_PKTIO_IPC
#include <odp_pool_internal.h>
#endif
@@ -956,6 +957,8 @@ const schedule_fn_t schedule_default_fn = {
.init_queue = schedule_init_queue,
.destroy_queue = schedule_destroy_queue,
.sched_queue = schedule_sched_queue,
+ .ord_enq = schedule_ordered_queue_enq,
+ .ord_enq_multi = schedule_ordered_queue_enq_multi,
.init_global = schedule_init_global,
.term_global = schedule_term_global,
.init_local = schedule_init_local,
diff --git a/platform/linux-generic/odp_schedule_ordered.c b/platform/linux-generic/odp_schedule_ordered.c
index 17d3825..8c1dd7e 100644
--- a/platform/linux-generic/odp_schedule_ordered.c
+++ b/platform/linux-generic/odp_schedule_ordered.c
@@ -452,18 +452,19 @@ static int ordered_queue_enq(queue_entry_t *queue, odp_buffer_hdr_t *buf_hdr,
return 0;
}
-int schedule_ordered_queue_enq(queue_entry_t *queue,
- odp_buffer_hdr_t *buf_hdr,
+int schedule_ordered_queue_enq(uint32_t queue_index, void *p_buf_hdr,
int sustain, int *ret)
{
queue_entry_t *origin_qe;
uint64_t order;
+ queue_entry_t *qe = get_qentry(queue_index);
+ odp_buffer_hdr_t *buf_hdr = p_buf_hdr;
get_queue_order(&origin_qe, &order, buf_hdr);
/* Handle enqueues from ordered queues separately */
if (origin_qe) {
- *ret = ordered_queue_enq(queue, buf_hdr, sustain,
+ *ret = ordered_queue_enq(qe, buf_hdr, sustain,
origin_qe, order);
return 1;
}
@@ -471,19 +472,20 @@ int schedule_ordered_queue_enq(queue_entry_t *queue,
return 0;
}
-int schedule_ordered_queue_enq_multi(queue_entry_t *queue,
- odp_buffer_hdr_t *buf_hdr[],
+int schedule_ordered_queue_enq_multi(uint32_t queue_index, void *p_buf_hdr[],
int num, int sustain, int *ret)
{
queue_entry_t *origin_qe;
uint64_t order;
int rc;
+ queue_entry_t *qe = get_qentry(queue_index);
+ odp_buffer_hdr_t *buf_hdr = p_buf_hdr[0];
/* Handle ordered enqueues commonly via links */
- get_queue_order(&origin_qe, &order, buf_hdr[0]);
+ get_queue_order(&origin_qe, &order, buf_hdr);
if (origin_qe) {
- buf_hdr[0]->link = buf_hdr[0]->next;
- rc = ordered_queue_enq(queue, buf_hdr[0], sustain,
+ buf_hdr->link = buf_hdr->next;
+ rc = ordered_queue_enq(qe, buf_hdr, sustain,
origin_qe, order);
*ret = rc == 0 ? num : rc;
return 1;
commit 69717806018f61af84645ff458e3dc69a13d747e
Author: Petri Savolainen <petri.savolainen(a)nokia.com>
Date: Thu Jun 9 15:55:57 2016 +0300
helper: linux: correct pthread join retval check
Helper defines that pthread exit status is NULL on error,
but checks for != NULL. Both NULL and !NULL were returned
on failure.
Defined that both process and pthread return !0 (!NULL) on
failure.
Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/helper/linux.c b/helper/linux.c
index 8b9dbe8..a1dbe52 100644
--- a/helper/linux.c
+++ b/helper/linux.c
@@ -261,7 +261,7 @@ static void *odpthread_run_start_routine(void *arg)
ODPH_ERR("Local init failed\n");
if (start_args->linuxtype == ODPTHREAD_PROCESS)
_exit(EXIT_FAILURE);
- return NULL;
+ return (void *)-1;
}
ODPH_DBG("helper: ODP %s thread started as linux %s. (pid=%d)\n",
@@ -284,7 +284,7 @@ static void *odpthread_run_start_routine(void *arg)
_exit(status);
/* threads implementation return void* pointers: cast status to that. */
- return (void *)(long)status;
+ return (void *)(intptr_t)status;
}
/*
@@ -426,8 +426,10 @@ int odph_odpthreads_join(odph_odpthread_t *thread_tbl)
pid_t pid;
int i = 0;
int terminated = 0;
- int status = 0; /* child process return code (!=0 is error) */
- void *thread_ret; /* "child" thread return code (NULL is error) */
+ /* child process return code (!=0 is error) */
+ int status = 0;
+ /* "child" thread return code (!NULL is error) */
+ void *thread_ret = NULL;
int ret;
int retval = 0;
@@ -445,8 +447,11 @@ int odph_odpthreads_join(odph_odpthread_t *thread_tbl)
retval = -1;
} else {
terminated++;
- if (thread_ret != NULL)
+ if (thread_ret != NULL) {
+ ODPH_ERR("Bad exit status cpu #%d %p\n",
+ thread_tbl[i].cpu, thread_ret);
retval = -1;
+ }
}
pthread_attr_destroy(&thread_tbl[i].thread.attr);
break;
diff --git a/helper/test/thread.c b/helper/test/thread.c
index b290753..8268d9f 100644
--- a/helper/test/thread.c
+++ b/helper/test/thread.c
@@ -17,7 +17,7 @@ static void *worker_fn(void *arg TEST_UNUSED)
/* depend on the odp helper to call odp_term_local */
- return 0;
+ return NULL;
}
/* Create additional dataplane threads */
-----------------------------------------------------------------------
Summary of changes:
helper/linux.c | 15 +-
helper/test/thread.c | 2 +-
platform/linux-generic/include/odp_schedule_if.h | 8 +
.../include/odp_schedule_ordered_internal.h | 5 +-
platform/linux-generic/odp_packet_io.c | 5 +-
platform/linux-generic/odp_queue.c | 32 +-
platform/linux-generic/odp_schedule.c | 3 +
platform/linux-generic/odp_schedule_ordered.c | 18 +-
platform/linux-generic/odp_schedule_sp.c | 702 ++++++++++++++++++++-
platform/linux-generic/pktio/loop.c | 4 +
test/validation/scheduler/scheduler.c | 267 ++++----
test/validation/timer/timer.c | 33 +-
12 files changed, 901 insertions(+), 193 deletions(-)
hooks/post-receive
--
7 years, 10 months
- 1
- 0
[COMMIT] annotated tag v1.10.1.0 created. v1.10.1.0
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The annotated tag, v1.10.1.0 has been created
at c76a3e82d2fa7585314680e24f2756831bdabac0 (tag)
tagging b78d235b8fe23b423bf6e7a3c65abbfb7efa4af8 (commit)
replaces v1.10.0.0
tagged by Maxim Uvarov
on Tue Jun 14 19:35:59 2016 +0300
- Log -----------------------------------------------------------------
== OpenDataPlane (1.10.1.0)
=== New Features
==== APIs
ODP v1.10.1.0 is a maintenance release and as such introduces no new APIs or
other changes that might result in application source incompatibility with
v1.10.0.0.
==== Modular Scheduler
The ODP scheduler included as part of the `odp-linux` reference implementation
has been modularized to support a "pluggable" architecture that will permit
the easy introduction of alternate scheduler implementations that permit
both easy experimentation as well as alternate scheduling models that are
tuned to specific application workloads (_i.e.,_ a strict priority scheduler
for latency-sensitive workloads). Included in this release is the just the
foundation and alternate schedulers are expected to be added in future ODP
releases.
=== Packaging
==== Rename of `linux-generic` to `odp-linux`
While the platform name within the ODP git repository remains
`linux-generic`, the package name of this reference implementation has been
changed to `odp-linux` to better reflect that this is an implementation of
ODP that is dependent only on the Linux kernel and is intended to be runnable
on any Linux distribution. All ODP documentation has been changed to reflect
this name change.
=== Helpers
==== Introduction of "agnostic" threading support
The current helper APIs for linux pthreads (`odph_linux_pthread_create()`, etc.)
and processes (`odph_linux_process_fork()`, etc.) have been augmented with a
new "agnostic" set of helper routines for general ODP thread management.
`odph_odpthreads_create()` and `odph_odpthreads_join()` are now the preferred
helpers to use for creating and joining threads that may be implemented as
_either_ pthreads or Linux processes. Although currently ODP threads in
Monarch are assumed to share the same (single) address space, this change is
to permit evolution towards multi-address space (_i.e.,_ process oriented)
threading models without requiring application and/or validation test changes.
The various ODP examples and validation tests that make use of threading have
all been changed to new these new helper APIs.
==== Thread affinity APIs
As part of the new "agnostic" threading support, two additional helper APIs
(`odph_odpthread_getaffinity()` and `odph_odpthread_setaffinity()`) have been
added to permit easy management of thread affinity.
The CUnit framework used by the ODP validation suite has been changed to set
the affinity of the initial thread to the first available control CPU. This
avoids inconsistencies in a number of timing tests.
=== Bug Fixes
As a maintenance release, numerous bugs have been fixed in the `odp-linux`
reference implementation in areas such as platform support (particularly on
32-bit systems), compiler support (clang), C++ compatibility, and other
cleanup items. Highlights include:
==== 32-bit platform support
The `configure` utility now correctly identifies and sets variables needed for
proper compilation on 32-bit x86 systems. In addition the Traffic Manager
now executes properly on 32-bit systems.
==== Timer improvements
The `odp_timer_t` abstract type is now strongly typed for consistency with
other ODP types, and the `odp_timer_to_u64()` and `odp_timer_pool_to_u64()`
APIs are now properly implemented. In addition, an issue with compiling the
timer routines on 32-bit systems using clang was resolved.
==== Scheduler fairness
The default scheduler has been improved to avoid starvation and increase
fairness when running with a limited number of threads or CPUs.
==== 128-bit atomics
The `-mcx16` compiler option is now properly identified and used to support
128-bit atomics on systems that support these operations. This leads to
increased efficiency in the implementation of both timers as well as other
atomic operations.
==== Use of hugepages
In systems that support multiple hugepage sizes, the default hugepage size is
now reported properly by the `odp_sys_huge_page_size()` API.
==== Coverity and Valgrind issue cleanup
Numerous issues identified by the Coverity scan tool have been cleaned up
and resolved, leading to improved robustness in the `odp-linux` reference
implementation. In addition, several memory leaks identified by the valgrind
tool have been fixed.
==== Validation test resource checks
The Traffic Manager validation test has certain sub-tests that require a
minimum of 2 CPUs to operate properly. These tests are now skipped with a
warning when run on uniprocessor systems.
=== Performance
Performance enhancements in the `odp-linux` reference implementation have been
made in packet processing, classification, and pktio, leading to increased
observed throughput and packet handling rates.
=== Examples
A new `l2fwd_simple` example has been added that does simple Layer 2 forwarding.
=== Documentation
==== Switch from AsciiDoc to AsciiDoctor
To get better formatting capabilities and future extensibility the ODP user
documentation system has been switched from http://asciidoc.org[AsciiDoc] to
http://asciidoctor.org[AsciiDoctor]. There are a handful of notable changes as
a result of this. Those submitting documentation patches should be aware of
the following:
* `monospace font` is now indicated by demarking the text with backticks (`)
rather than plus signs (+).
* Callouts are now indicated by C++-style double slash comments (// <1>)
instead of C-style comments (/* <1> */). So, for example writing
-----------------------------------------------
[source,c]
----
...some great code deserving a callout // \<1>
----
<1> This is an example of a callout
-----------------------------------------------
yields:
----
...some great code deserving a callout // <1>
----
<1> This is an example of a callout
Note that this change only affects user documentation. Code documentation
still uses http://doxygen.org[Doxygen].
==== Image Cleanup
The images in the user guide have been trimmed to fit the page better. In
addition, many new images have been added to better illustrate ODP API usage.
==== Additional User Documentation for Monarch APIs
The *ODP User's Guide* has been updated to include new sections documenting
the use of the full Monarch packet APIs as well as the Timer APIs. In
addition, the crypto, classification, and traffic manager API documentation
has been improved to cover all of the latest Monarch features, and an
introductory section on overall ODP packet flow architecture has been added.
==== Helper Documentation
The ODP Helper library now has its own document that describes these additional
functions of use to ODP applications and validation tests.
==== Other documentation
The Process Guide, FAQ, CONTRIBUTING, and CHANGELOG files have been reworked
for the new AsciiDoctor structure, leading to a more uniform method of
presenting ODP support documentation. In addition, an option for generating
both a "pure" ODP API document that defines the APIs in their
implementation-independent forms as well as their implementation-dependent
forms for the `odp-linux` reference implementation is now available.
=== Known Issues
==== https://bugs.linaro.org/show_bug.cgi?id=2301[Bug 2301]
The scheduler does not remove PKTIN queues following `odp_pktio_close()`
==== https://bugs.linaro.org/show_bug.cgi?id=2309[Bug 2309]
The timer validation tests have seen occasional failures when run on systems
containing a larger number of CPUs (typically 24 or more).
Anders Roxell (3):
helper/test: add missing scripts to EXTRA_DIST
linux-generic: include: drv: std_types.h: fix cyclic include
example/timer: don't run test if configure flag not set
Balakrishna Garapati (1):
test: performance: return when pkt alloc fails
Balasubramanian Manoharan (3):
linux-generic: classification:fix uninitialized pmr param value
doc: users-guide: add packet marking documentation
doc: users-guide: add packet drop and error CoS documentation
Barry Spinney (8):
linux-generic: traffic-mngr: fix printing on 32-bit platforms
linux-generic: traffic-mngr: 32-bit platform fixes
validation: traffic-mngr: fixes to support 32-bit platforms
linux-generic: tm: fix compile error on 32-bit platforms
linux-generic: tm: completed implementing _odp_timer_wheel_destroy
linux-generic: tm: fix an off by one error
linux-generic: tm: fix memory leaks
linux-generic: tm: fix more memory leaks
Bill Fischofer (33):
linux-generic: init: comment out last local stage to avoid scan issues
doc: userguide: change plus to backtick for asciidoctor
doc: userguide: add sub-documents and images to list of source files
doc: userguide: split packet section into its own sub document
doc: userguide: revise packet segment image to account for extend/trunc
doc: userguide: add extend/trunc doc
doc: userguide: add additional images for packet processing
doc: userguide: add descriptions of new packet manipulation APIs
linux-generic: arch: add missing cache line size definition for linux
doc: userguide: trim images for better fit
linux-generic: queue: avoid leakage on queue create
linux-generic: includes: typo correction
doc: guides: remove extraneous non-ascii characters from doc files
validation: timer: verify timer successfully allocated
doc: userguide: add timer/timeout state diagrams
doc: userguide: add timer and timeout event section to user guide
test: packet: remove unused values
configure: whitespace cleanup
configure: add check for gcc version
example: tm: remove unused code
example: tm: check rc from odp init calls
validation: tm: add debug check to avoid unreachable code
validation: tm: handle pktio open/config failures properly
validation: tm: avoid potential null pointer dereference
linux-generic: tm: avoid underflow on log2 of 0
linux-generic: tm: check for proper init of tm_system_thread
linux-generic: tm: discard rc values properly when not needed
linux-generic: tm: avoid potential null pointer dereference
linux-generic: tm: replace printf with odp_dbg calls
example: l2fwd: use parameterized array to avoid memory corruption
linux-generic: tm: parameterize use of secondary_hash_dump() routine
validation: tm: avoid resouce/memory leaks in corner cases
changelog: update for v1.10.1.0
Christophe Milard (37):
validation: lock: tuning the iteration number
helpers: adding command line argument parsing
validation: common: adding command line argument parsing
validation: shmem: adding command line argument parsing
helpers: linux: creating functions to handle odpthreads
helper: test: adding odpthread functions tests
validation: using implementation agnostic function for ODP threads
validation: most tests: adding command line argument parsing
validation: init: adding command line argument parsing
validation: pktio: adding command line argument parsing
performance: odp_scheduling: proc mode done by helper
performance: odp_pktio_perf: using agnostic function for ODP threads
performance: odp_pktio_perf: adding helper cmd line parsing
performance: odp_l2fwd: using agnostic function for ODP threads
performance: odp_l2fwd: adding helper cmd line parsing
performance: crypto: using agnostic function for ODP threads
performance: crypto: adding helper cmd line parsing
example: classifier: using agnostic function for ODP threads
example: classifier: adding helper cmd line parsing
example: generator: using agnostic function for ODP threads
example: generator: adding helper cmd line parsing
example: ipsec: using agnostic function for ODP threads
example: ipsec: adding helper cmd line parsing
example: l2fwd_simple: using agnostic function for ODP threads
example: l2fwd_simple: adding helper cmd line parsing
example: pktio: using agnostic function for ODP threads
example: pktio: adding helper cmd line parsing
example: time: using agnostic function for ODP threads
example: time: adding helper cmd line parsing
example: timer: using agnostic function for ODP threads
example: timer: adding helper cmd line parsing
example: switch: using agnostic function for ODP threads
example: switch: adding helper cmd line parsing
linux-generic: test: ringtest: using agnostic function for ODP threads
linux-generic: test: ringtest: adding helper cmd line parsing
doc: implementers-guide: adding helper recommendations
helper: fix doxygen comments for odpthread creation parameters
Matias Elo (18):
configure: detect ARCH correctly for 32-bit x86 hosts
time: fix invalid casting on a 32-bit host
linux-generic: timer: add missing odp_timeX_to_u64() functions
linux-generic: timer: use strong typing
linux-generic: dpdk: use memset() to initialize dev_info
linux-generic: packet: remove l3_protocol and l4_protocol members from odp_packet_hdr_t
linux-generic: packet: remove vlan_s_tag and vlan_c_tag members from odp_packet_hdr_t
linux-generic: packet: remove payload_offset member from odp_packet_hdr_t
linux-generic: buffer: ifdef ipc_addr_offset member from odp_buffer_hdr_t
linux-generic: packet: initialize only selected odp_packet_hdr_t members
linux-generic: pktio: add pktio type specific print function
linux-generic: pktio: print maximum input/output queue counts in odp_pktio_print()
linux-gen: netmap: handle modified _odp_packet_cls_enq() return values correctly
linux-gen: packet: increase input flags bit field size to 64 bits
linux-gen: pktio: remove old single queue recv and send functions
linux-gen: pktio: don't allocate new packets in classifier
linux-generic: dpdk: remove unnecessary rte_pktmbuf_reset call
linux-gen: pktio: fix variable overwrite in pktin_recv_buf
Maxim Uvarov (23):
linux-generic: pktio: ipc: remove not needed assignment
validation: timer: fix handle unused tmo
validation: time: remove print and add verbose faults
validation: pktio: fix assert for odp_pktin_queue ret code
linux-generic:pktio mmap: fix nb_rx overflow
validation: pktio: initialize pkt_seq
linux-generic: use default huge page size
linux-generic: drop odp_ prefix for internal cpuinfo
autotools: define test extensions to skip on valgrind test
linux-generic: timer: disable 128 bit timer optimization for clang
Revert "doc: process: add FAQ document"
Revert "doc: images: add new images for the FAQ"
Revert "example: use one copy of pcap file"
Revert "doc: generate a pure application-api-guide"
linux-generic: remove not used queue_handle function
linux-generic: test: fix ring resource leaks
validation: sched: fix out of array reference
linux-generic: timer fix odp_timer_pool_create return code
linux-generic: sched: do not allocate sheduler info in shm area
linux-generic: tm: init pthread attrs
example: timer simple
example: timer: add cunit artifacts to gitignore
update version number from v1.10.0.0 to v1.10.1.0
Mike Holmes (24):
doc: support asciidoctor
linux-generic: correctly set arch as undefined
doc: api guide: remove incorrect include
doc: api guide: use default cfg file name Doxyfile
doc: api guide: look directly in api guide dir for src
doc: images: add helper lib to overview
doc: helper guide: add initial version
helper: add linux documentation section
helper: add strong types documentation section
helper: add chksum documentation section
doc: images: add packet flow overview image
doc: users-guide: depend on the images
doc: users-guide: add packet flow overview
doc: process-guide: convert CONTRIBUTING to asciidoc
example: fix pcap location assumption
example: use one copy of pcap file
doc: images: add new images for the FAQ
doc: process: add FAQ document
doc: images: add new images for the FAQ
doc: process: add FAQ document
doc: generate a pure application-api-guide
doc: doxygen: fix distribution build
doc: process: fix distribution build
doc: process: generate html change log
Nikhil Agarwal (1):
doc: user-guide: Improve crypto section.
Ola Liljedahl (3):
linux-generic: odp_atomic_internal.h: add 128-bit atomics
linux-generic: timer: fix failed static assert
linux-generic: timer: generalize arch-specific code path selection
Oriol Arcas (1):
helper: chksum: fix type casting for C++ include
Petri Savolainen (23):
test: scheduling: simplify code structure
test: scheduling: add scheduler fairness check
linux-generic: scheduler: avoid starvation
linux-generic: schedule: remove static function prototype from header
linux-generic: schedule: introduce scheduler interfaces
linux-generic: pktio: use handle on api functions
linux-generic: schedule: clean interface towards pktio
linux-generic: schedule: move schedule group mask into scheduler
linux-generic: schedule: clean up dependency to config interface
linux-generic: schedule: start decouple from queue internals
linux-generic: schedule: move ordered queue code to a new file
linux-generic: schedule: rename schedule interface header
linux-generic: schedule: move local struct into internal header
linux-generic: schedule: remove queue internal depencies
linux-generic: config: remove duplicate defines
linux-generic: implementation name is odp-linux
linux-gen: ring: volatile head and tail types
test: ring: simplify ring stress test
linux-generic: sched: add init functions to interface
linux-generic: sched: add api interface struct
linux-generic: sched: add sched params to queue init
linux-generic: sched: add skeleton for strict priority
linux-generic: sched: bind default scheduler api calls
Yi He (6):
linux-generic: test: ring: convert to cunit and improve coverage
linux-generic: test: ring: .gitignore ring_main
helper: linux: odp thread cpu affinity APIs
linux-generic: shared memory: fix the name composition in odp_shm_free
linux-generic: pktio: ipc: _ring_tailq_init() at global init
linux-generic: pktio: ring: add _ring_destroy()
Zoltan Kiss (4):
linux-generic: classification: release the packet as soon as an error happens
linux-generic: pktio: classification error handling fixes for loop
linux-generic: pktio: don't return packet after failed enqueue
linux-generic: classification: use proper accessor to set packet length
-----------------------------------------------------------------------
hooks/post-receive
--
7 years, 10 months
- 1
- 0
[COMMIT] branch master updated. v1.10.0.0-188-gb78d235
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via b78d235b8fe23b423bf6e7a3c65abbfb7efa4af8 (commit)
from 193bbc8eafa14932f342476a44687237be512148 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit b78d235b8fe23b423bf6e7a3c65abbfb7efa4af8
Author: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Date: Tue Jun 14 15:22:24 2016 +0300
update version number from v1.10.0.0 to v1.10.1.0
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Reviewed-by: Anders Roxell <anders.roxell(a)linaro.org>
diff --git a/configure.ac b/configure.ac
index a12f984..3851ebd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -12,7 +12,7 @@ AM_SILENT_RULES([yes])
##########################################################################
# Set correct platform library version
##########################################################################
-ODP_LIBSO_VERSION=110:0:0
+ODP_LIBSO_VERSION=110:0:1
AC_SUBST(ODP_LIBSO_VERSION)
# Checks for programs.
diff --git a/include/odp/api/spec/version.h b/include/odp/api/spec/version.h
index 6220f37..aa3f3ab 100644
--- a/include/odp/api/spec/version.h
+++ b/include/odp/api/spec/version.h
@@ -54,7 +54,7 @@ extern "C" {
* to the API. For an API with common generation and major version, but with
* different minor numbers the two versions are backward compatible.
*/
-#define ODP_VERSION_API_MINOR 0
+#define ODP_VERSION_API_MINOR 1
/**
* ODP API version string
-----------------------------------------------------------------------
Summary of changes:
configure.ac | 2 +-
include/odp/api/spec/version.h | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
hooks/post-receive
--
7 years, 10 months
- 1
- 0
[COMMIT] branch master updated. v1.10.0.0-187-g193bbc8
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 193bbc8eafa14932f342476a44687237be512148 (commit)
from 165897bfd094d824e2dd83c968ad9fde28146ef9 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 193bbc8eafa14932f342476a44687237be512148
Author: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Date: Tue Jun 14 15:24:35 2016 +0300
example: timer: add cunit artifacts to gitignore
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
Reviewed-by Mike Holmes <mike.holmes(a)linaro.org>
diff --git a/example/timer/.gitignore b/example/timer/.gitignore
index f53a0df..eaa9a36 100644
--- a/example/timer/.gitignore
+++ b/example/timer/.gitignore
@@ -1,2 +1,4 @@
+*.log
+*.trs
odp_timer_test
odp_timer_simple
-----------------------------------------------------------------------
Summary of changes:
example/timer/.gitignore | 2 ++
1 file changed, 2 insertions(+)
hooks/post-receive
--
7 years, 10 months
- 1
- 0
[COMMIT] branch master updated. v1.10.0.0-186-g165897b
by git＠git-us.linaro.org
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "".
The branch, master has been updated
via 165897bfd094d824e2dd83c968ad9fde28146ef9 (commit)
from 4e4ae44b527a9a0635a219eb19e1ffa425c2186a (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 165897bfd094d824e2dd83c968ad9fde28146ef9
Author: Zoltan Kiss <zoltan.kiss(a)linaro.org>
Date: Mon Jun 13 17:46:27 2016 +0100
linux-generic: classification: use proper accessor to set packet length
And repurpose packet_set_len() for this, as it is no longer used.
This was introduced by the following commit, and break compatibility with
ODP-DPDK:
bd18047a "linux-gen: pktio: don't allocate new packets in classifier"
Signed-off-by: Zoltan Kiss <zoltan.kiss(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Reviewed-by: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_packet_internal.h b/platform/linux-generic/include/odp_packet_internal.h
index d5ace12..a84a6f8 100644
--- a/platform/linux-generic/include/odp_packet_internal.h
+++ b/platform/linux-generic/include/odp_packet_internal.h
@@ -278,9 +278,9 @@ static inline uint32_t packet_len(odp_packet_hdr_t *pkt_hdr)
return pkt_hdr->frame_len;
}
-static inline void packet_set_len(odp_packet_t pkt, uint32_t len)
+static inline void packet_set_len(odp_packet_hdr_t *pkt_hdr, uint32_t len)
{
- odp_packet_hdr(pkt)->frame_len = len;
+ pkt_hdr->frame_len = len;
}
static inline int packet_parse_l2_not_done(odp_packet_hdr_t *pkt_hdr)
diff --git a/platform/linux-generic/odp_classification.c b/platform/linux-generic/odp_classification.c
index 7520bdc..d2cc081 100644
--- a/platform/linux-generic/odp_classification.c
+++ b/platform/linux-generic/odp_classification.c
@@ -815,7 +815,7 @@ int cls_classify_packet(pktio_entry_t *entry, const uint8_t *base, uint16_t len,
cos_t *cos;
packet_parse_reset(pkt_hdr);
- pkt_hdr->frame_len = len;
+ packet_set_len(pkt_hdr, len);
_odp_parse_common(pkt_hdr, base);
cos = cls_select_cos(entry, base, pkt_hdr);
-----------------------------------------------------------------------
Summary of changes:
platform/linux-generic/include/odp_packet_internal.h | 4 ++--
platform/linux-generic/odp_classification.c | 2 +-
2 files changed, 3 insertions(+), 3 deletions(-)
hooks/post-receive
--
7 years, 10 months
- 1
- 0