#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include "adjustment.h"
#include "dbDefs.h"
#include "epicsThread.h"
#include "cantProceed.h"
#include "epicsMutex.h"
#include "epicsEvent.h"
#include "epicsInterrupt.h"
#include "errMdef.h"
#include "errSymTbl.h"
#include "ellLib.h"
#include "errlog.h"
#include "epicsStdio.h"
#include "epicsExit.h"

Include dependency graph for errlog.c:

Classes
struct	listenerNode

struct	msgNode

struct	initArgs

Macros
#define	ERRLOG_INIT

#define	BUFFER_SIZE 1280

#define	MAX_MESSAGE_SIZE 256

Typedefs
typedef struct listenerNode	listenerNode

typedef struct msgNode	msgNode

Functions
int	errlogPrintf (const char *pFormat,...)

int	errlogVprintf (const char *pFormat, va_list pvar)

int	errlogMessage (const char *message)

int	errlogPrintfNoConsole (const char *pFormat,...)

int	errlogVprintfNoConsole (const char *pFormat, va_list pvar)

int	errlogSevPrintf (errlogSevEnum severity, const char *pFormat,...)

int	errlogSevVprintf (errlogSevEnum severity, const char *pFormat, va_list pvar)

const char *	errlogGetSevEnumString (errlogSevEnum severity)

void	errlogSetSevToLog (errlogSevEnum severity)

errlogSevEnum	errlogGetSevToLog (void)

void	errlogAddListener (errlogListener listener, void *pPrivate)

int	errlogRemoveListeners (errlogListener listener, void *pPrivate)

int	eltc (int yesno)

int	errlogSetConsole (FILE *stream)

void	errPrintf (long status, const char pFileName, int lineno, const char pformat,...)

int	errlogInit2 (int bufsize, int maxMsgSize)

int	errlogInit (int bufsize)

void	errlogFlush (void)

Variables
int	errVerbose = 0

Macro Definition Documentation

#define BUFFER_SIZE 1280

Definition at line 37 of file errlog.c.

#define ERRLOG_INIT

Definition at line 21 of file errlog.c.

#define MAX_MESSAGE_SIZE 256

Definition at line 38 of file errlog.c.

Typedef Documentation

typedef struct listenerNode listenerNode

typedef struct msgNode msgNode

Function Documentation

int eltc ( int yesno )

Definition at line 368 of file errlog.c.

 {
     errlogInit(0);
     errlogFlush();
     pvtData.toConsole = yesno;
     return 0;
 }

void errlogAddListener	(	errlogListener	listener,
		void *	pPrivate
	)

Definition at line 317 of file errlog.c.

 {
     listenerNode *plistenerNode;
 
     errlogInit(0);
     if (pvtData.atExit)
         return;
 
     plistenerNode = callocMustSucceed(1,sizeof(listenerNode),
         "errlogAddListener");
     epicsMutexMustLock(pvtData.listenerLock);
     plistenerNode->listener = listener;
     plistenerNode->pPrivate = pPrivate;
     ellAdd(&pvtData.listenerList,&plistenerNode->node);
     epicsMutexUnlock(pvtData.listenerLock);
 }

void errlogFlush ( void )

Definition at line 529 of file errlog.c.

 {
     int count;
 
     errlogInit(0);
     if (pvtData.atExit)
         return;
 
    /*If nothing in queue dont wake up errlogThread*/
     epicsMutexMustLock(pvtData.msgQueueLock);
     count = ellCount(&pvtData.msgQueue);
     epicsMutexUnlock(pvtData.msgQueueLock);
     if (count <= 0)
         return;
 
     /*must let errlogThread empty queue*/
     epicsMutexMustLock(pvtData.flushLock);
     epicsEventSignal(pvtData.flush);
     epicsEventSignal(pvtData.waitForWork);
     epicsEventMustWait(pvtData.waitForFlush);
     epicsMutexUnlock(pvtData.flushLock);
 }

const char* errlogGetSevEnumString ( errlogSevEnum severity )

Definition at line 297 of file errlog.c.

 {
     errlogInit(0);
     if (severity > 3)
         return "unknown";
     return errlogSevEnumString[severity];
 }

