WebSVN – HelenOS – Path Comparison – / – /branches/tracing/kernel/generic/ Rev 3424 and /branches/tracing/kernel/generic/ Rev 3425

Ignore whitespace Rev 3424 → Rev 3425

 /branches/tracing/kernel/generic/include/config.h
 ,8 → 40,6
 #define STACK_SIZE      PAGE_SIZE
-#define CONFIG_MEMORY_SIZE  (8 * 1024 * 1024)
 #define CONFIG_INIT_TASKS   32
 typedef struct {

/branches/tracing/kernel/generic/include/proc/task.h
145,7 → 145,6
#endif

extern unative_t sys_task_get_id(task_id_t *uspace_task_id);
extern unative_t sys_task_spawn(void *image, size_t size);

#endif

 /branches/tracing/kernel/generic/include/proc/thread.h
 ,8 → 252,6
 extern void thread_update_accounting(void);
 extern bool thread_exists(thread_t *t);
-extern thread_t *thread_create_program(void *program_addr, char *name);
 /** Fpu context slab cache. */
 extern slab_cache_t *fpu_context_slab;

 /branches/tracing/kernel/generic/include/proc/program.h
 ,0 → 1,65
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup genericproc
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_PROGRAM_H_
+#define KERN_PROGRAM_H_
+#include <arch/types.h>
+struct task;
+struct thread;
+/** Program info structure.
+ *
+ * A program is an abstraction of a freshly created (not yet running)
+ * userspace task containing a main thread along with its userspace stack.
+ */
+typedef struct program {
+    struct task *task;      /**< Program task */
+    struct thread *main_thread; /**< Program main thread */
+} program_t;
+extern void *program_loader;
+extern void program_create(as_t *as, uintptr_t entry_addr, program_t *p);
+extern int program_create_from_image(void *image_addr, program_t *p);
+extern int program_create_loader(program_t *p);
+extern void program_ready(program_t *p);
+extern unative_t sys_program_spawn_loader(int *uspace_phone_id);
+#endif
+/** @}
+ */

/branches/tracing/kernel/generic/include/lib/objc_ext.h
File deleted

/branches/tracing/kernel/generic/include/lib/objc.h
File deleted

 /branches/tracing/kernel/generic/include/lib/elf.h
 ,7 → 114,8
 #define EE_MEMORY       2   /* Cannot allocate address space */
 #define EE_INCOMPATIBLE     3   /* ELF image is not compatible with current architecture */
 #define EE_UNSUPPORTED      4   /* Non-supported ELF (e.g. dynamic ELFs) */
-#define EE_IRRECOVERABLE    5
+#define EE_LOADER       5   /* The image is actually a program loader */
+#define EE_IRRECOVERABLE    6
 /**
  * ELF section types
 ,6 → 339,10
 extern char *elf_error(unsigned int rc);
+/* Interpreter string used to recognize the program loader */
+#define ELF_INTERP_ZSTR "kernel"
+#define ELF_INTERP_ZLEN  sizeof(ELF_INTERP_ZSTR)
 #endif
 /** @}

 /branches/tracing/kernel/generic/include/synch/mutex.h
 ,20 → 39,26
 #include <synch/semaphore.h>
 #include <synch/synch.h>
+typedef enum {
+    MUTEX_PASSIVE,
+    MUTEX_ACTIVE
+} mutex_type_t;
 typedef struct {
+    mutex_type_t type;
     semaphore_t sem;
 } mutex_t;
-#define mutex_lock(mtx) \
+#define mutex_lock(mtx)         \
     _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
-#define mutex_trylock(mtx) \
+#define mutex_trylock(mtx)      \
     _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING)
-#define mutex_lock_timeout(mtx, usec) \
+#define mutex_lock_timeout(mtx, usec)   \
     _mutex_lock_timeout((mtx), (usec), SYNCH_FLAGS_NON_BLOCKING)
-extern void mutex_initialize(mutex_t *mtx);
-extern int _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, int flags);
-extern void mutex_unlock(mutex_t *mtx);
+extern void mutex_initialize(mutex_t *, mutex_type_t);
+extern int _mutex_lock_timeout(mutex_t *, uint32_t, int);
+extern void mutex_unlock(mutex_t *);
 #endif

 /branches/tracing/kernel/generic/include/synch/smc.h
 ,0 → 1,43
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup sync
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_SMC_H_
+#define KERN_SMC_H_
+extern unative_t sys_smc_coherence(uintptr_t va, size_t size);
+#endif
+/** @}
+ */

 /branches/tracing/kernel/generic/include/mm/frame.h
 ,15 → 57,14
 /** Maximum number of zones in system. */
 #define ZONES_MAX           16
-/** If possible, merge with neighbouring zones. */
-#define ZONE_JOIN           0x1
 /** Convert the frame address to kernel va. */
 #define FRAME_KA        0x1
 /** Do not panic and do not sleep on failure. */
-#define FRAME_ATOMIC            0x2
+#define FRAME_ATOMIC        0x2
 /** Do not start reclaiming when no free memory. */
-#define FRAME_NO_RECLAIM        0x4
+#define FRAME_NO_RECLAIM    0x4
+/** Do not allocate above 4 GiB. */
+#define FRAME_LOW_4_GiB     0x8
 static inline uintptr_t PFN2ADDR(pfn_t frame)
 {
 ,30 → 89,30
 }
 #define IS_BUDDY_ORDER_OK(index, order)     \
-    ((~(((unative_t) -1) << (order)) & (index)) == 0)
+    ((~(((unative_t) -1) << (order)) & (index)) == 0)
 #define IS_BUDDY_LEFT_BLOCK(zone, frame)    \
-    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
+    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
 #define IS_BUDDY_RIGHT_BLOCK(zone, frame)   \
-    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
+    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
 #define IS_BUDDY_LEFT_BLOCK_ABS(zone, frame)    \
-    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
+    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
 #define IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame)   \
-    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
+    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
 #define frame_alloc(order, flags)       \
-    frame_alloc_generic(order, flags, NULL)
+    frame_alloc_generic(order, flags, NULL)
 extern void frame_init(void);
-extern void *frame_alloc_generic(uint8_t order, int flags, unsigned int *pzone);
-extern void frame_free(uintptr_t frame);
-extern void frame_reference_add(pfn_t pfn);
+extern void *frame_alloc_generic(uint8_t, int, unsigned int *);
+extern void frame_free(uintptr_t);
+extern void frame_reference_add(pfn_t);
-extern int zone_create(pfn_t start, count_t count, pfn_t confframe, int flags);
-extern void *frame_get_parent(pfn_t frame, unsigned int hint);
-extern void frame_set_parent(pfn_t frame, void *data, unsigned int hint);
-extern void frame_mark_unavailable(pfn_t start, count_t count);
-extern uintptr_t zone_conf_size(count_t count);
-extern void zone_merge(unsigned int z1, unsigned int z2);
+extern int zone_create(pfn_t, count_t, pfn_t, int);
+extern void *frame_get_parent(pfn_t, unsigned int);
+extern void frame_set_parent(pfn_t, void *, unsigned int);
+extern void frame_mark_unavailable(pfn_t, count_t);
+extern uintptr_t zone_conf_size(count_t);
+extern void zone_merge(unsigned int, unsigned int);
 extern void zone_merge_all(void);
 extern uint64_t zone_total_size(void);
 ,7 → 120,7
  * Console functions
  */
 extern void zone_print_list(void);
-extern void zone_print_one(unsigned int znum);
+extern void zone_print_one(unsigned int);
 #endif

 /branches/tracing/kernel/generic/include/mm/page.h
 ,11 → 39,6
 #include <mm/as.h>
 #include <memstr.h>
-/**
- * Macro for computing page color.
- */
-#define PAGE_COLOR(va)  (((va) >> PAGE_WIDTH) & ((1 << PAGE_COLOR_BITS) - 1))
 /** Operations to manipulate page mappings. */
 typedef struct {
     void (* mapping_insert)(as_t *as, uintptr_t page, uintptr_t frame,

 /branches/tracing/kernel/generic/include/mm/slab.h
 ,7 → 53,8
 #define SLAB_INSIDE_SIZE   (PAGE_SIZE >> 3)
 /** Maximum wasted space we allow for cache */
-#define SLAB_MAX_BADNESS(cache)   (((unsigned int) PAGE_SIZE << (cache)->order) >> 2)
+#define SLAB_MAX_BADNESS(cache) \
+    (((unsigned int) PAGE_SIZE << (cache)->order) >> 2)
 /* slab_reclaim constants */
 ,7 → 100,7
     int flags;
     /* Computed values */
-    uint8_t order;              /**< Order of frames to be allocated */
+    uint8_t order;          /**< Order of frames to be allocated */
     unsigned int objects;       /**< Number of objects that fit in */
     /* Statistics */
 ,14 → 122,13
     slab_mag_cache_t *mag_cache;
 } slab_cache_t;
-extern slab_cache_t * slab_cache_create(char *name, size_t size, size_t align,
-    int (*constructor)(void *obj, int kmflag), int (*destructor)(void *obj),
-    int flags);
-extern void slab_cache_destroy(slab_cache_t *cache);
+extern slab_cache_t *slab_cache_create(char *, size_t, size_t,
+    int (*)(void *, int), int (*)(void *), int);
+extern void slab_cache_destroy(slab_cache_t *);
-extern void * slab_alloc(slab_cache_t *cache, int flags);
-extern void slab_free(slab_cache_t *cache, void *obj);
-extern count_t slab_reclaim(int flags);
+extern void * slab_alloc(slab_cache_t *, int);
+extern void slab_free(slab_cache_t *, void *);
+extern count_t slab_reclaim(int);
 /* slab subsytem initialization */
 extern void slab_cache_init(void);
 ,9 → 138,9
 extern void slab_print_list(void);
 /* malloc support */
-extern void * malloc(unsigned int size, int flags);
-extern void * realloc(void *ptr, unsigned int size, int flags);
-extern void free(void *ptr);
+extern void *malloc(unsigned int, int);
+extern void *realloc(void *, unsigned int, int);
+extern void free(void *);
 #endif
 /** @}

 /branches/tracing/kernel/generic/include/mm/as.h
 ,10 → 53,6
 #include <adt/btree.h>
 #include <lib/elf.h>
-#ifdef __OBJC__
-#include <lib/objc.h>
-#endif
 /**
  * Defined to be true if user address space and kernel address space shadow each
  * other.
 ,47 → 80,6
 /** The page fault was caused by memcpy_from_uspace() or memcpy_to_uspace(). */
 #define AS_PF_DEFER     2
-#ifdef __OBJC__
-@interface as_t : base_t {
-    @public
-        /** Protected by asidlock. */
-        link_t inactive_as_with_asid_link;
-        /**
-         * Number of processors on wich is this address space active.
-         * Protected by asidlock.
-         */
-        count_t cpu_refcount;
-        /**
-         * Address space identifier.
-         * Constant on architectures that do not support ASIDs.
-         * Protected by asidlock.
-         */
-        asid_t asid;
-        /** Number of references (i.e tasks that reference this as). */
-        atomic_t refcount;
-        mutex_t lock;
-        /** B+tree of address space areas. */
-        btree_t as_area_btree;
-        /** Non-generic content. */
-        as_genarch_t genarch;
-        /** Architecture specific content. */
-        as_arch_t arch;
-}
-+ (pte_t *) page_table_create: (int) flags;
-+ (void) page_table_destroy: (pte_t *) page_table;
-- (void) page_table_lock: (bool) _lock;
-- (void) page_table_unlock: (bool) unlock;
-@end
-#else
 /** Address space structure.
  *
  * as_t contains the list of as_areas of userspace accessible
 ,7 → 123,6
     void (* page_table_lock)(as_t *as, bool lock);
     void (* page_table_unlock)(as_t *as, bool unlock);
 } as_operations_t;
-#endif
 /**
  * This structure contains information associated with the shared address space
 ,10 → 203,7
 extern as_t *AS_KERNEL;
-#ifndef __OBJC__
 extern as_operations_t *as_operations;
-#endif
 extern link_t inactive_as_with_asid_head;
 extern void as_init(void);
 ,6 → 220,7
 extern int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags);
 int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
     as_t *dst_as, uintptr_t dst_base, int dst_flags_mask);
+extern int as_area_change_flags(as_t *as, int flags, uintptr_t address);
 extern int as_area_get_flags(as_area_t *area);
 extern bool as_area_check_access(as_area_t *area, pf_access_t access);
 ,11 → 253,19
 extern mem_backend_t elf_backend;
 extern mem_backend_t phys_backend;
-extern unsigned int elf_load(elf_header_t *header, as_t *as);
+/**
+ * This flags is passed when running the loader, otherwise elf_load()
+ * would return with a EE_LOADER error code.
+ */
+#define ELD_F_NONE  0
+#define ELD_F_LOADER    1
+extern unsigned int elf_load(elf_header_t *header, as_t *as, int flags);
 /* Address space area related syscalls. */
 extern unative_t sys_as_area_create(uintptr_t address, size_t size, int flags);
 extern unative_t sys_as_area_resize(uintptr_t address, size_t size, int flags);
+extern unative_t sys_as_area_change_flags(uintptr_t address, int flags);
 extern unative_t sys_as_area_destroy(uintptr_t address);
 /* Introspection functions. */

 /branches/tracing/kernel/generic/include/mm/buddy.h
 ,7 → 66,6
     void (*mark_available)(struct buddy_system *, link_t *);
     /** Find parent of block that has given order  */
     link_t *(* find_block)(struct buddy_system *, link_t *, uint8_t);
-    void (* print_id)(struct buddy_system *, link_t *);
 } buddy_system_operations_t;
 typedef struct buddy_system {
 ,14 → 77,13
     void *data;
 } buddy_system_t;
-extern void buddy_system_create(buddy_system_t *b, uint8_t max_order,
-    buddy_system_operations_t *op, void *data);
-extern link_t *buddy_system_alloc(buddy_system_t *b, uint8_t i);
-extern bool buddy_system_can_alloc(buddy_system_t *b, uint8_t order);
-extern void buddy_system_free(buddy_system_t *b, link_t *block);
-extern void buddy_system_structure_print(buddy_system_t *b, size_t elem_size);
-extern size_t buddy_conf_size(int max_order);
-extern link_t *buddy_system_alloc_block(buddy_system_t *b, link_t *block);
+extern void buddy_system_create(buddy_system_t *, uint8_t,
+    buddy_system_operations_t *, void *);
+extern link_t *buddy_system_alloc(buddy_system_t *, uint8_t);
+extern bool buddy_system_can_alloc(buddy_system_t *, uint8_t);
+extern void buddy_system_free(buddy_system_t *, link_t *);
+extern size_t buddy_conf_size(int);
+extern link_t *buddy_system_alloc_block(buddy_system_t *, link_t *);
 #endif

 /branches/tracing/kernel/generic/include/macros.h
 ,20 → 40,20
 #define isdigit(d)  (((d) >= '0') && ((d) <= '9'))
 #define islower(c)  (((c) >= 'a') && ((c) <= 'z'))
 #define isupper(c)  (((c) >= 'A') && ((c) <= 'Z'))
-#define isalpha(c)  (is_lower(c) || is_upper(c))
-#define isalphanum(c)   (is_alpha(c) || is_digit(c))
+#define isalpha(c)  (is_lower((c)) || is_upper((c)))
+#define isalphanum(c)   (is_alpha((c)) || is_digit((c)))
 #define isspace(c)  (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || \
-                ((c) == '\r'))
+                ((c) == '\r'))
 #define min(a,b)    ((a) < (b) ? (a) : (b))
 #define max(a,b)    ((a) > (b) ? (a) : (b))
