Add jniThrowErrnoException in libnativehelper

Since a few places in frameworks and libcore implement their own
functions to throw android.system.ErrnoException, these have been
integrated in libnativehelper to avoid duplication.

As part of the change a more generic ThrowException function is
provided that can take a variable number of arguments, rather
than just a description string. Due to this, the code now
constructs the exception object itself and then passes it to the
JNIEnv.

A helper macro is also added to convert the C string to jstring
for the description parameter, which is usually the first
parameter in the exception constructors.

Bug: 180958753
Fix: 180958753
Test: atest MtsLibnativehelperTestCases
Test: atest MtsLibnativehelperLazyTestCases
Change-Id: I4841cf9924a48eaf0b6965c203c9ebe851e443ff

Author: sbgoog

JNIHelp.c

@@ -16,6 +16,7 @@
 
 #include "include/nativehelper/JNIHelp.h"
 
+#include <stdarg.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -233,6 +234,84 @@ static void DiscardPendingException(JNIEnv* env, const char* className) {
     (*env)->DeleteLocalRef(env, exception);
 }
 
+static int ThrowException(JNIEnv* env, const char* className, const char* ctorSig, ...) {
+    int status = -1;
+    jclass exceptionClass = NULL;
+
+    va_list args;
+    va_start(args, ctorSig);
+
+    DiscardPendingException(env, className);
+
+    {
+        /* We want to clean up local references before returning from this function, so,
+         * regardless of return status, the end block must run. Have the work done in a
+         * nested block to avoid using any uninitialized variables in the end block. */
+        exceptionClass = (*env)->FindClass(env, className);
+        if (exceptionClass == NULL) {
+            ALOGE("Unable to find exception class %s", className);
+            /* an exception, most likely ClassNotFoundException, will now be pending */
+            goto end;
+        }
+
+        jmethodID init = (*env)->GetMethodID(env, exceptionClass, "<init>", ctorSig);
+        if(init == NULL) {
+            ALOGE("Failed to find constructor for '%s' '%s'", className, ctorSig);
+            goto end;
+        }
+
+        jobject instance = (*env)->NewObjectV(env, exceptionClass, init, args);
+        if (instance == NULL) {
+            ALOGE("Failed to construct '%s'", className);
+            goto end;
+        }
+
+        if ((*env)->Throw(env, (jthrowable)instance) != JNI_OK) {
+            ALOGE("Failed to throw '%s'", className);
+            /* an exception, most likely OOM, will now be pending */
+            goto end;
+        }
+
+        /* everything worked fine, just update status to success and clean up */
+        status = 0;
+    }
+
+end:
+    va_end(args);
+    if (exceptionClass != NULL) {
+        (*env)->DeleteLocalRef(env, exceptionClass);
+    }
+    return status;
+}
+
+static jstring CreateExceptionMsg(JNIEnv* env, const char* msg) {
+    jstring detailMessage = (*env)->NewStringUTF(env, msg);
+    if (detailMessage == NULL) {
+        /* Not really much we can do here. We're probably dead in the water,
+           but let's try to stumble on... */
+        (*env)->ExceptionClear(env);
+    }
+    return detailMessage;
+}
+
+/* Helper macro to deal with conversion of the exception message from a C string
+ * to jstring.
+ *
+ * This is useful because most exceptions have a message as the first parameter
+ * and delegating the conversion to all the callers of ThrowException results in
+ * code duplication. However, since we try to allow variable number of arguments
+ * for the exception constructor we'd either need to do the conversion inside
+ * the macro, or manipulate the va_list to replace the C string to a jstring.
+ * This seems like the cleaner solution.
+ */
+#define THROW_EXCEPTION_WITH_MESSAGE(env, className, ctorSig, msg, ...) ({                 \
+    jstring _detailMessage = CreateExceptionMsg(env, msg);                                 \
+    int _status = ThrowException(env, className, ctorSig, _detailMessage, ## __VA_ARGS__); \
+    if (_detailMessage != NULL) {                                                          \
+        (*env)->DeleteLocalRef(env, _detailMessage);                                       \
+    }                                                                                      \
+    _status; })
+
 //
 // JNIHelp external API
 //
