mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-11-13 08:27:23 +00:00
3c21d7738a
The name of the function emitting a log message may be of interest for a
developer but is distracting for normal users. See the example below:
try_load_entry() Booting: Debian
Make the default format for log messages customizable. By default show
only the message text.
Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
Reviewed-by: Simon Glass <sjg@chromium.org>
288 lines
8.1 KiB
C
288 lines
8.1 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright (c) 2020, Heinrich Schuchardt <xypron.glpk@gmx.de>
|
|
*
|
|
* Logging function tests for CONFIG_LOG_SYSLOG=y.
|
|
*
|
|
* Invoke the test with: ./u-boot -d arch/sandbox/dts/test.dtb
|
|
*/
|
|
|
|
/* Override CONFIG_LOG_MAX_LEVEL */
|
|
#define LOG_DEBUG
|
|
|
|
#include <common.h>
|
|
#include <dm/device.h>
|
|
#include <hexdump.h>
|
|
#include <test/log.h>
|
|
#include <test/test.h>
|
|
#include <test/suites.h>
|
|
#include <test/ut.h>
|
|
#include <asm/eth.h>
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
#define LOGF_TEST (BIT(LOGF_FUNC) | BIT(LOGF_MSG))
|
|
|
|
/**
|
|
* struct sb_log_env - private data for sandbox ethernet driver
|
|
*
|
|
* This structure is used for the private data of the sandbox ethernet
|
|
* driver.
|
|
*
|
|
* @expected: string expected to be written by the syslog driver
|
|
* @uts: unit test state
|
|
*/
|
|
struct sb_log_env {
|
|
const char *expected;
|
|
struct unit_test_state *uts;
|
|
};
|
|
|
|
/**
|
|
* sb_log_tx_handler() - transmit callback function
|
|
*
|
|
* This callback function is invoked when a network package is sent using the
|
|
* sandbox Ethernet driver. The private data of the driver holds a sb_log_env
|
|
* structure with the unit test state and the expected UDP payload.
|
|
*
|
|
* The following checks are executed:
|
|
*
|
|
* * the Ethernet packet indicates a IP broadcast message
|
|
* * the IP header is for a local UDP broadcast message to port 514
|
|
* * the UDP payload matches the expected string
|
|
*
|
|
* After testing the pointer to the expected string is set to NULL to signal
|
|
* that the callback function has been called.
|
|
*
|
|
* @dev: sandbox ethernet device
|
|
* @packet: Ethernet packet
|
|
* @len: length of Ethernet packet
|
|
* Return: 0 = success
|
|
*/
|
|
static int sb_log_tx_handler(struct udevice *dev, void *packet,
|
|
unsigned int len)
|
|
{
|
|
struct eth_sandbox_priv *priv = dev_get_priv(dev);
|
|
struct sb_log_env *env = priv->priv;
|
|
/* uts is updated by the ut_assert* macros */
|
|
struct unit_test_state *uts = env->uts;
|
|
char *buf = packet;
|
|
struct ethernet_hdr *eth_hdr = packet;
|
|
struct ip_udp_hdr *ip_udp_hdr;
|
|
|
|
/* Check Ethernet header */
|
|
ut_asserteq_mem(ð_hdr->et_dest, net_bcast_ethaddr, ARP_HLEN);
|
|
ut_asserteq(ntohs(eth_hdr->et_protlen), PROT_IP);
|
|
|
|
/* Check IP header */
|
|
buf += sizeof(struct ethernet_hdr);
|
|
ip_udp_hdr = (struct ip_udp_hdr *)buf;
|
|
ut_asserteq(ip_udp_hdr->ip_p, IPPROTO_UDP);
|
|
ut_asserteq(ip_udp_hdr->ip_dst.s_addr, 0xffffffff);
|
|
ut_asserteq(ntohs(ip_udp_hdr->udp_dst), 514);
|
|
ut_asserteq(UDP_HDR_SIZE + strlen(env->expected) + 1,
|
|
ntohs(ip_udp_hdr->udp_len));
|
|
|
|
/* Check payload */
|
|
buf += sizeof(struct ip_udp_hdr);
|
|
ut_asserteq_mem(env->expected, buf,
|
|
ntohs(ip_udp_hdr->udp_len) - UDP_HDR_SIZE);
|
|
|
|
/* Signal that the callback function has been executed */
|
|
env->expected = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* log_test_syslog_err() - test log_err() function
|
|
*
|
|
* @uts: unit test state
|
|
* Return: 0 = success
|
|
*/
|
|
static int log_test_syslog_err(struct unit_test_state *uts)
|
|
{
|
|
int old_log_level = gd->default_log_level;
|
|
struct sb_log_env env;
|
|
|
|
gd->log_fmt = LOGF_TEST;
|
|
gd->default_log_level = LOGL_INFO;
|
|
env_set("ethact", "eth@10002000");
|
|
env_set("log_hostname", "sandbox");
|
|
env.expected = "<3>sandbox uboot: log_test_syslog_err() "
|
|
"testing log_err\n";
|
|
env.uts = uts;
|
|
sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
|
|
/* Used by ut_assert macros in the tx_handler */
|
|
sandbox_eth_set_priv(0, &env);
|
|
log_err("testing %s\n", "log_err");
|
|
/* Check that the callback function was called */
|
|
sandbox_eth_set_tx_handler(0, NULL);
|
|
gd->default_log_level = old_log_level;
|
|
gd->log_fmt = log_get_default_format();
|
|
|
|
return 0;
|
|
}
|
|
LOG_TEST(log_test_syslog_err);
|
|
|
|
/**
|
|
* log_test_syslog_warning() - test log_warning() function
|
|
*
|
|
* @uts: unit test state
|
|
* Return: 0 = success
|
|
*/
|
|
static int log_test_syslog_warning(struct unit_test_state *uts)
|
|
{
|
|
int old_log_level = gd->default_log_level;
|
|
struct sb_log_env env;
|
|
|
|
gd->log_fmt = LOGF_TEST;
|
|
gd->default_log_level = LOGL_INFO;
|
|
env_set("ethact", "eth@10002000");
|
|
env_set("log_hostname", "sandbox");
|
|
env.expected = "<4>sandbox uboot: log_test_syslog_warning() "
|
|
"testing log_warning\n";
|
|
env.uts = uts;
|
|
sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
|
|
/* Used by ut_assert macros in the tx_handler */
|
|
sandbox_eth_set_priv(0, &env);
|
|
log_warning("testing %s\n", "log_warning");
|
|
sandbox_eth_set_tx_handler(0, NULL);
|
|
/* Check that the callback function was called */
|
|
ut_assertnull(env.expected);
|
|
gd->default_log_level = old_log_level;
|
|
gd->log_fmt = log_get_default_format();
|
|
|
|
return 0;
|
|
}
|
|
LOG_TEST(log_test_syslog_warning);
|
|
|
|
/**
|
|
* log_test_syslog_notice() - test log_notice() function
|
|
*
|
|
* @uts: unit test state
|
|
* Return: 0 = success
|
|
*/
|
|
static int log_test_syslog_notice(struct unit_test_state *uts)
|
|
{
|
|
int old_log_level = gd->default_log_level;
|
|
struct sb_log_env env;
|
|
|
|
gd->log_fmt = LOGF_TEST;
|
|
gd->default_log_level = LOGL_INFO;
|
|
env_set("ethact", "eth@10002000");
|
|
env_set("log_hostname", "sandbox");
|
|
env.expected = "<5>sandbox uboot: log_test_syslog_notice() "
|
|
"testing log_notice\n";
|
|
env.uts = uts;
|
|
sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
|
|
/* Used by ut_assert macros in the tx_handler */
|
|
sandbox_eth_set_priv(0, &env);
|
|
log_notice("testing %s\n", "log_notice");
|
|
sandbox_eth_set_tx_handler(0, NULL);
|
|
/* Check that the callback function was called */
|
|
ut_assertnull(env.expected);
|
|
gd->default_log_level = old_log_level;
|
|
gd->log_fmt = log_get_default_format();
|
|
|
|
return 0;
|
|
}
|
|
LOG_TEST(log_test_syslog_notice);
|
|
|
|
/**
|
|
* log_test_syslog_info() - test log_info() function
|
|
*
|
|
* @uts: unit test state
|
|
* Return: 0 = success
|
|
*/
|
|
static int log_test_syslog_info(struct unit_test_state *uts)
|
|
{
|
|
int old_log_level = gd->default_log_level;
|
|
struct sb_log_env env;
|
|
|
|
gd->log_fmt = LOGF_TEST;
|
|
gd->default_log_level = LOGL_INFO;
|
|
env_set("ethact", "eth@10002000");
|
|
env_set("log_hostname", "sandbox");
|
|
env.expected = "<6>sandbox uboot: log_test_syslog_info() "
|
|
"testing log_info\n";
|
|
env.uts = uts;
|
|
sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
|
|
/* Used by ut_assert macros in the tx_handler */
|
|
sandbox_eth_set_priv(0, &env);
|
|
log_info("testing %s\n", "log_info");
|
|
sandbox_eth_set_tx_handler(0, NULL);
|
|
/* Check that the callback function was called */
|
|
ut_assertnull(env.expected);
|
|
gd->default_log_level = old_log_level;
|
|
gd->log_fmt = log_get_default_format();
|
|
|
|
return 0;
|
|
}
|
|
LOG_TEST(log_test_syslog_info);
|
|
|
|
/**
|
|
* log_test_syslog_debug() - test log_debug() function
|
|
*
|
|
* @uts: unit test state
|
|
* Return: 0 = success
|
|
*/
|
|
static int log_test_syslog_debug(struct unit_test_state *uts)
|
|
{
|
|
int old_log_level = gd->default_log_level;
|
|
struct sb_log_env env;
|
|
|
|
gd->log_fmt = LOGF_TEST;
|
|
gd->default_log_level = LOGL_DEBUG;
|
|
env_set("ethact", "eth@10002000");
|
|
env_set("log_hostname", "sandbox");
|
|
env.expected = "<7>sandbox uboot: log_test_syslog_debug() "
|
|
"testing log_debug\n";
|
|
env.uts = uts;
|
|
sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
|
|
/* Used by ut_assert macros in the tx_handler */
|
|
sandbox_eth_set_priv(0, &env);
|
|
log_debug("testing %s\n", "log_debug");
|
|
sandbox_eth_set_tx_handler(0, NULL);
|
|
/* Check that the callback function was called */
|
|
ut_assertnull(env.expected);
|
|
gd->default_log_level = old_log_level;
|
|
gd->log_fmt = log_get_default_format();
|
|
|
|
return 0;
|
|
}
|
|
LOG_TEST(log_test_syslog_debug);
|
|
|
|
/**
|
|
* log_test_syslog_nodebug() - test logging level filter
|
|
*
|
|
* Verify that log_debug() does not lead to a log message if the logging level
|
|
* is set to LOGL_INFO.
|
|
*
|
|
* @uts: unit test state
|
|
* Return: 0 = success
|
|
*/
|
|
static int log_test_syslog_nodebug(struct unit_test_state *uts)
|
|
{
|
|
int old_log_level = gd->default_log_level;
|
|
struct sb_log_env env;
|
|
|
|
gd->log_fmt = LOGF_TEST;
|
|
gd->default_log_level = LOGL_INFO;
|
|
env_set("ethact", "eth@10002000");
|
|
env_set("log_hostname", "sandbox");
|
|
env.expected = "<7>sandbox uboot: log_test_syslog_nodebug() "
|
|
"testing log_debug\n";
|
|
env.uts = uts;
|
|
sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
|
|
/* Used by ut_assert macros in the tx_handler */
|
|
sandbox_eth_set_priv(0, &env);
|
|
log_debug("testing %s\n", "log_debug");
|
|
sandbox_eth_set_tx_handler(0, NULL);
|
|
/* Check that the callback function was not called */
|
|
ut_assertnonnull(env.expected);
|
|
gd->default_log_level = old_log_level;
|
|
gd->log_fmt = log_get_default_format();
|
|
|
|
return 0;
|
|
}
|
|
LOG_TEST(log_test_syslog_nodebug);
|