michaelh/zephyr
1
0
Fork 0
Code Releases Activity

kernel: remove object tracing

Browse source 
Remove this intrusive tracing feature in favor of the new object tracing
using the main tracing feature in zephyr. See #33603 for the new tracing
coverage for all objects.

This will allow for support in more tools and less reliance on GDB for
tracing objects.

Signed-off-by: Anas Nashif <anas.nashif@intel.com>
This commit is contained in:
Anas Nashif 2021-04-18 23:24:40 -04:00
commit 4d994af032
40 changed files with 32 additions and 872 deletions
Download patch file Download diff file Expand all files Collapse all files

58
include/debug/object_tracing.h
View file

@ -4,60 +4,10 @@
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief APIs used when examining the objects in a debug tracing list.
*/
#ifndef ZEPHYR_INCLUDE_DEBUG_OBJECT_TRACING_H_
#define ZEPHYR_INCLUDE_DEBUG_OBJECT_TRACING_H_
#ifdef CONFIG_OBJECT_TRACING
#ifndef ZEPHYR_INCLUDE_THREAD_MONITOR_H_
#define ZEPHYR_INCLUDE_THREAD_MONITOR_H_
#include <kernel.h>
extern struct k_timer *_trace_list_k_timer;
extern struct k_mem_slab *_trace_list_k_mem_slab;
extern struct k_mem_pool *_trace_list_k_mem_pool;
extern struct k_sem *_trace_list_k_sem;
extern struct k_mutex *_trace_list_k_mutex;
extern struct k_fifo *_trace_list_k_fifo;
extern struct k_lifo *_trace_list_k_lifo;
extern struct k_stack *_trace_list_k_stack;
extern struct k_msgq *_trace_list_k_msgq;
extern struct k_mbox *_trace_list_k_mbox;
extern struct k_pipe *_trace_list_k_pipe;
extern struct k_queue *_trace_list_k_queue;
/**
* @def SYS_TRACING_HEAD
*
* @brief Head element of a trace list.
*
* @details Access the head element of a given trace list.
*
* @param type Data type of the trace list to get the head from.
* @param name Name of the trace list to get the head from.
*/
#define SYS_TRACING_HEAD(type, name) ((type *) _CONCAT(_trace_list_, name))
/**
* @def SYS_TRACING_NEXT
*
* @brief Gets a node's next element.
*
* @details Given a node in a trace list, gets the next element
* in the list.
*
* @param type Data type of the trace list
* @param name Name of the trace list to get the head from.
* @param obj Object to get next element from.
*/
#define SYS_TRACING_NEXT(type, name, obj) (((type *)obj)->__next)
#endif /*CONFIG_OBJECT_TRACING*/
#ifdef CONFIG_THREAD_MONITOR
#include <kernel_structs.h>
/**
@ -82,6 +32,4 @@ extern struct k_queue *_trace_list_k_queue;
*/
#define SYS_THREAD_MONITOR_NEXT(obj) (((struct k_thread *)obj)->next_thread)
#endif /*CONFIG_THREAD_MONITOR*/
#endif /*ZEPHYR_INCLUDE_DEBUG_OBJECT_TRACING_H_*/
#endif /* ZEPHYR_INCLUDE_THREAD_MONITOR_H_ */

106
include/debug/object_tracing_common.h
View file

@ -1,106 +0,0 @@
/*
* Copyright (c) 2016 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief APIs used to add or remove an object in a debug tracing list.
*/
#ifndef ZEPHYR_INCLUDE_DEBUG_OBJECT_TRACING_COMMON_H_
#define ZEPHYR_INCLUDE_DEBUG_OBJECT_TRACING_COMMON_H_
#include <stdbool.h>
#ifndef CONFIG_OBJECT_TRACING
#define SYS_TRACING_OBJ_INIT(name, obj) do { } while (false)
#define SYS_TRACING_OBJ_INIT_DLL(name, obj) do { } while (false)
#define SYS_TRACING_OBJ_REMOVE_DLL(name, obj) do { } while (false)
#else
/**
* @def SYS_TRACING_OBJ_INIT
*
* @brief Adds a new object into the trace list
*
* @details The object is added for tracing into a trace list. This is usually
* called at the moment of object initialization.
*
* @param name Name of the trace list.
* @param obj Object to be added in the trace list.
*/
#define SYS_TRACING_OBJ_INIT(name, obj) \
do { \
unsigned int key; \
\
key = irq_lock(); \
if (!(obj)->__linked) { \
(obj)->__next = _trace_list_ ## name; \
_trace_list_ ## name = obj; \
(obj)->__linked = 1; \
} \
irq_unlock(key); \
} \
while (false)
/**
* @def SYS_TRACING_OBJ_INIT_DLL
*
* @brief Adds a new object into the trace list as a double linked list.
*
* @details The object is added for tracing into a trace list. This is usually
* called at the moment of object initialization. This list is used for objects
* that can be removed from the tracing list dynamically.
*
* @param name Name of the trace list.
* @param obj Object to be added in the trace list.
*/
#define SYS_TRACING_OBJ_INIT_DLL(name, obj) \
do { \
unsigned int key; \
\
key = irq_lock(); \
if (_trace_list_ ## name) { \
_trace_list_ ## name->__prev = (obj); \
} \
(obj)->__next = _trace_list_ ## name; \
(obj)->__prev = NULL; \
_trace_list_ ## name = obj; \
irq_unlock(key); \
} \
while (false)
/**
* @def SYS_TRACING_OBJ_REMOVE_DLL
*
* @brief Removes an object from a double linked trace list.
*
* @details The object is remove from the trace list.
* It needs to be used with DEBUG_TRACING_OBJ_INIT_DLL as a pair.
*
* @param name Name of the trace list.
* @param obj Object to be removed from the trace list.
*/
#define SYS_TRACING_OBJ_REMOVE_DLL(name, obj) \
do { \
unsigned int key; \
\
key = irq_lock(); \
if (obj->__next) { \
obj->__next->__prev = (obj)->__prev; \
} \
if (obj->__prev) { \
obj->__prev->__next = (obj)->__next; \
} else { \
_trace_list_ ## name = (obj)->__next; \
} \
irq_unlock(key); \
} \
while (false)
#endif /*CONFIG_OBJECT_TRACING*/
#endif /*ZEPHYR_INCLUDE_DEBUG_OBJECT_TRACING_COMMON_H_*/

