Differential D27199

malloc: retire MALLOC_PROFILE
ClosedPublic
Actions

Authored by mjg on Nov 12 2020, 9:18 PM.

Details

Reviewers

markj

Commits

rS367650: malloc: retire MALLOC_PROFILE

Summary

The global array has prohibitive performance impact on multicore systems.

The same data (and more) can be obtained via other means, e.g. dtrace.

Diff Detail

Repository

rS FreeBSD src repository - subversion

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

mjg requested review of this revision.Nov 12 2020, 9:18 PM

mjg created this revision.

Couldn't find any userspace code that references this.

This revision is now accepted and ready to land.Nov 13 2020, 2:01 PM

Closed by commit rS367650: malloc: retire MALLOC_PROFILE (authored by mjg). · Explain WhyNov 13 2020, 7:23 PM

This revision was automatically updated to reflect the committed changes.

mjg added a commit: rS367650: malloc: retire MALLOC_PROFILE.

Herald added a subscriber: imp. · View Herald TranscriptNov 13 2020, 7:23 PM

Revision Contents
Changeset List

Path

Size

head/

sys/

kern/

kern_malloc.c

61 lines

Diff 79520

View Options

head/sys/kern/kern_malloc.c

Show First 20 Lines • Show All 4,126 Lines • ▼ Show 20 Lines	vm_map_stack_locked(vm_map_t map, vm_offset_t addrbos, vm_size_t max_ssize,
KASSERT(orient != 0, ("No stack grow direction"));		KASSERT(orient != 0, ("No stack grow direction"));
KASSERT(orient != (MAP_STACK_GROWS_DOWN \| MAP_STACK_GROWS_UP),		KASSERT(orient != (MAP_STACK_GROWS_DOWN \| MAP_STACK_GROWS_UP),
("bi-dir stack"));		("bi-dir stack"));

if (addrbos < vm_map_min(map) \|\|		if (addrbos < vm_map_min(map) \|\|
addrbos + max_ssize > vm_map_max(map) \|\|		addrbos + max_ssize > vm_map_max(map) \|\|
addrbos + max_ssize <= addrbos)		addrbos + max_ssize <= addrbos)
return (KERN_INVALID_ADDRESS);		return (KERN_INVALID_ADDRESS);
sgp = (vm_size_t)stack_guard_page * PAGE_SIZE;		sgp = (curproc->p_flag2 & P2_STKGAP_DISABLE) != 0 ? 0 :
		(vm_size_t)stack_guard_page * PAGE_SIZE;
if (sgp >= max_ssize)		if (sgp >= max_ssize)
return (KERN_INVALID_ARGUMENT);		return (KERN_INVALID_ARGUMENT);

init_ssize = growsize;		init_ssize = growsize;
if (max_ssize < init_ssize + sgp)		if (max_ssize < init_ssize + sgp)
init_ssize = max_ssize - sgp;		init_ssize = max_ssize - sgp;

/* If addr is already mapped, no go */		/* If addr is already mapped, no go */
Show All 34 Lines	vm_map_stack_locked(vm_map_t map, vm_offset_t addrbos, vm_size_t max_ssize,
KASSERT(new_entry->end == top \|\| new_entry->start == bot,		KASSERT(new_entry->end == top \|\| new_entry->start == bot,
("Bad entry start/end for new stack entry"));		("Bad entry start/end for new stack entry"));
KASSERT((orient & MAP_STACK_GROWS_DOWN) == 0 \|\|		KASSERT((orient & MAP_STACK_GROWS_DOWN) == 0 \|\|
(new_entry->eflags & MAP_ENTRY_GROWS_DOWN) != 0,		(new_entry->eflags & MAP_ENTRY_GROWS_DOWN) != 0,
("new entry lacks MAP_ENTRY_GROWS_DOWN"));		("new entry lacks MAP_ENTRY_GROWS_DOWN"));
KASSERT((orient & MAP_STACK_GROWS_UP) == 0 \|\|		KASSERT((orient & MAP_STACK_GROWS_UP) == 0 \|\|
(new_entry->eflags & MAP_ENTRY_GROWS_UP) != 0,		(new_entry->eflags & MAP_ENTRY_GROWS_UP) != 0,
("new entry lacks MAP_ENTRY_GROWS_UP"));		("new entry lacks MAP_ENTRY_GROWS_UP"));
rv = vm_map_insert(map, NULL, 0, gap_bot, gap_top, VM_PROT_NONE,		if (gap_bot != gap_top) {
VM_PROT_NONE, MAP_CREATE_GUARD \| (orient == MAP_STACK_GROWS_DOWN ?		rv = vm_map_insert(map, NULL, 0, gap_bot, gap_top,
		VM_PROT_NONE, VM_PROT_NONE, MAP_CREATE_GUARD \|
		(orient == MAP_STACK_GROWS_DOWN ?
MAP_CREATE_STACK_GAP_DN : MAP_CREATE_STACK_GAP_UP));		MAP_CREATE_STACK_GAP_DN : MAP_CREATE_STACK_GAP_UP));
if (rv == KERN_SUCCESS) {		if (rv == KERN_SUCCESS) {
/*		/*
* Gap can never successfully handle a fault, so		* Gap can never successfully handle a fault, so
* read-ahead logic is never used for it. Re-use		* read-ahead logic is never used for it. Re-use
* next_read of the gap entry to store		* next_read of the gap entry to store
* stack_guard_page for vm_map_growstack().		* stack_guard_page for vm_map_growstack().
*/		*/
if (orient == MAP_STACK_GROWS_DOWN)		if (orient == MAP_STACK_GROWS_DOWN)
new_entry->prev->next_read = sgp;		new_entry->prev->next_read = sgp;
else		else
new_entry->next->next_read = sgp;		new_entry->next->next_read = sgp;
} else {		} else {
(void)vm_map_delete(map, bot, top);		(void)vm_map_delete(map, bot, top);
}		}
		dougmUnsubmitted Done Inline Actions if (gap_bot == gap_top) return (KERN_SUCCESS); seems easier than indenting the lines below. dougm: if (gap_bot == gap_top) return (KERN_SUCCESS); seems easier than indenting the lines…
		}
return (rv);		return (rv);
}		}

