int kprintf(const char *format, ...) { va_list ap; va_start(ap, format); int size = kvsprintf(buffer, format, ap); return console_write(buffer, size); }
/** * @brief Writes a message to the kernel's output device and panics the kernel. * * @param fmt Formatted message to be written onto kernel's output device. */ PUBLIC void kpanic(const char *fmt, ...) { int i; /* Loop index. */ va_list args; /* Variable arguments list. */ char buffer[KBUFFER_SIZE + 1]; /* Temporary buffer. */ kstrncpy(buffer, "PANIC: ", 7); /* Convert to raw string. */ va_start(args, fmt); i = kvsprintf(buffer + 7, fmt, args) + 7; buffer[i++] = '\n'; va_end(args); /* Save on kernel log and write on kout. */ cdev_write(kout, buffer, i); klog_write(buffer, i); /* * Disable interrupts, so we cannot * be bothered. */ disable_interrupts(); while(1); halt(); }
int ksprintf(char *buf, const char *format, ...) { va_list ap; va_start(ap, format); int len = kvsprintf(buf, format, ap); buf[len] = 0; return len; }
int console_printf(const char * fmt, ...) { char buf[256]; va_list vlp; size_t r; va_start(vlp, fmt); if( (r = kvsprintf(buf, fmt, vlp)) >= sizeof(buf) ) console_write_block("ERROR: vsprintf - insufficient buffer size!\r\n", 46); //console_write_block(buf, r); return r; }
int kprintf(const char *format, ...) { va_list ap; va_start(ap, format); int size = kvsprintf(buffer, format, ap); HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); WriteFile(handle, buffer, size, NULL, NULL); FlushFileBuffers(handle); return size; }
int ksprintf(char *buffer, const char *format, ...) { int done; va_list args; va_start(args, format); done = kvsprintf(buffer, format, args); va_end(args); return done; }
int ksprintf(char *str, const char *format, ...) { va_list args; int i; va_start(args, format); i = kvsprintf(str, format, args); va_end(args); return i; }
int ksprintf(char *str, const char *fmt, ...) { int ret; va_list ap; va_start(ap, fmt); ret = kvsprintf(str, fmt, ap); va_end(ap); return ret; }
void log_raw_internal(const char *format, ...) { va_list ap; va_start(ap, format); int size = kvsprintf(buffer, format, ap); DWORD bytes_written; if (!WriteFile(hLoggerPipe, buffer, size, &bytes_written, NULL)) { CloseHandle(hLoggerPipe); logger_attached = 0; } }
int kprintf(const char *format, ...) { va_list args; int i; va_start(args, format); i = kvsprintf(_buf, format, args); va_end(args); console_puts(_buf); return i; }
static void log_internal(char type, const char *format, va_list ap) { buffer[0] = '('; buffer[1] = type; buffer[2] = type; buffer[3] = ')'; buffer[4] = ' '; int size = 5 + kvsprintf(buffer + 5, format, ap); DWORD bytes_written; if (!WriteFile(hLoggerPipe, buffer, size, &bytes_written, NULL)) { CloseHandle(hLoggerPipe); logger_attached = 0; } }
int kprintf_unlocked(const char *fmt, ...) { /* yes yes, a possible buffer overflow.. I know. * I'm to lazy to do something about it, atm */ char buf[1024]; va_list ap; int ret; va_start(ap, fmt); ret = kvsprintf(buf, fmt, ap); va_end(ap); kputs_unlocked(buf); return ret; }
static void log_internal(int type, char typech, const char *format, va_list ap) { struct packet *packet = (struct packet*)buffer; packet->type = type; SYSTEMTIME ts; GetSystemTime(&ts); /* TODO: Use GetSystemTimePreciseAsFileTime for Win8 */ packet->len = ksprintf(packet->text, "[%02u:%02u:%02u.%03u] (%c%c) ", ts.wHour, ts.wMinute, ts.wSecond, ts.wMilliseconds, typech, typech); packet->len += kvsprintf(packet->text + packet->len, format, ap); packet->packet_size = sizeof(struct packet) + packet->len; DWORD bytes_written; if (!WriteFile(hLoggerPipe, buffer, packet->packet_size, &bytes_written, NULL)) { CloseHandle(hLoggerPipe); logger_attached = 0; } }
/** * @brief Writes on the screen a formated string. * * @param fmt Formated string. */ PUBLIC void kprintf(const char *fmt, ...) { int i; /* Loop index. */ va_list args; /* Variable arguments list. */ char buffer[KBUFFER_SIZE + 1]; /* Temporary buffer. */ const char *buffer_no_code; /* Temporary buffer for log level printing. */ /* Convert to raw string. */ va_start(args, fmt); i = kvsprintf(buffer, fmt, args); buffer[i++] = '\n'; va_end(args); /* Save on kernel log, skip code in case it's not correctly done and write on kout. */ klog_write(0, buffer, i); buffer_no_code = skip_code(buffer, &i); cdev_write(kout, buffer_no_code, i); }