Add a helper to do what is needed when the maple copy node contains a
new root node.  This is useful for future commits and is
self-documenting code.

Signed-off-by: Liam R. Howlett <Liam.Howlett@oracle.com>
---
 lib/maple_tree.c | 70 ++++++++++++++++++++++++++----------------------
 1 file changed, 38 insertions(+), 32 deletions(-)

diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index 5280fa6d2d6ec..42038e42a4c7e 100644
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -3337,6 +3337,43 @@ static void mas_spanning_rebalance(struct ma_state *mas,
 	mas_spanning_rebalance_loop(mas, mast, count);
 }
 
+static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
+{
+	if (cp->min || cp->max != ULONG_MAX)
+		return false;
+
+	if (cp->d_count != 1) {
+		enum maple_type mt = maple_arange_64;
+
+		if (!mt_is_alloc(mas->tree))
+			mt = maple_range_64;
+
+		cp->data = cp->d_count;
+		cp->s_count = 0;
+		dst_setup(cp, mas, mt);
+		init_cp_src(cp);
+		node_copy(mas, cp->src[0].node, 0, cp->data, cp->max, maple_copy,
+			  cp->dst[0].node, 0, mt);
+		node_finalise(cp->dst[0].node, mt, cp->end + 1);
+		/*
+		 * Warning, see cp_leaf_init() comment and rcu_assign_pointer()
+		 * documentation.  Since this is a new root, there are no
+		 * read-side operations that can view it until it is insert into
+		 * the tree after an rcu_assign_pointer() call.
+		 */
+		RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
+		cp->height++;
+	}
+	WARN_ON_ONCE(cp->dst[0].node != mte_to_node(
+				mt_slot_locked(mas->tree, cp->slot, 0)));
+	cp->dst[0].node->parent = ma_parent_ptr(mas_tree_parent(mas));
+	mas->min = 0;
+	mas->max = ULONG_MAX;
+	mas->depth = 0;
+	mas->node = mas_root_locked(mas);
+	return true;
+}
+
 /*
  * spanning_ascend() - See if a spanning store operation has to keep walking up
  * the tree
@@ -3359,39 +3396,8 @@ static bool spanning_ascend(struct maple_copy *cp, struct ma_state *mas,
 	}
 
 	cp_dst_to_slots(cp, l_wr_mas->mas->min, r_wr_mas->mas->max, mas);
-	if (!cp->min && cp->max == ULONG_MAX) {
-		/* New root */
-		if (cp->d_count != 1) {
-			enum maple_type mt = maple_arange_64;
-
-			if (!mt_is_alloc(mas->tree))
-				mt = maple_range_64;
-
-			cp->data = cp->d_count;
-			cp->s_count = 0;
-			dst_setup(cp, mas, mt);
-			init_cp_src(cp);
-			node_copy(mas, cp->src[0].node, 0, cp->data, cp->max, maple_copy,
-				  cp->dst[0].node, 0, mt);
-			node_finalise(cp->dst[0].node, mt, cp->end + 1);
-			/*
-			 * Warning, see cp_leaf_init() comment and rcu_assign_pointer()
-			 * documentation.  Since this is a new root, there are no
-			 * read-side operations that can view it until it is insert into
-			 * the tree after an rcu_assign_pointer() call.
-			 */
-			ma_init_slot(&cp->slot[0], cp->dst[0].node, mt);
-			cp->height++;
-		}
-		WARN_ON_ONCE(cp->dst[0].node != mte_to_node(
-				mt_slot_locked(mas->tree, cp->slot, 0)));
-		cp->dst[0].node->parent = ma_parent_ptr(mas_tree_parent(mas));
-		mas->min = 0;
-		mas->max = ULONG_MAX;
-		mas->depth = 0;
-		mas->node = mas_root_locked(mas);
+	if (cp_is_new_root(cp, mas))
 		return false;
