/***********************************************************************

*                                                                      *

*               This software is part of the ast package               *

*          Copyright (c) 1985-2012 AT&T Intellectual Property          *

*                      and is licensed under the                       *

*                 Eclipse Public License, Version 1.0                  *

*                    by AT&T Intellectual Property                     *

*                                                                      *

*                A copy of the License is available at                 *

*          http://www.eclipse.org/org/documents/epl-v10.html           *

*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *

*                                                                      *

*              Information and Software Systems Research               *

*                            AT&T Research                             *

*                           Florham Park NJ                            *

*                                                                      *

*                 Glenn Fowler <gsf@research.att.com>                  *

*                  David Korn <dgk@research.att.com>                   *

*                   Phong Vo <kpv@research.att.com>                    *

*                                                                      *

***********************************************************************/

#if defined(_UWIN) && defined(_BLD_ast)

void _STUB_vmdebug(){}

#else

#include	"vmhdr.h"

/*	Method to help with debugging. This does rigorous checks on

**	addresses and arena integrity.

**

**	Written by Kiem-Phong Vo, kpv@research.att.com, 01/16/94.

*/

/* structure to keep track of file names */

typedef struct _dbfile_s	Dbfile_t;

struct _dbfile_s

{	Dbfile_t*	next;

	char		file[1];

};

static Dbfile_t*	Dbfile;

/* global watch list */

#define S_WATCH	32

static int	Dbnwatch;

static Void_t*	Dbwatch[S_WATCH];

/* types of warnings reported by dbwarn() */

#define	DB_CHECK	0

#define DB_ALLOC	1

#define DB_FREE		2

#define DB_RESIZE	3

#define DB_WATCH	4

#define DB_RESIZED	5

static int Dbinit = 0;

#define DBINIT()	(Dbinit ? 0 : (dbinit(), Dbinit=1) )

static void dbinit()

{	int	fd;	

	if((fd = vmtrace(-1)) >= 0)

		vmtrace(fd);

}

static int	Dbfd = 2;	/* default warning file descriptor */

#if __STD_C

int vmdebug(int fd)

#else

int vmdebug(fd)

int	fd;

#endif

{

	int	old = Dbfd;

	Dbfd = fd;

	return old;

}

/* just an entry point to make it easy to set break point */

#if __STD_C

static void vmdbwarn(Vmalloc_t* vm, char* mesg, int n)

#else

static void vmdbwarn(vm, mesg, n)

Vmalloc_t*	vm;

char*		mesg;

int		n;

#endif

{

	reg Vmdata_t*	vd = vm->data;

	write(Dbfd,mesg,n);

	if(vd->mode&VM_DBABORT)

		abort();

}

/* issue a warning of some type */

#if __STD_C

static void dbwarn(Vmalloc_t* vm, Void_t* data, int where,

		   char* file, int line, Void_t* func, int type)

#else

static void dbwarn(vm, data, where, file, line, func, type)

Vmalloc_t*	vm;	/* region holding the block	*/

Void_t*		data;	/* data block			*/

int		where;	/* byte that was corrupted	*/

char*		file;	/* file where call originates	*/

int		line;	/* line number of call		*/

Void_t*		func;	/* function called from		*/

int		type;	/* operation being done		*/

#endif

