c_bool
u_userGetSPBFromEnvUri() {
char *uri = NULL;
c_bool spb = FALSE;
cf_element platformConfig = NULL;
cf_element dc = NULL;
cf_element elemName = NULL;
cf_element singleProcess = NULL;
cf_data elementData = NULL;
cf_data dataName;
c_value value;
cfgprs_status r;
uri = os_getenv ("OSPL_URI");
r = cfg_parse_ospl (uri, &platformConfig);
if (r == CFGPRS_OK)
{
dc = cf_element (cf_elementChild (platformConfig, CFG_DOMAIN));
if (dc) {
singleProcess = cf_element(cf_elementChild(dc, CFG_SINGLEPROCESS));
if (singleProcess != NULL) {
elementData = cf_data(cf_elementChild(singleProcess, "#text"));
if (elementData != NULL) {
value = cf_dataValue(elementData);
if (os_strncasecmp(value.is.String, "TRUE", 4) == 0) {
/* A SingleProcess value of True implies that Heap is to be used */
spb = TRUE;
}
}
}
}
}
return spb;
}
int
u_userGetDomainIdFromEnvUri() {
char *uri = NULL;
int domainId = 0;
cf_element platformConfig = NULL;
cf_element dc = NULL;
cf_element elemName = NULL;
cf_data dataName;
c_value value;
cfgprs_status r;
uri = os_getenv ("OSPL_URI");
r = cfg_parse_ospl (uri, &platformConfig);
if (r == CFGPRS_OK)
{
dc = cf_element (cf_elementChild (platformConfig, CFG_DOMAIN));
if (dc) {
elemName = cf_element(cf_elementChild(dc, CFG_ID));
if (elemName) {
dataName = cf_data(cf_elementChild(elemName, "#text"));
if (dataName != NULL) {
value = cf_dataValue(dataName);
sscanf(value.is.String, "%d", &domainId);
}
}
}
}
return domainId;
}
static char *
findDomain(
cf_element platformConfig,
cf_element *domain)
{
char *domainName = NULL;
cf_element dc = NULL;
cf_element elemName = NULL;
cf_data dataName;
c_value value;
dc = cf_element (cf_elementChild (platformConfig, CFG_DOMAIN));
if (dc) {
elemName = cf_element(cf_elementChild(dc, CFG_NAME));
if (elemName) {
dataName = cf_data(cf_elementChild(elemName, "#text"));
if (dataName) {
value = cf_dataValue(dataName);
domainName = value.is.String;
*domain = dc;
}
}
}
return domainName;
}
static void
findServiceTerminatePeriod(
cf_element domain,
os_time *serviceTerminatePeriod)
{
cf_element elem;
cf_attribute attr;
cf_data data;
c_value value;
float offset, update_factor, expiry_time;
/* Spliced uses 4 seconds by default or a value defined in the configuration file. */
/* But the timing in ospl starts earlier. Therefore, increase the period in ospl */
/* with an additional 4 seconds such that it is larger than that in spliced. */
offset = 4.0;
(*serviceTerminatePeriod).tv_sec = offset + 4;
(*serviceTerminatePeriod).tv_nsec = 0;
if (domain != NULL) {
elem = cf_element(cf_elementChild(domain, CFG_LEASE));
if (elem) {
elem = cf_element(cf_elementChild(elem, CFG_EXPIRYTIME));
if (elem) {
data = cf_data(cf_elementChild(elem, "#text"));
if (data) {
value = cf_dataValue(data);
expiry_time = atof(value.is.String);
}
attr = cf_attribute(cf_elementAttribute(elem,"update_factor"));
if (attr) {
value = cf_attributeValue(attr);
update_factor = atof(value.is.String);
offset += (expiry_time * update_factor);
}
}
}
elem = cf_element(cf_elementChild(domain, CFG_TERMPERIOD));
if (elem) {
data = cf_data(cf_elementChild(elem, "#text"));
if (data) {
value = cf_dataValue(data);
/* dds2164: if '0' is defined, override any wait times, including
* the 4 second offset defined above.
*/
if(0 == atof(value.is.String))
{
(*serviceTerminatePeriod).tv_sec = 0;
(*serviceTerminatePeriod).tv_nsec = 0;
} else
{
*serviceTerminatePeriod = os_realToTime(offset + atof(value.is.String));
}
}
}
}
}
/**************************************************************
* constructor/destructor
**************************************************************/
cf_element
cf_elementNew (
const c_char *tagName)
{
cf_element el;
assert(tagName != NULL);
el = cf_element(os_malloc((os_uint32)C_SIZEOF(cf_element)));
cf_elementInit(el, tagName);
return el;
}
char *
u_userGetDomainNameFromEnvUri() {
char *uri = NULL;
char * domainName = NULL;
cf_element platformConfig = NULL;
cf_element dc = NULL;
cf_element elemName = NULL;
cf_data dataName;
c_value value;
cfgprs_status r;
uri = os_getenv ("OSPL_URI");
if ( uri != NULL )
{
domainName = os_strdup(uri);
}
else
{
r = cfg_parse_ospl (uri, &platformConfig);
if (r == CFGPRS_OK)
{
dc = cf_element (cf_elementChild (platformConfig, CFG_DOMAIN));
if (dc)
{
elemName = cf_element(cf_elementChild(dc, CFG_NAME));
if (elemName)
{
dataName = cf_data(cf_elementChild(elemName, "#text"));
if (dataName != NULL)
{
value = cf_dataValue(dataName);
domainName = os_strdup(value.is.String);
}
}
}
}
}
return domainName;
}
void
cf_nodeFree (
cf_node node)
{
assert(node != NULL);
if (node != NULL) {
switch (node->kind) {
case CF_ELEMENT: cf_elementDeinit(cf_element(node)); break;
case CF_DATA: cf_dataDeinit(cf_data(node)); break;
case CF_ATTRIBUTE: cf_attributeDeinit(cf_attribute(node)); break;
case CF_NODE: /* abstract */
default:
assert (FALSE); /* catch undefined behaviour */
break;
}
os_free(node);
}
}
static c_iter
getCPUAffinities(cf_element root)
{
c_iter affinities = NULL;
cf_element domain;
cf_element cpuAffinity;
cf_data data;
assert(root);
if (root
&& (domain = (cf_element)cf_elementChild(root, "Domain")) )
{
cpuAffinity = cf_element(cf_elementChild(domain, CFG_CPUAFFINITY));
if (cpuAffinity != NULL)
{
data = cf_data(cf_elementChild(cpuAffinity, "#text"));
if (data != NULL)
{
char *saveptr;
char *next;
char *value;
value = cf_dataValue(data).is.String;
next = os_strtok_r(value, ",", &saveptr);
while ( next != NULL )
{
signed int corenum;
struct cpuAffinity *newCpuAffinity;
sscanf( next, "%d", &corenum);
newCpuAffinity = (struct cpuAffinity *)malloc (sizeof(struct cpuAffinity));
newCpuAffinity->cpuNumber = corenum;
affinities = c_iterInsert(affinities, newCpuAffinity);
next = os_strtok_r(NULL, ",", &saveptr);
}
}
}
}
return affinities;
}
{
cf_element dc = NULL;
cf_element child;
cf_element name;
cf_data elementData;
cf_element size;
cf_element threshold;
cf_element address;
cf_element heap;
cf_element locked;
c_value value;
cf_attribute attr;
assert(config != NULL);
assert(domainConfig != NULL);
dc = cf_element(cf_elementChild(config, CFG_DOMAIN));
if (dc != NULL) {
name = cf_element(cf_elementChild(dc, CFG_NAME));
if (name != NULL) {
elementData = cf_data(cf_elementChild(name, "#text"));
if (elementData != NULL) {
value = cf_dataValue(elementData);
os_free(domainConfig->name);
domainConfig->name = os_malloc(strlen(value.is.String) + 1);
os_strcpy(domainConfig->name, value.is.String);
child = cf_element(cf_elementChild(dc, CFG_DATABASE));
if (child != NULL) {
size = cf_element(cf_elementChild(child, CFG_SIZE));
if (size != NULL) {
elementData = cf_data(cf_elementChild(size, "#text"));
if (elementData != NULL) {
void
u_usrClockInit (
const cf_element config)
{
cf_element cfgUsrClockService = NULL;
cf_element cfgUsrClockModule = NULL;
cf_element cfgUsrClockStart = NULL;
cf_element cfgUsrClockStop = NULL;
cf_element cfgUsrClockQuery = NULL;
cf_element dc = NULL;
cf_element cfgDomainY2038 = NULL;
const char *module = NULL;
const char *moduleName = NULL;
const char *clockStart = NULL;
const char *clockStop = NULL;
const char *clockQuery = U_USRCLOCK_QUERYNAME_DEFAULT;
const char *domainY2038 = NULL;
os_boolean y2038Ready = OS_FALSE;
os_boolean domainY2038Ready = OS_FALSE;
os_boolean ignoreUserClockforReportStack=OS_FALSE;
assert(config != NULL);
dc = cf_element(cf_elementChild(config, CFG_DOMAIN));
if (dc != NULL) {
cfgUsrClockService = cf_element(cf_elementChild(dc, U_CONF_USRCLOCK_SERVICENAME));
if (cfgUsrClockService == NULL) {
cfgUsrClockService = cf_element(cf_elementChild(dc, U_CONF_USRCLOCK_SERVICENAME_OLD));
if (cfgUsrClockService != NULL) {
OS_REPORT(OS_WARNING, "u_usrClockInit", 0,
"Found deprecated tag 'UserClockService' in configuration. Please use 'UserClock'");
}
}
if (cfgUsrClockService != NULL) {
ignoreUserClockforReportStack = u_usrClockConfigElementAttributeStringToBoolean(cfgUsrClockService, "reporting", OS_TRUE);
if ( ignoreUserClockforReportStack == OS_FALSE) {
os_reportIgnoreUserClock();
}
cfgUsrClockModule = cf_element(cf_elementChild(cfgUsrClockService, U_CONF_USRCLOCK_SERVICEMODULENAME));
cfgUsrClockStart = cf_element(cf_elementChild(cfgUsrClockService, U_CONF_USRCLOCK_SERVICESTARTNAME));
cfgUsrClockStop = cf_element(cf_elementChild(cfgUsrClockService, U_CONF_USRCLOCK_SERVICESTOPNAME));
cfgUsrClockQuery = cf_element(cf_elementChild(cfgUsrClockService, U_CONF_USRCLOCK_SERVICEQUERYNAME));
cfgDomainY2038 = cf_element(cf_elementChild(dc, U_CONF_DOMAIN_Y2038READY));
if (cfgDomainY2038 != NULL) {
domainY2038 = u_usrClockConfigElementDataString(cfgDomainY2038, NULL);
if ((domainY2038 != NULL) && (strcmp(domainY2038, "true") == 0)) {
domainY2038Ready = OS_TRUE;
}
}
y2038Ready = u_usrClockConfigElementAttributeStringToBoolean(cfgUsrClockService, U_CONF_USRCLOCK_Y2038READY, domainY2038Ready);
if ((domainY2038Ready == OS_TRUE) &&
(y2038Ready != domainY2038Ready)) {
OS_REPORT(OS_WARNING, "u_usrClockInit", 0,
"The configuration element //OpenSplice/Domain/y2038Ready is 'true' while the attribute "
"//OpenSplice/Domain/UserClock/y2038Ready overrules this configuration for the userClock. "
"This will cause undefined behavior when using this configuration after y2038.");
}
if (cfgUsrClockModule) {
module = u_usrClockConfigElementDataString(cfgUsrClockModule, NULL);
if (module) {
if (strncmp (module, "file://", 7) == 0) {
moduleName = &module[7];
} else {
moduleName = module;
}
}
}
if (cfgUsrClockStart) {
if (u_usrClockConfigElementAttributeStringToBoolean(cfgUsrClockStart, "enabled", OS_TRUE) == OS_TRUE) {
clockStart = u_usrClockConfigElementDataString(cfgUsrClockStart, U_USRCLOCK_STARTNAME_DEFAULT);
}
}
if (cfgUsrClockStop) {
if (u_usrClockConfigElementAttributeStringToBoolean(cfgUsrClockStop, "enabled", OS_TRUE) == OS_TRUE) {
clockStop = u_usrClockConfigElementDataString(cfgUsrClockStop, U_USRCLOCK_STOPNAME_DEFAULT);
}
}
if (cfgUsrClockQuery) {
if (u_usrClockConfigElementAttributeStringToBoolean(cfgUsrClockQuery, "enabled", OS_TRUE) == OS_TRUE) {
clockQuery = u_usrClockConfigElementDataString(cfgUsrClockQuery, U_USRCLOCK_QUERYNAME_DEFAULT);
}
}
os_userClockStart (moduleName, clockStart, clockStop, clockQuery, y2038Ready);
}
}
}
