date:20171226

Re: [Cocci] [PATCH v2] Coccinelle: kzalloc-simple: Add all zero allocating functions

2017-12-26 Thread Julia Lawall



On Wed, 27 Dec 2017, Himanshu Jha wrote:

> There are many instances where memory is allocated using regular
> allocator
> functions immediately followed by setting the allocated memory
> to 0 value using memset.
>
> We already have zero memory allocator functions to set the memory to
> 0 value instead of manually setting it using memset.
>
> Therefore, use zero memory allocating functions instead of regular
> memory allocators followed by memset 0 to remove redundant memset and
> make the code more cleaner and also reduce the code size.
>
> Signed-off-by: Himanshu Jha 

Acked-by: Julia Lawall 

> ---
>
> v2:
>-fix typo in copyright.
>-move all the (T *) disjunction cases before (T) as (T) matches any cast
> at all including (T *) ones which is not desirable.
>
>  scripts/coccinelle/api/alloc/kzalloc-simple.cocci | 373 
> +-
>  1 file changed, 368 insertions(+), 5 deletions(-)
>
> diff --git a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci 
> b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
> index 52c55e4..d08d526 100644
> --- a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
> +++ b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
> @@ -1,5 +1,5 @@
>  ///
> -/// Use kzalloc rather than kmalloc followed by memset with 0
> +/// Use zeroing allocator rather than allocator followed by memset with 0
>  ///
>  /// This considers some simple cases that are common and easy to validate
>  /// Note in particular that there are no ...s in the rule, so all of the
> @@ -8,6 +8,7 @@
>  // Confidence: High
>  // Copyright: (C) 2009-2010 Julia Lawall, Nicolas Palix, DIKU.  GPLv2.
>  // Copyright: (C) 2009-2010 Gilles Muller, INRIA/LiP6.  GPLv2.
> +// Copyright: (C) 2017 Himanshu Jha GPLv2.
>  // URL: http://coccinelle.lip6.fr/rules/kzalloc.html
>  // Options: --no-includes --include-headers
>  //
> @@ -28,11 +29,14 @@ virtual report
>  @depends on context@
>  type T, T2;
>  expression x;
> -expression E1,E2;
> +expression E1;
>  statement S;
>  @@
>
> -* x = (T)kmalloc(E1,E2);
> +* x = (T)\(kmalloc(E1, ...)\|vmalloc(E1)\|dma_alloc_coherent(...,E1,...)\|
> +  kmalloc_node(E1, ...)\|kmem_cache_alloc(...)\|kmem_alloc(E1, ...)\|
> +  devm_kmalloc(...,E1,...)\|kvmalloc(E1, 
> ...)\|pci_alloc_consistent(...,E1,...)\|
> +  kvmalloc_node(E1,...)\);
>if ((x==NULL) || ...) S
>  * memset((T2)x,0,E1);
>
> @@ -43,12 +47,101 @@ statement S;
>  @depends on patch@
>  type T, T2;
>  expression x;
> -expression E1,E2;
> +expression E1,E2,E3,E4;
>  statement S;
>  @@
>
> -- x = (T)kmalloc(E1,E2);
> +(
> +- x = kmalloc(E1,E2);
> ++ x = kzalloc(E1,E2);
> +|
> +- x = (T *)kmalloc(E1,E2);
>  + x = kzalloc(E1,E2);
> +|
> +- x = (T)kmalloc(E1,E2);
> ++ x = (T)kzalloc(E1,E2);
> +|
> +- x = vmalloc(E1);
> ++ x = vzalloc(E1);
> +|
> +- x = (T *)vmalloc(E1);
> ++ x = vzalloc(E1);
> +|
> +- x = (T)vmalloc(E1);
> ++ x = (T)vzalloc(E1);
> +|
> +- x = dma_alloc_coherent(E2,E1,E3,E4);
> ++ x = dma_zalloc_coherent(E2,E1,E3,E4);
> +|
> +- x = (T *)dma_alloc_coherent(E2,E1,E3,E4);
> ++ x = dma_zalloc_coherent(E2,E1,E3,E4);
> +|
> +- x = (T)dma_alloc_coherent(E2,E1,E3,E4);
> ++ x = (T)dma_zalloc_coherent(E2,E1,E3,E4);
> +|
> +- x = kmalloc_node(E1,E2,E3);
> ++ x = kzalloc_node(E1,E2,E3);
> +|
> +- x = (T *)kmalloc_node(E1,E2,E3);
> ++ x = kzalloc_node(E1,E2,E3);
> +|
> +- x = (T)kmalloc_node(E1,E2,E3);
> ++ x = (T)kzalloc_node(E1,E2,E3);
> +|
> +- x = kmem_cache_alloc(E3,E4);
> ++ x = kmem_cache_zalloc(E3,E4);
> +|
> +- x = (T *)kmem_cache_alloc(E3,E4);
> ++ x = kmem_cache_zalloc(E3,E4);
> +|
> +- x = (T)kmem_cache_alloc(E3,E4);
> ++ x = (T)kmem_cache_zalloc(E3,E4);
> +|
> +- x = kmem_alloc(E1,E2);
> ++ x = kmem_zalloc(E1,E2);
> +|
> +- x = (T *)kmem_alloc(E1,E2);
> ++ x = kmem_zalloc(E1,E2);
> +|
> +- x = (T)kmem_alloc(E1,E2);
> ++ x = (T)kmem_zalloc(E1,E2);
> +|
> +- x = devm_kmalloc(E2,E1,E3);
> ++ x = devm_kzalloc(E2,E1,E3);
> +|
> +- x = (T *)devm_kmalloc(E2,E1,E3);
> ++ x = devm_kzalloc(E2,E1,E3);
> +|
> +- x = (T)devm_kmalloc(E2,E1,E3);
> ++ x = (T)devm_kzalloc(E2,E1,E3);
> +|
> +- x = kvmalloc(E1,E2);
> ++ x = kvzalloc(E1,E2);
> +|
> +- x = (T *)kvmalloc(E1,E2);
> ++ x = kvzalloc(E1,E2);
> +|
> +- x = (T)kvmalloc(E1,E2);
> ++ x = (T)kvzalloc(E1,E2);
> +|
> +- x = pci_alloc_consistent(E2,E1,E3);
> ++ x = pci_zalloc_consistent(E2,E1,E3);
> +|
> +- x = (T *)pci_alloc_consistent(E2,E1,E3);
> ++ x = pci_zalloc_consistent(E2,E1,E3);
> +|
> +- x = (T)pci_alloc_consistent(E2,E1,E3);
> ++ x = (T)pci_zalloc_consistent(E2,E1,E3);
> +|
> +- x = kvmalloc_node(E1,E2,E3);
> ++ x = kvzalloc_node(E1,E2,E3);
> +|
> +- x = (T *)kvmalloc_node(E1,E2,E3);
> ++ x = kvzalloc_node(E1,E2,E3);
> +|
> +- x = (T)kvmalloc_node(E1,E2,E3);
> ++ x = (T)kvzalloc_node(E1,E2,E3);
> +)
>if ((x==NULL) || ...) S
>  - memset((T2)x,0,E1);
>
> @@ -84,3 +177,273 @@ x << r.x;
>
>  msg="WARNING: kzalloc should be used for %s, instead of kmalloc/memset" % (x)
>

