#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include <pthread.h>
#include <signal.h>
#include <sched.h>
#include <unistd.h>
#include "epicsStdio.h"
#include "ellLib.h"
#include "epicsEvent.h"
#include "epicsMutex.h"
#include "epicsString.h"
#include "epicsThread.h"
#include "cantProceed.h"
#include "errlog.h"
#include "epicsAssert.h"
#include "epicsExit.h"
#include "epicsAtomic.h"

Include dependency graph for osdThread.c:

Classes
struct	commonAttr

Macros
#define	checkStatus(status, message)

#define	checkStatusQuit(status, message, method)

#define	checkStatusOnce(status, message)

#define	checkStatusOnceQuit(status, message, method)

#define	STACK_SIZE(f) (0)

#define	EPICS_THREAD_ONCE_DONE &threadOnceComplete

Typedefs
typedef struct commonAttr	commonAttr

Functions
LIBCOM_API void	epicsThreadShowInfo (epicsThreadOSD *pthreadInfo, unsigned int level)

LIBCOM_API void	osdThreadHooksRun (epicsThreadId id)

LIBCOM_API void	osdThreadHooksRunMain (epicsThreadId id)

LIBCOM_API int	epicsThreadGetPosixPriority (epicsThreadId pthreadInfo)

LIBCOM_API void	epicsThreadRealtimeLock (void)

LIBCOM_API unsigned int epicsStdCall	epicsThreadGetStackSize (epicsThreadStackSizeClass stackSizeClass)

LIBCOM_API void epicsStdCall	epicsThreadOnce (epicsThreadOnceId id, void(func)(void ), void arg)

epicsThreadId	epicsThreadCreateOpt (const char name, EPICSTHREADFUNC funptr, void parm, const epicsThreadOpts *opts)
	Allocate and start a new OS thread. More...

void	epicsThreadMustJoin (epicsThreadId id)

LIBCOM_API void epicsStdCall	epicsThreadSuspendSelf (void)

LIBCOM_API void epicsStdCall	epicsThreadResume (epicsThreadOSD *pthreadInfo)

LIBCOM_API void epicsStdCall	epicsThreadExitMain (void)

LIBCOM_API unsigned int epicsStdCall	epicsThreadGetPriority (epicsThreadId pthreadInfo)

LIBCOM_API unsigned int epicsStdCall	epicsThreadGetPrioritySelf (void)

LIBCOM_API void epicsStdCall	epicsThreadSetPriority (epicsThreadId pthreadInfo, unsigned int priority)

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

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

LIBCOM_API int epicsStdCall	epicsThreadIsEqual (epicsThreadId p1, epicsThreadId p2)

LIBCOM_API int epicsStdCall	epicsThreadIsSuspended (epicsThreadId pthreadInfo)

LIBCOM_API void epicsStdCall	epicsThreadSleep (double seconds)
	Block the calling thread for at least the specified time. More...

LIBCOM_API epicsThreadId epicsStdCall	epicsThreadGetIdSelf (void)

LIBCOM_API pthread_t	epicsThreadGetPosixThreadId (epicsThreadId threadId)

LIBCOM_API epicsThreadId epicsStdCall	epicsThreadGetId (const char *name)

LIBCOM_API const char epicsStdCall *	epicsThreadGetNameSelf ()

LIBCOM_API void epicsStdCall	epicsThreadGetName (epicsThreadId pthreadInfo, char *name, size_t size)

LIBCOM_API void	epicsThreadMap (EPICS_THREAD_HOOK_ROUTINE func)

LIBCOM_API void epicsStdCall	epicsThreadShowAll (unsigned int level)

LIBCOM_API void epicsStdCall	epicsThreadShow (epicsThreadId showThread, unsigned int level)

LIBCOM_API epicsThreadPrivateId epicsStdCall	epicsThreadPrivateCreate (void)

LIBCOM_API void epicsStdCall	epicsThreadPrivateDelete (epicsThreadPrivateId id)

LIBCOM_API void epicsStdCall	epicsThreadPrivateSet (epicsThreadPrivateId id, void *value)

