MqCall_jv.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#include <jni.h>
#include "LibMqMsgque_private_jv.h"
 
void MK_DECL
NS(ServiceCopy) ( MQ_SERVICE_COPY_ARGS )
{
  struct MkProcCallS * old = (struct MkProcCallS *) *dataP;
  JavaErrorCheckNULL(*dataP = MK(ProcCreate) (MK_RT_CALL old->env, old->object, old->class, old->method, old->hasArg));
  return;
error:
  MkPanicC_4M(mqctx, __func__, -1, "unable to copy proc data");
}
 
void MK_DECL
NS(ServiceFree) ( MQ_SERVICE_FREE_ARGS)
{
  MK(ProcFree) ((struct MkProcCallS **) dataP);
}
 
enum MkErrorE MK_DECL
NS(ServiceCall) ( MQ_SERVICE_CALL_ARGS )
{
  MQ_SERVICE_CALL_CHECK;
 
  struct MkProcCallS const * const call = (struct MkProcCallS const * const) __data__;
  JNIEnv *env = call->env;
 
  // clean JAVA and libmqmsgque error
  //(*env)->ExceptionClear(env);
  //MkErrorReset(mqctx);
 
//printXV(mqctx "%s: self=%p, class=%p, object=%p, method=%p", MqServiceTokenGet(mqctx), self, call->class, call->object, call->method);
  if (call->hasArg == false) {
 
    // call the function
    if (call->class == NULL) {
      // method call of the same class
      (*env)->CallVoidMethod(env, call->object, call->method);
    } else if (call->object == NULL) {
      // static method call returning an object
      (*env)->CallStaticObjectMethod(env, call->class, call->method);
    } else {
      // method call of an other class
      (*env)->CallNonvirtualVoidMethod(env, call->object, call->class, call->method);
    }
 
  } else {
 
    jobject self = MqContextC_ObjNewOrNull(env,mqctx);
 
    // call the function
    if (call->class == NULL) {
      // method call of the same class
      //(*env)->CallVoidMethod(env, call->object, call->method, call->data);
      (*env)->CallVoidMethod(env, call->object, call->method, self);
    } else if (call->object == NULL) {
      // static method call returning an object
      (*env)->CallStaticObjectMethod(env, call->class, call->method, self);
    } else {
      // method call of an other class
      (*env)->CallNonvirtualVoidMethod(env, call->object, call->class, call->method, self);
    }
  }
 
  // check on error
  if((*env)->ExceptionCheck(env) != JNI_FALSE) {
    // is the ERROR from "java" or "jvmkkernel"
    OT_ERROR_LNG_2_META(mqctx);
  }
  return MkErrorStack_0E_Check();
}
 
/*
void printObj (JNIEnv *env, jobject obj) {
  (*env)->CallStaticObjectMethod(env, NS(Class_MkObjectC), NS(MID_MkObjectC_printObj), obj);
  JavaErrorReport
}
*/
 
// ************************************************************************************
 
/*
#
# A fatal error has been detected by the Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x00000000063f681d, pid=47793, tid=0x000000002ebba700
#
# JRE version: OpenJDK Runtime Environment (8.0_191-b12) (build 1.8.0_191-b12)
# Java VM: OpenJDK 64-Bit Server VM (25.191-b12 interpreted mode linux-amd64 compressed oops)
# Derivative: IcedTea 3.10.0
# Distribution: Custom build (Thu Jan 10 19:41:37 UTC 2019)
# Problematic frame:
# V  [libjvm.so+0x5d581d]  jni_ReleaseByteArrayElements+0x6d
#
# Failed to write core dump. Core dumps have been disabled. To enable core dumping, try "ulimit -c unlimited" before starting Java again
#
# An error report file with more information is saved as:
# .../NHI1/theLink/tests/hs_err_pid47793.log
 
 
The code described in your link makes the invalid assumption that Java will never move the underlying byte array. 
Astonishing that it ever worked, if indeed it ever did, and even more astonishing that it got published under the IBM banner. 
– user207421 Jan 27 '17 at 21:10
 
*/
 
