/*
 * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2024, Red Hat, Inc. and/or its affiliates.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#include "nmt/memMapPrinter.hpp"
#include "os_windows.hpp"
#include "runtime/vm_version.hpp"
#include "utilities/ostream.hpp"

#include <limits.h>
#include <winnt.h>
#include <memoryapi.h>
#include <psapi.h>

/* maximum number of mapping records returned */
static const int MAX_REGIONS_RETURNED = 1000000;

class MappingInfo {
public:
  stringStream _ap_buffer;
  stringStream _state_buffer;
  stringStream _protect_buffer;
  stringStream _type_buffer;
  char _file_name[MAX_PATH];

  MappingInfo() {}

  void process(MEMORY_BASIC_INFORMATION& mem_info) {
    _ap_buffer.reset();
    _state_buffer.reset();
    _protect_buffer.reset();
    _type_buffer.reset();
    get_protect_string(_ap_buffer, mem_info.AllocationProtect);
    get_state_string(_state_buffer, mem_info);
    get_protect_string(_protect_buffer,  mem_info.Protect);
    get_type_string(_type_buffer, mem_info);
    _file_name[0] = 0;
    if (mem_info.Type == MEM_IMAGE) {
      HMODULE hModule = 0;
      if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, static_cast<LPCSTR>(mem_info.AllocationBase), &hModule)) {
        GetModuleFileName(hModule, _file_name, sizeof(_file_name));
      }
    }
  }

  void get_protect_string(outputStream& out, DWORD prot) {
    const char read_c = prot & (PAGE_READONLY | PAGE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY) ? 'r' : '-';
    const char write_c = prot & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY) ? 'w' : '-';
    const char execute_c = prot & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY) ? 'x' : '-';
    out.print("%c%c%c", read_c, write_c, execute_c);
    if (prot & (PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY)) {
      out.put('c');
    }
    if (prot & PAGE_GUARD) {
      out.put('g');
    }
    if (prot & PAGE_NOCACHE) {
      out.put('n');
    }
    if (prot & PAGE_WRITECOMBINE) {
      out.put('W');
    }
    const DWORD bits = PAGE_NOACCESS | PAGE_READONLY | PAGE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE
                        | PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE
                        | PAGE_GUARD | PAGE_NOCACHE | PAGE_WRITECOMBINE;
    if ((prot & bits) != prot) {
      out.print_cr("Unknown Windows memory protection value: 0x%x unknown bits: 0x%x", prot, prot & ~bits);
      assert(false, "Unknown Windows memory protection value: 0x%x unknown bits: 0x%x", prot, prot & ~bits);
    }
  }

  void get_state_string(outputStream& out, MEMORY_BASIC_INFORMATION& mem_info) {
    if (mem_info.State == MEM_COMMIT) {
      out.put('c');
    } else if (mem_info.State == MEM_FREE) {
      out.put('f');
    } else if (mem_info.State == MEM_RESERVE) {
      out.put('r');
    } else {
      out.print_cr("Unknown Windows memory state value: 0x%x", mem_info.State);
      assert(false, "Unknown Windows memory state value: 0x%x", mem_info.State);
    }
  }

  void get_type_string(outputStream& out, MEMORY_BASIC_INFORMATION& mem_info) {
    if (mem_info.Type == MEM_IMAGE) {
      out.print("img");
    } else if (mem_info.Type == MEM_MAPPED) {
      out.print("map");
    } else if (mem_info.Type == MEM_PRIVATE) {
      out.print("pvt");
    } else if (mem_info.Type == 0 && mem_info.State == MEM_FREE) {
      out.print("---");
    } else {
      out.print_cr("Unknown Windows memory type 0x%x", mem_info.Type);
      assert(false, "Unknown Windows memory type 0x%x", mem_info.Type);
    }
  }
};

class MappingInfoSummary {
  unsigned _num_mappings;
  size_t _total_region_size;  // combined resident set size
  size_t _total_committed;    // combined committed size
  class WinOsInfo : public os::win32 {
    public:
      static void printOsInfo(outputStream* st) {
        st->print("OS:");
        os::win32::print_windows_version(st);
        os::win32::print_uptime_info(st);
        VM_Version::print_platform_virtualization_info(st);
        os::print_memory_info(st);
      }
  };
public:
  MappingInfoSummary() : _num_mappings(0),  _total_region_size(0),
                      _total_committed(0) {}

  void add_mapping(const MEMORY_BASIC_INFORMATION& mem_info, const MappingInfo& mapping_info) {
    if (mem_info.State != MEM_FREE) {
      _num_mappings++;
      _total_region_size += mem_info.RegionSize;
      _total_committed += mem_info.State == MEM_COMMIT ? mem_info.RegionSize : 0;
    }
  }