[Cocci] [PATCH v2] Coccinelle: kzalloc-simple: Add all zero allocating functions

2017-12-26 Thread Himanshu Jha

There are many instances where memory is allocated using regular
allocator
functions immediately followed by setting the allocated memory
to 0 value using memset.

We already have zero memory allocator functions to set the memory to
0 value instead of manually setting it using memset.

Therefore, use zero memory allocating functions instead of regular
memory allocators followed by memset 0 to remove redundant memset and
make the code more cleaner and also reduce the code size.

Signed-off-by: Himanshu Jha 
---

v2:
   -fix typo in copyright.
   -move all the (T *) disjunction cases before (T) as (T) matches any cast
at all including (T *) ones which is not desirable.

 scripts/coccinelle/api/alloc/kzalloc-simple.cocci | 373 +-
 1 file changed, 368 insertions(+), 5 deletions(-)

diff --git a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci 
b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
index 52c55e4..d08d526 100644
--- a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
+++ b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
@@ -1,5 +1,5 @@
 ///
-/// Use kzalloc rather than kmalloc followed by memset with 0
+/// Use zeroing allocator rather than allocator followed by memset with 0
 ///
 /// This considers some simple cases that are common and easy to validate
 /// Note in particular that there are no ...s in the rule, so all of the
@@ -8,6 +8,7 @@
 // Confidence: High
 // Copyright: (C) 2009-2010 Julia Lawall, Nicolas Palix, DIKU.  GPLv2.
 // Copyright: (C) 2009-2010 Gilles Muller, INRIA/LiP6.  GPLv2.
+// Copyright: (C) 2017 Himanshu Jha GPLv2.
 // URL: http://coccinelle.lip6.fr/rules/kzalloc.html
 // Options: --no-includes --include-headers
 //
@@ -28,11 +29,14 @@ virtual report
 @depends on context@
 type T, T2;
 expression x;
-expression E1,E2;
+expression E1;
 statement S;
 @@
 
