1 /* $NetBSD: subr_log.c,v 1.25 2002/11/26 18:44:34 christos Exp $ */ 2 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. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 * 35 * @(#)subr_log.c 8.3 (Berkeley) 2/14/95 36 */ 37 38 /* 39 * Error log buffer for kernel printf's. 40 */ 41 42 #include <sys/cdefs.h> 43 __KERNEL_RCSID(0, "$NetBSD: subr_log.c,v 1.25 2002/11/26 18:44:34 christos Exp $"); 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/proc.h> 48 #include <sys/vnode.h> 49 #include <sys/ioctl.h> 50 #include <sys/msgbuf.h> 51 #include <sys/file.h> 52 #include <sys/signalvar.h> 53 #include <sys/syslog.h> 54 #include <sys/conf.h> 55 #include <sys/select.h> 56 #include <sys/poll.h> 57 58 #define LOG_RDPRI (PZERO + 1) 59 60 #define LOG_ASYNC 0x04 61 #define LOG_RDWAIT 0x08 62 63 struct logsoftc { 64 int sc_state; /* see above for possibilities */ 65 struct selinfo sc_selp; /* process waiting on select call */ 66 int sc_pgid; /* process/group for async I/O */ 67 } logsoftc; 68 69 int log_open; /* also used in log() */ 70 int msgbufmapped; /* is the message buffer mapped */ 71 int msgbufenabled; /* is logging to the buffer enabled */ 72 struct kern_msgbuf *msgbufp; /* the mapped buffer, itself. */ 73 74 dev_type_open(logopen); 75 dev_type_close(logclose); 76 dev_type_read(logread); 77 dev_type_ioctl(logioctl); 78 dev_type_poll(logpoll); 79 dev_type_kqfilter(logkqfilter); 80 81 const struct cdevsw log_cdevsw = { 82 logopen, logclose, logread, nowrite, logioctl, 83 nostop, notty, logpoll, nommap, logkqfilter, 84 }; 85 86 void 87 initmsgbuf(buf, bufsize) 88 caddr_t buf; 89 size_t bufsize; 90 { 91 struct kern_msgbuf *mbp; 92 long new_bufs; 93 94 /* Sanity-check the given size. */ 95 if (bufsize < sizeof(struct kern_msgbuf)) 96 return; 97 98 mbp = msgbufp = (struct kern_msgbuf *)buf; 99 100 new_bufs = bufsize - offsetof(struct kern_msgbuf, msg_bufc); 101 if ((mbp->msg_magic != MSG_MAGIC) || (mbp->msg_bufs != new_bufs) || 102 (mbp->msg_bufr < 0) || (mbp->msg_bufr >= mbp->msg_bufs) || 103 (mbp->msg_bufx < 0) || (mbp->msg_bufx >= mbp->msg_bufs)) { 104 /* 105 * If the buffer magic number is wrong, has changed 106 * size (which shouldn't happen often), or is 107 * internally inconsistent, initialize it. 108 */ 109 110 memset(buf, 0, bufsize); 111 mbp->msg_magic = MSG_MAGIC; 112 mbp->msg_bufs = new_bufs; 113 } 114 115 /* mark it as ready for use. */ 116 msgbufmapped = msgbufenabled = 1; 117 } 118 119 /*ARGSUSED*/ 120 int 121 logopen(dev, flags, mode, p) 122 dev_t dev; 123 int flags, mode; 124 struct proc *p; 125 { 126 struct kern_msgbuf *mbp = msgbufp; 127 128 if (log_open) 129 return (EBUSY); 130 log_open = 1; 131 logsoftc.sc_pgid = p->p_pid; /* signal process only */ 132 /* 133 * The message buffer is initialized during system configuration. 134 * If it's been clobbered, note that and return an error. (This 135 * allows a user to potentially read the buffer via /dev/kmem, 136 * and try to figure out what clobbered it. 137 */ 138 if (mbp->msg_magic != MSG_MAGIC) { 139 msgbufenabled = 0; 140 return (ENXIO); 141 } 142 143 return (0); 144 } 145 146 /*ARGSUSED*/ 147 int 148 logclose(dev, flag, mode, p) 149 dev_t dev; 150 int flag, mode; 151 struct proc *p; 152 { 153 154 log_open = 0; 155 logsoftc.sc_state = 0; 156 return (0); 157 } 158 159 /*ARGSUSED*/ 160 int 161 logread(dev, uio, flag) 162 dev_t dev; 163 struct uio *uio; 164 int flag; 165 { 166 struct kern_msgbuf *mbp = msgbufp; 167 long l; 168 int s; 169 int error = 0; 170 171 s = splhigh(); 172 while (mbp->msg_bufr == mbp->msg_bufx) { 173 if (flag & IO_NDELAY) { 174 splx(s); 175 return (EWOULDBLOCK); 176 } 177 logsoftc.sc_state |= LOG_RDWAIT; 178 error = tsleep((caddr_t)mbp, LOG_RDPRI | PCATCH, 179 "klog", 0); 180 if (error) { 181 splx(s); 182 return (error); 183 } 184 } 185 splx(s); 186 logsoftc.sc_state &= ~LOG_RDWAIT; 187 188 while (uio->uio_resid > 0) { 189 l = mbp->msg_bufx - mbp->msg_bufr; 190 if (l < 0) 191 l = mbp->msg_bufs - mbp->msg_bufr; 192 l = min(l, uio->uio_resid); 193 if (l == 0) 194 break; 195 error = uiomove((caddr_t)&mbp->msg_bufc[mbp->msg_bufr], 196 (int)l, uio); 197 if (error) 198 break; 199 mbp->msg_bufr += l; 200 if (mbp->msg_bufr < 0 || mbp->msg_bufr >= mbp->msg_bufs) 201 mbp->msg_bufr = 0; 202 } 203 return (error); 204 } 205 206 /*ARGSUSED*/ 207 int 208 logpoll(dev, events, p) 209 dev_t dev; 210 int events; 211 struct proc *p; 212 { 213 int revents = 0; 214 int s = splhigh(); 215 216 if (events & (POLLIN | POLLRDNORM)) { 217 if (msgbufp->msg_bufr != msgbufp->msg_bufx) 218 revents |= events & (POLLIN | POLLRDNORM); 219 else 220 selrecord(p, &logsoftc.sc_selp); 221 } 222 223 splx(s); 224 return (revents); 225 } 226 227 static void 228 filt_logrdetach(struct knote *kn) 229 { 230 int s; 231 232 s = splhigh(); 233 SLIST_REMOVE(&logsoftc.sc_selp.sel_klist, kn, knote, kn_selnext); 234 splx(s); 235 } 236 237 static int 238 filt_logread(struct knote *kn, long hint) 239 { 240 241 if (msgbufp->msg_bufr == msgbufp->msg_bufx) 242 return (0); 243 244 if (msgbufp->msg_bufr < msgbufp->msg_bufx) 245 kn->kn_data = msgbufp->msg_bufx - msgbufp->msg_bufr; 246 else 247 kn->kn_data = (msgbufp->msg_bufs - msgbufp->msg_bufr) + 248 msgbufp->msg_bufx; 249 250 return (1); 251 } 252 253 static const struct filterops logread_filtops = 254 { 1, NULL, filt_logrdetach, filt_logread }; 255 256 int 257 logkqfilter(dev_t dev, struct knote *kn) 258 { 259 struct klist *klist; 260 int s; 261 262 switch (kn->kn_filter) { 263 case EVFILT_READ: 264 klist = &logsoftc.sc_selp.sel_klist; 265 kn->kn_fop = &logread_filtops; 266 break; 267 268 default: 269 return (1); 270 } 271 272 kn->kn_hook = NULL; 273 274 s = splhigh(); 275 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 276 splx(s); 277 278 return (0); 279 } 280 281 void 282 logwakeup() 283 { 284 struct proc *p; 285 286 if (!log_open) 287 return; 288 selnotify(&logsoftc.sc_selp, 0); 289 if (logsoftc.sc_state & LOG_ASYNC) { 290 if (logsoftc.sc_pgid < 0) 291 gsignal(-logsoftc.sc_pgid, SIGIO); 292 else if (logsoftc.sc_pgid > 0 && 293 (p = pfind(logsoftc.sc_pgid)) != NULL) 294 psignal(p, SIGIO); 295 } 296 if (logsoftc.sc_state & LOG_RDWAIT) { 297 wakeup((caddr_t)msgbufp); 298 logsoftc.sc_state &= ~LOG_RDWAIT; 299 } 300 } 301 302 /*ARGSUSED*/ 303 int 304 logioctl(dev, com, data, flag, p) 305 dev_t dev; 306 u_long com; 307 caddr_t data; 308 int flag; 309 struct proc *p; 310 { 311 long l; 312 int s; 313 314 switch (com) { 315 316 /* return number of characters immediately available */ 317 case FIONREAD: 318 s = splhigh(); 319 l = msgbufp->msg_bufx - msgbufp->msg_bufr; 320 splx(s); 321 if (l < 0) 322 l += msgbufp->msg_bufs; 323 *(int *)data = l; 324 break; 325 326 case FIONBIO: 327 break; 328 329 case FIOASYNC: 330 if (*(int *)data) 331 logsoftc.sc_state |= LOG_ASYNC; 332 else 333 logsoftc.sc_state &= ~LOG_ASYNC; 334 break; 335 336 case TIOCSPGRP: 337 logsoftc.sc_pgid = *(int *)data; 338 break; 339 340 case TIOCGPGRP: 341 *(int *)data = logsoftc.sc_pgid; 342 break; 343 344 default: 345 return (EPASSTHROUGH); 346 } 347 return (0); 348 } 349