{

	char	buf[1024], *bufp, *endbuf, *s;

#define SLOP	64	/* enough for a message and an int */

	DBINIT();

	bufp = buf;

	endbuf = buf + sizeof(buf);

	if(type == DB_ALLOC)

		bufp = (*_Vmstrcpy)(bufp, "alloc error", ':');

	else if(type == DB_FREE)

		bufp = (*_Vmstrcpy)(bufp, "free error", ':');

	else if(type == DB_RESIZE)

		bufp = (*_Vmstrcpy)(bufp, "resize error", ':');

	else if(type == DB_CHECK)

		bufp = (*_Vmstrcpy)(bufp, "corrupted data", ':');

	else if(type == DB_WATCH)

		bufp = (*_Vmstrcpy)(bufp, "alert", ':');

	/* region info */

	bufp = (*_Vmstrcpy)(bufp, "region", '=');

	bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(vm), 0), ':');

	if(data)

	{	bufp = (*_Vmstrcpy)(bufp,"block",'=');

		bufp = (*_Vmstrcpy)(bufp,(*_Vmitoa)(VLONG(data),0),':');

	}

	if(!data)

	{	if(where == DB_ALLOC)

			bufp = (*_Vmstrcpy)(bufp, "can't get memory", ':');

		else	bufp = (*_Vmstrcpy)(bufp, "region is locked", ':');

	}

	else if(type == DB_FREE || type == DB_RESIZE)

	{	if(where == 0)

			bufp = (*_Vmstrcpy)(bufp, "unallocated block", ':');

		else	bufp = (*_Vmstrcpy)(bufp, "already freed", ':');

	}

	else if(type == DB_WATCH)

	{	bufp = (*_Vmstrcpy)(bufp, "size", '=');

		bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)((Vmulong_t)DBSIZE(data),-1), ':');

		if(where == DB_ALLOC)

			bufp = (*_Vmstrcpy)(bufp,"just allocated", ':');

		else if(where == DB_FREE)

			bufp = (*_Vmstrcpy)(bufp,"being freed", ':');

		else if(where == DB_RESIZE)

			bufp = (*_Vmstrcpy)(bufp,"being resized", ':');

		else if(where == DB_RESIZED)

			bufp = (*_Vmstrcpy)(bufp,"just resized", ':');

	}

	else if(type == DB_CHECK)

	{	bufp = (*_Vmstrcpy)(bufp, "bad byte at", '=');

		bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(where),-1), ':');

		if((s = DBFILE(data)) && (bufp + strlen(s) + SLOP) < endbuf)

		{	bufp = (*_Vmstrcpy)(bufp,"allocated at", '=');

			bufp = (*_Vmstrcpy)(bufp, s, ',');

			bufp = (*_Vmstrcpy)(bufp,(*_Vmitoa)(VLONG(DBLINE(data)),-1),':');

		}

	}

	/* location where offending call originates from */

	if(file && file[0] && line > 0 && (bufp + strlen(file) + SLOP) < endbuf)

	{	bufp = (*_Vmstrcpy)(bufp, "detected at", '=');

		bufp = (*_Vmstrcpy)(bufp, file, ',');

		bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(line),-1), ',');

		bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(func),-1), ':');

	}

	*bufp++ = '\n';

	*bufp = '\0';

	vmdbwarn(vm,buf,(int)(bufp-buf));

}

/* check for watched address and issue warnings */

#if __STD_C

static void dbwatch(Vmalloc_t* vm, Void_t* data,

		    char* file, int line, Void_t* func, int type)

#else

static void dbwatch(vm, data, file, line, func, type)

Vmalloc_t*	vm;

Void_t*		data;

char*		file;

int		line;

Void_t*		func;

int		type;

#endif

{

	reg int		n;

	for(n = Dbnwatch; n >= 0; --n)

	{	if(Dbwatch[n] == data)

		{	dbwarn(vm,data,type,file,line,func,DB_WATCH);

			return;

		}

	}

}

/* record information about the block */

#if __STD_C

static void dbsetinfo(Vmuchar_t* data, size_t size, char* file, int line)

#else

static void dbsetinfo(data, size, file, line)

Vmuchar_t*	data;	/* real address not the one from Vmbest	*/

size_t		size;	/* the actual requested size		*/

char*		file;	/* file where the request came from	*/

int		line;	/* and line number			*/

#endif

