2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* drivers/note/noteram_driver.c
|
|
|
|
*
|
2021-03-04 07:10:42 +01:00
|
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
|
|
* this work for additional information regarding copyright ownership. The
|
|
|
|
* ASF licenses this file to you 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
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
2021-03-04 07:10:42 +01:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
2021-03-04 07:10:42 +01:00
|
|
|
* 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.
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sched.h>
|
2020-09-09 02:06:38 +02:00
|
|
|
#include <fcntl.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
#include <assert.h>
|
|
|
|
#include <errno.h>
|
2023-08-11 04:31:02 +02:00
|
|
|
#include <stdio.h>
|
2020-10-28 02:45:30 +01:00
|
|
|
#include <string.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
#include <nuttx/spinlock.h>
|
2020-10-28 02:45:30 +01:00
|
|
|
#include <nuttx/sched.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
#include <nuttx/sched_note.h>
|
2023-04-27 13:42:27 +02:00
|
|
|
#include <nuttx/kmalloc.h>
|
2022-12-16 11:31:28 +01:00
|
|
|
#include <nuttx/note/note_driver.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
#include <nuttx/note/noteram_driver.h>
|
2023-07-05 15:53:33 +02:00
|
|
|
#include <nuttx/panic_notifier.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
#include <nuttx/fs/fs.h>
|
2023-08-11 04:31:04 +02:00
|
|
|
#include <nuttx/streams.h>
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-08-11 04:31:02 +02:00
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_SYSCALL
|
|
|
|
# ifdef CONFIG_LIB_SYSCALL
|
|
|
|
# include <syscall.h>
|
|
|
|
# else
|
|
|
|
# define CONFIG_LIB_SYSCALL
|
|
|
|
# include <syscall.h>
|
|
|
|
# undef CONFIG_LIB_SYSCALL
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Pre-processor Definitions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#define NCPUS CONFIG_SMP_NCPUS
|
|
|
|
|
|
|
|
/* Renumber idle task PIDs
|
|
|
|
* In NuttX, PID number less than NCPUS are idle tasks.
|
|
|
|
* In Linux, there is only one idle task of PID 0.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define get_pid(pid) ((pid) < NCPUS ? 0 : (pid))
|
|
|
|
|
|
|
|
#define get_task_state(s) \
|
|
|
|
((s) == 0 ? 'X' : ((s) <= LAST_READY_TO_RUN_STATE ? 'R' : 'S'))
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Types
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
struct noteram_driver_s
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
struct note_driver_s driver;
|
2023-04-20 12:27:15 +02:00
|
|
|
FAR uint8_t *ni_buffer;
|
|
|
|
size_t ni_bufsize;
|
2022-03-26 21:51:22 +01:00
|
|
|
unsigned int ni_overwrite;
|
2020-09-08 12:44:29 +02:00
|
|
|
volatile unsigned int ni_head;
|
|
|
|
volatile unsigned int ni_tail;
|
2020-09-09 02:06:38 +02:00
|
|
|
volatile unsigned int ni_read;
|
2023-04-27 13:42:27 +02:00
|
|
|
spinlock_t lock;
|
2020-09-08 12:44:29 +02:00
|
|
|
};
|
|
|
|
|
2023-08-11 04:31:02 +02:00
|
|
|
/* The structure to hold the context data of trace dump */
|
|
|
|
|
|
|
|
struct noteram_dump_cpu_context_s
|
|
|
|
{
|
|
|
|
int intr_nest; /* Interrupt nest level */
|
|
|
|
bool pendingswitch; /* sched_switch pending flag */
|
|
|
|
int current_state; /* Task state of the current line */
|
|
|
|
pid_t current_pid; /* Task PID of the current line */
|
|
|
|
pid_t next_pid; /* Task PID of the next line */
|
|
|
|
uint8_t current_priority; /* Task Priority of the current line */
|
|
|
|
uint8_t next_priority; /* Task Priority of the next line */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct noteram_dump_context_s
|
|
|
|
{
|
|
|
|
struct noteram_dump_cpu_context_s cpu[NCPUS];
|
|
|
|
};
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Function Prototypes
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
static int noteram_open(FAR struct file *filep);
|
2023-08-11 04:31:02 +02:00
|
|
|
static int noteram_close(FAR struct file *filep);
|
2020-09-08 12:44:29 +02:00
|
|
|
static ssize_t noteram_read(FAR struct file *filep,
|
|
|
|
FAR char *buffer, size_t buflen);
|
2020-09-09 02:06:38 +02:00
|
|
|
static int noteram_ioctl(struct file *filep, int cmd, unsigned long arg);
|
2022-12-16 11:31:28 +01:00
|
|
|
static void noteram_add(FAR struct note_driver_s *drv,
|
|
|
|
FAR const void *note, size_t len);
|
2023-08-11 04:31:02 +02:00
|
|
|
static void
|
|
|
|
noteram_dump_init_context(FAR struct noteram_dump_context_s *ctx);
|
2023-08-11 04:31:04 +02:00
|
|
|
static int noteram_dump_one(FAR uint8_t *p, FAR struct lib_outstream_s *s,
|
2023-08-11 04:31:02 +02:00
|
|
|
FAR struct noteram_dump_context_s *ctx);
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Data
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static const struct file_operations g_noteram_fops =
|
|
|
|
{
|
2020-09-09 02:06:38 +02:00
|
|
|
noteram_open, /* open */
|
2023-08-11 04:31:02 +02:00
|
|
|
noteram_close, /* close */
|
2020-09-08 12:44:29 +02:00
|
|
|
noteram_read, /* read */
|
|
|
|
NULL, /* write */
|
|
|
|
NULL, /* seek */
|
2020-09-09 02:06:38 +02:00
|
|
|
noteram_ioctl, /* ioctl */
|
2020-09-08 12:44:29 +02:00
|
|
|
};
|
|
|
|
|
2023-04-20 12:27:15 +02:00
|
|
|
static uint8_t g_ramnote_buffer[CONFIG_DRIVERS_NOTERAM_BUFSIZE];
|
|
|
|
|
2022-12-16 11:31:28 +01:00
|
|
|
static const struct note_driver_ops_s g_noteram_ops =
|
|
|
|
{
|
|
|
|
noteram_add
|
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Public Data
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
struct noteram_driver_s g_noteram_driver =
|
2022-12-16 11:31:28 +01:00
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
{&g_noteram_ops},
|
|
|
|
g_ramnote_buffer,
|
|
|
|
CONFIG_DRIVERS_NOTERAM_BUFSIZE,
|
|
|
|
#ifdef CONFIG_DRIVERS_NOTERAM_DEFAULT_NOOVERWRITE
|
|
|
|
NOTERAM_MODE_OVERWRITE_DISABLE
|
|
|
|
#else
|
|
|
|
NOTERAM_MODE_OVERWRITE_ENABLE
|
|
|
|
#endif
|
2022-12-16 11:31:28 +01:00
|
|
|
};
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Private Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_buffer_clear
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Clear all contents of the circular buffer.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
static void noteram_buffer_clear(FAR struct noteram_driver_s *drv)
|
2020-09-09 02:06:38 +02:00
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
drv->ni_tail = drv->ni_head;
|
|
|
|
drv->ni_read = drv->ni_head;
|
2020-09-09 02:06:38 +02:00
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
if (drv->ni_overwrite == NOTERAM_MODE_OVERWRITE_OVERFLOW)
|
2020-09-09 02:06:38 +02:00
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
drv->ni_overwrite = NOTERAM_MODE_OVERWRITE_DISABLE;
|
2020-09-09 02:06:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_next
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Return the circular buffer index at offset from the specified index
|
|
|
|
* value, handling wraparound
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* ndx - Old circular buffer index
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* New circular buffer index
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
static inline unsigned int noteram_next(FAR struct noteram_driver_s *drv,
|
|
|
|
unsigned int ndx,
|
2020-09-08 12:44:29 +02:00
|
|
|
unsigned int offset)
|
|
|
|
{
|
|
|
|
ndx += offset;
|
2023-04-27 13:42:27 +02:00
|
|
|
if (ndx >= drv->ni_bufsize)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
ndx -= drv->ni_bufsize;
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return ndx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_length
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Length of data currently in circular buffer.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Length of data currently in circular buffer.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
static unsigned int noteram_length(FAR struct noteram_driver_s *drv)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
unsigned int head = drv->ni_head;
|
|
|
|
unsigned int tail = drv->ni_tail;
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
if (tail > head)
|
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
head += drv->ni_bufsize;
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return head - tail;
|
|
|
|
}
|
2020-09-09 02:06:38 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_unread_length
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Length of unread data currently in circular buffer.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Length of unread data currently in circular buffer.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
static unsigned int noteram_unread_length(FAR struct noteram_driver_s *drv)
|
2020-09-09 02:06:38 +02:00
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
unsigned int head = drv->ni_head;
|
|
|
|
unsigned int read = drv->ni_read;
|
2020-09-09 02:06:38 +02:00
|
|
|
|
|
|
|
if (read > head)
|
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
head += drv->ni_bufsize;
|
2020-09-09 02:06:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return head - read;
|
|
|
|
}
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_remove
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Remove the variable length note from the tail of the circular buffer
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* We are within a critical section.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
static void noteram_remove(FAR struct noteram_driver_s *drv)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
|
|
|
unsigned int tail;
|
|
|
|
unsigned int length;
|
|
|
|
|
|
|
|
/* Get the tail index of the circular buffer */
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
tail = drv->ni_tail;
|
|
|
|
DEBUGASSERT(tail < drv->ni_bufsize);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
/* Get the length of the note at the tail index */
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
length = drv->ni_buffer[tail];
|
|
|
|
DEBUGASSERT(length <= noteram_length(drv));
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
/* Increment the tail index to remove the entire note from the circular
|
|
|
|
* buffer.
|
|
|
|
*/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
if (drv->ni_read == drv->ni_tail)
|
2020-09-09 02:06:38 +02:00
|
|
|
{
|
|
|
|
/* The read index also needs increment. */
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
drv->ni_read = noteram_next(drv, tail, length);
|
2020-09-09 02:06:38 +02:00
|
|
|
}
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
drv->ni_tail = noteram_next(drv, tail, length);
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_get
|
|
|
|
*
|
|
|
|
* Description:
|
2020-09-09 02:06:38 +02:00
|
|
|
* Get the next note from the read index of the circular buffer.
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* buffer - Location to return the next note
|
|
|
|
* buflen - The length of the user provided buffer.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* On success, the positive, non-zero length of the return note is
|
|
|
|
* provided. Zero is returned only if the circular buffer is empty. A
|
|
|
|
* negated errno value is returned in the event of any failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
static ssize_t noteram_get(FAR struct noteram_driver_s *drv,
|
|
|
|
FAR uint8_t *buffer, size_t buflen)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
|
|
|
FAR struct note_common_s *note;
|
|
|
|
unsigned int remaining;
|
2020-09-09 02:06:38 +02:00
|
|
|
unsigned int read;
|
2020-09-08 12:44:29 +02:00
|
|
|
ssize_t notelen;
|
|
|
|
size_t circlen;
|
|
|
|
|
|
|
|
DEBUGASSERT(buffer != NULL);
|
|
|
|
|
|
|
|
/* Verify that the circular buffer is not empty */
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
circlen = noteram_unread_length(drv);
|
2020-09-08 12:44:29 +02:00
|
|
|
if (circlen <= 0)
|
|
|
|
{
|
2022-12-28 11:00:06 +01:00
|
|
|
return 0;
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Get the read index of the circular buffer */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
read = drv->ni_read;
|
|
|
|
DEBUGASSERT(read < drv->ni_bufsize);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Get the length of the note at the read index */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
note = (FAR struct note_common_s *)&drv->ni_buffer[read];
|
2020-09-08 12:44:29 +02:00
|
|
|
notelen = note->nc_length;
|
|
|
|
DEBUGASSERT(notelen <= circlen);
|
|
|
|
|
|
|
|
/* Is the user buffer large enough to hold the note? */
|
|
|
|
|
|
|
|
if (buflen < notelen)
|
|
|
|
{
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Skip the large note so that we do not get constipated. */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
drv->ni_read = noteram_next(drv, read, notelen);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
/* and return an error */
|
|
|
|
|
2022-12-28 11:00:06 +01:00
|
|
|
return -EFBIG;
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Loop until the note has been transferred to the user buffer */
|
|
|
|
|
|
|
|
remaining = (unsigned int)notelen;
|
|
|
|
while (remaining > 0)
|
|
|
|
{
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Copy the next byte at the read index */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
*buffer++ = drv->ni_buffer[read];
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
/* Adjust indices and counts */
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
read = noteram_next(drv, read, 1);
|
2020-09-08 12:44:29 +02:00
|
|
|
remaining--;
|
|
|
|
}
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
drv->ni_read = read;
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
return notelen;
|
|
|
|
}
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_open
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static int noteram_open(FAR struct file *filep)
|
|
|
|
{
|
2023-08-11 04:31:02 +02:00
|
|
|
FAR struct noteram_dump_context_s *ctx;
|
|
|
|
FAR struct noteram_driver_s *drv = (FAR struct noteram_driver_s *)
|
|
|
|
filep->f_inode->i_private;
|
2023-04-27 13:42:27 +02:00
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/* Reset the read index of the circular buffer */
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
drv->ni_read = drv->ni_tail;
|
2023-08-11 04:31:02 +02:00
|
|
|
ctx = kmm_zalloc(sizeof(*ctx));
|
|
|
|
if (ctx == NULL)
|
|
|
|
{
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2020-09-09 02:06:38 +02:00
|
|
|
|
2023-08-11 04:31:02 +02:00
|
|
|
filep->f_priv = ctx;
|
|
|
|
noteram_dump_init_context(ctx);
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
int noteram_close(FAR struct file *filep)
|
|
|
|
{
|
|
|
|
FAR struct noteram_dump_context_s *ctx = filep->f_priv;
|
|
|
|
kmm_free(ctx);
|
2020-09-09 02:06:38 +02:00
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_read
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-08-11 04:31:02 +02:00
|
|
|
static ssize_t noteram_read(FAR struct file *filep, FAR char *buffer,
|
|
|
|
size_t buflen)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
2023-08-11 04:31:02 +02:00
|
|
|
FAR struct noteram_dump_context_s *ctx = filep->f_priv;
|
2023-08-11 04:31:04 +02:00
|
|
|
FAR struct noteram_driver_s *drv = filep->f_inode->i_private;
|
|
|
|
FAR struct lib_memoutstream_s stream;
|
|
|
|
ssize_t ret;
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
lib_memoutstream(&stream, buffer, buflen);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
|
|
|
do
|
|
|
|
{
|
2023-08-11 04:31:04 +02:00
|
|
|
irqstate_t flags;
|
2023-08-24 13:34:08 +02:00
|
|
|
uint8_t note[256];
|
2023-08-11 04:31:04 +02:00
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/* Get the next note (removing it from the buffer) */
|
|
|
|
|
2023-08-11 04:31:02 +02:00
|
|
|
flags = spin_lock_irqsave_wo_note(&drv->lock);
|
|
|
|
ret = noteram_get(drv, note, sizeof(note));
|
|
|
|
spin_unlock_irqrestore_wo_note(&drv->lock, flags);
|
|
|
|
if (ret <= 0)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
2023-08-11 04:31:04 +02:00
|
|
|
return ret;
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-08-11 04:31:02 +02:00
|
|
|
/* Parse notes into text format */
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret = noteram_dump_one(note, (FAR struct lib_outstream_s *)&stream,
|
|
|
|
ctx);
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
2023-08-11 04:31:04 +02:00
|
|
|
while (ret == 0);
|
2023-08-11 04:31:02 +02:00
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
return ret;
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
|
|
|
|
2020-09-09 02:06:38 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_ioctl
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-12-26 06:18:33 +01:00
|
|
|
static int noteram_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
|
2020-09-09 02:06:38 +02:00
|
|
|
{
|
|
|
|
int ret = -ENOSYS;
|
2023-08-29 06:16:49 +02:00
|
|
|
FAR struct noteram_driver_s *drv = filep->f_inode->i_private;
|
2023-04-27 13:42:27 +02:00
|
|
|
irqstate_t flags = spin_lock_irqsave_wo_note(&drv->lock);
|
2020-09-09 02:06:38 +02:00
|
|
|
|
|
|
|
/* Handle the ioctl commands */
|
|
|
|
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
/* NOTERAM_CLEAR
|
|
|
|
* - Clear all contents of the circular buffer
|
|
|
|
* Argument: Ignored
|
|
|
|
*/
|
|
|
|
|
|
|
|
case NOTERAM_CLEAR:
|
2023-04-27 13:42:27 +02:00
|
|
|
noteram_buffer_clear(drv);
|
2020-09-09 02:06:38 +02:00
|
|
|
ret = OK;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* NOTERAM_GETMODE
|
|
|
|
* - Get overwrite mode
|
|
|
|
* Argument: A writable pointer to unsigned int
|
|
|
|
*/
|
|
|
|
|
|
|
|
case NOTERAM_GETMODE:
|
|
|
|
if (arg == 0)
|
|
|
|
{
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
*(unsigned int *)arg = drv->ni_overwrite;
|
2020-09-09 02:06:38 +02:00
|
|
|
ret = OK;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* NOTERAM_SETMODE
|
|
|
|
* - Set overwrite mode
|
|
|
|
* Argument: A read-only pointer to unsigned int
|
|
|
|
*/
|
|
|
|
|
|
|
|
case NOTERAM_SETMODE:
|
|
|
|
if (arg == 0)
|
|
|
|
{
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
drv->ni_overwrite = *(unsigned int *)arg;
|
2020-09-09 02:06:38 +02:00
|
|
|
ret = OK;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
spin_unlock_irqrestore_wo_note(&drv->lock, flags);
|
2020-09-09 02:06:38 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
2022-12-16 11:31:28 +01:00
|
|
|
* Name: noteram_add
|
2020-09-08 12:44:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Add the variable length note to the transport layer
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* note - The note buffer
|
|
|
|
* notelen - The buffer length
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* We are within a critical section.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
static void noteram_add(FAR struct note_driver_s *driver,
|
2022-12-16 11:31:28 +01:00
|
|
|
FAR const void *note, size_t notelen)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
|
|
|
FAR const char *buf = note;
|
2023-04-27 13:42:27 +02:00
|
|
|
FAR struct noteram_driver_s *drv = (FAR struct noteram_driver_s *)driver;
|
2020-09-08 12:44:29 +02:00
|
|
|
unsigned int head;
|
2023-03-02 09:26:19 +01:00
|
|
|
unsigned int remain;
|
|
|
|
unsigned int space;
|
2020-09-09 02:06:38 +02:00
|
|
|
irqstate_t flags;
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
flags = spin_lock_irqsave_wo_note(&drv->lock);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
if (drv->ni_overwrite == NOTERAM_MODE_OVERWRITE_OVERFLOW)
|
2020-09-09 02:06:38 +02:00
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
spin_unlock_irqrestore_wo_note(&drv->lock, flags);
|
2020-09-09 02:06:38 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
DEBUGASSERT(note != NULL && notelen < drv->ni_bufsize);
|
|
|
|
remain = drv->ni_bufsize - noteram_length(drv);
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-03-02 09:26:19 +01:00
|
|
|
if (remain < notelen)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
if (drv->ni_overwrite == NOTERAM_MODE_OVERWRITE_DISABLE)
|
2020-09-08 12:44:29 +02:00
|
|
|
{
|
2023-03-02 09:26:19 +01:00
|
|
|
/* Stop recording if not in overwrite mode */
|
2020-09-09 02:06:38 +02:00
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
drv->ni_overwrite = NOTERAM_MODE_OVERWRITE_OVERFLOW;
|
|
|
|
spin_unlock_irqrestore_wo_note(&drv->lock, flags);
|
2023-03-02 09:26:19 +01:00
|
|
|
return;
|
|
|
|
}
|
2020-09-09 02:06:38 +02:00
|
|
|
|
2023-03-02 09:26:19 +01:00
|
|
|
/* Remove the note at the tail index , make sure there is enough space
|
|
|
|
*/
|
2020-09-08 12:44:29 +02:00
|
|
|
|
2023-03-02 09:26:19 +01:00
|
|
|
do
|
|
|
|
{
|
2023-04-27 13:42:27 +02:00
|
|
|
noteram_remove(drv);
|
|
|
|
remain = drv->ni_bufsize - noteram_length(drv);
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
2023-03-02 09:26:19 +01:00
|
|
|
while (remain < notelen);
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
|
|
|
|
2023-04-27 13:42:27 +02:00
|
|
|
head = drv->ni_head;
|
|
|
|
space = drv->ni_bufsize - head;
|
2023-03-02 09:26:19 +01:00
|
|
|
space = space < notelen ? space : notelen;
|
2023-04-27 13:42:27 +02:00
|
|
|
memcpy(drv->ni_buffer + head, note, space);
|
|
|
|
memcpy(drv->ni_buffer, buf + space, notelen - space);
|
|
|
|
drv->ni_head = noteram_next(drv, head, notelen);
|
|
|
|
spin_unlock_irqrestore_wo_note(&drv->lock, flags);
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
|
|
|
|
2023-08-11 04:31:02 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_dump_unflatten
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static void noteram_dump_unflatten(FAR void *dst, FAR uint8_t *src,
|
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_ENDIAN_BIG
|
|
|
|
FAR uint8_t *end = (FAR uint8_t *)dst + len - 1;
|
|
|
|
while (len-- > 0)
|
|
|
|
{
|
|
|
|
*end-- = *src++;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
memcpy(dst, src, len);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_dump_init_context
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static void noteram_dump_init_context(FAR struct noteram_dump_context_s *ctx)
|
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
/* Initialize the trace dump context */
|
|
|
|
|
|
|
|
for (cpu = 0; cpu < NCPUS; cpu++)
|
|
|
|
{
|
|
|
|
ctx->cpu[cpu].intr_nest = 0;
|
|
|
|
ctx->cpu[cpu].pendingswitch = false;
|
|
|
|
ctx->cpu[cpu].current_state = TSTATE_TASK_RUNNING;
|
|
|
|
ctx->cpu[cpu].current_pid = -1;
|
|
|
|
ctx->cpu[cpu].next_pid = -1;
|
|
|
|
ctx->cpu[cpu].current_priority = -1;
|
|
|
|
ctx->cpu[cpu].next_priority = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: get_task_name
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-08-11 04:31:03 +02:00
|
|
|
static const char *get_task_name(pid_t pid)
|
2023-08-11 04:31:02 +02:00
|
|
|
{
|
2023-08-11 04:31:03 +02:00
|
|
|
FAR const char *taskname;
|
2023-08-11 04:31:02 +02:00
|
|
|
|
2023-08-11 04:31:03 +02:00
|
|
|
taskname = note_get_taskname(pid);
|
|
|
|
if (taskname != NULL)
|
2023-08-11 04:31:02 +02:00
|
|
|
{
|
2023-08-11 04:31:03 +02:00
|
|
|
return taskname;
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return "<noname>";
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_dump_header
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
static int noteram_dump_header(FAR struct lib_outstream_s *s,
|
2023-08-11 04:31:02 +02:00
|
|
|
FAR struct note_common_s *note,
|
|
|
|
FAR struct noteram_dump_context_s *ctx)
|
|
|
|
{
|
|
|
|
pid_t pid;
|
|
|
|
uint32_t nsec;
|
|
|
|
uint32_t sec;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
noteram_dump_unflatten(&nsec, note->nc_systime_nsec, sizeof(nsec));
|
|
|
|
noteram_dump_unflatten(&sec, note->nc_systime_sec, sizeof(sec));
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
int cpu = note->nc_cpu;
|
|
|
|
#else
|
|
|
|
int cpu = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
noteram_dump_unflatten(&pid, note->nc_pid, sizeof(pid));
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret = lib_sprintf(s, "%8s-%-3u [%d] %3" PRIu32 ".%09" PRIu32 ": ",
|
|
|
|
get_task_name(pid), get_pid(pid), cpu, sec, nsec);
|
2023-08-11 04:31:02 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if (defined CONFIG_SCHED_INSTRUMENTATION_SWITCH) \
|
|
|
|
|| (defined CONFIG_SCHED_INSTRUMENTATION_IRQHANDLER)
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_dump_sched_switch
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
static int noteram_dump_sched_switch(FAR struct lib_outstream_s *s,
|
2023-08-11 04:31:02 +02:00
|
|
|
FAR struct note_common_s *note,
|
|
|
|
FAR struct noteram_dump_context_s *ctx)
|
|
|
|
{
|
|
|
|
FAR struct noteram_dump_cpu_context_s *cctx;
|
|
|
|
uint8_t current_priority;
|
|
|
|
uint8_t next_priority;
|
|
|
|
pid_t current_pid;
|
|
|
|
pid_t next_pid;
|
|
|
|
int ret;
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
int cpu = note->nc_cpu;
|
|
|
|
#else
|
|
|
|
int cpu = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
cctx = &ctx->cpu[cpu];
|
|
|
|
current_pid = cctx->current_pid;
|
|
|
|
next_pid = cctx->next_pid;
|
|
|
|
|
|
|
|
current_priority = cctx->current_priority;
|
|
|
|
next_priority = cctx->next_priority;
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret = lib_sprintf(s, "sched_switch: prev_comm=%s prev_pid=%u "
|
|
|
|
"prev_prio=%u prev_state=%c ==> "
|
|
|
|
"next_comm=%s next_pid=%u next_prio=%u\n",
|
|
|
|
get_task_name(current_pid), get_pid(current_pid),
|
|
|
|
current_priority, get_task_state(cctx->current_state),
|
|
|
|
get_task_name(next_pid), get_pid(next_pid),
|
|
|
|
next_priority);
|
2023-08-11 04:31:02 +02:00
|
|
|
|
|
|
|
cctx->current_pid = cctx->next_pid;
|
|
|
|
cctx->current_priority = cctx->next_priority;
|
|
|
|
cctx->pendingswitch = false;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_dump_one
|
|
|
|
****************************************************************************/
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
static int noteram_dump_one(FAR uint8_t *p, FAR struct lib_outstream_s *s,
|
2023-08-11 04:31:02 +02:00
|
|
|
FAR struct noteram_dump_context_s *ctx)
|
|
|
|
{
|
|
|
|
FAR struct note_common_s *note = (FAR struct note_common_s *)p;
|
|
|
|
FAR struct noteram_dump_cpu_context_s *cctx;
|
2023-08-11 04:31:04 +02:00
|
|
|
int ret = 0;
|
2023-08-11 04:31:02 +02:00
|
|
|
pid_t pid;
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
int cpu = note->nc_cpu;
|
|
|
|
#else
|
|
|
|
int cpu = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
cctx = &ctx->cpu[cpu];
|
|
|
|
noteram_dump_unflatten(&pid, note->nc_pid, sizeof(pid));
|
|
|
|
|
|
|
|
if (cctx->current_pid < 0)
|
|
|
|
{
|
|
|
|
cctx->current_pid = pid;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Output one note */
|
|
|
|
|
|
|
|
switch (note->nc_type)
|
|
|
|
{
|
|
|
|
case NOTE_START:
|
|
|
|
{
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
|
|
|
ret += lib_sprintf(s, "sched_wakeup_new: comm=%s pid=%d "
|
|
|
|
"target_cpu=%d\n",
|
|
|
|
get_task_name(pid), get_pid(pid), cpu);
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOTE_STOP:
|
|
|
|
{
|
|
|
|
/* This note informs the task to be stopped.
|
|
|
|
* Change current task state for the succeeding NOTE_RESUME.
|
|
|
|
*/
|
|
|
|
|
|
|
|
cctx->current_state = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_SWITCH
|
|
|
|
case NOTE_SUSPEND:
|
|
|
|
{
|
|
|
|
FAR struct note_suspend_s *nsu = (FAR struct note_suspend_s *)p;
|
|
|
|
|
|
|
|
/* This note informs the task to be suspended.
|
|
|
|
* Preserve the information for the succeeding NOTE_RESUME.
|
|
|
|
*/
|
|
|
|
|
|
|
|
cctx->current_state = nsu->nsu_state;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOTE_RESUME:
|
|
|
|
{
|
|
|
|
/* This note informs the task to be resumed.
|
|
|
|
* The task switch timing depends on the running context.
|
|
|
|
*/
|
|
|
|
|
|
|
|
cctx->next_pid = pid;
|
|
|
|
cctx->next_priority = note->nc_priority;
|
|
|
|
|
|
|
|
if (cctx->intr_nest == 0)
|
|
|
|
{
|
|
|
|
/* If not in the interrupt context, the task switch is
|
|
|
|
* executed immediately.
|
|
|
|
*/
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
|
|
|
ret += noteram_dump_sched_switch(s, note, ctx);
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* If in the interrupt context, the task switch is postponed
|
|
|
|
* until leaving the interrupt handler.
|
|
|
|
*/
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
|
|
|
ret += lib_sprintf(s, "sched_waking: comm=%s "
|
|
|
|
"pid=%d target_cpu=%d\n",
|
|
|
|
get_task_name(cctx->next_pid),
|
|
|
|
get_pid(cctx->next_pid), cpu);
|
2023-08-11 04:31:02 +02:00
|
|
|
cctx->pendingswitch = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_SYSCALL
|
|
|
|
case NOTE_SYSCALL_ENTER:
|
|
|
|
{
|
|
|
|
FAR struct note_syscall_enter_s *nsc;
|
|
|
|
int i;
|
|
|
|
int j;
|
|
|
|
uintptr_t arg;
|
|
|
|
|
|
|
|
nsc = (FAR struct note_syscall_enter_s *)p;
|
|
|
|
if (nsc->nsc_nr < CONFIG_SYS_RESERVED ||
|
|
|
|
nsc->nsc_nr >= SYS_maxsyscall)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
|
|
|
ret += lib_sprintf(s, "sys_%s(",
|
|
|
|
g_funcnames[nsc->nsc_nr - CONFIG_SYS_RESERVED]);
|
2023-08-11 04:31:02 +02:00
|
|
|
|
|
|
|
for (i = j = 0; i < nsc->nsc_argc; i++)
|
|
|
|
{
|
|
|
|
noteram_dump_unflatten(&arg, nsc->nsc_args, sizeof(arg));
|
|
|
|
if (i == 0)
|
|
|
|
{
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += lib_sprintf(s, "arg%d: 0x%" PRIxPTR, i, arg);
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += lib_sprintf(s, ", arg%d: 0x%" PRIxPTR, i, arg);
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += lib_sprintf(s, ")\n");
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOTE_SYSCALL_LEAVE:
|
|
|
|
{
|
|
|
|
FAR struct note_syscall_leave_s *nsc;
|
|
|
|
uintptr_t result;
|
|
|
|
|
|
|
|
nsc = (FAR struct note_syscall_leave_s *)p;
|
|
|
|
if (nsc->nsc_nr < CONFIG_SYS_RESERVED ||
|
|
|
|
nsc->nsc_nr >= SYS_maxsyscall)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
2023-08-11 04:31:02 +02:00
|
|
|
noteram_dump_unflatten(&result, nsc->nsc_result, sizeof(result));
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += lib_sprintf(s, "sys_%s -> 0x%" PRIxPTR "\n",
|
2023-08-11 04:31:02 +02:00
|
|
|
g_funcnames[nsc->nsc_nr - CONFIG_SYS_RESERVED],
|
|
|
|
result);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_IRQHANDLER
|
|
|
|
case NOTE_IRQ_ENTER:
|
|
|
|
{
|
|
|
|
FAR struct note_irqhandler_s *nih;
|
|
|
|
|
|
|
|
nih = (FAR struct note_irqhandler_s *)p;
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
2023-06-20 10:56:24 +02:00
|
|
|
ret += lib_sprintf(s, "irq_handler_entry: irq=%u name=%pS\n",
|
|
|
|
nih->nih_irq, (FAR void *)nih->nih_handler);
|
2023-08-11 04:31:02 +02:00
|
|
|
cctx->intr_nest++;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOTE_IRQ_LEAVE:
|
|
|
|
{
|
|
|
|
FAR struct note_irqhandler_s *nih;
|
|
|
|
|
|
|
|
nih = (FAR struct note_irqhandler_s *)p;
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
|
|
|
ret += lib_sprintf(s, "irq_handler_exit: irq=%u ret=handled\n",
|
|
|
|
nih->nih_irq);
|
2023-08-11 04:31:02 +02:00
|
|
|
cctx->intr_nest--;
|
|
|
|
|
|
|
|
if (cctx->intr_nest <= 0)
|
|
|
|
{
|
|
|
|
cctx->intr_nest = 0;
|
|
|
|
if (cctx->pendingswitch)
|
|
|
|
{
|
|
|
|
/* If the pending task switch exists, it is executed here */
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
|
|
|
ret += noteram_dump_sched_switch(s, note, ctx);
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_CSECTION
|
|
|
|
case NOTE_CSECTION_ENTER:
|
|
|
|
case NOTE_CSECTION_LEAVE:
|
|
|
|
{
|
|
|
|
struct note_csection_s *ncs;
|
|
|
|
ncs = (FAR struct note_csection_s *)p;
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, &ncs->ncs_cmn, ctx);
|
|
|
|
ret += lib_sprintf(s, "tracing_mark_write: %c|%d|critical_section\n",
|
2023-08-11 04:31:02 +02:00
|
|
|
note->nc_type == NOTE_CSECTION_ENTER ?
|
|
|
|
'B' : 'E', pid);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_PREEMPTION
|
|
|
|
case NOTE_PREEMPT_LOCK:
|
|
|
|
case NOTE_PREEMPT_UNLOCK:
|
|
|
|
{
|
|
|
|
struct note_preempt_s *npr;
|
|
|
|
int16_t count;
|
|
|
|
npr = (FAR struct note_preempt_s *)p;
|
|
|
|
noteram_dump_unflatten(&count, npr->npr_count, sizeof(count));
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, &npr->npr_cmn, ctx);
|
|
|
|
ret += lib_sprintf(s, "tracing_mark_write: "
|
2023-08-11 04:31:02 +02:00
|
|
|
"%c|%d|sched_lock:%d\n",
|
|
|
|
note->nc_type == NOTE_PREEMPT_LOCK ?
|
|
|
|
'B' : 'E', pid, count);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_DUMP
|
|
|
|
case NOTE_DUMP_STRING:
|
|
|
|
{
|
|
|
|
FAR struct note_string_s *nst;
|
|
|
|
uintptr_t ip;
|
|
|
|
|
|
|
|
nst = (FAR struct note_string_s *)p;
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
2023-08-11 04:31:02 +02:00
|
|
|
noteram_dump_unflatten(&ip, nst->nst_ip, sizeof(ip));
|
|
|
|
|
|
|
|
if (nst->nst_data[1] == '\0' &&
|
|
|
|
(nst->nst_data[0] == 'B' || nst->nst_data[0] == 'E'))
|
|
|
|
{
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += lib_sprintf(s, "tracing_mark_write: %c|%d|%pS\n",
|
|
|
|
nst->nst_data[0], pid, (FAR void *)ip);
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += lib_sprintf(s, "tracing_mark_write: %s\n",
|
|
|
|
nst->nst_data);
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOTE_DUMP_BINARY:
|
|
|
|
{
|
|
|
|
FAR struct note_binary_s *nbi;
|
|
|
|
uint8_t count;
|
|
|
|
uintptr_t ip;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
nbi = (FAR struct note_binary_s *)p;
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += noteram_dump_header(s, note, ctx);
|
2023-08-11 04:31:02 +02:00
|
|
|
count = note->nc_length - sizeof(struct note_binary_s) + 1;
|
|
|
|
|
|
|
|
noteram_dump_unflatten(&ip, nbi->nbi_ip, sizeof(ip));
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += lib_sprintf(s, "0x%" PRIdPTR ": event=%u count=%u", ip,
|
|
|
|
nbi->nbi_event, count);
|
2023-08-11 04:31:02 +02:00
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
{
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += lib_sprintf(s, " 0x%x", nbi->nbi_data[i]);
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
ret += lib_sprintf(s, "\n");
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the length of the processed note */
|
|
|
|
|
2023-08-11 04:31:04 +02:00
|
|
|
return ret;
|
2023-08-11 04:31:02 +02:00
|
|
|
}
|
|
|
|
|
2023-07-05 15:53:33 +02:00
|
|
|
#ifdef CONFIG_DRIVERS_NOTERAM_CRASH_DUMP
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_dump
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static void noteram_dump(FAR struct noteram_driver_s *drv)
|
|
|
|
{
|
|
|
|
struct noteram_dump_context_s ctx;
|
|
|
|
struct lib_syslograwstream_s stream;
|
|
|
|
uint8_t note[64];
|
|
|
|
|
|
|
|
lib_syslograwstream_open(&stream);
|
|
|
|
lib_sprintf(&stream.public, "# tracer:nop\n#\n");
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = noteram_get(drv, note, sizeof(note));
|
|
|
|
if (ret <= 0)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
noteram_dump_one(note, &stream.public, &ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
lib_syslograwstream_close(&stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_crash_dump
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
static int noteram_crash_dump(FAR struct notifier_block *nb,
|
|
|
|
unsigned long action, FAR void *data)
|
|
|
|
{
|
|
|
|
if (action == PANIC_KERNEL)
|
|
|
|
{
|
|
|
|
noteram_dump(&g_noteram_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void noteram_crash_dump_register(void)
|
|
|
|
{
|
|
|
|
static struct notifier_block nb;
|
|
|
|
nb.notifier_call = noteram_crash_dump;
|
|
|
|
panic_notifier_chain_register(&nb);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2022-12-16 11:31:28 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Public Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-09-08 12:44:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_register
|
|
|
|
*
|
|
|
|
* Description:
|
2022-12-14 05:53:09 +01:00
|
|
|
* Register a serial driver at /dev/note/ram that can be used by an
|
2020-09-08 12:44:29 +02:00
|
|
|
* application to read data from the circular note buffer.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Zero on succress. A negated errno value is returned on a failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int noteram_register(void)
|
|
|
|
{
|
2023-07-05 15:53:33 +02:00
|
|
|
#ifdef CONFIG_DRIVERS_NOTERAM_CRASH_DUMP
|
|
|
|
noteram_crash_dump_register();
|
|
|
|
#endif
|
2023-04-27 13:42:27 +02:00
|
|
|
return register_driver("/dev/note/ram", &g_noteram_fops, 0666,
|
|
|
|
&g_noteram_driver);
|
2020-09-08 12:44:29 +02:00
|
|
|
}
|
2023-04-27 13:42:27 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: noteram_initialize
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Register a serial driver at /dev/note/ram that can be used by an
|
|
|
|
* application to read data from the circular note buffer.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* devpath: The path of the Noteram device
|
|
|
|
* bufsize: The size of the circular buffer
|
|
|
|
* overwrite: The overwrite mode
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Zero on succress. A negated errno value is returned on a failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
FAR struct note_driver_s *
|
|
|
|
noteram_initialize(FAR const char *devpath, size_t bufsize, bool overwrite)
|
|
|
|
{
|
|
|
|
FAR struct noteram_driver_s *drv;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
drv = (FAR struct noteram_driver_s *)kmm_malloc(sizeof(*drv) + bufsize);
|
|
|
|
if (drv == NULL)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
drv->driver.ops = &g_noteram_ops;
|
|
|
|
drv->ni_bufsize = bufsize;
|
|
|
|
drv->ni_buffer = (FAR uint8_t *)(drv + 1);
|
|
|
|
drv->ni_overwrite = overwrite;
|
|
|
|
drv->ni_head = 0;
|
|
|
|
drv->ni_tail = 0;
|
|
|
|
drv->ni_read = 0;
|
|
|
|
|
|
|
|
ret = note_driver_register(&drv->driver);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
kmm_free(drv);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (devpath == NULL)
|
|
|
|
{
|
|
|
|
return &drv->driver;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = register_driver(devpath, &g_noteram_fops, 0666, drv);
|
|
|
|
if (ret < 0)
|
|
|
|
{
|
|
|
|
kmm_free(drv);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return &drv->driver;
|
|
|
|
}
|