Changeset 3a0a4d8 in mainline for kernel/generic/include


Ignore:
Timestamp:
2013-09-12T07:54:05Z (12 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
95027b5
Parents:
47f5a77 (diff), 64f3d3b (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 deleted
7 edited

Legend:

Unmodified
Added
Removed

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

    r47f5a77 r3a0a4d8  
    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       
     47        size_t block_size;
     48        uint8_t *blocks;
    4549} bitmap_t;
    4650
    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);
     51static inline void bitmap_set(bitmap_t *bitmap, size_t element,
     52    unsigned int value)
     53{
     54        if (element < bitmap->elements) {
     55                /*
     56                 * The 2nd level bitmap is conservative.
     57                 * Make sure we update it properly.
     58                 */
     59               
     60                if (value) {
     61                        bitmap->bits[element / BITMAP_ELEMENT] |=
     62                            (1 << (element & BITMAP_REMAINER));
     63                } else {
     64                        bitmap->bits[element / BITMAP_ELEMENT] &=
     65                            ~(1 << (element & BITMAP_REMAINER));
     66                       
     67                        if (bitmap->block_size > 0) {
     68                                size_t block = element / bitmap->block_size;
     69                               
     70                                bitmap->blocks[block / BITMAP_ELEMENT] &=
     71                                    ~(1 << (block & BITMAP_REMAINER));
     72                        }
     73                }
     74        }
     75}
    5176
    52 static inline int bitmap_get(bitmap_t *bitmap, size_t bit)
     77static inline unsigned int bitmap_get(bitmap_t *bitmap, size_t element)
    5378{
    54         if(bit >= bitmap->bits)
     79        if (element >= bitmap->elements)
    5580                return 0;
    5681       
    57         return !! ((bitmap->map)[bit/8] & (1 << (bit & 7)));
     82        return !!((bitmap->bits)[element / BITMAP_ELEMENT] &
     83            (1 << (element & BITMAP_REMAINER)));
    5884}
    5985
     86extern size_t bitmap_size(size_t, size_t);
     87extern void bitmap_initialize(bitmap_t *, size_t, size_t, void *);
     88
     89extern void bitmap_set_range(bitmap_t *, size_t, size_t);
     90extern void bitmap_clear_range(bitmap_t *, size_t, size_t);
     91
     92extern int bitmap_allocate_range(bitmap_t *, size_t, size_t, size_t, size_t *);
     93extern void bitmap_copy(bitmap_t *, bitmap_t *, size_t);
    6094
    6195#endif

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

    r47f5a77 r3a0a4d8  
    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 *
    … …  
    6565
    6666#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)
     67        ((type *) (((void *)(link)) - list_link_to_void(&(((type *) NULL)->member))))
     68
     69#define list_foreach(list, member, itype, iterator) \
     70        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
     71            for (link_t *_link = (list).head.next; \
     72            iterator = list_get_instance(_link, itype, member), \
     73            _link != &(list).head; _link = _link->next)
    7274
    7375#define assert_link_not_used(link) \
    … …  
    204206}
    205207
     208/** Get next item in list.
     209 *
     210 * @param link Current item link
     211 * @param list List containing @a link
     212 *
     213 * @return Next item or NULL if @a link is the last item.
     214 */
     215static inline link_t *list_next(link_t *link, const list_t *list)
     216{
     217        return (link->next == &list->head) ? NULL : link->next;
     218}
     219
     220/** Get previous item in list.
     221 *
     222 * @param link Current item link
     223 * @param list List containing @a link
     224 *
     225 * @return Previous item or NULL if @a link is the first item.
     226 */
     227static inline link_t *list_prev(link_t *link, const list_t *list)
     228{
     229        return (link->prev == &list->head) ? NULL : link->prev;
     230}
     231
    206232/** Split or concatenate headless doubly-linked circular list
    207233 *
    … …  
    270296{
    271297        unsigned int cnt = 0;
    272        
    273         list_foreach(*list, link) {
     298        link_t *link;
     299       
     300        link = list_first(list);
     301        while (link != NULL) {
    274302                if (cnt == n)
    275303                        return link;
    276304               
    277305                cnt++;
     306                link = list_next(link, list);
    278307        }
    279308       
    280309        return NULL;
     310}
     311
     312/** Verify that argument type is a pointer to link_t (at compile time).
     313 *
     314 * This can be used to check argument type in a macro.
     315 */
     316static inline const void *list_link_to_void(const link_t *link)
     317{
     318        return link;
    281319}
    282320

  • kernel/generic/include/config.h

    r47f5a77 r3a0a4d8  
    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
    … …  
    9794        /** Size of initial stack. */
    9895        size_t stack_size;
    99 
     96       
    10097        bool identity_configured;
    10198        /** Base address of the kernel identity mapped memory. */
    … …  
    103100        /** Size of the kernel identity mapped memory. */
    104101        size_t identity_size;
    105 
    106         bool non_identity_configured;   
    107 
     102       
     103        bool non_identity_configured;
     104       
    108105        /** End of physical memory. */
    109106        uint64_t physmem_end;

  • kernel/generic/include/macros.h

    r47f5a77 r3a0a4d8  
    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/frame.h

    r47f5a77 r3a0a4d8  
    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, size_t *);
     134extern uintptr_t frame_alloc(size_t, frame_flags_t, uintptr_t);
     135extern uintptr_t frame_alloc_noreserve(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

    r47f5a77 r3a0a4d8  
    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

    r47f5a77 r3a0a4d8  
    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       
Note: See TracChangeset for help on using the changeset viewer.