On Wed, 3 Mar 2021, Mansour Moufid wrote:
> On Tue, Mar 2, 2021 at 4:22 PM Joe Perches <j...@perches.com> wrote:
> >
> > Here is a possible opportunity to reduce data usage in the kernel.
> >
> > $ git grep -P -n '^static\s+(?!const|struct)(?:\w+\s+){1,3}\w+\s*\[\s*\]'
> > drivers/ | \
> > grep -v __initdata | \
> > wc -l
> > 3250
> >
> > Meaning there are ~3000 declarations of arrays with what appears to be
> > file static const content that are not marked const.
> >
> > So there are many static arrays that could be marked const to move the
> > compiled object code from data to text minimizing the total amount of
> > exposed r/w data.
> >
> > However, I do not know of a mechanism using coccinelle to determine
> > whether or not any of these static declarations are ever modified.
>
> I thought it would be a fun exercise but it got tedious quick.
>
> I don't know how to ignore an attribute like __initdata.
>
> Feel free to refine it:
This adds the consts, but it doesn't check that the array is never
updated, or never stored in a field from which it could get updated.
In my attempt, I tried something like this for the first part:
@r disable optional_qualifier@
type T;
identifier x;
position p != ok.p;
@@
static T x@p[] = { ... };
In principle, this should match cases where there is no const. But it
dones't work. It matches some cases with const too.
Then I tried:
@ok@
type T;
identifier x;
position p;
@@
static const T x@p[] = { ... };
@r@
type T;
identifier x;
position p != ok.p;
@@
static T x@p[] = { ... };
The first rule matches the cases with const, and then the second rule
matches all of the cases with the declared variable at a position
different than that of the first rule. It works if the type T is a simple
type like int, but it doesn't work if it is something more complex, like
struct foo *.
Afterwards, I have the following:
@bad@
position p;
identifier r.x;
expression e,y;
@@
(
x@p[y] = e
|
&x@p[y]
)
@good@
identifier r.x;
expression y;
position p != bad.p;
@@
x@p[y]
@notgood@
identifier r.x;
position p != good.p;
@@
x@p
@depends on good && !notgood@
identifier r.x;
type r.T;
@@
static
+const
T x[] = { ... };
That is,
* rule bad: Give up if we assign an element or take the address of an
element.
* rule good: Things are going well if we access an element of the array.
If there is no access at all, there is something suspicious, perhaps uses
in macros.
* rule notgood: A montion of the array that is not an element access is
not good either
In the end, if we match good and we don't match notgood, then we can make
the change.
I got stuck on the const problem, and didn't try the __initdata issue.
But one could address with a rule like the rule ok above.
The const problem is at least something worth looking into.
julia
>
>
> @@
> type t;
> identifier x;
> @@
> (
> static const struct { ... } x[];
> |
> static
> + const
> struct { ... } x[];
> |
> static const struct s *x[];
> |
> static
> + const
> struct s *x[];
> |
> static const struct s x[];
> |
> static
> + const
> struct s x[];
> |
> static const t *x[];
> |
> static
> + const
> t *x[];
> |
> static const t x[];
> |
> static
> + const
> t x[];
> )
>
> @@
> type t;
> identifier s, x, y, z;
> assignment operator xx;
> @@
> (
> static const struct { ... } x[] = { ... };
> |
> static
> + const
> struct { ... } x[] = { ... };
> |
> static const struct s *x[] = { ... };
> |
> static
> + const
> struct s *x[] = { ... };
> |
> static const struct s x[] = { ... };
> |
> static
> + const
> struct s x[] = { ... };
> |
> static const t *x[] = { ... };
> |
> static
> + const
> t *x[] = { ... };
> |
> static const t x[] = { ... };
> |
> static
> + const
> t x[] = { ... };
> )
> ... when != x.y xx ...
> when != x[...] xx ...
> when != z = x
> _______________________________________________
> Cocci mailing list
> Cocci@systeme.lip6.fr
> https://systeme.lip6.fr/mailman/listinfo/cocci
>
_______________________________________________
Cocci mailing list
Cocci@systeme.lip6.fr
https://systeme.lip6.fr/mailman/listinfo/cocci
