/************************************************************************************
 * apps/system/sched_note/note_main.c
 *
 * 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
 *
 *   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.
 *
 ************************************************************************************/

/************************************************************************************
 * Included Files
 ************************************************************************************/

#include <nuttx/config.h>

#include <sys/types.h>
#include <stdbool.h>
#include <stdlib.h>
#include <inttypes.h>
#include <stdio.h>
#include <syslog.h>
#include <fcntl.h>
#include <errno.h>

#include <nuttx/sched_note.h>

/************************************************************************************
 * Pre-processor Definitions
 ************************************************************************************/

#ifdef CONFIG_SCHED_INSTRUMENTATION_HIRES
#  define syslog_time(priority, fmt, ...) \
            syslog(priority, "%08lx.%08lx: " fmt, \
                   (unsigned long)systime_sec, (unsigned long)systime_nsec, \
                   __VA_ARGS__)
#else
#  define syslog_time(priority, fmt, ...) \
            syslog(priority, "%08lx: " fmt, \
                   (unsigned long)systime, \
                   __VA_ARGS__)
#endif

/************************************************************************************
 * Private Data
 ************************************************************************************/

static bool g_note_daemon_started;
static uint8_t g_note_buffer[CONFIG_SYSTEM_NOTE_BUFFERSIZE];

/* Names of task/thread states */

#ifdef CONFIG_SCHED_INSTRUMENTATION_SWITCH
static FAR const char *g_statenames[] =
{
  "Invalid",
  "Waiting for Unlock",
  "Ready",
  "Running",
  "Inactive",
  "Waiting for Semaphore",
  "Waiting for Signal",
#ifndef CONFIG_DISABLE_MQUEUE
  "Waiting for MQ empty",
  "Waiting for MQ full"
#endif
};

#define NSTATES (sizeof(g_statenames)/sizeof(FAR const char *))
#endif

/************************************************************************************
 * Private Functions
 ************************************************************************************/

/************************************************************************************
 * Name: dump_notes
 ************************************************************************************/

static void dump_notes(size_t nread)
{
  FAR struct note_common_s *note;
#ifdef CONFIG_SCHED_INSTRUMENTATION_HIRES
  uint32_t systime_sec;
  uint32_t systime_nsec;
#else
  uint32_t systime;
#endif
  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);
#ifdef CONFIG_SCHED_INSTRUMENTATION_HIRES
      systime_nsec = (uint32_t)note->nc_systime_nsec[0] +
                     (uint32_t)(note->nc_systime_nsec[1] << 8) +
                     (uint32_t)(note->nc_systime_nsec[2] << 16) +
                     (uint32_t)(note->nc_systime_nsec[3] << 24);
      systime_sec = (uint32_t)note->nc_systime_sec[0] +
                    (uint32_t)(note->nc_systime_sec[1] << 8) +
                    (uint32_t)(note->nc_systime_sec[2] << 16) +
                    (uint32_t)(note->nc_systime_sec[3] << 24);
#else
      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);
#endif

      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_ERR,
                         "Note too small for \"Start\" note: %d\n",
                         note->nc_length);
                  return;
                }

#ifdef CONFIG_SMP
#if CONFIG_TASK_NAME_SIZE > 0
              syslog_time(LOG_INFO,
                     "Task %u \"%s\" started, CPU%u, priority %u\n",
                     (unsigned int)pid,
                     note_start->nst_name, (unsigned int)note->nc_cpu,
                     (unsigned int)note->nc_priority);
#else
              syslog_time(LOG_INFO,
                     "Task %u started, CPU%u, priority %u\n",
                     (unsigned int)pid,
                     (unsigned int)note->nc_cpu,
                     (unsigned int)note->nc_priority);
#endif
#else
#if CONFIG_TASK_NAME_SIZE > 0
              syslog_time(LOG_INFO,
                     "Task %u \"%s\" started, priority %u\n",
                     (unsigned int)pid,
                     note_start->nst_name, (unsigned int)note->nc_priority);
#else
              syslog_time(LOG_INFO,
                     "Task %u started, priority %u\n",
                     (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_ERR,
                         "Size incorrect for \"Stop\" note: %d\n",
                         note->nc_length);
                  return;
                }

#ifdef CONFIG_SMP
              syslog_time(LOG_INFO,
                     "Task %u stopped, CPU%u, priority %u\n",
                     (unsigned int)pid,
                     (unsigned int)note->nc_cpu, (unsigned int)note->nc_priority);
#else
              syslog_time(LOG_INFO,
                     "Task %u stopped, priority %u\n",
                     (unsigned int)pid,
                     (unsigned int)note->nc_priority);
#endif
            }
            break;

