subr_log.c revision 1.53
1 /* $NetBSD: subr_log.c,v 1.53 2014/07/25 08:10:40 dholland Exp $ */ 2 3 /*- 4 * Copyright (c) 2007, 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Doran. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Copyright (c) 1982, 1986, 1993 34 * The Regents of the University of California. All rights reserved. 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that the following conditions 38 * are met: 39 * 1. Redistributions of source code must retain the above copyright 40 * notice, this list of conditions and the following disclaimer. 41 * 2. Redistributions in binary form must reproduce the above copyright 42 * notice, this list of conditions and the following disclaimer in the 43 * documentation and/or other materials provided with the distribution. 44 * 3. Neither the name of the University nor the names of its contributors 45 * may be used to endorse or promote products derived from this software 46 * without specific prior written permission. 47 * 48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 58 * SUCH DAMAGE. 59 * 60 * @(#)subr_log.c 8.3 (Berkeley) 2/14/95 61 */ 62 63 /* 64 * Error log buffer for kernel printf's. 65 */ 66 67 #include <sys/cdefs.h> 68 __KERNEL_RCSID(0, "$NetBSD: subr_log.c,v 1.53 2014/07/25 08:10:40 dholland Exp $"); 69 70 #include <sys/param.h> 71 #include <sys/systm.h> 72 #include <sys/kernel.h> 73 #include <sys/proc.h> 74 #include <sys/vnode.h> 75 #include <sys/ioctl.h> 76 #include <sys/msgbuf.h> 77 #include <sys/file.h> 78 #include <sys/syslog.h> 79 #include <sys/conf.h> 80 #include <sys/select.h> 81 #include <sys/poll.h> 82 #include <sys/intr.h> 83 84 static void logsoftintr(void *); 85 86 static bool log_async; 87 static struct selinfo log_selp; /* process waiting on select call */ 88 static pid_t log_pgid; /* process/group for async I/O */ 89 static kcondvar_t log_cv; 90 static void *log_sih; 91 92 kmutex_t log_lock; 93 int log_open; /* also used in log() */ 94 int msgbufmapped; /* is the message buffer mapped */ 95 int msgbufenabled; /* is logging to the buffer enabled */ 96 struct kern_msgbuf *msgbufp; /* the mapped buffer, itself. */ 97 98 void 99 initmsgbuf(void *bf, size_t bufsize) 100 { 101 struct kern_msgbuf *mbp; 102 long new_bufs; 103 104 /* Sanity-check the given size. */ 105 if (bufsize < sizeof(struct kern_msgbuf)) 106 return; 107 108 mbp = msgbufp = (struct kern_msgbuf *)bf; 109 110 new_bufs = bufsize - offsetof(struct kern_msgbuf, msg_bufc); 111 if ((mbp->msg_magic != MSG_MAGIC) || (mbp->msg_bufs != new_bufs) || 112 (mbp->msg_bufr < 0) || (mbp->msg_bufr >= mbp->msg_bufs) || 113 (mbp->msg_bufx < 0) || (mbp->msg_bufx >= mbp->msg_bufs)) { 114 /* 115 * If the buffer magic number is wrong, has changed 116 * size (which shouldn't happen often), or is 117 * internally inconsistent, initialize it. 118 */ 119 120 memset(bf, 0, bufsize); 121 mbp->msg_magic = MSG_MAGIC; 122 mbp->msg_bufs = new_bufs; 123 } 124 125 /* mark it as ready for use. */ 126 msgbufmapped = msgbufenabled = 1; 127 } 128 129 void 130 loginit(void) 131 { 132 133 mutex_init(&log_lock, MUTEX_DEFAULT, IPL_VM); 134 selinit(&log_selp); 135 cv_init(&log_cv, "klog"); 136 log_sih = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE, 137 logsoftintr, NULL); 138 } 139 140 /*ARGSUSED*/ 141 static int 142 logopen(dev_t dev, int flags, int mode, struct lwp *l) 143 { 144 struct kern_msgbuf *mbp = msgbufp; 145 int error = 0; 146 147 mutex_spin_enter(&log_lock); 148 if (log_open) { 149 error = EBUSY; 150 } else { 151 log_open = 1; 152 log_pgid = l->l_proc->p_pid; /* signal process only */ 153 /* 154 * The message buffer is initialized during system 155 * configuration. If it's been clobbered, note that 156 * and return an error. (This allows a user to read 157 * the buffer via /dev/kmem, and try to figure out 158 * what clobbered it. 159 */ 160 if (mbp->msg_magic != MSG_MAGIC) { 161 msgbufenabled = 0; 162 error = ENXIO; 163 } 164 } 165 mutex_spin_exit(&log_lock); 166 167 return error; 168 } 169 170 /*ARGSUSED*/ 171 static int 172 logclose(dev_t dev, int flag, int mode, struct lwp *l) 173 { 174 175 mutex_spin_enter(&log_lock); 176 log_pgid = 0; 177 log_open = 0; 178 log_async = 0; 179 mutex_spin_exit(&log_lock); 180 181 return 0; 182 } 183 184 /*ARGSUSED*/ 185 static int 186 logread(dev_t dev, struct uio *uio, int flag) 187 { 188 struct kern_msgbuf *mbp = msgbufp; 189 long l; 190 int error = 0; 191 192 mutex_spin_enter(&log_lock); 193 while (mbp->msg_bufr == mbp->msg_bufx) { 194 if (flag & IO_NDELAY) { 195 mutex_spin_exit(&log_lock); 196 return EWOULDBLOCK; 197 } 198 error = cv_wait_sig(&log_cv, &log_lock); 199 if (error) { 200 mutex_spin_exit(&log_lock); 201 return error; 202 } 203 } 204 while (uio->uio_resid > 0) { 205 l = mbp->msg_bufx - mbp->msg_bufr; 206 if (l < 0) 207 l = mbp->msg_bufs - mbp->msg_bufr; 208 l = min(l, uio->uio_resid); 209 if (l == 0) 210 break; 211 mutex_spin_exit(&log_lock); 212 error = uiomove(&mbp->msg_bufc[mbp->msg_bufr], (int)l, uio); 213 mutex_spin_enter(&log_lock); 214 if (error) 215 break; 216 mbp->msg_bufr += l; 217 if (mbp->msg_bufr < 0 || mbp->msg_bufr >= mbp->msg_bufs) 218 mbp->msg_bufr = 0; 219 } 220 mutex_spin_exit(&log_lock); 221 222 return error; 223 } 224 225 /*ARGSUSED*/ 226 static int 227 logpoll(dev_t dev, int events, struct lwp *l) 228 { 229 int revents = 0; 230 231 if (events & (POLLIN | POLLRDNORM)) { 232 mutex_spin_enter(&log_lock); 233 if (msgbufp->msg_bufr != msgbufp->msg_bufx) 234 revents |= events & (POLLIN | POLLRDNORM); 235 else 236 selrecord(l, &log_selp); 237 mutex_spin_exit(&log_lock); 238 } 239 240 return revents; 241 } 242 243 static void 244 filt_logrdetach(struct knote *kn) 245 { 246 247 mutex_spin_enter(&log_lock); 248 SLIST_REMOVE(&log_selp.sel_klist, kn, knote, kn_selnext); 249 mutex_spin_exit(&log_lock); 250 } 251 252 static int 253 filt_logread(struct knote *kn, long hint) 254 { 255 int rv; 256 257 if ((hint & NOTE_SUBMIT) == 0) 258 mutex_spin_enter(&log_lock); 259 if (msgbufp->msg_bufr == msgbufp->msg_bufx) { 260 rv = 0; 261 } else if (msgbufp->msg_bufr < msgbufp->msg_bufx) { 262 kn->kn_data = msgbufp->msg_bufx - msgbufp->msg_bufr; 263 rv = 1; 264 } else { 265 kn->kn_data = (msgbufp->msg_bufs - msgbufp->msg_bufr) + 266 msgbufp->msg_bufx; 267 rv = 1; 268 } 269 if ((hint & NOTE_SUBMIT) == 0) 270 mutex_spin_exit(&log_lock); 271 272 return rv; 273 } 274 275 static const struct filterops logread_filtops = 276 { 1, NULL, filt_logrdetach, filt_logread }; 277 278 static int 279 logkqfilter(dev_t dev, struct knote *kn) 280 { 281 struct klist *klist; 282 283 switch (kn->kn_filter) { 284 case EVFILT_READ: 285 klist = &log_selp.sel_klist; 286 kn->kn_fop = &logread_filtops; 287 break; 288 289 default: 290 return (EINVAL); 291 } 292 293 mutex_spin_enter(&log_lock); 294 kn->kn_hook = NULL; 295 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 296 mutex_spin_exit(&log_lock); 297 298 return (0); 299 } 300 301 void 302 logwakeup(void) 303 { 304 305 if (!cold && log_open) { 306 mutex_spin_enter(&log_lock); 307 selnotify(&log_selp, 0, NOTE_SUBMIT); 308 if (log_async) 309 softint_schedule(log_sih); 310 cv_broadcast(&log_cv); 311 mutex_spin_exit(&log_lock); 312 } 313 } 314 315 static void 316 logsoftintr(void *cookie) 317 { 318 pid_t pid; 319 320 if ((pid = log_pgid) != 0) 321 fownsignal(pid, SIGIO, 0, 0, NULL); 322 } 323 324 /*ARGSUSED*/ 325 static int 326 logioctl(dev_t dev, u_long com, void *data, int flag, struct lwp *lwp) 327 { 328 long l; 329 330 switch (com) { 331 332 /* return number of characters immediately available */ 333 case FIONREAD: 334 mutex_spin_enter(&log_lock); 335 l = msgbufp->msg_bufx - msgbufp->msg_bufr; 336 if (l < 0) 337 l += msgbufp->msg_bufs; 338 mutex_spin_exit(&log_lock); 339 *(int *)data = l; 340 break; 341 342 case FIONBIO: 343 break; 344 345 case FIOASYNC: 346 /* No locking needed, 'thread private'. */ 347 log_async = (*((int *)data) != 0); 348 break; 349 350 case TIOCSPGRP: 351 case FIOSETOWN: 352 return fsetown(&log_pgid, com, data); 353 354 case TIOCGPGRP: 355 case FIOGETOWN: 356 return fgetown(log_pgid, com, data); 357 358 default: 359 return (EPASSTHROUGH); 360 } 361 return (0); 362 } 363 364 void 365 logputchar(int c) 366 { 367 struct kern_msgbuf *mbp; 368 369 if (!cold) 370 mutex_spin_enter(&log_lock); 371 if (msgbufenabled) { 372 mbp = msgbufp; 373 if (mbp->msg_magic != MSG_MAGIC) { 374 /* 375 * Arguably should panic or somehow notify the 376 * user... but how? Panic may be too drastic, 377 * and would obliterate the message being kicked 378 * out (maybe a panic itself), and printf 379 * would invoke us recursively. Silently punt 380 * for now. If syslog is running, it should 381 * notice. 382 */ 383 msgbufenabled = 0; 384 } else { 385 mbp->msg_bufc[mbp->msg_bufx++] = c; 386 if (mbp->msg_bufx < 0 || mbp->msg_bufx >= mbp->msg_bufs) 387 mbp->msg_bufx = 0; 388 /* If the buffer is full, keep the most recent data. */ 389 if (mbp->msg_bufr == mbp->msg_bufx) { 390 char c0; 391 int i; 392 393 /* 394 * Move forward read pointer to the next line 395 * in the buffer. Note that the buffer is 396 * a ring buffer so we should reset msg_bufr 397 * to 0 when msg_bufr exceeds msg_bufs. 398 * 399 * To prevent to loop forever, give up if we 400 * cannot find a newline in mbp->msg_bufs 401 * characters (the max size of the buffer). 402 */ 403 for (i = 0; i < mbp->msg_bufs; i++) { 404 c0 = mbp->msg_bufc[mbp->msg_bufr]; 405 if (++mbp->msg_bufr >= mbp->msg_bufs) 406 mbp->msg_bufr = 0; 407 if (c0 == '\n') 408 break; 409 } 410 } 411 } 412 } 413 if (!cold) 414 mutex_spin_exit(&log_lock); 415 } 416 417 const struct cdevsw log_cdevsw = { 418 .d_open = logopen, 419 .d_close = logclose, 420 .d_read = logread, 421 .d_write = nowrite, 422 .d_ioctl = logioctl, 423 .d_stop = nostop, 424 .d_tty = notty, 425 .d_poll = logpoll, 426 .d_mmap = nommap, 427 .d_kqfilter = logkqfilter, 428 .d_discard = nodiscard, 429 .d_flag = D_OTHER | D_MPSAFE 430 }; 431
Indexes created Sun Sep 21 20:09:37 GMT 2025