[v5,3/3] linux-generic: classification initial implementation

Message ID 1417838383-3215-3-git-send-email-bala.manoharan@linaro.org
State New
Headers show

Commit Message

Balasubramanian Manoharan Dec. 6, 2014, 3:59 a.m.
The following features are implemented in this classification implementation:
* Attaches PMR, PMR_SET to a Pktio entry
* Adds classifier object to pktio entry
* Attaches CoS values for L2 and L3 QoS to a Pktio entry
* Selects ClassOfService for a packet based on PMR, L2 QoS and L3 QoS values
* Selects a default CoS if packet does not match any of the assigned rules
* Selects an Error CoS for an Error packet
* Enqueues the packet to the queue associated with the selected CoS

Signed-off-by: Balasubramanian Manoharan <bala.manoharan@linaro.org>
---
 helper/include/odph_ip.h                           |   6 +
 platform/linux-generic/include/api/odp.h           |   1 +
 .../include/odp_buffer_pool_internal.h             |   9 +
 .../include/odp_classification_datamodel.h         | 201 +++++
 .../include/odp_classification_inlines.h           | 259 ++++++
 .../include/odp_classification_internal.h          | 173 ++++
 platform/linux-generic/include/odp_internal.h      |   2 +
 .../linux-generic/include/odp_packet_io_internal.h |   2 +
 platform/linux-generic/odp_buffer_pool.c           |  10 -
 platform/linux-generic/odp_classification.c        | 878 +++++++++++++++++++--
 platform/linux-generic/odp_init.c                  |   4 +
 platform/linux-generic/odp_packet_io.c             |  47 +-
 12 files changed, 1493 insertions(+), 99 deletions(-)
 create mode 100644 platform/linux-generic/include/odp_classification_datamodel.h
 create mode 100644 platform/linux-generic/include/odp_classification_inlines.h
 create mode 100644 platform/linux-generic/include/odp_classification_internal.h

Comments

Balasubramanian Manoharan Dec. 6, 2014, 4:16 a.m. | #1
These patches are available in the following public repo

http://git.linaro.org/people/bala.manoharan/classification.git

Regards,
Bala

On 6 December 2014 at 09:29, Balasubramanian Manoharan <
bala.manoharan@linaro.org> wrote:

