osdThread.c File Reference

#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <syslog.h>
#include <limits.h>
#include <pthread.h>
#include <rtems.h>
#include <rtems/error.h>
#include "epicsStdio.h"
#include "errlog.h"
#include "epicsMutex.h"
#include "epicsString.h"
#include "epicsThread.h"
#include "cantProceed.h"
#include "osiUnistd.h"
#include "osdInterrupt.h"
#include "epicsExit.h"
#include "epicsAtomic.h"

Include dependency graph for osdThread.c:

Go to the source code of this file.

Classes
struct	taskVar
struct	bitmap

Macros
#define	__RTEMS_VIOLATE_KERNEL_VISIBILITY__   1
#define	RTEMS_NOTEPAD_TASKVAR   11
#define	EPICS_THREAD_ONCE_DONE   (epicsThreadId) 1

Functions
LIBCOM_API void	osdThreadHooksRun (epicsThreadId id)
LIBCOM_API void	osdThreadHooksRunMain (epicsThreadId id)
int	epicsThreadGetOsiPriorityValue (int ossPriority)
int	epicsThreadGetOssPriorityValue (unsigned int osiPriority)
LIBCOM_API epicsThreadBooleanStatus	epicsThreadLowestPriorityLevelAbove (unsigned int priority, unsigned *pPriorityJustAbove)
LIBCOM_API epicsThreadBooleanStatus	epicsThreadHighestPriorityLevelBelow (unsigned int priority, unsigned *pPriorityJustBelow)
unsigned int	epicsThreadGetStackSize (epicsThreadStackSizeClass size)
void	epicsThreadExitMain (void)
void	epicsThreadRealtimeLock (void)
epicsThreadId	epicsThreadCreateOpt (const char *name, EPICSTHREADFUNC funptr, void *parm, const epicsThreadOpts *opts)
	Allocate and start a new OS thread. More...
epicsThreadId	threadMustCreate (const char *name, unsigned int priority, unsigned int stackSize, EPICSTHREADFUNC funptr, void *parm)
void	epicsThreadMustJoin (epicsThreadId id)
void	epicsThreadSuspendSelf (void)
void	epicsThreadResume (epicsThreadId id)
unsigned int	epicsThreadGetPriority (epicsThreadId id)
unsigned int	epicsThreadGetPrioritySelf (void)
void	epicsThreadSetPriority (epicsThreadId id, unsigned int osip)
int	epicsThreadIsEqual (epicsThreadId id1, epicsThreadId id2)
int	epicsThreadIsSuspended (epicsThreadId id)
void	epicsThreadSleep (double seconds)
	Block the calling thread for at least the specified time. More...
epicsThreadId	epicsThreadGetIdSelf (void)
const char *	epicsThreadGetNameSelf (void)
void	epicsThreadGetName (epicsThreadId id, char *name, size_t size)
epicsThreadId	epicsThreadGetId (const char *name)
void	epicsThreadOnce (epicsThreadOnceId *id, void(*func)(void *), void *arg)
epicsThreadPrivateId	epicsThreadPrivateCreate ()
void	epicsThreadPrivateDelete (epicsThreadPrivateId id)
void	epicsThreadPrivateSet (epicsThreadPrivateId id, void *pvt)
void *	epicsThreadPrivateGet (epicsThreadPrivateId id)
void	epicsThreadShow (epicsThreadId id, unsigned int level)
void	epicsThreadMap (EPICS_THREAD_HOOK_ROUTINE func)
void	epicsThreadShowAll (unsigned int level)
double	epicsThreadSleepQuantum (void)
	Query a value approximating the OS timer/scheduler resolution. More...
LIBCOM_API int	epicsThreadGetCPUs (void)

Macro Definition Documentation

#define __RTEMS_VIOLATE_KERNEL_VISIBILITY__   1

Definition at line 15 of file osdThread.c.

#define EPICS_THREAD_ONCE_DONE   (epicsThreadId) 1

#define RTEMS_NOTEPAD_TASKVAR   11

Definition at line 62 of file osdThread.c.

Function Documentation

epicsThreadId epicsThreadCreateOpt	(	const char *	name,
		EPICSTHREADFUNC	funptr,
		void *	parm,
		const epicsThreadOpts *	opts
	)

Allocate and start a new OS thread.

Parameters

