path: root/src/error.c

#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>

#include "config.h"

int lt_error_app(struct lt_config_app *cfg, struct lt_error_app *error_app)
{
	struct lt_error_app *app;
	struct lt_error_app_go *go, *g;
	struct lt_error_app_run *run, *r;

	if (!error_app->prog)
		return -EINVAL;

	app = malloc(sizeof(*app));
	if (!app)
		return -ENOMEM;

	/* XXX Just copy whatever we got from the bison app object,
	 * but afterwards we need to reinit all the lists, since
	 * it's based on the bison object.
	 * There's probably more sane way to have the app object
	 * dynamically allocated from the start.. let's wait for
	 * someone smart to do that ;) */

	*app = *error_app;

	lt_init_list_head(&app->head_run);
	lt_init_list_head(&app->head_go);
	lt_init_list_head(&app->list);

	lt_list_for_each_entry_safe(run, r, &error_app->head_run, list_app) {
		lt_list_del(&run->list_app);
		lt_list_add_tail(&run->list_app, &app->head_run);
	}

	lt_list_for_each_entry_safe(go, g, &error_app->head_go, list) {
		lt_list_del(&go->list);
		lt_list_add_tail(&go->list, &app->head_go);
	}

	lt_list_add_tail(&app->list, &cfg->error_apps);

	return 0;
}

int lt_error_set(struct lt_config_app *cfg, char *error)
{
	struct lt_error_app *app;
	int found = 0;

	lt_list_for_each_entry(app, &cfg->error_apps, list) {
		if (!strcmp(error, app->name)) {
			found = 1;
			break;
		}
	}

	if (!found)
		return -EINVAL;

	lt_sh(cfg, error_sim) = 1;
	cfg->error_app = app;
	return 0;
}

#define LT_DIR_PERM (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)

static int dir_get(struct lt_config_app *cfg, char *dir, int exist_check)
{
	struct stat st;

	PRINT_VERBOSE(cfg, 1, "exist_check %d, dir '%s'\n", exist_check, dir);

	if (!stat(dir, &st)) {
		if (exist_check) {
			printf("failed: directory already exists '%s'\n", dir);
			return -EEXIST;
		}

		/* TODO permission check */
		return 0;
	}

	if (mkdir(dir, LT_DIR_PERM)) {
		PRINT_VERBOSE(cfg, 1, "failed to create directory '%s'\n",
			      dir);
		/* XXX some sensiblle return value ;) */
		return -1;
	}

	return 0;
}

static int dir_base_name(struct lt_config_app *cfg,
			 char *buf, int len,
			 char *dir, char *prog)
{
	char file[LT_MAXFILE];
	char *last_bs;
	int size;

	PRINT_VERBOSE(cfg, 1, "dir '%s', prog '%s'\n", dir, prog);

	last_bs = strrchr(prog, '/');
	if (last_bs) {
		/* move behind '/' */
		last_bs++;

		/* endup with '/' isnt nice */
		if (!strlen(last_bs))
			return 0;

		size = snprintf(file, LT_MAXFILE, "%s", last_bs);
	} else
		size = snprintf(file, LT_MAXFILE, "%s", prog);

	PRINT_VERBOSE(cfg, 1, "file '%s'\n", file);

	if (size == LT_MAXFILE)
		return 0;

	size = snprintf(buf, len, "%s/latrace-%s/", dir, file);
	if (size == len)
		return 0;

	PRINT_VERBOSE(cfg, 1, "main dir '%s'\n", buf);
	return size;
}

static int dir_base(struct lt_config_app *cfg, struct lt_error_app *app, char *dir)
{
	int size;
	int ret;

	/* We dont create parents, just one level..
	 * whatever pass mkdir ;) */
	if (dir_get(cfg, app->dir, 0))
		return -1;

	size = dir_base_name(cfg, dir, LT_MAXFILE, app->dir, app->prog);
	if (!size)
		return -1;

	if (dir_get(cfg, dir, 0))
		return -1;

	size = snprintf(dir + size , LT_MAXFILE, "latest");
	if (size == LT_MAXFILE)
		return -1;

	ret = dir_get(cfg, dir, 1);
	if (ret == -EEXIST) {
		/* TODO move latest */
		return -1;
	} else if (ret != 0) {
		return ret;
	}

	return 0;
}

static int dir_go(struct lt_config_app *cfg,
		    char *dir, char *dir_base,
		    struct lt_error_app_go *go)
{
	int size;

	size = snprintf(dir, LT_MAXFILE, "%s/GO-%s/", dir_base, go->name);
	if (size == LT_MAXFILE)
		return -1;

	if (dir_get(cfg, dir, 0))
		return -1;

