sys/kern/subr_log.c

   1 /*
   2  * Copyright (c) 1982, 1986, 1993
   3  *      The Regents of the University of California.  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  *
  33  *      @(#)subr_log.c  8.1 (Berkeley) 6/10/93
  34  * $FreeBSD: src/sys/kern/subr_log.c,v 1.39.2.2 2001/06/02 08:11:25 phk Exp $
  35  * $DragonFly: src/sys/kern/subr_log.c,v 1.7 2004/05/19 22:52:58 dillon Exp $
  36  */
  37
  38 /*
  39  * Error log buffer for kernel printf's.
  40  */
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/conf.h>
  45 #include <sys/proc.h>
  46 #include <sys/vnode.h>
  47 #include <sys/filio.h>
  48 #include <sys/ttycom.h>
  49 #include <sys/msgbuf.h>
  50 #include <sys/signalvar.h>
  51 #include <sys/kernel.h>
  52 #include <sys/poll.h>
  53 #include <sys/filedesc.h>
  54 #include <sys/sysctl.h>
  55
  56 #define LOG_ASYNC       0x04
  57 #define LOG_RDWAIT      0x08
  58
  59 static  d_open_t        logopen;
  60 static  d_close_t       logclose;
  61 static  d_read_t        logread;
  62 static  d_ioctl_t       logioctl;
  63 static  d_poll_t        logpoll;
  64
  65 static  void logtimeout(void *arg);
  66
  67 #define CDEV_MAJOR 7
  68 static struct cdevsw log_cdevsw = {
  69         /* name */      "log",
  70         /* maj */       CDEV_MAJOR,
  71         /* flags */     0,
  72         /* port */      NULL,
  73         /* clone */     NULL,
  74
  75         /* open */      logopen,
  76         /* close */     logclose,
  77         /* read */      logread,
  78         /* write */     nowrite,
  79         /* ioctl */     logioctl,
  80         /* poll */      logpoll,
  81         /* mmap */      nommap,
  82         /* strategy */  nostrategy,
  83         /* dump */      nodump,
  84         /* psize */     nopsize
  85 };
  86
  87 static struct logsoftc {
  88         int     sc_state;               /* see above for possibilities */
  89         struct  selinfo sc_selp;        /* process waiting on select call */
  90         struct  sigio *sc_sigio;        /* information for async I/O */
  91         struct  callout sc_callout;     /* callout to wakeup syslog  */
  92 } logsoftc;
  93
  94 int     log_open;                       /* also used in log() */
  95
  96 /* Times per second to check for a pending syslog wakeup. */
  97 static int      log_wakeups_per_second = 5;
  98 SYSCTL_INT(_kern, OID_AUTO, log_wakeups_per_second, CTLFLAG_RW,
  99     &log_wakeups_per_second, 0, "");
 100
 101 /*ARGSUSED*/
 102 static  int
 103 logopen(dev_t dev, int flags, int mode, struct thread *td)
 104 {
 105         struct proc *p = td->td_proc;
 106
 107         KKASSERT(p != NULL);
 108         if (log_open)
 109                 return (EBUSY);
 110         log_open = 1;
 111         callout_init(&logsoftc.sc_callout);
 112         fsetown(p->p_pid, &logsoftc.sc_sigio);  /* signal process only */
 113         callout_reset(&logsoftc.sc_callout, hz / log_wakeups_per_second,
 114             logtimeout, NULL);
 115         return (0);
 116 }
 117
 118 /*ARGSUSED*/
 119 static  int
 120 logclose(dev_t dev, int flag, int mode, struct thread *td)
 121 {
 122
 123         log_open = 0;
 124         callout_stop(&logsoftc.sc_callout);
 125         logsoftc.sc_state = 0;
 126         funsetown(logsoftc.sc_sigio);
 127         return (0);
 128 }
 129
 130 /*ARGSUSED*/
 131 static  int
 132 logread(dev_t dev, struct uio *uio, int flag)
 133 {
 134         struct msgbuf *mbp = msgbufp;
 135         long l;
 136         int s;
 137         int error = 0;
 138
 139         s = splhigh();
 140         while (mbp->msg_bufr == mbp->msg_bufx) {
 141                 if (flag & IO_NDELAY) {
 142                         splx(s);
 143                         return (EWOULDBLOCK);
 144                 }
 145                 logsoftc.sc_state |= LOG_RDWAIT;
 146                 if ((error = tsleep((caddr_t)mbp, PCATCH, "klog", 0))) {
 147                         splx(s);
 148                         return (error);
 149                 }
 150         }
 151         splx(s);
 152         logsoftc.sc_state &= ~LOG_RDWAIT;
 153
 154         while (uio->uio_resid > 0) {
 155                 l = mbp->msg_bufx - mbp->msg_bufr;
 156                 if (l < 0)
 157                         l = mbp->msg_size - mbp->msg_bufr;
 158                 l = min(l, uio->uio_resid);
 159                 if (l == 0)
 160                         break;
 161                 error = uiomove((caddr_t)msgbufp->msg_ptr + mbp->msg_bufr,
 162                     (int)l, uio);
 163                 if (error)
 164                         break;
 165                 mbp->msg_bufr += l;
 166                 if (mbp->msg_bufr >= mbp->msg_size)
 167                         mbp->msg_bufr = 0;
 168         }
 169         return (error);
 170 }
 171
 172 /*ARGSUSED*/
 173 static  int
 174 logpoll(dev_t dev, int events, struct thread *td)
 175 {
 176         int s;
 177         int revents = 0;
 178
 179         s = splhigh();
 180
 181         if (events & (POLLIN | POLLRDNORM)) {
 182                 if (msgbufp->msg_bufr != msgbufp->msg_bufx)
 183                         revents |= events & (POLLIN | POLLRDNORM);
 184                 else
 185                         selrecord(td, &logsoftc.sc_selp);
 186         }
 187         splx(s);
 188         return (revents);
 189 }
 190
 191 static void
 192 logtimeout(void *arg)
 193 {
 194
 195         if (!log_open)
 196                 return;
 197         if (msgbuftrigger == 0) {
 198                 callout_reset(&logsoftc.sc_callout,
 199                     hz / log_wakeups_per_second, logtimeout, NULL);
 200                 return;
 201         }
 202         msgbuftrigger = 0;
 203         selwakeup(&logsoftc.sc_selp);
 204         if ((logsoftc.sc_state & LOG_ASYNC) && logsoftc.sc_sigio != NULL)
 205                 pgsigio(logsoftc.sc_sigio, SIGIO, 0);
 206         if (logsoftc.sc_state & LOG_RDWAIT) {
 207                 wakeup((caddr_t)msgbufp);
 208                 logsoftc.sc_state &= ~LOG_RDWAIT;
 209         }
 210         callout_reset(&logsoftc.sc_callout, hz / log_wakeups_per_second,
 211             logtimeout, NULL);
 212 }
 213
 214 /*ARGSUSED*/
 215 static  int
 216 logioctl(dev_t dev, u_long com, caddr_t data, int flag, struct thread *td)
 217 {
 218         long l;
 219         int s;
 220
 221         switch (com) {
 222
 223         /* return number of characters immediately available */
 224         case FIONREAD:
 225                 s = splhigh();
 226                 l = msgbufp->msg_bufx - msgbufp->msg_bufr;
 227                 splx(s);
 228                 if (l < 0)
 229                         l += msgbufp->msg_size;
 230                 *(int *)data = l;
 231                 break;
 232
 233         case FIONBIO:
 234                 break;
 235
 236         case FIOASYNC:
 237                 if (*(int *)data)
 238                         logsoftc.sc_state |= LOG_ASYNC;
 239                 else
 240                         logsoftc.sc_state &= ~LOG_ASYNC;
 241                 break;
 242
 243         case FIOSETOWN:
 244                 return (fsetown(*(int *)data, &logsoftc.sc_sigio));
 245
 246         case FIOGETOWN:
 247                 *(int *)data = fgetown(logsoftc.sc_sigio);
 248                 break;
 249
 250         /* This is deprecated, FIOSETOWN should be used instead. */
 251         case TIOCSPGRP:
 252                 return (fsetown(-(*(int *)data), &logsoftc.sc_sigio));
 253
 254         /* This is deprecated, FIOGETOWN should be used instead */
 255         case TIOCGPGRP:
 256                 *(int *)data = -fgetown(logsoftc.sc_sigio);
 257                 break;
 258
 259         default:
 260                 return (ENOTTY);
 261         }
 262         return (0);
 263 }
 264
 265 static void
 266 log_drvinit(void *unused)
 267 {
 268         cdevsw_add(&log_cdevsw, 0, 0);
 269         make_dev(&log_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600, "klog");
 270 }
 271
 272 SYSINIT(logdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,log_drvinit,NULL)