lldb/tools/debugserver/source/libdebugserver.cpp

   1 //===-- libdebugserver.cpp --------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include <cerrno>
  10 #include <getopt.h>
  11 #include <netinet/in.h>
  12 #include <sys/select.h>
  13 #include <sys/socket.h>
  14 #include <sys/sysctl.h>
  15 #include <sys/types.h>
  16
  17 #include <memory>
  18
  19 #include "DNB.h"
  20 #include "DNBLog.h"
  21 #include "DNBTimer.h"
  22 #include "PseudoTerminal.h"
  23 #include "RNBContext.h"
  24 #include "RNBRemote.h"
  25 #include "RNBServices.h"
  26 #include "RNBSocket.h"
  27 #include "SysSignal.h"
  28
  29 // Run loop modes which determine which run loop function will be called
  30 enum RNBRunLoopMode {
  31   eRNBRunLoopModeInvalid = 0,
  32   eRNBRunLoopModeGetStartModeFromRemoteProtocol,
  33   eRNBRunLoopModeInferiorExecuting,
  34   eRNBRunLoopModeExit
  35 };
  36
  37 // Global Variables
  38 RNBRemoteSP g_remoteSP;
  39 int g_disable_aslr = 0;
  40 int g_isatty = 0;
  41
  42 #define RNBLogSTDOUT(fmt, ...)                                                 \
  43   do {                                                                         \
  44     if (g_isatty) {                                                            \
  45       fprintf(stdout, fmt, ##__VA_ARGS__);                                     \
  46     } else {                                                                   \
  47       _DNBLog(0, fmt, ##__VA_ARGS__);                                          \
  48     }                                                                          \
  49   } while (0)
  50 #define RNBLogSTDERR(fmt, ...)                                                 \
  51   do {                                                                         \
  52     if (g_isatty) {                                                            \
  53       fprintf(stderr, fmt, ##__VA_ARGS__);                                     \
  54     } else {                                                                   \
  55       _DNBLog(0, fmt, ##__VA_ARGS__);                                          \
  56     }                                                                          \
  57   } while (0)
  58
  59 // Get our program path and arguments from the remote connection.
  60 // We will need to start up the remote connection without a PID, get the
  61 // arguments, wait for the new process to finish launching and hit its
  62 // entry point,  and then return the run loop mode that should come next.
  63 RNBRunLoopMode RNBRunLoopGetStartModeFromRemote(RNBRemoteSP &remoteSP) {
  64   std::string packet;
  65
  66   if (remoteSP.get() != NULL) {
  67     RNBRemote *remote = remoteSP.get();
  68     RNBContext &ctx = remote->Context();
  69     uint32_t event_mask = RNBContext::event_read_packet_available;
  70
  71     // Spin waiting to get the A packet.
  72     while (true) {
  73       DNBLogThreadedIf(LOG_RNB_MAX,
  74                        "%s ctx.Events().WaitForSetEvents( 0x%08x ) ...",
  75                        __FUNCTION__, event_mask);
  76       nub_event_t set_events = ctx.Events().WaitForSetEvents(event_mask);
  77       DNBLogThreadedIf(LOG_RNB_MAX,
  78                        "%s ctx.Events().WaitForSetEvents( 0x%08x ) => 0x%08x",
  79                        __FUNCTION__, event_mask, set_events);
  80
  81       if (set_events & RNBContext::event_read_packet_available) {
  82         rnb_err_t err = rnb_err;
  83         RNBRemote::PacketEnum type;
  84
  85         err = remote->HandleReceivedPacket(&type);
  86
  87         // check if we tried to attach to a process
  88         if (type == RNBRemote::vattach || type == RNBRemote::vattachwait) {
  89           if (err == rnb_success)
  90             return eRNBRunLoopModeInferiorExecuting;
  91           else {
  92             RNBLogSTDERR("error: attach failed.");
  93             return eRNBRunLoopModeExit;
  94           }
  95         }
  96
  97         if (err == rnb_success) {
  98           DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Got success...", __FUNCTION__);
  99           continue;
 100         } else if (err == rnb_not_connected) {
 101           RNBLogSTDERR("error: connection lost.");
 102           return eRNBRunLoopModeExit;
 103         } else {
 104           // a catch all for any other gdb remote packets that failed
 105           DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Error getting packet.",
 106                            __FUNCTION__);
 107           continue;
 108         }
 109
 110         DNBLogThreadedIf(LOG_RNB_MINIMAL, "#### %s", __FUNCTION__);
 111       } else {
 112         DNBLogThreadedIf(LOG_RNB_MINIMAL,
 113                          "%s Connection closed before getting \"A\" packet.",
 114                          __FUNCTION__);
 115         return eRNBRunLoopModeExit;
 116       }
 117     }
 118   }
 119   return eRNBRunLoopModeExit;
 120 }
 121
 122 // Watch for signals:
 123 // SIGINT: so we can halt our inferior. (disabled for now)
 124 // SIGPIPE: in case our child process dies
 125 nub_process_t g_pid;
 126 int g_sigpipe_received = 0;
 127 void signal_handler(int signo) {
 128   DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s (%s)", __FUNCTION__,
 129                    SysSignal::Name(signo));
 130
 131   switch (signo) {
 132   //  case SIGINT:
 133   //      DNBProcessKill (g_pid, signo);
 134   //      break;
 135
 136   case SIGPIPE:
 137     g_sigpipe_received = 1;
 138     break;
 139   }
 140 }
 141
 142 // Return the new run loop mode based off of the current process state
 143 RNBRunLoopMode HandleProcessStateChange(RNBRemoteSP &remote, bool initialize) {
 144   RNBContext &ctx = remote->Context();
 145   nub_process_t pid = ctx.ProcessID();
 146
 147   if (pid == INVALID_NUB_PROCESS) {
 148     DNBLogThreadedIf(LOG_RNB_MINIMAL, "#### %s error: pid invalid, exiting...",
 149                      __FUNCTION__);
 150     return eRNBRunLoopModeExit;
 151   }
 152   nub_state_t pid_state = DNBProcessGetState(pid);
 153
 154   DNBLogThreadedIf(LOG_RNB_MINIMAL,
 155                    "%s (&remote, initialize=%i)  pid_state = %s", __FUNCTION__,
 156                    (int)initialize, DNBStateAsString(pid_state));
 157
 158   switch (pid_state) {
 159   case eStateInvalid:
 160   case eStateUnloaded:
 161     // Something bad happened
 162     return eRNBRunLoopModeExit;
 163     break;
 164
 165   case eStateAttaching:
 166   case eStateLaunching:
 167     return eRNBRunLoopModeInferiorExecuting;
 168
 169   case eStateSuspended:
 170   case eStateCrashed:
 171   case eStateStopped:
 172     if (!initialize) {
 173       // Compare the last stop count to our current notion of a stop count
 174       // to make sure we don't notify more than once for a given stop.
 175       nub_size_t prev_pid_stop_count = ctx.GetProcessStopCount();
 176       bool pid_stop_count_changed =
 177           ctx.SetProcessStopCount(DNBProcessGetStopCount(pid));
 178       if (pid_stop_count_changed) {
 179         remote->FlushSTDIO();
 180
 181         if (ctx.GetProcessStopCount() == 1) {
 182           DNBLogThreadedIf(
 183               LOG_RNB_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s "
 184                                "pid_stop_count %zu (old %zu)) Notify??? no, "
 185                                "first stop...",
 186               __FUNCTION__, (int)initialize, DNBStateAsString(pid_state),
 187               ctx.GetProcessStopCount(), prev_pid_stop_count);
 188         } else {
 189
 190           DNBLogThreadedIf(
 191               LOG_RNB_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s "
 192                                "pid_stop_count %zu (old %zu)) Notify??? YES!!!",
 193               __FUNCTION__, (int)initialize, DNBStateAsString(pid_state),
 194               ctx.GetProcessStopCount(), prev_pid_stop_count);
 195           remote->NotifyThatProcessStopped();
 196         }
 197       } else {
 198         DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s (&remote, initialize=%i)  "
 199                                           "pid_state = %s pid_stop_count %zu "
 200                                           "(old %zu)) Notify??? skipping...",
 201                          __FUNCTION__, (int)initialize,
 202                          DNBStateAsString(pid_state), ctx.GetProcessStopCount(),
 203                          prev_pid_stop_count);
 204       }
 205     }
 206     return eRNBRunLoopModeInferiorExecuting;
 207
 208   case eStateStepping:
 209   case eStateRunning:
 210     return eRNBRunLoopModeInferiorExecuting;
 211
 212   case eStateExited:
 213     remote->HandlePacket_last_signal(NULL);
 214     return eRNBRunLoopModeExit;
 215   case eStateDetached:
 216     return eRNBRunLoopModeExit;
 217   }
 218
 219   // Catch all...
 220   return eRNBRunLoopModeExit;
 221 }
 222 // This function handles the case where our inferior program is stopped and
 223 // we are waiting for gdb remote protocol packets. When a packet occurs that
 224 // makes the inferior run, we need to leave this function with a new state
 225 // as the return code.
 226 RNBRunLoopMode RNBRunLoopInferiorExecuting(RNBRemoteSP &remote) {
 227   DNBLogThreadedIf(LOG_RNB_MINIMAL, "#### %s", __FUNCTION__);
 228   RNBContext &ctx = remote->Context();
 229
 230   // Init our mode and set 'is_running' based on the current process state
 231   RNBRunLoopMode mode = HandleProcessStateChange(remote, true);
 232
 233   while (ctx.ProcessID() != INVALID_NUB_PROCESS) {
 234
 235     std::string set_events_str;
 236     uint32_t event_mask = ctx.NormalEventBits();
 237
 238     if (!ctx.ProcessStateRunning()) {
 239       // Clear the stdio bits if we are not running so we don't send any async
 240       // packets
 241       event_mask &= ~RNBContext::event_proc_stdio_available;
 242     }
 243
 244     // We want to make sure we consume all process state changes and have
 245     // whomever is notifying us to wait for us to reset the event bit before
 246     // continuing.
 247     // ctx.Events().SetResetAckMask (RNBContext::event_proc_state_changed);
 248
 249     DNBLogThreadedIf(LOG_RNB_EVENTS,
 250                      "%s ctx.Events().WaitForSetEvents(0x%08x) ...",
 251                      __FUNCTION__, event_mask);
 252     nub_event_t set_events = ctx.Events().WaitForSetEvents(event_mask);
 253     DNBLogThreadedIf(LOG_RNB_EVENTS,
 254                      "%s ctx.Events().WaitForSetEvents(0x%08x) => 0x%08x (%s)",
 255                      __FUNCTION__, event_mask, set_events,
 256                      ctx.EventsAsString(set_events, set_events_str));
 257
 258     if (set_events) {
 259       if ((set_events & RNBContext::event_proc_thread_exiting) ||
 260           (set_events & RNBContext::event_proc_stdio_available)) {
 261         remote->FlushSTDIO();
 262       }
 263
 264       if (set_events & RNBContext::event_read_packet_available) {
 265         // handleReceivedPacket will take care of resetting the
 266         // event_read_packet_available events when there are no more...
 267         set_events ^= RNBContext::event_read_packet_available;
 268
 269         if (ctx.ProcessStateRunning()) {
 270           if (remote->HandleAsyncPacket() == rnb_not_connected) {
 271             // TODO: connect again? Exit?
 272           }
 273         } else {
 274           if (remote->HandleReceivedPacket() == rnb_not_connected) {
 275             // TODO: connect again? Exit?
 276           }
 277         }
 278       }
 279
 280       if (set_events & RNBContext::event_proc_state_changed) {
 281         mode = HandleProcessStateChange(remote, false);
 282         ctx.Events().ResetEvents(RNBContext::event_proc_state_changed);
 283         set_events ^= RNBContext::event_proc_state_changed;
 284       }
 285
 286       if (set_events & RNBContext::event_proc_thread_exiting) {
 287         mode = eRNBRunLoopModeExit;
 288       }
 289
 290       if (set_events & RNBContext::event_read_thread_exiting) {
 291         // Out remote packet receiving thread exited, exit for now.
 292         if (ctx.HasValidProcessID()) {
 293           // TODO: We should add code that will leave the current process
 294           // in its current state and listen for another connection...
 295           if (ctx.ProcessStateRunning()) {
 296             DNBProcessKill(ctx.ProcessID());
 297           }
 298         }
 299         mode = eRNBRunLoopModeExit;
 300       }
 301     }
 302
 303     // Reset all event bits that weren't reset for now...
 304     if (set_events != 0)
 305       ctx.Events().ResetEvents(set_events);
 306
 307     if (mode != eRNBRunLoopModeInferiorExecuting)
 308       break;
 309   }
 310
 311   return mode;
 312 }
 313
 314 void ASLLogCallback(void *baton, uint32_t flags, const char *format,
 315                     va_list args) {
 316 #if 0
 317         vprintf(format, args);
 318 #endif
 319 }
 320
 321 extern "C" int debug_server_main(int fd) {
 322 #if 1
 323   g_isatty = 0;
 324 #else
 325   g_isatty = ::isatty(STDIN_FILENO);
 326
 327   DNBLogSetDebug(1);
 328   DNBLogSetVerbose(1);
 329   DNBLogSetLogMask(-1);
 330   DNBLogSetLogCallback(ASLLogCallback, NULL);
 331 #endif
 332
 333   signal(SIGPIPE, signal_handler);
 334
 335   g_remoteSP = std::make_shared<RNBRemote>();
 336
 337   RNBRemote *remote = g_remoteSP.get();
 338   if (remote == NULL) {
 339     RNBLogSTDERR("error: failed to create a remote connection class\n");
 340     return -1;
 341   }
 342
 343   RNBRunLoopMode mode = eRNBRunLoopModeGetStartModeFromRemoteProtocol;
 344
 345   while (mode != eRNBRunLoopModeExit) {
 346     switch (mode) {
 347     case eRNBRunLoopModeGetStartModeFromRemoteProtocol:
 348       if (g_remoteSP->Comm().useFD(fd) == rnb_success) {
 349         RNBLogSTDOUT("Starting remote data thread.\n");
 350         g_remoteSP->StartReadRemoteDataThread();
 351
 352         RNBLogSTDOUT("Waiting for start mode from remote.\n");
 353         mode = RNBRunLoopGetStartModeFromRemote(g_remoteSP);
 354       } else {
 355         mode = eRNBRunLoopModeExit;
 356       }
 357       break;
 358
 359     case eRNBRunLoopModeInferiorExecuting:
 360       mode = RNBRunLoopInferiorExecuting(g_remoteSP);
 361       break;
 362
 363     default:
 364       mode = eRNBRunLoopModeExit;
 365       break;
 366
 367     case eRNBRunLoopModeExit:
 368       break;
 369     }
 370   }
 371
 372   g_remoteSP->StopReadRemoteDataThread();
 373   g_remoteSP->Context().SetProcessID(INVALID_NUB_PROCESS);
 374
 375   return 0;
 376 }