errlogSevEnum errlogGetSevToLog ( void )

Definition at line 311 of file errlog.c.

 {
     errlogInit(0);
     return pvtData.sevToLog;
 }

int errlogInit ( int bufsize )

Definition at line 524 of file errlog.c.

 {
     return errlogInit2(bufsize, MAX_MESSAGE_SIZE);
 }

int errlogInit2	(	int	bufsize,
		int	maxMsgSize
	)

Definition at line 500 of file errlog.c.

 {
     static epicsThreadOnceId errlogOnceFlag = EPICS_THREAD_ONCE_INIT;
     struct initArgs config;
 
     if (pvtData.atExit)
         return 0;
 
     if (bufsize < BUFFER_SIZE)
         bufsize = BUFFER_SIZE;
     config.bufsize = bufsize;
 
     if (maxMsgSize < MAX_MESSAGE_SIZE)
         maxMsgSize = MAX_MESSAGE_SIZE;
     config.maxMsgSize = maxMsgSize;
 
     epicsThreadOnce(&errlogOnceFlag, errlogInitPvt, &config);
     if (pvtData.errlogInitFailed) {
         fprintf(stderr,"errlogInit failed\n");
         exit(1);
     }
     return 0;
 }

int errlogMessage ( const char * message )

Definition at line 180 of file errlog.c.

 {
     errlogPrintf("%s", message);
     return 0;
 }

int errlogPrintf	(	const char *	pFormat,
			...
	)

Definition at line 105 of file errlog.c.

 {
     va_list pvar;
     char *pbuffer;
     int nchar;
     int isOkToBlock;
 
     if (epicsInterruptIsInterruptContext()) {
         epicsInterruptContextMessage
             ("errlogPrintf called from interrupt level\n");
         return 0;
     }
 
     errlogInit(0);
     isOkToBlock = epicsThreadIsOkToBlock();
 
     if (pvtData.atExit || (isOkToBlock && pvtData.toConsole)) {
         FILE *console = pvtData.console ? pvtData.console : stderr;
 
         va_start(pvar, pFormat);
         nchar = vfprintf(console, pFormat, pvar);
         va_end (pvar);
         fflush(console);
     }
 
     if (pvtData.atExit)
         return nchar;
 
     pbuffer = msgbufGetFree(isOkToBlock);
     if (!pbuffer)
         return 0;
 
     va_start(pvar, pFormat);
     nchar = tvsnPrint(pbuffer, pvtData.maxMsgSize, pFormat?pFormat:"", pvar);
     va_end(pvar);
     msgbufSetSize(nchar);
     return nchar;
 }

int errlogPrintfNoConsole	(	const char *	pFormat,
			...
	)

Definition at line 186 of file errlog.c.

 {
     va_list pvar;
     int nchar;
 
     if (epicsInterruptIsInterruptContext()) {
         epicsInterruptContextMessage
             ("errlogPrintfNoConsole called from interrupt level\n");
         return 0;
     }
 
     errlogInit(0);
     va_start(pvar, pFormat);
     nchar = errlogVprintfNoConsole(pFormat, pvar);
     va_end(pvar);
     return nchar;
 }

int errlogRemoveListeners	(	errlogListener	listener,
		void *	pPrivate
	)

Definition at line 334 of file errlog.c.

 {
     listenerNode *plistenerNode;
     int count = 0;
 
     errlogInit(0);
     if (!pvtData.atExit)
         epicsMutexMustLock(pvtData.listenerLock);
 
     plistenerNode = (listenerNode *)ellFirst(&pvtData.listenerList);
     while (plistenerNode) {
         listenerNode *pnext = (listenerNode *)ellNext(&plistenerNode->node);
 
         if (plistenerNode->listener == listener &&
             plistenerNode->pPrivate == pPrivate) {
             ellDelete(&pvtData.listenerList, &plistenerNode->node);
             free(plistenerNode);
             ++count;
         }
         plistenerNode = pnext;
     }
 
     if (!pvtData.atExit)
         epicsMutexUnlock(pvtData.listenerLock);
 
     if (count == 0) {
         FILE *console = pvtData.console ? pvtData.console : stderr;
 
         fprintf(console,
             "errlogRemoveListeners: No listeners found\n");
     }
     return count;
 }

