/*

 * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.

 * 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 <jni.h>

#include <unistd.h>

#include <fcntl.h>

#include <string.h>

#include <stdlib.h>

#include <stddef.h>

#include <elf.h>

#include <link.h>

#include "libproc_impl.h"

#include "salibelf.h"

// This file has the libproc implementation to read core files.

// For live processes, refer to ps_proc.c. Portions of this is adapted

// /modelled after Solaris libproc.so (in particular Pcore.c)

//----------------------------------------------------------------------

// ps_prochandle cleanup helper functions

// close all file descriptors

static void close_elf_files(struct ps_prochandle* ph) {

   lib_info* lib = NULL;

   // close core file descriptor

   if (ph->core->core_fd >= 0)

     close(ph->core->core_fd);

   // close exec file descriptor

   if (ph->core->exec_fd >= 0)

     close(ph->core->exec_fd);

   // close interp file descriptor

   if (ph->core->interp_fd >= 0)

     close(ph->core->interp_fd);

   // close class share archive file

   if (ph->core->classes_jsa_fd >= 0)

     close(ph->core->classes_jsa_fd);

   // close all library file descriptors

   lib = ph->libs;

   while (lib) {

      int fd = lib->fd;

      if (fd >= 0 && fd != ph->core->exec_fd) close(fd);

      lib = lib->next;

   }

}

// clean all map_info stuff

static void destroy_map_info(struct ps_prochandle* ph) {

  map_info* map = ph->core->maps;

  while (map) {

     map_info* next = map->next;

     free(map);

     map = next;

  }

  if (ph->core->map_array) {

     free(ph->core->map_array);

  }

  // Part of the class sharing workaround

  map = ph->core->class_share_maps;

  while (map) {

     map_info* next = map->next;

     free(map);

     map = next;

  }

}

// ps_prochandle operations

static void core_release(struct ps_prochandle* ph) {

   if (ph->core) {

      close_elf_files(ph);

      destroy_map_info(ph);

      free(ph->core);

   }

}

static map_info* allocate_init_map(int fd, off_t offset, uintptr_t vaddr, size_t memsz) {

   map_info* map;

   if ( (map = (map_info*) calloc(1, sizeof(map_info))) == NULL) {

      print_debug("can't allocate memory for map_info\n");

      return NULL;

   }

   // initialize map

   map->fd     = fd;

   map->offset = offset;

   map->vaddr  = vaddr;

   map->memsz  = memsz;

   return map;

}

// add map info with given fd, offset, vaddr and memsz

static map_info* add_map_info(struct ps_prochandle* ph, int fd, off_t offset,

                             uintptr_t vaddr, size_t memsz) {

   map_info* map;

   if ((map = allocate_init_map(fd, offset, vaddr, memsz)) == NULL) {

      return NULL;

   }

   // add this to map list

   map->next  = ph->core->maps;

   ph->core->maps   = map;

   ph->core->num_maps++;

   return map;

}

// Part of the class sharing workaround

static map_info* add_class_share_map_info(struct ps_prochandle* ph, off_t offset,

                             uintptr_t vaddr, size_t memsz) {

   map_info* map;

   if ((map = allocate_init_map(ph->core->classes_jsa_fd,

                                offset, vaddr, memsz)) == NULL) {

      return NULL;

   }

   map->next = ph->core->class_share_maps;

   ph->core->class_share_maps = map;

}

// Return the map_info for the given virtual address.  We keep a sorted

// array of pointers in ph->map_array, so we can binary search.

static map_info* core_lookup(struct ps_prochandle *ph, uintptr_t addr)

{

   int mid, lo = 0, hi = ph->core->num_maps - 1;

   map_info *mp;

   while (hi - lo > 1) {

     mid = (lo + hi) / 2;

      if (addr >= ph->core->map_array[mid]->vaddr)

         lo = mid;

      else

         hi = mid;

   }

   if (addr < ph->core->map_array[hi]->vaddr)

      mp = ph->core->map_array[lo];

   else

      mp = ph->core->map_array[hi];

   if (addr >= mp->vaddr && addr < mp->vaddr + mp->memsz)

      return (mp);

   // Part of the class sharing workaround

   // Unfortunately, we have no way of detecting -Xshare state.

   // Check out the share maps atlast, if we don't find anywhere.

   // This is done this way so to avoid reading share pages

   // ahead of other normal maps. For eg. with -Xshare:off we don't

   // want to prefer class sharing data to data from core.

   mp = ph->core->class_share_maps;

   if (mp) {

      print_debug("can't locate map_info at 0x%lx, trying class share maps\n",

             addr);

   }

   while (mp) {

      if (addr >= mp->vaddr && addr < mp->vaddr + mp->memsz) {

         print_debug("located map_info at 0x%lx from class share maps\n",

                  addr);

         return (mp);

      }

      mp = mp->next;

   }

   print_debug("can't locate map_info at 0x%lx\n", addr);

   return (NULL);

}

//---------------------------------------------------------------

// Part of the class sharing workaround:

//

// With class sharing, pages are mapped from classes[_g].jsa file.

// The read-only class sharing pages are mapped as MAP_SHARED,

// PROT_READ pages. These pages are not dumped into core dump.

// With this workaround, these pages are read from classes[_g].jsa.

// FIXME: !HACK ALERT!

// The format of sharing achive file header is needed to read shared heap

// file mappings. For now, I am hard coding portion of FileMapHeader here.

// Refer to filemap.hpp.

// FileMapHeader describes the shared space data in the file to be

// mapped.  This structure gets written to a file.  It is not a class,

// so that the compilers don't add any compiler-private data to it.

#define NUM_SHARED_MAPS 4

// Refer to FileMapInfo::_current_version in filemap.hpp

#define CURRENT_ARCHIVE_VERSION 1

struct FileMapHeader {

  int   _magic;              // identify file type.

  int   _version;            // (from enum, above.)

  size_t _alignment;         // how shared archive should be aligned

  struct space_info {

    int    _file_offset;     // sizeof(this) rounded to vm page size

    char*  _base;            // copy-on-write base address

    size_t _capacity;        // for validity checking

    size_t _used;            // for setting space top on read

    // 4991491 NOTICE These are C++ bool's in filemap.hpp and must match up with

    // the C type matching the C++ bool type on any given platform. For

    // Hotspot on Linux we assume the corresponding C type is char but

    // licensees on Linux versions may need to adjust the type of these fields.

    char   _read_only;       // read only space?

    char   _allow_exec;      // executable code in space?

  } _space[NUM_SHARED_MAPS];

  // Ignore the rest of the FileMapHeader. We don't need those fields here.

};

static bool read_jboolean(struct ps_prochandle* ph, uintptr_t addr, jboolean* pvalue) {

   jboolean i;

   if (ps_pdread(ph, (psaddr_t) addr, &i, sizeof(i)) == PS_OK) {

      *pvalue = i;

      return true;

   } else {

      return false;

   }

}

static bool read_pointer(struct ps_prochandle* ph, uintptr_t addr, uintptr_t* pvalue) {

   uintptr_t uip;

   if (ps_pdread(ph, (psaddr_t) addr, &uip, sizeof(uip)) == PS_OK) {

      *pvalue = uip;

      return true;

   } else {

      return false;

   }

}

// used to read strings from debuggee

static bool read_string(struct ps_prochandle* ph, uintptr_t addr, char* buf, size_t size) {

   size_t i = 0;

   char  c = ' ';

   while (c != '\0') {

     if (ps_pdread(ph, (psaddr_t) addr, &c, sizeof(char)) != PS_OK)

         return false;

      if (i < size - 1)

         buf[i] = c;

      else // smaller buffer

         return false;

      i++; addr++;

   }

   buf[i] = '\0';

   return true;

}

#define USE_SHARED_SPACES_SYM "UseSharedSpaces"

// mangled name of Arguments::SharedArchivePath

#define SHARED_ARCHIVE_PATH_SYM "_ZN9Arguments17SharedArchivePathE"

static bool init_classsharing_workaround(struct ps_prochandle* ph) {

   lib_info* lib = ph->libs;

   while (lib != NULL) {

      // we are iterating over shared objects from the core dump. look for

      // libjvm[_g].so.

      const char *jvm_name = 0;

      if ((jvm_name = strstr(lib->name, "/libjvm.so")) != 0 ||

          (jvm_name = strstr(lib->name, "/libjvm_g.so")) != 0) {

         char classes_jsa[PATH_MAX];

         struct FileMapHeader header;

         size_t n = 0;

         int fd = -1, m = 0;

         uintptr_t base = 0, useSharedSpacesAddr = 0;

         uintptr_t sharedArchivePathAddrAddr = 0, sharedArchivePathAddr = 0;

         jboolean useSharedSpaces = 0;

         map_info* mi = 0;

         memset(classes_jsa, 0, sizeof(classes_jsa));

         jvm_name = lib->name;

         useSharedSpacesAddr = lookup_symbol(ph, jvm_name, USE_SHARED_SPACES_SYM);

         if (useSharedSpacesAddr == 0) {

            print_debug("can't lookup 'UseSharedSpaces' flag\n");

            return false;

         }

         // Hotspot vm types are not exported to build this library. So

         // using equivalent type jboolean to read the value of

         // UseSharedSpaces which is same as hotspot type "bool".

         if (read_jboolean(ph, useSharedSpacesAddr, &useSharedSpaces) != true) {

            print_debug("can't read the value of 'UseSharedSpaces' flag\n");

            return false;

         }

         if ((int)useSharedSpaces == 0) {

            print_debug("UseSharedSpaces is false, assuming -Xshare:off!\n");

            return true;

         }

         sharedArchivePathAddrAddr = lookup_symbol(ph, jvm_name, SHARED_ARCHIVE_PATH_SYM);

         if (sharedArchivePathAddrAddr == 0) {

            print_debug("can't lookup shared archive path symbol\n");

            return false;

         }

         if (read_pointer(ph, sharedArchivePathAddrAddr, &sharedArchivePathAddr) != true) {

            print_debug("can't read shared archive path pointer\n");

            return false;

         }

         if (read_string(ph, sharedArchivePathAddr, classes_jsa, sizeof(classes_jsa)) != true) {

            print_debug("can't read shared archive path value\n");

            return false;

         }

         print_debug("looking for %s\n", classes_jsa);

         // open the class sharing archive file

         fd = pathmap_open(classes_jsa);

         if (fd < 0) {

            print_debug("can't open %s!\n", classes_jsa);

            ph->core->classes_jsa_fd = -1;

            return false;

         } else {

            print_debug("opened %s\n", classes_jsa);

         }

         // read FileMapHeader from the file

         memset(&header, 0, sizeof(struct FileMapHeader));

         if ((n = read(fd, &header, sizeof(struct FileMapHeader)))

              != sizeof(struct FileMapHeader)) {

            print_debug("can't read shared archive file map header from %s\n", classes_jsa);

            close(fd);

            return false;

         }

         // check file magic

         if (header._magic != 0xf00baba2) {

            print_debug("%s has bad shared archive file magic number 0x%x, expecing 0xf00baba2\n",

                        classes_jsa, header._magic);

            close(fd);

            return false;

         }

         // check version

         if (header._version != CURRENT_ARCHIVE_VERSION) {

            print_debug("%s has wrong shared archive file version %d, expecting %d\n",

                        classes_jsa, header._version, CURRENT_ARCHIVE_VERSION);

            close(fd);

            return false;

         }

         ph->core->classes_jsa_fd = fd;

         // add read-only maps from classes[_g].jsa to the list of maps

         for (m = 0; m < NUM_SHARED_MAPS; m++) {

            if (header._space[m]._read_only) {

               base = (uintptr_t) header._space[m]._base;

               // no need to worry about the fractional pages at-the-end.

               // possible fractional pages are handled by core_read_data.

               add_class_share_map_info(ph, (off_t) header._space[m]._file_offset,

                         base, (size_t) header._space[m]._used);

               print_debug("added a share archive map at 0x%lx\n", base);

            }

         }

         return true;

      }

      lib = lib->next;

   }

   return true;

}

//---------------------------------------------------------------------------

// functions to handle map_info

// Order mappings based on virtual address.  We use this function as the

// callback for sorting the array of map_info pointers.

static int core_cmp_mapping(const void *lhsp, const void *rhsp)

{

   const map_info *lhs = *((const map_info **)lhsp);

   const map_info *rhs = *((const map_info **)rhsp);

   if (lhs->vaddr == rhs->vaddr)

      return (0);

   return (lhs->vaddr < rhs->vaddr ? -1 : 1);

}

// we sort map_info by starting virtual address so that we can do

// binary search to read from an address.

static bool sort_map_array(struct ps_prochandle* ph) {

   size_t num_maps = ph->core->num_maps;

   map_info* map = ph->core->maps;

   int i = 0;

   // allocate map_array

   map_info** array;

   if ( (array = (map_info**) malloc(sizeof(map_info*) * num_maps)) == NULL) {

      print_debug("can't allocate memory for map array\n");

      return false;

   }

   // add maps to array

   while (map) {

      array[i] = map;

      i++;

      map = map->next;

   }

   // sort is called twice. If this is second time, clear map array

   if (ph->core->map_array) free(ph->core->map_array);

   ph->core->map_array = array;

   // sort the map_info array by base virtual address.

   qsort(ph->core->map_array, ph->core->num_maps, sizeof (map_info*),

            core_cmp_mapping);

   // print map

   if (is_debug()) {

      int j = 0;

      print_debug("---- sorted virtual address map ----\n");

      for (j = 0; j < ph->core->num_maps; j++) {

        print_debug("base = 0x%lx\tsize = %zu\n", ph->core->map_array[j]->vaddr,

                                         ph->core->map_array[j]->memsz);

      }

   }

   return true;

}

#ifndef MIN

#define MIN(x, y) (((x) < (y))? (x): (y))

#endif

static bool core_read_data(struct ps_prochandle* ph, uintptr_t addr, char *buf, size_t size) {

   ssize_t resid = size;

   int page_size=sysconf(_SC_PAGE_SIZE);

   while (resid != 0) {

      map_info *mp = core_lookup(ph, addr);

      uintptr_t mapoff;

      ssize_t len, rem;

      off_t off;

      int fd;

      if (mp == NULL)

         break;  /* No mapping for this address */

      fd = mp->fd;

      mapoff = addr - mp->vaddr;

      len = MIN(resid, mp->memsz - mapoff);

      off = mp->offset + mapoff;

      if ((len = pread(fd, buf, len, off)) <= 0)

         break;

      resid -= len;

      addr += len;

      buf = (char *)buf + len;

      // mappings always start at page boundary. But, may end in fractional

      // page. fill zeros for possible fractional page at the end of a mapping.

      rem = mp->memsz % page_size;

      if (rem > 0) {

         rem = page_size - rem;

         len = MIN(resid, rem);

         resid -= len;

         addr += len;

         // we are not assuming 'buf' to be zero initialized.

         memset(buf, 0, len);

         buf += len;

      }

   }

   if (resid) {

      print_debug("core read failed for %d byte(s) @ 0x%lx (%d more bytes)\n",

              size, addr, resid);

      return false;

   } else {

      return true;

   }

}

// null implementation for write

static bool core_write_data(struct ps_prochandle* ph,

                             uintptr_t addr, const char *buf , size_t size) {

   return false;

}

static bool core_get_lwp_regs(struct ps_prochandle* ph, lwpid_t lwp_id,

                          struct user_regs_struct* regs) {

   // for core we have cached the lwp regs from NOTE section

   thread_info* thr = ph->threads;

   while (thr) {

     if (thr->lwp_id == lwp_id) {

       memcpy(regs, &thr->regs, sizeof(struct user_regs_struct));

       return true;

     }

     thr = thr->next;

   }

   return false;

}

static ps_prochandle_ops core_ops = {

   .release=  core_release,

   .p_pread=  core_read_data,

   .p_pwrite= core_write_data,

   .get_lwp_regs= core_get_lwp_regs