自学教程：C++ vm_page_lock函数代码示例

/* * Obtain a page pointer array and lock all pages into system memory. A segmentation violation will * occur here if the calling user does not have access to the submitted address. */static intvia_lock_all_dma_pages(drm_via_sg_info_t *vsg,  drm_via_dmablit_t *xfer){	unsigned long first_pfn = VIA_PFN(xfer->mem_addr);	vm_page_t m;	int i;	vsg->num_pages = VIA_PFN(xfer->mem_addr +	    (xfer->num_lines * xfer->mem_stride -1)) - first_pfn + 1;	if (NULL == (vsg->pages = malloc(sizeof(vm_page_t) * vsg->num_pages,	    DRM_MEM_DRIVER, M_NOWAIT)))		return -ENOMEM;	vsg->state = dr_via_pages_alloc;	if (vm_fault_quick_hold_pages(&curproc->p_vmspace->vm_map,	    (vm_offset_t)xfer->mem_addr, vsg->num_pages * PAGE_SIZE,	    VM_PROT_READ | VM_PROT_WRITE, vsg->pages, vsg->num_pages) < 0)		return -EACCES;	for (i = 0; i < vsg->num_pages; i++) {		m = vsg->pages[i];		vm_page_lock(m);		vm_page_wire(m);		vm_page_unhold(m);		vm_page_unlock(m);	}	vsg->state = dr_via_pages_locked;	DRM_DEBUG("DMA pages locked/n");	return 0;}

/* * Function that frees up all resources for a blit. It is usable even if the * blit info has only been partially built as long as the status enum is consistent * with the actual status of the used resources. */static voidvia_free_sg_info(drm_via_sg_info_t *vsg){	vm_page_t page;	int i;	switch(vsg->state) {	case dr_via_device_mapped:		via_unmap_blit_from_device(vsg);	case dr_via_desc_pages_alloc:		for (i=0; i<vsg->num_desc_pages; ++i) {			if (vsg->desc_pages[i] != NULL)			    free(vsg->desc_pages[i], DRM_MEM_PAGES);		}		free(vsg->desc_pages, DRM_MEM_DRIVER);	case dr_via_pages_locked:		for (i=0; i < vsg->num_pages; ++i) {			page = vsg->pages[i];			vm_page_lock(page);			vm_page_unwire(page, 0);			vm_page_unlock(page);		}	case dr_via_pages_alloc:		free(vsg->pages, DRM_MEM_DRIVER);	default:		vsg->state = dr_via_sg_init;	}	free(vsg->bounce_buffer, DRM_MEM_DRIVER);	vsg->bounce_buffer = NULL;	vsg->free_on_sequence = 0;}

/* --------------------------------------------------------------------- */static inttmpfs_nocacheread(vm_object_t tobj, vm_pindex_t idx,    vm_offset_t offset, size_t tlen, struct uio *uio){	vm_page_t	m;	int		error;	VM_OBJECT_LOCK(tobj);	vm_object_pip_add(tobj, 1);	m = vm_page_grab(tobj, idx, VM_ALLOC_WIRED |	    VM_ALLOC_ZERO | VM_ALLOC_NORMAL | VM_ALLOC_RETRY);	if (m->valid != VM_PAGE_BITS_ALL) {		if (vm_pager_has_page(tobj, idx, NULL, NULL)) {			error = vm_pager_get_pages(tobj, &m, 1, 0);			if (error != 0) {				printf("tmpfs get pages from pager error [read]/n");				goto out;			}		} else			vm_page_zero_invalid(m, TRUE);	}	VM_OBJECT_UNLOCK(tobj);	error = uiomove_fromphys(&m, offset, tlen, uio);	VM_OBJECT_LOCK(tobj);out:	vm_page_lock(m);	vm_page_unwire(m, TRUE);	vm_page_unlock(m);	vm_page_wakeup(m);	vm_object_pip_subtract(tobj, 1);	VM_OBJECT_UNLOCK(tobj);	return (error);}

/* * Same as above, but forces the page to be detached from the object * and go into free pool. */voidsf_ext_free_nocache(void *arg1, void *arg2){	struct sf_buf *sf = arg1;	struct sendfile_sync *sfs = arg2;	vm_page_t pg = sf_buf_page(sf);	sf_buf_free(sf);	vm_page_lock(pg);	if (vm_page_unwire(pg, PQ_NONE)) {		vm_object_t obj;		/* Try to free the page, but only if it is cheap to. */		if ((obj = pg->object) == NULL)			vm_page_free(pg);		else if (!vm_page_xbusied(pg) && VM_OBJECT_TRYWLOCK(obj)) {			vm_page_free(pg);			VM_OBJECT_WUNLOCK(obj);		} else			vm_page_deactivate(pg);	}	vm_page_unlock(pg);	if (sfs != NULL) {		mtx_lock(&sfs->mtx);		KASSERT(sfs->count > 0, ("Sendfile sync botchup count == 0"));		if (--sfs->count == 0)			cv_signal(&sfs->cv);		mtx_unlock(&sfs->mtx);	}}

