Skip to contentSkip to conversation

waitqueue: fix clang -Wuninitialized warnings

PATCH In review Arnd Bergmann 5 participants 9 messages Jul 3, 2019 – Jul 12, 2019

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

PATCH 1/1 waitqueue: fix clang -Wuninitialized warnings

When CONFIG_LOCKDEP is set, every use of DECLARE_WAIT_QUEUE_HEAD_ONSTACK() produces an annoying warning from clang, which is particularly annoying for allmodconfig builds:

fs/namei.c:1646:34: error: variable 'wq' is uninitialized when used within its own initialization [-Werror,-Wuninitialized]

        DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
                                        ^~

include/linux/wait.h:74:63: note: expanded from macro 'DECLARE_WAIT_QUEUE_HEAD_ONSTACK'
struct wait_queue_head name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
~~~~ ^~~~
include/linux/wait.h:72:33: note: expanded from macro '__WAIT_QUEUE_HEAD_INIT_ONSTACK'

        ({ init_waitqueue_head(&name); name; })
                                       ^~~~

After playing with it for a while, I have found a way to rephrase the macro in a way that should work well with both gcc and clang and not produce this warning. The open-coded __WAIT_QUEUE_HEAD_INIT_ONSTACK is a little more verbose than the original version by Peter Zijlstra, but avoids the gcc-ism that suppresses warnings when assigning a variable to itself.

---
 include/linux/wait.h | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)
include/linux/wait.h +9 -2
index ddb959641709..84e39643b780 100644
@@ -68,8 +68,15 @@ extern void __init_waitqueue_head(struct wait_queue_head *wq_head, const char *n
 	} while (0)
 
 #ifdef CONFIG_LOCKDEP
-# define __WAIT_QUEUE_HEAD_INIT_ONSTACK(name) \
-	({ init_waitqueue_head(&name); name; })
+# define __WAIT_QUEUE_HEAD_INIT_ONSTACK(name) {					\
+	.lock		= __SPIN_LOCK_UNLOCKED(name.lock),			\
+	.head		= ({							\
+		static struct lock_class_key __key;				\
+		lockdep_set_class_and_name(&(name).lock, &__key, # name);	\
+		(struct list_head){ &(name).head, &(name).head };		\
+	}),									\
+}
+
 # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) \
 	struct wait_queue_head name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
 #else
Signature · 1 line
2.20.0
Reviewed-by Tested-by on v1 1/1
#1 lore raw
Quoted 21 lines · Arnd Bergmann

When CONFIG_LOCKDEP is set, every use of DECLARE_WAIT_QUEUE_HEAD_ONSTACK() produces an annoying warning from clang, which is particularly annoying for allmodconfig builds:

fs/namei.c:1646:34: error: variable 'wq' is uninitialized when used within its own initialization [-Werror,-Wuninitialized]

        DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
                                        ^~

include/linux/wait.h:74:63: note: expanded from macro 'DECLARE_WAIT_QUEUE_HEAD_ONSTACK'
struct wait_queue_head name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
~~~~ ^~~~
include/linux/wait.h:72:33: note: expanded from macro '__WAIT_QUEUE_HEAD_INIT_ONSTACK'

        ({ init_waitqueue_head(&name); name; })
                                       ^~~~

After playing with it for a while, I have found a way to rephrase the macro in a way that should work well with both gcc and clang and not produce this warning. The open-coded __WAIT_QUEUE_HEAD_INIT_ONSTACK is a little more verbose than the original version by Peter Zijlstra, but avoids the gcc-ism that suppresses warnings when assigning a variable to itself.

Quoted 2 lines

Thank you for sending the fix for these warnings, they are the last major ones that I can see across various defconfig and allyesconfig testing. This resolves all of them.

#2 lore raw
Quoted 22 lines · Nathan Chancellor
Quoted 21 lines · Arnd Bergmann

When CONFIG_LOCKDEP is set, every use of DECLARE_WAIT_QUEUE_HEAD_ONSTACK() produces an annoying warning from clang, which is particularly annoying for allmodconfig builds:

fs/namei.c:1646:34: error: variable 'wq' is uninitialized when used within its own initialization [-Werror,-Wuninitialized]

        DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
                                        ^~

include/linux/wait.h:74:63: note: expanded from macro 'DECLARE_WAIT_QUEUE_HEAD_ONSTACK'
struct wait_queue_head name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
~~~~ ^~~~
include/linux/wait.h:72:33: note: expanded from macro '__WAIT_QUEUE_HEAD_INIT_ONSTACK'

        ({ init_waitqueue_head(&name); name; })
                                       ^~~~

