src/threads/thread.cpp

   1 /* src/threads/thread.cpp - machine independent thread functions
   2
   3    Copyright (C) 2007, 2008
   4    CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
   5
   6    This file is part of CACAO.
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License as
  10    published by the Free Software Foundation; either version 2, or (at
  11    your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23 */
  24
  25
  26 #include "config.h"
  27
  28 #include <assert.h>
  29 #include <stdint.h>
  30 #include <unistd.h>
  31
  32 #include "vm/types.h"
  33
  34 #include "mm/memory.h"
  35
  36 #if defined(ENABLE_GC_BOEHM)
  37 /* We need to include Boehm's gc.h here for GC_register_my_thread and
  38    friends. */
  39 # include "mm/boehm-gc/include/gc.h"
  40 #endif
  41
  42 #include "native/llni.h"
  43 #include "native/native.h"
  44
  45 #include "threads/lock-common.h"
  46 #include "threads/threadlist.h"
  47 #include "threads/thread.hpp"
  48
  49 #include "vm/jit/builtin.hpp"
  50 #include "vm/class.h"
  51 #include "vm/exceptions.hpp"
  52 #include "vm/globals.hpp"
  53 #include "vm/javaobjects.hpp"
  54 #include "vm/method.h"
  55 #include "vm/options.h"
  56 #include "vm/string.hpp"
  57 #include "vm/utf8.h"
  58 #include "vm/vm.hpp"
  59
  60 #if defined(ENABLE_STATISTICS)
  61 # include "vm/statistics.h"
  62 #endif
  63
  64 #include "vm/jit/stacktrace.hpp"
  65
  66
  67 // FIXME
  68 extern "C" {
  69
  70 /* global variables ***********************************************************/
  71
  72 static methodinfo    *thread_method_init;
  73 static java_handle_t *threadgroup_system;
  74 static java_handle_t *threadgroup_main;
  75
  76 #if defined(__LINUX__)
  77 /* XXX Remove for exact-GC. */
  78 bool threads_pthreads_implementation_nptl;
  79 #endif
  80
  81
  82 /* static functions ***********************************************************/
  83
  84 static void          thread_create_initial_threadgroups(void);
  85 static void          thread_create_initial_thread(void);
  86 static threadobject *thread_new(void);
  87
  88
  89 /* threads_preinit *************************************************************
  90
  91    Do some early initialization of stuff required.
  92
  93 *******************************************************************************/
  94
  95 void threads_preinit(void)
  96 {
  97         threadobject *mainthread;
  98 #if defined(__LINUX__) && defined(_CS_GNU_LIBPTHREAD_VERSION)
  99         char         *pathbuf;
 100         size_t        len;
 101 #endif
 102
 103         TRACESUBSYSTEMINITIALIZATION("threads_preinit");
 104
 105 #if defined(__LINUX__)
 106         /* XXX Remove for exact-GC. */
 107
 108         /* On Linux we need to check the pthread implementation. */
 109
 110         /* _CS_GNU_LIBPTHREAD_VERSION (GNU C library only; since glibc 2.3.2) */
 111         /* If the glibc is a pre-2.3.2 version, we fall back to
 112            linuxthreads. */
 113
 114 # if defined(_CS_GNU_LIBPTHREAD_VERSION)
 115         len = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, (size_t) 0);
 116
 117         /* Some systems return as length 0 (maybe cross-compilation
 118            related).  In this case we also fall back to linuxthreads. */
 119
 120         if (len > 0) {
 121                 pathbuf = MNEW(char, len);
 122
 123                 (void) confstr(_CS_GNU_LIBPTHREAD_VERSION, pathbuf, len);
 124
 125                 if (strstr(pathbuf, "NPTL") != NULL)
 126                         threads_pthreads_implementation_nptl = true;
 127                 else
 128                         threads_pthreads_implementation_nptl = false;
 129         }
 130         else
 131                 threads_pthreads_implementation_nptl = false;
 132 # else
 133         threads_pthreads_implementation_nptl = false;
 134 # endif
 135 #endif
 136
 137         /* Initialize the threads implementation (sets the thinlock on the
 138            main thread). */
 139
 140         threads_impl_preinit();
 141
 142         /* Create internal thread data-structure for the main thread. */
 143
 144         mainthread = thread_new();
 145
 146         /* The main thread should always have index 1. */
 147
 148         if (mainthread->index != 1)
 149                 vm_abort("threads_preinit: main thread index not 1: %d != 1",
 150                                  mainthread->index);
 151
 152         /* thread is a Java thread and running */
 153
 154         mainthread->flags |= THREAD_FLAG_JAVA;
 155         mainthread->state = THREAD_STATE_RUNNABLE;
 156
 157         /* Store the internal thread data-structure in the TSD. */
 158
 159         thread_set_current(mainthread);
 160 }
 161
 162
 163 /* threads_init ****************************************************************
 164
 165    Initialize the main thread.
 166
 167 *******************************************************************************/
 168
 169 void threads_init(void)
 170 {
 171         TRACESUBSYSTEMINITIALIZATION("threads_init");
 172
 173         /* Create the system and main thread groups. */
 174
 175         thread_create_initial_threadgroups();
 176
 177         /* Cache the java.lang.Thread initialization method. */
 178
 179 #if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
 180
 181         thread_method_init =
 182                 class_resolveclassmethod(class_java_lang_Thread,
 183                                                                  utf_init,
 184                                                                  utf_new_char("(Ljava/lang/VMThread;Ljava/lang/String;IZ)V"),
 185                                                                  class_java_lang_Thread,
 186                                                                  true);
 187
 188 #elif defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
 189
 190         thread_method_init =
 191                 class_resolveclassmethod(class_java_lang_Thread,
 192                                                                  utf_init,
 193                                                                  utf_new_char("(Ljava/lang/ThreadGroup;Ljava/lang/String;)V"),
 194                                                                  class_java_lang_Thread,
 195                                                                  true);
 196
 197 #elif defined(WITH_JAVA_RUNTIME_LIBRARY_CLDC1_1)
 198
 199         thread_method_init =
 200                 class_resolveclassmethod(class_java_lang_Thread,
 201                                                                  utf_init,
 202                                                                  utf_java_lang_String__void,
 203                                                                  class_java_lang_Thread,
 204                                                                  true);
 205
 206 #else
 207 # error unknown classpath configuration
 208 #endif
 209
 210         if (thread_method_init == NULL)
 211                 vm_abort("threads_init: failed to resolve thread init method");
 212
 213         thread_create_initial_thread();
 214 }
 215
 216
 217 /* thread_create_object ********************************************************
 218
 219    Create a Java thread object for the given thread data-structure,
 220    initializes it and adds the thread to the threadgroup.
 221
 222    ARGUMENTS:
 223
 224        t ....... thread
 225        name .... thread name
 226        group ... threadgroup
 227
 228    RETURN:
 229
 230 *******************************************************************************/
 231
 232 static bool thread_create_object(threadobject *t, java_handle_t *name, java_handle_t *group)
 233 {
 234         /* Create a java.lang.Thread Java object. */
 235
 236         java_handle_t* h = builtin_new(class_java_lang_Thread);
 237
 238         if (h == NULL)
 239                 return false;
 240
 241         java_lang_Thread jlt(h);
 242
 243         // Set the Java object in the thread data-structure.  This
 244         // indicates that the thread is attached to the VM.
 245         thread_set_object(t, jlt.get_handle());
 246
 247 #if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
 248
 249         h = builtin_new(class_java_lang_VMThread);
 250
 251         if (h == NULL)
 252                 return false;
 253
 254         // Create and initialize a java.lang.VMThread object.
 255         java_lang_VMThread jlvmt(h, jlt.get_handle(), t);
 256
 257         /* Call:
 258            java.lang.Thread.<init>(Ljava/lang/VMThread;Ljava/lang/String;IZ)V */
 259
 260         bool isdaemon = thread_is_daemon(t);
 261
 262         (void) vm_call_method(thread_method_init, jlt.get_handle(), jlvmt.get_handle(),
 263                                                   name, NORM_PRIORITY, isdaemon);
 264
 265         if (exceptions_get_exception())
 266                 return false;
 267
 268         // Set the ThreadGroup in the Java thread object.
 269         jlt.set_group(group);
 270
 271         /* Add thread to the threadgroup. */
 272
 273         classinfo* c;
 274         LLNI_class_get(group, c);
 275
 276         methodinfo* m = class_resolveclassmethod(c,
 277                                                                                          utf_addThread,
 278                                                                                          utf_java_lang_Thread__V,
 279                                                                                          class_java_lang_ThreadGroup,
 280                                                                                          true);
 281
 282         if (m == NULL)
 283                 return false;
 284
 285         (void) vm_call_method(m, group, jlt.get_handle());
 286
 287         if (exceptions_get_exception())
 288                 return false;
 289
 290 #elif defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
 291
 292         /* Set the priority.  java.lang.Thread.<init> requires it because
 293            it sets the priority of the current thread to the parent's one
 294            (which is the current thread in this case). */
 295         jlt.set_priority(NORM_PRIORITY);
 296
 297         // Call: java.lang.Thread.<init>(Ljava/lang/ThreadGroup;Ljava/lang/String;)V
 298
 299         (void) vm_call_method(thread_method_init, jlt.get_handle(), group, name);
 300
 301         if (exceptions_get_exception())
 302                 return false;
 303
 304 #elif defined(WITH_JAVA_RUNTIME_LIBRARY_CLDC1_1)
 305
 306         // Set the thread data-structure in the Java thread object.
 307         jlt.set_vm_thread(t);
 308
 309         // Call: public Thread(Ljava/lang/String;)V
 310         (void) vm_call_method(thread_method_init, jlt.get_handle(), name);
 311
 312         if (exceptions_get_exception())
 313                 return false;
 314
 315 #else
 316 # error unknown classpath configuration
 317 #endif
 318
 319         return true;
 320 }
 321
 322
 323 /* thread_create_initial_threadgroups ******************************************
 324
 325    Create the initial threadgroups.
 326
 327    GNU Classpath:
 328        Create the main threadgroup only and set the system
 329        threadgroup to the main threadgroup.
 330
 331    SUN:
 332        Create the system and main threadgroup.
 333
 334    CLDC:
 335        This function is a no-op.
 336
 337 *******************************************************************************/
 338
 339 static void thread_create_initial_threadgroups(void)
 340 {
 341 #if defined(ENABLE_JAVASE)
 342 # if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
 343
 344         /* Allocate and initialize the main thread group. */
 345
 346         threadgroup_main = native_new_and_init(class_java_lang_ThreadGroup);
 347
 348         if (threadgroup_main == NULL)
 349                 vm_abort("thread_create_initial_threadgroups: failed to allocate main threadgroup");
 350
 351         /* Use the same threadgroup for system as for main. */
 352
 353         threadgroup_system = threadgroup_main;
 354
 355 # elif defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
 356
 357         java_handle_t *name;
 358         methodinfo    *m;
 359
 360         /* Allocate and initialize the system thread group. */
 361
 362         threadgroup_system = native_new_and_init(class_java_lang_ThreadGroup);
 363
 364         if (threadgroup_system == NULL)
 365                 vm_abort("thread_create_initial_threadgroups: failed to allocate system threadgroup");
 366
 367         /* Allocate and initialize the main thread group. */
 368
 369         threadgroup_main = builtin_new(class_java_lang_ThreadGroup);
 370
 371         if (threadgroup_main == NULL)
 372                 vm_abort("thread_create_initial_threadgroups: failed to allocate main threadgroup");
 373
 374         name = javastring_new(utf_main);
 375
 376         m = class_resolveclassmethod(class_java_lang_ThreadGroup,
 377                                                                  utf_init,
 378                                                                  utf_Ljava_lang_ThreadGroup_Ljava_lang_String__V,
 379                                                                  class_java_lang_ThreadGroup,
 380                                                                  true);
 381
 382         if (m == NULL)
 383                 vm_abort("thread_create_initial_threadgroups: failed to resolve threadgroup init method");
 384
 385         (void) vm_call_method(m, threadgroup_main, threadgroup_system, name);
 386
 387         if (exceptions_get_exception())
 388                 vm_abort("thread_create_initial_threadgroups: exception while initializing main threadgroup");
 389
 390 # else
 391 #  error unknown classpath configuration
 392 # endif
 393 #endif
 394 }
 395
 396
 397 /* thread_create_initial_thread ***********************************************
 398
 399    Create the initial thread: main
 400
 401 *******************************************************************************/
 402
 403 static void thread_create_initial_thread(void)
 404 {
 405         threadobject  *t;
 406         java_handle_t *name;
 407
 408         /* Get the main-thread (NOTE: The main thread is always the first
 409            thread in the list). */
 410
 411         t = threadlist_first();
 412
 413         /* The thread name. */
 414
 415         name = javastring_new(utf_main);
 416
 417 #if defined(ENABLE_INTRP)
 418         /* create interpreter stack */
 419
 420         if (opt_intrp) {
 421                 MSET(intrp_main_stack, 0, u1, opt_stacksize);
 422                 mainthread->_global_sp = (Cell*) (intrp_main_stack + opt_stacksize);
 423         }
 424 #endif
 425
 426         /* Create the Java thread object. */
 427
 428         if (!thread_create_object(t, name, threadgroup_main))
 429                 vm_abort("thread_create_initial_thread: failed to create Java object");
 430
 431         /* Initialize the implementation specific bits. */
 432
 433         threads_impl_init();
 434
 435         DEBUGTHREADS("starting (main)", t);
 436 }
 437
 438
 439 /* thread_new ******************************************************************
 440
 441    Allocates and initializes an internal thread data-structure and
 442    adds it to the threads list.
 443
 444 *******************************************************************************/
 445
 446 static threadobject *thread_new(void)
 447 {
 448         int32_t       index;
 449         threadobject *t;
 450
 451         /* Lock the thread lists */
 452
 453         threadlist_lock();
 454
 455         index = threadlist_get_free_index();
 456
 457         /* Allocate a thread data structure. */
 458
 459         /* First, try to get one from the free-list. */
 460
 461         t = threadlist_free_first();
 462
 463         if (t != NULL) {
 464                 /* Remove from free list. */
 465
 466                 threadlist_free_remove(t);
 467
 468                 /* Equivalent of MZERO on the else path */
 469
 470                 threads_impl_thread_clear(t);
 471         }
 472         else {
 473 #if defined(ENABLE_GC_BOEHM)
 474                 t = GCNEW_UNCOLLECTABLE(threadobject, 1);
 475 #else
 476                 t = NEW(threadobject);
 477 #endif
 478
 479 #if defined(ENABLE_STATISTICS)
 480                 if (opt_stat)
 481                         size_threadobject += sizeof(threadobject);
 482 #endif
 483
 484                 /* Clear memory. */
 485
 486                 MZERO(t, threadobject, 1);
 487
 488                 // Initialize the mutex and the condition.
 489                 t->flc_lock = new Mutex();
 490                 t->flc_cond = new Condition();
 491
 492                 t->waitmutex = new Mutex();
 493                 t->waitcond = new Condition();
 494
 495                 t->suspendmutex = new Mutex();
 496                 t->suspendcond = new Condition();
 497
 498 #if defined(ENABLE_TLH)
 499                 tlh_init(&(t->tlh));
 500 #endif
 501
 502 #if defined(ENABLE_GC_CACAO)
 503                 /* Register reference to java.lang.Thread with the GC. */
 504                 /* FIXME is it ok to do this only once? */
 505
 506                 gc_reference_register(&(t->object), GC_REFTYPE_THREADOBJECT);
 507                 gc_reference_register(&(t->_exceptionptr), GC_REFTYPE_THREADOBJECT);
 508 #endif
 509         }
 510
 511         /* Pre-compute the thinlock-word. */
 512
 513         assert(index != 0);
 514
 515         t->index     = index;
 516         t->thinlock  = lock_pre_compute_thinlock(t->index);
 517         t->flags     = 0;
 518         t->state     = THREAD_STATE_NEW;
 519
 520 #if defined(ENABLE_GC_CACAO)
 521         t->flags    |= THREAD_FLAG_IN_NATIVE;
 522 #endif
 523
 524         /* Initialize the implementation-specific bits. */
 525
 526         threads_impl_thread_reuse(t);
 527
 528         /* Add the thread to the thread list. */
 529
 530         threadlist_add(t);
 531
 532         /* Unlock the thread lists. */
 533
 534         threadlist_unlock();
 535
 536         return t;
 537 }
 538
 539
 540 /* thread_free *****************************************************************
 541
 542    Remove the thread from the threads-list and free the internal
 543    thread data structure.  The thread index is added to the
 544    thread-index free-list.
 545
 546    IN:
 547        t ... thread data structure
 548
 549 *******************************************************************************/
 550
 551 void thread_free(threadobject *t)
 552 {
 553         /* Lock the thread lists. */
 554
 555         threadlist_lock();
 556
 557         /* Remove the thread from the thread-list. */
 558
 559         threadlist_remove(t);
 560
 561         /* Add the thread index to the free list. */
 562
 563         threadlist_index_add(t->index);
 564
 565         /* Set the reference to the Java object to NULL. */
 566
 567         thread_set_object(t, NULL);
 568
 569         /* Add the thread data structure to the free list. */
 570
 571         threadlist_free_add(t);
 572
 573         /* Unlock the thread lists. */
 574
 575         threadlist_unlock();
 576 }
 577
 578
 579 /* threads_thread_start_internal ***********************************************
 580
 581    Start an internal thread in the JVM.  No Java thread objects exists
 582    so far.
 583
 584    IN:
 585       name.......UTF-8 name of the thread
 586       f..........function pointer to C function to start
 587
 588 *******************************************************************************/
 589
 590 bool threads_thread_start_internal(utf *name, functionptr f)
 591 {
 592         threadobject *t;
 593
 594         /* Enter the join-mutex, so if the main-thread is currently
 595            waiting to join all threads, the number of non-daemon threads
 596            is correct. */
 597
 598         threads_mutex_join_lock();
 599
 600         /* Create internal thread data-structure. */
 601
 602         t = thread_new();
 603
 604         t->flags |= THREAD_FLAG_INTERNAL | THREAD_FLAG_DAEMON;
 605
 606         /* The thread is flagged as (non-)daemon thread, we can leave the
 607            mutex. */
 608
 609         threads_mutex_join_unlock();
 610
 611         /* Create the Java thread object. */
 612
 613         if (!thread_create_object(t, javastring_new(name), threadgroup_system))
 614                 return false;
 615
 616         /* Start the thread. */
 617
 618         threads_impl_thread_start(t, f);
 619
 620         /* everything's ok */
 621
 622         return true;
 623 }
 624
 625
 626 /* threads_thread_start ********************************************************
 627
 628    Start a Java thread in the JVM.  Only the java thread object exists
 629    so far.
 630
 631    IN:
 632       object.....the java thread object java.lang.Thread
 633
 634 *******************************************************************************/
 635
 636 void threads_thread_start(java_handle_t *object)
 637 {
 638         java_lang_Thread jlt(object);
 639
 640         /* Enter the join-mutex, so if the main-thread is currently
 641            waiting to join all threads, the number of non-daemon threads
 642            is correct. */
 643
 644         threads_mutex_join_lock();
 645
 646         /* Create internal thread data-structure. */
 647
 648         threadobject* t = thread_new();
 649
 650         /* this is a normal Java thread */
 651
 652         t->flags |= THREAD_FLAG_JAVA;
 653
 654 #if defined(ENABLE_JAVASE)
 655         /* Is this a daemon thread? */
 656
 657         if (jlt.get_daemon() == true)
 658                 t->flags |= THREAD_FLAG_DAEMON;
 659 #endif
 660
 661         /* The thread is flagged and (non-)daemon thread, we can leave the
 662            mutex. */
 663
 664         threads_mutex_join_unlock();
 665
 666         /* Link the two objects together. */
 667
 668         thread_set_object(t, object);
 669
 670 #if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
 671
 672         /* Get the java.lang.VMThread object and do some sanity checks. */
 673         java_lang_VMThread jlvmt(jlt.get_vmThread());
 674
 675         assert(jlvmt.get_handle() != NULL);
 676         assert(jlvmt.get_vmdata() == NULL);
 677
 678         jlvmt.set_vmdata(t);
 679
 680 #elif defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
 681
 682         // Nothing to do.
 683
 684 #elif defined(WITH_JAVA_RUNTIME_LIBRARY_CLDC1_1)
 685
 686         jlt.set_vm_thread(t);
 687
 688 #else
 689 # error unknown classpath configuration
 690 #endif
 691
 692         /* Start the thread.  Don't pass a function pointer (NULL) since
 693            we want Thread.run()V here. */
 694
 695         threads_impl_thread_start(t, NULL);
 696 }
 697
 698
 699 /**
 700  * Attaches the current thread to the VM.
 701  *
 702  * @param vm_aargs Attach arguments.
 703  * @param isdaemon true if the attached thread should be a daemon
 704  *                 thread.
 705  *
 706  * @return true on success, false otherwise.
 707  */
 708 bool thread_attach_current_thread(JavaVMAttachArgs *vm_aargs, bool isdaemon)
 709 {
 710         bool           result;
 711         threadobject  *t;
 712         utf           *u;
 713         java_handle_t *name;
 714         java_handle_t *group;
 715
 716     /* If the current thread has already been attached, this operation
 717            is a no-op. */
 718
 719         result = thread_current_is_attached();
 720
 721         if (result == true)
 722                 return true;
 723
 724         /* Enter the join-mutex, so if the main-thread is currently
 725            waiting to join all threads, the number of non-daemon threads
 726            is correct. */
 727
 728         threads_mutex_join_lock();
 729
 730         /* Create internal thread data structure. */
 731
 732         t = thread_new();
 733
 734         /* Thread is a Java thread and running. */
 735
 736         t->flags = THREAD_FLAG_JAVA;
 737
 738         if (isdaemon)
 739                 t->flags |= THREAD_FLAG_DAEMON;
 740
 741         /* Store the internal thread data-structure in the TSD. */
 742
 743         thread_set_current(t);
 744
 745         /* The thread is flagged and (non-)daemon thread, we can leave the
 746            mutex. */
 747
 748         threads_mutex_join_unlock();
 749
 750         DEBUGTHREADS("attaching", t);
 751
 752         /* Get the thread name. */
 753
 754         if (vm_aargs != NULL) {
 755                 u = utf_new_char(vm_aargs->name);
 756         }
 757         else {
 758                 u = utf_null;
 759         }
 760
 761         name = javastring_new(u);
 762
 763 #if defined(ENABLE_JAVASE)
 764         /* Get the threadgroup. */
 765
 766         if (vm_aargs != NULL)
 767                 group = (java_handle_t *) vm_aargs->group;
 768         else
 769                 group = NULL;
 770
 771         /* If no threadgroup was given, use the main threadgroup. */
 772
 773         if (group == NULL)
 774                 group = threadgroup_main;
 775 #endif
 776
 777 #if defined(ENABLE_INTRP)
 778         /* create interpreter stack */
 779
 780         if (opt_intrp) {
 781                 MSET(intrp_main_stack, 0, u1, opt_stacksize);
 782                 thread->_global_sp = (Cell *) (intrp_main_stack + opt_stacksize);
 783         }
 784 #endif
 785
 786         /* Create the Java thread object. */
 787
 788         if (!thread_create_object(t, name, group))
 789                 return false;
 790
 791         /* The thread is completely initialized. */
 792
 793         thread_set_state_runnable(t);
 794
 795         return true;
 796 }
 797
 798
 799 /**
 800  * Attaches the current external thread to the VM.  This function is
 801  * called by JNI's AttachCurrentThread.
 802  *
 803  * @param vm_aargs Attach arguments.
 804  * @param isdaemon true if the attached thread should be a daemon
 805  *                 thread.
 806  *
 807  * @return true on success, false otherwise.
 808  */
 809 bool thread_attach_current_external_thread(JavaVMAttachArgs *vm_aargs, bool isdaemon)
 810 {
 811         int result;
 812
 813 #if defined(ENABLE_GC_BOEHM)
 814         struct GC_stack_base sb;
 815 #endif
 816
 817 #if defined(ENABLE_GC_BOEHM)
 818         /* Register the thread with Boehm-GC.  This must happen before the
 819            thread allocates any memory from the GC heap.*/
 820
 821         result = GC_get_stack_base(&sb);
 822
 823         if (result != GC_SUCCESS)
 824                 vm_abort("threads_attach_current_thread: GC_get_stack_base failed");
 825
 826         GC_register_my_thread(&sb);
 827 #endif
 828
 829         result = thread_attach_current_thread(vm_aargs, isdaemon);
 830
 831         if (result == false) {
 832 #if defined(ENABLE_GC_BOEHM)
 833                 /* Unregister the thread. */
 834
 835                 GC_unregister_my_thread();
 836 #endif
 837
 838                 return false;
 839         }
 840
 841         return true;
 842 }
 843
 844
 845 /**
 846  * Detaches the current external thread from the VM.  This function is
 847  * called by JNI's DetachCurrentThread.
 848  *
 849  * @return true on success, false otherwise.
 850  */
 851 bool thread_detach_current_external_thread(void)
 852 {
 853         int result;
 854
 855         result = thread_detach_current_thread();
 856
 857         if (result == false)
 858                 return false;
 859
 860 #if defined(ENABLE_GC_BOEHM)
 861         /* Unregister the thread with Boehm-GC.  This must happen after
 862            the thread allocates any memory from the GC heap. */
 863
 864         /* Don't detach the main thread.  This is a workaround for
 865            OpenJDK's java binary. */
 866         if (thread_get_current()->index != 1)
 867                 GC_unregister_my_thread();
 868 #endif
 869
 870         return true;
 871 }
 872
 873
 874 /* thread_fprint_name **********************************************************
 875
 876    Print the name of the given thread to the given stream.
 877
 878    ARGUMENTS:
 879        t ........ thread data-structure
 880        stream ... stream to print to
 881
 882 *******************************************************************************/
 883
 884 void thread_fprint_name(threadobject *t, FILE *stream)
 885 {
 886         if (thread_get_object(t) == NULL)
 887                 vm_abort("");
 888
 889         java_lang_Thread jlt(thread_get_object(t));
 890
 891 #if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
 892
 893         java_handle_t* name = jlt.get_name();
 894         javastring_fprint(name, stream);
 895
 896 #elif defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK) || defined(WITH_JAVA_RUNTIME_LIBRARY_CLDC1_1)
 897
 898         /* FIXME: In OpenJDK and CLDC the name is a char[]. */
 899         java_chararray_t *name;
 900
 901         /* FIXME This prints to stdout. */
 902         utf_display_printable_ascii(utf_null);
 903
 904 #else
 905 # error unknown classpath configuration
 906 #endif
 907 }
 908
 909
 910 /* thread_print_info ***********************************************************
 911
 912    Print information of the passed thread.
 913
 914    ARGUMENTS:
 915        t ... thread data-structure.
 916
 917 *******************************************************************************/
 918
 919 void thread_print_info(threadobject *t)
 920 {
 921         java_lang_Thread jlt(thread_get_object(t));
 922
 923         /* Print as much as we can when we are in state NEW. */
 924
 925         if (jlt.get_handle() != NULL) {
 926                 /* Print thread name. */
 927
 928                 printf("\"");
 929                 thread_fprint_name(t, stdout);
 930                 printf("\"");
 931         }
 932         else {
 933         }
 934
 935         if (thread_is_daemon(t))
 936                 printf(" daemon");
 937
 938         if (jlt.get_handle() != NULL) {
 939                 printf(" prio=%d", jlt.get_priority());
 940         }
 941
 942 #if SIZEOF_VOID_P == 8
 943         printf(" t=0x%016lx tid=0x%016lx (%ld)",
 944                    (ptrint) t, (ptrint) t->tid, (ptrint) t->tid);
 945 #else
 946         printf(" t=0x%08x tid=0x%08x (%d)",
 947                    (ptrint) t, (ptrint) t->tid, (ptrint) t->tid);
 948 #endif
 949
 950         printf(" index=%d", t->index);
 951
 952         /* Print thread state. */
 953
 954         int state = cacaothread_get_state(t);
 955
 956         switch (state) {
 957         case THREAD_STATE_NEW:
 958                 printf(" new");
 959                 break;
 960         case THREAD_STATE_RUNNABLE:
 961                 printf(" runnable");
 962                 break;
 963         case THREAD_STATE_BLOCKED:
 964                 printf(" blocked");
 965                 break;
 966         case THREAD_STATE_WAITING:
 967                 printf(" waiting");
 968                 break;
 969         case THREAD_STATE_TIMED_WAITING:
 970                 printf(" waiting on condition");
 971                 break;
 972         case THREAD_STATE_TERMINATED:
 973                 printf(" terminated");
 974                 break;
 975         default:
 976                 vm_abort("thread_print_info: unknown thread state %d", state);
 977         }
 978 }
 979
 980
 981 /* threads_get_current_tid *****************************************************
 982
 983    Return the tid of the current thread.
 984
 985    RETURN VALUE:
 986        the current tid
 987
 988 *******************************************************************************/
 989
 990 intptr_t threads_get_current_tid(void)
 991 {
 992         threadobject *thread;
 993
 994         thread = THREADOBJECT;
 995
 996         /* this may happen during bootstrap */
 997
 998         if (thread == NULL)
 999                 return 0;
1000
1001         return (intptr_t) thread->tid;
1002 }
1003
1004
1005 /* thread_set_state_runnable ***************************************************
1006
1007    Set the current state of the given thread to THREAD_STATE_RUNNABLE.
1008
1009    NOTE: If the thread has already terminated, don't set the state.
1010          This is important for threads_detach_thread.
1011
1012 *******************************************************************************/
1013
1014 void thread_set_state_runnable(threadobject *t)
1015 {
1016         /* Set the state inside a lock. */
1017
1018         threadlist_lock();
1019
1020         if (t->state != THREAD_STATE_TERMINATED) {
1021                 t->state = THREAD_STATE_RUNNABLE;
1022
1023                 DEBUGTHREADS("is RUNNABLE", t);
1024         }
1025
1026         threadlist_unlock();
1027 }
1028
1029
1030 /* thread_set_state_waiting ****************************************************
1031
1032    Set the current state of the given thread to THREAD_STATE_WAITING.
1033
1034    NOTE: If the thread has already terminated, don't set the state.
1035          This is important for threads_detach_thread.
1036
1037 *******************************************************************************/
1038
1039 void thread_set_state_waiting(threadobject *t)
1040 {
1041         /* Set the state inside a lock. */
1042
1043         threadlist_lock();
1044
1045         if (t->state != THREAD_STATE_TERMINATED) {
1046                 t->state = THREAD_STATE_WAITING;
1047
1048                 DEBUGTHREADS("is WAITING", t);
1049         }
1050
1051         threadlist_unlock();
1052 }
1053
1054
1055 /* thread_set_state_timed_waiting **********************************************
1056
1057    Set the current state of the given thread to
1058    THREAD_STATE_TIMED_WAITING.
1059
1060    NOTE: If the thread has already terminated, don't set the state.
1061          This is important for threads_detach_thread.
1062
1063 *******************************************************************************/
1064
1065 void thread_set_state_timed_waiting(threadobject *t)
1066 {
1067         /* Set the state inside a lock. */
1068
1069         threadlist_lock();
1070
1071         if (t->state != THREAD_STATE_TERMINATED) {
1072                 t->state = THREAD_STATE_TIMED_WAITING;
1073
1074                 DEBUGTHREADS("is TIMED_WAITING", t);
1075         }
1076
1077         threadlist_unlock();
1078 }
1079
1080
1081 /* thread_set_state_terminated *************************************************
1082
1083    Set the current state of the given thread to
1084    THREAD_STATE_TERMINATED.
1085
1086 *******************************************************************************/
1087
1088 void thread_set_state_terminated(threadobject *t)
1089 {
1090         /* Set the state inside a lock. */
1091
1092         threadlist_lock();
1093
1094         t->state = THREAD_STATE_TERMINATED;
1095
1096         DEBUGTHREADS("is TERMINATED", t);
1097
1098         threadlist_unlock();
1099 }
1100
1101
1102 /* thread_get_thread **********************************************************
1103
1104    Return the thread data structure of the given Java thread object.
1105
1106    ARGUMENTS:
1107        h ... java.lang.{VM}Thread object
1108
1109    RETURN VALUE:
1110        the thread object
1111
1112 *******************************************************************************/
1113
1114 threadobject *thread_get_thread(java_handle_t *h)
1115 {
1116 #if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
1117
1118         java_lang_VMThread jlvmt(h);
1119         threadobject* t = jlvmt.get_vmdata();
1120
1121 #elif defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
1122
1123         /* XXX This is just a quick hack. */
1124         threadobject* t;
1125         bool          equal;
1126
1127         threadlist_lock();
1128
1129         for (t = threadlist_first(); t != NULL; t = threadlist_next(t)) {
1130                 LLNI_equals(t->object, h, equal);
1131
1132                 if (equal == true)
1133                         break;
1134         }
1135
1136         threadlist_unlock();
1137
1138 #elif defined(WITH_JAVA_RUNTIME_LIBRARY_CLDC1_1)
1139
1140         log_println("threads_get_thread: IMPLEMENT ME!");
1141         threadobject* t = NULL;
1142
1143 #else
1144 # error unknown classpath configuration
1145 #endif
1146
1147         return t;
1148 }
1149
1150
1151 /* threads_thread_is_alive *****************************************************
1152
1153    Returns if the give thread is alive.
1154
1155 *******************************************************************************/
1156
1157 bool threads_thread_is_alive(threadobject *t)
1158 {
1159         int state;
1160
1161         state = cacaothread_get_state(t);
1162
1163         switch (state) {
1164         case THREAD_STATE_NEW:
1165         case THREAD_STATE_TERMINATED:
1166                 return false;
1167
1168         case THREAD_STATE_RUNNABLE:
1169         case THREAD_STATE_BLOCKED:
1170         case THREAD_STATE_WAITING:
1171         case THREAD_STATE_TIMED_WAITING:
1172                 return true;
1173
1174         default:
1175                 vm_abort("threads_thread_is_alive: unknown thread state %d", state);
1176         }
1177
1178         /* keep compiler happy */
1179
1180         return false;
1181 }
1182
1183
1184 /* threads_dump ****************************************************************
1185
1186    Dumps info for all threads running in the JVM.  This function is
1187    called when SIGQUIT (<ctrl>-\) is sent to CACAO.
1188
1189 *******************************************************************************/
1190
1191 void threads_dump(void)
1192 {
1193         threadobject *t;
1194
1195         /* XXX we should stop the world here */
1196
1197         /* Lock the thread lists. */
1198
1199         threadlist_lock();
1200
1201         printf("Full thread dump CACAO "VERSION":\n");
1202
1203         /* iterate over all started threads */
1204
1205         for (t = threadlist_first(); t != NULL; t = threadlist_next(t)) {
1206                 /* ignore threads which are in state NEW */
1207                 if (t->state == THREAD_STATE_NEW)
1208                         continue;
1209
1210 #if defined(ENABLE_GC_CACAO)
1211                 /* Suspend the thread. */
1212                 /* XXX Is the suspend reason correct? */
1213
1214                 if (threads_suspend_thread(t, SUSPEND_REASON_JNI) == false)
1215                         vm_abort("threads_dump: threads_suspend_thread failed");
1216 #endif
1217
1218                 /* Print thread info. */
1219
1220                 printf("\n");
1221                 thread_print_info(t);
1222                 printf("\n");
1223
1224                 /* Print trace of thread. */
1225
1226                 stacktrace_print_of_thread(t);
1227
1228 #if defined(ENABLE_GC_CACAO)
1229                 /* Resume the thread. */
1230
1231                 if (threads_resume_thread(t) == false)
1232                         vm_abort("threads_dump: threads_resume_thread failed");
1233 #endif
1234         }
1235
1236         /* Unlock the thread lists. */
1237
1238         threadlist_unlock();
1239 }
1240
1241 } // extern "C"
1242
1243
1244 /*
1245  * These are local overrides for various environment variables in Emacs.
1246  * Please do not remove this and leave it at the end of the file, where
1247  * Emacs will automagically detect them.
1248  * ---------------------------------------------------------------------
1249  * Local variables:
1250  * mode: c++
1251  * indent-tabs-mode: t
1252  * c-basic-offset: 4
1253  * tab-width: 4
1254  * End:
1255  * vim:noexpandtab:sw=4:ts=4:
1256  */