/* * Detach mapped page and release resources back to the system.  Called * by mbuf(9) code when last reference to a page is freed. */voidsf_ext_free(void *arg1, void *arg2){	struct sf_buf *sf = arg1;	struct sendfile_sync *sfs = arg2;	vm_page_t pg = sf_buf_page(sf);	sf_buf_free(sf);	vm_page_lock(pg);	/*	 * Check for the object going away on us. This can	 * happen since we don't hold a reference to it.	 * If so, we're responsible for freeing the page.	 */	if (vm_page_unwire(pg, PQ_INACTIVE) && pg->object == NULL)		vm_page_free(pg);	vm_page_unlock(pg);	if (sfs != NULL) {		mtx_lock(&sfs->mtx);		KASSERT(sfs->count > 0, ("Sendfile sync botchup count == 0"));		if (--sfs->count == 0)			cv_signal(&sfs->cv);		mtx_unlock(&sfs->mtx);	}}

/* * Fill as many pages as vm_fault has allocated for us. */static intphys_pager_getpages(vm_object_t object, vm_page_t *m, int count, int reqpage){	int i;	VM_OBJECT_ASSERT_WLOCKED(object);	for (i = 0; i < count; i++) {		if (m[i]->valid == 0) {			if ((m[i]->flags & PG_ZERO) == 0)				pmap_zero_page(m[i]);			m[i]->valid = VM_PAGE_BITS_ALL;		}		KASSERT(m[i]->valid == VM_PAGE_BITS_ALL,		    ("phys_pager_getpages: partially valid page %p", m[i]));		KASSERT(m[i]->dirty == 0,		    ("phys_pager_getpages: dirty page %p", m[i]));		/* The requested page must remain busy, the others not. */		if (i == reqpage) {			vm_page_lock(m[i]);			vm_page_flash(m[i]);			vm_page_unlock(m[i]);		} else			vm_page_xunbusy(m[i]);	}	return (VM_PAGER_OK);}

