9  * This code is distributed in the hope that it will be useful, but WITHOUT
12  * version 2 for more details (a copy is included in the LICENSE file that
146   recommended that MPSS be used for Solaris 9 and above.
182 // Some more macros from sys/mman.h that are not present in Solaris 8.
407 // Version of setup_interruptible() for threads that are already in
559 // We also need to take care that the loop (below) terminates as the
561 // request and the loop that builds the list of processor ids.   Unfortunately
565 // not too sparse".  MAX_PROCESSOR_ID is used to ensure that we eventually
568 // In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's
597       // we've got.  Note that in the worst case find_processors_online() could
641   //                It would be nice to have an API that let us ask
643   //                but we don't have that, either.
644   //                In the short term, "board" is static so that
704   // We assume that a processorid_t can be stored in a uint.
889       // Construct the invariant part of ld_library_path. Note that the
917       // For compatibility, it is optimal that we insert the additional path
954      * Note that the space for the colon and the trailing null are provided
1041   // we need to call set_native_priority now that we have an lwp.
1265   // that assumption is not accurate, but our alternate signal stack
1287   // The following code is palliative -- it attempts to ensure that our
1290   // (THR_BOUND) or using LWP-based synchronization.  Note that there is a
1295   // THR_NEW_LWP here, but I'd recommend against it as that could
1329   // Mark that we don't have an lwp or thread id yet.
1350   // Remember that we created this thread so we can set priority on it
1393 // Note: SIGRTMIN is a macro that calls sysconf() so it will
1402   // Fill in signals that are necessarily unblocked for all threads in
1409   // Programs embedding the VM that want to use the above signals for their
1450   // Fill in signals that are blocked by all but the VM thread.
1460 // These are signals that are unblocked while a thread is running Java.
1467 // These are the signals that are blocked while a (non-VM) thread is
1474 // These are signals that are blocked during cond_wait to allow debugger in
1627   //           assuming that the current thread already has a value bound to k.
1630   //           interface.  I think, however, that it will be faster to
1631   //           maintain the invariant that %g2 always contains the
1972       // available even if the vm is built on a machine that does
2157     #error Method os::dll_load requires that one of following is defined:\
2317 // but they're the same for all the solaris architectures that we support.
2771         // while suspended because that would surprise the thread that
2961 // Tell the OS that this range would be accessed from different LWPs.
2975 // Get a list of leaf locality groups. A leaf lgroup is group that
3179 // Reserve memory at an arbitrary address, only if that area is
3194   // Assert only that the size is a multiple of the page size, since
3195   // that's all that mmap requires, and since that's all we really know
3240       // check that the gap value is right
3266       // This could be fixed with a new algorithm that used larger
3269       // It's rare enough that the planets align for this bug,
3494   // Signal to OS that we want large pages for addresses
3627     // using the logic below checks that we really did
3659   // On Solaris machines (especially 2.5.1) we found that sometimes the VM gets into a live lock
3662   // thread. We suspect that because the Watcher thread keeps waking up at periodic intervals the kernel
3663   // is fooled into believing that the system is making progress. In the code below we block the
3664   // the watcher thread while safepoint is in progress so that it would not appear as though the
3694       // I'm preserving that decision for now.
3756 // Note that yield semantics are defined by the scheduling class to which
3758 // other equal or higher priority threads that reside on the dispatch queues
3764 // On Solaris we found that yield_all doesn't always yield to all other threads.
3771 // so that the starving thread would get an lwp
3828 // +    We assume that all threads in the process belong to the same
3832 //              we read-back the value and notice that it hasn't changed.
3863 // of Solaris. We need to call through this wrapper so that we can
3928   // the system.  We should have a loop that iterates over the
4272     // Use thr_setprio only if we have a priority that thr_setprio understands
4312 // Hint to the underlying OS that a task switch would not be good.
4425   // NOTE that since there is no "lock" around these two operations,
4426   // there is the possibility that the interrupted flag will be
4427   // "false" but that the interrupt event will be set. This is
4428   // intentional. The effect of this is that Object.wait() will appear
4430   // possibility is so rare that it is not worth the added complexity
4500         // make sure that we consume the signal on the semaphore as well
4573 // A lightweight implementation that does not suspend the target thread and
4576   // Make sure that it is called by the watcher and the Threads lock is owned.
4603 // or breakpoint) that the VM was generating for its own correct operation.
4613 // field of the structure passed to sigaction().  This routine assumes that
4616 // Note that the VM will print warnings if it detects conflicting signal
4968   // Log that signal checking is off only if -verbose:jni is specified.
5063 // bit set, we must assume that we are NOT using T2.  The T2 team
5075   lwpstatus_t * that;
5099         that = LWPINDEX(lwpArray,i);
5100         if (that->pr_flags & PR_ASLWP) {
5132     // Guarantee that this VM is running on an new enough OS (5.6 or
5133     // later) that it will have a new enough libthread.so.
5328   // (Solaris only) this switches to calls that actually do locking.
5423   // Make the stack size a multiple of the page size so that
5517     // call DestroyJavaVM() to assure that VM resources are released.
5558     //search  for the named symbol in the objects that were loaded after libjvm
5563       //search  for the named symbol in the objects that were loaded before libjvm
5639      *   descriptors that is too low for many Java programs.
5653      * - As of Solaris 10u4, we can request that Solaris raise the 256
5679      * All file descriptors that are opened in the JVM and not
6184 // Another alternative that works quite well is pipes:
6203 // then we know that a concurrent unpark() operation is in-progress.
6204 // in that case the park() code could simply set _count to 0
6264        // It appears that when we go directly through Solaris _lwp_cond_timedwait()
6389   // that it will take two back-to-back park() calls for the owning
6421  * on the condvar. Contention seen when trying to park implies that someone
6438  * prior to 10 there is a restriction (see cond_timedwait) that the specified
6566   // Note that an untimed cond_wait() can sometimes return ETIME on older
6661        // because that is what all Unix shells do, and because

Indexes created Tue Jul 24 14:28:13 CEST 2018