-* x = (T)kmalloc(E1,E2);
+* x = (T)\(kmalloc(E1, ...)\|vmalloc(E1)\|dma_alloc_coherent(...,E1,...)\|
+  kmalloc_node(E1, ...)\|kmem_cache_alloc(...)\|kmem_alloc(E1, ...)\|
+  devm_kmalloc(...,E1,...)\|kvmalloc(E1, 
...)\|pci_alloc_consistent(...,E1,...)\|
+  kvmalloc_node(E1,...)\);
   if ((x==NULL) || ...) S
 * memset((T2)x,0,E1);
 
@@ -43,12 +47,101 @@ statement S;
 @depends on patch@
 type T, T2;
 expression x;
-expression E1,E2;
+expression E1,E2,E3,E4;
 statement S;
 @@
 
-- x = (T)kmalloc(E1,E2);
+(
+- x = kmalloc(E1,E2);
++ x = kzalloc(E1,E2);
+|
+- x = (T *)kmalloc(E1,E2);
 + x = kzalloc(E1,E2);
+|
+- x = (T)kmalloc(E1,E2);
++ x = (T)kzalloc(E1,E2);
+|
+- x = vmalloc(E1);
++ x = vzalloc(E1);
+|
+- x = (T *)vmalloc(E1);
++ x = vzalloc(E1);
+|
+- x = (T)vmalloc(E1);
++ x = (T)vzalloc(E1);
+|
+- x = dma_alloc_coherent(E2,E1,E3,E4);
++ x = dma_zalloc_coherent(E2,E1,E3,E4);
+|
+- x = (T *)dma_alloc_coherent(E2,E1,E3,E4);
++ x = dma_zalloc_coherent(E2,E1,E3,E4);
+|
+- x = (T)dma_alloc_coherent(E2,E1,E3,E4);
++ x = (T)dma_zalloc_coherent(E2,E1,E3,E4);
+|
+- x = kmalloc_node(E1,E2,E3);
++ x = kzalloc_node(E1,E2,E3);
+|
+- x = (T *)kmalloc_node(E1,E2,E3);
++ x = kzalloc_node(E1,E2,E3);
+|
+- x = (T)kmalloc_node(E1,E2,E3);
++ x = (T)kzalloc_node(E1,E2,E3);
+|
+- x = kmem_cache_alloc(E3,E4);
++ x = kmem_cache_zalloc(E3,E4);
+|
+- x = (T *)kmem_cache_alloc(E3,E4);
++ x = kmem_cache_zalloc(E3,E4);
+|
+- x = (T)kmem_cache_alloc(E3,E4);
++ x = (T)kmem_cache_zalloc(E3,E4);
+|
+- x = kmem_alloc(E1,E2);
++ x = kmem_zalloc(E1,E2);
+|
+- x = (T *)kmem_alloc(E1,E2);
++ x = kmem_zalloc(E1,E2);
+|
+- x = (T)kmem_alloc(E1,E2);
++ x = (T)kmem_zalloc(E1,E2);
+|
+- x = devm_kmalloc(E2,E1,E3);
++ x = devm_kzalloc(E2,E1,E3);
+|
+- x = (T *)devm_kmalloc(E2,E1,E3);
++ x = devm_kzalloc(E2,E1,E3);
+|
+- x = (T)devm_kmalloc(E2,E1,E3);
++ x = (T)devm_kzalloc(E2,E1,E3);
+|
+- x = kvmalloc(E1,E2);
++ x = kvzalloc(E1,E2);
+|
+- x = (T *)kvmalloc(E1,E2);
++ x = kvzalloc(E1,E2);
+|
+- x = (T)kvmalloc(E1,E2);
++ x = (T)kvzalloc(E1,E2);
+|
+- x = pci_alloc_consistent(E2,E1,E3);
++ x = pci_zalloc_consistent(E2,E1,E3);
+|
+- x = (T *)pci_alloc_consistent(E2,E1,E3);
++ x = pci_zalloc_consistent(E2,E1,E3);
+|
+- x = (T)pci_alloc_consistent(E2,E1,E3);
++ x = (T)pci_zalloc_consistent(E2,E1,E3);
+|
+- x = kvmalloc_node(E1,E2,E3);
++ x = kvzalloc_node(E1,E2,E3);
+|
+- x = (T *)kvmalloc_node(E1,E2,E3);
++ x = kvzalloc_node(E1,E2,E3);
+|
+- x = (T)kvmalloc_node(E1,E2,E3);
++ x = (T)kvzalloc_node(E1,E2,E3);
+)
   if ((x==NULL) || ...) S
 - memset((T2)x,0,E1);
 
