rsyslog/runtime/rsyslog.c

/* 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 "rswatch.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 */
        rswatchExit();
        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:
 */