1 // SPDX-License-Identifier: BSD-3-Clause
2 /*
3 * Copyright (c) 2020-2021, Arm Limited. All rights reserved.
4 */
5
6 #include <CppUTestExt/MockSupport.h>
7 #include <CppUTest/TestHarness.h>
8 #include "../include/sp_memory_management.h"
9 #include "mock_assert.h"
10 #include "mock_ffa_api.h"
11 #include "mock_sp_rxtx.h"
12 #include <setjmp.h>
13 #include <stdint.h>
14 #include <string.h>
15
16 /* Picked functions */
17 extern "C" {
18 bool is_valid_buffer(struct ffa_mem_transaction_buffer *buffer);
19 uint8_t build_mem_region_attr(enum sp_memory_type type,
20 union sp_memory_attr *sp_mem_attr);
21 void parse_mem_region_attr(uint8_t attr, enum sp_memory_type *type,
22 union sp_memory_attr *sp_mem_attr);
23 uint32_t build_mem_flags(struct sp_memory_transaction_flags *flags);
24 void parse_mem_flags(uint32_t raw, struct sp_memory_transaction_flags *flags);
25 void parse_descriptors(struct ffa_mem_transaction_buffer *buffer,
26 struct sp_memory_descriptor *descriptor,
27 struct sp_memory_access_descriptor *acc_desc,
28 uint32_t acc_desc_count,
29 struct sp_memory_region regions[],
30 uint32_t *region_count);
31 }
32
TEST_GROUP(sp_memory_management_internals)33 TEST_GROUP(sp_memory_management_internals)
34 {
35 TEST_SETUP()
36 {
37 memset(&attr, 0x00, sizeof(attr));
38 memset(&flags, 0x00, sizeof(flags));
39 }
40
41 TEST_TEARDOWN()
42 {
43 mock().checkExpectations();
44 mock().clear();
45 }
46
47 union sp_memory_attr attr;
48 struct sp_memory_transaction_flags flags;
49 };
50
TEST(sp_memory_management_internals,is_valid_buffer_null)51 TEST(sp_memory_management_internals, is_valid_buffer_null)
52 {
53 CHECK_FALSE(is_valid_buffer(NULL));
54 }
55
TEST(sp_memory_management_internals,is_valid_buffer_address_not_aligned)56 TEST(sp_memory_management_internals, is_valid_buffer_address_not_aligned)
57 {
58 struct ffa_mem_transaction_buffer buffer = { .buffer = (void *)1,
59 .length = 0 };
60 CHECK_FALSE(is_valid_buffer(&buffer));
61 }
62
TEST(sp_memory_management_internals,is_valid_buffer_size_not_aligned)63 TEST(sp_memory_management_internals, is_valid_buffer_size_not_aligned)
64 {
65 struct ffa_mem_transaction_buffer buffer = { .buffer = (void *)0,
66 .length = 1 };
67 CHECK_FALSE(is_valid_buffer(&buffer));
68 }
69
TEST(sp_memory_management_internals,is_valid_buffer)70 TEST(sp_memory_management_internals, is_valid_buffer)
71 {
72 struct ffa_mem_transaction_buffer buffer = { .buffer = (void *)0,
73 .length = 0 };
74 CHECK_TRUE(is_valid_buffer(&buffer));
75 }
76
TEST(sp_memory_management_internals,build_mem_region_attr_reserved_type)77 TEST(sp_memory_management_internals, build_mem_region_attr_reserved_type)
78 {
79 assert_environment_t env;
80 uint8_t result = 0;
81
82 attr.device_memory = sp_device_memory_nGnRnE;
83
84 if (SETUP_ASSERT_ENVIRONMENT(env)) {
85 build_mem_region_attr(sp_memory_type_reserved, &attr);
86 }
87 }
88
TEST(sp_memory_management_internals,build_mem_region_attr_device_nGnRnE)89 TEST(sp_memory_management_internals, build_mem_region_attr_device_nGnRnE)
90 {
91 uint8_t result = 0;
92 uint8_t expected_result = 0;
93
94 attr.device_memory = sp_device_memory_nGnRnE;
95
96 expected_result = FFA_MEM_REGION_ATTR_MEMORY_TYPE_DEVICE
97 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
98 expected_result |= FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_NGNRNE
99 << FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_SHIFT;
100
101 result = build_mem_region_attr(sp_memory_type_device_memory, &attr);
102 BYTES_EQUAL(expected_result, result);
103 }
104
TEST(sp_memory_management_internals,build_mem_region_attr_device_nGnRE)105 TEST(sp_memory_management_internals, build_mem_region_attr_device_nGnRE)
106 {
107 uint8_t result = 0;
108 uint8_t expected_result = 0;
109
110 attr.device_memory = sp_device_memory_nGnRE;
111
112 expected_result = FFA_MEM_REGION_ATTR_MEMORY_TYPE_DEVICE
113 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
114 expected_result |= FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_NGNRE
115 << FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_SHIFT;
116
117 result = build_mem_region_attr(sp_memory_type_device_memory, &attr);
118 BYTES_EQUAL(expected_result, result);
119 }
120
TEST(sp_memory_management_internals,build_mem_region_attr_device_nGRE)121 TEST(sp_memory_management_internals, build_mem_region_attr_device_nGRE)
122 {
123 uint8_t result = 0;
124 uint8_t expected_result = 0;
125
126 attr.device_memory = sp_device_memory_nGRE;
127
128 expected_result = FFA_MEM_REGION_ATTR_MEMORY_TYPE_DEVICE
129 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
130 expected_result |= FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_NGRE
131 << FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_SHIFT;
132
133 result = build_mem_region_attr(sp_memory_type_device_memory, &attr);
134 BYTES_EQUAL(expected_result, result);
135 }
136
TEST(sp_memory_management_internals,build_mem_region_attr_device_GRE)137 TEST(sp_memory_management_internals, build_mem_region_attr_device_GRE)
138 {
139 uint8_t result = 0;
140 uint8_t expected_result = 0;
141
142 attr.device_memory = sp_device_memory_GRE;
143
144 expected_result = FFA_MEM_REGION_ATTR_MEMORY_TYPE_DEVICE
145 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
146 expected_result |= FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_GRE
147 << FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_SHIFT;
148
149 result = build_mem_region_attr(sp_memory_type_device_memory, &attr);
150 BYTES_EQUAL(expected_result, result);
151 }
152
TEST(sp_memory_management_internals,build_mem_region_attr_normal_cache_reserved0)153 TEST(sp_memory_management_internals,
154 build_mem_region_attr_normal_cache_reserved0)
155 {
156 assert_environment_t env;
157 uint8_t result = 0;
158 uint8_t expected_result = 0;
159
160 attr.normal_memory.cacheability = sp_cacheability_reserved0;
161 attr.normal_memory.shareability = sp_shareability_non_shareable;
162
163 if (SETUP_ASSERT_ENVIRONMENT(env)) {
164 build_mem_region_attr(sp_memory_type_normal_memory, &attr);
165 }
166 }
167
TEST(sp_memory_management_internals,build_mem_region_attr_normal_cache_reserved2)168 TEST(sp_memory_management_internals,
169 build_mem_region_attr_normal_cache_reserved2)
170 {
171 assert_environment_t env;
172 uint8_t result = 0;
173 uint8_t expected_result = 0;
174
175 attr.normal_memory.cacheability = sp_cacheability_reserved2;
176 attr.normal_memory.shareability = sp_shareability_non_shareable;
177
178 if (SETUP_ASSERT_ENVIRONMENT(env)) {
179 build_mem_region_attr(sp_memory_type_normal_memory, &attr);
180 }
181 }
182
TEST(sp_memory_management_internals,build_mem_region_attr_normal_share_reserved)183 TEST(sp_memory_management_internals,
184 build_mem_region_attr_normal_share_reserved)
185 {
186 assert_environment_t env;
187 uint8_t result = 0;
188 uint8_t expected_result = 0;
189
190 attr.normal_memory.cacheability = sp_cacheability_non_cacheable;
191 attr.normal_memory.shareability = sp_shareability_reserved;
192
193 if (SETUP_ASSERT_ENVIRONMENT(env)) {
194 build_mem_region_attr(sp_memory_type_normal_memory, &attr);
195 }
196 }
197
TEST(sp_memory_management_internals,build_mem_region_attr_normal_non_non)198 TEST(sp_memory_management_internals, build_mem_region_attr_normal_non_non)
199 {
200 uint8_t result = 0;
201 uint8_t expected_result = 0;
202
203 attr.normal_memory.cacheability = sp_cacheability_non_cacheable;
204 attr.normal_memory.shareability = sp_shareability_non_shareable;
205
206 expected_result = FFA_MEM_REGION_ATTR_MEMORY_TYPE_NORMAL
207 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
208 expected_result |= FFA_MEM_REGION_ATTR_CACHEABILITY_NON_CACHEABLE
209 << FFA_MEM_REGION_ATTR_CACHEABILITY_SHIFT;
210 expected_result |= FFA_MEM_REGION_ATTR_SHAREABILITY_NON_SHAREABLE
211 << FFA_MEM_REGION_ATTR_SHAREABILITY_SHIFT;
212
213 result = build_mem_region_attr(sp_memory_type_normal_memory, &attr);
214 BYTES_EQUAL(expected_result, result);
215 }
216
TEST(sp_memory_management_internals,build_mem_region_attr_normal_writeback_non)217 TEST(sp_memory_management_internals, build_mem_region_attr_normal_writeback_non)
218 {
219 uint8_t result = 0;
220 uint8_t expected_result = 0;
221
222 attr.normal_memory.cacheability = sp_cacheability_write_back;
223 attr.normal_memory.shareability = sp_shareability_non_shareable;
224
225 expected_result = FFA_MEM_REGION_ATTR_MEMORY_TYPE_NORMAL
226 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
227 expected_result |= FFA_MEM_REGION_ATTR_CACHEABILITY_WRITE_BACK
228 << FFA_MEM_REGION_ATTR_CACHEABILITY_SHIFT;
229 expected_result |= FFA_MEM_REGION_ATTR_SHAREABILITY_NON_SHAREABLE
230 << FFA_MEM_REGION_ATTR_SHAREABILITY_SHIFT;
231
232 result = build_mem_region_attr(sp_memory_type_normal_memory, &attr);
233 BYTES_EQUAL(expected_result, result);
234 }
235
TEST(sp_memory_management_internals,build_mem_region_attr_normal_non_inner)236 TEST(sp_memory_management_internals, build_mem_region_attr_normal_non_inner)
237 {
238 uint8_t result = 0;
239 uint8_t expected_result = 0;
240
241 attr.normal_memory.cacheability = sp_cacheability_non_cacheable;
242 attr.normal_memory.shareability = sp_shareability_inner_shareable;
243
244 expected_result = FFA_MEM_REGION_ATTR_MEMORY_TYPE_NORMAL
245 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
246 expected_result |= FFA_MEM_REGION_ATTR_CACHEABILITY_NON_CACHEABLE
247 << FFA_MEM_REGION_ATTR_CACHEABILITY_SHIFT;
248 expected_result |= FFA_MEM_REGION_ATTR_SHAREABILITY_INNER_SHAREABLE
249 << FFA_MEM_REGION_ATTR_SHAREABILITY_SHIFT;
250
251 result = build_mem_region_attr(sp_memory_type_normal_memory, &attr);
252 BYTES_EQUAL(expected_result, result);
253 }
254
TEST(sp_memory_management_internals,build_mem_region_attr_normal_non_outer)255 TEST(sp_memory_management_internals, build_mem_region_attr_normal_non_outer)
256 {
257 uint8_t result = 0;
258 uint8_t expected_result = 0;
259
260 attr.normal_memory.cacheability = sp_cacheability_non_cacheable;
261 attr.normal_memory.shareability = sp_shareability_outer_shareable;
262
263 expected_result = FFA_MEM_REGION_ATTR_MEMORY_TYPE_NORMAL
264 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
265 expected_result |= FFA_MEM_REGION_ATTR_CACHEABILITY_NON_CACHEABLE
266 << FFA_MEM_REGION_ATTR_CACHEABILITY_SHIFT;
267 expected_result |= FFA_MEM_REGION_ATTR_SHAREABILITY_OUTER_SHAREABLE
268 << FFA_MEM_REGION_ATTR_SHAREABILITY_SHIFT;
269
270 result = build_mem_region_attr(sp_memory_type_normal_memory, &attr);
271 BYTES_EQUAL(expected_result, result);
272 }
273
TEST(sp_memory_management_internals,parse_mem_region_attr_not_specified)274 TEST(sp_memory_management_internals, parse_mem_region_attr_not_specified)
275 {
276 enum sp_memory_type type = sp_memory_type_reserved;
277 uint8_t raw = 0;
278
279 parse_mem_region_attr(raw, &type, &attr);
280 CHECK_EQUAL(sp_memory_type_not_specified, type);
281 }
282
TEST(sp_memory_management_internals,parse_mem_region_attr_device)283 TEST(sp_memory_management_internals, parse_mem_region_attr_device)
284 {
285 enum sp_memory_type type = sp_memory_type_reserved;
286 uint8_t raw = 0;
287
288 raw = FFA_MEM_REGION_ATTR_MEMORY_TYPE_DEVICE
289 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
290 raw |= FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_GRE
291 << FFA_MEM_REGION_ATTR_DEVICE_MEM_ATTR_SHIFT;
292
293 parse_mem_region_attr(raw, &type, &attr);
294 CHECK_EQUAL(sp_memory_type_device_memory, type);
295 CHECK_EQUAL(sp_device_memory_GRE, attr.device_memory);
296 }
297
TEST(sp_memory_management_internals,parse_mem_region_attr_normal)298 TEST(sp_memory_management_internals, parse_mem_region_attr_normal)
299 {
300 enum sp_memory_type type = sp_memory_type_reserved;
301 uint8_t raw = 0;
302
303 raw = FFA_MEM_REGION_ATTR_MEMORY_TYPE_NORMAL
304 << FFA_MEM_REGION_ATTR_MEMORY_TYPE_SHIFT;
305 raw |= FFA_MEM_REGION_ATTR_CACHEABILITY_WRITE_BACK
306 << FFA_MEM_REGION_ATTR_CACHEABILITY_SHIFT;
307 raw |= FFA_MEM_REGION_ATTR_SHAREABILITY_INNER_SHAREABLE
308 << FFA_MEM_REGION_ATTR_SHAREABILITY_SHIFT;
309
310 parse_mem_region_attr(raw, &type, &attr);
311 CHECK_EQUAL(sp_memory_type_normal_memory, type);
312 CHECK_EQUAL(sp_cacheability_write_back,
313 attr.normal_memory.cacheability);
314 CHECK_EQUAL(sp_shareability_inner_shareable,
315 attr.normal_memory.shareability);
316 }
317
TEST(sp_memory_management_internals,build_mem_flags_none)318 TEST(sp_memory_management_internals, build_mem_flags_none)
319 {
320 uint32_t result = 0;
321
322 result = build_mem_flags(&flags);
323 UNSIGNED_LONGS_EQUAL(0, result);
324 }
325
TEST(sp_memory_management_internals,build_mem_flags_zero_memory)326 TEST(sp_memory_management_internals, build_mem_flags_zero_memory)
327 {
328 uint32_t result = 0;
329
330 flags.zero_memory = true;
331 result = build_mem_flags(&flags);
332 UNSIGNED_LONGS_EQUAL(FFA_MEM_TRANSACTION_FLAGS_ZERO_MEMORY, result);
333 }
334
TEST(sp_memory_management_internals,build_mem_flags_time_slicing)335 TEST(sp_memory_management_internals, build_mem_flags_time_slicing)
336 {
337 uint32_t result = 0;
338
339 flags.operation_time_slicing = true;
340 result = build_mem_flags(&flags);
341 UNSIGNED_LONGS_EQUAL(FFA_MEM_TRANSACTION_FLAGS_OPERATION_TIME_SLICING,
342 result);
343 }
344
TEST(sp_memory_management_internals,build_mem_flags_zero_mem_after_relinquish)345 TEST(sp_memory_management_internals, build_mem_flags_zero_mem_after_relinquish)
346 {
347 uint32_t result = 0;
348
349 flags.zero_memory_after_relinquish = true;
350 result = build_mem_flags(&flags);
351 UNSIGNED_LONGS_EQUAL(
352 FFA_MEM_TRANSACTION_FLAGS_ZERO_MEMORY_AFTER_RELINQIUSH, result);
353 }
354
TEST(sp_memory_management_internals,build_mem_flags_type)355 TEST(sp_memory_management_internals, build_mem_flags_type)
356 {
357 uint32_t result = 0;
358 uint32_t expected_result = 0;
359
360 expected_result = FFA_MEM_TRANSACTION_FLAGS_TYPE_DONATE
361 << FFA_MEM_TRANSACTION_FLAGS_TYPE_SHIFT;
362
363 flags.transaction_type = sp_memory_transaction_type_donate;
364 result = build_mem_flags(&flags);
365 UNSIGNED_LONGS_EQUAL(expected_result, result);
366 }
367
TEST(sp_memory_management_internals,build_mem_flags_alignment_hint_invalid)368 TEST(sp_memory_management_internals, build_mem_flags_alignment_hint_invalid)
369 {
370 assert_environment_t env;
371 uint32_t result = 0;
372
373 flags.alignment_hint =
374 FFA_MEM_TRANSACTION_FLAGS_ALIGNMENT_HINT_MASK + 1;
375
376 if (SETUP_ASSERT_ENVIRONMENT(env)) {
377 build_mem_flags(&flags);
378 }
379 }
380
TEST(sp_memory_management_internals,build_mem_flags_alignment_hint)381 TEST(sp_memory_management_internals, build_mem_flags_alignment_hint)
382 {
383 uint32_t result = 0;
384 uint32_t expected_result = 0;
385
386 expected_result = FFA_MEM_TRANSACTION_FLAGS_ALIGNMENT_HINT_VALID;
387 expected_result |= FFA_MEM_TRANSACTION_FLAGS_ALIGNMENT_HINT_MASK
388 << FFA_MEM_TRANSACTION_FLAGS_ALIGNMENT_HINT_SHIFT;
389
390 flags.alignment_hint = FFA_MEM_TRANSACTION_FLAGS_ALIGNMENT_HINT_MASK;
391 result = build_mem_flags(&flags);
392 UNSIGNED_LONGS_EQUAL(expected_result, result);
393 }
394
TEST(sp_memory_management_internals,parse_mem_flags_none)395 TEST(sp_memory_management_internals, parse_mem_flags_none)
396 {
397 uint32_t raw = 0;
398
399 parse_mem_flags(raw, &flags);
400 CHECK_FALSE(flags.zero_memory);
401 CHECK_FALSE(flags.operation_time_slicing);
402 CHECK_FALSE(flags.zero_memory_after_relinquish);
403 CHECK_EQUAL(sp_memory_transaction_type_relayer_specified,
404 flags.transaction_type);
405 UNSIGNED_LONGS_EQUAL(0, flags.alignment_hint);
406 }
407
TEST(sp_memory_management_internals,parse_mem_flags_zero_memory)408 TEST(sp_memory_management_internals, parse_mem_flags_zero_memory)
409 {
410 uint32_t raw = 0;
411
412 raw |= FFA_MEM_TRANSACTION_FLAGS_ZERO_MEMORY;
413
414 parse_mem_flags(raw, &flags);
415 CHECK_TRUE(flags.zero_memory);
416 CHECK_FALSE(flags.operation_time_slicing);
417 CHECK_FALSE(flags.zero_memory_after_relinquish);
418 CHECK_EQUAL(sp_memory_transaction_type_relayer_specified,
419 flags.transaction_type);
420 UNSIGNED_LONGS_EQUAL(0, flags.alignment_hint);
421 }
422
TEST(sp_memory_management_internals,parse_mem_flags_operation_time_slicing)423 TEST(sp_memory_management_internals, parse_mem_flags_operation_time_slicing)
424 {
425 uint32_t raw = 0;
426
427 raw |= FFA_MEM_TRANSACTION_FLAGS_OPERATION_TIME_SLICING;
428
429 parse_mem_flags(raw, &flags);
430 CHECK_FALSE(flags.zero_memory);
431 CHECK_TRUE(flags.operation_time_slicing);
432 CHECK_FALSE(flags.zero_memory_after_relinquish);
433 CHECK_EQUAL(sp_memory_transaction_type_relayer_specified,
434 flags.transaction_type);
435 UNSIGNED_LONGS_EQUAL(0, flags.alignment_hint);
436 }
437
TEST(sp_memory_management_internals,parse_mem_flags_zero_memory_after_relinquish)438 TEST(sp_memory_management_internals,
439 parse_mem_flags_zero_memory_after_relinquish)
440 {
441 uint32_t raw = 0;
442
443 raw |= FFA_MEM_TRANSACTION_FLAGS_ZERO_MEMORY_AFTER_RELINQIUSH;
444
445 parse_mem_flags(raw, &flags);
446 CHECK_FALSE(flags.zero_memory);
447 CHECK_FALSE(flags.operation_time_slicing);
448 CHECK_TRUE(flags.zero_memory_after_relinquish);
449 CHECK_EQUAL(sp_memory_transaction_type_relayer_specified,
450 flags.transaction_type);
451 UNSIGNED_LONGS_EQUAL(0, flags.alignment_hint);
452 }
453
TEST(sp_memory_management_internals,parse_mem_flags_type)454 TEST(sp_memory_management_internals, parse_mem_flags_type)
455 {
456 uint32_t raw = 0;
457
458 raw |= FFA_MEM_TRANSACTION_FLAGS_TYPE_DONATE
459 << FFA_MEM_TRANSACTION_FLAGS_TYPE_SHIFT;
460
461 parse_mem_flags(raw, &flags);
462 CHECK_FALSE(flags.zero_memory);
463 CHECK_FALSE(flags.operation_time_slicing);
464 CHECK_FALSE(flags.zero_memory_after_relinquish);
465 CHECK_EQUAL(sp_memory_transaction_type_donate, flags.transaction_type);
466 UNSIGNED_LONGS_EQUAL(0, flags.alignment_hint);
467 }
468
TEST(sp_memory_management_internals,parse_mem_flags_alignment_hint)469 TEST(sp_memory_management_internals, parse_mem_flags_alignment_hint)
470 {
471 uint32_t raw = 0;
472
473 raw |= FFA_MEM_TRANSACTION_FLAGS_ALIGNMENT_HINT_VALID;
474 raw |= FFA_MEM_TRANSACTION_FLAGS_ALIGNMENT_HINT_MASK
475 << FFA_MEM_TRANSACTION_FLAGS_ALIGNMENT_HINT_SHIFT;
476
477 parse_mem_flags(raw, &flags);
478 CHECK_FALSE(flags.zero_memory);
479 CHECK_FALSE(flags.operation_time_slicing);
480 CHECK_FALSE(flags.zero_memory_after_relinquish);
481 CHECK_EQUAL(sp_memory_transaction_type_relayer_specified,
482 flags.transaction_type);
483 UNSIGNED_LONGS_EQUAL(FFA_MEM_TRANSACTION_FLAGS_ALIGNMENT_HINT_MASK,
484 flags.alignment_hint);
485 }
486
TEST(sp_memory_management_internals,parse_descriptors_different_tag)487 TEST(sp_memory_management_internals, parse_descriptors_different_tag)
488 {
489 assert_environment_t env;
490 uint8_t buffer_area[FFA_MEM_TRANSACTION_PAGE_SIZE] = { 0 };
491 struct ffa_mem_transaction_buffer buffer = { 0 };
492 struct sp_memory_descriptor desc = { 0 };
493
494 desc.tag = 1;
495
496 ffa_init_mem_transaction_buffer(buffer_area, sizeof(buffer_area),
497 &buffer);
498 ffa_init_mem_transaction_desc(&buffer, 0, 0, 0, 0, 2);
499
500 if (SETUP_ASSERT_ENVIRONMENT(env)) {
501 parse_descriptors(&buffer, &desc, NULL, 0, NULL, 0);
502 }
503 }
504
TEST(sp_memory_management_internals,parse_descriptors_zero_descriptors)505 TEST(sp_memory_management_internals, parse_descriptors_zero_descriptors)
506 {
507 assert_environment_t env;
508 uint8_t buffer_area[FFA_MEM_TRANSACTION_PAGE_SIZE] = { 0 };
509 struct ffa_mem_transaction_buffer buffer = { 0 };
510 struct sp_memory_descriptor desc = { 0 };
511
512 ffa_init_mem_transaction_buffer(buffer_area, sizeof(buffer_area),
513 &buffer);
514 ffa_init_mem_transaction_desc(&buffer, 0, 0, 0, 0, 0);
515
516 if (SETUP_ASSERT_ENVIRONMENT(env)) {
517 parse_descriptors(&buffer, &desc, NULL, 0, NULL, 0);
518 }
519 }
520
TEST(sp_memory_management_internals,parse_descriptors_invalid_desc_count)521 TEST(sp_memory_management_internals, parse_descriptors_invalid_desc_count)
522 {
523 assert_environment_t env;
524 uint8_t buffer_area[FFA_MEM_TRANSACTION_PAGE_SIZE] = { 0 };
525 struct ffa_mem_transaction_buffer buffer = { 0 };
526 struct sp_memory_descriptor desc = { 0 };
527
528 ffa_init_mem_transaction_buffer(buffer_area, sizeof(buffer_area),
529 &buffer);
530 ffa_init_mem_transaction_desc(&buffer, 0, 0, 0, 0, 0);
531 ffa_add_mem_access_desc(&buffer, 1, 0, 0);
532
533 if (SETUP_ASSERT_ENVIRONMENT(env)) {
534 parse_descriptors(&buffer, &desc, NULL, 0, NULL, 0);
535 }
536 }
537
TEST(sp_memory_management_internals,parse_descriptors_invalid_region_count)538 TEST(sp_memory_management_internals, parse_descriptors_invalid_region_count)
539 {
540 assert_environment_t env;
541 uint8_t buffer_area[FFA_MEM_TRANSACTION_PAGE_SIZE] = { 0 };
542 struct ffa_mem_transaction_buffer buffer = { 0 };
543 struct sp_memory_descriptor desc = { 0 };
544 struct sp_memory_access_descriptor acc_desc = { 0 };
545 uint32_t region_count = 0;
546
547 ffa_init_mem_transaction_buffer(buffer_area, sizeof(buffer_area),
548 &buffer);
549 ffa_init_mem_transaction_desc(&buffer, 0, 0, 0, 0, 0);
550 ffa_add_mem_access_desc(&buffer, 1, 0, 0);
551 ffa_add_memory_region(&buffer, 0, 0);
552
553 if (SETUP_ASSERT_ENVIRONMENT(env)) {
554 parse_descriptors(&buffer, &desc, &acc_desc, 1, NULL,
555 ®ion_count);
556 }
557 }
558