LIBCOM_API void epicsStdCall *	epicsThreadPrivateGet (epicsThreadPrivateId id)

LIBCOM_API double epicsStdCall	epicsThreadSleepQuantum ()
	Query a value approximating the OS timer/scheduler resolution. More...

LIBCOM_API int	epicsThreadGetCPUs (void)

Macro Definition Documentation

#define checkStatus	(	status,
		message
	)

Value:

if((status))  {\
    errlogPrintf("%s error %s\n",(message),strerror((status))); \
}

Definition at line 87 of file osdThread.c.

#define checkStatusOnce	(	status,
		message
	)

Value:

if((status)) {\

fprintf(stderr,"%s error %s\n",(message),strerror((status))); }

status

pvd::Status status

Definition: sharedstate_pv.cpp:122

stderr

#define stderr

Definition: epicsStdio.h:32

Definition at line 102 of file osdThread.c.

#define checkStatusOnceQuit	(	status,
		message,
		method
	)

Value:

if(status) { \
    fprintf(stderr,"%s  error %s",(message),strerror((status))); \
    fprintf(stderr," %s\n",method); \
    fprintf(stderr,"epicsThreadInit cant proceed. Program exiting\n"); \
    exit(-1);\
}

Definition at line 106 of file osdThread.c.

#define checkStatusQuit	(	status,
		message,
		method
	)

Value:

if(status) { \
    errlogPrintf("%s  error %s\n",(message),strerror((status))); \
    cantProceed((method)); \
}

Definition at line 92 of file osdThread.c.

#define EPICS_THREAD_ONCE_DONE &threadOnceComplete

#define STACK_SIZE ( f ) (0)

Definition at line 463 of file osdThread.c.

Typedef Documentation

typedef struct commonAttr commonAttr

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 529 of file osdThread.c.

 {
     unsigned int stackSize;
     epicsThreadOSD *pthreadInfo;
     int status;
     sigset_t blockAllSig, oldSig;
 
     epicsThreadInit();
     assert(pcommonAttr);
 
     if (!opts) {
         static const epicsThreadOpts opts_default = EPICS_THREAD_OPTS_INIT;
         opts = &opts_default;
     }
     stackSize = opts->stackSize;
     if (stackSize <= epicsThreadStackBig)
         stackSize = epicsThreadGetStackSize(stackSize);
 
     sigfillset(&blockAllSig);
     pthread_sigmask(SIG_SETMASK, &blockAllSig, &oldSig);
 
     pthreadInfo = init_threadInfo(name, opts->priority, stackSize, funptr,
         parm, opts->joinable);
     if (pthreadInfo==0)
         return 0;
 
     pthreadInfo->isEpicsThread = 1;
     setSchedulingPolicy(pthreadInfo, SCHED_FIFO);
     pthreadInfo->isRealTimeScheduled = 1;
 
     if (pthreadInfo->joinable) {
         /* extra ref for epicsThreadMustJoin() */
         epicsAtomicIncrIntT(&pthreadInfo->refcnt);
     }
 
     status = pthread_create(&pthreadInfo->tid, &pthreadInfo->attr,
         start_routine, pthreadInfo);
     if (status==EPERM) {
         /* Try again without SCHED_FIFO*/
         free_threadInfo(pthreadInfo);
 
         pthreadInfo = init_threadInfo(name, opts->priority, stackSize,
             funptr, parm, opts->joinable);
         if (pthreadInfo==0)
             return 0;
 
         pthreadInfo->isEpicsThread = 1;
         status = pthread_create(&pthreadInfo->tid, &pthreadInfo->attr,
             start_routine, pthreadInfo);
     }
     checkStatusOnce(status, "pthread_create");
     if (status) {
         if (pthreadInfo->joinable) {
             /* release extra ref which would have been for epicsThreadMustJoin() */
             epicsAtomicDecrIntT(&pthreadInfo->refcnt);
         }
 
         free_threadInfo(pthreadInfo);
         return 0;
     }
 
     status = pthread_sigmask(SIG_SETMASK, &oldSig, NULL);
     checkStatusOnce(status, "pthread_sigmask");
     return pthreadInfo;
 }

