source: mainline/kernel/generic/src/console/console.c@ c88d91e8

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since c88d91e8 was c88d91e8, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 7 years ago

Fix atomic initialization
  • Property mode set to 100644
File size: 9.8 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 <mm/slab.h> /* malloc */
59
60#define KIO_PAGES 8
61#define KIO_LENGTH (KIO_PAGES * PAGE_SIZE / sizeof(wchar_t))
62
63/** Kernel log cyclic buffer */
64wchar_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 *, wchar_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, wchar_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 event_notify_1(EVENT_KCONSOLE, false, true);
212 bool prev = console_override;
213
214 console_override = true;
215 if ((stdout) && (stdout->op->redraw))
216 stdout->op->redraw(stdout);
217
218 if ((stdin) && (!prev)) {
219 /*
220 * Force the console to print the prompt.
221 */
222 indev_push_character(stdin, '\n');
223 }
224}
225
226void release_console(void)
227{
228 console_override = false;
229 event_notify_1(EVENT_KCONSOLE, false, false);
230}
231
232/** Activate kernel console override */
233sysarg_t sys_debug_console(void)
234{
235#ifdef CONFIG_KCONSOLE
236 grab_console();
237 return true;
238#else
239 return false;
240#endif
241}
242
243/** Get string from input character device.
244 *
245 * Read characters from input character device until first occurrence
246 * of newline character.
247 *
248 * @param indev Input character device.
249 * @param buf Buffer where to store string terminated by NULL.
250 * @param buflen Size of the buffer.
251 *
252 * @return Number of characters read.
253 *
254 */
255size_t gets(indev_t *indev, char *buf, size_t buflen)
256{
257 size_t offset = 0;
258 size_t count = 0;
259 buf[offset] = 0;
260
261 wchar_t ch;
262 while ((ch = indev_pop_character(indev)) != '\n') {
263 if (ch == '\b') {
264 if (count > 0) {
265 /* Space, backspace, space */
266 putwchar('\b');
267 putwchar(' ');
268 putwchar('\b');
269
270 count--;
271 offset = str_lsize(buf, count);
272 buf[offset] = 0;
273 }
274 }
275
276 if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) {
277 putwchar(ch);
278 count++;
279 buf[offset] = 0;
280 }
281 }
282
283 return count;
284}
285
286/** Get character from input device & echo it to screen */
287wchar_t getc(indev_t *indev)
288{
289 wchar_t ch = indev_pop_character(indev);
290 putwchar(ch);
291 return ch;
292}
293
294void kio_update(void *event)
295{
296 if (!atomic_load(&kio_inited))
297 return;
298
299 spinlock_lock(&kio_lock);
300
301 if (kio_uspace > 0) {
302 if (event_notify_3(EVENT_KIO, true, kio_start, kio_len,
303 kio_uspace) == EOK)
304 kio_uspace = 0;
305 }
306
307 spinlock_unlock(&kio_lock);
308}
309
310/** Flush characters that are stored in the output buffer
311 *
312 */
313void kio_flush(void)
314{
315 bool ordy = ((stdout) && (stdout->op->write));
316
317 if (!ordy)
318 return;
319
320 spinlock_lock(&kio_lock);
321
322 /* Print characters that weren't printed earlier */
323 while (kio_stored > 0) {
324 wchar_t tmp = kio[(kio_start + kio_len - kio_stored) % KIO_LENGTH];
325 kio_stored--;
326
327 /*
328 * We need to give up the spinlock for
329 * the physical operation of writing out
330 * the character.
331 */
332 spinlock_unlock(&kio_lock);
333 stdout->op->write(stdout, tmp);
334 spinlock_lock(&kio_lock);
335 }
336
337 spinlock_unlock(&kio_lock);
338}
339
340/** Put a character into the output buffer.
341 *
342 * The caller is required to hold kio_lock
343 */
344void kio_push_char(const wchar_t ch)
345{
346 kio[(kio_start + kio_len) % KIO_LENGTH] = ch;
347 if (kio_len < KIO_LENGTH)
348 kio_len++;
349 else
350 kio_start = (kio_start + 1) % KIO_LENGTH;
351
352 if (kio_stored < kio_len)
353 kio_stored++;
354
355 /* The character is stored for uspace */
356 if (kio_uspace < kio_len)
357 kio_uspace++;
358}
359
360void putwchar(const wchar_t ch)
361{
362 bool ordy = ((stdout) && (stdout->op->write));
363
364 spinlock_lock(&kio_lock);
365 kio_push_char(ch);
366 spinlock_unlock(&kio_lock);
367
368 /* Output stored characters */
369 kio_flush();
370
371 if (!ordy) {
372 /*
373 * No standard output routine defined yet.
374 * The character is still stored in the kernel log
375 * for possible future output.
376 *
377 * The early_putwchar() function is used to output
378 * the character for low-level debugging purposes.
379 * Note that the early_putc() function might be
380 * a no-op on certain hardware configurations.
381 */
382 early_putwchar(ch);
383 }
384
385 /* Force notification on newline */
386 if (ch == '\n')
387 kio_update(NULL);
388}
389
390/** Print using kernel facility
391 *
392 * Print to kernel log.
393 *
394 */
395sys_errno_t sys_kio(int cmd, const void *buf, size_t size)
396{
397 char *data;
398 errno_t rc;
399
400 switch (cmd) {
401 case KIO_UPDATE:
402 kio_update(NULL);
403 return EOK;
404 case KIO_WRITE:
405 case KIO_COMMAND:
406 break;
407 default:
408 return ENOTSUP;
409 }
410
411 if (size > PAGE_SIZE)
412 return (sys_errno_t) ELIMIT;
413
414 if (size > 0) {
415 data = (char *) malloc(size + 1);
416 if (!data)
417 return (sys_errno_t) ENOMEM;
418
419 rc = copy_from_uspace(data, buf, size);
420 if (rc) {
421 free(data);
422 return (sys_errno_t) rc;
423 }
424 data[size] = 0;
425
426 switch (cmd) {
427 case KIO_WRITE:
428 printf("[%s(%lu)] %s\n", TASK->name,
429 (unsigned long) TASK->taskid, data);
430 break;
431 case KIO_COMMAND:
432 if (!stdin)
433 break;
434 for (unsigned int i = 0; i < size; i++)
435 indev_push_character(stdin, data[i]);
436 indev_push_character(stdin, '\n');
437 break;
438 }
439
440 free(data);
441 }
442
443 return EOK;
444}
445
446/** @}
447 */
Note: See TracBrowser for help on using the repository browser.