name	A name describing this thread. Appears in various log and error message.
funptr	The thread main function.
parm	Passed to thread main function.
opts	Modifiers for the new thread, or NULL to use target specific defaults.

Returns

NULL on error

Definition at line 308 of file osdThread.c.

{
    unsigned int stackSize;
    rtems_id tid;
    rtems_status_code sc;
    char c[4];

    if (!initialized)
        epicsThreadInit();

    if (!opts) {
        static const epicsThreadOpts opts_default = EPICS_THREAD_OPTS_INIT;
        opts = &opts_default;
    }
    stackSize = opts->stackSize;
    if (stackSize <= epicsThreadStackBig)
        stackSize = epicsThreadGetStackSize(stackSize);

    if (stackSize < RTEMS_MINIMUM_STACK_SIZE) {
        errlogPrintf ("Warning: epicsThreadCreate %s illegal stackSize %d\n",
            name, stackSize);
        stackSize = RTEMS_MINIMUM_STACK_SIZE;
    }
    strncpy (c, name, sizeof c);
    sc = rtems_task_create (rtems_build_name (c[0], c[1], c[2], c[3]),
         epicsThreadGetOssPriorityValue (opts->priority),
         stackSize,
         RTEMS_PREEMPT|RTEMS_NO_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0),
         RTEMS_FLOATING_POINT|RTEMS_LOCAL,
         &tid);
    if (sc !=  RTEMS_SUCCESSFUL) {
        errlogPrintf ("epicsThreadCreate create failure for %s: %s\n",
            name, rtems_status_text(sc));
        return 0;
    }
    sc = setThreadInfo (tid, name, funptr, parm, opts->joinable);
    if (sc != RTEMS_SUCCESSFUL) {
        errlogPrintf ("epicsThreadCreate create failure during setup for %s: %s\n",
            name, rtems_status_text(sc));
        rtems_task_delete(tid);
        return 0;
    }
    return (epicsThreadId)tid;
}

void epicsThreadExitMain

(

void

)

If the main routine is done but wants to let other threads run it can call this routine. This should be the last call in main, except the final return. On most systems epicsThreadExitMain never returns.This must only be called by the main thread.

Definition at line 219 of file osdThread.c.

{
}

LIBCOM_API int epicsThreadGetCPUs

(

void

)

Return a value approximating the number of threads which this target can run in parallel. This value is advisory.

Returns

>=1

Definition at line 862 of file osdThread.c.

{
#if defined(RTEMS_SMP)
    return rtems_smp_get_number_of_processors();
#else
    return 1;
#endif
}

epicsThreadId epicsThreadGetId

(

const char *

name

)

Attempt to find the first instance of a thread by name.

Returns

An epicsThreadId, or NULL if no such thread is currently running. Note that a non-NULL ID may still be invalid if this call races with thread exit.

Warning

Safe use of this function requires external knowledge that this thread will not return.

Definition at line 579 of file osdThread.c.

{
    struct taskVar *v;
    rtems_id tid = 0;

    /*
     * Linear search is good enough since this routine
     * is invoked only by command-line calls.
     */
    taskVarLock ();
    for (v = taskVarHead ; v != NULL ; v = v->forw) {
        if (strcmp (name, v->name) == 0) {
            tid = v->id;
            break;
        }
    }
    taskVarUnlock ();
    return (epicsThreadId)tid;
}

epicsThreadId epicsThreadGetIdSelf

(

void

)

Find an epicsThreadId associated with the current thread. For non-EPICS threads, a new epicsThreadId may be allocated.

Definition at line 510 of file osdThread.c.

{
    rtems_id tid;

    rtems_task_ident (RTEMS_SELF, 0, &tid);
    return (epicsThreadId)tid;
}

void epicsThreadGetName	(	epicsThreadId	id,
		char *	name,
		size_t	size
	)

Copy out the thread name into the provided buffer.

Guaranteed to be null terminated. size is number of bytes in buffer to hold name (including terminator). Failure results in an empty string stored in name.

Definition at line 528 of file osdThread.c.

