android_util_EventLog.cpp revision 3ed8e2e679668767dc90c35a3a8a24e9ebf0b940
1/* 2 * Copyright (C) 2007-2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include <fcntl.h> 18 19#include "JNIHelp.h" 20#include "android_runtime/AndroidRuntime.h" 21#include "jni.h" 22#include "log/logger.h" 23 24#define UNUSED __attribute__((__unused__)) 25 26// The size of the tag number comes out of the payload size. 27#define MAX_EVENT_PAYLOAD (LOGGER_ENTRY_MAX_PAYLOAD - sizeof(int32_t)) 28 29namespace android { 30 31static jclass gCollectionClass; 32static jmethodID gCollectionAddID; 33 34static jclass gEventClass; 35static jmethodID gEventInitID; 36 37static jclass gIntegerClass; 38static jfieldID gIntegerValueID; 39 40static jclass gLongClass; 41static jfieldID gLongValueID; 42 43static jclass gStringClass; 44 45/* 46 * In class android.util.EventLog: 47 * static native int writeEvent(int tag, int value) 48 */ 49static jint android_util_EventLog_writeEvent_Integer(JNIEnv* env UNUSED, 50 jobject clazz UNUSED, 51 jint tag, jint value) 52{ 53 return android_btWriteLog(tag, EVENT_TYPE_INT, &value, sizeof(value)); 54} 55 56/* 57 * In class android.util.EventLog: 58 * static native int writeEvent(long tag, long value) 59 */ 60static jint android_util_EventLog_writeEvent_Long(JNIEnv* env UNUSED, 61 jobject clazz UNUSED, 62 jint tag, jlong value) 63{ 64 return android_btWriteLog(tag, EVENT_TYPE_LONG, &value, sizeof(value)); 65} 66 67/* 68 * In class android.util.EventLog: 69 * static native int writeEvent(int tag, String value) 70 */ 71static jint android_util_EventLog_writeEvent_String(JNIEnv* env, 72 jobject clazz UNUSED, 73 jint tag, jstring value) { 74 uint8_t buf[MAX_EVENT_PAYLOAD]; 75 76 // Don't throw NPE -- I feel like it's sort of mean for a logging function 77 // to be all crashy if you pass in NULL -- but make the NULL value explicit. 78 const char *str = value != NULL ? env->GetStringUTFChars(value, NULL) : "NULL"; 79 uint32_t len = strlen(str); 80 size_t max = sizeof(buf) - sizeof(len) - 2; // Type byte, final newline 81 if (len > max) len = max; 82 83 buf[0] = EVENT_TYPE_STRING; 84 memcpy(&buf[1], &len, sizeof(len)); 85 memcpy(&buf[1 + sizeof(len)], str, len); 86 buf[1 + sizeof(len) + len] = '\n'; 87 88 if (value != NULL) env->ReleaseStringUTFChars(value, str); 89 return android_bWriteLog(tag, buf, 2 + sizeof(len) + len); 90} 91 92/* 93 * In class android.util.EventLog: 94 * static native int writeEvent(long tag, Object... value) 95 */ 96static jint android_util_EventLog_writeEvent_Array(JNIEnv* env, jobject clazz, 97 jint tag, jobjectArray value) { 98 if (value == NULL) { 99 return android_util_EventLog_writeEvent_String(env, clazz, tag, NULL); 100 } 101 102 uint8_t buf[MAX_EVENT_PAYLOAD]; 103 const size_t max = sizeof(buf) - 1; // leave room for final newline 104 size_t pos = 2; // Save room for type tag & array count 105 106 jsize copied = 0, num = env->GetArrayLength(value); 107 for (; copied < num && copied < 255; ++copied) { 108 jobject item = env->GetObjectArrayElement(value, copied); 109 if (item == NULL || env->IsInstanceOf(item, gStringClass)) { 110 if (pos + 1 + sizeof(jint) > max) break; 111 const char *str = item != NULL ? env->GetStringUTFChars((jstring) item, NULL) : "NULL"; 112 jint len = strlen(str); 113 if (pos + 1 + sizeof(len) + len > max) len = max - pos - 1 - sizeof(len); 114 buf[pos++] = EVENT_TYPE_STRING; 115 memcpy(&buf[pos], &len, sizeof(len)); 116 memcpy(&buf[pos + sizeof(len)], str, len); 117 pos += sizeof(len) + len; 118 if (item != NULL) env->ReleaseStringUTFChars((jstring) item, str); 119 } else if (env->IsInstanceOf(item, gIntegerClass)) { 120 jint intVal = env->GetIntField(item, gIntegerValueID); 121 if (pos + 1 + sizeof(intVal) > max) break; 122 buf[pos++] = EVENT_TYPE_INT; 123 memcpy(&buf[pos], &intVal, sizeof(intVal)); 124 pos += sizeof(intVal); 125 } else if (env->IsInstanceOf(item, gLongClass)) { 126 jlong longVal = env->GetLongField(item, gLongValueID); 127 if (pos + 1 + sizeof(longVal) > max) break; 128 buf[pos++] = EVENT_TYPE_LONG; 129 memcpy(&buf[pos], &longVal, sizeof(longVal)); 130 pos += sizeof(longVal); 131 } else { 132 jniThrowException(env, 133 "java/lang/IllegalArgumentException", 134 "Invalid payload item type"); 135 return -1; 136 } 137 env->DeleteLocalRef(item); 138 } 139 140 buf[0] = EVENT_TYPE_LIST; 141 buf[1] = copied; 142 buf[pos++] = '\n'; 143 return android_bWriteLog(tag, buf, pos); 144} 145 146/* 147 * In class android.util.EventLog: 148 * static native void readEvents(int[] tags, Collection<Event> output) 149 * 150 * Reads events from the event log 151 */ 152static void android_util_EventLog_readEvents(JNIEnv* env, jobject clazz UNUSED, 153 jintArray tags, 154 jobject out) { 155 156 if (tags == NULL || out == NULL) { 157 jniThrowNullPointerException(env, NULL); 158 return; 159 } 160 161 struct logger_list *logger_list = android_logger_list_open( 162 LOG_ID_EVENTS, O_RDONLY | O_NONBLOCK, 0, 0); 163 164 if (!logger_list) { 165 jniThrowIOException(env, errno); 166 return; 167 } 168 169 jsize tagLength = env->GetArrayLength(tags); 170 jint *tagValues = env->GetIntArrayElements(tags, NULL); 171 172 while (1) { 173 log_msg log_msg; 174 int ret = android_logger_list_read(logger_list, &log_msg); 175 176 if (ret == 0) { 177 break; 178 } 179 if (ret < 0) { 180 if (errno == EINTR) { 181 continue; 182 } 183 if (errno == EINVAL) { 184 jniThrowException(env, "java/io/IOException", "Event too short"); 185 } else if (errno != EAGAIN) { 186 jniThrowIOException(env, errno); // Will throw on return 187 } 188 break; 189 } 190 191 int32_t tag = * (int32_t *) log_msg.msg(); 192 193 int found = 0; 194 for (int i = 0; !found && i < tagLength; ++i) { 195 found = (tag == tagValues[i]); 196 } 197 198 if (found) { 199 jsize len = ret; 200 jbyteArray array = env->NewByteArray(len); 201 if (array == NULL) { 202 break; 203 } 204 205 jbyte *bytes = env->GetByteArrayElements(array, NULL); 206 memcpy(bytes, log_msg.buf, len); 207 env->ReleaseByteArrayElements(array, bytes, 0); 208 209 jobject event = env->NewObject(gEventClass, gEventInitID, array); 210 if (event == NULL) { 211 break; 212 } 213 214 env->CallBooleanMethod(out, gCollectionAddID, event); 215 env->DeleteLocalRef(event); 216 env->DeleteLocalRef(array); 217 } 218 } 219 220 android_logger_list_close(logger_list); 221 222 env->ReleaseIntArrayElements(tags, tagValues, 0); 223} 224 225/* 226 * JNI registration. 227 */ 228static JNINativeMethod gRegisterMethods[] = { 229 /* name, signature, funcPtr */ 230 { "writeEvent", "(II)I", (void*) android_util_EventLog_writeEvent_Integer }, 231 { "writeEvent", "(IJ)I", (void*) android_util_EventLog_writeEvent_Long }, 232 { "writeEvent", 233 "(ILjava/lang/String;)I", 234 (void*) android_util_EventLog_writeEvent_String 235 }, 236 { "writeEvent", 237 "(I[Ljava/lang/Object;)I", 238 (void*) android_util_EventLog_writeEvent_Array 239 }, 240 { "readEvents", 241 "([ILjava/util/Collection;)V", 242 (void*) android_util_EventLog_readEvents 243 }, 244}; 245 246static struct { const char *name; jclass *clazz; } gClasses[] = { 247 { "android/util/EventLog$Event", &gEventClass }, 248 { "java/lang/Integer", &gIntegerClass }, 249 { "java/lang/Long", &gLongClass }, 250 { "java/lang/String", &gStringClass }, 251 { "java/util/Collection", &gCollectionClass }, 252}; 253 254static struct { jclass *c; const char *name, *ft; jfieldID *id; } gFields[] = { 255 { &gIntegerClass, "value", "I", &gIntegerValueID }, 256 { &gLongClass, "value", "J", &gLongValueID }, 257}; 258 259static struct { jclass *c; const char *name, *mt; jmethodID *id; } gMethods[] = { 260 { &gEventClass, "<init>", "([B)V", &gEventInitID }, 261 { &gCollectionClass, "add", "(Ljava/lang/Object;)Z", &gCollectionAddID }, 262}; 263 264int register_android_util_EventLog(JNIEnv* env) { 265 for (int i = 0; i < NELEM(gClasses); ++i) { 266 jclass clazz = env->FindClass(gClasses[i].name); 267 if (clazz == NULL) { 268 ALOGE("Can't find class: %s\n", gClasses[i].name); 269 return -1; 270 } 271 *gClasses[i].clazz = (jclass) env->NewGlobalRef(clazz); 272 } 273 274 for (int i = 0; i < NELEM(gFields); ++i) { 275 *gFields[i].id = env->GetFieldID( 276 *gFields[i].c, gFields[i].name, gFields[i].ft); 277 if (*gFields[i].id == NULL) { 278 ALOGE("Can't find field: %s\n", gFields[i].name); 279 return -1; 280 } 281 } 282 283 for (int i = 0; i < NELEM(gMethods); ++i) { 284 *gMethods[i].id = env->GetMethodID( 285 *gMethods[i].c, gMethods[i].name, gMethods[i].mt); 286 if (*gMethods[i].id == NULL) { 287 ALOGE("Can't find method: %s\n", gMethods[i].name); 288 return -1; 289 } 290 } 291 292 return AndroidRuntime::registerNativeMethods( 293 env, 294 "android/util/EventLog", 295 gRegisterMethods, NELEM(gRegisterMethods)); 296} 297 298}; // namespace android 299