{

	reg Vmuchar_t	*begp, *endp;

	reg Dbfile_t	*last, *db;

	DBINIT();

	/* find the file structure */

	if(!file || !file[0])

		db = NIL(Dbfile_t*);

	else

	{	for(last = NIL(Dbfile_t*), db = Dbfile; db; last = db, db = db->next)

			if(strcmp(db->file,file) == 0)

				break;

		if(!db)

		{	db = (Dbfile_t*)vmalloc(Vmheap,sizeof(Dbfile_t)+strlen(file));

			if(db)

			{	(*_Vmstrcpy)(db->file,file,0);

				db->next = Dbfile;

				Dbfile = db;

			}

		}

		else if(last) /* move-to-front heuristic */

		{	last->next = db->next;

			db->next = Dbfile;

			Dbfile = db;

		}

	}

	DBSETFL(data,(db ? db->file : NIL(char*)),line);

	DBSIZE(data) = size;

	DBSEG(data)  = SEG(DBBLOCK(data));

	DBHEAD(data,begp,endp);

	while(begp < endp)

		*begp++ = DB_MAGIC;

	DBTAIL(data,begp,endp);

	while(begp < endp)

		*begp++ = DB_MAGIC;

}

/* Check to see if an address is in some data block of a region.

** This returns -(offset+1) if block is already freed, +(offset+1)

** if block is live, 0 if no match.

*/

#if __STD_C

static long dbaddr(Vmalloc_t* vm, Void_t* addr, int local)

#else

static long dbaddr(vm, addr, local)

Vmalloc_t*	vm;

Void_t*		addr;

int		local;

#endif

{

	reg Block_t	*b, *endb;

	reg Seg_t	*seg;

	reg Vmuchar_t	*data;

	reg long	offset = -1L;

	reg Vmdata_t	*vd = vm->data;

	SETLOCK(vm, local);

	b = endb = NIL(Block_t*);

	for(seg = vd->seg; seg; seg = seg->next)

	{	b = SEGBLOCK(seg);

		endb = (Block_t*)(seg->baddr - sizeof(Head_t));

		if((Vmuchar_t*)addr > (Vmuchar_t*)b &&

		   (Vmuchar_t*)addr < (Vmuchar_t*)endb)

			break;

	}

	if(!seg)

		goto done;

	if(local) /* must be vmfree or vmresize checking address */

	{	if(DBSEG(addr) == seg)

		{	b = DBBLOCK(addr);

			if(ISBUSY(SIZE(b)) && !ISJUNK(SIZE(b)) )

				offset = 0;

			else	offset = -2L;

		}

		goto done;

	}

	while(b < endb)

	{	data = (Vmuchar_t*)DATA(b);

		if((Vmuchar_t*)addr >= data && (Vmuchar_t*)addr < data+SIZE(b))

		{	if(ISBUSY(SIZE(b)) && !ISJUNK(SIZE(b)) )

			{	data = DB2DEBUG(data);

				if((Vmuchar_t*)addr >= data &&

				   (Vmuchar_t*)addr < data+DBSIZE(data))

					offset = (long)((Vmuchar_t*)addr - data);

			}

			goto done;

		}

		b = (Block_t*)((Vmuchar_t*)DATA(b) + (SIZE(b)&~BITS) );

	}

done:

	CLRLOCK(vm, local);

	return offset;

}

#if __STD_C

static long dbsize(Vmalloc_t* vm, Void_t* addr, int local)

#else

static long dbsize(vm, addr, local)

Vmalloc_t*	vm;

Void_t*		addr;

int		local;

#endif

{

	Block_t		*b, *endb;

	Seg_t		*seg;

	long		size;

	Vmdata_t	*vd = vm->data;

	SETLOCK(vm, local);

	size = -1L;

	for(seg = vd->seg; seg; seg = seg->next)

	{	b = SEGBLOCK(seg);

		endb = (Block_t*)(seg->baddr - sizeof(Head_t));

		if((Vmuchar_t*)addr <= (Vmuchar_t*)b ||

		   (Vmuchar_t*)addr >= (Vmuchar_t*)endb)

			continue;

		while(b < endb)

		{	if(addr == (Void_t*)DB2DEBUG(DATA(b)))

			{	if(ISBUSY(SIZE(b)) && !ISJUNK(SIZE(b)) )

					size = (long)DBSIZE(addr);

				goto done;

			}

			b = (Block_t*)((Vmuchar_t*)DATA(b) + (SIZE(b)&~BITS) );

		}

	}

done:

	CLRLOCK(vm, local);

	return size;

}

#if __STD_C

static Void_t* dballoc(Vmalloc_t* vm, size_t size, int local)

#else

