003 File Manager
Current Path:
/usr/src/contrib/kyua/utils
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; }
Upload File
Create Folder