@@ -84,3 +177,273 @@ x << r.x;
 
 msg="WARNING: kzalloc should be used for %s, instead of kmalloc/memset" % (x)
 coccilib.report.print_report(p[0], msg)
+
+//-
+@r1 depends on org || report@
+type T, T2;
+expression x;
+expression E1;
+statement S;
+position p;
+@@
+
+ x = (T)vmalloc@p(E1);
+ if ((x==NULL) || ...) S
+ memset((T2)x,0,E1);
+
+@script:python depends on org@
+p << r1.p;
+x << r1.x;
+@@
+
+msg="%s" % (x)
+msg_safe=msg.replace("[","@(").replace("]",")")

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add all zero allocating functions

2017-12-26 Thread Himanshu Jha

On Tue, Dec 26, 2017 at 06:14:07PM -0200, Fabio Estevam wrote:
> On Tue, Dec 26, 2017 at 5:49 PM, Himanshu Jha
>  wrote:
> 
> > diff --git a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci 
> > b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
> > index 52c55e4..f94888d 100644
> > --- a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
> > +++ b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
> > @@ -1,5 +1,5 @@
> >  ///
> > -/// Use kzalloc rather than kmalloc followed by memset with 0
> > +/// Use zeroing allocator rather than allocator followed by memset with 0
> >  ///
> >  /// This considers some simple cases that are common and easy to validate
> >  /// Note in particular that there are no ...s in the rule, so all of the
> > @@ -8,6 +8,7 @@
> >  // Confidence: High
> >  // Copyright: (C) 2009-2010 Julia Lawall, Nicolas Palix, DIKU.  GPLv2.
> >  // Copyright: (C) 2009-2010 Gilles Muller, INRIA/LiP6.  GPLv2.
> > +// Cpoyright: (C) 2017 Himanshu Jha GPLv2.
> 
> Typo here in "Copyright"

Oops! 
Thank you so much!

I will send v2 patch with other necessary changes that Julia pointed me
out in the SmPL rule.

Himanshu Jha
___
Cocci mailing list
Cocci@systeme.lip6.fr
https://systeme.lip6.fr/mailman/listinfo/cocci

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add all zero allocating functions

2017-12-26 Thread Fabio Estevam

On Tue, Dec 26, 2017 at 5:49 PM, Himanshu Jha
 wrote:

> diff --git a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci 
> b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
> index 52c55e4..f94888d 100644
> --- a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
> +++ b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
> @@ -1,5 +1,5 @@
>  ///
> -/// Use kzalloc rather than kmalloc followed by memset with 0
> +/// Use zeroing allocator rather than allocator followed by memset with 0
>  ///
>  /// This considers some simple cases that are common and easy to validate
>  /// Note in particular that there are no ...s in the rule, so all of the
> @@ -8,6 +8,7 @@
>  // Confidence: High
>  // Copyright: (C) 2009-2010 Julia Lawall, Nicolas Palix, DIKU.  GPLv2.
>  // Copyright: (C) 2009-2010 Gilles Muller, INRIA/LiP6.  GPLv2.
> +// Cpoyright: (C) 2017 Himanshu Jha GPLv2.

Typo here in "Copyright"
___
Cocci mailing list
Cocci@systeme.lip6.fr
https://systeme.lip6.fr/mailman/listinfo/cocci

[Cocci] [PATCH] Coccinelle: kzalloc-simple: Add all zero allocating functions

2017-12-26 Thread Himanshu Jha

There are many instances where memory is allocated using regular allocator
functions immediately followed by setting the allocated memory
to 0 value using memset.

We already have zero memory allocator functions to set the memory to
0 value instead of manually setting it using memset.

Therefore, use zero memory allocating functions instead of regular
memory allocators followed by memset 0 to remove redundant memset and
make the code more cleaner and also reduce the code size.

Signed-off-by: Himanshu Jha 
---
 scripts/coccinelle/api/alloc/kzalloc-simple.cocci | 371 +-
 1 file changed, 367 insertions(+), 4 deletions(-)

diff --git a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci 
b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
index 52c55e4..f94888d 100644
--- a/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
+++ b/scripts/coccinelle/api/alloc/kzalloc-simple.cocci
@@ -1,5 +1,5 @@
 ///
-/// Use kzalloc rather than kmalloc followed by memset with 0
+/// Use zeroing allocator rather than allocator followed by memset with 0
 ///
 /// This considers some simple cases that are common and easy to validate
 /// Note in particular that there are no ...s in the rule, so all of the
@@ -8,6 +8,7 @@
 // Confidence: High
 // Copyright: (C) 2009-2010 Julia Lawall, Nicolas Palix, DIKU.  GPLv2.
 // Copyright: (C) 2009-2010 Gilles Muller, INRIA/LiP6.  GPLv2.
