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

voiddrm_gem_object_release(struct drm_gem_object *obj){    /*     * obj->vm_obj can be NULL for private gem objects.     */    vm_object_deallocate(obj->vm_obj);}

/* * MPSAFE */static vm_object_tphys_pager_alloc(void *handle, vm_ooffset_t size, vm_prot_t prot,    vm_ooffset_t foff, struct ucred *cred){	vm_object_t object, object1;	vm_pindex_t pindex;	/*	 * Offset should be page aligned.	 */	if (foff & PAGE_MASK)		return (NULL);	pindex = OFF_TO_IDX(foff + PAGE_MASK + size);	if (handle != NULL) {		mtx_lock(&phys_pager_mtx);		/*		 * Look up pager, creating as necessary.		 */		object1 = NULL;		object = vm_pager_object_lookup(&phys_pager_object_list, handle);		if (object == NULL) {			/*			 * Allocate object and associate it with the pager.			 */			mtx_unlock(&phys_pager_mtx);			object1 = vm_object_allocate(OBJT_PHYS, pindex);			mtx_lock(&phys_pager_mtx);			object = vm_pager_object_lookup(&phys_pager_object_list,			    handle);			if (object != NULL) {				/*				 * We raced with other thread while				 * allocating object.				 */				if (pindex > object->size)					object->size = pindex;			} else {				object = object1;				object1 = NULL;				object->handle = handle;				TAILQ_INSERT_TAIL(&phys_pager_object_list, object,				    pager_object_list);			}		} else {			if (pindex > object->size)				object->size = pindex;		}		mtx_unlock(&phys_pager_mtx);		vm_object_deallocate(object1);	} else {		object = vm_object_allocate(OBJT_PHYS, pindex);	}	return (object);}