/*		/*
* Attempts to grow a vm stack entry. Returns KERN_SUCCESS if we		* Attempts to grow a vm stack entry. Returns KERN_SUCCESS if we
* successfully grow the stack.		* successfully grow the stack.
*/		*/
static int		static int
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines	if ((gap_entry->eflags & MAP_ENTRY_STACK_GAP_DN) != 0) {
if ((stack_entry->eflags & MAP_ENTRY_GROWS_UP) == 0 \|\|		if ((stack_entry->eflags & MAP_ENTRY_GROWS_UP) == 0 \|\|
stack_entry->end != gap_entry->start)		stack_entry->end != gap_entry->start)
return (KERN_FAILURE);		return (KERN_FAILURE);
grow_amount = round_page(addr + 1 - stack_entry->end);		grow_amount = round_page(addr + 1 - stack_entry->end);
grow_down = false;		grow_down = false;
} else {		} else {
return (KERN_FAILURE);		return (KERN_FAILURE);
}		}
guard = gap_entry->next_read;		guard = (curproc->p_flag2 & P2_STKGAP_DISABLE) != 0 ? 0 :
		gap_entry->next_read;
max_grow = gap_entry->end - gap_entry->start;		max_grow = gap_entry->end - gap_entry->start;
if (guard > max_grow)		if (guard > max_grow)
return (KERN_NO_SPACE);		return (KERN_NO_SPACE);
max_grow -= guard;		max_grow -= guard;
if (grow_amount > max_grow)		if (grow_amount > max_grow)
return (KERN_NO_SPACE);		return (KERN_NO_SPACE);

/*		/*
▲ Show 20 Lines • Show All 642 Lines • Show Last 20 Lines

malloc: retire MALLOC_PROFILEClosedPublicActions