/** @fn char CBufferLoop::get_buffer_tmp(char* pbuffer, int nbuffer_size, int* nreal_buffer_size)
* @brief 获取指定大小的数据，但是不会清空该数据
* @param[in] pbuffer 数据存放指针
* @param[in] nbuffer_size 想要获取的大小
* @param[in] nreal_buffer_size 实际获取的大小
* @return
*/
char get_buffer_tmp(char* pbuffer, int nbuffer_size, int* nreal_buffer_size)
{
bool bret = true;
int nrealsize = (nbuffer_size < get_used_size() ? nbuffer_size : get_used_size());
if (m_nhead_pos <= m_ntail_pos)
{
memcpy(pbuffer, &m_pbuffer[m_nhead_pos], nrealsize);
}
else
{
int nrestsize = m_nbuffer_size - m_nhead_pos;
//到末尾的长度大于需要的长度
if (nrealsize <= nrestsize)
{
memcpy(pbuffer, &m_pbuffer[m_nhead_pos], nrealsize);
}
else
{
//需要分两次获取,先把到末尾的数据全部获取
memcpy(pbuffer, &m_pbuffer[m_nhead_pos], nrestsize);
//然后从起始处获取剩余的数据
memcpy(&pbuffer[nrestsize], &m_pbuffer[0], nrealsize - nrestsize);
}
}
*nreal_buffer_size = nrealsize;
return bret;
}
static void interface_free_func(void** state) {
void* malloc_pool = malloc(POOL_SIZE);
init_memory_pool(POOL_SIZE, malloc_pool, 0);
size_t first_size = get_used_size(malloc_pool);
IPv4Interface* interface = interface_alloc(malloc_pool);
size_t comp_size = get_used_size(malloc_pool);
assert_int_not_equal(comp_size, first_size);
interface_free(interface, malloc_pool);
comp_size = get_used_size(malloc_pool);
assert_int_equal(comp_size, first_size);
destroy_memory_pool(malloc_pool);
free(malloc_pool);
malloc_pool = NULL;
}
void event_write(unsigned long index, unsigned long len)
{
if (page_table[index].addr)
free_ex(page_table[index].addr, pool);
page_table[index].addr = malloc_ex(len, pool);
if (page_table[index].addr == NULL) {
printf("Error allocating for index=%lu, len=%lu\n", index, len);
return;
}
page_table[index].len = len;
printf("%u\n", KB(get_used_size(pool)));
}
//write data into interface
void write_to_interface(char * buffer, int buffer_size)
{
if (!is_device_ready())
{
return;
}
if (0 == buffer_size)
{
return;
}
PVERBOSE("write %d byte(s) buffer to cache now\n", buffer_size);
if (down_interruptible(&sem))
{
return;
}
//we will never let our buffer be full
//note when cycle_buffer_size - get_used_size() = buffer_size, all buffer will be filled, then read_ptr = write_ptr
//but we have no idea buffer size is 0 or full when read_ptr = write_ptr, so avoid this states
if ((cycle_buffer_size - get_used_size()) > buffer_size)
{
//buffer is enough
write_ptr = copy_to_buffer(write_ptr, buffer, buffer_size);
PVERBOSE("write complete, read_ptr: 0x%08x, write_ptr: 0x%08x, used size: %d\n", read_ptr, write_ptr, get_used_size());
}
else
{
PWARN("failed while write to interface, buffer is full, used size: %d, need: %d\n", get_used_size(), buffer_size);
}
up(&sem);
}
U32 nx_memalloc_used(void) {
return get_used_size(mp);
}
//read sys_call will invoke this, do read something
ssize_t interface_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
int used = 0;
int min = 0;
int left = 0;
int copyed = 0;
int first_size = 0;
if (down_interruptible(&sem))
{
copyed = -EINTR;
goto cleanup;
}
PVERBOSE("read begin, read_ptr: 0x%08x, write_ptr: 0x%08x, used size: %d, want to read %d byte(s)\n", read_ptr, write_ptr, get_used_size(), count);
used = get_used_size();
if (count > used)
{
min = used;
}
else
{
min = count;
}
first_size = cycle_buffer_size - (read_ptr - cycle_buffer);
if (read_ptr == write_ptr)
{
copyed = 0;
goto cleanup;
}
else if (read_ptr > write_ptr && first_size <= min)
{
//deal with read cross boundary
int first_copy = 0;
int left = 0;
ASSERT(first_size > 0);
PDEBUG("read cross boundary, left %d byte(s), need %d byte(s)\n", first_size, min);
//read buffer is bigger than this part, so read all left out
first_copy = first_size;
left = copy_to_user(buf, read_ptr, first_copy);
if (0 == left)
{
copyed = first_copy;
}
else
{
//copy not completed, go cleanup
copyed = first_copy - left;
PWARN("copy_to_user not completed (%d, %d) inside interface_read\n", left, first_copy);
goto cleanup;
}
read_ptr = cycle_buffer;
buf += copyed;
min -= copyed;
}
if (min > 0)
{
//read second part or read normally
PVERBOSE("read secondly or normally %d byte(s) at 0x%08x\n", min, read_ptr);
left = copy_to_user(buf, read_ptr, min);
if (0 == left)
{
copyed += min;
read_ptr += min;
}
else
{
copyed += min - left;
read_ptr += min - left;
PWARN("copy_to_user not completed (%d, %d) inside interface_read\n", left, min);
}
}
cleanup:
up(&sem);
PVERBOSE("read complete, read_ptr: 0x%08x, write_ptr: 0x%08x, used size: %d, copyed: %d\n", read_ptr, write_ptr, get_used_size(), copyed);
return copyed;
}
int get_rest_size() { return get_buffer_size() - get_used_size(); }
/** @fn int CBufferLoop::get_rest_size()
* @brief
* @return
*/
int CBufferLoop::get_rest_size()
{
return get_buffer_size() - get_used_size();
}
size_t malloc_used() {
return get_used_size(__malloc_pool);
}