{
    rtems_id tid = (rtems_id)id;
    struct taskVar *v;
    int haveName = 0;

    taskVarLock ();
    for (v=taskVarHead ; v != NULL ; v=v->forw) {
        if (v->id == tid) {
            strncpy(name, v->name, size);
            haveName = 1;
            break;
        }
    }
    taskVarUnlock ();
    if (!haveName) {
#if (__RTEMS_MAJOR__>4 || \
    (__RTEMS_MAJOR__==4 && __RTEMS_MINOR__>8) || \
    (__RTEMS_MAJOR__==4 && __RTEMS_MINOR__==8 && __RTEMS_REVISION__>=99))
        if (_Objects_Get_name_as_string((rtems_id)id, size, name) != NULL)
            haveName = 1;
#else
        /*
         * Try to get the RTEMS task name
         */
        Thread_Control *thr;
        Objects_Locations l;
        if ((thr=_Thread_Get(tid, &l)) != NULL) {
            if (OBJECTS_LOCAL == l) {
                int length;
                Objects_Information *oi = _Objects_Get_information(tid);
                if (oi->name_length >= size)
                    length = size - 1;
                else
                    length = oi->name_length;
                 if (oi->is_string)
                     strncpy(name, thr->Object.name, length);
                else
                    _Objects_Copy_name_raw( &thr->Object.name, name, length);
                name[length] = '\0';
                haveName = 1;
            }
            _Thread_Enable_dispatch();
        }
#endif
    }
    if (!haveName)
        snprintf(name, size, "0x%lx", (long)tid);
    name[size-1] = '\0';
}

const char* epicsThreadGetNameSelf

(

void

)

Return the name of the current thread.

Returns

Never NULL. Storage lifetime tied to epicsThreadId.

This is either a copy of the string passed to epicsThread*Create*(), or an arbitrary unique string for non-EPICS threads.

Definition at line 518 of file osdThread.c.

{
    uint32_t note;
    struct taskVar *v;

    rtems_task_get_note (RTEMS_SELF, RTEMS_NOTEPAD_TASKVAR, &note);
    v = (void *)note;
    return v->name;
}

int epicsThreadGetOsiPriorityValue

(

int

ossPriority

)

Definition at line 85 of file osdThread.c.

{
    if (ossPriority < 100) {
        return epicsThreadPriorityMax;
    }
    else if (ossPriority > 199) {
        return epicsThreadPriorityMin;
    }
    else {
        return (199u - (unsigned int)ossPriority);
    }
}

int epicsThreadGetOssPriorityValue

(

unsigned int

osiPriority

)

Definition at line 98 of file osdThread.c.

{
    if (osiPriority > 99) {
        return 100;
    }
    else {
        return (199 - (signed int)osiPriority);
    }
}

unsigned int epicsThreadGetPriority

(

epicsThreadId

id

)

Return thread OSI priority

Definition at line 434 of file osdThread.c.

{
    rtems_id tid = (rtems_id)id;
    rtems_status_code sc;
    rtems_task_priority pri;

    sc = rtems_task_set_priority (tid, RTEMS_CURRENT_PRIORITY, &pri);
    if (sc != RTEMS_SUCCESSFUL)
        errlogPrintf("epicsThreadGetPriority failed: %s\n",
            rtems_status_text(sc));
    return epicsThreadGetOsiPriorityValue(pri);
}

unsigned int epicsThreadGetPrioritySelf

(

void

)

Return thread OSI priority

Definition at line 447 of file osdThread.c.

{
    return epicsThreadGetPriority((epicsThreadId)RTEMS_SELF);
}

unsigned int epicsThreadGetStackSize

(

epicsThreadStackSizeClass

size

)

Get a stack size value that can be given to epicsThreadCreate().

Parameters

size	one of the values epicsThreadStackSmall, epicsThreadStackMedium or epicsThreadStackBig.

Definition at line 140 of file osdThread.c.

{
    unsigned int stackSize = 11000;
    switch(size) {
    case epicsThreadStackSmall:  stackSize = 5000; break;
    case epicsThreadStackMedium: stackSize = 8000; break;
    case epicsThreadStackBig:                      break;
    default:
        errlogPrintf("epicsThreadGetStackSize illegal argument");
        break;
    }
    if (stackSize < RTEMS_MINIMUM_STACK_SIZE)
        stackSize = RTEMS_MINIMUM_STACK_SIZE;
    return stackSize;
}

LIBCOM_API epicsThreadBooleanStatus epicsThreadHighestPriorityLevelBelow	(	unsigned int	priority,
		unsigned *	pPriorityJustBelow
	)

Lookup the next usage OSI priority such that priority > *pPriorityJustBelow if this is possible with the current target configuration and privlages.

Definition at line 128 of file osdThread.c.