41
include/kernel.h
View file

@ -76,18 +76,6 @@ extern "C" {
#define K_HIGHEST_APPLICATION_THREAD_PRIO (K_HIGHEST_THREAD_PRIO)
#define K_LOWEST_APPLICATION_THREAD_PRIO (K_LOWEST_THREAD_PRIO - 1)
#ifdef CONFIG_OBJECT_TRACING
#define _OBJECT_TRACING_NEXT_PTR(type) struct type *__next;
#define _OBJECT_TRACING_LINKED_FLAG uint8_t __linked;
#define _OBJECT_TRACING_INIT \
.__next = NULL, \
.__linked = 0,
#else
#define _OBJECT_TRACING_INIT
#define _OBJECT_TRACING_NEXT_PTR(type)
#define _OBJECT_TRACING_LINKED_FLAG
#endif
#ifdef CONFIG_POLL
#define _POLL_EVENT_OBJ_INIT(obj) \
.poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events),
@ -1296,8 +1284,6 @@ struct k_timer {
/* user-specific data, also used to support legacy features */
void *user_data;
_OBJECT_TRACING_NEXT_PTR(k_timer)
_OBJECT_TRACING_LINKED_FLAG
};
#define Z_TIMER_INITIALIZER(obj, expiry, stop) \
@ -1312,7 +1298,6 @@ struct k_timer {
.stop_fn = stop, \
.status = 0, \
.user_data = 0, \
_OBJECT_TRACING_INIT \
}
/**
@ -1659,8 +1644,6 @@ struct k_queue {
_wait_q_t wait_q;
_POLL_EVENT;
_OBJECT_TRACING_NEXT_PTR(k_queue)
_OBJECT_TRACING_LINKED_FLAG
};
#define Z_QUEUE_INITIALIZER(obj) \
@ -1669,7 +1652,6 @@ struct k_queue {
.lock = { }, \
.wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
_POLL_EVENT_OBJ_INIT(obj) \
_OBJECT_TRACING_INIT \
}
extern void *z_queue_node_peek(sys_sfnode_t *node, bool needs_free);
@ -2403,8 +2385,6 @@ struct k_stack {
struct k_spinlock lock;
stack_data_t *base, *next, *top;
_OBJECT_TRACING_NEXT_PTR(k_stack)
_OBJECT_TRACING_LINKED_FLAG
uint8_t flags;
};
@ -2414,7 +2394,6 @@ struct k_stack {
.base = stack_buffer, \
.next = stack_buffer, \
.top = stack_buffer + stack_num_entries, \
_OBJECT_TRACING_INIT \
}
/**
@ -2564,9 +2543,6 @@ struct k_mutex {
/** Original thread priority */
int owner_orig_prio;
_OBJECT_TRACING_NEXT_PTR(k_mutex)
_OBJECT_TRACING_LINKED_FLAG
};
/**
@ -2578,7 +2554,6 @@ struct k_mutex {
.owner = NULL, \
.lock_count = 0, \
.owner_orig_prio = K_LOWEST_THREAD_PRIO, \
_OBJECT_TRACING_INIT \
}
/**
@ -2751,8 +2726,6 @@ struct k_sem {
_POLL_EVENT;
_OBJECT_TRACING_NEXT_PTR(k_sem)
_OBJECT_TRACING_LINKED_FLAG
};
#define Z_SEM_INITIALIZER(obj, initial_count, count_limit) \
@ -2761,7 +2734,6 @@ struct k_sem {
.count = initial_count, \
.limit = count_limit, \
_POLL_EVENT_OBJ_INIT(obj) \
_OBJECT_TRACING_INIT \
}
/**
@ -4164,9 +4136,6 @@ struct k_msgq {
_POLL_EVENT;
_OBJECT_TRACING_NEXT_PTR(k_msgq)
_OBJECT_TRACING_LINKED_FLAG
/** Message queue */
uint8_t flags;
};
@ -4186,7 +4155,6 @@ struct k_msgq {
.write_ptr = q_buffer, \
.used_msgs = 0, \
_POLL_EVENT_OBJ_INIT(obj) \
_OBJECT_TRACING_INIT \
}
/**
@ -4459,8 +4427,6 @@ struct k_mbox {
_wait_q_t rx_msg_queue;
struct k_spinlock lock;
_OBJECT_TRACING_NEXT_PTR(k_mbox)
_OBJECT_TRACING_LINKED_FLAG
};
/**
* @cond INTERNAL_HIDDEN
@ -4470,7 +4436,6 @@ struct k_mbox {
{ \
.tx_msg_queue = Z_WAIT_Q_INIT(&obj.tx_msg_queue), \
.rx_msg_queue = Z_WAIT_Q_INIT(&obj.rx_msg_queue), \
_OBJECT_TRACING_INIT \
}
/**
@ -4600,8 +4565,6 @@ struct k_pipe {
_wait_q_t writers; /**< Writer wait queue */
} wait_q; /** Wait queue */
_OBJECT_TRACING_NEXT_PTR(k_pipe)
_OBJECT_TRACING_LINKED_FLAG
uint8_t flags; /**< Flags */
};
@ -4622,7 +4585,6 @@ struct k_pipe {
.readers = Z_WAIT_Q_INIT(&obj.wait_q.readers), \
.writers = Z_WAIT_Q_INIT(&obj.wait_q.writers) \
}, \
_OBJECT_TRACING_INIT \
.flags = 0 \
}
@ -4777,8 +4739,6 @@ struct k_mem_slab {
uint32_t max_used;
#endif
_OBJECT_TRACING_NEXT_PTR(k_mem_slab)
_OBJECT_TRACING_LINKED_FLAG
};
#define Z_MEM_SLAB_INITIALIZER(obj, slab_buffer, slab_block_size, \
@ -4791,7 +4751,6 @@ struct k_mem_slab {
.buffer = slab_buffer, \
.free_list = NULL, \
.num_used = 0, \
_OBJECT_TRACING_INIT \
}

