upstream/opnsense-src
1
0
Fork 0
mirror of https://github.com/opnsense/src.git synced 2026-06-09 08:43:19 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Simplify the invocation of vm_fault(). Specifically, eliminate the flag

Browse source 
VM_FAULT_DIRTY.  The information provided by this flag can be trivially
inferred by vm_fault().

Discussed with:	kib
This commit is contained in:
Alan Cox 2009-11-27 20:24:11 +00:00
parent 137f2acad4
commit e2997fea72
12 changed files with 27 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
sys/amd64/amd64/trap.c
View file

@ -750,9 +750,7 @@ trap_pfault(frame, usermode)
PROC_UNLOCK(p);
/* Fault in the user page: */
rv = vm_fault(map, va, ftype,
(ftype & VM_PROT_WRITE) ? VM_FAULT_DIRTY
: VM_FAULT_NORMAL);
rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL);
PROC_LOCK(p);
--p->p_lock;

3
sys/arm/arm/trap.c
View file

@ -425,8 +425,7 @@ data_abort_handler(trapframe_t *tf)
p->p_lock++;
PROC_UNLOCK(p);
}
error = vm_fault(map, va, ftype, (ftype & VM_PROT_WRITE) ?
VM_FAULT_DIRTY : VM_FAULT_NORMAL);
error = vm_fault(map, va, ftype, VM_FAULT_NORMAL);
pcb->pcb_onfault = onfault;
if (map != kernel_map) {

3
sys/dev/cxgb/ulp/tom/cxgb_vm.c
View file

@ -131,8 +131,7 @@ vm_fault_hold_user_pages(vm_map_t map, vm_offset_t addr, vm_page_t *mp,
* taken away from us before it is held
*/
while (*pages == NULL) {
rv = vm_fault(map, va, prot,
(prot & VM_PROT_WRITE) ? VM_FAULT_DIRTY : VM_FAULT_NORMAL);
rv = vm_fault(map, va, prot, VM_FAULT_NORMAL);
if (rv)
goto error;
*pages = pmap_extract_and_hold(pmap, va, prot);

4
sys/i386/i386/trap.c
View file

@ -825,9 +825,7 @@ trap_pfault(frame, usermode, eva)
PROC_UNLOCK(p);
/* Fault in the user page: */
rv = vm_fault(map, va, ftype,
(ftype & VM_PROT_WRITE) ? VM_FAULT_DIRTY
: VM_FAULT_NORMAL);
rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL);
PROC_LOCK(p);
--p->p_lock;

3
sys/ia64/ia64/trap.c
View file

@ -572,8 +572,7 @@ trap(int vector, struct trapframe *tf)
PROC_UNLOCK(p);
/* Fault in the user page: */
rv = vm_fault(map, va, ftype, (ftype & VM_PROT_WRITE)
? VM_FAULT_DIRTY : VM_FAULT_NORMAL);
rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL);
PROC_LOCK(p);
--p->p_lock;

12
sys/mips/mips/trap.c
View file

@ -538,17 +538,11 @@ dofault:
struct vmspace *vm;
vm_map_t map;
int rv = 0;
int flag;
vm = p->p_vmspace;
map = &vm->vm_map;
va = trunc_page((vm_offset_t)trapframe->badvaddr);
if ((vm_offset_t)trapframe->badvaddr < VM_MIN_KERNEL_ADDRESS) {
if (ftype & VM_PROT_WRITE)
flag = VM_FAULT_DIRTY;
else
flag = VM_FAULT_NORMAL;
} else {
if ((vm_offset_t)trapframe->badvaddr >= VM_MIN_KERNEL_ADDRESS) {
/*
* Don't allow user-mode faults in kernel
* address space.
@ -564,14 +558,14 @@ dofault:
++p->p_lock;
PROC_UNLOCK(p);
rv = vm_fault(map, va, ftype, flag);
rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL);
PROC_LOCK(p);
--p->p_lock;
PROC_UNLOCK(p);
#ifdef VMFAULT_TRACE
printf("vm_fault(%x (pmap %x), %x (%x), %x, %d) -> %x at pc %x\n",
map, &vm->vm_pmap, va, trapframe->badvaddr, ftype, flag,
map, &vm->vm_pmap, va, trapframe->badvaddr, ftype, VM_FAULT_NORMAL,
rv, trapframe->pc);
#endif

4
sys/powerpc/aim/trap.c
View file

@ -491,9 +491,7 @@ trap_pfault(struct trapframe *frame, int user)
PROC_UNLOCK(p);
/* Fault in the user page: */
rv = vm_fault(map, va, ftype,
(ftype & VM_PROT_WRITE) ? VM_FAULT_DIRTY
: VM_FAULT_NORMAL);
rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL);
PROC_LOCK(p);
--p->p_lock;

3
sys/powerpc/booke/trap.c
View file

@ -497,8 +497,7 @@ trap_pfault(struct trapframe *frame, int user)
PROC_UNLOCK(p);
/* Fault in the user page: */
rv = vm_fault(map, va, ftype,
(ftype & VM_PROT_WRITE) ? VM_FAULT_DIRTY : VM_FAULT_NORMAL);
rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL);
PROC_LOCK(p);
--p->p_lock;

9
sys/sparc64/sparc64/trap.c
View file

@ -409,7 +409,6 @@ trap_pfault(struct thread *td, struct trapframe *tf)
vm_prot_t prot;
vm_map_entry_t entry;
u_long ctx;
int flags;
int type;
int rv;
@ -429,15 +428,13 @@ trap_pfault(struct thread *td, struct trapframe *tf)
CTR4(KTR_TRAP, "trap_pfault: td=%p pm_ctx=%#lx va=%#lx ctx=%#lx",
td, p->p_vmspace->vm_pmap.pm_context[curcpu], va, ctx);
if (type == T_DATA_PROTECTION) {
if (type == T_DATA_PROTECTION)
prot = VM_PROT_WRITE;
flags = VM_FAULT_DIRTY;
} else {
else {
if (type == T_DATA_MISS)
prot = VM_PROT_READ;
else
prot = VM_PROT_READ | VM_PROT_EXECUTE;
flags = VM_FAULT_NORMAL;
}
if (ctx != TLB_CTX_KERNEL) {
@ -463,7 +460,7 @@ trap_pfault(struct thread *td, struct trapframe *tf)
PROC_UNLOCK(p);
/* Fault in the user page. */
rv = vm_fault(&vm->vm_map, va, prot, flags);
rv = vm_fault(&vm->vm_map, va, prot, VM_FAULT_NORMAL);
/*
* Now the process can be swapped again.

9
sys/sun4v/sun4v/trap.c
View file

@ -460,7 +460,6 @@ trap_pfault(struct thread *td, struct trapframe *tf, int64_t type, uint64_t data
vm_offset_t va;
vm_prot_t prot;
u_long ctx;
int flags;
int rv;
if (td == NULL)
@ -487,15 +486,13 @@ trap_pfault(struct thread *td, struct trapframe *tf, int64_t type, uint64_t data
KASSERT(td->td_proc->p_vmspace != NULL, ("trap_pfault: vmspace NULL"));
if (type == T_DATA_PROTECTION) {
if (type == T_DATA_PROTECTION)
prot = VM_PROT_WRITE;
flags = VM_FAULT_DIRTY;
} else {
else {
if (type == T_DATA_MISS)
prot = VM_PROT_READ;
else
prot = VM_PROT_READ | VM_PROT_EXECUTE;
flags = VM_FAULT_NORMAL;
}
if (ctx != TLB_CTX_KERNEL) {
@ -521,7 +518,7 @@ trap_pfault(struct thread *td, struct trapframe *tf, int64_t type, uint64_t data
PROC_UNLOCK(p);
/* Fault in the user page. */
rv = vm_fault(&vm->vm_map, va, prot, flags);
rv = vm_fault(&vm->vm_map, va, prot, VM_FAULT_NORMAL);
/*
* Now the process can be swapped again.

19
sys/vm/vm_fault.c
View file

@ -857,19 +857,12 @@ vnode_locked:
vm_object_set_writeable_dirty(fs.object);
/*
* If the fault is a write, we know that this page is being
* written NOW so dirty it explicitly to save on
* pmap_is_modified() calls later.
*
* If this is a NOSYNC mmap we do not want to set VPO_NOSYNC
* if the page is already dirty to prevent data written with
* the expectation of being synced from not being synced.
* Likewise if this entry does not request NOSYNC then make
* sure the page isn't marked NOSYNC. Applications sharing
* data should use the same flags to avoid ping ponging.
*
* Also tell the backing pager, if any, that it should remove
* any swap backing since the page is now dirty.
*/
if (fs.entry->eflags & MAP_ENTRY_NOSYNC) {
if (fs.m->dirty == 0)
@ -877,7 +870,17 @@ vnode_locked:
} else {
fs.m->oflags &= ~VPO_NOSYNC;
}
if (fault_flags & VM_FAULT_DIRTY) {
/*
* If the fault is a write, we know that this page is being
* written NOW so dirty it explicitly to save on
* pmap_is_modified() calls later.
*
* Also tell the backing pager, if any, that it should remove
* any swap backing since the page is now dirty.
*/
if ((fault_type & VM_PROT_WRITE) != 0 &&
(fault_flags & VM_FAULT_CHANGE_WIRING) == 0) {
vm_page_dirty(fs.m);
vm_pager_page_unswapped(fs.m);
}

1
sys/vm/vm_map.h
View file

@ -319,7 +319,6 @@ long vmspace_wired_count(struct vmspace *vmspace);
*/
#define VM_FAULT_NORMAL 0 /* Nothing special */
#define VM_FAULT_CHANGE_WIRING 1 /* Change the wiring as appropriate */
#define VM_FAULT_DIRTY 8 /* Dirty the page */
/*
* The following "find_space" options are supported by vm_map_find()