coccinelle: misc: add flexible_array.cocci script
RFC PATCH 1/1 coccinelle: misc: add flexible_array.cocci script
Commit 68e4cd17e218 ("docs: deprecated.rst: Add zero-length and one-element arrays") marks one-element and zero-length arrays as deprecated. Kernel code should always use "flexible array members" instead.
The script warns about one-element and zero-length arrays in structs.
---
Currently, it's just a draft. I've placed a number of questions in the script and marked them as TODO. Kees, Gustavo, if you could help me with my questions I think that this rule will be enough to close:
https://github.com/KSPP/linux/issues/76
BTW, I it's possible to not warn about files in uapi folder if this is relevant. Do I need to do it in the script?
scripts/coccinelle/misc/flexible_array.cocci | 158 +++++++++++++++++++ 1 file changed, 158 insertions(+) create mode 100644 scripts/coccinelle/misc/flexible_array.cocci
scripts/coccinelle/misc/flexible_array.cocci new file +158 -0
@@ -0,0 +1,158 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// +/// Zero-length and one-element arrays are deprecated, see +/// Documentation/process/deprecated.rst +/// Flexible-array members should be used instead. +/// +// +// Confidence: High +// Copyright: (C) 2020 Denis Efremov ISPRAS. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual report +virtual org +virtual patch + +@r depends on !patch@ +identifier name, size, array; +// TODO: We can additionally restrict size and array to: +// identifier size =~ ".*(num|len|count|size|ncpus).*"; +// identifier array !~ ".*(pad|reserved).*"; +// Do we need it? +type TS, TA; +position p; +@@ + +( + // This will also match: typedef struct name { ... + // However nested structs are not matched, i.e.: + // struct name1 { struct name2 { int s; int a[0]; } st; int i; } + // will not be matched. Do we need to handle it? + struct name { + ... // TODO: Maybe simple ... is enough? It will match structs with a + TS size; // single field, e.g. + ... // https://elixir.bootlin.com/linux/v5.8/source/arch/arm/include/uapi/asm/setup.h#L127 +( +* TA array@p[0]; +| + // TODO: It seems that there are exception cases for array[1], e.g. + // https://elixir.bootlin.com/linux/v5.8/source/arch/powerpc/boot/rs6000.h#L152 + // https://elixir.bootlin.com/linux/v5.8/source/include/uapi/linux/cdrom.h#L292 + // https://elixir.bootlin.com/linux/v5.8/source/drivers/net/wireless/ath/ath6kl/usb.c#L108 + // We could either drop array[1] checking from this rule or + // restrict array name with regexp and add, for example, an "allowlist" + // with struct names where we allow this code pattern. + // TODO: How to handle: u8 data[1][MAXLEN_PSTR6]; ? +* TA array@p[1]; +) + }; +| + struct { + ... + TS size; + ... +( +* TA array@p[0]; +| +* TA array@p[1]; +) + }; +| + // TODO: do we need to handle unions? + union name { + ... + TS size; + ... +( +* TA array@p[0]; +| +* TA array@p[1]; +) + }; +| + union { + ... + TS size; + ... +( +* TA array@p[0]; +| +* TA array@p[1]; +) + }; +) + +// FIXME: Patch mode doesn't work as expected. +// Coccinelle handles formatting incorrectly. +// Patch mode in this rule should be disabled until +// proper formatting will be supported. +@depends on patch exists@ +identifier name, size, array; +type TS, TA; +@@ + +( + struct name { + ... + TS size; + ... +( +- TA array[0]; +| +- TA array[1]; +) ++ TA array[]; + }; +| + struct { + ... + TS size; + ... +( +- TA array[0]; +| +- TA array[1]; +) ++ TA array[]; + }; +| + union name { + ... + TS size; + ... +( +- TA array[0]; +| +- TA array[1]; +) ++ TA array[]; + }; +| + union { + ... + TS size; + ... +( +- TA array[0]; +| +- TA array[1]; +) ++ TA array[]; + }; +) + +@script: python depends on report@ +p << r.p; +@@ + +msg = "WARNING: use flexible-array member instead" +coccilib.report.print_report(p[0], msg) + +@script: python depends on org@ +p << r.p; +@@ + +msg = "WARNING: use flexible-array member instead" +coccilib.org.print_todo(p, msg)
Signature · 1 line
2.26.2
Hi Denis,
Thanks a lot for working on this. Please, see some comments below...
Quoted 11 lines · Denis Efremov
Commit
68e4cd17e218("docs:deprecated.rst: Add zero-length and one-element arrays") marks one-element and zero-length arrays as deprecated. Kernel code should always use "flexible array members" instead.The script warns about one-element and zero-length arrays in structs.
Cc Kees Cook <[email protected]>Cc Gustavo A. R. Silva <[email protected]>Signed-off-by Denis Efremov <[email protected]>---
Quoted 8 lines
Currently, it's just a draft. I've placed a number of questions in the script and marked them as TODO. Kees, Gustavo, if you could help me with my questions I think that this rule will be enough to close:
https://github.com/KSPP/linux/issues/76BTW, I it's possible to not warn about files in uapi folder if this is relevant. Do I need to do it in the script?
I think the script should warn about new additions of zero-length/one-element arrays in UAPI.
Quoted 32 lines
scripts/coccinelle/misc/flexible_array.cocci | 158 +++++++++++++++++++ 1 file changed, 158 insertions(+) create mode 100644 scripts/coccinelle/misc/flexible_array.cocciscripts/coccinelle/misc/flexible_array.cocci new file +22
-0@@ -0,0 +1,158 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// +/// Zero-length and one-element arrays are deprecated, see +/// Documentation/process/deprecated.rst +/// Flexible-array members should be used instead. +/// +// +// Confidence: High +// Copyright: (C) 2020 Denis Efremov ISPRAS. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual report +virtual org +virtual patch + +@r depends on !patch@ +identifier name, size, array; +// TODO: We can additionally restrict size and array to: +// identifier size =~ ".*(num|len|count|size|ncpus).*"; +// identifier array !~ ".*(pad|reserved).*";
scripts/coccinelle/misc/flexible_array.cocci line 32
Quoted 10 lines
scripts/coccinelle/misc/flexible_array.cocci new file +10
-0+// Do we need it? +type TS, TA; +position p; +@@ + +( + // This will also match: typedef struct name { ... + // However nested structs are not matched, i.e.: + // struct name1 { struct name2 { int s; int a[0]; } st; int i; } + // will not be matched. Do we need to handle it?
It's fine. I think this would be a different script. One that exclusively look for all three: zero-length, one-element arrays and flexible array members in nested structures because "A structure containing a flexible array member, or a union containing such a structure (possibly recursively), may not be a member of a structure or an element of an array. (However these uses are permitted by GCC as extensions.)"[1]
scripts/coccinelle/misc/flexible_array.cocci line 34
Quoted 2 lines
scripts/coccinelle/misc/flexible_array.cocci new file +2
-0+ struct name { + ... // TODO: Maybe simple ... is enough? It will match structs with a
Yep; simple is always better at first. :)
Quoted 19 lines
scripts/coccinelle/misc/flexible_array.cocci new file +19
-0+ TS size; // single field, e.g. + ... // https://elixir.bootlin.com/linux/v5.8/source/arch/arm/include/uapi/asm/setup.h#L127 +( +* TA array@p[0]; +| + // TODO: It seems that there are exception cases for array[1], e.g. + // https://elixir.bootlin.com/linux/v5.8/source/arch/powerpc/boot/rs6000.h#L152 + // https://elixir.bootlin.com/linux/v5.8/source/include/uapi/linux/cdrom.h#L292 + // https://elixir.bootlin.com/linux/v5.8/source/drivers/net/wireless/ath/ath6kl/usb.c#L108 + // We could either drop array[1] checking from this rule or + // restrict array name with regexp and add, for example, an "allowlist" + // with struct names where we allow this code pattern. + // TODO: How to handle: u8 data[1][MAXLEN_PSTR6]; ? +* TA array@p[1]; +) + }; +| + struct { + ...
scripts/coccinelle/misc/flexible_array.cocci line 63
Quoted 10 lines
scripts/coccinelle/misc/flexible_array.cocci new file +10
-0+ TS size; + ... +( +* TA array@p[0]; +| +* TA array@p[1]; +) + }; +| + // TODO: do we need to handle unions?
Yep; we should warn about this in unions, too.
However, I think unions cannot have members with
incomplete type, so we should not suggest the use
of flexible-array members in unions, because
flexible arrays have incomplete type.
Quoted 69 lines
scripts/coccinelle/misc/flexible_array.cocci new file +69
-0+ union name { + ... + TS size; + ... +( +* TA array@p[0]; +| +* TA array@p[1]; +) + }; +| + union { + ... + TS size; + ... +( +* TA array@p[0]; +| +* TA array@p[1]; +) + }; +) + +// FIXME: Patch mode doesn't work as expected. +// Coccinelle handles formatting incorrectly. +// Patch mode in this rule should be disabled until +// proper formatting will be supported. +@depends on patch exists@ +identifier name, size, array; +type TS, TA; +@@ + +( + struct name { + ... + TS size; + ... +( +- TA array[0]; +| +- TA array[1]; +) ++ TA array[]; + }; +| + struct { + ... + TS size; + ... +( +- TA array[0]; +| +- TA array[1]; +) ++ TA array[]; + }; +| + union name { + ... + TS size; + ... +( +- TA array[0]; +| +- TA array[1]; +) ++ TA array[]; + }; +|
scripts/coccinelle/misc/flexible_array.cocci line 142
Quoted 10 lines
scripts/coccinelle/misc/flexible_array.cocci new file +10
-0+ union { + ... + TS size; + ... +( +- TA array[0]; +| +- TA array[1]; +) ++ TA array[];
This is not allowed, neither is GCC[2] nor in Clang[3].
Quoted 7 lines
scripts/coccinelle/misc/flexible_array.cocci new file +6
-0+ }; +) + +@script: python depends on report@ +p << r.p; +@@
scripts/coccinelle/misc/flexible_array.cocci line 158
Quoted 10 lines
scripts/coccinelle/misc/flexible_array.cocci new file +10
-0+ +msg = "WARNING: use flexible-array member instead" +coccilib.report.print_report(p[0], msg) + +@script: python depends on org@ +p << r.p; +@@ + +msg = "WARNING: use flexible-array member instead" +coccilib.org.print_todo(p, msg)
I wonder if it might be worth it to also point people to the documentation in deprecated.rst (commit 68e4cd17e218 ("docs: deprecated.rst: Add zero-length and one-element arrays")), once helpdesk generates the official documentation for 5.9-rc1.
Thanks
--
Gustavo
[1] https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html
[2] https://godbolt.org/z/Kajd7e
[3] https://godbolt.org/z/dvKMYb
PATCH v2 1/1 coccinelle: misc: add flexible_array.cocci script
In reply to Denis EfremovCommit 68e4cd17e218 ("docs: deprecated.rst: Add zero-length and one-element arrays") marks one-element and zero-length arrays as deprecated. Kernel code should always use "flexible array members" instead.
The script warns about one-element and zero-length arrays in structs.
---
Changes in v2:
- all uapi headers are now filtered-out. Unfortunately, coccinelle doesn't provide structure names in Location.current_element. For structures the field is always "something_else". Thus, there is no easy way to create a list of existing structures in uapi headers and suppress the warning only for them, but not for the newly added uapi structures.
- The pattern doesn't require 2+ fields in a structure/union anymore. Now it also checks single field structures/unions.
- The pattern simplified and now uses disjuction in array elements (Thanks, Markus)
- Unions are removed from patch mode
- one-element arrays are removed from patch mode. Correct patch may involve turning the array to a simple field instead of a flexible array.
On the current master branch, the rule generates:
- context: https://gist.github.com/evdenis/e2b4323491f9eff35376372df07f723c
- patch: https://gist.github.com/evdenis/46081da9d68ecefd07edc3769cebcf32
scripts/coccinelle/misc/flexible_array.cocci | 88 ++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 scripts/coccinelle/misc/flexible_array.cocci
scripts/coccinelle/misc/flexible_array.cocci new file +88 -0
@@ -0,0 +1,88 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// +/// Zero-length and one-element arrays are deprecated, see +/// Documentation/process/deprecated.rst +/// Flexible-array members should be used instead. +/// +// +// Confidence: High +// Copyright: (C) 2020 Denis Efremov ISPRAS. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual report +virtual org +virtual patch + +@initialize:python@ +@@ +def relevant(positions): + for p in positions: + if "uapi" in p.file: + return False + return True + +@r depends on !patch@ +identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... +* T array@p[\(0\|1\)]; + }; +| + struct { + ... +* T array@p[\(0\|1\)]; + }; +| + union name { + ... +* T array@p[\(0\|1\)]; + }; +| + union { + ... +* T array@p[\(0\|1\)]; + }; +) + +@depends on patch exists@ +identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... + T array@p[ +- 0 + ]; + }; +| + struct { + ... + T array@p[ +- 0 + ]; + }; +) + +@script: python depends on report@ +p << r.p; +@@ + +msg = "WARNING: use flexible-array member instead" +coccilib.report.print_report(p[0], msg) + +@script: python depends on org@ +p << r.p; +@@ + +msg = "WARNING: use flexible-array member instead" +coccilib.org.print_todo(p, msg)
Signature · 1 line
2.26.2
Julia Lawall
maintainerQuoted 84 lines · Denis Efremov
Commit
68e4cd17e218("docs:deprecated.rst: Add zero-length and one-element arrays") marks one-element and zero-length arrays as deprecated. Kernel code should always use "flexible array members" instead.The script warns about one-element and zero-length arrays in structs.
Cc Kees Cook <[email protected]>Cc Gustavo A. R. Silva <[email protected]>Signed-off-by Denis Efremov <[email protected]>---
Changes in v2:
- all uapi headers are now filtered-out. Unfortunately, coccinelle doesn't provide structure names in Location.current_element. For structures the field is always "something_else". Thus, there is no easy way to create a list of existing structures in uapi headers and suppress the warning only for them, but not for the newly added uapi structures.
- The pattern doesn't require 2+ fields in a structure/union anymore. Now it also checks single field structures/unions.
- The pattern simplified and now uses disjuction in array elements (Thanks, Markus)
- Unions are removed from patch mode
- one-element arrays are removed from patch mode. Correct patch may involve turning the array to a simple field instead of a flexible array.On the current master branch, the rule generates:
- context: https://gist.github.com/evdenis/e2b4323491f9eff35376372df07f723c
- patch: https://gist.github.com/evdenis/46081da9d68ecefd07edc3769cebcf32scripts/coccinelle/misc/flexible_array.cocci | 88 ++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 scripts/coccinelle/misc/flexible_array.cocciscripts/coccinelle/misc/flexible_array.cocci new file +44
-0@@ -0,0 +1,88 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// +/// Zero-length and one-element arrays are deprecated, see +/// Documentation/process/deprecated.rst +/// Flexible-array members should be used instead. +/// +// +// Confidence: High +// Copyright: (C) 2020 Denis Efremov ISPRAS. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual report +virtual org +virtual patch + +@initialize:python@ +@@ +def relevant(positions): + for p in positions: + if "uapi" in p.file: + return False + return True + +@r depends on !patch@ +identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... +* T array@p[\(0\|1\)]; + }; +| + struct { + ... +* T array@p[\(0\|1\)]; + }; +| + union name { + ...
scripts/coccinelle/misc/flexible_array.cocci line 54
Quoted 10 lines
scripts/coccinelle/misc/flexible_array.cocci new file +10
-0+* T array@p[\(0\|1\)]; + }; +| + union { + ... +* T array@p[\(0\|1\)]; + }; +) + +@depends on patch exists@
exists is not necessary here. There are not multiple control-flow paths through a structure declaration.
Quoted 24 lines
scripts/coccinelle/misc/flexible_array.cocci new file +24
-0+identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... + T array@p[ +- 0 + ]; + }; +| + struct { + ... + T array@p[ +- 0 + ]; + }; +) + +@script: python depends on report@ +p << r.p; +@@
scripts/coccinelle/misc/flexible_array.cocci line 88
Quoted 10 lines
scripts/coccinelle/misc/flexible_array.cocci new file +10
-0+ +msg = "WARNING: use flexible-array member instead" +coccilib.report.print_report(p[0], msg) + +@script: python depends on org@ +p << r.p; +@@ + +msg = "WARNING: use flexible-array member instead" +coccilib.org.print_todo(p, msg)
This should be coccilib.org.print_todo(p[0], msg)
julia
_______________________________________________
Cocci mailing list
[email protected]
https://systeme.lip6.fr/mailman/listinfo/cocci
Hi,
Quoted 130 lines · Julia Lawall
Quoted 84 lines · Denis Efremov
Commit
68e4cd17e218("docs:deprecated.rst: Add zero-length and one-element arrays") marks one-element and zero-length arrays as deprecated. Kernel code should always use "flexible array members" instead.The script warns about one-element and zero-length arrays in structs.
Cc Kees Cook <[email protected]>Cc Gustavo A. R. Silva <[email protected]>Signed-off-by Denis Efremov <[email protected]>---
Changes in v2:
- all uapi headers are now filtered-out. Unfortunately, coccinelle doesn't provide structure names in Location.current_element. For structures the field is always "something_else". Thus, there is no easy way to create a list of existing structures in uapi headers and suppress the warning only for them, but not for the newly added uapi structures.
- The pattern doesn't require 2+ fields in a structure/union anymore. Now it also checks single field structures/unions.
- The pattern simplified and now uses disjuction in array elements (Thanks, Markus)
- Unions are removed from patch mode
- one-element arrays are removed from patch mode. Correct patch may involve turning the array to a simple field instead of a flexible array.On the current master branch, the rule generates:
- context: https://gist.github.com/evdenis/e2b4323491f9eff35376372df07f723c
- patch: https://gist.github.com/evdenis/46081da9d68ecefd07edc3769cebcf32scripts/coccinelle/misc/flexible_array.cocci | 88 ++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 scripts/coccinelle/misc/flexible_array.cocciscripts/coccinelle/misc/flexible_array.cocci new file +44
-0@@ -0,0 +1,88 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// +/// Zero-length and one-element arrays are deprecated, see +/// Documentation/process/deprecated.rst +/// Flexible-array members should be used instead. +/// +// +// Confidence: High +// Copyright: (C) 2020 Denis Efremov ISPRAS. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual report +virtual org +virtual patch + +@initialize:python@ +@@ +def relevant(positions): + for p in positions: + if "uapi" in p.file: + return False + return True + +@r depends on !patch@ +identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... +* T array@p[\(0\|1\)]; + }; +| + struct { + ... +* T array@p[\(0\|1\)]; + }; +| + union name { + ...scripts/coccinelle/misc/flexible_array.cocci line 54
Quoted 10 lines
scripts/coccinelle/misc/flexible_array.cocci new file +10
-0+* T array@p[\(0\|1\)]; + }; +| + union { + ... +* T array@p[\(0\|1\)]; + }; +) + +@depends on patch exists@exists is not necessary here. There are not multiple control-flow paths through a structure declaration.
Quoted 28 lines
scripts/coccinelle/misc/flexible_array.cocci new file +28
-0+identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... + T array@p[ +- 0 + ]; + }; +| + struct { + ... + T array@p[ +- 0 + ]; + }; +) + +@script: python depends on report@ +p << r.p; +@@ + +msg = "WARNING: use flexible-array member instead" +coccilib.report.print_report(p[0], msg) +
Quoted 9 lines
scripts/coccinelle/misc/flexible_array.cocci line 88
Quoted 6 lines
scripts/coccinelle/misc/flexible_array.cocci new file +6
-0+@script: python depends on org@ +p << r.p; +@@ + +msg = "WARNING: use flexible-array member instead" +coccilib.org.print_todo(p, msg)This should be
coccilib.org.print_todo(p[0], msg)
Thanks, I will send v3 with fixes and proper links to online documentation.
Regards,
Denis
PATCH v3 1/1 coccinelle: misc: add flexible_array.cocci script
In reply to Denis EfremovOne-element and zero-length arrays are deprecated [1]. Kernel code should always use "flexible array members" instead, except for existing uapi definitions.
The script warns about one-element and zero-length arrays in structs.
[1] commit 68e4cd17e218 ("docs: deprecated.rst: Add zero-length and one-element arrays")
---
Changes in v2:
- all uapi headers are now filtered-out. Unfortunately, coccinelle doesn't provide structure names in Location.current_element. For structures the field is always "something_else". Thus, there is no easy way to create a list of existing structures in uapi headers and suppress the warning only for them, but not for the newly added uapi structures.
- The pattern doesn't require 2+ fields in a structure/union anymore. Now it also checks single field structures/unions.
- The pattern simplified and now uses disjuction in array elements (Thanks, Markus)
- Unions are removed from patch mode
- one-element arrays are removed from patch mode. Correct patch may involve turning the array to a simple field instead of a flexible array.
Changes in v3:
- exists removed from "depends on patch"
- position argument fixed in org mode
- link to the online documentation added to the warning message
scripts/coccinelle/misc/flexible_array.cocci | 88 ++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 scripts/coccinelle/misc/flexible_array.cocci
scripts/coccinelle/misc/flexible_array.cocci new file +88 -0
@@ -0,0 +1,88 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// +/// Zero-length and one-element arrays are deprecated, see +/// Documentation/process/deprecated.rst +/// Flexible-array members should be used instead. +/// +// +// Confidence: High +// Copyright: (C) 2020 Denis Efremov ISPRAS. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual report +virtual org +virtual patch + +@initialize:python@ +@@ +def relevant(positions): + for p in positions: + if "uapi" in p.file: + return False + return True + +@r depends on !patch@ +identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... +* T array@p[\(0\|1\)]; + }; +| + struct { + ... +* T array@p[\(0\|1\)]; + }; +| + union name { + ... +* T array@p[\(0\|1\)]; + }; +| + union { + ... +* T array@p[\(0\|1\)]; + }; +) + +@depends on patch@ +identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... + T array@p[ +- 0 + ]; + }; +| + struct { + ... + T array@p[ +- 0 + ]; + }; +) + +@script: python depends on report@ +p << r.p; +@@ + +msg = "WARNING use flexible-array member instead (https://www.kernel.org/doc/html/latest/process/deprecated.html#zero-length-and-one-element-arrays)" +coccilib.report.print_report(p[0], msg) + +@script: python depends on org@ +p << r.p; +@@ + +msg = "WARNING use flexible-array member instead (https://www.kernel.org/doc/html/latest/process/deprecated.html#zero-length-and-one-element-arrays)" +coccilib.org.print_todo(p[0], msg)
Signature · 1 line
2.26.2
Quoted 4 lines · Denis Efremov
One-element and zero-length arrays are deprecated [1]. Kernel code should always use "flexible array members" instead, except for existing uapi definitions.
Quoted 8 lines
The script warns about one-element and zero-length arrays in structs.
[1] commit
68e4cd17e218("docs:deprecated.rst: Add zero-length and one-element arrays")Cc Kees Cook <[email protected]>Cc Gustavo A. R. Silva <[email protected]>Signed-off-by Denis Efremov <[email protected]>
Applied, thanks.
Quoted 120 lines
---
Changes in v2:
- all uapi headers are now filtered-out. Unfortunately, coccinelle doesn't provide structure names in Location.current_element. For structures the field is always "something_else". Thus, there is no easy way to create a list of existing structures in uapi headers and suppress the warning only for them, but not for the newly added uapi structures.
- The pattern doesn't require 2+ fields in a structure/union anymore. Now it also checks single field structures/unions.
- The pattern simplified and now uses disjuction in array elements (Thanks, Markus)
- Unions are removed from patch mode
- one-element arrays are removed from patch mode. Correct patch may involve turning the array to a simple field instead of a flexible array.
Changes in v3:
- exists removed from "depends on patch"
- position argument fixed in org mode
- link to the online documentation added to the warning messagescripts/coccinelle/misc/flexible_array.cocci | 88 ++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 scripts/coccinelle/misc/flexible_array.cocciscripts/coccinelle/misc/flexible_array.cocci new file +88
-1@@ -0,0 +1,88 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// +/// Zero-length and one-element arrays are deprecated, see +/// Documentation/process/deprecated.rst +/// Flexible-array members should be used instead. +/// +// +// Confidence: High +// Copyright: (C) 2020 Denis Efremov ISPRAS. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual report +virtual org +virtual patch + +@initialize:python@ +@@ +def relevant(positions): + for p in positions: + if "uapi" in p.file: + return False + return True + +@r depends on !patch@ +identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... +* T array@p[\(0\|1\)]; + }; +| + struct { + ... +* T array@p[\(0\|1\)]; + }; +| + union name { + ... +* T array@p[\(0\|1\)]; + }; +| + union { + ... +* T array@p[\(0\|1\)]; + }; +) + +@depends on patch@ +identifier name, array; +type T; +position p : script:python() { relevant(p) }; +@@ + +( + struct name { + ... + T array@p[ +- 0 + ]; + }; +| + struct { + ... + T array@p[ +- 0 + ]; + }; +) + +@script: python depends on report@ +p << r.p; +@@ + +msg = "WARNING use flexible-array member instead (https://www.kernel.org/doc/html/latest/process/deprecated.html#zero-length-and-one-element-arrays)" +coccilib.report.print_report(p[0], msg) + +@script: python depends on org@ +p << r.p; +@@ + +msg = "WARNING use flexible-array member instead (https://www.kernel.org/doc/html/latest/process/deprecated.html#zero-length-and-one-element-arrays)" +coccilib.org.print_todo(p[0], msg) --
Quoted 3 lines
2.26.2
_______________________________________________
Cocci mailing list
[email protected]
https://systeme.lip6.fr/mailman/listinfo/cocci