Merge "recovery: use __android_log_pmsg_file_write for log files"

  LOCAL_STATIC_LIBRARIES += $(TARGET_RECOVERY_UI_LIB)

endif

ifeq ($(BOARD_CACHEIMAGE_PARTITION_SIZE),)

LOCAL_REQUIRED_MODULES := recovery-persist recovery-refresh

endif

include $(BUILD_EXECUTABLE)

# recovery-persist (system partition dynamic executable run after /data mounts)

# ===============================

include $(CLEAR_VARS)

LOCAL_SRC_FILES := recovery-persist.cpp

LOCAL_MODULE := recovery-persist

LOCAL_SHARED_LIBRARIES := liblog libbase

LOCAL_CFLAGS := -Werror

LOCAL_INIT_RC := recovery-persist.rc

include $(BUILD_EXECUTABLE)

# recovery-refresh (system partition dynamic executable run at init)

# ===============================

include $(CLEAR_VARS)

LOCAL_SRC_FILES := recovery-refresh.cpp

LOCAL_MODULE := recovery-refresh

LOCAL_SHARED_LIBRARIES := liblog

LOCAL_CFLAGS := -Werror

LOCAL_INIT_RC := recovery-refresh.rc

include $(BUILD_EXECUTABLE)

# libverifier (static library)

/*

 * Copyright (C) 2016 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.

 */

#define LOG_TAG "recovery-persist"

//

// Strictly to deal with reboot into system after OTA after /data

// mounts to pull the last pmsg file data and place it

// into /data/misc/recovery/ directory, rotating it in.

//

// Usage: recovery-persist [--force-persist]

//

//    On systems without /cache mount, all file content representing in the

//    recovery/ directory stored in /sys/fs/pstore/pmsg-ramoops-0 in logger

//    format that reside in the LOG_ID_SYSTEM buffer at ANDROID_LOG_INFO

//    priority or higher is transfered to the /data/misc/recovery/ directory.

//    The content is matched and rotated in as need be.

//

//    --force-persist  ignore /cache mount, always rotate in the contents.

//

#include <errno.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <string>

#include <android/log.h> /* Android Log Priority Tags */

#include <android-base/file.h>

#include <log/log.h>

#include <log/logger.h> /* Android Log packet format */

#include <private/android_logger.h> /* private pmsg functions */

static const char *LAST_LOG_FILE = "/data/misc/recovery/last_log";

static const char *LAST_PMSG_FILE = "/sys/fs/pstore/pmsg-ramoops-0";

static const char *LAST_KMSG_FILE = "/data/misc/recovery/last_kmsg";

static const char *LAST_CONSOLE_FILE = "/sys/fs/pstore/console-ramoops-0";

static const int KEEP_LOG_COUNT = 10;

// close a file, log an error if the error indicator is set

static void check_and_fclose(FILE *fp, const char *name) {

    fflush(fp);

    if (ferror(fp)) SLOGE("%s %s", name, strerror(errno));

    fclose(fp);

}

static void copy_file(const char* source, const char* destination) {

    FILE* dest_fp = fopen(destination, "w");

    if (dest_fp == nullptr) {

        SLOGE("%s %s", destination, strerror(errno));

    } else {

        FILE* source_fp = fopen(source, "r");

        if (source_fp != nullptr) {

            char buf[4096];

            size_t bytes;

            while ((bytes = fread(buf, 1, sizeof(buf), source_fp)) != 0) {

                fwrite(buf, 1, bytes, dest_fp);

            }

            check_and_fclose(source_fp, source);

        }

        check_and_fclose(dest_fp, destination);

    }

}

static bool rotated = false;

// Rename last_log -> last_log.1 -> last_log.2 -> ... -> last_log.$max.

// Similarly rename last_kmsg -> last_kmsg.1 -> ... -> last_kmsg.$max.

// Overwrite any existing last_log.$max and last_kmsg.$max.

static void rotate_logs(int max) {

    // Logs should only be rotated once.

    if (rotated) {

        return;

    }

    rotated = true;

    for (int i = max-1; i >= 0; --i) {

        std::string old_log(LAST_LOG_FILE);

        if (i > 0) {

          old_log += "." + std::to_string(i);

        }

        std::string new_log(LAST_LOG_FILE);

        new_log += "." + std::to_string(i+1);

        // Ignore errors if old_log doesn't exist.

        rename(old_log.c_str(), new_log.c_str());

        std::string old_kmsg(LAST_KMSG_FILE);

        if (i > 0) {

          old_kmsg += "." + std::to_string(i);

        }

        std::string new_kmsg(LAST_KMSG_FILE);

        new_kmsg += "." + std::to_string(i+1);

        rename(old_kmsg.c_str(), new_kmsg.c_str());

    }

}

ssize_t logsave(

        log_id_t /* logId */,

        char /* prio */,

        const char *filename,

        const char *buf, size_t len,

        void * /* arg */) {

    std::string destination("/data/misc/");

    destination += filename;

    std::string buffer(buf, len);

    {

        std::string content;

        android::base::ReadFileToString(destination, &content);

        if (buffer.compare(content) == 0) {

            return len;

        }

    }

    // ToDo: Any others that match? Are we pulling in multiple

    // already-rotated files? Algorithm thus far is KISS: one file,

    // one rotation allowed.

    rotate_logs(KEEP_LOG_COUNT);

    return android::base::WriteStringToFile(buffer, destination.c_str());

}

