bsd/kern/subr_log.c

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