kernel/include/kern/mem.h

   1 #ifndef _KERN_MEM_H
   2 #define _KERN_MEM_H
   3
   4 #include <System/Mem.h>
   5
   6 #include <kern/kernel.h>
   7
   8 #include <arch/mem.h>
   9 #include <arch/addrs.h>
  10
  11 #include <util/rbtree.h>
  12 #include <util/list.h>
  13 #include <util/lock.h>
  14 #include <kernel/region.h>
  15 #include <lowlevel/bitops.h>
  16
  17 namespace Mem {
  18         // Used for allocating memory at boot time before the page allocator
  19         // is running.  Alignment must be a power of 2.  Because nothing other
  20         // than the kernel is guaranteed to be mapped from the beginning on
  21         // all architectures, no generic code should use this until after
  22         // Arch::arch_init() has run and set up physical memory mappings.
  23         //
  24         // This function may not be used after the page allocator has
  25         // been initialized by architecture code.
  26         //
  27         // Architectures must provide Arch::next_free_bootmem initalized
  28         // to the first free piece of bootmem.
  29
  30         static inline void *get_bootmem(size_t size, size_t align)
  31         {
  32                 uintptr_t ret = (Arch::next_free_bootmem + align - 1) & ~(align - 1);
  33                 Arch::next_free_bootmem = ret + size;
  34                 return reinterpret_cast<void *>(ret);
  35         }
  36
  37         typedef System::Mem::AddrSpace IAddrSpace;
  38         typedef System::Mem::Mappable IMappable;
  39         using System::Mem::Cacheable;
  40         using System::Mem::Region;
  41         using System::Mem::RegionWithOffset;
  42         using System::Mem::AllocFlags;
  43         using System::Mem::MapFlags;
  44         using System::Mem::AccessFlags;
  45
  46         union PTEFlags {
  47                 enum {
  48                         valid = 0x001,
  49                         writeable = 0x002,
  50                         readable = 0x004,
  51                         executable = 0x008,
  52                         user = 0x010,
  53                         accessed = 0x020,
  54                         dirty = 0x040,
  55                         uncached = 0x080,
  56                         faultonwrite = 0x100,
  57                         addressonly = 0x200,
  58                         protectedmap = 0x400,
  59                 };
  60
  61                 struct {
  62                         // This must be kept in sync with include/kern/generic-pte.h
  63
  64 #ifdef BITFIELD_LE
  65                         // Readable, Writeable, and Executable are for permission only,
  66                         // not for implementing copy on write, swapping, etc.
  67
  68                         ulong Valid:1;
  69                         ulong Writeable:1;
  70                         ulong Readable:1;
  71                         ulong Executable:1;
  72                         ulong User:1;
  73                         ulong Accessed:1;
  74                         ulong Dirty:1;
  75                         ulong Uncached:1;
  76
  77                         // If set, then on a write access, the page is copied and this
  78                         // address space gets the new, anonymous version.  The rmap list
  79                         // is then traversed; all downstream mappings will share the new
  80                         // copy.
  81                         //
  82                         // For vareas that directly map something other than an address
  83                         // space, the action to be taken on a write fault is
  84                         // mapping-specific.
  85
  86                         ulong FaultOnWrite:1;
  87
  88                         // The address itself is being mapped, not the page located
  89                         // there.  Do not manipulate page reference counts.  This bit
  90                         // does not get propagated during copy-on-write.
  91
  92                         ulong AddressOnly:1;
  93
  94                         // VArea Only:
  95                         // Do not allow the user to unmap or modify flags.
  96                         // Used for the shared user/kernel mappings.
  97
  98                         ulong Protected:1;
  99
 100 #elif defined(BITFIELD_BE)
 101                         ulong pad:_LL_LONG_BYTES * 8 - 11;
 102                         ulong Protected:1;
 103                         ulong AddressOnly:1;
 104                         ulong FaultOnWrite:1;
 105                         ulong Uncached:1;
 106                         ulong Dirty:1;
 107                         ulong Accessed:1;
 108                         ulong User:1;
 109                         ulong Executable:1;
 110                         ulong Readable:1;
 111                         ulong Writeable:1;
 112                         ulong Valid:1;
 113 #else
 114 #error Unspecified/unrecognized bitfield endianness
 115 #endif
 116                 };
 117
 118                 ulong raw;
 119
 120                 PTEFlags(ulong init) : raw(init)
 121                 {
 122                 }
 123
 124                 PTEFlags() : raw(0)
 125                 {
 126                 }
 127
 128                 operator ulong()
 129                 {
 130                         return raw;
 131                 }
 132         };
 133
 134         using Arch::kvirt_to_phys;
 135         using Arch::phys_to_kvirt;
 136         class PageTable;
 137         class AddrSpace;
 138
 139         struct VirtualArea;
 140         typedef Util::RBTree<VirtualArea, Region, u64> VirtualAreaTree;
 141
 142         class Mappable {
 143         protected:
 144                 // This linked list keeps track of the virtual areas that map this
 145                 // mappable (this is not transitive; vareas that map a varea that
 146                 // maps this mappable are not on this list).
 147                 //
 148                 // OPT: rbtree keyed on mapped address range?
 149
 150                 Util::List mappings;
 151                 Lock::SpinLock mappings_lock;
 152
 153         public:
 154                 bool is_aspace;
 155
 156                 virtual void get_size(u64 *size) = 0;
 157
 158                 virtual void get_block_size(u64 *block_size)
 159                 {
 160                         *block_size = Arch::page_size;
 161                 }
 162
 163                 // Register/unregister varea as mapping this mappable.
 164
 165                 virtual void map(VirtualArea *varea);
 166                 virtual void unmap(VirtualArea *varea);
 167
 168                 // Make the specified page available for mapping.  This must be
 169                 // done before map() will succeed.  It is possible (though
 170                 // unlikely) that the pages will be removed before map() is called,
 171                 // causing map() to return false.  In such a case, pagein should be
 172                 // called again by the fault handler.  If the mapping fails for
 173                 // other reasons (such as lack of permission, a hole in a stacked
 174                 // aspace, or an I/O error) then pagein() will throw a BadPageFault
 175                 // exception.
 176
 177                 virtual void pagein(u64 vaddr, PTEFlags reqflags) = 0;
 178
 179                 // Returns the physical address and flags associated with a given
 180                 // virtual address.  If flags.Valid is not set, then phys and all
 181                 // other flags are undefined, and pagein() should be retried.
 182                 // rmap_lock must be held.
 183
 184                 virtual void get_mapping(u64 vaddr, u64 *phys, PTEFlags *flags) = 0;
 185
 186                 #include <servers/mem/addrspace/Mem/Mappable.h>
 187
 188                 Mappable()
 189                 {
 190                         init_iface();
 191                         is_aspace = false;
 192                 }
 193
 194                 virtual ~Mappable()
 195                 {
 196                 }
 197         };
 198
 199         struct VirtualArea {
 200                 AddrSpace *aspace;
 201
 202                 // The red/black tree is used to find a region based on address.
 203                 //
 204                 // The linked list is kept in order and is used to iterate over
 205                 // vmas in a region (after looking up the starting point in the
 206                 // tree, unless the region is the entire address space).
 207
 208                 VirtualAreaTree::Node rbtree_node;
 209                 Util::List list_node;
 210                 Util::List mappings_node;
 211
 212                 PTEFlags flags;
 213                 Mappable *ma;
 214
 215                 // This is added to the virtual address to get the offset
 216                 // into the mappable.
 217                 s64 offset;
 218
 219                 Region &region()
 220                 {
 221                         return rbtree_node.value;
 222                 }
 223         };
 224
 225
 226         struct BadPageFault {
 227                 MemoryFault_ns::Cause cause;
 228
 229                 BadPageFault(MemoryFault_ns::Cause CAUSE) : cause(CAUSE)
 230                 {
 231                 }
 232         };
 233
 234         class ASpaceMappable : public Mappable {
 235                 AddrSpace *aspace;
 236
 237                 static bool rec_pagein(AddrSpace *aspace, u64 vaddr,
 238                                        PTEFlags reqflags);
 239
 240         public:
 241                 ASpaceMappable (AddrSpace *ASPACE) : aspace(ASPACE)
 242                 {
 243                         is_aspace = true;
 244                 }
 245
 246                 void get_size(u64 *size);
 247
 248                 // Unexported
 249                 virtual void pagein(u64 vaddr, PTEFlags reqflags);
 250                 virtual void get_mapping(u64 vaddr, u64 *phys, PTEFlags *flags);
 251
 252                 friend class AddrSpace;
 253         };
 254
 255         class AddrSpace {
 256                 // OPT: Coalesce vareas when possible (except when setting flags to
 257                 // match surrounding vareas, as the flags are likely to change
 258                 // again if they've already changed).
 259
 260                 // OPT: A subclass of AddrSpace that doesn't use
 261                 // VirtualArea::offset, but rather has its own virtual method that
 262                 // figures out offsets to the next level using its own data
 263                 // structures (such as filesystem block tables).  This would avoid
 264                 // excessive vareas for fragmented files.  Whether the excess of
 265                 // vareas is significant enough for this to be worthwhile remains
 266                 // to be seen.
 267
 268                 VirtualAreaTree varea_tree;
 269                 Util::List varea_list;
 270                 Lock::Lock lock;
 271
 272                 // This defines the start and end of the aspace; mappings outside
 273                 // this range may not be done, and will not be returned by
 274                 // get_free_region().  For process aspaces, this goes from
 275                 // Arch::user_start to Arch::user_end.  For non-proc aspaces, this
 276                 // can be anything.
 277
 278                 Region aspace_region;
 279
 280                 // Returns true if there is a mapped region that overlaps the given
 281                 // region.  If there is a collision, then the first overlapping
 282                 // varea is returned in va.  Otherwise, it returns the last mapped
 283                 // area before the region in va (if there are no areas, or the
 284                 // region is before the first area, then prev is NULL).  The aspace
 285                 // lock must be held.
 286
 287                 bool check_overlap(Region region, VirtualArea *&va);
 288
 289                 // Finds a free region of the requested length and puts it in
 290                 // region.  Returns true if an appropriate area is found.  The prev
 291                 // pointer is as in check_overlap.  The aspace lock must be held.
 292
 293                 bool get_free_region(ulong len, Region &region, VirtualArea *&prev);
 294
 295                 // This is the value after the last region returned by
 296                 // get_free_region.  If there was an intervening unmap for a lower
 297                 // address, then it is set to that address instead.
 298
 299                 u64 cached_free_region;
 300
 301                 static u64 rec_unmap(AddrSpace *aspace, Region region,
 302                                      PTEFlags reqflags, VirtualArea *va);
 303
 304                 // If there are multiple virtual areas that cover the specified region,
 305                 // split them at the region's boundaries.  The first varea in the region
 306                 // (if any) is returned.  The aspace lock must be held.
 307
 308                 VirtualArea *split_varea(Region region);
 309
 310                 void break_copy_on_write(VirtualArea *va, u64 vaddr, u64 phys);
 311                 bool map(VirtualArea *va, u64 vaddr, PTEFlags reqflags);
 312
 313         protected:
 314                 bool is_process;
 315
 316         public:
 317                 #include <servers/mem/addrspace/Mem/AddrSpace.h>
 318
 319                 ASpaceMappable mappable;
 320                 PageTable *page_table;
 321
 322                 AddrSpace(PageTable *ptbl = NULL);
 323
 324                 // Returns negative if the fault was "good"; otherwise, a fault
 325                 // code corresponding to MemoryFault.Cause is returned.  exec
 326                 // should only be set if the CPU implements per-page exec
 327                 // protection; otherwise, treat it as a read.
 328
 329                 int handle_fault(ulong addr, bool write, bool exec, bool user);
 330
 331                 void get_mappable(IMappable *ma);
 332                 void clone(IAddrSpace *addrspace, u8 clone_is_real);
 333
 334                 void map(IMappable ma, Region region, u64 *vstart, MapFlags mflags,
 335                          PTEFlags set = 0, PTEFlags clear = 0);
 336                 void unmap(Region region, bool from_kernel = false);
 337
 338                 void set_mapflags(Region region, MapFlags mflags);
 339                 void get_mapflags(Region region, MapFlags *mflags, uint8_t *all_same);
 340                 void get_mapping(Region region, IMappable *ma, u64 *offset);
 341
 342                 void get_page_size(u32 *page_size);
 343                 void get_min_align(u32 *min_align);
 344                 void get_size(u64 *size);
 345
 346                 friend class ASpaceMappable;
 347         };
 348
 349         extern Factory addr_space_factory, proc_addr_space_factory;
 350
 351         static inline bool page_aligned(u64 addr)
 352         {
 353                 return !(addr & (u64)(Arch::page_size - 1));
 354         }
 355
 356         static inline u64 page_align(u64 addr)
 357         {
 358                 return addr & ~(u64)(Arch::page_size - 1);
 359         }
 360
 361         // FIXME: Valid user addr?  Paging holes?
 362         static inline bool valid_addr(uint64_t addr)
 363         {
 364                 if (sizeof(void *) == 8)
 365                         return true;
 366
 367                 return (addr >> 32) == 0;
 368         }
 369 };
 370
 371 #endif