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; }