kernel/arch/i386/paging.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   6  *
   7  *  This program is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  *
  20  *  Based on JamesM's paging tutorial
  21  */
  22
  23 #include <arch/io.h>
  24 #include <system.h>
  25 #include <paging.h>
  26 #include <config.h>
  27 #include <task.h>
  28
  29 extern unsigned *code, *bss, *data, *end;
  30
  31 // A bitset of frames - used or free.
  32 static unsigned page_nframes;
  33
  34 // Amount of RAM Memory in Bytes
  35 static unsigned long mem_end_page;
  36
  37 // Static function to set a bit in the frames bitset
  38 static void page_set_frame (page_ent_t *page_cover, unsigned frame_addr)
  39 {
  40         unsigned frame = frame_addr / 0x1000;
  41         unsigned idx = index_from_bit (frame);
  42         unsigned off = offset_from_bit (frame);
  43         page_cover->frames[idx] |= (0x1 << off);
  44 }
  45
  46 // Static function to clear a bit in the frames bitset
  47 static void page_clear_frame (page_ent_t *page_cover, unsigned frame_addr)
  48 {
  49         unsigned frame = frame_addr / 0x1000;
  50         unsigned idx = index_from_bit (frame);
  51         unsigned off = offset_from_bit (frame);
  52         page_cover->frames[idx] &= ~(0x1 << off);
  53 }
  54
  55 // Static function to test if a bit is set.
  56 static unsigned page_test_frame (page_ent_t *page_cover, unsigned frame_addr)
  57 {
  58         unsigned frame = frame_addr / 0x1000;
  59         unsigned idx = index_from_bit (frame);
  60         unsigned off = offset_from_bit (frame);
  61
  62         return (page_cover->frames[idx] & (0x1 << off));
  63 }
  64
  65 // Static function to find the first free frame.
  66 static unsigned page_first_frame (page_ent_t *page_cover)
  67 {
  68         unsigned i, j;
  69         for (i = 0; i < index_from_bit (page_nframes); i++) {
  70                 // nothing free, exit early.
  71                 if (page_cover->frames[i] != ~0) {
  72                         // at least one bit is free here.
  73                         for (j = 0; j < 32; j++) {
  74                                 unsigned toTest = 0x1 << j;
  75
  76                                 if (!(page_cover->frames[i] & toTest))
  77                                         return (i * 4 * 8 + j);
  78                         }
  79                 }
  80         }
  81
  82         return 0;
  83 }
  84
  85 // Function to allocate a frame.
  86 void page_alloc_frame (page_ent_t *page_cover, page_t *page, int supervisor, int rw)
  87 {
  88         if (page->frame != 0)
  89                 return; // Frame was already allocated, return straight away.
  90         else {
  91                 unsigned idx = page_first_frame (page_cover); // idx is now the index of the first free frame.
  92
  93                 if (idx == (unsigned) -1) {
  94                         // PANIC is just a macro that prints a message to the screen then hits an infinite loop.
  95                         kprintf ("No free frames!");
  96                 }
  97
  98                 page_set_frame (page_cover, idx * 0x1000); // this frame is now ours!
  99                 page->present = 1; // Mark it as present.
 100                 page->rw = (rw) ? 1 : 0; // Should the page be writeable?
 101                 page->user = (supervisor) ? 0 : 1; // Should the page be user-mode?
 102                 page->frame = idx;
 103         }
 104 }
 105
 106 // Function to deallocate a frame.
 107 void page_free_frame (page_ent_t *page_cover, page_t *page)
 108 {
 109         unsigned frame;
 110         if (!(frame = page->frame)) {
 111                 return; // The given page didn't actually have an allocated frame!
 112         } else {
 113                 page_clear_frame (page_cover, frame); // Frame is now free again.
 114                 page->frame = 0x0; // Page now doesn't have a frame.
 115         }
 116 }
 117
 118 void page_dir_switch (page_dir_t *page_dir)
 119 {
 120 #ifdef CONFIG_MEM_PAGING
 121         page_cover_curr = page_dir;
 122
 123         write_cr3 (&page_dir->tables_phys); // put that page directory address into CR3
 124 #endif
 125 }
 126
 127 page_t *page_get (page_dir_t *dir, unsigned address, int make)
 128 {
 129         // Turn the address into an index.
 130         address /= 0x1000;
 131         // Find the page table containing this address.
 132         unsigned table_idx = address / 1024;
 133
 134         // If this table is already assigned
 135         if (dir->tables[table_idx])
 136                 return &dir->tables[table_idx]->pages[address % 1024];
 137         else if (make) {
 138                 unsigned tmp;
 139                 dir->tables[table_idx] = (page_table_t *) pmalloc_ext (sizeof (page_table_t), (unsigned *) &tmp);
 140
 141                 memset (dir->tables[table_idx], 0, 0x1000);
 142                 dir->tables_phys[table_idx] = tmp | 0x7; // PRESENT, RW, US.
 143
 144                 return &dir->tables[table_idx]->pages[address % 1024];
 145         }
 146
 147         return 0;
 148 }
 149
 150 page_ent_t *page_cover_create ()
 151 {
 152 #ifdef CONFIG_MEM_PAGING
 153         /* Alloc memory for new page_ent_t * structure */
 154         page_ent_t *page_cover = (page_ent_t *) kmalloc (sizeof (page_ent_t));
 155
 156         if (!page_cover)
 157                 return 0;
 158
 159         // Alloc page aligned memory for new page directory
 160         page_cover->page_dir = (page_dir_t *) pmalloc (sizeof (page_dir_t));
 161
 162         if (!page_cover->page_dir) {
 163                 kfree (page_cover);
 164                 return 0;
 165         }
 166
 167         memset (page_cover->page_dir, 0, sizeof (page_dir_t));
 168
 169         page_cover->frames = (unsigned *) kmalloc (index_from_bit (page_nframes));
 170
 171         if (!page_cover->frames) {
 172                 pfree (page_cover->page_dir);
 173                 kfree (page_cover);
 174                 return 0;
 175         }
 176
 177         memset (page_cover->frames, 0, index_from_bit (page_nframes));
 178
 179         return page_cover;
 180 #else
 181         return 0;
 182 #endif
 183 }
 184
 185 unsigned page_cover_delete (page_ent_t *page_cover)
 186 {
 187         if (!page_cover)
 188                 return 0;
 189
 190         if (!page_cover->page_dir)
 191                 return 0;
 192
 193         if (!page_cover->frames)
 194                 return 0;
 195
 196         pfree (page_cover->page_dir);
 197
 198         kfree (page_cover);
 199
 200         kfree (page_cover->frames);
 201
 202         return 1;
 203 }
 204
 205 unsigned page_mmap (page_ent_t *page_cover, void *from, void *to, unsigned kernel, unsigned writeable)
 206 {
 207 #ifdef CONFIG_MEM_PAGING
 208         if (!page_cover)
 209                 return 0;
 210
 211 //      kprintf ("l: 0x%x - 0x%x : ", from, to);
 212
 213         page_cover_curr = page_cover->page_dir;
 214
 215         /* There is start address, where we begin mapping */
 216         unsigned i = (unsigned) from;
 217
 218         /* Loop for increase next 4kB of memory from start */
 219         while (i < ((unsigned) to) ) {
 220                 page_alloc_frame (page_cover, page_get (page_cover->page_dir, i, 1), kernel, writeable);
 221                 i += 0x1000;
 222         }
 223 #endif
 224         return 1;
 225 }
 226
 227 unsigned page_unmmap (page_ent_t *page_cover, void *from, void *to)
 228 {
 229 #ifdef CONFIG_MEM_PAGING
 230         if (!page_cover)
 231                 return 0;
 232
 233         /* There is start address, where we begin unmapping */
 234         unsigned i = (unsigned) from;
 235
 236         /* Loop for increase next 4kB of memory from start */
 237         while (i < ((unsigned) to) ) {
 238                 page_free_frame (page_cover, page_get (page_cover->page_dir, i, 0));
 239
 240                 unsigned address = i;
 241
 242                 // Turn the address into an index.
 243                 address /= 0x1000;
 244                 // Find the page table containing this address.
 245                 unsigned table_idx = address / 1024;
 246
 247                 pfree (page_cover->page_dir->tables[table_idx]);
 248
 249                 i += 0x1000;
 250         }
 251 #endif
 252         return 1;
 253 }
 254
 255 unsigned page_fault (struct regs *r)
 256 {
 257         // A page fault has occurred.
 258         // The faulting address is stored in the CR2 register.
 259         unsigned faulting_address;
 260         asm volatile("mov %%cr2, %0" : "=r" (faulting_address));
 261
 262         // The error code gives us details of what happened.
 263         int present = !(r->err_code & 0x1);   // Page not present
 264         int rw = r->err_code & 0x2;           // Write operation?
 265         int us = r->err_code & 0x4;           // Processor was in user-mode?
 266         int reserved = r->err_code & 0x8;     // Overwritten CPU-reserved bits of page entry?
 267         int id = r->err_code & 0x10;          // Caused by an instruction fetch?
 268
 269         video_color (14, 0);
 270
 271         // Output an error message.
 272         kprintf ("\nERROR -> page flags: ");
 273
 274         if (present)
 275                 kprintf ("present ");
 276         if (rw)
 277                 kprintf ("read-only ");
 278         if (us)
 279                 kprintf ("user-mode ");
 280         if (reserved)
 281                 kprintf ("reserved ");
 282
 283         kprintf ("\n\tFault at 0x%x address\n", faulting_address);
 284
 285         return proc_page_fault ();
 286 }
 287
 288 unsigned paging_enable ()
 289 {
 290 #ifdef CONFIG_MEM_PAGING
 291         unsigned long flags = read_cr0 ();
 292
 293         if (flags & PAGING_BIT)
 294                 return 0;
 295
 296         write_cr0 (flags | PAGING_BIT); // set the paging bit in CR0 to 1
 297 #endif
 298         return 1;
 299 }
 300
 301 unsigned paging_disable ()
 302 {
 303 #ifdef CONFIG_MEM_PAGING
 304         unsigned long flags = read_cr0 ();
 305
 306         if (!(flags & PAGING_BIT))
 307                 return 0;
 308
 309         flags &= ~PAGING_BIT;
 310
 311         write_cr0 (flags); // set the paging bit in CR0 to 0
 312 #endif
 313 }
 314
 315 unsigned int init_paging ()
 316 {
 317 #ifdef CONFIG_MEM_PAGING
 318         // The size of physical memory.
 319         mem_end_page = mem_ext * 1024 * 1024;
 320
 321         page_nframes = mem_end_page / 0x1000;
 322 #endif
 323
 324         return 1;
 325 }