monitor.h

Go to the documentation of this file.

#ifndef CVMFS_MONITOR_H_
#define CVMFS_MONITOR_H_

#include <pthread.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>

#include <map>
#include <string>

#include "util/platform.h"
#include "util/pointer.h"
#include "util/single_copy.h"

struct Pipe;

class Watchdog : SingleCopy {
 public:
  typedef void (*FnOnCrash)(void);

  static Watchdog *Create(FnOnCrash on_crash);
  static pid_t GetPid();
  ~Watchdog();
  void Spawn(const std::string &crash_dump_path);

 private:
  typedef std::map<int, struct sigaction> SigactionMap;

  struct CrashData {
    int signal;
    int sys_errno;
    pid_t pid;
  };

  struct ControlFlow {
    enum Flags {
      kProduceStacktrace = 0,
      kQuit,
      kSupervise,
      kUnknown,
    };
  };

  static const unsigned kSignalHandlerStacksize = 2 * 1024 * 1024;  // 2 MB
  static const unsigned kMaxBacktrace = 64;

  static Watchdog *instance_;
  static Watchdog *Me() { return instance_; }

  static void *MainWatchdogListener(void *data);

  static void ReportSignalAndTerminate(int sig, siginfo_t *siginfo,
                                       void *context);
  static void SendTrace(int sig, siginfo_t *siginfo, void *context);

  explicit Watchdog(FnOnCrash on_crash);
  void Fork();
  bool WaitForSupervisee();
  SigactionMap SetSignalHandlers(const SigactionMap &signal_handlers);
  void Supervise();
  void LogEmergency(std::string msg);
  std::string ReportStacktrace();
  std::string GenerateStackTrace(pid_t pid);
  std::string ReadUntilGdbPrompt(int fd_pipe);

  bool spawned_;
  std::string crash_dump_path_;
  std::string exe_path_;
  pid_t watchdog_pid_;
  UniquePtr<Pipe> pipe_watchdog_;
  UniquePtr<Pipe> pipe_listener_;
  UniquePtr<Pipe> pipe_terminate_;
  pthread_t thread_listener_;
  FnOnCrash on_crash_;
  platform_spinlock lock_handler_;
  stack_t sighandler_stack_;
  SigactionMap old_signal_handlers_;
};

#endif  // CVMFS_MONITOR_H_