const enum esif_tracemodule EsifTraceModule_FromString(const char *name)
{
int j;
for (j=0; g_EsifTraceModuleList[j].str; j++) {
if (esif_ccb_stricmp(name, g_EsifTraceModuleList[j].str)==0 || // ESIF_TRACEMODULE_XXXX
esif_ccb_stricmp(name, g_EsifTraceModuleList[j].str+17)==0) // XXXX
return g_EsifTraceModuleList[j].id;
}
return (enum esif_tracemodule)0;
}
void DataBank_CloseNameSpace (
DataBankPtr self,
esif_string nameSpace
)
{
UInt32 ns;
esif_ccb_write_lock(&self->lock);
// Find Existing NameSpace
for (ns = 0; ns < self->size; ns++) {
if (esif_ccb_stricmp(nameSpace, self->elements[ns].name) == 0) {
DataVault_dtor(&self->elements[ns]);
// Move Array Items down one and wipe the final item
for ( ; ns + 1 < self->size; ns++)
esif_ccb_memcpy(&self->elements[ns], &self->elements[ns + 1], sizeof(self->elements[ns]));
if (ns < ESIF_MAX_NAME_SPACES) {
WIPEPTR(&self->elements[ns]);
}
self->size--;
}
}
esif_ccb_write_unlock(&self->lock);
}
DataVaultPtr DataBank_OpenNameSpace (
DataBankPtr self,
esif_string nameSpace
)
{
DataVaultPtr DB = NULL;
UInt32 ns;
// Exit if NameSpace already exists
// TODO: Change this to a linked list or array of pointers so each DataVaultPtr is static
esif_ccb_read_lock(&self->lock);
for (ns = 0; ns < self->size; ns++) {
if (esif_ccb_stricmp(nameSpace, self->elements[ns].name) == 0) {
DB = &self->elements[ns];
break;
}
}
esif_ccb_read_unlock(&self->lock);
if (DB != NULL || ns >= ESIF_MAX_NAME_SPACES) {
return DB;
}
// Not Found. Create NameSpace
esif_ccb_write_lock(&self->lock);
DB = &self->elements[self->size++];
DataVault_ctor(DB);
esif_ccb_strcpy(DB->name, nameSpace, ESIF_NAME_LEN);
esif_ccb_strlwr(DB->name, sizeof(DB->name));
esif_ccb_write_unlock(&self->lock);
return DB;
}
EsifLogType EsifLogType_FromString(const char *name)
{
EsifLogType result = (EsifLogType)0;
if (NULL == name)
return result;
else if (esif_ccb_strnicmp(name, "eventlog", 5)==0)
result = ESIF_LOG_EVENTLOG;
else if (esif_ccb_strnicmp(name, "debugger", 5)==0)
result = ESIF_LOG_DEBUGGER;
else if (esif_ccb_stricmp(name, "shell")==0)
result = ESIF_LOG_SHELL;
else if (esif_ccb_stricmp(name, "trace")==0)
result = ESIF_LOG_TRACE;
else if (esif_ccb_stricmp(name, "ui")==0)
result = ESIF_LOG_UI;
return result;
}
int IString_Stricmp (
IStringPtr self,
ZString str2
)
{
ESIF_ASSERT(self);
if (self->buf_ptr && str2) {
return esif_ccb_stricmp((ZString)self->buf_ptr, str2);
}
return 0;
}
// Update flags bitmask used by EsifConfigSet
esif_flags_t EsifConfigFlags_Set(esif_flags_t bitmask, esif_string optname)
{
// List of option names and codes. TODO: Keep this list sorted alphabetically and do a binary search
static struct OptionList_s {
StringPtr name;
UInt32 option;
}
optionList[] = {
{"PERSIST", ESIF_SERVICE_CONFIG_PERSIST },
{"SCRAMBLE", ESIF_SERVICE_CONFIG_SCRAMBLE },
{"READONLY", ESIF_SERVICE_CONFIG_READONLY},
{"NOCACHE", ESIF_SERVICE_CONFIG_NOCACHE },
{"FILELINK", ESIF_SERVICE_CONFIG_FILELINK},
{"DELETE", ESIF_SERVICE_CONFIG_DELETE },
{"STATIC", ESIF_SERVICE_CONFIG_STATIC }, // DataVault-Level Option
{"~NOPERSIST", ESIF_SERVICE_CONFIG_PERSIST }, // Unset option
{ 0, 0}
};
int j;
for (j = 0; optionList[j].name; j++) {
// NAME = Set option
if (esif_ccb_stricmp(optname, optionList[j].name) == 0) {
bitmask |= optionList[j].option;
break;
}
// ~NAME = Unset option
if (optionList[j].name[0] == '~' && esif_ccb_stricmp(optname, optionList[j].name+1) == 0) {
bitmask &= ~optionList[j].option;
break;
}
}
if (!optionList[j].name) {
//CMD_OUT("Error: Invalid Option: %s\n", optname);
}
return bitmask;
}
// Compare two IStrings
int IString_Compare (
IStringPtr self,
IStringPtr str2,
int IgnoreCase
)
{
if (self && str2 && self->buf_ptr && str2->buf_ptr) {
if (IgnoreCase) {
return esif_ccb_stricmp((ZString)self->buf_ptr, (ZString)str2->buf_ptr);
} else {
return esif_ccb_strcmp((ZString)self->buf_ptr, (ZString)str2->buf_ptr);
}
}
return 0;
}
static EsifAppPtr GetAppFromName(
EsifAppMgr *THIS,
EsifString lib_name
)
{
u8 i = 0;
EsifAppPtr a_app_ptr = NULL;
for (i = 0; i < ESIF_MAX_APPS; i++) {
a_app_ptr = &THIS->fEntries[i];
if (NULL == a_app_ptr->fLibNamePtr) {
continue;
}
if (!esif_ccb_stricmp(a_app_ptr->fLibNamePtr, lib_name)) {
return a_app_ptr;
}
}
return NULL;
}
// Return NameSpace in the Configuration Manager or NULL if it doesn't exist
DataVaultPtr DataBank_GetNameSpace (
DataBankPtr self,
StringPtr nameSpace
)
{
DataVaultPtr result = NULL;
UInt32 ns;
if (NULL == nameSpace) {
nameSpace = g_DataVaultDefault;
}
if (NULL != nameSpace) {
esif_ccb_read_lock(&self->lock);
for (ns = 0; ns < self->size; ns++) {
if (esif_ccb_stricmp(nameSpace, self->elements[ns].name) == 0) {
result = &self->elements[ns];
break;
}
}
esif_ccb_read_unlock(&self->lock);
}
return result;
}
// Initialize Pathname List
enum esif_rc esif_pathlist_init(esif_string paths)
{
static esif_pathmap pathmap[] = {
{ "HOME", ESIF_PATHTYPE_HOME },
{ "TEMP", ESIF_PATHTYPE_TEMP },
{ "DV", ESIF_PATHTYPE_DV },
{ "LOG", ESIF_PATHTYPE_LOG },
{ "BIN", ESIF_PATHTYPE_BIN },
{ "LOCK", ESIF_PATHTYPE_LOCK },
{ "EXE", ESIF_PATHTYPE_EXE },
{ "DLL", ESIF_PATHTYPE_DLL },
{ "DPTF", ESIF_PATHTYPE_DPTF },
{ "DSP", ESIF_PATHTYPE_DSP },
{ "CMD", ESIF_PATHTYPE_CMD },
{ "UI", ESIF_PATHTYPE_UI },
{ NULL }
};
static int num_paths = (sizeof(pathmap)/sizeof(*pathmap)) - 1;
esif_string *pathlist = NULL;
enum esif_rc rc = ESIF_OK;
if (!g_pathlist.initialized) {
char *buffer = NULL;
char *filename = ESIF_PATHLIST_FILENAME;
FILE *fp = NULL;
struct stat st={0};
// Use pathlist file, if it exists
if (esif_ccb_stat(filename, &st) == 0 && esif_ccb_fopen(&fp, filename, "rb") == 0) {
if ((buffer = (char *) esif_ccb_malloc(st.st_size + 1)) != NULL) {
if (esif_ccb_fread(buffer, st.st_size, sizeof(char), st.st_size, fp) != (size_t)st.st_size) {
rc = ESIF_E_IO_ERROR;
}
}
esif_ccb_fclose(fp);
}
// Otherwise, use default pathlist
else if (buffer == NULL && paths != NULL) {
buffer = esif_ccb_strdup(paths);
}
if ((buffer == NULL) || ((pathlist = (esif_string *)esif_ccb_malloc(num_paths * sizeof(esif_string))) == NULL)) {
esif_ccb_free(buffer);
buffer = NULL;
rc = ESIF_E_NO_MEMORY;
}
// Parse key/value pairs into pathlist
if (rc == ESIF_OK && buffer != NULL) {
char *ctxt = 0;
char *keypair = esif_ccb_strtok(buffer, "\r\n", &ctxt);
char *value = 0;
int id=0;
g_pathlist.initialized = 1;
g_pathlist.pathmap = pathmap;
g_pathlist.num_paths = num_paths;
g_pathlist.pathlist = pathlist;
while (keypair != NULL) {
value = esif_ccb_strchr(keypair, '=');
if (value) {
*value++ = 0;
for (id = 0; id < g_pathlist.num_paths && g_pathlist.pathmap[id].name; id++) {
if (esif_ccb_stricmp(keypair, g_pathlist.pathmap[id].name) == 0) {
esif_pathlist_set(g_pathlist.pathmap[id].type, value);
break;
}
}
}
keypair = esif_ccb_strtok(NULL, "\r\n", &ctxt);
}
}
esif_ccb_free(buffer);
}
return rc;
}
static eEsifError esif_dsp_file_scan()
{
eEsifError rc = ESIF_OK;
struct esif_ccb_file *ffdPtr = NULL;
esif_ccb_file_enum_t findHandle = ESIF_INVALID_FILE_ENUM_HANDLE;
char path[MAX_PATH] = {0};
char pattern[MAX_PATH] = {0};
StringPtr namesp = ESIF_DSP_NAMESPACE;
DataVaultPtr DB = DataBank_GetDataVault(namesp);
// 1. Load all EDP's in the DSP Configuration Namespace, if any exist
if (DB) {
EsifDataPtr nameSpace = EsifData_CreateAs(ESIF_DATA_AUTO, namesp, 0, ESIFAUTOLEN);
EsifDataPtr key = EsifData_CreateAs(ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0);
EsifDataPtr value = EsifData_CreateAs(ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0);
EsifConfigFindContext context = NULL;
ESIF_TRACE_DEBUG("SCAN CONFIG For DSP Files NameSpace = %s, Pattern %s", namesp, pattern);
if (nameSpace != NULL && key != NULL && value != NULL &&
(rc = EsifConfigFindFirst(nameSpace, key, value, &context)) == ESIF_OK) {
do {
// Load all keys from the DataVault with an ".edp" extension
if (key->data_len >= 5 && esif_ccb_stricmp(((StringPtr)(key->buf_ptr)) + key->data_len - 5, ".edp") == 0) {
ffdPtr = (struct esif_ccb_file *)esif_ccb_malloc(sizeof(*ffdPtr));
esif_ccb_strcpy(ffdPtr->filename, (StringPtr)key->buf_ptr, sizeof(ffdPtr->filename));
if (esif_dsp_entry_create(ffdPtr) != ESIF_OK) {
esif_ccb_free(ffdPtr);
}
}
EsifData_Set(key, ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0);
EsifData_Set(value, ESIF_DATA_AUTO, NULL, ESIF_DATA_ALLOCATE, 0);
} while ((rc = EsifConfigFindNext(nameSpace, key, value, &context)) == ESIF_OK);
EsifConfigFindClose(&context);
if (rc == ESIF_E_ITERATION_DONE) {
rc = ESIF_OK;
}
}
EsifData_Destroy(nameSpace);
EsifData_Destroy(key);
EsifData_Destroy(value);
}
// 2. Load all EDP's from the DSP folder, if any exist, except ones already loaded from DataBank
esif_build_path(path, MAX_PATH, ESIF_PATHTYPE_DSP, NULL, NULL);
esif_ccb_strcpy(pattern, "*.edp", MAX_PATH);
ESIF_TRACE_DEBUG("SCAN File System For DSP Files Path = %s, Pattern %s", path, pattern);
/* Find the first file in the directory that matches are search */
ffdPtr = (struct esif_ccb_file *)esif_ccb_malloc(sizeof(*ffdPtr));
if (ffdPtr == NULL) {
ESIF_TRACE_ERROR("Fail to allocate esif_ccb file\n");
rc = ESIF_E_NO_MEMORY;
goto exit;
}
findHandle = esif_ccb_file_enum_first(path, pattern, ffdPtr);
if (ESIF_INVALID_FILE_ENUM_HANDLE == findHandle) {
rc = ESIF_E_UNSPECIFIED;
goto exit;
}
/* Process Each File */
do {
// Don't process the file if it the same name was already loaded from a DataVault
if (DB == NULL || DataCache_GetValue(DB->cache, ffdPtr->filename) == NULL) {
if (esif_dsp_entry_create(ffdPtr) != ESIF_OK) {
esif_ccb_free(ffdPtr);
}
ffdPtr = (struct esif_ccb_file *)esif_ccb_malloc(sizeof(*ffdPtr));
}
} while (esif_ccb_file_enum_next(findHandle, pattern, ffdPtr));
esif_ccb_file_enum_close(findHandle);
exit:
if (ffdPtr != NULL) {
esif_ccb_free(ffdPtr);
}
return rc;
}
// Find Next path in nameSpace
eEsifError EsifConfigFindNext(
EsifDataPtr nameSpace,
EsifDataPtr path,
EsifDataPtr value,
EsifConfigFindContextPtr context
)
{
eEsifError rc = ESIF_E_NOT_FOUND;
DataVaultPtr DB = 0;
ESIF_ASSERT(nameSpace && path && context);
DB = DataBank_GetNameSpace(g_DataBankMgr, (StringPtr)(nameSpace->buf_ptr));
if (DB) {
UInt32 item = 0;
esif_ccb_read_lock(&DB->lock);
for (item = 0; item < DB->cache->size; item++) {
if (*context == NULL || esif_ccb_stricmp(DB->cache->elements[item].key.buf_ptr, *context) > 0) {
break;
}
}
// Find next matching key
while (item < DB->cache->size && EsifConfigKeyMatch(path, &DB->cache->elements[item].key) != ESIF_TRUE) {
item++;
}
// Return matching item, if any
if (item < DB->cache->size) {
esif_ccb_free(*context);
*context = esif_ccb_strdup(DB->cache->elements[item].key.buf_ptr);
if (path->buf_len && path->buf_len < DB->cache->elements[item].key.data_len) {
rc = ESIF_E_NEED_LARGER_BUFFER;
}
else {
EsifData_Set(path,
ESIF_DATA_STRING,
esif_ccb_strdup((char*)DB->cache->elements[item].key.buf_ptr),
DB->cache->elements[item].key.data_len,
DB->cache->elements[item].key.data_len);
// If no value buffer for result, just return next matching key
if (NULL == value)
rc = ESIF_OK;
else
rc = EsifConfigGet(nameSpace, path, value);
}
}
else if (*context != NULL) {
rc = ESIF_E_ITERATION_DONE;
}
esif_ccb_read_unlock(&DB->lock);
}
if (rc != ESIF_OK) {
EsifConfigFindClose(context);
}
return rc;
}
//
// PUBLIC INTERFACE---------------------------------------------------------------------
//
char *EsifShellCmdDataLog(EsifShellCmdPtr shell)
{
eEsifError rc = ESIF_OK;
int argc = shell->argc;
char **argv = shell->argv;
char *output = shell->outbuf;
char participantList[MAX_LOG_LINE] = { 0 };
/*
* Serialize access to the datalog state.
*/
while (atomic_set(&g_dataLogLock, ESIF_TRUE)) {
esif_ccb_sleep_msec(ESIF_DATALOG_LOCK_SLEEP_MS);
}
if (argc < 2) {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging is: %s\n", (EsifDataIsLogStarted() ? "started" : "stopped"));
}
else if (esif_ccb_stricmp(argv[1], "start") == 0) {
if (EsifDataIsLogStarted()){
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging is already started.\n");
goto exit;
}
g_dataLogInterval = DEFAULT_STATUS_LOG_INTERVAL;
if (argc > 2) {
if ((int)esif_atoi(argv[2]) >= MIN_STATUS_LOG_INTERVAL) {
g_dataLogInterval = (esif_ccb_time_t)esif_atoi(argv[2]);
}
else {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Invalid sampling period specified (minimum is %d ms).\n", MIN_STATUS_LOG_INTERVAL);
goto exit;
}
}
if (argc > 3) {
esif_ccb_sprintf(sizeof(participantList), participantList, "%s", argv[3]);
}
rc = EsifDataLogValidateParticipantList(participantList);
if (rc != ESIF_OK) {
esif_ccb_sprintf(OUT_BUF_LEN, output, "There was a problem with your participant list. You may have selected invalid participants, or too many participants. \n");
goto exit;
}
rc = EsifDataLogOpenLogFile();
if (rc != ESIF_OK) {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Error opening log file... \n");
goto exit;
}
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging starting... \n");
EsifDataLogStart();
}
else if (esif_ccb_stricmp(argv[1], "schedule") == 0) {
UInt32 startTime = 1000;
/* initialize */
if (dataLogContextPtr == NULL) {
dataLogContextPtr = (struct dataLogContext *)esif_ccb_malloc(sizeof(struct dataLogContext));
if (dataLogContextPtr == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
dataLogContextPtr->dataLogScheduleTimer = (esif_ccb_timer_t *) esif_ccb_malloc(sizeof(esif_ccb_timer_t));
if (dataLogContextPtr->dataLogScheduleTimer == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
dataLogContextPtr->dataLogParticipantList = NULL;
}
dataLogContextPtr->dataLogInterval = DEFAULT_STATUS_LOG_INTERVAL;
/* start time (in ms from now) */
if (argc > 2) {
if ((int) esif_atoi(argv[2]) >= MIN_STATUS_LOG_SCHEDULE) {
startTime = (esif_ccb_time_t) esif_atoi(argv[2]);
}
else {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Invalid schedule time specified (minimum is %d ms).\n", MIN_STATUS_LOG_INTERVAL);
goto exit;
}
}
/* log interval */
if (argc > 3) {
if ((int) esif_atoi(argv[3]) >= MIN_STATUS_LOG_INTERVAL) {
dataLogContextPtr->dataLogInterval = (esif_ccb_time_t) esif_atoi(argv[3]);
}
else {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Invalid sampling period specified (minimum is %d ms).\n", MIN_STATUS_LOG_INTERVAL);
goto exit;
}
}
if (argc > 4) {
dataLogContextPtr->dataLogParticipantList = esif_ccb_strdup(argv[4]);
if (dataLogContextPtr->dataLogParticipantList == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
}
rc = esif_ccb_timer_init(dataLogContextPtr->dataLogScheduleTimer, (esif_ccb_timer_cb) EsifDataLogSchedule, NULL);
if (ESIF_OK != rc) {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Error starting timer... \n");
goto exit;
}
rc = esif_ccb_timer_set_msec(dataLogContextPtr->dataLogScheduleTimer, startTime);
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging scheduled for start in %d ms at an interval of %d... \n", startTime, dataLogContextPtr->dataLogInterval);
}
else if (esif_ccb_stricmp(argv[1], "stop") == 0) {
EsifDataLogStop();
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging stopped...\n");
g_dataLogActive = ESIF_FALSE;
}
else {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Invalid parameter specified\n");
}
exit:
atomic_set(&g_dataLogLock, ESIF_FALSE);
return output;
}