Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 1247 → Rev 1248

/kernel/trunk/genarch/src/mm/page_pt.c
49,8 → 49,8
 
/** Map page to frame using hierarchical page tables.
*
* Map virtual address @page to physical address @frame
* using @flags.
* Map virtual address page to physical address frame
* using flags.
*
* The page table must be locked and interrupts must be disabled.
*
99,7 → 99,7
 
/** Remove mapping of page from hierarchical page tables.
*
* Remove any mapping of 'page' within address space 'as'.
* Remove any mapping of page within address space as.
* TLB shootdown should follow in order to make effects of
* this call visible.
*
107,7 → 107,7
*
* The page table must be locked and interrupts must be disabled.
*
* @param as Address space to wich @page belongs.
* @param as Address space to wich page belongs.
* @param page Virtual address of the page to be demapped.
*/
void pt_mapping_remove(as_t *as, __address page)
227,7 → 227,7
*
* The page table must be locked and interrupts must be disabled.
*
* @param as Address space to which @page belongs.
* @param as Address space to which page belongs.
* @param page Virtual page.
*
* @return NULL if there is no such mapping; entry from PTL3 describing the mapping otherwise.
/kernel/trunk/genarch/src/mm/page_ht.c
154,12 → 154,12
 
/** Map page to frame using page hash table.
*
* Map virtual address @page to physical address @frame
* using @flags.
* Map virtual address page to physical address frame
* using flags.
*
* The page table must be locked and interrupts must be disabled.
*
* @param as Address space to which @page belongs.
* @param as Address space to which page belongs.
* @param page Virtual address of the page to be mapped.
* @param frame Physical address of memory frame to which the mapping is done.
* @param flags Flags to be used for mapping.
190,7 → 190,7
 
/** Remove mapping of page from page hash table.
*
* Remove any mapping of @page within address space @as.
* Remove any mapping of page within address space as.
* TLB shootdown should follow in order to make effects of
* this call visible.
*
217,7 → 217,7
*
* The page table must be locked and interrupts must be disabled.
*
* @param as Address space to wich @page belongs.
* @param as Address space to wich page belongs.
* @param page Virtual page.
*
* @return NULL if there is no such mapping; requested mapping otherwise.
/kernel/trunk/generic/src/synch/rwlock.c
26,15 → 26,16
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/** Reader/Writer locks
/**
* @file rwlock.c
* @brief Reader/Writer locks.
*
* A reader/writer lock can be held by multiple readers at a time.
* Or it can be exclusively held by a sole writer at a time.
*/
 
/*
*
* These locks are not recursive.
* Neither readers nor writers will suffer starvation.
* Because technique called direct hand-off is used, neither readers
* nor writers will suffer starvation.
*
* If there is a writer followed by a reader waiting for the rwlock
* and the writer times out, all leading readers are automatically woken up
145,7 → 146,7
* @param trylock Switches between blocking and non-blocking mode.
*
* For exact description of possible combinations of
* @usec and @trylock, see comment for waitq_sleep_timeout().
* usec and trylock, see comment for waitq_sleep_timeout().
*
* @return See comment for waitq_sleep_timeout().
*/
/kernel/trunk/generic/src/synch/mutex.c
51,7 → 51,7
* @param trylock Switches between blocking and non-blocking mode.
*
* For exact description of possible combinations of
* @usec and @trylock, see comment for waitq_sleep_timeout().
* usec and trylock, see comment for waitq_sleep_timeout().
*
* @return See comment for waitq_sleep_timeout().
*/
/kernel/trunk/generic/src/synch/semaphore.c
65,7 → 65,7
* @param trydown Switches between blocking and non-blocking mode.
*
* For exact description of possible combinations of
* @usec and @trydown, see comment for waitq_sleep_timeout().
* usec and trydown, see comment for waitq_sleep_timeout().
*
* @return See comment for waitq_sleep_timeout().
*/
/kernel/trunk/generic/src/synch/waitq.c
26,6 → 26,18
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file waitq.c
* @brief Wait queue.
*
* Wait queue is the basic synchronization primitive upon all
* other synchronization primitives build.
*
* It allows threads to wait for an event in first-come, first-served
* fashion. Conditional operation as well as timeouts and interruptions
* are supported.
*/
 
