Lines Matching +defs:start +defs:file +defs:process
82 // Comment out line below to disable memory caching, overriding the process
83 // setting target.process.disable-memory-cache
100 // When getting the value for a key from the process options, we will
101 // always try and grab the setting from the current process if there is
104 Process *process = exe_ctx->GetProcessPtr();
105 if (process) {
108 process->GetValueProperties().get());
121 "Continue tracing the parent process and detach the child.",
126 "Trace the child process and detach the parent.",
161 ProcessProperties::ProcessProperties(lldb_private::Process *process)
163 m_process(process) // Can be nullptr for global ProcessProperties
165 if (process == nullptr) {
166 // Global process properties, set them up one time
167 m_collection_sp = std::make_shared<ProcessOptionValueProperties>("process");
242 void ProcessProperties::SetPythonOSPluginPath(const FileSpec &file) {
244 SetPropertyAtIndex(idx, file);
414 static constexpr llvm::StringLiteral class_name("lldb.process");
432 "lldb.process.internal_state_broadcaster"),
434 nullptr, "lldb.process.internal_state_control_broadcaster"),
436 Listener::MakeListener("lldb.process.internal_state_listener")),
443 m_stdio_communication("process.stdio"), m_stdio_communication_mutex(),
478 // The listener passed into process creation is the primary listener:
514 // ThreadList::Clear() will try to acquire this process's mutex, so
534 // Destroy the process. This will call the virtual function DoDestroy under
546 // access to the real process.
572 // process
576 // process around forever. These events need to be cleared out.
638 // don't sync (potentially context switch) in case where there is no process
678 "Process::%s returning without waiting for events; process "
682 // SetPublicState() if the process is hijacked.
704 // SetPublicState() if the process is hijacked.
713 // SetPublicState() if the process is hijacked.
899 // ThreadList mutex, then the process is going to have a hard time
900 // restarting the process.
947 // Pop the process IO handler
1089 // process
1117 // current host. The child process exits, the process will be found in the
1123 int exit_status // Exit value of process if signal is zero
1357 "Resume request failed - process still running.");
1373 "Resume request failed - process still running.");
1389 "process not in stopped state after synchronous resume: %s",
1396 // Undo the hijacking of process events...
1423 // Use m_destructing not m_finalizing here. If we are finalizing a process
1460 // the process stops. In the future we will want to support a debugging
1466 // The process plugin is responsible for managing the actual behavior of
1727 // Don't try to disable the site if we don't have a live process anymore.
2005 lldb::addr_t start = llvm::alignTo(start_addr, alignment);
2006 while (matches.size() < max_matches && (start + size) < end_addr) {
2007 const lldb::addr_t found_addr = FindInMemory(start, end_addr, buf, size);
2014 start = llvm::alignTo(start + 1, alignment);
2019 start = found_addr + alignment;
2416 "cannot allocate memory while process is running");
2658 // module. But we should be able to debug a remote process even if the
2683 // Listen and queue events that are broadcasted during the process launch.
2694 return Status::FromErrorStringWithFormat("file doesn't exist: '%s'",
2707 error = Status::FromErrorString("failed to acquire process run lock");
2721 // Now wait for the process to launch and return control to us, and then
2726 // We were able to launch the process, but we failed to catch the
2744 // Now that we know the process type, update its signal responses from the
2764 // We successfully launched the process and stopped, now it the
2771 "Unexpected process state after the launch: %s, expected %s, "
2782 Listener::MakeListener("lldb.process.load_core_listener"));
2803 // We successfully loaded a core file, now pretend we stopped so we can
2804 // show all of the threads in the core file and explore the crashed state.
2818 "Did not get stopped event after loading the core file.");
2855 Process::AttachCompletionHandler::AttachCompletionHandler(Process *process,
2857 : NextEventAction(process), m_exec_count(exec_count) {
2861 "Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32,
2862 __FUNCTION__, static_cast<void *>(process), exec_count);
2885 // lldb_private::Process subclasses must set the new process ID.
2904 "execs expected to start, continuing with attach",
2983 Status::FromErrorString("failed to acquire process run lock");
3013 // Fall through and attach using the above process ID
3025 "more than one process named %s:\n%s", process_name,
3029 "could not find a process named %s", process_name);
3038 error = Status::FromErrorString("invalid process name");
3054 error = Status::FromErrorString("failed to acquire process run lock");
3080 // Let the process subclass figure out at much as it can about the process
3087 "Process::{0} replacing process architecture with DidAttach() "
3093 // We just attached. If we have a platform, ask it for the process
3132 // Now that we know the process type, update its signal responses from the
3174 // chance to process the threads.
3210 // Find the process and its architecture. Make sure it matches the
3220 // If we attached and actually have a process on the other end, then
3255 // Tell the process it is about to resume before the thread list
3260 // state that they are supposed to have when the process is resumed
3263 // start back up with a signal.
3275 LLDB_LOGF(log, "Process thinks the process has resumed.");
3287 "Process::PrivateResume() asked to simulate a start & stop.");
3307 Listener::MakeListener("lldb.process.halt_listener"));
3323 // Wait for the process halt timeout seconds for the process to stop.
3423 // If the process exited while we were waiting for it to stop, put the
3425 // doesn't need to do anything else, since they don't have a process
3438 // If we really couldn't stop the process then we should just error out
3467 // We shouldn't need to do anything else here. There's no process left
3488 // If we exited when we were waiting for a process to stop, then forward the
3499 // down the process we don't get an error destroying the lock.
3514 // Tell ourselves we are in the process of destroying the process, so that we
3517 // failed and the process stays around for some reason it won't be in a
3524 // FIXME: This will have to be a process setting:
3566 // If we exited when we were waiting for a process to stop, then forward
3577 // to tear down the process we don't get an error destroying the lock.
3662 // run the lldb/test/thread/a.out file and break at main.cpp:58, run
3730 "Process::ShouldBroadcastEvent (%p) Restarting process "
3793 "<lldb.process.internal-state-override(pid=%" PRIu64 ")>",
3797 "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
3965 // to pop the process IOHandler here, we want to do it when we receive
3966 // the stopped event so we can carefully control when the process
3969 // process/thread/frame info, and then we want the "(lldb) " prompt to
3970 // show up. If we pop the process IOHandler here, then we will cause
3972 // process pops off and it will update its prompt right away... See the
3973 // Debugger.cpp file where it calls the function as
3980 // we are hijacked, then we always pop the process IO handler manually.
3981 // Hijacking happens when the internal process state thread is running
3983 // they call "process->WaitForProcessToStop()". An example of something
3988 // This will cause the internal process state thread to resume and halt
3989 // the process (and _it_ will hijack the eBroadcastBitStateChanged
4017 // Ask the process subclass to actually halt our process
4066 // The server may be spinning waiting for a process to appear, in which
4083 ") failed to halt the process: %s",
4094 // running and sends an interrupt request, but the process actually
4122 // event so clients can tell an interrupted process from a natural
4195 // whether we should stop the process, so we need to query that as we go.
4301 // pulled off of the private process event queue, and then any number of
4315 // Let process subclasses know we are about to do a public stop and do
4324 // end up restarting the process.
4366 s->Printf(" process = %p (pid = %" PRIu64 "), ",
4369 s->PutCString(" process = NULL, ");
4610 Process *process = (Process *)baton;
4611 process->AppendSTDOUT(static_cast<const char *>(src), src_len);
4616 IOHandlerProcessSTDIO(Process *process, int write_fd)
4617 : IOHandler(process->GetTarget().GetDebugger(),
4619 m_process(process),
4706 // the command and if the process pushes and pops the IOHandler thousands
4719 // SIGINT handler), like write 1 byte to a file descriptor. This will
4731 // STDIN by sending the interrupt to the process. Otherwise the write to
4735 // which will cause the expression to run, which will push the process IO
4750 NativeFile m_read_file; // Read from this file (usually actual STDIN for LLDB
4751 NativeFile m_write_file; // Write to this file (usually the primary pty for
4759 // First set up the Read Thread for reading/handling process I/O
4813 // The process needs to know about installed plug-ins
4974 "RunThreadPlan called on wrong process.");
5009 // this in the ProcesModID of this process. This RAII takes care of marking
5115 Listener::MakeListener("lldb.process.listener.run-thread-plan"));
5120 // This process event hijacker Hijacks the Public events and its destructor
5121 // makes sure that the process events get restored on exit to the function.
5123 // If the event needs to propagate beyond the hijacker (e.g., the process
5184 // thread timeout expires, I go to halt, but the process already stopped on
5193 // We usually want to resume the process if we get to the top of the
5285 // Now wait for the process to stop again:
5394 // interrupt the process here. Depending on what we were asked to do
5469 // delivered it, the process could have already finished its
5534 // If we had to start up a temporary private state thread to run this
5608 Process *process = event_data->GetProcessSP().get();
5610 if (!process) {
5611 event_explanation = "<no process>";
5615 ThreadList &thread_list = process->GetThreadList();
5713 // Also restore the current process'es selected frame & thread, since this
5731 // If the process exited during the run of the thread plan, notify everyone.
5771 // arguments.) For that to work the process has to be able to acquire it.
5957 // After an exec, the inferior is a new process and these memory regions are
5969 // Flush the process (threads and all stack frames) after running
6211 // We only check the end address, not start and end, because we assume that
6212 // the start will not have non-address bits until the first unmappable
6221 // For a process with no non-address bits, all address bits
6254 "the process supports the following async structured data types:");
6287 // This plugin doesn't think it can work with the process. Move on to the
6358 "Can't trace a non-live process.");
6481 // Add dirty pages to the core file ranges and return true if dirty pages
6501 range = llvm::AddressRange(range.start(), page_addr + page_size);
6505 ranges.Append(range.start(), range.size(), {range, lldb_permissions});
6512 ranges.Append(range.start(), range.size(), {range, lldb_permissions});
6539 static void SaveDynamicLoaderSections(Process &process,
6543 DynamicLoader *dyld = process.GetDynamicLoader();
6552 dyld->CalculateDynamicSaveCoreRanges(process, dynamic_loader_mem_regions,
6562 static void SaveOffRegionsWithStackPointers(Process &process,
6573 for (lldb::ThreadSP thread_sp : process.GetThreadList().Threads()) {
6583 const size_t red_zone = process.GetABI()->GetRedZoneSize();
6585 if (process.GetMemoryRegionInfo(sp, sp_region).Success()) {
6605 // for a full core file style.
6606 static void GetCoreFileSaveRangesFull(Process &process,
6618 // Save only the dirty pages to the core file. Make sure the process has at
6622 static void GetCoreFileSaveRangesDirtyOnly(Process &process,
6636 // We didn't find support for reporting dirty pages from the process
6646 // Save all thread stacks to the core file. Some OS versions support reporting
6651 // dirty regions as this will make the core file smaller. If the process
6654 static void GetCoreFileSaveRangesStackOnly(Process &process,
6670 static void GetUserSpecifiedCoreFileSaveRanges(Process &process,
6697 "failed to get any valid memory regions from the process");