upstream/illumos/illumos-gate: comparison usr/src/uts/common/vm/seg

equal deleted inserted replaced

-:95e8ec05aa83
+:256464cbb73c
 /*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
-* Common Development and Distribution License, Version 1.0 only
+* Common Development and Distribution License (the "License").
-* (the "License").  You may not use this file except in compliance
+* You may not use this file except in compliance with the License.
-* with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 char *kernelheap;		/* start of primary kernel heap */
 char *ekernelheap;		/* end of primary kernel heap */
 struct seg kvseg;		/* primary kernel heap segment */
 struct seg kvseg_core;		/* "core" kernel heap segment */
+struct seg kzioseg;		/* Segment for zio mappings */
 vmem_t *heap_arena;		/* primary kernel heap arena */
 vmem_t *heap_core_arena;	/* core kernel heap arena */
 char *heap_core_base;		/* start of core kernel heap arena */
 char *heap_lp_base;		/* start of kernel large page heap arena */
 char *heap_lp_end;		/* end of kernel large page heap arena */
 struct seg kvseg32;		/* 32-bit kernel heap segment */
 vmem_t *heap32_arena;		/* 32-bit kernel heap arena */
 vmem_t *heaptext_arena;		/* heaptext arena */
 struct as kas;			/* kernel address space */
 struct vnode kvp;		/* vnode for all segkmem pages */
+struct vnode zvp;		/* vnode for zfs pages */
 int segkmem_reloc;		/* enable/disable relocatable segkmem pages */
 vmem_t *static_arena;		/* arena for caches to import static memory */
 vmem_t *static_alloc_arena;	/* arena for allocating static memory */
