[lttng-modules.git] / src / lib / ringbuffer / ring_buffer_mmap.c

/* SPDX-License-Identifier: GPL-2.0-only
 *
 * ring_buffer_mmap.c
 *
 * Copyright (C) 2002-2005 - Tom Zanussi <zanussi@us.ibm.com>, IBM Corp
 * Copyright (C) 1999-2005 - Karim Yaghmour <karim@opersys.com>
 * Copyright (C) 2008-2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Re-using code from kernel/relay.c, hence the GPL-2.0-only license for this
 * file.
 */

#include <linux/module.h>
#include <linux/mm.h>

#include <ringbuffer/backend.h>
#include <ringbuffer/frontend.h>
#include <ringbuffer/vfs.h>

/*
 * fault() vm_op implementation for ring buffer file mapping.
 */
#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0) || \
	LTTNG_RHEL_KERNEL_RANGE(4,18,0,193,0,0, 4,19,0,0,0,0))
static vm_fault_t lib_ring_buffer_fault_compat(struct vm_area_struct *vma, struct vm_fault *vmf)
#else
static int lib_ring_buffer_fault_compat(struct vm_area_struct *vma, struct vm_fault *vmf)
#endif
{
	struct lttng_kernel_ring_buffer *buf = vma->vm_private_data;
	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
	pgoff_t pgoff = vmf->pgoff;
	unsigned long *pfnp;
	void **virt;
	unsigned long offset, sb_bindex;

	/*
	 * Verify that faults are only done on the range of pages owned by the
	 * reader.
	 */
	offset = pgoff << PAGE_SHIFT;
	sb_bindex = subbuffer_id_get_index(config, buf->backend.buf_rsb.id);
	if (!(offset >= buf->backend.array[sb_bindex]->mmap_offset
	      && offset < buf->backend.array[sb_bindex]->mmap_offset +
			  buf->backend.chan->backend.subbuf_size))
		return VM_FAULT_SIGBUS;
	/*
	 * ring_buffer_read_get_pfn() gets the page frame number for the
	 * current reader's pages.
	 */
	pfnp = lib_ring_buffer_read_get_pfn(&buf->backend, offset, &virt);
	if (!*pfnp)
		return VM_FAULT_SIGBUS;
	get_page(pfn_to_page(*pfnp));
	vmf->page = pfn_to_page(*pfnp);

	return 0;
}

#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0) || \
	LTTNG_RHEL_KERNEL_RANGE(4,18,0,193,0,0, 4,19,0,0,0,0))
static vm_fault_t lib_ring_buffer_fault(struct vm_fault *vmf)
{
	struct vm_area_struct *vma = vmf->vma;
	return lib_ring_buffer_fault_compat(vma, vmf);
}
#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0))
static int lib_ring_buffer_fault(struct vm_fault *vmf)
{
	struct vm_area_struct *vma = vmf->vma;
	return lib_ring_buffer_fault_compat(vma, vmf);
}
#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0)) */
static int lib_ring_buffer_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	return lib_ring_buffer_fault_compat(vma, vmf);
}
#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0)) */

/*
 * vm_ops for ring buffer file mappings.
 */
static const struct vm_operations_struct lib_ring_buffer_mmap_ops = {
	.fault = lib_ring_buffer_fault,
};

/**
 *	lib_ring_buffer_mmap_buf: - mmap channel buffer to process address space
 *	@buf: ring buffer to map
 *	@vma: vm_area_struct describing memory to be mapped
 *
 *	Returns 0 if ok, negative on error
 *
 *	Caller should already have grabbed mmap_sem.
 */
static int lib_ring_buffer_mmap_buf(struct lttng_kernel_ring_buffer *buf,
				    struct vm_area_struct *vma)
{
	unsigned long length = vma->vm_end - vma->vm_start;
	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
	unsigned long mmap_buf_len;

	if (config->output != RING_BUFFER_MMAP)
		return -EINVAL;

	mmap_buf_len = chan->backend.buf_size;
	if (chan->backend.extra_reader_sb)
		mmap_buf_len += chan->backend.subbuf_size;

	if (length != mmap_buf_len)
		return -EINVAL;

