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
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 gStringClass;
44
45 /*
46 * In class android.util.EventLog:
47 * static native int writeEvent(int tag, int value)
48 */
android_util_EventLog_writeEvent_Integer(JNIEnv * env UNUSED,jobject clazz UNUSED,jint tag,jint value)49 static 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 */
android_util_EventLog_writeEvent_Long(JNIEnv * env UNUSED,jobject clazz UNUSED,jint tag,jlong value)60 static 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 */
android_util_EventLog_writeEvent_String(JNIEnv * env,jobject clazz UNUSED,jint tag,jstring value)71 static 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 */
android_util_EventLog_writeEvent_Array(JNIEnv * env,jobject clazz,jint tag,jobjectArray value)96 static 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 */
android_util_EventLog_readEvents(JNIEnv * env,jobject clazz UNUSED,jintArray tags,jobject out)152 static 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 (ret == -EINTR) {
181 continue;
182 }
183 if (ret == -EINVAL) {
184 jniThrowException(env, "java/io/IOException", "Event too short");
185 } else if (ret != -EAGAIN) {
186 jniThrowIOException(env, -ret); // 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 */
228 static 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
246 static 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
254 static struct { jclass *c; const char *name, *ft; jfieldID *id; } gFields[] = {
255 { &gIntegerClass, "value", "I", &gIntegerValueID },
256 { &gLongClass, "value", "J", &gLongValueID },
257 };
258
259 static 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
register_android_util_EventLog(JNIEnv * env)264 int 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