| // Copyright 2016 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/memory/shared_memory_helper.h" | |
| #if defined(OS_CHROMEOS) | |
| #include <sys/resource.h> | |
| #include <sys/time.h> | |
| #include "base/debug/alias.h" | |
| #endif // defined(OS_CHROMEOS) | |
| #include "base/threading/thread_restrictions.h" | |
| namespace base { | |
| struct ScopedPathUnlinkerTraits { | |
| static const FilePath* InvalidValue() { return nullptr; } | |
| static void Free(const FilePath* path) { | |
| if (unlink(path->value().c_str())) | |
| PLOG(WARNING) << "unlink"; | |
| } | |
| }; | |
| // Unlinks the FilePath when the object is destroyed. | |
| using ScopedPathUnlinker = | |
| ScopedGeneric<const FilePath*, ScopedPathUnlinkerTraits>; | |
| #if !defined(OS_ANDROID) | |
| bool CreateAnonymousSharedMemory(const SharedMemoryCreateOptions& options, | |
| ScopedFD* fd, | |
| ScopedFD* readonly_fd, | |
| FilePath* path) { | |
| #if defined(OS_LINUX) | |
| // It doesn't make sense to have a open-existing private piece of shmem | |
| DCHECK(!options.open_existing_deprecated); | |
| #endif // defined(OS_LINUX) | |
| // Q: Why not use the shm_open() etc. APIs? | |
| // A: Because they're limited to 4mb on OS X. FFFFFFFUUUUUUUUUUU | |
| FilePath directory; | |
| ScopedPathUnlinker path_unlinker; | |
| if (!GetShmemTempDir(options.executable, &directory)) | |
| return false; | |
| fd->reset(base::CreateAndOpenFdForTemporaryFileInDir(directory, path)); | |
| if (!fd->is_valid()) | |
| return false; | |
| // Deleting the file prevents anyone else from mapping it in (making it | |
| // private), and prevents the need for cleanup (once the last fd is | |
| // closed, it is truly freed). | |
| path_unlinker.reset(path); | |
| if (options.share_read_only) { | |
| // Also open as readonly so that we can GetReadOnlyHandle. | |
| readonly_fd->reset(HANDLE_EINTR(open(path->value().c_str(), O_RDONLY))); | |
| if (!readonly_fd->is_valid()) { | |
| DPLOG(ERROR) << "open(\"" << path->value() << "\", O_RDONLY) failed"; | |
| fd->reset(); | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| bool PrepareMapFile(ScopedFD fd, | |
| ScopedFD readonly_fd, | |
| int* mapped_file, | |
| int* readonly_mapped_file) { | |
| DCHECK_EQ(-1, *mapped_file); | |
| DCHECK_EQ(-1, *readonly_mapped_file); | |
| if (!fd.is_valid()) | |
| return false; | |
| // This function theoretically can block on the disk, but realistically | |
| // the temporary files we create will just go into the buffer cache | |
| // and be deleted before they ever make it out to disk. | |
| base::ThreadRestrictions::ScopedAllowIO allow_io; | |
| if (readonly_fd.is_valid()) { | |
| struct stat st = {}; | |
| if (fstat(fd.get(), &st)) | |
| NOTREACHED(); | |
| struct stat readonly_st = {}; | |
| if (fstat(readonly_fd.get(), &readonly_st)) | |
| NOTREACHED(); | |
| if (st.st_dev != readonly_st.st_dev || st.st_ino != readonly_st.st_ino) { | |
| LOG(ERROR) << "writable and read-only inodes don't match; bailing"; | |
| return false; | |
| } | |
| } | |
| *mapped_file = HANDLE_EINTR(dup(fd.get())); | |
| if (*mapped_file == -1) { | |
| NOTREACHED() << "Call to dup failed, errno=" << errno; | |
| #if defined(OS_CHROMEOS) | |
| if (errno == EMFILE) { | |
| // We're out of file descriptors and are probably about to crash somewhere | |
| // else in Chrome anyway. Let's collect what FD information we can and | |
| // crash. | |
| // Added for debugging crbug.com/733718 | |
| int original_fd_limit = 16384; | |
| struct rlimit rlim; | |
| if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) { | |
| original_fd_limit = rlim.rlim_cur; | |
| if (rlim.rlim_max > rlim.rlim_cur) { | |
| // Increase fd limit so breakpad has a chance to write a minidump. | |
| rlim.rlim_cur = rlim.rlim_max; | |
| if (setrlimit(RLIMIT_NOFILE, &rlim) != 0) { | |
| PLOG(ERROR) << "setrlimit() failed"; | |
| } | |
| } | |
| } else { | |
| PLOG(ERROR) << "getrlimit() failed"; | |
| } | |
| const char kFileDataMarker[] = "FDATA"; | |
| char buf[PATH_MAX]; | |
| char fd_path[PATH_MAX]; | |
| char crash_buffer[32 * 1024] = {0}; | |
| char* crash_ptr = crash_buffer; | |
| base::debug::Alias(crash_buffer); | |
| // Put a marker at the start of our data so we can confirm where it | |
| // begins. | |
| crash_ptr = strncpy(crash_ptr, kFileDataMarker, strlen(kFileDataMarker)); | |
| for (int i = original_fd_limit; i >= 0; --i) { | |
| memset(buf, 0, arraysize(buf)); | |
| memset(fd_path, 0, arraysize(fd_path)); | |
| snprintf(fd_path, arraysize(fd_path) - 1, "/proc/self/fd/%d", i); | |
| ssize_t count = readlink(fd_path, buf, arraysize(buf) - 1); | |
| if (count < 0) { | |
| PLOG(ERROR) << "readlink failed for: " << fd_path; | |
| continue; | |
| } | |
| if (crash_ptr + count + 1 < crash_buffer + arraysize(crash_buffer)) { | |
| crash_ptr = strncpy(crash_ptr, buf, count + 1); | |
| } | |
| LOG(ERROR) << i << ": " << buf; | |
| } | |
| LOG(FATAL) << "Logged for file descriptor exhaustion, crashing now"; | |
| } | |
| #endif // defined(OS_CHROMEOS) | |
| } | |
| *readonly_mapped_file = readonly_fd.release(); | |
| return true; | |
| } | |
| #endif // !defined(OS_ANDROID) | |
| } // namespace base |