ProcessFreeBSD.cpp revision 360784 
1//===-- ProcessFreeBSD.cpp ----------------------------------------*- C++
2//-*-===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#include <errno.h>
11#include <pthread.h>
12#include <pthread_np.h>
13#include <stdlib.h>
14#include <sys/sysctl.h>
15#include <sys/types.h>
16#include <sys/user.h>
17#include <machine/elf.h>
18
19#include <mutex>
20#include <unordered_map>
21
22#include "lldb/Core/PluginManager.h"
23#include "lldb/Host/FileSystem.h"
24#include "lldb/Host/Host.h"
25#include "lldb/Symbol/ObjectFile.h"
26#include "lldb/Target/DynamicLoader.h"
27#include "lldb/Target/Target.h"
28#include "lldb/Utility/RegisterValue.h"
29#include "lldb/Utility/State.h"
30
31#include "FreeBSDThread.h"
32#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
33#include "Plugins/Process/Utility/FreeBSDSignals.h"
34#include "Plugins/Process/Utility/InferiorCallPOSIX.h"
35#include "ProcessFreeBSD.h"
36#include "ProcessMonitor.h"
37
38#include "lldb/Breakpoint/BreakpointLocation.h"
39#include "lldb/Breakpoint/Watchpoint.h"
40#include "lldb/Core/Module.h"
41#include "lldb/Core/ModuleSpec.h"
42#include "lldb/Core/PluginManager.h"
43#include "lldb/Host/Host.h"
44#include "lldb/Symbol/ObjectFile.h"
45#include "lldb/Target/DynamicLoader.h"
46#include "lldb/Target/Platform.h"
47#include "lldb/Target/Target.h"
48#include "lldb/Utility/DataBufferHeap.h"
49#include "lldb/Utility/FileSpec.h"
50#include "lldb/Utility/State.h"
51
52#include "lldb/Host/posix/Fcntl.h"
53
54#include "llvm/Support/FileSystem.h"
55#include "llvm/Support/Threading.h"
56
57using namespace lldb;
58using namespace lldb_private;
59
60namespace {
61UnixSignalsSP &GetFreeBSDSignals() {
62  static UnixSignalsSP s_freebsd_signals_sp(new FreeBSDSignals());
63  return s_freebsd_signals_sp;
64}
65}
66
67// Static functions.
68
69lldb::ProcessSP
70ProcessFreeBSD::CreateInstance(lldb::TargetSP target_sp,
71                               lldb::ListenerSP listener_sp,
72                               const FileSpec *crash_file_path) {
73  lldb::ProcessSP process_sp;
74  if (crash_file_path == NULL)
75    process_sp.reset(
76        new ProcessFreeBSD(target_sp, listener_sp, GetFreeBSDSignals()));
77  return process_sp;
78}
79
80void ProcessFreeBSD::Initialize() {
81  static llvm::once_flag g_once_flag;
82
83  llvm::call_once(g_once_flag, []() {
84    PluginManager::RegisterPlugin(GetPluginNameStatic(),
85                                  GetPluginDescriptionStatic(), CreateInstance);
86  });
87}
88
89lldb_private::ConstString ProcessFreeBSD::GetPluginNameStatic() {
90  static ConstString g_name("freebsd");
91  return g_name;
92}
93
94const char *ProcessFreeBSD::GetPluginDescriptionStatic() {
95  return "Process plugin for FreeBSD";
96}
97
98// ProcessInterface protocol.
99
100lldb_private::ConstString ProcessFreeBSD::GetPluginName() {
101  return GetPluginNameStatic();
102}
103
104uint32_t ProcessFreeBSD::GetPluginVersion() { return 1; }
105
106void ProcessFreeBSD::Terminate() {}
107
108Status ProcessFreeBSD::DoDetach(bool keep_stopped) {
109  Status error;
110  if (keep_stopped) {
111    error.SetErrorString("Detaching with keep_stopped true is not currently "
112                         "supported on FreeBSD.");
113    return error;
114  }
115
116  error = m_monitor->Detach(GetID());
117
118  if (error.Success())
119    SetPrivateState(eStateDetached);
120
121  return error;
122}
123
124Status ProcessFreeBSD::DoResume() {
125  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
126
127  SetPrivateState(eStateRunning);
128
129  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
130  bool do_step = false;
131  bool software_single_step = !SupportHardwareSingleStepping();
132
133  for (tid_collection::const_iterator t_pos = m_run_tids.begin(),
134                                      t_end = m_run_tids.end();
135       t_pos != t_end; ++t_pos) {
136    m_monitor->ThreadSuspend(*t_pos, false);
137  }
138  for (tid_collection::const_iterator t_pos = m_step_tids.begin(),
139                                      t_end = m_step_tids.end();
140       t_pos != t_end; ++t_pos) {
141    m_monitor->ThreadSuspend(*t_pos, false);
142    do_step = true;
143    if (software_single_step) {
144      Status error = SetupSoftwareSingleStepping(*t_pos);
145      if (error.Fail())
146        return error;
147    }
148  }
149  for (tid_collection::const_iterator t_pos = m_suspend_tids.begin(),
150                                      t_end = m_suspend_tids.end();
151       t_pos != t_end; ++t_pos) {
152    m_monitor->ThreadSuspend(*t_pos, true);
153    // XXX Cannot PT_CONTINUE properly with suspended threads.
154    do_step = true;
155  }
156
157  LLDB_LOGF(log, "process %" PRIu64 " resuming (%s)", GetID(),
158            do_step ? "step" : "continue");
159  if (do_step && !software_single_step)
160    m_monitor->SingleStep(GetID(), m_resume_signo);
161  else
162    m_monitor->Resume(GetID(), m_resume_signo);
163
164  return Status();
165}
166
167bool ProcessFreeBSD::UpdateThreadList(ThreadList &old_thread_list,
168                                      ThreadList &new_thread_list) {
169  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
170  LLDB_LOGF(log, "ProcessFreeBSD::%s (pid = %" PRIu64 ")", __FUNCTION__,
171            GetID());
172
173  std::vector<lldb::pid_t> tds;
174  if (!GetMonitor().GetCurrentThreadIDs(tds)) {
175    return false;
176  }
177
178  ThreadList old_thread_list_copy(old_thread_list);
179  for (size_t i = 0; i < tds.size(); ++i) {
180    tid_t tid = tds[i];
181    ThreadSP thread_sp(old_thread_list_copy.RemoveThreadByID(tid, false));
182    if (!thread_sp) {
183      thread_sp.reset(new FreeBSDThread(*this, tid));
184      LLDB_LOGF(log, "ProcessFreeBSD::%s new tid = %" PRIu64, __FUNCTION__,
185                tid);
186    } else {
187      LLDB_LOGF(log, "ProcessFreeBSD::%s existing tid = %" PRIu64, __FUNCTION__,
188                tid);
189    }
190    new_thread_list.AddThread(thread_sp);
191  }
192  for (size_t i = 0; i < old_thread_list_copy.GetSize(false); ++i) {
193    ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex(i, false));
194    if (old_thread_sp) {
195      LLDB_LOGF(log, "ProcessFreeBSD::%s remove tid", __FUNCTION__);
196    }
197  }
198
199  return true;
200}
201
202Status ProcessFreeBSD::WillResume() {
203  m_resume_signo = 0;
204  m_suspend_tids.clear();
205  m_run_tids.clear();
206  m_step_tids.clear();
207  return Process::WillResume();
208}
209
210void ProcessFreeBSD::SendMessage(const ProcessMessage &message) {
211  std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
212
213  switch (message.GetKind()) {
214  case ProcessMessage::eInvalidMessage:
215    return;
216
217  case ProcessMessage::eAttachMessage:
218    SetPrivateState(eStateStopped);
219    return;
220
221  case ProcessMessage::eLimboMessage:
222  case ProcessMessage::eExitMessage:
223    SetExitStatus(message.GetExitStatus(), NULL);
224    break;
225
226  case ProcessMessage::eSignalMessage:
227  case ProcessMessage::eSignalDeliveredMessage:
228  case ProcessMessage::eBreakpointMessage:
229  case ProcessMessage::eTraceMessage:
230  case ProcessMessage::eWatchpointMessage:
231  case ProcessMessage::eCrashMessage:
232    SetPrivateState(eStateStopped);
233    break;
234
235  case ProcessMessage::eNewThreadMessage:
236    llvm_unreachable("eNewThreadMessage unexpected on FreeBSD");
237    break;
238
239  case ProcessMessage::eExecMessage:
240    SetPrivateState(eStateStopped);
241    break;
242  }
243
244  m_message_queue.push(message);
245}
246
247// Constructors and destructors.
248
249ProcessFreeBSD::ProcessFreeBSD(lldb::TargetSP target_sp,
250                               lldb::ListenerSP listener_sp,
251                               UnixSignalsSP &unix_signals_sp)
252    : Process(target_sp, listener_sp, unix_signals_sp),
253      m_byte_order(endian::InlHostByteOrder()), m_monitor(NULL), m_module(NULL),
254      m_message_mutex(), m_exit_now(false), m_seen_initial_stop(),
255      m_resume_signo(0) {
256  // FIXME: Putting this code in the ctor and saving the byte order in a
257  // member variable is a hack to avoid const qual issues in GetByteOrder.
258  lldb::ModuleSP module = GetTarget().GetExecutableModule();
259  if (module && module->GetObjectFile())
260    m_byte_order = module->GetObjectFile()->GetByteOrder();
261}
262
263ProcessFreeBSD::~ProcessFreeBSD() { delete m_monitor; }
264
265// Process protocol.
266void ProcessFreeBSD::Finalize() {
267  Process::Finalize();
268
269  if (m_monitor)
270    m_monitor->StopMonitor();
271}
272
273bool ProcessFreeBSD::CanDebug(lldb::TargetSP target_sp,
274                              bool plugin_specified_by_name) {
275  // For now we are just making sure the file exists for a given module
276  ModuleSP exe_module_sp(target_sp->GetExecutableModule());
277  if (exe_module_sp.get())
278    return FileSystem::Instance().Exists(exe_module_sp->GetFileSpec());
279  // If there is no executable module, we return true since we might be
280  // preparing to attach.
281  return true;
282}
283
284Status
285ProcessFreeBSD::DoAttachToProcessWithID(lldb::pid_t pid,
286                                        const ProcessAttachInfo &attach_info) {
287  Status error;
288  assert(m_monitor == NULL);
289
290  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
291  LLDB_LOGV(log, "pid = {0}", GetID());
292
293  m_monitor = new ProcessMonitor(this, pid, error);
294
295  if (!error.Success())
296    return error;
297
298  PlatformSP platform_sp(GetTarget().GetPlatform());
299  assert(platform_sp.get());
300  if (!platform_sp)
301    return error; // FIXME: Detatch?
302
303  // Find out what we can about this process
304  ProcessInstanceInfo process_info;
305  platform_sp->GetProcessInfo(pid, process_info);
306
307  // Resolve the executable module
308  ModuleSP exe_module_sp;
309  FileSpecList executable_search_paths(
310      Target::GetDefaultExecutableSearchPaths());
311  ModuleSpec exe_module_spec(process_info.GetExecutableFile(),
312                             GetTarget().GetArchitecture());
313  error = platform_sp->ResolveExecutable(
314      exe_module_spec, exe_module_sp,
315      executable_search_paths.GetSize() ? &executable_search_paths : NULL);
316  if (!error.Success())
317    return error;
318
319  // Fix the target architecture if necessary
320  const ArchSpec &module_arch = exe_module_sp->GetArchitecture();
321  if (module_arch.IsValid() &&
322      !GetTarget().GetArchitecture().IsExactMatch(module_arch))
323    GetTarget().SetArchitecture(module_arch);
324
325  // Initialize the target module list
326  GetTarget().SetExecutableModule(exe_module_sp, eLoadDependentsYes);
327
328  SetSTDIOFileDescriptor(m_monitor->GetTerminalFD());
329
330  SetID(pid);
331
332  return error;
333}
334
335Status ProcessFreeBSD::WillLaunch(Module *module) {
336  Status error;
337  return error;
338}
339
340FileSpec
341ProcessFreeBSD::GetFileSpec(const lldb_private::FileAction *file_action,
342                            const FileSpec &default_file_spec,
343                            const FileSpec &dbg_pts_file_spec) {
344  FileSpec file_spec{};
345
346  if (file_action && file_action->GetAction() == FileAction::eFileActionOpen) {
347    file_spec = file_action->GetFileSpec();
348    // By default the stdio paths passed in will be pseudo-terminal (/dev/pts).
349    // If so, convert to using a different default path instead to redirect I/O
350    // to the debugger console. This should also handle user overrides to
351    // /dev/null or a different file.
352    if (!file_spec || file_spec == dbg_pts_file_spec)
353      file_spec = default_file_spec;
354  }
355  return file_spec;
356}
357
358Status ProcessFreeBSD::DoLaunch(Module *module,
359                                ProcessLaunchInfo &launch_info) {
360  Status error;
361  assert(m_monitor == NULL);
362
363  FileSpec working_dir = launch_info.GetWorkingDirectory();
364  if (working_dir) {
365    FileSystem::Instance().Resolve(working_dir);
366    if (!FileSystem::Instance().IsDirectory(working_dir.GetPath())) {
367      error.SetErrorStringWithFormat("No such file or directory: %s",
368                                   working_dir.GetCString());
369      return error;
370    }
371  }
372
373  SetPrivateState(eStateLaunching);
374
375  const lldb_private::FileAction *file_action;
376
377  // Default of empty will mean to use existing open file descriptors
378  FileSpec stdin_file_spec{};
379  FileSpec stdout_file_spec{};
380  FileSpec stderr_file_spec{};
381
382  const FileSpec dbg_pts_file_spec{launch_info.GetPTY().GetSlaveName(NULL, 0)};
383
384  file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
385  stdin_file_spec =
386      GetFileSpec(file_action, stdin_file_spec, dbg_pts_file_spec);
387
388  file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
389  stdout_file_spec =
390      GetFileSpec(file_action, stdout_file_spec, dbg_pts_file_spec);
391
392  file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
393  stderr_file_spec =
394      GetFileSpec(file_action, stderr_file_spec, dbg_pts_file_spec);
395
396  m_monitor = new ProcessMonitor(
397      this, module, launch_info.GetArguments().GetConstArgumentVector(),
398      launch_info.GetEnvironment(), stdin_file_spec, stdout_file_spec,
399      stderr_file_spec, working_dir, launch_info, error);
400
401  m_module = module;
402
403  if (!error.Success())
404    return error;
405
406  int terminal = m_monitor->GetTerminalFD();
407  if (terminal >= 0) {
408// The reader thread will close the file descriptor when done, so we pass it a
409// copy.
410#ifdef F_DUPFD_CLOEXEC
411    int stdio = fcntl(terminal, F_DUPFD_CLOEXEC, 0);
412    if (stdio == -1) {
413      error.SetErrorToErrno();
414      return error;
415    }
416#else
417    // Special case when F_DUPFD_CLOEXEC does not exist (Debian kFreeBSD)
418    int stdio = fcntl(terminal, F_DUPFD, 0);
419    if (stdio == -1) {
420      error.SetErrorToErrno();
421      return error;
422    }
423    stdio = fcntl(terminal, F_SETFD, FD_CLOEXEC);
424    if (stdio == -1) {
425      error.SetErrorToErrno();
426      return error;
427    }
428#endif
429    SetSTDIOFileDescriptor(stdio);
430  }
431
432  SetID(m_monitor->GetPID());
433  return error;
434}
435
436void ProcessFreeBSD::DidLaunch() {}
437
438addr_t ProcessFreeBSD::GetImageInfoAddress() {
439  Target *target = &GetTarget();
440  ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
441  Address addr = obj_file->GetImageInfoAddress(target);
442
443  if (addr.IsValid())
444    return addr.GetLoadAddress(target);
445  return LLDB_INVALID_ADDRESS;
446}
447
448Status ProcessFreeBSD::DoHalt(bool &caused_stop) {
449  Status error;
450
451  if (IsStopped()) {
452    caused_stop = false;
453  } else if (kill(GetID(), SIGSTOP)) {
454    caused_stop = false;
455    error.SetErrorToErrno();
456  } else {
457    caused_stop = true;
458  }
459  return error;
460}
461
462Status ProcessFreeBSD::DoSignal(int signal) {
463  Status error;
464
465  if (kill(GetID(), signal))
466    error.SetErrorToErrno();
467
468  return error;
469}
470
471Status ProcessFreeBSD::DoDestroy() {
472  Status error;
473
474  if (!HasExited()) {
475    assert(m_monitor);
476    m_exit_now = true;
477    if (GetID() == LLDB_INVALID_PROCESS_ID) {
478      error.SetErrorString("invalid process id");
479      return error;
480    }
481    if (!m_monitor->Kill()) {
482      error.SetErrorToErrno();
483      return error;
484    }
485
486    SetPrivateState(eStateExited);
487  }
488
489  return error;
490}
491
492void ProcessFreeBSD::DoDidExec() {
493  Target *target = &GetTarget();
494  if (target) {
495    PlatformSP platform_sp(target->GetPlatform());
496    assert(platform_sp.get());
497    if (platform_sp) {
498      ProcessInstanceInfo process_info;
499      platform_sp->GetProcessInfo(GetID(), process_info);
500      ModuleSP exe_module_sp;
501      ModuleSpec exe_module_spec(process_info.GetExecutableFile(),
502                                 target->GetArchitecture());
503      FileSpecList executable_search_paths(
504          Target::GetDefaultExecutableSearchPaths());
505      Status error = platform_sp->ResolveExecutable(
506          exe_module_spec, exe_module_sp,
507          executable_search_paths.GetSize() ? &executable_search_paths : NULL);
508      if (!error.Success())
509        return;
510      target->SetExecutableModule(exe_module_sp, eLoadDependentsYes);
511    }
512  }
513}
514
515bool ProcessFreeBSD::AddThreadForInitialStopIfNeeded(lldb::tid_t stop_tid) {
516  bool added_to_set = false;
517  ThreadStopSet::iterator it = m_seen_initial_stop.find(stop_tid);
518  if (it == m_seen_initial_stop.end()) {
519    m_seen_initial_stop.insert(stop_tid);
520    added_to_set = true;
521  }
522  return added_to_set;
523}
524
525bool ProcessFreeBSD::WaitingForInitialStop(lldb::tid_t stop_tid) {
526  return (m_seen_initial_stop.find(stop_tid) == m_seen_initial_stop.end());
527}
528
529FreeBSDThread *
530ProcessFreeBSD::CreateNewFreeBSDThread(lldb_private::Process &process,
531                                       lldb::tid_t tid) {
532  return new FreeBSDThread(process, tid);
533}
534
535void ProcessFreeBSD::RefreshStateAfterStop() {
536  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
537  LLDB_LOGV(log, "message_queue size = {0}", m_message_queue.size());
538
539  std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
540
541  // This method used to only handle one message.  Changing it to loop allows
542  // it to handle the case where we hit a breakpoint while handling a different
543  // breakpoint.
544  while (!m_message_queue.empty()) {
545    ProcessMessage &message = m_message_queue.front();
546
547    // Resolve the thread this message corresponds to and pass it along.
548    lldb::tid_t tid = message.GetTID();
549    LLDB_LOGV(log, " message_queue size = {0}, pid = {1}",
550              m_message_queue.size(), tid);
551
552    m_thread_list.RefreshStateAfterStop();
553
554    FreeBSDThread *thread = static_cast<FreeBSDThread *>(
555        GetThreadList().FindThreadByID(tid, false).get());
556    if (thread)
557      thread->Notify(message);
558
559    if (message.GetKind() == ProcessMessage::eExitMessage) {
560      // FIXME: We should tell the user about this, but the limbo message is
561      // probably better for that.
562      LLDB_LOG(log, "removing thread, tid = {0}", tid);
563      std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
564
565      ThreadSP thread_sp = m_thread_list.RemoveThreadByID(tid, false);
566      thread_sp.reset();
567      m_seen_initial_stop.erase(tid);
568    }
569
570    m_message_queue.pop();
571  }
572}
573
574bool ProcessFreeBSD::IsAlive() {
575  StateType state = GetPrivateState();
576  return state != eStateDetached && state != eStateExited &&
577         state != eStateInvalid && state != eStateUnloaded;
578}
579
580size_t ProcessFreeBSD::DoReadMemory(addr_t vm_addr, void *buf, size_t size,
581                                    Status &error) {
582  assert(m_monitor);
583  return m_monitor->ReadMemory(vm_addr, buf, size, error);
584}
585
586size_t ProcessFreeBSD::DoWriteMemory(addr_t vm_addr, const void *buf,
587                                     size_t size, Status &error) {
588  assert(m_monitor);
589  return m_monitor->WriteMemory(vm_addr, buf, size, error);
590}
591
592addr_t ProcessFreeBSD::DoAllocateMemory(size_t size, uint32_t permissions,
593                                        Status &error) {
594  addr_t allocated_addr = LLDB_INVALID_ADDRESS;
595
596  unsigned prot = 0;
597  if (permissions & lldb::ePermissionsReadable)
598    prot |= eMmapProtRead;
599  if (permissions & lldb::ePermissionsWritable)
600    prot |= eMmapProtWrite;
601  if (permissions & lldb::ePermissionsExecutable)
602    prot |= eMmapProtExec;
603
604  if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
605                       eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) {
606    m_addr_to_mmap_size[allocated_addr] = size;
607    error.Clear();
608  } else {
609    allocated_addr = LLDB_INVALID_ADDRESS;
610    error.SetErrorStringWithFormat(
611        "unable to allocate %zu bytes of memory with permissions %s", size,
612        GetPermissionsAsCString(permissions));
613  }
614
615  return allocated_addr;
616}
617
618Status ProcessFreeBSD::DoDeallocateMemory(lldb::addr_t addr) {
619  Status error;
620  MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
621  if (pos != m_addr_to_mmap_size.end() &&
622      InferiorCallMunmap(this, addr, pos->second))
623    m_addr_to_mmap_size.erase(pos);
624  else
625    error.SetErrorStringWithFormat("unable to deallocate memory at 0x%" PRIx64,
626                                   addr);
627
628  return error;
629}
630
631size_t
632ProcessFreeBSD::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
633  static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xD4};
634  static const uint8_t g_i386_opcode[] = {0xCC};
635
636  ArchSpec arch = GetTarget().GetArchitecture();
637  const uint8_t *opcode = NULL;
638  size_t opcode_size = 0;
639
640  switch (arch.GetMachine()) {
641  default:
642    assert(false && "CPU type not supported!");
643    break;
644
645  case llvm::Triple::arm: {
646    // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
647    // linux kernel does otherwise.
648    static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
649    static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
650
651    lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
652    AddressClass addr_class = AddressClass::eUnknown;
653
654    if (bp_loc_sp)
655      addr_class = bp_loc_sp->GetAddress().GetAddressClass();
656
657    if (addr_class == AddressClass::eCodeAlternateISA ||
658        (addr_class == AddressClass::eUnknown &&
659         bp_loc_sp->GetAddress().GetOffset() & 1)) {
660      opcode = g_thumb_breakpoint_opcode;
661      opcode_size = sizeof(g_thumb_breakpoint_opcode);
662    } else {
663      opcode = g_arm_breakpoint_opcode;
664      opcode_size = sizeof(g_arm_breakpoint_opcode);
665    }
666  } break;
667  case llvm::Triple::aarch64:
668    opcode = g_aarch64_opcode;
669    opcode_size = sizeof(g_aarch64_opcode);
670    break;
671
672  case llvm::Triple::x86:
673  case llvm::Triple::x86_64:
674    opcode = g_i386_opcode;
675    opcode_size = sizeof(g_i386_opcode);
676    break;
677  }
678
679  bp_site->SetTrapOpcode(opcode, opcode_size);
680  return opcode_size;
681}
682
683Status ProcessFreeBSD::EnableBreakpointSite(BreakpointSite *bp_site) {
684  return EnableSoftwareBreakpoint(bp_site);
685}
686
687Status ProcessFreeBSD::DisableBreakpointSite(BreakpointSite *bp_site) {
688  return DisableSoftwareBreakpoint(bp_site);
689}
690
691Status ProcessFreeBSD::EnableWatchpoint(Watchpoint *wp, bool notify) {
692  Status error;
693  if (wp) {
694    user_id_t watchID = wp->GetID();
695    addr_t addr = wp->GetLoadAddress();
696    Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
697    LLDB_LOGF(log, "ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64 ")",
698              watchID);
699    if (wp->IsEnabled()) {
700      LLDB_LOGF(log,
701                "ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64
702                ") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.",
703                watchID, (uint64_t)addr);
704      return error;
705    }
706
707    // Try to find a vacant watchpoint slot in the inferiors' main thread
708    uint32_t wp_hw_index = LLDB_INVALID_INDEX32;
709    std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
710    FreeBSDThread *thread = static_cast<FreeBSDThread *>(
711        m_thread_list.GetThreadAtIndex(0, false).get());
712
713    if (thread)
714      wp_hw_index = thread->FindVacantWatchpointIndex();
715
716    if (wp_hw_index == LLDB_INVALID_INDEX32) {
717      error.SetErrorString("Setting hardware watchpoint failed.");
718    } else {
719      wp->SetHardwareIndex(wp_hw_index);
720      bool wp_enabled = true;
721      uint32_t thread_count = m_thread_list.GetSize(false);
722      for (uint32_t i = 0; i < thread_count; ++i) {
723        thread = static_cast<FreeBSDThread *>(
724            m_thread_list.GetThreadAtIndex(i, false).get());
725        if (thread)
726          wp_enabled &= thread->EnableHardwareWatchpoint(wp);
727        else
728          wp_enabled = false;
729      }
730      if (wp_enabled) {
731        wp->SetEnabled(true, notify);
732        return error;
733      } else {
734        // Watchpoint enabling failed on at least one of the threads so roll
735        // back all of them
736        DisableWatchpoint(wp, false);
737        error.SetErrorString("Setting hardware watchpoint failed");
738      }
739    }
740  } else
741    error.SetErrorString("Watchpoint argument was NULL.");
742  return error;
743}
744
745Status ProcessFreeBSD::DisableWatchpoint(Watchpoint *wp, bool notify) {
746  Status error;
747  if (wp) {
748    user_id_t watchID = wp->GetID();
749    addr_t addr = wp->GetLoadAddress();
750    Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
751    LLDB_LOGF(log, "ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64 ")",
752              watchID);
753    if (!wp->IsEnabled()) {
754      LLDB_LOGF(log,
755                "ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64
756                ") addr = 0x%8.8" PRIx64 ": watchpoint already disabled.",
757                watchID, (uint64_t)addr);
758      // This is needed (for now) to keep watchpoints disabled correctly
759      wp->SetEnabled(false, notify);
760      return error;
761    }
762
763    if (wp->IsHardware()) {
764      bool wp_disabled = true;
765      std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
766      uint32_t thread_count = m_thread_list.GetSize(false);
767      for (uint32_t i = 0; i < thread_count; ++i) {
768        FreeBSDThread *thread = static_cast<FreeBSDThread *>(
769            m_thread_list.GetThreadAtIndex(i, false).get());
770        if (thread)
771          wp_disabled &= thread->DisableHardwareWatchpoint(wp);
772        else
773          wp_disabled = false;
774      }
775      if (wp_disabled) {
776        wp->SetHardwareIndex(LLDB_INVALID_INDEX32);
777        wp->SetEnabled(false, notify);
778        return error;
779      } else
780        error.SetErrorString("Disabling hardware watchpoint failed");
781    }
782  } else
783    error.SetErrorString("Watchpoint argument was NULL.");
784  return error;
785}
786
787Status ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num) {
788  Status error;
789  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
790  FreeBSDThread *thread = static_cast<FreeBSDThread *>(
791      m_thread_list.GetThreadAtIndex(0, false).get());
792  if (thread)
793    num = thread->NumSupportedHardwareWatchpoints();
794  else
795    error.SetErrorString("Process does not exist.");
796  return error;
797}
798
799Status ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num, bool &after) {
800  Status error = GetWatchpointSupportInfo(num);
801  // Watchpoints trigger and halt the inferior after the corresponding
802  // instruction has been executed.
803  after = true;
804  return error;
805}
806
807uint32_t ProcessFreeBSD::UpdateThreadListIfNeeded() {
808  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
809  // Do not allow recursive updates.
810  return m_thread_list.GetSize(false);
811}
812
813ByteOrder ProcessFreeBSD::GetByteOrder() const {
814  // FIXME: We should be able to extract this value directly.  See comment in
815  // ProcessFreeBSD().
816  return m_byte_order;
817}
818
819size_t ProcessFreeBSD::PutSTDIN(const char *buf, size_t len, Status &error) {
820  ssize_t status;
821  if ((status = write(m_monitor->GetTerminalFD(), buf, len)) < 0) {
822    error.SetErrorToErrno();
823    return 0;
824  }
825  return status;
826}
827
828// Utility functions.
829
830bool ProcessFreeBSD::HasExited() {
831  switch (GetPrivateState()) {
832  default:
833    break;
834
835  case eStateDetached:
836  case eStateExited:
837    return true;
838  }
839
840  return false;
841}
842
843bool ProcessFreeBSD::IsStopped() {
844  switch (GetPrivateState()) {
845  default:
846    break;
847
848  case eStateStopped:
849  case eStateCrashed:
850  case eStateSuspended:
851    return true;
852  }
853
854  return false;
855}
856
857bool ProcessFreeBSD::IsAThreadRunning() {
858  bool is_running = false;
859  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
860  uint32_t thread_count = m_thread_list.GetSize(false);
861  for (uint32_t i = 0; i < thread_count; ++i) {
862    FreeBSDThread *thread = static_cast<FreeBSDThread *>(
863        m_thread_list.GetThreadAtIndex(i, false).get());
864    StateType thread_state = thread->GetState();
865    if (thread_state == eStateRunning || thread_state == eStateStepping) {
866      is_running = true;
867      break;
868    }
869  }
870  return is_running;
871}
872
873lldb_private::DataExtractor ProcessFreeBSD::GetAuxvData() {
874  // If we're the local platform, we can ask the host for auxv data.
875  PlatformSP platform_sp = GetTarget().GetPlatform();
876  assert(platform_sp && platform_sp->IsHost());
877
878  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_AUXV, (int)m_process->GetID()};
879  size_t auxv_size = AT_COUNT * sizeof(Elf_Auxinfo);
880  DataBufferSP buf_sp(new DataBufferHeap(auxv_size, 0));
881
882  if (::sysctl(mib, 4, buf_sp->GetBytes(), &auxv_size, NULL, 0) != 0) {
883    perror("sysctl failed on auxv");
884    buf_sp.reset();
885  }
886
887  return DataExtractor(buf_sp, GetByteOrder(), GetAddressByteSize());
888}
889
890struct EmulatorBaton {
891  ProcessFreeBSD *m_process;
892  RegisterContext *m_reg_context;
893
894  // eRegisterKindDWARF -> RegisterValue
895  std::unordered_map<uint32_t, RegisterValue> m_register_values;
896
897  EmulatorBaton(ProcessFreeBSD *process, RegisterContext *reg_context)
898      : m_process(process), m_reg_context(reg_context) {}
899};
900
901static size_t ReadMemoryCallback(EmulateInstruction *instruction, void *baton,
902                                 const EmulateInstruction::Context &context,
903                                 lldb::addr_t addr, void *dst, size_t length) {
904  EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
905
906  Status error;
907  size_t bytes_read =
908      emulator_baton->m_process->DoReadMemory(addr, dst, length, error);
909  if (!error.Success())
910    bytes_read = 0;
911  return bytes_read;
912}
913
914static bool ReadRegisterCallback(EmulateInstruction *instruction, void *baton,
915                                 const RegisterInfo *reg_info,
916                                 RegisterValue &reg_value) {
917  EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
918
919  auto it = emulator_baton->m_register_values.find(
920      reg_info->kinds[eRegisterKindDWARF]);
921  if (it != emulator_baton->m_register_values.end()) {
922    reg_value = it->second;
923    return true;
924  }
925
926  // The emulator only fills in the dwarf register numbers (and in some cases
927  // the generic register numbers). Get the full register info from the
928  // register context based on the dwarf register numbers.
929  const RegisterInfo *full_reg_info =
930      emulator_baton->m_reg_context->GetRegisterInfo(
931          eRegisterKindDWARF, reg_info->kinds[eRegisterKindDWARF]);
932
933  bool error =
934      emulator_baton->m_reg_context->ReadRegister(full_reg_info, reg_value);
935  return error;
936}
937
938static bool WriteRegisterCallback(EmulateInstruction *instruction, void *baton,
939                                  const EmulateInstruction::Context &context,
940                                  const RegisterInfo *reg_info,
941                                  const RegisterValue &reg_value) {
942  EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
943  emulator_baton->m_register_values[reg_info->kinds[eRegisterKindDWARF]] =
944      reg_value;
945  return true;
946}
947
948static size_t WriteMemoryCallback(EmulateInstruction *instruction, void *baton,
949                                  const EmulateInstruction::Context &context,
950                                  lldb::addr_t addr, const void *dst,
951                                  size_t length) {
952  return length;
953}
954
955bool ProcessFreeBSD::SingleStepBreakpointHit(
956    void *baton, lldb_private::StoppointCallbackContext *context,
957    lldb::user_id_t break_id, lldb::user_id_t break_loc_id) {
958  return false;
959}
960
961Status ProcessFreeBSD::SetSoftwareSingleStepBreakpoint(lldb::tid_t tid,
962                                                       lldb::addr_t addr) {
963  Status error;
964
965  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
966  if (log) {
967    LLDB_LOGF(log, "ProcessFreeBSD::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
968    LLDB_LOGF(log, "SoftwareBreakpoint::%s addr = 0x%" PRIx64, __FUNCTION__,
969              addr);
970  }
971
972  // Validate the address.
973  if (addr == LLDB_INVALID_ADDRESS)
974    return Status("ProcessFreeBSD::%s invalid load address specified.",
975                  __FUNCTION__);
976
977  Breakpoint *const sw_step_break =
978      m_process->GetTarget().CreateBreakpoint(addr, true, false).get();
979  sw_step_break->SetCallback(SingleStepBreakpointHit, this, true);
980  sw_step_break->SetBreakpointKind("software-single-step");
981
982  LLDB_LOGF(log, "ProcessFreeBSD::%s addr = 0x%" PRIx64 " -- SUCCESS",
983            __FUNCTION__, addr);
984
985  m_threads_stepping_with_breakpoint.insert({tid, sw_step_break->GetID()});
986  return Status();
987}
988
989bool ProcessFreeBSD::IsSoftwareStepBreakpoint(lldb::tid_t tid) {
990  ThreadSP thread = GetThreadList().FindThreadByID(tid);
991  if (!thread)
992    return false;
993
994  assert(thread->GetRegisterContext());
995  lldb::addr_t stop_pc = thread->GetRegisterContext()->GetPC();
996
997  const auto &iter = m_threads_stepping_with_breakpoint.find(tid);
998  if (iter == m_threads_stepping_with_breakpoint.end())
999    return false;
1000
1001  lldb::break_id_t bp_id = iter->second;
1002  BreakpointSP bp = GetTarget().GetBreakpointByID(bp_id);
1003  if (!bp)
1004    return false;
1005
1006  BreakpointLocationSP bp_loc = bp->FindLocationByAddress(stop_pc);
1007  if (!bp_loc)
1008    return false;
1009
1010  GetTarget().RemoveBreakpointByID(bp_id);
1011  m_threads_stepping_with_breakpoint.erase(tid);
1012  return true;
1013}
1014
1015bool ProcessFreeBSD::SupportHardwareSingleStepping() const {
1016  lldb_private::ArchSpec arch = GetTarget().GetArchitecture();
1017  if (arch.GetMachine() == llvm::Triple::arm || arch.IsMIPS())
1018    return false;
1019  return true;
1020}
1021
1022Status ProcessFreeBSD::SetupSoftwareSingleStepping(lldb::tid_t tid) {
1023  std::unique_ptr<EmulateInstruction> emulator_up(
1024      EmulateInstruction::FindPlugin(GetTarget().GetArchitecture(),
1025                                     eInstructionTypePCModifying, nullptr));
1026
1027  if (emulator_up == nullptr)
1028    return Status("Instruction emulator not found!");
1029
1030  FreeBSDThread *thread = static_cast<FreeBSDThread *>(
1031      m_thread_list.FindThreadByID(tid, false).get());
1032  if (thread == NULL)
1033    return Status("Thread not found not found!");
1034
1035  lldb::RegisterContextSP register_context_sp = thread->GetRegisterContext();
1036
1037  EmulatorBaton baton(this, register_context_sp.get());
1038  emulator_up->SetBaton(&baton);
1039  emulator_up->SetReadMemCallback(&ReadMemoryCallback);
1040  emulator_up->SetReadRegCallback(&ReadRegisterCallback);
1041  emulator_up->SetWriteMemCallback(&WriteMemoryCallback);
1042  emulator_up->SetWriteRegCallback(&WriteRegisterCallback);
1043
1044  if (!emulator_up->ReadInstruction())
1045    return Status("Read instruction failed!");
1046
1047  bool emulation_result =
1048      emulator_up->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC);
1049  const RegisterInfo *reg_info_pc = register_context_sp->GetRegisterInfo(
1050      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
1051  auto pc_it =
1052      baton.m_register_values.find(reg_info_pc->kinds[eRegisterKindDWARF]);
1053
1054  lldb::addr_t next_pc;
1055  if (emulation_result) {
1056    assert(pc_it != baton.m_register_values.end() &&
1057           "Emulation was successful but PC wasn't updated");
1058    next_pc = pc_it->second.GetAsUInt64();
1059  } else if (pc_it == baton.m_register_values.end()) {
1060    // Emulate instruction failed and it haven't changed PC. Advance PC with
1061    // the size of the current opcode because the emulation of all
1062    // PC modifying instruction should be successful. The failure most
1063    // likely caused by a not supported instruction which don't modify PC.
1064    next_pc =
1065        register_context_sp->GetPC() + emulator_up->GetOpcode().GetByteSize();
1066  } else {
1067    // The instruction emulation failed after it modified the PC. It is an
1068    // unknown error where we can't continue because the next instruction is
1069    // modifying the PC but we don't  know how.
1070    return Status("Instruction emulation failed unexpectedly");
1071  }
1072
1073  SetSoftwareSingleStepBreakpoint(tid, next_pc);
1074  return Status();
1075}
1076