1 /*
2 * Copyright (c) 2013-2019, Intel Corporation
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * * Redistributions of source code must retain the above copyright notice,
8 * this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above copyright notice,
10 * this list of conditions and the following disclaimer in the documentation
11 * and/or other materials provided with the distribution.
12 * * Neither the name of Intel Corporation nor the names of its contributors
13 * may be used to endorse or promote products derived from this software
14 * without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "ptunit.h"
30
31 #include "pt_image.h"
32 #include "pt_section.h"
33 #include "pt_mapped_section.h"
34
35 #include "intel-pt.h"
36
37
38 struct image_fixture;
39
40 /* A test mapping. */
41 struct ifix_mapping {
42 /* The contents. */
43 uint8_t content[0x10];
44
45 /* The size - between 0 and sizeof(content). */
46 uint64_t size;
47
48 /* An artificial error code to be injected into pt_section_read().
49 *
50 * If @errcode is non-zero, pt_section_read() fails with @errcode.
51 */
52 int errcode;
53 };
54
55 /* A test file status - turned into a section status. */
56 struct ifix_status {
57 /* Delete indication:
58 * - zero if initialized and not (yet) deleted
59 * - non-zero if deleted and not (re-)initialized
60 */
61 int deleted;
62
63 /* Put with use-count of zero indication. */
64 int bad_put;
65
66 /* The test mapping to be used. */
67 struct ifix_mapping *mapping;
68
69 /* A link back to the test fixture providing this section. */
70 struct image_fixture *ifix;
71 };
72
73 enum {
74 ifix_nsecs = 5
75 };
76
77 /* A fake image section cache. */
78 struct pt_image_section_cache {
79 /* The cached sections. */
80 struct pt_section *section[ifix_nsecs];
81
82 /* Their load addresses. */
83 uint64_t laddr[ifix_nsecs];
84
85 /* The number of used sections. */
86 int nsecs;
87 };
88
89 extern int pt_iscache_lookup(struct pt_image_section_cache *iscache,
90 struct pt_section **section, uint64_t *laddr,
91 int isid);
92
93
94 /* A test fixture providing an image, test sections, and asids. */
95 struct image_fixture {
96 /* The image. */
97 struct pt_image image;
98
99 /* The test states. */
100 struct ifix_status status[ifix_nsecs];
101
102 /* The test mappings. */
103 struct ifix_mapping mapping[ifix_nsecs];
104
105 /* The sections. */
106 struct pt_section section[ifix_nsecs];
107
108 /* The asids. */
109 struct pt_asid asid[3];
110
111 /* The number of used sections/mappings/states. */
112 int nsecs;
113
114 /* An initially empty image as destination for image copies. */
115 struct pt_image copy;
116
117 /* A test section cache. */
118 struct pt_image_section_cache iscache;
119
120 /* The test fixture initialization and finalization functions. */
121 struct ptunit_result (*init)(struct image_fixture *);
122 struct ptunit_result (*fini)(struct image_fixture *);
123 };
124
ifix_init_section(struct pt_section * section,char * filename,struct ifix_status * status,struct ifix_mapping * mapping,struct image_fixture * ifix)125 static void ifix_init_section(struct pt_section *section, char *filename,
126 struct ifix_status *status,
127 struct ifix_mapping *mapping,
128 struct image_fixture *ifix)
129 {
130 uint8_t i;
131
132 memset(section, 0, sizeof(*section));
133
134 section->filename = filename;
135 section->status = status;
136 section->size = mapping->size = sizeof(mapping->content);
137 section->offset = 0x10;
138
139 for (i = 0; i < mapping->size; ++i)
140 mapping->content[i] = i;
141
142 status->deleted = 0;
143 status->bad_put = 0;
144 status->mapping = mapping;
145 status->ifix = ifix;
146 }
147
ifix_add_section(struct image_fixture * ifix,char * filename)148 static int ifix_add_section(struct image_fixture *ifix, char *filename)
149 {
150 int index;
151
152 if (!ifix)
153 return -pte_internal;
154
155 index = ifix->nsecs;
156 if (ifix_nsecs <= index)
157 return -pte_internal;
158
159 ifix_init_section(&ifix->section[index], filename, &ifix->status[index],
160 &ifix->mapping[index], ifix);
161
162 ifix->nsecs += 1;
163 return index;
164 }
165
ifix_cache_section(struct image_fixture * ifix,struct pt_section * section,uint64_t laddr)166 static int ifix_cache_section(struct image_fixture *ifix,
167 struct pt_section *section, uint64_t laddr)
168 {
169 int index;
170
171 if (!ifix)
172 return -pte_internal;
173
174 index = ifix->iscache.nsecs;
175 if (ifix_nsecs <= index)
176 return -pte_internal;
177
178 ifix->iscache.section[index] = section;
179 ifix->iscache.laddr[index] = laddr;
180
181 index += 1;
182 ifix->iscache.nsecs = index;
183
184 return index;
185 }
186
pt_section_filename(const struct pt_section * section)187 const char *pt_section_filename(const struct pt_section *section)
188 {
189 if (!section)
190 return NULL;
191
192 return section->filename;
193 }
194
pt_section_offset(const struct pt_section * section)195 uint64_t pt_section_offset(const struct pt_section *section)
196 {
197 if (!section)
198 return 0ull;
199
200 return section->offset;
201 }
202
pt_section_size(const struct pt_section * section)203 uint64_t pt_section_size(const struct pt_section *section)
204 {
205 if (!section)
206 return 0ull;
207
208 return section->size;
209 }
210
pt_mk_section(struct pt_section ** psection,const char * filename,uint64_t offset,uint64_t size)211 int pt_mk_section(struct pt_section **psection, const char *filename,
212 uint64_t offset, uint64_t size)
213 {
214 (void) psection;
215 (void) filename;
216 (void) offset;
217 (void) size;
218
219 /* This function is not used by our tests. */
220 return -pte_not_supported;
221 }
222
pt_section_get(struct pt_section * section)223 int pt_section_get(struct pt_section *section)
224 {
225 if (!section)
226 return -pte_internal;
227
228 section->ucount += 1;
229 return 0;
230 }
231
pt_section_put(struct pt_section * section)232 int pt_section_put(struct pt_section *section)
233 {
234 struct ifix_status *status;
235 uint16_t ucount;
236
237 if (!section)
238 return -pte_internal;
239
240 status = section->status;
241 if (!status)
242 return -pte_internal;
243
244 ucount = section->ucount;
245 if (!ucount) {
246 status->bad_put += 1;
247
248 return -pte_internal;
249 }
250
251 ucount = --section->ucount;
252 if (!ucount) {
253 status->deleted += 1;
254
255 if (status->deleted > 1)
256 return -pte_internal;
257 }
258
259 return 0;
260 }
261
pt_iscache_lookup(struct pt_image_section_cache * iscache,struct pt_section ** section,uint64_t * laddr,int isid)262 int pt_iscache_lookup(struct pt_image_section_cache *iscache,
263 struct pt_section **section, uint64_t *laddr, int isid)
264 {
265 if (!iscache || !section || !laddr)
266 return -pte_internal;
267
268 if (!isid || iscache->nsecs < isid)
269 return -pte_bad_image;
270
271 isid -= 1;
272
273 *section = iscache->section[isid];
274 *laddr = iscache->laddr[isid];
275
276 return pt_section_get(*section);
277 }
278
ifix_unmap(struct pt_section * section)279 static int ifix_unmap(struct pt_section *section)
280 {
281 uint16_t mcount;
282
283 if (!section)
284 return -pte_internal;
285
286 mcount = section->mcount;
287 if (!mcount)
288 return -pte_internal;
289
290 if (!section->mapping)
291 return -pte_internal;
292
293 mcount = --section->mcount;
294 if (!mcount)
295 section->mapping = NULL;
296
297 return 0;
298 }
299
ifix_read(const struct pt_section * section,uint8_t * buffer,uint16_t size,uint64_t offset)300 static int ifix_read(const struct pt_section *section, uint8_t *buffer,
301 uint16_t size, uint64_t offset)
302 {
303 struct ifix_mapping *mapping;
304 uint64_t begin, end;
305
306 if (!section || !buffer)
307 return -pte_internal;
308
309 begin = offset;
310 end = begin + size;
311
312 if (end < begin)
313 return -pte_nomap;
314
315 mapping = section->mapping;
316 if (!mapping)
317 return -pte_nomap;
318
319 if (mapping->errcode)
320 return mapping->errcode;
321
322 if (mapping->size <= begin)
323 return -pte_nomap;
324
325 if (mapping->size < end) {
326 end = mapping->size;
327 size = (uint16_t) (end - begin);
328 }
329
330 memcpy(buffer, &mapping->content[begin], size);
331
332 return size;
333 }
334
pt_section_map(struct pt_section * section)335 int pt_section_map(struct pt_section *section)
336 {
337 struct ifix_status *status;
338 uint16_t mcount;
339
340 if (!section)
341 return -pte_internal;
342
343 mcount = section->mcount++;
344 if (mcount)
345 return 0;
346
347 if (section->mapping)
348 return -pte_internal;
349
350 status = section->status;
351 if (!status)
352 return -pte_internal;
353
354 section->mapping = status->mapping;
355 section->unmap = ifix_unmap;
356 section->read = ifix_read;
357
358 return 0;
359 }
360
pt_section_on_map_lock(struct pt_section * section)361 int pt_section_on_map_lock(struct pt_section *section)
362 {
363 if (!section)
364 return -pte_internal;
365
366 return 0;
367 }
368
pt_section_unmap(struct pt_section * section)369 int pt_section_unmap(struct pt_section *section)
370 {
371 if (!section)
372 return -pte_internal;
373
374 if (!section->unmap)
375 return -pte_nomap;
376
377 return section->unmap(section);
378 }
379
pt_section_read(const struct pt_section * section,uint8_t * buffer,uint16_t size,uint64_t offset)380 int pt_section_read(const struct pt_section *section, uint8_t *buffer,
381 uint16_t size, uint64_t offset)
382 {
383 if (!section)
384 return -pte_internal;
385
386 if (!section->read)
387 return -pte_nomap;
388
389 return section->read(section, buffer, size, offset);
390 }
391
392 /* A test read memory callback. */
image_readmem_callback(uint8_t * buffer,size_t size,const struct pt_asid * asid,uint64_t ip,void * context)393 static int image_readmem_callback(uint8_t *buffer, size_t size,
394 const struct pt_asid *asid,
395 uint64_t ip, void *context)
396 {
397 const uint8_t *memory;
398 size_t idx;
399
400 (void) asid;
401
402 if (!buffer)
403 return -pte_invalid;
404
405 /* We use a constant offset of 0x3000. */
406 if (ip < 0x3000ull)
407 return -pte_nomap;
408
409 ip -= 0x3000ull;
410
411 memory = (const uint8_t *) context;
412 if (!memory)
413 return -pte_internal;
414
415 for (idx = 0; idx < size; ++idx)
416 buffer[idx] = memory[ip + idx];
417
418 return (int) idx;
419 }
420
init(void)421 static struct ptunit_result init(void)
422 {
423 struct pt_image image;
424
425 memset(&image, 0xcd, sizeof(image));
426
427 pt_image_init(&image, NULL);
428 ptu_null(image.name);
429 ptu_null(image.sections);
430 ptu_null((void *) (uintptr_t) image.readmem.callback);
431 ptu_null(image.readmem.context);
432
433 return ptu_passed();
434 }
435
init_name(struct image_fixture * ifix)436 static struct ptunit_result init_name(struct image_fixture *ifix)
437 {
438 memset(&ifix->image, 0xcd, sizeof(ifix->image));
439
440 pt_image_init(&ifix->image, "image-name");
441 ptu_str_eq(ifix->image.name, "image-name");
442 ptu_null(ifix->image.sections);
443 ptu_null((void *) (uintptr_t) ifix->image.readmem.callback);
444 ptu_null(ifix->image.readmem.context);
445
446 return ptu_passed();
447 }
448
init_null(void)449 static struct ptunit_result init_null(void)
450 {
451 pt_image_init(NULL, NULL);
452
453 return ptu_passed();
454 }
455
fini(void)456 static struct ptunit_result fini(void)
457 {
458 struct ifix_mapping mapping;
459 struct ifix_status status;
460 struct pt_section section;
461 struct pt_image image;
462 struct pt_asid asid;
463 int errcode;
464
465 pt_asid_init(&asid);
466 ifix_init_section(§ion, NULL, &status, &mapping, NULL);
467
468 pt_image_init(&image, NULL);
469 errcode = pt_image_add(&image, §ion, &asid, 0x0ull, 0);
470 ptu_int_eq(errcode, 0);
471
472 pt_image_fini(&image);
473 ptu_int_eq(section.ucount, 0);
474 ptu_int_eq(section.mcount, 0);
475 ptu_int_eq(status.deleted, 1);
476 ptu_int_eq(status.bad_put, 0);
477
478 return ptu_passed();
479 }
480
fini_empty(void)481 static struct ptunit_result fini_empty(void)
482 {
483 struct pt_image image;
484
485 pt_image_init(&image, NULL);
486 pt_image_fini(&image);
487
488 return ptu_passed();
489 }
490
fini_null(void)491 static struct ptunit_result fini_null(void)
492 {
493 pt_image_fini(NULL);
494
495 return ptu_passed();
496 }
497
name(struct image_fixture * ifix)498 static struct ptunit_result name(struct image_fixture *ifix)
499 {
500 const char *name;
501
502 pt_image_init(&ifix->image, "image-name");
503
504 name = pt_image_name(&ifix->image);
505 ptu_str_eq(name, "image-name");
506
507 return ptu_passed();
508 }
509
name_none(void)510 static struct ptunit_result name_none(void)
511 {
512 struct pt_image image;
513 const char *name;
514
515 pt_image_init(&image, NULL);
516
517 name = pt_image_name(&image);
518 ptu_null(name);
519
520 return ptu_passed();
521 }
522
name_null(void)523 static struct ptunit_result name_null(void)
524 {
525 const char *name;
526
527 name = pt_image_name(NULL);
528 ptu_null(name);
529
530 return ptu_passed();
531 }
532
read_empty(struct image_fixture * ifix)533 static struct ptunit_result read_empty(struct image_fixture *ifix)
534 {
535 struct pt_asid asid;
536 uint8_t buffer[] = { 0xcc, 0xcc };
537 int status, isid;
538
539 pt_asid_init(&asid);
540
541 isid = -1;
542 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
543 &asid, 0x1000ull);
544 ptu_int_eq(status, -pte_nomap);
545 ptu_int_eq(isid, -1);
546 ptu_uint_eq(buffer[0], 0xcc);
547 ptu_uint_eq(buffer[1], 0xcc);
548
549 return ptu_passed();
550 }
551
overlap_front(struct image_fixture * ifix)552 static struct ptunit_result overlap_front(struct image_fixture *ifix)
553 {
554 uint8_t buffer[] = { 0xcc, 0xcc };
555 int status, isid;
556
557 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
558 0x1001ull, 1);
559 ptu_int_eq(status, 0);
560
561 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
562 0x1000ull, 2);
563 ptu_int_eq(status, 0);
564
565 isid = -1;
566 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
567 0x1010ull);
568 ptu_int_eq(status, 1);
569 ptu_int_eq(isid, 1);
570 ptu_uint_eq(buffer[0], 0x0f);
571 ptu_uint_eq(buffer[1], 0xcc);
572
573 buffer[0] = 0xcc;
574
575 isid = -1;
576 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
577 0x100full);
578 ptu_int_eq(status, 1);
579 ptu_int_eq(isid, 2);
580 ptu_uint_eq(buffer[0], 0x0f);
581 ptu_uint_eq(buffer[1], 0xcc);
582
583 return ptu_passed();
584 }
585
overlap_back(struct image_fixture * ifix)586 static struct ptunit_result overlap_back(struct image_fixture *ifix)
587 {
588 uint8_t buffer[] = { 0xcc, 0xcc };
589 int status, isid;
590
591 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
592 0x1000ull, 1);
593 ptu_int_eq(status, 0);
594
595 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
596 0x1001ull, 2);
597 ptu_int_eq(status, 0);
598
599 isid = -1;
600 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
601 0x1000ull);
602 ptu_int_eq(status, 1);
603 ptu_int_eq(isid, 1);
604 ptu_uint_eq(buffer[0], 0x00);
605 ptu_uint_eq(buffer[1], 0xcc);
606
607 isid = -1;
608 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
609 0x1010ull);
610 ptu_int_eq(status, 1);
611 ptu_int_eq(isid, 2);
612 ptu_uint_eq(buffer[0], 0x0f);
613 ptu_uint_eq(buffer[1], 0xcc);
614
615 isid = -1;
616 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
617 0x1001ull);
618 ptu_int_eq(status, 1);
619 ptu_int_eq(isid, 2);
620 ptu_uint_eq(buffer[0], 0x00);
621 ptu_uint_eq(buffer[1], 0xcc);
622
623 return ptu_passed();
624 }
625
overlap_multiple(struct image_fixture * ifix)626 static struct ptunit_result overlap_multiple(struct image_fixture *ifix)
627 {
628 uint8_t buffer[] = { 0xcc, 0xcc };
629 int status, isid;
630
631 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
632 0x1000ull, 1);
633 ptu_int_eq(status, 0);
634
635 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
636 0x1010ull, 2);
637 ptu_int_eq(status, 0);
638
639 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
640 0x1008ull, 3);
641 ptu_int_eq(status, 0);
642
643 isid = -1;
644 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
645 0x1007ull);
646 ptu_int_eq(status, 1);
647 ptu_int_eq(isid, 1);
648 ptu_uint_eq(buffer[0], 0x07);
649 ptu_uint_eq(buffer[1], 0xcc);
650
651 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
652 0x1008ull);
653 ptu_int_eq(status, 1);
654 ptu_int_eq(isid, 3);
655 ptu_uint_eq(buffer[0], 0x00);
656 ptu_uint_eq(buffer[1], 0xcc);
657
658 isid = -1;
659 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
660 0x1017ull);
661 ptu_int_eq(status, 1);
662 ptu_int_eq(isid, 3);
663 ptu_uint_eq(buffer[0], 0x0f);
664 ptu_uint_eq(buffer[1], 0xcc);
665
666 isid = -1;
667 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
668 0x1018ull);
669 ptu_int_eq(status, 1);
670 ptu_int_eq(isid, 2);
671 ptu_uint_eq(buffer[0], 0x08);
672 ptu_uint_eq(buffer[1], 0xcc);
673
674 return ptu_passed();
675 }
676
overlap_mid(struct image_fixture * ifix)677 static struct ptunit_result overlap_mid(struct image_fixture *ifix)
678 {
679 uint8_t buffer[] = { 0xcc, 0xcc };
680 int status, isid;
681
682 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
683 0x1000ull, 1);
684 ptu_int_eq(status, 0);
685
686 ifix->section[1].size = 0x8;
687 ifix->mapping[1].size = 0x8;
688 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
689 0x1004ull, 2);
690 ptu_int_eq(status, 0);
691
692 isid = -1;
693 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
694 0x1003ull);
695 ptu_int_eq(status, 1);
696 ptu_int_eq(isid, 1);
697 ptu_uint_eq(buffer[0], 0x03);
698 ptu_uint_eq(buffer[1], 0xcc);
699
700 isid = -1;
701 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
702 0x1004ull);
703 ptu_int_eq(status, 1);
704 ptu_int_eq(isid, 2);
705 ptu_uint_eq(buffer[0], 0x00);
706 ptu_uint_eq(buffer[1], 0xcc);
707
708 isid = -1;
709 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
710 0x100bull);
711 ptu_int_eq(status, 1);
712 ptu_int_eq(isid, 2);
713 ptu_uint_eq(buffer[0], 0x07);
714 ptu_uint_eq(buffer[1], 0xcc);
715
716 isid = -1;
717 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
718 0x100cull);
719 ptu_int_eq(status, 1);
720 ptu_int_eq(isid, 1);
721 ptu_uint_eq(buffer[0], 0x0c);
722 ptu_uint_eq(buffer[1], 0xcc);
723
724 return ptu_passed();
725 }
726
contained(struct image_fixture * ifix)727 static struct ptunit_result contained(struct image_fixture *ifix)
728 {
729 uint8_t buffer[] = { 0xcc, 0xcc };
730 int status, isid;
731
732 ifix->section[0].size = 0x8;
733 ifix->mapping[0].size = 0x8;
734 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
735 0x1004ull, 1);
736 ptu_int_eq(status, 0);
737
738 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
739 0x1000ull, 2);
740 ptu_int_eq(status, 0);
741
742 isid = -1;
743 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
744 0x1008ull);
745 ptu_int_eq(status, 1);
746 ptu_int_eq(isid, 2);
747 ptu_uint_eq(buffer[0], 0x08);
748 ptu_uint_eq(buffer[1], 0xcc);
749
750 return ptu_passed();
751 }
752
contained_multiple(struct image_fixture * ifix)753 static struct ptunit_result contained_multiple(struct image_fixture *ifix)
754 {
755 uint8_t buffer[] = { 0xcc, 0xcc };
756 int status, isid;
757
758 ifix->section[0].size = 0x2;
759 ifix->mapping[0].size = 0x2;
760 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
761 0x1004ull, 1);
762 ptu_int_eq(status, 0);
763
764 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
765 0x1008ull, 2);
766 ptu_int_eq(status, 0);
767
768 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
769 0x1000ull, 3);
770 ptu_int_eq(status, 0);
771
772 isid = -1;
773 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
774 0x1004ull);
775 ptu_int_eq(status, 1);
776 ptu_int_eq(isid, 3);
777 ptu_uint_eq(buffer[0], 0x04);
778 ptu_uint_eq(buffer[1], 0xcc);
779
780 isid = -1;
781 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
782 0x1008ull);
783 ptu_int_eq(status, 1);
784 ptu_int_eq(isid, 3);
785 ptu_uint_eq(buffer[0], 0x08);
786 ptu_uint_eq(buffer[1], 0xcc);
787
788 return ptu_passed();
789 }
790
contained_back(struct image_fixture * ifix)791 static struct ptunit_result contained_back(struct image_fixture *ifix)
792 {
793 uint8_t buffer[] = { 0xcc, 0xcc };
794 int status, isid;
795
796 ifix->section[0].size = 0x8;
797 ifix->mapping[0].size = 0x8;
798 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
799 0x1004ull, 1);
800 ptu_int_eq(status, 0);
801
802 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
803 0x100cull, 2);
804 ptu_int_eq(status, 0);
805
806 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
807 0x1000ull, 3);
808 ptu_int_eq(status, 0);
809
810 isid = -1;
811 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
812 0x1004ull);
813 ptu_int_eq(status, 1);
814 ptu_int_eq(isid, 3);
815 ptu_uint_eq(buffer[0], 0x04);
816 ptu_uint_eq(buffer[1], 0xcc);
817
818 isid = -1;
819 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
820 0x100cull);
821 ptu_int_eq(status, 1);
822 ptu_int_eq(isid, 3);
823 ptu_uint_eq(buffer[0], 0x0c);
824 ptu_uint_eq(buffer[1], 0xcc);
825
826 isid = -1;
827 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
828 0x100full);
829 ptu_int_eq(status, 1);
830 ptu_int_eq(isid, 3);
831 ptu_uint_eq(buffer[0], 0x0f);
832 ptu_uint_eq(buffer[1], 0xcc);
833
834 isid = -1;
835 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
836 0x1010ull);
837 ptu_int_eq(status, 1);
838 ptu_int_eq(isid, 2);
839 ptu_uint_eq(buffer[0], 0x04);
840 ptu_uint_eq(buffer[1], 0xcc);
841
842 return ptu_passed();
843 }
844
same(struct image_fixture * ifix)845 static struct ptunit_result same(struct image_fixture *ifix)
846 {
847 uint8_t buffer[] = { 0xcc, 0xcc };
848 int status, isid;
849
850 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
851 0x1000ull, 1);
852 ptu_int_eq(status, 0);
853
854 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
855 0x1000ull, 1);
856 ptu_int_eq(status, 0);
857
858 isid = -1;
859 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
860 0x1008ull);
861 ptu_int_eq(status, 1);
862 ptu_int_eq(isid, 1);
863 ptu_uint_eq(buffer[0], 0x08);
864 ptu_uint_eq(buffer[1], 0xcc);
865
866 return ptu_passed();
867 }
868
same_different_isid(struct image_fixture * ifix)869 static struct ptunit_result same_different_isid(struct image_fixture *ifix)
870 {
871 uint8_t buffer[] = { 0xcc, 0xcc };
872 int status, isid;
873
874 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
875 0x1000ull, 1);
876 ptu_int_eq(status, 0);
877
878 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
879 0x1000ull, 2);
880 ptu_int_eq(status, 0);
881
882 isid = -1;
883 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
884 0x1008ull);
885 ptu_int_eq(status, 1);
886 ptu_int_eq(isid, 2);
887 ptu_uint_eq(buffer[0], 0x08);
888 ptu_uint_eq(buffer[1], 0xcc);
889
890 return ptu_passed();
891 }
892
same_different_offset(struct image_fixture * ifix)893 static struct ptunit_result same_different_offset(struct image_fixture *ifix)
894 {
895 uint8_t buffer[] = { 0xcc, 0xcc }, i;
896 int status, isid, index;
897
898 /* Add another section from a different part of the same file as an
899 * existing section.
900 */
901 index = ifix_add_section(ifix, ifix->section[0].filename);
902 ptu_int_gt(index, 0);
903
904 ifix->section[index].offset = ifix->section[0].offset + 0x10;
905 ptu_uint_eq(ifix->section[index].size, ifix->section[0].size);
906
907 /* Change the content of the new section so we can distinguish them. */
908 for (i = 0; i < ifix->mapping[index].size; ++i)
909 ifix->mapping[index].content[i] += 0x10;
910
911
912 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
913 0x1000ull, 0);
914 ptu_int_eq(status, 0);
915
916 status = pt_image_add(&ifix->image, &ifix->section[index],
917 &ifix->asid[0], 0x1000ull, 0);
918 ptu_int_eq(status, 0);
919
920 isid = -1;
921 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
922 0x1000ull);
923 ptu_int_eq(status, 1);
924 ptu_int_eq(isid, 0);
925 ptu_uint_eq(buffer[0], 0x10);
926 ptu_uint_eq(buffer[1], 0xcc);
927
928 isid = -1;
929 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
930 0x100full);
931 ptu_int_eq(status, 1);
932 ptu_int_eq(isid, 0);
933 ptu_uint_eq(buffer[0], 0x1f);
934 ptu_uint_eq(buffer[1], 0xcc);
935
936 return ptu_passed();
937 }
938
adjacent(struct image_fixture * ifix)939 static struct ptunit_result adjacent(struct image_fixture *ifix)
940 {
941 uint8_t buffer[] = { 0xcc, 0xcc };
942 int status, isid;
943
944 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
945 0x1000ull, 1);
946 ptu_int_eq(status, 0);
947
948 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
949 0x1000ull - ifix->section[1].size, 2);
950 ptu_int_eq(status, 0);
951
952 status = pt_image_add(&ifix->image, &ifix->section[2], &ifix->asid[0],
953 0x1000ull + ifix->section[0].size, 3);
954 ptu_int_eq(status, 0);
955
956 isid = -1;
957 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
958 0x1000ull);
959 ptu_int_eq(status, 1);
960 ptu_int_eq(isid, 1);
961 ptu_uint_eq(buffer[0], 0x00);
962 ptu_uint_eq(buffer[1], 0xcc);
963
964 isid = -1;
965 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
966 0xfffull);
967 ptu_int_eq(status, 1);
968 ptu_int_eq(isid, 2);
969 ptu_uint_eq(buffer[0],
970 ifix->mapping[1].content[ifix->mapping[1].size - 1]);
971 ptu_uint_eq(buffer[1], 0xcc);
972
973 isid = -1;
974 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
975 0x1000ull + ifix->section[0].size);
976 ptu_int_eq(status, 1);
977 ptu_int_eq(isid, 3);
978 ptu_uint_eq(buffer[0], 0x00);
979 ptu_uint_eq(buffer[1], 0xcc);
980
981 return ptu_passed();
982 }
983
read_null(struct image_fixture * ifix)984 static struct ptunit_result read_null(struct image_fixture *ifix)
985 {
986 uint8_t buffer;
987 int status, isid;
988
989 status = pt_image_read(NULL, &isid, &buffer, 1, &ifix->asid[0],
990 0x1000ull);
991 ptu_int_eq(status, -pte_internal);
992
993 status = pt_image_read(&ifix->image, NULL, &buffer, 1, &ifix->asid[0],
994 0x1000ull);
995 ptu_int_eq(status, -pte_internal);
996
997 status = pt_image_read(&ifix->image, &isid, NULL, 1, &ifix->asid[0],
998 0x1000ull);
999 ptu_int_eq(status, -pte_internal);
1000
1001 status = pt_image_read(&ifix->image, &isid, &buffer, 1, NULL,
1002 0x1000ull);
1003 ptu_int_eq(status, -pte_internal);
1004
1005 return ptu_passed();
1006 }
1007
read(struct image_fixture * ifix)1008 static struct ptunit_result read(struct image_fixture *ifix)
1009 {
1010 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1011 int status, isid;
1012
1013 isid = -1;
1014 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1015 0x2003ull);
1016 ptu_int_eq(status, 2);
1017 ptu_int_eq(isid, 11);
1018 ptu_uint_eq(buffer[0], 0x03);
1019 ptu_uint_eq(buffer[1], 0x04);
1020 ptu_uint_eq(buffer[2], 0xcc);
1021
1022 return ptu_passed();
1023 }
1024
read_asid(struct image_fixture * ifix)1025 static struct ptunit_result read_asid(struct image_fixture *ifix)
1026 {
1027 uint8_t buffer[] = { 0xcc, 0xcc };
1028 int status, isid;
1029
1030 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
1031 0x1000ull, 1);
1032 ptu_int_eq(status, 0);
1033
1034 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[1],
1035 0x1008ull, 2);
1036 ptu_int_eq(status, 0);
1037
1038 isid = -1;
1039 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
1040 0x1009ull);
1041 ptu_int_eq(status, 1);
1042 ptu_int_eq(isid, 1);
1043 ptu_uint_eq(buffer[0], 0x09);
1044 ptu_uint_eq(buffer[1], 0xcc);
1045
1046 isid = -1;
1047 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[1],
1048 0x1009ull);
1049 ptu_int_eq(status, 1);
1050 ptu_int_eq(isid, 2);
1051 ptu_uint_eq(buffer[0], 0x01);
1052 ptu_uint_eq(buffer[1], 0xcc);
1053
1054 return ptu_passed();
1055 }
1056
read_bad_asid(struct image_fixture * ifix)1057 static struct ptunit_result read_bad_asid(struct image_fixture *ifix)
1058 {
1059 uint8_t buffer[] = { 0xcc, 0xcc };
1060 int status, isid;
1061
1062 isid = -1;
1063 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1064 &ifix->asid[0], 0x2003ull);
1065 ptu_int_eq(status, -pte_nomap);
1066 ptu_int_eq(isid, -1);
1067 ptu_uint_eq(buffer[0], 0xcc);
1068 ptu_uint_eq(buffer[1], 0xcc);
1069
1070 return ptu_passed();
1071 }
1072
read_null_asid(struct image_fixture * ifix)1073 static struct ptunit_result read_null_asid(struct image_fixture *ifix)
1074 {
1075 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1076 int status, isid;
1077
1078 isid = -1;
1079 status = pt_image_read(&ifix->image, &isid, buffer, 2, NULL, 0x2003ull);
1080 ptu_int_eq(status, -pte_internal);
1081 ptu_int_eq(isid, -1);
1082 ptu_uint_eq(buffer[0], 0xcc);
1083 ptu_uint_eq(buffer[1], 0xcc);
1084
1085 return ptu_passed();
1086 }
1087
read_callback(struct image_fixture * ifix)1088 static struct ptunit_result read_callback(struct image_fixture *ifix)
1089 {
1090 uint8_t memory[] = { 0xdd, 0x01, 0x02, 0xdd };
1091 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1092 int status, isid;
1093
1094 status = pt_image_set_callback(&ifix->image, image_readmem_callback,
1095 memory);
1096 ptu_int_eq(status, 0);
1097
1098 isid = -1;
1099 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1100 0x3001ull);
1101 ptu_int_eq(status, 2);
1102 ptu_int_eq(isid, 0);
1103 ptu_uint_eq(buffer[0], 0x01);
1104 ptu_uint_eq(buffer[1], 0x02);
1105 ptu_uint_eq(buffer[2], 0xcc);
1106
1107 return ptu_passed();
1108 }
1109
read_nomem(struct image_fixture * ifix)1110 static struct ptunit_result read_nomem(struct image_fixture *ifix)
1111 {
1112 uint8_t buffer[] = { 0xcc, 0xcc };
1113 int status, isid;
1114
1115 isid = -1;
1116 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1117 &ifix->asid[1], 0x1010ull);
1118 ptu_int_eq(status, -pte_nomap);
1119 ptu_int_eq(isid, -1);
1120 ptu_uint_eq(buffer[0], 0xcc);
1121 ptu_uint_eq(buffer[1], 0xcc);
1122
1123 return ptu_passed();
1124 }
1125
read_truncated(struct image_fixture * ifix)1126 static struct ptunit_result read_truncated(struct image_fixture *ifix)
1127 {
1128 uint8_t buffer[] = { 0xcc, 0xcc };
1129 int status, isid;
1130
1131 isid = -1;
1132 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1133 &ifix->asid[0], 0x100full);
1134 ptu_int_eq(status, 1);
1135 ptu_int_eq(isid, 10);
1136 ptu_uint_eq(buffer[0], 0x0f);
1137 ptu_uint_eq(buffer[1], 0xcc);
1138
1139 return ptu_passed();
1140 }
1141
read_error(struct image_fixture * ifix)1142 static struct ptunit_result read_error(struct image_fixture *ifix)
1143 {
1144 uint8_t buffer[] = { 0xcc };
1145 int status, isid;
1146
1147 ifix->mapping[0].errcode = -pte_nosync;
1148
1149 isid = -1;
1150 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
1151 0x1000ull);
1152 ptu_int_eq(status, -pte_nosync);
1153 ptu_int_eq(isid, 10);
1154 ptu_uint_eq(buffer[0], 0xcc);
1155
1156 return ptu_passed();
1157 }
1158
read_spurious_error(struct image_fixture * ifix)1159 static struct ptunit_result read_spurious_error(struct image_fixture *ifix)
1160 {
1161 uint8_t buffer[] = { 0xcc, 0xcc };
1162 int status, isid;
1163
1164 isid = -1;
1165 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
1166 0x1000ull);
1167 ptu_int_eq(status, 1);
1168 ptu_int_eq(isid, 10);
1169 ptu_uint_eq(buffer[0], 0x00);
1170 ptu_uint_eq(buffer[1], 0xcc);
1171
1172 ifix->mapping[0].errcode = -pte_nosync;
1173
1174 isid = -1;
1175 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
1176 0x1005ull);
1177 ptu_int_eq(status, -pte_nosync);
1178 ptu_int_eq(isid, 10);
1179 ptu_uint_eq(buffer[0], 0x00);
1180
1181 return ptu_passed();
1182 }
1183
remove_section(struct image_fixture * ifix)1184 static struct ptunit_result remove_section(struct image_fixture *ifix)
1185 {
1186 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1187 int status, isid;
1188
1189 isid = -1;
1190 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1191 0x1001ull);
1192 ptu_int_eq(status, 2);
1193 ptu_int_eq(isid, 10);
1194 ptu_uint_eq(buffer[0], 0x01);
1195 ptu_uint_eq(buffer[1], 0x02);
1196 ptu_uint_eq(buffer[2], 0xcc);
1197
1198 status = pt_image_remove(&ifix->image, &ifix->section[0],
1199 &ifix->asid[0], 0x1000ull);
1200 ptu_int_eq(status, 0);
1201
1202 ptu_int_ne(ifix->status[0].deleted, 0);
1203 ptu_int_eq(ifix->status[1].deleted, 0);
1204
1205 isid = -1;
1206 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1207 &ifix->asid[0], 0x1003ull);
1208 ptu_int_eq(status, -pte_nomap);
1209 ptu_int_eq(isid, -1);
1210 ptu_uint_eq(buffer[0], 0x01);
1211 ptu_uint_eq(buffer[1], 0x02);
1212 ptu_uint_eq(buffer[2], 0xcc);
1213
1214 isid = -1;
1215 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1216 0x2003ull);
1217 ptu_int_eq(status, 2);
1218 ptu_int_eq(isid, 11);
1219 ptu_uint_eq(buffer[0], 0x03);
1220 ptu_uint_eq(buffer[1], 0x04);
1221 ptu_uint_eq(buffer[2], 0xcc);
1222
1223 return ptu_passed();
1224 }
1225
remove_bad_vaddr(struct image_fixture * ifix)1226 static struct ptunit_result remove_bad_vaddr(struct image_fixture *ifix)
1227 {
1228 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1229 int status, isid;
1230
1231 isid = -1;
1232 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1233 0x1001ull);
1234 ptu_int_eq(status, 2);
1235 ptu_int_eq(isid, 10);
1236 ptu_uint_eq(buffer[0], 0x01);
1237 ptu_uint_eq(buffer[1], 0x02);
1238 ptu_uint_eq(buffer[2], 0xcc);
1239
1240 status = pt_image_remove(&ifix->image, &ifix->section[0],
1241 &ifix->asid[0], 0x2000ull);
1242 ptu_int_eq(status, -pte_bad_image);
1243
1244 ptu_int_eq(ifix->status[0].deleted, 0);
1245 ptu_int_eq(ifix->status[1].deleted, 0);
1246
1247 isid = -1;
1248 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1249 0x1003ull);
1250 ptu_int_eq(status, 2);
1251 ptu_int_eq(isid, 10);
1252 ptu_uint_eq(buffer[0], 0x03);
1253 ptu_uint_eq(buffer[1], 0x04);
1254 ptu_uint_eq(buffer[2], 0xcc);
1255
1256 isid = -1;
1257 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1258 0x2005ull);
1259 ptu_int_eq(status, 2);
1260 ptu_int_eq(isid, 11);
1261 ptu_uint_eq(buffer[0], 0x05);
1262 ptu_uint_eq(buffer[1], 0x06);
1263 ptu_uint_eq(buffer[2], 0xcc);
1264
1265 return ptu_passed();
1266 }
1267
remove_bad_asid(struct image_fixture * ifix)1268 static struct ptunit_result remove_bad_asid(struct image_fixture *ifix)
1269 {
1270 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1271 int status, isid;
1272
1273 isid = -1;
1274 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1275 0x1001ull);
1276 ptu_int_eq(status, 2);
1277 ptu_int_eq(isid, 10);
1278 ptu_uint_eq(buffer[0], 0x01);
1279 ptu_uint_eq(buffer[1], 0x02);
1280 ptu_uint_eq(buffer[2], 0xcc);
1281
1282 status = pt_image_remove(&ifix->image, &ifix->section[0],
1283 &ifix->asid[1], 0x1000ull);
1284 ptu_int_eq(status, -pte_bad_image);
1285
1286 ptu_int_eq(ifix->status[0].deleted, 0);
1287 ptu_int_eq(ifix->status[1].deleted, 0);
1288
1289 isid = -1;
1290 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1291 0x1003ull);
1292 ptu_int_eq(status, 2);
1293 ptu_int_eq(isid, 10);
1294 ptu_uint_eq(buffer[0], 0x03);
1295 ptu_uint_eq(buffer[1], 0x04);
1296 ptu_uint_eq(buffer[2], 0xcc);
1297
1298 isid = -1;
1299 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1300 0x2005ull);
1301 ptu_int_eq(status, 2);
1302 ptu_int_eq(isid, 11);
1303 ptu_uint_eq(buffer[0], 0x05);
1304 ptu_uint_eq(buffer[1], 0x06);
1305 ptu_uint_eq(buffer[2], 0xcc);
1306
1307 return ptu_passed();
1308 }
1309
remove_by_filename(struct image_fixture * ifix)1310 static struct ptunit_result remove_by_filename(struct image_fixture *ifix)
1311 {
1312 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1313 int status, isid;
1314
1315 isid = -1;
1316 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1317 0x1001ull);
1318 ptu_int_eq(status, 2);
1319 ptu_int_eq(isid, 10);
1320 ptu_uint_eq(buffer[0], 0x01);
1321 ptu_uint_eq(buffer[1], 0x02);
1322 ptu_uint_eq(buffer[2], 0xcc);
1323
1324 status = pt_image_remove_by_filename(&ifix->image,
1325 ifix->section[0].filename,
1326 &ifix->asid[0]);
1327 ptu_int_eq(status, 1);
1328
1329 ptu_int_ne(ifix->status[0].deleted, 0);
1330 ptu_int_eq(ifix->status[1].deleted, 0);
1331
1332 isid = -1;
1333 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1334 &ifix->asid[0], 0x1003ull);
1335 ptu_int_eq(status, -pte_nomap);
1336 ptu_int_eq(isid, -1);
1337 ptu_uint_eq(buffer[0], 0x01);
1338 ptu_uint_eq(buffer[1], 0x02);
1339 ptu_uint_eq(buffer[2], 0xcc);
1340
1341 isid = -1;
1342 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1343 0x2003ull);
1344 ptu_int_eq(status, 2);
1345 ptu_int_eq(isid, 11);
1346 ptu_uint_eq(buffer[0], 0x03);
1347 ptu_uint_eq(buffer[1], 0x04);
1348 ptu_uint_eq(buffer[2], 0xcc);
1349
1350 return ptu_passed();
1351 }
1352
1353 static struct ptunit_result
remove_by_filename_bad_asid(struct image_fixture * ifix)1354 remove_by_filename_bad_asid(struct image_fixture *ifix)
1355 {
1356 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1357 int status, isid;
1358
1359 isid = -1;
1360 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1361 0x1001ull);
1362 ptu_int_eq(status, 2);
1363 ptu_int_eq(isid, 10);
1364 ptu_uint_eq(buffer[0], 0x01);
1365 ptu_uint_eq(buffer[1], 0x02);
1366 ptu_uint_eq(buffer[2], 0xcc);
1367
1368 status = pt_image_remove_by_filename(&ifix->image,
1369 ifix->section[0].filename,
1370 &ifix->asid[1]);
1371 ptu_int_eq(status, 0);
1372
1373 ptu_int_eq(ifix->status[0].deleted, 0);
1374 ptu_int_eq(ifix->status[1].deleted, 0);
1375
1376 isid = -1;
1377 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1378 0x1003ull);
1379 ptu_int_eq(status, 2);
1380 ptu_int_eq(isid, 10);
1381 ptu_uint_eq(buffer[0], 0x03);
1382 ptu_uint_eq(buffer[1], 0x04);
1383 ptu_uint_eq(buffer[2], 0xcc);
1384
1385 isid = -1;
1386 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1387 0x2005ull);
1388 ptu_int_eq(status, 2);
1389 ptu_int_eq(isid, 11);
1390 ptu_uint_eq(buffer[0], 0x05);
1391 ptu_uint_eq(buffer[1], 0x06);
1392 ptu_uint_eq(buffer[2], 0xcc);
1393
1394 return ptu_passed();
1395 }
1396
remove_none_by_filename(struct image_fixture * ifix)1397 static struct ptunit_result remove_none_by_filename(struct image_fixture *ifix)
1398 {
1399 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1400 int status, isid;
1401
1402 status = pt_image_remove_by_filename(&ifix->image, "bad-name",
1403 &ifix->asid[0]);
1404 ptu_int_eq(status, 0);
1405
1406 ptu_int_eq(ifix->status[0].deleted, 0);
1407 ptu_int_eq(ifix->status[1].deleted, 0);
1408
1409 isid = -1;
1410 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1411 0x1003ull);
1412 ptu_int_eq(status, 2);
1413 ptu_int_eq(isid, 10);
1414 ptu_uint_eq(buffer[0], 0x03);
1415 ptu_uint_eq(buffer[1], 0x04);
1416 ptu_uint_eq(buffer[2], 0xcc);
1417
1418 isid = -1;
1419 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1420 0x2001ull);
1421 ptu_int_eq(status, 2);
1422 ptu_int_eq(isid, 11);
1423 ptu_uint_eq(buffer[0], 0x01);
1424 ptu_uint_eq(buffer[1], 0x02);
1425 ptu_uint_eq(buffer[2], 0xcc);
1426
1427 return ptu_passed();
1428 }
1429
remove_all_by_filename(struct image_fixture * ifix)1430 static struct ptunit_result remove_all_by_filename(struct image_fixture *ifix)
1431 {
1432 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1433 int status, isid;
1434
1435 ifix->section[0].filename = "same-name";
1436 ifix->section[1].filename = "same-name";
1437
1438 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
1439 0x1000ull, 1);
1440 ptu_int_eq(status, 0);
1441
1442 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
1443 0x2000ull, 2);
1444 ptu_int_eq(status, 0);
1445
1446 isid = -1;
1447 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1448 0x1001ull);
1449 ptu_int_eq(status, 2);
1450 ptu_int_eq(isid, 1);
1451 ptu_uint_eq(buffer[0], 0x01);
1452 ptu_uint_eq(buffer[1], 0x02);
1453 ptu_uint_eq(buffer[2], 0xcc);
1454
1455 status = pt_image_remove_by_filename(&ifix->image, "same-name",
1456 &ifix->asid[0]);
1457 ptu_int_eq(status, 2);
1458
1459 ptu_int_ne(ifix->status[0].deleted, 0);
1460 ptu_int_ne(ifix->status[1].deleted, 0);
1461
1462 isid = -1;
1463 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1464 &ifix->asid[0], 0x1003ull);
1465 ptu_int_eq(status, -pte_nomap);
1466 ptu_int_eq(isid, -1);
1467 ptu_uint_eq(buffer[0], 0x01);
1468 ptu_uint_eq(buffer[1], 0x02);
1469 ptu_uint_eq(buffer[2], 0xcc);
1470
1471 isid = -1;
1472 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1473 &ifix->asid[0], 0x2003ull);
1474 ptu_int_eq(status, -pte_nomap);
1475 ptu_int_eq(isid, -1);
1476 ptu_uint_eq(buffer[0], 0x01);
1477 ptu_uint_eq(buffer[1], 0x02);
1478 ptu_uint_eq(buffer[2], 0xcc);
1479
1480 return ptu_passed();
1481 }
1482
remove_by_asid(struct image_fixture * ifix)1483 static struct ptunit_result remove_by_asid(struct image_fixture *ifix)
1484 {
1485 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1486 int status, isid;
1487
1488 isid = -1;
1489 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1490 0x1001ull);
1491 ptu_int_eq(status, 2);
1492 ptu_int_eq(isid, 10);
1493 ptu_uint_eq(buffer[0], 0x01);
1494 ptu_uint_eq(buffer[1], 0x02);
1495 ptu_uint_eq(buffer[2], 0xcc);
1496
1497 status = pt_image_remove_by_asid(&ifix->image, &ifix->asid[0]);
1498 ptu_int_eq(status, 1);
1499
1500 ptu_int_ne(ifix->status[0].deleted, 0);
1501 ptu_int_eq(ifix->status[1].deleted, 0);
1502
1503 isid = -1;
1504 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1505 &ifix->asid[0], 0x1003ull);
1506 ptu_int_eq(status, -pte_nomap);
1507 ptu_int_eq(isid, -1);
1508 ptu_uint_eq(buffer[0], 0x01);
1509 ptu_uint_eq(buffer[1], 0x02);
1510 ptu_uint_eq(buffer[2], 0xcc);
1511
1512 isid = -1;
1513 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1514 0x2003ull);
1515 ptu_int_eq(status, 2);
1516 ptu_int_eq(isid, 11);
1517 ptu_uint_eq(buffer[0], 0x03);
1518 ptu_uint_eq(buffer[1], 0x04);
1519 ptu_uint_eq(buffer[2], 0xcc);
1520
1521 return ptu_passed();
1522 }
1523
copy_empty(struct image_fixture * ifix)1524 static struct ptunit_result copy_empty(struct image_fixture *ifix)
1525 {
1526 struct pt_asid asid;
1527 uint8_t buffer[] = { 0xcc, 0xcc };
1528 int status, isid;
1529
1530 pt_asid_init(&asid);
1531
1532 status = pt_image_copy(&ifix->copy, &ifix->image);
1533 ptu_int_eq(status, 0);
1534
1535 isid = -1;
1536 status = pt_image_read(&ifix->copy, &isid, buffer, sizeof(buffer),
1537 &asid, 0x1000ull);
1538 ptu_int_eq(status, -pte_nomap);
1539 ptu_int_eq(isid, -1);
1540 ptu_uint_eq(buffer[0], 0xcc);
1541 ptu_uint_eq(buffer[1], 0xcc);
1542
1543 return ptu_passed();
1544 }
1545
copy(struct image_fixture * ifix)1546 static struct ptunit_result copy(struct image_fixture *ifix)
1547 {
1548 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1549 int status, isid;
1550
1551 status = pt_image_copy(&ifix->copy, &ifix->image);
1552 ptu_int_eq(status, 0);
1553
1554 isid = -1;
1555 status = pt_image_read(&ifix->copy, &isid, buffer, 2, &ifix->asid[1],
1556 0x2003ull);
1557 ptu_int_eq(status, 2);
1558 ptu_int_eq(isid, 11);
1559 ptu_uint_eq(buffer[0], 0x03);
1560 ptu_uint_eq(buffer[1], 0x04);
1561 ptu_uint_eq(buffer[2], 0xcc);
1562
1563 return ptu_passed();
1564 }
1565
copy_self(struct image_fixture * ifix)1566 static struct ptunit_result copy_self(struct image_fixture *ifix)
1567 {
1568 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1569 int status, isid;
1570
1571 status = pt_image_copy(&ifix->image, &ifix->image);
1572 ptu_int_eq(status, 0);
1573
1574 isid = -1;
1575 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1576 0x2003ull);
1577 ptu_int_eq(status, 2);
1578 ptu_int_eq(isid, 11);
1579 ptu_uint_eq(buffer[0], 0x03);
1580 ptu_uint_eq(buffer[1], 0x04);
1581 ptu_uint_eq(buffer[2], 0xcc);
1582
1583 return ptu_passed();
1584 }
1585
copy_shrink(struct image_fixture * ifix)1586 static struct ptunit_result copy_shrink(struct image_fixture *ifix)
1587 {
1588 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1589 int status, isid;
1590
1591 status = pt_image_add(&ifix->copy, &ifix->section[1], &ifix->asid[1],
1592 0x2000ull, 1);
1593 ptu_int_eq(status, 0);
1594
1595 status = pt_image_copy(&ifix->copy, &ifix->image);
1596 ptu_int_eq(status, 0);
1597
1598 isid = -1;
1599 status = pt_image_read(&ifix->copy, &isid, buffer, 2, &ifix->asid[1],
1600 0x2003ull);
1601 ptu_int_eq(status, 2);
1602 ptu_int_eq(isid, 11);
1603 ptu_uint_eq(buffer[0], 0x03);
1604 ptu_uint_eq(buffer[1], 0x04);
1605 ptu_uint_eq(buffer[2], 0xcc);
1606
1607 return ptu_passed();
1608 }
1609
copy_split(struct image_fixture * ifix)1610 static struct ptunit_result copy_split(struct image_fixture *ifix)
1611 {
1612 uint8_t buffer[] = { 0xcc, 0xcc };
1613 int status, isid;
1614
1615 status = pt_image_add(&ifix->copy, &ifix->section[0], &ifix->asid[0],
1616 0x2000ull, 1);
1617 ptu_int_eq(status, 0);
1618
1619 ifix->section[1].size = 0x7;
1620 ifix->mapping[1].size = 0x7;
1621
1622 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
1623 0x2001ull, 2);
1624 ptu_int_eq(status, 0);
1625
1626 ifix->section[2].size = 0x8;
1627 ifix->mapping[2].size = 0x8;
1628
1629 status = pt_image_add(&ifix->image, &ifix->section[2], &ifix->asid[0],
1630 0x2008ull, 3);
1631 ptu_int_eq(status, 0);
1632
1633 status = pt_image_copy(&ifix->copy, &ifix->image);
1634 ptu_int_eq(status, 0);
1635
1636 isid = -1;
1637 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1638 0x2003ull);
1639 ptu_int_eq(status, 1);
1640 ptu_int_eq(isid, 2);
1641 ptu_uint_eq(buffer[0], 0x02);
1642 ptu_uint_eq(buffer[1], 0xcc);
1643
1644 isid = -1;
1645 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1646 0x2009ull);
1647 ptu_int_eq(status, 1);
1648 ptu_int_eq(isid, 3);
1649 ptu_uint_eq(buffer[0], 0x01);
1650 ptu_uint_eq(buffer[1], 0xcc);
1651
1652 isid = -1;
1653 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1654 0x2000ull);
1655 ptu_int_eq(status, 1);
1656 ptu_int_eq(isid, 1);
1657 ptu_uint_eq(buffer[0], 0x00);
1658 ptu_uint_eq(buffer[1], 0xcc);
1659
1660 return ptu_passed();
1661 }
1662
copy_merge(struct image_fixture * ifix)1663 static struct ptunit_result copy_merge(struct image_fixture *ifix)
1664 {
1665 uint8_t buffer[] = { 0xcc, 0xcc };
1666 int status, isid;
1667
1668 ifix->section[1].size = 0x8;
1669 ifix->mapping[1].size = 0x8;
1670
1671 status = pt_image_add(&ifix->copy, &ifix->section[1], &ifix->asid[0],
1672 0x2000ull, 1);
1673 ptu_int_eq(status, 0);
1674
1675 ifix->section[2].size = 0x8;
1676 ifix->mapping[2].size = 0x8;
1677
1678 status = pt_image_add(&ifix->copy, &ifix->section[2], &ifix->asid[0],
1679 0x2008ull, 2);
1680 ptu_int_eq(status, 0);
1681
1682 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
1683 0x2000ull, 3);
1684 ptu_int_eq(status, 0);
1685
1686 status = pt_image_copy(&ifix->copy, &ifix->image);
1687 ptu_int_eq(status, 0);
1688
1689 isid = -1;
1690 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1691 0x2003ull);
1692 ptu_int_eq(status, 1);
1693 ptu_int_eq(isid, 3);
1694 ptu_uint_eq(buffer[0], 0x03);
1695 ptu_uint_eq(buffer[1], 0xcc);
1696
1697 isid = -1;
1698 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1699 0x200aull);
1700 ptu_int_eq(status, 1);
1701 ptu_int_eq(isid, 3);
1702 ptu_uint_eq(buffer[0], 0x0a);
1703 ptu_uint_eq(buffer[1], 0xcc);
1704
1705 return ptu_passed();
1706 }
1707
copy_overlap(struct image_fixture * ifix)1708 static struct ptunit_result copy_overlap(struct image_fixture *ifix)
1709 {
1710 uint8_t buffer[] = { 0xcc, 0xcc };
1711 int status, isid;
1712
1713 status = pt_image_add(&ifix->copy, &ifix->section[0], &ifix->asid[0],
1714 0x2000ull, 1);
1715 ptu_int_eq(status, 0);
1716
1717 status = pt_image_add(&ifix->copy, &ifix->section[1], &ifix->asid[0],
1718 0x2010ull, 2);
1719 ptu_int_eq(status, 0);
1720
1721 status = pt_image_add(&ifix->image, &ifix->section[2], &ifix->asid[0],
1722 0x2008ull, 3);
1723 ptu_int_eq(status, 0);
1724
1725 status = pt_image_copy(&ifix->copy, &ifix->image);
1726 ptu_int_eq(status, 0);
1727
1728 isid = -1;
1729 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1730 0x2003ull);
1731 ptu_int_eq(status, 1);
1732 ptu_int_eq(isid, 1);
1733 ptu_uint_eq(buffer[0], 0x03);
1734 ptu_uint_eq(buffer[1], 0xcc);
1735
1736 isid = -1;
1737 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1738 0x200aull);
1739 ptu_int_eq(status, 1);
1740 ptu_int_eq(isid, 3);
1741 ptu_uint_eq(buffer[0], 0x02);
1742 ptu_uint_eq(buffer[1], 0xcc);
1743
1744 isid = -1;
1745 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1746 0x2016ull);
1747 ptu_int_eq(status, 1);
1748 ptu_int_eq(isid, 3);
1749 ptu_uint_eq(buffer[0], 0x0e);
1750 ptu_uint_eq(buffer[1], 0xcc);
1751
1752 isid = -1;
1753 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1754 0x2019ull);
1755 ptu_int_eq(status, 1);
1756 ptu_int_eq(isid, 2);
1757 ptu_uint_eq(buffer[0], 0x09);
1758 ptu_uint_eq(buffer[1], 0xcc);
1759
1760 return ptu_passed();
1761 }
1762
copy_replace(struct image_fixture * ifix)1763 static struct ptunit_result copy_replace(struct image_fixture *ifix)
1764 {
1765 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1766 int status, isid;
1767
1768 ifix->section[0].size = 0x8;
1769 ifix->mapping[0].size = 0x8;
1770
1771 status = pt_image_add(&ifix->copy, &ifix->section[0], &ifix->asid[0],
1772 0x1004ull, 1);
1773 ptu_int_eq(status, 0);
1774
1775 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
1776 0x1000ull, 2);
1777 ptu_int_eq(status, 0);
1778
1779 status = pt_image_copy(&ifix->copy, &ifix->image);
1780 ptu_int_eq(status, 0);
1781
1782 isid = -1;
1783 status = pt_image_read(&ifix->copy, &isid, buffer, 2, &ifix->asid[0],
1784 0x1003ull);
1785 ptu_int_eq(status, 2);
1786 ptu_int_eq(isid, 2);
1787 ptu_uint_eq(buffer[0], 0x03);
1788 ptu_uint_eq(buffer[1], 0x04);
1789 ptu_uint_eq(buffer[2], 0xcc);
1790
1791 return ptu_passed();
1792 }
1793
add_cached_null(void)1794 static struct ptunit_result add_cached_null(void)
1795 {
1796 struct pt_image_section_cache iscache;
1797 struct pt_image image;
1798 int status;
1799
1800 status = pt_image_add_cached(NULL, &iscache, 0, NULL);
1801 ptu_int_eq(status, -pte_invalid);
1802
1803 status = pt_image_add_cached(&image, NULL, 0, NULL);
1804 ptu_int_eq(status, -pte_invalid);
1805
1806 return ptu_passed();
1807 }
1808
add_cached(struct image_fixture * ifix)1809 static struct ptunit_result add_cached(struct image_fixture *ifix)
1810 {
1811 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1812 int status, isid, risid;
1813
1814 isid = ifix_cache_section(ifix, &ifix->section[0], 0x1000ull);
1815 ptu_int_gt(isid, 0);
1816
1817 status = pt_image_add_cached(&ifix->image, &ifix->iscache, isid,
1818 &ifix->asid[0]);
1819 ptu_int_eq(status, 0);
1820
1821 risid = -1;
1822 status = pt_image_read(&ifix->image, &risid, buffer, 2, &ifix->asid[0],
1823 0x1003ull);
1824 ptu_int_eq(status, 2);
1825 ptu_int_eq(risid, isid);
1826 ptu_uint_eq(buffer[0], 0x03);
1827 ptu_uint_eq(buffer[1], 0x04);
1828 ptu_uint_eq(buffer[2], 0xcc);
1829
1830 return ptu_passed();
1831 }
1832
add_cached_null_asid(struct image_fixture * ifix)1833 static struct ptunit_result add_cached_null_asid(struct image_fixture *ifix)
1834 {
1835 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1836 int status, isid, risid;
1837
1838 isid = ifix_cache_section(ifix, &ifix->section[0], 0x1000ull);
1839 ptu_int_gt(isid, 0);
1840
1841 status = pt_image_add_cached(&ifix->image, &ifix->iscache, isid, NULL);
1842 ptu_int_eq(status, 0);
1843
1844 risid = -1;
1845 status = pt_image_read(&ifix->image, &risid, buffer, 2, &ifix->asid[0],
1846 0x1003ull);
1847 ptu_int_eq(status, 2);
1848 ptu_int_eq(risid, isid);
1849 ptu_uint_eq(buffer[0], 0x03);
1850 ptu_uint_eq(buffer[1], 0x04);
1851 ptu_uint_eq(buffer[2], 0xcc);
1852
1853 return ptu_passed();
1854 }
1855
add_cached_twice(struct image_fixture * ifix)1856 static struct ptunit_result add_cached_twice(struct image_fixture *ifix)
1857 {
1858 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1859 int status, isid, risid;
1860
1861 isid = ifix_cache_section(ifix, &ifix->section[0], 0x1000ull);
1862 ptu_int_gt(isid, 0);
1863
1864 status = pt_image_add_cached(&ifix->image, &ifix->iscache, isid,
1865 &ifix->asid[0]);
1866 ptu_int_eq(status, 0);
1867
1868 status = pt_image_add_cached(&ifix->image, &ifix->iscache, isid,
1869 &ifix->asid[0]);
1870 ptu_int_eq(status, 0);
1871
1872 risid = -1;
1873 status = pt_image_read(&ifix->image, &risid, buffer, 2, &ifix->asid[0],
1874 0x1003ull);
1875 ptu_int_eq(status, 2);
1876 ptu_int_eq(risid, isid);
1877 ptu_uint_eq(buffer[0], 0x03);
1878 ptu_uint_eq(buffer[1], 0x04);
1879 ptu_uint_eq(buffer[2], 0xcc);
1880
1881 return ptu_passed();
1882 }
1883
add_cached_bad_isid(struct image_fixture * ifix)1884 static struct ptunit_result add_cached_bad_isid(struct image_fixture *ifix)
1885 {
1886 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1887 int status, isid;
1888
1889 status = pt_image_add_cached(&ifix->image, &ifix->iscache, 1,
1890 &ifix->asid[0]);
1891 ptu_int_eq(status, -pte_bad_image);
1892
1893 isid = -1;
1894 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1895 0x1003ull);
1896 ptu_int_eq(status, -pte_nomap);
1897 ptu_int_eq(isid, -1);
1898
1899 return ptu_passed();
1900 }
1901
find_null(struct image_fixture * ifix)1902 static struct ptunit_result find_null(struct image_fixture *ifix)
1903 {
1904 struct pt_mapped_section msec;
1905 int status;
1906
1907 status = pt_image_find(NULL, &msec, &ifix->asid[0],
1908 0x1000ull);
1909 ptu_int_eq(status, -pte_internal);
1910
1911 status = pt_image_find(&ifix->image, NULL, &ifix->asid[0],
1912 0x1000ull);
1913 ptu_int_eq(status, -pte_internal);
1914
1915 status = pt_image_find(&ifix->image, &msec, NULL, 0x1000ull);
1916 ptu_int_eq(status, -pte_internal);
1917
1918 return ptu_passed();
1919 }
1920
find(struct image_fixture * ifix)1921 static struct ptunit_result find(struct image_fixture *ifix)
1922 {
1923 struct pt_mapped_section msec;
1924 int status;
1925
1926 status = pt_image_find(&ifix->image, &msec, &ifix->asid[1], 0x2003ull);
1927 ptu_int_eq(status, 11);
1928 ptu_ptr_eq(msec.section, &ifix->section[1]);
1929 ptu_uint_eq(msec.vaddr, 0x2000ull);
1930
1931 status = pt_section_put(msec.section);
1932 ptu_int_eq(status, 0);
1933
1934 return ptu_passed();
1935 }
1936
find_asid(struct image_fixture * ifix)1937 static struct ptunit_result find_asid(struct image_fixture *ifix)
1938 {
1939 struct pt_mapped_section msec;
1940 int status;
1941
1942 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
1943 0x1000ull, 1);
1944 ptu_int_eq(status, 0);
1945
1946 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[1],
1947 0x1008ull, 2);
1948 ptu_int_eq(status, 0);
1949
1950 status = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1009ull);
1951 ptu_int_eq(status, 1);
1952 ptu_ptr_eq(msec.section, &ifix->section[0]);
1953 ptu_uint_eq(msec.vaddr, 0x1000ull);
1954
1955 status = pt_section_put(msec.section);
1956 ptu_int_eq(status, 0);
1957
1958 status = pt_image_find(&ifix->image, &msec, &ifix->asid[1], 0x1009ull);
1959 ptu_int_eq(status, 2);
1960 ptu_ptr_eq(msec.section, &ifix->section[0]);
1961 ptu_uint_eq(msec.vaddr, 0x1008ull);
1962
1963 status = pt_section_put(msec.section);
1964 ptu_int_eq(status, 0);
1965
1966 return ptu_passed();
1967 }
1968
find_bad_asid(struct image_fixture * ifix)1969 static struct ptunit_result find_bad_asid(struct image_fixture *ifix)
1970 {
1971 struct pt_mapped_section msec;
1972 int status;
1973
1974 status = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x2003ull);
1975 ptu_int_eq(status, -pte_nomap);
1976
1977 return ptu_passed();
1978 }
1979
find_nomem(struct image_fixture * ifix)1980 static struct ptunit_result find_nomem(struct image_fixture *ifix)
1981 {
1982 struct pt_mapped_section msec;
1983 int status;
1984
1985 status = pt_image_find(&ifix->image, &msec, &ifix->asid[1], 0x1010ull);
1986 ptu_int_eq(status, -pte_nomap);
1987
1988 return ptu_passed();
1989 }
1990
validate_null(struct image_fixture * ifix)1991 static struct ptunit_result validate_null(struct image_fixture *ifix)
1992 {
1993 struct pt_mapped_section msec;
1994 int status;
1995
1996 status = pt_image_validate(NULL, &msec, 0x1004ull, 10);
1997 ptu_int_eq(status, -pte_internal);
1998
1999 status = pt_image_validate(&ifix->image, NULL, 0x1004ull, 10);
2000 ptu_int_eq(status, -pte_internal);
2001
2002 return ptu_passed();
2003 }
2004
validate(struct image_fixture * ifix)2005 static struct ptunit_result validate(struct image_fixture *ifix)
2006 {
2007 struct pt_mapped_section msec;
2008 int isid, status;
2009
2010 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2011 ptu_int_ge(isid, 0);
2012
2013 status = pt_section_put(msec.section);
2014 ptu_int_eq(status, 0);
2015
2016 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2017 ptu_int_eq(status, 0);
2018
2019 return ptu_passed();
2020 }
2021
validate_bad_asid(struct image_fixture * ifix)2022 static struct ptunit_result validate_bad_asid(struct image_fixture *ifix)
2023 {
2024 struct pt_mapped_section msec;
2025 int isid, status;
2026
2027 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2028 ptu_int_ge(isid, 0);
2029
2030 status = pt_section_put(msec.section);
2031 ptu_int_eq(status, 0);
2032
2033 msec.asid = ifix->asid[1];
2034
2035 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2036 ptu_int_eq(status, -pte_nomap);
2037
2038 return ptu_passed();
2039 }
2040
validate_bad_vaddr(struct image_fixture * ifix)2041 static struct ptunit_result validate_bad_vaddr(struct image_fixture *ifix)
2042 {
2043 struct pt_mapped_section msec;
2044 int isid, status;
2045
2046 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2047 ptu_int_ge(isid, 0);
2048
2049 status = pt_section_put(msec.section);
2050 ptu_int_eq(status, 0);
2051
2052 msec.vaddr = 0x2000ull;
2053
2054 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2055 ptu_int_eq(status, -pte_nomap);
2056
2057 return ptu_passed();
2058 }
2059
validate_bad_offset(struct image_fixture * ifix)2060 static struct ptunit_result validate_bad_offset(struct image_fixture *ifix)
2061 {
2062 struct pt_mapped_section msec;
2063 int isid, status;
2064
2065 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2066 ptu_int_ge(isid, 0);
2067
2068 status = pt_section_put(msec.section);
2069 ptu_int_eq(status, 0);
2070
2071 msec.offset = 0x8ull;
2072
2073 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2074 ptu_int_eq(status, -pte_nomap);
2075
2076 return ptu_passed();
2077 }
2078
validate_bad_size(struct image_fixture * ifix)2079 static struct ptunit_result validate_bad_size(struct image_fixture *ifix)
2080 {
2081 struct pt_mapped_section msec;
2082 int isid, status;
2083
2084 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2085 ptu_int_ge(isid, 0);
2086
2087 status = pt_section_put(msec.section);
2088 ptu_int_eq(status, 0);
2089
2090 msec.size = 0x8ull;
2091
2092 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2093 ptu_int_eq(status, -pte_nomap);
2094
2095 return ptu_passed();
2096 }
2097
validate_bad_isid(struct image_fixture * ifix)2098 static struct ptunit_result validate_bad_isid(struct image_fixture *ifix)
2099 {
2100 struct pt_mapped_section msec;
2101 int isid, status;
2102
2103 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2104 ptu_int_ge(isid, 0);
2105
2106 status = pt_section_put(msec.section);
2107 ptu_int_eq(status, 0);
2108
2109 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid + 1);
2110 ptu_int_eq(status, -pte_nomap);
2111
2112 return ptu_passed();
2113 }
2114
ifix_init(struct image_fixture * ifix)2115 static struct ptunit_result ifix_init(struct image_fixture *ifix)
2116 {
2117 int index;
2118
2119 pt_image_init(&ifix->image, NULL);
2120 pt_image_init(&ifix->copy, NULL);
2121
2122 memset(ifix->status, 0, sizeof(ifix->status));
2123 memset(ifix->mapping, 0, sizeof(ifix->mapping));
2124 memset(ifix->section, 0, sizeof(ifix->section));
2125 memset(&ifix->iscache, 0, sizeof(ifix->iscache));
2126
2127 ifix->nsecs = 0;
2128
2129 index = ifix_add_section(ifix, "file-0");
2130 ptu_int_eq(index, 0);
2131
2132 index = ifix_add_section(ifix, "file-1");
2133 ptu_int_eq(index, 1);
2134
2135 index = ifix_add_section(ifix, "file-2");
2136 ptu_int_eq(index, 2);
2137
2138 pt_asid_init(&ifix->asid[0]);
2139 ifix->asid[0].cr3 = 0xa000;
2140
2141 pt_asid_init(&ifix->asid[1]);
2142 ifix->asid[1].cr3 = 0xb000;
2143
2144 pt_asid_init(&ifix->asid[2]);
2145 ifix->asid[2].cr3 = 0xc000;
2146
2147 return ptu_passed();
2148 }
2149
rfix_init(struct image_fixture * ifix)2150 static struct ptunit_result rfix_init(struct image_fixture *ifix)
2151 {
2152 int status;
2153
2154 ptu_check(ifix_init, ifix);
2155
2156 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
2157 0x1000ull, 10);
2158 ptu_int_eq(status, 0);
2159
2160 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[1],
2161 0x2000ull, 11);
2162 ptu_int_eq(status, 0);
2163
2164 return ptu_passed();
2165 }
2166
dfix_fini(struct image_fixture * ifix)2167 static struct ptunit_result dfix_fini(struct image_fixture *ifix)
2168 {
2169 pt_image_fini(&ifix->image);
2170
2171 return ptu_passed();
2172 }
2173
ifix_fini(struct image_fixture * ifix)2174 static struct ptunit_result ifix_fini(struct image_fixture *ifix)
2175 {
2176 int sec;
2177
2178 ptu_check(dfix_fini, ifix);
2179
2180 pt_image_fini(&ifix->copy);
2181
2182 for (sec = 0; sec < ifix_nsecs; ++sec) {
2183 ptu_int_eq(ifix->section[sec].ucount, 0);
2184 ptu_int_eq(ifix->section[sec].mcount, 0);
2185 ptu_int_le(ifix->status[sec].deleted, 1);
2186 ptu_int_eq(ifix->status[sec].bad_put, 0);
2187 }
2188
2189 return ptu_passed();
2190 }
2191
main(int argc,char ** argv)2192 int main(int argc, char **argv)
2193 {
2194 struct image_fixture dfix, ifix, rfix;
2195 struct ptunit_suite suite;
2196
2197 /* Dfix provides image destruction. */
2198 dfix.init = NULL;
2199 dfix.fini = dfix_fini;
2200
2201 /* Ifix provides an empty image. */
2202 ifix.init = ifix_init;
2203 ifix.fini = ifix_fini;
2204
2205 /* Rfix provides an image with two sections added. */
2206 rfix.init = rfix_init;
2207 rfix.fini = ifix_fini;
2208
2209 suite = ptunit_mk_suite(argc, argv);
2210
2211 ptu_run(suite, init);
2212 ptu_run_f(suite, init_name, dfix);
2213 ptu_run(suite, init_null);
2214
2215 ptu_run(suite, fini);
2216 ptu_run(suite, fini_empty);
2217 ptu_run(suite, fini_null);
2218
2219 ptu_run_f(suite, name, dfix);
2220 ptu_run(suite, name_none);
2221 ptu_run(suite, name_null);
2222
2223 ptu_run_f(suite, read_empty, ifix);
2224 ptu_run_f(suite, overlap_front, ifix);
2225 ptu_run_f(suite, overlap_back, ifix);
2226 ptu_run_f(suite, overlap_multiple, ifix);
2227 ptu_run_f(suite, overlap_mid, ifix);
2228 ptu_run_f(suite, contained, ifix);
2229 ptu_run_f(suite, contained_multiple, ifix);
2230 ptu_run_f(suite, contained_back, ifix);
2231 ptu_run_f(suite, same, ifix);
2232 ptu_run_f(suite, same_different_isid, ifix);
2233 ptu_run_f(suite, same_different_offset, ifix);
2234 ptu_run_f(suite, adjacent, ifix);
2235
2236 ptu_run_f(suite, read_null, rfix);
2237 ptu_run_f(suite, read, rfix);
2238 ptu_run_f(suite, read_null, rfix);
2239 ptu_run_f(suite, read_asid, ifix);
2240 ptu_run_f(suite, read_bad_asid, rfix);
2241 ptu_run_f(suite, read_null_asid, rfix);
2242 ptu_run_f(suite, read_callback, rfix);
2243 ptu_run_f(suite, read_nomem, rfix);
2244 ptu_run_f(suite, read_truncated, rfix);
2245 ptu_run_f(suite, read_error, rfix);
2246 ptu_run_f(suite, read_spurious_error, rfix);
2247
2248 ptu_run_f(suite, remove_section, rfix);
2249 ptu_run_f(suite, remove_bad_vaddr, rfix);
2250 ptu_run_f(suite, remove_bad_asid, rfix);
2251 ptu_run_f(suite, remove_by_filename, rfix);
2252 ptu_run_f(suite, remove_by_filename_bad_asid, rfix);
2253 ptu_run_f(suite, remove_none_by_filename, rfix);
2254 ptu_run_f(suite, remove_all_by_filename, ifix);
2255 ptu_run_f(suite, remove_by_asid, rfix);
2256
2257 ptu_run_f(suite, copy_empty, ifix);
2258 ptu_run_f(suite, copy, rfix);
2259 ptu_run_f(suite, copy_self, rfix);
2260 ptu_run_f(suite, copy_shrink, rfix);
2261 ptu_run_f(suite, copy_split, ifix);
2262 ptu_run_f(suite, copy_merge, ifix);
2263 ptu_run_f(suite, copy_overlap, ifix);
2264 ptu_run_f(suite, copy_replace, ifix);
2265
2266 ptu_run(suite, add_cached_null);
2267 ptu_run_f(suite, add_cached, ifix);
2268 ptu_run_f(suite, add_cached_null_asid, ifix);
2269 ptu_run_f(suite, add_cached_twice, ifix);
2270 ptu_run_f(suite, add_cached_bad_isid, ifix);
2271
2272 ptu_run_f(suite, find_null, rfix);
2273 ptu_run_f(suite, find, rfix);
2274 ptu_run_f(suite, find_asid, ifix);
2275 ptu_run_f(suite, find_bad_asid, rfix);
2276 ptu_run_f(suite, find_nomem, rfix);
2277
2278 ptu_run_f(suite, validate_null, rfix);
2279 ptu_run_f(suite, validate, rfix);
2280 ptu_run_f(suite, validate_bad_asid, rfix);
2281 ptu_run_f(suite, validate_bad_vaddr, rfix);
2282 ptu_run_f(suite, validate_bad_offset, rfix);
2283 ptu_run_f(suite, validate_bad_size, rfix);
2284 ptu_run_f(suite, validate_bad_isid, rfix);
2285
2286 return ptunit_report(&suite);
2287 }
2288