Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 786dac3d authored by Kelvin Zhang's avatar Kelvin Zhang
Browse files

Update some fs_mgr/debuggerd to use getpagesize() instead of PAGE_SIZE 

Test: th
Bug: 279808236
Change-Id: I9d30cfe19d2b1a7d624cc5425e4315dc6e3b2ad2
parent 8ec7d3da

debuggerd/crasher/crasher.cpp

+1 −1
Original line number Diff line number Diff line
@@ -148,7 +148,7 @@ noinline void abuse_heap() { 
noinline void leak() {

    while (true) {

        void* mapping =

            mmap(nullptr, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

            mmap(nullptr, getpagesize(), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

        static_cast<volatile char*>(mapping)[0] = 'a';

    }

}

debuggerd/debuggerd_test.cpp

+1 −18
Original line number Diff line number Diff line
@@ -300,24 +300,7 @@ void CrasherTest::AssertDeath(int signo) { 
}



static void ConsumeFd(unique_fd fd, std::string* output) {

  constexpr size_t read_length = PAGE_SIZE;

  std::string result;



  while (true) {

    size_t offset = result.size();

    result.resize(result.size() + PAGE_SIZE);

    ssize_t rc = TEMP_FAILURE_RETRY(read(fd.get(), &result[offset], read_length));

    if (rc == -1) {

      FAIL() << "read failed: " << strerror(errno);

    } else if (rc == 0) {

      result.resize(result.size() - PAGE_SIZE);

      break;

    }



    result.resize(result.size() - PAGE_SIZE + rc);

  }



  *output = std::move(result);

  ASSERT_TRUE(android::base::ReadFdToString(fd, output));

}



class LogcatCollector {

debuggerd/handler/debuggerd_handler.cpp

+4 −4
Original line number Diff line number Diff line
@@ -721,19 +721,19 @@ void debuggerd_init(debuggerd_callbacks_t* callbacks) { 
  }



  size_t thread_stack_pages = 8;

  void* thread_stack_allocation = mmap(nullptr, PAGE_SIZE * (thread_stack_pages + 2), PROT_NONE,

  void* thread_stack_allocation = mmap(nullptr, getpagesize() * (thread_stack_pages + 2), PROT_NONE,

                                       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);

  if (thread_stack_allocation == MAP_FAILED) {

    fatal_errno("failed to allocate debuggerd thread stack");

  }



  char* stack = static_cast<char*>(thread_stack_allocation) + PAGE_SIZE;

  if (mprotect(stack, PAGE_SIZE * thread_stack_pages, PROT_READ | PROT_WRITE) != 0) {

  char* stack = static_cast<char*>(thread_stack_allocation) + getpagesize();

  if (mprotect(stack, getpagesize() * thread_stack_pages, PROT_READ | PROT_WRITE) != 0) {

    fatal_errno("failed to mprotect debuggerd thread stack");

  }



  // Stack grows negatively, set it to the last byte in the page...

  stack = (stack + thread_stack_pages * PAGE_SIZE - 1);

  stack = (stack + thread_stack_pages * getpagesize() - 1);

  // and align it.

  stack -= 15;

  pseudothread_stack = stack;

debuggerd/libdebuggerd/scudo.cpp

+6 −5
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 


#include <android-base/macros.h>

#include <bionic/macros.h>

#include <unistd.h>



#include "tombstone.pb.h"
@@ -54,21 +55,21 @@ ScudoCrashData::ScudoCrashData(unwindstack::Memory* process_memory, 
  }



  untagged_fault_addr_ = process_info.untagged_fault_address;

  uintptr_t fault_page = untagged_fault_addr_ & ~(PAGE_SIZE - 1);

  uintptr_t fault_page = untagged_fault_addr_ & ~(getpagesize() - 1);



  uintptr_t memory_begin = fault_page - PAGE_SIZE * 16;

  uintptr_t memory_begin = fault_page - getpagesize() * 16;

  if (memory_begin > fault_page) {

    return;

  }



  uintptr_t memory_end = fault_page + PAGE_SIZE * 16;

  uintptr_t memory_end = fault_page + getpagesize() * 16;

  if (memory_end < fault_page) {

    return;

  }



  auto memory = std::make_unique<char[]>(memory_end - memory_begin);

  for (auto i = memory_begin; i != memory_end; i += PAGE_SIZE) {

    process_memory->ReadFully(i, memory.get() + i - memory_begin, PAGE_SIZE);

  for (auto i = memory_begin; i != memory_end; i += getpagesize()) {

    process_memory->ReadFully(i, memory.get() + i - memory_begin, getpagesize());

  }



  auto memory_tags = std::make_unique<char[]>((memory_end - memory_begin) / kTagGranuleSize);

fs_mgr/fs_mgr.cpp

+4 −3
Original line number Diff line number Diff line
@@ -613,7 +613,6 @@ static void tune_metadata_csum(const std::string& blk_device, const FstabEntry& 


// Read the primary superblock from an f2fs filesystem.  On failure return

// false.  If it's not an f2fs filesystem, also set FS_STAT_INVALID_MAGIC.

#define F2FS_BLKSIZE 4096

#define F2FS_SUPER_OFFSET 1024

static bool read_f2fs_superblock(const std::string& blk_device, int* fs_stat) {

    android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device.c_str(), O_RDONLY | O_CLOEXEC)));
@@ -628,7 +627,9 @@ static bool read_f2fs_superblock(const std::string& blk_device, int* fs_stat) { 
        PERROR << "Can't read '" << blk_device << "' superblock1";

        return false;

    }

    if (TEMP_FAILURE_RETRY(pread(fd, &sb2, sizeof(sb2), F2FS_BLKSIZE + F2FS_SUPER_OFFSET)) !=

    // F2FS only supports block_size=page_size case. So, it is safe to call

    // `getpagesize()` and use that as size of super block.

    if (TEMP_FAILURE_RETRY(pread(fd, &sb2, sizeof(sb2), getpagesize() + F2FS_SUPER_OFFSET)) !=

        sizeof(sb2)) {

        PERROR << "Can't read '" << blk_device << "' superblock2";

        return false;
@@ -652,7 +653,7 @@ bool fs_mgr_is_f2fs(const std::string& blk_device) { 
        return false;

    }

    if (sb == cpu_to_le32(F2FS_SUPER_MAGIC)) return true;

    if (TEMP_FAILURE_RETRY(pread(fd, &sb, sizeof(sb), F2FS_BLKSIZE + F2FS_SUPER_OFFSET)) !=

    if (TEMP_FAILURE_RETRY(pread(fd, &sb, sizeof(sb), getpagesize() + F2FS_SUPER_OFFSET)) !=

        sizeof(sb)) {

        return false;

    }