	vma->vm_ops = &lib_ring_buffer_mmap_ops;
	vma->vm_flags |= VM_DONTEXPAND;
	vma->vm_private_data = buf;

	return 0;
}

int lib_ring_buffer_mmap(struct file *filp, struct vm_area_struct *vma,
		struct lttng_kernel_ring_buffer *buf)
{
	return lib_ring_buffer_mmap_buf(buf, vma);
}
EXPORT_SYMBOL_GPL(lib_ring_buffer_mmap);

/**
 *	vfs_lib_ring_buffer_mmap - mmap file op
 *	@filp: the file
 *	@vma: the vma describing what to map
 *
 *	Calls upon lib_ring_buffer_mmap_buf() to map the file into user space.
 */
int vfs_lib_ring_buffer_mmap(struct file *filp, struct vm_area_struct *vma)
{
	struct lttng_kernel_ring_buffer *buf = filp->private_data;
	return lib_ring_buffer_mmap(filp, vma, buf);
}
EXPORT_SYMBOL_GPL(vfs_lib_ring_buffer_mmap);
Commit	Line	Data
b7cdc182	1	/* SPDX-License-Identifier: GPL-2.0-only
9f36eaed	2	*
f3bc08c5 MD	3	* ring_buffer_mmap.c
	4	*
	5	* Copyright (C) 2002-2005 - Tom Zanussi <zanussi@us.ibm.com>, IBM Corp
	6	* Copyright (C) 1999-2005 - Karim Yaghmour <karim@opersys.com>
886d51a3	7	* Copyright (C) 2008-2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
f3bc08c5	8	*
b7cdc182	9	* Re-using code from kernel/relay.c, hence the GPL-2.0-only license for this
886d51a3	10	* file.
f3bc08c5 MD	11	*/
	12
	13	#include <linux/module.h>
	14	#include <linux/mm.h>
	15
24591303 MD	16	#include <ringbuffer/backend.h>
	17	#include <ringbuffer/frontend.h>
	18	#include <ringbuffer/vfs.h>
f3bc08c5 MD	19
	20	/*
	21	* fault() vm_op implementation for ring buffer file mapping.
	22	*/
05355f0b MJ	23	#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0) \|\| \
05355f0b MJ	24	LTTNG_RHEL_KERNEL_RANGE(4,18,0,193,0,0, 4,19,0,0,0,0))
2ca0c84f MJ	25	static vm_fault_t lib_ring_buffer_fault_compat(struct vm_area_struct vma, struct vm_fault vmf)
2ca0c84f MJ	26	#else
52a391bd	27	static int lib_ring_buffer_fault_compat(struct vm_area_struct vma, struct vm_fault vmf)
2ca0c84f	28	#endif
f3bc08c5	29	{
e20c0fec	30	struct lttng_kernel_ring_buffer *buf = vma->vm_private_data;
860c213b	31	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
e20c0fec	32	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
f3bc08c5	33	pgoff_t pgoff = vmf->pgoff;
0112cb7b	34	unsigned long *pfnp;
f3bc08c5 MD	35	void **virt;
	36	unsigned long offset, sb_bindex;
	37
f3bc08c5 MD	38	/*
	39	* Verify that faults are only done on the range of pages owned by the
	40	* reader.
	41	*/
	42	offset = pgoff << PAGE_SHIFT;
	43	sb_bindex = subbuffer_id_get_index(config, buf->backend.buf_rsb.id);
	44	if (!(offset >= buf->backend.array[sb_bindex]->mmap_offset
	45	&& offset < buf->backend.array[sb_bindex]->mmap_offset +
	46	buf->backend.chan->backend.subbuf_size))
	47	return VM_FAULT_SIGBUS;
	48	/*
0112cb7b MD	49	* ring_buffer_read_get_pfn() gets the page frame number for the
0112cb7b MD	50	* current reader's pages.
f3bc08c5	51	*/
0112cb7b MD	52	pfnp = lib_ring_buffer_read_get_pfn(&buf->backend, offset, &virt);
0112cb7b MD	53	if (!*pfnp)
f3bc08c5	54	return VM_FAULT_SIGBUS;
0112cb7b MD	55	get_page(pfn_to_page(*pfnp));
0112cb7b MD	56	vmf->page = pfn_to_page(*pfnp);
f3bc08c5 MD	57
	58	return 0;
	59	}
	60
