unmap (user) address space early enough to allow sleep (if releasing

[unix-history] / usr / src / sys / kern / subr_log.c

diff --git a/usr/src/sys/kern/subr_log.c b/usr/src/sys/kern/subr_log.c
index b555264..b52883e 100644 (file)
--- a/usr/src/sys/kern/subr_log.c
+++ b/usr/src/sys/kern/subr_log.c
@@ -1,160 +1,164 @@
-/*     subr_log.c      6.1     84/07/16        */
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.
+ *
+ * %sccs.include.redist.c%
+ *
+ *     @(#)subr_log.c  7.11 (Berkeley) %G%
+ */

 
 /*
  * Error log buffer for kernel printf's.
  */
 
 
 /*
  * Error log buffer for kernel printf's.
  */
 

-#include "../h/param.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/proc.h"
-#include "../h/ioctl.h"
-#include "../h/msgbuf.h"
-#include "../h/file.h"
-#include "../h/errno.h"
+#include "param.h"
+#include "proc.h"
+#include "vnode.h"
+#include "ioctl.h"
+#include "msgbuf.h"
+#include "file.h"

 
 #define LOG_RDPRI      (PZERO + 1)
 
 
 #define LOG_RDPRI      (PZERO + 1)
 

-#define LOG_OPEN       0x01
-#define LOG_NBIO       0x02

 #define LOG_ASYNC      0x04
 #define LOG_RDWAIT     0x08
 
 struct logsoftc {
        int     sc_state;               /* see above for possibilities */
        struct  proc *sc_selp;          /* process waiting on select call */
 #define LOG_ASYNC      0x04
 #define LOG_RDWAIT     0x08
 
 struct logsoftc {
        int     sc_state;               /* see above for possibilities */
        struct  proc *sc_selp;          /* process waiting on select call */

-       int     sc_pgrp;                /* process group for async I/O */
+       int     sc_pgid;                /* process/group for async I/O */

 } logsoftc;
 
 } logsoftc;
 

-logopen(dev)
+int    log_open;                       /* also used in log() */
+
+/*ARGSUSED*/
+logopen(dev, flags, mode, p)

        dev_t dev;
        dev_t dev;

+       int flags, mode;
+       struct proc *p;

 {
 {

+       register struct msgbuf *mbp = msgbufp;

 
 

-#ifdef LOGDEBUG
-       printf("logopen: dev=0x%x\n", dev);
-#endif
-       if (logsoftc.sc_state & LOG_OPEN)
-               return(EBUSY);
-       logsoftc.sc_state |= LOG_OPEN;
-       logsoftc.sc_selp = 0;
-       logsoftc.sc_pgrp = u.u_procp->p_pgrp;
+       if (log_open)
+               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.
         */
        /*
         * 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 (msgbuf.msg_magic != MSG_MAGIC) {
+       if (mbp->msg_magic != MSG_MAGIC) {

                register int i;
 
                register int i;
 

-               msgbuf.msg_magic = MSG_MAGIC;
-               msgbuf.msg_bufx = msgbuf.msg_bufr = 0;
+               mbp->msg_magic = MSG_MAGIC;
+               mbp->msg_bufx = mbp->msg_bufr = 0;

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

-                       msgbuf.msg_bufc[i] = 0;
+                       mbp->msg_bufc[i] = 0;

        }
        }

-       return(0);
+       return (0);

 }
 
 }
 

+/*ARGSUSED*/

 logclose(dev, flag)
        dev_t dev;
 {
 logclose(dev, flag)
        dev_t dev;
 {

+       log_open = 0;

        logsoftc.sc_state = 0;
        logsoftc.sc_selp = 0;
        logsoftc.sc_state = 0;
        logsoftc.sc_selp = 0;

-       logsoftc.sc_pgrp = 0;
-#ifdef LOGDEBUG
-       printf("logclose: dev=0x%x\n", dev);
-#endif

 }
 
 }
 

-logread(dev, uio)
+/*ARGSUSED*/
+logread(dev, uio, flag)

        dev_t dev;
        struct uio *uio;
        dev_t dev;
        struct uio *uio;

+       int flag;

 {
 {

+       register struct msgbuf *mbp = msgbufp;

        register long l;
        register long l;

-       register u_int c;
-       register struct iovec *iov;

        register int s;
        int error = 0;
 
        register int s;
        int error = 0;
 

-#ifdef LOGDEBUG
-       printf("logread: dev=0x%x\n", dev);
-#endif
-

        s = splhigh();
        s = splhigh();

-       while (msgbuf.msg_bufr == msgbuf.msg_bufx) {
-               if (logsoftc.sc_state & LOG_NBIO) {
+       while (mbp->msg_bufr == mbp->msg_bufx) {
+               if (flag & IO_NDELAY) {

                        splx(s);
                        splx(s);

-                       return(EWOULDBLOCK);
+                       return (EWOULDBLOCK);

                }
                logsoftc.sc_state |= LOG_RDWAIT;
                }
                logsoftc.sc_state |= LOG_RDWAIT;

-               sleep((caddr_t)&msgbuf, LOG_RDPRI);
+               if (error = tsleep((caddr_t)mbp, LOG_RDPRI | PCATCH,
+                   "klog", 0)) {
+                       splx(s);
+                       return (error);
+               }

        }
        splx(s);
        logsoftc.sc_state &= ~LOG_RDWAIT;
 
        while (uio->uio_resid > 0) {
        }
        splx(s);
        logsoftc.sc_state &= ~LOG_RDWAIT;
 
        while (uio->uio_resid > 0) {

-               l = msgbuf.msg_bufx - msgbuf.msg_bufr;
+               l = mbp->msg_bufx - mbp->msg_bufr;

                if (l < 0)
                if (l < 0)

-                       l = MSG_BSIZE - msgbuf.msg_bufr;
-               c = min((u_int) l, (u_int)uio->uio_resid);
-               error = uiomove((caddr_t)&msgbuf.msg_bufc[msgbuf.msg_bufr],
-                       (int)c, UIO_READ, uio);
+                       l = MSG_BSIZE - mbp->msg_bufr;
+               l = MIN(l, uio->uio_resid);
+               if (l == 0)
+                       break;
+               error = uiomove((caddr_t)&mbp->msg_bufc[mbp->msg_bufr],
+                       (int)l, uio);

                if (error)
                        break;
                if (error)
                        break;

-               msgbuf.msg_bufr += c;
-               if (msgbuf.msg_bufr < 0 || msgbuf.msg_bufr >= MSG_BSIZE)
-                       msgbuf.msg_bufr = 0;
+               mbp->msg_bufr += l;
+               if (mbp->msg_bufr < 0 || mbp->msg_bufr >= MSG_BSIZE)
+                       mbp->msg_bufr = 0;

        }
        }

-       return(error);
+       return (error);

 }
 
 }
 

-logselect(dev, rw)
+/*ARGSUSED*/
+logselect(dev, rw, p)

        dev_t dev;
        int rw;
        dev_t dev;
        int rw;

+       struct proc *p;

 {
        int s = splhigh();
 
        switch (rw) {
 
        case FREAD:
 {
        int s = splhigh();
 
        switch (rw) {
 
        case FREAD:

-               if (msgbuf.msg_bufr != msgbuf.msg_bufx)
-                       goto win;
-#ifdef LOGDEBUG
-               if (logsoftc.sc_selp)
-                       printf("logselect: collision\n");
-#endif
-               logsoftc.sc_selp = u.u_procp;
-               break;
-
-       case FWRITE:
-#ifdef LOGDEBUG
-               printf("logselect: FWRITE\n");
-#endif
+               if (msgbufp->msg_bufr != msgbufp->msg_bufx) {
+                       splx(s);
+                       return (1);
+               }
+               logsoftc.sc_selp = p;

                break;
        }
        splx(s);
                break;
        }
        splx(s);

-       return(0);
-win:
-       splx(s);
-       return(1);
+       return (0);

 }
 
 logwakeup()
 {
 }
 
 logwakeup()
 {

+       struct proc *p;

 
 

+       if (!log_open)
+               return;

        if (logsoftc.sc_selp) {
                selwakeup(logsoftc.sc_selp, 0);
                logsoftc.sc_selp = 0;
        }
        if (logsoftc.sc_selp) {
                selwakeup(logsoftc.sc_selp, 0);
                logsoftc.sc_selp = 0;
        }

-       if (logsoftc.sc_state & LOG_ASYNC)
-               gsignal(logsoftc.sc_pgrp, SIGIO); 
+       if (logsoftc.sc_state & LOG_ASYNC) {
+               if (logsoftc.sc_pgid < 0)
+                       gsignal(-logsoftc.sc_pgid, SIGIO); 
+               else if (p = pfind(logsoftc.sc_pgid))
+                       psignal(p, SIGIO);
+       }

        if (logsoftc.sc_state & LOG_RDWAIT) {
        if (logsoftc.sc_state & LOG_RDWAIT) {

-               wakeup((caddr_t)&msgbuf);
+               wakeup((caddr_t)msgbufp);

                logsoftc.sc_state &= ~LOG_RDWAIT;
        }
 }
 
 /*ARGSUSED*/
                logsoftc.sc_state &= ~LOG_RDWAIT;
        }
 }
 
 /*ARGSUSED*/

-logioctl(com, data, flag)
+logioctl(dev, com, data, flag)

        caddr_t data;
 {
        long l;
        caddr_t data;
 {
        long l;


@@ -165,7 +169,7 @@ logioctl(com, data, flag)
        /* return number of characters immediately available */
        case FIONREAD:
                s = splhigh();
        /* return number of characters immediately available */
        case FIONREAD:
                s = splhigh();

-               l = msgbuf.msg_bufx - msgbuf.msg_bufr;
+               l = msgbufp->msg_bufx - msgbufp->msg_bufr;

                splx(s);
                if (l < 0)
                        l += MSG_BSIZE;
                splx(s);
                if (l < 0)
                        l += MSG_BSIZE;


@@ -173,10 +177,6 @@ logioctl(com, data, flag)
                break;
 
        case FIONBIO:
                break;
 
        case FIONBIO:

-               if (*(int *)data)
-                       logsoftc.sc_state |= LOG_NBIO;
-               else
-                       logsoftc.sc_state &= ~LOG_NBIO;

                break;
 
        case FIOASYNC:
                break;
 
        case FIOASYNC:


@@ -187,15 +187,15 @@ logioctl(com, data, flag)
                break;
 
        case TIOCSPGRP:
                break;
 
        case TIOCSPGRP:

-               logsoftc.sc_pgrp = *(int *)data;
+               logsoftc.sc_pgid = *(int *)data;

                break;
 
        case TIOCGPGRP:
                break;
 
        case TIOCGPGRP:

-               *(int *)data = logsoftc.sc_pgrp;
+               *(int *)data = logsoftc.sc_pgid;

                break;
 
        default:
                break;
 
        default:

-               return(-1);
+               return (-1);

        }
        }

-       return(0);
+       return (0);

 }
 }