blob: f98b734fb7fe471e6fb15265b052437ddc756a79 [file] [log] [blame]
// 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