> The following features are implemented in this classification
> implementation:
> * Attaches PMR, PMR_SET to a Pktio entry
> * Adds classifier object to pktio entry
> * Attaches CoS values for L2 and L3 QoS to a Pktio entry
> * Selects ClassOfService for a packet based on PMR, L2 QoS and L3 QoS
> values
> * Selects a default CoS if packet does not match any of the assigned rules
> * Selects an Error CoS for an Error packet
> * Enqueues the packet to the queue associated with the selected CoS
>
> Signed-off-by: Balasubramanian Manoharan <bala.manoharan@linaro.org>
> ---
>  helper/include/odph_ip.h                           |   6 +
>  platform/linux-generic/include/api/odp.h           |   1 +
>  .../include/odp_buffer_pool_internal.h             |   9 +
>  .../include/odp_classification_datamodel.h         | 201 +++++
>  .../include/odp_classification_inlines.h           | 259 ++++++
>  .../include/odp_classification_internal.h          | 173 ++++
>  platform/linux-generic/include/odp_internal.h      |   2 +
>  .../linux-generic/include/odp_packet_io_internal.h |   2 +
>  platform/linux-generic/odp_buffer_pool.c           |  10 -
>  platform/linux-generic/odp_classification.c        | 878
> +++++++++++++++++++--
>  platform/linux-generic/odp_init.c                  |   4 +
>  platform/linux-generic/odp_packet_io.c             |  47 +-
>  12 files changed, 1493 insertions(+), 99 deletions(-)
>  create mode 100644
> platform/linux-generic/include/odp_classification_datamodel.h
>  create mode 100644
> platform/linux-generic/include/odp_classification_inlines.h
>  create mode 100644
> platform/linux-generic/include/odp_classification_internal.h
>
> diff --git a/helper/include/odph_ip.h b/helper/include/odph_ip.h
> index 2c83c0f..f78724e 100644
> --- a/helper/include/odph_ip.h
> +++ b/helper/include/odph_ip.h
> @@ -35,6 +35,9 @@ extern "C" {
>  /** @internal Returns IPv4 header length */
>  #define ODPH_IPV4HDR_IHL(ver_ihl) ((ver_ihl) & 0x0f)
>
> +/** @internal Returns IPv4 DSCP */
> +#define ODPH_IPV4HDR_DSCP(tos) (((tos) & 0xfc) >> 2)
> +
>  /** @internal Returns IPv4 Don't fragment */
>  #define ODPH_IPV4HDR_FLAGS_DONT_FRAG(frag_offset)  ((frag_offset) &
> 0x4000)
>
> @@ -47,6 +50,9 @@ extern "C" {
>  /** @internal Returns true if IPv4 packet is a fragment */
>  #define ODPH_IPV4HDR_IS_FRAGMENT(frag_offset) ((frag_offset) & 0x3fff)
>
> +/** @internal Returns IPv4 DSCP */
> +#define ODPH_IPV6HDR_DSCP(ver_tc_flow) (uint8_t)((((ver_tc_flow) &
> 0x0fc00000) >> 22) & 0xff)
> +
>  /** IPv4 header */
>  typedef struct ODP_PACKED {
>         uint8_t    ver_ihl;     /**< Version / Header length */
> diff --git a/platform/linux-generic/include/api/odp.h
> b/platform/linux-generic/include/api/odp.h
> index 6e4f69e..b7b1ca9 100644
> --- a/platform/linux-generic/include/api/odp.h
> +++ b/platform/linux-generic/include/api/odp.h
> @@ -47,6 +47,7 @@ extern "C" {
>  #include <odp_packet_flags.h>
>  #include <odp_packet_io.h>
>  #include <odp_crypto.h>
> +#include <odp_classification.h>
>  #include <odp_rwlock.h>
>
>  #ifdef __cplusplus
> diff --git a/platform/linux-generic/include/odp_buffer_pool_internal.h
> b/platform/linux-generic/include/odp_buffer_pool_internal.h
> index e0210bd..07602fe 100644
> --- a/platform/linux-generic/include/odp_buffer_pool_internal.h
> +++ b/platform/linux-generic/include/odp_buffer_pool_internal.h
> @@ -22,6 +22,7 @@ extern "C" {
>  #include <odp_buffer_pool.h>
>  #include <odp_buffer_internal.h>
>  #include <odp_align.h>
> +#include <odp_align_internal.h>
>  #include <odp_hints.h>
>  #include <odp_config.h>
>  #include <odp_debug.h>
> @@ -64,6 +65,10 @@ struct pool_entry_s {
>         size_t                  hdr_size;
>  };
>
> +typedef union pool_entry_u {
> +       struct pool_entry_s s;
> +       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct
> pool_entry_s))];
> +} pool_entry_t;
>
>  extern void *pool_entry_ptr[];
>
> @@ -73,6 +78,10 @@ static inline void *get_pool_entry(uint32_t pool_id)
>         return pool_entry_ptr[pool_id];
>  }
>
> +static inline uint32_t pool_handle_to_index(odp_buffer_pool_t pool_hdl)
> +{
> +       return pool_hdl - 1;
> +}
>
>  static inline odp_buffer_hdr_t *odp_buf_to_hdr(odp_buffer_t buf)
>  {
> diff --git a/platform/linux-generic/include/odp_classification_datamodel.h
> b/platform/linux-generic/include/odp_classification_datamodel.h
> new file mode 100644
> index 0000000..18846bc
> --- /dev/null
> +++ b/platform/linux-generic/include/odp_classification_datamodel.h
> @@ -0,0 +1,201 @@
> +/* Copyright (c) 2014, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier:     BSD-3-Clause
> + */
> +
> +
> +/**
> + * @file
> + *
> + * ODP Classification Datamodel
> + * Describes the classification internal data model
> + */
> +
> +#ifndef ODP_CLASSIFICATION_DATAMODEL_H_
> +#define ODP_CLASSIFICATION_DATAMODEL_H_
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#include <odp_spinlock.h>
> +#include <odp_classification.h>
> +#include <odp_buffer_pool_internal.h>
> +#include <odp_packet_internal.h>
> +#include <odp_packet_io_internal.h>
> +#include <odp_queue_internal.h>
> +
> +/* Maximum Class Of Service Entry */
> +#define ODP_COS_MAX_ENTRY              64
> +/* Maximum PMR Set Entry */
> +#define ODP_PMRSET_MAX_ENTRY           64
> +/* Maximum PMR Entry */
> +#define ODP_PMR_MAX_ENTRY              64
> +/* Maximum PMR Terms in a PMR Set */
> +#define ODP_PMRTERM_MAX                        8
> +/* Maximum PMRs attached in PKTIO Level */
> +#define ODP_PKTIO_MAX_PMR              8
> +/* L2 Priority Bits */
> +#define ODP_COS_L2_QOS_BITS            3
> +/* Max L2 QoS value */
> +#define ODP_COS_MAX_L2_QOS             (1 << ODP_COS_L2_QOS_BITS)
> +/* L2 DSCP Bits */
> +#define ODP_COS_L3_QOS_BITS            6
> +/* Max L3 QoS Value */
> +#define ODP_COS_MAX_L3_QOS             (1 << ODP_COS_L3_QOS_BITS)
> +/* Max PMR Term bits */
> +#define ODP_PMR_TERM_BYTES_MAX         8
> +
> +/* forward declaration */
> +typedef union pmr_u pmr_t;
> +
> +/**
> +Packet Matching Rule Term Value
> +
> +Stores the Term and Value mapping for a PMR.
> +The maximum size of value currently supported in 64 bits
> +**/
> +typedef struct pmr_term_value {
> +       odp_pmr_match_type_e match_type; /**< Packet Match Type*/
> +       odp_pmr_term_e  term;           /* PMR Term */
> +       union {
> +               struct {
> +                       uint64_t        val;
> +                       uint64_t        mask;
> +               } mask; /**< Match a masked set of bits */
> +               struct {
> +                       uint64_t        val1;
> +                       uint64_t        val2;
> +               } range; /**< Match an integer range */
> +       };
> +} pmr_term_value_t;
> +
> +typedef union cos_u cos_t;
> +/*
> +Class Of Service
> +*/
> +struct cos_s {
> +       queue_entry_t *queue;           /* Associated Queue */
> +       pool_entry_t *pool;             /* Associated Buffer pool */
> +       pmr_t *pmr;                     /* Chained PMR */
> +       cos_t *linked_cos;              /* CoS linked with the PMR */
> +       uint32_t valid;                 /* validity Flag */
> +       odp_drop_e drop_policy;         /* Associated Drop Policy */
> +       odp_queue_group_t queue_group;  /* Associated Queue Group */
> +       odp_cos_flow_set_t flow_set;    /* Assigned Flow Set */
> +       char name[ODP_COS_NAME_LEN];    /* name */
> +       size_t headroom;                /* Headroom for this CoS */
> +       odp_spinlock_t lock;            /* cos lock */
> +};
> +
> +typedef union cos_u {
> +       struct cos_s s;
> +       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct cos_s))];
> +} cos_t;
> +
> +
> +/**
> +Packet Matching Rule
> +
> +**/
> +struct pmr_s {
> +       uint32_t valid;                 /* Validity Flag */
> +       odp_atomic_u32_t count;         /* num of packets matching this
> rule */
> +       uint32_t num_pmr;               /* num of PMR Term Values*/
> +       odp_spinlock_t lock;            /* pmr lock*/
> +       pmr_term_value_t  pmr_term_value[1];    /* Associated PMR Term */
> +};
> +
> +typedef union pmr_u {
> +       struct pmr_s s;
> +       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct pmr_s))];
> +} pmr_t;
> +
> +/**
> +Packet Matching Rule Set
> +
> +This structure is implemented as a extension over struct pmr_s
> +In order to use same pointer to access both pmr_s and pmr_set_s
> +'num_pmr' value is used to differentiate between pmr_s and pmr_set_s
> struct
> +**/
> +struct pmr_set_s {
> +       pmr_t pmr;
> +       pmr_term_value_t  pmr_term_value[ODP_PMRTERM_MAX - 1];
> +                       /* List of associated PMR Terms */
> +};
> +
> +typedef union pmr_set_u {
> +       struct pmr_set_s s;
> +       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct pmr_set_s))];
> +} pmr_set_t;
> +
> +/**
> +L2 QoS and CoS Map
> +
> +This structure holds the mapping between L2 QoS value and
> +corresponding cos_t object
> +**/
> +typedef struct pmr_l2_cos {
> +       odp_spinlock_t lock;    /* pmr_l2_cos lock */
> +       cos_t *cos[ODP_COS_MAX_L2_QOS]; /* Array of CoS objects */
> +} pmr_l2_cos_t;
> +
> +/**
> +L3 QoS and CoS Map
> +
> +This structure holds the mapping between L3 QoS value and
> +corresponding cos_t object
> +**/
> +typedef struct pmr_l3_cos {
> +       odp_spinlock_t lock;    /* pmr_l3_cos lock */
> +       cos_t *cos[ODP_COS_MAX_L3_QOS]; /* Array of CoS objects */
> +} pmr_l3_cos_t;
> +
> +/**
> +Linux Generic Classifier
> +
> +This structure is stored in pktio_entry and holds all
> +the classifier configuration value.
> +**/
> +typedef struct classifier {
> +       odp_spinlock_t lock;            /*pktio_cos lock */
> +       uint32_t num_pmr;               /* num of PMRs linked to given
> PKTIO*/
> +       pmr_t *pmr[ODP_PKTIO_MAX_PMR];  /* PMRs linked with this PKTIO */
> +       cos_t *cos[ODP_PKTIO_MAX_PMR];  /* CoS linked with this PKTIO */
> +       cos_t *error_cos;               /* Associated Error CoS */
> +       cos_t *default_cos;             /* Associated Default CoS */
> +       uint32_t l3_precedence;         /* L3 QoS precedence */
> +       pmr_l2_cos_t l2_cos_table;      /* L2 QoS-CoS table map */
> +       pmr_l3_cos_t l3_cos_table;      /* L3 Qos-CoS table map */
> +       odp_cos_flow_set_t flow_set;    /* Flow Set to be calculated
> +                                       for this pktio */
> +       size_t headroom;                /* Pktio Headroom */
> +       size_t skip;                    /* Pktio Skip Offset */
> +} classifier_t;
> +
> +/**
> +Class of Service Table
> +**/
> +typedef struct odp_cos_table {
> +       cos_t cos_entry[ODP_COS_MAX_ENTRY];
> +} cos_tbl_t;
> +
> +/**
> +PMR set table
> +**/
> +typedef struct pmr_set_tbl {
> +       pmr_set_t pmr_set[ODP_PMRSET_MAX_ENTRY];
> +} pmr_set_tbl_t;
> +
> +/**
> +PMR table
> +**/
> +typedef struct pmr_tbl {
> +       pmr_t pmr[ODP_PMR_MAX_ENTRY];
> +} pmr_tbl_t;
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +#endif
> diff --git a/platform/linux-generic/include/odp_classification_inlines.h
> b/platform/linux-generic/include/odp_classification_inlines.h
> new file mode 100644
> index 0000000..6b20119
> --- /dev/null
> +++ b/platform/linux-generic/include/odp_classification_inlines.h
> @@ -0,0 +1,259 @@
> +/* Copyright (c) 2014, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier:     BSD-3-Clause
> + */
> +
> +
> +/**
> + * @file
> + *
> + * ODP Classification Inlines
> + * Classification Inlines Functions
> + */
> +#ifndef __ODP_CLASSIFICATION_INLINES_H_
> +#define __ODP_CLASSIFICATION_INLINES_H_
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#include <odp_debug.h>
> +#include <odph_eth.h>
> +#include <odph_ip.h>
> +#include <odph_udp.h>
> +#include <odph_tcp.h>
> +
> +/* PMR term value verification function
> +These functions verify the given PMR term value with the value in the
> packet
> +These following functions return 1 on success and 0 on failure
> +*/
> +
> +static inline int verify_pmr_packet_len(odp_packet_hdr_t *pkt_hdr,
> +                                       pmr_term_value_t *term_value)
> +{
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (pkt_hdr->frame_len &
> +                   term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= pkt_hdr->frame_len) &&
> +                   (pkt_hdr->frame_len <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +static inline int verify_pmr_ip_proto(uint8_t *pkt_addr,
> +                                     odp_packet_hdr_t *pkt_hdr,
> +                                     pmr_term_value_t *term_value)
> +{
> +       odph_ipv4hdr_t *ip;
> +       uint8_t proto;
> +       if (!pkt_hdr->input_flags.ipv4)
> +               return 0;
> +       ip = (odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
> +       proto = ip->proto;
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (proto &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= proto) &&
> +                   (proto <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_ipv4_saddr(uint8_t *pkt_addr,
> +                                       odp_packet_hdr_t *pkt_hdr,
> +                                       pmr_term_value_t *term_value)
> +{
> +       odph_ipv4hdr_t *ip;
> +       uint32_t ipaddr;
> +       if (!pkt_hdr->input_flags.ipv4)
> +               return 0;
> +       ip = (odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
> +       ipaddr = odp_be_to_cpu_32(ip->src_addr);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (ipaddr &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= ipaddr) &&
> +                   (ipaddr <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_ipv4_daddr(uint8_t *pkt_addr,
> +                                       odp_packet_hdr_t *pkt_hdr,
> +                                       pmr_term_value_t *term_value)
> +{
> +       odph_ipv4hdr_t *ip;
> +       uint32_t ipaddr;
> +       if (!pkt_hdr->input_flags.ipv4)
> +               return 0;
> +       ip = (odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
> +       ipaddr = odp_be_to_cpu_32(ip->dst_addr);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (ipaddr &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= ipaddr) &&
> +                   (ipaddr <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_tcp_sport(uint8_t *pkt_addr,
> +                                      odp_packet_hdr_t *pkt_hdr,
> +                                      pmr_term_value_t *term_value)
> +{
> +       uint16_t sport;
> +       odph_tcphdr_t *tcp;
> +       if (!pkt_hdr->input_flags.tcp)
> +               return 0;
> +       tcp = (odph_tcphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
> +       sport = odp_be_to_cpu_16(tcp->src_port);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (sport &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= sport) &&
> +                   (sport <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_tcp_dport(uint8_t *pkt_addr,
> +                                      odp_packet_hdr_t *pkt_hdr,
> +                                      pmr_term_value_t *term_value)
> +{
> +       uint16_t dport;
> +       odph_tcphdr_t *tcp;
> +       if (!pkt_hdr->input_flags.tcp)
> +               return 0;
> +       tcp = (odph_tcphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
> +       dport = odp_be_to_cpu_16(tcp->dst_port);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (dport &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= dport) &&
> +                   (dport <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_udp_dport(uint8_t *pkt_addr,
> +                                      odp_packet_hdr_t *pkt_hdr,
> +                                      pmr_term_value_t *term_value)
> +{
> +       uint16_t dport;
> +       odph_udphdr_t *udp;
> +       if (!pkt_hdr->input_flags.udp)
> +               return 0;
> +       udp = (odph_udphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
> +       dport = odp_be_to_cpu_16(udp->dst_port);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (dport &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= dport) &&
> +                   (dport <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +static inline int verify_pmr_udp_sport(uint8_t *pkt_addr,
> +                                      odp_packet_hdr_t *pkt_hdr,
> +                                      pmr_term_value_t *term_value)
> +{
> +       uint16_t sport;
> +       odph_udphdr_t *udp;
> +       if (!pkt_hdr->input_flags.udp)
> +               return 0;
> +       udp = (odph_udphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
> +       sport = odp_be_to_cpu_16(udp->src_port);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (sport &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= sport) &&
> +                   (sport <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_dmac(uint8_t *pkt_addr ODP_UNUSED,
> +                                 odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
> +                                 pmr_term_value_t *term_value ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +
> +static inline int verify_pmr_ipv6_saddr(uint8_t *pkt_addr ODP_UNUSED,
> +                                       odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                       pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_ipv6_daddr(uint8_t *pkt_addr ODP_UNUSED,
> +                                       odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                       pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_vlan_id_0(uint8_t *pkt_addr ODP_UNUSED,
> +                                      odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                      pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_vlan_id_x(uint8_t *pkt_addr ODP_UNUSED,
> +                                      odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                      pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_ipsec_spi(uint8_t *pkt_addr ODP_UNUSED,
> +                                      odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                      pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_ld_vni(uint8_t *pkt_addr ODP_UNUSED,
> +                                   odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
> +                                   pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_eth_type_0(uint8_t *pkt_addr ODP_UNUSED,
> +                                       odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                       pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_eth_type_x(uint8_t *pkt_addr ODP_UNUSED,
> +                                       odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                       pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +#ifdef __cplusplus
> +}
> +#endif
> +#endif
> diff --git a/platform/linux-generic/include/odp_classification_internal.h
> b/platform/linux-generic/include/odp_classification_internal.h
> new file mode 100644
> index 0000000..fd2c6af
> --- /dev/null
> +++ b/platform/linux-generic/include/odp_classification_internal.h
> @@ -0,0 +1,173 @@
> +/* Copyright (c) 2014, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier:     BSD-3-Clause
> + */
> +
> +
> +/**
> + * @file
> + *
> + * ODP Classification Internal
> + * Describes the classification internal Functions
> + */
> +
> +#ifndef __ODP_CLASSIFICATION_INTERNAL_H_
> +#define __ODP_CLASSIFICATION_INTERNAL_H_
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#include <odp_classification.h>
> +#include <odp_queue.h>
> +#include <odp_packet_internal.h>
> +#include <odp_packet_io.h>
> +#include <odp_packet_io_internal.h>
> +#include <odp_classification_datamodel.h>
> +
> +/** Classification Internal function **/
> +
> +/**
> +@internal
> +Select a CoS for the given Packet based on pktio
> +
> +This function will call all the PMRs associated with a pktio for
> +a given packet and will return the matched COS object.
> +This function will check PMR, L2 and L3 QoS COS object associated
> +with the PKTIO interface.
> +
> +Returns the default cos if the packet does not match any PMR
> +Returns the error_cos if the packet has an error
> +**/
> +cos_t *pktio_select_cos(pktio_entry_t *pktio, uint8_t *pkt_addr,
> +                      odp_packet_hdr_t *pkt_hdr);
> +
> +/**
> +@internal
> +match_qos_cos
> +
> +Select a CoS for the given Packet based on QoS values
> +This function returns the COS object matching the L2 and L3 QoS
> +based on the l3_preference value of the pktio
> +**/
> +cos_t *match_qos_cos(pktio_entry_t *entry, uint8_t *pkt_addr,
> +                    odp_packet_hdr_t *hdr);
> +/**
> +Packet Classifier
> +
> +Start function for Packet Classifier
> +This function calls Classifier module internal functions for a given
> packet and
> +enqueues the packet to specific Queue based on PMR and CoS selected.
> +**/
> +int packet_classifier(odp_pktio_t pktio, odp_packet_t pkt);
> +/**
> +Packet IO classifier init
> +
> +This function does initialization of classifier object associated with
> pktio.
> +This function should be called during pktio initialization.
> +**/
> +int pktio_classifier_init(pktio_entry_t *pktio);
> +
> +/**
> +@internal
> +match_pmr_cos
> +
> +Match a PMR chain with a Packet and return matching CoS
> +This function gets called recursively to check the chained PMR Term value
> +with the packet.
> +
> +**/
> +cos_t *match_pmr_cos(cos_t *cos, uint8_t *pkt_addr, pmr_t *pmr,
> +                    odp_packet_hdr_t *hdr);
> +/**
> +@internal
> +CoS associated with L3 QoS value
> +
> +This function returns the CoS associated with L3 QoS value
> +**/
> +cos_t *match_qos_l3_cos(pmr_l3_cos_t *l3_cos, uint8_t *pkt_addr,
> +                       odp_packet_hdr_t *hdr);
> +
> +/**
> +@internal
> +CoS associated with L2 QoS value
> +
> +This function returns the CoS associated with L2 QoS value
> +**/
> +cos_t *match_qos_l2_cos(pmr_l2_cos_t *l2_cos, uint8_t *pkt_addr,
> +                       odp_packet_hdr_t *hdr);
> +/**
> +@internal
> +Flow Signature Calculation
> +
> +This function calculates the Flow Signature for a packet based on
> +CoS and updates in Packet Meta Data
> +**/
> +int update_flow_signature(uint8_t *pkt_addr, cos_t *cos);
> +
> +/**
> +@internal
> +Allocate a odp_pmr_set_t Handle
> +*/
> +odp_pmr_set_t alloc_pmr_set(pmr_t **pmr);
> +
> +/**
> +@internal
> +Allocate a odp_pmr_t Handle
> +*/
> +odp_pmr_t alloc_pmr(pmr_t **pmr);
> +
> +/**
> +@internal
> +Pointer to pmr_set_t Handle
> +This function checks for validity of pmr_set_t Handle
> +*/
> +pmr_set_t *get_pmr_set_entry(odp_pmr_set_t pmr_set_id);
> +
> +/**
> +@internal
> +Pointer to pmr_set_t Handle
> +*/
> +pmr_set_t *get_pmr_set_entry_internal(odp_pmr_set_t pmr_set_id);
> +
> +/**
> +@internal
> +Pointer to pmr_set_t Handle
> +This function checks for validity of pmr_set_t Handle
> +*/
> +pmr_t *get_pmr_entry(odp_pmr_t pmr_id);
> +
> +/**
> +@internal
> +Pointer to pmr_set_t Handle
> +*/
> +pmr_t *get_pmr_entry_internal(odp_pmr_t pmr_id);
> +
> +/**
> +@internal
> +Pointer to odp_cos_t Handle
> +*/
> +cos_t *get_cos_entry(odp_cos_t cos_id);
> +
> +/**
> +@internal
> +Pointer to odp_cos_t Handle
> +This function checks for validity of odp_cos_t Handle
> +*/
> +cos_t *get_cos_entry_internal(odp_cos_t cos_id);
> +
> +/**
> +@internal
> +Verify PMR with a Packet
> +
> +This function goes through each PMR_TERM value in pmr_t structure and
> +calls verification function for each term.Returns 1 if PMR matches or 0
> +Otherwise.
> +**/
> +int verify_pmr(pmr_t *pmr, uint8_t *pkt_addr, odp_packet_hdr_t *pkt_hdr);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +#endif
> diff --git a/platform/linux-generic/include/odp_internal.h
> b/platform/linux-generic/include/odp_internal.h
> index f8c1596..04c1030 100644
> --- a/platform/linux-generic/include/odp_internal.h
> +++ b/platform/linux-generic/include/odp_internal.h
> @@ -32,6 +32,8 @@ int odp_buffer_pool_init_global(void);
>  int odp_pktio_init_global(void);
>  int odp_pktio_init_local(void);
>
> +int odp_classification_init_global(void);
> +
>  int odp_queue_init_global(void);
>
>  int odp_crypto_init_global(void);
> diff --git a/platform/linux-generic/include/odp_packet_io_internal.h
> b/platform/linux-generic/include/odp_packet_io_internal.h
> index d129f22..465127b 100644
> --- a/platform/linux-generic/include/odp_packet_io_internal.h
> +++ b/platform/linux-generic/include/odp_packet_io_internal.h
> @@ -20,6 +20,7 @@ extern "C" {
>
>  #include <odp_spinlock.h>
>  #include <odp_packet_socket.h>
> +#include <odp_classification_datamodel.h>
>  #include <odp_align_internal.h>
>
>  #include <odp_config.h>
> @@ -43,6 +44,7 @@ struct pktio_entry {
>         odp_pktio_type_t type;          /**< pktio type */
>         pkt_sock_t pkt_sock;            /**< using socket API for IO */
>         pkt_sock_mmap_t pkt_sock_mmap;  /**< using socket mmap API for IO
> */
> +       classifier_t cls;               /**< classifier linked with this
> pktio*/
>         char name[IFNAMSIZ];            /**< name of pktio provided to
>                                            pktio_open() */
>  };
> diff --git a/platform/linux-generic/odp_buffer_pool.c
> b/platform/linux-generic/odp_buffer_pool.c
> index 83c51fa..d20999b 100644
> --- a/platform/linux-generic/odp_buffer_pool.c
> +++ b/platform/linux-generic/odp_buffer_pool.c
> @@ -57,12 +57,6 @@ typedef struct {
>  } odp_any_buffer_hdr_t;
>
>
> -typedef union pool_entry_u {
> -       struct pool_entry_s s;
> -
> -       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct
> pool_entry_s))];
> -
> -} pool_entry_t;
>
>
>  typedef struct pool_table_t {
> @@ -87,10 +81,6 @@ static inline odp_buffer_pool_t
> pool_index_to_handle(uint32_t pool_id)
>  }
>
>
> -static inline uint32_t pool_handle_to_index(odp_buffer_pool_t pool_hdl)
> -{
> -       return pool_hdl -1;
> -}
>
>
>  static inline void set_handle(odp_buffer_hdr_t *hdr,
> diff --git a/platform/linux-generic/odp_classification.c
> b/platform/linux-generic/odp_classification.c
> index 190d71e..e3c4bf7 100644
> --- a/platform/linux-generic/odp_classification.c
> +++ b/platform/linux-generic/odp_classification.c
> @@ -1,69 +1,318 @@
> +/* Copyright (c) 2014, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier:     BSD-3-Clause
> + */
> +
>  #include <odp_classification.h>
>  #include <odp_align.h>
>  #include <odp_queue.h>
>  #include <odp_debug.h>
> +#include <odp_internal.h>
>  #include <odp_debug_internal.h>
> +#include <odp_packet_internal.h>
>  #include <odp_packet_io.h>
> +#include <odp_packet_io_internal.h>
> +#include <odp_classification_datamodel.h>
> +#include <odp_classification_inlines.h>
> +#include <odp_classification_internal.h>
> +#include <odp_buffer_pool_internal.h>
> +#include <odp_shared_memory.h>
> +#include <odph_eth.h>
> +#include <string.h>
> +#include <odp_spinlock.h>
>
> -odp_cos_t odp_cos_create(const char *name)
> +#define LOCK(a)      odp_spinlock_lock(a)
> +#define UNLOCK(a)    odp_spinlock_unlock(a)
> +#define LOCK_INIT(a)   odp_spinlock_init(a)
> +
> +static cos_tbl_t *cos_tbl;
> +static pmr_set_tbl_t   *pmr_set_tbl;
> +static pmr_tbl_t       *pmr_tbl;
> +
> +cos_t *get_cos_entry_internal(odp_cos_t cos_id)
> +{
> +       return &(cos_tbl->cos_entry[cos_id]);
> +}
> +
> +pmr_set_t *get_pmr_set_entry_internal(odp_pmr_set_t pmr_set_id)
> +{
> +       return &(pmr_set_tbl->pmr_set[pmr_set_id]);
> +}
> +
> +pmr_t *get_pmr_entry_internal(odp_pmr_t pmr_id)
>  {
> -       (void) name;
> -       ODP_UNIMPLEMENTED();
> +       return &(pmr_tbl->pmr[pmr_id]);
> +}
> +
> +int odp_classification_init_global(void)
> +{
> +       odp_shm_t cos_shm;
> +       odp_shm_t pmr_shm;
> +       odp_shm_t pmr_set_shm;
> +       int i;
> +
> +       cos_shm = odp_shm_reserve("shm_odp_cos_tbl",
> +                       sizeof(cos_tbl_t),
> +                       sizeof(cos_t), 0);
> +
> +       if (cos_shm == ODP_SHM_INVALID) {
> +               ODP_ERR("shm allocation failed for shm_odp_cos_tbl");
> +               return -1;
> +       }
> +
> +       cos_tbl = odp_shm_addr(cos_shm);
> +       if (cos_tbl == NULL) {
> +               odp_shm_free(cos_shm);
> +               return -1;
> +       }
> +
> +       memset(cos_tbl, 0, sizeof(cos_tbl_t));
> +       for (i = 0; i < ODP_COS_MAX_ENTRY; i++) {
> +               /* init locks */
> +               cos_t *cos = get_cos_entry_internal(i);
> +               LOCK_INIT(&cos->s.lock);
> +       }
> +
> +       pmr_shm = odp_shm_reserve("shm_odp_pmr_tbl",
> +                       sizeof(pmr_tbl_t),
> +                       sizeof(pmr_t), 0);
> +
> +       if (pmr_shm == ODP_SHM_INVALID) {
> +               ODP_ERR("shm allocation failed for shm_odp_pmr_tbl");
> +               return -1;
> +       }
> +
> +       pmr_tbl = odp_shm_addr(pmr_shm);
> +       if (pmr_tbl == NULL) {
> +               odp_shm_free(pmr_shm);
> +               return -1;
> +       }
> +
> +       memset(pmr_tbl, 0, sizeof(pmr_tbl_t));
> +       for (i = 0; i < ODP_PMR_MAX_ENTRY; i++) {
> +               /* init locks */
> +               pmr_t *pmr = get_pmr_entry_internal(i);
> +               LOCK_INIT(&pmr->s.lock);
> +       }
> +
> +       pmr_set_shm = odp_shm_reserve("shm_odp_pmr_set_tbl",
> +                       sizeof(pmr_set_tbl_t),
> +                       sizeof(pmr_set_t), 0);
> +
> +       if (pmr_set_shm == ODP_SHM_INVALID) {
> +               ODP_ERR("shm allocation failed for shm_odp_pmr_set_tbl");
> +               return -1;
> +       }
> +
> +       pmr_set_tbl = odp_shm_addr(pmr_set_shm);
> +       if (pmr_set_tbl == NULL) {
> +               odp_shm_free(pmr_set_shm);
> +               return -1;
> +       }
> +
> +       memset(pmr_set_tbl, 0, sizeof(pmr_set_tbl_t));
> +       for (i = 0; i < ODP_PMRSET_MAX_ENTRY; i++) {
> +               /* init locks */
> +               pmr_set_t *pmr = get_pmr_set_entry_internal(i);
> +               LOCK_INIT(&pmr->s.pmr.s.lock);
> +       }
> +
>         return 0;
>  }
>
> +odp_cos_t odp_cos_create(const char *name)
> +{
> +       int i;
> +
> +       for (i = 0; i < ODP_COS_MAX_ENTRY; i++) {
> +               LOCK(&cos_tbl->cos_entry[i].s.lock);
> +               if (0 == cos_tbl->cos_entry[i].s.valid) {
> +                       strncpy(cos_tbl->cos_entry[i].s.name, name,
> +                               ODP_COS_NAME_LEN - 1);
> +                       cos_tbl->cos_entry[i].s.name[ODP_COS_NAME_LEN -
> 1] = 0;
> +                       cos_tbl->cos_entry[i].s.pmr = NULL;
> +                       cos_tbl->cos_entry[i].s.linked_cos = NULL;
> +                       cos_tbl->cos_entry[i].s.queue = NULL;
> +                       cos_tbl->cos_entry[i].s.pool = NULL;
> +                       cos_tbl->cos_entry[i].s.flow_set = 0;
> +                       cos_tbl->cos_entry[i].s.headroom = 0;
> +                       cos_tbl->cos_entry[i].s.valid = 1;
> +                       UNLOCK(&cos_tbl->cos_entry[i].s.lock);
> +                       return (odp_cos_t)i;
> +               }
> +               UNLOCK(&cos_tbl->cos_entry[i].s.lock);
> +       }
> +       ODP_ERR("ODP_COS_MAX_ENTRY reached");
> +       return ODP_COS_INVALID;
> +}
> +
> +odp_pmr_set_t alloc_pmr_set(pmr_t **pmr)
> +{
> +       int i;
> +
> +       for (i = 0; i < ODP_PMRSET_MAX_ENTRY; i++) {
> +               LOCK(&pmr_set_tbl->pmr_set[i].s.pmr.s.lock);
> +               if (0 == pmr_set_tbl->pmr_set[i].s.pmr.s.valid) {
> +                       pmr_set_tbl->pmr_set[i].s.pmr.s.valid = 1;
> +                       pmr_set_tbl->pmr_set[i].s.pmr.s.num_pmr = 0;
> +                       *pmr = (pmr_t *)&pmr_set_tbl->pmr_set[i];
> +                       odp_atomic_init_u32(&pmr_set_tbl->pmr_set[i]
> +                                           .s.pmr.s.count, 0);
> +                       return (odp_pmr_set_t)i; /* return as locked */
> +               }
> +               UNLOCK(&pmr_set_tbl->pmr_set[i].s.pmr.s.lock);
> +       }
> +       ODP_ERR("ODP_PMRSET_MAX_ENTRY reached");
> +       return ODP_PMR_INVAL;
> +}
> +
> +odp_pmr_t alloc_pmr(pmr_t **pmr)
> +{
> +       int i;
> +
> +       for (i = 0; i < ODP_PMR_MAX_ENTRY; i++) {
> +               LOCK(&pmr_tbl->pmr[i].s.lock);
> +               if (0 == pmr_tbl->pmr[i].s.valid) {
> +                       pmr_tbl->pmr[i].s.valid = 1;
> +                       odp_atomic_init_u32(&pmr_tbl->pmr[i].s.count, 0);
> +                       pmr_tbl->pmr[i].s.num_pmr = 0;
> +                       *pmr = &pmr_tbl->pmr[i];
> +                       return (odp_pmr_t)i; /* return as locked */
> +               }
> +               UNLOCK(&pmr_tbl->pmr[i].s.lock);
> +       }
> +       ODP_ERR("ODP_PMR_MAX_ENTRY reached");
> +       return ODP_PMR_INVAL;
> +}
> +
> +
> +cos_t *get_cos_entry(odp_cos_t cos_id)
> +{
> +       if (cos_id >= ODP_COS_MAX_ENTRY || cos_id == ODP_COS_INVALID)
> +               return NULL;
> +       if (cos_tbl->cos_entry[cos_id].s.valid == 0)
> +               return NULL;
> +       return &(cos_tbl->cos_entry[cos_id]);
> +}
> +
> +
> +pmr_set_t *get_pmr_set_entry(odp_pmr_set_t pmr_set_id)
> +{
> +       if (pmr_set_id >= ODP_PMRSET_MAX_ENTRY || pmr_set_id ==
> ODP_PMR_INVAL)
> +               return NULL;
> +       if (pmr_set_tbl->pmr_set[pmr_set_id].s.pmr.s.valid == 0)
> +               return NULL;
> +       return &(pmr_set_tbl->pmr_set[pmr_set_id]);
> +}
> +
> +pmr_t *get_pmr_entry(odp_pmr_t pmr_id)
> +{
> +       if (pmr_id >= ODP_PMR_MAX_ENTRY || pmr_id == ODP_PMR_INVAL)
> +               return NULL;
> +       if (pmr_tbl->pmr[pmr_id].s.valid == 0)
> +               return NULL;
> +       return &(pmr_tbl->pmr[pmr_id]);
> +}
> +
>  int odp_cos_destroy(odp_cos_t cos_id)
>  {
> -       (void)cos_id;
> -       ODP_UNIMPLEMENTED();
> +       cos_t *cos = get_cos_entry(cos_id);
> +       if (NULL == cos) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       cos->s.valid = 0;
>         return 0;
>  }
>
>  int odp_cos_set_queue(odp_cos_t cos_id, odp_queue_t queue_id)
>  {
> -       (void)cos_id;
> -       (void)queue_id;
> -       ODP_UNIMPLEMENTED();
> +       cos_t *cos = get_cos_entry(cos_id);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +       /* Locking is not required as intermitted stale
> +       data during CoS modification is acceptable*/
> +       cos->s.queue = queue_to_qentry(queue_id);
>         return 0;
>  }
>
>  int odp_cos_set_drop(odp_cos_t cos_id, odp_drop_e drop_policy)
>  {
> -       (void)cos_id;
> -       (void)drop_policy;
> -       ODP_UNIMPLEMENTED();
> +       cos_t *cos = get_cos_entry(cos_id);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       /*Drop policy is not supported in v1.0*/
> +       cos->s.drop_policy = drop_policy;
>         return 0;
>  }
>
>  int odp_pktio_set_default_cos(odp_pktio_t pktio_in, odp_cos_t default_cos)
>  {
> -       (void)pktio_in;
> -       (void)default_cos;
> -       ODP_UNIMPLEMENTED();
> +       pktio_entry_t *entry;
> +       cos_t *cos;
> +       entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +       cos = get_cos_entry(default_cos);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       entry->s.cls.default_cos = cos;
>         return 0;
>  }
>
>  int odp_pktio_set_error_cos(odp_pktio_t pktio_in, odp_cos_t error_cos)
>  {
> -       (void)pktio_in;
> -       (void)error_cos;
> -       ODP_UNIMPLEMENTED();
> +       pktio_entry_t *entry;
> +       cos_t *cos;
> +
> +       entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +
> +       cos = get_cos_entry(error_cos);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       entry->s.cls.error_cos = cos;
>         return 0;
>  }
>
>  int odp_pktio_set_skip(odp_pktio_t pktio_in, size_t offset)
>  {
> -       (void)pktio_in;
> -       (void)offset;
> -       ODP_UNIMPLEMENTED();
> +       pktio_entry_t *entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       entry->s.cls.skip = offset;
>         return 0;
>  }
>
> -int odp_pktio_set_headroom(odp_pktio_t port_id, size_t headroom)
> +int odp_pktio_set_headroom(odp_pktio_t pktio_in, size_t headroom)
>  {
> -       (void)port_id;
> -       (void)headroom;
> -       ODP_UNIMPLEMENTED();
> +       pktio_entry_t *entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +       entry->s.cls.headroom = headroom;
>         return 0;
>  }
>
> @@ -72,11 +321,26 @@ int odp_cos_with_l2_priority(odp_pktio_t pktio_in,
>                              uint8_t qos_table[],
>                              odp_cos_t cos_table[])
>  {
> -       (void)pktio_in;
> -       (void)num_qos;
> -       (void)qos_table;
> -       (void)cos_table;
> -       ODP_UNIMPLEMENTED();
> +       pmr_l2_cos_t *l2_cos;
> +       size_t i;
> +       cos_t *cos;
> +       pktio_entry_t *entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +       l2_cos = &entry->s.cls.l2_cos_table;
> +
> +       LOCK(&l2_cos->lock);
> +       /* Update the L2 QoS table*/
> +       for (i = 0; i < num_qos; i++) {
> +               cos = get_cos_entry(cos_table[i]);
> +               if (cos != NULL) {
> +                       if (ODP_COS_MAX_L2_QOS > qos_table[i])
> +                               l2_cos->cos[qos_table[i]] = cos;
> +               }
> +       }
> +       UNLOCK(&l2_cos->lock);
>         return 0;
>  }
>
> @@ -86,12 +350,29 @@ int odp_cos_with_l3_qos(odp_pktio_t pktio_in,
>                         odp_cos_t cos_table[],
>                         bool l3_preference)
>  {
> -       (void)pktio_in;
> -       (void)num_qos;
> -       (void)qos_table;
> -       (void)cos_table;
> -       (void)l3_preference;
> -       ODP_UNIMPLEMENTED();
> +       pmr_l3_cos_t *l3_cos;
> +       size_t i;
> +       pktio_entry_t *entry = get_pktio_entry(pktio_in);
> +       cos_t *cos;
> +
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +
> +       entry->s.cls.l3_precedence = l3_preference;
> +       l3_cos = &entry->s.cls.l3_cos_table;
> +
> +       LOCK(&l3_cos->lock);
> +       /* Update the L3 QoS table*/
> +       for (i = 0; i < num_qos; i++) {
> +               cos = get_cos_entry(cos_table[i]);
> +               if (cos != NULL) {
> +                       if (ODP_COS_MAX_L3_QOS > qos_table[i])
> +                               l3_cos->cos[qos_table[i]] = cos;
> +               }
> +       }
> +       UNLOCK(&l3_cos->lock);
>         return 0;
>  }
>
> @@ -100,12 +381,27 @@ odp_pmr_t odp_pmr_create_match(odp_pmr_term_e term,
>                                const void *mask,
>                                size_t val_sz)
>  {
> -       (void)term;
> -       (void)val;
> -       (void)mask;
> -       (void)val_sz;
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       pmr_t *pmr;
> +       odp_pmr_t id;
> +       if (val_sz > ODP_PMR_TERM_BYTES_MAX) {
> +               ODP_DBG();
> +               return ODP_PMR_INVAL;
> +       }
> +
> +       id = alloc_pmr(&pmr);
> +       /*if alloc_pmr() is successful it returns with lock acquired*/
> +       if (id == ODP_PMR_INVAL)
> +               return ODP_PMR_INVAL;
> +
> +       pmr->s.num_pmr = 1;
> +       pmr->s.pmr_term_value[0].match_type = ODP_PMR_MASK;
> +       pmr->s.pmr_term_value[0].term = term;
> +       pmr->s.pmr_term_value[0].mask.val =  0;
> +       pmr->s.pmr_term_value[0].mask.mask =  0;
> +       memcpy(&pmr->s.pmr_term_value[0].mask.val, val, val_sz);
> +       memcpy(&pmr->s.pmr_term_value[0].mask.mask, mask, val_sz);
> +       UNLOCK(&pmr->s.lock);
> +       return id;
>  }
>
>  odp_pmr_t odp_pmr_create_range(odp_pmr_term_e term,
> @@ -113,18 +409,34 @@ odp_pmr_t odp_pmr_create_range(odp_pmr_term_e term,
>                                const void *val2,
>                                size_t val_sz)
>  {
> -       (void)term;
> -       (void)val1;
> -       (void)val2;
> -       (void)val_sz;
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       pmr_t *pmr;
> +       odp_pmr_t id;
> +
> +       if (val_sz > ODP_PMR_TERM_BYTES_MAX)
> +               return ODP_PMR_INVAL;
> +       id = alloc_pmr(&pmr);
> +       /*if alloc_pmr() is successful it returns with lock acquired*/
> +       if (id == ODP_PMR_INVAL)
> +               return ODP_PMR_INVAL;
> +
> +       pmr->s.num_pmr = 1;
> +       pmr->s.pmr_term_value[0].match_type = ODP_PMR_MASK;
> +       pmr->s.pmr_term_value[0].term = term;
> +       pmr->s.pmr_term_value[0].range.val1 =  0;
> +       pmr->s.pmr_term_value[0].range.val2 =  0;
> +       memcpy(&pmr->s.pmr_term_value[0].range.val1, val1, val_sz);
> +       memcpy(&pmr->s.pmr_term_value[0].range.val2, val2, val_sz);
> +       UNLOCK(&pmr->s.lock);
> +       return id;
>  }
>
>  int odp_pmr_destroy(odp_pmr_t pmr_id)
>  {
> -       (void)pmr_id;
> -       ODP_UNIMPLEMENTED();
> +       pmr_t *pmr = get_pmr_entry(pmr_id);
> +
> +       if (pmr == NULL)
> +               return -1;
> +       pmr->s.valid = 0;
>         return 0;
>  }
>
> @@ -132,64 +444,478 @@ int odp_pktio_pmr_cos(odp_pmr_t pmr_id,
>                       odp_pktio_t src_pktio,
>                       odp_cos_t dst_cos)
>  {
> -       (void)pmr_id;
> -       (void)src_pktio;
> -       (void)dst_cos;
> -       ODP_UNIMPLEMENTED();
> +       uint8_t num_pmr;
> +       pktio_entry_t *pktio_entry;
> +       pmr_t *pmr;
> +       cos_t *cos;
> +
> +       pktio_entry = get_pktio_entry(src_pktio);
> +       if (pktio_entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +
> +       pmr = get_pmr_entry(pmr_id);
> +       if (pmr == NULL) {
> +               ODP_ERR("Invalid odp_pmr_t handle");
> +               return -1;
> +       }
> +
> +       cos = get_cos_entry(dst_cos);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       LOCK(&pktio_entry->s.cls.lock);
> +       num_pmr = pktio_entry->s.cls.num_pmr;
> +       if (num_pmr >= ODP_PKTIO_MAX_PMR) {
> +               ODP_ERR("ODP_PKTIO_MAX_PMR reached");
> +               UNLOCK(&pktio_entry->s.cls.lock);
> +               return -1;
> +       }
> +
> +       pktio_entry->s.cls.pmr[num_pmr] = pmr;
> +       pktio_entry->s.cls.cos[num_pmr] = cos;
> +       pktio_entry->s.cls.num_pmr++;
> +       UNLOCK(&pktio_entry->s.cls.lock);
> +
>         return 0;
>  }
>
>  int odp_cos_pmr_cos(odp_pmr_t pmr_id, odp_cos_t src_cos, odp_cos_t
> dst_cos)
>  {
> -       (void)pmr_id;
> -       (void)src_cos;
> -       (void)dst_cos;
> -       ODP_UNIMPLEMENTED();
> +       cos_t *cos_src = get_cos_entry(src_cos);
> +       cos_t *cos_dst = get_cos_entry(dst_cos);
> +       pmr_t *pmr = get_pmr_entry(pmr_id);
> +       if (NULL == cos_src || NULL == cos_dst || NULL == pmr) {
> +               ODP_ERR("Invalid input handle");
> +               return -1;
> +       }
> +
> +       /*Locking is not required as intermitted stale data is acceptable*/
> +       cos_src->s.pmr = pmr;
> +       cos_src->s.linked_cos = cos_dst;
> +
>         return 0;
>  }
>
>  signed long odp_pmr_match_count(odp_pmr_t pmr_id)
>  {
> -       (void)pmr_id;
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       pmr_t *pmr = get_pmr_entry(pmr_id);
> +       if (pmr == NULL)
> +               return -1;
> +       return (signed long)odp_atomic_load_u32(&pmr->s.count);
>  }
>
>  unsigned long long odp_pmr_terms_cap(void)
>  {
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       unsigned long long term_cap = 0;
> +
> +       term_cap |= (1 << ODP_PMR_LEN);
> +       term_cap |= (1 << ODP_PMR_IPPROTO);
> +       term_cap |= (1 << ODP_PMR_UDP_DPORT);
> +       term_cap |= (1 << ODP_PMR_TCP_DPORT);
> +       term_cap |= (1 << ODP_PMR_UDP_SPORT);
> +       term_cap |= (1 << ODP_PMR_TCP_SPORT);
> +       term_cap |= (1 << ODP_PMR_SIP_ADDR);
> +       term_cap |= (1 << ODP_PMR_DIP_ADDR);
> +       return term_cap;
>  }
>
>  unsigned odp_pmr_terms_avail(void)
>  {
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       unsigned count = 0;
> +       int i;
> +
> +       for (i = 0; i < ODP_PMR_MAX_ENTRY; i++)
> +               if (!pmr_tbl->pmr[i].s.valid)
> +                       count++;
> +       return count;
>  }
>
>  int odp_pmr_match_set_create(int num_terms, odp_pmr_match_t *terms,
>                              odp_pmr_set_t *pmr_set_id)
>  {
> -       (void)num_terms;
> -       (void)terms;
> -       (void)pmr_set_id;
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       pmr_t *pmr;
> +       int i;
> +       uint32_t id;
> +       int val_sz;
> +       int count = 0;
> +
> +       if (num_terms > ODP_PMRTERM_MAX) {
> +               ODP_ERR("no of terms greater than supported
> ODP_PMRTERM_MAX");
> +               return -1;
> +       }
> +
> +       id = alloc_pmr_set(&pmr);
> +       /*if alloc_pmr_set is successful it returns with the acquired
> lock*/
> +       if (id == ODP_PMR_INVAL) {
> +               *pmr_set_id = id;
> +               return -1;
> +       }
> +
> +       pmr->s.num_pmr = num_terms;
> +       for (i = 0; i < num_terms; i++) {
> +               pmr->s.pmr_term_value[i].match_type = terms[i].match_type;
> +               if (terms[i].match_type == ODP_PMR_MASK) {
> +                       val_sz = terms[i].mask.val_sz;
> +                       if (val_sz > ODP_PMR_TERM_BYTES_MAX)
> +                               continue;
> +                       pmr->s.pmr_term_value[i].term = terms[i].mask.term;
> +                       pmr->s.pmr_term_value[i].mask.val = 0;
> +                       pmr->s.pmr_term_value[i].mask.mask = 0;
> +                       memcpy(&pmr->s.pmr_term_value[i].mask.val,
> +                              terms[i].mask.val, val_sz);
> +                       memcpy(&pmr->s.pmr_term_value[i].mask.mask,
> +                              terms[i].mask.mask, val_sz);
> +               } else {
> +                       val_sz = terms[i].range.val_sz;
> +                       if (val_sz > ODP_PMR_TERM_BYTES_MAX)
> +                               continue;
> +                       pmr->s.pmr_term_value[i].term =
> terms[i].range.term;
> +                       pmr->s.pmr_term_value[i].range.val1 = 0;
> +                       pmr->s.pmr_term_value[i].range.val2 = 0;
> +                       memcpy(&pmr->s.pmr_term_value[i].range.val1,
> +                              terms[i].range.val1, val_sz);
> +                       memcpy(&pmr->s.pmr_term_value[i].range.val2,
> +                              terms[i].range.val2, val_sz);
> +               }
> +               count++;
> +       }
> +       *pmr_set_id = id;
> +       UNLOCK(&pmr->s.lock);
> +       return count;
>  }
>
>  int odp_pmr_match_set_destroy(odp_pmr_set_t pmr_set_id)
>  {
> -       (void)pmr_set_id;
> -       ODP_UNIMPLEMENTED();
> +       pmr_set_t *pmr_set = get_pmr_set_entry(pmr_set_id);
> +       if (pmr_set == NULL)
> +               return -1;
> +
> +       pmr_set->s.pmr.s.valid = 0;
>         return 0;
>  }
>
>  int odp_pktio_pmr_match_set_cos(odp_pmr_set_t pmr_set_id, odp_pktio_t
> src_pktio,
> -                               odp_cos_t dst_cos)
> +               odp_cos_t dst_cos)
>  {
> -       (void)pmr_set_id;
> -       (void)src_pktio;
> -       (void)dst_cos;
> -       ODP_UNIMPLEMENTED();
> +       uint8_t num_pmr;
> +       pktio_entry_t *pktio_entry;
> +       pmr_t *pmr;
> +       cos_t *cos;
> +
> +       pktio_entry = get_pktio_entry(src_pktio);
> +       if (pktio_entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +
> +       pmr = (pmr_t *)get_pmr_set_entry(pmr_set_id);
> +       if (pmr == NULL) {
> +               ODP_ERR("Invalid odp_pmr_set_t handle");
> +               return -1;
> +       }
> +
> +       cos = get_cos_entry(dst_cos);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       LOCK(&pktio_entry->s.cls.lock);
> +       num_pmr = pktio_entry->s.cls.num_pmr;
> +       if (num_pmr >= ODP_PKTIO_MAX_PMR) {
> +               ODP_ERR("ODP_PKTIO_MAX_PMR reached");
> +               UNLOCK(&pktio_entry->s.cls.lock);
> +               return -1;
> +       }
> +
> +       pktio_entry->s.cls.pmr[num_pmr] = pmr;
> +       pktio_entry->s.cls.cos[num_pmr] = cos;
> +       pktio_entry->s.cls.num_pmr++;
> +       UNLOCK(&pktio_entry->s.cls.lock);
> +
>         return 0;
>  }
> +
> +int verify_pmr(pmr_t *pmr, uint8_t *pkt_addr, odp_packet_hdr_t *pkt_hdr)
> +{
> +       int pmr_failure = 0;
> +       int num_pmr;
> +       int i;
> +       pmr_term_value_t *term_value;
> +
> +       /* Locking is not required as PMR rules for in-flight packets
> +       delivery during a PMR change is indeterminate*/
> +
> +       if (!pmr->s.valid)
> +               return 0;
> +       num_pmr = pmr->s.num_pmr;
> +
> +       /* Iterate through list of PMR Term values in a pmr_t */
> +       for (i = 0; i < num_pmr; i++) {
> +               term_value = &pmr->s.pmr_term_value[i];
> +               switch (term_value->term) {
> +               case ODP_PMR_LEN:
> +                       if (!verify_pmr_packet_len(pkt_hdr, term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_ETHTYPE_0:
> +                       if (!verify_pmr_eth_type_0(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_ETHTYPE_X:
> +                       if (!verify_pmr_eth_type_x(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_VLAN_ID_0:
> +                       if (!verify_pmr_vlan_id_0(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_VLAN_ID_X:
> +                       if (!verify_pmr_vlan_id_x(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_DMAC:
> +                       if (!verify_pmr_dmac(pkt_addr, pkt_hdr,
> +                                            term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_IPPROTO:
> +                       if (!verify_pmr_ip_proto(pkt_addr, pkt_hdr,
> +                                                term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_UDP_DPORT:
> +                       if (!verify_pmr_udp_dport(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_TCP_DPORT:
> +                       if (!verify_pmr_tcp_dport(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_UDP_SPORT:
> +                       if (!verify_pmr_udp_sport(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_TCP_SPORT:
> +                       if (!verify_pmr_tcp_sport(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_SIP_ADDR:
> +                       if (!verify_pmr_ipv4_saddr(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_DIP_ADDR:
> +                       if (!verify_pmr_ipv4_daddr(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_SIP6_ADDR:
> +                       if (!verify_pmr_ipv6_saddr(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_DIP6_ADDR:
> +                       if (!verify_pmr_ipv6_daddr(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_IPSEC_SPI:
> +                       if (!verify_pmr_ipsec_spi(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_LD_VNI:
> +                       if (!verify_pmr_ld_vni(pkt_addr, pkt_hdr,
> +                                              term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_INNER_HDR_OFF:
> +                       break;
> +               }
> +
> +               if (pmr_failure)
> +                       return false;
> +       }
> +       odp_atomic_inc_u32(&pmr->s.count);
> +       return true;
> +}
> +
> +cos_t *match_pmr_cos(cos_t *cos, uint8_t *pkt_addr, pmr_t *pmr,
> +                    odp_packet_hdr_t *hdr)
> +{
> +       cos_t *retcos = NULL;
> +
> +       if (cos == NULL || pmr == NULL)
> +               return NULL;
> +
> +       if (!cos->s.valid)
> +               return NULL;
> +
> +       if (verify_pmr(pmr, pkt_addr, hdr)) {
> +               /** This gets called recursively to check all the PMRs in
> +                * a PMR chain */
> +               retcos = match_pmr_cos(cos->s.linked_cos, pkt_addr,
> +                                      cos->s.pmr, hdr);
> +               if (!retcos)
> +                       return cos;
> +       }
> +       return retcos;
> +}
> +
> +int pktio_classifier_init(pktio_entry_t *entry)
> +{
> +       classifier_t *cls;
> +       int i;
> +       /* classifier lock should be acquired by the calling function */
> +       if (entry == NULL)
> +               return -1;
> +       cls = &entry->s.cls;
> +       cls->num_pmr = 0;
> +       cls->flow_set = 0;
> +       cls->error_cos = NULL;
> +       cls->default_cos = NULL;
> +       cls->headroom = 0;
> +       cls->skip = 0;
> +
> +       for (i = 0; i < ODP_PKTIO_MAX_PMR; i++) {
> +               cls->pmr[i] = NULL;
> +               cls->cos[i] = NULL;
> +       }
> +
> +       return 0;
> +}
> +
> +int packet_classifier(odp_pktio_t pktio, odp_packet_t pkt)
> +{
> +       pktio_entry_t *entry;
> +       queue_entry_t *queue;
> +       cos_t *cos;
> +       odp_packet_hdr_t *pkt_hdr;
> +       uint8_t *pkt_addr;
> +
> +       entry = get_pktio_entry(pktio);
> +       if (entry == NULL)
> +               return -1;
> +
> +       pkt_hdr = odp_packet_hdr(pkt);
> +       pkt_addr = odp_packet_addr(pkt);
> +
> +       /* Matching PMR and selecting the CoS for the packet*/
> +       cos = pktio_select_cos(entry, pkt_addr, pkt_hdr);
> +       if (cos == NULL)
> +               return -1;
> +
> +       /* Enqueuing the Packet based on the CoS */
> +       queue = cos->s.queue;
> +       return queue_enq(queue, odp_buf_to_hdr((odp_buffer_t)pkt));
> +}
> +
> +cos_t *pktio_select_cos(pktio_entry_t *entry, uint8_t *pkt_addr,
> +                      odp_packet_hdr_t *pkt_hdr)
> +{
> +       pmr_t *pmr;
> +       cos_t *cos;
> +       uint32_t i;
> +       classifier_t *cls;
> +
> +       cls = &entry->s.cls;
> +
> +       /* Return error cos for error packet */
> +       if (pkt_hdr->error_flags.all)
> +               return cls->error_cos;
> +       /* Calls all the PMRs attached at the PKTIO level*/
> +       for (i = 0; i < cls->num_pmr; i++) {
> +               pmr = entry->s.cls.pmr[i];
> +               cos = entry->s.cls.cos[i];
> +               cos = match_pmr_cos(cos, pkt_addr, pmr, pkt_hdr);
> +               if (cos)
> +                       return cos;
> +       }
> +
> +       cos = match_qos_cos(entry, pkt_addr, pkt_hdr);
> +       if (cos)
> +               return cos;
> +
> +       return cls->default_cos;
> +}
> +
> +cos_t *match_qos_l3_cos(pmr_l3_cos_t *l3_cos, uint8_t *pkt_addr,
> +                       odp_packet_hdr_t *hdr)
> +{
> +       uint8_t dscp;
> +       cos_t *cos = NULL;
> +       odph_ipv4hdr_t *ipv4;
> +       odph_ipv6hdr_t *ipv6;
> +
> +       if (hdr->input_flags.l3 && hdr->input_flags.ipv4) {
> +               ipv4 = (odph_ipv4hdr_t *)(pkt_addr + hdr->l3_offset);
> +               dscp = ODPH_IPV4HDR_DSCP(ipv4->tos);
> +               cos = l3_cos->cos[dscp];
> +       } else if (hdr->input_flags.l3 && hdr->input_flags.ipv6) {
> +               ipv6 = (odph_ipv6hdr_t *)(pkt_addr + hdr->l3_offset);
> +               dscp = ODPH_IPV6HDR_DSCP(ipv6->ver_tc_flow);
> +               cos = l3_cos->cos[dscp];
> +       }
> +
> +       return cos;
> +}
> +
> +cos_t *match_qos_l2_cos(pmr_l2_cos_t *l2_cos, uint8_t *pkt_addr,
> +                       odp_packet_hdr_t *hdr)
> +{
> +       uint8_t qos;
> +       cos_t *cos = NULL;
> +       odph_ethhdr_t *eth;
> +       odph_vlanhdr_t *vlan;
> +
> +       if (hdr->input_flags.l2 && hdr->input_flags.vlan &&
> +           hdr->input_flags.eth) {
> +               eth = (odph_ethhdr_t *)(pkt_addr + hdr->l2_offset);
> +               vlan = (odph_vlanhdr_t *)(&eth->type);
> +               qos = ((vlan->tci >> 13) & 0xFF);
> +               cos = l2_cos->cos[qos];
> +       }
> +       return cos;
> +}
> +
> +cos_t *match_qos_cos(pktio_entry_t *entry, uint8_t *pkt_addr,
> +                    odp_packet_hdr_t *hdr)
> +{
> +       classifier_t *cls = &entry->s.cls;
> +       pmr_l2_cos_t *l2_cos;
> +       pmr_l3_cos_t *l3_cos;
> +       cos_t *cos;
> +
> +       l2_cos = &cls->l2_cos_table;
> +       l3_cos = &cls->l3_cos_table;
> +
> +       if (cls->l3_precedence) {
> +               cos =  match_qos_l3_cos(l3_cos, pkt_addr, hdr);
> +               if (cos)
> +                       return cos;
> +               cos = match_qos_l2_cos(l2_cos, pkt_addr, hdr);
> +               if (cos)
> +                       return cos;
> +       } else {
> +               cos = match_qos_l2_cos(l2_cos, pkt_addr, hdr);
> +               if (cos)
> +                       return cos;
> +               cos = match_qos_l3_cos(l3_cos, pkt_addr, hdr);
> +               if (cos)
> +                       return cos;
> +       }
> +       return NULL;
> +}
> diff --git a/platform/linux-generic/odp_init.c
> b/platform/linux-generic/odp_init.c
> index 672b3d6..c661231 100644
> --- a/platform/linux-generic/odp_init.c
> +++ b/platform/linux-generic/odp_init.c
> @@ -54,6 +54,10 @@ int odp_init_global(odp_init_t *params  ODP_UNUSED,
>                 ODP_ERR("ODP crypto init failed.\n");
>                 return -1;
>         }
> +       if (odp_classification_init_global()) {
> +               ODP_ERR("ODP crypto init failed.\n");
> +               return -1;
> +       }
>
>         return 0;
>  }
> diff --git a/platform/linux-generic/odp_packet_io.c
> b/platform/linux-generic/odp_packet_io.c
> index 19b9eea..6bda003 100644
> --- a/platform/linux-generic/odp_packet_io.c
> +++ b/platform/linux-generic/odp_packet_io.c
> @@ -13,10 +13,10 @@
>  #include <odp_spinlock.h>
>  #include <odp_shared_memory.h>
>  #include <odp_packet_socket.h>
> -#include <odp_hints.h>
>  #include <odp_config.h>
>  #include <odp_queue_internal.h>
>  #include <odp_schedule_internal.h>
> +#include <odp_classification_internal.h>
>  #include <odp_debug_internal.h>
>
>  #include <string.h>
> @@ -50,6 +50,7 @@ int odp_pktio_init_global(void)
>                 pktio_entry = &pktio_tbl->entries[id - 1];
>
>                 odp_spinlock_init(&pktio_entry->s.lock);
> +               odp_spinlock_init(&pktio_entry->s.cls.lock);
>
>                 pktio_entry_ptr[id - 1] = pktio_entry;
>                 /* Create a default output queue for each pktio resource */
> @@ -98,12 +99,25 @@ static void unlock_entry(pktio_entry_t *entry)
>         odp_spinlock_unlock(&entry->s.lock);
>  }
>
> +static void lock_entry_classifier(pktio_entry_t *entry)
> +{
> +       odp_spinlock_lock(&entry->s.lock);
> +       odp_spinlock_lock(&entry->s.cls.lock);
> +}
> +
> +static void unlock_entry_classifier(pktio_entry_t *entry)
> +{
> +       odp_spinlock_unlock(&entry->s.cls.lock);
> +       odp_spinlock_unlock(&entry->s.lock);
> +}
> +
>  static void init_pktio_entry(pktio_entry_t *entry)
>  {
>         set_taken(entry);
>         entry->s.inq_default = ODP_QUEUE_INVALID;
>         memset(&entry->s.pkt_sock, 0, sizeof(entry->s.pkt_sock));
>         memset(&entry->s.pkt_sock_mmap, 0, sizeof(entry->s.pkt_sock_mmap));
> +       pktio_classifier_init(entry);
>  }
>
>  static odp_pktio_t alloc_lock_pktio_entry(void)
> @@ -115,13 +129,13 @@ static odp_pktio_t alloc_lock_pktio_entry(void)
>         for (i = 0; i < ODP_CONFIG_PKTIO_ENTRIES; ++i) {
>                 entry = &pktio_tbl->entries[i];
>                 if (is_free(entry)) {
> -                       lock_entry(entry);
> +                       lock_entry_classifier(entry);
>                         if (is_free(entry)) {
>                                 init_pktio_entry(entry);
>                                 id = i + 1;
>                                 return id; /* return with entry locked! */
>                         }
> -                       unlock_entry(entry);
> +                       unlock_entry_classifier(entry);
>                 }
>         }
>
> @@ -190,14 +204,14 @@ odp_pktio_t odp_pktio_open(const char *dev,
> odp_buffer_pool_t pool)
>                 close_pkt_sock(&pktio_entry->s.pkt_sock);
>         }
>
> -       unlock_entry(pktio_entry);
> +       unlock_entry_classifier(pktio_entry);
>         free_pktio_entry(id);
>         ODP_ERR("Unable to init any I/O type.\n");
>         return ODP_PKTIO_INVALID;
>
>  done:
>         strncpy(pktio_entry->s.name, dev, IFNAMSIZ);
> -       unlock_entry(pktio_entry);
> +       unlock_entry_classifier(pktio_entry);
>         return id;
>  }
>
> @@ -415,7 +429,7 @@ odp_buffer_hdr_t *pktin_dequeue(queue_entry_t *qentry)
>         odp_buffer_t buf;
>         odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
>         odp_buffer_hdr_t *tmp_hdr_tbl[QUEUE_MULTI_MAX];
> -       int pkts, i;
> +       int pkts, i, j;
>
>         buf_hdr = queue_deq(qentry);
>         if (buf_hdr != NULL)
> @@ -425,12 +439,15 @@ odp_buffer_hdr_t *pktin_dequeue(queue_entry_t
> *qentry)
>         if (pkts <= 0)
>                 return NULL;
>
> -       for (i = 0; i < pkts; ++i) {
> +       for (i = 0, j = 0; i < pkts; ++i) {
>                 buf = odp_packet_to_buffer(pkt_tbl[i]);
> -               tmp_hdr_tbl[i] = odp_buf_to_hdr(buf);
> +               buf_hdr = odp_buf_to_hdr(buf);
> +               if (0 > packet_classifier(qentry->s.pktin, pkt_tbl[i]))
> +                       tmp_hdr_tbl[j++] = buf_hdr;
>         }
>
> -       queue_enq_multi(qentry, tmp_hdr_tbl, pkts);
> +       if (j)
> +               queue_enq_multi(qentry, tmp_hdr_tbl, j);
>         buf_hdr = tmp_hdr_tbl[0];
>         return buf_hdr;
>  }
> @@ -446,8 +463,9 @@ int pktin_deq_multi(queue_entry_t *qentry,
> odp_buffer_hdr_t *buf_hdr[], int num)
>         int nbr;
>         odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
>         odp_buffer_hdr_t *tmp_hdr_tbl[QUEUE_MULTI_MAX];
> +       odp_buffer_hdr_t *tmp_hdr;
>         odp_buffer_t buf;
> -       int pkts, i;
> +       int pkts, i, j;
>
>         nbr = queue_deq_multi(qentry, buf_hdr, num);
>         if (odp_unlikely(nbr > num))
> @@ -464,12 +482,15 @@ int pktin_deq_multi(queue_entry_t *qentry,
> odp_buffer_hdr_t *buf_hdr[], int num)
>         if (pkts <= 0)
>                 return nbr;
>
> -       for (i = 0; i < pkts; ++i) {
> +       for (i = 0, j = 0; i < pkts; ++i) {
>                 buf = odp_packet_to_buffer(pkt_tbl[i]);
> -               tmp_hdr_tbl[i] = odp_buf_to_hdr(buf);
> +               tmp_hdr = odp_buf_to_hdr(buf);
> +               if (0 > packet_classifier(qentry->s.pktin, pkt_tbl[i]))
> +                       tmp_hdr_tbl[j++] = tmp_hdr;
>         }
>
> -       queue_enq_multi(qentry, tmp_hdr_tbl, pkts);
> +       if (j)
> +               queue_enq_multi(qentry, tmp_hdr_tbl, j);
>         return nbr;
>  }
>
> --
> 2.0.1.472.g6f92e5f
>
>
Bill Fischofer Dec. 8, 2014, 2:35 a.m. | #2
General comments:

This patch will conflict with the buffer pool patch I posted this evening,
because we're both moving the same things from odp_buffer_pool.c to
odp_buffer_pool_internal.h.  Whichever gets merged first the other can do
the very trivial fixup to resolve the conflict.

Aside from a few minor comments (see below).  This looks good.

Bill

On Fri, Dec 5, 2014 at 9:59 PM, Balasubramanian Manoharan <
bala.manoharan@linaro.org> wrote:

> The following features are implemented in this classification
> implementation:
> * Attaches PMR, PMR_SET to a Pktio entry
> * Adds classifier object to pktio entry
> * Attaches CoS values for L2 and L3 QoS to a Pktio entry
> * Selects ClassOfService for a packet based on PMR, L2 QoS and L3 QoS
> values
> * Selects a default CoS if packet does not match any of the assigned rules
> * Selects an Error CoS for an Error packet
> * Enqueues the packet to the queue associated with the selected CoS
>
> Signed-off-by: Balasubramanian Manoharan <bala.manoharan@linaro.org>
> ---
>  helper/include/odph_ip.h                           |   6 +
>  platform/linux-generic/include/api/odp.h           |   1 +
>  .../include/odp_buffer_pool_internal.h             |   9 +
>  .../include/odp_classification_datamodel.h         | 201 +++++
>  .../include/odp_classification_inlines.h           | 259 ++++++
>  .../include/odp_classification_internal.h          | 173 ++++
>  platform/linux-generic/include/odp_internal.h      |   2 +
>  .../linux-generic/include/odp_packet_io_internal.h |   2 +
>  platform/linux-generic/odp_buffer_pool.c           |  10 -
>  platform/linux-generic/odp_classification.c        | 878
> +++++++++++++++++++--
>  platform/linux-generic/odp_init.c                  |   4 +
>  platform/linux-generic/odp_packet_io.c             |  47 +-
>  12 files changed, 1493 insertions(+), 99 deletions(-)
>  create mode 100644
> platform/linux-generic/include/odp_classification_datamodel.h
>  create mode 100644
> platform/linux-generic/include/odp_classification_inlines.h
>  create mode 100644
> platform/linux-generic/include/odp_classification_internal.h
>
> diff --git a/helper/include/odph_ip.h b/helper/include/odph_ip.h
> index 2c83c0f..f78724e 100644
> --- a/helper/include/odph_ip.h
> +++ b/helper/include/odph_ip.h
> @@ -35,6 +35,9 @@ extern "C" {
>  /** @internal Returns IPv4 header length */
>  #define ODPH_IPV4HDR_IHL(ver_ihl) ((ver_ihl) & 0x0f)
>
> +/** @internal Returns IPv4 DSCP */
> +#define ODPH_IPV4HDR_DSCP(tos) (((tos) & 0xfc) >> 2)
> +
>  /** @internal Returns IPv4 Don't fragment */
>  #define ODPH_IPV4HDR_FLAGS_DONT_FRAG(frag_offset)  ((frag_offset) &
> 0x4000)
>
> @@ -47,6 +50,9 @@ extern "C" {
>  /** @internal Returns true if IPv4 packet is a fragment */
>  #define ODPH_IPV4HDR_IS_FRAGMENT(frag_offset) ((frag_offset) & 0x3fff)
>
> +/** @internal Returns IPv4 DSCP */
> +#define ODPH_IPV6HDR_DSCP(ver_tc_flow) (uint8_t)((((ver_tc_flow) &
> 0x0fc00000) >> 22) & 0xff)
> +
>  /** IPv4 header */
>  typedef struct ODP_PACKED {
>         uint8_t    ver_ihl;     /**< Version / Header length */
> diff --git a/platform/linux-generic/include/api/odp.h
> b/platform/linux-generic/include/api/odp.h
> index 6e4f69e..b7b1ca9 100644
> --- a/platform/linux-generic/include/api/odp.h
> +++ b/platform/linux-generic/include/api/odp.h
> @@ -47,6 +47,7 @@ extern "C" {
>  #include <odp_packet_flags.h>
>  #include <odp_packet_io.h>
>  #include <odp_crypto.h>
> +#include <odp_classification.h>
>  #include <odp_rwlock.h>
>
>  #ifdef __cplusplus
> diff --git a/platform/linux-generic/include/odp_buffer_pool_internal.h
> b/platform/linux-generic/include/odp_buffer_pool_internal.h
> index e0210bd..07602fe 100644
> --- a/platform/linux-generic/include/odp_buffer_pool_internal.h
> +++ b/platform/linux-generic/include/odp_buffer_pool_internal.h
> @@ -22,6 +22,7 @@ extern "C" {
>  #include <odp_buffer_pool.h>
>  #include <odp_buffer_internal.h>
>  #include <odp_align.h>
> +#include <odp_align_internal.h>
>  #include <odp_hints.h>
>  #include <odp_config.h>
>  #include <odp_debug.h>
> @@ -64,6 +65,10 @@ struct pool_entry_s {
>         size_t                  hdr_size;
>  };
>
> +typedef union pool_entry_u {
> +       struct pool_entry_s s;
> +       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct
> pool_entry_s))];
> +} pool_entry_t;
>
>  extern void *pool_entry_ptr[];
>
> @@ -73,6 +78,10 @@ static inline void *get_pool_entry(uint32_t pool_id)
>         return pool_entry_ptr[pool_id];
>  }
>
> +static inline uint32_t pool_handle_to_index(odp_buffer_pool_t pool_hdl)
> +{
> +       return pool_hdl - 1;
> +}
>
>  static inline odp_buffer_hdr_t *odp_buf_to_hdr(odp_buffer_t buf)
>  {
> diff --git a/platform/linux-generic/include/odp_classification_datamodel.h
> b/platform/linux-generic/include/odp_classification_datamodel.h
> new file mode 100644
> index 0000000..18846bc
> --- /dev/null
> +++ b/platform/linux-generic/include/odp_classification_datamodel.h
> @@ -0,0 +1,201 @@
> +/* Copyright (c) 2014, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier:     BSD-3-Clause
> + */
> +
> +
> +/**
> + * @file
> + *
> + * ODP Classification Datamodel
> + * Describes the classification internal data model
> + */
> +
> +#ifndef ODP_CLASSIFICATION_DATAMODEL_H_
> +#define ODP_CLASSIFICATION_DATAMODEL_H_
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#include <odp_spinlock.h>
> +#include <odp_classification.h>
> +#include <odp_buffer_pool_internal.h>
> +#include <odp_packet_internal.h>
> +#include <odp_packet_io_internal.h>
> +#include <odp_queue_internal.h>
> +
> +/* Maximum Class Of Service Entry */
> +#define ODP_COS_MAX_ENTRY              64
> +/* Maximum PMR Set Entry */
> +#define ODP_PMRSET_MAX_ENTRY           64
> +/* Maximum PMR Entry */
> +#define ODP_PMR_MAX_ENTRY              64
> +/* Maximum PMR Terms in a PMR Set */
> +#define ODP_PMRTERM_MAX                        8
> +/* Maximum PMRs attached in PKTIO Level */
> +#define ODP_PKTIO_MAX_PMR              8
> +/* L2 Priority Bits */
> +#define ODP_COS_L2_QOS_BITS            3
> +/* Max L2 QoS value */
> +#define ODP_COS_MAX_L2_QOS             (1 << ODP_COS_L2_QOS_BITS)
> +/* L2 DSCP Bits */
> +#define ODP_COS_L3_QOS_BITS            6
> +/* Max L3 QoS Value */
> +#define ODP_COS_MAX_L3_QOS             (1 << ODP_COS_L3_QOS_BITS)
> +/* Max PMR Term bits */
> +#define ODP_PMR_TERM_BYTES_MAX         8
> +
> +/* forward declaration */
> +typedef union pmr_u pmr_t;
> +
> +/**
> +Packet Matching Rule Term Value
> +
> +Stores the Term and Value mapping for a PMR.
> +The maximum size of value currently supported in 64 bits
> +**/
> +typedef struct pmr_term_value {
> +       odp_pmr_match_type_e match_type; /**< Packet Match Type*/
> +       odp_pmr_term_e  term;           /* PMR Term */
> +       union {
> +               struct {
> +                       uint64_t        val;
> +                       uint64_t        mask;
> +               } mask; /**< Match a masked set of bits */
> +               struct {
> +                       uint64_t        val1;
> +                       uint64_t        val2;
> +               } range; /**< Match an integer range */
> +       };
> +} pmr_term_value_t;
> +
> +typedef union cos_u cos_t;
> +/*
> +Class Of Service
> +*/
> +struct cos_s {
> +       queue_entry_t *queue;           /* Associated Queue */
> +       pool_entry_t *pool;             /* Associated Buffer pool */
> +       pmr_t *pmr;                     /* Chained PMR */
> +       cos_t *linked_cos;              /* CoS linked with the PMR */
> +       uint32_t valid;                 /* validity Flag */
> +       odp_drop_e drop_policy;         /* Associated Drop Policy */
> +       odp_queue_group_t queue_group;  /* Associated Queue Group */
> +       odp_cos_flow_set_t flow_set;    /* Assigned Flow Set */
> +       char name[ODP_COS_NAME_LEN];    /* name */
> +       size_t headroom;                /* Headroom for this CoS */
> +       odp_spinlock_t lock;            /* cos lock */
> +};
> +
> +typedef union cos_u {
> +       struct cos_s s;
> +       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct cos_s))];
> +} cos_t;
> +
> +
> +/**
> +Packet Matching Rule
> +
> +**/
> +struct pmr_s {
> +       uint32_t valid;                 /* Validity Flag */
> +       odp_atomic_u32_t count;         /* num of packets matching this
> rule */
> +       uint32_t num_pmr;               /* num of PMR Term Values*/
> +       odp_spinlock_t lock;            /* pmr lock*/
> +       pmr_term_value_t  pmr_term_value[1];    /* Associated PMR Term */
> +};
> +
> +typedef union pmr_u {
> +       struct pmr_s s;
> +       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct pmr_s))];
> +} pmr_t;
> +
> +/**
> +Packet Matching Rule Set
> +
> +This structure is implemented as a extension over struct pmr_s
> +In order to use same pointer to access both pmr_s and pmr_set_s
> +'num_pmr' value is used to differentiate between pmr_s and pmr_set_s
> struct
> +**/
> +struct pmr_set_s {
> +       pmr_t pmr;
> +       pmr_term_value_t  pmr_term_value[ODP_PMRTERM_MAX - 1];
> +                       /* List of associated PMR Terms */
> +};
> +
> +typedef union pmr_set_u {
> +       struct pmr_set_s s;
> +       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct pmr_set_s))];
> +} pmr_set_t;
> +
> +/**
> +L2 QoS and CoS Map
> +
> +This structure holds the mapping between L2 QoS value and
> +corresponding cos_t object
> +**/
> +typedef struct pmr_l2_cos {
> +       odp_spinlock_t lock;    /* pmr_l2_cos lock */
> +       cos_t *cos[ODP_COS_MAX_L2_QOS]; /* Array of CoS objects */
> +} pmr_l2_cos_t;
> +
> +/**
> +L3 QoS and CoS Map
> +
> +This structure holds the mapping between L3 QoS value and
> +corresponding cos_t object
> +**/
> +typedef struct pmr_l3_cos {
> +       odp_spinlock_t lock;    /* pmr_l3_cos lock */
> +       cos_t *cos[ODP_COS_MAX_L3_QOS]; /* Array of CoS objects */
> +} pmr_l3_cos_t;
> +
> +/**
> +Linux Generic Classifier
> +
> +This structure is stored in pktio_entry and holds all
> +the classifier configuration value.
> +**/
> +typedef struct classifier {
> +       odp_spinlock_t lock;            /*pktio_cos lock */
> +       uint32_t num_pmr;               /* num of PMRs linked to given
> PKTIO*/
> +       pmr_t *pmr[ODP_PKTIO_MAX_PMR];  /* PMRs linked with this PKTIO */
> +       cos_t *cos[ODP_PKTIO_MAX_PMR];  /* CoS linked with this PKTIO */
> +       cos_t *error_cos;               /* Associated Error CoS */
> +       cos_t *default_cos;             /* Associated Default CoS */
> +       uint32_t l3_precedence;         /* L3 QoS precedence */
> +       pmr_l2_cos_t l2_cos_table;      /* L2 QoS-CoS table map */
> +       pmr_l3_cos_t l3_cos_table;      /* L3 Qos-CoS table map */
> +       odp_cos_flow_set_t flow_set;    /* Flow Set to be calculated
> +                                       for this pktio */
> +       size_t headroom;                /* Pktio Headroom */
> +       size_t skip;                    /* Pktio Skip Offset */
> +} classifier_t;
> +
> +/**
> +Class of Service Table
> +**/
> +typedef struct odp_cos_table {
> +       cos_t cos_entry[ODP_COS_MAX_ENTRY];
> +} cos_tbl_t;
> +
> +/**
> +PMR set table
> +**/
> +typedef struct pmr_set_tbl {
> +       pmr_set_t pmr_set[ODP_PMRSET_MAX_ENTRY];
> +} pmr_set_tbl_t;
> +
> +/**
> +PMR table
> +**/
> +typedef struct pmr_tbl {
> +       pmr_t pmr[ODP_PMR_MAX_ENTRY];
> +} pmr_tbl_t;
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +#endif
> diff --git a/platform/linux-generic/include/odp_classification_inlines.h
> b/platform/linux-generic/include/odp_classification_inlines.h
> new file mode 100644
> index 0000000..6b20119
> --- /dev/null
> +++ b/platform/linux-generic/include/odp_classification_inlines.h
> @@ -0,0 +1,259 @@
> +/* Copyright (c) 2014, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier:     BSD-3-Clause
> + */
> +
> +
> +/**
> + * @file
> + *
> + * ODP Classification Inlines
> + * Classification Inlines Functions
> + */
> +#ifndef __ODP_CLASSIFICATION_INLINES_H_
> +#define __ODP_CLASSIFICATION_INLINES_H_
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#include <odp_debug.h>
> +#include <odph_eth.h>
> +#include <odph_ip.h>
> +#include <odph_udp.h>
> +#include <odph_tcp.h>
> +
> +/* PMR term value verification function
> +These functions verify the given PMR term value with the value in the
> packet
> +These following functions return 1 on success and 0 on failure
> +*/
> +
> +static inline int verify_pmr_packet_len(odp_packet_hdr_t *pkt_hdr,
> +                                       pmr_term_value_t *term_value)
> +{
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (pkt_hdr->frame_len &
> +                   term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= pkt_hdr->frame_len) &&
> +                   (pkt_hdr->frame_len <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +static inline int verify_pmr_ip_proto(uint8_t *pkt_addr,
> +                                     odp_packet_hdr_t *pkt_hdr,
> +                                     pmr_term_value_t *term_value)
> +{
> +       odph_ipv4hdr_t *ip;
> +       uint8_t proto;
> +       if (!pkt_hdr->input_flags.ipv4)
> +               return 0;
> +       ip = (odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
> +       proto = ip->proto;
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (proto &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= proto) &&
> +                   (proto <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_ipv4_saddr(uint8_t *pkt_addr,
> +                                       odp_packet_hdr_t *pkt_hdr,
> +                                       pmr_term_value_t *term_value)
> +{
> +       odph_ipv4hdr_t *ip;
> +       uint32_t ipaddr;
> +       if (!pkt_hdr->input_flags.ipv4)
> +               return 0;
> +       ip = (odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
> +       ipaddr = odp_be_to_cpu_32(ip->src_addr);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (ipaddr &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= ipaddr) &&
> +                   (ipaddr <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_ipv4_daddr(uint8_t *pkt_addr,
> +                                       odp_packet_hdr_t *pkt_hdr,
> +                                       pmr_term_value_t *term_value)
> +{
> +       odph_ipv4hdr_t *ip;
> +       uint32_t ipaddr;
> +       if (!pkt_hdr->input_flags.ipv4)
> +               return 0;
> +       ip = (odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
> +       ipaddr = odp_be_to_cpu_32(ip->dst_addr);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (ipaddr &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= ipaddr) &&
> +                   (ipaddr <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_tcp_sport(uint8_t *pkt_addr,
> +                                      odp_packet_hdr_t *pkt_hdr,
> +                                      pmr_term_value_t *term_value)
> +{
> +       uint16_t sport;
> +       odph_tcphdr_t *tcp;
> +       if (!pkt_hdr->input_flags.tcp)
> +               return 0;
> +       tcp = (odph_tcphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
> +       sport = odp_be_to_cpu_16(tcp->src_port);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (sport &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= sport) &&
> +                   (sport <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_tcp_dport(uint8_t *pkt_addr,
> +                                      odp_packet_hdr_t *pkt_hdr,
> +                                      pmr_term_value_t *term_value)
> +{
> +       uint16_t dport;
> +       odph_tcphdr_t *tcp;
> +       if (!pkt_hdr->input_flags.tcp)
> +               return 0;
> +       tcp = (odph_tcphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
> +       dport = odp_be_to_cpu_16(tcp->dst_port);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (dport &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= dport) &&
> +                   (dport <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_udp_dport(uint8_t *pkt_addr,
> +                                      odp_packet_hdr_t *pkt_hdr,
> +                                      pmr_term_value_t *term_value)
> +{
> +       uint16_t dport;
> +       odph_udphdr_t *udp;
> +       if (!pkt_hdr->input_flags.udp)
> +               return 0;
> +       udp = (odph_udphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
> +       dport = odp_be_to_cpu_16(udp->dst_port);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (dport &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= dport) &&
> +                   (dport <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +static inline int verify_pmr_udp_sport(uint8_t *pkt_addr,
> +                                      odp_packet_hdr_t *pkt_hdr,
> +                                      pmr_term_value_t *term_value)
> +{
> +       uint16_t sport;
> +       odph_udphdr_t *udp;
> +       if (!pkt_hdr->input_flags.udp)
> +               return 0;
> +       udp = (odph_udphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
> +       sport = odp_be_to_cpu_16(udp->src_port);
> +       if (term_value->match_type == ODP_PMR_MASK) {
> +               if (term_value->mask.val == (sport &
> term_value->mask.mask))
> +                       return 1;
> +       } else {
> +               if ((term_value->range.val1 <= sport) &&
> +                   (sport <= term_value->range.val2))
> +                       return 1;
> +       }
> +       return 0;
> +}
> +
> +static inline int verify_pmr_dmac(uint8_t *pkt_addr ODP_UNUSED,
> +                                 odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
> +                                 pmr_term_value_t *term_value ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +
> +static inline int verify_pmr_ipv6_saddr(uint8_t *pkt_addr ODP_UNUSED,
> +                                       odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                       pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_ipv6_daddr(uint8_t *pkt_addr ODP_UNUSED,
> +                                       odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                       pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_vlan_id_0(uint8_t *pkt_addr ODP_UNUSED,
> +                                      odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                      pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_vlan_id_x(uint8_t *pkt_addr ODP_UNUSED,
> +                                      odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                      pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_ipsec_spi(uint8_t *pkt_addr ODP_UNUSED,
> +                                      odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                      pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_ld_vni(uint8_t *pkt_addr ODP_UNUSED,
> +                                   odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
> +                                   pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_eth_type_0(uint8_t *pkt_addr ODP_UNUSED,
> +                                       odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                       pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +static inline int verify_pmr_eth_type_x(uint8_t *pkt_addr ODP_UNUSED,
> +                                       odp_packet_hdr_t *pkt_hdr
> ODP_UNUSED,
> +                                       pmr_term_value_t *term_value
> ODP_UNUSED)
> +{
> +       ODP_UNIMPLEMENTED();
> +       return 0;
> +}
> +#ifdef __cplusplus
> +}
> +#endif
> +#endif
> diff --git a/platform/linux-generic/include/odp_classification_internal.h
> b/platform/linux-generic/include/odp_classification_internal.h
> new file mode 100644
> index 0000000..fd2c6af
> --- /dev/null
> +++ b/platform/linux-generic/include/odp_classification_internal.h
> @@ -0,0 +1,173 @@
> +/* Copyright (c) 2014, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier:     BSD-3-Clause
> + */
> +
> +
> +/**
> + * @file
> + *
> + * ODP Classification Internal
> + * Describes the classification internal Functions
> + */
> +
> +#ifndef __ODP_CLASSIFICATION_INTERNAL_H_
> +#define __ODP_CLASSIFICATION_INTERNAL_H_
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#include <odp_classification.h>
> +#include <odp_queue.h>
> +#include <odp_packet_internal.h>
> +#include <odp_packet_io.h>
> +#include <odp_packet_io_internal.h>
> +#include <odp_classification_datamodel.h>
> +
> +/** Classification Internal function **/
> +
> +/**
> +@internal
> +Select a CoS for the given Packet based on pktio
> +
> +This function will call all the PMRs associated with a pktio for
> +a given packet and will return the matched COS object.
> +This function will check PMR, L2 and L3 QoS COS object associated
> +with the PKTIO interface.
> +
> +Returns the default cos if the packet does not match any PMR
> +Returns the error_cos if the packet has an error
> +**/
> +cos_t *pktio_select_cos(pktio_entry_t *pktio, uint8_t *pkt_addr,
> +                      odp_packet_hdr_t *pkt_hdr);
> +
> +/**
> +@internal
> +match_qos_cos
> +
> +Select a CoS for the given Packet based on QoS values
> +This function returns the COS object matching the L2 and L3 QoS
> +based on the l3_preference value of the pktio
> +**/
> +cos_t *match_qos_cos(pktio_entry_t *entry, uint8_t *pkt_addr,
> +                    odp_packet_hdr_t *hdr);
> +/**
> +Packet Classifier
> +
> +Start function for Packet Classifier
> +This function calls Classifier module internal functions for a given
> packet and
> +enqueues the packet to specific Queue based on PMR and CoS selected.
> +**/
> +int packet_classifier(odp_pktio_t pktio, odp_packet_t pkt);
> +/**
> +Packet IO classifier init
> +
> +This function does initialization of classifier object associated with
> pktio.
> +This function should be called during pktio initialization.
> +**/
> +int pktio_classifier_init(pktio_entry_t *pktio);
> +
> +/**
> +@internal
> +match_pmr_cos
> +
> +Match a PMR chain with a Packet and return matching CoS
> +This function gets called recursively to check the chained PMR Term value
> +with the packet.
> +
> +**/
> +cos_t *match_pmr_cos(cos_t *cos, uint8_t *pkt_addr, pmr_t *pmr,
> +                    odp_packet_hdr_t *hdr);
> +/**
> +@internal
> +CoS associated with L3 QoS value
> +
> +This function returns the CoS associated with L3 QoS value
> +**/
> +cos_t *match_qos_l3_cos(pmr_l3_cos_t *l3_cos, uint8_t *pkt_addr,
> +                       odp_packet_hdr_t *hdr);
> +
> +/**
> +@internal
> +CoS associated with L2 QoS value
> +
> +This function returns the CoS associated with L2 QoS value
> +**/
> +cos_t *match_qos_l2_cos(pmr_l2_cos_t *l2_cos, uint8_t *pkt_addr,
> +                       odp_packet_hdr_t *hdr);
> +/**
> +@internal
> +Flow Signature Calculation
> +
> +This function calculates the Flow Signature for a packet based on
> +CoS and updates in Packet Meta Data
> +**/
> +int update_flow_signature(uint8_t *pkt_addr, cos_t *cos);
> +
> +/**
> +@internal
> +Allocate a odp_pmr_set_t Handle
> +*/
> +odp_pmr_set_t alloc_pmr_set(pmr_t **pmr);
> +
> +/**
> +@internal
> +Allocate a odp_pmr_t Handle
> +*/
> +odp_pmr_t alloc_pmr(pmr_t **pmr);
> +
> +/**
> +@internal
> +Pointer to pmr_set_t Handle
> +This function checks for validity of pmr_set_t Handle
> +*/
> +pmr_set_t *get_pmr_set_entry(odp_pmr_set_t pmr_set_id);
> +
> +/**
> +@internal
> +Pointer to pmr_set_t Handle
> +*/
> +pmr_set_t *get_pmr_set_entry_internal(odp_pmr_set_t pmr_set_id);
> +
> +/**
> +@internal
> +Pointer to pmr_set_t Handle
> +This function checks for validity of pmr_set_t Handle
> +*/
> +pmr_t *get_pmr_entry(odp_pmr_t pmr_id);
> +
> +/**
> +@internal
> +Pointer to pmr_set_t Handle
> +*/
> +pmr_t *get_pmr_entry_internal(odp_pmr_t pmr_id);
> +
> +/**
> +@internal
> +Pointer to odp_cos_t Handle
> +*/
> +cos_t *get_cos_entry(odp_cos_t cos_id);
> +
> +/**
> +@internal
> +Pointer to odp_cos_t Handle
> +This function checks for validity of odp_cos_t Handle
> +*/
> +cos_t *get_cos_entry_internal(odp_cos_t cos_id);
> +
> +/**
> +@internal
> +Verify PMR with a Packet
> +
> +This function goes through each PMR_TERM value in pmr_t structure and
> +calls verification function for each term.Returns 1 if PMR matches or 0
> +Otherwise.
> +**/
> +int verify_pmr(pmr_t *pmr, uint8_t *pkt_addr, odp_packet_hdr_t *pkt_hdr);
> +
> +#ifdef __cplusplus
> +}
> +#endif
> +#endif
> diff --git a/platform/linux-generic/include/odp_internal.h
> b/platform/linux-generic/include/odp_internal.h
> index f8c1596..04c1030 100644
> --- a/platform/linux-generic/include/odp_internal.h
> +++ b/platform/linux-generic/include/odp_internal.h
> @@ -32,6 +32,8 @@ int odp_buffer_pool_init_global(void);
>  int odp_pktio_init_global(void);
>  int odp_pktio_init_local(void);
>
> +int odp_classification_init_global(void);
> +
>  int odp_queue_init_global(void);
>
>  int odp_crypto_init_global(void);
> diff --git a/platform/linux-generic/include/odp_packet_io_internal.h
> b/platform/linux-generic/include/odp_packet_io_internal.h
> index d129f22..465127b 100644
> --- a/platform/linux-generic/include/odp_packet_io_internal.h
> +++ b/platform/linux-generic/include/odp_packet_io_internal.h
> @@ -20,6 +20,7 @@ extern "C" {
>
>  #include <odp_spinlock.h>
>  #include <odp_packet_socket.h>
> +#include <odp_classification_datamodel.h>
>  #include <odp_align_internal.h>
>
>  #include <odp_config.h>
> @@ -43,6 +44,7 @@ struct pktio_entry {
>         odp_pktio_type_t type;          /**< pktio type */
>         pkt_sock_t pkt_sock;            /**< using socket API for IO */
>         pkt_sock_mmap_t pkt_sock_mmap;  /**< using socket mmap API for IO
> */
> +       classifier_t cls;               /**< classifier linked with this
> pktio*/
>         char name[IFNAMSIZ];            /**< name of pktio provided to
>                                            pktio_open() */
>  };
> diff --git a/platform/linux-generic/odp_buffer_pool.c
> b/platform/linux-generic/odp_buffer_pool.c
> index 83c51fa..d20999b 100644
> --- a/platform/linux-generic/odp_buffer_pool.c
> +++ b/platform/linux-generic/odp_buffer_pool.c
> @@ -57,12 +57,6 @@ typedef struct {
>  } odp_any_buffer_hdr_t;
>
>
> -typedef union pool_entry_u {
> -       struct pool_entry_s s;
> -
> -       uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct
> pool_entry_s))];
> -
> -} pool_entry_t;
>
>
>  typedef struct pool_table_t {
> @@ -87,10 +81,6 @@ static inline odp_buffer_pool_t
> pool_index_to_handle(uint32_t pool_id)
>  }
>
>
> -static inline uint32_t pool_handle_to_index(odp_buffer_pool_t pool_hdl)
> -{
> -       return pool_hdl -1;
> -}
>
>
>  static inline void set_handle(odp_buffer_hdr_t *hdr,
> diff --git a/platform/linux-generic/odp_classification.c
> b/platform/linux-generic/odp_classification.c
> index 190d71e..e3c4bf7 100644
> --- a/platform/linux-generic/odp_classification.c
> +++ b/platform/linux-generic/odp_classification.c
> @@ -1,69 +1,318 @@
> +/* Copyright (c) 2014, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier:     BSD-3-Clause
> + */
> +
>  #include <odp_classification.h>
>  #include <odp_align.h>
>  #include <odp_queue.h>
>  #include <odp_debug.h>
> +#include <odp_internal.h>
>  #include <odp_debug_internal.h>
> +#include <odp_packet_internal.h>
>  #include <odp_packet_io.h>
> +#include <odp_packet_io_internal.h>
> +#include <odp_classification_datamodel.h>
> +#include <odp_classification_inlines.h>
> +#include <odp_classification_internal.h>
> +#include <odp_buffer_pool_internal.h>
> +#include <odp_shared_memory.h>
> +#include <odph_eth.h>
> +#include <string.h>
> +#include <odp_spinlock.h>
>
> -odp_cos_t odp_cos_create(const char *name)
> +#define LOCK(a)      odp_spinlock_lock(a)
> +#define UNLOCK(a)    odp_spinlock_unlock(a)
> +#define LOCK_INIT(a)   odp_spinlock_init(a)
> +
> +static cos_tbl_t *cos_tbl;
> +static pmr_set_tbl_t   *pmr_set_tbl;
> +static pmr_tbl_t       *pmr_tbl;
> +
> +cos_t *get_cos_entry_internal(odp_cos_t cos_id)
> +{
> +       return &(cos_tbl->cos_entry[cos_id]);
> +}
> +
> +pmr_set_t *get_pmr_set_entry_internal(odp_pmr_set_t pmr_set_id)
> +{
> +       return &(pmr_set_tbl->pmr_set[pmr_set_id]);
> +}
> +
> +pmr_t *get_pmr_entry_internal(odp_pmr_t pmr_id)
>  {
> -       (void) name;
> -       ODP_UNIMPLEMENTED();
> +       return &(pmr_tbl->pmr[pmr_id]);
> +}
> +
> +int odp_classification_init_global(void)
> +{
> +       odp_shm_t cos_shm;
> +       odp_shm_t pmr_shm;
> +       odp_shm_t pmr_set_shm;
> +       int i;
> +
> +       cos_shm = odp_shm_reserve("shm_odp_cos_tbl",
> +                       sizeof(cos_tbl_t),
> +                       sizeof(cos_t), 0);
> +
> +       if (cos_shm == ODP_SHM_INVALID) {
> +               ODP_ERR("shm allocation failed for shm_odp_cos_tbl");
> +               return -1;
> +       }
> +
> +       cos_tbl = odp_shm_addr(cos_shm);
> +       if (cos_tbl == NULL) {
> +               odp_shm_free(cos_shm);
> +               return -1;
> +       }
> +
> +       memset(cos_tbl, 0, sizeof(cos_tbl_t));
> +       for (i = 0; i < ODP_COS_MAX_ENTRY; i++) {
> +               /* init locks */
> +               cos_t *cos = get_cos_entry_internal(i);
> +               LOCK_INIT(&cos->s.lock);
> +       }
> +
> +       pmr_shm = odp_shm_reserve("shm_odp_pmr_tbl",
> +                       sizeof(pmr_tbl_t),
> +                       sizeof(pmr_t), 0);
> +
> +       if (pmr_shm == ODP_SHM_INVALID) {
> +               ODP_ERR("shm allocation failed for shm_odp_pmr_tbl");
> +               return -1;
> +       }
> +
>

Good you're doing the step-by-step checks here, but if the first
odp_shm_reserve() call succeeds and the second one fails, you exit without
doing an odp_shm_free() for the first one, so it's now lost.  Similar
problem with chaining the reserves/frees as you step through this routine.
For robustness, you need to back out all of the prior successful
reservations when you detect a later error.


> +       pmr_tbl = odp_shm_addr(pmr_shm);
> +       if (pmr_tbl == NULL) {
> +               odp_shm_free(pmr_shm);
> +               return -1;
> +       }
> +
> +       memset(pmr_tbl, 0, sizeof(pmr_tbl_t));
> +       for (i = 0; i < ODP_PMR_MAX_ENTRY; i++) {
> +               /* init locks */
> +               pmr_t *pmr = get_pmr_entry_internal(i);
> +               LOCK_INIT(&pmr->s.lock);
> +       }
> +
> +       pmr_set_shm = odp_shm_reserve("shm_odp_pmr_set_tbl",
> +                       sizeof(pmr_set_tbl_t),
> +                       sizeof(pmr_set_t), 0);
> +
> +       if (pmr_set_shm == ODP_SHM_INVALID) {
> +               ODP_ERR("shm allocation failed for shm_odp_pmr_set_tbl");
> +               return -1;
> +       }
> +
> +       pmr_set_tbl = odp_shm_addr(pmr_set_shm);
> +       if (pmr_set_tbl == NULL) {
> +               odp_shm_free(pmr_set_shm);
> +               return -1;
> +       }
> +
> +       memset(pmr_set_tbl, 0, sizeof(pmr_set_tbl_t));
> +       for (i = 0; i < ODP_PMRSET_MAX_ENTRY; i++) {
> +               /* init locks */
> +               pmr_set_t *pmr = get_pmr_set_entry_internal(i);
> +               LOCK_INIT(&pmr->s.pmr.s.lock);
> +       }
> +
>         return 0;
>  }
>
> +odp_cos_t odp_cos_create(const char *name)
> +{
> +       int i;
> +
> +       for (i = 0; i < ODP_COS_MAX_ENTRY; i++) {
> +               LOCK(&cos_tbl->cos_entry[i].s.lock);
> +               if (0 == cos_tbl->cos_entry[i].s.valid) {
> +                       strncpy(cos_tbl->cos_entry[i].s.name, name,
> +                               ODP_COS_NAME_LEN - 1);
> +                       cos_tbl->cos_entry[i].s.name[ODP_COS_NAME_LEN -
> 1] = 0;
> +                       cos_tbl->cos_entry[i].s.pmr = NULL;
> +                       cos_tbl->cos_entry[i].s.linked_cos = NULL;
> +                       cos_tbl->cos_entry[i].s.queue = NULL;
> +                       cos_tbl->cos_entry[i].s.pool = NULL;
> +                       cos_tbl->cos_entry[i].s.flow_set = 0;
> +                       cos_tbl->cos_entry[i].s.headroom = 0;
> +                       cos_tbl->cos_entry[i].s.valid = 1;
> +                       UNLOCK(&cos_tbl->cos_entry[i].s.lock);
> +                       return (odp_cos_t)i;
> +               }
> +               UNLOCK(&cos_tbl->cos_entry[i].s.lock);
> +       }
> +       ODP_ERR("ODP_COS_MAX_ENTRY reached");
> +       return ODP_COS_INVALID;
> +}
> +
> +odp_pmr_set_t alloc_pmr_set(pmr_t **pmr)
> +{
> +       int i;
> +
> +       for (i = 0; i < ODP_PMRSET_MAX_ENTRY; i++) {
> +               LOCK(&pmr_set_tbl->pmr_set[i].s.pmr.s.lock);
> +               if (0 == pmr_set_tbl->pmr_set[i].s.pmr.s.valid) {
> +                       pmr_set_tbl->pmr_set[i].s.pmr.s.valid = 1;
> +                       pmr_set_tbl->pmr_set[i].s.pmr.s.num_pmr = 0;
> +                       *pmr = (pmr_t *)&pmr_set_tbl->pmr_set[i];
> +                       odp_atomic_init_u32(&pmr_set_tbl->pmr_set[i]
> +                                           .s.pmr.s.count, 0);
> +                       return (odp_pmr_set_t)i; /* return as locked */
> +               }
> +               UNLOCK(&pmr_set_tbl->pmr_set[i].s.pmr.s.lock);
> +       }
> +       ODP_ERR("ODP_PMRSET_MAX_ENTRY reached");
> +       return ODP_PMR_INVAL;
> +}
> +
> +odp_pmr_t alloc_pmr(pmr_t **pmr)
> +{
> +       int i;
> +
> +       for (i = 0; i < ODP_PMR_MAX_ENTRY; i++) {
> +               LOCK(&pmr_tbl->pmr[i].s.lock);
> +               if (0 == pmr_tbl->pmr[i].s.valid) {
> +                       pmr_tbl->pmr[i].s.valid = 1;
> +                       odp_atomic_init_u32(&pmr_tbl->pmr[i].s.count, 0);
> +                       pmr_tbl->pmr[i].s.num_pmr = 0;
> +                       *pmr = &pmr_tbl->pmr[i];
> +                       return (odp_pmr_t)i; /* return as locked */
> +               }
> +               UNLOCK(&pmr_tbl->pmr[i].s.lock);
> +       }
> +       ODP_ERR("ODP_PMR_MAX_ENTRY reached");
> +       return ODP_PMR_INVAL;
> +}
> +
> +
> +cos_t *get_cos_entry(odp_cos_t cos_id)
> +{
> +       if (cos_id >= ODP_COS_MAX_ENTRY || cos_id == ODP_COS_INVALID)
> +               return NULL;
> +       if (cos_tbl->cos_entry[cos_id].s.valid == 0)
> +               return NULL;
> +       return &(cos_tbl->cos_entry[cos_id]);
> +}
> +
> +
> +pmr_set_t *get_pmr_set_entry(odp_pmr_set_t pmr_set_id)
> +{
> +       if (pmr_set_id >= ODP_PMRSET_MAX_ENTRY || pmr_set_id ==
> ODP_PMR_INVAL)
> +               return NULL;
> +       if (pmr_set_tbl->pmr_set[pmr_set_id].s.pmr.s.valid == 0)
> +               return NULL;
> +       return &(pmr_set_tbl->pmr_set[pmr_set_id]);
> +}
> +
> +pmr_t *get_pmr_entry(odp_pmr_t pmr_id)
> +{
> +       if (pmr_id >= ODP_PMR_MAX_ENTRY || pmr_id == ODP_PMR_INVAL)
> +               return NULL;
> +       if (pmr_tbl->pmr[pmr_id].s.valid == 0)
> +               return NULL;
> +       return &(pmr_tbl->pmr[pmr_id]);
> +}
> +
>  int odp_cos_destroy(odp_cos_t cos_id)
>  {
> -       (void)cos_id;
> -       ODP_UNIMPLEMENTED();
> +       cos_t *cos = get_cos_entry(cos_id);
> +       if (NULL == cos) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       cos->s.valid = 0;
>         return 0;
>  }
>
>  int odp_cos_set_queue(odp_cos_t cos_id, odp_queue_t queue_id)
>  {
> -       (void)cos_id;
> -       (void)queue_id;
> -       ODP_UNIMPLEMENTED();
> +       cos_t *cos = get_cos_entry(cos_id);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +       /* Locking is not required as intermitted stale
> +       data during CoS modification is acceptable*/
>

Typo: intermitted.  I assume either intermediate or intermittent?


> +       cos->s.queue = queue_to_qentry(queue_id);
>         return 0;
>  }
>
>  int odp_cos_set_drop(odp_cos_t cos_id, odp_drop_e drop_policy)
>  {
> -       (void)cos_id;
> -       (void)drop_policy;
> -       ODP_UNIMPLEMENTED();
> +       cos_t *cos = get_cos_entry(cos_id);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       /*Drop policy is not supported in v1.0*/
> +       cos->s.drop_policy = drop_policy;
>         return 0;
>  }
>
>  int odp_pktio_set_default_cos(odp_pktio_t pktio_in, odp_cos_t default_cos)
>  {
> -       (void)pktio_in;
> -       (void)default_cos;
> -       ODP_UNIMPLEMENTED();
> +       pktio_entry_t *entry;
> +       cos_t *cos;
> +       entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +       cos = get_cos_entry(default_cos);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       entry->s.cls.default_cos = cos;
>         return 0;
>  }
>
>  int odp_pktio_set_error_cos(odp_pktio_t pktio_in, odp_cos_t error_cos)
>  {
> -       (void)pktio_in;
> -       (void)error_cos;
> -       ODP_UNIMPLEMENTED();
> +       pktio_entry_t *entry;
> +       cos_t *cos;
> +
> +       entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +
> +       cos = get_cos_entry(error_cos);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       entry->s.cls.error_cos = cos;
>         return 0;
>  }
>
>  int odp_pktio_set_skip(odp_pktio_t pktio_in, size_t offset)
>  {
> -       (void)pktio_in;
> -       (void)offset;
> -       ODP_UNIMPLEMENTED();
> +       pktio_entry_t *entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       entry->s.cls.skip = offset;
>         return 0;
>  }
>
> -int odp_pktio_set_headroom(odp_pktio_t port_id, size_t headroom)
> +int odp_pktio_set_headroom(odp_pktio_t pktio_in, size_t headroom)
>  {
> -       (void)port_id;
> -       (void)headroom;
> -       ODP_UNIMPLEMENTED();
> +       pktio_entry_t *entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +       entry->s.cls.headroom = headroom;
>         return 0;
>  }
>
> @@ -72,11 +321,26 @@ int odp_cos_with_l2_priority(odp_pktio_t pktio_in,
>                              uint8_t qos_table[],
>                              odp_cos_t cos_table[])
>  {
> -       (void)pktio_in;
> -       (void)num_qos;
> -       (void)qos_table;
> -       (void)cos_table;
> -       ODP_UNIMPLEMENTED();
> +       pmr_l2_cos_t *l2_cos;
> +       size_t i;
> +       cos_t *cos;
> +       pktio_entry_t *entry = get_pktio_entry(pktio_in);
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +       l2_cos = &entry->s.cls.l2_cos_table;
> +
> +       LOCK(&l2_cos->lock);
> +       /* Update the L2 QoS table*/
> +       for (i = 0; i < num_qos; i++) {
> +               cos = get_cos_entry(cos_table[i]);
> +               if (cos != NULL) {
> +                       if (ODP_COS_MAX_L2_QOS > qos_table[i])
> +                               l2_cos->cos[qos_table[i]] = cos;
> +               }
> +       }
> +       UNLOCK(&l2_cos->lock);
>         return 0;
>  }
>
> @@ -86,12 +350,29 @@ int odp_cos_with_l3_qos(odp_pktio_t pktio_in,
>                         odp_cos_t cos_table[],
>                         bool l3_preference)
>  {
> -       (void)pktio_in;
> -       (void)num_qos;
> -       (void)qos_table;
> -       (void)cos_table;
> -       (void)l3_preference;
> -       ODP_UNIMPLEMENTED();
> +       pmr_l3_cos_t *l3_cos;
> +       size_t i;
> +       pktio_entry_t *entry = get_pktio_entry(pktio_in);
> +       cos_t *cos;
> +
> +       if (entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +
> +       entry->s.cls.l3_precedence = l3_preference;
> +       l3_cos = &entry->s.cls.l3_cos_table;
> +
> +       LOCK(&l3_cos->lock);
> +       /* Update the L3 QoS table*/
> +       for (i = 0; i < num_qos; i++) {
> +               cos = get_cos_entry(cos_table[i]);
> +               if (cos != NULL) {
> +                       if (ODP_COS_MAX_L3_QOS > qos_table[i])
> +                               l3_cos->cos[qos_table[i]] = cos;
> +               }
> +       }
> +       UNLOCK(&l3_cos->lock);
>         return 0;
>  }
>
> @@ -100,12 +381,27 @@ odp_pmr_t odp_pmr_create_match(odp_pmr_term_e term,
>                                const void *mask,
>                                size_t val_sz)
>  {
> -       (void)term;
> -       (void)val;
> -       (void)mask;
> -       (void)val_sz;
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       pmr_t *pmr;
> +       odp_pmr_t id;
> +       if (val_sz > ODP_PMR_TERM_BYTES_MAX) {
> +               ODP_DBG();
>

Is the null ODP_DBG() intentional here?  Looks odd.  Vestigial from some
debugging, perhaps?


> +               return ODP_PMR_INVAL;
> +       }
> +
> +       id = alloc_pmr(&pmr);
> +       /*if alloc_pmr() is successful it returns with lock acquired*/
> +       if (id == ODP_PMR_INVAL)
> +               return ODP_PMR_INVAL;
> +
> +       pmr->s.num_pmr = 1;
> +       pmr->s.pmr_term_value[0].match_type = ODP_PMR_MASK;
> +       pmr->s.pmr_term_value[0].term = term;
> +       pmr->s.pmr_term_value[0].mask.val =  0;
> +       pmr->s.pmr_term_value[0].mask.mask =  0;
> +       memcpy(&pmr->s.pmr_term_value[0].mask.val, val, val_sz);
> +       memcpy(&pmr->s.pmr_term_value[0].mask.mask, mask, val_sz);
> +       UNLOCK(&pmr->s.lock);
> +       return id;
>  }
>
>  odp_pmr_t odp_pmr_create_range(odp_pmr_term_e term,
> @@ -113,18 +409,34 @@ odp_pmr_t odp_pmr_create_range(odp_pmr_term_e term,
>                                const void *val2,
>                                size_t val_sz)
>  {
> -       (void)term;
> -       (void)val1;
> -       (void)val2;
> -       (void)val_sz;
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       pmr_t *pmr;
> +       odp_pmr_t id;
> +
> +       if (val_sz > ODP_PMR_TERM_BYTES_MAX)
> +               return ODP_PMR_INVAL;
> +       id = alloc_pmr(&pmr);
> +       /*if alloc_pmr() is successful it returns with lock acquired*/
> +       if (id == ODP_PMR_INVAL)
> +               return ODP_PMR_INVAL;
> +
> +       pmr->s.num_pmr = 1;
> +       pmr->s.pmr_term_value[0].match_type = ODP_PMR_MASK;
> +       pmr->s.pmr_term_value[0].term = term;
> +       pmr->s.pmr_term_value[0].range.val1 =  0;
> +       pmr->s.pmr_term_value[0].range.val2 =  0;
> +       memcpy(&pmr->s.pmr_term_value[0].range.val1, val1, val_sz);
> +       memcpy(&pmr->s.pmr_term_value[0].range.val2, val2, val_sz);
> +       UNLOCK(&pmr->s.lock);
> +       return id;
>  }
>
>  int odp_pmr_destroy(odp_pmr_t pmr_id)
>  {
> -       (void)pmr_id;
> -       ODP_UNIMPLEMENTED();
> +       pmr_t *pmr = get_pmr_entry(pmr_id);
> +
> +       if (pmr == NULL)
> +               return -1;
> +       pmr->s.valid = 0;
>         return 0;
>  }
>
> @@ -132,64 +444,478 @@ int odp_pktio_pmr_cos(odp_pmr_t pmr_id,
>                       odp_pktio_t src_pktio,
>                       odp_cos_t dst_cos)
>  {
> -       (void)pmr_id;
> -       (void)src_pktio;
> -       (void)dst_cos;
> -       ODP_UNIMPLEMENTED();
> +       uint8_t num_pmr;
> +       pktio_entry_t *pktio_entry;
> +       pmr_t *pmr;
> +       cos_t *cos;
> +
> +       pktio_entry = get_pktio_entry(src_pktio);
> +       if (pktio_entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +
> +       pmr = get_pmr_entry(pmr_id);
> +       if (pmr == NULL) {
> +               ODP_ERR("Invalid odp_pmr_t handle");
> +               return -1;
> +       }
> +
> +       cos = get_cos_entry(dst_cos);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       LOCK(&pktio_entry->s.cls.lock);
> +       num_pmr = pktio_entry->s.cls.num_pmr;
> +       if (num_pmr >= ODP_PKTIO_MAX_PMR) {
> +               ODP_ERR("ODP_PKTIO_MAX_PMR reached");
> +               UNLOCK(&pktio_entry->s.cls.lock);
> +               return -1;
> +       }
> +
> +       pktio_entry->s.cls.pmr[num_pmr] = pmr;
> +       pktio_entry->s.cls.cos[num_pmr] = cos;
> +       pktio_entry->s.cls.num_pmr++;
> +       UNLOCK(&pktio_entry->s.cls.lock);
> +
>         return 0;
>  }
>
>  int odp_cos_pmr_cos(odp_pmr_t pmr_id, odp_cos_t src_cos, odp_cos_t
> dst_cos)
>  {
> -       (void)pmr_id;
> -       (void)src_cos;
> -       (void)dst_cos;
> -       ODP_UNIMPLEMENTED();
> +       cos_t *cos_src = get_cos_entry(src_cos);
> +       cos_t *cos_dst = get_cos_entry(dst_cos);
> +       pmr_t *pmr = get_pmr_entry(pmr_id);
> +       if (NULL == cos_src || NULL == cos_dst || NULL == pmr) {
> +               ODP_ERR("Invalid input handle");
> +               return -1;
> +       }
> +
> +       /*Locking is not required as intermitted stale data is acceptable*/
> +       cos_src->s.pmr = pmr;
> +       cos_src->s.linked_cos = cos_dst;
> +
>         return 0;
>  }
>
>  signed long odp_pmr_match_count(odp_pmr_t pmr_id)
>  {
> -       (void)pmr_id;
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       pmr_t *pmr = get_pmr_entry(pmr_id);
> +       if (pmr == NULL)
> +               return -1;
> +       return (signed long)odp_atomic_load_u32(&pmr->s.count);
>  }
>
>  unsigned long long odp_pmr_terms_cap(void)
>  {
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       unsigned long long term_cap = 0;
> +
> +       term_cap |= (1 << ODP_PMR_LEN);
> +       term_cap |= (1 << ODP_PMR_IPPROTO);
> +       term_cap |= (1 << ODP_PMR_UDP_DPORT);
> +       term_cap |= (1 << ODP_PMR_TCP_DPORT);
> +       term_cap |= (1 << ODP_PMR_UDP_SPORT);
> +       term_cap |= (1 << ODP_PMR_TCP_SPORT);
> +       term_cap |= (1 << ODP_PMR_SIP_ADDR);
> +       term_cap |= (1 << ODP_PMR_DIP_ADDR);
> +       return term_cap;
>  }
>
>  unsigned odp_pmr_terms_avail(void)
>  {
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       unsigned count = 0;
> +       int i;
> +
> +       for (i = 0; i < ODP_PMR_MAX_ENTRY; i++)
> +               if (!pmr_tbl->pmr[i].s.valid)
> +                       count++;
> +       return count;
>  }
>
>  int odp_pmr_match_set_create(int num_terms, odp_pmr_match_t *terms,
>                              odp_pmr_set_t *pmr_set_id)
>  {
> -       (void)num_terms;
> -       (void)terms;
> -       (void)pmr_set_id;
> -       ODP_UNIMPLEMENTED();
> -       return 0;
> +       pmr_t *pmr;
> +       int i;
> +       uint32_t id;
> +       int val_sz;
> +       int count = 0;
> +
> +       if (num_terms > ODP_PMRTERM_MAX) {
> +               ODP_ERR("no of terms greater than supported
> ODP_PMRTERM_MAX");
> +               return -1;
> +       }
> +
> +       id = alloc_pmr_set(&pmr);
> +       /*if alloc_pmr_set is successful it returns with the acquired
> lock*/
> +       if (id == ODP_PMR_INVAL) {
> +               *pmr_set_id = id;
> +               return -1;
> +       }
> +
> +       pmr->s.num_pmr = num_terms;
> +       for (i = 0; i < num_terms; i++) {
> +               pmr->s.pmr_term_value[i].match_type = terms[i].match_type;
> +               if (terms[i].match_type == ODP_PMR_MASK) {
> +                       val_sz = terms[i].mask.val_sz;
> +                       if (val_sz > ODP_PMR_TERM_BYTES_MAX)
> +                               continue;
> +                       pmr->s.pmr_term_value[i].term = terms[i].mask.term;
> +                       pmr->s.pmr_term_value[i].mask.val = 0;
> +                       pmr->s.pmr_term_value[i].mask.mask = 0;
> +                       memcpy(&pmr->s.pmr_term_value[i].mask.val,
> +                              terms[i].mask.val, val_sz);
> +                       memcpy(&pmr->s.pmr_term_value[i].mask.mask,
> +                              terms[i].mask.mask, val_sz);
> +               } else {
> +                       val_sz = terms[i].range.val_sz;
> +                       if (val_sz > ODP_PMR_TERM_BYTES_MAX)
> +                               continue;
> +                       pmr->s.pmr_term_value[i].term =
> terms[i].range.term;
> +                       pmr->s.pmr_term_value[i].range.val1 = 0;
> +                       pmr->s.pmr_term_value[i].range.val2 = 0;
> +                       memcpy(&pmr->s.pmr_term_value[i].range.val1,
> +                              terms[i].range.val1, val_sz);
> +                       memcpy(&pmr->s.pmr_term_value[i].range.val2,
> +                              terms[i].range.val2, val_sz);
> +               }
> +               count++;
> +       }
> +       *pmr_set_id = id;
> +       UNLOCK(&pmr->s.lock);
> +       return count;
>  }
>
>  int odp_pmr_match_set_destroy(odp_pmr_set_t pmr_set_id)
>  {
> -       (void)pmr_set_id;
> -       ODP_UNIMPLEMENTED();
> +       pmr_set_t *pmr_set = get_pmr_set_entry(pmr_set_id);
> +       if (pmr_set == NULL)
> +               return -1;
> +
> +       pmr_set->s.pmr.s.valid = 0;
>         return 0;
>  }
>
>  int odp_pktio_pmr_match_set_cos(odp_pmr_set_t pmr_set_id, odp_pktio_t
> src_pktio,
> -                               odp_cos_t dst_cos)
> +               odp_cos_t dst_cos)
>  {
> -       (void)pmr_set_id;
> -       (void)src_pktio;
> -       (void)dst_cos;
> -       ODP_UNIMPLEMENTED();
> +       uint8_t num_pmr;
> +       pktio_entry_t *pktio_entry;
> +       pmr_t *pmr;
> +       cos_t *cos;
> +
> +       pktio_entry = get_pktio_entry(src_pktio);
> +       if (pktio_entry == NULL) {
> +               ODP_ERR("Invalid odp_pktio_t handle");
> +               return -1;
> +       }
> +
> +       pmr = (pmr_t *)get_pmr_set_entry(pmr_set_id);
> +       if (pmr == NULL) {
> +               ODP_ERR("Invalid odp_pmr_set_t handle");
> +               return -1;
> +       }
> +
> +       cos = get_cos_entry(dst_cos);
> +       if (cos == NULL) {
> +               ODP_ERR("Invalid odp_cos_t handle");
> +               return -1;
> +       }
> +
> +       LOCK(&pktio_entry->s.cls.lock);
> +       num_pmr = pktio_entry->s.cls.num_pmr;
> +       if (num_pmr >= ODP_PKTIO_MAX_PMR) {
> +               ODP_ERR("ODP_PKTIO_MAX_PMR reached");
> +               UNLOCK(&pktio_entry->s.cls.lock);
> +               return -1;
> +       }
> +
> +       pktio_entry->s.cls.pmr[num_pmr] = pmr;
> +       pktio_entry->s.cls.cos[num_pmr] = cos;
> +       pktio_entry->s.cls.num_pmr++;
> +       UNLOCK(&pktio_entry->s.cls.lock);
> +
>         return 0;
>  }
> +
> +int verify_pmr(pmr_t *pmr, uint8_t *pkt_addr, odp_packet_hdr_t *pkt_hdr)
> +{
> +       int pmr_failure = 0;
> +       int num_pmr;
> +       int i;
> +       pmr_term_value_t *term_value;
> +
> +       /* Locking is not required as PMR rules for in-flight packets
> +       delivery during a PMR change is indeterminate*/
> +
> +       if (!pmr->s.valid)
> +               return 0;
> +       num_pmr = pmr->s.num_pmr;
> +
> +       /* Iterate through list of PMR Term values in a pmr_t */
> +       for (i = 0; i < num_pmr; i++) {
> +               term_value = &pmr->s.pmr_term_value[i];
> +               switch (term_value->term) {
> +               case ODP_PMR_LEN:
> +                       if (!verify_pmr_packet_len(pkt_hdr, term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_ETHTYPE_0:
> +                       if (!verify_pmr_eth_type_0(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_ETHTYPE_X:
> +                       if (!verify_pmr_eth_type_x(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_VLAN_ID_0:
> +                       if (!verify_pmr_vlan_id_0(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_VLAN_ID_X:
> +                       if (!verify_pmr_vlan_id_x(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_DMAC:
> +                       if (!verify_pmr_dmac(pkt_addr, pkt_hdr,
> +                                            term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_IPPROTO:
> +                       if (!verify_pmr_ip_proto(pkt_addr, pkt_hdr,
> +                                                term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_UDP_DPORT:
> +                       if (!verify_pmr_udp_dport(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_TCP_DPORT:
> +                       if (!verify_pmr_tcp_dport(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_UDP_SPORT:
> +                       if (!verify_pmr_udp_sport(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_TCP_SPORT:
> +                       if (!verify_pmr_tcp_sport(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_SIP_ADDR:
> +                       if (!verify_pmr_ipv4_saddr(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_DIP_ADDR:
> +                       if (!verify_pmr_ipv4_daddr(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_SIP6_ADDR:
> +                       if (!verify_pmr_ipv6_saddr(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_DIP6_ADDR:
> +                       if (!verify_pmr_ipv6_daddr(pkt_addr, pkt_hdr,
> +                                                  term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_IPSEC_SPI:
> +                       if (!verify_pmr_ipsec_spi(pkt_addr, pkt_hdr,
> +                                                 term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_LD_VNI:
> +                       if (!verify_pmr_ld_vni(pkt_addr, pkt_hdr,
> +                                              term_value))
> +                               pmr_failure = 1;
> +                       break;
> +               case ODP_PMR_INNER_HDR_OFF:
> +                       break;
> +               }
> +
> +               if (pmr_failure)
> +                       return false;
> +       }
> +       odp_atomic_inc_u32(&pmr->s.count);
> +       return true;
> +}
> +
> +cos_t *match_pmr_cos(cos_t *cos, uint8_t *pkt_addr, pmr_t *pmr,
> +                    odp_packet_hdr_t *hdr)
> +{
> +       cos_t *retcos = NULL;
> +
> +       if (cos == NULL || pmr == NULL)
> +               return NULL;
> +
> +       if (!cos->s.valid)
> +               return NULL;
> +
> +       if (verify_pmr(pmr, pkt_addr, hdr)) {
> +               /** This gets called recursively to check all the PMRs in
> +                * a PMR chain */
> +               retcos = match_pmr_cos(cos->s.linked_cos, pkt_addr,
> +                                      cos->s.pmr, hdr);
> +               if (!retcos)
> +                       return cos;
> +       }
> +       return retcos;
> +}
> +
> +int pktio_classifier_init(pktio_entry_t *entry)
> +{
> +       classifier_t *cls;
> +       int i;
> +       /* classifier lock should be acquired by the calling function */
> +       if (entry == NULL)
> +               return -1;
> +       cls = &entry->s.cls;
> +       cls->num_pmr = 0;
> +       cls->flow_set = 0;
> +       cls->error_cos = NULL;
> +       cls->default_cos = NULL;
> +       cls->headroom = 0;
> +       cls->skip = 0;
> +
> +       for (i = 0; i < ODP_PKTIO_MAX_PMR; i++) {
> +               cls->pmr[i] = NULL;
> +               cls->cos[i] = NULL;
> +       }
> +
> +       return 0;
> +}
> +
> +int packet_classifier(odp_pktio_t pktio, odp_packet_t pkt)
> +{
> +       pktio_entry_t *entry;
> +       queue_entry_t *queue;
> +       cos_t *cos;
> +       odp_packet_hdr_t *pkt_hdr;
> +       uint8_t *pkt_addr;
> +
> +       entry = get_pktio_entry(pktio);
> +       if (entry == NULL)
> +               return -1;
> +
> +       pkt_hdr = odp_packet_hdr(pkt);
> +       pkt_addr = odp_packet_addr(pkt);
> +
> +       /* Matching PMR and selecting the CoS for the packet*/
> +       cos = pktio_select_cos(entry, pkt_addr, pkt_hdr);
> +       if (cos == NULL)
> +               return -1;
> +
> +       /* Enqueuing the Packet based on the CoS */
> +       queue = cos->s.queue;
> +       return queue_enq(queue, odp_buf_to_hdr((odp_buffer_t)pkt));
> +}
> +
> +cos_t *pktio_select_cos(pktio_entry_t *entry, uint8_t *pkt_addr,
> +                      odp_packet_hdr_t *pkt_hdr)
> +{
> +       pmr_t *pmr;
> +       cos_t *cos;
> +       uint32_t i;
> +       classifier_t *cls;
> +
> +       cls = &entry->s.cls;
> +
> +       /* Return error cos for error packet */
> +       if (pkt_hdr->error_flags.all)
> +               return cls->error_cos;
> +       /* Calls all the PMRs attached at the PKTIO level*/
> +       for (i = 0; i < cls->num_pmr; i++) {
> +               pmr = entry->s.cls.pmr[i];
> +               cos = entry->s.cls.cos[i];
> +               cos = match_pmr_cos(cos, pkt_addr, pmr, pkt_hdr);
> +               if (cos)
> +                       return cos;
> +       }
> +
> +       cos = match_qos_cos(entry, pkt_addr, pkt_hdr);
> +       if (cos)
> +               return cos;
> +
> +       return cls->default_cos;
> +}
> +
> +cos_t *match_qos_l3_cos(pmr_l3_cos_t *l3_cos, uint8_t *pkt_addr,
> +                       odp_packet_hdr_t *hdr)
> +{
> +       uint8_t dscp;
> +       cos_t *cos = NULL;
> +       odph_ipv4hdr_t *ipv4;
> +       odph_ipv6hdr_t *ipv6;
> +
> +       if (hdr->input_flags.l3 && hdr->input_flags.ipv4) {
> +               ipv4 = (odph_ipv4hdr_t *)(pkt_addr + hdr->l3_offset);
> +               dscp = ODPH_IPV4HDR_DSCP(ipv4->tos);
> +               cos = l3_cos->cos[dscp];
> +       } else if (hdr->input_flags.l3 && hdr->input_flags.ipv6) {
> +               ipv6 = (odph_ipv6hdr_t *)(pkt_addr + hdr->l3_offset);
> +               dscp = ODPH_IPV6HDR_DSCP(ipv6->ver_tc_flow);
> +               cos = l3_cos->cos[dscp];
> +       }
> +
> +       return cos;
> +}
> +
> +cos_t *match_qos_l2_cos(pmr_l2_cos_t *l2_cos, uint8_t *pkt_addr,
> +                       odp_packet_hdr_t *hdr)
> +{
> +       uint8_t qos;
> +       cos_t *cos = NULL;
> +       odph_ethhdr_t *eth;
> +       odph_vlanhdr_t *vlan;
> +
> +       if (hdr->input_flags.l2 && hdr->input_flags.vlan &&
> +           hdr->input_flags.eth) {
> +               eth = (odph_ethhdr_t *)(pkt_addr + hdr->l2_offset);
> +               vlan = (odph_vlanhdr_t *)(&eth->type);
> +               qos = ((vlan->tci >> 13) & 0xFF);
> +               cos = l2_cos->cos[qos];
> +       }
> +       return cos;
> +}
> +
> +cos_t *match_qos_cos(pktio_entry_t *entry, uint8_t *pkt_addr,
> +                    odp_packet_hdr_t *hdr)
> +{
> +       classifier_t *cls = &entry->s.cls;
> +       pmr_l2_cos_t *l2_cos;
> +       pmr_l3_cos_t *l3_cos;
> +       cos_t *cos;
> +
> +       l2_cos = &cls->l2_cos_table;
> +       l3_cos = &cls->l3_cos_table;
> +
> +       if (cls->l3_precedence) {
> +               cos =  match_qos_l3_cos(l3_cos, pkt_addr, hdr);
> +               if (cos)
> +                       return cos;
> +               cos = match_qos_l2_cos(l2_cos, pkt_addr, hdr);
> +               if (cos)
> +                       return cos;
> +       } else {
> +               cos = match_qos_l2_cos(l2_cos, pkt_addr, hdr);
> +               if (cos)
> +                       return cos;
> +               cos = match_qos_l3_cos(l3_cos, pkt_addr, hdr);
> +               if (cos)
> +                       return cos;
> +       }
> +       return NULL;
> +}
> diff --git a/platform/linux-generic/odp_init.c
> b/platform/linux-generic/odp_init.c
> index 672b3d6..c661231 100644
> --- a/platform/linux-generic/odp_init.c
> +++ b/platform/linux-generic/odp_init.c
> @@ -54,6 +54,10 @@ int odp_init_global(odp_init_t *params  ODP_UNUSED,
>                 ODP_ERR("ODP crypto init failed.\n");
>                 return -1;
>         }
> +       if (odp_classification_init_global()) {
> +               ODP_ERR("ODP crypto init failed.\n");
> +               return -1;
> +       }
>
>         return 0;
>  }
> diff --git a/platform/linux-generic/odp_packet_io.c
> b/platform/linux-generic/odp_packet_io.c
> index 19b9eea..6bda003 100644
> --- a/platform/linux-generic/odp_packet_io.c
> +++ b/platform/linux-generic/odp_packet_io.c
> @@ -13,10 +13,10 @@
>  #include <odp_spinlock.h>
>  #include <odp_shared_memory.h>
>  #include <odp_packet_socket.h>
> -#include <odp_hints.h>
>  #include <odp_config.h>
>  #include <odp_queue_internal.h>
>  #include <odp_schedule_internal.h>
> +#include <odp_classification_internal.h>
>  #include <odp_debug_internal.h>
>
>  #include <string.h>
> @@ -50,6 +50,7 @@ int odp_pktio_init_global(void)
>                 pktio_entry = &pktio_tbl->entries[id - 1];
>
>                 odp_spinlock_init(&pktio_entry->s.lock);
> +               odp_spinlock_init(&pktio_entry->s.cls.lock);
>
>                 pktio_entry_ptr[id - 1] = pktio_entry;
>                 /* Create a default output queue for each pktio resource */
> @@ -98,12 +99,25 @@ static void unlock_entry(pktio_entry_t *entry)
>         odp_spinlock_unlock(&entry->s.lock);
>  }
>
> +static void lock_entry_classifier(pktio_entry_t *entry)
> +{
> +       odp_spinlock_lock(&entry->s.lock);
> +       odp_spinlock_lock(&entry->s.cls.lock);
> +}
> +
> +static void unlock_entry_classifier(pktio_entry_t *entry)
> +{
> +       odp_spinlock_unlock(&entry->s.cls.lock);
> +       odp_spinlock_unlock(&entry->s.lock);
> +}
> +
>  static void init_pktio_entry(pktio_entry_t *entry)
>  {
>         set_taken(entry);
>         entry->s.inq_default = ODP_QUEUE_INVALID;
>         memset(&entry->s.pkt_sock, 0, sizeof(entry->s.pkt_sock));
>         memset(&entry->s.pkt_sock_mmap, 0, sizeof(entry->s.pkt_sock_mmap));
> +       pktio_classifier_init(entry);
>  }
>
>  static odp_pktio_t alloc_lock_pktio_entry(void)
> @@ -115,13 +129,13 @@ static odp_pktio_t alloc_lock_pktio_entry(void)
>         for (i = 0; i < ODP_CONFIG_PKTIO_ENTRIES; ++i) {
>                 entry = &pktio_tbl->entries[i];
>                 if (is_free(entry)) {
> -                       lock_entry(entry);
> +                       lock_entry_classifier(entry);
>                         if (is_free(entry)) {
>                                 init_pktio_entry(entry);
>                                 id = i + 1;
>                                 return id; /* return with entry locked! */
>                         }
> -                       unlock_entry(entry);
> +                       unlock_entry_classifier(entry);
>                 }
>         }
>
> @@ -190,14 +204,14 @@ odp_pktio_t odp_pktio_open(const char *dev,
> odp_buffer_pool_t pool)
>                 close_pkt_sock(&pktio_entry->s.pkt_sock);
>         }
>
> -       unlock_entry(pktio_entry);
> +       unlock_entry_classifier(pktio_entry);
>         free_pktio_entry(id);
>         ODP_ERR("Unable to init any I/O type.\n");
>         return ODP_PKTIO_INVALID;
>
>  done:
>         strncpy(pktio_entry->s.name, dev, IFNAMSIZ);
> -       unlock_entry(pktio_entry);
> +       unlock_entry_classifier(pktio_entry);
>         return id;
>  }
>
> @@ -415,7 +429,7 @@ odp_buffer_hdr_t *pktin_dequeue(queue_entry_t *qentry)
>         odp_buffer_t buf;
>         odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
>         odp_buffer_hdr_t *tmp_hdr_tbl[QUEUE_MULTI_MAX];
> -       int pkts, i;
> +       int pkts, i, j;
>
>         buf_hdr = queue_deq(qentry);
>         if (buf_hdr != NULL)
> @@ -425,12 +439,15 @@ odp_buffer_hdr_t *pktin_dequeue(queue_entry_t
> *qentry)
>         if (pkts <= 0)
>                 return NULL;
>
> -       for (i = 0; i < pkts; ++i) {
> +       for (i = 0, j = 0; i < pkts; ++i) {
>                 buf = odp_packet_to_buffer(pkt_tbl[i]);
> -               tmp_hdr_tbl[i] = odp_buf_to_hdr(buf);
> +               buf_hdr = odp_buf_to_hdr(buf);
> +               if (0 > packet_classifier(qentry->s.pktin, pkt_tbl[i]))
> +                       tmp_hdr_tbl[j++] = buf_hdr;
>         }
>
> -       queue_enq_multi(qentry, tmp_hdr_tbl, pkts);
> +       if (j)
> +               queue_enq_multi(qentry, tmp_hdr_tbl, j);
>         buf_hdr = tmp_hdr_tbl[0];
>         return buf_hdr;
>  }
> @@ -446,8 +463,9 @@ int pktin_deq_multi(queue_entry_t *qentry,
> odp_buffer_hdr_t *buf_hdr[], int num)
>         int nbr;
>         odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
>         odp_buffer_hdr_t *tmp_hdr_tbl[QUEUE_MULTI_MAX];
> +       odp_buffer_hdr_t *tmp_hdr;
>         odp_buffer_t buf;
> -       int pkts, i;
> +       int pkts, i, j;
>
>         nbr = queue_deq_multi(qentry, buf_hdr, num);
>         if (odp_unlikely(nbr > num))
> @@ -464,12 +482,15 @@ int pktin_deq_multi(queue_entry_t *qentry,
> odp_buffer_hdr_t *buf_hdr[], int num)
>         if (pkts <= 0)
>                 return nbr;
>
> -       for (i = 0; i < pkts; ++i) {
> +       for (i = 0, j = 0; i < pkts; ++i) {
>                 buf = odp_packet_to_buffer(pkt_tbl[i]);
> -               tmp_hdr_tbl[i] = odp_buf_to_hdr(buf);
> +               tmp_hdr = odp_buf_to_hdr(buf);
> +               if (0 > packet_classifier(qentry->s.pktin, pkt_tbl[i]))
> +                       tmp_hdr_tbl[j++] = tmp_hdr;
>         }
>
> -       queue_enq_multi(qentry, tmp_hdr_tbl, pkts);
> +       if (j)
> +               queue_enq_multi(qentry, tmp_hdr_tbl, j);
>         return nbr;
>  }
>
> --
> 2.0.1.472.g6f92e5f
>
>
> _______________________________________________
> lng-odp mailing list
> lng-odp@lists.linaro.org
> http://lists.linaro.org/mailman/listinfo/lng-odp
>

Patch

diff --git a/helper/include/odph_ip.h b/helper/include/odph_ip.h
index 2c83c0f..f78724e 100644
--- a/helper/include/odph_ip.h
+++ b/helper/include/odph_ip.h
@@ -35,6 +35,9 @@  extern "C" {
 /** @internal Returns IPv4 header length */
 #define ODPH_IPV4HDR_IHL(ver_ihl) ((ver_ihl) & 0x0f)
 
+/** @internal Returns IPv4 DSCP */
+#define ODPH_IPV4HDR_DSCP(tos) (((tos) & 0xfc) >> 2)
+
 /** @internal Returns IPv4 Don't fragment */
 #define ODPH_IPV4HDR_FLAGS_DONT_FRAG(frag_offset)  ((frag_offset) & 0x4000)
 
@@ -47,6 +50,9 @@  extern "C" {
 /** @internal Returns true if IPv4 packet is a fragment */
 #define ODPH_IPV4HDR_IS_FRAGMENT(frag_offset) ((frag_offset) & 0x3fff)
 
+/** @internal Returns IPv4 DSCP */
+#define ODPH_IPV6HDR_DSCP(ver_tc_flow) (uint8_t)((((ver_tc_flow) & 0x0fc00000) >> 22) & 0xff)
+
 /** IPv4 header */
 typedef struct ODP_PACKED {
 	uint8_t    ver_ihl;     /**< Version / Header length */
diff --git a/platform/linux-generic/include/api/odp.h b/platform/linux-generic/include/api/odp.h
index 6e4f69e..b7b1ca9 100644
--- a/platform/linux-generic/include/api/odp.h
+++ b/platform/linux-generic/include/api/odp.h
@@ -47,6 +47,7 @@  extern "C" {
 #include <odp_packet_flags.h>
 #include <odp_packet_io.h>
 #include <odp_crypto.h>
+#include <odp_classification.h>
 #include <odp_rwlock.h>
 
 #ifdef __cplusplus
diff --git a/platform/linux-generic/include/odp_buffer_pool_internal.h b/platform/linux-generic/include/odp_buffer_pool_internal.h
index e0210bd..07602fe 100644
--- a/platform/linux-generic/include/odp_buffer_pool_internal.h
+++ b/platform/linux-generic/include/odp_buffer_pool_internal.h
@@ -22,6 +22,7 @@  extern "C" {
 #include <odp_buffer_pool.h>
 #include <odp_buffer_internal.h>
 #include <odp_align.h>
+#include <odp_align_internal.h>
 #include <odp_hints.h>
 #include <odp_config.h>
 #include <odp_debug.h>
@@ -64,6 +65,10 @@  struct pool_entry_s {
 	size_t                  hdr_size;
 };
 
+typedef union pool_entry_u {
+	struct pool_entry_s s;
+	uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct pool_entry_s))];
+} pool_entry_t;
 
 extern void *pool_entry_ptr[];
 
@@ -73,6 +78,10 @@  static inline void *get_pool_entry(uint32_t pool_id)
 	return pool_entry_ptr[pool_id];
 }
 
+static inline uint32_t pool_handle_to_index(odp_buffer_pool_t pool_hdl)
+{
+	return pool_hdl - 1;
+}
 
 static inline odp_buffer_hdr_t *odp_buf_to_hdr(odp_buffer_t buf)
 {
diff --git a/platform/linux-generic/include/odp_classification_datamodel.h b/platform/linux-generic/include/odp_classification_datamodel.h
new file mode 100644
index 0000000..18846bc
--- /dev/null
+++ b/platform/linux-generic/include/odp_classification_datamodel.h
@@ -0,0 +1,201 @@ 
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:     BSD-3-Clause
+ */
+
+
+/**
+ * @file
+ *
+ * ODP Classification Datamodel
+ * Describes the classification internal data model
+ */
+
+#ifndef ODP_CLASSIFICATION_DATAMODEL_H_
+#define ODP_CLASSIFICATION_DATAMODEL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <odp_spinlock.h>
+#include <odp_classification.h>
+#include <odp_buffer_pool_internal.h>
+#include <odp_packet_internal.h>
+#include <odp_packet_io_internal.h>
+#include <odp_queue_internal.h>
+
+/* Maximum Class Of Service Entry */
+#define ODP_COS_MAX_ENTRY		64
+/* Maximum PMR Set Entry */
+#define ODP_PMRSET_MAX_ENTRY		64
+/* Maximum PMR Entry */
+#define ODP_PMR_MAX_ENTRY		64
+/* Maximum PMR Terms in a PMR Set */
+#define ODP_PMRTERM_MAX			8
+/* Maximum PMRs attached in PKTIO Level */
+#define ODP_PKTIO_MAX_PMR		8
+/* L2 Priority Bits */
+#define ODP_COS_L2_QOS_BITS		3
+/* Max L2 QoS value */
+#define ODP_COS_MAX_L2_QOS		(1 << ODP_COS_L2_QOS_BITS)
+/* L2 DSCP Bits */
+#define ODP_COS_L3_QOS_BITS		6
+/* Max L3 QoS Value */
+#define ODP_COS_MAX_L3_QOS		(1 << ODP_COS_L3_QOS_BITS)
+/* Max PMR Term bits */
+#define ODP_PMR_TERM_BYTES_MAX		8
+
+/* forward declaration */
+typedef union pmr_u pmr_t;
+
+/**
+Packet Matching Rule Term Value
+
+Stores the Term and Value mapping for a PMR.
+The maximum size of value currently supported in 64 bits
+**/
+typedef struct pmr_term_value {
+	odp_pmr_match_type_e match_type; /**< Packet Match Type*/
+	odp_pmr_term_e  term;		/* PMR Term */
+	union {
+		struct {
+			uint64_t	val;
+			uint64_t	mask;
+		} mask; /**< Match a masked set of bits */
+		struct {
+			uint64_t	val1;
+			uint64_t	val2;
+		} range; /**< Match an integer range */
+	};
+} pmr_term_value_t;
+
+typedef union cos_u cos_t;
+/*
+Class Of Service
+*/
+struct cos_s {
+	queue_entry_t *queue;		/* Associated Queue */
+	pool_entry_t *pool;		/* Associated Buffer pool */
+	pmr_t *pmr;			/* Chained PMR */
+	cos_t *linked_cos;		/* CoS linked with the PMR */
+	uint32_t valid;			/* validity Flag */
+	odp_drop_e drop_policy;		/* Associated Drop Policy */
+	odp_queue_group_t queue_group;	/* Associated Queue Group */
+	odp_cos_flow_set_t flow_set;	/* Assigned Flow Set */
+	char name[ODP_COS_NAME_LEN];	/* name */
+	size_t headroom;		/* Headroom for this CoS */
+	odp_spinlock_t lock;		/* cos lock */
+};
+
+typedef union cos_u {
+	struct cos_s s;
+	uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct cos_s))];
+} cos_t;
+
+
+/**
+Packet Matching Rule
+
+**/
+struct pmr_s {
+	uint32_t valid;			/* Validity Flag */
+	odp_atomic_u32_t count;		/* num of packets matching this rule */
+	uint32_t num_pmr;		/* num of PMR Term Values*/
+	odp_spinlock_t lock;		/* pmr lock*/
+	pmr_term_value_t  pmr_term_value[1];	/* Associated PMR Term */
+};
+
+typedef union pmr_u {
+	struct pmr_s s;
+	uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct pmr_s))];
+} pmr_t;
+
+/**
+Packet Matching Rule Set
+
+This structure is implemented as a extension over struct pmr_s
+In order to use same pointer to access both pmr_s and pmr_set_s
+'num_pmr' value is used to differentiate between pmr_s and pmr_set_s struct
+**/
+struct pmr_set_s {
+	pmr_t pmr;
+	pmr_term_value_t  pmr_term_value[ODP_PMRTERM_MAX - 1];
+			/* List of associated PMR Terms */
+};
+
+typedef union pmr_set_u {
+	struct pmr_set_s s;
+	uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct pmr_set_s))];
+} pmr_set_t;
+
+/**
+L2 QoS and CoS Map
+
+This structure holds the mapping between L2 QoS value and
+corresponding cos_t object
+**/
+typedef struct pmr_l2_cos {
+	odp_spinlock_t lock;	/* pmr_l2_cos lock */
+	cos_t *cos[ODP_COS_MAX_L2_QOS];	/* Array of CoS objects */
+} pmr_l2_cos_t;
+
+/**
+L3 QoS and CoS Map
+
+This structure holds the mapping between L3 QoS value and
+corresponding cos_t object
+**/
+typedef struct pmr_l3_cos {
+	odp_spinlock_t lock;	/* pmr_l3_cos lock */
+	cos_t *cos[ODP_COS_MAX_L3_QOS];	/* Array of CoS objects */
+} pmr_l3_cos_t;
+
+/**
+Linux Generic Classifier
+
+This structure is stored in pktio_entry and holds all
+the classifier configuration value.
+**/
+typedef struct classifier {
+	odp_spinlock_t lock;		/*pktio_cos lock */
+	uint32_t num_pmr;		/* num of PMRs linked to given PKTIO*/
+	pmr_t *pmr[ODP_PKTIO_MAX_PMR];	/* PMRs linked with this PKTIO */
+	cos_t *cos[ODP_PKTIO_MAX_PMR];	/* CoS linked with this PKTIO */
+	cos_t *error_cos;		/* Associated Error CoS */
+	cos_t *default_cos;		/* Associated Default CoS */
+	uint32_t l3_precedence;		/* L3 QoS precedence */
+	pmr_l2_cos_t l2_cos_table;	/* L2 QoS-CoS table map */
+	pmr_l3_cos_t l3_cos_table;	/* L3 Qos-CoS table map */
+	odp_cos_flow_set_t flow_set;	/* Flow Set to be calculated
+					for this pktio */
+	size_t headroom;		/* Pktio Headroom */
+	size_t skip;			/* Pktio Skip Offset */
+} classifier_t;
+
+/**
+Class of Service Table
+**/
+typedef struct odp_cos_table {
+	cos_t cos_entry[ODP_COS_MAX_ENTRY];
+} cos_tbl_t;
+
+/**
+PMR set table
+**/
+typedef struct pmr_set_tbl {
+	pmr_set_t pmr_set[ODP_PMRSET_MAX_ENTRY];
+} pmr_set_tbl_t;
+
+/**
+PMR table
+**/
+typedef struct pmr_tbl {
+	pmr_t pmr[ODP_PMR_MAX_ENTRY];
+} pmr_tbl_t;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/platform/linux-generic/include/odp_classification_inlines.h b/platform/linux-generic/include/odp_classification_inlines.h
new file mode 100644
index 0000000..6b20119
--- /dev/null
+++ b/platform/linux-generic/include/odp_classification_inlines.h
@@ -0,0 +1,259 @@ 
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:     BSD-3-Clause
+ */
+
+
+/**
+ * @file
+ *
+ * ODP Classification Inlines
+ * Classification Inlines Functions
+ */
+#ifndef __ODP_CLASSIFICATION_INLINES_H_
+#define __ODP_CLASSIFICATION_INLINES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <odp_debug.h>
+#include <odph_eth.h>
+#include <odph_ip.h>
+#include <odph_udp.h>
+#include <odph_tcp.h>
+
+/* PMR term value verification function
+These functions verify the given PMR term value with the value in the packet
+These following functions return 1 on success and 0 on failure
+*/
+
+static inline int verify_pmr_packet_len(odp_packet_hdr_t *pkt_hdr,
+					pmr_term_value_t *term_value)
+{
+	if (term_value->match_type == ODP_PMR_MASK) {
+		if (term_value->mask.val == (pkt_hdr->frame_len &
+		    term_value->mask.mask))
+			return 1;
+	} else {
+		if ((term_value->range.val1 <= pkt_hdr->frame_len) &&
+		    (pkt_hdr->frame_len <= term_value->range.val2))
+			return 1;
+	}
+	return 0;
+}
+static inline int verify_pmr_ip_proto(uint8_t *pkt_addr,
+				      odp_packet_hdr_t *pkt_hdr,
+				      pmr_term_value_t *term_value)
+{
+	odph_ipv4hdr_t *ip;
+	uint8_t proto;
+	if (!pkt_hdr->input_flags.ipv4)
+		return 0;
+	ip = (odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
+	proto = ip->proto;
+	if (term_value->match_type == ODP_PMR_MASK) {
+		if (term_value->mask.val == (proto & term_value->mask.mask))
+			return 1;
+	} else {
+		if ((term_value->range.val1 <= proto) &&
+		    (proto <= term_value->range.val2))
+			return 1;
+	}
+	return 0;
+}
+
+static inline int verify_pmr_ipv4_saddr(uint8_t *pkt_addr,
+					odp_packet_hdr_t *pkt_hdr,
+					pmr_term_value_t *term_value)
+{
+	odph_ipv4hdr_t *ip;
+	uint32_t ipaddr;
+	if (!pkt_hdr->input_flags.ipv4)
+		return 0;
+	ip = (odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
+	ipaddr = odp_be_to_cpu_32(ip->src_addr);
+	if (term_value->match_type == ODP_PMR_MASK) {
+		if (term_value->mask.val == (ipaddr & term_value->mask.mask))
+			return 1;
+	} else {
+		if ((term_value->range.val1 <= ipaddr) &&
+		    (ipaddr <= term_value->range.val2))
+			return 1;
+	}
+	return 0;
+}
+
+static inline int verify_pmr_ipv4_daddr(uint8_t *pkt_addr,
+					odp_packet_hdr_t *pkt_hdr,
+					pmr_term_value_t *term_value)
+{
+	odph_ipv4hdr_t *ip;
+	uint32_t ipaddr;
+	if (!pkt_hdr->input_flags.ipv4)
+		return 0;
+	ip = (odph_ipv4hdr_t *)(pkt_addr + pkt_hdr->l3_offset);
+	ipaddr = odp_be_to_cpu_32(ip->dst_addr);
+	if (term_value->match_type == ODP_PMR_MASK) {
+		if (term_value->mask.val == (ipaddr & term_value->mask.mask))
+			return 1;
+	} else {
+		if ((term_value->range.val1 <= ipaddr) &&
+		    (ipaddr <= term_value->range.val2))
+			return 1;
+	}
+	return 0;
+}
+
+static inline int verify_pmr_tcp_sport(uint8_t *pkt_addr,
+				       odp_packet_hdr_t *pkt_hdr,
+				       pmr_term_value_t *term_value)
+{
+	uint16_t sport;
+	odph_tcphdr_t *tcp;
+	if (!pkt_hdr->input_flags.tcp)
+		return 0;
+	tcp = (odph_tcphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
+	sport = odp_be_to_cpu_16(tcp->src_port);
+	if (term_value->match_type == ODP_PMR_MASK) {
+		if (term_value->mask.val == (sport & term_value->mask.mask))
+			return 1;
+	} else {
+		if ((term_value->range.val1 <= sport) &&
+		    (sport <= term_value->range.val2))
+			return 1;
+	}
+	return 0;
+}
+
+static inline int verify_pmr_tcp_dport(uint8_t *pkt_addr,
+				       odp_packet_hdr_t *pkt_hdr,
+				       pmr_term_value_t *term_value)
+{
+	uint16_t dport;
+	odph_tcphdr_t *tcp;
+	if (!pkt_hdr->input_flags.tcp)
+		return 0;
+	tcp = (odph_tcphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
+	dport = odp_be_to_cpu_16(tcp->dst_port);
+	if (term_value->match_type == ODP_PMR_MASK) {
+		if (term_value->mask.val == (dport & term_value->mask.mask))
+			return 1;
+	} else {
+		if ((term_value->range.val1 <= dport) &&
+		    (dport <= term_value->range.val2))
+			return 1;
+	}
+	return 0;
+}
+
+static inline int verify_pmr_udp_dport(uint8_t *pkt_addr,
+				       odp_packet_hdr_t *pkt_hdr,
+				       pmr_term_value_t *term_value)
+{
+	uint16_t dport;
+	odph_udphdr_t *udp;
+	if (!pkt_hdr->input_flags.udp)
+		return 0;
+	udp = (odph_udphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
+	dport = odp_be_to_cpu_16(udp->dst_port);
+	if (term_value->match_type == ODP_PMR_MASK) {
+		if (term_value->mask.val == (dport & term_value->mask.mask))
+			return 1;
+	} else {
+		if ((term_value->range.val1 <= dport) &&
+		    (dport <= term_value->range.val2))
+			return 1;
+	}
+	return 0;
+}
+static inline int verify_pmr_udp_sport(uint8_t *pkt_addr,
+				       odp_packet_hdr_t *pkt_hdr,
+				       pmr_term_value_t *term_value)
+{
+	uint16_t sport;
+	odph_udphdr_t *udp;
+	if (!pkt_hdr->input_flags.udp)
+		return 0;
+	udp = (odph_udphdr_t *)(pkt_addr + pkt_hdr->l4_offset);
+	sport = odp_be_to_cpu_16(udp->src_port);
+	if (term_value->match_type == ODP_PMR_MASK) {
+		if (term_value->mask.val == (sport & term_value->mask.mask))
+			return 1;
+	} else {
+		if ((term_value->range.val1 <= sport) &&
+		    (sport <= term_value->range.val2))
+			return 1;
+	}
+	return 0;
+}
+
+static inline int verify_pmr_dmac(uint8_t *pkt_addr ODP_UNUSED,
+				  odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
+				  pmr_term_value_t *term_value ODP_UNUSED)
+{
+	ODP_UNIMPLEMENTED();
+	return 0;
+}
+
+static inline int verify_pmr_ipv6_saddr(uint8_t *pkt_addr ODP_UNUSED,
+					odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
+					pmr_term_value_t *term_value ODP_UNUSED)
+{
+	ODP_UNIMPLEMENTED();
+	return 0;
+}
+static inline int verify_pmr_ipv6_daddr(uint8_t *pkt_addr ODP_UNUSED,
+					odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
+					pmr_term_value_t *term_value ODP_UNUSED)
+{
+	ODP_UNIMPLEMENTED();
+	return 0;
+}
+static inline int verify_pmr_vlan_id_0(uint8_t *pkt_addr ODP_UNUSED,
+				       odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
+				       pmr_term_value_t *term_value ODP_UNUSED)
+{
+	ODP_UNIMPLEMENTED();
+	return 0;
+}
+static inline int verify_pmr_vlan_id_x(uint8_t *pkt_addr ODP_UNUSED,
+				       odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
+				       pmr_term_value_t *term_value ODP_UNUSED)
+{
+	ODP_UNIMPLEMENTED();
+	return 0;
+}
+static inline int verify_pmr_ipsec_spi(uint8_t *pkt_addr ODP_UNUSED,
+				       odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
+				       pmr_term_value_t *term_value ODP_UNUSED)
+{
+	ODP_UNIMPLEMENTED();
+	return 0;
+}
+static inline int verify_pmr_ld_vni(uint8_t *pkt_addr ODP_UNUSED,
+				    odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
+				    pmr_term_value_t *term_value ODP_UNUSED)
+{
+	ODP_UNIMPLEMENTED();
+	return 0;
+}
+static inline int verify_pmr_eth_type_0(uint8_t *pkt_addr ODP_UNUSED,
+					odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
+					pmr_term_value_t *term_value ODP_UNUSED)
+{
+	ODP_UNIMPLEMENTED();
+	return 0;
+}
+static inline int verify_pmr_eth_type_x(uint8_t *pkt_addr ODP_UNUSED,
+					odp_packet_hdr_t *pkt_hdr ODP_UNUSED,
+					pmr_term_value_t *term_value ODP_UNUSED)
+{
+	ODP_UNIMPLEMENTED();
+	return 0;
+}
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/platform/linux-generic/include/odp_classification_internal.h b/platform/linux-generic/include/odp_classification_internal.h
new file mode 100644
index 0000000..fd2c6af
--- /dev/null
+++ b/platform/linux-generic/include/odp_classification_internal.h
@@ -0,0 +1,173 @@ 
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:     BSD-3-Clause
+ */
+
+
+/**
+ * @file
+ *
+ * ODP Classification Internal
+ * Describes the classification internal Functions
+ */
+
+#ifndef __ODP_CLASSIFICATION_INTERNAL_H_
+#define __ODP_CLASSIFICATION_INTERNAL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <odp_classification.h>
+#include <odp_queue.h>
+#include <odp_packet_internal.h>
+#include <odp_packet_io.h>
+#include <odp_packet_io_internal.h>
+#include <odp_classification_datamodel.h>
+
+/** Classification Internal function **/
+
+/**
+@internal
+Select a CoS for the given Packet based on pktio
+
+This function will call all the PMRs associated with a pktio for
+a given packet and will return the matched COS object.
+This function will check PMR, L2 and L3 QoS COS object associated
+with the PKTIO interface.
+
+Returns the default cos if the packet does not match any PMR
+Returns the error_cos if the packet has an error
+**/
+cos_t *pktio_select_cos(pktio_entry_t *pktio, uint8_t *pkt_addr,
+		       odp_packet_hdr_t *pkt_hdr);
+
+/**
+@internal
+match_qos_cos
+
+Select a CoS for the given Packet based on QoS values
+This function returns the COS object matching the L2 and L3 QoS
+based on the l3_preference value of the pktio
+**/
+cos_t *match_qos_cos(pktio_entry_t *entry, uint8_t *pkt_addr,
+		     odp_packet_hdr_t *hdr);
+/**
+Packet Classifier
+
+Start function for Packet Classifier
+This function calls Classifier module internal functions for a given packet and
+enqueues the packet to specific Queue based on PMR and CoS selected.
+**/
+int packet_classifier(odp_pktio_t pktio, odp_packet_t pkt);
+/**
+Packet IO classifier init
+
+This function does initialization of classifier object associated with pktio.
+This function should be called during pktio initialization.
+**/
+int pktio_classifier_init(pktio_entry_t *pktio);
+
+/**
+@internal
+match_pmr_cos
+
+Match a PMR chain with a Packet and return matching CoS
+This function gets called recursively to check the chained PMR Term value
+with the packet.
+
+**/
+cos_t *match_pmr_cos(cos_t *cos, uint8_t *pkt_addr, pmr_t *pmr,
+		     odp_packet_hdr_t *hdr);
+/**
+@internal
+CoS associated with L3 QoS value
+
+This function returns the CoS associated with L3 QoS value
+**/
+cos_t *match_qos_l3_cos(pmr_l3_cos_t *l3_cos, uint8_t *pkt_addr,
+			odp_packet_hdr_t *hdr);
+
+/**
+@internal
+CoS associated with L2 QoS value
+
+This function returns the CoS associated with L2 QoS value
+**/
+cos_t *match_qos_l2_cos(pmr_l2_cos_t *l2_cos, uint8_t *pkt_addr,
+			odp_packet_hdr_t *hdr);
+/**
+@internal
+Flow Signature Calculation
+
+This function calculates the Flow Signature for a packet based on
+CoS and updates in Packet Meta Data
+**/
+int update_flow_signature(uint8_t *pkt_addr, cos_t *cos);
+
+/**
+@internal
+Allocate a odp_pmr_set_t Handle
+*/
+odp_pmr_set_t alloc_pmr_set(pmr_t **pmr);
+
+/**
+@internal
+Allocate a odp_pmr_t Handle
+*/
+odp_pmr_t alloc_pmr(pmr_t **pmr);
+
+/**
+@internal
+Pointer to pmr_set_t Handle
+This function checks for validity of pmr_set_t Handle
+*/
+pmr_set_t *get_pmr_set_entry(odp_pmr_set_t pmr_set_id);
+
+/**
+@internal
+Pointer to pmr_set_t Handle
+*/
+pmr_set_t *get_pmr_set_entry_internal(odp_pmr_set_t pmr_set_id);
+
+/**
+@internal
+Pointer to pmr_set_t Handle
+This function checks for validity of pmr_set_t Handle
+*/
+pmr_t *get_pmr_entry(odp_pmr_t pmr_id);
+
+/**
+@internal
+Pointer to pmr_set_t Handle
+*/
+pmr_t *get_pmr_entry_internal(odp_pmr_t pmr_id);
+
+/**
+@internal
+Pointer to odp_cos_t Handle
+*/
+cos_t *get_cos_entry(odp_cos_t cos_id);
+
+/**
+@internal
+Pointer to odp_cos_t Handle
+This function checks for validity of odp_cos_t Handle
+*/
+cos_t *get_cos_entry_internal(odp_cos_t cos_id);
+
+/**
+@internal
+Verify PMR with a Packet
+
+This function goes through each PMR_TERM value in pmr_t structure and
+calls verification function for each term.Returns 1 if PMR matches or 0
+Otherwise.
+**/
+int verify_pmr(pmr_t *pmr, uint8_t *pkt_addr, odp_packet_hdr_t *pkt_hdr);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/platform/linux-generic/include/odp_internal.h b/platform/linux-generic/include/odp_internal.h
index f8c1596..04c1030 100644
--- a/platform/linux-generic/include/odp_internal.h
+++ b/platform/linux-generic/include/odp_internal.h
@@ -32,6 +32,8 @@  int odp_buffer_pool_init_global(void);
 int odp_pktio_init_global(void);
 int odp_pktio_init_local(void);
 
+int odp_classification_init_global(void);
+
 int odp_queue_init_global(void);
 
 int odp_crypto_init_global(void);
diff --git a/platform/linux-generic/include/odp_packet_io_internal.h b/platform/linux-generic/include/odp_packet_io_internal.h
index d129f22..465127b 100644
--- a/platform/linux-generic/include/odp_packet_io_internal.h
+++ b/platform/linux-generic/include/odp_packet_io_internal.h
@@ -20,6 +20,7 @@  extern "C" {
 
 #include <odp_spinlock.h>
 #include <odp_packet_socket.h>
+#include <odp_classification_datamodel.h>
 #include <odp_align_internal.h>
 
 #include <odp_config.h>
@@ -43,6 +44,7 @@  struct pktio_entry {
 	odp_pktio_type_t type;		/**< pktio type */
 	pkt_sock_t pkt_sock;		/**< using socket API for IO */
 	pkt_sock_mmap_t pkt_sock_mmap;	/**< using socket mmap API for IO */
+	classifier_t cls;		/**< classifier linked with this pktio*/
 	char name[IFNAMSIZ];		/**< name of pktio provided to
 					   pktio_open() */
 };
diff --git a/platform/linux-generic/odp_buffer_pool.c b/platform/linux-generic/odp_buffer_pool.c
index 83c51fa..d20999b 100644
--- a/platform/linux-generic/odp_buffer_pool.c
+++ b/platform/linux-generic/odp_buffer_pool.c
@@ -57,12 +57,6 @@  typedef struct {
 } odp_any_buffer_hdr_t;
 
 
-typedef union pool_entry_u {
-	struct pool_entry_s s;
-
-	uint8_t pad[ODP_CACHE_LINE_SIZE_ROUNDUP(sizeof(struct pool_entry_s))];
-
-} pool_entry_t;
 
 
 typedef struct pool_table_t {
@@ -87,10 +81,6 @@  static inline odp_buffer_pool_t pool_index_to_handle(uint32_t pool_id)
 }
 
 
-static inline uint32_t pool_handle_to_index(odp_buffer_pool_t pool_hdl)
-{
-	return pool_hdl -1;
-}
 
 
 static inline void set_handle(odp_buffer_hdr_t *hdr,
diff --git a/platform/linux-generic/odp_classification.c b/platform/linux-generic/odp_classification.c
index 190d71e..e3c4bf7 100644
--- a/platform/linux-generic/odp_classification.c
+++ b/platform/linux-generic/odp_classification.c
@@ -1,69 +1,318 @@ 
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:     BSD-3-Clause
+ */
+
 #include <odp_classification.h>
 #include <odp_align.h>
 #include <odp_queue.h>
 #include <odp_debug.h>
+#include <odp_internal.h>
 #include <odp_debug_internal.h>
+#include <odp_packet_internal.h>
 #include <odp_packet_io.h>
+#include <odp_packet_io_internal.h>
+#include <odp_classification_datamodel.h>
+#include <odp_classification_inlines.h>
+#include <odp_classification_internal.h>
+#include <odp_buffer_pool_internal.h>
+#include <odp_shared_memory.h>
+#include <odph_eth.h>
+#include <string.h>
+#include <odp_spinlock.h>
 
-odp_cos_t odp_cos_create(const char *name)
+#define LOCK(a)      odp_spinlock_lock(a)
+#define UNLOCK(a)    odp_spinlock_unlock(a)
+#define LOCK_INIT(a)	odp_spinlock_init(a)
+
+static cos_tbl_t *cos_tbl;
+static pmr_set_tbl_t	*pmr_set_tbl;
+static pmr_tbl_t	*pmr_tbl;
+
+cos_t *get_cos_entry_internal(odp_cos_t cos_id)
+{
+	return &(cos_tbl->cos_entry[cos_id]);
+}
+
+pmr_set_t *get_pmr_set_entry_internal(odp_pmr_set_t pmr_set_id)
+{
+	return &(pmr_set_tbl->pmr_set[pmr_set_id]);
+}
+
+pmr_t *get_pmr_entry_internal(odp_pmr_t pmr_id)
 {
-	(void) name;
-	ODP_UNIMPLEMENTED();
+	return &(pmr_tbl->pmr[pmr_id]);
+}
+
+int odp_classification_init_global(void)
+{
+	odp_shm_t cos_shm;
+	odp_shm_t pmr_shm;
+	odp_shm_t pmr_set_shm;
+	int i;
+
+	cos_shm = odp_shm_reserve("shm_odp_cos_tbl",
+			sizeof(cos_tbl_t),
+			sizeof(cos_t), 0);
+
+	if (cos_shm == ODP_SHM_INVALID) {
+		ODP_ERR("shm allocation failed for shm_odp_cos_tbl");
+		return -1;
+	}
+
+	cos_tbl = odp_shm_addr(cos_shm);
+	if (cos_tbl == NULL) {
+		odp_shm_free(cos_shm);
+		return -1;
+	}
+
+	memset(cos_tbl, 0, sizeof(cos_tbl_t));
+	for (i = 0; i < ODP_COS_MAX_ENTRY; i++) {
+		/* init locks */
+		cos_t *cos = get_cos_entry_internal(i);
+		LOCK_INIT(&cos->s.lock);
+	}
+
+	pmr_shm = odp_shm_reserve("shm_odp_pmr_tbl",
+			sizeof(pmr_tbl_t),
+			sizeof(pmr_t), 0);
+
+	if (pmr_shm == ODP_SHM_INVALID) {
+		ODP_ERR("shm allocation failed for shm_odp_pmr_tbl");
+		return -1;
+	}
+
+	pmr_tbl = odp_shm_addr(pmr_shm);
+	if (pmr_tbl == NULL) {
+		odp_shm_free(pmr_shm);
+		return -1;
+	}
+
+	memset(pmr_tbl, 0, sizeof(pmr_tbl_t));
+	for (i = 0; i < ODP_PMR_MAX_ENTRY; i++) {
+		/* init locks */
+		pmr_t *pmr = get_pmr_entry_internal(i);
+		LOCK_INIT(&pmr->s.lock);
+	}
+
+	pmr_set_shm = odp_shm_reserve("shm_odp_pmr_set_tbl",
+			sizeof(pmr_set_tbl_t),
+			sizeof(pmr_set_t), 0);
+
+	if (pmr_set_shm == ODP_SHM_INVALID) {
+		ODP_ERR("shm allocation failed for shm_odp_pmr_set_tbl");
+		return -1;
+	}
+
+	pmr_set_tbl = odp_shm_addr(pmr_set_shm);
+	if (pmr_set_tbl == NULL) {
+		odp_shm_free(pmr_set_shm);
+		return -1;
+	}
+
+	memset(pmr_set_tbl, 0, sizeof(pmr_set_tbl_t));
+	for (i = 0; i < ODP_PMRSET_MAX_ENTRY; i++) {
+		/* init locks */
+		pmr_set_t *pmr = get_pmr_set_entry_internal(i);
+		LOCK_INIT(&pmr->s.pmr.s.lock);
+	}
+
 	return 0;
 }
 
+odp_cos_t odp_cos_create(const char *name)
+{
+	int i;
+
+	for (i = 0; i < ODP_COS_MAX_ENTRY; i++) {
+		LOCK(&cos_tbl->cos_entry[i].s.lock);
+		if (0 == cos_tbl->cos_entry[i].s.valid) {
+			strncpy(cos_tbl->cos_entry[i].s.name, name,
+				ODP_COS_NAME_LEN - 1);
+			cos_tbl->cos_entry[i].s.name[ODP_COS_NAME_LEN - 1] = 0;
+			cos_tbl->cos_entry[i].s.pmr = NULL;
+			cos_tbl->cos_entry[i].s.linked_cos = NULL;
+			cos_tbl->cos_entry[i].s.queue = NULL;
+			cos_tbl->cos_entry[i].s.pool = NULL;
+			cos_tbl->cos_entry[i].s.flow_set = 0;
+			cos_tbl->cos_entry[i].s.headroom = 0;
+			cos_tbl->cos_entry[i].s.valid = 1;
+			UNLOCK(&cos_tbl->cos_entry[i].s.lock);
+			return (odp_cos_t)i;
+		}
+		UNLOCK(&cos_tbl->cos_entry[i].s.lock);
+	}
+	ODP_ERR("ODP_COS_MAX_ENTRY reached");
+	return ODP_COS_INVALID;
+}
+
+odp_pmr_set_t alloc_pmr_set(pmr_t **pmr)
+{
+	int i;
+
+	for (i = 0; i < ODP_PMRSET_MAX_ENTRY; i++) {
+		LOCK(&pmr_set_tbl->pmr_set[i].s.pmr.s.lock);
+		if (0 == pmr_set_tbl->pmr_set[i].s.pmr.s.valid) {
+			pmr_set_tbl->pmr_set[i].s.pmr.s.valid = 1;
+			pmr_set_tbl->pmr_set[i].s.pmr.s.num_pmr = 0;
+			*pmr = (pmr_t *)&pmr_set_tbl->pmr_set[i];
+			odp_atomic_init_u32(&pmr_set_tbl->pmr_set[i]
+					    .s.pmr.s.count, 0);
+			return (odp_pmr_set_t)i; /* return as locked */
+		}
+		UNLOCK(&pmr_set_tbl->pmr_set[i].s.pmr.s.lock);
+	}
+	ODP_ERR("ODP_PMRSET_MAX_ENTRY reached");
+	return ODP_PMR_INVAL;
+}
+
+odp_pmr_t alloc_pmr(pmr_t **pmr)
+{
+	int i;
+
+	for (i = 0; i < ODP_PMR_MAX_ENTRY; i++) {
+		LOCK(&pmr_tbl->pmr[i].s.lock);
+		if (0 == pmr_tbl->pmr[i].s.valid) {
+			pmr_tbl->pmr[i].s.valid = 1;
+			odp_atomic_init_u32(&pmr_tbl->pmr[i].s.count, 0);
+			pmr_tbl->pmr[i].s.num_pmr = 0;
+			*pmr = &pmr_tbl->pmr[i];
+			return (odp_pmr_t)i; /* return as locked */
+		}
+		UNLOCK(&pmr_tbl->pmr[i].s.lock);
+	}
+	ODP_ERR("ODP_PMR_MAX_ENTRY reached");
+	return ODP_PMR_INVAL;
+}
+
+
+cos_t *get_cos_entry(odp_cos_t cos_id)
+{
+	if (cos_id >= ODP_COS_MAX_ENTRY || cos_id == ODP_COS_INVALID)
+		return NULL;
+	if (cos_tbl->cos_entry[cos_id].s.valid == 0)
+		return NULL;
+	return &(cos_tbl->cos_entry[cos_id]);
+}
+
+
+pmr_set_t *get_pmr_set_entry(odp_pmr_set_t pmr_set_id)
+{
+	if (pmr_set_id >= ODP_PMRSET_MAX_ENTRY || pmr_set_id == ODP_PMR_INVAL)
+		return NULL;
+	if (pmr_set_tbl->pmr_set[pmr_set_id].s.pmr.s.valid == 0)
+		return NULL;
+	return &(pmr_set_tbl->pmr_set[pmr_set_id]);
+}
+
+pmr_t *get_pmr_entry(odp_pmr_t pmr_id)
+{
+	if (pmr_id >= ODP_PMR_MAX_ENTRY || pmr_id == ODP_PMR_INVAL)
+		return NULL;
+	if (pmr_tbl->pmr[pmr_id].s.valid == 0)
+		return NULL;
+	return &(pmr_tbl->pmr[pmr_id]);
+}
+
 int odp_cos_destroy(odp_cos_t cos_id)
 {
-	(void)cos_id;
-	ODP_UNIMPLEMENTED();
+	cos_t *cos = get_cos_entry(cos_id);
+	if (NULL == cos) {
+		ODP_ERR("Invalid odp_cos_t handle");
+		return -1;
+	}
+
+	cos->s.valid = 0;
 	return 0;
 }
 
 int odp_cos_set_queue(odp_cos_t cos_id, odp_queue_t queue_id)
 {
-	(void)cos_id;
-	(void)queue_id;
-	ODP_UNIMPLEMENTED();
+	cos_t *cos = get_cos_entry(cos_id);
+	if (cos == NULL) {
+		ODP_ERR("Invalid odp_cos_t handle");
+		return -1;
+	}
+	/* Locking is not required as intermitted stale
+	data during CoS modification is acceptable*/
+	cos->s.queue = queue_to_qentry(queue_id);
 	return 0;
 }
 
 int odp_cos_set_drop(odp_cos_t cos_id, odp_drop_e drop_policy)
 {
-	(void)cos_id;
-	(void)drop_policy;
-	ODP_UNIMPLEMENTED();
+	cos_t *cos = get_cos_entry(cos_id);
+	if (cos == NULL) {
+		ODP_ERR("Invalid odp_cos_t handle");
+		return -1;
+	}
+
+	/*Drop policy is not supported in v1.0*/
+	cos->s.drop_policy = drop_policy;
 	return 0;
 }
 
 int odp_pktio_set_default_cos(odp_pktio_t pktio_in, odp_cos_t default_cos)
 {
-	(void)pktio_in;
-	(void)default_cos;
-	ODP_UNIMPLEMENTED();
+	pktio_entry_t *entry;
+	cos_t *cos;
+	entry = get_pktio_entry(pktio_in);
+	if (entry == NULL) {
+		ODP_ERR("Invalid odp_pktio_t handle");
+		return -1;
+	}
+	cos = get_cos_entry(default_cos);
+	if (cos == NULL) {
+		ODP_ERR("Invalid odp_cos_t handle");
+		return -1;
+	}
+
+	entry->s.cls.default_cos = cos;
 	return 0;
 }
 
 int odp_pktio_set_error_cos(odp_pktio_t pktio_in, odp_cos_t error_cos)
 {
-	(void)pktio_in;
-	(void)error_cos;
-	ODP_UNIMPLEMENTED();
+	pktio_entry_t *entry;
+	cos_t *cos;
+
+	entry = get_pktio_entry(pktio_in);
+	if (entry == NULL) {
+		ODP_ERR("Invalid odp_pktio_t handle");
+		return -1;
+	}
+
+	cos = get_cos_entry(error_cos);
+	if (cos == NULL) {
+		ODP_ERR("Invalid odp_cos_t handle");
+		return -1;
+	}
+
+	entry->s.cls.error_cos = cos;
 	return 0;
 }
 
 int odp_pktio_set_skip(odp_pktio_t pktio_in, size_t offset)
 {
-	(void)pktio_in;
-	(void)offset;
-	ODP_UNIMPLEMENTED();
+	pktio_entry_t *entry = get_pktio_entry(pktio_in);
+	if (entry == NULL) {
+		ODP_ERR("Invalid odp_cos_t handle");
+		return -1;
+	}
+
+	entry->s.cls.skip = offset;
 	return 0;
 }
 
-int odp_pktio_set_headroom(odp_pktio_t port_id, size_t headroom)
+int odp_pktio_set_headroom(odp_pktio_t pktio_in, size_t headroom)
 {
-	(void)port_id;
-	(void)headroom;
-	ODP_UNIMPLEMENTED();
+	pktio_entry_t *entry = get_pktio_entry(pktio_in);
+	if (entry == NULL) {
+		ODP_ERR("Invalid odp_pktio_t handle");
+		return -1;
+	}
+	entry->s.cls.headroom = headroom;
 	return 0;
 }
 
@@ -72,11 +321,26 @@  int odp_cos_with_l2_priority(odp_pktio_t pktio_in,
 			     uint8_t qos_table[],
 			     odp_cos_t cos_table[])
 {
-	(void)pktio_in;
-	(void)num_qos;
-	(void)qos_table;
-	(void)cos_table;
-	ODP_UNIMPLEMENTED();
+	pmr_l2_cos_t *l2_cos;
+	size_t i;
+	cos_t *cos;
+	pktio_entry_t *entry = get_pktio_entry(pktio_in);
+	if (entry == NULL) {
+		ODP_ERR("Invalid odp_pktio_t handle");
+		return -1;
+	}
+	l2_cos = &entry->s.cls.l2_cos_table;
+
+	LOCK(&l2_cos->lock);
+	/* Update the L2 QoS table*/
+	for (i = 0; i < num_qos; i++) {
+		cos = get_cos_entry(cos_table[i]);
+		if (cos != NULL) {
+			if (ODP_COS_MAX_L2_QOS > qos_table[i])
+				l2_cos->cos[qos_table[i]] = cos;
+		}
+	}
+	UNLOCK(&l2_cos->lock);
 	return 0;
 }
 
@@ -86,12 +350,29 @@  int odp_cos_with_l3_qos(odp_pktio_t pktio_in,
 			odp_cos_t cos_table[],
 			bool l3_preference)
 {
-	(void)pktio_in;
-	(void)num_qos;
-	(void)qos_table;
-	(void)cos_table;
-	(void)l3_preference;
-	ODP_UNIMPLEMENTED();
+	pmr_l3_cos_t *l3_cos;
+	size_t i;
+	pktio_entry_t *entry = get_pktio_entry(pktio_in);
+	cos_t *cos;
+
+	if (entry == NULL) {
+		ODP_ERR("Invalid odp_pktio_t handle");
+		return -1;
+	}
+
+	entry->s.cls.l3_precedence = l3_preference;
+	l3_cos = &entry->s.cls.l3_cos_table;
+
+	LOCK(&l3_cos->lock);
+	/* Update the L3 QoS table*/
+	for (i = 0; i < num_qos; i++) {
+		cos = get_cos_entry(cos_table[i]);
+		if (cos != NULL) {
+			if (ODP_COS_MAX_L3_QOS > qos_table[i])
+				l3_cos->cos[qos_table[i]] = cos;
+		}
+	}
+	UNLOCK(&l3_cos->lock);
 	return 0;
 }
 
@@ -100,12 +381,27 @@  odp_pmr_t odp_pmr_create_match(odp_pmr_term_e term,
 			       const void *mask,
 			       size_t val_sz)
 {
-	(void)term;
-	(void)val;
-	(void)mask;
-	(void)val_sz;
-	ODP_UNIMPLEMENTED();
-	return 0;
+	pmr_t *pmr;
+	odp_pmr_t id;
+	if (val_sz > ODP_PMR_TERM_BYTES_MAX) {
+		ODP_DBG();
+		return ODP_PMR_INVAL;
+	}
+
+	id = alloc_pmr(&pmr);
+	/*if alloc_pmr() is successful it returns with lock acquired*/
+	if (id == ODP_PMR_INVAL)
+		return ODP_PMR_INVAL;
+
+	pmr->s.num_pmr = 1;
+	pmr->s.pmr_term_value[0].match_type = ODP_PMR_MASK;
+	pmr->s.pmr_term_value[0].term = term;
+	pmr->s.pmr_term_value[0].mask.val =  0;
+	pmr->s.pmr_term_value[0].mask.mask =  0;
+	memcpy(&pmr->s.pmr_term_value[0].mask.val, val, val_sz);
+	memcpy(&pmr->s.pmr_term_value[0].mask.mask, mask, val_sz);
+	UNLOCK(&pmr->s.lock);
+	return id;
 }
 
 odp_pmr_t odp_pmr_create_range(odp_pmr_term_e term,
@@ -113,18 +409,34 @@  odp_pmr_t odp_pmr_create_range(odp_pmr_term_e term,
 			       const void *val2,
 			       size_t val_sz)
 {
-	(void)term;
-	(void)val1;
-	(void)val2;
-	(void)val_sz;
-	ODP_UNIMPLEMENTED();
-	return 0;
+	pmr_t *pmr;
+	odp_pmr_t id;
+
+	if (val_sz > ODP_PMR_TERM_BYTES_MAX)
+		return ODP_PMR_INVAL;
+	id = alloc_pmr(&pmr);
+	/*if alloc_pmr() is successful it returns with lock acquired*/
+	if (id == ODP_PMR_INVAL)
+		return ODP_PMR_INVAL;
+
+	pmr->s.num_pmr = 1;
+	pmr->s.pmr_term_value[0].match_type = ODP_PMR_MASK;
+	pmr->s.pmr_term_value[0].term = term;
+	pmr->s.pmr_term_value[0].range.val1 =  0;
+	pmr->s.pmr_term_value[0].range.val2 =  0;
+	memcpy(&pmr->s.pmr_term_value[0].range.val1, val1, val_sz);
+	memcpy(&pmr->s.pmr_term_value[0].range.val2, val2, val_sz);
+	UNLOCK(&pmr->s.lock);
+	return id;
 }
 
 int odp_pmr_destroy(odp_pmr_t pmr_id)
 {
-	(void)pmr_id;
-	ODP_UNIMPLEMENTED();
+	pmr_t *pmr = get_pmr_entry(pmr_id);
+
+	if (pmr == NULL)
+		return -1;
+	pmr->s.valid = 0;
 	return 0;
 }
 
@@ -132,64 +444,478 @@  int odp_pktio_pmr_cos(odp_pmr_t pmr_id,
 		      odp_pktio_t src_pktio,
 		      odp_cos_t dst_cos)
 {
-	(void)pmr_id;
-	(void)src_pktio;
-	(void)dst_cos;
-	ODP_UNIMPLEMENTED();
+	uint8_t num_pmr;
+	pktio_entry_t *pktio_entry;
+	pmr_t *pmr;
+	cos_t *cos;
+
+	pktio_entry = get_pktio_entry(src_pktio);
+	if (pktio_entry == NULL) {
+		ODP_ERR("Invalid odp_pktio_t handle");
+		return -1;
+	}
+
+	pmr = get_pmr_entry(pmr_id);
+	if (pmr == NULL) {
+		ODP_ERR("Invalid odp_pmr_t handle");
+		return -1;
+	}
+
+	cos = get_cos_entry(dst_cos);
+	if (cos == NULL) {
+		ODP_ERR("Invalid odp_cos_t handle");
+		return -1;
+	}
+
+	LOCK(&pktio_entry->s.cls.lock);
+	num_pmr = pktio_entry->s.cls.num_pmr;
+	if (num_pmr >= ODP_PKTIO_MAX_PMR) {
+		ODP_ERR("ODP_PKTIO_MAX_PMR reached");
+		UNLOCK(&pktio_entry->s.cls.lock);
+		return -1;
+	}
+
+	pktio_entry->s.cls.pmr[num_pmr] = pmr;
+	pktio_entry->s.cls.cos[num_pmr] = cos;
+	pktio_entry->s.cls.num_pmr++;
+	UNLOCK(&pktio_entry->s.cls.lock);
+
 	return 0;
 }
 
 int odp_cos_pmr_cos(odp_pmr_t pmr_id, odp_cos_t src_cos, odp_cos_t dst_cos)
 {
-	(void)pmr_id;
-	(void)src_cos;
-	(void)dst_cos;
-	ODP_UNIMPLEMENTED();
+	cos_t *cos_src = get_cos_entry(src_cos);
+	cos_t *cos_dst = get_cos_entry(dst_cos);
+	pmr_t *pmr = get_pmr_entry(pmr_id);
+	if (NULL == cos_src || NULL == cos_dst || NULL == pmr) {
+		ODP_ERR("Invalid input handle");
+		return -1;
+	}
+
+	/*Locking is not required as intermitted stale data is acceptable*/
+	cos_src->s.pmr = pmr;
+	cos_src->s.linked_cos = cos_dst;
+
 	return 0;
 }
 
 signed long odp_pmr_match_count(odp_pmr_t pmr_id)
 {
-	(void)pmr_id;
-	ODP_UNIMPLEMENTED();
-	return 0;
+	pmr_t *pmr = get_pmr_entry(pmr_id);
+	if (pmr == NULL)
+		return -1;
+	return (signed long)odp_atomic_load_u32(&pmr->s.count);
 }
 
 unsigned long long odp_pmr_terms_cap(void)
 {
-	ODP_UNIMPLEMENTED();
-	return 0;
+	unsigned long long term_cap = 0;
+
+	term_cap |= (1 << ODP_PMR_LEN);
+	term_cap |= (1 << ODP_PMR_IPPROTO);
+	term_cap |= (1 << ODP_PMR_UDP_DPORT);
+	term_cap |= (1 << ODP_PMR_TCP_DPORT);
+	term_cap |= (1 << ODP_PMR_UDP_SPORT);
+	term_cap |= (1 << ODP_PMR_TCP_SPORT);
+	term_cap |= (1 << ODP_PMR_SIP_ADDR);
+	term_cap |= (1 << ODP_PMR_DIP_ADDR);
+	return term_cap;
 }
 
 unsigned odp_pmr_terms_avail(void)
 {
-	ODP_UNIMPLEMENTED();
-	return 0;
+	unsigned count = 0;
+	int i;
+
+	for (i = 0; i < ODP_PMR_MAX_ENTRY; i++)
+		if (!pmr_tbl->pmr[i].s.valid)
+			count++;
+	return count;
 }
 
 int odp_pmr_match_set_create(int num_terms, odp_pmr_match_t *terms,
 			     odp_pmr_set_t *pmr_set_id)
 {
-	(void)num_terms;
-	(void)terms;
-	(void)pmr_set_id;
-	ODP_UNIMPLEMENTED();
-	return 0;
+	pmr_t *pmr;
+	int i;
+	uint32_t id;
+	int val_sz;
+	int count = 0;
+
+	if (num_terms > ODP_PMRTERM_MAX) {
+		ODP_ERR("no of terms greater than supported ODP_PMRTERM_MAX");
+		return -1;
+	}
+
+	id = alloc_pmr_set(&pmr);
+	/*if alloc_pmr_set is successful it returns with the acquired lock*/
+	if (id == ODP_PMR_INVAL) {
+		*pmr_set_id = id;
+		return -1;
+	}
+
+	pmr->s.num_pmr = num_terms;
+	for (i = 0; i < num_terms; i++) {
+		pmr->s.pmr_term_value[i].match_type = terms[i].match_type;
+		if (terms[i].match_type == ODP_PMR_MASK) {
+			val_sz = terms[i].mask.val_sz;
+			if (val_sz > ODP_PMR_TERM_BYTES_MAX)
+				continue;
+			pmr->s.pmr_term_value[i].term = terms[i].mask.term;
+			pmr->s.pmr_term_value[i].mask.val = 0;
+			pmr->s.pmr_term_value[i].mask.mask = 0;
+			memcpy(&pmr->s.pmr_term_value[i].mask.val,
+			       terms[i].mask.val, val_sz);
+			memcpy(&pmr->s.pmr_term_value[i].mask.mask,
+			       terms[i].mask.mask, val_sz);
+		} else {
+			val_sz = terms[i].range.val_sz;
+			if (val_sz > ODP_PMR_TERM_BYTES_MAX)
+				continue;
+			pmr->s.pmr_term_value[i].term = terms[i].range.term;
+			pmr->s.pmr_term_value[i].range.val1 = 0;
+			pmr->s.pmr_term_value[i].range.val2 = 0;
+			memcpy(&pmr->s.pmr_term_value[i].range.val1,
+			       terms[i].range.val1, val_sz);
+			memcpy(&pmr->s.pmr_term_value[i].range.val2,
+			       terms[i].range.val2, val_sz);
+		}
+		count++;
+	}
+	*pmr_set_id = id;
+	UNLOCK(&pmr->s.lock);
+	return count;
 }
 
 int odp_pmr_match_set_destroy(odp_pmr_set_t pmr_set_id)
 {
-	(void)pmr_set_id;
-	ODP_UNIMPLEMENTED();
+	pmr_set_t *pmr_set = get_pmr_set_entry(pmr_set_id);
+	if (pmr_set == NULL)
+		return -1;
+
+	pmr_set->s.pmr.s.valid = 0;
 	return 0;
 }
 
 int odp_pktio_pmr_match_set_cos(odp_pmr_set_t pmr_set_id, odp_pktio_t src_pktio,
-				odp_cos_t dst_cos)
+		odp_cos_t dst_cos)
 {
-	(void)pmr_set_id;
-	(void)src_pktio;
-	(void)dst_cos;
-	ODP_UNIMPLEMENTED();
+	uint8_t num_pmr;
+	pktio_entry_t *pktio_entry;
+	pmr_t *pmr;
+	cos_t *cos;
+
+	pktio_entry = get_pktio_entry(src_pktio);
+	if (pktio_entry == NULL) {
+		ODP_ERR("Invalid odp_pktio_t handle");
+		return -1;
+	}
+
+	pmr = (pmr_t *)get_pmr_set_entry(pmr_set_id);
+	if (pmr == NULL) {
+		ODP_ERR("Invalid odp_pmr_set_t handle");
+		return -1;
+	}
+
+	cos = get_cos_entry(dst_cos);
+	if (cos == NULL) {
+		ODP_ERR("Invalid odp_cos_t handle");
+		return -1;
+	}
+
+	LOCK(&pktio_entry->s.cls.lock);
+	num_pmr = pktio_entry->s.cls.num_pmr;
+	if (num_pmr >= ODP_PKTIO_MAX_PMR) {
+		ODP_ERR("ODP_PKTIO_MAX_PMR reached");
+		UNLOCK(&pktio_entry->s.cls.lock);
+		return -1;
+	}
+
+	pktio_entry->s.cls.pmr[num_pmr] = pmr;
+	pktio_entry->s.cls.cos[num_pmr] = cos;
+	pktio_entry->s.cls.num_pmr++;
+	UNLOCK(&pktio_entry->s.cls.lock);
+
 	return 0;
 }
+
+int verify_pmr(pmr_t *pmr, uint8_t *pkt_addr, odp_packet_hdr_t *pkt_hdr)
+{
+	int pmr_failure = 0;
+	int num_pmr;
+	int i;
+	pmr_term_value_t *term_value;
+
+	/* Locking is not required as PMR rules for in-flight packets
+	delivery during a PMR change is indeterminate*/
+
+	if (!pmr->s.valid)
+		return 0;
+	num_pmr = pmr->s.num_pmr;
+
+	/* Iterate through list of PMR Term values in a pmr_t */
+	for (i = 0; i < num_pmr; i++) {
+		term_value = &pmr->s.pmr_term_value[i];
+		switch (term_value->term) {
+		case ODP_PMR_LEN:
+			if (!verify_pmr_packet_len(pkt_hdr, term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_ETHTYPE_0:
+			if (!verify_pmr_eth_type_0(pkt_addr, pkt_hdr,
+						   term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_ETHTYPE_X:
+			if (!verify_pmr_eth_type_x(pkt_addr, pkt_hdr,
+						   term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_VLAN_ID_0:
+			if (!verify_pmr_vlan_id_0(pkt_addr, pkt_hdr,
+						  term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_VLAN_ID_X:
+			if (!verify_pmr_vlan_id_x(pkt_addr, pkt_hdr,
+						  term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_DMAC:
+			if (!verify_pmr_dmac(pkt_addr, pkt_hdr,
+					     term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_IPPROTO:
+			if (!verify_pmr_ip_proto(pkt_addr, pkt_hdr,
+						 term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_UDP_DPORT:
+			if (!verify_pmr_udp_dport(pkt_addr, pkt_hdr,
+						  term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_TCP_DPORT:
+			if (!verify_pmr_tcp_dport(pkt_addr, pkt_hdr,
+						  term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_UDP_SPORT:
+			if (!verify_pmr_udp_sport(pkt_addr, pkt_hdr,
+						  term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_TCP_SPORT:
+			if (!verify_pmr_tcp_sport(pkt_addr, pkt_hdr,
+						  term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_SIP_ADDR:
+			if (!verify_pmr_ipv4_saddr(pkt_addr, pkt_hdr,
+						   term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_DIP_ADDR:
+			if (!verify_pmr_ipv4_daddr(pkt_addr, pkt_hdr,
+						   term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_SIP6_ADDR:
+			if (!verify_pmr_ipv6_saddr(pkt_addr, pkt_hdr,
+						   term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_DIP6_ADDR:
+			if (!verify_pmr_ipv6_daddr(pkt_addr, pkt_hdr,
+						   term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_IPSEC_SPI:
+			if (!verify_pmr_ipsec_spi(pkt_addr, pkt_hdr,
+						  term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_LD_VNI:
+			if (!verify_pmr_ld_vni(pkt_addr, pkt_hdr,
+					       term_value))
+				pmr_failure = 1;
+			break;
+		case ODP_PMR_INNER_HDR_OFF:
+			break;
+		}
+
+		if (pmr_failure)
+			return false;
+	}
+	odp_atomic_inc_u32(&pmr->s.count);
+	return true;
+}
+
+cos_t *match_pmr_cos(cos_t *cos, uint8_t *pkt_addr, pmr_t *pmr,
+		     odp_packet_hdr_t *hdr)
+{
+	cos_t *retcos = NULL;
+
+	if (cos == NULL || pmr == NULL)
+		return NULL;
+
+	if (!cos->s.valid)
+		return NULL;
+
+	if (verify_pmr(pmr, pkt_addr, hdr)) {
+		/** This gets called recursively to check all the PMRs in
+		 * a PMR chain */
+		retcos = match_pmr_cos(cos->s.linked_cos, pkt_addr,
+				       cos->s.pmr, hdr);
+		if (!retcos)
+			return cos;
+	}
+	return retcos;
+}
+
+int pktio_classifier_init(pktio_entry_t *entry)
+{
+	classifier_t *cls;
+	int i;
+	/* classifier lock should be acquired by the calling function */
+	if (entry == NULL)
+		return -1;
+	cls = &entry->s.cls;
+	cls->num_pmr = 0;
+	cls->flow_set = 0;
+	cls->error_cos = NULL;
+	cls->default_cos = NULL;
+	cls->headroom = 0;
+	cls->skip = 0;
+
+	for (i = 0; i < ODP_PKTIO_MAX_PMR; i++) {
+		cls->pmr[i] = NULL;
+		cls->cos[i] = NULL;
+	}
+
+	return 0;
+}
+
+int packet_classifier(odp_pktio_t pktio, odp_packet_t pkt)
+{
+	pktio_entry_t *entry;
+	queue_entry_t *queue;
+	cos_t *cos;
+	odp_packet_hdr_t *pkt_hdr;
+	uint8_t *pkt_addr;
+
+	entry = get_pktio_entry(pktio);
+	if (entry == NULL)
+		return -1;
+
+	pkt_hdr = odp_packet_hdr(pkt);
+	pkt_addr = odp_packet_addr(pkt);
+
+	/* Matching PMR and selecting the CoS for the packet*/
+	cos = pktio_select_cos(entry, pkt_addr, pkt_hdr);
+	if (cos == NULL)
+		return -1;
+
+	/* Enqueuing the Packet based on the CoS */
+	queue = cos->s.queue;
+	return queue_enq(queue, odp_buf_to_hdr((odp_buffer_t)pkt));
+}
+
+cos_t *pktio_select_cos(pktio_entry_t *entry, uint8_t *pkt_addr,
+		       odp_packet_hdr_t *pkt_hdr)
+{
+	pmr_t *pmr;
+	cos_t *cos;
+	uint32_t i;
+	classifier_t *cls;
+
+	cls = &entry->s.cls;
+
+	/* Return error cos for error packet */
+	if (pkt_hdr->error_flags.all)
+		return cls->error_cos;
+	/* Calls all the PMRs attached at the PKTIO level*/
+	for (i = 0; i < cls->num_pmr; i++) {
+		pmr = entry->s.cls.pmr[i];
+		cos = entry->s.cls.cos[i];
+		cos = match_pmr_cos(cos, pkt_addr, pmr, pkt_hdr);
+		if (cos)
+			return cos;
+	}
+
+	cos = match_qos_cos(entry, pkt_addr, pkt_hdr);
+	if (cos)
+		return cos;
+
+	return cls->default_cos;
+}
+
+cos_t *match_qos_l3_cos(pmr_l3_cos_t *l3_cos, uint8_t *pkt_addr,
+			odp_packet_hdr_t *hdr)
+{
+	uint8_t dscp;
+	cos_t *cos = NULL;
+	odph_ipv4hdr_t *ipv4;
+	odph_ipv6hdr_t *ipv6;
+
+	if (hdr->input_flags.l3 && hdr->input_flags.ipv4) {
+		ipv4 = (odph_ipv4hdr_t *)(pkt_addr + hdr->l3_offset);
+		dscp = ODPH_IPV4HDR_DSCP(ipv4->tos);
+		cos = l3_cos->cos[dscp];
+	} else if (hdr->input_flags.l3 && hdr->input_flags.ipv6) {
+		ipv6 = (odph_ipv6hdr_t *)(pkt_addr + hdr->l3_offset);
+		dscp = ODPH_IPV6HDR_DSCP(ipv6->ver_tc_flow);
+		cos = l3_cos->cos[dscp];
+	}
+
+	return cos;
+}
+
+cos_t *match_qos_l2_cos(pmr_l2_cos_t *l2_cos, uint8_t *pkt_addr,
+			odp_packet_hdr_t *hdr)
+{
+	uint8_t qos;
+	cos_t *cos = NULL;
+	odph_ethhdr_t *eth;
+	odph_vlanhdr_t *vlan;
+
+	if (hdr->input_flags.l2 && hdr->input_flags.vlan &&
+	    hdr->input_flags.eth) {
+		eth = (odph_ethhdr_t *)(pkt_addr + hdr->l2_offset);
+		vlan = (odph_vlanhdr_t *)(&eth->type);
+		qos = ((vlan->tci >> 13) & 0xFF);
+		cos = l2_cos->cos[qos];
+	}
+	return cos;
+}
+
+cos_t *match_qos_cos(pktio_entry_t *entry, uint8_t *pkt_addr,
+		     odp_packet_hdr_t *hdr)
+{
+	classifier_t *cls = &entry->s.cls;
+	pmr_l2_cos_t *l2_cos;
+	pmr_l3_cos_t *l3_cos;
+	cos_t *cos;
+
+	l2_cos = &cls->l2_cos_table;
+	l3_cos = &cls->l3_cos_table;
+
+	if (cls->l3_precedence) {
+		cos =  match_qos_l3_cos(l3_cos, pkt_addr, hdr);
+		if (cos)
+			return cos;
+		cos = match_qos_l2_cos(l2_cos, pkt_addr, hdr);
+		if (cos)
+			return cos;
+	} else {
+		cos = match_qos_l2_cos(l2_cos, pkt_addr, hdr);
+		if (cos)
+			return cos;
+		cos = match_qos_l3_cos(l3_cos, pkt_addr, hdr);
+		if (cos)
+			return cos;
+	}
+	return NULL;
+}
diff --git a/platform/linux-generic/odp_init.c b/platform/linux-generic/odp_init.c
index 672b3d6..c661231 100644
--- a/platform/linux-generic/odp_init.c
+++ b/platform/linux-generic/odp_init.c
@@ -54,6 +54,10 @@  int odp_init_global(odp_init_t *params  ODP_UNUSED,
 		ODP_ERR("ODP crypto init failed.\n");
 		return -1;
 	}
+	if (odp_classification_init_global()) {
+		ODP_ERR("ODP crypto init failed.\n");
+		return -1;
+	}
 
 	return 0;
 }
diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c
index 19b9eea..6bda003 100644
--- a/platform/linux-generic/odp_packet_io.c
+++ b/platform/linux-generic/odp_packet_io.c
@@ -13,10 +13,10 @@ 
 #include <odp_spinlock.h>
 #include <odp_shared_memory.h>
 #include <odp_packet_socket.h>
-#include <odp_hints.h>
 #include <odp_config.h>
 #include <odp_queue_internal.h>
 #include <odp_schedule_internal.h>
+#include <odp_classification_internal.h>
 #include <odp_debug_internal.h>
 
 #include <string.h>
@@ -50,6 +50,7 @@  int odp_pktio_init_global(void)
 		pktio_entry = &pktio_tbl->entries[id - 1];
 
 		odp_spinlock_init(&pktio_entry->s.lock);
+		odp_spinlock_init(&pktio_entry->s.cls.lock);
 
 		pktio_entry_ptr[id - 1] = pktio_entry;
 		/* Create a default output queue for each pktio resource */
@@ -98,12 +99,25 @@  static void unlock_entry(pktio_entry_t *entry)
 	odp_spinlock_unlock(&entry->s.lock);
 }
 
+static void lock_entry_classifier(pktio_entry_t *entry)
+{
+	odp_spinlock_lock(&entry->s.lock);
+	odp_spinlock_lock(&entry->s.cls.lock);
+}
+
+static void unlock_entry_classifier(pktio_entry_t *entry)
+{
+	odp_spinlock_unlock(&entry->s.cls.lock);
+	odp_spinlock_unlock(&entry->s.lock);
+}
+
 static void init_pktio_entry(pktio_entry_t *entry)
 {
 	set_taken(entry);
 	entry->s.inq_default = ODP_QUEUE_INVALID;
 	memset(&entry->s.pkt_sock, 0, sizeof(entry->s.pkt_sock));
 	memset(&entry->s.pkt_sock_mmap, 0, sizeof(entry->s.pkt_sock_mmap));
+	pktio_classifier_init(entry);
 }
 
 static odp_pktio_t alloc_lock_pktio_entry(void)
@@ -115,13 +129,13 @@  static odp_pktio_t alloc_lock_pktio_entry(void)
 	for (i = 0; i < ODP_CONFIG_PKTIO_ENTRIES; ++i) {
 		entry = &pktio_tbl->entries[i];
 		if (is_free(entry)) {
-			lock_entry(entry);
+			lock_entry_classifier(entry);
 			if (is_free(entry)) {
 				init_pktio_entry(entry);
 				id = i + 1;
 				return id; /* return with entry locked! */
 			}
-			unlock_entry(entry);
+			unlock_entry_classifier(entry);
 		}
 	}
 
@@ -190,14 +204,14 @@  odp_pktio_t odp_pktio_open(const char *dev, odp_buffer_pool_t pool)
 		close_pkt_sock(&pktio_entry->s.pkt_sock);
 	}
 
-	unlock_entry(pktio_entry);
+	unlock_entry_classifier(pktio_entry);
 	free_pktio_entry(id);
 	ODP_ERR("Unable to init any I/O type.\n");
 	return ODP_PKTIO_INVALID;
 
 done:
 	strncpy(pktio_entry->s.name, dev, IFNAMSIZ);
-	unlock_entry(pktio_entry);
+	unlock_entry_classifier(pktio_entry);
 	return id;
 }
 
@@ -415,7 +429,7 @@  odp_buffer_hdr_t *pktin_dequeue(queue_entry_t *qentry)
 	odp_buffer_t buf;
 	odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
 	odp_buffer_hdr_t *tmp_hdr_tbl[QUEUE_MULTI_MAX];
-	int pkts, i;
+	int pkts, i, j;
 
 	buf_hdr = queue_deq(qentry);
 	if (buf_hdr != NULL)
@@ -425,12 +439,15 @@  odp_buffer_hdr_t *pktin_dequeue(queue_entry_t *qentry)
 	if (pkts <= 0)
 		return NULL;
 
-	for (i = 0; i < pkts; ++i) {
+	for (i = 0, j = 0; i < pkts; ++i) {
 		buf = odp_packet_to_buffer(pkt_tbl[i]);
-		tmp_hdr_tbl[i] = odp_buf_to_hdr(buf);
+		buf_hdr = odp_buf_to_hdr(buf);
+		if (0 > packet_classifier(qentry->s.pktin, pkt_tbl[i]))
+			tmp_hdr_tbl[j++] = buf_hdr;
 	}
 
-	queue_enq_multi(qentry, tmp_hdr_tbl, pkts);
+	if (j)
+		queue_enq_multi(qentry, tmp_hdr_tbl, j);
 	buf_hdr = tmp_hdr_tbl[0];
 	return buf_hdr;
 }
@@ -446,8 +463,9 @@  int pktin_deq_multi(queue_entry_t *qentry, odp_buffer_hdr_t *buf_hdr[], int num)
 	int nbr;
 	odp_packet_t pkt_tbl[QUEUE_MULTI_MAX];
 	odp_buffer_hdr_t *tmp_hdr_tbl[QUEUE_MULTI_MAX];
+	odp_buffer_hdr_t *tmp_hdr;
 	odp_buffer_t buf;
-	int pkts, i;
+	int pkts, i, j;
 
 	nbr = queue_deq_multi(qentry, buf_hdr, num);
 	if (odp_unlikely(nbr > num))
@@ -464,12 +482,15 @@  int pktin_deq_multi(queue_entry_t *qentry, odp_buffer_hdr_t *buf_hdr[], int num)
 	if (pkts <= 0)
 		return nbr;
 
-	for (i = 0; i < pkts; ++i) {
+	for (i = 0, j = 0; i < pkts; ++i) {
 		buf = odp_packet_to_buffer(pkt_tbl[i]);
-		tmp_hdr_tbl[i] = odp_buf_to_hdr(buf);
+		tmp_hdr = odp_buf_to_hdr(buf);
+		if (0 > packet_classifier(qentry->s.pktin, pkt_tbl[i]))
+			tmp_hdr_tbl[j++] = tmp_hdr;
 	}
 
-	queue_enq_multi(qentry, tmp_hdr_tbl, pkts);
+	if (j)
+		queue_enq_multi(qentry, tmp_hdr_tbl, j);
 	return nbr;
 }