X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fthreads%2Fpalloc.c;h=177001f3c1c4b4ae622422be84f356217ac6dcf5;hb=94d17ee9287aec1c4c9ee37ca02615e8293a5f3a;hp=cec2bacb619575b77edcaa8b4c40634a879c5256;hpb=cd44d58647a33cd74056748e57bb8148cdb6d9df;p=pintos-anon

diff --git a/src/threads/palloc.c b/src/threads/palloc.c
index cec2bac..177001f 100644
--- a/src/threads/palloc.c
+++ b/src/threads/palloc.c
@@ -9,8 +9,8 @@
 #include <string.h>
 #include "threads/init.h"
 #include "threads/loader.h"
-#include "threads/mmu.h"
 #include "threads/synch.h"
+#include "threads/vaddr.h"
 
 /* Page allocator.  Hands out memory in page-size (or
    page-multiple) chunks.  See malloc.h for an allocator that
@@ -35,18 +35,16 @@ struct pool
   };
 
 /* Two pools: one for kernel data, one for user pages. */
-struct pool kernel_pool, user_pool;
-
-/* Maximum number of pages to put in user pool. */
-size_t user_page_limit = SIZE_MAX;
+static struct pool kernel_pool, user_pool;
 
 static void init_pool (struct pool *, void *base, size_t page_cnt,
                        const char *name);
 static bool page_from_pool (const struct pool *, void *page);
 
-/* Initializes the page allocator. */
+/* Initializes the page allocator.  At most USER_PAGE_LIMIT
+   pages are put into the user pool. */
 void
-palloc_init (void) 
+palloc_init (size_t user_page_limit)
 {
   /* End of the kernel as recorded by the linker.
      See kernel.lds.S. */
@@ -54,7 +52,7 @@ palloc_init (void)
 
   /* Free memory. */
   uint8_t *free_start = pg_round_up (&_end);
-  uint8_t *free_end = ptov (ram_pages * PGSIZE);
+  uint8_t *free_end = ptov (init_ram_pages * PGSIZE);
   size_t free_pages = (free_end - free_start) / PGSIZE;
   size_t user_pages = free_pages / 2;
   size_t kernel_pages;
@@ -85,8 +83,9 @@ palloc_get_multiple (enum palloc_flags flags, size_t page_cnt)
     return NULL;
 
   lock_acquire (&pool->lock);
-
   page_idx = bitmap_scan_and_flip (pool->used_map, 0, page_cnt, false);
+  lock_release (&pool->lock);
+
   if (page_idx != BITMAP_ERROR)
     pages = pool->base + PGSIZE * page_idx;
   else
@@ -103,12 +102,11 @@ palloc_get_multiple (enum palloc_flags flags, size_t page_cnt)
         PANIC ("palloc_get: out of pages");
     }
 
-  lock_release (&pool->lock);
-  
   return pages;
 }
 
-/* Obtains and returns a single free page.
+/* Obtains a single free page and returns its kernel virtual
+   address.
    If PAL_USER is set, the page is obtained from the user pool,
    otherwise from the kernel pool.  If PAL_ZERO is set in FLAGS,
    then the page is filled with zeros.  If no pages are
@@ -144,10 +142,8 @@ palloc_free_multiple (void *pages, size_t page_cnt)
   memset (pages, 0xcc, PGSIZE * page_cnt);
 #endif
 
-  lock_acquire (&pool->lock);
-  ASSERT (bitmap_all (pool->used_map, page_idx, page_idx + page_cnt));
-  bitmap_set_multiple (pool->used_map, page_idx, page_idx + page_cnt, false);
-  lock_release (&pool->lock);
+  ASSERT (bitmap_all (pool->used_map, page_idx, page_cnt));
+  bitmap_set_multiple (pool->used_map, page_idx, page_cnt, false);
 }
 
 /* Frees the page at PAGE. */
@@ -165,17 +161,16 @@ init_pool (struct pool *p, void *base, size_t page_cnt, const char *name)
   /* We'll put the pool's used_map at its base.
      Calculate the space needed for the bitmap
      and subtract it from the pool's size. */
-  size_t bm_pages = DIV_ROUND_UP (bitmap_needed_bytes (page_cnt), PGSIZE);
+  size_t bm_pages = DIV_ROUND_UP (bitmap_buf_size (page_cnt), PGSIZE);
   if (bm_pages > page_cnt)
     PANIC ("Not enough memory in %s for bitmap.", name);
   page_cnt -= bm_pages;
 
-  printf ("%d pages available in %s.\n", page_cnt, name);
+  printf ("%zu pages available in %s.\n", page_cnt, name);
 
   /* Initialize the pool. */
-  lock_init (&p->lock, name);
-  p->used_map = bitmap_create_preallocated (page_cnt, base,
-                                            bm_pages * PGSIZE);
+  lock_init (&p->lock);
+  p->used_map = bitmap_create_in_buf (page_cnt, base, bm_pages * PGSIZE);
   p->base = base + bm_pages * PGSIZE;
 }