/*

 * Copyright (c) 2008, 2009, 2010, 2011, 2013 Nicira, Inc.

 *

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

#include <errno.h>

#include <fcntl.h>

#include <inttypes.h>

#include <string.h>

#include <unistd.h>

#include "backtrace.h"

#include "openvswitch/vlog.h"

#include "util.h"

VLOG_DEFINE_THIS_MODULE(backtrace);

#ifdef HAVE_BACKTRACE

#include <execinfo.h>

void

backtrace_capture(struct backtrace *b)

{

    b->n_frames = backtrace(b->frames, BACKTRACE_MAX_FRAMES);

}

void

backtrace_format(struct ds *ds, const struct backtrace *bt,

                 const char *delimiter)

{

    if (bt->n_frames) {

        char **symbols = backtrace_symbols(bt->frames, bt->n_frames);

        if (!symbols) {

            return;

        }

        for (int i = 0; i < bt->n_frames - 1; i++) {

            ds_put_format(ds, "%s%s", symbols[i], delimiter);

        }

        ds_put_format(ds, "%s", symbols[bt->n_frames - 1]);

        free(symbols);

    }

}

#else

void

backtrace_capture(struct backtrace *backtrace)

{

    backtrace->n_frames = 0;

}

void

backtrace_format(struct ds *ds, const struct backtrace *bt OVS_UNUSED,

                 const char *delimiter OVS_UNUSED)

{

    ds_put_cstr(ds, "backtrace() is not supported!\n");

}

#endif

void

log_backtrace_at(const char *msg, const char *where)

{

    struct backtrace b;

    struct ds ds = DS_EMPTY_INITIALIZER;

    backtrace_capture(&b);

    if (msg) {

        ds_put_format(&ds, "%s ", msg);

    }

    ds_put_cstr(&ds, where);

    ds_put_cstr(&ds, " backtrace:\n");

    backtrace_format(&ds, &b, "\n");

    VLOG_ERR("%s", ds_cstr_ro(&ds));

    ds_destroy(&ds);

}

#if defined(HAVE_UNWIND) || defined(HAVE_BACKTRACE)

static bool

read_received_backtrace(int fd, void *dest, size_t len)

{

    VLOG_DBG("%s fd %d", __func__, fd);

    fcntl(fd, F_SETFL, O_NONBLOCK);

    memset(dest, 0, len);

    int byte_read = read(fd, dest, len);

    if (byte_read < 0) {

        VLOG_ERR("Read fd %d failed: %s", fd, ovs_strerror(errno));

    }

    return byte_read > 0;;

}

#else

static bool

read_received_backtrace(int fd OVS_UNUSED, void *dest OVS_UNUSED,

                        size_t len OVS_UNUSED)

{

    return false;

}

#endif

#ifdef HAVE_UNWIND

void

log_received_backtrace(int fd)

{

    struct unw_backtrace backtrace[UNW_MAX_DEPTH];

    if (read_received_backtrace(fd, backtrace, UNW_MAX_BUF)) {

        struct ds ds = DS_EMPTY_INITIALIZER;

        ds_put_cstr(&ds, BACKTRACE_DUMP_MSG);

        for (int i = 0; i < UNW_MAX_DEPTH; i++) {

            if (backtrace[i].func[0] == 0) {

                break;

            }

            ds_put_format(&ds, "0x%016"PRIxPTR" <%s+0x%"PRIxPTR">\n",

                          backtrace[i].ip,

                          backtrace[i].func,

                          backtrace[i].offset);

        }

        VLOG_WARN("%s", ds_cstr_ro(&ds));

        ds_destroy(&ds);

    }

}

#elif HAVE_BACKTRACE

void

log_received_backtrace(int fd)

{

    struct backtrace bt;

    if (read_received_backtrace(fd, &bt, sizeof bt)) {

        struct ds ds = DS_EMPTY_INITIALIZER;

        bt.n_frames = MIN(bt.n_frames, BACKTRACE_MAX_FRAMES);

        ds_put_cstr(&ds, BACKTRACE_DUMP_MSG);

        backtrace_format(&ds, &bt, "\n");

        VLOG_WARN("%s", ds_cstr_ro(&ds));

        ds_destroy(&ds);

    }

}

#else

void

log_received_backtrace(int daemonize_fd OVS_UNUSED)

{

    VLOG_WARN("Backtrace using libunwind or backtrace() is not supported.");

}

#endif