From patchwork Thu Apr 9 10:52:59 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tonghao Zhang X-Patchwork-Id: 68049 X-Patchwork-Delegate: david.marchand@redhat.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 8EF81A0597; Thu, 9 Apr 2020 12:54:53 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 630FF1C240; Thu, 9 Apr 2020 12:54:53 +0200 (CEST) Received: from mail-pl1-f195.google.com (mail-pl1-f195.google.com [209.85.214.195]) by dpdk.org (Postfix) with ESMTP id 33ACA1C238 for ; Thu, 9 Apr 2020 12:54:52 +0200 (CEST) Received: by mail-pl1-f195.google.com with SMTP id t4so3690948plq.12 for ; Thu, 09 Apr 2020 03:54:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=KFkLUNoEGrFs9SEW+QgZPd9xOdWP4uv7nkqDU4n2MCs=; b=N1JPNjX/kFIOAHAypvnC9Qcw70bp559J6wE9mTaZHBFLNLBOZZ1Qqu/7HlHIWPLow+ hbGi3KmN3aMFgEd69tc75VQZFgNVLsd0dXwbLH7rByBOF/RmLOg6ZSyZlIN/vFyfuVXK 3Hfx/0fLZwZMSQackEMdIu8iN/VYDkbDc1NiPWQOeeypZ2wL7FMmTGtPEDYD7WLTb9Co 3sMynidF5+6DYsDRMJV3d7w0CscIm3sgu4P7BaAiSf2ojL9OHgQLu/P3/yBkiMdUQRnZ n7V++/DWkOKe0sOiL4o/uypvCCILVXaJ/S7DhOI7uY0HkL24/lc6huTKguxJfCDtB/G7 DtNA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=KFkLUNoEGrFs9SEW+QgZPd9xOdWP4uv7nkqDU4n2MCs=; b=qFS+G+tKzvTfhta8ssC9PCs3jBsHmnl04i/dBk0Jdck/FSgrPrbZEK0vp2aLkIvTXZ Ac+htVjkhZvsDAaHr+ZYNZNsYIBVrBqgcIitHOSWTboCqm6fTIyWyTsC+bHaJXSM73ex GvhXetR8PTmXgL0M7SWvDkEMK6EsOF4X/WkQJu0qt2YD+zm4ncnVnGjNa+sKnVnOuW0D lPHtm9NE/i+HdD4t55Q7tuX86MpwLHeharnocoHDGxQjJXq7NWet8CN0UFy0+GQ/++sq 9alo9EWPhY0r5zeGMSpZKOSfF+q1CC27Zd2DJ7a0XXL+j5lG7xunhGrBvIlhVg79M1s7 il+g== X-Gm-Message-State: AGi0PubTQ4vk7Sd43+N43rLt7l52xdKTpMbzmIvrAmiEkK0Za2flOe8C 2rWqRsi8rvOOox36b83FCMw= X-Google-Smtp-Source: APiQypKK7AIHXd3lDABKZKAiSzUztWEsXtUn6xisCIiX6azruU9gaNs4CNz7vlBjLEP4J0OjjXEa6g== X-Received: by 2002:a17:90b:430f:: with SMTP id ih15mr10773277pjb.56.1586429691409; Thu, 09 Apr 2020 03:54:51 -0700 (PDT) Received: from local.opencloud.tech.localdomain ([115.171.63.184]) by smtp.gmail.com with ESMTPSA id n69sm1549895pjc.8.2020.04.09.03.54.45 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 09 Apr 2020 03:54:50 -0700 (PDT) From: xiangxia.m.yue@gmail.com To: olivier.matz@6wind.com, arybchenko@solarflare.com, gage.eads@intel.com, artem.andreev@oktetlabs.ru, jerinj@marvell.com, ndabilpuram@marvell.com, vattunuru@marvell.com, hemant.agrawal@nxp.com, david.marchand@redhat.com, anatoly.burakov@intel.com, bruce.richardson@intel.com Cc: dev@dpdk.org, Tonghao Zhang Date: Thu, 9 Apr 2020 18:52:59 +0800 Message-Id: <1586429580-6990-1-git-send-email-xiangxia.m.yue@gmail.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1583114253-15345-1-git-send-email-xiangxia.m.yue@gmail.com> References: <1583114253-15345-1-git-send-email-xiangxia.m.yue@gmail.com> Subject: [dpdk-dev] [PATCH dpdk-dev 1/2] eal: introduce last-init queue for libraries initialization X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Tonghao Zhang This patch introduces last-init queue, user can register a callback for theirs initialization. Running rte_last_init_run(), the almost resource of DPDK are available, such as memzone, ring. With this way, user don't introduce additional codes in eal layer. [This patch will be used for next patch.] Signed-off-by: Tonghao Zhang --- lib/librte_eal/common/eal_common_last_init.c | 43 ++++++++++++++++++++++++++++ lib/librte_eal/common/meson.build | 1 + lib/librte_eal/freebsd/Makefile | 1 + lib/librte_eal/freebsd/eal.c | 7 +++++ lib/librte_eal/include/rte_last_init.h | 36 +++++++++++++++++++++++ lib/librte_eal/linux/Makefile | 1 + lib/librte_eal/linux/eal.c | 8 ++++++ 7 files changed, 97 insertions(+) create mode 100644 lib/librte_eal/common/eal_common_last_init.c create mode 100644 lib/librte_eal/include/rte_last_init.h diff --git a/lib/librte_eal/common/eal_common_last_init.c b/lib/librte_eal/common/eal_common_last_init.c new file mode 100644 index 0000000..4f168e9 --- /dev/null +++ b/lib/librte_eal/common/eal_common_last_init.c @@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2020 DPDK Community + */ + +#include + +#include +#include + +static struct rte_last_init_list rte_last_init_list = + TAILQ_HEAD_INITIALIZER(rte_last_init_list); + +void +rte_last_init_register(rte_last_init_cb cb, const void *arg) +{ + struct rte_last_init *last; + + RTE_VERIFY(cb); + + last = malloc(sizeof(*last)); + if (last == NULL) + rte_panic("Alloc memory for rte_last_init node failed\n"); + + last->cb = cb; + last->arg = arg; + + TAILQ_INSERT_TAIL(&rte_last_init_list, last, next); +} + +int +rte_last_init_run(void) +{ + struct rte_last_init *init; + int ret; + + TAILQ_FOREACH(init, &rte_last_init_list, next) { + ret = init->cb(init->arg); + if (ret) + return ret; + } + + return 0; +} diff --git a/lib/librte_eal/common/meson.build b/lib/librte_eal/common/meson.build index 02d9280..8107b24 100644 --- a/lib/librte_eal/common/meson.build +++ b/lib/librte_eal/common/meson.build @@ -43,6 +43,7 @@ sources += files( 'eal_common_thread.c', 'eal_common_timer.c', 'eal_common_uuid.c', + 'eal_common_last_init.c', 'hotplug_mp.c', 'malloc_elem.c', 'malloc_heap.c', diff --git a/lib/librte_eal/freebsd/Makefile b/lib/librte_eal/freebsd/Makefile index e5d4d8f..63cb0b9 100644 --- a/lib/librte_eal/freebsd/Makefile +++ b/lib/librte_eal/freebsd/Makefile @@ -60,6 +60,7 @@ SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += eal_common_thread.c SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += eal_common_proc.c SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += eal_common_fbarray.c SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += eal_common_uuid.c +SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += eal_common_last_init.c SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += rte_malloc.c SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += hotplug_mp.c SRCS-$(CONFIG_RTE_EXEC_ENV_FREEBSD) += malloc_elem.c diff --git a/lib/librte_eal/freebsd/eal.c b/lib/librte_eal/freebsd/eal.c index 6ae37e7..b51615f 100644 --- a/lib/librte_eal/freebsd/eal.c +++ b/lib/librte_eal/freebsd/eal.c @@ -44,6 +44,7 @@ #include #include #include +#include #include "eal_private.h" #include "eal_thread.h" @@ -874,6 +875,12 @@ static void rte_eal_init_alert(const char *msg) eal_check_mem_on_local_socket(); + if (rte_last_init_run() < 0) { + rte_eal_init_alert("Cannot init objects in last-init queue"); + rte_errno = EFAULT; + return -1; + } + eal_thread_init_master(rte_config.master_lcore); ret = eal_thread_dump_affinity(cpuset, sizeof(cpuset)); diff --git a/lib/librte_eal/include/rte_last_init.h b/lib/librte_eal/include/rte_last_init.h new file mode 100644 index 0000000..8c91a97 --- /dev/null +++ b/lib/librte_eal/include/rte_last_init.h @@ -0,0 +1,36 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2020 DPDK Community + */ + +#ifndef _RTE_LAST_INIT_H_ +#define _RTE_LAST_INIT_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +typedef int (*rte_last_init_cb)(const void *arg); + +/** + * A structure describing a generic initialization. + */ +struct rte_last_init { + TAILQ_ENTRY(rte_last_init) next; /**< Next bus object in linked list */ + const void *arg; + rte_last_init_cb cb; +}; + +/** Double linked list of buses */ +TAILQ_HEAD(rte_last_init_list, rte_last_init); + +void rte_last_init_register(rte_last_init_cb cb, const void *arg); +int rte_last_init_run(void); + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_LAST_INIT_H_ */ diff --git a/lib/librte_eal/linux/Makefile b/lib/librte_eal/linux/Makefile index e5f4495..3a476a7 100644 --- a/lib/librte_eal/linux/Makefile +++ b/lib/librte_eal/linux/Makefile @@ -67,6 +67,7 @@ SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += eal_common_thread.c SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += eal_common_proc.c SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += eal_common_fbarray.c SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += eal_common_uuid.c +SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += eal_common_last_init.c SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += rte_malloc.c SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += hotplug_mp.c SRCS-$(CONFIG_RTE_EXEC_ENV_LINUX) += malloc_elem.c diff --git a/lib/librte_eal/linux/eal.c b/lib/librte_eal/linux/eal.c index 9530ee5..61fc540 100644 --- a/lib/librte_eal/linux/eal.c +++ b/lib/librte_eal/linux/eal.c @@ -51,6 +51,7 @@ #include #include #include +#include #include "eal_private.h" #include "eal_thread.h" @@ -1203,6 +1204,13 @@ static void rte_eal_init_alert(const char *msg) eal_check_mem_on_local_socket(); + + if (rte_last_init_run() < 0) { + rte_eal_init_alert("Cannot init objects in last-init queue"); + rte_errno = EFAULT; + return -1; + } + eal_thread_init_master(rte_config.master_lcore); ret = eal_thread_dump_affinity(cpuset, sizeof(cpuset)); From patchwork Thu Apr 9 10:53:00 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tonghao Zhang X-Patchwork-Id: 68050 X-Patchwork-Delegate: david.marchand@redhat.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 64349A0597; Thu, 9 Apr 2020 12:55:00 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id B790B1C238; Thu, 9 Apr 2020 12:54:58 +0200 (CEST) Received: from mail-pj1-f66.google.com (mail-pj1-f66.google.com [209.85.216.66]) by dpdk.org (Postfix) with ESMTP id 30B121C238 for ; Thu, 9 Apr 2020 12:54:57 +0200 (CEST) Received: by mail-pj1-f66.google.com with SMTP id z3so1124563pjr.4 for ; Thu, 09 Apr 2020 03:54:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=M30enMMYohcdZ1ckQotcxeCeEbb75YFhdrc8PE5Q/Xk=; b=uOr6dKsKbDzUhWbLL1uggvL1tjC45ZdWT0j7EMiOXX9VcYwKSXmTcAIbzYGJsbBh4B 0n/5crWRsQb5crW2pghe1VJTVPTRGSOF+Mg+cfwAoLaOPlDhXBmwNGAHpEU0KCWo+1Ai wshEc2zjUcXamS7CM6eW1xlYCLqgDa5s9soZxxv9l+oUHT3P8FJ3rnawVhkPfy+0RmuH 0dZ+18ejuiOU1lwYPsdyhpFtD6NvOs4U88foRtxIXj26DczpkKCX55015Cu4VaSjQ9Du +9XKSdK9GYepiIz//VmX+q17SK5DdQwQ3hwQPpTUmBV8SQESeQTlOZcfLt1cAHIcxN5g Yi6g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=M30enMMYohcdZ1ckQotcxeCeEbb75YFhdrc8PE5Q/Xk=; b=P5h+U7PGVW8+v1aWj09DsAC8+0Ko2oMXqq0lbVPosJ1iLhGK5Y7VWxmkrtioRJRKGH JWY2fao8LTUbjNj4Zq3y3j2O4f8OFCa0zqxJa/EXbK0IY7vG5XYDmeUs0Pdg0LpGplEN RssFAEZD22pBfV3MzqP0YxxoG6xiWUiGjaT0Vqqp1H+8Su7L+yBeqLgOGXrVAH6bS6ar 070NtBbIuSs4qhWSqaeHuyUPXlFvS1jNM5G6KqnhdqOStbrwzPbsKus4JAdY9l0Yet52 KXkryrJQlTwTOLFTjfaxjAcH4GKcHTQOaIKRJVQMIRgpSXWbae8lNIcGEkbyJz037S+z g78w== X-Gm-Message-State: AGi0PuZywwiHdNgNqZiw2ZTNB1cG/PY9LQaMAQbsS8+OXlUSDyCxPmdS 6IUPCLHG+kGCBAUjysdMJoM= X-Google-Smtp-Source: APiQypIu6YXzOu/Drjof62XAOBVBh5uhJBt5Gp9Ee2QCT8QklIFYzFST4tO/8mCBCvDk3cFX4DuuYA== X-Received: by 2002:a17:90a:2281:: with SMTP id s1mr8682252pjc.68.1586429696310; Thu, 09 Apr 2020 03:54:56 -0700 (PDT) Received: from local.opencloud.tech.localdomain ([115.171.63.184]) by smtp.gmail.com with ESMTPSA id n69sm1549895pjc.8.2020.04.09.03.54.51 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 09 Apr 2020 03:54:55 -0700 (PDT) From: xiangxia.m.yue@gmail.com To: olivier.matz@6wind.com, arybchenko@solarflare.com, gage.eads@intel.com, artem.andreev@oktetlabs.ru, jerinj@marvell.com, ndabilpuram@marvell.com, vattunuru@marvell.com, hemant.agrawal@nxp.com, david.marchand@redhat.com, anatoly.burakov@intel.com, bruce.richardson@intel.com Cc: dev@dpdk.org, Tonghao Zhang Date: Thu, 9 Apr 2020 18:53:00 +0800 Message-Id: <1586429580-6990-2-git-send-email-xiangxia.m.yue@gmail.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1586429580-6990-1-git-send-email-xiangxia.m.yue@gmail.com> References: <1583114253-15345-1-git-send-email-xiangxia.m.yue@gmail.com> <1586429580-6990-1-git-send-email-xiangxia.m.yue@gmail.com> Subject: [dpdk-dev] [PATCH dpdk-dev 2/2] mempool: use shared memzone for rte_mempool_ops X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Tonghao Zhang The order of mempool initiation affects mempool index in the rte_mempool_ops_table. For example, when building APPs with: $ gcc -lrte_mempool_bucket -lrte_mempool_ring ... The "bucket" mempool will be registered firstly, and its index in table is 0 while the index of "ring" mempool is 1. DPDK uses the mk/rte.app.mk to build APPs, and others, for example, Open vSwitch, use the libdpdk.a or libdpdk.so to build it. The mempool lib linked in dpdk and Open vSwitch is different. The mempool can be used between primary and secondary process, such as dpdk-pdump and pdump-pmd/Open vSwitch(pdump enabled). There will be a crash because dpdk-pdump creates the "ring_mp_mc" ring which index in table is 0, but the index of "bucket" ring is 0 in Open vSwitch. If Open vSwitch use the index 0 to get mempool ops and malloc memory from mempool. The crash will occur: bucket_dequeue (access null and crash) rte_mempool_get_ops (should get "ring_mp_mc", but get "bucket" mempool) rte_mempool_ops_dequeue_bulk ... rte_pktmbuf_alloc rte_pktmbuf_copy pdump_copy pdump_rx rte_eth_rx_burst To avoid the crash, there are some solution: * constructor priority: Different mempool uses different priority in RTE_INIT, but it's not easy to maintain. * change mk/rte.app.mk: Change the order in mk/rte.app.mk to be same as libdpdk.a/libdpdk.so, but when adding a new mempool driver in future, we must make sure the order. * register mempool orderly: Sort the mempool when registering, so the lib linked will not affect the index in mempool table. but the number of mempool libraries may be different. * shared memzone: The primary process allocates a struct in shared memory named memzone, When we register a mempool ops, we first get a name and id from the shared struct: with the lock held, lookup for the registered name and return its index, else get the last id and copy the name in the struct. previous discussion: https://mails.dpdk.org/archives/dev/2020-March/159354.html Suggested-by: Olivier Matz Signed-off-by: Tonghao Zhang --- lib/librte_mempool/rte_mempool.h | 22 ++++++++- lib/librte_mempool/rte_mempool_ops.c | 89 ++++++++++++++++++++++++++++-------- 2 files changed, 90 insertions(+), 21 deletions(-) diff --git a/lib/librte_mempool/rte_mempool.h b/lib/librte_mempool/rte_mempool.h index c90cf31..fdd1057 100644 --- a/lib/librte_mempool/rte_mempool.h +++ b/lib/librte_mempool/rte_mempool.h @@ -50,6 +50,7 @@ #include #include #include +#include #ifdef __cplusplus extern "C" { @@ -678,7 +679,6 @@ struct rte_mempool_ops { */ struct rte_mempool_ops_table { rte_spinlock_t sl; /**< Spinlock for add/delete. */ - uint32_t num_ops; /**< Number of used ops structs in the table. */ /** * Storage for all possible ops structs. */ @@ -910,6 +910,23 @@ int rte_mempool_ops_get_info(const struct rte_mempool *mp, */ int rte_mempool_register_ops(const struct rte_mempool_ops *ops); +struct rte_mempool_shared_ops { + size_t num_mempool_ops; + struct { + char name[RTE_MEMPOOL_OPS_NAMESIZE]; + } mempool_ops[RTE_MEMPOOL_MAX_OPS_IDX]; + + rte_spinlock_t mempool; +}; + +static inline int +rte_mempool_register_ops_cb(const void *arg) +{ + const struct rte_mempool_ops *h = (const struct rte_mempool_ops *)arg; + + return rte_mempool_register_ops(h); +} + /** * Macro to statically register the ops of a mempool handler. * Note that the rte_mempool_register_ops fails silently here when @@ -918,7 +935,8 @@ int rte_mempool_ops_get_info(const struct rte_mempool *mp, #define MEMPOOL_REGISTER_OPS(ops) \ RTE_INIT(mp_hdlr_init_##ops) \ { \ - rte_mempool_register_ops(&ops); \ + rte_last_init_register(rte_mempool_register_ops_cb, \ + (const void *)&ops); \ } /** diff --git a/lib/librte_mempool/rte_mempool_ops.c b/lib/librte_mempool/rte_mempool_ops.c index 22c5251..48aa999 100644 --- a/lib/librte_mempool/rte_mempool_ops.c +++ b/lib/librte_mempool/rte_mempool_ops.c @@ -14,43 +14,95 @@ /* indirect jump table to support external memory pools. */ struct rte_mempool_ops_table rte_mempool_ops_table = { .sl = RTE_SPINLOCK_INITIALIZER, - .num_ops = 0 }; -/* add a new ops struct in rte_mempool_ops_table, return its index. */ -int -rte_mempool_register_ops(const struct rte_mempool_ops *h) +static int +rte_mempool_register_shared_ops(const char *name) { - struct rte_mempool_ops *ops; - int16_t ops_index; + static bool mempool_shared_ops_inited = false; + struct rte_mempool_shared_ops *shared_ops; + const struct rte_memzone* mz; + uint32_t ops_index = 0; + + if (rte_eal_process_type() == RTE_PROC_PRIMARY && + !mempool_shared_ops_inited) { + + mz = rte_memzone_reserve("mempool_ops_shared", + sizeof(*shared_ops), 0, 0); + if (mz == NULL) + return -ENOMEM; + + shared_ops = mz->addr; + shared_ops->num_mempool_ops = 0; + rte_spinlock_init(&shared_ops->mempool); + + mempool_shared_ops_inited = true; + } else { + mz = rte_memzone_lookup("mempool_ops_shared"); + if (mz == NULL) + return -ENOMEM; + + shared_ops = mz->addr; + } - rte_spinlock_lock(&rte_mempool_ops_table.sl); + rte_spinlock_lock(&shared_ops->mempool); - if (rte_mempool_ops_table.num_ops >= - RTE_MEMPOOL_MAX_OPS_IDX) { - rte_spinlock_unlock(&rte_mempool_ops_table.sl); + if (shared_ops->num_mempool_ops >= RTE_MEMPOOL_MAX_OPS_IDX) { + rte_spinlock_unlock(&shared_ops->mempool); RTE_LOG(ERR, MEMPOOL, "Maximum number of mempool ops structs exceeded\n"); return -ENOSPC; } + while (shared_ops->mempool_ops[ops_index].name[0]) { + if(!strcmp(name, shared_ops->mempool_ops[ops_index].name)) { + rte_spinlock_unlock(&shared_ops->mempool); + return ops_index; + } + + ops_index ++; + } + + strlcpy(shared_ops->mempool_ops[ops_index].name, name, + sizeof(shared_ops->mempool_ops[0].name)); + + shared_ops->num_mempool_ops ++; + + rte_spinlock_unlock(&shared_ops->mempool); + return ops_index; +} + +/* add a new ops struct in rte_mempool_ops_table, return its index. */ +int +rte_mempool_register_ops(const struct rte_mempool_ops *h) +{ + struct rte_mempool_ops *ops; + int16_t ops_index; + if (h->alloc == NULL || h->enqueue == NULL || - h->dequeue == NULL || h->get_count == NULL) { - rte_spinlock_unlock(&rte_mempool_ops_table.sl); + h->dequeue == NULL || h->get_count == NULL) { RTE_LOG(ERR, MEMPOOL, "Missing callback while registering mempool ops\n"); + rte_errno = EINVAL; return -EINVAL; } if (strlen(h->name) >= sizeof(ops->name) - 1) { - rte_spinlock_unlock(&rte_mempool_ops_table.sl); - RTE_LOG(DEBUG, EAL, "%s(): mempool_ops <%s>: name too long\n", - __func__, h->name); + RTE_LOG(ERR, MEMPOOL, + "The registering mempool_ops <%s>: name too long\n", + h->name); rte_errno = EEXIST; return -EEXIST; } - ops_index = rte_mempool_ops_table.num_ops++; + ops_index = rte_mempool_register_shared_ops(h->name); + if (ops_index < 0) { + rte_errno = -ops_index; + return ops_index; + } + + rte_spinlock_lock(&rte_mempool_ops_table.sl); + ops = &rte_mempool_ops_table.ops[ops_index]; strlcpy(ops->name, h->name, sizeof(ops->name)); ops->alloc = h->alloc; @@ -165,9 +217,8 @@ struct rte_mempool_ops_table rte_mempool_ops_table = { if (mp->flags & MEMPOOL_F_POOL_CREATED) return -EEXIST; - for (i = 0; i < rte_mempool_ops_table.num_ops; i++) { - if (!strcmp(name, - rte_mempool_ops_table.ops[i].name)) { + for (i = 0; i < RTE_MEMPOOL_MAX_OPS_IDX; i++) { + if (!strcmp(name, rte_mempool_ops_table.ops[i].name)) { ops = &rte_mempool_ops_table.ops[i]; break; }