After playing with it for a while, I have found a way to rephrase the macro in a way that should work well with both gcc and clang and not produce this warning. The open-coded __WAIT_QUEUE_HEAD_INIT_ONSTACK is a little more verbose than the original version by Peter Zijlstra, but avoids the gcc-ism that suppresses warnings when assigning a variable to itself.

Quoted 5 lines
Quoted 2 lines

Who would be the right person to pick this patch up for mainline?

I guess it may have to wait until the end of the merge window now, but I'd still like this to be part of 4.3 and possibly backported to the stable kernels as we build those with clang as well.

Arnd

maintainer
#3 lore raw
Quoted 24 lines · Arnd Bergmann
Quoted 22 lines · Nathan Chancellor
Quoted 21 lines · Arnd Bergmann

When CONFIG_LOCKDEP is set, every use of DECLARE_WAIT_QUEUE_HEAD_ONSTACK() produces an annoying warning from clang, which is particularly annoying for allmodconfig builds:

fs/namei.c:1646:34: error: variable 'wq' is uninitialized when used within its own initialization [-Werror,-Wuninitialized]

        DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
                                        ^~

include/linux/wait.h:74:63: note: expanded from macro 'DECLARE_WAIT_QUEUE_HEAD_ONSTACK'
struct wait_queue_head name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
~~~~ ^~~~
include/linux/wait.h:72:33: note: expanded from macro '__WAIT_QUEUE_HEAD_INIT_ONSTACK'

        ({ init_waitqueue_head(&name); name; })
                                       ^~~~

After playing with it for a while, I have found a way to rephrase the macro in a way that should work well with both gcc and clang and not produce this warning. The open-coded __WAIT_QUEUE_HEAD_INIT_ONSTACK is a little more verbose than the original version by Peter Zijlstra, but avoids the gcc-ism that suppresses warnings when assigning a variable to itself.

Quoted 7 lines
Quoted 5 lines
Quoted 2 lines

Who would be the right person to pick this patch up for mainline?

That would be me; but like Andrew, I'm not a fan of this patch.

#4 lore raw
In reply to Arnd Bergmann
Quoted 5 lines · On Wed, 3 Jul 2019 10:10:55 +0200 Arnd Bergmann <[email protected]> wrote:

When CONFIG_LOCKDEP is set, every use of DECLARE_WAIT_QUEUE_HEAD_ONSTACK() produces an annoying warning from clang, which is particularly annoying for allmodconfig builds:

fs/namei.c:1646:34: error: variable 'wq' is uninitialized when used within its own initialization [-Werror,-Wuninitialized]

Quoted 8 lines
        DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
                                        ^~

include/linux/wait.h:74:63: note: expanded from macro 'DECLARE_WAIT_QUEUE_HEAD_ONSTACK'
struct wait_queue_head name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
~~~~ ^~~~
include/linux/wait.h:72:33: note: expanded from macro '__WAIT_QUEUE_HEAD_INIT_ONSTACK'

        ({ init_waitqueue_head(&name); name; })
                                       ^~~~

<scratches head>

Surely clang is being extraordinarily dumb here?

DECLARE_WAIT_QUEUE_HEAD_ONSTACK() is effectively doing

struct wait_queue_head name = ({ __init_waitqueue_head(&name) ; name; })

which is perfectly legitimate! clang has no business assuming that __init_waitqueue_head() will do any reads from the pointer which it was passed, nor can clang assume that __init_waitqueue_head() leaves any of *name uninitialized.

Does it also warn if code does this?

	struct wait_queue_head name;
	__init_waitqueue_head(&name);
	name = name;

which is equivalent, isn't it?

The proposed solution is, effectively, to open-code __init_waitqueue_head() at each DECLARE_WAIT_QUEUE_HEAD_ONSTACK() callsite. That's pretty unpleasant and calls for an explanatory comment at the __WAIT_QUEUE_HEAD_INIT_ONSTACK() definition site as well as a cautionary comment at the __init_waitqueue_head() definition so we can keep the two versions in sync as code evolves.

Hopefully clang will soon be hit with the cluebat (yes?) and this change becomes obsolete in the quite short term. Surely 6-12 months from now nobody will be using the uncluebatted version of clang on contemporary kernel sources so we get to remove this nastiness again. Which makes me wonder whether we should merge it at all.

#5 lore raw
Quoted 15 lines · Andrew Morton

On Wed, 3 Jul 2019 10:10:55 +0200 Arnd Bergmann <[email protected]> wrote:

