void CThread::Run(void) { if (m_ThreadState != ctsRunning) { if (m_ThreadState == ctsSuspended) { cerr << "CThread::CThread(POSIX) - does not support thread sleeping!" << endl; } m_ThreadState = ctsRunning; #ifdef HAVE_PTH pth_attr_t l_ThreadAttributes = pth_attr_new(); pth_attr_set(l_ThreadAttributes, PTH_ATTR_NAME, "thread"); pth_attr_set(l_ThreadAttributes, PTH_ATTR_STACK_SIZE, 64*1024); pth_attr_set(l_ThreadAttributes, PTH_ATTR_JOINABLE, FALSE); m_ThreadID = pth_spawn(l_ThreadAttributes, &CThreadExecute, (void *) this); #else #ifndef _THREAD_DCE pthread_attr_t l_ThreadAttributes; pthread_attr_init(&l_ThreadAttributes); // pthread_attr_setscope(&l_ThreadAttributes, PTHREAD_SCOPE_SYSTEM); pthread_attr_setdetachstate(&l_ThreadAttributes, PTHREAD_CREATE_DETACHED); pthread_create(&m_ThreadID, &l_ThreadAttributes, &CThreadExecute, this); pthread_attr_destroy(&l_ThreadAttributes); #else pthread_create(&m_ThreadID, NULL, &CThreadExecute, this); ::pthread_detach(&m_ThreadID); #endif #endif m_ThreadState = ctsRunning; if (m_ThreadStartMutex) m_ThreadStartMutex->UnLock(); } else cerr << "CThread::CThread(POSIX) - call of Run() in an invalid state!" << endl; }
int ldap_int_thread_initialize( void ) { if( !pth_init() ) { return -1; } detach_attr = pth_attr_new(); joined_attr = pth_attr_new(); #ifdef LDAP_PVT_THREAD_SET_STACK_SIZE pth_attr_set( joined_attr, PTH_ATTR_STACK_SIZE, LDAP_PVT_THREAD_STACK_SIZE ); pth_attr_set( detach_attr, PTH_ATTR_STACK_SIZE, LDAP_PVT_THREAD_STACK_SIZE ); #endif return pth_attr_set( detach_attr, PTH_ATTR_JOINABLE, FALSE ); }
void mgt_dispatch_t::launch (int i, int fdout) { // warn << "mgt_dispatch_t::launch: " << i << "\n"; // debug int closeit; mtd_thread_arg_t *arg = launch_init (i, fdout, &closeit); pth_attr_t attr = pth_attr_new (); names[i] = strbuf ("dispatch thread ") << i; pth_attr_set (attr, PTH_ATTR_NAME, names[i].cstr ()); pth_attr_set (attr, PTH_ATTR_STACK_SIZE, MTD_STACKSIZE); pth_attr_set (attr, PTH_ATTR_JOINABLE, FALSE); if (!(gts[i] = pth_spawn (attr, amt_vnew_threadv, static_cast<void *> (arg)))) fatal << "mtdispatch::launch: pth_spawn failed\n"; }
TASK_DLLEXPORT Task * Task_new(const char *name, long stacksize, void *data, void *(*run) (void *data), void (*destroy) (void *data)) { Task *task = NEW(Task); pth_t ptask; pth_attr_t attr; #ifdef _LDEBUG printf("F=%s,L=%d\n", __FILE__, __LINE__); #endif if (pth_inited == 0) { if (pth_init() == 0) return NULL; pth_inited = 1; } if (stacksize < TASK_STACK_MIN) stacksize = TASK_STACK_MIN; ++seqNo; task->id = seqNo; task->stacklen = stacksize; task->name = strdup(name); task->data = data; task->run = run; task->destroy = destroy; attr = pth_attr_new(); pth_attr_set(attr, PTH_ATTR_NAME, name); pth_attr_set(attr, PTH_ATTR_STACK_SIZE, (unsigned int) stacksize); ptask = pth_spawn(attr, task_pth_run, task); pth_attr_destroy(attr); if (ptask == NULL) { free(task); return NULL; } task->ref = (void *) ptask; #ifdef _LDEBUG printf(" open ptask=%p,task=%p,name=%s,%p\n", (void *) ptask, (void *) task, task->name, task->name); printf("F=%s,L=%d\n", __FILE__, __LINE__); #endif return task; }
/* Pop up a message window similar to the confirm one but keep it open until agent_popup_message_stop has been called. It is crucial for the caller to make sure that the stop function gets called as soon as the message is not anymore required because the message is system modal and all other attempts to use the pinentry will fail (after a timeout). */ int agent_popup_message_start (ctrl_t ctrl, const char *desc, const char *ok_btn) { int rc; char line[ASSUAN_LINELENGTH]; pth_attr_t tattr; rc = start_pinentry (ctrl); if (rc) return rc; if (desc) snprintf (line, DIM(line)-1, "SETDESC %s", desc); else snprintf (line, DIM(line)-1, "RESET"); line[DIM(line)-1] = 0; rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL); if (rc) return unlock_pinentry (rc); if (ok_btn) { snprintf (line, DIM(line)-1, "SETOK %s", ok_btn); line[DIM(line)-1] = 0; rc = assuan_transact (entry_ctx, line, NULL,NULL,NULL,NULL,NULL,NULL); if (rc) return unlock_pinentry (rc); } tattr = pth_attr_new(); pth_attr_set (tattr, PTH_ATTR_JOINABLE, 1); pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024); pth_attr_set (tattr, PTH_ATTR_NAME, "popup-message"); popup_finished = 0; popup_tid = pth_spawn (tattr, popup_message_thread, NULL); if (!popup_tid) { rc = gpg_error_from_syserror (); log_error ("error spawning popup message handler: %s\n", strerror (errno) ); pth_attr_destroy (tattr); return unlock_pinentry (rc); } pth_attr_destroy (tattr); return 0; }
/* Fire up a thread to copy data between STREAM and a pipe's descriptor FD. With DIRECTION set to true the copy takes place from the stream to the pipe, otherwise from the pipe to the stream. */ static gpg_error_t start_feeder (estream_t stream, HANDLE hd, int direction) { #ifdef USE_NPTH gpg_error_t err; struct feeder_thread_parms *parm; pth_attr_t tattr; parm = xtrymalloc (sizeof *parm); if (!parm) return gpg_error_from_syserror (); parm->stream = stream; parm->stream_valid = 1; parm->hd = hd; parm->direction = direction; if (es_onclose (stream, 1, feeder_onclose_notification, parm)) { err = gpg_error_from_syserror (); xfree (parm); return err; } tattr = pth_attr_new (); pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0); pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 64*1024); pth_attr_set (tattr, PTH_ATTR_NAME, "exec-feeder"); log_debug ("spawning new feeder(%p, %p, %d)\n", stream, hd, direction); if(!pth_spawn (tattr, feeder_thread, parm)) { err = gpg_error_from_syserror (); es_onclose (stream, 0, feeder_onclose_notification, parm); xfree (parm); } else err = 0; pth_attr_destroy (tattr); return err; #else (void)stream; (void)hd; (void)direction; return gpg_error (GPG_ERR_NOT_IMPLEMENTED); /* No Pth. */ #endif }
/** * The main function for creating a new task. */ task_pid_t task_create_gid (task_gid_t gid, task_function_t fn) { pth_t pid; pth_attr_t attr; int i; #ifdef PTHDEBUG printf ("task_create_gid: gid=%d, fn=%p\n", gid, fn); #endif /* Set the task attributes: * - Not joinable : all tasks are independent * - cancellable : task kill is permitted * - priority : make certain tasks that the simulator itself * uses higher priority, and all others equal in priority. */ attr = pth_attr_new (); pth_attr_set (attr, PTH_ATTR_JOINABLE, FALSE); pth_attr_set (attr, PTH_ATTR_CANCEL_STATE, PTH_CANCEL_ENABLE); if (gid == GID_LINUX_REALTIME) /* time tracking */ pth_attr_set (attr, PTH_ATTR_PRIO, PTH_PRIO_STD + 2); else if (gid == GID_LINUX_INTERFACE) /* user input */ pth_attr_set (attr, PTH_ATTR_PRIO, PTH_PRIO_STD + 1); /* TODO - inside of calling the function directly, call a global * function and pass it a pointer to the task_data_table entry * as an argument. */ pid = pth_spawn (attr, fn, 0); for (i=0; i < NUM_TASKS; i++) if (task_data_table[i].pid == 0) { task_data_table[i].pid = pid; task_data_table[i].gid = gid; task_data_table[i].duration = TASK_DURATION_INF; task_data_table[i].arg.u16 = 0; task_data_table[i].duration = TASK_DURATION_BALL; #ifdef CONFIG_UI ui_write_task (i, gid); #endif return (pid); } fatal (ERR_NO_FREE_TASKS); }
void Thread::StopDelete () { autodel = true; pth_sem_inc (&should_stop, FALSE); if (!tid) return; pth_attr_t at = pth_attr_of (tid); pth_attr_set (at, PTH_ATTR_JOINABLE, FALSE); pth_attr_destroy (at); }
void Thread::Start (bool detach) { if (joinable && tid) { pth_attr_t a = pth_attr_of (tid); int state; pth_attr_get (a, PTH_ATTR_STATE, &state); pth_attr_destroy (a); if (state != PTH_STATE_DEAD) return; Stop (); } pth_sem_init (&should_stop); pth_attr_t attr = pth_attr_new (); pth_attr_set (attr, PTH_ATTR_PRIO, prio); joinable = !detach; if (detach) pth_attr_set (attr, PTH_ATTR_JOINABLE, FALSE); tid = pth_spawn (attr, &ThreadWrapper, this); pth_attr_destroy (attr); }
int main(int argc, char *argv[]) { pth_attr_t attr; sigset_t sigs; pth_init(); fprintf(stderr, "This is TEST_SIG, a Pth test using signals.\n"); fprintf(stderr, "\n"); fprintf(stderr, "Hit CTRL-C three times to stop this test.\n"); fprintf(stderr, "But only after all threads were terminated.\n"); fprintf(stderr, "\n"); fprintf(stderr, "main: init\n"); /* block signals */ pth_sigmask(SIG_SETMASK, NULL, &sigs); sigaddset(&sigs, SIGUSR1); sigaddset(&sigs, SIGUSR2); sigaddset(&sigs, SIGINT); pth_sigmask(SIG_SETMASK, &sigs, NULL); /* spawn childs */ attr = pth_attr_new(); pth_attr_set(attr, PTH_ATTR_NAME, "child1"); child1 = pth_spawn(attr, child, (void *)"child1"); pth_attr_set(attr, PTH_ATTR_NAME, "child2"); child2 = pth_spawn(attr, child, (void *)"child2"); pth_attr_set(attr, PTH_ATTR_NAME, "inthandler"); pth_spawn(attr, inthandler, (void *)"inthandler"); pth_attr_destroy(attr); /* wait until childs are finished */ while (pth_join(NULL, NULL)); fprintf(stderr, "main: exit\n"); pth_kill(); return 0; }
int FrSimThread::startThread() { printf("Base StartThread\n"); fflush(stdout); // Should add attributes as class members pth_attr_t attr; attr = pth_attr_new(); pth_attr_set(attr, PTH_ATTR_NAME, threadName.c_str()); pth_attr_set(attr, PTH_ATTR_STACK_SIZE, 2048*1024); pth_attr_set(attr, PTH_ATTR_JOINABLE, TRUE); pth_t tid = pth_spawn(attr, newThreadInit, (void *)this); if (tid == NULL) { return(1); } FrSimThreadId *newId = new FrSimThreadId(tid); id = newId; return (0); }
void Thread::Start () { if (tid) { pth_attr_t a = pth_attr_of (tid); int state; pth_attr_get (a, PTH_ATTR_STATE, &state); pth_attr_destroy (a); if (state != PTH_STATE_DEAD) return; Stop (); } pth_attr_t attr = pth_attr_new (); pth_attr_set (attr, PTH_ATTR_PRIO, prio); tid = pth_spawn (attr, &ThreadWrapper, this); pth_attr_destroy (attr); }
int SDL_SYS_CreateThread(SDL_Thread *thread, void *args) { pth_attr_t type; /* Create a new attribute */ type = pth_attr_new(); if ( type == NULL ) { SDL_SetError("Couldn't initialize pth attributes"); return(-1); } pth_attr_set(type, PTH_ATTR_JOINABLE, TRUE); /* Create the thread and go! */ thread->handle = pth_spawn(type, RunThread, args); if ( thread->handle == NULL ) { SDL_SetError("Not enough resources to create thread"); return(-1); } return(0); }
/* UNIX listener */ static void listener(IOCHAN h, int event) { COMSTACK line = (COMSTACK) iochan_getdata(h); int res; if (event == EVENT_INPUT) { COMSTACK new_line; if ((res = cs_listen_check(line, 0, 0, control_block.check_ip, control_block.daemon_name)) < 0) { yaz_log(YLOG_WARN|YLOG_ERRNO, "cs_listen failed"); return; } else if (res == 1) { yaz_log(YLOG_WARN, "cs_listen incomplete"); return; } new_line = cs_accept(line); if (!new_line) { yaz_log(YLOG_FATAL, "Accept failed."); iochan_setflags(h, EVENT_INPUT | EVENT_EXCEPT); /* reset listener */ return; } yaz_log(log_sessiondetail, "Connect from %s", cs_addrstr(new_line)); no_sessions++; if (control_block.dynamic) { if ((res = fork()) < 0) { yaz_log(YLOG_FATAL|YLOG_ERRNO, "fork"); iochan_destroy(h); return; } else if (res == 0) /* child */ { char nbuf[100]; IOCHAN pp; for (pp = pListener; pp; pp = iochan_getnext(pp)) { COMSTACK l = (COMSTACK)iochan_getdata(pp); cs_close(l); iochan_destroy(pp); } sprintf(nbuf, "%s(%d)", me, no_sessions); yaz_log_init_prefix(nbuf); /* ensure that bend_stop is not called when each child exits - only for the main process .. */ control_block.bend_stop = 0; } else /* parent */ { cs_close(new_line); return; } } if (control_block.threads) { #if YAZ_POSIX_THREADS pthread_t child_thread; pthread_create(&child_thread, 0, new_session, new_line); pthread_detach(child_thread); #elif YAZ_GNU_THREADS pth_attr_t attr; pth_t child_thread; attr = pth_attr_new(); pth_attr_set(attr, PTH_ATTR_JOINABLE, FALSE); pth_attr_set(attr, PTH_ATTR_STACK_SIZE, 32*1024); pth_attr_set(attr, PTH_ATTR_NAME, "session"); yaz_log(YLOG_DEBUG, "pth_spawn begin"); child_thread = pth_spawn(attr, new_session, new_line); yaz_log(YLOG_DEBUG, "pth_spawn finish"); pth_attr_destroy(attr); #else new_session(new_line); #endif } else new_session(new_line); } else if (event == EVENT_TIMEOUT) { yaz_log(log_server, "Shutting down listener."); iochan_destroy(h); } else { yaz_log(YLOG_FATAL, "Bad event on listener."); iochan_destroy(h); } }
int main(int argc, char *argv[]) { char caLine[MAXLINELEN]; pth_event_t ev = NULL; pth_event_t evt = NULL; pth_t t_worker = NULL; pth_t t_ticker = NULL; pth_attr_t t_attr; pth_msgport_t mp = NULL; pth_msgport_t mp_worker = NULL; struct query *q = NULL; int n; if (!pth_init()) { perror("pth_init"); exit(1); } /* murray added for tmp debug */ /* pth_time_t intval, former; printf("-------------------------\n"); pth_time_set(&former, PTH_TIME_NOW); pth_usleep(300); pth_time_set(&intval, PTH_TIME_NOW); pth_time_sub(&intval, &former); double val = pth_time_t2d(&intval); printf("the intval is [%f]\n", val); pth_debug2("the intval is [%f]\n", val); return 0; */ fprintf(stderr, "This is TEST_MP, a Pth test using message ports.\n"); fprintf(stderr, "\n"); fprintf(stderr, "Lines on stdin are send to a worker thread via message\n"); fprintf(stderr, "ports, translated to upper case by the worker thread and\n"); fprintf(stderr, "send back to the main thread via message ports.\n"); fprintf(stderr, "Additionally a useless ticker thread awakens every 5s.\n"); fprintf(stderr, "Enter \"quit\" on stdin for stopping this test.\n"); fprintf(stderr, "\n"); t_attr = pth_attr_new(); pth_attr_set(t_attr, PTH_ATTR_NAME, "worker"); pth_attr_set(t_attr, PTH_ATTR_JOINABLE, TRUE); pth_attr_set(t_attr, PTH_ATTR_STACK_SIZE, 16*1024); t_worker = pth_spawn(t_attr, worker, NULL); pth_attr_set(t_attr, PTH_ATTR_NAME, "ticker"); t_ticker = pth_spawn(t_attr, ticker, NULL); pth_attr_destroy(t_attr); pth_yield(NULL); mp_worker = pth_msgport_find("worker"); mp = pth_msgport_create("main"); q = (struct query *)malloc(sizeof(struct query)); ev = pth_event(PTH_EVENT_MSG, mp); evt = NULL; for (;;) { if (evt == NULL) evt = pth_event(PTH_EVENT_TIME, pth_timeout(20,0)); else evt = pth_event(PTH_EVENT_TIME|PTH_MODE_REUSE, evt, pth_timeout(20,0)); n = pth_readline_ev(STDIN_FILENO, caLine, MAXLINELEN, evt); if (n == -1 && pth_event_status(evt) == PTH_STATUS_OCCURRED) { fprintf(stderr, "main: Hey, what are you waiting for? Type in something!\n"); continue; } if (n < 0) { fprintf(stderr, "main: I/O read error on stdin\n"); break; } if (n == 0) { fprintf(stderr, "main: EOF on stdin\n"); break; } caLine[n-1] = NUL; if (strcmp(caLine, "quit") == 0) { fprintf(stderr, "main: quit\n"); break; } fprintf(stderr, "main: out --> <%s>\n", caLine); q->string = caLine; q->head.m_replyport = mp; pth_msgport_put(mp_worker, (pth_message_t *)q); pth_wait(ev); q = (struct query *)pth_msgport_get(mp); fprintf(stderr, "main: in <-- <%s>\n", q->string); } free(q); pth_event_free(ev, PTH_FREE_THIS); pth_event_free(evt, PTH_FREE_THIS); pth_msgport_destroy(mp); pth_cancel(t_worker); pth_join(t_worker, NULL); pth_cancel(t_ticker); pth_join(t_ticker, NULL); pth_kill(); return 0; }
int main(int argc, char *argv[]) { struct sockaddr_in sar; struct protoent *pe; struct sockaddr_in peer_addr; socklen_t peer_len; int sr; int port; /* initialize scheduler */ pth_init(); signal(SIGPIPE, SIG_IGN); signal(SIGINT, myexit); signal(SIGTERM, myexit); /* argument line parsing */ if (argc != 2) { fprintf(stderr, "Usage: %s <port>\n", argv[0]); exit(1); } port = atoi(argv[1]); if (port <= 0 || port >= 65535) { fprintf(stderr, "Illegal port: %d\n", port); exit(1); } fprintf(stderr, "This is TEST_HTTPD, a Pth test using socket I/O.\n"); fprintf(stderr, "\n"); fprintf(stderr, "Multiple connections are accepted on the specified port.\n"); fprintf(stderr, "For each connection a separate thread is spawned which\n"); fprintf(stderr, "reads a HTTP request the socket and writes back a constant\n"); fprintf(stderr, "(and useless) HTTP response to the socket.\n"); fprintf(stderr, "Additionally a useless ticker thread awakens every 5s.\n"); fprintf(stderr, "Watch the average scheduler load the ticker displays.\n"); fprintf(stderr, "Hit CTRL-C for stopping this test.\n"); fprintf(stderr, "\n"); /* run a just for fun ticker thread */ attr = pth_attr_new(); pth_attr_set(attr, PTH_ATTR_NAME, "ticker"); pth_attr_set(attr, PTH_ATTR_JOINABLE, FALSE); pth_attr_set(attr, PTH_ATTR_STACK_SIZE, 64*1024); pth_spawn(attr, ticker, NULL); /* create TCP socket */ if ((pe = getprotobyname("tcp")) == NULL) { perror("getprotobyname"); exit(1); } if ((s = socket(AF_INET, SOCK_STREAM, pe->p_proto)) == -1) { perror("socket"); exit(1); } /* bind socket to port */ sar.sin_family = AF_INET; sar.sin_addr.s_addr = INADDR_ANY; sar.sin_port = htons(port); if (bind(s, (struct sockaddr *)&sar, sizeof(struct sockaddr_in)) == -1) { perror("socket"); exit(1); } /* start listening on the socket with a queue of 10 */ if (listen(s, REQ_MAX) == -1) { perror("listen"); exit(1); } /* finally loop for requests */ pth_attr_set(attr, PTH_ATTR_NAME, "handler"); fprintf(stderr, "listening on port %d (max %d simultaneous connections)\n", port, REQ_MAX); for (;;) { /* accept next connection */ peer_len = sizeof(peer_addr); if ((sr = pth_accept(s, (struct sockaddr *)&peer_addr, &peer_len)) == -1) { perror("accept"); pth_sleep(1); continue; } if (pth_ctrl(PTH_CTRL_GETTHREADS) >= REQ_MAX) { fprintf(stderr, "currently no more connections acceptable\n"); continue; } fprintf(stderr, "connection established (fd: %d, ip: %s, port: %d)\n", sr, inet_ntoa(peer_addr.sin_addr), ntohs(peer_addr.sin_port)); /* spawn new handling thread for connection */ pth_spawn(attr, handler, (void *)((long)sr)); } }
int main (int argc, char **argv ) { ARGPARSE_ARGS pargs; int orig_argc; gpg_error_t err; int may_coredump; char **orig_argv; FILE *configfp = NULL; char *configname = NULL; const char *shell; unsigned int configlineno; int parse_debug = 0; const char *debug_level = NULL; int default_config =1; int greeting = 0; int nogreeting = 0; int multi_server = 0; int is_daemon = 0; int nodetach = 0; int csh_style = 0; char *logfile = NULL; int debug_wait = 0; int gpgconf_list = 0; const char *config_filename = NULL; int allow_coredump = 0; int standard_socket = 0; struct assuan_malloc_hooks malloc_hooks; set_strusage (my_strusage); gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN); /* Please note that we may running SUID(ROOT), so be very CAREFUL when adding any stuff between here and the call to INIT_SECMEM() somewhere after the option parsing */ log_set_prefix ("scdaemon", 1|4); /* Make sure that our subsystems are ready. */ i18n_init (); init_common_subsystems (&argc, &argv); /* Libgcrypt requires us to register the threading model first. Note that this will also do the pth_init. */ gcry_threads_pth.init = fixed_gcry_pth_init; err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth); if (err) { log_fatal ("can't register GNU Pth with Libgcrypt: %s\n", gpg_strerror (err)); } /* Check that the libraries are suitable. Do it here because the option parsing may need services of the library */ if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) ) { log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt", NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) ); } ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free); malloc_hooks.malloc = gcry_malloc; malloc_hooks.realloc = gcry_realloc; malloc_hooks.free = gcry_free; assuan_set_malloc_hooks (&malloc_hooks); assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT); assuan_set_system_hooks (ASSUAN_SYSTEM_PTH); assuan_sock_init (); setup_libassuan_logging (&opt.debug); setup_libgcrypt_logging (); gcry_control (GCRYCTL_USE_SECURE_RNDPOOL); may_coredump = disable_core_dumps (); /* Set default options. */ opt.allow_admin = 1; opt.pcsc_driver = DEFAULT_PCSC_DRIVER; #ifdef HAVE_W32_SYSTEM standard_socket = 1; /* Under Windows we always use a standard socket. */ #endif shell = getenv ("SHELL"); if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") ) csh_style = 1; opt.homedir = default_homedir (); /* Check whether we have a config file on the commandline */ orig_argc = argc; orig_argv = argv; pargs.argc = &argc; pargs.argv = &argv; pargs.flags= 1|(1<<6); /* do not remove the args, ignore version */ while (arg_parse( &pargs, opts)) { if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll) parse_debug++; else if (pargs.r_opt == oOptions) { /* yes there is one, so we do not try the default one, but read the option file when it is encountered at the commandline */ default_config = 0; } else if (pargs.r_opt == oNoOptions) default_config = 0; /* --no-options */ else if (pargs.r_opt == oHomedir) opt.homedir = pargs.r.ret_str; } /* initialize the secure memory. */ gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0); maybe_setuid = 0; /* Now we are working under our real uid */ if (default_config) configname = make_filename (opt.homedir, "scdaemon.conf", NULL ); argc = orig_argc; argv = orig_argv; pargs.argc = &argc; pargs.argv = &argv; pargs.flags= 1; /* do not remove the args */ next_pass: if (configname) { configlineno = 0; configfp = fopen (configname, "r"); if (!configfp) { if (default_config) { if( parse_debug ) log_info (_("NOTE: no default option file `%s'\n"), configname ); } else { log_error (_("option file `%s': %s\n"), configname, strerror(errno) ); exit(2); } xfree (configname); configname = NULL; } if (parse_debug && configname ) log_info (_("reading options from `%s'\n"), configname ); default_config = 0; } while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) ) { switch (pargs.r_opt) { case aGPGConfList: gpgconf_list = 1; break; case aGPGConfTest: gpgconf_list = 2; break; case oQuiet: opt.quiet = 1; break; case oVerbose: opt.verbose++; break; case oBatch: opt.batch=1; break; case oDebug: opt.debug |= pargs.r.ret_ulong; break; case oDebugAll: opt.debug = ~0; break; case oDebugLevel: debug_level = pargs.r.ret_str; break; case oDebugWait: debug_wait = pargs.r.ret_int; break; case oDebugAllowCoreDump: enable_core_dumps (); allow_coredump = 1; break; case oDebugCCIDDriver: #ifdef HAVE_LIBUSB ccid_set_debug_level (ccid_set_debug_level (-1)+1); #endif /*HAVE_LIBUSB*/ break; case oDebugDisableTicker: ticker_disabled = 1; break; case oDebugLogTid: log_set_pid_suffix_cb (tid_log_callback); break; case oOptions: /* config files may not be nested (silently ignore them) */ if (!configfp) { xfree(configname); configname = xstrdup(pargs.r.ret_str); goto next_pass; } break; case oNoGreeting: nogreeting = 1; break; case oNoVerbose: opt.verbose = 0; break; case oNoOptions: break; /* no-options */ case oHomedir: opt.homedir = pargs.r.ret_str; break; case oNoDetach: nodetach = 1; break; case oLogFile: logfile = pargs.r.ret_str; break; case oCsh: csh_style = 1; break; case oSh: csh_style = 0; break; case oServer: pipe_server = 1; break; case oMultiServer: pipe_server = 1; multi_server = 1; break; case oDaemon: is_daemon = 1; break; case oReaderPort: opt.reader_port = pargs.r.ret_str; break; case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break; case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break; case oDisableCCID: opt.disable_ccid = 1; break; case oDisableOpenSC: break; case oDisableKeypad: opt.disable_keypad = 1; break; case oAllowAdmin: /* Dummy because allow is now the default. */ break; case oDenyAdmin: opt.allow_admin = 0; break; case oCardTimeout: opt.card_timeout = pargs.r.ret_ulong; break; case oDisableApplication: add_to_strlist (&opt.disabled_applications, pargs.r.ret_str); break; default: pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR; break; } } if (configfp) { fclose( configfp ); configfp = NULL; /* Keep a copy of the config name for use by --gpgconf-list. */ config_filename = configname; configname = NULL; goto next_pass; } xfree (configname); configname = NULL; if (log_get_errorcount(0)) exit(2); if (nogreeting ) greeting = 0; if (greeting) { es_fprintf (es_stderr, "%s %s; %s\n", strusage(11), strusage(13), strusage(14) ); es_fprintf (es_stderr, "%s\n", strusage(15) ); } #ifdef IS_DEVELOPMENT_VERSION log_info ("NOTE: this is a development version!\n"); #endif if (atexit (cleanup)) { log_error ("atexit failed\n"); cleanup (); exit (1); } set_debug (debug_level); initialize_module_command (); if (gpgconf_list == 2) scd_exit (0); if (gpgconf_list) { /* List options and default values in the GPG Conf format. */ char *filename = NULL; char *filename_esc; if (config_filename) filename = xstrdup (config_filename); else filename = make_filename (opt.homedir, "scdaemon.conf", NULL); filename_esc = percent_escape (filename, NULL); es_printf ("gpgconf-scdaemon.conf:%lu:\"%s\n", GC_OPT_FLAG_DEFAULT, filename_esc); xfree (filename_esc); xfree (filename); es_printf ("verbose:%lu:\n" "quiet:%lu:\n" "debug-level:%lu:\"none:\n" "log-file:%lu:\n", GC_OPT_FLAG_NONE, GC_OPT_FLAG_NONE, GC_OPT_FLAG_DEFAULT, GC_OPT_FLAG_NONE ); es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE ); es_printf ("ctapi-driver:%lu:\n", GC_OPT_FLAG_NONE ); es_printf ("pcsc-driver:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT, DEFAULT_PCSC_DRIVER ); #ifdef HAVE_LIBUSB es_printf ("disable-ccid:%lu:\n", GC_OPT_FLAG_NONE ); #endif es_printf ("deny-admin:%lu:\n", GC_OPT_FLAG_NONE ); es_printf ("disable-keypad:%lu:\n", GC_OPT_FLAG_NONE ); es_printf ("card-timeout:%lu:%d:\n", GC_OPT_FLAG_DEFAULT, 0); scd_exit (0); } /* Now start with logging to a file if this is desired. */ if (logfile) { log_set_file (logfile); log_set_prefix (NULL, 1|2|4); } if (debug_wait && pipe_server) { log_debug ("waiting for debugger - my pid is %u .....\n", (unsigned int)getpid()); gnupg_sleep (debug_wait); log_debug ("... okay\n"); } if (pipe_server) { /* This is the simple pipe based server */ ctrl_t ctrl; pth_attr_t tattr; int fd = -1; #ifndef HAVE_W32_SYSTEM { struct sigaction sa; sa.sa_handler = SIG_IGN; sigemptyset (&sa.sa_mask); sa.sa_flags = 0; sigaction (SIGPIPE, &sa, NULL); } #endif /* If --debug-allow-core-dump has been given we also need to switch the working directory to a place where we can actually write. */ if (allow_coredump) { if (chdir("/tmp")) log_debug ("chdir to `/tmp' failed: %s\n", strerror (errno)); else log_debug ("changed working directory to `/tmp'\n"); } /* In multi server mode we need to listen on an additional socket. Create that socket now before starting the handler for the pipe connection. This allows that handler to send back the name of that socket. */ if (multi_server) { socket_name = create_socket_name (standard_socket, "S.scdaemon", "gpg-XXXXXX/S.scdaemon"); fd = FD2INT(create_server_socket (standard_socket, socket_name, &socket_nonce)); } tattr = pth_attr_new(); pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0); pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 512*1024); pth_attr_set (tattr, PTH_ATTR_NAME, "pipe-connection"); ctrl = xtrycalloc (1, sizeof *ctrl); if ( !ctrl ) { log_error ("error allocating connection control data: %s\n", strerror (errno) ); scd_exit (2); } ctrl->thread_startup.fd = GNUPG_INVALID_FD; if ( !pth_spawn (tattr, start_connection_thread, ctrl) ) { log_error ("error spawning pipe connection handler: %s\n", strerror (errno) ); xfree (ctrl); scd_exit (2); } /* We run handle_connection to wait for the shutdown signal and to run the ticker stuff. */ handle_connections (fd); if (fd != -1) close (fd); } else if (!is_daemon) { log_info (_("please use the option `--daemon'" " to run the program in the background\n")); } else { /* Regular server mode */ int fd; #ifndef HAVE_W32_SYSTEM pid_t pid; int i; #endif /* Create the socket. */ socket_name = create_socket_name (standard_socket, "S.scdaemon", "gpg-XXXXXX/S.scdaemon"); fd = FD2INT (create_server_socket (standard_socket, socket_name, &socket_nonce)); fflush (NULL); #ifndef HAVE_W32_SYSTEM pid = fork (); if (pid == (pid_t)-1) { log_fatal ("fork failed: %s\n", strerror (errno) ); exit (1); } else if (pid) { /* we are the parent */ char *infostr; close (fd); /* create the info string: <name>:<pid>:<protocol_version> */ if (estream_asprintf (&infostr, "SCDAEMON_INFO=%s:%lu:1", socket_name, (ulong) pid) < 0) { log_error ("out of core\n"); kill (pid, SIGTERM); exit (1); } *socket_name = 0; /* don't let cleanup() remove the socket - the child should do this from now on */ if (argc) { /* run the program given on the commandline */ if (putenv (infostr)) { log_error ("failed to set environment: %s\n", strerror (errno) ); kill (pid, SIGTERM ); exit (1); } execvp (argv[0], argv); log_error ("failed to run the command: %s\n", strerror (errno)); kill (pid, SIGTERM); exit (1); } else { /* Print the environment string, so that the caller can use shell's eval to set it */ if (csh_style) { *strchr (infostr, '=') = ' '; es_printf ( "setenv %s\n", infostr); } else { es_printf ( "%s; export SCDAEMON_INFO;\n", infostr); } xfree (infostr); exit (0); } /* NOTREACHED */ } /* end parent */ /* This is the child. */ /* Detach from tty and put process into a new session. */ if (!nodetach ) { /* Close stdin, stdout and stderr unless it is the log stream. */ for (i=0; i <= 2; i++) { if ( log_test_fd (i) && i != fd) close (i); } if (setsid() == -1) { log_error ("setsid() failed: %s\n", strerror(errno) ); cleanup (); exit (1); } } { struct sigaction sa; sa.sa_handler = SIG_IGN; sigemptyset (&sa.sa_mask); sa.sa_flags = 0; sigaction (SIGPIPE, &sa, NULL); } if (chdir("/")) { log_error ("chdir to / failed: %s\n", strerror (errno)); exit (1); } #endif /*!HAVE_W32_SYSTEM*/ handle_connections (fd); close (fd); } return 0; }
int main(int argc, char *argv[]) { if (argc < 5) { return 1; } auto processNum = 4; auto threadNum = atoi(argv[4]); auto dtime = atol(argv[3]) * 1000; auto isPth = std::string(argv[2]) == "pth"; auto taskNum = atoi(argv[1]); long cycles = 0; switch(taskNum) { case 1: task = task1; break; case 2: task = task2; break; case 3: task = task3; break; } time_start(); for (auto i = 0; i < processNum; ++i) { if (fork() != 0) { continue; } if (isPth) { pth_init(); pth_attr_t attr = pth_attr_new(); pth_attr_set(attr, PTH_ATTR_NAME, "task"); pth_attr_set(attr, PTH_ATTR_STACK_SIZE, 64*1024); pth_attr_set(attr, PTH_ATTR_JOINABLE, true); pth_mutex_t mutex; pth_mutex_init(&mutex); pth_cond_init(&pthCond); while (time_stop() < dtime) { for (auto i = workingNum; i < threadNum; ++i) { ++workingNum; pth_spawn(attr, task, &isPth); } int rc; if ((rc = pth_mutex_acquire(&mutex, FALSE, NULL)) != 0) { std::cout << "pthread_mutex_lock " << rc << " " << strerror(rc) << std::endl; return 3; } if (workingNum == threadNum) { if ((rc = pth_cond_await(&pthCond, &mutex, NULL)) != 0) { std::cout << "pthread_cond_wait " << rc << " " << strerror(rc) << std::endl; return 3; } } if ((rc = pth_mutex_release(&mutex)) != 0) { std::cout << "pthread_mutex_unlock " << rc << " " << strerror(rc) << std::endl; return 3; } cycles += threadNum - workingNum; } } else { pthread_attr_t attr; pthread_attr_setstacksize(&attr, 64*1024); pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutexattr_t mutexattr; pthread_mutex_init(&mutex, &mutexattr); pthread_condattr_t condattr; pthread_cond_init(&cond, &condattr); pthread_t pid; while (time_stop() < dtime) { for (auto i = workingNum; i < threadNum; ++i) { ++workingNum; if (pthread_create(&pid, NULL, task, &isPth) == -1) { return 2; } } int rc; if ((rc = pthread_mutex_lock(&mutex)) != 0) { std::cout << "pthread_mutex_lock " << rc << " " << strerror(rc) << std::endl; return 3; } if (workingNum == threadNum) { if ((rc = pthread_cond_wait(&cond, &mutex)) != 0) { std::cout << "pthread_cond_wait " << rc << " " << strerror(rc) << std::endl; return 3; } } if ((rc = pthread_mutex_unlock(&mutex)) != 0) { std::cout << "pthread_mutex_unlock " << rc << " " << strerror(rc) << std::endl; return 3; } //pthread_join(pids.front(), NULL); //pids.pop_front(); cycles += threadNum - workingNum; } } std::cout << cycles << std::endl; return 0; } for (auto i = 0; i < processNum; ++i) { wait(NULL); } return 0; }