#include <synch/waitq.h>
#include <synch/synch.h>
#include <synch/spinlock.h>
160,30 → 172,30
* @param usec Timeout in microseconds.
* @param nonblocking Blocking vs. non-blocking operation mode switch.
*
* If @usec is greater than zero, regardless of the value of @nonblocking,
* If usec is greater than zero, regardless of the value of nonblocking,
* the call will not return until either timeout or wakeup comes.
*
* If @usec is zero and @nonblocking is zero (false), the call
* If usec is zero and @nonblocking is zero (false), the call
* will not return until wakeup comes.
*
* If @usec is zero and @nonblocking is non-zero (true), the call will
* If usec is zero and nonblocking is non-zero (true), the call will
* immediately return, reporting either success or failure.
*
* @return Returns one of: ESYNCH_WOULD_BLOCK, ESYNCH_TIMEOUT,
* ESYNCH_OK_ATOMIC, ESYNCH_OK_BLOCKED.
* @return Returns one of: ESYNCH_WOULD_BLOCK, ESYNCH_TIMEOUT,
* ESYNCH_OK_ATOMIC, ESYNCH_OK_BLOCKED.
*
* ESYNCH_WOULD_BLOCK means that the sleep failed because at the time
* @li ESYNCH_WOULD_BLOCK means that the sleep failed because at the time
* of the call there was no pending wakeup.
*
* ESYNCH_TIMEOUT means that the sleep timed out.
* @li ESYNCH_TIMEOUT means that the sleep timed out.
*
* ESYNCH_INTERRUPTED means that somebody interrupted the sleeping thread.
* @li ESYNCH_INTERRUPTED means that somebody interrupted the sleeping thread.
*
* ESYNCH_OK_ATOMIC means that the sleep succeeded and that there was
* @li ESYNCH_OK_ATOMIC means that the sleep succeeded and that there was
* a pending wakeup at the time of the call. The caller was not put
* asleep at all.
*
* ESYNCH_OK_BLOCKED means that the sleep succeeded; the full sleep was
* @li ESYNCH_OK_BLOCKED means that the sleep succeeded; the full sleep was
* attempted.
*/
int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int nonblocking)
/kernel/trunk/generic/src/synch/futex.c
93,7 → 93,7
*
* @param uaddr Userspace address of the futex counter.
* @param usec If non-zero, number of microseconds this thread is willing to sleep.
* @param trydown If @usec is zero and trydown is non-zero, conditional operation will be attempted.
* @param trydown If usec is zero and trydown is non-zero, conditional operation will be attempted.
*
* @return One of ESYNCH_TIMEOUT, ESYNCH_OK_ATOMIC and ESYNCH_OK_BLOCKED. See synch.h.
* If there is no physical mapping for uaddr ENOENT is returned.
218,7 → 218,7
 
