tools/diskomizer/log.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)log.c	1.20	09/05/26 SMI"

/*
 * logging routines.
 */
#ifndef _LARGEFILE64_SOURCE
#define	_LARGEFILE64_SOURCE
#endif
#include <stdio.h>
#include <stdarg.h>
#include <thread.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <ctype.h>
#include "diskomizer64mpism.h"
#include <diskomizer/log.h>
#include "args.h"
#include "locks.h"
#include "time.h"

struct log {
	FILE *fp;
	long log_instance;
	int log_depth;
};

static struct facility {
	char *str;
	int fac;
} faclities[] = {
	"kern", LOG_KERN,
	"user", LOG_USER,
	"mail", LOG_MAIL,
	"daemon", LOG_DAEMON,
	"auth", LOG_AUTH,
	"lpr", LOG_LPR,
	"news", LOG_NEWS,
	"uucp", LOG_UUCP,
	"cron", LOG_CRON,
	"local0", LOG_LOCAL0,
	"local1", LOG_LOCAL1,
	"local2", LOG_LOCAL2,
	"local3", LOG_LOCAL3,
	"local4", LOG_LOCAL4,
	"local5", LOG_LOCAL5,
	"local6", LOG_LOCAL6,
	"local7", LOG_LOCAL7,
	NULL, -1
};
/*
 * This is ordered so dont insert any elements or change the
 * order.
 */
static struct priority {
	char *str;
	int pri;
} priorities[] = {
	{"EMERG", LOG_EMERG},
	{"ALERT", LOG_ALERT},
	{"CRIT", LOG_CRIT},
	{"ERR", LOG_ERR},
	{"WARNING", LOG_WARNING},
	{"NOTICE", LOG_NOTICE},
	{"INFO", LOG_INFO},
	{"DEBUG", LOG_DEBUG},
	{NULL, -1}
};

static int stderr_pri = LOG_WARNING;
static int stdout_pri = LOG_INFO;
static struct log log;
static char time_error_str[1024];
static void vlog_syslog(int priority, const char *message,  va_list ap);
static void vlog_nosyslog(int priority, const char *message,  va_list ap);

static void (*do_vlog)(int priority, const char *message,  va_list ap) =
	vlog_nosyslog;
#define	LOG_INSTANCE(A) ((A.log_instance * opts.nprocs) + this_proc())

void
vlog(int pri, const char *fmt, va_list ap)
{
	do_vlog(pri, fmt, ap);
}

/*PRINTFLIKE2*/
void
plog(int pri, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	do_vlog(pri, fmt, ap);
}

/*PRINTFLIKE2*/
void
dlog(int pri, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	if (opts.debug_report_errors_as_discovered) {
		do_vlog(pri, fmt, ap);
	}
}

static void
vtime_log(int pri, time_t tyme, const char *fmt, va_list ap)
{
	const char *nfmt;
	char *timestr = alloc_time_str(tyme);
	int len = strlen(fmt);

	while (len && isspace(fmt[len-1])) {
		len--;
	}

	if (timestr == NULL || (nfmt = (char *)malloc(strlen(timestr) + 4 +
	    len)) == NULL) {
		nfmt = fmt;
	} else {
		(void) sprintf((char *)nfmt, "%.*s: %s\n", len, fmt, timestr);
		free(timestr);
	}

	do_vlog(pri, nfmt, ap);

	if (nfmt != fmt)
		free((char *)nfmt);
}

/*PRINTFLIKE3*/
void
time_log(int pri, time_t tyme, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);

	vtime_log(pri, tyme, fmt, ap);
}

/*PRINTFLIKE3*/
void
dtime_log(int pri, time_t tyme, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);

	if (opts.debug_report_errors_as_discovered) {
		vtime_log(pri, tyme, fmt, ap);
	}
}

/*PRINTFLIKE2*/
void
time_now_log(int pri, const char *fmt, ...)
{
	struct timeval tv;
	va_list ap;
	va_start(ap, fmt);

	while (my_gettimeofday(&tv, NULL) == -1)
		pperror("gettimeofday");
	vtime_log(pri, tv.tv_sec, fmt, ap);
}

void
new_log_transaction(FILE *fp)
{

	if (log.log_depth != 0) {
		char *log_time = alloc_time_now();
		if (log_time == NULL) {
			struct timeval tv;
			if (my_gettimeofday(&tv, NULL) == -1)
				tv.tv_sec = 0;

			log_time = time_error_str;
			(void) snprintf(time_error_str,
			    sizeof (time_error_str), "%ld", tv.tv_sec);
		}
		pfprintf(log.fp, "ERROR %ld end: %s\n", LOG_INSTANCE(log),
		    log_time);
		pfprintf(log.fp, "\n");

#ifndef __lint
		if (log_time != time_error_str) {
			free(log_time);
		}
#endif /* __lint */
		log.log_depth = 0;
		log.log_instance++;
	}
	log.fp = fp;
}

int
get_error_instance_number()
{
	return (LOG_INSTANCE(log));
}

static void
vtfprintf(FILE *fd, const char *fmt, va_list ap)
{
	const char *nfmt;
	if ((nfmt = (char *)malloc(20 + strlen(fmt))) == NULL) {
		nfmt = fmt;
	} else {
		(void) sprintf((char *)nfmt, "PID %d: %s", getpid(), fmt);
	}

	(void) vfprintf(fd, nfmt, ap);
	(void) fflush(fd);
	(void) fsync(fileno(fd));
	if (nfmt != fmt)
		free((char *)nfmt);
}

static void
ptfprintf(FILE *fd, char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vtfprintf(fd, fmt, ap);
}

