taskwd.c File Reference

#include <stddef.h>
#include <stdlib.h>
#include "cantProceed.h"
#include "dbDefs.h"
#include "epicsEvent.h"
#include "epicsExit.h"
#include "epicsStdioRedirect.h"
#include "epicsThread.h"
#include "epicsMutex.h"
#include "valgrind/valgrind.h"
#include "errlog.h"
#include "ellLib.h"
#include "errMdef.h"
#include "taskwd.h"

Include dependency graph for taskwd.c:

Go to the source code of this file.

Classes
struct	tNode
struct	mNode
struct	aNode
union	twdNode

Macros
#define	TASKWD_DELAY   6.0

Enumerations
enum	{ twdctlInit, twdctlRun, twdctlDisable, twdctlExit }

Functions
void	taskwdInit (void)
void	taskwdInsert (epicsThreadId tid, TASKWDFUNC callback, void *usr)
void	taskwdRemove (epicsThreadId tid)
void	taskwdMonitorAdd (const taskwdMonitor *funcs, void *usr)
void	taskwdMonitorDel (const taskwdMonitor *funcs, void *usr)
void	taskwdAnyInsert (void *key, TASKWDANYFUNC callback, void *usr)
void	taskwdAnyRemove (void *key)
LIBCOM_API void	taskwdShow (int level)

Macro Definition Documentation

#define TASKWD_DELAY   6.0

Definition at line 79 of file taskwd.c.

Enumeration Type Documentation

anonymous enum

Enumerator
twdctlInit
twdctlRun
twdctlDisable
twdctlExit

Definition at line 72 of file taskwd.c.

                     {
    twdctlInit, twdctlRun, twdctlDisable, twdctlExit
} twdCtl;

Function Documentation

void taskwdAnyInsert	(	void *	key,
		TASKWDANYFUNC	callback,
		void *	usr
	)

Definition at line 305 of file taskwd.c.

{
    struct mNode *pm;
    struct aNode *pa;

    if (callback == NULL) return;

    taskwdInit();

    pa = &allocNode()->a;
    pa->key = key;
    pa->callback = callback;
    pa->usr = usr;

    pm = &allocNode()->m;
    pm->funcs = &anyFuncs;
    pm->usr = pa;

    epicsMutexMustLock(mLock);
    ellAdd(&mList, (void *)pm);
    epicsMutexUnlock(mLock);
}

void taskwdAnyRemove

(

void *

key

)

Definition at line 328 of file taskwd.c.

{
    struct mNode *pm;
    struct aNode *pa;

    taskwdInit();

    epicsMutexMustLock(mLock);
    pm = (struct mNode *)ellFirst(&mList);
    while (pm) {
        if (pm->funcs == &anyFuncs) {
            pa = (struct aNode *)pm->usr;
            if (pa->key == key) {
                ellDelete(&mList, (void *)pm);
                freeNode((union twdNode *)pa);
                freeNode((union twdNode *)pm);
                epicsMutexUnlock(mLock);
                return;
            }
        }
        pm = (struct mNode *)ellNext(&pm->node);
    }
    epicsMutexUnlock(mLock);

    errlogPrintf("taskwdAnyRemove: Unregistered key %p\n", key);
}

void taskwdInit

(

void

)

Definition at line 167 of file taskwd.c.

{
    static epicsThreadOnceId twdOnceFlag = EPICS_THREAD_ONCE_INIT;
    epicsThreadOnce(&twdOnceFlag, twdInitOnce, NULL);
}

void taskwdInsert	(	epicsThreadId	tid,
		TASKWDFUNC	callback,
		void *	usr
	)

Definition at line 176 of file taskwd.c.

{
    struct tNode *pt;
    struct mNode *pm;

    taskwdInit();
    if (tid == 0)
       tid = epicsThreadGetIdSelf();

    pt = &allocNode()->t;
    pt->tid = tid;
    pt->callback = callback;
    pt->usr = usr;
    pt->suspended = FALSE;

    epicsMutexMustLock(mLock);
    pm = (struct mNode *)ellFirst(&mList);
    while (pm) {
        if (pm->funcs->insert) {
            pm->funcs->insert(pm->usr, tid);
        }
        pm = (struct mNode *)ellNext(&pm->node);
    }
    epicsMutexUnlock(mLock);

    epicsMutexMustLock(tLock);
    ellAdd(&tList, (void *)pt);
    epicsMutexUnlock(tLock);
}