#ifdef CONFIG_SCHED_INSTRUMENTATION_SWITCH
          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_ERR,
                         "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_time(LOG_INFO,
                     "Task %u suspended, CPU%u, priority %u, state \"%s\"\n",
                     (unsigned int)pid,
                     (unsigned int)note->nc_cpu,
                     (unsigned int)note->nc_priority, statename);
#else
              syslog_time(LOG_INFO,
                     "Task %u suspended, priority %u, state \"%s\"\n",
                     (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_ERR,
                         "Size incorrect for \"Resume\" note: %d\n",
                         note->nc_length);
                  return;
                }

#ifdef CONFIG_SMP
              syslog_time(LOG_INFO,
                     "Task %u resumed, CPU%u, priority %u\n",
                     (unsigned int)pid,
                     (unsigned int)note->nc_cpu,
                     (unsigned int)note->nc_priority);
#else
              syslog_time(LOG_INFO,
                     "Task %u resumed, priority %u\n",
                     (unsigned int)pid,
                     (unsigned int)note->nc_priority);
#endif
            }
            break;
#endif

#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_ERR,
                         "Size incorrect for \"CPU Start\" note: %d\n",
                         note->nc_length);
                  return;
                }

              syslog_time(LOG_INFO,
                     "Task %u CPU%u requests CPU%u to start, priority %u\n",
                     (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_ERR,
                         "Size incorrect for \"CPU started\" note: %d\n",
                         note->nc_length);
                  return;
                }

              syslog_time(LOG_INFO,
                     "Task %u CPU%u has started, priority %u\n",
                     (unsigned int)pid,
                     (unsigned int)note->nc_cpu,
                     (unsigned int)note->nc_priority);
            }
            break;

#ifdef CONFIG_SCHED_INSTRUMENTATION_SWITCH
          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_ERR,
                         "Size incorrect for \"CPU pause\" note: %d\n",
                         note->nc_length);
                  return;
                }

              syslog_time(LOG_INFO,
                     "Task %u CPU%u requests CPU%u to pause, priority %u\n",
                     (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_ERR,
                         "Size incorrect for \"CPU paused\" note: %d\n",
                         note->nc_length);
                  return;
                }

              syslog_time(LOG_INFO,
                     "Task %u CPU%u has paused, priority %u\n",
                     (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_ERR,
                         "Size incorrect for \"CPU resume\" note: %d\n",
                         note->nc_length);
                  return;
                }

              syslog_time(LOG_INFO,
                     "Task %u CPU%u requests CPU%u to resume, priority %u\n",
                     (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_ERR,
                         "Size incorrect for \"CPU resumed\" note: %d\n",
                         note->nc_length);
                  return;
                }

              syslog_time(LOG_INFO,
                     "Task %u CPU%u has resumed, priority %u\n",
                     (unsigned int)pid,
                     (unsigned int)note->nc_cpu,
                     (unsigned int)note->nc_priority);
            }
            break;
#endif
#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_ERR,
                         "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_time(LOG_INFO,
                         "Task %u locked, CPU%u, priority %u, count=%u\n",
                         (unsigned int)pid,
                         (unsigned int)note->nc_cpu,
                         (unsigned int)note->nc_priority, (unsigned int)count);
#else
                  syslog_time(LOG_INFO,
                         "Task %u locked, priority %u, count=%u\n",
                         (unsigned int)pid,
                         (unsigned int)note->nc_priority, (unsigned int)count);
