C++ (Cpp) read_ring_buffer Examples

Example #1

File: proc_create_buf.c Project: JamiLiang/android_kernel_samsung_xcover

static int pxcm_proc_create_buf_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
	unsigned int count_read;

	count_read = read_ring_buffer(&g_buffer_info[CM_BUFFER_ID_PROCESS_CREATE].buffer, buf);

	return count_read;
}

Example #2

File: module_buf.c Project: JamiLiang/android_kernel_samsung_xcover

static int pxhs_module_buf_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
	unsigned int count_read;

	count_read = read_ring_buffer(&g_module_buffer.buffer, buf);

	return count_read;
}

Example #3

File: thrd_switch_buf.c Project: JamiLiang/android_kernel_samsung_xcover

static int pxcm_thrd_switch_buf_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
	unsigned int count_read;

	count_read = read_ring_buffer(&g_buffer_info[CM_BUFFER_ID_THREAD_SWITCH].buffer, buf);

	return count_read;
}

Example #4

File: tp_drv.c Project: ashang/xpenology-3.x

static int read_module_buffer(struct read_buffer_data * data)
{
	unsigned int cpu;
	unsigned int buffer_addr;
	unsigned int buffer_size;
	unsigned int size_read;
	bool         when_stop;
	bool         only_full;

	struct read_buffer_data rsbd;

	if (copy_from_user(&rsbd, data, sizeof(struct read_buffer_data)))
	{
		return -EFAULT;
	}

	if (rsbd.cpu >= num_possible_cpus())
	{
		return -EINVAL;
	}

	rsbd.size_read = 0;

	cpu         = rsbd.cpu;
	buffer_addr = rsbd.buffer_addr;
	buffer_size = rsbd.buffer_size;
	when_stop   = rsbd.when_stop;
	only_full   = rsbd.only_full;

	if (!only_full || g_module_buffer.is_full_event_set)
	{
		char * buf;

		buf = vmalloc(g_module_buffer.buffer.size);

		if (buf != NULL)
		{
			size_read = read_ring_buffer(&g_module_buffer.buffer, buf);

			if (copy_to_user((void *)rsbd.buffer_addr, buf, size_read) == 0)
				rsbd.size_read = size_read;
			else
				rsbd.size_read = 0;

			/* reset the sample buffer full */
			g_module_buffer.is_full_event_set = false;

			vfree(buf);
		}
	}

	if (copy_to_user(data, &rsbd, sizeof(struct read_buffer_data)))
	{
		return -EFAULT;
	}

	return 0;
}

Example #5

static int read_module_buffer(struct read_buffer_data * data)
{
	unsigned int buffer_addr;
	unsigned int buffer_size;
	unsigned int size_read;
	bool         only_full;

	struct read_buffer_data rmbd;

	if (copy_from_user(&rmbd, data, sizeof(struct read_buffer_data)))
	{
		return -EFAULT;
	}

	buffer_addr = rmbd.buffer_addr;
	buffer_size = rmbd.buffer_size;
	only_full   = rmbd.only_full;

	if (!only_full || g_module_buffer_hs.is_full_event_set)
	{
		char * buffer = vmalloc(g_module_buffer_hs.buffer.size);

		if (buffer != NULL)
		{
			size_read = read_ring_buffer(&g_module_buffer_hs.buffer, buffer);
			
			if (copy_to_user((void *)rmbd.buffer_addr, buffer, size_read) == 0)
				rmbd.size_read = size_read;
			else
				rmbd.size_read = 0;

			/* reset the module buffer full */
			g_module_buffer_hs.is_full_event_set = false;
			
			vfree(buffer);
		}
	}

	if (copy_to_user(data, &rmbd, sizeof(struct read_buffer_data)))
	{
		return -EFAULT;
	}


	return 0;
}

Example #6

static int read_sample_buffer(struct read_buffer_data * data)
{
	unsigned int cpu;
	unsigned int buffer_addr;
	unsigned int buffer_size;
	unsigned int size_read;
	bool         when_stop;
	bool         only_full;
	struct RingBufferInfo * sample_buffer;

	struct read_buffer_data rsbd;

	if (copy_from_user(&rsbd, data, sizeof(struct read_buffer_data)))
	{
		return -EFAULT;
	}

	if (rsbd.cpu >= num_possible_cpus())
	{
		return -EINVAL;
	}

	rsbd.size_read = 0;

	cpu         = rsbd.cpu;
	buffer_addr = rsbd.buffer_addr;
	buffer_size = rsbd.buffer_size;
	when_stop   = rsbd.when_stop;
	only_full   = rsbd.only_full;

	sample_buffer = &per_cpu(g_sample_buffer_hs, cpu);

	if (!only_full || sample_buffer->is_full_event_set)
	{
		char * buffer = vmalloc(sample_buffer->buffer.size);

		if (buffer != NULL)
		{
			size_read = read_ring_buffer(&sample_buffer->buffer, buffer);

			if (copy_to_user((void *)rsbd.buffer_addr, buffer, size_read) == 0)
				rsbd.size_read = size_read;
			else
				rsbd.size_read = 0;

			/* reset the sample buffer full */
			sample_buffer->is_full_event_set = false;
			
			vfree(buffer);
		}
	}

	if (copy_to_user(data, &rsbd, sizeof(struct read_buffer_data)))
	{
		return -EFAULT;
	}

	/* if it is not the sample buffer flush when stopping, we need to resume profiling */
	if (!when_stop)
	{
		resume_profiling();
	}

	return 0;
}