bsd/kern/subr_log.c

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