This is Unofficial EPICS BASE Doxygen Site
initHooks.c File Reference
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include "dbDefs.h"
#include "ellLib.h"
#include "epicsMutex.h"
#include "epicsThread.h"
#include "initHooks.h"
+ Include dependency graph for initHooks.c:

Go to the source code of this file.

Classes

struct  initHookLink
 

Typedefs

typedef struct initHookLink initHookLink
 

Functions

int initHookRegister (initHookFunction func)
 
void initHookAnnounce (initHookState state)
 
void initHookFree (void)
 
const char * initHookName (int state)
 

Typedef Documentation

typedef struct initHookLink initHookLink

Function Documentation

void initHookAnnounce ( initHookState  state)

Definition at line 76 of file initHooks.c.

77 {
78  initHookLink *hook;
79 
80  initHookInit();
81 
82  epicsMutexMustLock(listLock);
83  hook = (initHookLink *)ellFirst(&functionList);
84  epicsMutexUnlock(listLock);
85 
86  while (hook != NULL) {
87  hook->func(state);
88 
89  epicsMutexMustLock(listLock);
90  hook = (initHookLink *)ellNext(&hook->node);
91  epicsMutexUnlock(listLock);
92  }
93 }
#define NULL
Definition: catime.c:38
void epicsStdCall epicsMutexUnlock(epicsMutexId pmutexNode)
Release the semaphore.
Definition: epicsMutex.cpp:140
#define ellNext(PNODE)
Find the next node in list.
Definition: ellLib.h:99
#define epicsMutexMustLock(ID)
Claim a semaphore (see epicsMutexLock()).
Definition: epicsMutex.h:214
#define ellFirst(PLIST)
Find the first node in list.
Definition: ellLib.h:89
void initHookFree ( void  )

Definition at line 95 of file initHooks.c.

96 {
97  initHookInit();
98  epicsMutexMustLock(listLock);
99  ellFree(&functionList);
100  epicsMutexUnlock(listLock);
101 }
void epicsStdCall epicsMutexUnlock(epicsMutexId pmutexNode)
Release the semaphore.
Definition: epicsMutex.cpp:140
#define ellFree(PLIST)
Free up the list.
Definition: ellLib.h:108
#define epicsMutexMustLock(ID)
Claim a semaphore (see epicsMutexLock()).
Definition: epicsMutex.h:214
const char* initHookName ( int  state)

Definition at line 106 of file initHooks.c.

107 {
108  const char *stateName[] = {
109  "initHookAtIocBuild",
110  "initHookAtBeginning",
111  "initHookAfterCallbackInit",
112  "initHookAfterCaLinkInit",
113  "initHookAfterInitDrvSup",
114  "initHookAfterInitRecSup",
115  "initHookAfterInitDevSup",
116  "initHookAfterInitDatabase",
117  "initHookAfterFinishDevSup",
118  "initHookAfterScanInit",
119  "initHookAfterInitialProcess",
120  "initHookAfterCaServerInit",
121  "initHookAfterIocBuilt",
122  "initHookAtIocRun",
123  "initHookAfterDatabaseRunning",
124  "initHookAfterCaServerRunning",
125  "initHookAfterIocRunning",
126  "initHookAtIocPause",
127  "initHookAfterCaServerPaused",
128  "initHookAfterDatabasePaused",
129  "initHookAfterIocPaused",
130  "initHookAfterInterruptAccept",
131  "initHookAtEnd"
132  };
133  if (state < 0 || state >= NELEMENTS(stateName)) {
134  return "Not an initHookState";
135  }
136  return stateName[state];
137 }
#define NELEMENTS(A)
Definition: aToIPAddr.c:21
int initHookRegister ( initHookFunction  func)

Definition at line 51 of file initHooks.c.

52 {
53  initHookLink *newHook;
54 
55  if (!func) return 0;
56 
57  initHookInit();
58 
59  newHook = (initHookLink *)malloc(sizeof(initHookLink));
60  if (!newHook) {
61  printf("Cannot malloc a new initHookLink\n");
62  return -1;
63  }
64  newHook->func = func;
65 
66  epicsMutexMustLock(listLock);
67  ellAdd(&functionList, &newHook->node);
68  epicsMutexUnlock(listLock);
69  return 0;
70 }
#define printf
Definition: epicsStdio.h:41
void epicsStdCall epicsMutexUnlock(epicsMutexId pmutexNode)
Release the semaphore.
Definition: epicsMutex.cpp:140
void ellAdd(ELLLIST *pList, ELLNODE *pNode)
Adds a node to the end of a list.
Definition: ellLib.c:24
#define epicsMutexMustLock(ID)
Claim a semaphore (see epicsMutexLock()).
Definition: epicsMutex.h:214