/*

 * Copyright (c) 2003, 2019, 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 "libproc_impl.h"

#include "ps_core_common.h"

#ifdef __APPLE__

#include "sun_jvm_hotspot_debugger_amd64_AMD64ThreadContext.h"

#endif

// 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)

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

// 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 = %d\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 reg* regs) {

   // for core we have cached the lwp regs after segment parsed

   sa_thread_info* thr = ph->threads;

   while (thr) {

     if (thr->lwp_id == lwp_id) {

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

       return true;

     }

     thr = thr->next;

   }

   return false;

}

static bool core_get_lwp_info(struct ps_prochandle *ph, lwpid_t id, void *info) {

   print_debug("core_get_lwp_info not implemented\n");

   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,

   .get_lwp_info= core_get_lwp_info

};

// from this point, mainly two blocks divided by def __APPLE__

// one for Macosx, the other for regular Bsd

#ifdef __APPLE__

void print_thread(sa_thread_info *threadinfo) {

  print_debug("thread added: %d\n", threadinfo->lwp_id);

  print_debug("registers:\n");

  print_debug("  r_r15: 0x%" PRIx64 "\n", threadinfo->regs.r_r15);

  print_debug("  r_r14: 0x%" PRIx64 "\n", threadinfo->regs.r_r14);

  print_debug("  r_r13: 0x%" PRIx64 "\n", threadinfo->regs.r_r13);

  print_debug("  r_r12: 0x%" PRIx64 "\n", threadinfo->regs.r_r12);

  print_debug("  r_r11: 0x%" PRIx64 "\n", threadinfo->regs.r_r11);

  print_debug("  r_r10: 0x%" PRIx64 "\n", threadinfo->regs.r_r10);

  print_debug("  r_r9:  0x%" PRIx64 "\n", threadinfo->regs.r_r9);

  print_debug("  r_r8:  0x%" PRIx64 "\n", threadinfo->regs.r_r8);

  print_debug("  r_rdi: 0x%" PRIx64 "\n", threadinfo->regs.r_rdi);

  print_debug("  r_rsi: 0x%" PRIx64 "\n", threadinfo->regs.r_rsi);

  print_debug("  r_rbp: 0x%" PRIx64 "\n", threadinfo->regs.r_rbp);

  print_debug("  r_rbx: 0x%" PRIx64 "\n", threadinfo->regs.r_rbx);

  print_debug("  r_rdx: 0x%" PRIx64 "\n", threadinfo->regs.r_rdx);

  print_debug("  r_rcx: 0x%" PRIx64 "\n", threadinfo->regs.r_rcx);

  print_debug("  r_rax: 0x%" PRIx64 "\n", threadinfo->regs.r_rax);

  print_debug("  r_fs:  0x%" PRIx32 "\n", threadinfo->regs.r_fs);

  print_debug("  r_gs:  0x%" PRIx32 "\n", threadinfo->regs.r_gs);

  print_debug("  r_rip  0x%" PRIx64 "\n", threadinfo->regs.r_rip);

  print_debug("  r_cs:  0x%" PRIx64 "\n", threadinfo->regs.r_cs);

  print_debug("  r_rsp: 0x%" PRIx64 "\n", threadinfo->regs.r_rsp);

  print_debug("  r_rflags: 0x%" PRIx64 "\n", threadinfo->regs.r_rflags);

}

// read all segments64 commands from core file

// read all thread commands from core file

static bool read_core_segments(struct ps_prochandle* ph) {

  int i = 0;

  int num_threads = 0;

  int fd = ph->core->core_fd;

  off_t offset = 0;

  mach_header_64      fhead;

  load_command        lcmd;

  segment_command_64  segcmd;

  // thread_command      thrcmd;

  lseek(fd, offset, SEEK_SET);

  if(read(fd, (void *)&fhead, sizeof(mach_header_64)) != sizeof(mach_header_64)) {

     goto err;

  }

  print_debug("total commands: %d\n", fhead.ncmds);

  offset += sizeof(mach_header_64);

  for (i = 0; i < fhead.ncmds; i++) {

    lseek(fd, offset, SEEK_SET);

    if (read(fd, (void *)&lcmd, sizeof(load_command)) != sizeof(load_command)) {

      goto err;

    }

    offset += lcmd.cmdsize;    // next command position

    if (lcmd.cmd == LC_SEGMENT_64) {

      lseek(fd, -sizeof(load_command), SEEK_CUR);

      if (read(fd, (void *)&segcmd, sizeof(segment_command_64)) != sizeof(segment_command_64)) {

        print_debug("failed to read LC_SEGMENT_64 i = %d!\n", i);

        goto err;

      }

      if (add_map_info(ph, fd, segcmd.fileoff, segcmd.vmaddr, segcmd.vmsize) == NULL) {

        print_debug("Failed to add map_info at i = %d\n", i);

        goto err;

      }

      print_debug("segment added: %" PRIu64 " 0x%" PRIx64 " %d\n",

                   segcmd.fileoff, segcmd.vmaddr, segcmd.vmsize);

    } else if (lcmd.cmd == LC_THREAD || lcmd.cmd == LC_UNIXTHREAD) {

      typedef struct thread_fc {

        uint32_t  flavor;

        uint32_t  count;

      } thread_fc;

      thread_fc fc;

      uint32_t size = sizeof(load_command);

      while (size < lcmd.cmdsize) {

        if (read(fd, (void *)&fc, sizeof(thread_fc)) != sizeof(thread_fc)) {

          printf("Reading flavor, count failed.\n");

          goto err;

        }

        size += sizeof(thread_fc);

        if (fc.flavor == x86_THREAD_STATE) {

          x86_thread_state_t thrstate;

          if (read(fd, (void *)&thrstate, sizeof(x86_thread_state_t)) != sizeof(x86_thread_state_t)) {

            printf("Reading flavor, count failed.\n");

            goto err;

          }

          size += sizeof(x86_thread_state_t);

          // create thread info list, update lwp_id later

          sa_thread_info* newthr = add_thread_info(ph, (pthread_t) -1, (lwpid_t) num_threads++);

          if (newthr == NULL) {

            printf("create thread_info failed\n");

            goto err;

          }

          // note __DARWIN_UNIX03 depengs on other definitions

#if __DARWIN_UNIX03

#define get_register_v(regst, regname) \

  regst.uts.ts64.__##regname

#else

#define get_register_v(regst, regname) \

  regst.uts.ts64.##regname

#endif // __DARWIN_UNIX03

          newthr->regs.r_rax = get_register_v(thrstate, rax);

          newthr->regs.r_rbx = get_register_v(thrstate, rbx);

          newthr->regs.r_rcx = get_register_v(thrstate, rcx);

          newthr->regs.r_rdx = get_register_v(thrstate, rdx);

          newthr->regs.r_rdi = get_register_v(thrstate, rdi);

          newthr->regs.r_rsi = get_register_v(thrstate, rsi);

          newthr->regs.r_rbp = get_register_v(thrstate, rbp);

          newthr->regs.r_rsp = get_register_v(thrstate, rsp);

          newthr->regs.r_r8  = get_register_v(thrstate, r8);

          newthr->regs.r_r9  = get_register_v(thrstate, r9);

          newthr->regs.r_r10 = get_register_v(thrstate, r10);

          newthr->regs.r_r11 = get_register_v(thrstate, r11);

          newthr->regs.r_r12 = get_register_v(thrstate, r12);

          newthr->regs.r_r13 = get_register_v(thrstate, r13);

          newthr->regs.r_r14 = get_register_v(thrstate, r14);

          newthr->regs.r_r15 = get_register_v(thrstate, r15);

          newthr->regs.r_rip = get_register_v(thrstate, rip);

          newthr->regs.r_rflags = get_register_v(thrstate, rflags);

          newthr->regs.r_cs  = get_register_v(thrstate, cs);

          newthr->regs.r_fs  = get_register_v(thrstate, fs);

          newthr->regs.r_gs  = get_register_v(thrstate, gs);

          print_thread(newthr);

        } else if (fc.flavor == x86_FLOAT_STATE) {

          x86_float_state_t flstate;

          if (read(fd, (void *)&flstate, sizeof(x86_float_state_t)) != sizeof(x86_float_state_t)) {

            print_debug("Reading flavor, count failed.\n");

            goto err;

          }

          size += sizeof(x86_float_state_t);

        } else if (fc.flavor == x86_EXCEPTION_STATE) {

          x86_exception_state_t excpstate;

          if (read(fd, (void *)&excpstate, sizeof(x86_exception_state_t)) != sizeof(x86_exception_state_t)) {

            printf("Reading flavor, count failed.\n");

            goto err;

          }

          size += sizeof(x86_exception_state_t);

        }

      }

    }

  }

  return true;

err:

  return false;

}

/**local function **/