{
    unsigned newPriority = priority - 1;

    if (newPriority <= 99) {
        *pPriorityJustBelow = newPriority;
        return epicsThreadBooleanStatusSuccess;
    }
    return epicsThreadBooleanStatusFail;
}

int epicsThreadIsEqual	(	epicsThreadId	id1,
		epicsThreadId	id2
	)

Test if two thread IDs actually refer to the same OS thread

Definition at line 466 of file osdThread.c.

{
    return (id1 == id2);
}

int epicsThreadIsSuspended

(

epicsThreadId

id

)

How and why a thread can be suspended is implementation dependent. A thread calling epicsThreadSuspendSelf() should result in this routine returning true for that thread, but a thread may also be suspended for other reasons.

Definition at line 472 of file osdThread.c.

{
    rtems_id tid = (rtems_id)id;
    rtems_status_code sc;

    switch (sc = rtems_task_is_suspended (tid)) {
    case RTEMS_SUCCESSFUL:
        return 0;

    case RTEMS_ALREADY_SUSPENDED:
        return 1;

    default:
        return 1;
    }
}

LIBCOM_API epicsThreadBooleanStatus epicsThreadLowestPriorityLevelAbove	(	unsigned int	priority,
		unsigned *	pPriorityJustAbove
	)

Lookup the next usage OSI priority such that priority < *pPriorityJustBelow if this is possible with the current target configuration and privlages.

Definition at line 112 of file osdThread.c.

{
    unsigned newPriority = priority + 1;

    newPriority = priority + 1;
    if (newPriority <= 99) {
        *pPriorityJustAbove = newPriority;
        return epicsThreadBooleanStatusSuccess;
    }
    return epicsThreadBooleanStatusFail;
}

void epicsThreadMap

(

EPICS_THREAD_HOOK_ROUTINE

func

)

Call func once for every known thread.

Definition at line 820 of file osdThread.c.

{
    struct taskVar *v;

    taskVarLock ();
    /*
     * Map tasks in the order of creation (backwards through list)
     */
    for (v = taskVarHead ; v != NULL && v->forw != NULL ; v = v->forw)
        continue;
    while (v) {
        func ((epicsThreadId)v->id);
        v = v->back;
    }
    taskVarUnlock ();
}

void epicsThreadMustJoin

(

epicsThreadId

id

)

Wait for a joinable thread to exit (return from its main function)

Definition at line 367 of file osdThread.c.

{
    rtems_id target_tid = (rtems_id)id, self_tid;
    struct taskVar *v = 0;

    rtems_task_ident (RTEMS_SELF, 0, &self_tid);

    {
        uint32_t note;
        rtems_task_get_note (target_tid, RTEMS_NOTEPAD_TASKVAR, &note);
        v = (void *)note;
    }
    /* 'v' may be NULL if 'id' represents a non-EPICS thread other than _main_. */

    if(!v || !v->joinable) {
        if(epicsThreadGetIdSelf()==id) {
            errlogPrintf("Warning: %s thread self-join of unjoinable\n", v ? v->name : "non-EPICS thread");

        } else {
            /* try to error nicely, however in all likelyhood de-ref of
             * 'id' has already caused SIGSEGV as we are racing thread exit,
             * which free's 'id'.
             */
            cantProceed("Error: %s thread not joinable.\n", v->name);
        }
        return;

    } else if(target_tid!=self_tid) {
        /* wait for target to complete */
        rtems_status_code sc = rtems_barrier_wait(v->join_barrier, RTEMS_NO_TIMEOUT);
        if(sc!=RTEMS_SUCCESSFUL)
            cantProceed("oopsj %s\n", rtems_status_text(sc));

        if(sc != RTEMS_SUCCESSFUL) {
            errlogPrintf("epicsThreadMustJoin('%s') -> %s\n", v->name, rtems_status_text(sc));
        }
    }

    v->joinable = 0;
    taskUnref(v);
    /* target task may be deleted.
     * self task is not deleted, even for self join.
     */
}

void epicsThreadOnce	(	epicsThreadOnceId *	id,
		void(*)(void *)	func,
		void *	arg
	)

Definition at line 602 of file osdThread.c.

