1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/flex_array.h>
24#include <linux/slab.h>
25#include <linux/stddef.h>
26#include <linux/module.h>
27
28struct flex_array_part {
29 char elements[FLEX_ARRAY_PART_SIZE];
30};
31
32
33
34
35
36
37
38static inline int elements_fit_in_base(struct flex_array *fa)
39{
40 int data_size = fa->element_size * fa->total_nr_elements;
41 if (data_size <= FLEX_ARRAY_BASE_BYTES_LEFT)
42 return 1;
43 return 0;
44}
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87struct flex_array *flex_array_alloc(int element_size, unsigned int total,
88 gfp_t flags)
89{
90 struct flex_array *ret;
91 int max_size = FLEX_ARRAY_NR_BASE_PTRS *
92 FLEX_ARRAY_ELEMENTS_PER_PART(element_size);
93
94
95 if (total > max_size)
96 return NULL;
97 ret = kzalloc(sizeof(struct flex_array), flags);
98 if (!ret)
99 return NULL;
100 ret->element_size = element_size;
101 ret->total_nr_elements = total;
102 if (elements_fit_in_base(ret) && !(flags & __GFP_ZERO))
103 memset(&ret->parts[0], FLEX_ARRAY_FREE,
104 FLEX_ARRAY_BASE_BYTES_LEFT);
105 return ret;
106}
107EXPORT_SYMBOL(flex_array_alloc);
108
109static int fa_element_to_part_nr(struct flex_array *fa,
110 unsigned int element_nr)
111{
112 return element_nr / FLEX_ARRAY_ELEMENTS_PER_PART(fa->element_size);
113}
114
115
116
117
118
119
120
121
122void flex_array_free_parts(struct flex_array *fa)
123{
124 int part_nr;
125
126 if (elements_fit_in_base(fa))
127 return;
128 for (part_nr = 0; part_nr < FLEX_ARRAY_NR_BASE_PTRS; part_nr++)
129 kfree(fa->parts[part_nr]);
130}
131EXPORT_SYMBOL(flex_array_free_parts);
132
133void flex_array_free(struct flex_array *fa)
134{
135 flex_array_free_parts(fa);
136 kfree(fa);
137}
138EXPORT_SYMBOL(flex_array_free);
139
140static unsigned int index_inside_part(struct flex_array *fa,
141 unsigned int element_nr)
142{
143 unsigned int part_offset;
144
145 part_offset = element_nr %
146 FLEX_ARRAY_ELEMENTS_PER_PART(fa->element_size);
147 return part_offset * fa->element_size;
148}
149
150static struct flex_array_part *
151__fa_get_part(struct flex_array *fa, int part_nr, gfp_t flags)
152{
153 struct flex_array_part *part = fa->parts[part_nr];
154 if (!part) {
155 part = kmalloc(sizeof(struct flex_array_part), flags);
156 if (!part)
157 return NULL;
158 if (!(flags & __GFP_ZERO))
159 memset(part, FLEX_ARRAY_FREE,
160 sizeof(struct flex_array_part));
161 fa->parts[part_nr] = part;
162 }
163 return part;
164}
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183int flex_array_put(struct flex_array *fa, unsigned int element_nr, void *src,
184 gfp_t flags)
185{
186 int part_nr = fa_element_to_part_nr(fa, element_nr);
187 struct flex_array_part *part;
188 void *dst;
189
190 if (element_nr >= fa->total_nr_elements)
191 return -ENOSPC;
192 if (elements_fit_in_base(fa))
193 part = (struct flex_array_part *)&fa->parts[0];
194 else {
195 part = __fa_get_part(fa, part_nr, flags);
196 if (!part)
197 return -ENOMEM;
198 }
199 dst = &part->elements[index_inside_part(fa, element_nr)];
200 memcpy(dst, src, fa->element_size);
201 return 0;
202}
203EXPORT_SYMBOL(flex_array_put);
204
205
206
207
208
209
210
211
212int flex_array_clear(struct flex_array *fa, unsigned int element_nr)
213{
214 int part_nr = fa_element_to_part_nr(fa, element_nr);
215 struct flex_array_part *part;
216 void *dst;
217
218 if (element_nr >= fa->total_nr_elements)
219 return -ENOSPC;
220 if (elements_fit_in_base(fa))
221 part = (struct flex_array_part *)&fa->parts[0];
222 else {
223 part = fa->parts[part_nr];
224 if (!part)
225 return -EINVAL;
226 }
227 dst = &part->elements[index_inside_part(fa, element_nr)];
228 memset(dst, FLEX_ARRAY_FREE, fa->element_size);
229 return 0;
230}
231EXPORT_SYMBOL(flex_array_clear);
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247int flex_array_prealloc(struct flex_array *fa, unsigned int start,
248 unsigned int end, gfp_t flags)
249{
250 int start_part;
251 int end_part;
252 int part_nr;
253 struct flex_array_part *part;
254
255 if (start >= fa->total_nr_elements || end >= fa->total_nr_elements)
256 return -ENOSPC;
257 if (elements_fit_in_base(fa))
258 return 0;
259 start_part = fa_element_to_part_nr(fa, start);
260 end_part = fa_element_to_part_nr(fa, end);
261 for (part_nr = start_part; part_nr <= end_part; part_nr++) {
262 part = __fa_get_part(fa, part_nr, flags);
263 if (!part)
264 return -ENOMEM;
265 }
266 return 0;
267}
268EXPORT_SYMBOL(flex_array_prealloc);
269
270
271
272
273
274
275
276
277
278
279
280
281
282void *flex_array_get(struct flex_array *fa, unsigned int element_nr)
283{
284 int part_nr = fa_element_to_part_nr(fa, element_nr);
285 struct flex_array_part *part;
286
287 if (element_nr >= fa->total_nr_elements)
288 return NULL;
289 if (elements_fit_in_base(fa))
290 part = (struct flex_array_part *)&fa->parts[0];
291 else {
292 part = fa->parts[part_nr];
293 if (!part)
294 return NULL;
295 }
296 return &part->elements[index_inside_part(fa, element_nr)];
297}
298EXPORT_SYMBOL(flex_array_get);
299
300
301
302
303
304
305
306
307
308
309void *flex_array_get_ptr(struct flex_array *fa, unsigned int element_nr)
310{
311 void **tmp;
312
313 tmp = flex_array_get(fa, element_nr);
314 if (!tmp)
315 return NULL;
316
317 return *tmp;
318}
319EXPORT_SYMBOL(flex_array_get_ptr);
320
321static int part_is_free(struct flex_array_part *part)
322{
323 int i;
324
325 for (i = 0; i < sizeof(struct flex_array_part); i++)
326 if (part->elements[i] != FLEX_ARRAY_FREE)
327 return 0;
328 return 1;
329}
330
331
332
333
334
335
336
337
338
339
340int flex_array_shrink(struct flex_array *fa)
341{
342 struct flex_array_part *part;
343 int part_nr;
344 int ret = 0;
345
346 if (elements_fit_in_base(fa))
347 return ret;
348 for (part_nr = 0; part_nr < FLEX_ARRAY_NR_BASE_PTRS; part_nr++) {
349 part = fa->parts[part_nr];
350 if (!part)
351 continue;
352 if (part_is_free(part)) {
353 fa->parts[part_nr] = NULL;
354 kfree(part);
355 ret++;
356 }
357 }
358 return ret;
359}
360EXPORT_SYMBOL(flex_array_shrink);
361