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 <event/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_SIZE     PAGE_SIZE
#define KLOG_LENGTH   (KLOG_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);
    ASSERT(KLOG_SIZE % 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, SIZE2FRAMES(sizeof(klog)));
   
    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 4218	Rev 4226
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 <event/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_SIZE PAGE_SIZE
-		56	#define KLOG_LENGTH (KLOG_SIZE / sizeof(wchar_t))
56	#define KLOG_LATENCY 8	57	#define KLOG_LATENCY 8
57		58
58	/** Kernel log cyclic buffer */	59	/** Kernel log cyclic buffer */
59	static wchar_t klog[KLOG_SIZE] __attribute__ ((aligned (PAGE_SIZE)));	60	static wchar_t klog[KLOG_LENGTH] __attribute__ ((aligned (PAGE_SIZE)));
60		61
61	/** Kernel log initialized */	62	/** Kernel log initialized */
62	static bool klog_inited = false;	63	static bool klog_inited = false;
63	/** First kernel log characters */	64	/** First kernel log characters */
64	static index_t klog_start = 0;	65	static index_t klog_start = 0;
65	/** Number of valid kernel log characters */	66	/** Number of valid kernel log characters */
66	static size_t klog_len = 0;	67	static size_t klog_len = 0;
67	/** Number of stored (not printed) kernel log characters */	68	/** Number of stored (not printed) kernel log characters */
68	static size_t klog_stored = 0;	69	static size_t klog_stored = 0;
69	/** Number of stored kernel log characters for uspace */	70	/** Number of stored kernel log characters for uspace */
70	static size_t klog_uspace = 0;	71	static size_t klog_uspace = 0;
71		72
72	/** Silence output */	73	/** Silence output */
73	bool silent = false;	74	bool silent = false;
74		75
75	/** Kernel log spinlock */	76	/** Kernel log spinlock */
76	SPINLOCK_INITIALIZE(klog_lock);	77	SPINLOCK_INITIALIZE(klog_lock);
77		78
78	/** Physical memory area used for klog buffer */	79	/** Physical memory area used for klog buffer */
79	static parea_t klog_parea;	80	static parea_t klog_parea;
80		81
81	/** Standard input and output character devices */	82	/** Standard input and output character devices */
82	indev_t *stdin = NULL;	83	indev_t *stdin = NULL;
83	outdev_t *stdout = NULL;	84	outdev_t *stdout = NULL;
84		85
85	/** Initialize kernel logging facility	86	/** Initialize kernel logging facility
86	*	87	*
87	* The shared area contains kernel cyclic buffer. Userspace application may	88	* The shared area contains kernel cyclic buffer. Userspace application may
88	* be notified on new data with indication of position and size	89	* be notified on new data with indication of position and size
89	* of the data within the circular buffer.	90	* of the data within the circular buffer.
90	*	91	*
91	*/	92	*/
92	void klog_init(void)	93	void klog_init(void)
93	{	94	{
94	void faddr = (void ) KA2PA(klog);	95	void faddr = (void ) KA2PA(klog);
95		96
96	ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);	97	ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);
97	ASSERT(KLOG_SIZE % FRAME_SIZE == 0);	98	ASSERT(KLOG_SIZE % FRAME_SIZE == 0);
98		99
99	klog_parea.pbase = (uintptr_t) faddr;	100	klog_parea.pbase = (uintptr_t) faddr;
100	klog_parea.frames = SIZE2FRAMES(sizeof(klog));	101	klog_parea.frames = SIZE2FRAMES(sizeof(klog));
101	ddi_parea_register(&klog_parea);	102	ddi_parea_register(&klog_parea);
102		103
103	sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);	104	sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);
104	sysinfo_set_item_val("klog.pages", NULL, SIZE2FRAMES(sizeof(klog)));	105	sysinfo_set_item_val("klog.pages", NULL, SIZE2FRAMES(sizeof(klog)));
105		106
106	spinlock_lock(&klog_lock);	107	spinlock_lock(&klog_lock);
107	klog_inited = true;	108	klog_inited = true;
108	spinlock_unlock(&klog_lock);	109	spinlock_unlock(&klog_lock);
109	}	110	}
110		111
111	void grab_console(void)	112	void grab_console(void)
112	{	113	{
113	silent = false;	114	silent = false;
114	arch_grab_console();	115	arch_grab_console();
115	}	116	}
116		117
117	void release_console(void)	118	void release_console(void)
118	{	119	{
119	silent = true;	120	silent = true;
120	arch_release_console();	121	arch_release_console();
121	}	122	}
122		123
123	/** Tell kernel to get keyboard/console access again */	124	/** Tell kernel to get keyboard/console access again */
124	unative_t sys_debug_enable_console(void)	125	unative_t sys_debug_enable_console(void)
125	{	126	{
126	#ifdef CONFIG_KCONSOLE	127	#ifdef CONFIG_KCONSOLE
127	grab_console();	128	grab_console();
128	return true;	129	return true;
129	#else	130	#else
130	return false;	131	return false;
131	#endif	132	#endif
132	}	133	}
133		134
134	/** Tell kernel to relinquish keyboard/console access */	135	/** Tell kernel to relinquish keyboard/console access */
135	unative_t sys_debug_disable_console(void)	136	unative_t sys_debug_disable_console(void)
136	{	137	{
137	release_console();	138	release_console();
138	return true;	139	return true;
139	}	140	}
140		141
141	bool check_poll(indev_t *indev)	142	bool check_poll(indev_t *indev)
142	{	143	{
143	if (indev == NULL)	144	if (indev == NULL)
144	return false;	145	return false;
145		146
146	if (indev->op == NULL)	147	if (indev->op == NULL)
147	return false;	148	return false;
148		149
149	return (indev->op->poll != NULL);	150	return (indev->op->poll != NULL);
150	}	151	}
151		152
152	/** Get character from input character device. Do not echo character.	153	/** Get character from input character device. Do not echo character.
153	*	154	*
154	* @param indev Input character device.	155	* @param indev Input character device.
155	* @return Character read.	156	* @return Character read.
156	*	157	*
157	*/	158	*/
158	wchar_t _getc(indev_t *indev)	159	wchar_t _getc(indev_t *indev)
159	{	160	{
160	if (atomic_get(&haltstate)) {	161	if (atomic_get(&haltstate)) {
161	/* If we are here, we are hopefully on the processor that	162	/* If we are here, we are hopefully on the processor that
162	* issued the 'halt' command, so proceed to read the character	163	* issued the 'halt' command, so proceed to read the character
163	* directly from input	164	* directly from input
164	*/	165	*/
165	if (check_poll(indev))	166	if (check_poll(indev))
166	return indev->op->poll(indev);	167	return indev->op->poll(indev);
167		168
168	/* No other way of interacting with user */	169	/* No other way of interacting with user */
169	interrupts_disable();	170	interrupts_disable();
170		171
171	if (CPU)	172	if (CPU)
172	printf("cpu%u: ", CPU->id);	173	printf("cpu%u: ", CPU->id);
173	else	174	else
174	printf("cpu: ");	175	printf("cpu: ");
175	printf("halted (no polling input)\n");	176	printf("halted (no polling input)\n");
176	cpu_halt();	177	cpu_halt();
177	}	178	}
178		179
179	waitq_sleep(&indev->wq);	180	waitq_sleep(&indev->wq);
180	ipl_t ipl = interrupts_disable();	181	ipl_t ipl = interrupts_disable();
181	spinlock_lock(&indev->lock);	182	spinlock_lock(&indev->lock);
182	wchar_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];	183	wchar_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];
183	indev->counter--;	184	indev->counter--;
184	spinlock_unlock(&indev->lock);	185	spinlock_unlock(&indev->lock);
185	interrupts_restore(ipl);	186	interrupts_restore(ipl);
186		187
187	return ch;	188	return ch;
188	}	189	}
189		190
190	/** Get string from input character device.	191	/** Get string from input character device.
191	*	192	*
192	* Read characters from input character device until first occurrence	193	* Read characters from input character device until first occurrence
193	* of newline character.	194	* of newline character.
194	*	195	*
195	* @param indev Input character device.	196	* @param indev Input character device.
196	* @param buf Buffer where to store string terminated by NULL.	197	* @param buf Buffer where to store string terminated by NULL.
197	* @param buflen Size of the buffer.	198	* @param buflen Size of the buffer.
198	*	199	*
199	* @return Number of characters read.	200	* @return Number of characters read.
200	*	201	*
201	*/	202	*/
202	count_t gets(indev_t indev, char buf, size_t buflen)	203	count_t gets(indev_t indev, char buf, size_t buflen)
203	{	204	{
204	size_t offset = 0;	205	size_t offset = 0;
205	count_t count = 0;	206	count_t count = 0;
206	buf[offset] = 0;	207	buf[offset] = 0;
207		208
208	wchar_t ch;	209	wchar_t ch;
209	while ((ch = _getc(indev)) != '\n') {	210	while ((ch = _getc(indev)) != '\n') {
210	if (ch == '\b') {	211	if (ch == '\b') {
211	if (count > 0) {	212	if (count > 0) {
212	/* Space, backspace, space */	213	/* Space, backspace, space */
213	putchar('\b');	214	putchar('\b');
214	putchar(' ');	215	putchar(' ');
215	putchar('\b');	216	putchar('\b');
216		217
217	count--;	218	count--;
218	offset = str_lsize(buf, count);	219	offset = str_lsize(buf, count);
219	buf[offset] = 0;	220	buf[offset] = 0;
220	}	221	}
221	}	222	}
222	if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) {	223	if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) {
223	putchar(ch);	224	putchar(ch);
224	count++;	225	count++;
225	buf[offset] = 0;	226	buf[offset] = 0;
226	}	227	}
227	}	228	}
228		229
229	return count;	230	return count;
230	}	231	}
231		232
232	/** Get character from input device & echo it to screen */	233	/** Get character from input device & echo it to screen */
233	wchar_t getc(indev_t *indev)	234	wchar_t getc(indev_t *indev)
234	{	235	{
235	wchar_t ch = _getc(indev);	236	wchar_t ch = _getc(indev);
236	putchar(ch);	237	putchar(ch);
237	return ch;	238	return ch;
238	}	239	}
239		240
240	void klog_update(void)	241	void klog_update(void)
241	{	242	{
242	spinlock_lock(&klog_lock);	243	spinlock_lock(&klog_lock);
243		244
244	if ((klog_inited) && (event_is_subscribed(EVENT_KLOG)) && (klog_uspace > 0)) {	245	if ((klog_inited) && (event_is_subscribed(EVENT_KLOG)) && (klog_uspace > 0)) {
245	event_notify_3(EVENT_KLOG, klog_start, klog_len, klog_uspace);	246	event_notify_3(EVENT_KLOG, klog_start, klog_len, klog_uspace);
246	klog_uspace = 0;	247	klog_uspace = 0;
247	}	248	}
248		249
249	spinlock_unlock(&klog_lock);	250	spinlock_unlock(&klog_lock);
250	}	251	}
251		252
252	void putchar(const wchar_t ch)	253	void putchar(const wchar_t ch)
253	{	254	{
254	spinlock_lock(&klog_lock);	255	spinlock_lock(&klog_lock);
255		256
256	if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {	257	if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {
257	/* Print charaters stored in kernel log */	258	/* Print charaters stored in kernel log */
258	index_t i;	259	index_t i;
259	for (i = klog_len - klog_stored; i < klog_len; i++)	260	for (i = klog_len - klog_stored; i < klog_len; i++)
260	stdout->op->write(stdout, klog[(klog_start + i) % KLOG_SIZE], silent);	261	stdout->op->write(stdout, klog[(klog_start + i) % KLOG_LENGTH], silent);
261	klog_stored = 0;	262	klog_stored = 0;
262	}	263	}
263		264
264	/* Store character in the cyclic kernel log */	265	/* Store character in the cyclic kernel log */
265	klog[(klog_start + klog_len) % KLOG_SIZE] = ch;	266	klog[(klog_start + klog_len) % KLOG_LENGTH] = ch;
266	if (klog_len < KLOG_SIZE)	267	if (klog_len < KLOG_LENGTH)
267	klog_len++;	268	klog_len++;
268	else	269	else
269	klog_start = (klog_start + 1) % KLOG_SIZE;	270	klog_start = (klog_start + 1) % KLOG_LENGTH;
270		271
271	if ((stdout) && (stdout->op->write))	272	if ((stdout) && (stdout->op->write))
272	stdout->op->write(stdout, ch, silent);	273	stdout->op->write(stdout, ch, silent);
273	else {	274	else {
274	/* The character is just in the kernel log */	275	/* The character is just in the kernel log */
275	if (klog_stored < klog_len)	276	if (klog_stored < klog_len)
276	klog_stored++;	277	klog_stored++;
277	}	278	}
278		279
279	/* The character is stored for uspace */	280	/* The character is stored for uspace */
280	if (klog_uspace < klog_len)	281	if (klog_uspace < klog_len)
281	klog_uspace++;	282	klog_uspace++;
282		283
283	/* Check notify uspace to update */	284	/* Check notify uspace to update */
284	bool update;	285	bool update;
285	if ((klog_uspace > KLOG_LATENCY) \|\| (ch == '\n'))	286	if ((klog_uspace > KLOG_LATENCY) \|\| (ch == '\n'))
286	update = true;	287	update = true;
287	else	288	else
288	update = false;	289	update = false;
289		290
290	spinlock_unlock(&klog_lock);	291	spinlock_unlock(&klog_lock);
291		292
292	if (update)	293	if (update)
293	klog_update();	294	klog_update();
294	}	295	}
295		296
296	/** Print using kernel facility	297	/** Print using kernel facility
297	*	298	*
298	* Print to kernel log.	299	* Print to kernel log.
299	*	300	*
300	*/	301	*/
301	unative_t sys_klog(int fd, const void *buf, size_t size)	302	unative_t sys_klog(int fd, const void *buf, size_t size)
302	{	303	{
303	char *data;	304	char *data;
304	int rc;	305	int rc;
305		306
306	if (size > PAGE_SIZE)	307	if (size > PAGE_SIZE)
307	return ELIMIT;	308	return ELIMIT;
308		309
309	if (size > 0) {	310	if (size > 0) {
310	data = (char *) malloc(size + 1, 0);	311	data = (char *) malloc(size + 1, 0);
311	if (!data)	312	if (!data)
312	return ENOMEM;	313	return ENOMEM;
313		314
314	rc = copy_from_uspace(data, buf, size);	315	rc = copy_from_uspace(data, buf, size);
315	if (rc) {	316	if (rc) {
316	free(data);	317	free(data);
317	return rc;	318	return rc;
318	}	319	}
319	data[size] = 0;	320	data[size] = 0;
320		321
321	printf("%s", data);	322	printf("%s", data);
322	free(data);	323	free(data);
323	} else	324	} else
324	klog_update();	325	klog_update();
325		326
326	return size;	327	return size;
327	}	328	}
328		329
329	/** @}	330	/** @}
330	*/	331	*/
331		332

Subversion Repositories HelenOS

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