1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
// Copyright (c) 2012 The Chromium 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 CHROMEOS_DBUS_DEBUG_DAEMON_CLIENT_H_
#define CHROMEOS_DBUS_DEBUG_DAEMON_CLIENT_H_
#include "base/callback.h"
#include "base/files/file.h"
#include "base/memory/ref_counted_memory.h"
#include "base/task_runner.h"
#include "chromeos/chromeos_export.h"
#include "chromeos/dbus/dbus_client.h"
#include <map>
namespace metrics {
class PerfDataProto;
}
namespace chromeos {
// DebugDaemonClient is used to communicate with the debug daemon.
class CHROMEOS_EXPORT DebugDaemonClient : public DBusClient {
public:
virtual ~DebugDaemonClient();
// Called once GetDebugLogs() is complete. Takes one parameter:
// - succeeded: was the logs stored successfully.
typedef base::Callback<void(bool succeeded)> GetDebugLogsCallback;
// Requests to store debug logs into |file| and calls |callback|
// when completed. Debug logs will be stored in the .tgz if
// |is_compressed| is true, otherwise in logs will be stored in .tar format.
virtual void DumpDebugLogs(bool is_compressed,
base::File file,
scoped_refptr<base::TaskRunner> task_runner,
const GetDebugLogsCallback& callback) = 0;
// Called once SetDebugMode() is complete. Takes one parameter:
// - succeeded: debug mode was changed successfully.
typedef base::Callback<void(bool succeeded)> SetDebugModeCallback;
// Requests to change debug mode to given |subsystem| and calls
// |callback| when completed. |subsystem| should be one of the
// following: "wifi", "ethernet", "cellular" or "none".
virtual void SetDebugMode(const std::string& subsystem,
const SetDebugModeCallback& callback) = 0;
// Called once GetRoutes() is complete.
typedef base::Callback<void(bool succeeded,
const std::vector<std::string>& routes)>
GetRoutesCallback;
virtual void GetRoutes(bool numeric, bool ipv6,
const GetRoutesCallback& callback) = 0;
// Called once GetNetworkStatus() is complete.
typedef base::Callback<void(bool succeeded, const std::string& status)>
GetNetworkStatusCallback;
// Gets information about network status as json.
virtual void GetNetworkStatus(const GetNetworkStatusCallback& callback) = 0;
// Called once GetModemStatus() is complete.
typedef base::Callback<void(bool succeeded, const std::string& status)>
GetModemStatusCallback;
// Gets information about modem status as json.
virtual void GetModemStatus(const GetModemStatusCallback& callback) = 0;
// Called once GetWiMaxStatus() is complete.
typedef base::Callback<void(bool succeeded, const std::string& status)>
GetWiMaxStatusCallback;
// Gets information about WiMAX status as json.
virtual void GetWiMaxStatus(const GetWiMaxStatusCallback& callback) = 0;
// Called once GetNetworkInterfaces() is complete. Takes two parameters:
// - succeeded: information was obtained successfully.
// - status: network interfaces information in json. For details, please refer
// to http://gerrit.chromium.org/gerrit/#/c/28045/5/src/helpers/netif.cc
typedef base::Callback<void(bool succeeded, const std::string& status)>
GetNetworkInterfacesCallback;
// Gets information about network interfaces as json.
virtual void GetNetworkInterfaces(
const GetNetworkInterfacesCallback& callback) = 0;
// Called once GetPerfData() is complete only if the the data is successfully
// obtained from debugd.
typedef base::Callback<void(const std::vector<uint8>& data)>
GetPerfDataCallback;
// Runs perf for |duration| seconds and returns data collected.
virtual void GetPerfData(uint32_t duration,
const GetPerfDataCallback& callback) = 0;
// Callback type for GetScrubbedLogs(), GetAllLogs() or GetUserLogFiles().
typedef base::Callback<void(bool succeeded,
const std::map<std::string, std::string>& logs)>
GetLogsCallback;
// Gets scrubbed logs from debugd.
virtual void GetScrubbedLogs(const GetLogsCallback& callback) = 0;
// Gets all logs collected by debugd.
virtual void GetAllLogs(const GetLogsCallback& callback) = 0;
// Gets list of user log files that must be read by Chrome.
virtual void GetUserLogFiles(const GetLogsCallback& callback) = 0;
// Requests to start system/kernel tracing.
virtual void StartSystemTracing() = 0;
// Called once RequestStopSystemTracing() is complete. Takes one parameter:
// - result: the data collected while tracing was active
typedef base::Callback<void(const scoped_refptr<base::RefCountedString>&
result)> StopSystemTracingCallback;
// Requests to stop system tracing and calls |callback| when completed.
virtual bool RequestStopSystemTracing(
scoped_refptr<base::TaskRunner> task_runner,
const StopSystemTracingCallback& callback) = 0;
// Returns an empty SystemTracingCallback that does nothing.
static StopSystemTracingCallback EmptyStopSystemTracingCallback();
// Called once TestICMP() is complete. Takes two parameters:
// - succeeded: information was obtained successfully.
// - status: information about ICMP connectivity to a specified host as json.
// For details please refer to
// https://gerrit.chromium.org/gerrit/#/c/30310/2/src/helpers/icmp.cc
typedef base::Callback<void(bool succeeded, const std::string& status)>
TestICMPCallback;
// Tests ICMP connectivity to a specified host. The |ip_address| contains the
// IPv4 or IPv6 address of the host, for example "8.8.8.8".
virtual void TestICMP(const std::string& ip_address,
const TestICMPCallback& callback) = 0;
// Tests ICMP connectivity to a specified host. The |ip_address| contains the
// IPv4 or IPv6 address of the host, for example "8.8.8.8".
virtual void TestICMPWithOptions(
const std::string& ip_address,
const std::map<std::string, std::string>& options,
const TestICMPCallback& callback) = 0;
// Called once EnableDebuggingFeatures() is complete. |succeeded| will be true
// if debugging features have been successfully enabled.
typedef base::Callback<void(bool succeeded)> EnableDebuggingCallback;
// Enables debugging features (sshd, boot from USB). |password| is a new
// password for root user. Can be only called in dev mode.
virtual void EnableDebuggingFeatures(
const std::string& password,
const EnableDebuggingCallback& callback) = 0;
enum DebuggingFeature {
DEV_FEATURE_NONE = 0,
DEV_FEATURES_DISABLED = 1 << 0,
DEV_FEATURE_ROOTFS_VERIFICATION_REMOVED = 1 << 1,
DEV_FEATURE_BOOT_FROM_USB_ENABLED = 1 << 2,
DEV_FEATURE_SSH_SERVER_CONFIGURED = 1 << 3,
DEV_FEATURE_DEV_MODE_ROOT_PASSWORD_SET = 1 << 4,
DEV_FEATURE_SYSTEM_ROOT_PASSWORD_SET = 1 << 5,
DEV_FEATURE_ALL_ENABLED =
DEV_FEATURE_ROOTFS_VERIFICATION_REMOVED |
DEV_FEATURE_BOOT_FROM_USB_ENABLED |
DEV_FEATURE_SSH_SERVER_CONFIGURED |
DEV_FEATURE_DEV_MODE_ROOT_PASSWORD_SET |
DEV_FEATURE_DEV_MODE_ROOT_PASSWORD_SET,
};
// Called once QueryDebuggingFeatures() is complete. |succeeded| will be true
// if debugging features have been successfully enabled. |feature_mask| is a
// bitmask made out of DebuggingFeature enum values.
typedef base::Callback<void(bool succeeded,
int feature_mask)> QueryDevFeaturesCallback;
// Checks which debugging features have been already enabled.
virtual void QueryDebuggingFeatures(
const QueryDevFeaturesCallback& callback) = 0;
// Removes rootfs verification from the file system. Can be only called in
// dev mode.
virtual void RemoveRootfsVerification(
const EnableDebuggingCallback& callback) = 0;
// Trigger uploading of crashes.
virtual void UploadCrashes() = 0;
// A callback for WaitForServiceToBeAvailable().
typedef base::Callback<void(bool service_is_ready)>
WaitForServiceToBeAvailableCallback;
// Runs the callback as soon as the service becomes available.
virtual void WaitForServiceToBeAvailable(
const WaitForServiceToBeAvailableCallback& callback) = 0;
// Factory function, creates a new instance and returns ownership.
// For normal usage, access the singleton via DBusThreadManager::Get().
static DebugDaemonClient* Create();
protected:
// Create() should be used instead.
DebugDaemonClient();
private:
DISALLOW_COPY_AND_ASSIGN(DebugDaemonClient);
};
} // namespace chromeos
#endif // CHROMEOS_DBUS_DEBUG_DAEMON_CLIENT_H_
|
