date:20211009

From: Narcisa Vasile 

EAL thread API

**Problem Statement**
DPDK currently uses the pthread interface to create and manage threads.
Windows does not support the POSIX thread programming model,
so it currently
relies on a header file that hides the Windows calls under
pthread matched interfaces. Given that EAL should isolate the environment
specifics from the applications and libraries and mediate
all the communication with the operating systems, a new EAL interface
is needed for thread management.

**Goals**
* Introduce a generic EAL API for threading support that will remove
  the current Windows pthread.h shim.
* Replace references to pthread_* across the DPDK codebase with the new
  RTE_THREAD_* API.
* Allow users to choose between using the RTE_THREAD_* API or a
  3rd party thread library through a configuration option.

**Design plan**
New API main files:
* rte_thread.h (librte_eal/include)
* rte_thread.c (librte_eal/windows)
* rte_thread.c (librte_eal/common)

**A schematic example of the design**
--
lib/librte_eal/include/rte_thread.h
int rte_thread_create();

lib/librte_eal/common/rte_thread.c
int rte_thread_create() 
{
return pthread_create();
}

lib/librte_eal/windows/rte_thread.c
int rte_thread_create() 
{
return CreateThread();
}
-

**Thread attributes**

When or after a thread is created, specific characteristics of the thread
can be adjusted. Given that the thread characteristics that are of interest
for DPDK applications are affinity and priority, the following structure
that represents thread attributes has been defined:

typedef struct
{
enum rte_thread_priority priority;
rte_cpuset_t cpuset;
} rte_thread_attr_t;

The *rte_thread_create()* function can optionally receive
an rte_thread_attr_t
object that will cause the thread to be created with the
affinity and priority
described by the attributes object. If no rte_thread_attr_t is passed
(parameter is NULL), the default affinity and priority are used.
An rte_thread_attr_t object can also be set to the default values
by calling *rte_thread_attr_init()*.

*Priority* is represented through an enum that currently advertises
two values for priority:
- RTE_THREAD_PRIORITY_NORMAL
- RTE_THREAD_PRIORITY_REALTIME_CRITICAL
The enum can be extended to allow for multiple priority levels.
rte_thread_set_priority  - sets the priority of a thread
rte_thread_get_priority  - retrieves the priority of a thread
   from the OS
rte_thread_attr_set_priority - updates an rte_thread_attr_t object
   with a new value for priority

The user can choose thread priority through an EAL parameter,
when starting an application.  If EAL parameter is not used,
the per-platform default value for thread priority is used.
Otherwise administrator has an option to set one of available options:
 --thread-prio normal
 --thread-prio realtime

Example:
./dpdk-l2fwd -l 0-3 -n 4 –thread-prio normal -- -q 8 -p 

*Affinity* is described by the already known “rte_cpuset_t” type.
rte_thread_attr_set/get_affinity - sets/gets the affinity field in a
   rte_thread_attr_t object
rte_thread_set/get_affinity  – sets/gets the affinity of a thread

**Errors**
A translation function that maps Windows error codes to errno-style
error codes is provided. 

**Future work**
The long term plan is for EAL to provide full threading support:
* Add support for conditional variables
* Additional functionality offered by pthread_*
  (such as pthread_setname_np, etc.)

v16:
- Fix warning on freebsd by adding cast
- Change affinity unit test to consider ases when the requested CPU
  are not available on the system.
- Fix priority unit test to avoid termination of thread before the
  priority is checked.

v15:
- Add try_lock mutex functionality. If the mutex is already owned by a
  different thread, the function returns immediately. Otherwise, 
  the mutex will be acquired.
- Add function for getting the priority of a thread.
  An auxiliary function that translates the OS priority to the
  EAL accepted ones is added.
- Fix unit tests logging, add descriptive asserts that mark test failures.
  Verify mutex locking, verify barrier return values. Add test for
  statically initialized mutexes.
- Fix Alpine build by removing the use of pthread_attr_set_affinity() and
  using pthread_set_affinity() after the thread is created.

v14:
- Remove patch "eal: add EAL argument for setting thread priority"
  This will be added later when enabling the new threading API.
- Remove priority enum value "_UNDEFINED". NORMAL is used
  as the default.
- Fix issue with thread return value.

v13:
 - Fix syntax error in unit tests

v12:
 - Fix freebsd warning about initializer in unit tests

v11:
 - Add unit tests for thread API
 - Rebase

v10:
 - Remove patch no. 10. It will be broken do

[dpdk-dev] [PATCH v16 1/9] eal: add basic threading functions

From: Narcisa Vasile 

Use a portable, type-safe representation for the thread identifier.
Add functions for comparing thread ids and obtaining the thread id
for the current thread.

Signed-off-by: Narcisa Vasile 
---
 lib/eal/common/meson.build|  1 +
 lib/eal/{unix => common}/rte_thread.c | 57 ---
 lib/eal/include/rte_thread.h  | 48 +-
 lib/eal/unix/meson.build  |  1 -
 lib/eal/version.map   |  3 ++
 lib/eal/windows/rte_thread.c  | 17 
 6 files changed, 95 insertions(+), 32 deletions(-)
 rename lib/eal/{unix => common}/rte_thread.c (66%)

diff --git a/lib/eal/common/meson.build b/lib/eal/common/meson.build
index 6d01b0f072..5299bb80d3 100644
--- a/lib/eal/common/meson.build
+++ b/lib/eal/common/meson.build
@@ -51,5 +51,6 @@ if not is_windows
 'hotplug_mp.c',
 'malloc_mp.c',
 'rte_keepalive.c',
+'rte_thread.c'
 )
 endif
diff --git a/lib/eal/unix/rte_thread.c b/lib/eal/common/rte_thread.c
similarity index 66%
rename from lib/eal/unix/rte_thread.c
rename to lib/eal/common/rte_thread.c
index c72d619ec1..92a7451b0a 100644
--- a/lib/eal/unix/rte_thread.c
+++ b/lib/eal/common/rte_thread.c
@@ -1,5 +1,6 @@
 /* SPDX-License-Identifier: BSD-3-Clause
  * Copyright 2021 Mellanox Technologies, Ltd
+ * Copyright(c) 2021 Microsoft Corporation
  */
 
 #include 
@@ -16,25 +17,41 @@ struct eal_tls_key {
pthread_key_t thread_index;
 };
 
