kitten/include/lwk/aspace.h

   1 /* Copyright (c) 2007,2008 Sandia National Laboratories */
   2
   3 #ifndef _LWK_ASPACE_H
   4 #define _LWK_ASPACE_H
   5
   6 #include <lwk/types.h>
   7 #include <lwk/idspace.h>
   8 #include <arch/aspace.h>
   9
  10 /**
  11  * Valid user-space created address space IDs are in interval
  12  * [ASPACE_MIN_ID, ASPACE_MAX_ID].
  13  */
  14 #define ASPACE_MIN_ID     0
  15 #define ASPACE_MAX_ID     4094
  16
  17 /**
  18  * The address space ID to use for the init_task.
  19  * Put it at the top of the space to keep it out of the way.
  20  */
  21 #define INIT_ASPACE_ID    ASPACE_MAX_ID
  22
  23 /**
  24  * Protection and memory type flags.
  25  */
  26 #define VM_READ           (1 << 0)
  27 #define VM_WRITE          (1 << 1)
  28 #define VM_EXEC           (1 << 2)
  29 #define VM_NOCACHE        (1 << 3)
  30 #define VM_WRITETHRU      (1 << 4)
  31 #define VM_GLOBAL         (1 << 5)
  32 #define VM_USER           (1 << 6)
  33 #define VM_KERNEL         (1 << 7)
  34 #define VM_HEAP           (1 << 8)
  35 #define VM_SMARTMAP       (1 << 9)
  36 typedef unsigned long vmflags_t;
  37
  38 /**
  39  * Page sizes.
  40  */
  41 #define VM_PAGE_4KB       (1 << 12)
  42 #define VM_PAGE_2MB       (1 << 21)
  43 #define VM_PAGE_1GB       (1 << 30)
  44 typedef unsigned long vmpagesize_t;
  45
  46 /**
  47  * Core address space management API.
  48  * These are accessible from both kernel-space and user-space (via syscalls).
  49  */
  50 extern int aspace_get_myid(id_t *id);
  51 extern int aspace_create(id_t id_request, const char *name, id_t *id);
  52 extern int aspace_destroy(id_t id);
  53
  54 extern int aspace_find_hole(id_t id,
  55                             vaddr_t start_hint, size_t extent, size_t alignment,
  56                             vaddr_t *start);
  57
  58 extern int aspace_add_region(id_t id,
  59                              vaddr_t start, size_t extent,
  60                              vmflags_t flags, vmpagesize_t pagesz,
  61                              const char *name);
  62 extern int aspace_del_region(id_t id, vaddr_t start, size_t extent);
  63
  64 extern int aspace_map_pmem(id_t id,
  65                            paddr_t pmem, vaddr_t start, size_t extent);
  66 extern int aspace_unmap_pmem(id_t id, vaddr_t start, size_t extent);
  67
  68 extern int aspace_smartmap(id_t src, id_t dst, vaddr_t start, size_t extent);
  69 extern int aspace_unsmartmap(id_t src, id_t dst);
  70
  71 extern int aspace_dump2console(id_t id);
  72
  73 /**
  74  * Convenience functions defined in liblwk.
  75  */
  76 extern int
  77 aspace_map_region(
  78         id_t         id,
  79         vaddr_t      start,
  80         size_t       extent,
  81         vmflags_t    flags,
  82         vmpagesize_t pagesz,
  83         const char * name,
  84         paddr_t      pmem
  85 );
  86
  87 extern int
  88 aspace_map_region_anywhere(
  89         id_t         id,
  90         vaddr_t *    start,
  91         size_t       extent,
  92         vmflags_t    flags,
  93         vmpagesize_t pagesz,
  94         const char * name,
  95         paddr_t      pmem
  96 );
  97
  98 #ifdef __KERNEL__
  99
 100 #include <lwk/spinlock.h>
 101 #include <lwk/list.h>
 102 #include <lwk/init.h>
 103 #include <arch/aspace.h>
 104
 105 /**
 106  * Address space structure.
 107  */
 108 struct aspace {
 109         spinlock_t         lock;        /* Must be held to access addr space */
 110
 111         id_t               id;          /* The address space's ID */
 112         char               name[16];    /* Address space's name */
 113         struct hlist_node  ht_link;     /* Adress space hash table linkage */
 114         int                refcnt;      /* # of users of this address space */
 115
 116         struct list_head   region_list; /* Sorted non-overlapping region list */
 117
 118         /**
 119          * The address space's "Heap" region spans from:
 120          *     [heap_start, heap_end)
 121          */
 122         vaddr_t            heap_start;
 123         vaddr_t            heap_end;
 124
 125         /**
 126          * The traditional UNIX data segment is contained in the address
 127          * space's heap region, ranging from:
 128          *     [heap_start, brk)
 129          *
 130          * GLIBC/malloc will call the sys_brk() system call when it wants to
 131          * expand or shrink the data segment. The kernel verifies that the new
 132          * brk value is legal before updating it. The data segment may not
 133          * extend beyond the address space's heap region or overlap with
 134          * any anonymous mmap regions (see mmap_brk below).
 135          */
 136         vaddr_t            brk;
 137
 138         /**
 139          * Memory for anonymous mmap() regions is allocated from the top of the
 140          * address space's heap region, ranging from:
 141          *     [mmap_brk, heap_end)
 142          *
 143          * GLIBC makes at least one mmap() call during pre-main app startup
 144          * to allocate some "anonymous" memory (i.e., normal memory, not a
 145          * file mapping). mmap_brk starts out set to heap_end and grows down
 146          * as anonymous mmap() calls are made. The kernel takes care to prevent
 147          * mmap_brk from extending into the UNIX data segment (see brk above).
 148          */
 149         vaddr_t            mmap_brk;
 150
 151         /**
 152          * Architecture specific address space data.
 153          */
 154         struct arch_aspace arch;
 155 };
 156
 157 /**
 158  * Valid address space IDs are in interval [__ASPACE_MIN_ID, __ASPACE_MAX_ID].
 159  */
 160 #define __ASPACE_MIN_ID   ASPACE_MIN_ID
 161 #define __ASPACE_MAX_ID   ASPACE_MAX_ID+1  /* +1 for KERNEL_ASPACE_ID */
 162
 163 /**
 164  * ID of the address space used by kernel threads.
 165  */
 166 #define KERNEL_ASPACE_ID  ASPACE_MAX_ID+1
 167
 168 /**
 169  * Kernel-only unlocked versions of the core adress space management API.
 170  * These assume that the aspace objects passed in have already been locked.
 171  * The caller must unlock the aspaces. The caller must also ensure that
 172  * interrupts are disabled before calling these functions.
 173  */
 174 extern int __aspace_find_hole(struct aspace *aspace,
 175                               vaddr_t start_hint, size_t extent, size_t alignment,
 176                               vaddr_t *start);
 177 extern int __aspace_add_region(struct aspace *aspace,
 178                                vaddr_t start, size_t extent,
 179                                vmflags_t flags, vmpagesize_t pagesz,
 180                                const char *name);
 181 extern int __aspace_del_region(struct aspace *aspace,
 182                                vaddr_t start, size_t extent);
 183 extern int __aspace_map_pmem(struct aspace *aspace,
 184                              paddr_t pmem, vaddr_t start, size_t extent);
 185 extern int __aspace_unmap_pmem(struct aspace *aspace,
 186                                vaddr_t start, size_t extent);
 187 extern int __aspace_smartmap(struct aspace *src, struct aspace *dst,
 188                              vaddr_t start, size_t extent);
 189 extern int __aspace_unsmartmap(struct aspace *src, struct aspace *dst);
 190
 191 /**
 192  * Kernel-only address space management API.
 193  * These are not accessible from user-space.
 194  */
 195 extern int __init aspace_subsys_init(void);
 196 extern struct aspace *aspace_acquire(id_t id);
 197 extern void aspace_release(struct aspace *aspace);
 198
 199 /**
 200  * Architecture specific address space functions.
 201  * Each architecture port must provide these.
 202  */
 203 extern int arch_aspace_create(struct aspace *aspace);
 204 extern void arch_aspace_destroy(struct aspace *aspace);
 205 extern void arch_aspace_activate(struct aspace *aspace);
 206 extern int arch_aspace_map_page(struct aspace * aspace,
 207                                 vaddr_t start, paddr_t paddr,
 208                                 vmflags_t flags, vmpagesize_t pagesz);
 209 extern void arch_aspace_unmap_page(struct aspace * aspace,
 210                                    vaddr_t start, vmpagesize_t pagesz);
 211 extern int arch_aspace_smartmap(struct aspace *src, struct aspace *dst,
 212                                 vaddr_t start, size_t extent);
 213 extern int arch_aspace_unsmartmap(struct aspace *src, struct aspace *dst,
 214                                   vaddr_t start, size_t extent);
 215
 216 /**
 217  * System call handlers.
 218  */
 219 extern int sys_aspace_get_myid(id_t __user *id);
 220 extern int sys_aspace_create(id_t id_request, const char __user *name,
 221                              id_t __user *id);
 222 extern int sys_aspace_destroy(id_t id);
 223 extern int sys_aspace_find_hole(id_t id, vaddr_t start_hint, size_t extent,
 224                                 size_t alignment, vaddr_t __user *start);
 225 extern int sys_aspace_add_region(id_t id,
 226                                  vaddr_t start, size_t extent,
 227                                  vmflags_t flags, vmpagesize_t pagesz,
 228                                  const char __user *name);
 229 extern int sys_aspace_del_region(id_t id, vaddr_t start, size_t extent);
 230 extern int sys_aspace_map_pmem(id_t id,
 231                                paddr_t pmem, vaddr_t start, size_t extent);
 232 extern int sys_aspace_unmap_pmem(id_t id, vaddr_t start, size_t extent);
 233 extern int sys_aspace_smartmap(id_t src, id_t dst,
 234                                vaddr_t start, size_t extent);
 235 extern int sys_aspace_unsmartmap(id_t src, id_t dst);
 236 extern int sys_aspace_dump2console(id_t id);
 237
 238 #endif
 239 #endif