bsd/kern/subr_log.c

   1 /*
   2  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  24 /*
  25  * Copyright (c) 1982, 1986, 1993
  26  *      The Regents of the University of California.  All rights reserved.
  27  *
  28  * Redistribution and use in source and binary forms, with or without
  29  * modification, are permitted provided that the following conditions
  30  * are met:
  31  * 1. Redistributions of source code must retain the above copyright
  32  *    notice, this list of conditions and the following disclaimer.
  33  * 2. Redistributions in binary form must reproduce the above copyright
  34  *    notice, this list of conditions and the following disclaimer in the
  35  *    documentation and/or other materials provided with the distribution.
  36  * 3. All advertising materials mentioning features or use of this software
  37  *    must display the following acknowledgement:
  38  *      This product includes software developed by the University of
  39  *      California, Berkeley and its contributors.
  40  * 4. Neither the name of the University nor the names of its contributors
  41  *    may be used to endorse or promote products derived from this software
  42  *    without specific prior written permission.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  45  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  46  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  48  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  50  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  52  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  53  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  54  * SUCH DAMAGE.
  55  *
  56  *      @(#)subr_log.c  8.3 (Berkeley) 2/14/95
  57  */
  58
  59 /*
  60  * Error log buffer for kernel printf's.
  61  */
  62
  63 #include <sys/param.h>
  64 #include <sys/systm.h>
  65 #include <sys/proc_internal.h>
  66 #include <sys/vnode.h>
  67 #include <sys/ioctl.h>
  68 #include <sys/msgbuf.h>
  69 #include <sys/file_internal.h>
  70 #include <sys/errno.h>
  71 #include <sys/select.h>
  72 #include <sys/kernel.h>
  73 #include <kern/thread.h>
  74 #include <sys/lock.h>
  75
  76 #define LOG_RDPRI       (PZERO + 1)
  77
  78 #define LOG_NBIO        0x02
  79 #define LOG_ASYNC       0x04
  80 #define LOG_RDWAIT      0x08
  81
  82 struct logsoftc {
  83         int     sc_state;               /* see above for possibilities */
  84         struct  selinfo sc_selp;        /* thread waiting for select */
  85         int     sc_pgid;                /* process/group for async I/O */
  86 } logsoftc;
  87
  88 int     log_open;                       /* also used in log() */
  89 struct msgbuf temp_msgbuf;
  90 struct msgbuf *msgbufp;
  91 static int _logentrypend = 0;
  92 static int log_inited = 0;
  93 void bsd_log_lock(void);
  94 /* the following two are implemented in osfmk/kern/printf.c  */
  95 extern void bsd_log_unlock(void);
  96 extern void bsd_log_init(void);
  97
  98 /*
  99  * Serialize log access.  Note that the log can be written at interrupt level,
 100  * so any log manipulations that can be done from, or affect, another processor
 101  * at interrupt level must be guarded with a spin lock.
 102  */
 103
 104 #define LOG_LOCK() bsd_log_lock()
 105 #define LOG_UNLOCK() bsd_log_unlock()
 106
 107
 108 /*ARGSUSED*/
 109 logopen(dev, flags, mode, p)
 110         dev_t dev;
 111         int flags, mode;
 112         struct proc *p;
 113 {
 114         LOG_LOCK();
 115         if (log_open) {
 116                 LOG_UNLOCK();
 117                 return (EBUSY);
 118         }
 119         log_open = 1;
 120         logsoftc.sc_pgid = p->p_pid;            /* signal process only */
 121         /*
 122          * Potential race here with putchar() but since putchar should be
 123          * called by autoconf, msg_magic should be initialized by the time
 124          * we get here.
 125          */
 126         if (msgbufp->msg_magic != MSG_MAGIC) {
 127                 register int i;
 128
 129                 msgbufp->msg_magic = MSG_MAGIC;
 130                 msgbufp->msg_bufx = msgbufp->msg_bufr = 0;
 131                 for (i=0; i < MSG_BSIZE; i++)
 132                         msgbufp->msg_bufc[i] = 0;
 133         }
 134         LOG_UNLOCK();
 135
 136         return (0);
 137 }
 138
 139 /*ARGSUSED*/
 140 int
 141 logclose(dev, flag)
 142         dev_t dev;
 143 {
 144         int oldpri;
 145         LOG_LOCK();
 146         log_open = 0;
 147         selwakeup(&logsoftc.sc_selp);
 148         selthreadclear(&logsoftc.sc_selp);
 149         LOG_UNLOCK();
 150         return (0);
 151 }
 152
 153 /*ARGSUSED*/
 154 int
 155 logread(dev, uio, flag)
 156         dev_t dev;
 157         struct uio *uio;
 158         int flag;
 159 {
 160         register long l;
 161         register int s;
 162         int error = 0;
 163         char localbuff[MSG_BSIZE];
 164         int copybytes;
 165
 166         LOG_LOCK();
 167         while (msgbufp->msg_bufr == msgbufp->msg_bufx) {
 168                 if (flag & IO_NDELAY) {
 169                         error = EWOULDBLOCK;
 170                         goto out;
 171                 }
 172                 if (logsoftc.sc_state & LOG_NBIO) {
 173                         error = EWOULDBLOCK;
 174                         goto out;
 175                 }
 176                 logsoftc.sc_state |= LOG_RDWAIT;
 177                 LOG_UNLOCK();
 178                 /*
 179                  * If the wakeup is missed the ligtening bolt will wake this up
 180                  * if there are any new characters. If that doesn't do it
 181                  * then wait for 5 sec and reevaluate
 182                  */
 183                 if (error = tsleep((caddr_t)msgbufp, LOG_RDPRI | PCATCH,
 184                                 "klog", 5 * hz)) {
 185                         /* if it times out; ignore */
 186                         if (error != EWOULDBLOCK)
 187                                 return (error);
 188                 }
 189                 LOG_LOCK();
 190         }
 191         logsoftc.sc_state &= ~LOG_RDWAIT;
 192
 193
 194         while (uio_resid(uio) > 0) {
 195                 l = msgbufp->msg_bufx - msgbufp->msg_bufr;
 196                 if (l < 0)
 197                         l = MSG_BSIZE - msgbufp->msg_bufr;
 198                 l = min(l, uio_resid(uio));
 199                 if (l == 0)
 200                         break;
 201                 bcopy(&msgbufp->msg_bufc[msgbufp->msg_bufr], &localbuff[0], l);
 202                 LOG_UNLOCK();
 203                 error = uiomove((caddr_t)&localbuff[0],
 204                         (int)l, uio);
 205                 LOG_LOCK();
 206                 if (error)
 207                         break;
 208                 msgbufp->msg_bufr += l;
 209                 if (msgbufp->msg_bufr < 0 || msgbufp->msg_bufr >= MSG_BSIZE)
 210                         msgbufp->msg_bufr = 0;
 211         }
 212 out:
 213         LOG_UNLOCK();
 214         return (error);
 215 }
 216
 217 /*ARGSUSED*/
 218 int
 219 logselect(dev, rw, wql, p)
 220         dev_t dev;
 221         int rw;
 222         void * wql;
 223         struct proc *p;
 224 {
 225
 226         switch (rw) {
 227
 228         case FREAD:
 229                 LOG_LOCK();
 230                 if (msgbufp->msg_bufr != msgbufp->msg_bufx) {
 231                         LOG_UNLOCK();
 232                         return (1);
 233                 }
 234                 selrecord(p, &logsoftc.sc_selp, wql);
 235                 LOG_UNLOCK();
 236                 break;
 237         }
 238         return (0);
 239 }
 240
 241 void
 242 logwakeup()
 243 {
 244         struct proc *p;
 245         int pgid;
 246         boolean_t funnel_state;
 247
 248         LOG_LOCK();
 249         if (!log_open) {
 250                 LOG_UNLOCK();
 251                 return;
 252         }
 253         selwakeup(&logsoftc.sc_selp);
 254         if (logsoftc.sc_state & LOG_ASYNC) {
 255                 pgid = logsoftc.sc_pgid;
 256                 LOG_UNLOCK();
 257                 if (pgid < 0)
 258                         gsignal(-pgid, SIGIO);
 259                 else if (p = pfind(pgid))
 260                         psignal(p, SIGIO);
 261                 LOG_LOCK();
 262         }
 263         if (logsoftc.sc_state & LOG_RDWAIT) {
 264                 wakeup((caddr_t)msgbufp);
 265                 logsoftc.sc_state &= ~LOG_RDWAIT;
 266         }
 267         LOG_UNLOCK();
 268 }
 269
 270 void
 271 klogwakeup()
 272 {
 273
 274         if (_logentrypend) {
 275                 _logentrypend = 0;
 276                 logwakeup();
 277         }
 278 }
 279
 280 /*ARGSUSED*/
 281 int
 282 logioctl(dev, com, data, flag)
 283         caddr_t data;
 284 {
 285         long l;
 286         int s;
 287
 288         LOG_LOCK();
 289         switch (com) {
 290
 291         /* return number of characters immediately available */
 292         case FIONREAD:
 293                 l = msgbufp->msg_bufx - msgbufp->msg_bufr;
 294                 if (l < 0)
 295                         l += MSG_BSIZE;
 296                 *(off_t *)data = l;
 297                 break;
 298
 299         case FIONBIO:
 300                 if (*(int *)data)
 301                         logsoftc.sc_state |= LOG_NBIO;
 302                 else
 303                         logsoftc.sc_state &= ~LOG_NBIO;
 304                 break;
 305
 306         case FIOASYNC:
 307                 if (*(int *)data)
 308                         logsoftc.sc_state |= LOG_ASYNC;
 309                 else
 310                         logsoftc.sc_state &= ~LOG_ASYNC;
 311                 break;
 312
 313         case TIOCSPGRP:
 314                 logsoftc.sc_pgid = *(int *)data;
 315                 break;
 316
 317         case TIOCGPGRP:
 318                 *(int *)data = logsoftc.sc_pgid;
 319                 break;
 320
 321         default:
 322                 LOG_UNLOCK();
 323                 return (-1);
 324         }
 325         LOG_UNLOCK();
 326         return (0);
 327 }
 328
 329 void
 330 bsd_log_init()
 331 {
 332         if (!log_inited) {
 333                 msgbufp = &temp_msgbuf;
 334                 log_inited = 1;
 335         }
 336 }
 337
 338 void
 339 log_putc(char c)
 340 {
 341         register struct msgbuf *mbp;
 342
 343         if (!log_inited) {
 344                 panic("bsd log is not inited");
 345         }
 346         LOG_LOCK();
 347
 348         mbp = msgbufp;
 349         if (mbp-> msg_magic != MSG_MAGIC) {
 350                 register int i;
 351
 352                 mbp->msg_magic = MSG_MAGIC;
 353                 mbp->msg_bufx = mbp->msg_bufr = 0;
 354                 for (i=0; i < MSG_BSIZE; i++)
 355                         mbp->msg_bufc[i] = 0;
 356         }
 357         mbp->msg_bufc[mbp->msg_bufx++] = c;
 358         _logentrypend = 1;
 359         if (mbp->msg_bufx < 0 || mbp->msg_bufx >= MSG_BSIZE)
 360                 mbp->msg_bufx = 0;
 361         LOG_UNLOCK();
 362 }
 363