WebSVN – HelenOS – Diff – /trunk/kernel/generic/src/console/console.c


/*
 * Copyright (c) 2003 Josef Cejka
 * Copyright (c) 2005 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup genericconsole
 * @{
 */
/** @file
 */
 
#include <console/console.h>
#include <console/chardev.h>
#include <sysinfo/sysinfo.h>
#include <synch/waitq.h>
#include <synch/spinlock.h>
#include <arch/types.h>
#include <ddi/irq.h>
#include <ddi/ddi.h>
#include <ipc/event.h>
#include <ipc/irq.h>
#include <arch.h>
#include <func.h>
#include <print.h>
#include <putchar.h>
#include <atomic.h>
#include <syscall/copy.h>
#include <errno.h>
#include <string.h>
 
#define KLOG_PAGES    4
#define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
#define KLOG_LATENCY  8
 
/** Kernel log cyclic buffer */
static wchar_t klog[KLOG_LENGTH] __attribute__ ((aligned (PAGE_SIZE)));
 
/** Kernel log initialized */
static bool klog_inited = false;
/** First kernel log characters */
static index_t klog_start = 0;
/** Number of valid kernel log characters */
static size_t klog_len = 0;
/** Number of stored (not printed) kernel log characters */
static size_t klog_stored = 0;
/** Number of stored kernel log characters for uspace */
static size_t klog_uspace = 0;
 
/** Silence output */
bool silent = false;
 
/** Kernel log spinlock */
SPINLOCK_INITIALIZE(klog_lock);
 
/** Physical memory area used for klog buffer */
static parea_t klog_parea;
 
/** Standard input and output character devices */
indev_t *stdin = NULL;
outdev_t *stdout = NULL;
 
/** Initialize kernel logging facility
 *
 * The shared area contains kernel cyclic buffer. Userspace application may
 * be notified on new data with indication of position and size
 * of the data within the circular buffer.
 *
 */
void klog_init(void)
{
    void *faddr = (void *) KA2PA(klog);
   
    ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);
 
   
    klog_parea.pbase = (uintptr_t) faddr;
    klog_parea.frames = SIZE2FRAMES(sizeof(klog));
    ddi_parea_register(&klog_parea);
   
    sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);
    sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
   
    spinlock_lock(&klog_lock);
    klog_inited = true;
    spinlock_unlock(&klog_lock);
}
 
void grab_console(void)
{
    silent = false;
    arch_grab_console();
}
 
void release_console(void)
{
    silent = true;
    arch_release_console();
}
 
/** Tell kernel to get keyboard/console access again */
unative_t sys_debug_enable_console(void)
{
#ifdef CONFIG_KCONSOLE
    grab_console();
    return true;
#else
    return false;
#endif
}
 
/** Tell kernel to relinquish keyboard/console access */
unative_t sys_debug_disable_console(void)
{
    release_console();
    return true;
}
 
bool check_poll(indev_t *indev)
{
    if (indev == NULL)
        return false;
   
    if (indev->op == NULL)
        return false;
   
    return (indev->op->poll != NULL);
}
 
/** Get character from input character device. Do not echo character.
 *
 * @param indev Input character device.
 * @return Character read.
 *
 */
wchar_t _getc(indev_t *indev)
{
    if (atomic_get(&haltstate)) {
        /* If we are here, we are hopefully on the processor that
         * issued the 'halt' command, so proceed to read the character
         * directly from input
         */
        if (check_poll(indev))
            return indev->op->poll(indev);
       
        /* No other way of interacting with user */
        interrupts_disable();
       
        if (CPU)
            printf("cpu%u: ", CPU->id);
        else
            printf("cpu: ");
        printf("halted (no polling input)\n");
        cpu_halt();
    }
   
    waitq_sleep(&indev->wq);
    ipl_t ipl = interrupts_disable();
    spinlock_lock(&indev->lock);
    wchar_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];
    indev->counter--;
    spinlock_unlock(&indev->lock);
    interrupts_restore(ipl);
   
    return ch;
}
 
