1/* $NetBSD: subr_log.c,v 1.55 2015/05/20 11:18:36 pooka 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.55 2015/05/20 11:18:36 pooka 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#include <sys/sysctl.h>
84#include <sys/ktrace.h>
85
86static int sysctl_msgbuf(SYSCTLFN_PROTO);
87
88static void logsoftintr(void *);
89
90static bool log_async;
91static struct selinfo log_selp; /* process waiting on select call */
92static pid_t log_pgid; /* process/group for async I/O */
93static kcondvar_t log_cv;
94static void *log_sih;
95
96kmutex_t log_lock;
97int log_open; /* also used in log() */
98int msgbufmapped; /* is the message buffer mapped */
99int msgbufenabled; /* is logging to the buffer enabled */
100struct kern_msgbuf *msgbufp; /* the mapped buffer, itself. */
101
102void
103initmsgbuf(void *bf, size_t bufsize)
104{
105 struct kern_msgbuf *mbp;
106 long new_bufs;
107
108 /* Sanity-check the given size. */
109 if (bufsize < sizeof(struct kern_msgbuf))
110 return;
111
112 mbp = msgbufp = (struct kern_msgbuf *)bf;
113
114 new_bufs = bufsize - offsetof(struct kern_msgbuf, msg_bufc);
115 if ((mbp->msg_magic != MSG_MAGIC) || (mbp->msg_bufs != new_bufs) ||
116 (mbp->msg_bufr < 0) || (mbp->msg_bufr >= mbp->msg_bufs) ||
117 (mbp->msg_bufx < 0) || (mbp->msg_bufx >= mbp->msg_bufs)) {
118 /*
119 * If the buffer magic number is wrong, has changed
120 * size (which shouldn't happen often), or is
121 * internally inconsistent, initialize it.
122 */
123
124 memset(bf, 0, bufsize);
125 mbp->msg_magic = MSG_MAGIC;
126 mbp->msg_bufs = new_bufs;
127 }
128
129 /* mark it as ready for use. */
130 msgbufmapped = msgbufenabled = 1;
131}
132
133void
134loginit(void)
135{
136
137 mutex_init(&log_lock, MUTEX_DEFAULT, IPL_VM);
138 selinit(&log_selp);
139 cv_init(&log_cv, "klog");
140 log_sih = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE,
141 logsoftintr, NULL);
142
143 sysctl_createv(NULL, 0, NULL, NULL,
144 CTLFLAG_PERMANENT,
145 CTLTYPE_INT, "msgbufsize",
146 SYSCTL_DESCR("Size of the kernel message buffer"),
147 sysctl_msgbuf, 0, NULL, 0,
148 CTL_KERN, KERN_MSGBUFSIZE, CTL_EOL);
149 sysctl_createv(NULL, 0, NULL, NULL,
150 CTLFLAG_PERMANENT,
151 CTLTYPE_INT, "msgbuf",
152 SYSCTL_DESCR("Kernel message buffer"),
153 sysctl_msgbuf, 0, NULL, 0,
154 CTL_KERN, KERN_MSGBUF, CTL_EOL);
155}
156
157/*ARGSUSED*/
158static int
159logopen(dev_t dev, int flags, int mode, struct lwp *l)
160{
161 struct kern_msgbuf *mbp = msgbufp;
162 int error = 0;
163
164 mutex_spin_enter(&log_lock);
165 if (log_open) {
166 error = EBUSY;
167 } else {
168 log_open = 1;
169 log_pgid = l->l_proc->p_pid; /* signal process only */
170 /*
171 * The message buffer is initialized during system
172 * configuration. If it's been clobbered, note that
173 * and return an error. (This allows a user to read
174 * the buffer via /dev/kmem, and try to figure out
175 * what clobbered it.
176 */
177 if (mbp->msg_magic != MSG_MAGIC) {
178 msgbufenabled = 0;
179 error = ENXIO;
180 }
181 }
182 mutex_spin_exit(&log_lock);
183
184 return error;
185}
186
187/*ARGSUSED*/
188static int
189logclose(dev_t dev, int flag, int mode, struct lwp *l)
190{
191
192 mutex_spin_enter(&log_lock);
193 log_pgid = 0;
194 log_open = 0;
195 log_async = 0;
196 mutex_spin_exit(&log_lock);
197
198 return 0;
199}
200
201/*ARGSUSED*/
202static int
203logread(dev_t dev, struct uio *uio, int flag)
204{
205 struct kern_msgbuf *mbp = msgbufp;
206 long l;
207 int error = 0;
208
209 mutex_spin_enter(&log_lock);
210 while (mbp->msg_bufr == mbp->msg_bufx) {
211 if (flag & IO_NDELAY) {
212 mutex_spin_exit(&log_lock);
213 return EWOULDBLOCK;
214 }
215 error = cv_wait_sig(&log_cv, &log_lock);
216 if (error) {
217 mutex_spin_exit(&log_lock);
218 return error;
219 }
220 }
221 while (uio->uio_resid > 0) {
222 l = mbp->msg_bufx - mbp->msg_bufr;
223 if (l < 0)
224 l = mbp->msg_bufs - mbp->msg_bufr;
225 l = min(l, uio->uio_resid);
226 if (l == 0)
227 break;
228 mutex_spin_exit(&log_lock);
229 error = uiomove(&mbp->msg_bufc[mbp->msg_bufr], (int)l, uio);
230 mutex_spin_enter(&log_lock);
231 if (error)
232 break;
233 mbp->msg_bufr += l;
234 if (mbp->msg_bufr < 0 || mbp->msg_bufr >= mbp->msg_bufs)
235 mbp->msg_bufr = 0;
236 }
237 mutex_spin_exit(&log_lock);
238
239 return error;
240}
241
242/*ARGSUSED*/
243static int
244logpoll(dev_t dev, int events, struct lwp *l)
245{
246 int revents = 0;
247
248 if (events & (POLLIN | POLLRDNORM)) {
249 mutex_spin_enter(&log_lock);
250 if (msgbufp->msg_bufr != msgbufp->msg_bufx)
251 revents |= events & (POLLIN | POLLRDNORM);
252 else
253 selrecord(l, &log_selp);
254 mutex_spin_exit(&log_lock);
255 }
256
257 return revents;
258}
259
260static void
261filt_logrdetach(struct knote *kn)
262{
263
264 mutex_spin_enter(&log_lock);
265 SLIST_REMOVE(&log_selp.sel_klist, kn, knote, kn_selnext);
266 mutex_spin_exit(&log_lock);
267}
268
269static int
270filt_logread(struct knote *kn, long hint)
271{
272 int rv;
273
274 if ((hint & NOTE_SUBMIT) == 0)
275 mutex_spin_enter(&log_lock);
276 if (msgbufp->msg_bufr == msgbufp->msg_bufx) {
277 rv = 0;
278 } else if (msgbufp->msg_bufr < msgbufp->msg_bufx) {
279 kn->kn_data = msgbufp->msg_bufx - msgbufp->msg_bufr;
280 rv = 1;
281 } else {
282 kn->kn_data = (msgbufp->msg_bufs - msgbufp->msg_bufr) +
283 msgbufp->msg_bufx;
284 rv = 1;
285 }
286 if ((hint & NOTE_SUBMIT) == 0)
287 mutex_spin_exit(&log_lock);
288
289 return rv;
290}
291
292static const struct filterops logread_filtops =
293 { 1, NULL, filt_logrdetach, filt_logread };
294
295static int
296logkqfilter(dev_t dev, struct knote *kn)
297{
298 struct klist *klist;
299
300 switch (kn->kn_filter) {
301 case EVFILT_READ:
302 klist = &log_selp.sel_klist;
303 kn->kn_fop = &logread_filtops;
304 break;
305
306 default:
307 return (EINVAL);
308 }
309
310 mutex_spin_enter(&log_lock);
311 kn->kn_hook = NULL;
312 SLIST_INSERT_HEAD(klist, kn, kn_selnext);
313 mutex_spin_exit(&log_lock);
314
315 return (0);
316}
317
318void
319logwakeup(void)
320{
321
322 if (!cold && log_open) {
323 mutex_spin_enter(&log_lock);
324 selnotify(&log_selp, 0, NOTE_SUBMIT);
325 if (log_async)
326 softint_schedule(log_sih);
327 cv_broadcast(&log_cv);
328 mutex_spin_exit(&log_lock);
329 }
330}
331
332static void
333logsoftintr(void *cookie)
334{
335 pid_t pid;
336
337 if ((pid = log_pgid) != 0)
338 fownsignal(pid, SIGIO, 0, 0, NULL);
339}
340
341/*ARGSUSED*/
342static int
343logioctl(dev_t dev, u_long com, void *data, int flag, struct lwp *lwp)
344{
345 long l;
346
347 switch (com) {
348
349 /* return number of characters immediately available */
350 case FIONREAD:
351 mutex_spin_enter(&log_lock);
352 l = msgbufp->msg_bufx - msgbufp->msg_bufr;
353 if (l < 0)
354 l += msgbufp->msg_bufs;
355 mutex_spin_exit(&log_lock);
356 *(int *)data = l;
357 break;
358
359 case FIONBIO:
360 break;
361
362 case FIOASYNC:
363 /* No locking needed, 'thread private'. */
364 log_async = (*((int *)data) != 0);
365 break;
366
367 case TIOCSPGRP:
368 case FIOSETOWN:
369 return fsetown(&log_pgid, com, data);
370
371 case TIOCGPGRP:
372 case FIOGETOWN:
373 return fgetown(log_pgid, com, data);
374
375 default:
376 return (EPASSTHROUGH);
377 }
378 return (0);
379}
380
381void
382logputchar(int c)
383{
384 struct kern_msgbuf *mbp;
385
386 if (!cold)
387 mutex_spin_enter(&log_lock);
388 if (msgbufenabled) {
389 mbp = msgbufp;
390 if (mbp->msg_magic != MSG_MAGIC) {
391 /*
392 * Arguably should panic or somehow notify the
393 * user... but how? Panic may be too drastic,
394 * and would obliterate the message being kicked
395 * out (maybe a panic itself), and printf
396 * would invoke us recursively. Silently punt
397 * for now. If syslog is running, it should
398 * notice.
399 */
400 msgbufenabled = 0;
401 } else {
402 mbp->msg_bufc[mbp->msg_bufx++] = c;
403 if (mbp->msg_bufx < 0 || mbp->msg_bufx >= mbp->msg_bufs)
404 mbp->msg_bufx = 0;
405 /* If the buffer is full, keep the most recent data. */
406 if (mbp->msg_bufr == mbp->msg_bufx) {
407 char c0;
408 int i;
409
410 /*
411 * Move forward read pointer to the next line
412 * in the buffer. Note that the buffer is
413 * a ring buffer so we should reset msg_bufr
414 * to 0 when msg_bufr exceeds msg_bufs.
415 *
416 * To prevent to loop forever, give up if we
417 * cannot find a newline in mbp->msg_bufs
418 * characters (the max size of the buffer).
419 */
420 for (i = 0; i < mbp->msg_bufs; i++) {
421 c0 = mbp->msg_bufc[mbp->msg_bufr];
422 if (++mbp->msg_bufr >= mbp->msg_bufs)
423 mbp->msg_bufr = 0;
424 if (c0 == '\n')
425 break;
426 }
427 }
428 }
429 }
430 if (!cold)
431 mutex_spin_exit(&log_lock);
432}
433
434/*
435 * sysctl helper routine for kern.msgbufsize and kern.msgbuf. For the
436 * former it merely checks the message buffer is set up. For the latter,
437 * it also copies out the data if necessary.
438 */
439static int
440sysctl_msgbuf(SYSCTLFN_ARGS)
441{
442 char *where = oldp;
443 size_t len, maxlen;
444 long beg, end;
445 extern kmutex_t log_lock;
446 int error;
447
448 if (!msgbufenabled || msgbufp->msg_magic != MSG_MAGIC) {
449 msgbufenabled = 0;
450 return (ENXIO);
451 }
452
453 switch (rnode->sysctl_num) {
454 case KERN_MSGBUFSIZE: {
455 struct sysctlnode node = *rnode;
456 int msg_bufs = (int)msgbufp->msg_bufs;
457 node.sysctl_data = &msg_bufs;
458 return (sysctl_lookup(SYSCTLFN_CALL(&node)));
459 }
460 case KERN_MSGBUF:
461 break;
462 default:
463 return (EOPNOTSUPP);
464 }
465
466 if (newp != NULL)
467 return (EPERM);
468
469 if (oldp == NULL) {
470 /* always return full buffer size */
471 *oldlenp = msgbufp->msg_bufs;
472 return (0);
473 }
474
475 sysctl_unlock();
476
477 /*
478 * First, copy from the write pointer to the end of
479 * message buffer.
480 */
481 error = 0;
482 mutex_spin_enter(&log_lock);
483 maxlen = MIN(msgbufp->msg_bufs, *oldlenp);
484 beg = msgbufp->msg_bufx;
485 end = msgbufp->msg_bufs;
486 mutex_spin_exit(&log_lock);
487
488 while (maxlen > 0) {
489 len = MIN(end - beg, maxlen);
490 if (len == 0)
491 break;
492 /* XXX unlocked, but hardly matters. */
493 error = copyout(&msgbufp->msg_bufc[beg], where, len);
494 ktrmibio(-1, UIO_READ, where, len, error);
495 if (error)
496 break;
497 where += len;
498 maxlen -= len;
499
500 /*
501 * ... then, copy from the beginning of message buffer to
502 * the write pointer.
503 */
504 beg = 0;
505 end = msgbufp->msg_bufx;
506 }
507
508 sysctl_relock();
509 return (error);
510}
511
512const struct cdevsw log_cdevsw = {
513 .d_open = logopen,
514 .d_close = logclose,
515 .d_read = logread,
516 .d_write = nowrite,
517 .d_ioctl = logioctl,
518 .d_stop = nostop,
519 .d_tty = notty,
520 .d_poll = logpoll,
521 .d_mmap = nommap,
522 .d_kqfilter = logkqfilter,
523 .d_discard = nodiscard,
524 .d_flag = D_OTHER | D_MPSAFE
525};
526