+// Cpoyright: (C) 2017 Himanshu Jha GPLv2.
 // URL: http://coccinelle.lip6.fr/rules/kzalloc.html
 // Options: --no-includes --include-headers
 //
@@ -28,11 +29,14 @@ virtual report
 @depends on context@
 type T, T2;
 expression x;
-expression E1,E2;
+expression E1;
 statement S;
 @@
 
-* x = (T)kmalloc(E1,E2);
+* x = (T)\(kmalloc(E1, ...)\|vmalloc(E1)\|dma_alloc_coherent(...,E1,...)\|
+  kmalloc_node(E1, ...)\|kmem_cache_alloc(...)\|kmem_alloc(E1, ...)\|
+  devm_kmalloc(...,E1,...)\|kvmalloc(E1, 
...)\|pci_alloc_consistent(...,E1,...)\|
+  kvmalloc_node(E1,...)\);
   if ((x==NULL) || ...) S
 * memset((T2)x,0,E1);
 
@@ -43,12 +47,101 @@ statement S;
 @depends on patch@
 type T, T2;
 expression x;
-expression E1,E2;
+expression E1,E2,E3,E4;
 statement S;
 @@
 
+(
+- x = kmalloc(E1,E2);
++ x = kzalloc(E1,E2);
+|
 - x = (T)kmalloc(E1,E2);
++ x = (T)kzalloc(E1,E2);
+|
+- x = (T *)kmalloc(E1,E2);
 + x = kzalloc(E1,E2);
+|
+- x = vmalloc(E1);
++ x = vzalloc(E1);
+|
+- x = (T)vmalloc(E1);
++ x = (T)vzalloc(E1);
+|
+- x = (T *)vmalloc(E1);
++ x = vzalloc(E1);
+|
+- x = dma_alloc_coherent(E2,E1,E3,E4);
++ x = dma_zalloc_coherent(E2,E1,E3,E4);
+|
+- x = (T)dma_alloc_coherent(E2,E1,E3,E4);
++ x = (T)dma_zalloc_coherent(E2,E1,E3,E4);
+|
+- x = (T *)dma_alloc_coherent(E2,E1,E3,E4);
++ x = dma_zalloc_coherent(E2,E1,E3,E4);
+|
+- x = kmalloc_node(E1,E2,E3);
++ x = kzalloc_node(E1,E2,E3);
+|
+- x = (T)kmalloc_node(E1,E2,E3);
++ x = (T)kzalloc_node(E1,E2,E3);
+|
+- x = (T *)kmalloc_node(E1,E2,E3);
++ x = kzalloc_node(E1,E2,E3);
+|
+- x = kmem_cache_alloc(E3,E4);
++ x = kmem_cache_zalloc(E3,E4);
+|
+- x = (T)kmem_cache_alloc(E3,E4);
++ x = (T)kmem_cache_zalloc(E3,E4);
+|
+- x = (T *)kmem_cache_alloc(E3,E4);
++ x = kmem_cache_zalloc(E3,E4);
+|
+- x = kmem_alloc(E1,E2);
++ x = kmem_zalloc(E1,E2);
+|
+- x = (T)kmem_alloc(E1,E2);
++ x = (T)kmem_zalloc(E1,E2);
+|
+- x = (T *)kmem_alloc(E1,E2);
++ x = kmem_zalloc(E1,E2);
+|
+- x = devm_kmalloc(E2,E1,E3);
++ x = devm_kzalloc(E2,E1,E3);
+|
+- x = (T)devm_kmalloc(E2,E1,E3);
++ x = (T)devm_kzalloc(E2,E1,E3);
+|
+- x = (T *)devm_kmalloc(E2,E1,E3);
++ x = devm_kzalloc(E2,E1,E3);
+|
+- x = kvmalloc(E1,E2);
++ x = kvzalloc(E1,E2);
+|
+- x = (T)kvmalloc(E1,E2);
++ x = (T)kvzalloc(E1,E2);
+|
+- x = (T *)kvmalloc(E1,E2);
++ x = kvzalloc(E1,E2);
+|
+- x = pci_alloc_consistent(E2,E1,E3);
++ x = pci_zalloc_consistent(E2,E1,E3);
+|
+- x = (T)pci_alloc_consistent(E2,E1,E3);
++ x = (T)pci_zalloc_consistent(E2,E1,E3);
+|
+- x = (T *)pci_alloc_consistent(E2,E1,E3);
++ x = pci_zalloc_consistent(E2,E1,E3);
+|
+- x = kvmalloc_node(E1,E2,E3);
++ x = kvzalloc_node(E1,E2,E3);
+|
+- x = (T)kvmalloc_node(E1,E2,E3);
++ x = (T)kvzalloc_node(E1,E2,E3);
+|
+- x = (T *)kvmalloc_node(E1,E2,E3);
++ x = kvzalloc_node(E1,E2,E3);
+)
   if ((x==NULL) || ...) S
 - memset((T2)x,0,E1);
 
