File Manager

003 File Manager

Current Path: /usr/src/contrib/kyua/utils

📁 ..
📄 .gitignore(27 B)
📄 Kyuafile(651 B)
📄 Makefile.am.inc(5.42 KB)
📄 auto_array.hpp(3.32 KB)
📄 auto_array.ipp(6 KB)
📄 auto_array_fwd.hpp(1.8 KB)
📄 auto_array_test.cpp(8.27 KB)
📁 cmdline
📁 config
📄 datetime.cpp(16.78 KB)
📄 datetime.hpp(4.57 KB)
📄 datetime_fwd.hpp(1.83 KB)
📄 datetime_test.cpp(19.52 KB)
📄 defs.hpp.in(2.18 KB)
📄 env.cpp(6.62 KB)
📄 env.hpp(2.31 KB)
📄 env_test.cpp(4.97 KB)
📁 format
📁 fs
📁 logging
📄 memory.cpp(5.29 KB)
📄 memory.hpp(1.8 KB)
📄 memory_test.cpp(2.25 KB)
📄 noncopyable.hpp(2.78 KB)
📄 optional.hpp(2.97 KB)
📄 optional.ipp(6.3 KB)
📄 optional_fwd.hpp(2.14 KB)
📄 optional_test.cpp(7.83 KB)
📄 passwd.cpp(5.68 KB)
📄 passwd.hpp(2.4 KB)
📄 passwd_fwd.hpp(1.8 KB)
📄 passwd_test.cpp(5.75 KB)
📁 process
📄 sanity.cpp(6.48 KB)
📄 sanity.hpp(6.93 KB)
📄 sanity_fwd.hpp(1.98 KB)
📄 sanity_test.cpp(9.36 KB)
📁 signals
📁 sqlite
📄 stacktrace.cpp(12.56 KB)
📄 stacktrace.hpp(2.71 KB)
📄 stacktrace_helper.cpp(1.58 KB)
📄 stacktrace_test.cpp(21.15 KB)
📄 stream.cpp(4.59 KB)
📄 stream.hpp(2.16 KB)
📄 stream_test.cpp(4.92 KB)
📄 test_utils.ipp(3.53 KB)
📁 text
📄 units.cpp(5.25 KB)
📄 units.hpp(2.99 KB)
📄 units_fwd.hpp(1.79 KB)
📄 units_test.cpp(7.79 KB)

Editing: sanity.cpp

// Copyright 2010 The Kyua Authors.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
//   notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the distribution.
// * Neither the name of Google Inc. nor the names of its contributors
//   may be used to endorse or promote products derived from this software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "utils/sanity.hpp"

#if defined(HAVE_CONFIG_H)
#include "config.h"
#endif

extern "C" {
#include <signal.h>
#include <unistd.h>
}

#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <iostream>

#include "utils/format/macros.hpp"
#include "utils/logging/macros.hpp"

namespace {

/// List of fatal signals to be intercepted by the sanity code.
///
/// The tests hardcode this list; update them whenever the list gets updated.
static int fatal_signals[] = { SIGABRT, SIGBUS, SIGSEGV, 0 };

/// The path to the log file to report on crashes.  Be aware that this is empty
/// until install_crash_handlers() is called.
static std::string logfile;

/// Prints a message to stderr.
///
/// Note that this runs from a signal handler.  Calling write() is OK.
///
/// \param message The message to print.
static void
err_write(const std::string& message)
{
    if (::write(STDERR_FILENO, message.c_str(), message.length()) == -1) {
        // We are crashing.  If ::write fails, there is not much we could do,
        // specially considering that we are running within a signal handler.
        // Just ignore the error.
    }
}

/// The crash handler for fatal signals.
///
/// The sole purpose of this is to print some informational data before
/// reraising the original signal.
///
/// \param signo The received signal.
static void
crash_handler(const int signo)
{
    PRE(!logfile.empty());

err_write(F("*** Fatal signal %s received\n") % signo);
    err_write(F("*** Log file is %s\n") % logfile);
    err_write(F("*** Please report this problem to %s detailing what you were "
                "doing before the crash happened; if possible, include the log "
                "file mentioned above\n") % PACKAGE_BUGREPORT);

/// The handler is installed with SA_RESETHAND, so this is safe to do.  We
    /// really want to call the default handler to generate any possible core
    /// dumps.
    ::kill(::getpid(), signo);
}

/// Installs a handler for a fatal signal representing a crash.
///
/// When the specified signal is captured, the crash_handler() will be called to
/// print some informational details to the user and, later, the signal will be
/// redelivered using the default handler to obtain a core dump.
///
/// \param signo The fatal signal for which to install a handler.
static void
install_one_crash_handler(const int signo)
{
    struct ::sigaction sa;
    sa.sa_handler = crash_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESETHAND;

if (::sigaction(signo, &sa, NULL) == -1) {
        const int original_errno = errno;
        LW(F("Could not install crash handler for signal %s: %s") %
           signo % std::strerror(original_errno));
    } else
        LD(F("Installed crash handler for signal %s") % signo);
}

/// Returns a textual representation of an assertion type.
///
/// The textual representation is user facing.
///
/// \param type The type of the assertion.  If the type is unknown for whatever
///     reason, a special message is returned.  The code cannot abort in such a
///     case because this code is dealing for assertion errors.
///
/// \return A textual description of the assertion type.
static std::string
format_type(const utils::assert_type type)
{
    switch (type) {
    case utils::invariant: return "Invariant check failed";
    case utils::postcondition: return "Postcondition check failed";
    case utils::precondition: return "Precondition check failed";
    case utils::unreachable: return "Unreachable point reached";
    default: return "UNKNOWN ASSERTION TYPE";
    }
}

}  // anonymous namespace

/// Raises an assertion error.
///
/// This function prints information about the assertion failure and terminates
/// execution immediately by calling std::abort().  This ensures a coredump so
/// that the failure can be analyzed later.
///
/// \param type The assertion type; this influences the printed message.
/// \param file The file in which the assertion failed.
/// \param line The line in which the assertion failed.
/// \param message The failure message associated to the condition.
void
utils::sanity_failure(const assert_type type, const char* file,
                      const size_t line, const std::string& message)
{
    std::cerr << "*** " << file << ":" << line << ": " << format_type(type);
    if (!message.empty())
        std::cerr << ": " << message << "\n";
    else
        std::cerr << "\n";
    std::abort();
}

/// Installs persistent handlers for crash signals.
///
/// Should be called at the very beginning of the execution of the program to
/// ensure that a signal handler for fatal crash signals is installed.
///
/// \pre The function has not been called before.
///
/// \param logfile_ The path to the log file to report during a crash.
void
utils::install_crash_handlers(const std::string& logfile_)
{
    static bool installed = false;
    PRE(!installed);
    logfile = logfile_;

for (const int* iter = &fatal_signals[0]; *iter != 0; iter++)
        install_one_crash_handler(*iter);

installed = true;
}

003 File Manager

Editing: sanity.cpp

Upload File

Create Folder