/** Get string from input character device.
 *
 * Read characters from input character device until first occurrence
 * of newline character.
 *
 * @param indev  Input character device.
 * @param buf    Buffer where to store string terminated by NULL.
 * @param buflen Size of the buffer.
 *
 * @return Number of characters read.
 *
 */
count_t gets(indev_t *indev, char *buf, size_t buflen)
{
    size_t offset = 0;
    count_t count = 0;
    buf[offset] = 0;
   
    wchar_t ch;
    while ((ch = _getc(indev)) != '\n') {
        if (ch == '\b') {
            if (count > 0) {
                /* Space, backspace, space */
                putchar('\b');
                putchar(' ');
                putchar('\b');
               
                count--;
                offset = str_lsize(buf, count);
                buf[offset] = 0;
            }
        }
        if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) {
            putchar(ch);
            count++;
            buf[offset] = 0;
        }
    }
   
    return count;
}
 
/** Get character from input device & echo it to screen */
wchar_t getc(indev_t *indev)
{
    wchar_t ch = _getc(indev);
    putchar(ch);
    return ch;
}
 
void klog_update(void)
{
    spinlock_lock(&klog_lock);
   
    if ((klog_inited) && (event_is_subscribed(EVENT_KLOG)) && (klog_uspace > 0)) {
        event_notify_3(EVENT_KLOG, klog_start, klog_len, klog_uspace);
        klog_uspace = 0;
    }
   
    spinlock_unlock(&klog_lock);
}
 
void putchar(const wchar_t ch)
{
    spinlock_lock(&klog_lock);
   
    if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {
        /* Print charaters stored in kernel log */
        index_t i;
        for (i = klog_len - klog_stored; i < klog_len; i++)
            stdout->op->write(stdout, klog[(klog_start + i) % KLOG_LENGTH], silent);
        klog_stored = 0;
    }
   
    /* Store character in the cyclic kernel log */
    klog[(klog_start + klog_len) % KLOG_LENGTH] = ch;
    if (klog_len < KLOG_LENGTH)
        klog_len++;
    else
        klog_start = (klog_start + 1) % KLOG_LENGTH;
   
    if ((stdout) && (stdout->op->write))
        stdout->op->write(stdout, ch, silent);
    else {
        /* The character is just in the kernel log */
        if (klog_stored < klog_len)
            klog_stored++;
    }
   
    /* The character is stored for uspace */
    if (klog_uspace < klog_len)
        klog_uspace++;
   
    /* Check notify uspace to update */
    bool update;
    if ((klog_uspace > KLOG_LATENCY) || (ch == '\n'))
        update = true;
    else
        update = false;
   
    spinlock_unlock(&klog_lock);
   
    if (update)
        klog_update();
}
 
/** Print using kernel facility
 *
 * Print to kernel log.
 *
 */
unative_t sys_klog(int fd, const void *buf, size_t size)
{
    char *data;
    int rc;
   
    if (size > PAGE_SIZE)
        return ELIMIT;
   
    if (size > 0) {
        data = (char *) malloc(size + 1, 0);
        if (!data)
            return ENOMEM;
       
        rc = copy_from_uspace(data, buf, size);
        if (rc) {
            free(data);
            return rc;
        }
        data[size] = 0;
       
        printf("%s", data);
        free(data);
    } else
        klog_update();
   
    return size;
}
 
/** @}
 */
 

