/* 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);
}