-	}
 
 	/* Converged and has a single destination */
 	if ((cp->d_count == 1) &&
-- 
2.47.3

Andrew,

Please apply this fix to remove warnings on older compilers.  I've compiled the
lot against gcc 8.1 and 9.3 with only this fix needed.

Thanks again, SJ, for looking at these patches!

Regards,
Liam

-------------------------------------------------------------------------------
diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index 42038e42a4c7e..22cbaba72931f 100644
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -3361,7 +3361,7 @@ static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
                 * read-side operations that can view it until it is insert into
                 * the tree after an rcu_assign_pointer() call.
                 */
-               RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
+               ma_init_slot(cp->slot[0], cp->dst[0].node, mt);
                cp->height++;
        }
        WARN_ON_ONCE(cp->dst[0].node != mte_to_node(

-------------------------------------------------------------------------------

* Liam R. Howlett <Liam.Howlett@oracle.com> [260130 16:00]:
> Add a helper to do what is needed when the maple copy node contains a
> new root node.  This is useful for future commits and is
> self-documenting code.
> 
> Signed-off-by: Liam R. Howlett <Liam.Howlett@oracle.com>
> ---
>  lib/maple_tree.c | 70 ++++++++++++++++++++++++++----------------------
>  1 file changed, 38 insertions(+), 32 deletions(-)
> 
> diff --git a/lib/maple_tree.c b/lib/maple_tree.c
> index 5280fa6d2d6ec..42038e42a4c7e 100644
> --- a/lib/maple_tree.c
> +++ b/lib/maple_tree.c
> @@ -3337,6 +3337,43 @@ static void mas_spanning_rebalance(struct ma_state *mas,
>  	mas_spanning_rebalance_loop(mas, mast, count);
>  }
>  
> +static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
> +{
> +	if (cp->min || cp->max != ULONG_MAX)
> +		return false;
> +
> +	if (cp->d_count != 1) {
> +		enum maple_type mt = maple_arange_64;
> +
> +		if (!mt_is_alloc(mas->tree))
> +			mt = maple_range_64;
> +
> +		cp->data = cp->d_count;
> +		cp->s_count = 0;
> +		dst_setup(cp, mas, mt);
> +		init_cp_src(cp);
> +		node_copy(mas, cp->src[0].node, 0, cp->data, cp->max, maple_copy,
> +			  cp->dst[0].node, 0, mt);
> +		node_finalise(cp->dst[0].node, mt, cp->end + 1);
> +		/*
> +		 * Warning, see cp_leaf_init() comment and rcu_assign_pointer()
> +		 * documentation.  Since this is a new root, there are no
> +		 * read-side operations that can view it until it is insert into
> +		 * the tree after an rcu_assign_pointer() call.
> +		 */
> +		RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
> +		cp->height++;
> +	}
> +	WARN_ON_ONCE(cp->dst[0].node != mte_to_node(
> +				mt_slot_locked(mas->tree, cp->slot, 0)));
> +	cp->dst[0].node->parent = ma_parent_ptr(mas_tree_parent(mas));
> +	mas->min = 0;
> +	mas->max = ULONG_MAX;
> +	mas->depth = 0;
> +	mas->node = mas_root_locked(mas);
> +	return true;
> +}
> +
>  /*
>   * spanning_ascend() - See if a spanning store operation has to keep walking up
>   * the tree
> @@ -3359,39 +3396,8 @@ static bool spanning_ascend(struct maple_copy *cp, struct ma_state *mas,
>  	}
>  
>  	cp_dst_to_slots(cp, l_wr_mas->mas->min, r_wr_mas->mas->max, mas);
> -	if (!cp->min && cp->max == ULONG_MAX) {
> -		/* New root */
> -		if (cp->d_count != 1) {
> -			enum maple_type mt = maple_arange_64;
> -
> -			if (!mt_is_alloc(mas->tree))
> -				mt = maple_range_64;
> -
> -			cp->data = cp->d_count;
> -			cp->s_count = 0;
> -			dst_setup(cp, mas, mt);
> -			init_cp_src(cp);
> -			node_copy(mas, cp->src[0].node, 0, cp->data, cp->max, maple_copy,
> -				  cp->dst[0].node, 0, mt);
> -			node_finalise(cp->dst[0].node, mt, cp->end + 1);
> -			/*
> -			 * Warning, see cp_leaf_init() comment and rcu_assign_pointer()
> -			 * documentation.  Since this is a new root, there are no
> -			 * read-side operations that can view it until it is insert into
> -			 * the tree after an rcu_assign_pointer() call.
> -			 */
> -			ma_init_slot(&cp->slot[0], cp->dst[0].node, mt);
> -			cp->height++;
> -		}
> -		WARN_ON_ONCE(cp->dst[0].node != mte_to_node(
> -				mt_slot_locked(mas->tree, cp->slot, 0)));
> -		cp->dst[0].node->parent = ma_parent_ptr(mas_tree_parent(mas));
> -		mas->min = 0;
> -		mas->max = ULONG_MAX;
> -		mas->depth = 0;
> -		mas->node = mas_root_locked(mas);
> +	if (cp_is_new_root(cp, mas))
>  		return false;
> -	}
>  
>  	/* Converged and has a single destination */
>  	if ((cp->d_count == 1) &&
> -- 
> 2.47.3
>

On Tue, 3 Feb 2026 12:26:44 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:

> 
> Andrew,
> 
> Please apply this fix to remove warnings on older compilers.  I've compiled the
> lot against gcc 8.1 and 9.3 with only this fix needed.

I also confirmed the below patch passes my build tests.

> 
> Thanks again, SJ, for looking at these patches!

You're welcome, that's my pleasure :)

> 
> Regards,
> Liam
> 
> -------------------------------------------------------------------------------
> diff --git a/lib/maple_tree.c b/lib/maple_tree.c
> index 42038e42a4c7e..22cbaba72931f 100644
> --- a/lib/maple_tree.c
> +++ b/lib/maple_tree.c
> @@ -3361,7 +3361,7 @@ static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
>                  * read-side operations that can view it until it is insert into
>                  * the tree after an rcu_assign_pointer() call.
>                  */
> -               RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
> +               ma_init_slot(cp->slot[0], cp->dst[0].node, mt);
>                 cp->height++;
>         }
>         WARN_ON_ONCE(cp->dst[0].node != mte_to_node(

But, I found mm-new of today triggers below warning during booting on my test
machine.  And git-bisect points this fixup patch.  I further found reverting
this patch makes the booting success without the below warning.  I have no idea
about the root cause, so reporting first.

[    0.447863] ------------[ cut here ]------------
[    0.449019] WARNING: lib/maple_tree.c:2617 at mas_wr_split+0x116d/0x1270, CPU#0: swapper/0/0
[    0.451068] Modules linked in:
[    0.451745] CPU: 0 UID: 0 PID: 0 Comm: swapper/0 Not tainted 6.19.0-rc6+ #263 PREEMPT(voluntary)
[    0.453653] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014
[    0.455282] RIP: 0010:mas_wr_split (lib/maple_tree.c:2617 (discriminator 1) lib/maple_tree.c:2590 (discriminator 1) lib/maple_tree.c:3400 (discriminator 1) lib/maple_tree.c:3462 (discriminator 1))
[    0.456071] Code: ff ff ff 40 88 7b 4f 88 53 4d 4c 89 43 08 48 89 4b 10 48 89 6b 20 4c 89 63 28 e9 27 fe ff ff 4c 39 e2 0f 45 f8 e9 e7 f2 ff ff <0f> 0b e9 78 f8 ff ff 48 c7 44 24 10 00 00 00 00 b9 01 00 00 09
All code
========
   0:   ff                      (bad)
   1:   ff                      (bad)
   2:   ff 40 88                incl   -0x78(%rax)
   5:   7b 4f                   jnp    0x56
   7:   88 53 4d                mov    %dl,0x4d(%rbx)
   a:   4c 89 43 08             mov    %r8,0x8(%rbx)
   e:   48 89 4b 10             mov    %rcx,0x10(%rbx)
  12:   48 89 6b 20             mov    %rbp,0x20(%rbx)
  16:   4c 89 63 28             mov    %r12,0x28(%rbx)
  1a:   e9 27 fe ff ff          jmp    0xfffffffffffffe46
  1f:   4c 39 e2                cmp    %r12,%rdx
  22:   0f 45 f8                cmovne %eax,%edi
  25:   e9 e7 f2 ff ff          jmp    0xfffffffffffff311
  2a:*  0f 0b                   ud2             <-- trapping instruction
  2c:   e9 78 f8 ff ff          jmp    0xfffffffffffff8a9
  31:   48 c7 44 24 10 00 00    movq   $0x0,0x10(%rsp)
  38:   00 00
  3a:   b9 01 00 00 09          mov    $0x9000001,%ecx

Code starting with the faulting instruction
===========================================
   0:   0f 0b                   ud2
   2:   e9 78 f8 ff ff          jmp    0xfffffffffffff87f
   7:   48 c7 44 24 10 00 00    movq   $0x0,0x10(%rsp)
   e:   00 00
  10:   b9 01 00 00 09          mov    $0x9000001,%ecx
[    0.460144] RSP: 0000:ffffffff9b803ba0 EFLAGS: 00010087
[    0.461338] RAX: ffff8c6b8022f600 RBX: ffffffff9b803e78 RCX: 0000000000000000
[    0.462915] RDX: ffff8c6b8022ee00 RSI: 0000000000000001 RDI: ffff8c6b8022ee50
[    0.464498] RBP: 0000000000000003 R08: 0000000000000001 R09: 0000000000000003
[    0.466099] R10: 0000000000000002 R11: ffff8c6b8022ee00 R12: ffffffff9b803c90
[    0.467676] R13: ffffffff9b803e78 R14: 0000000000000001 R15: ffffffff9b803c78
[    0.469244] FS:  0000000000000000(0000) GS:ffff8c6ccfce7000(0000) knlGS:0000000000000000
[    0.470862] CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[    0.471827] CR2: ffff8c6c40801000 CR3: 00000001bf624000 CR4: 00000000000000b0
[    0.473238] Call Trace:
[    0.473861]  <TASK>
[    0.474326]  mas_store_gfp (lib/maple_tree.c:4890)
[    0.475159]  early_irq_init (kernel/irq/irqdesc.c:197 (discriminator 2) kernel/irq/irqdesc.c:572 (discriminator 2))
[    0.476105]  start_kernel (init/main.c:1112)
[    0.476922]  x86_64_start_reservations (arch/x86/kernel/head64.c:310)
[    0.477950]  x86_64_start_kernel (??:?)
[    0.478854]  common_startup_64 (arch/x86/kernel/head_64.S:419)
[    0.479761]  </TASK>
[    0.480243] ---[ end trace 0000000000000000 ]---


Thanks,
SJ

[...]

Hello,

On Fri, 30 Jan 2026 15:59:26 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:

> Add a helper to do what is needed when the maple copy node contains a
> new root node.  This is useful for future commits and is
> self-documenting code.
> 
> Signed-off-by: Liam R. Howlett <Liam.Howlett@oracle.com>
> ---
>  lib/maple_tree.c | 70 ++++++++++++++++++++++++++----------------------
>  1 file changed, 38 insertions(+), 32 deletions(-)
> 
> diff --git a/lib/maple_tree.c b/lib/maple_tree.c
> index 5280fa6d2d6ec..42038e42a4c7e 100644
> --- a/lib/maple_tree.c
> +++ b/lib/maple_tree.c
> @@ -3337,6 +3337,43 @@ static void mas_spanning_rebalance(struct ma_state *mas,
>  	mas_spanning_rebalance_loop(mas, mast, count);
>  }
>  
> +static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
> +{
> +	if (cp->min || cp->max != ULONG_MAX)
> +		return false;
> +
> +	if (cp->d_count != 1) {
> +		enum maple_type mt = maple_arange_64;
> +
> +		if (!mt_is_alloc(mas->tree))
> +			mt = maple_range_64;
> +
> +		cp->data = cp->d_count;
> +		cp->s_count = 0;
> +		dst_setup(cp, mas, mt);
> +		init_cp_src(cp);
> +		node_copy(mas, cp->src[0].node, 0, cp->data, cp->max, maple_copy,
> +			  cp->dst[0].node, 0, mt);
> +		node_finalise(cp->dst[0].node, mt, cp->end + 1);
> +		/*
> +		 * Warning, see cp_leaf_init() comment and rcu_assign_pointer()
> +		 * documentation.  Since this is a new root, there are no
> +		 * read-side operations that can view it until it is insert into
> +		 * the tree after an rcu_assign_pointer() call.
> +		 */
> +		RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));

I just found the above makes my build test using an old version compiler fails.
Fortunately, seems it is same to the one we discussed before [1], and same
mitigation like below attached patch works, at least for my test setup.

[1] https://lore.kernel.org/dwhxxuil4zkesmyj6xviyyyfedrcd65h6qd4bplmcrsg36purj@f523i7t6nxag


Thanks,
SJ

[...]
=== >8 ===
From ecc4e468d72c431d53043c8a61fddb6ddf2ecf7c Mon Sep 17 00:00:00 2001
From: SeongJae Park <sj@kernel.org>
Date: Sat, 31 Jan 2026 16:02:56 -0800
Subject: [PATCH] lib/mape_tree: temporal build fix

Without the fix, build with old compilers fails like below:

  CC      lib/maple_tree.o
In file included from .../arch/arm64/include/asm/rwonce.h:67,
                 from .../include/linux/compiler.h:380,
                 from .../include/linux/array_size.h:5,
                 from .../include/linux/kernel.h:16,
                 from .../include/linux/maple_tree.h:11,
                 from .../lib/maple_tree.c:56:
.../lib/maple_tree.c: In function 'cp_is_new_root':
.../include/linux/rcupdate.h:555:36: error: dereferencing pointer to incomplete type 'struct maple_enode'
  555 | #define RCU_INITIALIZER(v) (typeof(*(v)) __force __rcu *)(v)
      |                                    ^~~~
.../include/asm-generic/rwonce.h:55:33: note: in definition of macro '__WRITE_ONCE'
   55 |  *(volatile typeof(x) *)&(x) = (val);    \
      |                                 ^~~
.../include/linux/rcupdate.h:1046:3: note: in expansion of macro 'WRITE_ONCE'
 1046 |   WRITE_ONCE(p, RCU_INITIALIZER(v)); \
      |   ^~~~~~~~~~
.../include/linux/rcupdate.h:1046:17: note: in expansion of macro 'RCU_INITIALIZER'
 1046 |   WRITE_ONCE(p, RCU_INITIALIZER(v)); \
      |                 ^~~~~~~~~~~~~~~
.../lib/maple_tree.c:3364:3: note: in expansion of macro 'RCU_INIT_POINTER'
 3364 |   RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
      |   ^~~~~~~~~~~~~~~~

Signed-off-by: SeongJae Park <sj@kernel.org>
---
 lib/maple_tree.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index c522419e99f4e..eb2855269332a 100644
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -3361,7 +3361,8 @@ static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
 		 * read-side operations that can view it until it is insert into
 		 * the tree after an rcu_assign_pointer() call.
 		 */
-		RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
+		RCU_INIT_POINTER(cp->slot[0],
+				(void *)mt_mk_node(cp->dst[0].node, mt));
 		cp->height++;
 	}
 	WARN_ON_ONCE(cp->dst[0].node != mte_to_node(
-- 
2.47.3

* SeongJae Park <sj@kernel.org> [260131 19:10]:
> Hello,
> 
> On Fri, 30 Jan 2026 15:59:26 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:
> 
> > Add a helper to do what is needed when the maple copy node contains a
> > new root node.  This is useful for future commits and is
> > self-documenting code.
> > 
> > Signed-off-by: Liam R. Howlett <Liam.Howlett@oracle.com>
> > ---
> >  lib/maple_tree.c | 70 ++++++++++++++++++++++++++----------------------
> >  1 file changed, 38 insertions(+), 32 deletions(-)
> > 
> > diff --git a/lib/maple_tree.c b/lib/maple_tree.c
> > index 5280fa6d2d6ec..42038e42a4c7e 100644
> > --- a/lib/maple_tree.c
> > +++ b/lib/maple_tree.c
> > @@ -3337,6 +3337,43 @@ static void mas_spanning_rebalance(struct ma_state *mas,
> >  	mas_spanning_rebalance_loop(mas, mast, count);
> >  }
> >  
> > +static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
> > +{
> > +	if (cp->min || cp->max != ULONG_MAX)
> > +		return false;
> > +
> > +	if (cp->d_count != 1) {
> > +		enum maple_type mt = maple_arange_64;
> > +
> > +		if (!mt_is_alloc(mas->tree))
> > +			mt = maple_range_64;
> > +
> > +		cp->data = cp->d_count;
> > +		cp->s_count = 0;
> > +		dst_setup(cp, mas, mt);
> > +		init_cp_src(cp);
> > +		node_copy(mas, cp->src[0].node, 0, cp->data, cp->max, maple_copy,
> > +			  cp->dst[0].node, 0, mt);
> > +		node_finalise(cp->dst[0].node, mt, cp->end + 1);
> > +		/*
> > +		 * Warning, see cp_leaf_init() comment and rcu_assign_pointer()
> > +		 * documentation.  Since this is a new root, there are no
> > +		 * read-side operations that can view it until it is insert into
> > +		 * the tree after an rcu_assign_pointer() call.
> > +		 */
> > +		RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
> 
> I just found the above makes my build test using an old version compiler fails.
> Fortunately, seems it is same to the one we discussed before [1], and same
> mitigation like below attached patch works, at least for my test setup.

Thanks SJ.

This is still with gcc 8.1.0?

I thought debian stable would be old enough.

Thanks,
Liam

> 
> [1] https://lore.kernel.org/dwhxxuil4zkesmyj6xviyyyfedrcd65h6qd4bplmcrsg36purj@f523i7t6nxag
> 
> 
> Thanks,
> SJ
> 
> [...]
> === >8 ===
> From ecc4e468d72c431d53043c8a61fddb6ddf2ecf7c Mon Sep 17 00:00:00 2001
> From: SeongJae Park <sj@kernel.org>
> Date: Sat, 31 Jan 2026 16:02:56 -0800
> Subject: [PATCH] lib/mape_tree: temporal build fix
> 
> Without the fix, build with old compilers fails like below:
> 
>   CC      lib/maple_tree.o
> In file included from .../arch/arm64/include/asm/rwonce.h:67,
>                  from .../include/linux/compiler.h:380,
>                  from .../include/linux/array_size.h:5,
>                  from .../include/linux/kernel.h:16,
>                  from .../include/linux/maple_tree.h:11,
>                  from .../lib/maple_tree.c:56:
> .../lib/maple_tree.c: In function 'cp_is_new_root':
> .../include/linux/rcupdate.h:555:36: error: dereferencing pointer to incomplete type 'struct maple_enode'
>   555 | #define RCU_INITIALIZER(v) (typeof(*(v)) __force __rcu *)(v)
>       |                                    ^~~~
> .../include/asm-generic/rwonce.h:55:33: note: in definition of macro '__WRITE_ONCE'
>    55 |  *(volatile typeof(x) *)&(x) = (val);    \
>       |                                 ^~~
> .../include/linux/rcupdate.h:1046:3: note: in expansion of macro 'WRITE_ONCE'
>  1046 |   WRITE_ONCE(p, RCU_INITIALIZER(v)); \
>       |   ^~~~~~~~~~
> .../include/linux/rcupdate.h:1046:17: note: in expansion of macro 'RCU_INITIALIZER'
>  1046 |   WRITE_ONCE(p, RCU_INITIALIZER(v)); \
>       |                 ^~~~~~~~~~~~~~~
> .../lib/maple_tree.c:3364:3: note: in expansion of macro 'RCU_INIT_POINTER'
>  3364 |   RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
>       |   ^~~~~~~~~~~~~~~~
> 
> Signed-off-by: SeongJae Park <sj@kernel.org>
> ---
>  lib/maple_tree.c | 3 ++-
>  1 file changed, 2 insertions(+), 1 deletion(-)
> 
> diff --git a/lib/maple_tree.c b/lib/maple_tree.c
> index c522419e99f4e..eb2855269332a 100644
> --- a/lib/maple_tree.c
> +++ b/lib/maple_tree.c
> @@ -3361,7 +3361,8 @@ static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
>  		 * read-side operations that can view it until it is insert into
>  		 * the tree after an rcu_assign_pointer() call.
>  		 */
> -		RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
> +		RCU_INIT_POINTER(cp->slot[0],
> +				(void *)mt_mk_node(cp->dst[0].node, mt));
>  		cp->height++;
>  	}
>  	WARN_ON_ONCE(cp->dst[0].node != mte_to_node(
> -- 
> 2.47.3
>

On Mon, 2 Feb 2026 09:58:31 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:

> * SeongJae Park <sj@kernel.org> [260131 19:10]:
> > Hello,
> > 
> > On Fri, 30 Jan 2026 15:59:26 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:
> > 
> > > Add a helper to do what is needed when the maple copy node contains a
> > > new root node.  This is useful for future commits and is
> > > self-documenting code.
> > > 
> > > Signed-off-by: Liam R. Howlett <Liam.Howlett@oracle.com>
> > > ---
> > >  lib/maple_tree.c | 70 ++++++++++++++++++++++++++----------------------
> > >  1 file changed, 38 insertions(+), 32 deletions(-)
> > > 
> > > diff --git a/lib/maple_tree.c b/lib/maple_tree.c
> > > index 5280fa6d2d6ec..42038e42a4c7e 100644
> > > --- a/lib/maple_tree.c
> > > +++ b/lib/maple_tree.c
> > > @@ -3337,6 +3337,43 @@ static void mas_spanning_rebalance(struct ma_state *mas,
> > >  	mas_spanning_rebalance_loop(mas, mast, count);
> > >  }
> > >  
> > > +static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
> > > +{
> > > +	if (cp->min || cp->max != ULONG_MAX)
> > > +		return false;
> > > +
> > > +	if (cp->d_count != 1) {
> > > +		enum maple_type mt = maple_arange_64;
> > > +
> > > +		if (!mt_is_alloc(mas->tree))
> > > +			mt = maple_range_64;
> > > +
> > > +		cp->data = cp->d_count;
> > > +		cp->s_count = 0;
> > > +		dst_setup(cp, mas, mt);
> > > +		init_cp_src(cp);
> > > +		node_copy(mas, cp->src[0].node, 0, cp->data, cp->max, maple_copy,
> > > +			  cp->dst[0].node, 0, mt);
> > > +		node_finalise(cp->dst[0].node, mt, cp->end + 1);
> > > +		/*
> > > +		 * Warning, see cp_leaf_init() comment and rcu_assign_pointer()
> > > +		 * documentation.  Since this is a new root, there are no
> > > +		 * read-side operations that can view it until it is insert into
> > > +		 * the tree after an rcu_assign_pointer() call.
> > > +		 */
> > > +		RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
> > 
> > I just found the above makes my build test using an old version compiler fails.
> > Fortunately, seems it is same to the one we discussed before [1], and same
> > mitigation like below attached patch works, at least for my test setup.
> 
> Thanks SJ.

My pleasure :)

> 
> This is still with gcc 8.1.0?

Yes.  The test code is available at GitHub [1].

Nonetheless, another test [2] that is using 9.3.0 was also failing.


[1] https://github.com/damonitor/damon-tests/blob/master/corr/tests/build_m68k.sh
[2] https://github.com/damonitor/damon-tests/blob/master/corr/tests/build_arm64.sh


Thanks,
SJ

[...]

* SeongJae Park <sj@kernel.org> [260202 10:56]:
> On Mon, 2 Feb 2026 09:58:31 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:
> 
> > * SeongJae Park <sj@kernel.org> [260131 19:10]:
> > > Hello,
> > > 
> > > On Fri, 30 Jan 2026 15:59:26 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:
> > > 
> > > > Add a helper to do what is needed when the maple copy node contains a
> > > > new root node.  This is useful for future commits and is
> > > > self-documenting code.
> > > > 
> > > > Signed-off-by: Liam R. Howlett <Liam.Howlett@oracle.com>
> > > > ---
> > > >  lib/maple_tree.c | 70 ++++++++++++++++++++++++++----------------------
> > > >  1 file changed, 38 insertions(+), 32 deletions(-)
> > > > 
> > > > diff --git a/lib/maple_tree.c b/lib/maple_tree.c
> > > > index 5280fa6d2d6ec..42038e42a4c7e 100644
> > > > --- a/lib/maple_tree.c
> > > > +++ b/lib/maple_tree.c
> > > > @@ -3337,6 +3337,43 @@ static void mas_spanning_rebalance(struct ma_state *mas,
> > > >  	mas_spanning_rebalance_loop(mas, mast, count);
> > > >  }
> > > >  
> > > > +static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
> > > > +{
> > > > +	if (cp->min || cp->max != ULONG_MAX)
> > > > +		return false;
> > > > +
> > > > +	if (cp->d_count != 1) {
> > > > +		enum maple_type mt = maple_arange_64;
> > > > +
> > > > +		if (!mt_is_alloc(mas->tree))
> > > > +			mt = maple_range_64;
> > > > +
> > > > +		cp->data = cp->d_count;
> > > > +		cp->s_count = 0;
> > > > +		dst_setup(cp, mas, mt);
> > > > +		init_cp_src(cp);
> > > > +		node_copy(mas, cp->src[0].node, 0, cp->data, cp->max, maple_copy,
> > > > +			  cp->dst[0].node, 0, mt);
> > > > +		node_finalise(cp->dst[0].node, mt, cp->end + 1);
> > > > +		/*
> > > > +		 * Warning, see cp_leaf_init() comment and rcu_assign_pointer()
> > > > +		 * documentation.  Since this is a new root, there are no
> > > > +		 * read-side operations that can view it until it is insert into
> > > > +		 * the tree after an rcu_assign_pointer() call.
> > > > +		 */
> > > > +		RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
> > > 
> > > I just found the above makes my build test using an old version compiler fails.
> > > Fortunately, seems it is same to the one we discussed before [1], and same
> > > mitigation like below attached patch works, at least for my test setup.
> > 
> > Thanks SJ.
> 
> My pleasure :)
> 
> > 
> > This is still with gcc 8.1.0?
> 
> Yes.  The test code is available at GitHub [1].
> 
> Nonetheless, another test [2] that is using 9.3.0 was also failing.

You have two failures: one in 8.1 and one in 9.3?

I was planning to test 7.5.0 and ensure everything works, but this
implies my plan will not catch everything?

> 
> 
> [1] https://github.com/damonitor/damon-tests/blob/master/corr/tests/build_m68k.sh
> [2] https://github.com/damonitor/damon-tests/blob/master/corr/tests/build_arm64.sh
> 
> 
> Thanks,
> SJ
> 
> [...]

On Mon, 2 Feb 2026 12:01:53 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:

> * SeongJae Park <sj@kernel.org> [260202 10:56]:
> > On Mon, 2 Feb 2026 09:58:31 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:
> > 
> > > * SeongJae Park <sj@kernel.org> [260131 19:10]:
> > > > Hello,
> > > > 
> > > > On Fri, 30 Jan 2026 15:59:26 -0500 "Liam R. Howlett" <Liam.Howlett@oracle.com> wrote:
> > > > 
> > > > > Add a helper to do what is needed when the maple copy node contains a
> > > > > new root node.  This is useful for future commits and is
> > > > > self-documenting code.
> > > > > 
> > > > > Signed-off-by: Liam R. Howlett <Liam.Howlett@oracle.com>
> > > > > ---
> > > > >  lib/maple_tree.c | 70 ++++++++++++++++++++++++++----------------------
> > > > >  1 file changed, 38 insertions(+), 32 deletions(-)
> > > > > 
> > > > > diff --git a/lib/maple_tree.c b/lib/maple_tree.c
> > > > > index 5280fa6d2d6ec..42038e42a4c7e 100644
> > > > > --- a/lib/maple_tree.c
> > > > > +++ b/lib/maple_tree.c
> > > > > @@ -3337,6 +3337,43 @@ static void mas_spanning_rebalance(struct ma_state *mas,
> > > > >  	mas_spanning_rebalance_loop(mas, mast, count);
> > > > >  }
> > > > >  
> > > > > +static inline bool cp_is_new_root(struct maple_copy *cp, struct ma_state *mas)
> > > > > +{
> > > > > +	if (cp->min || cp->max != ULONG_MAX)
> > > > > +		return false;
> > > > > +
> > > > > +	if (cp->d_count != 1) {
> > > > > +		enum maple_type mt = maple_arange_64;
> > > > > +
> > > > > +		if (!mt_is_alloc(mas->tree))
> > > > > +			mt = maple_range_64;
> > > > > +
> > > > > +		cp->data = cp->d_count;
> > > > > +		cp->s_count = 0;
> > > > > +		dst_setup(cp, mas, mt);
> > > > > +		init_cp_src(cp);
> > > > > +		node_copy(mas, cp->src[0].node, 0, cp->data, cp->max, maple_copy,
> > > > > +			  cp->dst[0].node, 0, mt);
> > > > > +		node_finalise(cp->dst[0].node, mt, cp->end + 1);
> > > > > +		/*
> > > > > +		 * Warning, see cp_leaf_init() comment and rcu_assign_pointer()
> > > > > +		 * documentation.  Since this is a new root, there are no
> > > > > +		 * read-side operations that can view it until it is insert into
> > > > > +		 * the tree after an rcu_assign_pointer() call.
> > > > > +		 */
> > > > > +		RCU_INIT_POINTER(cp->slot[0], mt_mk_node(cp->dst[0].node, mt));
> > > > 
> > > > I just found the above makes my build test using an old version compiler fails.
> > > > Fortunately, seems it is same to the one we discussed before [1], and same
> > > > mitigation like below attached patch works, at least for my test setup.
> > > 
> > > Thanks SJ.
> > 
> > My pleasure :)
> > 
> > > 
> > > This is still with gcc 8.1.0?
> > 
> > Yes.  The test code is available at GitHub [1].
> > 
> > Nonetheless, another test [2] that is using 9.3.0 was also failing.
> 
> You have two failures: one in 8.1 and one in 9.3?

Yes.  FYI, I picked the compiler versions for no good reason but just because
there were reports of DAMON build failures on the compilers in the past.

> 
> I was planning to test 7.5.0 and ensure everything works, but this
> implies my plan will not catch everything?

From Documentation/process/changes.rst, I find minimal version of GCC for
building kernel is 8.1.  So gcc 7.5.0 might not need to be ensured for?

I have no good expertise on planning tests, though.


Thanks,
SJ

[...]