LIBCOM_API void epicsStdCall 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 683 of file osdThread.c.

 {
     epicsThreadOSD *pthreadInfo;
 
     epicsThreadInit();
     pthreadInfo = (epicsThreadOSD *)pthread_getspecific(getpthreadInfo);
     if(pthreadInfo==NULL)
         pthreadInfo = createImplicit();
     if(pthreadInfo->createFunc) {
         errlogPrintf("called from non-main thread\n");
         cantProceed("epicsThreadExitMain");
     }
     else {
     free_threadInfo(pthreadInfo);
     pthread_exit(0);
     }
 }

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 990 of file osdThread.c.

 {
     long ret;
 #ifdef _SC_NPROCESSORS_ONLN
     ret = sysconf(_SC_NPROCESSORS_ONLN);
     if (ret > 0)
         return ret;
 #endif
 #ifdef _SC_NPROCESSORS_CONF
     ret = sysconf(_SC_NPROCESSORS_CONF);
     if (ret > 0)
         return ret;
 #endif
     return 1;
 }

LIBCOM_API epicsThreadId epicsStdCall 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 826 of file osdThread.c.

                                                                          {
     epicsThreadOSD *pthreadInfo;
     int status;
 
     assert(epicsThreadOnceCalled);
     status = mutexLock(&listLock);
     checkStatus(status,"pthread_mutex_lock epicsThreadGetId");
     if(status)
         return NULL;
     pthreadInfo=(epicsThreadOSD *)ellFirst(&pthreadList);
     while(pthreadInfo) {
     if(strcmp(name,pthreadInfo->name) == 0) break;
         pthreadInfo=(epicsThreadOSD *)ellNext(&pthreadInfo->node);
     }
     status = pthread_mutex_unlock(&listLock);
     checkStatus(status,"pthread_mutex_unlock epicsThreadGetId");
 
     return(pthreadInfo);
 }

LIBCOM_API epicsThreadId epicsStdCall epicsThreadGetIdSelf ( void )

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

Definition at line 810 of file osdThread.c.

                                                                  {
     epicsThreadOSD *pthreadInfo;
 
     epicsThreadInit();
     pthreadInfo = (epicsThreadOSD *)pthread_getspecific(getpthreadInfo);
     if(pthreadInfo==NULL)
         pthreadInfo = createImplicit();
     assert ( pthreadInfo );
     return(pthreadInfo);
 }

LIBCOM_API void epicsStdCall 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 857 of file osdThread.c.

 {
     assert(epicsThreadOnceCalled);
     strncpy(name, pthreadInfo->name, size-1);
     name[size-1] = '\0';
 }

LIBCOM_API const char epicsStdCall* 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 846 of file osdThread.c.

 {
     epicsThreadOSD *pthreadInfo;
 
     epicsThreadInit();
     pthreadInfo = (epicsThreadOSD *)pthread_getspecific(getpthreadInfo);
     if(pthreadInfo==NULL)
         pthreadInfo = createImplicit();
     return(pthreadInfo->name);
 }

LIBCOM_API int epicsThreadGetPosixPriority ( epicsThreadId pthreadInfo )

Definition at line 115 of file osdThread.c.

 {
 #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
     double maxPriority,minPriority,slope,oss;
 
     if(pcommonAttr->maxPriority==pcommonAttr->minPriority)
         return(pcommonAttr->maxPriority);
     maxPriority = (double)pcommonAttr->maxPriority;
     minPriority = (double)pcommonAttr->minPriority;
     slope = (maxPriority - minPriority)/100.0;
     oss = (double)pthreadInfo->osiPriority * slope + minPriority;
     return((int)oss);
 #else
     return 0;
 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 }

LIBCOM_API pthread_t epicsThreadGetPosixThreadId ( epicsThreadId threadId )

Definition at line 821 of file osdThread.c.

 {
     return threadId->tid;
 }

LIBCOM_API unsigned int epicsStdCall epicsThreadGetPriority ( epicsThreadId id )

