Annotation of Net2/kern/subr_log.c, revision 1.1.1.2

1.1       root        1: /*
                      2:  * Copyright (c) 1982, 1986 Regents of the University of California.
                      3:  * All rights reserved.
                      4:  *
                      5:  * Redistribution and use in source and binary forms, with or without
                      6:  * modification, are permitted provided that the following conditions
                      7:  * are met:
                      8:  * 1. Redistributions of source code must retain the above copyright
                      9:  *    notice, this list of conditions and the following disclaimer.
                     10:  * 2. Redistributions in binary form must reproduce the above copyright
                     11:  *    notice, this list of conditions and the following disclaimer in the
                     12:  *    documentation and/or other materials provided with the distribution.
                     13:  * 3. All advertising materials mentioning features or use of this software
                     14:  *    must display the following acknowledgement:
                     15:  *     This product includes software developed by the University of
                     16:  *     California, Berkeley and its contributors.
                     17:  * 4. Neither the name of the University nor the names of its contributors
                     18:  *    may be used to endorse or promote products derived from this software
                     19:  *    without specific prior written permission.
                     20:  *
                     21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     31:  * SUCH DAMAGE.
                     32:  *
1.1.1.2 ! root       33:  *     from: @(#)subr_log.c    7.11 (Berkeley) 3/17/91
        !            34:  *     subr_log.c,v 1.3 1993/06/27 06:01:52 andrew Exp
1.1       root       35:  */
                     36: 
                     37: /*
                     38:  * Error log buffer for kernel printf's.
                     39:  */
                     40: 
                     41: #include "param.h"
1.1.1.2 ! root       42: #include "systm.h"
1.1       root       43: #include "proc.h"
                     44: #include "vnode.h"
                     45: #include "ioctl.h"
                     46: #include "msgbuf.h"
                     47: #include "file.h"
1.1.1.2 ! root       48: #include "select.h"
1.1       root       49: 
                     50: #define LOG_RDPRI      (PZERO + 1)
                     51: 
                     52: #define LOG_ASYNC      0x04
                     53: #define LOG_RDWAIT     0x08
                     54: 
                     55: struct logsoftc {
                     56:        int     sc_state;               /* see above for possibilities */
1.1.1.2 ! root       57:        struct selinfo sc_selp;         /* process waiting on select call */
1.1       root       58:        int     sc_pgid;                /* process/group for async I/O */
                     59: } logsoftc;
                     60: 
                     61: int    log_open;                       /* also used in log() */
                     62: 
                     63: /*ARGSUSED*/
1.1.1.2 ! root       64: int
1.1       root       65: logopen(dev, flags, mode, p)
                     66:        dev_t dev;
                     67:        int flags, mode;
                     68:        struct proc *p;
                     69: {
                     70:        register struct msgbuf *mbp = msgbufp;
                     71: 
                     72:        if (log_open)
                     73:                return (EBUSY);
                     74:        log_open = 1;
                     75:        logsoftc.sc_pgid = p->p_pid;            /* signal process only */
                     76:        /*
                     77:         * Potential race here with putchar() but since putchar should be
                     78:         * called by autoconf, msg_magic should be initialized by the time
                     79:         * we get here.
                     80:         */
                     81:        if (mbp->msg_magic != MSG_MAGIC) {
                     82:                register int i;
                     83: 
                     84:                mbp->msg_magic = MSG_MAGIC;
                     85:                mbp->msg_bufx = mbp->msg_bufr = 0;
                     86:                for (i=0; i < MSG_BSIZE; i++)
                     87:                        mbp->msg_bufc[i] = 0;
                     88:        }
                     89:        return (0);
                     90: }
                     91: 
                     92: /*ARGSUSED*/
1.1.1.2 ! root       93: int
1.1       root       94: logclose(dev, flag)
                     95:        dev_t dev;
1.1.1.2 ! root       96:        int flag;
1.1       root       97: {
                     98:        log_open = 0;
                     99:        logsoftc.sc_state = 0;
1.1.1.2 ! root      100:        bzero(&logsoftc.sc_selp, sizeof(logsoftc.sc_selp));
        !           101:        return 0;
1.1       root      102: }
                    103: 
                    104: /*ARGSUSED*/
