void ion_map_test() { int fd, map_fd, ret; size_t i; struct ion_handle *handle; unsigned char *ptr; if(_ion_alloc_test(&fd, &handle)) return; if (tiler_test) len = height * stride; ret = ion_map(fd, handle, len, prot, map_flags, 0, &ptr, &map_fd); if (ret) return; if (tiler_test) _ion_tiler_map_test(ptr); else { for (i = 0; i < len; i++) { ptr[i] = (unsigned char)i; } for (i = 0; i < len; i++) if (ptr[i] != (unsigned char)i) printf("%s failed wrote %d read %d from mapped " "memory\n", __func__, i, ptr[i]); } /* clean up properly */ ret = ion_free(fd, handle); ion_close(fd); munmap(ptr, len); close(map_fd); _ion_alloc_test(&fd, &handle); close(fd); #if 0 munmap(ptr, len); close(map_fd); ion_close(fd); _ion_alloc_test(len, align, flags, &fd, &handle); close(map_fd); ret = ion_map(fd, handle, len, prot, flags, 0, &ptr, &map_fd); /* don't clean up */ #endif }
int ion_alloc_test(int count) { int fd, ret = 0, i, count_alloc; struct ion_handle **handle; fd = ion_open(); if (fd < 0) { printf("%s(): FAILED to open ion device\n", __func__); return -1; } handle = (struct ion_handle **)malloc(count * sizeof(struct ion_handle *)); if(handle == NULL) { printf("%s() : FAILED to allocate memory for ion_handles\n", __func__); return -ENOMEM; } /* Allocate ion_handles */ count_alloc = count; for(i = 0; i < count; i++) { ret = _ion_alloc_test(fd, &(handle[i])); printf("%s(): Alloc handle[%d]=%p\n", __func__, i, handle[i]); if(ret || ((int)handle[i] == -ENOMEM)) { printf("%s(): Alloc handle[%d]=%p FAILED, err:%s\n", __func__, i, handle[i], strerror(ret)); count_alloc = i; goto err_alloc; } } err_alloc: /* Free ion_handles */ for (i = 0; i < count_alloc; i++) { printf("%s(): Free handle[%d]=%p\n", __func__, i, handle[i]); ret = ion_free(fd, handle[i]); if (ret) { printf("%s(): Free handle[%d]=%p FAILED, err:%s\n", __func__, i, handle[i], strerror(ret)); } } ion_close(fd); free(handle); handle = NULL; if(ret || (count_alloc != count)) { printf("\nion alloc test: FAILED\n\n"); if(count_alloc != count) ret = -ENOMEM; } else printf("\nion alloc test: PASSED\n\n"); return ret; }
void ion_alloc_test() { int fd, ret; ion_user_handle_t handle; if(_ion_alloc_test(&fd, &handle)) return; ret = ion_free(fd, handle); if (ret) { printf("%s failed: %s %d\n", __func__, strerror(ret), handle); return; } ion_close(fd); printf("ion alloc test: passed\n"); }
/** * Go on allocating buffers of specified size & type, untill the allocation fails. * Then free 10 buffers and allocate 10 buffers again. */ int ion_alloc_fail_alloc_test() { int fd, ret = 0, i; struct ion_handle **handle; const int COUNT_ALLOC_MAX = 200; const int COUNT_REALLOC_MAX = 10; int count_alloc = COUNT_ALLOC_MAX, count_realloc = COUNT_ALLOC_MAX; fd = ion_open(); if (fd < 0) { printf("%s(): FAILED to open ion device\n", __func__); return -1; } handle = (struct ion_handle **)malloc(COUNT_ALLOC_MAX * sizeof(struct ion_handle *)); if(handle == NULL) { printf("%s(): FAILED to allocate memory for ion_handles\n", __func__); return -ENOMEM; } /* Allocate ion_handles as much as possible */ for(i = 0; i < COUNT_ALLOC_MAX; i++) { ret = _ion_alloc_test(fd, &(handle[i])); printf("%s(): Alloc handle[%d]=%p\n", __func__, i, handle[i]); if(ret || ((int)handle[i] == -ENOMEM)) { printf("%s(): Alloc handle[%d]=%p FAILED, err:%s\n\n", __func__, i, handle[i], strerror(ret)); count_alloc = i; break; } } /* Free COUNT_REALLOC_MAX ion_handles */ for (i = count_alloc-1; i > (count_alloc-1 - COUNT_REALLOC_MAX); i--) { printf("%s(): Free handle[%d]=%p\n", __func__, i, handle[i]); ret = ion_free(fd, handle[i]); if (ret) { printf("%s(): Free handle[%d]=%p FAILED, err:%s\n\n", __func__, i, handle[i], strerror(ret)); } } /* Again allocate COUNT_REALLOC_MAX ion_handles to test that we are still able to allocate */ for(i = (count_alloc - COUNT_REALLOC_MAX); i < count_alloc; i++) { ret = _ion_alloc_test(fd, &(handle[i])); printf("%s(): Alloc handle[%d]=%p\n", __func__, i, handle[i]); if(ret || ((int)handle[i] == -ENOMEM)) { printf("%s(): Alloc handle[%d]=%p FAILED, err:%s\n\n", __func__, i, handle[i], strerror(ret)); count_realloc = i; goto err_alloc; } } count_realloc = i; err_alloc: /* Free all ion_handles */ for (i = 0; i < count_alloc; i++) { printf("%s(): Free handle[%d]=%p\n", __func__, i, handle[i]); ret = ion_free(fd, handle[i]); if (ret) { printf("%s(): Free handle[%d]=%p FAILED, err:%s\n", __func__, i, handle[i], strerror(ret)); } } ion_close(fd); free(handle); handle = NULL; printf("\ncount_alloc=%d, count_realloc=%d\n",count_alloc, count_realloc); if(ret || (count_alloc != count_realloc)) { printf("\nion alloc->fail->alloc test: FAILED\n\n"); if(count_alloc != COUNT_ALLOC_MAX) ret = -ENOMEM; } else printf("\nion alloc->fail->alloc test: PASSED\n\n"); return ret; }
int ion_map_test(int count) { int fd, ret = 0, i, count_alloc, count_map; struct ion_handle **handle; unsigned char **ptr; int *map_fd; fd = ion_open(); if (fd < 0) { printf("%s(): FAILED to open ion device\n", __func__); return -1; } handle = (struct ion_handle **)malloc(count * sizeof(struct ion_handle *)); if(handle == NULL) { printf("%s(): FAILED to allocate memory for ion_handles\n", __func__); return -ENOMEM; } count_alloc = count; count_map = count; /* Allocate ion_handles */ for(i = 0; i < count; i++) { ret = _ion_alloc_test(fd, &(handle[i])); printf("%s(): Alloc handle[%d]=%p\n", __func__, i, handle[i]); if(ret || ((int)handle[i] == -ENOMEM)) { printf("%s(): Alloc handle[%d]=%p FAILED, err:%s\n", __func__, i, handle[i], strerror(ret)); count_alloc = i; goto err_alloc; } } /* Map ion_handles and validate */ if (tiler_test) len = height * stride; ptr = (unsigned char **)malloc(count * sizeof(unsigned char **)); map_fd = (int *)malloc(count * sizeof(int *)); for(i = 0; i < count; i++) { /* Map ion_handle on userside */ ret = ion_map(fd, handle[i], len, prot, map_flags, 0, &(ptr[i]), &(map_fd[i])); printf("%s(): Map handle[%d]=%p, map_fd=%d, ptr=%p\n", __func__, i, handle[i], map_fd[i], ptr[i]); if(ret) { printf("%s Map handle[%d]=%p FAILED, err:%s\n", __func__, i, handle[i], strerror(ret)); count_map = i; goto err_map; } /* Validate mapping by writing the data and reading it back */ if (tiler_test) _ion_tiler_map_test(ptr[i]); else _ion_map_test(ptr[i]); } /* clean up properly */ err_map: for(i = 0; i < count_map; i++) { /* Unmap ion_handles */ ret = munmap(ptr[i], len); printf("%s(): Unmap handle[%d]=%p, map_fd=%d, ptr=%p\n", __func__, i, handle[i], map_fd[i], ptr[i]); if(ret) { printf("%s(): Unmap handle[%d]=%p FAILED, err:%s\n", __func__, i, handle[i], strerror(ret)); goto err_map; } /* Close fds */ close(map_fd[i]); } free(map_fd); free(ptr); err_alloc: /* Free ion_handles */ for (i = 0; i < count_alloc; i++) { printf("%s(): Free handle[%d]=%p\n", __func__, i, handle[i]); ret = ion_free(fd, handle[i]); if (ret) { printf("%s(): Free handle[%d]=%p FAILED, err:%s\n", __func__, i, handle[i], strerror(ret)); } } ion_close(fd); free(handle); handle = NULL; if(ret || (count_alloc != count) || (count_map != count)) { printf("\nion map test: FAILED\n\n"); if((count_alloc != count) || (count_map != count)) ret = -ENOMEM; } else printf("\nion map test: PASSED\n"); return ret; }
void ion_share_test() { ion_user_handle_t handle; int sd[2]; int num_fd = 1; struct iovec count_vec = { .iov_base = &num_fd, .iov_len = sizeof num_fd, }; char buf[CMSG_SPACE(sizeof(int))]; socketpair(AF_UNIX, SOCK_STREAM, 0, sd); if (fork()) { struct msghdr msg = { .msg_control = buf, .msg_controllen = sizeof buf, .msg_iov = &count_vec, .msg_iovlen = 1, }; struct cmsghdr *cmsg; int fd, share_fd, ret; char *ptr; /* parent */ if(_ion_alloc_test(&fd, &handle)) return; ret = ion_share(fd, handle, &share_fd); if (ret) printf("share failed %s\n", strerror(errno)); ptr = mmap(NULL, len, prot, map_flags, share_fd, 0); if (ptr == MAP_FAILED) { return; } strcpy(ptr, "master"); cmsg = CMSG_FIRSTHDR(&msg); cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_type = SCM_RIGHTS; cmsg->cmsg_len = CMSG_LEN(sizeof(int)); *(int *)CMSG_DATA(cmsg) = share_fd; /* send the fd */ printf("master? [%10s] should be [master]\n", ptr); printf("master sending msg 1\n"); sendmsg(sd[0], &msg, 0); if (recvmsg(sd[0], &msg, 0) < 0) perror("master recv msg 2"); printf("master? [%10s] should be [child]\n", ptr); /* send ping */ sendmsg(sd[0], &msg, 0); printf("master->master? [%10s]\n", ptr); if (recvmsg(sd[0], &msg, 0) < 0) perror("master recv 1"); } else { struct msghdr msg; struct cmsghdr *cmsg; char* ptr; int fd, recv_fd; char* child_buf[100]; /* child */ struct iovec count_vec = { .iov_base = child_buf, .iov_len = sizeof child_buf, }; struct msghdr child_msg = { .msg_control = buf, .msg_controllen = sizeof buf, .msg_iov = &count_vec, .msg_iovlen = 1, }; if (recvmsg(sd[1], &child_msg, 0) < 0) perror("child recv msg 1"); cmsg = CMSG_FIRSTHDR(&child_msg); if (cmsg == NULL) { printf("no cmsg rcvd in child"); return; } recv_fd = *(int*)CMSG_DATA(cmsg); if (recv_fd < 0) { printf("could not get recv_fd from socket"); return; } printf("child %d\n", recv_fd); fd = ion_open(); ptr = mmap(NULL, len, prot, map_flags, recv_fd, 0); if (ptr == MAP_FAILED) { return; } printf("child? [%10s] should be [master]\n", ptr); strcpy(ptr, "child"); printf("child sending msg 2\n"); sendmsg(sd[1], &child_msg, 0); } } int main(int argc, char* argv[]) { int c; enum tests { ALLOC_TEST = 0, MAP_TEST, SHARE_TEST, }; while (1) { static struct option opts[] = { {"alloc", no_argument, 0, 'a'}, {"alloc_flags", required_argument, 0, 'f'}, {"map", no_argument, 0, 'm'}, {"share", no_argument, 0, 's'}, {"len", required_argument, 0, 'l'}, {"align", required_argument, 0, 'g'}, {"map_flags", required_argument, 0, 'z'}, {"prot", required_argument, 0, 'p'}, {"width", required_argument, 0, 'w'}, {"height", required_argument, 0, 'h'}, }; int i = 0; c = getopt_long(argc, argv, "af:h:l:mr:stw:", opts, &i); if (c == -1) break; switch (c) { case 'l': len = atol(optarg); break; case 'g': align = atol(optarg); break; case 'z': map_flags = 0; map_flags |= strstr(optarg, "PROT_EXEC") ? PROT_EXEC : 0; map_flags |= strstr(optarg, "PROT_READ") ? PROT_READ: 0; map_flags |= strstr(optarg, "PROT_WRITE") ? PROT_WRITE: 0; map_flags |= strstr(optarg, "PROT_NONE") ? PROT_NONE: 0; break; case 'p': prot = 0; prot |= strstr(optarg, "MAP_PRIVATE") ? MAP_PRIVATE : 0; prot |= strstr(optarg, "MAP_SHARED") ? MAP_PRIVATE : 0; break; case 'f': alloc_flags = atol(optarg); break; case 'a': test = ALLOC_TEST; break; case 'm': test = MAP_TEST; break; case 's': test = SHARE_TEST; break; case 'w': width = atol(optarg); break; case 'h': height = atol(optarg); break; } } printf("test %d, len %u, width %u, height %u align %u, " "map_flags %d, prot %d, alloc_flags %d\n", test, len, width, height, align, map_flags, prot, alloc_flags); switch (test) { case ALLOC_TEST: ion_alloc_test(); break; case MAP_TEST: ion_map_test(); break; case SHARE_TEST: ion_share_test(); break; default: printf("must specify a test (alloc, map, share)\n"); } return 0; }