Return thread OSI priority

Definition at line 701 of file osdThread.c.

 {
     assert(epicsThreadOnceCalled);
     return(pthreadInfo->osiPriority);
 }

LIBCOM_API unsigned int epicsStdCall epicsThreadGetPrioritySelf ( void )

Return thread OSI priority

Definition at line 707 of file osdThread.c.

 {
     epicsThreadInit();
     return(epicsThreadGetPriority(epicsThreadGetIdSelf()));
 }

LIBCOM_API unsigned int epicsStdCall 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 466 of file osdThread.c.

 {
 #if defined (OSITHREAD_USE_DEFAULT_STACK)
     return 0;
 #elif defined(_POSIX_THREAD_ATTR_STACKSIZE) && _POSIX_THREAD_ATTR_STACKSIZE > 0
     if (stackSizeClass<epicsThreadStackSmall) {
         errlogPrintf("epicsThreadGetStackSize illegal argument (too small)");
         return stackSizeTable[epicsThreadStackBig];
     }
 
     if (stackSizeClass>epicsThreadStackBig) {
         errlogPrintf("epicsThreadGetStackSize illegal argument (too large)");
         return stackSizeTable[epicsThreadStackBig];
     }
 
     return stackSizeTable[stackSizeClass];
 #else
     return 0;
 #endif /*_POSIX_THREAD_ATTR_STACKSIZE*/
 }

LIBCOM_API epicsThreadBooleanStatus epicsStdCall 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 740 of file osdThread.c.

 {
     unsigned newPriority = priority - 1;
 #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
     int diff;
     diff = pcommonAttr->maxPriority - pcommonAttr->minPriority;
     if(diff<0) diff = -diff;
     if(diff>1 && diff <100) newPriority -=  100/(diff+1);
 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
     if (newPriority <= 99) {
         *pPriorityJustBelow = newPriority;
         return epicsThreadBooleanStatusSuccess;
     }
     return epicsThreadBooleanStatusFail;
 }

LIBCOM_API int epicsStdCall epicsThreadIsEqual	(	epicsThreadId	id1,
		epicsThreadId	id2
	)

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

Definition at line 776 of file osdThread.c.

 {
     assert(epicsThreadOnceCalled);
     assert(p1);
     assert(p2);
     return(pthread_equal(p1->tid,p2->tid));
 }

LIBCOM_API int epicsStdCall 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 784 of file osdThread.c.

                                                                               {
     assert(epicsThreadOnceCalled);
     assert(pthreadInfo);
     return(pthreadInfo->isSuspended ? 1 : 0);
 }

LIBCOM_API epicsThreadBooleanStatus epicsStdCall 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 757 of file osdThread.c.

 {
     unsigned newPriority = priority + 1;
 
 #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
     int diff;
     diff = pcommonAttr->maxPriority - pcommonAttr->minPriority;
     if(diff<0) diff = -diff;
     if(diff>1 && diff <100) newPriority += 100/(diff+1);
 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 
     if (newPriority <= 99) {
         *pPriorityJustAbove = newPriority;
         return epicsThreadBooleanStatusSuccess;
     }
     return epicsThreadBooleanStatusFail;
 }

LIBCOM_API void epicsThreadMap ( EPICS_THREAD_HOOK_ROUTINE func )

Call func once for every known thread.

Definition at line 864 of file osdThread.c.

 {
     epicsThreadOSD *pthreadInfo;
     int status;
 
     epicsThreadInit();
     status = mutexLock(&listLock);
     checkStatus(status, "pthread_mutex_lock epicsThreadMap");
     if (status)
         return;
     pthreadInfo=(epicsThreadOSD *)ellFirst(&pthreadList);
     while (pthreadInfo) {
         func(pthreadInfo);
         pthreadInfo = (epicsThreadOSD *)ellNext(&pthreadInfo->node);
     }
     status = pthread_mutex_unlock(&listLock);
     checkStatus(status, "pthread_mutex_unlock epicsThreadMap");
 }

