--- old/usr/src/uts/common/avs/ns/nsctl/nsc_mem.c	Fri Jul 27 15:35:55 2018
+++ /dev/null	Fri Jul 27 15:07:21 2018
@@ -1,939 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License (the "License").
- * You may not use this file except in compliance 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.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
- * If applicable, add the following below this CDDL HEADER, with the
- * fields enclosed by brackets "[]" replaced with your own identifying
- * information: Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- */
-/*
- * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
- * Use is subject to license terms.
- */
-
-#include <sys/types.h>
-#include <sys/cmn_err.h>
-#include <sys/ksynch.h>
-#include <sys/kmem.h>
-#include <sys/map.h>
-#include <sys/errno.h>
-#include <sys/ddi.h>
-
-
-#define	__NSC_GEN__
-#include "nsc_dev.h"
-#include "nsc_gen.h"
-#include "nsc_mem.h"
-#include "../nsctl.h"
-#ifdef DS_DDICT
-#include "../contract.h"
-#endif
-
-
-static size_t _nsc_rm_size;
-caddr_t _nsc_rm_base;
-caddr_t _nsc_rm_nvmem_base;
-size_t	_nsc_rmhdr_size;
-
-static kmutex_t _nsc_mem_lock;
-static nsc_mem_t *_nsc_anon_mem;
-static nsc_mem_t *_nsc_rmhdr_mem;
-
-nsc_mem_t *_nsc_mem_top;
-
-nsc_rmhdr_t *_nsc_rmhdr_ptr;
-nsc_rmmap_t *_nsc_global_map;
-nsc_mem_t *_nsc_local_mem;
-
-static void *_nsc_mem_alloc(size_t *, int, nsc_mem_t *);
-static void *_nsc_rm_alloc(size_t *, nsc_mem_t *);
-static int _nsc_mem_free(void *, size_t);
-static int _nsc_rm_free(void *, size_t);
-static size_t _nsc_rm_avail(nsc_mem_t *);
-
-extern void nscsetup(void);
-extern void _nsc_mark_pages(caddr_t, size_t, int);
-extern int  _nsc_lock_all_rm(void);
-extern void _nsc_unlock_all_rm(void);
-extern void _nsc_set_max_devices(int);
-
-/*
- * void
- * _nsc_init_mem (void)
- *	Initialise memory allocation system.
- *
- * Calling/Exit State:
- *	Called at driver initialisation time to allocate necessary
- *	data structures.
- */
-void
-_nsc_init_mem()
-{
-	mutex_init(&_nsc_mem_lock, NULL, MUTEX_DRIVER, NULL);
-
-	_nsc_anon_mem = nsc_register_mem("anon:kmem", NSC_MEM_LOCAL, 0);
-	_nsc_local_mem = nsc_register_mem("nsctl:kmem", NSC_MEM_LOCAL, 0);
-
-	if (!_nsc_anon_mem)
-		cmn_err(CE_PANIC, "nsctl: nsc_init_mem");
-}
-
-
-/*
- * void
- * _nsc_deinit_mem (void)
- *	De-initialise memory alloation system.
- *
- * Calling/Exit State:
- *	Called at driver unload time to de-allocate
- *	resources.
- */
-
-
-void
-_nsc_deinit_mem()
-{
-	if (_nsc_rm_nvmem_base)
-		nsc_kmem_free(_nsc_rm_base, _nsc_rmhdr_size);
-
-	_nsc_rm_nvmem_base = NULL;
-	_nsc_rm_base = NULL;
-}
-
-/*
- * int
- * _nsc_clear_dirty(int force)
- *	mark the global area clean by clearing the header dirty bit number.
- *
- *	returns 0 if successfully cleared, valid errno otherwise
- *
- *	this function should only be called at system shutdown.
- */
-/*ARGSUSED*/
-int
-_nsc_clear_dirty(int force)
-{
-	int rc = 0;
-
-#ifdef DEBUG
-	ulong_t longzeros = 0;
-	if (force) {
-		if (_nsc_rm_nvmem_base) {
-			if (nsc_commit_mem((void *)&longzeros,
-			    (void *)&((nsc_rmhdr_t *)
-			    _nsc_rm_nvmem_base)->rh_dirty,
-			    sizeof (ulong_t), nsc_cm_errhdlr) < 0) {
-				cmn_err(CE_WARN,
-				    "!nsctl: _nsc_clear_magic: "
-				    "hdr force clear failed 0x%p",
-				    (void *)_nsc_rm_nvmem_base);
-			} else {
-				cmn_err(CE_WARN,
-				    "!nsctl: _nsc_clear_magic: "
-				    "hdr force cleared 0x%p",
-				    (void *)_nsc_rm_nvmem_base);
-				_nsc_rmhdr_ptr->rh_dirty = 0;
-			}
-
-			return (0);
-		} else
-			return (EINVAL);
-	}
-
-	if (_nsc_rm_nvmem_base) {
-		if (_nsc_global_lock_init) {
-			mutex_enter(&_nsc_global_lock);
-			if (!_nsc_check_mapinuse()) {
-				if (nsc_commit_mem((void *)&longzeros,
-				    (void *)&((nsc_rmhdr_t *)
-				    _nsc_rm_nvmem_base)->rh_dirty,
-				    sizeof (ulong_t), nsc_cm_errhdlr) < 0) {
-					cmn_err(CE_WARN,
-					    "!nsctl: _nsc_clear_magic: "
-					    "hdr clear failed 0x%p",
-					    (void *)_nsc_rm_nvmem_base);
-				} else {
-					cmn_err(CE_WARN,
-					    "!nsctl: _nsc_clear_magic: "
-					    "hdr cleared 0x%p",
-					    (void *)_nsc_rm_nvmem_base);
-					_nsc_rmhdr_ptr->rh_dirty = 0;
-				}
-				rc = 0;
-			} else {
-				cmn_err(CE_WARN,
-				    "!nsctl: _nsc_clear_magic: "
-				    "global area in use. cannot clear magic");
-				rc = EBUSY;
-			}
-			mutex_exit(&_nsc_global_lock);
-		} else {
-			cmn_err(CE_WARN,
-			    "!nsctl: _nsc_clear_magic: cannot clear magic");
-			rc = EINVAL;
-		}
-	} else
-		rc = EINVAL;
-#else
-
-	rc = ENOTTY;
-
-#endif /* DEBUG */
-
-	return (rc);
-}
-
-/*
- * int
- * _nsc_check_mapinuse()
- *	check if any global maps are still inuse;
- *
- *	return 1 if any non-nsctl map is in use, 0 otherwise
- *	should be called with _nsc_global_lock held
- *
- * 	for nvmem support.  if a client of nsctl is still
- * 	using the global maps then the global area will not
- *	be marked clean.
- */
-int
-_nsc_check_mapinuse(void)
-{
-	nsc_rmmap_t *rmap = _nsc_rmhdr_ptr->map;
-	nsc_rmmap_t *rmapend;
-
-	rmapend = (nsc_rmmap_t *)
-	    ((char *)_nsc_rmhdr_ptr + _nsc_rmhdr_ptr->size);
-
-	for (; rmap < rmapend; ++rmap)
-		if ((rmap->inuse) && !(_nsc_is_nsctl_map(rmap->name)))
-			return (1);
-
-	return (0);
-
-}
-
-/* names of maps in the global area that belong to nsctl */
-static char *nsctl_mapnames[] = {
-	"nsc_global",
-	"nsc_lock"
-};
-
-int
-_nsc_is_nsctl_map(char *mapname)
-{
-	int i;
-
-	for (i = 0; i < sizeof (nsctl_mapnames)/sizeof (char *); ++i)
-		if (strncmp(mapname, nsctl_mapnames[i], _NSC_MAXNAME) == 0)
-			return (1);
-
-	return (0);
-}
-
-
-/*
- * nsc_mem_t *
- * nsc_register_mem(char *name, int type, int flag)
- *	Register a category of memory usage.
- *
- * Calling/Exit State:
- *	Returns a token for use in future calls to nsc_kmem_alloc.
- *		type is NSC_MEM_LOCAL, or NSC_MEM_GLOBAL.
- *		flag is passed through to kmem_alloc on allocate.
- *
- * Description:
- *	The parameters associated with a category can be changed
- *	by making a subsequent call to nsc_register_mem.
- */
-nsc_mem_t *
-nsc_register_mem(char *name, int type, int flag)
-{
-	nsc_mem_t *mp, *new;
-
-	new = kmem_zalloc(sizeof (*new), KM_NOSLEEP);
-
-	mutex_enter(&_nsc_mem_lock);
-
-	for (mp = _nsc_mem_top; mp; mp = mp->next)
-		if (strcmp(mp->name, name) == 0)
-			break;
-
-	if (!mp && !(mp = new)) {
-		mutex_exit(&_nsc_mem_lock);
-		return (NULL);
-	}
-
-	mp->type = type;
-	mp->flag = flag;
-
-	mp->hwm = mp->used;
-	mp->pagehwm = mp->pages;
-	mp->nalloc -= mp->nfree;
-	mp->nfree = 0;
-
-	if (!mp->name) {
-		mp->name = name;
-		mp->next = _nsc_mem_top;
-		_nsc_mem_top = mp;
-	}
-
-	mutex_exit(&_nsc_mem_lock);
-
-	if (new && mp != new)
-		kmem_free(new, sizeof (*new));
-
-	return (mp);
-}
-
-
-/*
- * void
- * nsc_unregister_mem(nsc_mem_t *)
- *	Un-register a category of memory usage.
- *
- * Description:
- *	The specified category is un-registered. For correct
- *	operation this should only be called when all memory
- *	associated with the category has been free'd.
- */
-void
-nsc_unregister_mem(nsc_mem_t *mp)
-{
-	nsc_mem_t **mpp;
-
-	if (!mp)
-		return;
-
-	mutex_enter(&_nsc_mem_lock);
-
-	for (mpp = &_nsc_mem_top; *mpp; mpp = &(*mpp)->next)
-		if (*mpp == mp)
-			break;
-
-	if (*mpp != NULL) {
-		*mpp = mp->next;
-		kmem_free(mp, sizeof (*mp));
-	}
-
-	mutex_exit(&_nsc_mem_lock);
-}
-
-/*
- * void
- * _nsc_global_setup
- *	Setup global variables.
- *
- * Calling/Exit State:
- *	Called to setup the global header.
- */
-void
-_nsc_global_setup()
-{
-	nsc_rmhdr_t *hdr = (void *)_nsc_rm_base;
-	size_t size;
-
-	if (!hdr || !_nsc_global_lock_init || _nsc_rmhdr_ptr)
-		return;
-
-	mutex_enter(&_nsc_global_lock);
-
-	if (!hdr->magic || (_nsc_rm_nvmem_base && !hdr->rh_dirty)) {
-		size = sizeof (nsc_rmhdr_t) +
-		    (sizeof (nsc_rmmap_t) * (_NSC_GLSLOT - 1));
-
-		size = (size + _NSC_GLALIGN) & ~_NSC_GLALIGN;
-		bzero(_nsc_rm_base, size);
-
-		hdr->magic = _NSCTL_HDRMAGIC;
-		hdr->ver = _NSCTL_HDRVER3;
-		hdr->size = size;
-		hdr->maxdev = nsc_max_devices();
-
-		hdr->map[0].inuse = _NSC_GLSLOT;
-		if (_nsc_rm_nvmem_base) {
-			if (hdr->rh_dirty) { /* corrupted */
-				cmn_err(CE_WARN,
-				    "!nsctl: _nsc_global_setup: nv bad header");
-				mutex_exit(&_nsc_global_lock);
-				return;
-			}
-			if (nsc_commit_mem((void *)_nsc_rm_base,
-			    (void *)_nsc_rm_nvmem_base,
-			    size, nsc_cm_errhdlr) < 0)
-				cmn_err(CE_WARN, "!_nsc_global_setup: "
-				    "nvmem header not updated");
-		}
-	}
-
-	_nsc_rmhdr_ptr = hdr;
-	mutex_exit(&_nsc_global_lock);
-
-	if (hdr->magic != _NSCTL_HDRMAGIC || (hdr->ver != _NSCTL_HDRVER &&
-	    hdr->ver != _NSCTL_HDRVER3)) {
-		cmn_err(CE_WARN, "!nsctl: _nsc_global_setup: bad header");
-		return;
-	}
-
-	if (hdr->ver == _NSCTL_HDRVER3 && hdr->maxdev != nsc_max_devices()) {
-		_nsc_set_max_devices(hdr->maxdev);
-		cmn_err(CE_WARN,
-		    "!nsctl: _nsc_global_setup: setting nsc_max_devices to %d",
-		    hdr->maxdev);
-	}
-
-	if (!_nsc_rmmap_init(hdr->map, "nsc_global", _NSC_GLSLOT,
-	    _nsc_rm_size - hdr->size, hdr->size)) {
-		cmn_err(CE_WARN,
-		    "!nsctl: _nsc_global_setup: global map init failed");
-		return;
-	}
-
-	_nsc_global_map = hdr->map;
-
-	(void) nsc_kmem_alloc(hdr->size, 0, _nsc_rmhdr_mem);
-}
-
-/*
- * int
- * _nsc_need_global_mem ()
- *	Expected global memory usage.
- *
- * Calling/Exit State:
- *	Returns the amount of global memory expected to be
- *	used by internal data structures.
- *
- * Remarks:
- *	This is provided purely as a configuration aid to
- *	systems without global memory and as such is not
- *	declared in nsctl.h.
- */
-int
-_nsc_need_global_mem()
-{
-	int size = sizeof (nsc_rmhdr_t) +
-	    (sizeof (nsc_rmmap_t) * (_NSC_GLSLOT - 1));
-
-	size = (size + _NSC_GLALIGN) & ~_NSC_GLALIGN;
-	return (size);
-}
-
-
-/*
- * void *
- * nsc_kmem_alloc (size_t size, int flag, nsc_mem_t *mem)
- *	Allocate memory of the specified type.
- *
- * Calling/Exit State:
- *	Returns a pointer to a word aligned area of memory.
- *	If mem is zero then an anonymous category is used.
- *
- * Description:
- *	Allocates the required memory and updates the usage
- *	statistics stored in mem.
- *
- * Remarks:
- *	VME memory is guaranteed to be eight byte aligned.
- */
-void *
-nsc_kmem_alloc(size_t size, int flag, nsc_mem_t *mem)
-{
-	void *vp;
-
-	if (!mem)
-		mem = _nsc_anon_mem;
-
-	if ((vp = _nsc_mem_alloc(&size, flag, mem)) == NULL)
-		return (NULL);
-
-	mutex_enter(&_nsc_mem_lock);
-
-	mem->nalloc++;
-	mem->used += size;
-	mem->pages += btopr(size);
-
-	if (mem->used > mem->hwm)
-		mem->hwm = mem->used;
-	if (mem->pages > mem->pagehwm)
-		mem->pagehwm = mem->pages;
-
-	mutex_exit(&_nsc_mem_lock);
-	return (vp);
-}
-
-
-/*
- * void *
- * _nsc_mem_alloc (size_t *sizep, int flag, nsc_mem_t *mem)
- *	Allocate memory of the specified type.
- *
- * Calling/Exit State:
- *	Returns a pointer to a word aligned area of memory.
- *
- * Description:
- *	Uses the type field to determine whether to allocate RM,
- *	VME or kernel memory. For types other then RM a copy of
- *	mem is stored immediately prior to the returned area.
- *	size is updated to reflect the header.
- *
- * Remarks:
- *	A two word header is user for VME memory to ensure
- *	eight byte alignment.
- */
-static void *
-_nsc_mem_alloc(size_t *sizep, int flag, nsc_mem_t *mem)
-{
-	size_t size = *sizep;
-	void *vp;
-
-	if (mem->type & NSC_MEM_GLOBAL)
-		return (_nsc_rm_alloc(sizep, mem));
-
-	flag |= mem->flag;
-	size += sizeof (nsc_mem_t *);
-
-	if (flag & KM_NOSLEEP)
-		flag &= ~KM_SLEEP;
-
-	vp = kmem_alloc(size, flag);
-	if (!vp)
-		return (NULL);
-
-	*sizep = size;
-
-	*(nsc_mem_t **)vp = mem;
-
-	return (void *)((nsc_mem_t **)vp + 1);
-}
-
-
-/*
- * void
- * nsc_kmem_free (void *addr, size_t size)
- *	Free a previously allocated area of memory.
- *
- * Calling/Exit State:
- *	The memory specified by addr is returned to the free pool.
- *
- * Description:
- *	Updates the usage statistics appropriately.
- */
-void
-nsc_kmem_free(void *addr, size_t size)
-{
-	caddr_t caddr = (caddr_t)addr;
-	caddr_t rm_base;
-	int rc;
-
-	if (_nsc_rm_nvmem_base)
-		rm_base = _nsc_rm_nvmem_base;
-	else
-		rm_base = _nsc_rm_base;
-
-	if (rm_base <= caddr && caddr < rm_base + _nsc_rm_size)
-		rc = _nsc_rm_free(addr, size);
-	else
-		rc = _nsc_mem_free(addr, size);
-
-	if (rc < 0)
-		cmn_err(CE_PANIC, "nsctl: nsc_kmem_free: invalid free");
-}
-
-
-/*
- * nsc_mem_t *
- * _nsc_mem_free (void *addr, size_t size)
- *	Free a previously allocated area of memory.
- *
- * Calling/Exit State:
- *	Frees the VME or kernel memory at addr and updates
- *	the associated mem structure.
- */
-static int
-_nsc_mem_free(void *addr, size_t size)
-{
-	nsc_mem_t *mp, *tp;
-
-	addr = (void *)((nsc_mem_t **)addr - 1);
-	size += sizeof (nsc_mem_t *);
-
-	mutex_enter(&_nsc_mem_lock);
-
-	mp = *(nsc_mem_t **)addr;
-
-	for (tp = _nsc_mem_top; tp; tp = tp->next)
-		if (tp == mp)
-			break;
-
-	if (tp == NULL) {
-		mutex_exit(&_nsc_mem_lock);
-		return (-1);
-	}
-
-	mp->nfree++;
-	mp->used -= size;
-	mp->pages -= btopr(size);
-
-	*(nsc_mem_t **)addr = NULL;
-
-	mutex_exit(&_nsc_mem_lock);
-
-	kmem_free(addr, size);
-
-	return (0);
-}
-
-
-/*
- * void *
- * nsc_kmem_zalloc(size_t size, int flags, nsc_mem_t *mem)
- *	Allocate and zero memory.
- *
- * Calling/Exit State:
- *	Same as nsc_kmem_alloc(), except that the memory is zeroed.
- */
-void *
-nsc_kmem_zalloc(size_t size, int flag, nsc_mem_t *mem)
-{
-	void *vp = nsc_kmem_alloc(size, flag, mem);
-
-	if (vp)
-		bzero((char *)vp, size);
-
-	return (vp);
-}
-
-
-/*
- * void
- * nsc_mem_sizes (nsc_mem_t *mem, size_t *usedp, size_t *hwmp, size_t *reqp)
- *	Access size information for category.
- *
- * Calling/Exit State:
- *	If the corresponding pointer is non-zero returns
- *	respectively, the number of bytes currently allocated, the
- *	high water mark in bytes and an estimate of the number of
- *	bytes needed for the category assuming that each request
- *	is satisfied from a different page.
- *
- * Remarks:
- *	The reqp parameter is used to estimate the amount of special
- *	purpose memory needed to support the category.
- */
-void
-nsc_mem_sizes(nsc_mem_t *mem, size_t *usedp, size_t *hwmp, size_t *reqp)
-{
-	if (!mem)
-		mem = _nsc_anon_mem;
-
-	if (usedp)
-		*usedp = mem->used;
-	if (hwmp)
-		*hwmp = mem->hwm;
-	if (reqp)
-		*reqp = (size_t)ptob(mem->pagehwm);
-}
-
-
-/*
- * size_t
- * nsc_mem_avail (nsc_mem_t *mem)
- *	Memory available for use by category.
- *
- * Calling/Exit State:
- *	Returns the number of bytes of memory currently
- *	available for use by the category.
- *
- * Remarks:
- *	Reduces the memory available to allow for one unit
- *	of allocation overhead.
- *
- *	Only implemented for NSC_MEM_GLOBAL.
- */
-size_t
-nsc_mem_avail(nsc_mem_t *mem)
-{
-	if (!mem)
-		mem = _nsc_anon_mem;
-
-	if (mem->type & NSC_MEM_GLOBAL)
-		return (_nsc_rm_avail(mem));
-
-#ifdef DEBUG
-	cmn_err(CE_WARN, "!nsc_mem_avail: called for non-global memory!");
-#endif
-
-	return (0);
-}
-
-
-/*
- * void
- * _nsc_global_zero (ulong_t offset, size_t size)
- *	Zero global memory.
- *
- * Description:
- *	Zeroes an area of global memory at the specified offset.
- */
-
-#define	ZSIZE 4096
-static char _nsc_nvmem_zeroes[ZSIZE];
-
-static void
-_nsc_global_zero(ulong_t offset, size_t size)
-{
-	int i;
-	int rc;
-	int failed = 0;
-
-	if (_nsc_rm_nvmem_base) {
-		for (i = 0; i < (int)(size / ZSIZE); ++i) {
-			rc = nsc_commit_mem((void *)_nsc_nvmem_zeroes,
-			    (void *)(_nsc_rm_nvmem_base + offset +
-			    i * ZSIZE),
-			    ZSIZE, nsc_cm_errhdlr);
-
-			if (rc < 0)
-				++failed;
-
-		}
-		rc = nsc_commit_mem((void *)_nsc_nvmem_zeroes,
-		    (void *)(_nsc_rm_nvmem_base + offset + i * ZSIZE),
-		    size % ZSIZE,
-		    nsc_cm_errhdlr);
-		if ((rc <  0) || failed)
-			cmn_err(CE_WARN, "!_nsc_global_zero: clear mem failed");
-		return;
-	}
-
-	if (_nsc_rm_base)
-		bzero(_nsc_rm_base + offset, size);
-}
-
-
-/*
- * void *
- * _nsc_rm_alloc (size_t *sizep, nsc_mem_t *mem)
- *	Allocate next available section of RM.
- *
- * Calling/Exit State:
- *	Returns a pointer to an area of global memory.
- *
- * Description:
- *	Only one allocation request is allowed for each
- *	category of global memory.
- */
-static void *
-_nsc_rm_alloc(size_t *sizep, nsc_mem_t *mem)
-{
-	size_t avail, size = (*sizep);
-	ulong_t offset = 0;
-	caddr_t	retaddr;
-
-	if (!_nsc_global_map) {
-		cmn_err(CE_WARN, "!_nsc_rm_alloc: no map");
-		return (NULL);
-	}
-
-	mutex_enter(&_nsc_mem_lock);
-
-	if (mem->base || mem->pend) {
-		mutex_exit(&_nsc_mem_lock);
-		cmn_err(CE_WARN, "!_nsc_rm_alloc: invalid alloc");
-		return (NULL);
-	}
-
-	mem->pend = 1;
-	mutex_exit(&_nsc_mem_lock);
-
-	size = (size + _NSC_GLALIGN) & ~_NSC_GLALIGN;
-
-	/* CONSTCOND */
-
-	while (1) {
-		if (strcmp(mem->name, "nsctl:rmhdr") == 0)
-			break;
-
-		offset = _nsc_rmmap_alloc(_nsc_global_map,
-		    mem->name, size, _nsc_global_zero);
-
-		if (offset)
-			break;
-
-		if (mem->type & NSC_MEM_RESIZE) {
-			avail = _nsc_rmmap_size(_nsc_global_map, mem->name);
-
-			if (avail && avail != size) {
-				size = avail;
-				continue;
-			}
-		}
-
-		mem->pend = 0;
-		cmn_err(CE_WARN,
-		    "!_nsc_rm_alloc: alloc %ld bytes - %ld available",
-		    size, _nsc_rm_avail(mem));
-		return (NULL);
-	}
-
-	_nsc_mark_pages(_nsc_rm_base + offset, size, 1);
-
-	if (_nsc_rm_nvmem_base)
-		retaddr = _nsc_rm_nvmem_base + offset;
-	else
-		retaddr = _nsc_rm_base + offset;
-
-	mutex_enter(&_nsc_mem_lock);
-
-	mem->base = retaddr;
-	mem->pend = 0;
-
-	mutex_exit(&_nsc_mem_lock);
-
-	(*sizep) = size;
-	return (retaddr);
-}
-
-
-/*
- * nsc_mem_t *
- * _nsc_rm_free (void *addr, size_t size)
- *	Free an area of RM.
- *
- * Calling/Exit State:
- *	Returns 0 on success, -1 on failure.
- */
-static int
-_nsc_rm_free(void *addr, size_t size)
-{
-	caddr_t caddr = (caddr_t)addr;
-	nsc_mem_t *mp;
-
-	mutex_enter(&_nsc_mem_lock);
-
-	for (mp = _nsc_mem_top; mp; mp = mp->next)
-		if (mp->base == caddr)
-			break;
-
-	if (!mp) {
-		mutex_exit(&_nsc_mem_lock);
-		return (-1);
-	}
-
-	mp->nfree++;
-	mp->used -= size;
-	mp->pages -= btopr(size);
-	mp->pend = 1;
-
-	if (!mp->used)
-		mp->base = 0;
-
-	mutex_exit(&_nsc_mem_lock);
-
-	if (_nsc_global_map)
-		_nsc_rmmap_free(_nsc_global_map, mp->name, mp);
-
-	_nsc_mark_pages(addr, size, 0);
-
-	mp->pend = 0;
-	return (0);
-}
-
-
-/*
- * static size_t
- * _nsc_rm_avail (mem)
- *	Amount of RM available.
- *
- * Calling/Exit State:
- *	Returns 0 if the specified category has already been
- *	allocated. Returns the size of the region if it already
- *	exists, otherwise the number of bytes of global memory
- *	available.
- */
-static size_t
-_nsc_rm_avail(nsc_mem_t *mem)
-{
-	size_t size;
-
-	if (!_nsc_global_map || mem->base || mem->pend)
-		return (0);
-
-	if ((size = _nsc_rmmap_size(_nsc_global_map, mem->name)) != 0)
-		return (size);
-
-	return (_nsc_rmmap_avail(_nsc_global_map));
-}
-
-
-/*
- * nvram support
- * given a map address, return the address of the copy
- * in nvram.
- * Assumes that _nsc_rm_nvmem_base is valid.
- */
-nsc_rmmap_t *
-_nsc_global_nvmemmap_lookup(nsc_rmmap_t *hp)
-{
-	size_t offset;
-
-	/* LINTED */
-	offset = (caddr_t)hp - _nsc_rm_base;
-	return ((nsc_rmmap_t *)(_nsc_rm_nvmem_base + offset));
-}
-
-int
-_nsc_get_global_sizes(void *arg, int *rvp)
-{
-	if (!_nsc_rmhdr_ptr)
-		return (EINVAL);
-
-	if (copyout(&_nsc_rmhdr_ptr->size, arg,
-	    sizeof (_nsc_rmhdr_ptr->size)) < 0)
-		return (EFAULT);
-
-	*rvp = 0;
-	return (0);
-}
-
-int
-_nsc_get_global_data(void *arg, int *rvp)
-{
-	size_t size;
-
-	if (!_nsc_rmhdr_ptr)
-		return (EINVAL);
-
-	size = _nsc_rmhdr_ptr->size;
-
-	if (copyout(_nsc_rmhdr_ptr, arg, size) < 0)
-		return (EFAULT);
-
-	if (_nsc_rm_nvmem_base) {
-		char *taddr;
-
-		if ((taddr = kmem_alloc(size, KM_NOSLEEP)) == NULL)
-			return (ENOMEM);
-
-		if (copyout(taddr, (char *)arg + size, size) < 0) {
-			kmem_free(taddr, size);
-			return (EFAULT);
-		}
-
-		kmem_free(taddr, size);
-	}
-
-	*rvp = 0;
-	return (0);
-}
