diff options
Diffstat (limited to 'sys/contrib/octeon-sdk/cvmx-log.c')
| -rw-r--r-- | sys/contrib/octeon-sdk/cvmx-log.c | 539 |
1 files changed, 539 insertions, 0 deletions
diff --git a/sys/contrib/octeon-sdk/cvmx-log.c b/sys/contrib/octeon-sdk/cvmx-log.c new file mode 100644 index 0000000..2944a2a --- /dev/null +++ b/sys/contrib/octeon-sdk/cvmx-log.c @@ -0,0 +1,539 @@ +/***********************license start*************** + * Copyright (c) 2003-2010 Cavium Inc. (support@cavium.com). All rights + * reserved. + * + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + + * * Neither the name of Cavium Inc. nor the names of + * its contributors may be used to endorse or promote products + * derived from this software without specific prior written + * permission. + + * This Software, including technical data, may be subject to U.S. export control + * laws, including the U.S. Export Administration Act and its associated + * regulations, and may be subject to export or import regulations in other + * countries. + + * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS" + * AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS OR + * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO + * THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY REPRESENTATION OR + * DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT DEFECTS, AND CAVIUM + * SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES OF TITLE, + * MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF + * VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR + * CORRESPONDENCE TO DESCRIPTION. THE ENTIRE RISK ARISING OUT OF USE OR + * PERFORMANCE OF THE SOFTWARE LIES WITH YOU. + ***********************license end**************************************/ + + + + + + + +/** + * @file + * + * cvmx-log supplies a fast log buffer implementation. Each core writes + * log data to a differnet buffer to avoid synchronization overhead. Function + * call logging can be turned on with the GCC option "-pg". + * + * <hr>$Revision: 70030 $<hr> + */ +#include "cvmx.h" +#include "cvmx-core.h" +#include "cvmx-log.h" + +#define CVMX_LOG_BUFFER_SIZE (1<<15) +#define CVMX_LOG_NUM_BUFFERS 4 + +/** + * The possible types of log data that can be stored in the + * buffer. + */ +typedef enum +{ + CVMX_LOG_TYPE_PC = 0, /**< Log of the program counter location. used for code profiling / tracing */ + CVMX_LOG_TYPE_PRINTF, /**< Constant printf format string with two 64bit arguments */ + CVMX_LOG_TYPE_DATA, /**< Arbitrary array of dwords. Max size is 31 dwords */ + CVMX_LOG_TYPE_STRUCTURE,/**< Log a structured data element. Max size is 30 dwords */ + CVMX_LOG_TYPE_PERF, /**< Mips performance counters control registers followed by the data */ +} cvmx_log_type_t; + +/** + * Header definition for each log entry. + */ +typedef union +{ + uint64_t u64; + struct + { + cvmx_log_type_t type : 3; /* Data in the log entry */ + uint64_t size : 8; /* Data size in 64bit words */ + uint64_t cycle :53; /* Low bits of the cycle counter as a timestamp */ + } s; +} cvmx_log_header_t; + +/** + * Circular log buffer. Each processor gets a private one to + * write to. Log entries are added at the current write + * location, then the write location is incremented. The + * buffer may wrap in the middle of a log entry. + */ +static uint64_t cvmx_log_buffers[CVMX_LOG_NUM_BUFFERS][CVMX_LOG_BUFFER_SIZE]; + +/** + * Current locations in the log. + */ +uint64_t *cvmx_log_buffer_write_ptr = NULL; /* The next write will occur here */ +uint64_t *cvmx_log_buffer_end_ptr = NULL; /* Write must move to the next buffer when it equals this */ +uint64_t *cvmx_log_buffer_head_ptr = NULL; /* Pointer to begin extracting log data from */ +static uint64_t *cvmx_log_buffer_read_ptr = NULL; /* Location cvmx_display is reading from */ +static uint64_t *cvmx_log_buffer_read_end_ptr = NULL; /* Location where read will need the next buffer */ +uint64_t cvmx_log_mcd0_on_full = 0; /* If this is set, cvm-log will assert MCD0 when the log + is full. This is set by the remote logging utility through + the debugger interface. */ + + +/** + * @INTERNAL + * Initialize the log for writing + */ +static void __cvmx_log_initialize(void) CVMX_LOG_DISABLE_PC_LOGGING; +static void __cvmx_log_initialize(void) +{ + int buf_num; + + /* Link the buffers together using the last element in each buffer */ + for (buf_num=0; buf_num<CVMX_LOG_NUM_BUFFERS-1; buf_num++) + cvmx_log_buffers[buf_num][CVMX_LOG_BUFFER_SIZE-1] = CAST64(cvmx_log_buffers[buf_num+1]); + cvmx_log_buffers[CVMX_LOG_NUM_BUFFERS-1][CVMX_LOG_BUFFER_SIZE-1] = CAST64(NULL); + + cvmx_log_buffer_head_ptr = &cvmx_log_buffers[0][0]; + cvmx_log_buffer_write_ptr = &cvmx_log_buffers[0][0]; + cvmx_log_buffer_end_ptr = cvmx_log_buffer_write_ptr + CVMX_LOG_BUFFER_SIZE-1; +} + + +/** + * @INTERNAL + * Called when the log is full of data. This function must + * make room for more log data before returning. + */ +static void __cvmx_log_full_process(void) CVMX_LOG_DISABLE_PC_LOGGING; +static void __cvmx_log_full_process(void) +{ + if (cvmx_log_mcd0_on_full) + { + register uint64_t tmp; + /* Pulse MCD0 signal so a remote utility can extract the data */ + asm volatile ( + "dmfc0 %0, $22\n" + "ori %0, %0, 0x1110\n" + "dmtc0 %0, $22\n" + "nop\n" + "nop\n" + "nop\n" + "nop\n" + "nop\n" + "nop\n" + : "=r" (tmp)); + } + /* The write ptr may have been modifed by the debugger, check it again */ + if (!(volatile uint64_t)CAST64(cvmx_log_buffer_write_ptr)) + { + #ifndef __KERNEL__ + /* Disabled for the Linux kernel since printk is also profiled */ + cvmx_dprintf("Log is full, reusing first buffer\n"); + #endif + *cvmx_log_buffer_end_ptr = CAST64(cvmx_log_buffer_head_ptr); + cvmx_log_buffer_write_ptr = cvmx_log_buffer_head_ptr; + cvmx_log_buffer_end_ptr = cvmx_log_buffer_write_ptr + CVMX_LOG_BUFFER_SIZE-1; + cvmx_log_buffer_head_ptr = CASTPTR(uint64_t, *cvmx_log_buffer_end_ptr); + *cvmx_log_buffer_end_ptr = CAST64(NULL); + } +} + + +/** + * @INTERNAL + * Simple inline function to build a log header + * + * @param type Type of header to build + * @param size Amount of data that follows the header in dwords + * @return The header + */ +static inline uint64_t __cvmx_log_build_header(cvmx_log_type_t type, uint64_t size) CVMX_LOG_DISABLE_PC_LOGGING; +static inline uint64_t __cvmx_log_build_header(cvmx_log_type_t type, uint64_t size) +{ + cvmx_log_header_t header; + header.u64 = 0; + header.s.type = type; + header.s.size = size; + header.s.cycle = cvmx_get_cycle(); + return header.u64; +} + + +/** + * @INTERNAL + * Function to write and increment the position. It rotates + * to the next log buffer as necessary. + * + * @param data Data to write to the log + */ +static inline void __cvmx_log_write(uint64_t data) CVMX_LOG_DISABLE_PC_LOGGING; +static inline void __cvmx_log_write(uint64_t data) +{ + /* Check and see if we need to rotate the log */ + if (cvmx_likely(cvmx_log_buffer_write_ptr != cvmx_log_buffer_end_ptr)) + { + /* No rotate is necessary, just write the data */ + *cvmx_log_buffer_write_ptr++ = data; + } + else + { + /* Initialize the log if necessary */ + if (cvmx_unlikely(cvmx_log_buffer_head_ptr == NULL)) + __cvmx_log_initialize(); + else + { + cvmx_log_buffer_write_ptr = CASTPTR(uint64_t, *cvmx_log_buffer_end_ptr); + if (cvmx_likely(cvmx_log_buffer_write_ptr)) + { + /* Rotate the log. Might be a good time to send the old buffer + somewhere */ + cvmx_log_buffer_end_ptr = cvmx_log_buffer_write_ptr + CVMX_LOG_BUFFER_SIZE-1; + } + else + __cvmx_log_full_process(); /* After this function returns, the log must be ready for updates */ + } + *cvmx_log_buffer_write_ptr++ = data; + } +} + + +/** + * Log a program counter address to the log. This is caused by + * the assembly code function mcount when writing the PC value + * is more complicated that the simple case support by it. + * + * @param pc Program counter address to log + */ +void cvmx_log_pc(uint64_t pc) CVMX_LOG_DISABLE_PC_LOGGING; +void cvmx_log_pc(uint64_t pc) +{ + __cvmx_log_write(__cvmx_log_build_header(CVMX_LOG_TYPE_PC, 1)); + __cvmx_log_write(pc); +} + + +/** + * Log a constant printf style format string with 0 to 4 + * arguments. The string must persist until the log is read, + * but the parameters are copied into the log. + * + * @param format Constant printf style format string. + */ +void cvmx_log_printf0(const char *format) +{ + __cvmx_log_write(__cvmx_log_build_header(CVMX_LOG_TYPE_PRINTF, 1)); + __cvmx_log_write(CAST64(format)); +} + + +/** + * Log a constant printf style format string with 0 to 4 + * arguments. The string must persist until the log is read, + * but the parameters are copied into the log. + * + * @param format Constant printf style format string. + * @param number1 64bit argument to the printf format string + */ +void cvmx_log_printf1(const char *format, uint64_t number1) +{ + __cvmx_log_write(__cvmx_log_build_header(CVMX_LOG_TYPE_PRINTF, 2)); + __cvmx_log_write(CAST64(format)); + __cvmx_log_write(number1); +} + + +/** + * Log a constant printf style format string with 0 to 4 + * arguments. The string must persist until the log is read, + * but the parameters are copied into the log. + * + * @param format Constant printf style format string. + * @param number1 64bit argument to the printf format string + * @param number2 64bit argument to the printf format string + */ +void cvmx_log_printf2(const char *format, uint64_t number1, uint64_t number2) +{ + __cvmx_log_write(__cvmx_log_build_header(CVMX_LOG_TYPE_PRINTF, 3)); + __cvmx_log_write(CAST64(format)); + __cvmx_log_write(number1); + __cvmx_log_write(number2); +} + + +/** + * Log a constant printf style format string with 0 to 4 + * arguments. The string must persist until the log is read, + * but the parameters are copied into the log. + * + * @param format Constant printf style format string. + * @param number1 64bit argument to the printf format string + * @param number2 64bit argument to the printf format string + * @param number3 64bit argument to the printf format string + */ +void cvmx_log_printf3(const char *format, uint64_t number1, uint64_t number2, uint64_t number3) +{ + __cvmx_log_write(__cvmx_log_build_header(CVMX_LOG_TYPE_PRINTF, 4)); + __cvmx_log_write(CAST64(format)); + __cvmx_log_write(number1); + __cvmx_log_write(number2); + __cvmx_log_write(number3); +} + + +/** + * Log a constant printf style format string with 0 to 4 + * arguments. The string must persist until the log is read, + * but the parameters are copied into the log. + * + * @param format Constant printf style format string. + * @param number1 64bit argument to the printf format string + * @param number2 64bit argument to the printf format string + * @param number3 64bit argument to the printf format string + * @param number4 64bit argument to the printf format string + */ +void cvmx_log_printf4(const char *format, uint64_t number1, uint64_t number2, uint64_t number3, uint64_t number4) +{ + __cvmx_log_write(__cvmx_log_build_header(CVMX_LOG_TYPE_PRINTF, 5)); + __cvmx_log_write(CAST64(format)); + __cvmx_log_write(number1); + __cvmx_log_write(number2); + __cvmx_log_write(number3); + __cvmx_log_write(number4); +} + + +/** + * Log an arbitrary block of 64bit words. At most 255 64bit + * words can be logged. The words are copied into the log. + * + * @param size_in_dwords + * Number of 64bit dwords to copy into the log. + * @param data Array of 64bit dwords to copy + */ +void cvmx_log_data(uint64_t size_in_dwords, const uint64_t *data) +{ + if (size_in_dwords > 255) + size_in_dwords = 255; + + __cvmx_log_write(__cvmx_log_build_header(CVMX_LOG_TYPE_DATA, size_in_dwords)); + while (size_in_dwords--) + __cvmx_log_write(*data++); +} + + +/** + * Log a structured data object. Post processing will use the + * debugging information in the ELF file to determine how to + * display the structure. Max of 2032 bytes. + * + * Example: + * cvmx_log_structure("cvmx_wqe_t", work, sizeof(*work)); + * + * @param type C typedef expressed as a string. This will be used to + * lookup the structure in the debugging infirmation. + * @param data Data to be written to the log. + * @param size_in_bytes + * Size if the data in bytes. Normally you'll use the + * sizeof() operator here. + */ +void cvmx_log_structure(const char *type, void *data, int size_in_bytes) +{ + uint64_t size_in_dwords = (size_in_bytes + 7) >> 3; + uint64_t *ptr = (uint64_t*)data; + + if (size_in_dwords > 254) + size_in_dwords = 254; + + __cvmx_log_write(__cvmx_log_build_header(CVMX_LOG_TYPE_STRUCTURE, size_in_dwords + 1)); + __cvmx_log_write(CAST64(type)); + while (size_in_dwords--) + __cvmx_log_write(*ptr++); +} + + +/** + * Setup the mips performance counters + * + * @param counter1 Event type for counter 1 + * @param counter2 Event type for counter 2 + */ +void cvmx_log_perf_setup(cvmx_core_perf_t counter1, cvmx_core_perf_t counter2) +{ + cvmx_core_perf_control_t control; + + control.u32 = 0; + control.s.event = counter1; + control.s.u = 1; + control.s.s = 1; + control.s.k = 1; + control.s.ex = 1; + asm ("mtc0 %0, $25, 0\n" : : "r"(control.u32)); + control.s.event = counter2; + asm ("mtc0 %0, $25, 2\n" : : "r"(control.u32)); +} + + +/** + * Log the performance counters + */ +void cvmx_log_perf(void) +{ + uint64_t control1; + uint64_t control2; + uint64_t data1; + uint64_t data2; + asm ("dmfc0 %0, $25, 1\n" : "=r"(data1)); + asm ("dmfc0 %0, $25, 3\n" : "=r"(data2)); + asm ("mfc0 %0, $25, 0\n" : "=r"(control1)); + asm ("mfc0 %0, $25, 2\n" : "=r"(control2)); + __cvmx_log_write(__cvmx_log_build_header(CVMX_LOG_TYPE_PERF, 3)); + __cvmx_log_write(((control1 & 0xffffffff) << 32) | (control2 & 0xffffffff)); + __cvmx_log_write(data1); + __cvmx_log_write(data2); +} + + +/** + * @INTERNAL + * Read a dword from the log + * + * @return the dword + */ +static uint64_t __cvmx_log_read(void) CVMX_LOG_DISABLE_PC_LOGGING; +static uint64_t __cvmx_log_read(void) +{ + uint64_t data; + + /* Check and see if we need to rotate the log */ + if (cvmx_likely(cvmx_log_buffer_read_ptr != cvmx_log_buffer_read_end_ptr)) + { + /* No rotate is necessary, just read the data */ + data = *cvmx_log_buffer_read_ptr++; + } + else + { + cvmx_log_buffer_read_ptr = CASTPTR(uint64_t, *cvmx_log_buffer_read_end_ptr); + if (cvmx_likely(cvmx_log_buffer_read_ptr)) + { + /* Rotate to the next log buffer */ + cvmx_log_buffer_read_end_ptr = cvmx_log_buffer_read_ptr + CVMX_LOG_BUFFER_SIZE-1; + data = *cvmx_log_buffer_read_ptr++; + } + else + { + /* No more log buffers, return 0 */ + cvmx_log_buffer_read_end_ptr = NULL; + data = 0; + } + } + + return data; +} + + +/** + * Display the current log in a human readable format. + */ +void cvmx_log_display(void) +{ + unsigned int i; + cvmx_log_header_t header; + + cvmx_log_buffer_read_ptr = cvmx_log_buffer_head_ptr; + cvmx_log_buffer_read_end_ptr = cvmx_log_buffer_read_ptr + CVMX_LOG_BUFFER_SIZE-1; + + while (cvmx_log_buffer_read_ptr && (cvmx_log_buffer_read_ptr != cvmx_log_buffer_write_ptr)) + { + header.u64 = __cvmx_log_read(); + if (header.s.cycle == 0) + continue; + printf("%llu: ", (unsigned long long)header.s.cycle); + switch (header.s.type) + { + case CVMX_LOG_TYPE_PC: + if (header.s.size == 1) + printf("pc 0x%016llx\n", (unsigned long long)__cvmx_log_read()); + else + printf("Illegal size (%d) for log entry: pc\n", header.s.size); + break; + case CVMX_LOG_TYPE_PRINTF: + switch (header.s.size) + { + case 1: + printf(CASTPTR(const char, __cvmx_log_read())); + break; + case 2: + printf(CASTPTR(const char, __cvmx_log_read()), __cvmx_log_read()); + break; + case 3: + printf(CASTPTR(const char, __cvmx_log_read()), __cvmx_log_read(), __cvmx_log_read()); + break; + case 4: + printf(CASTPTR(const char, __cvmx_log_read()), __cvmx_log_read(), __cvmx_log_read(), __cvmx_log_read()); + break; + case 5: + printf(CASTPTR(const char, __cvmx_log_read()), __cvmx_log_read(), __cvmx_log_read(), __cvmx_log_read(), __cvmx_log_read()); + break; + default: + printf("Illegal size (%d) for log entry: printf\n", header.s.size); + break; + } + printf("\n"); + break; + case CVMX_LOG_TYPE_DATA: + printf("data"); + for (i=0; i<header.s.size; i++) + printf(" 0x%016llx", (unsigned long long)__cvmx_log_read()); + printf("\n"); + break; + case CVMX_LOG_TYPE_STRUCTURE: + printf("struct %s", CASTPTR(const char, __cvmx_log_read())); + for (i=1; i<header.s.size; i++) + printf(" 0x%016llx", (unsigned long long)__cvmx_log_read()); + printf("\n"); + break; + case CVMX_LOG_TYPE_PERF: + if (header.s.size == 3) + { + unsigned long long control = __cvmx_log_read(); + unsigned long long data1 = __cvmx_log_read(); + unsigned long long data2 = __cvmx_log_read(); + printf("perf control=0x%016llx data1=0x%016llx data2=0x%016llx\n", control, data1, data2); + } + else + printf("Illegal size (%d) for log entry: perf\n", header.s.size); + break; + default: + break; + } + } +} + |