	return 0;
}

static int dir_run(struct lt_config_app *cfg,
		     char *dir, char *dir_base,
		     struct lt_error_app_run *run, int n)
{
	int size;

	size = snprintf(dir, LT_MAXFILE, "%s/RUN-%s-%05d/", dir_base, run->name, n);
	if (size == LT_MAXFILE)
		return -1;

	if (dir_get(cfg, dir, 0))
		return -1;

	return 0;
}

static int prepare_config_trace(struct lt_config_app *cfg, char *dir)
{
	FILE *f;

	snprintf(lt_sh(cfg, output), LT_MAXFILE, "%s/trace", dir);

	PRINT_VERBOSE(cfg, 1, "trace file %s\n", lt_sh(cfg, output));

	/* If the pipe mode is on, the latrace itself is doing the
	 * the trace output to the file, we need to open the output
	 * file each run */
	if (lt_sh(cfg, pipe)) {

		f = fopen(lt_sh(cfg, output), "w");
		if (!f) {
			perror("pipe mode: failed to open output file");
			return -1;
		}

		lt_sh(cfg, fout) = f;
		PRINT_VERBOSE(cfg, 1, "trace file pipe enabled\n");
	}

	return 0;
}

static int prepare_config_stat(struct lt_config_app *cfg, char *dir)
{
	char stat_file[LT_MAXFILE];
	FILE *f;

	snprintf(stat_file, LT_MAXFILE, "%s/stat", dir);
	f = fopen(stat_file, "w");
	if (!f) {
		perror("failed to open stat file");
		return -1;
	}

	cfg->fstat = f;

	PRINT_VERBOSE(cfg, 1, "stat file %s\n", stat_file);
	return 0;
}

static int prepare_config_tty(struct lt_config_app *cfg, char *dir)
{
	cfg->output_tty = 1;
	cfg->output_tty_fd = -1;
	snprintf(cfg->output_tty_file, LT_MAXFILE, "%s/tty-output", dir);

	PRINT_VERBOSE(cfg, 1, "tty output file %s\n", cfg->output_tty_file);
	return 0;
}

static int prepare_config_args(struct lt_config_app *cfg,
			       struct lt_error_app *app,
			       struct lt_error_app_run *run)
{
	int i = 1, size;
	char **arg = run->args;
#define BUFSIZE 4096
	char buf[BUFSIZE];

	cfg->prog   = app->prog;
	cfg->arg[0] = app->prog;

	size = snprintf(buf, BUFSIZE, "%s", app->prog);

	while(arg && *arg && (i < LT_NUM_ARG)) {
		PRINT_VERBOSE(cfg, 1, "arg: %s\n", *arg);
		size += snprintf(buf + size, BUFSIZE, " %s", *arg);
		cfg->arg[i++] = *arg++;
	}

	PRINT_VERBOSE(cfg, 1, "args: %s\n", buf);
	return 0;
}

static int prepare_config_error(struct lt_config_app *cfg,
			        struct lt_error_app_run *run,
			        int n)
{
	struct lt_error_app_return *ret;
	struct lt_error_def *error_def = &lt_sh(cfg, error_def);
	int i = 0;

	bzero(error_def, sizeof(struct lt_error_def));

	lt_list_for_each_entry(ret, &run->head_return, list_run) {
		struct lt_error_app_return_sym *sym;

		lt_list_for_each_entry(sym, &ret->head_sym, list) {
			struct lt_error_def_sym *sym_def;

			sym_def = &error_def->sym[i];
			strncpy(sym_def->symbol, sym->name, LT_MAXNAME);
			sym_def->ret = sym->val;
			sym_def->filter.type = ret->filter.type;

			PRINT_VERBOSE(cfg, 1, "symbol %s, ret %s\n",
					sym->name, sym->val);

			if (i++ >= LT_ERROR_MAXSYM)
				return -1;
		}
	}

	lt_sh(cfg, error_def.n) = n;
	PRINT_VERBOSE(cfg, 1, "N = %d\n", n);
	return 0;
}

static int prepare_config(struct lt_config_app *cfg, char *dir,
			  struct lt_error_app *app,
			  struct lt_error_app_run *run, int n)
{
	PRINT_VERBOSE(cfg, 1, "dir '%s'\n", dir);

	if (!app->no_storage) {
		if (prepare_config_trace(cfg, dir))
			return -1;

		if (prepare_config_stat(cfg, dir))
			return -1;

		if (prepare_config_tty(cfg, dir))
			return -1;
	}

	if (prepare_config_args(cfg, app, run))
		return -1;

	if (prepare_config_error(cfg, run, n))
		return -1;

	return 0;
}

static void post_config(struct lt_config_app *cfg,
			struct lt_error_app *app)
{
	if (!app->no_storage) {
		if ((lt_sh(cfg, pipe)) && (*lt_sh(cfg, output)))
			fclose(lt_sh(cfg, fout));

		fclose(cfg->fstat);
	}
}

static int process_run(struct lt_config_app *cfg,
		       char *dir_base,
		       struct lt_error_app *app,
		       struct lt_error_app_go *go,
		       struct lt_error_app_run *run,
		       int n)
{
	static char dir[LT_MAXFILE];

	if (!app->no_storage &&
	    dir_run(cfg, dir, dir_base, run, n))
		return -1;

	PRINT_VERBOSE(cfg, 1, "dir '%s'\n", dir);

	if (prepare_config(cfg, dir, app, run, n))
		return -1;

	if (app->no_storage)
		printf("latrace error simulation [%s] n = %d\n", app->name, n);

	lt_run(cfg);

	post_config(cfg, app);

	return 0;
}

static int process_go(struct lt_config_app *cfg, char *dir_base,
		      struct lt_error_app *app,
		      struct lt_error_app_go *go)
{
	static char dir[LT_MAXFILE];
	int i;

	if (!app->no_storage &&
	    dir_go(cfg, dir, dir_base, go))
		return -1;

	PRINT_VERBOSE(cfg, 1, "dir '%s'\n", dir);

	for(i = go->start; i < (go->start + go->n); i++) {
		struct lt_error_app_run *run;

		lt_list_for_each_entry(run, &go->head_run, list_go)
			if (process_run(cfg, dir, app, go, run, i))
				return -1;
	}

	return 0;
}

int lt_error_run(struct lt_config_app *cfg)
{
	struct lt_error_app *app = cfg->error_app;
	struct lt_error_app_go *go;
	static char dir[LT_MAXFILE];

	printf("latrace error simulation [%s]\n", app->name);

	if (!app->no_storage &&
	    dir_base(cfg, app, dir))
		return -1;

	PRINT_VERBOSE(cfg, 1, "dir '%s'\n", dir);

	lt_list_for_each_entry(go, &app->head_go, list) {
		if (process_go(cfg, dir, app, go))
			return -1;
	}

	return 0;
}

static struct lt_error_app_run *app_run_get(struct lt_config_app *cfg,
					    struct lt_error_app_run **run)
{

	PRINT_VERBOSE(cfg, 1, "run %p\n", *run);

	if (!*run) {
		struct lt_error_app_run *app_run;

		app_run = malloc(sizeof(*app_run));
		if (!app_run)
			return NULL;

		bzero(app_run, sizeof(*app_run));
		lt_init_list_head(&app_run->head_return);
		lt_init_list_head(&app_run->list_go);
		lt_init_list_head(&app_run->list_app);

		*run = app_run;
		PRINT_VERBOSE(cfg, 1, "new %p\n", *run);
	}

	return *run;
}

static struct lt_error_app_return*
find_return(struct lt_config_app *cfg,
	    struct lt_error_app *error_app,
	    char *name)
{
	struct lt_error_app_return *ret;

	PRINT_VERBOSE(cfg, 1, "looking for %s\n", name);

	lt_list_for_each_entry(ret, &error_app->head_return, list_app) {

		PRINT_VERBOSE(cfg, 2, "got %s\n", ret->name);

		if (!strcmp(name, ret->name)) {
			PRINT_VERBOSE(cfg, 2, "FOUND\n");
			return ret;
		}
	}

	PRINT_VERBOSE(cfg, 1, "NOT FOUND\n");
	return NULL;
}

int lt_error_run_return(struct lt_config_app *cfg,
			struct lt_error_app_run **run,
			struct lt_error_app *error_app,
			struct lt_list_head *rets)
{
	struct lt_error_app_run *app_run = app_run_get(cfg, run);
	struct lt_config_ln *ln, *h;

	if (!app_run)
		return -ENOMEM;

	PRINT_VERBOSE(cfg, 1, "run %s\n", app_run->name);

	lt_list_for_each_entry_safe(ln, h, rets, list) {
		struct lt_error_app_return *ret;

		ret = find_return(cfg, error_app, ln->name);
		if (!ret)
			return -EINVAL;

		PRINT_VERBOSE(cfg, 1, "return %s, empty %d\n",
			      ret->name, lt_list_empty(&ret->list_run));

		/* TODO Allow more than 1 RUN assignment to GO,
		 * so far only one assignment is allowed.  */
		if (!lt_list_empty(&ret->list_run))
			return -EINVAL;

		lt_list_add_tail(&ret->list_run, &app_run->head_return);

		lt_list_del(&ln->list);
                free(ln->name);
                free(ln);
	}

