0

Move base::IsPageAligned() out to chromeos/memory/.

This function only has callers in chromeos/memory/, so move it there.
It was added in https://crrev.com/756778 just over a year ago for use
with chromeos/memory/, but has not picked up any new callers.

Change-Id: I625fc6d66715088e70875596f1675bcc787cb1fe
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2976751
Reviewed-by: Brian Geffon <bgeffon@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
Cr-Commit-Position: refs/heads/master@{#894394}
This commit is contained in:
Lei Zhang
2021-06-21 20:49:20 +00:00
committed by Chromium LUCI CQ
parent 823e76acee
commit bb89dc3106
5 changed files with 41 additions and 23 deletions

@ -9,12 +9,10 @@
#include <stdint.h> #include <stdint.h>
#include <ostream> #include <ostream>
#include <type_traits>
#include "base/base_export.h" #include "base/base_export.h"
#include "base/bits.h" #include "base/bits.h"
#include "base/check.h" #include "base/check.h"
#include "base/memory/page_size.h"
#include "build/build_config.h" #include "build/build_config.h"
#if defined(COMPILER_MSVC) #if defined(COMPILER_MSVC)
@ -80,13 +78,6 @@ inline bool IsAligned(const void* val, size_t alignment) {
return IsAligned(reinterpret_cast<uintptr_t>(val), alignment); return IsAligned(reinterpret_cast<uintptr_t>(val), alignment);
} }
template <typename Type>
inline bool IsPageAligned(Type val) {
static_assert(std::is_integral<Type>::value || std::is_pointer<Type>::value,
"Integral or pointer type required");
return IsAligned(val, GetPageSize());
}
} // namespace base } // namespace base
#endif // BASE_MEMORY_ALIGNED_MEMORY_H_ #endif // BASE_MEMORY_ALIGNED_MEMORY_H_