void epicsThreadMustJoin ( epicsThreadId id )

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

Definition at line 632 of file osdThread.c.

 {
     void *ret = NULL;
     int status;
 
     if(!id) {
         return;
     } else if(epicsAtomicCmpAndSwapIntT(&id->joinable, 1, 0)!=1) {
         if(epicsThreadGetIdSelf()==id) {
             errlogPrintf("Warning: %s thread self-join of unjoinable\n", id->name);
 
         } 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", id->name);
         }
         return;
     }
 
     status = pthread_join(id->tid, &ret);
     if(status == EDEADLK) {
         /* Thread can't join itself (directly or indirectly)
          * so we detach instead.
          */
         status = pthread_detach(id->tid);
         checkStatusOnce(status, "pthread_detach");
     } else checkStatusOnce(status, "pthread_join");
     free_threadInfo(id);
 }

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

Definition at line 487 of file osdThread.c.

 {
     static struct epicsThreadOSD threadOnceComplete;
     #define EPICS_THREAD_ONCE_DONE &threadOnceComplete
     int status;
 
     epicsThreadInit();
     status = mutexLock(&onceLock);
     if(status) {
         fprintf(stderr,"epicsThreadOnce: pthread_mutex_lock returned %s.\n",
             strerror(status));
         exit(-1);
     }
 
     if (*id != EPICS_THREAD_ONCE_DONE) {
         if (*id == EPICS_THREAD_ONCE_INIT) { /* first call */
             *id = epicsThreadGetIdSelf();    /* mark active */
             status = pthread_mutex_unlock(&onceLock);
             checkStatusQuit(status,"pthread_mutex_unlock", "epicsThreadOnce");
             func(arg);
             status = mutexLock(&onceLock);
             checkStatusQuit(status,"pthread_mutex_lock", "epicsThreadOnce");
             *id = EPICS_THREAD_ONCE_DONE;    /* mark done */
         } else if (*id == epicsThreadGetIdSelf()) {
             status = pthread_mutex_unlock(&onceLock);
             checkStatusQuit(status,"pthread_mutex_unlock", "epicsThreadOnce");
             cantProceed("Recursive epicsThreadOnce() initialization\n");
         } else
             while (*id != EPICS_THREAD_ONCE_DONE) {
                 /* Another thread is in the above func(arg) call. */
                 status = pthread_mutex_unlock(&onceLock);
                 checkStatusQuit(status,"pthread_mutex_unlock", "epicsThreadOnce");
                 epicsThreadSleep(epicsThreadSleepQuantum());
                 status = mutexLock(&onceLock);
                 checkStatusQuit(status,"pthread_mutex_lock", "epicsThreadOnce");
             }
     }
     status = pthread_mutex_unlock(&onceLock);
     checkStatusQuit(status,"pthread_mutex_unlock","epicsThreadOnce");
 }

LIBCOM_API epicsThreadPrivateId epicsStdCall epicsThreadPrivateCreate ( void )

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

Definition at line 934 of file osdThread.c.

 {
     pthread_key_t *key;
     int status;
 
     epicsThreadInit();
     key = calloc(1,sizeof(pthread_key_t));
     if(!key)
         return NULL;
     status = pthread_key_create(key,0);
     checkStatus(status,"pthread_key_create epicsThreadPrivateCreate");
     if(status)
         return NULL;
     return((epicsThreadPrivateId)key);
 }

LIBCOM_API void epicsStdCall epicsThreadPrivateDelete ( epicsThreadPrivateId id )

Free a thread local variable

Definition at line 950 of file osdThread.c.

 {
     pthread_key_t *key = (pthread_key_t *)id;
     int status;
 
     assert(epicsThreadOnceCalled);
     status = pthread_key_delete(*key);
     checkStatusQuit(status,"pthread_key_delete","epicsThreadPrivateDelete");
     free((void *)key);
 }

LIBCOM_API void epicsStdCall* epicsThreadPrivateGet ( epicsThreadPrivateId )

Fetch the current value of a thread local variable

