/*

 * 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 (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.

 */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/varargs.h>

#include <sys/systm.h>

#include <sys/cmn_err.h>

#include <sys/stream.h>

#include <sys/strsubr.h>

#include <sys/strsun.h>

#include <sys/sysmacros.h>

#include <sys/kmem.h>

#include <sys/log.h>

#include <sys/spl.h>

#include <sys/syslog.h>

#include <sys/console.h>

#include <sys/debug.h>

#include <sys/utsname.h>

#include <sys/id_space.h>

#include <sys/zone.h>

log_zone_t log_global;

queue_t *log_consq;

queue_t *log_backlogq;

queue_t *log_intrq;

#define	LOG_PRISIZE	8	/* max priority size: 7 characters + null */

#define	LOG_FACSIZE	9	/* max priority size: 8 characters + null */

static krwlock_t log_rwlock;

static int log_rwlock_depth;

static int log_seq_no[SL_CONSOLE + 1];

static stdata_t log_fakestr;

static id_space_t *log_minorspace;

static log_t log_backlog;

static struct kmem_cache *log_cons_cache;	/* log_t cache */

static queue_t *log_recentq;

static queue_t *log_freeq;

static zone_key_t log_zone_key;

static char log_overflow_msg[] = "message overflow on /dev/log minor #%d%s\n";

static char log_pri[LOG_PRIMASK + 1][LOG_PRISIZE] = {

	"emerg",	"alert",	"crit",		"error",

	"warning",	"notice",	"info",		"debug"

};

static char log_fac[LOG_NFACILITIES + 1][LOG_FACSIZE] = {

	"kern",		"user",		"mail",		"daemon",

	"auth",		"syslog",	"lpr",		"news",

	"uucp",		"resv9",	"resv10",	"resv11",

	"resv12",	"audit",	"resv14",	"cron",

	"local0",	"local1",	"local2",	"local3",

	"local4",	"local5",	"local6",	"local7",

	"unknown"

};

static int log_cons_constructor(void *, void *, int);

static void log_cons_destructor(void *, void *);

/*

 * Get exclusive access to the logging system; this includes all minor

 * devices.  We use an rwlock rather than a mutex because hold times

 * are potentially long, so we don't want to waste cycles in adaptive mutex

 * spin (rwlocks always block when contended).  Note that we explicitly

 * support recursive calls (e.g. printf() calls foo() calls printf()).

 *

 * Clients may use log_enter() / log_exit() to guarantee that a group

 * of messages is treated atomically (i.e. they appear in order and are

 * not interspersed with any other messages), e.g. for multiline printf().

 *

 * This could probably be changed to a per-zone lock if contention becomes

 * an issue.

 */

void

log_enter(void)

{

	if (rw_owner(&log_rwlock) != curthread)

		rw_enter(&log_rwlock, RW_WRITER);

	log_rwlock_depth++;

}

void

log_exit(void)

{

	if (--log_rwlock_depth == 0)

		rw_exit(&log_rwlock);

}

void

log_flushq(queue_t *q)

{

	mblk_t *mp;

	log_t *lp = (log_t *)q->q_ptr;

	/* lp will be NULL if the queue was created via log_makeq */

	while ((mp = getq_noenab(q, 0)) != NULL)

		log_sendmsg(mp, lp == NULL ? GLOBAL_ZONEID : lp->log_zoneid);

}

/*

 * Create a minimal queue with just enough fields filled in to support

 * canput(9F), putq(9F), and getq_noenab(9F).  We set QNOENB to ensure

 * that the queue will never be enabled.

 */

static queue_t *

log_makeq(size_t lowat, size_t hiwat, void *ibc)

{

	queue_t *q;

	q = kmem_zalloc(sizeof (queue_t), KM_SLEEP);

	q->q_stream = &log_fakestr;

	q->q_flag = QISDRV | QMTSAFE | QNOENB | QREADR | QUSE;

	q->q_nfsrv = q;

	q->q_lowat = lowat;

	q->q_hiwat = hiwat;

	mutex_init(QLOCK(q), NULL, MUTEX_DRIVER, ibc);

	return (q);

}

/*

 * Initialize the log structure for a new zone.

 */

static void *

