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

Commit e2d05c56 authored by Tianjie Xu's avatar Tianjie Xu Committed by Gerrit Code Review
Browse files

Merge "Cleanup the duplicates of logs rotation functions"

parents 529032f4 e113e4d6

Android.mk

+8 −3
Original line number Diff line number Diff line
@@ -46,6 +46,7 @@ LOCAL_SRC_FILES := \ 
    install.cpp \

    recovery.cpp \

    roots.cpp \

    rotate_logs.cpp \

    screen_ui.cpp \

    ui.cpp \

    verifier.cpp \
@@ -119,7 +120,9 @@ include $(BUILD_EXECUTABLE) 
# recovery-persist (system partition dynamic executable run after /data mounts)

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

include $(CLEAR_VARS)

LOCAL_SRC_FILES := recovery-persist.cpp

LOCAL_SRC_FILES := \

    recovery-persist.cpp \

    rotate_logs.cpp

LOCAL_MODULE := recovery-persist

LOCAL_SHARED_LIBRARIES := liblog libbase

LOCAL_CFLAGS := -Werror
@@ -129,9 +132,11 @@ include $(BUILD_EXECUTABLE) 
# recovery-refresh (system partition dynamic executable run at init)

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

include $(CLEAR_VARS)

LOCAL_SRC_FILES := recovery-refresh.cpp

LOCAL_SRC_FILES := \

    recovery-refresh.cpp \

    rotate_logs.cpp

LOCAL_MODULE := recovery-refresh

LOCAL_SHARED_LIBRARIES := liblog

LOCAL_SHARED_LIBRARIES := liblog libbase

LOCAL_CFLAGS := -Werror

LOCAL_INIT_RC := recovery-refresh.rc

include $(BUILD_EXECUTABLE)

recovery-persist.cpp

+4 −38
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ 
//    --force-persist  ignore /cache mount, always rotate in the contents.

//



#include <errno.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>
@@ -40,17 +39,16 @@ 


#include <android-base/file.h>

#include <android-base/logging.h>



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



#include "rotate_logs.h"



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 char *ALT_LAST_CONSOLE_FILE = "/sys/fs/pstore/console-ramoops";



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);
@@ -80,39 +78,6 @@ static void copy_file(const char* source, const char* 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 */,
@@ -138,7 +103,8 @@ ssize_t logsave( 
    // already-rotated files? Algorithm thus far is KISS: one file,

    // one rotation allowed.



    rotate_logs(KEEP_LOG_COUNT);

    rotate_logs(LAST_LOG_FILE, LAST_KMSG_FILE);

    rotated = true;



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

}

recovery-refresh.cpp

+1 −57
Original line number Diff line number Diff line
@@ -14,8 +14,6 @@ 
 * 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
@@ -40,64 +38,11 @@ 
//



#include <string.h>



#include <string>



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

#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 {

            auto i = std::stoull(number);

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

        }

    }



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

}

#include "rotate_logs.h"



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

    static const char filter[] = "recovery/";
@@ -105,7 +50,6 @@ int main(int argc, char **argv) { 
    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))) &&

recovery.cpp

+6 −84
Original line number Diff line number Diff line
@@ -66,8 +66,9 @@ 
#include "minui/minui.h"

#include "otautil/DirUtil.h"

#include "roots.h"

#include "ui.h"

#include "rotate_logs.h"

#include "screen_ui.h"

#include "ui.h"



static const struct option OPTIONS[] = {

  { "update_package", required_argument, NULL, 'u' },
@@ -108,7 +109,6 @@ static const char *TEMPORARY_LOG_FILE = "/tmp/recovery.log"; 
static const char *TEMPORARY_INSTALL_FILE = "/tmp/last_install";

static const char *LAST_KMSG_FILE = "/cache/recovery/last_kmsg";

static const char *LAST_LOG_FILE = "/cache/recovery/last_log";

static const int KEEP_LOG_COUNT = 10;

// We will try to apply the update package 5 times at most in case of an I/O error.

static const int EIO_RETRY_COUNT = 4;

static const int BATTERY_READ_TIMEOUT_IN_SEC = 10;
@@ -451,37 +451,6 @@ static void copy_log_file(const char* source, const char* destination, bool appe 
    }

}



