xdasd_logger.c

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 * Copyright (c) 2006, Novell, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are 
 * met:
 * 
 *     * Redistributions of source code must retain the above copyright 
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright 
 *       notice, this list of conditions and the following disclaimer in the 
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Novell nor the names of its contributors 
 *       may be used to endorse or promote products derived from this 
 *       software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *--------------------------------------------------------------------------*/

#include <xdas_base.h>

#include "xdasd_logger.h"
#include "xdasd_parse.h"
#include "xdasd_mqueue.h"
#include "xdasd_mcache.h"
#include "xdasd_conf.h"
#include "xdasd_log.h"

#include <stdio.h>
#include <string.h>

#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
#else
# include <sys/types.h>
# include <sys/stat.h>
# include <dlfcn.h>
#endif

#define XDASD_MAX_LOGGERS 16

#define XDM_INIT_SYM_NAME "xdm_init"
#define XDM_APND_SYM_NAME "xdm_append"
#define XDM_EXIT_SYM_NAME "xdm_exit"
/* @} */

typedef void * xdasd_lib_t;

typedef void (*xdasd_fptr_t)(void);

typedef int logger_init_fn_t(void (*logmsg)(int level, const char *, ... ), 
      char * (*getcnfstr)(const char *, char *, size_t *));
typedef int logger_apnd_fn_t(const char ** fields);
typedef void logger_exit_fn_t(void);

typedef struct xdasd_logger_tag
{
   xdasd_lib_t lib;
   logger_init_fn_t * init_fn;
   logger_apnd_fn_t * apnd_fn;
   logger_exit_fn_t * exit_fn;
   char fname[FILENAME_MAX];
} xdasd_logger_t;

static xdasd_logger_t s_loggers[XDASD_MAX_LOGGERS];
static MsgQueue s_mq_logger = 0;
static MsgCache s_mcache = 0;

static xdasd_lib_t xdasd_load_library(const char * libname)
{
#ifdef _WIN32
   return (xdasd_lib_t)LoadLibraryA(libname);
#else
   return (xdasd_lib_t)dlopen(libname, RTLD_NOW | RTLD_LOCAL);
#endif
}

static xdasd_fptr_t xdasd_import_symbol(xdasd_lib_t lib, const char * sym)
{
#ifdef _WIN32
   return (xdasd_fptr_t)GetProcAddress((HANDLE)lib, sym);
#else
   return (xdasd_fptr_t)dlsym((void *)lib, sym);
#endif
}

static void xdasd_free_library(xdasd_lib_t lib)
{
#ifdef _WIN32
   FreeLibrary((HANDLE)lib);
#else
   dlclose((void *)lib);
#endif
}

void logger_clear(void)
{
   xdasd_logger_t * p = s_loggers;
   while (p->lib)
   {
      xdasd_log(0, "Logger %s unloading.\n", p->fname);
      xdasd_free_library(p->lib);
      p++;
   }
   memset(s_loggers, 0, sizeof(s_loggers));
}

static int logger_put(void * data)
{
   return xdasd_mcache_put_msg(s_mcache, (Parsed *)data);
}

static void * logger_get(void)
{
   return xdasd_mcache_get_msg(s_mcache);
} 

static void logger_append(void * data)
{
   Parsed * parsed = (Parsed *)data;

   int logged = 0;
   xdasd_logger_t * p = s_loggers;

   while (p->lib)
   {
      if ((*p->apnd_fn)(parsed->parsed) == 0)
         logged = 1;
      p++;
   }
   if (!logged) 
      xdasd_log(0, "logger: All loggers FAILED to log message:\n[ %s ]\n", 
            parsed->msg);

   xdasd_parse_free(parsed);
}

/*--------------------------------------------------------------------------*/

int xdasd_logger_append(Parsed * parsed)
{
   return xdasd_mqueue_append(s_mq_logger, parsed);
}

int xdasd_logger_init(const char * msgfdir)
{
   char * libfile;
   char buf[4096];
   size_t bufsz = sizeof(buf);
   unsigned loadcnt = 0;

   /* clear all loggers */
   memset(s_loggers, 0, sizeof(s_loggers));

   /* access logger list, if empty, return failure - there's no point
      in being loaded if there are no loggers registered. */
   (void)xdasd_conf_getstr("xdasd.loggers", buf, &bufsz);
   if (!bufsz) 
      return -1;

   /* separate comma separated names into an array */
   libfile = strtok(buf, ",");
   while (libfile != 0 && loadcnt < xdas_elemcount(s_loggers))
   {
      char * ep;

      /* strip leading whitespace */
      while (isspace(*libfile))
         libfile++;

      /* strip trailing white space */
      ep = libfile + strlen(libfile);
      while (ep > libfile && isspace(ep[-1]))
         *--ep = 0;

      /* if there's any file name remaining, prefix it and load it */
      if (*libfile)
      {
         xdasd_lib_t lib;

         if ((lib = xdasd_load_library(libfile)) != 0)
         {
            logger_init_fn_t * init_fn;
            logger_apnd_fn_t * apnd_fn;
            logger_exit_fn_t * exit_fn;

            /* import all symbols */
            init_fn = (logger_init_fn_t *)xdasd_import_symbol(lib, XDM_INIT_SYM_NAME);
            apnd_fn = (logger_apnd_fn_t *)xdasd_import_symbol(lib, XDM_APND_SYM_NAME);
            exit_fn = (logger_exit_fn_t *)xdasd_import_symbol(lib, XDM_EXIT_SYM_NAME);

            /* if import succeeded and initialization succeeds... */
            if (init_fn != 0 && apnd_fn != 0 && exit_fn != 0 
                  && (*init_fn)(xdasd_log, xdasd_conf_getstr) == 0)
            {
               s_loggers[loadcnt].lib = lib;
               s_loggers[loadcnt].init_fn = init_fn;
               s_loggers[loadcnt].apnd_fn = apnd_fn;
               s_loggers[loadcnt].exit_fn = exit_fn;
               strncpy(s_loggers[loadcnt].fname, libfile, FILENAME_MAX - 1);
               s_loggers[loadcnt].fname[FILENAME_MAX - 1] = 0;
               loadcnt++;
               xdasd_log(0, "Logger %s loaded and initialized.\n", libfile);
            }
            else
            {
               if (init_fn == 0 || apnd_fn == 0 || exit_fn == 0)
                  xdasd_log(0, "Logger %s FAILED. Missing required symbols.\n", libfile);
               else
                  xdasd_log(0, "Logger %s FAILED. Initialization failure.\n", libfile);
               xdasd_free_library(lib);
            }
         }
         else
            xdasd_log(0, "Logger %s FAILED. Load failure.\n", libfile);
      }
      libfile = strtok(0, ",");
   }
   if (loadcnt == 0)
   {
      xdasd_log(0, "logger: No back-end loggers loaded.\n");
      return -1;
   }

   /* initialize the message cache sub-system */
   if ((s_mcache = xdasd_mcache_create(msgfdir)) == 0)
   {
      xdasd_log(0, "logger: Unable to create the persistent message cache.\n");
      logger_clear();
      return -1;
   }

   /* create the logger message queue */
   if ((s_mq_logger = xdasd_mqueue_create(logger_put, logger_get, logger_append)) == 0)
   {
      xdasd_log(0, "logger: Unable to create logger message queue.\n");
      xdasd_mcache_destroy(s_mcache);
      logger_clear();
      return -1;
   }
   return 0;
}

void xdasd_logger_exit(void)
{
   xdasd_mqueue_destroy(s_mq_logger);
   xdasd_mcache_destroy(s_mcache);
   logger_clear();
}