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