log_zoneinit(zoneid_t zoneid)

{

	int i;

	log_zone_t *lzp;

	if (zoneid == GLOBAL_ZONEID)

		lzp = &log_global;	/* use statically allocated struct */

	else

		lzp = kmem_zalloc(sizeof (log_zone_t), KM_SLEEP);

	for (i = 0; i < LOG_NUMCLONES; i++) {

		lzp->lz_clones[i].log_minor =

		    (minor_t)id_alloc(log_minorspace);

		lzp->lz_clones[i].log_zoneid = zoneid;

	}

	return (lzp);

}

/*ARGSUSED*/

static void

log_zonefree(zoneid_t zoneid, void *arg)

{

	log_zone_t *lzp = arg;

	int i;

	ASSERT(lzp != &log_global && zoneid != GLOBAL_ZONEID);

	if (lzp == NULL)

		return;

	for (i = 0; i < LOG_NUMCLONES; i++)

		id_free(log_minorspace, lzp->lz_clones[i].log_minor);

	kmem_free(lzp, sizeof (log_zone_t));

}

void

log_init(void)

{

	int log_maxzones;

	/*

	 * Create a backlog queue to consume console messages during periods

	 * when there is no console reader (e.g. before syslogd(1M) starts).

	 */

	log_backlogq = log_consq = log_makeq(0, LOG_HIWAT, NULL);

	/*

	 * Create a queue to hold free message of size <= LOG_MSGSIZE.

	 * Calls from high-level interrupt handlers will do a getq_noenab()

	 * from this queue, so its q_lock must be a maximum SPL spin lock.

	 */

	log_freeq = log_makeq(LOG_MINFREE, LOG_MAXFREE, (void *)ipltospl(SPL8));

	/*

	 * Create a queue for messages from high-level interrupt context.

	 * These messages are drained via softcall, or explicitly by panic().

	 */

	log_intrq = log_makeq(0, LOG_HIWAT, (void *)ipltospl(SPL8));

	/*

	 * Create a queue to hold the most recent 8K of console messages.

	 * Useful for debugging.  Required by the "$<msgbuf" adb macro.

	 */

	log_recentq = log_makeq(0, LOG_RECENTSIZE, NULL);

	/*

	 * Create an id space for clone devices opened via /dev/log.

	 * Need to limit the number of zones to avoid exceeding the

	 * available minor number space.

	 */

	log_maxzones = (L_MAXMIN32 - LOG_LOGMIN) / LOG_NUMCLONES - 1;

	if (log_maxzones < maxzones)

		maxzones = log_maxzones;

	log_minorspace = id_space_create("logminor_space", LOG_LOGMIN + 1,

	    L_MAXMIN32);

	/*

	 * Put ourselves on the ZSD list.  Note that zones have not been

	 * initialized yet, but our constructor will be called on the global

	 * zone when they are.

	 */

	zone_key_create(&log_zone_key, log_zoneinit, NULL, log_zonefree);

	/*

	 * Initialize backlog structure.

	 */

	log_backlog.log_zoneid = GLOBAL_ZONEID;

	log_backlog.log_minor = LOG_BACKLOG;

	/* Allocate kmem cache for conslog's log structures */

	log_cons_cache = kmem_cache_create("log_cons_cache",

	    sizeof (struct log), 0, log_cons_constructor, log_cons_destructor,

	    NULL, NULL, NULL, 0);

	/*

	 * Let the logging begin.

	 */

	log_update(&log_backlog, log_backlogq, SL_CONSOLE, log_console);

	/*

	 * Now that logging is enabled, emit the SunOS banner.

	 */

	    utsname.version, NBBY * (uint_t)sizeof (void *));

	printf("SunOS Release %s - Copyright 1983-2010 Oracle and/or its "

	    "affiliates.\n", utsname.release);

	printf("All rights reserved. Use is subject to license terms.\n");

#ifdef DEBUG

	printf("DEBUG enabled\n");

#endif

}

/*

 * Allocate a log device corresponding to supplied device type.

 * Both devices are clonable. /dev/log devices are allocated per zone.

 * /dev/conslog devices are allocated from kmem cache.

 */

log_t *

log_alloc(minor_t type)

