1 /**
2 * Copyright (c) 2016, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "dumpstate"
18
19 #include "DumpstateService.h"
20
21 #include <memory>
22
23 #include <android-base/stringprintf.h>
24 #include "android/os/BnDumpstate.h"
25
26 #include "DumpstateInternal.h"
27
28 using android::base::StringPrintf;
29
30 namespace android {
31 namespace os {
32
33 namespace {
34
35 struct DumpstateInfo {
36 public:
37 Dumpstate* ds = nullptr;
38 int32_t calling_uid = -1;
39 std::string calling_package;
40 };
41
exception(uint32_t code,const std::string & msg,const std::string & extra_msg="")42 static binder::Status exception(uint32_t code, const std::string& msg,
43 const std::string& extra_msg = "") {
44 if (extra_msg.empty()) {
45 MYLOGE("%s (%d) ", msg.c_str(), code);
46 } else {
47 MYLOGE("%s %s (%d) ", msg.c_str(), extra_msg.c_str(), code);
48 }
49 return binder::Status::fromExceptionCode(code, String8(msg.c_str()));
50 }
51
52 // Creates a bugreport and exits, thus preserving the oneshot nature of the service.
53 // Note: takes ownership of data.
dumpstate_thread_main(void * data)54 [[noreturn]] static void* dumpstate_thread_main(void* data) {
55 std::unique_ptr<DumpstateInfo> ds_info(static_cast<DumpstateInfo*>(data));
56 ds_info->ds->Run(ds_info->calling_uid, ds_info->calling_package);
57 MYLOGD("Finished taking a bugreport. Exiting.\n");
58 exit(0);
59 }
60
signalErrorAndExit(sp<IDumpstateListener> listener,int error_code)61 [[noreturn]] static void signalErrorAndExit(sp<IDumpstateListener> listener, int error_code) {
62 listener->onError(error_code);
63 exit(0);
64 }
65
66 } // namespace
67
DumpstateService()68 DumpstateService::DumpstateService() : ds_(nullptr), calling_uid_(-1), calling_package_() {
69 }
70
getServiceName()71 char const* DumpstateService::getServiceName() {
72 return "dumpstate";
73 }
74
Start()75 status_t DumpstateService::Start() {
76 IPCThreadState::self()->disableBackgroundScheduling(true);
77 status_t ret = BinderService<DumpstateService>::publish();
78 if (ret != android::OK) {
79 return ret;
80 }
81 sp<ProcessState> ps(ProcessState::self());
82 ps->startThreadPool();
83 ps->giveThreadPoolName();
84 return android::OK;
85 }
86
startBugreport(int32_t calling_uid,const std::string & calling_package,android::base::unique_fd bugreport_fd,android::base::unique_fd screenshot_fd,int bugreport_mode,const sp<IDumpstateListener> & listener,bool is_screenshot_requested)87 binder::Status DumpstateService::startBugreport(int32_t calling_uid,
88 const std::string& calling_package,
89 android::base::unique_fd bugreport_fd,
90 android::base::unique_fd screenshot_fd,
91 int bugreport_mode,
92 const sp<IDumpstateListener>& listener,
93 bool is_screenshot_requested) {
94 MYLOGI("startBugreport() with mode: %d\n", bugreport_mode);
95
96 // Ensure there is only one bugreport in progress at a time.
97 std::lock_guard<std::mutex> lock(lock_);
98 if (ds_ != nullptr) {
99 MYLOGE("Error! There is already a bugreport in progress. Returning.");
100 if (listener != nullptr) {
101 listener->onError(IDumpstateListener::BUGREPORT_ERROR_ANOTHER_REPORT_IN_PROGRESS);
102 }
103 return exception(binder::Status::EX_SERVICE_SPECIFIC,
104 "There is already a bugreport in progress");
105 }
106
107 // From here on, all conditions that indicate we are done with this incoming request should
108 // result in exiting the service to free it up for next invocation.
109 if (listener == nullptr) {
110 MYLOGE("Invalid input: no listener");
111 exit(0);
112 }
113
114 if (bugreport_mode != Dumpstate::BugreportMode::BUGREPORT_FULL &&
115 bugreport_mode != Dumpstate::BugreportMode::BUGREPORT_INTERACTIVE &&
116 bugreport_mode != Dumpstate::BugreportMode::BUGREPORT_REMOTE &&
117 bugreport_mode != Dumpstate::BugreportMode::BUGREPORT_WEAR &&
118 bugreport_mode != Dumpstate::BugreportMode::BUGREPORT_TELEPHONY &&
119 bugreport_mode != Dumpstate::BugreportMode::BUGREPORT_WIFI &&
120 bugreport_mode != Dumpstate::BugreportMode::BUGREPORT_DEFAULT) {
121 MYLOGE("Invalid input: bad bugreport mode: %d", bugreport_mode);
122 signalErrorAndExit(listener, IDumpstateListener::BUGREPORT_ERROR_INVALID_INPUT);
123 }
124
125 std::unique_ptr<Dumpstate::DumpOptions> options = std::make_unique<Dumpstate::DumpOptions>();
126 options->Initialize(static_cast<Dumpstate::BugreportMode>(bugreport_mode), bugreport_fd,
127 screenshot_fd, is_screenshot_requested);
128
129 if (bugreport_fd.get() == -1 || (options->do_screenshot && screenshot_fd.get() == -1)) {
130 MYLOGE("Invalid filedescriptor");
131 signalErrorAndExit(listener, IDumpstateListener::BUGREPORT_ERROR_INVALID_INPUT);
132 }
133
134
135 ds_ = &(Dumpstate::GetInstance());
136 ds_->SetOptions(std::move(options));
137 ds_->listener_ = listener;
138
139 // Track caller info for cancellation purposes.
140 calling_uid_ = calling_uid;
141 calling_package_ = calling_package;
142
143 DumpstateInfo* ds_info = new DumpstateInfo();
144 ds_info->ds = ds_;
145 ds_info->calling_uid = calling_uid;
146 ds_info->calling_package = calling_package;
147
148 pthread_t thread;
149 // Initialize dumpstate
150 ds_->Initialize();
151 status_t err = pthread_create(&thread, nullptr, dumpstate_thread_main, ds_info);
152 if (err != 0) {
153 delete ds_info;
154 ds_info = nullptr;
155 MYLOGE("Could not create a thread");
156 signalErrorAndExit(listener, IDumpstateListener::BUGREPORT_ERROR_RUNTIME_ERROR);
157 }
158 return binder::Status::ok();
159 }
160
cancelBugreport(int32_t calling_uid,const std::string & calling_package)161 binder::Status DumpstateService::cancelBugreport(int32_t calling_uid,
162 const std::string& calling_package) {
163 std::lock_guard<std::mutex> lock(lock_);
164 if (calling_uid != calling_uid_ || calling_package != calling_package_) {
165 // Note: we use a SecurityException to prevent BugreportManagerServiceImpl from killing the
166 // report in progress (from another caller).
167 return exception(
168 binder::Status::EX_SECURITY,
169 StringPrintf("Cancellation requested by %d/%s does not match report in "
170 "progress",
171 calling_uid, calling_package.c_str()),
172 // Sharing the owner of the BR is a (minor) leak, so leave it out of the app's exception
173 StringPrintf("started by %d/%s", calling_uid_, calling_package_.c_str()));
174 }
175 ds_->Cancel();
176 return binder::Status::ok();
177 }
178
dump(int fd,const Vector<String16> &)179 status_t DumpstateService::dump(int fd, const Vector<String16>&) {
180 std::lock_guard<std::mutex> lock(lock_);
181 if (ds_ == nullptr) {
182 dprintf(fd, "Bugreport not in progress yet");
183 return NO_ERROR;
184 }
185 std::string destination = ds_->options_->bugreport_fd.get() != -1
186 ? StringPrintf("[fd:%d]", ds_->options_->bugreport_fd.get())
187 : ds_->bugreport_internal_dir_.c_str();
188 dprintf(fd, "id: %d\n", ds_->id_);
189 dprintf(fd, "pid: %d\n", ds_->pid_);
190 dprintf(fd, "update_progress: %s\n", ds_->options_->do_progress_updates ? "true" : "false");
191 dprintf(fd, "last_percent_progress: %d\n", ds_->last_reported_percent_progress_);
192 dprintf(fd, "progress:\n");
193 ds_->progress_->Dump(fd, " ");
194 dprintf(fd, "args: %s\n", ds_->options_->args.c_str());
195 dprintf(fd, "bugreport_mode: %s\n", ds_->options_->bugreport_mode.c_str());
196 dprintf(fd, "version: %s\n", ds_->version_.c_str());
197 dprintf(fd, "bugreport_dir: %s\n", destination.c_str());
198 dprintf(fd, "screenshot_path: %s\n", ds_->screenshot_path_.c_str());
199 dprintf(fd, "log_path: %s\n", ds_->log_path_.c_str());
200 dprintf(fd, "tmp_path: %s\n", ds_->tmp_path_.c_str());
201 dprintf(fd, "path: %s\n", ds_->path_.c_str());
202 dprintf(fd, "base_name: %s\n", ds_->base_name_.c_str());
203 dprintf(fd, "name: %s\n", ds_->name_.c_str());
204 dprintf(fd, "now: %ld\n", ds_->now_);
205 dprintf(fd, "is_zipping: %s\n", ds_->IsZipping() ? "true" : "false");
206 dprintf(fd, "notification title: %s\n", ds_->options_->notification_title.c_str());
207 dprintf(fd, "notification description: %s\n", ds_->options_->notification_description.c_str());
208
209 return NO_ERROR;
210 }
211 } // namespace os
212 } // namespace android
213