-/** Return true if the interlvals overlap.
+/** Return true if the intervals overlap.
  *
- * @param s1 Start address of the first interval.
- * @param sz1 Size of the first interval.
- * @param s2 Start address of the second interval.
- * @param sz2 Size of the second interval.
+ * @param s1        Start address of the first interval.
+ * @param sz1       Size of the first interval.
+ * @param s2        Start address of the second interval.
+ * @param sz2       Size of the second interval.
  */
 static inline int overlaps(uintptr_t s1, size_t sz1, uintptr_t s2, size_t sz2)
 {
 ,11 → 64,15
 }
 /* Compute overlapping of physical addresses */
-#define PA_overlaps(x, szx, y, szy) overlaps(KA2PA(x), szx, KA2PA(y), szy)
+#define PA_overlaps(x, szx, y, szy) \
+    overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
-#define SIZE2KB(size) (size >> 10)
-#define SIZE2MB(size) (size >> 20)
+#define SIZE2KB(size) ((size) >> 10)
+#define SIZE2MB(size) ((size) >> 20)
+#define KB2SIZE(kb) ((kb) << 10)
+#define MB2SIZE(mb) ((mb) << 20)
 #define STRING(arg) STRING_ARG(arg)
 #define STRING_ARG(arg) #arg

 /branches/tracing/kernel/generic/include/syscall/syscall.h
 ,13 → 44,15
     SYS_THREAD_GET_ID,
     SYS_TASK_GET_ID,
-    SYS_TASK_SPAWN,
+    SYS_PROGRAM_SPAWN_LOADER,
     SYS_FUTEX_SLEEP,
     SYS_FUTEX_WAKEUP,
+    SYS_SMC_COHERENCE,
     SYS_AS_AREA_CREATE,
     SYS_AS_AREA_RESIZE,
+    SYS_AS_AREA_CHANGE_FLAGS,
     SYS_AS_AREA_DESTROY,
     SYS_IPC_CALL_SYNC_FAST,

 /branches/tracing/kernel/generic/include/ipc/ipc.h
 ,27 → 287,33
     /** Buffer for IPC_M_DATA_WRITE and IPC_M_DATA_READ. */
     uint8_t *buffer;
+    /*
+     * The forward operation can masquerade the caller phone. For those
+     * cases, we must keep it aside so that the answer is processed
+     * correctly.
+     */
+    phone_t *caller_phone;
 } call_t;
 extern void ipc_init(void);
-extern call_t * ipc_wait_for_call(answerbox_t *box, uint32_t usec, int flags);
-extern void ipc_answer(answerbox_t *box, call_t *request);
-extern int ipc_call(phone_t *phone, call_t *call);
-extern void ipc_call_sync(phone_t *phone, call_t *request);
-extern void ipc_phone_init(phone_t *phone);
-extern void ipc_phone_connect(phone_t *phone, answerbox_t *box);
-extern void ipc_call_free(call_t *call);
-extern call_t * ipc_call_alloc(int flags);
-extern void ipc_answerbox_init(answerbox_t *box, struct task *task);
-extern void ipc_call_static_init(call_t *call);
+extern call_t * ipc_wait_for_call(answerbox_t *, uint32_t, int);
+extern void ipc_answer(answerbox_t *, call_t *);
+extern int ipc_call(phone_t *, call_t *);
+extern int ipc_call_sync(phone_t *, call_t *);
+extern void ipc_phone_init(phone_t *);
+extern void ipc_phone_connect(phone_t *, answerbox_t *);
+extern void ipc_call_free(call_t *);
+extern call_t * ipc_call_alloc(int);
+extern void ipc_answerbox_init(answerbox_t *, struct task *);
+extern void ipc_call_static_init(call_t *);
 extern void task_print_list(void);
-extern int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox,
-    int mode);
+extern int ipc_forward(call_t *, phone_t *, answerbox_t *, int);
 extern void ipc_cleanup(void);
-extern int ipc_phone_hangup(phone_t *phone);
-extern void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err);
-extern void ipc_print_task(task_id_t taskid);
-extern int ipc_connect_kbox(task_id_t taskid);
+extern int ipc_phone_hangup(phone_t *);
+extern void ipc_backsend_err(phone_t *, call_t *, unative_t);
+extern void ipc_print_task(task_id_t);
+extern int ipc_connect_kbox(task_id_t);
 extern answerbox_t *ipc_phone_0;

/branches/tracing/kernel/generic/include/errno.h
56,6 → 56,7
#define EINVAL -13 /* Invalid value */
#define EBUSY -14 /* Resource is busy */
#define EOVERFLOW -15 /* The result does not fit its size. */
#define EINTR -16 /* Operation was interrupted. */

#endif

 /branches/tracing/kernel/generic/src/synch/rwlock.c
 ,7 → 82,7
  */
 void rwlock_initialize(rwlock_t *rwl) {
     spinlock_initialize(&rwl->lock, "rwlock_t");
-    mutex_initialize(&rwl->exclusive);
+    mutex_initialize(&rwl->exclusive, MUTEX_PASSIVE);
     rwl->readers_in = 0;
 }

 /branches/tracing/kernel/generic/src/synch/mutex.c
 ,42 → 38,54
 #include <synch/mutex.h>
 #include <synch/semaphore.h>
 #include <synch/synch.h>
+#include <debug.h>
-/** Initialize mutex
+/** Initialize mutex.
  *
- * Initialize mutex.
- *
- * @param mtx Mutex.
+ * @param mtx       Mutex.
+ * @param type      Type of the mutex.
  */
-void mutex_initialize(mutex_t *mtx)
+void mutex_initialize(mutex_t *mtx, mutex_type_t type)
 {
+    mtx->type = type;
     semaphore_initialize(&mtx->sem, 1);
 }