static Void_t* dballoc(vm, size, local)

Vmalloc_t*	vm;

size_t		size;

int		local;

#endif

{

	size_t		s;

	Vmuchar_t	*data;

	char		*file;

	int		line;

	Void_t		*func;

	Vmdata_t	*vd = vm->data;

	VMFLF(vm,file,line,func);

	SETLOCK(vm, local);

	if(vd->mode&VM_DBCHECK)

		vmdbcheck(vm);

	s = ROUND(size,ALIGN) + DB_EXTRA;

	if(s < sizeof(Body_t))	/* no tiny blocks during Vmdebug */

		s = sizeof(Body_t);

	if(!(data = (Vmuchar_t*)KPVALLOC(vm,s,(*(Vmbest->allocf))) ) )

	{	dbwarn(vm,NIL(Vmuchar_t*),DB_ALLOC,file,line,func,DB_ALLOC);

		goto done;

	}

	data = DB2DEBUG(data);

	dbsetinfo(data,size,file,line);

	if((vd->mode&VM_TRACE) && _Vmtrace)

	{	vm->file = file; vm->line = line; vm->func = func;

		(*_Vmtrace)(vm,NIL(Vmuchar_t*),data,size,0);

	}

	if(Dbnwatch > 0 )

		dbwatch(vm,data,file,line,func,DB_ALLOC);

done:

	CLRLOCK(vm, local);

	return (Void_t*)data;

}

#if __STD_C

static int dbfree(Vmalloc_t* vm, Void_t* data, int local )

#else

static int dbfree(vm, data, local )

Vmalloc_t*	vm;

Void_t*		data;

int		local;

#endif

{

	char		*file;

	int		line;

	Void_t		*func;

	long		offset;

	int		rv, *ip, *endip;

	Vmdata_t	*vd = vm->data;

	VMFLF(vm,file,line,func);

	if(!data)

		return 0;

	SETLOCK(vm, local);

	if(vd->mode&VM_DBCHECK)

		vmdbcheck(vm);

	if((offset = KPVADDR(vm,data,dbaddr)) != 0)

	{	dbwarn(vm,(Vmuchar_t*)data,offset == -1L ? 0 : 1,file,line,func,DB_FREE);

		rv = -1;

	}

	else

	{	if(Dbnwatch > 0)

			dbwatch(vm,data,file,line,func,DB_FREE);

		if((vd->mode&VM_TRACE) && _Vmtrace)

		{	vm->file = file; vm->line = line; vm->func = func;

			(*_Vmtrace)(vm,(Vmuchar_t*)data,NIL(Vmuchar_t*),DBSIZE(data),0);

		}

		/* clear free space */

		ip = (int*)data;

		endip = ip + (DBSIZE(data)+sizeof(int)-1)/sizeof(int);

		while(ip < endip)

			*ip++ = 0;

		rv = KPVFREE((vm), (Void_t*)DB2BEST(data), (*Vmbest->freef));

	}

	CLRLOCK(vm, local);

	return rv;

}

/*	Resizing an existing block */

#if __STD_C

static Void_t* dbresize(Vmalloc_t* vm, Void_t* addr, reg size_t size, int type, int local)

#else

static Void_t* dbresize(vm, addr, size, type, local)

Vmalloc_t*	vm;	/* region allocating from	*/

Void_t*		addr;	/* old block of data		*/

reg size_t	size;	/* new size			*/

int		type;	/* !=0 for movable, >0 for copy	*/

int		local;

#endif