int errlogSetConsole ( FILE * stream )

Definition at line 376 of file errlog.c.

 {
     errlogInit(0);
     pvtData.console = stream;
     return 0;
 }

void errlogSetSevToLog ( errlogSevEnum severity )

Definition at line 305 of file errlog.c.

 {
     errlogInit(0);
     pvtData.sevToLog = severity;
 }

int errlogSevPrintf	(	errlogSevEnum	severity,
		const char *	pFormat,
			...
	)

Definition at line 229 of file errlog.c.

 {
     va_list pvar;
     int nchar;
     int isOkToBlock;
 
     if (epicsInterruptIsInterruptContext()) {
         epicsInterruptContextMessage
             ("errlogSevPrintf called from interrupt level\n");
         return 0;
     }
 
     errlogInit(0);
     if (pvtData.sevToLog > severity)
         return 0;
 
     isOkToBlock = epicsThreadIsOkToBlock();
     if (pvtData.atExit || (isOkToBlock && pvtData.toConsole)) {
         FILE *console = pvtData.console ? pvtData.console : stderr;
 
         fprintf(console, "sevr=%s ", errlogGetSevEnumString(severity));
         va_start(pvar, pFormat);
         vfprintf(console, pFormat, pvar);
         va_end(pvar);
         fflush(console);
     }
 
     va_start(pvar, pFormat);
     nchar = errlogSevVprintf(severity, pFormat, pvar);
     va_end(pvar);
     return nchar;
 }

int errlogSevVprintf	(	errlogSevEnum	severity,
		const char *	pFormat,
		va_list	pvar
	)

Definition at line 262 of file errlog.c.

 {
     char *pnext;
     int nchar;
     int totalChar = 0;
     int isOkToBlock;
 
     if (epicsInterruptIsInterruptContext()) {
         epicsInterruptContextMessage
             ("errlogSevVprintf called from interrupt level\n");
         return 0;
     }
 
     errlogInit(0);
     if (pvtData.atExit)
         return 0;
 
     isOkToBlock = epicsThreadIsOkToBlock();
     pnext = msgbufGetFree(isOkToBlock);
     if (!pnext)
         return 0;
 
     nchar = sprintf(pnext, "sevr=%s ", errlogGetSevEnumString(severity));
     pnext += nchar; totalChar += nchar;
     nchar = tvsnPrint(pnext, pvtData.maxMsgSize - totalChar - 1, pFormat, pvar);
     pnext += nchar; totalChar += nchar;
     if (pnext[-1] != '\n') {
         strcpy(pnext,"\n");
         totalChar++;
     }
     msgbufSetSize(totalChar);
     return nchar;
 }

int errlogVprintf	(	const char *	pFormat,
		va_list	pvar
	)

Definition at line 144 of file errlog.c.

 {
     int nchar;
     char *pbuffer;
     int isOkToBlock;
     FILE *console;
 
     if (epicsInterruptIsInterruptContext()) {
         epicsInterruptContextMessage
             ("errlogVprintf called from interrupt level\n");
         return 0;
     }
 
     errlogInit(0);
     if (pvtData.atExit)
         return 0;
     isOkToBlock = epicsThreadIsOkToBlock();
 
     pbuffer = msgbufGetFree(isOkToBlock);
     if (!pbuffer) {
         console = pvtData.console ? pvtData.console : stderr;
         vfprintf(console, pFormat, pvar);
         fflush(console);
         return 0;
     }
 
     nchar = tvsnPrint(pbuffer, pvtData.maxMsgSize, pFormat?pFormat:"", pvar);
     if (pvtData.atExit || (isOkToBlock && pvtData.toConsole)) {
         console = pvtData.console ? pvtData.console : stderr;
         fprintf(console, "%s", pbuffer);
         fflush(console);
     }
     msgbufSetSize(nchar);
     return nchar;
 }

int errlogVprintfNoConsole	(	const char *	pFormat,
		va_list	pvar
	)

