@@ -350,7 +350,6 @@ struct logtype {
static const struct logtype logtype_strings[] = {
{RTE_LOGTYPE_EAL, "lib.eal"},
{RTE_LOGTYPE_PMD, "pmd"},
- {RTE_LOGTYPE_TABLE, "lib.table"},
{RTE_LOGTYPE_PIPELINE, "lib.pipeline"},
{RTE_LOGTYPE_CRYPTODEV, "lib.cryptodev"},
{RTE_LOGTYPE_EVENTDEV, "lib.eventdev"},
@@ -40,7 +40,7 @@ extern "C" {
/* was RTE_LOGTYPE_METER */
/* was RTE_LOGTYPE_SCHED */
/* was RTE_LOGTYPE_PORT */
-#define RTE_LOGTYPE_TABLE 14 /**< Log related to table. */
+ /* was RTE_LOGTYPE_TABLE */
#define RTE_LOGTYPE_PIPELINE 15 /**< Log related to pipeline. */
/* was RTE_LOGTYPE_MBUF */
#define RTE_LOGTYPE_CRYPTODEV 17 /**< Log related to cryptodev. */
@@ -11,6 +11,11 @@
#include "rte_table_acl.h"
+RTE_LOG_REGISTER_SUFFIX(table_logtype_acl, acl, INFO);
+#define TABLE_ACL_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_acl, \
+ "%s(): " fmt "\n", __func__, ##args)
+
#ifdef RTE_TABLE_STATS_COLLECT
#define RTE_TABLE_ACL_STATS_PKTS_IN_ADD(table, val) \
@@ -65,22 +70,20 @@ rte_table_acl_create(
/* Check input parameters */
if (p == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Invalid value for params\n", __func__);
+ TABLE_ACL_LOG(ERR, "Invalid value for params");
return NULL;
}
if (p->name == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Invalid value for name\n", __func__);
+ TABLE_ACL_LOG(ERR, "Invalid value for name");
return NULL;
}
if (p->n_rules == 0) {
- RTE_LOG(ERR, TABLE, "%s: Invalid value for n_rules\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "Invalid value for n_rules");
return NULL;
}
if ((p->n_rule_fields == 0) ||
(p->n_rule_fields > RTE_ACL_MAX_FIELDS)) {
- RTE_LOG(ERR, TABLE, "%s: Invalid value for n_rule_fields\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "Invalid value for n_rule_fields");
return NULL;
}
@@ -98,9 +101,7 @@ rte_table_acl_create(
acl = rte_zmalloc_socket("TABLE", total_size, RTE_CACHE_LINE_SIZE,
socket_id);
if (acl == NULL) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot allocate %u bytes for ACL table\n",
- __func__, total_size);
+ TABLE_ACL_LOG(ERR,"Cannot allocate %u bytes for ACL table", total_size);
return NULL;
}
@@ -140,7 +141,7 @@ rte_table_acl_free(void *table)
/* Check input parameters */
if (table == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -164,8 +165,7 @@ rte_table_acl_build(struct rte_table_acl *acl, struct rte_acl_ctx **acl_ctx)
/* Create low level ACL table */
ctx = rte_acl_create(&acl->acl_params);
if (ctx == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Cannot create low level ACL table\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "Cannot create low level ACL table");
return -1;
}
@@ -176,9 +176,7 @@ rte_table_acl_build(struct rte_table_acl *acl, struct rte_acl_ctx **acl_ctx)
status = rte_acl_add_rules(ctx, acl->acl_rule_list[i],
1);
if (status != 0) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot add rule to low level ACL table\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "Cannot add rule to low level ACL table");
rte_acl_free(ctx);
return -1;
}
@@ -196,9 +194,7 @@ rte_table_acl_build(struct rte_table_acl *acl, struct rte_acl_ctx **acl_ctx)
/* Build low level ACl table */
status = rte_acl_build(ctx, &acl->cfg);
if (status != 0) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot build the low level ACL table\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "Cannot build the low level ACL table");
rte_acl_free(ctx);
return -1;
}
@@ -226,29 +222,27 @@ rte_table_acl_entry_add(
/* Check input parameters */
if (table == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
if (key == NULL) {
- RTE_LOG(ERR, TABLE, "%s: key parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "key parameter is NULL");
return -EINVAL;
}
if (entry == NULL) {
- RTE_LOG(ERR, TABLE, "%s: entry parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "entry parameter is NULL");
return -EINVAL;
}
if (key_found == NULL) {
- RTE_LOG(ERR, TABLE, "%s: key_found parameter is NULL\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "key_found parameter is NULL");
return -EINVAL;
}
if (entry_ptr == NULL) {
- RTE_LOG(ERR, TABLE, "%s: entry_ptr parameter is NULL\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "entry_ptr parameter is NULL");
return -EINVAL;
}
if (rule->priority > RTE_ACL_MAX_PRIORITY) {
- RTE_LOG(ERR, TABLE, "%s: Priority is too high\n", __func__);
+ TABLE_ACL_LOG(ERR, "Priority is too high");
return -EINVAL;
}
@@ -291,8 +285,7 @@ rte_table_acl_entry_add(
/* Return if max rules */
if (free_pos_valid == 0) {
- RTE_LOG(ERR, TABLE, "%s: Max number of rules reached\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "Max number of rules reached");
return -ENOSPC;
}
@@ -342,16 +335,15 @@ rte_table_acl_entry_delete(
/* Check input parameters */
if (table == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
if (key == NULL) {
- RTE_LOG(ERR, TABLE, "%s: key parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "key parameter is NULL");
return -EINVAL;
}
if (key_found == NULL) {
- RTE_LOG(ERR, TABLE, "%s: key_found parameter is NULL\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "key_found parameter is NULL");
return -EINVAL;
}
@@ -424,29 +416,27 @@ rte_table_acl_entry_add_bulk(
/* Check input parameters */
if (table == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
if (keys == NULL) {
- RTE_LOG(ERR, TABLE, "%s: keys parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "keys parameter is NULL");
return -EINVAL;
}
if (entries == NULL) {
- RTE_LOG(ERR, TABLE, "%s: entries parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "entries parameter is NULL");
return -EINVAL;
}
if (n_keys == 0) {
- RTE_LOG(ERR, TABLE, "%s: 0 rules to add\n", __func__);
+ TABLE_ACL_LOG(ERR, "0 rules to add");
return -EINVAL;
}
if (key_found == NULL) {
- RTE_LOG(ERR, TABLE, "%s: key_found parameter is NULL\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "key_found parameter is NULL");
return -EINVAL;
}
if (entries_ptr == NULL) {
- RTE_LOG(ERR, TABLE, "%s: entries_ptr parameter is NULL\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "entries_ptr parameter is NULL");
return -EINVAL;
}
@@ -455,20 +445,18 @@ rte_table_acl_entry_add_bulk(
struct rte_table_acl_rule_add_params *rule;
if (keys[i] == NULL) {
- RTE_LOG(ERR, TABLE, "%s: keys[%" PRIu32 "] parameter is NULL\n",
- __func__, i);
+ TABLE_ACL_LOG(ERR, "keys[%" PRIu32 "] parameter is NULL\n", i);
return -EINVAL;
}
if (entries[i] == NULL) {
- RTE_LOG(ERR, TABLE, "%s: entries[%" PRIu32 "] parameter is NULL\n",
- __func__, i);
+ TABLE_ACL_LOG(ERR, "entries[%" PRIu32 "] parameter is NULL\n", i);
return -EINVAL;
}
rule = keys[i];
if (rule->priority > RTE_ACL_MAX_PRIORITY) {
- RTE_LOG(ERR, TABLE, "%s: Priority is too high\n", __func__);
+ TABLE_ACL_LOG(ERR, "Priority is too high");
return -EINVAL;
}
}
@@ -604,27 +592,25 @@ rte_table_acl_entry_delete_bulk(
/* Check input parameters */
if (table == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
if (keys == NULL) {
- RTE_LOG(ERR, TABLE, "%s: key parameter is NULL\n", __func__);
+ TABLE_ACL_LOG(ERR, "key parameter is NULL");
return -EINVAL;
}
if (n_keys == 0) {
- RTE_LOG(ERR, TABLE, "%s: 0 rules to delete\n", __func__);
+ TABLE_ACL_LOG(ERR, "0 rules to delete");
return -EINVAL;
}
if (key_found == NULL) {
- RTE_LOG(ERR, TABLE, "%s: key_found parameter is NULL\n",
- __func__);
+ TABLE_ACL_LOG(ERR, "key_found parameter is NULL");
return -EINVAL;
}
for (i = 0; i < n_keys; i++) {
if (keys[i] == NULL) {
- RTE_LOG(ERR, TABLE, "%s: keys[%" PRIu32 "] parameter is NULL\n",
- __func__, i);
+ TABLE_ACL_LOG(ERR, "keys[%" PRIu32 "] parameter is NULL", i);
return -EINVAL;
}
}
@@ -11,6 +11,11 @@
#include "rte_table_array.h"
+RTE_LOG_REGISTER_SUFFIX(table_logtype_array, array, INFO);
+#define TABLE_ARRAY_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_array, \
+ "%s(): " fmt "\n", __func__, ##args)
+
#ifdef RTE_TABLE_STATS_COLLECT
#define RTE_TABLE_ARRAY_STATS_PKTS_IN_ADD(table, val) \
@@ -61,9 +66,7 @@ rte_table_array_create(void *params, int socket_id, uint32_t entry_size)
total_size = total_cl_size * RTE_CACHE_LINE_SIZE;
t = rte_zmalloc_socket("TABLE", total_size, RTE_CACHE_LINE_SIZE, socket_id);
if (t == NULL) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot allocate %u bytes for array table\n",
- __func__, total_size);
+ TABLE_ARRAY_LOG(ERR, "Cannot allocate %u bytes for array table\n", total_size);
return NULL;
}
@@ -83,7 +86,7 @@ rte_table_array_free(void *table)
/* Check input parameters */
if (t == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_ARRAY_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -107,25 +110,23 @@ rte_table_array_entry_add(
/* Check input parameters */
if (table == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_ARRAY_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
if (key == NULL) {
- RTE_LOG(ERR, TABLE, "%s: key parameter is NULL\n", __func__);
+ TABLE_ARRAY_LOG(ERR, "key parameter is NULL");
return -EINVAL;
}
if (entry == NULL) {
- RTE_LOG(ERR, TABLE, "%s: entry parameter is NULL\n", __func__);
+ TABLE_ARRAY_LOG(ERR, "entry parameter is NULL");
return -EINVAL;
}
if (key_found == NULL) {
- RTE_LOG(ERR, TABLE, "%s: key_found parameter is NULL\n",
- __func__);
+ TABLE_ARRAY_LOG(ERR, "key_found parameter is NULL");
return -EINVAL;
}
if (entry_ptr == NULL) {
- RTE_LOG(ERR, TABLE, "%s: entry_ptr parameter is NULL\n",
- __func__);
+ TABLE_ARRAY_LOG(ERR, "entry_ptr parameter is NULL");
return -EINVAL;
}
@@ -10,6 +10,11 @@
#include "rte_table_hash_cuckoo.h"
+RTE_LOG_REGISTER_SUFFIX(table_logtype_hash, hash, INFO);
+#define TABLE_HASH_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_hash, \
+ "%s(): " fmt "\n", __func__, ##args)
+
#ifdef RTE_TABLE_STATS_COLLECT
#define RTE_TABLE_HASH_CUCKOO_STATS_PKTS_IN_ADD(table, val) \
@@ -47,27 +52,27 @@ static int
check_params_create_hash_cuckoo(struct rte_table_hash_cuckoo_params *params)
{
if (params == NULL) {
- RTE_LOG(ERR, TABLE, "NULL Input Parameters.\n");
+ TABLE_HASH_LOG(ERR, "NULL Input Parameters.");
return -EINVAL;
}
if (params->name == NULL) {
- RTE_LOG(ERR, TABLE, "Table name is NULL.\n");
+ TABLE_HASH_LOG(ERR, "Table name is NULL.");
return -EINVAL;
}
if (params->key_size == 0) {
- RTE_LOG(ERR, TABLE, "Invalid key_size.\n");
+ TABLE_HASH_LOG(ERR, "Invalid key_size.");
return -EINVAL;
}
if (params->n_keys == 0) {
- RTE_LOG(ERR, TABLE, "Invalid n_keys.\n");
+ TABLE_HASH_LOG(ERR, "Invalid n_keys.");
return -EINVAL;
}
if (params->f_hash == NULL) {
- RTE_LOG(ERR, TABLE, "f_hash is NULL.\n");
+ TABLE_HASH_LOG(ERR, "f_hash is NULL.");
return -EINVAL;
}
@@ -94,9 +99,8 @@ rte_table_hash_cuckoo_create(void *params,
t = rte_zmalloc_socket(p->name, total_size, RTE_CACHE_LINE_SIZE, socket_id);
if (t == NULL) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot allocate %u bytes for cuckoo hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH_LOG(ERR, "Cannot allocate %u bytes for cuckoo hash table %s",
+ total_size, p->name);
return NULL;
}
@@ -114,9 +118,8 @@ rte_table_hash_cuckoo_create(void *params,
if (h_table == NULL) {
h_table = rte_hash_create(&hash_cuckoo_params);
if (h_table == NULL) {
- RTE_LOG(ERR, TABLE,
- "%s: failed to create cuckoo hash table %s\n",
- __func__, p->name);
+ TABLE_HASH_LOG(ERR, "failed to create cuckoo hash table %s",
+ p->name);
rte_free(t);
return NULL;
}
@@ -131,9 +134,8 @@ rte_table_hash_cuckoo_create(void *params,
t->key_offset = p->key_offset;
t->h_table = h_table;
- RTE_LOG(INFO, TABLE,
- "%s: Cuckoo hash table %s memory footprint is %u bytes\n",
- __func__, p->name, total_size);
+ TABLE_HASH_LOG(INFO, "Cuckoo hash table %s memory footprint is %u bytes",
+ p->name, total_size);
return t;
}
@@ -11,6 +11,11 @@
#include "rte_table_hash.h"
+RTE_LOG_REGISTER_SUFFIX(table_logtype_hash_ext, hash.ext, INFO);
+#define TABLE_HASH_EXT_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_hash_ext, \
+ "%s(): " fmt "\n", __func__, ##args)
+
#define KEYS_PER_BUCKET 4
struct bucket {
@@ -128,33 +133,33 @@ check_params_create(struct rte_table_hash_params *params)
{
/* name */
if (params->name == NULL) {
- RTE_LOG(ERR, TABLE, "%s: name invalid value\n", __func__);
+ TABLE_HASH_EXT_LOG(ERR, "name invalid value");
return -EINVAL;
}
/* key_size */
if ((params->key_size < sizeof(uint64_t)) ||
(!rte_is_power_of_2(params->key_size))) {
- RTE_LOG(ERR, TABLE, "%s: key_size invalid value\n", __func__);
+ TABLE_HASH_EXT_LOG(ERR, "key_size invalid value");
return -EINVAL;
}
/* n_keys */
if (params->n_keys == 0) {
- RTE_LOG(ERR, TABLE, "%s: n_keys invalid value\n", __func__);
+ TABLE_HASH_EXT_LOG(ERR, "n_keys invalid value");
return -EINVAL;
}
/* n_buckets */
if ((params->n_buckets == 0) ||
(!rte_is_power_of_2(params->n_buckets))) {
- RTE_LOG(ERR, TABLE, "%s: n_buckets invalid value\n", __func__);
+ TABLE_HASH_EXT_LOG(ERR, "n_buckets invalid value");
return -EINVAL;
}
/* f_hash */
if (params->f_hash == NULL) {
- RTE_LOG(ERR, TABLE, "%s: f_hash invalid value\n", __func__);
+ TABLE_HASH_EXT_LOG(ERR, "f_hash invalid value");
return -EINVAL;
}
@@ -211,9 +216,9 @@ rte_table_hash_ext_create(void *params, int socket_id, uint32_t entry_size)
key_sz + key_stack_sz + bkt_ext_stack_sz + data_sz;
if (total_size > SIZE_MAX) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes"
- " for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH_EXT_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
@@ -222,14 +227,15 @@ rte_table_hash_ext_create(void *params, int socket_id, uint32_t entry_size)
RTE_CACHE_LINE_SIZE,
socket_id);
if (t == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes"
- " for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH_EXT_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
- RTE_LOG(INFO, TABLE, "%s (%u-byte key): Hash table %s memory "
- "footprint is %" PRIu64 " bytes\n",
- __func__, p->key_size, p->name, total_size);
+
+ TABLE_HASH_EXT_LOG(INFO,
+ "(%u-byte key): Hash table %s memory footprint is %" PRIu64 " bytes",
+ p->key_size, p->name, total_size);
/* Memory initialization */
t->key_size = p->key_size;
@@ -11,6 +11,11 @@
#include "rte_table_hash.h"
#include "rte_lru.h"
+RTE_LOG_REGISTER_SUFFIX(table_logtype_hash16, hash16, INFO);
+#define TABLE_HASH16_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_hash16, \
+ "%s(): " fmt "\n", __func__, ##args)
+
#define KEY_SIZE 16
#define KEYS_PER_BUCKET 4
@@ -107,33 +112,32 @@ check_params_create(struct rte_table_hash_params *params)
{
/* name */
if (params->name == NULL) {
- RTE_LOG(ERR, TABLE, "%s: name invalid value\n", __func__);
+ TABLE_HASH16_LOG(ERR, "name invalid value");
return -EINVAL;
}
/* key_size */
if (params->key_size != KEY_SIZE) {
- RTE_LOG(ERR, TABLE, "%s: key_size invalid value\n", __func__);
+ TABLE_HASH16_LOG(ERR, "key_size invalid value");
return -EINVAL;
}
/* n_keys */
if (params->n_keys == 0) {
- RTE_LOG(ERR, TABLE, "%s: n_keys is zero\n", __func__);
+ TABLE_HASH16_LOG(ERR, "n_keys is zero");
return -EINVAL;
}
/* n_buckets */
if ((params->n_buckets == 0) ||
(!rte_is_power_of_2(params->n_buckets))) {
- RTE_LOG(ERR, TABLE, "%s: n_buckets invalid value\n", __func__);
+ TABLE_HASH16_LOG(ERR, "n_buckets invalid value");
return -EINVAL;
}
/* f_hash */
if (params->f_hash == NULL) {
- RTE_LOG(ERR, TABLE, "%s: f_hash function pointer is NULL\n",
- __func__);
+ TABLE_HASH16_LOG(ERR, "f_hash function pointer is NULL");
return -EINVAL;
}
@@ -181,9 +185,9 @@ rte_table_hash_create_key16_lru(void *params,
total_size = sizeof(struct rte_table_hash) + n_buckets * bucket_size;
if (total_size > SIZE_MAX) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH16_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
@@ -192,14 +196,14 @@ rte_table_hash_create_key16_lru(void *params,
RTE_CACHE_LINE_SIZE,
socket_id);
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH16_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
- RTE_LOG(INFO, TABLE, "%s: Hash table %s memory footprint "
- "is %" PRIu64 " bytes\n",
- __func__, p->name, total_size);
+ TABLE_HASH16_LOG(INFO,
+ "Hash table %s memory footprint is %" PRIu64 " bytes",
+ p->name, total_size);
/* Memory initialization */
f->n_buckets = n_buckets;
@@ -236,7 +240,7 @@ rte_table_hash_free_key16_lru(void *table)
/* Check input parameters */
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_HASH16_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -391,9 +395,9 @@ rte_table_hash_create_key16_ext(void *params,
total_size = sizeof(struct rte_table_hash) +
(p->n_buckets + n_buckets_ext) * bucket_size + stack_size;
if (total_size > SIZE_MAX) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH16_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
@@ -402,14 +406,14 @@ rte_table_hash_create_key16_ext(void *params,
RTE_CACHE_LINE_SIZE,
socket_id);
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH16_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
- RTE_LOG(INFO, TABLE, "%s: Hash table %s memory footprint "
- "is %" PRIu64 " bytes\n",
- __func__, p->name, total_size);
+ TABLE_HASH16_LOG(INFO,
+ "Hash table %s memory footprint is %" PRIu64 " bytes",
+ p->name, total_size);
/* Memory initialization */
f->n_buckets = p->n_buckets;
@@ -446,7 +450,7 @@ rte_table_hash_free_key16_ext(void *table)
/* Check input parameters */
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_HASH16_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -11,11 +11,16 @@
#include "rte_table_hash.h"
#include "rte_lru.h"
-#define KEY_SIZE 32
+RTE_LOG_REGISTER_SUFFIX(table_logtype_hash32, hash32, INFO);
+#define TABLE_HASH32_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_hash32, \
+ "%s(): " fmt "\n", __func__, ##args)
+
+#define KEY_SIZE 32
#define KEYS_PER_BUCKET 4
-#define RTE_BUCKET_ENTRY_VALID 0x1LLU
+#define RTE_BUCKET_ENTRY_VALID 0x1LLU
#ifdef RTE_TABLE_STATS_COLLECT
@@ -111,33 +116,32 @@ check_params_create(struct rte_table_hash_params *params)
{
/* name */
if (params->name == NULL) {
- RTE_LOG(ERR, TABLE, "%s: name invalid value\n", __func__);
+ TABLE_HASH32_LOG(ERR, "name invalid value");
return -EINVAL;
}
/* key_size */
if (params->key_size != KEY_SIZE) {
- RTE_LOG(ERR, TABLE, "%s: key_size invalid value\n", __func__);
+ TABLE_HASH32_LOG(ERR, "key_size invalid value");
return -EINVAL;
}
/* n_keys */
if (params->n_keys == 0) {
- RTE_LOG(ERR, TABLE, "%s: n_keys is zero\n", __func__);
+ TABLE_HASH32_LOG(ERR, "n_keys is zero");
return -EINVAL;
}
/* n_buckets */
if ((params->n_buckets == 0) ||
(!rte_is_power_of_2(params->n_buckets))) {
- RTE_LOG(ERR, TABLE, "%s: n_buckets invalid value\n", __func__);
+ TABLE_HASH32_LOG(ERR, "n_buckets invalid value");
return -EINVAL;
}
/* f_hash */
if (params->f_hash == NULL) {
- RTE_LOG(ERR, TABLE, "%s: f_hash function pointer is NULL\n",
- __func__);
+ TABLE_HASH32_LOG(ERR, "f_hash function pointer is NULL");
return -EINVAL;
}
@@ -184,9 +188,9 @@ rte_table_hash_create_key32_lru(void *params,
KEYS_PER_BUCKET * entry_size);
total_size = sizeof(struct rte_table_hash) + n_buckets * bucket_size;
if (total_size > SIZE_MAX) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH32_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
@@ -195,15 +199,14 @@ rte_table_hash_create_key32_lru(void *params,
RTE_CACHE_LINE_SIZE,
socket_id);
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH32_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
- RTE_LOG(INFO, TABLE,
- "%s: Hash table %s memory footprint "
- "is %" PRIu64 " bytes\n",
- __func__, p->name, total_size);
+ TABLE_HASH32_LOG(INFO,
+ "Hash table %s memory footprint is %" PRIu64 " bytes",
+ p->name, total_size);
/* Memory initialization */
f->n_buckets = n_buckets;
@@ -244,7 +247,7 @@ rte_table_hash_free_key32_lru(void *table)
/* Check input parameters */
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_HASH32_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -400,9 +403,9 @@ rte_table_hash_create_key32_ext(void *params,
total_size = sizeof(struct rte_table_hash) +
(p->n_buckets + n_buckets_ext) * bucket_size + stack_size;
if (total_size > SIZE_MAX) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH32_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
@@ -411,15 +414,14 @@ rte_table_hash_create_key32_ext(void *params,
RTE_CACHE_LINE_SIZE,
socket_id);
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH32_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
- RTE_LOG(INFO, TABLE,
- "%s: Hash table %s memory footprint "
- "is %" PRIu64" bytes\n",
- __func__, p->name, total_size);
+ TABLE_HASH32_LOG(INFO,
+ "Hash table %s memory footprint is %" PRIu64" bytes",
+ p->name, total_size);
/* Memory initialization */
f->n_buckets = p->n_buckets;
@@ -460,7 +462,7 @@ rte_table_hash_free_key32_ext(void *table)
/* Check input parameters */
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_HASH32_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -11,7 +11,12 @@
#include "rte_table_hash.h"
#include "rte_lru.h"
-#define KEY_SIZE 8
+RTE_LOG_REGISTER_SUFFIX(table_logtype_hash8, hash8, INFO);
+#define TABLE_HASH8_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_hash8, \
+ "%s(): " fmt "\n", __func__, ##args)
+
+#define KEY_SIZE 8
#define KEYS_PER_BUCKET 4
@@ -101,33 +106,32 @@ check_params_create(struct rte_table_hash_params *params)
{
/* name */
if (params->name == NULL) {
- RTE_LOG(ERR, TABLE, "%s: name invalid value\n", __func__);
+ TABLE_HASH8_LOG(ERR, "name invalid value");
return -EINVAL;
}
/* key_size */
if (params->key_size != KEY_SIZE) {
- RTE_LOG(ERR, TABLE, "%s: key_size invalid value\n", __func__);
+ TABLE_HASH8_LOG(ERR, "key_size invalid value");
return -EINVAL;
}
/* n_keys */
if (params->n_keys == 0) {
- RTE_LOG(ERR, TABLE, "%s: n_keys is zero\n", __func__);
+ TABLE_HASH8_LOG(ERR, "n_keys is zero");
return -EINVAL;
}
/* n_buckets */
if ((params->n_buckets == 0) ||
(!rte_is_power_of_2(params->n_buckets))) {
- RTE_LOG(ERR, TABLE, "%s: n_buckets invalid value\n", __func__);
+ TABLE_HASH8_LOG(ERR, "n_buckets invalid value");
return -EINVAL;
}
/* f_hash */
if (params->f_hash == NULL) {
- RTE_LOG(ERR, TABLE, "%s: f_hash function pointer is NULL\n",
- __func__);
+ TABLE_HASH8_LOG(ERR, "f_hash function pointer is NULL");
return -EINVAL;
}
@@ -173,9 +177,9 @@ rte_table_hash_create_key8_lru(void *params, int socket_id, uint32_t entry_size)
total_size = sizeof(struct rte_table_hash) + n_buckets * bucket_size;
if (total_size > SIZE_MAX) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes"
- " for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH8_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
@@ -184,15 +188,15 @@ rte_table_hash_create_key8_lru(void *params, int socket_id, uint32_t entry_size)
RTE_CACHE_LINE_SIZE,
socket_id);
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes"
- " for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH8_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
- RTE_LOG(INFO, TABLE, "%s: Hash table %s memory footprint "
- "is %" PRIu64 " bytes\n",
- __func__, p->name, total_size);
+ TABLE_HASH8_LOG(INFO,
+ "Hash table %s memory footprint is %" PRIu64 " bytes",
+ p->name, total_size);
/* Memory initialization */
f->n_buckets = n_buckets;
@@ -226,7 +230,7 @@ rte_table_hash_free_key8_lru(void *table)
/* Check input parameters */
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_HASH8_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -377,9 +381,9 @@ rte_table_hash_create_key8_ext(void *params, int socket_id, uint32_t entry_size)
(p->n_buckets + n_buckets_ext) * bucket_size + stack_size;
if (total_size > SIZE_MAX) {
- RTE_LOG(ERR, TABLE, "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH8_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
@@ -388,15 +392,14 @@ rte_table_hash_create_key8_ext(void *params, int socket_id, uint32_t entry_size)
RTE_CACHE_LINE_SIZE,
socket_id);
if (f == NULL) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot allocate %" PRIu64 " bytes "
- "for hash table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH8_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
- RTE_LOG(INFO, TABLE, "%s: Hash table %s memory footprint "
- "is %" PRIu64 " bytes\n",
- __func__, p->name, total_size);
+ TABLE_HASH8_LOG(INFO,
+ "Hash table %s memory footprint is %" PRIu64 " bytes",
+ p->name, total_size);
/* Memory initialization */
f->n_buckets = p->n_buckets;
@@ -430,7 +433,7 @@ rte_table_hash_free_key8_ext(void *table)
/* Check input parameters */
if (f == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_HASH8_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -14,6 +14,11 @@
#define KEYS_PER_BUCKET 4
+RTE_LOG_REGISTER_SUFFIX(table_logtype_hash_lru, hash.lru, INFO);
+#define TABLE_HASH_LRU_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_hash_lru, \
+ "%s(): " fmt "\n", __func__, ##args)
+
#ifdef RTE_TABLE_STATS_COLLECT
#define RTE_TABLE_HASH_LRU_STATS_PKTS_IN_ADD(table, val) \
@@ -105,33 +110,33 @@ check_params_create(struct rte_table_hash_params *params)
{
/* name */
if (params->name == NULL) {
- RTE_LOG(ERR, TABLE, "%s: name invalid value\n", __func__);
+ TABLE_HASH_LRU_LOG(ERR, "name invalid value");
return -EINVAL;
}
/* key_size */
if ((params->key_size < sizeof(uint64_t)) ||
(!rte_is_power_of_2(params->key_size))) {
- RTE_LOG(ERR, TABLE, "%s: key_size invalid value\n", __func__);
+ TABLE_HASH_LRU_LOG(ERR, "key_size invalid value");
return -EINVAL;
}
/* n_keys */
if (params->n_keys == 0) {
- RTE_LOG(ERR, TABLE, "%s: n_keys invalid value\n", __func__);
+ TABLE_HASH_LRU_LOG(ERR, "n_keys invalid value");
return -EINVAL;
}
/* n_buckets */
if ((params->n_buckets == 0) ||
(!rte_is_power_of_2(params->n_buckets))) {
- RTE_LOG(ERR, TABLE, "%s: n_buckets invalid value\n", __func__);
+ TABLE_HASH_LRU_LOG(ERR, "n_buckets invalid value");
return -EINVAL;
}
/* f_hash */
if (params->f_hash == NULL) {
- RTE_LOG(ERR, TABLE, "%s: f_hash invalid value\n", __func__);
+ TABLE_HASH_LRU_LOG(ERR, "f_hash invalid value");
return -EINVAL;
}
@@ -187,10 +192,9 @@ rte_table_hash_lru_create(void *params, int socket_id, uint32_t entry_size)
key_stack_sz + data_sz;
if (total_size > SIZE_MAX) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot allocate %" PRIu64 " bytes for hash "
- "table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH_LRU_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
@@ -199,15 +203,14 @@ rte_table_hash_lru_create(void *params, int socket_id, uint32_t entry_size)
RTE_CACHE_LINE_SIZE,
socket_id);
if (t == NULL) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot allocate %" PRIu64 " bytes for hash "
- "table %s\n",
- __func__, total_size, p->name);
+ TABLE_HASH_LRU_LOG(ERR,
+ "Cannot allocate %" PRIu64 " bytes for hash table %s",
+ total_size, p->name);
return NULL;
}
- RTE_LOG(INFO, TABLE, "%s (%u-byte key): Hash table %s memory footprint"
- " is %" PRIu64 " bytes\n",
- __func__, p->key_size, p->name, total_size);
+ TABLE_HASH_LRU_LOG(INFO,
+ "(%u-byte key): Hash table %s memory footprint is %" PRIu64 " bytes",
+ p->key_size, p->name, total_size);
/* Memory initialization */
t->key_size = p->key_size;
@@ -13,6 +13,11 @@
#include "rte_table_lpm.h"
+RTE_LOG_REGISTER_SUFFIX(table_logtype_lpm, lpm, INFO);
+#define TABLE_LPM_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_lpm, \
+ "%s(): " fmt "\n", __func__, ##args)
+
#ifndef RTE_TABLE_LPM_MAX_NEXT_HOPS
#define RTE_TABLE_LPM_MAX_NEXT_HOPS 65536
#endif
@@ -59,30 +64,27 @@ rte_table_lpm_create(void *params, int socket_id, uint32_t entry_size)
/* Check input parameters */
if (p == NULL) {
- RTE_LOG(ERR, TABLE, "%s: NULL input parameters\n", __func__);
+ TABLE_LPM_LOG(ERR, "NULL input parameters");
return NULL;
}
if (p->n_rules == 0) {
- RTE_LOG(ERR, TABLE, "%s: Invalid n_rules\n", __func__);
+ TABLE_LPM_LOG(ERR, "Invalid n_rules");
return NULL;
}
if (p->number_tbl8s == 0) {
- RTE_LOG(ERR, TABLE, "%s: Invalid number_tbl8s\n", __func__);
+ TABLE_LPM_LOG(ERR, "Invalid number_tbl8s");
return NULL;
}
if (p->entry_unique_size == 0) {
- RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n",
- __func__);
+ TABLE_LPM_LOG(ERR, "Invalid entry_unique_size");
return NULL;
}
if (p->entry_unique_size > entry_size) {
- RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n",
- __func__);
+ TABLE_LPM_LOG(ERR, "Invalid entry_unique_size");
return NULL;
}
if (p->name == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Table name is NULL\n",
- __func__);
+ TABLE_LPM_LOG(ERR, "Table name is NULL");
return NULL;
}
entry_size = RTE_ALIGN(entry_size, sizeof(uint64_t));
@@ -93,9 +95,8 @@ rte_table_lpm_create(void *params, int socket_id, uint32_t entry_size)
lpm = rte_zmalloc_socket("TABLE", total_size, RTE_CACHE_LINE_SIZE,
socket_id);
if (lpm == NULL) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot allocate %u bytes for LPM table\n",
- __func__, total_size);
+ TABLE_LPM_LOG(ERR, "Cannot allocate %u bytes for LPM table",
+ total_size);
return NULL;
}
@@ -107,7 +108,7 @@ rte_table_lpm_create(void *params, int socket_id, uint32_t entry_size)
if (lpm->lpm == NULL) {
rte_free(lpm);
- RTE_LOG(ERR, TABLE, "Unable to create low-level LPM table\n");
+ TABLE_LPM_LOG(ERR, "Unable to create low-level LPM table");
return NULL;
}
@@ -127,7 +128,7 @@ rte_table_lpm_free(void *table)
/* Check input parameters */
if (lpm == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_LPM_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -187,22 +188,20 @@ rte_table_lpm_entry_add(
/* Check input parameters */
if (lpm == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_LPM_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
if (ip_prefix == NULL) {
- RTE_LOG(ERR, TABLE, "%s: ip_prefix parameter is NULL\n",
- __func__);
+ TABLE_LPM_LOG(ERR, "ip_prefix parameter is NULL");
return -EINVAL;
}
if (entry == NULL) {
- RTE_LOG(ERR, TABLE, "%s: entry parameter is NULL\n", __func__);
+ TABLE_LPM_LOG(ERR, "entry parameter is NULL");
return -EINVAL;
}
if ((ip_prefix->depth == 0) || (ip_prefix->depth > 32)) {
- RTE_LOG(ERR, TABLE, "%s: invalid depth (%d)\n",
- __func__, ip_prefix->depth);
+ TABLE_LPM_LOG(ERR, "invalid depth (%d)", ip_prefix->depth);
return -EINVAL;
}
@@ -216,7 +215,7 @@ rte_table_lpm_entry_add(
uint8_t *nht_entry;
if (nht_find_free(lpm, &nht_pos) == 0) {
- RTE_LOG(ERR, TABLE, "%s: NHT full\n", __func__);
+ TABLE_LPM_LOG(ERR, "NHT full");
return -1;
}
@@ -226,7 +225,7 @@ rte_table_lpm_entry_add(
/* Add rule to low level LPM table */
if (rte_lpm_add(lpm->lpm, ip_prefix->ip, ip_prefix->depth, nht_pos) < 0) {
- RTE_LOG(ERR, TABLE, "%s: LPM rule add failed\n", __func__);
+ TABLE_LPM_LOG(ERR, "LPM rule add failed");
return -1;
}
@@ -253,16 +252,15 @@ rte_table_lpm_entry_delete(
/* Check input parameters */
if (lpm == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_LPM_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
if (ip_prefix == NULL) {
- RTE_LOG(ERR, TABLE, "%s: ip_prefix parameter is NULL\n",
- __func__);
+ TABLE_LPM_LOG(ERR, "ip_prefix parameter is NULL");
return -EINVAL;
}
if ((ip_prefix->depth == 0) || (ip_prefix->depth > 32)) {
- RTE_LOG(ERR, TABLE, "%s: invalid depth (%d)\n", __func__,
+ TABLE_LPM_LOG(ERR, "invalid depth (%d)",
ip_prefix->depth);
return -EINVAL;
}
@@ -271,7 +269,7 @@ rte_table_lpm_entry_delete(
status = rte_lpm_is_rule_present(lpm->lpm, ip_prefix->ip,
ip_prefix->depth, &nht_pos);
if (status < 0) {
- RTE_LOG(ERR, TABLE, "%s: LPM algorithmic error\n", __func__);
+ TABLE_LPM_LOG(ERR, "LPM algorithmic error");
return -1;
}
if (status == 0) {
@@ -282,7 +280,7 @@ rte_table_lpm_entry_delete(
/* Delete rule from the low-level LPM table */
status = rte_lpm_delete(lpm->lpm, ip_prefix->ip, ip_prefix->depth);
if (status) {
- RTE_LOG(ERR, TABLE, "%s: LPM rule delete failed\n", __func__);
+ TABLE_LPM_LOG(ERR, "LPM rule delete failed");
return -1;
}
@@ -12,6 +12,11 @@
#include "rte_table_lpm_ipv6.h"
+RTE_LOG_REGISTER_SUFFIX(table_logtype_lpm6, lpm6, INFO);
+#define TABLE_LPM6_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_lpm6, \
+ "%s(): " fmt "\n", __func__, ##args)
+
#define RTE_TABLE_LPM_MAX_NEXT_HOPS 256
#ifdef RTE_TABLE_STATS_COLLECT
@@ -56,30 +61,27 @@ rte_table_lpm_ipv6_create(void *params, int socket_id, uint32_t entry_size)
/* Check input parameters */
if (p == NULL) {
- RTE_LOG(ERR, TABLE, "%s: NULL input parameters\n", __func__);
+ TABLE_LPM6_LOG(ERR, "NULL input parameters");
return NULL;
}
if (p->n_rules == 0) {
- RTE_LOG(ERR, TABLE, "%s: Invalid n_rules\n", __func__);
+ TABLE_LPM6_LOG(ERR, "Invalid n_rules");
return NULL;
}
if (p->number_tbl8s == 0) {
- RTE_LOG(ERR, TABLE, "%s: Invalid n_rules\n", __func__);
+ TABLE_LPM6_LOG(ERR, "Invalid n_rules");
return NULL;
}
if (p->entry_unique_size == 0) {
- RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n",
- __func__);
+ TABLE_LPM6_LOG(ERR, "Invalid entry_unique_size");
return NULL;
}
if (p->entry_unique_size > entry_size) {
- RTE_LOG(ERR, TABLE, "%s: Invalid entry_unique_size\n",
- __func__);
+ TABLE_LPM6_LOG(ERR, "Invalid entry_unique_size");
return NULL;
}
if (p->name == NULL) {
- RTE_LOG(ERR, TABLE, "%s: Table name is NULL\n",
- __func__);
+ TABLE_LPM6_LOG(ERR, "Table name is NULL");
return NULL;
}
entry_size = RTE_ALIGN(entry_size, sizeof(uint64_t));
@@ -90,9 +92,8 @@ rte_table_lpm_ipv6_create(void *params, int socket_id, uint32_t entry_size)
lpm = rte_zmalloc_socket("TABLE", total_size, RTE_CACHE_LINE_SIZE,
socket_id);
if (lpm == NULL) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot allocate %u bytes for LPM IPv6 table\n",
- __func__, total_size);
+ TABLE_LPM6_LOG(ERR, "Cannot allocate %u bytes for LPM IPv6 table",
+ total_size);
return NULL;
}
@@ -103,8 +104,7 @@ rte_table_lpm_ipv6_create(void *params, int socket_id, uint32_t entry_size)
lpm->lpm = rte_lpm6_create(p->name, socket_id, &lpm6_config);
if (lpm->lpm == NULL) {
rte_free(lpm);
- RTE_LOG(ERR, TABLE,
- "Unable to create low-level LPM IPv6 table\n");
+ TABLE_LPM6_LOG(ERR, "Unable to create low-level LPM IPv6 table\n");
return NULL;
}
@@ -124,7 +124,7 @@ rte_table_lpm_ipv6_free(void *table)
/* Check input parameters */
if (lpm == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_LPM6_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
@@ -184,21 +184,20 @@ rte_table_lpm_ipv6_entry_add(
/* Check input parameters */
if (lpm == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_LPM6_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
if (ip_prefix == NULL) {
- RTE_LOG(ERR, TABLE, "%s: ip_prefix parameter is NULL\n",
- __func__);
+ TABLE_LPM6_LOG(ERR, "ip_prefix parameter is NULL");
return -EINVAL;
}
if (entry == NULL) {
- RTE_LOG(ERR, TABLE, "%s: entry parameter is NULL\n", __func__);
+ TABLE_LPM6_LOG(ERR, "entry parameter is NULL");
return -EINVAL;
}
if ((ip_prefix->depth == 0) || (ip_prefix->depth > 128)) {
- RTE_LOG(ERR, TABLE, "%s: invalid depth (%d)\n", __func__,
+ TABLE_LPM6_LOG(ERR, "invalid depth (%d)",
ip_prefix->depth);
return -EINVAL;
}
@@ -213,7 +212,7 @@ rte_table_lpm_ipv6_entry_add(
uint8_t *nht_entry;
if (nht_find_free(lpm, &nht_pos) == 0) {
- RTE_LOG(ERR, TABLE, "%s: NHT full\n", __func__);
+ TABLE_LPM6_LOG(ERR, "NHT full");
return -1;
}
@@ -224,7 +223,7 @@ rte_table_lpm_ipv6_entry_add(
/* Add rule to low level LPM table */
if (rte_lpm6_add(lpm->lpm, ip_prefix->ip, ip_prefix->depth,
nht_pos) < 0) {
- RTE_LOG(ERR, TABLE, "%s: LPM IPv6 rule add failed\n", __func__);
+ TABLE_LPM6_LOG(ERR, "LPM IPv6 rule add failed");
return -1;
}
@@ -252,16 +251,15 @@ rte_table_lpm_ipv6_entry_delete(
/* Check input parameters */
if (lpm == NULL) {
- RTE_LOG(ERR, TABLE, "%s: table parameter is NULL\n", __func__);
+ TABLE_LPM6_LOG(ERR, "table parameter is NULL");
return -EINVAL;
}
if (ip_prefix == NULL) {
- RTE_LOG(ERR, TABLE, "%s: ip_prefix parameter is NULL\n",
- __func__);
+ TABLE_LPM6_LOG(ERR, "ip_prefix parameter is NULL");
return -EINVAL;
}
if ((ip_prefix->depth == 0) || (ip_prefix->depth > 128)) {
- RTE_LOG(ERR, TABLE, "%s: invalid depth (%d)\n", __func__,
+ TABLE_LPM6_LOG(ERR, "invalid depth (%d)",
ip_prefix->depth);
return -EINVAL;
}
@@ -270,8 +268,7 @@ rte_table_lpm_ipv6_entry_delete(
status = rte_lpm6_is_rule_present(lpm->lpm, ip_prefix->ip,
ip_prefix->depth, &nht_pos);
if (status < 0) {
- RTE_LOG(ERR, TABLE, "%s: LPM IPv6 algorithmic error\n",
- __func__);
+ TABLE_LPM6_LOG(ERR, "LPM IPv6 algorithmic error");
return -1;
}
if (status == 0) {
@@ -282,8 +279,7 @@ rte_table_lpm_ipv6_entry_delete(
/* Delete rule from the low-level LPM table */
status = rte_lpm6_delete(lpm->lpm, ip_prefix->ip, ip_prefix->depth);
if (status) {
- RTE_LOG(ERR, TABLE, "%s: LPM IPv6 rule delete failed\n",
- __func__);
+ TABLE_LPM6_LOG(ERR, "LPM IPv6 rule delete failed");
return -1;
}
@@ -8,6 +8,11 @@
#include "rte_table_stub.h"
+RTE_LOG_REGISTER_SUFFIX(table_logtype_stub, stub, INFO);
+#define TABLE_STUB_LOG(level, fmt, args...) \
+ rte_log(RTE_LOG_ ## level, table_logtype_stub, \
+ "%s(): " fmt "\n", __func__, ##args)
+
#ifdef RTE_TABLE_STATS_COLLECT
#define RTE_TABLE_LPM_STATS_PKTS_IN_ADD(table, val) \
@@ -38,9 +43,7 @@ rte_table_stub_create(__rte_unused void *params,
stub = rte_zmalloc_socket("TABLE", size, RTE_CACHE_LINE_SIZE,
socket_id);
if (stub == NULL) {
- RTE_LOG(ERR, TABLE,
- "%s: Cannot allocate %u bytes for stub table\n",
- __func__, size);
+ TABLE_STUB_LOG(ERR, "Cannot allocate %u bytes for stub table", size);
return NULL;
}