-/** Acquire mutex
+/** Acquire mutex.
  *
- * Acquire mutex.
  * Timeout mode and non-blocking mode can be requested.
  *
- * @param mtx Mutex.
- * @param usec Timeout in microseconds.
- * @param flags Specify mode of operation.
+ * @param mtx       Mutex.
+ * @param usec      Timeout in microseconds.
+ * @param flags     Specify mode of operation.
  *
  * For exact description of possible combinations of
  * usec and flags, see comment for waitq_sleep_timeout().
  *
- * @return See comment for waitq_sleep_timeout().
+ * @return      See comment for waitq_sleep_timeout().
  */
 int _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, int flags)
 {
-    return _semaphore_down_timeout(&mtx->sem, usec, flags);
+    int rc;
+    if (mtx->type == MUTEX_PASSIVE) {
+        rc = _semaphore_down_timeout(&mtx->sem, usec, flags);
+    } else {
+        ASSERT(mtx->type == MUTEX_ACTIVE);
+        ASSERT(usec == SYNCH_NO_TIMEOUT);
+        ASSERT(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
+        do {
+            rc = semaphore_trydown(&mtx->sem);
+        } while (SYNCH_FAILED(rc) &&
+            !(flags & SYNCH_FLAGS_NON_BLOCKING));
+    }
+    return rc;
 }
-/** Release mutex
+/** Release mutex.
  *
- * Release mutex.
- *
- * @param mtx Mutex.
+ * @param mtx       Mutex.
  */
 void mutex_unlock(mutex_t *mtx)
 {

 /branches/tracing/kernel/generic/src/synch/smc.c
 ,0 → 1,60
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup sync
+ * @{
+ */
+/**
+ * @file
+ * @brief   Self-modifying code barriers.
+ */
+#include <arch.h>
+#include <macros.h>
+#include <errno.h>
+#include <arch/barrier.h>
+#include <synch/smc.h>
+unative_t sys_smc_coherence(uintptr_t va, size_t size)
+{
+    if (overlaps(va, size, NULL, PAGE_SIZE))
+        return EINVAL;
+    if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
+        if (overlaps(va, size, KERNEL_ADDRESS_SPACE_START,
+            KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START))
+            return EINVAL;
+    }
+    smc_coherence_block((void *) va, size);
+    return 0;
+}
+/** @}
+ */

 /branches/tracing/kernel/generic/src/synch/condvar.c
 ,7 → 43,7
 /** Initialize condition variable.
  *
- * @param cv Condition variable.
+ * @param cv        Condition variable.
  */
 void condvar_initialize(condvar_t *cv)
 {
 ,11 → 50,10
     waitq_initialize(&cv->wq);
 }
-/**
- * Signal the condition has become true
- * to the first waiting thread by waking it up.
+/** Signal the condition has become true to the first waiting thread by waking
+ * it up.
  *
- * @param cv Condition variable.
+ * @param cv        Condition variable.
  */
 void condvar_signal(condvar_t *cv)
 {
 ,11 → 60,10
     waitq_wakeup(&cv->wq, WAKEUP_FIRST);
 }
-/**
- * Signal the condition has become true
- * to all waiting threads by waking them up.
+/** Signal the condition has become true to all waiting threads by waking
+ * them up.
  *
- * @param cv Condition variable.
+ * @param cv        Condition variable.
  */
 void condvar_broadcast(condvar_t *cv)
 {
 ,17 → 72,17
 /** Wait for the condition becoming true.
  *
- * @param cv Condition variable.
- * @param mtx Mutex.
- * @param usec Timeout value in microseconds.
- * @param flags Select mode of operation.
+ * @param cv        Condition variable.
+ * @param mtx       Mutex.
+ * @param usec      Timeout value in microseconds.
+ * @param flags     Select mode of operation.
  *
- * For exact description of meaning of possible combinations
- * of usec and flags, see comment for waitq_sleep_timeout().
- * Note that when SYNCH_FLAGS_NON_BLOCKING is specified here,
- * ESYNCH_WOULD_BLOCK is always returned.
+ * For exact description of meaning of possible combinations of usec and flags,
+ * see comment for waitq_sleep_timeout().  Note that when
+ * SYNCH_FLAGS_NON_BLOCKING is specified here, ESYNCH_WOULD_BLOCK is always
+ * returned.
  *
- * @return See comment for waitq_sleep_timeout().
+ * @return      See comment for waitq_sleep_timeout().
  */
 int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec, int flags)
 {

 /branches/tracing/kernel/generic/src/main/kinit.c
 ,6 → 47,7
 #include <proc/scheduler.h>
 #include <proc/task.h>
 #include <proc/thread.h>
+#include <proc/program.h>
 #include <panic.h>
 #include <func.h>
 #include <cpu.h>
 ,7 → 147,8
     /*
      * Create kernel console.
      */
-    t = thread_create(kconsole, (void *) "kconsole", TASK, 0, "kconsole", false);
+    t = thread_create(kconsole, (void *) "kconsole", TASK, 0, "kconsole",
+        false);
     if (t)
         thread_ready(t);
     else
 ,7 → 160,7
      * Create user tasks, load RAM disk images.
      */
     count_t i;
-    thread_t *threads[CONFIG_INIT_TASKS];
+    program_t programs[CONFIG_INIT_TASKS];
     for (i = 0; i < init.cnt; i++) {
         if (init.tasks[i].addr % FRAME_SIZE) {
 ,24 → 168,28
             continue;
         }
-        threads[i] = thread_create_program(
-            (void *) init.tasks[i].addr, "uspace");
-        if (threads[i] != NULL) {
+        int rc = program_create_from_image((void *) init.tasks[i].addr,
+            &programs[i]);
+        if (rc == 0 && programs[i].task != NULL) {
             /*
              * Set capabilities to init userspace tasks.
              */
-            cap_set(threads[i]->task, CAP_CAP | CAP_MEM_MANAGER |
+            cap_set(programs[i].task, CAP_CAP | CAP_MEM_MANAGER |
                 CAP_IO_MANAGER | CAP_PREEMPT_CONTROL | CAP_IRQ_REG);
             if (!ipc_phone_0)
-                ipc_phone_0 = &threads[i]->task->answerbox;
+                ipc_phone_0 = &programs[i].task->answerbox;
+        } else if (rc == 0) {
+            /* It was the program loader and was registered */
         } else {
+            /* RAM disk image */
             int rd = init_rd((rd_header_t *) init.tasks[i].addr,
                 init.tasks[i].size);
             if (rd != RE_OK)
-                printf("Init binary %" PRIc " not used, error code %d.\n", i, rd);
+                printf("Init binary %" PRIc " not used, error "
+                    "code %d.\n", i, rd);
         }
     }
 ,9 → 197,9
      * Run user tasks with reasonable delays
      */
     for (i = 0; i < init.cnt; i++) {
-        if (threads[i] != NULL) {
+        if (programs[i].task != NULL) {
             thread_usleep(50000);
-            thread_ready(threads[i]);
+            program_ready(&programs[i]);
         }
     }

 /branches/tracing/kernel/generic/src/main/main.c
 ,6 → 61,7
 #include <main/kinit.h>
 #include <main/version.h>
 #include <console/kconsole.h>
+#include <console/console.h>
 #include <cpu.h>
 #include <align.h>
 #include <interrupt.h>
 ,8 → 81,8
 #include <adt/btree.h>
 #include <smp/smp.h>
 #include <ddi/ddi.h>
-#include <console/console.h>
 /** Global configuration structure. */
 config_t config;
 ,8 → 236,8
     /* Slab must be initialized after we know the number of processors. */
     LOG_EXEC(slab_enable_cpucache());
-    printf("Detected %" PRIc " CPU(s), %" PRIu64" MB free memory\n",
-        config.cpu_count, SIZE2MB(zone_total_size()));
+    printf("Detected %" PRIc " CPU(s), %" PRIu64" MiB free memory\n",
+        config.cpu_count, SIZE2MB(zone_total_size()));
     LOG_EXEC(cpu_init());
 ,8 → 253,8
         count_t i;
         for (i = 0; i < init.cnt; i++)
             printf("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc
-                "].size=%#" PRIs "\n", i, init.tasks[i].addr,
-                i, init.tasks[i].size);
+                "].size=%#" PRIs "\n", i, init.tasks[i].addr, i,
+                init.tasks[i].size);
     } else
         printf("No init binaries found\n");

 /branches/tracing/kernel/generic/src/sysinfo/sysinfo.c
 ,10 → 281,15
     return ret;
 }
+#define SYSINFO_MAX_LEN 1024
 unative_t sys_sysinfo_valid(unative_t ptr, unative_t len)
 {
     char *str;
     sysinfo_rettype_t ret = {0, 0};
+    if (len > SYSINFO_MAX_LEN)
+        return ret.valid;
     str = malloc(len + 1, 0);
     ASSERT(str);
 ,6 → 304,9
 {
     char *str;
     sysinfo_rettype_t ret = {0, 0};
+    if (len > SYSINFO_MAX_LEN)
+        return ret.val;
     str = malloc(len + 1, 0);
     ASSERT(str);

 /branches/tracing/kernel/generic/src/console/kconsole.c
 ,7 → 169,7
 }
 /** Try to find a command beginning with prefix */
-static const char * cmdtab_search_one(const char *name,link_t **startpos)
+static const char *cmdtab_search_one(const char *name,link_t **startpos)
 {
     size_t namelen = strlen(name);
     const char *curname;
 ,7 → 203,7
  */
 static int cmdtab_compl(char *name)
 {
-    static char output[MAX_SYMBOL_NAME+1];
+    static char output[MAX_SYMBOL_NAME + 1];
     link_t *startpos = NULL;
     const char *foundtxt;
     int found = 0;
 ,7 → 213,7
     while ((foundtxt = cmdtab_search_one(name, &startpos))) {
         startpos = startpos->next;
         if (!found)
-            strncpy(output, foundtxt, strlen(foundtxt)+1);
+            strncpy(output, foundtxt, strlen(foundtxt) + 1);
         else {
             for (i = 0; output[i] && foundtxt[i] &&
                 output[i] == foundtxt[i]; i++)
 ,11 → 240,11
 }
-static char * clever_readline(const char *prompt, chardev_t *input)
+static char *clever_readline(const char *prompt, chardev_t *input)
 {
     static int histposition = 0;
-    static char tmp[MAX_CMDLINE+1];
+    static char tmp[MAX_CMDLINE + 1];
     int curlen = 0, position = 0;
     char *current = history[histposition];
     int i;
 ,7 → 257,8
         if (c == '\n') {
             putchar(c);
             break;
-        } if (c == '\b') { /* Backspace */
+        }
+        if (c == '\b') { /* Backspace */
             if (position == 0)
                 continue;
             for (i = position; i < curlen; i++)
 ,7 → 544,8
             buf = (char *) cmd->argv[i].buffer;
             strncpy(buf, (const char *) &cmdline[start],
                 min((end - start) + 2, cmd->argv[i].len));
-            buf[min((end - start) + 1, cmd->argv[i].len - 1)] = '\0';
+            buf[min((end - start) + 1, cmd->argv[i].len - 1)] =
+                '\0';
             break;
         case ARG_TYPE_INT:
             if (parse_int_arg(cmdline + start, end - start + 1,
 ,8 → 562,8
                     '\0';
                 cmd->argv[i].intval = (unative_t) buf;
                 cmd->argv[i].vartype = ARG_TYPE_STRING;
-            } else if (!parse_int_arg(cmdline + start, end - start + 1,
-                &cmd->argv[i].intval)) {
+            } else if (!parse_int_arg(cmdline + start,
+                end - start + 1, &cmd->argv[i].intval)) {
                 cmd->argv[i].vartype = ARG_TYPE_INT;
             } else {
                 printf("Unrecognized variable argument.\n");

 /branches/tracing/kernel/generic/src/proc/scheduler.c
 ,8 → 451,8
             /*
              * Entering state is unexpected.
              */
-            panic("tid%" PRIu64 ": unexpected state %s\n", THREAD->tid,
-                thread_states[THREAD->state]);
+            panic("tid%" PRIu64 ": unexpected state %s\n",
+                THREAD->tid, thread_states[THREAD->state]);
             break;
         }
 ,9 → 504,9
     THREAD->state = Running;
 #ifdef SCHEDULER_VERBOSE
-    printf("cpu%u: tid %" PRIu64 " (priority=%d, ticks=%" PRIu64 ", nrdy=%ld)\n",
-        CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks,
-        atomic_get(&CPU->nrdy));
+    printf("cpu%u: tid %" PRIu64 " (priority=%d, ticks=%" PRIu64
+        ", nrdy=%ld)\n", CPU->id, THREAD->tid, THREAD->priority,
+        THREAD->ticks, atomic_get(&CPU->nrdy));
 #endif
     /*
 ,9 → 640,9
                  */
                 spinlock_lock(&t->lock);
 #ifdef KCPULB_VERBOSE
-                printf("kcpulb%u: TID %" PRIu64 " -> cpu%u, nrdy=%ld, "
-                    "avg=%ld\n", CPU->id, t->tid, CPU->id,
-                    atomic_get(&CPU->nrdy),
+                printf("kcpulb%u: TID %" PRIu64 " -> cpu%u, "
+                    "nrdy=%ld, avg=%ld\n", CPU->id, t->tid,
+                    CPU->id, atomic_get(&CPU->nrdy),
                     atomic_get(&nrdy) / config.cpu_active);
 #endif
                 t->flags |= THREAD_FLAG_STOLEN;

 /branches/tracing/kernel/generic/src/proc/task.c
 ,10 → 35,8
  * @brief   Task management.
  */
-#include <main/uinit.h>
 #include <proc/thread.h>
 #include <proc/task.h>
-#include <proc/uarg.h>
 #include <mm/as.h>
 #include <mm/slab.h>
 #include <atomic.h>
 ,23 → 44,16
 #include <synch/waitq.h>
 #include <arch.h>
 #include <arch/barrier.h>
-#include <panic.h>
 #include <adt/avl.h>
 #include <adt/btree.h>
 #include <adt/list.h>
 #include <ipc/ipc.h>
-#include <security/cap.h>
-#include <memstr.h>
+#include <ipc/ipcrsc.h>
 #include <print.h>
-#include <lib/elf.h>
 #include <errno.h>
 #include <func.h>
 #include <syscall/copy.h>
-#ifndef LOADED_PROG_STACK_PAGES_NO
-#define LOADED_PROG_STACK_PAGES_NO 1
-#endif
 /** Spinlock protecting the tasks_tree AVL tree. */
 SPINLOCK_INITIALIZE(tasks_lock);
 ,11 → 71,7
 static task_id_t task_counter = 0;
-/** Initialize tasks
- *
- * Initialize kernel tasks support.
- *
- */
+/** Initialize kernel tasks support. */
 void task_init(void)
 {
     TASK = NULL;
 ,7 → 79,8
 }
 /*
- * The idea behind this walker is to remember a single task different from TASK.
+ * The idea behind this walker is to remember a single task different from
+ * TASK.
  */
 static bool task_done_walker(avltree_node_t *node, void *arg)
 {
 ,9 → 95,7
     return true;    /* continue the walk */
 }
-/** Kill all tasks except the current task.
- *
- */
+/** Kill all tasks except the current task. */
 void task_done(void)
 {
     task_t *t;
 ,15 → 127,13
     } while (t != NULL);
 }
-/** Create new task
+/** Create new task with no threads.
  *
- * Create new task with no threads.
+ * @param as        Task's address space.
+ * @param name      Symbolic name.
  *
- * @param as Task's address space.
- * @param name Symbolic name.
+ * @return      New task's structure.
  *
- * @return New task's structure
- *
  */
 task_t *task_create(as_t *as, char *name)
 {
 ,7 → 173,7
         ipc_phone_connect(&ta->phones[0], ipc_phone_0);
     atomic_set(&ta->active_calls, 0);
-    mutex_initialize(&ta->futexes_lock);
+    mutex_initialize(&ta->futexes_lock, MUTEX_PASSIVE);
     btree_create(&ta->futexes);
     ipl = interrupts_disable();
 ,7 → 196,7
 /** Destroy task.
  *
- * @param t Task to be destroyed.
+ * @param t     Task to be destroyed.
  */
 void task_destroy(task_t *t)
 {
 ,116 → 229,32
 /** Syscall for reading task ID from userspace.
  *
- * @param uspace_task_id 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 0 on success or an error code from @ref errno.h.
+ * @return      Zero on success or an error code from @ref errno.h.
  */
 unative_t sys_task_get_id(task_id_t *uspace_task_id)
 {
     /*
-     * No need to acquire lock on TASK because taskid
-     * remains constant for the lifespan of the task.
+     * No need to acquire lock on TASK because taskid remains constant for
+     * the lifespan of the task.
      */
     return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
         sizeof(TASK->taskid));
 }
-unative_t sys_task_spawn(void *image, size_t size)
-{
-    void *kimage = malloc(size, 0);
-    if (kimage == NULL)
-        return ENOMEM;
-    int rc = copy_from_uspace(kimage, image, size);
-    if (rc != EOK)
-        return rc;
-    /*
-     * Not very efficient and it would be better to call it on code only,
-     * but this whole function is a temporary hack anyway and one day it
-     * will go in favor of the userspace dynamic loader.
-     */
-    smc_coherence_block(kimage, size);
-    uspace_arg_t *kernel_uarg;
-    kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
-    if (kernel_uarg == NULL) {
-        free(kimage);
-        return ENOMEM;
-    }
-    kernel_uarg->uspace_entry =
-        (void *) ((elf_header_t *) kimage)->e_entry;
-    kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
-    kernel_uarg->uspace_thread_function = NULL;
-    kernel_uarg->uspace_thread_arg = NULL;
-    kernel_uarg->uspace_uarg = NULL;
-    as_t *as = as_create(0);
-    if (as == NULL) {
-        free(kernel_uarg);
-        free(kimage);
-        return ENOMEM;
-    }
-    unsigned int erc = elf_load((elf_header_t *) kimage, as);
-    if (erc != EE_OK) {
-        as_destroy(as);
-        free(kernel_uarg);
-        free(kimage);
-        return ENOENT;
-    }
-    as_area_t *area = as_area_create(as,
-        AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
-        LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
-        AS_AREA_ATTR_NONE, &anon_backend, NULL);
-    if (area == NULL) {
-        as_destroy(as);
-        free(kernel_uarg);
-        free(kimage);
-        return ENOMEM;
-    }
-    task_t *task = task_create(as, "app");
-    if (task == NULL) {
-        as_destroy(as);
-        free(kernel_uarg);
-        free(kimage);
-        return ENOENT;
-    }
-    // FIXME: control the capabilities
-    cap_set(task, cap_get(TASK));
-    thread_t *thread = thread_create(uinit, kernel_uarg, task,
-        THREAD_FLAG_USPACE, "user", false);
-    if (thread == NULL) {
-        task_destroy(task);
-        as_destroy(as);
-        free(kernel_uarg);
-        free(kimage);
-        return ENOENT;
-    }
-    thread_ready(thread);
-    return EOK;
-}
 /** Find task structure corresponding to task ID.
  *
- * The tasks_lock must be already held by the caller of this function
- * and interrupts must be disabled.
+ * The tasks_lock must be already held by the caller of this function and
+ * interrupts must be disabled.
  *
- * @param id Task ID.
+ * @param id        Task ID.
  *
- * @return Task structure address or NULL if there is no such task ID.
+ * @return      Task structure address or NULL if there is no such task
+ *          ID.
  */
-task_t *task_find_by_id(task_id_t id)
-{
-    avltree_node_t *node;
+task_t *task_find_by_id(task_id_t id) { avltree_node_t *node;
     node = avltree_search(&tasks_tree, (avltree_key_t) id);
 ,11 → 265,13
 /** Get accounting data of given task.
  *
- * Note that task lock of 't' must be already held and
- * interrupts must be already disabled.
+ * Note that task lock of 't' must be already held and interrupts must be
+ * already disabled.
  *
- * @param t Pointer to thread.
+ * @param t     Pointer to thread.
  *
+ * @return      Number of cycles used by the task and all its threads
+ *          so far.
  */
 uint64_t task_get_accounting(task_t *t)
 {
 ,9 → 303,9
  * This function is idempotent.
  * It signals all the task's threads to bail it out.
  *
- * @param id ID of the task to be killed.
+ * @param id        ID of the task to be killed.
  *
- * @return 0 on success or an error code from errno.h
+ * @return      Zero on success or an error code from errno.h.
  */
 int task_kill(task_id_t id)
 {
 ,7 → 326,7
     spinlock_unlock(&tasks_lock);
     /*
-     * Interrupt all threads except ktaskclnp.
+     * Interrupt all threads.
      */
     spinlock_lock(&ta->lock);
     for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {

 /branches/tracing/kernel/generic/src/proc/thread.c
 ,74 → 683,6
     return node != NULL;
 }
-/** Create new user task with 1 thread from image
- *
- * @param program_addr Address of program executable image.
- * @param name Program name.
- *
- * @return Initialized main thread of the task or NULL on error.
- */
-thread_t *thread_create_program(void *program_addr, char *name)
-{
-    as_t *as;
-    as_area_t *area;
-    unsigned int rc;
-    task_t *task;
-    uspace_arg_t *kernel_uarg;
-    kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
-    if (kernel_uarg == NULL)
-        return NULL;
-    kernel_uarg->uspace_entry =
-        (void *) ((elf_header_t *) program_addr)->e_entry;
-    kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
-    kernel_uarg->uspace_thread_function = NULL;
-    kernel_uarg->uspace_thread_arg = NULL;
-    kernel_uarg->uspace_uarg = NULL;
-    as = as_create(0);
-    if (as == NULL) {
-        free(kernel_uarg);
-        return NULL;
-    }
-    rc = elf_load((elf_header_t *) program_addr, as);
-    if (rc != EE_OK) {
-        free(kernel_uarg);
-        as_destroy(as);
-        return NULL;
-    }
-    /*
-     * Create the data as_area.
-     */
-    area = as_area_create(as,
-        AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
-        LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
-        AS_AREA_ATTR_NONE, &anon_backend, NULL);
-    if (area == NULL) {
-        free(kernel_uarg);
-        as_destroy(as);
-        return NULL;
-    }
-    task = task_create(as, name);
-    if (task == NULL) {
-        free(kernel_uarg);
-        as_destroy(as);
-        return NULL;
-    }
-    /*
-     * Create the main thread.
-     */
-    return thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE,
-        "uinit", false);
-}
 /** Update accounting of current thread.
  *
  * Note that thread_lock on THREAD must be already held and

 /branches/tracing/kernel/generic/src/proc/program.c
 ,0 → 1,239
+/*
+ * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup genericproc
+ * @{
+ */
+/**
+ * @file
+ * @brief   Running userspace programs.
+ */
+#include <main/uinit.h>
+#include <proc/thread.h>
+#include <proc/task.h>
+#include <proc/uarg.h>
+#include <mm/as.h>
+#include <mm/slab.h>
+#include <arch.h>
+#include <adt/list.h>
+#include <ipc/ipc.h>
+#include <ipc/ipcrsc.h>
+#include <security/cap.h>
+#include <lib/elf.h>
+#include <errno.h>
+#include <print.h>
+#include <syscall/copy.h>
+#include <proc/program.h>
+#ifndef LOADED_PROG_STACK_PAGES_NO
+#define LOADED_PROG_STACK_PAGES_NO 1
+#endif
+/**
+ * Points to the binary image used as the program loader. All non-initial
+ * tasks are created from this executable image.
+ */
+void *program_loader = NULL;
+/** Create a program using an existing address space.
+ *
+ * @param as        Address space containing a binary program image.
+ * @param entry_addr    Program entry-point address in program address space.
+ * @param p     Buffer for storing program information.
+ */
+void program_create(as_t *as, uintptr_t entry_addr, program_t *p)
+{
+    as_area_t *a;
+    uspace_arg_t *kernel_uarg;
+    kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
+    kernel_uarg->uspace_entry = (void *) entry_addr;
+    kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
+    kernel_uarg->uspace_thread_function = NULL;
+    kernel_uarg->uspace_thread_arg = NULL;
+    kernel_uarg->uspace_uarg = NULL;
+    p->task = task_create(as, "app");
+    ASSERT(p->task);
+    /*
+     * Create the data as_area.
+     */
+    a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
+        LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
+        AS_AREA_ATTR_NONE, &anon_backend, NULL);
+    /*
+     * Create the main thread.
+     */
+    p->main_thread = thread_create(uinit, kernel_uarg, p->task,
+        THREAD_FLAG_USPACE, "uinit", false);
+    ASSERT(p->main_thread);
+}
+/** Parse an executable image in the kernel memory.
+ *
+ * If the image belongs to a program loader, it is registered as such,
+ * (and *task is set to NULL). Otherwise a task is created from the
+ * executable image. The task is returned in *task.
+ *
+ * @param image_addr    Address of an executable program image.
+ * @param p     Buffer for storing program info. If image_addr
+ *          points to a loader image, p->task will be set to
+ *          NULL and EOK will be returned.
+ *
+ * @return EOK on success or negative error code.
+ */
+int program_create_from_image(void *image_addr, program_t *p)
+{
+    as_t *as;
+    unsigned int rc;
+    as = as_create(0);
+    ASSERT(as);
+    rc = elf_load((elf_header_t *) image_addr, as, 0);
+    if (rc != EE_OK) {
+        as_destroy(as);
+        p->task = NULL;
+        p->main_thread = NULL;
+        if (rc != EE_LOADER)
+            return ENOTSUP;
+        /* Register image as the program loader */
+        ASSERT(program_loader == NULL);
+        program_loader = image_addr;
+        printf("Registered program loader at 0x%" PRIp "\n",
+            image_addr);
+        return EOK;
+    }
+    program_create(as, ((elf_header_t *) image_addr)->e_entry, p);
+    return EOK;
+}
+/** Create a task from the program loader image.
+ *
+ * @param p Buffer for storing program info.
+ * @return EOK on success or negative error code.
+ */
+int program_create_loader(program_t *p)
+{
+    as_t *as;
+    unsigned int rc;
+    void *loader;
+    as = as_create(0);
+    ASSERT(as);
+    loader = program_loader;
+    if (!loader) {
+        printf("Cannot spawn loader as none was registered\n");
+        return ENOENT;
+    }
+    rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);
+    if (rc != EE_OK) {
+        as_destroy(as);
+        return ENOENT;
+    }
+    program_create(as, ((elf_header_t *) program_loader)->e_entry, p);
+    return EOK;
+}
+/** Make program ready.
+ *
+ * Switch program's main thread to the ready state.
+ *
+ * @param p Program to make ready.
+ */
+void program_ready(program_t *p)
+{
+    thread_ready(p->main_thread);
+}
+/** Syscall for creating a new loader instance from userspace.
+ *
+ * Creates a new task from the program loader image, connects a phone
+ * to it and stores the phone id into the provided buffer.
+ *
+ * @param uspace_phone_id Userspace address where to store the phone id.
+ *
+ * @return 0 on success or an error code from @ref errno.h.
+ */
+unative_t sys_program_spawn_loader(int *uspace_phone_id)
+{
+    program_t p;
+    int fake_id;
+    int rc;
+    int phone_id;
+    fake_id = 0;
+    /* Before we even try creating the task, see if we can write the id */
+    rc = (unative_t) copy_to_uspace(uspace_phone_id, &fake_id,
+        sizeof(fake_id));
+    if (rc != 0)
+        return rc;
+    phone_id = phone_alloc();
+    if (phone_id < 0)
+        return ELIMIT;
+    rc = program_create_loader(&p);
+    if (rc != 0)
+        return rc;
+    phone_connect(phone_id, &p.task->answerbox);
+    /* No need to aquire lock before task_ready() */
+    rc = (unative_t) copy_to_uspace(uspace_phone_id, &phone_id,
+        sizeof(phone_id));
+    if (rc != 0) {
+        /* Ooops */
+        ipc_phone_hangup(&TASK->phones[phone_id]);
+        task_kill(p.task->taskid);
+        return rc;
+    }
+    // FIXME: control the capabilities
+    cap_set(p.task, cap_get(TASK));
+    program_ready(&p);
+    return EOK;
+}
+/** @}
+ */

/branches/tracing/kernel/generic/src/lib/objc_ext.c
File deleted

/branches/tracing/kernel/generic/src/lib/objc.c
File deleted

 /branches/tracing/kernel/generic/src/lib/rd.c
 ,14 → 48,14
 /**
  * RAM disk initialization routine. At this point, the RAM disk memory is shared
- * and information about the share is provided as sysinfo values to the userspace
- * tasks.
+ * and information about the share is provided as sysinfo values to the
+ * userspace tasks.
  */
 int init_rd(rd_header_t *header, size_t size)
 {
     /* Identify RAM disk */
     if ((header->magic[0] != RD_MAG0) || (header->magic[1] != RD_MAG1) ||
-        (header->magic[2] != RD_MAG2) || (header->magic[3] != RD_MAG3))
+        (header->magic[2] != RD_MAG2) || (header->magic[3] != RD_MAG3))
         return RE_INVALID;
     /* Identify version */
 ,7 → 86,8
     if ((uint64_t) hsize + dsize > size)
         dsize = size - hsize;
-    rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize), FRAME_SIZE);
+    rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize),
+        FRAME_SIZE);
     rd_parea.vbase = (uintptr_t) ((void *) header + hsize);
     rd_parea.frames = SIZE2FRAMES(dsize);
     rd_parea.cacheable = true;
 ,8 → 96,8
     sysinfo_set_item_val("rd", NULL, true);
     sysinfo_set_item_val("rd.header_size", NULL, hsize);
     sysinfo_set_item_val("rd.size", NULL, dsize);
-    sysinfo_set_item_val("rd.address.physical", NULL, (unative_t)
-        KA2PA((void *) header + hsize));
+    sysinfo_set_item_val("rd.address.physical", NULL,
+        (unative_t) KA2PA((void *) header + hsize));
     return RE_OK;
 }

 /branches/tracing/kernel/generic/src/lib/elf.c
 ,7 → 57,7
 };
 static int segment_header(elf_segment_header_t *entry, elf_header_t *elf,
-    as_t *as);
+    as_t *as, int flags);
 static int section_header(elf_section_header_t *entry, elf_header_t *elf,
     as_t *as);
 static int load_segment(elf_segment_header_t *entry, elf_header_t *elf,
 ,9 → 67,10
  *
  * @param header Pointer to ELF header in memory
  * @param as Created and properly mapped address space
+ * @param flags A combination of ELD_F_*
  * @return EE_OK on success
  */
-unsigned int elf_load(elf_header_t *header, as_t * as)
+unsigned int elf_load(elf_header_t *header, as_t * as, int flags)
 {
     int i, rc;
 ,7 → 111,7
         seghdr = &((elf_segment_header_t *)(((uint8_t *) header) +
             header->e_phoff))[i];
-        rc = segment_header(seghdr, header, as);
+        rc = segment_header(seghdr, header, as, flags);
         if (rc != EE_OK)
             return rc;
     }
 ,8 → 152,10
  * @return EE_OK on success, error code otherwise.
  */
 static int segment_header(elf_segment_header_t *entry, elf_header_t *elf,
-    as_t *as)
+    as_t *as, int flags)
 {
+    char *interp;
     switch (entry->p_type) {
     case PT_NULL:
     case PT_PHDR:
 ,6 → 165,16
         break;
     case PT_DYNAMIC:
     case PT_INTERP:
+        interp = (char *)elf + entry->p_offset;
+        /* FIXME */
+        /*if (memcmp((uintptr_t)interp, (uintptr_t)ELF_INTERP_ZSTR,
+            ELF_INTERP_ZLEN) != 0) {
+            return EE_UNSUPPORTED;
+        }*/
+        if ((flags & ELD_F_LOADER) == 0) {
+            return EE_LOADER;
+        }
+        break;
     case PT_SHLIB:
     case PT_NOTE:
     case PT_LOPROC:

 /branches/tracing/kernel/generic/src/lib/memstr.c
 ,12 → 34,10
  * @file
  * @brief   Memory string operations.
  *
- * This file provides architecture independent functions
- * to manipulate blocks of memory. These functions
- * are optimized as much as generic functions of
- * this type can be. However, architectures are
- * free to provide even more optimized versions of these
- * functions.
+ * This file provides architecture independent functions to manipulate blocks of
+ * memory. These functions are optimized as much as generic functions of this
+ * type can be. However, architectures are free to provide even more optimized
+ * versions of these functions.
  */
 #include <memstr.h>
 ,45 → 44,46
 #include <arch/types.h>
 #include <align.h>
-/** Copy block of memory
+/** Copy block of memory.
  *
- * Copy cnt bytes from src address to dst address.
- * The copying is done word-by-word and then byte-by-byte.
- * The source and destination memory areas cannot overlap.
+ * Copy cnt bytes from src address to dst address.  The copying is done
+ * word-by-word and then byte-by-byte.  The source and destination memory areas
+ * cannot overlap.
  *
- * @param src Origin address to copy from.
- * @param dst Origin address to copy to.
- * @param cnt Number of bytes to copy.
+ * @param src       Source address to copy from.
+ * @param dst       Destination address to copy to.
+ * @param cnt       Number of bytes to copy.
  *
+ * @return      Destination address.
  */
-void *_memcpy(void * dst, const void *src, size_t cnt)
+void *_memcpy(void *dst, const void *src, size_t cnt)
 {
     unsigned int i, j;
     if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
-        ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
+        ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
         for (i = 0; i < cnt; i++)
             ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
     } else {
         for (i = 0; i < cnt / sizeof(unative_t); i++)
             ((unative_t *) dst)[i] = ((unative_t *) src)[i];
         for (j = 0; j < cnt % sizeof(unative_t); j++)
-            ((uint8_t *)(((unative_t *) dst) + i))[j] = ((uint8_t *)(((unative_t *) src) + i))[j];
+            ((uint8_t *)(((unative_t *) dst) + i))[j] =
+                ((uint8_t *)(((unative_t *) src) + i))[j];
     }
-    return (char *) src;
+    return (char *) dst;
 }
 /** Fill block of memory
  *
- * Fill cnt bytes at dst address with the value x.
- * The filling is done byte-by-byte.
+ * Fill cnt bytes at dst address with the value x.  The filling is done
+ * byte-by-byte.
  *
- * @param dst Origin address to fill.
- * @param cnt Number of bytes to fill.
- * @param x   Value to fill.
+ * @param dst       Destination address to fill.
+ * @param cnt       Number of bytes to fill.
+ * @param x     Value to fill.
  *
  */
 void _memsetb(void *dst, size_t cnt, uint8_t x)
 ,14 → 95,14
         p[i] = x;
 }
-/** Fill block of memory
+/** Fill block of memory.
  *
- * Fill cnt words at dst address with the value x.
- * The filling is done word-by-word.
+ * Fill cnt words at dst address with the value x.  The filling is done
+ * word-by-word.
  *
- * @param dst Origin address to fill.
- * @param cnt Number of words to fill.
- * @param x   Value to fill.
+ * @param dst       Destination address to fill.
+ * @param cnt       Number of words to fill.
+ * @param x     Value to fill.
  *
  */
 void _memsetw(void *dst, size_t cnt, uint16_t x)
 ,16 → 114,16
         p[i] = x;
 }
-/** Copy string
+/** Copy string.
  *
- * Copy string from src address to dst address.
- * The copying is done char-by-char until the null
- * character. The source and destination memory areas
- * cannot overlap.
+ * Copy string from src address to dst address.  The copying is done
+ * char-by-char until the null character. The source and destination memory
+ * areas cannot overlap.
  *
- * @param src Origin string to copy from.
- * @param dst Origin string to copy to.
+ * @param src       Source string to copy from.
+ * @param dst       Destination string to copy to.
  *
+ * @return      Address of the destination string.
  */
 char *strcpy(char *dest, const char *src)
 {

 /branches/tracing/kernel/generic/src/mm/slab.c
 ,30 → 794,77
 /* Print list of slabs */
 void slab_print_list(void)
 {
-    slab_cache_t *cache;
-    link_t *cur;
-    ipl_t ipl;
-    ipl = interrupts_disable();
-    spinlock_lock(&slab_cache_lock);
+    int skip = 0;
     printf("slab name        size     pages  obj/pg slabs  cached allocated"
         " ctl\n");
     printf("---------------- -------- ------ ------ ------ ------ ---------"
         " ---\n");
-    for (cur = slab_cache_list.next; cur != &slab_cache_list;
-        cur = cur->next) {
+    while (true) {
+        slab_cache_t *cache;
+        link_t *cur;
+        ipl_t ipl;
+        int i;
+        /*
+         * We must not hold the slab_cache_lock spinlock when printing
+         * the statistics. Otherwise we can easily deadlock if the print
+         * needs to allocate memory.
+         *
+         * Therefore, we walk through the slab cache list, skipping some
+         * amount of already processed caches during each iteration and
+         * gathering statistics about the first unprocessed cache. For
+         * the sake of printing the statistics, we realese the
+         * slab_cache_lock and reacquire it afterwards. Then the walk
+         * starts again.
+         *
+         * This limits both the efficiency and also accuracy of the
+         * obtained statistics. The efficiency is decreased because the
+         * time complexity of the algorithm is quadratic instead of
+         * linear. The accuracy is impacted because we drop the lock
+         * after processing one cache. If there is someone else
+         * manipulating the cache list, we might omit an arbitrary
+         * number of caches or process one cache multiple times.
+         * However, we don't bleed for this algorithm for it is only
+         * statistics.
+         */
+        ipl = interrupts_disable();
+        spinlock_lock(&slab_cache_lock);
+        for (i = 0, cur = slab_cache_list.next;
+            i < skip && cur != &slab_cache_list;
+            i++, cur = cur->next)
+            ;
+        if (cur == &slab_cache_list) {
+            spinlock_unlock(&slab_cache_lock);
+            interrupts_restore(ipl);
+            break;
+        }
+        skip++;
         cache = list_get_instance(cur, slab_cache_t, link);
+        char *name = cache->name;
+        uint8_t order = cache->order;
+        size_t size = cache->size;
+        unsigned int objects = cache->objects;
+        long allocated_slabs = atomic_get(&cache->allocated_slabs);
+        long cached_objs = atomic_get(&cache->cached_objs);
+        long allocated_objs = atomic_get(&cache->allocated_objs);
+        int flags = cache->flags;
+        spinlock_unlock(&slab_cache_lock);
+        interrupts_restore(ipl);
         printf("%-16s %8" PRIs " %6d %6u %6ld %6ld %9ld %-3s\n",
-            cache->name, cache->size, (1 << cache->order),
-            cache->objects, atomic_get(&cache->allocated_slabs),
-            atomic_get(&cache->cached_objs),
-            atomic_get(&cache->allocated_objs),
-            cache->flags & SLAB_CACHE_SLINSIDE ? "in" : "out");
+            name, size, (1 << order), objects, allocated_slabs,
+            cached_objs, allocated_objs,
+            flags & SLAB_CACHE_SLINSIDE ? "in" : "out");
     }
-    spinlock_unlock(&slab_cache_lock);
-    interrupts_restore(ipl);
 }
 void slab_cache_init(void)

/branches/tracing/kernel/generic/src/mm/backend_anon.c
78,7 → 78,6
int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
{
uintptr_t frame;
bool dirty = false;

if (!as_area_check_access(area, access))
return AS_PF_FAULT;
106,7 → 105,7
*/
for (i = 0; i < leaf->keys; i++) {
if (leaf->key[i] ==
ALIGN_DOWN(addr, PAGE_SIZE)) {
ALIGN_DOWN(addr, PAGE_SIZE) - area->base) {
allocate = false;
break;
}
114,7 → 113,6
if (allocate) {
frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
dirty = true;

/*
* Insert the address of the newly allocated
145,7 → 143,6
*/
frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
dirty = true;
}

/*

 /branches/tracing/kernel/generic/src/mm/as.c
 ,7 → 82,6
 #include <arch/mm/cache.h>
 #endif /* CONFIG_VIRT_IDX_DCACHE */
-#ifndef __OBJC__
 /**
  * Each architecture decides what functions will be used to carry out
  * address space operations such as creating or locking page tables.
 ,7 → 92,6
  * Slab for as_t objects.
  */
 static slab_cache_t *as_slab;
-#endif
 /**
  * This lock serializes access to the ASID subsystem.
 ,13 → 111,11
 /** Kernel address space. */
 as_t *AS_KERNEL = NULL;
-static int area_flags_to_page_flags(int aflags);
-static as_area_t *find_area_and_lock(as_t *as, uintptr_t va);
-static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
-    as_area_t *avoid_area);
-static void sh_info_remove_reference(share_info_t *sh_info);
+static int area_flags_to_page_flags(int);
+static as_area_t *find_area_and_lock(as_t *, uintptr_t);
+static bool check_area_conflicts(as_t *, uintptr_t, size_t, as_area_t *);
+static void sh_info_remove_reference(share_info_t *);
-#ifndef __OBJC__
 static int as_constructor(void *obj, int flags)
 {
     as_t *as = (as_t *) obj;
 ,7 → 122,7
     int rc;
     link_initialize(&as->inactive_as_with_asid_link);
-    mutex_initialize(&as->lock);
+    mutex_initialize(&as->lock, MUTEX_PASSIVE);
     rc = as_constructor_arch(as, flags);
 ,7 → 135,6
     return as_destructor_arch(as);
 }
-#endif
 /** Initialize address space subsystem. */
 void as_init(void)
 ,10 → 141,8
 {
     as_arch_init();
-#ifndef __OBJC__
     as_slab = slab_cache_create("as_slab", sizeof(as_t), 0,
         as_constructor, as_destructor, SLAB_CACHE_MAGDEFERRED);
-#endif
     AS_KERNEL = as_create(FLAG_AS_KERNEL);
     if (!AS_KERNEL)
 ,20 → 152,14
 /** Create address space.
  *
- * @param flags Flags that influence way in wich the address space is created.
+ * @param flags     Flags that influence the way in wich the address space
+ *          is created.
  */
 as_t *as_create(int flags)
 {
     as_t *as;
-#ifdef __OBJC__
-    as = [as_t new];
-    link_initialize(&as->inactive_as_with_asid_link);
-    mutex_initialize(&as->lock);
-    (void) as_constructor_arch(as, flags);
-#else
     as = (as_t *) slab_alloc(as_slab, 0);
-#endif
     (void) as_create_arch(as, 0);
     btree_create(&as->as_area_btree);
 ,6 → 186,8
  * zero), the address space can be destroyed.
  *
  * We know that we don't hold any spinlock.
+ *
+ * @param as        Address space to be destroyed.
  */
 void as_destroy(as_t *as)
 {
 ,11 → 252,7
     interrupts_restore(ipl);
-#ifdef __OBJC__
-    [as free];
-#else
     slab_free(as_slab, as);
-#endif
 }
 /** Create address space area of common attributes.
 ,19 → 259,19
  *
  * The created address space area is added to the target address space.
  *
- * @param as Target address space.
- * @param flags Flags of the area memory.
- * @param size Size of area.
- * @param base Base address of area.
- * @param attrs Attributes of the area.
- * @param backend Address space area backend. NULL if no backend is used.
- * @param backend_data NULL or a pointer to an array holding two void *.
+ * @param as        Target address space.
+ * @param flags     Flags of the area memory.
+ * @param size      Size of area.
+ * @param base      Base address of area.
+ * @param attrs     Attributes of the area.
+ * @param backend   Address space area backend. NULL if no backend is used.
+ * @param backend_data  NULL or a pointer to an array holding two void *.
  *
- * @return Address space area on success or NULL on failure.
+ * @return      Address space area on success or NULL on failure.
  */
 as_area_t *
 as_area_create(as_t *as, int flags, size_t size, uintptr_t base, int attrs,
-           mem_backend_t *backend, mem_backend_data_t *backend_data)
+    mem_backend_t *backend, mem_backend_data_t *backend_data)
 {
     ipl_t ipl;
     as_area_t *a;
 ,7 → 297,7
     a = (as_area_t *) malloc(sizeof(as_area_t), 0);
-    mutex_initialize(&a->lock);
+    mutex_initialize(&a->lock, MUTEX_PASSIVE);
     a->as = as;
     a->flags = flags;
 ,13 → 323,14
 /** Find address space area and change it.
  *
- * @param as Address space.
- * @param address Virtual address belonging to the area to be changed. Must be
- *     page-aligned.
- * @param size New size of the virtual memory block starting at address.
- * @param flags Flags influencing the remap operation. Currently unused.
+ * @param as        Address space.
+ * @param address   Virtual address belonging to the area to be changed.
+ *          Must be page-aligned.
+ * @param size      New size of the virtual memory block starting at
+ *          address.
+ * @param flags     Flags influencing the remap operation. Currently unused.
  *
- * @return Zero on success or a value from @ref errno.h otherwise.
+ * @return      Zero on success or a value from @ref errno.h otherwise.
  */
 int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags)
 {
 ,7 → 385,7
     if (pages < area->pages) {
         bool cond;
-        uintptr_t start_free = area->base + pages*PAGE_SIZE;
+        uintptr_t start_free = area->base + pages * PAGE_SIZE;
         /*
          * Shrinking the area.
 ,7 → 395,7
         /*
          * Start TLB shootdown sequence.
          */
-        tlb_shootdown_start(TLB_INVL_PAGES, AS->asid, area->base +
+        tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base +
             pages * PAGE_SIZE, area->pages - pages);
         /*
 ,8 → 438,10
                     cond = false;   /* we are almost done */
                     i = (start_free - b) >> PAGE_WIDTH;
-                    if (!used_space_remove(area, start_free, c - i))
-                        panic("Could not remove used space.\n");
+                    if (!used_space_remove(area, start_free,
+                        c - i))
+                        panic("Could not remove used "
+                            "space.\n");
                 } else {
                     /*
                      * The interval of used space can be
 ,7 → 448,8
                      * completely removed.
                      */
                     if (!used_space_remove(area, b, c))
-                        panic("Could not remove used space.\n");
+                        panic("Could not remove used "
+                            "space.\n");
                 }
                 for (; i < c; i++) {
 ,10 → 511,10
 /** Destroy address space area.
  *
- * @param as Address space.
- * @param address Address withing the area to be deleted.
+ * @param as        Address space.
+ * @param address   Address within the area to be deleted.
  *
- * @return Zero on success or a value from @ref errno.h on failure.
+ * @return      Zero on success or a value from @ref errno.h on failure.
  */
 int as_area_destroy(as_t *as, uintptr_t address)
 {
 ,18 → 611,19
  * sh_info of the source area. The process of duplicating the
  * mapping is done through the backend share function.
  *
- * @param src_as Pointer to source address space.
- * @param src_base Base address of the source address space area.
- * @param acc_size Expected size of the source area.
- * @param dst_as Pointer to destination address space.
- * @param dst_base Target base address.
+ * @param src_as    Pointer to source address space.
+ * @param src_base  Base address of the source address space area.
+ * @param acc_size  Expected size of the source area.
+ * @param dst_as    Pointer to destination address space.
+ * @param dst_base  Target base address.
  * @param dst_flags_mask Destination address space area flags mask.
  *
- * @return Zero on success or ENOENT if there is no such task or if there is no
- * such address space area, EPERM if there was a problem in accepting the area
- * or ENOMEM if there was a problem in allocating destination address space
- * area. ENOTSUP is returned if the address space area backend does not support
- * sharing.
+ * @return      Zero on success or ENOENT if there is no such task or if
+ *          there is no such address space area, EPERM if there was
+ *          a problem in accepting the area or ENOMEM if there was a
+ *          problem in allocating destination address space area.
+ *          ENOTSUP is returned if the address space area backend
+ *          does not support sharing.
  */
 int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
     as_t *dst_as, uintptr_t dst_base, int dst_flags_mask)
 ,7 → 684,7
     sh_info = src_area->sh_info;
     if (!sh_info) {
         sh_info = (share_info_t *) malloc(sizeof(share_info_t), 0);
-        mutex_initialize(&sh_info->lock);
+        mutex_initialize(&sh_info->lock, MUTEX_PASSIVE);
         sh_info->refcount = 2;
         btree_create(&sh_info->pagemap);
         src_area->sh_info = sh_info;
 ,10 → 742,11
  *
  * The address space area must be locked prior to this call.
  *
- * @param area Address space area.
- * @param access Access mode.
+ * @param area      Address space area.
+ * @param access    Access mode.
  *
- * @return False if access violates area's permissions, true otherwise.
+ * @return      False if access violates area's permissions, true
+ *          otherwise.
  */
 bool as_area_check_access(as_area_t *area, pf_access_t access)
 {
 ,21 → 762,181
     return true;
 }
+/** Change adress space area flags.
+ *
+ * The idea is to have the same data, but with a different access mode.
+ * This is needed e.g. for writing code into memory and then executing it.
+ * In order for this to work properly, this may copy the data
+ * into private anonymous memory (unless it's already there).
+ *
+ * @param as        Address space.
+ * @param flags     Flags of the area memory.
+ * @param address   Address withing the area to be changed.
+ *
+ * @return      Zero on success or a value from @ref errno.h on failure.
+ */
+int as_area_change_flags(as_t *as, int flags, uintptr_t address)
+{
+    as_area_t *area;
+    uintptr_t base;
+    link_t *cur;
+    ipl_t ipl;
+    int page_flags;
+    uintptr_t *old_frame;
+    index_t frame_idx;
+    count_t used_pages;
+    /* Flags for the new memory mapping */
+    page_flags = area_flags_to_page_flags(flags);
+    ipl = interrupts_disable();
+    mutex_lock(&as->lock);
+    area = find_area_and_lock(as, address);
+    if (!area) {
+        mutex_unlock(&as->lock);
+        interrupts_restore(ipl);
+        return ENOENT;
+    }
+    if (area->sh_info || area->backend != &anon_backend) {
+        /* Copying shared areas not supported yet */
+        /* Copying non-anonymous memory not supported yet */
+        mutex_unlock(&area->lock);
+        mutex_unlock(&as->lock);
+        interrupts_restore(ipl);
+        return ENOTSUP;
+    }
+    base = area->base;
+    /*
+     * Compute total number of used pages in the used_space B+tree
+     */
+    used_pages = 0;
+    for (cur = area->used_space.leaf_head.next;
+        cur != &area->used_space.leaf_head; cur = cur->next) {
+        btree_node_t *node;
+        unsigned int i;
+        node = list_get_instance(cur, btree_node_t, leaf_link);
+        for (i = 0; i < node->keys; i++) {
+            used_pages += (count_t) node->value[i];
+        }
+    }
+    /* An array for storing frame numbers */
+    old_frame = malloc(used_pages * sizeof(uintptr_t), 0);
+    /*
+     * Start TLB shootdown sequence.
+     */
+    tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base, area->pages);
+    /*
+     * Remove used pages from page tables and remember their frame
+     * numbers.
+     */
+    frame_idx = 0;
+    for (cur = area->used_space.leaf_head.next;
+        cur != &area->used_space.leaf_head; cur = cur->next) {
+        btree_node_t *node;
+        unsigned int i;
+        node = list_get_instance(cur, btree_node_t, leaf_link);
+        for (i = 0; i < node->keys; i++) {
+            uintptr_t b = node->key[i];
+            count_t j;
+            pte_t *pte;
+            for (j = 0; j < (count_t) node->value[i]; j++) {
+                page_table_lock(as, false);
+                pte = page_mapping_find(as, b + j * PAGE_SIZE);
+                ASSERT(pte && PTE_VALID(pte) &&
+                    PTE_PRESENT(pte));
+                old_frame[frame_idx++] = PTE_GET_FRAME(pte);
+                /* Remove old mapping */
+                page_mapping_remove(as, b + j * PAGE_SIZE);
+                page_table_unlock(as, false);
+            }
+        }
+    }
+    /*
+     * Finish TLB shootdown sequence.
+     */
+    tlb_invalidate_pages(as->asid, area->base, area->pages);
+    /*
+     * Invalidate potential software translation caches (e.g. TSB on
+     * sparc64).
+     */
+    as_invalidate_translation_cache(as, area->base, area->pages);
+    tlb_shootdown_finalize();
+    /*
+     * Set the new flags.
+     */
+    area->flags = flags;
+    /*
+     * Map pages back in with new flags. This step is kept separate
+     * so that the memory area could not be accesed with both the old and
+     * the new flags at once.
+     */
+    frame_idx = 0;
+    for (cur = area->used_space.leaf_head.next;
+        cur != &area->used_space.leaf_head; cur = cur->next) {
+        btree_node_t *node;
+        unsigned int i;
+        node = list_get_instance(cur, btree_node_t, leaf_link);
+        for (i = 0; i < node->keys; i++) {
+            uintptr_t b = node->key[i];
+            count_t j;
+            for (j = 0; j < (count_t) node->value[i]; j++) {
+                page_table_lock(as, false);
+                /* Insert the new mapping */
+                page_mapping_insert(as, b + j * PAGE_SIZE,
+                    old_frame[frame_idx++], page_flags);
+                page_table_unlock(as, false);
+            }
+        }
+    }
+    free(old_frame);
+    mutex_unlock(&area->lock);
+    mutex_unlock(&as->lock);
+    interrupts_restore(ipl);
+    return 0;
+}
 /** Handle page fault within the current address space.
  *
- * This is the high-level page fault handler. It decides
- * whether the page fault can be resolved by any backend
- * and if so, it invokes the backend to resolve the page
- * fault.
+ * This is the high-level page fault handler. It decides whether the page fault
+ * can be resolved by any backend and if so, it invokes the backend to resolve
+ * the page fault.
  *
  * Interrupts are assumed disabled.
  *
- * @param page Faulting page.
- * @param access Access mode that caused the fault (i.e. read/write/exec).
- * @param istate Pointer to interrupted state.
+ * @param page      Faulting page.
+ * @param access    Access mode that caused the page fault (i.e.
+ *          read/write/exec).
+ * @param istate    Pointer to the interrupted state.
  *
- * @return AS_PF_FAULT on page fault, AS_PF_OK on success or AS_PF_DEFER if the
- *     fault was caused by copy_to_uspace() or copy_from_uspace().
+ * @return      AS_PF_FAULT on page fault, AS_PF_OK on success or
+ *          AS_PF_DEFER if the fault was caused by copy_to_uspace()
+ *          or copy_from_uspace().
  */
 int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate)
 {
 ,9 → 982,8
     page_table_lock(AS, false);
     /*
-     * To avoid race condition between two page faults
-     * on the same address, we need to make sure
-     * the mapping has not been already inserted.
+     * To avoid race condition between two page faults on the same address,
+     * we need to make sure the mapping has not been already inserted.
      */
     if ((pte = page_mapping_find(AS, page))) {
         if (PTE_PRESENT(pte)) {
 ,8 → 1037,8
  *
  * When this function is enetered, no spinlocks may be held.
  *
- * @param old Old address space or NULL.
- * @param new New address space.
+ * @param old       Old address space or NULL.
+ * @param new       New address space.
  */
 void as_switch(as_t *old_as, as_t *new_as)
 {
 ,9 → 1309,9
 /** Convert address space area flags to page flags.
  *
- * @param aflags Flags of some address space area.
+ * @param aflags    Flags of some address space area.
  *
- * @return Flags to be passed to page_mapping_insert().
+ * @return      Flags to be passed to page_mapping_insert().
  */
 int area_flags_to_page_flags(int aflags)
 {
 ,9 → 1339,9
  * The address space area must be locked.
  * Interrupts must be disabled.
  *
- * @param a Address space area.
+ * @param a     Address space area.
  *
- * @return Flags to be used in page_mapping_insert().
+ * @return      Flags to be used in page_mapping_insert().
  */
 int as_area_get_flags(as_area_t *a)
 {
 ,23 → 1350,20
 /** Create page table.
  *
- * Depending on architecture, create either address space
- * private or global page table.
+ * Depending on architecture, create either address space private or global page
+ * table.
  *
- * @param flags Flags saying whether the page table is for kernel address space.
+ * @param flags     Flags saying whether the page table is for the kernel
+ *          address space.
  *
- * @return First entry of the page table.
+ * @return      First entry of the page table.
  */
 pte_t *page_table_create(int flags)
 {
-#ifdef __OBJC__
-    return [as_t page_table_create: flags];
-#else
     ASSERT(as_operations);
     ASSERT(as_operations->page_table_create);
     return as_operations->page_table_create(flags);
-#endif
 }
 /** Destroy page table.
 ,18 → 1370,14
  *
  * Destroy page table in architecture specific way.
  *
- * @param page_table Physical address of PTL0.
+ * @param page_table    Physical address of PTL0.
  */
 void page_table_destroy(pte_t *page_table)
 {
-#ifdef __OBJC__
-    return [as_t page_table_destroy: page_table];
-#else
     ASSERT(as_operations);
     ASSERT(as_operations->page_table_destroy);
     as_operations->page_table_destroy(page_table);
-#endif
 }
 /** Lock page table.
 ,36 → 1389,28
  * prior to this call. Address space can be locked prior to this
  * call in which case the lock argument is false.
  *
- * @param as Address space.
- * @param lock If false, do not attempt to lock as->lock.
+ * @param as        Address space.
+ * @param lock      If false, do not attempt to lock as->lock.
  */
 void page_table_lock(as_t *as, bool lock)
 {
-#ifdef __OBJC__
-    [as page_table_lock: lock];
-#else
     ASSERT(as_operations);
     ASSERT(as_operations->page_table_lock);
     as_operations->page_table_lock(as, lock);
-#endif
 }
 /** Unlock page table.
  *
- * @param as Address space.
- * @param unlock If false, do not attempt to unlock as->lock.
+ * @param as        Address space.
+ * @param unlock    If false, do not attempt to unlock as->lock.
  */
 void page_table_unlock(as_t *as, bool unlock)
 {
-#ifdef __OBJC__
-    [as page_table_unlock: unlock];
-#else
     ASSERT(as_operations);
     ASSERT(as_operations->page_table_unlock);
     as_operations->page_table_unlock(as, unlock);
-#endif
 }
 ,11 → 1418,11
  *
  * The address space must be locked and interrupts must be disabled.
  *
- * @param as Address space.
- * @param va Virtual address.
+ * @param as        Address space.
+ * @param va        Virtual address.
  *
- * @return Locked address space area containing va on success or NULL on
- *     failure.
+ * @return      Locked address space area containing va on success or
+ *          NULL on failure.
  */
 as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
 {
 ,15 → 1474,15
  *
  * The address space must be locked and interrupts must be disabled.
  *
- * @param as Address space.
- * @param va Starting virtual address of the area being tested.
- * @param size Size of the area being tested.
- * @param avoid_area Do not touch this area.
+ * @param as        Address space.
+ * @param va        Starting virtual address of the area being tested.
+ * @param size      Size of the area being tested.
+ * @param avoid_area    Do not touch this area.
  *
- * @return True if there is no conflict, false otherwise.
+ * @return      True if there is no conflict, false otherwise.
  */
-bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
-              as_area_t *avoid_area)
+bool
+check_area_conflicts(as_t *as, uintptr_t va, size_t size, as_area_t *avoid_area)
 {
     as_area_t *a;
     btree_node_t *leaf, *node;
 ,7 → 1571,7
     ipl = interrupts_disable();
     src_area = find_area_and_lock(AS, base);
-    if (src_area){
+    if (src_area) {
         size = src_area->pages * PAGE_SIZE;
         mutex_unlock(&src_area->lock);
     } else {
 ,11 → 1585,11
  *
  * The address space area must be already locked.
  *
- * @param a Address space area.
- * @param page First page to be marked.
- * @param count Number of page to be marked.
+ * @param a     Address space area.
+ * @param page      First page to be marked.
+ * @param count     Number of page to be marked.
  *
- * @return 0 on failure and 1 on success.
+ * @return      Zero on failure and non-zero on success.
  */
 int used_space_insert(as_area_t *a, uintptr_t page, count_t count)
 {
 ,8 → 1859,8
         }
     }
-    panic("Inconsistency detected while adding %" PRIc " pages of used space at "
-        "%p.\n", count, page);
+    panic("Inconsistency detected while adding %" PRIc " pages of used "
+        "space at %p.\n", count, page);
 }
 /** Mark portion of address space area as unused.
 ,11 → 1867,11
  *
  * The address space area must be already locked.
  *
- * @param a Address space area.
- * @param page First page to be marked.
- * @param count Number of page to be marked.
+ * @param a     Address space area.
+ * @param page      First page to be marked.
+ * @param count     Number of page to be marked.
  *
- * @return 0 on failure and 1 on success.
+ * @return      Zero on failure and non-zero on success.
  */
 int used_space_remove(as_area_t *a, uintptr_t page, count_t count)
 {
 ,8 → 2038,8
     }
 error:
-    panic("Inconsistency detected while removing %" PRIc " pages of used space "
-        "from %p.\n", count, page);
+    panic("Inconsistency detected while removing %" PRIc " pages of used "
+        "space from %p.\n", count, page);
 }
 /** Remove reference to address space area share info.
 ,7 → 2046,7
  *
  * If the reference count drops to 0, the sh_info is deallocated.
  *
- * @param sh_info Pointer to address space area share info.
+ * @param sh_info   Pointer to address space area share info.
  */
 void sh_info_remove_reference(share_info_t *sh_info)
 {
 ,6 → 2101,12
     return (unative_t) as_area_resize(AS, address, size, 0);
 }
+/** Wrapper for as_area_change_flags(). */
+unative_t sys_as_area_change_flags(uintptr_t address, int flags)
+{
+    return (unative_t) as_area_change_flags(AS, flags, address);
+}
 /** Wrapper for as_area_destroy(). */
 unative_t sys_as_area_destroy(uintptr_t address)
 {
 ,7 → 2115,7
 /** Print out information about address space.
  *
- * @param as Address space.
+ * @param as        Address space.
  */
 void as_print(as_t *as)
 {
 ,9 → 2137,9
             as_area_t *area = node->value[i];
             mutex_lock(&area->lock);
-            printf("as_area: %p, base=%p, pages=%" PRIc " (%p - %p)\n",
-                area, area->base, area->pages, area->base,
-                area->base + FRAMES2SIZE(area->pages));
+            printf("as_area: %p, base=%p, pages=%" PRIc
+                " (%p - %p)\n", area, area->base, area->pages,
+                area->base, area->base + FRAMES2SIZE(area->pages));
             mutex_unlock(&area->lock);
         }
     }

 /branches/tracing/kernel/generic/src/mm/buddy.c
 ,8 → 35,7
  * @brief   Buddy allocator framework.
  *
  * This file contains buddy system allocator framework.
- * Specialized functions are needed for this abstract framework
- * to be useful.
+ * Specialized functions are needed for this abstract framework to be useful.
  */
 #include <mm/buddy.h>
 ,7 → 45,7
 #include <print.h>
 #include <macros.h>
-/** Return size needed for the buddy configuration data */
+/** Return size needed for the buddy configuration data. */
 size_t buddy_conf_size(int max_order)
 {
     return sizeof(buddy_system_t) + (max_order + 1) * sizeof(link_t);
 ,21 → 52,20
 }
-/** Create buddy system
+/** Create buddy system.
  *
  * Allocate memory for and initialize new buddy system.
  *
- * @param b Preallocated buddy system control data.
- * @param max_order The biggest allocable size will be 2^max_order.
- * @param op Operations for new buddy system.
- * @param data Pointer to be used by implementation.
+ * @param b     Preallocated buddy system control data.
+ * @param max_order The biggest allocable size will be 2^max_order.
+ * @param op        Operations for new buddy system.
+ * @param data      Pointer to be used by implementation.
  *
- * @return New buddy system.
+ * @return      New buddy system.
  */
-void buddy_system_create(buddy_system_t *b,
-             uint8_t max_order,
-             buddy_system_operations_t *op,
-             void *data)
+void
+buddy_system_create(buddy_system_t *b, uint8_t max_order,
+    buddy_system_operations_t *op, void *data)
 {
     int i;
 ,7 → 79,7
     ASSERT(op->mark_busy);
     /*
-     * Use memory after our own structure
+     * Use memory after our own structure.
      */
     b->order = (link_t *) (&b[1]);
 ,14 → 91,15
     b->data = data;
 }
-/** Check if buddy system can allocate block
+/** Check if buddy system can allocate block.
  *
- * @param b Buddy system pointer
- * @param i Size of the block (2^i)
+ * @param b     Buddy system pointer.
+ * @param i     Size of the block (2^i).
  *
- * @return True if block can be allocated
+ * @return      True if block can be allocated.
  */
-bool buddy_system_can_alloc(buddy_system_t *b, uint8_t i) {
+bool buddy_system_can_alloc(buddy_system_t *b, uint8_t i)
+{
     uint8_t k;
     /*
 ,12 → 106,13
      * If requested block is greater then maximal block
      * we know immediatly that we cannot satisfy the request.
      */
-    if (i > b->max_order) return false;
+    if (i > b->max_order)
+        return false;
     /*
      * Check if any bigger or equal order has free elements
      */
-    for (k=i; k <= b->max_order; k++) {
+    for (k = i; k <= b->max_order; k++) {
         if (!list_empty(&b->order[k])) {
             return true;
         }
 ,12 → 119,11
     }
     return false;
 }
-/** Allocate PARTICULAR block from buddy system
+/** Allocate PARTICULAR block from buddy system.
  *
- * @ return Block of data or NULL if no such block was found
+ * @return      Block of data or NULL if no such block was found.
  */
 link_t *buddy_system_alloc_block(buddy_system_t *b, link_t *block)
 {
 ,7 → 134,7
     ASSERT(left);
     list_remove(left);
     while (1) {
-        if (! b->op->get_order(b,left)) {
+        if (!b->op->get_order(b, left)) {
             b->op->mark_busy(b, left);
             return left;
         }
 ,8 → 142,8
         order = b->op->get_order(b, left);
         right = b->op->bisect(b, left);
-        b->op->set_order(b, left, order-1);
-        b->op->set_order(b, right, order-1);
+        b->op->set_order(b, left, order - 1);
+        b->op->set_order(b, right, order - 1);
         tmp = b->op->find_block(b, block, BUDDY_SYSTEM_INNER_BLOCK);
 ,10 → 160,10
 /** Allocate block from buddy system.
  *
- * @param b Buddy system pointer.
- * @param i Returned block will be 2^i big.
+ * @param b     Buddy system pointer.
+ * @param i     Returned block will be 2^i big.
  *
- * @return Block of data represented by link_t.
+ * @return      Block of data represented by link_t.
  */
 link_t *buddy_system_alloc(buddy_system_t *b, uint8_t i)
 {
 ,13 → 217,12
     buddy_system_free(b, hlp);
     return res;
 }
 /** Return block to buddy system.
  *
- * @param b Buddy system pointer.
- * @param block Block to return.
+ * @param b     Buddy system pointer.
+ * @param block     Block to return.
  */
 void buddy_system_free(buddy_system_t *b, link_t *block)
 {
 ,7 → 266,8
             b->op->set_order(b, hlp, i + 1);
             /*
-             * Recursively add the coalesced block to the list of order i + 1.
+             * Recursively add the coalesced block to the list of
+             * order i + 1.
              */
             buddy_system_free(b, hlp);
             return;
 ,46 → 278,7
      * Insert block into the list of order i.
      */
     list_append(block, &b->order[i]);
 }
-/** Prints out structure of buddy system
- *
- * @param b Pointer to buddy system
- * @param elem_size Element size
- */
-void buddy_system_structure_print(buddy_system_t *b, size_t elem_size) {
-    index_t i;
-    count_t cnt, elem_count = 0, block_count = 0;
-    link_t *cur;
-    printf("Order\tBlocks\tSize    \tBlock size\tElems per block\n");
-    printf("-----\t------\t--------\t----------\t---------------\n");
-    for (i = 0;i <= b->max_order; i++) {
-        cnt = 0;
-        if (!list_empty(&b->order[i])) {
-            for (cur = b->order[i].next; cur != &b->order[i]; cur = cur->next)
-                cnt++;
-        }
-        printf("#%" PRIi "\t%5" PRIc "\t%7" PRIc "K\t%8" PRIi "K\t%6u\t",
-            i, cnt, SIZE2KB(cnt * (1 << i) * elem_size), SIZE2KB((1 << i) * elem_size), 1 << i);
-        if (!list_empty(&b->order[i])) {
-            for (cur = b->order[i].next; cur != &b->order[i]; cur = cur->next) {
-                b->op->print_id(b, cur);
-                printf(" ");
-            }
-        }
-        printf("\n");
-        block_count += cnt;
-        elem_count += (1 << i) * cnt;
-    }
-    printf("-----\t------\t--------\t----------\t---------------\n");
-    printf("Buddy system contains %" PRIc " free elements (%" PRIc " blocks)\n" , elem_count, block_count);
-}
 /** @}
  */

 /branches/tracing/kernel/generic/src/mm/frame.c
 ,6 → 58,8
 #include <debug.h>
 #include <adt/list.h>
 #include <synch/spinlock.h>
+#include <synch/mutex.h>
+#include <synch/condvar.h>
 #include <arch/asm.h>
 #include <arch.h>
 #include <print.h>
 ,6 → 105,14
 static zones_t zones;
+/*
+ * Synchronization primitives used to sleep when there is no memory
+ * available.
+ */
+mutex_t mem_avail_mtx;
+condvar_t mem_avail_cv;
+unsigned long mem_avail_frames = 0; /**< Number of available frames. */
+unsigned long mem_avail_gen = 0;    /**< Generation counter. */
 /********************/
 /* Helper functions */
 ,11 → 139,9
     return (frame - zone->frames);
 }
-/** Initialize frame structure
+/** Initialize frame structure.
  *
- * Initialize frame structure.
- *
- * @param frame Frame structure to be initialized.
+ * @param frame     Frame structure to be initialized.
  */
 static void frame_initialize(frame_t *frame)
 {
 ,11 → 153,10
 /* Zoneinfo functions */
 /**********************/
-/**
- * Insert-sort zone into zones list
+/** Insert-sort zone into zones list.
  *
- * @param newzone New zone to be inserted into zone list
- * @return zone number on success, -1 on error
+ * @param newzone   New zone to be inserted into zone list.
+ * @return      Zone number on success, -1 on error.
  */
 static int zones_add_zone(zone_t *newzone)
 {
 ,7 → 178,8
     for (i = 0; i < zones.count; i++) {
         /* Check for overflow */
         z = zones.info[i];
-        if (overlaps(newzone->base, newzone->count, z->base, z->count)) {
+        if (overlaps(newzone->base, newzone->count, z->base,
+            z->count)) {
             printf("Zones overlap!\n");
             return -1;
         }
 ,17 → 200,16
     return i;
 }
-/**
- * Try to find a zone where can we find the frame
+/** Try to find a zone where can we find the frame.
  *
  * Assume interrupts are disabled.
  *
- * @param frame Frame number contained in zone
- * @param pzone If not null, it is used as zone hint. Zone index
- *              is filled into the variable on success.
- * @return Pointer to locked zone containing frame
+ * @param frame     Frame number contained in zone.
+ * @param pzone     If not null, it is used as zone hint. Zone index is
+ *          filled into the variable on success.
+ * @return      Pointer to locked zone containing frame.
  */
-static zone_t * find_zone_and_lock(pfn_t frame, unsigned int *pzone)
+static zone_t *find_zone_and_lock(pfn_t frame, unsigned int *pzone)
 {
     unsigned int i;
     unsigned int hint = pzone ? *pzone : 0;
 ,7 → 236,7
         i++;
         if (i >= zones.count)
             i = 0;
-    } while(i != hint);
+    } while (i != hint);
     spinlock_unlock(&zones.lock);
     return NULL;
 ,16 → 252,21
  *
  * Assume interrupts are disabled.
  *
- * @param order Size (2^order) of free space we are trying to find
- * @param pzone Pointer to preferred zone or NULL, on return contains zone
- *      number
+ * @param order     Size (2^order) of free space we are trying to find.
+ * @param flags     Required flags of the target zone.
+ * @param pzone     Pointer to preferred zone or NULL, on return contains
+ *          zone number.
  */
-static zone_t * find_free_zone_and_lock(uint8_t order, unsigned int *pzone)
+static zone_t *
+find_free_zone_and_lock(uint8_t order, int flags, unsigned int *pzone)
 {
     unsigned int i;
     zone_t *z;
     unsigned int hint = pzone ? *pzone : 0;
+    /* Mask off flags that are not applicable. */
+    flags &= FRAME_LOW_4_GiB;
     spinlock_lock(&zones.lock);
     if (hint >= zones.count)
         hint = 0;
 ,17 → 276,24
         spinlock_lock(&z->lock);
-        /* Check if the zone has 2^order frames area available  */
-        if (zone_can_alloc(z, order)) {
-            spinlock_unlock(&zones.lock);
-            if (pzone)
-                *pzone = i;
-            return z;
+        /*
+         * Check whether the zone meets the search criteria.
+         */
+        if ((z->flags & flags) == flags) {
+            /*
+             * Check if the zone has 2^order frames area available.
+             */
+            if (zone_can_alloc(z, order)) {
+                spinlock_unlock(&zones.lock);
+                if (pzone)
+                    *pzone = i;
+                return z;
+            }
         }
         spinlock_unlock(&z->lock);
         if (++i >= zones.count)
             i = 0;
-    } while(i != hint);
+    } while (i != hint);
     spinlock_unlock(&zones.lock);
     return NULL;
 }
 ,12 → 302,13
 /* Buddy system functions */
 /**************************/
-/** Buddy system find_block implementation
+/** Buddy system find_block implementation.
  *
  * Find block that is parent of current list.
  * That means go to lower addresses, until such block is found
  *
- * @param order - Order of parent must be different then this parameter!!
+ * @param order     Order of parent must be different then this
+ *          parameter!!
  */
 static link_t *zone_buddy_find_block(buddy_system_t *b, link_t *child,
     uint8_t order)
 ,24 → 329,12
     return NULL;
 }
-static void zone_buddy_print_id(buddy_system_t *b, link_t *block)
-{
-    frame_t *frame;
-    zone_t *zone;
-    index_t index;
-    frame = list_get_instance(block, frame_t, buddy_link);
-    zone = (zone_t *) b->data;
-    index = frame_index(zone, frame);
-    printf("%" PRIi, index);
-}
-/** Buddy system find_buddy implementation
+/** Buddy system find_buddy implementation.
  *
- * @param b Buddy system.
- * @param block Block for which buddy should be found
+ * @param b     Buddy system.
+ * @param block     Block for which buddy should be found.
  *
- * @return Buddy for given block if found
+ * @return      Buddy for given block if found.
  */
 static link_t *zone_buddy_find_buddy(buddy_system_t *b, link_t *block)
 {
 ,9 → 353,11
     ASSERT(is_left ^ is_right);
     if (is_left) {
-        index = (frame_index(zone, frame)) + (1 << frame->buddy_order);
+        index = (frame_index(zone, frame)) +
+            (1 << frame->buddy_order);
     } else {    /* if (is_right) */
-        index = (frame_index(zone, frame)) - (1 << frame->buddy_order);
+        index = (frame_index(zone, frame)) -
+            (1 << frame->buddy_order);
     }
     if (frame_index_valid(zone, index)) {
 ,14 → 370,15
     return NULL;
 }
-/** Buddy system bisect implementation
+/** Buddy system bisect implementation.
  *
- * @param b Buddy system.
- * @param block Block to bisect
+ * @param b     Buddy system.
+ * @param block     Block to bisect.
  *
- * @return right block
+ * @return      Right block.
  */
-static link_t * zone_buddy_bisect(buddy_system_t *b, link_t *block) {
+static link_t *zone_buddy_bisect(buddy_system_t *b, link_t *block)
+{
     frame_t *frame_l, *frame_r;
     frame_l = list_get_instance(block, frame_t, buddy_link);
 ,13 → 387,14
     return &frame_r->buddy_link;
 }
-/** Buddy system coalesce implementation
+/** Buddy system coalesce implementation.
  *
- * @param b Buddy system.
- * @param block_1 First block
- * @param block_2 First block's buddy
+ * @param b     Buddy system.
+ * @param block_1   First block.
+ * @param block_2   First block's buddy.
  *
- * @return Coalesced block (actually block that represents lower address)
+ * @return      Coalesced block (actually block that represents lower
+ *          address).
  */
 static link_t *zone_buddy_coalesce(buddy_system_t *b, link_t *block_1,
     link_t *block_2)
 ,39 → 407,41
     return frame1 < frame2 ? block_1 : block_2;
 }
-/** Buddy system set_order implementation
+/** Buddy system set_order implementation.
  *
- * @param b Buddy system.
- * @param block Buddy system block
- * @param order Order to set
+ * @param b     Buddy system.
+ * @param block     Buddy system block.
+ * @param order     Order to set.
  */
 static void zone_buddy_set_order(buddy_system_t *b, link_t *block,
-    uint8_t order) {
+    uint8_t order)
+{
     frame_t *frame;
     frame = list_get_instance(block, frame_t, buddy_link);
     frame->buddy_order = order;
 }
-/** Buddy system get_order implementation
+/** Buddy system get_order implementation.
  *
- * @param b Buddy system.
- * @param block Buddy system block
+ * @param b     Buddy system.
+ * @param block     Buddy system block.
  *
- * @return Order of block
+ * @return      Order of block.
  */
-static uint8_t zone_buddy_get_order(buddy_system_t *b, link_t *block) {
+static uint8_t zone_buddy_get_order(buddy_system_t *b, link_t *block)
+{
     frame_t *frame;
     frame = list_get_instance(block, frame_t, buddy_link);
     return frame->buddy_order;
 }
-/** Buddy system mark_busy implementation
+/** Buddy system mark_busy implementation.
  *
- * @param b Buddy system
- * @param block Buddy system block
- *
+ * @param b     Buddy system.
+ * @param block     Buddy system block.
  */
-static void zone_buddy_mark_busy(buddy_system_t *b, link_t * block) {
+static void zone_buddy_mark_busy(buddy_system_t *b, link_t * block)
+{
     frame_t * frame;
     frame = list_get_instance(block, frame_t, buddy_link);
 ,13 → 448,13
     frame->refcount = 1;
 }
-/** Buddy system mark_available implementation
+/** Buddy system mark_available implementation.
  *
- * @param b Buddy system
- * @param block Buddy system block
- *
+ * @param b     Buddy system.
+ * @param block     Buddy system block.
  */
-static void zone_buddy_mark_available(buddy_system_t *b, link_t *block) {
+static void zone_buddy_mark_available(buddy_system_t *b, link_t *block)
+{
     frame_t *frame;
     frame = list_get_instance(block, frame_t, buddy_link);
     frame->refcount = 0;
 ,8 → 468,7
     .get_order = zone_buddy_get_order,
     .mark_busy = zone_buddy_mark_busy,
     .mark_available = zone_buddy_mark_available,
-    .find_block = zone_buddy_find_block,
-    .print_id = zone_buddy_print_id
+    .find_block = zone_buddy_find_block
 };
 /******************/
 ,15 → 475,15
 /* Zone functions */
 /******************/
-/** Allocate frame in particular zone
+/** Allocate frame in particular zone.
  *
- * Assume zone is locked
+ * Assume zone is locked.
  * Panics if allocation is impossible.
  *
- * @param zone  Zone to allocate from.
- * @param order Allocate exactly 2^order frames.
+ * @param zone      Zone to allocate from.
+ * @param order     Allocate exactly 2^order frames.
  *
- * @return Frame index in zone
+ * @return      Frame index in zone.
  *
  */
 static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
 ,12 → 509,12
     return v;
 }
-/** Free frame from zone
+/** Free frame from zone.
  *
- * Assume zone is locked
+ * Assume zone is locked.
  *
- * @param zone Pointer to zone from which the frame is to be freed
- * @param frame_idx Frame index relative to zone
+ * @param zone      Pointer to zone from which the frame is to be freed.
+ * @param frame_idx Frame index relative to zone.
  */
 static void zone_frame_free(zone_t *zone, index_t frame_idx)
 {
 ,14 → 537,14
     }
 }
-/** Return frame from zone */
-static frame_t * zone_get_frame(zone_t *zone, index_t frame_idx)
+/** Return frame from zone. */
+static frame_t *zone_get_frame(zone_t *zone, index_t frame_idx)
 {
     ASSERT(frame_idx < zone->count);
     return &zone->frames[frame_idx];
 }
-/** Mark frame in zone unavailable to allocation */
+/** Mark frame in zone unavailable to allocation. */
 static void zone_mark_unavailable(zone_t *zone, index_t frame_idx)
 {
     frame_t *frame;
 ,18 → 557,21
         &frame->buddy_link);
     ASSERT(link);
     zone->free_count--;
+    mutex_lock(&mem_avail_mtx);
+    mem_avail_frames--;
+    mutex_unlock(&mem_avail_mtx);
 }
-/**
- * Join 2 zones
+/** Join two zones.
  *
- * Expect zone_t *z to point to space at least zone_conf_size large
+ * Expect zone_t *z to point to space at least zone_conf_size large.
  *
- * Assume z1 & z2 are locked
+ * Assume z1 & z2 are locked.
  *
- * @param z Target zone structure pointer
- * @param z1 Zone to merge
- * @param z2 Zone to merge
+ * @param z     Target zone structure pointer.
+ * @param z1        Zone to merge.
+ * @param z2        Zone to merge.
  */
 static void _zone_merge(zone_t *z, zone_t *z1, zone_t *z2)
 {
 ,7 → 645,7
     }
 }
-/** Return old configuration frames into the zone
+/** Return old configuration frames into the zone.
  *
  * We have several cases
  * - the conf. data is outside of zone -> exit, shall we call frame_free??
 ,9 → 652,9
  * - the conf. data was created by zone_create or
  *   updated with reduce_region -> free every frame
  *
- * @param newzone The actual zone where freeing should occur
- * @param oldzone Pointer to old zone configuration data that should
- *                be freed from new zone
+ * @param newzone   The actual zone where freeing should occur.
+ * @param oldzone   Pointer to old zone configuration data that should
+ *          be freed from new zone.
  */
 static void return_config_frames(zone_t *newzone, zone_t *oldzone)
 {
 ,7 → 678,7
     }
 }
-/** Reduce allocated block to count of order 0 frames
+/** Reduce allocated block to count of order 0 frames.
  *
  * The allocated block need 2^order frames of space. Reduce all frames
  * in block to order 0 and free the unneeded frames. This means, that
 ,8 → 686,8
  * you have to free every frame.
  *
  * @param zone
- * @param frame_idx Index to block
- * @param count Allocated space in block
+ * @param frame_idx     Index to block.
+ * @param count         Allocated space in block.
  */
 static void zone_reduce_region(zone_t *zone, pfn_t frame_idx, count_t count)
 {
 ,7 → 714,7
     }
 }
-/** Merge zones z1 and z2
+/** Merge zones z1 and z2.
  *
  * - the zones must be 2 zones with no zone existing in between,
  *   which means that z2 = z1+1
 ,7 → 738,7
     if ((z1 >= zones.count) || (z2 >= zones.count))
         goto errout;
     /* We can join only 2 zones with none existing inbetween */
-    if (z2-z1 != 1)
+    if (z2 - z1 != 1)
         goto errout;
     zone1 = zones.info[z1];
 ,8 → 789,7
     interrupts_restore(ipl);
 }
-/**
- * Merge all zones into one big zone
+/** Merge all zones into one big zone.
  *
  * It is reasonable to do this on systems whose bios reports parts in chunks,
  * so that we could have 1 zone (it's faster).
 ,21 → 799,19
     int count = zones.count;
     while (zones.count > 1 && --count) {
-        zone_merge(0,1);
+        zone_merge(0, 1);
         break;
     }
 }
-/** Create frame zone
+/** Create new frame zone.
  *
- * Create new frame zone.
+ * @param start     Physical address of the first frame within the zone.
+ * @param count     Count of frames in zone.
+ * @param z     Address of configuration information of zone.
+ * @param flags     Zone flags.
  *
- * @param start Physical address of the first frame within the zone.
- * @param count Count of frames in zone
- * @param z Address of configuration information of zone
- * @param flags Zone flags.
- *
- * @return Initialized zone.
+ * @return      Initialized zone.
  */
 static void zone_construct(pfn_t start, count_t count, zone_t *z, int flags)
 {
 ,7 → 821,15
     spinlock_initialize(&z->lock, "zone_lock");
     z->base = start;
     z->count = count;
+    /* Mask off flags that are calculated automatically. */
+    flags &= ~FRAME_LOW_4_GiB;
+    /* Determine calculated flags. */
+    if (z->base + count < (1ULL << (32 - FRAME_WIDTH))) /* 4 GiB */
+        flags |= FRAME_LOW_4_GiB;
     z->flags = flags;
     z->free_count = count;
     z->busy_count = 0;
 ,8 → 840,7
     z->buddy_system = (buddy_system_t *)&z[1];
     buddy_system_create(z->buddy_system, max_order,
-                &zone_buddy_system_operations,
-                (void *) z);
+        &zone_buddy_system_operations, (void *) z);
     /* Allocate frames _after_ the conframe */
     /* Check sizes */
 ,10 → 857,10
     }
 }
-/** Compute configuration data size for zone
+/** Compute configuration data size for zone.
  *
- * @param count Size of zone in frames
- * @return Size of zone configuration info (in bytes)
+ * @param count     Size of zone in frames.
+ * @return      Size of zone configuration info (in bytes).
  */
 uintptr_t zone_conf_size(count_t count)
 {
 ,20 → 872,20
     return size;
 }
-/** Create and add zone to system
+/** Create and add zone to system.
  *
- * @param start First frame number (absolute)
- * @param count Size of zone in frames
- * @param confframe Where configuration frames are supposed to be.
- *                  Automatically checks, that we will not disturb the
- *                  kernel and possibly init.
- *                  If confframe is given _outside_ this zone, it is expected,
- *                  that the area is already marked BUSY and big enough
- *                  to contain zone_conf_size() amount of data.
- *                  If the confframe is inside the area, the zone free frame
- *                  information is modified not to include it.
+ * @param start     First frame number (absolute).
+ * @param count     Size of zone in frames.
+ * @param confframe Where configuration frames are supposed to be.
+ *          Automatically checks, that we will not disturb the
+ *          kernel and possibly init.  If confframe is given
+ *          _outside_ this zone, it is expected, that the area is
+ *          already marked BUSY and big enough to contain
+ *          zone_conf_size() amount of data.  If the confframe is
+ *          inside the area, the zone free frame information is
+ *          modified not to include it.
  *
- * @return Zone number or -1 on error
+ * @return      Zone number or -1 on error.
  */
 int zone_create(pfn_t start, count_t count, pfn_t confframe, int flags)
 {
 ,8 → 904,8
      * it does not span kernel & init
      */
     confcount = SIZE2FRAMES(zone_conf_size(count));
-    if (confframe >= start && confframe < start+count) {
-        for (;confframe < start + count; confframe++) {
+    if (confframe >= start && confframe < start + count) {
+        for (; confframe < start + count; confframe++) {
             addr = PFN2ADDR(confframe);
             if (overlaps(addr, PFN2ADDR(confcount),
                 KA2PA(config.base), config.kernel_size))
 ,11 → 939,16
     if (znum == -1)
         return -1;
+    mutex_lock(&mem_avail_mtx);
+    mem_avail_frames += count;
+    mutex_unlock(&mem_avail_mtx);
     /* If confdata in zone, mark as unavailable */
     if (confframe >= start && confframe < start + count)
         for (i = confframe; i < confframe + confcount; i++) {
             zone_mark_unavailable(z, i - z->base);
         }
     return znum;
 }
 ,7 → 955,7
 /***************************************/
 /* Frame functions */
-/** Set parent of frame */
+/** Set parent of frame. */
 void frame_set_parent(pfn_t pfn, void *data, unsigned int hint)
 {
     zone_t *zone = find_zone_and_lock(pfn, &hint);
 ,7 → 962,7
     ASSERT(zone);
-    zone_get_frame(zone, pfn-zone->base)->parent = data;
+    zone_get_frame(zone, pfn - zone->base)->parent = data;
     spinlock_unlock(&zone->lock);
 }
 ,19 → 980,20
 /** Allocate power-of-two frames of physical memory.
  *
- * @param order  Allocate exactly 2^order frames.
- * @param flags  Flags for host zone selection and address processing.
- * @param pzone  Preferred zone
+ * @param order     Allocate exactly 2^order frames.
+ * @param flags     Flags for host zone selection and address processing.
+ * @param pzone     Preferred zone.
  *
- * @return Physical address of the allocated frame.
+ * @return      Physical address of the allocated frame.
  *
  */
-void * frame_alloc_generic(uint8_t order, int flags, unsigned int *pzone)
+void *frame_alloc_generic(uint8_t order, int flags, unsigned int *pzone)
 {
     ipl_t ipl;
     int freed;
     pfn_t v;
     zone_t *zone;
+    unsigned long gen = 0;
 loop:
     ipl = interrupts_disable();
 ,7 → 1001,7
     /*
      * First, find suitable frame zone.
      */
-    zone = find_free_zone_and_lock(order, pzone);
+    zone = find_free_zone_and_lock(order, flags, pzone);
     /* If no memory, reclaim some slab memory,
        if it does not help, reclaim all */
 ,23 → 1008,51
     if (!zone && !(flags & FRAME_NO_RECLAIM)) {
         freed = slab_reclaim(0);
         if (freed)
-            zone = find_free_zone_and_lock(order, pzone);
+            zone = find_free_zone_and_lock(order, flags, pzone);
         if (!zone) {
             freed = slab_reclaim(SLAB_RECLAIM_ALL);
             if (freed)
-                zone = find_free_zone_and_lock(order, pzone);
+                zone = find_free_zone_and_lock(order, flags,
+                    pzone);
         }
     }
     if (!zone) {
         /*
-         * TODO: Sleep until frames are available again.
+         * Sleep until some frames are available again.
          */
-        interrupts_restore(ipl);
-        if (flags & FRAME_ATOMIC)
+        if (flags & FRAME_ATOMIC) {
+            interrupts_restore(ipl);
             return 0;
+        }
-        panic("Sleep not implemented.\n");
+#ifdef CONFIG_DEBUG
+        unsigned long avail;
+        mutex_lock(&mem_avail_mtx);
+        avail = mem_avail_frames;
+        mutex_unlock(&mem_avail_mtx);
+        printf("Thread %" PRIu64 " waiting for %u frames, "
+            "%u available.\n", THREAD->tid, 1ULL << order, avail);
+#endif
+        mutex_lock(&mem_avail_mtx);
+        while ((mem_avail_frames < (1ULL << order)) ||
+            gen == mem_avail_gen)
+            condvar_wait(&mem_avail_cv, &mem_avail_mtx);
+        gen = mem_avail_gen;
+        mutex_unlock(&mem_avail_mtx);
+#ifdef CONFIG_DEBUG
+        mutex_lock(&mem_avail_mtx);
+        avail = mem_avail_frames;
+        mutex_unlock(&mem_avail_mtx);
+        printf("Thread %" PRIu64 " woken up, %u frames available.\n",
+            THREAD->tid, avail);
+#endif
+        interrupts_restore(ipl);
         goto loop;
     }
 ,6 → 1060,11
     v += zone->base;
     spinlock_unlock(&zone->lock);
+    mutex_lock(&mem_avail_mtx);
+    mem_avail_frames -= (1ULL << order);
+    mutex_unlock(&mem_avail_mtx);
     interrupts_restore(ipl);
     if (flags & FRAME_KA)
 ,7 → 1078,7
  * Decrement frame reference count.
  * If it drops to zero, move the frame structure to free list.
  *
- * @param Frame Physical Address of of the frame to be freed.
+ * @param frame     Physical Address of of the frame to be freed.
  */
 void frame_free(uintptr_t frame)
 {
 ,16 → 1087,26
     pfn_t pfn = ADDR2PFN(frame);
     ipl = interrupts_disable();
     /*
      * First, find host frame zone for addr.
      */
-    zone = find_zone_and_lock(pfn,NULL);
+    zone = find_zone_and_lock(pfn, NULL);
     ASSERT(zone);
-    zone_frame_free(zone, pfn-zone->base);
+    zone_frame_free(zone, pfn - zone->base);
     spinlock_unlock(&zone->lock);
+    /*
+     * Signal that some memory has been freed.
+     */
+    mutex_lock(&mem_avail_mtx);
+    mem_avail_frames++;
+    mem_avail_gen++;
+    condvar_broadcast(&mem_avail_cv);
+    mutex_unlock(&mem_avail_mtx);
     interrupts_restore(ipl);
 }
 ,7 → 1115,7
  * Find respective frame structure for supplied PFN and
  * increment frame reference count.
  *
- * @param pfn Frame number of the frame to be freed.
+ * @param pfn       Frame number of the frame to be freed.
  */
 void frame_reference_add(pfn_t pfn)
 {
 ,10 → 1128,10
     /*
      * First, find host frame zone for addr.
      */
-    zone = find_zone_and_lock(pfn,NULL);
+    zone = find_zone_and_lock(pfn, NULL);
     ASSERT(zone);
-    frame = &zone->frames[pfn-zone->base];
+    frame = &zone->frames[pfn - zone->base];
     frame->refcount++;
     spinlock_unlock(&zone->lock);
 ,7 → 1138,7
     interrupts_restore(ipl);
 }
-/** Mark given range unavailable in frame zones */
+/** Mark given range unavailable in frame zones. */
 void frame_mark_unavailable(pfn_t start, count_t count)
 {
     unsigned int i;
 ,15 → 1155,14
     }
 }
-/** Initialize physical memory management
- *
- * Initialize physical memory managemnt.
- */
+/** Initialize physical memory management. */
 void frame_init(void)
 {
     if (config.cpu_active == 1) {
         zones.count = 0;
         spinlock_initialize(&zones.lock, "zones.lock");
+        mutex_initialize(&mem_avail_mtx, MUTEX_ACTIVE);
+        condvar_initialize(&mem_avail_cv);
     }
     /* Tell the architecture to create some memory */
     frame_arch_init();
 ,10 → 1190,9
 }
-/** Return total size of all zones
- *
- */
-uint64_t zone_total_size(void) {
+/** Return total size of all zones. */
+uint64_t zone_total_size(void)
+{
     zone_t *zone = NULL;
     unsigned int i;
     ipl_t ipl;
 ,19 → 1214,13
     return total;
 }
-/** Prints list of zones
- *
- */
-void zone_print_list(void) {
+/** Prints list of zones. */
+void zone_print_list(void)
+{
     zone_t *zone = NULL;
     unsigned int i;
     ipl_t ipl;
-    ipl = interrupts_disable();
-    spinlock_lock(&zones.lock);
 #ifdef __32_BITS__
     printf("#  base address free frames  busy frames\n");
     printf("-- ------------ ------------ ------------\n");
 ,35 → 1231,69
     printf("-- -------------------- ------------ ------------\n");
 #endif
-    for (i = 0; i < zones.count; i++) {
+    /*
+     * Because printing may require allocation of memory, we may not hold
+     * the frame allocator locks when printing zone statistics.  Therefore,
+     * we simply gather the statistics under the protection of the locks and
+     * print the statistics when the locks have been released.
+     *
+     * When someone adds/removes zones while we are printing the statistics,
+     * we may end up with inaccurate output (e.g. a zone being skipped from
+     * the listing).
+     */
+    for (i = 0; ; i++) {
+        uintptr_t base;
+        count_t free_count;
+        count_t busy_count;
+        ipl = interrupts_disable();
+        spinlock_lock(&zones.lock);
+        if (i >= zones.count) {
+            spinlock_unlock(&zones.lock);
+            interrupts_restore(ipl);
+            break;
+        }
         zone = zones.info[i];
         spinlock_lock(&zone->lock);
+        base = PFN2ADDR(zone->base);
+        free_count = zone->free_count;
+        busy_count = zone->busy_count;
+        spinlock_unlock(&zone->lock);
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
 #ifdef __32_BITS__
-        printf("%-2u   %10p %12" PRIc " %12" PRIc "\n", i, PFN2ADDR(zone->base),
-            zone->free_count, zone->busy_count);
+        printf("%-2u   %10p %12" PRIc " %12" PRIc "\n", i, base,
+            free_count, busy_count);
 #endif
 #ifdef __64_BITS__
-        printf("%-2u   %18p %12" PRIc " %12" PRIc "\n", i, PFN2ADDR(zone->base),
-            zone->free_count, zone->busy_count);
+        printf("%-2u   %18p %12" PRIc " %12" PRIc "\n", i, base,
+            free_count, busy_count);
 #endif
-        spinlock_unlock(&zone->lock);
     }
-    spinlock_unlock(&zones.lock);
-    interrupts_restore(ipl);
 }
 /** Prints zone details.
  *
- * @param num Zone base address or zone number.
+ * @param num       Zone base address or zone number.
  */
-void zone_print_one(unsigned int num) {
+void zone_print_one(unsigned int num)
+{
     zone_t *zone = NULL;
     ipl_t ipl;
     unsigned int i;
+    uintptr_t base;
+    count_t count;
+    count_t busy_count;
+    count_t free_count;
     ipl = interrupts_disable();
     spinlock_lock(&zones.lock);
 ,25 → 1305,28
         }
     }
     if (!zone) {
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
         printf("Zone not found.\n");
-        goto out;
+        return;
     }
     spinlock_lock(&zone->lock);
-    printf("Memory zone information\n");
-    printf("Zone base address: %p\n", PFN2ADDR(zone->base));
-    printf("Zone size: %" PRIc " frames (%" PRIs " KB)\n", zone->count,
-        SIZE2KB(FRAMES2SIZE(zone->count)));
-    printf("Allocated space: %" PRIc " frames (%" PRIs " KB)\n", zone->busy_count,
-        SIZE2KB(FRAMES2SIZE(zone->busy_count)));
-    printf("Available space: %" PRIc " frames (%" PRIs " KB)\n", zone->free_count,
-        SIZE2KB(FRAMES2SIZE(zone->free_count)));
-    buddy_system_structure_print(zone->buddy_system, FRAME_SIZE);
+    base = PFN2ADDR(zone->base);
+    count = zone->count;
+    busy_count = zone->busy_count;
+    free_count = zone->free_count;
     spinlock_unlock(&zone->lock);
-out:
     spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+    printf("Zone base address: %p\n", base);
+    printf("Zone size: %" PRIc " frames (%" PRIs " KiB)\n", count,
+        SIZE2KB(FRAMES2SIZE(count)));
+    printf("Allocated space: %" PRIc " frames (%" PRIs " KiB)\n",
+        busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
+    printf("Available space: %" PRIc " frames (%" PRIs " KiB)\n",
+        free_count, SIZE2KB(FRAMES2SIZE(free_count)));
 }
 /** @}

 /branches/tracing/kernel/generic/src/mm/backend_elf.c
 ,7 → 118,7
              */
             for (i = 0; i < leaf->keys; i++) {
-                if (leaf->key[i] == page) {
+                if (leaf->key[i] == page - area->base) {
                     found = true;
                     break;
                 }

/branches/tracing/kernel/generic/src/syscall/syscall.c
38,6 → 38,7
#include <syscall/syscall.h>
#include <proc/thread.h>
#include <proc/task.h>
#include <proc/program.h>
#include <mm/as.h>
#include <print.h>
#include <putchar.h>
46,6 → 47,7
#include <debug.h>
#include <ipc/sysipc.h>
#include <synch/futex.h>
#include <synch/smc.h>
#include <ddi/ddi.h>
#include <security/cap.h>
#include <syscall/copy.h>
133,15 → 135,17
(syshandler_t) sys_thread_get_id,

(syshandler_t) sys_task_get_id,
(syshandler_t) sys_task_spawn,
(syshandler_t) sys_program_spawn_loader,

/* Synchronization related syscalls. */
(syshandler_t) sys_futex_sleep_timeout,
(syshandler_t) sys_futex_wakeup,
(syshandler_t) sys_smc_coherence,

/* Address space related syscalls. */
(syshandler_t) sys_as_area_create,
(syshandler_t) sys_as_area_resize,
(syshandler_t) sys_as_area_change_flags,
(syshandler_t) sys_as_area_destroy,

/* IPC related syscalls. */

 /branches/tracing/kernel/generic/src/ipc/ipcrsc.c
 ,7 → 170,6
     int i;
     spinlock_lock(&TASK->lock);
     for (i = 0; i < IPC_MAX_PHONES; i++) {
         if (TASK->phones[i].state == IPC_PHONE_HUNGUP &&
             atomic_get(&TASK->phones[i].active_calls) == 0)
 ,8 → 182,9
     }
     spinlock_unlock(&TASK->lock);
-    if (i >= IPC_MAX_PHONES)
+    if (i == IPC_MAX_PHONES)
         return -1;
     return i;
 }

 /branches/tracing/kernel/generic/src/ipc/sysipc.c
 ,12 → 271,12
             /* The recipient agreed to receive data. */
             int rc;
             uintptr_t dst;
-            uintptr_t size;
-            uintptr_t max_size;
+            size_t size;
+            size_t max_size;
-            dst = IPC_GET_ARG1(answer->data);
-            size = IPC_GET_ARG2(answer->data);
-            max_size = IPC_GET_ARG2(*olddata);
+            dst = (uintptr_t)IPC_GET_ARG1(answer->data);
+            size = (size_t)IPC_GET_ARG2(answer->data);
+            max_size = (size_t)IPC_GET_ARG2(*olddata);
             if (size <= max_size) {
                 rc = copy_to_uspace((void *) dst,
 ,7 → 453,9
     IPC_SET_ARG5(call.data, 0);
     if (!(res = request_preprocess(&call, phone))) {
-        ipc_call_sync(phone, &call);
+        rc = ipc_call_sync(phone, &call);
+        if (rc != EOK)
+            return rc;
         process_answer(&call);
     } else {
         IPC_SET_RETVAL(call.data, res);
 ,7 → 493,9
     GET_CHECK_PHONE(phone, phoneid, return ENOENT);
     if (!(res = request_preprocess(&call, phone))) {
-        ipc_call_sync(phone, &call);
+        rc = ipc_call_sync(phone, &call);
+        if (rc != EOK)
+            return rc;
         process_answer(&call);
     } else
         IPC_SET_RETVAL(call.data, res);

 /branches/tracing/kernel/generic/src/ipc/ipc.c
 ,7 → 88,8
     call_t *call;
     call = slab_alloc(ipc_call_slab, flags);
-    _ipc_call_init(call);
+    if (call)
+        _ipc_call_init(call);
     return call;
 }
 ,7 → 162,7
  */
 void ipc_phone_init(phone_t *phone)
 {
-    mutex_initialize(&phone->lock);
+    mutex_initialize(&phone->lock, MUTEX_PASSIVE);
     phone->callee = NULL;
     phone->state = IPC_PHONE_FREE;
     atomic_set(&phone->active_calls, 0);
 ,8 → 172,10
  *
  * @param phone     Destination kernel phone structure.
  * @param request   Call structure with request.
+ *
+ * @return      EOK on success or EINTR if the sleep was interrupted.
  */
-void ipc_call_sync(phone_t *phone, call_t *request)
+int ipc_call_sync(phone_t *phone, call_t *request)
 {
     answerbox_t sync_box;
 ,7 → 185,10
     request->callerbox = &sync_box;
     ipc_call(phone, request);
-    ipc_wait_for_call(&sync_box, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
+    if (!ipc_wait_for_call(&sync_box, SYNCH_NO_TIMEOUT,
+        SYNCH_FLAGS_INTERRUPTIBLE))
+        return EINTR;
+    return EOK;
 }
 /** Answer a message which was not dispatched and is not listed in any queue.
 ,6 → 201,13
     call->flags |= IPC_CALL_ANSWERED;
+    if (call->flags & IPC_CALL_FORWARDED) {
+        if (call->caller_phone) {
+            /* Demasquerade the caller phone. */
+            call->data.phone = call->caller_phone;
+        }
+    }
     spinlock_lock(&callerbox->lock);
     list_append(&call->link, &callerbox->answers);
     spinlock_unlock(&callerbox->lock);
 ,8 → 360,11
     list_remove(&call->link);
     spinlock_unlock(&oldbox->lock);
-    if (mode & IPC_FF_ROUTE_FROM_ME)
+    if (mode & IPC_FF_ROUTE_FROM_ME) {
+        if (!call->caller_phone)
+            call->caller_phone = call->data.phone;
         call->data.phone = newphone;
+    }
     return ipc_call(newphone, call);
 }
 ,8 → 682,9
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
-            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call, call->sender->taskid,
+            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
+            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
+            call->sender->taskid,
             IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
 ,8 → 697,9
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
-            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call, call->sender->taskid,
+            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
+            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
+            call->sender->taskid,
             IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
 ,11 → 707,12
     }
     /* Print answerbox - calls */
     printf("ABOX - ANSWERS:\n");
-    for (tmp = task->answerbox.answers.next; tmp != &task->answerbox.answers;
+    for (tmp = task->answerbox.answers.next;
+        tmp != &task->answerbox.answers;
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid:%p M:%" PRIun " A1:%" PRIun " A2:%" PRIun
-            " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
+            " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
             call, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3424 → Rev 3425