Definition at line 204 of file errlog.c.

 {
     int nchar;
     char *pbuffer;
 
     if (epicsInterruptIsInterruptContext()) {
         epicsInterruptContextMessage
             ("errlogVprintfNoConsole called from interrupt level\n");
         return 0;
     }
 
     errlogInit(0);
     if (pvtData.atExit)
         return 0;
 
     pbuffer = msgbufGetFree(1);
     if (!pbuffer)
         return 0;
 
     nchar = tvsnPrint(pbuffer, pvtData.maxMsgSize, pFormat?pFormat:"", pvar);
     msgbufSetSize(nchar);
     return nchar;
 }

void errPrintf	(	long	status,
		const char *	pFileName,
		int	lineno,
		const char *	pformat,
			...
	)

Definition at line 383 of file errlog.c.

 {
     va_list pvar;
     char    *pnext;
     int     nchar;
     int     totalChar=0;
     int     isOkToBlock;
     char    name[256];
 
     if (epicsInterruptIsInterruptContext()) {
         epicsInterruptContextMessage("errPrintf called from interrupt level\n");
         return;
     }
 
     errlogInit(0);
     isOkToBlock = epicsThreadIsOkToBlock();
     if (status == 0)
         status = errno;
 
     if (status > 0) {
         errSymLookup(status, name, sizeof(name));
     }
 
     if (pvtData.atExit || (isOkToBlock && pvtData.toConsole)) {
         FILE *console = pvtData.console ? pvtData.console : stderr;
 
         if (pFileName)
             fprintf(console, "filename=\"%s\" line number=%d\n",
                 pFileName, lineno);
         if (status > 0)
             fprintf(console, "%s ", name);
 
         va_start(pvar, pformat);
         vfprintf(console, pformat, pvar);
         va_end(pvar);
         fputc('\n', console);
         fflush(console);
     }
 
     if (pvtData.atExit)
         return;
 
     pnext = msgbufGetFree(isOkToBlock);
     if (!pnext)
         return;
 
     if (pFileName) {
         nchar = sprintf(pnext,"filename=\"%s\" line number=%d\n",
             pFileName, lineno);
         pnext += nchar; totalChar += nchar;
     }
 
     if (status > 0) {
         nchar = sprintf(pnext,"%s ",name);
         pnext += nchar; totalChar += nchar;
     }
     va_start(pvar, pformat);
     nchar = tvsnPrint(pnext, pvtData.maxMsgSize - totalChar - 1, pformat, pvar);
     va_end(pvar);
     if (nchar>0) {
         pnext += nchar;
         totalChar += nchar;
     }
     strcpy(pnext, "\n");
     totalChar++ ; /*include the \n */
     msgbufSetSize(totalChar);
 }

Variable Documentation

int atExit

Definition at line 73 of file errlog.c.

int buffersize

Definition at line 78 of file errlog.c.

FILE* console

Definition at line 83 of file errlog.c.

int errlogInitFailed

Definition at line 77 of file errlog.c.

int errVerbose = 0

Definition at line 41 of file errlog.c.

epicsEventId flush

Definition at line 70 of file errlog.c.

epicsMutexId flushLock

Definition at line 71 of file errlog.c.

ELLLIST listenerList

Definition at line 74 of file errlog.c.

epicsMutexId listenerLock

Definition at line 68 of file errlog.c.

int maxMsgSize

Definition at line 79 of file errlog.c.

int missedMessages

Definition at line 84 of file errlog.c.

int msgNeeded

Definition at line 80 of file errlog.c.

ELLLIST msgQueue

Definition at line 75 of file errlog.c.

epicsMutexId msgQueueLock

Definition at line 67 of file errlog.c.

char* pbuffer

Definition at line 85 of file errlog.c.

msgNode* pnextSend

Definition at line 76 of file errlog.c.

int sevToLog

Definition at line 81 of file errlog.c.

int toConsole

Definition at line 82 of file errlog.c.

epicsEventId waitForExit

Definition at line 72 of file errlog.c.

epicsEventId waitForFlush

Definition at line 69 of file errlog.c.

epicsEventId waitForWork

Definition at line 66 of file errlog.c.

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation