fault.c

#include "fault.h"

#include "config.h"

#include <err.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "libks/list.h"

#include "log.h"

#ifdef DIAGNOSTIC

LIST(fault_list, fault);

struct fault {
	char			fu_name[32];
	int			fu_errno;
	unsigned int		fu_hits;

	LIST_ENTRY(fault_list, fault);
};

static void	fault_init(void);
static int	fault_match(const char *);

static const char	*parse_attr(struct fault *, const char *, const char *);

static struct fault_list	faults;
static int			cold = 1;

int
fault(const char *name)
{
	fault_init();

	if (!fault_match(name))
		return 0;
	warnx("fault: %s", name);
	return 1;
}

void
fault_shutdown(void)
{
	struct fault *fu;
	int error = 0;

	fault_init();

	while ((fu = LIST_FIRST(&faults)) != NULL) {
		LIST_REMOVE(&faults, fu);
		if (fu->fu_hits == 0) {
			warnx("%s: %s: fault never hit", __func__, fu->fu_name);
			error = 1;
		}
		free(fu);
	}

	if (error)
		exit(66);
}

static void
fault_init(void)
{
	const char *str;

	if (!cold)
		return;

	LIST_INIT(&faults);

	str = getenv("FAULT");
	if (str == NULL || str[0] == '\0')
		return;
	log_debug("%s: faults=\"%s\"\n", __func__, str);

	for (;;) {
		struct fault *fu;
		const char *end, *p;

		p = end = strchr(str, ':');
		if (end == NULL)
			end = str + strlen(str);

		fu = calloc(1, sizeof(*fu));
		if (fu == NULL)
			err(1, NULL);

		for (;;) {
			str = parse_attr(fu, str, end);
			if (str == NULL)
				break;
		}
		LIST_INSERT_TAIL(&faults, fu);

		if (p == NULL)
			break;
		str = end + 1;
	}

	cold = 0;
}

static int
fault_match(const char *name)
{
	struct fault *fu;

	LIST_FOREACH(fu, &faults) {
		if (strcmp(fu->fu_name, name) != 0)
			continue;
		if (fu->fu_hits > 0)
			continue;

		fu->fu_hits++;
		errno = fu->fu_errno;
		return 1;
	}
	return 0;
}

static const char *
parse_attr(struct fault *fu, const char *str, const char *end)
{
	const char *key, *p, *val;
	size_t keysiz, valsiz;

	p = strchr(str, '=');
	if (p == NULL)
		errx(1, "%s: %s: invalid fault", __func__, str);
	key = str;
	keysiz = (size_t)(p - str);
	str = p + 1;

	p = strchr(str, ',');
	if (p == NULL)
		p = end;
	val = str;
	valsiz = (size_t)(p - str);
	str = p + 1;

	if (strncmp(key, "errno", keysiz) == 0) {
#define ERRNO(e) do {							\
		if (strncmp(val, #e, valsiz) == 0) {			\
			fu->fu_errno = e;				\
			goto out;					\
		}							\
} while (0)
		ERRNO(EINVAL);
		ERRNO(ENAMETOOLONG);
		ERRNO(ENOENT);
		ERRNO(ENOSPC);
		ERRNO(EXDEV);
#undef ERRNO

		errx(1, "%s: %.*s: unknown errno value",
		    __func__, (int)valsiz, val);
	} else if (strncmp(key, "name", keysiz) == 0) {
		size_t siz;
		int n;

		siz = sizeof(fu->fu_name);
		n = snprintf(fu->fu_name, siz, "%.*s", (int)valsiz, val);
		if (n < 0 || (size_t)n >= siz)
			errc(1, ENAMETOOLONG, "%s", __func__);
	} else {
		errx(1, "%s: %.*s: unknown fault attribute",
		    __func__, (int)keysiz, key);
	}

out:
	if (p == end)
		return NULL;
	return str;
}

#endif	/* DIAGNOSTIC */