source: mainline/kernel/generic/src/console/console.c@ 63ed840

topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 63ed840 was 63ed840, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 20 months ago

Remove unused functions gets() and getc() from kernel
  • Property mode set to 100644
File size: 8.9 KB
Line 
1/*
2 * Copyright (c) 2003 Josef Cejka
3 * Copyright (c) 2005 Jakub Jermar
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - 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 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup kernel_generic_console
31 * @{
32 */
33/** @file
34 */
35
36#include <assert.h>
37#include <console/console.h>
38#include <console/chardev.h>
39#include <sysinfo/sysinfo.h>
40#include <synch/waitq.h>
41#include <synch/spinlock.h>
42#include <typedefs.h>
43#include <ddi/irq.h>
44#include <ddi/ddi.h>
45#include <ipc/event.h>
46#include <ipc/irq.h>
47#include <arch.h>
48#include <panic.h>
49#include <stdio.h>
50#include <putchar.h>
51#include <atomic.h>
52#include <syscall/copy.h>
53#include <errno.h>
54#include <str.h>
55#include <stdatomic.h>
56#include <abi/kio.h>
57#include <mm/frame.h> /* SIZE2FRAMES */
58#include <stdlib.h> /* malloc */
59
60#define KIO_PAGES 8
61#define KIO_LENGTH (KIO_PAGES * PAGE_SIZE / sizeof(char32_t))
62
63/** Kernel log cyclic buffer */
64char32_t kio[KIO_LENGTH] __attribute__((aligned(PAGE_SIZE)));
65
66/** Kernel log initialized */
67static atomic_bool kio_inited = ATOMIC_VAR_INIT(false);
68
69/** First kernel log characters */
70static size_t kio_start = 0;
71
72/** Number of valid kernel log characters */
73static size_t kio_len = 0;
74
75/** Number of stored (not printed) kernel log characters */
76static size_t kio_stored = 0;
77
78/** Number of stored kernel log characters for uspace */
79static size_t kio_uspace = 0;
80
81/** Kernel log spinlock */
82SPINLOCK_INITIALIZE_NAME(kio_lock, "kio_lock");
83
84/** Physical memory area used for kio buffer */
85static parea_t kio_parea;
86
87static indev_t stdin_sink;
88static outdev_t stdout_source;
89
90static void stdin_signal(indev_t *, indev_signal_t);
91
92static indev_operations_t stdin_ops = {
93 .poll = NULL,
94 .signal = stdin_signal
95};
96
97static void stdout_write(outdev_t *, char32_t);
98static void stdout_redraw(outdev_t *);
99static void stdout_scroll_up(outdev_t *);
100static void stdout_scroll_down(outdev_t *);
101
102static outdev_operations_t stdout_ops = {
103 .write = stdout_write,
104 .redraw = stdout_redraw,
105 .scroll_up = stdout_scroll_up,
106 .scroll_down = stdout_scroll_down
107};
108
109/** Override kernel console lockout */
110bool console_override = false;
111
112/** Standard input and output character devices */
113indev_t *stdin = NULL;
114outdev_t *stdout = NULL;
115
116indev_t *stdin_wire(void)
117{
118 if (stdin == NULL) {
119 indev_initialize("stdin", &stdin_sink, &stdin_ops);
120 stdin = &stdin_sink;
121 }
122
123 return stdin;
124}
125
126static void stdin_signal(indev_t *indev, indev_signal_t signal)
127{
128 switch (signal) {
129 case INDEV_SIGNAL_SCROLL_UP:
130 if (stdout != NULL)
131 stdout_scroll_up(stdout);
132 break;
133 case INDEV_SIGNAL_SCROLL_DOWN:
134 if (stdout != NULL)
135 stdout_scroll_down(stdout);
136 break;
137 }
138}
139
140void stdout_wire(outdev_t *outdev)
141{
142 if (stdout == NULL) {
143 outdev_initialize("stdout", &stdout_source, &stdout_ops);
144 stdout = &stdout_source;
145 }
146
147 list_append(&outdev->link, &stdout->list);
148}
149
150static void stdout_write(outdev_t *dev, char32_t ch)
151{
152 list_foreach(dev->list, link, outdev_t, sink) {
153 if ((sink) && (sink->op->write))
154 sink->op->write(sink, ch);
155 }
156}
157
158static void stdout_redraw(outdev_t *dev)
159{
160 list_foreach(dev->list, link, outdev_t, sink) {
161 if ((sink) && (sink->op->redraw))
162 sink->op->redraw(sink);
163 }
164}
165
166static void stdout_scroll_up(outdev_t *dev)
167{
168 list_foreach(dev->list, link, outdev_t, sink) {
169 if ((sink) && (sink->op->scroll_up))
170 sink->op->scroll_up(sink);
171 }
172}
173
174static void stdout_scroll_down(outdev_t *dev)
175{
176 list_foreach(dev->list, link, outdev_t, sink) {
177 if ((sink) && (sink->op->scroll_down))
178 sink->op->scroll_down(sink);
179 }
180}
181
182/** Initialize kernel logging facility
183 *
184 * The shared area contains kernel cyclic buffer. Userspace application may
185 * be notified on new data with indication of position and size
186 * of the data within the circular buffer.
187 *
188 */
189void kio_init(void)
190{
191 void *faddr = (void *) KA2PA(kio);
192
193 assert((uintptr_t) faddr % FRAME_SIZE == 0);
194
195 ddi_parea_init(&kio_parea);
196 kio_parea.pbase = (uintptr_t) faddr;
197 kio_parea.frames = SIZE2FRAMES(sizeof(kio));
198 kio_parea.unpriv = false;
199 kio_parea.mapped = false;
200 ddi_parea_register(&kio_parea);
201
202 sysinfo_set_item_val("kio.faddr", NULL, (sysarg_t) faddr);
203 sysinfo_set_item_val("kio.pages", NULL, KIO_PAGES);
204
205 event_set_unmask_callback(EVENT_KIO, kio_update);
206 atomic_store(&kio_inited, true);
207}
208
209void grab_console(void)
210{
211 sysinfo_set_item_val("kconsole", NULL, true);
212 event_notify_1(EVENT_KCONSOLE, false, true);
213 bool prev = console_override;
214
215 console_override = true;
216 if ((stdout) && (stdout->op->redraw))
217 stdout->op->redraw(stdout);
218
219 if ((stdin) && (!prev)) {
220 /*
221 * Force the console to print the prompt.
222 */
223 indev_push_character(stdin, '\n');
224 }
225}
226
227void release_console(void)
228{
229 sysinfo_set_item_val("kconsole", NULL, false);
230 console_override = false;
231 event_notify_1(EVENT_KCONSOLE, false, false);
232}
233
234/** Activate kernel console override */
235sysarg_t sys_debug_console(void)
236{
237#ifdef CONFIG_KCONSOLE
238 grab_console();
239 return true;
240#else
241 return false;
242#endif
243}
244
245void kio_update(void *event)
246{
247 if (!atomic_load(&kio_inited))
248 return;
249
250 spinlock_lock(&kio_lock);
251
252 if (kio_uspace > 0) {
253 if (event_notify_3(EVENT_KIO, true, kio_start, kio_len,
254 kio_uspace) == EOK)
255 kio_uspace = 0;
256 }
257
258 spinlock_unlock(&kio_lock);
259}
260
261/** Flush characters that are stored in the output buffer
262 *
263 */
264void kio_flush(void)
265{
266 bool ordy = ((stdout) && (stdout->op->write));
267
268 if (!ordy)
269 return;
270
271 spinlock_lock(&kio_lock);
272
273 /* Print characters that weren't printed earlier */
274 while (kio_stored > 0) {
275 char32_t tmp = kio[(kio_start + kio_len - kio_stored) % KIO_LENGTH];
276 kio_stored--;
277
278 /*
279 * We need to give up the spinlock for
280 * the physical operation of writing out
281 * the character.
282 */
283 spinlock_unlock(&kio_lock);
284 stdout->op->write(stdout, tmp);
285 spinlock_lock(&kio_lock);
286 }
287
288 spinlock_unlock(&kio_lock);
289}
290
291/** Put a character into the output buffer.
292 *
293 * The caller is required to hold kio_lock
294 */
295void kio_push_char(const char32_t ch)
296{
297 kio[(kio_start + kio_len) % KIO_LENGTH] = ch;
298 if (kio_len < KIO_LENGTH)
299 kio_len++;
300 else
301 kio_start = (kio_start + 1) % KIO_LENGTH;
302
303 if (kio_stored < kio_len)
304 kio_stored++;
305
306 /* The character is stored for uspace */
307 if (kio_uspace < kio_len)
308 kio_uspace++;
309}
310
311void putuchar(const char32_t ch)
312{
313 bool ordy = ((stdout) && (stdout->op->write));
314
315 spinlock_lock(&kio_lock);
316 kio_push_char(ch);
317 spinlock_unlock(&kio_lock);
318
319 /* Output stored characters */
320 kio_flush();
321
322 if (!ordy) {
323 /*
324 * No standard output routine defined yet.
325 * The character is still stored in the kernel log
326 * for possible future output.
327 *
328 * The early_putuchar() function is used to output
329 * the character for low-level debugging purposes.
330 * Note that the early_putuchar() function might be
331 * a no-op on certain hardware configurations.
332 */
333 early_putuchar(ch);
334 }
335
336 /* Force notification on newline */
337 if (ch == '\n')
338 kio_update(NULL);
339}
340
341/** Print using kernel facility
342 *
343 * Print to kernel log.
344 *
345 */
346sys_errno_t sys_kio(int cmd, uspace_addr_t buf, size_t size)
347{
348 char *data;
349 errno_t rc;
350
351 switch (cmd) {
352 case KIO_UPDATE:
353 kio_update(NULL);
354 return EOK;
355 case KIO_WRITE:
356 case KIO_COMMAND:
357 break;
358 default:
359 return ENOTSUP;
360 }
361
362 if (size > PAGE_SIZE)
363 return (sys_errno_t) ELIMIT;
364
365 if (size > 0) {
366 data = (char *) malloc(size + 1);
367 if (!data)
368 return (sys_errno_t) ENOMEM;
369
370 rc = copy_from_uspace(data, buf, size);
371 if (rc) {
372 free(data);
373 return (sys_errno_t) rc;
374 }
375 data[size] = 0;
376
377 switch (cmd) {
378 case KIO_WRITE:
379 printf("[%s(%lu)] %s\n", TASK->name,
380 (unsigned long) TASK->taskid, data);
381 break;
382 case KIO_COMMAND:
383 if (!stdin)
384 break;
385 for (unsigned int i = 0; i < size; i++)
386 indev_push_character(stdin, data[i]);
387 indev_push_character(stdin, '\n');
388 break;
389 }
390
391 free(data);
392 }
393
394 return EOK;
395}
396
397/** @}
398 */
Note: See TracBrowser for help on using the repository browser.