Lines Matching refs:buffer
180 struct hmm_buffer *buffer,
187 cmd.addr = (__u64)buffer->ptr;
188 cmd.ptr = (__u64)buffer->mirror;
199 buffer->cpages = cmd.cpages;
200 buffer->faults = cmd.faults;
205 static void hmm_buffer_free(struct hmm_buffer *buffer)
207 if (buffer == NULL)
210 if (buffer->ptr)
211 munmap(buffer->ptr, buffer->size);
212 free(buffer->mirror);
213 free(buffer);
269 struct hmm_buffer *buffer,
272 return hmm_dmirror_cmd(fd, HMM_DMIRROR_MIGRATE_TO_DEV, buffer, npages);
276 struct hmm_buffer *buffer,
279 return hmm_dmirror_cmd(fd, HMM_DMIRROR_MIGRATE_TO_SYS, buffer, npages);
294 struct hmm_buffer *buffer;
306 buffer = malloc(sizeof(*buffer));
307 ASSERT_NE(buffer, NULL);
309 buffer->fd = -1;
310 buffer->size = size;
311 buffer->mirror = malloc(size);
312 ASSERT_NE(buffer->mirror, NULL);
314 buffer->ptr = mmap(NULL, size,
317 buffer->fd, 0);
318 ASSERT_NE(buffer->ptr, MAP_FAILED);
321 * Initialize buffer in system memory but leave the first two pages
325 for (ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
328 /* Set buffer permission to read-only. */
329 ret = mprotect(buffer->ptr, size, PROT_READ);
333 val = *(int *)(buffer->ptr + self->page_size);
337 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_READ, buffer, npages);
339 ASSERT_EQ(buffer->cpages, npages);
340 ASSERT_EQ(buffer->faults, 1);
343 ptr = buffer->mirror;
349 hmm_buffer_free(buffer);
358 struct hmm_buffer *buffer;
369 buffer = malloc(sizeof(*buffer));
370 ASSERT_NE(buffer, NULL);
372 buffer->fd = -1;
373 buffer->size = size;
374 buffer->mirror = malloc(size);
375 ASSERT_NE(buffer->mirror, NULL);
377 buffer->ptr = mmap(NULL, size,
380 buffer->fd, 0);
381 ASSERT_NE(buffer->ptr, MAP_FAILED);
383 /* Initialize buffer in system memory. */
384 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
387 /* Initialize mirror buffer so we can verify it isn't written. */
388 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
391 /* Protect buffer from reading. */
392 ret = mprotect(buffer->ptr, size, PROT_NONE);
396 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_READ, buffer, npages);
399 /* Allow CPU to read the buffer so we can check it. */
400 ret = mprotect(buffer->ptr, size, PROT_READ);
402 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
406 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
409 hmm_buffer_free(buffer);
417 struct hmm_buffer *buffer;
428 buffer = malloc(sizeof(*buffer));
429 ASSERT_NE(buffer, NULL);
431 buffer->fd = -1;
432 buffer->size = size;
433 buffer->mirror = malloc(size);
434 ASSERT_NE(buffer->mirror, NULL);
436 buffer->ptr = mmap(NULL, size,
439 buffer->fd, 0);
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)
447 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_WRITE, buffer, npages);
449 ASSERT_EQ(buffer->cpages, npages);
450 ASSERT_EQ(buffer->faults, 1);
453 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
456 hmm_buffer_free(buffer);
465 struct hmm_buffer *buffer;
476 buffer = malloc(sizeof(*buffer));
477 ASSERT_NE(buffer, NULL);
479 buffer->fd = -1;
480 buffer->size = size;
481 buffer->mirror = malloc(size);
482 ASSERT_NE(buffer->mirror, NULL);
484 buffer->ptr = mmap(NULL, size,
487 buffer->fd, 0);
488 ASSERT_NE(buffer->ptr, MAP_FAILED);
491 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_READ, buffer, 1);
493 ASSERT_EQ(buffer->cpages, 1);
494 ASSERT_EQ(buffer->faults, 1);
496 /* Initialize data that the device will write to buffer->ptr. */
497 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
501 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_WRITE, buffer, npages);
505 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
509 ret = mprotect(buffer->ptr, size, PROT_WRITE | PROT_READ);
513 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_WRITE, buffer, npages);
515 ASSERT_EQ(buffer->cpages, npages);
516 ASSERT_EQ(buffer->faults, 1);
519 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
522 hmm_buffer_free(buffer);
531 struct hmm_buffer *buffer;
544 buffer = malloc(sizeof(*buffer));
545 ASSERT_NE(buffer, NULL);
547 buffer->fd = -1;
548 buffer->size = size;
549 buffer->mirror = malloc(size);
550 ASSERT_NE(buffer->mirror, NULL);
552 buffer->ptr = mmap(NULL, size,
555 buffer->fd, 0);
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)
562 /* Initialize data that the device will write to buffer->ptr. */
563 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
573 /* Check that the parent's buffer did not change. */
574 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
580 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
582 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
590 ret = hmm_dmirror_cmd(child_fd, HMM_DMIRROR_WRITE, buffer, npages);
592 ASSERT_EQ(buffer->cpages, npages);
593 ASSERT_EQ(buffer->faults, 1);
596 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
609 struct hmm_buffer *buffer;
622 buffer = malloc(sizeof(*buffer));
623 ASSERT_NE(buffer, NULL);
625 buffer->fd = -1;
626 buffer->size = size;
627 buffer->mirror = malloc(size);
628 ASSERT_NE(buffer->mirror, NULL);
630 buffer->ptr = mmap(NULL, size,
633 buffer->fd, 0);
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)
640 /* Initialize data that the device will write to buffer->ptr. */
641 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
651 /* Check that the parent's buffer did change. */
652 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
658 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
660 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
668 ret = hmm_dmirror_cmd(child_fd, HMM_DMIRROR_WRITE, buffer, npages);
670 ASSERT_EQ(buffer->cpages, npages);
671 ASSERT_EQ(buffer->faults, 1);
674 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
686 struct hmm_buffer *buffer;
697 buffer = malloc(sizeof(*buffer));
698 ASSERT_NE(buffer, NULL);
700 buffer->fd = -1;
701 buffer->size = size;
702 buffer->mirror = malloc(size);
703 ASSERT_NE(buffer->mirror, NULL);
705 buffer->ptr = mmap(NULL, size,
708 buffer->fd, 0);
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)
724 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_WRITE, buffer, npages);
726 ASSERT_EQ(buffer->cpages, npages);
727 ASSERT_EQ(buffer->faults, 1);
730 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
733 buffer->ptr = old_ptr;
734 hmm_buffer_free(buffer);
790 struct hmm_buffer *buffer;
806 buffer = malloc(sizeof(*buffer));
807 ASSERT_NE(buffer, NULL);
809 buffer->ptr = mmap(NULL, size,
813 if (buffer->ptr == MAP_FAILED) {
814 free(buffer);
818 buffer->fd = -1;
819 buffer->size = size;
820 buffer->mirror = malloc(size);
821 ASSERT_NE(buffer->mirror, NULL);
823 /* Initialize data that the device will write to buffer->ptr. */
824 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
828 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_WRITE, buffer, npages);
830 ASSERT_EQ(buffer->cpages, npages);
831 ASSERT_EQ(buffer->faults, 1);
834 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
837 munmap(buffer->ptr, buffer->size);
838 buffer->ptr = NULL;
839 hmm_buffer_free(buffer);
847 struct hmm_buffer *buffer;
863 buffer = malloc(sizeof(*buffer));
864 ASSERT_NE(buffer, NULL);
866 buffer->fd = fd;
867 buffer->size = size;
868 buffer->mirror = malloc(size);
869 ASSERT_NE(buffer->mirror, NULL);
872 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
874 len = pwrite(fd, buffer->mirror, size, 0);
876 memset(buffer->mirror, 0, size);
878 buffer->ptr = mmap(NULL, size,
881 buffer->fd, 0);
882 ASSERT_NE(buffer->ptr, MAP_FAILED);
885 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_READ, buffer, npages);
887 ASSERT_EQ(buffer->cpages, npages);
888 ASSERT_EQ(buffer->faults, 1);
891 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
894 hmm_buffer_free(buffer);
902 struct hmm_buffer *buffer;
918 buffer = malloc(sizeof(*buffer));
919 ASSERT_NE(buffer, NULL);
921 buffer->fd = fd;
922 buffer->size = size;
923 buffer->mirror = malloc(size);
924 ASSERT_NE(buffer->mirror, NULL);
926 buffer->ptr = mmap(NULL, size,
929 buffer->fd, 0);
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)
937 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_WRITE, buffer, npages);
939 ASSERT_EQ(buffer->cpages, npages);
940 ASSERT_EQ(buffer->faults, 1);
943 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
947 len = pread(fd, buffer->mirror, size, 0);
949 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
952 hmm_buffer_free(buffer);
960 struct hmm_buffer *buffer;
971 buffer = malloc(sizeof(*buffer));
972 ASSERT_NE(buffer, NULL);
974 buffer->fd = -1;
975 buffer->size = size;
976 buffer->mirror = malloc(size);
977 ASSERT_NE(buffer->mirror, NULL);
979 buffer->ptr = mmap(NULL, size,
982 buffer->fd, 0);
983 ASSERT_NE(buffer->ptr, MAP_FAILED);
985 /* Initialize buffer in system memory. */
986 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
990 ret = hmm_migrate_sys_to_dev(self->fd, buffer, npages);
992 ASSERT_EQ(buffer->cpages, npages);
995 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
998 hmm_buffer_free(buffer);
1008 struct hmm_buffer *buffer;
1019 buffer = malloc(sizeof(*buffer));
1020 ASSERT_NE(buffer, NULL);
1022 buffer->fd = -1;
1023 buffer->size = size;
1024 buffer->mirror = malloc(size);
1025 ASSERT_NE(buffer->mirror, NULL);
1027 buffer->ptr = mmap(NULL, size,
1030 buffer->fd, 0);
1031 ASSERT_NE(buffer->ptr, MAP_FAILED);
1033 /* Initialize buffer in system memory. */
1034 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1038 ret = hmm_migrate_sys_to_dev(self->fd, buffer, npages);
1040 ASSERT_EQ(buffer->cpages, npages);
1043 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1047 for (i = 0, ptr = buffer->ptr; i < size / (2 * sizeof(*ptr)); ++i)
1051 ret = hmm_migrate_sys_to_dev(self->fd, buffer, npages);
1053 ASSERT_EQ(buffer->cpages, npages);
1056 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1059 hmm_buffer_free(buffer);
1064 struct hmm_buffer *buffer;
1075 buffer = malloc(sizeof(*buffer));
1076 ASSERT_NE(buffer, NULL);
1078 buffer->fd = -1;
1079 buffer->size = size;
1080 buffer->mirror = malloc(size);
1081 ASSERT_NE(buffer->mirror, NULL);
1083 buffer->ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,
1084 MAP_PRIVATE | MAP_ANONYMOUS, buffer->fd, 0);
1085 ASSERT_NE(buffer->ptr, MAP_FAILED);
1087 /* Initialize buffer in system memory. */
1088 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1092 ret = hmm_migrate_sys_to_dev(self->fd, buffer, npages);
1094 ASSERT_EQ(buffer->cpages, npages);
1097 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1101 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_RELEASE, buffer, npages);
1105 for (i = 0, ptr = buffer->ptr; i < size / (2 * sizeof(*ptr)); ++i)
1108 hmm_buffer_free(buffer);
1116 struct hmm_buffer *buffer;
1125 buffer = malloc(sizeof(*buffer));
1126 ASSERT_NE(buffer, NULL);
1128 buffer->fd = -1;
1129 buffer->size = size;
1130 buffer->mirror = malloc(size);
1131 ASSERT_NE(buffer->mirror, NULL);
1133 buffer->ptr = mmap(NULL, size,
1136 buffer->fd, 0);
1137 ASSERT_NE(buffer->ptr, MAP_FAILED);
1140 ret = hmm_migrate_sys_to_dev(self->fd, buffer, npages);
1143 hmm_buffer_free(buffer);
1151 struct hmm_buffer *buffer;
1162 buffer = malloc(sizeof(*buffer));
1163 ASSERT_NE(buffer, NULL);
1165 buffer->fd = -1;
1166 buffer->size = size;
1167 buffer->mirror = malloc(size);
1168 ASSERT_NE(buffer->mirror, NULL);
1171 buffer->ptr = mmap(NULL, size,
1174 buffer->fd, 0);
1175 ASSERT_NE(buffer->ptr, MAP_FAILED);
1176 p = buffer->ptr;
1179 ret = hmm_migrate_sys_to_dev(self->fd1, buffer, npages);
1183 ret = munmap(buffer->ptr + self->page_size, self->page_size);
1187 ret = hmm_migrate_sys_to_dev(self->fd1, buffer, 3);
1191 ret = mprotect(buffer->ptr + 2 * self->page_size, self->page_size,
1194 ptr = (int *)(buffer->ptr + 2 * self->page_size);
1199 ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,
1202 ptr = (int *)(buffer->ptr + 3 * self->page_size);
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);
1214 ptr = (int *)(buffer->ptr + 5 * self->page_size);
1218 buffer->ptr = p + 2 * self->page_size;
1219 ret = hmm_migrate_sys_to_dev(self->fd1, buffer, 4);
1221 ASSERT_EQ(buffer->cpages, 4);
1224 buffer->ptr = p + 5 * self->page_size;
1225 ret = hmm_migrate_sys_to_dev(self->fd0, buffer, 1);
1227 buffer->ptr = p;
1229 buffer->ptr = p;
1230 hmm_buffer_free(buffer);
1243 struct hmm_buffer *buffer;
1256 buffer = malloc(sizeof(*buffer));
1257 ASSERT_NE(buffer, NULL);
1259 buffer->fd = -1;
1260 buffer->size = size;
1261 buffer->mirror = malloc(size);
1262 ASSERT_NE(buffer->mirror, NULL);
1264 buffer->ptr = mmap(NULL, size,
1267 buffer->fd, 0);
1268 ASSERT_NE(buffer->ptr, MAP_FAILED);
1270 /* Initialize buffer in system memory. */
1271 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1275 ret = hmm_migrate_sys_to_dev(self->fd, buffer, npages);
1277 ASSERT_EQ(buffer->cpages, npages);
1280 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1285 ret = hmm_migrate_dev_to_sys(self->fd, buffer, npages);
1287 ASSERT_EQ(buffer->cpages, npages);
1290 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1293 hmm_buffer_free(buffer);
1302 struct hmm_buffer *buffer;
1315 buffer = malloc(sizeof(*buffer));
1316 ASSERT_NE(buffer, NULL);
1318 buffer->fd = -1;
1319 buffer->size = size;
1320 buffer->mirror = malloc(size);
1321 ASSERT_NE(buffer->mirror, NULL);
1323 buffer->ptr = mmap(NULL, size,
1326 buffer->fd, 0);
1327 ASSERT_NE(buffer->ptr, MAP_FAILED);
1329 /* Initialize buffer in system memory. */
1330 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1334 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_READ, buffer,
1337 ASSERT_EQ(buffer->cpages, npages);
1338 ASSERT_EQ(buffer->faults, 1);
1341 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1344 hmm_buffer_free(buffer);
1350 struct hmm_buffer *buffer = p;
1352 /* Delay for a bit and then unmap buffer while it is being read. */
1354 munmap(buffer->ptr + buffer->size / 2, buffer->size / 2);
1355 buffer->ptr = NULL;
1376 struct hmm_buffer *buffer;
1381 buffer = malloc(sizeof(*buffer));
1382 ASSERT_NE(buffer, NULL);
1384 buffer->fd = -1;
1385 buffer->size = size;
1386 buffer->mirror = malloc(size);
1387 ASSERT_NE(buffer->mirror, NULL);
1389 buffer->ptr = mmap(NULL, size,
1392 buffer->fd, 0);
1393 ASSERT_NE(buffer->ptr, MAP_FAILED);
1395 /* Initialize buffer in system memory. */
1396 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1399 rc = pthread_create(&thread, NULL, unmap_buffer, buffer);
1403 rc = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_READ, buffer,
1406 ASSERT_EQ(buffer->cpages, npages);
1407 ASSERT_EQ(buffer->faults, 1);
1410 for (i = 0, ptr = buffer->mirror;
1417 hmm_buffer_free(buffer);
1426 struct hmm_buffer *buffer;
1435 buffer = malloc(sizeof(*buffer));
1436 ASSERT_NE(buffer, NULL);
1438 buffer->fd = -1;
1439 buffer->size = size;
1440 buffer->mirror = malloc(npages);
1441 ASSERT_NE(buffer->mirror, NULL);
1445 buffer->ptr = mmap(NULL, size,
1449 ASSERT_NE(buffer->ptr, MAP_FAILED);
1452 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_SNAPSHOT, buffer, npages);
1454 ASSERT_EQ(buffer->cpages, npages);
1457 m = buffer->mirror;
1460 hmm_buffer_free(buffer);
1468 struct hmm_buffer *buffer;
1480 buffer = malloc(sizeof(*buffer));
1481 ASSERT_NE(buffer, NULL);
1483 buffer->fd = -1;
1484 buffer->size = size;
1485 buffer->mirror = malloc(npages);
1486 ASSERT_NE(buffer->mirror, NULL);
1489 buffer->ptr = mmap(NULL, size,
1492 buffer->fd, 0);
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);
1509 ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,
1512 ptr = (int *)(buffer->ptr + 3 * self->page_size);
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);
1526 buffer->ptr = p + 5 * self->page_size;
1527 ret = hmm_migrate_sys_to_dev(self->fd0, buffer, 1);
1529 ASSERT_EQ(buffer->cpages, 1);
1532 buffer->ptr = p + 6 * self->page_size;
1533 ret = hmm_migrate_sys_to_dev(self->fd1, buffer, 1);
1535 ASSERT_EQ(buffer->cpages, 1);
1538 buffer->ptr = p;
1539 ret = hmm_dmirror_cmd(self->fd0, HMM_DMIRROR_SNAPSHOT, buffer, npages);
1541 ASSERT_EQ(buffer->cpages, npages);
1544 m = buffer->mirror;
1561 hmm_buffer_free(buffer);
1570 struct hmm_buffer *buffer;
1589 buffer = malloc(sizeof(*buffer));
1590 ASSERT_NE(buffer, NULL);
1592 buffer->ptr = mmap(NULL, size,
1596 if (buffer->ptr == MAP_FAILED) {
1597 free(buffer);
1601 buffer->size = size;
1602 buffer->mirror = malloc(npages);
1603 ASSERT_NE(buffer->mirror, NULL);
1605 /* Initialize the pages the device will snapshot in buffer->ptr. */
1606 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1610 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_SNAPSHOT, buffer, npages);
1612 ASSERT_EQ(buffer->cpages, npages);
1615 m = buffer->mirror;
1621 ret = mprotect(buffer->ptr, size, PROT_READ);
1625 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_SNAPSHOT, buffer, npages);
1627 ASSERT_EQ(buffer->cpages, npages);
1630 m = buffer->mirror;
1635 munmap(buffer->ptr, buffer->size);
1636 buffer->ptr = NULL;
1637 hmm_buffer_free(buffer);
1645 struct hmm_buffer *buffer;
1655 buffer = malloc(sizeof(*buffer));
1656 ASSERT_NE(buffer, NULL);
1658 buffer->fd = -1;
1659 buffer->size = size;
1660 buffer->mirror = malloc(size);
1661 ASSERT_NE(buffer->mirror, NULL);
1664 buffer->ptr = mmap(NULL, size,
1667 buffer->fd, 0);
1668 ASSERT_NE(buffer->ptr, MAP_FAILED);
1670 /* Initialize buffer in system memory. */
1671 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1675 ret = mprotect(buffer->ptr, size, PROT_READ);
1679 ret = hmm_dmirror_cmd(self->fd0, HMM_DMIRROR_READ, buffer, npages);
1681 ASSERT_EQ(buffer->cpages, npages);
1682 ASSERT_EQ(buffer->faults, 1);
1685 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1689 ret = hmm_dmirror_cmd(self->fd1, HMM_DMIRROR_READ, buffer, npages);
1691 ASSERT_EQ(buffer->cpages, npages);
1692 ASSERT_EQ(buffer->faults, 1);
1695 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1699 ret = hmm_migrate_sys_to_dev(self->fd1, buffer, npages);
1701 ASSERT_EQ(buffer->cpages, npages);
1703 ret = hmm_dmirror_cmd(self->fd0, HMM_DMIRROR_READ, buffer, npages);
1705 ASSERT_EQ(buffer->cpages, npages);
1706 ASSERT_EQ(buffer->faults, 1);
1709 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1712 hmm_buffer_free(buffer);
1720 struct hmm_buffer *buffer;
1731 buffer = malloc(sizeof(*buffer));
1732 ASSERT_NE(buffer, NULL);
1734 buffer->fd = -1;
1735 buffer->size = size;
1736 buffer->mirror = malloc(size);
1737 ASSERT_NE(buffer->mirror, NULL);
1739 buffer->ptr = mmap(NULL, size,
1742 buffer->fd, 0);
1743 ASSERT_NE(buffer->ptr, MAP_FAILED);
1745 /* Initialize buffer in system memory. */
1746 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1750 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_EXCLUSIVE, buffer, npages);
1752 ASSERT_EQ(buffer->cpages, npages);
1755 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1759 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1762 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1766 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_CHECK_EXCLUSIVE, buffer, npages);
1769 hmm_buffer_free(buffer);
1774 struct hmm_buffer *buffer;
1785 buffer = malloc(sizeof(*buffer));
1786 ASSERT_NE(buffer, NULL);
1788 buffer->fd = -1;
1789 buffer->size = size;
1790 buffer->mirror = malloc(size);
1791 ASSERT_NE(buffer->mirror, NULL);
1793 buffer->ptr = mmap(NULL, size,
1796 buffer->fd, 0);
1797 ASSERT_NE(buffer->ptr, MAP_FAILED);
1799 /* Initialize buffer in system memory. */
1800 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1804 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_EXCLUSIVE, buffer, npages);
1806 ASSERT_EQ(buffer->cpages, npages);
1809 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++i)
1812 ret = mprotect(buffer->ptr, size, PROT_READ);
1816 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_WRITE, buffer, npages);
1819 hmm_buffer_free(buffer);
1827 struct hmm_buffer *buffer;
1838 buffer = malloc(sizeof(*buffer));
1839 ASSERT_NE(buffer, NULL);
1841 buffer->fd = -1;
1842 buffer->size = size;
1843 buffer->mirror = malloc(size);
1844 ASSERT_NE(buffer->mirror, NULL);
1846 buffer->ptr = mmap(NULL, size,
1849 buffer->fd, 0);
1850 ASSERT_NE(buffer->ptr, MAP_FAILED);
1852 /* Initialize buffer in system memory. */
1853 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1857 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_EXCLUSIVE, buffer, npages);
1859 ASSERT_EQ(buffer->cpages, npages);
1864 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1867 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1870 hmm_buffer_free(buffer);
1900 struct hmm_buffer *buffer;
1916 buffer = malloc(sizeof(*buffer));
1917 ASSERT_NE(buffer, NULL);
1919 buffer->fd = -1;
1920 buffer->size = size;
1921 buffer->mirror = malloc(size);
1922 ASSERT_NE(buffer->mirror, NULL);
1924 buffer->ptr = mmap(NULL, size,
1927 buffer->fd, 0);
1928 ASSERT_NE(buffer->ptr, MAP_FAILED);
1930 /* Initialize buffer in system memory. */
1931 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1935 ret = hmm_migrate_sys_to_dev(self->fd, buffer, npages);
1937 ASSERT_EQ(buffer->cpages, npages);
1939 for (i = 0, ptr = buffer->mirror; i < size / sizeof(*ptr); ++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,
1956 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_SNAPSHOT, buffer, npages);
1958 ASSERT_EQ(buffer->cpages, npages);
1959 m = buffer->mirror;
1973 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
1977 hmm_buffer_free(buffer);
1989 struct hmm_buffer *buffer;
2002 buffer = malloc(sizeof(*buffer));
2003 ASSERT_NE(buffer, NULL);
2005 buffer->fd = -1;
2006 buffer->size = size;
2007 buffer->mirror = malloc(size);
2008 ASSERT_NE(buffer->mirror, NULL);
2010 buffer->ptr = mmap(NULL, size,
2013 buffer->fd, 0);
2014 ASSERT_NE(buffer->ptr, MAP_FAILED);
2016 /* Initialize buffer in system memory. */
2017 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
2022 ret = hmm_migrate_sys_to_dev(self->fd, buffer, npages);
2024 ASSERT_EQ(buffer->cpages, npages);
2040 for (i = 0, ptr = buffer->ptr; i < size / sizeof(*ptr); ++i)
2050 ret = hmm_dmirror_cmd(self->fd, HMM_DMIRROR_SNAPSHOT, buffer, npages);
2052 ASSERT_EQ(buffer->cpages, npages);
2053 m = buffer->mirror;
2057 hmm_buffer_free(buffer);