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 "chrome/app/image_pre_reader_win.h" 6 7 #include <windows.h> 8 #include <algorithm> 9 #include <limits> 10 #include <vector> 11 12 #include "base/logging.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "base/threading/thread_restrictions.h" 15 #include "base/win/pe_image.h" 16 #include "base/win/scoped_handle.h" 17 #include "base/win/windows_version.h" 18 19 namespace { 20 21 // The minimum buffer size to allocate when reading the PE file headers. 22 // 23 // The PE file headers usually fit into a single 1KB page, and a PE file must 24 // at least contain the initial page with the headers. That said, as long as 25 // we expect at least sizeof(IMAGE_DOS_HEADER) bytes, we're ok. 26 const size_t kMinHeaderBufferSize = 0x400; 27 28 // A handy symbolic constant. 29 const size_t kOneHundredPercent = 100; 30 31 void StaticAssertions() { 32 COMPILE_ASSERT(kMinHeaderBufferSize >= sizeof(IMAGE_DOS_HEADER), 33 min_header_buffer_size_at_least_as_big_as_the_dos_header); 34 } 35 36 // This struct provides a deallocation functor for use with scoped_ptr<T> 37 // allocated with ::VirtualAlloc(). 38 struct VirtualFreeDeleter { 39 void operator() (void* ptr) { 40 ::VirtualFree(ptr, 0, MEM_RELEASE); 41 } 42 }; 43 44 // A wrapper for the Win32 ::SetFilePointer() function with some error checking. 45 bool SetFilePointer(HANDLE file_handle, size_t position) { 46 return position <= static_cast<size_t>(std::numeric_limits<LONG>::max()) && 47 ::SetFilePointer(file_handle, 48 static_cast<LONG>(position), 49 NULL, 50 FILE_BEGIN) != INVALID_SET_FILE_POINTER; 51 } 52 53 // A helper function to read the next |bytes_to_read| bytes from the file 54 // given by |file_handle| into |buffer|. 55 bool ReadNextBytes(HANDLE file_handle, void* buffer, size_t bytes_to_read) { 56 DCHECK(file_handle != INVALID_HANDLE_VALUE); 57 DCHECK(buffer != NULL); 58 DCHECK(bytes_to_read > 0); 59 60 DWORD bytes_read = 0; 61 return bytes_to_read <= std::numeric_limits<DWORD>::max() && 62 ::ReadFile(file_handle, 63 buffer, 64 static_cast<DWORD>(bytes_to_read), 65 &bytes_read, 66 NULL) && 67 bytes_read == bytes_to_read; 68 } 69 70 // A helper function to extend the |current_buffer| of bytes such that it 71 // contains |desired_length| bytes read from the file given by |file_handle|. 72 // 73 // It is assumed that |file_handle| has been used to sequentially populate 74 // |current_buffer| thus far and is already positioned at the appropriate 75 // read location. 76 bool ReadMissingBytes(HANDLE file_handle, 77 std::vector<uint8>* current_buffer, 78 size_t desired_length) { 79 DCHECK(file_handle != INVALID_HANDLE_VALUE); 80 DCHECK(current_buffer != NULL); 81 82 size_t current_length = current_buffer->size(); 83 if (current_length >= desired_length) 84 return true; 85 86 size_t bytes_to_read = desired_length - current_length; 87 current_buffer->resize(desired_length); 88 return ReadNextBytes(file_handle, 89 &(current_buffer->at(current_length)), 90 bytes_to_read); 91 } 92 93 // Return a |percentage| of the number of initialized bytes in the given 94 // |section|. 95 // 96 // This returns a percentage of the lesser of the size of the raw data in 97 // the section and the virtual size of the section. 98 // 99 // Note that sections can have their tails implicitly initialized to zero 100 // (i.e., their virtual size is larger than the raw size) and that raw data 101 // is padded to the PE page size if the entire section is initialized (i.e., 102 // their raw data size will be larger than the virtual size). 103 // 104 // Any data after the initialized portion of the section will be soft-faulted 105 // in (very quickly) as needed, so we don't need to include it in the returned 106 // length. 107 size_t GetPercentageOfSectionLength(const IMAGE_SECTION_HEADER* section, 108 size_t percentage) { 109 DCHECK(section != NULL); 110 DCHECK_GT(percentage, 0u); 111 DCHECK_LE(percentage, kOneHundredPercent); 112 113 size_t initialized_length = std::min(section->SizeOfRawData, 114 section->Misc.VirtualSize); 115 116 if (initialized_length == 0) 117 return 0; 118 119 size_t length = (initialized_length * percentage) / kOneHundredPercent; 120 121 return std::max<size_t>(length, 1); 122 } 123 124 // Helper function to read through a |percentage| of the given |section| 125 // of the file denoted by |file_handle|. The |temp_buffer| is (re)used as 126 // a transient storage area as the section is read in chunks of 127 // |temp_buffer_size| bytes. 128 bool ReadThroughSection(HANDLE file_handle, 129 const IMAGE_SECTION_HEADER* section, 130 size_t percentage, 131 void* temp_buffer, 132 size_t temp_buffer_size) { 133 DCHECK(file_handle != INVALID_HANDLE_VALUE); 134 DCHECK(section != NULL); 135 DCHECK_LE(percentage, kOneHundredPercent); 136 DCHECK(temp_buffer != NULL); 137 DCHECK(temp_buffer_size > 0); 138 139 size_t bytes_to_read = GetPercentageOfSectionLength(section, percentage); 140 if (bytes_to_read == 0) 141 return true; 142 143 if (!SetFilePointer(file_handle, section->PointerToRawData)) 144 return false; 145 146 // Read all chunks except the last one. 147 while (bytes_to_read > temp_buffer_size) { 148 if (!ReadNextBytes(file_handle, temp_buffer, temp_buffer_size)) 149 return false; 150 bytes_to_read -= temp_buffer_size; 151 } 152 153 // Read the last (possibly partial) chunk and return. 154 DCHECK(bytes_to_read > 0); 155 DCHECK(bytes_to_read <= temp_buffer_size); 156 return ReadNextBytes(file_handle, temp_buffer, bytes_to_read); 157 } 158 159 // A helper function to touch all pages in the range 160 // [base_addr, base_addr + length). 161 void TouchPagesInRange(void* base_addr, size_t length) { 162 DCHECK(base_addr != NULL); 163 DCHECK(length > 0); 164 165 // Get the system info so we know the page size. Also, make sure we use a 166 // non-zero value for the page size; GetSystemInfo() is hookable/patchable, 167 // and you never know what shenanigans someone could get up to. 168 SYSTEM_INFO system_info = {}; 169 GetSystemInfo(&system_info); 170 if (system_info.dwPageSize == 0) 171 system_info.dwPageSize = 4096; 172 173 // We don't want to read outside the byte range (which could trigger an 174 // access violation), so let's figure out the exact locations of the first 175 // and final bytes we want to read. 176 volatile uint8* touch_ptr = reinterpret_cast<uint8*>(base_addr); 177 volatile uint8* final_touch_ptr = touch_ptr + length - 1; 178 179 // Read the memory in the range [touch_ptr, final_touch_ptr] with a stride 180 // of the system page size, to ensure that it's been paged in. 181 uint8 dummy; 182 while (touch_ptr < final_touch_ptr) { 183 dummy = *touch_ptr; 184 touch_ptr += system_info.dwPageSize; 185 } 186 dummy = *final_touch_ptr; 187 } 188 189 } // namespace 190 191 bool ImagePreReader::PartialPreReadImageOnDisk(const wchar_t* file_path, 192 size_t percentage, 193 size_t max_chunk_size) { 194 // TODO(rogerm): change this to have the number of bytes pre-read per 195 // section be driven by a static table within the PE file (defaulting to 196 // full read if it's not there?) that's initialized by the optimization 197 // toolchain. 198 DCHECK(file_path != NULL); 199 200 if (percentage == 0) 201 return true; 202 203 if (percentage > kOneHundredPercent) 204 percentage = kOneHundredPercent; 205 206 // Validate/setup max_chunk_size, imposing a 1MB minimum on the chunk size. 207 const size_t kMinChunkSize = 1024 * 1024; 208 max_chunk_size = std::max(max_chunk_size, kMinChunkSize); 209 210 // Open the file. 211 base::win::ScopedHandle file( 212 CreateFile(file_path, 213 GENERIC_READ, 214 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 215 NULL, 216 OPEN_EXISTING, 217 FILE_FLAG_SEQUENTIAL_SCAN, 218 NULL)); 219 220 if (!file.IsValid()) 221 return false; 222 223 // Allocate a resizable buffer for the headers. We initially reserve as much 224 // space as we typically see as the header size for chrome.dll and other 225 // PE images. 226 std::vector<uint8> headers; 227 headers.reserve(kMinHeaderBufferSize); 228 229 // Read, hopefully, all of the headers. 230 if (!ReadMissingBytes(file.Get(), &headers, kMinHeaderBufferSize)) 231 return false; 232 233 // The DOS header starts at offset 0 and allows us to get the offset of the 234 // NT headers. Let's ensure we've read enough to capture the NT headers. 235 size_t nt_headers_start = 236 reinterpret_cast<IMAGE_DOS_HEADER*>(&headers[0])->e_lfanew; 237 size_t nt_headers_end = nt_headers_start + sizeof(IMAGE_NT_HEADERS); 238 if (!ReadMissingBytes(file.Get(), &headers, nt_headers_end)) 239 return false; 240 241 // Now that we've got the NT headers we can get the total header size, 242 // including all of the section headers. Let's ensure we've read enough 243 // to capture all of the header data. 244 size_t size_of_headers = reinterpret_cast<IMAGE_NT_HEADERS*>( 245 &headers[nt_headers_start])->OptionalHeader.SizeOfHeaders; 246 if (!ReadMissingBytes(file.Get(), &headers, size_of_headers)) 247 return false; 248 249 // Now we have all of the headers. This is enough to let us use the PEImage 250 // wrapper to query the structure of the image. 251 base::win::PEImage pe_image(reinterpret_cast<HMODULE>(&headers[0])); 252 CHECK(pe_image.VerifyMagic()); 253 254 // Allocate a buffer to hold the pre-read bytes. 255 scoped_ptr<uint8, VirtualFreeDeleter> buffer( 256 static_cast<uint8*>( 257 ::VirtualAlloc(NULL, max_chunk_size, MEM_COMMIT, PAGE_READWRITE))); 258 if (buffer.get() == NULL) 259 return false; 260 261 // Iterate over each section, reading in a percentage of each. 262 const IMAGE_SECTION_HEADER* section = NULL; 263 for (UINT i = 0; (section = pe_image.GetSectionHeader(i)) != NULL; ++i) { 264 CHECK_LE(reinterpret_cast<const uint8*>(section + 1), 265 &headers[0] + headers.size()); 266 if (!ReadThroughSection(file.Get(), section, percentage, buffer.get(), 267 max_chunk_size)) { 268 return false; 269 } 270 } 271 272 // We're done. 273 return true; 274 } 275 276 bool ImagePreReader::PartialPreReadImageInMemory(const wchar_t* file_path, 277 size_t percentage) { 278 // TODO(rogerm): change this to have the number of bytes pre-read per 279 // section be driven by a static table within the PE file (defaulting to 280 // full read if it's not there?) that's initialized by the optimization 281 // toolchain. 282 DCHECK(file_path != NULL); 283 284 if (percentage == 0) 285 return true; 286 287 if (percentage > kOneHundredPercent) 288 percentage = kOneHundredPercent; 289 290 HMODULE dll_module = ::LoadLibraryExW( 291 file_path, 292 NULL, 293 LOAD_WITH_ALTERED_SEARCH_PATH | DONT_RESOLVE_DLL_REFERENCES); 294 295 if (!dll_module) 296 return false; 297 298 base::win::PEImage pe_image(dll_module); 299 CHECK(pe_image.VerifyMagic()); 300 301 // Iterate over each section, stepping through a percentage of each to page 302 // it in off the disk. 303 const IMAGE_SECTION_HEADER* section = NULL; 304 for (UINT i = 0; (section = pe_image.GetSectionHeader(i)) != NULL; ++i) { 305 // Get the extent we want to touch. 306 size_t length = GetPercentageOfSectionLength(section, percentage); 307 if (length == 0) 308 continue; 309 uint8* start = 310 static_cast<uint8*>(pe_image.RVAToAddr(section->VirtualAddress)); 311 312 // Verify that the extent we're going to touch falls inside the section 313 // we expect it to (and by implication, inside the pe_image). 314 CHECK_EQ(section, 315 pe_image.GetImageSectionFromAddr(start)); 316 CHECK_EQ(section, 317 pe_image.GetImageSectionFromAddr(start + length - 1)); 318 319 // Page in the section range. 320 TouchPagesInRange(start, length); 321 } 322 323 FreeLibrary(dll_module); 324 325 return true; 326 } 327 328 bool ImagePreReader::PreReadImage(const wchar_t* file_path, 329 size_t size_to_read, 330 size_t step_size) { 331 base::ThreadRestrictions::AssertIOAllowed(); 332 if (base::win::GetVersion() > base::win::VERSION_XP) { 333 // Vista+ branch. On these OSes, the forced reads through the DLL actually 334 // slows warm starts. The solution is to sequentially read file contents 335 // with an optional cap on total amount to read. 336 base::win::ScopedHandle file( 337 CreateFile(file_path, 338 GENERIC_READ, 339 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 340 NULL, 341 OPEN_EXISTING, 342 FILE_FLAG_SEQUENTIAL_SCAN, 343 NULL)); 344 345 if (!file.IsValid()) 346 return false; 347 348 // Default to 1MB sequential reads. 349 const DWORD actual_step_size = std::max(static_cast<DWORD>(step_size), 350 static_cast<DWORD>(1024*1024)); 351 LPVOID buffer = ::VirtualAlloc(NULL, 352 actual_step_size, 353 MEM_COMMIT, 354 PAGE_READWRITE); 355 356 if (buffer == NULL) 357 return false; 358 359 DWORD len; 360 size_t total_read = 0; 361 while (::ReadFile(file.Get(), buffer, actual_step_size, &len, NULL) && 362 len > 0 && 363 (size_to_read ? total_read < size_to_read : true)) { 364 total_read += static_cast<size_t>(len); 365 } 366 ::VirtualFree(buffer, 0, MEM_RELEASE); 367 } else { 368 // WinXP branch. Here, reading the DLL from disk doesn't do 369 // what we want so instead we pull the pages into memory by loading 370 // the DLL and touching pages at a stride. We use the system's page 371 // size as the stride, ignoring the passed in step_size, to make sure 372 // each page in the range is touched. 373 HMODULE dll_module = ::LoadLibraryExW( 374 file_path, 375 NULL, 376 LOAD_WITH_ALTERED_SEARCH_PATH | DONT_RESOLVE_DLL_REFERENCES); 377 378 if (!dll_module) 379 return false; 380 381 base::win::PEImage pe_image(dll_module); 382 CHECK(pe_image.VerifyMagic()); 383 384 // We don't want to read past the end of the module (which could trigger 385 // an access violation), so make sure to check the image size. 386 PIMAGE_NT_HEADERS nt_headers = pe_image.GetNTHeaders(); 387 size_t dll_module_length = std::min( 388 size_to_read ? size_to_read : ~0, 389 static_cast<size_t>(nt_headers->OptionalHeader.SizeOfImage)); 390 391 // Page in then release the module. 392 TouchPagesInRange(dll_module, dll_module_length); 393 FreeLibrary(dll_module); 394 } 395 396 return true; 397 } 398 399 bool ImagePreReader::PartialPreReadImage(const wchar_t* file_path, 400 size_t percentage, 401 size_t max_chunk_size) { 402 base::ThreadRestrictions::AssertIOAllowed(); 403 404 if (percentage >= kOneHundredPercent) { 405 // If we're reading the whole image, we don't need to parse headers and 406 // navigate sections, the basic PreReadImage() can be used to just step 407 // blindly through the entire file / address-space. 408 return PreReadImage(file_path, 0, max_chunk_size); 409 } 410 411 if (base::win::GetVersion() > base::win::VERSION_XP) { 412 // Vista+ branch. On these OSes, we warm up the Image by reading its 413 // file off the disk. 414 return PartialPreReadImageOnDisk(file_path, percentage, max_chunk_size); 415 } 416 417 // WinXP branch. For XP, reading the image from disk doesn't do what we want 418 // so instead we pull the pages into memory by loading the DLL and touching 419 // initialized pages at a stride. 420 return PartialPreReadImageInMemory(file_path, percentage); 421 } 422
