Guys
See the attach patch, this implements a xentoollog consumer that can log
in to syslog
Following are the changes
xentoollog.h:
1) Generic, xtl_logger_set_minlevel and xtl_logger_adjust_flags
functions to be called from outside,
2) Making logger flags to be more generic
3) Change the struct xentool_logger, each logger will implement its own
"set_minlevel" and "adjust_flags" which will be invoked by
xtl_logger_set_minlevel and xtl_logger_adjust_flags generic functions.
4) New function prototype to create a xentool_logger_syslogger
Going forward I would like to suggest that xentoollog.h file should only
have generic functions, except for xtl_createlogger_* functions. Logger
type specific function should not be included(e.g
xtl_stdiostream_set_minlevel ) this will make sure outside code can
switch from one logger to another (from stdiologger to syslogger vice
versa) with out breaking the code.
xtl_core.c:
1) Implementation of xtl_logger_set_minlevel and xtl_logger_adjust_flags
functions.
xtl_logger_syslog.c :
New logger implementation to log in to syslog.
I did some testing by changing the code in xl. This seems to work, but I
would really like if more people can test this.
Also could someone look @ the syslogger_progress function and add any
extra bits if needed, I did a very basic implementation of this.
Signed-off-by : Gihan Munasinghe <GMunasinghe@xxxxxxxxxxxx>
Thanks
Gihan
diff -Nuar a/tools/libxc/Makefile b/tools/libxc/Makefile
--- a/tools/libxc/Makefile 2010-06-01 23:32:43.000000000 +0100
+++ b/tools/libxc/Makefile 2010-06-03 22:56:42.000000000 +0100
@@ -29,6 +29,7 @@
CTRL_SRCS-y += xc_memshr.c
CTRL_SRCS-y += xtl_core.c
CTRL_SRCS-y += xtl_logger_stdio.c
+CTRL_SRCS-y += xtl_logger_syslog.c
CTRL_SRCS-$(CONFIG_X86) += xc_pagetab.c
CTRL_SRCS-$(CONFIG_Linux) += xc_linux.c
CTRL_SRCS-$(CONFIG_SunOS) += xc_solaris.c
diff -Nuar a/tools/libxc/xentoollog.h b/tools/libxc/xentoollog.h
--- a/tools/libxc/xentoollog.h 2010-06-01 23:32:43.000000000 +0100
+++ b/tools/libxc/xentoollog.h 2010-06-04 22:49:54.000000000 +0100
@@ -45,16 +45,28 @@
* will always be called with done==0 for each new
* context/doing_what */;
void (*destroy)(struct xentoollog_logger *logger);
+ void (*set_minlevel)(xentoollog_logger *logger,
+ xentoollog_level min_level);
+ void (*adjust_flags)(xentoollog_logger *logger,
+ unsigned set_flags, unsigned clear_flags);
/* each logger can put its necessary data here */
+
};
/*---------- facilities for consuming log messages ----------*/
+//-- Should be depricated not generic enough --//
#define XTL_STDIOSTREAM_SHOW_PID 01u
#define XTL_STDIOSTREAM_SHOW_DATE 02u
#define XTL_STDIOSTREAM_HIDE_PROGRESS 04u
+//---Plase use the following as the new flags when creating and setting loggers
+#define XTL_SHOW_PID 01u
+#define XTL_SHOW_DATE 02u
+#define XTL_HIDE_PROGRESS 04u
+
+
typedef struct xentoollog_logger_stdiostream xentoollog_logger_stdiostream;
xentoollog_logger_stdiostream *xtl_createlogger_stdiostream
@@ -62,15 +74,47 @@
/* may return 0 if malloc fails, in which case error was logged */
/* destroy on this logger does not close the file */
+//This method need to be depricated use more generic xtl_logger_set_minlevel
method insted
void xtl_stdiostream_set_minlevel(xentoollog_logger_stdiostream*,
xentoollog_level min_level);
+
+//This method need to be depricated use more generic xtl_logger_adjust_flags
method insted.
void xtl_stdiostream_adjust_flags(xentoollog_logger_stdiostream*,
unsigned set_flags, unsigned clear_flags);
/* if set_flags and clear_flags overlap, set_flags takes precedence */
+
+typedef struct xentoollog_logger_syslogger xentoollog_logger_syslogger;
+
+/**
+Create a logger that will log to syslog
+syslog_facility is the facilities that are in the sys/syslog.h
+edit /etc/syslog.conf file to indicate where you wansyslog to send log data
+
+example config:-
+Add the following line in to /etc/syslog.conf
+
+local1.* /var/log/xenlog
+restart syslogd
+When setting up the logger give LOG_LOCAL1 as the logging facility
+now all your logs will appear in /var/log/xenlog file
+
+Please look more in to syslog and syslogng configs if you want to send the
data in to remote logging servers
+
+NOTE: XTL_SHOW_DATE flag will not take any effect as syslogd will put the date
by default
+**/
+xentoollog_logger_syslogger *xtl_createlogger_syslogger
+ (int syslog_facility, xentoollog_level min_level, unsigned flags);
+
void xtl_logger_destroy(struct xentoollog_logger *logger /* 0 is ok */);
+void xtl_logger_set_minlevel(struct xentoollog_logger *logger,xentoollog_level
min_level);
+
+void xtl_logger_adjust_flags(struct xentoollog_logger *logger,
+ unsigned set_flags, unsigned clear_flags);
+
+
/*---------- facilities for generating log messages ----------*/
void xtl_logv(struct xentoollog_logger *logger,
@@ -104,6 +148,8 @@
(buffer).vtable.vmessage = LOGGER##_vmessage; \
(buffer).vtable.progress = LOGGER##_progress; \
(buffer).vtable.destroy = LOGGER##_destroy; \
+ (buffer).vtable.set_minlevel = LOGGER##_set_minlevel; \
+ (buffer).vtable.adjust_flags = LOGGER##_adjust_flags; \
\
new_consumer = malloc(sizeof(*new_consumer)); \
if (!new_consumer) { \
diff -Nuar a/tools/libxc/xtl_core.c b/tools/libxc/xtl_core.c
--- a/tools/libxc/xtl_core.c 2010-06-01 23:32:43.000000000 +0100
+++ b/tools/libxc/xtl_core.c 2010-06-04 21:34:55.000000000 +0100
@@ -63,7 +63,23 @@
logger->progress(logger, context, doing_what, percent, done, total);
}
+void xtl_logger_set_minlevel(struct xentoollog_logger *logger,
+ xentoollog_level min_level){
+ if (!logger || !logger->set_minlevel) return;
+
+ logger->set_minlevel(logger,min_level);
+}
+
+void xtl_logger_adjust_flags(struct xentoollog_logger *logger,
+ unsigned set_flags, unsigned clear_flags){
+ if (!logger || !logger->adjust_flags) return;
+
+ logger->adjust_flags(logger,set_flags,clear_flags);
+}
+
+
void xtl_logger_destroy(struct xentoollog_logger *logger) {
- if (!logger) return;
+ if (!logger || !logger->destroy) return;
+
logger->destroy(logger);
}
diff -Nuar a/tools/libxc/xtl_logger_stdio.c b/tools/libxc/xtl_logger_stdio.c
--- a/tools/libxc/xtl_logger_stdio.c 2010-06-01 23:32:43.000000000 +0100
+++ b/tools/libxc/xtl_logger_stdio.c 2010-06-04 21:44:52.000000000 +0100
@@ -124,6 +124,20 @@
lg->flags = new_flags;
}
+static void stdiostream_set_minlevel(struct xentoollog_logger *logger_in,
+ xentoollog_level min_level){
+
+ xentoollog_logger_stdiostream *lg = (void*)logger_in;
+ xtl_stdiostream_set_minlevel(lg,min_level);
+}
+
+static void stdiostream_adjust_flags(struct xentoollog_logger *logger_in,
+ unsigned set_flags, unsigned clear_flags) {
+
+ xentoollog_logger_stdiostream *lg = (void*)logger_in;
+ xtl_stdiostream_adjust_flags(lg,set_flags,clear_flags);
+}
+
xentoollog_logger_stdiostream *xtl_createlogger_stdiostream
(FILE *f, xentoollog_level min_level, unsigned flags) {
xentoollog_logger_stdiostream newlogger;
diff -Nuar a/tools/libxc/xtl_logger_syslog.c b/tools/libxc/xtl_logger_syslog.c
--- a/tools/libxc/xtl_logger_syslog.c 1970-01-01 01:00:00.000000000 +0100
+++ b/tools/libxc/xtl_logger_syslog.c 2010-06-05 00:52:09.000000000 +0100
@@ -0,0 +1,152 @@
+/**
+*xtl_logger_syslog.c
+*
+*xentool log comsumer implementation, that will log into syslog
+*
+*Copyright (c) 2010 Flexiant Ltd.
+**/
+#include "xentoollog.h"
+
+#include <sys/syslog.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <pthread.h>
+
+typedef struct _log_map{
+ xentoollog_level xen_log;
+ int syslog_level;
+}LOG_MAP;
+
+LOG_MAP log_mappings[] =
+ {
+ {XTL_DEBUG,LOG_DEBUG},
+ {XTL_VERBOSE,LOG_DEBUG},
+ {XTL_DETAIL,LOG_DEBUG},
+ {XTL_PROGRESS,LOG_DEBUG},
+ {XTL_INFO,LOG_INFO},
+ {XTL_NOTICE,LOG_NOTICE},
+ {XTL_WARN,LOG_WARNING},
+ {XTL_ERROR,LOG_ERR},
+ {XTL_CRITICAL,LOG_CRIT}
+ };
+
+int maptable_len = sizeof(log_mappings)/sizeof(LOG_MAP);
+
+
+struct xentoollog_logger_syslogger{
+ xentoollog_logger vtable;
+ pthread_mutex_t mutex; //syslog in not thread safe at all therefore we
need a lock before issue a syslog call
+ unsigned flags;
+};
+
+/**
+Returns mapping syslog level for a given xentoollog_level
+**/
+static int get_syslog_level(xentoollog_level level){
+ int i;
+ for (i=0; i<maptable_len; i++){
+ LOG_MAP map = log_mappings[i];
+ if (map.xen_log==level){
+ return map.syslog_level;
+ }
+ }
+ // If a mapping is not found use LOG_INFO as default
+ return LOG_INFO;
+}
+
+
+static void syslogger_vmessage(xentoollog_logger *logger_in,
+ xentoollog_level level,
+ int errnoval,
+ const char *context,
+ const char *format,
+ va_list al) {
+ char *buffer;
+ xentoollog_logger_syslogger *lg = (void*)logger_in;
+
+ buffer = (char *)calloc(1024,sizeof(char));
+ if (context && (lg->flags & XTL_SHOW_PID)){
+ char *new_format = (char *) calloc(13+strlen(context)+10,sizeof(char));
+ sprintf(new_format,"[%s] [%lu] : ",context,(unsigned long)getpid());
+ strcat(buffer,new_format);
+ free(new_format);
+
+ }else if(context){
+ char *new_format = (char *) calloc(7+strlen(context),sizeof(char));
+ sprintf(new_format,"[%s] : ",context);
+ strcat(buffer,new_format);
+ free(new_format);
+
+ }else if(lg->flags & XTL_SHOW_PID){
+ char *new_format = (char *) calloc(18,sizeof(char));
+ sprintf(new_format,"[%lu] : ",(unsigned long)getpid());
+ strcat(buffer,new_format);
+ free(new_format);
+
+ }
+
+ if (errnoval >= 0){
+ char *new_format = (char *) calloc(100,sizeof(char));
+ sprintf(new_format,"[%s] : ",strerror(errnoval));
+ strcat(buffer,new_format);
+ free(new_format);
+ }
+
+ strcat(buffer,format);
+
+ pthread_mutex_lock(&lg->mutex);
+ vsyslog(get_syslog_level(level),buffer,al);
+ pthread_mutex_unlock(&lg->mutex);
+
+ free(buffer);
+}
+
+static void syslogger_progress(struct xentoollog_logger *logger_in,
+ const char *context,
+ const char *doing_what, int percent,
+ unsigned long done, unsigned long total){
+ xentoollog_logger_syslogger *lg = (void *)logger_in;
+
+ pthread_mutex_lock(&lg->mutex);
+ syslog(get_syslog_level(XTL_PROGRESS),"%s%s" "%s: %lu/%lu %3d%%",
+ context?context:"", context?": ":"",
+ doing_what, done, total, percent);
+ pthread_mutex_unlock(&lg->mutex);
+}
+
+static void syslogger_destroy(struct xentoollog_logger *logger_in) {
+ xentoollog_logger_syslogger *lg = (void*)logger_in;
+ closelog();
+ pthread_mutex_destroy(&lg->mutex);
+ free(lg);
+}
+
+static void syslogger_set_minlevel(struct xentoollog_logger *logger_in,
+ xentoollog_level minlevel){
+ setlogmask(LOG_UPTO(get_syslog_level(minlevel)));
+}
+
+static void syslogger_adjust_flags(struct xentoollog_logger *logger_in,
+ unsigned set_flags, unsigned clear_flags){
+ xentoollog_logger_syslogger *lg = (void *)logger_in;
+ unsigned new_flags = (lg->flags & ~clear_flags) | set_flags;
+ lg->flags = new_flags;
+}
+
+xentoollog_logger_syslogger *xtl_createlogger_syslogger
+ (int syslog_facility, xentoollog_level min_level, unsigned flags) {
+
+ xentoollog_logger_syslogger newlogger;
+ newlogger.flags = flags;
+ pthread_mutex_init(&newlogger.mutex,NULL);;
+
+ openlog("",LOG_CONS | LOG_NDELAY,syslog_facility);
+ setlogmask(LOG_UPTO(get_syslog_level(min_level)));
+
+ return XTL_NEW_LOGGER(syslogger, newlogger);
+}
+
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel
|
Home