int main(int argc, char **argv) {

    /* Is /cache a mount?, we have been delivered where we are not wanted */

    /*

     * Following code halves the size of the executable as compared to:

     *

     *    load_volume_table();

     *    has_cache = volume_for_path(CACHE_ROOT) != nullptr;

     */

    bool has_cache = false;

    static const char mounts_file[] = "/proc/mounts";

    FILE *fp = fopen(mounts_file, "r");

    if (!fp) {

        SLOGV("%s %s", mounts_file, strerror(errno));

    } else {

        char *line = NULL;

        size_t len = 0;

        ssize_t read;

        while ((read = getline(&line, &len, fp)) != -1) {

            if (strstr(line, " /cache ")) {

                has_cache = true;

                break;

            }

        }

        free(line);

        fclose(fp);

    }

    if (has_cache) {

        /*

         * TBD: Future location to move content from

         * /cache/recovery to /data/misc/recovery/

         */

        /* if --force-persist flag, then transfer pmsg data anyways */

        if ((argc <= 1) || !argv[1] || strcmp(argv[1], "--force-persist")) {

            return 0;

        }

    }

    /* Is there something in pmsg? */

    if (access(LAST_PMSG_FILE, R_OK)) {

        return 0;

    }

    // Take last pmsg file contents and send it off to the logsave

    __android_log_pmsg_file_read(

        LOG_ID_SYSTEM, ANDROID_LOG_INFO, "recovery/", logsave, NULL);

    /* Is there a last console log too? */

    if (rotated && !access(LAST_CONSOLE_FILE, R_OK)) {

        copy_file(LAST_CONSOLE_FILE, LAST_KMSG_FILE);

    }

    return 0;

}

on post-fs-data

    mkdir /data/misc/recovery 0770 system log

    exec - system log -- /system/bin/recovery-persist

/*

 * Copyright (C) 2016 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.

 */

#define LOG_TAG "recovery-refresh"

//

// Strictly to deal with reboot into system after OTA, then

// reboot while in system before boot complete landing us back

// into recovery to continue with any mitigations with retained

// log history. This simply refreshes the pmsg files from

// the last pmsg file contents.

//

// Usage:

//    recovery-refresh [--force-rotate|--rotate]

//

//    All file content representing in the recovery/ directory stored in

//    /sys/fs/pstore/pmsg-ramoops-0 in logger format that reside in the

//    LOG_ID_SYSTEM buffer at ANDROID_LOG_INFO priority or higher is

//    refreshed into /dev/pmsg0. This ensures that an unexpected reboot

//    before recovery-persist is run will still contain the associated

//    pmsg Android Logger content.

//

//    --force-rotate  recovery/last_kmsg and recovery.last_log files are

//                    rotated with .<number> suffixes upwards.

//    --rotate        rotated only if rocovery/last_msg or recovery/last_log

//                    exist, otherwise perform 1:1 refresh.

//

#include <string.h>

#include <string>

#include <android/log.h> /* Android Log Priority Tags */

#include <log/logger.h> /* Android Log packet format */

#include <private/android_logger.h> /* private pmsg functions */

static const char LAST_KMSG_FILE[] = "recovery/last_kmsg";

static const char LAST_LOG_FILE[] = "recovery/last_log";

static ssize_t logbasename(

        log_id_t /* logId */,

        char /* prio */,

        const char *filename,

        const char * /* buf */, size_t len,

        void *arg) {

    if (strstr(LAST_KMSG_FILE, filename) ||

            strstr(LAST_LOG_FILE, filename)) {

        bool *doRotate = reinterpret_cast<bool *>(arg);

        *doRotate = true;

    }

    return len;

}

static ssize_t logrotate(

        log_id_t logId,

        char prio,

        const char *filename,

        const char *buf, size_t len,

        void *arg) {

    bool *doRotate = reinterpret_cast<bool *>(arg);

    if (!*doRotate) {

        return __android_log_pmsg_file_write(logId, prio, filename, buf, len);

    }

    std::string name(filename);

    size_t dot = name.find_last_of(".");

    std::string sub = name.substr(0, dot);

    if (!strstr(LAST_KMSG_FILE, sub.c_str()) &&

                !strstr(LAST_LOG_FILE, sub.c_str())) {

        return __android_log_pmsg_file_write(logId, prio, filename, buf, len);

    }

    // filename rotation

    if (dot == std::string::npos) {

        name += ".1";

    } else {

        std::string number = name.substr(dot + 1);

        if (!isdigit(number.data()[0])) {

            name += ".1";

        } else {

            unsigned long long i = std::stoull(number);

            name = sub + "." + std::to_string(i + 1);

        }

    }

    return __android_log_pmsg_file_write(logId, prio, name.c_str(), buf, len);

}

int main(int argc, char **argv) {

    static const char filter[] = "recovery/";

    static const char force_rotate_flag[] = "--force-rotate";

    static const char rotate_flag[] = "--rotate";

    ssize_t ret;

    bool doRotate = false;

    // Take last pmsg contents and rewrite it to the current pmsg session.

    if ((argc <= 1) || !argv[1] ||

            (((doRotate = strcmp(argv[1], rotate_flag))) &&

                strcmp(argv[1], force_rotate_flag))) {

        doRotate = false;

    } else if (!doRotate) {

        // Do we need to rotate?

        __android_log_pmsg_file_read(

            LOG_ID_SYSTEM, ANDROID_LOG_INFO, filter,

            logbasename, &doRotate);

    }

    // Take action to refresh pmsg contents

    ret = __android_log_pmsg_file_read(

        LOG_ID_SYSTEM, ANDROID_LOG_INFO, filter,

        logrotate, &doRotate);

    return (ret < 0) ? ret : 0;

}

on post-fs

    exec - system log -- /system/bin/recovery-refresh