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

Cache object: 80be6e0aac69482ad6f14c125154a9d2

[ 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