static void EsifDataLogFire(int isHeader) { int i = 0; char outLine[MAX_LOG_LINE] = { 0 }; EsifLogType logtype = ESIF_LOG_UI; time_t now = time(NULL); struct tm time = { 0 }; esif_ccb_time_t msec = 0; esif_ccb_system_time(&msec); if (isHeader > 0) { esif_ccb_sprintf(MAX_LOG_LINE, outLine, "Time,Server Msec,"); } else { if (esif_ccb_localtime(&time, &now) == 0) { esif_ccb_sprintf(MAX_LOG_LINE, outLine, "%04d-%02d-%02d %02d:%02d:%02d,%llu,", time.tm_year + 1900, time.tm_mon + 1, time.tm_mday, time.tm_hour, time.tm_min, time.tm_sec, msec); } } for (i = 0; i < MAX_PARTICIPANT_ENTRY; i++) { eEsifError rc = ESIF_OK; DataLogParticipant currentParticipant = g_dataLogParticipants[i]; if (currentParticipant.participantNumFields > 0) { rc = EsifDataLogAddParticipant(outLine, i, isHeader); } } EsifLogFile_Write(logtype, "%s\n", outLine); }
/* Allocate Event IPC */ struct esif_ipc *esif_ipc_alloc_event( struct esif_ipc_event **event_ptr_ptr, u32 data_len ) { struct esif_ipc *ipc_ptr = NULL; ESIF_ASSERT(event_ptr_ptr != NULL); ipc_ptr = esif_ipc_alloc(ESIF_IPC_TYPE_EVENT, data_len + sizeof(**event_ptr_ptr)); if (NULL == ipc_ptr) { *event_ptr_ptr = NULL; } else { esif_ccb_time_t timestamp = {0}; struct esif_ipc_event *event_ptr = NULL; event_ptr = (struct esif_ipc_event *)(ipc_ptr + 1); event_ptr->version = ESIF_EVENT_VERSION; event_ptr->priority = ESIF_EVENT_PRIORITY_NORMAL; event_ptr->data_len = data_len; esif_ccb_system_time(×tamp); event_ptr->timestamp = (u64)timestamp; *event_ptr_ptr = event_ptr; } return ipc_ptr; }
static void *ESIF_CALLCONV EsifDataLogWorkerThread(void *ptr) { eEsifError rc = ESIF_OK; UNREFERENCED_PARAMETER(ptr); ESIF_TRACE_ENTRY_INFO(); while (!g_dataLogQuit) { esif_ccb_time_t msecStart = 0; esif_ccb_time_t msecStop = 0; esif_ccb_time_t msecDif = 0; UInt32 sleepMs = 0; esif_ccb_system_time(&msecStart); EsifDataLogFire(0); esif_ccb_system_time(&msecStop); /* Determine how long processing actually took */ msecDif = msecStop - msecStart; /* Determine next sleep time based on previous processing time*/ sleepMs = g_dataLogInterval - ((int) msecDif); if ((sleepMs < MIN_STATUS_LOG_INTERVAL_ADJUSTED) || (msecDif > g_dataLogInterval)){ sleepMs = MIN_STATUS_LOG_INTERVAL_ADJUSTED; } rc = EsifTimedEventWait(&g_dataLogQuitEvent, sleepMs); if (rc != ESIF_OK) { ESIF_TRACE_ERROR("Error waiting on data log event\n"); goto exit; } } exit: ESIF_TRACE_EXIT_INFO(); return 0; }
void EsifEvent_SignalIpcEvent(struct esif_ipc_event *eventHdrPtr) { #ifdef ESIF_FEAT_OPT_ACTION_SYSFS UNREFERENCED_PARAMETER(domainStr); #else eEsifError rc = ESIF_OK; EsifData binaryData = {ESIF_DATA_BINARY, NULL, 0, 0}; EsifData voidData = {ESIF_DATA_VOID, NULL, 0}; EsifDataPtr dataPtr = NULL; UInt8 participantId; char domainStr[8] = ""; esif_ccb_time_t now; UNREFERENCED_PARAMETER(domainStr); esif_ccb_system_time(&now); ESIF_TRACE_DEBUG( "\n" "===================================================\n" "ESIF IPC EVENT HEADER: Timestamp: %llu\n" " Latency: %u msec\n" "===================================================\n" "Version: %d\n" "Type: %s(%d)\n" "ID: %llu\n" "Timestamp: %llu\n" "Priority: %s(%d)\n" "Source: %d\n" "Dest: %d\n" "Dest Domain: %s(%04X)\n" "Data Size: %u\n\n", (u64)now, (int)(now - eventHdrPtr->timestamp), eventHdrPtr->version, esif_event_type_str(eventHdrPtr->type), eventHdrPtr->type, eventHdrPtr->id, eventHdrPtr->timestamp, esif_event_priority_str(eventHdrPtr->priority), eventHdrPtr->priority, eventHdrPtr->src_id, eventHdrPtr->dst_id, esif_primitive_domain_str(eventHdrPtr->dst_domain_id, domainStr, 8), eventHdrPtr->dst_domain_id, eventHdrPtr->data_len); dataPtr = &voidData; if (eventHdrPtr->data_len > 0) { binaryData.buf_ptr = eventHdrPtr + 1; binaryData.buf_len = eventHdrPtr->data_len; binaryData.data_len = eventHdrPtr->data_len; dataPtr = &binaryData; } /* * If the mapping function fails, we assume that the participant hasn't been created * In that case, we use 0 for the participant as the real ID will be gathered from * the creation data. */ participantId = eventHdrPtr->dst_id; if (eventHdrPtr->dst_id == ESIF_INSTANCE_UF) { rc = EsifUpPm_MapLpidToParticipantInstance(eventHdrPtr->src_id, &participantId); if (rc != ESIF_OK) { participantId = 0; } } // Best Effort Delivery EsifEventMgr_SignalEvent(participantId, eventHdrPtr->dst_domain_id, eventHdrPtr->type, dataPtr); return; #endif }
TimeSpan EsifTime::getCurrentTime(void) { esif_ccb_time_t currentTimeInMilliSeconds; esif_ccb_system_time(¤tTimeInMilliSeconds); return TimeSpan::createFromMilliseconds(currentTimeInMilliSeconds); }
/* Documented In Header */ struct esif_event *esif_event_allocate( const enum esif_event_type type, const u16 size, const enum esif_event_priority priority, const u8 src, const u8 dst, const u16 dst_domain_id, const void *data_ptr ) { u16 new_size = size + sizeof(struct esif_event); struct esif_event *event_ptr = NULL; event_ptr = esif_ccb_memtype_zalloc(ESIF_MEMTYPE_TYPE_EVENT, new_size); if (event_ptr) { event_ptr->version = ESIF_EVENT_VERSION; event_ptr->size = new_size; event_ptr->type = type; event_ptr->priority = priority; event_ptr->src = src; event_ptr->dst = dst; event_ptr->dst_domain_id = dst_domain_id; event_ptr->data_size = size; /* * Assign Function Pointers If Any */ #ifdef ESIF_EVENT_DEBUG event_ptr->get_type_str = esif_event_type_str; event_ptr->get_priority_str = esif_event_priority_str; event_ptr->dump = esif_dump_event; #endif /* ** Transaction ID */ esif_ccb_write_lock(&g_event_lock); event_ptr->id = g_event_transaction_id++; esif_ccb_write_unlock(&g_event_lock); /* ** Time Stamp */ esif_ccb_system_time(&event_ptr->timestamp); /* ** Make A Copy Of The Data To Make Sure It Is Contigous ** In The Buffer */ if (NULL != data_ptr) esif_ccb_memcpy((event_ptr + 1), data_ptr, size); ESIF_TRACE_DYN_EVENT("%s: buf %p bytes %d\n", ESIF_FUNC, event_ptr, new_size); ESIF_TRACE_DYN_DECODE("Version: %d\n" "Type: %s(%d)\n" "ID: %llu\n" "Timestamp: %llu\n" "Priority: %s(%d)\n" "Source: %d\n" "Destination: %d\n" "Data Size: %d\n", event_ptr->version, esif_event_type_str(event_ptr->type), event_ptr->type, event_ptr->id, (u64)event_ptr->timestamp, esif_event_priority_str( event_ptr->priority), event_ptr->priority, event_ptr->src, event_ptr->dst, event_ptr->data_size); } return event_ptr; }
int EsifTraceMessage( esif_tracemask_t module, int level, const char *func, const char *file, int line, const char *msg, ...) { int rc=0; char *appname = ""; char *fmtDetail= "%s%s:[<%s>%s@%s#%d]<%llu ms>: "; char *fmtInfo = "%s%s:[<%s>]<%llu ms>: "; const char *sep=NULL; size_t fmtlen=esif_ccb_strlen(msg, 0x7FFFFFFF); int detailed_message = (level >= DETAILED_TRACELEVEL ? ESIF_TRUE : ESIF_FALSE); va_list args; esif_ccb_time_t msec = 0; enum esif_tracemodule moduleid = ESIF_TRACEMODULE_DEFAULT; const char *module_name = NULL; esif_ccb_system_time(&msec); while (module >>= 1) moduleid++; module_name = EsifTraceModule_ToString(moduleid); level = esif_ccb_min(level, ESIF_TRACELEVEL_MAX); level = esif_ccb_max(level, ESIF_TRACELEVEL_FATAL); if ((sep = strrchr(file, *ESIF_PATH_SEP)) != NULL) file = sep+1; // Do not log function/file/line information for DPTF app interface messages logged from EsifSvcWriteLog if (moduleid == ESIF_TRACEMODULE_DPTF) { detailed_message = ESIF_FALSE; } if (g_traceinfo[level].routes & ESIF_TRACEROUTE_CONSOLE) { if (detailed_message) rc = CMD_CONSOLE(fmtDetail, appname, g_traceinfo[level].label, module_name, func, file, line, msec); else rc = CMD_CONSOLE(fmtInfo, appname, g_traceinfo[level].label, module_name, msec); va_start(args, msg); rc += EsifConsole_WriteConsole(msg, args); va_end(args); if (fmtlen && msg[fmtlen-1]!='\n') CMD_CONSOLE("\n"); } if (g_traceinfo[level].routes & ESIF_TRACEROUTE_LOGFILE && EsifLogFile_IsOpen(ESIF_LOG_TRACE)) { time_t now=0; char timestamp[MAX_CTIME_LEN]={0}; time(&now); esif_ccb_ctime(timestamp, sizeof(timestamp), &now); timestamp[20] = 0; // truncate year if (detailed_message) rc = EsifLogFile_Write(ESIF_LOG_TRACE, fmtDetail, timestamp + 4, g_traceinfo[level].label, module_name, func, file, line, msec); else rc = EsifLogFile_Write(ESIF_LOG_TRACE, fmtInfo, timestamp+4, g_traceinfo[level].label, module_name, msec); va_start(args, msg); rc += EsifLogFile_WriteArgsAppend(ESIF_LOG_TRACE, "\n", msg, args); va_end(args); } #ifdef ESIF_ATTR_OS_WINDOWS if (g_traceinfo[level].routes & (ESIF_TRACEROUTE_DEBUGGER)) { size_t msglen=0; char *buffer=0; int offset=0; va_start(args, msg); msglen = esif_ccb_vscprintf(msg, args) + esif_ccb_strlen(g_traceinfo[level].label, MAX_PATH) + esif_ccb_strlen(appname, MAX_PATH) + esif_ccb_strlen(func, MAX_PATH) + esif_ccb_strlen(file, MAX_PATH) + esif_ccb_strlen(module_name, MAX_PATH) + 22; va_end(args); msglen += (detailed_message ? esif_ccb_strlen(fmtDetail, MAX_PATH) : esif_ccb_strlen(fmtInfo, MAX_PATH)); buffer = (char *)esif_ccb_malloc(msglen); if (NULL != buffer) { if (detailed_message) rc = esif_ccb_sprintf(msglen, buffer, fmtDetail, appname, g_traceinfo[level].label, module_name, func, file, line, msec); else rc = esif_ccb_sprintf(msglen, buffer, fmtInfo, appname, g_traceinfo[level].label, module_name, msec); offset = rc; va_start(args, msg); rc += esif_ccb_vsprintf(msglen-offset, buffer+offset, msg, args); va_end(args); if (rc && buffer[rc-1]!='\n') esif_ccb_strcat(buffer, "\n", msglen); OutputDebugStringA(buffer); esif_ccb_free(buffer); } } if (g_traceinfo[level].routes & (ESIF_TRACEROUTE_EVENTLOG)) { size_t msglen=0; char *buffer=0; char *replaced=0; int offset=0; int backset=0; WORD eventType; appname = ""; fmtInfo = "%sESIF(%s) TYPE: %s MODULE: %s TIME %llu ms\n\n"; fmtDetail= "%sESIF(%s) TYPE: %s MODULE: %s FUNC: %s FILE: %s LINE: %d TIME: %llu ms\n\n"; backset = 0; va_start(args, msg); msglen = esif_ccb_vscprintf(msg,args) + esif_ccb_strlen(g_traceinfo[level].label, MAX_PATH) + esif_ccb_strlen(appname, MAX_PATH) + esif_ccb_strlen(func, MAX_PATH) + esif_ccb_strlen(file, MAX_PATH) + esif_ccb_strlen(module_name, MAX_PATH) + 32; va_end(args); msglen += (detailed_message ? esif_ccb_strlen(fmtDetail, MAX_PATH) : esif_ccb_strlen(fmtInfo, MAX_PATH)); buffer = (char *)esif_ccb_malloc(msglen); if (NULL != buffer) { if (detailed_message) rc = esif_ccb_sprintf(msglen, buffer, fmtDetail, appname, ESIF_UF_VERSION, g_traceinfo[level].label, module_name, func, file, line, msec); else rc = esif_ccb_sprintf(msglen, buffer, fmtInfo, appname, ESIF_UF_VERSION, g_traceinfo[level].label, module_name, msec); if (backset && backset < rc) buffer[rc-backset-1] = 0; offset = rc-backset; va_start(args, msg); rc += esif_ccb_vsprintf(msglen-(offset+backset), buffer+offset+backset, msg, args); va_end(args); if (rc && buffer[rc-1]=='\n') buffer[--rc] = 0; switch (g_traceinfo[level].level) { case ESIF_TRACELEVEL_FATAL: case ESIF_TRACELEVEL_ERROR: eventType = EVENTLOG_ERROR_TYPE; break; case ESIF_TRACELEVEL_WARN: eventType = EVENTLOG_WARNING_TYPE; break; case ESIF_TRACELEVEL_INFO: case ESIF_TRACELEVEL_DEBUG: default: eventType = EVENTLOG_INFORMATION_TYPE; break; } // Escape any "%" in message before writing to EventLog if ((replaced = esif_str_replace(buffer, "%", "%%")) != NULL) { esif_ccb_free(buffer); buffer = replaced; replaced = NULL; } report_event_to_event_log(CATEGORY_GENERAL, eventType, buffer); esif_ccb_free(buffer); } } #endif #ifdef ESIF_ATTR_OS_LINUX if (g_traceinfo[level].routes & (ESIF_TRACEROUTE_EVENTLOG|ESIF_TRACEROUTE_DEBUGGER)) { size_t msglen=0; char *buffer=0; int offset=0; int priority; fmtDetail= "%s:[<%s>%s@%s#%d]<%llu ms>: "; fmtInfo = "%s:[<%s>]<%llu ms>: "; va_start(args, msg); msglen = esif_ccb_vscprintf(msg,args) + esif_ccb_strlen(g_traceinfo[level].label, MAX_PATH) + esif_ccb_strlen(func, MAX_PATH) + esif_ccb_strlen(file, MAX_PATH) + esif_ccb_strlen(module_name, MAX_PATH) + 22; va_end(args); msglen += (detailed_message ? esif_ccb_strlen(fmtDetail, MAX_PATH) : esif_ccb_strlen(fmtInfo, MAX_PATH)); buffer = (char *)esif_ccb_malloc(msglen); if (NULL != buffer) { char *lf; if (detailed_message) rc = esif_ccb_sprintf(msglen, buffer, fmtDetail, g_traceinfo[level].label, module_name, func, file, line, msec); else rc = esif_ccb_sprintf(msglen, buffer, fmtInfo, g_traceinfo[level].label, module_name, msec); offset = rc; va_start(args, msg); rc += esif_ccb_vsprintf(msglen-offset, buffer+offset, msg, args); va_end(args); if (rc && buffer[rc-1]=='\n') buffer[--rc] = 0; while ((lf = esif_ccb_strchr(buffer, '\n')) != NULL) *lf = '\t'; switch (g_traceinfo[level].level) { case ESIF_TRACELEVEL_FATAL: priority = ESIF_PRIORITY_FATAL; break; case ESIF_TRACELEVEL_ERROR: priority = ESIF_PRIORITY_ERROR; break; case ESIF_TRACELEVEL_WARN: priority = ESIF_PRIORITY_WARNING; break; case ESIF_TRACELEVEL_INFO: priority = ESIF_PRIORITY_INFO; break; case ESIF_TRACELEVEL_DEBUG: default: priority = ESIF_PRIORITY_DEBUG; break; } #ifdef ESIF_ATTR_OS_ANDROID __android_log_write(priority, IDENT, buffer); #else openlog(IDENT, OPTION, FACILITY); syslog(priority, "%s", buffer); closelog(); #endif esif_ccb_free(buffer); } } #endif return rc; }