SCCS-vsn: sys/vm/vm_page.c 8.4
SCCS-vsn: sys/vm/vm_kern.c 8.4
SCCS-vsn: sys/vm/vm_fault.c 8.5
SCCS-vsn: sys/vm/vm_object.c 8.6
SCCS-vsn: sys/vm/vm_page.h 8.3
SCCS-vsn: sys/vm/vm_pageout.c 8.6
SCCS-vsn: sys/vm/vm_unix.c 8.2
SCCS-vsn: sys/vm/vm_pageout.h 8.3
SCCS-vsn: sys/vm/vm_param.h 8.2
SCCS-vsn: sys/vm/vm_extern.h 8.3
*
* %sccs.include.redist.c%
*
*
* %sccs.include.redist.c%
*
- * @(#)vm_extern.h 8.2 (Berkeley) %G%
+ * @(#)vm_extern.h 8.3 (Berkeley) %G%
int sstk __P((struct proc *, void *, int *));
#endif
int sstk __P((struct proc *, void *, int *));
#endif
-void assert_wait __P((int, boolean_t));
-int grow __P((struct proc *, u_int));
+void assert_wait __P((void *, boolean_t));
+int grow __P((struct proc *, vm_offset_t));
void iprintf __P((const char *, ...));
int kernacc __P((caddr_t, int, int));
int kinfo_loadavg __P((int, char *, int *, int, int *));
void iprintf __P((const char *, ...));
int kernacc __P((caddr_t, int, int));
int kinfo_loadavg __P((int, char *, int *, int, int *));
vm_map_t kmem_suballoc __P((vm_map_t, vm_offset_t *, vm_offset_t *,
vm_size_t, boolean_t));
void loadav __P((struct loadavg *));
vm_map_t kmem_suballoc __P((vm_map_t, vm_offset_t *, vm_offset_t *,
vm_size_t, boolean_t));
void loadav __P((struct loadavg *));
-void munmapfd __P((int));
+void munmapfd __P((struct proc *, int));
int pager_cache __P((vm_object_t, boolean_t));
void sched __P((void));
int svm_allocate __P((struct proc *, void *, int *));
int pager_cache __P((vm_object_t, boolean_t));
void sched __P((void));
int svm_allocate __P((struct proc *, void *, int *));
int swfree __P((struct proc *, int));
void swstrategy __P((struct buf *));
void thread_block __P((void));
int swfree __P((struct proc *, int));
void swstrategy __P((struct buf *));
void thread_block __P((void));
-void thread_sleep __P((int, simple_lock_t, boolean_t));
-void thread_wakeup __P((int));
+void thread_sleep __P((void *, simple_lock_t, boolean_t));
+void thread_wakeup __P((void *));
int useracc __P((caddr_t, int, int));
int vm_allocate __P((vm_map_t,
vm_offset_t *, vm_size_t, boolean_t));
int useracc __P((caddr_t, int, int));
int vm_allocate __P((vm_map_t,
vm_offset_t *, vm_size_t, boolean_t));
*
* %sccs.include.redist.c%
*
*
* %sccs.include.redist.c%
*
- * @(#)vm_fault.c 8.4 (Berkeley) %G%
+ * @(#)vm_fault.c 8.5 (Berkeley) %G%
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
* Unwire a range of virtual addresses in a map.
*/
*
* Unwire a range of virtual addresses in a map.
*/
-void vm_fault_unwire(map, start, end)
+void
+vm_fault_unwire(map, start, end)
vm_map_t map;
vm_offset_t start, end;
{
vm_map_t map;
vm_offset_t start, end;
{
* entry corresponding to a main map entry that is wired down).
*/
* entry corresponding to a main map entry that is wired down).
*/
-void vm_fault_copy_entry(dst_map, src_map, dst_entry, src_entry)
+void
+vm_fault_copy_entry(dst_map, src_map, dst_entry, src_entry)
vm_map_t dst_map;
vm_map_t src_map;
vm_map_entry_t dst_entry;
vm_map_t dst_map;
vm_map_t src_map;
vm_map_entry_t dst_entry;
*
* %sccs.include.redist.c%
*
*
* %sccs.include.redist.c%
*
- * @(#)vm_kern.c 8.3 (Berkeley) %G%
+ * @(#)vm_kern.c 8.4 (Berkeley) %G%
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
* Allocate pageable memory to the kernel's address map.
* map must be "kernel_map" below.
*/
* Allocate pageable memory to the kernel's address map.
* map must be "kernel_map" below.
*/
-
-vm_offset_t kmem_alloc_pageable(map, size)
+vm_offset_t
+kmem_alloc_pageable(map, size)
vm_map_t map;
register vm_size_t size;
{
vm_map_t map;
register vm_size_t size;
{
* Allocate wired-down memory in the kernel's address map
* or a submap.
*/
* Allocate wired-down memory in the kernel's address map
* or a submap.
*/
-vm_offset_t kmem_alloc(map, size)
+vm_offset_t
+kmem_alloc(map, size)
register vm_map_t map;
register vm_size_t size;
{
register vm_map_t map;
register vm_size_t size;
{
* with kmem_alloc, and return the physical pages
* associated with that region.
*/
* with kmem_alloc, and return the physical pages
* associated with that region.
*/
-void kmem_free(map, addr, size)
+void
+kmem_free(map, addr, size)
vm_map_t map;
register vm_offset_t addr;
vm_size_t size;
vm_map_t map;
register vm_offset_t addr;
vm_size_t size;
* min, max Returned endpoints of map
* pageable Can the region be paged
*/
* min, max Returned endpoints of map
* pageable Can the region be paged
*/
-vm_map_t kmem_suballoc(parent, min, max, size, pageable)
+vm_map_t
+kmem_suballoc(parent, min, max, size, pageable)
register vm_map_t parent;
vm_offset_t *min, *max;
register vm_size_t size;
register vm_map_t parent;
vm_offset_t *min, *max;
register vm_size_t size;
* has no room, the caller sleeps waiting for more memory in the submap.
*
*/
* has no room, the caller sleeps waiting for more memory in the submap.
*
*/
-vm_offset_t kmem_alloc_wait(map, size)
+vm_offset_t
+kmem_alloc_wait(map, size)
vm_map_t map;
vm_size_t size;
{
vm_map_t map;
vm_size_t size;
{
vm_map_unlock(map);
return (0);
}
vm_map_unlock(map);
return (0);
}
- assert_wait((int)map, TRUE);
+ assert_wait(map, TRUE);
vm_map_unlock(map);
thread_block();
}
vm_map_unlock(map);
thread_block();
}
* Returns memory to a submap of the kernel, and wakes up any threads
* waiting for memory in that map.
*/
* Returns memory to a submap of the kernel, and wakes up any threads
* waiting for memory in that map.
*/
-void kmem_free_wakeup(map, addr, size)
+void
+kmem_free_wakeup(map, addr, size)
vm_map_t map;
vm_offset_t addr;
vm_size_t size;
{
vm_map_lock(map);
(void) vm_map_delete(map, trunc_page(addr), round_page(addr + size));
vm_map_t map;
vm_offset_t addr;
vm_size_t size;
{
vm_map_lock(map);
(void) vm_map_delete(map, trunc_page(addr), round_page(addr + size));
- thread_wakeup((int)map);
* map the range between VM_MIN_KERNEL_ADDRESS and `start' as allocated, and
* the range between `start' and `end' as free.
*/
* map the range between VM_MIN_KERNEL_ADDRESS and `start' as allocated, and
* the range between `start' and `end' as free.
*/
-void kmem_init(start, end)
+void
+kmem_init(start, end)
vm_offset_t start, end;
{
register vm_map_t m;
vm_offset_t start, end;
{
register vm_map_t m;
*
* %sccs.include.redist.c%
*
*
* %sccs.include.redist.c%
*
- * @(#)vm_object.c 8.5 (Berkeley) %G%
+ * @(#)vm_object.c 8.6 (Berkeley) %G%
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
* Initialize the VM objects module.
*/
*
* Initialize the VM objects module.
*/
-void vm_object_init(size)
+void
+vm_object_init(size)
vm_size_t size;
{
register int i;
vm_size_t size;
{
register int i;
* Returns a new object with the given size.
*/
* Returns a new object with the given size.
*/
-vm_object_t vm_object_allocate(size)
+vm_object_t
+vm_object_allocate(size)
vm_size_t size;
{
register vm_object_t result;
vm_size_t size;
{
register vm_object_t result;
*
* Gets another reference to the given object.
*/
*
* Gets another reference to the given object.
*/
-void vm_object_reference(object)
+void
+vm_object_reference(object)
register vm_object_t object;
{
if (object == NULL)
register vm_object_t object;
{
if (object == NULL)
*
* No object may be locked.
*/
*
* No object may be locked.
*/
-void vm_object_deallocate(object)
+void
+vm_object_deallocate(object)
register vm_object_t object;
{
vm_object_t temp;
register vm_object_t object;
{
vm_object_t temp;
*
* The object must be locked.
*/
*
* The object must be locked.
*/
-void vm_object_terminate(object)
+void
+vm_object_terminate(object)
register vm_object_t object;
{
register vm_page_t p;
register vm_object_t object;
{
register vm_page_t p;
* Wait until the pageout daemon is through with the object.
*/
while (object->paging_in_progress) {
* Wait until the pageout daemon is through with the object.
*/
while (object->paging_in_progress) {
- vm_object_sleep((int)object, object, FALSE);
+ vm_object_sleep(object, object, FALSE);
vm_object_lock(object);
}
vm_object_lock(object);
}
* Wait until the pageout daemon is through with the object.
*/
while (object->paging_in_progress) {
* Wait until the pageout daemon is through with the object.
*/
while (object->paging_in_progress) {
- vm_object_sleep((int)object, object, FALSE);
+ vm_object_sleep(object, object, FALSE);
vm_object_lock(object);
}
/*
vm_object_lock(object);
}
/*
*
* The object must *not* be locked.
*/
*
* The object must *not* be locked.
*/
-void vm_object_pmap_copy(object, start, end)
+void
+vm_object_pmap_copy(object, start, end)
register vm_object_t object;
register vm_offset_t start;
register vm_offset_t end;
register vm_object_t object;
register vm_offset_t start;
register vm_offset_t end;
*
* The object must *not* be locked.
*/
*
* The object must *not* be locked.
*/
-void vm_object_pmap_remove(object, start, end)
+void
+vm_object_pmap_remove(object, start, end)
register vm_object_t object;
register vm_offset_t start;
register vm_offset_t end;
register vm_object_t object;
register vm_offset_t start;
register vm_offset_t end;
* May defer the copy until later if the object is not backed
* up by a non-default pager.
*/
* May defer the copy until later if the object is not backed
* up by a non-default pager.
*/
-void vm_object_copy(src_object, src_offset, size,
+void
+vm_object_copy(src_object, src_offset, size,
dst_object, dst_offset, src_needs_copy)
register vm_object_t src_object;
vm_offset_t src_offset;
dst_object, dst_offset, src_needs_copy)
register vm_object_t src_object;
vm_offset_t src_offset;
* are returned in the source parameters.
*/
* are returned in the source parameters.
*/
-void vm_object_shadow(object, offset, length)
+void
+vm_object_shadow(object, offset, length)
vm_object_t *object; /* IN/OUT */
vm_offset_t *offset; /* IN/OUT */
vm_size_t length;
vm_object_t *object; /* IN/OUT */
vm_offset_t *offset; /* IN/OUT */
vm_size_t length;
* Set the specified object's pager to the specified pager.
*/
* Set the specified object's pager to the specified pager.
*/
-void vm_object_setpager(object, pager, paging_offset,
+void
+vm_object_setpager(object, pager, paging_offset,
read_only)
vm_object_t object;
vm_pager_t pager;
read_only)
vm_object_t object;
vm_pager_t pager;
*/
#define vm_object_hash(pager) \
*/
#define vm_object_hash(pager) \
- (((unsigned)pager)%VM_OBJECT_HASH_COUNT)
+ (((unsigned long)pager)%VM_OBJECT_HASH_COUNT)
/*
* vm_object_lookup looks in the object cache for an object with the
* specified pager and paging id.
*/
/*
* vm_object_lookup looks in the object cache for an object with the
* specified pager and paging id.
*/
-vm_object_t vm_object_lookup(pager)
+vm_object_t
+vm_object_lookup(pager)
vm_pager_t pager;
{
register vm_object_hash_entry_t entry;
vm_pager_t pager;
{
register vm_object_hash_entry_t entry;
-void vm_object_enter(object, pager)
+void
+vm_object_enter(object, pager)
vm_object_t object;
vm_pager_t pager;
{
vm_object_t object;
vm_pager_t pager;
{
* vm_object_cache_clear removes all objects from the cache.
*
*/
* vm_object_cache_clear removes all objects from the cache.
*
*/
-
-void vm_object_cache_clear()
+void
+vm_object_cache_clear()
{
register vm_object_t object;
{
register vm_object_t object;
* queues be unlocked.
*
*/
* queues be unlocked.
*
*/
-void vm_object_collapse(object)
+void
+vm_object_collapse(object)
register vm_object_t object;
{
register vm_object_t object;
{
*
* The object must be locked.
*/
*
* The object must be locked.
*/
-void vm_object_page_remove(object, start, end)
+void
+vm_object_page_remove(object, start, end)
register vm_object_t object;
register vm_offset_t start;
register vm_offset_t end;
register vm_object_t object;
register vm_offset_t start;
register vm_offset_t end;
* Conditions:
* The object must *not* be locked.
*/
* Conditions:
* The object must *not* be locked.
*/
-boolean_t vm_object_coalesce(prev_object, next_object,
+boolean_t
+vm_object_coalesce(prev_object, next_object,
prev_offset, next_offset,
prev_size, next_size)
prev_offset, next_offset,
prev_size, next_size)
/*
* vm_object_print: [ debug ]
*/
/*
* vm_object_print: [ debug ]
*/
-void vm_object_print(object, full)
+void
+vm_object_print(object, full)
vm_object_t object;
boolean_t full;
{
vm_object_t object;
boolean_t full;
{
*
* %sccs.include.redist.c%
*
*
* %sccs.include.redist.c%
*
- * @(#)vm_page.c 8.3 (Berkeley) %G%
+ * @(#)vm_page.c 8.4 (Berkeley) %G%
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
* Sets page_shift and page_mask from cnt.v_page_size.
*/
*
* Sets page_shift and page_mask from cnt.v_page_size.
*/
+void
+vm_set_page_size()
{
if (cnt.v_page_size == 0)
{
if (cnt.v_page_size == 0)
* for the object/offset-to-page hash table headers.
* Each page cell is initialized and placed on the free list.
*/
* for the object/offset-to-page hash table headers.
* Each page cell is initialized and placed on the free list.
*/
-void vm_page_startup(start, end)
+void
+vm_page_startup(start, end)
vm_offset_t *start;
vm_offset_t *end;
{
vm_offset_t *start;
vm_offset_t *end;
{
* NOTE: This macro depends on vm_page_bucket_count being a power of 2.
*/
#define vm_page_hash(object, offset) \
* NOTE: This macro depends on vm_page_bucket_count being a power of 2.
*/
#define vm_page_hash(object, offset) \
- (((unsigned)object+(unsigned)atop(offset))&vm_page_hash_mask)
+ (((unsigned long)object+(unsigned long)atop(offset))&vm_page_hash_mask)
/*
* vm_page_insert: [ internal use only ]
/*
* vm_page_insert: [ internal use only ]
* The object and page must be locked.
*/
* The object and page must be locked.
*/
-void vm_page_insert(mem, object, offset)
+void
+vm_page_insert(mem, object, offset)
register vm_page_t mem;
register vm_object_t object;
register vm_offset_t offset;
register vm_page_t mem;
register vm_object_t object;
register vm_offset_t offset;
* The object and page must be locked.
*/
* The object and page must be locked.
*/
-void vm_page_remove(mem)
+void
+vm_page_remove(mem)
register vm_page_t mem;
{
register struct pglist *bucket;
register vm_page_t mem;
{
register struct pglist *bucket;
* The object must be locked. No side effects.
*/
* The object must be locked. No side effects.
*/
-vm_page_t vm_page_lookup(object, offset)
+vm_page_t
+vm_page_lookup(object, offset)
register vm_object_t object;
register vm_offset_t offset;
{
register vm_object_t object;
register vm_offset_t offset;
{
*
* The object must be locked.
*/
*
* The object must be locked.
*/
-void vm_page_rename(mem, new_object, new_offset)
+void
+vm_page_rename(mem, new_object, new_offset)
register vm_page_t mem;
register vm_object_t new_object;
vm_offset_t new_offset;
register vm_page_t mem;
register vm_object_t new_object;
vm_offset_t new_offset;
*
* Object must be locked.
*/
*
* Object must be locked.
*/
-vm_page_t vm_page_alloc(object, offset)
+vm_page_t
+vm_page_alloc(object, offset)
vm_object_t object;
vm_offset_t offset;
{
vm_object_t object;
vm_offset_t offset;
{
if (cnt.v_free_count < cnt.v_free_min ||
(cnt.v_free_count < cnt.v_free_target &&
cnt.v_inactive_count < cnt.v_inactive_target))
if (cnt.v_free_count < cnt.v_free_min ||
(cnt.v_free_count < cnt.v_free_target &&
cnt.v_inactive_count < cnt.v_inactive_target))
- thread_wakeup((int)&vm_pages_needed);
+ thread_wakeup(&vm_pages_needed);
*
* Object and page must be locked prior to entry.
*/
*
* Object and page must be locked prior to entry.
*/
register vm_page_t mem;
{
vm_page_remove(mem);
register vm_page_t mem;
{
vm_page_remove(mem);
*
* The page queues must be locked.
*/
*
* The page queues must be locked.
*/
register vm_page_t mem;
{
VM_PAGE_CHECK(mem);
register vm_page_t mem;
{
VM_PAGE_CHECK(mem);
*
* The page queues must be locked.
*/
*
* The page queues must be locked.
*/
-void vm_page_unwire(mem)
+void
+vm_page_unwire(mem)
register vm_page_t mem;
{
VM_PAGE_CHECK(mem);
register vm_page_t mem;
{
VM_PAGE_CHECK(mem);
*
* The page queues must be locked.
*/
*
* The page queues must be locked.
*/
-void vm_page_deactivate(m)
+void
+vm_page_deactivate(m)
register vm_page_t m;
{
VM_PAGE_CHECK(m);
register vm_page_t m;
{
VM_PAGE_CHECK(m);
* The page queues must be locked.
*/
* The page queues must be locked.
*/
-void vm_page_activate(m)
+void
+vm_page_activate(m)
register vm_page_t m;
{
VM_PAGE_CHECK(m);
register vm_page_t m;
{
VM_PAGE_CHECK(m);
* be used by the zero-fill object.
*/
* be used by the zero-fill object.
*/
-boolean_t vm_page_zero_fill(m)
+boolean_t
+vm_page_zero_fill(m)
vm_page_t m;
{
VM_PAGE_CHECK(m);
vm_page_t m;
{
VM_PAGE_CHECK(m);
* Copy one page to another
*/
* Copy one page to another
*/
-void vm_page_copy(src_m, dest_m)
+void
+vm_page_copy(src_m, dest_m)
vm_page_t src_m;
vm_page_t dest_m;
{
vm_page_t src_m;
vm_page_t dest_m;
{
*
* %sccs.include.redist.c%
*
*
* %sccs.include.redist.c%
*
- * @(#)vm_page.h 8.2 (Berkeley) %G%
+ * @(#)vm_page.h 8.3 (Berkeley) %G%
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
#define PAGE_ASSERT_WAIT(m, interruptible) { \
(m)->flags |= PG_WANTED; \
#define PAGE_ASSERT_WAIT(m, interruptible) { \
(m)->flags |= PG_WANTED; \
- assert_wait((int) (m), (interruptible)); \
+ assert_wait((m), (interruptible)); \
}
#define PAGE_WAKEUP(m) { \
(m)->flags &= ~PG_BUSY; \
if ((m)->flags & PG_WANTED) { \
(m)->flags &= ~PG_WANTED; \
}
#define PAGE_WAKEUP(m) { \
(m)->flags &= ~PG_BUSY; \
if ((m)->flags & PG_WANTED) { \
(m)->flags &= ~PG_WANTED; \
- thread_wakeup((int) (m)); \
*
* %sccs.include.redist.c%
*
*
* %sccs.include.redist.c%
*
- * @(#)vm_pageout.c 8.5 (Berkeley) %G%
+ * @(#)vm_pageout.c 8.6 (Berkeley) %G%
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
else
#endif
vm_pageout_page(m, object);
else
#endif
vm_pageout_page(m, object);
- thread_wakeup((int) object);
vm_object_unlock(object);
/*
* Former next page may no longer even be on the inactive
vm_object_unlock(object);
/*
* Former next page may no longer even be on the inactive
/*
* Do a wakeup here in case the following operations block.
*/
/*
* Do a wakeup here in case the following operations block.
*/
- thread_wakeup((int) &cnt.v_free_count);
+ thread_wakeup(&cnt.v_free_count);
/*
* If there is no pager for the page, use the default pager.
/*
* If there is no pager for the page, use the default pager.
object->paging_in_progress++;
vm_object_unlock(object);
again:
object->paging_in_progress++;
vm_object_unlock(object);
again:
- thread_wakeup((int) &cnt.v_free_count);
+ thread_wakeup(&cnt.v_free_count);
postatus = vm_pager_put_pages(object->pager, plistp, count, FALSE);
/*
* XXX rethink this
postatus = vm_pager_put_pages(object->pager, plistp, count, FALSE);
/*
* XXX rethink this
* vm_pageout is the high level pageout daemon.
*/
* vm_pageout is the high level pageout daemon.
*/
simple_lock(&vm_pages_needed_lock);
while (TRUE) {
simple_lock(&vm_pages_needed_lock);
while (TRUE) {
- thread_sleep((int) &vm_pages_needed, &vm_pages_needed_lock,
- FALSE);
+ thread_sleep(&vm_pages_needed, &vm_pages_needed_lock, FALSE);
/*
* Compute the inactive target for this scan.
* We need to keep a reasonable amount of memory in the
/*
* Compute the inactive target for this scan.
* We need to keep a reasonable amount of memory in the
vm_pageout_scan();
vm_pager_sync();
simple_lock(&vm_pages_needed_lock);
vm_pageout_scan();
vm_pager_sync();
simple_lock(&vm_pages_needed_lock);
- thread_wakeup((int) &cnt.v_free_count);
+ thread_wakeup(&cnt.v_free_count);
*
* %sccs.include.redist.c%
*
*
* %sccs.include.redist.c%
*
- * @(#)vm_pageout.h 8.2 (Berkeley) %G%
+ * @(#)vm_pageout.h 8.3 (Berkeley) %G%
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
#define VM_WAIT { \
simple_lock(&vm_pages_needed_lock); \
#define VM_WAIT { \
simple_lock(&vm_pages_needed_lock); \
- thread_wakeup((int)&vm_pages_needed); \
- thread_sleep((int)&cnt.v_free_count, \
+ thread_wakeup(&vm_pages_needed); \
+ thread_sleep(&cnt.v_free_count, \
&vm_pages_needed_lock, FALSE); \
}
#ifdef KERNEL
&vm_pages_needed_lock, FALSE); \
}
#ifdef KERNEL
*
* %sccs.include.redist.c%
*
*
* %sccs.include.redist.c%
*
- * @(#)vm_param.h 8.1 (Berkeley) %G%
+ * @(#)vm_param.h 8.2 (Berkeley) %G%
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
*
*
* Copyright (c) 1987, 1990 Carnegie-Mellon University.
* The machine independent pages are refered to as PAGES. A page
* is some number of hardware pages, depending on the target machine.
*/
* The machine independent pages are refered to as PAGES. A page
* is some number of hardware pages, depending on the target machine.
*/
-#define DEFAULT_PAGE_SIZE 4096
+#define DEFAULT_PAGE_SIZE 4096
/*
* All references to the size of a page should be done with PAGE_SIZE
/*
* All references to the size of a page should be done with PAGE_SIZE
* we can easily make them constant if we so desire.
*/
#define PAGE_SIZE cnt.v_page_size /* size of page */
* we can easily make them constant if we so desire.
*/
#define PAGE_SIZE cnt.v_page_size /* size of page */
-#define PAGE_MASK page_mask /* size of page - 1 */
-#define PAGE_SHIFT page_shift /* bits to shift for pages */
+#define PAGE_MASK page_mask /* size of page - 1 */
+#define PAGE_SHIFT page_shift /* bits to shift for pages */
#ifdef KERNEL
extern vm_size_t page_mask;
extern int page_shift;
#ifdef KERNEL
extern vm_size_t page_mask;
extern int page_shift;
/*
* CTL_VM identifiers
*/
/*
* CTL_VM identifiers
*/
-#define VM_METER 1 /* struct vmmeter */
-#define VM_LOADAVG 2 /* struct loadavg */
-#define VM_MAXID 3 /* number of valid vm ids */
+#define VM_METER 1 /* struct vmmeter */
+#define VM_LOADAVG 2 /* struct loadavg */
+#define VM_MAXID 3 /* number of valid vm ids */
-#define CTL_VM_NAMES { \
+#define CTL_VM_NAMES { \
{ 0, 0 }, \
{ "vmmeter", CTLTYPE_STRUCT }, \
{ "loadavg", CTLTYPE_STRUCT }, \
{ 0, 0 }, \
{ "vmmeter", CTLTYPE_STRUCT }, \
{ "loadavg", CTLTYPE_STRUCT }, \
* No rounding is used.
*/
#ifdef KERNEL
* No rounding is used.
*/
#ifdef KERNEL
-#define atop(x) (((unsigned)(x)) >> PAGE_SHIFT)
+#define atop(x) (((unsigned long)(x)) >> PAGE_SHIFT)
#define ptoa(x) ((vm_offset_t)((x) << PAGE_SHIFT))
/*
* Round off or truncate to the nearest page. These will work
* for either addresses or counts (i.e., 1 byte rounds to 1 page).
*/
#define ptoa(x) ((vm_offset_t)((x) << PAGE_SHIFT))
/*
* Round off or truncate to the nearest page. These will work
* for either addresses or counts (i.e., 1 byte rounds to 1 page).
*/
((vm_offset_t)((((vm_offset_t)(x)) + PAGE_MASK) & ~PAGE_MASK))
((vm_offset_t)((((vm_offset_t)(x)) + PAGE_MASK) & ~PAGE_MASK))
((vm_offset_t)(((vm_offset_t)(x)) & ~PAGE_MASK))
((vm_offset_t)(((vm_offset_t)(x)) & ~PAGE_MASK))
((vm_offset_t)((((vm_offset_t)(x)) + PAGE_MASK) >> PAGE_SHIFT))
extern vm_size_t mem_size; /* size of physical memory (bytes) */
((vm_offset_t)((((vm_offset_t)(x)) + PAGE_MASK) >> PAGE_SHIFT))
extern vm_size_t mem_size; /* size of physical memory (bytes) */
#else
/* out-of-kernel versions of round_page and trunc_page */
#define round_page(x) \
#else
/* out-of-kernel versions of round_page and trunc_page */
#define round_page(x) \
- ((((vm_offset_t)(x) + (vm_page_size - 1)) / vm_page_size) * vm_page_size)
+ ((((vm_offset_t)(x) + (vm_page_size - 1)) / vm_page_size) * \
+ vm_page_size)
#define trunc_page(x) \
((((vm_offset_t)(x)) / vm_page_size) * vm_page_size)
#define trunc_page(x) \
((((vm_offset_t)(x)) / vm_page_size) * vm_page_size)
*
* from: Utah $Hdr: vm_unix.c 1.1 89/11/07$
*
*
* from: Utah $Hdr: vm_unix.c 1.1 89/11/07$
*
- * @(#)vm_unix.c 8.1 (Berkeley) %G%
+ * @(#)vm_unix.c 8.2 (Berkeley) %G%
int
grow(p, sp)
struct proc *p;
int
grow(p, sp)
struct proc *p;
{
register struct vmspace *vm = p->p_vmspace;
register int si;
{
register struct vmspace *vm = p->p_vmspace;
register int si;
/*
* For user defined stacks (from sendsig).
*/
/*
* For user defined stacks (from sendsig).
*/
- if (sp < (unsigned)vm->vm_maxsaddr)
+ if (sp < (vm_offset_t)vm->vm_maxsaddr)
return (0);
/*
* For common case of already allocated (from trap).
return (0);
/*
* For common case of already allocated (from trap).
projects / unix-history / commitdiff