void parse_packet(uint8_t *notused, const struct pcap_pkthdr *phdr, const uint8_t *packet) {
size_t pk_len=0;
int pk_layer=0;
extern pcap_dumper_t *pdump;
if (packet == NULL || phdr == NULL) {
ERR("%s is null", packet == NULL ? "packet" : "pcap header");
return;
}
/* when you forget to put this here, it makes for really dull pcap log files */
if (s->pcap_dumpfile) {
pcap_dump((uint8_t *)pdump, phdr, packet);
}
pk_len=phdr->caplen;
if (pk_len <= s->ss->header_len) {
ERR("this packet is too short " STFMT ", header length is %u", pk_len, s->ss->header_len);
return;
}
if (ISDBG(M_PKT) || GET_SNIFF()) {
INF("got packet with length %u (cap %u) with header length at %u", phdr->len, phdr->caplen, s->ss->header_len);
}
pk_len -= s->ss->header_len;
packet += s->ss->header_len;
pk_layer++;
switch (s->ss->mode) {
case MODE_ARPSCAN:
report_init(REPORT_TYPE_ARP, &phdr->ts);
packet_init(packet, pk_len);
decode_arp(packet, pk_len, pk_layer); /* the pcap filter should be arp only */
break;
case MODE_TCPSCAN:
case MODE_UDPSCAN:
case MODE_ICMPSCAN:
case MODE_IPSCAN:
report_init(REPORT_TYPE_IP, &phdr->ts);
packet_init(packet, pk_len);
decode_ip(packet, pk_len, pk_layer); /* the pcap filter should be ip only */
break;
}
return;
}
static int __init PlayerLoadModule (void)
{
report_init ();
report_restricted_severity_levels(severity_fatal, severity_interrupt * 10);
DisplayInit ();
BackendInit ();
register_dvb_backend (MODULE_NAME, &DvbBackendOps);
register_alsa_backend (MODULE_NAME, &AlsaBackendOps);
#if defined (CONFIG_EXPORT_PLAYER_INTERFACE)
register_player_interface (MODULE_NAME, &PlayerInterfaceOps);
#endif
PLAYER_DEBUG("Player2 backend loaded\n");
return 0;
}
static int _report(struct cmd_context *cmd, int argc, char **argv,
report_type_t report_type)
{
void *report_handle;
const char *opts;
char *str;
const char *keys = NULL, *options = NULL, *separator;
int r = ECMD_PROCESSED;
int aligned, buffered, headings;
unsigned args_are_pvs;
aligned = find_config_tree_int(cmd, "report/aligned",
DEFAULT_REP_ALIGNED);
buffered = find_config_tree_int(cmd, "report/buffered",
DEFAULT_REP_BUFFERED);
headings = find_config_tree_int(cmd, "report/headings",
DEFAULT_REP_HEADINGS);
separator = find_config_tree_str(cmd, "report/separator",
DEFAULT_REP_SEPARATOR);
args_are_pvs = (report_type == PVS || report_type == PVSEGS) ? 1 : 0;
switch (report_type) {
case LVS:
keys = find_config_tree_str(cmd, "report/lvs_sort",
DEFAULT_LVS_SORT);
if (!arg_count(cmd, verbose_ARG))
options = find_config_tree_str(cmd,
"report/lvs_cols",
DEFAULT_LVS_COLS);
else
options = find_config_tree_str(cmd,
"report/lvs_cols_verbose",
DEFAULT_LVS_COLS_VERB);
break;
case VGS:
keys = find_config_tree_str(cmd, "report/vgs_sort",
DEFAULT_VGS_SORT);
if (!arg_count(cmd, verbose_ARG))
options = find_config_tree_str(cmd,
"report/vgs_cols",
DEFAULT_VGS_COLS);
else
options = find_config_tree_str(cmd,
"report/vgs_cols_verbose",
DEFAULT_VGS_COLS_VERB);
break;
case PVS:
keys = find_config_tree_str(cmd, "report/pvs_sort",
DEFAULT_PVS_SORT);
if (!arg_count(cmd, verbose_ARG))
options = find_config_tree_str(cmd,
"report/pvs_cols",
DEFAULT_PVS_COLS);
else
options = find_config_tree_str(cmd,
"report/pvs_cols_verbose",
DEFAULT_PVS_COLS_VERB);
break;
case SEGS:
keys = find_config_tree_str(cmd, "report/segs_sort",
DEFAULT_SEGS_SORT);
if (!arg_count(cmd, verbose_ARG))
options = find_config_tree_str(cmd,
"report/segs_cols",
DEFAULT_SEGS_COLS);
else
options = find_config_tree_str(cmd,
"report/segs_cols_verbose",
DEFAULT_SEGS_COLS_VERB);
break;
case PVSEGS:
keys = find_config_tree_str(cmd, "report/pvsegs_sort",
DEFAULT_PVSEGS_SORT);
if (!arg_count(cmd, verbose_ARG))
options = find_config_tree_str(cmd,
"report/pvsegs_cols",
DEFAULT_PVSEGS_COLS);
else
options = find_config_tree_str(cmd,
"report/pvsegs_cols_verbose",
DEFAULT_PVSEGS_COLS_VERB);
break;
}
/* If -o supplied use it, else use default for report_type */
if (arg_count(cmd, options_ARG)) {
opts = arg_str_value(cmd, options_ARG, "");
if (!opts || !*opts) {
log_error("Invalid options string: %s", opts);
return 0;
}
if (*opts == '+') {
if (!(str = dm_pool_alloc(cmd->mem,
strlen(options) + strlen(opts) + 1))) {
log_error("options string allocation failed");
return 0;
}
strcpy(str, options);
strcat(str, ",");
strcat(str, opts + 1);
options = str;
} else
options = opts;
}
/* -O overrides default sort settings */
if (arg_count(cmd, sort_ARG))
keys = arg_str_value(cmd, sort_ARG, "");
if (arg_count(cmd, separator_ARG))
separator = arg_str_value(cmd, separator_ARG, " ");
if (arg_count(cmd, separator_ARG))
aligned = 0;
if (arg_count(cmd, aligned_ARG))
aligned = 1;
if (arg_count(cmd, unbuffered_ARG) && !arg_count(cmd, sort_ARG))
buffered = 0;
if (arg_count(cmd, noheadings_ARG))
headings = 0;
if (!(report_handle = report_init(cmd, options, keys, &report_type,
separator, aligned, buffered,
headings)))
return_0;
/* Ensure options selected are compatible */
if (report_type & SEGS)
report_type |= LVS;
if (report_type & PVSEGS)
report_type |= PVS;
if ((report_type & LVS) && (report_type & PVS)) {
log_error("Can't report LV and PV fields at the same time");
dm_report_free(report_handle);
return 0;
}
/* Change report type if fields specified makes this necessary */
if (report_type & SEGS)
report_type = SEGS;
else if (report_type & LVS)
report_type = LVS;
else if (report_type & PVSEGS)
report_type = PVSEGS;
else if (report_type & PVS)
report_type = PVS;
switch (report_type) {
case LVS:
r = process_each_lv(cmd, argc, argv, LCK_VG_READ, report_handle,
&_lvs_single);
break;
case VGS:
r = process_each_vg(cmd, argc, argv, LCK_VG_READ, 0,
report_handle, &_vgs_single);
break;
case PVS:
if (args_are_pvs)
r = process_each_pv(cmd, argc, argv, NULL,
report_handle, &_pvs_single);
else
r = process_each_vg(cmd, argc, argv, LCK_VG_READ, 0,
report_handle, &_pvs_in_vg);
break;
case SEGS:
r = process_each_lv(cmd, argc, argv, LCK_VG_READ, report_handle,
&_lvsegs_single);
break;
case PVSEGS:
if (args_are_pvs)
r = process_each_pv(cmd, argc, argv, NULL,
report_handle, &_pvsegs_single);
else
r = process_each_vg(cmd, argc, argv, LCK_VG_READ, 0,
report_handle, &_pvsegs_in_vg);
break;
}
dm_report_output(report_handle);
dm_report_free(report_handle);
return r;
}
int main(int argc, char **argv)
{
int cnt, x, y, i = 0, verbose = 0;
Window win = 0;
Bool keysymMappingInitialized = False;
int rc = 0;
int inputEvents[100];
int inputEventsIndex = 0;
int iEvent = 0;
if (argc == 1)
usage(argv[0]);
const char* log_file = NULL;
if (streq(argv[1],"-o") || streq(argv[1],"--logfile")) {
i++;
if (++i > argc)
usage(argv[0]);
log_file = argv[i];
}
report_init(log_file);
if (!xhandler_init(getenv("DISPLAY")))
exit(1);
report_add_message(xhandler_get_server_time(), "Startup\n");
/* initialize subsystems */
xemu_init(xhandler.display);
scheduler_init(xhandler.display);
window_init(xhandler.display);
application_init();
/*
* Process the command line options.
* Skip emulation options (--click, --drag, --key, --type), but remember they index
* and process them later.
*/
while (++i < argc) {
if (streq(argv[i],"-v") || streq(argv[i],"--verbose")) {
verbose = 1;
continue;
}
if (streq(argv[i], "-id") || streq(argv[i], "--id")) {
char name[PATH_MAX];
if (++i >= argc)
usage(argv[0]);
cnt = sscanf(argv[i], "0x%lx", &win);
if (cnt < 1) {
cnt = sscanf(argv[i], "%lu", &win);
}
if (cnt < 1) {
fprintf(stderr, "*** invalid window id '%s'\n", argv[i]);
usage(argv[0]);
}
sprintf(name, "0x%lx", win);
if (!window_add(win, application_monitor(name))) {
fprintf(stderr, "Could not setup damage monitoring for window 0x%lx!\n", win);
exit(1);
}
if (verbose)
report_add_message(REPORT_LAST_TIMESTAMP, "Monitoring window 0x%lx\n", win);
continue;
}
if (streq(argv[i], "-a") || streq(argv[i], "--application")) {
if (++i >= argc)
usage(argv[0]);
response.application = application_monitor(argv[i]);
if (response.application && verbose) {
report_add_message(REPORT_LAST_TIMESTAMP, "Monitoring application '%s'\n", argv[i]);
}
if (!strcmp(argv[i], "*")) {
application_set_monitor_all(true);
}
continue;
}
if (streq("-c", argv[i]) || streq("--click", argv[i])) {
if (!xemu.pointer.dev) {
fprintf(stderr, "Failed to open pointer device, unable to simulate pointer events.\n");
exit(-1);
}
if (inputEventsIndex == ASIZE(inputEvents)) {
fprintf(stderr, "Too many input events specified\n");
exit(-1);
}
if (!argv[i + 1] || !match_regex(argv[i + 1], "^[0-9]+x[0-9]+(,[0-9]+)?$")) {
fprintf(stderr, "Failed to parse --c options: %s\n", argv[i + 1]);
exit(-1);
}
inputEvents[inputEventsIndex++] = i;
if (++i >= argc)
usage(argv[0]);
continue;
}
if (streq("-l", argv[i]) || streq("--level", argv[i])) {
if (++i >= argc)
usage(argv[0]);
if (!strcmp(argv[i], "raw")) {
window_set_damage_level(XDamageReportRawRectangles);
} else if (!strcmp(argv[i], "delta")) {
window_set_damage_level(XDamageReportDeltaRectangles);
} else if (!strcmp(argv[i], "box")) {
window_set_damage_level(XDamageReportDeltaRectangles);
} else if (!strcmp(argv[i], "nonempty")) {
window_set_damage_level(XDamageReportNonEmpty);
} else {
fprintf(stderr, "Unrecongnized damage level: %s\n", argv[i]);
usage(argv[0]);
}
if (verbose)
report_add_message(REPORT_LAST_TIMESTAMP, "Setting damage report level to %s\n", argv[i]);
continue;
}
if (streq("-x", argv[i]) || streq("--exclude", argv[i])) {
char* exclude[] = { "none", "less", "greater" };
if (options.exclude_rules != EXCLUDE_NONE) {
fprintf(stderr, "Duplicated --exclude parameter detected. Aborting\n");
exit(-1);
}
if (++i >= argc)
usage(argv[0]);
char rules[32] = "";
if ((cnt = sscanf(argv[i], "%ux%u,%s", &options.exclude_rect.width, &options.exclude_rect.height, rules)) >= 2) {
options.exclude_size = 0;
} else if ((cnt = sscanf(argv[i], "%u,%s", &options.exclude_size, rules)) >= 1) {
options.exclude_rect.width = 0;
options.exclude_rect.height = 0;
} else {
fprintf(stderr, "*** failed to parse '%s'\n", argv[i]);
usage(argv[0]);
}
options.exclude_rules = *rules && !strcmp(rules, "greater") ? EXCLUDE_GREATER : EXCLUDE_LESS;
if (verbose) {
if (options.exclude_size) {
report_add_message(REPORT_LAST_TIMESTAMP, "Excluding damage areas %s than %d pixels\n", exclude[options.exclude_rules],
options.exclude_size);
} else {
report_add_message(REPORT_LAST_TIMESTAMP, "Excluding damage areas %s than (%dx%d)\n", exclude[options.exclude_rules],
options.exclude_rect.width, options.exclude_rect.height);
}
}
continue;
}
if (streq("-m", argv[i]) || streq("--monitor", argv[i])) {
if (options.interested_damage_rect.width || options.interested_damage_rect.height || options.interested_damage_rect.x
|| options.interested_damage_rect.y) {
fprintf(stderr, "Duplicated --monitor parameter detected. Aborting\n");
exit(-1);
}
if (++i >= argc)
usage(argv[0]);
if ((cnt = sscanf(argv[i], "%ux%u+%u+%u", &options.interested_damage_rect.width, &options.interested_damage_rect.height,
&options.interested_damage_rect.x, &options.interested_damage_rect.y)) != 4) {
fprintf(stderr, "*** failed to parse '%s'\n", argv[i]);
usage(argv[0]);
}
if (verbose) {
report_add_message(REPORT_LAST_TIMESTAMP, "Set monitor rect to %ix%i+%i+%i\n", options.interested_damage_rect.width,
options.interested_damage_rect.height, options.interested_damage_rect.x, options.interested_damage_rect.y);
}
continue;
}
if (streq("-w", argv[i]) || streq("--wait", argv[i])) {
if (++i >= argc)
usage(argv[0]);
if (options.damage_wait_secs >= 0) {
fprintf(stderr, "Duplicate -w(--wait) option detected. Discarding the previous value\n");
}
if ((options.damage_wait_secs = atoi(argv[i])) < 0) {
fprintf(stderr, "*** failed to parse '%s'\n", argv[i]);
usage(argv[0]);
}
if (verbose)
report_add_message(REPORT_LAST_TIMESTAMP, "Set event timeout to %isecs\n", options.damage_wait_secs);
continue;
}
if (streq("-b", argv[i]) || streq("--break", argv[i])) {
if (options.break_timeout || options.break_on_damage) {
fprintf(stderr, "Duplicate -b(--break)option detected. Discarding the previous value\n");
options.break_timeout = 0;
options.break_on_damage = 0;
}
if (++i >= argc)
usage(argv[0]);
if (!strncmp(argv[i], "damage", 6)) {
sscanf(argv[i] + 6, ",%d", &options.break_on_damage);
if (!options.break_on_damage)
options.break_on_damage = 1;
if (verbose)
report_add_message(REPORT_LAST_TIMESTAMP, "Break wait on the %d damage event\n", options.break_on_damage);
} else {
if ((options.break_timeout = atoi(argv[i])) < 0) {
fprintf(stderr, "*** failed to parse '%s'\n", argv[i]);
usage(argv[0]);
}
if (verbose)
report_add_message(REPORT_LAST_TIMESTAMP, "Set break timout to %imsecs\n", options.break_timeout);
}
continue;
}
if (streq("-d", argv[i]) || streq("--drag", argv[i])) {
if (!xemu.pointer.dev) {
fprintf(stderr, "Failed to open pointer device, unable to simulate pointer events.\n");
exit(-1);
}
if (inputEventsIndex == ASIZE(inputEvents)) {
fprintf(stderr, "Too many input events specified\n");
exit(-1);
}
if (!argv[i + 1] || (!match_regex(argv[i + 1], "^([0-9]+,)?(([0-9]+x[0-9]+,([0-9]+,)?)+[0-9]+x[0-9]+)$") &&
(!match_regex(argv[i + 1], "[0-9]+x[0-9]+-[0-9]+x[0-9]+") ||
!match_regex(argv[i + 1], "^(((([0-9]+,)?([0-9]+x[0-9]+)|([0-9]+x[0-9]+-[0-9]+x[0-9]+(\\*[0-9]+)?(\\+[1-9][0-9]*)?)),?)+)$") ) ) ) {
fprintf(stderr, "Failed to parse --drag options: %s\n", argv[i + 1]);
exit(-1);
}
inputEvents[inputEventsIndex++] = i;
if (++i >= argc)
usage(argv[0]);
continue;
}
if (streq("-k", argv[i]) || streq("--key", argv[i])) {
if (!xemu.keyboard.dev) {
fprintf(stderr, "Failed to open keyboard device, unable to simulate keyboard events.\n");
exit(-1);
}
if (inputEventsIndex == ASIZE(inputEvents)) {
fprintf(stderr, "Too many input events specified\n");
exit(-1);
}
inputEvents[inputEventsIndex++] = i;
if (++i >= argc)
usage(argv[0]);
continue;
}
if (streq("-t", argv[i]) || streq("--type", argv[i])) {
if (!xemu.keyboard.dev) {
fprintf(stderr, "Failed to open keyboard device, unable to simulate keyboard events.\n");
exit(-1);
}
if (inputEventsIndex == ASIZE(inputEvents)) {
fprintf(stderr, "Too many input events specified\n");
exit(-1);
}
inputEvents[inputEventsIndex++] = i;
if (++i >= argc)
usage(argv[0]);
if (!keysymMappingInitialized) {
xemu_load_keycodes();
keysymMappingInitialized = True;
}
continue;
}
/* since moving from command sequence approach the inspect parameter is deprecated */
if (streq("-i", argv[i]) || streq("--inspect", argv[i])) {
if (verbose)
report_add_message(REPORT_LAST_TIMESTAMP, "Just displaying damage events until timeout\n");
continue;
}
/* */
if (streq("-u", argv[i]) || streq("--user", argv[i]) ||
(xrecord.motion = (streq("-U", argv[i]) || streq("--user-all", argv[i])) ) ) {
xinput_init(xhandler.display);
if (verbose)
report_add_message(REPORT_LAST_TIMESTAMP, "Reporting user input events\n");
continue;
}
if (streq(argv[i], "-r") || streq(argv[i], "--response")) {
if (++i >= argc)
usage(argv[0]);
char option[500];
cnt = sscanf(argv[i], "%u,%s", &response.timeout, option);
if (cnt < 1) {
fprintf(stderr, "*** invalid response timeout value '%s'\n", argv[i]);
usage(argv[0]);
}
if (cnt < 2) {
report_set_silent(true);
} else {
if (strcmp(option, "verbose")) {
fprintf(stderr, "*** invalid response option '%s'\n", argv[i]);
usage(argv[0]);
}
}
application_monitor_screen();
xinput_init(xhandler.display);
if (verbose)
report_add_message(REPORT_LAST_TIMESTAMP, "Monitoring application response time\n");
continue;
}
fprintf(stderr, "*** Dont understand %s\n", argv[i]);
usage(argv[0]);
}
/* start monitoring the root window if no targets are specified */
if ((window_empty() && application_empty()) || response.timeout) {
application_monitor(ROOT_WINDOW_RESOURCE);
}
window_monitor_all();
application_start_monitor();
/* eat first damage event when options.break_on_damage set */
if (options.break_on_damage)
xhandler_eat_damage();
/* monitor the whole screen of no area is specified */
if (!options.interested_damage_rect.width && !options.interested_damage_rect.height && !options.interested_damage_rect.x
&& !options.interested_damage_rect.y) {
options.interested_damage_rect.x = 0;
options.interested_damage_rect.y = 0;
options.interested_damage_rect.width = DisplayWidth(xhandler.display, DefaultScreen(xhandler.display));
options.interested_damage_rect.height = DisplayHeight(xhandler.display, DefaultScreen(xhandler.display));
}
/* emulate user input */
for (iEvent = 0; iEvent < inputEventsIndex; iEvent++) {
i = inputEvents[iEvent];
if (!strcmp("-c", argv[i]) || !strcmp("--click", argv[i])) {
unsigned long delay = 0;
Time start = 0;
cnt = sscanf(argv[++i], "%ux%u,%lu", &x, &y, &delay);
if (cnt == 2) {
start = xhandler_get_server_time();
report_add_message(start, "Using no delay between press/release\n");
delay = 0;
} else if (cnt != 3) {
fprintf(stderr, "cnt: %d\n", cnt);
fprintf(stderr, "*** failed to parse '%s'\n", argv[i]);
usage(argv[0]);
}
/* Send the event */
start = xemu_button_event(x, y, delay);
report_add_message(start, "Clicked %ix%i\n", x, y);
continue;
}
if (!strcmp("-d", argv[i]) || !strcmp("--drag", argv[i])) {
Time drag_time;
char *s = NULL, *p = NULL;
int button_state = XR_BUTTON_STATE_PRESS;
s = p = argv[++i];
int delay = DEFAULT_DRAG_DELAY;
int x1, y1, x2, y2;
while (p) {
p = strchr(s, ',');
if (p) {
*p++ = '\0';
}
int count = DEFAULT_DRAG_COUNT;
cnt = sscanf(s, "%ix%i-%ix%i*%i+%i", &x1, &y1, &x2, &y2, &delay, &count);
if (cnt >= 4) {
drag_time = xemu_drag_event(x1, y1, button_state, delay);
button_state = XR_BUTTON_STATE_NONE;
report_add_message(drag_time, "Dragged to %ix%i\n", x1, y1);
int xdev = (x2 - x1) / (count + 1);
int ydev = (y2 - y1) / (count + 1);
for (i = 1; i <= count; i++) {
x = x1 + xdev * i;
y = y1 + ydev * i;
drag_time = xemu_drag_event(x, y, button_state, delay);
report_add_message(drag_time, "Dragged to %ix%i\n", x, y);
}
if (!p) button_state = XR_BUTTON_STATE_RELEASE;
drag_time = xemu_drag_event(x2, y2, button_state, delay);
report_add_message(drag_time, "Dragged to %ix%i\n", x2, y2);
}
else if (cnt == 2) {
/* Send the event */
if (!p) {
if (button_state == XR_BUTTON_STATE_PRESS) {
fprintf(stderr, "*** Need at least 2 drag points!\n");
usage(argv[0]);
}
button_state = XR_BUTTON_STATE_RELEASE;
}
drag_time = xemu_drag_event(x1, y1, button_state, delay);
report_add_message(drag_time, "Dragged to %ix%i\n", x1, y1);
/* Make sure button state set to none after first point */
button_state = XR_BUTTON_STATE_NONE;
/* reset the delay to default value */
delay = DEFAULT_DRAG_DELAY;
} else if (cnt == 1) {
delay = x1;
} else {
fprintf(stderr, "*** failed to parse '%s'\n", argv[i]);
usage(argv[0]);
}
s = p;
}
continue;
}
if (!strcmp("-k", argv[i]) || !strcmp("--key", argv[i])) {
char *key = NULL;
char separator;
unsigned long delay = 0;
Time start = 0;
cnt = sscanf(argv[++i], "%a[^,]%c%lu", &key, &separator, &delay);
if (cnt == 1) {
report_add_message(REPORT_LAST_TIMESTAMP, "Using default delay between press/release\n", delay);
delay = DEFAULT_KEY_DELAY;
} else if (cnt != 3 || separator != ',') {
fprintf(stderr, "cnt: %d\n", cnt);
fprintf(stderr, "*** failed to parse '%s'\n", argv[i]);
if (key != NULL)
free(key);
usage(argv[0]);
}
start = xemu_send_key(key, delay);
report_add_message(start, "Simulating keypress/-release pair (keycode '%s')\n", key);
free(key);
continue;
}
if (!strcmp("-t", argv[i]) || !strcmp("--type", argv[i])) {
Time start = xemu_send_string(argv[++i]);
report_add_message(start, "Simulated keys for '%s'\n", argv[i]);
continue;
}
}
/* setting the default wait period */
if (options.damage_wait_secs < 0) {
options.damage_wait_secs = 5;
}
signal(SIGINT, abort_wait);
/* wait for damage events */
rc = wait_response();
scheduler_fini();
report_flush_queue();
report_fini();
xinput_fini();
xemu_fini();
window_fini();
application_fini();
xhandler_fini();
return rc;
}
int main(int argc, char ** argv){
MPI_Init(&argc, &argv);
// Default values
struct args args;
args.procs.nn = 0;
args.procs.ppn = 0;
args.dgeom_size = 0;
args.dgeom = NULL;
args.bgeom_size = 0;
args.bgeom = NULL;
args.cgeom_size = 0;
args.cgeom = NULL;
args.testfn = NULL;
args.write_test = 0;
args.read_test = 0;
args.report_type = REPORT_HUMAN;
args.par_access = NC_INDEPENDENT;
args.is_unlimited = 0;
args.verify = 0;
args.fill_value = 0;
char * dg = NULL, * bg = NULL, *cg = NULL, *iot = "ind", *xf = "human";
option_help options [] = {
{'n' , "nn" , "Number of nodes" , OPTION_OPTIONAL_ARGUMENT , 'd' , & args.procs.nn} ,
{'p' , "ppn" , "Number of processes" , OPTION_OPTIONAL_ARGUMENT , 'd' , & args.procs.ppn} ,
{'d' , "data-geometry" , "Data geometry (t:x:y:z)" , OPTION_OPTIONAL_ARGUMENT , 's' , & dg} ,
{'b' , "block-geometry" , "Block geometry (t:x:y:z)" , OPTION_OPTIONAL_ARGUMENT , 's' , & bg} ,
{'c' , "chunk-geometry" , "Chunk geometry (t:x:y:z|auto)" , OPTION_OPTIONAL_ARGUMENT , 's' , & cg} ,
{'r' , "read" , "Enable read benchmark" , OPTION_FLAG , 'd' , & args.read_test} ,
{'w' , "write" , "Enable write benchmark" , OPTION_FLAG , 'd' , & args.write_test} ,
{'t' , "io-type" , "Independent / Collective I/O (ind|coll)" , OPTION_OPTIONAL_ARGUMENT , 's' , & iot} ,
{'u' , "unlimited" , "Enable unlimited time dimension" , OPTION_FLAG , 'd' , & args.is_unlimited} ,
{'f' , "testfile" , "Filename of the testfile" , OPTION_OPTIONAL_ARGUMENT , 's' , & args.testfn} ,
{'x' , "output-format" , "Output-Format (parser|human)" , OPTION_OPTIONAL_ARGUMENT , 's' , & xf} ,
{'F' , "use-fill-value" , "Write a fill value" , OPTION_FLAG , 'd', & args.fill_value} ,
{0 , "verify" , "Verify that the data read is correct (reads the data again)", OPTION_FLAG , 'd' , & args.verify} ,
LAST_OPTION
};
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, & rank);
// check the correctness of the options only for rank 0
if (rank == 0){
printf("Benchtool (datatype: %s) \n", xstr(DATATYPE));
parseOptions(argc, argv, options);
}
MPI_Barrier(MPI_COMM_WORLD);
if (rank != 0){
parseOptions(argc, argv, options);
}
parse_dims(dg, &args.dgeom, &args.dgeom_size);
parse_dims(bg, &args.bgeom, &args.bgeom_size);
if ((0 == strcmp(iot, "c")) | (0 == strcmp(iot, "coll")) | (0 == strcmp(iot,"collective"))) {
args.par_access = NC_COLLECTIVE;
}
else if ((0 == strcmp(iot, "i")) | (0 == strcmp(iot, "ind")) | (0 == strcmp(iot, "independent"))) {
args.par_access = NC_INDEPENDENT;
}
else {
FATAL_ERR("Unsupported parallel access type %s\n", xf);
}
if (0 == strcmp(xf, "parser")) {
args.report_type = REPORT_PARSER;
}else if (0 == strcmp(xf, "human")) {
args.report_type = REPORT_HUMAN;
}else{
FATAL_ERR("Unsupported report type %s\n", xf);
}
if (0 == args.procs.nn) {
char *end = NULL;
const char* env = getenv("SLURM_NNODES");
if (NULL != env) {
args.procs.nn = strtol(env, &end, 10);
}
if (0 == args.procs.nn) {
args.procs.nn = 1;
}
}
if (0 == args.procs.ppn) {
char *end = NULL;
const char* env = getenv("SLURM_NTASKS_PER_NODE");
if (NULL != env) {
args.procs.ppn = strtol(env, &end, 10);
}
if (0 == args.procs.ppn) {
args.procs.ppn = 1;
}
}
if (NULL == args.testfn) {
const char* testfn = "./testfn.nc";
args.testfn = (char*)malloc(sizeof(*args.testfn) * strlen(testfn) + 1);
strcpy(args.testfn, testfn);
}
if (NULL == args.dgeom) {
args.dgeom_size = NDIMS;
args.dgeom = (size_t*)malloc(sizeof(*args.dgeom) * args.dgeom_size);
args.dgeom[DT] = 100;
args.dgeom[DX] = args.procs.nn * 100;
args.dgeom[DY] = args.procs.ppn * 100;
args.dgeom[DZ] = 10;
}
if (NDIMS != args.dgeom_size) {
FATAL_ERR("Found %zu dimensions (expected %d).\n", args.dgeom_size, NDIMS);
}
// Automatic block layout
if (NULL == args.bgeom) {
args.bgeom_size = args.dgeom_size;
args.bgeom = (size_t*)malloc(sizeof(*args.bgeom) * args.bgeom_size);
args.bgeom[DT] = 1;
args.bgeom[DX] = args.dgeom[DX] / args.procs.nn;
args.bgeom[DY] = args.dgeom[DY] / args.procs.ppn;
args.bgeom[DZ] = args.dgeom[DZ];
}
if (cg != NULL && 0 == strcmp(cg, "auto")) {
args.cgeom_size = args.bgeom_size;
args.cgeom = (size_t*)malloc(sizeof(*args.cgeom) * args.cgeom_size);
args.cgeom[DT] = 1;
args.cgeom[DX] = args.bgeom[DX];
args.cgeom[DY] = args.bgeom[DY];
args.cgeom[DZ] = args.bgeom[DZ];
}
else {
parse_dims(cg, &args.cgeom, &args.cgeom_size);
}
if (NDIMS != args.bgeom_size) {
FATAL_ERR("Found %zu dimensions (expected %d).\n", args.bgeom_size, NDIMS);
}
if (NULL != args.cgeom) {
if (NDIMS != args.cgeom_size) {
FATAL_ERR("Found %zu dimensions (expected %d).\n", args.cgeom_size, NDIMS);
}
}
DEBUG_MESSAGE("dgeom (%zu:%zu:%zu:%zu)\n", args.dgeom[DT], args.dgeom[DX], args.dgeom[DY], args.dgeom[DZ]);
DEBUG_MESSAGE("bgeom (%zu:%zu:%zu:%zu)\n", args.bgeom[DT], args.bgeom[DX], args.bgeom[DY], args.bgeom[DZ]);
if (NULL != args.cgeom) {
DEBUG_MESSAGE("cgeom (%zu:%zu:%zu:%zu)\n", args.cgeom[DT], args.cgeom[DX], args.cgeom[DY], args.cgeom[DZ]);
}
DEBUG_MESSAGE("(nn %zu, ppn %zu)\n", args.procs.nn, args.procs.ppn);
DEBUG_MESSAGE("test filename %s\n", args.testfn);
if (args.dgeom[DX] % args.procs.nn != 0) {
FATAL_ERR("x must be a multiple of number of nodes.\n");
}
if (args.dgeom[DY] % args.procs.ppn != 0) {
FATAL_ERR("y must be a multiple of number of processes.\n");
}
if (NULL != args.cgeom) {
if (args.dgeom[DT] % args.cgeom[DT] != 0) {
FATAL_ERR("Time range must be a multiple of time slice (range=%zu; slice=%zu)\n", args.dgeom[DT], args.cgeom[DT]);
}
}
int nranks = 0;
MPI_Comm_size(MPI_COMM_WORLD, &nranks);
if (nranks != args.procs.nn * args.procs.ppn){
FATAL_ERR("Bad environment: np != nn * ppn; np(size of MPI_COMM_WORLD)=%d, nodes(nn)=%zu, ppn(procs per node)=%zu\n",
nranks, args.procs.nn, args.procs.ppn);
}
if ((args.read_test == false) & (args.write_test == false) & (args.verify == false)) {
args.write_test = true;
}
benchmark_t wbm;
benchmark_init(&wbm);
int header_printed = 0;
benchmark_t rbm;
benchmark_init(&rbm);
if (args.write_test || args.verify) {
benchmark_setup(&wbm, args.procs, NDIMS, args.dgeom, args.bgeom, args.cgeom, args.testfn, IO_MODE_WRITE, args.par_access, args.is_unlimited, args.fill_value);
if(rank == 0){
print_header(& wbm);
header_printed = 1;
}
}
if (args.write_test) {
benchmark_run(&wbm, NULL);
report_t report;
report_init(&report);
report_setup(&report, &wbm);
report_print(&report, args.report_type);
report_destroy(&report);
}
if (args.read_test) {
int ret;
benchmark_setup(&rbm, args.procs, NDIMS, args.dgeom, args.bgeom, args.cgeom, args.testfn, IO_MODE_READ, args.par_access, args.is_unlimited, 0);
if(rank == 0 && ! header_printed){
print_header(& rbm);
header_printed = 1;
}
ret = benchmark_run(&rbm, args.verify ? wbm.block : NULL );
report_t report;
report_init(&report);
report_setup(&report, &rbm);
report_print(&report, args.report_type);
report_destroy(&report);
}else if (args.verify) {
int ret;
benchmark_setup(& rbm, args.procs, NDIMS, args.dgeom, args.bgeom, args.cgeom, args.testfn, IO_MODE_READ, args.par_access, args.is_unlimited, 0);
if(rank == 0 && ! header_printed){
print_header(& rbm);
header_printed = 1;
}
ret = benchmark_run(& rbm, wbm.block);
if (args.verify){
if (ret) {
printf("TEST PASSED [%u]\n", wbm.rank);
}
else {
printf("TEST FAILED [%u]\n", wbm.rank);
}
}
}
MPI_Finalize();
benchmark_destroy(&wbm);
benchmark_destroy(&rbm);
free(args.dgeom);
free(args.bgeom);
free(args.cgeom);
free(args.testfn);
return 0;
}
int main(void)
{
char wdrst = 0;
uint8_t mcusr;
mcusr = MCUSR;
if ( mcusr & _BV(WDRF) ) {
wdrst = 1;
}
MCUSR = 0;
wdt_disable();
cli();
#ifdef LED1
LED1 = 1;
#endif
uart_init(UART_BAUD_SELECT_DOUBLE_SPEED(115200,F_CPU));
stdout = &mystdout;
sei();
if ( wdrst ) {
kputs("\n***WATCHDOG RESET***\n");
}
wdt_enable(WDTO_8S);
wdt_reset();
kputs("\nSetting DDR registers\n");
DDRA = DDRA_SETTING;
DDRB = DDRB_SETTING;
DDRC = DDRC_SETTING;
DDRD = DDRD_SETTING;
DIDR0 = 0;
DIDR1 = 0;
/*
kputs("Hi i2c\n");
i2c_init();
kputs("Hi humid\n");
humid_init();
humid_sleep();
kputs("Hi accel\n");
accel_init();
accel_sleep();
kputs("Hi light\n");
light_init();
light_sleep();
kputs("Hi PIR\n");
pir_wake();
kputs("Hi RTC\n");
rtctimer_init();
kputs("Go away RTC\n");
DDRC &= 0x3F;
PORTC |= 0xC0;
kputs("Go to sleep\n");
uart_flush();
ACSR = (1<<ACD);
LED1 = LED2 = 0;
cli();
wdt_disable();
SMCR = (2<<SM0) | (1<<SE); //Enable Power-Down Mode
while(1) {
asm volatile ("sleep"); // __sleep(); // Go to sleep
}
*/
kputs("Initializing PCINT\n");
pcint_init();
kputs("Initializing Reports\n");
report_init();
board_init_devices();
kputs("Initializing wireless mote\n");
wdt_reset();
datalink_init();
/*
PIR_VCC = 1;
while(1) {
if(PIR_OUT_PIN) {
kputs("ON\n");
} else {
kputs("OFF\n");
}
_delay_ms(50);
}*/
kputs("Powering down all devices\n");
board_power_down_devices();
kputs("Init logic subsystem\n");
logic_init();
/*
kputs("Turning on always-on devices\n");
pir_wake();
accel_wake();
*/
board_setup_reporting();
kputs("Starting RTC clock\n");
rtctimer_init();
rtctimer_set_periodic_alarm(report_interval_needed(),&rtc_timer_cb);
wdt_reset();
wdt_disable();
while(1)
{
//wdt_enable(WDTO_2S);
//wdt_reset();
pcint_check();
rtctimer_check_alarm();
wdt_disable();
datalink_tick();
#ifdef USE_PN532
rtc_timer_cb(); // causes monitor list to be run
#else
#if defined LOW_POWER // do we have a RTC clock and battery-powered
avr_sleep();
#else
avr_doze();
#endif
#endif
}
}
int
main(int argc, char **argv)
{
int timeout;
struct bootp *bp;
struct servent *servp;
struct hostent *hep;
char *stmp;
socklen_t ba_len, ra_len;
int n;
int nfound;
struct pollfd set[1];
int standalone;
progname = strrchr(argv[0], '/');
if (progname) progname++;
else progname = argv[0];
/*
* Initialize logging.
*/
report_init(0); /* uses progname */
/*
* Log startup
*/
report(LOG_INFO, "version %s.%d", VERSION, PATCHLEVEL);
/* Debugging for compilers with struct padding. */
assert(sizeof(struct bootp) == BP_MINPKTSZ);
/* Get space for receiving packets and composing replies. */
pktbuf = malloc(MAX_MSG_SIZE);
if (!pktbuf) {
report(LOG_ERR, "malloc failed");
exit(1);
}
bp = (struct bootp *) pktbuf;
/*
* Check to see if a socket was passed to us from inetd.
*
* Use getsockname() to determine if descriptor 0 is indeed a socket
* (and thus we are probably a child of inetd) or if it is instead
* something else and we are running standalone.
*/
s = 0;
ba_len = sizeof(bind_addr);
bzero((char *) &bind_addr, ba_len);
errno = 0;
standalone = TRUE;
if (getsockname(s, (struct sockaddr *) &bind_addr, &ba_len) == 0) {
/*
* Descriptor 0 is a socket. Assume we are a child of inetd.
*/
if (bind_addr.sin_family == AF_INET) {
standalone = FALSE;
bootps_port = ntohs(bind_addr.sin_port);
} else {
/* Some other type of socket? */
report(LOG_INFO, "getsockname: not an INET socket");
}
}
/*
* Set defaults that might be changed by option switches.
*/
stmp = NULL;
timeout = actualtimeout;
gethostname(myhostname, sizeof(myhostname));
myhostname[sizeof(myhostname) - 1] = '\0';
hep = gethostbyname(myhostname);
if (!hep) {
printf("Can not get my IP address\n");
exit(1);
}
bcopy(hep->h_addr, (char *)&my_ip_addr, sizeof(my_ip_addr));
/*
* Read switches.
*/
for (argc--, argv++; argc > 0; argc--, argv++) {
if (argv[0][0] != '-')
break;
switch (argv[0][1]) {
case 'd': /* debug level */
if (argv[0][2]) {
stmp = &(argv[0][2]);
} else if (argv[1] && argv[1][0] == '-') {
/*
* Backwards-compatible behavior:
* no parameter, so just increment the debug flag.
*/
debug++;
break;
} else {
argc--;
argv++;
stmp = argv[0];
}
if (!stmp || (sscanf(stmp, "%d", &n) != 1) || (n < 0)) {
fprintf(stderr,
"%s: invalid debug level\n", progname);
break;
}
debug = n;
break;
case 'h': /* hop count limit */
if (argv[0][2]) {
stmp = &(argv[0][2]);
} else {
argc--;
argv++;
stmp = argv[0];
}
if (!stmp || (sscanf(stmp, "%d", &n) != 1) ||
(n < 0) || (n > 16))
{
fprintf(stderr,
"bootpgw: invalid hop count limit\n");
break;
}
maxhops = (u_int)n;
break;
case 'i': /* inetd mode */
standalone = FALSE;
break;
case 's': /* standalone mode */
standalone = TRUE;
break;
case 't': /* timeout */
if (argv[0][2]) {
stmp = &(argv[0][2]);
} else {
argc--;
argv++;
stmp = argv[0];
}
if (!stmp || (sscanf(stmp, "%d", &n) != 1) || (n < 0)) {
fprintf(stderr,
"%s: invalid timeout specification\n", progname);
break;
}
actualtimeout = n * 60000;
/*
* If the actual timeout is zero, pass INFTIM
* to poll so it blocks indefinitely, otherwise,
* use the actual timeout value.
*/
timeout = (n > 0) ? actualtimeout : INFTIM;
break;
case 'w': /* wait time */
if (argv[0][2]) {
stmp = &(argv[0][2]);
} else {
argc--;
argv++;
stmp = argv[0];
}
if (!stmp || (sscanf(stmp, "%d", &n) != 1) ||
(n < 0) || (n > 60))
{
fprintf(stderr,
"bootpgw: invalid wait time\n");
break;
}
minwait = (u_int)n;
break;
default:
fprintf(stderr, "%s: unknown switch: -%c\n",
progname, argv[0][1]);
usage();
break;
} /* switch */
} /* for args */
/* Make sure server name argument is suplied. */
servername = argv[0];
if (!servername) {
fprintf(stderr, "bootpgw: missing server name\n");
usage();
}
/*
* Get address of real bootp server.
*/
if (inet_aton(servername, &serv_addr.sin_addr) == 0) {
hep = gethostbyname(servername);
if (!hep) {
fprintf(stderr, "bootpgw: can't get addr for %s\n", servername);
exit(1);
}
memcpy(&serv_addr.sin_addr, hep->h_addr,
sizeof(serv_addr.sin_addr));
}
if (standalone) {
/*
* Go into background and disassociate from controlling terminal.
* XXX - This is not the POSIX way (Should use setsid). -gwr
*/
if (debug < 3) {
if (fork())
exit(0);
#ifdef NO_SETSID
setpgrp(0,0);
#ifdef TIOCNOTTY
n = open("/dev/tty", O_RDWR);
if (n >= 0) {
ioctl(n, TIOCNOTTY, (char *) 0);
(void) close(n);
}
#endif /* TIOCNOTTY */
#else /* SETSID */
if (setsid() < 0)
perror("setsid");
#endif /* SETSID */
} /* if debug < 3 */
/*
* Nuke any timeout value
*/
timeout = INFTIM;
/*
* Here, bootpd would do:
* chdir
* tzone_init
* rdtab_init
* readtab
*/
/*
* Create a socket.
*/
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
report(LOG_ERR, "socket: %s", get_network_errmsg());
exit(1);
}
/*
* Get server's listening port number
*/
servp = getservbyname("bootps", "udp");
if (servp) {
bootps_port = ntohs((u_short) servp->s_port);
} else {
bootps_port = (u_short) IPPORT_BOOTPS;
report(LOG_ERR,
"udp/bootps: unknown service -- assuming port %d",
bootps_port);
}
/*
* Bind socket to BOOTPS port.
*/
bind_addr.sin_family = AF_INET;
bind_addr.sin_port = htons(bootps_port);
bind_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(s, (struct sockaddr *) &bind_addr,
sizeof(bind_addr)) < 0)
{
report(LOG_ERR, "bind: %s", get_network_errmsg());
exit(1);
}
} /* if standalone */
/*
* Get destination port number so we can reply to client
*/
servp = getservbyname("bootpc", "udp");
if (servp) {
bootpc_port = ntohs(servp->s_port);
} else {
report(LOG_ERR,
"udp/bootpc: unknown service -- assuming port %d",
IPPORT_BOOTPC);
bootpc_port = (u_short) IPPORT_BOOTPC;
}
/* no signal catchers */
/*
* Process incoming requests.
*/
set[0].fd = s;
set[0].events = POLLIN;
for (;;) {
nfound = poll(set, 1, timeout);
if (nfound < 0) {
if (errno != EINTR) {
report(LOG_ERR, "poll: %s", get_errmsg());
}
continue;
}
if (nfound == 0) {
report(LOG_INFO, "exiting after %d minute%s of inactivity",
actualtimeout / 60000,
actualtimeout == 60000 ? "" : "s");
exit(0);
}
ra_len = sizeof(clnt_addr);
n = recvfrom(s, pktbuf, MAX_MSG_SIZE, 0,
(struct sockaddr *) &clnt_addr, &ra_len);
if (n <= 0) {
continue;
}
if (debug > 3) {
report(LOG_INFO, "recvd pkt from IP addr %s",
inet_ntoa(clnt_addr.sin_addr));
}
if (n < (int)sizeof(struct bootp)) {
if (debug) {
report(LOG_INFO, "received short packet");
}
continue;
}
pktlen = n;
switch (bp->bp_op) {
case BOOTREQUEST:
handle_request();
break;
case BOOTREPLY:
handle_reply();
break;
}
}
}