@@ -84,3 +177,273 @@ x << r.x;
 
 msg="WARNING: kzalloc should be used for %s, instead of kmalloc/memset" % (x)
 coccilib.report.print_report(p[0], msg)
+
+//-
+@r1 depends on org || report@
+type T, T2;
+expression x;
+expression E1;
+statement S;
+position p;
+@@
+
+ x = (T)vmalloc@p(E1);
+ if ((x==NULL) || ...) S
+ memset((T2)x,0,E1);
+
+@script:python depends on org@
+p << r1.p;
+x << r1.x;
+@@
+
+msg="%s" % (x)
+msg_safe=msg.replace("[","@(").replace("]",")")
+coccilib.org.print_todo(p[0], msg_safe)
+
+@script:python depends on report@
+p << r1.p;
+x << r1.x;
+@@
+
+msg="WARNING: vzalloc should be used for %s, instead of vmalloc/memset" % (x)

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

2017-12-26 Thread Himanshu Jha

On Tue, Dec 26, 2017 at 08:35:52PM +0100, Julia Lawall wrote:
> 
> 
> On Wed, 27 Dec 2017, Himanshu Jha wrote:
> 
> > Hello Markus,
> >
> > On Tue, Dec 26, 2017 at 06:39:07PM +0100, SF Markus Elfring wrote:
> > > > We already have zero memory allocator functions to set the memory to
> > > > 0 value instead of manually setting it using memset.
> > >
> > > Thanks for your extension of this script for the semantic patch
> > > language.
> > >
> > > Will this update suggestion get any better chances than the approach
> > > “Script to replace allocate and memset with zalloc functions”?
> > > https://systeme.lip6.fr/pipermail/cocci/2016-August/003510.html
> >
> > Yes! You can check it yourself. And I didn't knew someone previously
> > worked on this. I was assigned the task of scrapping vmalloc/meset with
> > vzalloc by Luis R. Rodriguez but when I made a new rule and sent it
> > usptream, Julia told me find all instances and group into one.
> > https://lkml.org/lkml/2017/11/4/171
> >
> > >
> > > > +/// Use zeroing allocator rather than allocator followed by memset
> > > > with 0
> > >
> > > Do you find the shown function name list complete now?
> >
> > Perhaps yes! If you find anything new then please send to patch out when
> > it gets merged.
> > You are most welcome!
> > > Did you omit a name like “kvm_kvzalloc” intentionally?
> >
> > Hmm...I don't anything in my linux-next latest
> >
> > himanshu@himanshu-Vostro-3559:~/linux-next$ git grep -w "kvm_kvzalloc"
> > himanshu@himanshu-Vostro-3559:~/linux-next$
> >
> > > How do you think about the possibility to analyse relevant source
> > > files for
> > > functions with the mentioned property?
> >
> > Three rules for one functions :
> >
> > (
> > - x = kmalloc(E1,E2);
> > + x = kzalloc(E1,E2);
> >
> > It is most basic case.
> >
> > |
> > - x = (T)kmalloc(E1,E2);
> > + x = (T)kzalloc(E1,E2);
> >
> > This for useless pointer cast which is done implicitily.
> 
> Actually, the above rule is for the case where the cast is useful.  The (T
> *) rule should be above this one, because that is for the case where the
> cast is not needed.  I don't remember if this is done correctly.  Please
> check.

Oops! Yes, I somehow hurriedly made the typo.

I already verified this! This case handles for eg:

drivers/scsi/fnic/fnic_trace.c +471

fnic_trace_buf_p = (unsigned long)vmalloc((trace_max_pages *
PAGE_SIZE));

Here, the cast it is necessary and we can't omit this cast.

> > Also, Julia who is going to get it merged ? Please get it merged soon,
> > and after that I will start sending out the patches!
> 
> Masahiro Yamada merges the patches.  Please check also that he was in CC
> in your submission.

No, he is not! 
get_maintainer didn't mention his name!
Fine I am sending that again cc'ing him!

Thanks
Himanshu Jha
___
Cocci mailing list
Cocci@systeme.lip6.fr
https://systeme.lip6.fr/mailman/listinfo/cocci

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

2017-12-26 Thread Julia Lawall



On Wed, 27 Dec 2017, Himanshu Jha wrote:

> Hello Markus,
>
> On Tue, Dec 26, 2017 at 06:39:07PM +0100, SF Markus Elfring wrote:
> > > We already have zero memory allocator functions to set the memory to
> > > 0 value instead of manually setting it using memset.
> >
> > Thanks for your extension of this script for the semantic patch
> > language.
> >
> > Will this update suggestion get any better chances than the approach
> > “Script to replace allocate and memset with zalloc functions”?
> > https://systeme.lip6.fr/pipermail/cocci/2016-August/003510.html
>
> Yes! You can check it yourself. And I didn't knew someone previously
> worked on this. I was assigned the task of scrapping vmalloc/meset with
> vzalloc by Luis R. Rodriguez but when I made a new rule and sent it
> usptream, Julia told me find all instances and group into one.
> https://lkml.org/lkml/2017/11/4/171
>
> >
> > > +/// Use zeroing allocator rather than allocator followed by memset
> > > with 0
> >
> > Do you find the shown function name list complete now?
>
> Perhaps yes! If you find anything new then please send to patch out when
> it gets merged.
> You are most welcome!
> > Did you omit a name like “kvm_kvzalloc” intentionally?
>
> Hmm...I don't anything in my linux-next latest
>
> himanshu@himanshu-Vostro-3559:~/linux-next$ git grep -w "kvm_kvzalloc"
> himanshu@himanshu-Vostro-3559:~/linux-next$
>
> > How do you think about the possibility to analyse relevant source
> > files for
> > functions with the mentioned property?
>
> Three rules for one functions :
>
> (
> - x = kmalloc(E1,E2);
> + x = kzalloc(E1,E2);
>
> It is most basic case.
>
> |
> - x = (T)kmalloc(E1,E2);
> + x = (T)kzalloc(E1,E2);
>
> This for useless pointer cast which is done implicitily.

Actually, the above rule is for the case where the cast is useful.  The (T
*) rule should be above this one, because that is for the case where the
cast is not needed.  I don't remember if this is done correctly.  Please
check.

> Also, Julia who is going to get it merged ? Please get it merged soon,
> and after that I will start sending out the patches!

Masahiro Yamada merges the patches.  Please check also that he was in CC
in your submission.

julia___
Cocci mailing list
Cocci@systeme.lip6.fr
https://systeme.lip6.fr/mailman/listinfo/cocci

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

2017-12-26 Thread Himanshu Jha

Hello Markus,

On Tue, Dec 26, 2017 at 06:39:07PM +0100, SF Markus Elfring wrote:
> > We already have zero memory allocator functions to set the memory to
> > 0 value instead of manually setting it using memset.
>
> Thanks for your extension of this script for the semantic patch
> language.
>
> Will this update suggestion get any better chances than the approach
> “Script to replace allocate and memset with zalloc functions”?
> https://systeme.lip6.fr/pipermail/cocci/2016-August/003510.html

Yes! You can check it yourself. And I didn't knew someone previously
worked on this. I was assigned the task of scrapping vmalloc/meset with
vzalloc by Luis R. Rodriguez but when I made a new rule and sent it
usptream, Julia told me find all instances and group into one.
https://lkml.org/lkml/2017/11/4/171

> 
> > +/// Use zeroing allocator rather than allocator followed by memset
> > with 0
> 
> Do you find the shown function name list complete now?

Perhaps yes! If you find anything new then please send to patch out when
it gets merged.
You are most welcome!
> Did you omit a name like “kvm_kvzalloc” intentionally?

Hmm...I don't anything in my linux-next latest

himanshu@himanshu-Vostro-3559:~/linux-next$ git grep -w "kvm_kvzalloc"
himanshu@himanshu-Vostro-3559:~/linux-next$

> How do you think about the possibility to analyse relevant source
> files for 
> functions with the mentioned property?

Three rules for one functions :

(
- x = kmalloc(E1,E2);
+ x = kzalloc(E1,E2);

It is most basic case.

|
- x = (T)kmalloc(E1,E2);
+ x = (T)kzalloc(E1,E2);

This for useless pointer cast which is done implicitily.

> > +(
> > +- x = kmalloc(E1,E2);
> > ++ x = kzalloc(E1,E2);
> > +|
>
> You suggest to use another application for the SmPL disjunction.
> How do you think about to refactor this specification a bit like the
> following?
>
> +(
> + x =
> +-kmalloc
> ++kzalloc
> +(E1, E2);
> +|

Julia answered this better!

> > +|
> > +- x = (T *)kmalloc(E1,E2);
> > + x = kzalloc(E1,E2);
> > +|
>
> Why do you find it appropriate to omit a cast at this place while it
> is
> preserved at other places?

What we can do is your best to make a perfect rule with least number of
false positives but can we ensure it to be fully perfect. The coccinelle
tool find can do its best but we are the ones to ensure that the patch
generated is absolutely correct and if it's not, then we change and
improve the existing rule perhaps!

Thanks for the feedback! I am not an experienced developer like you and
used to send out checkpatch 2 months ago and now I work under the
mentorship of Luis. Just to let you know I am just another
*kernelnewbie* ;-)

If found any queries then you can too omit/change rule to see why I
exactly did that!

Lastly, I got it 0-day tested with no errors :-)
https://github.com/himanshujha199640/linux-next/commit/24c13fe24c21a5997cbdb099d1da9f5e8e23c100

I already shared the 0-day test report with Julia and if you wish I can
send it to you too!

Please while replying also cc this to lkml mainling list so that other
relevant people can also put their opinion.

Also, Julia who is going to get it merged ? Please get it merged soon,
and after that I will start sending out the patches!

Thanks
Himanshu Jha
___
Cocci mailing list
Cocci@systeme.lip6.fr
https://systeme.lip6.fr/mailman/listinfo/cocci

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

2017-12-26 Thread Julia Lawall



On Tue, 26 Dec 2017, SF Markus Elfring wrote:

> > We already have zero memory allocator functions to set the memory to
> > 0 value instead of manually setting it using memset.
>
> Thanks for your extension of this script for the semantic patch language.
>
> Will this update suggestion get any better chances than the approach
> “Script to replace allocate and memset with zalloc functions”?
> https://systeme.lip6.fr/pipermail/cocci/2016-August/003510.html

I don't know why the previous version was not accepted, since I acked it.
I wonder if it had anything to do with your mostly useless comments.  The
current version, however, is better because it deals with casts.

>
>
> > +/// Use zeroing allocator rather than allocator followed by memset with 0
>
> Do you find the shown function name list complete now?
>
> Did you omit a name like “kvm_kvzalloc” intentionally?

There seems to be no such function currently.

>
> How do you think about the possibility to analyse relevant source files for
> functions with the mentioned property?
>
>
> > +(
> > +- x = kmalloc(E1,E2);
> > ++ x = kzalloc(E1,E2);
> > +|
>
> You suggest to use another application for the SmPL disjunction.
> How do you think about to refactor this specification a bit like the 
> following?
>
> +(
> + x =
> +-kmalloc
> ++kzalloc
> +(E1, E2);
> +|

This would be OK here, since kzalloc has the same length as kmalloc.  But
it doesn't work well when the function name changes size and the arguments
are on multiple lines.

>
>
> > +|
> > +- x = (T *)kmalloc(E1,E2);
> > + x = kzalloc(E1,E2);
> > +|
>
> Why do you find it appropriate to omit a cast at this place while it is
> preserved at other places?

Because a void * value doesn't have to be explicitly casted to another
pointer type.

julia___
Cocci mailing list
Cocci@systeme.lip6.fr
https://systeme.lip6.fr/mailman/listinfo/cocci

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

2017-12-26 Thread SF Markus Elfring

> We already have zero memory allocator functions to set the memory to
> 0 value instead of manually setting it using memset.

Thanks for your extension of this script for the semantic patch language.

Will this update suggestion get any better chances than the approach
“Script to replace allocate and memset with zalloc functions”?
https://systeme.lip6.fr/pipermail/cocci/2016-August/003510.html


> +/// Use zeroing allocator rather than allocator followed by memset with 0

Do you find the shown function name list complete now?

Did you omit a name like “kvm_kvzalloc” intentionally?


How do you think about the possibility to analyse relevant source files for
functions with the mentioned property?


> +(
> +- x = kmalloc(E1,E2);
> ++ x = kzalloc(E1,E2);
> +|

You suggest to use another application for the SmPL disjunction.
How do you think about to refactor this specification a bit like the following?

+(
+ x = 
+-kmalloc
++kzalloc
+(E1, E2);
+|



> +|
> +- x = (T *)kmalloc(E1,E2);
> + x = kzalloc(E1,E2);
> +|

Why do you find it appropriate to omit a cast at this place while it is
preserved at other places?

Regards,
Markus
___
Cocci mailing list
Cocci@systeme.lip6.fr
https://systeme.lip6.fr/mailman/listinfo/cocci

Re: [Cocci] [PATCH v2] Coccinelle: kzalloc-simple: Add all zero allocating functions

[Cocci] [PATCH v2] Coccinelle: kzalloc-simple: Add all zero allocating functions

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add all zero allocating functions

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add all zero allocating functions

[Cocci] [PATCH] Coccinelle: kzalloc-simple: Add all zero allocating functions

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

Re: [Cocci] [PATCH] Coccinelle: kzalloc-simple: Add more zero allocating functions

10 matches

Site Navigation

Mail list logo

Footer information