675 lines
24 KiB
C
675 lines
24 KiB
C
/****************************************************************************
|
|
* system/note/note_main.c
|
|
*
|
|
* Copyright (C) 2016 Gregory Nutt. All rights reserved.
|
|
* Author: Gregory Nutt <gnutt@nuttx.org>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. 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.
|
|
* 3. Neither the name NuttX 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 IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <syslog.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
|
|
#include <nuttx/sched_note.h>
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
static bool g_note_daemon_started;
|
|
static uint8_t g_note_buffer[CONFIG_SYSTEM_NOTE_BUFFERSIZE];
|
|
|
|
/* Names of task/thread states */
|
|
|
|
static FAR const char *g_statenames[] =
|
|
{
|
|
"Invalid",
|
|
"Waiting for Unlock",
|
|
"Ready",
|
|
"Running",
|
|
"Inactive",
|
|
"Waiting for Semaphore",
|
|
#ifndef CONFIG_DISABLE_SIGNALS
|
|
"Waiting for Signal",
|
|
#endif
|
|
#ifndef CONFIG_DISABLE_MQUEUE
|
|
"Waiting for MQ empty",
|
|
"Waiting for MQ full"
|
|
#endif
|
|
};
|
|
|
|
#define NSTATES (sizeof(g_statenames)/sizeof(FAR const char *))
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: dump_notes
|
|
****************************************************************************/
|
|
|
|
static void dump_notes(size_t nread)
|
|
{
|
|
FAR struct note_common_s *note;
|
|
uint32_t systime;
|
|
pid_t pid;
|
|
off_t offset;
|
|
|
|
offset = 0;
|
|
while (offset < nread)
|
|
{
|
|
note = (FAR struct note_common_s *)&g_note_buffer[offset];
|
|
pid = (pid_t)note->nc_pid[0] +
|
|
((pid_t)note->nc_pid[1] << 8);
|
|
systime = (uint32_t) note->nc_systime[0] +
|
|
(uint32_t)(note->nc_systime[1] << 8) +
|
|
(uint32_t)(note->nc_systime[2] << 16) +
|
|
(uint32_t)(note->nc_systime[3] << 24);
|
|
|
|
switch (note->nc_type)
|
|
{
|
|
case NOTE_START:
|
|
{
|
|
FAR struct note_start_s *note_start =
|
|
(FAR struct note_start_s *)note;
|
|
|
|
if (note->nc_length < sizeof(struct note_start_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note too small for start note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
#ifdef CONFIG_SMP
|
|
#if CONFIG_TASK_NAME_SIZE > 0
|
|
syslog(LOG_INFO, "%08lx: Task %u \"%s\" started, CPU%u, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
note_start->nst_name, (unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority);
|
|
#else
|
|
syslog(LOG_INFO, "%08lx: Task %u started, CPU%u, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority);
|
|
#endif
|
|
#else
|
|
#if CONFIG_TASK_NAME_SIZE > 0
|
|
syslog(LOG_INFO, "%08lx: Task %u \"%s\" started, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
note_start->nst_name, (unsigned int)note->nc_priority);
|
|
#else
|
|
syslog(LOG_INFO, "%08lx: Task %u started, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_priority);
|
|
#endif
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case NOTE_STOP:
|
|
{
|
|
if (note->nc_length != sizeof(struct note_stop_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for stop note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
#ifdef CONFIG_SMP
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u stopped, CPU%u, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu, (unsigned int)note->nc_priority);
|
|
#else
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u stopped, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_priority);
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case NOTE_SUSPEND:
|
|
{
|
|
FAR struct note_suspend_s *note_suspend =
|
|
(FAR struct note_suspend_s *)note;
|
|
FAR const char *statename;
|
|
|
|
if (note->nc_length != sizeof(struct note_suspend_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for suspend note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
if (note_suspend->nsu_state < NSTATES)
|
|
{
|
|
statename = g_statenames[note_suspend->nsu_state];
|
|
}
|
|
else
|
|
{
|
|
statename = "ERROR";
|
|
}
|
|
|
|
#ifdef CONFIG_SMP
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u suspended, CPU%u, priority %u, state \"%s\"\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority, statename);
|
|
#else
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u suspended, priority %u, state \"%s\"\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_priority, statename);
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case NOTE_RESUME:
|
|
{
|
|
if (note->nc_length != sizeof(struct note_resume_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for resume note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
#ifdef CONFIG_SMP
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u resumed, CPU%u, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority);
|
|
#else
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u resumed, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_priority);
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
#ifdef CONFIG_SMP
|
|
case NOTE_CPU_START:
|
|
{
|
|
FAR struct note_cpu_start_s *note_start =
|
|
(FAR struct note_cpu_start_s *)note;
|
|
|
|
if (note->nc_length != sizeof(struct note_cpu_start_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for CPU start note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u requests CPU%u to start, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note_start->ncs_target,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_CPU_STARTED:
|
|
{
|
|
if (note->nc_length != sizeof(struct note_cpu_started_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for CPU started note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u has started, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_CPU_PAUSE:
|
|
{
|
|
FAR struct note_cpu_pause_s *note_pause =
|
|
(FAR struct note_cpu_pause_s *)note;
|
|
|
|
if (note->nc_length != sizeof(struct note_cpu_pause_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for CPU pause note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u requests CPU%u to pause, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note_pause->ncp_target,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_CPU_PAUSED:
|
|
{
|
|
if (note->nc_length != sizeof(struct note_cpu_paused_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for CPU paused note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u has paused, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_CPU_RESUME:
|
|
{
|
|
FAR struct note_cpu_resume_s *note_resume =
|
|
(FAR struct note_cpu_resume_s *)note;
|
|
|
|
if (note->nc_length != sizeof(struct note_cpu_resume_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for CPU resume note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u requests CPU%u to resume, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note_resume->ncr_target,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_CPU_RESUMED:
|
|
{
|
|
if (note->nc_length != sizeof(struct note_cpu_resumed_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for CPU resumed note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u has resumed, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_PREEMPTION
|
|
case NOTE_PREEMPT_LOCK:
|
|
case NOTE_PREEMPT_UNLOCK:
|
|
{
|
|
FAR struct note_preempt_s *note_preempt =
|
|
(FAR struct note_preempt_s *)note;
|
|
uint16_t count;
|
|
|
|
if (note->nc_length != sizeof(struct note_preempt_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for preemption note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
count = (uint16_t) note_preempt->npr_count[0] +
|
|
(uint16_t)(note_preempt->npr_count[1] << 8);
|
|
|
|
if (note->nc_type == NOTE_PREEMPT_LOCK)
|
|
{
|
|
#ifdef CONFIG_SMP
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u locked, CPU%u, priority %u, count=%u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority, (unsigned int)count);
|
|
#else
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u locked, priority %u, count=%u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_priority, (unsigned int)count);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#ifdef CONFIG_SMP
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u unlocked, CPU%u, priority %u, count=%u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority, (unsigned int)count);
|
|
#else
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u unlocked, priority %u, count=%u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_priority, (unsigned int)count);
|
|
#endif
|
|
}
|
|
}
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_CSECTION
|
|
case NOTE_CSECTION_ENTER:
|
|
case NOTE_CSECTION_LEAVE:
|
|
{
|
|
#ifdef CONFIG_SMP
|
|
FAR struct note_csection_s *note_csection =
|
|
(FAR struct note_csection_s *)note;
|
|
uint16_t count;
|
|
#endif
|
|
|
|
if (note->nc_length != sizeof(struct note_csection_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for csection note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
#ifdef CONFIG_SMP
|
|
count = (uint16_t) note_csection->ncs_count[0] +
|
|
(uint16_t)(note_csection->ncs_count[1] << 8);
|
|
|
|
if (note->nc_type == NOTE_CSECTION_ENTER)
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u enter csection, CPU%u, priority %u, count=%u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority, (unsigned int)count);
|
|
}
|
|
else
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u leave csection, CPU%u, priority %u, count=%u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note->nc_priority, (unsigned int)count);
|
|
}
|
|
#else
|
|
if (note->nc_type == NOTE_CSECTION_ENTER)
|
|
{
|
|
syslog(LOG_INFO, "%08lx: Task %u enter csection, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
else
|
|
{
|
|
syslog(LOG_INFO, "%08lx: Task %u leave csection, priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
#endif
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHED_INSTRUMENTATION_SPINLOCKS
|
|
case NOTE_SPINLOCK_LOCK:
|
|
case NOTE_SPINLOCK_LOCKED:
|
|
case NOTE_SPINLOCK_UNLOCK:
|
|
case NOTE_SPINLOCK_ABORT:
|
|
{
|
|
FAR struct note_spinlock_s *note_spinlock =
|
|
(FAR struct note_spinlock_s *)note;
|
|
|
|
if (note->nc_length != sizeof(struct note_spinlock_s))
|
|
{
|
|
syslog(LOG_INFO,
|
|
"ERROR: note size incorrect for spinlock note: %d\n",
|
|
note->nc_length);
|
|
return;
|
|
}
|
|
|
|
switch (note->nc_type)
|
|
{
|
|
#ifdef CONFIG_SMP
|
|
case NOTE_SPINLOCK_LOCK:
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u wait for spinlock=%p value=%u priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
note_spinlock->nsp_spinlock,
|
|
(unsigned int)note_spinlock->nsp_value,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_SPINLOCK_LOCKED:
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u has spinlock=%p value=%u priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
note_spinlock->nsp_spinlock,
|
|
(unsigned int)note_spinlock->nsp_value,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_SPINLOCK_UNLOCK:
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u unlocking spinlock=%p value=%u priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
note_spinlock->nsp_spinlock,
|
|
(unsigned int)note_spinlock->nsp_value,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_SPINLOCK_ABORT:
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u CPU%u abort wait on spinlock=%p value=%u priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
note_spinlock->nsp_spinlock,
|
|
(unsigned int)note_spinlock->nsp_value,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
#else
|
|
case NOTE_SPINLOCK_LOCK:
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u wait for spinlock=%p value=%u priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
note_spinlock->nsp_spinlock,
|
|
(unsigned int)note_spinlock->nsp_value,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_SPINLOCK_LOCKED:
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u has spinlock=%p value=%u priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
note_spinlock->nsp_spinlock,
|
|
(unsigned int)note_spinlock->nsp_value,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_SPINLOCK_UNLOCK:
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u unlocking spinlock=%p value=%u priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
(unsigned int)note->nc_cpu,
|
|
(unsigned int)note_spinlock->nsp_value,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
|
|
case NOTE_SPINLOCK_ABORT:
|
|
{
|
|
syslog(LOG_INFO,
|
|
"%08lx: Task %u abort wait on spinlock=%p value=%u priority %u\n",
|
|
(unsigned long)systime, (unsigned int)pid,
|
|
note_spinlock->nsp_spinlock,
|
|
(unsigned int)note_spinlock->nsp_value,
|
|
(unsigned int)note->nc_priority);
|
|
}
|
|
break;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
default:
|
|
syslog(LOG_INFO, "Unrecognized note type: %d\n", note->nc_type);
|
|
return;
|
|
}
|
|
|
|
offset += note->nc_length;
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: note_daemon
|
|
****************************************************************************/
|
|
|
|
static int note_daemon(int argc, char *argv[])
|
|
{
|
|
ssize_t nread;
|
|
int fd;
|
|
|
|
/* Indicate that we are running */
|
|
|
|
g_note_daemon_started = true;
|
|
syslog(LOG_INFO, "note_daemon: Running\n");
|
|
|
|
/* Open the note driver */
|
|
|
|
syslog(LOG_INFO, "note_daemon: Opening /dev/note\n");
|
|
fd = open("/dev/note", O_RDONLY);
|
|
if (fd < 0)
|
|
{
|
|
int errcode = errno;
|
|
syslog(LOG_INFO, "note_daemon: ERROR: Failed to open /dev/note: %d\n",
|
|
errcode);
|
|
goto errout;
|
|
}
|
|
|
|
/* Now loop forever, dumping note data to the display */
|
|
|
|
for (; ; )
|
|
{
|
|
nread = read(fd, g_note_buffer, CONFIG_SYSTEM_NOTE_BUFFERSIZE);
|
|
if (nread > 0)
|
|
{
|
|
dump_notes(nread);
|
|
}
|
|
|
|
usleep(CONFIG_SYSTEM_NOTE_DELAY * 1000L);
|
|
}
|
|
|
|
(void)close(fd);
|
|
|
|
errout:
|
|
g_note_daemon_started = false;
|
|
|
|
syslog(LOG_INFO, "note_daemon: Terminating\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* note_main
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_BUILD_KERNEL
|
|
int main(int argc, FAR char *argv[])
|
|
#else
|
|
int note_main(int argc, FAR char *argv[])
|
|
#endif
|
|
{
|
|
int ret;
|
|
|
|
printf("note_main: Starting the note_daemon\n");
|
|
if (g_note_daemon_started)
|
|
{
|
|
printf("note_main: note_daemon already running\n");
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
ret = task_create("note_daemon", CONFIG_SYSTEM_NOTE_PRIORITY,
|
|
CONFIG_SYSTEM_NOTE_STACKSIZE, note_daemon,
|
|
NULL);
|
|
if (ret < 0)
|
|
{
|
|
int errcode = errno;
|
|
printf("note_main: ERROR: Failed to start note_daemon: %d\n",
|
|
errcode);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
printf("note_main: note_daemon started\n");
|
|
return EXIT_SUCCESS;
|
|
}
|