WebSVN – HelenOS – Path Comparison – / – /branches/network/kernel/generic/include Rev 3370 and /branches/network/kernel/generic/include Rev 3386

Ignore whitespace Rev 3370 → Rev 3386

 /branches/network/kernel/generic/include/ipc/ipc.h
 ,6 → 205,8
 #define IPC_MAX_PHONES  16
+#include <synch/spinlock.h>
+#include <synch/mutex.h>
 #include <synch/waitq.h>
 struct answerbox;
 ,7 → 227,7
 /** Structure identifying phone (in TASK structure) */
 typedef struct {
-    SPINLOCK_DECLARE(lock);
+    mutex_t lock;
     link_t link;
     struct answerbox *callee;
     ipc_phone_state_t state;
 ,6 → 260,12
 typedef struct {
     unative_t args[IPC_CALL_LEN];
     phone_t *phone;
+    /*
+     * 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;
 } ipc_data_t;
 typedef struct {
 ,23 → 290,22
 } 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);
-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_phone_hangup(phone_t *);
+extern void ipc_backsend_err(phone_t *, call_t *, unative_t);
+extern void ipc_print_task(task_id_t);
 extern answerbox_t *ipc_phone_0;

/branches/network/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/network/kernel/generic/include/lib/objc_ext.h
File deleted

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

 /branches/network/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
 ,8 → 337,12
 typedef struct elf64_symbol elf_symbol_t;
 #endif
-extern char *elf_error(int rc);
+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/network/kernel/generic/include/lib/rd.h
 ,16 → 66,18
 #define RE_UNSUPPORTED      2   /* Non-supported image (e.g. wrong version) */
 /** RAM disk header */
-typedef struct {
+struct rd_header {
     uint8_t magic[RD_MAGIC_SIZE];
     uint8_t version;
     uint8_t data_type;
     uint32_t header_size;
     uint64_t data_size;
-} rd_header;
+} __attribute__ ((packed));
-extern int init_rd(rd_header * addr, size_t size);
+typedef struct rd_header rd_header_t;
+extern int init_rd(rd_header_t *addr, size_t size);
 #endif
 /** @}

 /branches/network/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 → 251,19
 extern mem_backend_t elf_backend;
 extern mem_backend_t phys_backend;
-extern 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/network/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/network/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/network/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/network/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)   ((PAGE_SIZE << (cache)->order) >> 2)
+#define SLAB_MAX_BADNESS(cache) \
+    (((unsigned int) PAGE_SIZE << (cache)->order) >> 2)
 /* slab_reclaim constants */
 ,8 → 100,8
     int flags;
     /* Computed values */
-    uint8_t order;      /**< Order of frames to be allocated */
-    int objects;        /**< Number of objects that fit in */
+    uint8_t order;          /**< Order of frames to be allocated */
+    unsigned int objects;       /**< Number of objects that fit in */
     /* Statistics */
     atomic_t allocated_slabs;
 ,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/network/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/network/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/network/kernel/generic/include/proc/task.h
116,7 → 116,6
extern void task_done(void);
extern task_t task_create(as_t as, char *name);
extern void task_destroy(task_t *t);
extern task_t task_run_program(void program_addr, char *name);
extern task_t *task_find_by_id(task_id_t id);
extern int task_kill(task_id_t id);
extern uint64_t task_get_accounting(task_t *t);

 /branches/network/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/network/kernel/generic/include/proc/tasklet.h
 ,0 → 1,73
+/*
+ * Copyright (c) 2007 Jan Hudecek
+ * Copyright (c) 2008 Martin Decky
+ * 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 tasklet.h
+ * @brief Tasklets declarations
+ */
+#ifndef KERN_TASKLET_H_
+#define KERN_TASKLET_H_
+#include <adt/list.h>
+/** Tasklet callback type */
+typedef void (* tasklet_callback_t)(void *arg);
+/** Tasklet state */
+typedef enum {
+    NotActive,
+    Scheduled,
+    InProgress,
+    Disabled
+} tasklet_state_t;
+/** Structure describing a tasklet */
+typedef struct tasklet_descriptor {
+    link_t link;
+    /** Callback to call */
+    tasklet_callback_t callback;
+    /** Argument passed to the callback */
+    void *arg;
+    /** State of the tasklet */
+    tasklet_state_t state;
+} tasklet_descriptor_t;
+extern void tasklet_init(void);
+#endif
+/** @}
+ */

 /branches/network/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/network/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/network/kernel/generic/include/synch/spinlock.h
 ,8 → 110,8
 #define DEADLOCK_PROBE(pname, value)                    \
     if ((pname)++ > (value)) {                  \
         (pname) = 0;                        \
-        printf("Deadlock probe %s: exceeded threshold %d\n",    \
-            "cpu%d: function=%s, line=%d\n",            \
+        printf("Deadlock probe %s: exceeded threshold %u\n",    \
+            "cpu%u: function=%s, line=%u\n",            \
             #pname, (value), CPU->id, __func__, __LINE__);  \
     }
 #else

 /branches/network/kernel/generic/include/syscall/syscall.h
 ,17 → 36,25
 #define KERN_SYSCALL_H_
 typedef enum {
-    SYS_IO = 0,
+    SYS_KLOG = 0,
     SYS_TLS_SET = 1, /* Hardcoded in AMD64, IA32 uspace - fibril.S */
     SYS_THREAD_CREATE,
     SYS_THREAD_EXIT,
     SYS_THREAD_GET_ID,
     SYS_TASK_GET_ID,
+    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,
     SYS_IPC_CALL_SYNC_SLOW,
     SYS_IPC_CALL_ASYNC_FAST,
 ,13 → 66,17
     SYS_IPC_HANGUP,
     SYS_IPC_REGISTER_IRQ,
     SYS_IPC_UNREGISTER_IRQ,
     SYS_CAP_GRANT,
     SYS_CAP_REVOKE,
     SYS_PHYSMEM_MAP,
     SYS_IOSPACE_ENABLE,
     SYS_PREEMPT_CONTROL,
     SYS_SYSINFO_VALID,
     SYS_SYSINFO_VALUE,
     SYS_DEBUG_ENABLE_CONSOLE,
     SYSCALL_END
 } syscall_t;

 /branches/network/kernel/generic/include/memstr.h
 ,8 → 42,8
  * Architecture independent variants.
  */
 extern void *_memcpy(void *dst, const void *src, size_t cnt);
-extern void _memsetb(uintptr_t dst, size_t cnt, uint8_t x);
-extern void _memsetw(uintptr_t dst, size_t cnt, uint16_t x);
+extern void _memsetb(void *dst, size_t cnt, uint8_t x);
+extern void _memsetw(void *dst, size_t cnt, uint16_t x);
 extern char *strcpy(char *dest, const char *src);
 #endif

 /branches/network/kernel/generic/include/typedefs.h
 ,8 → 35,22
 #ifndef KERN_TYPEDEFS_H_
 #define KERN_TYPEDEFS_H_
+#include <arch/types.h>
+#define NULL 0
+#define false 0
+#define true 1
 typedef void (* function)();
+typedef uint8_t bool;
+typedef uint64_t thread_id_t;
+typedef uint64_t task_id_t;
+typedef uint32_t context_id_t;
+typedef int32_t inr_t;
+typedef int32_t devno_t;
 #endif
 /** @}

/branches/network/kernel/generic/include/console/klog.h
File deleted

 /branches/network/kernel/generic/include/console/console.h
 ,6 → 41,9
 extern chardev_t *stdin;
 extern chardev_t *stdout;
+extern void klog_init(void);
+extern void klog_update(void);
 extern uint8_t getc(chardev_t *chardev);
 uint8_t _getc(chardev_t *chardev);
 extern count_t gets(chardev_t *chardev, char *buf, size_t buflen);

 /branches/network/kernel/generic/include/stackarg.h
 ,9 → 52,9
     (ap).last = (uint8_t *) &(lst)
 #define va_arg(ap, type)        \
-    (*((type *)((ap).last + ((ap).pos  += sizeof(type) ) - sizeof(type))))
+    (*((type *)((ap).last + ((ap).pos += sizeof(type)) - sizeof(type))))
-#define va_copy(dst,src)       dst=src
+#define va_copy(dst, src) dst = src
 #define va_end(ap)

 /branches/network/kernel/generic/include/interrupt.h
 ,7 → 40,6
 #include <proc/task.h>
 #include <proc/thread.h>
 #include <arch.h>
-#include <console/klog.h>
 #include <ddi/irq.h>
 typedef void (* iroutine)(int n, istate_t *istate);
 ,8 → 48,8
 { \
     if (istate_from_uspace(istate)) { \
         task_t *task = TASK; \
-        klog_printf("Task %llu killed due to an exception at %p.", task->taskid, istate_get_pc(istate)); \
-        klog_printf("  " cmd, ##__VA_ARGS__); \
+        printf("Task %" PRIu64 " killed due to an exception at %p.", task->taskid, istate_get_pc(istate)); \
+        printf("  " cmd, ##__VA_ARGS__); \
         task_kill(task->taskid); \
         thread_exit(); \
     } \

 /branches/network/kernel/generic/include/ddi/device.h
 ,6 → 35,9
 #ifndef KERN_DEVICE_H_
 #define KERN_DEVICE_H_
+#include <arch/types.h>
+#include <typedefs.h>
 extern devno_t device_assign_devno(void);
 #endif

/branches/network/kernel/generic/include/adt/list.h
36,6 → 36,7
#define KERN_LIST_H_

#include <arch/types.h>
#include <typedefs.h>

/** Doubly linked list head and link type. */
typedef struct link {

/branches/network/kernel/generic/include/adt/avl.h
36,6 → 36,7
#define KERN_AVLTREE_H_

#include <arch/types.h>
#include <typedefs.h>

/**
* Macro for getting a pointer to the structure which contains the avltree

 /branches/network/kernel/generic/include/debug.h
 ,11 → 38,11
 #include <panic.h>
 #include <arch/debug.h>
-#define CALLER       ((uintptr_t)__builtin_return_address(0))
+#define CALLER ((uintptr_t) __builtin_return_address(0))
 #ifndef HERE
 /** Current Instruction Pointer address */
-#  define HERE ((uintptr_t *) 0)
+#   define HERE ((uintptr_t *) 0)
 #endif
 /** Debugging ASSERT macro
 ,12 → 55,51
  *
  */
 #ifdef CONFIG_DEBUG
-#   define ASSERT(expr) if (!(expr)) { panic("assertion failed (%s), caller=%.*p\n", #expr, sizeof(uintptr_t) * 2, CALLER); }
+#   define ASSERT(expr) \
+        if (!(expr)) { \
+            panic("assertion failed (%s), caller=%p\n", #expr, CALLER); \
+        }
 #else
 #   define ASSERT(expr)
 #endif
+/** Extensive debugging output macro
+ *
+ * If CONFIG_EDEBUG is set, the LOG() macro
+ * will print whatever message is indicated plus
+ * an information about the location.
+ *
+ */
+#ifdef CONFIG_EDEBUG
+#   define LOG(format, ...) \
+        printf("%s() at %s:%u: " format "\n", __func__, __FILE__, \
+            __LINE__, ##__VA_ARGS__);
+#else
+#   define LOG(format, ...)
 #endif
+/** Extensive debugging execute macro
+ *
+ * If CONFIG_EDEBUG is set, the LOG_EXEC() macro
+ * will print an information about calling a given
+ * function and call it.
+ *
+ */
+#ifdef CONFIG_EDEBUG
+#   define LOG_EXEC(fnc) \
+        { \
+            printf("%s() at %s:%u: " #fnc "\n", __func__, __FILE__, \
+            __LINE__); \
+            fnc; \
+        }
+#else
+#   define LOG_EXEC(fnc) fnc
+#endif
+#endif
 /** @}
  */

 /branches/network/kernel/generic/include/panic.h
 ,15 → 36,15
 #define KERN_PANIC_H_
 #ifdef CONFIG_DEBUG
-#define panic(format, ...) \
-    panic_printf("Kernel panic in %s() at %s on line %d: " format, __func__, \
-    __FILE__, __LINE__, ##__VA_ARGS__);
+#   define panic(format, ...) \
+        panic_printf("Kernel panic in %s() at %s:%u: " format, __func__, \
+        __FILE__, __LINE__, ##__VA_ARGS__);
 #else
-#define panic(format, ...) \
-    panic_printf("Kernel panic: " format, ##__VA_ARGS__);
+#   define panic(format, ...) \
+        panic_printf("Kernel panic: " format, ##__VA_ARGS__);
 #endif
-extern void panic_printf(char *fmt, ...) __attribute__((noreturn)) ;
+extern void panic_printf(char *fmt, ...) __attribute__((noreturn));
 #endif

 /branches/network/kernel/generic/include/byteorder.h
 ,26 → 35,60
 #ifndef KERN_BYTEORDER_H_
 #define KERN_BYTEORDER_H_
+#include <arch/byteorder.h>
+#if !(defined(ARCH_IS_BIG_ENDIAN) ^ defined(ARCH_IS_LITTLE_ENDIAN))
+#error The architecture must be either big-endian or little-endian.
+#endif
+#ifdef ARCH_IS_BIG_ENDIAN
+#define uint16_t_le2host(n)     uint16_t_byteorder_swap(n)
+#define uint32_t_le2host(n)     uint32_t_byteorder_swap(n)
+#define uint64_t_le2host(n)     uint64_t_byteorder_swap(n)
+#define uint16_t_be2host(n)     (n)
+#define uint32_t_be2host(n)     (n)
+#define uint64_t_be2host(n)     (n)
+#else
+#define uint16_t_le2host(n)     (n)
+#define uint32_t_le2host(n)     (n)
+#define uint64_t_le2host(n)     (n)
+#define uint16_t_be2host(n)     uint16_t_byteorder_swap(n)
+#define uint32_t_be2host(n)     uint32_t_byteorder_swap(n)
+#define uint64_t_be2host(n)     uint64_t_byteorder_swap(n)
+#endif
 static inline uint64_t uint64_t_byteorder_swap(uint64_t n)
 {
     return ((n & 0xff) << 56) |
-        ((n & 0xff00) << 40) |
-        ((n & 0xff0000) << 24) |
-        ((n & 0xff000000LL) << 8) |
-        ((n & 0xff00000000LL) >> 8) |
-        ((n & 0xff0000000000LL) >> 24) |
-        ((n & 0xff000000000000LL) >> 40) |
-        ((n & 0xff00000000000000LL) >> 56);
+        ((n & 0xff00) << 40) |
+        ((n & 0xff0000) << 24) |
+        ((n & 0xff000000LL) << 8) |
+        ((n & 0xff00000000LL) >> 8) |
+        ((n & 0xff0000000000LL) >> 24) |
+        ((n & 0xff000000000000LL) >> 40) |
+        ((n & 0xff00000000000000LL) >> 56);
 }
 static inline uint32_t uint32_t_byteorder_swap(uint32_t n)
 {
     return ((n & 0xff) << 24) |
-        ((n & 0xff00) << 8) |
-        ((n & 0xff0000) >> 8) |
-        ((n & 0xff000000) >> 24);
+        ((n & 0xff00) << 8) |
+        ((n & 0xff0000) >> 8) |
+        ((n & 0xff000000) >> 24);
 }
+static inline uint16_t uint16_t_byteorder_swap(uint16_t n)
+{
+    return ((n & 0xff) << 8) |
+        ((n & 0xff00) >> 8);
+}
 #endif
 /** @}

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3370 → Rev 3386