{
    #define EPICS_THREAD_ONCE_DONE (epicsThreadId) 1

    if (!initialized) epicsThreadInit();
    epicsMutexOsdMustLock(onceMutex);
    if (*id != EPICS_THREAD_ONCE_DONE) {
        if (*id == EPICS_THREAD_ONCE_INIT) { /* first call */
            *id = epicsThreadGetIdSelf();    /* mark active */
            epicsMutexOsdUnlock(onceMutex);
            func(arg);
            epicsMutexOsdMustLock(onceMutex);
            *id = EPICS_THREAD_ONCE_DONE;    /* mark done */
        } else if (*id == epicsThreadGetIdSelf()) {
            epicsMutexOsdUnlock(onceMutex);
            cantProceed("Recursive epicsThreadOnce() initialization\n");
        } else
            while (*id != EPICS_THREAD_ONCE_DONE) {
                /* Another thread is in the above func(arg) call. */
                epicsMutexOsdUnlock(onceMutex);
                epicsThreadSleep(epicsThreadSleepQuantum());
                epicsMutexOsdMustLock(onceMutex);
            }
    }
    epicsMutexOsdUnlock(onceMutex);
}

epicsThreadPrivateId epicsThreadPrivateCreate

(

void

)

Allocate a new thread local variable. This variable will initially hold NULL for each thread.

Definition at line 633 of file osdThread.c.

{
    unsigned int taskVarIndex;
    static volatile unsigned int threadVariableCount = 0;

    if (!initialized) epicsThreadInit ();
    taskVarLock ();
    taskVarIndex = ++threadVariableCount;
    taskVarUnlock ();
    return (epicsThreadPrivateId)taskVarIndex;
}

void epicsThreadPrivateDelete

(

epicsThreadPrivateId

id

)

Free a thread local variable

Definition at line 645 of file osdThread.c.

{
    /* empty */
}

void* epicsThreadPrivateGet

(

epicsThreadPrivateId

)

Fetch the current value of a thread local variable

Definition at line 671 of file osdThread.c.

{
    unsigned int varIndex = (unsigned int)id;
    uint32_t note;
    struct taskVar *v;

    rtems_task_get_note (RTEMS_SELF, RTEMS_NOTEPAD_TASKVAR, &note);
    v = (struct taskVar *)note;
    if (varIndex >= v->threadVariableCapacity)
        return NULL;
    return v->threadVariables[varIndex];
}

void epicsThreadPrivateSet	(	epicsThreadPrivateId	,
		void *
	)

Update thread local variable

Definition at line 650 of file osdThread.c.

{
    unsigned int varIndex = (unsigned int)id;
    uint32_t note;
    struct taskVar *v;
    int i;

    rtems_task_get_note (RTEMS_SELF, RTEMS_NOTEPAD_TASKVAR, &note);
    v = (struct taskVar *)note;
    if (varIndex >= v->threadVariableCapacity) {
        v->threadVariables = realloc (v->threadVariables,
            (varIndex + 1) * sizeof(void *));
        if (v->threadVariables == NULL)
            cantProceed("epicsThreadPrivateSet realloc failed\n");
        for (i = v->threadVariableCapacity ; i < varIndex ; i++)
            v->threadVariables[i] = NULL;
        v->threadVariableCapacity = varIndex + 1;
    }
    v->threadVariables[varIndex] = pvt;
}

void epicsThreadRealtimeLock

(

void

)

When real-time scheduling is active, attempt any post-init operations that preserve real-time performance. For POSIX targets this locks the process into RAM, preventing swap-related VM faults.

Definition at line 301 of file osdThread.c.

{}

void epicsThreadResume

(

epicsThreadId

id

)

Resume a thread suspended with epicsThreadSuspendSelf()

Definition at line 423 of file osdThread.c.

{
    rtems_id tid = (rtems_id)id;
    rtems_status_code sc;

    sc = rtems_task_resume (tid);
    if (sc != RTEMS_SUCCESSFUL)
        errlogPrintf("epicsThreadResume failed: %s\n",
            rtems_status_text (sc));
}

void epicsThreadSetPriority	(	epicsThreadId	id,
		unsigned int	priority
	)

Change OSI priority of target thread.

Definition at line 453 of file osdThread.c.

{
    rtems_id tid = (rtems_id)id;
    rtems_status_code sc;
    rtems_task_priority pri = epicsThreadGetOssPriorityValue(osip);

    sc = rtems_task_set_priority (tid, pri, &pri);
    if (sc != RTEMS_SUCCESSFUL)
        errlogPrintf("epicsThreadSetPriority failed: %s\n",
            rtems_status_text(sc));
}

