bool zmq::thread_t::is_current_thread () const { return taskIdSelf () == descriptor; }
int devRead(myDev * dev, char * data, size_t dataSize) { int taskId; fifo * i; msg * buff = (msg*)data; int buffSize = dataSize/sizeof(msg); //I can't see any reason why sizeof(msg) //should change, but let's not take any chances int msgsRead = 0; printf("1\n"); taskId = taskIdSelf(); printf("2\n"); if (dev==NULL) { errnoSet(NOT_OPEN); return -1; } //we'll only send whole messages, thus if dataSize<sizeof(msg), //we can't send anything : if (dataSize<sizeof(msg)) { errnoSet(SHORT_BUFF); return -1; } printf("3\n"); if(semTake(dev->semMData,WAIT_FOREVER)==-1) { errnoSet(SEM_ERR); return -1; } printf("4\n"); //find out wich fifo is our own: for (i=dev->firstFifo; i!=NULL && i->taskId!=taskId; i=i->nextFifo); if (i==NULL) { errnoSet(NOT_OPEN); return -1; } printf("5\n"); semGive(dev->semMData); printf("6\n"); if (i==NULL) { //We have nothing to write on? This shouldn't happen either... errnoSet(NOT_REGISTERED); return -1; } printf("7\n"); readFifo(i,&(buff[0]), WAIT_FOREVER); //First call block if fifo empty, cf specs. printf("8\n"); msgsRead++; printf("9, bufferSize=%d, msgsRead=%d\n",buffSize,msgsRead); while (msgsRead<buffSize && readFifo(i,&(buff[msgsRead]),NO_WAIT)==0) { //Let's read messages until fifo is empty or until the data buffer is //to full to take whole messages msgsRead++; printf("9.1\n"); } printf("10\n"); return msgsRead*sizeof(msg); }
/* * Launch the CGI process and return a handle to it. Process spawning * is not supported in VxWorks. Instead, we spawn a "task". A major * difference is that we have to know the entry point for the taskSpawn * API. Also the module may have to be loaded before being executed; * it may also be part of the OS image, in which case it cannot be * loaded or unloaded. The following sequence is used: * 1. If the module is already loaded, unload it from memory. * 2. Search for a query string keyword=value pair in the environment * variables where the keyword is cgientry. If found use its value * as the the entry point name. If there is no such pair set * the entry point name to the default: basename_cgientry, where * basename is the name of the cgi file without the extension. Use * the entry point name in a symbol table search for that name to * use as the entry point address. If successful go to step 5. * 3. Try to load the module into memory. If not successful error out. * 4. If step 3 is successful repeat the entry point search from step * 2. If the entry point exists, go to step 5. If it does not, * error out. * 5. Use taskSpawn to start a new task which uses vxWebsCgiEntry * as its starting point. The five arguments to vxWebsCgiEntry * will be the user entry point address, argp, envp, stdIn * and stdOut. vxWebsCgiEntry will convert argp to an argc * argv pair to pass to the user entry, it will initialize the * task environment with envp, it will open and redirect stdin * and stdout to stdIn and stdOut, and then it will call the * user entry. * 6. Return the taskSpawn return value. */ int websLaunchCgiProc(char_t *cgiPath, char_t **argp, char_t **envp, char_t *stdIn, char_t *stdOut) { SYM_TYPE ptype; char_t *p, *basename, *pEntry, *pname, *entryAddr, **pp; int priority, rc, fd; /* * Determine the basename, which is without path or the extension. */ if ((int)(p = gstrrchr(cgiPath, '/') + 1) == 1) { p = cgiPath; } basename = bstrdup(B_L, p); if ((p = gstrrchr(basename, '.')) != NULL) { *p = '\0'; } /* * Unload the module, if it is already loaded. Get the current task * priority. */ unld(cgiPath, 0); taskPriorityGet(taskIdSelf(), &priority); rc = fd = -1; /* * Set the entry point symbol name as described above. Look for an already * loaded entry point; if it exists, spawn the task accordingly. */ for (pp = envp, pEntry = NULL; pp != NULL && *pp != NULL; pp++) { if (gstrncmp(*pp, T("cgientry="), 9) == 0) { pEntry = bstrdup(B_L, *pp + 9); break; } } if (pEntry == NULL) { fmtAlloc(&pEntry, LF_PATHSIZE, T("%s_%s"), basename, T("cgientry")); } entryAddr = 0; if (symFindByName(sysSymTbl, pEntry, &entryAddr, &ptype) == -1) { fmtAlloc(&pname, VALUE_MAX_STRING, T("_%s"), pEntry); symFindByName(sysSymTbl, pname, &entryAddr, &ptype); bfreeSafe(B_L, pname); } if (entryAddr != 0) { rc = taskSpawn(pEntry, priority, 0, 20000, (void *)vxWebsCgiEntry, (int)entryAddr, (int)argp, (int)envp, (int)stdIn, (int)stdOut, 0, 0, 0, 0, 0); goto DONE; } /* * Try to load the module. */ if ((fd = gopen(cgiPath, O_RDONLY | O_BINARY, 0666)) < 0 || loadModule(fd, LOAD_GLOBAL_SYMBOLS) == NULL) { goto DONE; } if ((symFindByName(sysSymTbl, pEntry, &entryAddr, &ptype)) == -1) { fmtAlloc(&pname, VALUE_MAX_STRING, T("_%s"), pEntry); symFindByName(sysSymTbl, pname, &entryAddr, &ptype); bfreeSafe(B_L, pname); } if (entryAddr != 0) { rc = taskSpawn(pEntry, priority, 0, 20000, (void *)vxWebsCgiEntry, (int)entryAddr, (int)argp, (int)envp, (int)stdIn, (int)stdOut, 0, 0, 0, 0, 0); } DONE: if (fd != -1) { gclose(fd); } bfree(B_L, basename); bfree(B_L, pEntry); return rc; }
/* * main - parse arguments and handle options */ int ntpdcmain( int argc, char *argv[] ) { extern int ntp_optind; delay_time.l_ui = 0; delay_time.l_uf = DEFDELAY; #ifdef SYS_VXWORKS clear_globals(); taskPrioritySet(taskIdSelf(), 100 ); #endif init_lib(); /* sets up ipv4_works, ipv6_works */ ssl_applink(); /* Check to see if we have IPv6. Otherwise default to IPv4 */ if (!ipv6_works) ai_fam_default = AF_INET; progname = argv[0]; { int optct = optionProcess(&ntpdcOptions, argc, argv); argc -= optct; argv += optct; } if (HAVE_OPT(IPV4)) ai_fam_templ = AF_INET; else if (HAVE_OPT(IPV6)) ai_fam_templ = AF_INET6; else ai_fam_templ = ai_fam_default; if (HAVE_OPT(COMMAND)) { int cmdct = STACKCT_OPT( COMMAND ); const char** cmds = STACKLST_OPT( COMMAND ); while (cmdct-- > 0) { ADDCMD(*cmds++); } } debug = DESC(DEBUG_LEVEL).optOccCt; if (HAVE_OPT(INTERACTIVE)) { interactive = 1; } if (HAVE_OPT(NUMERIC)) { showhostnames = 0; } if (HAVE_OPT(LISTPEERS)) { ADDCMD("listpeers"); } if (HAVE_OPT(PEERS)) { ADDCMD("peers"); } if (HAVE_OPT(SHOWPEERS)) { ADDCMD("dmpeers"); } if (ntp_optind == argc) { ADDHOST(DEFHOST); } else { for (; ntp_optind < argc; ntp_optind++) ADDHOST(argv[ntp_optind]); } if (numcmds == 0 && interactive == 0 && isatty(fileno(stdin)) && isatty(fileno(stderr))) { interactive = 1; } #if 0 ai_fam_templ = ai_fam_default; while ((c = ntp_getopt(argc, argv, "46c:dilnps")) != EOF) switch (c) { case '4': ai_fam_templ = AF_INET; break; case '6': ai_fam_templ = AF_INET6; break; case 'c': ADDCMD(ntp_optarg); break; case 'd': ++debug; break; case 'i': interactive = 1; break; case 'l': ADDCMD("listpeers"); break; case 'n': showhostnames = 0; break; case 'p': ADDCMD("peers"); break; case 's': ADDCMD("dmpeers"); break; default: errflg++; break; } if (errflg) { (void) fprintf(stderr, "usage: %s [-46dilnps] [-c cmd] host ...\n", progname); exit(2); } if (ntp_optind == argc) { ADDHOST(DEFHOST); } else { for (; ntp_optind < argc; ntp_optind++) ADDHOST(argv[ntp_optind]); } if (numcmds == 0 && interactive == 0 && isatty(fileno(stdin)) && isatty(fileno(stderr))) { interactive = 1; } #endif #ifndef SYS_WINNT /* Under NT cannot handle SIGINT, WIN32 spawns a handler */ if (interactive) (void) signal_no_reset(SIGINT, abortcmd); #endif /* SYS_WINNT */ /* * Initialize the packet data buffer */ pktdatasize = INITDATASIZE; pktdata = emalloc(INITDATASIZE); if (numcmds == 0) { (void) openhost(chosts[0]); getcmds(); } else { int ihost; int icmd; for (ihost = 0; ihost < numhosts; ihost++) { if (openhost(chosts[ihost])) for (icmd = 0; icmd < numcmds; icmd++) { if (numhosts > 1) printf ("--- %s ---\n",chosts[ihost]); docmd(ccmds[icmd]); } } } #ifdef SYS_WINNT WSACleanup(); #endif return(0); } /* main end */
int setTaskID(TaskExecutor* te) { te->id = (void*)taskIdSelf(); }
static inline void regulator_pm_om_log(struct regulator *regulator, int opsid) { struct regulator_pm_om_log regu_log = {(unsigned int)opsid, (unsigned int)regulator->id, (unsigned int)regulator->use_count, 0}; regu_log.task_id = (unsigned int)taskIdSelf(); bsp_pm_log_type(PM_OM_REGU, REGULATOR_TYPE, sizeof(struct regulator_pm_om_log), ®u_log); }
/* N.B.!! We do *not* execute in the context of the dying task here, but rather that of tExcTask - we do get a pointer to the task's TCB though - this pointer is in fact also the task's ID. */ static void save_reclaim(WIND_TCB *tcbp) { int i, var, oldfd; struct task_data *tdp; struct mall_data *mdp, *mdnextp; if ((var = taskVarGet((int)tcbp, (int *)&task_data)) != ERROR && var != 0) { tdp = (struct task_data *)var; if (tdp->version == (FUNCPTR)save_reclaim) { /* Only handle our own */ #ifdef DEBUG fdprintf(2, "Reclaiming for task id 0x%x:\nFiles: ", (int)tcbp); #endif /* Ugh! VxWorks doesn't even flush stdout/err - we need to get at those (which are task-private of course, i.e. we can't just do fflush(stdout) here) - we could be really pedantic and try to redefine stdout/err (which "are" function calls) too, snarfing the values when they are used - but besides the overhead this is problematic since they are actually #defines already... We'll peek in the TCB instead (no documentation of course). And of course, we must also meddle with the *file descriptor* indirections, or we'll just flush out on tExcTask's descriptors... */ for (i = 1; i <= 2; i++) { if (tcbp->taskStdFp[i] != NULL) { #ifdef DEBUG fdprintf(2, "fflush(%s) ", i == 1 ? "stdout" : "stderr"); #endif oldfd = ioTaskStdGet(0, i); ioTaskStdSet(0, i, tcbp->taskStd[i]); fflush(tcbp->taskStdFp[i]); ioTaskStdSet(0, i, oldfd); } } for (i = 3; i < tdp->max_files; i++) { if (FD_ISSET(i, &tdp->open_fds)) { #ifdef DEBUG fdprintf(2, "close(%d) ", i); #endif (void) close(i); } if (tdp->open_fps[i] != NULL) { #ifdef DEBUG fdprintf(2, "fclose(%0x%x) ", (int)tdp->open_fps[i]); #endif (void) fclose(tdp->open_fps[i]); } } i = 0; mdp = tdp->mall_data; while (mdp != NULL) { mdnextp = mdp->next; if(reclaim_free_function != NULL) (*reclaim_free_function)(mdp->self); else free(mdp->self); i++; mdp = mdnextp; } #ifdef DEBUG fdprintf(2, "\nFreeing memory: total %d mallocs\n", i); #endif if (tdp->delete_hook != NULL) { #ifdef DEBUG fdprintf(2, "Calling delete hook at 0x%08x\n", tdp->delete_hook); #endif (*tdp->delete_hook)(tdp->hook_data); #ifdef DEBUG fdprintf(2, "Called delete hook at 0x%08x\n", tdp->delete_hook); #endif } #ifdef DEBUG fdprintf(2, "Freeing own mem at 0x%08x\n", tdp); #endif (void) free((char *)tdp); #ifdef DEBUG fdprintf(2, "Freed own mem at 0x%08x, done (0x%08x)\n**********\n", tdp, taskIdSelf()); checkStack(0); #endif } } #ifdef DEBUG else fdprintf(2, "No task data found for id 0x%x, var = %d\n", (int)tcbp, var); #endif }
ThreadImpl::TIDImpl ThreadImpl::currentTidImpl() { return taskIdSelf(); }
static void rootTask(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) { int ret; traceobj_enter(&trobj); traceobj_mark(&trobj, 6); ret = taskPrioritySet(taskIdSelf(), 11); traceobj_assert(&trobj, ret == OK); traceobj_mark(&trobj, 7); sem_id = semMCreate(0xffffffff); traceobj_assert(&trobj, sem_id == 0 && errno == S_semLib_INVALID_OPTION); traceobj_mark(&trobj, 8); sem_id = semMCreate(SEM_Q_PRIORITY|SEM_DELETE_SAFE|SEM_INVERSION_SAFE); traceobj_assert(&trobj, sem_id != 0); traceobj_mark(&trobj, 9); ret = semTake(sem_id, WAIT_FOREVER); traceobj_assert(&trobj, ret == OK); traceobj_mark(&trobj, 10); ret = semTake(sem_id, WAIT_FOREVER); traceobj_assert(&trobj, ret == OK); traceobj_mark(&trobj, 11); ret = semGive(sem_id); traceobj_assert(&trobj, ret == OK); traceobj_mark(&trobj, 12); ret = semGive(sem_id); traceobj_assert(&trobj, ret == OK); traceobj_mark(&trobj, 13); ret = semGive(sem_id); traceobj_assert(&trobj, ret == ERROR && errno == S_semLib_INVALID_OPERATION); traceobj_mark(&trobj, 14); ret = semTake(sem_id, WAIT_FOREVER); traceobj_assert(&trobj, ret == OK); traceobj_mark(&trobj, 15); ret = taskSuspend(taskIdSelf()); traceobj_assert(&trobj, ret == OK); traceobj_mark(&trobj, 16); ret = semGive(sem_id); traceobj_assert(&trobj, ret == OK); traceobj_mark(&trobj, 17); traceobj_exit(&trobj); }