	return 0;
}

int lt_error_run_args(struct lt_config_app *cfg,
		      struct lt_error_app_run **run,
		      struct lt_list_head *head)
{
	struct lt_error_app_run *app_run = app_run_get(cfg, run);
	char **args = NULL;

	if (!app_run)
		return -ENOMEM;

	/* only one ARGS definition perf RUN */
	if (app_run->args)
		return -EINVAL;

	args = lt_config_ln_fill_array(head);
	if (!args)
		return -ENOMEM;

	PRINT_VERBOSE(cfg, 1, "args %p\n", args);

	app_run->args = args;
	return 0;
}

static struct lt_error_app_run *find_run(struct lt_config_app *cfg,
					 struct lt_error_app *error_app,
					 char *name)
{
	struct lt_error_app_run *run;

	PRINT_VERBOSE(cfg, 1, "looking for %s\n", name);

	lt_list_for_each_entry(run, &error_app->head_run, list_app) {

		PRINT_VERBOSE(cfg, 2, "got %s\n", run->name);

		if (!strcmp(name, run->name)) {
			PRINT_VERBOSE(cfg, 2, "FOUND\n");
			return run;
		}
	}

	PRINT_VERBOSE(cfg, 1, "NOT FOUND\n");
	return NULL;
}

int lt_error_go(struct lt_config_app *cfg,
		struct lt_error_app_go **go,
		struct lt_error_app *error_app,
		char *name, int start, int n,
		struct lt_list_head *runs)
{
	struct lt_error_app_go *app_go = *go;
	struct lt_config_ln *ln, *h;

	if (app_go)
		return -EINVAL;

	app_go = malloc(sizeof(*app_go));
	bzero(app_go, sizeof(*app_go));
	lt_init_list_head(&app_go->head_run);
	lt_init_list_head(&app_go->list);

	app_go->n = n;
	app_go->start = start;
	app_go->name = name;

	lt_list_for_each_entry_safe(ln, h, runs, list) {
		struct lt_error_app_run *run;

		run = find_run(cfg, error_app, ln->name);
		if (!run)
			return -EINVAL;

		PRINT_VERBOSE(cfg, 1, "run %s, empty %d\n",
			      run->name, lt_list_empty(&run->list_go));

		/* TODO Allow more than 1 RUN assignment to GO,
		 * so far only one assignment is allowed.  */
		if (!lt_list_empty(&run->list_go))
			return -EINVAL;

		lt_list_add_tail(&run->list_go, &app_go->head_run);

		lt_list_del(&ln->list);
                free(ln->name);
                free(ln);
	}

	*go = app_go;
	return 0;
}

static struct lt_error_app_return*
app_return_get(struct lt_config_app *cfg, struct lt_error_app_return **ret)
{
	if (!*ret) {
		struct lt_error_app_return *app_return;

		app_return = malloc(sizeof(*app_return));
		if (!app_return)
			return NULL;

		bzero(app_return, sizeof(*app_return));
		lt_init_list_head(&app_return->head_sym);
		lt_init_list_head(&app_return->list_app);
		lt_init_list_head(&app_return->list_run);

		*ret = app_return;
		PRINT_VERBOSE(cfg, 1, "new %p\n", *ret);
	}

	return *ret;
}

int lt_error_return_ass(struct lt_config_app *cfg,
			struct lt_error_app_return **ret,
			char *name, unsigned long val)
{
	struct lt_error_app_return *app_ret = app_return_get(cfg, ret);
	struct lt_error_app_return_sym *sym;

	if (!app_ret)
		return -ENOMEM;

	sym = malloc(sizeof(*sym));
	if (!sym)
		return -ENOMEM;

	sym->name = strdup(name);
	sym->val = val;

	PRINT_VERBOSE(cfg, 1, "%s = %ld\n", sym->name, val);

	lt_list_add_tail(&sym->list, &app_ret->head_sym);
        return 0;
}

int lt_error_return_filter(struct lt_config_app *cfg,
                           struct lt_error_app_return **ret,
                           int type, void *data)
{
	struct lt_error_app_return *app_ret = app_return_get(cfg, ret);

	if (!app_ret)
		return -ENOMEM;

	app_ret->filter.type = type;
	PRINT_VERBOSE(cfg, 1, "type %d\n", type);
        return 0;
}


int lt_error_app_init(struct lt_error_app *app)
{
	bzero(app, sizeof(*app));
	lt_init_list_head(&app->head_run);
	lt_init_list_head(&app->head_go);
	lt_init_list_head(&app->head_return);
	lt_init_list_head(&app->list);
	app->no_storage = 1;
	return 0;
}