euleros inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/IC4GP7 CVE: NA ---------------------------------------- Add the fast_ipc module to support fast switching and communication between processes. Signed-off-by: chenrenhui <chenrenhui1@huawei.com> --- Kconfig | 2 + arch/arm64/configs/openeuler_defconfig | 1 + include/linux/fast_ipc.h | 45 ++++ ipc/Kconfig | 6 + ipc/Makefile | 2 +- ipc/fast_ipc.c | 296 +++++++++++++++++++++++++ 6 files changed, 351 insertions(+), 1 deletion(-) create mode 100644 include/linux/fast_ipc.h create mode 100644 ipc/Kconfig create mode 100644 ipc/fast_ipc.c diff --git a/Kconfig b/Kconfig index 745bc773f567..38535ecc8aa6 100644 --- a/Kconfig +++ b/Kconfig @@ -21,6 +21,8 @@ source "drivers/Kconfig" source "fs/Kconfig" +source "ipc/Kconfig" + source "security/Kconfig" source "crypto/Kconfig" diff --git a/arch/arm64/configs/openeuler_defconfig b/arch/arm64/configs/openeuler_defconfig index fb9f92d11bde..03d26243a4db 100644 --- a/arch/arm64/configs/openeuler_defconfig +++ b/arch/arm64/configs/openeuler_defconfig @@ -6660,6 +6660,7 @@ CONFIG_FILE_MITIGATION_FALSE_SHARING=y # end of File systems CONFIG_RESCTRL=y +CONFIG_FAST_IPC=m # # Security options diff --git a/include/linux/fast_ipc.h b/include/linux/fast_ipc.h new file mode 100644 index 000000000000..2bc6e6691b8e --- /dev/null +++ b/include/linux/fast_ipc.h @@ -0,0 +1,45 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2024-2024. All rights reserved. + * Description: fast IPC header + * Author: yangyun + * Create: 2024-05-31 + */ +#ifndef __FAST_IPC_H_ +#define __FAST_IPC_H_ + +struct fast_ipc_bind_info { + unsigned int data_size; + + struct task_struct *client_task; + struct task_struct *server_task; + + bool is_calling; + bool client_need_exit; + bool server_need_exit; + + atomic_t nr_call; + + spinlock_t lock; + struct list_head node; +}; + +void fast_ipc_wakeup_server_task(struct fast_ipc_bind_info *bind_info); + +void *fast_ipc_bind(struct task_struct *server_task); + +void fast_ipc_unbind(struct fast_ipc_bind_info *bind_info, + struct task_struct *server_task); + +ssize_t fast_ipc_do_call(struct fast_ipc_bind_info *bind_info, + struct task_struct *tsk); + +long fast_ipc_ret_call(struct fast_ipc_bind_info *bind_info, + struct task_struct *tsk); + +long fast_ipc_wait_call(struct fast_ipc_bind_info *bind_info, + struct task_struct *tsk); + +void fast_ipc_release(struct fast_ipc_bind_info *bind_info); + +#endif diff --git a/ipc/Kconfig b/ipc/Kconfig new file mode 100644 index 000000000000..e29b75bfb6c3 --- /dev/null +++ b/ipc/Kconfig @@ -0,0 +1,6 @@ +config FAST_IPC + tristate "Fast IPC support" + default n + depends on ARM64 + help + Fast Inter-process call, used to switch threads quickly. \ No newline at end of file diff --git a/ipc/Makefile b/ipc/Makefile index c2558c430f51..83600d89573c 100644 --- a/ipc/Makefile +++ b/ipc/Makefile @@ -9,4 +9,4 @@ obj-$(CONFIG_SYSVIPC_SYSCTL) += ipc_sysctl.o obj-$(CONFIG_POSIX_MQUEUE) += mqueue.o msgutil.o obj-$(CONFIG_IPC_NS) += namespace.o obj-$(CONFIG_POSIX_MQUEUE_SYSCTL) += mq_sysctl.o - +obj-$(CONFIG_FAST_IPC) += fast_ipc.o diff --git a/ipc/fast_ipc.c b/ipc/fast_ipc.c new file mode 100644 index 000000000000..3de28f382bd1 --- /dev/null +++ b/ipc/fast_ipc.c @@ -0,0 +1,296 @@ +// SPDX-License-Identifier: GPL-2.0 + +#ifndef pr_fmt +# define pr_fmt(fmt) "fast_ipc: " fmt +#endif + +#include <linux/init.h> +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/types.h> +#include <linux/slab.h> +#include <linux/sched.h> +#include <linux/printk.h> +#include <linux/preempt.h> +#include <linux/sched/signal.h> +#include <linux/fast_ipc.h> +#include <linux/sched/debug.h> + +#define IPC_DEBUG(fmt, ...) + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("yangyun"); +MODULE_DESCRIPTION("fast ipc"); +MODULE_VERSION("1.0"); + +static inline void bind_info_lock(struct fast_ipc_bind_info *bind_info) +{ + spin_lock(&bind_info->lock); +} + +static inline void bind_info_unlock(struct fast_ipc_bind_info *bind_info) +{ + spin_unlock(&bind_info->lock); +} + +static inline int fast_ipc_check_task_consistency(struct task_struct *client, + struct task_struct *server) +{ + if (client->pid == server->pid) { + pr_err("error: client(%s/%d) and server(%s/%d) is same\n", client->comm, + client->pid, server->comm, server->pid); + return -EPERM; + } + + return 0; +} + +static inline ssize_t +fast_ipc_call_check(struct fast_ipc_bind_info *bind_info, + struct task_struct *tsk) +{ + ssize_t ret = 0; + struct task_struct *server_task; + + if (!bind_info) + return -ENOENT; + + if (bind_info->client_task) { + pr_err("error: bind already with client task: %s/%d, current is : %s/%d", + bind_info->client_task->comm, bind_info->client_task->pid, + tsk->comm, tsk->pid); + return -EEXIST; + } + + server_task = bind_info->server_task; + if (!server_task) { + pr_err("error: server thread is not exsit\n"); + return -ESRCH; + } + + return ret; +} + +static inline void fast_ipc_client_init( + struct fast_ipc_bind_info *bind_info, struct task_struct *tsk) +{ + bind_info->client_task = tsk; +} + + +static inline void fast_ipc_client_exit( + struct fast_ipc_bind_info *bind_info, struct task_struct *tsk) +{ + bind_info->client_task = NULL; +} + +static inline int fast_ipc_get_client_exit_code( + const struct fast_ipc_bind_info *bind_info) +{ + return bind_info->client_need_exit ? -ESRCH : 0; +} + +static inline void fast_ipc_wakeup_client_task( + struct fast_ipc_bind_info *bind_info) +{ + struct task_struct *client_task; + + client_task = bind_info->client_task; + bind_info->client_need_exit = true; + wake_up_process(client_task); +} + +void fast_ipc_wakeup_server_task(struct fast_ipc_bind_info *bind_info) +{ + struct task_struct *server_task; + + server_task = bind_info->server_task; + bind_info->server_need_exit = true; + wake_up_process(server_task); +} +EXPORT_SYMBOL_GPL(fast_ipc_wakeup_server_task); + +void *fast_ipc_bind(struct task_struct *server_task) +{ + struct fast_ipc_bind_info *bind_info = NULL; + + bind_info = kcalloc(1, sizeof(struct fast_ipc_bind_info), GFP_KERNEL); + if (!bind_info) + return ERR_PTR(-ENOMEM); + + bind_info->server_task = server_task; + + return (void *) bind_info; +} +EXPORT_SYMBOL_GPL(fast_ipc_bind); + +void fast_ipc_release(struct fast_ipc_bind_info *bind_info) +{ + if (bind_info) { + if (bind_info->client_task && bind_info->is_calling) + fast_ipc_wakeup_client_task(bind_info); + kfree(bind_info); + } +} +EXPORT_SYMBOL_GPL(fast_ipc_release); + +void fast_ipc_unbind(struct fast_ipc_bind_info *bind_info, + struct task_struct *server_task) +{ + if (bind_info) { + if (bind_info->server_task == server_task) { + bind_info->server_task = NULL; + if (bind_info->client_task && bind_info->is_calling) + fast_ipc_wakeup_client_task(bind_info); + kfree(bind_info); + } + } + +} +EXPORT_SYMBOL_GPL(fast_ipc_unbind); + +ssize_t fast_ipc_do_call(struct fast_ipc_bind_info *bind_info, + struct task_struct *tsk) +{ + struct task_struct *server_task; + ssize_t ret; + + ret = fast_ipc_call_check(bind_info, tsk); + if (ret) { + pr_err("fast ipc call check and init failed, errno: %ld\n", ret); + return ret; + } + + fast_ipc_client_init(bind_info, tsk); + + server_task = bind_info->server_task; + + bind_info->client_need_exit = false; + bind_info->is_calling = true; + + preempt_disable(); /* optimize performance if preemption occurs */ + smp_mb(); + wake_up_process(server_task); + preempt_enable(); + IPC_DEBUG("[cpu/%d][%s/%d] ipc do call server(%s/%d)\n", + smp_processor_id(), tsk->comm, tsk->pid, server_task->comm, + server_task->pid); + + set_current_state(TASK_INTERRUPTIBLE); + while (bind_info->is_calling) { + IPC_DEBUG("[cpu/%d][%s/%d] client begin schedule\n", smp_processor_id(), + tsk->comm, tsk->pid); + schedule(); + IPC_DEBUG("[cpu/%d][%s/%d] client schedule end\n", smp_processor_id(), + tsk->comm, tsk->pid); + if (signal_pending(current)) { + ret = -EINTR; + pr_err("[cpu/%d][%s/%d] client has signal pending break\n", + smp_processor_id(), tsk->comm, tsk->pid); + break; + } + set_current_state(TASK_INTERRUPTIBLE); + } + set_current_state(TASK_RUNNING); + + if (bind_info->is_calling) { + pr_err("[cpu/%d][%s/%d] server is still calling, but client is waken up\n", + smp_processor_id(), tsk->comm, tsk->pid); + pr_err("[cpu/%d][%s/%d] servertask(%s/%d) is running on cpu %d\n", + smp_processor_id(), tsk->comm, tsk->pid, server_task->comm, + server_task->pid, task_cpu(server_task)); + } + + fast_ipc_client_exit(bind_info, tsk); + + if (ret == -EINTR) + return ret; + ret = fast_ipc_get_client_exit_code(bind_info); + + return ret; +} +EXPORT_SYMBOL_GPL(fast_ipc_do_call); + +long fast_ipc_ret_call(struct fast_ipc_bind_info *bind_info, + struct task_struct *tsk) +{ + struct task_struct *client_task; + + if (!bind_info->is_calling) + return 0; + + bind_info_lock(bind_info); + client_task = bind_info->client_task; + if (!client_task) { + bind_info_unlock(bind_info); + return -ESRCH; + } + + bind_info_unlock(bind_info); + + bind_info->is_calling = false; + preempt_disable(); + /* memory barrier for preempt */ + smp_mb(); + wake_up_process(client_task); + preempt_enable(); + IPC_DEBUG("[CPU/%d][%s/%d] client task pid: %d, state: %d\n", + smp_processor_id(), tsk->comm, tsk->pid, client_task->pid, + client_task->state); + + return 0; +} +EXPORT_SYMBOL_GPL(fast_ipc_ret_call); + +long fast_ipc_wait_call(struct fast_ipc_bind_info *bind_info, + struct task_struct *tsk) +{ + long ret = 0; + sigset_t pending_signals; + + for (;;) { + set_current_state(TASK_INTERRUPTIBLE); + if (bind_info->is_calling) + break; + + if (bind_info->server_need_exit) { + ret = -ENODEV; + break; + } + + schedule(); + + if (signal_pending_state(TASK_INTERRUPTIBLE, tsk) + && !bind_info->is_calling) { + if (fatal_signal_pending(tsk)) { + pr_err("[CPU/%d][%s/%d] current task has SIGKILL\n", + smp_processor_id(), tsk->comm, tsk->pid); + } + + pending_signals = current->pending.signal; + ret = -ERESTARTSYS; + break; + } + } + + set_current_state(TASK_RUNNING); + return ret; +} +EXPORT_SYMBOL_GPL(fast_ipc_wait_call); + +static int __init +fast_ipc_init(void) +{ + pr_info("fast ipc init\n"); + return 0; +} + +static void __exit +fast_ipc_exit(void) +{ + pr_info("fast ipc exit\n"); +} + + +module_init(fast_ipc_init); +module_exit(fast_ipc_exit); -- 2.33.0