<scratches head>

Surely clang is being extraordinarily dumb here?

DECLARE_WAIT_QUEUE_HEAD_ONSTACK() is effectively doing

struct wait_queue_head name = ({ __init_waitqueue_head(&name) ; name; })

which is perfectly legitimate! clang has no business assuming that __init_waitqueue_head() will do any reads from the pointer which it was passed, nor can clang assume that __init_waitqueue_head() leaves any of *name uninitialized.

Quoted 7 lines

Does it also warn if code does this?

        struct wait_queue_head name;
        __init_waitqueue_head(&name);
        name = name;

which is equivalent, isn't it?

No, it does not warn for this.

I've tried a few more variants here: https://godbolt.org/z/ykSX0r

What I think is going on here is a result of clang and gcc fundamentally treating -Wuninitialized warnings differently. gcc tries to make the warnings as helpful as possible, but given the NP-complete nature of this problem it won't always get it right, and it traditionally allowed this syntax as a workaround.

int f(void)
{
int i = i; // tell gcc not to warn
return i;
}

clang apparently implements the warnings in a way that is as completely predictable (and won't warn in cases that it doesn't completely understand), but decided as a result that the gcc 'int i = i' syntax is bogus and it always warns about a variable used in its own declaration that is later referenced, without looking at whether the declaration does initialize it or not.

Quoted 6 lines

The proposed solution is, effectively, to open-code __init_waitqueue_head() at each DECLARE_WAIT_QUEUE_HEAD_ONSTACK() callsite. That's pretty unpleasant and calls for an explanatory comment at the __WAIT_QUEUE_HEAD_INIT_ONSTACK() definition site as well as a cautionary comment at the __init_waitqueue_head() definition so we can keep the two versions in sync as code evolves.

Yes, makes sense.

Quoted 5 lines

Hopefully clang will soon be hit with the cluebat (yes?) and this change becomes obsolete in the quite short term. Surely 6-12 months from now nobody will be using the uncluebatted version of clang on contemporary kernel sources so we get to remove this nastiness again. Which makes me wonder whether we should merge it at all.

Would it make you feel better to keep the current code but have an alternative version guarded with e.g. "#if defined(__clang__ && (__clang_major__ <= 9)"?

While it is probably a good idea to fix clang here, this is one of the last issues that causes a significant difference between gcc and clang in build testing with kernelci:
https://kernelci.org/build/next/branch/master/kernel/next-20190709/
I'm trying to get all the warnings fixed there so we can spot build-time regressions more easily.

Arnd

#6 lore raw
Quoted 65 lines · Arnd Bergmann
Quoted 15 lines · Andrew Morton

On Wed, 3 Jul 2019 10:10:55 +0200 Arnd Bergmann <[email protected]> wrote:

<scratches head>

Surely clang is being extraordinarily dumb here?

DECLARE_WAIT_QUEUE_HEAD_ONSTACK() is effectively doing

struct wait_queue_head name = ({ __init_waitqueue_head(&name) ; name; })

which is perfectly legitimate! clang has no business assuming that __init_waitqueue_head() will do any reads from the pointer which it was passed, nor can clang assume that __init_waitqueue_head() leaves any of *name uninitialized.

Quoted 7 lines

Does it also warn if code does this?

        struct wait_queue_head name;
        __init_waitqueue_head(&name);
        name = name;

which is equivalent, isn't it?

No, it does not warn for this.

I've tried a few more variants here: https://godbolt.org/z/ykSX0r

What I think is going on here is a result of clang and gcc fundamentally treating -Wuninitialized warnings differently. gcc tries to make the warnings as helpful as possible, but given the NP-complete nature of this problem it won't always get it right, and it traditionally allowed this syntax as a workaround.

int f(void)
{
int i = i; // tell gcc not to warn
return i;
}

clang apparently implements the warnings in a way that is as completely predictable (and won't warn in cases that it doesn't completely understand), but decided as a result that the gcc 'int i = i' syntax is bogus and it always warns about a variable used in its own declaration that is later referenced, without looking at whether the declaration does initialize it or not.

Quoted 6 lines

The proposed solution is, effectively, to open-code __init_waitqueue_head() at each DECLARE_WAIT_QUEUE_HEAD_ONSTACK() callsite. That's pretty unpleasant and calls for an explanatory comment at the __WAIT_QUEUE_HEAD_INIT_ONSTACK() definition site as well as a cautionary comment at the __init_waitqueue_head() definition so we can keep the two versions in sync as code evolves.

Yes, makes sense.

Quoted 5 lines

