contrib/llvm/tools/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp

   1 //===-- ProcessMonitor.cpp ------------------------------------ -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // C Includes
  11 #include <errno.h>
  12 #include <poll.h>
  13 #include <signal.h>
  14 #include <stdint.h>
  15 #include <string.h>
  16 #include <sys/ptrace.h>
  17 #include <sys/socket.h>
  18 #include <sys/types.h>
  19 #include <sys/wait.h>
  20 #include <unistd.h>
  21
  22 // C++ Includes
  23 // Other libraries and framework includes
  24 #include "lldb/Core/RegisterValue.h"
  25 #include "lldb/Core/Scalar.h"
  26 #include "lldb/Host/Host.h"
  27 #include "lldb/Host/PseudoTerminal.h"
  28 #include "lldb/Host/ThreadLauncher.h"
  29 #include "lldb/Target/RegisterContext.h"
  30 #include "lldb/Target/Thread.h"
  31 #include "lldb/Target/UnixSignals.h"
  32 #include "lldb/Utility/Status.h"
  33 #include "llvm/Support/Errno.h"
  34
  35 #include "FreeBSDThread.h"
  36 #include "Plugins/Process/POSIX/CrashReason.h"
  37 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
  38 #include "ProcessFreeBSD.h"
  39 #include "ProcessMonitor.h"
  40
  41 using namespace lldb;
  42 using namespace lldb_private;
  43
  44 // We disable the tracing of ptrace calls for integration builds to avoid the
  45 // additional indirection and checks.
  46 #ifndef LLDB_CONFIGURATION_BUILDANDINTEGRATION
  47 // Wrapper for ptrace to catch errors and log calls.
  48
  49 const char *Get_PT_IO_OP(int op) {
  50   switch (op) {
  51   case PIOD_READ_D:
  52     return "READ_D";
  53   case PIOD_WRITE_D:
  54     return "WRITE_D";
  55   case PIOD_READ_I:
  56     return "READ_I";
  57   case PIOD_WRITE_I:
  58     return "WRITE_I";
  59   default:
  60     return "Unknown op";
  61   }
  62 }
  63
  64 // Wrapper for ptrace to catch errors and log calls. Note that ptrace sets
  65 // errno on error because -1 is reserved as a valid result.
  66 extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data,
  67                           const char *reqName, const char *file, int line) {
  68   long int result;
  69
  70   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
  71
  72   if (log) {
  73     log->Printf("ptrace(%s, %" PRIu64 ", %p, %x) called from file %s line %d",
  74                 reqName, pid, addr, data, file, line);
  75     if (req == PT_IO) {
  76       struct ptrace_io_desc *pi = (struct ptrace_io_desc *)addr;
  77
  78       log->Printf("PT_IO: op=%s offs=%zx size=%zu", Get_PT_IO_OP(pi->piod_op),
  79                   (size_t)pi->piod_offs, pi->piod_len);
  80     }
  81   }
  82
  83   // PtraceDisplayBytes(req, data);
  84
  85   errno = 0;
  86   result = ptrace(req, pid, (caddr_t)addr, data);
  87
  88   // PtraceDisplayBytes(req, data);
  89
  90   if (log && errno != 0) {
  91     const char *str;
  92     switch (errno) {
  93     case ESRCH:
  94       str = "ESRCH";
  95       break;
  96     case EINVAL:
  97       str = "EINVAL";
  98       break;
  99     case EBUSY:
 100       str = "EBUSY";
 101       break;
 102     case EPERM:
 103       str = "EPERM";
 104       break;
 105     default:
 106       str = "<unknown>";
 107     }
 108     log->Printf("ptrace() failed; errno=%d (%s)", errno, str);
 109   }
 110
 111   if (log) {
 112 #ifdef __amd64__
 113     if (req == PT_GETREGS) {
 114       struct reg *r = (struct reg *)addr;
 115
 116       log->Printf("PT_GETREGS: rip=0x%lx rsp=0x%lx rbp=0x%lx rax=0x%lx",
 117                   r->r_rip, r->r_rsp, r->r_rbp, r->r_rax);
 118     }
 119     if (req == PT_GETDBREGS || req == PT_SETDBREGS) {
 120       struct dbreg *r = (struct dbreg *)addr;
 121       char setget = (req == PT_GETDBREGS) ? 'G' : 'S';
 122
 123       for (int i = 0; i <= 7; i++)
 124         log->Printf("PT_%cETDBREGS: dr[%d]=0x%lx", setget, i, r->dr[i]);
 125     }
 126 #endif
 127   }
 128
 129   return result;
 130 }
 131
 132 // Wrapper for ptrace when logging is not required. Sets errno to 0 prior to
 133 // calling ptrace.
 134 extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data) {
 135   long result = 0;
 136   errno = 0;
 137   result = ptrace(req, pid, (caddr_t)addr, data);
 138   return result;
 139 }
 140
 141 #define PTRACE(req, pid, addr, data)                                           \
 142   PtraceWrapper((req), (pid), (addr), (data), #req, __FILE__, __LINE__)
 143 #else
 144 PtraceWrapper((req), (pid), (addr), (data))
 145 #endif
 146
 147 //------------------------------------------------------------------------------
 148 // Static implementations of ProcessMonitor::ReadMemory and
 149 // ProcessMonitor::WriteMemory.  This enables mutual recursion between these
 150 // functions without needed to go thru the thread funnel.
 151
 152 static size_t DoReadMemory(lldb::pid_t pid, lldb::addr_t vm_addr, void *buf,
 153                            size_t size, Status &error) {
 154   struct ptrace_io_desc pi_desc;
 155
 156   pi_desc.piod_op = PIOD_READ_D;
 157   pi_desc.piod_offs = (void *)vm_addr;
 158   pi_desc.piod_addr = buf;
 159   pi_desc.piod_len = size;
 160
 161   if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0) {
 162     error.SetErrorToErrno();
 163     return 0;
 164   }
 165   return pi_desc.piod_len;
 166 }
 167
 168 static size_t DoWriteMemory(lldb::pid_t pid, lldb::addr_t vm_addr,
 169                             const void *buf, size_t size, Status &error) {
 170   struct ptrace_io_desc pi_desc;
 171
 172   pi_desc.piod_op = PIOD_WRITE_D;
 173   pi_desc.piod_offs = (void *)vm_addr;
 174   pi_desc.piod_addr = (void *)buf;
 175   pi_desc.piod_len = size;
 176
 177   if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0) {
 178     error.SetErrorToErrno();
 179     return 0;
 180   }
 181   return pi_desc.piod_len;
 182 }
 183
 184 // Simple helper function to ensure flags are enabled on the given file
 185 // descriptor.
 186 static bool EnsureFDFlags(int fd, int flags, Status &error) {
 187   int status;
 188
 189   if ((status = fcntl(fd, F_GETFL)) == -1) {
 190     error.SetErrorToErrno();
 191     return false;
 192   }
 193
 194   if (fcntl(fd, F_SETFL, status | flags) == -1) {
 195     error.SetErrorToErrno();
 196     return false;
 197   }
 198
 199   return true;
 200 }
 201
 202 //------------------------------------------------------------------------------
 203 /// @class Operation
 204 /// Represents a ProcessMonitor operation.
 205 ///
 206 /// Under FreeBSD, it is not possible to ptrace() from any other thread but
 207 /// the one that spawned or attached to the process from the start.
 208 /// Therefore, when a ProcessMonitor is asked to deliver or change the state
 209 /// of an inferior process the operation must be "funneled" to a specific
 210 /// thread to perform the task.  The Operation class provides an abstract base
 211 /// for all services the ProcessMonitor must perform via the single virtual
 212 /// function Execute, thus encapsulating the code that needs to run in the
 213 /// privileged context.
 214 class Operation {
 215 public:
 216   virtual ~Operation() {}
 217   virtual void Execute(ProcessMonitor *monitor) = 0;
 218 };
 219
 220 //------------------------------------------------------------------------------
 221 /// @class ReadOperation
 222 /// Implements ProcessMonitor::ReadMemory.
 223 class ReadOperation : public Operation {
 224 public:
 225   ReadOperation(lldb::addr_t addr, void *buff, size_t size, Status &error,
 226                 size_t &result)
 227       : m_addr(addr), m_buff(buff), m_size(size), m_error(error),
 228         m_result(result) {}
 229
 230   void Execute(ProcessMonitor *monitor);
 231
 232 private:
 233   lldb::addr_t m_addr;
 234   void *m_buff;
 235   size_t m_size;
 236   Status &m_error;
 237   size_t &m_result;
 238 };
 239
 240 void ReadOperation::Execute(ProcessMonitor *monitor) {
 241   lldb::pid_t pid = monitor->GetPID();
 242
 243   m_result = DoReadMemory(pid, m_addr, m_buff, m_size, m_error);
 244 }
 245
 246 //------------------------------------------------------------------------------
 247 /// @class WriteOperation
 248 /// Implements ProcessMonitor::WriteMemory.
 249 class WriteOperation : public Operation {
 250 public:
 251   WriteOperation(lldb::addr_t addr, const void *buff, size_t size,
 252                  Status &error, size_t &result)
 253       : m_addr(addr), m_buff(buff), m_size(size), m_error(error),
 254         m_result(result) {}
 255
 256   void Execute(ProcessMonitor *monitor);
 257
 258 private:
 259   lldb::addr_t m_addr;
 260   const void *m_buff;
 261   size_t m_size;
 262   Status &m_error;
 263   size_t &m_result;
 264 };
 265
 266 void WriteOperation::Execute(ProcessMonitor *monitor) {
 267   lldb::pid_t pid = monitor->GetPID();
 268
 269   m_result = DoWriteMemory(pid, m_addr, m_buff, m_size, m_error);
 270 }
 271
 272 //------------------------------------------------------------------------------
 273 /// @class ReadRegOperation
 274 /// Implements ProcessMonitor::ReadRegisterValue.
 275 class ReadRegOperation : public Operation {
 276 public:
 277   ReadRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
 278                    RegisterValue &value, bool &result)
 279       : m_tid(tid), m_offset(offset), m_size(size), m_value(value),
 280         m_result(result) {}
 281
 282   void Execute(ProcessMonitor *monitor);
 283
 284 private:
 285   lldb::tid_t m_tid;
 286   unsigned m_offset;
 287   unsigned m_size;
 288   RegisterValue &m_value;
 289   bool &m_result;
 290 };
 291
 292 void ReadRegOperation::Execute(ProcessMonitor *monitor) {
 293   struct reg regs;
 294   int rc;
 295
 296   if ((rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)&regs, 0)) < 0) {
 297     m_result = false;
 298   } else {
 299     // 'struct reg' contains only 32- or 64-bit register values.  Punt on
 300     // others.  Also, not all entries may be uintptr_t sized, such as 32-bit
 301     // processes on powerpc64 (probably the same for i386 on amd64)
 302     if (m_size == sizeof(uint32_t))
 303       m_value = *(uint32_t *)(((caddr_t)&regs) + m_offset);
 304     else if (m_size == sizeof(uint64_t))
 305       m_value = *(uint64_t *)(((caddr_t)&regs) + m_offset);
 306     else
 307       memcpy((void *)&m_value, (((caddr_t)&regs) + m_offset), m_size);
 308     m_result = true;
 309   }
 310 }
 311
 312 //------------------------------------------------------------------------------
 313 /// @class WriteRegOperation
 314 /// Implements ProcessMonitor::WriteRegisterValue.
 315 class WriteRegOperation : public Operation {
 316 public:
 317   WriteRegOperation(lldb::tid_t tid, unsigned offset,
 318                     const RegisterValue &value, bool &result)
 319       : m_tid(tid), m_offset(offset), m_value(value), m_result(result) {}
 320
 321   void Execute(ProcessMonitor *monitor);
 322
 323 private:
 324   lldb::tid_t m_tid;
 325   unsigned m_offset;
 326   const RegisterValue &m_value;
 327   bool &m_result;
 328 };
 329
 330 void WriteRegOperation::Execute(ProcessMonitor *monitor) {
 331   struct reg regs;
 332
 333   if (PTRACE(PT_GETREGS, m_tid, (caddr_t)&regs, 0) < 0) {
 334     m_result = false;
 335     return;
 336   }
 337   *(uintptr_t *)(((caddr_t)&regs) + m_offset) =
 338       (uintptr_t)m_value.GetAsUInt64();
 339   if (PTRACE(PT_SETREGS, m_tid, (caddr_t)&regs, 0) < 0)
 340     m_result = false;
 341   else
 342     m_result = true;
 343 }
 344
 345 //------------------------------------------------------------------------------
 346 /// @class ReadDebugRegOperation
 347 /// Implements ProcessMonitor::ReadDebugRegisterValue.
 348 class ReadDebugRegOperation : public Operation {
 349 public:
 350   ReadDebugRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
 351                         RegisterValue &value, bool &result)
 352       : m_tid(tid), m_offset(offset), m_size(size), m_value(value),
 353         m_result(result) {}
 354
 355   void Execute(ProcessMonitor *monitor);
 356
 357 private:
 358   lldb::tid_t m_tid;
 359   unsigned m_offset;
 360   unsigned m_size;
 361   RegisterValue &m_value;
 362   bool &m_result;
 363 };
 364
 365 void ReadDebugRegOperation::Execute(ProcessMonitor *monitor) {
 366   struct dbreg regs;
 367   int rc;
 368
 369   if ((rc = PTRACE(PT_GETDBREGS, m_tid, (caddr_t)&regs, 0)) < 0) {
 370     m_result = false;
 371   } else {
 372     if (m_size == sizeof(uintptr_t))
 373       m_value = *(uintptr_t *)(((caddr_t)&regs) + m_offset);
 374     else
 375       memcpy((void *)&m_value, (((caddr_t)&regs) + m_offset), m_size);
 376     m_result = true;
 377   }
 378 }
 379
 380 //------------------------------------------------------------------------------
 381 /// @class WriteDebugRegOperation
 382 /// Implements ProcessMonitor::WriteDebugRegisterValue.
 383 class WriteDebugRegOperation : public Operation {
 384 public:
 385   WriteDebugRegOperation(lldb::tid_t tid, unsigned offset,
 386                          const RegisterValue &value, bool &result)
 387       : m_tid(tid), m_offset(offset), m_value(value), m_result(result) {}
 388
 389   void Execute(ProcessMonitor *monitor);
 390
 391 private:
 392   lldb::tid_t m_tid;
 393   unsigned m_offset;
 394   const RegisterValue &m_value;
 395   bool &m_result;
 396 };
 397
 398 void WriteDebugRegOperation::Execute(ProcessMonitor *monitor) {
 399   struct dbreg regs;
 400
 401   if (PTRACE(PT_GETDBREGS, m_tid, (caddr_t)&regs, 0) < 0) {
 402     m_result = false;
 403     return;
 404   }
 405   *(uintptr_t *)(((caddr_t)&regs) + m_offset) =
 406       (uintptr_t)m_value.GetAsUInt64();
 407   if (PTRACE(PT_SETDBREGS, m_tid, (caddr_t)&regs, 0) < 0)
 408     m_result = false;
 409   else
 410     m_result = true;
 411 }
 412
 413 //------------------------------------------------------------------------------
 414 /// @class ReadGPROperation
 415 /// Implements ProcessMonitor::ReadGPR.
 416 class ReadGPROperation : public Operation {
 417 public:
 418   ReadGPROperation(lldb::tid_t tid, void *buf, bool &result)
 419       : m_tid(tid), m_buf(buf), m_result(result) {}
 420
 421   void Execute(ProcessMonitor *monitor);
 422
 423 private:
 424   lldb::tid_t m_tid;
 425   void *m_buf;
 426   bool &m_result;
 427 };
 428
 429 void ReadGPROperation::Execute(ProcessMonitor *monitor) {
 430   int rc;
 431
 432   errno = 0;
 433   rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)m_buf, 0);
 434   if (errno != 0)
 435     m_result = false;
 436   else
 437     m_result = true;
 438 }
 439
 440 //------------------------------------------------------------------------------
 441 /// @class ReadFPROperation
 442 /// Implements ProcessMonitor::ReadFPR.
 443 class ReadFPROperation : public Operation {
 444 public:
 445   ReadFPROperation(lldb::tid_t tid, void *buf, bool &result)
 446       : m_tid(tid), m_buf(buf), m_result(result) {}
 447
 448   void Execute(ProcessMonitor *monitor);
 449
 450 private:
 451   lldb::tid_t m_tid;
 452   void *m_buf;
 453   bool &m_result;
 454 };
 455
 456 void ReadFPROperation::Execute(ProcessMonitor *monitor) {
 457   if (PTRACE(PT_GETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
 458     m_result = false;
 459   else
 460     m_result = true;
 461 }
 462
 463 //------------------------------------------------------------------------------
 464 /// @class WriteGPROperation
 465 /// Implements ProcessMonitor::WriteGPR.
 466 class WriteGPROperation : public Operation {
 467 public:
 468   WriteGPROperation(lldb::tid_t tid, void *buf, bool &result)
 469       : m_tid(tid), m_buf(buf), m_result(result) {}
 470
 471   void Execute(ProcessMonitor *monitor);
 472
 473 private:
 474   lldb::tid_t m_tid;
 475   void *m_buf;
 476   bool &m_result;
 477 };
 478
 479 void WriteGPROperation::Execute(ProcessMonitor *monitor) {
 480   if (PTRACE(PT_SETREGS, m_tid, (caddr_t)m_buf, 0) < 0)
 481     m_result = false;
 482   else
 483     m_result = true;
 484 }
 485
 486 //------------------------------------------------------------------------------
 487 /// @class WriteFPROperation
 488 /// Implements ProcessMonitor::WriteFPR.
 489 class WriteFPROperation : public Operation {
 490 public:
 491   WriteFPROperation(lldb::tid_t tid, void *buf, bool &result)
 492       : m_tid(tid), m_buf(buf), m_result(result) {}
 493
 494   void Execute(ProcessMonitor *monitor);
 495
 496 private:
 497   lldb::tid_t m_tid;
 498   void *m_buf;
 499   bool &m_result;
 500 };
 501
 502 void WriteFPROperation::Execute(ProcessMonitor *monitor) {
 503   if (PTRACE(PT_SETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
 504     m_result = false;
 505   else
 506     m_result = true;
 507 }
 508
 509 //------------------------------------------------------------------------------
 510 /// @class ResumeOperation
 511 /// Implements ProcessMonitor::Resume.
 512 class ResumeOperation : public Operation {
 513 public:
 514   ResumeOperation(uint32_t signo, bool &result)
 515       : m_signo(signo), m_result(result) {}
 516
 517   void Execute(ProcessMonitor *monitor);
 518
 519 private:
 520   uint32_t m_signo;
 521   bool &m_result;
 522 };
 523
 524 void ResumeOperation::Execute(ProcessMonitor *monitor) {
 525   lldb::pid_t pid = monitor->GetPID();
 526   int data = 0;
 527
 528   if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
 529     data = m_signo;
 530
 531   if (PTRACE(PT_CONTINUE, pid, (caddr_t)1, data)) {
 532     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 533     LLDB_LOG(log, "ResumeOperation ({0}) failed: {1}", pid,
 534              llvm::sys::StrError(errno));
 535     m_result = false;
 536   } else
 537     m_result = true;
 538 }
 539
 540 //------------------------------------------------------------------------------
 541 /// @class SingleStepOperation
 542 /// Implements ProcessMonitor::SingleStep.
 543 class SingleStepOperation : public Operation {
 544 public:
 545   SingleStepOperation(uint32_t signo, bool &result)
 546       : m_signo(signo), m_result(result) {}
 547
 548   void Execute(ProcessMonitor *monitor);
 549
 550 private:
 551   uint32_t m_signo;
 552   bool &m_result;
 553 };
 554
 555 void SingleStepOperation::Execute(ProcessMonitor *monitor) {
 556   lldb::pid_t pid = monitor->GetPID();
 557   int data = 0;
 558
 559   if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
 560     data = m_signo;
 561
 562   if (PTRACE(PT_STEP, pid, NULL, data))
 563     m_result = false;
 564   else
 565     m_result = true;
 566 }
 567
 568 //------------------------------------------------------------------------------
 569 /// @class LwpInfoOperation
 570 /// Implements ProcessMonitor::GetLwpInfo.
 571 class LwpInfoOperation : public Operation {
 572 public:
 573   LwpInfoOperation(lldb::tid_t tid, void *info, bool &result, int &ptrace_err)
 574       : m_tid(tid), m_info(info), m_result(result), m_err(ptrace_err) {}
 575
 576   void Execute(ProcessMonitor *monitor);
 577
 578 private:
 579   lldb::tid_t m_tid;
 580   void *m_info;
 581   bool &m_result;
 582   int &m_err;
 583 };
 584
 585 void LwpInfoOperation::Execute(ProcessMonitor *monitor) {
 586   struct ptrace_lwpinfo plwp;
 587
 588   if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp))) {
 589     m_result = false;
 590     m_err = errno;
 591   } else {
 592     memcpy(m_info, &plwp, sizeof(plwp));
 593     m_result = true;
 594   }
 595 }
 596
 597 //------------------------------------------------------------------------------
 598 /// @class ThreadSuspendOperation
 599 /// Implements ProcessMonitor::ThreadSuspend.
 600 class ThreadSuspendOperation : public Operation {
 601 public:
 602   ThreadSuspendOperation(lldb::tid_t tid, bool suspend, bool &result)
 603       : m_tid(tid), m_suspend(suspend), m_result(result) {}
 604
 605   void Execute(ProcessMonitor *monitor);
 606
 607 private:
 608   lldb::tid_t m_tid;
 609   bool m_suspend;
 610   bool &m_result;
 611 };
 612
 613 void ThreadSuspendOperation::Execute(ProcessMonitor *monitor) {
 614   m_result = !PTRACE(m_suspend ? PT_SUSPEND : PT_RESUME, m_tid, NULL, 0);
 615 }
 616
 617 //------------------------------------------------------------------------------
 618 /// @class EventMessageOperation
 619 /// Implements ProcessMonitor::GetEventMessage.
 620 class EventMessageOperation : public Operation {
 621 public:
 622   EventMessageOperation(lldb::tid_t tid, unsigned long *message, bool &result)
 623       : m_tid(tid), m_message(message), m_result(result) {}
 624
 625   void Execute(ProcessMonitor *monitor);
 626
 627 private:
 628   lldb::tid_t m_tid;
 629   unsigned long *m_message;
 630   bool &m_result;
 631 };
 632
 633 void EventMessageOperation::Execute(ProcessMonitor *monitor) {
 634   struct ptrace_lwpinfo plwp;
 635
 636   if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp)))
 637     m_result = false;
 638   else {
 639     if (plwp.pl_flags & PL_FLAG_FORKED) {
 640       *m_message = plwp.pl_child_pid;
 641       m_result = true;
 642     } else
 643       m_result = false;
 644   }
 645 }
 646
 647 //------------------------------------------------------------------------------
 648 /// @class KillOperation
 649 /// Implements ProcessMonitor::Kill.
 650 class KillOperation : public Operation {
 651 public:
 652   KillOperation(bool &result) : m_result(result) {}
 653
 654   void Execute(ProcessMonitor *monitor);
 655
 656 private:
 657   bool &m_result;
 658 };
 659
 660 void KillOperation::Execute(ProcessMonitor *monitor) {
 661   lldb::pid_t pid = monitor->GetPID();
 662
 663   if (PTRACE(PT_KILL, pid, NULL, 0))
 664     m_result = false;
 665   else
 666     m_result = true;
 667 }
 668
 669 //------------------------------------------------------------------------------
 670 /// @class DetachOperation
 671 /// Implements ProcessMonitor::Detach.
 672 class DetachOperation : public Operation {
 673 public:
 674   DetachOperation(Status &result) : m_error(result) {}
 675
 676   void Execute(ProcessMonitor *monitor);
 677
 678 private:
 679   Status &m_error;
 680 };
 681
 682 void DetachOperation::Execute(ProcessMonitor *monitor) {
 683   lldb::pid_t pid = monitor->GetPID();
 684
 685   if (PTRACE(PT_DETACH, pid, NULL, 0) < 0)
 686     m_error.SetErrorToErrno();
 687 }
 688
 689 ProcessMonitor::OperationArgs::OperationArgs(ProcessMonitor *monitor)
 690     : m_monitor(monitor) {
 691   sem_init(&m_semaphore, 0, 0);
 692 }
 693
 694 ProcessMonitor::OperationArgs::~OperationArgs() { sem_destroy(&m_semaphore); }
 695
 696 ProcessMonitor::LaunchArgs::LaunchArgs(ProcessMonitor *monitor,
 697                                        lldb_private::Module *module,
 698                                        char const **argv, Environment env,
 699                                        const FileSpec &stdin_file_spec,
 700                                        const FileSpec &stdout_file_spec,
 701                                        const FileSpec &stderr_file_spec,
 702                                        const FileSpec &working_dir)
 703     : OperationArgs(monitor), m_module(module), m_argv(argv),
 704       m_env(std::move(env)), m_stdin_file_spec(stdin_file_spec),
 705       m_stdout_file_spec(stdout_file_spec),
 706       m_stderr_file_spec(stderr_file_spec), m_working_dir(working_dir) {}
 707
 708 ProcessMonitor::LaunchArgs::~LaunchArgs() {}
 709
 710 ProcessMonitor::AttachArgs::AttachArgs(ProcessMonitor *monitor, lldb::pid_t pid)
 711     : OperationArgs(monitor), m_pid(pid) {}
 712
 713 ProcessMonitor::AttachArgs::~AttachArgs() {}
 714
 715 //------------------------------------------------------------------------------
 716 /// The basic design of the ProcessMonitor is built around two threads.
 717 ///
 718 /// One thread (@see SignalThread) simply blocks on a call to waitpid()
 719 /// looking for changes in the debugee state.  When a change is detected a
 720 /// ProcessMessage is sent to the associated ProcessFreeBSD instance.  This
 721 /// thread "drives" state changes in the debugger.
 722 ///
 723 /// The second thread (@see OperationThread) is responsible for two things 1)
 724 /// launching or attaching to the inferior process, and then 2) servicing
 725 /// operations such as register reads/writes, stepping, etc.  See the comments
 726 /// on the Operation class for more info as to why this is needed.
 727 ProcessMonitor::ProcessMonitor(
 728     ProcessFreeBSD *process, Module *module, const char *argv[],
 729     Environment env, const FileSpec &stdin_file_spec,
 730     const FileSpec &stdout_file_spec, const FileSpec &stderr_file_spec,
 731     const FileSpec &working_dir,
 732     const lldb_private::ProcessLaunchInfo & /* launch_info */,
 733     lldb_private::Status &error)
 734     : m_process(static_cast<ProcessFreeBSD *>(process)),
 735       m_pid(LLDB_INVALID_PROCESS_ID), m_terminal_fd(-1), m_operation(0) {
 736   using namespace std::placeholders;
 737
 738   std::unique_ptr<LaunchArgs> args(
 739       new LaunchArgs(this, module, argv, std::move(env), stdin_file_spec,
 740                      stdout_file_spec, stderr_file_spec, working_dir));
 741
 742   sem_init(&m_operation_pending, 0, 0);
 743   sem_init(&m_operation_done, 0, 0);
 744
 745   StartLaunchOpThread(args.get(), error);
 746   if (!error.Success())
 747     return;
 748
 749   if (llvm::sys::RetryAfterSignal(-1, sem_wait, &args->m_semaphore) == -1) {
 750     error.SetErrorToErrno();
 751     return;
 752   }
 753
 754   // Check that the launch was a success.
 755   if (!args->m_error.Success()) {
 756     StopOpThread();
 757     error = args->m_error;
 758     return;
 759   }
 760
 761   // Finally, start monitoring the child process for change in state.
 762   m_monitor_thread = Host::StartMonitoringChildProcess(
 763       std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4),
 764       GetPID(), true);
 765   if (!m_monitor_thread.IsJoinable()) {
 766     error.SetErrorToGenericError();
 767     error.SetErrorString("Process launch failed.");
 768     return;
 769   }
 770 }
 771
 772 ProcessMonitor::ProcessMonitor(ProcessFreeBSD *process, lldb::pid_t pid,
 773                                lldb_private::Status &error)
 774     : m_process(static_cast<ProcessFreeBSD *>(process)), m_pid(pid),
 775       m_terminal_fd(-1), m_operation(0) {
 776   using namespace std::placeholders;
 777
 778   sem_init(&m_operation_pending, 0, 0);
 779   sem_init(&m_operation_done, 0, 0);
 780
 781   std::unique_ptr<AttachArgs> args(new AttachArgs(this, pid));
 782
 783   StartAttachOpThread(args.get(), error);
 784   if (!error.Success())
 785     return;
 786
 787   if (llvm::sys::RetryAfterSignal(-1, sem_wait, &args->m_semaphore) == -1) {
 788     error.SetErrorToErrno();
 789     return;
 790   }
 791
 792   // Check that the attach was a success.
 793   if (!args->m_error.Success()) {
 794     StopOpThread();
 795     error = args->m_error;
 796     return;
 797   }
 798
 799   // Finally, start monitoring the child process for change in state.
 800   m_monitor_thread = Host::StartMonitoringChildProcess(
 801       std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4),
 802       GetPID(), true);
 803   if (!m_monitor_thread.IsJoinable()) {
 804     error.SetErrorToGenericError();
 805     error.SetErrorString("Process attach failed.");
 806     return;
 807   }
 808 }
 809
 810 ProcessMonitor::~ProcessMonitor() { StopMonitor(); }
 811
 812 //------------------------------------------------------------------------------
 813 // Thread setup and tear down.
 814 void ProcessMonitor::StartLaunchOpThread(LaunchArgs *args, Status &error) {
 815   static const char *g_thread_name = "lldb.process.freebsd.operation";
 816
 817   if (m_operation_thread.IsJoinable())
 818     return;
 819
 820   m_operation_thread =
 821       ThreadLauncher::LaunchThread(g_thread_name, LaunchOpThread, args, &error);
 822 }
 823
 824 void *ProcessMonitor::LaunchOpThread(void *arg) {
 825   LaunchArgs *args = static_cast<LaunchArgs *>(arg);
 826
 827   if (!Launch(args)) {
 828     sem_post(&args->m_semaphore);
 829     return NULL;
 830   }
 831
 832   ServeOperation(args);
 833   return NULL;
 834 }
 835
 836 bool ProcessMonitor::Launch(LaunchArgs *args) {
 837   ProcessMonitor *monitor = args->m_monitor;
 838   ProcessFreeBSD &process = monitor->GetProcess();
 839   const char **argv = args->m_argv;
 840   const FileSpec &stdin_file_spec = args->m_stdin_file_spec;
 841   const FileSpec &stdout_file_spec = args->m_stdout_file_spec;
 842   const FileSpec &stderr_file_spec = args->m_stderr_file_spec;
 843   const FileSpec &working_dir = args->m_working_dir;
 844
 845   PseudoTerminal terminal;
 846   const size_t err_len = 1024;
 847   char err_str[err_len];
 848   ::pid_t pid;
 849
 850   // Propagate the environment if one is not supplied.
 851   Environment::Envp envp =
 852       (args->m_env.empty() ? Host::GetEnvironment() : args->m_env).getEnvp();
 853
 854   if ((pid = terminal.Fork(err_str, err_len)) == -1) {
 855     args->m_error.SetErrorToGenericError();
 856     args->m_error.SetErrorString("Process fork failed.");
 857     goto FINISH;
 858   }
 859
 860   // Recognized child exit status codes.
 861   enum {
 862     ePtraceFailed = 1,
 863     eDupStdinFailed,
 864     eDupStdoutFailed,
 865     eDupStderrFailed,
 866     eChdirFailed,
 867     eExecFailed,
 868     eSetGidFailed
 869   };
 870
 871   // Child process.
 872   if (pid == 0) {
 873     // Trace this process.
 874     if (PTRACE(PT_TRACE_ME, 0, NULL, 0) < 0)
 875       exit(ePtraceFailed);
 876
 877     // terminal has already dupped the tty descriptors to stdin/out/err. This
 878     // closes original fd from which they were copied (and avoids leaking
 879     // descriptors to the debugged process.
 880     terminal.CloseSlaveFileDescriptor();
 881
 882     // Do not inherit setgid powers.
 883     if (setgid(getgid()) != 0)
 884       exit(eSetGidFailed);
 885
 886     // Let us have our own process group.
 887     setpgid(0, 0);
 888
 889     // Dup file descriptors if needed.
 890     //
 891     // FIXME: If two or more of the paths are the same we needlessly open
 892     // the same file multiple times.
 893     if (stdin_file_spec)
 894       if (!DupDescriptor(stdin_file_spec, STDIN_FILENO, O_RDONLY))
 895         exit(eDupStdinFailed);
 896
 897     if (stdout_file_spec)
 898       if (!DupDescriptor(stdout_file_spec, STDOUT_FILENO, O_WRONLY | O_CREAT))
 899         exit(eDupStdoutFailed);
 900
 901     if (stderr_file_spec)
 902       if (!DupDescriptor(stderr_file_spec, STDERR_FILENO, O_WRONLY | O_CREAT))
 903         exit(eDupStderrFailed);
 904
 905     // Change working directory
 906     if (working_dir && 0 != ::chdir(working_dir.GetCString()))
 907       exit(eChdirFailed);
 908
 909     // Execute.  We should never return.
 910     execve(argv[0], const_cast<char *const *>(argv), envp);
 911     exit(eExecFailed);
 912   }
 913
 914   // Wait for the child process to to trap on its call to execve.
 915   ::pid_t wpid;
 916   int status;
 917   if ((wpid = waitpid(pid, &status, 0)) < 0) {
 918     args->m_error.SetErrorToErrno();
 919     goto FINISH;
 920   } else if (WIFEXITED(status)) {
 921     // open, dup or execve likely failed for some reason.
 922     args->m_error.SetErrorToGenericError();
 923     switch (WEXITSTATUS(status)) {
 924     case ePtraceFailed:
 925       args->m_error.SetErrorString("Child ptrace failed.");
 926       break;
 927     case eDupStdinFailed:
 928       args->m_error.SetErrorString("Child open stdin failed.");
 929       break;
 930     case eDupStdoutFailed:
 931       args->m_error.SetErrorString("Child open stdout failed.");
 932       break;
 933     case eDupStderrFailed:
 934       args->m_error.SetErrorString("Child open stderr failed.");
 935       break;
 936     case eChdirFailed:
 937       args->m_error.SetErrorString("Child failed to set working directory.");
 938       break;
 939     case eExecFailed:
 940       args->m_error.SetErrorString("Child exec failed.");
 941       break;
 942     case eSetGidFailed:
 943       args->m_error.SetErrorString("Child setgid failed.");
 944       break;
 945     default:
 946       args->m_error.SetErrorString("Child returned unknown exit status.");
 947       break;
 948     }
 949     goto FINISH;
 950   }
 951   assert(WIFSTOPPED(status) && wpid == (::pid_t)pid &&
 952          "Could not sync with inferior process.");
 953
 954 #ifdef notyet
 955   // Have the child raise an event on exit.  This is used to keep the child in
 956   // limbo until it is destroyed.
 957   if (PTRACE(PTRACE_SETOPTIONS, pid, NULL, PTRACE_O_TRACEEXIT) < 0) {
 958     args->m_error.SetErrorToErrno();
 959     goto FINISH;
 960   }
 961 #endif
 962   // Release the master terminal descriptor and pass it off to the
 963   // ProcessMonitor instance.  Similarly stash the inferior pid.
 964   monitor->m_terminal_fd = terminal.ReleaseMasterFileDescriptor();
 965   monitor->m_pid = pid;
 966
 967   // Set the terminal fd to be in non blocking mode (it simplifies the
 968   // implementation of ProcessFreeBSD::GetSTDOUT to have a non-blocking
 969   // descriptor to read from).
 970   if (!EnsureFDFlags(monitor->m_terminal_fd, O_NONBLOCK, args->m_error))
 971     goto FINISH;
 972
 973   process.SendMessage(ProcessMessage::Attach(pid));
 974
 975 FINISH:
 976   return args->m_error.Success();
 977 }
 978
 979 void ProcessMonitor::StartAttachOpThread(AttachArgs *args,
 980                                          lldb_private::Status &error) {
 981   static const char *g_thread_name = "lldb.process.freebsd.operation";
 982
 983   if (m_operation_thread.IsJoinable())
 984     return;
 985
 986   m_operation_thread =
 987       ThreadLauncher::LaunchThread(g_thread_name, AttachOpThread, args, &error);
 988 }
 989
 990 void *ProcessMonitor::AttachOpThread(void *arg) {
 991   AttachArgs *args = static_cast<AttachArgs *>(arg);
 992
 993   Attach(args);
 994
 995   ServeOperation(args);
 996   return NULL;
 997 }
 998
 999 void ProcessMonitor::Attach(AttachArgs *args) {
1000   lldb::pid_t pid = args->m_pid;
1001
1002   ProcessMonitor *monitor = args->m_monitor;
1003   ProcessFreeBSD &process = monitor->GetProcess();
1004
1005   if (pid <= 1) {
1006     args->m_error.SetErrorToGenericError();
1007     args->m_error.SetErrorString("Attaching to process 1 is not allowed.");
1008     return;
1009   }
1010
1011   // Attach to the requested process.
1012   if (PTRACE(PT_ATTACH, pid, NULL, 0) < 0) {
1013     args->m_error.SetErrorToErrno();
1014     return;
1015   }
1016
1017   int status;
1018   if ((status = waitpid(pid, NULL, 0)) < 0) {
1019     args->m_error.SetErrorToErrno();
1020     return;
1021   }
1022
1023   process.SendMessage(ProcessMessage::Attach(pid));
1024 }
1025
1026 size_t
1027 ProcessMonitor::GetCurrentThreadIDs(std::vector<lldb::tid_t> &thread_ids) {
1028   lwpid_t *tids;
1029   int tdcnt;
1030
1031   thread_ids.clear();
1032
1033   tdcnt = PTRACE(PT_GETNUMLWPS, m_pid, NULL, 0);
1034   if (tdcnt <= 0)
1035     return 0;
1036   tids = (lwpid_t *)malloc(tdcnt * sizeof(*tids));
1037   if (tids == NULL)
1038     return 0;
1039   if (PTRACE(PT_GETLWPLIST, m_pid, (void *)tids, tdcnt) < 0) {
1040     free(tids);
1041     return 0;
1042   }
1043   thread_ids = std::vector<lldb::tid_t>(tids, tids + tdcnt);
1044   free(tids);
1045   return thread_ids.size();
1046 }
1047
1048 bool ProcessMonitor::MonitorCallback(ProcessMonitor *monitor, lldb::pid_t pid,
1049                                      bool exited, int signal, int status) {
1050   ProcessMessage message;
1051   ProcessFreeBSD *process = monitor->m_process;
1052   assert(process);
1053   bool stop_monitoring;
1054   struct ptrace_lwpinfo plwp;
1055   int ptrace_err;
1056
1057   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1058
1059   if (exited) {
1060     if (log)
1061       log->Printf("ProcessMonitor::%s() got exit signal, tid = %" PRIu64,
1062                   __FUNCTION__, pid);
1063     message = ProcessMessage::Exit(pid, status);
1064     process->SendMessage(message);
1065     return pid == process->GetID();
1066   }
1067
1068   if (!monitor->GetLwpInfo(pid, &plwp, ptrace_err))
1069     stop_monitoring = true; // pid is gone.  Bail.
1070   else {
1071     switch (plwp.pl_siginfo.si_signo) {
1072     case SIGTRAP:
1073       message = MonitorSIGTRAP(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
1074       break;
1075
1076     default:
1077       message = MonitorSignal(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
1078       break;
1079     }
1080
1081     process->SendMessage(message);
1082     stop_monitoring = message.GetKind() == ProcessMessage::eExitMessage;
1083   }
1084
1085   return stop_monitoring;
1086 }
1087
1088 ProcessMessage ProcessMonitor::MonitorSIGTRAP(ProcessMonitor *monitor,
1089                                               const siginfo_t *info,
1090                                               lldb::tid_t tid) {
1091   ProcessMessage message;
1092
1093   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1094
1095   assert(monitor);
1096   assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!");
1097
1098   switch (info->si_code) {
1099   default:
1100     assert(false && "Unexpected SIGTRAP code!");
1101     break;
1102
1103   case (SIGTRAP /* | (PTRACE_EVENT_EXIT << 8) */): {
1104     // The inferior process is about to exit.  Maintain the process in a state
1105     // of "limbo" until we are explicitly commanded to detach, destroy, resume,
1106     // etc.
1107     unsigned long data = 0;
1108     if (!monitor->GetEventMessage(tid, &data))
1109       data = -1;
1110     if (log)
1111       log->Printf("ProcessMonitor::%s() received exit? event, data = %lx, tid "
1112                   "= %" PRIu64,
1113                   __FUNCTION__, data, tid);
1114     message = ProcessMessage::Limbo(tid, (data >> 8));
1115     break;
1116   }
1117
1118   case 0:
1119   case TRAP_TRACE:
1120 #ifdef TRAP_CAP
1121   // Map TRAP_CAP to a trace trap in the absense of a more specific handler.
1122   case TRAP_CAP:
1123 #endif
1124     if (log)
1125       log->Printf("ProcessMonitor::%s() received trace event, tid = %" PRIu64
1126                   "  : si_code = %d",
1127                   __FUNCTION__, tid, info->si_code);
1128     message = ProcessMessage::Trace(tid);
1129     break;
1130
1131   case SI_KERNEL:
1132   case TRAP_BRKPT:
1133     if (monitor->m_process->IsSoftwareStepBreakpoint(tid)) {
1134       if (log)
1135         log->Printf("ProcessMonitor::%s() received sw single step breakpoint "
1136                     "event, tid = %" PRIu64,
1137                     __FUNCTION__, tid);
1138       message = ProcessMessage::Trace(tid);
1139     } else {
1140       if (log)
1141         log->Printf(
1142             "ProcessMonitor::%s() received breakpoint event, tid = %" PRIu64,
1143             __FUNCTION__, tid);
1144       message = ProcessMessage::Break(tid);
1145     }
1146     break;
1147   }
1148
1149   return message;
1150 }
1151
1152 ProcessMessage ProcessMonitor::MonitorSignal(ProcessMonitor *monitor,
1153                                              const siginfo_t *info,
1154                                              lldb::tid_t tid) {
1155   ProcessMessage message;
1156   int signo = info->si_signo;
1157
1158   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1159
1160   // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
1161   // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a kill(2)
1162   // or raise(3).  Similarly for tgkill(2) on FreeBSD.
1163   //
1164   // IOW, user generated signals never generate what we consider to be a
1165   // "crash".
1166   //
1167   // Similarly, ACK signals generated by this monitor.
1168   if (info->si_code == SI_USER) {
1169     if (log)
1170       log->Printf(
1171           "ProcessMonitor::%s() received signal %s with code %s, pid = %d",
1172           __FUNCTION__,
1173           monitor->m_process->GetUnixSignals()->GetSignalAsCString(signo),
1174           "SI_USER", info->si_pid);
1175     if (info->si_pid == getpid())
1176       return ProcessMessage::SignalDelivered(tid, signo);
1177     else
1178       return ProcessMessage::Signal(tid, signo);
1179   }
1180
1181   if (log)
1182     log->Printf(
1183         "ProcessMonitor::%s() received signal %s", __FUNCTION__,
1184         monitor->m_process->GetUnixSignals()->GetSignalAsCString(signo));
1185
1186   switch (signo) {
1187   case SIGSEGV:
1188   case SIGILL:
1189   case SIGFPE:
1190   case SIGBUS:
1191     lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr);
1192     const auto reason = GetCrashReason(*info);
1193     if (reason != CrashReason::eInvalidCrashReason) {
1194       return ProcessMessage::Crash(tid, reason, signo, fault_addr);
1195     } // else; Use atleast si_signo info for other si_code
1196   }
1197
1198   // Everything else is "normal" and does not require any special action on our
1199   // part.
1200   return ProcessMessage::Signal(tid, signo);
1201 }
1202
1203 void ProcessMonitor::ServeOperation(OperationArgs *args) {
1204   ProcessMonitor *monitor = args->m_monitor;
1205
1206   // We are finised with the arguments and are ready to go.  Sync with the
1207   // parent thread and start serving operations on the inferior.
1208   sem_post(&args->m_semaphore);
1209
1210   for (;;) {
1211     // wait for next pending operation
1212     sem_wait(&monitor->m_operation_pending);
1213
1214     monitor->m_operation->Execute(monitor);
1215
1216     // notify calling thread that operation is complete
1217     sem_post(&monitor->m_operation_done);
1218   }
1219 }
1220
1221 void ProcessMonitor::DoOperation(Operation *op) {
1222   std::lock_guard<std::mutex> guard(m_operation_mutex);
1223
1224   m_operation = op;
1225
1226   // notify operation thread that an operation is ready to be processed
1227   sem_post(&m_operation_pending);
1228
1229   // wait for operation to complete
1230   sem_wait(&m_operation_done);
1231 }
1232
1233 size_t ProcessMonitor::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
1234                                   Status &error) {
1235   size_t result;
1236   ReadOperation op(vm_addr, buf, size, error, result);
1237   DoOperation(&op);
1238   return result;
1239 }
1240
1241 size_t ProcessMonitor::WriteMemory(lldb::addr_t vm_addr, const void *buf,
1242                                    size_t size, lldb_private::Status &error) {
1243   size_t result;
1244   WriteOperation op(vm_addr, buf, size, error, result);
1245   DoOperation(&op);
1246   return result;
1247 }
1248
1249 bool ProcessMonitor::ReadRegisterValue(lldb::tid_t tid, unsigned offset,
1250                                        const char *reg_name, unsigned size,
1251                                        RegisterValue &value) {
1252   bool result;
1253   ReadRegOperation op(tid, offset, size, value, result);
1254   DoOperation(&op);
1255   return result;
1256 }
1257
1258 bool ProcessMonitor::WriteRegisterValue(lldb::tid_t tid, unsigned offset,
1259                                         const char *reg_name,
1260                                         const RegisterValue &value) {
1261   bool result;
1262   WriteRegOperation op(tid, offset, value, result);
1263   DoOperation(&op);
1264   return result;
1265 }
1266
1267 bool ProcessMonitor::ReadDebugRegisterValue(
1268     lldb::tid_t tid, unsigned offset, const char *reg_name, unsigned size,
1269     lldb_private::RegisterValue &value) {
1270   bool result;
1271   ReadDebugRegOperation op(tid, offset, size, value, result);
1272   DoOperation(&op);
1273   return result;
1274 }
1275
1276 bool ProcessMonitor::WriteDebugRegisterValue(
1277     lldb::tid_t tid, unsigned offset, const char *reg_name,
1278     const lldb_private::RegisterValue &value) {
1279   bool result;
1280   WriteDebugRegOperation op(tid, offset, value, result);
1281   DoOperation(&op);
1282   return result;
1283 }
1284
1285 bool ProcessMonitor::ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1286   bool result;
1287   ReadGPROperation op(tid, buf, result);
1288   DoOperation(&op);
1289   return result;
1290 }
1291
1292 bool ProcessMonitor::ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1293   bool result;
1294   ReadFPROperation op(tid, buf, result);
1295   DoOperation(&op);
1296   return result;
1297 }
1298
1299 bool ProcessMonitor::ReadRegisterSet(lldb::tid_t tid, void *buf,
1300                                      size_t buf_size, unsigned int regset) {
1301   return false;
1302 }
1303
1304 bool ProcessMonitor::WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1305   bool result;
1306   WriteGPROperation op(tid, buf, result);
1307   DoOperation(&op);
1308   return result;
1309 }
1310
1311 bool ProcessMonitor::WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size) {
1312   bool result;
1313   WriteFPROperation op(tid, buf, result);
1314   DoOperation(&op);
1315   return result;
1316 }
1317
1318 bool ProcessMonitor::WriteRegisterSet(lldb::tid_t tid, void *buf,
1319                                       size_t buf_size, unsigned int regset) {
1320   return false;
1321 }
1322
1323 bool ProcessMonitor::ReadThreadPointer(lldb::tid_t tid, lldb::addr_t &value) {
1324   return false;
1325 }
1326
1327 bool ProcessMonitor::Resume(lldb::tid_t unused, uint32_t signo) {
1328   bool result;
1329   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
1330
1331   if (log) {
1332     const char *signame =
1333         m_process->GetUnixSignals()->GetSignalAsCString(signo);
1334     if (signame == nullptr)
1335       signame = "<none>";
1336     log->Printf("ProcessMonitor::%s() resuming pid %" PRIu64 " with signal %s",
1337                 __FUNCTION__, GetPID(), signame);
1338   }
1339   ResumeOperation op(signo, result);
1340   DoOperation(&op);
1341   if (log)
1342     log->Printf("ProcessMonitor::%s() resuming result = %s", __FUNCTION__,
1343                 result ? "true" : "false");
1344   return result;
1345 }
1346
1347 bool ProcessMonitor::SingleStep(lldb::tid_t unused, uint32_t signo) {
1348   bool result;
1349   SingleStepOperation op(signo, result);
1350   DoOperation(&op);
1351   return result;
1352 }
1353
1354 bool ProcessMonitor::Kill() {
1355   bool result;
1356   KillOperation op(result);
1357   DoOperation(&op);
1358   return result;
1359 }
1360
1361 bool ProcessMonitor::GetLwpInfo(lldb::tid_t tid, void *lwpinfo,
1362                                 int &ptrace_err) {
1363   bool result;
1364   LwpInfoOperation op(tid, lwpinfo, result, ptrace_err);
1365   DoOperation(&op);
1366   return result;
1367 }
1368
1369 bool ProcessMonitor::ThreadSuspend(lldb::tid_t tid, bool suspend) {
1370   bool result;
1371   ThreadSuspendOperation op(tid, suspend, result);
1372   DoOperation(&op);
1373   return result;
1374 }
1375
1376 bool ProcessMonitor::GetEventMessage(lldb::tid_t tid, unsigned long *message) {
1377   bool result;
1378   EventMessageOperation op(tid, message, result);
1379   DoOperation(&op);
1380   return result;
1381 }
1382
1383 lldb_private::Status ProcessMonitor::Detach(lldb::tid_t tid) {
1384   lldb_private::Status error;
1385   if (tid != LLDB_INVALID_THREAD_ID) {
1386     DetachOperation op(error);
1387     DoOperation(&op);
1388   }
1389   return error;
1390 }
1391
1392 bool ProcessMonitor::DupDescriptor(const FileSpec &file_spec, int fd,
1393                                    int flags) {
1394   int target_fd = open(file_spec.GetCString(), flags, 0666);
1395
1396   if (target_fd == -1)
1397     return false;
1398
1399   if (dup2(target_fd, fd) == -1)
1400     return false;
1401
1402   return (close(target_fd) == -1) ? false : true;
1403 }
1404
1405 void ProcessMonitor::StopMonitoringChildProcess() {
1406   if (m_monitor_thread.IsJoinable()) {
1407     m_monitor_thread.Cancel();
1408     m_monitor_thread.Join(nullptr);
1409     m_monitor_thread.Reset();
1410   }
1411 }
1412
1413 void ProcessMonitor::StopMonitor() {
1414   StopMonitoringChildProcess();
1415   StopOpThread();
1416   sem_destroy(&m_operation_pending);
1417   sem_destroy(&m_operation_done);
1418   if (m_terminal_fd >= 0) {
1419     close(m_terminal_fd);
1420     m_terminal_fd = -1;
1421   }
1422 }
1423
1424 // FIXME: On Linux, when a new thread is created, we receive to notifications,
1425 // (1) a SIGTRAP|PTRACE_EVENT_CLONE from the main process thread with the child
1426 // thread id as additional information, and (2) a SIGSTOP|SI_USER from the new
1427 // child thread indicating that it has is stopped because we attached. We have
1428 // no guarantee of the order in which these arrive, but we need both before we
1429 // are ready to proceed.  We currently keep a list of threads which have sent
1430 // the initial SIGSTOP|SI_USER event.  Then when we receive the
1431 // SIGTRAP|PTRACE_EVENT_CLONE notification, if the initial stop has not
1432 // occurred we call ProcessMonitor::WaitForInitialTIDStop() to wait for it.
1433 //
1434 // Right now, the above logic is in ProcessPOSIX, so we need a definition of
1435 // this function in the FreeBSD ProcessMonitor implementation even if it isn't
1436 // logically needed.
1437 //
1438 // We really should figure out what actually happens on FreeBSD and move the
1439 // Linux-specific logic out of ProcessPOSIX as needed.
1440
1441 bool ProcessMonitor::WaitForInitialTIDStop(lldb::tid_t tid) { return true; }
1442
1443 void ProcessMonitor::StopOpThread() {
1444   if (!m_operation_thread.IsJoinable())
1445     return;
1446
1447   m_operation_thread.Cancel();
1448   m_operation_thread.Join(nullptr);
1449   m_operation_thread.Reset();
1450 }