static void
start_log(FILE *fp)
{
	if (log.fp == fp && log.log_depth == 0) {
		char *log_time = alloc_time_now();
		if (log_time == NULL) {
			struct timeval tv;
			if (my_gettimeofday(&tv, NULL) == -1)
				tv.tv_sec = 0;

			log_time = time_error_str;
			(void) snprintf(time_error_str,
			    sizeof (time_error_str), "%ld", tv.tv_sec);
		}
		ptfprintf(log.fp, "ERROR %ld begin: %s\n", LOG_INSTANCE(log),
		    log_time);
#ifndef __lint
		if (log_time != time_error_str) {
			free(log_time);
		}
#endif
		log.log_depth++;
	}
}

static void
vpfprintf(FILE *fd, const char *fmt, va_list ap)
{
	void (*lock_enter)(void);
	void (*lock_exit)(void);

	if (fd == stdout) {
		lock_enter = mutex->stdout_enter;
		lock_exit = mutex->stdout_exit;
	} else {
		lock_enter = mutex->stderr_enter;
		lock_exit = mutex->stderr_exit;
	}
	lock_enter();

	start_log(fd);

	vtfprintf(fd, fmt, ap);

	lock_exit();
}

/*
 * pprintf and pfprintf.
 *
 * Old style interfaces.  The new way is to log all messages using plog()
 * and tlog() with a priority that will route it into the correct file
 * and or syslog
 */
/*PRINTFLIKE1*/
void
pprintf(char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);

	do_vlog(stdout_pri, fmt, ap);
}

/*PRINTFLIKE2*/
void
pfprintf(FILE *fp, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);

	if (fp == stderr || fp == stdout)
		do_vlog(stderr_pri, fmt, ap);
	else
		vpfprintf(fp, fmt, ap);
}

/*PRINTFLIKE2*/
void
dfprintf(FILE *fp, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);


	if (opts.debug_report_errors_as_discovered) {
		if (fp == stderr || fp == stdout) {
			do_vlog(stderr_pri, fmt, ap);
		} else {
			vpfprintf(fp, fmt, ap);
		}
	}
}

/*PRINTFLIKE1*/
void
pperror(char *fmt, ...)
{
	char *nfmt;
	char *errstr = strerror(errno);
	va_list ap;
	va_start(ap, fmt);

	if ((nfmt = (char *)malloc(4 + strlen(errstr) + strlen(fmt))) ==
	    NULL) {
		nfmt = fmt;
	} else {
		(void) sprintf(nfmt, "%s: %s\n", fmt, errstr);
	}
	do_vlog(LOG_ERR, nfmt, ap);
	if (nfmt != fmt)
		free(nfmt);
}

/*PRINTFLIKE1*/
static void
debug_printf(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	do_vlog(LOG_DEBUG, fmt, ap);
}

static void
vlog_nosyslog(int pri, const char *fmt,  va_list ap)
{
	char buf[1024];
	char *nfmt;

	if (opts.obscure_report_priority) {
		(void) snprintf(buf, sizeof (buf),
		    "%s %s", priorities[pri].str, fmt);
		nfmt = buf;
	} else {
		nfmt = (char *)fmt;
	}
	if (pri <= stderr_pri) {
		vpfprintf(stderr, nfmt, ap);
	} else if (pri <= stdout_pri) {
		vpfprintf(stdout, nfmt, ap);
	}
}

static void
vlog_syslog(int priority, const char *message,  va_list ap)
{
	vsyslog(priority, message, ap);
	vlog_nosyslog(priority, message, ap);
}
static int
get_priority(const char *str)
{
	struct priority *pri;
	for (pri = &priorities[0]; pri->str != NULL; pri++) {
		if (strcasecmp(pri->str, str) == 0) {
			return (pri->pri);
		}
	}
	plog(LOG_ERR, "Unknown priority %s\n", str);
	return (-1);
}
static void
get_facility(const char *str, const char *ident)
{
	struct facility *fac;
	for (fac = &faclities[0]; fac->str != NULL; fac++) {
		if (strcasecmp(fac->str, str) == 0) {
			int i;
			do_vlog = vlog_syslog;
			openlog(ident, LOG_NDELAY|LOG_PID, fac->fac);
			if ((i = get_priority(
			    opts.syslog_log_upto_priority)) != -1) {
				(void) setlogmask(LOG_UPTO(i));
			}
			return;
		}
	}
}
void
popenlog(const char *ident)
{
	int i;
	if ((i = get_priority(opts.stderr_priority)) != -1)
		stderr_pri = i;
	if ((i = get_priority(opts.stdout_priority)) != -1)
		stdout_pri = i;

	if (opts.syslog_facility != NULL) {
		get_facility(opts.syslog_facility, ident);
	}
}
void
plog_number_of_bytes(int pri, unsigned long long  x,
	char *singular, char *plural)
{
	char *str = x != 1 ? plural : singular;
	const char *units;
	long long save = x;
	int j;
	int after_decimal_point;
	/*
	 * All the units that fit in 64 bits:
	 * kilo, mega, giga, tera, peta, exa
	 */
	static const char *all_units[] = { "K", "M", "G", "T", "P", "E" };

	units = NULL;

	for (j = 0; j < (sizeof (all_units) / sizeof (all_units[0])); j++) {
		if (x / 1024) {
			after_decimal_point = ((x * 1000) / 1024) % 1000;
			x = x / 1024;
			units = all_units[j];
		} else {
			break;
		}
	}

	if (units) {
		/* Round up it necessary */
		if (after_decimal_point % 10 >= 5) {
			after_decimal_point += 10;
		}
		/* loose the least significant digit */
		after_decimal_point /= 10;

		plog(pri, "%#llx, %lld, %s (%lld.%.2d %s)\n",
		    save, save, str, x, after_decimal_point, units);
	} else {
		plog(pri, "%#llx, %lld, %s\n", save, save, str);
	}

}