19
kernel/mailbox.c
View file

@ -10,7 +10,7 @@
#include <kernel.h>
#include <kernel_structs.h>
#include <debug/object_tracing_common.h>
#include <toolchain.h>
#include <linker/sections.h>
#include <string.h>
@ -44,12 +44,7 @@ static inline void mbox_async_free(struct k_mbox_async *async)
#endif /* CONFIG_NUM_MBOX_ASYNC_MSGS > 0 */
#ifdef CONFIG_OBJECT_TRACING
struct k_mbox *_trace_list_k_mbox;
#endif /* CONFIG_OBJECT_TRACING */
#if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0) || \
defined(CONFIG_OBJECT_TRACING)
#if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
/*
* Do run-time initialization of mailbox object subsystem.
@ -84,18 +79,12 @@ static int init_mbox_module(const struct device *dev)
/* Complete initialization of statically defined mailboxes. */
#ifdef CONFIG_OBJECT_TRACING
Z_STRUCT_SECTION_FOREACH(k_mbox, mbox) {
SYS_TRACING_OBJ_INIT(k_mbox, mbox);
}
#endif /* CONFIG_OBJECT_TRACING */
return 0;
}
SYS_INIT(init_mbox_module, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
#endif /* CONFIG_NUM_MBOX_ASYNC_MSGS or CONFIG_OBJECT_TRACING */
#endif /* CONFIG_NUM_MBOX_ASYNC_MSGS */
void k_mbox_init(struct k_mbox *mbox)
{
@ -104,8 +93,6 @@ void k_mbox_init(struct k_mbox *mbox)
mbox->lock = (struct k_spinlock) {};
SYS_PORT_TRACING_OBJ_INIT(k_mbox, mbox);
SYS_TRACING_OBJ_INIT(k_mbox, mbox);
}
/**

12
kernel/mem_slab.c
View file

@ -6,7 +6,7 @@
#include <kernel.h>
#include <kernel_structs.h>
#include <debug/object_tracing_common.h>
#include <toolchain.h>
#include <linker/sections.h>
#include <wait_q.h>
@ -15,10 +15,6 @@
#include <init.h>
#include <sys/check.h>
#ifdef CONFIG_OBJECT_TRACING
struct k_mem_slab *_trace_list_k_mem_slab;
#endif /* CONFIG_OBJECT_TRACING */
/**
* @brief Initialize kernel memory slab subsystem.
*
@ -66,7 +62,6 @@ static int init_mem_slab_module(const struct device *dev)
if (rc < 0) {
goto out;
}
SYS_TRACING_OBJ_INIT(k_mem_slab, slab);
z_object_init(slab);
}
@ -96,12 +91,9 @@ int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
if (rc < 0) {
goto out;
}
z_waitq_init(&slab->wait_q);
SYS_TRACING_OBJ_INIT(k_mem_slab, slab);
z_object_init(slab);
out:
SYS_PORT_TRACING_OBJ_INIT(k_mem_slab, slab, rc);

25
kernel/msg_q.c
View file

@ -12,7 +12,7 @@
#include <kernel.h>
#include <kernel_structs.h>
#include <debug/object_tracing_common.h>
#include <toolchain.h>
#include <linker/sections.h>
#include <string.h>
@ -25,27 +25,6 @@
#include <kernel_internal.h>
#include <sys/check.h>
#ifdef CONFIG_OBJECT_TRACING
struct k_msgq *_trace_list_k_msgq;
/*
* Complete initialization of statically defined message queues.
*/
static int init_msgq_module(const struct device *dev)
{
ARG_UNUSED(dev);
Z_STRUCT_SECTION_FOREACH(k_msgq, msgq) {
SYS_TRACING_OBJ_INIT(k_msgq, msgq);
}
return 0;
}
SYS_INIT(init_msgq_module, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
#endif /* CONFIG_OBJECT_TRACING */
#ifdef CONFIG_POLL
static inline void handle_poll_events(struct k_msgq *msgq, uint32_t state)
{
@ -72,8 +51,6 @@ void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
SYS_PORT_TRACING_OBJ_INIT(k_msgq, msgq);
SYS_TRACING_OBJ_INIT(k_msgq, msgq);
z_object_init(msgq);
}

23
kernel/mutex.c
View file

@ -34,7 +34,6 @@
#include <errno.h>
#include <init.h>
#include <syscall_handler.h>
#include <debug/object_tracing_common.h>
#include <tracing/tracing.h>
#include <sys/check.h>
#include <logging/log.h>
@ -47,27 +46,6 @@ LOG_MODULE_DECLARE(os, CONFIG_KERNEL_LOG_LEVEL);
*/
static struct k_spinlock lock;
#ifdef CONFIG_OBJECT_TRACING
struct k_mutex *_trace_list_k_mutex;
/*
* Complete initialization of statically defined mutexes.
*/
static int init_mutex_module(const struct device *dev)
{
ARG_UNUSED(dev);
Z_STRUCT_SECTION_FOREACH(k_mutex, mutex) {
SYS_TRACING_OBJ_INIT(k_mutex, mutex);
}
return 0;
}
SYS_INIT(init_mutex_module, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
#endif /* CONFIG_OBJECT_TRACING */
int z_impl_k_mutex_init(struct k_mutex *mutex)
{
mutex->owner = NULL;
@ -75,7 +53,6 @@ int z_impl_k_mutex_init(struct k_mutex *mutex)
z_waitq_init(&mutex->wait_q);
SYS_TRACING_OBJ_INIT(k_mutex, mutex);
z_object_init(mutex);
SYS_PORT_TRACING_OBJ_INIT(k_mutex, mutex, 0);

19
kernel/pipes.c
View file

@ -12,7 +12,7 @@
#include <kernel.h>
#include <kernel_structs.h>
#include <debug/object_tracing_common.h>
#include <toolchain.h>
#include <ksched.h>
#include <wait_q.h>
@ -36,17 +36,12 @@ struct k_pipe_async {
struct k_pipe_desc desc; /* Pipe message descriptor */
};
#ifdef CONFIG_OBJECT_TRACING
struct k_pipe *_trace_list_k_pipe;
#endif /* CONFIG_OBJECT_TRACING */
#if (CONFIG_NUM_PIPE_ASYNC_MSGS > 0)
/* stack of unused asynchronous message descriptors */
K_STACK_DEFINE(pipe_async_msgs, CONFIG_NUM_PIPE_ASYNC_MSGS);
#endif /* CONFIG_NUM_PIPE_ASYNC_MSGS > 0 */
#if (CONFIG_NUM_PIPE_ASYNC_MSGS > 0) || \
defined(CONFIG_OBJECT_TRACING)
#if (CONFIG_NUM_PIPE_ASYNC_MSGS > 0)
/*
* Do run-time initialization of pipe object subsystem.
@ -83,18 +78,12 @@ static int init_pipes_module(const struct device *dev)
/* Complete initialization of statically defined mailboxes. */
#ifdef CONFIG_OBJECT_TRACING
Z_STRUCT_SECTION_FOREACH(k_pipe, pipe) {
SYS_TRACING_OBJ_INIT(k_pipe, pipe);
}
#endif /* CONFIG_OBJECT_TRACING */
return 0;
}
SYS_INIT(init_pipes_module, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
#endif /* CONFIG_NUM_PIPE_ASYNC_MSGS or CONFIG_OBJECT_TRACING */
#endif /* CONFIG_NUM_PIPE_ASYNC_MSGS */
void k_pipe_init(struct k_pipe *pipe, unsigned char *buffer, size_t size)
{
@ -106,10 +95,8 @@ void k_pipe_init(struct k_pipe *pipe, unsigned char *buffer, size_t size)
pipe->lock = (struct k_spinlock){};
z_waitq_init(&pipe->wait_q.writers);
z_waitq_init(&pipe->wait_q.readers);
SYS_PORT_TRACING_OBJ_INIT(k_pipe, pipe);
SYS_TRACING_OBJ_INIT(k_pipe, pipe);
pipe->flags = 0;
z_object_init(pipe);
}

24
kernel/queue.c
View file

@ -13,7 +13,7 @@
#include <kernel.h>
#include <kernel_structs.h>
#include <debug/object_tracing_common.h>
#include <toolchain.h>
#include <wait_q.h>
#include <ksched.h>
@ -55,27 +55,6 @@ void *z_queue_node_peek(sys_sfnode_t *node, bool needs_free)
return ret;
}
#ifdef CONFIG_OBJECT_TRACING
struct k_queue *_trace_list_k_queue;
/*
* Complete initialization of statically defined queues.
*/
static int init_queue_module(const struct device *dev)
{
ARG_UNUSED(dev);
Z_STRUCT_SECTION_FOREACH(k_queue, queue) {
SYS_TRACING_OBJ_INIT(k_queue, queue);
}
return 0;
}
SYS_INIT(init_queue_module, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
#endif /* CONFIG_OBJECT_TRACING */
void z_impl_k_queue_init(struct k_queue *queue)
{
sys_sflist_init(&queue->data_q);
@ -87,7 +66,6 @@ void z_impl_k_queue_init(struct k_queue *queue)
SYS_PORT_TRACING_OBJ_INIT(k_queue, queue);
SYS_TRACING_OBJ_INIT(k_queue, queue);
z_object_init(queue);
}

25
kernel/sem.c
View file

@ -19,7 +19,7 @@
#include <kernel.h>
#include <kernel_structs.h>
#include <debug/object_tracing_common.h>
#include <toolchain.h>
#include <wait_q.h>
#include <sys/dlist.h>
@ -38,27 +38,6 @@
*/
static struct k_spinlock lock;
#ifdef CONFIG_OBJECT_TRACING
struct k_sem *_trace_list_k_sem;
/*
* Complete initialization of statically defined semaphores.
*/
static int init_sem_module(const struct device *dev)
{
ARG_UNUSED(dev);
Z_STRUCT_SECTION_FOREACH(k_sem, sem) {
SYS_TRACING_OBJ_INIT(k_sem, sem);
}
return 0;
}
SYS_INIT(init_sem_module, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
#endif /* CONFIG_OBJECT_TRACING */
int z_impl_k_sem_init(struct k_sem *sem, unsigned int initial_count,
unsigned int limit)
{
@ -80,8 +59,6 @@ int z_impl_k_sem_init(struct k_sem *sem, unsigned int initial_count,
#if defined(CONFIG_POLL)
sys_dlist_init(&sem->poll_events);
#endif
SYS_TRACING_OBJ_INIT(k_sem, sem);
z_object_init(sem);
return 0;

25
kernel/stack.c
View file

@ -10,7 +10,7 @@
#include <kernel.h>
#include <kernel_structs.h>
#include <debug/object_tracing_common.h>
#include <toolchain.h>
#include <ksched.h>
#include <wait_q.h>
@ -19,27 +19,6 @@
#include <syscall_handler.h>
#include <kernel_internal.h>
#ifdef CONFIG_OBJECT_TRACING
struct k_stack *_trace_list_k_stack;
/*
* Complete initialization of statically defined stacks.
*/
static int init_stack_module(const struct device *dev)
{
ARG_UNUSED(dev);
Z_STRUCT_SECTION_FOREACH(k_stack, stack) {
SYS_TRACING_OBJ_INIT(k_stack, stack);
}
return 0;
}
SYS_INIT(init_stack_module, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
#endif /* CONFIG_OBJECT_TRACING */
void k_stack_init(struct k_stack *stack, stack_data_t *buffer,
uint32_t num_entries)
{
@ -49,8 +28,6 @@ void k_stack_init(struct k_stack *stack, stack_data_t *buffer,
stack->top = stack->base + num_entries;
SYS_PORT_TRACING_OBJ_INIT(k_stack, stack);
SYS_TRACING_OBJ_INIT(k_stack, stack);
z_object_init(stack);
}

25
kernel/timer.c
View file

@ -5,7 +5,7 @@
*/
#include <kernel.h>
#include <debug/object_tracing_common.h>
#include <init.h>
#include <ksched.h>
#include <wait_q.h>
@ -15,27 +15,6 @@
static struct k_spinlock lock;
#ifdef CONFIG_OBJECT_TRACING
struct k_timer *_trace_list_k_timer;
/*
* Complete initialization of statically defined timers.
*/
static int init_timer_module(const struct device *dev)
{
ARG_UNUSED(dev);
Z_STRUCT_SECTION_FOREACH(k_timer, timer) {
SYS_TRACING_OBJ_INIT(k_timer, timer);
}
return 0;
}
SYS_INIT(init_timer_module, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
#endif /* CONFIG_OBJECT_TRACING */
/**
* @brief Handle expiration of a kernel timer object.
*
@ -108,8 +87,6 @@ void k_timer_init(struct k_timer *timer,
SYS_PORT_TRACING_OBJ_INIT(k_timer, timer);
SYS_TRACING_OBJ_INIT(k_timer, timer);
timer->user_data = NULL;
z_object_init(timer);

2
samples/subsys/shell/shell_module/prj_minimal.conf
View file

@ -3,7 +3,7 @@ CONFIG_SHELL=y
CONFIG_SHELL_MINIMAL=y
CONFIG_SHELL_STACK_SIZE=1024
CONFIG_SHELL_BACKEND_SERIAL=y
CONFIG_OBJECT_TRACING=y
CONFIG_THREAD_MONITOR=y
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
samples/subsys/shell/shell_module/prj_minimal_rtt.conf
View file

@ -3,7 +3,7 @@ CONFIG_SHELL=y
CONFIG_SHELL_MINIMAL=y
CONFIG_SHELL_STACK_SIZE=1024
CONFIG_SHELL_BACKEND_SERIAL=n
CONFIG_OBJECT_TRACING=y
CONFIG_THREAD_MONITOR=y
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

1
scripts/kconfig/hardened.csv
View file

@ -17,7 +17,6 @@ STACK_USAGE,n
PRINTK,n
EARLY_CONSOLE,n
ASSERT,n
OBJECT_TRACING,n
OVERRIDE_FRAME_POINTER_DEFAULT,y
DEBUG_INFO,n
DEBUG_THREAD_INFO,n

1 HW_STACK_PROTECTION y
17 PRINTK n
18 EARLY_CONSOLE n
19 ASSERT n
OBJECT_TRACING n
20 OVERRIDE_FRAME_POINTER_DEFAULT y
21 DEBUG_INFO n
22 DEBUG_THREAD_INFO n

6
subsys/debug/Kconfig
View file

@ -266,12 +266,6 @@ config ASSERT_NO_MSG_INFO
before disabling file info since the message can be found in the
source using file info.
config OBJECT_TRACING
bool "Kernel object tracing"
help
This option enable the feature for tracing kernel objects. This option
is for debug purposes and increases the memory footprint of the kernel.
config OVERRIDE_FRAME_POINTER_DEFAULT
bool "Override compiler defaults for -fomit-frame-pointer"
help

1
subsys/shell/modules/kernel_service.c
View file

@ -8,7 +8,6 @@
#include <sys/printk.h>
#include <shell/shell.h>
#include <init.h>
#include <debug/object_tracing.h>
#include <sys/reboot.h>
#include <debug/stack.h>
#include <string.h>

2
tests/kernel/mbox/mbox_api/prj.conf
View file

@ -1,4 +1,4 @@
CONFIG_ZTEST=y
CONFIG_NUM_MBOX_ASYNC_MSGS=5
CONFIG_OBJECT_TRACING=y
CONFIG_MP_NUM_CPUS=1

1
tests/kernel/mem_protect/obj_validation/prj.conf
View file

@ -2,4 +2,3 @@ CONFIG_ZTEST=y
CONFIG_TEST_USERSPACE=y
CONFIG_DYNAMIC_OBJECTS=y
CONFIG_HEAP_MEM_POOL_SIZE=8192
CONFIG_OBJECT_TRACING=y

1
tests/kernel/msgq/msgq_api/prj.conf
View file

@ -1,4 +1,3 @@
CONFIG_ZTEST=y
CONFIG_IRQ_OFFLOAD=y
CONFIG_TEST_USERSPACE=y
CONFIG_OBJECT_TRACING=y

8
tests/kernel/obj_tracing/CMakeLists.txt
View file

@ -1,8 +0,0 @@
# SPDX-License-Identifier: Apache-2.0
cmake_minimum_required(VERSION 3.13.1)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(obj_tracing)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources})

46
tests/kernel/obj_tracing/README.txt
View file

@ -1,46 +0,0 @@
Test Description
----------------
The object tracing test is a sanity test to verify that the
object tracing API remains healthy.
It uses the philsophers as an application that implements
multiple threads that are synchronized with semaphores.
The application initializes their objects and starts the philosophers'
thread interaction. A specific thread, called object monitor, accesses
the object tracing API and reports the number of expected objects.
The sanity test script expects each test to finish its execution
and then it considers the test completed. For that reason the
philosophers' threads execute a finite number of iterations. After
that the application execution ends.
Sample Output
--------------
***** BOOTING ZEPHYR OS vxxxx - BUILD: yyyyy *****
Running test suite test_obj_tracing
===================================================================
starting test - test_tracing
SEMAPHORE REF: 0x004002d0
SEMAPHORE REF: 0x004002bc
SEMAPHORE REF: 0x004002a8
SEMAPHORE REF: 0x00400294
SEMAPHORE REF: 0x00400280
SEMAPHORE REF: 0x0042402c
SEMAPHORE REF: 0x00424250
SEMAPHORE QUANTITY: 6
COOP: 0x00400040 OPTIONS: 0x00, STATE: 0x00
COOP: 0x00400200 OPTIONS: 0x00, STATE: 0x02
COOP: 0x004001a8 OPTIONS: 0x00, STATE: 0x02
COOP: 0x00400150 OPTIONS: 0x00, STATE: 0x00
COOP: 0x004000f8 OPTIONS: 0x00, STATE: 0x02
COOP: 0x004000a0 OPTIONS: 0x00, STATE: 0x00
PREMPT: 0x00401254 OPTIONS: 0x00, STATE: 0x02
COOP: 0x00401020 OPTIONS: 0x01, STATE: 0x00
COOP: 0x00401080 OPTIONS: 0x01, STATE: 0x00
THREAD QUANTITY: 9
PASS - test_tracing.
===================================================================
===================================================================
PROJECT EXECUTION SUCCESSFUL

5
tests/kernel/obj_tracing/prj.conf
View file

@ -1,5 +0,0 @@
CONFIG_OBJECT_TRACING=y
CONFIG_THREAD_MONITOR=y
CONFIG_ZTEST=y
CONFIG_BT=n
CONFIG_MP_NUM_CPUS=1

189
tests/kernel/obj_tracing/src/main.c
View file

@ -1,189 +0,0 @@
/*
* Copyright (c) 2011-2016 Wind River Systems, Inc.
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr.h>
#include <ztest.h>
#include <debug/object_tracing.h>
extern void test_obj_tracing(void);
#define STSIZE (1024 + CONFIG_TEST_EXTRA_STACKSIZE)
#define N_PHILOSOPHERS 5
#define TOTAL_TEST_NUMBER 2
#define ZTEST_THREADS_CREATED 1
#define TOTAL_THREADS (N_PHILOSOPHERS + ZTEST_THREADS_CREATED)
#define TOTAL_OBJECTS (N_PHILOSOPHERS)
#define OBJ_LIST_NAME k_sem
#define OBJ_LIST_TYPE struct k_sem
#define FORK(x) (&forks[x])
#define TAKE(x) k_sem_take(x, K_FOREVER)
#define GIVE(x) k_sem_give(x)
#define RANDDELAY(x) k_msleep(10 * (x) + 1)
static int initial_count;
/* Must account for:
* N Philosopher threads
* 1 Object monitor thread
* 1 System idle thread
* 1 System workqueue thread
*/
void *force_sys_work_q_in = (void *)&k_sys_work_q;
K_THREAD_STACK_ARRAY_DEFINE(phil_stack, N_PHILOSOPHERS, STSIZE);
static struct k_thread phil_data[N_PHILOSOPHERS];
K_THREAD_STACK_DEFINE(mon_stack, STSIZE);
static struct k_thread mon_data;
struct k_sem forks[N_PHILOSOPHERS];
K_SEM_DEFINE(f3, -5, 1);
/**
* @brief Object Tracing Tests
* @defgroup kernel_objtracing_tests Object Tracing Tests
* @ingroup all_tests
* @{
* @}
*/
static inline void thread_list_cb(const struct k_thread *thread, void *data)
{
int *ctr = data;
if (thread->base.prio == -1) {
TC_PRINT("PREMPT: %p OPTIONS: 0x%02x, STATE: 0x%02x\n",
thread,
thread->base.user_options,
thread->base.thread_state);
} else {
TC_PRINT("COOP: %p OPTIONS: 0x%02x, STATE: 0x%02x\n",
thread,
thread->base.user_options,
thread->base.thread_state);
}
(*ctr)++;
}
static inline int thread_monitor(void)
{
int obj_counter = 0;
k_thread_foreach(thread_list_cb, &obj_counter);
TC_PRINT("THREAD QUANTITY: %d\n", obj_counter);
return obj_counter;
}
static void object_monitor(void)
{
int obj_counter = 0;
int thread_counter = 0, sem = 0;
void *obj_list = NULL;
k_sem_take(&f3, K_NO_WAIT);
/* ztest use one semaphore so use one count less than expected to pass
* test
*/
obj_list = SYS_TRACING_HEAD(OBJ_LIST_TYPE, OBJ_LIST_NAME);
while (obj_list != NULL) {
TC_PRINT("SEMAPHORE REF: %p\n", obj_list);
obj_list = SYS_TRACING_NEXT(OBJ_LIST_TYPE, OBJ_LIST_NAME,
obj_list);
for (sem = 0; sem < N_PHILOSOPHERS; sem++) {
if (obj_list == &forks[sem] || obj_list == &f3) {
obj_counter++;
break;
}
}
}
TC_PRINT("SEMAPHORE QUANTITY: %d\n", obj_counter);
thread_counter += thread_monitor();
zassert_true(((thread_counter == (TOTAL_THREADS + initial_count)) &&
(obj_counter == TOTAL_OBJECTS)), "test failed");
}
static void phil_entry(void)
{
int counter;
struct k_sem *f1; /* fork #1 */
struct k_sem *f2; /* fork #2 */
static int myId; /* next philosopher ID */
unsigned int pri = irq_lock(); /* interrupt lock level */
int id = myId++; /* current philosopher ID */
irq_unlock(pri);
/* always take the lowest fork first */
if ((id + 1) != N_PHILOSOPHERS) {
f1 = FORK(id);
f2 = FORK(id + 1);
} else {
f1 = FORK(0);
f2 = FORK(id);
}
for (counter = 0; counter < 5; counter++) {
TAKE(f1);
TAKE(f2);
RANDDELAY(id);
GIVE(f2);
GIVE(f1);
RANDDELAY(id);
}
GIVE(&f3);
}
/**
* @brief Trace the number of objects created
*
* @ingroup kernel_objtracing_tests
*
* @details The test uses dining philsophers problem as
* an application that implements multiple threads that
* are synchronized with semaphores.
*/
void test_philosophers_tracing(void)
{
int i;
for (i = 0; i < N_PHILOSOPHERS; i++) {
k_sem_init(&forks[i], 1, 1);
}
/* create philosopher threads */
for (i = 0; i < N_PHILOSOPHERS; i++) {
k_thread_create(&phil_data[i], &phil_stack[i][0], STSIZE,
(k_thread_entry_t)phil_entry, NULL, NULL, NULL,
K_PRIO_COOP(6), 0, K_NO_WAIT);
}
/* create object counter monitor thread */
k_thread_create(&mon_data, mon_stack, STSIZE,
(k_thread_entry_t)object_monitor, NULL, NULL, NULL,
K_PRIO_COOP(7), 0, K_NO_WAIT);
}
void test_main(void)
{
initial_count = thread_monitor();
ztest_test_suite(obj_tracing,
ztest_unit_test(test_philosophers_tracing),
ztest_unit_test(test_obj_tracing));
ztest_run_test_suite(obj_tracing);
}

203
tests/kernel/obj_tracing/src/trace_obj.c
View file

@ -1,203 +0,0 @@
/*
* Copyright (c) 2018 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr.h>
#include <ztest.h>
#include <debug/object_tracing.h>
enum obj_name {
TIMER,
MEM_SLAB,
SEM,
MUTEX,
STACK,
MSGQ,
MBOX,
PIPE,
QUEUE
};
static inline void expiry_dummy_fn(struct k_timer *timer)
{
ARG_UNUSED(timer);
}
static inline void stop_dummy_fn(struct k_timer *timer)
{
ARG_UNUSED(timer);
}
K_TIMER_DEFINE(ktimer, expiry_dummy_fn, stop_dummy_fn);
K_MEM_SLAB_DEFINE(kmslab, 8, 2, 8);
K_SEM_DEFINE(ksema, 0, 1);
K_MUTEX_DEFINE(kmutex);
K_STACK_DEFINE(kstack, 512);
K_MSGQ_DEFINE(kmsgq, 4, 2, 4);
K_MBOX_DEFINE(kmbox);
K_PIPE_DEFINE(kpipe, 256, 4);
K_QUEUE_DEFINE(kqueue);
static struct k_timer timer;
static struct k_mem_slab mslab;
static struct k_sem sema;
static struct k_mutex mutex;
static struct k_stack stack;
static struct k_msgq msgq;
static struct k_mbox mbox;
static struct k_pipe pipe;
static struct k_queue queue;
#define BLOCK_SIZE 8
#define NUM_BLOCKS 4
static char __aligned(8) slab[BLOCK_SIZE * NUM_BLOCKS];
static stack_data_t sdata[BLOCK_SIZE * NUM_BLOCKS];
static char buffer[BLOCK_SIZE * NUM_BLOCKS];
static char data[] = "test";
static void get_obj_count(int obj_type)
{
void *obj_list;
int obj_found = 0;
switch (obj_type) {
case TIMER:
k_timer_init(&timer, expiry_dummy_fn, stop_dummy_fn);
obj_list = SYS_TRACING_HEAD(struct k_timer, k_timer);
while (obj_list != NULL) {
/* TESTPOINT: Check if the object created
* is added to the list
*/
if (obj_list == &ktimer || obj_list == &timer) {
obj_found++;
}
obj_list = SYS_TRACING_NEXT(struct k_timer, k_timer,
obj_list);
}
zassert_equal(obj_found, 2, "Didn't find timer objects");
break;
case MEM_SLAB:
k_mem_slab_init(&mslab, slab, BLOCK_SIZE, NUM_BLOCKS);
obj_list = SYS_TRACING_HEAD(struct k_mem_slab, k_mem_slab);
while (obj_list != NULL) {
if (obj_list == &kmslab || obj_list == &mslab) {
obj_found++;
}
obj_list = SYS_TRACING_NEXT(struct k_mem_slab,
k_mem_slab, obj_list);
}
zassert_equal(obj_found, 2, "Didn't find mem_slab objects");
break;
case SEM:
k_sem_init(&sema, 0, 1);
obj_list = SYS_TRACING_HEAD(struct k_sem, k_sem);
while (obj_list != NULL) {
if (obj_list == &ksema || obj_list == &sema) {
obj_found++;
}
obj_list = SYS_TRACING_NEXT(struct k_sem, k_sem,
obj_list);
}
zassert_equal(obj_found, 2, "Didn't find semaphore objects");
break;
case MUTEX:
k_mutex_init(&mutex);
obj_list = SYS_TRACING_HEAD(struct k_mutex, k_mutex);
while (obj_list != NULL) {
if (obj_list == &kmutex || obj_list == &mutex) {
obj_found++;
}
obj_list = SYS_TRACING_NEXT(struct k_mutex, k_mutex,
obj_list);
}
zassert_equal(obj_found, 2, "Didn't find mutex objects");
break;
case STACK:
k_stack_init(&stack, sdata, NUM_BLOCKS);
obj_list = SYS_TRACING_HEAD(struct k_stack, k_stack);
while (obj_list != NULL) {
if (obj_list == &kstack || obj_list == &stack) {
obj_found++;
}
obj_list = SYS_TRACING_NEXT(struct k_stack, k_stack,
obj_list);
}
zassert_equal(obj_found, 2, "Didn't find stack objects");
break;
case MSGQ:
k_msgq_init(&msgq, buffer, BLOCK_SIZE, NUM_BLOCKS);
obj_list = SYS_TRACING_HEAD(struct k_msgq, k_msgq);
while (obj_list != NULL) {
if (obj_list == &kmsgq || obj_list == &msgq) {
obj_found++;
}
obj_list = SYS_TRACING_NEXT(struct k_msgq, k_msgq,
obj_list);
}
zassert_equal(obj_found, 2, "Didn't find msgq objects");
break;
case MBOX:
k_mbox_init(&mbox);
obj_list = SYS_TRACING_HEAD(struct k_mbox, k_mbox);
while (obj_list != NULL) {
if (obj_list == &kmbox || obj_list == &mbox) {
obj_found++;
}
obj_list = SYS_TRACING_NEXT(struct k_mbox, k_mbox,
obj_list);
}
zassert_equal(obj_found, 2, "Didn't find mbox objects");
break;
case PIPE:
k_pipe_init(&pipe, data, 8);
obj_list = SYS_TRACING_HEAD(struct k_pipe, k_pipe);
while (obj_list != NULL) {
if (obj_list == &kpipe || obj_list == &pipe) {
obj_found++;
}
obj_list = SYS_TRACING_NEXT(struct k_pipe, k_pipe,
obj_list);
}
zassert_equal(obj_found, 2, "Didn't find pipe objects");
break;
case QUEUE:
k_queue_init(&queue);
obj_list = SYS_TRACING_HEAD(struct k_queue, k_queue);
while (obj_list != NULL) {
if (obj_list == &kqueue || obj_list == &queue) {
obj_found++;
}
obj_list = SYS_TRACING_NEXT(struct k_queue, k_queue,
obj_list);
}
zassert_equal(obj_found, 2, "Didn't find queue objects\n");
break;
default:
zassert_unreachable("Undefined kernel object");
}
}
/**
* @brief Verify tracing of kernel objects
* @details Statically create kernel objects and check if they are added to
* trace object list with object tracing enabled.
* @ingroup kernel_objtracing_tests
* @see SYS_TRACING_HEAD(), SYS_TRACING_NEXT()
*/
void test_obj_tracing(void)
{
for (int i = TIMER; i < QUEUE; i++) {
get_obj_count(i);
}
}

3
tests/kernel/obj_tracing/testcase.yaml
View file

@ -1,3 +0,0 @@
tests:
kernel.objects.tracing:
tags: kernel

5
tests/subsys/shell/shell/shell_min.conf
View file

@ -1,19 +1,14 @@
CONFIG_ZTEST=y
CONFIG_TEST_LOGGING_DEFAULTS=n
CONFIG_SHELL=y
CONFIG_SHELL_MINIMAL=y
CONFIG_SHELL_BACKEND_DUMMY=y
CONFIG_SHELL_BACKEND_SERIAL=n
CONFIG_THREAD_NAME=y
CONFIG_SHELL_STACK_SIZE=2048
#using CBPRINTF_NANO decreases signigicantly Flash usage.
CONFIG_CBPRINTF_NANO=y
CONFIG_LOG=n
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

3
tests/subsys/shell/shell/shell_min_cmds.conf
View file

@ -1,6 +1,5 @@
CONFIG_ZTEST=y
CONFIG_TEST_LOGGING_DEFAULTS=n
CONFIG_SHELL=y
CONFIG_SHELL_MINIMAL=y
CONFIG_SHELL_BACKEND_DUMMY=y
@ -15,7 +14,7 @@ CONFIG_LOG=n
#Shell features:
CONFIG_SHELL_CMDS=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_cmds_all.conf
View file

@ -17,7 +17,7 @@ CONFIG_SHELL_CMDS=y
CONFIG_SHELL_CMDS_RESIZE=y
CONFIG_SHELL_CMDS_SELECT=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_cmds_resize.conf
View file

@ -16,7 +16,7 @@ CONFIG_LOG=n
CONFIG_SHELL_CMDS=y
CONFIG_SHELL_CMDS_RESIZE=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_cmds_select.conf
View file

@ -16,7 +16,7 @@ CONFIG_LOG=n
CONFIG_SHELL_CMDS=y
CONFIG_SHELL_CMDS_SELECT=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_colors.conf
View file

@ -15,7 +15,7 @@ CONFIG_LOG=n
#Shell features:
CONFIG_SHELL_VT100_COLORS=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_help.conf
View file

@ -15,7 +15,7 @@ CONFIG_LOG=n
#Shell features:
CONFIG_SHELL_HELP=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_help_all.conf
View file

@ -17,7 +17,7 @@ CONFIG_LOG=n
CONFIG_SHELL_HELP=y
CONFIG_SHELL_HELP_ON_WRONG_ARGUMENT_COUNT=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_history.conf
View file

@ -16,7 +16,7 @@ CONFIG_LOG=n
CONFIG_SHELL_HISTORY=y
CONFIG_SHELL_HISTORY_BUFFER=128
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_log_backend.conf
View file

@ -15,7 +15,7 @@ CONFIG_LOG=y
#Shell features:
CONFIG_SHELL_LOG_BACKEND=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_metakeys.conf
View file

@ -15,7 +15,7 @@ CONFIG_LOG=n
#Shell features:
CONFIG_SHELL_METAKEYS=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_tab.conf
View file

@ -15,7 +15,7 @@ CONFIG_LOG=n
#Shell features:
CONFIG_SHELL_TAB=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_tab_auto.conf
View file

@ -16,7 +16,7 @@ CONFIG_LOG=n
CONFIG_SHELL_TAB=y
CONFIG_SHELL_TAB_AUTOCOMPLETION=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n

2
tests/subsys/shell/shell/shell_min_wildcards.conf
View file

@ -15,7 +15,7 @@ CONFIG_LOG=n
#Shell features:
CONFIG_SHELL_WILDCARD=y
CONFIG_OBJECT_TRACING=n
CONFIG_THREAD_MONITOR=n
CONFIG_INIT_STACKS=y
CONFIG_BOOT_BANNER=n