/*
 * Copyright (c) 1982, 1986 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 *
 *	@(#)subr_log.c	2.1 (2.11BSD) 1999/4/29
 */

/*
 * logioctl() had the wrong number of arguments.  Argh!  Apparently this
 * driver was overlooked when 'dev' was added to ioctl entry points.
 *
 * logclose() returned garbage.  this went unnoticed because most programs
 * don't check status when doing a close.

 * Remove vax ifdefs - this driver is never going back to vaxland.
 *
 * Add support for multiple log devices.  Minor device 0 is the traditional
 * kernel logger (/dev/klog), minor device 1 is reserved for the future device 
 * error logging daemon.  Minor device 2 is used by the 'accounting' daemon
 * 'acctd'.
 */

#define	NLOG	3
	int	nlog = NLOG;

#include "param.h"
#include "user.h"
#include "proc.h"
#include "ioctl.h"
#include "msgbuf.h"
#include "file.h"
#include "inode.h"
#include "errno.h"
#include "uio.h"
#include "machine/seg.h"
#include "map.h"

#define LOG_RDPRI	(PZERO + 1)

#define	LOG_OPEN	0x01
#define LOG_ASYNC	0x04
#define LOG_RDWAIT	0x08

/*
 * This is an efficiency hack.  This global is provided for exit() to
 * test and avoid the overhead of function calls when accounting is
 * turned off.
*/
	int	Acctopen;

	struct	msgbuf	msgbuf[NLOG];
	static	struct logsoftc
		{
		int	sc_state;	/* see above for possibilities */
		struct	proc *sc_selp;	/* process waiting on select call */
		int	sc_pgid;	/* process/group for async I/O */
		int	sc_overrun;	/* full buffer count */
		} logsoftc[NLOG];

/*ARGSUSED*/
logopen(dev, mode)
	dev_t dev;
	int mode;
	{
	register int	unit = minor(dev);

	if	(unit >= NLOG)
		return(ENODEV);
	if	(logisopen(unit))
		return(EBUSY);
	if	(msgbuf[unit].msg_click == 0)	/* no buffer allocated */
		return(ENOMEM);
	logsoftc[unit].sc_state |= LOG_OPEN;
	if	(unit == logACCT)
		Acctopen = 1;
	logsoftc[unit].sc_pgid = u.u_procp->p_pid;  /* signal process only */
	logsoftc[unit].sc_overrun = 0;
	return(0);
	}

/*ARGSUSED*/
logclose(dev, flag)
	dev_t	dev;
	int	flag;
	{
	register int unit = minor(dev);

	logsoftc[unit].sc_state = 0;
	if	(unit == logACCT)
		Acctopen = 0;
	return(0);
	}

/*
 * This is a helper function to keep knowledge of this driver's data
 * structures away from the rest of the kernel.
*/
logisopen(unit)
	int	unit;
	{

	if	(logsoftc[unit].sc_state & LOG_OPEN)
		return(1);
	return(0);
	}

/*ARGSUSED*/
logread(dev, uio, flag)
	dev_t dev;
	struct uio *uio;
	int flag;
	{
	register int l;
	register struct logsoftc *lp;
	register struct msgbuf *mp;
	int	s, error = 0;
	char	buf[ctob(2)];

	l = minor(dev);
	lp = &logsoftc[l];
	mp = &msgbuf[l];
	s = splhigh();
	while	(mp->msg_bufr == mp->msg_bufx)
		{
		if	(flag & IO_NDELAY)
			{
			splx(s);
			return(EWOULDBLOCK);
			}
		lp->sc_state |= LOG_RDWAIT;
		sleep((caddr_t)mp, LOG_RDPRI);
		}
	lp->sc_state &= ~LOG_RDWAIT;

	while	(uio->uio_resid)
		{
		l = mp->msg_bufx - mp->msg_bufr;
/*
 * If the reader and writer are equal then we have caught up and there
 * is nothing more to transfer.
*/
		if	(l == 0)
			break;
/*
 * If the write pointer is behind the reader then only consider as
 * available for now the bytes from the read pointer thru the end of 
 * the buffer.
*/
		if	(l < 0)
			{
			l = MSG_BSIZE - mp->msg_bufr;
/*
 * If the reader is exactly at the end of the buffer it is
 * time to wrap it around to the beginning and recalculate the
 * amount of data to transfer.
*/
			if	(l == 0)
				{
				mp->msg_bufr = 0;
				continue;
				}
			}
		l = MIN(l, uio->uio_resid);
		l = MIN(l, sizeof buf);
		mapseg5(mp->msg_click, (btoc(MSG_BSIZE) << 8) | RW);
		bcopy(&mp->msg_bufc[mp->msg_bufr], buf, l);
		normalseg5();
		error = uiomove(buf, l, uio);
		if	(error)
			break;
		mp->msg_bufr += l;
		}
	splx(s);
	return(error);
	}

