Lines Matching defs:ptr

38 	void		*ptr;
187 cmd.addr = (__u64)buffer->ptr;
188 cmd.ptr = (__u64)buffer->mirror;
210 if (buffer->ptr)
211 munmap(buffer->ptr, buffer->size);
298 int *ptr;
314 buffer->ptr = mmap(NULL, size,
318 ASSERT_NE(buffer->ptr, MAP_FAILED);
324 i = 2 * self->page_size / sizeof(*ptr);
325 for (ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
326 ptr[i] = i;
329 ret = mprotect(buffer->ptr, size, PROT_READ);
333 val = *(int *)(buffer->ptr + self->page_size);
343 ptr = buffer->mirror;
344 for (i = 0; i < 2 * self->page_size / sizeof(*ptr); ++i)
345 ASSERT_EQ(ptr[i], 0);
346 for (; i < size / sizeof(*ptr); ++i)
347 ASSERT_EQ(ptr[i], i);
362 int *ptr;
377 buffer->ptr = mmap(NULL, size,
381 ASSERT_NE(buffer->ptr, MAP_FAILED);
384 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
385 ptr[i] = i;
388 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
389 ptr[i] = -i;
392 ret = mprotect(buffer->ptr, size, PROT_NONE);
400 ret = mprotect(buffer->ptr, size, PROT_READ);
402 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
403 ASSERT_EQ(ptr[i], i);
406 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
407 ASSERT_EQ(ptr[i], -i);
421 int *ptr;
436 buffer->ptr = mmap(NULL, size,
440 ASSERT_NE(buffer->ptr, MAP_FAILED);
442 /* Initialize data that the device will write to buffer->ptr. */
443 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
444 ptr[i] = i;
453 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
454 ASSERT_EQ(ptr[i], i);
469 int *ptr;
484 buffer->ptr = mmap(NULL, size,
488 ASSERT_NE(buffer->ptr, MAP_FAILED);
496 /* Initialize data that the device will write to buffer->ptr. */
497 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
498 ptr[i] = i;
505 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
506 ASSERT_EQ(ptr[i], 0);
509 ret = mprotect(buffer->ptr, size, PROT_WRITE | PROT_READ);
519 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
520 ASSERT_EQ(ptr[i], i);
535 int *ptr;
552 buffer->ptr = mmap(NULL, size,
556 ASSERT_NE(buffer->ptr, MAP_FAILED);
558 /* Initialize buffer->ptr so we can tell if it is written. */
559 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
560 ptr[i] = i;
562 /* Initialize data that the device will write to buffer->ptr. */
563 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
564 ptr[i] = -i;
574 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
575 ASSERT_EQ(ptr[i], i);
580 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
581 ASSERT_EQ(ptr[i], i);
582 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
583 ASSERT_EQ(ptr[i], -i);
596 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
597 ASSERT_EQ(ptr[i], -i);
613 int *ptr;
630 buffer->ptr = mmap(NULL, size,
634 ASSERT_NE(buffer->ptr, MAP_FAILED);
636 /* Initialize buffer->ptr so we can tell if it is written. */
637 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
638 ptr[i] = i;
640 /* Initialize data that the device will write to buffer->ptr. */
641 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
642 ptr[i] = -i;
652 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
653 ASSERT_EQ(ptr[i], -i);
658 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
659 ASSERT_EQ(ptr[i], i);
660 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
661 ASSERT_EQ(ptr[i], -i);
674 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
675 ASSERT_EQ(ptr[i], -i);
692 int *ptr;
705 buffer->ptr = mmap(NULL, size,
709 ASSERT_NE(buffer->ptr, MAP_FAILED);
713 map = (void *)ALIGN((uintptr_t)buffer->ptr, size);
716 old_ptr = buffer->ptr;
717 buffer->ptr = map;
719 /* Initialize data that the device will write to buffer->ptr. */
720 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
721 ptr[i] = i;
730 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
731 ASSERT_EQ(ptr[i], i);
733 buffer->ptr = old_ptr;
795 int *ptr;
809 buffer->ptr = mmap(NULL, size,
813 if (buffer->ptr == MAP_FAILED) {
823 /* Initialize data that the device will write to buffer->ptr. */
824 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
825 ptr[i] = i;
834 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
835 ASSERT_EQ(ptr[i], i);
837 munmap(buffer->ptr, buffer->size);
838 buffer->ptr = NULL;
851 int *ptr;
872 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
873 ptr[i] = i;
878 buffer->ptr = mmap(NULL, size,
882 ASSERT_NE(buffer->ptr, MAP_FAILED);
891 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
892 ASSERT_EQ(ptr[i], i);
906 int *ptr;
926 buffer->ptr = mmap(NULL, size,
930 ASSERT_NE(buffer->ptr, MAP_FAILED);
932 /* Initialize data that the device will write to buffer->ptr. */
933 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
934 ptr[i] = i;
943 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
944 ASSERT_EQ(ptr[i], i);
949 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
950 ASSERT_EQ(ptr[i], i);
964 int *ptr;
979 buffer->ptr = mmap(NULL, size,
983 ASSERT_NE(buffer->ptr, MAP_FAILED);
986 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
987 ptr[i] = i;
995 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
996 ASSERT_EQ(ptr[i], i);
1012 int *ptr;
1027 buffer->ptr = mmap(NULL, size,
1031 ASSERT_NE(buffer->ptr, MAP_FAILED);
1034 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1035 ptr[i] = i;
1043 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1044 ASSERT_EQ(ptr[i], i);
1047 for (i = 0, ptr = buffer->ptr; i < size / (2 * sizeof(*ptr)); ++i)
1048 ASSERT_EQ(ptr[i], i);
1056 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1057 ASSERT_EQ(ptr[i], i);
1068 int *ptr;
1083 buffer->ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,
1085 ASSERT_NE(buffer->ptr, MAP_FAILED);
1088 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1089 ptr[i] = i;
1097 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1098 ASSERT_EQ(ptr[i], i);
1105 for (i = 0, ptr = buffer->ptr; i < size / (2 * sizeof(*ptr)); ++i)
1106 ASSERT_EQ(ptr[i], i);
1133 buffer->ptr = mmap(NULL, size,
1137 ASSERT_NE(buffer->ptr, MAP_FAILED);
1154 int *ptr;
1171 buffer->ptr = mmap(NULL, size,
1175 ASSERT_NE(buffer->ptr, MAP_FAILED);
1176 p = buffer->ptr;
1183 ret = munmap(buffer->ptr + self->page_size, self->page_size);
1191 ret = mprotect(buffer->ptr + 2 * self->page_size, self->page_size,
1194 ptr = (int *)(buffer->ptr + 2 * self->page_size);
1195 val = *ptr + 3;
1199 ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,
1202 ptr = (int *)(buffer->ptr + 3 * self->page_size);
1203 *ptr = val;
1204 ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,
1209 ret = mprotect(buffer->ptr + 4 * self->page_size, 2 * self->page_size,
1212 ptr = (int *)(buffer->ptr + 4 * self->page_size);
1213 *ptr = val;
1214 ptr = (int *)(buffer->ptr + 5 * self->page_size);
1215 *ptr = val;
1218 buffer->ptr = p + 2 * self->page_size;
1224 buffer->ptr = p + 5 * self->page_size;
1227 buffer->ptr = p;
1229 buffer->ptr = p;
1248 int *ptr;
1264 buffer->ptr = mmap(NULL, size,
1268 ASSERT_NE(buffer->ptr, MAP_FAILED);
1271 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1272 ptr[i] = i;
1280 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1281 ASSERT_EQ(ptr[i], i);
1290 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1291 ASSERT_EQ(ptr[i], i);
1307 int *ptr;
1323 buffer->ptr = mmap(NULL, size,
1327 ASSERT_NE(buffer->ptr, MAP_FAILED);
1330 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1331 ptr[i] = i + c;
1341 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1342 ASSERT_EQ(ptr[i], i + c);
1354 munmap(buffer->ptr + buffer->size / 2, buffer->size / 2);
1355 buffer->ptr = NULL;
1378 int *ptr;
1389 buffer->ptr = mmap(NULL, size,
1393 ASSERT_NE(buffer->ptr, MAP_FAILED);
1396 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1397 ptr[i] = i + c;
1410 for (i = 0, ptr = buffer->mirror;
1411 i < size / sizeof(*ptr);
1413 ASSERT_EQ(ptr[i], i + c);
1445 buffer->ptr = mmap(NULL, size,
1449 ASSERT_NE(buffer->ptr, MAP_FAILED);
1471 int *ptr;
1489 buffer->ptr = mmap(NULL, size,
1493 ASSERT_NE(buffer->ptr, MAP_FAILED);
1494 p = buffer->ptr;
1497 ret = munmap(buffer->ptr + self->page_size, self->page_size);
1501 ret = mprotect(buffer->ptr + 2 * self->page_size, self->page_size,
1504 ptr = (int *)(buffer->ptr + 2 * self->page_size);
1505 val = *ptr + 3;
1509 ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,
1512 ptr = (int *)(buffer->ptr + 3 * self->page_size);
1513 *ptr = val;
1514 ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,
1519 ret = mprotect(buffer->ptr + 4 * self->page_size, 3 * self->page_size,
1522 ptr = (int *)(buffer->ptr + 4 * self->page_size);
1523 *ptr = val;
1526 buffer->ptr = p + 5 * self->page_size;
1532 buffer->ptr = p + 6 * self->page_size;
1538 buffer->ptr = p;
1574 int *ptr;
1592 buffer->ptr = mmap(NULL, size,
1596 if (buffer->ptr == MAP_FAILED) {
1605 /* Initialize the pages the device will snapshot in buffer->ptr. */
1606 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1607 ptr[i] = i;
1621 ret = mprotect(buffer->ptr, size, PROT_READ);
1635 munmap(buffer->ptr, buffer->size);
1636 buffer->ptr = NULL;
1649 int *ptr;
1664 buffer->ptr = mmap(NULL, size,
1668 ASSERT_NE(buffer->ptr, MAP_FAILED);
1671 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1672 ptr[i] = i;
1675 ret = mprotect(buffer->ptr, size, PROT_READ);
1685 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1686 ASSERT_EQ(ptr[i], i);
1695 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1696 ASSERT_EQ(ptr[i], i);
1709 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1710 ASSERT_EQ(ptr[i], i);
1724 int *ptr;
1739 buffer->ptr = mmap(NULL, size,
1743 ASSERT_NE(buffer->ptr, MAP_FAILED);
1746 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1747 ptr[i] = i;
1755 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1756 ASSERT_EQ(ptr[i], i);
1759 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1760 ASSERT_EQ(ptr[i]++, i);
1762 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1763 ASSERT_EQ(ptr[i], i+1);
1778 int *ptr;
1793 buffer->ptr = mmap(NULL, size,
1797 ASSERT_NE(buffer->ptr, MAP_FAILED);
1800 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1801 ptr[i] = i;
1809 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1810 ASSERT_EQ(ptr[i], i);
1812 ret = mprotect(buffer->ptr, size, PROT_READ);
1831 int *ptr;
1846 buffer->ptr = mmap(NULL, size,
1850 ASSERT_NE(buffer->ptr, MAP_FAILED);
1853 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1854 ptr[i] = i;
1864 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1865 ASSERT_EQ(ptr[i]++, i);
1867 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1868 ASSERT_EQ(ptr[i], i+1);
1905 int *ptr;
1924 buffer->ptr = mmap(NULL, size,
1928 ASSERT_NE(buffer->ptr, MAP_FAILED);
1931 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1932 ptr[i] = i;
1939 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1940 ASSERT_EQ(ptr[i], i);
1943 (unsigned long)buffer->ptr,
1946 (unsigned long)buffer->ptr + 1 * self->page_size,
1949 (unsigned long)buffer->ptr + 2 * self->page_size,
1952 (unsigned long)buffer->ptr + 3 * self->page_size,
1973 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1974 ASSERT_EQ(ptr[i], i);
1993 int *ptr;
2010 buffer->ptr = mmap(NULL, size,
2014 ASSERT_NE(buffer->ptr, MAP_FAILED);
2017 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
2018 ptr[i] = i;
2040 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
2041 ptr[i] = i;