1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "dm_services.h"
27#include "include/vector.h"
28
29bool dal_vector_construct(
30 struct vector *vector,
31 struct dc_context *ctx,
32 uint32_t capacity,
33 uint32_t struct_size)
34{
35 vector->container = NULL;
36
37 if (!struct_size || !capacity) {
38
39 BREAK_TO_DEBUGGER();
40 return false;
41 }
42
43 vector->container = kcalloc(capacity, struct_size, GFP_KERNEL);
44 if (vector->container == NULL)
45 return false;
46 vector->capacity = capacity;
47 vector->struct_size = struct_size;
48 vector->count = 0;
49 vector->ctx = ctx;
50 return true;
51}
52
53bool dal_vector_presized_costruct(
54 struct vector *vector,
55 struct dc_context *ctx,
56 uint32_t count,
57 void *initial_value,
58 uint32_t struct_size)
59{
60 uint32_t i;
61
62 vector->container = NULL;
63
64 if (!struct_size || !count) {
65
66 BREAK_TO_DEBUGGER();
67 return false;
68 }
69
70 vector->container = kcalloc(count, struct_size, GFP_KERNEL);
71
72 if (vector->container == NULL)
73 return false;
74
75
76
77
78 if (NULL != initial_value) {
79 for (i = 0; i < count; ++i)
80 memmove(
81 vector->container + i * struct_size,
82 initial_value,
83 struct_size);
84 }
85
86 vector->capacity = count;
87 vector->struct_size = struct_size;
88 vector->count = count;
89 return true;
90}
91
92struct vector *dal_vector_presized_create(
93 struct dc_context *ctx,
94 uint32_t size,
95 void *initial_value,
96 uint32_t struct_size)
97{
98 struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL);
99
100 if (vector == NULL)
101 return NULL;
102
103 if (dal_vector_presized_costruct(
104 vector, ctx, size, initial_value, struct_size))
105 return vector;
106
107 BREAK_TO_DEBUGGER();
108 kfree(vector);
109 return NULL;
110}
111
112struct vector *dal_vector_create(
113 struct dc_context *ctx,
114 uint32_t capacity,
115 uint32_t struct_size)
116{
117 struct vector *vector = kzalloc(sizeof(struct vector), GFP_KERNEL);
118
119 if (vector == NULL)
120 return NULL;
121
122 if (dal_vector_construct(vector, ctx, capacity, struct_size))
123 return vector;
124
125 BREAK_TO_DEBUGGER();
126 kfree(vector);
127 return NULL;
128}
129
130void dal_vector_destruct(
131 struct vector *vector)
132{
133 kfree(vector->container);
134 vector->count = 0;
135 vector->capacity = 0;
136}
137
138void dal_vector_destroy(
139 struct vector **vector)
140{
141 if (vector == NULL || *vector == NULL)
142 return;
143 dal_vector_destruct(*vector);
144 kfree(*vector);
145 *vector = NULL;
146}
147
148uint32_t dal_vector_get_count(
149 const struct vector *vector)
150{
151 return vector->count;
152}
153
154void *dal_vector_at_index(
155 const struct vector *vector,
156 uint32_t index)
157{
158 if (vector->container == NULL || index >= vector->count)
159 return NULL;
160 return vector->container + (index * vector->struct_size);
161}
162
163bool dal_vector_remove_at_index(
164 struct vector *vector,
165 uint32_t index)
166{
167 if (index >= vector->count)
168 return false;
169
170 if (index != vector->count - 1)
171 memmove(
172 vector->container + (index * vector->struct_size),
173 vector->container + ((index + 1) * vector->struct_size),
174 (vector->count - index - 1) * vector->struct_size);
175 vector->count -= 1;
176
177 return true;
178}
179
180void dal_vector_set_at_index(
181 const struct vector *vector,
182 const void *what,
183 uint32_t index)
184{
185 void *where = dal_vector_at_index(vector, index);
186
187 if (!where) {
188 BREAK_TO_DEBUGGER();
189 return;
190 }
191 memmove(
192 where,
193 what,
194 vector->struct_size);
195}
196
197static inline uint32_t calc_increased_capacity(
198 uint32_t old_capacity)
199{
200 return old_capacity * 2;
201}
202
203bool dal_vector_insert_at(
204 struct vector *vector,
205 const void *what,
206 uint32_t position)
207{
208 uint8_t *insert_address;
209
210 if (vector->count == vector->capacity) {
211 if (!dal_vector_reserve(
212 vector,
213 calc_increased_capacity(vector->capacity)))
214 return false;
215 }
216
217 insert_address = vector->container + (vector->struct_size * position);
218
219 if (vector->count && position < vector->count)
220 memmove(
221 insert_address + vector->struct_size,
222 insert_address,
223 vector->struct_size * (vector->count - position));
224
225 memmove(
226 insert_address,
227 what,
228 vector->struct_size);
229
230 vector->count++;
231
232 return true;
233}
234
235bool dal_vector_append(
236 struct vector *vector,
237 const void *item)
238{
239 return dal_vector_insert_at(vector, item, vector->count);
240}
241
242struct vector *dal_vector_clone(
243 const struct vector *vector)
244{
245 struct vector *vec_cloned;
246 uint32_t count;
247
248
249 count = dal_vector_get_count(vector);
250
251 if (count == 0)
252
253
254 vec_cloned = dal_vector_create(
255 vector->ctx,
256 vector->capacity,
257 vector->struct_size);
258 else
259
260
261
262
263
264 vec_cloned = dal_vector_presized_create(vector->ctx, count,
265 NULL,
266 vector->struct_size);
267
268 if (NULL == vec_cloned) {
269 BREAK_TO_DEBUGGER();
270 return NULL;
271 }
272
273
274 memmove(vec_cloned->container, vector->container,
275 vec_cloned->struct_size * vec_cloned->capacity);
276
277 return vec_cloned;
278}
279
280uint32_t dal_vector_capacity(const struct vector *vector)
281{
282 return vector->capacity;
283}
284
285bool dal_vector_reserve(struct vector *vector, uint32_t capacity)
286{
287 void *new_container;
288
289 if (capacity <= vector->capacity)
290 return true;
291
292 new_container = krealloc(vector->container,
293 capacity * vector->struct_size, GFP_KERNEL);
294
295 if (new_container) {
296 vector->container = new_container;
297 vector->capacity = capacity;
298 return true;
299 }
300
301 return false;
302}
303
304void dal_vector_clear(struct vector *vector)
305{
306 vector->count = 0;
307}
308