Lines Matching refs:ptr
65 static int sys_mprotect(void *ptr, size_t size, unsigned long prot)
70 sret = syscall(__NR_mprotect, ptr, size, prot);
74 static int sys_mprotect_pkey(void *ptr, size_t size, unsigned long orig_prot,
80 sret = syscall(__NR_pkey_mprotect, ptr, size, orig_prot, pkey);
84 static int sys_munmap(void *ptr, size_t size)
89 sret = syscall(__NR_munmap, ptr, size);
172 void *ptr;
174 ptr = mmap(NULL, size, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
175 *ptrOut = ptr;
180 void *ptr;
183 ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, mapflags, -1, 0);
184 *ptrOut = ptr;
187 static int clean_single_address(void *ptr, int size)
190 ret = munmap(ptr, size);
194 static int seal_single_address(void *ptr, int size)
197 ret = sys_mseal(ptr, size);
204 void *ptr;
207 ptr = mmap(NULL, page_size, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
208 if (ptr == (void *) -1)
211 ret = sys_mseal(ptr, page_size);
232 void *ptr;
236 setup_single_address(size, &ptr);
237 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
239 ret = sys_mseal(ptr, size);
248 void *ptr;
252 setup_single_address(size, &ptr);
253 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
255 /* munmap 2 pages from ptr. */
256 ret = sys_munmap(ptr, 2 * page_size);
259 /* mprotect will fail because 2 pages from ptr are unmapped. */
260 ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
263 /* mseal will fail because 2 pages from ptr are unmapped. */
264 ret = sys_mseal(ptr, size);
267 ret = sys_mseal(ptr + 2 * page_size, 2 * page_size);
276 void *ptr;
280 setup_single_address(size, &ptr);
281 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
283 /* munmap 2 pages from ptr + page. */
284 ret = sys_munmap(ptr + page_size, 2 * page_size);
288 ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
292 ret = sys_mseal(ptr, size);
296 ret = sys_mseal(ptr, page_size);
299 ret = sys_mseal(ptr + 3 * page_size, page_size);
308 void *ptr;
312 setup_single_address(size, &ptr);
313 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
316 ret = sys_munmap(ptr + 2 * page_size, 2 * page_size);
320 ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
324 ret = sys_mseal(ptr, size);
328 ret = sys_mseal(ptr, 2 * page_size);
337 void *ptr;
341 setup_single_address(size, &ptr);
342 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
345 ret = sys_mprotect(ptr + page_size, 2 * page_size,
350 ret = sys_mprotect(ptr, size, PROT_READ);
354 ret = sys_mprotect(ptr + page_size, 2 * page_size,
359 ret = sys_mseal(ptr, size);
368 void *ptr;
372 setup_single_address(size, &ptr);
373 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
376 ret = sys_mprotect(ptr, 2 * page_size, PROT_READ | PROT_WRITE);
380 ret = sys_mseal(ptr, page_size);
384 ret = sys_mseal(ptr + page_size, 3 * page_size);
393 void *ptr;
397 setup_single_address(size, &ptr);
398 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
401 ret = sys_mprotect(ptr, 2 * page_size, PROT_READ | PROT_WRITE);
405 ret = sys_mseal(ptr + 3 * page_size, page_size);
409 ret = sys_mseal(ptr, 3 * page_size);
417 void *ptr;
422 setup_single_address(8 * page_size, &ptr);
423 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
424 ret = clean_single_address(ptr + 4 * page_size, 4 * page_size);
428 ret = syscall(__NR_mseal, ptr, size, 0x20);
432 ret = sys_mseal(ptr + 1, 2 * page_size);
436 ret = sys_mseal(ptr, 5 * page_size);
440 ret = sys_mseal(ptr, UINT64_MAX/page_size);
444 ret = sys_mseal(ptr - page_size, 5 * page_size);
452 void *ptr;
457 setup_single_address(size, &ptr);
458 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
460 ret = sys_mprotect(ptr, 0, PROT_READ | PROT_WRITE);
464 ret = sys_mseal(ptr, 0);
468 ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
476 void *ptr;
483 ptr = mmap(0, size, PROT_NONE,
485 FAIL_TEST_IF_FALSE(ptr == 0);
487 size = get_vma_size(ptr, &prot);
490 ret = sys_mseal(ptr, size);
494 ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
503 void *ptr;
507 setup_single_address(size, &ptr);
508 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
510 ret = sys_mseal(ptr, size);
514 ret = sys_mseal(ptr, size);
522 void *ptr;
527 setup_single_address(size, &ptr);
528 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
531 ret = seal_single_address(ptr, size);
535 ret = sys_mprotect(ptr, size, PROT_READ | PROT_WRITE);
546 void *ptr;
551 setup_single_address(size, &ptr);
552 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
555 ret = seal_single_address(ptr, page_size);
560 ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);
567 ret = sys_mprotect(ptr + page_size, page_size * 3,
576 void *ptr;
581 setup_single_address(size, &ptr);
582 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
585 ret = seal_single_address(ptr + page_size, 3 * page_size);
590 ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);
594 ret = sys_mprotect(ptr + page_size, page_size * 3,
606 void *ptr;
611 setup_single_address(size, &ptr);
612 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
615 ret = seal_single_address(ptr, page_size * 2 - 1);
620 ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
626 ret = sys_mprotect(ptr + page_size * 2, page_size,
635 void *ptr;
640 setup_single_address(size, &ptr);
641 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
643 ret = seal_single_address(ptr, page_size * 2 + 1);
648 ret = sys_mprotect(ptr, page_size * 3, PROT_READ | PROT_WRITE);
654 ret = sys_mprotect(ptr + page_size * 3, page_size,
663 void *ptr;
668 setup_single_address(size, &ptr);
669 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
672 ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
676 ret = seal_single_address(ptr, page_size * 4);
680 ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
686 ret = sys_mprotect(ptr + page_size * 2, page_size * 2,
698 void *ptr;
703 setup_single_address(size, &ptr);
704 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
707 ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
712 ret = seal_single_address(ptr + page_size, page_size * 2);
717 ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);
721 ret = sys_mprotect(ptr + page_size, page_size, PROT_READ | PROT_WRITE);
728 ret = sys_mprotect(ptr + 2 * page_size, page_size,
736 ret = sys_mprotect(ptr + 3 * page_size, page_size,
745 void *ptr;
750 setup_single_address(size, &ptr);
751 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
755 ret = seal_single_address(ptr, page_size);
760 ret = sys_mprotect(ptr, 2 * page_size, PROT_READ | PROT_WRITE);
771 void *ptr;
782 setup_single_address(size, &ptr);
783 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
786 ret = sys_mseal(ptr + page_size, page_size);
790 ret = sys_mprotect(ptr, size, PROT_EXEC);
797 FAIL_TEST_IF_FALSE(get_vma_size(ptr + page_size, &prot) > 0);
807 void *ptr;
812 setup_single_address(size, &ptr);
813 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
816 ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);
820 ret = sys_mprotect(ptr + 3 * page_size, page_size,
825 ret = sys_munmap(ptr + page_size, 2 * page_size);
830 ret = sys_mprotect(ptr, 4 * page_size, PROT_READ);
834 ret = sys_mseal(ptr, 4 * page_size);
838 ret = sys_mprotect(ptr, page_size, PROT_READ);
842 ret = sys_mprotect(ptr + 3 * page_size, page_size, PROT_READ);
850 void *ptr;
855 setup_single_address(size, &ptr);
856 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
859 ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);
864 ret = sys_mseal(ptr, 4 * page_size);
869 ret = sys_mprotect(ptr, 2 * page_size, PROT_READ);
876 ret = sys_mprotect(ptr + 2 * page_size, 2 * page_size, PROT_READ);
887 void *ptr;
892 setup_single_address(size, &ptr);
893 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
896 ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);
901 ret = sys_mseal(ptr, 2 * page_size);
906 ret = sys_mprotect(ptr, 2 * page_size, PROT_READ);
913 ret = sys_mprotect(ptr + 2 * page_size, 2 * page_size, PROT_READ);
921 void *ptr;
926 setup_single_address(size, &ptr);
927 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
930 ret = sys_mseal(ptr, size);
935 ret = sys_munmap(ptr, size);
952 void *ptr;
957 setup_single_address(size, &ptr);
958 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
961 ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);
965 ret = sys_mseal(ptr, size);
969 ret = sys_munmap(ptr, page_size * 2);
975 ret = sys_munmap(ptr + page_size, page_size * 2);
993 void *ptr;
998 setup_single_address(size, &ptr);
999 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1001 ret = sys_munmap(ptr + page_size, page_size * 2);
1006 ret = sys_mseal(ptr, size);
1010 ret = sys_munmap(ptr, page_size);
1013 ret = sys_munmap(ptr + page_size * 2, page_size);
1016 ret = sys_munmap(ptr, size);
1024 void *ptr;
1030 setup_single_address(size, &ptr);
1031 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1034 ret = sys_mseal(ptr + page_size, page_size);
1038 ret = sys_munmap(ptr, size);
1045 FAIL_TEST_IF_FALSE(get_vma_size(ptr + page_size, &prot) > 0);
1054 void *ptr;
1060 setup_single_address(size, &ptr);
1061 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1064 ret = sys_munmap(ptr, page_size);
1069 ret = sys_mseal(ptr + page_size, 3 * page_size);
1074 ret = sys_munmap(ptr, size);
1078 size = get_vma_size(ptr + page_size, &prot);
1085 size = get_vma_size(ptr + page_size, &prot);
1094 void *ptr;
1099 setup_single_address(size, &ptr);
1100 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1103 ret = sys_munmap(ptr + page_size * 3, page_size);
1108 ret = sys_mseal(ptr, 3 * page_size);
1113 ret = sys_munmap(ptr, size);
1124 void *ptr;
1130 setup_single_address(size, &ptr);
1131 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1134 ret = sys_munmap(ptr + page_size, page_size * 2);
1139 ret = sys_mseal(ptr, page_size);
1144 ret = sys_munmap(ptr, size);
1148 size = get_vma_size(ptr, &prot);
1151 size = get_vma_size(ptr + page_size * 3, &prot);
1156 size = get_vma_size(ptr, &prot);
1159 size = get_vma_size(ptr + page_size * 3, &prot);
1168 void *ptr;
1174 setup_single_address(size, &ptr);
1175 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1178 ret = sys_mseal(ptr, size);
1183 ret2 = sys_mremap(ptr, size, 2 * page_size, 0, 0);
1197 void *ptr;
1203 setup_single_address(size, &ptr);
1204 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1206 ret = sys_munmap(ptr + 2 * page_size, 2 * page_size);
1210 ret = sys_mseal(ptr, 2 * page_size);
1215 ret2 = sys_mremap(ptr, 2 * page_size, 4 * page_size, 0, 0);
1220 FAIL_TEST_IF_FALSE(ret2 == ptr);
1229 void *ptr, *newPtr;
1235 setup_single_address(size, &ptr);
1236 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1243 ret = sys_mseal(ptr, size);
1247 /* move from ptr to fixed address. */
1248 ret2 = sys_mremap(ptr, size, size, MREMAP_MAYMOVE | MREMAP_FIXED, newPtr);
1262 void *ptr;
1268 setup_single_address(size, &ptr);
1269 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1272 ret = sys_mseal(ptr, size);
1277 ret2 = mmap(ptr, size, PROT_NONE,
1283 FAIL_TEST_IF_FALSE(ret2 == ptr);
1290 void *ptr;
1296 setup_single_address(size, &ptr);
1297 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1299 ret = sys_munmap(ptr + 8 * page_size, 4 * page_size);
1303 ret = sys_mseal(ptr, 8 * page_size);
1308 ret2 = mmap(ptr, size, PROT_READ,
1314 FAIL_TEST_IF_FALSE(ret2 == ptr);
1321 void *ptr;
1327 setup_single_address(size, &ptr);
1328 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1331 ret = sys_mseal(ptr, size);
1336 ret2 = mmap(ptr, 8 * page_size, PROT_READ,
1342 FAIL_TEST_IF_FALSE(ret2 == ptr);
1349 void *ptr;
1356 setup_single_address(size, &ptr);
1357 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1362 ret = sys_mseal(ptr, size);
1367 ret2 = sys_mremap(ptr, size, 2 * page_size, MREMAP_MAYMOVE | MREMAP_FIXED,
1380 void *ptr;
1387 setup_single_address(page_size, &ptr);
1388 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1398 ret2 = sys_mremap(ptr, page_size, size, MREMAP_MAYMOVE | MREMAP_FIXED,
1411 void *ptr;
1418 setup_single_address(size, &ptr);
1419 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1429 ret2 = sys_mremap(ptr, size, size, MREMAP_MAYMOVE | MREMAP_FIXED, newAddr);
1441 void *ptr;
1447 setup_single_address(size, &ptr);
1448 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1451 ret = sys_mseal(ptr, size);
1458 ret2 = sys_mremap(ptr, size, 2 * page_size, MREMAP_MAYMOVE | MREMAP_FIXED,
1472 void *ptr;
1478 setup_single_address(size, &ptr);
1479 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1482 ret = sys_mseal(ptr, size);
1487 ret2 = sys_mremap(ptr, size, size, MREMAP_MAYMOVE | MREMAP_DONTUNMAP, 0);
1501 void *ptr, *ptr2;
1507 setup_single_address(size, &ptr);
1508 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1511 ret = sys_mseal(ptr, size);
1527 ret2 = sys_mremap(ptr, size, size, MREMAP_MAYMOVE | MREMAP_DONTUNMAP,
1542 void *ptr;
1549 setup_single_address(24 * page_size, &ptr);
1550 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1554 ret = sys_mprotect(ptr, page_size, PROT_NONE);
1556 ret = sys_mprotect(ptr + 23 * page_size, page_size, PROT_NONE);
1558 size = get_vma_size(ptr + page_size, &prot);
1564 ret = sys_mseal(ptr + page_size, page_size);
1566 size = get_vma_size(ptr + page_size, &prot);
1569 size = get_vma_size(ptr + 2 * page_size, &prot);
1575 ret = sys_mseal(ptr + 22 * page_size, page_size);
1577 size = get_vma_size(ptr + 22 * page_size, &prot);
1580 size = get_vma_size(ptr + 2 * page_size, &prot);
1586 ret = sys_mseal(ptr + 2 * page_size, page_size);
1588 size = get_vma_size(ptr + page_size, &prot);
1594 ret = sys_mseal(ptr + 21 * page_size, page_size);
1596 size = get_vma_size(ptr + 21 * page_size, &prot);
1602 ret = sys_mseal(ptr + 2 * page_size, 2 * page_size);
1604 size = get_vma_size(ptr + 1 * page_size, &prot);
1607 ret = sys_munmap(ptr + page_size, page_size);
1609 ret = sys_mprotect(ptr + 2 * page_size, page_size, PROT_NONE);
1614 ret = sys_mseal(ptr + 20 * page_size, 2 * page_size);
1617 size = get_vma_size(ptr + 20 * page_size, &prot);
1623 ret = sys_mseal(ptr + 2 * page_size, 20 * page_size);
1625 size = get_vma_size(ptr + page_size, &prot);
1634 void *ptr;
1639 setup_single_address_rw(size, &ptr);
1640 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1643 ret = sys_mseal(ptr, size);
1648 ret = sys_madvise(ptr, size, MADV_DONTNEED);
1652 ret = sys_munmap(ptr, size);
1663 void *ptr;
1671 setup_single_address_rw(size, &ptr);
1672 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1677 ret = sys_mprotect_pkey((void *)ptr, size, PROT_READ | PROT_WRITE, pkey);
1681 ret = sys_mseal(ptr, size);
1687 ret = sys_madvise(ptr, size, MADV_DONTNEED);
1692 ret = sys_madvise(ptr, size, MADV_DONTNEED);
1699 ret = sys_munmap(ptr, size);
1710 void *ptr;
1723 ptr = mmap(NULL, size, PROT_READ, mapflags, fd, 0);
1724 FAIL_TEST_IF_FALSE(ptr != MAP_FAILED);
1727 ret = sys_mseal(ptr, size);
1732 ret = sys_madvise(ptr, size, MADV_DONTNEED);
1735 ret = sys_munmap(ptr, size);
1747 void *ptr;
1753 ptr = mmap(NULL, size, PROT_READ, mapflags, -1, 0);
1754 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1757 ret = sys_mseal(ptr, size);
1762 ret = sys_madvise(ptr, size, MADV_DONTNEED);
1765 ret = sys_munmap(ptr, size);
1776 void *ptr;
1781 setup_single_address(size, &ptr);
1782 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1785 ret = seal_single_address(ptr, size);
1789 ret = sys_madvise(ptr, size, MADV_DONTNEED);
1795 ret = sys_munmap(ptr, size);
1806 void *ptr;
1811 setup_single_address(size, &ptr);
1812 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1815 ret = seal_single_address(ptr + page_size, page_size);
1819 ret = sys_madvise(ptr, size, MADV_DONTNEED);
1825 ret = sys_munmap(ptr, size);
1837 void *ptr;
1842 setup_single_address(size, &ptr);
1843 FAIL_TEST_IF_FALSE(ptr != (void *)-1);
1846 ret = seal_single_address(ptr, size);
1855 ret = sys_madvise(ptr, size, MADV_RANDOM);
1858 ret = sys_munmap(ptr, size);