Re: [patch V3 03/14] futex: Move futex related mm_struct data into a struct

Alexander Kuleshov
2026-03-30T15:23:43Z

Hello Thomas,

On Mon, Mar 30, 2026 at 5:05 PM Thomas Gleixner <tglx@kernel.org> wrote:
>
> +#ifdef CONFIG_FUTEX_PRIVATE_HASH
> +/**
> + * struct futex_mm_phash - Futex private hash related per MM data
> + * @lock: Mutex to protect the private hash operations
> + * @hash: RCU managed pointer to the private hash
> + * @hash_new: Pointer to a newly allocated private hash
> + * @batches: Batch state for RCU synchronization
> + * @rcu: RCU head for call_rcu()
> + * @atomic: Aggregate value for @hash_ref
> + * @ref: Per CPU reference counter for a private hash
> + */
> +struct futex_mm_phash {
> + struct mutex lock;
> + struct futex_private_hash __rcu *hash;
> + struct futex_private_hash *hash_new;
> + unsigned long batches;
> + struct rcu_head rcu;
> + atomic_long_t atomic;
> + unsigned int __percpu *ref;
> +};
> +#else /* CONFIG_FUTEX_ROBUST_UNLOCK */

The comment here should be CONFIG_FUTEX_PRIVATE_HASH

> +struct futex_mm_phash { };
> +#endif /* !CONFIG_FUTEX_ROBUST_UNLOCK */

And the same.

