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