Changeset 8b863a62 in mainline for kernel/generic/include


Ignore:
Timestamp:
2014-04-16T17:14:06Z (12 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f857e8b
Parents:
dba3e2c (diff), 70b570c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

Location:
kernel/generic/include
Files:
1 added
1 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/adt/bitmap.h

    rdba3e2c r8b863a62  
    3838#include <typedefs.h>
    3939
    40 #define BITS2BYTES(bits)        (bits ? ((((bits)-1)>>3)+1) : 0)
     40#define BITMAP_ELEMENT   8
     41#define BITMAP_REMAINER  7
    4142
    4243typedef struct {
    43         uint8_t *map;
    44         size_t bits;
     44        size_t elements;
     45        uint8_t *bits;
     46        size_t next_fit;
    4547} bitmap_t;
    4648
    47 extern void bitmap_initialize(bitmap_t *bitmap, uint8_t *map, size_t bits);
    48 extern void bitmap_set_range(bitmap_t *bitmap, size_t start, size_t bits);
    49 extern void bitmap_clear_range(bitmap_t *bitmap, size_t start, size_t bits);
    50 extern void bitmap_copy(bitmap_t *dst, bitmap_t *src, size_t bits);
     49static inline void bitmap_set(bitmap_t *bitmap, size_t element,
     50    unsigned int value)
     51{
     52        if (element >= bitmap->elements)
     53                return;
     54       
     55        size_t byte = element / BITMAP_ELEMENT;
     56        uint8_t mask = 1 << (element & BITMAP_REMAINER);
     57       
     58        if (value) {
     59                bitmap->bits[byte] |= mask;
     60        } else {
     61                bitmap->bits[byte] &= ~mask;
     62                bitmap->next_fit = byte;
     63        }
     64}
    5165
    52 static inline int bitmap_get(bitmap_t *bitmap, size_t bit)
     66static inline unsigned int bitmap_get(bitmap_t *bitmap, size_t element)
    5367{
    54         if(bit >= bitmap->bits)
     68        if (element >= bitmap->elements)
    5569                return 0;
    5670       
    57         return !! ((bitmap->map)[bit/8] & (1 << (bit & 7)));
     71        size_t byte = element / BITMAP_ELEMENT;
     72        uint8_t mask = 1 << (element & BITMAP_REMAINER);
     73       
     74        return !!((bitmap->bits)[byte] & mask);
    5875}
    5976
     77extern size_t bitmap_size(size_t);
     78extern void bitmap_initialize(bitmap_t *, size_t, void *);
     79
     80extern void bitmap_set_range(bitmap_t *, size_t, size_t);
     81extern void bitmap_clear_range(bitmap_t *, size_t, size_t);
     82
     83extern int bitmap_allocate_range(bitmap_t *, size_t, size_t, size_t, size_t,
     84    size_t *);
     85extern void bitmap_copy(bitmap_t *, bitmap_t *, size_t);
    6086
    6187#endif

  • kernel/generic/include/adt/list.h

    rdba3e2c r8b863a62  
    11/*
    22 * Copyright (c) 2001-2004 Jakub Jermar
    3  * Copyright (c) 2011 Jiri Svoboda
     3 * Copyright (c) 2013 Jiri Svoboda
    44 * All rights reserved.
    55 *
    … …  
    3737#define KERN_LIST_H_
    3838
     39#include <debug.h>
    3940#include <typedefs.h>
    4041#include <trace.h>
    … …  
    6566
    6667#define list_get_instance(link, type, member) \
    67         ((type *) (((void *)(link)) - ((void *) &(((type *) NULL)->member))))
    68 
    69 #define list_foreach(list, iterator) \
    70         for (link_t *iterator = (list).head.next; \
    71             iterator != &(list).head; iterator = iterator->next)
     68        ((type *) (((void *)(link)) - list_link_to_void(&(((type *) NULL)->member))))
     69
     70#define list_foreach(list, member, itype, iterator) \
     71        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
     72            for (link_t *_link = (list).head.next; \
     73            iterator = list_get_instance(_link, itype, member), \
     74            _link != &(list).head; _link = _link->next)
     75
     76#define list_foreach_rev(list, member, itype, iterator) \
     77        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
     78            for (link_t *_link = (list).head.prev; \
     79            iterator = list_get_instance(_link, itype, member), \
     80            _link != &(list).head; _link = _link->prev)
    7281
    7382#define assert_link_not_used(link) \
    74         ASSERT(((link)->prev == NULL) && ((link)->next == NULL))
     83        ASSERT(!link_used(link))
    7584
    7685/** Initialize doubly-linked circular list link
    … …  
    204213}
    205214
     215/** Get next item in list.
     216 *
     217 * @param link Current item link
     218 * @param list List containing @a link
     219 *
     220 * @return Next item or NULL if @a link is the last item.
     221 */
     222static inline link_t *list_next(link_t *link, const list_t *list)
     223{
     224        return (link->next == &list->head) ? NULL : link->next;
     225}
     226
     227/** Get previous item in list.
     228 *
     229 * @param link Current item link
     230 * @param list List containing @a link
     231 *
     232 * @return Previous item or NULL if @a link is the first item.
     233 */
     234static inline link_t *list_prev(link_t *link, const list_t *list)
     235{
     236        return (link->prev == &list->head) ? NULL : link->prev;
     237}
     238
    206239/** Split or concatenate headless doubly-linked circular list
    207240 *
    … …  
    270303{
    271304        unsigned int cnt = 0;
    272        
    273         list_foreach(*list, link) {
     305        link_t *link;
     306       
     307        link = list_first(list);
     308        while (link != NULL) {
    274309                if (cnt == n)
    275310                        return link;
    276311               
    277312                cnt++;
     313                link = list_next(link, list);
    278314        }
    279315       
    280316        return NULL;
     317}
     318
     319/** Verify that argument type is a pointer to link_t (at compile time).
     320 *
     321 * This can be used to check argument type in a macro.
     322 */
     323static inline const void *list_link_to_void(const link_t *link)
     324{
     325        return link;
     326}
     327
     328/** Determine if link is used.
     329 *
     330 * @param link Link
     331 * @return @c true if link is used, @c false if not.
     332 */
     333static inline bool link_used(link_t *link)
     334{
     335        if (link->prev == NULL && link->next == NULL)
     336                return false;
     337
     338        ASSERT(link->prev != NULL && link->next != NULL);
     339        return true;
    281340}
    282341

  • kernel/generic/include/config.h

    rdba3e2c r8b863a62  
    3737
    3838#include <arch/mm/page.h>
     39#include <macros.h>
    3940
    40 #define ONE_FRAME    0
    41 #define TWO_FRAMES   1
    42 #define FOUR_FRAMES  2
     41#define STACK_FRAMES  2
     42#define STACK_SIZE    FRAMES2SIZE(STACK_FRAMES)
    4343
    44 #define STACK_FRAMES  TWO_FRAMES
    45 #define STACK_SIZE    ((1 << STACK_FRAMES) << PAGE_WIDTH)
    46 
    47 #define STACK_SIZE_USER (1 * 1024 * 1024)
     44#define STACK_SIZE_USER  (1 * 1024 * 1024)
    4845
    4946#define CONFIG_INIT_TASKS        32
    5047#define CONFIG_TASK_NAME_BUFLEN  32
    5148#define CONFIG_TASK_ARGUMENTS_BUFLEN 64
    52 
    53 /**
    54  * Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ
    55  * requests.
    56  */
    57 #define DATA_XFER_LIMIT  (64 * 1024)
    5849
    5950#ifndef __ASM__
    … …  
    9788        /** Size of initial stack. */
    9889        size_t stack_size;
    99 
     90       
    10091        bool identity_configured;
    10192        /** Base address of the kernel identity mapped memory. */
    … …  
    10394        /** Size of the kernel identity mapped memory. */
    10495        size_t identity_size;
    105 
    106         bool non_identity_configured;   
    107 
     96       
     97        bool non_identity_configured;
     98       
    10899        /** End of physical memory. */
    109100        uint64_t physmem_end;

  • kernel/generic/include/console/chardev.h

    rdba3e2c r8b863a62  
    4343#define INDEV_BUFLEN  512
    4444
     45/** Input character device out-of-band signal type. */
     46typedef enum {
     47        INDEV_SIGNAL_SCROLL_UP = 0,
     48        INDEV_SIGNAL_SCROLL_DOWN
     49} indev_signal_t;
     50
    4551struct indev;
    4652
    47 /* Input character device operations interface. */
     53/** Input character device operations interface. */
    4854typedef struct {
    4955        /** Read character directly from device, assume interrupts disabled. */
    5056        wchar_t (* poll)(struct indev *);
     57       
     58        /** Signal out-of-band condition. */
     59        void (* signal)(struct indev *, indev_signal_t);
    5160} indev_operations_t;
    5261
    … …  
    6776} indev_t;
    6877
    69 
    7078struct outdev;
    7179
    72 /* Output character device operations interface. */
     80/** Output character device operations interface. */
    7381typedef struct {
    7482        /** Write character to output. */
    … …  
    7785        /** Redraw any previously cached characters. */
    7886        void (* redraw)(struct outdev *);
     87       
     88        /** Scroll up in the device cache. */
     89        void (* scroll_up)(struct outdev *);
     90       
     91        /** Scroll down in the device cache. */
     92        void (* scroll_down)(struct outdev *);
    7993} outdev_operations_t;
    8094
    … …  
    99113extern void indev_push_character(indev_t *, wchar_t);
    100114extern wchar_t indev_pop_character(indev_t *);
     115extern void indev_signal(indev_t *, indev_signal_t);
    101116
    102117extern void outdev_initialize(const char *, outdev_t *,

  • kernel/generic/include/console/console.h

    rdba3e2c r8b863a62  
    3939#include <print.h>
    4040#include <console/chardev.h>
     41#include <synch/spinlock.h>
    4142
    4243#define PAGING(counter, increment, before, after) \
    … …  
    6263extern void console_init(void);
    6364
    64 extern void klog_init(void);
    65 extern void klog_update(void *);
     65extern void kio_init(void);
     66extern void kio_update(void *);
     67extern void kio_flush(void);
     68extern void kio_push_char(const wchar_t);
     69SPINLOCK_EXTERN(kio_lock);
    6670
    6771extern wchar_t getc(indev_t *indev);
    6872extern size_t gets(indev_t *indev, char *buf, size_t buflen);
    69 extern sysarg_t sys_klog(int cmd, const void *buf, size_t size);
     73extern sysarg_t sys_kio(int cmd, const void *buf, size_t size);
    7074
    7175extern void grab_console(void);

  • kernel/generic/include/debug.h

    rdba3e2c r8b863a62  
    107107#define LOG(format, ...) \
    108108        do { \
    109                 printf("%s() from %s at %s:%u: " format "\n", __func__, \
     109                log(LF_OTHER, LVL_DEBUG, \
     110                    "%s() from %s at %s:%u: " format,__func__, \
    110111                    symtab_fmt_name_lookup(CALLER), __FILE__, __LINE__, \
    111112                    ##__VA_ARGS__); \

  • kernel/generic/include/macros.h

    rdba3e2c r8b863a62  
    117117        overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
    118118
     119#define PFN2ADDR(frame)  ((frame) << FRAME_WIDTH)
     120#define ADDR2PFN(addr)   ((addr) >> FRAME_WIDTH)
     121
     122#define FRAMES2SIZE(frames)  ((frames) << FRAME_WIDTH)
     123#define SIZE2FRAMES(size) \
     124        (((size) == 0) ? 0 : ((((size) - 1) >> FRAME_WIDTH) + 1))
     125
    119126#define KiB2SIZE(kb)  ((kb) << 10)
    120127#define MiB2SIZE(mb)  ((mb) << 20)

  • kernel/generic/include/mm/as.h

    rdba3e2c r8b863a62  
    140140        /** This structure can be deallocated if refcount drops to 0. */
    141141        size_t refcount;
    142        
     142        /** True if the area has been ever shared. */
     143        bool shared;
     144
    143145        /**
    144146         * B+tree containing complete map of anonymous pages of the shared area.
    145147         */
    146148        btree_t pagemap;
     149
     150        /** Address space area backend. */
     151        struct mem_backend *backend;
     152        /** Address space area shared data. */
     153        void *backend_shared_data;
    147154} share_info_t;
    148155
    … …  
    169176                uintptr_t base;
    170177                size_t frames;
     178                bool anonymous;
    171179        };
    172180} mem_backend_data_t;
    … …  
    226234        int (* page_fault)(as_area_t *, uintptr_t, pf_access_t);
    227235        void (* frame_free)(as_area_t *, uintptr_t, uintptr_t);
     236
     237        bool (* create_shared_data)(as_area_t *);
     238        void (* destroy_shared_data)(void *);
    228239} mem_backend_t;
    229240

  • kernel/generic/include/mm/frame.h

    rdba3e2c r8b863a62  
    3939#include <typedefs.h>
    4040#include <trace.h>
     41#include <adt/bitmap.h>
    4142#include <adt/list.h>
    42 #include <mm/buddy.h>
    4343#include <synch/spinlock.h>
    4444#include <arch/mm/page.h>
    … …  
    5050typedef uint8_t frame_flags_t;
    5151
    52 #define FRAME_NONE        0x0
    53 /** Convert the frame address to kernel VA. */
    54 #define FRAME_KA          0x1
     52#define FRAME_NONE        0x00
    5553/** Do not panic and do not sleep on failure. */
    56 #define FRAME_ATOMIC      0x2
     54#define FRAME_ATOMIC      0x01
    5755/** Do not start reclaiming when no free memory. */
    58 #define FRAME_NO_RECLAIM  0x4
     56#define FRAME_NO_RECLAIM  0x02
    5957/** Do not reserve / unreserve memory. */
    60 #define FRAME_NO_RESERVE  0x8
     58#define FRAME_NO_RESERVE  0x04
    6159/** Allocate a frame which can be identity-mapped. */
    62 #define FRAME_LOWMEM      0x10
     60#define FRAME_LOWMEM      0x08
    6361/** Allocate a frame which cannot be identity-mapped. */
    64 #define FRAME_HIGHMEM     0x20
     62#define FRAME_HIGHMEM     0x10
    6563
    6664typedef uint8_t zone_flags_t;
    6765
    68 #define ZONE_NONE       0x0
     66#define ZONE_NONE       0x00
    6967/** Available zone (free for allocation) */
    70 #define ZONE_AVAILABLE  0x1
     68#define ZONE_AVAILABLE  0x01
    7169/** Zone is reserved (not available for allocation) */
    72 #define ZONE_RESERVED   0x2
     70#define ZONE_RESERVED   0x02
    7371/** Zone is used by firmware (not available for allocation) */
    74 #define ZONE_FIRMWARE   0x4
     72#define ZONE_FIRMWARE   0x04
    7573/** Zone contains memory that can be identity-mapped */
    76 #define ZONE_LOWMEM     0x8
     74#define ZONE_LOWMEM     0x08
    7775/** Zone contains memory that cannot be identity-mapped */
    78 #define ZONE_HIGHMEM    0x10
     76#define ZONE_HIGHMEM    0x10
    7977
    8078/** Mask of zone bits that must be matched exactly. */
    81 #define ZONE_EF_MASK    0x7
     79#define ZONE_EF_MASK  0x07
    8280
    83 #define FRAME_TO_ZONE_FLAGS(ff) \
     81#define FRAME_TO_ZONE_FLAGS(ff) \
    8482        ((((ff) & FRAME_LOWMEM) ? ZONE_LOWMEM : \
    8583            (((ff) & FRAME_HIGHMEM) ? ZONE_HIGHMEM : \
    8684            ZONE_LOWMEM /* | ZONE_HIGHMEM */)) | \
    87             ZONE_AVAILABLE) 
     85            ZONE_AVAILABLE)
    8886
    8987#define ZONE_FLAGS_MATCH(zf, f) \
    … …  
    9290
    9391typedef struct {
    94         size_t refcount;      /**< Tracking of shared frames */
    95         link_t buddy_link;    /**< Link to the next free block inside
    96                                    one order */
    97         void *parent;         /**< If allocated by slab, this points there */
    98         uint8_t buddy_order;  /**< Buddy system block order */
     92        size_t refcount;  /**< Tracking of shared frames */
     93        void *parent;     /**< If allocated by slab, this points there */
    9994} frame_t;
    10095
    10196typedef struct {
    102         pfn_t base;                    /**< Frame_no of the first frame
    103                                             in the frames array */
    104         size_t count;                  /**< Size of zone */
    105         size_t free_count;             /**< Number of free frame_t
    106                                             structures */
    107         size_t busy_count;             /**< Number of busy frame_t
    108                                             structures */
    109         zone_flags_t flags;            /**< Type of the zone */
     97        /** Frame_no of the first frame in the frames array */
     98        pfn_t base;
    11099       
    111         frame_t *frames;               /**< Array of frame_t structures
    112                                             in this zone */
    113         buddy_system_t *buddy_system;  /**< Buddy system for the zone */
     100        /** Size of zone */
     101        size_t count;
     102       
     103        /** Number of free frame_t structures */
     104        size_t free_count;
     105       
     106        /** Number of busy frame_t structures */
     107        size_t busy_count;
     108       
     109        /** Type of the zone */
     110        zone_flags_t flags;
     111       
     112        /** Frame bitmap */
     113        bitmap_t bitmap;
     114       
     115        /** Array of frame_t structures in this zone */
     116        frame_t *frames;
    114117} zone_t;
    115118
    … …  
    126129extern zones_t zones;
    127130
    128 NO_TRACE static inline uintptr_t PFN2ADDR(pfn_t frame)
    129 {
    130         return (uintptr_t) (frame << FRAME_WIDTH);
    131 }
    132 
    133 NO_TRACE static inline pfn_t ADDR2PFN(uintptr_t addr)
    134 {
    135         return (pfn_t) (addr >> FRAME_WIDTH);
    136 }
    137 
    138 NO_TRACE static inline size_t SIZE2FRAMES(size_t size)
    139 {
    140         if (!size)
    141                 return 0;
    142         return (size_t) ((size - 1) >> FRAME_WIDTH) + 1;
    143 }
    144 
    145 NO_TRACE static inline size_t FRAMES2SIZE(size_t frames)
    146 {
    147         return (size_t) (frames << FRAME_WIDTH);
    148 }
    149 
    150 #define IS_BUDDY_ORDER_OK(index, order) \
    151     ((~(((sysarg_t) -1) << (order)) & (index)) == 0)
    152 #define IS_BUDDY_LEFT_BLOCK(zone, frame) \
    153     (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
    154 #define IS_BUDDY_RIGHT_BLOCK(zone, frame) \
    155     (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
    156 #define IS_BUDDY_LEFT_BLOCK_ABS(zone, frame) \
    157     (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
    158 #define IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame) \
    159     (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
    160 
    161131extern void frame_init(void);
    162132extern bool frame_adjust_zone_bounds(bool, uintptr_t *, size_t *);
    163 extern void *frame_alloc_generic(uint8_t, frame_flags_t, size_t *);
    164 extern void *frame_alloc(uint8_t, frame_flags_t);
    165 extern void *frame_alloc_noreserve(uint8_t, frame_flags_t);
    166 extern void frame_free_generic(uintptr_t, frame_flags_t);
    167 extern void frame_free(uintptr_t);
    168 extern void frame_free_noreserve(uintptr_t);
     133extern uintptr_t frame_alloc_generic(size_t, frame_flags_t, uintptr_t,
     134    size_t *);
     135extern uintptr_t frame_alloc(size_t, frame_flags_t, uintptr_t);
     136extern void frame_free_generic(uintptr_t, size_t, frame_flags_t);
     137extern void frame_free(uintptr_t, size_t);
     138extern void frame_free_noreserve(uintptr_t, size_t);
    169139extern void frame_reference_add(pfn_t);
    170140extern size_t frame_total_free_get(void);

  • kernel/generic/include/mm/page.h

    rdba3e2c r8b863a62  
    6565extern void page_table_destroy(pte_t *);
    6666
    67 extern int page_find_mapping(uintptr_t, void **);
    68 extern sysarg_t sys_page_find_mapping(uintptr_t, void *);
     67extern int page_find_mapping(uintptr_t, uintptr_t *);
     68extern sysarg_t sys_page_find_mapping(uintptr_t, uintptr_t *);
    6969
    7070#endif

  • kernel/generic/include/mm/slab.h

    rdba3e2c r8b863a62  
    5555/** Maximum wasted space we allow for cache */
    5656#define SLAB_MAX_BADNESS(cache) \
    57         (((unsigned int) PAGE_SIZE << (cache)->order) >> 2)
     57        (FRAMES2SIZE((cache)->frames) >> 2)
    5858
    5959/* slab_reclaim constants */
    … …  
    9090       
    9191        /* Configuration */
     92       
    9293        /** Size of slab position - align_up(sizeof(obj)) */
    9394        size_t size;
    … …  
    100101       
    101102        /* Computed values */
    102         uint8_t order;   /**< Order of frames to be allocated */
     103        size_t frames;   /**< Number of frames to be allocated */
    103104        size_t objects;  /**< Number of objects that fit in */
    104105       

  • kernel/generic/include/synch/spinlock.h

    rdba3e2c r8b863a62  
    137137#ifdef CONFIG_DEBUG_SPINLOCK
    138138
    139 #include <print.h>
     139#include <log.h>
    140140
    141141#define DEADLOCK_THRESHOLD  100000000
    … …  
    146146        if ((pname)++ > (value)) { \
    147147                (pname) = 0; \
    148                 printf("Deadlock probe %s: exceeded threshold %u\n" \
     148                log(LF_OTHER, LVL_WARN, \
     149                    "Deadlock probe %s: exceeded threshold %u\n" \
    149150                    "cpu%u: function=%s, line=%u\n", \
    150151                    #pname, (value), CPU->id, __func__, __LINE__); \
Note: See TracChangeset for help on using the changeset viewer.