05355f0b MJ	61	#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0) \|\| \
05355f0b MJ	62	LTTNG_RHEL_KERNEL_RANGE(4,18,0,193,0,0, 4,19,0,0,0,0))
2ca0c84f MJ	63	static vm_fault_t lib_ring_buffer_fault(struct vm_fault *vmf)
	64	{
	65	struct vm_area_struct *vma = vmf->vma;
	66	return lib_ring_buffer_fault_compat(vma, vmf);
	67	}
5f4c791e	68	#elif (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0))
52a391bd FD	69	static int lib_ring_buffer_fault(struct vm_fault *vmf)
	70	{
	71	struct vm_area_struct *vma = vmf->vma;
	72	return lib_ring_buffer_fault_compat(vma, vmf);
	73	}
5f4c791e	74	#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0)) */
52a391bd FD	75	static int lib_ring_buffer_fault(struct vm_area_struct vma, struct vm_fault vmf)
	76	{
	77	return lib_ring_buffer_fault_compat(vma, vmf);
	78	}
5f4c791e	79	#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,11,0)) */
52a391bd	80
f3bc08c5 MD	81	/*
	82	* vm_ops for ring buffer file mappings.
	83	*/
	84	static const struct vm_operations_struct lib_ring_buffer_mmap_ops = {
	85	.fault = lib_ring_buffer_fault,
	86	};
	87
	88	/**
	89	* lib_ring_buffer_mmap_buf: - mmap channel buffer to process address space
	90	* @buf: ring buffer to map
	91	* @vma: vm_area_struct describing memory to be mapped
	92	*
	93	* Returns 0 if ok, negative on error
	94	*
	95	* Caller should already have grabbed mmap_sem.
	96	*/
e20c0fec	97	static int lib_ring_buffer_mmap_buf(struct lttng_kernel_ring_buffer *buf,
f3bc08c5 MD	98	struct vm_area_struct *vma)
	99	{
	100	unsigned long length = vma->vm_end - vma->vm_start;
860c213b	101	struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan;
e20c0fec	102	const struct lttng_kernel_ring_buffer_config *config = &chan->backend.config;
f3bc08c5 MD	103	unsigned long mmap_buf_len;
	104
	105	if (config->output != RING_BUFFER_MMAP)
	106	return -EINVAL;
	107
f3bc08c5 MD	108	mmap_buf_len = chan->backend.buf_size;
	109	if (chan->backend.extra_reader_sb)
	110	mmap_buf_len += chan->backend.subbuf_size;
	111
	112	if (length != mmap_buf_len)
	113	return -EINVAL;
	114
	115	vma->vm_ops = &lib_ring_buffer_mmap_ops;
	116	vma->vm_flags \|= VM_DONTEXPAND;
	117	vma->vm_private_data = buf;
	118
	119	return 0;
	120	}
	121
d83004aa	122	int lib_ring_buffer_mmap(struct file filp, struct vm_area_struct vma,
e20c0fec	123	struct lttng_kernel_ring_buffer *buf)
d83004aa JD	124	{
	125	return lib_ring_buffer_mmap_buf(buf, vma);
	126	}
	127	EXPORT_SYMBOL_GPL(lib_ring_buffer_mmap);
	128
f3bc08c5	129	/**
d83004aa	130	* vfs_lib_ring_buffer_mmap - mmap file op
f3bc08c5 MD	131	* @filp: the file
	132	* @vma: the vma describing what to map
	133	*
	134	* Calls upon lib_ring_buffer_mmap_buf() to map the file into user space.
	135	*/
d83004aa	136	int vfs_lib_ring_buffer_mmap(struct file filp, struct vm_area_struct vma)
f3bc08c5	137	{
e20c0fec	138	struct lttng_kernel_ring_buffer *buf = filp->private_data;
d83004aa	139	return lib_ring_buffer_mmap(filp, vma, buf);
f3bc08c5	140	}
d83004aa	141	EXPORT_SYMBOL_GPL(vfs_lib_ring_buffer_mmap);