minix/commands/fbdctl/fbdctl.c
David van Moolenbroek e7db2d3588 Add fbd -- Faulty Block Device driver
This driver can be loaded as an overlay on top of a real block
device, and can then be used to generate block-level failures for
certain transfer requests. Specifically, a rule-based system allows
the user to introduce (overt and silent) data corruption and errors.

It exposes itself through /dev/fbd, and a file system can be mounted
on top of it. The new fbdctl(8) tool can be used to control the
driver; see ``man fbdctl'' for details. It also comes with a test
set, located in test/fbdtest.
2011-12-11 22:45:46 +01:00

319 lines
6.3 KiB
C

/* fbdctl - FBD control tool - by D.C. van Moolenbroek */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <minix/ioctl.h>
#include <minix/u64.h>
#include <sys/ioc_fbd.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
static int usage(char *name)
{
printf("usage:\n");
printf(" %s list\n", name);
printf(" %s add [-a start[-end]] [-s skip] [-c count] [-rw] "
"<action> [params]\n", name);
printf(" %s del N\n", name);
printf("\n");
printf("actions and params:\n");
printf(" corrupt [zero|persist|random]\n");
printf(" error [OK|EIO]\n");
printf(" misdir <start>-<end> <align>\n");
printf(" lost\n");
printf(" torn <lead>\n");
printf("use %s -d <device> to specify a device other than /dev/fbd\n",
name);
return EXIT_FAILURE;
}
static void print_rule(struct fbd_rule *rule)
{
printf("%-2d %04lX%08lX-%04lX%08lX %-4d %-5d %c%c ",
rule->num, ex64hi(rule->start), ex64lo(rule->start),
ex64hi(rule->end), ex64lo(rule->end), rule->skip,
rule->count, (rule->flags & FBD_FLAG_READ) ? 'r' : ' ',
(rule->flags & FBD_FLAG_WRITE) ? 'w' : ' ');
switch (rule->action) {
case FBD_ACTION_CORRUPT:
printf("%-7s ", "corrupt");
switch (rule->params.corrupt.type) {
case FBD_CORRUPT_ZERO: printf("zero"); break;
case FBD_CORRUPT_PERSIST: printf("persist"); break;
case FBD_CORRUPT_RANDOM: printf("random"); break;
default: printf("<unknown>");
}
break;
case FBD_ACTION_ERROR:
printf("%-7s ", "error");
switch (rule->params.error.code) {
case 0:
printf("OK");
break;
case EIO:
case -EIO:
printf("EIO");
break;
default:
printf("%d", rule->params.error.code);
}
break;
case FBD_ACTION_MISDIR:
printf("%-7s %04lX%08lX-%04lX%08lX %u",
"misdir", ex64hi(rule->params.misdir.start),
ex64lo(rule->params.misdir.start),
ex64hi(rule->params.misdir.end),
ex64lo(rule->params.misdir.end),
rule->params.misdir.align);
break;
case FBD_ACTION_LOSTTORN:
if (rule->params.losttorn.lead > 0)
printf("%-7s %u", "torn",
rule->params.losttorn.lead);
else
printf("%-7s", "lost");
}
printf("\n");
}
static int do_list(int fd)
{
struct fbd_rule rule;
int i;
printf("N Start End Skip Count RW Action Params\n");
for (i = 1; ; i++) {
rule.num = i;
if (ioctl(fd, FBDCGETRULE, &rule) < 0) {
if (errno == ENOENT)
continue;
break;
}
print_rule(&rule);
}
return EXIT_SUCCESS;
}
static int scan_hex64(char *input, u64_t *val)
{
u32_t lo, hi;
char buf[9];
int len;
len = strlen(input);
if (len < 1 || len > 16) return 0;
if (len > 8) {
memcpy(buf, input, len - 8);
buf[len - 8] = 0;
input += len - 8;
hi = strtoul(buf, NULL, 16);
}
else hi = 0;
lo = strtoul(input, NULL, 16);
*val = make64(lo, hi);
return 1;
}
static int scan_range(char *input, u64_t *start, u64_t *end, int need_end)
{
char *p;
if ((p = strchr(input, '-')) != NULL) {
*p++ = 0;
if (!scan_hex64(p, end)) return 0;
}
else if (need_end) return 0;
return scan_hex64(input, start);
}
static int do_add(int fd, int argc, char **argv, int off)
{
struct fbd_rule rule;
int c, r;
memset(&rule, 0, sizeof(rule));
while ((c = getopt(argc-off, argv+off, "a:s:c:rw")) != EOF) {
switch (c) {
case 'a':
if (!scan_range(optarg, &rule.start, &rule.end, 0))
return usage(argv[0]);
break;
case 's':
rule.skip = atoi(optarg);
break;
case 'c':
rule.count = atoi(optarg);
break;
case 'r':
rule.flags |= FBD_FLAG_READ;
break;
case 'w':
rule.flags |= FBD_FLAG_WRITE;
break;
default:
return usage(argv[0]);
}
}
optind += off; /* compensate for the shifted argc/argv */
if (optind >= argc) return usage(argv[0]);
/* default to reads and writes */
if (!rule.flags) rule.flags = FBD_FLAG_READ | FBD_FLAG_WRITE;
if (!strcmp(argv[optind], "corrupt")) {
if (optind+1 >= argc) return usage(argv[0]);
rule.action = FBD_ACTION_CORRUPT;
if (!strcmp(argv[optind+1], "zero"))
rule.params.corrupt.type = FBD_CORRUPT_ZERO;
else if (!strcmp(argv[optind+1], "persist"))
rule.params.corrupt.type = FBD_CORRUPT_PERSIST;
else if (!strcmp(argv[optind+1], "random"))
rule.params.corrupt.type = FBD_CORRUPT_RANDOM;
else return usage(argv[0]);
}
else if (!strcmp(argv[optind], "error")) {
if (optind+1 >= argc) return usage(argv[0]);
rule.action = FBD_ACTION_ERROR;
if (!strcmp(argv[optind+1], "OK"))
rule.params.error.code = 0;
else if (!strcmp(argv[optind+1], "EIO")) {
if (EIO > 0)
rule.params.error.code = -EIO;
else
rule.params.error.code = EIO;
}
else return usage(argv[0]);
}
else if (!strcmp(argv[optind], "misdir")) {
if (optind+2 >= argc) return usage(argv[0]);
rule.action = FBD_ACTION_MISDIR;
if (!scan_range(argv[optind+1], &rule.params.misdir.start,
&rule.params.misdir.end, 1))
return usage(argv[0]);
rule.params.misdir.align = atoi(argv[optind+2]);
if ((int) rule.params.misdir.align <= 0)
return usage(argv[0]);
}
else if (!strcmp(argv[optind], "lost")) {
rule.action = FBD_ACTION_LOSTTORN;
rule.params.losttorn.lead = 0;
}
else if (!strcmp(argv[optind], "torn")) {
if (optind+1 >= argc) return usage(argv[0]);
rule.action = FBD_ACTION_LOSTTORN;
rule.params.losttorn.lead = atoi(argv[optind+1]);
if ((int) rule.params.losttorn.lead <= 0)
return usage(argv[0]);
}
else return usage(argv[0]);
#if DEBUG
print_rule(&rule);
#endif
r = ioctl(fd, FBDCADDRULE, &rule);
if (r < 0) {
perror("ioctl");
return EXIT_FAILURE;
}
printf("Added rule %d\n", r);
return EXIT_SUCCESS;
}
static int do_del(int fd, int argc, char **argv, int off)
{
fbd_rulenum_t num;
if (argc < off + 2)
return usage(argv[0]);
num = atoi(argv[off + 1]);
if (ioctl(fd, FBDCDELRULE, &num)) {
perror("ioctl");
return EXIT_FAILURE;
}
printf("Deleted rule %d\n", num);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int r, fd, off = 1;
char *dev = "/dev/fbd";
if (argc < 2)
return usage(argv[0]);
if (!strcmp(argv[1], "-d")) {
if (argc < 4)
return usage(argv[0]);
dev = argv[2];
off += 2;
}
fd = open(dev, O_RDONLY);
if (fd < 0) {
perror(dev);
return EXIT_FAILURE;
}
else if (!strcmp(argv[off], "list"))
r = do_list(fd);
else if (!strcmp(argv[off], "add"))
r = do_add(fd, argc, argv, off);
else if (!strcmp(argv[off], "del"))
r = do_del(fd, argc, argv, off);
else
r = usage(argv[0]);
close(fd);
return r;
}