Skip to contentSkip to conversation

rcutorture: remove unneeded check

PATCH In review [email protected] 2 participants 9 messages Oct 9, 2020 – Oct 10, 2020

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 rcutorture: remove unneeded check

From: Tom Rix <[email protected]>

clang static analysis reports this problem:

rcutorture.c:1999:2: warning: Called function pointer
is null (null dereference)

        cur_ops->sync(); /* Later readers see above write. */
        ^~~~~~~~~~~~~~~

This is a false positive triggered by an earlier, later ignored NULL check of sync() op. By inspection of the rcu_torture_ops, the sync() op is never uninitialized. So this earlier check is not needed.

---
 kernel/rcu/rcutorture.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/rcu/rcutorture.c +1 -1
index beba9e7963c8..6efc03a1d623 100644
@@ -1989,7 +1989,7 @@ static void rcu_torture_fwd_prog_nr(struct rcu_fwd *rfp,
 	unsigned long stopat;
 	static DEFINE_TORTURE_RANDOM(trs);
 
-	if  (cur_ops->call && cur_ops->sync && cur_ops->cb_barrier) {
+	if  (cur_ops->call && cur_ops->cb_barrier) {
 		init_rcu_head_on_stack(&fcs.rh);
 		selfpropcb = true;
 	}
Signature · 1 line
2.18.1
maintainer
#1 lore raw
Quoted 6 lines · On Fri, Oct 09, 2020 at 12:47:36PM -0700, [email protected] wrote:

From: Tom Rix <[email protected]>

clang static analysis reports this problem:

rcutorture.c:1999:2: warning: Called function pointer
is null (null dereference)

Quoted 7 lines
        cur_ops->sync(); /* Later readers see above write. */
        ^~~~~~~~~~~~~~~

This is a false positive triggered by an earlier, later ignored NULL check of sync() op. By inspection of the rcu_torture_ops, the sync() op is never uninitialized. So this earlier check is not needed.

You lost me on this one. This check is at the very beginning of rcu_torture_fwd_prog_nr(). Or are you saying that clang is seeing an earlier check in one of rcu_torture_fwd_prog_nr()'s callers? If so, where exactly is this check?

In any case, the check is needed because all three functions are invoked if there is a self-propagating RCU callback that ensures that there is always an RCU grace period outstanding.

Ah. Is clang doing local analysis and assuming that because there was a NULL check earlier, then the pointer might be NULL later? That does not seem to me to be a sound check.

So please let me know exactly what is causing clang to emit this diagnostic. It might or might not be worth fixing this, but either way I need to understand the situation so as to be able to understand the set of feasible fixes.

Thanx, Paul

Quoted 21 lines
---
 kernel/rcu/rcutorture.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/rcu/rcutorture.c +1 -1
index beba9e7963c8..6efc03a1d623 100644
@@ -1989,7 +1989,7 @@ static void rcu_torture_fwd_prog_nr(struct rcu_fwd *rfp,
 	unsigned long stopat;
 	static DEFINE_TORTURE_RANDOM(trs);
 
-	if  (cur_ops->call && cur_ops->sync && cur_ops->cb_barrier) {
+	if  (cur_ops->call && cur_ops->cb_barrier) {
 		init_rcu_head_on_stack(&fcs.rh);
 		selfpropcb = true;
 	}
Signature · 1 line
2.18.1
author
#2 lore raw
Quoted 27 lines · Paul E. McKenney
Quoted 6 lines · On Fri, Oct 09, 2020 at 12:47:36PM -0700, [email protected] wrote:

From: Tom Rix <[email protected]>

clang static analysis reports this problem:

rcutorture.c:1999:2: warning: Called function pointer
is null (null dereference)

Quoted 7 lines
        cur_ops->sync(); /* Later readers see above write. */
        ^~~~~~~~~~~~~~~

This is a false positive triggered by an earlier, later ignored NULL check of sync() op. By inspection of the rcu_torture_ops, the sync() op is never uninitialized. So this earlier check is not needed.

You lost me on this one. This check is at the very beginning of rcu_torture_fwd_prog_nr(). Or are you saying that clang is seeing an earlier check in one of rcu_torture_fwd_prog_nr()'s callers? If so, where exactly is this check?

In any case, the check is needed because all three functions are invoked if there is a self-propagating RCU callback that ensures that there is always an RCU grace period outstanding.

Ah. Is clang doing local analysis and assuming that because there was a NULL check earlier, then the pointer might be NULL later? That does not seem to me to be a sound check.

Quoted 6 lines

So please let me know exactly what is causing clang to emit this diagnostic. It might or might not be worth fixing this, but either way I need to understand the situation so as to be able to understand the set of feasible fixes.

Thanx, Paul

In rcu_prog_nr() there is check for for sync.

if ( ... cur_op->sync ...

   do something

This flags in clang's static analyzer as 'could be null'

later in the function, in a reachable block it is used

cur_ops->sync()

I agree this is not a good check that's why i said is was a false positive.

However when looking closer at how cur_ops is set, it is never uninitialized.

So the check is not needed.

This is not a fix, the code works fine.  It is a small optimization.

Tom

Quoted 22 lines
Quoted 22 lines
---
 kernel/rcu/rcutorture.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/rcu/rcutorture.c +1 -1
index beba9e7963c8..6efc03a1d623 100644
@@ -1989,7 +1989,7 @@ static void rcu_torture_fwd_prog_nr(struct rcu_fwd *rfp,
 	unsigned long stopat;
 	static DEFINE_TORTURE_RANDOM(trs);
 
-	if  (cur_ops->call && cur_ops->sync && cur_ops->cb_barrier) {
+	if  (cur_ops->call && cur_ops->cb_barrier) {
 		init_rcu_head_on_stack(&fcs.rh);
 		selfpropcb = true;
 	}
Signature · 1 line
2.18.1
maintainer
#3 lore raw
Quoted 46 lines · Tom Rix
Quoted 27 lines · Paul E. McKenney
Quoted 6 lines · On Fri, Oct 09, 2020 at 12:47:36PM -0700, [email protected] wrote:

From: Tom Rix <[email protected]>

clang static analysis reports this problem:

rcutorture.c:1999:2: warning: Called function pointer
is null (null dereference)

Quoted 7 lines
        cur_ops->sync(); /* Later readers see above write. */
        ^~~~~~~~~~~~~~~

This is a false positive triggered by an earlier, later ignored NULL check of sync() op. By inspection of the rcu_torture_ops, the sync() op is never uninitialized. So this earlier check is not needed.

You lost me on this one. This check is at the very beginning of rcu_torture_fwd_prog_nr(). Or are you saying that clang is seeing an earlier check in one of rcu_torture_fwd_prog_nr()'s callers? If so, where exactly is this check?

In any case, the check is needed because all three functions are invoked if there is a self-propagating RCU callback that ensures that there is always an RCU grace period outstanding.

Ah. Is clang doing local analysis and assuming that because there was a NULL check earlier, then the pointer might be NULL later? That does not seem to me to be a sound check.

Quoted 6 lines

So please let me know exactly what is causing clang to emit this diagnostic. It might or might not be worth fixing this, but either way I need to understand the situation so as to be able to understand the set of feasible fixes.

Thanx, Paul

In rcu_prog_nr() there is check for for sync.

if ( ... cur_op->sync ...

   do something

This flags in clang's static analyzer as 'could be null'

later in the function, in a reachable block it is used

Quoted 7 lines

cur_ops->sync()

I agree this is not a good check that's why i said is was a false positive.

However when looking closer at how cur_ops is set, it is never uninitialized.

So the check is not needed.

OK, got it, and thank you for the explanation.

Quoted 1 line

This is not a fix, the code works fine.  It is a small optimization.

Well, there really is a bug. Yes, right now all ->sync pointers are non-NULL, but they have not been in the past and might not be in the future. So if ->sync is NULL, rcu_torture_fwd_prog_nr() either should not be called or it should return immediately without doing anything.

My current thought is something like the (untested) patch below, of course with your Reported-by.

Thoughts?

Thanx, Paul

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

kernel/rcu/rcutorture.c +5 -3
index beba9e7..44749be 100644
@@ -1989,7 +1989,9 @@ static void rcu_torture_fwd_prog_nr(struct rcu_fwd *rfp,
 	unsigned long stopat;
 	static DEFINE_TORTURE_RANDOM(trs);
 
-	if  (cur_ops->call && cur_ops->sync && cur_ops->cb_barrier) {
+	if (!cur_ops->sync) 
+		return; // Cannot do need_resched() forward progress testing without ->sync.
+	if (cur_ops->call && cur_ops->cb_barrier) {
 		init_rcu_head_on_stack(&fcs.rh);
 		selfpropcb = true;
 	}
@@ -2215,8 +2217,8 @@ static int __init rcu_torture_fwd_prog_init(void)
 
 	if (!fwd_progress)
 		return 0; /* Not requested, so don't do it. */
-	if (!cur_ops->stall_dur || cur_ops->stall_dur() <= 0 ||
-	    cur_ops == &rcu_busted_ops) {
+	if ((!cur_ops->sync && !cur_ops->call) ||
+	    !cur_ops->stall_dur || cur_ops->stall_dur() <= 0 || cur_ops == &rcu_busted_ops) {
 		VERBOSE_TOROUT_STRING("rcu_torture_fwd_prog_init: Disabled, unsupported by RCU flavor under test");
 		return 0;
 	}
author
#4 lore raw
Quoted 60 lines · Paul E. McKenney
Quoted 44 lines · Tom Rix
Quoted 27 lines · Paul E. McKenney
Quoted 6 lines · On Fri, Oct 09, 2020 at 12:47:36PM -0700, [email protected] wrote:

From: Tom Rix <[email protected]>

clang static analysis reports this problem:

rcutorture.c:1999:2: warning: Called function pointer
is null (null dereference)

Quoted 7 lines
        cur_ops->sync(); /* Later readers see above write. */
        ^~~~~~~~~~~~~~~

This is a false positive triggered by an earlier, later ignored NULL check of sync() op. By inspection of the rcu_torture_ops, the sync() op is never uninitialized. So this earlier check is not needed.

You lost me on this one. This check is at the very beginning of rcu_torture_fwd_prog_nr(). Or are you saying that clang is seeing an earlier check in one of rcu_torture_fwd_prog_nr()'s callers? If so, where exactly is this check?

In any case, the check is needed because all three functions are invoked if there is a self-propagating RCU callback that ensures that there is always an RCU grace period outstanding.

Ah. Is clang doing local analysis and assuming that because there was a NULL check earlier, then the pointer might be NULL later? That does not seem to me to be a sound check.

Quoted 6 lines

So please let me know exactly what is causing clang to emit this diagnostic. It might or might not be worth fixing this, but either way I need to understand the situation so as to be able to understand the set of feasible fixes.

Thanx, Paul

In rcu_prog_nr() there is check for for sync.

if ( ... cur_op->sync ...

   do something

This flags in clang's static analyzer as 'could be null'

later in the function, in a reachable block it is used

Quoted 7 lines

cur_ops->sync()

I agree this is not a good check that's why i said is was a false positive.

However when looking closer at how cur_ops is set, it is never uninitialized.

So the check is not needed.

OK, got it, and thank you for the explanation.

Quoted 1 line

This is not a fix, the code works fine.  It is a small optimization.

Well, there really is a bug. Yes, right now all ->sync pointers are non-NULL, but they have not been in the past and might not be in the future. So if ->sync is NULL, rcu_torture_fwd_prog_nr() either should not be called or it should return immediately without doing anything.

Quoted 4 lines

My current thought is something like the (untested) patch below, of course with your Reported-by.

Thoughts?

Yes that would be fine.

In in review these other cases need to be been take care of.

Thanks,

Quoted 31 lines

Thanx, Paul

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

kernel/rcu/rcutorture.c +5 -3
index beba9e7..44749be 100644
@@ -1989,7 +1989,9 @@ static void rcu_torture_fwd_prog_nr(struct rcu_fwd *rfp,
 	unsigned long stopat;
 	static DEFINE_TORTURE_RANDOM(trs);
 
-	if  (cur_ops->call && cur_ops->sync && cur_ops->cb_barrier) {
+	if (!cur_ops->sync) 
+		return; // Cannot do need_resched() forward progress testing without ->sync.
+	if (cur_ops->call && cur_ops->cb_barrier) {
 		init_rcu_head_on_stack(&fcs.rh);
 		selfpropcb = true;
 	}
@@ -2215,8 +2217,8 @@ static int __init rcu_torture_fwd_prog_init(void)
 
 	if (!fwd_progress)
 		return 0; /* Not requested, so don't do it. */
-	if (!cur_ops->stall_dur || cur_ops->stall_dur() <= 0 ||
-	    cur_ops == &rcu_busted_ops) {
+	if ((!cur_ops->sync && !cur_ops->call) ||
+	    !cur_ops->stall_dur || cur_ops->stall_dur() <= 0 || cur_ops == &rcu_busted_ops) {
 		VERBOSE_TOROUT_STRING("rcu_torture_fwd_prog_init: Disabled, unsupported by RCU flavor under test");
 		return 0;
 	}
maintainer
#5 lore raw
Quoted 62 lines · Tom Rix
Quoted 60 lines · Paul E. McKenney
Quoted 44 lines · Tom Rix
Quoted 27 lines · Paul E. McKenney
Quoted 6 lines · On Fri, Oct 09, 2020 at 12:47:36PM -0700, [email protected] wrote:

From: Tom Rix <[email protected]>

clang static analysis reports this problem:

rcutorture.c:1999:2: warning: Called function pointer
is null (null dereference)

Quoted 7 lines
        cur_ops->sync(); /* Later readers see above write. */
        ^~~~~~~~~~~~~~~

This is a false positive triggered by an earlier, later ignored NULL check of sync() op. By inspection of the rcu_torture_ops, the sync() op is never uninitialized. So this earlier check is not needed.

You lost me on this one. This check is at the very beginning of rcu_torture_fwd_prog_nr(). Or are you saying that clang is seeing an earlier check in one of rcu_torture_fwd_prog_nr()'s callers? If so, where exactly is this check?

In any case, the check is needed because all three functions are invoked if there is a self-propagating RCU callback that ensures that there is always an RCU grace period outstanding.

Ah. Is clang doing local analysis and assuming that because there was a NULL check earlier, then the pointer might be NULL later? That does not seem to me to be a sound check.

Quoted 6 lines

So please let me know exactly what is causing clang to emit this diagnostic. It might or might not be worth fixing this, but either way I need to understand the situation so as to be able to understand the set of feasible fixes.

Thanx, Paul

In rcu_prog_nr() there is check for for sync.

if ( ... cur_op->sync ...

   do something

This flags in clang's static analyzer as 'could be null'

later in the function, in a reachable block it is used

Quoted 7 lines

cur_ops->sync()

I agree this is not a good check that's why i said is was a false positive.

However when looking closer at how cur_ops is set, it is never uninitialized.

So the check is not needed.

OK, got it, and thank you for the explanation.

Quoted 1 line

This is not a fix, the code works fine.  It is a small optimization.

Well, there really is a bug. Yes, right now all ->sync pointers are non-NULL, but they have not been in the past and might not be in the future. So if ->sync is NULL, rcu_torture_fwd_prog_nr() either should not be called or it should return immediately without doing anything.

Quoted 8 lines
Quoted 4 lines

My current thought is something like the (untested) patch below, of course with your Reported-by.

Thoughts?

Yes that would be fine.

In in review these other cases need to be been take care of.

I am having a difficult time interpreting this sentence, but will optimistically assume that it means that you are good with this approach. If my optimism is unwarranted, please let me know so I can fix whatever might be broken.

Quoted 1 line

How does the commit below look?

Thanx, Paul

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

commit 75c79a5dd72c1bb59f6bd6c5ec36f3a6516795cd

Author: Paul E. McKenney <[email protected]>
Date:   Fri Oct 9 19:51:55 2020 -0700

rcutorture: Don't do need_resched() testing if ->sync is NULL

If cur_ops->sync is NULL, rcu_torture_fwd_prog_nr() will nevertheless attempt to call through it. This commit therefore flags cases where neither need_resched() nor call_rcu() forward-progress testing can be performed due to NULL function pointers, and also causes rcu_torture_fwd_prog_nr() to take an early exit if cur_ops->sync() is NULL.

kernel/rcu/rcutorture.c +5 -3
index beba9e7..44749be 100644
@@ -1989,7 +1989,9 @@ static void rcu_torture_fwd_prog_nr(struct rcu_fwd *rfp,
 	unsigned long stopat;
 	static DEFINE_TORTURE_RANDOM(trs);
 
-	if  (cur_ops->call && cur_ops->sync && cur_ops->cb_barrier) {
+	if (!cur_ops->sync) 
+		return; // Cannot do need_resched() forward progress testing without ->sync.
+	if (cur_ops->call && cur_ops->cb_barrier) {
 		init_rcu_head_on_stack(&fcs.rh);
 		selfpropcb = true;
 	}
@@ -2215,8 +2217,8 @@ static int __init rcu_torture_fwd_prog_init(void)
 
 	if (!fwd_progress)
 		return 0; /* Not requested, so don't do it. */
-	if (!cur_ops->stall_dur || cur_ops->stall_dur() <= 0 ||
-	    cur_ops == &rcu_busted_ops) {
+	if ((!cur_ops->sync && !cur_ops->call) ||
+	    !cur_ops->stall_dur || cur_ops->stall_dur() <= 0 || cur_ops == &rcu_busted_ops) {
 		VERBOSE_TOROUT_STRING("rcu_torture_fwd_prog_init: Disabled, unsupported by RCU flavor under test");
 		return 0;
 	}
author
#6 lore raw
Quoted 68 lines · Paul E. McKenney
Quoted 67 lines · Tom Rix
Quoted 60 lines · Paul E. McKenney
Quoted 44 lines · Tom Rix
Quoted 27 lines · Paul E. McKenney
Quoted 6 lines · On Fri, Oct 09, 2020 at 12:47:36PM -0700, [email protected] wrote:

From: Tom Rix <[email protected]>

clang static analysis reports this problem:

rcutorture.c:1999:2: warning: Called function pointer
is null (null dereference)

Quoted 7 lines
        cur_ops->sync(); /* Later readers see above write. */
        ^~~~~~~~~~~~~~~

This is a false positive triggered by an earlier, later ignored NULL check of sync() op. By inspection of the rcu_torture_ops, the sync() op is never uninitialized. So this earlier check is not needed.

You lost me on this one. This check is at the very beginning of rcu_torture_fwd_prog_nr(). Or are you saying that clang is seeing an earlier check in one of rcu_torture_fwd_prog_nr()'s callers? If so, where exactly is this check?

In any case, the check is needed because all three functions are invoked if there is a self-propagating RCU callback that ensures that there is always an RCU grace period outstanding.

Ah. Is clang doing local analysis and assuming that because there was a NULL check earlier, then the pointer might be NULL later? That does not seem to me to be a sound check.

Quoted 6 lines

So please let me know exactly what is causing clang to emit this diagnostic. It might or might not be worth fixing this, but either way I need to understand the situation so as to be able to understand the set of feasible fixes.

Thanx, Paul

In rcu_prog_nr() there is check for for sync.

if ( ... cur_op->sync ...

   do something

This flags in clang's static analyzer as 'could be null'

later in the function, in a reachable block it is used

Quoted 7 lines

cur_ops->sync()

I agree this is not a good check that's why i said is was a false positive.

However when looking closer at how cur_ops is set, it is never uninitialized.

So the check is not needed.

OK, got it, and thank you for the explanation.

Quoted 1 line

This is not a fix, the code works fine.  It is a small optimization.

Well, there really is a bug. Yes, right now all ->sync pointers are non-NULL, but they have not been in the past and might not be in the future. So if ->sync is NULL, rcu_torture_fwd_prog_nr() either should not be called or it should return immediately without doing anything.

Quoted 4 lines

My current thought is something like the (untested) patch below, of course with your Reported-by.

Thoughts?

Yes that would be fine.

Quoted 8 lines
Quoted 1 line

In in review these other cases need to be been take care of.

I am having a difficult time interpreting this sentence, but will optimistically assume that it means that you are good with this approach. If my optimism is unwarranted, please let me know so I can fix whatever might be broken.

Quoted 1 line

How does the commit below look?

Looks fine.

Thanks

Tom

Quoted 48 lines

Thanx, Paul

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

commit 75c79a5dd72c1bb59f6bd6c5ec36f3a6516795cd

Author: Paul E. McKenney <[email protected]>
Date:   Fri Oct 9 19:51:55 2020 -0700

rcutorture: Don't do need_resched() testing if ->sync is NULL

If cur_ops->sync is NULL, rcu_torture_fwd_prog_nr() will nevertheless attempt to call through it. This commit therefore flags cases where neither need_resched() nor call_rcu() forward-progress testing can be performed due to NULL function pointers, and also causes rcu_torture_fwd_prog_nr() to take an early exit if cur_ops->sync() is NULL.

kernel/rcu/rcutorture.c +5 -3
index beba9e7..44749be 100644
@@ -1989,7 +1989,9 @@ static void rcu_torture_fwd_prog_nr(struct rcu_fwd *rfp,
 	unsigned long stopat;
 	static DEFINE_TORTURE_RANDOM(trs);
 
-	if  (cur_ops->call && cur_ops->sync && cur_ops->cb_barrier) {
+	if (!cur_ops->sync) 
+		return; // Cannot do need_resched() forward progress testing without ->sync.
+	if (cur_ops->call && cur_ops->cb_barrier) {
 		init_rcu_head_on_stack(&fcs.rh);
 		selfpropcb = true;
 	}
@@ -2215,8 +2217,8 @@ static int __init rcu_torture_fwd_prog_init(void)
 
 	if (!fwd_progress)
 		return 0; /* Not requested, so don't do it. */
-	if (!cur_ops->stall_dur || cur_ops->stall_dur() <= 0 ||
-	    cur_ops == &rcu_busted_ops) {
+	if ((!cur_ops->sync && !cur_ops->call) ||
+	    !cur_ops->stall_dur || cur_ops->stall_dur() <= 0 || cur_ops == &rcu_busted_ops) {
 		VERBOSE_TOROUT_STRING("rcu_torture_fwd_prog_init: Disabled, unsupported by RCU flavor under test");
 		return 0;
 	}
author
#8 lore raw
In reply to Paul E. McKenney
Quoted 28 lines · Paul E. McKenney
Quoted 27 lines · Paul E. McKenney
Quoted 26 lines · Tom Rix
Quoted 25 lines · Paul E. McKenney
Quoted 24 lines · Tom Rix
Quoted 23 lines · Paul E. McKenney
Quoted 6 lines · On Fri, Oct 09, 2020 at 12:47:36PM -0700, [email protected] wrote:

From: Tom Rix <[email protected]>

clang static analysis reports this problem:

rcutorture.c:1999:2: warning: Called function pointer
is null (null dereference)

Quoted 7 lines
        cur_ops->sync(); /* Later readers see above write. */
        ^~~~~~~~~~~~~~~

This is a false positive triggered by an earlier, later ignored NULL check of sync() op. By inspection of the rcu_torture_ops, the sync() op is never uninitialized. So this earlier check is not needed.

You lost me on this one. This check is at the very beginning of rcu_torture_fwd_prog_nr(). Or are you saying that clang is seeing an earlier check in one of rcu_torture_fwd_prog_nr()'s callers? If so, where exactly is this check?

In any case, the check is needed because all three functions are invoked if there is a self-propagating RCU callback that ensures that there is always an RCU grace period outstanding.

Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

Ah. Is clang doing local analysis and assuming that because there was a NULL check earlier, then the pointer might be NULL later? That does not seem to me to be a sound check.

In this case, the diagnostic was clearly pointing out a latent bug, so my bad. So more of a code-review comment than a diagnostic. Therefore, if clang really wants to be in the code-review space, I suggest that it more clearly explain its code-review feedback. ;-)

Ok.

I have another a change in other area queued up.

I'll improve it's and future comments.

Tom

Quoted 94 lines

Thanx, Paul

Quoted 92 lines
Quoted 31 lines
Quoted 31 lines
Quoted 16 lines
Quoted 6 lines

So please let me know exactly what is causing clang to emit this diagnostic. It might or might not be worth fixing this, but either way I need to understand the situation so as to be able to understand the set of feasible fixes.

Thanx, Paul

In rcu_prog_nr() there is check for for sync.

if ( ... cur_op->sync ...

   do something

This flags in clang's static analyzer as 'could be null'

later in the function, in a reachable block it is used

Quoted 7 lines

cur_ops->sync()

I agree this is not a good check that's why i said is was a false positive.

However when looking closer at how cur_ops is set, it is never uninitialized.

So the check is not needed.

OK, got it, and thank you for the explanation.

Quoted 1 line

This is not a fix, the code works fine.  It is a small optimization.

Well, there really is a bug. Yes, right now all ->sync pointers are non-NULL, but they have not been in the past and might not be in the future. So if ->sync is NULL, rcu_torture_fwd_prog_nr() either should not be called or it should return immediately without doing anything.

Quoted 7 lines
Quoted 4 lines

My current thought is something like the (untested) patch below, of course with your Reported-by.

Thoughts?

Yes that would be fine.

In in review these other cases need to be been take care of.

I am having a difficult time interpreting this sentence, but will optimistically assume that it means that you are good with this approach. If my optimism is unwarranted, please let me know so I can fix whatever might be broken.

Quoted 1 line

How does the commit below look?

Thanx, Paul

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

commit 75c79a5dd72c1bb59f6bd6c5ec36f3a6516795cd

Author: Paul E. McKenney <[email protected]>
Date:   Fri Oct 9 19:51:55 2020 -0700

rcutorture: Don't do need_resched() testing if ->sync is NULL

If cur_ops->sync is NULL, rcu_torture_fwd_prog_nr() will nevertheless attempt to call through it. This commit therefore flags cases where neither need_resched() nor call_rcu() forward-progress testing can be performed due to NULL function pointers, and also causes rcu_torture_fwd_prog_nr() to take an early exit if cur_ops->sync() is NULL.

kernel/rcu/rcutorture.c +5 -3
index beba9e7..44749be 100644
@@ -1989,7 +1989,9 @@ static void rcu_torture_fwd_prog_nr(struct rcu_fwd *rfp,
 	unsigned long stopat;
 	static DEFINE_TORTURE_RANDOM(trs);
 
-	if  (cur_ops->call && cur_ops->sync && cur_ops->cb_barrier) {
+	if (!cur_ops->sync) 
+		return; // Cannot do need_resched() forward progress testing without ->sync.
+	if (cur_ops->call && cur_ops->cb_barrier) {
 		init_rcu_head_on_stack(&fcs.rh);
 		selfpropcb = true;
 	}
@@ -2215,8 +2217,8 @@ static int __init rcu_torture_fwd_prog_init(void)
 
 	if (!fwd_progress)
 		return 0; /* Not requested, so don't do it. */
-	if (!cur_ops->stall_dur || cur_ops->stall_dur() <= 0 ||
-	    cur_ops == &rcu_busted_ops) {
+	if ((!cur_ops->sync && !cur_ops->call) ||
+	    !cur_ops->stall_dur || cur_ops->stall_dur() <= 0 || cur_ops == &rcu_busted_ops) {
 		VERBOSE_TOROUT_STRING("rcu_torture_fwd_prog_init: Disabled, unsupported by RCU flavor under test");
 		return 0;
 	}
maintainer
#7 lore raw
In reply to Paul E. McKenney
Quoted 24 lines · Paul E. McKenney
Quoted 23 lines · Tom Rix
Quoted 21 lines · Paul E. McKenney
Quoted 20 lines · Tom Rix
Quoted 19 lines · Paul E. McKenney
Quoted 6 lines · On Fri, Oct 09, 2020 at 12:47:36PM -0700, [email protected] wrote:

From: Tom Rix <[email protected]>

clang static analysis reports this problem:

rcutorture.c:1999:2: warning: Called function pointer
is null (null dereference)

Quoted 7 lines
        cur_ops->sync(); /* Later readers see above write. */
        ^~~~~~~~~~~~~~~

This is a false positive triggered by an earlier, later ignored NULL check of sync() op. By inspection of the rcu_torture_ops, the sync() op is never uninitialized. So this earlier check is not needed.

You lost me on this one. This check is at the very beginning of rcu_torture_fwd_prog_nr(). Or are you saying that clang is seeing an earlier check in one of rcu_torture_fwd_prog_nr()'s callers? If so, where exactly is this check?

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

In any case, the check is needed because all three functions are invoked if there is a self-propagating RCU callback that ensures that there is always an RCU grace period outstanding.

Ah. Is clang doing local analysis and assuming that because there was a NULL check earlier, then the pointer might be NULL later? That does not seem to me to be a sound check.

In this case, the diagnostic was clearly pointing out a latent bug, so my bad. So more of a code-review comment than a diagnostic. Therefore, if clang really wants to be in the code-review space, I suggest that it more clearly explain its code-review feedback. ;-)

Thanx, Paul

Quoted 95 lines
Quoted 31 lines
Quoted 31 lines
Quoted 16 lines
Quoted 6 lines

So please let me know exactly what is causing clang to emit this diagnostic. It might or might not be worth fixing this, but either way I need to understand the situation so as to be able to understand the set of feasible fixes.

Thanx, Paul

In rcu_prog_nr() there is check for for sync.

if ( ... cur_op->sync ...

   do something

This flags in clang's static analyzer as 'could be null'

later in the function, in a reachable block it is used

Quoted 7 lines

cur_ops->sync()

I agree this is not a good check that's why i said is was a false positive.

However when looking closer at how cur_ops is set, it is never uninitialized.

So the check is not needed.

OK, got it, and thank you for the explanation.

Quoted 1 line

This is not a fix, the code works fine.  It is a small optimization.

Well, there really is a bug. Yes, right now all ->sync pointers are non-NULL, but they have not been in the past and might not be in the future. So if ->sync is NULL, rcu_torture_fwd_prog_nr() either should not be called or it should return immediately without doing anything.

Quoted 8 lines
Quoted 4 lines

My current thought is something like the (untested) patch below, of course with your Reported-by.

Thoughts?

Yes that would be fine.

In in review these other cases need to be been take care of.

I am having a difficult time interpreting this sentence, but will optimistically assume that it means that you are good with this approach. If my optimism is unwarranted, please let me know so I can fix whatever might be broken.

Quoted 1 line

How does the commit below look?

Thanx, Paul

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

commit 75c79a5dd72c1bb59f6bd6c5ec36f3a6516795cd

Author: Paul E. McKenney <[email protected]>
Date:   Fri Oct 9 19:51:55 2020 -0700

rcutorture: Don't do need_resched() testing if ->sync is NULL

If cur_ops->sync is NULL, rcu_torture_fwd_prog_nr() will nevertheless attempt to call through it. This commit therefore flags cases where neither need_resched() nor call_rcu() forward-progress testing can be performed due to NULL function pointers, and also causes rcu_torture_fwd_prog_nr() to take an early exit if cur_ops->sync() is NULL.

kernel/rcu/rcutorture.c +5 -3
index beba9e7..44749be 100644
@@ -1989,7 +1989,9 @@ static void rcu_torture_fwd_prog_nr(struct rcu_fwd *rfp,
 	unsigned long stopat;
 	static DEFINE_TORTURE_RANDOM(trs);
 
-	if  (cur_ops->call && cur_ops->sync && cur_ops->cb_barrier) {
+	if (!cur_ops->sync) 
+		return; // Cannot do need_resched() forward progress testing without ->sync.
+	if (cur_ops->call && cur_ops->cb_barrier) {
 		init_rcu_head_on_stack(&fcs.rh);
 		selfpropcb = true;
 	}
@@ -2215,8 +2217,8 @@ static int __init rcu_torture_fwd_prog_init(void)
 
 	if (!fwd_progress)
 		return 0; /* Not requested, so don't do it. */
-	if (!cur_ops->stall_dur || cur_ops->stall_dur() <= 0 ||
-	    cur_ops == &rcu_busted_ops) {
+	if ((!cur_ops->sync && !cur_ops->call) ||
+	    !cur_ops->stall_dur || cur_ops->stall_dur() <= 0 || cur_ops == &rcu_busted_ops) {
 		VERBOSE_TOROUT_STRING("rcu_torture_fwd_prog_init: Disabled, unsupported by RCU flavor under test");
 		return 0;
 	}