void epicsThreadShow	(	epicsThreadId	id,
		unsigned int	level
	)

Print info about a single EPICS thread.

Definition at line 800 of file osdThread.c.

{
    struct taskVar *v;

    if (!id) {
        epicsThreadShowInfo (NULL, level);
        return;
    }
    taskVarLock ();
    for (v = taskVarHead ; v != NULL ; v = v->forw) {
        if ((rtems_id)id == v->id) {
            epicsThreadShowInfo (v, level);
            taskVarUnlock ();
            return;
        }
    }
    taskVarUnlock ();
    fprintf(epicsGetStdout(),"*** Thread %x does not exist.\n", (unsigned int)id);
}

void epicsThreadShowAll

(

unsigned int

level

)

Print to stdout information about all running EPICS threads.

Parameters

level

0 prints minimal output. Higher values print more details.

Definition at line 837 of file osdThread.c.

{
    struct taskVar *v;

    epicsThreadShowInfo (NULL, level);
    taskVarLock ();
    /*
     * Show tasks in the order of creation (backwards through list)
     */
    for (v = taskVarHead ; v != NULL && v->forw != NULL ; v = v->forw)
        continue;
    while (v) {
        epicsThreadShowInfo (v, level);
        v = v->back;
    }
    taskVarUnlock ();
}

void epicsThreadSleep

(

double

seconds

)

Block the calling thread for at least the specified time.

Parameters

seconds

Time to wait in seconds. Values <=0 blocks for the shortest possible time.

Definition at line 490 of file osdThread.c.

{
    rtems_status_code sc;
    rtems_interval delay;
    extern double rtemsTicksPerSecond_double;

    if (seconds > 0.0) {
        seconds *= rtemsTicksPerSecond_double;
        seconds += 0.99999999;  /* 8 9s here is optimal */
        delay = (seconds >= INT_MAX) ? INT_MAX : (int) seconds;
    }
    else {  /* seconds <= 0 or NAN */
        delay = 0;
    }
    sc = rtems_task_wake_after (delay);
    if(sc != RTEMS_SUCCESSFUL)
        errlogPrintf("epicsThreadSleep: %s\n", rtems_status_text(sc));
}

double epicsThreadSleepQuantum

(

void

)

Query a value approximating the OS timer/scheduler resolution.

Returns

A value in seconds >=0

Warning

On targets other than vxWorks and RTEMS, the quantum value often isn't meaningful. Use of this function is discouraged in portable code.

Definition at line 855 of file osdThread.c.

{
    extern double rtemsTicksPerSecond_double;

    return 1.0 / rtemsTicksPerSecond_double;
}

void epicsThreadSuspendSelf

(

void

)

Block the current thread until epicsThreadResume().

Definition at line 413 of file osdThread.c.

{
    rtems_status_code sc;

    sc = rtems_task_suspend (RTEMS_SELF);
    if (sc != RTEMS_SUCCESSFUL)
        errlogPrintf("epicsThreadSuspendSelf failed: %s\n",
            rtems_status_text(sc));
}

LIBCOM_API void osdThreadHooksRun

(

epicsThreadId

id

)

Definition at line 105 of file osdThreadHooks.c.

{
    threadHookInit();

    if (epicsMutexLock(hookLock) == epicsMutexLockOK) {
        epicsThreadHook *pHook = (epicsThreadHook *) ellFirst(&hookList);

        while (pHook) {
            pHook->func(id);
            pHook = (epicsThreadHook *) ellNext(&pHook->node);
        }
        epicsMutexUnlock(hookLock);
    }
    else {
        fprintf(stderr, "osdThreadHooksRun: Locking problem\n");
    }
}

LIBCOM_API void osdThreadHooksRunMain

(

epicsThreadId

id

)

Definition at line 99 of file osdThreadHooks.c.

{
    if (epicsThreadHookMain)
        epicsThreadHookMain(id);
}

epicsThreadId threadMustCreate	(	const char *	name,
		unsigned int	priority,
		unsigned int	stackSize,
		EPICSTHREADFUNC	funptr,
		void *	parm
	)

Definition at line 356 of file osdThread.c.

{
    epicsThreadId tid = epicsThreadCreate(name, priority, stackSize, funptr, parm);

    if (tid == NULL)
        cantProceed(0);
    return tid;
}