@ -29,6 +29,7 @@ component("memory") {
"//services/resource_coordinator/public/cpp/memory_instrumentation", "//services/resource_coordinator/public/cpp/memory_instrumentation",
] ]
sources = [ sources = [
"aligned_memory.h",
"kstaled.cc", "kstaled.cc",
"kstaled.h", "kstaled.h",
"memory.cc", "memory.cc",

@ -0,0 +1,26 @@
// Copyright 2021 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.
#ifndef CHROMEOS_MEMORY_ALIGNED_MEMORY_H_
#define CHROMEOS_MEMORY_ALIGNED_MEMORY_H_
#include <type_traits>
#include "base/memory/aligned_memory.h"
#include "base/memory/page_size.h"
namespace chromeos {
namespace memory {
template <typename Type>
inline bool IsPageAligned(Type val) {
static_assert(std::is_integral<Type>::value || std::is_pointer<Type>::value,
"Integral or pointer type required");
return base::IsAligned(val, base::GetPageSize());
}
} // namespace memory
} // namespace chromeos
#endif // CHROMEOS_MEMORY_ALIGNED_MEMORY_H_

@ -10,11 +10,11 @@
#include <string> #include <string>
#include "base/logging.h" #include "base/logging.h"
#include "base/memory/aligned_memory.h"
#include "base/memory/page_size.h" #include "base/memory/page_size.h"
#include "base/posix/eintr_wrapper.h" #include "base/posix/eintr_wrapper.h"
#include "base/strings/stringprintf.h" #include "base/strings/stringprintf.h"
#include "base/threading/scoped_blocking_call.h" #include "base/threading/scoped_blocking_call.h"
#include "chromeos/memory/aligned_memory.h"
namespace chromeos { namespace chromeos {
namespace memory { namespace memory {
@ -45,8 +45,8 @@ bool Pagemap::GetEntries(uint64_t address,
DCHECK(entries); DCHECK(entries);
const size_t kPageSize = base::GetPageSize(); const size_t kPageSize = base::GetPageSize();
DCHECK(base::IsPageAligned(address)); DCHECK(IsPageAligned(address));
DCHECK(base::IsPageAligned(length)); DCHECK(IsPageAligned(length));
// The size of each pagemap entry to calculate our offset in the file. // The size of each pagemap entry to calculate our offset in the file.
uint64_t num_pages = length / kPageSize; uint64_t num_pages = length / kPageSize;

@ -19,7 +19,6 @@
#include "base/files/file_descriptor_watcher_posix.h" #include "base/files/file_descriptor_watcher_posix.h"
#include "base/files/scoped_file.h" #include "base/files/scoped_file.h"
#include "base/logging.h" #include "base/logging.h"
#include "base/memory/aligned_memory.h"
#include "base/memory/ptr_util.h" #include "base/memory/ptr_util.h"
#include "base/posix/eintr_wrapper.h" #include "base/posix/eintr_wrapper.h"
#include "base/sequenced_task_runner.h" #include "base/sequenced_task_runner.h"
@ -28,6 +27,7 @@
#include "base/threading/platform_thread.h" #include "base/threading/platform_thread.h"
#include "base/threading/scoped_blocking_call.h" #include "base/threading/scoped_blocking_call.h"
#include "base/threading/sequenced_task_runner_handle.h" #include "base/threading/sequenced_task_runner_handle.h"
#include "chromeos/memory/aligned_memory.h"
namespace chromeos { namespace chromeos {
namespace memory { namespace memory {
@ -66,8 +66,8 @@ bool UserfaultFD::RegisterRange(RegisterMode mode,
uintptr_t range_start, uintptr_t range_start,
uint64_t len) { uint64_t len) {
#if defined(HAS_USERFAULTFD) #if defined(HAS_USERFAULTFD)
CHECK(base::IsPageAligned(range_start)); CHECK(IsPageAligned(range_start));
CHECK(base::IsPageAligned(len)); CHECK(IsPageAligned(len));
uffdio_register reg = {}; uffdio_register reg = {};
reg.range.start = range_start; reg.range.start = range_start;
@ -99,8 +99,8 @@ bool UserfaultFD::RegisterRange(RegisterMode mode,
bool UserfaultFD::UnregisterRange(uintptr_t range_start, uint64_t len) { bool UserfaultFD::UnregisterRange(uintptr_t range_start, uint64_t len) {
#if defined(HAS_USERFAULTFD) #if defined(HAS_USERFAULTFD)
CHECK(base::IsPageAligned(range_start)); CHECK(IsPageAligned(range_start));
CHECK(base::IsPageAligned(len)); CHECK(IsPageAligned(len));
uffdio_range range = {}; uffdio_range range = {};
range.start = range_start; range.start = range_start;
@ -123,8 +123,8 @@ bool UserfaultFD::CopyToRange(uintptr_t dest_range_start,
int64_t* copied) { int64_t* copied) {
#if defined(HAS_USERFAULTFD) #if defined(HAS_USERFAULTFD)
// NOTE: The source doesn't need to be page aligned. // NOTE: The source doesn't need to be page aligned.
CHECK(base::IsPageAligned(dest_range_start)); CHECK(IsPageAligned(dest_range_start));
CHECK(base::IsPageAligned(len)); CHECK(IsPageAligned(len));
CHECK(copied); CHECK(copied);
uffdio_copy fault_copy = {}; uffdio_copy fault_copy = {};
@ -149,8 +149,8 @@ bool UserfaultFD::ZeroRange(uintptr_t range_start,
uint64_t len, uint64_t len,
int64_t* zeroed) { int64_t* zeroed) {
#if defined(HAS_USERFAULTFD) #if defined(HAS_USERFAULTFD)
CHECK(base::IsPageAligned(range_start)); CHECK(IsPageAligned(range_start));
CHECK(base::IsPageAligned(len)); CHECK(IsPageAligned(len));
CHECK(zeroed); CHECK(zeroed);
uffdio_zeropage zp = {}; uffdio_zeropage zp = {};
@ -172,8 +172,8 @@ bool UserfaultFD::ZeroRange(uintptr_t range_start,
bool UserfaultFD::WakeRange(uintptr_t range_start, uint64_t len) { bool UserfaultFD::WakeRange(uintptr_t range_start, uint64_t len) {
#if defined(HAS_USERFAULTFD) #if defined(HAS_USERFAULTFD)
CHECK(base::IsPageAligned(range_start)); CHECK(IsPageAligned(range_start));
CHECK(base::IsPageAligned(len)); CHECK(IsPageAligned(len));
uffdio_range range = {}; uffdio_range range = {};
range.start = range_start; range.start = range_start;