libdaemonize: retry launch several times

Chainfire · Chainfire · commit 89360b46b017 · 2018-12-19T10:44:51.000+01:00
On some devices in the early boot stages, execv will fail with EACCESS,
cause unknown. Retrying a couple of times seems to work. Most-seen
required attempts is three. That retrying works implies some sort of
race-condition, possibly SELinux related.
diff --git a/librootjavadaemon/CMakeLists.txt b/librootjavadaemon/CMakeLists.txt
@@ -1,3 +1,8 @@
 cmake_minimum_required(VERSION 3.4.1)
 
+
 add_executable( libdaemonize.so src/main/jni/daemonize.cpp )
+
+target_link_libraries( libdaemonize.so log )
+
+#target_compile_definitions( libdaemonize.so PRIVATE DEBUG )
diff --git a/librootjavadaemon/src/main/jni/daemonize.cpp b/librootjavadaemon/src/main/jni/daemonize.cpp
@@ -21,12 +21,33 @@
 #include <sys/wait.h>
 #include <fcntl.h>
 #include <stdio.h>
+#include <errno.h>
+#include <time.h>
+
+#ifdef DEBUG
+#include <android/log.h>
+#define LOG(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, "libdaemonize", __VA_ARGS__))
+#else
+#define LOG(...) ((void)0)
+#endif
+
+int sleep_ms(int ms) {
+    struct timespec ts;
+    ts.tv_sec = ms / 1000;
+    ts.tv_nsec = (ms % 1000) * 1000000;
+    if ((nanosleep(&ts,&ts) == -1) && (errno == EINTR)) {
+        int ret = (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
+        if (ret < 1) ret = 1;
+        return ret;
+    }
+    return 0;
+}
 
 /* Proper daemonization includes forking, closing the current STDIN/STDOUT/STDERR, creating a new
  * session, and forking again, making sure the twice-forked process becomes a child of init (1) */
 static int fork_daemon(int returnParent) {
     pid_t child = fork();
-    if (child == 0) {
+    if (child == 0) { // 1st child
         close(STDIN_FILENO);
         close(STDOUT_FILENO);
         close(STDERR_FILENO);
@@ -39,21 +60,46 @@ static int fork_daemon(int returnParent) {
 
         setsid();
         pid_t child2 = fork();
-        if (child2 <= 0) return 0; // success child or error on 2nd fork
-        exit(EXIT_SUCCESS);
+        if (child2 == 0) { // 2nd child
+            return 0; // return execution to caller
+        } else if (child2 > 0) { // 1st child, fork ok
+            exit(EXIT_SUCCESS);
+        } else if (child2 < 0) { // 1st child, fork fail
+            LOG("2nd fork failed (%d)", errno);
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    // parent
+    if (child < 0) {
+        LOG("1st fork failed (%d)", errno);
+        return -1; // error on 1st fork
+    }
+    while (true) {
+        int status;
+        pid_t waited = waitpid(child, &status, 0);
+        if ((waited == child) && WIFEXITED(status)) {
+            break;
+        }
     }
-    if (child < 0) return -1; // error on 1st fork
-    int status;
-    waitpid(child, &status, 0);
     if (!returnParent) exit(EXIT_SUCCESS);
     return 1; // success parent
 }
 
 extern "C" {
 
 int main(int argc, char *argv[], char** envp) {
-    if (fork_daemon(0) == 0) {
-        execv(argv[1], &argv[1]);
+    if (fork_daemon(0) == 0) { // daemonized child
+        // On some devices in the early boot stages, execv will fail with EACCESS, cause unknown.
+        // Retrying a couple of times seems to work. Most-seen required attempts is three.
+        // That retrying works implies some sort of race-condition, possibly SELinux related.
+        for (int i = 0; i < 16; i++) {
+            execv(argv[1], &argv[1]); // never returns if successful
+            LOG("[%d] execv(%s, ...)-->%d", i, argv[1], errno);
+            sleep_ms(16);
+        }
+        LOG("too many failures, aborting");
+        exit(EXIT_FAILURE);
     }
 }
 
