1134 JavaThread* java_thread = NULL;
1135 jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), thread, &java_thread, &thread_oop);
1136 if (err != JVMTI_ERROR_NONE) {
1137 // We got an error code so we don't have a JavaThread *, but
1138 // only return an error from here if we didn't get a valid
1139 // thread_oop.
1140 if (thread_oop == NULL) {
1141 return err;
1142 }
1143 // We have a valid thread_oop so we can return some thread info.
1144 }
1145 }
1146
1147 Handle thread_obj(current_thread, thread_oop);
1148 Handle name;
1149 ThreadPriority priority;
1150 Handle thread_group;
1151 Handle context_class_loader;
1152 bool is_daemon;
1153
1154 { MutexLocker mu(Threads_lock);
1155
1156 name = Handle(current_thread, java_lang_Thread::name(thread_obj()));
1157 priority = java_lang_Thread::priority(thread_obj());
1158 thread_group = Handle(current_thread, java_lang_Thread::threadGroup(thread_obj()));
1159 is_daemon = java_lang_Thread::is_daemon(thread_obj());
1160
1161 oop loader = java_lang_Thread::context_class_loader(thread_obj());
1162 context_class_loader = Handle(current_thread, loader);
1163 }
1164 { const char *n;
1165
1166 if (name() != NULL) {
1167 n = java_lang_String::as_utf8_string(name());
1168 } else {
1169 int utf8_length = 0;
1170 n = UNICODE::as_utf8((jchar*) NULL, utf8_length);
1171 }
1172
1173 info_ptr->name = (char *) jvmtiMalloc(strlen(n)+1);
1174 if (info_ptr->name == NULL)
1175 return JVMTI_ERROR_OUT_OF_MEMORY;
1176
1177 strcpy(info_ptr->name, n);
1178 }
1179 info_ptr->is_daemon = is_daemon;
1180 info_ptr->priority = priority;
1181
1182 info_ptr->context_class_loader = (context_class_loader.is_null()) ? NULL :
1183 jni_reference(context_class_loader);
1392 return JVMTI_ERROR_NONE;
1393 } /* end GetTopThreadGroups */
1394
1395
1396 // info_ptr - pre-checked for NULL
1397 jvmtiError
1398 JvmtiEnv::GetThreadGroupInfo(jthreadGroup group, jvmtiThreadGroupInfo* info_ptr) {
1399 ResourceMark rm;
1400 HandleMark hm;
1401
1402 JavaThread* current_thread = JavaThread::current();
1403
1404 Handle group_obj (current_thread, JNIHandles::resolve_external_guard(group));
1405 NULL_CHECK(group_obj(), JVMTI_ERROR_INVALID_THREAD_GROUP);
1406
1407 const char* name;
1408 Handle parent_group;
1409 bool is_daemon;
1410 ThreadPriority max_priority;
1411
1412 { MutexLocker mu(Threads_lock);
1413
1414 name = java_lang_ThreadGroup::name(group_obj());
1415 parent_group = Handle(current_thread, java_lang_ThreadGroup::parent(group_obj()));
1416 is_daemon = java_lang_ThreadGroup::is_daemon(group_obj());
1417 max_priority = java_lang_ThreadGroup::maxPriority(group_obj());
1418 }
1419
1420 info_ptr->is_daemon = is_daemon;
1421 info_ptr->max_priority = max_priority;
1422 info_ptr->parent = jni_reference(parent_group);
1423
1424 if (name != NULL) {
1425 info_ptr->name = (char*)jvmtiMalloc(strlen(name)+1);
1426 NULL_CHECK(info_ptr->name, JVMTI_ERROR_OUT_OF_MEMORY);
1427 strcpy(info_ptr->name, name);
1428 } else {
1429 info_ptr->name = NULL;
1430 }
1431
1432 return JVMTI_ERROR_NONE;
1433 } /* end GetThreadGroupInfo */
1434
1435
1436 // thread_count_ptr - pre-checked for NULL
1437 // threads_ptr - pre-checked for NULL
1438 // group_count_ptr - pre-checked for NULL
1439 // groups_ptr - pre-checked for NULL
1440 jvmtiError
1441 JvmtiEnv::GetThreadGroupChildren(jthreadGroup group, jint* thread_count_ptr, jthread** threads_ptr, jint* group_count_ptr, jthreadGroup** groups_ptr) {
1442 JavaThread* current_thread = JavaThread::current();
1443 oop group_obj = (oop) JNIHandles::resolve_external_guard(group);
1444 NULL_CHECK(group_obj, JVMTI_ERROR_INVALID_THREAD_GROUP);
1445
1446 Handle *thread_objs = NULL;
1447 Handle *group_objs = NULL;
1448 int nthreads = 0;
1449 int ngroups = 0;
1450 int hidden_threads = 0;
1451
1452 ResourceMark rm(current_thread);
1453 HandleMark hm(current_thread);
1454
1455 Handle group_hdl(current_thread, group_obj);
1456
1457 { // Cannot allow thread or group counts to change.
1458 MutexLocker mu(Threads_lock);
1459
1460 nthreads = java_lang_ThreadGroup::nthreads(group_hdl());
1461 ngroups = java_lang_ThreadGroup::ngroups(group_hdl());
1462
1463 if (nthreads > 0) {
1464 ThreadsListHandle tlh(current_thread);
1465 objArrayOop threads = java_lang_ThreadGroup::threads(group_hdl());
1466 assert(nthreads <= threads->length(), "too many threads");
1467 thread_objs = NEW_RESOURCE_ARRAY(Handle,nthreads);
1468 for (int i=0, j=0; i<nthreads; i++) {
1469 oop thread_obj = threads->obj_at(i);
1470 assert(thread_obj != NULL, "thread_obj is NULL");
1471 JavaThread *java_thread = NULL;
1472 jvmtiError err = JvmtiExport::cv_oop_to_JavaThread(tlh.list(), thread_obj, &java_thread);
1473 if (err == JVMTI_ERROR_NONE) {
1474 // Have a valid JavaThread*.
1475 if (java_thread->is_hidden_from_external_view()) {
1476 // Filter out hidden java threads.
1477 hidden_threads++;
1478 continue;
1486 continue;
1487 }
1488 // We have a valid thread_obj, but no JavaThread*; the caller
1489 // can still have limited use for the thread_obj.
1490 }
1491 thread_objs[j++] = Handle(current_thread, thread_obj);
1492 }
1493 nthreads -= hidden_threads;
1494 } // ThreadsListHandle is destroyed here.
1495
1496 if (ngroups > 0) {
1497 objArrayOop groups = java_lang_ThreadGroup::groups(group_hdl());
1498 assert(ngroups <= groups->length(), "too many groups");
1499 group_objs = NEW_RESOURCE_ARRAY(Handle,ngroups);
1500 for (int i=0; i<ngroups; i++) {
1501 oop group_obj = groups->obj_at(i);
1502 assert(group_obj != NULL, "group_obj != NULL");
1503 group_objs[i] = Handle(current_thread, group_obj);
1504 }
1505 }
1506 }
1507
1508 // have to make global handles outside of Threads_lock
1509 *group_count_ptr = ngroups;
1510 *thread_count_ptr = nthreads;
1511 *threads_ptr = new_jthreadArray(nthreads, thread_objs);
1512 *groups_ptr = new_jthreadGroupArray(ngroups, group_objs);
1513 if ((nthreads > 0) && (*threads_ptr == NULL)) {
1514 return JVMTI_ERROR_OUT_OF_MEMORY;
1515 }
1516 if ((ngroups > 0) && (*groups_ptr == NULL)) {
1517 return JVMTI_ERROR_OUT_OF_MEMORY;
1518 }
1519
1520 return JVMTI_ERROR_NONE;
1521 } /* end GetThreadGroupChildren */
1522
1523
1524 //
1525 // Stack Frame functions
1526 //
1527
1528 // Threads_lock NOT held, java_thread not protected by lock
|
1134 JavaThread* java_thread = NULL;
1135 jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), thread, &java_thread, &thread_oop);
1136 if (err != JVMTI_ERROR_NONE) {
1137 // We got an error code so we don't have a JavaThread *, but
1138 // only return an error from here if we didn't get a valid
1139 // thread_oop.
1140 if (thread_oop == NULL) {
1141 return err;
1142 }
1143 // We have a valid thread_oop so we can return some thread info.
1144 }
1145 }
1146
1147 Handle thread_obj(current_thread, thread_oop);
1148 Handle name;
1149 ThreadPriority priority;
1150 Handle thread_group;
1151 Handle context_class_loader;
1152 bool is_daemon;
1153
1154 name = Handle(current_thread, java_lang_Thread::name(thread_obj()));
1155 priority = java_lang_Thread::priority(thread_obj());
1156 thread_group = Handle(current_thread, java_lang_Thread::threadGroup(thread_obj()));
1157 is_daemon = java_lang_Thread::is_daemon(thread_obj());
1158
1159 oop loader = java_lang_Thread::context_class_loader(thread_obj());
1160 context_class_loader = Handle(current_thread, loader);
1161
1162 { const char *n;
1163
1164 if (name() != NULL) {
1165 n = java_lang_String::as_utf8_string(name());
1166 } else {
1167 int utf8_length = 0;
1168 n = UNICODE::as_utf8((jchar*) NULL, utf8_length);
1169 }
1170
1171 info_ptr->name = (char *) jvmtiMalloc(strlen(n)+1);
1172 if (info_ptr->name == NULL)
1173 return JVMTI_ERROR_OUT_OF_MEMORY;
1174
1175 strcpy(info_ptr->name, n);
1176 }
1177 info_ptr->is_daemon = is_daemon;
1178 info_ptr->priority = priority;
1179
1180 info_ptr->context_class_loader = (context_class_loader.is_null()) ? NULL :
1181 jni_reference(context_class_loader);
1390 return JVMTI_ERROR_NONE;
1391 } /* end GetTopThreadGroups */
1392
1393
1394 // info_ptr - pre-checked for NULL
1395 jvmtiError
1396 JvmtiEnv::GetThreadGroupInfo(jthreadGroup group, jvmtiThreadGroupInfo* info_ptr) {
1397 ResourceMark rm;
1398 HandleMark hm;
1399
1400 JavaThread* current_thread = JavaThread::current();
1401
1402 Handle group_obj (current_thread, JNIHandles::resolve_external_guard(group));
1403 NULL_CHECK(group_obj(), JVMTI_ERROR_INVALID_THREAD_GROUP);
1404
1405 const char* name;
1406 Handle parent_group;
1407 bool is_daemon;
1408 ThreadPriority max_priority;
1409
1410 name = java_lang_ThreadGroup::name(group_obj());
1411 parent_group = Handle(current_thread, java_lang_ThreadGroup::parent(group_obj()));
1412 is_daemon = java_lang_ThreadGroup::is_daemon(group_obj());
1413 max_priority = java_lang_ThreadGroup::maxPriority(group_obj());
1414
1415 info_ptr->is_daemon = is_daemon;
1416 info_ptr->max_priority = max_priority;
1417 info_ptr->parent = jni_reference(parent_group);
1418
1419 if (name != NULL) {
1420 info_ptr->name = (char*)jvmtiMalloc(strlen(name)+1);
1421 NULL_CHECK(info_ptr->name, JVMTI_ERROR_OUT_OF_MEMORY);
1422 strcpy(info_ptr->name, name);
1423 } else {
1424 info_ptr->name = NULL;
1425 }
1426
1427 return JVMTI_ERROR_NONE;
1428 } /* end GetThreadGroupInfo */
1429
1430
1431 // thread_count_ptr - pre-checked for NULL
1432 // threads_ptr - pre-checked for NULL
1433 // group_count_ptr - pre-checked for NULL
1434 // groups_ptr - pre-checked for NULL
1435 jvmtiError
1436 JvmtiEnv::GetThreadGroupChildren(jthreadGroup group, jint* thread_count_ptr, jthread** threads_ptr, jint* group_count_ptr, jthreadGroup** groups_ptr) {
1437 JavaThread* current_thread = JavaThread::current();
1438 oop group_obj = (oop) JNIHandles::resolve_external_guard(group);
1439 NULL_CHECK(group_obj, JVMTI_ERROR_INVALID_THREAD_GROUP);
1440
1441 Handle *thread_objs = NULL;
1442 Handle *group_objs = NULL;
1443 int nthreads = 0;
1444 int ngroups = 0;
1445 int hidden_threads = 0;
1446
1447 ResourceMark rm(current_thread);
1448 HandleMark hm(current_thread);
1449
1450 Handle group_hdl(current_thread, group_obj);
1451
1452 { // Cannot allow thread or group counts to change.
1453 ObjectLocker ol(group_hdl, current_thread);
1454
1455 nthreads = java_lang_ThreadGroup::nthreads(group_hdl());
1456 ngroups = java_lang_ThreadGroup::ngroups(group_hdl());
1457
1458 if (nthreads > 0) {
1459 ThreadsListHandle tlh(current_thread);
1460 objArrayOop threads = java_lang_ThreadGroup::threads(group_hdl());
1461 assert(nthreads <= threads->length(), "too many threads");
1462 thread_objs = NEW_RESOURCE_ARRAY(Handle,nthreads);
1463 for (int i=0, j=0; i<nthreads; i++) {
1464 oop thread_obj = threads->obj_at(i);
1465 assert(thread_obj != NULL, "thread_obj is NULL");
1466 JavaThread *java_thread = NULL;
1467 jvmtiError err = JvmtiExport::cv_oop_to_JavaThread(tlh.list(), thread_obj, &java_thread);
1468 if (err == JVMTI_ERROR_NONE) {
1469 // Have a valid JavaThread*.
1470 if (java_thread->is_hidden_from_external_view()) {
1471 // Filter out hidden java threads.
1472 hidden_threads++;
1473 continue;
1481 continue;
1482 }
1483 // We have a valid thread_obj, but no JavaThread*; the caller
1484 // can still have limited use for the thread_obj.
1485 }
1486 thread_objs[j++] = Handle(current_thread, thread_obj);
1487 }
1488 nthreads -= hidden_threads;
1489 } // ThreadsListHandle is destroyed here.
1490
1491 if (ngroups > 0) {
1492 objArrayOop groups = java_lang_ThreadGroup::groups(group_hdl());
1493 assert(ngroups <= groups->length(), "too many groups");
1494 group_objs = NEW_RESOURCE_ARRAY(Handle,ngroups);
1495 for (int i=0; i<ngroups; i++) {
1496 oop group_obj = groups->obj_at(i);
1497 assert(group_obj != NULL, "group_obj != NULL");
1498 group_objs[i] = Handle(current_thread, group_obj);
1499 }
1500 }
1501 } // ThreadGroup unlocked here
1502
1503 *group_count_ptr = ngroups;
1504 *thread_count_ptr = nthreads;
1505 *threads_ptr = new_jthreadArray(nthreads, thread_objs);
1506 *groups_ptr = new_jthreadGroupArray(ngroups, group_objs);
1507 if ((nthreads > 0) && (*threads_ptr == NULL)) {
1508 return JVMTI_ERROR_OUT_OF_MEMORY;
1509 }
1510 if ((ngroups > 0) && (*groups_ptr == NULL)) {
1511 return JVMTI_ERROR_OUT_OF_MEMORY;
1512 }
1513
1514 return JVMTI_ERROR_NONE;
1515 } /* end GetThreadGroupChildren */
1516
1517
1518 //
1519 // Stack Frame functions
1520 //
1521
1522 // Threads_lock NOT held, java_thread not protected by lock
|