Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3a1b4e49 authored by Jared Duke's avatar Jared Duke
Browse files

Fully deprecate Process.setCanSelfBackground 

Make this method a no-op, preserved only to avoid app compat breakage.
There's no evidence this has been used in recent history in practice,
and by default its behavior is behind a disabled-by-default #define.
All it does is add slight JNI overhead for certain common code paths.

Bug: 441066069
Flag: EXEMPT REFACTOR
Test: presubmit
Change-Id: I37d09edd33e16d5443bc35373a05b17908a62fdc
parent ce97e4ad

core/java/android/os/Process.java

+7 −11
Original line number Diff line number Diff line
@@ -1134,21 +1134,21 @@ public class Process { 
            throws IllegalArgumentException, SecurityException;



    /**

     * No-op stub, kept only for app compat purposes.

     *

     * Historical description:

     * Call with 'false' to cause future calls to {@link #setThreadPriority(int)} to

     * throw an exception if passed a background-level thread priority.  This is only

     * effective if the JNI layer is built with GUARD_THREAD_PRIORITY defined to 1.

     * This does not prevent a thread from backgrounding itself via other means, such

     * as a call to Thread.setPriority() or a native setpriority() call.

     *

     * @deprecated This method does nothing.  Do not use.

     *

     * @hide

     */

    @RavenwoodRedirect

    @FastNative

    public static final native void setCanSelfBackground(boolean backgroundOk);



    @RavenwoodRedirect

    @CriticalNative

    private static native boolean getCanSelfBackground();

    @Deprecated

    public static final void setCanSelfBackground(boolean backgroundOk) {}



    /**

     * Sets the scheduling group for a thread.
@@ -1312,10 +1312,6 @@ public class Process { 
            setThreadPriority(myTid(), priority);

            return;

        }

        if (priority >= THREAD_PRIORITY_BACKGROUND && !getCanSelfBackground()) {

            throw new IllegalArgumentException(

                "Priority " + priority + " blocked by setCanSelfBackground()");

        }

        boolean succ = VMRuntime.getRuntime().setThreadNiceness(Thread.currentThread(), priority);

        // VMRuntime.setThreadNiceness() just returns false for out-of-range priority.

        if (!succ) {

core/java/android/os/Process_ravenwood.java

+4 −26
Original line number Diff line number Diff line
@@ -15,11 +15,10 @@ 
 */

package android.os;



import android.util.Pair;



public class Process_ravenwood {



    private static volatile ThreadLocal<Pair<Integer, Boolean>> sThreadPriority;

    private static volatile ThreadLocal<Integer> sThreadPriority;



    static {

        reset();
@@ -27,8 +26,7 @@ public class Process_ravenwood { 


    public static void reset() {

        // Reset the thread local variable

        sThreadPriority = ThreadLocal.withInitial(

                () -> Pair.create(Process.THREAD_PRIORITY_DEFAULT, true));

        sThreadPriority = ThreadLocal.withInitial(() -> Process.THREAD_PRIORITY_DEFAULT);

    }



    /**
@@ -48,30 +46,10 @@ public class Process_ravenwood { 
     * The real implementation uses an Android-specific API.

     */

    public static void setThreadPriority(int priority) {

        boolean backgroundOk = getCanSelfBackground();

        if (priority >= Process.THREAD_PRIORITY_BACKGROUND && !backgroundOk) {

            throw new IllegalArgumentException(

                    "Priority " + priority + " blocked by setCanSelfBackground()");

        }

        if (priority < -20 || priority > 19) {

            throw new IllegalArgumentException("Priority/niceness " + priority + " is invalid");

        }

        sThreadPriority.set(Pair.create(priority, backgroundOk));

    }



    /**

     * Called by {@link Process#setCanSelfBackground(boolean)}

     */

    public static void setCanSelfBackground(boolean backgroundOk) {

        int priority = sThreadPriority.get().first;

        sThreadPriority.set(Pair.create(priority, backgroundOk));

    }



    /**

     * Called by {@link Process#getCanSelfBackground(int)}

     */

    public static boolean getCanSelfBackground() {

        return sThreadPriority.get().second;

        sThreadPriority.set(priority);

    }



    /**
@@ -79,7 +57,7 @@ public class Process_ravenwood { 
     */

    public static int getThreadPriority(int tid) {

        if (Process.myTid() == tid) {

            return sThreadPriority.get().first;

            return sThreadPriority.get();

        } else {

            throw new UnsupportedOperationException(

                    "Cross-thread priority management not yet available in Ravenwood");

core/java/com/android/server/ServiceThread.java

+0 −3
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ package com.android.server; 
import android.os.Handler;

import android.os.HandlerThread;

import android.os.Looper;

import android.os.Process;

import android.os.StrictMode;



/**
@@ -40,8 +39,6 @@ public class ServiceThread extends HandlerThread { 


    @Override

    public void run() {

        Process.setCanSelfBackground(false);



        if (!mAllowIo) {

            StrictMode.initThreadDefaults(null);

        }

core/jni/android_util_Process.cpp

+0 −53
Original line number Diff line number Diff line
@@ -64,8 +64,6 @@ 
#include <time.h>

#include <unistd.h>



#define GUARD_THREAD_PRIORITY 0



using namespace android;



static constexpr bool kDebugPolicy = false;
@@ -83,11 +81,6 @@ static constexpr size_t kProcReadStackBufferSize = 1024; 
// this size and retry until the whole file fits.

static constexpr size_t kProcReadMinHeapBufferSize = 4096;



#if GUARD_THREAD_PRIORITY

Mutex gKeyCreateMutex;

static pthread_key_t gBgKey = -1;

#endif



// For both of these, err should be in the errno range (positive), not a status_t (negative)

static void signalExceptionForError(JNIEnv* env, int err, int tid) {

    switch (err) {
@@ -534,33 +527,6 @@ jlongArray android_os_Process_getSchedAffinity(JNIEnv* env, jobject clazz, jint 
    return masks;

}



static void android_os_Process_setCanSelfBackground(JNIEnv* env, jobject clazz, jboolean bgOk) {

    // Establishes the calling thread as illegal to put into the background.

    // Typically used only for the system process's main looper.

#if GUARD_THREAD_PRIORITY

    ALOGV("Process.setCanSelfBackground(%d) : tid=%d", bgOk, gettid());

    {

        Mutex::Autolock _l(gKeyCreateMutex); // Acquired nowhere else.

        if (gBgKey == -1) {

            pthread_key_create(&gBgKey, NULL);

        }

    }



    // inverted:  not-okay, we set a sentinel value

    pthread_setspecific(gBgKey, (void*)(bgOk ? 0 : 0xbaad));

#endif

}



static jboolean android_os_Process_getCanSelfBackground(CRITICAL_JNI_PARAMS) {

#if GUARD_THREAD_PRIORITY

    void* bgOk = pthread_getspecific(gBgKey);

    if (bgOk == ((void*)0xbaad)) {

        return false;

    }

#endif

    return true;

}



jint android_os_Process_getThreadScheduler(JNIEnv* env, jclass clazz,

                                              jint tid)

{
@@ -595,21 +561,6 @@ void android_os_Process_setThreadScheduler(JNIEnv* env, jclass clazz, 
}



void android_os_Process_setThreadPriorityNative(JNIEnv* env, jobject clazz, jint pid, jint pri) {

#if GUARD_THREAD_PRIORITY

    // if we're putting the current thread into the background, check the TLS

    // to make sure this thread isn't guarded.  If it is, raise an exception.

    if (pri >= ANDROID_PRIORITY_BACKGROUND) {

        if (pid == gettid()) {

            void* bgOk = pthread_getspecific(gBgKey);

            if (bgOk == ((void*)0xbaad)) {

                ALOGE("Thread marked fg-only put self in background!");

                jniThrowException(env, "java/lang/SecurityException", "May not put this thread into background");

                return;

            }

        }

    }

#endif



    int rc = androidSetThreadPriority(pid, pri);

    if (rc != 0) {

        if (rc == INVALID_OPERATION) {
@@ -1413,10 +1364,6 @@ static const JNINativeMethod methods[] = { 
        {"setThreadPriorityNative", "(II)V", (void*)android_os_Process_setThreadPriorityNative},

        // @FastNative

        {"getThreadPriority", "(I)I", (void*)android_os_Process_getThreadPriority},

        // @FastNative

        {"setCanSelfBackground", "(Z)V", (void*)android_os_Process_setCanSelfBackground},

        // @CriticalNative

        {"getCanSelfBackground", "()Z", (void*)android_os_Process_getCanSelfBackground},

        {"getThreadScheduler", "(I)I", (void*)android_os_Process_getThreadScheduler},

        {"setThreadGroup", "(II)V", (void*)android_os_Process_setThreadGroup},

        {"setThreadGroupAndCpuset", "(II)V", (void*)android_os_Process_setThreadGroupAndCpuset},

ravenwood/tests/runtime-test/test/com/android/ravenwoodtest/runtimetest/ProcessTest.java

+2 −3
Original line number Diff line number Diff line
@@ -45,10 +45,9 @@ public class ProcessTest { 
        assertEquals(THREAD_PRIORITY_DEFAULT, Process.getThreadPriority(Process.myTid()));

        Process.setThreadPriority(THREAD_PRIORITY_FOREGROUND);

        assertEquals(THREAD_PRIORITY_FOREGROUND, Process.getThreadPriority(Process.myTid()));

        Process.setCanSelfBackground(false);

        Process.setThreadPriority(THREAD_PRIORITY_DEFAULT);

        assertEquals(THREAD_PRIORITY_DEFAULT, Process.getThreadPriority(Process.myTid()));

        assertThrows(IllegalArgumentException.class,

                () -> Process.setThreadPriority(THREAD_PRIORITY_BACKGROUND));

        Process.setThreadPriority(THREAD_PRIORITY_BACKGROUND);

        assertEquals(THREAD_PRIORITY_BACKGROUND, Process.getThreadPriority(Process.myTid()));

    }

}