36 friend class os;
37
38 protected:
39 static void print_distro_info(outputStream* st);
40 static void print_rlimit_info(outputStream* st);
41 static void print_uname_info(outputStream* st);
42 static void print_libversion_info(outputStream* st);
43 static void print_load_average(outputStream* st);
44
45 // Minimum stack size a thread can be created with (allowing
46 // the VM to completely create the thread and enter user code).
47 // The initial values exclude any guard pages (by HotSpot or libc).
48 // set_minimum_stack_sizes() will add the size required for
49 // HotSpot guard pages depending on page size and flag settings.
50 // Libc guard pages are never considered by these values.
51 static size_t _compiler_thread_min_stack_allowed;
52 static size_t _java_thread_min_stack_allowed;
53 static size_t _vm_internal_thread_min_stack_allowed;
54
55 public:
56 // Return default stack size for the specified thread type
57 static size_t default_stack_size(os::ThreadType thr_type);
58 // Check and sets minimum stack sizes
59 static jint set_minimum_stack_sizes();
60 static size_t get_initial_stack_size(ThreadType thr_type, size_t req_stack_size);
61
62 // Returns true if signal is valid.
63 static bool is_valid_signal(int sig);
64
65 // Helper function, returns a string (e.g. "SIGILL") for a signal.
66 // Returned string is a constant. For unknown signals "UNKNOWN" is returned.
67 static const char* get_signal_name(int sig, char* out, size_t outlen);
68
69 // Helper function, returns a signal number for a given signal name, e.g. 11
70 // for "SIGSEGV". Name can be given with or without "SIG" prefix, so both
71 // "SEGV" or "SIGSEGV" work. Name must be uppercase.
72 // Returns -1 for an unknown signal name.
73 static int get_signal_number(const char* signal_name);
74
75 // Returns one-line short description of a signal set in a user provided buffer.
85 // into a user provided buffer. Returns that buffer.
86 static const char* describe_sa_flags(int flags, char* buffer, size_t size);
87
88 // Prints a one-line description of a combination of sigaction.sa_flags.
89 static void print_sa_flags(outputStream* st, int flags);
90
91 static address ucontext_get_pc(const ucontext_t* ctx);
92 // Set PC into context. Needed for continuation after signal.
93 static void ucontext_set_pc(ucontext_t* ctx, address pc);
94
95 // Helper function; describes pthread attributes as short string. String is written
96 // to buf with len buflen; buf is returned.
97 static char* describe_pthread_attr(char* buf, size_t buflen, const pthread_attr_t* attr);
98
99 // A safe implementation of realpath which will not cause a buffer overflow if the resolved path
100 // is longer than PATH_MAX.
101 // On success, returns 'outbuf', which now contains the path.
102 // On error, it will return NULL and set errno. The content of 'outbuf' is undefined.
103 // On truncation error ('outbuf' too small), it will return NULL and set errno to ENAMETOOLONG.
104 static char* realpath(const char* filename, char* outbuf, size_t outbuflen);
105
106 };
107
108 /*
109 * Crash protection for the watcher thread. Wrap the callback
110 * with a sigsetjmp and in case of a SIGSEGV/SIGBUS we siglongjmp
111 * back.
112 * To be able to use this - don't take locks, don't rely on destructors,
113 * don't make OS library calls, don't allocate memory, don't print,
114 * don't call code that could leave the heap / memory in an inconsistent state,
115 * or anything else where we are not in control if we suddenly jump out.
116 */
117 class WatcherThreadCrashProtection : public StackObj {
118 public:
119 WatcherThreadCrashProtection();
120 bool call(os::CrashProtectionCallback& cb);
121
122 static void check_crash_protection(int signal, Thread* thread);
123 private:
124 void restore();
125 sigjmp_buf _jmpbuf;
126 };
127
128 #endif // OS_POSIX_VM_OS_POSIX_HPP
|
36 friend class os;
37
38 protected:
39 static void print_distro_info(outputStream* st);
40 static void print_rlimit_info(outputStream* st);
41 static void print_uname_info(outputStream* st);
42 static void print_libversion_info(outputStream* st);
43 static void print_load_average(outputStream* st);
44
45 // Minimum stack size a thread can be created with (allowing
46 // the VM to completely create the thread and enter user code).
47 // The initial values exclude any guard pages (by HotSpot or libc).
48 // set_minimum_stack_sizes() will add the size required for
49 // HotSpot guard pages depending on page size and flag settings.
50 // Libc guard pages are never considered by these values.
51 static size_t _compiler_thread_min_stack_allowed;
52 static size_t _java_thread_min_stack_allowed;
53 static size_t _vm_internal_thread_min_stack_allowed;
54
55 public:
56 static void init(void); // early initialization - no logging available
57 static void init_2(void);// later initialization - logging available
58
59 // Return default stack size for the specified thread type
60 static size_t default_stack_size(os::ThreadType thr_type);
61 // Check and sets minimum stack sizes
62 static jint set_minimum_stack_sizes();
63 static size_t get_initial_stack_size(ThreadType thr_type, size_t req_stack_size);
64
65 // Returns true if signal is valid.
66 static bool is_valid_signal(int sig);
67
68 // Helper function, returns a string (e.g. "SIGILL") for a signal.
69 // Returned string is a constant. For unknown signals "UNKNOWN" is returned.
70 static const char* get_signal_name(int sig, char* out, size_t outlen);
71
72 // Helper function, returns a signal number for a given signal name, e.g. 11
73 // for "SIGSEGV". Name can be given with or without "SIG" prefix, so both
74 // "SEGV" or "SIGSEGV" work. Name must be uppercase.
75 // Returns -1 for an unknown signal name.
76 static int get_signal_number(const char* signal_name);
77
78 // Returns one-line short description of a signal set in a user provided buffer.
88 // into a user provided buffer. Returns that buffer.
89 static const char* describe_sa_flags(int flags, char* buffer, size_t size);
90
91 // Prints a one-line description of a combination of sigaction.sa_flags.
92 static void print_sa_flags(outputStream* st, int flags);
93
94 static address ucontext_get_pc(const ucontext_t* ctx);
95 // Set PC into context. Needed for continuation after signal.
96 static void ucontext_set_pc(ucontext_t* ctx, address pc);
97
98 // Helper function; describes pthread attributes as short string. String is written
99 // to buf with len buflen; buf is returned.
100 static char* describe_pthread_attr(char* buf, size_t buflen, const pthread_attr_t* attr);
101
102 // A safe implementation of realpath which will not cause a buffer overflow if the resolved path
103 // is longer than PATH_MAX.
104 // On success, returns 'outbuf', which now contains the path.
105 // On error, it will return NULL and set errno. The content of 'outbuf' is undefined.
106 // On truncation error ('outbuf' too small), it will return NULL and set errno to ENAMETOOLONG.
107 static char* realpath(const char* filename, char* outbuf, size_t outbuflen);
108 };
109
110 /*
111 * Crash protection for the watcher thread. Wrap the callback
112 * with a sigsetjmp and in case of a SIGSEGV/SIGBUS we siglongjmp
113 * back.
114 * To be able to use this - don't take locks, don't rely on destructors,
115 * don't make OS library calls, don't allocate memory, don't print,
116 * don't call code that could leave the heap / memory in an inconsistent state,
117 * or anything else where we are not in control if we suddenly jump out.
118 */
119 class WatcherThreadCrashProtection : public StackObj {
120 public:
121 WatcherThreadCrashProtection();
122 bool call(os::CrashProtectionCallback& cb);
123
124 static void check_crash_protection(int signal, Thread* thread);
125 private:
126 void restore();
127 sigjmp_buf _jmpbuf;
128 };
129
130 #ifndef SOLARIS
131
132 /*
133 * This is the platform-specific implementation underpinning
134 * the ParkEvent class, which itself underpins Java-level monitor
135 * operations. See park.hpp for details.
136 * These event objects are type-stable and immortal - we never delete them.
137 * Events are associated with a thread for the lifetime of the thread.
138 */
139 class PlatformEvent : public CHeapObj<mtInternal> {
140 private:
141 double cachePad[4]; // Increase odds that _mutex is sole occupant of cache line
142 volatile int _event; // Event count/permit: -1, 0 or 1
143 volatile int _nParked; // Indicates if associated thread is blocked: 0 or 1
144 pthread_mutex_t _mutex[1]; // Native mutex for locking
145 pthread_cond_t _cond[1]; // Native condition variable for blocking
146 double postPad[2];
147
148 protected: // TODO-FIXME: make dtor private
149 ~PlatformEvent() { guarantee(0, "invariant"); } // immortal so can't delete
150
151 public:
152 PlatformEvent();
153 void park();
154 int park(jlong millis);
155 void unpark();
156
157 // Use caution with reset() and fired() -- they may require MEMBARs
158 void reset() { _event = 0; }
159 int fired() { return _event; }
160 };
161
162 // JSR166 support
163 // PlatformParker provides the platform dependent base class for the
164 // Parker class. It basically provides the internal data structures:
165 // - mutex and convars
166 // which are then used directly by the Parker methods defined in the OS
167 // specific implementation files.
168 // There is significant overlap between the funcionality supported in the
169 // combination of Parker+PlatformParker and PlatformEvent (above). If Parker
170 // were more like ObjectMonitor we could use PlatformEvent in both (with some
171 // API updates of course). But Parker methods use fastpaths that break that
172 // level of encapsulation - so combining the two remains a future project.
173
174 class PlatformParker : public CHeapObj<mtInternal> {
175 protected:
176 enum {
177 REL_INDEX = 0,
178 ABS_INDEX = 1
179 };
180 int _cur_index; // which cond is in use: -1, 0, 1
181 pthread_mutex_t _mutex[1];
182 pthread_cond_t _cond[2]; // one for relative times and one for absolute
183
184 public: // TODO-FIXME: make dtor private
185 ~PlatformParker() { guarantee(0, "invariant"); }
186
187 public:
188 PlatformParker();
189 };
190
191 #endif // !SOLARIS
192
193 #endif // OS_POSIX_VM_OS_POSIX_HPP
|