@@ -277,24 +356,7 @@ void jniLogException(JNIEnv* env, int priority, const char* tag, jthrowable thro
 }
 
 int jniThrowException(JNIEnv* env, const char* className, const char* message) {
-    DiscardPendingException(env, className);
-
-    jclass exceptionClass = (*env)->FindClass(env, className);
-    if (exceptionClass == NULL) {
-        ALOGE("Unable to find exception class %s", className);
-        /* ClassNotFoundException now pending */
-        return -1;
-    }
-
-    int status = 0;
-    if ((*env)->ThrowNew(env, exceptionClass, message) != JNI_OK) {
-        ALOGE("Failed throwing '%s' '%s'", className, message);
-        /* an exception, most likely OOM, will now be pending */
-        status = -1;
-    }
-    (*env)->DeleteLocalRef(env, exceptionClass);
-
-    return status;
+    return THROW_EXCEPTION_WITH_MESSAGE(env, className, "(Ljava/lang/String;)V", message);
 }
 
 int jniThrowExceptionFmt(JNIEnv* env, const char* className, const char* fmt, va_list args) {
@@ -311,12 +373,17 @@ int jniThrowRuntimeException(JNIEnv* env, const char* msg) {
     return jniThrowException(env, "java/lang/RuntimeException", msg);
 }
 
-int jniThrowIOException(JNIEnv* env, int errnum) {
+int jniThrowIOException(JNIEnv* env, int errno_value) {
     char buffer[80];
-    const char* message = platformStrError(errnum, buffer, sizeof(buffer));
+    const char* message = platformStrError(errno_value, buffer, sizeof(buffer));
     return jniThrowException(env, "java/io/IOException", message);
 }
 
+int jniThrowErrnoException(JNIEnv* env, const char* functionName, int errno_value) {
+    return THROW_EXCEPTION_WITH_MESSAGE(env, "android/system/ErrnoException",
+            "(Ljava/lang/String;I)V", functionName, errno_value);
+}
+
 jstring jniCreateString(JNIEnv* env, const jchar* unicodeChars, jsize len) {
     return (*env)->NewString(env, unicodeChars, len);
 }

include/nativehelper/JNIHelp.h

@@ -88,9 +88,14 @@ int jniThrowNullPointerException(C_JNIEnv* env, const char* msg);
 int jniThrowRuntimeException(C_JNIEnv* env, const char* msg);
 
 /*
- * Throw a java.io.IOException, generating the message from errno.
+ * Throw a java.io.IOException, generating the message from the given errno value.
  */
-int jniThrowIOException(C_JNIEnv* env, int errnum);
+int jniThrowIOException(C_JNIEnv* env, int errno_value);
+
+/*
+ * Throw an android.system.ErrnoException, with the given function name and errno value.
+ */
+int jniThrowErrnoException(C_JNIEnv* env, const char* functionName, int errno_value);
 
 /*
  * Returns a Java String object created from UTF-16 data either from jchar or,
@@ -143,6 +148,10 @@ inline int jniThrowIOException(JNIEnv* env, int errnum) {
     return jniThrowIOException(&env->functions, errnum);
 }
 
+inline int jniThrowErrnoException(JNIEnv* env, const char* functionName, int errnum) {
+    return jniThrowErrnoException(&env->functions, functionName, errnum);
+}
+
 inline jstring jniCreateString(JNIEnv* env, const jchar* unicodeChars, jsize len) {
     return jniCreateString(&env->functions, unicodeChars, len);
 }

libnativehelper.map.txt

@@ -17,6 +17,7 @@ LIBNATIVEHELPER_S { # introduced=S
     jniThrowNullPointerException; # apex
     jniThrowRuntimeException; # apex
     jniThrowIOException; # apex
+    jniThrowErrnoException; # apex
     jniCreateFileDescriptor; # apex
     jniGetFDFromFileDescriptor; # apex
     jniSetFileDescriptorOfFD; # apex

libnativehelper_lazy.c

@@ -51,6 +51,7 @@ enum MethodIndex {
     k_jniCreateString,
     k_jniLogException,
     k_jniRegisterNativeMethods,
+    k_jniThrowErrnoException,
     k_jniThrowException,
     k_jniThrowExceptionFmt,
     k_jniThrowIOException,
@@ -132,6 +133,7 @@ static void InitializeOnce() {
     BIND_SYMBOL(jniCreateString);
     BIND_SYMBOL(jniLogException);
     BIND_SYMBOL(jniRegisterNativeMethods);
+    BIND_SYMBOL(jniThrowErrnoException);
     BIND_SYMBOL(jniThrowException);
     BIND_SYMBOL(jniThrowExceptionFmt);
     BIND_SYMBOL(jniThrowIOException);
@@ -266,6 +268,11 @@ int jniRegisterNativeMethods(JNIEnv* env,
     INVOKE_METHOD(jniRegisterNativeMethods, M, env, className, gMethods, numMethods);
 }
 
+int jniThrowErrnoException(JNIEnv* env, const char* functionName, int errnum) {
+    typedef int (*M)(JNIEnv*, const char*, int);
+    INVOKE_METHOD(jniThrowErrnoException, M, env, functionName, errnum);
+}
+
 int jniThrowException(JNIEnv* env, const char* className, const char* msg) {
     typedef int (*M)(JNIEnv*, const char*, const char*);
     INVOKE_METHOD(jniThrowException, M, env, className, msg);
@@ -359,4 +366,4 @@ bool JniInvocationInit(struct JniInvocationImpl* instance, const char* library)
 const char* JniInvocationGetLibrary(const char* library, char* buffer) {
     typedef const char* (*M)(const char*, char*);
     INVOKE_METHOD(JniInvocationGetLibrary, M, library, buffer);
-}
+}

tests/libnativehelper_lazy_test.cpp

@@ -47,6 +47,7 @@ TEST_F(LibnativehelperLazyTest, NoLibnativehelperIsForJNIHelp) {
   EXPECT_DEATH(jniThrowIOException(env, 1), kLoadFailed);
   EXPECT_DEATH(jniThrowNullPointerException(env, "msg"), kLoadFailed);
   EXPECT_DEATH(jniThrowRuntimeException(env, "msg"), kLoadFailed);
+  EXPECT_DEATH(jniThrowErrnoException(env, "fn", 1), kLoadFailed);
 }
 
 TEST_F(LibnativehelperLazyTest, NoLibnativehelperIsForJNIPlatformHelp) {

tests_mts/jni/jni_helper_jni.cpp

@@ -80,6 +80,11 @@ static void throwIOException(JNIEnv* env, jclass /*clazz*/, jint cause) {
     jniThrowIOException(env, cause);
 }
 
+static void throwErrnoException(JNIEnv* env, jclass /*clazz*/, jstring functionName, jint cause) {
+    ScopedUtfChars m(env, functionName);
+    jniThrowErrnoException(env, m.c_str(), cause);
+}
+
 static void logException(JNIEnv* env, jclass /*clazz*/, jthrowable throwable) {
     jniLogException(env, ANDROID_LOG_VERBOSE, __FILE__, throwable);
 }
@@ -197,6 +202,9 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
         MAKE_JNI_NATIVE_METHOD("throwIOException",
                                "(I)V",
                                throwIOException),
+        MAKE_JNI_NATIVE_METHOD("throwErrnoException",
+                               "(Ljava/lang/String;I)V",
+                               throwErrnoException),
         MAKE_JNI_NATIVE_METHOD("logException",
                                "(Ljava/lang/Throwable;)V",
                                logException),

tests_mts/src/com/android/art/libnativehelper/JniHelpTest.java

@@ -29,6 +29,8 @@
 import java.nio.FloatBuffer;
 import java.nio.DoubleBuffer;
 
+import android.system.ErrnoException;
+
 import org.junit.Assert;
 
 public class JniHelpTest extends AndroidTestCase {
@@ -39,6 +41,7 @@ private static native void throwExceptionWithIntFormat(String className,
     private static native void throwNullPointerException(String message);
     private static native void throwRuntimeException(String message);
     private static native void throwIOException(int cause) throws IOException;
+    private static native void throwErrnoException(String fileName, int cause) throws ErrnoException;
     private static native void logException(Throwable throwable);
 
     private static native FileDescriptor fileDescriptorCreate(int unixFd);
@@ -118,6 +121,20 @@ public void testIOException() {
         assertFalse(s1.equals(s2));
     }
 
+    public void testErrnoException() {
+        final String functionName = "execve";
+        final int err = 42;
+        try {
+            throwErrnoException(functionName, err);
+            fail("Unreachable");
+        } catch (ErrnoException e) {
+            // The message contains the function name as well as the string for the errno, just only
+            // check the first part of the message
+            assertTrue("Function name", e.getMessage().startsWith(functionName));
+            assertEquals(err, e.errno);
+        }
+    }
+
     public void testLogException() {
         try {
             throw new RuntimeException("Exception for logging test");