tools/lock_agent/java/com/android/lock_checker/LockHook.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.lock_checker;

 import android.app.ActivityThread;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
 import android.os.Message;
 import android.os.Process;
 import android.util.Log;
 import android.util.LogWriter;

 import com.android.internal.os.RuntimeInit;
 import com.android.internal.os.SomeArgs;
 import com.android.internal.util.StatLogger;

 import dalvik.system.AnnotatedStackTraceElement;

 import libcore.util.HexEncoding;

 import java.io.PrintWriter;
 import java.nio.charset.Charset;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Map;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicInteger;

 /**
  * Entry class for lock inversion infrastructure. The agent will inject calls to preLock
  * and postLock, and the hook will call the checker, and store violations.
  */
 public class LockHook {
     private static final String TAG = "LockHook";

     private static final Charset sFilenameCharset = Charset.forName("UTF-8");

     private static final HandlerThread sHandlerThread;
     private static final WtfHandler sHandler;

     private static final AtomicInteger sTotalObtainCount = new AtomicInteger();
     private static final AtomicInteger sTotalReleaseCount = new AtomicInteger();
     private static final AtomicInteger sDeepestNest = new AtomicInteger();

     /**
      * Whether to do the lock check on this thread.
      */
     private static final ThreadLocal<Boolean> sDoCheck = ThreadLocal.withInitial(() -> true);

     interface Stats {
         int ON_THREAD = 0;
     }

     static final StatLogger sStats = new StatLogger(new String[] { "on-thread", });

     private static final ConcurrentLinkedQueue<Violation> sViolations =
             new ConcurrentLinkedQueue<>();
     private static final int MAX_VIOLATIONS = 50;

     private static final LockChecker[] sCheckers;

     private static boolean sNativeHandling = false;
     private static boolean sSimulateCrash = false;

     static {
         sHandlerThread = new HandlerThread("LockHook:wtf", Process.THREAD_PRIORITY_BACKGROUND);
         sHandlerThread.start();
         sHandler = new WtfHandler(sHandlerThread.getLooper());

         sCheckers = new LockChecker[] { new OnThreadLockChecker() };

         sNativeHandling = getNativeHandlingConfig();
         sSimulateCrash = getSimulateCrashConfig();
     }

     private static native boolean getNativeHandlingConfig();
     private static native boolean getSimulateCrashConfig();

     static <T> boolean shouldDumpStacktrace(StacktraceHasher hasher, Map<String, T> dumpedSet,
             T val, AnnotatedStackTraceElement[] st, int from, int to) {
         final String stacktraceHash = hasher.stacktraceHash(st, from, to);
         if (dumpedSet.containsKey(stacktraceHash)) {
             return false;
         }
         dumpedSet.put(stacktraceHash, val);
         return true;
     }

     static void updateDeepestNest(int nest) {
         for (;;) {
             final int knownDeepest = sDeepestNest.get();
             if (knownDeepest >= nest) {
                 return;
             }
             if (sDeepestNest.compareAndSet(knownDeepest, nest)) {
                 return;
             }
         }
     }

     static void wtf(Violation v) {
         sHandler.wtf(v);
     }

     static void doCheckOnThisThread(boolean check) {
         sDoCheck.set(check);
     }

     /**
      * This method is called when a lock is about to be held. (Except if it's a
      * synchronized, the lock is already held.)
      */
     public static void preLock(Object lock) {
         if (Thread.currentThread() != sHandlerThread && sDoCheck.get()) {
             sDoCheck.set(false);
             try {
                 sTotalObtainCount.incrementAndGet();
                 for (LockChecker checker : sCheckers) {
                     checker.pre(lock);
                 }
             } finally {
                 sDoCheck.set(true);
             }
         }
     }

     /**
      * This method is called when a lock is about to be released.
      */
     public static void postLock(Object lock) {
         if (Thread.currentThread() != sHandlerThread && sDoCheck.get()) {
             sDoCheck.set(false);
             try {
                 sTotalReleaseCount.incrementAndGet();
                 for (LockChecker checker : sCheckers) {
                     checker.post(lock);
                 }
             } finally {
                 sDoCheck.set(true);
             }
         }
     }

     private static class WtfHandler extends Handler {
         private static final int MSG_WTF = 1;

         WtfHandler(Looper looper) {
             super(looper);
         }

         public void wtf(Violation v) {
             sDoCheck.set(false);
             SomeArgs args = SomeArgs.obtain();
             args.arg1 = v;
             obtainMessage(MSG_WTF, args).sendToTarget();
             sDoCheck.set(true);
         }

         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_WTF:
                     SomeArgs args = (SomeArgs) msg.obj;
                     handleViolation((Violation) args.arg1);
                     args.recycle();
                     break;
             }
         }
     }

     private static void handleViolation(Violation v) {
         String msg = v.toString();
         Log.wtf(TAG, msg);
         if (sNativeHandling) {
             nWtf(msg);  // Also send to native.
         }
         if (sSimulateCrash) {
             RuntimeInit.logUncaught("LockAgent",
                     ActivityThread.isSystem() ? "system_server"
                             : ActivityThread.currentProcessName(),
                     Process.myPid(), v.getException());
         }
     }

     private static native void nWtf(String msg);

     /**
      * Generates a hash for a given stacktrace of a {@link Throwable}.
      */
     static class StacktraceHasher {
         private byte[] mLineNumberBuffer = new byte[4];
         private final MessageDigest mHash;

         StacktraceHasher() {
             try {
                 mHash = MessageDigest.getInstance("MD5");
             } catch (NoSuchAlgorithmException e) {
                 throw new RuntimeException(e);
             }
         }

         public String stacktraceHash(Throwable t) {
             mHash.reset();
             for (StackTraceElement e : t.getStackTrace()) {
                 hashStackTraceElement(e);
             }
             return HexEncoding.encodeToString(mHash.digest());
         }

         public String stacktraceHash(AnnotatedStackTraceElement[] annotatedStack, int from,
                 int to) {
             mHash.reset();
             for (int i = from; i <= to; i++) {
                 hashStackTraceElement(annotatedStack[i].getStackTraceElement());
             }
             return HexEncoding.encodeToString(mHash.digest());
         }

         private void hashStackTraceElement(StackTraceElement e) {
             if (e.getFileName() != null) {
                 mHash.update(sFilenameCharset.encode(e.getFileName()).array());
             } else {
                 if (e.getClassName() != null) {
                     mHash.update(sFilenameCharset.encode(e.getClassName()).array());
                 }
                 if (e.getMethodName() != null) {
                     mHash.update(sFilenameCharset.encode(e.getMethodName()).array());
                 }
             }

             final int line = e.getLineNumber();
             mLineNumberBuffer[0] = (byte) ((line >> 24) & 0xff);
             mLineNumberBuffer[1] = (byte) ((line >> 16) & 0xff);
             mLineNumberBuffer[2] = (byte) ((line >> 8) & 0xff);
             mLineNumberBuffer[3] = (byte) ((line >> 0) & 0xff);
             mHash.update(mLineNumberBuffer);
         }
     }

     static void addViolation(Violation v) {
         wtf(v);

         sViolations.offer(v);
         while (sViolations.size() > MAX_VIOLATIONS) {
             sViolations.poll();
         }
     }

     /**
      * Dump stats to the given PrintWriter.
      */
     public static void dump(PrintWriter pw, String indent) {
         final int oc = LockHook.sTotalObtainCount.get();
         final int rc = LockHook.sTotalReleaseCount.get();
         final int dn = LockHook.sDeepestNest.get();
         pw.print("Lock stats: oc=");
         pw.print(oc);
         pw.print(" rc=");
         pw.print(rc);
         pw.print(" dn=");
         pw.print(dn);
         pw.println();

         for (LockChecker checker : sCheckers) {
             pw.print(indent);
             pw.print("  ");
             checker.dump(pw);
             pw.println();
         }

         sStats.dump(pw, indent);

         pw.print(indent);
         pw.println("Violations:");
         for (Object v : sViolations) {
             pw.print(indent); // This won't really indent a multiline string,
                               // though.
             pw.println(v);
         }
     }

     /**
      * Dump stats to logcat.
      */
     public static void dump() {
         // Dump to logcat.
         PrintWriter out = new PrintWriter(new LogWriter(Log.WARN, TAG), true);
         dump(out, "");
         out.close();
     }

     interface LockChecker {
         void pre(Object lock);

         void post(Object lock);

         int getNumDetected();

         int getNumDetectedUnique();

         String getCheckerName();

         void dump(PrintWriter pw);
     }

     interface Violation {
         Throwable getException();
     }
 }
	/*
	* Copyright (C) 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.lock_checker;

	import android.app.ActivityThread;
	import android.os.Handler;
	import android.os.HandlerThread;
	import android.os.Looper;
	import android.os.Message;
	import android.os.Process;
	import android.util.Log;
	import android.util.LogWriter;

	import com.android.internal.os.RuntimeInit;
	import com.android.internal.os.SomeArgs;
	import com.android.internal.util.StatLogger;

	import dalvik.system.AnnotatedStackTraceElement;

	import libcore.util.HexEncoding;

	import java.io.PrintWriter;
	import java.nio.charset.Charset;
	import java.security.MessageDigest;
	import java.security.NoSuchAlgorithmException;
	import java.util.Map;
	import java.util.concurrent.ConcurrentLinkedQueue;
	import java.util.concurrent.atomic.AtomicInteger;

	/**
	* Entry class for lock inversion infrastructure. The agent will inject calls to preLock
	* and postLock, and the hook will call the checker, and store violations.
	*/
	public class LockHook {
	private static final String TAG = "LockHook";

	private static final Charset sFilenameCharset = Charset.forName("UTF-8");

	private static final HandlerThread sHandlerThread;
	private static final WtfHandler sHandler;

	private static final AtomicInteger sTotalObtainCount = new AtomicInteger();
	private static final AtomicInteger sTotalReleaseCount = new AtomicInteger();
	private static final AtomicInteger sDeepestNest = new AtomicInteger();

	/**
	* Whether to do the lock check on this thread.
	*/
	private static final ThreadLocal<Boolean> sDoCheck = ThreadLocal.withInitial(() -> true);

	interface Stats {
	int ON_THREAD = 0;
	}

	static final StatLogger sStats = new StatLogger(new String[] { "on-thread", });

	private static final ConcurrentLinkedQueue<Violation> sViolations =
	new ConcurrentLinkedQueue<>();
	private static final int MAX_VIOLATIONS = 50;

	private static final LockChecker[] sCheckers;

	private static boolean sNativeHandling = false;
	private static boolean sSimulateCrash = false;

	static {
	sHandlerThread = new HandlerThread("LockHook:wtf", Process.THREAD_PRIORITY_BACKGROUND);
	sHandlerThread.start();
	sHandler = new WtfHandler(sHandlerThread.getLooper());

	sCheckers = new LockChecker[] { new OnThreadLockChecker() };

	sNativeHandling = getNativeHandlingConfig();
	sSimulateCrash = getSimulateCrashConfig();
	}

	private static native boolean getNativeHandlingConfig();
	private static native boolean getSimulateCrashConfig();

	static <T> boolean shouldDumpStacktrace(StacktraceHasher hasher, Map<String, T> dumpedSet,
	T val, AnnotatedStackTraceElement[] st, int from, int to) {
	final String stacktraceHash = hasher.stacktraceHash(st, from, to);
	if (dumpedSet.containsKey(stacktraceHash)) {
	return false;
	}
	dumpedSet.put(stacktraceHash, val);
	return true;
	}

	static void updateDeepestNest(int nest) {
	for (;;) {
	final int knownDeepest = sDeepestNest.get();
	if (knownDeepest >= nest) {
	return;
	}
	if (sDeepestNest.compareAndSet(knownDeepest, nest)) {
	return;
	}
	}
	}

	static void wtf(Violation v) {
	sHandler.wtf(v);
	}

	static void doCheckOnThisThread(boolean check) {
	sDoCheck.set(check);
	}

	/**
	* This method is called when a lock is about to be held. (Except if it's a
	* synchronized, the lock is already held.)
	*/
	public static void preLock(Object lock) {
	if (Thread.currentThread() != sHandlerThread && sDoCheck.get()) {
	sDoCheck.set(false);
	try {
	sTotalObtainCount.incrementAndGet();
	for (LockChecker checker : sCheckers) {
	checker.pre(lock);
	}
	} finally {
	sDoCheck.set(true);
	}
	}
	}

	/**
	* This method is called when a lock is about to be released.
	*/
	public static void postLock(Object lock) {
	if (Thread.currentThread() != sHandlerThread && sDoCheck.get()) {
	sDoCheck.set(false);
	try {
	sTotalReleaseCount.incrementAndGet();
	for (LockChecker checker : sCheckers) {
	checker.post(lock);
	}
	} finally {
	sDoCheck.set(true);
	}
	}
	}

	private static class WtfHandler extends Handler {
	private static final int MSG_WTF = 1;

	WtfHandler(Looper looper) {
	super(looper);
	}

	public void wtf(Violation v) {
	sDoCheck.set(false);
	SomeArgs args = SomeArgs.obtain();
	args.arg1 = v;
	obtainMessage(MSG_WTF, args).sendToTarget();
	sDoCheck.set(true);
	}

	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case MSG_WTF:
	SomeArgs args = (SomeArgs) msg.obj;
	handleViolation((Violation) args.arg1);
	args.recycle();
	break;
	}
	}
	}

	private static void handleViolation(Violation v) {
	String msg = v.toString();
	Log.wtf(TAG, msg);
	if (sNativeHandling) {
	nWtf(msg); // Also send to native.
	}
	if (sSimulateCrash) {
	RuntimeInit.logUncaught("LockAgent",
	ActivityThread.isSystem() ? "system_server"
	: ActivityThread.currentProcessName(),
	Process.myPid(), v.getException());
	}
	}

	private static native void nWtf(String msg);

	/**
	* Generates a hash for a given stacktrace of a {@link Throwable}.
	*/
	static class StacktraceHasher {
	private byte[] mLineNumberBuffer = new byte[4];
	private final MessageDigest mHash;

	StacktraceHasher() {
	try {
	mHash = MessageDigest.getInstance("MD5");
	} catch (NoSuchAlgorithmException e) {
	throw new RuntimeException(e);
	}
	}

	public String stacktraceHash(Throwable t) {
	mHash.reset();
	for (StackTraceElement e : t.getStackTrace()) {
	hashStackTraceElement(e);
	}
	return HexEncoding.encodeToString(mHash.digest());
	}

	public String stacktraceHash(AnnotatedStackTraceElement[] annotatedStack, int from,
	int to) {
	mHash.reset();
	for (int i = from; i <= to; i++) {
	hashStackTraceElement(annotatedStack[i].getStackTraceElement());
	}
	return HexEncoding.encodeToString(mHash.digest());
	}

	private void hashStackTraceElement(StackTraceElement e) {
	if (e.getFileName() != null) {
	mHash.update(sFilenameCharset.encode(e.getFileName()).array());
	} else {
	if (e.getClassName() != null) {
	mHash.update(sFilenameCharset.encode(e.getClassName()).array());
	}
	if (e.getMethodName() != null) {
	mHash.update(sFilenameCharset.encode(e.getMethodName()).array());
	}
	}

	final int line = e.getLineNumber();
	mLineNumberBuffer[0] = (byte) ((line >> 24) & 0xff);
	mLineNumberBuffer[1] = (byte) ((line >> 16) & 0xff);
	mLineNumberBuffer[2] = (byte) ((line >> 8) & 0xff);
	mLineNumberBuffer[3] = (byte) ((line >> 0) & 0xff);
	mHash.update(mLineNumberBuffer);
	}
	}

	static void addViolation(Violation v) {
	wtf(v);

	sViolations.offer(v);
	while (sViolations.size() > MAX_VIOLATIONS) {
	sViolations.poll();
	}
	}

	/**
	* Dump stats to the given PrintWriter.
	*/
	public static void dump(PrintWriter pw, String indent) {
	final int oc = LockHook.sTotalObtainCount.get();
	final int rc = LockHook.sTotalReleaseCount.get();
	final int dn = LockHook.sDeepestNest.get();
	pw.print("Lock stats: oc=");
	pw.print(oc);
	pw.print(" rc=");
	pw.print(rc);
	pw.print(" dn=");
	pw.print(dn);
	pw.println();

	for (LockChecker checker : sCheckers) {
	pw.print(indent);
	pw.print(" ");
	checker.dump(pw);
	pw.println();
	}

	sStats.dump(pw, indent);

	pw.print(indent);
	pw.println("Violations:");
	for (Object v : sViolations) {
	pw.print(indent); // This won't really indent a multiline string,
	// though.
	pw.println(v);
	}
	}

	/**
	* Dump stats to logcat.
	*/
	public static void dump() {
	// Dump to logcat.
	PrintWriter out = new PrintWriter(new LogWriter(Log.WARN, TAG), true);
	dump(out, "");
	out.close();
	}

	interface LockChecker {
	void pre(Object lock);

	void post(Object lock);

	int getNumDetected();

	int getNumDetectedUnique();

	String getCheckerName();

	void dump(PrintWriter pw);
	}

	interface Violation {
	Throwable getException();
	}
	}