static voidshm_drop(struct shmfd *shmfd){	if (refcount_release(&shmfd->shm_refs)) {#ifdef MAC		mac_posixshm_destroy(shmfd);#endif		vm_object_deallocate(shmfd->shm_object);		free(shmfd, M_SHMFD);	}}

/* * Helper routines to allow the backing object of a shared memory file * descriptor to be mapped in the kernel. */intshm_map(struct file *fp, size_t size, off_t offset, void **memp){	struct shmfd *shmfd;	vm_offset_t kva, ofs;	vm_object_t obj;	int rv;	if (fp->f_type != DTYPE_SHM)		return (EINVAL);	shmfd = fp->f_data;	obj = shmfd->shm_object;	VM_OBJECT_LOCK(obj);	/*	 * XXXRW: This validation is probably insufficient, and subject to	 * sign errors.  It should be fixed.	 */	if (offset >= shmfd->shm_size ||	    offset + size > round_page(shmfd->shm_size)) {		VM_OBJECT_UNLOCK(obj);		return (EINVAL);	}	shmfd->shm_kmappings++;	vm_object_reference_locked(obj);	VM_OBJECT_UNLOCK(obj);	/* Map the object into the kernel_map and wire it. */	kva = vm_map_min(kernel_map);	ofs = offset & PAGE_MASK;	offset = trunc_page(offset);	size = round_page(size + ofs);	rv = vm_map_find(kernel_map, obj, offset, &kva, size,	    VMFS_ALIGNED_SPACE, VM_PROT_READ | VM_PROT_WRITE,	    VM_PROT_READ | VM_PROT_WRITE, 0);	if (rv == KERN_SUCCESS) {		rv = vm_map_wire(kernel_map, kva, kva + size,		    VM_MAP_WIRE_SYSTEM | VM_MAP_WIRE_NOHOLES);		if (rv == KERN_SUCCESS) {			*memp = (void *)(kva + ofs);			return (0);		}		vm_map_remove(kernel_map, kva, kva + size);	} else		vm_object_deallocate(obj);	/* On failure, drop our mapping reference. */	VM_OBJECT_LOCK(obj);	shmfd->shm_kmappings--;	VM_OBJECT_UNLOCK(obj);	return (vm_mmap_to_errno(rv));}

DECLHIDDEN(int) rtR0MemAllocEx(size_t cb, uint32_t fFlags, PRTMEMHDR *ppHdr){    size_t      cbAllocated = cb;    PRTMEMHDR   pHdr        = NULL;#ifdef RT_ARCH_AMD64    /*     * Things are a bit more complicated on AMD64 for executable memory     * because we need to be in the ~2GB..~0 range for code.     */    if (fFlags & RTMEMHDR_FLAG_EXEC)    {        if (fFlags & RTMEMHDR_FLAG_ANY_CTX)            return VERR_NOT_SUPPORTED;# ifdef USE_KMEM_ALLOC_PROT        pHdr = (PRTMEMHDR)kmem_alloc_prot(kernel_map, cb + sizeof(*pHdr),                                          VM_PROT_ALL, VM_PROT_ALL, KERNBASE);# else        vm_object_t pVmObject = NULL;        vm_offset_t Addr = KERNBASE;        cbAllocated = RT_ALIGN_Z(cb + sizeof(*pHdr), PAGE_SIZE);        pVmObject = vm_object_allocate(OBJT_DEFAULT, cbAllocated >> PAGE_SHIFT);        if (!pVmObject)            return VERR_NO_EXEC_MEMORY;        /* Addr contains a start address vm_map_find will start searching for suitable space at. */        int rc = vm_map_find(kernel_map, pVmObject, 0, &Addr,                             cbAllocated, TRUE, VM_PROT_ALL, VM_PROT_ALL, 0);        if (rc == KERN_SUCCESS)        {            rc = vm_map_wire(kernel_map, Addr, Addr + cbAllocated,                             VM_MAP_WIRE_SYSTEM | VM_MAP_WIRE_NOHOLES);            if (rc == KERN_SUCCESS)            {                pHdr = (PRTMEMHDR)Addr;                if (fFlags & RTMEMHDR_FLAG_ZEROED)                    bzero(pHdr, cbAllocated);            }            else                vm_map_remove(kernel_map,                              Addr,                              Addr + cbAllocated);        }        else            vm_object_deallocate(pVmObject);# endif    }    else#endif    {

static int rtR0MemObjFreeBSDAllocPhysPages(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJTYPE enmType,                                           size_t cb,                                           RTHCPHYS PhysHighest, size_t uAlignment,                                           bool fContiguous, int rcNoMem){    uint32_t   cPages = atop(cb);    vm_paddr_t VmPhysAddrHigh;    /* create the object. */    PRTR0MEMOBJFREEBSD pMemFreeBSD = (PRTR0MEMOBJFREEBSD)rtR0MemObjNew(sizeof(*pMemFreeBSD),                                                                       enmType, NULL, cb);    if (!pMemFreeBSD)        return VERR_NO_MEMORY;    pMemFreeBSD->pObject = vm_object_allocate(OBJT_PHYS, atop(cb));    if (PhysHighest != NIL_RTHCPHYS)        VmPhysAddrHigh = PhysHighest;    else        VmPhysAddrHigh = ~(vm_paddr_t)0;    int rc = rtR0MemObjFreeBSDPhysAllocHelper(pMemFreeBSD->pObject, cPages, VmPhysAddrHigh,                                              uAlignment, fContiguous, true, rcNoMem);    if (RT_SUCCESS(rc))    {        if (fContiguous)        {            Assert(enmType == RTR0MEMOBJTYPE_PHYS);#if __FreeBSD_version >= 1000030            VM_OBJECT_WLOCK(pMemFreeBSD->pObject);#else            VM_OBJECT_LOCK(pMemFreeBSD->pObject);#endif            pMemFreeBSD->Core.u.Phys.PhysBase = VM_PAGE_TO_PHYS(vm_page_find_least(pMemFreeBSD->pObject, 0));#if __FreeBSD_version >= 1000030            VM_OBJECT_WUNLOCK(pMemFreeBSD->pObject);#else            VM_OBJECT_UNLOCK(pMemFreeBSD->pObject);#endif            pMemFreeBSD->Core.u.Phys.fAllocated = true;        }        *ppMem = &pMemFreeBSD->Core;    }    else    {        vm_object_deallocate(pMemFreeBSD->pObject);        rtR0MemObjDelete(&pMemFreeBSD->Core);    }    return rc;}

vm_object_tvmm_mmio_alloc(struct vmspace *vmspace, vm_paddr_t gpa, size_t len,	       vm_paddr_t hpa){	int error;	vm_object_t obj;	struct sglist *sg;	sg = sglist_alloc(1, M_WAITOK);	error = sglist_append_phys(sg, hpa, len);	KASSERT(error == 0, ("error %d appending physaddr to sglist", error));	obj = vm_pager_allocate(OBJT_SG, sg, len, VM_PROT_RW, 0, NULL);	if (obj != NULL) {		/*		 * VT-x ignores the MTRR settings when figuring out the		 * memory type for translations obtained through EPT.		 *		 * Therefore we explicitly force the pages provided by		 * this object to be mapped as uncacheable.		 */		VM_OBJECT_WLOCK(obj);		error = vm_object_set_memattr(obj, VM_MEMATTR_UNCACHEABLE);		VM_OBJECT_WUNLOCK(obj);		if (error != KERN_SUCCESS) {			panic("vmm_mmio_alloc: vm_object_set_memattr error %d",				error);		}		error = vm_map_find(&vmspace->vm_map, obj, 0, &gpa, len, 0,				    VMFS_NO_SPACE, VM_PROT_RW, VM_PROT_RW, 0);		if (error != KERN_SUCCESS) {			vm_object_deallocate(obj);			obj = NULL;		}	}	/*	 * Drop the reference on the sglist.	 *	 * If the scatter/gather object was successfully allocated then it	 * has incremented the reference count on the sglist. Dropping the	 * initial reference count ensures that the sglist will be freed	 * when the object is deallocated.	 * 	 * If the object could not be allocated then we end up freeing the	 * sglist.	 */	sglist_free(sg);	return (obj);}

static int rtR0MemObjFreeBSDAllocHelper(PRTR0MEMOBJFREEBSD pMemFreeBSD, bool fExecutable,                                        vm_paddr_t VmPhysAddrHigh, bool fContiguous, int rcNoMem){    vm_offset_t MapAddress = vm_map_min(kernel_map);    size_t      cPages = atop(pMemFreeBSD->Core.cb);    int         rc;    pMemFreeBSD->pObject = vm_object_allocate(OBJT_PHYS, cPages);    /* No additional object reference for auto-deallocation upon unmapping. */#if __FreeBSD_version >= 1000055    rc = vm_map_find(kernel_map, pMemFreeBSD->pObject, 0,                     &MapAddress, pMemFreeBSD->Core.cb, 0, VMFS_ANY_SPACE,                     fExecutable ? VM_PROT_ALL : VM_PROT_RW, VM_PROT_ALL, 0);#else    rc = vm_map_find(kernel_map, pMemFreeBSD->pObject, 0,                     &MapAddress, pMemFreeBSD->Core.cb, VMFS_ANY_SPACE,                     fExecutable ? VM_PROT_ALL : VM_PROT_RW, VM_PROT_ALL, 0);#endif    if (rc == KERN_SUCCESS)    {        rc = rtR0MemObjFreeBSDPhysAllocHelper(pMemFreeBSD->pObject, cPages,                                              VmPhysAddrHigh, PAGE_SIZE, fContiguous,                                              false, rcNoMem);        if (RT_SUCCESS(rc))        {            vm_map_wire(kernel_map, MapAddress, MapAddress + pMemFreeBSD->Core.cb,                        VM_MAP_WIRE_SYSTEM | VM_MAP_WIRE_NOHOLES);            /* Store start address */            pMemFreeBSD->Core.pv = (void *)MapAddress;            return VINF_SUCCESS;        }        vm_map_remove(kernel_map, MapAddress, MapAddress + pMemFreeBSD->Core.cb);    }    else    {        rc = rcNoMem; /** @todo fix translation (borrow from darwin) */        vm_object_deallocate(pMemFreeBSD->pObject);    }    rtR0MemObjDelete(&pMemFreeBSD->Core);    return rc;}

voidefi_destroy_1t1_map(void){	vm_page_t m;	if (obj_1t1_pt != NULL) {		VM_OBJECT_RLOCK(obj_1t1_pt);		TAILQ_FOREACH(m, &obj_1t1_pt->memq, listq)			m->wire_count = 0;		vm_wire_sub(obj_1t1_pt->resident_page_count);		VM_OBJECT_RUNLOCK(obj_1t1_pt);		vm_object_deallocate(obj_1t1_pt);	}	obj_1t1_pt = NULL;	efi_pml4 = NULL;	efi_pml4_page = NULL;}

static intspigen_close(struct cdev *cdev, int fflag, int devtype, struct thread *td){    device_t dev = cdev->si_drv1;    struct spigen_softc *sc = device_get_softc(dev);    mtx_lock(&sc->sc_mtx);    if (sc->sc_mmap_buffer != NULL) {        pmap_qremove(sc->sc_mmap_kvaddr,                     sc->sc_mmap_buffer_size / PAGE_SIZE);        kva_free(sc->sc_mmap_kvaddr, sc->sc_mmap_buffer_size);        sc->sc_mmap_kvaddr = 0;        vm_object_deallocate(sc->sc_mmap_buffer);        sc->sc_mmap_buffer = NULL;        sc->sc_mmap_buffer_size = 0;    }    mtx_unlock(&sc->sc_mtx);    return (0);}

voidefi_destroy_1t1_map(void){	vm_page_t m;	if (obj_1t1_pt != NULL) {		VM_OBJECT_RLOCK(obj_1t1_pt);		TAILQ_FOREACH(m, &obj_1t1_pt->memq, listq)			m->wire_count = 0;		atomic_subtract_int(&vm_cnt.v_wire_count,		    obj_1t1_pt->resident_page_count);		VM_OBJECT_RUNLOCK(obj_1t1_pt);		vm_object_deallocate(obj_1t1_pt);	}	obj_1t1_pt = NULL;	efi_l0 = NULL;	efi_l0_page = NULL;}

static voidpscnv_gem_pager_dtor(void *handle){	struct drm_gem_object *gem_obj = handle;	struct pscnv_bo *bo = gem_obj->driver_private;	struct drm_device *dev = gem_obj->dev;	vm_object_t devobj;	DRM_LOCK(dev);	devobj = cdev_pager_lookup(handle);	if (devobj != NULL) {		vm_size_t page_count = OFF_TO_IDX(bo->size);		vm_page_t m;		int i;		VM_OBJECT_LOCK(devobj);		for (i = 0; i < page_count; i++) {			m = vm_page_lookup(devobj, i);			if (!m)				continue;			if (pscnv_mem_debug > 0)				NV_WARN(dev, "Freeing %010llx + %08llx (%p/n", bo->start, i * PAGE_SIZE, m);			cdev_pager_free_page(devobj, m);		}		VM_OBJECT_UNLOCK(devobj);		vm_object_deallocate(devobj);	}	else {		DRM_UNLOCK(dev);		NV_ERROR(dev, "Could not find handle %p bo %p/n", handle, bo);		return;	}	if (pscnv_mem_debug > 0)		NV_WARN(dev, "Freed %010llx (%p)/n", bo->start, bo);	//kfree(bo->fake_pages);	if (bo->chan)		pscnv_chan_unref(bo->chan);	else		drm_gem_object_unreference_unlocked(gem_obj);	DRM_UNLOCK(dev);}

voidttm_bo_release_mmap(struct ttm_buffer_object *bo){	vm_object_t vm_obj;	vm_page_t m;	int i;	vm_obj = cdev_pager_lookup(bo);	if (vm_obj == NULL)		return;	VM_OBJECT_WLOCK(vm_obj);	for (i = 0; i < bo->num_pages; i++) {		m = vm_page_lookup_busy_wait(vm_obj, i, TRUE, "ttm_unm");		if (m == NULL)			continue;		cdev_pager_free_page(vm_obj, m);	}	VM_OBJECT_WUNLOCK(vm_obj);	vm_object_deallocate(vm_obj);}

static voidlink_elf_unload_file(linker_file_t file){    elf_file_t ef = file->priv;    if (ef) {#ifdef SPARSE_MAPPING	if (ef->object) {	    vm_map_remove(&kernel_map, (vm_offset_t) ef->address,			  (vm_offset_t) ef->address			  + (ef->object->size << PAGE_SHIFT));	    vm_object_deallocate(ef->object);	}#else	if (ef->address)	    kfree(ef->address, M_LINKER);#endif	if (ef->symbase)	    kfree(ef->symbase, M_LINKER);	if (ef->strbase)	    kfree(ef->strbase, M_LINKER);	kfree(ef, M_LINKER);    }}

vm_object_tvmm_mem_alloc(struct vmspace *vmspace, vm_paddr_t gpa, size_t len){	int error;	vm_object_t obj;	if (gpa & PAGE_MASK)		panic("vmm_mem_alloc: invalid gpa %#lx", gpa);	if (len == 0 || (len & PAGE_MASK) != 0)		panic("vmm_mem_alloc: invalid allocation size %lu", len);	obj = vm_object_allocate(OBJT_DEFAULT, len >> PAGE_SHIFT);	if (obj != NULL) {		error = vm_map_find(&vmspace->vm_map, obj, 0, &gpa, len, 0,				    VMFS_NO_SPACE, VM_PROT_ALL, VM_PROT_ALL, 0);		if (error != KERN_SUCCESS) {			vm_object_deallocate(obj);			obj = NULL;		}	}	return (obj);}

static voidos_balloonobject_delete(void){   vm_object_deallocate(global_state.vmobject);}

//.........这里部分代码省略.........	 * stuff needs to be in a single chunk so that profiling etc can get	 * the bounds and gdb can associate offsets with modules	 */	ef->object = vm_object_allocate(OBJT_DEFAULT,					round_page(mapsize) >> PAGE_SHIFT);	if (ef->object == NULL) {		error = ENOMEM;		goto out;	}	vm_object_hold(ef->object);	vm_object_reference_locked(ef->object);	ef->address = (caddr_t) vm_map_min(&kernel_map);	ef->bytes = 0;	/*	 * In order to satisfy x86_64's architectural requirements on the	 * location of code and data in the kernel's address space, request a	 * mapping that is above the kernel.	 *	 * vkernel64's text+data is outside the managed VM space entirely.	 */#if defined(__x86_64__) && defined(_KERNEL_VIRTUAL)	error = vkernel_module_memory_alloc(&mapbase, round_page(mapsize));	vm_object_drop(ef->object);#else	mapbase = KERNBASE;	error = vm_map_find(&kernel_map, ef->object, NULL,			    0, &mapbase, round_page(mapsize),			    PAGE_SIZE,			    TRUE, VM_MAPTYPE_NORMAL,			    VM_PROT_ALL, VM_PROT_ALL, FALSE);	vm_object_drop(ef->object);	if (error) {		vm_object_deallocate(ef->object);		ef->object = NULL;		goto out;	}	/* Wire the pages */	error = vm_map_wire(&kernel_map, mapbase,			    mapbase + round_page(mapsize), 0);#endif	if (error != KERN_SUCCESS) {		error = ENOMEM;		goto out;	}	/* Inform the kld system about the situation */	lf->address = ef->address = (caddr_t) mapbase;	lf->size = round_page(mapsize);	ef->bytes = mapsize;	/*	 * Now load code/data(progbits), zero bss(nobits), allocate space for	 * and load relocs	 */	pb = 0;	rl = 0;	ra = 0;	alignmask = 0;	for (i = 0; i < hdr->e_shnum; i++) {		if (shdr[i].sh_size == 0)			continue;		switch (shdr[i].sh_type) {		case SHT_PROGBITS:		case SHT_NOBITS:			alignmask = shdr[i].sh_addralign - 1;			mapbase += alignmask;

static voidlink_elf_obj_unload_file(linker_file_t file){	elf_file_t	ef = file->priv;	int i;	if (ef->progtab) {		for (i = 0; i < ef->nprogtab; i++) {			if (ef->progtab[i].size == 0)				continue;			if (ef->progtab[i].name == NULL)				continue;#if 0			if (!strcmp(ef->progtab[i].name, "set_pcpu"))				dpcpu_free(ef->progtab[i].addr,				    ef->progtab[i].size);#ifdef VIMAGE			else if (!strcmp(ef->progtab[i].name, VNET_SETNAME))				vnet_data_free(ef->progtab[i].addr,				    ef->progtab[i].size);#endif#endif		}	}	if (ef->preloaded) {		if (ef->reltab)			kfree(ef->reltab, M_LINKER);		if (ef->relatab)			kfree(ef->relatab, M_LINKER);		if (ef->progtab)			kfree(ef->progtab, M_LINKER);		if (ef->ctftab)			kfree(ef->ctftab, M_LINKER);		if (ef->ctfoff)			kfree(ef->ctfoff, M_LINKER);		if (ef->typoff)			kfree(ef->typoff, M_LINKER);		if (file->filename != NULL)			preload_delete_name(file->filename);		kfree(ef, M_LINKER);		/* XXX reclaim module memory? */		return;	}	for (i = 0; i < ef->nreltab; i++)		if (ef->reltab[i].rel)			kfree(ef->reltab[i].rel, M_LINKER);	for (i = 0; i < ef->nrelatab; i++)		if (ef->relatab[i].rela)			kfree(ef->relatab[i].rela, M_LINKER);	if (ef->reltab)		kfree(ef->reltab, M_LINKER);	if (ef->relatab)		kfree(ef->relatab, M_LINKER);	if (ef->progtab)		kfree(ef->progtab, M_LINKER);	if (ef->object) {#if defined(__x86_64__) && defined(_KERNEL_VIRTUAL)		vkernel_module_memory_free((vm_offset_t)ef->address, ef->bytes);#else		vm_map_remove(&kernel_map, (vm_offset_t) ef->address,		    (vm_offset_t) ef->address +		    (ef->object->size << PAGE_SHIFT));#endif		vm_object_deallocate(ef->object);		ef->object = NULL;	}	if (ef->e_shdr)		kfree(ef->e_shdr, M_LINKER);	if (ef->ddbsymtab)		kfree(ef->ddbsymtab, M_LINKER);	if (ef->ddbstrtab)		kfree(ef->ddbstrtab, M_LINKER);	if (ef->shstrtab)		kfree(ef->shstrtab, M_LINKER);	if (ef->ctftab)		kfree(ef->ctftab, M_LINKER);	if (ef->ctfoff)		kfree(ef->ctfoff, M_LINKER);	if (ef->typoff)		kfree(ef->typoff, M_LINKER);	kfree(ef, M_LINKER);}

vm_object_tcdev_pager_allocate(void *handle, enum obj_type tp, struct cdev_pager_ops *ops,    vm_ooffset_t size, vm_prot_t prot, vm_ooffset_t foff, struct ucred *cred){	vm_object_t object, object1;	vm_pindex_t pindex;	u_short color;	if (tp != OBJT_DEVICE && tp != OBJT_MGTDEVICE)		return (NULL);	/*	 * Offset should be page aligned.	 */	if (foff & PAGE_MASK)		return (NULL);	size = round_page(size);	pindex = OFF_TO_IDX(foff + size);	if (ops->cdev_pg_ctor(handle, size, prot, foff, cred, &color) != 0)		return (NULL);	mtx_lock(&dev_pager_mtx);	/*	 * Look up pager, creating as necessary.	 */	object1 = NULL;	object = vm_pager_object_lookup(&dev_pager_object_list, handle);	if (object == NULL) {		/*		 * Allocate object and associate it with the pager.  Initialize		 * the object's pg_color based upon the physical address of the		 * device's memory.		 */		mtx_unlock(&dev_pager_mtx);		object1 = vm_object_allocate(tp, pindex);		object1->flags |= OBJ_COLORED;		object1->pg_color = color;		object1->handle = handle;		object1->un_pager.devp.ops = ops;		object1->un_pager.devp.dev = handle;		TAILQ_INIT(&object1->un_pager.devp.devp_pglist);		mtx_lock(&dev_pager_mtx);		object = vm_pager_object_lookup(&dev_pager_object_list, handle);		if (object != NULL) {			/*			 * We raced with other thread while allocating object.			 */			if (pindex > object->size)				object->size = pindex;		} else {			object = object1;			object1 = NULL;			object->handle = handle;			TAILQ_INSERT_TAIL(&dev_pager_object_list, object,			    pager_object_list);			KASSERT(object->type == tp,		("Inconsistent device pager type %p %d", object, tp));		}	} else {		if (pindex > object->size)			object->size = pindex;	}	mtx_unlock(&dev_pager_mtx);	if (object1 != NULL) {		object1->handle = object1;		mtx_lock(&dev_pager_mtx);		TAILQ_INSERT_TAIL(&dev_pager_object_list, object1,		    pager_object_list);		mtx_unlock(&dev_pager_mtx);		vm_object_deallocate(object1);	}	return (object);}

//.........这里部分代码省略.........	AcpiSetFirmwareWakingVector(sc->acpi_wakephys);	ef = read_eflags();	disable_intr();	/* Create Identity Mapping */	if ((p = curproc) == NULL)		p = &proc0;	pm = vmspace_pmap(p->p_vmspace);	if (pm->pm_pteobj == NULL) {		pm->pm_pteobj = vm_object_allocate(OBJT_DEFAULT, PTDPTDI + 1);		pteobj_allocated = 1;	}	oldphys = pmap_extract(pm, sc->acpi_wakephys);	if (oldphys) {		opage = PHYS_TO_VM_PAGE(oldphys);	}	page = PHYS_TO_VM_PAGE(sc->acpi_wakephys);	pmap_enter(pm, sc->acpi_wakephys, page,		   VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE, 1);	ret_addr = 0;	if (acpi_savecpu()) {		/* Execute Sleep */		p_gdt = (struct region_descriptor *)(sc->acpi_wakeaddr + physical_gdt);		p_gdt->rd_limit = r_gdt.rd_limit;		p_gdt->rd_base = vtophys(r_gdt.rd_base);		WAKECODE_FIXUP(physical_esp, u_int32_t, vtophys(r_esp));		WAKECODE_FIXUP(previous_cr0, u_int32_t, r_cr0);		WAKECODE_FIXUP(previous_cr2, u_int32_t, r_cr2);		WAKECODE_FIXUP(previous_cr3, u_int32_t, r_cr3);		WAKECODE_FIXUP(previous_cr4, u_int32_t, r_cr4);		WAKECODE_FIXUP(previous_tr,  u_int16_t, r_tr);		WAKECODE_BCOPY(previous_gdt, struct region_descriptor, r_gdt);		WAKECODE_FIXUP(previous_ldt, u_int16_t, r_ldt);		WAKECODE_BCOPY(previous_idt, struct region_descriptor, r_idt);		WAKECODE_FIXUP(where_to_recover, void, acpi_restorecpu);		WAKECODE_FIXUP(previous_ds,  u_int16_t, r_ds);		WAKECODE_FIXUP(previous_es,  u_int16_t, r_es);		WAKECODE_FIXUP(previous_fs,  u_int16_t, r_fs);		WAKECODE_FIXUP(previous_gs,  u_int16_t, r_gs);		WAKECODE_FIXUP(previous_ss,  u_int16_t, r_ss);		if (acpi_get_verbose(sc)) {			acpi_printcpu();		}		wbinvd(); 		if (state == ACPI_STATE_S4 && sc->acpi_s4bios) {			status = AcpiEnterSleepStateS4Bios();		} else {			status = AcpiEnterSleepState(state);		}		if (status != AE_OK) {			device_printf(sc->acpi_dev,				"AcpiEnterSleepState failed - %s/n",				AcpiFormatException(status));			ret = -1;			goto out;		}		for (;;) ;	} else {		/* Execute Wakeup */#if 0		initializecpu();#endif		icu_reinit();		if (acpi_get_verbose(sc)) {			acpi_savecpu();			acpi_printcpu();		}	}out:	vm_page_lock_queues();	pmap_remove(pm, sc->acpi_wakephys, sc->acpi_wakephys + PAGE_SIZE);	vm_page_unlock_queues();	if (opage) {		pmap_enter(pm, sc->acpi_wakephys, page,			   VM_PROT_READ | VM_PROT_WRITE, 0);	}	if (pteobj_allocated) {		vm_object_deallocate(pm->pm_pteobj);		pm->pm_pteobj = NULL;	}	write_eflags(ef);	return (ret);}

//.........这里部分代码省略.........		docow |= MAP_COPY_ON_WRITE;	if (flags & MAP_NOSYNC)		docow |= MAP_DISABLE_SYNCER;	if (flags & MAP_NOCORE)		docow |= MAP_DISABLE_COREDUMP;#if defined(VM_PROT_READ_IS_EXEC)	if (prot & VM_PROT_READ)		prot |= VM_PROT_EXECUTE;	if (maxprot & VM_PROT_READ)		maxprot |= VM_PROT_EXECUTE;#endif	/*	 * This may place the area in its own page directory if (size) is	 * large enough, otherwise it typically returns its argument.	 *	 * (object can be NULL)	 */	if (fitit) {		*addr = pmap_addr_hint(object, *addr, size);	}	/*	 * Stack mappings need special attention.	 *	 * Mappings that use virtual page tables will default to storing	 * the page table at offset 0.	 */	if (uksmap) {		rv = vm_map_find(map, uksmap, vp->v_rdev,				 foff, addr, size,				 align,				 fitit, VM_MAPTYPE_UKSMAP,				 prot, maxprot, docow);	} else if (flags & MAP_STACK) {		rv = vm_map_stack(map, *addr, size, flags,				  prot, maxprot, docow);	} else if (flags & MAP_VPAGETABLE) {		rv = vm_map_find(map, object, NULL,				 foff, addr, size,				 align,				 fitit, VM_MAPTYPE_VPAGETABLE,				 prot, maxprot, docow);	} else {		rv = vm_map_find(map, object, NULL,				 foff, addr, size,				 align,				 fitit, VM_MAPTYPE_NORMAL,				 prot, maxprot, docow);	}	if (rv != KERN_SUCCESS) {		/*		 * Lose the object reference. Will destroy the		 * object if it's an unnamed anonymous mapping		 * or named anonymous without other references.		 *		 * (NOTE: object can be NULL)		 */		vm_object_deallocate(object);		goto out;	}	/*	 * Shared memory is also shared with children.	 */	if (flags & (MAP_SHARED|MAP_INHERIT)) {		rv = vm_map_inherit(map, *addr, *addr + size, VM_INHERIT_SHARE);		if (rv != KERN_SUCCESS) {			vm_map_remove(map, *addr, *addr + size);			goto out;		}	}	/* If a process has marked all future mappings for wiring, do so */	if ((rv == KERN_SUCCESS) && (map->flags & MAP_WIREFUTURE))		vm_map_unwire(map, *addr, *addr + size, FALSE);	/*	 * Set the access time on the vnode	 */	if (vp != NULL)		vn_mark_atime(vp, td);out:	lwkt_reltoken(&map->token);		switch (rv) {	case KERN_SUCCESS:		return (0);	case KERN_INVALID_ADDRESS:	case KERN_NO_SPACE:		return (ENOMEM);	case KERN_PROTECTION_FAILURE:		return (EACCES);	default:		return (EINVAL);	}}

//.........这里部分代码省略.........	if (error) {		if (error == -1) {			if (textset == 0)				VOP_UNSET_TEXT(imgp->vp);			error = ENOEXEC;		}		goto exec_fail_dealloc;	}	/*	 * Special interpreter operation, cleanup and loop up to try to	 * activate the interpreter.	 */	if (imgp->interpreted) {		exec_unmap_first_page(imgp);		/*		 * VV_TEXT needs to be unset for scripts.  There is a short		 * period before we determine that something is a script where		 * VV_TEXT will be set. The vnode lock is held over this		 * entire period so nothing should illegitimately be blocked.		 */		VOP_UNSET_TEXT(imgp->vp);		/* free name buffer and old vnode */		if (args->fname != NULL)			NDFREE(&nd, NDF_ONLY_PNBUF);#ifdef MAC		mac_execve_interpreter_enter(newtextvp, &interpvplabel);#endif		if (imgp->opened) {			VOP_CLOSE(newtextvp, FREAD, td->td_ucred, td);			imgp->opened = 0;		}		vput(newtextvp);		vm_object_deallocate(imgp->object);		imgp->object = NULL;		imgp->credential_setid = false;		if (imgp->newcred != NULL) {			crfree(imgp->newcred);			imgp->newcred = NULL;		}		imgp->execpath = NULL;		free(imgp->freepath, M_TEMP);		imgp->freepath = NULL;		/* set new name to that of the interpreter */		NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW | SAVENAME,		    UIO_SYSSPACE, imgp->interpreter_name, td);		args->fname = imgp->interpreter_name;		goto interpret;	}	/*	 * NB: We unlock the vnode here because it is believed that none	 * of the sv_copyout_strings/sv_fixup operations require the vnode.	 */	VOP_UNLOCK(imgp->vp, 0);	if (disallow_high_osrel &&	    P_OSREL_MAJOR(p->p_osrel) > P_OSREL_MAJOR(__FreeBSD_version)) {		error = ENOEXEC;		uprintf("Osrel %d for image %s too high/n", p->p_osrel,		    imgp->execpath != NULL ? imgp->execpath : "<unresolved>");		vn_lock(imgp->vp, LK_SHARED | LK_RETRY);		goto exec_fail_dealloc;	}	/* ABI enforces the use of Capsicum. Switch into capabilities mode. */

//.........这里部分代码省略.........			mapsize &= ~alignmask;			mapsize += shdr[i].sh_size;			break;		}	}	/*	 * We know how much space we need for the text/data/bss/etc.	 * This stuff needs to be in a single chunk so that profiling etc	 * can get the bounds and gdb can associate offsets with modules	 */	ef->object = vm_object_allocate(OBJT_DEFAULT,	    round_page(mapsize) >> PAGE_SHIFT);	if (ef->object == NULL) {		error = ENOMEM;		goto out;	}	ef->address = (caddr_t) vm_map_min(kernel_map);	/*	 * In order to satisfy amd64's architectural requirements on the	 * location of code and data in the kernel's address space, request a	 * mapping that is above the kernel.  	 */#ifdef __amd64__	mapbase = KERNBASE;#else	mapbase = VM_MIN_KERNEL_ADDRESS;#endif	error = vm_map_find(kernel_map, ef->object, 0, &mapbase,	    round_page(mapsize), 0, VMFS_OPTIMAL_SPACE, VM_PROT_ALL,	    VM_PROT_ALL, 0);	if (error) {		vm_object_deallocate(ef->object);		ef->object = 0;		goto out;	}	/* Wire the pages */	error = vm_map_wire(kernel_map, mapbase,	    mapbase + round_page(mapsize),	    VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES);	if (error != KERN_SUCCESS) {		error = ENOMEM;		goto out;	}	/* Inform the kld system about the situation */	lf->address = ef->address = (caddr_t)mapbase;	lf->size = mapsize;	/*	 * Now load code/data(progbits), zero bss(nobits), allocate space for	 * and load relocs	 */	pb = 0;	rl = 0;	ra = 0;	alignmask = 0;	for (i = 0; i < hdr->e_shnum; i++) {		if (shdr[i].sh_size == 0)			continue;		switch (shdr[i].sh_type) {		case SHT_PROGBITS:		case SHT_NOBITS:			alignmask = shdr[i].sh_addralign - 1;

/* * Destroy old address space, and allocate a new stack. *	The new stack is only sgrowsiz large because it is grown *	automatically on a page fault. */intexec_new_vmspace(struct image_params *imgp, struct sysentvec *sv){	int error;	struct proc *p = imgp->proc;	struct vmspace *vmspace = p->p_vmspace;	vm_object_t obj;	struct rlimit rlim_stack;	vm_offset_t sv_minuser, stack_addr;	vm_map_t map;	u_long ssiz;	imgp->vmspace_destroyed = 1;	imgp->sysent = sv;	/* May be called with Giant held */	EVENTHANDLER_DIRECT_INVOKE(process_exec, p, imgp);	/*	 * Blow away entire process VM, if address space not shared,	 * otherwise, create a new VM space so that other threads are	 * not disrupted	 */	map = &vmspace->vm_map;	if (map_at_zero)		sv_minuser = sv->sv_minuser;	else		sv_minuser = MAX(sv->sv_minuser, PAGE_SIZE);	if (vmspace->vm_refcnt == 1 && vm_map_min(map) == sv_minuser &&	    vm_map_max(map) == sv->sv_maxuser &&	    cpu_exec_vmspace_reuse(p, map)) {		shmexit(vmspace);		pmap_remove_pages(vmspace_pmap(vmspace));		vm_map_remove(map, vm_map_min(map), vm_map_max(map));		/*		 * An exec terminates mlockall(MCL_FUTURE), ASLR state		 * must be re-evaluated.		 */		vm_map_lock(map);		vm_map_modflags(map, 0, MAP_WIREFUTURE | MAP_ASLR |		    MAP_ASLR_IGNSTART);		vm_map_unlock(map);	} else {		error = vmspace_exec(p, sv_minuser, sv->sv_maxuser);		if (error)			return (error);		vmspace = p->p_vmspace;		map = &vmspace->vm_map;	}	map->flags |= imgp->map_flags;	/* Map a shared page */	obj = sv->sv_shared_page_obj;	if (obj != NULL) {		vm_object_reference(obj);		error = vm_map_fixed(map, obj, 0,		    sv->sv_shared_page_base, sv->sv_shared_page_len,		    VM_PROT_READ | VM_PROT_EXECUTE,		    VM_PROT_READ | VM_PROT_EXECUTE,		    MAP_INHERIT_SHARE | MAP_ACC_NO_CHARGE);		if (error != KERN_SUCCESS) {			vm_object_deallocate(obj);			return (vm_mmap_to_errno(error));		}	}	/* Allocate a new stack */	if (imgp->stack_sz != 0) {		ssiz = trunc_page(imgp->stack_sz);		PROC_LOCK(p);		lim_rlimit_proc(p, RLIMIT_STACK, &rlim_stack);		PROC_UNLOCK(p);		if (ssiz > rlim_stack.rlim_max)			ssiz = rlim_stack.rlim_max;		if (ssiz > rlim_stack.rlim_cur) {			rlim_stack.rlim_cur = ssiz;			kern_setrlimit(curthread, RLIMIT_STACK, &rlim_stack);		}	} else if (sv->sv_maxssiz != NULL) {		ssiz = *sv->sv_maxssiz;	} else {		ssiz = maxssiz;	}	stack_addr = sv->sv_usrstack - ssiz;	error = vm_map_stack(map, stack_addr, (vm_size_t)ssiz,	    obj != NULL && imgp->stack_prot != 0 ? imgp->stack_prot :	    sv->sv_stackprot, VM_PROT_ALL, MAP_STACK_GROWS_DOWN);	if (error != KERN_SUCCESS)		return (vm_mmap_to_errno(error));	/*	 * vm_ssize and vm_maxsaddr are somewhat antiquated concepts, but they	 * are still used to enforce the stack rlimit on the process stack.	 */	vmspace->vm_ssize = sgrowsiz >> PAGE_SHIFT;//.........这里部分代码省略.........