michaelh/zephyr
1
0
Fork 0
Code Releases Activity

kernel: event_logger: remove kernel_event_logger

Browse source 
Move to more generic tracing hooks that can be implemented in different
ways and do not interfere with the kernel.

Signed-off-by: Anas Nashif <anas.nashif@intel.com>
This commit is contained in:
Anas Nashif 2018-04-06 07:48:53 -04:00
commit a2248782a2
39 changed files with 75 additions and 1134 deletions
Download patch file Download diff file Expand all files Collapse all files

339
include/logging/kernel_event_logger.h
View file

@ -1,339 +0,0 @@
/*
* Copyright (c) 2015 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief Kernel event logger support.
*/
#include <logging/event_logger.h>
#ifndef __KERNEL_EVENT_LOGGER_H__
#define __KERNEL_EVENT_LOGGER_H__
#ifdef __cplusplus
extern "C" {
#endif
/* predefined event types */
#define KERNEL_EVENT_LOGGER_CONTEXT_SWITCH_EVENT_ID BIT(0)
#define KERNEL_EVENT_LOGGER_INTERRUPT_EVENT_ID BIT(1)
#define KERNEL_EVENT_LOGGER_SLEEP_EVENT_ID BIT(2)
#define KERNEL_EVENT_LOGGER_THREAD_EVENT_ID BIT(3)
#ifndef _ASMLANGUAGE
extern struct event_logger sys_k_event_logger;
extern int _sys_k_event_logger_mask;
#ifdef CONFIG_KERNEL_EVENT_LOGGER_SLEEP
extern void _sys_k_event_logger_enter_sleep(void);
extern void _sys_k_event_logger_exit_sleep(void);
#else
static inline void _sys_k_event_logger_enter_sleep(void) {}
static inline void _sys_k_event_logger_exit_sleep(void) {}
#endif
#ifdef CONFIG_KERNEL_EVENT_LOGGER_INTERRUPT
extern void _sys_k_event_logger_interrupt(void);
#else
static inline void _sys_k_event_logger_interrupt(void) {}
#endif
#ifdef CONFIG_KERNEL_EVENT_LOGGER_THREAD
#include <kernel.h>
enum sys_k_event_logger_thread_event {
KERNEL_LOG_THREAD_EVENT_READYQ,
KERNEL_LOG_THREAD_EVENT_PEND,
KERNEL_LOG_THREAD_EVENT_EXIT,
};
extern void _sys_k_event_logger_thread_ready(struct k_thread *thread);
extern void _sys_k_event_logger_thread_pend(struct k_thread *thread);
extern void _sys_k_event_logger_thread_exit(struct k_thread *thread);
#else
static inline void _sys_k_event_logger_thread_create(void *thread) {}
static inline void _sys_k_event_logger_thread_ready(void *thread) {}
static inline void _sys_k_event_logger_thread_pend(void *thread) {}
static inline void _sys_k_event_logger_thread_exit(void *thread) {}
#endif
/**
* @brief Kernel Event Logger
* @defgroup kernel_event_logger Kernel Event Logger
* @{
*/
/**
* @typedef sys_k_timer_func_t
* @brief Event timestamp generator function type.
*
* A timestamp generator function is executed when the kernel event logger
* generates an event containing a timestamp.
*
* @return Timestamp value (application-defined).
*/
typedef u32_t (*sys_k_timer_func_t)(void);
/**
* @cond INTERNAL_HIDDEN
*/
#ifdef CONFIG_KERNEL_EVENT_LOGGER_CUSTOM_TIMESTAMP
extern sys_k_timer_func_t _sys_k_get_time;
#else
#define _sys_k_get_time k_cycle_get_32
#endif /* CONFIG_KERNEL_EVENT_LOGGER_CUSTOM_TIMESTAMP */
/**
* INTERNAL_HIDDEN @endcond
*/
/**
* @brief Set kernel event logger timestamp function.
*
* This routine instructs the kernel event logger to call @a func
* whenever it needs to generate an event timestamp. By default,
* the kernel's hardware timer is used.
*
* @note
* On some boards the hardware timer is not a pure hardware up counter,
* which can lead to timestamp errors. For example, boards using the LOAPIC
* timer can run it in periodic mode, which requires software to update
* a count of accumulated cycles each time the timer hardware resets itself
* to zero. This can result in an incorrect timestamp being generated
* if it occurs after the timer hardware has reset but before the timer ISR
* has updated accumulated cycle count.
*
* @param func Address of timestamp function to be used.
*
* @return N/A
*/
#ifdef CONFIG_KERNEL_EVENT_LOGGER_CUSTOM_TIMESTAMP
static inline void sys_k_event_logger_set_timer(sys_k_timer_func_t func)
{
_sys_k_get_time = func;
}
#endif /* CONFIG_KERNEL_EVENT_LOGGER_CUSTOM_TIMESTAMP */
/**
* @brief Set kernel event logger filtering mask.
*
* This routine specifies which events are recorded by the kernel event logger.
* It can only be used when dynamic event logging has been configured.
*
* Each mask bit corresponds to a kernel event type. The least significant
* mask bit corresponds to event type 1, the next bit to event type 2,
* and so on.
*
* @param value Bitmask indicating events to be recorded.
*
* @return N/A
*/
#ifdef CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC
static inline void sys_k_event_logger_set_mask(int value)
{
_sys_k_event_logger_mask = value;
}
#endif /* CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC */
/**
* @brief Get kernel event logger filtering mask.
*
* This routine indicates which events are currently being recorded by
* the kernel event logger. It can only be used when dynamic event logging
* has been configured. By default, no events are recorded.
*
* @return Bitmask indicating events that are being recorded.
*/
#ifdef CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC
static inline int sys_k_event_logger_get_mask(void)
{
return _sys_k_event_logger_mask;
}
#endif /* CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC */
/**
* @brief Indicate if an event type is currently being recorded.
*
* This routine indicates if event type @a event_type should be recorded
* by the kernel event logger when the event occurs. The routine should be
* used by code that writes an event to the kernel event logger to ensure
* that only events of interest to the application are recorded.
*
* @param event_type Event ID.
*
* @return 1 if event should be recorded, or 0 if not.
*
*/
static inline int sys_k_must_log_event(int event_type)
{
#ifdef CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC
return !!(_sys_k_event_logger_mask & event_type);
#else
ARG_UNUSED(event_type);
return 1;
#endif
}
/**
* @brief Write an event to the kernel event logger.
*
* This routine writes an event message to the kernel event logger.
*
* @param event_id Event ID.
* @param event_data Address of event data.
* @param data_size Size of event data (number of 32-bit words).
*
* @return N/A
*/
static inline void sys_k_event_logger_put(u16_t event_id,
u32_t *event_data,
u8_t data_size)
{
#ifdef CONFIG_KERNEL_EVENT_LOGGER
sys_event_logger_put(&sys_k_event_logger, event_id,
event_data, data_size);
#else
ARG_UNUSED(event_id);
ARG_UNUSED(event_data);
ARG_UNUSED(data_size);
#endif /* CONFIG_KERNEL_EVENT_LOGGER */
};
/**
* @brief Write an event to the kernel event logger (with timestamp only).
*
* This routine writes an event message to the kernel event logger.
* The event records a single 32-bit word containing a timestamp.
*
* @param event_id Event ID.
*
* @return N/A
*/
#ifdef CONFIG_KERNEL_EVENT_LOGGER
extern void sys_k_event_logger_put_timed(u16_t event_id);
#else
static inline void sys_k_event_logger_put_timed(u16_t event_id)
{
ARG_UNUSED(event_id);
};
#endif /* CONFIG_KERNEL_EVENT_LOGGER */
/**
* @brief Retrieves a kernel event message, or returns without waiting.
*
* This routine retrieves the next recorded event from the kernel event logger,
* or returns immediately if no such event exists.
*
* @param event_id Area to store event type ID.
* @param dropped Area to store number of events that were dropped between
* the previous event and the retrieved event.
* @param event_data Buffer to store event data.
* @param data_size Size of event data buffer (number of 32-bit words).
*
* @retval positive_integer Number of event data words retrieved;
* @a event_id, @a dropped, and @a buffer have been updated.
* @retval 0 Returned without waiting; no event was retrieved.
* @retval -EMSGSIZE Buffer too small; @a data_size now indicates
* the size of the event to be retrieved.
*/
#ifdef CONFIG_KERNEL_EVENT_LOGGER
static inline int sys_k_event_logger_get(u16_t *event_id, u8_t *dropped,
u32_t *event_data, u8_t *data_size)
{
return sys_event_logger_get(&sys_k_event_logger, event_id, dropped,
event_data, data_size);
}
#endif /* CONFIG_KERNEL_EVENT_LOGGER */
/**
* @brief Retrieves a kernel event message.
*
* This routine retrieves the next recorded event from the kernel event logger.
* If there is no such event the caller pends until it is available.
*
* @param event_id Area to store event type ID.
* @param dropped Area to store number of events that were dropped between
* the previous event and the retrieved event.
* @param event_data Buffer to store event data.
* @param data_size Size of event data buffer (number of 32-bit words).
*
* @retval positive_integer Number of event data words retrieved;
* @a event_id, @a dropped, and @a buffer have been updated.
* @retval -EMSGSIZE Buffer too small; @a data_size now indicates
* the size of the event to be retrieved.
*/
#ifdef CONFIG_KERNEL_EVENT_LOGGER
static inline int sys_k_event_logger_get_wait(u16_t *event_id,
u8_t *dropped, u32_t *event_data, u8_t *data_size)
{
return sys_event_logger_get_wait(&sys_k_event_logger, event_id, dropped,
event_data, data_size);
}
#endif /* CONFIG_KERNEL_EVENT_LOGGER */
/**
* @brief Retrieves a kernel event message, or waits for a specified time.
*
* This routine retrieves the next recorded event from the kernel event logger.
* If there is no such event the caller pends until it is available or until
* the specified timeout expires.
*
* @param event_id Area to store event type ID.
* @param dropped Area to store number of events that were dropped between
* the previous event and the retrieved event.
* @param event_data Buffer to store event data.
* @param data_size Size of event data buffer (number of 32-bit words).
* @param timeout Timeout in system clock ticks.
*
* @retval positive_integer Number of event data words retrieved;
* @a event_id, @a dropped, and @a buffer have been updated.
* @retval 0 Waiting period timed out; no event was retrieved.
* @retval -EMSGSIZE Buffer too small; @a data_size now indicates
* the size of the event to be retrieved.
*/
#if defined(CONFIG_KERNEL_EVENT_LOGGER)
static inline int sys_k_event_logger_get_wait_timeout(u16_t *event_id,
u8_t *dropped, u32_t *event_data,
u8_t *data_size, u32_t timeout)
{
return sys_event_logger_get_wait_timeout(&sys_k_event_logger, event_id,
dropped, event_data,
data_size, timeout);
}
#endif /* CONFIG_KERNEL_EVENT_LOGGER */
/**
* @brief Register thread that retrieves kernel events.
*
* This routine instructs the kernel event logger not to record context
* switch events for the calling thread. It is typically called by the thread
* that retrieves events from the kernel event logger.
*
* @return N/A
*/
#ifdef CONFIG_KERNEL_EVENT_LOGGER_CONTEXT_SWITCH
void sys_k_event_logger_register_as_collector(void);
#else
static inline void sys_k_event_logger_register_as_collector(void) {};
#endif
/**
* @} end defgroup kernel_event_logger
*/
#endif /* _ASMLANGUAGE */
#ifdef __cplusplus
}
#endif
#endif /* __KERNEL_EVENT_LOGGER_H__ */