xref: /titanic_44/usr/src/lib/libast/common/features/mmap (revision da2e3ebdc1edfbc5028edf1354e7dd2fa69a7968)

ref	-D_def_map_ast=1

sys	mman

tst	lib_mmap note{ standard mmap interface that works }end execute{
	#include <unistd.h>
	#include <fcntl.h>
	#include <sys/types.h>
	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <sys/times.h>

	#define MAPSIZE (64*1024)
	#define BUFSIZE	(8*1024)
	#define WRITE   (64)

	#define Failed(file)	(remove(file),1)

	int
	#if _STD_
	main(int argc, char** argv)
	#else
	main(argc,argv)
	int     argc;
	char**  argv;
	#endif
	{
		caddr_t		mm;
		char		*t, *u, *f;
		int		i, fd, okfixed;
		char		file[1024], buf[MAPSIZE];
		struct tms	stm, etm;
		clock_t		rdtm, mmtm;

		/* create data file in a local fs if possible */
		t = file;
		if (access(f = "/tmp", 0) == 0 ||
		    access(f = "/usr/tmp", 0) == 0)
		{
			while (*t = *f++)
				t++;
			*t++ = '/';
		}
		u = t;
		f = argv[0];
		while (*t = *f++)
			if (*t == '/')
				t = u;
			else if (*t != '.')
				t++;
		*t++ = '.'; *t++ = 'D'; *t = 0;
		if ((fd = open(file, O_CREAT|O_TRUNC|O_WRONLY, 0666)) < 0)
			return 1;

		for (i = 0; i < sizeof(buf); ++i)
			buf[i] = '0' + (i%10);
		for (i = 0; i < WRITE; ++i)
			if (write(fd,buf,sizeof(buf)) != sizeof(buf))
				return Failed(file);
		close(fd);

		/* see if can overwrite fixed map */
	#ifndef MAP_VARIABLE
	#define MAP_VARIABLE	0
	#endif
		if ((fd = open(file, O_RDWR)) < 0)
			return Failed(file);

		mm = mmap((caddr_t)0, sizeof(buf), (PROT_READ|PROT_WRITE),
			  (MAP_PRIVATE|MAP_VARIABLE), fd, 0);
		if(mm == (caddr_t)0 || mm == (caddr_t)(-1))
			return Failed(file);
		mm = mmap(mm, sizeof(buf), (PROT_READ|PROT_WRITE),
			  (MAP_PRIVATE|MAP_FIXED), fd, 0);
		okfixed = (mm == (caddr_t)0 || mm == (caddr_t)(-1)) ? 0 : 1;
		munmap(mm, sizeof(buf));
		close(fd);

		/* read time */
		if((fd = open(file,  O_RDWR)) < 0)
			return Failed(file);
		times(&stm);
		for (i = 0; i < WRITE; ++i)
			if (read(fd,buf,BUFSIZE) != BUFSIZE)
				return Failed(file);
		times(&etm);
		close(fd);
		rdtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_stime);

		/* mmap time */
		if ((fd = open(file, O_RDWR)) < 0)
			return Failed(file);
		times(&stm);
		for(i = 0, mm = (caddr_t)0; i < WRITE; ++i)
		{	if(okfixed)
			{	mm = (caddr_t)mmap(mm, MAPSIZE,
					(PROT_READ|PROT_WRITE),
					(MAP_PRIVATE | (mm ? MAP_FIXED : MAP_VARIABLE)),
					fd, i*MAPSIZE );
			}
			else
			{	if(mm)
					munmap(mm, MAPSIZE);
				mm = (caddr_t)mmap((caddr_t)0, MAPSIZE,
					(PROT_READ|PROT_WRITE),
					(MAP_PRIVATE|MAP_VARIABLE),
					fd, i*MAPSIZE );
			}
			if(mm == (caddr_t)(-1) || mm == (caddr_t)0)
				return Failed(file);
		}
		times(&etm);
		close(fd);
		remove(file);
		mmtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_stime);

		return rdtm+60 < mmtm ? 1 : 0;
	}
}end