bool exists(const char *fname) {

  return access(fname, F_OK) == 0;

}

// we check: 1. lib

//           2. lib/server

//           3. jre/lib

//           4. jre/lib/server

// from: 1. exe path

//       2. JAVA_HOME

//       3. DYLD_LIBRARY_PATH

static bool get_real_path(struct ps_prochandle* ph, char *rpath) {

  /** check if they exist in JAVA ***/

  char* execname = ph->core->exec_path;

  char  filepath[4096];

  char* filename = strrchr(rpath, '/');               // like /libjvm.dylib

  if (filename == NULL) {

    return false;

  }

  char* posbin = strstr(execname, "/bin/java");

  if (posbin != NULL) {

    memcpy(filepath, execname, posbin - execname);    // not include trailing '/'

    filepath[posbin - execname] = '\0';

  } else {

    char* java_home = getenv("JAVA_HOME");

    if (java_home != NULL) {

      strcpy(filepath, java_home);

    } else {

      char* dyldpath = getenv("DYLD_LIBRARY_PATH");

      char* save_ptr;

      char* dypath = strtok_r(dyldpath, ":", &save_ptr);

      while (dypath != NULL) {

        strcpy(filepath, dypath);

        strcat(filepath, filename);

        if (exists(filepath)) {

           strcpy(rpath, filepath);

           return true;

        }

        dypath = strtok_r(NULL, ":", &save_ptr);

      }

      // not found

      return false;

    }

  }

  // for exec and java_home, jdkpath now is filepath

  size_t filepath_base_size = strlen(filepath);

  // first try /lib/ and /lib/server

  strcat(filepath, "/lib");

  strcat(filepath, filename);

  if (exists(filepath)) {

    strcpy(rpath, filepath);

    return true;

  }

  char* pos = strstr(filepath, filename);    // like /libjvm.dylib

  *pos = '\0';

  strcat(filepath, "/server");

  strcat(filepath, filename);

  if (exists(filepath)) {

    strcpy(rpath, filepath);

    return true;

  }

  // then try /jre/lib/ and /jre/lib/server

  filepath[filepath_base_size] = '\0';

  strcat(filepath, "/jre/lib");

  strcat(filepath, filename);

  if (exists(filepath)) {

    strcpy(rpath, filepath);

    return true;

  }

  pos = strstr(filepath, filename);

  *pos = '\0';

  strcat(filepath, "/server");

  strcat(filepath, filename);

  if (exists(filepath)) {

    strcpy(rpath, filepath);

    return true;

  }

  return false;

}

