| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/crash/tools/crash_service.h" | |
| 6 | |
| 7 #include <windows.h> | |
| 8 | |
| 9 #include <sddl.h> | |
| 10 #include <fstream> | |
| 11 #include <map> | |
| 12 | |
| 13 #include "base/command_line.h" | |
| 14 #include "base/files/file_util.h" | |
| 15 #include "base/logging.h" | |
| 16 #include "base/win/windows_version.h" | |
| 17 #include "breakpad/src/client/windows/crash_generation/client_info.h" | |
| 18 #include "breakpad/src/client/windows/crash_generation/crash_generation_server.h
" | |
| 19 #include "breakpad/src/client/windows/sender/crash_report_sender.h" | |
| 20 | |
| 21 namespace breakpad { | |
| 22 | |
| 23 namespace { | |
| 24 | |
| 25 const wchar_t kTestPipeName[] = L"\\\\.\\pipe\\ChromeCrashServices"; | |
| 26 | |
| 27 const wchar_t kCrashReportURL[] = L"https://clients2.google.com/cr/report"; | |
| 28 const wchar_t kCheckPointFile[] = L"crash_checkpoint.txt"; | |
| 29 | |
| 30 typedef std::map<std::wstring, std::wstring> CrashMap; | |
| 31 | |
| 32 bool CustomInfoToMap(const google_breakpad::ClientInfo* client_info, | |
| 33 const std::wstring& reporter_tag, CrashMap* map) { | |
| 34 google_breakpad::CustomClientInfo info = client_info->GetCustomInfo(); | |
| 35 | |
| 36 for (uintptr_t i = 0; i < info.count; ++i) { | |
| 37 (*map)[info.entries[i].name] = info.entries[i].value; | |
| 38 } | |
| 39 | |
| 40 (*map)[L"rept"] = reporter_tag; | |
| 41 | |
| 42 return !map->empty(); | |
| 43 } | |
| 44 | |
| 45 bool WriteCustomInfoToFile(const std::wstring& dump_path, const CrashMap& map) { | |
| 46 std::wstring file_path(dump_path); | |
| 47 size_t last_dot = file_path.rfind(L'.'); | |
| 48 if (last_dot == std::wstring::npos) | |
| 49 return false; | |
| 50 file_path.resize(last_dot); | |
| 51 file_path += L".txt"; | |
| 52 | |
| 53 std::wofstream file(file_path.c_str(), | |
| 54 std::ios_base::out | std::ios_base::app | std::ios::binary); | |
| 55 if (!file.is_open()) | |
| 56 return false; | |
| 57 | |
| 58 CrashMap::const_iterator pos; | |
| 59 for (pos = map.begin(); pos != map.end(); ++pos) { | |
| 60 std::wstring line = pos->first; | |
| 61 line += L':'; | |
| 62 line += pos->second; | |
| 63 line += L'\n'; | |
| 64 file.write(line.c_str(), static_cast<std::streamsize>(line.length())); | |
| 65 } | |
| 66 return true; | |
| 67 } | |
| 68 | |
| 69 // The window procedure task is to handle when a) the user logs off. | |
| 70 // b) the system shuts down or c) when the user closes the window. | |
| 71 LRESULT __stdcall CrashSvcWndProc(HWND hwnd, UINT message, | |
| 72 WPARAM wparam, LPARAM lparam) { | |
| 73 switch (message) { | |
| 74 case WM_CLOSE: | |
| 75 case WM_ENDSESSION: | |
| 76 case WM_DESTROY: | |
| 77 PostQuitMessage(0); | |
| 78 break; | |
| 79 default: | |
| 80 return DefWindowProc(hwnd, message, wparam, lparam); | |
| 81 } | |
| 82 return 0; | |
| 83 } | |
| 84 | |
| 85 // This is the main and only application window. | |
| 86 HWND g_top_window = NULL; | |
| 87 | |
| 88 bool CreateTopWindow(HINSTANCE instance, bool visible) { | |
| 89 WNDCLASSEXW wcx = {0}; | |
| 90 wcx.cbSize = sizeof(wcx); | |
| 91 wcx.style = CS_HREDRAW | CS_VREDRAW; | |
| 92 wcx.lpfnWndProc = CrashSvcWndProc; | |
| 93 wcx.hInstance = instance; | |
| 94 wcx.lpszClassName = L"crash_svc_class"; | |
| 95 ::RegisterClassExW(&wcx); | |
| 96 DWORD style = visible ? WS_POPUPWINDOW | WS_VISIBLE : WS_OVERLAPPED; | |
| 97 | |
| 98 // The window size is zero but being a popup window still shows in the | |
| 99 // task bar and can be closed using the system menu or using task manager. | |
| 100 HWND window = CreateWindowExW(0, wcx.lpszClassName, L"crash service", style, | |
| 101 CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, | |
| 102 NULL, NULL, instance, NULL); | |
| 103 if (!window) | |
| 104 return false; | |
| 105 | |
| 106 ::UpdateWindow(window); | |
| 107 VLOG(1) << "window handle is " << window; | |
| 108 g_top_window = window; | |
| 109 return true; | |
| 110 } | |
| 111 | |
| 112 // Simple helper class to keep the process alive until the current request | |
| 113 // finishes. | |
| 114 class ProcessingLock { | |
| 115 public: | |
| 116 ProcessingLock() { | |
| 117 ::InterlockedIncrement(&op_count_); | |
| 118 } | |
| 119 ~ProcessingLock() { | |
| 120 ::InterlockedDecrement(&op_count_); | |
| 121 } | |
| 122 static bool IsWorking() { | |
| 123 return (op_count_ != 0); | |
| 124 } | |
| 125 private: | |
| 126 static volatile LONG op_count_; | |
| 127 }; | |
| 128 | |
| 129 volatile LONG ProcessingLock::op_count_ = 0; | |
| 130 | |
| 131 // This structure contains the information that the worker thread needs to | |
| 132 // send a crash dump to the server. | |
| 133 struct DumpJobInfo { | |
| 134 DWORD pid; | |
| 135 CrashService* self; | |
| 136 CrashMap map; | |
| 137 std::wstring dump_path; | |
| 138 | |
| 139 DumpJobInfo(DWORD process_id, CrashService* service, | |
| 140 const CrashMap& crash_map, const std::wstring& path) | |
| 141 : pid(process_id), self(service), map(crash_map), dump_path(path) { | |
| 142 } | |
| 143 }; | |
| 144 | |
| 145 } // namespace | |
| 146 | |
| 147 // Command line switches: | |
| 148 const char CrashService::kMaxReports[] = "max-reports"; | |
| 149 const char CrashService::kNoWindow[] = "no-window"; | |
| 150 const char CrashService::kReporterTag[] = "reporter"; | |
| 151 const char CrashService::kDumpsDir[] = "dumps-dir"; | |
| 152 const char CrashService::kPipeName[] = "pipe-name"; | |
| 153 | |
| 154 CrashService::CrashService() | |
| 155 : dumper_(NULL), | |
| 156 sender_(NULL), | |
| 157 requests_handled_(0), | |
| 158 requests_sent_(0), | |
| 159 clients_connected_(0), | |
| 160 clients_terminated_(0) { | |
| 161 } | |
| 162 | |
| 163 CrashService::~CrashService() { | |
| 164 base::AutoLock lock(sending_); | |
| 165 delete dumper_; | |
| 166 delete sender_; | |
| 167 } | |
| 168 | |
| 169 bool CrashService::Initialize(const base::FilePath& operating_dir, | |
| 170 const base::FilePath& dumps_path) { | |
| 171 using google_breakpad::CrashReportSender; | |
| 172 using google_breakpad::CrashGenerationServer; | |
| 173 | |
| 174 std::wstring pipe_name = kTestPipeName; | |
| 175 int max_reports = -1; | |
| 176 | |
| 177 // The checkpoint file allows CrashReportSender to enforce the the maximum | |
| 178 // reports per day quota. Does not seem to serve any other purpose. | |
| 179 base::FilePath checkpoint_path = operating_dir.Append(kCheckPointFile); | |
| 180 | |
| 181 base::CommandLine& cmd_line = *base::CommandLine::ForCurrentProcess(); | |
| 182 | |
| 183 base::FilePath dumps_path_to_use = dumps_path; | |
| 184 | |
| 185 if (cmd_line.HasSwitch(kDumpsDir)) { | |
| 186 dumps_path_to_use = | |
| 187 base::FilePath(cmd_line.GetSwitchValueNative(kDumpsDir)); | |
| 188 } | |
| 189 | |
| 190 // We can override the send reports quota with a command line switch. | |
| 191 if (cmd_line.HasSwitch(kMaxReports)) | |
| 192 max_reports = _wtoi(cmd_line.GetSwitchValueNative(kMaxReports).c_str()); | |
| 193 | |
| 194 // Allow the global pipe name to be overridden for better testability. | |
| 195 if (cmd_line.HasSwitch(kPipeName)) | |
| 196 pipe_name = cmd_line.GetSwitchValueNative(kPipeName); | |
| 197 | |
| 198 #ifdef _WIN64 | |
| 199 pipe_name += L"-x64"; | |
| 200 #endif | |
| 201 | |
| 202 if (max_reports > 0) { | |
| 203 // Create the http sender object. | |
| 204 sender_ = new CrashReportSender(checkpoint_path.value()); | |
| 205 sender_->set_max_reports_per_day(max_reports); | |
| 206 } | |
| 207 | |
| 208 SECURITY_ATTRIBUTES security_attributes = {0}; | |
| 209 SECURITY_ATTRIBUTES* security_attributes_actual = NULL; | |
| 210 | |
| 211 if (base::win::GetVersion() >= base::win::VERSION_VISTA) { | |
| 212 SECURITY_DESCRIPTOR* security_descriptor = | |
| 213 reinterpret_cast<SECURITY_DESCRIPTOR*>( | |
| 214 GetSecurityDescriptorForLowIntegrity()); | |
| 215 DCHECK(security_descriptor != NULL); | |
| 216 | |
| 217 security_attributes.nLength = sizeof(security_attributes); | |
| 218 security_attributes.lpSecurityDescriptor = security_descriptor; | |
| 219 security_attributes.bInheritHandle = FALSE; | |
| 220 | |
| 221 security_attributes_actual = &security_attributes; | |
| 222 } | |
| 223 | |
| 224 // Create the OOP crash generator object. | |
| 225 dumper_ = new CrashGenerationServer(pipe_name, security_attributes_actual, | |
| 226 &CrashService::OnClientConnected, this, | |
| 227 &CrashService::OnClientDumpRequest, this, | |
| 228 &CrashService::OnClientExited, this, | |
| 229 NULL, NULL, | |
| 230 true, &dumps_path_to_use.value()); | |
| 231 | |
| 232 if (!dumper_) { | |
| 233 LOG(ERROR) << "could not create dumper"; | |
| 234 if (security_attributes.lpSecurityDescriptor) | |
| 235 LocalFree(security_attributes.lpSecurityDescriptor); | |
| 236 return false; | |
| 237 } | |
| 238 | |
| 239 if (!CreateTopWindow(::GetModuleHandleW(NULL), | |
| 240 !cmd_line.HasSwitch(kNoWindow))) { | |
| 241 LOG(ERROR) << "could not create window"; | |
| 242 if (security_attributes.lpSecurityDescriptor) | |
| 243 LocalFree(security_attributes.lpSecurityDescriptor); | |
| 244 return false; | |
| 245 } | |
| 246 | |
| 247 reporter_tag_ = L"crash svc"; | |
| 248 if (cmd_line.HasSwitch(kReporterTag)) | |
| 249 reporter_tag_ = cmd_line.GetSwitchValueNative(kReporterTag); | |
| 250 | |
| 251 // Log basic information. | |
| 252 VLOG(1) << "pipe name is " << pipe_name | |
| 253 << "\ndumps at " << dumps_path_to_use.value(); | |
| 254 | |
| 255 if (sender_) { | |
| 256 VLOG(1) << "checkpoint is " << checkpoint_path.value() | |
| 257 << "\nserver is " << kCrashReportURL | |
| 258 << "\nmaximum " << sender_->max_reports_per_day() << " reports/day" | |
| 259 << "\nreporter is " << reporter_tag_; | |
| 260 } | |
| 261 // Start servicing clients. | |
| 262 if (!dumper_->Start()) { | |
| 263 LOG(ERROR) << "could not start dumper"; | |
| 264 if (security_attributes.lpSecurityDescriptor) | |
| 265 LocalFree(security_attributes.lpSecurityDescriptor); | |
| 266 return false; | |
| 267 } | |
| 268 | |
| 269 if (security_attributes.lpSecurityDescriptor) | |
| 270 LocalFree(security_attributes.lpSecurityDescriptor); | |
| 271 | |
| 272 // This is throwaway code. We don't need to sync with the browser process | |
| 273 // once Google Update is updated to a version supporting OOP crash handling. | |
| 274 // Create or open an event to signal the browser process that the crash | |
| 275 // service is initialized. | |
| 276 HANDLE running_event = | |
| 277 ::CreateEventW(NULL, TRUE, TRUE, L"g_chrome_crash_svc"); | |
| 278 // If the browser already had the event open, the CreateEvent call did not | |
| 279 // signal it. We need to do it manually. | |
| 280 ::SetEvent(running_event); | |
| 281 | |
| 282 return true; | |
| 283 } | |
| 284 | |
| 285 void CrashService::OnClientConnected(void* context, | |
| 286 const google_breakpad::ClientInfo* client_info) { | |
| 287 ProcessingLock lock; | |
| 288 VLOG(1) << "client start. pid = " << client_info->pid(); | |
| 289 CrashService* self = static_cast<CrashService*>(context); | |
| 290 ::InterlockedIncrement(&self->clients_connected_); | |
| 291 } | |
| 292 | |
| 293 void CrashService::OnClientExited(void* context, | |
| 294 const google_breakpad::ClientInfo* client_info) { | |
| 295 ProcessingLock lock; | |
| 296 VLOG(1) << "client end. pid = " << client_info->pid(); | |
| 297 CrashService* self = static_cast<CrashService*>(context); | |
| 298 ::InterlockedIncrement(&self->clients_terminated_); | |
| 299 | |
| 300 if (!self->sender_) | |
| 301 return; | |
| 302 | |
| 303 // When we are instructed to send reports we need to exit if there are | |
| 304 // no more clients to service. The next client that runs will start us. | |
| 305 // Only chrome.exe starts crash_service with a non-zero max_reports. | |
| 306 if (self->clients_connected_ > self->clients_terminated_) | |
| 307 return; | |
| 308 if (self->sender_->max_reports_per_day() > 0) { | |
| 309 // Wait for the other thread to send crashes, if applicable. The sender | |
| 310 // thread takes the sending_ lock, so the sleep is just to give it a | |
| 311 // chance to start. | |
| 312 ::Sleep(1000); | |
| 313 base::AutoLock lock(self->sending_); | |
| 314 // Some people can restart chrome very fast, check again if we have | |
| 315 // a new client before exiting for real. | |
| 316 if (self->clients_connected_ == self->clients_terminated_) { | |
| 317 VLOG(1) << "zero clients. exiting"; | |
| 318 ::PostMessage(g_top_window, WM_CLOSE, 0, 0); | |
| 319 } | |
| 320 } | |
| 321 } | |
| 322 | |
| 323 void CrashService::OnClientDumpRequest(void* context, | |
| 324 const google_breakpad::ClientInfo* client_info, | |
| 325 const std::wstring* file_path) { | |
| 326 ProcessingLock lock; | |
| 327 | |
| 328 if (!file_path) { | |
| 329 LOG(ERROR) << "dump with no file path"; | |
| 330 return; | |
| 331 } | |
| 332 if (!client_info) { | |
| 333 LOG(ERROR) << "dump with no client info"; | |
| 334 return; | |
| 335 } | |
| 336 | |
| 337 CrashService* self = static_cast<CrashService*>(context); | |
| 338 if (!self) { | |
| 339 LOG(ERROR) << "dump with no context"; | |
| 340 return; | |
| 341 } | |
| 342 | |
| 343 CrashMap map; | |
| 344 CustomInfoToMap(client_info, self->reporter_tag_, &map); | |
| 345 | |
| 346 // Move dump file to the directory under client breakpad dump location. | |
| 347 base::FilePath dump_location = base::FilePath(*file_path); | |
| 348 CrashMap::const_iterator it = map.find(L"breakpad-dump-location"); | |
| 349 if (it != map.end()) { | |
| 350 base::FilePath alternate_dump_location = base::FilePath(it->second); | |
| 351 base::CreateDirectoryW(alternate_dump_location); | |
| 352 alternate_dump_location = alternate_dump_location.Append( | |
| 353 dump_location.BaseName()); | |
| 354 base::Move(dump_location, alternate_dump_location); | |
| 355 dump_location = alternate_dump_location; | |
| 356 } | |
| 357 | |
| 358 DWORD pid = client_info->pid(); | |
| 359 VLOG(1) << "dump for pid = " << pid << " is " << dump_location.value(); | |
| 360 | |
| 361 if (!WriteCustomInfoToFile(dump_location.value(), map)) { | |
| 362 LOG(ERROR) << "could not write custom info file"; | |
| 363 } | |
| 364 | |
| 365 if (!self->sender_) | |
| 366 return; | |
| 367 | |
| 368 // Send the crash dump using a worker thread. This operation has retry | |
| 369 // logic in case there is no internet connection at the time. | |
| 370 DumpJobInfo* dump_job = new DumpJobInfo(pid, self, map, | |
| 371 dump_location.value()); | |
| 372 if (!::QueueUserWorkItem(&CrashService::AsyncSendDump, | |
| 373 dump_job, WT_EXECUTELONGFUNCTION)) { | |
| 374 LOG(ERROR) << "could not queue job"; | |
| 375 } | |
| 376 } | |
| 377 | |
| 378 // We are going to try sending the report several times. If we can't send, | |
| 379 // we sleep from one minute to several hours depending on the retry round. | |
| 380 unsigned long CrashService::AsyncSendDump(void* context) { | |
| 381 if (!context) | |
| 382 return 0; | |
| 383 | |
| 384 DumpJobInfo* info = static_cast<DumpJobInfo*>(context); | |
| 385 | |
| 386 std::wstring report_id = L"<unsent>"; | |
| 387 | |
| 388 const DWORD kOneMinute = 60*1000; | |
| 389 const DWORD kOneHour = 60*kOneMinute; | |
| 390 | |
| 391 const DWORD kSleepSchedule[] = { | |
| 392 24*kOneHour, | |
| 393 8*kOneHour, | |
| 394 4*kOneHour, | |
| 395 kOneHour, | |
| 396 15*kOneMinute, | |
| 397 0}; | |
| 398 | |
| 399 int retry_round = arraysize(kSleepSchedule) - 1; | |
| 400 | |
| 401 do { | |
| 402 ::Sleep(kSleepSchedule[retry_round]); | |
| 403 { | |
| 404 // Take the server lock while sending. This also prevent early | |
| 405 // termination of the service object. | |
| 406 base::AutoLock lock(info->self->sending_); | |
| 407 VLOG(1) << "trying to send report for pid = " << info->pid; | |
| 408 google_breakpad::ReportResult send_result | |
| 409 = info->self->sender_->SendCrashReport(kCrashReportURL, info->map, | |
| 410 info->dump_path, &report_id); | |
| 411 switch (send_result) { | |
| 412 case google_breakpad::RESULT_FAILED: | |
| 413 report_id = L"<network issue>"; | |
| 414 break; | |
| 415 case google_breakpad::RESULT_REJECTED: | |
| 416 report_id = L"<rejected>"; | |
| 417 ++info->self->requests_handled_; | |
| 418 retry_round = 0; | |
| 419 break; | |
| 420 case google_breakpad::RESULT_SUCCEEDED: | |
| 421 ++info->self->requests_sent_; | |
| 422 ++info->self->requests_handled_; | |
| 423 retry_round = 0; | |
| 424 break; | |
| 425 case google_breakpad::RESULT_THROTTLED: | |
| 426 report_id = L"<throttled>"; | |
| 427 break; | |
| 428 default: | |
| 429 report_id = L"<unknown>"; | |
| 430 break; | |
| 431 }; | |
| 432 } | |
| 433 | |
| 434 VLOG(1) << "dump for pid =" << info->pid << " crash2 id =" << report_id; | |
| 435 --retry_round; | |
| 436 } while (retry_round >= 0); | |
| 437 | |
| 438 if (!::DeleteFileW(info->dump_path.c_str())) | |
| 439 LOG(WARNING) << "could not delete " << info->dump_path; | |
| 440 | |
| 441 delete info; | |
| 442 return 0; | |
| 443 } | |
| 444 | |
| 445 int CrashService::ProcessingLoop() { | |
| 446 MSG msg; | |
| 447 while (GetMessage(&msg, NULL, 0, 0)) { | |
| 448 TranslateMessage(&msg); | |
| 449 DispatchMessage(&msg); | |
| 450 } | |
| 451 | |
| 452 VLOG(1) << "session ending.."; | |
| 453 while (ProcessingLock::IsWorking()) { | |
| 454 ::Sleep(50); | |
| 455 } | |
| 456 | |
| 457 VLOG(1) << "clients connected :" << clients_connected_ | |
| 458 << "\nclients terminated :" << clients_terminated_ | |
| 459 << "\ndumps serviced :" << requests_handled_ | |
| 460 << "\ndumps reported :" << requests_sent_; | |
| 461 | |
| 462 return static_cast<int>(msg.wParam); | |
| 463 } | |
| 464 | |
| 465 PSECURITY_DESCRIPTOR CrashService::GetSecurityDescriptorForLowIntegrity() { | |
| 466 // Build the SDDL string for the label. | |
| 467 std::wstring sddl = L"S:(ML;;NW;;;S-1-16-4096)"; | |
| 468 | |
| 469 PSECURITY_DESCRIPTOR sec_desc = NULL; | |
| 470 | |
| 471 PACL sacl = NULL; | |
| 472 BOOL sacl_present = FALSE; | |
| 473 BOOL sacl_defaulted = FALSE; | |
| 474 | |
| 475 if (::ConvertStringSecurityDescriptorToSecurityDescriptorW(sddl.c_str(), | |
| 476 SDDL_REVISION, | |
| 477 &sec_desc, NULL)) { | |
| 478 if (::GetSecurityDescriptorSacl(sec_desc, &sacl_present, &sacl, | |
| 479 &sacl_defaulted)) { | |
| 480 return sec_desc; | |
| 481 } | |
| 482 } | |
| 483 | |
| 484 return NULL; | |
| 485 } | |
| 486 | |
| 487 } // namespace breakpad | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1315303004:
Turn components/crash into a layered component. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master