Changes in kernel/generic/src/console/console.c [11527051:6afc9d7] in mainline
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/src/console/console.c
r11527051 r6afc9d7 52 52 #include <errno.h> 53 53 #include <str.h> 54 #include <abi/klog.h> 55 56 #define KLOG_PAGES 8 57 #define KLOG_LENGTH (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t)) 54 #include <abi/kio.h> 55 #include <mm/frame.h> /* SIZE2FRAMES */ 56 #include <mm/slab.h> /* malloc */ 57 58 #define KIO_PAGES 8 59 #define KIO_LENGTH (KIO_PAGES * PAGE_SIZE / sizeof(wchar_t)) 58 60 59 61 /** Kernel log cyclic buffer */ 60 wchar_t k log[KLOG_LENGTH] __attribute__((aligned(PAGE_SIZE)));62 wchar_t kio[KIO_LENGTH] __attribute__((aligned(PAGE_SIZE))); 61 63 62 64 /** Kernel log initialized */ 63 static atomic_t k log_inited = {false};65 static atomic_t kio_inited = {false}; 64 66 65 67 /** First kernel log characters */ 66 static size_t k log_start = 0;68 static size_t kio_start = 0; 67 69 68 70 /** Number of valid kernel log characters */ 69 static size_t k log_len = 0;71 static size_t kio_len = 0; 70 72 71 73 /** Number of stored (not printed) kernel log characters */ 72 static size_t k log_stored = 0;74 static size_t kio_stored = 0; 73 75 74 76 /** Number of stored kernel log characters for uspace */ 75 static size_t k log_uspace = 0;77 static size_t kio_uspace = 0; 76 78 77 79 /** Kernel log spinlock */ 78 SPINLOCK_ STATIC_INITIALIZE_NAME(klog_lock, "klog_lock");79 80 /** Physical memory area used for k logbuffer */81 static parea_t k log_parea;80 SPINLOCK_INITIALIZE_NAME(kio_lock, "kio_lock"); 81 82 /** Physical memory area used for kio buffer */ 83 static parea_t kio_parea; 82 84 83 85 static indev_t stdin_sink; 84 86 static outdev_t stdout_source; 85 87 88 static void stdin_signal(indev_t *, indev_signal_t); 89 86 90 static indev_operations_t stdin_ops = { 87 .poll = NULL 91 .poll = NULL, 92 .signal = stdin_signal 88 93 }; 89 94 90 95 static void stdout_write(outdev_t *, wchar_t); 91 96 static void stdout_redraw(outdev_t *); 97 static void stdout_scroll_up(outdev_t *); 98 static void stdout_scroll_down(outdev_t *); 92 99 93 100 static outdev_operations_t stdout_ops = { 94 101 .write = stdout_write, 95 .redraw = stdout_redraw 102 .redraw = stdout_redraw, 103 .scroll_up = stdout_scroll_up, 104 .scroll_down = stdout_scroll_down 96 105 }; 97 106 … … 113 122 } 114 123 124 static void stdin_signal(indev_t *indev, indev_signal_t signal) 125 { 126 switch (signal) { 127 case INDEV_SIGNAL_SCROLL_UP: 128 if (stdout != NULL) 129 stdout_scroll_up(stdout); 130 break; 131 case INDEV_SIGNAL_SCROLL_DOWN: 132 if (stdout != NULL) 133 stdout_scroll_down(stdout); 134 break; 135 } 136 } 137 115 138 void stdout_wire(outdev_t *outdev) 116 139 { … … 125 148 static void stdout_write(outdev_t *dev, wchar_t ch) 126 149 { 127 list_foreach(dev->list, cur) { 128 outdev_t *sink = list_get_instance(cur, outdev_t, link); 150 list_foreach(dev->list, link, outdev_t, sink) { 129 151 if ((sink) && (sink->op->write)) 130 152 sink->op->write(sink, ch); … … 134 156 static void stdout_redraw(outdev_t *dev) 135 157 { 136 list_foreach(dev->list, cur) { 137 outdev_t *sink = list_get_instance(cur, outdev_t, link); 158 list_foreach(dev->list, link, outdev_t, sink) { 138 159 if ((sink) && (sink->op->redraw)) 139 160 sink->op->redraw(sink); 161 } 162 } 163 164 static void stdout_scroll_up(outdev_t *dev) 165 { 166 list_foreach(dev->list, link, outdev_t, sink) { 167 if ((sink) && (sink->op->scroll_up)) 168 sink->op->scroll_up(sink); 169 } 170 } 171 172 static void stdout_scroll_down(outdev_t *dev) 173 { 174 list_foreach(dev->list, link, outdev_t, sink) { 175 if ((sink) && (sink->op->scroll_down)) 176 sink->op->scroll_down(sink); 140 177 } 141 178 } … … 148 185 * 149 186 */ 150 void k log_init(void)151 { 152 void *faddr = (void *) KA2PA(k log);187 void kio_init(void) 188 { 189 void *faddr = (void *) KA2PA(kio); 153 190 154 191 ASSERT((uintptr_t) faddr % FRAME_SIZE == 0); 155 192 156 k log_parea.pbase = (uintptr_t) faddr;157 k log_parea.frames = SIZE2FRAMES(sizeof(klog));158 k log_parea.unpriv = false;159 k log_parea.mapped = false;160 ddi_parea_register(&k log_parea);161 162 sysinfo_set_item_val("k log.faddr", NULL, (sysarg_t) faddr);163 sysinfo_set_item_val("k log.pages", NULL, KLOG_PAGES);164 165 event_set_unmask_callback(EVENT_K LOG, klog_update);166 atomic_set(&k log_inited, true);193 kio_parea.pbase = (uintptr_t) faddr; 194 kio_parea.frames = SIZE2FRAMES(sizeof(kio)); 195 kio_parea.unpriv = false; 196 kio_parea.mapped = false; 197 ddi_parea_register(&kio_parea); 198 199 sysinfo_set_item_val("kio.faddr", NULL, (sysarg_t) faddr); 200 sysinfo_set_item_val("kio.pages", NULL, KIO_PAGES); 201 202 event_set_unmask_callback(EVENT_KIO, kio_update); 203 atomic_set(&kio_inited, true); 167 204 } 168 205 169 206 void grab_console(void) 170 207 { 208 event_notify_1(EVENT_KCONSOLE, false, true); 171 209 bool prev = console_override; 172 210 … … 186 224 { 187 225 console_override = false; 226 event_notify_1(EVENT_KCONSOLE, false, false); 188 227 } 189 228 190 229 /** Activate kernel console override */ 191 sysarg_t sys_debug_ activate_console(void)230 sysarg_t sys_debug_console(void) 192 231 { 193 232 #ifdef CONFIG_KCONSOLE … … 231 270 } 232 271 } 272 233 273 if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) { 234 274 putchar(ch); … … 249 289 } 250 290 251 void k log_update(void *event)252 { 253 if (!atomic_get(&k log_inited))291 void kio_update(void *event) 292 { 293 if (!atomic_get(&kio_inited)) 254 294 return; 255 295 256 spinlock_lock(&klog_lock); 257 258 if (klog_uspace > 0) { 259 if (event_notify_3(EVENT_KLOG, true, klog_start, klog_len, 260 klog_uspace) == EOK) 261 klog_uspace = 0; 262 } 263 264 spinlock_unlock(&klog_lock); 296 spinlock_lock(&kio_lock); 297 298 if (kio_uspace > 0) { 299 if (event_notify_3(EVENT_KIO, true, kio_start, kio_len, 300 kio_uspace) == EOK) 301 kio_uspace = 0; 302 } 303 304 spinlock_unlock(&kio_lock); 305 } 306 307 /** Flush characters that are stored in the output buffer 308 * 309 */ 310 void kio_flush(void) 311 { 312 bool ordy = ((stdout) && (stdout->op->write)); 313 314 if (!ordy) 315 return; 316 317 spinlock_lock(&kio_lock); 318 319 /* Print characters that weren't printed earlier */ 320 while (kio_stored > 0) { 321 wchar_t tmp = kio[(kio_start + kio_len - kio_stored) % KIO_LENGTH]; 322 kio_stored--; 323 324 /* 325 * We need to give up the spinlock for 326 * the physical operation of writing out 327 * the character. 328 */ 329 spinlock_unlock(&kio_lock); 330 stdout->op->write(stdout, tmp); 331 spinlock_lock(&kio_lock); 332 } 333 334 spinlock_unlock(&kio_lock); 335 } 336 337 /** Put a character into the output buffer. 338 * 339 * The caller is required to hold kio_lock 340 */ 341 void kio_push_char(const wchar_t ch) 342 { 343 kio[(kio_start + kio_len) % KIO_LENGTH] = ch; 344 if (kio_len < KIO_LENGTH) 345 kio_len++; 346 else 347 kio_start = (kio_start + 1) % KIO_LENGTH; 348 349 if (kio_stored < kio_len) 350 kio_stored++; 351 352 /* The character is stored for uspace */ 353 if (kio_uspace < kio_len) 354 kio_uspace++; 265 355 } 266 356 … … 269 359 bool ordy = ((stdout) && (stdout->op->write)); 270 360 271 spinlock_lock(&klog_lock); 272 273 /* Print charaters stored in kernel log */ 274 if (ordy) { 275 while (klog_stored > 0) { 276 wchar_t tmp = klog[(klog_start + klog_len - klog_stored) % KLOG_LENGTH]; 277 klog_stored--; 278 279 /* 280 * We need to give up the spinlock for 281 * the physical operation of writting out 282 * the character. 283 */ 284 spinlock_unlock(&klog_lock); 285 stdout->op->write(stdout, tmp); 286 spinlock_lock(&klog_lock); 287 } 288 } 289 290 /* Store character in the cyclic kernel log */ 291 klog[(klog_start + klog_len) % KLOG_LENGTH] = ch; 292 if (klog_len < KLOG_LENGTH) 293 klog_len++; 294 else 295 klog_start = (klog_start + 1) % KLOG_LENGTH; 361 spinlock_lock(&kio_lock); 362 kio_push_char(ch); 363 spinlock_unlock(&kio_lock); 364 365 /* Output stored characters */ 366 kio_flush(); 296 367 297 368 if (!ordy) { 298 if (klog_stored < klog_len)299 klog_stored++;300 }301 302 /* The character is stored for uspace */303 if (klog_uspace < klog_len)304 klog_uspace++;305 306 spinlock_unlock(&klog_lock);307 308 if (ordy) {309 /*310 * Output the character. In this case311 * it should be no longer buffered.312 */313 stdout->op->write(stdout, ch);314 } else {315 369 /* 316 370 * No standard output routine defined yet. … … 328 382 /* Force notification on newline */ 329 383 if (ch == '\n') 330 k log_update(NULL);384 kio_update(NULL); 331 385 } 332 386 … … 336 390 * 337 391 */ 338 sysarg_t sys_k log(int cmd, const void *buf, size_t size)392 sysarg_t sys_kio(int cmd, const void *buf, size_t size) 339 393 { 340 394 char *data; … … 342 396 343 397 switch (cmd) { 344 case K LOG_UPDATE:345 k log_update(NULL);398 case KIO_UPDATE: 399 kio_update(NULL); 346 400 return EOK; 347 case K LOG_WRITE:348 case K LOG_COMMAND:401 case KIO_WRITE: 402 case KIO_COMMAND: 349 403 break; 350 404 default: … … 368 422 369 423 switch (cmd) { 370 case K LOG_WRITE:424 case KIO_WRITE: 371 425 printf("%s", data); 372 426 break; 373 case K LOG_COMMAND:427 case KIO_COMMAND: 374 428 if (!stdin) 375 429 break; … … 383 437 } 384 438 385 return size;439 return EOK; 386 440 } 387 441
Note:
See TracChangeset
for help on using the changeset viewer.