/** Compute hash index into futex hash table.
*
* @param key Address where the @key (i.e. physical address of futex counter) is stored.
* @param key Address where the key (i.e. physical address of futex counter) is stored.
*
* @return Index into futex hash table.
*/
231,7 → 231,7
*
* @param key Address where the key (i.e. physical address of futex counter) is stored.
*
* @return True if the item matches the @key. False otherwise.
* @return True if the item matches the key. False otherwise.
*/
bool futex_ht_compare(__native *key, count_t keys, link_t *item)
{
/kernel/trunk/generic/src/synch/condvar.c
76,7 → 76,7
* @param trywait Blocking versus non-blocking operation mode switch.
*
* For exact description of possible combinations of
* @usec and @trywait, see comment for waitq_sleep_timeout().
* usec and trywait, see comment for waitq_sleep_timeout().
*
* @return See comment for waitq_sleep_timeout().
*/
/kernel/trunk/generic/src/main/kinit.c
26,6 → 26,17
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file kinit.c
* @brief Kernel initialization thread.
*
* This file contains kinit kernel thread which carries out
* high level system initialization.
*
* This file is responsible for finishing SMP configuration
* and creation of userspace init tasks.
*/
 
#include <main/kinit.h>
#include <config.h>
#include <arch.h>
/kernel/trunk/generic/src/main/main.c
26,6 → 26,22
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file main.c
* @brief Main initialization kernel function for all processors.
*
* During kernel boot, all processors, after architecture dependent
* initialization, start executing code found in this file. After
* bringing up all subsystems, control is passed to scheduler().
*
* The bootstrap processor starts executing main_bsp() while
* the application processors start executing main_ap().
*
* @see scheduler()
* @see main_bsp()
* @see main_ap()
*/
 
#include <arch/asm.h>
#include <context.h>
#include <print.h>
/kernel/trunk/generic/src/main/uinit.c
26,6 → 26,16
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file uinit.c
* @brief Userspace bootstrap thread.
*
* This file contains uinit kernel thread wich is used to start every
* userspace thread including threads created by SYS_THREAD_CREATE syscall.
*
* @see SYS_THREAD_CREATE
*/
#include <main/uinit.h>
#include <arch/types.h>
#include <proc/thread.h>
/kernel/trunk/generic/src/debug/symtab.c
139,7 → 139,7
 
/** Symtab completion
*
* @param name - Search string, completes to symbol name
* @param input - Search string, completes to symbol name
* @returns - 0 - nothing found, 1 - success, >1 print duplicates
*/
int symtab_compl(char *input)
/kernel/trunk/generic/src/ddi/ddi.c
25,6 → 25,15
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @file ddi.c
* @brief Device Driver Interface functions.
*
* This file contains functions that comprise the Device Driver Interface.
* These are the functions for mapping physical memory and enabling I/O
* space to tasks.
*/
 
#include <ddi/ddi.h>
#include <ddi/ddi_arg.h>
/kernel/trunk/generic/src/proc/scheduler.c
26,6 → 26,14
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file scheduler.c
* @brief Scheduler and load balancing.
*
* This file contains the scheduler and kcpulb kernel thread wich
* performs load-balancing of per-CPU run queues.
*/
 
#include <proc/scheduler.h>
#include <proc/thread.h>
#include <proc/task.h>
/kernel/trunk/generic/src/proc/the.c
26,6 → 26,17
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file the.c
* @brief THE structure functions.
*
* This file contains functions to manage the THE structure.
* The THE structure exists at the base address of every kernel
* stack and carries information about current settings
* (e.g. current CPU, current thread, task and address space
* and current preemption counter).
*/
 
#include <arch.h>
#include <typedefs.h>
 
/kernel/trunk/generic/src/proc/task.c
26,6 → 26,11
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file task.c
* @brief Task management.
*/
 
#include <main/uinit.h>
#include <proc/thread.h>
#include <proc/task.h>
115,7 → 120,7
 
/** Create new task with 1 thread and run it
*
* @param programe_addr Address of program executable image.
* @param program_addr Address of program executable image.
* @param name Program name.
*
* @return Task of the running program or NULL on error.
163,7 → 168,7
 
/** Syscall for reading task ID from userspace.
*
* @param uaddr Userspace address of 8-byte buffer where to store current task ID.
* @param uspace_task_id Userspace address of 8-byte buffer where to store current task ID.
*
* @return Always returns 0.
*/
/kernel/trunk/generic/src/proc/thread.c
26,6 → 26,11
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file thread.c
* @brief Thread management functions.
*/
 
#include <proc/scheduler.h>
#include <proc/thread.h>
#include <proc/task.h>
/kernel/trunk/generic/src/lib/elf.c
147,7 → 147,7
*
* @param entry Program header entry describing segment to be loaded.
* @param elf ELF header.
* @parma as Address space into wich the ELF is being loaded.
* @param as Address space into wich the ELF is being loaded.
*
* @return EE_OK on success, error code otherwise.
*/
/kernel/trunk/generic/src/adt/btree.c
26,13 → 26,17
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/*
* This B-tree has the following properties:
* - it is a ballanced 3-4-5 tree (i.e. BTREE_M = 5)
* - values (i.e. pointers to values) are stored only in leaves
* - leaves are linked in a list
* - technically, it is a B+tree (because of the previous properties)
/**
* @file btree.c
* @brief B+tree implementation.
*
* This file implements B+tree type and operations.
*
* The B+tree has the following properties:
* @li it is a ballanced 3-4-5 tree (i.e. BTREE_M = 5)
* @li values (i.e. pointers to values) are stored only in leaves
* @li leaves are linked in a list
*
* Be carefull when using these trees. They need to allocate
* and deallocate memory for their index nodes and as such
* can sleep.
/kernel/trunk/generic/src/adt/hash_table.c
26,8 → 26,11
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/*
* This is an implementation of generic chained hash table.
/**
* @file hash_table.c
* @brief Implementation of generic chained hash table.
*
* This file contains implementation of generic chained hash table.
*/
 
#include <adt/hash_table.h>
125,7 → 128,7
*
* @param h Hash table.
* @param key Array of keys that will be compared against items of the hash table.
* @param keys Number of keys in the 'key' array.
* @param keys Number of keys in the key array.
*/
void hash_table_remove(hash_table_t *h, __native key[], count_t keys)
{
/kernel/trunk/generic/src/adt/list.c
26,9 → 26,16
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file list.c
* @brief Functions completing doubly linked circular list implementaion.
*
* This file contains some of the functions implementing doubly linked circular lists.
* However, this ADT is mostly implemented in @ref list.h.
*/
 
#include <adt/list.h>
 
 
/** Check for membership
*
* Check whether link is contained in the list head.
/kernel/trunk/generic/src/adt/bitmap.c
26,6 → 26,14
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file bitmap.c
* @brief Implementation of bitmap ADT.
*
* This file implements bitmap ADT and provides functions for
* setting and clearing ranges of bits.
*/
 
#include <adt/bitmap.h>
#include <typedefs.h>
#include <arch/types.h>
/kernel/trunk/generic/src/mm/slab.c
26,32 → 26,35
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/*
* The SLAB allocator is closely modelled after OpenSolaris SLAB allocator
* http://www.usenix.org/events/usenix01/full_papers/bonwick/bonwick_html/
/**
* @file slab.c
* @brief Slab allocator.
*
* The slab allocator is closely modelled after OpenSolaris slab allocator.
* @see http://www.usenix.org/events/usenix01/full_papers/bonwick/bonwick_html/
*
* with the following exceptions:
* - empty SLABS are deallocated immediately
* @li empty slabs are deallocated immediately
* (in Linux they are kept in linked list, in Solaris ???)
* - empty magazines are deallocated when not needed
* @li empty magazines are deallocated when not needed
* (in Solaris they are held in linked list in slab cache)
*
* Following features are not currently supported but would be easy to do:
* - cache coloring
* - dynamic magazine growing (different magazine sizes are already
* Following features are not currently supported but would be easy to do:
* @li cache coloring
* @li dynamic magazine growing (different magazine sizes are already
* supported, but we would need to adjust allocation strategy)
*
* The SLAB allocator supports per-CPU caches ('magazines') to facilitate
* The slab allocator supports per-CPU caches ('magazines') to facilitate
* good SMP scaling.
*
* When a new object is being allocated, it is first checked, if it is
* available in CPU-bound magazine. If it is not found there, it is
* allocated from CPU-shared SLAB - if partial full is found, it is used,
* allocated from CPU-shared slab - if partial full is found, it is used,
* otherwise a new one is allocated.
*
* When an object is being deallocated, it is put to CPU-bound magazine.
* If there is no such magazine, new one is allocated (if it fails,
* the object is deallocated into SLAB). If the magazine is full, it is
* the object is deallocated into slab). If the magazine is full, it is
* put into cpu-shared list of magazines and new one is allocated.
*
* The CPU-bound magazine is actually a pair of magazine to avoid
60,15 → 63,15
* as much as possible.
*
* Every cache contains list of full slabs and list of partialy full slabs.
* Empty SLABS are immediately freed (thrashing will be avoided because
* Empty slabs are immediately freed (thrashing will be avoided because
* of magazines).
*
* The SLAB information structure is kept inside the data area, if possible.
* The slab information structure is kept inside the data area, if possible.
* The cache can be marked that it should not use magazines. This is used
* only for SLAB related caches to avoid deadlocks and infinite recursion
* (the SLAB allocator uses itself for allocating all it's control structures).
* only for slab related caches to avoid deadlocks and infinite recursion
* (the slab allocator uses itself for allocating all it's control structures).
*
* The SLAB allocator allocates lot of space and does not free it. When
* The slab allocator allocates lot of space and does not free it. When
* frame allocator fails to allocate the frame, it calls slab_reclaim().
* It tries 'light reclaim' first, then brutal reclaim. The light reclaim
* releases slabs from cpu-shared magazine-list, until at least 1 slab
76,7 → 79,8
* The brutal reclaim removes all cached objects, even from CPU-bound
* magazines.
*
* TODO: For better CPU-scaling the magazine allocation strategy should
* TODO:@n
* For better CPU-scaling the magazine allocation strategy should
* be extended. Currently, if the cache does not have magazine, it asks
* for non-cpu cached magazine cache to provide one. It might be feasible
* to add cpu-cached magazine cache (which would allocate it's magazines
85,12 → 89,11
* 'empty-magazine-list', which decreases competing for 1 per-system
* magazine cache.
*
* - it might be good to add granularity of locks even to slab level,
* we could then try_spinlock over all partial slabs and thus improve
* scalability even on slab level
* @li it might be good to add granularity of locks even to slab level,
* we could then try_spinlock over all partial slabs and thus improve
* scalability even on slab level
*/
 
 
#include <synch/spinlock.h>
#include <mm/slab.h>
#include <adt/list.h>
113,7 → 116,7
static slab_cache_t slab_cache_cache;
/** Cache for external slab descriptors
* This time we want per-cpu cache, so do not make it static
* - using SLAB for internal SLAB structures will not deadlock,
* - using slab for internal slab structures will not deadlock,
* as all slab structures are 'small' - control structures of
* their caches do not require further allocation
*/
141,7 → 144,7
#endif
 
/**************************************/
/* SLAB allocation functions */
/* Slab allocation functions */
 
/**
* Allocate frames for slab space and initialize
190,7 → 193,7
}
 
/**
* Deallocate space associated with SLAB
* Deallocate space associated with slab
*
* @return number of freed frames
*/
212,7 → 215,7
}
 
/**************************************/
/* SLAB functions */
/* Slab functions */
 
 
/**
273,7 → 276,7
 
if (list_empty(&cache->partial_slabs)) {
/* Allow recursion and reclaiming
* - this should work, as the SLAB control structures
* - this should work, as the slab control structures
* are small and do not need to allocte with anything
* other ten frame_alloc when they are allocating,
* that's why we should get recursion at most 1-level deep
509,7 → 512,7
 
 
/**************************************/
/* SLAB CACHE functions */
/* Slab cache functions */
 
/** Return number of objects that fit in certain cache size */
static int comp_objects(slab_cache_t *cache)
789,7 → 792,7
ipl = interrupts_disable();
spinlock_lock(&slab_cache_lock);
printf("SLAB name\t Osize\t Pages\t Obj/pg\t Slabs\t Cached\tAllocobjs\tCtl\n");
printf("slab name\t Osize\t Pages\t Obj/pg\t Slabs\t Cached\tAllocobjs\tCtl\n");
for (cur = slab_cache_list.next;cur!=&slab_cache_list; cur=cur->next) {
cache = list_get_instance(cur, slab_cache_t, link);
printf("%s\t%7zd\t%7zd\t%7zd\t%7zd\t%7zd\t%7zd\t\t%s\n", cache->name, cache->size,
/kernel/trunk/generic/src/mm/tlb.c
26,6 → 26,11
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file tlb.c
* @brief Generic TLB shootdown algorithm.
*/
 
#include <mm/tlb.h>
#include <mm/asid.h>
#include <arch/mm/tlb.h>
/kernel/trunk/generic/src/mm/as.c
26,10 → 26,20
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/*
/**
* @file as.c
* @brief Address space related functions.
*
* This file contains address space manipulation functions.
* Roughly speaking, this is a higher-level client of
* Virtual Address Translation (VAT) subsystem.
*
* Functionality provided by this file allows one to
* create address space and create, resize and share
* address space areas.
*
* @see page.c
*
*/
 
#include <mm/as.h>
684,7 → 694,7
* call in which case the lock argument is false.
*
* @param as Address space.
* @param as_locked If false, do not attempt to lock as->lock.
* @param lock If false, do not attempt to lock as->lock.
*/
void page_table_lock(as_t *as, bool lock)
{
697,7 → 707,7
/** Unlock page table.
*
* @param as Address space.
* @param as_locked If false, do not attempt to unlock as->lock.
* @param unlock If false, do not attempt to unlock as->lock.
*/
void page_table_unlock(as_t *as, bool unlock)
{
/kernel/trunk/generic/src/mm/buddy.c
26,6 → 26,15
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file buddy.c
* @brief Buddy allocator framework.
*
* This file contains buddy system allocator framework.
* Specialized functions are needed for this abstract framework
* to be useful.
*/
 
#include <mm/buddy.h>
#include <mm/frame.h>
#include <arch/types.h>
/kernel/trunk/generic/src/mm/frame.c
27,6 → 27,16
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/**
* @file frame.c
* @brief Physical frame allocator.
*
* This file contains the physical frame allocator and memory zone management.
* The frame allocator is built on top of the buddy allocator.
*
* @see buddy.c
*/
 
/*
* Locking order
*
/kernel/trunk/generic/src/mm/page.c
26,8 → 26,14
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
/*
* Virtual Address Translation subsystem.
/**
* @file page.c
* @brief Virtual Address Translation subsystem.
*
* This file contains code for creating, destroying and searching
* mappings between virtual addresses and physical addresses.
* Functions here are mere wrappers that call the real implementation.
* They however, define the single interface.
*/
 
#include <mm/page.h>
73,8 → 79,8
 
/** Insert mapping of page to frame.
*
* Map virtual address @page to physical address @frame
* using @flags. Allocate and setup any missing page tables.
* Map virtual address page to physical address frame
* using flags. Allocate and setup any missing page tables.
*
* The page table must be locked and interrupts must be disabled.
*
93,7 → 99,7
 
/** Remove mapping of page.
*
* Remove any mapping of @page within address space @as.
* Remove any mapping of page within address space as.
* TLB shootdown should follow in order to make effects of
* this call visible.
*
/kernel/trunk/generic/src/ipc/sysipc.c
429,8 → 429,6
/** Wait for incoming ipc call or answer
*
* @param calldata Pointer to buffer where the call/answer data is stored
* @param taskid On 'CONNECT_ME_TO' call it is filled with 'taskid' of
* the caller.
* @param flags
* @return Callid, if callid & 1, then the call is answer
*/