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

/* * 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);	}}

static int rtR0MemObjFreeBSDPhysAllocHelper(vm_object_t pObject, u_long cPages,                                            vm_paddr_t VmPhysAddrHigh, u_long uAlignment,                                            bool fContiguous, bool fWire, int rcNoMem){    if (fContiguous)    {        if (rtR0MemObjFreeBSDContigPhysAllocHelper(pObject, 0, cPages, VmPhysAddrHigh,                                                   uAlignment, fWire) != NULL)            return VINF_SUCCESS;        return rcNoMem;    }    for (vm_pindex_t iPage = 0; iPage < cPages; iPage++)    {        vm_page_t pPage = rtR0MemObjFreeBSDContigPhysAllocHelper(pObject, iPage, 1, VmPhysAddrHigh,                                                                 uAlignment, fWire);        if (!pPage)        {            /* Free all allocated pages */            VM_OBJECT_LOCK(pObject);            while (iPage-- > 0)            {                pPage = vm_page_lookup(pObject, iPage);                vm_page_lock_queues();                if (fWire)                    vm_page_unwire(pPage, 0);                vm_page_free(pPage);                vm_page_unlock_queues();            }            VM_OBJECT_UNLOCK(pObject);            return rcNoMem;        }    }    return VINF_SUCCESS;}

/* *	kmem_unback: * *	Unmap and free the physical pages underlying the specified virtual *	address range. * *	A physical page must exist within the specified object at each index *	that is being unmapped. */static int_kmem_unback(vm_object_t object, vm_offset_t addr, vm_size_t size){	vm_page_t m, next;	vm_offset_t end, offset;	int domain;	KASSERT(object == kernel_object,	    ("kmem_unback: only supports kernel object."));	if (size == 0)		return (0);	pmap_remove(kernel_pmap, addr, addr + size);	offset = addr - VM_MIN_KERNEL_ADDRESS;	end = offset + size;	VM_OBJECT_WLOCK(object);	m = vm_page_lookup(object, atop(offset)); 	domain = vm_phys_domain(m);	for (; offset < end; offset += PAGE_SIZE, m = next) {		next = vm_page_next(m);		vm_page_unwire(m, PQ_NONE);		vm_page_free(m);	}	VM_OBJECT_WUNLOCK(object);	return (domain);}

vm_page_tshmem_read_mapping_page(vm_object_t object, vm_pindex_t pindex){	vm_page_t m;	int rv;	VM_OBJECT_LOCK_ASSERT_OWNED(object);	m = vm_page_grab(object, pindex, VM_ALLOC_NORMAL | VM_ALLOC_RETRY);	if (m->valid != VM_PAGE_BITS_ALL) {		if (vm_pager_has_page(object, pindex)) {			rv = vm_pager_get_page(object, &m, 1);			m = vm_page_lookup(object, pindex);			if (m == NULL)				return ERR_PTR(-ENOMEM);			if (rv != VM_PAGER_OK) {				vm_page_free(m);				return ERR_PTR(-ENOMEM);			}		} else {			pmap_zero_page(VM_PAGE_TO_PHYS(m));			m->valid = VM_PAGE_BITS_ALL;			m->dirty = 0;		}	}	vm_page_wire(m);	vm_page_wakeup(m);	return (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);}

/* * Release a page busied for a getpages operation.  The page may have become * wired (typically due to being used by the buffer cache) or otherwise been * soft-busied and cannot be freed in that case.  A held page can still be * freed. */voidvnode_pager_freepage(vm_page_t m){	if (m->busy || m->wire_count || (m->flags & PG_NEED_COMMIT)) {		vm_page_activate(m);		vm_page_wakeup(m);	} else {		vm_page_free(m);	}}

voiduma_small_free(void *mem, int size, u_int8_t flags){	vm_page_t m;	m = PHYS_TO_VM_PAGE(TLB_DIRECT_TO_PHYS((vm_offset_t)mem));	m->wire_count--;	vm_page_free(m);	atomic_subtract_int(&cnt.v_wire_count, 1);}

