Commit 207a573c authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'trace_printk-banner-remove' 

Alan Maguire says:

====================
Steven suggested a way to resolve the appearance of the warning banner
that appears as a result of using trace_printk() in BPF [1].
Applying the patch and testing reveals all works as expected; we
can call bpf_trace_printk() and see the trace messages in
/sys/kernel/debug/tracing/trace_pipe and no banner message appears.

Also add a test prog to verify basic bpf_trace_printk() helper behaviour.

Changes since v2:

- fixed stray newline in bpf_trace_printk(), use sizeof(buf)
  rather than #defined value in vsnprintf() (Daniel, patch 1)
- Daniel also pointed out that vsnprintf() returns 0 on error rather
  than a negative value; also turns out that a null byte is not
  appended if the length of the string written is zero, so to fix
  for cases where the string to be traced is zero length we set the
  null byte explicitly (Daniel, patch 1)
- switch to using getline() for retrieving lines from trace buffer
  to ensure we don't read a portion of the search message in one
  read() operation and then fail to find it (Andrii, patch 2)

Changes since v1:

- reorder header inclusion in bpf_trace.c (Steven, patch 1)
- trace zero-length messages also (Andrii, patch 1)
- use a raw spinlock to ensure there are no issues for PREMMPT_RT
  kernels when using bpf_trace_printk() within other raw spinlocks
  (Steven, patch 1)
- always enable bpf_trace_printk() tracepoint when loading programs
  using bpf_trace_printk() as this will ensure that a user disabling
  that tracepoint will not prevent tracing output from being logged
  (Steven, patch 1)
- use "tp/raw_syscalls/sys_enter" and a usleep(1) to trigger events
  in the selftest ensuring test runs faster (Andrii, patch 2)

[1]  https://lore.kernel.org/r/20200628194334.6238b933@oasis.local.home


====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents 93776cb9 59e8b60b

kernel/trace/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -31,6 +31,8 @@ ifdef CONFIG_GCOV_PROFILE_FTRACE 
GCOV_PROFILE := y

endif



CFLAGS_bpf_trace.o := -I$(src)



CFLAGS_trace_benchmark.o := -I$(src)

CFLAGS_trace_events_filter.o := -I$(src)

kernel/trace/bpf_trace.c

+37 −5
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
#include <linux/uaccess.h>

#include <linux/ctype.h>

#include <linux/kprobes.h>

#include <linux/spinlock.h>

#include <linux/syscalls.h>

#include <linux/error-injection.h>

#include <linux/btf_ids.h>
@@ -20,6 +21,9 @@ 
#include "trace_probe.h"

#include "trace.h"



#define CREATE_TRACE_POINTS

#include "bpf_trace.h"



#define bpf_event_rcu_dereference(p)					\

	rcu_dereference_protected(p, lockdep_is_held(&bpf_event_mutex))
@@ -375,6 +379,30 @@ static void bpf_trace_copy_string(char *buf, void *unsafe_ptr, char fmt_ptype, 
	}

}



static DEFINE_RAW_SPINLOCK(trace_printk_lock);



#define BPF_TRACE_PRINTK_SIZE   1024



static inline __printf(1, 0) int bpf_do_trace_printk(const char *fmt, ...)

{

	static char buf[BPF_TRACE_PRINTK_SIZE];

	unsigned long flags;

	va_list ap;

	int ret;



	raw_spin_lock_irqsave(&trace_printk_lock, flags);

	va_start(ap, fmt);

	ret = vsnprintf(buf, sizeof(buf), fmt, ap);

	va_end(ap);

	/* vsnprintf() will not append null for zero-length strings */

	if (ret == 0)

		buf[0] = '\0';

	trace_bpf_trace_printk(buf);

	raw_spin_unlock_irqrestore(&trace_printk_lock, flags);



	return ret;

}



/*

 * Only limited trace_printk() conversion specifiers allowed:

 * %d %i %u %x %ld %li %lu %lx %lld %lli %llu %llx %p %pB %pks %pus %s
@@ -484,8 +512,7 @@ fmt_next: 
 */

#define __BPF_TP_EMIT()	__BPF_ARG3_TP()