#endif
                }
              else
                {
#ifdef CONFIG_SMP
                  syslog_time(LOG_INFO,
                         "Task %u unlocked, CPU%u, priority %u, count=%u\n",
                         (unsigned int)pid,
                         (unsigned int)note->nc_cpu,
                         (unsigned int)note->nc_priority, (unsigned int)count);
#else
                  syslog_time(LOG_INFO,
                         "Task %u unlocked, priority %u, count=%u\n",
                         (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_ERR,
                         "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_time(LOG_INFO,
                         "Task %u enter csection, CPU%u, priority %u, "
                         "count=%u\n",
                         (unsigned int)pid,
                         (unsigned int)note->nc_cpu,
                         (unsigned int)note->nc_priority, (unsigned int)count);
                }
              else
                {
                  syslog_time(LOG_INFO,
                         "Task %u leave csection, CPU%u, priority %u, "
                         "count=%u\n",
                         (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_time(LOG_INFO, "Task %u enter csection, priority %u\n",
                       (unsigned int)pid,
                       (unsigned int)note->nc_priority);
                }
              else
                {
                  syslog_time(LOG_INFO, "Task %u leave csection, priority %u\n",
                       (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;
              FAR void *spinlock;

              if (note->nc_length != sizeof(struct note_spinlock_s))
                {
                  syslog(LOG_ERR,
                         "Size incorrect for \"Spinlock\" note: %d\n",
                         note->nc_length);
                  return;
                }

              spinlock = (FAR void *)
                            ((uintptr_t)note_spinlock->nsp_spinlock[0]
                             + ((uintptr_t)note_spinlock->nsp_spinlock[1] << 8)
#if UINTPTR_MAX > UINT16_MAX
                             + ((uintptr_t)note_spinlock->nsp_spinlock[2] << 16)
                             + ((uintptr_t)note_spinlock->nsp_spinlock[3] << 24)
#if UINTPTR_MAX > UINT32_MAX
                             + ((uintptr_t)note_spinlock->nsp_spinlock[4] << 32)
                             + ((uintptr_t)note_spinlock->nsp_spinlock[5] << 40)
                             + ((uintptr_t)note_spinlock->nsp_spinlock[6] << 48)
                             + ((uintptr_t)note_spinlock->nsp_spinlock[7] << 56)
#endif
#endif
                            );

             switch (note->nc_type)
               {
#ifdef CONFIG_SMP
                case NOTE_SPINLOCK_LOCK:
                  {
                    syslog_time(LOG_INFO,
                           "Task %u CPU%u wait for spinlock=%p value=%u "
                           "priority %u\n",
                           (unsigned int)pid,
                           (unsigned int)note->nc_cpu,
                           spinlock,
                           (unsigned int)note_spinlock->nsp_value,
                           (unsigned int)note->nc_priority);
                  }
                  break;

                case NOTE_SPINLOCK_LOCKED:
                  {
                    syslog_time(LOG_INFO,
                           "Task %u CPU%u has spinlock=%p value=%u "
                           "priority %u\n",
                           (unsigned int)pid,
                           (unsigned int)note->nc_cpu,
                           spinlock,
                           (unsigned int)note_spinlock->nsp_value,
                           (unsigned int)note->nc_priority);
                  }
                  break;

                case NOTE_SPINLOCK_UNLOCK:
                  {
                    syslog_time(LOG_INFO,
                           "Task %u CPU%u unlocking spinlock=%p value=%u "
                           "priority %u\n",
                           (unsigned int)pid,
                           (unsigned int)note->nc_cpu,
                           spinlock,
                           (unsigned int)note_spinlock->nsp_value,
                           (unsigned int)note->nc_priority);
                  }
                  break;

                case NOTE_SPINLOCK_ABORT:
                  {
                    syslog_time(LOG_INFO,
                           "Task %u CPU%u abort wait on spinlock=%p value=%u "
                           "priority %u\n",
                           (unsigned int)pid,
                           (unsigned int)note->nc_cpu,
                           spinlock,
                           (unsigned int)note_spinlock->nsp_value,
                           (unsigned int)note->nc_priority);
                  }
                  break;
#else
                case NOTE_SPINLOCK_LOCK:
                  {
                    syslog_time(LOG_INFO,
                           "Task %u wait for spinlock=%p value=%u "
                           "priority %u\n",
                           (unsigned int)pid,
                           spinlock,
                           (unsigned int)note_spinlock->nsp_value,
                           (unsigned int)note->nc_priority);
                  }
                  break;

                case NOTE_SPINLOCK_LOCKED:
                  {
                    syslog_time(LOG_INFO,
                           "Task %u has spinlock=%p value=%u priority %u\n",
                           (unsigned int)pid,
                           spinlock,
                           (unsigned int)note_spinlock->nsp_value,
                           (unsigned int)note->nc_priority);
                  }
                  break;

                case NOTE_SPINLOCK_UNLOCK:
                  {
                    syslog_time(LOG_INFO,
                           "Task %u unlocking spinlock=%p value=%u "
                           "priority %u\n",
                           (unsigned int)pid,
                           spinlock,
                           (unsigned int)note_spinlock->nsp_value,
                           (unsigned int)note->nc_priority);
                  }
                  break;

                case NOTE_SPINLOCK_ABORT:
                  {
                    syslog_time(LOG_INFO,
                           "Task %u abort wait on spinlock=%p value=%u "
                           "priority %u\n",
                           (unsigned int)pid,
                           spinlock,
                           (unsigned int)note_spinlock->nsp_value,
                           (unsigned int)note->nc_priority);
                  }
                  break;
#endif
               }
              break;
            }
#endif

#ifdef CONFIG_SCHED_INSTRUMENTATION_SYSCALL
                case NOTE_SYSCALL_ENTER:
                  {
                    FAR struct note_syscall_enter_s *note_sysenter =
                      (FAR struct note_syscall_enter_s *)note;

                    if (note->nc_length < SIZEOF_NOTE_SYSCALL_ENTER(0))
                      {
                        syslog(LOG_ERR,
                               "Size incorrect for \"SYSCALL enter\" note: %d\n",
                               note->nc_length);
                        return;
                      }

                    syslog_time(LOG_INFO,
                           "Task %u Enter SYSCALL %d\n",
                           (unsigned int)pid,
                           note_sysenter->nsc_nr);
                  }
                  break;

                case NOTE_SYSCALL_LEAVE:
                  {
                    FAR struct note_syscall_leave_s *note_sysleave =
                      (FAR struct note_syscall_leave_s *)note;
                    uintptr_t result;

                    if (note->nc_length != sizeof(struct note_syscall_leave_s))
                      {
                        syslog(LOG_ERR,
                               "Size incorrect for \"SYSCALL leave\" note: %d\n",
                               note->nc_length);
                        return;
                      }

                    result =    (uintptr_t)note_sysleave->nsc_result[0]
                             + ((uintptr_t)note_sysleave->nsc_result[1] << 8)
#if UINTPTR_MAX > UINT16_MAX
                             + ((uintptr_t)note_sysleave->nsc_result[2] << 16)
                             + ((uintptr_t)note_sysleave->nsc_result[3] << 24)
#if UINTPTR_MAX > UINT32_MAX
                             + ((uintptr_t)note_sysleave->nsc_result[4] << 32)
                             + ((uintptr_t)note_sysleave->nsc_result[5] << 40)
                             + ((uintptr_t)note_sysleave->nsc_result[6] << 48)
                             + ((uintptr_t)note_sysleave->nsc_result[7] << 56)
#endif
#endif
                    ;

                    syslog_time(LOG_INFO,
                           "Task %u Leave SYSCALL %d: %" PRIdPTR "\n",
                           (unsigned int)pid,
                           note_sysleave->nsc_nr, result);
                  }
                  break;
#endif

#ifdef CONFIG_SCHED_INSTRUMENTATION_IRQHANDLER
                case NOTE_IRQ_ENTER:
                case NOTE_IRQ_LEAVE:
                  {
                    FAR struct note_irqhandler_s *note_irq =
                      (FAR struct note_irqhandler_s *)note;

                    if (note->nc_length != sizeof(struct note_irqhandler_s))
                      {
                        syslog(LOG_ERR,
                               "Size incorrect for \"IRQ\" note: %d\n",
                               note->nc_length);
                        return;
                      }

                    syslog_time(LOG_INFO,
                           "Task %u %s IRQ %d\n",
                           (unsigned int)pid,
                           note->nc_type == NOTE_IRQ_ENTER ? "Enter" : "Leave",
                           note_irq->nih_irq);
                  }
                  break;
#endif

#ifdef CONFIG_SCHED_INSTRUMENTATION_DUMP
                case NOTE_DUMP_STRING:
                  {
                    FAR struct note_string_s *note_string =
                      (FAR struct note_string_s *)note;

                    if (note->nc_length < sizeof(struct note_string_s))
                      {
                        syslog(LOG_INFO,
                               "ERROR: note too small for string note: %d\n",
                               note->nc_length);
                        return;
                      }

                    syslog_time(LOG_INFO,
                           "Task %u priority %u, string:%s\n",
                           (unsigned int)pid,
                           (unsigned int)note->nc_priority,
                           note_string->nst_data);
                  }
                  break;

                case NOTE_DUMP_BINARY:
                  {
                    FAR struct note_binary_s *note_binary =
                      (FAR struct note_binary_s *)note;
                    char out[1280];
                    int count;
                    int ret = 0;
                    int i;

                    count = note->nc_length - sizeof(struct note_binary_s) + 1;

                    if (count < 0)
                      {
                        syslog(LOG_INFO,
                               "ERROR: note too small for binary note: %d\n",
                               note->nc_length);
                        return;
                      }

                    for (i = 0; i < count; i++)
                      {
                        ret += sprintf(&out[ret], " 0x%x", note_binary->nbi_data[i]);
                      }

                    syslog_time(LOG_INFO,
                           "Task %u priority %u, binary:module=%c%c%c%c "
                            "event=%u count=%u%s\n",
                           (unsigned int)pid,
                           (unsigned int)note->nc_priority,
                           note_binary->nbi_module[0],
                           note_binary->nbi_module[1],
                           note_binary->nbi_module[2],
                           note_binary->nbi_module[3],
                           note_binary->nbi_event,
                           count,
                           out);
                  }
                  break;
#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_ERR, "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);
    }

  close(fd);

errout:
  g_note_daemon_started = false;

  syslog(LOG_INFO, "note_daemon: Terminating\n");
  return EXIT_FAILURE;
}

/************************************************************************************
 * Public Functions
 ************************************************************************************/

/************************************************************************************
 * Name: note_main
 ************************************************************************************/

int main(int argc, FAR char *argv[])
{
  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;
}