/* * 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_queues();		pmap_remove_all(user_pg);		vm_page_free(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_lock_queues();	}	vm_page_insert(kern_pg, uobject, upindex);	vm_page_dirty(kern_pg);	vm_page_unlock_queues();	VM_OBJECT_UNLOCK(uobject);	vm_map_lookup_done(map, entry);	return(KERN_SUCCESS);}

voiduma_small_free(void *mem, vm_size_t size, u_int8_t flags){	vm_page_t m;	vm_paddr_t pa;	pa = DMAP_TO_PHYS((vm_offset_t)mem);	m = PHYS_TO_VM_PAGE(pa);	m->wire_count--;	vm_page_free(m);	atomic_subtract_int(&vm_cnt.v_wire_count, 1);}

static voidos_kmem_free(vm_page_t page) // IN{   os_state *state = &global_state;   os_pmap *pmap = &state->pmap;   if ( !vm_page_lookup(state->vmobject, page->pindex) ) {      return;   }   os_pmap_putindex(pmap, page->pindex);   vm_page_free(page);}

voiduma_small_free(void *mem, vm_size_t size, u_int8_t flags){	vm_page_t m;	if (!hw_direct_map)		pmap_remove(kernel_pmap,(vm_offset_t)mem,		    (vm_offset_t)mem + PAGE_SIZE);	m = PHYS_TO_VM_PAGE((vm_offset_t)mem);	m->wire_count--;	vm_page_free(m);	atomic_subtract_int(&vm_cnt.v_wire_count, 1);	atomic_subtract_int(&hw_uma_mdpages, 1);}

intreaddir(ipc_port_t file, struct fs_directory_entry *de, off_t *offp){	struct ipc_request_message req;	struct ipc_response_message resp;	struct fs_directory_read_request fsreq;	struct fs_directory_read_response *fsresp;	int error;	memset(&req, 0, sizeof req);	memset(&resp, 0, sizeof resp);	memset(&fsreq, 0, sizeof fsreq);	fsreq.offset = *offp;	req.src = IPC_PORT_UNKNOWN;	req.dst = file;	req.msg = FS_DIRECTORY_MSG_READ;	req.param = 0;	req.data = &fsreq;	req.datalen = sizeof fsreq;	resp.data = true;	error = ipc_request(&req, &resp);	if (error != 0)		return (error);	if (resp.error != 0)		return (resp.error);	/* End of directory.  */	if (resp.param == 0) {		de->name[0] = '/0';		*offp = 0;		return (0);	}	/* XXX assert cnt == 1?  */	fsresp = resp.page;	strlcpy(de->name, fsresp->entry.name, sizeof de->name);	*offp = fsresp->next;	vm_page_free(resp.page);	return (0);}

static intnetmap_dev_pager_fault(vm_object_t object, vm_ooffset_t offset,                       int prot, vm_page_t *mres){    struct netmap_vm_handle_t *vmh = object->handle;    struct netmap_priv_d *priv = vmh->priv;    vm_paddr_t paddr;    vm_page_t page;    vm_memattr_t memattr;    vm_pindex_t pidx;    ND("object %p offset %jd prot %d mres %p",       object, (intmax_t)offset, prot, mres);    memattr = object->memattr;    pidx = OFF_TO_IDX(offset);    paddr = netmap_mem_ofstophys(priv->np_mref, offset);    if (paddr == 0)        return VM_PAGER_FAIL;    if (((*mres)->flags & PG_FICTITIOUS) != 0) {        /*         * If the passed in result page is a fake page, update it with         * the new physical address.         */        page = *mres;        vm_page_updatefake(page, paddr, memattr);    } else {        /*         * Replace the passed in reqpage page with our own fake page and         * free up the all of the original pages.         */#ifndef VM_OBJECT_WUNLOCK	/* FreeBSD < 10.x */#define VM_OBJECT_WUNLOCK VM_OBJECT_UNLOCK#define VM_OBJECT_WLOCK	VM_OBJECT_LOCK#endif /* VM_OBJECT_WUNLOCK */        VM_OBJECT_WUNLOCK(object);        page = vm_page_getfake(paddr, memattr);        VM_OBJECT_WLOCK(object);        vm_page_free(*mres);        *mres = page;        vm_page_insert(page, object, pidx);    }    page->valid = VM_PAGE_BITS_ALL;    return (VM_PAGER_OK);}

static int old_dev_pager_fault(vm_object_t object, vm_ooffset_t offset,    int prot, vm_page_t *mres){	vm_paddr_t paddr;	vm_page_t page;	vm_offset_t pidx = OFF_TO_IDX(offset);	cdev_t dev;	page = *mres;	dev = object->handle;	paddr = pmap_phys_address(		    dev_dmmap(dev, offset, prot, NULL));	KASSERT(paddr != -1,("dev_pager_getpage: map function returns error"));	KKASSERT(object->type == OBJT_DEVICE);	if (page->flags & PG_FICTITIOUS) {		/*		 * If the passed in reqpage page is already a fake page,		 * update it with the new physical address.		 */		page->phys_addr = paddr;		page->valid = VM_PAGE_BITS_ALL;	} else {		/*		 * Replace the passed in reqpage page with our own fake page		 * and free up all the original pages.		 */		page = dev_pager_getfake(paddr, object->memattr);		TAILQ_INSERT_TAIL(&object->un_pager.devp.devp_pglist,				  page, pageq);		vm_object_hold(object);		vm_page_free(*mres);		if (vm_page_insert(page, object, pidx) == FALSE) {			panic("dev_pager_getpage: page (%p,%016jx) exists",			      object, (uintmax_t)pidx);		}		vm_object_drop(object);	}	return (VM_PAGER_OK);}

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);}

