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
|
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/windows_services/elevated_tracing_service/system_tracing_session.h"
#include <windows.h>
#include <utility>
#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/task/sequenced_task_runner.h"
#include "base/win/win_util.h"
#include "chrome/windows_services/elevated_tracing_service/service_integration.h"
#include "chrome/windows_services/service_program/crash_reporting.h"
#include "chrome/windows_services/service_program/get_calling_process.h"
#include "chrome/windows_services/service_program/scoped_client_impersonation.h"
#include "chrome/windows_services/service_program/user_crash_state.h"
#include "components/tracing/common/etw_system_data_source_win.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/platform/named_platform_channel.h"
#include "mojo/public/cpp/platform/platform_channel_endpoint.h"
#include "mojo/public/cpp/system/handle.h"
#include "mojo/public/cpp/system/invitation.h"
#include "mojo/public/cpp/system/message_pipe.h"
#include "services/tracing/public/cpp/traced_process.h"
namespace elevated_tracing_service {
namespace {
// Invoked on the main service thread.
void OnTracedProcessReceiver(base::ProcessId client_pid,
mojo::ScopedMessagePipeHandle pipe) {
// Register the ETW data source the first time a handle is received.
[[maybe_unused]] static const bool etw_data_source_registered = [client_pid] {
tracing::EtwSystemDataSource::Register(client_pid);
return true;
}();
// Drop any previous connection before accepting the new one.
tracing::TracedProcess::ResetTracedProcessReceiver();
tracing::TracedProcess::OnTracedProcessRequest(
mojo::PendingReceiver<tracing::mojom::TracedProcess>(std::move(pipe)));
}
} // namespace
SystemTracingSession::SystemTracingSession() = default;
HRESULT SystemTracingSession::RuntimeClassInitialize(
scoped_refptr<base::SequencedTaskRunner> task_runner) {
task_runner_ = std::move(task_runner);
return S_OK;
}
// Invoked on an arbitrary RPC thread.
HRESULT SystemTracingSession::AcceptInvitation(const wchar_t* server_name,
DWORD* pid) {
if (!pid || !server_name || !*server_name) {
return E_INVALIDARG;
}
*pid = base::kNullProcessId;
if (session_) {
return kErrorSessionAlreadyActive;
}
// Impersonate the client to get a handle to the client's process and per-user
// state related to crash handling.
base::Process client_process;
std::unique_ptr<UserCrashState> user_crash_state;
if (ScopedClientImpersonation impersonate; impersonate.is_valid()) {
client_process = GetCallingProcess();
if (!client_process.IsValid()) {
return kErrorCouldNotObtainCallingProcess;
}
user_crash_state = UserCrashState::Create(impersonate, client_process);
} else {
return impersonate.result();
}
// Get a handle to the client process with appropriate rights.
const auto client_pid = client_process.Pid();
if (client_pid != base::kNullProcessId) {
if (auto dup = base::Process::OpenWithAccess(client_pid, SYNCHRONIZE);
dup.IsValid()) {
std::swap(client_process, dup);
} else {
return kErrorCouldNotOpenCallingProcess;
}
} else {
return kErrorCouldNotGetCallingProcessPid;
}
// This instance is ready to become the active session provided that there
// isn't one already.
auto session = SessionRegistry::RegisterActiveSession(
CastToUnknown(), std::move(client_process));
if (!session) {
return kErrorSessionInProgress;
}
// Start the crash handler with a user-specific database.
if (user_crash_state) {
windows_services::StartCrashHandler(
std::move(user_crash_state),
/*directory_name=*/elevated_tracing_service::GetStorageDirBasename(),
/*process_type=*/"elevated-tracing-service", task_runner_);
}
auto endpoint = mojo::NamedPlatformChannel::ConnectToServer(server_name);
if (!endpoint.is_valid()) {
return E_INVALIDARG; // Invalid channel name.
}
mojo::IncomingInvitation invitation = mojo::IncomingInvitation::Accept(
std::move(endpoint), MOJO_ACCEPT_INVITATION_FLAG_ELEVATED);
if (!invitation.is_valid()) {
return E_INVALIDARG;
}
task_runner_->PostTask(
FROM_HERE, base::BindOnce(&OnTracedProcessReceiver, client_pid,
invitation.ExtractMessagePipe(/*name=*/0)));
session_ = std::move(session);
*pid = ::GetCurrentProcessId();
return S_OK;
}
SystemTracingSession::~SystemTracingSession() = default;
} // namespace elevated_tracing_service
|
