core/jni/android_util_EventLog.cpp

   1 /*
   2  * Copyright (C) 2007 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 // The size of the tag number comes out of the payload size.
  25 #define MAX_EVENT_PAYLOAD (LOGGER_ENTRY_MAX_PAYLOAD - sizeof(int32_t))
  26
  27 namespace android {
  28
  29 static jclass gCollectionClass;
  30 static jmethodID gCollectionAddID;
  31
  32 static jclass gEventClass;
  33 static jmethodID gEventInitID;
  34
  35 static jclass gIntegerClass;
  36 static jfieldID gIntegerValueID;
  37
  38 static jclass gLongClass;
  39 static jfieldID gLongValueID;
  40
  41 static jclass gStringClass;
  42
  43 /*
  44  * In class android.util.EventLog:
  45  *  static native int writeEvent(int tag, int value)
  46  */
  47 static jint android_util_EventLog_writeEvent_Integer(JNIEnv* env, jobject clazz,
  48                                                      jint tag, jint value)
  49 {
  50     return android_btWriteLog(tag, EVENT_TYPE_INT, &value, sizeof(value));
  51 }
  52
  53 /*
  54  * In class android.util.EventLog:
  55  *  static native int writeEvent(long tag, long value)
  56  */
  57 static jint android_util_EventLog_writeEvent_Long(JNIEnv* env, jobject clazz,
  58                                                   jint tag, jlong value)
  59 {
  60     return android_btWriteLog(tag, EVENT_TYPE_LONG, &value, sizeof(value));
  61 }
  62
  63 /*
  64  * In class android.util.EventLog:
  65  *  static native int writeEvent(int tag, String value)
  66  */
  67 static jint android_util_EventLog_writeEvent_String(JNIEnv* env, jobject clazz,
  68                                                     jint tag, jstring value) {
  69     uint8_t buf[MAX_EVENT_PAYLOAD];
  70
  71     // Don't throw NPE -- I feel like it's sort of mean for a logging function
  72     // to be all crashy if you pass in NULL -- but make the NULL value explicit.
  73     const char *str = value != NULL ? env->GetStringUTFChars(value, NULL) : "NULL";
  74     uint32_t len = strlen(str);
  75     size_t max = sizeof(buf) - sizeof(len) - 2;  // Type byte, final newline
  76     if (len > max) len = max;
  77
  78     buf[0] = EVENT_TYPE_STRING;
  79     memcpy(&buf[1], &len, sizeof(len));
  80     memcpy(&buf[1 + sizeof(len)], str, len);
  81     buf[1 + sizeof(len) + len] = '\n';
  82
  83     if (value != NULL) env->ReleaseStringUTFChars(value, str);
  84     return android_bWriteLog(tag, buf, 2 + sizeof(len) + len);
  85 }
  86
  87 /*
  88  * In class android.util.EventLog:
  89  *  static native int writeEvent(long tag, Object... value)
  90  */
  91 static jint android_util_EventLog_writeEvent_Array(JNIEnv* env, jobject clazz,
  92                                                    jint tag, jobjectArray value) {
  93     if (value == NULL) {
  94         return android_util_EventLog_writeEvent_String(env, clazz, tag, NULL);
  95     }
  96
  97     uint8_t buf[MAX_EVENT_PAYLOAD];
  98     const size_t max = sizeof(buf) - 1;  // leave room for final newline
  99     size_t pos = 2;  // Save room for type tag & array count
 100
 101     jsize copied = 0, num = env->GetArrayLength(value);
 102     for (; copied < num && copied < 255; ++copied) {
 103         jobject item = env->GetObjectArrayElement(value, copied);
 104         if (item == NULL || env->IsInstanceOf(item, gStringClass)) {
 105             if (pos + 1 + sizeof(jint) > max) break;
 106             const char *str = item != NULL ? env->GetStringUTFChars((jstring) item, NULL) : "NULL";
 107             jint len = strlen(str);
 108             if (pos + 1 + sizeof(len) + len > max) len = max - pos - 1 - sizeof(len);
 109             buf[pos++] = EVENT_TYPE_STRING;
 110             memcpy(&buf[pos], &len, sizeof(len));
 111             memcpy(&buf[pos + sizeof(len)], str, len);
 112             pos += sizeof(len) + len;
 113             if (item != NULL) env->ReleaseStringUTFChars((jstring) item, str);
 114         } else if (env->IsInstanceOf(item, gIntegerClass)) {
 115             jint intVal = env->GetIntField(item, gIntegerValueID);
 116             if (pos + 1 + sizeof(intVal) > max) break;
 117             buf[pos++] = EVENT_TYPE_INT;
 118             memcpy(&buf[pos], &intVal, sizeof(intVal));
 119             pos += sizeof(intVal);
 120         } else if (env->IsInstanceOf(item, gLongClass)) {
 121             jlong longVal = env->GetLongField(item, gLongValueID);
 122             if (pos + 1 + sizeof(longVal) > max) break;
 123             buf[pos++] = EVENT_TYPE_LONG;
 124             memcpy(&buf[pos], &longVal, sizeof(longVal));
 125             pos += sizeof(longVal);
 126         } else {
 127             jniThrowException(env,
 128                     "java/lang/IllegalArgumentException",
 129                     "Invalid payload item type");
 130             return -1;
 131         }
 132         env->DeleteLocalRef(item);
 133     }
 134
 135     buf[0] = EVENT_TYPE_LIST;
 136     buf[1] = copied;
 137     buf[pos++] = '\n';
 138     return android_bWriteLog(tag, buf, pos);
 139 }
 140
 141 /*
 142  * In class android.util.EventLog:
 143  *  static native void readEvents(int[] tags, Collection<Event> output)
 144  *
 145  *  Reads events from the event log, typically /dev/log/events
 146  */
 147 static void android_util_EventLog_readEvents(JNIEnv* env, jobject clazz,
 148                                              jintArray tags,
 149                                              jobject out) {
 150     if (tags == NULL || out == NULL) {
 151         jniThrowNullPointerException(env, NULL);
 152         return;
 153     }
 154
 155     int fd = open("/dev/" LOGGER_LOG_EVENTS, O_RDONLY | O_NONBLOCK);
 156     if (fd < 0) {
 157         jniThrowIOException(env, errno);
 158         return;
 159     }
 160
 161     jsize tagLength = env->GetArrayLength(tags);
 162     jint *tagValues = env->GetIntArrayElements(tags, NULL);
 163
 164     uint8_t buf[LOGGER_ENTRY_MAX_LEN];
 165     struct timeval timeout = {0, 0};
 166     fd_set readset;
 167     FD_ZERO(&readset);
 168
 169     for (;;) {
 170         // Use a short select() to try to avoid problems hanging on read().
 171         // This means we block for 5ms at the end of the log -- oh well.
 172         timeout.tv_usec = 5000;
 173         FD_SET(fd, &readset);
 174         int r = select(fd + 1, &readset, NULL, NULL, &timeout);
 175         if (r == 0) {
 176             break;  // no more events
 177         } else if (r < 0 && errno == EINTR) {
 178             continue;  // interrupted by signal, try again
 179         } else if (r < 0) {
 180             jniThrowIOException(env, errno);  // Will throw on return
 181             break;
 182         }
 183
 184         int len = read(fd, buf, sizeof(buf));
 185         if (len == 0 || (len < 0 && errno == EAGAIN)) {
 186             break;  // no more events
 187         } else if (len < 0 && errno == EINTR) {
 188             continue;  // interrupted by signal, try again
 189         } else if (len < 0) {
 190             jniThrowIOException(env, errno);  // Will throw on return
 191             break;
 192         } else if ((size_t) len < sizeof(logger_entry) + sizeof(int32_t)) {
 193             jniThrowException(env, "java/io/IOException", "Event too short");
 194             break;
 195         }
 196
 197         logger_entry* entry = (logger_entry*) buf;
 198         int32_t tag = * (int32_t*) (buf + sizeof(*entry));
 199
 200         int found = 0;
 201         for (int i = 0; !found && i < tagLength; ++i) {
 202             found = (tag == tagValues[i]);
 203         }
 204
 205         if (found) {
 206             jsize len = sizeof(*entry) + entry->len;
 207             jbyteArray array = env->NewByteArray(len);
 208             if (array == NULL) break;
 209
 210             jbyte *bytes = env->GetByteArrayElements(array, NULL);
 211             memcpy(bytes, buf, len);
 212             env->ReleaseByteArrayElements(array, bytes, 0);
 213
 214             jobject event = env->NewObject(gEventClass, gEventInitID, array);
 215             if (event == NULL) break;
 216
 217             env->CallBooleanMethod(out, gCollectionAddID, event);
 218             env->DeleteLocalRef(event);
 219             env->DeleteLocalRef(array);
 220         }
 221     }
 222
 223     close(fd);
 224     env->ReleaseIntArrayElements(tags, tagValues, 0);
 225 }
 226
 227 /*
 228  * JNI registration.
 229  */
 230 static JNINativeMethod gRegisterMethods[] = {
 231     /* name, signature, funcPtr */
 232     { "writeEvent", "(II)I", (void*) android_util_EventLog_writeEvent_Integer },
 233     { "writeEvent", "(IJ)I", (void*) android_util_EventLog_writeEvent_Long },
 234     { "writeEvent",
 235       "(ILjava/lang/String;)I",
 236       (void*) android_util_EventLog_writeEvent_String
 237     },
 238     { "writeEvent",
 239       "(I[Ljava/lang/Object;)I",
 240       (void*) android_util_EventLog_writeEvent_Array
 241     },
 242     { "readEvents",
 243       "([ILjava/util/Collection;)V",
 244       (void*) android_util_EventLog_readEvents
 245     },
 246 };
 247
 248 static struct { const char *name; jclass *clazz; } gClasses[] = {
 249     { "android/util/EventLog$Event", &gEventClass },
 250     { "java/lang/Integer", &gIntegerClass },
 251     { "java/lang/Long", &gLongClass },
 252     { "java/lang/String", &gStringClass },
 253     { "java/util/Collection", &gCollectionClass },
 254 };
 255
 256 static struct { jclass *c; const char *name, *ft; jfieldID *id; } gFields[] = {
 257     { &gIntegerClass, "value", "I", &gIntegerValueID },
 258     { &gLongClass, "value", "J", &gLongValueID },
 259 };
 260
 261 static struct { jclass *c; const char *name, *mt; jmethodID *id; } gMethods[] = {
 262     { &gEventClass, "<init>", "([B)V", &gEventInitID },
 263     { &gCollectionClass, "add", "(Ljava/lang/Object;)Z", &gCollectionAddID },
 264 };
 265
 266 int register_android_util_EventLog(JNIEnv* env) {
 267     for (int i = 0; i < NELEM(gClasses); ++i) {
 268         jclass clazz = env->FindClass(gClasses[i].name);
 269         if (clazz == NULL) {
 270             ALOGE("Can't find class: %s\n", gClasses[i].name);
 271             return -1;
 272         }
 273         *gClasses[i].clazz = (jclass) env->NewGlobalRef(clazz);
 274     }
 275
 276     for (int i = 0; i < NELEM(gFields); ++i) {
 277         *gFields[i].id = env->GetFieldID(
 278                 *gFields[i].c, gFields[i].name, gFields[i].ft);
 279         if (*gFields[i].id == NULL) {
 280             ALOGE("Can't find field: %s\n", gFields[i].name);
 281             return -1;
 282         }
 283     }
 284
 285     for (int i = 0; i < NELEM(gMethods); ++i) {
 286         *gMethods[i].id = env->GetMethodID(
 287                 *gMethods[i].c, gMethods[i].name, gMethods[i].mt);
 288         if (*gMethods[i].id == NULL) {
 289             ALOGE("Can't find method: %s\n", gMethods[i].name);
 290             return -1;
 291         }
 292     }
 293
 294     return AndroidRuntime::registerNativeMethods(
 295             env,
 296             "android/util/EventLog",
 297             gRegisterMethods, NELEM(gRegisterMethods));
 298 }
 299
 300 }; // namespace android