tst	lib_mmap64 -D_LARGEFILE64_SOURCE note{ mmap64 interface and implementation work }end execute{
	#if !_lib_mmap
	(
	#endif

	#include <unistd.h>
	#include <fcntl.h>
	#include <sys/types.h>
	#include <sys/mman.h>
	#include <sys/stat.h>

	int
	main()
	{
	        off64_t         off;
	        int             fd;
	        int             n;
	        char*           s;
		struct stat64	st;
	        char            file[32] = {'/','t','m','p','/','m','m','X','X','X','X','X','X'};

		/* hey, stubs are supposed to fail! */
		if (stat64(".", &st) || !st.st_mode || !st.st_mtime)
			return 1;
	        if (!mktemp(file) || (fd = open64(file, O_CREAT|O_WRONLY, 0600)) < 0)
	        {
	                remove(file);
	                return 1;
	        }
	        off = (1<<8);
	        off *= off;
	        if (lseek64(fd, off, SEEK_SET) != off)
	        {
	                remove(file);
	                return 1;
	        }
	        n = strlen(file) + 1;
	        if (write(fd, file, n) != n)
	        {
	                remove(file);
	                return 1;
	        }
	        if (close(fd) < 0 || (fd = open64(file, O_RDWR)) < 0)
	        {
	                remove(file);
	                return 1;
	        }
	        if (!(s = mmap64((caddr_t)0, (size_t)n, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, off)))
	        {
	                remove(file);
	                return 1;
	        }
	        if (strcmp(s, file))
	        {
	                remove(file);
	                return 1;
	        }
	        close(fd);
	        remove(file);
	        return 0;
	}
}end

tst	mmap_anon note{ use mmap MAP_ANON to get raw memory }end execute{
	#if !_lib_mmap
	(
	#endif
	#include <unistd.h>
	#include <fcntl.h>
	#include <sys/types.h>
	#include <sys/mman.h>
	#if defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
	#define MAP_ANON	MAP_ANONYMOUS
	#endif
	int
	main()
	{	void	*addr;
		addr = mmap(0,1024*1024,PROT_READ|PROT_WRITE,MAP_ANON|MAP_PRIVATE,-1,0);
		return (addr && addr != (void*)(-1)) ? 0 : 1;
	}
}end

tst	mmap_devzero note{ use mmap on /dev/zero to get raw memory }end execute{
	#if !_lib_mmap
	(
	#endif
	#include <unistd.h>
	#include <fcntl.h>
	#include <sys/types.h>
	#include <sys/mman.h>
	int
	main()
	{	int	fd;
		void	*addr;
		if((fd = open("/dev/zero", O_RDWR)) < 0)
			return 1;
		addr = mmap(0,1024*1024,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);
		return (addr && addr != (void*)(-1)) ? 0 : 1;
	}
}end

tst	note{ mmap is worth using }end output{
	#if !_lib_mmap
	(
	#endif
	#include <unistd.h>
	#include <fcntl.h>
	#include <sys/types.h>
	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <sys/times.h>

	#define MAPSIZE (64*1024)
	#define BUFSIZE	(MAPSIZE/8)
	#define WRITE   (64)
	#define RUN	(64)

	#define Failed(file)	(remove(file),1)

	int
	#if _STD_
	main(int argc, char** argv)
	#else
	main(argc,argv)
	int     argc;
	char**  argv;
	#endif
	{
		caddr_t		mm;
		char		*t, *f;
		int		i, fd, k, run;
		char		file[1024], buf[MAPSIZE];
		struct tms	stm, etm;
		clock_t		rdtm, mmtm;

		/* create data file */
		f = argv[0]; t = file;
		while (*t = *f++)
			t++;
		*t++ = '.'; *t++ = 'D'; *t = 0;
		if ((fd = open(file, O_CREAT|O_TRUNC|O_WRONLY, 0666)) < 0)
			return 1;

		for (i = 0; i < sizeof(buf); ++i)
			buf[i] = '0' + (i%10);
		for (i = 0; i < WRITE; ++i)
			if (write(fd,buf,sizeof(buf)) != sizeof(buf))
				return Failed(file);
		close(fd);

		/* read time */
		times(&stm);
		for(run = 0; run < RUN; ++run)
		{	if((fd = open(file, O_RDWR)) < 0)
				return Failed(file);
			for (i = 0; i < WRITE; ++i)
			{	for(k = 0; k < MAPSIZE; k += BUFSIZE)
					if (read(fd,buf,BUFSIZE) != BUFSIZE)
						return Failed(file);
			}
			close(fd);
		}
		times(&etm);
		rdtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_stime);

		/* mmap time */
		times(&stm);
		for(run = 0; run < RUN; ++run)
		{	if ((fd = open(file, O_RDWR)) < 0)
				return Failed(file);
			for(i = 0, mm = (caddr_t)0; i < WRITE; ++i)
			{	if(mm)
					munmap(mm, MAPSIZE);
				mm = (caddr_t)mmap((caddr_t)0, MAPSIZE,
						   (PROT_READ|PROT_WRITE),
						   MAP_PRIVATE, fd, i*MAPSIZE );
				if(mm == (caddr_t)(-1) || mm == (caddr_t)0)
					return Failed(file);

				/* the memcpy is < BUFSIZE to simulate the
				   fact that functions like sfreserve/sfgetr do
				   not do buffer copying.
				*/
				t = (char*)mm;
				for(k = 0; k < MAPSIZE; k += BUFSIZE, t += BUFSIZE)
					memcpy(buf,t,(3*BUFSIZE)/4);
			}
			close(fd);
		}
		times(&etm);
		mmtm = (etm.tms_utime-stm.tms_utime) + (etm.tms_stime-stm.tms_stime);

		remove(file);

		if(4*mmtm <= 3*rdtm)
			printf("#define _mmap_worthy	2	/* mmap is great */\n");
		else if(4*mmtm <= 5*rdtm)
			printf("#define _mmap_worthy	1	/* mmap is good */\n");

		else
			return 1;
		return 0;
	}
}end

cat{

	/* some systems get it wrong but escape concise detection */
	#ifndef _NO_MMAP
	#if __CYGWIN__
	#define _NO_MMAP	1
	#endif
	#endif

	#if _NO_MMAP
	#undef	_lib_mmap
	#undef	_lib_mmap64
	#undef	_mmap_anon
	#undef	_mmap_devzero
	#undef	_mmap_worthy
	#endif
}end