+vmem_t *zio_arena = NULL;	/* arena for allocating zio memory */
+vmem_t *zio_alloc_arena = NULL;	/* arena for allocating zio memory */
 /*
 * seg_kmem driver can map part of the kernel heap with large pages.
 * Currently this functionality is implemented for sparc platforms only.
 *
 	enum fault_type type, enum seg_rw rw)
 {
 	pgcnt_t npages;
 	spgcnt_t pg;
 	page_t *pp;
+	struct vnode *vp = seg->s_data;
 	ASSERT(RW_READ_HELD(&seg->s_as->a_lock));
 	if (seg->s_as != &kas || size > seg->s_size ||
 	    addr < seg->s_base || addr + size > seg->s_base + seg->s_size)
 	npages = btopr(size);
 	switch (type) {
 	case F_SOFTLOCK:	/* lock down already-loaded translations */
 		for (pg = 0; pg < npages; pg++) {
-			pp = page_lookup(&kvp, (u_offset_t)(uintptr_t)addr,
+			pp = page_lookup(vp, (u_offset_t)(uintptr_t)addr,
 			    SE_SHARED);
 			if (pp == NULL) {
 				/*
 				 * Hmm, no page. Does a kernel mapping
 				 * exist for it?
 				 */
 				if (!hat_probe(kas.a_hat, addr)) {
 					addr -= PAGESIZE;
 					while (--pg >= 0) {
-						pp = page_find(&kvp,
+						pp = page_find(vp,
 						(u_offset_t)(uintptr_t)addr);
 						if (pp)
 							page_unlock(pp);
 						addr -= PAGESIZE;
 					}
 		if (rw == S_OTHER)
 			hat_reserve(seg->s_as, addr, size);
 		return (0);
 	case F_SOFTUNLOCK:
 		while (npages--) {
-			pp = page_find(&kvp, (u_offset_t)(uintptr_t)addr);
+			pp = page_find(vp, (u_offset_t)(uintptr_t)addr);
 			if (pp)
 				page_unlock(pp);
 			addr += PAGESIZE;
 		}
 		return (0);
 	} else if (seg == &kvseg32) {
 		vmem_walk(heap32_arena, VMEM_ALLOC | VMEM_REENTRANT,
 		    segkmem_dump_range, seg->s_as);
 		vmem_walk(heaptext_arena, VMEM_ALLOC | VMEM_REENTRANT,
 		    segkmem_dump_range, seg->s_as);
+	} else if (seg == &kzioseg) {
+		/*
+		 * We don't want to dump pages attached to kzioseg since they
+		 * contain file data from ZFS.  If this page's segment is
+		 * kzioseg return instead of writing it to the dump device.
+		 */
+		return;
 	} else {
 		segkmem_dump_range(seg->s_as, seg->s_base, seg->s_size);
 	}
 }
 {
 	page_t **pplist, *pp;
 	pgcnt_t npages;
 	spgcnt_t pg;
 	size_t nb;
+	struct vnode *vp = seg->s_data;
 	ASSERT(ppp != NULL);
 	if (segkp_bitmap && seg == &kvseg) {
 		/*
 		*ppp = NULL;
 		return (ENOTSUP);	/* take the slow path */
 	}
 	for (pg = 0; pg < npages; pg++) {
-		pp = page_lookup(&kvp, (u_offset_t)(uintptr_t)addr, SE_SHARED);
+		pp = page_lookup(vp, (u_offset_t)(uintptr_t)addr, SE_SHARED);
 		if (pp == NULL) {
 			while (--pg >= 0)
 				page_unlock(pplist[pg]);
 			kmem_free(pplist, nb);
 			*ppp = NULL;
 	segkmem_getpolicy,		/* getpolicy */
 	segkmem_capable,		/* capable */
 };
 int
-segkmem_create(struct seg *seg)
+segkmem_zio_create(struct seg *seg)
 {
 	ASSERT(seg->s_as == &kas && RW_WRITE_HELD(&kas.a_lock));
 	seg->s_ops = &segkmem_ops;
-	seg->s_data = NULL;
+	seg->s_data = &zvp;
+	kas.a_size += seg->s_size;
+	return (0);
+}
+int
+segkmem_create(struct seg *seg)
+{
+	ASSERT(seg->s_as == &kas && RW_WRITE_HELD(&kas.a_lock));
+	seg->s_ops = &segkmem_ops;
+	seg->s_data = &kvp;
 	kas.a_size += seg->s_size;
 	return (0);
 }
 /*ARGSUSED*/
 page_t *
 segkmem_page_create(void *addr, size_t size, int vmflag, void *arg)
 {
 	struct seg kseg;
 	int pgflags;
+	struct vnode *vp = arg;
+	if (vp == NULL)
+		vp = &kvp;
 	kseg.s_as = &kas;
 	pgflags = PG_EXCL;
 	if (segkmem_reloc == 0 || (vmflag & VM_NORELOC))
 	if (vmflag & VM_PANIC)
 		pgflags |= PG_PANIC;
 	if (vmflag & VM_PUSHPAGE)
 		pgflags |= PG_PUSHPAGE;
-	return (page_create_va(&kvp, (u_offset_t)(uintptr_t)addr, size,
+	return (page_create_va(vp, (u_offset_t)(uintptr_t)addr, size,
 	    pgflags, &kseg, addr));
 }
 /*
 * Allocate pages to back the virtual address range [addr, addr + size).
 	}
 	return (addr);
 }
-void *
+static void *
-segkmem_alloc(vmem_t *vmp, size_t size, int vmflag)
+segkmem_alloc_vn(vmem_t *vmp, size_t size, int vmflag, struct vnode *vp)
 {
 	void *addr;
 	segkmem_gc_list_t *gcp, **prev_gcpp;
+	ASSERT(vp != NULL);
 	if (kvseg.s_base == NULL) {
 #ifndef __sparc
 		if (bootops->bsys_alloc == NULL)
 			halt("Memory allocation between bop_alloc() and "
 		if (boot_alloc(addr, size, BO_NO_ALIGN) != addr)
 			panic("segkmem_alloc: boot_alloc failed");
 		return (addr);
 	}
 	return (segkmem_xalloc(vmp, NULL, size, vmflag, 0,
-	    segkmem_page_create, NULL));
+	    segkmem_page_create, vp));
+}
+void *
+segkmem_alloc(vmem_t *vmp, size_t size, int vmflag)
+{
+	return (segkmem_alloc_vn(vmp, size, vmflag, &kvp));
+}
+void *
+segkmem_zio_alloc(vmem_t *vmp, size_t size, int vmflag)
+{
+	return (segkmem_alloc_vn(vmp, size, vmflag, &zvp));
 }
 /*
 * Any changes to this routine must also be carried over to
 * devmap_free_pages() in the seg_dev driver. This is because
 * we currently don't have a special kernel segment for non-paged
 * kernel memory that is exported by drivers to user space.
 */
-void
+static void
-segkmem_free(vmem_t *vmp, void *inaddr, size_t size)
+segkmem_free_vn(vmem_t *vmp, void *inaddr, size_t size, struct vnode *vp)
 {
 	page_t *pp;
 	caddr_t addr = inaddr;
 	caddr_t eaddr;
 	pgcnt_t npages = btopr(size);
 	ASSERT(((uintptr_t)addr & PAGEOFFSET) == 0);
+	ASSERT(vp != NULL);
 	if (kvseg.s_base == NULL) {
 		segkmem_gc_list_t *gc = inaddr;
 		gc->gc_arena = vmp;
 		gc->gc_size = size;
 	hat_unload(kas.a_hat, addr, size, HAT_UNLOAD_UNLOCK);
 	for (eaddr = addr + size; addr < eaddr; addr += PAGESIZE) {
 #if defined(__x86)
-		pp = page_find(&kvp, (u_offset_t)(uintptr_t)addr);
+		pp = page_find(vp, (u_offset_t)(uintptr_t)addr);
 		if (pp == NULL)
 			panic("segkmem_free: page not found");
 		if (!page_tryupgrade(pp)) {
 			/*
 			 * Some other thread has a sharelock. Wait for
 			 * it to drop the lock so we can free this page.
 			 */
 			page_unlock(pp);
-			pp = page_lookup(&kvp, (u_offset_t)(uintptr_t)addr,
+			pp = page_lookup(vp, (u_offset_t)(uintptr_t)addr,
 			    SE_EXCL);
 		}
 #else
-		pp = page_lookup(&kvp, (u_offset_t)(uintptr_t)addr, SE_EXCL);
+		pp = page_lookup(vp, (u_offset_t)(uintptr_t)addr, SE_EXCL);
 #endif
 		if (pp == NULL)
 			panic("segkmem_free: page not found");
 		/* Clear p_lckcnt so page_destroy() doesn't update availrmem */
 		pp->p_lckcnt = 0;
 	}
 	page_unresv(npages);
 	if (vmp != NULL)
 		vmem_free(vmp, inaddr, size);
+}
+void
+segkmem_free(vmem_t *vmp, void *inaddr, size_t size)
+{
+	segkmem_free_vn(vmp, inaddr, size, &kvp);
+}
+void
+segkmem_zio_free(vmem_t *vmp, void *inaddr, size_t size)
+{
+	segkmem_free_vn(vmp, inaddr, size, &zvp);
 }
 void
 segkmem_gc(void)
 {
 #endif
 	return (use_large_pages);
 }
+void
+segkmem_zio_init(void *zio_mem_base, size_t zio_mem_size)
+{
+	ASSERT(zio_mem_base != NULL);
+	ASSERT(zio_mem_size != 0);
+	zio_arena = vmem_create("zio", zio_mem_base, zio_mem_size, PAGESIZE,
+	    NULL, NULL, NULL, 0, VM_SLEEP);
+	zio_alloc_arena = vmem_create("zio_buf", NULL, 0, PAGESIZE,
+	    segkmem_zio_alloc, segkmem_zio_free, zio_arena, 0, VM_SLEEP);
+	ASSERT(zio_arena != NULL);
+	ASSERT(zio_alloc_arena != NULL);
+}
 #ifdef __sparc
 static void *
 segkmem_alloc_ppa(vmem_t *vmp, size_t size, int vmflag)

changeset 3290	256464cbb73c
parent 1338	c2e71173ece3
child 3351	853fb8df244a