2 * Copyright (c) 2013-2018, Intel Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
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.
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.
32 #include "pt_section.h"
33 #include "pt_mapped_section.h"
43 uint8_t content[0x10];
45 /* The size - between 0 and sizeof(content). */
48 /* An artificial error code to be injected into pt_section_read().
50 * If @errcode is non-zero, pt_section_read() fails with @errcode.
55 /* A test file status - turned into a section status. */
58 * - zero if initialized and not (yet) deleted
59 * - non-zero if deleted and not (re-)initialized
63 /* Put with use-count of zero indication. */
66 /* The test mapping to be used. */
67 struct ifix_mapping *mapping;
69 /* A link back to the test fixture providing this section. */
70 struct image_fixture *ifix;
77 /* A fake image section cache. */
78 struct pt_image_section_cache {
79 /* The cached sections. */
80 struct pt_section *section[ifix_nsecs];
82 /* Their load addresses. */
83 uint64_t laddr[ifix_nsecs];
85 /* The number of used sections. */
89 extern int pt_iscache_lookup(struct pt_image_section_cache *iscache,
90 struct pt_section **section, uint64_t *laddr,
94 /* A test fixture providing an image, test sections, and asids. */
95 struct image_fixture {
97 struct pt_image image;
99 /* The test states. */
100 struct ifix_status status[ifix_nsecs];
102 /* The test mappings. */
103 struct ifix_mapping mapping[ifix_nsecs];
106 struct pt_section section[ifix_nsecs];
109 struct pt_asid asid[3];
111 /* The number of used sections/mappings/states. */
114 /* An initially empty image as destination for image copies. */
115 struct pt_image copy;
117 /* A test section cache. */
118 struct pt_image_section_cache iscache;
120 /* The test fixture initialization and finalization functions. */
121 struct ptunit_result (*init)(struct image_fixture *);
122 struct ptunit_result (*fini)(struct image_fixture *);
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)
132 memset(section, 0, sizeof(*section));
134 section->filename = filename;
135 section->status = status;
136 section->size = mapping->size = sizeof(mapping->content);
137 section->offset = 0x10;
139 for (i = 0; i < mapping->size; ++i)
140 mapping->content[i] = i;
144 status->mapping = mapping;
148 static int ifix_add_section(struct image_fixture *ifix, char *filename)
153 return -pte_internal;
156 if (ifix_nsecs <= index)
157 return -pte_internal;
159 ifix_init_section(&ifix->section[index], filename, &ifix->status[index],
160 &ifix->mapping[index], ifix);
166 static int ifix_cache_section(struct image_fixture *ifix,
167 struct pt_section *section, uint64_t laddr)
172 return -pte_internal;
174 index = ifix->iscache.nsecs;
175 if (ifix_nsecs <= index)
176 return -pte_internal;
178 ifix->iscache.section[index] = section;
179 ifix->iscache.laddr[index] = laddr;
182 ifix->iscache.nsecs = index;
187 const char *pt_section_filename(const struct pt_section *section)
192 return section->filename;
195 uint64_t pt_section_offset(const struct pt_section *section)
200 return section->offset;
203 uint64_t pt_section_size(const struct pt_section *section)
208 return section->size;
211 struct pt_section *pt_mk_section(const char *file, uint64_t offset,
218 /* This function is not used by our tests. */
222 int pt_section_get(struct pt_section *section)
225 return -pte_internal;
227 section->ucount += 1;
231 int pt_section_put(struct pt_section *section)
233 struct ifix_status *status;
237 return -pte_internal;
239 status = section->status;
241 return -pte_internal;
243 ucount = section->ucount;
245 status->bad_put += 1;
247 return -pte_internal;
250 ucount = --section->ucount;
252 status->deleted += 1;
254 if (status->deleted > 1)
255 return -pte_internal;
261 int pt_iscache_lookup(struct pt_image_section_cache *iscache,
262 struct pt_section **section, uint64_t *laddr, int isid)
264 if (!iscache || !section || !laddr)
265 return -pte_internal;
267 if (!isid || iscache->nsecs < isid)
268 return -pte_bad_image;
272 *section = iscache->section[isid];
273 *laddr = iscache->laddr[isid];
275 return pt_section_get(*section);
278 static int ifix_unmap(struct pt_section *section)
283 return -pte_internal;
285 mcount = section->mcount;
287 return -pte_internal;
289 if (!section->mapping)
290 return -pte_internal;
292 mcount = --section->mcount;
294 section->mapping = NULL;
299 static int ifix_read(const struct pt_section *section, uint8_t *buffer,
300 uint16_t size, uint64_t offset)
302 struct ifix_mapping *mapping;
305 if (!section || !buffer)
306 return -pte_internal;
314 mapping = section->mapping;
318 if (mapping->errcode)
319 return mapping->errcode;
321 if (mapping->size <= begin)
324 if (mapping->size < end) {
326 size = (uint16_t) (end - begin);
329 memcpy(buffer, &mapping->content[begin], size);
334 int pt_section_map(struct pt_section *section)
336 struct ifix_status *status;
340 return -pte_internal;
342 mcount = section->mcount++;
346 if (section->mapping)
347 return -pte_internal;
349 status = section->status;
351 return -pte_internal;
353 section->mapping = status->mapping;
354 section->unmap = ifix_unmap;
355 section->read = ifix_read;
360 int pt_section_on_map_lock(struct pt_section *section)
363 return -pte_internal;
368 int pt_section_unmap(struct pt_section *section)
371 return -pte_internal;
376 return section->unmap(section);
379 int pt_section_read(const struct pt_section *section, uint8_t *buffer,
380 uint16_t size, uint64_t offset)
383 return -pte_internal;
388 return section->read(section, buffer, size, offset);
391 /* A test read memory callback. */
392 static int image_readmem_callback(uint8_t *buffer, size_t size,
393 const struct pt_asid *asid,
394 uint64_t ip, void *context)
396 const uint8_t *memory;
404 /* We use a constant offset of 0x3000. */
410 memory = (const uint8_t *) context;
412 return -pte_internal;
414 for (idx = 0; idx < size; ++idx)
415 buffer[idx] = memory[ip + idx];
420 static struct ptunit_result init(void)
422 struct pt_image image;
424 memset(&image, 0xcd, sizeof(image));
426 pt_image_init(&image, NULL);
427 ptu_null(image.name);
428 ptu_null(image.sections);
429 ptu_null((void *) (uintptr_t) image.readmem.callback);
430 ptu_null(image.readmem.context);
435 static struct ptunit_result init_name(struct image_fixture *ifix)
437 memset(&ifix->image, 0xcd, sizeof(ifix->image));
439 pt_image_init(&ifix->image, "image-name");
440 ptu_str_eq(ifix->image.name, "image-name");
441 ptu_null(ifix->image.sections);
442 ptu_null((void *) (uintptr_t) ifix->image.readmem.callback);
443 ptu_null(ifix->image.readmem.context);
448 static struct ptunit_result init_null(void)
450 pt_image_init(NULL, NULL);
455 static struct ptunit_result fini(void)
457 struct ifix_mapping mapping;
458 struct ifix_status status;
459 struct pt_section section;
460 struct pt_image image;
465 ifix_init_section(§ion, NULL, &status, &mapping, NULL);
467 pt_image_init(&image, NULL);
468 errcode = pt_image_add(&image, §ion, &asid, 0x0ull, 0);
469 ptu_int_eq(errcode, 0);
471 pt_image_fini(&image);
472 ptu_int_eq(section.ucount, 0);
473 ptu_int_eq(section.mcount, 0);
474 ptu_int_eq(status.deleted, 1);
475 ptu_int_eq(status.bad_put, 0);
480 static struct ptunit_result fini_empty(void)
482 struct pt_image image;
484 pt_image_init(&image, NULL);
485 pt_image_fini(&image);
490 static struct ptunit_result fini_null(void)
497 static struct ptunit_result name(struct image_fixture *ifix)
501 pt_image_init(&ifix->image, "image-name");
503 name = pt_image_name(&ifix->image);
504 ptu_str_eq(name, "image-name");
509 static struct ptunit_result name_none(void)
511 struct pt_image image;
514 pt_image_init(&image, NULL);
516 name = pt_image_name(&image);
522 static struct ptunit_result name_null(void)
526 name = pt_image_name(NULL);
532 static struct ptunit_result read_empty(struct image_fixture *ifix)
535 uint8_t buffer[] = { 0xcc, 0xcc };
541 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
543 ptu_int_eq(status, -pte_nomap);
544 ptu_int_eq(isid, -1);
545 ptu_uint_eq(buffer[0], 0xcc);
546 ptu_uint_eq(buffer[1], 0xcc);
551 static struct ptunit_result overlap_front(struct image_fixture *ifix)
553 uint8_t buffer[] = { 0xcc, 0xcc };
556 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
558 ptu_int_eq(status, 0);
560 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
562 ptu_int_eq(status, 0);
565 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
567 ptu_int_eq(status, 1);
569 ptu_uint_eq(buffer[0], 0x0f);
570 ptu_uint_eq(buffer[1], 0xcc);
575 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
577 ptu_int_eq(status, 1);
579 ptu_uint_eq(buffer[0], 0x0f);
580 ptu_uint_eq(buffer[1], 0xcc);
585 static struct ptunit_result overlap_back(struct image_fixture *ifix)
587 uint8_t buffer[] = { 0xcc, 0xcc };
590 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
592 ptu_int_eq(status, 0);
594 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
596 ptu_int_eq(status, 0);
599 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
601 ptu_int_eq(status, 1);
603 ptu_uint_eq(buffer[0], 0x00);
604 ptu_uint_eq(buffer[1], 0xcc);
607 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
609 ptu_int_eq(status, 1);
611 ptu_uint_eq(buffer[0], 0x0f);
612 ptu_uint_eq(buffer[1], 0xcc);
615 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
617 ptu_int_eq(status, 1);
619 ptu_uint_eq(buffer[0], 0x00);
620 ptu_uint_eq(buffer[1], 0xcc);
625 static struct ptunit_result overlap_multiple(struct image_fixture *ifix)
627 uint8_t buffer[] = { 0xcc, 0xcc };
630 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
632 ptu_int_eq(status, 0);
634 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
636 ptu_int_eq(status, 0);
638 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
640 ptu_int_eq(status, 0);
643 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
645 ptu_int_eq(status, 1);
647 ptu_uint_eq(buffer[0], 0x07);
648 ptu_uint_eq(buffer[1], 0xcc);
650 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
652 ptu_int_eq(status, 1);
654 ptu_uint_eq(buffer[0], 0x00);
655 ptu_uint_eq(buffer[1], 0xcc);
658 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
660 ptu_int_eq(status, 1);
662 ptu_uint_eq(buffer[0], 0x0f);
663 ptu_uint_eq(buffer[1], 0xcc);
666 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
668 ptu_int_eq(status, 1);
670 ptu_uint_eq(buffer[0], 0x08);
671 ptu_uint_eq(buffer[1], 0xcc);
676 static struct ptunit_result overlap_mid(struct image_fixture *ifix)
678 uint8_t buffer[] = { 0xcc, 0xcc };
681 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
683 ptu_int_eq(status, 0);
685 ifix->section[1].size = 0x8;
686 ifix->mapping[1].size = 0x8;
687 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
689 ptu_int_eq(status, 0);
692 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
694 ptu_int_eq(status, 1);
696 ptu_uint_eq(buffer[0], 0x03);
697 ptu_uint_eq(buffer[1], 0xcc);
700 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
702 ptu_int_eq(status, 1);
704 ptu_uint_eq(buffer[0], 0x00);
705 ptu_uint_eq(buffer[1], 0xcc);
708 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
710 ptu_int_eq(status, 1);
712 ptu_uint_eq(buffer[0], 0x07);
713 ptu_uint_eq(buffer[1], 0xcc);
716 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
718 ptu_int_eq(status, 1);
720 ptu_uint_eq(buffer[0], 0x0c);
721 ptu_uint_eq(buffer[1], 0xcc);
726 static struct ptunit_result contained(struct image_fixture *ifix)
728 uint8_t buffer[] = { 0xcc, 0xcc };
731 ifix->section[0].size = 0x8;
732 ifix->mapping[0].size = 0x8;
733 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
735 ptu_int_eq(status, 0);
737 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
739 ptu_int_eq(status, 0);
742 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
744 ptu_int_eq(status, 1);
746 ptu_uint_eq(buffer[0], 0x08);
747 ptu_uint_eq(buffer[1], 0xcc);
752 static struct ptunit_result contained_multiple(struct image_fixture *ifix)
754 uint8_t buffer[] = { 0xcc, 0xcc };
757 ifix->section[0].size = 0x2;
758 ifix->mapping[0].size = 0x2;
759 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
761 ptu_int_eq(status, 0);
763 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
765 ptu_int_eq(status, 0);
767 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
769 ptu_int_eq(status, 0);
772 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
774 ptu_int_eq(status, 1);
776 ptu_uint_eq(buffer[0], 0x04);
777 ptu_uint_eq(buffer[1], 0xcc);
780 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
782 ptu_int_eq(status, 1);
784 ptu_uint_eq(buffer[0], 0x08);
785 ptu_uint_eq(buffer[1], 0xcc);
790 static struct ptunit_result contained_back(struct image_fixture *ifix)
792 uint8_t buffer[] = { 0xcc, 0xcc };
795 ifix->section[0].size = 0x8;
796 ifix->mapping[0].size = 0x8;
797 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
799 ptu_int_eq(status, 0);
801 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
803 ptu_int_eq(status, 0);
805 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
807 ptu_int_eq(status, 0);
810 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
812 ptu_int_eq(status, 1);
814 ptu_uint_eq(buffer[0], 0x04);
815 ptu_uint_eq(buffer[1], 0xcc);
818 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
820 ptu_int_eq(status, 1);
822 ptu_uint_eq(buffer[0], 0x0c);
823 ptu_uint_eq(buffer[1], 0xcc);
826 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
828 ptu_int_eq(status, 1);
830 ptu_uint_eq(buffer[0], 0x0f);
831 ptu_uint_eq(buffer[1], 0xcc);
834 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
836 ptu_int_eq(status, 1);
838 ptu_uint_eq(buffer[0], 0x04);
839 ptu_uint_eq(buffer[1], 0xcc);
844 static struct ptunit_result same(struct image_fixture *ifix)
846 uint8_t buffer[] = { 0xcc, 0xcc };
849 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
851 ptu_int_eq(status, 0);
853 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
855 ptu_int_eq(status, 0);
858 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
860 ptu_int_eq(status, 1);
862 ptu_uint_eq(buffer[0], 0x08);
863 ptu_uint_eq(buffer[1], 0xcc);
868 static struct ptunit_result same_different_isid(struct image_fixture *ifix)
870 uint8_t buffer[] = { 0xcc, 0xcc };
873 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
875 ptu_int_eq(status, 0);
877 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
879 ptu_int_eq(status, 0);
882 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
884 ptu_int_eq(status, 1);
886 ptu_uint_eq(buffer[0], 0x08);
887 ptu_uint_eq(buffer[1], 0xcc);
892 static struct ptunit_result same_different_offset(struct image_fixture *ifix)
894 uint8_t buffer[] = { 0xcc, 0xcc }, i;
895 int status, isid, index;
897 /* Add another section from a different part of the same file as an
900 index = ifix_add_section(ifix, ifix->section[0].filename);
901 ptu_int_gt(index, 0);
903 ifix->section[index].offset = ifix->section[0].offset + 0x10;
904 ptu_uint_eq(ifix->section[index].size, ifix->section[0].size);
906 /* Change the content of the new section so we can distinguish them. */
907 for (i = 0; i < ifix->mapping[index].size; ++i)
908 ifix->mapping[index].content[i] += 0x10;
911 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
913 ptu_int_eq(status, 0);
915 status = pt_image_add(&ifix->image, &ifix->section[index],
916 &ifix->asid[0], 0x1000ull, 0);
917 ptu_int_eq(status, 0);
920 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
922 ptu_int_eq(status, 1);
924 ptu_uint_eq(buffer[0], 0x10);
925 ptu_uint_eq(buffer[1], 0xcc);
928 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
930 ptu_int_eq(status, 1);
932 ptu_uint_eq(buffer[0], 0x1f);
933 ptu_uint_eq(buffer[1], 0xcc);
938 static struct ptunit_result adjacent(struct image_fixture *ifix)
940 uint8_t buffer[] = { 0xcc, 0xcc };
943 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
945 ptu_int_eq(status, 0);
947 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
948 0x1000ull - ifix->section[1].size, 2);
949 ptu_int_eq(status, 0);
951 status = pt_image_add(&ifix->image, &ifix->section[2], &ifix->asid[0],
952 0x1000ull + ifix->section[0].size, 3);
953 ptu_int_eq(status, 0);
956 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
958 ptu_int_eq(status, 1);
960 ptu_uint_eq(buffer[0], 0x00);
961 ptu_uint_eq(buffer[1], 0xcc);
964 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
966 ptu_int_eq(status, 1);
968 ptu_uint_eq(buffer[0],
969 ifix->mapping[1].content[ifix->mapping[1].size - 1]);
970 ptu_uint_eq(buffer[1], 0xcc);
973 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
974 0x1000ull + ifix->section[0].size);
975 ptu_int_eq(status, 1);
977 ptu_uint_eq(buffer[0], 0x00);
978 ptu_uint_eq(buffer[1], 0xcc);
983 static struct ptunit_result read_null(struct image_fixture *ifix)
988 status = pt_image_read(NULL, &isid, &buffer, 1, &ifix->asid[0],
990 ptu_int_eq(status, -pte_internal);
992 status = pt_image_read(&ifix->image, NULL, &buffer, 1, &ifix->asid[0],
994 ptu_int_eq(status, -pte_internal);
996 status = pt_image_read(&ifix->image, &isid, NULL, 1, &ifix->asid[0],
998 ptu_int_eq(status, -pte_internal);
1000 status = pt_image_read(&ifix->image, &isid, &buffer, 1, NULL,
1002 ptu_int_eq(status, -pte_internal);
1004 return ptu_passed();
1007 static struct ptunit_result read(struct image_fixture *ifix)
1009 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1013 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1015 ptu_int_eq(status, 2);
1016 ptu_int_eq(isid, 11);
1017 ptu_uint_eq(buffer[0], 0x03);
1018 ptu_uint_eq(buffer[1], 0x04);
1019 ptu_uint_eq(buffer[2], 0xcc);
1021 return ptu_passed();
1024 static struct ptunit_result read_asid(struct image_fixture *ifix)
1026 uint8_t buffer[] = { 0xcc, 0xcc };
1029 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
1031 ptu_int_eq(status, 0);
1033 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[1],
1035 ptu_int_eq(status, 0);
1038 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
1040 ptu_int_eq(status, 1);
1041 ptu_int_eq(isid, 1);
1042 ptu_uint_eq(buffer[0], 0x09);
1043 ptu_uint_eq(buffer[1], 0xcc);
1046 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[1],
1048 ptu_int_eq(status, 1);
1049 ptu_int_eq(isid, 2);
1050 ptu_uint_eq(buffer[0], 0x01);
1051 ptu_uint_eq(buffer[1], 0xcc);
1053 return ptu_passed();
1056 static struct ptunit_result read_bad_asid(struct image_fixture *ifix)
1058 uint8_t buffer[] = { 0xcc, 0xcc };
1062 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1063 &ifix->asid[0], 0x2003ull);
1064 ptu_int_eq(status, -pte_nomap);
1065 ptu_int_eq(isid, -1);
1066 ptu_uint_eq(buffer[0], 0xcc);
1067 ptu_uint_eq(buffer[1], 0xcc);
1069 return ptu_passed();
1072 static struct ptunit_result read_null_asid(struct image_fixture *ifix)
1074 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1078 status = pt_image_read(&ifix->image, &isid, buffer, 2, NULL, 0x2003ull);
1079 ptu_int_eq(status, -pte_internal);
1080 ptu_int_eq(isid, -1);
1081 ptu_uint_eq(buffer[0], 0xcc);
1082 ptu_uint_eq(buffer[1], 0xcc);
1084 return ptu_passed();
1087 static struct ptunit_result read_callback(struct image_fixture *ifix)
1089 uint8_t memory[] = { 0xdd, 0x01, 0x02, 0xdd };
1090 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1093 status = pt_image_set_callback(&ifix->image, image_readmem_callback,
1095 ptu_int_eq(status, 0);
1098 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1100 ptu_int_eq(status, 2);
1101 ptu_int_eq(isid, 0);
1102 ptu_uint_eq(buffer[0], 0x01);
1103 ptu_uint_eq(buffer[1], 0x02);
1104 ptu_uint_eq(buffer[2], 0xcc);
1106 return ptu_passed();
1109 static struct ptunit_result read_nomem(struct image_fixture *ifix)
1111 uint8_t buffer[] = { 0xcc, 0xcc };
1115 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1116 &ifix->asid[1], 0x1010ull);
1117 ptu_int_eq(status, -pte_nomap);
1118 ptu_int_eq(isid, -1);
1119 ptu_uint_eq(buffer[0], 0xcc);
1120 ptu_uint_eq(buffer[1], 0xcc);
1122 return ptu_passed();
1125 static struct ptunit_result read_truncated(struct image_fixture *ifix)
1127 uint8_t buffer[] = { 0xcc, 0xcc };
1131 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1132 &ifix->asid[0], 0x100full);
1133 ptu_int_eq(status, 1);
1134 ptu_int_eq(isid, 10);
1135 ptu_uint_eq(buffer[0], 0x0f);
1136 ptu_uint_eq(buffer[1], 0xcc);
1138 return ptu_passed();
1141 static struct ptunit_result read_error(struct image_fixture *ifix)
1143 uint8_t buffer[] = { 0xcc };
1146 ifix->mapping[0].errcode = -pte_nosync;
1149 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
1151 ptu_int_eq(status, -pte_nosync);
1152 ptu_int_eq(isid, 10);
1153 ptu_uint_eq(buffer[0], 0xcc);
1155 return ptu_passed();
1158 static struct ptunit_result read_spurious_error(struct image_fixture *ifix)
1160 uint8_t buffer[] = { 0xcc, 0xcc };
1164 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
1166 ptu_int_eq(status, 1);
1167 ptu_int_eq(isid, 10);
1168 ptu_uint_eq(buffer[0], 0x00);
1169 ptu_uint_eq(buffer[1], 0xcc);
1171 ifix->mapping[0].errcode = -pte_nosync;
1174 status = pt_image_read(&ifix->image, &isid, buffer, 1, &ifix->asid[0],
1176 ptu_int_eq(status, -pte_nosync);
1177 ptu_int_eq(isid, 10);
1178 ptu_uint_eq(buffer[0], 0x00);
1180 return ptu_passed();
1183 static struct ptunit_result remove_section(struct image_fixture *ifix)
1185 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1189 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1191 ptu_int_eq(status, 2);
1192 ptu_int_eq(isid, 10);
1193 ptu_uint_eq(buffer[0], 0x01);
1194 ptu_uint_eq(buffer[1], 0x02);
1195 ptu_uint_eq(buffer[2], 0xcc);
1197 status = pt_image_remove(&ifix->image, &ifix->section[0],
1198 &ifix->asid[0], 0x1000ull);
1199 ptu_int_eq(status, 0);
1201 ptu_int_ne(ifix->status[0].deleted, 0);
1202 ptu_int_eq(ifix->status[1].deleted, 0);
1205 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1206 &ifix->asid[0], 0x1003ull);
1207 ptu_int_eq(status, -pte_nomap);
1208 ptu_int_eq(isid, -1);
1209 ptu_uint_eq(buffer[0], 0x01);
1210 ptu_uint_eq(buffer[1], 0x02);
1211 ptu_uint_eq(buffer[2], 0xcc);
1214 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1216 ptu_int_eq(status, 2);
1217 ptu_int_eq(isid, 11);
1218 ptu_uint_eq(buffer[0], 0x03);
1219 ptu_uint_eq(buffer[1], 0x04);
1220 ptu_uint_eq(buffer[2], 0xcc);
1222 return ptu_passed();
1225 static struct ptunit_result remove_bad_vaddr(struct image_fixture *ifix)
1227 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1231 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1233 ptu_int_eq(status, 2);
1234 ptu_int_eq(isid, 10);
1235 ptu_uint_eq(buffer[0], 0x01);
1236 ptu_uint_eq(buffer[1], 0x02);
1237 ptu_uint_eq(buffer[2], 0xcc);
1239 status = pt_image_remove(&ifix->image, &ifix->section[0],
1240 &ifix->asid[0], 0x2000ull);
1241 ptu_int_eq(status, -pte_bad_image);
1243 ptu_int_eq(ifix->status[0].deleted, 0);
1244 ptu_int_eq(ifix->status[1].deleted, 0);
1247 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1249 ptu_int_eq(status, 2);
1250 ptu_int_eq(isid, 10);
1251 ptu_uint_eq(buffer[0], 0x03);
1252 ptu_uint_eq(buffer[1], 0x04);
1253 ptu_uint_eq(buffer[2], 0xcc);
1256 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1258 ptu_int_eq(status, 2);
1259 ptu_int_eq(isid, 11);
1260 ptu_uint_eq(buffer[0], 0x05);
1261 ptu_uint_eq(buffer[1], 0x06);
1262 ptu_uint_eq(buffer[2], 0xcc);
1264 return ptu_passed();
1267 static struct ptunit_result remove_bad_asid(struct image_fixture *ifix)
1269 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1273 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1275 ptu_int_eq(status, 2);
1276 ptu_int_eq(isid, 10);
1277 ptu_uint_eq(buffer[0], 0x01);
1278 ptu_uint_eq(buffer[1], 0x02);
1279 ptu_uint_eq(buffer[2], 0xcc);
1281 status = pt_image_remove(&ifix->image, &ifix->section[0],
1282 &ifix->asid[1], 0x1000ull);
1283 ptu_int_eq(status, -pte_bad_image);
1285 ptu_int_eq(ifix->status[0].deleted, 0);
1286 ptu_int_eq(ifix->status[1].deleted, 0);
1289 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1291 ptu_int_eq(status, 2);
1292 ptu_int_eq(isid, 10);
1293 ptu_uint_eq(buffer[0], 0x03);
1294 ptu_uint_eq(buffer[1], 0x04);
1295 ptu_uint_eq(buffer[2], 0xcc);
1298 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1300 ptu_int_eq(status, 2);
1301 ptu_int_eq(isid, 11);
1302 ptu_uint_eq(buffer[0], 0x05);
1303 ptu_uint_eq(buffer[1], 0x06);
1304 ptu_uint_eq(buffer[2], 0xcc);
1306 return ptu_passed();
1309 static struct ptunit_result remove_by_filename(struct image_fixture *ifix)
1311 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1315 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1317 ptu_int_eq(status, 2);
1318 ptu_int_eq(isid, 10);
1319 ptu_uint_eq(buffer[0], 0x01);
1320 ptu_uint_eq(buffer[1], 0x02);
1321 ptu_uint_eq(buffer[2], 0xcc);
1323 status = pt_image_remove_by_filename(&ifix->image,
1324 ifix->section[0].filename,
1326 ptu_int_eq(status, 1);
1328 ptu_int_ne(ifix->status[0].deleted, 0);
1329 ptu_int_eq(ifix->status[1].deleted, 0);
1332 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1333 &ifix->asid[0], 0x1003ull);
1334 ptu_int_eq(status, -pte_nomap);
1335 ptu_int_eq(isid, -1);
1336 ptu_uint_eq(buffer[0], 0x01);
1337 ptu_uint_eq(buffer[1], 0x02);
1338 ptu_uint_eq(buffer[2], 0xcc);
1341 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1343 ptu_int_eq(status, 2);
1344 ptu_int_eq(isid, 11);
1345 ptu_uint_eq(buffer[0], 0x03);
1346 ptu_uint_eq(buffer[1], 0x04);
1347 ptu_uint_eq(buffer[2], 0xcc);
1349 return ptu_passed();
1352 static struct ptunit_result
1353 remove_by_filename_bad_asid(struct image_fixture *ifix)
1355 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1359 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1361 ptu_int_eq(status, 2);
1362 ptu_int_eq(isid, 10);
1363 ptu_uint_eq(buffer[0], 0x01);
1364 ptu_uint_eq(buffer[1], 0x02);
1365 ptu_uint_eq(buffer[2], 0xcc);
1367 status = pt_image_remove_by_filename(&ifix->image,
1368 ifix->section[0].filename,
1370 ptu_int_eq(status, 0);
1372 ptu_int_eq(ifix->status[0].deleted, 0);
1373 ptu_int_eq(ifix->status[1].deleted, 0);
1376 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1378 ptu_int_eq(status, 2);
1379 ptu_int_eq(isid, 10);
1380 ptu_uint_eq(buffer[0], 0x03);
1381 ptu_uint_eq(buffer[1], 0x04);
1382 ptu_uint_eq(buffer[2], 0xcc);
1385 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1387 ptu_int_eq(status, 2);
1388 ptu_int_eq(isid, 11);
1389 ptu_uint_eq(buffer[0], 0x05);
1390 ptu_uint_eq(buffer[1], 0x06);
1391 ptu_uint_eq(buffer[2], 0xcc);
1393 return ptu_passed();
1396 static struct ptunit_result remove_none_by_filename(struct image_fixture *ifix)
1398 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1401 status = pt_image_remove_by_filename(&ifix->image, "bad-name",
1403 ptu_int_eq(status, 0);
1405 ptu_int_eq(ifix->status[0].deleted, 0);
1406 ptu_int_eq(ifix->status[1].deleted, 0);
1409 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1411 ptu_int_eq(status, 2);
1412 ptu_int_eq(isid, 10);
1413 ptu_uint_eq(buffer[0], 0x03);
1414 ptu_uint_eq(buffer[1], 0x04);
1415 ptu_uint_eq(buffer[2], 0xcc);
1418 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1420 ptu_int_eq(status, 2);
1421 ptu_int_eq(isid, 11);
1422 ptu_uint_eq(buffer[0], 0x01);
1423 ptu_uint_eq(buffer[1], 0x02);
1424 ptu_uint_eq(buffer[2], 0xcc);
1426 return ptu_passed();
1429 static struct ptunit_result remove_all_by_filename(struct image_fixture *ifix)
1431 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1434 ifix->section[0].filename = "same-name";
1435 ifix->section[1].filename = "same-name";
1437 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
1439 ptu_int_eq(status, 0);
1441 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
1443 ptu_int_eq(status, 0);
1446 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1448 ptu_int_eq(status, 2);
1449 ptu_int_eq(isid, 1);
1450 ptu_uint_eq(buffer[0], 0x01);
1451 ptu_uint_eq(buffer[1], 0x02);
1452 ptu_uint_eq(buffer[2], 0xcc);
1454 status = pt_image_remove_by_filename(&ifix->image, "same-name",
1456 ptu_int_eq(status, 2);
1458 ptu_int_ne(ifix->status[0].deleted, 0);
1459 ptu_int_ne(ifix->status[1].deleted, 0);
1462 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1463 &ifix->asid[0], 0x1003ull);
1464 ptu_int_eq(status, -pte_nomap);
1465 ptu_int_eq(isid, -1);
1466 ptu_uint_eq(buffer[0], 0x01);
1467 ptu_uint_eq(buffer[1], 0x02);
1468 ptu_uint_eq(buffer[2], 0xcc);
1471 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1472 &ifix->asid[0], 0x2003ull);
1473 ptu_int_eq(status, -pte_nomap);
1474 ptu_int_eq(isid, -1);
1475 ptu_uint_eq(buffer[0], 0x01);
1476 ptu_uint_eq(buffer[1], 0x02);
1477 ptu_uint_eq(buffer[2], 0xcc);
1479 return ptu_passed();
1482 static struct ptunit_result remove_by_asid(struct image_fixture *ifix)
1484 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1488 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1490 ptu_int_eq(status, 2);
1491 ptu_int_eq(isid, 10);
1492 ptu_uint_eq(buffer[0], 0x01);
1493 ptu_uint_eq(buffer[1], 0x02);
1494 ptu_uint_eq(buffer[2], 0xcc);
1496 status = pt_image_remove_by_asid(&ifix->image, &ifix->asid[0]);
1497 ptu_int_eq(status, 1);
1499 ptu_int_ne(ifix->status[0].deleted, 0);
1500 ptu_int_eq(ifix->status[1].deleted, 0);
1503 status = pt_image_read(&ifix->image, &isid, buffer, sizeof(buffer),
1504 &ifix->asid[0], 0x1003ull);
1505 ptu_int_eq(status, -pte_nomap);
1506 ptu_int_eq(isid, -1);
1507 ptu_uint_eq(buffer[0], 0x01);
1508 ptu_uint_eq(buffer[1], 0x02);
1509 ptu_uint_eq(buffer[2], 0xcc);
1512 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1514 ptu_int_eq(status, 2);
1515 ptu_int_eq(isid, 11);
1516 ptu_uint_eq(buffer[0], 0x03);
1517 ptu_uint_eq(buffer[1], 0x04);
1518 ptu_uint_eq(buffer[2], 0xcc);
1520 return ptu_passed();
1523 static struct ptunit_result copy_empty(struct image_fixture *ifix)
1525 struct pt_asid asid;
1526 uint8_t buffer[] = { 0xcc, 0xcc };
1529 pt_asid_init(&asid);
1531 status = pt_image_copy(&ifix->copy, &ifix->image);
1532 ptu_int_eq(status, 0);
1535 status = pt_image_read(&ifix->copy, &isid, buffer, sizeof(buffer),
1537 ptu_int_eq(status, -pte_nomap);
1538 ptu_int_eq(isid, -1);
1539 ptu_uint_eq(buffer[0], 0xcc);
1540 ptu_uint_eq(buffer[1], 0xcc);
1542 return ptu_passed();
1545 static struct ptunit_result copy(struct image_fixture *ifix)
1547 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1550 status = pt_image_copy(&ifix->copy, &ifix->image);
1551 ptu_int_eq(status, 0);
1554 status = pt_image_read(&ifix->copy, &isid, buffer, 2, &ifix->asid[1],
1556 ptu_int_eq(status, 2);
1557 ptu_int_eq(isid, 11);
1558 ptu_uint_eq(buffer[0], 0x03);
1559 ptu_uint_eq(buffer[1], 0x04);
1560 ptu_uint_eq(buffer[2], 0xcc);
1562 return ptu_passed();
1565 static struct ptunit_result copy_self(struct image_fixture *ifix)
1567 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1570 status = pt_image_copy(&ifix->image, &ifix->image);
1571 ptu_int_eq(status, 0);
1574 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[1],
1576 ptu_int_eq(status, 2);
1577 ptu_int_eq(isid, 11);
1578 ptu_uint_eq(buffer[0], 0x03);
1579 ptu_uint_eq(buffer[1], 0x04);
1580 ptu_uint_eq(buffer[2], 0xcc);
1582 return ptu_passed();
1585 static struct ptunit_result copy_shrink(struct image_fixture *ifix)
1587 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1590 status = pt_image_add(&ifix->copy, &ifix->section[1], &ifix->asid[1],
1592 ptu_int_eq(status, 0);
1594 status = pt_image_copy(&ifix->copy, &ifix->image);
1595 ptu_int_eq(status, 0);
1598 status = pt_image_read(&ifix->copy, &isid, buffer, 2, &ifix->asid[1],
1600 ptu_int_eq(status, 2);
1601 ptu_int_eq(isid, 11);
1602 ptu_uint_eq(buffer[0], 0x03);
1603 ptu_uint_eq(buffer[1], 0x04);
1604 ptu_uint_eq(buffer[2], 0xcc);
1606 return ptu_passed();
1609 static struct ptunit_result copy_split(struct image_fixture *ifix)
1611 uint8_t buffer[] = { 0xcc, 0xcc };
1614 status = pt_image_add(&ifix->copy, &ifix->section[0], &ifix->asid[0],
1616 ptu_int_eq(status, 0);
1618 ifix->section[1].size = 0x7;
1619 ifix->mapping[1].size = 0x7;
1621 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
1623 ptu_int_eq(status, 0);
1625 ifix->section[2].size = 0x8;
1626 ifix->mapping[2].size = 0x8;
1628 status = pt_image_add(&ifix->image, &ifix->section[2], &ifix->asid[0],
1630 ptu_int_eq(status, 0);
1632 status = pt_image_copy(&ifix->copy, &ifix->image);
1633 ptu_int_eq(status, 0);
1636 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1638 ptu_int_eq(status, 1);
1639 ptu_int_eq(isid, 2);
1640 ptu_uint_eq(buffer[0], 0x02);
1641 ptu_uint_eq(buffer[1], 0xcc);
1644 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1646 ptu_int_eq(status, 1);
1647 ptu_int_eq(isid, 3);
1648 ptu_uint_eq(buffer[0], 0x01);
1649 ptu_uint_eq(buffer[1], 0xcc);
1652 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1654 ptu_int_eq(status, 1);
1655 ptu_int_eq(isid, 1);
1656 ptu_uint_eq(buffer[0], 0x00);
1657 ptu_uint_eq(buffer[1], 0xcc);
1659 return ptu_passed();
1662 static struct ptunit_result copy_merge(struct image_fixture *ifix)
1664 uint8_t buffer[] = { 0xcc, 0xcc };
1667 ifix->section[1].size = 0x8;
1668 ifix->mapping[1].size = 0x8;
1670 status = pt_image_add(&ifix->copy, &ifix->section[1], &ifix->asid[0],
1672 ptu_int_eq(status, 0);
1674 ifix->section[2].size = 0x8;
1675 ifix->mapping[2].size = 0x8;
1677 status = pt_image_add(&ifix->copy, &ifix->section[2], &ifix->asid[0],
1679 ptu_int_eq(status, 0);
1681 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
1683 ptu_int_eq(status, 0);
1685 status = pt_image_copy(&ifix->copy, &ifix->image);
1686 ptu_int_eq(status, 0);
1689 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1691 ptu_int_eq(status, 1);
1692 ptu_int_eq(isid, 3);
1693 ptu_uint_eq(buffer[0], 0x03);
1694 ptu_uint_eq(buffer[1], 0xcc);
1697 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1699 ptu_int_eq(status, 1);
1700 ptu_int_eq(isid, 3);
1701 ptu_uint_eq(buffer[0], 0x0a);
1702 ptu_uint_eq(buffer[1], 0xcc);
1704 return ptu_passed();
1707 static struct ptunit_result copy_overlap(struct image_fixture *ifix)
1709 uint8_t buffer[] = { 0xcc, 0xcc };
1712 status = pt_image_add(&ifix->copy, &ifix->section[0], &ifix->asid[0],
1714 ptu_int_eq(status, 0);
1716 status = pt_image_add(&ifix->copy, &ifix->section[1], &ifix->asid[0],
1718 ptu_int_eq(status, 0);
1720 status = pt_image_add(&ifix->image, &ifix->section[2], &ifix->asid[0],
1722 ptu_int_eq(status, 0);
1724 status = pt_image_copy(&ifix->copy, &ifix->image);
1725 ptu_int_eq(status, 0);
1728 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1730 ptu_int_eq(status, 1);
1731 ptu_int_eq(isid, 1);
1732 ptu_uint_eq(buffer[0], 0x03);
1733 ptu_uint_eq(buffer[1], 0xcc);
1736 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1738 ptu_int_eq(status, 1);
1739 ptu_int_eq(isid, 3);
1740 ptu_uint_eq(buffer[0], 0x02);
1741 ptu_uint_eq(buffer[1], 0xcc);
1744 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1746 ptu_int_eq(status, 1);
1747 ptu_int_eq(isid, 3);
1748 ptu_uint_eq(buffer[0], 0x0e);
1749 ptu_uint_eq(buffer[1], 0xcc);
1752 status = pt_image_read(&ifix->copy, &isid, buffer, 1, &ifix->asid[0],
1754 ptu_int_eq(status, 1);
1755 ptu_int_eq(isid, 2);
1756 ptu_uint_eq(buffer[0], 0x09);
1757 ptu_uint_eq(buffer[1], 0xcc);
1759 return ptu_passed();
1762 static struct ptunit_result copy_replace(struct image_fixture *ifix)
1764 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1767 ifix->section[0].size = 0x8;
1768 ifix->mapping[0].size = 0x8;
1770 status = pt_image_add(&ifix->copy, &ifix->section[0], &ifix->asid[0],
1772 ptu_int_eq(status, 0);
1774 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[0],
1776 ptu_int_eq(status, 0);
1778 status = pt_image_copy(&ifix->copy, &ifix->image);
1779 ptu_int_eq(status, 0);
1782 status = pt_image_read(&ifix->copy, &isid, buffer, 2, &ifix->asid[0],
1784 ptu_int_eq(status, 2);
1785 ptu_int_eq(isid, 2);
1786 ptu_uint_eq(buffer[0], 0x03);
1787 ptu_uint_eq(buffer[1], 0x04);
1788 ptu_uint_eq(buffer[2], 0xcc);
1790 return ptu_passed();
1793 static struct ptunit_result add_cached_null(void)
1795 struct pt_image_section_cache iscache;
1796 struct pt_image image;
1799 status = pt_image_add_cached(NULL, &iscache, 0, NULL);
1800 ptu_int_eq(status, -pte_invalid);
1802 status = pt_image_add_cached(&image, NULL, 0, NULL);
1803 ptu_int_eq(status, -pte_invalid);
1805 return ptu_passed();
1808 static struct ptunit_result add_cached(struct image_fixture *ifix)
1810 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1811 int status, isid, risid;
1813 isid = ifix_cache_section(ifix, &ifix->section[0], 0x1000ull);
1814 ptu_int_gt(isid, 0);
1816 status = pt_image_add_cached(&ifix->image, &ifix->iscache, isid,
1818 ptu_int_eq(status, 0);
1821 status = pt_image_read(&ifix->image, &risid, buffer, 2, &ifix->asid[0],
1823 ptu_int_eq(status, 2);
1824 ptu_int_eq(risid, isid);
1825 ptu_uint_eq(buffer[0], 0x03);
1826 ptu_uint_eq(buffer[1], 0x04);
1827 ptu_uint_eq(buffer[2], 0xcc);
1829 return ptu_passed();
1832 static struct ptunit_result add_cached_null_asid(struct image_fixture *ifix)
1834 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1835 int status, isid, risid;
1837 isid = ifix_cache_section(ifix, &ifix->section[0], 0x1000ull);
1838 ptu_int_gt(isid, 0);
1840 status = pt_image_add_cached(&ifix->image, &ifix->iscache, isid, NULL);
1841 ptu_int_eq(status, 0);
1844 status = pt_image_read(&ifix->image, &risid, buffer, 2, &ifix->asid[0],
1846 ptu_int_eq(status, 2);
1847 ptu_int_eq(risid, isid);
1848 ptu_uint_eq(buffer[0], 0x03);
1849 ptu_uint_eq(buffer[1], 0x04);
1850 ptu_uint_eq(buffer[2], 0xcc);
1852 return ptu_passed();
1855 static struct ptunit_result add_cached_twice(struct image_fixture *ifix)
1857 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1858 int status, isid, risid;
1860 isid = ifix_cache_section(ifix, &ifix->section[0], 0x1000ull);
1861 ptu_int_gt(isid, 0);
1863 status = pt_image_add_cached(&ifix->image, &ifix->iscache, isid,
1865 ptu_int_eq(status, 0);
1867 status = pt_image_add_cached(&ifix->image, &ifix->iscache, isid,
1869 ptu_int_eq(status, 0);
1872 status = pt_image_read(&ifix->image, &risid, buffer, 2, &ifix->asid[0],
1874 ptu_int_eq(status, 2);
1875 ptu_int_eq(risid, isid);
1876 ptu_uint_eq(buffer[0], 0x03);
1877 ptu_uint_eq(buffer[1], 0x04);
1878 ptu_uint_eq(buffer[2], 0xcc);
1880 return ptu_passed();
1883 static struct ptunit_result add_cached_bad_isid(struct image_fixture *ifix)
1885 uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
1888 status = pt_image_add_cached(&ifix->image, &ifix->iscache, 1,
1890 ptu_int_eq(status, -pte_bad_image);
1893 status = pt_image_read(&ifix->image, &isid, buffer, 2, &ifix->asid[0],
1895 ptu_int_eq(status, -pte_nomap);
1896 ptu_int_eq(isid, -1);
1898 return ptu_passed();
1901 static struct ptunit_result find_null(struct image_fixture *ifix)
1903 struct pt_mapped_section msec;
1906 status = pt_image_find(NULL, &msec, &ifix->asid[0],
1908 ptu_int_eq(status, -pte_internal);
1910 status = pt_image_find(&ifix->image, NULL, &ifix->asid[0],
1912 ptu_int_eq(status, -pte_internal);
1914 status = pt_image_find(&ifix->image, &msec, NULL, 0x1000ull);
1915 ptu_int_eq(status, -pte_internal);
1917 return ptu_passed();
1920 static struct ptunit_result find(struct image_fixture *ifix)
1922 struct pt_mapped_section msec;
1925 status = pt_image_find(&ifix->image, &msec, &ifix->asid[1], 0x2003ull);
1926 ptu_int_eq(status, 11);
1927 ptu_ptr_eq(msec.section, &ifix->section[1]);
1928 ptu_uint_eq(msec.vaddr, 0x2000ull);
1930 status = pt_section_put(msec.section);
1931 ptu_int_eq(status, 0);
1933 return ptu_passed();
1936 static struct ptunit_result find_asid(struct image_fixture *ifix)
1938 struct pt_mapped_section msec;
1941 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
1943 ptu_int_eq(status, 0);
1945 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[1],
1947 ptu_int_eq(status, 0);
1949 status = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1009ull);
1950 ptu_int_eq(status, 1);
1951 ptu_ptr_eq(msec.section, &ifix->section[0]);
1952 ptu_uint_eq(msec.vaddr, 0x1000ull);
1954 status = pt_section_put(msec.section);
1955 ptu_int_eq(status, 0);
1957 status = pt_image_find(&ifix->image, &msec, &ifix->asid[1], 0x1009ull);
1958 ptu_int_eq(status, 2);
1959 ptu_ptr_eq(msec.section, &ifix->section[0]);
1960 ptu_uint_eq(msec.vaddr, 0x1008ull);
1962 status = pt_section_put(msec.section);
1963 ptu_int_eq(status, 0);
1965 return ptu_passed();
1968 static struct ptunit_result find_bad_asid(struct image_fixture *ifix)
1970 struct pt_mapped_section msec;
1973 status = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x2003ull);
1974 ptu_int_eq(status, -pte_nomap);
1976 return ptu_passed();
1979 static struct ptunit_result find_nomem(struct image_fixture *ifix)
1981 struct pt_mapped_section msec;
1984 status = pt_image_find(&ifix->image, &msec, &ifix->asid[1], 0x1010ull);
1985 ptu_int_eq(status, -pte_nomap);
1987 return ptu_passed();
1990 static struct ptunit_result validate_null(struct image_fixture *ifix)
1992 struct pt_mapped_section msec;
1995 status = pt_image_validate(NULL, &msec, 0x1004ull, 10);
1996 ptu_int_eq(status, -pte_internal);
1998 status = pt_image_validate(&ifix->image, NULL, 0x1004ull, 10);
1999 ptu_int_eq(status, -pte_internal);
2001 return ptu_passed();
2004 static struct ptunit_result validate(struct image_fixture *ifix)
2006 struct pt_mapped_section msec;
2009 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2010 ptu_int_ge(isid, 0);
2012 status = pt_section_put(msec.section);
2013 ptu_int_eq(status, 0);
2015 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2016 ptu_int_eq(status, 0);
2018 return ptu_passed();
2021 static struct ptunit_result validate_bad_asid(struct image_fixture *ifix)
2023 struct pt_mapped_section msec;
2026 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2027 ptu_int_ge(isid, 0);
2029 status = pt_section_put(msec.section);
2030 ptu_int_eq(status, 0);
2032 msec.asid = ifix->asid[1];
2034 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2035 ptu_int_eq(status, -pte_nomap);
2037 return ptu_passed();
2040 static struct ptunit_result validate_bad_vaddr(struct image_fixture *ifix)
2042 struct pt_mapped_section msec;
2045 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2046 ptu_int_ge(isid, 0);
2048 status = pt_section_put(msec.section);
2049 ptu_int_eq(status, 0);
2051 msec.vaddr = 0x2000ull;
2053 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2054 ptu_int_eq(status, -pte_nomap);
2056 return ptu_passed();
2059 static struct ptunit_result validate_bad_offset(struct image_fixture *ifix)
2061 struct pt_mapped_section msec;
2064 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2065 ptu_int_ge(isid, 0);
2067 status = pt_section_put(msec.section);
2068 ptu_int_eq(status, 0);
2070 msec.offset = 0x8ull;
2072 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2073 ptu_int_eq(status, -pte_nomap);
2075 return ptu_passed();
2078 static struct ptunit_result validate_bad_size(struct image_fixture *ifix)
2080 struct pt_mapped_section msec;
2083 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2084 ptu_int_ge(isid, 0);
2086 status = pt_section_put(msec.section);
2087 ptu_int_eq(status, 0);
2091 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid);
2092 ptu_int_eq(status, -pte_nomap);
2094 return ptu_passed();
2097 static struct ptunit_result validate_bad_isid(struct image_fixture *ifix)
2099 struct pt_mapped_section msec;
2102 isid = pt_image_find(&ifix->image, &msec, &ifix->asid[0], 0x1003ull);
2103 ptu_int_ge(isid, 0);
2105 status = pt_section_put(msec.section);
2106 ptu_int_eq(status, 0);
2108 status = pt_image_validate(&ifix->image, &msec, 0x1004ull, isid + 1);
2109 ptu_int_eq(status, -pte_nomap);
2111 return ptu_passed();
2114 static struct ptunit_result ifix_init(struct image_fixture *ifix)
2118 pt_image_init(&ifix->image, NULL);
2119 pt_image_init(&ifix->copy, NULL);
2121 memset(ifix->status, 0, sizeof(ifix->status));
2122 memset(ifix->mapping, 0, sizeof(ifix->mapping));
2123 memset(ifix->section, 0, sizeof(ifix->section));
2124 memset(&ifix->iscache, 0, sizeof(ifix->iscache));
2128 index = ifix_add_section(ifix, "file-0");
2129 ptu_int_eq(index, 0);
2131 index = ifix_add_section(ifix, "file-1");
2132 ptu_int_eq(index, 1);
2134 index = ifix_add_section(ifix, "file-2");
2135 ptu_int_eq(index, 2);
2137 pt_asid_init(&ifix->asid[0]);
2138 ifix->asid[0].cr3 = 0xa000;
2140 pt_asid_init(&ifix->asid[1]);
2141 ifix->asid[1].cr3 = 0xb000;
2143 pt_asid_init(&ifix->asid[2]);
2144 ifix->asid[2].cr3 = 0xc000;
2146 return ptu_passed();
2149 static struct ptunit_result rfix_init(struct image_fixture *ifix)
2153 ptu_check(ifix_init, ifix);
2155 status = pt_image_add(&ifix->image, &ifix->section[0], &ifix->asid[0],
2157 ptu_int_eq(status, 0);
2159 status = pt_image_add(&ifix->image, &ifix->section[1], &ifix->asid[1],
2161 ptu_int_eq(status, 0);
2163 return ptu_passed();
2166 static struct ptunit_result dfix_fini(struct image_fixture *ifix)
2168 pt_image_fini(&ifix->image);
2170 return ptu_passed();
2173 static struct ptunit_result ifix_fini(struct image_fixture *ifix)
2177 ptu_check(dfix_fini, ifix);
2179 pt_image_fini(&ifix->copy);
2181 for (sec = 0; sec < ifix_nsecs; ++sec) {
2182 ptu_int_eq(ifix->section[sec].ucount, 0);
2183 ptu_int_eq(ifix->section[sec].mcount, 0);
2184 ptu_int_le(ifix->status[sec].deleted, 1);
2185 ptu_int_eq(ifix->status[sec].bad_put, 0);
2188 return ptu_passed();
2191 int main(int argc, char **argv)
2193 struct image_fixture dfix, ifix, rfix;
2194 struct ptunit_suite suite;
2196 /* Dfix provides image destruction. */
2198 dfix.fini = dfix_fini;
2200 /* Ifix provides an empty image. */
2201 ifix.init = ifix_init;
2202 ifix.fini = ifix_fini;
2204 /* Rfix provides an image with two sections added. */
2205 rfix.init = rfix_init;
2206 rfix.fini = ifix_fini;
2208 suite = ptunit_mk_suite(argc, argv);
2210 ptu_run(suite, init);
2211 ptu_run_f(suite, init_name, dfix);
2212 ptu_run(suite, init_null);
2214 ptu_run(suite, fini);
2215 ptu_run(suite, fini_empty);
2216 ptu_run(suite, fini_null);
2218 ptu_run_f(suite, name, dfix);
2219 ptu_run(suite, name_none);
2220 ptu_run(suite, name_null);
2222 ptu_run_f(suite, read_empty, ifix);
2223 ptu_run_f(suite, overlap_front, ifix);
2224 ptu_run_f(suite, overlap_back, ifix);
2225 ptu_run_f(suite, overlap_multiple, ifix);
2226 ptu_run_f(suite, overlap_mid, ifix);
2227 ptu_run_f(suite, contained, ifix);
2228 ptu_run_f(suite, contained_multiple, ifix);
2229 ptu_run_f(suite, contained_back, ifix);
2230 ptu_run_f(suite, same, ifix);
2231 ptu_run_f(suite, same_different_isid, ifix);
2232 ptu_run_f(suite, same_different_offset, ifix);
2233 ptu_run_f(suite, adjacent, ifix);
2235 ptu_run_f(suite, read_null, rfix);
2236 ptu_run_f(suite, read, rfix);
2237 ptu_run_f(suite, read_null, rfix);
2238 ptu_run_f(suite, read_asid, ifix);
2239 ptu_run_f(suite, read_bad_asid, rfix);
2240 ptu_run_f(suite, read_null_asid, rfix);
2241 ptu_run_f(suite, read_callback, rfix);
2242 ptu_run_f(suite, read_nomem, rfix);
2243 ptu_run_f(suite, read_truncated, rfix);
2244 ptu_run_f(suite, read_error, rfix);
2245 ptu_run_f(suite, read_spurious_error, rfix);
2247 ptu_run_f(suite, remove_section, rfix);
2248 ptu_run_f(suite, remove_bad_vaddr, rfix);
2249 ptu_run_f(suite, remove_bad_asid, rfix);
2250 ptu_run_f(suite, remove_by_filename, rfix);
2251 ptu_run_f(suite, remove_by_filename_bad_asid, rfix);
2252 ptu_run_f(suite, remove_none_by_filename, rfix);
2253 ptu_run_f(suite, remove_all_by_filename, ifix);
2254 ptu_run_f(suite, remove_by_asid, rfix);
2256 ptu_run_f(suite, copy_empty, ifix);
2257 ptu_run_f(suite, copy, rfix);
2258 ptu_run_f(suite, copy_self, rfix);
2259 ptu_run_f(suite, copy_shrink, rfix);
2260 ptu_run_f(suite, copy_split, ifix);
2261 ptu_run_f(suite, copy_merge, ifix);
2262 ptu_run_f(suite, copy_overlap, ifix);
2263 ptu_run_f(suite, copy_replace, ifix);
2265 ptu_run(suite, add_cached_null);
2266 ptu_run_f(suite, add_cached, ifix);
2267 ptu_run_f(suite, add_cached_null_asid, ifix);
2268 ptu_run_f(suite, add_cached_twice, ifix);
2269 ptu_run_f(suite, add_cached_bad_isid, ifix);
2271 ptu_run_f(suite, find_null, rfix);
2272 ptu_run_f(suite, find, rfix);
2273 ptu_run_f(suite, find_asid, ifix);
2274 ptu_run_f(suite, find_bad_asid, rfix);
2275 ptu_run_f(suite, find_nomem, rfix);
2277 ptu_run_f(suite, validate_null, rfix);
2278 ptu_run_f(suite, validate, rfix);
2279 ptu_run_f(suite, validate_bad_asid, rfix);
2280 ptu_run_f(suite, validate_bad_vaddr, rfix);
2281 ptu_run_f(suite, validate_bad_offset, rfix);
2282 ptu_run_f(suite, validate_bad_size, rfix);
2283 ptu_run_f(suite, validate_bad_isid, rfix);
2285 return ptunit_report(&suite);