// 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.

    static bool rotated = false;

    if (rotated) {

        return;

    }

    rotated = true;

    ensure_path_mounted(LAST_LOG_FILE);

    ensure_path_mounted(LAST_KMSG_FILE);



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

        std::string old_log = android::base::StringPrintf("%s", LAST_LOG_FILE);

        if (i > 0) {

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

        }

        std::string new_log = android::base::StringPrintf("%s.%d", LAST_LOG_FILE, i+1);

        // Ignore errors if old_log doesn't exist.

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



        std::string old_kmsg = android::base::StringPrintf("%s", LAST_KMSG_FILE);

        if (i > 0) {

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

        }

        std::string new_kmsg = android::base::StringPrintf("%s.%d", LAST_KMSG_FILE, i+1);

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

    }

}



static void copy_logs() {

    // We only rotate and record the log of the current session if there are

    // actual attempts to modify the flash, such as wipes, installs from BCB
@@ -500,7 +469,9 @@ static void copy_logs() { 
        return;

    }



    rotate_logs(KEEP_LOG_COUNT);

    ensure_path_mounted(LAST_LOG_FILE);

    ensure_path_mounted(LAST_KMSG_FILE);

    rotate_logs(LAST_LOG_FILE, LAST_KMSG_FILE);



    // Copy logs to cache so the system can find out what happened.

    copy_log_file(TEMPORARY_LOG_FILE, LOG_FILE, true);
@@ -1418,56 +1389,6 @@ static void log_failure_code(ErrorCode code, const char *update_package) { 
    LOG(INFO) << log_content;

}



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 {

            auto 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) {

    // We don't have logcat yet under recovery; so we'll print error on screen and

    // log to stdout (which is redirected to recovery.log) as we used to do.
@@ -1477,6 +1398,7 @@ int main(int argc, char **argv) { 
    static const char filter[] = "recovery/";

    // Do we need to rotate?

    bool doRotate = false;



    __android_log_pmsg_file_read(

        LOG_ID_SYSTEM, ANDROID_LOG_INFO, filter,

        logbasename, &doRotate);

rotate_logs.cpp

0 → 100644
+115 −0
Original line number Diff line number Diff line 
/*

 * 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.

 */



#include "rotate_logs.h"



#include <stdio.h>

#include <string.h>

#include <sys/types.h>



#include <string>



#include <android-base/file.h>

#include <android-base/logging.h>

#include <android-base/parseint.h>

#include <android-base/stringprintf.h>

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



static const std::string LAST_KMSG_FILTER = "recovery/last_kmsg";

static const std::string LAST_LOG_FILTER = "recovery/last_log";



ssize_t logbasename(

        log_id_t /* logId */,

        char /* prio */,

        const char *filename,

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

        void *arg) {

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

    if (LAST_KMSG_FILTER.find(filename) != std::string::npos ||

            LAST_LOG_FILTER.find(filename) != std::string::npos) {

        *doRotate = true;

    }

    return len;

}



ssize_t logrotate(

        log_id_t logId,

        char prio,

        const char *filename,

        const char *buf, size_t len,

        void *arg) {

    bool* doRotate  = static_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 (LAST_KMSG_FILTER.find(sub) == std::string::npos &&

            LAST_LOG_FILTER.find(sub) == std::string::npos) {

        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[0])) {

            name += ".1";

        } else {

            size_t i;

            if (!android::base::ParseUint(number, &i)) {

                LOG(ERROR) << "failed to parse uint in " << number;

                return -1;

            }

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

        }

    }



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

}



// 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.

void rotate_logs(const char* last_log_file, const char* last_kmsg_file) {

    // Logs should only be rotated once.

    static bool rotated = false;

    if (rotated) {

        return;

    }

    rotated = true;



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

        std::string old_log = android::base::StringPrintf("%s", last_log_file);

        if (i > 0) {

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

        }

        std::string new_log = android::base::StringPrintf("%s.%d", last_log_file, i+1);

        // Ignore errors if old_log doesn't exist.

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



        std::string old_kmsg = android::base::StringPrintf("%s", last_kmsg_file);

        if (i > 0) {

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

        }

        std::string new_kmsg = android::base::StringPrintf("%s.%d", last_kmsg_file, i+1);

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

    }

}