0001 // SPDX-License-Identifier: GPL-2.0-only
0002 ///
0003 /// Find if/else condition with kmalloc/vmalloc calls.
0004 /// Suggest to use kvmalloc instead. Same for kvfree.
0005 ///
0006 // Confidence: High
0007 // Copyright: (C) 2020 Denis Efremov ISPRAS
0008 // Options: --no-includes --include-headers
0009 //
0010
0011 virtual patch
0012 virtual report
0013 virtual org
0014 virtual context
0015
0016 @initialize:python@
0017 @@
0018 filter = frozenset(['kvfree'])
0019
0020 def relevant(p):
0021 return not (filter & {el.current_element for el in p})
0022
0023 @kvmalloc depends on !patch@
0024 expression E, E1, size;
0025 identifier flags;
0026 binary operator cmp = {<=, <, ==, >, >=};
0027 identifier x;
0028 type T;
0029 position p;
0030 @@
0031
0032 (
0033 * if (size cmp E1 || ...)@p {
0034 ...
0035 * E = \(kmalloc\|kzalloc\|kcalloc\|kmalloc_node\|kzalloc_node\|
0036 * kmalloc_array\|kmalloc_array_node\|kcalloc_node\)
0037 * (..., size, \(flags\|GFP_KERNEL\|\(GFP_KERNEL\|flags\)|__GFP_NOWARN\), ...)
0038 ...
0039 } else {
0040 ...
0041 * E = \(vmalloc\|vzalloc\|vmalloc_node\|vzalloc_node\)(..., size, ...)
0042 ...
0043 }
0044 |
0045 * E = \(kmalloc\|kzalloc\|kcalloc\|kmalloc_node\|kzalloc_node\|
0046 * kmalloc_array\|kmalloc_array_node\|kcalloc_node\)
0047 * (..., size, \(flags\|GFP_KERNEL\|\(GFP_KERNEL\|flags\)|__GFP_NOWARN\), ...)
0048 ... when != E = E1
0049 when != size = E1
0050 when any
0051 * if (E == NULL)@p {
0052 ...
0053 * E = \(vmalloc\|vzalloc\|vmalloc_node\|vzalloc_node\)(..., size, ...)
0054 ...
0055 }
0056 |
0057 * T x = \(kmalloc\|kzalloc\|kcalloc\|kmalloc_node\|kzalloc_node\|
0058 * kmalloc_array\|kmalloc_array_node\|kcalloc_node\)
0059 * (..., size, \(flags\|GFP_KERNEL\|\(GFP_KERNEL\|flags\)|__GFP_NOWARN\), ...);
0060 ... when != x = E1
0061 when != size = E1
0062 when any
0063 * if (x == NULL)@p {
0064 ...
0065 * x = \(vmalloc\|vzalloc\|vmalloc_node\|vzalloc_node\)(..., size, ...)
0066 ...
0067 }
0068 )
0069
0070 @kvfree depends on !patch@
0071 expression E;
0072 position p : script:python() { relevant(p) };
0073 @@
0074
0075 * if (is_vmalloc_addr(E))@p {
0076 ...
0077 * vfree(E)
0078 ...
0079 } else {
0080 ... when != krealloc(E, ...)
0081 when any
0082 * \(kfree\|kfree_sensitive\)(E)
0083 ...
0084 }
0085
0086 @depends on patch@
0087 expression E, E1, size, node;
0088 binary operator cmp = {<=, <, ==, >, >=};
0089 identifier flags, x;
0090 type T;
0091 @@
0092
0093 (
0094 - if (size cmp E1)
0095 - E = kmalloc(size, flags);
0096 - else
0097 - E = vmalloc(size);
0098 + E = kvmalloc(size, flags);
0099 |
0100 - if (size cmp E1)
0101 - E = kmalloc(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\));
0102 - else
0103 - E = vmalloc(size);
0104 + E = kvmalloc(size, GFP_KERNEL);
0105 |
0106 - E = kmalloc(size, flags | __GFP_NOWARN);
0107 - if (E == NULL)
0108 - E = vmalloc(size);
0109 + E = kvmalloc(size, flags);
0110 |
0111 - E = kmalloc(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\));
0112 - if (E == NULL)
0113 - E = vmalloc(size);
0114 + E = kvmalloc(size, GFP_KERNEL);
0115 |
0116 - T x = kmalloc(size, flags | __GFP_NOWARN);
0117 - if (x == NULL)
0118 - x = vmalloc(size);
0119 + T x = kvmalloc(size, flags);
0120 |
0121 - T x = kmalloc(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\));
0122 - if (x == NULL)
0123 - x = vmalloc(size);
0124 + T x = kvmalloc(size, GFP_KERNEL);
0125 |
0126 - if (size cmp E1)
0127 - E = kzalloc(size, flags);
0128 - else
0129 - E = vzalloc(size);
0130 + E = kvzalloc(size, flags);
0131 |
0132 - if (size cmp E1)
0133 - E = kzalloc(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\));
0134 - else
0135 - E = vzalloc(size);
0136 + E = kvzalloc(size, GFP_KERNEL);
0137 |
0138 - E = kzalloc(size, flags | __GFP_NOWARN);
0139 - if (E == NULL)
0140 - E = vzalloc(size);
0141 + E = kvzalloc(size, flags);
0142 |
0143 - E = kzalloc(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\));
0144 - if (E == NULL)
0145 - E = vzalloc(size);
0146 + E = kvzalloc(size, GFP_KERNEL);
0147 |
0148 - T x = kzalloc(size, flags | __GFP_NOWARN);
0149 - if (x == NULL)
0150 - x = vzalloc(size);
0151 + T x = kvzalloc(size, flags);
0152 |
0153 - T x = kzalloc(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\));
0154 - if (x == NULL)
0155 - x = vzalloc(size);
0156 + T x = kvzalloc(size, GFP_KERNEL);
0157 |
0158 - if (size cmp E1)
0159 - E = kmalloc_node(size, flags, node);
0160 - else
0161 - E = vmalloc_node(size, node);
0162 + E = kvmalloc_node(size, flags, node);
0163 |
0164 - if (size cmp E1)
0165 - E = kmalloc_node(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\), node);
0166 - else
0167 - E = vmalloc_node(size, node);
0168 + E = kvmalloc_node(size, GFP_KERNEL, node);
0169 |
0170 - E = kmalloc_node(size, flags | __GFP_NOWARN, node);
0171 - if (E == NULL)
0172 - E = vmalloc_node(size, node);
0173 + E = kvmalloc_node(size, flags, node);
0174 |
0175 - E = kmalloc_node(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\), node);
0176 - if (E == NULL)
0177 - E = vmalloc_node(size, node);
0178 + E = kvmalloc_node(size, GFP_KERNEL, node);
0179 |
0180 - T x = kmalloc_node(size, flags | __GFP_NOWARN, node);
0181 - if (x == NULL)
0182 - x = vmalloc_node(size, node);
0183 + T x = kvmalloc_node(size, flags, node);
0184 |
0185 - T x = kmalloc_node(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\), node);
0186 - if (x == NULL)
0187 - x = vmalloc_node(size, node);
0188 + T x = kvmalloc_node(size, GFP_KERNEL, node);
0189 |
0190 - if (size cmp E1)
0191 - E = kvzalloc_node(size, flags, node);
0192 - else
0193 - E = vzalloc_node(size, node);
0194 + E = kvzalloc_node(size, flags, node);
0195 |
0196 - if (size cmp E1)
0197 - E = kvzalloc_node(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\), node);
0198 - else
0199 - E = vzalloc_node(size, node);
0200 + E = kvzalloc_node(size, GFP_KERNEL, node);
0201 |
0202 - E = kvzalloc_node(size, flags | __GFP_NOWARN, node);
0203 - if (E == NULL)
0204 - E = vzalloc_node(size, node);
0205 + E = kvzalloc_node(size, flags, node);
0206 |
0207 - E = kvzalloc_node(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\), node);
0208 - if (E == NULL)
0209 - E = vzalloc_node(size, node);
0210 + E = kvzalloc_node(size, GFP_KERNEL, node);
0211 |
0212 - T x = kvzalloc_node(size, flags | __GFP_NOWARN, node);
0213 - if (x == NULL)
0214 - x = vzalloc_node(size, node);
0215 + T x = kvzalloc_node(size, flags, node);
0216 |
0217 - T x = kvzalloc_node(size, \(GFP_KERNEL\|GFP_KERNEL|__GFP_NOWARN\), node);
0218 - if (x == NULL)
0219 - x = vzalloc_node(size, node);
0220 + T x = kvzalloc_node(size, GFP_KERNEL, node);
0221 )
0222
0223 @depends on patch@
0224 expression E;
0225 position p : script:python() { relevant(p) };
0226 @@
0227
0228 - if (is_vmalloc_addr(E))@p
0229 - vfree(E);
0230 - else
0231 - kfree(E);
0232 + kvfree(E);
0233
0234 @script: python depends on report@
0235 p << kvmalloc.p;
0236 @@
0237
0238 coccilib.report.print_report(p[0], "WARNING opportunity for kvmalloc")
0239
0240 @script: python depends on org@
0241 p << kvmalloc.p;
0242 @@
0243
0244 coccilib.org.print_todo(p[0], "WARNING opportunity for kvmalloc")
0245
0246 @script: python depends on report@
0247 p << kvfree.p;
0248 @@
0249
0250 coccilib.report.print_report(p[0], "WARNING opportunity for kvfree")
0251
0252 @script: python depends on org@
0253 p << kvfree.p;
0254 @@
0255
0256 coccilib.org.print_todo(p[0], "WARNING opportunity for kvfree")
