crashpad/util/posix/scoped_mmap.h
Mark Mentovai 96dc950eaf posix: Add ScopedMmap for managing memory-mapped regions
This wraps mmap(), munmap(), and mprotect().

Bug: crashpad:30
Test: crashpad_util_test ScopedMmap.*
Change-Id: If14363dfd00e314482cc91e53c7f4e3df737b0d3
Reviewed-on: https://chromium-review.googlesource.com/461361
Reviewed-by: Joshua Peraza <jperaza@chromium.org>
2017-03-28 18:30:14 +00:00

101 lines
3.3 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// Copyright 2017 The Crashpad Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef CRASHPAD_UTIL_POSIX_SCOPED_MMAP_H_
#define CRASHPAD_UTIL_POSIX_SCOPED_MMAP_H_
#include "base/macros.h"
#include <sys/mman.h>
#include <sys/types.h>
namespace crashpad {
//! \brief Maintains a memory-mapped region created by `mmap()`.
//!
//! On destruction, any memory-mapped region managed by an object of this class
//! will be released by calling `munmap()`.
class ScopedMmap {
public:
ScopedMmap();
~ScopedMmap();
//! \brief Releases the memory-mapped region by calling `munmap()`.
//!
//! A message will be logged on failure.
void Reset();
//! \brief Releases any existing memory-mapped region and sets the object to
//! maintain an already-established mapping.
//!
//! \param[in] addr The base address of the existing memory-mapped region to
//! maintain.
//! \param[in] len The size of the existing memory-mapped region to maintain.
//!
//! A message will be logged on failure to release any existing memory-mapped
//! region, but the new mapping will be set regardless.
void ResetAddrLen(void* addr, size_t len);
//! \brief Releases any existing memory-mapped region and establishes a new
//! one by calling `mmap()`.
//!
//! The parameters to this method are passed directly to `mmap()`.
//!
//! \return `true` on success. `false` on failure, with a message logged. A
//! message will also be logged on failure to release any existing
//! memory-mapped region, but this will not preclude `mmap()` from being
//! called or a new mapping from being established, and if such a call to
//! `mmap()` is successful, this method will return `true`.
bool ResetMmap(void* addr,
size_t len,
int prot,
int flags,
int fd,
off_t offset);
//! \brief Sets the protection of the memory-mapped region by calling
//! `mprotect()`.
//!
//! \a prot is passed directly to `mprotect()`.
//!
//! \return `true` on success. `false` on failure, with a message logged.
bool Mprotect(int prot);
//! \return Whether this object is managing a valid memory-mapped region.
bool is_valid() const { return addr_ != MAP_FAILED; }
//! \brief Returns the base address of the memory-mapped region.
void* addr() const { return addr_; }
//! \brief Returns the base address of the memory-mapped region, casted to
//! a type of the callers choosing.
template <typename T>
T addr_as() const {
return reinterpret_cast<T>(addr_);
}
//! \brief Returns the size of the memory-mapped region.
size_t len() const { return len_; }
private:
void* addr_ = MAP_FAILED;
size_t len_ = 0;
DISALLOW_COPY_AND_ASSIGN(ScopedMmap);
};
} // namespace crashpad
#endif // CRASHPAD_UTIL_POSIX_SCOPED_MMAP_H_