//.........这里部分代码省略.........		goto out_unlock;	}	ret = ttm_mem_io_reserve_vm(bo);	if (unlikely(ret != 0)) {		retval = VM_PAGER_ERROR;		goto out_io_unlock;	}	/*	 * Strictly, we're not allowed to modify vma->vm_page_prot here,	 * since the mmap_sem is only held in read mode. However, we	 * modify only the caching bits of vma->vm_page_prot and	 * consider those bits protected by	 * the bo->mutex, as we should be the only writers.	 * There shouldn't really be any readers of these bits except	 * within vm_insert_mixed()? fork?	 *	 * TODO: Add a list of vmas to the bo, and change the	 * vma->vm_page_prot when the object changes caching policy, with	 * the correct locks held.	 */	if (!bo->mem.bus.is_iomem) {		/* Allocate all page at once, most common usage */		ttm = bo->ttm;		if (ttm->bdev->driver->ttm_tt_populate(ttm)) {			retval = VM_PAGER_ERROR;			goto out_io_unlock;		}	}	if (bo->mem.bus.is_iomem) {		m = PHYS_TO_VM_PAGE(bo->mem.bus.base + bo->mem.bus.offset +		    offset);		KASSERT((m->flags & PG_FICTITIOUS) != 0,		    ("physical address %#jx not fictitious",		    (uintmax_t)(bo->mem.bus.base + bo->mem.bus.offset		    + offset)));		pmap_page_set_memattr(m, ttm_io_prot(bo->mem.placement));	} else {		ttm = bo->ttm;		m = ttm->pages[OFF_TO_IDX(offset)];		if (unlikely(!m)) {			retval = VM_PAGER_ERROR;			goto out_io_unlock;		}		pmap_page_set_memattr(m,		    (bo->mem.placement & TTM_PL_FLAG_CACHED) ?		    VM_MEMATTR_WRITE_BACK : ttm_io_prot(bo->mem.placement));	}	VM_OBJECT_WLOCK(vm_obj);	if (vm_page_busied(m)) {		vm_page_lock(m);		VM_OBJECT_WUNLOCK(vm_obj);		vm_page_busy_sleep(m, "ttmpbs");		VM_OBJECT_WLOCK(vm_obj);		ttm_mem_io_unlock(man);		ttm_bo_unreserve(bo);		goto retry;	}	m1 = vm_page_lookup(vm_obj, OFF_TO_IDX(offset));	if (m1 == NULL) {		if (vm_page_insert(m, vm_obj, OFF_TO_IDX(offset))) {			VM_OBJECT_WUNLOCK(vm_obj);			VM_WAIT;			VM_OBJECT_WLOCK(vm_obj);			ttm_mem_io_unlock(man);			ttm_bo_unreserve(bo);			goto retry;		}	} else {		KASSERT(m == m1,		    ("inconsistent insert bo %p m %p m1 %p offset %jx",		    bo, m, m1, (uintmax_t)offset));	}	m->valid = VM_PAGE_BITS_ALL;	*mres = m;	vm_page_xbusy(m);	if (oldm != NULL) {		vm_page_lock(oldm);		vm_page_free(oldm);		vm_page_unlock(oldm);	}out_io_unlock1:	ttm_mem_io_unlock(man);out_unlock1:	ttm_bo_unreserve(bo);	vm_object_pip_wakeup(vm_obj);	return (retval);out_io_unlock:	VM_OBJECT_WLOCK(vm_obj);	goto out_io_unlock1;out_unlock:	VM_OBJECT_WLOCK(vm_obj);	goto out_unlock1;}