/*
struct Jalloc{
  int         sig;
  jbyteArray  jba;
  jobject     ref;
  size_t      siz;
};
 
static MK_PTR jv_malloc(size_t t)
{
  if (MK(cached_jvm) != NULL) {
    JNIEnv* env = NULL;
    jboolean isCopy = false;
    MkErrorCheck(MK(GetJniEnv)(&env));
 
    jbyteArray jba=(*env)->NewByteArray(env, (int)t+sizeof(struct Jalloc));
    if ((*env)->ExceptionOccurred(env)) goto error;
 
    void* jbuffer = (void*) (*env)->GetByteArrayElements(env,jba,&isCopy);
    if ((*env)->ExceptionOccurred(env)) goto error;
 
//printV("env=%p, buffer=%p, isCopy=%s\n", env, jbuffer, isCopy?"true":"false")
 
    struct Jalloc *pJalloc = (struct Jalloc*) jbuffer;
    pJalloc->sig = 0x39F6F1A8;
    pJalloc->jba = jba;
    pJalloc->ref = (*env)->NewGlobalRef(env, jba);
    pJalloc->siz = t;
    if((*env)->ExceptionOccurred(env)) goto error;
 
    return (MK_PTR) (((char*)jbuffer)+sizeof(struct Jalloc));
  } else {
    struct Jalloc* pJalloc= (struct Jalloc*) malloc((int)t+sizeof(struct Jalloc));
    if (!pJalloc) goto error;
    pJalloc->sig = 0x39F6F1A8;
    pJalloc->ref = 0;
    pJalloc->siz = t;
    return (MK_PTR) (((char*)((void*)pJalloc))+sizeof(struct Jalloc));
  }
error:
  return NULL;
}
 
static void jv_free(void* v)
{
  if (v != NULL) {
    void* buffer = (void*) (((char*)v)-sizeof(struct Jalloc));
    struct Jalloc* pJalloc = (struct Jalloc*) buffer;
    if(pJalloc->sig == 0x39F6F1A8 && pJalloc->ref) {
      JNIEnv* env = NULL;
      pJalloc->sig = 0x00000000;
      MkErrorCheck(MK(GetJniEnv)(&env));
 
//printV("env=%p, buffer=%p\n", env, buffer)
 
      (*env)->DeleteGlobalRef(env, pJalloc->ref);
      if ((*env)->ExceptionCheck(env)) {
        (*env)->ExceptionDescribe(env);
      }
      (*env)->ReleaseByteArrayElements(env, pJalloc->jba, (jbyte*)buffer, JNI_ABORT);
    } else{
      free(buffer);
    }
  }
error:
  return;
}
 
static MK_PTR jv_calloc (size_t nelem, size_t elsize)
{
  register MK_PTR ptr;  
 
  if (nelem == 0 || elsize == 0) nelem = elsize = 1;
  
  ptr = jv_malloc (nelem * elsize);
  if (ptr) memset(ptr,'\0', nelem * elsize);
  
  return ptr;
}
 
static MK_PTR jv_realloc (MK_PTR oldPtr, size_t newsize)
{
  if (oldPtr == NULL)  return jv_malloc (newsize);
 
  void* buffer = (void*) (((char*)oldPtr)-sizeof(struct Jalloc));
  struct Jalloc* pJalloc = (struct Jalloc*) buffer;
 
  if (newsize < pJalloc->siz) return oldPtr;
 
  if(pJalloc->ref) {
    MK_PTR newPtr = jv_malloc (newsize);
    if (newPtr == NULL) goto error;
    bcopy(oldPtr, newPtr, pJalloc->siz);
    jv_free(oldPtr);
    return newPtr;
  } else{
    return realloc(oldPtr,newsize);
  }
error:
  return NULL;
}
 
static MK_STR jv_strdup (MK_STRN s) 
{
  MK_STR result = (MK_STR) jv_malloc (strlen(s) + 1);
  if (result == (MK_STR)0)
    return (MK_STR)0;
  strcpy(result, s);
  return result;
}
 
static MK_STR jv_strndup (MK_STRN s, MK_SIZE l) 
{
  const MK_SIZE len = l+1;
  MK_STR result = (MK_STR) jv_malloc (len);
  if (result == (MK_STR)0)
    return (MK_STR)0;
  strncpy(result, s, len);
  return result;
}
*/
 
//void JavaSetup (void) {
/*
 
  → total shit → https://www.usenix.org/legacy/event/usenix07/posters/sorensen.pdf
 
  MkLal.SysCalloc       = jv_calloc;
  MkLal.SysMalloc       = jv_malloc;
  MkLal.SysRealloc      = jv_realloc;
  MkLal.SysFree         = jv_free;
  MkLal.SysStrDup       = jv_strdup;
  MkLal.SysStrNDup      = jv_strndup;
*/
//}