/*
- * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2010 Apple, Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
#include <sys/conf.h>
#include <sys/sysctl.h>
#include <kern/kalloc.h>
+#include <pexpert/pexpert.h>
/* XXX should be in a common header somewhere */
-extern void klogwakeup(void);
extern void logwakeup(void);
#define LOG_RDPRI (PZERO + 1)
#define LOG_ASYNC 0x04
#define LOG_RDWAIT 0x08
+#define MAX_UNREAD_CHARS (CONFIG_MSG_BSIZE/2)
+/* All globals should be accessed under LOG_LOCK() */
+
+/* logsoftc only valid while log_open=1 */
struct logsoftc {
int sc_state; /* see above for possibilities */
struct selinfo sc_selp; /* thread waiting for select */
} logsoftc;
int log_open; /* also used in log() */
-char smsg_bufc[MSG_BSIZE]; /* static buffer */
-struct msgbuf temp_msgbuf = {0,MSG_BSIZE,0,0,smsg_bufc};
-struct msgbuf *msgbufp;
-static int _logentrypend = 0;
-static int log_inited = 0;
+char smsg_bufc[CONFIG_MSG_BSIZE]; /* static buffer */
+struct msgbuf msgbuf = {MSG_MAGIC,sizeof(smsg_bufc),0,0,smsg_bufc};
+struct msgbuf *msgbufp __attribute__((used)) = &msgbuf;
+
/* the following are implemented in osfmk/kern/printf.c */
extern void bsd_log_lock(void);
extern void bsd_log_unlock(void);
#define LOG_LOCK() bsd_log_lock()
#define LOG_UNLOCK() bsd_log_unlock()
+#if DEBUG
+#define LOG_SETSIZE_DEBUG(x...) kprintf(x)
+#else
+#define LOG_SETSIZE_DEBUG(x...) do { } while(0)
+#endif
+
+static int sysctl_kern_msgbuf(struct sysctl_oid *oidp,
+ void *arg1,
+ int arg2,
+ struct sysctl_req *req);
/*ARGSUSED*/
int
LOG_UNLOCK();
return (EBUSY);
}
- log_open = 1;
logsoftc.sc_pgid = p->p_pid; /* signal process only */
- /*
- * Potential race here with putchar() but since putchar should be
- * called by autoconf, msg_magic should be initialized by the time
- * we get here.
- */
- if (msgbufp->msg_magic != MSG_MAGIC) {
- register int i;
+ log_open = 1;
- msgbufp->msg_magic = MSG_MAGIC;
- msgbufp->msg_bufx = msgbufp->msg_bufr = 0;
- for (i=0; i < MSG_BSIZE; i++)
- msgbufp->msg_bufc[i] = 0;
- }
LOG_UNLOCK();
return (0);
logclose(__unused dev_t dev, __unused int flag, __unused int devtype, __unused struct proc *p)
{
LOG_LOCK();
- log_open = 0;
selwakeup(&logsoftc.sc_selp);
selthreadclear(&logsoftc.sc_selp);
+ log_open = 0;
LOG_UNLOCK();
return (0);
}
int
logread(__unused dev_t dev, struct uio *uio, int flag)
{
- register long l;
+ int l;
int error = 0;
LOG_LOCK();
logsoftc.sc_state |= LOG_RDWAIT;
LOG_UNLOCK();
/*
- * If the wakeup is missed the ligtening bolt will wake this up
- * if there are any new characters. If that doesn't do it
+ * If the wakeup is missed
* then wait for 5 sec and reevaluate
*/
if ((error = tsleep((caddr_t)msgbufp, LOG_RDPRI | PCATCH,
logsoftc.sc_state &= ~LOG_RDWAIT;
while (uio_resid(uio) > 0) {
+ int readpos;
+
l = msgbufp->msg_bufx - msgbufp->msg_bufr;
if (l < 0)
l = msgbufp->msg_size - msgbufp->msg_bufr;
l = min(l, uio_resid(uio));
if (l == 0)
break;
+
+ readpos = msgbufp->msg_bufr;
LOG_UNLOCK();
- error = uiomove((caddr_t)&msgbufp->msg_bufc[msgbufp->msg_bufr],
- (int)l, uio);
+ error = uiomove((caddr_t)&msgbufp->msg_bufc[readpos],
+ l, uio);
LOG_LOCK();
if (error)
break;
- msgbufp->msg_bufr += l;
- if (msgbufp->msg_bufr < 0 || msgbufp->msg_bufr >= msgbufp->msg_size)
+ msgbufp->msg_bufr = readpos + l;
+ if (msgbufp->msg_bufr >= msgbufp->msg_size)
msgbufp->msg_bufr = 0;
}
out:
LOG_UNLOCK();
}
-void
-klogwakeup(void)
-{
- if (_logentrypend) {
- _logentrypend = 0;
- logwakeup();
- }
-}
/*ARGSUSED*/
int
logioctl(__unused dev_t dev, u_long com, caddr_t data, __unused int flag, __unused struct proc *p)
{
- long l;
+ int l;
LOG_LOCK();
switch (com) {
void
bsd_log_init(void)
{
- if (!log_inited) {
- msgbufp = &temp_msgbuf;
- log_inited = 1;
- }
+ /* After this point, we must be ready to accept characters */
}
void
log_putc_locked(char c)
{
- register struct msgbuf *mbp;
-
- if (!log_inited) {
- panic("bsd log is not inited");
- }
+ struct msgbuf *mbp;
mbp = msgbufp;
- if (mbp-> msg_magic != MSG_MAGIC) {
- register int i;
-
- mbp->msg_magic = MSG_MAGIC;
- mbp->msg_bufx = mbp->msg_bufr = 0;
- for (i=0; i < MSG_BSIZE; i++)
- mbp->msg_bufc[i] = 0;
- }
mbp->msg_bufc[mbp->msg_bufx++] = c;
- _logentrypend = 1;
- if (mbp->msg_bufx < 0 || mbp->msg_bufx >= msgbufp->msg_size)
+ if (mbp->msg_bufx >= msgbufp->msg_size)
mbp->msg_bufx = 0;
}
void
log_putc(char c)
{
- if (!log_inited) {
- panic("bsd log is not inited");
- }
+ int unread_count = 0;
LOG_LOCK();
log_putc_locked(c);
+ unread_count = msgbufp->msg_bufx - msgbufp->msg_bufr;
LOG_UNLOCK();
+
+ if (unread_count < 0)
+ unread_count = 0 - unread_count;
+ if (c == '\n' || unread_count >= MAX_UNREAD_CHARS)
+ logwakeup();
}
* to the kernel command line, and to read the current size using
* sysctl kern.msgbuf
* If there is no parameter on the kernel command line, the buffer is
- * allocated statically and is MSG_BSIZE characters in size, otherwise
- * memory is dynamically allocated.
- * This function may only be called once, during kernel initialization.
- * Memory management must already be up. The buffer must not have
- * overflown yet.
+ * allocated statically and is CONFIG_MSG_BSIZE characters in size, otherwise
+ * memory is dynamically allocated. Memory management must already be up.
*/
-void
-log_setsize(long size) {
+int
+log_setsize(int size) {
char *new_logdata;
- if (msgbufp->msg_size!=MSG_BSIZE) {
- printf("log_setsize: attempt to change size more than once\n");
- return;
- }
- if (size==MSG_BSIZE)
- return;
- if (size<MSG_BSIZE) { /* we don't support reducing the log size */
- printf("log_setsize: can't decrease log size\n");
- return;
- }
+ int new_logsize, new_bufr, new_bufx;
+ char *old_logdata;
+ int old_logsize, old_bufr, old_bufx;
+ int i, count;
+ char *p, ch;
+
+ if (size > MAX_MSG_BSIZE)
+ return (EINVAL);
+
+ if (size <= 0)
+ return (EINVAL);
+
+ new_logsize = size;
if (!(new_logdata = (char*)kalloc(size))) {
printf("log_setsize: unable to allocate memory\n");
- return;
+ return (ENOMEM);
}
+ bzero(new_logdata, new_logsize);
+
LOG_LOCK();
- bcopy(smsg_bufc, new_logdata, MSG_BSIZE);
- bzero(new_logdata+MSG_BSIZE, size - MSG_BSIZE);
+
+ old_logsize = msgbufp->msg_size;
+ old_logdata = msgbufp->msg_bufc;
+ old_bufr = msgbufp->msg_bufr;
+ old_bufx = msgbufp->msg_bufx;
+
+ LOG_SETSIZE_DEBUG("log_setsize(%d): old_logdata %p old_logsize %d old_bufr %d old_bufx %d\n",
+ size, old_logdata, old_logsize, old_bufr, old_bufx);
+
+ /* start "new_logsize" bytes before the write pointer */
+ if (new_logsize <= old_bufx) {
+ count = new_logsize;
+ p = old_logdata + old_bufx - count;
+ } else {
+ /*
+ * if new buffer is bigger, copy what we have and let the
+ * bzero above handle the difference
+ */
+ count = MIN(new_logsize, old_logsize);
+ p = old_logdata + old_logsize - (count - old_bufx);
+ }
+ for (i = 0; i < count; i++) {
+ if (p >= old_logdata + old_logsize)
+ p = old_logdata;
+
+ ch = *p++;
+ new_logdata[i] = ch;
+ }
+
+ new_bufx = i;
+ if (new_bufx >= new_logsize)
+ new_bufx = 0;
+ msgbufp->msg_bufx = new_bufx;
+
+ new_bufr = old_bufx - old_bufr; /* how much were we trailing bufx by? */
+ if (new_bufr < 0)
+ new_bufr += old_logsize;
+ new_bufr = new_bufx - new_bufr; /* now relative to oldest data in new buffer */
+ if (new_bufr < 0)
+ new_bufr += new_logsize;
+ msgbufp->msg_bufr = new_bufr;
+
+ msgbufp->msg_size = new_logsize;
+ msgbufp->msg_bufc = new_logdata;
+
+ LOG_SETSIZE_DEBUG("log_setsize(%d): new_logdata %p new_logsize %d new_bufr %d new_bufx %d\n",
+ size, new_logdata, new_logsize, new_bufr, new_bufx);
+
+ LOG_UNLOCK();
+
/* this memory is now dead - clear it so that it compresses better
in case of suspend to disk etc. */
- bzero(smsg_bufc, MSG_BSIZE);
- msgbufp->msg_size = size;
- msgbufp->msg_bufc = new_logdata;
+ bzero(old_logdata, old_logsize);
+ if (old_logdata != smsg_bufc) {
+ /* dynamic memory that must be freed */
+ kfree(old_logdata, old_logsize);
+ }
+
+ printf("set system log size to %d bytes\n", new_logsize);
+
+ return 0;
+}
+
+SYSCTL_PROC(_kern, OID_AUTO, msgbuf, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, 0, 0, sysctl_kern_msgbuf, "I", "");
+
+static int sysctl_kern_msgbuf(struct sysctl_oid *oidp __unused,
+ void *arg1 __unused,
+ int arg2 __unused,
+ struct sysctl_req *req)
+{
+ int old_bufsize, bufsize;
+ int error;
+
+ LOG_LOCK();
+ old_bufsize = bufsize = msgbufp->msg_size;
LOG_UNLOCK();
- printf("set system log size to %ld bytes\n", msgbufp->msg_size);
+
+ error = sysctl_io_number(req, bufsize, sizeof(bufsize), &bufsize, NULL);
+ if (error)
+ return (error);
+
+ if (bufsize != old_bufsize) {
+ error = log_setsize(bufsize);
+ }
+
+ return (error);
}
-SYSCTL_LONG(_kern, OID_AUTO, msgbuf, CTLFLAG_RD, &temp_msgbuf.msg_size, "");
/*
- * This should be called by single user mode /sbin/dmesg only.
+ * This should be called by /sbin/dmesg only via libproc.
* It returns as much data still in the buffer as possible.
*/
int
log_dmesg(user_addr_t buffer, uint32_t buffersize, int32_t * retval) {
uint32_t i;
- uint32_t localbuff_size = (msgbufp->msg_size + 2);
+ uint32_t localbuff_size;
int error = 0, newl, skip;
char *localbuff, *p, *copystart, ch;
- long copysize;
+ size_t copysize;
+ LOG_LOCK();
+ localbuff_size = (msgbufp->msg_size + 2); /* + '\n' + '\0' */
+ LOG_UNLOCK();
+
+ /* Allocate a temporary non-circular buffer for copyout */
if (!(localbuff = (char *)kalloc(localbuff_size))) {
printf("log_dmesg: unable to allocate memory\n");
return (ENOMEM);
}
+
/* in between here, the log could become bigger, but that's fine */
LOG_LOCK();
}
if (ch == '\0')
continue;
- newl = ch == '\n';
+ newl = (ch == '\n');
localbuff[i++] = ch;
/* The original version of this routine contained a buffer
* overflow. At the time, a "small" targeted fix was desired
projects / apple / xnu.git / blobdiff