Hopefully clang will soon be hit with the cluebat (yes?) and this change becomes obsolete in the quite short term. Surely 6-12 months from now nobody will be using the uncluebatted version of clang on contemporary kernel sources so we get to remove this nastiness again. Which makes me wonder whether we should merge it at all.

Would it make you feel better to keep the current code but have an alternative version guarded with e.g. "#if defined(__clang__ && (__clang_major__ <= 9)"?

Quoted 8 lines

While it is probably a good idea to fix clang here, this is one of the last issues that causes a significant difference between gcc and clang in build testing with kernelci:
https://kernelci.org/build/next/branch/master/kernel/next-20190709/
I'm trying to get all the warnings fixed there so we can spot build-time regressions more easily.

Arnd

I'm just spitballing here since I am about to go to sleep but could we do something like you did for bee20031772a ("disable -Wattribute-alias warning for SYSCALL_DEFINEx()") and disable the warning in DECLARE_WAIT_QUEUE_HEAD_ONSTACK only since we know it is not going to be a problem? That way, if/when Clang is fixed, we can just have the warning be disabled for older versions?

Cheers,
Nathan

#7 lore raw
Quoted 74 lines · Nathan Chancellor
Quoted 72 lines · Arnd Bergmann
Quoted 15 lines · Andrew Morton

On Wed, 3 Jul 2019 10:10:55 +0200 Arnd Bergmann <[email protected]> wrote:

<scratches head>

Surely clang is being extraordinarily dumb here?

DECLARE_WAIT_QUEUE_HEAD_ONSTACK() is effectively doing

struct wait_queue_head name = ({ __init_waitqueue_head(&name) ; name; })

which is perfectly legitimate! clang has no business assuming that __init_waitqueue_head() will do any reads from the pointer which it was passed, nor can clang assume that __init_waitqueue_head() leaves any of *name uninitialized.

Quoted 7 lines

Does it also warn if code does this?

        struct wait_queue_head name;
        __init_waitqueue_head(&name);
        name = name;

which is equivalent, isn't it?

No, it does not warn for this.

I've tried a few more variants here: https://godbolt.org/z/ykSX0r

What I think is going on here is a result of clang and gcc fundamentally treating -Wuninitialized warnings differently. gcc tries to make the warnings as helpful as possible, but given the NP-complete nature of this problem it won't always get it right, and it traditionally allowed this syntax as a workaround.

int f(void)
{
int i = i; // tell gcc not to warn
return i;
}

clang apparently implements the warnings in a way that is as completely predictable (and won't warn in cases that it doesn't completely understand), but decided as a result that the gcc 'int i = i' syntax is bogus and it always warns about a variable used in its own declaration that is later referenced, without looking at whether the declaration does initialize it or not.

Quoted 6 lines

The proposed solution is, effectively, to open-code __init_waitqueue_head() at each DECLARE_WAIT_QUEUE_HEAD_ONSTACK() callsite. That's pretty unpleasant and calls for an explanatory comment at the __WAIT_QUEUE_HEAD_INIT_ONSTACK() definition site as well as a cautionary comment at the __init_waitqueue_head() definition so we can keep the two versions in sync as code evolves.

Yes, makes sense.

Quoted 5 lines

Hopefully clang will soon be hit with the cluebat (yes?) and this change becomes obsolete in the quite short term. Surely 6-12 months from now nobody will be using the uncluebatted version of clang on contemporary kernel sources so we get to remove this nastiness again. Which makes me wonder whether we should merge it at all.

Would it make you feel better to keep the current code but have an alternative version guarded with e.g. "#if defined(__clang__ && (__clang_major__ <= 9)"?

While it is probably a good idea to fix clang here, this is one of the last issues that causes a significant difference between gcc and clang in build testing with kernelci:
https://kernelci.org/build/next/branch/master/kernel/next-20190709/
I'm trying to get all the warnings fixed there so we can spot build-time regressions more easily.

Quoted 8 lines
Quoted 1 line

Arnd

I'm just spitballing here since I am about to go to sleep but could we do something like you did for bee20031772a ("disable -Wattribute-alias warning for SYSCALL_DEFINEx()") and disable the warning in DECLARE_WAIT_QUEUE_HEAD_ONSTACK only since we know it is not going to be a problem? That way, if/when Clang is fixed, we can just have the warning be disabled for older versions?

I managed to get that to work, but there are two problems:

- the __diag_ignore() infrastructure was never added for clang, so I ended up copying a lot from gcc. There is probably a nicer way to do this, but that would require a larger rework
- adding __diag_pop() between two variable declarations is seen as a statement that causes a warning with both gcc and clang, so I had to turn that warning off as well for all compilers, and at that point it gets rather ugly in the macro.