{

	zone_t *zptr = curproc->p_zone;

	log_zone_t *lzp;

	log_t *lp;

	int i;

	minor_t minor;

	if (type == LOG_CONSMIN) {

		/*

		 * Return a write-only /dev/conslog device.

		 * No point allocating log_t until there's a free minor number.

		 */

		minor = (minor_t)id_alloc(log_minorspace);

		lp = kmem_cache_alloc(log_cons_cache, KM_SLEEP);

		lp->log_minor = minor;

		return (lp);

	} else {

		ASSERT(type == LOG_LOGMIN);

		lzp = zone_getspecific(log_zone_key, zptr);

		ASSERT(lzp != NULL);

		/* search for an available /dev/log device for the zone */

		for (i = LOG_LOGMINIDX; i <= LOG_LOGMAXIDX; i++) {

			lp = &lzp->lz_clones[i];

			if (lp->log_inuse == 0)

				break;

		}

		if (i > LOG_LOGMAXIDX)

			lp = NULL;

		else

			/* Indicate which device type */

			lp->log_major = LOG_LOGMIN;

		return (lp);

	}

}

void

log_free(log_t *lp)

{

	id_free(log_minorspace, lp->log_minor);

	kmem_cache_free(log_cons_cache, lp);

}

/*

 * Move console messages from src to dst.  The time of day isn't known

 * early in boot, so fix up the message timestamps if necessary.

 */

static void

log_conswitch(log_t *src, log_t *dst)

{

	mblk_t *mp;

	mblk_t *hmp = NULL;

	mblk_t *tmp = NULL;

	log_ctl_t *hlc;

	while ((mp = getq_noenab(src->log_q, 0)) != NULL) {

		log_ctl_t *lc = (log_ctl_t *)mp->b_rptr;

		lc->flags |= SL_LOGONLY;

		/*

		 * The ttime is written with 0 in log_sensmsg() only when

		 * good gethrestime_sec() data is not available to store in

		 * the log_ctl_t in the early boot phase.

		 */

		if (lc->ttime == 0) {

			/*

			 * Look ahead to first early boot message with time.

			 */

			if (hmp) {

				tmp->b_next = mp;

				tmp = mp;

			} else

				hmp = tmp = mp;

			continue;

		}

		while (hmp) {

			tmp = hmp->b_next;

			hmp->b_next = NULL;

			hlc = (log_ctl_t *)hmp->b_rptr;

			/*

			 * Calculate hrestime for an early log message with

			 * an invalid time stamp. We know:

			 *  - the lbolt of the invalid time stamp.

			 *  - the hrestime and lbolt of the first valid

			 *    time stamp.

			 */

			hlc->ttime = lc->ttime - (lc->ltime - hlc->ltime) / hz;

			(void) putq(dst->log_q, hmp);

			hmp = tmp;

		}

		(void) putq(dst->log_q, mp);

	}

	while (hmp) {

		tmp = hmp->b_next;

		hmp->b_next = NULL;

		hlc = (log_ctl_t *)hmp->b_rptr;

		hlc->ttime = gethrestime_sec() -

		    (ddi_get_lbolt() - hlc->ltime) / hz;

		(void) putq(dst->log_q, hmp);

		hmp = tmp;

	}

	dst->log_overflow = src->log_overflow;

	src->log_flags = 0;

	dst->log_flags = SL_CONSOLE;

	log_consq = dst->log_q;

}

/*

 * Set the fields in the 'target' clone to the specified values.

 * Then, look at all clones to determine which message types are

 * currently active and which clone is the primary console queue.

 * If the primary console queue changes to or from the backlog

 * queue, copy all messages from backlog to primary or vice versa.

 */

void

log_update(log_t *target, queue_t *q, short flags, log_filter_t *filter)

