static void
gui_do_fork()
{
-#ifdef __QNXNTO__
+#if 0
procmgr_daemon(0, PROCMGR_DAEMON_KEEPUMASK | PROCMGR_DAEMON_NOCHDIR |
PROCMGR_DAEMON_NOCLOSE | PROCMGR_DAEMON_NODEVNULL);
gui_attempt_start();
int main(int argc, char *argv[]) {
dispatch_t *dpp;
resmgr_context_t *ctp;
resmgr_attr_t res_attr;
resmgr_connect_funcs_t connect_funcs1;
resmgr_connect_funcs_t connect_funcs2;
resmgr_io_funcs_t io_funcs1;
resmgr_io_funcs_t io_funcs2;
struct slogdev *trp;
int daemon_flag = 0;
// Parse any options.
options(argc, argv);
//
// Buffer allocation.
// The design puts all the data structures in one big contiguious
// chunk of memory. Makes it easy to analyze if it was in a memory
// mapped SRAM card which survives a crash or power failure.
//
trp = &SlogDev;
trp->beg = malloc(NumInts*sizeof(int));
trp->end = trp->beg + NumInts;
if(trp->beg == NULL) {
fprintf(stderr, "%s: Insufficient memory to allocate buffers.\n", __progname);
exit(EXIT_FAILURE);
}
slogger_init(trp);
// Create a dispatch context to receive messages.
if((dpp = dispatch_create()) == NULL) {
fprintf(stderr, "%s: Unable to allocate dispatch context\n", __progname);
exit(EXIT_FAILURE);
}
// Init resmgr attributes
memset(&res_attr, 0, sizeof res_attr);
res_attr.nparts_max = 2;
// All slogf/slogb calls should fit in the intial receive
res_attr.msg_max_size = _SLOG_MAXSIZE + _SLOG_HDRINTS + sizeof(io_msg_t);
// Init funcs for handling /dev/slog messages
iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect_funcs1, _RESMGR_IO_NFUNCS, &io_funcs1);
connect_funcs1.unlink = io_unlink;
io_funcs1.read = io_read;
io_funcs1.write = io_write;
io_funcs1.unblock = io_unblock;
// Create /dev/slog in the pathname space. At this point we can get opens.
iofunc_attr_init(&trp->attr, S_IFCHR | 0666, 0, 0);
if((trp->id = resmgr_attach(dpp, &res_attr, "/dev/slog", _FTYPE_ANY, _RESMGR_FLAG_SELF,
&connect_funcs1, &io_funcs1, &trp->attr)) == -1) {
fprintf(stderr, "%s: Unable to allocate device %s (%s)\n", __progname, "/dev/slog", strerror(errno));
exit(EXIT_FAILURE);
}
// Init funcs for handling /dev/slog messages
iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect_funcs2, _RESMGR_IO_NFUNCS, &io_funcs2);
io_funcs2.write = io_console_write;
// Create /dev/console in the pathname space. At this point we can get opens.
if(resmgr_attach(dpp, &res_attr, "/dev/console", _FTYPE_ANY, 0,
&connect_funcs2, &io_funcs2, &trp->attr) == -1) {
fprintf(stderr, "%s: Unable to allocate device %s (%s)\n", __progname, "/dev/console", strerror(errno));
exit(EXIT_FAILURE);
}
// If a logfile was specified then create a thread to write it
if(LogFname) {
sigset_t signalset;
if(pthread_create(0, NULL, &logger, NULL) != 0) {
fprintf(stderr, "%s: Unable to create logger thread.\n", __progname);
exit(EXIT_FAILURE);
}
// We want the logger thread to catch signals. Not us!
sigemptyset(&signalset);
sigfillset(&signalset);
pthread_sigmask(SIG_BLOCK, &signalset, NULL);
}
// Run in backgound
if(Verbose) {
daemon_flag = PROCMGR_DAEMON_NODEVNULL;
}
if (procmgr_daemon(EXIT_SUCCESS, daemon_flag) == -1) {
fprintf(stderr, "%s: Couldn't become daemon.\n", argv[0]);
}
// Slogger is single-threaded
ctp = resmgr_context_alloc(dpp);
for(;;) {
if((ctp = resmgr_block(ctp)) == NULL)
exit(EXIT_FAILURE);
resmgr_handler(ctp);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int c;
char *size_suffix;
pid_t process = 0;
dispatch_t *dpp;
resmgr_attr_t resmgr_attr;
resmgr_context_t *ctp;
umask(0222);
/* We want some pshysical memory reserved for dumper process. */
init_memory();
/* We also want some physical memory for our stack. */
init_stack();
while ( (c = getopt( argc, argv, "Dd:p:ns:vmPwtz:" )) != -1 ) {
switch(c) {
case 'd':
dump_dir = optarg;
break;
case 'n':
sequential_dumps = 1;
break;
case 'p':
process = atoi(optarg);
break;
case 's':
max_core_size = strtol(optarg, &size_suffix, 10);
switch(*size_suffix){
case 'g':
case 'G':
max_core_size *= 1024;
case 'm':
case 'M':
max_core_size *= 1024;
case 'k':
case 'K':
max_core_size *= 1024;
break;
case 0:
break;
default:
fprintf(stderr, "Warning: suffix '%c' unrecognized\n", *size_suffix);
}
break;
case 'v':
verbose = 1;
break;
case 'm':
nodumpmem = 1;
break;
case 'P':
nodumpphys = 0;
break;
case 't':
cur_tid_only = 1;
break;
case 'w':
world_readable = 1;
break;
case 'z':
gzlevel = strtol(optarg, &size_suffix, 10);
if (gzlevel < 1 || gzlevel > 9) {
fprintf(stderr, "Compress level must between 1 and 9.\n");
exit(EXIT_FAILURE);
}
break;
}
}
if ( process ) {
requested = 1;
return dump( ND_LOCAL_NODE, process, max_core_size );
}
if((dpp = dispatch_create()) == NULL) {
fprintf(stderr, "%s: Unable to allocate dispatch handle.\n",argv[0]);
exit(EXIT_FAILURE);
}
memset(&resmgr_attr, 0, sizeof resmgr_attr);
resmgr_attr.nparts_max = 1;
resmgr_attr.msg_max_size = 2048;
iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect, _RESMGR_IO_NFUNCS, &io);
io.write = dumper_write;
io.devctl = dumper_devctl;
io.close_ocb = dumper_close_ocb;
iofunc_attr_init(&attr, S_IFNAM | 0600, 0, 0);
if ( -1 == resmgr_attach(dpp, &resmgr_attr, "/proc/dumper", _FTYPE_DUMPER, 0, &connect, &io, &attr)) {
fprintf( stderr, "%s: Couldn't attach as /proc/dumper: %s\n", argv[0], strerror(errno) );
exit(EXIT_FAILURE);
}
if((ctp = resmgr_context_alloc(dpp)) == NULL) {
fprintf(stderr, "%s: Unable to allocate dispatch handle.\n",argv[0]);
exit(EXIT_FAILURE);
}
if ( -1 == procmgr_daemon(EXIT_SUCCESS, verbose ?
PROCMGR_DAEMON_NODEVNULL | PROCMGR_DAEMON_KEEPUMASK :
PROCMGR_DAEMON_KEEPUMASK) ) {
fprintf(stderr, "%s: Couldn't become daemon.\n",argv[0]);
exit(EXIT_FAILURE);
}
while(1) {
if((ctp = resmgr_block(ctp)) == NULL) {
fprintf(stderr, "block error\n");
exit(EXIT_FAILURE);
}
resmgr_handler(ctp);
}
return EXIT_SUCCESS;
}
int
begin(int argc, char *argv[])
{
int i, j;
uint32_t ph_flags = 0;
thread_pool_attr_t tp_attr;
static void *tpp;
dispatch_t *dpp;
dpp = dispatch_create();
if (dpp == NULL) {
char * pMsgTxt = "Error: cannot create dispatch interface\n";
fprintf(stderr, pMsgTxt);
slogf(_SLOG_SETCODE(_SLOGC_INPUT, 0), _SLOG_ERROR, pMsgTxt);
return (EXIT_FAILURE);
}
devi_set_dispatch_handle(dpp);
/* set up the module table */
if (modules != NULL) {
for (i = 0; i < MODULE_TABLE_SIZE && ModuleTable[i] != NULL;
i++)
;
/* add extra modules to end of ModuleTable */
for (j = 0; j < (MODULE_TABLE_SIZE - i) && modules[j] != NULL;
j++, i++)
ModuleTable[i] = modules[j];
}
if(ThreadCtl(_NTO_TCTL_IO, 0) == -1) {
errno_print("ThreadCtl");
return (EXIT_FAILURE);
}
// Call global callback if it was specified
if(commonCallbacks.pre_init && commonCallbacks.pre_init())
return (EXIT_FAILURE);
if (options(argc, argv, &ph_flags, &OptFlags) < 0)
return (EXIT_FAILURE);
// Call global callback if it was specified
if(commonCallbacks.post_init && commonCallbacks.post_init())
return (EXIT_FAILURE);
sig_install(signal_table, termination_hndlr);
if (procmgr_daemon(0, PROCMGR_DAEMON_NODEVNULL |
PROCMGR_DAEMON_NOCLOSE) < 0) {
errno_print("procmgr_daemon");
return (EXIT_FAILURE);
}
if (!(OptFlags & OPT_NO_PHOTON)) {
if (start_photon_interface(ph_flags) < 0) {
errno_print("unable to start photon interface");
return (EXIT_FAILURE);
}
}
memset(&tp_attr, 0, sizeof(tp_attr));
tp_attr.handle = devi_get_dispatch_handle();
tp_attr.context_alloc = dispatch_context_alloc;
tp_attr.block_func = dispatch_block;
tp_attr.handler_func = dispatch_handler;
tp_attr.context_free = dispatch_context_free;
/* We'd rather not to use thread pool for device driver - it could
cause desynchronizing and data losing */
tp_attr.lo_water = 1; /* min amount threads waiting blocked */
tp_attr.hi_water = 1; /* max amount threads waiting blocked */
tp_attr.increment = 1;
tp_attr.maximum = 1;
tpp = thread_pool_create(&tp_attr, POOL_FLAG_USE_SELF);
if (tpp == NULL) {
errno_print("thread_pool_create");
return (EXIT_FAILURE);
}
thread_pool_start(tpp);
return (EOK);
}
