Logging.c：
/*
Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
This file is part of GlusterFS.
This file is licensed to you under your choice of the GNU Lesser
General Public License, version 3 or any later version (LGPLv3 or
later), or the GNU General Public License, version 2 (GPLv2), in all
cases as published by the Free Software Foundation.
*/
#ifndef _CONFIG_H
#define _CONFIG_H
#include "config.h"
#endif
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
#include <locale.h>
#include <string.h>
#include <stdlib.h>
#include "xlator.h"
#include "logging.h"
#include "defaults.h"
#include "glusterfs.h"
#ifdef GF_LINUX_HOST_OS
#include <syslog.h>
#endif
#ifdef HAVE_BACKTRACE
#include <execinfo.h>
#endif
/* Ideally this should get moved to logging.h */
struct _msg_queue {
struct list_head msgs;
};
struct _log_msg {
const char *msg;
struct list_head queue;
};
void
gf_log_logrotate (int signum)
{
THIS->ctx->log.logrotate = 1;
}
void
gf_log_enable_syslog (void)
{
THIS->ctx->log.gf_log_syslog = 1;
}
void
gf_log_disable_syslog (void)
{
THIS->ctx->log.gf_log_syslog = 0;
}
gf_loglevel_t
gf_log_get_loglevel (void)
{
return THIS->ctx->log.loglevel;
}
void
gf_log_set_loglevel (gf_loglevel_t level)
{
THIS->ctx->log.loglevel = level;
}
gf_loglevel_t
gf_log_get_xl_loglevel (void *this)
{
xlator_t *xl = this;
if (!xl)
return 0;
return xl->loglevel;
}
void
gf_log_set_xl_loglevel (void *this, gf_loglevel_t level)
{
xlator_t *xl = this;
if (!xl)
return;
xl->ctx->log.gf_log_xl_log_set = 1;
xl->loglevel = level;
}
void
gf_log_fini (void)
{
pthread_mutex_destroy (&THIS->ctx->log.logfile_mutex);
}
void
gf_log_globals_init (void *data)
{
glusterfs_ctx_t *ctx = data;
pthread_mutex_init (&ctx->log.logfile_mutex, NULL);
ctx->log.loglevel = GF_LOG_INFO;
ctx->log.gf_log_syslog = 1;
ctx->log.sys_log_level = GF_LOG_CRITICAL;
#ifdef GF_LINUX_HOST_OS
/* For the 'syslog' output. one can grep 'GlusterFS' in syslog
for serious logs */
openlog ("GlusterFS", LOG_PID, LOG_DAEMON);
#endif
}
int
gf_log_init (void *data, const char *file)
{
glusterfs_ctx_t *ctx = NULL;
int fd = -1;
ctx = data;
if (!file){
fprintf (stderr, "ERROR: no filename specified\n");
return -1;
}
if (strcmp (file, "-") == 0) {
ctx->log.gf_log_logfile = stderr;
return 0;
}
ctx->log.filename = gf_strdup (file);
if (!ctx->log.filename) {
fprintf (stderr, "ERROR: updating log-filename failed: %s\n",
strerror (errno));
return -1;
}
fd = open (file, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
if (fd < 0) {
fprintf (stderr, "ERROR: failed to create logfile \"%s\" (%s)\n",
file, strerror (errno));
return -1;
}
close (fd);
ctx->log.logfile = fopen (file, "a");
if (!ctx->log.logfile){
fprintf (stderr, "ERROR: failed to open logfile \"%s\" (%s)\n",
file, strerror (errno));
return -1;
}
ctx->log.gf_log_logfile = ctx->log.logfile;
return 0;
}
void
set_sys_log_level (gf_loglevel_t level)
{
THIS->ctx->log.sys_log_level = level;
}
/*
* 内存申请失败日志打印.假设日志级别较高，打印到系统日志中"/var/log/message"
* 不支持变參
*
* 若定义了HAVE_BACKTRACE，则打出函数调用栈
*
* @domain 模块名
*
* 假设日志文件不存在，则打印到标准错误输出
*/
int
_gf_log_nomem (const char *domain, const char *file,
const char *function, int line, gf_loglevel_t level,
size_t size)
{
const char *basename = NULL;
xlator_t *this = NULL;
struct timeval tv = {0,};
int ret = 0;
char msg[8092] = {0,};
char timestr[256] = {0,};
char callstr[4096] = {0,};
glusterfs_ctx_t *ctx = NULL;
this = THIS;
ctx = this->ctx;
if (ctx->log.gf_log_xl_log_set) {
if (this->loglevel && (level > this->loglevel))
goto out;
}
if (level > ctx->log.loglevel)
goto out;
static char *level_strings[] = {"", /* NONE */
"M", /* EMERGENCY */
"A", /* ALERT */
"C", /* CRITICAL */
"E", /* ERROR */
"W", /* WARNING */
"N", /* NOTICE */
"I", /* INFO */
"D", /* DEBUG */
"T", /* TRACE */
""};
if (!domain || !file || !function) {
fprintf (stderr,
"logging: %s:%s():%d: invalid argument\n",
__FILE__, __PRETTY_FUNCTION__, __LINE__);
return -1;
}
#if HAVE_BACKTRACE
/* Print 'calling function' */
do {
void *array[5];
char **callingfn = NULL;
size_t bt_size = 0;
bt_size = backtrace (array, 5);
if (bt_size)
callingfn = backtrace_symbols (&array[2], bt_size-2);
if (!callingfn)
break;
if (bt_size == 5)
snprintf (callstr, 4096, "(-->%s (-->%s (-->%s)))",
callingfn[2], callingfn[1], callingfn[0]);
if (bt_size == 4)
snprintf (callstr, 4096, "(-->%s (-->%s))",
callingfn[1], callingfn[0]);
if (bt_size == 3)
snprintf (callstr, 4096, "(-->%s)", callingfn[0]);
free (callingfn);
} while (0);
#endif /* HAVE_BACKTRACE */
ret = gettimeofday (&tv, NULL);
if (-1 == ret)
goto out;
gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
".%"GF_PRI_SUSECONDS, tv.tv_usec);
basename = strrchr (file, '/');
if (basename)
basename++;
else
basename = file;
ret = sprintf (msg, "[%s] %s [%s:%d:%s] %s %s: no memory "
"available for size (%"GF_PRI_SIZET")",
timestr, level_strings[level],
basename, line, function, callstr,
domain, size);
if (-1 == ret) {
goto out;
}
pthread_mutex_lock (&ctx->log.logfile_mutex);
{
if (ctx->log.logfile) {
fprintf (ctx->log.logfile, "%s\n", msg);
} else {
fprintf (stderr, "%s\n", msg);
}
#ifdef GF_LINUX_HOST_OS
/* We want only serious log in 'syslog', not our debug
and trace logs */
if (ctx->log.gf_log_syslog && level &&
(level <= ctx->log.sys_log_level))
syslog ((level-1), "%s\n", msg);
#endif
}
pthread_mutex_unlock (&ctx->log.logfile_mutex);
out:
return ret;
}
/*
* 函数调用參数无效日志打印.假设日志级别较高，打印到系统日志中"/var/log/message"
* 支持变參
*
* 若定义了HAVE_BACKTRACE，则打出函数调用栈
*
* @domain 模块名
*
* 假设日志文件不存在，则打印到标准输出
*/
int
_gf_log_callingfn (const char *domain, const char *file, const char *function,
int line, gf_loglevel_t level, const char *fmt, ...)
{
const char *basename = NULL;
xlator_t *this = NULL;
char *str1 = NULL;
char *str2 = NULL;
char *msg = NULL;
char timestr[256] = {0,};
char callstr[4096] = {0,};
struct timeval tv = {0,};
size_t len = 0;
int ret = 0;
va_list ap;
glusterfs_ctx_t *ctx = NULL;
this = THIS;
ctx = this->ctx;
if (ctx->log.gf_log_xl_log_set) {
if (this->loglevel && (level > this->loglevel))
goto out;
}
if (level > ctx->log.loglevel)
goto out;
static char *level_strings[] = {"", /* NONE */
"M", /* EMERGENCY */
"A", /* ALERT */
"C", /* CRITICAL */
"E", /* ERROR */
"W", /* WARNING */
"N", /* NOTICE */
"I", /* INFO */
"D", /* DEBUG */
"T", /* TRACE */
""};
if (!domain || !file || !function || !fmt) {
fprintf (stderr,
"logging: %s:%s():%d: invalid argument\n",
__FILE__, __PRETTY_FUNCTION__, __LINE__);
return -1;
}
#if HAVE_BACKTRACE
/* Print 'calling function' */
do {
void *array[5];
char **callingfn = NULL;
size_t size = 0;
size = backtrace (array, 5);
if (size)
callingfn = backtrace_symbols (&array[2], size-2);
if (!callingfn)
break;
if (size == 5)
snprintf (callstr, 4096, "(-->%s (-->%s (-->%s)))",
callingfn[2], callingfn[1], callingfn[0]);
if (size == 4)
snprintf (callstr, 4096, "(-->%s (-->%s))",
callingfn[1], callingfn[0]);
if (size == 3)
snprintf (callstr, 4096, "(-->%s)", callingfn[0]);
free (callingfn);
} while (0);
#endif /* HAVE_BACKTRACE */
ret = gettimeofday (&tv, NULL);
if (-1 == ret)
goto out;
va_start (ap, fmt);
gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
".%"GF_PRI_SUSECONDS, tv.tv_usec);
basename = strrchr (file, '/');
if (basename)
basename++;
else
basename = file;
ret = gf_asprintf (&str1, "[%s] %s [%s:%d:%s] %s %d-%s: ",
timestr, level_strings[level],
basename, line, function, callstr,
((this->graph) ? this->graph->id:0), domain);
if (-1 == ret) {
goto out;
}
ret = vasprintf (&str2, fmt, ap);
if (-1 == ret) {
goto out;
}
va_end (ap);
len = strlen (str1);
msg = GF_MALLOC (len + strlen (str2) + 1, gf_common_mt_char);
strcpy (msg, str1);
strcpy (msg + len, str2);
pthread_mutex_lock (&ctx->log.logfile_mutex);
{
if (ctx->log.logfile) {
fprintf (ctx->log.logfile, "%s\n", msg);
} else {
fprintf (stderr, "%s\n", msg);
}
#ifdef GF_LINUX_HOST_OS
/* We want only serious log in 'syslog', not our debug
and trace logs */
if (ctx->log.gf_log_syslog && level &&
(level <= ctx->log.sys_log_level))
syslog ((level-1), "%s\n", msg);
#endif
}
pthread_mutex_unlock (&ctx->log.logfile_mutex);
out:
GF_FREE (msg);
GF_FREE (str1);
FREE (str2);
return ret;
}
/*
* 记录系统执行日志到文件
*
* 假设日志文件不存在，则打印到标准输出
*/
int
_gf_log (const char *domain, const char *file, const char *function, int line,
gf_loglevel_t level, const char *fmt, ...)
{
const char *basename = NULL;
FILE *new_logfile = NULL;
va_list ap;
char timestr[256] = {0,};
struct timeval tv = {0,};
char *str1 = NULL;
char *str2 = NULL;
char *msg = NULL;
size_t len = 0;
int ret = 0;
int fd = -1;
xlator_t *this = NULL;
glusterfs_ctx_t *ctx = NULL;
this = THIS;
ctx = this->ctx;
if (ctx->log.gf_log_xl_log_set) {
if (this->loglevel && (level > this->loglevel))
goto out;
}
if (level > ctx->log.loglevel)
goto out;
static char *level_strings[] = {"", /* NONE */
"M", /* EMERGENCY */
"A", /* ALERT */
"C", /* CRITICAL */
"E", /* ERROR */
"W", /* WARNING */
"N", /* NOTICE */
"I", /* INFO */
"D", /* DEBUG */
"T", /* TRACE */
""};
if (!domain || !file || !function || !fmt) {
fprintf (stderr,
"logging: %s:%s():%d: invalid argument\n",
__FILE__, __PRETTY_FUNCTION__, __LINE__);
return -1;
}
if (ctx->log.logrotate) {
ctx->log.logrotate = 0;
fd = open (ctx->log.filename,
O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
if (fd < 0) {
gf_log ("logrotate", GF_LOG_ERROR,
"%s", strerror (errno));
return -1;
}
close (fd);
new_logfile = fopen (ctx->log.filename, "a");
if (!new_logfile) {
gf_log ("logrotate", GF_LOG_CRITICAL,
"failed to open logfile %s (%s)",
ctx->log.filename, strerror (errno));
goto log;
}
pthread_mutex_lock (&ctx->log.logfile_mutex);
{
if (ctx->log.logfile)
fclose (ctx->log.logfile);
ctx->log.gf_log_logfile = ctx->log.logfile = new_logfile;
}
pthread_mutex_unlock (&ctx->log.logfile_mutex);
}
log:
ret = gettimeofday (&tv, NULL);
if (-1 == ret)
goto out;
va_start (ap, fmt);
gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr),
".%"GF_PRI_SUSECONDS, tv.tv_usec);
basename = strrchr (file, '/');
if (basename)
basename++;
else
basename = file;
ret = gf_asprintf (&str1, "[%s] %s [%s:%d:%s] %d-%s: ",
timestr, level_strings[level],
basename, line, function,
((this->graph)?this->graph->id:0), domain);
if (-1 == ret) {
goto err;
}
ret = vasprintf (&str2, fmt, ap);
if (-1 == ret) {
goto err;
}
va_end (ap);
len = strlen (str1);
msg = GF_MALLOC (len + strlen (str2) + 1, gf_common_mt_char);
strcpy (msg, str1);
strcpy (msg + len, str2);
pthread_mutex_lock (&ctx->log.logfile_mutex);
{
if (ctx->log.logfile) {
fprintf (ctx->log.logfile, "%s\n", msg);
fflush (ctx->log.logfile);
} else {
fprintf (stderr, "%s\n", msg);
fflush (stderr);
}
#ifdef GF_LINUX_HOST_OS
/* We want only serious log in 'syslog', not our debug
and trace logs */
if (ctx->log.gf_log_syslog && level &&
(level <= ctx->log.sys_log_level))
syslog ((level-1), "%s\n", msg);
#endif
}
pthread_mutex_unlock (&ctx->log.logfile_mutex);
err:
GF_FREE (msg);
GF_FREE (str1);
FREE (str2);
out:
return (0);
}
int
_gf_log_eh (const char *function, const char *fmt, ...)
{
int ret = -1;
va_list ap;
char *str1 = NULL;
char *str2 = NULL;
char *msg = NULL;
xlator_t *this = NULL;
this = THIS;
ret = gf_asprintf (&str1, "[%d] %s: ",
((this->graph)?this->graph->id:0),
function);
if (-1 == ret) {
goto out;
}
va_start (ap, fmt);
ret = vasprintf (&str2, fmt, ap);
if (-1 == ret) {
goto out;
}
va_end (ap);
msg = GF_MALLOC (strlen (str1) + strlen (str2) + 1, gf_common_mt_char);
if (!msg) {
ret = -1;
goto out;
}
strcpy (msg, str1);
strcat (msg, str2);
ret = eh_save_history (this->history, msg);
out:
GF_FREE (str1);
/* Use FREE instead of GF_FREE since str2 was allocated by vasprintf */
if (str2)
FREE (str2);
return ret;
}
/*
* 初始化"命令记录"日志
*/
int
gf_cmd_log_init (const char *filename)
{
int fd = -1;
xlator_t *this = NULL;
glusterfs_ctx_t *ctx = NULL;
this = THIS;
ctx = this->ctx;
if (!filename){
gf_log (this->name, GF_LOG_CRITICAL, "gf_cmd_log_init: no "
"filename specified\n");
return -1;
}
ctx->log.cmd_log_filename = gf_strdup (filename);
if (!ctx->log.cmd_log_filename) {
gf_log (this->name, GF_LOG_CRITICAL,
"gf_cmd_log_init: strdup error\n");
return -1;
}
/* close and reopen cmdlogfile for log rotate*/
if (ctx->log.cmdlogfile) {
fclose (ctx->log.cmdlogfile);
ctx->log.cmdlogfile = NULL;
}
fd = open (ctx->log.cmd_log_filename,
O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
if (fd < 0) {
gf_log (this->name, GF_LOG_CRITICAL,
"%s", strerror (errno));
return -1;
}
close (fd);
ctx->log.cmdlogfile = fopen (ctx->log.cmd_log_filename, "a");
if (!ctx->log.cmdlogfile){
gf_log (this->name, GF_LOG_CRITICAL,
"gf_cmd_log_init: failed to open logfile \"%s\" "
"(%s)\n", ctx->log.cmd_log_filename, strerror (errno));
return -1;
}
return 0;
}
/*
* 记录命令日志到文件
*/
int
gf_cmd_log (const char *domain, const char *fmt, ...)
{
va_list ap;
char timestr[64];
struct timeval tv = {0,};
char *str1 = NULL;
char *str2 = NULL;
char *msg = NULL;
size_t len = 0;
int ret = 0;
glusterfs_ctx_t *ctx = NULL;
ctx = THIS->ctx;
if (!ctx->log.cmdlogfile)
return -1;
if (!domain || !fmt) {
gf_log ("glusterd", GF_LOG_TRACE,
"logging: invalid argument\n");
return -1;
}
ret = gettimeofday (&tv, NULL);
if (ret == -1)
goto out;
va_start (ap, fmt);
gf_time_fmt (timestr, sizeof timestr, tv.tv_sec, gf_timefmt_FT);
snprintf (timestr + strlen (timestr), 256 - strlen (timestr),
".%"GF_PRI_SUSECONDS, tv.tv_usec);
ret = gf_asprintf (&str1, "[%s] %s : ",
timestr, domain);
if (ret == -1) {
goto out;
}
ret = vasprintf (&str2, fmt, ap);
if (ret == -1) {
goto out;
}
va_end (ap);
len = strlen (str1);
msg = GF_MALLOC (len + strlen (str2) + 1, gf_common_mt_char);
strcpy (msg, str1);
strcpy (msg + len, str2);
fprintf (ctx->log.cmdlogfile, "%s\n", msg);
fflush (ctx->log.cmdlogfile);
out:
GF_FREE (msg);
GF_FREE (str1);
FREE (str2);
return (0);
}