1.1.1.2 ! root      105: int
1.1       root      106: logread(dev, uio, flag)
                    107:        dev_t dev;
                    108:        struct uio *uio;
                    109:        int flag;
                    110: {
                    111:        register struct msgbuf *mbp = msgbufp;
                    112:        register long l;
                    113:        register int s;
                    114:        int error = 0;
                    115: 
                    116:        s = splhigh();
                    117:        while (mbp->msg_bufr == mbp->msg_bufx) {
                    118:                if (flag & IO_NDELAY) {
                    119:                        splx(s);
                    120:                        return (EWOULDBLOCK);
                    121:                }
                    122:                logsoftc.sc_state |= LOG_RDWAIT;
                    123:                if (error = tsleep((caddr_t)mbp, LOG_RDPRI | PCATCH,
                    124:                    "klog", 0)) {
                    125:                        splx(s);
                    126:                        return (error);
                    127:                }
                    128:        }
                    129:        splx(s);
                    130:        logsoftc.sc_state &= ~LOG_RDWAIT;
                    131: 
                    132:        while (uio->uio_resid > 0) {
                    133:                l = mbp->msg_bufx - mbp->msg_bufr;
                    134:                if (l < 0)
                    135:                        l = MSG_BSIZE - mbp->msg_bufr;
                    136:                l = MIN(l, uio->uio_resid);
                    137:                if (l == 0)
                    138:                        break;
                    139:                error = uiomove((caddr_t)&mbp->msg_bufc[mbp->msg_bufr],
                    140:                        (int)l, uio);
                    141:                if (error)
                    142:                        break;
                    143:                mbp->msg_bufr += l;
                    144:                if (mbp->msg_bufr < 0 || mbp->msg_bufr >= MSG_BSIZE)
                    145:                        mbp->msg_bufr = 0;
                    146:        }
                    147:        return (error);
                    148: }
                    149: 
                    150: /*ARGSUSED*/
1.1.1.2 ! root      151: int
1.1       root      152: logselect(dev, rw, p)
                    153:        dev_t dev;
                    154:        int rw;
                    155:        struct proc *p;
                    156: {
                    157:        int s = splhigh();
                    158: 
                    159:        switch (rw) {
                    160: 
                    161:        case FREAD:
                    162:                if (msgbufp->msg_bufr != msgbufp->msg_bufx) {
                    163:                        splx(s);
                    164:                        return (1);
                    165:                }
1.1.1.2 ! root      166:                selrecord(p, &logsoftc.sc_selp);
1.1       root      167:                break;
                    168:        }
                    169:        splx(s);
                    170:        return (0);
                    171: }
                    172: 
1.1.1.2 ! root      173: void
1.1       root      174: logwakeup()
                    175: {
                    176:        struct proc *p;
                    177: 
                    178:        if (!log_open)
                    179:                return;
1.1.1.2 ! root      180:        selwakeup(&logsoftc.sc_selp);
1.1       root      181:        if (logsoftc.sc_state & LOG_ASYNC) {
                    182:                if (logsoftc.sc_pgid < 0)
                    183:                        gsignal(-logsoftc.sc_pgid, SIGIO); 
                    184:                else if (p = pfind(logsoftc.sc_pgid))
                    185:                        psignal(p, SIGIO);
                    186:        }
                    187:        if (logsoftc.sc_state & LOG_RDWAIT) {
                    188:                wakeup((caddr_t)msgbufp);
                    189:                logsoftc.sc_state &= ~LOG_RDWAIT;
                    190:        }
                    191: }
                    192: 
                    193: /*ARGSUSED*/
1.1.1.2 ! root      194: int
1.1       root      195: logioctl(dev, com, data, flag)
1.1.1.2 ! root      196:        dev_t dev;
        !           197:        int com;
1.1       root      198:        caddr_t data;
1.1.1.2 ! root      199:        int flag;
1.1       root      200: {
                    201:        long l;
                    202:        int s;
                    203: 
                    204:        switch (com) {
                    205: 
                    206:        /* return number of characters immediately available */
                    207:        case FIONREAD:
                    208:                s = splhigh();
                    209:                l = msgbufp->msg_bufx - msgbufp->msg_bufr;
                    210:                splx(s);
                    211:                if (l < 0)
                    212:                        l += MSG_BSIZE;
                    213:                *(off_t *)data = l;
                    214:                break;
                    215: 
                    216:        case FIONBIO:
                    217:                break;
                    218: 
                    219:        case FIOASYNC:
                    220:                if (*(int *)data)
                    221:                        logsoftc.sc_state |= LOG_ASYNC;
                    222:                else
                    223:                        logsoftc.sc_state &= ~LOG_ASYNC;
                    224:                break;
                    225: 
                    226:        case TIOCSPGRP:
                    227:                logsoftc.sc_pgid = *(int *)data;
                    228:                break;
                    229: 
                    230:        case TIOCGPGRP:
                    231:                *(int *)data = logsoftc.sc_pgid;
                    232:                break;
                    233: 
                    234:        default:
                    235:                return (-1);
                    236:        }
                    237:        return (0);
                    238: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.