1 | /* |
2 | * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ |
29 | /*- |
30 | * Copyright (c) 1986, 1988, 1991, 1993 |
31 | * The Regents of the University of California. All rights reserved. |
32 | * (c) UNIX System Laboratories, Inc. |
33 | * All or some portions of this file are derived from material licensed |
34 | * to the University of California by American Telephone and Telegraph |
35 | * Co. or Unix System Laboratories, Inc. and are reproduced herein with |
36 | * the permission of UNIX System Laboratories, Inc. |
37 | * |
38 | * Redistribution and use in source and binary forms, with or without |
39 | * modification, are permitted provided that the following conditions |
40 | * are met: |
41 | * 1. Redistributions of source code must retain the above copyright |
42 | * notice, this list of conditions and the following disclaimer. |
43 | * 2. Redistributions in binary form must reproduce the above copyright |
44 | * notice, this list of conditions and the following disclaimer in the |
45 | * documentation and/or other materials provided with the distribution. |
46 | * 3. All advertising materials mentioning features or use of this software |
47 | * must display the following acknowledgement: |
48 | * This product includes software developed by the University of |
49 | * California, Berkeley and its contributors. |
50 | * 4. Neither the name of the University nor the names of its contributors |
51 | * may be used to endorse or promote products derived from this software |
52 | * without specific prior written permission. |
53 | * |
54 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
55 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
56 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
57 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
58 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
59 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
60 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
61 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
62 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
63 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
64 | * SUCH DAMAGE. |
65 | * |
66 | * @(#)subr_prf.c 8.4 (Berkeley) 5/4/95 |
67 | */ |
68 | /* HISTORY |
69 | * 22-Sep-1997 Umesh Vaishampayan (umeshv@apple.com) |
70 | * Cleaned up m68k crud. Fixed vlog() to do logpri() for ppc, too. |
71 | * |
72 | * 17-July-97 Umesh Vaishampayan (umeshv@apple.com) |
73 | * Eliminated multiple definition of constty which is defined |
74 | * in bsd/dev/XXX/cons.c |
75 | * |
76 | * 26-MAR-1997 Umesh Vaishampayan (umeshv@NeXT.com |
77 | * Fixed tharshing format in many functions. Cleanup. |
78 | * |
79 | * 17-Jun-1995 Mac Gillon (mgillon) at NeXT |
80 | * Purged old history |
81 | * New version based on 4.4 and NS3.3 |
82 | */ |
83 | |
84 | #include <sys/param.h> |
85 | #include <sys/systm.h> |
86 | #include <sys/conf.h> |
87 | #include <sys/reboot.h> |
88 | #include <sys/msgbuf.h> |
89 | #include <sys/proc_internal.h> |
90 | #include <sys/ioctl.h> |
91 | #include <sys/tty.h> |
92 | #include <sys/file_internal.h> |
93 | #include <sys/tprintf.h> |
94 | #include <sys/syslog.h> |
95 | #include <stdarg.h> |
96 | #include <sys/malloc.h> |
97 | #include <sys/lock.h> |
98 | #include <sys/subr_prf.h> |
99 | |
100 | #include <kern/cpu_number.h> /* for cpu_number() */ |
101 | #include <libkern/libkern.h> |
102 | #include <os/log_private.h> |
103 | |
104 | /* for vaddlog(): the following are implemented in osfmk/kern/printf.c */ |
105 | extern void bsd_log_lock(void); |
106 | extern void bsd_log_unlock(void); |
107 | |
108 | /* Keep this around only because it's exported */ |
109 | void _printf(int, struct tty *, const char *, ...); |
110 | |
111 | struct snprintf_arg { |
112 | char *str; |
113 | size_t remain; |
114 | }; |
115 | |
116 | |
117 | /* |
118 | * In case console is off, |
119 | * debugger_panic_str contains argument to last |
120 | * call to panic. |
121 | */ |
122 | extern const char *debugger_panic_str; |
123 | |
124 | extern void cnputc(char); /* standard console putc */ |
125 | void (*v_putc)(char) = cnputc; /* routine to putc on virtual console */ |
126 | |
127 | extern struct tty cons; /* standard console tty */ |
128 | extern struct tty *constty; /* pointer to console "window" tty */ |
129 | extern int __doprnt(const char *fmt, |
130 | va_list argp, |
131 | void (*)(int, void *), |
132 | void *arg, |
133 | int radix, |
134 | int is_log); |
135 | |
136 | /* |
137 | * Record cpu that panic'd and lock around panic data |
138 | */ |
139 | |
140 | extern void logwakeup(struct msgbuf *); |
141 | extern void halt_cpu(void); |
142 | |
143 | static void |
144 | snprintf_func(int ch, void *arg); |
145 | |
146 | struct putchar_args { |
147 | int flags; |
148 | struct tty *tty; |
149 | }; |
150 | static void putchar(int c, void *arg); |
151 | |
152 | |
153 | /* |
154 | * Uprintf prints to the controlling terminal for the current process. |
155 | * It may block if the tty queue is overfull. No message is printed if |
156 | * the queue does not clear in a reasonable time. |
157 | */ |
158 | void |
159 | uprintf(const char *fmt, ...) |
160 | { |
161 | struct proc *p = current_proc(); |
162 | struct putchar_args pca; |
163 | va_list ap; |
164 | struct session *sessp; |
165 | |
166 | sessp = proc_session(p); |
167 | |
168 | if (p->p_flag & P_CONTROLT && sessp != SESSION_NULL && sessp->s_ttyvp) { |
169 | pca.flags = TOTTY; |
170 | pca.tty = SESSION_TP(sessp); |
171 | if (pca.tty != NULL) |
172 | tty_lock(pca.tty); |
173 | va_start(ap, fmt); |
174 | __doprnt(fmt, ap, putchar, &pca, 10, FALSE); |
175 | va_end(ap); |
176 | if (pca.tty != NULL) |
177 | tty_unlock(pca.tty); |
178 | } |
179 | if (sessp != SESSION_NULL) |
180 | session_rele(sessp); |
181 | } |
182 | |
183 | tpr_t |
184 | tprintf_open(struct proc *p) |
185 | { |
186 | struct session * sessp; |
187 | |
188 | sessp = proc_session(p); |
189 | |
190 | if (p->p_flag & P_CONTROLT && sessp->s_ttyvp) { |
191 | return ((tpr_t)sessp); |
192 | } |
193 | if (sessp != SESSION_NULL) |
194 | session_rele(sessp); |
195 | |
196 | return ((tpr_t) NULL); |
197 | } |
198 | |
199 | void |
200 | tprintf_close(tpr_t sessp) |
201 | { |
202 | if (sessp) |
203 | session_rele((struct session *) sessp); |
204 | } |
205 | |
206 | /* |
207 | * tprintf prints on the controlling terminal associated |
208 | * with the given session. |
209 | * |
210 | * NOTE: No one else should call this function!!! |
211 | */ |
212 | void |
213 | tprintf(tpr_t tpr, const char *fmt, ...) |
214 | { |
215 | struct session *sess = (struct session *)tpr; |
216 | struct tty *tp; |
217 | va_list ap; |
218 | struct putchar_args pca; |
219 | |
220 | if (sess && (tp = SESSION_TP(sess)) != TTY_NULL) { |
221 | /* ttycheckoutq(), tputchar() require a locked tp */ |
222 | tty_lock(tp); |
223 | if(ttycheckoutq(tp, 0)) { |
224 | pca.flags = TOTTY; |
225 | /* going to the tty; leave locked */ |
226 | pca.tty = tp; |
227 | va_start(ap, fmt); |
228 | __doprnt(fmt, ap, putchar, &pca, 10, FALSE); |
229 | va_end(ap); |
230 | } |
231 | tty_unlock(tp); |
232 | } |
233 | |
234 | pca.flags = TOLOG; |
235 | pca.tty = TTY_NULL; |
236 | va_start(ap, fmt); |
237 | __doprnt(fmt, ap, putchar, &pca, 10, TRUE); |
238 | va_end(ap); |
239 | |
240 | logwakeup(msgbufp); |
241 | |
242 | va_start(ap, fmt); |
243 | os_log_with_args(OS_LOG_DEFAULT, OS_LOG_TYPE_DEFAULT, fmt, ap, __builtin_return_address(0)); |
244 | va_end(ap); |
245 | } |
246 | |
247 | /* |
248 | * Ttyprintf displays a message on a tty; it should be used only by |
249 | * the tty driver, or anything that knows the underlying tty will not |
250 | * be revoke(2)'d away. Other callers should use tprintf. |
251 | * |
252 | * Locks: It is assumed that the tty_lock() is held over the call |
253 | * to this function. Ensuring this is the responsibility |
254 | * of the caller. |
255 | */ |
256 | void |
257 | ttyprintf(struct tty *tp, const char *fmt, ...) |
258 | { |
259 | va_list ap; |
260 | |
261 | if (tp != NULL) { |
262 | struct putchar_args pca; |
263 | pca.flags = TOTTY; |
264 | pca.tty = tp; |
265 | |
266 | va_start(ap, fmt); |
267 | __doprnt(fmt, ap, putchar, &pca, 10, TRUE); |
268 | va_end(ap); |
269 | } |
270 | } |
271 | |
272 | void |
273 | logtime(time_t secs) |
274 | { |
275 | printf("Time %ld Message " , secs); |
276 | } |
277 | |
278 | static void |
279 | putchar_asl(int c, void *arg) |
280 | { |
281 | struct putchar_args *pca = arg; |
282 | |
283 | if ((pca->flags & TOLOGLOCKED) && c != '\0' && c != '\r' && c != 0177) |
284 | log_putc_locked(aslbufp, c); |
285 | putchar(c, arg); |
286 | } |
287 | |
288 | /* |
289 | * Vestigial support for kern_asl_msg() via /dev/klog |
290 | */ |
291 | int |
292 | vaddlog(const char *fmt, va_list ap) |
293 | { |
294 | struct putchar_args pca = { |
295 | .flags = TOLOGLOCKED, |
296 | .tty = NULL, |
297 | }; |
298 | |
299 | bsd_log_lock(); |
300 | __doprnt(fmt, ap, putchar_asl, &pca, 10, TRUE); |
301 | bsd_log_unlock(); |
302 | logwakeup(NULL); |
303 | |
304 | return (0); |
305 | } |
306 | |
307 | void |
308 | _printf(int flags, struct tty *ttyp, const char *format, ...) |
309 | { |
310 | va_list ap; |
311 | struct putchar_args pca; |
312 | |
313 | pca.flags = flags; |
314 | pca.tty = ttyp; |
315 | |
316 | if (ttyp != NULL) { |
317 | tty_lock(ttyp); |
318 | |
319 | va_start(ap, format); |
320 | __doprnt(format, ap, putchar, &pca, 10, TRUE); |
321 | va_end(ap); |
322 | |
323 | tty_unlock(ttyp); |
324 | } |
325 | } |
326 | |
327 | int |
328 | prf(const char *fmt, va_list ap, int flags, struct tty *ttyp) |
329 | { |
330 | struct putchar_args pca; |
331 | |
332 | pca.flags = flags; |
333 | pca.tty = ttyp; |
334 | |
335 | __doprnt(fmt, ap, putchar, &pca, 10, TRUE); |
336 | |
337 | return 0; |
338 | } |
339 | |
340 | /* |
341 | * Warn that a system table is full. |
342 | */ |
343 | void tablefull(const char *tab) |
344 | { |
345 | log(LOG_ERR, "%s: table is full\n" , tab); |
346 | } |
347 | |
348 | /* |
349 | * Print a character on console or users terminal. |
350 | * If destination is console then the last MSGBUFS characters |
351 | * are saved in msgbuf for inspection later. |
352 | * |
353 | * Locks: If TOTTY is set, we assume that the tty lock is held |
354 | * over the call to this function. |
355 | */ |
356 | /*ARGSUSED*/ |
357 | void |
358 | putchar(int c, void *arg) |
359 | { |
360 | struct putchar_args *pca = arg; |
361 | char **sp = (char**) pca->tty; |
362 | |
363 | if (debugger_panic_str) |
364 | constty = 0; |
365 | if ((pca->flags & TOCONS) && pca->tty == NULL && constty) { |
366 | pca->tty = constty; |
367 | pca->flags |= TOTTY; |
368 | } |
369 | if ((pca->flags & TOTTY) && pca->tty && tputchar(c, pca->tty) < 0 && |
370 | (pca->flags & TOCONS) && pca->tty == constty) |
371 | constty = 0; |
372 | if ((pca->flags & TOLOG) && c != '\0' && c != '\r' && c != 0177) |
373 | log_putc(c); |
374 | if ((pca->flags & TOLOGLOCKED) && c != '\0' && c != '\r' && c != 0177) |
375 | log_putc_locked(msgbufp, c); |
376 | if ((pca->flags & TOCONS) && constty == 0 && c != '\0') |
377 | (*v_putc)(c); |
378 | if (pca->flags & TOSTR) { |
379 | **sp = c; |
380 | (*sp)++; |
381 | } |
382 | } |
383 | |
384 | int |
385 | vprintf_log_locked(const char *fmt, va_list ap) |
386 | { |
387 | struct putchar_args pca; |
388 | |
389 | pca.flags = TOLOGLOCKED; |
390 | pca.tty = NULL; |
391 | __doprnt(fmt, ap, putchar, &pca, 10, TRUE); |
392 | return 0; |
393 | } |
394 | |
395 | #if !CONFIG_EMBEDDED |
396 | |
397 | /* |
398 | * Scaled down version of vsprintf(3). |
399 | * |
400 | * Deprecation Warning: |
401 | * vsprintf() is being deprecated. Please use vsnprintf() instead. |
402 | */ |
403 | int |
404 | vsprintf(char *buf, const char *cfmt, va_list ap) |
405 | { |
406 | int retval; |
407 | struct snprintf_arg info; |
408 | |
409 | info.str = buf; |
410 | info.remain = 999999; |
411 | |
412 | retval = __doprnt(cfmt, ap, snprintf_func, &info, 10, FALSE); |
413 | if (info.remain >= 1) { |
414 | *info.str++ = '\0'; |
415 | } |
416 | return 0; |
417 | } |
418 | #endif /* !CONFIG_EMBEDDED */ |
419 | |
420 | /* |
421 | * Scaled down version of snprintf(3). |
422 | */ |
423 | int |
424 | snprintf(char *str, size_t size, const char *format, ...) |
425 | { |
426 | int retval; |
427 | va_list ap; |
428 | |
429 | va_start(ap, format); |
430 | retval = vsnprintf(str, size, format, ap); |
431 | va_end(ap); |
432 | return(retval); |
433 | } |
434 | |
435 | /* |
436 | * Scaled down version of vsnprintf(3). |
437 | */ |
438 | int |
439 | vsnprintf(char *str, size_t size, const char *format, va_list ap) |
440 | { |
441 | struct snprintf_arg info; |
442 | int retval; |
443 | |
444 | info.str = str; |
445 | info.remain = size; |
446 | retval = __doprnt(format, ap, snprintf_func, &info, 10, FALSE); |
447 | if (info.remain >= 1) |
448 | *info.str++ = '\0'; |
449 | return retval; |
450 | } |
451 | |
452 | static void |
453 | snprintf_func(int ch, void *arg) |
454 | { |
455 | struct snprintf_arg *const info = arg; |
456 | |
457 | if (info->remain >= 2) { |
458 | *info->str++ = ch; |
459 | info->remain--; |
460 | } |
461 | } |
462 | |
463 | int |
464 | kvprintf(char const *fmt, void (*func)(int, void*), void *arg, int radix, va_list ap) |
465 | { |
466 | __doprnt(fmt, ap, func, arg, radix, TRUE); |
467 | return 0; |
468 | } |
469 | |
470 | |