intexec_map_first_page(struct image_params *imgp){	int rv, i, after, initial_pagein;	vm_page_t ma[VM_INITIAL_PAGEIN];	vm_object_t object;	if (imgp->firstpage != NULL)		exec_unmap_first_page(imgp);	object = imgp->vp->v_object;	if (object == NULL)		return (EACCES);	VM_OBJECT_WLOCK(object);#if VM_NRESERVLEVEL > 0	vm_object_color(object, 0);#endif	ma[0] = vm_page_grab(object, 0, VM_ALLOC_NORMAL | VM_ALLOC_NOBUSY);	if (ma[0]->valid != VM_PAGE_BITS_ALL) {		vm_page_xbusy(ma[0]);		if (!vm_pager_has_page(object, 0, NULL, &after)) {			vm_page_lock(ma[0]);			vm_page_free(ma[0]);			vm_page_unlock(ma[0]);			VM_OBJECT_WUNLOCK(object);			return (EIO);		}		initial_pagein = min(after, VM_INITIAL_PAGEIN);		KASSERT(initial_pagein <= object->size,		    ("%s: initial_pagein %d object->size %ju",		    __func__, initial_pagein, (uintmax_t )object->size));		for (i = 1; i < initial_pagein; i++) {			if ((ma[i] = vm_page_next(ma[i - 1])) != NULL) {				if (ma[i]->valid)					break;				if (!vm_page_tryxbusy(ma[i]))					break;			} else {				ma[i] = vm_page_alloc(object, i,				    VM_ALLOC_NORMAL);				if (ma[i] == NULL)					break;			}		}		initial_pagein = i;		rv = vm_pager_get_pages(object, ma, initial_pagein, NULL, NULL);		if (rv != VM_PAGER_OK) {			for (i = 0; i < initial_pagein; i++) {				vm_page_lock(ma[i]);				vm_page_free(ma[i]);				vm_page_unlock(ma[i]);			}			VM_OBJECT_WUNLOCK(object);			return (EIO);		}		vm_page_xunbusy(ma[0]);		for (i = 1; i < initial_pagein; i++)			vm_page_readahead_finish(ma[i]);	}	vm_page_lock(ma[0]);	vm_page_hold(ma[0]);	vm_page_activate(ma[0]);	vm_page_unlock(ma[0]);	VM_OBJECT_WUNLOCK(object);	imgp->firstpage = sf_buf_alloc(ma[0], 0);	imgp->image_header = (char *)sf_buf_kva(imgp->firstpage);	return (0);}

static intshm_dotruncate(struct shmfd *shmfd, off_t length){	vm_object_t object;	vm_page_t m, ma[1];	vm_pindex_t idx, nobjsize;	vm_ooffset_t delta;	int base, rv;	object = shmfd->shm_object;	VM_OBJECT_LOCK(object);	if (length == shmfd->shm_size) {		VM_OBJECT_UNLOCK(object);		return (0);	}	nobjsize = OFF_TO_IDX(length + PAGE_MASK);	/* Are we shrinking?  If so, trim the end. */	if (length < shmfd->shm_size) {		/*		 * Disallow any requests to shrink the size if this		 * object is mapped into the kernel.		 */		if (shmfd->shm_kmappings > 0) {			VM_OBJECT_UNLOCK(object);			return (EBUSY);		}		/*		 * Zero the truncated part of the last page.		 */		base = length & PAGE_MASK;		if (base != 0) {			idx = OFF_TO_IDX(length);retry:			m = vm_page_lookup(object, idx);			if (m != NULL) {				if ((m->oflags & VPO_BUSY) != 0 ||				    m->busy != 0) {					vm_page_sleep(m, "shmtrc");					goto retry;				}			} else if (vm_pager_has_page(object, idx, NULL, NULL)) {				m = vm_page_alloc(object, idx, VM_ALLOC_NORMAL);				if (m == NULL) {					VM_OBJECT_UNLOCK(object);					VM_WAIT;					VM_OBJECT_LOCK(object);					goto retry;				} else if (m->valid != VM_PAGE_BITS_ALL) {					ma[0] = m;					rv = vm_pager_get_pages(object, ma, 1,					    0);					m = vm_page_lookup(object, idx);				} else					/* A cached page was reactivated. */					rv = VM_PAGER_OK;				vm_page_lock(m);				if (rv == VM_PAGER_OK) {					vm_page_deactivate(m);					vm_page_unlock(m);					vm_page_wakeup(m);				} else {					vm_page_free(m);					vm_page_unlock(m);					VM_OBJECT_UNLOCK(object);					return (EIO);				}			}			if (m != NULL) {				pmap_zero_page_area(m, base, PAGE_SIZE - base);				KASSERT(m->valid == VM_PAGE_BITS_ALL,				    ("shm_dotruncate: page %p is invalid", m));				vm_page_dirty(m);				vm_pager_page_unswapped(m);			}		}		delta = ptoa(object->size - nobjsize);		/* Toss in memory pages. */		if (nobjsize < object->size)			vm_object_page_remove(object, nobjsize, object->size,			    0);		/* Toss pages from swap. */		if (object->type == OBJT_SWAP)			swap_pager_freespace(object, nobjsize, delta);		/* Free the swap accounted for shm */		swap_release_by_cred(delta, object->cred);		object->charge -= delta;	} else {		/* Attempt to reserve the swap */		delta = ptoa(nobjsize - object->size);		if (!swap_reserve_by_cred(delta, object->cred)) {			VM_OBJECT_UNLOCK(object);			return (ENOMEM);		}		object->charge += delta;	}//.........这里部分代码省略.........