From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) by dpdk.org (Postfix) with ESMTP id 360687292 for ; Wed, 21 Mar 2018 06:28:44 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by fmsmga106.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 20 Mar 2018 22:28:43 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.48,338,1517904000"; d="scan'208";a="26248021" Received: from jeffguo-z170x-ud5.sh.intel.com (HELO localhost.localdomain) ([10.67.104.10]) by fmsmga008.fm.intel.com with ESMTP; 20 Mar 2018 22:28:40 -0700 From: Jeff Guo To: stephen@networkplumber.org, bruce.richardson@intel.com, ferruh.yigit@intel.com, konstantin.ananyev@intel.com, gaetan.rivet@6wind.com, jingjing.wu@intel.com, thomas@monjalon.net, motih@mellanox.com, harry.van.haaren@intel.com, jianfeng.tan@intel.com Cc: jblunck@infradead.org, shreyansh.jain@nxp.com, dev@dpdk.org, jia.guo@intel.com, helin.zhang@intel.com Date: Wed, 21 Mar 2018 13:27:44 +0800 Message-Id: <1521610066-12966-1-git-send-email-jia.guo@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1517314860-8097-3-git-send-email-jia.guo@intel.com> References: <1517314860-8097-3-git-send-email-jia.guo@intel.com> Subject: [dpdk-dev] [PATCH V15 1/5] eal: add uevent monitor api and callback func 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: , X-List-Received-Date: Wed, 21 Mar 2018 05:28:45 -0000 This patch aim to add a general uevent mechanism in eal device layer, to enable all linux kernel object uevent monitoring, user could call these APIs to monitor and read out the device status info that sent from the kernel side, then corresponding to handle it, such as when detect hotplug uevent type, user could detach or attach the device. About uevent monitoring: a: add new device event handle type in eal interrupt, it could be register for uevent interrupt b: add enum of rte_eal_dev_event_type and struct of rte_eal_uevent. c: add below APIs in rte eal device layer for enable monitor and cb register rte_dev_callback_register rte_dev_callback_unregister _rte_dev_callback_process rte_dev_event_monitor_start rte_dev_event_monitor_stop Signed-off-by: Jeff Guo --- v15->v14: use exist eal interrupt epoll to replace of rte service usage for monitor thread, add new device event handle type in eal interrupt --- lib/librte_eal/bsdapp/eal/Makefile | 1 + lib/librte_eal/bsdapp/eal/eal_dev.c | 33 +++++ lib/librte_eal/common/eal_common_dev.c | 132 ++++++++++++++++++++ lib/librte_eal/common/include/rte_dev.h | 121 +++++++++++++++++++ lib/librte_eal/common/include/rte_eal_interrupts.h | 1 + lib/librte_eal/linuxapp/eal/Makefile | 1 + lib/librte_eal/linuxapp/eal/eal_dev.c | 134 +++++++++++++++++++++ lib/librte_eal/linuxapp/eal/eal_interrupts.c | 5 +- 8 files changed, 427 insertions(+), 1 deletion(-) create mode 100644 lib/librte_eal/bsdapp/eal/eal_dev.c create mode 100644 lib/librte_eal/linuxapp/eal/eal_dev.c diff --git a/lib/librte_eal/bsdapp/eal/Makefile b/lib/librte_eal/bsdapp/eal/Makefile index dd455e6..c0921dd 100644 --- a/lib/librte_eal/bsdapp/eal/Makefile +++ b/lib/librte_eal/bsdapp/eal/Makefile @@ -33,6 +33,7 @@ SRCS-$(CONFIG_RTE_EXEC_ENV_BSDAPP) += eal_lcore.c SRCS-$(CONFIG_RTE_EXEC_ENV_BSDAPP) += eal_timer.c SRCS-$(CONFIG_RTE_EXEC_ENV_BSDAPP) += eal_interrupts.c SRCS-$(CONFIG_RTE_EXEC_ENV_BSDAPP) += eal_alarm.c +SRCS-$(CONFIG_RTE_EXEC_ENV_BSDAPP) += eal_dev.c # from common dir SRCS-$(CONFIG_RTE_EXEC_ENV_BSDAPP) += eal_common_lcore.c diff --git a/lib/librte_eal/bsdapp/eal/eal_dev.c b/lib/librte_eal/bsdapp/eal/eal_dev.c new file mode 100644 index 0000000..3b7bbf2 --- /dev/null +++ b/lib/librte_eal/bsdapp/eal/eal_dev.c @@ -0,0 +1,33 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Intel Corporation + */ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "eal_thread.h" + +int __rte_experimental +rte_dev_event_monitor_start(void) +{ + RTE_LOG(ERR, EAL, "Not support event monitor for FreeBSD\n"); + return -1; +} + +int __rte_experimental +rte_dev_event_monitor_stop(void) +{ + RTE_LOG(ERR, EAL, "Not support event monitor for FreeBSD\n"); + return -1; +} diff --git a/lib/librte_eal/common/eal_common_dev.c b/lib/librte_eal/common/eal_common_dev.c index cd07144..9365118 100644 --- a/lib/librte_eal/common/eal_common_dev.c +++ b/lib/librte_eal/common/eal_common_dev.c @@ -14,9 +14,31 @@ #include #include #include +#include +#include #include "eal_private.h" +/* spinlock for device callbacks */ +static rte_spinlock_t rte_dev_event_lock = RTE_SPINLOCK_INITIALIZER; + +/** + * The user application callback description. + * + * It contains callback address to be registered by user application, + * the pointer to the parameters for callback, and the device name. + */ +struct rte_dev_event_callback { + TAILQ_ENTRY(rte_dev_event_callback) next; /**< Callbacks list */ + rte_dev_event_cb_fn cb_fn; /**< Callback address */ + void *cb_arg; /**< Callback parameter */ + char *dev_name; /**< Callback devcie name, NULL is for all device */ + uint32_t active; /**< Callback is executing */ +}; + +/* A general callbacks list for all callback of devices */ +static struct rte_dev_event_cb_list dev_event_cbs; + static int cmp_detached_dev_name(const struct rte_device *dev, const void *_name) { @@ -207,3 +229,113 @@ rte_eal_hotplug_remove(const char *busname, const char *devname) rte_eal_devargs_remove(busname, devname); return ret; } + +int __rte_experimental +rte_dev_callback_register(char *device_name, rte_dev_event_cb_fn cb_fn, + void *cb_arg) +{ + struct rte_dev_event_callback *event_cb = NULL; + + rte_spinlock_lock(&rte_dev_event_lock); + + if (TAILQ_EMPTY(&(dev_event_cbs))) + TAILQ_INIT(&(dev_event_cbs)); + + TAILQ_FOREACH(event_cb, &(dev_event_cbs), next) { + if (event_cb->cb_fn == cb_fn && + event_cb->cb_arg == cb_arg && + ((!device_name && !event_cb->dev_name) ? 1 : + (!strcmp(event_cb->dev_name, device_name)))) + break; + } + + /* create a new callback. */ + if (event_cb == NULL) { + /* allocate a new user callback entity */ + event_cb = malloc(sizeof(struct rte_dev_event_callback)); + if (event_cb != NULL) { + event_cb->cb_fn = cb_fn; + event_cb->cb_arg = cb_arg; + strcpy(event_cb->dev_name, device_name); + TAILQ_INSERT_TAIL(&(dev_event_cbs), event_cb, next); + } else + free(event_cb); + } + + rte_spinlock_unlock(&rte_dev_event_lock); + return (event_cb == NULL) ? -1 : 0; +} + +int __rte_experimental +rte_dev_callback_unregister(char *device_name, rte_dev_event_cb_fn cb_fn, + void *cb_arg) +{ + int ret; + struct rte_dev_event_callback *event_cb, *next; + + if (!cb_fn || device_name == NULL) + return -EINVAL; + + rte_spinlock_lock(&rte_dev_event_lock); + + ret = 0; + + for (event_cb = TAILQ_FIRST(&(dev_event_cbs)); event_cb != NULL; + event_cb = next) { + + next = TAILQ_NEXT(event_cb, next); + + if (event_cb->cb_fn != cb_fn || + (event_cb->cb_arg != (void *)-1 && + event_cb->cb_arg != cb_arg) || + (((!device_name && event_cb->dev_name) || + (device_name && !event_cb->dev_name)) ? 1 : + strcmp(event_cb->dev_name, device_name))) + continue; + + /* + * if this callback is not executing right now, + * then remove it. + */ + if (event_cb->active == 0) { + TAILQ_REMOVE(&(dev_event_cbs), event_cb, next); + rte_free(event_cb); + } else { + ret = -EAGAIN; + } + } + + rte_spinlock_unlock(&rte_dev_event_lock); + return ret; +} + +int __rte_experimental +_rte_dev_callback_process(char *device_name, enum rte_dev_event_type event, + void *cb_arg) +{ + struct rte_dev_event_callback dev_cb; + struct rte_dev_event_callback *cb_lst; + int rc = 0; + + rte_spinlock_lock(&rte_dev_event_lock); + + if (device_name == NULL) + return -EINVAL; + + TAILQ_FOREACH(cb_lst, &(dev_event_cbs), next) { + if (cb_lst->cb_fn == NULL || (!cb_lst->dev_name ? 0 : + strcmp(cb_lst->dev_name, + device_name) && cb_lst->dev_name)) + continue; + dev_cb = *cb_lst; + cb_lst->active = 1; + if (cb_arg) + dev_cb.cb_arg = cb_arg; + rc = dev_cb.cb_fn(device_name, event, + dev_cb.cb_arg); + cb_lst->active = 0; + } + + rte_spinlock_unlock(&rte_dev_event_lock); + return rc; +} diff --git a/lib/librte_eal/common/include/rte_dev.h b/lib/librte_eal/common/include/rte_dev.h index b688f1e..d2fcbc9 100644 --- a/lib/librte_eal/common/include/rte_dev.h +++ b/lib/librte_eal/common/include/rte_dev.h @@ -24,6 +24,30 @@ extern "C" { #include #include +/** + * The device event type. + */ +enum rte_dev_event_type { + RTE_DEV_EVENT_UNKNOWN, /**< unknown event type */ + RTE_DEV_EVENT_ADD, /**< device being added */ + RTE_DEV_EVENT_REMOVE, /**< device being removed */ + RTE_DEV_EVENT_MAX /**< max value of this enum */ +}; + +struct rte_dev_event { + enum rte_dev_event_type type; /**< device event type */ + int subsystem; /**< subsystem id */ + char *devname; /**< device name */ +}; + +typedef int (*rte_dev_event_cb_fn)(char *device_name, + enum rte_dev_event_type event, + void *cb_arg); + +struct rte_dev_event_callback; +/** @internal Structure to keep track of registered callbacks */ +TAILQ_HEAD(rte_dev_event_cb_list, rte_dev_event_callback); + __attribute__((format(printf, 2, 0))) static inline void rte_pmd_debug_trace(const char *func_name, const char *fmt, ...) @@ -267,4 +291,101 @@ __attribute__((used)) = str } #endif +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * It registers the callback for the specific device. + * Multiple callbacks cal be registered at the same time. + * + * @param device_name + * The device name, that is the param name of the struct rte_device, + * null value means for all devices. + * @param cb_fn + * callback address. + * @param cb_arg + * address of parameter for callback. + * + * @return + * - On success, zero. + * - On failure, a negative value. + */ +int __rte_experimental +rte_dev_callback_register(char *device_name, rte_dev_event_cb_fn cb_fn, + void *cb_arg); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * It unregisters the callback according to the specified device. + * + * @param device_name + * The device name, that is the param name of the struct rte_device, + * null value means for all devices. + * @param cb_fn + * callback address. + * @param cb_arg + * address of parameter for callback, (void *)-1 means to remove all + * registered which has the same callback address. + * + * @return + * - On success, return the number of callback entities removed. + * - On failure, a negative value. + */ +int __rte_experimental +rte_dev_callback_unregister(char *device_name, rte_dev_event_cb_fn cb_fn, + void *cb_arg); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * internal Executes all the user application registered callbacks for + * the specific device. It is for DPDK internal user only. User + * application should not call it directly. + * + * @param device_name + * The device name. + * @param event + * the device event type + * is permitted or not. + * @param cb_arg + * callback parameter. + * + * @return + * - On success, return zero. + * - On failure, a negative value. + */ +int __rte_experimental +_rte_dev_callback_process(char *device_name, enum rte_dev_event_type event, + void *cb_arg); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Start the device event monitoring. + * + * @param none + * @return + * - On success, zero. + * - On failure, a negative value. + */ +int __rte_experimental +rte_dev_event_monitor_start(void); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * + * Stop the device event monitoring . + * + * @param none + * @return + * - On success, zero. + * - On failure, a negative value. + */ +int __rte_experimental +rte_dev_event_monitor_stop(void); #endif /* _RTE_DEV_H_ */ diff --git a/lib/librte_eal/common/include/rte_eal_interrupts.h b/lib/librte_eal/common/include/rte_eal_interrupts.h index 3f792a9..6eb4932 100644 --- a/lib/librte_eal/common/include/rte_eal_interrupts.h +++ b/lib/librte_eal/common/include/rte_eal_interrupts.h @@ -34,6 +34,7 @@ enum rte_intr_handle_type { RTE_INTR_HANDLE_ALARM, /**< alarm handle */ RTE_INTR_HANDLE_EXT, /**< external handler */ RTE_INTR_HANDLE_VDEV, /**< virtual device */ + RTE_INTR_HANDLE_DEV_EVENT, /**< device event handle */ RTE_INTR_HANDLE_MAX /**< count of elements */ }; diff --git a/lib/librte_eal/linuxapp/eal/Makefile b/lib/librte_eal/linuxapp/eal/Makefile index 7e5bbe8..8578796 100644 --- a/lib/librte_eal/linuxapp/eal/Makefile +++ b/lib/librte_eal/linuxapp/eal/Makefile @@ -41,6 +41,7 @@ SRCS-$(CONFIG_RTE_EXEC_ENV_LINUXAPP) += eal_lcore.c SRCS-$(CONFIG_RTE_EXEC_ENV_LINUXAPP) += eal_timer.c SRCS-$(CONFIG_RTE_EXEC_ENV_LINUXAPP) += eal_interrupts.c SRCS-$(CONFIG_RTE_EXEC_ENV_LINUXAPP) += eal_alarm.c +SRCS-$(CONFIG_RTE_EXEC_ENV_LINUXAPP) += eal_dev.c # from common dir SRCS-$(CONFIG_RTE_EXEC_ENV_LINUXAPP) += eal_common_lcore.c diff --git a/lib/librte_eal/linuxapp/eal/eal_dev.c b/lib/librte_eal/linuxapp/eal/eal_dev.c new file mode 100644 index 0000000..9d9e088 --- /dev/null +++ b/lib/librte_eal/linuxapp/eal/eal_dev.c @@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Intel Corporation + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "eal_private.h" +#include "eal_thread.h" + +static struct rte_intr_handle intr_handle = {.fd = -1 }; +bool monitor_no_started = true; + +static int +dev_uev_monitor_fd_new(void) +{ + + int uevent_fd; + + uevent_fd = socket(PF_NETLINK, SOCK_RAW | SOCK_CLOEXEC | + SOCK_NONBLOCK, + NETLINK_KOBJECT_UEVENT); + if (uevent_fd < 0) { + RTE_LOG(ERR, EAL, "create uevent fd failed\n"); + return -1; + } + return uevent_fd; +} + +static int +dev_uev_monitor_create(int netlink_fd) +{ + struct sockaddr_nl addr; + int ret; + int size = 64 * 1024; + int nonblock = 1; + + memset(&addr, 0, sizeof(addr)); + addr.nl_family = AF_NETLINK; + addr.nl_pid = 0; + addr.nl_groups = 0xffffffff; + + if (bind(netlink_fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + RTE_LOG(ERR, EAL, "bind failed\n"); + goto err; + } + + setsockopt(netlink_fd, SOL_SOCKET, SO_PASSCRED, &size, sizeof(size)); + + ret = ioctl(netlink_fd, FIONBIO, &nonblock); + if (ret != 0) { + RTE_LOG(ERR, EAL, "ioctl(FIONBIO) failed\n"); + goto err; + } + return 0; +err: + close(netlink_fd); + return -1; +} + +static void +dev_uev_process(__rte_unused void *param) +{ + /* TODO: device uevent processing */ +} + +int __rte_experimental +rte_dev_event_monitor_start(void) +{ + int ret; + + if (!monitor_no_started) + return 0; + + intr_handle.fd = dev_uev_monitor_fd_new(); + intr_handle.type = RTE_INTR_HANDLE_DEV_EVENT; + + ret = dev_uev_monitor_create(intr_handle.fd); + + if (ret) { + RTE_LOG(ERR, EAL, "error create device event monitor\n"); + return -1; + } + + ret = rte_intr_callback_register(&intr_handle, dev_uev_process, NULL); + + if (ret) { + RTE_LOG(ERR, EAL, "fail to register uevent callback\n"); + return -1; + } + + monitor_no_started = false; + + return 0; +} + +int __rte_experimental +rte_dev_event_monitor_stop(void) +{ + int ret; + + if (monitor_no_started) + return 0; + + ret = rte_intr_callback_unregister(&intr_handle, dev_uev_process, NULL); + if (ret) { + RTE_LOG(ERR, EAL, "fail to unregister uevent callback"); + return ret; + } + + close(intr_handle.fd); + intr_handle.fd = -1; + monitor_no_started = true; + return 0; +} diff --git a/lib/librte_eal/linuxapp/eal/eal_interrupts.c b/lib/librte_eal/linuxapp/eal/eal_interrupts.c index f86f22f..842acaa 100644 --- a/lib/librte_eal/linuxapp/eal/eal_interrupts.c +++ b/lib/librte_eal/linuxapp/eal/eal_interrupts.c @@ -674,7 +674,10 @@ eal_intr_process_interrupts(struct epoll_event *events, int nfds) bytes_read = 0; call = true; break; - + case RTE_INTR_HANDLE_DEV_EVENT: + bytes_read = 0; + call = true; + break; default: bytes_read = 1; break; -- 2.7.4