int
main(int argc, char *argv[])
{
time_t start;
int ch, onerun, reps;
const char *config, *home;
config = NULL;
#ifdef _WIN32
g.progname = "t_format.exe";
#else
if ((g.progname = strrchr(argv[0], DIR_DELIM)) == NULL)
g.progname = argv[0];
else
++g.progname;
#endif
#if 0
/* Configure the GNU malloc for debugging. */
(void)setenv("MALLOC_CHECK_", "2", 1);
#endif
#if 0
/* Configure the FreeBSD malloc for debugging. */
(void)setenv("MALLOC_OPTIONS", "AJ", 1);
#endif
/* Track progress unless we're re-directing output to a file. */
g.c_quiet = isatty(1) ? 0 : 1;
/* Set values from the command line. */
home = NULL;
onerun = 0;
while ((ch = __wt_getopt(
g.progname, argc, argv, "1C:c:H:h:Llqrt:")) != EOF)
switch (ch) {
case '1': /* One run */
onerun = 1;
break;
case 'C': /* wiredtiger_open config */
g.config_open = __wt_optarg;
break;
case 'c': /* Configuration from a file */
config = __wt_optarg;
break;
case 'H':
g.helium_mount = __wt_optarg;
break;
case 'h':
home = __wt_optarg;
break;
case 'L': /* Re-direct output to a log */
/*
* The -l option is a superset of -L, ignore -L if we
* have already configured logging for operations.
*/
if (g.logging == 0)
g.logging = LOG_FILE;
break;
case 'l': /* Turn on operation logging */
g.logging = LOG_OPS;
break;
case 'q': /* Quiet */
g.c_quiet = 1;
break;
case 'r': /* Replay a run */
g.replay = 1;
break;
default:
usage();
}
argc -= __wt_optind;
argv += __wt_optind;
/* Initialize the global RNG. */
testutil_check(__wt_random_init_seed(NULL, &g.rnd));
/* Set up paths. */
path_setup(home);
/* If it's a replay, use the home directory's CONFIG file. */
if (g.replay) {
if (config != NULL)
testutil_die(EINVAL, "-c incompatible with -r");
if (access(g.home_config, R_OK) != 0)
testutil_die(ENOENT, "%s", g.home_config);
config = g.home_config;
}
/*
* If we weren't given a configuration file, set values from "CONFIG",
* if it exists.
*
* Small hack to ignore any CONFIG file named ".", that just makes it
* possible to ignore any local CONFIG file, used when running checks.
*/
if (config == NULL && access("CONFIG", R_OK) == 0)
config = "CONFIG";
if (config != NULL && strcmp(config, ".") != 0)
config_file(config);
/*
* The rest of the arguments are individual configurations that modify
* the base configuration.
*/
for (; *argv != NULL; ++argv)
config_single(*argv, 1);
/*
* Multithreaded runs can be replayed: it's useful and we'll get the
* configuration correct. Obviously the order of operations changes,
* warn the user.
*/
if (g.replay && !SINGLETHREADED)
printf("Warning: replaying a threaded run\n");
/*
* Single-threaded runs historically exited after a single replay, which
* makes sense when you're debugging, leave that semantic in place.
*/
if (g.replay && SINGLETHREADED)
g.c_runs = 1;
/*
* Let the command line -1 flag override runs configured from other
* sources.
*/
if (onerun)
g.c_runs = 1;
/*
* Initialize locks to single-thread named checkpoints and backups, last
* last-record updates, and failures.
*/
testutil_check(pthread_rwlock_init(&g.append_lock, NULL));
testutil_check(pthread_rwlock_init(&g.backup_lock, NULL));
testutil_check(pthread_rwlock_init(&g.checkpoint_lock, NULL));
testutil_check(pthread_rwlock_init(&g.death_lock, NULL));
printf("%s: process %" PRIdMAX "\n", g.progname, (intmax_t)getpid());
while (++g.run_cnt <= g.c_runs || g.c_runs == 0 ) {
startup(); /* Start a run */
config_setup(); /* Run configuration */
config_print(0); /* Dump run configuration */
key_len_setup(); /* Setup keys */
start = time(NULL);
track("starting up", 0ULL, NULL);
#ifdef HAVE_BERKELEY_DB
if (SINGLETHREADED)
bdb_open(); /* Initial file config */
#endif
wts_open(g.home, true, &g.wts_conn);
wts_init();
wts_load(); /* Load initial records */
wts_verify("post-bulk verify"); /* Verify */
/*
* If we're not doing any operations, scan the bulk-load, copy
* the statistics and we're done. Otherwise, loop reading and
* operations, with a verify after each set.
*/
if (g.c_timer == 0 && g.c_ops == 0) {
wts_read_scan(); /* Read scan */
wts_stats(); /* Statistics */
} else
for (reps = 1; reps <= FORMAT_OPERATION_REPS; ++reps) {
wts_read_scan(); /* Read scan */
/* Operations */
wts_ops(reps == FORMAT_OPERATION_REPS);
/*
* Copy out the run's statistics after the last
* set of operations.
*
* XXX
* Verify closes the underlying handle and
* discards the statistics, read them first.
*/
if (reps == FORMAT_OPERATION_REPS)
wts_stats();
/* Verify */
wts_verify("post-ops verify");
}
track("shutting down", 0ULL, NULL);
#ifdef HAVE_BERKELEY_DB
if (SINGLETHREADED)
bdb_close();
#endif
wts_close();
/*
* Rebalance testing.
*/
wts_rebalance();
/*
* If single-threaded, we can dump and compare the WiredTiger
* and Berkeley DB data sets.
*/
if (SINGLETHREADED)
wts_dump("standard", 1);
/*
* Salvage testing.
*/
wts_salvage();
/* Overwrite the progress line with a completion line. */
if (!g.c_quiet)
printf("\r%78s\r", " ");
printf("%4d: %s, %s (%.0f seconds)\n",
g.run_cnt, g.c_data_source,
g.c_file_type, difftime(time(NULL), start));
fflush(stdout);
}
/* Flush/close any logging information. */
fclose_and_clear(&g.logfp);
fclose_and_clear(&g.randfp);
config_print(0);
testutil_check(pthread_rwlock_destroy(&g.append_lock));
testutil_check(pthread_rwlock_destroy(&g.backup_lock));
testutil_check(pthread_rwlock_destroy(&g.checkpoint_lock));
testutil_check(pthread_rwlock_destroy(&g.death_lock));
config_clear();
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
wispy_tcpserv wts;
char errstr[WISPY_ERROR_MAX];
fd_set sel_r_fds, sel_w_fds;
struct timeval tm;
wispy_device_list list;
wispy_tcpserv_dev *devs = NULL;
int ndev = 0;
int x = 0, r = 0;
static struct option long_options[] = {
{ "port", required_argument, 0, 'p' },
{ "bindaddr", required_argument, 0, 'a' },
{ "broadcast", required_argument, 0, 'b' },
{ "help", no_argument, 0, 'h' },
{ "list", no_argument, 0, 'l' },
{ "range", required_argument, 0, 'r' },
{ 0, 0, 0, 0 }
};
int option_index;
char *bindaddr = NULL;
short int bindport = WISPY_NET_DEFAULT_PORT;
int broadcast = 0, bcast_sock = -1;
time_t last_bcast = 0;
int list_only = 0;
ndev = wispy_device_scan(&list);
int *rangeset = NULL;
if (ndev > 0) {
rangeset = (int *) malloc(sizeof(int) * ndev);
memset(rangeset, 0, sizeof(int) * ndev);
}
while (1) {
int o = getopt_long(argc, argv, "p:a:b:lr:h",
long_options, &option_index);
if (o < 0)
break;
if (o == 'h') {
Usage();
exit(-1);
} else if (o == 'a') {
bindaddr = strdup(optarg);
continue;
} else if (o == 'p') {
if (sscanf(optarg, "%hd", &bindport) != 1) {
fprintf(stderr, "Expected port number\n");
Usage();
exit(-1);
}
} else if (o == 'b') {
if (sscanf(optarg, "%d", &broadcast) != 1) {
fprintf(stderr, "Expected broadcast time in seconds\n");
Usage();
exit(-1);
}
} else if (o == 'l') {
list_only = 1;
} else if (o == 'r' && ndev > 0) {
if (sscanf(optarg, "%d:%d", &x, &r) != 2) {
if (sscanf(optarg, "%d", &r) != 1) {
fprintf(stderr, "Invalid range, expected device#:range# "
"or range#\n");
exit(-1);
} else {
rangeset[0] = r;
}
} else {
if (x < 0 || x >= ndev) {
fprintf(stderr, "Invalid range, no device %d\n", x);
exit(-1);
} else {
rangeset[x] = r;
}
}
}
}
if (list_only) {
if (ndev <= 0) {
printf("No wispy devices found, bailing\n");
exit(1);
}
printf("Found %d devices...\n", ndev);
for (x = 0; x < ndev; x++) {
printf("Device %d: %s id %u\n",
x, list.list[x].name, list.list[x].device_id);
for (r = 0; r < list.list[x].num_sweep_ranges; r++) {
wispy_sample_sweep *ran =
&(list.list[x].supported_ranges[r]);
printf(" Range %d: \"%s\" %d%s-%d%s @ %0.2f%s, %d samples\n", r,
ran->name,
ran->start_khz > 1000 ?
ran->start_khz / 1000 : ran->start_khz,
ran->start_khz > 1000 ? "MHz" : "KHz",
ran->end_khz > 1000 ? ran->end_khz / 1000 : ran->end_khz,
ran->end_khz > 1000 ? "MHz" : "KHz",
(ran->res_hz / 1000) > 1000 ?
((float) ran->res_hz / 1000) / 1000 : ran->res_hz / 1000,
(ran->res_hz / 1000) > 1000 ? "MHz" : "KHz",
ran->num_samples);
}
}
exit(0);
}
if (ndev <= 0) {
printf("No wispy devices found, bailing\n");
exit(1);
}
signal(SIGPIPE, &sigcatch);
fprintf(stderr, "Found %d wispy devices...\n", ndev);
/* devs = (wispy_phy *) malloc(WISPY_PHY_SIZE * ndev); */
devs = (wispy_tcpserv_dev *) malloc(sizeof(wispy_tcpserv_dev) * ndev);
for (x = 0; x < ndev; x++) {
fprintf(stderr, "Initializing WiSPY device %s id %u\n",
list.list[x].name, list.list[x].device_id);
devs[x].lock_fd = -1;
if (wispy_device_init(&(devs[x].phydev), &(list.list[x])) < 0) {
fprintf(stderr, "Error initializing WiSPY device %s id %u\n",
list.list[x].name, list.list[x].device_id);
fprintf(stderr, "%s\n", wispy_get_error(&(devs[x].phydev)));
exit(1);
}
if (wispy_phy_open(&(devs[x].phydev)) < 0) {
fprintf(stderr, "Error opening WiSPY device %s id %u\n",
list.list[x].name, list.list[x].device_id);
fprintf(stderr, "%s\n", wispy_get_error(&(devs[x].phydev)));
exit(1);
}
wispy_phy_setcalibration(&(devs[x].phydev), 1);
/* configure the default sweep block */
wispy_phy_setposition(&(devs[x].phydev), rangeset[x], 0, 0);
}
wispy_device_scan_free(&list);
wts_init(&wts);
if (broadcast > 0) {
if ((bcast_sock = wts_init_bcast(errstr, bindport)) < 0) {
fprintf(stderr, "Broadcast init failed: %s\n", errstr);
exit(1);
}
last_bcast = time(0);
}
wts.devs = devs;
wts.ndev = ndev;
if (wts_bind(&wts, bindaddr, bindport, errstr) < 0) {
fprintf(stderr, "TCP bind failed: %s\n", errstr);
exit(1);
}
fprintf(stderr, "TCP server listening on %s port %hd\n",
bindaddr == NULL ? "(any)" : bindaddr,
bindport);
if (broadcast) {
fprintf(stderr, "Broadcast server announcing on port %hd, %d seconds\n",
bindport, broadcast);
}
while (1) {
FD_ZERO(&sel_r_fds);
FD_ZERO(&sel_w_fds);
wts_fdset(&wts, &sel_r_fds, &sel_w_fds);
tm.tv_sec = 0;
tm.tv_usec = 100000;
if (broadcast > 0 && time(0) - last_bcast > broadcast) {
if (wts_send_bcast(bcast_sock, bindport, errstr) < 0) {
fprintf(stderr, "Sending broadcast packet failed, %s\n", errstr);
wts_shutdown(&wts);
exit(1);
}
last_bcast = time(0);
}
if (select(wts.maxfd + 1, &sel_r_fds, &sel_w_fds, NULL, &tm) < 0) {
fprintf(stderr, "Select() failed: %s\n", strerror(errno));
wts_shutdown(&wts);
exit(1);
}
if (wts_poll(&wts, &sel_r_fds, &sel_w_fds, errstr) < 0) {
fprintf(stderr, "Polling failed: %s\n", errstr);
wts_shutdown(&wts);
exit(1);
}
}
}
