common/util/src/com/android/compatibility/common/util/CrashUtils.java

/*
 * 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.compatibility.common.util;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.List;

/** Contains helper functions and shared constants for crash parsing. */
public class CrashUtils {
    // used to only detect actual addresses instead of nullptr and other unlikely values
    public static final long MIN_CRASH_ADDR = 0x8000;
    // Matches the end of a crash
    public static final Pattern sEndofCrashPattern =
            Pattern.compile("DEBUG\\s+?:\\s+?backtrace:");
    public static final String DEVICE_PATH = "/data/local/tmp/CrashParserResults/";
    public static final String LOCK_FILENAME = "lockFile.loc";
    public static final String UPLOAD_REQUEST = "Please upload a result file to stagefright";
    public static final Pattern sUploadRequestPattern =
            Pattern.compile(UPLOAD_REQUEST);
    public static final String NEW_TEST_ALERT = "New test starting with name: ";
    public static final Pattern sNewTestPattern =
            Pattern.compile(NEW_TEST_ALERT + "(\\w+?)\\(.*?\\)");
    // Matches the smallest blob that has the appropriate header and footer
    private static final Pattern sCrashBlobPattern =
            Pattern.compile("DEBUG\\s+?:( [*]{3})+?.*?DEBUG\\s+?:\\s+?backtrace:", Pattern.DOTALL);
    // Matches process id and name line and captures them
    private static final Pattern sPidtidNamePattern =
            Pattern.compile("pid: (\\d+?), tid: (\\d+?), name: ([^\\s]+?\\s+?)*?>>> (.*?) <<<");
    // Matches fault address and signal type line
    private static final Pattern sFaultLinePattern =
            Pattern.compile(
                    "\\w+? \\d+? \\((.*?)\\), code -*?\\d+? \\(.*?\\), fault addr "
                            + "(?:0x(\\p{XDigit}+)|-+)");
    // Matches the abort message line if it contains CHECK_
    private static Pattern sAbortMessageCheckPattern =
            Pattern.compile("(?i)Abort message.*?CHECK_");

    /**
     * Determines if the given input has a {@link com.android.compatibility.common.util.Crash} that
     * should fail an sts test
     *
     * @param processNames list of applicable process names
     * @param checkMinAddr if the minimum fault address should be respected
     * @param crashes list of crashes to check
     * @return if a crash is serious enough to fail an sts test
     */
    public static boolean detectCrash(
        String[] processNames, boolean checkMinAddr, List<Crash> crashes) {
        for (Crash crash : crashes) {
            if (!crash.signal.toLowerCase().matches("sig(segv|bus)")) {
                continue;
            }

            if (checkMinAddr) {
                if (crash.faultAddress != null && crash.faultAddress < MIN_CRASH_ADDR) {
                    continue;
                }
            }

            boolean foundProcess = false;
            for (String process : processNames) {
                if (crash.name.equals(process)) {
                    foundProcess = true;
                    break;
                }
            }

            if (!foundProcess) {
                continue;
            }

            return true; // crash detected
        }

        return false;
    }

    /**
     * Creates a list of all crashes found within the input
     *
     * @param input logs to scan through
     * @return List of all crashes as Crash objects
     */
    public static ArrayList<Crash> getAllCrashes(String input) {
        ArrayList<Crash> crashes = new ArrayList<>();
        Matcher crashBlobFinder = sCrashBlobPattern.matcher(input);
        while (crashBlobFinder.find()) {
            String crashStr = crashBlobFinder.group(0);
            int tid = 0, pid = 0;
            Long faultAddress = null;
            String name = null, signal = null;

            Matcher pidtidNameMatcher = sPidtidNamePattern.matcher(crashStr);
            if (pidtidNameMatcher.find()) {
                try {
                    pid = Integer.parseInt(pidtidNameMatcher.group(1));
                } catch (NumberFormatException e) {
                }
                try {
                    tid = Integer.parseInt(pidtidNameMatcher.group(2));
                } catch (NumberFormatException e) {
                }
                name = pidtidNameMatcher.group(3).trim();
            }

            Matcher faultLineMatcher = sFaultLinePattern.matcher(crashStr);
            if (faultLineMatcher.find()) {
                signal = faultLineMatcher.group(1);
                String faultAddrMatch = faultLineMatcher.group(2);
                if (faultAddrMatch != null) {
                    try {
                        faultAddress = Long.parseLong(faultAddrMatch, 16);
                    } catch (NumberFormatException e) {
                    }
                }
            }
            if (!sAbortMessageCheckPattern.matcher(crashStr).find()) {
                crashes.add(new Crash(pid, tid, name, faultAddress, signal));
            }
        }

        return crashes;
    }
}