services/core/jni/com_android_server_am_BatteryStatsService.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "BatteryStatsService"
 //#define LOG_NDEBUG 0

 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <semaphore.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include <android_runtime/AndroidRuntime.h>
 #include <jni.h>

 #include <nativehelper/ScopedLocalRef.h>
 #include <nativehelper/ScopedPrimitiveArray.h>

 #include <log/log.h>
 #include <utils/misc.h>
 #include <utils/Log.h>
 #include <hardware/hardware.h>
 #include <hardware/power.h>
 #include <suspend/autosuspend.h>

 namespace android
 {

 #define LAST_RESUME_REASON "/sys/kernel/wakeup_reasons/last_resume_reason"
 #define MAX_REASON_SIZE 512

 static bool wakeup_init = false;
 static sem_t wakeup_sem;
 extern struct power_module* gPowerModule;

 static void wakeup_callback(bool success)
 {
     ALOGV("In wakeup_callback: %s", success ? "resumed from suspend" : "suspend aborted");
     int ret = sem_post(&wakeup_sem);
     if (ret < 0) {
         char buf[80];
         strerror_r(errno, buf, sizeof(buf));
         ALOGE("Error posting wakeup sem: %s\n", buf);
     }
 }

 static jint nativeWaitWakeup(JNIEnv *env, jobject clazz, jobject outBuf)
 {
     if (outBuf == NULL) {
         jniThrowException(env, "java/lang/NullPointerException", "null argument");
         return -1;
     }

     // Register our wakeup callback if not yet done.
     if (!wakeup_init) {
         wakeup_init = true;
         ALOGV("Creating semaphore...");
         int ret = sem_init(&wakeup_sem, 0, 0);
         if (ret < 0) {
             char buf[80];
             strerror_r(errno, buf, sizeof(buf));
             ALOGE("Error creating semaphore: %s\n", buf);
             jniThrowException(env, "java/lang/IllegalStateException", buf);
             return -1;
         }
         ALOGV("Registering callback...");
         set_wakeup_callback(&wakeup_callback);
     }

     // Wait for wakeup.
     ALOGV("Waiting for wakeup...");
     int ret = sem_wait(&wakeup_sem);
     if (ret < 0) {
         char buf[80];
         strerror_r(errno, buf, sizeof(buf));
         ALOGE("Error waiting on semaphore: %s\n", buf);
         // Return 0 here to let it continue looping but not return results.
         return 0;
     }

     FILE *fp = fopen(LAST_RESUME_REASON, "r");
     if (fp == NULL) {
         ALOGE("Failed to open %s", LAST_RESUME_REASON);
         return -1;
     }

     char* mergedreason = (char*)env->GetDirectBufferAddress(outBuf);
     int remainreasonlen = (int)env->GetDirectBufferCapacity(outBuf);

     ALOGV("Reading wakeup reasons");
     char* mergedreasonpos = mergedreason;
     char reasonline[128];
     int i = 0;
     while (fgets(reasonline, sizeof(reasonline), fp) != NULL) {
         char* pos = reasonline;
         char* endPos;
         int len;
         // First field is the index or 'Abort'.
         int irq = (int)strtol(pos, &endPos, 10);
         if (pos != endPos) {
             // Write the irq number to the merged reason string.
             len = snprintf(mergedreasonpos, remainreasonlen, i == 0 ? "%d" : ":%d", irq);
         } else {
             // The first field is not an irq, it may be the word Abort.
             const size_t abortPrefixLen = strlen("Abort:");
             if (strncmp(pos, "Abort:", abortPrefixLen) != 0) {
                 // Ooops.
                 ALOGE("Bad reason line: %s", reasonline);
                 continue;
             }

             // Write 'Abort' to the merged reason string.
             len = snprintf(mergedreasonpos, remainreasonlen, i == 0 ? "Abort" : ":Abort");
             endPos = pos + abortPrefixLen;
         }
         pos = endPos;

         if (len >= 0 && len < remainreasonlen) {
             mergedreasonpos += len;
             remainreasonlen -= len;
         }

         // Skip whitespace; rest of the buffer is the reason string.
         while (*pos == ' ') {
             pos++;
         }

         // Chop newline at end.
         char* endpos = pos;
         while (*endpos != 0) {
             if (*endpos == '\n') {
                 *endpos = 0;
                 break;
             }
             endpos++;
         }

         len = snprintf(mergedreasonpos, remainreasonlen, ":%s", pos);
         if (len >= 0 && len < remainreasonlen) {
             mergedreasonpos += len;
             remainreasonlen -= len;
         }
         i++;
     }

     ALOGV("Got %d reasons", i);
     if (i > 0) {
         *mergedreasonpos = 0;
     }

     if (fclose(fp) != 0) {
         ALOGE("Failed to close %s", LAST_RESUME_REASON);
         return -1;
     }
     return mergedreasonpos - mergedreason;
 }

 static jint getPlatformLowPowerStats(JNIEnv* env, jobject /* clazz */, jobject outBuf) {
     int num_modes = -1;
     char *output = (char*)env->GetDirectBufferAddress(outBuf), *offset = output;
     int remaining = (int)env->GetDirectBufferCapacity(outBuf);
     power_state_platform_sleep_state_t *list;
     size_t *voter_list;
     int total_added = -1;

     if (outBuf == NULL) {
         jniThrowException(env, "java/lang/NullPointerException", "null argument");
         goto error;
     }

     if (!gPowerModule) {
         ALOGE("%s: gPowerModule not loaded", POWER_HARDWARE_MODULE_ID);
         goto error;
     }

     if (! (gPowerModule->get_platform_low_power_stats && gPowerModule->get_number_of_platform_modes
        && gPowerModule->get_voter_list)) {
         ALOGE("%s: Missing API", POWER_HARDWARE_MODULE_ID);
         goto error;
     }

     if (gPowerModule->get_number_of_platform_modes) {
         num_modes = gPowerModule->get_number_of_platform_modes(gPowerModule);
     }

     if (num_modes < 1) {
         ALOGE("%s: Platform does not even have one low power mode", POWER_HARDWARE_MODULE_ID);
         goto error;
     }

     list = (power_state_platform_sleep_state_t *)calloc(num_modes,
         sizeof(power_state_platform_sleep_state_t));
     if (!list) {
         ALOGE("%s: power_state_platform_sleep_state_t allocation failed", POWER_HARDWARE_MODULE_ID);
         goto error;
     }

     voter_list = (size_t *)calloc(num_modes, sizeof(*voter_list));
     if (!voter_list) {
         ALOGE("%s: voter_list allocation failed", POWER_HARDWARE_MODULE_ID);
         goto err_free;
     }

     gPowerModule->get_voter_list(gPowerModule, voter_list);

     for (int i = 0; i < num_modes; i++) {
         list[i].voters = (power_state_voter_t *)calloc(voter_list[i],
                          sizeof(power_state_voter_t));
         if (!list[i].voters) {
             ALOGE("%s: voter_t allocation failed", POWER_HARDWARE_MODULE_ID);
             goto err_free;
         }
     }

     if (!gPowerModule->get_platform_low_power_stats(gPowerModule, list)) {
         for (int i = 0; i < num_modes; i++) {
             int added;

             added = snprintf(offset, remaining,
                     "state_%d name=%s time=%" PRIu64 " count=%" PRIu64 " ",
                     i + 1, list[i].name, list[i].residency_in_msec_since_boot,
                     list[i].total_transitions);
             if (added < 0) {
                 break;
             }
             if (added > remaining) {
                 added = remaining;
             }
             offset += added;
             remaining -= added;
             total_added += added;

             for (unsigned int j = 0; j < list[i].number_of_voters; j++) {
                 added = snprintf(offset, remaining,
                         "voter_%d name=%s time=%" PRIu64 " count=%" PRIu64 " ",
                         j + 1, list[i].voters[j].name,
                         list[i].voters[j].total_time_in_msec_voted_for_since_boot,
                         list[i].voters[j].total_number_of_times_voted_since_boot);
                 if (added < 0) {
                     break;
                 }
                 if (added > remaining) {
                     added = remaining;
                 }
                 offset += added;
                 remaining -= added;
                 total_added += added;
             }

             if (remaining <= 0) {
                 /* rewrite NULL character*/
                 offset--;
                 total_added--;
                 ALOGE("%s module: buffer not enough", POWER_HARDWARE_MODULE_ID);
                 break;
             }
         }
     }
     *offset = 0;
     total_added += 1;

 err_free:
     for (int i = 0; i < num_modes; i++) {
         free(list[i].voters);
     }
     free(list);
     free(voter_list);
 error:
     return total_added;
 }

 static const JNINativeMethod method_table[] = {
     { "nativeWaitWakeup", "(Ljava/nio/ByteBuffer;)I", (void*)nativeWaitWakeup },
     { "getPlatformLowPowerStats", "(Ljava/nio/ByteBuffer;)I", (void*)getPlatformLowPowerStats },
 };

 int register_android_server_BatteryStatsService(JNIEnv *env)
 {
     return jniRegisterNativeMethods(env, "com/android/server/am/BatteryStatsService",
             method_table, NELEM(method_table));
 }

 };
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "BatteryStatsService"
	//#define LOG_NDEBUG 0

	#include <errno.h>
	#include <fcntl.h>
	#include <inttypes.h>
	#include <semaphore.h>
	#include <stddef.h>
	#include <stdio.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include <android_runtime/AndroidRuntime.h>
	#include <jni.h>

	#include <nativehelper/ScopedLocalRef.h>
	#include <nativehelper/ScopedPrimitiveArray.h>

	#include <log/log.h>
	#include <utils/misc.h>
	#include <utils/Log.h>
	#include <hardware/hardware.h>
	#include <hardware/power.h>
	#include <suspend/autosuspend.h>

	namespace android
	{

	#define LAST_RESUME_REASON "/sys/kernel/wakeup_reasons/last_resume_reason"
	#define MAX_REASON_SIZE 512

	static bool wakeup_init = false;
	static sem_t wakeup_sem;
	extern struct power_module* gPowerModule;

	static void wakeup_callback(bool success)
	{
	ALOGV("In wakeup_callback: %s", success ? "resumed from suspend" : "suspend aborted");
	int ret = sem_post(&wakeup_sem);
	if (ret < 0) {
	char buf[80];
	strerror_r(errno, buf, sizeof(buf));
	ALOGE("Error posting wakeup sem: %s\n", buf);
	}
	}

	static jint nativeWaitWakeup(JNIEnv *env, jobject clazz, jobject outBuf)
	{
	if (outBuf == NULL) {
	jniThrowException(env, "java/lang/NullPointerException", "null argument");
	return -1;
	}

	// Register our wakeup callback if not yet done.
	if (!wakeup_init) {
	wakeup_init = true;
	ALOGV("Creating semaphore...");
	int ret = sem_init(&wakeup_sem, 0, 0);
	if (ret < 0) {
	char buf[80];
	strerror_r(errno, buf, sizeof(buf));
	ALOGE("Error creating semaphore: %s\n", buf);
	jniThrowException(env, "java/lang/IllegalStateException", buf);
	return -1;
	}
	ALOGV("Registering callback...");
	set_wakeup_callback(&wakeup_callback);
	}

	// Wait for wakeup.
	ALOGV("Waiting for wakeup...");
	int ret = sem_wait(&wakeup_sem);
	if (ret < 0) {
	char buf[80];
	strerror_r(errno, buf, sizeof(buf));
	ALOGE("Error waiting on semaphore: %s\n", buf);
	// Return 0 here to let it continue looping but not return results.
	return 0;
	}

	FILE *fp = fopen(LAST_RESUME_REASON, "r");
	if (fp == NULL) {
	ALOGE("Failed to open %s", LAST_RESUME_REASON);
	return -1;
	}

	char* mergedreason = (char*)env->GetDirectBufferAddress(outBuf);
	int remainreasonlen = (int)env->GetDirectBufferCapacity(outBuf);

	ALOGV("Reading wakeup reasons");
	char* mergedreasonpos = mergedreason;
	char reasonline[128];
	int i = 0;
	while (fgets(reasonline, sizeof(reasonline), fp) != NULL) {
	char* pos = reasonline;
	char* endPos;
	int len;
	// First field is the index or 'Abort'.
	int irq = (int)strtol(pos, &endPos, 10);
	if (pos != endPos) {
	// Write the irq number to the merged reason string.
	len = snprintf(mergedreasonpos, remainreasonlen, i == 0 ? "%d" : ":%d", irq);
	} else {
	// The first field is not an irq, it may be the word Abort.
	const size_t abortPrefixLen = strlen("Abort:");
	if (strncmp(pos, "Abort:", abortPrefixLen) != 0) {
	// Ooops.
	ALOGE("Bad reason line: %s", reasonline);
	continue;
	}

	// Write 'Abort' to the merged reason string.
	len = snprintf(mergedreasonpos, remainreasonlen, i == 0 ? "Abort" : ":Abort");
	endPos = pos + abortPrefixLen;
	}
	pos = endPos;

	if (len >= 0 && len < remainreasonlen) {
	mergedreasonpos += len;
	remainreasonlen -= len;
	}

	// Skip whitespace; rest of the buffer is the reason string.
	while (*pos == ' ') {
	pos++;
	}

	// Chop newline at end.
	char* endpos = pos;
	while (*endpos != 0) {
	if (*endpos == '\n') {
	*endpos = 0;
	break;
	}
	endpos++;
	}

	len = snprintf(mergedreasonpos, remainreasonlen, ":%s", pos);
	if (len >= 0 && len < remainreasonlen) {
	mergedreasonpos += len;
	remainreasonlen -= len;
	}
	i++;
	}

	ALOGV("Got %d reasons", i);
	if (i > 0) {
	*mergedreasonpos = 0;
	}

	if (fclose(fp) != 0) {
	ALOGE("Failed to close %s", LAST_RESUME_REASON);
	return -1;
	}
	return mergedreasonpos - mergedreason;
	}

	static jint getPlatformLowPowerStats(JNIEnv* env, jobject /* clazz */, jobject outBuf) {
	int num_modes = -1;
	char output = (char)env->GetDirectBufferAddress(outBuf), *offset = output;
	int remaining = (int)env->GetDirectBufferCapacity(outBuf);
	power_state_platform_sleep_state_t *list;
	size_t *voter_list;
	int total_added = -1;

	if (outBuf == NULL) {
	jniThrowException(env, "java/lang/NullPointerException", "null argument");
	goto error;
	}

	if (!gPowerModule) {
	ALOGE("%s: gPowerModule not loaded", POWER_HARDWARE_MODULE_ID);
	goto error;
	}

	if (! (gPowerModule->get_platform_low_power_stats && gPowerModule->get_number_of_platform_modes
	&& gPowerModule->get_voter_list)) {
	ALOGE("%s: Missing API", POWER_HARDWARE_MODULE_ID);
	goto error;
	}

	if (gPowerModule->get_number_of_platform_modes) {
	num_modes = gPowerModule->get_number_of_platform_modes(gPowerModule);
	}

	if (num_modes < 1) {
	ALOGE("%s: Platform does not even have one low power mode", POWER_HARDWARE_MODULE_ID);
	goto error;
	}

	list = (power_state_platform_sleep_state_t *)calloc(num_modes,
	sizeof(power_state_platform_sleep_state_t));
	if (!list) {
	ALOGE("%s: power_state_platform_sleep_state_t allocation failed", POWER_HARDWARE_MODULE_ID);
	goto error;
	}

	voter_list = (size_t )calloc(num_modes, sizeof(voter_list));
	if (!voter_list) {
	ALOGE("%s: voter_list allocation failed", POWER_HARDWARE_MODULE_ID);
	goto err_free;
	}

	gPowerModule->get_voter_list(gPowerModule, voter_list);

	for (int i = 0; i < num_modes; i++) {
	list[i].voters = (power_state_voter_t *)calloc(voter_list[i],
	sizeof(power_state_voter_t));
	if (!list[i].voters) {
	ALOGE("%s: voter_t allocation failed", POWER_HARDWARE_MODULE_ID);
	goto err_free;
	}
	}

	if (!gPowerModule->get_platform_low_power_stats(gPowerModule, list)) {
	for (int i = 0; i < num_modes; i++) {
	int added;

	added = snprintf(offset, remaining,
	"state_%d name=%s time=%" PRIu64 " count=%" PRIu64 " ",
	i + 1, list[i].name, list[i].residency_in_msec_since_boot,
	list[i].total_transitions);
	if (added < 0) {
	break;
	}
	if (added > remaining) {
	added = remaining;
	}
	offset += added;
	remaining -= added;
	total_added += added;

	for (unsigned int j = 0; j < list[i].number_of_voters; j++) {
	added = snprintf(offset, remaining,
	"voter_%d name=%s time=%" PRIu64 " count=%" PRIu64 " ",
	j + 1, list[i].voters[j].name,
	list[i].voters[j].total_time_in_msec_voted_for_since_boot,
	list[i].voters[j].total_number_of_times_voted_since_boot);
	if (added < 0) {
	break;
	}
	if (added > remaining) {
	added = remaining;
	}
	offset += added;
	remaining -= added;
	total_added += added;
	}

	if (remaining <= 0) {
	/* rewrite NULL character*/
	offset--;
	total_added--;
	ALOGE("%s module: buffer not enough", POWER_HARDWARE_MODULE_ID);
	break;
	}
	}
	}
	*offset = 0;
	total_added += 1;

	err_free:
	for (int i = 0; i < num_modes; i++) {
	free(list[i].voters);
	}
	free(list);
	free(voter_list);
	error:
	return total_added;
	}

	static const JNINativeMethod method_table[] = {
	{ "nativeWaitWakeup", "(Ljava/nio/ByteBuffer;)I", (void*)nativeWaitWakeup },
	{ "getPlatformLowPowerStats", "(Ljava/nio/ByteBuffer;)I", (void*)getPlatformLowPowerStats },
	};

	int register_android_server_BatteryStatsService(JNIEnv *env)
	{
	return jniRegisterNativeMethods(env, "com/android/server/am/BatteryStatsService",
	method_table, NELEM(method_table));
	}

	};