sys/kern/subr_log.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1982, 1986, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      @(#)subr_log.c  8.1 (Berkeley) 6/10/93
  32  */
  33
  34 /*
  35  * Error log buffer for kernel printf's.
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/conf.h>
  44 #include <sys/proc.h>
  45 #include <sys/vnode.h>
  46 #include <sys/filio.h>
  47 #include <sys/ttycom.h>
  48 #include <sys/msgbuf.h>
  49 #include <sys/signalvar.h>
  50 #include <sys/kernel.h>
  51 #include <sys/poll.h>
  52 #include <sys/filedesc.h>
  53 #include <sys/sysctl.h>
  54
  55 #define LOG_RDPRI       (PZERO + 1)
  56
  57 #define LOG_ASYNC       0x04
  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 static  d_kqfilter_t    logkqfilter;
  65
  66 static  void logtimeout(void *arg);
  67
  68 static struct cdevsw log_cdevsw = {
  69         .d_version =    D_VERSION,
  70         .d_open =       logopen,
  71         .d_close =      logclose,
  72         .d_read =       logread,
  73         .d_ioctl =      logioctl,
  74         .d_poll =       logpoll,
  75         .d_kqfilter =   logkqfilter,
  76         .d_name =       "log",
  77 };
  78
  79 static int      logkqread(struct knote *note, long hint);
  80 static void     logkqdetach(struct knote *note);
  81
  82 static struct filterops log_read_filterops = {
  83         .f_isfd =       1,
  84         .f_attach =     NULL,
  85         .f_detach =     logkqdetach,
  86         .f_event =      logkqread,
  87 };
  88
  89 static struct logsoftc {
  90         int     sc_state;               /* see above for possibilities */
  91         struct  selinfo sc_selp;        /* process waiting on select call */
  92         struct  sigio *sc_sigio;        /* information for async I/O */
  93         struct  callout sc_callout;     /* callout to wakeup syslog  */
  94 } logsoftc;
  95
  96 int                     log_open;       /* also used in log() */
  97 static struct cv        log_wakeup;
  98 struct mtx              msgbuf_lock;
  99 MTX_SYSINIT(msgbuf_lock, &msgbuf_lock, "msgbuf lock", MTX_DEF);
 100
 101 /* Times per second to check for a pending syslog wakeup. */
 102 static int      log_wakeups_per_second = 5;
 103 SYSCTL_INT(_kern, OID_AUTO, log_wakeups_per_second, CTLFLAG_RW,
 104     &log_wakeups_per_second, 0, "");
 105
 106 /*ARGSUSED*/
 107 static  int
 108 logopen(struct cdev *dev, int flags, int mode, struct thread *td)
 109 {
 110
 111         if (log_wakeups_per_second < 1) {
 112                 printf("syslog wakeup is less than one.  Adjusting to 1.\n");
 113                 log_wakeups_per_second = 1;
 114         }
 115
 116         mtx_lock(&msgbuf_lock);
 117         if (log_open) {
 118                 mtx_unlock(&msgbuf_lock);
 119                 return (EBUSY);
 120         }
 121         log_open = 1;
 122         callout_reset_sbt(&logsoftc.sc_callout,
 123             SBT_1S / log_wakeups_per_second, 0, logtimeout, NULL, C_PREL(1));
 124         mtx_unlock(&msgbuf_lock);
 125
 126         fsetown(td->td_proc->p_pid, &logsoftc.sc_sigio);        /* signal process only */
 127         return (0);
 128 }
 129
 130 /*ARGSUSED*/
 131 static  int
 132 logclose(struct cdev *dev, int flag, int mode, struct thread *td)
 133 {
 134
 135         funsetown(&logsoftc.sc_sigio);
 136
 137         mtx_lock(&msgbuf_lock);
 138         callout_stop(&logsoftc.sc_callout);
 139         logsoftc.sc_state = 0;
 140         log_open = 0;
 141         mtx_unlock(&msgbuf_lock);
 142
 143         return (0);
 144 }
 145
 146 /*ARGSUSED*/
 147 static  int
 148 logread(struct cdev *dev, struct uio *uio, int flag)
 149 {
 150         char buf[128];
 151         struct msgbuf *mbp = msgbufp;
 152         int error = 0, l;
 153
 154         mtx_lock(&msgbuf_lock);
 155         while (msgbuf_getcount(mbp) == 0) {
 156                 if (flag & IO_NDELAY) {
 157                         mtx_unlock(&msgbuf_lock);
 158                         return (EWOULDBLOCK);
 159                 }
 160                 if ((error = cv_wait_sig(&log_wakeup, &msgbuf_lock)) != 0) {
 161                         mtx_unlock(&msgbuf_lock);
 162                         return (error);
 163                 }
 164         }
 165
 166         while (uio->uio_resid > 0) {
 167                 l = imin(sizeof(buf), uio->uio_resid);
 168                 l = msgbuf_getbytes(mbp, buf, l);
 169                 if (l == 0)
 170                         break;
 171                 mtx_unlock(&msgbuf_lock);
 172                 error = uiomove(buf, l, uio);
 173                 if (error || uio->uio_resid == 0)
 174                         return (error);
 175                 mtx_lock(&msgbuf_lock);
 176         }
 177         mtx_unlock(&msgbuf_lock);
 178         return (error);
 179 }
 180
 181 /*ARGSUSED*/
 182 static  int
 183 logpoll(struct cdev *dev, int events, struct thread *td)
 184 {
 185         int revents = 0;
 186
 187         if (events & (POLLIN | POLLRDNORM)) {
 188                 mtx_lock(&msgbuf_lock);
 189                 if (msgbuf_getcount(msgbufp) > 0)
 190                         revents |= events & (POLLIN | POLLRDNORM);
 191                 else
 192                         selrecord(td, &logsoftc.sc_selp);
 193                 mtx_unlock(&msgbuf_lock);
 194         }
 195         return (revents);
 196 }
 197
 198 static int
 199 logkqfilter(struct cdev *dev, struct knote *kn)
 200 {
 201
 202         if (kn->kn_filter != EVFILT_READ)
 203                 return (EINVAL);
 204
 205         kn->kn_fop = &log_read_filterops;
 206         kn->kn_hook = NULL;
 207
 208         mtx_lock(&msgbuf_lock);
 209         knlist_add(&logsoftc.sc_selp.si_note, kn, 1);
 210         mtx_unlock(&msgbuf_lock);
 211         return (0);
 212 }
 213
 214 static int
 215 logkqread(struct knote *kn, long hint)
 216 {
 217
 218         mtx_assert(&msgbuf_lock, MA_OWNED);
 219         kn->kn_data = msgbuf_getcount(msgbufp);
 220         return (kn->kn_data != 0);
 221 }
 222
 223 static void
 224 logkqdetach(struct knote *kn)
 225 {
 226
 227         mtx_lock(&msgbuf_lock);
 228         knlist_remove(&logsoftc.sc_selp.si_note, kn, 1);
 229         mtx_unlock(&msgbuf_lock);
 230 }
 231
 232 static void
 233 logtimeout(void *arg)
 234 {
 235
 236         if (!log_open)
 237                 return;
 238         if (msgbuftrigger == 0)
 239                 goto done;
 240         msgbuftrigger = 0;
 241         selwakeuppri(&logsoftc.sc_selp, LOG_RDPRI);
 242         KNOTE_LOCKED(&logsoftc.sc_selp.si_note, 0);
 243         if ((logsoftc.sc_state & LOG_ASYNC) && logsoftc.sc_sigio != NULL)
 244                 pgsigio(&logsoftc.sc_sigio, SIGIO, 0);
 245         cv_broadcastpri(&log_wakeup, LOG_RDPRI);
 246 done:
 247         if (log_wakeups_per_second < 1) {
 248                 printf("syslog wakeup is less than one.  Adjusting to 1.\n");
 249                 log_wakeups_per_second = 1;
 250         }
 251         callout_reset_sbt(&logsoftc.sc_callout,
 252             SBT_1S / log_wakeups_per_second, 0, logtimeout, NULL, C_PREL(1));
 253 }
 254
 255 /*ARGSUSED*/
 256 static  int
 257 logioctl(struct cdev *dev, u_long com, caddr_t data, int flag, struct thread *td)
 258 {
 259
 260         switch (com) {
 261         /* return number of characters immediately available */
 262         case FIONREAD:
 263                 *(int *)data = msgbuf_getcount(msgbufp);
 264                 break;
 265
 266         case FIONBIO:
 267                 break;
 268
 269         case FIOASYNC:
 270                 mtx_lock(&msgbuf_lock);
 271                 if (*(int *)data)
 272                         logsoftc.sc_state |= LOG_ASYNC;
 273                 else
 274                         logsoftc.sc_state &= ~LOG_ASYNC;
 275                 mtx_unlock(&msgbuf_lock);
 276                 break;
 277
 278         case FIOSETOWN:
 279                 return (fsetown(*(int *)data, &logsoftc.sc_sigio));
 280
 281         case FIOGETOWN:
 282                 *(int *)data = fgetown(&logsoftc.sc_sigio);
 283                 break;
 284
 285         /* This is deprecated, FIOSETOWN should be used instead. */
 286         case TIOCSPGRP:
 287                 return (fsetown(-(*(int *)data), &logsoftc.sc_sigio));
 288
 289         /* This is deprecated, FIOGETOWN should be used instead */
 290         case TIOCGPGRP:
 291                 *(int *)data = -fgetown(&logsoftc.sc_sigio);
 292                 break;
 293
 294         default:
 295                 return (ENOTTY);
 296         }
 297         return (0);
 298 }
 299
 300 static void
 301 log_drvinit(void *unused)
 302 {
 303
 304         cv_init(&log_wakeup, "klog");
 305         callout_init_mtx(&logsoftc.sc_callout, &msgbuf_lock, 0);
 306         knlist_init_mtx(&logsoftc.sc_selp.si_note, &msgbuf_lock);
 307         make_dev_credf(MAKEDEV_ETERNAL, &log_cdevsw, 0, NULL, UID_ROOT,
 308             GID_WHEEL, 0600, "klog");
 309 }
 310
 311 SYSINIT(logdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE,log_drvinit,NULL);