{

	Vmuchar_t	*data;

	long		offset;

	size_t		s, oldsize;

	char		*file, *oldfile;

	int		line, oldline;

	Void_t		*func;

	Vmdata_t	*vd = vm->data;

	VMFLF(vm,file,line,func);

	if(!addr)

	{	vm->file = file; vm->line = line;

		data = (Vmuchar_t*)dballoc(vm, size, local);

		if(data && (type&VM_RSZERO) )

			memset((Void_t*)data, 0, size);

		return data;

	}

	if(size == 0)

	{	vm->file = file; vm->line = line;

		(void)dbfree(vm, addr, local);

		return NIL(Void_t*);

	}

	SETLOCK(vm, local);

	if(vd->mode&VM_DBCHECK)

		vmdbcheck(vm);

	if((offset = KPVADDR(vm,addr,dbaddr)) != 0)

	{	dbwarn(vm,(Vmuchar_t*)addr,offset == -1L ? 0 : 1,file,line,func,DB_RESIZE);

		data = NIL(Vmuchar_t*);

	}

	else

	{	if(Dbnwatch > 0)

			dbwatch(vm,addr,file,line,func,DB_RESIZE);

		/* Vmbest data block */

		data = DB2BEST(addr);

		oldsize = DBSIZE(addr);

		oldfile = DBFILE(addr);

		oldline = DBLINE(addr);

		/* do the resize */

		s = ROUND(size,ALIGN) + DB_EXTRA;

		if(s < sizeof(Body_t))

			s = sizeof(Body_t);

		data = (Vmuchar_t*)KPVRESIZE(vm,(Void_t*)data,s,

					 (type&~VM_RSZERO),(*(Vmbest->resizef)) );

		if(!data) /* failed, reset data for old block */

		{	dbwarn(vm,NIL(Vmuchar_t*),DB_ALLOC,file,line,func,DB_RESIZE);

			dbsetinfo((Vmuchar_t*)addr,oldsize,oldfile,oldline);

		}

		else

		{	data = DB2DEBUG(data);

			dbsetinfo(data,size,file,line);

			if((vd->mode&VM_TRACE) && _Vmtrace)

			{	vm->file = file; vm->line = line;

				(*_Vmtrace)(vm,(Vmuchar_t*)addr,data,size,0);

			}

			if(Dbnwatch > 0)

				dbwatch(vm,data,file,line,func,DB_RESIZED);

		}

		if(data && (type&VM_RSZERO) && size > oldsize)

		{	Vmuchar_t *d = data+oldsize, *ed = data+size;

			do { *d++ = 0; } while(d < ed);

		}

	}

	CLRLOCK(vm, local);

	return (Void_t*)data;

}

/* compact any residual free space */

#if __STD_C

static int dbcompact(Vmalloc_t* vm, int local)

#else

static int dbcompact(vm, local)

Vmalloc_t*	vm;

int		local;

#endif

{

	return (*(Vmbest->compactf))(vm, local);

}

/* check for memory overwrites over all live blocks */

#if __STD_C

int vmdbcheck(Vmalloc_t* vm)

#else

int vmdbcheck(vm)

Vmalloc_t*	vm;

#endif

{

	reg Block_t	*b, *endb;

	reg Seg_t*	seg;

	int		rv;

	reg Vmdata_t*	vd = vm->data;

	/* check the meta-data of this region */

	if(vd->mode & (VM_MTDEBUG|VM_MTBEST|VM_MTPROFILE))

	{	if(_vmbestcheck(vd, NIL(Block_t*)) < 0)

			return -1;

		if(!(vd->mode&VM_MTDEBUG) )

			return 0;

	}

	else	return -1;

	rv = 0;

	for(seg = vd->seg; seg; seg = seg->next)

	{	b = SEGBLOCK(seg);

		endb = (Block_t*)(seg->baddr - sizeof(Head_t));

		while(b < endb)

		{	reg Vmuchar_t	*data, *begp, *endp;

			if(ISJUNK(SIZE(b)) || !ISBUSY(SIZE(b)))

				goto next;

			data = DB2DEBUG(DATA(b));

			if(DBISBAD(data))	/* seen this before */

			{	rv += 1;

				goto next;

			}

			DBHEAD(data,begp,endp);

			for(; begp < endp; ++begp)

				if(*begp != DB_MAGIC)

					goto set_bad;

			DBTAIL(data,begp,endp);

			for(; begp < endp; ++begp)

			{	if(*begp == DB_MAGIC)

					continue;

			set_bad:

				dbwarn(vm,data,(long)(begp-data),vm->file,vm->line,0,DB_CHECK);

				DBSETBAD(data);

				rv += 1;

				goto next;

			}

		next:	b = (Block_t*)((Vmuchar_t*)DATA(b) + (SIZE(b)&~BITS));

		}

	}

	return rv;

}

