// Блокировать текущий поток на заданный интервал времени
void damWait(uint32 ms, int *br)
{
uint32 currentTime = os_timeGet(); // Текущее время
uint32 timeoutTime = currentTime + ms;
while (currentTime < timeoutTime &&
(br == 0 || (br != 0 && !(*br))) ) {
currentTime = os_timeGet();
}
}
static in_result
in_ddsiStreamReaderImplScan(
in_ddsiStreamReaderImpl _this,
in_streamReaderCallbackTable callbackTable,
in_streamReaderCallbackArg callbackArg,
os_time *timeout)
{
in_result result = IN_RESULT_OK;
os_time now = os_timeGet();
os_time deadline = os_timeAdd(now, *timeout);
os_time recvTimeout;
os_boolean continueLoop = OS_TRUE;
os_boolean deadlineNotPassed = OS_TRUE;
/* init */
in_ddsiStreamReaderImplSetCallbackTable(_this,
callbackTable,
callbackArg);
/* iterate: wait for messages until timeout exceeded */
do {
/* each iteration the receiveTimeout decreases, "now" guarantees
* positive receiveTimeout */
recvTimeout = os_timeSub(deadline, now);
if (!in_ddsiStreamReaderImplFetchBuffer(_this, &recvTimeout, &result)) {
/* either timeout or criticial error, such as network down */
continueLoop = OS_FALSE;
} else {
/* verify the originator of the message is not this process itself.
* This case might be caused by loopback routing of outbound messages. */
if (callbackTable->isLocalEntity &&
callbackTable->isLocalEntity(
callbackArg,
_this->receiver.sourceGuidPrefix)) {
/* slow path */
continueLoop = OS_FALSE;
} else {
/* fast path */
result = in_ddsiStreamReaderImplScanBuffer(_this);
}
/* all messages have been parsed from the buffer */
in_ddsiStreamReaderImplReleaseBuffer(_this);
/* update 'now' for next iteration */
now = os_timeGet();
}
deadlineNotPassed = os_timeCompare(now, deadline) == OS_LESS;
} while (continueLoop && deadlineNotPassed);
in_ddsiStreamReaderImplResetCallbackTable(_this);
return result;
}
static void
os_defaultDiag (
const char *cluster,
os_diagLevel level,
const char *description,
va_list args)
{
os_time ostime;
char extended_description[512];
char procIdentity[64];
char threadIdentity[64];
char node[64];
ostime = os_timeGet();
os_vsnprintf (extended_description, sizeof(extended_description)-1, description, args);
extended_description [sizeof(extended_description)-1] = '\0';
os_gethostname (node, sizeof(node));
os_threadFigureIdentity (threadIdentity, sizeof (threadIdentity)-1);
threadIdentity [sizeof (threadIdentity)-1] = '\0';
os_procFigureIdentity (procIdentity, sizeof (procIdentity)-1);
procIdentity [sizeof (procIdentity)-1] = '\0';
printf (
"Diag - %s:%s:%s - T:%d.%9.9d L:%s C:%s D:%s\n",
node,
procIdentity,
threadIdentity,
ostime.tv_sec,
ostime.tv_nsec,
os_diagLevelText[level],
cluster,
extended_description);
}
/* NOTE: Blatantly stolen from the "native" networking implementation
(src/services/networking/code/nw_controller.c). Methinks these
should be guaranteed unique, not hopefully unique. Surely one could
just a "service instance id" or somesuch for this purpose ...
NOTE 2: And fixed after stealing ... Native networking uses (0 <=
id < (1e9-1)), we use one in (1e-9 <= id' < (2e9-1)). So there
never should (1) be an id collision and (2) an accidental use of
LOCAL by DDSI2. */
static v_networkId
getNetworkId(void)
{
os_time time;
/* NOTE: for now, let network ID be a "random"-number. This number has to be
* retrieved from the network/os layer. */
assert (V_NETWORKID_LOCAL == 0x0);
time = os_timeGet();
return time.tv_nsec + 1000000000;
}
int
s_kernelManagerWaitForActive(
s_kernelManager km)
{
int result;
os_time delay = {1, 0};
os_time cur;
os_time start;
os_result osr;
os_mutexLock(&km->mtx);
osr = os_resultSuccess;
cur = os_timeGet();
start = cur;
while ((km->active < 2) && (cur.tv_sec - start.tv_sec < 20)) {
osr = os_condTimedWait(&km->cv, &km->mtx, &delay);
cur = os_timeGet();
}
result = km->active;
os_mutexUnlock(&km->mtx);
return result;
}
static void
removeProcesses(
int pid,
os_time serviceTerminatePeriod)
{
os_time stopTime;
#ifndef NDEBUG
printf("\nWait %d.%d seconds for all processes to terminate\n",
serviceTerminatePeriod.tv_sec,serviceTerminatePeriod.tv_nsec);
#endif
stopTime = os_timeAdd(os_timeGet(), serviceTerminatePeriod);
kill (pid, SIGTERM);
while ((kill (pid, 0) != -1) && (os_timeCompare(os_timeGet(), stopTime) == OS_LESS) )
{
printf ("."); fflush (stdout);
sleep (1);
}
printf("\n");
if (kill (pid, 0) != -1)
{
printf ("Process %d would not terminate.\n", pid);
printf ("Using force now on ");
kill_descendents (pid, SIGKILL);
kill (pid, SIGKILL);
stopTime = os_timeAdd(os_timeGet(), serviceTerminatePeriod);
while ((kill (pid, 0) != -1) && (os_timeCompare(os_timeGet(), stopTime) == OS_LESS))
{
printf ("."); fflush (stdout);
sleep (1);
}
if (kill (pid, 0) != -1)
{
printf ("\nProcess %d would not terminate, bailing out\n", pid);
}
}
}
/** \brief Wait for the condition but return when the specified
* time has expired before the condition is triggered
*
* \b os_condTimedWait calls \b pthread_cond_timedwait to
* wait for the condition with a timeout.
*
* \b os_condTimedWait provides an relative time to wait while
* \b pthread_cond_timedwait expects an absolute time to wakeup.
* The absolute time is calculated from the current time + the
* provided relative time.
*
* \b os_condTimedWait will repeat \b pthread_cond_timedwait in case of an
* interrupted system call. Because the time which is passed onto
* \b pthread_cond_timedwait is absolute, no remaining time must be
* calculated.
*/
os_result
os_condTimedWait (
os_cond *cond,
os_mutex *mutex,
const os_time *time)
{
struct timespec t;
int result;
os_time wakeup_time;
os_result rv;
assert (cond != NULL);
assert (mutex != NULL);
assert (time != NULL);
#ifdef OSPL_STRICT_MEM
assert( cond->signature == OS_COND_MAGIC_SIG );
assert( mutex->signature == OS_MUTEX_MAGIC_SIG );
#endif
wakeup_time = os_timeAdd (os_timeGet(), *time);
t.tv_sec = wakeup_time.tv_sec;
t.tv_nsec = wakeup_time.tv_nsec;
do {
#ifdef OSPL_STRICT_MEM
result = pthread_cond_timedwait (&cond->cond, &mutex->mutex, &t);
#else
result = pthread_cond_timedwait (cond, mutex, &t);
#endif
} while (result == EINTR);
if (result == 0) {
rv = os_resultSuccess;
} else if (result == ETIMEDOUT) {
rv = os_resultTimeout;
} else {
rv = os_resultFail;
}
return rv;
}
c_bool
d_statusListenerStart(
d_statusListener listener)
{
c_bool result;
d_actionQueue queue;
d_admin admin;
os_time sleepTime, execTime;
assert(d_listenerIsValid(d_listener(listener), D_STATUS_LISTENER));
result = d_readerListenerStart(d_readerListener(listener));
if(result == TRUE){
result = FALSE;
d_listenerLock(d_listener(listener));
/* 200 ms */
sleepTime.tv_sec = 0;
sleepTime.tv_nsec = 200000000;
execTime = os_timeAdd(os_timeGet(), sleepTime);
admin = d_listenerGetAdmin(d_listener(listener));
queue = d_adminGetActionQueue(admin);
listener->cleanupAction = d_actionNew(execTime, sleepTime,
d_statusListenerRemoveDeadFellows,
admin);
result = d_actionQueueAdd(queue, listener->cleanupAction);
d_listenerUnlock(d_listener(listener));
if(result == FALSE){
d_readerListenerStop(d_readerListener(listener));
d_actionFree(listener->cleanupAction);
listener->cleanupAction = NULL;
}
}
return result;
}
static void
s_printState(
spliced s,
s_configuration config,
const char* threadName)
{
os_time time;
if (config->tracingOutputFile) {
if (config->tracingTimestamps == TRUE) {
time = os_timeGet();
if (config->tracingRelativeTimestamps == TRUE) {
time = os_timeSub(time, config->startTime);
}
fprintf(config->tracingOutputFile, "%d.%9.9d (%s) -> ",
time.tv_sec, time.tv_nsec, threadName);
} else {
fprintf(config->tracingOutputFile, "(%s) -> ", threadName);
}
}
}
void
monitor_msAction (
v_entity entity,
c_voidp args
)
{
time_t ct;
int cv;
char timbuf[30];
char extra[70];
c_mm mm;
c_mmStatus s;
c_mmStatus ms,ls;
c_base base;
monitor_ms msData;
msData = monitor_ms(args);
base = c_getBase(entity);
mm = c_baseMM(base);
s = c_mmState(mm, msData->preallocated);
ms = c_mmMapState(mm);
ls = c_mmListState(mm);
if (msData->rawMode == FALSE) {
time (&ct);
if (msData->header == 0) {
strftime (timbuf, sizeof(timbuf), "%d/%m/%Y", localtime(&ct));
if (msData->delta && msData->preallocated) {
printf (MM_MS_TIME_BUF_FMT
MM_MS_D_AVAILABLE_HDR_FMT
MM_MS_D_COUNT_HDR_FMT
MM_MS_D_USED_HDR_FMT
MM_MS_D_PREALLOCATED_HDR_FMT
MM_MS_D_MAXUSED_HDR_FMT
MM_MS_D_REUSABLE_HDR_FMT
MM_MS_D_FAILS_HDR_FMT
MM_MS_NEWLINE
,
timbuf,
MM_MS_D_AVAILABLE_HDR,
MM_MS_D_COUNT_HDR,
MM_MS_D_USED_HDR,
MM_MS_D_PREALLOCATED_HDR,
MM_MS_D_MAXUSED_HDR,
MM_MS_D_REUSABLE_HDR,
MM_MS_D_FAILS_HDR);
msData->header = 1;
} else if(msData->delta){
printf (MM_MS_TIME_BUF_FMT
MM_MS_D_AVAILABLE_HDR_FMT
MM_MS_D_COUNT_HDR_FMT
MM_MS_D_USED_HDR_FMT
MM_MS_D_MAXUSED_HDR_FMT
MM_MS_D_REUSABLE_HDR_FMT
MM_MS_D_FAILS_HDR_FMT
MM_MS_NEWLINE
,
timbuf,
MM_MS_D_AVAILABLE_HDR,
MM_MS_D_COUNT_HDR,
MM_MS_D_USED_HDR,
MM_MS_D_MAXUSED_HDR,
MM_MS_D_REUSABLE_HDR,
MM_MS_D_FAILS_HDR);
msData->header = 1;
} else if(msData->preallocated){
printf (MM_MS_TIME_BUF_HDR_FMT
MM_MS_AVAILABLE_HDR_FMT
MM_MS_COUNT_HDR_FMT
MM_MS_USED_HDR_FMT
MM_MS_PREALLOCATED_HDR_FMT
MM_MS_MAXUSED_HDR_FMT
MM_MS_REUSABLE_HDR_FMT
MM_MS_FAILS_HDR_FMT
MM_MS_NEWLINE
,
timbuf,
MM_MS_AVAILABLE_HDR,
MM_MS_COUNT_HDR,
MM_MS_USED_HDR,
MM_MS_PREALLOCATED_HDR,
MM_MS_MAXUSED_HDR,
MM_MS_REUSABLE_HDR,
MM_MS_FAILS_HDR);
msData->header = 15;
} else {
printf (MM_MS_TIME_BUF_HDR_FMT
MM_MS_AVAILABLE_HDR_FMT
MM_MS_COUNT_HDR_FMT
MM_MS_USED_HDR_FMT
MM_MS_MAXUSED_HDR_FMT
MM_MS_REUSABLE_HDR_FMT
MM_MS_FAILS_HDR_FMT
MM_MS_NEWLINE
,
timbuf,
MM_MS_AVAILABLE_HDR,
MM_MS_COUNT_HDR,
MM_MS_USED_HDR,
MM_MS_MAXUSED_HDR,
MM_MS_REUSABLE_HDR,
MM_MS_FAILS_HDR);
msData->header = 15;
}
}
strftime (timbuf, sizeof(timbuf), "%H:%M:%S", localtime(&ct));
} else {
/* no headers and print time as seconds since start of mmstat */
os_time now = os_timeGet();
os_sprintf(timbuf,"%d.%9.9d ",now.tv_sec,now.tv_nsec);
}
if (msData->extendedMode) {
cv = ((s.used * 40)/s.size);
os_strncpy (extra, " | |\r\n",
sizeof(extra));
extra [cv+3] = '*';
} else {
os_strncpy (extra, "\r\n", sizeof(extra));
}
if(msData->delta && msData->preallocated){
printf (MM_MS_TIME_BUF_FMT
MM_MS_D_AVAILABLE_FMT
MM_MS_D_COUNT_FMT
MM_MS_D_USED_FMT
MM_MS_D_PREALLOCATED_FMT
MM_MS_D_MAXUSED_FMT
MM_MS_D_REUSABLE_FMT
MM_MS_D_FAILS_FMT
MM_MS_NEWLINE
,
timbuf,
s.size - msData->prevState.size,
s.count - msData->prevState.count,
s.used - msData->prevState.used,
s.preallocated - msData->prevState.preallocated,
s.maxUsed - msData->prevState.maxUsed,
s.garbage - msData->prevState.garbage,
s.fails - msData->prevState.fails);
msData->prevState = s;
} else if (msData->delta) {
printf (MM_MS_TIME_BUF_FMT
MM_MS_D_AVAILABLE_FMT
MM_MS_D_COUNT_FMT
MM_MS_D_USED_FMT
MM_MS_D_MAXUSED_FMT
MM_MS_D_REUSABLE_FMT
MM_MS_D_FAILS_FMT
MM_MS_NEWLINE
,
timbuf,
s.size - msData->prevState.size,
s.count - msData->prevState.count,
s.used - msData->prevState.used,
s.maxUsed - msData->prevState.maxUsed,
s.garbage - msData->prevState.garbage,
s.fails - msData->prevState.fails);
msData->prevState = s;
} else {
char _size[32], _used[32], _maxUsed[32], _reusable[32];
to_string(ls.size + ls.garbage + ms.garbage, _size);
to_string(ls.used + ms.used, _used);
to_string(ls.maxUsed + ms.maxUsed, _maxUsed);
to_string(ls.garbage + ms.garbage, _reusable);
if(msData->preallocated){
char _preallocated[32];
to_string(s.preallocated, _preallocated);
printf(MM_MS_TIME_BUF_FMT
MM_MS_AVAILABLE_FMT
MM_MS_COUNT_FMT
MM_MS_USED_FMT
MM_MS_PREALLOCATED_FMT
MM_MS_MAXUSED_FMT
MM_MS_REUSABLE_FMT
MM_MS_FAILS_FMT
MM_MS_EXTRA_FMT
,
timbuf,
_size,
ls.count + ms.count,
_used,
_preallocated,
_maxUsed,
_reusable,
ls.fails + ms.fails,
extra);
} else {
printf(MM_MS_TIME_BUF_FMT
MM_MS_AVAILABLE_FMT
MM_MS_COUNT_FMT
MM_MS_USED_FMT
MM_MS_MAXUSED_FMT
MM_MS_REUSABLE_FMT
MM_MS_FAILS_FMT
MM_MS_EXTRA_FMT
,
timbuf,
_size,
ls.count + ms.count,
_used,
_maxUsed,
_reusable,
ls.fails + ms.fails,
extra);
}
}
msData->header--;
}
static void
os_defaultReport(
os_reportEventV1 event)
{
os_time ostime;
char node[64];
char date_time[128];
FILE *log;
time_t tt;
switch (event->reportType) {
case OS_DEBUG:
case OS_INFO:
case OS_WARNING:
/* Check info_file is NULL here to keep user loggging */
/* plugin simple in integrity */
if ( info_log == NULL )
{
info_log = os_open_info_file();
}
log = info_log;
break;
case OS_API_INFO:
case OS_ERROR:
case OS_CRITICAL:
case OS_FATAL:
case OS_REPAIRED:
default:
/* Check error_file is NULL here to keep user loggging */
/* plugin simple in integrity */
if ( error_log == NULL )
{
error_log = os_open_error_file();
}
log = error_log;
break;
}
ostime = os_timeGet();
tt = ostime.tv_sec;
if (strftime(date_time, sizeof(date_time), "%a %b %d %H:%M:%S %Z %Y", localtime(&tt)) == 0) {
date_time[0] = '\0';
}
os_gethostname(node, sizeof(node)-1);
node[sizeof(node)-1] = '\0';
os_mutexLock(&reportMutex);
#ifdef INTEGRITY
os_logprintf( log,
#else
fprintf(log,
#endif
"========================================================================================\n"
"Report : %s\n"
"Date : %s\n"
"Description : %s\n"
"Node : %s\n"
"Process : %s\n"
"Thread : %s\n"
"Internals : %s/%s/%s/%s/%s/%d/%d/%d.%09d\n",
os_reportTypeText[event->reportType],
date_time,
event->description,
node,
event->processDesc,
event->threadDesc,
OSPL_VERSION_STR,
OSPL_INNER_REV_STR,
OSPL_OUTER_REV_STR,
event->reportContext,
event->fileName,
event->lineNo,
event->code,
ostime.tv_sec,
ostime.tv_nsec);
#ifndef INTEGRITY
fflush (log);
#endif
os_mutexUnlock(&reportMutex);
}
void
d_printState(
d_durability durability,
d_configuration config,
const char* threadName)
{
os_time time;
d_serviceState kind;
const c_char* state;
if(config->tracingOutputFile){
kind = d_durabilityGetState(durability);
switch(kind){
case D_STATE_INIT:
state = "INIT";
break;
case D_STATE_DISCOVER_FELLOWS_GROUPS:
state = "DISCOVER_FELLOWS_GROUPS";
break;
case D_STATE_DISCOVER_PERSISTENT_SOURCE:
state = "DISCOVER_PERSISTENT_SOURCE";
break;
case D_STATE_INJECT_PERSISTENT:
state = "INJECT_PERSISTENT";
break;
case D_STATE_DISCOVER_LOCAL_GROUPS:
state = "DISCOVER_LOCAL_GROUPS";
break;
case D_STATE_FETCH_INITIAL:
state = "FETCH_INITIAL";
break;
case D_STATE_FETCH:
state = "FETCH";
break;
case D_STATE_ALIGN:
state = "ALIGN";
break;
case D_STATE_FETCH_ALIGN:
state = "FETCH_ALIGN";
break;
case D_STATE_COMPLETE:
state = "COMPLETE";
break;
case D_STATE_TERMINATING:
state = "TERMINATING";
break;
case D_STATE_TERMINATED:
state = "TERMINATED";
break;
default:
state = "<<UNKNOWN>>";
break;
}
if(config->tracingTimestamps == TRUE){
time = os_timeGet();
if(config->tracingRelativeTimestamps == TRUE){
time = os_timeSub(time, config->startTime);
}
fprintf(config->tracingOutputFile, "%d.%9.9d %s (%s) -> ",
time.tv_sec, time.tv_nsec, state, threadName);
} else {
fprintf(config->tracingOutputFile, "%s (%s) -> ", state, threadName);
}
}
}
v_kernel
v_kernelNew(
c_base base,
const c_char *name,
v_kernelQos qos)
{
v_kernel kernel;
v_kernelStatistics kernelStatistics;
v_spliced sd;
kernel = c_lookup(base,name);
if (kernel != NULL) {
assert(C_TYPECHECK(kernel,v_kernel));
kernel->userCount++;
return kernel;
}
loadkernelModule(base);
kernel = (v_kernel)c_new(c_resolve(base,"kernelModule::v_kernel"));
if (!kernel) {
OS_REPORT(OS_ERROR,
"v_kernelNew",0,
"Failed to allocate kernel.");
return NULL;
}
v_objectKind(kernel) = K_KERNEL;
v_object(kernel)->kernel = (c_voidp)kernel;
kernel->handleServer = v_handleServerNew(base);
#define INITTYPE(k,t,l) k->type[l] = c_resolve(base,#t)
INITTYPE(kernel,kernelModule::v_kernel, K_KERNEL);
INITTYPE(kernel,kernelModule::v_participant, K_PARTICIPANT);
INITTYPE(kernel,kernelModule::v_waitset, K_WAITSET);
INITTYPE(kernel,kernelModule::v_condition, K_CONDITION);
INITTYPE(kernel,kernelModule::v_query, K_QUERY);
INITTYPE(kernel,kernelModule::v_dataReaderQuery, K_DATAREADERQUERY);
INITTYPE(kernel,kernelModule::v_dataViewQuery, K_DATAVIEWQUERY);
INITTYPE(kernel,kernelModule::v_dataView, K_DATAVIEW);
INITTYPE(kernel,kernelModule::v_dataViewSample, K_DATAVIEWSAMPLE);
INITTYPE(kernel,kernelModule::v_dataViewInstance, K_DATAVIEWINSTANCE);
INITTYPE(kernel,kernelModule::v_projection, K_PROJECTION);
INITTYPE(kernel,kernelModule::v_mapping, K_MAPPING);
INITTYPE(kernel,kernelModule::v_topic, K_TOPIC);
INITTYPE(kernel,kernelModule::v_message, K_MESSAGE);
INITTYPE(kernel,kernelModule::v_transaction, K_TRANSACTION);
INITTYPE(kernel,kernelModule::v_dataReaderInstance, K_DATAREADERINSTANCE);
INITTYPE(kernel,kernelModule::v_purgeListItem, K_PURGELISTITEM);
INITTYPE(kernel,kernelModule::v_groupPurgeItem, K_GROUPPURGEITEM);
INITTYPE(kernel,kernelModule::v_dataReaderSample, K_READERSAMPLE);
INITTYPE(kernel,kernelModule::v_publisher, K_PUBLISHER);
INITTYPE(kernel,kernelModule::v_subscriber, K_SUBSCRIBER);
INITTYPE(kernel,kernelModule::v_partition, K_DOMAIN);
INITTYPE(kernel,kernelModule::v_partitionInterest, K_DOMAININTEREST);
INITTYPE(kernel,kernelModule::v_partitionAdmin, K_DOMAINADMIN);
INITTYPE(kernel,kernelModule::v_reader, K_READER);
INITTYPE(kernel,kernelModule::v_writer, K_WRITER);
INITTYPE(kernel,kernelModule::v_writerGroup, K_WRITERGROUP);
INITTYPE(kernel,kernelModule::v_group, K_GROUP);
INITTYPE(kernel,kernelModule::v_groupInstance, K_GROUPINSTANCE);
INITTYPE(kernel,kernelModule::v_groupSample, K_GROUPSAMPLE);
INITTYPE(kernel,kernelModule::v_groupCacheItem, K_GROUPCACHEITEM);
INITTYPE(kernel,kernelModule::v_cache, K_CACHE);
INITTYPE(kernel,kernelModule::v_entry, K_ENTRY);
INITTYPE(kernel,kernelModule::v_dataReaderEntry, K_DATAREADERENTRY);
INITTYPE(kernel,kernelModule::v_groupAction, K_GROUPACTION);
INITTYPE(kernel,kernelModule::v_groupStream, K_GROUPSTREAM);
INITTYPE(kernel,kernelModule::v_groupQueue, K_GROUPQUEUE);
INITTYPE(kernel,kernelModule::v_groupQueueSample, K_GROUPQUEUESAMPLE);
INITTYPE(kernel,kernelModule::v_dataReader, K_DATAREADER);
INITTYPE(kernel,kernelModule::v_deliveryService, K_DELIVERYSERVICE);
INITTYPE(kernel,kernelModule::v_deliveryServiceEntry, K_DELIVERYSERVICEENTRY);
INITTYPE(kernel,kernelModule::v_index, K_INDEX);
INITTYPE(kernel,kernelModule::v_filter, K_FILTER);
INITTYPE(kernel,kernelModule::v_readerStatus, K_READERSTATUS);
INITTYPE(kernel,kernelModule::v_writerStatus, K_WRITERSTATUS);
INITTYPE(kernel,kernelModule::v_partitionStatus, K_DOMAINSTATUS);
INITTYPE(kernel,kernelModule::v_topicStatus, K_TOPICSTATUS);
INITTYPE(kernel,kernelModule::v_subscriberStatus, K_SUBSCRIBERSTATUS);
INITTYPE(kernel,kernelModule::v_status, K_PUBLISHERSTATUS);
INITTYPE(kernel,kernelModule::v_status, K_PARTICIPANTSTATUS);
INITTYPE(kernel,kernelModule::v_kernelStatus, K_KERNELSTATUS);
INITTYPE(kernel,kernelModule::v_readerStatistics, K_READERSTATISTICS);
INITTYPE(kernel,kernelModule::v_writerStatistics, K_WRITERSTATISTICS);
INITTYPE(kernel,kernelModule::v_queryStatistics, K_QUERYSTATISTICS);
INITTYPE(kernel,kernelModule::v_lease, K_LEASE);
INITTYPE(kernel,kernelModule::v_leaseAction, K_LEASEACTION);
INITTYPE(kernel,kernelModule::v_serviceManager, K_SERVICEMANAGER);
INITTYPE(kernel,kernelModule::v_service, K_SERVICE);
INITTYPE(kernel,kernelModule::v_serviceState, K_SERVICESTATE);
INITTYPE(kernel,kernelModule::v_networking, K_NETWORKING);
INITTYPE(kernel,kernelModule::v_durability, K_DURABILITY);
INITTYPE(kernel,kernelModule::v_cmsoap, K_CMSOAP);
INITTYPE(kernel,kernelModule::v_leaseManager, K_LEASEMANAGER);
INITTYPE(kernel,kernelModule::v_groupSet, K_GROUPSET);
INITTYPE(kernel,kernelModule::v_proxy, K_PROXY);
INITTYPE(kernel,kernelModule::v_waitsetEvent, K_WAITSETEVENT);
INITTYPE(kernel,kernelModule::v_waitsetEventHistoryDelete, K_WAITSETEVENTHISTORYDELETE);
INITTYPE(kernel,kernelModule::v_waitsetEventHistoryRequest, K_WAITSETEVENTHISTORYREQUEST);
INITTYPE(kernel,kernelModule::v_waitsetEventPersistentSnapshot, K_WAITSETEVENTPERSISTENTSNAPSHOT);
INITTYPE(kernel,kernelModule::v_writerSample, K_WRITERSAMPLE);
INITTYPE(kernel,kernelModule::v_writerInstance, K_WRITERINSTANCE);
INITTYPE(kernel,kernelModule::v_writerInstanceTemplate, K_WRITERINSTANCETEMPLATE);
INITTYPE(kernel,kernelModule::v_writerCacheItem, K_WRITERCACHEITEM);
/* Networking types */
INITTYPE(kernel,kernelModule::v_networkReader, K_NETWORKREADER);
INITTYPE(kernel,kernelModule::v_networkReaderEntry, K_NETWORKREADERENTRY);
INITTYPE(kernel,kernelModule::v_networkMessage, K_NETWORKMESSAGE);
INITTYPE(kernel,kernelModule::v_networkMapEntry, K_NETWORKMAPENTRY);
INITTYPE(kernel,kernelModule::v_spliced, K_SPLICED);
INITTYPE(kernel,kernelModule::v_configuration, K_CONFIGURATION);
INITTYPE(kernel,kernelModule::v_registration, K_REGISTRATION);
INITTYPE(kernel,kernelModule::v_historicalDataRequest,K_HISTORICALDATAREQUEST);
INITTYPE(kernel,kernelModule::v_persistentSnapshotRequest,K_PERSISTENTSNAPSHOTREQUEST);
INITTYPE(kernel,kernelModule::v_pendingDisposeElement,K_PENDINGDISPOSEELEMENT);
#undef INITTYPE
kernel->pendingDisposeList =
c_listNew(v_kernelType(kernel, K_PENDINGDISPOSEELEMENT ));
c_mutexInit(&kernel->pendingDisposeListMutex, SHARED_MUTEX);
kernelStatistics = v_kernelStatisticsNew(kernel);
v_observableInit(v_observable(kernel),
V_KERNEL_VERSION,
v_statistics(kernelStatistics),
TRUE);
c_lockInit(&kernel->lock,SHARED_LOCK);
kernel->qos = v_kernelQosNew(kernel, qos);
{
os_time time;
/* Fill GID with 'random' value */
memset(&kernel->GID, 0, sizeof(kernel->GID));
time = os_timeGet();
kernel->GID.systemId = time.tv_nsec;
}
kernel->participants = c_setNew(v_kernelType(kernel,K_PARTICIPANT));
kernel->partitions = c_tableNew(v_kernelType(kernel,K_DOMAIN),"name");
kernel->topics = c_tableNew(v_kernelType(kernel,K_TOPIC),"name");
kernel->groupSet = v_groupSetNew(kernel);
kernel->serviceManager = v_serviceManagerNew(kernel);
kernel->livelinessLM = v_leaseManagerNew(kernel);
kernel->configuration = NULL;
kernel->userCount = 1;
kernel->transactionCount = 0;
kernel->splicedRunning = TRUE;
kernel->maxSamplesWarnLevel = V_KERNEL_MAX_SAMPLES_WARN_LEVEL_DEF;
kernel->maxSamplesWarnShown = FALSE;
kernel->maxSamplesPerInstanceWarnLevel = V_KERNEL_MAX_SAMPLES_PER_INSTANCES_WARN_LEVEL_DEF;
kernel->maxSamplesPerInstanceWarnShown = FALSE;
kernel->maxInstancesWarnLevel = V_KERNEL_MAX_INSTANCES_WARN_LEVEL_DEF;
kernel->maxInstancesWarnShown = FALSE;
kernel->enabledStatisticsCategories =
c_listNew(c_resolve(base, "kernelModule::v_statisticsCategory"));
c_mutexInit(&kernel->sharesMutex, SHARED_MUTEX);
kernel->shares = c_tableNew(v_kernelType(kernel,K_SUBSCRIBER),
"qos.share.name");
kernel->crc = v_crcNew(kernel, V_CRC_KEY);
kernel->builtin = v_builtinNew(kernel);
kernel->deliveryService = NULL;
sd = v_splicedNew(kernel);
c_free(sd);
c_bind(kernel,name);
return kernel;
}