static bool read_shared_lib_info(struct ps_prochandle* ph) {

  static int pagesize = 0;

  int fd = ph->core->core_fd;

  int i = 0, j;

  uint32_t  v;

  mach_header_64 header;        // used to check if a file header in segment

  load_command lcmd;

  dylib_command dylibcmd;

  char name[BUF_SIZE];  // use to store name

  if (pagesize == 0) {

    pagesize = getpagesize();

    print_debug("page size is %d\n", pagesize);

  }

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

    map_info *iter = ph->core->map_array[j];   // head

    off_t fpos = iter->offset;

    if (iter->fd != fd) {

      // only search core file!

      continue;

    }

    print_debug("map_info %d: vmaddr = 0x%016" PRIx64 "  fileoff = %" PRIu64 "  vmsize = %" PRIu64 "\n",

                           j, iter->vaddr, iter->offset, iter->memsz);

    lseek(fd, fpos, SEEK_SET);

    // we assume .dylib loaded at segment address --- which is true for JVM libraries

    // multiple files may be loaded in one segment.

    // if first word is not a magic word, means this segment does not contain lib file.

    if (read(fd, (void *)&v, sizeof(uint32_t)) == sizeof(uint32_t)) {

      if (v != MH_MAGIC_64) {

        continue;

      }

    } else {

      // may be encountered last map, which is not readable

      continue;

    }

    while (ltell(fd) - iter->offset < iter->memsz) {

      lseek(fd, fpos, SEEK_SET);

      if (read(fd, (void *)&v, sizeof(uint32_t)) != sizeof(uint32_t)) {

        break;

      }

      if (v != MH_MAGIC_64) {

        fpos = (ltell(fd) + pagesize -1)/pagesize * pagesize;

        continue;

      }

      lseek(fd, -sizeof(uint32_t), SEEK_CUR);

      // this is the file begining to core file.

      if (read(fd, (void *)&header, sizeof(mach_header_64)) != sizeof(mach_header_64)) {

        goto err;

      }

      fpos = ltell(fd);

      // found a mach-o file in this segment

      for (i = 0; i < header.ncmds; i++) {

        // read commands in this "file"

        // LC_ID_DYLIB is the file itself for a .dylib

        lseek(fd, fpos, SEEK_SET);

        if (read(fd, (void *)&lcmd, sizeof(load_command)) != sizeof(load_command)) {

          return false;   // error

        }

        fpos += lcmd.cmdsize;  // next command position

        // make sure still within seg size.

        if (fpos  - lcmd.cmdsize - iter->offset > iter->memsz) {

          print_debug("Warning: out of segement limit: %ld \n", fpos  - lcmd.cmdsize - iter->offset);

          break;  // no need to iterate all commands

        }

        if (lcmd.cmd == LC_ID_DYLIB) {

          lseek(fd, -sizeof(load_command), SEEK_CUR);

          if (read(fd, (void *)&dylibcmd, sizeof(dylib_command)) != sizeof(dylib_command)) {

            return false;

          }

          /**** name stored at dylib_command.dylib.name.offset, is a C string  */

          lseek(fd, dylibcmd.dylib.name.offset - sizeof(dylib_command), SEEK_CUR);

          int j = 0;

          while (j < BUF_SIZE) {

            read(fd, (void *)(name + j), sizeof(char));

            if (name[j] == '\0') break;

            j++;

          }

          print_debug("%s\n", name);

          // changed name from @rpath/xxxx.dylib to real path