1 /*

     2  * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include <stdlib.h>

    27 #include <jni.h>

    28 #include "management_ext.h"

    29 #include "com_sun_management_internal_DiagnosticCommandImpl.h"

    30 

    31 JNIEXPORT void JNICALL Java_com_sun_management_internal_DiagnosticCommandImpl_setNotificationEnabled

    32 (JNIEnv *env, jobject dummy, jboolean enabled) {

    33     if (jmm_version <= JMM_VERSION_1_2_2) {

    34         JNU_ThrowByName(env, "java/lang/UnsupportedOperationException",

    35                         "JMX interface to diagnostic framework notifications is not supported by this VM");

    36         return;

    37     }

    38     jmm_interface->SetDiagnosticFrameworkNotificationEnabled(env, enabled);

    39 }

    40 

    41 JNIEXPORT jobjectArray JNICALL

    42 Java_com_sun_management_internal_DiagnosticCommandImpl_getDiagnosticCommands

    43   (JNIEnv *env, jobject dummy)

    44 {

    45   return jmm_interface->GetDiagnosticCommands(env);

    46 }

    47 

    48 jobject getDiagnosticCommandArgumentInfoArray(JNIEnv *env, jstring command,

    49                                               int num_arg) {

    50   int i;

    51   jobject obj;

    52   jobjectArray result;

    53   dcmdArgInfo* dcmd_arg_info_array;

    54   jclass dcmdArgInfoCls;

    55   jclass arraysCls;

    56   jmethodID mid;

    57   jobject resultList;

    58 

    59   dcmd_arg_info_array = (dcmdArgInfo*) malloc(num_arg * sizeof(dcmdArgInfo));

    60   /* According to ISO C it is perfectly legal for malloc to return zero if called with a zero argument */

    61   if (dcmd_arg_info_array == NULL && num_arg != 0) {

    62     return NULL;

    63   }

    64   jmm_interface->GetDiagnosticCommandArgumentsInfo(env, command,

    65                                                    dcmd_arg_info_array);

    66   dcmdArgInfoCls = (*env)->FindClass(env,

    67                                      "com/sun/management/internal/DiagnosticCommandArgumentInfo");

    68   if ((*env)->ExceptionCheck(env)) {

    69     free(dcmd_arg_info_array);

    70     return NULL;

    71   }

    72 

    73   result = (*env)->NewObjectArray(env, num_arg, dcmdArgInfoCls, NULL);

    74   if (result == NULL) {

    75     free(dcmd_arg_info_array);

    76     return NULL;

    77   }

    78   for (i=0; i<num_arg; i++) {

    79     obj = JNU_NewObjectByName(env,

    80                               "com/sun/management/internal/DiagnosticCommandArgumentInfo",

    81                               "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZZI)V",

    82                               (*env)->NewStringUTF(env,dcmd_arg_info_array[i].name),

    83                               (*env)->NewStringUTF(env,dcmd_arg_info_array[i].description),

    84                               (*env)->NewStringUTF(env,dcmd_arg_info_array[i].type),

    85                               dcmd_arg_info_array[i].default_string == NULL ? NULL:

    86                               (*env)->NewStringUTF(env, dcmd_arg_info_array[i].default_string),

    87                               dcmd_arg_info_array[i].mandatory,

    88                               dcmd_arg_info_array[i].option,

    89                               dcmd_arg_info_array[i].multiple,

    90                               dcmd_arg_info_array[i].position);

    91     if (obj == NULL) {

    92       free(dcmd_arg_info_array);

    93       return NULL;

    94     }

    95     (*env)->SetObjectArrayElement(env, result, i, obj);

    96   }

    97   free(dcmd_arg_info_array);

    98   arraysCls = (*env)->FindClass(env, "java/util/Arrays");

    99   if ((*env)->ExceptionCheck(env)) {

   100     return NULL;

   101   }

   102   mid = (*env)->GetStaticMethodID(env, arraysCls,

   103                                   "asList", "([Ljava/lang/Object;)Ljava/util/List;");

   104   resultList = (*env)->CallStaticObjectMethod(env, arraysCls, mid, result);

   105   if ((*env)->ExceptionCheck(env)) {

   106     // Make sure we return NULL in case of OOM inside Java

   107     return NULL;

   108   }

   109   return resultList;

   110 }

   111 

   112 /* Throws IllegalArgumentException if at least one of the diagnostic command

   113  * passed in argument is not supported by the JVM

   114  */

   115 JNIEXPORT jobjectArray JNICALL

   116 Java_com_sun_management_internal_DiagnosticCommandImpl_getDiagnosticCommandInfo

   117 (JNIEnv *env, jobject dummy, jobjectArray commands)

   118 {

   119   int i;

   120   jclass dcmdInfoCls;

   121   jobject result;

   122   jobjectArray args;

   123   jobject obj;

   124   jmmOptionalSupport mos;

   125   jint ret = jmm_interface->GetOptionalSupport(env, &mos);

   126   jsize num_commands;

   127   dcmdInfo* dcmd_info_array;

   128 

   129   if (commands == NULL) {

   130       JNU_ThrowNullPointerException(env, "Invalid String Array");

   131       return NULL;

   132   }

   133   num_commands = (*env)->GetArrayLength(env, commands);

   134   dcmdInfoCls = (*env)->FindClass(env,

   135                                   "com/sun/management/internal/DiagnosticCommandInfo");

   136   if ((*env)->ExceptionCheck(env)) {

   137     return NULL;

   138   }

   139 

   140   result = (*env)->NewObjectArray(env, num_commands, dcmdInfoCls, NULL);

   141   if (result == NULL) {

   142       JNU_ThrowOutOfMemoryError(env, 0);

   143       return NULL;

   144   }

   145   if (num_commands == 0) {

   146       /* Handle the 'zero commands' case specially to avoid calling 'malloc()' */

   147       /* with a zero argument because that may legally return a NULL pointer.  */

   148       return result;

   149   }

   150   dcmd_info_array = (dcmdInfo*) malloc(num_commands * sizeof(dcmdInfo));

   151   if (dcmd_info_array == NULL) {

   152       JNU_ThrowOutOfMemoryError(env, NULL);

   153       return NULL;

   154   }

   155   jmm_interface->GetDiagnosticCommandInfo(env, commands, dcmd_info_array);

   156   for (i=0; i<num_commands; i++) {

   157       args = getDiagnosticCommandArgumentInfoArray(env,

   158                                                    (*env)->GetObjectArrayElement(env,commands,i),

   159                                                    dcmd_info_array[i].num_arguments);

   160       if (args == NULL) {

   161           free(dcmd_info_array);

   162           JNU_ThrowOutOfMemoryError(env, 0);

   163           return NULL;

   164       }

   165       obj = JNU_NewObjectByName(env,

   166                                 "com/sun/management/internal/DiagnosticCommandInfo",

   167                                 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZLjava/util/List;)V",

   168                                 (*env)->NewStringUTF(env,dcmd_info_array[i].name),

   169                                 (*env)->NewStringUTF(env,dcmd_info_array[i].description),

   170                                 (*env)->NewStringUTF(env,dcmd_info_array[i].impact),

   171                                 dcmd_info_array[i].permission_class==NULL?NULL:(*env)->NewStringUTF(env,dcmd_info_array[i].permission_class),

   172                                 dcmd_info_array[i].permission_name==NULL?NULL:(*env)->NewStringUTF(env,dcmd_info_array[i].permission_name),

   173                                 dcmd_info_array[i].permission_action==NULL?NULL:(*env)->NewStringUTF(env,dcmd_info_array[i].permission_action),

   174                                 dcmd_info_array[i].enabled,

   175                                 args);

   176       if (obj == NULL) {

   177           free(dcmd_info_array);

   178           JNU_ThrowOutOfMemoryError(env, 0);

   179           return NULL;

   180       }

   181       (*env)->SetObjectArrayElement(env, result, i, obj);

   182   }

   183   free(dcmd_info_array);

   184   return result;

   185 }

   186 

   187 /* Throws IllegalArgumentException if the diagnostic command

   188  * passed in argument is not supported by the JVM

   189  */

   190 JNIEXPORT jstring JNICALL

   191 Java_com_sun_management_internal_DiagnosticCommandImpl_executeDiagnosticCommand

   192 (JNIEnv *env, jobject dummy, jstring command) {

   193   return jmm_interface->ExecuteDiagnosticCommand(env, command);

   194 }