sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Some renaming so that future features will fit in better; If the architecture provides its only system logging (via CONFIG_ARCH_SYSLOG), then syslog_initialize() is stubbed out

Browse Source
This commit is contained in:
Gregory Nutt 2016-06-19 11:16:12 -06:00
parent 99ad3e9bcf
commit 9f260ca193
6 changed files with 80 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/arm/src/armv7-m/Kconfig
View File

@ -160,7 +160,7 @@ config ARMV7M_STACKCHECK
config ARMV7M_ITMSYSLOG
bool "ITM SYSLOG support"
default n
select ARCH_HAVE_SYSLOG
select ARCH_SYSLOG
select SYSLOG
---help---
Enable hooks to support ITM syslog output. This requires additional

6
drivers/syslog/Kconfig
View File

@ -7,7 +7,7 @@ comment "System Logging"
# Selected if the architecture has its own, built-in SYSLOGgin enabled
config ARCH_HAVE_SYSLOG
config ARCH_SYSLOG
bool
default n
@ -29,7 +29,7 @@ if RAMLOG
config RAMLOG_SYSLOG
bool "Use RAMLOG for SYSLOG"
default n
depends on SYSLOG && !ARCH_HAVE_SYSLOG
depends on SYSLOG && !ARCH_SYSLOG
---help---
Use the RAM logging device for the syslogging interface. If this feature
is enabled (along with SYSLOG), then all debug output (only) will be re-directed
@ -107,7 +107,7 @@ if SYSLOG
config SYSLOG_CHAR
bool "System log character device support"
default y
depends on !ARCH_HAVE_SYSLOG
depends on !ARCH_SYSLOG
---help---
Enable the generic character device for the SYSLOG. The full path to the
SYSLOG device is provided by SYSLOG_DEVPATH. A valid character device (or

4
drivers/syslog/Make.defs
View File

@ -39,6 +39,10 @@
CSRCS += syslog_initialize.c vsyslog.c vlowsyslog.c syslogstream.c
ifneq ($(CONFIG_ARCH_SYSLOG),y)
CSRCS += syslog_initialize.c
endif
# The note driver is hosted in this directory, but is not associated with
# SYSLOGging

86
drivers/syslog/syslog_device.c
View File

@ -76,7 +76,7 @@
/* This enumeration represents the state of the SYSLOG device interface */
enum syslog_state_e
enum syslog_dev_state
{
SYSLOG_UNINITIALIZED = 0, /* SYSLOG has not been initialized */
SYSLOG_INITIALIZING, /* SYSLOG is being initialized */
@ -89,7 +89,7 @@ enum syslog_state_e
struct syslog_dev_s
{
uint8_t sl_state; /* See enum syslog_state_e */
uint8_t sl_state; /* See enum syslog_dev_state */
sem_t sl_sem; /* Enforces mutually exclusive access */
pid_t sl_holder; /* PID of the thread that holds the semaphore */
struct file sl_file; /* The syslog file structure */
@ -101,7 +101,7 @@ struct syslog_dev_s
/* This is the device structure for the console or syslogging function. */
static struct syslog_dev_s g_sysdev;
static struct syslog_dev_s g_syslog_dev;
static const uint8_t g_syscrlf[2] =
{
'\r', '\n'
@ -112,25 +112,25 @@ static const uint8_t g_syscrlf[2] =
****************************************************************************/
/****************************************************************************
* Name: syslog_takesem
* Name: syslog_dev_takesem
*
* Description:
* Write to the syslog device
*
****************************************************************************/
static inline int syslog_takesem(void)
static inline int syslog_dev_takesem(void)
{
pid_t me = getpid();
int ret;
/* Does this thread already hold the semaphore? That could happen if
* we wer called recursively, i.e., if the logic kicked off by
* syslog_write() where to generate more debug output. Return an error
* syslog_dev_write() where to generate more debug output. Return an error
* in that case.
*/
if (g_sysdev.sl_holder == me)
if (g_syslog_dev.sl_holder == me)
{
/* Return an error (instead of deadlocking) */
@ -141,7 +141,7 @@ static inline int syslog_takesem(void)
* thread. Wait for it to become available.
*/
ret = sem_wait(&g_sysdev.sl_sem);
ret = sem_wait(&g_syslog_dev.sl_sem);
if (ret < 0)
{
return -get_errno();
@ -151,53 +151,53 @@ static inline int syslog_takesem(void)
* of the semaphore.
*/
g_sysdev.sl_holder = me;
g_syslog_dev.sl_holder = me;
return OK;
}
/****************************************************************************
* Name: syslog_givesem
* Name: syslog_dev_givesem
*
* Description:
* Write to the syslog device
*
****************************************************************************/
static inline void syslog_givesem(void)
static inline void syslog_dev_givesem(void)
{
#ifdef CONFIG_DEBUG_ASSERTIONS
pid_t me = getpid();
DEBUGASSERT(g_sysdev.sl_holder == me);
DEBUGASSERT(g_syslog_dev.sl_holder == me);
#endif
/* Relinquish the semaphore */
g_sysdev.sl_holder = NO_HOLDER;
sem_post(&g_sysdev.sl_sem);
g_syslog_dev.sl_holder = NO_HOLDER;
sem_post(&g_syslog_dev.sl_sem);
}
/****************************************************************************
* Name: syslog_write
* Name: syslog_dev_write
*
* Description:
* Write to the syslog device
*
****************************************************************************/
static inline ssize_t syslog_write(FAR const void *buf, size_t nbytes)
static inline ssize_t syslog_dev_write(FAR const void *buf, size_t nbytes)
{
FAR struct inode *inode;
/* Let the driver perform the write */
inode = g_sysdev.sl_file.f_inode;
inode = g_syslog_dev.sl_file.f_inode;
DEBUGASSERT(inode != NULL);
return inode->u.i_ops->write(&g_sysdev.sl_file, buf, nbytes);
return inode->u.i_ops->write(&g_syslog_dev.sl_file, buf, nbytes);
}
/****************************************************************************
* Name: syslog_flush
* Name: syslog_dev_flush
*
* Description:
* Flush any buffer data in the file system to media.
@ -205,9 +205,9 @@ static inline ssize_t syslog_write(FAR const void *buf, size_t nbytes)
****************************************************************************/
#ifndef CONFIG_DISABLE_MOUNTPOINT
static inline void syslog_flush(void)
static inline void syslog_dev_flush(void)
{
FAR struct inode *inode = g_sysdev.sl_file.f_inode;
FAR struct inode *inode = g_syslog_dev.sl_file.f_inode;
/* Is this a mountpoint? Does it support the sync method? */
@ -216,7 +216,7 @@ static inline void syslog_flush(void)
{
/* Yes... synchronize to the stream */
(void)inode->u.i_mops->sync(&g_sysdev.sl_file);
(void)inode->u.i_mops->sync(&g_syslog_dev.sl_file);
}
}
#endif
@ -259,10 +259,10 @@ int syslog_dev_initialize(void)
* SYSLOG_REOPEN.. Not SYSLOG_INITIALIZING, SYSLOG_FAILURE, SYSLOG_OPENED.
*/
DEBUGASSERT(g_sysdev.sl_state == SYSLOG_UNINITIALIZED ||
g_sysdev.sl_state == SYSLOG_REOPEN);
DEBUGASSERT(g_syslog_dev.sl_state == SYSLOG_UNINITIALIZED ||
g_syslog_dev.sl_state == SYSLOG_REOPEN);
g_sysdev.sl_state = SYSLOG_INITIALIZING;
g_syslog_dev.sl_state = SYSLOG_INITIALIZING;
/* Open the device driver. */
@ -282,7 +282,7 @@ int syslog_dev_initialize(void)
* not yet been installed.
*/
g_sysdev.sl_state = SYSLOG_REOPEN;
g_syslog_dev.sl_state = SYSLOG_REOPEN;
return -errcode;
}
@ -291,23 +291,23 @@ int syslog_dev_initialize(void)
* descriptor allows us to use the device on all threads in all tasks.
*/
ret = file_detach(fd, &g_sysdev.sl_file);
ret = file_detach(fd, &g_syslog_dev.sl_file);
if (ret < 0)
{
/* This should not happen and means that something very bad has
* occurred.
*/
g_sysdev.sl_state = SYSLOG_FAILURE;
g_syslog_dev.sl_state = SYSLOG_FAILURE;
close(fd);
return ret;
}
/* The SYSLOG device is open and ready for writing. */
sem_init(&g_sysdev.sl_sem, 0, 1);
g_sysdev.sl_holder = NO_HOLDER;
g_sysdev.sl_state = SYSLOG_OPENED;
sem_init(&g_syslog_dev.sl_sem, 0, 1);
g_syslog_dev.sl_holder = NO_HOLDER;
g_syslog_dev.sl_state = SYSLOG_OPENED;
return OK;
}
@ -368,12 +368,12 @@ int syslog_putc(int ch)
* has been successfully opened.
*/
if (g_sysdev.sl_state != SYSLOG_OPENED)
if (g_syslog_dev.sl_state != SYSLOG_OPENED)
{
/* Case (1) and (2) */
if (g_sysdev.sl_state == SYSLOG_UNINITIALIZED ||
g_sysdev.sl_state == SYSLOG_INITIALIZING)
if (g_syslog_dev.sl_state == SYSLOG_UNINITIALIZED ||
g_syslog_dev.sl_state == SYSLOG_INITIALIZING)
{
errcode = EAGAIN; /* Can't access the SYSLOG now... maybe next time? */
goto errout_with_errcode;
@ -381,7 +381,7 @@ int syslog_putc(int ch)
/* Case (6) */
if (g_sysdev.sl_state == SYSLOG_FAILURE)
if (g_syslog_dev.sl_state == SYSLOG_FAILURE)
{
errcode = ENXIO; /* There is no SYSLOG device */
goto errout_with_errcode;
@ -399,7 +399,7 @@ int syslog_putc(int ch)
*/
sched_lock();
if (g_sysdev.sl_state == SYSLOG_REOPEN)
if (g_syslog_dev.sl_state == SYSLOG_REOPEN)
{
/* Try again to initialize the device. We may do this repeatedly
* because the log device might be something that was not ready
@ -418,7 +418,7 @@ int syslog_putc(int ch)
}
sched_unlock();
DEBUGASSERT(g_sysdev.sl_state == SYSLOG_OPENED);
DEBUGASSERT(g_syslog_dev.sl_state == SYSLOG_OPENED);
}
/* Ignore carriage returns */
@ -432,11 +432,11 @@ int syslog_putc(int ch)
* value to write.
*/
ret = syslog_takesem();
ret = syslog_dev_takesem();
if (ret < 0)
{
/* We probably already hold the semaphore and were probably
* re-entered by the logic kicked off by syslog_write().
* re-entered by the logic kicked off by syslog_dev_write().
* We might also have been interrupted by a signal. Either
* way, we are outta here.
*/
@ -451,7 +451,7 @@ int syslog_putc(int ch)
{
/* Write the CR-LF sequence */
nbytes = syslog_write(g_syscrlf, 2);
nbytes = syslog_dev_write(g_syscrlf, 2);
/* Synchronize the file when each CR-LF is encountered (i.e.,
* implements line buffering always).
@ -460,7 +460,7 @@ int syslog_putc(int ch)
#ifndef CONFIG_DISABLE_MOUNTPOINT
if (nbytes > 0)
{
syslog_flush();
syslog_dev_flush();
}
#endif
}
@ -469,10 +469,10 @@ int syslog_putc(int ch)
/* Write the non-newline character (and don't flush) */
uch = (uint8_t)ch;
nbytes = syslog_write(&uch, 1);
nbytes = syslog_dev_write(&uch, 1);
}
syslog_givesem();
syslog_dev_givesem();
/* Check if the write was successful. If not, nbytes will be
* a negated errno value.

15
drivers/syslog/syslog_initialize.c
View File

@ -45,6 +45,8 @@
#include "syslog.h"
#ifndef CONFIG_ARCH_SYSLOG
/****************************************************************************
* Public Functions
****************************************************************************/
@ -54,10 +56,19 @@
*
* Description:
* One power up, the SYSLOG facility is non-existent or limited to very
* low-level output. This function is called later in the intialization
* low-level output. This function is called later in the initialization
* sequence after full driver support has been initialized. It installs
* the configured SYSLOG drivers and enables full SYSLOGing capability.
*
* This function performs these basic operations:
*
* - Initialize the SYSLOG device
* - Call syslog_channel() to begin using that device.
*
* If CONFIG_ARCH_SYSLOG is selected, then the architecture-specifica
* logic will provide its own SYSLOG device initialize which must include
* as a minimum a call to syslog_channel() to use the device.
*
* Input Parameters:
* None
*
@ -92,3 +103,5 @@ int syslog_initialize(void)
return ret;
}
#endif /* CONFIG_ARCH_SYSLOG */

16
include/nuttx/syslog/syslog.h
View File

@ -97,15 +97,25 @@ extern "C"
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
/****************************************************************************
* Name: syslog_initialize
*
* Description:
* One power up, the SYSLOG facility is non-existent or limited to very
* low-level output. This function is called later in the intialization
* low-level output. This function is called later in the initialization
* sequence after full driver support has been initialized. It installs
* the configured SYSLOG drivers and enables full SYSLOGing capability.
*
* This function performs these basic operations:
*
* - Initialize the SYSLOG device
* - Call syslog_channel() to begin using that device.
*
* If CONFIG_ARCH_SYSLOG is selected, then the architecture-specifica
* logic will provide its own SYSLOG device initialize which must include
* as a minimum a call to syslog_channel() to use the device.
*
* Input Parameters:
* None
*
@ -115,7 +125,11 @@ extern "C"
*
****************************************************************************/
#ifndef CONFIG_ARCH_SYSLOG
int syslog_initialize(void);
#else
# define syslog_initialize()
#endif
/****************************************************************************
* Name: syslog_putc