Re: [PATCH 1/1] tools/dtrace: initial implementation of DTrace

[Peter Zijlstra]

On Wed, Jul 03, 2019 at 08:14:30PM -0700, Kris Van Hees wrote:
> +/*
> + * Read the data_head offset from the header page of the ring buffer.  The
> + * argument is declared 'volatile' because it references a memory mapped page
> + * that the kernel may be writing to while we access it here.
> + */
> +static u64 read_rb_head(volatile struct perf_event_mmap_page *rb_page)
> +{
> +	u64	head = rb_page->data_head;
> +
> +	asm volatile("" ::: "memory");
> +
> +	return head;
> +}
> +
> +/*
> + * Write the data_tail offset in the header page of the ring buffer.  The
> + * argument is declared 'volatile' because it references a memory mapped page
> + * that the kernel may be writing to while we access it here.

s/writing/reading/

> + */
> +static void write_rb_tail(volatile struct perf_event_mmap_page *rb_page,
> +			  u64 tail)
> +{
> +	asm volatile("" ::: "memory");
> +
> +	rb_page->data_tail = tail;
> +}

That volatile usage is atrocious (kernel style would have you use
{READ,WRITE}_ONCE()). Also your comments fail to mark these as
load_acquire and store_release. And by only using a compiler barrier
you're hard assuming TSO, which is somewhat fragile at best.

Alternatively, you can use the C11 bits and write:

	return __atomic_load_n(&rb_page->data_head, __ATOMIC_ACQUIRE);

	__atomic_store_n(&rb_page->data_tail, tail, __ATOMIC_RELEASE);

> +/*
> + * Process and output the probe data at the supplied address.
> + */
> +static int output_event(int cpu, u64 *buf)
> +{
> +	u8				*data = (u8 *)buf;
> +	struct perf_event_header	*hdr;
> +
> +	hdr = (struct perf_event_header *)data;
> +	data += sizeof(struct perf_event_header);
> +
> +	if (hdr->type == PERF_RECORD_SAMPLE) {
> +		u8		*ptr = data;
> +		u32		i, size, probe_id;
> +
> +		/*
> +		 * struct {
> +		 *	struct perf_event_header	header;
> +		 *	u32				size;
> +		 *	u32				probe_id;
> +		 *	u32				gap;
> +		 *	u64				data[n];
> +		 * }
> +		 * and data points to the 'size' member at this point.
> +		 */
> +		if (ptr > (u8 *)buf + hdr->size) {
> +			fprintf(stderr, "BAD: corrupted sample header\n");
> +			goto out;
> +		}
> +
> +		size = *(u32 *)data;
> +		data += sizeof(size);
> +		ptr += sizeof(size) + size;
> +		if (ptr != (u8 *)buf + hdr->size) {
> +			fprintf(stderr, "BAD: invalid sample size\n");
> +			goto out;
> +		}
> +
> +		probe_id = *(u32 *)data;
> +		data += sizeof(probe_id);
> +		size -= sizeof(probe_id);
> +		data += sizeof(u32);		/* skip 32-bit gap */
> +		size -= sizeof(u32);
> +		buf = (u64 *)data;
> +
> +		printf("%3d %6d ", cpu, probe_id);
> +		for (i = 0, size /= sizeof(u64); i < size; i++)
> +			printf("%#016lx ", buf[i]);
> +		printf("\n");
> +	} else if (hdr->type == PERF_RECORD_LOST) {
> +		u64	lost;
> +
> +		/*
> +		 * struct {
> +		 *	struct perf_event_header	header;
> +		 *	u64				id;
> +		 *	u64				lost;
> +		 * }
> +		 * and data points to the 'id' member at this point.
> +		 */
> +		lost = *(u64 *)(data + sizeof(u64));
> +
> +		printf("[%ld probes dropped]\n", lost);
> +	} else
> +		fprintf(stderr, "UNKNOWN: record type %d\n", hdr->type);
> +
> +out:
> +	return hdr->size;
> +}

I see a distinct lack of wrapping support. AFAICT when buf+hdr->size
wraps you're doing out-of-bounds accesses.

> +/*
> + * Process the available probe data in the given buffer.
> + */
> +static void process_data(struct dtrace_buffer *buf)
> +{
> +	/* This is volatile because the kernel may be updating the content. */
> +	volatile struct perf_event_mmap_page	*rb_page = buf->base;
> +	u8					*base = (u8 *)buf->base +
> +							buf->page_size;
> +	u64					head = read_rb_head(rb_page);
> +
> +	while (rb_page->data_tail != head) {
> +		u64	tail = rb_page->data_tail;
> +		u64	*ptr = (u64 *)(base + tail % buf->data_size);
> +		int	len;
> +
> +		len = output_event(buf->cpu, ptr);
> +
> +		write_rb_tail(rb_page, tail + len);
> +		head = read_rb_head(rb_page);
> +	}
> +}

more volatile yuck.

Also:

	for (;;) {
		head = __atomic_load_n(&rb_page->data_head, __ATOMIC_ACQUIRE);
		tail = __atomic_load_n(&rb_page->data_tail, __ATOMIC_RELAXED);

		if (head == tail)
			break;

		do {
			hdr = buf->base + (tail & ((1UL << buf->data_shift) - 1));
			if ((tail >> buf->data_shift) !=
			    ((tail + hdr->size) >> buf->data_shift))
				/* handle wrap case */
			else
				/* normal case */

			tail += hdr->size;
		} while (tail != head);

		__atomic_store_n(&rb_page->data_tail, tail, __ATOMIC_RELEASE);
	}

Or something.

> +/*
> + * Wait for data to become available in any of the buffers.
> + */
> +int dt_buffer_poll(int epoll_fd, int timeout)
> +{
> +	struct epoll_event	events[dt_numcpus];
> +	int			i, cnt;
> +
> +	cnt = epoll_wait(epoll_fd, events, dt_numcpus, timeout);
> +	if (cnt < 0)
> +		return -errno;
> +
> +	for (i = 0; i < cnt; i++)
> +		process_data((struct dtrace_buffer *)events[i].data.ptr);
> +
> +	return cnt;
> +}

Or make sure to read on the CPU by having a poll thread per CPU, then
you can do away with the memory barriers.