/* * Return the requested word from the user-space address. * Returns 0 if it isn't mapped.  (For what we're using it * for, if the actual value is 0, that's equivalent to that.) */static caddr_tGET_WORD(pmap_t map, caddr_t virtual_addr){	caddr_t retval = 0;	vm_page_t page;	int err;	caddr_t old_fault;		page = pmap_extract_and_hold(map, (vm_offset_t)virtual_addr, VM_PROT_READ);	if (page == 0) {		return 0;	}	// I do this because copyin/copyout aren't re-entrant.	old_fault = curpcb->pcb_onfault;	err = copyin(virtual_addr, &retval, sizeof(retval));	curpcb->pcb_onfault = old_fault;	if (err != 0) {#if SAMPLE_DEBUG		printf("%s(%d):  copyin(%p, %p, %zd)  failed: %d/n", __FUNCTION__, __LINE__, (void*)virtual_addr, &retval, sizeof(retval), err);#endif		retval = 0;	}	vm_page_lock(page);	vm_page_unhold(page);	vm_page_unlock(page);	return retval;}

voidvm_gpa_release(void *cookie){	vm_page_t m = cookie;	vm_page_lock(m);	vm_page_unhold(m);	vm_page_unlock(m);}

/* * Release a page we've previously wired. */static voidzbuf_page_free(vm_page_t pp){	vm_page_lock(pp);	vm_page_unwire(pp, 0);	if (pp->wire_count == 0 && pp->object == NULL)		vm_page_free(pp);	vm_page_unlock(pp);}

/* * Identify the physical page mapped at the given kernel virtual * address.  Insert this physical page into the given address space at * the given virtual address, replacing the physical page, if any, * that already exists there. */static intvm_pgmoveco(vm_map_t mapa, vm_offset_t kaddr, vm_offset_t uaddr){    vm_map_t map = mapa;    vm_page_t kern_pg, user_pg;    vm_object_t uobject;    vm_map_entry_t entry;    vm_pindex_t upindex;    vm_prot_t prot;    boolean_t wired;    KASSERT((uaddr & PAGE_MASK) == 0,            ("vm_pgmoveco: uaddr is not page aligned"));    /*     * Herein the physical page is validated and dirtied.  It is     * unwired in sf_buf_mext().     */    kern_pg = PHYS_TO_VM_PAGE(vtophys(kaddr));    kern_pg->valid = VM_PAGE_BITS_ALL;    KASSERT(kern_pg->queue == PQ_NONE && kern_pg->wire_count == 1,            ("vm_pgmoveco: kern_pg is not correctly wired"));    if ((vm_map_lookup(&map, uaddr,                       VM_PROT_WRITE, &entry, &uobject,                       &upindex, &prot, &wired)) != KERN_SUCCESS) {        return(EFAULT);    }    VM_OBJECT_LOCK(uobject);retry:    if ((user_pg = vm_page_lookup(uobject, upindex)) != NULL) {        if (vm_page_sleep_if_busy(user_pg, TRUE, "vm_pgmoveco"))            goto retry;        vm_page_lock(user_pg);        pmap_remove_all(user_pg);        vm_page_free(user_pg);        vm_page_unlock(user_pg);    } else {        /*         * Even if a physical page does not exist in the         * object chain's first object, a physical page from a         * backing object may be mapped read only.         */        if (uobject->backing_object != NULL)            pmap_remove(map->pmap, uaddr, uaddr + PAGE_SIZE);    }    vm_page_insert(kern_pg, uobject, upindex);    vm_page_dirty(kern_pg);    VM_OBJECT_UNLOCK(uobject);    vm_map_lookup_done(map, entry);    return(KERN_SUCCESS);}

static voidunwire_ddp_buffer(struct ddp_buffer *db){	int i;	vm_page_t p;	for (i = 0; i < db->npages; i++) {		p = db->pages[i];		vm_page_lock(p);		vm_page_unwire(p, PQ_INACTIVE);		vm_page_unlock(p);	}}

voidexec_unmap_first_page(struct image_params *imgp){	vm_page_t m;	if (imgp->firstpage != NULL) {		m = sf_buf_page(imgp->firstpage);		sf_buf_free(imgp->firstpage);		imgp->firstpage = NULL;		vm_page_lock(m);		vm_page_unhold(m);		vm_page_unlock(m);	}}

voidcdev_pager_free_page(vm_object_t object, vm_page_t m){	VM_OBJECT_ASSERT_WLOCKED(object);	if (object->type == OBJT_MGTDEVICE) {		KASSERT((m->oflags & VPO_UNMANAGED) == 0, ("unmanaged %p", m));		pmap_remove_all(m);		vm_page_lock(m);		vm_page_remove(m);		vm_page_unlock(m);	} else if (object->type == OBJT_DEVICE)		dev_pager_free_page(object, m);}

static voidwire_ddp_buffer(struct ddp_buffer *db){	int i;	vm_page_t p;	for (i = 0; i < db->npages; i++) {		p = db->pages[i];		vm_page_lock(p);		vm_page_wire(p);		vm_page_unhold(p);		vm_page_unlock(p);	}}

/* * Speed up the reclamation of up to "distance" pages that precede the * faulting pindex within the first object of the shadow chain. */static voidvm_fault_cache_behind(const struct faultstate *fs, int distance){	vm_object_t first_object, object;	vm_page_t m, m_prev;	vm_pindex_t pindex;	object = fs->object;	VM_OBJECT_LOCK_ASSERT(object, MA_OWNED);	first_object = fs->first_object;	if (first_object != object) {		if (!VM_OBJECT_TRYLOCK(first_object)) {			VM_OBJECT_UNLOCK(object);			VM_OBJECT_LOCK(first_object);			VM_OBJECT_LOCK(object);		}	}	if (first_object->type != OBJT_DEVICE &&	    first_object->type != OBJT_PHYS && first_object->type != OBJT_SG) {		if (fs->first_pindex < distance)			pindex = 0;		else			pindex = fs->first_pindex - distance;		if (pindex < OFF_TO_IDX(fs->entry->offset))			pindex = OFF_TO_IDX(fs->entry->offset);		m = first_object != object ? fs->first_m : fs->m;		KASSERT((m->oflags & VPO_BUSY) != 0,		    ("vm_fault_cache_behind: page %p is not busy", m));		m_prev = vm_page_prev(m);		while ((m = m_prev) != NULL && m->pindex >= pindex &&		    m->valid == VM_PAGE_BITS_ALL) {			m_prev = vm_page_prev(m);			if (m->busy != 0 || (m->oflags & VPO_BUSY) != 0)				continue;			vm_page_lock(m);			if (m->hold_count == 0 && m->wire_count == 0) {				pmap_remove_all(m);				vm_page_aflag_clear(m, PGA_REFERENCED);				if (m->dirty != 0)					vm_page_deactivate(m);				else					vm_page_cache(m);			}			vm_page_unlock(m);		}	}	if (first_object != object)		VM_OBJECT_UNLOCK(first_object);}

/* * Given a user pointer to a page of user memory, return an sf_buf for the * page.  Because we may be requesting quite a few sf_bufs, prefer failure to * deadlock and use SFB_NOWAIT. */static struct sf_buf *zbuf_sfbuf_get(struct vm_map *map, vm_offset_t uaddr){	struct sf_buf *sf;	vm_page_t pp;	if (vm_fault_quick_hold_pages(map, uaddr, PAGE_SIZE, VM_PROT_READ |	    VM_PROT_WRITE, &pp, 1) < 0)		return (NULL);	vm_page_lock(pp);	vm_page_wire(pp);	vm_page_unhold(pp);	vm_page_unlock(pp);	sf = sf_buf_alloc(pp, SFB_NOWAIT);	if (sf == NULL) {		zbuf_page_free(pp);		return (NULL);	}	return (sf);}

static intprivcmd_pg_fault(vm_object_t object, vm_ooffset_t offset,    int prot, vm_page_t *mres){	struct privcmd_map *map = object->handle;	vm_pindex_t pidx;	vm_page_t page, oldm;	if (map->mapped != true)		return (VM_PAGER_FAIL);	pidx = OFF_TO_IDX(offset);	if (pidx >= map->size || BIT_ISSET(map->size, pidx, map->err))		return (VM_PAGER_FAIL);	page = PHYS_TO_VM_PAGE(map->phys_base_addr + offset);	if (page == NULL)		return (VM_PAGER_FAIL);	KASSERT((page->flags & PG_FICTITIOUS) != 0,	    ("not fictitious %p", page));	KASSERT(page->wire_count == 1, ("wire_count not 1 %p", page));	KASSERT(vm_page_busied(page) == 0, ("page %p is busy", page));	if (*mres != NULL) {		oldm = *mres;		vm_page_lock(oldm);		vm_page_free(oldm);		vm_page_unlock(oldm);		*mres = NULL;	}	vm_page_insert(page, object, pidx);	page->valid = VM_PAGE_BITS_ALL;	vm_page_xbusy(page);	*mres = page;	return (VM_PAGER_OK);}

static intsg_pager_getpages(vm_object_t object, vm_page_t *m, int count, int reqpage){	struct sglist *sg;	vm_page_t m_paddr, page;	vm_pindex_t offset;	vm_paddr_t paddr;	vm_memattr_t memattr;	size_t space;	int i;	VM_OBJECT_ASSERT_WLOCKED(object);	sg = object->handle;	memattr = object->memattr;	VM_OBJECT_WUNLOCK(object);	offset = m[reqpage]->pindex;	/*	 * Lookup the physical address of the requested page.  An initial	 * value of '1' instead of '0' is used so we can assert that the	 * page is found since '0' can be a valid page-aligned physical	 * address.	 */	space = 0;	paddr = 1;	for (i = 0; i < sg->sg_nseg; i++) {		if (space + sg->sg_segs[i].ss_len <= (offset * PAGE_SIZE)) {			space += sg->sg_segs[i].ss_len;			continue;		}		paddr = sg->sg_segs[i].ss_paddr + offset * PAGE_SIZE - space;		break;	}	KASSERT(paddr != 1, ("invalid SG page index"));	/* If "paddr" is a real page, perform a sanity check on "memattr". */	if ((m_paddr = vm_phys_paddr_to_vm_page(paddr)) != NULL &&	    pmap_page_get_memattr(m_paddr) != memattr) {		memattr = pmap_page_get_memattr(m_paddr);		printf(	    "WARNING: A device driver has set /"memattr/" inconsistently./n");	}	/* Return a fake page for the requested page. */	KASSERT(!(m[reqpage]->flags & PG_FICTITIOUS),	    ("backing page for SG is fake"));	/* Construct a new fake page. */	page = vm_page_getfake(paddr, memattr);	VM_OBJECT_WLOCK(object);	TAILQ_INSERT_TAIL(&object->un_pager.sgp.sgp_pglist, page, plinks.q);	/* Free the original pages and insert this fake page into the object. */	for (i = 0; i < count; i++) {		if (i == reqpage &&		    vm_page_replace(page, object, offset) != m[i])			panic("sg_pager_getpages: invalid place replacement");		vm_page_lock(m[i]);		vm_page_free(m[i]);		vm_page_unlock(m[i]);	}	m[reqpage] = page;	page->valid = VM_PAGE_BITS_ALL;	return (VM_PAGER_OK);}