| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef SRC_DEVELOPER_DEBUG_ZXDB_CLIENT_SYSTEM_H_ |
| #define SRC_DEVELOPER_DEBUG_ZXDB_CLIENT_SYSTEM_H_ |
| |
| #include <memory> |
| #include <vector> |
| |
| #include "lib/fit/function.h" |
| #include "src/developer/debug/ipc/protocol.h" |
| #include "src/developer/debug/zxdb/client/client_object.h" |
| #include "src/developer/debug/zxdb/client/filter_observer.h" |
| #include "src/developer/debug/zxdb/client/map_setting_store.h" |
| #include "src/developer/debug/zxdb/client/setting_store_observer.h" |
| #include "src/developer/debug/zxdb/client/target.h" |
| #include "src/developer/debug/zxdb/symbols/system_symbols.h" |
| #include "src/lib/fxl/macros.h" |
| #include "src/lib/fxl/memory/weak_ptr.h" |
| #include "src/lib/fxl/observer_list.h" |
| |
| namespace zxdb { |
| |
| class Breakpoint; |
| class BreakpointImpl; |
| class Download; |
| class Err; |
| class Filter; |
| class Job; |
| class ProcessImpl; |
| class SymbolServer; |
| class SystemObserver; |
| class TargetImpl; |
| |
| // Represents the client's view of the system-wide state on the debugged |
| // computer. |
| class System : public ClientObject, |
| public FilterObserver, |
| public SettingStoreObserver, |
| public SystemSymbols::DownloadHandler { |
| public: |
| // Callback for requesting the process tree. |
| using ProcessTreeCallback = fit::callback<void(const Err&, debug_ipc::ProcessTreeReply)>; |
| |
| explicit System(Session* session); |
| ~System() override; |
| |
| fxl::WeakPtr<System> GetWeakPtr() { return weak_factory_.GetWeakPtr(); } |
| |
| void AddObserver(SystemObserver* observer) { observers_.AddObserver(observer); } |
| void RemoveObserver(SystemObserver* observer) { observers_.RemoveObserver(observer); } |
| |
| MapSettingStore& settings() { return settings_; } |
| |
| // Provides the setting schema for this object. |
| static fxl::RefPtr<SettingSchema> GetSchema(); |
| |
| ProcessImpl* ProcessImplFromKoid(uint64_t koid) const; |
| |
| std::vector<TargetImpl*> GetTargetImpls() const; |
| |
| // Like CreateNewTarget but returns the implementation. |
| TargetImpl* CreateNewTargetImpl(TargetImpl* clone); |
| |
| SystemSymbols* GetSymbols(); |
| |
| // Returns all targets currently in this System instance. The returned pointers are managed by the |
| // System object and should not be cached once you return to the message loop. There is a single |
| // default Target, which is not initially attached to anything. |
| std::vector<Target*> GetTargets() const; |
| |
| // Returns all jobs currently in this System instance. The returned pointers are managed |
| // by the System object and should not be cached once you return to the message loop. |
| std::vector<Job*> GetJobs() const; |
| |
| // Returns all non-internal breakpoints currently in this System instance. The returned pointers |
| // are managed by the System object and should not be cached once you return to the message loop. |
| std::vector<Breakpoint*> GetBreakpoints() const; |
| |
| // Returns all filters currently in this System instance. The returned pointers are managed by the |
| // System object and should not be cached once you return to the message loop. |
| std::vector<Filter*> GetFilters() const; |
| |
| // Returns all symbol servers registered with this symbol instance. The returned pointers are |
| // managed by the System object and should not be cached once you return to the message loop. |
| std::vector<SymbolServer*> GetSymbolServers() const; |
| |
| // Returns the process (and hence Target) associated with the given live koid. Returns 0 if not |
| // found. |
| Process* ProcessFromKoid(uint64_t koid) const; |
| |
| // Schedules a request for the system process tree. |
| void GetProcessTree(ProcessTreeCallback callback); |
| |
| // Creates/Deletes a target in this System instance. If "clone" is given, the settings from that |
| // target will be cloned into the new one. If clone is null, an empty Target will be allocated. |
| // |
| // Targets can't be deleted if they're running, and there must always be at least one target |
| // in the system. Delete will fail otherwise. |
| Target* CreateNewTarget(Target* clone); |
| Err DeleteTarget(Target* t); |
| |
| // New jobs will have no attached job. |
| Job* CreateNewJob(); |
| void DeleteJob(Job* job); |
| |
| // Creates a new breakpoint. It will have no associated process or location and will be disabled. |
| Breakpoint* CreateNewBreakpoint(); |
| |
| // Creates an internal breakpoint. Internal breakpoints are not reported by GetBreakpoints() and |
| // are used to implement internal stepping functions. |
| Breakpoint* CreateNewInternalBreakpoint(); |
| |
| // Deletes the given breakpoint. The passed-in pointer will be invalid after this call. Used for |
| // both internal and external breakpoints. |
| void DeleteBreakpoint(Breakpoint* breakpoint); |
| |
| // Creates a new filter. It will have no associated pattern. |
| Filter* CreateNewFilter(); |
| |
| // Delete a filter. The passed-in pointer will be invalid after this call. |
| void DeleteFilter(Filter* filter); |
| |
| // Pauses (suspends in Zircon terms) all threads of all attached processes. |
| // |
| // The backend will try to ensure the threads are actually paused before issuing the on_paused |
| // callback. But this is best effort and not guaranteed: both because there's a timeout for the |
| // synchronous suspending and because a different continue message could race with the reply. |
| void Pause(fit::callback<void()> on_paused); |
| |
| // Applies to all threads of all debugged processes. |
| void Continue(bool forward); |
| |
| // Stops all thread controllers which may be doing automatic stepping for all threads in all |
| // processes. See Thread::CancelAllThreadControllers() for more. |
| void CancelAllThreadControllers(); |
| |
| // Whether there's a download pending for the given build ID. |
| bool HasDownload(const std::string& build_id); |
| |
| // Get a test download object. |
| std::shared_ptr<Download> InjectDownloadForTesting(const std::string& build_id); |
| |
| // DownloadHandler implementation: |
| void RequestDownload(const std::string& build_id, DebugSymbolFileType file_type, |
| bool quiet) override; |
| |
| // Notification that a connection has been made/terminated to a target system. |
| // |
| // The is_local flag will be set when the connection is just a loopback to the local computer. |
| void DidConnect(bool is_local); |
| void DidDisconnect(); |
| |
| // Returns the breakpoint implementation for the given ID, or null if the ID was not found in the |
| // map. This will include both internal and regular breakpoints (it is used for notification |
| // dispatch). |
| BreakpointImpl* BreakpointImplForId(uint32_t id); |
| |
| // SettingStoreObserver implementation. |
| void OnSettingChanged(const SettingStore&, const std::string& setting_name) override; |
| |
| // Add a symbol server for testing purposes. |
| void InjectSymbolServerForTesting(std::unique_ptr<SymbolServer> server); |
| |
| // Will attach to any process we are not already attached to. |
| void OnFilterMatches(Job* job, const std::vector<uint64_t>& matched_pids) override; |
| |
| // Searches through for an open slot (Target without an attached process) or creates another one |
| // if none is found. Calls attach on that target, passing |callback| into it. |
| void AttachToProcess(uint64_t pid, Target::CallbackWithTimestamp callback); |
| |
| private: |
| void AddNewTarget(std::unique_ptr<TargetImpl> target); |
| void AddNewJob(std::unique_ptr<Job> job); |
| void AddSymbolServer(std::unique_ptr<SymbolServer> server); |
| |
| // Called when we have attempted to download debug symbols and failed. If err is set then |
| // something went wrong during the attempt, otherwise the symbols simply weren't available from |
| // any of the servers. |
| void NotifyFailedToFindDebugSymbols(const Err& err, const std::string& build_id, |
| DebugSymbolFileType file_type); |
| |
| // Called when a symbol server under our control enters the Ready state. |
| void OnSymbolServerBecomesReady(SymbolServer* server); |
| |
| // Called every time a new download starts. |
| void DownloadStarted(); |
| |
| // Called every time a download ends. |
| void DownloadFinished(); |
| |
| // Create a new download obect for downloading a given build ID. If quiet is set, don't report the |
| // status of this download. |
| // |
| // If multiple callers request a download of the same build ID, this will return the same object |
| // to each. The first caller's preference is taken for the quiet parameter. |
| std::shared_ptr<Download> GetDownload(std::string build_id, DebugSymbolFileType file_type, |
| bool quiet); |
| |
| // Number of symbol servers currently initializing. |
| size_t servers_initializing_ = 0; |
| |
| // The number of downloads currently active. |
| size_t download_count_ = 0; |
| |
| // The number of downloads that have succeeded. Every time download_count_ reaches 0, this number |
| // is reported via an event, and then cleared to zero. |
| size_t download_success_count_ = 0; |
| |
| // The number of downloads that have failed. Semantics are the same as download_success_count_ |
| size_t download_fail_count_ = 0; |
| |
| // We hold pointers to downloads while we have servers initializing so that those servers have |
| // time to join the download. |
| std::vector<std::shared_ptr<Download>> suspended_downloads_; |
| |
| std::vector<std::unique_ptr<SymbolServer>> symbol_servers_; |
| std::vector<std::unique_ptr<TargetImpl>> targets_; |
| std::vector<std::unique_ptr<Job>> jobs_; |
| |
| // Downloads currently in progress. |
| std::map<std::pair<std::string, DebugSymbolFileType>, std::weak_ptr<Download>> downloads_; |
| |
| // The breakpoints are indexed by their unique backend ID. This is separate from the index |
| // generated by the console frontend to describe the breakpoint noun. |
| std::map<uint32_t, std::unique_ptr<BreakpointImpl>> breakpoints_; |
| |
| std::vector<std::unique_ptr<Filter>> filters_; |
| |
| SystemSymbols symbols_; |
| |
| MapSettingStore settings_; |
| |
| fxl::ObserverList<SystemObserver> observers_; |
| |
| fxl::WeakPtrFactory<System> weak_factory_; |
| |
| FXL_DISALLOW_COPY_AND_ASSIGN(System); |
| }; |
| |
| } // namespace zxdb |
| |
| #endif // SRC_DEVELOPER_DEBUG_ZXDB_CLIENT_SYSTEM_H_ |