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