Definition at line 973 of file osdThread.c.

 {
     pthread_key_t *key = (pthread_key_t *)id;
 
     assert(epicsThreadOnceCalled);
     return pthread_getspecific(*key);
 }

LIBCOM_API void epicsStdCall epicsThreadPrivateSet	(	epicsThreadPrivateId	,
		void *
	)

Update thread local variable

Definition at line 961 of file osdThread.c.

 {
     pthread_key_t *key = (pthread_key_t *)id;
     int status;
 
     assert(epicsThreadOnceCalled);
     if(errVerbose && !value)
         errlogPrintf("epicsThreadPrivateSet: setting value of 0\n");
     status = pthread_setspecific(*key,value);
     checkStatusQuit(status,"pthread_setspecific","epicsThreadPrivateSet");
 }

LIBCOM_API 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 425 of file osdThread.c.

 {
 #if defined(_POSIX_MEMLOCK) && _POSIX_MEMLOCK > 0
     if (pcommonAttr->maxPriority > pcommonAttr->minPriority) {
         int status = mlockall(MCL_CURRENT | MCL_FUTURE);
 
         if (status) {
             const int err = errno;
             switch(err) {
 #ifdef __linux__
             case ENOMEM:
                 fprintf(stderr, "epicsThreadRealtimeLock "
                         "Warning: unable to lock memory.  RLIMIT_MEMLOCK is too small or missing CAP_IPC_LOCK\n");
                 break;
             case EPERM:
                 fprintf(stderr, "epicsThreadRealtimeLock "
                                 "Warning: unable to lock memory.  missing CAP_IPC_LOCK\n");
                 break;
 #endif
             default:
                 fprintf(stderr, "epicsThreadRealtimeLock "
                                 "Warning: Unable to lock the virtual address space.\n"
                                 "VM page faults may harm real-time performance. errno=%d\n",
                         err);
             }
         }
     }
 #endif
 }

LIBCOM_API void epicsStdCall epicsThreadResume ( epicsThreadOSD * pthreadInfo )

Definition at line 676 of file osdThread.c.

 {
     assert(epicsThreadOnceCalled);
     pthreadInfo->isSuspended = 0;
     epicsEventSignal(pthreadInfo->suspendEvent);
 }

LIBCOM_API void epicsStdCall epicsThreadSetPriority	(	epicsThreadId	id,
		unsigned int	priority
	)

Change OSI priority of target thread.

Definition at line 713 of file osdThread.c.

 {
 #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
     int status;
 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 
     assert(epicsThreadOnceCalled);
     assert(pthreadInfo);
     if(!pthreadInfo->isEpicsThread) {
         fprintf(stderr,"epicsThreadSetPriority called by non epics thread\n");
         return;
     }
     pthreadInfo->osiPriority = priority;
     if(!pthreadInfo->isRealTimeScheduled) return;
 
 #if defined (_POSIX_THREAD_PRIORITY_SCHEDULING) && _POSIX_THREAD_PRIORITY_SCHEDULING > 0
     if(!pcommonAttr->usePolicy) return;
     pthreadInfo->schedParam.sched_priority = epicsThreadGetPosixPriority(pthreadInfo);
     status = pthread_attr_setschedparam(
         &pthreadInfo->attr,&pthreadInfo->schedParam);
     if(errVerbose) checkStatus(status,"pthread_attr_setschedparam");
     status = pthread_setschedparam(
         pthreadInfo->tid, pthreadInfo->schedPolicy, &pthreadInfo->schedParam);
     if(errVerbose) checkStatus(status,"pthread_setschedparam");
 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 }

LIBCOM_API void epicsStdCall epicsThreadShow	(	epicsThreadId	id,
		unsigned int	level
	)

Print info about a single EPICS thread.

