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
|
// Copyright 2014 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.
#include "base/debug/gdi_debug_util_win.h"
#include <algorithm>
#include <cmath>
#include <psapi.h>
#include <stddef.h>
#include <TlHelp32.h>
#include "base/debug/alias.h"
#include "base/logging.h"
#include "base/win/scoped_handle.h"
#include "base/win/win_util.h"
namespace {
void CollectChildGDIUsageAndDie(DWORD parent_pid) {
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
CHECK_NE(INVALID_HANDLE_VALUE, snapshot);
int total_process_count = 0;
base::debug::Alias(&total_process_count);
int total_peak_gdi_count = 0;
base::debug::Alias(&total_peak_gdi_count);
int total_gdi_count = 0;
base::debug::Alias(&total_gdi_count);
int total_user_count = 0;
base::debug::Alias(&total_user_count);
int child_count = 0;
base::debug::Alias(&child_count);
int peak_gdi_count = 0;
base::debug::Alias(&peak_gdi_count);
int sum_gdi_count = 0;
base::debug::Alias(&sum_gdi_count);
int sum_user_count = 0;
base::debug::Alias(&sum_user_count);
PROCESSENTRY32 proc_entry = {0};
proc_entry.dwSize = sizeof(PROCESSENTRY32);
CHECK(Process32First(snapshot, &proc_entry));
do {
base::win::ScopedHandle process(
OpenProcess(PROCESS_QUERY_INFORMATION,
FALSE,
proc_entry.th32ProcessID));
if (!process.IsValid())
continue;
int num_gdi_handles = GetGuiResources(process.Get(), GR_GDIOBJECTS);
int num_user_handles = GetGuiResources(process.Get(), GR_USEROBJECTS);
// Compute sum and peak counts for all processes.
++total_process_count;
total_user_count += num_user_handles;
total_gdi_count += num_gdi_handles;
total_peak_gdi_count = std::max(total_peak_gdi_count, num_gdi_handles);
if (parent_pid != proc_entry.th32ParentProcessID)
continue;
// Compute sum and peak counts for child processes.
++child_count;
sum_user_count += num_user_handles;
sum_gdi_count += num_gdi_handles;
peak_gdi_count = std::max(peak_gdi_count, num_gdi_handles);
} while (Process32Next(snapshot, &proc_entry));
CloseHandle(snapshot);
CHECK(false);
}
} // namespace
namespace base {
namespace debug {
void CollectGDIUsageAndDie(BITMAPINFOHEADER* header, HANDLE shared_section) {
// Make sure parameters are saved in the minidump.
DWORD last_error = GetLastError();
bool is_gdi_available = base::win::IsUser32AndGdi32Available();
LONG width = header ? header->biWidth : 0;
LONG height = header ? header->biHeight : 0;
base::debug::Alias(&last_error);
base::debug::Alias(&is_gdi_available);
base::debug::Alias(&width);
base::debug::Alias(&height);
base::debug::Alias(&shared_section);
DWORD num_user_handles = GetGuiResources(GetCurrentProcess(), GR_USEROBJECTS);
DWORD num_gdi_handles = GetGuiResources(GetCurrentProcess(), GR_GDIOBJECTS);
if (num_gdi_handles == 0) {
DWORD get_gui_resources_error = GetLastError();
base::debug::Alias(&get_gui_resources_error);
CHECK(false);
}
base::debug::Alias(&num_gdi_handles);
base::debug::Alias(&num_user_handles);
const DWORD kLotsOfHandles = 9990;
CHECK_LE(num_gdi_handles, kLotsOfHandles);
PROCESS_MEMORY_COUNTERS_EX pmc;
pmc.cb = sizeof(pmc);
CHECK(GetProcessMemoryInfo(GetCurrentProcess(),
reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&pmc),
sizeof(pmc)));
const size_t kLotsOfMemory = 1500 * 1024 * 1024; // 1.5GB
CHECK_LE(pmc.PagefileUsage, kLotsOfMemory);
CHECK_LE(pmc.PrivateUsage, kLotsOfMemory);
void* small_data = nullptr;
base::debug::Alias(&small_data);
if (std::abs(height) * width > 100) {
// Huh, that's weird. We don't have crazy handle count, we don't have
// ridiculous memory usage. Try to allocate a small bitmap and see if that
// fails too.
header->biWidth = 5;
header->biHeight = -5;
HBITMAP small_bitmap = CreateDIBSection(
nullptr, reinterpret_cast<BITMAPINFO*>(&header),
0, &small_data, shared_section, 0);
CHECK(small_bitmap != nullptr);
DeleteObject(small_bitmap);
}
// Maybe the child processes are the ones leaking GDI or USER resouces.
CollectChildGDIUsageAndDie(GetCurrentProcessId());
}
} // namespace debug
} // namespace base
|
