1/*
2 * Copyright 2008-2010, Ingo Weinhold, ingo_weinhold@gmx.de.
3 * Copyright 2005-2009, Axel D��rfler, axeld@pinc-software.de.
4 * Distributed under the terms of the MIT License.
5 */
6
7
8#include <low_resource_manager.h>
9
10#include <new>
11#include <stdio.h>
12#include <stdlib.h>
13
14#include <KernelExport.h>
15
16#include <condition_variable.h>
17#include <elf.h>
18#include <lock.h>
19#include <sem.h>
20#include <util/AutoLock.h>
21#include <util/DoublyLinkedList.h>
22#include <vm/vm_page.h>
23#include <vm/vm_priv.h>
24
25
26//#define TRACE_LOW_RESOURCE_MANAGER
27#ifdef TRACE_LOW_RESOURCE_MANAGER
28#	define TRACE(x)	dprintf x
29#else
30#	define TRACE(x) ;
31#endif
32
33
34struct low_resource_handler
35		: public DoublyLinkedListLinkImpl<low_resource_handler> {
36	low_resource_func	function;
37	void*				data;
38	uint32				resources;
39	int32				priority;
40};
41
42typedef DoublyLinkedList<low_resource_handler> HandlerList;
43
44
45static const bigtime_t kLowResourceInterval = 3000000;	// 3 secs
46static const bigtime_t kWarnResourceInterval = 500000;	// 0.5 secs
47
48// page limits
49static const size_t kNotePagesLimit = VM_PAGE_RESERVE_USER * 4;
50static const size_t kWarnPagesLimit = VM_PAGE_RESERVE_USER;
51static const size_t kCriticalPagesLimit = VM_PAGE_RESERVE_SYSTEM;
52
53// memory limits
54static const off_t kMinNoteMemoryLimit		= VM_MEMORY_RESERVE_USER * 4;
55static const off_t kMinWarnMemoryLimit		= VM_MEMORY_RESERVE_USER;
56static const off_t kMinCriticalMemoryLimit	= VM_MEMORY_RESERVE_SYSTEM;
57static off_t sNoteMemoryLimit;
58static off_t sWarnMemoryLimit;
59static off_t sCriticalMemoryLimit;
60
61// address space limits
62static const size_t kMinNoteSpaceLimit		= 128 * 1024 * 1024;
63static const size_t kMinWarnSpaceLimit		= 64 * 1024 * 1024;
64static const size_t kMinCriticalSpaceLimit	= 32 * 1024 * 1024;
65
66
67static int32 sLowPagesState = B_NO_LOW_RESOURCE;
68static int32 sLowMemoryState = B_NO_LOW_RESOURCE;
69static int32 sLowSemaphoresState = B_NO_LOW_RESOURCE;
70static int32 sLowSpaceState = B_NO_LOW_RESOURCE;
71static uint32 sLowResources = 0;	// resources that are not B_NO_LOW_RESOURCE
72static bigtime_t sLastMeasurement;
73
74static recursive_lock sLowResourceLock
75	= RECURSIVE_LOCK_INITIALIZER("low resource");
76static sem_id sLowResourceWaitSem;
77static HandlerList sLowResourceHandlers;
78
79static ConditionVariable sLowResourceWaiterCondition;
80
81
82static const char*
83state_to_string(uint32 state)
84{
85	switch (state) {
86		case B_LOW_RESOURCE_CRITICAL:
87			return "critical";
88		case B_LOW_RESOURCE_WARNING:
89			return "warning";
90		case B_LOW_RESOURCE_NOTE:
91			return "note";
92
93		default:
94			return "normal";
95	}
96}
97
98
99static int32
100low_resource_state_no_update(uint32 resources)
101{
102	int32 state = B_NO_LOW_RESOURCE;
103
104	if ((resources & B_KERNEL_RESOURCE_PAGES) != 0)
105		state = max_c(state, sLowPagesState);
106	if ((resources & B_KERNEL_RESOURCE_MEMORY) != 0)
107		state = max_c(state, sLowMemoryState);
108	if ((resources & B_KERNEL_RESOURCE_SEMAPHORES) != 0)
109		state = max_c(state, sLowSemaphoresState);
110	if ((resources & B_KERNEL_RESOURCE_ADDRESS_SPACE) != 0)
111		state = max_c(state, sLowSpaceState);
112
113	return state;
114}
115
116
117/*!	Calls low resource handlers for the given resources.
118	sLowResourceLock must be held.
119*/
120static void
121call_handlers(uint32 lowResources)
122{
123	if (sLowResourceHandlers.IsEmpty())
124		return;
125
126	// Add a marker, so we can drop the lock while calling the handlers and
127	// still iterate safely.
128	low_resource_handler marker;
129	sLowResourceHandlers.Insert(&marker, false);
130
131	while (low_resource_handler* handler
132			= sLowResourceHandlers.GetNext(&marker)) {
133		// swap with handler
134		sLowResourceHandlers.Swap(&marker, handler);
135		marker.priority = handler->priority;
136
137		int32 resources = handler->resources & lowResources;
138		if (resources != 0) {
139			recursive_lock_unlock(&sLowResourceLock);
140			handler->function(handler->data, resources,
141				low_resource_state_no_update(resources));
142			recursive_lock_lock(&sLowResourceLock);
143		}
144	}
145
146	// remove marker
147	sLowResourceHandlers.Remove(&marker);
148}
149
150
151static void
152compute_state(void)
153{
154	sLastMeasurement = system_time();
155
156	sLowResources = B_ALL_KERNEL_RESOURCES;
157
158	// free pages state
159	uint32 freePages = vm_page_num_free_pages();
160
161	int32 oldState = sLowPagesState;
162	if (freePages < kCriticalPagesLimit) {
163		sLowPagesState = B_LOW_RESOURCE_CRITICAL;
164	} else if (freePages < kWarnPagesLimit) {
165		sLowPagesState = B_LOW_RESOURCE_WARNING;
166	} else if (freePages < kNotePagesLimit) {
167		sLowPagesState = B_LOW_RESOURCE_NOTE;
168	} else {
169		sLowPagesState = B_NO_LOW_RESOURCE;
170		sLowResources &= ~B_KERNEL_RESOURCE_PAGES;
171	}
172
173	if (sLowPagesState != oldState) {
174		dprintf("low resource pages: %s -> %s\n", state_to_string(oldState),
175			state_to_string(sLowPagesState));
176	}
177
178	// free memory state
179	off_t freeMemory = vm_available_not_needed_memory();
180
181	oldState = sLowMemoryState;
182	if (freeMemory < sCriticalMemoryLimit) {
183		sLowMemoryState = B_LOW_RESOURCE_CRITICAL;
184	} else if (freeMemory < sWarnMemoryLimit) {
185		sLowMemoryState = B_LOW_RESOURCE_WARNING;
186	} else if (freeMemory < sNoteMemoryLimit) {
187		sLowMemoryState = B_LOW_RESOURCE_NOTE;
188	} else {
189		sLowMemoryState = B_NO_LOW_RESOURCE;
190		sLowResources &= ~B_KERNEL_RESOURCE_MEMORY;
191	}
192
193	if (sLowMemoryState != oldState) {
194		dprintf("low resource memory: %s -> %s\n", state_to_string(oldState),
195			state_to_string(sLowMemoryState));
196	}
197
198	// free semaphores state
199	uint32 maxSems = sem_max_sems();
200	uint32 freeSems = maxSems - sem_used_sems();
201
202	oldState = sLowSemaphoresState;
203	if (freeSems < maxSems >> 16) {
204		sLowSemaphoresState = B_LOW_RESOURCE_CRITICAL;
205	} else if (freeSems < maxSems >> 8) {
206		sLowSemaphoresState = B_LOW_RESOURCE_WARNING;
207	} else if (freeSems < maxSems >> 4) {
208		sLowSemaphoresState = B_LOW_RESOURCE_NOTE;
209	} else {
210		sLowSemaphoresState = B_NO_LOW_RESOURCE;
211		sLowResources &= ~B_KERNEL_RESOURCE_SEMAPHORES;
212	}
213
214	if (sLowSemaphoresState != oldState) {
215		dprintf("low resource semaphores: %s -> %s\n",
216			state_to_string(oldState), state_to_string(sLowSemaphoresState));
217	}
218
219	// free kernel address space state
220	// TODO: this should take fragmentation into account
221	size_t freeSpace = vm_kernel_address_space_left();
222
223	oldState = sLowSpaceState;
224	if (freeSpace < kMinCriticalSpaceLimit) {
225		sLowSpaceState = B_LOW_RESOURCE_CRITICAL;
226	} else if (freeSpace < kMinWarnSpaceLimit) {
227		sLowSpaceState = B_LOW_RESOURCE_WARNING;
228	} else if (freeSpace < kMinNoteSpaceLimit) {
229		sLowSpaceState = B_LOW_RESOURCE_NOTE;
230	} else {
231		sLowSpaceState = B_NO_LOW_RESOURCE;
232		sLowResources &= ~B_KERNEL_RESOURCE_ADDRESS_SPACE;
233	}
234
235	if (sLowSpaceState != oldState) {
236		dprintf("low resource address space: %s -> %s\n",
237			state_to_string(oldState), state_to_string(sLowSpaceState));
238	}
239}
240
241
242static status_t
243low_resource_manager(void*)
244{
245	bigtime_t timeout = kLowResourceInterval;
246	while (true) {
247		int32 state = low_resource_state_no_update(B_ALL_KERNEL_RESOURCES);
248		if (state != B_LOW_RESOURCE_CRITICAL) {
249			acquire_sem_etc(sLowResourceWaitSem, 1, B_RELATIVE_TIMEOUT,
250				timeout);
251		}
252
253		RecursiveLocker _(&sLowResourceLock);
254
255		compute_state();
256		state = low_resource_state_no_update(B_ALL_KERNEL_RESOURCES);
257
258		TRACE(("low_resource_manager: state = %ld, %ld free pages, %lld free "
259			"memory, %lu free semaphores\n", state, vm_page_num_free_pages(),
260			vm_available_not_needed_memory(),
261			sem_max_sems() - sem_used_sems()));
262
263		if (state < B_LOW_RESOURCE_NOTE)
264			continue;
265
266		call_handlers(sLowResources);
267
268		if (state == B_LOW_RESOURCE_WARNING)
269			timeout = kWarnResourceInterval;
270		else
271			timeout = kLowResourceInterval;
272
273		sLowResourceWaiterCondition.NotifyAll();
274	}
275	return 0;
276}
277
278
279static int
280dump_handlers(int argc, char** argv)
281{
282	kprintf("current state: %c%c%c%c\n",
283		(sLowResources & B_KERNEL_RESOURCE_PAGES) != 0 ? 'p' : '-',
284		(sLowResources & B_KERNEL_RESOURCE_MEMORY) != 0 ? 'm' : '-',
285		(sLowResources & B_KERNEL_RESOURCE_SEMAPHORES) != 0 ? 's' : '-',
286		(sLowResources & B_KERNEL_RESOURCE_ADDRESS_SPACE) != 0 ? 'a' : '-');
287	kprintf("  pages:  %s (%" B_PRIu64 ")\n", state_to_string(sLowPagesState),
288		(uint64)vm_page_num_free_pages());
289	kprintf("  memory: %s (%" B_PRIdOFF ")\n", state_to_string(sLowMemoryState),
290		vm_available_not_needed_memory_debug());
291	kprintf("  sems:   %s (%" B_PRIu32 ")\n",
292		state_to_string(sLowSemaphoresState), sem_max_sems() - sem_used_sems());
293	kprintf("  aspace: %s (%" B_PRIuSIZE ")\n\n",
294		state_to_string(sLowSpaceState), vm_kernel_address_space_left());
295
296	HandlerList::Iterator iterator = sLowResourceHandlers.GetIterator();
297	kprintf("function    data         resources  prio  function-name\n");
298
299	while (iterator.HasNext()) {
300		low_resource_handler *handler = iterator.Next();
301
302		const char* symbol = NULL;
303		elf_debug_lookup_symbol_address((addr_t)handler->function, NULL,
304			&symbol, NULL, NULL);
305
306		char resources[16];
307		snprintf(resources, sizeof(resources), "%c %c %c %c",
308			handler->resources & B_KERNEL_RESOURCE_PAGES ? 'p' : ' ',
309			handler->resources & B_KERNEL_RESOURCE_MEMORY ? 'm' : ' ',
310			handler->resources & B_KERNEL_RESOURCE_SEMAPHORES ? 's' : ' ',
311			handler->resources & B_KERNEL_RESOURCE_ADDRESS_SPACE ? 'a' : ' ');
312
313		kprintf("%p  %p   %s      %4" B_PRId32 "  %s\n", handler->function,
314			handler->data, resources, handler->priority, symbol);
315	}
316
317	return 0;
318}
319
320
321//	#pragma mark - private kernel API
322
323
324/*!	Notifies the low resource manager that a resource is lacking. If \a flags
325	and \a timeout specify a timeout, the function will wait until the low
326	resource manager has finished its next iteration of calling low resource
327	handlers, or until the timeout occurs (whichever happens first).
328*/
329void
330low_resource(uint32 resource, uint64 requirements, uint32 flags, uint32 timeout)
331{
332	// TODO: take requirements into account
333
334	switch (resource) {
335		case B_KERNEL_RESOURCE_PAGES:
336		case B_KERNEL_RESOURCE_MEMORY:
337		case B_KERNEL_RESOURCE_SEMAPHORES:
338		case B_KERNEL_RESOURCE_ADDRESS_SPACE:
339			break;
340	}
341
342	release_sem(sLowResourceWaitSem);
343
344	if ((flags & B_RELATIVE_TIMEOUT) == 0 || timeout > 0)
345		sLowResourceWaiterCondition.Wait(flags, timeout);
346}
347
348
349int32
350low_resource_state(uint32 resources)
351{
352	recursive_lock_lock(&sLowResourceLock);
353
354	if (system_time() - sLastMeasurement > 500000)
355		compute_state();
356
357	int32 state = low_resource_state_no_update(resources);
358
359	recursive_lock_unlock(&sLowResourceLock);
360
361	return state;
362}
363
364
365status_t
366low_resource_manager_init(void)
367{
368	new(&sLowResourceHandlers) HandlerList;
369		// static initializers do not work in the kernel,
370		// so we have to do it here, manually
371
372	sLowResourceWaiterCondition.Init(NULL, "low resource waiters");
373
374	// compute the free memory limits
375	off_t totalMemory = (off_t)vm_page_num_pages() * B_PAGE_SIZE;
376	sNoteMemoryLimit = totalMemory / 16;
377	if (sNoteMemoryLimit < kMinNoteMemoryLimit) {
378		sNoteMemoryLimit = kMinNoteMemoryLimit;
379		sWarnMemoryLimit = kMinWarnMemoryLimit;
380		sCriticalMemoryLimit = kMinCriticalMemoryLimit;
381	} else {
382		sWarnMemoryLimit = totalMemory / 64;
383		sCriticalMemoryLimit = totalMemory / 256;
384	}
385
386	return B_OK;
387}
388
389
390status_t
391low_resource_manager_init_post_thread(void)
392{
393	sLowResourceWaitSem = create_sem(0, "low resource wait");
394	if (sLowResourceWaitSem < B_OK)
395		return sLowResourceWaitSem;
396
397	thread_id thread = spawn_kernel_thread(&low_resource_manager,
398		"low resource manager", B_LOW_PRIORITY, NULL);
399	resume_thread(thread);
400
401	add_debugger_command("low_resource", &dump_handlers,
402		"Dump list of low resource handlers");
403	return B_OK;
404}
405
406
407status_t
408unregister_low_resource_handler(low_resource_func function, void* data)
409{
410	TRACE(("unregister_low_resource_handler(function = %p, data = %p)\n",
411		function, data));
412
413	RecursiveLocker locker(&sLowResourceLock);
414	HandlerList::Iterator iterator = sLowResourceHandlers.GetIterator();
415
416	while (iterator.HasNext()) {
417		low_resource_handler* handler = iterator.Next();
418
419		if (handler->function == function && handler->data == data) {
420			sLowResourceHandlers.Remove(handler);
421			free(handler);
422			return B_OK;
423		}
424	}
425
426	return B_ENTRY_NOT_FOUND;
427}
428
429
430/*! Registers a low resource handler. The higher the \a priority, the earlier
431	the handler will be called in low resource situations.
432*/
433status_t
434register_low_resource_handler(low_resource_func function, void* data,
435	uint32 resources, int32 priority)
436{
437	TRACE(("register_low_resource_handler(function = %p, data = %p)\n",
438		function, data));
439
440	low_resource_handler *newHandler = (low_resource_handler*)malloc(
441		sizeof(low_resource_handler));
442	if (newHandler == NULL)
443		return B_NO_MEMORY;
444
445	newHandler->function = function;
446	newHandler->data = data;
447	newHandler->resources = resources;
448	newHandler->priority = priority;
449
450	RecursiveLocker locker(&sLowResourceLock);
451
452	// sort it in after priority (higher priority comes first)
453
454	HandlerList::ReverseIterator iterator
455		= sLowResourceHandlers.GetReverseIterator();
456	low_resource_handler* last = NULL;
457	while (iterator.HasNext()) {
458		low_resource_handler *handler = iterator.Next();
459
460		if (handler->priority >= priority) {
461			sLowResourceHandlers.Insert(last, newHandler);
462			return B_OK;
463		}
464		last = handler;
465	}
466
467	sLowResourceHandlers.Add(newHandler, false);
468	return B_OK;
469}
470