forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
253 lines
5.3 KiB
253 lines
5.3 KiB
#include <stdio.h> |
|
#include <string.h> |
|
#include <unistd.h> |
|
#include <fcntl.h> |
|
#include <errno.h> |
|
//#include <stdint.h> |
|
#include <sys/ioctl.h> |
|
#include <sys/mman.h> |
|
#include "ionutils.h" |
|
#include "ipcsocket.h" |
|
|
|
|
|
void write_buffer(void *buffer, unsigned long len) |
|
{ |
|
int i; |
|
unsigned char *ptr = (unsigned char *)buffer; |
|
|
|
if (!ptr) { |
|
fprintf(stderr, "<%s>: Invalid buffer...\n", __func__); |
|
return; |
|
} |
|
|
|
printf("Fill buffer content:\n"); |
|
memset(ptr, 0xfd, len); |
|
for (i = 0; i < len; i++) |
|
printf("0x%x ", ptr[i]); |
|
printf("\n"); |
|
} |
|
|
|
void read_buffer(void *buffer, unsigned long len) |
|
{ |
|
int i; |
|
unsigned char *ptr = (unsigned char *)buffer; |
|
|
|
if (!ptr) { |
|
fprintf(stderr, "<%s>: Invalid buffer...\n", __func__); |
|
return; |
|
} |
|
|
|
printf("Read buffer content:\n"); |
|
for (i = 0; i < len; i++) |
|
printf("0x%x ", ptr[i]); |
|
printf("\n"); |
|
} |
|
|
|
int ion_export_buffer_fd(struct ion_buffer_info *ion_info) |
|
{ |
|
int i, ret, ionfd, buffer_fd; |
|
unsigned int heap_id; |
|
unsigned long maplen; |
|
unsigned char *map_buffer; |
|
struct ion_allocation_data alloc_data; |
|
struct ion_heap_query query; |
|
struct ion_heap_data heap_data[MAX_HEAP_COUNT]; |
|
|
|
if (!ion_info) { |
|
fprintf(stderr, "<%s>: Invalid ion info\n", __func__); |
|
return -1; |
|
} |
|
|
|
/* Create an ION client */ |
|
ionfd = open(ION_DEVICE, O_RDWR); |
|
if (ionfd < 0) { |
|
fprintf(stderr, "<%s>: Failed to open ion client: %s\n", |
|
__func__, strerror(errno)); |
|
return -1; |
|
} |
|
|
|
memset(&query, 0, sizeof(query)); |
|
query.cnt = MAX_HEAP_COUNT; |
|
query.heaps = (unsigned long int)&heap_data[0]; |
|
/* Query ION heap_id_mask from ION heap */ |
|
ret = ioctl(ionfd, ION_IOC_HEAP_QUERY, &query); |
|
if (ret < 0) { |
|
fprintf(stderr, "<%s>: Failed: ION_IOC_HEAP_QUERY: %s\n", |
|
__func__, strerror(errno)); |
|
goto err_query; |
|
} |
|
|
|
heap_id = MAX_HEAP_COUNT + 1; |
|
for (i = 0; i < query.cnt; i++) { |
|
if (heap_data[i].type == ion_info->heap_type) { |
|
heap_id = heap_data[i].heap_id; |
|
break; |
|
} |
|
} |
|
|
|
if (heap_id > MAX_HEAP_COUNT) { |
|
fprintf(stderr, "<%s>: ERROR: heap type does not exists\n", |
|
__func__); |
|
goto err_heap; |
|
} |
|
|
|
alloc_data.len = ion_info->heap_size; |
|
alloc_data.heap_id_mask = 1 << heap_id; |
|
alloc_data.flags = ion_info->flag_type; |
|
|
|
/* Allocate memory for this ION client as per heap_type */ |
|
ret = ioctl(ionfd, ION_IOC_ALLOC, &alloc_data); |
|
if (ret < 0) { |
|
fprintf(stderr, "<%s>: Failed: ION_IOC_ALLOC: %s\n", |
|
__func__, strerror(errno)); |
|
goto err_alloc; |
|
} |
|
|
|
/* This will return a valid buffer fd */ |
|
buffer_fd = alloc_data.fd; |
|
maplen = alloc_data.len; |
|
|
|
if (buffer_fd < 0 || maplen <= 0) { |
|
fprintf(stderr, "<%s>: Invalid map data, fd: %d, len: %ld\n", |
|
__func__, buffer_fd, maplen); |
|
goto err_fd_data; |
|
} |
|
|
|
/* Create memory mapped buffer for the buffer fd */ |
|
map_buffer = (unsigned char *)mmap(NULL, maplen, PROT_READ|PROT_WRITE, |
|
MAP_SHARED, buffer_fd, 0); |
|
if (map_buffer == MAP_FAILED) { |
|
fprintf(stderr, "<%s>: Failed: mmap: %s\n", |
|
__func__, strerror(errno)); |
|
goto err_mmap; |
|
} |
|
|
|
ion_info->ionfd = ionfd; |
|
ion_info->buffd = buffer_fd; |
|
ion_info->buffer = map_buffer; |
|
ion_info->buflen = maplen; |
|
|
|
return 0; |
|
|
|
munmap(map_buffer, maplen); |
|
|
|
err_fd_data: |
|
err_mmap: |
|
/* in case of error: close the buffer fd */ |
|
if (buffer_fd) |
|
close(buffer_fd); |
|
|
|
err_query: |
|
err_heap: |
|
err_alloc: |
|
/* In case of error: close the ion client fd */ |
|
if (ionfd) |
|
close(ionfd); |
|
|
|
return -1; |
|
} |
|
|
|
int ion_import_buffer_fd(struct ion_buffer_info *ion_info) |
|
{ |
|
int buffd; |
|
unsigned char *map_buf; |
|
unsigned long map_len; |
|
|
|
if (!ion_info) { |
|
fprintf(stderr, "<%s>: Invalid ion info\n", __func__); |
|
return -1; |
|
} |
|
|
|
map_len = ion_info->buflen; |
|
buffd = ion_info->buffd; |
|
|
|
if (buffd < 0 || map_len <= 0) { |
|
fprintf(stderr, "<%s>: Invalid map data, fd: %d, len: %ld\n", |
|
__func__, buffd, map_len); |
|
goto err_buffd; |
|
} |
|
|
|
map_buf = (unsigned char *)mmap(NULL, map_len, PROT_READ|PROT_WRITE, |
|
MAP_SHARED, buffd, 0); |
|
if (map_buf == MAP_FAILED) { |
|
printf("<%s>: Failed - mmap: %s\n", |
|
__func__, strerror(errno)); |
|
goto err_mmap; |
|
} |
|
|
|
ion_info->buffer = map_buf; |
|
ion_info->buflen = map_len; |
|
|
|
return 0; |
|
|
|
err_mmap: |
|
if (buffd) |
|
close(buffd); |
|
|
|
err_buffd: |
|
return -1; |
|
} |
|
|
|
void ion_close_buffer_fd(struct ion_buffer_info *ion_info) |
|
{ |
|
if (ion_info) { |
|
/* unmap the buffer properly in the end */ |
|
munmap(ion_info->buffer, ion_info->buflen); |
|
/* close the buffer fd */ |
|
if (ion_info->buffd > 0) |
|
close(ion_info->buffd); |
|
/* Finally, close the client fd */ |
|
if (ion_info->ionfd > 0) |
|
close(ion_info->ionfd); |
|
} |
|
} |
|
|
|
int socket_send_fd(struct socket_info *info) |
|
{ |
|
int status; |
|
int fd, sockfd; |
|
struct socketdata skdata; |
|
|
|
if (!info) { |
|
fprintf(stderr, "<%s>: Invalid socket info\n", __func__); |
|
return -1; |
|
} |
|
|
|
sockfd = info->sockfd; |
|
fd = info->datafd; |
|
memset(&skdata, 0, sizeof(skdata)); |
|
skdata.data = fd; |
|
skdata.len = sizeof(skdata.data); |
|
status = sendtosocket(sockfd, &skdata); |
|
if (status < 0) { |
|
fprintf(stderr, "<%s>: Failed: sendtosocket\n", __func__); |
|
return -1; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
int socket_receive_fd(struct socket_info *info) |
|
{ |
|
int status; |
|
int fd, sockfd; |
|
struct socketdata skdata; |
|
|
|
if (!info) { |
|
fprintf(stderr, "<%s>: Invalid socket info\n", __func__); |
|
return -1; |
|
} |
|
|
|
sockfd = info->sockfd; |
|
memset(&skdata, 0, sizeof(skdata)); |
|
status = receivefromsocket(sockfd, &skdata); |
|
if (status < 0) { |
|
fprintf(stderr, "<%s>: Failed: receivefromsocket\n", __func__); |
|
return -1; |
|
} |
|
|
|
fd = (int)skdata.data; |
|
info->datafd = fd; |
|
|
|
return status; |
|
}
|
|
|