From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id D0DA5C5B549 for ; Fri, 30 May 2025 09:30:32 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 739EE6B00A1; Fri, 30 May 2025 05:30:32 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 7112D6B00A2; Fri, 30 May 2025 05:30:32 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 627A06B00A3; Fri, 30 May 2025 05:30:32 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0012.hostedemail.com [216.40.44.12]) by kanga.kvack.org (Postfix) with ESMTP id 401646B00A1 for ; Fri, 30 May 2025 05:30:32 -0400 (EDT) Received: from smtpin08.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay04.hostedemail.com (Postfix) with ESMTP id F20C41A2C7E for ; Fri, 30 May 2025 09:30:31 +0000 (UTC) X-FDA: 83499053862.08.B06B780 Received: from mail-pj1-f43.google.com (mail-pj1-f43.google.com [209.85.216.43]) by imf09.hostedemail.com (Postfix) with ESMTP id 18140140006 for ; Fri, 30 May 2025 09:30:29 +0000 (UTC) Authentication-Results: imf09.hostedemail.com; dkim=pass header.d=bytedance.com header.s=google header.b=F7Ew8IDJ; spf=pass (imf09.hostedemail.com: domain of libo.gcs85@bytedance.com designates 209.85.216.43 as permitted sender) smtp.mailfrom=libo.gcs85@bytedance.com; dmarc=pass (policy=quarantine) header.from=bytedance.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1748597430; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=It0nagCB2dMHz+A5VnrcLdhvjSzG9DfFTU//7hpwVEI=; b=Uh6s/8Ys2REQFZxVLmhqotQQXESPTnLndfkYH8RmNMcyt+UbhDXVyRwwdoj3Rbkv3VNCXM pxjjM7HzBpcvv9Cppn2Mo2+oHN163AALOi4lCEgpui9ezoV5X7lM+tqU4AFaW42ZQkKY+8 5MsKCADciwK/21oSU0K2sr0HzHchDWg= ARC-Authentication-Results: i=1; imf09.hostedemail.com; dkim=pass header.d=bytedance.com header.s=google header.b=F7Ew8IDJ; spf=pass (imf09.hostedemail.com: domain of libo.gcs85@bytedance.com designates 209.85.216.43 as permitted sender) smtp.mailfrom=libo.gcs85@bytedance.com; dmarc=pass (policy=quarantine) header.from=bytedance.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1748597430; a=rsa-sha256; cv=none; b=i3IrVT0EO8oRYEWGDUNNz/CHR1kvIZ1ymLP+JuOnZaen8Uar5ZgNyx8AXxz7pG+1F4EAZ5 OUw3niRHBjT3mMR2aqrkNRd58s/MSNPoi5vGw983qXoeMDXpaUMkxuVUWDNRfdkLy66rYi s+vLJ8xEcGWVxW8MPUr7TNxcSlrQ6z4= Received: by mail-pj1-f43.google.com with SMTP id 98e67ed59e1d1-3119822df05so1883342a91.0 for ; Fri, 30 May 2025 02:30:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance.com; s=google; t=1748597429; x=1749202229; darn=kvack.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=It0nagCB2dMHz+A5VnrcLdhvjSzG9DfFTU//7hpwVEI=; b=F7Ew8IDJwBH7WbPUx0Dw5ubXi8nAkDHaTx7mGTC+YSmXNlqwrU+8X1IMRSq0XobV2g xXjL58L9t0yuXG0nF/yex/6yxbL6QZWnoXU8dxCrv/DMZjm2hwEVAJ2xRu3weWKig973 1ljDGcvOi6/bSsOo4vXqUTasDkjE2dEX+jcnm0OLZ2ATSlURZhJBGlLCIO50n9wKyGUy jAmsAxgzJErvfgO7XLhjjbQK8SYKKeqq1n1xC3f8N5471BoSifUQj8MNynKHSe8TfMTK hUUKQkPXmu683Y1nmBtDVQ9VICNO7WD+pMN0LEPQRClrPVEpjz143N+YLrgGsikz8aS4 gMvw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1748597429; x=1749202229; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=It0nagCB2dMHz+A5VnrcLdhvjSzG9DfFTU//7hpwVEI=; b=qPJcXJTiPVxNebGxFaYUOsQ/lWwryl6+UlZSZS6mlBjVkEkj5GcPMZRAmZSM7wql8l 3zxoX7i55D+ddVPs4yDvtAOZFs4mklkMu7B5XPaqTDr7AWmu4VKitLd6REPGp4GDDz+6 E1IXjzUfoXEXBh3br6weeCgBkWOExwbVZqplH6WiyZyz8z1SNhDKFj+5lU2KmSCz1vh+ JcbLynnC3GAFMLeSEiqJmlo1TYxbzqZ9UWEkHot21PlmjHHfUhM9APdr5DJoqVKz9JSV wCy8Pdgz48sCg5EZrZxrTlXFS89BaotES93rzlzYd3Y0qyXt/9mw9/wUfYtdi+UYGoRJ 2Pkw== X-Forwarded-Encrypted: i=1; AJvYcCX62lOhJRWMzBOJlxvZVbRe6RmncuE5W45ArYnCIl4VIGb0qFwH0xXFpMQWjMwI5nvDySKrHEd6zA==@kvack.org X-Gm-Message-State: AOJu0YwLz1bqf/KMEz8Y5ZGdHRXCfgHK/5uWbHdZbBh1Fc6Y47FG5ZYi 6D1cycf77iIyW1R1qCw9TazvFxL37VLQli85ggyJhYlMYSgNnouBLRTWmFNDk6Gb1ss= X-Gm-Gg: ASbGnctz0FF027XHwXH4xrRpONrrUqykT0OQdC0vbfA9yx4rmR/CQT+eslOZxE/hZ2R Rigpz2P03Otgf0bM3UimIeZXWq/eqCJSiw6/6EEtiXXPNNjrkz8Wi6mb1ws1NQ1sBkJVyvu9hMh HVCJS9kqu61eD0wZtoJmSOnx0URFgT+7vIaZezcxeJieOEOVr9dYj07bSafQwquCQrhWSM8XWLQ qTM9J8cKrnuw6zAvwENzi2ofrfprSVZjOC+csWR8e4qW3fTGc8BmOltvN6BBVBLvaUFKKqgkovr nqtqcPQrp41h0Wo7OjWwfXrSdJakUOx2+yWDndYPUvE/aeRc5DY93qgGHMO1yw6gs6KqH9tt6XY uyUPYQV/6aci1HG3MT+YV X-Google-Smtp-Source: AGHT+IHhFP+YSRyY0vGcXgga6NhFTtrcJFFIO4OfIe90gNYiOLxgktzPA73bwtmVpC1QBkXNF+uurw== X-Received: by 2002:a17:90b:4fd2:b0:311:f99e:7f4a with SMTP id 98e67ed59e1d1-31250427d15mr1963416a91.26.1748597428884; Fri, 30 May 2025 02:30:28 -0700 (PDT) Received: from FQ627FTG20.bytedance.net ([63.216.146.178]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-3124e29f7b8sm838724a91.2.2025.05.30.02.30.13 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Fri, 30 May 2025 02:30:28 -0700 (PDT) From: Bo Li To: tglx@linutronix.de, mingo@redhat.com, bp@alien8.de, dave.hansen@linux.intel.com, x86@kernel.org, luto@kernel.org, kees@kernel.org, akpm@linux-foundation.org, david@redhat.com, juri.lelli@redhat.com, vincent.guittot@linaro.org, peterz@infradead.org Cc: dietmar.eggemann@arm.com, hpa@zytor.com, acme@kernel.org, namhyung@kernel.org, mark.rutland@arm.com, alexander.shishkin@linux.intel.com, jolsa@kernel.org, irogers@google.com, adrian.hunter@intel.com, kan.liang@linux.intel.com, viro@zeniv.linux.org.uk, brauner@kernel.org, jack@suse.cz, lorenzo.stoakes@oracle.com, Liam.Howlett@oracle.com, vbabka@suse.cz, rppt@kernel.org, surenb@google.com, mhocko@suse.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, jannh@google.com, pfalcato@suse.de, riel@surriel.com, harry.yoo@oracle.com, linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, duanxiongchun@bytedance.com, yinhongbo@bytedance.com, dengliang.1214@bytedance.com, xieyongji@bytedance.com, chaiwen.cc@bytedance.com, songmuchun@bytedance.com, yuanzhu@bytedance.com, chengguozhu@bytedance.com, sunjiadong.lff@bytedance.com, Bo Li Subject: [RFC v2 08/35] RPAL: enable sender/receiver registration Date: Fri, 30 May 2025 17:27:36 +0800 Message-Id: X-Mailer: git-send-email 2.39.5 (Apple Git-154) In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Rspamd-Queue-Id: 18140140006 X-Stat-Signature: fdr9jmsjgos3o1qb1th3dr3obaey7f43 X-Rspam-User: X-Rspamd-Server: rspam07 X-HE-Tag: 1748597429-234894 X-HE-Meta: U2FsdGVkX1/1chHj/IRuE/I86X9vYuD5+ln5FiV7ywbtCfH1hcVmzX7PJcKiIkLO9I0PLXW0ussPJ/UGPhJXC5G3beDdMo4I0uWXW+KoHAuVz6ezBMzIBnvtUwMSqBmlcLOaVijRIl6Y0Ey6H+fjK5tRkGL0BMTk7SulchvYkdLEXMrnQgAHbFvdAOzD1GEatkbJMitFPHhJ9DQibVaU0L0VELIydQtHjk6XP5LZJXuYwYz9iSBpg3R5MByUSpXdMKYDne8MHsN5iTTusp9e7nzIIg+q9m26I9ZtLILJM9EqIOb6O/SHehxPPjxnX5gSkACfrpSjBh1J3Ml+ybAokIAkaQq8SssuP1laEZS+MERY6ckZTi8CM09x3qBBiT3/3aLPBg2aIdXqZNonLHsuiY1RytauZLsaNk1iI2PI5/fm3mXNaEFh9G15AV42f7K+YGzFnmXx7z+0TGDhgSmKxiRC2WRGJxoJxmBxnN8DdqtwAL2XAVxsDPHctXBz5EUT8ABNTdAR5zNFNH+JPHD7dMhPRGjZJ4cSyzFtVMEm13Pap18bTvkY7lPzPefHbhgcAJzSxYQ6m+WdFAp/IjvguPWe+X5B/UdYPnsXGgEifgHEBnHnUYERoZI1sNRuvL/4pDltIgOPp6X6JhebKjpRh+nZqu0dviPeHyohyIknVd+28QHl4rAh00/TS4Pw2SR7LIvq/g3PnaKFkiQcq/ctSnyHGV1iOwWB6JdRM30RenwhSYJrcva+/Ka1tpgP/h8tDfWpszEAPIHHwv1m19fo95ZwUNmMQffY8dWqcqXKTE8QW6ocZLn5Qg2eIEdjU/SzuYj59U69ucGTjXBGbFOSAdMl60KYu62cjlGdISixvnHH3/KTeUwV+IJWcF3TpAnntwo9p7FTxDF481AbrBt7kMcFTYBbn1MJ3txoURcB9RjShyeilWNBE4fSPzMAlk4IrUWYT1OjsooPwNgP6vi 9cTlkui1 77B0LiH7NRTYQMNRMkYnBfLsJ4+15TgotEO/98d4Uct3DqZ3uNOnTvVxlLp4u6B6eue9W2fGQUBwiROCaeotKhqaZxgN0y4UsGrhfc1LGcuG7gSRlCukt9YOEBTPMW7biyrHCEfZQSrYYD/iIczdCiIXHCRnQnqhc1gwzK6Zy9lLUeGWuHL+L/CMZyWDpCi1KbTfzADL8YEdy/S/Lonr5Ppb/zhzqY8AqkCOeA70rH2zxN6cF2CKPeOd4smgODaaXoZw/ODsR2v5rNitDtgouEvJIAkwGvqWSYX7QEX5wCUoT59ls6jGE5uOEyu8hvhzZ02hubLsSckoaVUmbZqRHYPWNgg== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: In RPAL, there are two roles: the sender (caller) and the receiver ( callee). This patch provides an interface for threads to register as a sender or a receiver with the kernel. Each sender and receiver has its own data structure, along with a block of memory shared between the user space and the kernel space, which is allocated through rpal_mmap(). Signed-off-by: Bo Li --- arch/x86/rpal/Makefile | 2 +- arch/x86/rpal/internal.h | 7 ++ arch/x86/rpal/proc.c | 12 +++ arch/x86/rpal/service.c | 6 ++ arch/x86/rpal/thread.c | 165 +++++++++++++++++++++++++++++++++++++++ include/linux/rpal.h | 79 +++++++++++++++++++ include/linux/sched.h | 15 ++++ init/init_task.c | 2 + kernel/fork.c | 2 + 9 files changed, 289 insertions(+), 1 deletion(-) create mode 100644 arch/x86/rpal/thread.c diff --git a/arch/x86/rpal/Makefile b/arch/x86/rpal/Makefile index a5926fc19334..89f745382c51 100644 --- a/arch/x86/rpal/Makefile +++ b/arch/x86/rpal/Makefile @@ -2,4 +2,4 @@ obj-$(CONFIG_RPAL) += rpal.o -rpal-y := service.o core.o mm.o proc.o +rpal-y := service.o core.o mm.o proc.o thread.o diff --git a/arch/x86/rpal/internal.h b/arch/x86/rpal/internal.h index 65fd14a26f0e..3559c9c6e868 100644 --- a/arch/x86/rpal/internal.h +++ b/arch/x86/rpal/internal.h @@ -34,3 +34,10 @@ static inline void rpal_put_shared_page(struct rpal_shared_page *rsp) int rpal_mmap(struct file *filp, struct vm_area_struct *vma); struct rpal_shared_page *rpal_find_shared_page(struct rpal_service *rs, unsigned long addr); + +/* thread.c */ +int rpal_register_sender(unsigned long addr); +int rpal_unregister_sender(void); +int rpal_register_receiver(unsigned long addr); +int rpal_unregister_receiver(void); +void exit_rpal_thread(void); diff --git a/arch/x86/rpal/proc.c b/arch/x86/rpal/proc.c index 86947dc233d0..8a1e4a8a2271 100644 --- a/arch/x86/rpal/proc.c +++ b/arch/x86/rpal/proc.c @@ -51,6 +51,18 @@ static long rpal_ioctl(struct file *file, unsigned int cmd, unsigned long arg) case RPAL_IOCTL_GET_SERVICE_ID: ret = put_user(cur->id, (int __user *)arg); break; + case RPAL_IOCTL_REGISTER_SENDER: + ret = rpal_register_sender(arg); + break; + case RPAL_IOCTL_UNREGISTER_SENDER: + ret = rpal_unregister_sender(); + break; + case RPAL_IOCTL_REGISTER_RECEIVER: + ret = rpal_register_receiver(arg); + break; + case RPAL_IOCTL_UNREGISTER_RECEIVER: + ret = rpal_unregister_receiver(); + break; default: return -EINVAL; } diff --git a/arch/x86/rpal/service.c b/arch/x86/rpal/service.c index f29a046fc22f..42fb719dbb2a 100644 --- a/arch/x86/rpal/service.c +++ b/arch/x86/rpal/service.c @@ -176,6 +176,7 @@ struct rpal_service *rpal_register_service(void) mutex_init(&rs->mutex); rs->nr_shared_pages = 0; INIT_LIST_HEAD(&rs->shared_pages); + atomic_set(&rs->thread_cnt, 0); rs->bad_service = false; rs->base = calculate_base_address(rs->id); @@ -216,6 +217,9 @@ void rpal_unregister_service(struct rpal_service *rs) if (!rs) return; + while (atomic_read(&rs->thread_cnt) != 0) + schedule(); + delete_service(rs); pr_debug("rpal: unregister service, id: %d, tgid: %d\n", rs->id, @@ -238,6 +242,8 @@ void exit_rpal(bool group_dead) if (!rs) return; + exit_rpal_thread(); + current->rpal_rs = NULL; rpal_put_service(rs); diff --git a/arch/x86/rpal/thread.c b/arch/x86/rpal/thread.c new file mode 100644 index 000000000000..7550ad94b63f --- /dev/null +++ b/arch/x86/rpal/thread.c @@ -0,0 +1,165 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * RPAL service level operations + * Copyright (c) 2025, ByteDance. All rights reserved. + * + * Author: Jiadong Sun + */ + +#include + +#include "internal.h" + +static void rpal_common_data_init(struct rpal_common_data *rcd) +{ + rcd->bp_task = current; + rcd->service_id = rpal_current_service()->id; +} + +int rpal_register_sender(unsigned long addr) +{ + struct rpal_service *cur = rpal_current_service(); + struct rpal_shared_page *rsp; + struct rpal_sender_data *rsd; + long ret = 0; + + if (rpal_test_current_thread_flag(RPAL_SENDER_BIT)) { + ret = -EINVAL; + goto out; + } + + rsp = rpal_find_shared_page(cur, addr); + if (!rsp) { + ret = -EINVAL; + goto out; + } + + if (addr + sizeof(struct rpal_sender_call_context) > + rsp->user_start + rsp->npage * PAGE_SIZE) { + ret = -EINVAL; + goto put_shared_page; + } + + rsd = kzalloc(sizeof(*rsd), GFP_KERNEL); + if (rsd == NULL) { + ret = -ENOMEM; + goto put_shared_page; + } + + rpal_common_data_init(&rsd->rcd); + rsd->rsp = rsp; + rsd->scc = (struct rpal_sender_call_context *)(addr - rsp->user_start + + rsp->kernel_start); + + current->rpal_sd = rsd; + rpal_set_current_thread_flag(RPAL_SENDER_BIT); + + atomic_inc(&cur->thread_cnt); + + return 0; + +put_shared_page: + rpal_put_shared_page(rsp); +out: + return ret; +} + +int rpal_unregister_sender(void) +{ + struct rpal_service *cur = rpal_current_service(); + struct rpal_sender_data *rsd = current->rpal_sd; + long ret = 0; + + if (!rpal_test_current_thread_flag(RPAL_SENDER_BIT)) { + ret = -EINVAL; + goto out; + } + + rpal_put_shared_page(rsd->rsp); + rpal_clear_current_thread_flag(RPAL_SENDER_BIT); + kfree(rsd); + + atomic_dec(&cur->thread_cnt); + +out: + return ret; +} + +int rpal_register_receiver(unsigned long addr) +{ + struct rpal_service *cur = rpal_current_service(); + struct rpal_receiver_data *rrd; + struct rpal_shared_page *rsp; + long ret = 0; + + if (rpal_test_current_thread_flag(RPAL_RECEIVER_BIT)) { + ret = -EINVAL; + goto out; + } + + rsp = rpal_find_shared_page(cur, addr); + if (!rsp) { + ret = -EINVAL; + goto out; + } + + if (addr + sizeof(struct rpal_receiver_call_context) > + rsp->user_start + rsp->npage * PAGE_SIZE) { + ret = -EINVAL; + goto put_shared_page; + } + + rrd = kzalloc(sizeof(*rrd), GFP_KERNEL); + if (rrd == NULL) { + ret = -ENOMEM; + goto put_shared_page; + } + + rpal_common_data_init(&rrd->rcd); + rrd->rsp = rsp; + rrd->rcc = + (struct rpal_receiver_call_context *)(addr - rsp->user_start + + rsp->kernel_start); + + current->rpal_rd = rrd; + rpal_set_current_thread_flag(RPAL_RECEIVER_BIT); + + atomic_inc(&cur->thread_cnt); + + return 0; + +put_shared_page: + rpal_put_shared_page(rsp); +out: + return ret; +} + +int rpal_unregister_receiver(void) +{ + struct rpal_service *cur = rpal_current_service(); + struct rpal_receiver_data *rrd = current->rpal_rd; + long ret = 0; + + if (!rpal_test_current_thread_flag(RPAL_RECEIVER_BIT)) { + ret = -EINVAL; + goto out; + } + + rpal_put_shared_page(rrd->rsp); + rpal_clear_current_thread_flag(RPAL_RECEIVER_BIT); + kfree(rrd); + + atomic_dec(&cur->thread_cnt); + +out: + return ret; +} + +void exit_rpal_thread(void) +{ + if (rpal_test_current_thread_flag(RPAL_SENDER_BIT)) + rpal_unregister_sender(); + + if (rpal_test_current_thread_flag(RPAL_RECEIVER_BIT)) + rpal_unregister_receiver(); +} diff --git a/include/linux/rpal.h b/include/linux/rpal.h index 986dfbd16fc9..c33425e896af 100644 --- a/include/linux/rpal.h +++ b/include/linux/rpal.h @@ -79,6 +79,11 @@ extern unsigned long rpal_cap; +enum rpal_task_flag_bits { + RPAL_SENDER_BIT, + RPAL_RECEIVER_BIT, +}; + /* * Each RPAL process (a.k.a RPAL service) should have a pointer to * struct rpal_service in all its tasks' task_struct. @@ -117,6 +122,9 @@ struct rpal_service { int nr_shared_pages; struct list_head shared_pages; + /* sender/receiver thread count */ + atomic_t thread_cnt; + /* delayed service put work */ struct delayed_work delayed_put_work; @@ -149,10 +157,55 @@ struct rpal_shared_page { struct list_head list; }; +struct rpal_common_data { + /* back pointer to task_struct */ + struct task_struct *bp_task; + /* service id of rpal_service */ + int service_id; +}; + +/* User registers state */ +struct rpal_task_context { + u64 r15; + u64 r14; + u64 r13; + u64 r12; + u64 rbx; + u64 rbp; + u64 rip; + u64 rsp; +}; + +struct rpal_receiver_call_context { + struct rpal_task_context rtc; + int receiver_id; +}; + +struct rpal_receiver_data { + struct rpal_common_data rcd; + struct rpal_shared_page *rsp; + struct rpal_receiver_call_context *rcc; +}; + +struct rpal_sender_call_context { + struct rpal_task_context rtc; + int sender_id; +}; + +struct rpal_sender_data { + struct rpal_common_data rcd; + struct rpal_shared_page *rsp; + struct rpal_sender_call_context *scc; +}; + enum rpal_command_type { RPAL_CMD_GET_API_VERSION_AND_CAP, RPAL_CMD_GET_SERVICE_KEY, RPAL_CMD_GET_SERVICE_ID, + RPAL_CMD_REGISTER_SENDER, + RPAL_CMD_UNREGISTER_SENDER, + RPAL_CMD_REGISTER_RECEIVER, + RPAL_CMD_UNREGISTER_RECEIVER, RPAL_NR_CMD, }; @@ -165,6 +218,14 @@ enum rpal_command_type { _IOWR(RPAL_IOCTL_MAGIC, RPAL_CMD_GET_SERVICE_KEY, u64 *) #define RPAL_IOCTL_GET_SERVICE_ID \ _IOWR(RPAL_IOCTL_MAGIC, RPAL_CMD_GET_SERVICE_ID, int *) +#define RPAL_IOCTL_REGISTER_SENDER \ + _IOWR(RPAL_IOCTL_MAGIC, RPAL_CMD_REGISTER_SENDER, unsigned long) +#define RPAL_IOCTL_UNREGISTER_SENDER \ + _IO(RPAL_IOCTL_MAGIC, RPAL_CMD_UNREGISTER_SENDER) +#define RPAL_IOCTL_REGISTER_RECEIVER \ + _IOWR(RPAL_IOCTL_MAGIC, RPAL_CMD_REGISTER_RECEIVER, unsigned long) +#define RPAL_IOCTL_UNREGISTER_RECEIVER \ + _IO(RPAL_IOCTL_MAGIC, RPAL_CMD_UNREGISTER_RECEIVER) /** * @brief get new reference to a rpal service, a corresponding @@ -200,8 +261,26 @@ static inline struct rpal_service *rpal_current_service(void) { return current->rpal_rs; } + +static inline void rpal_set_current_thread_flag(unsigned long bit) +{ + set_bit(bit, ¤t->rpal_flag); +} + +static inline void rpal_clear_current_thread_flag(unsigned long bit) +{ + clear_bit(bit, ¤t->rpal_flag); +} + +static inline bool rpal_test_current_thread_flag(unsigned long bit) +{ + return test_bit(bit, ¤t->rpal_flag); +} #else static inline struct rpal_service *rpal_current_service(void) { return NULL; } +static inline void rpal_set_current_thread_flag(unsigned long bit) { } +static inline void rpal_clear_current_thread_flag(unsigned long bit) { } +static inline bool rpal_test_current_thread_flag(unsigned long bit) { return false; } #endif void rpal_unregister_service(struct rpal_service *rs); diff --git a/include/linux/sched.h b/include/linux/sched.h index ad35b197543c..5f25cc09fb71 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -72,6 +72,9 @@ struct rcu_node; struct reclaim_state; struct robust_list_head; struct root_domain; +struct rpal_common_data; +struct rpal_receiver_data; +struct rpal_sender_data; struct rpal_service; struct rq; struct sched_attr; @@ -1648,6 +1651,18 @@ struct task_struct { #ifdef CONFIG_RPAL struct rpal_service *rpal_rs; + unsigned long rpal_flag; + /* + * The first member of both rpal_sd and rpal_rd has a type + * of struct rpal_common_data. So if we do not care whether + * it is a struct rpal_sender_data or a struct rpal_receiver_data, + * use rpal_cd instead of rpal_sd or rpal_rd. + */ + union { + struct rpal_common_data *rpal_cd; + struct rpal_sender_data *rpal_sd; + struct rpal_receiver_data *rpal_rd; + }; #endif /* CPU-specific state of this task: */ diff --git a/init/init_task.c b/init/init_task.c index 0c5b1927da41..2eb08b96e66b 100644 --- a/init/init_task.c +++ b/init/init_task.c @@ -222,6 +222,8 @@ struct task_struct init_task __aligned(L1_CACHE_BYTES) = { #endif #ifdef CONFIG_RPAL .rpal_rs = NULL, + .rpal_flag = 0, + .rpal_cd = NULL, #endif }; EXPORT_SYMBOL(init_task); diff --git a/kernel/fork.c b/kernel/fork.c index 1d1c8484a8f2..01cd48eadf68 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -1220,6 +1220,8 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node) #ifdef CONFIG_RPAL tsk->rpal_rs = NULL; + tsk->rpal_flag = 0; + tsk->rpal_cd = NULL; #endif return tsk; -- 2.20.1