void taskwdMonitorAdd	(	const taskwdMonitor *	funcs,
		void *	usr
	)

Definition at line 248 of file taskwd.c.

{
    struct mNode *pm;

    if (funcs == NULL) return;

    taskwdInit();

    pm = &allocNode()->m;
    pm->funcs = funcs;
    pm->usr = usr;

    epicsMutexMustLock(mLock);
    ellAdd(&mList, (void *)pm);
    epicsMutexUnlock(mLock);
}

void taskwdMonitorDel	(	const taskwdMonitor *	funcs,
		void *	usr
	)

Definition at line 265 of file taskwd.c.

{
    struct mNode *pm;

    if (funcs == NULL) return;

    taskwdInit();

    epicsMutexMustLock(mLock);
    pm = (struct mNode *)ellFirst(&mList);
    while (pm) {
        if (pm->funcs == funcs && pm->usr == usr) {
            ellDelete(&mList, (void *)pm);
            freeNode((union twdNode *)pm);
            epicsMutexUnlock(mLock);
            return;
        }
        pm = (struct mNode *)ellNext(&pm->node);
    }
    epicsMutexUnlock(mLock);

    errlogPrintf("taskwdMonitorDel: Unregistered!\n");
}

void taskwdRemove

(

epicsThreadId

tid

)

Definition at line 206 of file taskwd.c.

{
    struct tNode *pt;
    struct mNode *pm;
    char tName[40];

    taskwdInit();

    if (tid == 0)
       tid = epicsThreadGetIdSelf();

    epicsMutexMustLock(tLock);
    pt = (struct tNode *)ellFirst(&tList);
    while (pt != NULL) {
        if (tid == pt->tid) {
            ellDelete(&tList, (void *)pt);
            epicsMutexUnlock(tLock);
            freeNode((union twdNode *)pt);

            epicsMutexMustLock(mLock);
            pm = (struct mNode *)ellFirst(&mList);
            while (pm) {
                if (pm->funcs->remove) {
                    pm->funcs->remove(pm->usr, tid);
                }
                pm = (struct mNode *)ellNext(&pm->node);
            }
            epicsMutexUnlock(mLock);
            return;
        }
        pt = (struct tNode *)ellNext(&pt->node);
    }
    epicsMutexUnlock(tLock);

    epicsThreadGetName(tid, tName, sizeof(tName));
    errlogPrintf("taskwdRemove: Thread %s (%p) not registered!\n",
        tName, (void *)tid);
}

LIBCOM_API void taskwdShow

(

int

level

)

Definition at line 358 of file taskwd.c.

{
    struct tNode *pt;
    int mCount, fCount, tCount;
    char tName[40];

    epicsMutexMustLock(mLock);
    mCount = ellCount(&mList);
    epicsMutexUnlock(mLock);

    epicsMutexMustLock(fLock);
    fCount = ellCount(&fList);
    epicsMutexUnlock(fLock);

    epicsMutexMustLock(tLock);
    tCount = ellCount(&tList);
    printf("%d monitors, %d threads registered, %d free nodes\n",
        mCount, tCount, fCount);
    if (level) {
        printf("%16.16s %9s %12s %12s %12s\n",
            "THREAD NAME", "STATE", "EPICS TID", "epicsCallback", "USR ARG");
        pt = (struct tNode *)ellFirst(&tList);
        while (pt != NULL) {
            epicsThreadGetName(pt->tid, tName, sizeof(tName));
            printf("%16.16s %9s %12p %12p %12p\n",
                tName, pt->suspended ? "Suspended" : "Ok ",
                (void *)pt->tid, (void *)pt->callback, pt->usr);
            pt = (struct tNode *)ellNext(&pt->node);
        }
    }
    epicsMutexUnlock(tLock);
}