subr_log.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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);
Cache object: 9976294f1d320e411baaccac79692f48
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/kern/subr_log.c

FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_log.c