> +/**
> + * struct futex_mm_data - Futex related per MM data
> + * @phash: Futex private hash related data
> + */
> +struct futex_mm_data {
> + struct futex_mm_phash phash;
> +};
> +#else /* CONFIG_FUTEX */
> struct futex_sched_data { };
> +struct futex_mm_data { };
> #endif /* !CONFIG_FUTEX */
>
> #endif /* _LINUX_FUTEX_TYPES_H */
> --- a/include/linux/mm_types.h
> +++ b/include/linux/mm_types.h
> @@ -1221,16 +1221,7 @@ struct mm_struct {
> */
> seqcount_t mm_lock_seq;
> #endif
> -#ifdef CONFIG_FUTEX_PRIVATE_HASH
> - struct mutex futex_hash_lock;
> - struct futex_private_hash __rcu *futex_phash;
> - struct futex_private_hash *futex_phash_new;
> - /* futex-ref */
> - unsigned long futex_batches;
> - struct rcu_head futex_rcu;
> - atomic_long_t futex_atomic;
> - unsigned int __percpu *futex_ref;
> -#endif
> + struct futex_mm_data futex;
>
> unsigned long hiwater_rss; /* High-watermark of RSS usage */
> unsigned long hiwater_vm; /* High-water virtual memory usage */
> --- a/kernel/futex/core.c
> +++ b/kernel/futex/core.c
> @@ -188,13 +188,13 @@ static struct futex_hash_bucket *
> return NULL;
>
> if (!fph)
> - fph = rcu_dereference(key->private.mm->futex_phash);
> + fph = rcu_dereference(key->private.mm->futex.phash.hash);
> if (!fph || !fph->hash_mask)
> return NULL;
>
> - hash = jhash2((void *)&key->private.address,
> - sizeof(key->private.address) / 4,
> + hash = jhash2((void *)&key->private.address, sizeof(key->private.address) / 4,
> key->both.offset);
> +
> return &fph->queues[hash & fph->hash_mask];
> }
>
> @@ -233,18 +233,17 @@ static void futex_rehash_private(struct
> }
> }
>
> -static bool __futex_pivot_hash(struct mm_struct *mm,
> - struct futex_private_hash *new)
> +static bool __futex_pivot_hash(struct mm_struct *mm, struct futex_private_hash *new)
> {
> + struct futex_mm_phash *mmph = &mm->futex.phash;
> struct futex_private_hash *fph;
>
> - WARN_ON_ONCE(mm->futex_phash_new);
> + WARN_ON_ONCE(mmph->hash_new);
>
> - fph = rcu_dereference_protected(mm->futex_phash,
> - lockdep_is_held(&mm->futex_hash_lock));
> + fph = rcu_dereference_protected(mmph->hash, lockdep_is_held(&mmph->lock));
> if (fph) {
> if (!futex_ref_is_dead(fph)) {
> - mm->futex_phash_new = new;
> + mmph->hash_new = new;
> return false;
> }
>
> @@ -252,8 +251,8 @@ static bool __futex_pivot_hash(struct mm
> }
> new->state = FR_PERCPU;
> scoped_guard(rcu) {
> - mm->futex_batches = get_state_synchronize_rcu();
> - rcu_assign_pointer(mm->futex_phash, new);
> + mmph->batches = get_state_synchronize_rcu();
> + rcu_assign_pointer(mmph->hash, new);
> }
> kvfree_rcu(fph, rcu);
> return true;
> @@ -261,12 +260,12 @@ static bool __futex_pivot_hash(struct mm
>
> static void futex_pivot_hash(struct mm_struct *mm)
> {
> - scoped_guard(mutex, &mm->futex_hash_lock) {
> + scoped_guard(mutex, &mm->futex.phash.lock) {
> struct futex_private_hash *fph;
>
> - fph = mm->futex_phash_new;
> + fph = mm->futex.phash.hash_new;
> if (fph) {
> - mm->futex_phash_new = NULL;
> + mm->futex.phash.hash_new = NULL;
> __futex_pivot_hash(mm, fph);
> }
> }
> @@ -289,7 +288,7 @@ struct futex_private_hash *futex_private
> scoped_guard(rcu) {
> struct futex_private_hash *fph;
>
> - fph = rcu_dereference(mm->futex_phash);
> + fph = rcu_dereference(mm->futex.phash.hash);
> if (!fph)
> return NULL;
>
> @@ -412,8 +411,7 @@ static int futex_mpol(struct mm_struct *
> * private hash) is returned if existing. Otherwise a hash bucket from the
> * global hash is returned.
> */
> -static struct futex_hash_bucket *
> -__futex_hash(union futex_key *key, struct futex_private_hash *fph)
> +static struct futex_hash_bucket *__futex_hash(union futex_key *key, struct futex_private_hash *fph)
> {
> int node = key->both.node;
> u32 hash;
> @@ -426,8 +424,7 @@ static struct futex_hash_bucket *
> return hb;
> }
>
> - hash = jhash2((u32 *)key,
> - offsetof(typeof(*key), both.offset) / sizeof(u32),
> + hash = jhash2((u32 *)key, offsetof(typeof(*key), both.offset) / sizeof(u32),
> key->both.offset);
>
> if (node == FUTEX_NO_NODE) {
> @@ -442,8 +439,7 @@ static struct futex_hash_bucket *
> */
> node = (hash >> futex_hashshift) % nr_node_ids;
> if (!node_possible(node)) {
> - node = find_next_bit_wrap(node_possible_map.bits,
> - nr_node_ids, node);
> + node = find_next_bit_wrap(node_possible_map.bits, nr_node_ids, node);
> }
> }
>
> @@ -460,9 +456,8 @@ static struct futex_hash_bucket *
> * Return: Initialized hrtimer_sleeper structure or NULL if no timeout
> * value given
> */
> -struct hrtimer_sleeper *
> -futex_setup_timer(ktime_t *time, struct hrtimer_sleeper *timeout,
> - int flags, u64 range_ns)
> +struct hrtimer_sleeper *futex_setup_timer(ktime_t *time, struct hrtimer_sleeper *timeout,
> + int flags, u64 range_ns)
> {
> if (!time)
> return NULL;
> @@ -1551,17 +1546,17 @@ static void __futex_ref_atomic_begin(str
> * otherwise it would be impossible for it to have reported success
> * from futex_ref_is_dead().
> */
> - WARN_ON_ONCE(atomic_long_read(&mm->futex_atomic) != 0);
> + WARN_ON_ONCE(atomic_long_read(&mm->futex.phash.atomic) != 0);
>
> /*
> * Set the atomic to the bias value such that futex_ref_{get,put}()
> * will never observe 0. Will be fixed up in __futex_ref_atomic_end()
> * when folding in the percpu count.
> */
> - atomic_long_set(&mm->futex_atomic, LONG_MAX);
> + atomic_long_set(&mm->futex.phash.atomic, LONG_MAX);
> smp_store_release(&fph->state, FR_ATOMIC);
>
> - call_rcu_hurry(&mm->futex_rcu, futex_ref_rcu);
> + call_rcu_hurry(&mm->futex.phash.rcu, futex_ref_rcu);
> }
>
> static void __futex_ref_atomic_end(struct futex_private_hash *fph)
> @@ -1582,7 +1577,7 @@ static void __futex_ref_atomic_end(struc
> * Therefore the per-cpu counter is now stable, sum and reset.
> */
> for_each_possible_cpu(cpu) {
> - unsigned int *ptr = per_cpu_ptr(mm->futex_ref, cpu);
> + unsigned int *ptr = per_cpu_ptr(mm->futex.phash.ref, cpu);
> count += *ptr;
> *ptr = 0;
> }
> @@ -1590,7 +1585,7 @@ static void __futex_ref_atomic_end(struc
> /*
> * Re-init for the next cycle.
> */
> - this_cpu_inc(*mm->futex_ref); /* 0 -> 1 */
> + this_cpu_inc(*mm->futex.phash.ref); /* 0 -> 1 */
>
> /*
> * Add actual count, subtract bias and initial refcount.
> @@ -1598,7 +1593,7 @@ static void __futex_ref_atomic_end(struc
> * The moment this atomic operation happens, futex_ref_is_dead() can
> * become true.
> */
> - ret = atomic_long_add_return(count - LONG_MAX - 1, &mm->futex_atomic);
> + ret = atomic_long_add_return(count - LONG_MAX - 1, &mm->futex.phash.atomic);
> if (!ret)
> wake_up_var(mm);
>
> @@ -1608,8 +1603,8 @@ static void __futex_ref_atomic_end(struc
>
> static void futex_ref_rcu(struct rcu_head *head)
> {
> - struct mm_struct *mm = container_of(head, struct mm_struct, futex_rcu);
> - struct futex_private_hash *fph = rcu_dereference_raw(mm->futex_phash);
> + struct mm_struct *mm = container_of(head, struct mm_struct, futex.phash.rcu);
> + struct futex_private_hash *fph = rcu_dereference_raw(mm->futex.phash.hash);
>
> if (fph->state == FR_PERCPU) {
> /*
> @@ -1638,7 +1633,7 @@ static void futex_ref_drop(struct futex_
> /*
> * Can only transition the current fph;
> */
> - WARN_ON_ONCE(rcu_dereference_raw(mm->futex_phash) != fph);
> + WARN_ON_ONCE(rcu_dereference_raw(mm->futex.phash.hash) != fph);
> /*
> * We enqueue at least one RCU callback. Ensure mm stays if the task
> * exits before the transition is completed.
> @@ -1649,9 +1644,9 @@ static void futex_ref_drop(struct futex_
> * In order to avoid the following scenario:
> *
> * futex_hash() __futex_pivot_hash()
> - * guard(rcu); guard(mm->futex_hash_lock);
> - * fph = mm->futex_phash;
> - * rcu_assign_pointer(&mm->futex_phash, new);
> + * guard(rcu); guard(mm->futex.phash.lock);
> + * fph = mm->futex.phash.hash;
> + * rcu_assign_pointer(&mm->futex.phash.hash, new);
> * futex_hash_allocate()
> * futex_ref_drop()
> * fph->state = FR_ATOMIC;
> @@ -1666,7 +1661,7 @@ static void futex_ref_drop(struct futex_
> * There must be at least one full grace-period between publishing a
> * new fph and trying to replace it.
> */
> - if (poll_state_synchronize_rcu(mm->futex_batches)) {
> + if (poll_state_synchronize_rcu(mm->futex.phash.batches)) {
> /*
> * There was a grace-period, we can begin now.
> */
> @@ -1674,7 +1669,7 @@ static void futex_ref_drop(struct futex_
> return;
> }
>
> - call_rcu_hurry(&mm->futex_rcu, futex_ref_rcu);
> + call_rcu_hurry(&mm->futex.phash.rcu, futex_ref_rcu);
> }
>
> static bool futex_ref_get(struct futex_private_hash *fph)
> @@ -1684,11 +1679,11 @@ static bool futex_ref_get(struct futex_p
> guard(preempt)();
>
> if (READ_ONCE(fph->state) == FR_PERCPU) {
> - __this_cpu_inc(*mm->futex_ref);
> + __this_cpu_inc(*mm->futex.phash.ref);
> return true;
> }
>
> - return atomic_long_inc_not_zero(&mm->futex_atomic);
> + return atomic_long_inc_not_zero(&mm->futex.phash.atomic);
> }
>
> static bool futex_ref_put(struct futex_private_hash *fph)
> @@ -1698,11 +1693,11 @@ static bool futex_ref_put(struct futex_p
> guard(preempt)();
>
> if (READ_ONCE(fph->state) == FR_PERCPU) {
> - __this_cpu_dec(*mm->futex_ref);
> + __this_cpu_dec(*mm->futex.phash.ref);
> return false;
> }
>
> - return atomic_long_dec_and_test(&mm->futex_atomic);
> + return atomic_long_dec_and_test(&mm->futex.phash.atomic);
> }
>
> static bool futex_ref_is_dead(struct futex_private_hash *fph)
> @@ -1714,27 +1709,23 @@ static bool futex_ref_is_dead(struct fut
> if (smp_load_acquire(&fph->state) == FR_PERCPU)
> return false;
>
> - return atomic_long_read(&mm->futex_atomic) == 0;
> + return atomic_long_read(&mm->futex.phash.atomic) == 0;
> }
>
> void futex_mm_init(struct mm_struct *mm)
> {
> - mutex_init(&mm->futex_hash_lock);
> - RCU_INIT_POINTER(mm->futex_phash, NULL);
> - mm->futex_phash_new = NULL;
> - /* futex-ref */
> - mm->futex_ref = NULL;
> - atomic_long_set(&mm->futex_atomic, 0);
> - mm->futex_batches = get_state_synchronize_rcu();
> + memset(&mm->futex, 0, sizeof(mm->futex));
> + mutex_init(&mm->futex.phash.lock);
> + mm->futex.phash.batches = get_state_synchronize_rcu();
> }
>
> void futex_hash_free(struct mm_struct *mm)
> {
> struct futex_private_hash *fph;
>
> - free_percpu(mm->futex_ref);
> - kvfree(mm->futex_phash_new);
> - fph = rcu_dereference_raw(mm->futex_phash);
> + free_percpu(mm->futex.phash.ref);
> + kvfree(mm->futex.phash.hash_new);
> + fph = rcu_dereference_raw(mm->futex.phash.hash);
> if (fph)
> kvfree(fph);
> }
> @@ -1745,10 +1736,10 @@ static bool futex_pivot_pending(struct m
>
> guard(rcu)();
>
> - if (!mm->futex_phash_new)
> + if (!mm->futex.phash.hash_new)
> return true;
>
> - fph = rcu_dereference(mm->futex_phash);
> + fph = rcu_dereference(mm->futex.phash.hash);
> return futex_ref_is_dead(fph);
> }
>
> @@ -1790,7 +1781,7 @@ static int futex_hash_allocate(unsigned
> * Once we've disabled the global hash there is no way back.
> */
> scoped_guard(rcu) {
> - fph = rcu_dereference(mm->futex_phash);
> + fph = rcu_dereference(mm->futex.phash.hash);
> if (fph && !fph->hash_mask) {
> if (custom)
> return -EBUSY;
> @@ -1798,15 +1789,15 @@ static int futex_hash_allocate(unsigned
> }
> }
>
> - if (!mm->futex_ref) {
> + if (!mm->futex.phash.ref) {
> /*
> * This will always be allocated by the first thread and
> * therefore requires no locking.
> */
> - mm->futex_ref = alloc_percpu(unsigned int);
> - if (!mm->futex_ref)
> + mm->futex.phash.ref = alloc_percpu(unsigned int);
> + if (!mm->futex.phash.ref)
> return -ENOMEM;
> - this_cpu_inc(*mm->futex_ref); /* 0 -> 1 */
> + this_cpu_inc(*mm->futex.phash.ref); /* 0 -> 1 */
> }
>
> fph = kvzalloc(struct_size(fph, queues, hash_slots),
> @@ -1829,14 +1820,14 @@ static int futex_hash_allocate(unsigned
> wait_var_event(mm, futex_pivot_pending(mm));
> }
>
> - scoped_guard(mutex, &mm->futex_hash_lock) {
> + scoped_guard(mutex, &mm->futex.phash.lock) {
> struct futex_private_hash *free __free(kvfree) = NULL;
> struct futex_private_hash *cur, *new;
>
> - cur = rcu_dereference_protected(mm->futex_phash,
> - lockdep_is_held(&mm->futex_hash_lock));
> - new = mm->futex_phash_new;
> - mm->futex_phash_new = NULL;
> + cur = rcu_dereference_protected(mm->futex.phash.hash,
> + lockdep_is_held(&mm->futex.phash.lock));
> + new = mm->futex.phash.hash_new;
> + mm->futex.phash.hash_new = NULL;
>
> if (fph) {
> if (cur && !cur->hash_mask) {
> @@ -1846,7 +1837,7 @@ static int futex_hash_allocate(unsigned
> * the second one returns here.
> */
> free = fph;
> - mm->futex_phash_new = new;
> + mm->futex.phash.hash_new = new;
> return -EBUSY;
> }
> if (cur && !new) {
> @@ -1876,7 +1867,7 @@ static int futex_hash_allocate(unsigned
>
> if (new) {
> /*
> - * Will set mm->futex_phash_new on failure;
> + * Will set mm->futex.phash_new on failure;

mm->futex.phash.hash_new?