Arnd

include/linux/compiler-clang.h +28 -0
index 333a6695a918..0d30c0489ad7 100644
@@ -42,3 +42,31 @@
  * compilers, like ICC.
  */
 #define barrier() __asm__ __volatile__("" : : : "memory")
+
+/*
+ * Turn individual warnings and errors on and off locally, depending
+ * on version.
+ */
+#define __diag_clang(version, severity, s) \
+       __diag_clang_ ## version(__diag_clang_ ## severity s)
+
+/* Severity used in pragma directives */
+#define __diag_clang_ignore    ignored
+#define __diag_clang_warn      warning
+#define __diag_clang_error     error
+
+#define __diag_str1(s)         #s
+#define __diag_str(s)          __diag_str1(s)
+#define __diag(s)              _Pragma(__diag_str(clang diagnostic s))
+
+#if __clang_major__ >= 8
+#define __diag_clang_8(s)              __diag(s)
+#else
+#define __diag_clang_8(s)
+#endif
+
+#if __clang_major__ >= 9
+#define __diag_clang_9(s)              __diag(s)
+#else
+#define __diag_clang_9(s)
+#endif
include/linux/compiler-gcc.h +8 -0
index e8579412ad21..c5f8d9ae0530 100644
@@ -165,8 +165,16 @@
 #define __diag_str(s)          __diag_str1(s)
 #define __diag(s)              _Pragma(__diag_str(GCC diagnostic s))
 
+#if GCC_VERSION >= 40006
+#define __diag_GCC_4_6(s)      __diag(s)
+#else
+#define __diag_GCC_4_6(s)
+#endif
+
 #if GCC_VERSION >= 80000
 #define __diag_GCC_8(s)                __diag(s)
 #else
 #define __diag_GCC_8(s)
 #endif
+
+#define __diag_clang(s...)
include/linux/wait.h +0 -0
index ddb959641709..0e33fe589f49 100644
@@ -71,7 +71,12 @@ extern void __init_waitqueue_head(struct

wait_queue_head *wq_head, const char *n

 # define __WAIT_QUEUE_HEAD_INIT_ONSTACK(name) \
        ({ init_waitqueue_head(&name); name; })
 # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) \
-       struct wait_queue_head name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
+       __diag_push();                  \
+       __diag_ignore(clang, 8, "-Wuninitialized",
"https://godbolt.org/z/ykSX0r");     \
+       __diag_ignore(clang, 8, "-Wdeclaration-after-statement", "for
__diag_pop");     \
+       __diag_ignore(GCC, 4_6, "-Wdeclaration-after-statement", "for
__diag_pop");     \
+       struct wait_queue_head name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name); \
+       __diag_pop()
 #else
 # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) DECLARE_WAIT_QUEUE_HEAD(name)
 #endif
#8 lore raw
In reply to Arnd Bergmann
Quoted 19 lines · Arnd Bergmann
Quoted 17 lines · Andrew Morton

On Wed, 3 Jul 2019 10:10:55 +0200 Arnd Bergmann <[email protected]> wrote:

<scratches head>

Surely clang is being extraordinarily dumb here?

DECLARE_WAIT_QUEUE_HEAD_ONSTACK() is effectively doing

struct wait_queue_head name = ({ __init_waitqueue_head(&name) ; name; })

which is perfectly legitimate! clang has no business assuming that __init_waitqueue_head() will do any reads from the pointer which it was passed, nor can clang assume that __init_waitqueue_head() leaves any of *name uninitialized.

Does it also warn if code does this?

Quoted 7 lines
Quoted 5 lines
        struct wait_queue_head name;
        __init_waitqueue_head(&name);
        name = name;

which is equivalent, isn't it?

No, it does not warn for this.

So I think this is just a bug in Clang, where it's getting tripped up due to the GNU C statement expression. See the example I put in this bug report: https://bugs.llvm.org/show_bug.cgi?id=42604

Clang is warning for this pattern of struct assignment, but not for non-aggregate (integral) assignment.

(I think that pattern is pretty cool; it makes it more straightforward to provide macro's that properly construct aggregates in C; in particular I feel like I've been looking for something like this to simply the use of __attribute__((__cleanup__)) to do RAII in C and make smart pointers, fd's, etc.).

Let's fix Clang, drop the kernel workaround, and thanks for the discussion.

Signature · 2 lines
Thanks,
~Nick Desaulniers