#define __BPF_TP(...)							\

	__trace_printk(0 /* Fake ip */,					\

		       fmt, ##__VA_ARGS__)

	bpf_do_trace_printk(fmt, ##__VA_ARGS__)



#define __BPF_ARG1_TP(...)						\

	((mod[0] == 2 || (mod[0] == 1 && __BITS_PER_LONG == 64))	\
@@ -522,10 +549,15 @@ static const struct bpf_func_proto bpf_trace_printk_proto = { 
const struct bpf_func_proto *bpf_get_trace_printk_proto(void)

{

	/*

	 * this program might be calling bpf_trace_printk,

	 * so allocate per-cpu printk buffers

	 * This program might be calling bpf_trace_printk,

	 * so enable the associated bpf_trace/bpf_trace_printk event.

	 * Repeat this each time as it is possible a user has

	 * disabled bpf_trace_printk events.  By loading a program

	 * calling bpf_trace_printk() however the user has expressed

	 * the intent to see such events.

	 */

	trace_printk_init_buffers();

	if (trace_set_clr_event("bpf_trace", "bpf_trace_printk", 1))

		pr_warn_ratelimited("could not enable bpf_trace_printk events");



	return &bpf_trace_printk_proto;

}

kernel/trace/bpf_trace.h

0 → 100644
+34 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

#undef TRACE_SYSTEM

#define TRACE_SYSTEM bpf_trace



#if !defined(_TRACE_BPF_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)



#define _TRACE_BPF_TRACE_H



#include <linux/tracepoint.h>



TRACE_EVENT(bpf_trace_printk,



	TP_PROTO(const char *bpf_string),



	TP_ARGS(bpf_string),



	TP_STRUCT__entry(

		__string(bpf_string, bpf_string)

	),



	TP_fast_assign(

		__assign_str(bpf_string, bpf_string);

	),



	TP_printk("%s", __get_str(bpf_string))

);



#endif /* _TRACE_BPF_TRACE_H */



#undef TRACE_INCLUDE_PATH

#define TRACE_INCLUDE_PATH .

#define TRACE_INCLUDE_FILE bpf_trace



#include <trace/define_trace.h>

tools/testing/selftests/bpf/prog_tests/trace_printk.c

0 → 100644
+75 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2020, Oracle and/or its affiliates. */



#include <test_progs.h>



#include "trace_printk.skel.h"



#define TRACEBUF	"/sys/kernel/debug/tracing/trace_pipe"

#define SEARCHMSG	"testing,testing"



void test_trace_printk(void)

{

	int err, iter = 0, duration = 0, found = 0;

	struct trace_printk__bss *bss;

	struct trace_printk *skel;

	char *buf = NULL;

	FILE *fp = NULL;

	size_t buflen;



	skel = trace_printk__open();

	if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))

		return;



	err = trace_printk__load(skel);

	if (CHECK(err, "skel_load", "failed to load skeleton: %d\n", err))

		goto cleanup;



	bss = skel->bss;



	err = trace_printk__attach(skel);

	if (CHECK(err, "skel_attach", "skeleton attach failed: %d\n", err))

		goto cleanup;



	fp = fopen(TRACEBUF, "r");

	if (CHECK(fp == NULL, "could not open trace buffer",

		  "error %d opening %s", errno, TRACEBUF))

		goto cleanup;



	/* We do not want to wait forever if this test fails... */

	fcntl(fileno(fp), F_SETFL, O_NONBLOCK);



	/* wait for tracepoint to trigger */

	usleep(1);

	trace_printk__detach(skel);



	if (CHECK(bss->trace_printk_ran == 0,

		  "bpf_trace_printk never ran",

		  "ran == %d", bss->trace_printk_ran))

		goto cleanup;



	if (CHECK(bss->trace_printk_ret <= 0,

		  "bpf_trace_printk returned <= 0 value",

		  "got %d", bss->trace_printk_ret))

		goto cleanup;



	/* verify our search string is in the trace buffer */

	while (getline(&buf, &buflen, fp) >= 0 || errno == EAGAIN) {

		if (strstr(buf, SEARCHMSG) != NULL)

			found++;

		if (found == bss->trace_printk_ran)

			break;

		if (++iter > 1000)

			break;

	}



	if (CHECK(!found, "message from bpf_trace_printk not found",

		  "no instance of %s in %s", SEARCHMSG, TRACEBUF))

		goto cleanup;



cleanup:

	trace_printk__destroy(skel);

	free(buf);

	if (fp)

		fclose(fp);

}

tools/testing/selftests/bpf/progs/trace_printk.c

0 → 100644
+21 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

// Copyright (c) 2020, Oracle and/or its affiliates.



#include "vmlinux.h"

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_tracing.h>



char _license[] SEC("license") = "GPL";



int trace_printk_ret = 0;

int trace_printk_ran = 0;



SEC("tp/raw_syscalls/sys_enter")

int sys_enter(void *ctx)

{

	static const char fmt[] = "testing,testing %d\n";



	trace_printk_ret = bpf_trace_printk(fmt, sizeof(fmt),

					    ++trace_printk_ran);

	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE