From nobody Mon Jun 8 08:46:13 2026 Received: from galois.linutronix.de (Galois.linutronix.de [193.142.43.55]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3C0EB481A90; Wed, 3 Jun 2026 14:25:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=193.142.43.55 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780496710; cv=none; b=umsV8yFyoyVfBf3oAH/vtj9m4YFXx3h5mcpsM0rwCmz/GlEvrAmK6NvdnD/GmdXt9AGC6MrYNb+mWvlgspx1AOdIGaSeOMb9JSLFSrNBJGrOzip/eZy1C18mFDop5zbeOj6485Op6gWH4vpdm7pADFWkc8U7kmBSmM7vtyLzs4Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780496710; c=relaxed/simple; bh=JW/OG6kcWIts7wM+BkVIgT+BcLD+SuzKAgqv7OwN2Vg=; h=Date:From:To:Subject:Cc:In-Reply-To:References:MIME-Version: Message-ID:Content-Type; b=bra6uOV7bduDRl03fFnzaQKlYhlnnsd0bjMkow3V1zur8TVtHk3w+yLirhkMRoEdIIwqvNPKfuyRWKVvFSTn6UOsrRUbF2LXh+887NrG/PuDguDVi+FGPTZMSveBXPK57+oCqcpZ+4SBBxY7x6qI9vML77ZNJJYz3K1LvvsTpiE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linutronix.de; spf=pass smtp.mailfrom=linutronix.de; dkim=pass (2048-bit key) header.d=linutronix.de header.i=@linutronix.de header.b=drpVb0tv; dkim=permerror (0-bit key) header.d=linutronix.de header.i=@linutronix.de header.b=2JkI6PN5; arc=none smtp.client-ip=193.142.43.55 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linutronix.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linutronix.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linutronix.de header.i=@linutronix.de header.b="drpVb0tv"; dkim=permerror (0-bit key) header.d=linutronix.de header.i=@linutronix.de header.b="2JkI6PN5" Date: Wed, 03 Jun 2026 14:25:05 -0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020; t=1780496706; h=from:from:sender:sender:reply-to:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=LXuZwbLfGGCeBFDaolo0gTFIH5MM8cbf/XKmkU8OHdE=; b=drpVb0tv/zw4t+nKKFuf5ei6UA8XJiyXbPXLrBq7kVHhQWQ9L7wKL9mmSIMqJ/8ntofHbq c+6/zhDoD5SB8nuBbwKtWjEqHvLwTkWzL6U8Bf6rCczeWMIaqRqapiC6Ld1+lUuSpZcvgS cVvf0vvn9YzAR/mXaLYHX0PcsnJiLnqiRSMejGvjp6AX52W9zczUADx5objG/56kugCy4R OWAgM/rnHVRadR+HNWL4bbqT3kwXq9QcdKxiJwV/NW4dwpB5o1V9xhr51O6xct5zh1r9+v Nuf1/7wjNz8lGWizPjIonzU1I3OuUlMm22lPtqpid9gzi/yM2KTtDJmvX6O5eg== DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020e; t=1780496706; h=from:from:sender:sender:reply-to:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=LXuZwbLfGGCeBFDaolo0gTFIH5MM8cbf/XKmkU8OHdE=; b=2JkI6PN5q4lw+M5jDyfLMMLVgihUseq/SgB8GKp1Pq6BcnE3J2psxQ8WuFEHUPphBqpP7O QjmwGx+vi8GnWxCA== From: "tip-bot2 for Thomas Gleixner" Sender: tip-bot2@linutronix.de Reply-to: linux-kernel@vger.kernel.org To: linux-tip-commits@vger.kernel.org Subject: [tip: locking/core] futex: Move futex task related data into a struct Cc: Thomas Gleixner , "Peter Zijlstra (Intel)" , Mathieu Desnoyers , andrealmeid@igalia.com, x86@kernel.org, linux-kernel@vger.kernel.org In-Reply-To: <20260602090535.308220888@kernel.org> References: <20260602090535.308220888@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-ID: <178049670507.710.16711905151748466307.tip-bot2@tip-bot2> Robot-ID: Robot-Unsubscribe: Contact to get blacklisted from these emails Precedence: bulk Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable The following commit has been merged into the locking/core branch of tip: Commit-ID: c1ffc9c6e4f8a13dd68e97920c9a24d095c6e41a Gitweb: https://git.kernel.org/tip/c1ffc9c6e4f8a13dd68e97920c9a24d09= 5c6e41a Author: Thomas Gleixner AuthorDate: Tue, 02 Jun 2026 11:09:25 +02:00 Committer: Peter Zijlstra CommitterDate: Wed, 03 Jun 2026 11:38:49 +02:00 futex: Move futex task related data into a struct Having all these members in task_struct along with the required #ifdeffery is annoying, does not allow efficient initializing of the data with memset() and makes extending it tedious. Move it into a data structure and fix up all usage sites. Signed-off-by: Thomas Gleixner Signed-off-by: Peter Zijlstra (Intel) Reviewed-by: Mathieu Desnoyers Reviewed-by: Andr=C3=A9 Almeida Link: https://patch.msgid.link/20260602090535.308220888@kernel.org --- Documentation/locking/robust-futexes.rst | 8 +-- include/linux/futex.h | 12 +---- include/linux/futex_types.h | 36 ++++++++++++++- include/linux/sched.h | 16 +----- kernel/exit.c | 4 +- kernel/futex/core.c | 59 +++++++++++------------ kernel/futex/pi.c | 26 +++++----- kernel/futex/syscalls.c | 23 +++------ 8 files changed, 101 insertions(+), 83 deletions(-) create mode 100644 include/linux/futex_types.h diff --git a/Documentation/locking/robust-futexes.rst b/Documentation/locki= ng/robust-futexes.rst index 6361fb0..1423f53 100644 --- a/Documentation/locking/robust-futexes.rst +++ b/Documentation/locking/robust-futexes.rst @@ -94,7 +94,7 @@ time, the kernel checks this user-space list: are there a= ny robust futex locks to be cleaned up? =20 In the common case, at do_exit() time, there is no list registered, so -the cost of robust futexes is just a simple current->robust_list !=3D NULL +the cost of robust futexes is just a current->futex.robust_list !=3D NULL comparison. If the thread has registered a list, then normally the list is empty. If the thread/process crashed or terminated in some incorrect way then the list might be non-empty: in this case the kernel carefully @@ -178,9 +178,9 @@ one to query the registered list pointer:: size_t __user *len_ptr); =20 List registration is very fast: the pointer is simply stored in -current->robust_list. [Note that in the future, if robust futexes become -widespread, we could extend sys_clone() to register a robust-list head -for new threads, without the need of another syscall.] +current->futex.robust_list. [Note that in the future, if robust futexes +become widespread, we could extend sys_clone() to register a robust-list +head for new threads, without the need of another syscall.] =20 So there is virtually zero overhead for tasks not using robust futexes, and even for robust futex users, there is only one extra syscall per diff --git a/include/linux/futex.h b/include/linux/futex.h index 9e9750f..563e8dd 100644 --- a/include/linux/futex.h +++ b/include/linux/futex.h @@ -64,14 +64,10 @@ enum { =20 static inline void futex_init_task(struct task_struct *tsk) { - tsk->robust_list =3D NULL; -#ifdef CONFIG_COMPAT - tsk->compat_robust_list =3D NULL; -#endif - INIT_LIST_HEAD(&tsk->pi_state_list); - tsk->pi_state_cache =3D NULL; - tsk->futex_state =3D FUTEX_STATE_OK; - mutex_init(&tsk->futex_exit_mutex); + memset(&tsk->futex, 0, sizeof(tsk->futex)); + INIT_LIST_HEAD(&tsk->futex.pi_state_list); + tsk->futex.state =3D FUTEX_STATE_OK; + mutex_init(&tsk->futex.exit_mutex); } =20 void futex_exit_recursive(struct task_struct *tsk); diff --git a/include/linux/futex_types.h b/include/linux/futex_types.h new file mode 100644 index 0000000..9c6c0dc --- /dev/null +++ b/include/linux/futex_types.h @@ -0,0 +1,36 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _LINUX_FUTEX_TYPES_H +#define _LINUX_FUTEX_TYPES_H + +#ifdef CONFIG_FUTEX +#include +#include + +struct compat_robust_list_head; +struct futex_pi_state; +struct robust_list_head; + +/** + * struct futex_sched_data - Futex related per task data + * @robust_list: User space registered robust list pointer + * @compat_robust_list: User space registered robust list pointer for comp= at tasks + * @pi_state_list: List head for Priority Inheritance (PI) state management + * @pi_state_cache: Pointer to cache one PI state object per task + * @exit_mutex: Mutex for serializing exit + * @state: Futex handling state to handle exit races correctly + */ +struct futex_sched_data { + struct robust_list_head __user *robust_list; +#ifdef CONFIG_COMPAT + struct compat_robust_list_head __user *compat_robust_list; +#endif + struct list_head pi_state_list; + struct futex_pi_state *pi_state_cache; + struct mutex exit_mutex; + unsigned int state; +}; +#else +struct futex_sched_data { }; +#endif /* !CONFIG_FUTEX */ + +#endif /* _LINUX_FUTEX_TYPES_H */ diff --git a/include/linux/sched.h b/include/linux/sched.h index 368c7b4..c88fc10 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -16,6 +16,7 @@ #include =20 #include +#include #include #include #include @@ -64,7 +65,6 @@ struct bpf_net_context; struct capture_control; struct cfs_rq; struct fs_struct; -struct futex_pi_state; struct io_context; struct io_uring_task; struct mempolicy; @@ -76,7 +76,6 @@ struct pid_namespace; struct pipe_inode_info; struct rcu_node; struct reclaim_state; -struct robust_list_head; struct root_domain; struct rq; struct sched_attr; @@ -1331,16 +1330,9 @@ struct task_struct { u32 closid; u32 rmid; #endif -#ifdef CONFIG_FUTEX - struct robust_list_head __user *robust_list; -#ifdef CONFIG_COMPAT - struct compat_robust_list_head __user *compat_robust_list; -#endif - struct list_head pi_state_list; - struct futex_pi_state *pi_state_cache; - struct mutex futex_exit_mutex; - unsigned int futex_state; -#endif + + struct futex_sched_data futex; + #ifdef CONFIG_PERF_EVENTS u8 perf_recursion[PERF_NR_CONTEXTS]; struct perf_event_context *perf_event_ctxp; diff --git a/kernel/exit.c b/kernel/exit.c index 25e9cb6..1b4e55b 100644 --- a/kernel/exit.c +++ b/kernel/exit.c @@ -988,8 +988,8 @@ void __noreturn do_exit(long code) proc_exit_connector(tsk); mpol_put_task_policy(tsk); #ifdef CONFIG_FUTEX - if (unlikely(current->pi_state_cache)) - kfree(current->pi_state_cache); + if (unlikely(current->futex.pi_state_cache)) + kfree(current->futex.pi_state_cache); #endif /* * Make sure we are holding no locks: diff --git a/kernel/futex/core.c b/kernel/futex/core.c index ff2a4fb..e7d33d2 100644 --- a/kernel/futex/core.c +++ b/kernel/futex/core.c @@ -32,18 +32,19 @@ * "But they come in a choice of three flavours!" */ #include -#include -#include #include -#include +#include #include -#include +#include #include -#include -#include -#include #include #include +#include +#include +#include +#include +#include +#include =20 #include "futex.h" #include "../locking/rtmutex_common.h" @@ -829,7 +830,7 @@ void wait_for_owner_exiting(int ret, struct task_struct= *exiting) if (WARN_ON_ONCE(ret =3D=3D -EBUSY && !exiting)) return; =20 - mutex_lock(&exiting->futex_exit_mutex); + mutex_lock(&exiting->futex.exit_mutex); /* * No point in doing state checking here. If the waiter got here * while the task was in exec()->exec_futex_release() then it can @@ -838,7 +839,7 @@ void wait_for_owner_exiting(int ret, struct task_struct= *exiting) * already. Highly unlikely and not a problem. Just one more round * through the futex maze. */ - mutex_unlock(&exiting->futex_exit_mutex); + mutex_unlock(&exiting->futex.exit_mutex); =20 put_task_struct(exiting); } @@ -1047,7 +1048,7 @@ retry: * * In both cases the following conditions are met: * - * 1) task->robust_list->list_op_pending !=3D NULL + * 1) task->futex.robust_list->list_op_pending !=3D NULL * @pending_op =3D=3D true * 2) The owner part of user space futex value =3D=3D 0 * 3) Regular futex: @pi =3D=3D false @@ -1152,7 +1153,7 @@ static inline int fetch_robust_entry(struct robust_li= st __user **entry, */ static void exit_robust_list(struct task_struct *curr) { - struct robust_list_head __user *head =3D curr->robust_list; + struct robust_list_head __user *head =3D curr->futex.robust_list; struct robust_list __user *entry, *next_entry, *pending; unsigned int limit =3D ROBUST_LIST_LIMIT, pi, pip; unsigned int next_pi; @@ -1246,7 +1247,7 @@ compat_fetch_robust_entry(compat_uptr_t *uentry, stru= ct robust_list __user **ent */ static void compat_exit_robust_list(struct task_struct *curr) { - struct compat_robust_list_head __user *head =3D curr->compat_robust_list; + struct compat_robust_list_head __user *head =3D curr->futex.compat_robust= _list; struct robust_list __user *entry, *next_entry, *pending; unsigned int limit =3D ROBUST_LIST_LIMIT, pi, pip; unsigned int next_pi; @@ -1322,7 +1323,7 @@ static void compat_exit_robust_list(struct task_struc= t *curr) */ static void exit_pi_state_list(struct task_struct *curr) { - struct list_head *next, *head =3D &curr->pi_state_list; + struct list_head *next, *head =3D &curr->futex.pi_state_list; struct futex_pi_state *pi_state; union futex_key key =3D FUTEX_KEY_INIT; =20 @@ -1406,19 +1407,19 @@ static inline void exit_pi_state_list(struct task_s= truct *curr) { } =20 static void futex_cleanup(struct task_struct *tsk) { - if (unlikely(tsk->robust_list)) { + if (unlikely(tsk->futex.robust_list)) { exit_robust_list(tsk); - tsk->robust_list =3D NULL; + tsk->futex.robust_list =3D NULL; } =20 #ifdef CONFIG_COMPAT - if (unlikely(tsk->compat_robust_list)) { + if (unlikely(tsk->futex.compat_robust_list)) { compat_exit_robust_list(tsk); - tsk->compat_robust_list =3D NULL; + tsk->futex.compat_robust_list =3D NULL; } #endif =20 - if (unlikely(!list_empty(&tsk->pi_state_list))) + if (unlikely(!list_empty(&tsk->futex.pi_state_list))) exit_pi_state_list(tsk); } =20 @@ -1442,23 +1443,23 @@ static void futex_cleanup(struct task_struct *tsk) void futex_exit_recursive(struct task_struct *tsk) { /* If the state is FUTEX_STATE_EXITING then futex_exit_mutex is held */ - if (tsk->futex_state =3D=3D FUTEX_STATE_EXITING) { - __assume_ctx_lock(&tsk->futex_exit_mutex); - mutex_unlock(&tsk->futex_exit_mutex); + if (tsk->futex.state =3D=3D FUTEX_STATE_EXITING) { + __assume_ctx_lock(&tsk->futex.exit_mutex); + mutex_unlock(&tsk->futex.exit_mutex); } - tsk->futex_state =3D FUTEX_STATE_DEAD; + tsk->futex.state =3D FUTEX_STATE_DEAD; } =20 static void futex_cleanup_begin(struct task_struct *tsk) - __acquires(&tsk->futex_exit_mutex) + __acquires(&tsk->futex.exit_mutex) { /* * Prevent various race issues against a concurrent incoming waiter * including live locks by forcing the waiter to block on - * tsk->futex_exit_mutex when it observes FUTEX_STATE_EXITING in + * tsk->futex.exit_mutex when it observes FUTEX_STATE_EXITING in * attach_to_pi_owner(). */ - mutex_lock(&tsk->futex_exit_mutex); + mutex_lock(&tsk->futex.exit_mutex); =20 /* * Switch the state to FUTEX_STATE_EXITING under tsk->pi_lock. @@ -1472,23 +1473,23 @@ static void futex_cleanup_begin(struct task_struct = *tsk) * be observed in exit_pi_state_list(). */ raw_spin_lock_irq(&tsk->pi_lock); - tsk->futex_state =3D FUTEX_STATE_EXITING; + tsk->futex.state =3D FUTEX_STATE_EXITING; raw_spin_unlock_irq(&tsk->pi_lock); } =20 static void futex_cleanup_end(struct task_struct *tsk, int state) - __releases(&tsk->futex_exit_mutex) + __releases(&tsk->futex.exit_mutex) { /* * Lockless store. The only side effect is that an observer might * take another loop until it becomes visible. */ - tsk->futex_state =3D state; + tsk->futex.state =3D state; /* * Drop the exit protection. This unblocks waiters which observed * FUTEX_STATE_EXITING to reevaluate the state. */ - mutex_unlock(&tsk->futex_exit_mutex); + mutex_unlock(&tsk->futex.exit_mutex); } =20 void futex_exec_release(struct task_struct *tsk) diff --git a/kernel/futex/pi.c b/kernel/futex/pi.c index 643199f..e037a97 100644 --- a/kernel/futex/pi.c +++ b/kernel/futex/pi.c @@ -14,7 +14,7 @@ int refill_pi_state_cache(void) { struct futex_pi_state *pi_state; =20 - if (likely(current->pi_state_cache)) + if (likely(current->futex.pi_state_cache)) return 0; =20 pi_state =3D kzalloc_obj(*pi_state); @@ -28,17 +28,17 @@ int refill_pi_state_cache(void) refcount_set(&pi_state->refcount, 1); pi_state->key =3D FUTEX_KEY_INIT; =20 - current->pi_state_cache =3D pi_state; + current->futex.pi_state_cache =3D pi_state; =20 return 0; } =20 static struct futex_pi_state *alloc_pi_state(void) { - struct futex_pi_state *pi_state =3D current->pi_state_cache; + struct futex_pi_state *pi_state =3D current->futex.pi_state_cache; =20 WARN_ON(!pi_state); - current->pi_state_cache =3D NULL; + current->futex.pi_state_cache =3D NULL; =20 return pi_state; } @@ -60,7 +60,7 @@ static void pi_state_update_owner(struct futex_pi_state *= pi_state, if (new_owner) { raw_spin_lock(&new_owner->pi_lock); WARN_ON(!list_empty(&pi_state->list)); - list_add(&pi_state->list, &new_owner->pi_state_list); + list_add(&pi_state->list, &new_owner->futex.pi_state_list); pi_state->owner =3D new_owner; raw_spin_unlock(&new_owner->pi_lock); } @@ -96,7 +96,7 @@ void put_pi_state(struct futex_pi_state *pi_state) raw_spin_unlock_irqrestore(&pi_state->pi_mutex.wait_lock, flags); } =20 - if (current->pi_state_cache) { + if (current->futex.pi_state_cache) { kfree(pi_state); } else { /* @@ -106,7 +106,7 @@ void put_pi_state(struct futex_pi_state *pi_state) */ pi_state->owner =3D NULL; refcount_set(&pi_state->refcount, 1); - current->pi_state_cache =3D pi_state; + current->futex.pi_state_cache =3D pi_state; } } =20 @@ -179,7 +179,7 @@ void put_pi_state(struct futex_pi_state *pi_state) * * p->pi_lock: * - * p->pi_state_list -> pi_state->list, relation + * p->futex.pi_state_list -> pi_state->list, relation * pi_mutex->owner -> pi_state->owner, relation * * pi_state->refcount: @@ -327,7 +327,7 @@ static int handle_exit_race(u32 __user *uaddr, u32 uval, * If the futex exit state is not yet FUTEX_STATE_DEAD, tell the * caller that the alleged owner is busy. */ - if (tsk && tsk->futex_state !=3D FUTEX_STATE_DEAD) + if (tsk && tsk->futex.state !=3D FUTEX_STATE_DEAD) return -EBUSY; =20 /* @@ -346,8 +346,8 @@ static int handle_exit_race(u32 __user *uaddr, u32 uval, * *uaddr =3D 0xC0000000; tsk =3D get_task(PID); * } if (!tsk->flags & PF_EXITING) { * ... attach(); - * tsk->futex_state =3D } else { - * FUTEX_STATE_DEAD; if (tsk->futex_state !=3D + * tsk->futex.state =3D } else { + * FUTEX_STATE_DEAD; if (tsk->futex.state !=3D * FUTEX_STATE_DEAD) * return -EAGAIN; * return -ESRCH; <--- FAIL @@ -396,7 +396,7 @@ static void __attach_to_pi_owner(struct task_struct *p,= union futex_key *key, pi_state->key =3D *key; =20 WARN_ON(!list_empty(&pi_state->list)); - list_add(&pi_state->list, &p->pi_state_list); + list_add(&pi_state->list, &p->futex.pi_state_list); /* * Assignment without holding pi_state->pi_mutex.wait_lock is safe * because there is no concurrency as the object is not published yet. @@ -440,7 +440,7 @@ static int attach_to_pi_owner(u32 __user *uaddr, u32 uv= al, union futex_key *key, * in futex_exit_release(), we do this protected by p->pi_lock: */ raw_spin_lock_irq(&p->pi_lock); - if (unlikely(p->futex_state !=3D FUTEX_STATE_OK)) { + if (unlikely(p->futex.state !=3D FUTEX_STATE_OK)) { /* * The task is on the way out. When the futex state is * FUTEX_STATE_DEAD, we know that the task has finished diff --git a/kernel/futex/syscalls.c b/kernel/futex/syscalls.c index 77ad969..8944ff4 100644 --- a/kernel/futex/syscalls.c +++ b/kernel/futex/syscalls.c @@ -25,17 +25,13 @@ * @head: pointer to the list-head * @len: length of the list-head, as userspace expects */ -SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, - size_t, len) +SYSCALL_DEFINE2(set_robust_list, struct robust_list_head __user *, head, s= ize_t, len) { - /* - * The kernel knows only one size for now: - */ + /* The kernel knows only one size for now. */ if (unlikely(len !=3D sizeof(*head))) return -EINVAL; =20 - current->robust_list =3D head; - + current->futex.robust_list =3D head; return 0; } =20 @@ -43,9 +39,9 @@ static inline void __user *futex_task_robust_list(struct = task_struct *p, bool co { #ifdef CONFIG_COMPAT if (compat) - return p->compat_robust_list; + return p->futex.compat_robust_list; #endif - return p->robust_list; + return p->futex.robust_list; } =20 static void __user *futex_get_robust_list_common(int pid, bool compat) @@ -475,15 +471,13 @@ SYSCALL_DEFINE4(futex_requeue, } =20 #ifdef CONFIG_COMPAT -COMPAT_SYSCALL_DEFINE2(set_robust_list, - struct compat_robust_list_head __user *, head, - compat_size_t, len) +COMPAT_SYSCALL_DEFINE2(set_robust_list, struct compat_robust_list_head __u= ser *, head, + compat_size_t, len) { if (unlikely(len !=3D sizeof(*head))) return -EINVAL; =20 - current->compat_robust_list =3D head; - + current->futex.compat_robust_list =3D head; return 0; } =20 @@ -523,4 +517,3 @@ SYSCALL_DEFINE6(futex_time32, u32 __user *, uaddr, int,= op, u32, val, return do_futex(uaddr, op, val, tp, uaddr2, (unsigned long)utime, val3); } #endif /* CONFIG_COMPAT_32BIT_TIME */ -