| /* |
| * Copyright (c) 2015 Intel Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @file |
| * @brief Kernel event logger support. |
| */ |
| |
| |
| #include <misc/event_logger.h> |
| |
| #ifndef __KERNEL_EVENT_LOGGER_H__ |
| #define __KERNEL_EVENT_LOGGER_H__ |
| |
| /** |
| * @brief Kernel Event Logger |
| * @defgroup nanokernel_event_logger Kernel Event Logger |
| * @{ |
| */ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_CONTEXT_SWITCH |
| #define KERNEL_EVENT_LOGGER_CONTEXT_SWITCH_EVENT_ID 0x0001 |
| #endif |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_INTERRUPT |
| #define KERNEL_EVENT_LOGGER_INTERRUPT_EVENT_ID 0x0002 |
| #endif |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_SLEEP |
| #define KERNEL_EVENT_LOGGER_SLEEP_EVENT_ID 0x0003 |
| #endif |
| |
| #ifdef CONFIG_TASK_MONITOR |
| #define KERNEL_EVENT_LOGGER_TASK_MON_TASK_STATE_CHANGE_EVENT_ID 0x0004 |
| #define KERNEL_EVENT_LOGGER_TASK_MON_CMD_PACKET_EVENT_ID 0x0005 |
| #define KERNEL_EVENT_LOGGER_TASK_MON_KEVENT_EVENT_ID 0x0006 |
| #endif |
| |
| #ifndef _ASMLANGUAGE |
| |
| /** |
| * Global variable of the ring buffer that allows user to implement |
| * their own reading routine. |
| */ |
| struct event_logger sys_k_event_logger; |
| |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_CUSTOM_TIMESTAMP |
| |
| /** |
| * Callback used to set event timestamp |
| */ |
| typedef uint32_t (*sys_k_timer_func)(void); |
| extern sys_k_timer_func timer_func; |
| |
| static inline uint32_t _sys_k_get_time(void) |
| { |
| if (timer_func) |
| return timer_func(); |
| else |
| return sys_cycle_get_32(); |
| } |
| |
| /** |
| * @brief Set kernel event logger timestamp function |
| * |
| * @details Calling this function permits to set the function |
| * to be called by kernel event logger for setting the event |
| * timestamp. By default, kernel event logger is using the |
| * system timer. But on some platforms where the timer driver |
| * maintains the system timer cycle accumulator in software, |
| * such as ones using the LOAPIC timer, the system timer behavior |
| * leads to timestamp errors. For example, the timer interrupt is |
| * logged with a wrong timestamp since the HW timer value has been |
| * reset (periodic mode) but accumulated value not updated yet |
| * (done later in the ISR). |
| * |
| * @param func Pointer to a function returning a 32-bit timer |
| * Prototype: uint32_t (*func)(void) |
| */ |
| void sys_k_event_logger_set_timer(sys_k_timer_func func); |
| #else |
| static inline uint32_t _sys_k_get_time(void) |
| { |
| return sys_cycle_get_32(); |
| } |
| #endif |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC |
| |
| extern int _sys_k_event_logger_mask; |
| |
| /** |
| * @brief Set kernel event logger filtering mask |
| * |
| * @details Calling this macro sets the mask used to select which events |
| * to store in the kernel event logger ring buffer. This flag can be set |
| * at runtime and at any moment. |
| * This capability is only available when CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC |
| * is set. If enabled, no event is enabled for logging at initialization. |
| * The mask bits shall be set according to events ID defined in |
| * kernel_event_logger.h |
| * For example, to enable interrupt logging the following shall be done: |
| * sys_k_event_logger_set_mask(sys_k_event_logger_get_mask | |
| * (1 << (KERNEL_EVENT_LOGGER_INTERRUPT_EVENT_ID - 1))) |
| * To disable it: |
| * sys_k_event_logger_set_mask(sys_k_event_logger_get_mask & |
| * ~(1 << (KERNEL_EVENT_LOGGER_INTERRUPT_EVENT_ID - 1))) |
| * |
| * WARNING: task monitor events are not covered by this API. Please refer |
| * to sys_k_event_logger_set_monitor_mask / sys_k_event_logger_get_monitor_mask |
| */ |
| static inline void sys_k_event_logger_set_mask(int value) |
| { |
| _sys_k_event_logger_mask = value; |
| } |
| |
| /** |
| * @brief Get kernel event logger filtering mask |
| * |
| * @details Calling this macro permits to read the mask used to select which |
| * events are stored in the kernel event logger ring buffer. This macro can be |
| * used at runtime and at any moment. |
| * This capability is only available when CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC |
| * is set. If enabled, no event is enabled for logging at initialization. |
| * |
| * @see sys_k_event_logger_set_mask(value) for details |
| * |
| * WARNING: task monitor events are not covered by this API. Please refer |
| * to sys_k_event_logger_set_monitor_mask / sys_k_event_logger_get_monitor_mask |
| */ |
| static inline int sys_k_event_logger_get_mask(void) |
| { |
| return _sys_k_event_logger_mask; |
| } |
| |
| #ifdef CONFIG_TASK_MONITOR |
| |
| extern int _k_monitor_mask; |
| |
| /** |
| * @brief Set task monitor filtering mask |
| * |
| * @details Calling this function sets the mask used to select which task monitor |
| * events to store in the kernel event logger ring buffer. This flag can be set |
| * at runtime and at any moment. |
| * This capability is only available when CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC |
| * is set. If enabled, no event is enabled for logging at initialization |
| * so CONFIG_TASK_MONITOR_MASK is ignored |
| * |
| * The mask bits shall be set according to monitor events defined in |
| * micro_private.h |
| * |
| * For example, to enable k_swapper cmd logging the following shall be done: |
| * sys_k_event_logger_set_monitor_mask(sys_k_event_logger_get_monitor_mask | |
| * (1 << (MON_KSERV - 1))) |
| * To disable it: |
| * sys_k_event_logger_set_mask(sys_k_event_logger_get_mask & |
| * ~(1 << (MON_KSERV - 1))) |
| * |
| */ |
| static inline void sys_k_event_logger_set_monitor_mask(int value) |
| { |
| _k_monitor_mask = value; |
| } |
| |
| /** |
| * @brief Get task monitor filtering mask |
| * |
| * @details Calling this function permits to read the mask used to select which |
| * task monitor events to store in the kernel event logger ring buffer. This |
| * function can be used at runtime and at any moment. |
| * This capability is only available when CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC |
| * is set. If enabled, no event is enabled for logging at initialization |
| * so CONFIG_TASK_MONITOR_MASK is ignored |
| * |
| * @see sys_k_event_logger_set_monitor_mask() for details |
| * |
| */ |
| static inline int sys_k_event_logger_get_monitor_mask(void) |
| { |
| return _k_monitor_mask; |
| } |
| |
| #endif /* CONFIG_TASK_MONITOR */ |
| #endif /* CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC */ |
| |
| /** |
| * @brief Check if an event type has to be logged or not |
| * |
| * @details This function must be used before calling any sys_k_event_logger_put* |
| * function. In case CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC is enabled, that function |
| * permits to enable or disable the logging of each individual event at runtime |
| * |
| * @param event_type The identification of the event. |
| * |
| */ |
| |
| static inline int sys_k_must_log_event(int event_type) |
| { |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_DYNAMIC |
| return !!(_sys_k_event_logger_mask & (1 << (event_type - 1))); |
| #else |
| return 1; |
| #endif |
| } |
| |
| /** |
| * @brief Sends a event message to the kernel event logger. |
| * |
| * @details Sends a event message to the kernel event logger |
| * and informs that there are messages available. |
| * |
| * @param event_id The identification of the event. |
| * @param data Pointer to the data of the message. |
| * @param data_size Size of the data in 32-bit words. |
| * |
| * @return No return value. |
| */ |
| #define sys_k_event_logger_put(event_id, data, data_size) \ |
| sys_event_logger_put(&sys_k_event_logger, event_id, data, data_size) |
| |
| |
| /** |
| * @brief Sends a event message to the kernel event logger with the current |
| * timestamp. |
| * |
| * @details Sends a event message to the kernel event logger and informs that |
| * there messages available. The timestamp when the event occurred is stored |
| * as part of the event message. |
| * |
| * @param event_id The identification of the event. |
| * |
| * @return No return value. |
| */ |
| void sys_k_event_logger_put_timed(uint16_t event_id); |
| |
| |
| /** |
| * @brief Retrieves a kernel event message. |
| * |
| * @details Retrieves a kernel event message copying it to the provided |
| * buffer. If the buffer is smaller than the message size the function returns |
| * an error. The function retrieves messages in FIFO order. |
| * |
| * @param event_id Pointer to the id of the event fetched |
| * @param dropped Pointer to how many events were dropped |
| * @param buffer Pointer to the buffer where the message will be copied. |
| * @param buffer_size Size of the buffer in 32-bit words. |
| * |
| * @return -EMSGSIZE if the buffer size is smaller than the message size, |
| * the amount of 32-bit words copied or zero if there are no kernel event |
| * messages available. |
| */ |
| #define sys_k_event_logger_get(event_id, dropped, buffer, buffer_size) \ |
| sys_event_logger_get(&sys_k_event_logger, event_id, dropped, buffer, \ |
| buffer_size) |
| |
| |
| /** |
| * @brief Retrieves a kernel event message, wait if there is no message |
| * available. |
| * |
| * @details Retrieves a kernel event message copying it to the provided |
| * buffer. If the buffer is smaller than the message size the function returns |
| * an error. The function retrieves messages in FIFO order. If there is no |
| * kernel event message available the caller pends until a new message is |
| * logged. |
| * |
| * @param event_id Pointer to the id of the event fetched |
| * @param dropped Pointer to how many events were dropped |
| * @param buffer Pointer to the buffer where the message will be copied. |
| * @param buffer_size Size of the buffer in 32-bit words. |
| * |
| * @return -EMSGSIZE if the buffer size is smaller than the message size, or |
| * the amount of 32-bit words copied. |
| */ |
| #define sys_k_event_logger_get_wait(event_id, dropped, buffer, buffer_size) \ |
| sys_event_logger_get_wait(&sys_k_event_logger, event_id, dropped, \ |
| buffer, buffer_size) |
| |
| |
| #ifdef CONFIG_NANO_TIMEOUTS |
| |
| /** |
| * @brief Retrieves a kernel event message, wait with a timeout if there is |
| * no profiling event messages available. |
| * |
| * @details Retrieves a kernel event message copying it to the provided |
| * buffer. If the buffer is smaller than the message size the function returns |
| * an error. The function retrieves messages in FIFO order. If there are no |
| * kernel event messages available the caller pends until a new message is |
| * logged or the timeout expires. |
| * |
| * @param event_id Pointer to the id of the event fetched |
| * @param dropped Pointer to how many events were dropped |
| * @param buffer Pointer to the buffer where the message will be copied. |
| * @param buffer_size Size of the buffer in 32-bit words. |
| * @param timeout Timeout in ticks. |
| * |
| * @return -EMSGSIZE if the buffer size is smaller than the message size, the |
| * amount of 32-bit words copied or zero if the timeout expires and the was no |
| * message available. |
| */ |
| #define sys_k_event_logger_get_wait_timeout(event_id, dropped, buffer, buffer_size, \ |
| timeout) \ |
| sys_event_logger_get_wait_timeout(&sys_k_event_logger, event_id, \ |
| dropped, buffer, \ |
| buffer_size, timeout) |
| #endif /* CONFIG_NANO_TIMEOUTS */ |
| |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_CONTEXT_SWITCH |
| |
| /** |
| * @brief Register the fiber that calls the function as collector |
| * |
| * @details Initialize internal profiling data. This avoid registering |
| * the context switch of the collector fiber when |
| * CONFIG_KERNEL_EVENT_LOGGER_CONTEXT_SWITCH is enable. |
| * |
| * @return No return value. |
| */ |
| void sys_k_event_logger_register_as_collector(void); |
| #else /* !CONFIG_KERNEL_EVENT_LOGGER_CONTEXT_SWITCH */ |
| static inline void sys_k_event_logger_register_as_collector(void) {}; |
| #endif /* CONFIG_KERNEL_EVENT_LOGGER_CONTEXT_SWITCH */ |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_SLEEP |
| void _sys_k_event_logger_enter_sleep(void); |
| #else |
| static inline void _sys_k_event_logger_enter_sleep(void) {}; |
| #endif |
| |
| #endif /* _ASMLANGUAGE */ |
| |
| #else /* !CONFIG_KERNEL_EVENT_LOGGER */ |
| |
| #ifndef _ASMLANGUAGE |
| |
| static inline void sys_k_event_logger_put(uint16_t event_id, uint32_t *event_data, |
| uint8_t data_size) {}; |
| static inline void sys_k_event_logger_put_timed(uint16_t event_id) {}; |
| static inline void _sys_k_event_logger_enter_sleep(void) {}; |
| |
| #endif /* _ASMLANGUAGE */ |
| |
| #endif /* CONFIG_KERNEL_EVENT_LOGGER */ |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| /** |
| * @} |
| */ |
| |
| #endif /* __KERNEL_EVENT_LOGGER_H__ */ |