{

	log_t *lp;

	short active = SL_CONSOLE;

	zone_t *zptr = NULL;

	log_zone_t *lzp;

	zoneid_t zoneid = target->log_zoneid;

	int i;

	log_enter();

	if (q != NULL)

		target->log_q = q;

	target->log_wanted = filter;

	target->log_flags = flags;

	target->log_overflow = 0;

	/*

	 * Need to special case the global zone here since this may be

	 * called before zone_init.

	 */

	if (zoneid == GLOBAL_ZONEID) {

		lzp = &log_global;

	} else if ((zptr = zone_find_by_id(zoneid)) == NULL) {

		log_exit();

		return;		/* zone is being destroyed, ignore update */

	} else {

		lzp = zone_getspecific(log_zone_key, zptr);

	}

	ASSERT(lzp != NULL);

	for (i = LOG_LOGMAXIDX; i >= LOG_LOGMINIDX; i--) {

		lp = &lzp->lz_clones[i];

		if (zoneid == GLOBAL_ZONEID && (lp->log_flags & SL_CONSOLE))

			log_consq = lp->log_q;

		active |= lp->log_flags;

	}

	lzp->lz_active = active;

	if (zptr)

		zone_rele(zptr);

	if (log_consq == target->log_q) {

		if (flags & SL_CONSOLE)

			log_conswitch(&log_backlog, target);

		else

			log_conswitch(target, &log_backlog);

	}

	target->log_q = q;

	log_exit();

}

/*ARGSUSED*/

int

log_error(log_t *lp, log_ctl_t *lc)

{

	if ((lc->pri & LOG_FACMASK) == LOG_KERN)

		lc->pri = LOG_KERN | LOG_ERR;

	return (1);

}

int

log_trace(log_t *lp, log_ctl_t *lc)

{

	trace_ids_t *tid = (trace_ids_t *)lp->log_data->b_rptr;

	trace_ids_t *tidend = (trace_ids_t *)lp->log_data->b_wptr;

	/*

	 * We use `tid + 1 <= tidend' here rather than the more traditional

	 * `tid < tidend', since the former ensures that there's at least

	 * `sizeof (trace_ids_t)' bytes available before executing the

	 * loop, whereas the latter only ensures that there's a single byte.

	 */

	for (; tid + 1 <= tidend; tid++) {

		if (tid->ti_level < lc->level && tid->ti_level >= 0)

			continue;

		if (tid->ti_mid != lc->mid && tid->ti_mid >= 0)

			continue;

		if (tid->ti_sid != lc->sid && tid->ti_sid >= 0)

			continue;

		if ((lc->pri & LOG_FACMASK) == LOG_KERN)

			lc->pri = LOG_KERN | LOG_DEBUG;

		return (1);

	}

	return (0);

}

/*ARGSUSED*/

int

log_console(log_t *lp, log_ctl_t *lc)

{

	if ((lc->pri & LOG_FACMASK) == LOG_KERN) {

		if (lc->flags & SL_FATAL)

			lc->pri = LOG_KERN | LOG_CRIT;

		else if (lc->flags & SL_ERROR)

			lc->pri = LOG_KERN | LOG_ERR;

		else if (lc->flags & SL_WARN)

			lc->pri = LOG_KERN | LOG_WARNING;

		else if (lc->flags & SL_NOTE)

			lc->pri = LOG_KERN | LOG_NOTICE;

		else if (lc->flags & SL_TRACE)

			lc->pri = LOG_KERN | LOG_DEBUG;

		else

			lc->pri = LOG_KERN | LOG_INFO;

	}

	return (1);

}

mblk_t *

log_makemsg(int mid, int sid, int level, int sl, int pri, void *msg,

	size_t size, int on_intr)

{

	mblk_t *mp = NULL;

	mblk_t *mp2;

	log_ctl_t *lc;

	if (size <= LOG_MSGSIZE &&

	    (on_intr || log_freeq->q_count > log_freeq->q_lowat))

		mp = getq_noenab(log_freeq, 0);

	if (mp == NULL) {

		if (on_intr ||

		    (mp = allocb(sizeof (log_ctl_t), BPRI_HI)) == NULL ||

		    (mp2 = allocb(MAX(size, LOG_MSGSIZE), BPRI_HI)) == NULL) {

			freemsg(mp);

			return (NULL);

		}

		DB_TYPE(mp) = M_PROTO;

		mp->b_wptr += sizeof (log_ctl_t);

		mp->b_cont = mp2;

	} else {

		mp2 = mp->b_cont;

		mp2->b_wptr = mp2->b_rptr;

	}

	lc = (log_ctl_t *)mp->b_rptr;

	lc->mid = mid;

	lc->sid = sid;