• file
• revisions
• annotate
• diff
• comparison
• raw

src/os_cpu/linux_zero/vm/os_linux_zero.cpp@67d74f7a15d9 (annotated)

src/os_cpu/linux_zero/vm/os_linux_zero.cpp

Wed, 12 May 2010 10:28:13 -0700

author

jcoomes

date

Wed, 12 May 2010 10:28:13 -0700

changeset 1877

67d74f7a15d9

parent 1611

d11ce1551e8d

child 1907

c18cbe5936b8

permissions

-rw-r--r--

6951923: some uses of fatal1 were missed by 6888954
Reviewed-by: jcoomes
Contributed-by: Gary Benson <gbenson@redhat.com>

never@1445	1	/*
never@1445	2	* Copyright 2003-2007 Sun Microsystems, Inc. All Rights Reserved.
twisti@1611	3	* Copyright 2007, 2008, 2009, 2010 Red Hat, Inc.
never@1445	4	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
never@1445	5	*
never@1445	6	* This code is free software; you can redistribute it and/or modify it
never@1445	7	* under the terms of the GNU General Public License version 2 only, as
never@1445	8	* published by the Free Software Foundation.
never@1445	9	*
never@1445	10	* This code is distributed in the hope that it will be useful, but WITHOUT
never@1445	11	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
never@1445	12	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
never@1445	13	* version 2 for more details (a copy is included in the LICENSE file that
never@1445	14	* accompanied this code).
never@1445	15	*
never@1445	16	* You should have received a copy of the GNU General Public License version
never@1445	17	* 2 along with this work; if not, write to the Free Software Foundation,
never@1445	18	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
never@1445	19	*
never@1445	20	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
never@1445	21	* CA 95054 USA or visit www.sun.com if you need additional information or
never@1445	22	* have any questions.
never@1445	23	*
never@1445	24	*/
never@1445	25
never@1445	26	// do not include precompiled header file
never@1445	27	#include "incls/_os_linux_zero.cpp.incl"
never@1445	28
never@1445	29	address os::current_stack_pointer() {
never@1445	30	address dummy = (address) &dummy;
never@1445	31	return dummy;
never@1445	32	}
never@1445	33
never@1445	34	frame os::get_sender_for_C_frame(frame* fr) {
never@1445	35	ShouldNotCallThis();
never@1445	36	}
never@1445	37
never@1445	38	frame os::current_frame() {
never@1445	39	// The only thing that calls this is the stack printing code in
never@1445	40	// VMError::report:
never@1445	41	// - Step 110 (printing stack bounds) uses the sp in the frame
never@1445	42	// to determine the amount of free space on the stack. We
never@1445	43	// set the sp to a close approximation of the real value in
never@1445	44	// order to allow this step to complete.
never@1445	45	// - Step 120 (printing native stack) tries to walk the stack.
never@1445	46	// The frame we create has a NULL pc, which is ignored as an
never@1445	47	// invalid frame.
never@1445	48	frame dummy = frame();
never@1445	49	dummy.set_sp((intptr_t *) current_stack_pointer());
never@1445	50	return dummy;
never@1445	51	}
never@1445	52
never@1445	53	char* os::non_memory_address_word() {
never@1445	54	// Must never look like an address returned by reserve_memory,
never@1445	55	// even in its subfields (as defined by the CPU immediate fields,
never@1445	56	// if the CPU splits constants across multiple instructions).
never@1445	57	#ifdef SPARC
never@1445	58	// On SPARC, 0 != %hi(any real address), because there is no
never@1445	59	// allocation in the first 1Kb of the virtual address space.
never@1445	60	return (char *) 0;
never@1445	61	#else
never@1445	62	// This is the value for x86; works pretty well for PPC too.
never@1445	63	return (char *) -1;
never@1445	64	#endif // SPARC
never@1445	65	}
never@1445	66
never@1445	67	void os::initialize_thread() {
never@1445	68	// Nothing to do.
never@1445	69	}
never@1445	70
never@1445	71	address os::Linux::ucontext_get_pc(ucontext_t* uc) {
never@1445	72	ShouldNotCallThis();
never@1445	73	}
never@1445	74
never@1445	75	ExtendedPC os::fetch_frame_from_context(void* ucVoid,
never@1445	76	intptr_t** ret_sp,
never@1445	77	intptr_t** ret_fp) {
never@1445	78	ShouldNotCallThis();
never@1445	79	}
never@1445	80
never@1445	81	frame os::fetch_frame_from_context(void* ucVoid) {
never@1445	82	ShouldNotCallThis();
never@1445	83	}
never@1445	84
never@1445	85	extern "C" int
never@1445	86	JVM_handle_linux_signal(int sig,
never@1445	87	siginfo_t* info,
never@1445	88	void* ucVoid,
never@1445	89	int abort_if_unrecognized) {
never@1445	90	ucontext_t* uc = (ucontext_t*) ucVoid;
never@1445	91
never@1445	92	Thread* t = ThreadLocalStorage::get_thread_slow();
never@1445	93
never@1445	94	SignalHandlerMark shm(t);
never@1445	95
never@1445	96	// Note: it's not uncommon that JNI code uses signal/sigset to
never@1445	97	// install then restore certain signal handler (e.g. to temporarily
never@1445	98	// block SIGPIPE, or have a SIGILL handler when detecting CPU
never@1445	99	// type). When that happens, JVM_handle_linux_signal() might be
never@1445	100	// invoked with junk info/ucVoid. To avoid unnecessary crash when
never@1445	101	// libjsig is not preloaded, try handle signals that do not require
never@1445	102	// siginfo/ucontext first.
never@1445	103
never@1445	104	if (sig == SIGPIPE || sig == SIGXFSZ) {
never@1445	105	// allow chained handler to go first
never@1445	106	if (os::Linux::chained_handler(sig, info, ucVoid)) {
never@1445	107	return true;
never@1445	108	} else {
never@1445	109	if (PrintMiscellaneous && (WizardMode || Verbose)) {
never@1445	110	char buf[64];
never@1445	111	warning("Ignoring %s - see bugs 4229104 or 646499219",
never@1445	112	os::exception_name(sig, buf, sizeof(buf)));
never@1445	113	}
never@1445	114	return true;
never@1445	115	}
never@1445	116	}
never@1445	117
never@1445	118	JavaThread* thread = NULL;
never@1445	119	VMThread* vmthread = NULL;
never@1445	120	if (os::Linux::signal_handlers_are_installed) {
never@1445	121	if (t != NULL ){
never@1445	122	if(t->is_Java_thread()) {
never@1445	123	thread = (JavaThread*)t;
never@1445	124	}
never@1445	125	else if(t->is_VM_thread()){
never@1445	126	vmthread = (VMThread *)t;
never@1445	127	}
never@1445	128	}
never@1445	129	}
never@1445	130
never@1445	131	if (info != NULL && thread != NULL) {
never@1445	132	// Handle ALL stack overflow variations here
never@1445	133	if (sig == SIGSEGV) {
never@1445	134	address addr = (address) info->si_addr;
never@1445	135
never@1445	136	// check if fault address is within thread stack
never@1445	137	if (addr < thread->stack_base() &&
never@1445	138	addr >= thread->stack_base() - thread->stack_size()) {
never@1445	139	// stack overflow
never@1445	140	if (thread->in_stack_yellow_zone(addr)) {
never@1445	141	thread->disable_stack_yellow_zone();
never@1445	142	ShouldNotCallThis();
never@1445	143	}
never@1445	144	else if (thread->in_stack_red_zone(addr)) {
never@1445	145	thread->disable_stack_red_zone();
never@1445	146	ShouldNotCallThis();
never@1445	147	}
never@1445	148	else {
never@1445	149	// Accessing stack address below sp may cause SEGV if
never@1445	150	// current thread has MAP_GROWSDOWN stack. This should
never@1445	151	// only happen when current thread was created by user
never@1445	152	// code with MAP_GROWSDOWN flag and then attached to VM.
never@1445	153	// See notes in os_linux.cpp.
never@1445	154	if (thread->osthread()->expanding_stack() == 0) {
never@1445	155	thread->osthread()->set_expanding_stack();
never@1445	156	if (os::Linux::manually_expand_stack(thread, addr)) {
never@1445	157	thread->osthread()->clear_expanding_stack();
never@1445	158	return true;
never@1445	159	}
never@1445	160	thread->osthread()->clear_expanding_stack();
never@1445	161	}
never@1445	162	else {
never@1445	163	fatal("recursive segv. expanding stack.");
never@1445	164	}
never@1445	165	}
never@1445	166	}
never@1445	167	}
never@1445	168
never@1445	169	/*if (thread->thread_state() == _thread_in_Java) {
never@1445	170	ShouldNotCallThis();
never@1445	171	}
never@1445	172	else*/ if (thread->thread_state() == _thread_in_vm &&
never@1445	173	sig == SIGBUS && thread->doing_unsafe_access()) {
never@1445	174	ShouldNotCallThis();
never@1445	175	}
never@1445	176
never@1445	177	// jni_fast_Get<Primitive>Field can trap at certain pc's if a GC
never@1445	178	// kicks in and the heap gets shrunk before the field access.
never@1445	179	/*if (sig == SIGSEGV || sig == SIGBUS) {
never@1445	180	address addr = JNI_FastGetField::find_slowcase_pc(pc);
never@1445	181	if (addr != (address)-1) {
never@1445	182	stub = addr;
never@1445	183	}
never@1445	184	}*/
never@1445	185
never@1445	186	// Check to see if we caught the safepoint code in the process
never@1445	187	// of write protecting the memory serialization page. It write
never@1445	188	// enables the page immediately after protecting it so we can
never@1445	189	// just return to retry the write.
never@1445	190	if (sig == SIGSEGV &&
never@1445	191	os::is_memory_serialize_page(thread, (address) info->si_addr)) {
never@1445	192	// Block current thread until permission is restored.
never@1445	193	os::block_on_serialize_page_trap();
never@1445	194	return true;
never@1445	195	}
never@1445	196	}
never@1445	197
never@1445	198	// signal-chaining
never@1445	199	if (os::Linux::chained_handler(sig, info, ucVoid)) {
never@1445	200	return true;
never@1445	201	}
never@1445	202
never@1445	203	if (!abort_if_unrecognized) {
never@1445	204	// caller wants another chance, so give it to him
never@1445	205	return false;
never@1445	206	}
never@1445	207
never@1445	208	#ifndef PRODUCT
never@1445	209	if (sig == SIGSEGV) {
never@1445	210	fatal("\n#"
never@1445	211	"\n# /--------------------\\"
never@1445	212	"\n# | segmentation fault |"
never@1445	213	"\n# \\---\\ /--------------/"
never@1445	214	"\n# /"
never@1445	215	"\n# [-] |\\_/| "
never@1445	216	"\n# (+)=C |o o|__ "
never@1445	217	"\n# | | =-*-=__\\ "
never@1445	218	"\n# OOO c_c_(___)");
never@1445	219	}
never@1445	220	#endif // !PRODUCT
never@1445	221
never@1445	222	const char *fmt = "caught unhandled signal %d";
never@1445	223	char buf[64];
never@1445	224
never@1445	225	sprintf(buf, fmt, sig);
never@1445	226	fatal(buf);
never@1445	227	}
never@1445	228
never@1445	229	void os::Linux::init_thread_fpu_state(void) {
never@1445	230	// Nothing to do
never@1445	231	}
never@1445	232
never@1445	233	int os::Linux::get_fpu_control_word() {
never@1445	234	ShouldNotCallThis();
never@1445	235	}
never@1445	236
never@1445	237	void os::Linux::set_fpu_control_word(int fpu) {
never@1445	238	ShouldNotCallThis();
never@1445	239	}
never@1445	240
never@1445	241	bool os::is_allocatable(size_t bytes) {
twisti@1611	242	#ifdef _LP64
twisti@1611	243	return true;
twisti@1611	244	#else
twisti@1611	245	if (bytes < 2 * G) {
twisti@1611	246	return true;
twisti@1611	247	}
twisti@1611	248
twisti@1611	249	char* addr = reserve_memory(bytes, NULL);
twisti@1611	250
twisti@1611	251	if (addr != NULL) {
twisti@1611	252	release_memory(addr, bytes);
twisti@1611	253	}
twisti@1611	254
twisti@1611	255	return addr != NULL;
twisti@1611	256	#endif // _LP64
never@1445	257	}
never@1445	258
never@1445	259	///////////////////////////////////////////////////////////////////////////////
never@1445	260	// thread stack
never@1445	261
never@1445	262	size_t os::Linux::min_stack_allowed = 64 * K;
never@1445	263
never@1445	264	bool os::Linux::supports_variable_stack_size() {
never@1445	265	return true;
never@1445	266	}
never@1445	267
never@1445	268	size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
never@1445	269	#ifdef _LP64
never@1445	270	size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);
never@1445	271	#else
never@1445	272	size_t s = (thr_type == os::compiler_thread ? 2 * M : 512 * K);
never@1445	273	#endif // _LP64
never@1445	274	return s;
never@1445	275	}
never@1445	276
never@1445	277	size_t os::Linux::default_guard_size(os::ThreadType thr_type) {
never@1445	278	// Only enable glibc guard pages for non-Java threads
never@1445	279	// (Java threads have HotSpot guard pages)
never@1445	280	return (thr_type == java_thread ? 0 : page_size());
never@1445	281	}
never@1445	282
never@1445	283	static void current_stack_region(address *bottom, size_t *size) {
never@1445	284	pthread_attr_t attr;
never@1445	285	int res = pthread_getattr_np(pthread_self(), &attr);
never@1445	286	if (res != 0) {
never@1445	287	if (res == ENOMEM) {
never@1445	288	vm_exit_out_of_memory(0, "pthread_getattr_np");
never@1445	289	}
never@1445	290	else {
jcoomes@1877	291	fatal(err_msg("pthread_getattr_np failed with errno = %d", res));
never@1445	292	}
never@1445	293	}
never@1445	294
never@1445	295	address stack_bottom;
never@1445	296	size_t stack_bytes;
never@1445	297	res = pthread_attr_getstack(&attr, (void **) &stack_bottom, &stack_bytes);
never@1445	298	if (res != 0) {
jcoomes@1877	299	fatal(err_msg("pthread_attr_getstack failed with errno = %d", res));
never@1445	300	}
never@1445	301	address stack_top = stack_bottom + stack_bytes;
never@1445	302
never@1445	303	// The block of memory returned by pthread_attr_getstack() includes
never@1445	304	// guard pages where present. We need to trim these off.
never@1445	305	size_t page_bytes = os::Linux::page_size();
never@1445	306	assert(((intptr_t) stack_bottom & (page_bytes - 1)) == 0, "unaligned stack");
never@1445	307
never@1445	308	size_t guard_bytes;
never@1445	309	res = pthread_attr_getguardsize(&attr, &guard_bytes);
never@1445	310	if (res != 0) {
jcoomes@1877	311	fatal(err_msg("pthread_attr_getguardsize failed with errno = %d", res));
never@1445	312	}
never@1445	313	int guard_pages = align_size_up(guard_bytes, page_bytes) / page_bytes;
never@1445	314	assert(guard_bytes == guard_pages * page_bytes, "unaligned guard");
never@1445	315
never@1445	316	#ifdef IA64
never@1445	317	// IA64 has two stacks sharing the same area of memory, a normal
never@1445	318	// stack growing downwards and a register stack growing upwards.
never@1445	319	// Guard pages, if present, are in the centre. This code splits
never@1445	320	// the stack in two even without guard pages, though in theory
never@1445	321	// there's nothing to stop us allocating more to the normal stack
never@1445	322	// or more to the register stack if one or the other were found
never@1445	323	// to grow faster.
never@1445	324	int total_pages = align_size_down(stack_bytes, page_bytes) / page_bytes;
never@1445	325	stack_bottom += (total_pages - guard_pages) / 2 * page_bytes;
never@1445	326	#endif // IA64
never@1445	327
never@1445	328	stack_bottom += guard_bytes;
never@1445	329
never@1445	330	pthread_attr_destroy(&attr);
never@1445	331
never@1445	332	// The initial thread has a growable stack, and the size reported
never@1445	333	// by pthread_attr_getstack is the maximum size it could possibly
never@1445	334	// be given what currently mapped. This can be huge, so we cap it.
never@1445	335	if (os::Linux::is_initial_thread()) {
never@1445	336	stack_bytes = stack_top - stack_bottom;
never@1445	337
never@1445	338	if (stack_bytes > JavaThread::stack_size_at_create())
never@1445	339	stack_bytes = JavaThread::stack_size_at_create();
never@1445	340
never@1445	341	stack_bottom = stack_top - stack_bytes;
never@1445	342	}
never@1445	343
never@1445	344	assert(os::current_stack_pointer() >= stack_bottom, "should do");
never@1445	345	assert(os::current_stack_pointer() < stack_top, "should do");
never@1445	346
never@1445	347	*bottom = stack_bottom;
never@1445	348	*size = stack_top - stack_bottom;
never@1445	349	}
never@1445	350
never@1445	351	address os::current_stack_base() {
never@1445	352	address bottom;
never@1445	353	size_t size;
never@1445	354	current_stack_region(&bottom, &size);
never@1445	355	return bottom + size;
never@1445	356	}
never@1445	357
never@1445	358	size_t os::current_stack_size() {
never@1445	359	// stack size includes normal stack and HotSpot guard pages
never@1445	360	address bottom;
never@1445	361	size_t size;
never@1445	362	current_stack_region(&bottom, &size);
never@1445	363	return size;
never@1445	364	}
never@1445	365
never@1445	366	/////////////////////////////////////////////////////////////////////////////
never@1445	367	// helper functions for fatal error handler
never@1445	368
never@1445	369	void os::print_context(outputStream* st, void* context) {
never@1445	370	ShouldNotCallThis();
never@1445	371	}
never@1445	372
never@1445	373	/////////////////////////////////////////////////////////////////////////////
never@1445	374	// Stubs for things that would be in linux_zero.s if it existed.
never@1445	375	// You probably want to disassemble these monkeys to check they're ok.
never@1445	376
never@1445	377	extern "C" {
never@1445	378	int SpinPause() {
never@1445	379	}
never@1445	380
never@1445	381	int SafeFetch32(int *adr, int errValue) {
never@1445	382	int value = errValue;
never@1445	383	value = *adr;
never@1445	384	return value;
never@1445	385	}
never@1445	386	intptr_t SafeFetchN(intptr_t *adr, intptr_t errValue) {
never@1445	387	intptr_t value = errValue;
never@1445	388	value = *adr;
never@1445	389	return value;
never@1445	390	}
never@1445	391
never@1445	392	void _Copy_conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count) {
never@1445	393	if (from > to) {
never@1445	394	jshort *end = from + count;
never@1445	395	while (from < end)
never@1445	396	*(to++) = *(from++);
never@1445	397	}
never@1445	398	else if (from < to) {
never@1445	399	jshort *end = from;
never@1445	400	from += count - 1;
never@1445	401	to += count - 1;
never@1445	402	while (from >= end)
never@1445	403	*(to--) = *(from--);
never@1445	404	}
never@1445	405	}
never@1445	406	void _Copy_conjoint_jints_atomic(jint* from, jint* to, size_t count) {
never@1445	407	if (from > to) {
never@1445	408	jint *end = from + count;
never@1445	409	while (from < end)
never@1445	410	*(to++) = *(from++);
never@1445	411	}
never@1445	412	else if (from < to) {
never@1445	413	jint *end = from;
never@1445	414	from += count - 1;
never@1445	415	to += count - 1;
never@1445	416	while (from >= end)
never@1445	417	*(to--) = *(from--);
never@1445	418	}
never@1445	419	}
never@1445	420	void _Copy_conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) {
never@1445	421	if (from > to) {
never@1445	422	jlong *end = from + count;
never@1445	423	while (from < end)
never@1445	424	os::atomic_copy64(from++, to++);
never@1445	425	}
never@1445	426	else if (from < to) {
never@1445	427	jlong *end = from;
never@1445	428	from += count - 1;
never@1445	429	to += count - 1;
never@1445	430	while (from >= end)
never@1445	431	os::atomic_copy64(from--, to--);
never@1445	432	}
never@1445	433	}
never@1445	434
never@1445	435	void _Copy_arrayof_conjoint_bytes(HeapWord* from,
never@1445	436	HeapWord* to,
never@1445	437	size_t count) {
never@1445	438	ShouldNotCallThis();
never@1445	439	}
never@1445	440	void _Copy_arrayof_conjoint_jshorts(HeapWord* from,
never@1445	441	HeapWord* to,
never@1445	442	size_t count) {
never@1445	443	ShouldNotCallThis();
never@1445	444	}
never@1445	445	void _Copy_arrayof_conjoint_jints(HeapWord* from,
never@1445	446	HeapWord* to,
never@1445	447	size_t count) {
never@1445	448	ShouldNotCallThis();
never@1445	449	}
never@1445	450	void _Copy_arrayof_conjoint_jlongs(HeapWord* from,
never@1445	451	HeapWord* to,
never@1445	452	size_t count) {
never@1445	453	ShouldNotCallThis();
never@1445	454	}
never@1445	455	};
never@1445	456
never@1445	457	/////////////////////////////////////////////////////////////////////////////
never@1445	458	// Implementations of atomic operations not supported by processors.
never@1445	459	// -- http://gcc.gnu.org/onlinedocs/gcc-4.2.1/gcc/Atomic-Builtins.html
never@1445	460
never@1445	461	#ifndef _LP64
never@1445	462	extern "C" {
never@1445	463	long long unsigned int __sync_val_compare_and_swap_8(
never@1445	464	volatile void *ptr,
never@1445	465	long long unsigned int oldval,
never@1445	466	long long unsigned int newval) {
never@1445	467	ShouldNotCallThis();
never@1445	468	}
never@1445	469	};
never@1445	470	#endif // !_LP64