  void print_on(const MappingPrintSession& session) const {
    outputStream* st = session.out();
    WinOsInfo::printOsInfo(st);
    st->print_cr("current process reserved memory: " PROPERFMT, PROPERFMTARGS(_total_region_size));
    st->print_cr("current process committed memory: " PROPERFMT, PROPERFMTARGS(_total_committed));
    st->print_cr("current process region count: " PROPERFMT, PROPERFMTARGS(_num_mappings));
  }
};

class MappingInfoPrinter {
  const MappingPrintSession& _session;
public:
  MappingInfoPrinter(const MappingPrintSession& session) :
    _session(session)
  {}

  void print_single_mapping(const MEMORY_BASIC_INFORMATION& mem_info, const MappingInfo& mapping_info) const {
    outputStream* st = _session.out();
#define INDENT_BY(n)          \
  if (st->fill_to(n) == 0) {  \
    st->print(" ");           \
  }
    st->print(PTR_FORMAT "-" PTR_FORMAT, mem_info.BaseAddress, static_cast<const char*>(mem_info.BaseAddress) + mem_info.RegionSize);
    INDENT_BY(38);
    st->print("%12zu", mem_info.RegionSize);
    INDENT_BY(51);
    st->print("%s", mapping_info._protect_buffer.base());
    INDENT_BY(57);
    st->print("%s-%s", mapping_info._state_buffer.base(), mapping_info._type_buffer.base());
    INDENT_BY(63);
    st->print("%#11llx", reinterpret_cast<const unsigned long long>(mem_info.BaseAddress) - reinterpret_cast<const unsigned long long>(mem_info.AllocationBase));
    INDENT_BY(72);
    if (_session.print_nmt_info_for_region(mem_info.BaseAddress, static_cast<const char*>(mem_info.BaseAddress) + mem_info.RegionSize)) {
      st->print(" ");
    }
    st->print_raw(mapping_info._file_name);
  #undef INDENT_BY
    st->cr();
  }

  void print_legend() const {
    outputStream* st = _session.out();
    st->print_cr("from, to, vsize: address range and size");
    st->print_cr("prot:    protection:");
    st->print_cr("             rwx: read / write / execute");
    st->print_cr("             c: copy on write");
    st->print_cr("             g: guard");
    st->print_cr("             n: no cache");
    st->print_cr("             W: write combine");
    st->print_cr("state:   region state and type:");
    st->print_cr("             state: committed / reserved");
    st->print_cr("             type: image / mapped / private");
    st->print_cr("offset:  offset from start of allocation block");
    st->print_cr("vminfo:  VM information (requires NMT)");
    st->print_cr("file:    file mapped, if mapping is not anonymous");
    {
      StreamIndentor si(st, 16);
      _session.print_nmt_flag_legend();
    }
  }

  void print_header() const {
    outputStream* st = _session.out();
    //            0         1         2         3         4         5         6         7         8         9         0         1         2         3
    //            01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
    //            0x00007ffb24565000-0x00007ffb24a7e000      5345280 r--   c-img   0x1155000 C:\work\jdk\build\fastdebug\jdk\bin\server\jvm.dll
    st->print_cr("from               to                        vsize prot  state      offset vminfo/file");
    st->print_cr("===========================================================================================");
  }
};

void MemMapPrinter::pd_print_all_mappings(const MappingPrintSession& session) {

  HANDLE hProcess = GetCurrentProcess();

  MappingInfoPrinter printer(session);
  MappingInfoSummary summary;

  outputStream* const st = session.out();

  printer.print_legend();
  st->cr();
  printer.print_header();

  MEMORY_BASIC_INFORMATION mem_info;
  MappingInfo mapping_info;

  int region_count = 0;
  ::memset(&mem_info, 0, sizeof(mem_info));
  for (char* ptr = 0; VirtualQueryEx(hProcess, ptr, &mem_info, sizeof(mem_info)) == sizeof(mem_info); ) {
    assert(mem_info.RegionSize > 0, "RegionSize is not greater than zero");
    if (++region_count > MAX_REGIONS_RETURNED) {
      st->print_cr("limit of %d regions reached (results inaccurate)", region_count);
      break;
    }
    mapping_info.process(mem_info);
    if (mem_info.State != MEM_FREE) {
      printer.print_single_mapping(mem_info, mapping_info);
      summary.add_mapping(mem_info, mapping_info);
    }
    ptr += mem_info.RegionSize;
    ::memset(&mem_info, 0, sizeof(mem_info));
  }
  st->cr();
  summary.print_on(session);
  st->cr();
}