Subversion Repositories HelenOS

Rev

Rev 4087 | Rev 4173 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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