Added core dump handler code

Fixed author Doxygen tag

Added licence headers

Moved return value definition to new header

Converted all DOS line endings to Unix

Solution for CPU dependency by using CMAKE_SYSTEM_PROCESSOR cmake variable

CPU specific stuff is implemented in own implementation file for each CPU architecture

Added config file for sysctl. Fixed wrong parameters to open call for lockfile

Added mechanism to overwrite TARGET_CPU_NAME with command line option

Signed-off-by: Alexander Wenzel <Alexander.AW.Wenzel@bmw.de>

1 files changed, 458 insertions, 0 deletions

diff --git a/src/core_dump_handler/dlt_cdh.c b/src/core_dump_handler/dlt_cdh.c
new file mode 100644
index 0000000..c573982
--- /dev/null
+++ b/src/core_dump_handler/dlt_cdh.c
@@ -0,0 +1,458 @@
+/*
+ * @licence app begin@
+ * SPDX license identifier: MPL-2.0
+ *
+ * Copyright (C) 2011-2015, BMW AG
+ *
+ * This file is part of GENIVI Project DLT - Diagnostic Log and Trace.
+ *
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License (MPL), v. 2.0.
+ * If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * For further information see http://www.genivi.org/.
+ * @licence end@
+ */
+
+/*!
+ * \author Magneti Marelli http://www.magnetimarelli.com
+ * \author Lutz Helwing <lutz_helwing@mentor.com>
+ *
+ * \copyright Copyright © 2011-2015 BMW AG. \n
+ * License MPL-2.0: Mozilla Public License version 2.0 http://mozilla.org/MPL/2.0/.
+ *
+ * \file dlt_cdh.c
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <fcntl.h>
+#include <syslog.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include "dlt_cdh.h"
+#include <dirent.h>
+
+// Unusual characters in a windows filename are replaced
+#define UNUSUAL_CHARS                           ":/\\!*"
+#define REPLACEMENT_CHAR                        '_'
+
+#define COREDUMP_FILESYSTEM                     "/var"
+#define COREDUMP_FILESYSTEM_MIN_SIZE_MB         40
+#define COREDUMP_HANDLER_PRIORITY               -19
+
+void core_locks(const proc_info_t* p_proc, int action);
+
+/* ===================================================================
+ ** Method      : init_proc_info(...)
+ **
+ ** Description : initialises all members of process info structure to defined values
+ **
+ ** Parameters  : INPUT p_proc
+ **               OUTPUT pointer to initialised crashed process info structure
+ **
+ ** Returns     : nothing
+ ** ===================================================================*/
+void init_proc_info(proc_info_t* p_proc)
+{
+    memset(p_proc->name, 0, sizeof(p_proc->name));
+    memset(p_proc->threadname, 0, sizeof(p_proc->threadname));
+
+    p_proc->pid = 0;
+    p_proc->timestamp = 0;
+    p_proc->signal = 0;
+
+    p_proc->can_create_coredump = 1;
+    memset(&p_proc->streamer, 0, sizeof(p_proc->streamer));
+
+    memset(&p_proc->m_Ehdr, 0, sizeof(p_proc->m_Ehdr));
+    p_proc->m_pPhdr = NULL;
+    p_proc->m_Nhdr = NULL;
+
+    p_proc->m_note_page_size = 0;
+
+    memset(&p_proc->m_registers, 0, sizeof(p_proc->m_registers));
+
+    p_proc->m_crashed_pid = 0;
+    p_proc->m_crashid_phase1 = 0;
+    memset(p_proc->m_crashid, 0, sizeof(p_proc->m_crashid));
+}
+
+/* ===================================================================
+ ** Method      : read_args(...)
+ **
+ ** Description : reads command line arguments
+ **
+ ** Parameters  : INPUT argc
+ **               INPUT argv
+ **               OUTPUT pointer to crashed process info structure
+ **
+ ** Returns     : 0 if success, else -1
+ ** ===================================================================*/
+cdh_status_t read_args(int argc, char** argv, proc_info_t* proc)
+{
+    if (argc < 5)
+    {
+        syslog(LOG_ERR, "Usage: cdh timestamp pid signal procname");
+        return CDH_NOK;
+    }
+
+    init_proc_info(proc);
+
+    if (sscanf(argv[1], "%u", &proc->timestamp) != 1)
+    {
+        syslog(LOG_ERR, "Unable to read timestamp argument <%s>. Closing", argv[1]);
+        return CDH_NOK;
+    }
+
+    if (sscanf(argv[2], "%d", &proc->pid) != 1)
+    {
+        syslog(LOG_ERR, "Unable to read pid argument <%s>. Closing", argv[2]);
+        return CDH_NOK;
+    }
+
+    if (sscanf(argv[3], "%d", &proc->signal) != 1)
+    {
+        syslog(LOG_ERR, "Unable to read signal argument <%s>. Closing", argv[3]);
+        return CDH_NOK;
+    }
+
+    // save the thread name given by the kernel
+    strncpy(proc->threadname, argv[4], sizeof(proc->threadname) - 1);
+
+    // initialize the binary name with threadname... in case we cannot read it from /proc
+    strncpy(proc->name, argv[4], sizeof(proc->name) - 1);
+
+    return CDH_OK;
+}
+
+/* ===================================================================
+ ** Method      : remove_unusual_chars(...)
+ **
+ ** Description : modify the input string to change UNUSUALS_CHARS to
+ **              REPLACEMENT_CHAR
+ ** Parameters  : INPUT/OUTPUT  string to be modified
+ **
+ ** Returns     : nothing
+ ** ===================================================================*/
+void remove_unusual_chars(char* p_string)
+{
+    unsigned int l_char_index = 0;
+
+    for (l_char_index = 0; l_char_index < sizeof(UNUSUAL_CHARS) - 1; l_char_index++)
+    {
+        char* l_str_pointer = p_string;
+
+        do
+        {
+            l_str_pointer = strchr(l_str_pointer, UNUSUAL_CHARS[l_char_index]);
+
+            if (l_str_pointer != NULL)
+            {
+                *l_str_pointer = REPLACEMENT_CHAR;
+                l_str_pointer++;
+            }
+        }
+        while (l_str_pointer != NULL);
+    }
+}
+
+/* ===================================================================
+ ** Method      : check_disk_space(...)
+ **
+ ** Description : check if there is sufficient disk space to write a coredump
+ ** Parameters  : INPUT/OUTPUT  string to be modified
+ **
+ ** Returns     : 0 if success, else -1
+ ** ===================================================================*/
+cdh_status_t check_disk_space()
+{
+    struct statvfs stat;
+    unsigned long free_size = 0;
+
+    if (statvfs(COREDUMP_FILESYSTEM, &stat) < 0)
+    {
+        syslog(LOG_ERR, "ERR cannot stat disk space on %s: %s", COREDUMP_FILESYSTEM, strerror(errno));
+        return CDH_NOK;
+    }
+
+    // free space: size of block * number of free blocks (>>20 => MB)
+    free_size = (stat.f_bsize * stat.f_bavail) >> 20;
+    if (free_size < COREDUMP_FILESYSTEM_MIN_SIZE_MB)
+    {
+        syslog(LOG_WARNING, "ERR insufficient disk space for coredump: %ld MB.", free_size);
+        return CDH_NOK;
+    }
+
+    syslog(LOG_INFO, "INFO disk space for coredump: %ld MB.", free_size);
+    return CDH_OK;
+}
+
+void clean_core_tmp_dir()
+{
+    DIR *d = NULL;
+    struct dirent *dir = NULL;
+
+    if ((d = opendir(CORE_TMP_DIRECTORY)) != NULL)
+    {
+        char lockfilepath[CORE_MAX_FILENAME_LENGTH];
+
+        while ((dir = readdir(d)) != NULL)
+        {
+            struct stat unused_stat;
+
+            // check if lock file exists
+            snprintf(lockfilepath, sizeof(lockfilepath), "%s/%s", CORE_LOCK_DIRECTORY, dir->d_name);
+
+            if (stat(lockfilepath, &unused_stat) != 0)
+            {
+                // No lock file found for this coredump => from previous LC => delete
+                char filepath[CORE_MAX_FILENAME_LENGTH] = { 0 };
+
+                snprintf(filepath, sizeof(filepath), "%s/%s", CORE_TMP_DIRECTORY, dir->d_name);
+
+                syslog(LOG_INFO, "Cleaning %s: delete file %s", CORE_TMP_DIRECTORY, filepath);
+
+                unlink(filepath);
+            }
+        }
+
+        closedir(d);
+    }
+}
+
+/* ===================================================================
+ ** Method      : check_core_directory(...)
+ **
+ ** Description : checks the availability of core dumps directory.
+ **               if not available, there is an installation issue.
+ **
+ ** Parameters  :
+ **
+ ** Returns     : 0 if success, else -1
+ ** ===================================================================*/
+cdh_status_t check_and_create_directory(const char* p_dirname, int create_silently)
+{
+    int l_need_create = 0;
+    int l_need_delete = 0;
+
+    struct stat l_stat;
+
+    if (lstat(p_dirname, &l_stat) < 0)
+    {
+        l_need_create = 1;
+    }
+    else if (!S_ISDIR(l_stat.st_mode))
+    {
+        l_need_delete = 1;
+        l_need_create = 1;
+    }
+
+    if (l_need_delete > 0)
+    {
+        syslog(LOG_WARNING, "WARN core directory '%s' is not a directory => removing it", p_dirname);
+
+        if (unlink(p_dirname) == -1)
+        {
+            syslog(LOG_ERR, "ERR core directory '%s' cannot be unlinked: %s", p_dirname, strerror(errno));
+            return CDH_NOK;
+        }
+    }
+    if (l_need_create > 0)
+    {
+        if (create_silently == 0)
+            syslog(LOG_WARNING, "WARN core directory '%s' does not exist => creation", p_dirname);
+
+        if (mkdir(p_dirname, 0666) == -1)
+        {
+            syslog(LOG_ERR, "ERR core directory '%s' cannot be created: %s", p_dirname, strerror(errno));
+            return CDH_NOK;
+        }
+    }
+
+    return CDH_OK;
+}
+
+/* ===================================================================
+ ** Method      : check_core_directory(...)
+ **
+ ** Description : checks the availability of core dumps directory.
+ **               if not available, there is an installation issue.
+ **
+ ** Parameters  :
+ **
+ ** Returns     : 0 if success, else -1
+ ** ===================================================================*/
+cdh_status_t check_core_directory()
+{
+    if (check_and_create_directory(CORE_DIRECTORY, 0) < 0)
+        return CDH_NOK;
+
+    if (check_and_create_directory(CORE_TMP_DIRECTORY, 0) < 0)
+        return CDH_NOK;
+
+    if (check_and_create_directory(CORE_LOCK_DIRECTORY, 1) < 0)
+        return CDH_NOK;
+
+    clean_core_tmp_dir();
+
+    return CDH_OK;
+}
+
+/* ===================================================================
+ ** Method      : move_to_core_directory(...)
+ **
+ ** Description : move the coredump and context files 
+ **              from temporary dir to final core directory
+ **
+ ** Parameters  :
+ **
+ ** Returns     : 0 if success, else -1
+ ** ===================================================================*/
+cdh_status_t move_to_core_directory(proc_info_t* p_proc)
+{
+    char l_src_filename[CORE_MAX_FILENAME_LENGTH] = { 0 };
+    char l_dst_filename[CORE_MAX_FILENAME_LENGTH] = { 0 };
+    char* patterns[] = { CORE_FILE_PATTERN, CONTEXT_FILE_PATTERN };
+    unsigned int pattern_num = 0;
+
+    if (p_proc == NULL)
+        return CDH_NOK;
+
+    for (pattern_num = 0; pattern_num < sizeof(patterns) / sizeof(char*); pattern_num++)
+    {
+        // Don't move coredump if it cannot be created
+        if (p_proc->can_create_coredump == 0 && pattern_num == 0)
+            continue;
+
+        snprintf(l_src_filename, sizeof(l_src_filename), patterns[pattern_num],
+        CORE_TMP_DIRECTORY, p_proc->timestamp, p_proc->name, p_proc->pid);
+
+        snprintf(l_dst_filename, sizeof(l_dst_filename), patterns[pattern_num],
+        CORE_DIRECTORY, p_proc->timestamp, p_proc->name, p_proc->pid);
+
+        syslog(LOG_INFO, "Moving coredump from %s to %s", l_src_filename, l_dst_filename);
+
+        if (rename(l_src_filename, l_dst_filename) < 0)
+            syslog(LOG_ERR, "Moving failed: %s", strerror(errno));
+    }
+
+    return CDH_OK;
+}
+
+/* ===================================================================
+ ** Method      : main(...)
+ **
+ ** Description :
+ **
+ ** Parameters  : argc, argv
+ **
+ ** Returns     :
+ ** ===================================================================*/
+int main(int argc, char* argv[])
+{
+    proc_info_t l_proc_info;
+//    char l_exec_name[CORE_MAX_FILENAME_LENGTH] = {0};
+
+    openlog("CoredumpHandler", 0, LOG_DAEMON);
+
+    if (read_args(argc, argv, &l_proc_info) < 0)
+        exit(-1);
+
+    if (get_exec_name(l_proc_info.pid, l_proc_info.name, sizeof(l_proc_info.name)) != 0)
+        syslog(LOG_ERR, "Failed to get executable name");
+
+    syslog(LOG_NOTICE, "Handling coredump procname:%s pid:%d timest:%d signal:%d",
+                    l_proc_info.name,
+                    l_proc_info.pid,
+                    l_proc_info.timestamp,
+                    l_proc_info.signal);
+
+    // Increase priority of the coredump handler
+    if (nice(COREDUMP_HANDLER_PRIORITY) != COREDUMP_HANDLER_PRIORITY)
+        syslog(LOG_WARNING, "Failed to change CDH priority");
+
+    if (check_disk_space() < 0)
+    {
+        //return CDH_NOK;
+        l_proc_info.can_create_coredump = 0;
+    }
+
+    if (check_core_directory() < 0)
+    {
+        //return CDH_NOK;
+        l_proc_info.can_create_coredump = 0;
+    }
+
+    remove_unusual_chars(l_proc_info.name);
+
+    core_locks(&l_proc_info, 1);
+
+    write_proc_context(&l_proc_info);
+
+    treat_coredump(&l_proc_info);
+
+    move_to_core_directory(&l_proc_info);
+
+    core_locks(&l_proc_info, 0);
+
+    treat_crash_data(&l_proc_info);
+
+    closelog();
+
+    return CDH_OK;
+}
+
+void core_locks(const proc_info_t* p_proc, int action)
+{
+    char l_lockfilepath[CORE_MAX_FILENAME_LENGTH] = { 0 };
+    char* patterns[] = { CORE_FILE_PATTERN, CONTEXT_FILE_PATTERN };
+    unsigned int pattern_num = 0;
+    int fd_lockfile = -1;
+
+    if (p_proc == NULL)
+        return;
+
+    for (pattern_num = 0; pattern_num < sizeof(patterns) / sizeof(char*); pattern_num++)
+    {
+        snprintf(l_lockfilepath, sizeof(l_lockfilepath), patterns[pattern_num],
+        CORE_LOCK_DIRECTORY, p_proc->timestamp, p_proc->name, p_proc->pid);
+
+        switch (action)
+        {
+            case 0:
+                {
+                unlink(l_lockfilepath);
+                break;
+            }
+
+            case 1:
+                {
+                if ((fd_lockfile = open(l_lockfilepath, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR)) >= 0)
+                {
+                    if (write(fd_lockfile, "1", 1) < 0)
+                        syslog(LOG_WARNING, "Failed to write lockfile %d: %s", fd_lockfile, strerror(errno));
+
+                    close(fd_lockfile);
+                }
+                else
+                {
+                    syslog(LOG_WARNING, "Failed to open lockfile %s: %s", l_lockfilepath, strerror(errno));
+                }
+
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+}