Rev 4226	Rev 4252
1	/*	1	/*
2	* Copyright (c) 2003 Josef Cejka	2	* Copyright (c) 2003 Josef Cejka
3	* Copyright (c) 2005 Jakub Jermar	3	* Copyright (c) 2005 Jakub Jermar
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	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	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.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
30	/** @addtogroup genericconsole	30	/** @addtogroup genericconsole
31	* @{	31	* @{
32	*/	32	*/
33	/** @file	33	/** @file
34	*/	34	*/
35		35
36	#include <console/console.h>	36	#include <console/console.h>
37	#include <console/chardev.h>	37	#include <console/chardev.h>
38	#include <sysinfo/sysinfo.h>	38	#include <sysinfo/sysinfo.h>
39	#include <synch/waitq.h>	39	#include <synch/waitq.h>
40	#include <synch/spinlock.h>	40	#include <synch/spinlock.h>
41	#include <arch/types.h>	41	#include <arch/types.h>
42	#include <ddi/irq.h>	42	#include <ddi/irq.h>
43	#include <ddi/ddi.h>	43	#include <ddi/ddi.h>
44	#include <event/event.h>	44	#include <ipc/event.h>
45	#include <ipc/irq.h>	45	#include <ipc/irq.h>
46	#include <arch.h>	46	#include <arch.h>
47	#include <func.h>	47	#include <func.h>
48	#include <print.h>	48	#include <print.h>
49	#include <putchar.h>	49	#include <putchar.h>
50	#include <atomic.h>	50	#include <atomic.h>
51	#include <syscall/copy.h>	51	#include <syscall/copy.h>
52	#include <errno.h>	52	#include <errno.h>
53	#include <string.h>	53	#include <string.h>
54		54
55	#define KLOG_SIZE PAGE_SIZE	55	#define KLOG_PAGES 4
56	#define KLOG_LENGTH (KLOG_SIZE / sizeof(wchar_t))	56	#define KLOG_LENGTH (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
57	#define KLOG_LATENCY 8	57	#define KLOG_LATENCY 8
58		58
59	/** Kernel log cyclic buffer */	59	/** Kernel log cyclic buffer */
60	static wchar_t klog[KLOG_LENGTH] __attribute__ ((aligned (PAGE_SIZE)));	60	static wchar_t klog[KLOG_LENGTH] __attribute__ ((aligned (PAGE_SIZE)));
61		61
62	/** Kernel log initialized */	62	/** Kernel log initialized */
63	static bool klog_inited = false;	63	static bool klog_inited = false;
64	/** First kernel log characters */	64	/** First kernel log characters */
65	static index_t klog_start = 0;	65	static index_t klog_start = 0;
66	/** Number of valid kernel log characters */	66	/** Number of valid kernel log characters */
67	static size_t klog_len = 0;	67	static size_t klog_len = 0;
68	/** Number of stored (not printed) kernel log characters */	68	/** Number of stored (not printed) kernel log characters */
69	static size_t klog_stored = 0;	69	static size_t klog_stored = 0;
70	/** Number of stored kernel log characters for uspace */	70	/** Number of stored kernel log characters for uspace */
71	static size_t klog_uspace = 0;	71	static size_t klog_uspace = 0;
72		72
73	/** Silence output */	73	/** Silence output */
74	bool silent = false;	74	bool silent = false;
75		75
76	/** Kernel log spinlock */	76	/** Kernel log spinlock */
77	SPINLOCK_INITIALIZE(klog_lock);	77	SPINLOCK_INITIALIZE(klog_lock);
78		78
79	/** Physical memory area used for klog buffer */	79	/** Physical memory area used for klog buffer */
80	static parea_t klog_parea;	80	static parea_t klog_parea;
81		81
82	/** Standard input and output character devices */	82	/** Standard input and output character devices */
83	indev_t *stdin = NULL;	83	indev_t *stdin = NULL;
84	outdev_t *stdout = NULL;	84	outdev_t *stdout = NULL;
85		85
86	/** Initialize kernel logging facility	86	/** Initialize kernel logging facility
87	*	87	*
88	* The shared area contains kernel cyclic buffer. Userspace application may	88	* The shared area contains kernel cyclic buffer. Userspace application may
89	* be notified on new data with indication of position and size	89	* be notified on new data with indication of position and size
90	* of the data within the circular buffer.	90	* of the data within the circular buffer.
91	*	91	*
92	*/	92	*/
93	void klog_init(void)	93	void klog_init(void)
94	{	94	{
95	void faddr = (void ) KA2PA(klog);	95	void faddr = (void ) KA2PA(klog);
96		96
97	ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);	97	ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);
98	ASSERT(KLOG_SIZE % FRAME_SIZE == 0);	-
99		98
100	klog_parea.pbase = (uintptr_t) faddr;	99	klog_parea.pbase = (uintptr_t) faddr;
101	klog_parea.frames = SIZE2FRAMES(sizeof(klog));	100	klog_parea.frames = SIZE2FRAMES(sizeof(klog));
102	ddi_parea_register(&klog_parea);	101	ddi_parea_register(&klog_parea);
103		102
104	sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);	103	sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);
105	sysinfo_set_item_val("klog.pages", NULL, SIZE2FRAMES(sizeof(klog)));	104	sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
106		105
107	spinlock_lock(&klog_lock);	106	spinlock_lock(&klog_lock);
108	klog_inited = true;	107	klog_inited = true;
109	spinlock_unlock(&klog_lock);	108	spinlock_unlock(&klog_lock);
110	}	109	}
111		110
112	void grab_console(void)	111	void grab_console(void)
113	{	112	{
114	silent = false;	113	silent = false;
115	arch_grab_console();	114	arch_grab_console();
116	}	115	}
117		116
118	void release_console(void)	117	void release_console(void)
119	{	118	{
120	silent = true;	119	silent = true;
121	arch_release_console();	120	arch_release_console();
122	}	121	}
123		122
124	/** Tell kernel to get keyboard/console access again */	123	/** Tell kernel to get keyboard/console access again */
125	unative_t sys_debug_enable_console(void)	124	unative_t sys_debug_enable_console(void)
126	{	125	{
127	#ifdef CONFIG_KCONSOLE	126	#ifdef CONFIG_KCONSOLE
128	grab_console();	127	grab_console();
129	return true;	128	return true;
130	#else	129	#else
131	return false;	130	return false;
132	#endif	131	#endif
133	}	132	}
134		133
135	/** Tell kernel to relinquish keyboard/console access */	134	/** Tell kernel to relinquish keyboard/console access */
136	unative_t sys_debug_disable_console(void)	135	unative_t sys_debug_disable_console(void)
137	{	136	{
138	release_console();	137	release_console();
139	return true;	138	return true;
140	}	139	}
141		140
142	bool check_poll(indev_t *indev)	141	bool check_poll(indev_t *indev)
143	{	142	{
144	if (indev == NULL)	143	if (indev == NULL)
145	return false;	144	return false;
146		145
147	if (indev->op == NULL)	146	if (indev->op == NULL)
148	return false;	147	return false;
149		148
150	return (indev->op->poll != NULL);	149	return (indev->op->poll != NULL);
151	}	150	}
152		151
153	/** Get character from input character device. Do not echo character.	152	/** Get character from input character device. Do not echo character.
154	*	153	*
155	* @param indev Input character device.	154	* @param indev Input character device.
156	* @return Character read.	155	* @return Character read.
157	*	156	*
158	*/	157	*/
159	wchar_t _getc(indev_t *indev)	158	wchar_t _getc(indev_t *indev)
160	{	159	{
161	if (atomic_get(&haltstate)) {	160	if (atomic_get(&haltstate)) {
162	/* If we are here, we are hopefully on the processor that	161	/* If we are here, we are hopefully on the processor that
163	* issued the 'halt' command, so proceed to read the character	162	* issued the 'halt' command, so proceed to read the character
164	* directly from input	163	* directly from input
165	*/	164	*/
166	if (check_poll(indev))	165	if (check_poll(indev))
167	return indev->op->poll(indev);	166	return indev->op->poll(indev);
168		167
169	/* No other way of interacting with user */	168	/* No other way of interacting with user */
170	interrupts_disable();	169	interrupts_disable();
171		170
172	if (CPU)	171	if (CPU)
173	printf("cpu%u: ", CPU->id);	172	printf("cpu%u: ", CPU->id);
174	else	173	else
175	printf("cpu: ");	174	printf("cpu: ");
176	printf("halted (no polling input)\n");	175	printf("halted (no polling input)\n");
177	cpu_halt();	176	cpu_halt();
178	}	177	}
179		178
180	waitq_sleep(&indev->wq);	179	waitq_sleep(&indev->wq);
181	ipl_t ipl = interrupts_disable();	180	ipl_t ipl = interrupts_disable();
182	spinlock_lock(&indev->lock);	181	spinlock_lock(&indev->lock);
183	wchar_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];	182	wchar_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];
184	indev->counter--;	183	indev->counter--;
185	spinlock_unlock(&indev->lock);	184	spinlock_unlock(&indev->lock);
186	interrupts_restore(ipl);	185	interrupts_restore(ipl);
187		186
188	return ch;	187	return ch;
189	}	188	}
190		189
191	/** Get string from input character device.	190	/** Get string from input character device.
192	*	191	*
193	* Read characters from input character device until first occurrence	192	* Read characters from input character device until first occurrence
194	* of newline character.	193	* of newline character.
195	*	194	*
196	* @param indev Input character device.	195	* @param indev Input character device.
197	* @param buf Buffer where to store string terminated by NULL.	196	* @param buf Buffer where to store string terminated by NULL.
198	* @param buflen Size of the buffer.	197	* @param buflen Size of the buffer.
199	*	198	*
200	* @return Number of characters read.	199	* @return Number of characters read.
201	*	200	*
202	*/	201	*/
203	count_t gets(indev_t indev, char buf, size_t buflen)	202	count_t gets(indev_t indev, char buf, size_t buflen)
204	{	203	{
205	size_t offset = 0;	204	size_t offset = 0;
206	count_t count = 0;	205	count_t count = 0;
207	buf[offset] = 0;	206	buf[offset] = 0;
208		207
209	wchar_t ch;	208	wchar_t ch;
210	while ((ch = _getc(indev)) != '\n') {	209	while ((ch = _getc(indev)) != '\n') {
211	if (ch == '\b') {	210	if (ch == '\b') {
212	if (count > 0) {	211	if (count > 0) {
213	/* Space, backspace, space */	212	/* Space, backspace, space */
214	putchar('\b');	213	putchar('\b');
215	putchar(' ');	214	putchar(' ');
216	putchar('\b');	215	putchar('\b');
217		216
218	count--;	217	count--;
219	offset = str_lsize(buf, count);	218	offset = str_lsize(buf, count);
220	buf[offset] = 0;	219	buf[offset] = 0;
221	}	220	}
222	}	221	}
223	if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) {	222	if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) {
224	putchar(ch);	223	putchar(ch);
225	count++;	224	count++;
226	buf[offset] = 0;	225	buf[offset] = 0;
227	}	226	}
228	}	227	}
229		228
230	return count;	229	return count;
231	}	230	}
232		231
233	/** Get character from input device & echo it to screen */	232	/** Get character from input device & echo it to screen */
234	wchar_t getc(indev_t *indev)	233	wchar_t getc(indev_t *indev)
235	{	234	{
236	wchar_t ch = _getc(indev);	235	wchar_t ch = _getc(indev);
237	putchar(ch);	236	putchar(ch);
238	return ch;	237	return ch;
239	}	238	}
240		239
241	void klog_update(void)	240	void klog_update(void)
242	{	241	{
243	spinlock_lock(&klog_lock);	242	spinlock_lock(&klog_lock);
244		243
245	if ((klog_inited) && (event_is_subscribed(EVENT_KLOG)) && (klog_uspace > 0)) {	244	if ((klog_inited) && (event_is_subscribed(EVENT_KLOG)) && (klog_uspace > 0)) {
246	event_notify_3(EVENT_KLOG, klog_start, klog_len, klog_uspace);	245	event_notify_3(EVENT_KLOG, klog_start, klog_len, klog_uspace);
247	klog_uspace = 0;	246	klog_uspace = 0;
248	}	247	}
249		248
250	spinlock_unlock(&klog_lock);	249	spinlock_unlock(&klog_lock);
251	}	250	}
252		251
253	void putchar(const wchar_t ch)	252	void putchar(const wchar_t ch)
254	{	253	{
255	spinlock_lock(&klog_lock);	254	spinlock_lock(&klog_lock);
256		255
257	if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {	256	if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {
258	/* Print charaters stored in kernel log */	257	/* Print charaters stored in kernel log */
259	index_t i;	258	index_t i;
260	for (i = klog_len - klog_stored; i < klog_len; i++)	259	for (i = klog_len - klog_stored; i < klog_len; i++)
261	stdout->op->write(stdout, klog[(klog_start + i) % KLOG_LENGTH], silent);	260	stdout->op->write(stdout, klog[(klog_start + i) % KLOG_LENGTH], silent);
262	klog_stored = 0;	261	klog_stored = 0;
263	}	262	}
264		263
265	/* Store character in the cyclic kernel log */	264	/* Store character in the cyclic kernel log */
266	klog[(klog_start + klog_len) % KLOG_LENGTH] = ch;	265	klog[(klog_start + klog_len) % KLOG_LENGTH] = ch;
267	if (klog_len < KLOG_LENGTH)	266	if (klog_len < KLOG_LENGTH)
268	klog_len++;	267	klog_len++;
269	else	268	else
270	klog_start = (klog_start + 1) % KLOG_LENGTH;	269	klog_start = (klog_start + 1) % KLOG_LENGTH;
271		270
272	if ((stdout) && (stdout->op->write))	271	if ((stdout) && (stdout->op->write))
273	stdout->op->write(stdout, ch, silent);	272	stdout->op->write(stdout, ch, silent);
274	else {	273	else {
275	/* The character is just in the kernel log */	274	/* The character is just in the kernel log */
276	if (klog_stored < klog_len)	275	if (klog_stored < klog_len)
277	klog_stored++;	276	klog_stored++;
278	}	277	}
279		278
280	/* The character is stored for uspace */	279	/* The character is stored for uspace */
281	if (klog_uspace < klog_len)	280	if (klog_uspace < klog_len)
282	klog_uspace++;	281	klog_uspace++;
283		282
284	/* Check notify uspace to update */	283	/* Check notify uspace to update */
285	bool update;	284	bool update;
286	if ((klog_uspace > KLOG_LATENCY) \|\| (ch == '\n'))	285	if ((klog_uspace > KLOG_LATENCY) \|\| (ch == '\n'))
287	update = true;	286	update = true;
288	else	287	else
289	update = false;	288	update = false;
290		289
291	spinlock_unlock(&klog_lock);	290	spinlock_unlock(&klog_lock);
292		291
293	if (update)	292	if (update)
294	klog_update();	293	klog_update();
295	}	294	}
296		295
297	/** Print using kernel facility	296	/** Print using kernel facility
298	*	297	*
299	* Print to kernel log.	298	* Print to kernel log.
300	*	299	*
301	*/	300	*/
302	unative_t sys_klog(int fd, const void *buf, size_t size)	301	unative_t sys_klog(int fd, const void *buf, size_t size)
303	{	302	{
304	char *data;	303	char *data;
305	int rc;	304	int rc;
306		305
307	if (size > PAGE_SIZE)	306	if (size > PAGE_SIZE)
308	return ELIMIT;	307	return ELIMIT;
309		308
310	if (size > 0) {	309	if (size > 0) {
311	data = (char *) malloc(size + 1, 0);	310	data = (char *) malloc(size + 1, 0);
312	if (!data)	311	if (!data)
313	return ENOMEM;	312	return ENOMEM;
314		313
315	rc = copy_from_uspace(data, buf, size);	314	rc = copy_from_uspace(data, buf, size);
316	if (rc) {	315	if (rc) {
317	free(data);	316	free(data);
318	return rc;	317	return rc;
319	}	318	}
320	data[size] = 0;	319	data[size] = 0;
321		320
322	printf("%s", data);	321	printf("%s", data);
323	free(data);	322	free(data);
324	} else	323	} else
325	klog_update();	324	klog_update();
326		325
327	return size;	326	return size;
328	}	327	}
329		328
330	/** @}	329	/** @}
331	*/	330	*/
332		331

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/console/console.c – Rev 4226 → 4252