rsyslog/rsyslog
1
0
Fork 0
mirror of https://github.com/rsyslog/rsyslog.git synced 2025-12-15 17:30:42 +01:00
Code Issues Packages Projects Releases Wiki Activity
rsyslog/runtime/rsyslog.c

298 lines
12 KiB
C
Raw Blame History

/* rsyslog.c - the main entry point into rsyslog's runtime library (RTL)
*
* This module contains all function which work on a RTL global level. It's
* name is abbreviated to "rsrt" (rsyslog runtime).
*
* Please note that the runtime library tends to be plugin-safe. That is, it must be
* initialized by calling a global initialization function. However, that
* function checks if the library is already initialized and, if so, does
* nothing except incrementing a refeence count. Similarly, the deinit
* function does nothing as long as there are still other users (which
* is tracked via the refcount). As such, it is safe to call init and
* exit multiple times, as long as this are always matching calls. This
* capability is needed for a plugin system, where one plugin never
* knows what the other did. HOWEVER, as of this writing, not all runtime
* library objects may work cleanly without static global data (the
* debug system is a very good example of this). So while we aim at the
* ability to work well in a plugin environment, things may not really work
* out. If you intend to use the rsyslog runtime library inside plugins,
* you should investigate the situation in detail. Please note that the
* rsyslog project itself does not yet need this functionality - thus you
* can safely assume it is totally untested ;).
*
* rgerhards, 2008-04-17: I have now once again checked on the plugin-safety.
* Unfortunately, there is currently no hook at all with which we could
* abstract a global data instance class. As such, we can NOT make the
* runtime plugin-safe in the above-described sense. As the rsyslog
* project itself does not need this functionality (and it is quesationable
* if someone else ever will), we do currently do not make an effort to
* support it. So if you intend to use rsyslog runtime inside a non-rsyslog
* plugin system, be careful!
*
* The rsyslog runtime library is in general reentrant and thread-safe. There
* are some intentional exceptions (e.g. inside the msg object). These are
* documented. Any other threading and reentrency issue can be considered a bug.
*
* Module begun 2008-04-16 by Rainer Gerhards
*
* Copyright 2008-2016 Rainer Gerhards and Adiscon GmbH.
*
* This file is part of the rsyslog runtime library.
*
* The rsyslog runtime library is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* The rsyslog runtime library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with the rsyslog runtime library. If not, see <http://www.gnu.org/licenses/>.
*
* A copy of the GPL can be found in the file "COPYING" in this distribution.
* A copy of the LGPL can be found in the file "COPYING.LESSER" in this distribution.
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#ifdef ENABLE_LIBLOGGING_STDLOG
#include <liblogging/stdlog.h>
#endif
#include "rsyslog.h"
#include "obj.h"
#include "stringbuf.h"
#include "wti.h"
#include "wtp.h"
#include "datetime.h"
#include "queue.h"
#include "conf.h"
#include "rsconf.h"
#include "glbl.h"
#include "errmsg.h"
#include "prop.h"
#include "ruleset.h"
#include "parser.h"
#include "lookup.h"
#include "strgen.h"
#include "statsobj.h"
#include "atomic.h"
#include "srUtils.h"
pthread_attr_t default_thread_attr;
#ifdef HAVE_PTHREAD_SETSCHEDPARAM
struct sched_param default_sched_param;
int default_thr_sched_policy;
#endif
/* globally visible static data - see comment in rsyslog.h for details */
uchar *glblModPath; /* module load path */
void (*glblErrLogger)(const int, const int, const uchar *) = dfltErrLogger;
/* the error logger to use by the errmsg module */
/* static data */
static int iRefCount = 0; /* our refcount - it MUST exist only once inside a process (not thread)
thus it is perfectly OK to use a static. MUST be initialized to 0! */
/* This is the default instance of the error logger. It simply writes the message
* to stderr. It is expected that this is replaced by the runtime user very early
* during startup (at least if the default is unsuitable). However, we provide a
* default so that we can log errors during the initial phase, most importantly
* during initialization. -- rgerhards. 2008-04-17
*/
void dfltErrLogger(const int severity, const int iErr, const uchar *errMsg) {
fprintf(stderr, "rsyslog internal message (%d,%d): %s\n", severity, iErr, errMsg);
}
/* set the error log function
* rgerhards, 2008-04-18
*/
void rsrtSetErrLogger(void (*errLogger)(const int, const int, const uchar *)) {
assert(errLogger != NULL);
glblErrLogger = errLogger;
}
/* globally initialze the runtime system
* NOTE: this is NOT thread safe and must not be called concurrently. If that
* ever poses a problem, we may use proper mutex calls - not considered needed yet.
* If ppErrObj is provided, it receives a char pointer to the name of the object that
* caused the problem (if one occurred). The caller must never free this pointer. If
* ppErrObj is NULL, no such information will be provided. pObjIF is the pointer to
* the "obj" object interface, which may be used to query any other rsyslog objects.
* rgerhards, 2008-04-16
*/
rsRetVal rsrtInit(const char **ppErrObj, obj_if_t *pObjIF) {
DEFiRet;
int ret;
char errstr[1024];
if (iRefCount == 0) {
seedRandomNumber();
/* init runtime only if not yet done */
#ifdef ENABLE_LIBLOGGING_STDLOG
stdlog_init(0);
#endif
ret = pthread_attr_init(&default_thread_attr);
if (ret != 0) {
rs_strerror_r(ret, errstr, sizeof(errstr));
fprintf(stderr,
"rsyslogd: pthread_attr_init failed during "
"startup - can not continue. Error was %s\n",
errstr);
exit(1);
}
pthread_attr_setstacksize(&default_thread_attr, 4096 * 1024);
#ifdef HAVE_PTHREAD_SETSCHEDPARAM
ret = pthread_getschedparam(pthread_self(), &default_thr_sched_policy, &default_sched_param);
if (ret != 0) {
rs_strerror_r(ret, errstr, sizeof(errstr));
fprintf(stderr,
"rsyslogd: pthread_getschedparam failed during "
"startup - ignoring. Error was %s\n",
errstr);
default_thr_sched_policy = 0; /* should be default on all platforms */
}
#if defined(_AIX)
pthread_attr_setstacksize(&default_thread_attr, 4096 * 512);
#endif
ret = pthread_attr_setschedpolicy(&default_thread_attr, default_thr_sched_policy);
if (ret != 0) {
rs_strerror_r(ret, errstr, sizeof(errstr));
fprintf(stderr,
"rsyslogd: pthread_attr_setschedpolicy failed during "
"startup - tried to set priority %d, now using default "
"priority instead. Error was: %s\n",
default_thr_sched_policy, errstr);
}
ret = pthread_attr_setschedparam(&default_thread_attr, &default_sched_param);
if (ret != 0) {
rs_strerror_r(ret, errstr, sizeof(errstr));
fprintf(stderr,
"rsyslogd: pthread_attr_setschedparam failed during "
"startup - ignored Error was: %s\n",
errstr);
}
ret = pthread_attr_setinheritsched(&default_thread_attr, PTHREAD_EXPLICIT_SCHED);
if (ret != 0) {
rs_strerror_r(ret, errstr, sizeof(errstr));
fprintf(stderr,
"rsyslogd: pthread_attr_setinheritsched failed during "
"startup - ignoring. Error was: %s\n",
errstr);
}
#endif
if (ppErrObj != NULL) *ppErrObj = "obj";
CHKiRet(objClassInit(NULL)); /* *THIS* *MUST* always be the first class initilizer being called! */
CHKiRet(objGetObjInterface(pObjIF)); /* this provides the root pointer for all other queries */
/* initialize core classes. We must be very careful with the order of events. Some
* classes use others and if we do not initialize them in the right order, we may end
* up with an invalid call. The most important thing that can happen is that an error
* is detected and needs to be logged, wich in turn requires a broader number of classes
* to be available. The solution is that we take care in the order of calls AND use a
* class immediately after it is initialized. And, of course, we load those classes
* first that we use ourselfs... -- rgerhards, 2008-03-07
*/
if (ppErrObj != NULL) *ppErrObj = "statsobj";
CHKiRet(statsobjClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "prop";
CHKiRet(propClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "glbl";
CHKiRet(glblClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "msg";
CHKiRet(msgClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "ruleset";
CHKiRet(rulesetClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "wti";
CHKiRet(wtiClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "wtp";
CHKiRet(wtpClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "queue";
CHKiRet(qqueueClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "conf";
CHKiRet(confClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "parser";
CHKiRet(parserClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "strgen";
CHKiRet(strgenClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "rsconf";
CHKiRet(rsconfClassInit(NULL));
if (ppErrObj != NULL) *ppErrObj = "lookup";
CHKiRet(lookupClassInit());
if (ppErrObj != NULL) *ppErrObj = "dynstats";
CHKiRet(dynstatsClassInit());
if (ppErrObj != NULL) *ppErrObj = "perctile_stats";
CHKiRet(perctileClassInit());
/* dummy "classes" */
if (ppErrObj != NULL) *ppErrObj = "str";
CHKiRet(strInit());
}
++iRefCount;
dbgprintf("rsyslog runtime initialized, version %s, current users %d\n", VERSION, iRefCount);
finalize_it:
RETiRet;
}
/* globally de-initialze the runtime system
* NOTE: this is NOT thread safe and must not be called concurrently. If that
* ever poses a problem, we may use proper mutex calls - not considered needed yet.
* This function must be provided with the caller's obj object pointer. This is
* automatically deinitialized by the runtime system.
* rgerhards, 2008-04-16
*/
rsRetVal rsrtExit(void) {
DEFiRet;
if (iRefCount == 1) {
/* do actual de-init only if we are the last runtime user */
confClassExit();
glblClassExit();
rulesetClassExit();
wtiClassExit();
wtpClassExit();
strgenClassExit();
propClassExit();
statsobjClassExit();
objClassExit(); /* *THIS* *MUST/SHOULD?* always be the first class initilizer being
called (except debug)! */
}
--iRefCount;
/* TODO we must deinit this pointer! pObjIF = NULL; / * no longer exists for this caller */
dbgprintf("rsyslog runtime de-initialized, current users %d\n", iRefCount);
RETiRet;
}
/* returns 0 if the rsyslog runtime is not initialized and another value
* if it is. This function is primarily meant to be used by runtime functions
* itself. However, it is safe to call it before initializing the runtime.
* Plugins should NOT rely on this function. The reason is that another caller
* may have already initialized it but deinits it before this plugin is done.
* So for plugins and like architectures, the right course of action is to
* call rsrtInit() and rsrtExit(), which can be called by multiple callers.
* rgerhards, 2008-04-16
*/
int rsrtIsInit(void) {
return iRefCount;
}
/* vim:set ai:
*/
Reference in New Issue View Git Blame Copy Permalink