+rte_thread_t
+rte_thread_self(void)
+{
+   rte_thread_t thread_id;
+
+   thread_id.opaque_id = (uintptr_t)pthread_self();
+
+   return thread_id;
+}
+
+int
+rte_thread_equal(rte_thread_t t1, rte_thread_t t2)
+{
+   return pthread_equal((pthread_t)t1.opaque_id, (pthread_t)t2.opaque_id);
+}
+
 int
 rte_thread_key_create(rte_thread_key *key, void (*destructor)(void *))
 {
int err;
+   rte_thread_key k;
 
-   *key = malloc(sizeof(**key));
-   if ((*key) == NULL) {
+   k = malloc(sizeof(*k));
+   if (k == NULL) {
RTE_LOG(DEBUG, EAL, "Cannot allocate TLS key.\n");
-   rte_errno = ENOMEM;
-   return -1;
+   return EINVAL;
}
-   err = pthread_key_create(&((*key)->thread_index), destructor);
-   if (err) {
+   err = pthread_key_create(&(k->thread_index), destructor);
+   if (err != 0) {
RTE_LOG(DEBUG, EAL, "pthread_key_create failed: %s\n",
 strerror(err));
-   free(*key);
-   rte_errno = ENOEXEC;
-   return -1;
+   free(k);
+   return err;
}
+   *key = k;
return 0;
 }
 
@@ -43,18 +60,16 @@ rte_thread_key_delete(rte_thread_key key)
 {
int err;
 
-   if (!key) {
+   if (key == NULL) {
RTE_LOG(DEBUG, EAL, "Invalid TLS key.\n");
-   rte_errno = EINVAL;
-   return -1;
+   return EINVAL;
}
err = pthread_key_delete(key->thread_index);
-   if (err) {
+   if (err != 0) {
RTE_LOG(DEBUG, EAL, "pthread_key_delete failed: %s\n",
 strerror(err));
free(key);
-   rte_errno = ENOEXEC;
-   return -1;
+   return err;
}
free(key);
return 0;
@@ -65,17 +80,15 @@ rte_thread_value_set(rte_thread_key key, const void *value)
 {
int err;
 
-   if (!key) {
+   if (key == NULL) {
RTE_LOG(DEBUG, EAL, "Invalid TLS key.\n");
-   rte_errno = EINVAL;
-   return -1;
+   return EINVAL;
}
err = pthread_setspecific(key->thread_index, value);
-   if (err) {
+   if (err != 0) {
RTE_LOG(DEBUG, EAL, "pthread_setspecific failed: %s\n",
strerror(err));
-   rte_errno = ENOEXEC;
-   return -1;
+   return err;
}
return 0;
 }
@@ -83,7 +96,7 @@ rte_thread_value_set(rte_thread_key key, const void *value)
 void *
 rte_thread_value_get(rte_thread_key key)
 {
-   if (!key) {
+   if (key == NULL) {
RTE_LOG(DEBUG, EAL, "Invalid TLS key.\n");
rte_errno = EINVAL;
return NULL;
diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index 8be8ed8f36..748f64d230 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -1,6 +1,8 @@
 /* SPDX-License-Identifier: BSD-3-Clause
  * Copyright(c) 2021 Mellanox Technologies, Ltd
+ * Copyright(c) 2021 Microsoft Corporation
  */
+#include 
 
 #include 
 #include 
@@ -20,11 +22,45 @@
 extern "C" {
 #endif
 
+#include 
+
+/**
+ * Thread id descriptor.
+ */
+typedef struct rte_thread_tag {
+   uintptr_t opaque_id; /**< thread identifier */
+} rte_thread_t;
+
 /**
  * TLS key type, an opaque pointer.
  */
 typedef struct eal_tls_key *rte_t

[dpdk-dev] [PATCH v16 3/9] eal/windows: translate Windows errors to errno-style errors

From: Narcisa Vasile 

Add function to translate Windows error codes to
errno-style error codes. The possible return values are chosen
so that we have as much semantical compatibility between platforms as
possible.

Signed-off-by: Narcisa Vasile 
---
 lib/eal/common/rte_thread.c  |  6 +--
 lib/eal/include/rte_thread.h |  5 +-
 lib/eal/windows/rte_thread.c | 95 +++-
 3 files changed, 76 insertions(+), 30 deletions(-)

diff --git a/lib/eal/common/rte_thread.c b/lib/eal/common/rte_thread.c
index e1a4d7eae4..27ad1c7eb0 100644
--- a/lib/eal/common/rte_thread.c
+++ b/lib/eal/common/rte_thread.c
@@ -47,7 +47,7 @@ rte_thread_attr_init(rte_thread_attr_t *attr)
 
 int
 rte_thread_attr_set_affinity(rte_thread_attr_t *thread_attr,
-rte_cpuset_t *cpuset)
+   rte_cpuset_t *cpuset)
 {
RTE_VERIFY(thread_attr != NULL);
RTE_VERIFY(cpuset != NULL);
@@ -59,7 +59,7 @@ rte_thread_attr_set_affinity(rte_thread_attr_t *thread_attr,
 
 int
 rte_thread_attr_get_affinity(rte_thread_attr_t *thread_attr,
-rte_cpuset_t *cpuset)
+   rte_cpuset_t *cpuset)
 {
RTE_VERIFY(thread_attr != NULL);
RTE_VERIFY(cpuset != NULL);
@@ -71,7 +71,7 @@ rte_thread_attr_get_affinity(rte_thread_attr_t *thread_attr,
 
 int
 rte_thread_attr_set_priority(rte_thread_attr_t *thread_attr,
-enum rte_thread_priority priority)
+   enum rte_thread_priority priority)
 {
RTE_VERIFY(thread_attr != NULL);
 
diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index 4ac36957ce..8a20215a94 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -233,9 +233,8 @@ int rte_thread_value_set(rte_thread_key key, const void 
*value);
  *
  * @return
  *   On success, value data pointer (can also be NULL).
- *   On failure, NULL and an error number is set in rte_errno.
- *   rte_errno can be: EINVAL  - Invalid parameter passed.
- * ENOEXEC - Specific OS error.
+ *   On failure, NULL and a positive error number is set in rte_errno.
+ *
  */
 __rte_experimental
 void *rte_thread_value_get(rte_thread_key key);
diff --git a/lib/eal/windows/rte_thread.c b/lib/eal/windows/rte_thread.c
index 01966e7745..c1ecfbd6ae 100644
--- a/lib/eal/windows/rte_thread.c
+++ b/lib/eal/windows/rte_thread.c
@@ -13,6 +13,54 @@ struct eal_tls_key {
DWORD thread_index;
 };
 
+/* Translates the most common error codes related to threads */
+static int
+thread_translate_win32_error(DWORD error)
+{
+   switch (error) {
+   case ERROR_SUCCESS:
+   return 0;
+
+   case ERROR_INVALID_PARAMETER:
+   return EINVAL;
+
+   case ERROR_INVALID_HANDLE:
+   return EFAULT;
+
+   case ERROR_NOT_ENOUGH_MEMORY:
+   /* FALLTHROUGH */
+   case ERROR_NO_SYSTEM_RESOURCES:
+   return ENOMEM;
+
+   case ERROR_PRIVILEGE_NOT_HELD:
+   /* FALLTHROUGH */
+   case ERROR_ACCESS_DENIED:
+   return EACCES;
+
+   case ERROR_ALREADY_EXISTS:
+   return EEXIST;
+
+   case ERROR_POSSIBLE_DEADLOCK:
+   return EDEADLK;
+
+   case ERROR_INVALID_FUNCTION:
+   /* FALLTHROUGH */
+   case ERROR_CALL_NOT_IMPLEMENTED:
+   return ENOSYS;
+   }
+
+   return EINVAL;
+}
+
+static int
+thread_log_last_error(const char *message)
+{
+   DWORD error = GetLastError();
+   RTE_LOG(DEBUG, EAL, "GetLastError()=%lu: %s\n", error, message);
+
+   return thread_translate_win32_error(error);
+}
+
 rte_thread_t
 rte_thread_self(void)
 {
@@ -42,7 +90,7 @@ rte_thread_attr_init(rte_thread_attr_t *attr)
 
 int
 rte_thread_attr_set_affinity(rte_thread_attr_t *thread_attr,
-rte_cpuset_t *cpuset)
+   rte_cpuset_t *cpuset)
 {
RTE_VERIFY(thread_attr != NULL);
thread_attr->cpuset = *cpuset;
@@ -52,7 +100,7 @@ rte_thread_attr_set_affinity(rte_thread_attr_t *thread_attr,
 
 int
 rte_thread_attr_get_affinity(rte_thread_attr_t *thread_attr,
-rte_cpuset_t *cpuset)
+   rte_cpuset_t *cpuset)
 {
RTE_VERIFY(thread_attr != NULL);
 
@@ -63,7 +111,7 @@ rte_thread_attr_get_affinity(rte_thread_attr_t *thread_attr,
 
 int
 rte_thread_attr_set_priority(rte_thread_attr_t *thread_attr,
-enum rte_thread_priority priority)
+   enum rte_thread_priority priority)
 {
RTE_VERIFY(thread_attr != NULL);
 
@@ -76,18 +124,18 @@ int
 rte_thread_key_create(rte_thread_key *key,
__rte_unused void (*destructor)(void *))
 {
+   int ret;
+
*key = malloc(sizeof(**key));
if ((*key) == NULL) {
RTE_LOG(DEBUG, EAL, "Cannot allocate TLS key.\n");
-   rte_errno = ENOMEM;
-   return -1;
+   return ENOMEM;
}
(*key)->thread_index = TlsAlloc();

[dpdk-dev] [PATCH v16 4/9] eal: implement functions for thread affinity management

From: Narcisa Vasile 

Implement functions for getting/setting thread affinity.
Threads can be pinned to specific cores by setting their
affinity attribute.

Signed-off-by: Narcisa Vasile 
Signed-off-by: Dmitry Malloy 
---
 lib/eal/common/rte_thread.c   |  16 
 lib/eal/include/rte_thread.h  |  36 +++
 lib/eal/version.map   |   2 +
 lib/eal/windows/eal_lcore.c   | 176 +-
 lib/eal/windows/eal_windows.h |  10 ++
 lib/eal/windows/rte_thread.c  | 125 +++-
 6 files changed, 319 insertions(+), 46 deletions(-)

diff --git a/lib/eal/common/rte_thread.c b/lib/eal/common/rte_thread.c
index 27ad1c7eb0..73b7b3141c 100644
--- a/lib/eal/common/rte_thread.c
+++ b/lib/eal/common/rte_thread.c
@@ -34,6 +34,22 @@ rte_thread_equal(rte_thread_t t1, rte_thread_t t2)
return pthread_equal((pthread_t)t1.opaque_id, (pthread_t)t2.opaque_id);
 }
 
+int
+rte_thread_set_affinity_by_id(rte_thread_t thread_id,
+   const rte_cpuset_t *cpuset)
+{
+   return pthread_setaffinity_np((pthread_t)thread_id.opaque_id,
+   sizeof(*cpuset), cpuset);
+}
+
+int
+rte_thread_get_affinity_by_id(rte_thread_t thread_id,
+   rte_cpuset_t *cpuset)
+{
+   return pthread_getaffinity_np((pthread_t)thread_id.opaque_id,
+   sizeof(*cpuset), cpuset);
+}
+
 int
 rte_thread_attr_init(rte_thread_attr_t *attr)
 {
diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index 8a20215a94..5b100cafda 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -85,6 +85,42 @@ int rte_thread_equal(rte_thread_t t1, rte_thread_t t2);
 
 #ifdef RTE_HAS_CPUSET
 
+/**
+ * Set the affinity of thread 'thread_id' to the cpu set
+ * specified by 'cpuset'.
+ *
+ * @param thread_id
+ *Id of the thread for which to set the affinity.
+ *
+ * @param cpuset
+ *   Pointer to CPU affinity to set.
+ *
+ * @return
+ *   On success, return 0.
+ *   On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_set_affinity_by_id(rte_thread_t thread_id,
+   const rte_cpuset_t *cpuset);
+
+/**
+ * Get the affinity of thread 'thread_id' and store it
+ * in 'cpuset'.
+ *
+ * @param thread_id
+ *Id of the thread for which to get the affinity.
+ *
+ * @param cpuset
+ *   Pointer for storing the affinity value.
+ *
+ * @return
+ *   On success, return 0.
+ *   On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_get_affinity_by_id(rte_thread_t thread_id,
+   rte_cpuset_t *cpuset);
+
 /**
  * Initialize the attributes of a thread.
  * These attributes can be passed to the rte_thread_create() function
diff --git a/lib/eal/version.map b/lib/eal/version.map
index a1b944788e..58b9553d59 100644
--- a/lib/eal/version.map
+++ b/lib/eal/version.map
@@ -427,6 +427,8 @@ EXPERIMENTAL {
rte_thread_attr_get_affinity;
rte_thread_attr_set_affinity;
rte_thread_attr_set_priority;
+   rte_thread_get_affinity_by_id;
+   rte_thread_set_affinity_by_id;
 };
 
 INTERNAL {
diff --git a/lib/eal/windows/eal_lcore.c b/lib/eal/windows/eal_lcore.c
index 476c2d2bdf..295af50698 100644
--- a/lib/eal/windows/eal_lcore.c
+++ b/lib/eal/windows/eal_lcore.c
@@ -2,7 +2,6 @@
  * Copyright(c) 2019 Intel Corporation
  */
 
-#include 
 #include 
 #include 
 
@@ -27,13 +26,15 @@ struct socket_map {
 };
 
 struct cpu_map {
-   unsigned int socket_count;
unsigned int lcore_count;
+   unsigned int socket_count;
+   unsigned int cpu_count;
struct lcore_map lcores[RTE_MAX_LCORE];
struct socket_map sockets[RTE_MAX_NUMA_NODES];
+   GROUP_AFFINITY cpus[CPU_SETSIZE];
 };
 
-static struct cpu_map cpu_map = { 0 };
+static struct cpu_map cpu_map;
 
 /* eal_create_cpu_map() is called before logging is initialized */
 static void
@@ -47,13 +48,118 @@ log_early(const char *format, ...)
va_end(va);
 }
 
+static int
+eal_query_group_affinity(void)
+{
+   SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *infos = NULL;
+   unsigned int *cpu_count = &cpu_map.cpu_count;
+   DWORD infos_size = 0;
+   int ret = 0;
+   USHORT group_count;
+   KAFFINITY affinity;
+   USHORT group_no;
+   unsigned int i;
+
+   if (!GetLogicalProcessorInformationEx(RelationGroup, NULL,
+ &infos_size)) {
+   DWORD error = GetLastError();
+   if (error != ERROR_INSUFFICIENT_BUFFER) {
+   log_early("Cannot get group information size, "
+ "error %lu\n", error);
+   rte_errno = EINVAL;
+   ret = -1;
+   goto cleanup;
+   }
+   }
+
+   infos = malloc(infos_size);
+   if (infos == NULL) {
+   log_early("Cannot allocate memory for NUMA node information\n");
+   rte_errno = ENOMEM;
+

[dpdk-dev] [PATCH v16 2/9] eal: add thread attributes

From: Narcisa Vasile 

Implement thread attributes for:
* thread affinity
* thread priority
Implement functions for managing thread attributes.

Priority is represented through an enum that allows for two levels:
- RTE_THREAD_PRIORITY_NORMAL
- RTE_THREAD_PRIORITY_REALTIME_CRITICAL

Affinity is described by the rte_cpuset_t type.

An rte_thread_attr_t object can be set to the default values
by calling rte_thread_attr_init().

Signed-off-by: Narcisa Vasile 
---
 lib/eal/common/rte_thread.c  | 46 ++
 lib/eal/include/rte_thread.h | 91 
 lib/eal/version.map  |  4 ++
 lib/eal/windows/rte_thread.c | 44 +
 4 files changed, 185 insertions(+)

diff --git a/lib/eal/common/rte_thread.c b/lib/eal/common/rte_thread.c
index 92a7451b0a..e1a4d7eae4 100644
--- a/lib/eal/common/rte_thread.c
+++ b/lib/eal/common/rte_thread.c
@@ -9,6 +9,7 @@
 #include 
 
 #include 
+#include 
 #include 
 #include 
 #include 
@@ -33,6 +34,51 @@ rte_thread_equal(rte_thread_t t1, rte_thread_t t2)
return pthread_equal((pthread_t)t1.opaque_id, (pthread_t)t2.opaque_id);
 }
 
+int
+rte_thread_attr_init(rte_thread_attr_t *attr)
+{
+   RTE_VERIFY(attr != NULL);
+
+   CPU_ZERO(&attr->cpuset);
+   attr->priority = RTE_THREAD_PRIORITY_NORMAL;
+
+   return 0;
+}
+
+int
+rte_thread_attr_set_affinity(rte_thread_attr_t *thread_attr,
+rte_cpuset_t *cpuset)
+{
+   RTE_VERIFY(thread_attr != NULL);
+   RTE_VERIFY(cpuset != NULL);
+
+   thread_attr->cpuset = *cpuset;
+
+   return 0;
+}
+
+int
+rte_thread_attr_get_affinity(rte_thread_attr_t *thread_attr,
+rte_cpuset_t *cpuset)
+{
+   RTE_VERIFY(thread_attr != NULL);
+   RTE_VERIFY(cpuset != NULL);
+
+   *cpuset = thread_attr->cpuset;
+
+   return 0;
+}
+
+int
+rte_thread_attr_set_priority(rte_thread_attr_t *thread_attr,
+enum rte_thread_priority priority)
+{
+   RTE_VERIFY(thread_attr != NULL);
+
+   thread_attr->priority = priority;
+   return 0;
+}
+
 int
 rte_thread_key_create(rte_thread_key *key, void (*destructor)(void *))
 {
diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index 748f64d230..4ac36957ce 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -31,6 +31,28 @@ typedef struct rte_thread_tag {
uintptr_t opaque_id; /**< thread identifier */
 } rte_thread_t;
 
+/**
+ * Thread priority values.
+ */
+enum rte_thread_priority {
+   RTE_THREAD_PRIORITY_NORMAL= 0,
+   /**< normal thread priority, the default */
+   RTE_THREAD_PRIORITY_REALTIME_CRITICAL = 1,
+   /**< highest thread priority allowed */
+};
+
+#ifdef RTE_HAS_CPUSET
+
+/**
+ * Representation for thread attributes.
+ */
+typedef struct {
+   enum rte_thread_priority priority; /**< thread priority */
+   rte_cpuset_t cpuset; /**< thread affinity */
+} rte_thread_attr_t;
+
+#endif /* RTE_HAS_CPUSET */
+
 /**
  * TLS key type, an opaque pointer.
  */
@@ -63,6 +85,75 @@ int rte_thread_equal(rte_thread_t t1, rte_thread_t t2);
 
 #ifdef RTE_HAS_CPUSET
 
+/**
+ * Initialize the attributes of a thread.
+ * These attributes can be passed to the rte_thread_create() function
+ * that will create a new thread and set its attributes according to attr.
+ *
+ * @param attr
+ *   Thread attributes to initialize.
+ *
+ * @return
+ *   On success, return 0.
+ *   On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_attr_init(rte_thread_attr_t *attr);
+
+/**
+ * Set the CPU affinity value in the thread attributes pointed to
+ * by 'thread_attr'.
+ *
+ * @param thread_attr
+ *   Points to the thread attributes in which affinity will be updated.
+ *
+ * @param cpuset
+ *   Points to the value of the affinity to be set.
+ *
+ * @return
+ *   On success, return 0.
+ *   On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_attr_set_affinity(rte_thread_attr_t *thread_attr,
+   rte_cpuset_t *cpuset);
+
+/**
+ * Get the value of CPU affinity that is set in the thread attributes pointed
+ * to by 'thread_attr'.
+ *
+ * @param thread_attr
+ *   Points to the thread attributes from which affinity will be retrieved.
+ *
+ * @param cpuset
+ *   Pointer to the memory that will store the affinity.
+ *
+ * @return
+ *   On success, return 0.
+ *   On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_attr_get_affinity(rte_thread_attr_t *thread_attr,
+   rte_cpuset_t *cpuset);
+
+/**
+ * Set the thread priority value in the thread attributes pointed to
+ * by 'thread_attr'.
+ *
+ * @param thread_attr
+ *   Points to the thread attributes in which priority will be updated.
+ *
+ * @param priority
+ *   Points to the value of the priority to be set.
+ *
+ * @return
+ *   On success, return 0.
+ *   O

[dpdk-dev] [PATCH v16 5/9] eal: implement thread priority management functions

From: Narcisa Vasile 

Add functions for setting and getting the priority of a thread.
Priorities on multiple platforms are similarly determined by
a priority value and a priority class/policy.

On Linux, the following mapping is created:
RTE_THREAD_PRIORITY_NORMAL corresponds to
* policy SCHED_OTHER
* priority value:   (sched_get_priority_min(SCHED_OTHER) +
 sched_get_priority_max(SCHED_OTHER))/2;
RTE_THREAD_PRIORITY_REALTIME_CRITICAL corresponds to
* policy SCHED_RR
* priority value: sched_get_priority_max(SCHED_RR);

On Windows, the following mapping is created:
RTE_THREAD_PRIORITY_NORMAL corresponds to
* class NORMAL_PRIORITY_CLASS
* priority THREAD_PRIORITY_NORMAL
RTE_THREAD_PRIORITY_REALTIME_CRITICAL corresponds to
* class REALTIME_PRIORITY_CLASS
* priority THREAD_PRIORITY_TIME_CRITICAL

Signed-off-by: Narcisa Vasile 
---
 lib/eal/common/rte_thread.c  |  97 ++
 lib/eal/include/rte_thread.h |  34 ++
 lib/eal/version.map  |   2 +
 lib/eal/windows/rte_thread.c | 127 +++
 4 files changed, 260 insertions(+)

diff --git a/lib/eal/common/rte_thread.c b/lib/eal/common/rte_thread.c
index 73b7b3141c..7ab08561a5 100644
--- a/lib/eal/common/rte_thread.c
+++ b/lib/eal/common/rte_thread.c
@@ -50,6 +50,103 @@ rte_thread_get_affinity_by_id(rte_thread_t thread_id,
sizeof(*cpuset), cpuset);
 }
 
+static int
+thread_map_priority_to_os_value(enum rte_thread_priority eal_pri,
+   int *os_pri, int *pol)
+{
+   /* Clear the output parameters */
+   *os_pri = sched_get_priority_min(SCHED_OTHER) - 1;
+   *pol = -1;
+
+   switch (eal_pri) {
+   case RTE_THREAD_PRIORITY_NORMAL:
+   *pol = SCHED_OTHER;
+
+   /*
+* Choose the middle of the range to represent
+* the priority 'normal'.
+* On Linux, this should be 0, since both
+* sched_get_priority_min/_max return 0 for SCHED_OTHER.
+*/
+   *os_pri = (sched_get_priority_min(SCHED_OTHER) +
+   sched_get_priority_max(SCHED_OTHER))/2;
+   break;
+   case RTE_THREAD_PRIORITY_REALTIME_CRITICAL:
+   *pol = SCHED_RR;
+   *os_pri = sched_get_priority_max(SCHED_RR);
+   break;
+   default:
+   RTE_LOG(DEBUG, EAL, "The requested priority value is 
invalid.\n");
+   return EINVAL;
+   }
+   return 0;
+}
+
+static int
+thread_map_os_priority_to_eal_priority(int policy, int os_pri,
+   enum rte_thread_priority *eal_pri)
+{
+   switch (policy) {
+   case SCHED_OTHER:
+   if (os_pri == (sched_get_priority_min(SCHED_OTHER) +
+   sched_get_priority_max(SCHED_OTHER))/2) {
+   *eal_pri = RTE_THREAD_PRIORITY_NORMAL;
+   return 0;
+   }
+   break;
+   case SCHED_RR:
+   if (os_pri == sched_get_priority_max(SCHED_RR)) {
+   *eal_pri = RTE_THREAD_PRIORITY_REALTIME_CRITICAL;
+   return 0;
+   }
+   break;
+   default:
+   RTE_LOG(DEBUG, EAL, "The OS priority value does not map to an 
EAL-defined priority.\n");
+   return EINVAL;
+   }
+
+   return 0;
+}
+
+int
+rte_thread_get_priority(rte_thread_t thread_id,
+   enum rte_thread_priority *priority)
+{
+   int ret;
+   int policy;
+   struct sched_param param;
+
+   ret = pthread_getschedparam((pthread_t)thread_id.opaque_id, &policy,
+   ¶m);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "pthread_getschedparam failed\n");
+   goto cleanup;
+   }
+
+   return thread_map_os_priority_to_eal_priority(policy,
+   param.sched_priority, priority);
+
+cleanup:
+   return ret;
+}
+
+int
+rte_thread_set_priority(rte_thread_t thread_id,
+   enum rte_thread_priority priority)
+{
+   int ret;
+   int policy;
+   struct sched_param param;
+
+   ret = thread_map_priority_to_os_value(priority, ¶m.sched_priority,
+   &policy);
+   if (ret != 0)
+   return ret;
+
+   return pthread_setschedparam((pthread_t)thread_id.opaque_id,
+   policy, ¶m);
+}
+
 int
 rte_thread_attr_init(rte_thread_attr_t *attr)
 {
diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index 5b100cafda..7077c9ce46 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -213,6 +213,40 @@ void rte_thread_get_affinity(rte_cpuset_t *cpusetp);
 
 #endif /* RTE_HAS_CPUSET */
 
+/**
+ * Get the priority of a thread.
+ *
+ * @param thread_id
+ *Id of the thread for which to get priority.
+ *
+ * @param priority
+ *   Location to store the retrieved priority.
+ *
+ * @return
+ *   On success, return

[dpdk-dev] [PATCH v16 7/9] eal: implement functions for mutex management

From: Narcisa Vasile 

Add functions for mutex init, destroy, lock, unlock, trylock.

Add RTE_STATIC_MUTEX macro to replace static initialization
of mutexes.
Windows does not have a static initializer.
Initialization is only done through InitializeCriticalSection().

The RTE_STATIC_MUTEX calls into the rte_thread_mutex_init()
function that performs the actual mutex initialization.

Signed-off-by: Narcisa Vasile 
---
 lib/eal/common/rte_thread.c  |  69 ++
 lib/eal/include/rte_thread.h | 108 +++
 lib/eal/version.map  |   5 ++
 lib/eal/windows/rte_thread.c |  64 +
 4 files changed, 246 insertions(+)

diff --git a/lib/eal/common/rte_thread.c b/lib/eal/common/rte_thread.c
index b3a9d4b47e..476a8a1c08 100644
--- a/lib/eal/common/rte_thread.c
+++ b/lib/eal/common/rte_thread.c
@@ -295,6 +295,75 @@ rte_thread_detach(rte_thread_t thread_id)
return pthread_detach((pthread_t)thread_id.opaque_id);
 }
 
+int
+rte_thread_mutex_init(rte_thread_mutex *mutex)
+{
+   int ret = 0;
+   pthread_mutex_t *m = NULL;
+
+   RTE_VERIFY(mutex != NULL);
+
+   m = calloc(1, sizeof(*m));
+   if (m == NULL) {
+   RTE_LOG(DEBUG, EAL, "Unable to initialize mutex. Insufficient 
memory!\n");
+   ret = ENOMEM;
+   goto cleanup;
+   }
+
+   ret = pthread_mutex_init(m, NULL);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "Failed to init mutex. ret = %d\n", ret);
+   goto cleanup;
+   }
+
+   mutex->mutex_id = m;
+   m = NULL;
+
+cleanup:
+   free(m);
+   return ret;
+}
+
+int
+rte_thread_mutex_lock(rte_thread_mutex *mutex)
+{
+   RTE_VERIFY(mutex != NULL);
+
+   return pthread_mutex_lock((pthread_mutex_t *)mutex->mutex_id);
+}
+
+int
+rte_thread_mutex_unlock(rte_thread_mutex *mutex)
+{
+   RTE_VERIFY(mutex != NULL);
+
+   return pthread_mutex_unlock((pthread_mutex_t *)mutex->mutex_id);
+}
+
+int
+rte_thread_mutex_try_lock(rte_thread_mutex *mutex)
+{
+   RTE_VERIFY(mutex != NULL);
+
+   return pthread_mutex_trylock((pthread_mutex_t *)mutex->mutex_id);
+}
+
+int
+rte_thread_mutex_destroy(rte_thread_mutex *mutex)
+{
+   int ret = 0;
+   RTE_VERIFY(mutex != NULL);
+
+   ret = pthread_mutex_destroy((pthread_mutex_t *)mutex->mutex_id);
+   if (ret != 0)
+   RTE_LOG(DEBUG, EAL, "Unable to destroy mutex, ret = %d\n", ret);
+
+   free(mutex->mutex_id);
+   mutex->mutex_id = NULL;
+
+   return ret;
+}
+
 int
 rte_thread_key_create(rte_thread_key *key, void (*destructor)(void *))
 {
diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index e841321819..b5782d396f 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -54,6 +54,26 @@ typedef struct {
 
 #endif /* RTE_HAS_CPUSET */
 
+#define RTE_DECLARE_MUTEX(private_lock)  rte_thread_mutex private_lock
+
+#define RTE_DEFINE_MUTEX(private_lock)\
+RTE_INIT(__rte_ ## private_lock ## _init)\
+{\
+   RTE_VERIFY(rte_thread_mutex_init(&private_lock) == 0);\
+}
+
+#define RTE_STATIC_MUTEX(private_lock)\
+static RTE_DECLARE_MUTEX(private_lock);\
+RTE_DEFINE_MUTEX(private_lock)
+
+
+/**
+ * Thread mutex representation.
+ */
+typedef struct rte_thread_mutex_tag {
+   void *mutex_id;  /**< mutex identifier */
+} rte_thread_mutex;
+
 /**
  * TLS key type, an opaque pointer.
  */
@@ -266,6 +286,28 @@ int rte_thread_join(rte_thread_t thread_id, unsigned long 
*value_ptr);
 __rte_experimental
 int rte_thread_detach(rte_thread_t thread_id);
 
+/**
+ * Set core affinity of the current thread.
+ * Support both EAL and non-EAL thread and update TLS.
+ *
+ * @param cpusetp
+ *   Pointer to CPU affinity to set.
+ *
+ * @return
+ *   On success, return 0; otherwise return -1;
+ */
+int rte_thread_set_affinity(rte_cpuset_t *cpusetp);
+
+/**
+ * Get core affinity of the current thread.
+ *
+ * @param cpusetp
+ *   Pointer to CPU affinity of current thread.
+ *   It presumes input is not NULL, otherwise it causes panic.
+ *
+ */
+void rte_thread_get_affinity(rte_cpuset_t *cpusetp);
+
 #endif /* RTE_HAS_CPUSET */
 
 /**
@@ -302,6 +344,72 @@ __rte_experimental
 int rte_thread_set_priority(rte_thread_t thread_id,
enum rte_thread_priority priority);
 
+/**
+ * Initializes a mutex.
+ *
+ * @param mutex
+ *The mutex to be initialized.
+ *
+ * @return
+ *   On success, return 0.
+ *   On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_init(rte_thread_mutex *mutex);
+
+/**
+ * Locks a mutex.
+ *
+ * @param mutex
+ *The mutex to be locked.
+ *
+ * @return
+ *   On success, return 0.
+ *   On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_lock(rte_thread_mutex *mutex);
+
+/**
+ * Unlocks a mutex.
+ *
+ * @param mutex
+ *The mutex to be unlocked.
+ *
+ * @return
+ *   On success, return 0.
+ *

[dpdk-dev] [PATCH v16 8/9] eal: implement functions for thread barrier management

From: Narcisa Vasile 

Add functions for barrier init, destroy, wait.

A portable type is used to represent a barrier identifier.
The rte_thread_barrier_wait() function returns the same value
on all platforms.

Signed-off-by: Narcisa Vasile 
---
 lib/eal/common/rte_thread.c  | 61 
 lib/eal/include/rte_thread.h | 58 ++
 lib/eal/version.map  |  3 ++
 lib/eal/windows/rte_thread.c | 56 +
 4 files changed, 178 insertions(+)

diff --git a/lib/eal/common/rte_thread.c b/lib/eal/common/rte_thread.c
index 476a8a1c08..580448d8bf 100644
--- a/lib/eal/common/rte_thread.c
+++ b/lib/eal/common/rte_thread.c
@@ -364,6 +364,67 @@ rte_thread_mutex_destroy(rte_thread_mutex *mutex)
return ret;
 }
 
+int
+rte_thread_barrier_init(rte_thread_barrier *barrier, int count)
+{
+   int ret = 0;
+   pthread_barrier_t *pthread_barrier = NULL;
+
+   RTE_VERIFY(barrier != NULL);
+   RTE_VERIFY(count > 0);
+
+   pthread_barrier = calloc(1, sizeof(*pthread_barrier));
+   if (pthread_barrier == NULL) {
+   RTE_LOG(DEBUG, EAL, "Unable to initialize barrier. Insufficient 
memory!\n");
+   ret = ENOMEM;
+   goto cleanup;
+   }
+   ret = pthread_barrier_init(pthread_barrier, NULL, count);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "Failed to init barrier, ret = %d\n", ret);
+   goto cleanup;
+   }
+
+   barrier->barrier_id = pthread_barrier;
+   pthread_barrier = NULL;
+
+cleanup:
+   free(pthread_barrier);
+   return ret;
+}
+
+int
+rte_thread_barrier_wait(rte_thread_barrier *barrier)
+{
+   int ret = 0;
+
+   RTE_VERIFY(barrier != NULL);
+   RTE_VERIFY(barrier->barrier_id != NULL);
+
+   ret = pthread_barrier_wait(barrier->barrier_id);
+   if (ret == PTHREAD_BARRIER_SERIAL_THREAD)
+   ret = RTE_THREAD_BARRIER_SERIAL_THREAD;
+
+   return ret;
+}
+
+int
+rte_thread_barrier_destroy(rte_thread_barrier *barrier)
+{
+   int ret = 0;
+
+   RTE_VERIFY(barrier != NULL);
+
+   ret = pthread_barrier_destroy(barrier->barrier_id);
+   if (ret != 0)
+   RTE_LOG(DEBUG, EAL, "Failed to destroy barrier: %d\n", ret);
+
+   free(barrier->barrier_id);
+   barrier->barrier_id = NULL;
+
+   return ret;
+}
+
 int
 rte_thread_key_create(rte_thread_key *key, void (*destructor)(void *))
 {
diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index b5782d396f..0adc854225 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -74,6 +74,18 @@ typedef struct rte_thread_mutex_tag {
void *mutex_id;  /**< mutex identifier */
 } rte_thread_mutex;
 
+/**
+ * Returned by rte_thread_barrier_wait() when call is successful.
+ */
+#define RTE_THREAD_BARRIER_SERIAL_THREAD -1
+
+/**
+ * Thread barrier representation.
+ */
+typedef struct rte_thread_barrier_tag {
+   void *barrier_id;  /**< barrrier identifier */
+} rte_thread_barrier;
+
 /**
  * TLS key type, an opaque pointer.
  */
@@ -410,6 +422,52 @@ int rte_thread_mutex_try_lock(rte_thread_mutex *mutex);
 __rte_experimental
 int rte_thread_mutex_destroy(rte_thread_mutex *mutex);
 
+/**
+ * Initializes a synchronization barrier.
+ *
+ * @param barrier
+ *A pointer that references the newly created 'barrier' object.
+ *
+ * @param count
+ *The number of threads that must enter the barrier before
+ *the threads can continue execution.
+ *
+ * @return
+ *   On success, return 0.
+ *   On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_barrier_init(rte_thread_barrier *barrier, int count);
+
+/**
+ * Causes the calling thread to wait at the synchronization barrier 'barrier'.
+ *
+ * @param barrier
+ *The barrier used for synchronizing the threads.
+ *
+ * @return
+ *   Return RTE_THREAD_BARRIER_SERIAL_THREAD for the thread synchronized
+ *  at the barrier.
+ *   Return 0 for all other threads.
+ *   Return a positive errno-style error number, in case of failure.
+ */
+__rte_experimental
+int rte_thread_barrier_wait(rte_thread_barrier *barrier);
+
+/**
+ * Releases all resources used by a synchronization barrier
+ * and uninitializes it.
+ *
+ * @param barrier
+ *The barrier to be destroyed.
+ *
+ * @return
+ *   On success, return 0.
+ *   On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_barrier_destroy(rte_thread_barrier *barrier);
+
 /**
  * Create a TLS data key visible to all threads in the process.
  * the created key is later used to get/set a value.
diff --git a/lib/eal/version.map b/lib/eal/version.map
index 2506eb1587..ca05ba4f43 100644
--- a/lib/eal/version.map
+++ b/lib/eal/version.map
@@ -439,6 +439,9 @@ EXPERIMENTAL {
rte_thread_mutex_unlock;
rte_thread_mutex_try_lock;
rte_thread_mutex_destroy;
+   rte_thread_barrier_init

[dpdk-dev] [PATCH v16 6/9] eal: add thread lifetime management

From: Narcisa Vasile 

Add functions for thread creation, joining, detaching.

The *rte_thread_create()* function can optionally receive
an rte_thread_attr_t object that will cause the thread to be
created with the affinity and priority described by the
attributes object. If no rte_thread_attr_t is passed (parameter is NULL),
the default affinity and priority are used.

On Windows, the function executed by a thread when the thread starts is
represeneted by a function pointer of type DWORD (*func) (void*).
On other platforms, the function pointer is a void* (*func) (void*).

Performing a cast between these two types of function pointers to
uniformize the API on all platforms may result in undefined behavior.
TO fix this issue, a wrapper that respects the signature required by
CreateThread() has been created on Windows.

Signed-off-by: Narcisa Vasile 
---
 lib/eal/common/rte_thread.c | 103 
 lib/eal/include/rte_thread.h|  55 +
 lib/eal/version.map |   3 +
 lib/eal/windows/include/sched.h |   2 +-
 lib/eal/windows/rte_thread.c| 134 
 5 files changed, 296 insertions(+), 1 deletion(-)

diff --git a/lib/eal/common/rte_thread.c b/lib/eal/common/rte_thread.c
index 7ab08561a5..b3a9d4b47e 100644
--- a/lib/eal/common/rte_thread.c
+++ b/lib/eal/common/rte_thread.c
@@ -192,6 +192,109 @@ rte_thread_attr_set_priority(rte_thread_attr_t 
*thread_attr,
return 0;
 }
 
+int
+rte_thread_create(rte_thread_t *thread_id,
+   const rte_thread_attr_t *thread_attr,
+   rte_thread_func thread_func, void *args)
+{
+   int ret = 0;
+   pthread_attr_t attr;
+   pthread_attr_t *attrp = NULL;
+   struct sched_param param = {
+   .sched_priority = 0,
+   };
+   int policy = SCHED_OTHER;
+
+   if (thread_attr != NULL) {
+   ret = pthread_attr_init(&attr);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "pthread_attr_init failed\n");
+   goto cleanup;
+   }
+
+   attrp = &attr;
+
+   /*
+* Set the inherit scheduler parameter to explicit,
+* otherwise the priority attribute is ignored.
+*/
+   ret = pthread_attr_setinheritsched(attrp,
+   PTHREAD_EXPLICIT_SCHED);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "pthread_attr_setinheritsched 
failed\n");
+   goto cleanup;
+   }
+
+   ret = thread_map_priority_to_os_value(thread_attr->priority,
+   ¶m.sched_priority, &policy);
+   if (ret != 0)
+   goto cleanup;
+
+   ret = pthread_attr_setschedpolicy(attrp, policy);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "pthread_attr_setschedpolicy 
failed\n");
+   goto cleanup;
+   }
+
+   ret = pthread_attr_setschedparam(attrp, ¶m);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "pthread_attr_setschedparam 
failed\n");
+   goto cleanup;
+   }
+   }
+
+   ret = pthread_create((pthread_t *)&thread_id->opaque_id, attrp,
+   thread_func, args);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "pthread_create failed\n");
+   goto cleanup;
+   }
+
+   if (thread_attr != NULL && CPU_COUNT(&thread_attr->cpuset) > 0) {
+   ret = pthread_setaffinity_np((pthread_t)thread_id->opaque_id,
+   sizeof(thread_attr->cpuset),
+   &thread_attr->cpuset);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "pthread_setaffinity_np failed\n");
+   goto cleanup;
+   }
+   }
+
+cleanup:
+   if (attrp != NULL)
+   pthread_attr_destroy(&attr);
+
+   return ret;
+}
+
+int
+rte_thread_join(rte_thread_t thread_id, unsigned long *value_ptr)
+{
+   int ret = 0;
+   void *res = NULL;
+   void **pres = NULL;
+
+   if (value_ptr != NULL)
+   pres = &res;
+
+   ret = pthread_join((pthread_t)thread_id.opaque_id, pres);
+   if (ret != 0) {
+   RTE_LOG(DEBUG, EAL, "pthread_join failed\n");
+   return ret;
+   }
+
+   if (value_ptr != NULL && *pres != NULL)
+   *value_ptr = *(unsigned long *)(*pres);
+
+   return 0;
+}
+
+int
+rte_thread_detach(rte_thread_t thread_id)
+{
+   return pthread_detach((pthread_t)thread_id.opaque_id);
+}
+
 int
 rte_thread_key_create(rte_thread_key *key, void (*destructor)(void *))
 {
diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index 7077c9ce46..e841321819 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -31,

[dpdk-dev] [PATCH v16 9/9] Add unit tests for thread API

From: Narcisa Vasile 

As a new API for threading is introduced,
a set of unit tests have been added to test the new interface.
The tests verify that:
 * mutexes and barriers behave as expected
 * thread properties are applied correctly
 * the thread id is retrieved correctly
 * thread creation/destruction works properly

Signed-off-by: Narcisa Vasile 
---
 app/test/meson.build|   2 +
 app/test/test_threads.c | 372 
 2 files changed, 374 insertions(+)
 create mode 100644 app/test/test_threads.c

diff --git a/app/test/meson.build b/app/test/meson.build
index f144d8b8ed..019c7e27d0 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -141,6 +141,7 @@ test_sources = files(
 'test_table_tables.c',
 'test_tailq.c',
 'test_thash.c',
+'test_threads.c',
 'test_timer.c',
 'test_timer_perf.c',
 'test_timer_racecond.c',
@@ -277,6 +278,7 @@ fast_tests = [
 ['reorder_autotest', true],
 ['service_autotest', true],
 ['thash_autotest', true],
+['threads_autotest', true],
 ['trace_autotest', true],
 ]
 
diff --git a/app/test/test_threads.c b/app/test/test_threads.c
new file mode 100644
index 00..d125a55b2e
--- /dev/null
+++ b/app/test/test_threads.c
@@ -0,0 +1,372 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright (c) 2021 Microsoft.
+ */
+
+#include 
+#include 
+
+#include "test.h"
+
+#define THREADS_COUNT 20
+
+RTE_LOG_REGISTER(threads_logtype_test, test.threads, INFO);
+
+static void *
+thread_loop_self(void *arg)
+{
+   rte_thread_t *id = arg;
+
+   *id = rte_thread_self();
+
+   return NULL;
+}
+
+static int
+test_thread_self(void)
+{
+   rte_thread_t threads_ids[THREADS_COUNT];
+   rte_thread_t self_ids[THREADS_COUNT] = {};
+   int ret;
+   int i;
+
+   for (i = 0; i < THREADS_COUNT; ++i) {
+   ret = rte_thread_create(&threads_ids[i], NULL, thread_loop_self,
+   &self_ids[i]);
+   RTE_TEST_ASSERT(ret == 0, "Failed to create threads!");
+   }
+
+   for (i = 0; i < THREADS_COUNT; ++i) {
+   RTE_TEST_ASSERT(rte_thread_join(threads_ids[i], NULL) == 0, 
"Failed to join thread!");
+   RTE_TEST_ASSERT_EQUAL(threads_ids[i].opaque_id,
+   self_ids[i].opaque_id, "Unexpected thread id!");
+   }
+
+   return 0;
+}
+
+struct thread_context {
+   rte_thread_barrier *barrier;
+   int barrier_result;
+};
+
+static void *
+thread_loop_barrier(void *arg)
+{
+   struct thread_context *ctx = arg;
+
+   ctx->barrier_result = rte_thread_barrier_wait(ctx->barrier);
+   if (ctx->barrier_result > 0)
+   rte_log(RTE_LOG_DEBUG, threads_logtype_test, "Failed to wait at 
barrier!");
+
+   return NULL;
+}
+
+static int
+test_thread_barrier(void)
+{
+   rte_thread_t thread_id;
+   struct thread_context ctx;
+   rte_thread_barrier barrier;
+   int ret = 0;
+   int result = 0;
+
+   ret = rte_thread_barrier_init(&barrier, 2);
+   RTE_TEST_ASSERT(ret == 0, "Failed to initialize barrier!");
+
+   ctx.barrier = &barrier;
+   ret = rte_thread_create(&thread_id, NULL, thread_loop_barrier, &ctx);
+   RTE_TEST_ASSERT(ret == 0, "Failed to create thread!");
+
+   result = rte_thread_barrier_wait(&barrier);
+   RTE_TEST_ASSERT(result <= 0, "Failed to wait at the barrier!");
+
+   ret = rte_thread_join(thread_id, NULL);
+   RTE_TEST_ASSERT(ret == 0, "Failed to join threads!");
+
+   ret = rte_thread_barrier_destroy(&barrier);
+   RTE_TEST_ASSERT(ret == 0, "Failed to destroy barrier!");
+
+   RTE_TEST_ASSERT(ctx.barrier_result <= 0, "Child thread failed to wait 
at the barrier!");
+   RTE_TEST_ASSERT_NOT_EQUAL(ctx.barrier_result, result, "Threads were not 
blocked at the barrier!");
+
+   return 0;
+}
+
+RTE_STATIC_MUTEX(static_mutex);
+
+struct mutex_loop_args {
+   rte_thread_barrier *barrier;
+   rte_thread_mutex *mutex;
+   unsigned long result_A;
+   unsigned long result_B;
+};
+
+static void *
+thread_loop_mutex_B(void *arg)
+{
+   struct mutex_loop_args *args = arg;
+
+   if (rte_thread_mutex_try_lock(args->mutex) == 0) {
+   rte_thread_barrier_wait(args->barrier);
+   rte_thread_mutex_unlock(args->mutex);
+   args->result_B = 1;
+   } else {
+   rte_thread_barrier_wait(args->barrier);
+   args->result_B = 2;
+   }
+
+   return NULL;
+}
+
+static void *
+thread_loop_mutex_A(void *arg)
+{
+   struct mutex_loop_args *args = arg;
+
+   if (rte_thread_mutex_try_lock(args->mutex) != 0) {
+   rte_thread_barrier_wait(args->barrier);
+   args->result_A = 2;
+   } else {
+   rte_thread_barrier_wait(args->barrier);
+   rte_thread_mutex_unlock(args->mutex);
+   args->result_A =

[dpdk-dev] [PATCH] net/hns3: remove similar macro function definitions

2021-10-09 Thread Min Hu (Connor)

From: Chengchang Tang 

For different capabilities, we declare different macro functions to
determine whether the capabilities are supported.

This patch declare a unified macro function to judge capabilities.

Signed-off-by: Chengchang Tang 
Signed-off-by: Min Hu (Connor) 
---
 drivers/net/hns3/hns3_cmd.c   |  6 ++---
 drivers/net/hns3/hns3_dcb.c   |  4 +--
 drivers/net/hns3/hns3_ethdev.c| 24 +-
 drivers/net/hns3/hns3_ethdev.h| 41 ++-
 drivers/net/hns3/hns3_ethdev_vf.c |  6 ++---
 drivers/net/hns3/hns3_flow.c  |  2 +-
 drivers/net/hns3/hns3_intr.c  |  2 +-
 drivers/net/hns3/hns3_ptp.c   | 18 +++---
 drivers/net/hns3/hns3_rxtx.c  | 32 
 drivers/net/hns3/hns3_rxtx_vec.c  |  4 +--
 drivers/net/hns3/hns3_tm.c| 10 
 11 files changed, 56 insertions(+), 93 deletions(-)

diff --git a/drivers/net/hns3/hns3_cmd.c b/drivers/net/hns3/hns3_cmd.c
index 6a1e634684..50769c6226 100644
--- a/drivers/net/hns3/hns3_cmd.c
+++ b/drivers/net/hns3/hns3_cmd.c
@@ -617,7 +617,7 @@ hns3_update_dev_lsc_cap(struct hns3_hw *hw, int 
fw_compact_cmd_result)
 static int
 hns3_apply_fw_compat_cmd_result(struct hns3_hw *hw, int result)
 {
-   if (result != 0 && hns3_dev_copper_supported(hw)) {
+   if (result != 0 && hns3_dev_get_support(hw, COPPER)) {
hns3_err(hw, "firmware fails to initialize the PHY, ret = %d.",
 result);
return result;
@@ -656,7 +656,7 @@ hns3_firmware_compat_config(struct hns3_hw *hw, bool 
is_init)
}
if (revision == PCI_REVISION_ID_HIP09_A) {
struct hns3_pf *pf = HNS3_DEV_HW_TO_PF(hw);
-   if (hns3_dev_copper_supported(hw) == 0 || pf->is_tmp_phy) {
+   if (hns3_dev_get_support(hw, COPPER) == 0 || pf->is_tmp_phy) {
PMD_INIT_LOG(ERR, "***use temp phy driver in dpdk***");
pf->is_tmp_phy = true;
hns3_set_bit(hw->capability,
@@ -674,7 +674,7 @@ hns3_firmware_compat_config(struct hns3_hw *hw, bool 
is_init)
if (is_init) {
hns3_set_bit(compat, HNS3_LINK_EVENT_REPORT_EN_B, 1);
hns3_set_bit(compat, HNS3_NCSI_ERROR_REPORT_EN_B, 0);
-   if (hns3_dev_copper_supported(hw))
+   if (hns3_dev_get_support(hw, COPPER))
hns3_set_bit(compat, HNS3_FIRMWARE_PHY_DRIVER_EN_B, 1);
}
req->compat = rte_cpu_to_le_32(compat);
diff --git a/drivers/net/hns3/hns3_dcb.c b/drivers/net/hns3/hns3_dcb.c
index b71e2e9ea4..8753c340e7 100644
--- a/drivers/net/hns3/hns3_dcb.c
+++ b/drivers/net/hns3/hns3_dcb.c
@@ -918,7 +918,7 @@ hns3_dcb_pri_dwrr_cfg(struct hns3_hw *hw)
if (ret)
return ret;
 
-   if (!hns3_dev_dcb_supported(hw))
+   if (!hns3_dev_get_support(hw, DCB))
return 0;
 
ret = hns3_dcb_ets_tc_dwrr_cfg(hw);
@@ -1368,7 +1368,7 @@ hns3_dcb_pause_setup_hw(struct hns3_hw *hw)
}
 
/* Only DCB-supported dev supports qset back pressure and pfc cmd */
-   if (!hns3_dev_dcb_supported(hw))
+   if (!hns3_dev_get_support(hw, DCB))
return 0;
 
ret = hns3_pfc_setup_hw(hw);
diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c
index cabf73ffbc..b98a46f73e 100644
--- a/drivers/net/hns3/hns3_ethdev.c
+++ b/drivers/net/hns3/hns3_ethdev.c
@@ -2408,7 +2408,7 @@ hns3_setup_dcb(struct rte_eth_dev *dev)
struct hns3_hw *hw = &hns->hw;
int ret;
 
-   if (!hns3_dev_dcb_supported(hw)) {
+   if (!hns3_dev_get_support(hw, DCB)) {
hns3_err(hw, "this port does not support dcb configurations.");
return -EOPNOTSUPP;
}
@@ -2746,14 +2746,14 @@ hns3_dev_infos_get(struct rte_eth_dev *eth_dev, struct 
rte_eth_dev_info *info)
 DEV_TX_OFFLOAD_MBUF_FAST_FREE |
 hns3_txvlan_cap_get(hw));
 
-   if (hns3_dev_outer_udp_cksum_supported(hw))
+   if (hns3_dev_get_support(hw, OUTER_UDP_CKSUM))
info->tx_offload_capa |= DEV_TX_OFFLOAD_OUTER_UDP_CKSUM;
 
-   if (hns3_dev_indep_txrx_supported(hw))
+   if (hns3_dev_get_support(hw, INDEP_TXRX))
info->dev_capa = RTE_ETH_DEV_CAPA_RUNTIME_RX_QUEUE_SETUP |
 RTE_ETH_DEV_CAPA_RUNTIME_TX_QUEUE_SETUP;
 
-   if (hns3_dev_ptp_supported(hw))
+   if (hns3_dev_get_support(hw, PTP))
info->rx_offload_capa |= DEV_RX_OFFLOAD_TIMESTAMP;
 
info->rx_desc_lim = (struct rte_eth_desc_lim) {
@@ -3421,7 +3421,7 @@ hns3_check_media_type(struct hns3_hw *hw, uint8_t 
media_type)
 
switch (media_type) {
case HNS3_MEDIA_TYPE_COPPER:
-   if (!hns3_dev_copper_supported(hw)) {
+   if (!hns3_dev_get_support(hw, COPPER)) {
PMD_INIT_LOG(ERR,

[dpdk-dev] [PATCH v4 1/2] event/cnxk: update min interval calculation

2021-10-09 Thread pbhagavatula

From: Pavan Nikhilesh 

Minimum supported interval should now be retrieved from
mailbox based on the clock source and clock frequency.

Signed-off-by: Pavan Nikhilesh 
---
v4:
- Rebase on master, fix NULL checks.
v3:
- Add new mbox interface.
v2:
- Fixed devargs parsing and rebased.

 drivers/common/cnxk/roc_mbox.h  | 17 +++
 drivers/common/cnxk/roc_tim.c   | 32 +++-
 drivers/common/cnxk/roc_tim.h   |  9 +++-
 drivers/common/cnxk/version.map |  1 +
 drivers/event/cnxk/cnxk_tim_evdev.c | 69 +
 drivers/event/cnxk/cnxk_tim_evdev.h | 79 ++---
 6 files changed, 155 insertions(+), 52 deletions(-)

diff --git a/drivers/common/cnxk/roc_mbox.h b/drivers/common/cnxk/roc_mbox.h
index 75d1ff1ef3..c3688de065 100644
--- a/drivers/common/cnxk/roc_mbox.h
+++ b/drivers/common/cnxk/roc_mbox.h
@@ -131,6 +131,8 @@ struct mbox_msghdr {
M(TIM_ENABLE_RING, 0x803, tim_enable_ring, tim_ring_req,   \
  tim_enable_rsp)  \
M(TIM_DISABLE_RING, 0x804, tim_disable_ring, tim_ring_req, msg_rsp)\
+   M(TIM_GET_MIN_INTVL, 0x805, tim_get_min_intvl, tim_intvl_req,  \
+ tim_intvl_rsp)   \
/* CPT mbox IDs (range 0xA00 - 0xBFF) */   \
M(CPT_LF_ALLOC, 0xA00, cpt_lf_alloc, cpt_lf_alloc_req_msg, msg_rsp)\
M(CPT_LF_FREE, 0xA01, cpt_lf_free, msg_req, msg_rsp)   \
@@ -1756,6 +1758,9 @@ struct tim_config_req {
uint32_t __io chunksize;
uint32_t __io interval;
uint8_t __io gpioedge;
+   uint8_t __io rsvd[7];
+   uint64_t __io intervalns;
+   uint64_t __io clockfreq;
 };

 struct tim_lf_alloc_rsp {
@@ -1769,6 +1774,18 @@ struct tim_enable_rsp {
uint32_t __io currentbucket;
 };

+struct tim_intvl_req {
+   struct mbox_msghdr hdr;
+   uint8_t __io clocksource;
+   uint64_t __io clockfreq;
+};
+
+struct tim_intvl_rsp {
+   struct mbox_msghdr hdr;
+   uint64_t __io intvl_cyc;
+   uint64_t __io intvl_ns;
+};
+
 struct sdp_node_info {
/* Node to which this PF belons to */
uint8_t __io node_id;
diff --git a/drivers/common/cnxk/roc_tim.c b/drivers/common/cnxk/roc_tim.c
index 387164bb1d..eefa8253bc 100644
--- a/drivers/common/cnxk/roc_tim.c
+++ b/drivers/common/cnxk/roc_tim.c
@@ -145,7 +145,7 @@ int
 roc_tim_lf_config(struct roc_tim *roc_tim, uint8_t ring_id,
  enum roc_tim_clk_src clk_src, uint8_t ena_periodic,
  uint8_t ena_dfb, uint32_t bucket_sz, uint32_t chunk_sz,
- uint32_t interval)
+ uint32_t interval, uint64_t intervalns, uint64_t clockfreq)
 {
struct dev *dev = &roc_sso_to_sso_priv(roc_tim->roc_sso)->dev;
struct tim_config_req *req;
@@ -162,6 +162,8 @@ roc_tim_lf_config(struct roc_tim *roc_tim, uint8_t ring_id,
req->enableperiodic = ena_periodic;
req->enabledontfreebuffer = ena_dfb;
req->interval = interval;
+   req->intervalns = intervalns;
+   req->clockfreq = clockfreq;
req->gpioedge = TIM_GPIO_LTOH_TRANS;

rc = mbox_process(dev->mbox);
@@ -173,6 +175,34 @@ roc_tim_lf_config(struct roc_tim *roc_tim, uint8_t ring_id,
return 0;
 }

+int
+roc_tim_lf_interval(struct roc_tim *roc_tim, enum roc_tim_clk_src clk_src,
+   uint64_t clockfreq, uint64_t *intervalns,
+   uint64_t *interval)
+{
+   struct dev *dev = &roc_sso_to_sso_priv(roc_tim->roc_sso)->dev;
+   struct tim_intvl_req *req;
+   struct tim_intvl_rsp *rsp;
+   int rc = -ENOSPC;
+
+   req = mbox_alloc_msg_tim_get_min_intvl(dev->mbox);
+   if (req == NULL)
+   return rc;
+
+   req->clockfreq = clockfreq;
+   req->clocksource = clk_src;
+   rc = mbox_process_msg(dev->mbox, (void **)&rsp);
+   if (rc < 0) {
+   tim_err_desc(rc);
+   return rc;
+   }
+
+   *intervalns = rsp->intvl_ns;
+   *interval = rsp->intvl_cyc;
+
+   return 0;
+}
+
 int
 roc_tim_lf_alloc(struct roc_tim *roc_tim, uint8_t ring_id, uint64_t *clk)
 {
diff --git a/drivers/common/cnxk/roc_tim.h b/drivers/common/cnxk/roc_tim.h
index 159b021a31..392732eae2 100644
--- a/drivers/common/cnxk/roc_tim.h
+++ b/drivers/common/cnxk/roc_tim.h
@@ -10,6 +10,8 @@ enum roc_tim_clk_src {
ROC_TIM_CLK_SRC_GPIO,
ROC_TIM_CLK_SRC_GTI,
ROC_TIM_CLK_SRC_PTP,
+   ROC_TIM_CLK_SRC_SYNCE,
+   ROC_TIM_CLK_SRC_BTS,
ROC_TIM_CLK_SRC_INVALID,
 };

@@ -33,7 +35,12 @@ int __roc_api roc_tim_lf_config(struct roc_tim *roc_tim, 
uint8_t ring_id,
enum roc_tim_clk_src clk_src,
uint8_t ena_periodic, uint8_t ena_dfb,
uint32_t bucket_sz, uint32_t chunk_sz,
-   uint32_t interval)

[dpdk-dev] [PATCH v4 2/2] event/cnxk: add external clock support for timer

2021-10-09 Thread pbhagavatula

From: Pavan Nikhilesh 

Add external clock support for cnxk timer adapter.

External clock mapping is as follows:
RTE_EVENT_TIMER_ADAPTER_EXT_CLK0 = TIM_CLK_SRC_10NS,
RTE_EVENT_TIMER_ADAPTER_EXT_CLK1 = TIM_CLK_SRC_GPIO,
RTE_EVENT_TIMER_ADAPTER_EXT_CLK2 = TIM_CLK_SRC_PTP,
RTE_EVENT_TIMER_ADAPTER_EXT_CLK3 = TIM_CLK_SRC_SYNCE,

TIM supports clock input from external GPIO, PTP, SYNCE clocks.
Input resolution is adjusted based on CNTVCT frequency for better
estimation.

Since TIM is unaware of input clock frequency, application is
expected to pass the frequency.
Example:
-a 0002:0e:00.0,tim_eclk_freq=12288-0-0

The order of frequencies above is GPIO-PTP-SYNCE.

Signed-off-by: Shijith Thotton 
Signed-off-by: Pavan Nikhilesh 
---
 doc/guides/eventdevs/cnxk.rst   |  18 
 drivers/common/cnxk/roc_platform.h  |   1 +
 drivers/event/cnxk/cn10k_eventdev.c |   3 +-
 drivers/event/cnxk/cnxk_tim_evdev.c | 141 +++-
 drivers/event/cnxk/cnxk_tim_evdev.h |  11 ++-
 5 files changed, 165 insertions(+), 9 deletions(-)

diff --git a/doc/guides/eventdevs/cnxk.rst b/doc/guides/eventdevs/cnxk.rst
index 53560d3830..18540dc911 100644
--- a/doc/guides/eventdevs/cnxk.rst
+++ b/doc/guides/eventdevs/cnxk.rst
@@ -164,6 +164,24 @@ Runtime Config Options
 
 -a 0002:0e:00.0,tim_ring_ctl=[2-1023-1-0]
 
+- ``TIM external clock frequency``
+
+  The ``tim_eclk_freq`` devagrs can be used to pass external clock frequencies
+  when external clock source is selected.
+
+  External clock frequencies are mapped as follows::
+
+RTE_EVENT_TIMER_ADAPTER_EXT_CLK0 = TIM_CLK_SRC_10NS,
+RTE_EVENT_TIMER_ADAPTER_EXT_CLK1 = TIM_CLK_SRC_GPIO,
+RTE_EVENT_TIMER_ADAPTER_EXT_CLK2 = TIM_CLK_SRC_PTP,
+RTE_EVENT_TIMER_ADAPTER_EXT_CLK3 = TIM_CLK_SRC_SYNCE
+
+  The order of frequencies supplied to device args should be GPIO-PTP-SYNCE.
+
+  For Example::
+
+-a 0002:0e:00.0,tim_eclk_freq=12288-10-0
+
 Debugging Options
 -
 
diff --git a/drivers/common/cnxk/roc_platform.h 
b/drivers/common/cnxk/roc_platform.h
index 285b24b82d..7e73972b80 100644
--- a/drivers/common/cnxk/roc_platform.h
+++ b/drivers/common/cnxk/roc_platform.h
@@ -43,6 +43,7 @@
 #define PLT_MAX RTE_MAX
 #define PLT_DIM RTE_DIM
 #define PLT_SET_USEDRTE_SET_USED
+#define PLT_SWAPRTE_SWAP
 #define PLT_STATIC_ASSERT(s)_Static_assert(s, #s)
 #define PLT_ALIGN   RTE_ALIGN
 #define PLT_ALIGN_MUL_CEIL  RTE_ALIGN_MUL_CEIL
diff --git a/drivers/event/cnxk/cn10k_eventdev.c 
b/drivers/event/cnxk/cn10k_eventdev.c
index 8af273a01b..cf0a7d2325 100644
--- a/drivers/event/cnxk/cn10k_eventdev.c
+++ b/drivers/event/cnxk/cn10k_eventdev.c
@@ -976,4 +976,5 @@ RTE_PMD_REGISTER_PARAM_STRING(event_cn10k, CNXK_SSO_XAE_CNT 
"="
  CNXK_TIM_DISABLE_NPA "=1"
  CNXK_TIM_CHNK_SLOTS "="
  CNXK_TIM_RINGS_LMT "="
- CNXK_TIM_STATS_ENA "=1");
+ CNXK_TIM_STATS_ENA "=1"
+ CNXK_TIM_EXT_CLK "=");
diff --git a/drivers/event/cnxk/cnxk_tim_evdev.c 
b/drivers/event/cnxk/cnxk_tim_evdev.c
index 369f198444..cb0ad194b5 100644
--- a/drivers/event/cnxk/cnxk_tim_evdev.c
+++ b/drivers/event/cnxk/cnxk_tim_evdev.c
@@ -29,8 +29,8 @@ cnxk_tim_chnk_pool_create(struct cnxk_tim_ring *tim_ring,
snprintf(pool_name, sizeof(pool_name), "cnxk_tim_chunk_pool%d",
 tim_ring->ring_id);
 
-   if (cache_sz > RTE_MEMPOOL_CACHE_MAX_SIZE)
-   cache_sz = RTE_MEMPOOL_CACHE_MAX_SIZE;
+   if (cache_sz > CNXK_TIM_MAX_POOL_CACHE_SZ)
+   cache_sz = CNXK_TIM_MAX_POOL_CACHE_SZ;
cache_sz = cache_sz != 0 ? cache_sz : 2;
tim_ring->nb_chunks += (cache_sz * rte_lcore_count());
if (!tim_ring->disable_npa) {
@@ -117,6 +117,80 @@ cnxk_tim_ring_info_get(const struct 
rte_event_timer_adapter *adptr,
   sizeof(struct rte_event_timer_adapter_conf));
 }
 
+static inline void
+sort_multi_array(double ref_arr[], uint64_t arr1[], uint64_t arr2[],
+uint64_t arr3[], uint8_t sz)
+{
+   int x;
+
+   for (x = 0; x < sz - 1; x++) {
+   if (ref_arr[x] > ref_arr[x + 1]) {
+   PLT_SWAP(ref_arr[x], ref_arr[x + 1]);
+   PLT_SWAP(arr1[x], arr1[x + 1]);
+   PLT_SWAP(arr2[x], arr2[x + 1]);
+   PLT_SWAP(arr3[x], arr3[x + 1]);
+   x = -1;
+   }
+   }
+}
+
+static inline void
+populate_sample(uint64_t tck[], uint64_t ns[], double diff[], uint64_t dst[],
+   uint64_t req_tck, uint64_t clk_freq, double tck_ns, uint8_t sz,
+   bool mov_fwd)
+{
+   int i;
+
+   for (i = 0; i < sz; i++) {
+   tck[i] = i ? tck[i - 1] : req_tck;
+   do {
+   mov_fwd ? tck[i]++

[dpdk-dev] [PATCH] app/testpmd: retain all original dev conf when config DCB

2021-10-09 Thread Min Hu (Connor)

From: Huisong Li 

When configuring DCB, testpmd retains the rx_mode/tx_mode configuration in
rte_port->dev_conf. But some configurations, such as the link_speed, were
not saved if it were set before configuring DCB.

Fixes: 1a572499beb6 ("app/testpmd: setup DCB forwarding based on traffic class")
Cc: sta...@dpdk.org

Signed-off-by: Huisong Li 
Signed-off-by: Min Hu (Connor) 
---
 app/test-pmd/testpmd.c | 6 ++
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c
index eec4f1b81d..12a0db8796 100644
--- a/app/test-pmd/testpmd.c
+++ b/app/test-pmd/testpmd.c
@@ -3729,10 +3729,8 @@ init_port_dcb_config(portid_t pid,
}
rte_port = &ports[pid];
 
-   memset(&port_conf, 0, sizeof(struct rte_eth_conf));
-
-   port_conf.rxmode = rte_port->dev_conf.rxmode;
-   port_conf.txmode = rte_port->dev_conf.txmode;
+   /* retain the original device configuration. */
+   memcpy(&port_conf, &rte_port->dev_conf, sizeof(struct rte_eth_conf));
 
/*set configuration of DCB in vt mode and DCB in non-vt mode*/
retval = get_eth_dcb_conf(pid, &port_conf, dcb_mode, num_tcs, pfc_en);
-- 
2.33.0

Re: [dpdk-dev] [PATCH] net/i40e: fix remove MAC/VLAN addresses error

2021-10-09 Thread Zhang, Qi Z



> -Original Message-
> From: dev  On Behalf Of Zhang, RobinX
> Sent: Tuesday, September 28, 2021 6:36 PM
> To: Kevin Traynor ; dev@dpdk.org
> Cc: Xing, Beilei ; Guo, Junfeng
> ; Yang, SteveX 
> Subject: Re: [dpdk-dev] [PATCH] net/i40e: fix remove MAC/VLAN addresses
> error
> 
> Hi,
> 
> > -Original Message-
> > From: Kevin Traynor 
> > Sent: Tuesday, September 28, 2021 5:54 PM
> > To: Zhang, RobinX ; dev@dpdk.org
> > Cc: Xing, Beilei ; Guo, Junfeng
> > ; Yang, SteveX 
> > Subject: Re: [dpdk-dev] [PATCH] net/i40e: fix remove MAC/VLAN
> > addresses error
> >
> > On 28/09/2021 09:40, Robin Zhang wrote:
> > > Firmware will return I40E_AQ_RC_ENOENT when try to delete non-
> > existent
> > > MAC/VLAN addresses from the HW filtering, this should not be
> > > considered as an Admin Queue error. But in i40e_asq_send_command, it
> > > will return I40E_ERR_ADMIN_QUEUE_ERROR if the return value of Admin
> > > Queue command processed by Firmware is not I40E_AQ_RC_OK or
> > I40E_AQ_RC_EBUSY.
> > >
> > > Use i40e_aq_remove_macvlan_v2 instead so that we can get the
> > > corresponding Admin Queue status, and not report as an error in DPDK
> > > when Firmware return I40E_AQ_RC_ENOENT.
> > >
> > > Fixes: 4861cde46116 ("i40e: new poll mode driver")
> > >
> >
> > Is it relevant to stable releases (20.11/19.11) with earlier firmware?
> > https://git.dpdk.org/dpdk/tree/doc/guides/nics/i40e.rst#n101
> >
> 
> No, i40e_aq_remove_macvlan_v2 is added in latest i40e share code.
> So this patch cannot cc stable either.

To avoid confuse, lets remove the "fix" from this patch, 

Actually this is an AQ command upgrade to support new firmware and keep 
compatible with old firmware

So the title could be "upgrade AQ command of MAC/VLAN remove"

There might be the requirement to support new firmware in LTS release, but that 
should be covered by separated patches.


> 
> > > Signed-off-by: Robin Zhang 
> > > ---
> > >   drivers/net/i40e/i40e_ethdev.c | 15 +++
> > >   1 file changed, 11 insertions(+), 4 deletions(-)
> > >
> > > diff --git a/drivers/net/i40e/i40e_ethdev.c
> > > b/drivers/net/i40e/i40e_ethdev.c index acbe7380b1..fdc9943034 100644
> > > --- a/drivers/net/i40e/i40e_ethdev.c
> > > +++ b/drivers/net/i40e/i40e_ethdev.c
> > > @@ -7036,6 +7036,7 @@ i40e_remove_macvlan_filters(struct i40e_vsi
> *vsi,
> > >   int ret = I40E_SUCCESS;
> > >   struct i40e_hw *hw = I40E_VSI_TO_HW(vsi);
> > >   struct i40e_aqc_remove_macvlan_element_data *req_list;
> > > + enum i40e_admin_queue_err aq_status;
> > >
> > >   if (filter == NULL  || total == 0)
> > >   return I40E_ERR_PARAM;
> > > @@ -7083,11 +7084,17 @@ i40e_remove_macvlan_filters(struct i40e_vsi
> > *vsi,
> > >   req_list[i].flags = rte_cpu_to_le_16(flags);
> > >   }
> > >
> > > - ret = i40e_aq_remove_macvlan(hw, vsi->seid, req_list,
> > > - actual_num, NULL);
> > > + ret = i40e_aq_remove_macvlan_v2(hw, vsi->seid, req_list,
> > > + actual_num, NULL,
> > &aq_status);
> > > +
> > >   if (ret != I40E_SUCCESS) {
> > > - PMD_DRV_LOG(ERR, "Failed to remove macvlan
> > filter");
> > > - goto DONE;
> > > + /* Do not report as an error when firmware returns
> > ENOENT */
> > > + if (aq_status == I40E_AQ_RC_ENOENT) {
> > > + ret = I40E_SUCCESS;
> > > + } else {
> > > + PMD_DRV_LOG(ERR, "Failed to remove
> > macvlan filter");
> > > + goto DONE;
> > > + }
> > >   }
> > >   num += actual_num;
> > >   } while (num < total);
> > >

[dpdk-dev] [PATCH v24 0/6] support dmadev

This patch set contains six patch for new add dmadev.

Chengwen Feng (6):
  dmadev: introduce DMA device library
  dmadev: add control plane API support
  dmadev: add data plane API support
  dmadev: add multi-process support
  dma/skeleton: introduce skeleton dmadev driver
  app/test: add dmadev API test

---
v24:
* use rte_dma_fp_object to hide implementation details.
* support group doxygen for RTE_DMA_CAPA_* and RTE_DMA_OP_*.
* adjusted the naming of some functions.
* fix typo.
v23:
* split multi-process support from 1st patch.
* fix some static check warning.
* fix skeleton cpu thread zero_req_count flip bug.
* add test_dmadev_api.h.
* add the description of modifying the dmadev state when init OK.
v22:
* function prefix change from rte_dmadev_* to rte_dma_*.
* change to prefix comment in most scenarios.
* dmadev dev_id use int16_t type.
* fix typo.
* organize patchsets in incremental mode.
v21:
* add comment for reserved fields of struct rte_dmadev.
v20:
* delete unnecessary and duplicate include header files.
* the conf_sz parameter is added to the configure and vchan-setup
  callbacks of the PMD, this is mainly used to enhance ABI
  compatibility.
* the rte_dmadev structure field is rearranged to reserve more space
  for I/O functions.
* fix some ambiguous and unnecessary comments.
* fix the potential memory leak of ut.
* redefine skeldma_init_once to skeldma_count.
* suppress rte_dmadev error output when execute ut.

 MAINTAINERS|7 +
 app/test/meson.build   |4 +
 app/test/test_dmadev.c |   41 +
 app/test/test_dmadev_api.c |  574 +
 app/test/test_dmadev_api.h |5 +
 doc/api/doxy-api-index.md  |1 +
 doc/api/doxy-api.conf.in   |1 +
 doc/guides/dmadevs/index.rst   |   12 +
 doc/guides/index.rst   |1 +
 doc/guides/prog_guide/dmadev.rst   |  120 +++
 doc/guides/prog_guide/img/dmadev.svg   |  283 +++
 doc/guides/prog_guide/index.rst|1 +
 doc/guides/rel_notes/release_21_11.rst |6 +
 drivers/dma/meson.build|6 +
 drivers/dma/skeleton/meson.build   |7 +
 drivers/dma/skeleton/skeleton_dmadev.c |  571 +
 drivers/dma/skeleton/skeleton_dmadev.h |   61 ++
 drivers/dma/skeleton/version.map   |3 +
 drivers/meson.build|1 +
 lib/dmadev/meson.build |7 +
 lib/dmadev/rte_dmadev.c|  844 +++
 lib/dmadev/rte_dmadev.h| 1048 
 lib/dmadev/rte_dmadev_core.h   |   78 ++
 lib/dmadev/rte_dmadev_pmd.h|  173 
 lib/dmadev/version.map |   35 +
 lib/meson.build|1 +
 26 files changed, 3891 insertions(+)
 create mode 100644 app/test/test_dmadev.c
 create mode 100644 app/test/test_dmadev_api.c
 create mode 100644 app/test/test_dmadev_api.h
 create mode 100644 doc/guides/dmadevs/index.rst
 create mode 100644 doc/guides/prog_guide/dmadev.rst
 create mode 100644 doc/guides/prog_guide/img/dmadev.svg
 create mode 100644 drivers/dma/meson.build
 create mode 100644 drivers/dma/skeleton/meson.build
 create mode 100644 drivers/dma/skeleton/skeleton_dmadev.c
 create mode 100644 drivers/dma/skeleton/skeleton_dmadev.h
 create mode 100644 drivers/dma/skeleton/version.map
 create mode 100644 lib/dmadev/meson.build
 create mode 100644 lib/dmadev/rte_dmadev.c
 create mode 100644 lib/dmadev/rte_dmadev.h
 create mode 100644 lib/dmadev/rte_dmadev_core.h
 create mode 100644 lib/dmadev/rte_dmadev_pmd.h
 create mode 100644 lib/dmadev/version.map

-- 
2.33.0

[dpdk-dev] [PATCH v24 2/6] dmadev: add control plane API support

This patch add control plane API for dmadev.

Signed-off-by: Chengwen Feng 
Acked-by: Bruce Richardson 
Acked-by: Morten Brørup 
Reviewed-by: Kevin Laatz 
Reviewed-by: Conor Walsh 
---
 doc/guides/prog_guide/dmadev.rst   |  38 ++
 doc/guides/rel_notes/release_21_11.rst |   1 +
 lib/dmadev/rte_dmadev.c| 360 +++
 lib/dmadev/rte_dmadev.h| 464 +
 lib/dmadev/rte_dmadev_pmd.h|  61 
 lib/dmadev/version.map |   9 +
 6 files changed, 933 insertions(+)

diff --git a/doc/guides/prog_guide/dmadev.rst b/doc/guides/prog_guide/dmadev.rst
index 90bda28f33..5c70ad3d6a 100644
--- a/doc/guides/prog_guide/dmadev.rst
+++ b/doc/guides/prog_guide/dmadev.rst
@@ -58,3 +58,41 @@ identifiers:
 
 - A device name used to designate the DMA device in console messages, for
   administration or debugging purposes.
+
+
+Device Configuration
+
+
+The rte_dma_configure API is used to configure a DMA device.
+
+.. code-block:: c
+
+   int rte_dma_configure(int16_t dev_id,
+ const struct rte_dma_conf *dev_conf);
+
+The ``rte_dma_conf`` structure is used to pass the configuration parameters
+for the DMA device.
+
+
+Configuration of Virtual DMA Channels
+~
+
+The rte_dma_vchan_setup API is used to configure a virtual DMA channel.
+
+.. code-block:: c
+
+   int rte_dma_vchan_setup(int16_t dev_id, uint16_t vchan,
+   const struct rte_dma_vchan_conf *conf);
+
+The ``rte_dma_vchan_conf`` structure is used to pass the configuration
+parameters for the virtual DMA channel.
+
+
+Device Features and Capabilities
+
+
+DMA devices may support different feature sets. The ``rte_dma_info_get`` API
+can be used to get the device info and supported features.
+
+Silent mode is a special device capability which does not require the
+application to invoke dequeue APIs.
diff --git a/doc/guides/rel_notes/release_21_11.rst 
b/doc/guides/rel_notes/release_21_11.rst
index 929c0d6113..f935a3f395 100644
--- a/doc/guides/rel_notes/release_21_11.rst
+++ b/doc/guides/rel_notes/release_21_11.rst
@@ -144,6 +144,7 @@ New Features
 * **Introduced dmadev library with:**
 
   * Device allocation functions.
+  * Control plane API.
 
 
 Removed Items
diff --git a/lib/dmadev/rte_dmadev.c b/lib/dmadev/rte_dmadev.c
index 42a4693bd9..a6a5680d2b 100644
--- a/lib/dmadev/rte_dmadev.c
+++ b/lib/dmadev/rte_dmadev.c
@@ -201,6 +201,9 @@ rte_dma_pmd_release(const char *name)
if (dev == NULL)
return -EINVAL;
 
+   if (dev->state == RTE_DMA_DEV_READY)
+   return rte_dma_close(dev->dev_id);
+
dma_release(dev);
return 0;
 }
@@ -244,3 +247,360 @@ rte_dma_count_avail(void)
 
return count;
 }
+
+int
+rte_dma_info_get(int16_t dev_id, struct rte_dma_info *dev_info)
+{
+   const struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
+   int ret;
+
+   if (!rte_dma_is_valid(dev_id) || dev_info == NULL)
+   return -EINVAL;
+
+   RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_info_get, -ENOTSUP);
+   memset(dev_info, 0, sizeof(struct rte_dma_info));
+   ret = (*dev->dev_ops->dev_info_get)(dev, dev_info,
+   sizeof(struct rte_dma_info));
+   if (ret != 0)
+   return ret;
+
+   dev_info->numa_node = dev->device->numa_node;
+   dev_info->nb_vchans = dev->dev_conf.nb_vchans;
+
+   return 0;
+}
+
+int
+rte_dma_configure(int16_t dev_id, const struct rte_dma_conf *dev_conf)
+{
+   struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
+   struct rte_dma_info dev_info;
+   int ret;
+
+   if (!rte_dma_is_valid(dev_id) || dev_conf == NULL)
+   return -EINVAL;
+
+   if (dev->dev_started != 0) {
+   RTE_DMA_LOG(ERR,
+   "Device %d must be stopped to allow configuration",
+   dev_id);
+   return -EBUSY;
+   }
+
+   ret = rte_dma_info_get(dev_id, &dev_info);
+   if (ret != 0) {
+   RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
+   return -EINVAL;
+   }
+   if (dev_conf->nb_vchans == 0) {
+   RTE_DMA_LOG(ERR,
+   "Device %d configure zero vchans", dev_id);
+   return -EINVAL;
+   }
+   if (dev_conf->nb_vchans > dev_info.max_vchans) {
+   RTE_DMA_LOG(ERR,
+   "Device %d configure too many vchans", dev_id);
+   return -EINVAL;
+   }
+   if (dev_conf->enable_silent &&
+   !(dev_info.dev_capa & RTE_DMA_CAPA_SILENT)) {
+   RTE_DMA_LOG(ERR, "Device %d don't support silent", dev_id);
+   return -EINVAL;
+   }
+
+   RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
+   ret = (*dev->dev_ops->dev_configure)(dev, dev_conf,
+

[dpdk-dev] [PATCH v24 1/6] dmadev: introduce DMA device library

The 'dmadev' is a generic type of DMA device.

This patch introduce the 'dmadev' device allocation functions.

The infrastructure is prepared to welcome drivers in drivers/dma/

Signed-off-by: Chengwen Feng 
Acked-by: Bruce Richardson 
Acked-by: Morten Brørup 
Acked-by: Jerin Jacob 
Reviewed-by: Kevin Laatz 
Reviewed-by: Conor Walsh 
---
 MAINTAINERS|   5 +
 doc/api/doxy-api-index.md  |   1 +
 doc/api/doxy-api.conf.in   |   1 +
 doc/guides/dmadevs/index.rst   |  12 ++
 doc/guides/index.rst   |   1 +
 doc/guides/prog_guide/dmadev.rst   |  60 ++
 doc/guides/prog_guide/img/dmadev.svg   | 283 +
 doc/guides/prog_guide/index.rst|   1 +
 doc/guides/rel_notes/release_21_11.rst |   4 +
 drivers/dma/meson.build|   4 +
 drivers/meson.build|   1 +
 lib/dmadev/meson.build |   6 +
 lib/dmadev/rte_dmadev.c| 246 +
 lib/dmadev/rte_dmadev.h| 133 
 lib/dmadev/rte_dmadev_pmd.h|  90 
 lib/dmadev/version.map |  20 ++
 lib/meson.build|   1 +
 17 files changed, 869 insertions(+)
 create mode 100644 doc/guides/dmadevs/index.rst
 create mode 100644 doc/guides/prog_guide/dmadev.rst
 create mode 100644 doc/guides/prog_guide/img/dmadev.svg
 create mode 100644 drivers/dma/meson.build
 create mode 100644 lib/dmadev/meson.build
 create mode 100644 lib/dmadev/rte_dmadev.c
 create mode 100644 lib/dmadev/rte_dmadev.h
 create mode 100644 lib/dmadev/rte_dmadev_pmd.h
 create mode 100644 lib/dmadev/version.map

diff --git a/MAINTAINERS b/MAINTAINERS
index 278e5b3226..119cfaa04e 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -454,6 +454,11 @@ F: app/test-regex/
 F: doc/guides/prog_guide/regexdev.rst
 F: doc/guides/regexdevs/features/default.ini
 
+DMA device API - EXPERIMENTAL
+M: Chengwen Feng 
+F: lib/dmadev/
+F: doc/guides/prog_guide/dmadev.rst
+
 Eventdev API
 M: Jerin Jacob 
 T: git://dpdk.org/next/dpdk-next-eventdev
diff --git a/doc/api/doxy-api-index.md b/doc/api/doxy-api-index.md
index 1992107a03..2939050431 100644
--- a/doc/api/doxy-api-index.md
+++ b/doc/api/doxy-api-index.md
@@ -21,6 +21,7 @@ The public API headers are grouped by topics:
   [compressdev](@ref rte_compressdev.h),
   [compress]   (@ref rte_comp.h),
   [regexdev]   (@ref rte_regexdev.h),
+  [dmadev] (@ref rte_dmadev.h),
   [eventdev]   (@ref rte_eventdev.h),
   [event_eth_rx_adapter]   (@ref rte_event_eth_rx_adapter.h),
   [event_eth_tx_adapter]   (@ref rte_event_eth_tx_adapter.h),
diff --git a/doc/api/doxy-api.conf.in b/doc/api/doxy-api.conf.in
index 325a0195c6..109ec1f682 100644
--- a/doc/api/doxy-api.conf.in
+++ b/doc/api/doxy-api.conf.in
@@ -35,6 +35,7 @@ INPUT   = @TOPDIR@/doc/api/doxy-api-index.md \
   @TOPDIR@/lib/compressdev \
   @TOPDIR@/lib/cryptodev \
   @TOPDIR@/lib/distributor \
+  @TOPDIR@/lib/dmadev \
   @TOPDIR@/lib/efd \
   @TOPDIR@/lib/ethdev \
   @TOPDIR@/lib/eventdev \
diff --git a/doc/guides/dmadevs/index.rst b/doc/guides/dmadevs/index.rst
new file mode 100644
index 00..0bce29d766
--- /dev/null
+++ b/doc/guides/dmadevs/index.rst
@@ -0,0 +1,12 @@
+.. SPDX-License-Identifier: BSD-3-Clause
+   Copyright 2021 HiSilicon Limited
+
+DMA Device Drivers
+==
+
+The following are a list of DMA device drivers, which can be used from
+an application through DMA API.
+
+.. toctree::
+   :maxdepth: 2
+   :numbered:
diff --git a/doc/guides/index.rst b/doc/guides/index.rst
index 857f0363d3..919825992e 100644
--- a/doc/guides/index.rst
+++ b/doc/guides/index.rst
@@ -21,6 +21,7 @@ DPDK documentation
compressdevs/index
vdpadevs/index
regexdevs/index
+   dmadevs/index
eventdevs/index
rawdevs/index
mempool/index
diff --git a/doc/guides/prog_guide/dmadev.rst b/doc/guides/prog_guide/dmadev.rst
new file mode 100644
index 00..90bda28f33
--- /dev/null
+++ b/doc/guides/prog_guide/dmadev.rst
@@ -0,0 +1,60 @@
+.. SPDX-License-Identifier: BSD-3-Clause
+   Copyright 2021 HiSilicon Limited
+
+DMA Device Library
+==
+
+The DMA library provides a DMA device framework for management and provisioning
+of hardware and software DMA poll mode drivers, defining generic API which
+support a number of different DMA operations.
+
+
+Design Principles
+-
+
+The DMA framework provides a generic DMA device framework which supports both
+physical (hardware) and virtual (software) DMA devices, as well as a generic 
DMA
+API which allows DMA devices to be managed and configured, and supports DMA
+operations to be provisioned on DMA poll mode driver.
+
+.. _figure_dmadev:
+
+.. figure:: img/dmadev.*
+
+Th

[dpdk-dev] [PATCH v24 4/6] dmadev: add multi-process support

This patch add multi-process support for dmadev.

Signed-off-by: Chengwen Feng 
Acked-by: Bruce Richardson 
Acked-by: Morten Brørup 
Reviewed-by: Kevin Laatz 
Reviewed-by: Conor Walsh 
---
 doc/guides/rel_notes/release_21_11.rst |   1 +
 lib/dmadev/rte_dmadev.c| 176 -
 lib/dmadev/rte_dmadev_pmd.h|  29 +++-
 3 files changed, 163 insertions(+), 43 deletions(-)

diff --git a/doc/guides/rel_notes/release_21_11.rst 
b/doc/guides/rel_notes/release_21_11.rst
index d1d7abf694..af32fce1ed 100644
--- a/doc/guides/rel_notes/release_21_11.rst
+++ b/doc/guides/rel_notes/release_21_11.rst
@@ -145,6 +145,7 @@ New Features
 
   * Device allocation functions.
   * Control and data plane API.
+  * Multi-process support.
 
 
 Removed Items
diff --git a/lib/dmadev/rte_dmadev.c b/lib/dmadev/rte_dmadev.c
index 891ceeb988..2dba676b2b 100644
--- a/lib/dmadev/rte_dmadev.c
+++ b/lib/dmadev/rte_dmadev.c
@@ -19,6 +19,13 @@ static int16_t dma_devices_max;
 
 struct rte_dma_fp_object *rte_dma_fp_objs;
 struct rte_dma_dev *rte_dma_devices;
+static struct {
+   /* Hold the dev_max information of the primary process. This field is
+* set by the primary process and is read by the secondary process.
+*/
+   int16_t dev_max;
+   struct rte_dma_dev_data data[0];
+} *dma_devices_shared_data;
 
 RTE_LOG_REGISTER_DEFAULT(rte_dma_logtype, INFO);
 #define RTE_DMA_LOG(level, ...) \
@@ -70,11 +77,11 @@ dma_find_free_id(void)
 {
int16_t i;
 
-   if (rte_dma_devices == NULL)
+   if (rte_dma_devices == NULL || dma_devices_shared_data == NULL)
return -1;
 
for (i = 0; i < dma_devices_max; i++) {
-   if (rte_dma_devices[i].state == RTE_DMA_DEV_UNUSED)
+   if (dma_devices_shared_data->data[i].dev_name[0] == '\0')
return i;
}
 
@@ -91,7 +98,7 @@ dma_find_by_name(const char *name)
 
for (i = 0; i < dma_devices_max; i++) {
if ((rte_dma_devices[i].state != RTE_DMA_DEV_UNUSED) &&
-   (!strcmp(name, rte_dma_devices[i].dev_name)))
+   (!strcmp(name, rte_dma_devices[i].data->dev_name)))
return &rte_dma_devices[i];
}
 
@@ -147,23 +154,71 @@ dma_dev_data_prepare(void)
return 0;
 }
 
+static int
+dma_shared_data_prepare(void)
+{
+   const char *mz_name = "rte_dma_dev_data";
+   const struct rte_memzone *mz;
+   size_t size;
+
+   if (dma_devices_shared_data != NULL)
+   return 0;
+
+   size = sizeof(*dma_devices_shared_data) +
+   sizeof(struct rte_dma_dev_data) * dma_devices_max;
+
+   if (rte_eal_process_type() == RTE_PROC_PRIMARY)
+   mz = rte_memzone_reserve(mz_name, size, rte_socket_id(), 0);
+   else
+   mz = rte_memzone_lookup(mz_name);
+   if (mz == NULL)
+   return -ENOMEM;
+
+   dma_devices_shared_data = mz->addr;
+   if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
+   memset(dma_devices_shared_data, 0, size);
+   dma_devices_shared_data->dev_max = dma_devices_max;
+   } else {
+   dma_devices_max = dma_devices_shared_data->dev_max;
+   }
+
+   return 0;
+}
+
 static int
 dma_data_prepare(void)
 {
int ret;
 
-   if (dma_devices_max == 0)
-   dma_devices_max = RTE_DMADEV_DEFAULT_MAX;
-
-   ret = dma_fp_data_prepare();
-   if (ret)
-   return ret;
+   if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
+   if (dma_devices_max == 0)
+   dma_devices_max = RTE_DMADEV_DEFAULT_MAX;
+   ret = dma_fp_data_prepare();
+   if (ret)
+   return ret;
+   ret = dma_dev_data_prepare();
+   if (ret)
+   return ret;
+   ret = dma_shared_data_prepare();
+   if (ret)
+   return ret;
+   } else {
+   ret = dma_shared_data_prepare();
+   if (ret)
+   return ret;
+   ret = dma_fp_data_prepare();
+   if (ret)
+   return ret;
+   ret = dma_dev_data_prepare();
+   if (ret)
+   return ret;
+   }
 
-   return dma_dev_data_prepare();
+   return 0;
 }
 
 static struct rte_dma_dev *
-dma_allocate(const char *name, int numa_node, size_t private_data_size)
+dma_allocate_primary(const char *name, int numa_node, size_t private_data_size)
 {
struct rte_dma_dev *dev;
void *dev_private;
@@ -197,10 +252,54 @@ dma_allocate(const char *name, int numa_node, size_t 
private_data_size)
}
 
dev = &rte_dma_devices[dev_id];
-   rte_strscpy(dev->dev_name, name, sizeof(dev->dev_name));
-   dev->dev_id = dev_id;
-   dev->numa_node = numa_node;
-   dev->dev_private = dev_private;
+   dev->da

[dpdk-dev] [PATCH v24 3/6] dmadev: add data plane API support

This patch add data plane API for dmadev.

Signed-off-by: Chengwen Feng 
Acked-by: Bruce Richardson 
Acked-by: Morten Brørup 
Reviewed-by: Kevin Laatz 
Reviewed-by: Conor Walsh 
---
 doc/guides/prog_guide/dmadev.rst   |  22 ++
 doc/guides/rel_notes/release_21_11.rst |   2 +-
 lib/dmadev/meson.build |   1 +
 lib/dmadev/rte_dmadev.c| 134 
 lib/dmadev/rte_dmadev.h| 451 +
 lib/dmadev/rte_dmadev_core.h   |  78 +
 lib/dmadev/rte_dmadev_pmd.h|   7 +
 lib/dmadev/version.map |   6 +
 8 files changed, 700 insertions(+), 1 deletion(-)
 create mode 100644 lib/dmadev/rte_dmadev_core.h

diff --git a/doc/guides/prog_guide/dmadev.rst b/doc/guides/prog_guide/dmadev.rst
index 5c70ad3d6a..2e2a4bb62a 100644
--- a/doc/guides/prog_guide/dmadev.rst
+++ b/doc/guides/prog_guide/dmadev.rst
@@ -96,3 +96,25 @@ can be used to get the device info and supported features.
 
 Silent mode is a special device capability which does not require the
 application to invoke dequeue APIs.
+
+
+Enqueue / Dequeue APIs
+~~
+
+Enqueue APIs such as ``rte_dma_copy`` and ``rte_dma_fill`` can be used to
+enqueue operations to hardware. If an enqueue is successful, a ``ring_idx`` is
+returned. This ``ring_idx`` can be used by applications to track per operation
+metadata in an application-defined circular ring.
+
+The ``rte_dma_submit`` API is used to issue doorbell to hardware.
+Alternatively the ``RTE_DMA_OP_FLAG_SUBMIT`` flag can be passed to the enqueue
+APIs to also issue the doorbell to hardware.
+
+There are two dequeue APIs ``rte_dma_completed`` and
+``rte_dma_completed_status``, these are used to obtain the results of the
+enqueue requests. ``rte_dma_completed`` will return the number of successfully
+completed operations. ``rte_dma_completed_status`` will return the number of
+completed operations along with the status of each operation (filled into the
+``status`` array passed by user). These two APIs can also return the last
+completed operation's ``ring_idx`` which could help user track operations 
within
+their own application-defined rings.
diff --git a/doc/guides/rel_notes/release_21_11.rst 
b/doc/guides/rel_notes/release_21_11.rst
index f935a3f395..d1d7abf694 100644
--- a/doc/guides/rel_notes/release_21_11.rst
+++ b/doc/guides/rel_notes/release_21_11.rst
@@ -144,7 +144,7 @@ New Features
 * **Introduced dmadev library with:**
 
   * Device allocation functions.
-  * Control plane API.
+  * Control and data plane API.
 
 
 Removed Items
diff --git a/lib/dmadev/meson.build b/lib/dmadev/meson.build
index f8d54c6e74..d2fc85e8c7 100644
--- a/lib/dmadev/meson.build
+++ b/lib/dmadev/meson.build
@@ -3,4 +3,5 @@
 
 sources = files('rte_dmadev.c')
 headers = files('rte_dmadev.h')
+indirect_headers += files('rte_dmadev_core.h')
 driver_sdk_headers += files('rte_dmadev_pmd.h')
diff --git a/lib/dmadev/rte_dmadev.c b/lib/dmadev/rte_dmadev.c
index a6a5680d2b..891ceeb988 100644
--- a/lib/dmadev/rte_dmadev.c
+++ b/lib/dmadev/rte_dmadev.c
@@ -17,6 +17,7 @@
 
 static int16_t dma_devices_max;
 
+struct rte_dma_fp_object *rte_dma_fp_objs;
 struct rte_dma_dev *rte_dma_devices;
 
 RTE_LOG_REGISTER_DEFAULT(rte_dma_logtype, INFO);
@@ -97,6 +98,38 @@ dma_find_by_name(const char *name)
return NULL;
 }
 
+static void dma_fp_object_reset(int16_t dev_id);
+
+static int
+dma_fp_data_prepare(void)
+{
+   size_t size;
+   void *ptr;
+   int i;
+
+   if (rte_dma_fp_objs != NULL)
+   return 0;
+
+   /* Fast-path object must align cacheline, but the return value of malloc
+* may not be aligned to the cache line. Therefore, extra memory is
+* applied for realignment.
+* note: We do not call posix_memalign/aligned_alloc because it is
+* version dependent on libc.
+*/
+   size = dma_devices_max * sizeof(struct rte_dma_fp_object) +
+   RTE_CACHE_LINE_SIZE;
+   ptr = malloc(size);
+   if (ptr == NULL)
+   return -ENOMEM;
+   memset(ptr, 0, size);
+
+   rte_dma_fp_objs = RTE_PTR_ALIGN(ptr, RTE_CACHE_LINE_SIZE);
+   for (i = 0; i < dma_devices_max; i++)
+   dma_fp_object_reset(i);
+
+   return 0;
+}
+
 static int
 dma_dev_data_prepare(void)
 {
@@ -117,8 +150,15 @@ dma_dev_data_prepare(void)
 static int
 dma_data_prepare(void)
 {
+   int ret;
+
if (dma_devices_max == 0)
dma_devices_max = RTE_DMADEV_DEFAULT_MAX;
+
+   ret = dma_fp_data_prepare();
+   if (ret)
+   return ret;
+
return dma_dev_data_prepare();
 }
 
@@ -317,6 +357,8 @@ rte_dma_configure(int16_t dev_id, const struct rte_dma_conf 
*dev_conf)
return ret;
 }
 
+static void dma_fp_object_setup(int16_t dev_id,const struct 
rte_dma_dev *dev);
+
 int
 rte_dma_start(int16_t dev_id)
 {
@@ -344,6 +386,7 @@ rte_dma_start(int16_t dev_id)
return ret;
 
 mark_started

[dpdk-dev] [PATCH v24 5/6] dma/skeleton: introduce skeleton dmadev driver

Skeleton dmadevice driver, on the lines of rawdev skeleton, is for
showcasing of the dmadev library.

Design of skeleton involves a virtual device which is plugged into VDEV
bus on initialization.

Also, enable compilation of dmadev skeleton drivers.

Signed-off-by: Chengwen Feng 
Reviewed-by: Kevin Laatz 
Reviewed-by: Conor Walsh 
---
 MAINTAINERS|   1 +
 drivers/dma/meson.build|   4 +-
 drivers/dma/skeleton/meson.build   |   7 +
 drivers/dma/skeleton/skeleton_dmadev.c | 571 +
 drivers/dma/skeleton/skeleton_dmadev.h |  61 +++
 drivers/dma/skeleton/version.map   |   3 +
 6 files changed, 646 insertions(+), 1 deletion(-)
 create mode 100644 drivers/dma/skeleton/meson.build
 create mode 100644 drivers/dma/skeleton/skeleton_dmadev.c
 create mode 100644 drivers/dma/skeleton/skeleton_dmadev.h
 create mode 100644 drivers/dma/skeleton/version.map

diff --git a/MAINTAINERS b/MAINTAINERS
index 119cfaa04e..ec887ac49f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -457,6 +457,7 @@ F: doc/guides/regexdevs/features/default.ini
 DMA device API - EXPERIMENTAL
 M: Chengwen Feng 
 F: lib/dmadev/
+F: drivers/dma/skeleton/
 F: doc/guides/prog_guide/dmadev.rst
 
 Eventdev API
diff --git a/drivers/dma/meson.build b/drivers/dma/meson.build
index a24c56d8ff..d9c7ede32f 100644
--- a/drivers/dma/meson.build
+++ b/drivers/dma/meson.build
@@ -1,4 +1,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright 2021 HiSilicon Limited
 
-drivers = []
+drivers = [
+'skeleton',
+]
diff --git a/drivers/dma/skeleton/meson.build b/drivers/dma/skeleton/meson.build
new file mode 100644
index 00..8871b80956
--- /dev/null
+++ b/drivers/dma/skeleton/meson.build
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2021 HiSilicon Limited
+
+deps += ['dmadev', 'kvargs', 'ring', 'bus_vdev']
+sources = files(
+'skeleton_dmadev.c',
+)
diff --git a/drivers/dma/skeleton/skeleton_dmadev.c 
b/drivers/dma/skeleton/skeleton_dmadev.c
new file mode 100644
index 00..62b1eef2d5
--- /dev/null
+++ b/drivers/dma/skeleton/skeleton_dmadev.c
@@ -0,0 +1,571 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021 HiSilicon Limited
+ */
+
+#include 
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#include 
+
+#include "skeleton_dmadev.h"
+
+RTE_LOG_REGISTER_DEFAULT(skeldma_logtype, INFO);
+#define SKELDMA_LOG(level, fmt, args...) \
+   rte_log(RTE_LOG_ ## level, skeldma_logtype, "%s(): " fmt "\n", \
+   __func__, ##args)
+
+/* Count of instances, currently only 1 is supported. */
+static uint16_t skeldma_count;
+
+static int
+skeldma_info_get(const struct rte_dma_dev *dev, struct rte_dma_info *dev_info,
+uint32_t info_sz)
+{
+#define SKELDMA_MAX_DESC   8192
+#define SKELDMA_MIN_DESC   32
+
+   RTE_SET_USED(dev);
+   RTE_SET_USED(info_sz);
+
+   dev_info->dev_capa = RTE_DMA_CAPA_MEM_TO_MEM |
+RTE_DMA_CAPA_SVA |
+RTE_DMA_CAPA_OPS_COPY;
+   dev_info->max_vchans = 1;
+   dev_info->max_desc = SKELDMA_MAX_DESC;
+   dev_info->min_desc = SKELDMA_MIN_DESC;
+
+   return 0;
+}
+
+static int
+skeldma_configure(struct rte_dma_dev *dev, const struct rte_dma_conf *conf,
+ uint32_t conf_sz)
+{
+   RTE_SET_USED(dev);
+   RTE_SET_USED(conf);
+   RTE_SET_USED(conf_sz);
+   return 0;
+}
+
+static void *
+cpucopy_thread(void *param)
+{
+#define SLEEP_THRESHOLD1
+#define SLEEP_US_VAL   10
+
+   struct rte_dma_dev *dev = param;
+   struct skeldma_hw *hw = dev->data->dev_private;
+   struct skeldma_desc *desc = NULL;
+   int ret;
+
+   while (!hw->exit_flag) {
+   ret = rte_ring_dequeue(hw->desc_running, (void **)&desc);
+   if (ret) {
+   hw->zero_req_count++;
+   if (hw->zero_req_count == 0)
+   hw->zero_req_count = SLEEP_THRESHOLD;
+   if (hw->zero_req_count >= SLEEP_THRESHOLD)
+   rte_delay_us_sleep(SLEEP_US_VAL);
+   continue;
+   }
+
+   hw->zero_req_count = 0;
+   rte_memcpy(desc->dst, desc->src, desc->len);
+   hw->completed_count++;
+   (void)rte_ring_enqueue(hw->desc_completed, (void *)desc);
+   }
+
+   return NULL;
+}
+
+static void
+fflush_ring(struct skeldma_hw *hw, struct rte_ring *ring)
+{
+   struct skeldma_desc *desc = NULL;
+   while (rte_ring_count(ring) > 0) {
+   (void)rte_ring_dequeue(ring, (void **)&desc);
+   (void)rte_ring_enqueue(hw->desc_empty, (void *)desc);
+   }
+}
+
+static int
+skeldma_start(struct rte_dma_dev *dev)
+{
+   struct skeldma_hw *hw = dev->data->dev_private;
+   rte_cpuset_t cpuset;
+   int ret;
+
+

[dpdk-dev] [PATCH v24 6/6] app/test: add dmadev API test

This patch add dmadev API test which based on 'dma_skeleton' vdev. The
test cases could be executed using 'dmadev_autotest' command in test
framework.

Signed-off-by: Chengwen Feng 
Signed-off-by: Bruce Richardson 
Reviewed-by: Kevin Laatz 
Reviewed-by: Conor Walsh 
---
 MAINTAINERS|   1 +
 app/test/meson.build   |   4 +
 app/test/test_dmadev.c |  41 +++
 app/test/test_dmadev_api.c | 574 +
 app/test/test_dmadev_api.h |   5 +
 5 files changed, 625 insertions(+)
 create mode 100644 app/test/test_dmadev.c
 create mode 100644 app/test/test_dmadev_api.c
 create mode 100644 app/test/test_dmadev_api.h

diff --git a/MAINTAINERS b/MAINTAINERS
index ec887ac49f..d329873465 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -458,6 +458,7 @@ DMA device API - EXPERIMENTAL
 M: Chengwen Feng 
 F: lib/dmadev/
 F: drivers/dma/skeleton/
+F: app/test/test_dmadev*
 F: doc/guides/prog_guide/dmadev.rst
 
 Eventdev API
diff --git a/app/test/meson.build b/app/test/meson.build
index f144d8b8ed..a16374b7a1 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -44,6 +44,8 @@ test_sources = files(
 'test_debug.c',
 'test_distributor.c',
 'test_distributor_perf.c',
+'test_dmadev.c',
+'test_dmadev_api.c',
 'test_eal_flags.c',
 'test_eal_fs.c',
 'test_efd.c',
@@ -163,6 +165,7 @@ test_deps = [
 'cmdline',
 'cryptodev',
 'distributor',
+'dmadev',
 'efd',
 'ethdev',
 'eventdev',
@@ -334,6 +337,7 @@ driver_test_names = [
 'cryptodev_sw_mvsam_autotest',
 'cryptodev_sw_snow3g_autotest',
 'cryptodev_sw_zuc_autotest',
+'dmadev_autotest',
 'eventdev_selftest_octeontx',
 'eventdev_selftest_sw',
 'rawdev_autotest',
diff --git a/app/test/test_dmadev.c b/app/test/test_dmadev.c
new file mode 100644
index 00..45da6b76fe
--- /dev/null
+++ b/app/test/test_dmadev.c
@@ -0,0 +1,41 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021 HiSilicon Limited
+ * Copyright(c) 2021 Intel Corporation
+ */
+
+#include 
+#include 
+
+#include "test.h"
+#include "test_dmadev_api.h"
+
+static int
+test_apis(void)
+{
+   const char *pmd = "dma_skeleton";
+   int id;
+   int ret;
+
+   if (rte_vdev_init(pmd, NULL) < 0)
+   return TEST_SKIPPED;
+   id = rte_dma_get_dev_id_by_name(pmd);
+   if (id < 0)
+   return TEST_SKIPPED;
+   printf("\n### Test dmadev infrastructure using skeleton driver\n");
+   ret = test_dma_api(id);
+   rte_vdev_uninit(pmd);
+
+   return ret;
+}
+
+static int
+test_dma(void)
+{
+   /* basic sanity on dmadev infrastructure */
+   if (test_apis() < 0)
+   return -1;
+
+   return 0;
+}
+
+REGISTER_TEST_COMMAND(dmadev_autotest, test_dma);
diff --git a/app/test/test_dmadev_api.c b/app/test/test_dmadev_api.c
new file mode 100644
index 00..4a181af90a
--- /dev/null
+++ b/app/test/test_dmadev_api.c
@@ -0,0 +1,574 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021 HiSilicon Limited
+ */
+
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+extern int test_dma_api(uint16_t dev_id);
+
+#define DMA_TEST_API_RUN(test) \
+   testsuite_run_test(test, #test)
+
+#define TEST_MEMCPY_SIZE   1024
+#define TEST_WAIT_US_VAL   5
+
+#define TEST_SUCCESS 0
+#define TEST_FAILED  -1
+
+static int16_t test_dev_id;
+static int16_t invalid_dev_id;
+
+static char *src;
+static char *dst;
+
+static int total;
+static int passed;
+static int failed;
+
+static int
+testsuite_setup(int16_t dev_id)
+{
+   test_dev_id = dev_id;
+   invalid_dev_id = -1;
+
+   src = rte_malloc("dmadev_test_src", TEST_MEMCPY_SIZE, 0);
+   if (src == NULL)
+   return -ENOMEM;
+   dst = rte_malloc("dmadev_test_dst", TEST_MEMCPY_SIZE, 0);
+   if (dst == NULL) {
+   rte_free(src);
+   src = NULL;
+   return -ENOMEM;
+   }
+
+   total = 0;
+   passed = 0;
+   failed = 0;
+
+   /* Set dmadev log level to critical to suppress unnecessary output
+* during API tests.
+*/
+   rte_log_set_level_pattern("lib.dmadev", RTE_LOG_CRIT);
+
+   return 0;
+}
+
+static void
+testsuite_teardown(void)
+{
+   rte_free(src);
+   src = NULL;
+   rte_free(dst);
+   dst = NULL;
+   /* Ensure the dmadev is stopped. */
+   rte_dma_stop(test_dev_id);
+
+   rte_log_set_level_pattern("lib.dmadev", RTE_LOG_INFO);
+}
+
+static void
+testsuite_run_test(int (*test)(void), const char *name)
+{
+   int ret = 0;
+
+   if (test) {
+   ret = test();
+   if (ret < 0) {
+   failed++;
+   printf("%s Failed\n", name);
+   } else {
+   passed++;
+   printf("%s Passed\n", name);
+   }
+

Re: [dpdk-dev] [PATCH v2] net/iavf: fix multi-process shared data

2021-10-09 Thread Zhang, Qi Z




> -Original Message-
> From: Yu, DapengX 
> Sent: Saturday, October 9, 2021 11:25 AM
> To: Wu, Jingjing ; Xing, Beilei 
> ;
> Richardson, Bruce ; Ananyev, Konstantin
> 
> Cc: dev@dpdk.org; Zhang, Qi Z ; Yigit, Ferruh
> ; Yu, DapengX ;
> sta...@dpdk.org
> Subject: [PATCH v2] net/iavf: fix multi-process shared data
> 
.

> 
>  int
> -iavf_request_queues(struct iavf_adapter *adapter, uint16_t num)
> +iavf_request_queues(struct rte_eth_dev *dev, struct iavf_adapter *adapter,
> + uint16_t num)

No need adapter as parameter here.

Below help to covert from eth_dev to iavf_adapter
struct iavf_adapter *adapter =
IAVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);

>  {
> - struct rte_eth_dev *dev = adapter->eth_dev;
>   struct iavf_info *vf =  IAVF_DEV_PRIVATE_TO_VF(adapter);
>   struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
>   struct virtchnl_vf_res_request vfres;
> --
> 2.27.0

Re: [dpdk-dev] [PATCH] ethdev: fix one MAC address occupies two index in mac addrs

2021-10-09 Thread Min Hu (Connor)


Hi, Thomas,

The dev->data->mac_addrs[0] will be changed to a new MAC address when 
applications modify
the default MAC address by rte_eth_dev_default_mac_addr_set() API. 
However, If the new default
MAC address has been added as a non-default MAC address by 
rte_eth_dev_mac_addr_add() API, the
rte_eth_dev_default_mac_addr_set() API doesn't remove it from 
dev->data->mac_addrs[].
As a result, one MAC address occupies two index capacities in 
dev->data->mac_addrs[].

This patch adds the logic of removing MAC addresses for this scenario.

Is that will be more clear? Hope for your reply

在 2021/10/8 18:04, Thomas Monjalon 写道:

08/10/2021 09:02, Min Hu (Connor):

Hi, Thomas,

在 2021/10/6 3:21, Thomas Monjalon 写道:

22/09/2021 05:36, Min Hu (Connor):

From: Huisong Li 

Use the testpmd to perform the following operations:
1) mac_addr add 0 00:18:2D:00:00:90
2) mac_addr add 0 00:18:2D:00:00:91
3) mac_addr add 0 00:18:2D:00:00:92
4) mac_addr set 0 00:18:2D:00:00:91
5) show port 0 macs
Number of MAC address added: 4
00:18:2D:00:00:91
00:18:2D:00:00:90
00:18:2D:00:00:91
00:18:2D:00:00:92


Please describe with words.
Reading similar MAC addresses is not a fun game.


I do not catch you, could you please be
more detailed, thanks.


Me too, I don't catch you.
Please explain the problem in the commit log
so we can understand without the example.


This is due to the reason that if the address has been added as a
non-default MAC address by rte_eth_dev_mac_addr_add API, it doesn't remove
from dev->data->mac_addrs[] when set default MAC address with the same
address.

Fixes: 854d8ad4ef68 ("ethdev: add default mac address modifier")
Cc: sta...@dpdk.org

Signed-off-by: Huisong Li 
Signed-off-by: Min Hu (Connor) 




.

Re: [dpdk-dev] [PATCH v24 3/6] dmadev: add data plane API support

2021-10-09 Thread fengchengwen

This patch follows the idea of Konstantin, and introduces rte_dma_fp_object to 
hide
implementation detail.
This change modify the first parameter of drivers's dataplane interface: from
'struct rte_dma_dev *dev' to 'void *dev_private'.

On 2021/10/9 17:33, Chengwen Feng wrote:
> This patch add data plane API for dmadev.
> 
> Signed-off-by: Chengwen Feng 
> Acked-by: Bruce Richardson 
> Acked-by: Morten Brørup 
> Reviewed-by: Kevin Laatz 
> Reviewed-by: Conor Walsh 
> ---
>  doc/guides/prog_guide/dmadev.rst   |  22 ++
>  doc/guides/rel_notes/release_21_11.rst |   2 +-
>  lib/dmadev/meson.build |   1 +
>  lib/dmadev/rte_dmadev.c| 134 
>  lib/dmadev/rte_dmadev.h| 451 +
>  lib/dmadev/rte_dmadev_core.h   |  78 +
>  lib/dmadev/rte_dmadev_pmd.h|   7 +
>  lib/dmadev/version.map |   6 +
>  8 files changed, 700 insertions(+), 1 deletion(-)
>  create mode 100644 lib/dmadev/rte_dmadev_core.h
> 

[snip]

Re: [dpdk-dev] [PATCH v5 2/6] ethdev: move jumbo frame offload check to library

2021-10-09 Thread lihuisong (C)




在 2021/10/8 0:56, Ferruh Yigit 写道:

Setting MTU bigger than RTE_ETHER_MTU requires the jumbo frame support,
and application should enable the jumbo frame offload support for it.

When jumbo frame offload is not enabled by application, but MTU bigger
than RTE_ETHER_MTU is requested there are two options, either fail or
enable jumbo frame offload implicitly.

Enabling jumbo frame offload implicitly is selected by many drivers
since setting a big MTU value already implies it, and this increases
usability.

This patch moves this logic from drivers to the library, both to reduce
the duplicated code in the drivers and to make behaviour more visible.

Signed-off-by: Ferruh Yigit 
Reviewed-by: Andrew Rybchenko 
Reviewed-by: Rosen Xu 
Acked-by: Ajit Khaparde 
Acked-by: Somnath Kotur 
---
  drivers/net/axgbe/axgbe_ethdev.c|  9 ++---
  drivers/net/bnxt/bnxt_ethdev.c  |  9 ++---
  drivers/net/cnxk/cnxk_ethdev_ops.c  |  5 -
  drivers/net/cxgbe/cxgbe_ethdev.c|  8 
  drivers/net/dpaa/dpaa_ethdev.c  |  7 ---
  drivers/net/dpaa2/dpaa2_ethdev.c|  7 ---
  drivers/net/e1000/em_ethdev.c   |  9 ++---
  drivers/net/e1000/igb_ethdev.c  |  9 ++---
  drivers/net/enetc/enetc_ethdev.c|  7 ---
  drivers/net/hinic/hinic_pmd_ethdev.c|  7 ---
  drivers/net/hns3/hns3_ethdev.c  |  8 
  drivers/net/hns3/hns3_ethdev_vf.c   |  6 --
  drivers/net/i40e/i40e_ethdev.c  |  5 -
  drivers/net/iavf/iavf_ethdev.c  |  7 ---
  drivers/net/ice/ice_ethdev.c|  5 -
  drivers/net/igc/igc_ethdev.c|  9 ++---
  drivers/net/ipn3ke/ipn3ke_representor.c |  5 -
  drivers/net/ixgbe/ixgbe_ethdev.c|  7 ++-
  drivers/net/liquidio/lio_ethdev.c   |  7 ---
  drivers/net/nfp/nfp_common.c|  6 --
  drivers/net/octeontx/octeontx_ethdev.c  |  5 -
  drivers/net/octeontx2/otx2_ethdev_ops.c |  5 -
  drivers/net/qede/qede_ethdev.c  |  4 
  drivers/net/sfc/sfc_ethdev.c|  9 -
  drivers/net/thunderx/nicvf_ethdev.c |  6 --
  drivers/net/txgbe/txgbe_ethdev.c|  6 --
  lib/ethdev/rte_ethdev.c | 18 +-
  27 files changed, 29 insertions(+), 166 deletions(-)

diff --git a/drivers/net/axgbe/axgbe_ethdev.c b/drivers/net/axgbe/axgbe_ethdev.c
index 76aeec077f2b..2960834b4539 100644
--- a/drivers/net/axgbe/axgbe_ethdev.c
+++ b/drivers/net/axgbe/axgbe_ethdev.c
@@ -1492,15 +1492,10 @@ static int axgb_mtu_set(struct rte_eth_dev *dev, 
uint16_t mtu)
dev->data->port_id);
return -EBUSY;
}
-   if (mtu > RTE_ETHER_MTU) {
-   dev->data->dev_conf.rxmode.offloads |=
-   DEV_RX_OFFLOAD_JUMBO_FRAME;
+   if (mtu > RTE_ETHER_MTU)
val = 1;
-   } else {
-   dev->data->dev_conf.rxmode.offloads &=
-   ~DEV_RX_OFFLOAD_JUMBO_FRAME;
+   else
val = 0;
-   }
AXGMAC_IOWRITE_BITS(pdata, MAC_RCR, JE, val);
return 0;
  }
diff --git a/drivers/net/bnxt/bnxt_ethdev.c b/drivers/net/bnxt/bnxt_ethdev.c
index 8c6f20b75aed..07ee19938930 100644
--- a/drivers/net/bnxt/bnxt_ethdev.c
+++ b/drivers/net/bnxt/bnxt_ethdev.c
@@ -3052,15 +3052,10 @@ int bnxt_mtu_set_op(struct rte_eth_dev *eth_dev, 
uint16_t new_mtu)
return -EINVAL;
}
  
-	if (new_mtu > RTE_ETHER_MTU) {

+   if (new_mtu > RTE_ETHER_MTU)
bp->flags |= BNXT_FLAG_JUMBO;
-   bp->eth_dev->data->dev_conf.rxmode.offloads |=
-   DEV_RX_OFFLOAD_JUMBO_FRAME;
-   } else {
-   bp->eth_dev->data->dev_conf.rxmode.offloads &=
-   ~DEV_RX_OFFLOAD_JUMBO_FRAME;
+   else
bp->flags &= ~BNXT_FLAG_JUMBO;
-   }
  
  	/* Is there a change in mtu setting? */

if (eth_dev->data->mtu == new_mtu)
diff --git a/drivers/net/cnxk/cnxk_ethdev_ops.c 
b/drivers/net/cnxk/cnxk_ethdev_ops.c
index 695d0d6fd3e2..349896f6a1bf 100644
--- a/drivers/net/cnxk/cnxk_ethdev_ops.c
+++ b/drivers/net/cnxk/cnxk_ethdev_ops.c
@@ -439,11 +439,6 @@ cnxk_nix_mtu_set(struct rte_eth_dev *eth_dev, uint16_t mtu)
plt_err("Failed to max Rx frame length, rc=%d", rc);
goto exit;
}
-
-   if (mtu > RTE_ETHER_MTU)
-   dev->rx_offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME;
-   else
-   dev->rx_offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME;
  exit:
return rc;
  }
diff --git a/drivers/net/cxgbe/cxgbe_ethdev.c b/drivers/net/cxgbe/cxgbe_ethdev.c
index 8cf61f12a8d6..0c9cc2f5bb3f 100644
--- a/drivers/net/cxgbe/cxgbe_ethdev.c
+++ b/drivers/net/cxgbe/cxgbe_ethdev.c
@@ -313,14 +313,6 @@ int cxgbe_dev_mtu_set(struct rte_eth_dev *eth_dev, 
uint16_t mtu)
if (mtu < RTE_ETHER_MIN_MTU || new_mtu > dev_info.max_rx_pktlen)

Re: [dpdk-dev] [PATCH v5 4/6] ethdev: remove jumbo offload flag

2021-10-09 Thread lihuisong (C)




在 2021/10/9 1:11, Ananyev, Konstantin 写道:



Removing 'DEV_RX_OFFLOAD_JUMBO_FRAME' offload flag.

Instead of drivers announce this capability, application can deduct the
capability by checking reported 'dev_info.max_mtu' or
'dev_info.max_rx_pktlen'.

And instead of application setting this flag explicitly to enable jumbo
frames, this can be deduced by driver by comparing requested 'mtu' to
'RTE_ETHER_MTU'.

Removing this additional configuration for simplification.

Suggested-by: Konstantin Ananyev 
Signed-off-by: Ferruh Yigit 
Acked-by: Andrew Rybchenko 
Reviewed-by: Rosen Xu 
Acked-by: Somnath Kotur 
---

Acked-by: Konstantin Ananyev 


+1

Acked-by: Huisong Li 




2.31.1

.

Re: [dpdk-dev] [PATCH v5 5/6] ethdev: unify MTU checks

2021-10-09 Thread lihuisong (C)


Hi, Ferruh

在 2021/10/8 0:56, Ferruh Yigit 写道:

Both 'rte_eth_dev_configure()' & 'rte_eth_dev_set_mtu()' sets MTU but
have slightly different checks. Like one checks min MTU against
RTE_ETHER_MIN_MTU and other RTE_ETHER_MIN_LEN.

Checks moved into common function to unify the checks. Also this has
benefit to have common error logs.

Suggested-by: Huisong Li 
Signed-off-by: Ferruh Yigit 
---
  lib/ethdev/rte_ethdev.c | 82 ++---
  lib/ethdev/rte_ethdev.h |  2 +-
  2 files changed, 54 insertions(+), 30 deletions(-)

diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c
index c2b624aba1a0..0a6e952722ae 100644
--- a/lib/ethdev/rte_ethdev.c
+++ b/lib/ethdev/rte_ethdev.c
@@ -1336,6 +1336,47 @@ eth_dev_get_overhead_len(uint32_t max_rx_pktlen, 
uint16_t max_mtu)
return overhead_len;
  }
  
+/* rte_eth_dev_info_get() should be called prior to this function */

+static int
+eth_dev_validate_mtu(uint16_t port_id, struct rte_eth_dev_info *dev_info,
+   uint16_t mtu)
+{
+   uint16_t overhead_len;
+   uint32_t frame_size;
+
+   if (mtu < dev_info->min_mtu) {
+   RTE_ETHDEV_LOG(ERR,
+   "MTU (%u) < device min MTU (%u) for port_id %u\n",
+   mtu, dev_info->min_mtu, port_id);
+   return -EINVAL;
+   }
+   if (mtu > dev_info->max_mtu) {
+   RTE_ETHDEV_LOG(ERR,
+   "MTU (%u) > device max MTU (%u) for port_id %u\n",
+   mtu, dev_info->max_mtu, port_id);
+   return -EINVAL;
+   }
+
+   overhead_len = eth_dev_get_overhead_len(dev_info->max_rx_pktlen,
+   dev_info->max_mtu);
+   frame_size = mtu + overhead_len;
+   if (frame_size < RTE_ETHER_MIN_LEN) {
+   RTE_ETHDEV_LOG(ERR,
+   "Frame size (%u) < min frame size (%u) for port_id 
%u\n",
+   frame_size, RTE_ETHER_MIN_LEN, port_id);
+   return -EINVAL;
+   }
+
+   if (frame_size > dev_info->max_rx_pktlen) {
+   RTE_ETHDEV_LOG(ERR,
+   "Frame size (%u) > device max frame size (%u) for port_id 
%u\n",
+   frame_size, dev_info->max_rx_pktlen, port_id);
+   return -EINVAL;
+   }


This function is used to verify the MTU. So "frame_size" is redundant.

As modified by this patch, dev_info->min_mtu is calculated based on 
RTE_ETHER_MIN_LEN.



+
+   return 0;
+}
+
  int
  rte_eth_dev_configure(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
  const struct rte_eth_conf *dev_conf)
@@ -1463,26 +1504,13 @@ rte_eth_dev_configure(uint16_t port_id, uint16_t 
nb_rx_q, uint16_t nb_tx_q,
goto rollback;
}
  
-	/*

-* Check that the maximum RX packet length is supported by the
-* configured device.
-*/
if (dev_conf->rxmode.mtu == 0)
dev->data->dev_conf.rxmode.mtu = RTE_ETHER_MTU;
-   max_rx_pktlen = dev->data->dev_conf.rxmode.mtu + overhead_len;
-   if (max_rx_pktlen > dev_info.max_rx_pktlen) {
-   RTE_ETHDEV_LOG(ERR,
-   "Ethdev port_id=%u max_rx_pktlen %u > max valid value 
%u\n",
-   port_id, max_rx_pktlen, dev_info.max_rx_pktlen);
-   ret = -EINVAL;
-   goto rollback;
-   } else if (max_rx_pktlen < RTE_ETHER_MIN_LEN) {
-   RTE_ETHDEV_LOG(ERR,
-   "Ethdev port_id=%u max_rx_pktlen %u < min valid value 
%u\n",
-   port_id, max_rx_pktlen, RTE_ETHER_MIN_LEN);
-   ret = -EINVAL;
+
+   ret = eth_dev_validate_mtu(port_id, &dev_info,
+   dev->data->dev_conf.rxmode.mtu);
+   if (ret != 0)
goto rollback;
-   }
  
  	dev->data->mtu = dev->data->dev_conf.rxmode.mtu;
  
@@ -1491,6 +1519,9 @@ rte_eth_dev_configure(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,

 * size is supported by the configured device.
 */
if (dev_conf->rxmode.offloads & DEV_RX_OFFLOAD_TCP_LRO) {
+   overhead_len = eth_dev_get_overhead_len(dev_info.max_rx_pktlen,
+   dev_info.max_mtu);
+   max_rx_pktlen = dev->data->dev_conf.rxmode.mtu + overhead_len;
if (dev_conf->rxmode.max_lro_pkt_size == 0)
dev->data->dev_conf.rxmode.max_lro_pkt_size = 
max_rx_pktlen;
ret = eth_dev_check_lro_pkt_size(port_id,
@@ -3437,7 +3468,8 @@ rte_eth_dev_info_get(uint16_t port_id, struct 
rte_eth_dev_info *dev_info)
dev_info->rx_desc_lim = lim;
dev_info->tx_desc_lim = lim;
dev_info->device = dev->device;
-   dev_info->min_mtu = RTE_ETHER_MIN_MTU;
+   dev_info->min_mtu = RTE_ETHER_MIN_LEN - RTE_ETHER_HDR_LEN -
+   RTE_ETHER_CRC_LEN;
I suggest that the adjustment to the minimum mtu size is also explicitly

Re: [dpdk-dev] [PATCH v5 4/7] ethdev: copy fast-path API into separate structure

2021-10-09 Thread fengchengwen

On 2021/10/7 19:27, Konstantin Ananyev wrote:
> Copy public function pointers (rx_pkt_burst(), etc.) and related
> pointers to internal data from rte_eth_dev structure into a
> separate flat array. That array will remain in a public header.
> The intention here is to make rte_eth_dev and related structures internal.
> That should allow future possible changes to core eth_dev structures
> to be transparent to the user and help to avoid ABI/API breakages.
> The plan is to keep minimal part of data from rte_eth_dev public,
> so we still can use inline functions for fast-path calls
> (like rte_eth_rx_burst(), etc.) to avoid/minimize slowdown.
> The whole idea beyond this new schema:
> 1. PMDs keep to setup fast-path function pointers and related data
>inside rte_eth_dev struct in the same way they did it before.
> 2. Inside rte_eth_dev_start() and inside rte_eth_dev_probing_finish()
>(for secondary process) we call eth_dev_fp_ops_setup, which
>copies these function and data pointers into rte_eth_fp_ops[port_id].
> 3. Inside rte_eth_dev_stop() and inside rte_eth_dev_release_port()
>we call eth_dev_fp_ops_reset(), which resets rte_eth_fp_ops[port_id]
>into some dummy values.
> 4. fast-path ethdev API (rte_eth_rx_burst(), etc.) will use that new
>flat array to call PMD specific functions.
> That approach should allow us to make rte_eth_devices[] private
> without introducing regression and help to avoid changes in drivers code.
> 
> Signed-off-by: Konstantin Ananyev 
> ---
>  lib/ethdev/ethdev_private.c  | 52 ++
>  lib/ethdev/ethdev_private.h  |  7 +
>  lib/ethdev/rte_ethdev.c  | 27 ++
>  lib/ethdev/rte_ethdev_core.h | 55 
>  4 files changed, 141 insertions(+)
> 
> diff --git a/lib/ethdev/ethdev_private.c b/lib/ethdev/ethdev_private.c
> index 012cf73ca2..3eeda6e9f9 100644
> --- a/lib/ethdev/ethdev_private.c
> +++ b/lib/ethdev/ethdev_private.c
> @@ -174,3 +174,55 @@ rte_eth_devargs_parse_representor_ports(char *str, void 
> *data)
>   RTE_LOG(ERR, EAL, "wrong representor format: %s\n", str);
>   return str == NULL ? -1 : 0;
>  }
> +
> +static uint16_t
> +dummy_eth_rx_burst(__rte_unused void *rxq,
> + __rte_unused struct rte_mbuf **rx_pkts,
> + __rte_unused uint16_t nb_pkts)
> +{
> + RTE_ETHDEV_LOG(ERR, "rx_pkt_burst for unconfigured port\n");
> + rte_errno = ENOTSUP;
> + return 0;
> +}
> +
> +static uint16_t
> +dummy_eth_tx_burst(__rte_unused void *txq,
> + __rte_unused struct rte_mbuf **tx_pkts,
> + __rte_unused uint16_t nb_pkts)
> +{
> + RTE_ETHDEV_LOG(ERR, "tx_pkt_burst for unconfigured port\n");
> + rte_errno = ENOTSUP;
> + return 0;
> +}
> +
> +void
> +eth_dev_fp_ops_reset(struct rte_eth_fp_ops *fpo)

The port_id parameter is preferable, this will hide rte_eth_fp_ops as much as 
possible.

> +{
> + static void *dummy_data[RTE_MAX_QUEUES_PER_PORT];
> + static const struct rte_eth_fp_ops dummy_ops = {
> + .rx_pkt_burst = dummy_eth_rx_burst,
> + .tx_pkt_burst = dummy_eth_tx_burst,
> + .rxq = {.data = dummy_data, .clbk = dummy_data,},
> + .txq = {.data = dummy_data, .clbk = dummy_data,},
> + };
> +
> + *fpo = dummy_ops;
> +}
> +
> +void
> +eth_dev_fp_ops_setup(struct rte_eth_fp_ops *fpo,
> + const struct rte_eth_dev *dev)

Because fp_ops and eth_dev is a one-to-one correspondence. It's better only use
port_id parameter.

> +{
> + fpo->rx_pkt_burst = dev->rx_pkt_burst;
> + fpo->tx_pkt_burst = dev->tx_pkt_burst;
> + fpo->tx_pkt_prepare = dev->tx_pkt_prepare;
> + fpo->rx_queue_count = dev->rx_queue_count;
> + fpo->rx_descriptor_status = dev->rx_descriptor_status;
> + fpo->tx_descriptor_status = dev->tx_descriptor_status;
> +
> + fpo->rxq.data = dev->data->rx_queues;
> + fpo->rxq.clbk = (void **)(uintptr_t)dev->post_rx_burst_cbs;
> +
> + fpo->txq.data = dev->data->tx_queues;
> + fpo->txq.clbk = (void **)(uintptr_t)dev->pre_tx_burst_cbs;
> +}
> diff --git a/lib/ethdev/ethdev_private.h b/lib/ethdev/ethdev_private.h
> index 3724429577..5721be7bdc 100644
> --- a/lib/ethdev/ethdev_private.h
> +++ b/lib/ethdev/ethdev_private.h
> @@ -26,4 +26,11 @@ eth_find_device(const struct rte_eth_dev *_start, 
> rte_eth_cmp_t cmp,
>  /* Parse devargs value for representor parameter. */
>  int rte_eth_devargs_parse_representor_ports(char *str, void *data);
>  
> +/* reset eth fast-path API to dummy values */
> +void eth_dev_fp_ops_reset(struct rte_eth_fp_ops *fpo);
> +
> +/* setup eth fast-path API to ethdev values */
> +void eth_dev_fp_ops_setup(struct rte_eth_fp_ops *fpo,
> + const struct rte_eth_dev *dev);

Some drivers control the transmit/receive function during operation. E.g.
for hns3 driver, when detect reset, primary process will set rx/tx burst to 
dummy, after
process reset, primary process will set

[dpdk-dev] [PATCH v3] net/e1000: build on Windows

2021-10-09 Thread William Tu

This patch enables building the e1000 driver for Windows.
I tested using two Windows VM on top of VMware Fusion,
creating two e1000 devices with device ID 0x10D3 (8274L),
verifying rx/tx works correctly using dpdk-testpmd.exe
rxonly and txonly mode.

Signed-off-by: William Tu 
Acked-by: Haiyue Wang 
Acked-by: Pallavi Kadam 
Tested-by: Dmitry Kozlyuk 
Tested-by: Pallavi Kadam 
---
v3:
* Add acked and tested by tags
* @Dmitry: I think it's better keep the doc for
  people to reference NetUIO setup.
* I will send corresponding netuio device id patch
  to dpdk-kmods

A short demo:
https://youtu.be/UZ9hm2jQa2Y
Example when running:
PS C:\dpdk> .\build\app\dpdk-testpmd.exe
EAL: Detected CPU lcores: 4
EAL: Detected NUMA nodes: 1
EAL: Multi-process support is requested, but not available.
EAL: WARNING: TSC frequency estimated roughly - clock timings may be less 
accurate.
EAL: Probe PCI driver: net_e1000_em (8086:10d3) device: :03:00.0 (socket 0)
EAL: Requested device :1b:00.0 cannot be used
testpmd: create a new mbuf pool : n=171456, size=2176, socket=0
testpmd: preferred mempool ops selected: ring_mp_mc

Warning! port-topology=paired and odd forward ports number, the last port will p
air with itself.
Configuring Port 0 (socket 0)
Port 0: 00:50:56:3A:4D:A6
Checking link statuses...
Done
No commandline core given, start packet forwarding
allocation mode: native
Logical Core 1 (socket 0) forwards packets on 1 streams:
  RX P=0/Q=0 (socket 0) -> TX P=0/Q=0 (socket 0) peer=02:00:00:00:00:00

  io packet forwarding packets/burst=32
  nb forwarding cores=1 - nb forwarding ports=1
  port 0: RX queue number: 1 Tx queue number: 1
Rx offloads=0x0 Tx offloads=0x0
RX queue: 0
  RX desc=256 - RX free threshold=0
  TX desc=256 - TX free threshold=32
  TX offloads=0x0 - TX RS bit threshold=32
Press enter to exit

Telling cores to stop...
Waiting for lcores to finish...

  -- Forward statistics for port 0  --
  RX-packets: 40361  RX-dropped: 0 RX-total: 40361
  TX-packets: 40616  TX-dropped: 0 TX-total: 40616
  

  +++ Accumulated forward statistics for all ports+++
  RX-packets: 40361  RX-dropped: 0 RX-total: 40361
  TX-packets: 40616  TX-dropped: 0 TX-total: 40616
  

--
---
 doc/guides/nics/e1000em.rst| 13 +
 doc/guides/nics/features/e1000.ini |  1 +
 doc/guides/rel_notes/release_21_11.rst |  4 
 drivers/net/e1000/base/e1000_osdep.h   |  2 ++
 drivers/net/e1000/e1000_ethdev.h   |  1 +
 drivers/net/e1000/meson.build  |  6 --
 6 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/doc/guides/nics/e1000em.rst b/doc/guides/nics/e1000em.rst
index 041c9a09a3a5..03ae23838bfa 100644
--- a/doc/guides/nics/e1000em.rst
+++ b/doc/guides/nics/e1000em.rst
@@ -1,6 +1,8 @@
 ..  SPDX-License-Identifier: BSD-3-Clause
 Copyright(c) 2010-2014 Intel Corporation.
 
+.. include:: 
+
 Driver for VM Emulated Devices
 ==
 
@@ -153,3 +155,14 @@ The following are known limitations:
 #.  Qemu e1000 only supports one interrupt source, so link and Rx interrupt 
should be exclusive.
 
 #.  Qemu e1000 does not support interrupt auto-clear, application should 
disable interrupt immediately when woken up.
+
+Windows Configuration
+-
+
+- Follow the :doc:`guide for Windows <../windows_gsg/run_apps>`
+  to setup the basic DPDK environment.
+
+- Identify the Intel\ |reg| Ethernet adapter.
+
+- To load NetUIO driver, follow the steps mentioned in `dpdk-kmods repository
+  `_.
diff --git a/doc/guides/nics/features/e1000.ini 
b/doc/guides/nics/features/e1000.ini
index 5af6040e375b..b33f5a86e2e9 100644
--- a/doc/guides/nics/features/e1000.ini
+++ b/doc/guides/nics/features/e1000.ini
@@ -27,6 +27,7 @@ Tx descriptor status = Y
 Basic stats  = Y
 FreeBSD  = Y
 Linux= Y
+Windows  = Y
 x86-32   = Y
 x86-64   = Y
 
diff --git a/doc/guides/rel_notes/release_21_11.rst 
b/doc/guides/rel_notes/release_21_11.rst
index efeffe37a0e2..e4a092e562e3 100644
--- a/doc/guides/rel_notes/release_21_11.rst
+++ b/doc/guides/rel_notes/release_21_11.rst
@@ -73,6 +73,10 @@ New Features
   * Implement support for tunnel offload.
   * Updated HWRM API to version 1.10.2.44
 
+* **Updated Intel e1000 emulated driver.**
+
+  * Added Intel e1000 support on Windows.
+
 * **Updated Intel iavf driver.**
 
   * Added Intel iavf support on Windows.
diff --git a/drivers/net/e1000/base/e1000_osdep.h 
b/drivers/net/e1000/base/e1000_osdep.h
index 94a49f340446..cd90228cef59 100644
--- a/drivers/net/e1000/base/e1000_osdep.h
+++ b/drivers/net/e1000/base/e1000_osdep.h

Re: [dpdk-dev] [PATCH v2] net/e1000: build on Windows

2021-10-09 Thread William Tu

> > +Windows Configuration
> > +-
> > +
> > +- Follow the :doc:`guide for Windows <../windows_gsg/run_apps>`
> > +  to setup the basic DPDK environment.
> > +
> > +- Identify the Intel\ |reg| Ethernet adapter.
> > +
> > +- To load NetUIO driver, follow the steps mentioned in `dpdk-kmods 
> > repository
> > +  `_.
>
> There is nothing special about setting up this device on Windows.
> I think we don't need this part.

Hi Dmitry,

I keep this part in my v3 patch.
However, I think we should move or copy the netuio configuration
guide to DPDK repo
https://doc.dpdk.org/guides/windows_gsg/run_apps.html
maybe
4.2: Load the virt2phys driver
4.3: Load the NetUIO driver
4.4: Run helloworld example

Thanks
William

Re: [dpdk-dev] [PATCH v3] net/e1000: build on Windows

2021-10-09 Thread Dmitry Kozlyuk

2021-10-09 09:31 (UTC-0700), William Tu:
> [...]
> * @Dmitry: I think it's better keep the doc for
>   people to reference NetUIO setup.

I won't insist, especially since Intel is OK with this.
I've sent a patch to put the link in Windows GSG
so that we won't need to repeat it for each PMD:
http://inbox.dpdk.org/dev/20211008211154.349793-1-dmitry.kozl...@gmail.com/T/#u

[dpdk-dev] [Bug 798] mlx5 hw flow performance problem

2021-10-09 Thread bugzilla

https://bugs.dpdk.org/show_bug.cgi?id=798

Asaf Penso (as...@nvidia.com) changed:

   What|Removed |Added

 Status|IN_PROGRESS |RESOLVED
 Resolution|--- |WORKSFORME

--- Comment #3 from Asaf Penso (as...@nvidia.com) ---
After checking the configuration the issue is gone.

-- 
You are receiving this mail because:
You are the assignee for the bug.

Re: [dpdk-dev] [PATCH v2] net/e1000: build on Windows

2021-10-09 Thread Kadam, Pallavi




On 10/8/2021 5:14 PM, William Tu wrote:

On Fri, Oct 8, 2021 at 5:02 PM Kadam, Pallavi  wrote:


On 10/8/2021 6:53 AM, William Tu wrote:

This patch enables building the e1000 driver for Windows.
I tested using two Windows VM on top of VMware Fusion,
creating two e1000 devices with device ID 0x10D3,
verifying rx/tx works correctly using dpdk-testpmd.exe
rxonly and txonly mode.

Signed-off-by: William Tu 
Cc: Haiyue Wang 
---

Tested-by: Pallavi Kadam 

Acked-by: Pallavi Kadam 

Thanks!
I'm curious, what device ID are you testing so I can also add it to
the netuio.inf.
William


The Device ID is: 1521

Used the following string:

Intel.E1521NC.Description = "Intel(R) I350 Gigabit Network Connection"

Thanks,

Pallavi

Re: [dpdk-dev] [PATCH] doc/windows_gsg: update section on driver installation

2021-10-09 Thread Kadam, Pallavi




On 10/8/2021 2:11 PM, Dmitry Kozlyuk wrote:

Windows GSG included a section only on virt2phys driver installation,
but not on NetUIO. The content of the section duplicated documentation
in dpdk-kmods, but contained no links to it, only a reference.

Add subsections for virt2phys and NetUIO, explaining their roles.
Refer to documenttion in dpdk-kmods as an authoritative source,
but leave specific diagnostic and usage hints in the GSG.

Signed-off-by: Dmitry Kozlyuk 
---
  doc/guides/windows_gsg/run_apps.rst | 48 ++---
  1 file changed, 23 insertions(+), 25 deletions(-)

diff --git a/doc/guides/windows_gsg/run_apps.rst 
b/doc/guides/windows_gsg/run_apps.rst
index abaecc3793..70bb1da33f 100644
--- a/doc/guides/windows_gsg/run_apps.rst
+++ b/doc/guides/windows_gsg/run_apps.rst
@@ -27,40 +27,27 @@ See `Large-Page Support`_ in MSDN for details.
  .. _Large-Page Support: 
https://docs.microsoft.com/en-us/windows/win32/memory/large-page-support
  
  
-Load virt2phys Driver

--
+Install Drivers
+---
  
-Access to physical addresses is provided by a kernel-mode driver, virt2phys.

-It is mandatory at least for using hardware PMDs, but may also be required
-for mempools.
-
-Refer to documentation in ``dpdk-kmods`` repository for details on system
-setup, driver build and installation. This driver is not signed, so signature
-checking must be disabled to load it.
+Certain kernel-mode drivers are required to run DPDK applications.
+Refer to `Windows documentation 
`_
+in ``dpdk-kmods`` repository for common instructions on system setup,
+driver build and installation. The drivers are not signed, so signature
+enforcement has to be disabled.
  
  .. warning::
  
  Disabling driver signature enforcement weakens OS security.

  It is discouraged in production environments.
  
-Compiled package consists of ``virt2phys.inf``, ``virt2phys.cat``,

-and ``virt2phys.sys``. It can be installed as follows
-from Elevated Command Prompt:
-
-.. code-block:: console
-
-pnputil /add-driver Z:\path\to\virt2phys.inf /install
  
-On Windows Server additional steps are required:

+virt2phys
+~
  
-1. From Device Manager, Action menu, select "Add legacy hardware".

-2. It will launch the "Add Hardware Wizard". Click "Next".
-3. Select second option "Install the hardware that I manually select
-   from a list (Advanced)".
-4. On the next screen, "Kernel bypass" will be shown as a device class.
-5. Select it, and click "Next".
-6. The previously installed drivers will now be installed for the
-   "Virtual to physical address translator" device.
+Access to physical addresses is provided by a kernel-mode driver, virt2phys.
+It is mandatory for allocating physically-contiguous memory which is required
+by hardware PMDs.


Should we add specific link to virt2phys README in this section as well?

https://git.dpdk.org/dpdk-kmods/tree/windows/README.rst

  
  When loaded successfully, the driver is shown in *Device Manager* as *Virtual

  to physical address translator* device under *Kernel bypass* category.
@@ -74,6 +61,17 @@ on initialization (debug-level logs provide more details):
  EAL: Cannot open virt2phys driver interface
  
  
+NetUIO

+~~
+
+NetUIO kernel-mode driver provides access to the device hardware resources.
+It is mandatory for all hardware PMDs, except for MLX5 PMD.
+
+Refer to `NetUIO documentation 
`_
+in ``dpdk-kmods`` repository for instructions to build and set up the driver.
+Devices supported by NetUIO are listed in ``netuio.inf``.
+The list can be extended in order to try running DPDK with new devices.
+
  
  Run the ``helloworld`` Example

  --

Re: [dpdk-dev] [PATCH] doc/windows_gsg: update section on driver installation

2021-10-09 Thread Dmitry Kozlyuk

2021-10-09 12:38 (UTC-0700), Kadam, Pallavi:
> On 10/8/2021 2:11 PM, Dmitry Kozlyuk wrote:
> > [...]
> > +virt2phys
> > +~
> >   
> > -1. From Device Manager, Action menu, select "Add legacy hardware".
> > -2. It will launch the "Add Hardware Wizard". Click "Next".
> > -3. Select second option "Install the hardware that I manually select
> > -   from a list (Advanced)".
> > -4. On the next screen, "Kernel bypass" will be shown as a device class.
> > -5. Select it, and click "Next".
> > -6. The previously installed drivers will now be installed for the
> > -   "Virtual to physical address translator" device.
> > +Access to physical addresses is provided by a kernel-mode driver, 
> > virt2phys.
> > +It is mandatory for allocating physically-contiguous memory which is 
> > required
> > +by hardware PMDs.  
> 
> Should we add specific link to virt2phys README in this section as well?
> 
> https://git.dpdk.org/dpdk-kmods/tree/windows/README.rst

This link is given above and I consider it general information for all
drivers. However, reading it carefully, I think docs in dpdk-kmods could be
restructured as well:
* Keep windows/README.rst unchanged, except for Device Manager steps,
  which are actually specific to virt2phys.
* Create windows/virt2phys/README.rst with instructions above.
* Change windows/netuio/README.rst: remove the bulk of its content, as it
  repeats generic instructions, keep netuio-specific Device Manager part.
Then a specific link for virt2phys here would make sense
and there will be even less duplication in dpdk-kmods.
If no one objects, I'll do this in v2.
Thanks!

[dpdk-dev] [PATCH v2 00/12] ethdev: rework transfer flow API

As per RFC [1], action PORT_ID appears to be ambiguous. Its name suggests
that matching traffic be sent to the ethdev with the specified ID, that
is, to the application. However, in Open vSwitch, the action is used to
send traffic to a remote entity represented by the given port, that is,
in the opposite direction. Its interpretation across PMDs also varies.

RFC [2] attempted to define action PORT_ID semantics in vSwitch sense.
However, this solution would completely abandon the opposite meaning.

One more effort, RFC [3], was meant to declare that the use of direction
attributes in "transfer" flows assumed implicit filtering by the port ID
appearing as the first argument in rte_flow_create(). However, not all
PMDs require such filtering, so the RFC turned out rather disputable.

Since then, all of that has been given more thought:

1. One should not attempt to fix action PORT_ID. Instead, two new actions
should be introduced. The first one should send traffic to the given
ethdev. The second one should send it to the represented entity.

2. Similar to (1), two new items should be defined. The first one should
match traffic going down from the given ethdev. The second one should
match traffic going up from the entity represented by that ethdev.

3. The application always knows which packets come through which ethdevs.
So, as per (2), the application can use the new item to match traffic
arriving from precise entities represented by the relevant ethdev IDs.

4. New items suggested in (2) do not require the use of direction
attributes. These items define precise directions on their own.

5. As a consequence of (3) and (4), the problem of implicit filtering
by rte_flow_create() port ID argument and direction attributes is
no longer a blocker. The new items allow to dispose of it.

The new items appear to be symmetrical to each other. So do the new
actions. This requires that their names reflect the symmetry. Also,
the names should respect the existing concept of port representors.
By the looks of it, terms "PORT_REPRESENTOR" and "REPRESENTED_PORT"
satisfy these requirements. However, currently, ethdevs associated
with network ports are not considered as their representors. Such
understanding is mentioned in the documentation, but it's not
expressed in the code (see enum rte_eth_representor_type).

The short of it, this patch series follows points (1-5) to rework
support for "transfer" flows accordingly. On the way, a string of
ambiguous pattern items (PF, VF, PHY_PORT) is deprecated.

The patch series also updates PMDs which support item and action PORT_ID
to add support for replacements (1-2). However, there're some exceptions:

- Support for traffic source items in the case of net/mlx5 is really
complicated. This series does not rework it. The PMD maintainer
can do the job much better and test the new code accordingly;

- Support for action REPRESENTED_PORT is not added to net/sfc.
This will be done when support for VF representors has been
upstreamed, just for the new code to apply cleanly.

[1]
https://patches.dpdk.org/project/dpdk/patch/20210907125157.3843-1-ivan.ma...@oktetlabs.ru/
[2]
https://patches.dpdk.org/project/dpdk/patch/20210903074610.313622-1-andrew.rybche...@oktetlabs.ru/
[3]
https://patches.dpdk.org/project/dpdk/patch/20210901151104.3923889-1-andrew.rybche...@oktetlabs.ru/

Andrew Rybchenko (6):
net/bnxt: support meta flow items to match on traffic source
net/bnxt: support meta flow actions to overrule destinations
net/enic: support meta flow actions to overrule destinations
net/mlx5: support represented port flow action
net/octeontx2: support port representor flow action
net/sfc: support port representor flow item

Ivan Malov (6):
ethdev: add port representor item to flow API
ethdev: add represented port item to flow API
ethdev: add port representor action to flow API
ethdev: add represented port action to flow API
ethdev: deprecate hard-to-use or ambiguous items and actions
ethdev: deprecate direction attributes in transfer flows

[dpdk-dev] [PATCH v2 01/12] ethdev: add port representor item to flow API

For use in "transfer" flows. Supposed to match traffic
entering the embedded switch from the given ethdev.

Must not be combined with direction attributes.

Signed-off-by: Ivan Malov 
---
 app/test-pmd/cmdline_flow.c | 27 ++
 doc/guides/prog_guide/rte_flow.rst  | 59 +
 doc/guides/rel_notes/release_21_11.rst  |  2 +
 doc/guides/testpmd_app_ug/testpmd_funcs.rst |  4 ++
 lib/ethdev/rte_flow.c   |  1 +
 lib/ethdev/rte_flow.h   | 27 ++
 6 files changed, 120 insertions(+)

diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c
index bb22294dd3..a912a8d815 100644
--- a/app/test-pmd/cmdline_flow.c
+++ b/app/test-pmd/cmdline_flow.c
@@ -306,6 +306,8 @@ enum index {
ITEM_POL_PORT,
ITEM_POL_METER,
ITEM_POL_POLICY,
+   ITEM_PORT_REPRESENTOR,
+   ITEM_PORT_REPRESENTOR_PORT_ID,
 
/* Validate/create actions. */
ACTIONS,
@@ -1000,6 +1002,7 @@ static const enum index next_item[] = {
ITEM_GENEVE_OPT,
ITEM_INTEGRITY,
ITEM_CONNTRACK,
+   ITEM_PORT_REPRESENTOR,
END_SET,
ZERO,
 };
@@ -1368,6 +1371,12 @@ static const enum index item_integrity_lv[] = {
ZERO,
 };
 
+static const enum index item_port_representor[] = {
+   ITEM_PORT_REPRESENTOR_PORT_ID,
+   ITEM_NEXT,
+   ZERO,
+};
+
 static const enum index next_action[] = {
ACTION_END,
ACTION_VOID,
@@ -3608,6 +3617,21 @@ static const struct token token_list[] = {
 item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_conntrack, flags)),
},
+   [ITEM_PORT_REPRESENTOR] = {
+   .name = "port_representor",
+   .help = "match traffic entering the embedded switch from the 
given ethdev",
+   .priv = PRIV_ITEM(PORT_REPRESENTOR,
+ sizeof(struct rte_flow_item_ethdev)),
+   .next = NEXT(item_port_representor),
+   .call = parse_vc,
+   },
+   [ITEM_PORT_REPRESENTOR_PORT_ID] = {
+   .name = "port_id",
+   .help = "ethdev port ID",
+   .next = NEXT(item_port_representor, NEXT_ENTRY(COMMON_UNSIGNED),
+item_param),
+   .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ethdev, port_id)),
+   },
/* Validate/create actions. */
[ACTIONS] = {
.name = "actions",
@@ -8343,6 +8367,9 @@ flow_item_default_mask(const struct rte_flow_item *item)
case RTE_FLOW_ITEM_TYPE_PFCP:
mask = &rte_flow_item_pfcp_mask;
break;
+   case RTE_FLOW_ITEM_TYPE_PORT_REPRESENTOR:
+   mask = &rte_flow_item_ethdev_mask;
+   break;
default:
break;
}
diff --git a/doc/guides/prog_guide/rte_flow.rst 
b/doc/guides/prog_guide/rte_flow.rst
index 2b42d5ec8c..2e0f590777 100644
--- a/doc/guides/prog_guide/rte_flow.rst
+++ b/doc/guides/prog_guide/rte_flow.rst
@@ -1425,6 +1425,65 @@ Matches a conntrack state after conntrack action.
 - ``flags``: conntrack packet state flags.
 - Default ``mask`` matches all state bits.
 
+Item: ``PORT_REPRESENTOR``
+^^
+
+Matches traffic entering the embedded switch from the given ethdev.
+
+Term **ethdev** and the concept of **port representor** are synonymous.
+The **represented port** is an *entity* plugged to the embedded switch
+at the opposite end of the "wire" leading to the ethdev.
+
+::
+
+..
+|PORT_REPRESENTOR|  Ethdev (Application Port Referred to by its ID)
+''
+||
+\/
+..
+|  Embedded Switch Port  |  Logical Port
+''
+||
+||
+||
+\/
+..
+|  Embedded Flow Engine  |
+''
+:
+ :
+:
+ :
+..
+|  Embedded Switch Port  |  Logical Port
+''
+:
+ :
+..
+|REPRESENTED_PORT|  Net / Guest / Another Ethdev (Same Application)
+''
+
+
+- Incompatibe with `Attribute: Traffic direction`_.
+- Requires `Attribute: Transfer`_.
+
+.. _table_rte_flow_item_ethdev:
+
+.. table:: ``struct rte_flow_item_ethdev``
+
+   +--+-+---+
+   | Field| Subfield| Value |
+   +==+=+===+
+   | ``spec`` | ``port_id`` | ethdev port ID|
+   +--+-+---+
+   | ``last`` | ``port_id`` | upper range value |
+   +--+-+-

[dpdk-dev] [PATCH v2 02/12] ethdev: add represented port item to flow API

For use in "transfer" flows. Supposed to match traffic entering the
embedded switch from the entity represented by the given ethdev.
Such an entity can be a network (via a network port), a guest
machine (via a VF) or another ethdev in the same application.

Must not be combined with direction attributes.

Signed-off-by: Ivan Malov 
---
 app/test-pmd/cmdline_flow.c | 25 +++
 doc/guides/prog_guide/rte_flow.rst  | 46 +
 doc/guides/rel_notes/release_21_11.rst  |  2 +-
 doc/guides/testpmd_app_ug/testpmd_funcs.rst |  5 +++
 lib/ethdev/rte_flow.c   |  1 +
 lib/ethdev/rte_flow.h   | 13 +-
 6 files changed, 90 insertions(+), 2 deletions(-)

diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c
index a912a8d815..68698d805d 100644
--- a/app/test-pmd/cmdline_flow.c
+++ b/app/test-pmd/cmdline_flow.c
@@ -308,6 +308,8 @@ enum index {
ITEM_POL_POLICY,
ITEM_PORT_REPRESENTOR,
ITEM_PORT_REPRESENTOR_PORT_ID,
+   ITEM_REPRESENTED_PORT,
+   ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID,
 
/* Validate/create actions. */
ACTIONS,
@@ -1003,6 +1005,7 @@ static const enum index next_item[] = {
ITEM_INTEGRITY,
ITEM_CONNTRACK,
ITEM_PORT_REPRESENTOR,
+   ITEM_REPRESENTED_PORT,
END_SET,
ZERO,
 };
@@ -1377,6 +1380,12 @@ static const enum index item_port_representor[] = {
ZERO,
 };
 
+static const enum index item_represented_port[] = {
+   ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID,
+   ITEM_NEXT,
+   ZERO,
+};
+
 static const enum index next_action[] = {
ACTION_END,
ACTION_VOID,
@@ -3632,6 +3641,21 @@ static const struct token token_list[] = {
 item_param),
.args = ARGS(ARGS_ENTRY(struct rte_flow_item_ethdev, port_id)),
},
+   [ITEM_REPRESENTED_PORT] = {
+   .name = "represented_port",
+   .help = "match traffic entering the embedded switch from the 
entity represented by the given ethdev",
+   .priv = PRIV_ITEM(REPRESENTED_PORT,
+ sizeof(struct rte_flow_item_ethdev)),
+   .next = NEXT(item_represented_port),
+   .call = parse_vc,
+   },
+   [ITEM_REPRESENTED_PORT_ETHDEV_PORT_ID] = {
+   .name = "ethdev_port_id",
+   .help = "ethdev port ID",
+   .next = NEXT(item_represented_port, NEXT_ENTRY(COMMON_UNSIGNED),
+item_param),
+   .args = ARGS(ARGS_ENTRY(struct rte_flow_item_ethdev, port_id)),
+   },
/* Validate/create actions. */
[ACTIONS] = {
.name = "actions",
@@ -8368,6 +8392,7 @@ flow_item_default_mask(const struct rte_flow_item *item)
mask = &rte_flow_item_pfcp_mask;
break;
case RTE_FLOW_ITEM_TYPE_PORT_REPRESENTOR:
+   case RTE_FLOW_ITEM_TYPE_REPRESENTED_PORT:
mask = &rte_flow_item_ethdev_mask;
break;
default:
diff --git a/doc/guides/prog_guide/rte_flow.rst 
b/doc/guides/prog_guide/rte_flow.rst
index 2e0f590777..3dc209af4d 100644
--- a/doc/guides/prog_guide/rte_flow.rst
+++ b/doc/guides/prog_guide/rte_flow.rst
@@ -1484,6 +1484,52 @@ at the opposite end of the "wire" leading to the ethdev.
 
 - Default ``mask`` provides exact match behaviour.
 
+Item: ``REPRESENTED_PORT``
+^^
+
+Matches traffic entering the embedded switch from
+the entity represented by the given ethdev.
+
+Term **ethdev** and the concept of **port representor** are synonymous.
+The **represented port** is an *entity* plugged to the embedded switch
+at the opposite end of the "wire" leading to the ethdev.
+
+::
+
+..
+|PORT_REPRESENTOR|  Ethdev (Application Port Referred to by its ID)
+''
+:
+ :
+..
+|  Embedded Switch Port  |  Logical Port
+''
+:
+ :
+:
+ :
+..
+|  Embedded Flow Engine  |
+''
+/\
+||
+||
+||
+..
+|  Embedded Switch Port  |  Logical Port
+''
+/\
+||
+..
+|REPRESENTED_PORT|  Net / Guest / Another Ethdev (Same Application)
+''
+
+
+- Incompatibe with `Attribute: Traffic direction`_.
+- Requires `Attribute: Transfer`_.
+
+This item is meant to use the same structure as `Item: PORT_REPRESENTOR`_.
+
 Actions
 ~~~
 
diff --git a/doc/guides/rel_notes/release_21_11.rst 
b/doc/guides/rel_notes/release_21_11.rst
index 1261cb2bf3..39ff16780b 100644
--- a/doc/guides/

[dpdk-dev] [PATCH v2 03/12] ethdev: add port representor action to flow API

For use in "transfer" flows. Supposed to send matching traffic to
the given ethdev (to the application), at embedded switch level.

Signed-off-by: Ivan Malov 
---
 app/test-pmd/cmdline_flow.c | 26 ++
 doc/guides/prog_guide/rte_flow.rst  | 56 +
 doc/guides/rel_notes/release_21_11.rst  |  2 +-
 doc/guides/testpmd_app_ug/testpmd_funcs.rst |  5 ++
 lib/ethdev/rte_flow.c   |  1 +
 lib/ethdev/rte_flow.h   | 18 +++
 6 files changed, 107 insertions(+), 1 deletion(-)

diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c
index 68698d805d..ee6dac411a 100644
--- a/app/test-pmd/cmdline_flow.c
+++ b/app/test-pmd/cmdline_flow.c
@@ -460,6 +460,8 @@ enum index {
ACTION_POL_G,
ACTION_POL_Y,
ACTION_POL_R,
+   ACTION_PORT_REPRESENTOR,
+   ACTION_PORT_REPRESENTOR_PORT_ID,
 };
 
 /** Maximum size for pattern in struct rte_flow_item_raw. */
@@ -1452,6 +1454,7 @@ static const enum index next_action[] = {
ACTION_MODIFY_FIELD,
ACTION_CONNTRACK,
ACTION_CONNTRACK_UPDATE,
+   ACTION_PORT_REPRESENTOR,
ZERO,
 };
 
@@ -1733,6 +1736,12 @@ static const enum index action_update_conntrack[] = {
ZERO,
 };
 
+static const enum index action_port_representor[] = {
+   ACTION_PORT_REPRESENTOR_PORT_ID,
+   ACTION_NEXT,
+   ZERO,
+};
+
 static int parse_set_raw_encap_decap(struct context *, const struct token *,
 const char *, unsigned int,
 void *, unsigned int);
@@ -4820,6 +4829,23 @@ static const struct token token_list[] = {
.next = NEXT(action_update_conntrack),
.call = parse_vc_action_conntrack_update,
},
+   [ACTION_PORT_REPRESENTOR] = {
+   .name = "port_representor",
+   .help = "at embedded switch level, send matching traffic to the 
given ethdev",
+   .priv = PRIV_ACTION(PORT_REPRESENTOR,
+   sizeof(struct rte_flow_action_ethdev)),
+   .next = NEXT(action_port_representor),
+   .call = parse_vc,
+   },
+   [ACTION_PORT_REPRESENTOR_PORT_ID] = {
+   .name = "port_id",
+   .help = "ethdev port ID",
+   .next = NEXT(action_port_representor,
+NEXT_ENTRY(COMMON_UNSIGNED)),
+   .args = ARGS(ARGS_ENTRY(struct rte_flow_action_ethdev,
+   port_id)),
+   .call = parse_vc_conf,
+   },
/* Indirect action destroy arguments. */
[INDIRECT_ACTION_DESTROY_ID] = {
.name = "action_id",
diff --git a/doc/guides/prog_guide/rte_flow.rst 
b/doc/guides/prog_guide/rte_flow.rst
index 3dc209af4d..e85880c2d4 100644
--- a/doc/guides/prog_guide/rte_flow.rst
+++ b/doc/guides/prog_guide/rte_flow.rst
@@ -1484,6 +1484,8 @@ at the opposite end of the "wire" leading to the ethdev.
 
 - Default ``mask`` provides exact match behaviour.
 
+See also `Action: PORT_REPRESENTOR`_.
+
 Item: ``REPRESENTED_PORT``
 ^^
 
@@ -3104,6 +3106,60 @@ which is set in the packet meta-data (i.e. struct 
``rte_mbuf::sched::color``)
| ``meter_color`` | Packet color |
+-+--+
 
+Action: ``PORT_REPRESENTOR``
+
+
+At embedded switch level, send matching traffic to the given ethdev.
+
+Term **ethdev** and the concept of **port representor** are synonymous.
+The **represented port** is an *entity* plugged to the embedded switch
+at the opposite end of the "wire" leading to the ethdev.
+
+::
+
+..
+|PORT_REPRESENTOR|  Ethdev (Application Port Referred to by its ID)
+''
+/\
+||
+..
+|  Embedded Switch Port  |  Logical Port
+''
+/\
+||
+||
+||
+..  ..
+|  Embedded Flow Engine  |  <=  |  Matching Traffic  |
+''  ''
+:
+ :
+:
+ :
+..
+|  Embedded Switch Port  |  Logical Port
+''
+:
+ :
+..
+|REPRESENTED_PORT|  Net / Guest / Another Ethdev (Same Application)
+''
+
+
+- Requires `Attribute: Transfer`_.
+
+.. _table_rte_flow_action_ethdev:
+
+.. table:: ``struct rte_flow_action_ethdev``
+
+   +-++
+   | Field   | Value  |
+   +=++
+   | ``port_id`` | ethdev port ID |
+   +-++
+
+See also `Item: PORT_REPRESENTOR`_.
+

[dpdk-dev] [PATCH v2 04/12] ethdev: add represented port action to flow API

For use in "transfer" flows. Supposed to send matching traffic to the
entity represented by the given ethdev, at embedded switch level.
Such an entity can be a network (via a network port), a guest
machine (via a VF) or another ethdev in the same application.

Signed-off-by: Ivan Malov 
---
 app/test-pmd/cmdline_flow.c | 26 +++
 doc/guides/prog_guide/rte_flow.rst  | 49 +
 doc/guides/rel_notes/release_21_11.rst  |  2 +-
 doc/guides/testpmd_app_ug/testpmd_funcs.rst |  5 +++
 lib/ethdev/rte_flow.c   |  1 +
 lib/ethdev/rte_flow.h   | 11 -
 6 files changed, 92 insertions(+), 2 deletions(-)

diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c
index ee6dac411a..c704bbaead 100644
--- a/app/test-pmd/cmdline_flow.c
+++ b/app/test-pmd/cmdline_flow.c
@@ -462,6 +462,8 @@ enum index {
ACTION_POL_R,
ACTION_PORT_REPRESENTOR,
ACTION_PORT_REPRESENTOR_PORT_ID,
+   ACTION_REPRESENTED_PORT,
+   ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID,
 };
 
 /** Maximum size for pattern in struct rte_flow_item_raw. */
@@ -1455,6 +1457,7 @@ static const enum index next_action[] = {
ACTION_CONNTRACK,
ACTION_CONNTRACK_UPDATE,
ACTION_PORT_REPRESENTOR,
+   ACTION_REPRESENTED_PORT,
ZERO,
 };
 
@@ -1742,6 +1745,12 @@ static const enum index action_port_representor[] = {
ZERO,
 };
 
+static const enum index action_represented_port[] = {
+   ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID,
+   ACTION_NEXT,
+   ZERO,
+};
+
 static int parse_set_raw_encap_decap(struct context *, const struct token *,
 const char *, unsigned int,
 void *, unsigned int);
@@ -4846,6 +4855,23 @@ static const struct token token_list[] = {
port_id)),
.call = parse_vc_conf,
},
+   [ACTION_REPRESENTED_PORT] = {
+   .name = "represented_port",
+   .help = "at embedded switch level, send matching traffic to the 
entity represented by the given ethdev",
+   .priv = PRIV_ACTION(REPRESENTED_PORT,
+   sizeof(struct rte_flow_action_ethdev)),
+   .next = NEXT(action_represented_port),
+   .call = parse_vc,
+   },
+   [ACTION_REPRESENTED_PORT_ETHDEV_PORT_ID] = {
+   .name = "ethdev_port_id",
+   .help = "ethdev port ID",
+   .next = NEXT(action_represented_port,
+NEXT_ENTRY(COMMON_UNSIGNED)),
+   .args = ARGS(ARGS_ENTRY(struct rte_flow_action_ethdev,
+   port_id)),
+   .call = parse_vc_conf,
+   },
/* Indirect action destroy arguments. */
[INDIRECT_ACTION_DESTROY_ID] = {
.name = "action_id",
diff --git a/doc/guides/prog_guide/rte_flow.rst 
b/doc/guides/prog_guide/rte_flow.rst
index e85880c2d4..2056cfae38 100644
--- a/doc/guides/prog_guide/rte_flow.rst
+++ b/doc/guides/prog_guide/rte_flow.rst
@@ -1532,6 +1532,8 @@ at the opposite end of the "wire" leading to the ethdev.
 
 This item is meant to use the same structure as `Item: PORT_REPRESENTOR`_.
 
+See also `Action: REPRESENTED_PORT`_.
+
 Actions
 ~~~
 
@@ -3160,6 +3162,53 @@ at the opposite end of the "wire" leading to the ethdev.
 
 See also `Item: PORT_REPRESENTOR`_.
 
+Action: ``REPRESENTED_PORT``
+
+
+At embedded switch level, send matching traffic to
+the entity represented by the given ethdev.
+
+Term **ethdev** and the concept of **port representor** are synonymous.
+The **represented port** is an *entity* plugged to the embedded switch
+at the opposite end of the "wire" leading to the ethdev.
+
+::
+
+..
+|PORT_REPRESENTOR|  Ethdev (Application Port Referred to by its ID)
+''
+:
+ :
+..
+|  Embedded Switch Port  |  Logical Port
+''
+:
+ :
+:
+ :
+..  ..
+|  Embedded Flow Engine  |  <=  |  Matching Traffic  |
+''  ''
+||
+||
+||
+\/
+..
+|  Embedded Switch Port  |  Logical Port
+''
+||
+\/
+..
+|REPRESENTED_PORT|  Net / Guest / Another Ethdev (Same Application)
+''
+
+
+- Requires `Attribute: Transfer`_.
+
+This action is meant to use the same structure as `Action: PORT_REPRESENTOR`_.
+
+See also `Item: REPRESENTED_PORT`_.
+
 Negative types
 ~~
 
diff --git a/

[dpdk-dev] [PATCH v2 06/12] ethdev: deprecate direction attributes in transfer flows

Attributes "ingress" and "egress" can only apply unambiguosly
to non-"transfer" flows. In "transfer" flows, the standpoint
is effectively shifted to the embedded switch. There can be
many different endpoints connected to the switch, so the
use of "ingress" / "egress" does not shed light on which
endpoints precisely can be considered as traffic sources.

Add relevant deprecation notices and suggest the use of precise
traffic source items (PORT_REPRESENTOR and REPRESENTED_PORT).

Signed-off-by: Ivan Malov 
---
 doc/guides/prog_guide/rte_flow.rst | 28 --
 doc/guides/rel_notes/deprecation.rst   |  9 +++---
 doc/guides/rel_notes/release_21_11.rst |  3 ++
 lib/ethdev/rte_flow.h  | 41 --
 4 files changed, 52 insertions(+), 29 deletions(-)

diff --git a/doc/guides/prog_guide/rte_flow.rst 
b/doc/guides/prog_guide/rte_flow.rst
index 04ec1093be..f2e04fc7d8 100644
--- a/doc/guides/prog_guide/rte_flow.rst
+++ b/doc/guides/prog_guide/rte_flow.rst
@@ -9,8 +9,8 @@ Overview
 
 
 This API provides a generic means to configure hardware to match specific
-ingress or egress traffic, alter its fate and query related counters
-according to any number of user-defined rules.
+traffic, alter its fate and query related counters according to any
+number of user-defined rules.
 
 It is named *rte_flow* after the prefix used for all its symbols, and is
 defined in ``rte_flow.h``.
@@ -146,13 +146,10 @@ Note that support for more than a single priority level 
is not guaranteed.
 Attribute: Traffic direction
 
 
-Flow rule patterns apply to inbound and/or outbound traffic.
-
-In the context of this API, **ingress** and **egress** respectively stand
-for **inbound** and **outbound** based on the standpoint of the application
-creating a flow rule.
-
-There are no exceptions to this definition.
+Unless `Attribute: Transfer`_ is specified, flow rule patterns apply
+to inbound and / or outbound traffic. With this respect, ``ingress``
+and ``egress`` respectively stand for **inbound** and **outbound**
+based on the standpoint of the application creating a flow rule.
 
 Several pattern items and actions are valid and can be used in both
 directions. At least one direction must be specified.
@@ -171,12 +168,13 @@ When supported, this effectively enables an application 
to reroute traffic
 not necessarily intended for it (e.g. coming from or addressed to different
 physical ports, VFs or applications) at the device level.
 
-It complements the behavior of some pattern items such as `Item: PHY_PORT`_
-and is meaningless without them.
-
-When transferring flow rules, **ingress** and **egress** attributes
-(`Attribute: Traffic direction`_) keep their original meaning, as if
-processing traffic emitted or received by the application.
+In "transfer" flows, the use of `Attribute: Traffic direction`_ in the sense of
+implicitly matching packets going to or going from the ethdev used to create
+flow rules is **deprecated**. `Attribute: Transfer`_ shifts the viewpoint to
+the embedded switch. In it, `Attribute: Traffic direction`_ is ambiguous as
+the switch serves many different endpoints. The application should match
+traffic originating from precise locations. To do so, it should
+use `Item: PORT_REPRESENTOR`_ and `Item: REPRESENTED_PORT`_.
 
 Pattern item
 
diff --git a/doc/guides/rel_notes/deprecation.rst 
b/doc/guides/rel_notes/deprecation.rst
index c91d570099..02a5b6eeba 100644
--- a/doc/guides/rel_notes/deprecation.rst
+++ b/doc/guides/rel_notes/deprecation.rst
@@ -122,11 +122,6 @@ Deprecation Notices
   is deprecated and will be removed in DPDK 21.11. Shared counters should
   be managed using shared actions API (``rte_flow_shared_action_create`` etc).
 
-* ethdev: Flow API documentation is unclear if ethdev port used to create
-  a flow rule adds any implicit match criteria in the case of transfer rules.
-  The semantics will be clarified in DPDK 21.11 and it will require fixes in
-  drivers and applications which interpret it in a different way.
-
 * ethdev: The flow API matching pattern structures, ``struct rte_flow_item_*``,
   should start with relevant protocol header.
   Some matching pattern structures implements this by duplicating protocol 
header
@@ -253,3 +248,7 @@ Deprecation Notices
 
 * ethdev: Items and actions ``PF``, ``VF``, ``PHY_PORT``, ``PORT_ID`` are
   deprecated as hard-to-use / ambiguous and will be removed in DPDK 22.11.
+
+* ethdev: The use of attributes ``ingress`` / ``egress`` in "transfer" flows
+  is deprecated as ambiguous with respect to the embedded switch. The use of
+  these attributes will become invalid starting from DPDK 22.11.
diff --git a/doc/guides/rel_notes/release_21_11.rst 
b/doc/guides/rel_notes/release_21_11.rst
index 63f946ad88..d4dadbfcf4 100644
--- a/doc/guides/rel_notes/release_21_11.rst
+++ b/doc/guides/rel_notes/release_21_11.rst
@@ -193,6 +193,9 @@ API Changes
 * ethdev: Deprecated items

[dpdk-dev] [PATCH v2 05/12] ethdev: deprecate hard-to-use or ambiguous items and actions

PF, VF and PHY_PORT require that applications have extra
knowledge of the underlying NIC and thus are hard to use.
Also, the corresponding items depend on the direction
attribute (ingress / egress), which complicates their
use in applications and interpretation in PMDs.

The concept of PORT_ID is ambiguous as it doesn't say whether
the port in question is an ethdev or the represented entity.

Items and actions PORT_REPRESENTOR, REPRESENTED_PORT
should be used instead.

Signed-off-by: Ivan Malov 
---
 doc/guides/prog_guide/rte_flow.rst | 32 +++
 doc/guides/rel_notes/deprecation.rst   |  9 ++---
 doc/guides/rel_notes/release_21_11.rst |  3 ++
 lib/ethdev/rte_flow.h  | 56 ++
 4 files changed, 94 insertions(+), 6 deletions(-)

diff --git a/doc/guides/prog_guide/rte_flow.rst 
b/doc/guides/prog_guide/rte_flow.rst
index 2056cfae38..04ec1093be 100644
--- a/doc/guides/prog_guide/rte_flow.rst
+++ b/doc/guides/prog_guide/rte_flow.rst
@@ -504,6 +504,10 @@ Usage example, matching non-TCPv4 packets only:
 Item: ``PF``
 
 
+This item is deprecated. Consider:
+ - `Item: PORT_REPRESENTOR`_
+ - `Item: REPRESENTED_PORT`_
+
 Matches traffic originating from (ingress) or going to (egress) the physical
 function of the current device.
 
@@ -531,6 +535,10 @@ the application and thus not associated with a DPDK port 
ID.
 Item: ``VF``
 
 
+This item is deprecated. Consider:
+ - `Item: PORT_REPRESENTOR`_
+ - `Item: REPRESENTED_PORT`_
+
 Matches traffic originating from (ingress) or going to (egress) a given
 virtual function of the current device.
 
@@ -562,6 +570,10 @@ separate entities, should be addressed through their own 
DPDK port IDs.
 Item: ``PHY_PORT``
 ^^
 
+This item is deprecated. Consider:
+ - `Item: PORT_REPRESENTOR`_
+ - `Item: REPRESENTED_PORT`_
+
 Matches traffic originating from (ingress) or going to (egress) a physical
 port of the underlying device.
 
@@ -596,6 +608,10 @@ associated with a port_id should be retrieved by other 
means.
 Item: ``PORT_ID``
 ^
 
+This item is deprecated. Consider:
+ - `Item: PORT_REPRESENTOR`_
+ - `Item: REPRESENTED_PORT`_
+
 Matches traffic originating from (ingress) or going to (egress) a given DPDK
 port ID.
 
@@ -1965,6 +1981,10 @@ only matching traffic goes through.
 Action: ``PF``
 ^^
 
+This action is deprecated. Consider:
+ - `Action: PORT_REPRESENTOR`_
+ - `Action: REPRESENTED_PORT`_
+
 Directs matching traffic to the physical function (PF) of the current
 device.
 
@@ -1985,6 +2005,10 @@ See `Item: PF`_.
 Action: ``VF``
 ^^
 
+This action is deprecated. Consider:
+ - `Action: PORT_REPRESENTOR`_
+ - `Action: REPRESENTED_PORT`_
+
 Directs matching traffic to a given virtual function of the current device.
 
 Packets matched by a VF pattern item can be redirected to their original VF
@@ -2009,6 +2033,10 @@ See `Item: VF`_.
 Action: ``PHY_PORT``
 
 
+This action is deprecated. Consider:
+ - `Action: PORT_REPRESENTOR`_
+ - `Action: REPRESENTED_PORT`_
+
 Directs matching traffic to a given physical port index of the underlying
 device.
 
@@ -2028,6 +2056,10 @@ See `Item: PHY_PORT`_.
 
 Action: ``PORT_ID``
 ^^^
+This action is deprecated. Consider:
+ - `Action: PORT_REPRESENTOR`_
+ - `Action: REPRESENTED_PORT`_
+
 Directs matching traffic to a given DPDK port ID.
 
 See `Item: PORT_ID`_.
diff --git a/doc/guides/rel_notes/deprecation.rst 
b/doc/guides/rel_notes/deprecation.rst
index b86147dda1..c91d570099 100644
--- a/doc/guides/rel_notes/deprecation.rst
+++ b/doc/guides/rel_notes/deprecation.rst
@@ -122,12 +122,6 @@ Deprecation Notices
   is deprecated and will be removed in DPDK 21.11. Shared counters should
   be managed using shared actions API (``rte_flow_shared_action_create`` etc).
 
-* ethdev: Definition of the flow API action ``RTE_FLOW_ACTION_TYPE_PORT_ID``
-  is ambiguous and needs clarification.
-  Structure ``rte_flow_action_port_id`` will be extended to specify
-  traffic direction to the represented entity or ethdev port itself
-  in DPDK 21.11.
-
 * ethdev: Flow API documentation is unclear if ethdev port used to create
   a flow rule adds any implicit match criteria in the case of transfer rules.
   The semantics will be clarified in DPDK 21.11 and it will require fixes in
@@ -256,3 +250,6 @@ Deprecation Notices
 * cmdline: ``cmdline`` structure will be made opaque to hide platform-specific
   content. On Linux and FreeBSD, supported prior to DPDK 20.11,
   original structure will be kept until DPDK 21.11.
+
+* ethdev: Items and actions ``PF``, ``VF``, ``PHY_PORT``, ``PORT_ID`` are
+  deprecated as hard-to-use / ambiguous and will be removed in DPDK 22.11.
diff --git a/doc/guides/rel_notes/release_21_11.rst 
b/doc/guides/rel_notes/release_21_11.rst
index f689a10e63..63f946ad88 100644
--- a/doc/guides/rel_notes/release_21_11.rst
+++ b/doc/guides/rel_notes/release_21_11.rst
@@ -190,6 +190,9 @@ API

[dpdk-dev] [PATCH v2 07/12] net/bnxt: support meta flow items to match on traffic source

From: Andrew Rybchenko 

Add support for items PORT_REPRESENTOR and REPRESENTED_PORT
based on the existing support for item PORT_ID.

The use of item PORT_ID depends on the specified direction attribute.
Items PORT_REPRESENTOR and REPRESENTED_PORT, in turn, define traffic
direction themselves. The former matches traffic from the driver's
vNIC. The latter matches packets from either a v-port (network) or
a VF's vNIC (if the driver's port is a VF representor).

Signed-off-by: Andrew Rybchenko 
---
 drivers/net/bnxt/tf_ulp/ulp_rte_handler_tbl.c | 10 ++-
 drivers/net/bnxt/tf_ulp/ulp_rte_parser.c  | 77 ++-
 drivers/net/bnxt/tf_ulp/ulp_rte_parser.h  |  6 +-
 3 files changed, 70 insertions(+), 23 deletions(-)

diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_handler_tbl.c 
b/drivers/net/bnxt/tf_ulp/ulp_rte_handler_tbl.c
index 9b165c12b5..d28dd2e587 100644
--- a/drivers/net/bnxt/tf_ulp/ulp_rte_handler_tbl.c
+++ b/drivers/net/bnxt/tf_ulp/ulp_rte_handler_tbl.c
@@ -266,7 +266,7 @@ struct bnxt_ulp_rte_hdr_info ulp_hdr_info[] = {
},
[RTE_FLOW_ITEM_TYPE_PORT_ID] = {
.hdr_type= BNXT_ULP_HDR_TYPE_SUPPORTED,
-   .proto_hdr_func  = ulp_rte_port_id_hdr_handler
+   .proto_hdr_func  = ulp_rte_port_hdr_handler
},
[RTE_FLOW_ITEM_TYPE_RAW] = {
.hdr_type= BNXT_ULP_HDR_TYPE_NOT_SUPPORTED,
@@ -427,6 +427,14 @@ struct bnxt_ulp_rte_hdr_info ulp_hdr_info[] = {
[RTE_FLOW_ITEM_TYPE_HIGIG2] = {
.hdr_type= BNXT_ULP_HDR_TYPE_NOT_SUPPORTED,
.proto_hdr_func  = NULL
+   },
+   [RTE_FLOW_ITEM_TYPE_PORT_REPRESENTOR] = {
+   .hdr_type= BNXT_ULP_HDR_TYPE_SUPPORTED,
+   .proto_hdr_func  = ulp_rte_port_hdr_handler
+   },
+   [RTE_FLOW_ITEM_TYPE_REPRESENTED_PORT] = {
+   .hdr_type= BNXT_ULP_HDR_TYPE_SUPPORTED,
+   .proto_hdr_func  = ulp_rte_port_hdr_handler
}
 };
 
diff --git a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c 
b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c
index 3a9c9bba27..e1ea8932b0 100644
--- a/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c
+++ b/drivers/net/bnxt/tf_ulp/ulp_rte_parser.c
@@ -400,7 +400,8 @@ bnxt_ulp_rte_parser_direction_compute(struct 
ulp_rte_parser_params *params)
 static int32_t
 ulp_rte_parser_svif_set(struct ulp_rte_parser_params *params,
uint32_t ifindex,
-   uint16_t mask)
+   uint16_t mask,
+   enum bnxt_ulp_direction_type item_dir)
 {
uint16_t svif;
enum bnxt_ulp_direction_type dir;
@@ -429,11 +430,14 @@ ulp_rte_parser_svif_set(struct ulp_rte_parser_params 
*params,
bnxt_ulp_rte_parser_direction_compute(params);
 
/* Get the computed direction */
-   dir = ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_DIRECTION);
-   if (dir == BNXT_ULP_DIR_INGRESS) {
+   dir = (item_dir != BNXT_ULP_DIR_INVALID) ? item_dir :
+   ULP_COMP_FLD_IDX_RD(params, BNXT_ULP_CF_IDX_DIRECTION);
+   if (dir == BNXT_ULP_DIR_INGRESS &&
+   port_type != BNXT_ULP_INTF_TYPE_VF_REP) {
svif_type = BNXT_ULP_PHY_PORT_SVIF;
} else {
-   if (port_type == BNXT_ULP_INTF_TYPE_VF_REP)
+   if (port_type == BNXT_ULP_INTF_TYPE_VF_REP &&
+   item_dir != BNXT_ULP_DIR_EGRESS)
svif_type = BNXT_ULP_VF_FUNC_SVIF;
else
svif_type = BNXT_ULP_DRV_FUNC_SVIF;
@@ -474,7 +478,8 @@ ulp_rte_parser_implicit_match_port_process(struct 
ulp_rte_parser_params *params)
}
 
/* Update the SVIF details */
-   rc = ulp_rte_parser_svif_set(params, ifindex, svif_mask);
+   rc = ulp_rte_parser_svif_set(params, ifindex, svif_mask,
+BNXT_ULP_DIR_INVALID);
return rc;
 }
 
@@ -522,7 +527,8 @@ ulp_rte_pf_hdr_handler(const struct rte_flow_item *item 
__rte_unused,
}
 
/* Update the SVIF details */
-   return  ulp_rte_parser_svif_set(params, ifindex, svif_mask);
+   return ulp_rte_parser_svif_set(params, ifindex, svif_mask,
+  BNXT_ULP_DIR_INVALID);
 }
 
 /* Function to handle the parsing of RTE Flow item VF Header. */
@@ -555,39 +561,72 @@ ulp_rte_vf_hdr_handler(const struct rte_flow_item *item,
return rc;
}
/* Update the SVIF details */
-   return ulp_rte_parser_svif_set(params, ifindex, mask);
+   return ulp_rte_parser_svif_set(params, ifindex, mask,
+  BNXT_ULP_DIR_INVALID);
 }
 
-/* Function to handle the parsing of RTE Flow item port id  Header. */
+/* Parse items PORT_ID, PORT_REPRESENTOR and REPRESENTED_PORT. */
 int32_t
-ulp_rte_port_id_hdr_handler(const struct rte_flow_item *item,
-   struct ulp_rte_parser_params *params)
+ulp_rte_port_hdr_hand

[dpdk-dev] [PATCH v2 09/12] net/enic: support meta flow actions to overrule destinations

From: Andrew Rybchenko 

Add support for actions PORT_REPRESENTOR and REPRESENTED_PORT
based on the existing support for action PORT_ID.

Signed-off-by: Andrew Rybchenko 
---
 drivers/net/enic/enic_fm_flow.c | 93 ++---
 1 file changed, 75 insertions(+), 18 deletions(-)

diff --git a/drivers/net/enic/enic_fm_flow.c b/drivers/net/enic/enic_fm_flow.c
index cd364ee16b..4092ff1f61 100644
--- a/drivers/net/enic/enic_fm_flow.c
+++ b/drivers/net/enic/enic_fm_flow.c
@@ -1242,6 +1242,35 @@ vf_egress_port_id_action(struct enic_flowman *fm,
return 0;
 }
 
+static int
+enic_fm_check_transfer_dst(struct enic *enic, uint16_t dst_port_id,
+  struct rte_eth_dev **dst_dev,
+  struct rte_flow_error *error)
+{
+   struct rte_eth_dev *dev;
+
+   ENICPMD_LOG(DEBUG, "port id %u", dst_port_id);
+   if (!rte_eth_dev_is_valid_port(dst_port_id)) {
+   return rte_flow_error_set(error, EINVAL,
+   RTE_FLOW_ERROR_TYPE_ACTION,
+   NULL, "invalid port_id");
+   }
+   dev = &rte_eth_devices[dst_port_id];
+   if (!dev_is_enic(dev)) {
+   return rte_flow_error_set(error, EINVAL,
+   RTE_FLOW_ERROR_TYPE_ACTION,
+   NULL, "port_id is not enic");
+   }
+   if (enic->switch_domain_id != pmd_priv(dev)->switch_domain_id) {
+   return rte_flow_error_set(error, EINVAL,
+   RTE_FLOW_ERROR_TYPE_ACTION,
+   NULL, "destination and source ports are not in the same 
switch domain");
+   }
+
+   *dst_dev = dev;
+   return 0;
+}
+
 /* Translate flow actions to flowman TCAM entry actions */
 static int
 enic_fm_copy_action(struct enic_flowman *fm,
@@ -1446,24 +1475,10 @@ enic_fm_copy_action(struct enic_flowman *fm,
vnic_h = enic->fm_vnic_handle; /* This port */
break;
}
-   ENICPMD_LOG(DEBUG, "port id %u", port->id);
-   if (!rte_eth_dev_is_valid_port(port->id)) {
-   return rte_flow_error_set(error, EINVAL,
-   RTE_FLOW_ERROR_TYPE_ACTION,
-   NULL, "invalid port_id");
-   }
-   dev = &rte_eth_devices[port->id];
-   if (!dev_is_enic(dev)) {
-   return rte_flow_error_set(error, EINVAL,
-   RTE_FLOW_ERROR_TYPE_ACTION,
-   NULL, "port_id is not enic");
-   }
-   if (enic->switch_domain_id !=
-   pmd_priv(dev)->switch_domain_id) {
-   return rte_flow_error_set(error, EINVAL,
-   RTE_FLOW_ERROR_TYPE_ACTION,
-   NULL, "destination and source ports are 
not in the same switch domain");
-   }
+   ret = enic_fm_check_transfer_dst(enic, port->id, &dev,
+error);
+   if (ret)
+   return ret;
vnic_h = pmd_priv(dev)->fm_vnic_handle;
overlap |= PORT_ID;
/*
@@ -1560,6 +1575,48 @@ enic_fm_copy_action(struct enic_flowman *fm,
ovlan |= rte_be_to_cpu_16(vid->vlan_vid);
break;
}
+   case RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR: {
+   const struct rte_flow_action_ethdev *ethdev;
+   struct rte_eth_dev *dev;
+
+   ethdev = actions->conf;
+   ret = enic_fm_check_transfer_dst(enic, ethdev->port_id,
+&dev, error);
+   if (ret)
+   return ret;
+   vnic_h = pmd_priv(dev)->fm_vnic_handle;
+   overlap |= PORT_ID;
+   /*
+* Action PORT_REPRESENTOR implies ingress destination.
+* Noting to do. We add an implicit stree at the
+* end if needed.
+*/
+   ingress = 1;
+   break;
+   }
+   case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT: {
+   const struct rte_flow_action_ethdev *ethdev;
+   struct rte_eth_dev *dev;
+
+   if (overlap & PORT_ID) {
+   ENICPMD_LOG(DEBUG, "cannot have multiple egress 
PORT_ID actions");
+   goto unsupported;
+   }
+

[dpdk-dev] [PATCH v2 10/12] net/mlx5: support represented port flow action

From: Andrew Rybchenko 

Semantics of the existing support for action PORT_ID suggests
that support for equal action REPRESENTED_PORT be implemented.

Helper functions keep port_id suffix since action
MLX5_FLOW_ACTION_PORT_ID is still used internally.

Signed-off-by: Andrew Rybchenko 
---
 doc/guides/nics/mlx5.rst|  4 +--
 drivers/net/mlx5/mlx5_flow_dv.c | 62 ++---
 2 files changed, 52 insertions(+), 14 deletions(-)

diff --git a/doc/guides/nics/mlx5.rst b/doc/guides/nics/mlx5.rst
index bae73f42d8..b76e979f47 100644
--- a/doc/guides/nics/mlx5.rst
+++ b/doc/guides/nics/mlx5.rst
@@ -431,8 +431,8 @@ Limitations
  - yellow: NULL or END.
  - RED: DROP / END.
   - The only supported meter policy actions:
- - green: QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
- - yellow: QUEUE, RSS, PORT_ID, JUMP, DROP, MARK and SET_TAG.
+ - green: QUEUE, RSS, PORT_ID, REPRESENTED_PORT, JUMP, DROP, MARK and 
SET_TAG.
+ - yellow: QUEUE, RSS, PORT_ID, REPRESENTED_PORT, JUMP, DROP, MARK and 
SET_TAG.
  - RED: must be DROP.
   - Policy actions of RSS for green and yellow should have the same 
configuration except queues.
   - meter profile packet mode is supported.
diff --git a/drivers/net/mlx5/mlx5_flow_dv.c b/drivers/net/mlx5/mlx5_flow_dv.c
index c6370cd1d6..835cc5018c 100644
--- a/drivers/net/mlx5/mlx5_flow_dv.c
+++ b/drivers/net/mlx5/mlx5_flow_dv.c
@@ -5048,14 +5048,14 @@ flow_dv_validate_action_jump(struct rte_eth_dev *dev,
 }
 
 /*
- * Validate the port_id action.
+ * Validate action PORT_ID / REPRESENTED_PORT.
  *
  * @param[in] dev
  *   Pointer to rte_eth_dev structure.
  * @param[in] action_flags
  *   Bit-fields that holds the actions detected until now.
  * @param[in] action
- *   Port_id RTE action structure.
+ *   PORT_ID / REPRESENTED_PORT action structure.
  * @param[in] attr
  *   Attributes of flow that includes this action.
  * @param[out] error
@@ -5072,6 +5072,7 @@ flow_dv_validate_action_port_id(struct rte_eth_dev *dev,
struct rte_flow_error *error)
 {
const struct rte_flow_action_port_id *port_id;
+   const struct rte_flow_action_ethdev *ethdev;
struct mlx5_priv *act_priv;
struct mlx5_priv *dev_priv;
uint16_t port;
@@ -5080,13 +5081,13 @@ flow_dv_validate_action_port_id(struct rte_eth_dev *dev,
return rte_flow_error_set(error, ENOTSUP,
  RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
  NULL,
- "port id action is valid in transfer"
+ "port action is valid in transfer"
  " mode only");
if (!action || !action->conf)
return rte_flow_error_set(error, ENOTSUP,
  RTE_FLOW_ERROR_TYPE_ACTION_CONF,
  NULL,
- "port id action parameters must be"
+ "port action parameters must be"
  " specified");
if (action_flags & (MLX5_FLOW_FATE_ACTIONS |
MLX5_FLOW_FATE_ESWITCH_ACTIONS))
@@ -5100,13 +5101,26 @@ flow_dv_validate_action_port_id(struct rte_eth_dev *dev,
  RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
  NULL,
  "failed to obtain E-Switch info");
-   port_id = action->conf;
-   port = port_id->original ? dev->data->port_id : port_id->id;
+   switch (action->type) {
+   case RTE_FLOW_ACTION_TYPE_PORT_ID:
+   port_id = action->conf;
+   port = port_id->original ? dev->data->port_id : port_id->id;
+   break;
+   case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT:
+   ethdev = action->conf;
+   port = ethdev->port_id;
+   break;
+   default:
+   return rte_flow_error_set
+   (error, EINVAL,
+RTE_FLOW_ERROR_TYPE_ACTION, action,
+"unknown E-Switch action");
+   }
act_priv = mlx5_port_to_eswitch_info(port, false);
if (!act_priv)
return rte_flow_error_set
(error, rte_errno,
-RTE_FLOW_ERROR_TYPE_ACTION_CONF, port_id,
+RTE_FLOW_ERROR_TYPE_ACTION_CONF, action->conf,
 "failed to obtain E-Switch port id for port");
if (act_priv->domain_id != dev_priv->domain_id)
return rte_flow_error_set
@@ -5669,6 +5683,7 @@ flow_dv_validate_action_sample(uint64_t *action_flags,
++actions_n;
break;
case RTE_FLOW_ACTION_TYPE_

[dpdk-dev] [PATCH v2 11/12] net/octeontx2: support port representor flow action

From: Andrew Rybchenko 

Action PORT_ID implementation assumes ingress only. Its semantics
suggests that support for equal action PORT_REPRESENTOR be added.

Signed-off-by: Andrew Rybchenko 
---
 doc/guides/nics/octeontx2.rst   |  5 -
 drivers/net/octeontx2/otx2_flow_parse.c | 16 
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/doc/guides/nics/octeontx2.rst b/doc/guides/nics/octeontx2.rst
index e35c8116f7..eae32f0afe 100644
--- a/doc/guides/nics/octeontx2.rst
+++ b/doc/guides/nics/octeontx2.rst
@@ -403,10 +403,13 @@ Actions:
++-+
| 12 | RTE_FLOW_ACTION_TYPE_PORT_ID|
++-+
+   | 13 | RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR   |
+   ++-+
 
 .. note::
 
-   ``RTE_FLOW_ACTION_TYPE_PORT_ID`` is only supported between PF and its VFs.
+   ``RTE_FLOW_ACTION_TYPE_PORT_ID``, ``RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR``
+   are only supported between PF and its VFs.
 
 .. _table_octeontx2_supported_egress_action_types:
 
diff --git a/drivers/net/octeontx2/otx2_flow_parse.c 
b/drivers/net/octeontx2/otx2_flow_parse.c
index 63a33142a5..890c6d0719 100644
--- a/drivers/net/octeontx2/otx2_flow_parse.c
+++ b/drivers/net/octeontx2/otx2_flow_parse.c
@@ -900,7 +900,6 @@ otx2_flow_parse_actions(struct rte_eth_dev *dev,
 {
struct otx2_eth_dev *hw = dev->data->dev_private;
struct otx2_npc_flow_info *npc = &hw->npc_flow;
-   const struct rte_flow_action_port_id *port_act;
const struct rte_flow_action_count *act_count;
const struct rte_flow_action_mark *act_mark;
const struct rte_flow_action_queue *act_q;
@@ -987,9 +986,18 @@ otx2_flow_parse_actions(struct rte_eth_dev *dev,
break;
 
case RTE_FLOW_ACTION_TYPE_PORT_ID:
-   port_act = (const struct rte_flow_action_port_id *)
-   actions->conf;
-   port_id = port_act->id;
+   case RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR:
+   if (actions->type == RTE_FLOW_ACTION_TYPE_PORT_ID) {
+   const struct rte_flow_action_port_id *port_act;
+
+   port_act = actions->conf;
+   port_id = port_act->id;
+   } else {
+   const struct rte_flow_action_ethdev *ethdev_act;
+
+   ethdev_act = actions->conf;
+   port_id = ethdev_act->port_id;
+   }
if (rte_eth_dev_get_name_by_port(port_id, if_name)) {
errmsg = "Name not found for output port id";
errcode = EINVAL;
-- 
2.20.1

[dpdk-dev] [PATCH v2 12/12] net/sfc: support port representor flow item

From: Andrew Rybchenko 

Add support for item PORT_REPRESENTOR which should
be used instead of ambiguous item PORT_ID.

Signed-off-by: Andrew Rybchenko 
---
 doc/guides/nics/sfc_efx.rst |  2 ++
 drivers/net/sfc/sfc_mae.c   | 72 +
 2 files changed, 74 insertions(+)

diff --git a/doc/guides/nics/sfc_efx.rst b/doc/guides/nics/sfc_efx.rst
index 163bc2533f..9a9710325f 100644
--- a/doc/guides/nics/sfc_efx.rst
+++ b/doc/guides/nics/sfc_efx.rst
@@ -190,6 +190,8 @@ Supported actions (***non-transfer*** rules):
 
 Supported pattern items (***transfer*** rules):
 
+- PORT_REPRESENTOR (cannot repeat; conflicts with other traffic source items)
+
 - PORT_ID (cannot repeat; conflicts with other traffic source items)
 
 - PHY_PORT (cannot repeat; conflicts with other traffic source items)
diff --git a/drivers/net/sfc/sfc_mae.c b/drivers/net/sfc/sfc_mae.c
index 4b520bc619..392f6ec098 100644
--- a/drivers/net/sfc/sfc_mae.c
+++ b/drivers/net/sfc/sfc_mae.c
@@ -1100,6 +1100,66 @@ sfc_mae_rule_parse_item_port_id(const struct 
rte_flow_item *item,
return 0;
 }
 
+static int
+sfc_mae_rule_parse_item_port_representor(const struct rte_flow_item *item,
+struct sfc_flow_parse_ctx *ctx,
+struct rte_flow_error *error)
+{
+   struct sfc_mae_parse_ctx *ctx_mae = ctx->mae;
+   const struct rte_flow_item_ethdev supp_mask = {
+   .port_id = 0x,
+   };
+   const void *def_mask = &rte_flow_item_ethdev_mask;
+   const struct rte_flow_item_ethdev *spec = NULL;
+   const struct rte_flow_item_ethdev *mask = NULL;
+   efx_mport_sel_t mport_sel;
+   int rc;
+
+   if (ctx_mae->match_mport_set) {
+   return rte_flow_error_set(error, ENOTSUP,
+   RTE_FLOW_ERROR_TYPE_ITEM, item,
+   "Can't handle multiple traffic source items");
+   }
+
+   rc = sfc_flow_parse_init(item,
+(const void **)&spec, (const void **)&mask,
+(const void *)&supp_mask, def_mask,
+sizeof(struct rte_flow_item_ethdev), error);
+   if (rc != 0)
+   return rc;
+
+   if (mask->port_id != supp_mask.port_id) {
+   return rte_flow_error_set(error, EINVAL,
+   RTE_FLOW_ERROR_TYPE_ITEM, item,
+   "Bad mask in the PORT_REPRESENTOR pattern 
item");
+   }
+
+   /* If "spec" is not set, could be any port ID */
+   if (spec == NULL)
+   return 0;
+
+   rc = sfc_mae_switch_port_by_ethdev(
+   ctx_mae->sa->mae.switch_domain_id,
+   spec->port_id, &mport_sel);
+   if (rc != 0) {
+   return rte_flow_error_set(error, rc,
+   RTE_FLOW_ERROR_TYPE_ITEM, item,
+   "Can't find RTE ethdev by the port ID");
+   }
+
+   rc = efx_mae_match_spec_mport_set(ctx_mae->match_spec,
+ &mport_sel, NULL);
+   if (rc != 0) {
+   return rte_flow_error_set(error, rc,
+   RTE_FLOW_ERROR_TYPE_ITEM, item,
+   "Failed to set MPORT for the port ID");
+   }
+
+   ctx_mae->match_mport_set = B_TRUE;
+
+   return 0;
+}
+
 static int
 sfc_mae_rule_parse_item_phy_port(const struct rte_flow_item *item,
 struct sfc_flow_parse_ctx *ctx,
@@ -1995,6 +2055,18 @@ static const struct sfc_flow_item sfc_flow_items[] = {
.ctx_type = SFC_FLOW_PARSE_CTX_MAE,
.parse = sfc_mae_rule_parse_item_port_id,
},
+   {
+   .type = RTE_FLOW_ITEM_TYPE_PORT_REPRESENTOR,
+   .name = "PORT_REPRESENTOR",
+   /*
+* In terms of RTE flow, this item is a META one,
+* and its position in the pattern is don't care.
+*/
+   .prev_layer = SFC_FLOW_ITEM_ANY_LAYER,
+   .layer = SFC_FLOW_ITEM_ANY_LAYER,
+   .ctx_type = SFC_FLOW_PARSE_CTX_MAE,
+   .parse = sfc_mae_rule_parse_item_port_representor,
+   },
{
.type = RTE_FLOW_ITEM_TYPE_PHY_PORT,
.name = "PHY_PORT",
-- 
2.20.1

[dpdk-dev] [PATCH v2 08/12] net/bnxt: support meta flow actions to overrule destinations