/* set/delete an address to watch */

#if __STD_C

Void_t* vmdbwatch(Void_t* addr)

#else

Void_t* vmdbwatch(addr)

Void_t*		addr;	/* address to insert	*/

#endif

{

	reg int		n;

	reg Void_t*	out;

	out = NIL(Void_t*);

	if(!addr)

		Dbnwatch = 0;

	else

	{	for(n = Dbnwatch - 1; n >= 0; --n)

			if(Dbwatch[n] == addr)

				break;

		if(n < 0)	/* insert */

		{	if(Dbnwatch == S_WATCH)	

			{	/* delete left-most */

				out = Dbwatch[0];

				Dbnwatch -= 1;

				for(n = 0; n < Dbnwatch; ++n)

					Dbwatch[n] = Dbwatch[n+1];

			}

			Dbwatch[Dbnwatch] = addr;

			Dbnwatch += 1;

		}

	}

	return out;

}

#if __STD_C

static Void_t* dbalign(Vmalloc_t* vm, size_t size, size_t align, int local)

#else

static Void_t* dbalign(vm, size, align, local)

Vmalloc_t*	vm;

size_t		size;

size_t		align;

int		local;

#endif

{

	Vmuchar_t	*data;

	size_t		s;

	char		*file;

	int		line;

	Void_t		*func;

	Vmdata_t	*vd = vm->data;

	VMFLF(vm,file,line,func);

	if(size <= 0 || align <= 0)

		return NIL(Void_t*);

	SETLOCK(vm, local);

	if((s = ROUND(size,ALIGN) + DB_EXTRA) < sizeof(Body_t))

		s = sizeof(Body_t);

	if((data = (Vmuchar_t*)KPVALIGN(vm,s,align,(*(Vmbest->alignf)))) )

	{	data += DB_HEAD;

		dbsetinfo(data,size,file,line);

		if((vd->mode&VM_TRACE) && _Vmtrace)

		{	vm->file = file; vm->line = line; vm->func = func;

			(*_Vmtrace)(vm,NIL(Vmuchar_t*),data,size,align);

		}

	}

	CLRLOCK(vm, local);

	return (Void_t*)data;

}

/* print statistics of region vm. If vm is NULL, use Vmregion */

#if __STD_C

ssize_t vmdbstat(Vmalloc_t* vm)

#else

ssize_t vmdbstat(vm)

Vmalloc_t*	vm;

#endif

{	Vmstat_t	st;

	char		buf[1024], *bufp;

	vmstat(vm ? vm : Vmregion, &st);

	bufp = buf;

	bufp = (*_Vmstrcpy)(bufp, "n_busy", '=');

	bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.n_busy),-1), ',');

	bufp = (*_Vmstrcpy)(bufp, " s_busy", '=');

	bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.s_busy),-1), '\n');

	bufp = (*_Vmstrcpy)(bufp, "n_free", '=');

	bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.n_free),-1), ',');

	bufp = (*_Vmstrcpy)(bufp, " s_free", '=');

	bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.s_free),-1), '\n');

	bufp = (*_Vmstrcpy)(bufp, "m_busy", '=');

	bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.m_busy),-1), ',');

	bufp = (*_Vmstrcpy)(bufp, " m_free", '=');

	bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.m_free),-1), '\n');

	bufp = (*_Vmstrcpy)(bufp, "n_segment", '=');

	bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.n_seg),-1), ',');

	bufp = (*_Vmstrcpy)(bufp, " extent", '=');

	bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.extent),-1), '\n');

	*bufp = 0;

	write(Dbfd, buf, strlen(buf));

	return strlen(buf);

}

static Vmethod_t _Vmdebug =

{

	dballoc,

	dbresize,

	dbfree,

	dbaddr,

	dbsize,

	dbcompact,

	dbalign,

	VM_MTDEBUG

};

__DEFINE__(Vmethod_t*,Vmdebug,&_Vmdebug);

#ifdef NoF

NoF(vmdebug)

#endif

#endif