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;
}
