/* Dump the log buffer. */ void knllog_dump(void) { char banner[320]; char *bannerp = banner; int i, start, entries; knllog.lasttime = 0; if (knllog.bufp == NULL) { printk(KERN_ERR "Error: No log buffer allocated\n"); return; } if (!knllog.wrap) { start = 0; entries = knllog.idx; } else { start = knllog.idx; entries = knllog.entries; } getBanner(&bannerp, sizeof(banner), entries); printk(bannerp); for (i = 0; i < entries; i++) { char line[160]; char *linep = line; KNLLOG_ENTRY *ep = &knllog.bufp[start++]; decodeEvent(ep, &linep, sizeof(line), i); /* Print the event */ printk(linep); if (start >= knllog.entries) { start = 0; } knllog.lasttime = ep->time; } printk(KERN_NOTICE "Kernel Log Dump End...\n"); }
void writestart(struct config *cfg) { FILE *out; char line[256], *banner; struct classinfo *cl; snprintf(line, 255, "%s/%s_start.c", cfg->gendir, cfg->modulename); out = fopen(line, "w"); if (out == NULL) { perror(line); exit(20); } banner = getBanner(cfg); fprintf(out, banner); freeBanner(banner); writedecl(out, cfg); if (!(cfg->options & OPTION_NORESIDENT)) { writeresident(out, cfg); writedeclsets(out, cfg); writeinitlib(out, cfg); if (cfg->modtype != RESOURCE) { writeopenlib(out, cfg); writecloselib(out, cfg); writeexpungelib(out, cfg); writeextfunclib(out, cfg); if (cfg->modtype == MCC || cfg->modtype == MUI || cfg->modtype == MCP) writemccquery(out, cfg); else if (cfg->modtype == DATATYPE) writeobtainengine(out, cfg); } writesets(out, cfg); } writefunctable(out, cfg); for (cl = cfg->classlist; cl != NULL; cl = cl->next) { switch (cl->classtype) { case MCC: case MUI: case MCP: /* Second argument to next call: the class is not the main class if it is not * the first class or the modtype is not a MUI class */ writemccinit(out, cl != cfg->classlist || cfg->modtype != cl->classtype, cl); break; case GADGET: case DATATYPE: case CLASS: case IMAGE: writeclassinit(out, cl); break; case HIDD: writeoopinit(out, cl); break; default: fprintf(stdout, "Internal error: unsupported classtype in writestart\n"); exit(20); } } fclose(out); }
void writeincdefines(struct config *cfg) { FILE *out; char line[256], *banner; struct functionhead *funclistit; snprintf(line, 255, "%s/defines/%s.h", cfg->gendir, cfg->modulename); out = fopen(line, "w"); if (out == NULL) { perror(line); exit(20); } banner = getBanner(cfg); fprintf(out, "#ifndef DEFINES_%s_H\n" "#define DEFINES_%s_H\n" "\n" "%s" "\n" "/*\n" " Desc: Defines for %s\n" "*/\n" "\n" "#include <aros/libcall.h>\n" "#include <exec/types.h>\n" "#include <aros/preprocessor/variadic/cast2iptr.hpp>\n" "\n", cfg->modulenameupper, cfg->modulenameupper, banner, cfg->modulename ); freeBanner(banner); if (cfg->command!=DUMMY) { for (funclistit = cfg->funclist; funclistit!=NULL; funclistit = funclistit->next) { if (!funclistit->priv && (funclistit->lvo >= cfg->firstlvo)) { if (funclistit->libcall != STACK) { writedefineregister(out, funclistit, cfg); if (!funclistit->novararg) writedefinevararg(out, funclistit, cfg); } else /* libcall == STACK */ { writedefinestack(out, funclistit, cfg); } writealiases(out, funclistit, cfg); } } } fprintf(out, "\n" "#endif /* DEFINES_%s_H*/\n", cfg->modulenameupper ); fclose(out); }
/**************************************************************************** * * knllog_thread * * Worker thread to transfer data to the file or socket. * ***************************************************************************/ static int knllog_thread(void *data) { daemonize("knllog"); while (1) { if (0 == wait_event_interruptible(knllogWakeQ, knllogWake)) { /* * Waking here is a signal to dump the log. The inner * loop below will sleep until the log is dumped and * then will return here to wait for another dump command. */ knllogWake = 0; if (!knllog.wrap) { knllog.eventIdx = 0; knllog.eventsToDump = knllog.idx; } else { knllog.eventIdx = knllog.idx; knllog.eventsToDump = knllog.entries; } knllog.eventsDumped = 0; #if CONFIG_NET if (!knllog.logfile) { struct sockaddr_in serverAddr; int rc = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &knllog.sock); if (rc < 0) { printk(KERN_ERR "knllog: socket create failed rc=%d\n", rc); goto cleanup; } printk(KERN_NOTICE "socket created\n"); /* connect to the server */ memset(&serverAddr, 0, sizeof(serverAddr)); serverAddr.sin_family = AF_INET; serverAddr.sin_port = htons((short) knllog.port); if ((u32) - 1 == (serverAddr.sin_addr.s_addr = in_aton(knllog.ipaddr))) { printk(KERN_ERR "knllog: Unknown server name '%s'.\n", knllog.ipaddr); sock_release(knllog.sock); knllog.sock = NULL; return (-1); } rc = knllog.sock->ops->connect(knllog.sock, (struct sockaddr *) &serverAddr, sizeof(serverAddr), 0); if (rc < 0) { printk(KERN_ERR "knllog: Can't connect to server. rc = %d\n", rc); sock_release(knllog.sock); knllog.sock = NULL; return rc; } printk(KERN_NOTICE "knllog: connected to server. rc = %d\n", rc); } else /* log to file */ #endif { /* "console" is a special filename to trigger timed printk's */ if (strcmp(knllog.filename, "console") != 0) { mm_segment_t old_fs = get_fs(); set_fs(KERNEL_DS); printk(KERN_NOTICE "Calling open on %s\n", knllog.filename); knllog.file = filp_open(knllog.filename, O_TRUNC | O_WRONLY | O_CREAT, 0644); set_fs(old_fs); if (!knllog.file || !knllog.file->f_op || !knllog.file->f_op->write) { printk(KERN_ERR "Could not open %s\n", knllog.filename); return (-1); } } else { printk(KERN_NOTICE "Dumping to console\n"); } } { char line[320]; char *linep = line; getBanner(&linep, sizeof(line), knllog.eventsToDump); outputStr(line, 1); } while (knllog.dumping && (knllog.eventsDumped < knllog.eventsToDump)) { KNLLOG_ENTRY *ep = &knllog.bufp[knllog.eventIdx++]; char line[160]; char *linep = line; decodeEvent(ep, &linep, sizeof(line), knllog.eventsDumped); outputStr(linep, 0); if (knllog.eventIdx >= knllog.entries) { knllog.eventIdx = 0; } knllog.lasttime = ep->time; knllog.eventsDumped++; if (knllog.eventsDumped % 100 == 0) { msleep(knllog.sleeptime); } } outputStr("Kernel Log Dump End...\n", 1); cleanup: #if CONFIG_NET if (knllog.sock) { printk(KERN_NOTICE "Calling sock_release\n"); sock_release(knllog.sock); knllog.sock = NULL; } #endif if (knllog.file) { mm_segment_t old_fs = get_fs(); set_fs(KERNEL_DS); printk(KERN_NOTICE "Calling close on %s\n", knllog.filename); filp_close(knllog.file, current->files); set_fs(old_fs); knllog.file = NULL; } knllog.enable = knllog.oldenable; knllog.dumping = 0; } else { printk(KERN_ERR "wait_event_interruptible returned non-zero code\n"); } } complete_and_exit(&knllogExited, 0); }