sqlite3 %{TZ_SYS_DB}/.battery-monitor.db 'PRAGMA journal_mode = PERSIST;
CREATE TABLE if not exists appid_map (id INTEGER PRIMARY KEY AUTOINCREMENT, AppId TEXT);
CREATE TABLE if not exists appid_usage (AppId TEXT, log_time INT, rId_ble INT, rId_wifi INT, rId_cpu INT, rId_display INT, rId_device_network INT,
- rId_gps INT, rId_hrm INT, rId_battery INT, rId_newone INT, rId_newtwo INT, rId_newthree INT);
+ rId_gps INT, rId_hrm INT, rId_battery INT);
CREATE TABLE if not exists resourceid_usage (ResourceId TEXT, log_time INT, usage INT);
CREATE TABLE if not exists gble_stat (time_s LONG INT, ble_idle_time INT, ble_rx_time INT, ble_tx_time INT, ble_pwi_val INT);
CREATE TABLE if not exists gwfl_stat (time_s LONG INT, wifi_on_time INT, wifi_conn_time INT, wifi_idle_time INT,
CREATE TABLE if not exists gwst_stat (time_s LONG INT, wscan_time INT, wnone_time INT, wpoor_time INT, wmed_time INT,
wgood_time INT, wgrt_time INT);
CREATE TABLE if not exists gbst_stat (time_s LONG INT, off_time INT, low_time INT, med_time INT, high_time INT);
+ CREATE TABLE if not exists gcpu_stat (time_s LONG INT, usr_time INT, sys_time INT);
'
fi
return ret;
}
+static int bd_get_and_print_gcpu_stat_entry_from_dump(int fd, long int duration)
+{
+ ENTER;
+ bd_gl_cpu_stat_s *gcpu_stat = (bd_gl_cpu_stat_s *)calloc(1, sizeof(bd_gl_cpu_stat_s));
+ BM_CHECK_MEM_ALLOC(gcpu_stat, {});
+
+ int ret = BATTERY_MONITOR_ERROR_NONE;
+ const char *rid_str = NULL; int usage = 0;
+ rid_str = bm_get_resource_id_string(2);
+ resourceid_usage_s *res_use =
+ bm_server_query_resource_usage_resourceid(rid_str, 1, &ret);
+ if (res_use == NULL || ret != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("For resourceid %s", rid_str);
+ _DBG("Dump only system stats");
+ }
+ usage = res_use->usage;
+ float usagemah = (float)usage/3600;
+ ret = bm_server_battery_dump_query_from_db(gcpu_stat, 7, duration);
+ if (ret != BATTERY_MONITOR_ERROR_NONE) {
+ _ERR("Unable to fetch data from DB");
+ BM_FREE(gcpu_stat);
+ BM_FREE(res_use);
+ return ret;
+ }
+ GString *dump_p = g_string_sized_new(30);
+ BM_CHECK_MEM_ALLOC(dump_p, {BM_FREE(gcpu_stat); BM_FREE(res_use);});
+ g_string_append(dump_p, TIZEN_DUMP_VERSION);
+ g_string_append(dump_p, ",0,l,");
+ g_string_append(dump_p, "cpu,");
+ g_string_append_printf(dump_p, "%ld,", gcpu_stat->usr_time);
+ g_string_append_printf(dump_p, "%ld,", gcpu_stat->sys_time);
+ g_string_append_printf(dump_p, "%0.2f", usagemah);
+ g_string_append(dump_p, "\n");
+ bm_resourceid_usage_free(res_use);
+ _DBG("%s", dump_p->str);
+ if (write(fd, dump_p->str, dump_p->len) < 0)
+ _WARN("write error");
+ g_free(dump_p->str);
+
+ EXIT;
+ return ret;
+}
+
static int bd_get_and_print_uid_info_entry_from_dump(int fd)
{
ENTER;
ret = bd_get_and_print_gwst_stat_entry_from_dump(fd, duration);
if (ret != BATTERY_MONITOR_ERROR_NONE)
_ERR("GWST data dump failed");
+ ret = bd_get_and_print_gcpu_stat_entry_from_dump(fd, duration);
+ _ERR("GCPU data dump failed");
// Battery Usage Dump
// Add usage for each of the resource
// and each of the application
return count;
}
+static int bm_gl_cpu_stat_convert_to_sql(bd_gl_cpu_stat_s *gcpu_st, bm_stmt hstmt, char *sql_value)
+{
+ ENTER;
+
+ int count = 1;
+ bm_query_bind_int(hstmt, count++, gcpu_st->time_s);
+ bm_query_bind_int(hstmt, count++, gcpu_st->usr_time);
+ bm_query_bind_int(hstmt, count++, gcpu_st->sys_time);
+
+ EXIT;
+ return count;
+}
+
static void bm_convert_column_to_resourceid_usage(bm_stmt hstmt, resourceid_usage_s* bm_resource_type)
{
ENTER;
return;
}
+static void bm_convert_column_to_gl_cpu_stat(bm_stmt hstmt, bd_gl_cpu_stat_s *gcpu_st)
+{
+ ENTER;
+ gcpu_st->time_s = -1;
+ gcpu_st->usr_time = bm_query_table_column_int(hstmt, BD_GCPUSTAT_USR);
+ gcpu_st->sys_time = bm_query_table_column_int(hstmt, BD_GCPUSTAT_SYS);
+
+ EXIT;
+ return;
+}
+
static int bm_get_record_count(sqlite3 *bm_db_handle, const char *query)
{
ENTER;
BM_MEMSET(query, 0, sizeof(query));
BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in \
- ('%s', '%s', '%s', '%s','%s', '%s', '%s', '%s','%s', '%s')",
+ ('%s', '%s', '%s', '%s','%s', '%s', '%s', '%s','%s', '%s', '%s')",
BATTERY_MONITOR_APP_ID_MAP_TABLE, BATTERY_MONITOR_APP_ID_USAGE_TABLE,
BATTERY_MONITOR_RESOURCE_ID_USAGE_TABLE, BATTERY_MONITOR_GBL_BLE_STAT_TABLE,
BATTERY_MONITOR_GBL_WFL_STAT_TABLE, BATTERY_MONITOR_GBL_NT_STAT_TABLE,
BATTERY_MONITOR_GBL_BR_STAT_TABLE, BATTERY_MONITOR_GBL_SGT_STAT_TABLE,
- BATTERY_MONITOR_GBL_WST_STAT_TABLE, BATTERY_MONITOR_GBL_BST_STAT_TABLE);
+ BATTERY_MONITOR_GBL_WST_STAT_TABLE, BATTERY_MONITOR_GBL_BST_STAT_TABLE,
+ BATTERY_MONITOR_GBL_CPU_STAT_TABLE);
rc = bm_get_record_count(bm_db_handle, query);
("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
GBL_BST_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
}
+ /* Create the global cpu stats table */
+ BM_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')",
+ BATTERY_MONITOR_GBL_CPU_STAT_TABLE);
+ rc = bm_get_record_count(bm_db_handle, query);
+ if (rc <= 0) {
+ rc = bm_execute_query(bm_db_handle, GBL_CPU_STAT_SCHEMA);
+ if (rc == SQLITE_BUSY)
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ BM_RETURN_VAL((SQLITE_OK == rc), {}, BATTERY_MONITOR_ERROR_DB_FAILED,
+ ("bm_execute_query(bm_db_handle, %s) failed(%d, %s).\n",
+ GBL_CPU_STAT_SCHEMA, rc, bm_db_err_msg(bm_db_handle)));
+ }
EXIT;
return error_code;
BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
bm_gl_bst_stat_convert_to_sql(gbst_st, hstmt, query);
break;
+ case 7:
+ _DBG("GCPU_DATA");
+ bd_gl_cpu_stat_s *gcpu_st = (bd_gl_cpu_stat_s *)str_data;
+ _DBG("time %ld usr %ld sys %ld", gcpu_st->time_s, gcpu_st->usr_time, gcpu_st->sys_time);
+ BM_SNPRINTF(query, sizeof(query), "INSERT INTO %s(time_s, usr_time, sys_time) values "\
+ "(?, ?, ?)", BATTERY_MONITOR_GBL_CPU_STAT_TABLE);
+ hstmt = bm_prepare_query(bm_db_handle, query);
+ if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+ _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ } else if (bm_db_err_code(bm_db_handle) == SQLITE_BUSY) {
+ _ERR("Database Busy(%s)", bm_db_err_msg(bm_db_handle));
+ return BATTERY_MONITOR_ERROR_DATABASE_BUSY;
+ }
+ BM_RETURN_VAL((hstmt != NULL), {}, BATTERY_MONITOR_ERROR_DB_FAILED, ("bm_prepare_query() failed(%s).\n", bm_db_err_msg(bm_db_handle)));
+ bm_gl_cpu_stat_convert_to_sql(gcpu_st, hstmt, query);
+ break;
default:
break;
}
BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
bm_convert_column_to_gl_bst_stat(hstmt, str_data);
break;
+ case 7:
+ _DBG("GCPU_DATA");
+ BM_SNPRINTF(query, sizeof(query), "SELECT sum(usr_time), sum(sys_time) \
+ FROM %s WHERE time_s >= %ld", BATTERY_MONITOR_GBL_CPU_STAT_TABLE, duration);
+ hstmt = bm_prepare_query(bm_db_handle, query);
+ if (bm_db_err_code(bm_db_handle) == SQLITE_PERM) {
+ _ERR("Access failed(%s)", bm_db_err_msg(bm_db_handle));
+ error_code = BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
+ return error_code;
+ }
+ rc = bm_query_step(hstmt);
+ BM_CATCH_ERROR(rc == SQLITE_ROW, {}, BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n"));
+ bm_convert_column_to_gl_cpu_stat(hstmt, str_data);
+ break;
default:
break;
}