/*ARGSUSED*/
logselect(dev, rw)
	dev_t dev;
	int rw;
	{
	register int s = splhigh();
	int	unit = minor(dev);

	switch	(rw)
		{
		case	FREAD:
			if	(msgbuf[unit].msg_bufr != msgbuf[unit].msg_bufx)
				{
				splx(s);
				return(1);
				}
			logsoftc[unit].sc_selp = u.u_procp;
			break;
		}
	splx(s);
	return(0);
	}

logwakeup(unit)
	int	unit;
	{
	register struct proc *p;
	register struct logsoftc *lp;
	register struct msgbuf *mp;

	if	(!logisopen(unit))
		return;
	lp = &logsoftc[unit];
	mp = &msgbuf[unit];
	if	(lp->sc_selp)
		{
		selwakeup(lp->sc_selp, (long) 0);
		lp->sc_selp = 0;
		}
	if	(lp->sc_state & LOG_ASYNC && (mp->msg_bufx != mp->msg_bufr))
		{
		if	(lp->sc_pgid < 0)
			gsignal(-lp->sc_pgid, SIGIO); 
		else if (p = pfind(lp->sc_pgid))
			psignal(p, SIGIO);
		}
	if	(lp->sc_state & LOG_RDWAIT)
		{
		wakeup((caddr_t)mp);
		lp->sc_state &= ~LOG_RDWAIT;
		}
}

/*ARGSUSED*/
logioctl(dev, com, data, flag)
	dev_t	dev;
	u_int	com;
	caddr_t data;
	int	flag;
	{
	long l;
	register int s;
	int	unit;
	register struct logsoftc *lp;
	register struct msgbuf *mp;

	unit = minor(dev);
	lp = &logsoftc[unit];
	mp = &msgbuf[unit];

	switch	(com)
		{
		case	FIONREAD:
			s = splhigh();
			l = mp->msg_bufx - mp->msg_bufr;
			splx(s);
			if	(l < 0)
				l += MSG_BSIZE;
			*(off_t *)data = l;
			break;
		case	FIONBIO:
			break;
		case	FIOASYNC:
			if (*(int *)data)
				lp->sc_state |= LOG_ASYNC;
			else
				lp->sc_state &= ~LOG_ASYNC;
			break;
		case	TIOCSPGRP:
			lp->sc_pgid = *(int *)data;
			break;
		case	TIOCGPGRP:
			*(int *)data = lp->sc_pgid;
			break;
		default:
			return(-1);
		}
	return(0);
	}

/*
 * This is inefficient for single character writes.  Alas, changing this
 * to be buffered would affect the networking code's use of printf.  
*/

logwrt(buf,len,log)
	char	*buf;
	int	len;
	int	log;
	{
	segm	s5;
	register struct msgbuf *mp = &msgbuf[log];
	struct	logsoftc *lp = &logsoftc[log];
	register int	infront;
	int  s, n, writer, err = 0;

	if	(mp->msg_magic != MSG_MAGIC || (len > MSG_BSIZE))
		return(-1);
	saveseg5(s5);
/*
 * Hate to do this but since this can be called from anywhere in the kernel
 * we have to hold off any interrupt service routines so they don't change
 * things.  This looks like a lot of code but it isn't really.
*/
	s = splhigh();
	while	(len)
		{
again:		infront = MSG_BSIZE - mp->msg_bufx;
		if	(infront <= 0)
			{
			mp->msg_bufx = 0;
			infront = MSG_BSIZE - mp->msg_bufr;
			}
		n = mp->msg_bufr - mp->msg_bufx;
		if	(n < 0)		/* bufr < bufx */
			writer = (MSG_BSIZE - mp->msg_bufx) + mp->msg_bufr;
		else if	(n == 0)
			writer = MSG_BSIZE;
		else
			{
			writer = n;
			infront = n;
			}
		if	(len > writer)
			{
/*
 * won't fit.  the total number of bytes to be written is
 * greater than the number available.  the buffer is full.
 * throw away the old data and keep the current data by resetting
 * the 'writer' pointer to the current 'reader' position.  Bump the
 * overrun counter in case anyone wants to look at it for debugging.
*/
			lp->sc_overrun++;
			mp->msg_bufx = mp->msg_bufr;
			goto	again;
			}
		if	(infront > len)
			infront = len;
		mapseg5(mp->msg_click, (btoc(MSG_BSIZE) << 8) | RW);  /* XXX */
		bcopy(buf, &mp->msg_bufc[mp->msg_bufx], infront);
		restorseg5(s5);
		mp->msg_bufx += infront;
		len -= infront;
		buf += infront;
		}
out:	splx(s);
	return(err);
	}

/*
 * Initialize the log driver.  Called from the system startup code (machdep2.c).
 * All buffers are the same (MSG_BSIZE) size.
*/

loginit()
	{
register struct msgbuf *mp;

	for	(mp = &msgbuf[0]; mp < &msgbuf[NLOG]; mp++)
		{
		mp->msg_click = malloc(coremap,btoc(MSG_BSIZE));
		if	(!mp->msg_click)
			return(-1);
		mp->msg_magic = MSG_MAGIC;
		mp->msg_bufc = SEG5;
		mp->msg_bufx = mp->msg_bufr = 0;
		}
	return(0);
	}