Definition at line 903 of file osdThread.c.

 {
     epicsThreadOSD *pthreadInfo;
     int status;
     int found = 0;
 
     epicsThreadInit();
     if(!showThread) {
         epicsThreadShowInfo(0,level);
         return;
     }
     status = mutexLock(&listLock);
     checkStatus(status,"pthread_mutex_lock epicsThreadShowAll");
     if(status)
         return;
     pthreadInfo=(epicsThreadOSD *)ellFirst(&pthreadList);
     while(pthreadInfo) {
         if (((epicsThreadId)pthreadInfo == showThread)
          || ((epicsThreadId)pthreadInfo->tid == showThread)) {
             found = 1;
             epicsThreadShowInfo(pthreadInfo,level);
         }
         pthreadInfo=(epicsThreadOSD *)ellNext(&pthreadInfo->node);
     }
     status = pthread_mutex_unlock(&listLock);
     checkStatus(status,"pthread_mutex_unlock epicsThreadShowAll");
     if(status) return;
     if (!found)
         printf("Thread %#lx (%lu) not found.\n", (unsigned long)showThread, (unsigned long)showThread);
 }

LIBCOM_API void epicsStdCall 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 883 of file osdThread.c.

 {
     epicsThreadOSD *pthreadInfo;
     int status;
 
     epicsThreadInit();
     epicsThreadShow(0,level);
     status = mutexLock(&listLock);
     checkStatus(status,"pthread_mutex_lock epicsThreadShowAll");
     if(status)
         return;
     pthreadInfo=(epicsThreadOSD *)ellFirst(&pthreadList);
     while(pthreadInfo) {
         epicsThreadShowInfo(pthreadInfo,level);
         pthreadInfo=(epicsThreadOSD *)ellNext(&pthreadInfo->node);
     }
     status = pthread_mutex_unlock(&listLock);
     checkStatus(status,"pthread_mutex_unlock epicsThreadShowAll");
 }

LIBCOM_API void epicsThreadShowInfo	(	epicsThreadOSD *	pthreadInfo,
		unsigned int	level
	)

Definition at line 22 of file osdThreadExtra.c.

 {
     if(!pthreadInfo) {
         fprintf(epicsGetStdout(),"            NAME       EPICS ID   "
             "PTHREAD ID   OSIPRI  OSSPRI  STATE\n");
     } else {
         struct sched_param param;
         int policy;
         int priority = 0;
 
         if(pthreadInfo->tid) {
             int status;
             status = pthread_getschedparam(pthreadInfo->tid,&policy,&param);
             if(!status) priority = param.sched_priority;
         }
         fprintf(epicsGetStdout(),"%16.16s %14p %12lu    %3d%8d %8.8s\n",
              pthreadInfo->name,(void *)
              pthreadInfo,(unsigned long)pthreadInfo->tid,
              pthreadInfo->osiPriority,priority,
              pthreadInfo->isSuspended?"SUSPEND":"OK");
     }
 }

LIBCOM_API void epicsStdCall 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 790 of file osdThread.c.

 {
     struct timespec delayTime;
     struct timespec remainingTime;
     double nanoseconds;
 
     if (seconds > 0) {
         delayTime.tv_sec = seconds;
         nanoseconds = (seconds - delayTime.tv_sec) *1e9;
         delayTime.tv_nsec = nanoseconds;
     }
     else {
         delayTime.tv_sec = 0;
         delayTime.tv_nsec = 0;
     }
     while (nanosleep(&delayTime, &remainingTime) == -1 &&
            errno == EINTR)
         delayTime = remainingTime;
 }

LIBCOM_API double epicsStdCall 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 981 of file osdThread.c.

 {
     double hz;
     hz = sysconf ( _SC_CLK_TCK );
     if(hz<=0)
         return 0.0;
     return 1.0 / hz;
 }

LIBCOM_API void epicsStdCall epicsThreadSuspendSelf ( void )

Block the current thread until epicsThreadResume().

Definition at line 664 of file osdThread.c.

 {
     epicsThreadOSD *pthreadInfo;
 
     epicsThreadInit();
     pthreadInfo = (epicsThreadOSD *)pthread_getspecific(getpthreadInfo);
     if(pthreadInfo==NULL)
         pthreadInfo = createImplicit();
     pthreadInfo->isSuspended = 1;
     epicsEventWait(pthreadInfo->suspendEvent);
 }

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);
 }

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation