static int do_ltt_statedump(struct ltt_probe_private_data *call_data)
{
int cpu;
printk(KERN_DEBUG "LTT state dump thread start\n");
ltt_enumerate_process_states(call_data);
ltt_enumerate_file_descriptors(call_data);
list_modules(call_data);
ltt_enumerate_vm_maps(call_data);
list_interrupts(call_data);
ltt_enumerate_network_ip_interface(call_data);
/*
* Fire off a work queue on each CPU. Their sole purpose in life
* is to guarantee that each CPU has been in a state where is was in
* syscall mode (i.e. not in a trap, an IRQ or a soft IRQ).
*/
lock_cpu_hotplug();
atomic_set(&kernel_threads_to_run, num_online_cpus());
work_wake_task = current;
__set_current_state(TASK_UNINTERRUPTIBLE);
for_each_online_cpu(cpu) {
INIT_DELAYED_WORK(&cpu_work[cpu], ltt_statedump_work_func);
schedule_delayed_work_on(cpu, &cpu_work[cpu], 0);
}
unlock_cpu_hotplug();
/* Wait for all threads to run */
schedule();
BUG_ON(atomic_read(&kernel_threads_to_run) != 0);
/* Our work is done */
printk(KERN_DEBUG "LTT state dump end\n");
__trace_mark(0, list_statedump_end, call_data, MARK_NOARGS);
return 0;
}
static int do_ltt_statedump(void)
{
int cpu;
printk(KERN_DEBUG "do_ltt_statedump\n");
ltt_enumerate_process_states();
ltt_enumerate_file_descriptors();
list_modules();
ltt_enumerate_vm_maps();
list_interrupts();
ltt_enumerate_network_ip_interface();
/* Fire off a work queue on each CPU. Their sole purpose in life
* is to guarantee that each CPU has been in a state where is was in
* syscall mode (i.e. not in a trap, an IRQ or a soft IRQ) */
lock_cpu_hotplug();
atomic_set(&kernel_threads_to_run, num_online_cpus());
__set_current_state(TASK_UNINTERRUPTIBLE);
for_each_online_cpu(cpu) {
INIT_WORK(&cpu_work[cpu], ltt_statedump_work_func, current);
schedule_delayed_work_on(cpu,&cpu_work[cpu],0);
}
unlock_cpu_hotplug();
/* Wait for all threads to run */
schedule();
BUG_ON(atomic_read(&kernel_threads_to_run) != 0);
/* Our work is done */
printk(KERN_DEBUG "trace_statedump_statedump_end\n");
trace_statedump_statedump_end();
return 0;
}
static struct snobj *handle_reset_modules(struct snobj *q)
{
struct module *m;
while (list_modules((const struct module **)&m, 1, 0))
destroy_module(m);
printf("*** All modules have been destroyed ***\n");
return NULL;
}
int parse_flags(int argc, char** argv, const char* d = nullptr)
{
if (argc <= 1) {
return run_modules(argv[0], verbosity::low);
}
else if (argc <= 3) {
auto arg1 = boost::string_ref{argv[1]};
if (arg1 == "-h" || arg1 == "--help") {
return print_help();
}
else if (arg1 == "-l" || arg1 == "--list-modules") {
return list_modules(argv[0], d);
}
else if (arg1 == "-v" || arg1 == "--verbosity") {
if (argc < 3) {
auto s = cc::format("Error: expected verbosity "
"level after ${quote} flag.", arg1);
return print_error(argc, argv, s);
}
auto arg2 = boost::string_ref{argv[2]};
if (arg2 == "low") {
return run_modules(argv[0], verbosity::low);
}
else if (arg2 == "medium") {
return run_modules(argv[0], verbosity::medium);
}
else if (arg2 == "high") {
return run_modules(argv[0], verbosity::high);
}
else {
auto s = cc::format("Error: invalid verbosity "
"level ${quote}.", argv[2]);
return print_error(argc, argv, s);
}
}
else {
auto s = cc::format("Error: unrecognized flag "
"${quote}.", arg1);
return print_error(argc, argv, s);
}
}
else {
return print_error(argc, argv, "Error: too many flags.");
}
}
static struct snobj *handle_list_modules(struct snobj *q)
{
struct snobj *r;
int cnt = 1;
int offset;
r = snobj_list();
for (offset = 0; cnt != 0; offset += cnt) {
const int arr_size = 16;
const struct module *modules[arr_size];
int i;
cnt = list_modules(modules, arr_size, offset);
for (i = 0; i < cnt; i++) {
const struct module *m = modules[i];
const struct mclass *mclass = m->mclass;
struct snobj *module = snobj_map();
snobj_map_set(module, "name",
snobj_str(m->name));
snobj_map_set(module, "mclass",
snobj_str(mclass->name));
if (mclass->get_desc) {
snobj_map_set(module, "desc",
mclass->get_desc(m));
}
snobj_list_add(r, module);
}
};
return r;
}
int
main (int argc,
char ** argv)
{
const char *module_name;
unsigned int n_pages;
vbi_bool all_pages;
init_helpers (argc, argv);
option_in_file_format = FILE_FORMAT_SLICED;
option_default_fg = (vbi_rgba) 0xFFFFFF;
option_default_bg = (vbi_rgba) 0x000000;
all_pages = FALSE;
for (;;) {
int c;
c = getopt_long (argc, argv, short_options,
long_options, &option_index);
if (-1 == c)
break;
switch (c) {
case 0: /* getopt_long() flag */
break;
case '1':
/* Compatibility (used to be pgno -1). */
all_pages = TRUE;
break;
case 'a':
/* For debugging. */
assert (NULL != optarg);
option_target = strtoul (optarg, NULL, 0);
break;
case 'c':
option_dcc = TRUE;
break;
case 'd':
option_padding = TRUE;
break;
case 'e':
option_pdc_enum = TRUE;
break;
case 'f':
option_fast = TRUE;
break;
case 'g':
option_dump_pg = TRUE;
break;
case 'h':
usage (stdout);
exit (EXIT_SUCCESS);
case 'i':
assert (NULL != optarg);
option_in_file_name = optarg;
break;
case 'l':
option_hyperlinks = TRUE;
break;
case 'm':
list_modules ();
exit (EXIT_SUCCESS);
case 'n':
option_navigation = TRUE;
break;
case 'o':
parse_output_option ();
break;
case 'p':
option_pdc_links = TRUE;
break;
case 'q':
parse_option_quiet ();
break;
case 'r':
option_row_update = TRUE;
break;
case 's':
option_subtitles = TRUE;
break;
case 'v':
parse_option_verbose ();
break;
case 'w':
option_delay += 1;
break;
case 'A':
option_panels = TRUE;
break;
case 'B':
assert (NULL != optarg);
option_default_bg = strtoul (optarg, NULL, 0);
break;
case 'C':
assert (NULL != optarg);
option_default_cs = strtoul (optarg, NULL, 0);
have_option_default_cs = TRUE;
break;
case 'F':
assert (NULL != optarg);
option_default_fg = strtoul (optarg, NULL, 0);
break;
case 'H':
option_header_only = TRUE;
break;
case 'O':
assert (NULL != optarg);
option_override_cs = strtoul (optarg, NULL, 0);
break;
case 'P':
option_in_file_format = FILE_FORMAT_DVB_PES;
break;
case 'T':
option_in_ts_pid = parse_option_ts ();
option_in_file_format = FILE_FORMAT_DVB_TS;
break;
case 'V':
printf (PROGRAM_NAME " " VERSION "\n");
exit (EXIT_SUCCESS);
default:
usage (stderr);
exit (EXIT_FAILURE);
}
}
option_pdc_links |= option_pdc_enum;
if (argc - optind < 1) {
usage (stderr);
exit (EXIT_FAILURE);
}
module_name = argv[optind++];
pt = vbi_page_table_new ();
if (NULL == pt)
no_mem_exit ();
if (all_pages) {
/* Compatibility. */
out_file_name_prefix = strdup ("test");
if (NULL == out_file_name_prefix)
no_mem_exit ();
} else {
parse_page_numbers (argc - optind, &argv[optind]);
}
n_pages = vbi_page_table_num_pages (pt);
if (1 != n_pages && option_delay > 0) {
error_exit (_("The --wait option requires "
"a single page number."));
}
if (NULL == out_file_name_prefix) {
switch (n_pages) {
case 0: /* all pages? */
error_exit (_("No page number or "
"output file name specified."));
break;
case 1: /* one page to stdout */
break;
default: /* multiple pages */
error_exit (_("No output file name specified."));
break;
}
}
init_export_module (module_name);
init_vbi_decoder ();
cr = isatty (STDERR_FILENO) ? '\r' : '\n';
rst = read_stream_new (option_in_file_name,
option_in_file_format,
option_in_ts_pid,
decode_frame);
stream_loop (rst);
stream_delete (rst);
rst = NULL;
vbi_decoder_delete (vbi);
vbi = NULL;
finalize ();
free (out_file_name_prefix);
out_file_name_prefix = NULL;
free (out_file_name_suffix);
out_file_name_suffix = NULL;
if (!option_subtitles) {
n_pages = vbi_page_table_num_pages (pt);
if (1 == n_pages) {
vbi_pgno pgno = 0;
vbi_page_table_next_page (pt, &pgno);
error_exit (_("End of stream. Page %03x not found."),
pgno);
} else if (n_pages > 0) {
error_exit (_("End of stream. %u pages not found."));
}
}
vbi_page_table_delete (pt);
pt = NULL;
vbi_export_delete (ex);
ex = NULL;
exit (EXIT_SUCCESS);
}
static void
mtev_capabilities_tobuff(mtev_capsvc_closure_t *cl, eventer_func_t curr) {
const char **mod_names;
struct utsname utsn;
char vbuff[128], bwstr[4];
mtev_hash_table *lc;
mtev_hash_iter iter = MTEV_HASH_ITER_ZERO;
const char *k;
int klen, i, nmods;
void *data;
struct timeval now;
struct dso_type *t;
xmlDocPtr xmldoc;
xmlNodePtr root, cmds, bi, ri, mods, feat;
/* fill out capabilities */
/* Create an XML Document */
xmldoc = xmlNewDoc((xmlChar *)"1.0");
root = xmlNewDocNode(xmldoc, NULL, (xmlChar *)capabilities_namespace, NULL);
xmlDocSetRootElement(xmldoc, root);
/* Fill in the document */
mtev_build_version(vbuff, sizeof(vbuff));
xmlNewTextChild(root, NULL, (xmlChar *)"version", (xmlChar *)vbuff);
snprintf(bwstr, sizeof(bwstr), "%d", (int)sizeof(void *)*8);
/* Build info */
bi = xmlNewNode(NULL, (xmlChar *)"unameBuild");
xmlSetProp(bi, (xmlChar *)"bitwidth", (xmlChar *)bwstr);
xmlAddChild(root, bi);
xmlNewTextChild(bi, NULL, (xmlChar *)"sysname", (xmlChar *)UNAME_S);
xmlNewTextChild(bi, NULL, (xmlChar *)"nodename", (xmlChar *)UNAME_N);
xmlNewTextChild(bi, NULL, (xmlChar *)"release", (xmlChar *)UNAME_R);
xmlNewTextChild(bi, NULL, (xmlChar *)"version", (xmlChar *)UNAME_V);
xmlNewTextChild(bi, NULL, (xmlChar *)"machine", (xmlChar *)UNAME_M);
/* Run info */
ri = xmlNewNode(NULL, (xmlChar *)"unameRun");
xmlSetProp(ri, (xmlChar *)"bitwidth", (xmlChar *)bwstr);
xmlAddChild(root, ri);
if(uname(&utsn) < 0) {
xmlNewTextChild(ri, NULL, (xmlChar *)"error", (xmlChar *)strerror(errno));
} else {
xmlNewTextChild(ri, NULL, (xmlChar *)"sysname", (xmlChar *)utsn.sysname);
xmlNewTextChild(ri, NULL, (xmlChar *)"nodename", (xmlChar *)utsn.nodename);
xmlNewTextChild(ri, NULL, (xmlChar *)"release", (xmlChar *)utsn.release);
xmlNewTextChild(ri, NULL, (xmlChar *)"version", (xmlChar *)utsn.version);
xmlNewTextChild(ri, NULL, (xmlChar *)"machine", (xmlChar *)utsn.machine);
}
/* features */
feat = xmlNewNode(NULL, (xmlChar *)"features");
xmlAddChild(root, feat);
if(mtev_hash_size(&features)) {
mtev_hash_iter iter2 = MTEV_HASH_ITER_ZERO;
void *vfv;
const char *f;
int flen;
while(mtev_hash_next(&features, &iter2, &f, &flen, &vfv)) {
xmlNodePtr featnode;
featnode = xmlNewNode(NULL, (xmlChar *)"feature");
xmlSetProp(featnode, (xmlChar *)"name", (xmlChar *)f);
if(vfv) xmlSetProp(featnode, (xmlChar *)"version", (xmlChar *)vfv);
xmlAddChild(feat, featnode);
}
}
/* time (poor man's time check) */
gettimeofday(&now, NULL);
snprintf(vbuff, sizeof(vbuff), "%llu.%03d", (unsigned long long)now.tv_sec,
(int)(now.tv_usec / 1000));
xmlNewTextChild(root, NULL, (xmlChar *)"current_time", (xmlChar *)vbuff);
cmds = xmlNewNode(NULL, (xmlChar *)"services");
xmlAddChild(root, cmds);
lc = mtev_listener_commands();
while(mtev_hash_next(lc, &iter, &k, &klen, &data)) {
xmlNodePtr cnode;
char hexcode[11];
const char *name;
eventer_func_t *f = (eventer_func_t *)k;
mtev_hash_table *sc = (mtev_hash_table *)data;
mtev_hash_iter sc_iter = MTEV_HASH_ITER_ZERO;
const char *sc_k;
int sc_klen;
void *sc_data;
name = eventer_name_for_callback(*f);
cnode = xmlNewNode(NULL, (xmlChar *)"service");
xmlSetProp(cnode, (xmlChar *)"name", name ? (xmlChar *)name : NULL);
if(*f == curr)
xmlSetProp(cnode, (xmlChar *)"connected", (xmlChar *)"true");
xmlAddChild(cmds, cnode);
while(mtev_hash_next(sc, &sc_iter, &sc_k, &sc_klen, &sc_data)) {
xmlNodePtr scnode;
char *name_copy, *version = NULL;
eventer_func_t *f = (eventer_func_t *)sc_data;
snprintf(hexcode, sizeof(hexcode), "0x%08x", *((u_int32_t *)sc_k));
name = eventer_name_for_callback(*f);
name_copy = strdup(name ? name : "[[unknown]]");
version = strchr(name_copy, '/');
if(version) *version++ = '\0';
scnode = xmlNewNode(NULL, (xmlChar *)"command");
xmlSetProp(scnode, (xmlChar *)"name", (xmlChar *)name_copy);
if(version)
xmlSetProp(scnode, (xmlChar *)"version", (xmlChar *)version);
xmlSetProp(scnode, (xmlChar *)"code", (xmlChar *)hexcode);
xmlAddChild(cnode, scnode);
free(name_copy);
}
}
mods = xmlNewNode(NULL, (xmlChar *)"modules");
xmlAddChild(root, mods);
#define list_modules(func, name) do { \
nmods = func(&mod_names); \
for(i=0; i<nmods; i++) { \
xmlNodePtr pnode; \
pnode = xmlNewNode(NULL, (xmlChar *)"module"); \
xmlSetProp(pnode, (xmlChar *)"type", (xmlChar *)name); \
xmlSetProp(pnode, (xmlChar *)"name", (xmlChar *)mod_names[i]); \
xmlAddChild(mods, pnode); \
} \
if(mod_names) free(mod_names); \
} while(0)
for(t = mtev_dso_get_types(); t; t = t->next)
list_modules(t->list, t->name);
/* Write it out to a buffer and copy it for writing */
cl->buff = mtev_xmlSaveToBuffer(xmldoc);
cl->towrite = strlen(cl->buff);
/* Clean up after ourselves */
xmlFreeDoc(xmldoc);
}
int main(int argc, const char **argv)
{
int i;
unsigned int pname;
const char *params[NUM_PARAMS];
memset(params, '\0', sizeof(params));
/* first of all check whether debugging should be enabled */
for (i = 0; i < argc; i++)
if (strcmp("debug", argv[i]) == 0) {
set_debug_level(1);
}
for (i = 1; i < argc; i++) {
for (pname = 0; pname < NUM_PARAMS; pname++) {
if (param_names[pname][pn_sizes[pname]-2] == '=') {
if (strncmp(argv[i], param_names[pname], pn_sizes[pname]-1) == 0) {
params[pname] = argv[i] + pn_sizes[pname] - 1;
}
else if (strncmp(argv[i], param_names[pname], pn_sizes[pname]-2) == 0
&& argv[i][pn_sizes[pname]-2] == '\0') {
params[pname] = (void *)1;
}
}
else {
if (strcmp(argv[i], param_names[pname]) == 0) {
params[pname] = (void *)1;
}
}
}
}
for (pname = 0; pname < NUM_PARAMS; pname++) {
if (params[pname] != NULL)
break;
}
if (pname == NUM_PARAMS) {
DBG("No correct parameter specified");
printf("usage: pkcs11_setup [list_modules] [use_module[=<module_name>]]\n"
" [ins_action[=<executable,executable,...>]]\n"
" [rm_action[=<executable,executable,...>]]\n");
}
if (params[LIST_MODULES] != NULL) {
DBG("List modules:");
return list_modules();
}
else {
if (params[USE_MODULE] == (void *)1) {
DBG("Print default module:");
if ((i=print_default_module()) != 0) {
ERR1("Print default module failed with: %d", i);
return i;
}
return 0;
}
else if (params[USE_MODULE] != NULL) {
DBG1("Set default module: %s", params[USE_MODULE]);
if ((i=set_default_module(params[USE_MODULE])) != 0) {
ERR1("Set default module failed with: %d", i);
return i;
}
}
if (params[INS_ACTION] == (void *)1) {
DBG("Print card insert action:");
if ((i=print_card_insert_action()) != 0) {
ERR1("Print card insert action failed with: %d", i);
return i;
}
return 0;
}
else if (params[INS_ACTION] != NULL) {
DBG1("Set card insert action: %s", params[INS_ACTION]);
if ((i=set_card_insert_action(params[INS_ACTION])) != 0) {
ERR1("Set card insert action failed with: %d", i);
return i;
}
}
if (params[RM_ACTION] == (void *)1) {
DBG("Print card remove action:");
if ((i=print_card_remove_action()) != 0) {
ERR1("Set card remove action failed with: %d", i);
return i;
}
return 0;
}
else if (params[RM_ACTION] != NULL) {
DBG1("Set card remove action: %s", params[RM_ACTION]);
if ((i=set_card_remove_action(params[RM_ACTION])) != 0) {
ERR1("Set card remove action failed with: %d", i);
return i;
}
}
}
DBG("Process completed");
return 0;
}
int main(int argc, char *argv[]){
char *t;
int fd;
char *tmp=NULL;
struct bsdconv_instance *ins;
FILE *inf=NULL, *otf=stdout;
int inplace=0;
int i;
if(argc<2){
fprintf(stderr, "Usage:\n\t %s conversion|-l [-i] [file] [...]\n\t\t-i:\tsave in-place\n\t\t-l:\tlist codecs\n", argv[0]);
exit(1);
}
i=2;
if(strcmp(argv[1],"-l")==0){
list_modules();
return 0;
}
if(argc>2) while(i<argc){
if(strcmp(argv[i],"-i")==0)
inplace=1;
else if(strcmp(argv[i],"-l")==0)
list_modules();
else
break;
i+=1;
}
#ifdef WIN32
setmode(STDIN_FILENO, O_BINARY);
setmode(STDOUT_FILENO, O_BINARY);
#endif
ins=bsdconv_create(argv[1]);
if(!ins){
t=bsdconv_error();
fprintf(stderr, "%s\n", t);
free(t);
exit(1);
}
if(i>=argc){
bsdconv_file(ins, stdin, stdout, NULL);
}else for(;i<argc;++i){
if(inplace){
inf=fopen(argv[i],"rb");
if(inf==NULL){
fprintf(stderr, "Failed opening file %s.\n", argv[i]);
bsdconv_destroy(ins);
exit(1);
}
tmp=malloc(strlen(argv[i])+8);
strcpy(tmp, argv[i]);
strcat(tmp, ".XXXXXX");
if((fd=mkstemp(tmp))==-1){
free(tmp);
fprintf(stderr, "Failed creating temp file.\n");
bsdconv_destroy(ins);
exit(1);
}
otf=fdopen(fd, "wb");
if(!otf){
fprintf(stderr, "Unable to open output file for %s\n", argv[i]);
bsdconv_destroy(ins);
exit(1);
}
#ifndef WIN32
struct stat stat;
fstat(fileno(inf), &stat);
fchown(fileno(otf), stat.st_uid, stat.st_gid);
fchmod(fileno(otf), stat.st_mode);
#endif
bsdconv_file(ins, inf, otf, argv[i]);
fclose(inf);
fclose(otf);
unlink(argv[i]);
rename(tmp,argv[i]);
free(tmp);
}else{
inf=fopen(argv[i],"rb");
if(inf==NULL){
fprintf(stderr, "Failed opening file %s.\n", argv[i]);
bsdconv_destroy(ins);
exit(1);
}
bsdconv_file(ins, inf, stdout, argv[i]);
fclose(inf);
}
}
bsdconv_destroy(ins);
return 0;
}
