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 4B247C5B549 for ; Fri, 30 May 2025 09:29:31 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id E15EE6B009D; Fri, 30 May 2025 05:29:30 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id DC67E6B009E; Fri, 30 May 2025 05:29:30 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id CDCD66B009F; Fri, 30 May 2025 05:29:30 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0016.hostedemail.com [216.40.44.16]) by kanga.kvack.org (Postfix) with ESMTP id B20D36B009D for ; Fri, 30 May 2025 05:29:30 -0400 (EDT) Received: from smtpin18.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay06.hostedemail.com (Postfix) with ESMTP id 6D01BEC7C0 for ; Fri, 30 May 2025 09:29:30 +0000 (UTC) X-FDA: 83499051300.18.3C791AB Received: from mail-pl1-f169.google.com (mail-pl1-f169.google.com [209.85.214.169]) by imf29.hostedemail.com (Postfix) with ESMTP id 92C96120002 for ; Fri, 30 May 2025 09:29:28 +0000 (UTC) Authentication-Results: imf29.hostedemail.com; dkim=pass header.d=bytedance.com header.s=google header.b=YC7Bw562; spf=pass (imf29.hostedemail.com: domain of libo.gcs85@bytedance.com designates 209.85.214.169 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=1748597368; 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=qlcCT7HpVRiKFCiWQ8GjTfMWomzbPQPS5hEo4l8oJpI=; b=s2j6HRE0H7adyF4AXI/SGYubzxWoy5IJaEk5D3fHcsB2OEw2Ap8gjYMSiUrpNVX6wjM0zo xg/6MsSs2GTu8thpJh8qHFm9EkoLCkY0i3TxZxd3wdNvd6joGVnUYNfrLeqIpykEYn+t3T K9Off4N5keBHS5MOlOOkCP7G3TtPSRw= ARC-Authentication-Results: i=1; imf29.hostedemail.com; dkim=pass header.d=bytedance.com header.s=google header.b=YC7Bw562; spf=pass (imf29.hostedemail.com: domain of libo.gcs85@bytedance.com designates 209.85.214.169 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=1748597368; a=rsa-sha256; cv=none; b=dUxSE2eBZ17lc71flGC5a+YecROi1l5uWPJejSf2nei2bbhYGRtMgE/fwHzzqh5D0YUMQx fNXdhdZAcY12mi4SM6wl/VOw9iC52abH2MP7gjLCX27xmiWBGkeuFG+F/w83SHAo3jD/vr B6cBX7NPe1920QtqMQ0pdbYqBTqPPfQ= Received: by mail-pl1-f169.google.com with SMTP id d9443c01a7336-231e8553248so18176865ad.1 for ; Fri, 30 May 2025 02:29:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance.com; s=google; t=1748597367; x=1749202167; 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=qlcCT7HpVRiKFCiWQ8GjTfMWomzbPQPS5hEo4l8oJpI=; b=YC7Bw562QkgI7etbZ5sDDH0LvEW0i0gbWxuP86VO7cfoeHHmmx9blaeFLxJuF3kfJP WpMkSuPgb8Ag5T59uM+OvT0Wtd+1Z2cqQLq6qBae6ad8pQ/NLl/kywJEWwdrlz2kYl1m yGsdhcg94IJr0p5F9TP+jLrSiUv/9EIGhSuSwKJNfoCackk8w6AtU/etWP5pHQ3Zxp48 82VTycrxWLt0G2VtQb8HojRt1vtAHSVfwvIr5LK4wepXmtEliUCLBY/rDTBpNxo1WJJJ IyQC7WFIASZrnwfxVbb+YvVEyWfYIzGRmkeYFR7ejjPpg+C5S8xikOYMKF4sHW07G1e5 0kKA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1748597367; x=1749202167; 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=qlcCT7HpVRiKFCiWQ8GjTfMWomzbPQPS5hEo4l8oJpI=; b=DuU3USyEc7W9lVUNAe4+RQi1q4W9hJTcNGmmzUWNzbpJBGPD4xw/TmlJ6ceW5UrqGH 06HaW2LLyPbv0hn6kYlGo5ti/FG2m88QI0zPMqcV8rWYTSgOVhx1ozlemXe4ZX5BoU4n 6foWprHgwpcVYUEnfZUEm5FfsJC7jgU9oFB+gkJQkSvXi85BZ21DKE/uY95S+Sne2nqU 2fQ16tPUA7RTeIK6R1gbKe02tk9MoFAXcuHEXB9U1HgH5KXmZNvM3e1t814d3srrldgX ALiG8c7NOnEEzCTz+iJiHqfslbFmcqxEHUiWqc9FxRThRa765qYR3YvBbMrCmA3iLHC1 7fjg== X-Forwarded-Encrypted: i=1; AJvYcCUwQlZtr5f1g3pEm8vquYLsFly/y+ZeUafkG/7p1oM6M4Y9M/viKSM7Ua53LubMa3ya1qUyZ42wLg==@kvack.org X-Gm-Message-State: AOJu0Yz8rwEM6PlPhtOtR6X3L3fNgWtb3oQ48UCtCFkgxt5quhSoaQK/ u2nYDotwOAQcytBFC0dfzpg/RXvM7HDWL8BWE2SdST2XDllsMB0hpwXKRjWlLc5DWDk= X-Gm-Gg: ASbGncsf1DKZYE4tYJzgTt6c4FPFQHAPqguh62W+AIhkOGwm2/3OIUaPYWRbrLQXOC4 umI+kzhVvzQlpXOZw18JnRbuS1ir0//mofLD8M7cZuYOEpXRnmEpOsP1YMV16RKAowNEa89MB9Y CE2Z0DlgYVunyfxrISg9hLFRC/iQC7Ai00SE3915CKSFtqHDk2Mrsfv2zWKuOBIMKAuHbP2Mk6B wcvvi+R8x1AuNjRfzLts3l6BUiu7z3iz/5ygb5hM3MBYmJp+EXBHM9uqZP6HrOsGooSAA3VhEWm oemnjfUOTEfqqYFq3xiJJ1boMD+WB4RrILwz5HDabJ55j0z3TvZ5eNU1PWFUCbWKTfYeOQE7TFE opxBW96mPOg== X-Google-Smtp-Source: AGHT+IHhT+/kCKbFwXp40FdH2tTAUVIIkiKVWdZUIpWhrB1L0an0nzdMBrvxVW8z9SoZzZut7sVHuQ== X-Received: by 2002:a17:90b:5288:b0:312:ec:4128 with SMTP id 98e67ed59e1d1-31250476af1mr2024876a91.34.1748597367284; Fri, 30 May 2025 02:29:27 -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.29.12 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Fri, 30 May 2025 02:29:26 -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 04/35] RPAL: add member to task_struct and mm_struct Date: Fri, 30 May 2025 17:27:32 +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-Server: rspam01 X-Rspamd-Queue-Id: 92C96120002 X-Stat-Signature: nie9rr6bj1fzaf4981eiqdxba4dap811 X-Rspam-User: X-HE-Tag: 1748597368-971364 X-HE-Meta: U2FsdGVkX18uFbEs/6sJIaLJUCxyIWDv2dN9g83GX5b+cRVDzX36vTS/bS/hxrTG1GKHxQhHTndBjA62jOUKoRZTPGnRpwPvVuU1ClCMjlJ6l2bImkHGkuiQxNlUvOEDxAqT0atQX/AFkkwoaundQ/NC6n6VVU7P+MBOfiqPDh1o8OxC2B87xfDQ/hI7cX6A2ebyaxpsyWqP8ni8QEsqHpQHE6XTh7troVoZFLem/i+xgjkUawhLxxa+07MGNxLzeQFhXAKQS9VIce7W5x7FvFOjxxw0YliOT/9k7U5YYOJiFdoQ9v56RN1zM2NHJX2fGL+0LfIeSKVfOtyIm3cBRAW3btA+/+3APo5beCh8bHwRXCMNplEB/az0lj/+ROReP/4xe+j3kEewfgLzH+KY3nqEQAhgsCPl6ztY+xp5fnPdwkKwT3VDfUDi3Mi2rd8j0FG3qQnXzHd7awCsKMQNM9C42s5VT2nYFyMA3BvYQExB4yW1HPiIi+7Tm4qWEGjubt7cPaCPtLzkmEGz4rAnQNSMfJ80EzqRi0vP86a7dp5dRnK4segWkhVxjU9M3aVZ6Xy8GS4jWwgM4PUK5LXeY9gpVrEde67skCIa7F+o1n8/muhJIUvGrUY9skNNX4xrTdyJs4VWld4gEvr77z6/MEI598vwpxp60py6RKgMH8aDMt8E6XWV0HRrps1ypUxRuRaaoPgvyP06kSAywxlgSYXloV/bZ5Tq5Nx6vj4gMJhcxJ0vWqKN9mEO9ApRHgIgHjFK0cLbn6waX7IilAQcjozllU3X11xZ9K0vQHx8cQp1BoXxDIMl/L5N8NINwdVMN+dhB1E5FX2jzuM3H2H/fT/RWgcIKcjO4jHhYj6tqh2ahkir7MxtpBFdbOL5JkgK1TITqn+/c6xptkyp5YaEpZ1vjl8LH66uNoSLIpoAHHtqWgX9xWNSehZYaTtIHrQa0GUZmAXMtISkNWmdzyD gdhT/g1u 8HVk1RMN0uqhqGU5DNqUGqznJDnlKJqE6udYiLYKJY8bG8yewuFKBDzNiD0xdBCOh1GGGMpKSKd9FZSrVjCMZ/CAzDLiIQuAhzwWI+Tr8MbkTWyZeARhHNZWUnpXKXBFBjM4sPTt4NGRVRRSVcezdQ6ORu3ci95nGR9Zx31/IT3y7Aj1fJYVolHJ4FZKbHQV+7CppY6PM70bLraIXCTGQxCiugk2wcqYcHb+cjPNHQpyKBIRZwHrq3GK9quzuYt8SL/yVCLxTBwL0tNnyLudsTxK6likiVv8Wdebo42yKDEqtDFNNzDlaURYlp/HetIUTlmmikWwpzxGvCplHbkqpc9aOvzSWtzaImY63eMmo/VphG6I= 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 lazy switch and memory-related operations, there is a need to quickly locate the corresponding rpal_service structure. Therefore, rpal_service members are added to these two data structures. This patch adds an rpal_service member to both task_struct and mm_struct, and introduces initialization operations. Meanwhile, rpal_service is also augmented with references to the task_struct and mm_struct of the group_leader. For threads created via fork, the kernel acquires a reference to rpal_service and assigns it to the new task_struct. References to rpal_service are released when threads exit. Regarding the deallocation of rpal_struct, since rpal_put_service may be called in an atomic context (where mmdrop() cannot be invoked), this patch uses delayed work for deallocation. The work delay is set to 30 seconds, which ensures that IDs are not recycled and reused in the short term, preventing other processes from confusing the reallocated ID with the previous one due to race conditions. Signed-off-by: Bo Li --- arch/x86/rpal/service.c | 77 +++++++++++++++++++++++++++++++++++++--- fs/exec.c | 11 ++++++ include/linux/mm_types.h | 3 ++ include/linux/rpal.h | 29 +++++++++++++++ include/linux/sched.h | 5 +++ init/init_task.c | 3 ++ kernel/exit.c | 5 +++ kernel/fork.c | 16 +++++++++ 8 files changed, 145 insertions(+), 4 deletions(-) diff --git a/arch/x86/rpal/service.c b/arch/x86/rpal/service.c index 609c9550540d..55ecb7e0ef8c 100644 --- a/arch/x86/rpal/service.c +++ b/arch/x86/rpal/service.c @@ -26,9 +26,24 @@ static inline void rpal_free_service_id(int id) static void __rpal_put_service(struct rpal_service *rs) { + pr_debug("rpal: free service %d, tgid: %d\n", rs->id, + rs->group_leader->pid); + + rs->mm->rpal_rs = NULL; + mmdrop(rs->mm); + put_task_struct(rs->group_leader); + rpal_free_service_id(rs->id); kmem_cache_free(service_cache, rs); } +static void rpal_put_service_async_fn(struct work_struct *work) +{ + struct rpal_service *rs = + container_of(work, struct rpal_service, delayed_put_work.work); + + __rpal_put_service(rs); +} + static int rpal_alloc_service_id(void) { int id; @@ -75,9 +90,16 @@ void rpal_put_service(struct rpal_service *rs) { if (!rs) return; - - if (atomic_dec_and_test(&rs->refcnt)) - __rpal_put_service(rs); + /* + * Since __rpal_put_service() calls mmdrop() (which + * cannot be invoked in atomic context), we use + * delayed work to release rpal_service. + */ + if (atomic_dec_and_test(&rs->refcnt)) { + INIT_DELAYED_WORK(&rs->delayed_put_work, + rpal_put_service_async_fn); + schedule_delayed_work(&rs->delayed_put_work, HZ * 30); + } } static u32 get_hash_key(u64 key) @@ -128,6 +150,12 @@ struct rpal_service *rpal_register_service(void) if (!rpal_inited) return NULL; + if (!thread_group_leader(current)) { + rpal_err("task %d is not group leader %d\n", current->pid, + current->tgid); + goto alloc_fail; + } + rs = kmem_cache_zalloc(service_cache, GFP_KERNEL); if (!rs) goto alloc_fail; @@ -140,10 +168,27 @@ struct rpal_service *rpal_register_service(void) if (unlikely(rs->key == RPAL_INVALID_KEY)) goto key_fail; - atomic_set(&rs->refcnt, 1); + current->rpal_rs = rs; + + rs->group_leader = get_task_struct(current); + mmgrab(current->mm); + current->mm->rpal_rs = rs; + rs->mm = current->mm; + + /* + * The reference comes from: + * 1. registered service always has one reference + * 2. leader_thread also has one reference + * 3. mm also hold one reference + */ + atomic_set(&rs->refcnt, 3); insert_service(rs); + pr_debug( + "rpal: register service, key: %llx, id: %d, command: %s, tgid: %d\n", + rs->key, rs->id, current->comm, current->tgid); + return rs; key_fail: @@ -161,7 +206,31 @@ void rpal_unregister_service(struct rpal_service *rs) delete_service(rs); + pr_debug("rpal: unregister service, id: %d, tgid: %d\n", rs->id, + rs->group_leader->tgid); + + rpal_put_service(rs); +} + +void copy_rpal(struct task_struct *p) +{ + struct rpal_service *cur = rpal_current_service(); + + p->rpal_rs = rpal_get_service(cur); +} + +void exit_rpal(bool group_dead) +{ + struct rpal_service *rs = rpal_current_service(); + + if (!rs) + return; + + current->rpal_rs = NULL; rpal_put_service(rs); + + if (group_dead) + rpal_unregister_service(rs); } int __init rpal_service_init(void) diff --git a/fs/exec.c b/fs/exec.c index cfbb2b9ee3c9..922728aebebe 100644 --- a/fs/exec.c +++ b/fs/exec.c @@ -68,6 +68,7 @@ #include #include #include +#include #include #include @@ -1076,6 +1077,16 @@ static int de_thread(struct task_struct *tsk) /* we have changed execution domain */ tsk->exit_signal = SIGCHLD; +#if IS_ENABLED(CONFIG_RPAL) + /* + * The rpal process is going to load another binary, we + * need to unregister rpal since it is going to be another + * process. Other threads have already exited by the time + * we come here, we need to set group_dead as true. + */ + exit_rpal(true); +#endif + BUG_ON(!thread_group_leader(tsk)); return 0; diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h index 32ba5126e221..b29adef082c6 100644 --- a/include/linux/mm_types.h +++ b/include/linux/mm_types.h @@ -1172,6 +1172,9 @@ struct mm_struct { #ifdef CONFIG_MM_ID mm_id_t mm_id; #endif /* CONFIG_MM_ID */ +#ifdef CONFIG_RPAL + struct rpal_service *rpal_rs; +#endif } __randomize_layout; /* diff --git a/include/linux/rpal.h b/include/linux/rpal.h index 75c5acf33844..7b9d90b62b3f 100644 --- a/include/linux/rpal.h +++ b/include/linux/rpal.h @@ -11,6 +11,8 @@ #include #include +#include +#include #include #include @@ -29,6 +31,9 @@ #define RPAL_INVALID_KEY _AC(0, UL) /* + * Each RPAL process (a.k.a RPAL service) should have a pointer to + * struct rpal_service in all its tasks' task_struct. + * * Each RPAL service has a 64-bit key as its unique identifier, and * the 64-bit length ensures that the key will never repeat before * the kernel reboot. @@ -39,10 +44,23 @@ * is released, allowing newly started RPAL services to reuse the ID. */ struct rpal_service { + /* The task_struct of thread group leader. */ + struct task_struct *group_leader; + /* mm_struct of thread group */ + struct mm_struct *mm; /* Unique identifier for RPAL service */ u64 key; /* virtual address space id */ int id; + + /* + * Fields above should never change after initialization. + * Fields below may change after initialization. + */ + + /* delayed service put work */ + struct delayed_work delayed_put_work; + /* Hashtable list for this struct */ struct hlist_node hlist; /* reference count of this struct */ @@ -68,7 +86,18 @@ struct rpal_service *rpal_get_service(struct rpal_service *rs); */ void rpal_put_service(struct rpal_service *rs); +#ifdef CONFIG_RPAL +static inline struct rpal_service *rpal_current_service(void) +{ + return current->rpal_rs; +} +#else +static inline struct rpal_service *rpal_current_service(void) { return NULL; } +#endif + void rpal_unregister_service(struct rpal_service *rs); struct rpal_service *rpal_register_service(void); struct rpal_service *rpal_get_service_by_key(u64 key); +void copy_rpal(struct task_struct *p); +void exit_rpal(bool group_dead); #endif diff --git a/include/linux/sched.h b/include/linux/sched.h index 45e5953b8f32..ad35b197543c 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -72,6 +72,7 @@ struct rcu_node; struct reclaim_state; struct robust_list_head; struct root_domain; +struct rpal_service; struct rq; struct sched_attr; struct sched_dl_entity; @@ -1645,6 +1646,10 @@ struct task_struct { struct user_event_mm *user_event_mm; #endif +#ifdef CONFIG_RPAL + struct rpal_service *rpal_rs; +#endif + /* CPU-specific state of this task: */ struct thread_struct thread; diff --git a/init/init_task.c b/init/init_task.c index e557f622bd90..0c5b1927da41 100644 --- a/init/init_task.c +++ b/init/init_task.c @@ -220,6 +220,9 @@ struct task_struct init_task __aligned(L1_CACHE_BYTES) = { #ifdef CONFIG_SECCOMP_FILTER .seccomp = { .filter_count = ATOMIC_INIT(0) }, #endif +#ifdef CONFIG_RPAL + .rpal_rs = NULL, +#endif }; EXPORT_SYMBOL(init_task); diff --git a/kernel/exit.c b/kernel/exit.c index 38645039dd8f..0c8387da59da 100644 --- a/kernel/exit.c +++ b/kernel/exit.c @@ -70,6 +70,7 @@ #include #include #include +#include #include @@ -944,6 +945,10 @@ void __noreturn do_exit(long code) taskstats_exit(tsk, group_dead); trace_sched_process_exit(tsk, group_dead); +#if IS_ENABLED(CONFIG_RPAL) + exit_rpal(group_dead); +#endif + exit_mm(); if (group_dead) diff --git a/kernel/fork.c b/kernel/fork.c index 85afccfdf3b1..1d1c8484a8f2 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -105,6 +105,7 @@ #include #include #include +#include #include #include @@ -1216,6 +1217,10 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node) tsk->mm_cid_active = 0; tsk->migrate_from_cpu = -1; #endif + +#ifdef CONFIG_RPAL + tsk->rpal_rs = NULL; +#endif return tsk; free_stack: @@ -1312,6 +1317,9 @@ static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p, #endif mm_init_uprobes_state(mm); hugetlb_count_init(mm); +#ifdef CONFIG_RPAL + mm->rpal_rs = NULL; +#endif if (current->mm) { mm->flags = mmf_init_flags(current->mm->flags); @@ -2651,6 +2659,14 @@ __latent_entropy struct task_struct *copy_process( current->signal->nr_threads++; current->signal->quick_threads++; atomic_inc(¤t->signal->live); +#if IS_ENABLED(CONFIG_RPAL) + /* + * For rpal process, the child thread needs to + * inherit p->rpal_rs. Therefore, we can get the + * struct rpal_service for any thread of rpal process. + */ + copy_rpal(p); +#endif refcount_inc(¤t->signal->sigcnt); task_join_group_stop(p); list_add_tail_rcu(&p->thread_node, -- 2.20.1