*** fileio.c.dist	Sun Jun 11 22:06:34 2000
--- fileio.c	Mon Jul  7 17:07:07 2003
***************
*** 227,232 ****
--- 227,262 ----
  }
  
  static int
+ copy_in_flock64(struct lx_flock64 *from, struct flock64 *to)
+ {
+ 	if (! verify_read(from, sizeof(*from)))
+ 		return -1;
+ 
+ 	switch (from->l_type)
+ 	{
+ 		case LX_F_RDLCK:
+ 			to->l_type = F_RDLCK;
+ 			break;
+ 		case LX_F_WRLCK:
+ 			to->l_type = F_WRLCK;
+ 			break;
+ 		case LX_F_UNLCK:
+ 			to->l_type = F_UNLCK;
+ 			break;
+ 		default:
+ 		    return enoany(EINVAL,
+ 				  "copy_in_flock - unknown from->l_type");
+ 	}
+ 
+ 	to->l_whence	= from->l_whence;
+ 	to->l_start	= from->l_start;
+ 	to->l_len	= from->l_len;
+ 	to->l_pid	= from->l_pid;
+ 
+ 	return 0;
+ }
+ 
+ static int
  copy_out_flock(struct flock *from, struct lx_flock *to)
  {
  	if (! verify_write(to, sizeof(*to)))
***************
*** 256,261 ****
--- 286,321 ----
  	return 0;
  }
  
+ static int
+ copy_out_flock64(struct flock64 *from, struct lx_flock64 *to)
+ {
+ 	if (! verify_write(to, sizeof(*to)))
+ 		return -1;
+ 
+ 	switch (from->l_type)
+ 	{
+ 		case F_RDLCK:
+ 			to->l_type = LX_F_RDLCK;
+ 			break;
+ 		case F_WRLCK:
+ 			to->l_type = LX_F_WRLCK;
+ 			break;
+ 		case F_UNLCK:
+ 			to->l_type = LX_F_UNLCK;
+ 			break;
+ 		default:
+ 		    return enoany(EINVAL,
+ 				  "copy_out_flock - unknown from->l_type");
+ 	}
+ 
+ 	to->l_whence	= from->l_whence;
+ 	to->l_start	= from->l_start;
+ 	to->l_len	= from->l_len;
+ 	to->l_pid	= from->l_pid;
+ 
+ 	return 0;
+ }
+ 
  #if defined(SOLARIS) || defined(OSR5)
  /*
   * The Berkeley tty's don't have ptem pushed automatically.
***************
*** 642,648 ****
--- 702,747 ----
      }
  }
  
+ int
+ lx_fcntl64(int fd, int lx_cmd, int arg)
+ {
+ 	int		r;
+ 	int		flags;
+ 	struct	flock64	f;
  
+ #if 0
+ 	if ((r = lxprocfs_fcntl(fd, lx_cmd, arg)) != -1)
+ 	    return r;
+ #endif
+ 
+ 	switch (lx_cmd)
+ 	{
+ 		case LX_F_GETLK:
+ 			if (copy_in_flock64((struct lx_flock64 *)arg, &f) != 0)
+ 				return -1;
+ 			if ((r = fcntl(fd, F_GETLK64, &f)) == -1)
+ 				return -1;
+ 			if (copy_out_flock64(&f, (struct lx_flock64 *)arg) != 0)
+ 				return -1;
+ 			return r;
+ 
+ 		case LX_F_SETLK:
+ 			if (copy_in_flock64((struct lx_flock64 *)arg, &f) != 0)
+ 				return -1;
+ 			return fcntl(fd, F_SETLK64, &f);
+ 
+ 		case LX_F_SETLKW:
+ 			if (copy_in_flock64((struct lx_flock64 *)arg, &f) != 0)
+ 				return -1;
+ 			return fcntl(fd, F_SETLKW64, &f);
+ 
+ 		default:
+ 			/* all the other commands are the same as fcntl() */
+ 		        return lx_fcntl(fd, lx_cmd, arg);
+ 	}
+ }
+ 
+ 
  /*
  ** Mostly chmod maps right across the board.  However, the Linux kernel
  ** does not seem to complain if extra bits are present in the mode.  We
***************
*** 677,687 ****
  	return 0;
  }       
  
  struct lx_dirent
  {
  	long	d_ino;
  	long	d_off;
! 	short	d_namlen;
  	char	d_name[1];
  };
  
--- 776,787 ----
  	return 0;
  }       
  
+ 
  struct lx_dirent
  {
  	long	d_ino;
  	long	d_off;
! 	unsigned short	d_reclen;
  	char	d_name[1];
  };
  
***************
*** 690,711 ****
  int
  lx_readdir(int fd, struct lx_dirent *lx_dir, int count)
  {
  	char		buf[512];
  	struct dirent	*d	= (struct dirent *)buf;
  
! 	if (getdents(fd, d, 512) <= 0)
! 		return -1;
  
  	lx_dir->d_ino	= d->d_ino;
  	lx_dir->d_off	= d->d_off;
! 	lx_dir->d_namlen= strlen(d->d_name);
  	strncpy(lx_dir->d_name, d->d_name, LX_D_NAME_SIZE);
  	lseek(fd, d->d_off, 0);
  
! 	return d->d_reclen;
  }       
  
  
  /*
  ** The behavior of fdatasync and fsync are slightly different, so
  ** this isn't a perfect implementation.
--- 790,869 ----
  int
  lx_readdir(int fd, struct lx_dirent *lx_dir, int count)
  {
+ 	int		status;
  	char		buf[512];
  	struct dirent	*d	= (struct dirent *)buf;
  
! 	status = getdents(fd, d, 512);
  
+ 	if (status <= 0)
+ 		return status;
+ 
  	lx_dir->d_ino	= d->d_ino;
  	lx_dir->d_off	= d->d_off;
! 	lx_dir->d_reclen = strlen(d->d_name);
  	strncpy(lx_dir->d_name, d->d_name, LX_D_NAME_SIZE);
  	lseek(fd, d->d_off, 0);
  
! 	return 1; 	/* always returns 1 on success */
  }       
  
  
+ int
+ lx_getdents(int fd, struct lx_dirent *lx_dir, int count)
+ {
+ 	int		status;
+ 	char		buf[512];
+ 	struct dirent	*d	= (struct dirent *)buf;
+ 
+ 	status = getdents(fd, d, 512);
+ 
+ 	if (status <= 0)
+ 		return status;
+ 
+ 	lx_dir->d_ino	= d->d_ino;
+ 	lx_dir->d_off	= d->d_off;
+ 	lx_dir->d_reclen = sizeof(struct lx_dirent) + strlen(d->d_name);
+ 	strncpy(lx_dir->d_name, d->d_name, LX_D_NAME_SIZE);
+ 	lseek(fd, d->d_off, 0);
+ 
+ 	return lx_dir->d_reclen; 	/* read one entry at a time */
+ }
+ 
+ 
+ /* Linux has the extra "d_type" field */
+ struct lx_dirent64
+ {
+ 	long long	d_ino;
+ 	long long	d_off;
+ 	unsigned short	d_reclen;
+ 	unsigned char	d_type;
+ 	char		d_name[1];
+ };
+ 
+ int
+ lx_getdents64(int fd, struct lx_dirent64 *lx_dir, int count)
+ {
+ 	int		status;
+ 	char		buf[512];
+ 	struct dirent64	*d	= (struct dirent64 *)buf;
+ 
+ 	status = getdents64(fd, d, 512);
+ 
+ 	if (status <= 0)
+ 		return status;
+ 
+ 	lx_dir->d_ino	= d->d_ino;
+ 	lx_dir->d_off	= d->d_off;
+ 	lx_dir->d_reclen = sizeof(struct lx_dirent64) + strlen(d->d_name);
+ 	lx_dir->d_type  = 0;	/* unspecified */
+ 	strncpy(lx_dir->d_name, d->d_name, LX_D_NAME_SIZE);
+ 	lseek64(fd, d->d_off, 0);
+ 
+ 	return lx_dir->d_reclen; 	/* read one entry at a time */
+ }
+ 
+ 
  /*
  ** The behavior of fdatasync and fsync are slightly different, so
  ** this isn't a perfect implementation.
*** lxruninit.c.dist	Sun Apr  9 20:08:04 2000
--- lxruninit.c	Sat Jul  5 17:00:12 2003
***************
*** 142,148 ****
  	        if (!(pathmapdef = (char *)malloc(strlen(linux_root)+9)))
  	            fatal(ENOMEM, "Cannot malloc for pathmapdef\n");
  
! #if defined(SOLARIS)
  		/*++ change this so that if deffed fm Makefile that dfn used */
  		pathmapdef = strdup("/usr/local/lxrun/PATHMAP");
  #else
--- 142,148 ----
  	        if (!(pathmapdef = (char *)malloc(strlen(linux_root)+9)))
  	            fatal(ENOMEM, "Cannot malloc for pathmapdef\n");
  
! #if 0 /* defined(SOLARIS) */
  		/*++ change this so that if deffed fm Makefile that dfn used */
  		pathmapdef = strdup("/usr/local/lxrun/PATHMAP");
  #else
*** misc.c.dist	Wed Oct 25 22:39:27 2000
--- misc.c	Sun Jul  6 00:43:39 2003
***************
*** 290,292 ****
--- 290,310 ----
  int lx_nfsservctl()	{ return enosys("nfsservctl"); }
  int lx_query_module()	{ return enosys("query_module"); }
  
+ /*
+  * STILL TO DO 
+  */ 
+ int lx_capget()   { return enosys("capget"); }
+ int lx_capset()   { return enosys("capset"); }
+ int lx_sigaltstack()   { return enosys("sigaltstack"); }
+ int lx_sendfile()   { return enosys("sendfile"); }
+ int lx_getpmsg()   { return enosys("getpmsg"); }
+ int lx_putpmsg()   { return enosys("putpmsg"); }
+ int lx_ugetrlimit()   { return enosys("ugetrlimit"); }
+ int lx_setresuid32()   { return enosys("setresuid32"); }
+ int lx_getresuid32()   { return enosys("getresuid32"); }
+ int lx_setresgid32()   { return enosys("setresgid32"); }
+ int lx_getresgid32()   { return enosys("getresgid32"); }
+ int lx_setfsuid32()   { return enosys("setfsuid32"); }
+ int lx_setfsgid32()   { return enosys("setfsgid32"); }
+ int lx_pivot_root()   { return enosys("pivot_root"); }
+ int lx_mincore()   { return enosys("mincore"); }
*** mmap.c.dist	Wed Oct 25 22:08:59 2000
--- mmap.c	Mon Jul  7 01:28:57 2003
***************
*** 58,63 ****
--- 58,65 ----
  }
  
  
+ #define PAGE_SHIFT	12		/* 4k page size */
+ 
  void *
  dz_mmap(void *addr, size_t len, int prot, int flags, off_t off)
  {
***************
*** 88,93 ****
--- 90,126 ----
  	return ret;
  }
  
+ void *
+ dz_mmap2(void *addr, size_t len, int prot, int flags, off_t pgoff)
+ {
+ 	void *ret;
+ 
+ #if defined(MAP_ANON)
+ 	/* first try anonymous mapping */
+ 	ret = mmap(addr, len, prot, flags | MAP_ANON, -1, (off_t)0);
+ 	if (ret != MAP_FAILED) {
+ 		return (ret);
+ 	}
+ #endif  /* MAP_ANON */
+ 
+ 	ml_lock(dzfd_lock);
+ 	if (dzfd == -1)
+         {
+ 		if((dzfd = open("/dev/zero", O_RDWR))==-1)
+ 		{
+ 			ml_unlock(dzfd_lock);
+ 			return (void *)MAP_FAILED;
+ 		}
+ 		fcntl(dzfd, F_SETFD, FD_CLOEXEC);
+ 	}
+ 
+ 	ret=mmap64(addr, len, prot, flags, dzfd, ((off64_t)pgoff<<PAGE_SHIFT));
+ 	ml_unlock(dzfd_lock);
+ 
+ 	return ret;
+ }
+ 
+ 
  /* Possibly invalidate the /dev/zero fd
   * (I don't see how this is going to work since close won't ever have
   *  the fd that dz_mmap opened /dev/zero with  - so we just hold
***************
*** 159,164 ****
--- 192,236 ----
  	return mmap(addr, len, prot, flags, fd, off);
  }	
  
+ void *
+ lx_mmap2(void *addr, size_t len, int lx_prot, int lx_flags, int fd, off_t pgoff)
+ {
+ 	int	prot	= 0;
+ 	int	flags	= 0;
+ 	void	*r;
+ 
+ 	MMAP_TRACE_MSG(("TRACE: lx_mmap2(0x%x, %d, %d, 0x%x, %d, %d)\n",
+ 			addr, len, lx_prot, lx_flags, fd, (int)pgoff));
+ /* XXX: pgoff isn't passed correctly according to the trace message.
+   To be safe, we punt unless anonymous memory is being mapped */
+ 	if (!(lx_flags & LX_MAP_ANONYMOUS)) {
+ 		errno = ENOSYS;
+ 		return (void *)MAP_FAILED;
+ 	}
+ 
+ 	if (lx_prot & LX_PROT_READ)
+ 		prot |= PROT_READ;
+ 	if (lx_prot & LX_PROT_WRITE)
+ 		/* WRITE => READ.
+ 		** quake3 requests write-only, then reads and dies */
+ 		prot |= (PROT_WRITE | PROT_READ);
+ 	if (lx_prot & LX_PROT_EXEC)
+ 		prot |= PROT_EXEC;
+ 
+ 	if (lx_flags & LX_MAP_SHARED)
+ 		flags |= MAP_SHARED;
+ 	if (lx_flags & LX_MAP_PRIVATE)
+ 		flags |= MAP_PRIVATE;
+ 	if (lx_flags & LX_MAP_FIXED)
+ 		flags |= MAP_FIXED;
+ 	
+ 	if (lx_flags & LX_MAP_ANONYMOUS)
+ 		return dz_mmap2(addr, len, prot, flags, pgoff);
+ 
+ 	return mmap64(addr, len, prot, flags, fd, ((off64_t)pgoff<<PAGE_SHIFT));
+ }	
+ 
+ 
  int
  lx_munmap(void *addr, size_t len)
  {
***************
*** 261,263 ****
--- 333,350 ----
                  return (void*)MAP_FAILED;
  	}
  }
+ 
+ 
+ int
+ lx_madvise(void *addr, size_t size, int advice)
+ {
+ #ifdef MADV_NORMAL
+ 	/* host system seems to support madvise().  Assume advice constants are 
+ 	  compatible systems (at least true for Solaris) */
+ 	return madvise(addr, size, advice);
+ #else
+ 	/* just ignore -- it's just advice anyway */
+ 	return 0;
+ #endif /* MADV_NORMAL */
+ }
+ 
*** process.c.dist	Sun Jan 30 12:46:55 2000
--- process.c	Sun Jul  6 15:46:25 2003
***************
*** 209,217 ****
--- 209,236 ----
  
  int lx_ptrace()		{ return enosys("ptrace"); }
  
+ /*
+  * If BRK_GROWTH_RATE is defined we use an over-allocation strategy that
+  * greatly reduces the number of calls to mmap() and even to lx_brk() itself.
+  * 
+  * - Never give back any memory (i.e., the break value is never actually
+  *   decreased).  This has no big effect since standard malloc() doesn't seem
+  *   ever lower the break value anyway.
+  * - when increasing the break, grow it by at least a factor of BRK_GROWTH_RATE
+  *   of the current memory allocates so far.  This reduced the number of 
+  *   calls to mmap() from linear to logarithmic (relative to the user program's
+  *   number of calls so malloc()).
+  * - Tell the caller that we actually got more memory than was asked for.
+  *   This reduces the number of sbrk() calls from malloc(), thereby saving on
+  *   system call overhead, which can be substantial.
+  */
  void *
  lx_brk(caddr_t brkval)
  {
+ #ifdef BRK_GROWTH_RATE
+ 	static  unsigned long max_brk, init_brk;
+ 	unsigned long   new_max_brk;
+ #endif
  	unsigned long	new_brk;
  	unsigned long	old_brk;
  	void		*ret;
***************
*** 224,232 ****
--- 243,284 ----
  	new_brk = PAGE_ALIGN(brkval);
  	old_brk	= PAGE_ALIGN(current_brk);
  
+ #ifdef BRK_GROWTH_RATE
+ 	/* initialize the max and remember the initial brk value */
+ 	if (max_brk == 0) {
+ 		max_brk = init_brk = old_brk;
+ 	}
+ #endif
+ 
  	if (new_brk == old_brk)
  	    return current_brk = brkval;
  
+ #ifdef BRK_GROWTH_RATE
+ 	if (new_brk <= max_brk)
+ 	{
+ 		return current_brk = brkval;
+ 	}
+ 
+ 	/* at least double allocated memory */
+ 	new_max_brk = max_brk + (unsigned)(BRK_GROWTH_RATE *
+ 						(max_brk - init_brk));
+ 	new_max_brk = PAGE_ALIGN(new_max_brk);
+ TRACE_MSG(TRACE_BRK, ("TRACE: init_brk = 0x%08x max_brk = 0x%08x new_max_brk = 0x%08x\n", init_brk, max_brk, new_max_brk));
+ 	if (new_max_brk < new_brk) {
+ 		new_max_brk = new_brk;
+ 	}
+ 
+ TRACE_MSG(TRACE_BRK, ("TRACE: lx_brk calling dz_mmap\n"));
+ 	ret = dz_mmap((caddr_t)max_brk, new_max_brk - max_brk,
+ 		      PROT_READ|PROT_WRITE|PROT_EXEC,
+ 		      MAP_FIXED|MAP_PRIVATE, 0);
+ 	if (ret == (caddr_t)max_brk)
+ 	{
+ 	    max_brk = new_max_brk;
+ 	    /* current_brk = brkval; */
+ 	    current_brk = (caddr_t)max_brk;
+ 	}
+ #else
  	if (new_brk < old_brk)
  	{
  		munmap((caddr_t)new_brk, old_brk - new_brk);
***************
*** 233,238 ****
--- 285,291 ----
  		return current_brk = brkval;
  	}
  
+ TRACE_MSG(TRACE_BRK, ("TRACE: lx_brk calling dz_mmap\n"));
  	ret = dz_mmap((caddr_t)old_brk, new_brk - old_brk,
  		      PROT_READ|PROT_WRITE|PROT_EXEC,
  		      MAP_FIXED|MAP_PRIVATE, 0);
***************
*** 240,245 ****
--- 293,299 ----
  	{
  	    current_brk = brkval;
  	}
+ #endif
  	else if (ret == (caddr_t)-1)	/* MAP_FAILED */
  	{
  	    TRACE_MSG(TRACE_BRK,
*** signal.c.dist	Sun Jan 16 12:04:12 2000
--- signal.c	Sun Jul  6 02:42:09 2003
***************
*** 642,654 ****
  ** to the regular versions of these calls.
  ** So to avoid printing gratuitous warning messages, we set errno to ENOSYS
  ** ourselves (warninglessly) instead of going through enosys().  */
! int lx_rt_sigpending()		{ errno=ENOSYS; return -1; }
! int lx_rt_sigtimedwait()	{ errno=ENOSYS; return -1; }
! int lx_rt_sigsuspend()		{ errno=ENOSYS; return -1; }
! int lx_rt_sigprocmask()		{ errno=ENOSYS; return -1; }
! int lx_rt_sigqueueinfo()	{ errno=ENOSYS; return -1; }
! int lx_rt_sigaction()		{ errno=ENOSYS; return -1; }
! int lx_rt_sigreturn()		{ errno=ENOSYS; return -1; }
  
  
  #include	<stdio.h>
--- 642,662 ----
  ** to the regular versions of these calls.
  ** So to avoid printing gratuitous warning messages, we set errno to ENOSYS
  ** ourselves (warninglessly) instead of going through enosys().  */
! /* ALAS, this is not so, and things like system() seem to require these calls.
!   Just map them to the non-rt versions for now. */
! int lx_rt_sigpending(lx_sigset_t *lx_mask) { return lx_sigpending(lx_mask); }
! int lx_rt_sigtimedwait()	{ return enosys("rt_sigtimedwait"); }
! int lx_rt_sigsuspend(int restart, unsigned long lx_oldmask,
! 		unsigned long lx_set)
!   { return lx_sigsuspend(restart, lx_oldmask, lx_set); }
! int lx_rt_sigprocmask(int lx_cmd, lx_sigset_t *lx_new_mask,
! 						lx_sigset_t *lx_old_mask)
!   { return lx_sigprocmask(lx_cmd, lx_new_mask, lx_old_mask); }
! int lx_rt_sigqueueinfo()	{ return enosys("rt_sigqueueinfo"); }
! int lx_rt_sigaction(int lx_sig, struct lx_sigaction *lx_new_act,
! 					struct lx_sigaction *lx_old_act)
!   { return lx_sigaction(lx_sig, lx_new_act, lx_old_act); }
! int lx_rt_sigreturn()		{ return enosys("rt_sigreturn"); }
  
  
  #include	<stdio.h>
*** stat.c.dist	Sat May 29 09:19:22 1999
--- stat.c	Sat Jul  5 21:54:55 2003
***************
*** 78,83 ****
--- 78,107 ----
  	return 0;
  }
  
+ static int
+ copy_out_new_stat64(struct stat64 *from, struct lx_new_stat64 *to)
+ {
+ 	if (! verify_write(to, sizeof(*to)))
+ 		return -1;
+ 
+ 	to->st_dev	= from->st_dev;
+ 	to->__st_ino	= from->st_ino;		/* 32 bit inode number */
+ 	to->st_ino	= from->st_ino;		/* 64 bit inode number */
+ 	to->st_mode	= from->st_mode;
+ 	to->st_nlink	= from->st_nlink;
+ 	to->st_uid	= from->st_uid;
+ 	to->st_gid	= from->st_gid;
+ 	to->st_rdev	= from->st_rdev;
+ 	to->st_size	= from->st_size;
+ 	to->st_blksize	= from->st_blksize;
+ 	to->st_blocks	= from->st_blocks;
+ 	to->st__atime	= from->st_atime;
+ 	to->st__mtime	= from->st_mtime;
+ 	to->st__ctime	= from->st_ctime;
+ 
+ 	return 0;
+ }
+ 
  int
  lx_oldstat(char *lx_path, struct lx_old_stat *buf)
  {
***************
*** 143,148 ****
--- 167,188 ----
  }	
  
  int
+ lx_stat64(char *lx_path, struct lx_new_stat64 *buf)
+ {
+ 	int		r;
+ 	struct stat64	s;
+ 
+ 	if (!(r = stat64(lx_path, &s))
+ #if 0
+ 	    || !(r = lxprocfs_stat(lx_path, &s))
+ #endif
+ 	)
+ 		return copy_out_new_stat64(&s, buf);
+ 
+ 	return -1;
+ }	
+ 
+ int
  lx_fstat(int fd, struct lx_new_stat *buf)
  {
  	int		r;
***************
*** 159,164 ****
--- 199,220 ----
  }	
  
  int
+ lx_fstat64(int fd, struct lx_new_stat64 *buf)
+ {
+ 	int		r;
+ 	struct stat64	s;
+ 
+ 	if (!(r = fstat64(fd, &s))
+ #if 0
+ 	    || !(r = lxprocfs_fstat(fd, &s))
+ #endif
+ 	)
+ 		return copy_out_new_stat64(&s, buf);
+ 
+ 	return -1;
+ }	
+ 
+ int
  lx_lstat(char *lx_path, struct lx_new_stat *buf)
  {
  	int		r;
***************
*** 172,176 ****
--- 228,248 ----
  		return copy_out_new_stat(&s, buf);
  
  	return -1;
+ }	
+ 
+ int
+ lx_lstat64(char *lx_path, struct lx_new_stat64 *buf)
+ {
+ 	int		r;
+ 	struct stat64	s;
+ 
+ 	if (!(r = lstat64(lx_path, &s))
+ #if 0
+ 	    || !(r = lxprocfs_lstat(lx_path, &s))
+ #endif
+ 	)
+ 		return copy_out_new_stat64(&s, buf);
+ 
+ 	return -1;
  }	
  
*** sysent.c.dist	Sun Jan 16 12:10:10 2000
--- sysent.c	Sun Jul  6 02:20:55 2003
***************
*** 22,27 ****
--- 22,28 ----
  
  #define lx_exit		exit
  #define lx_fork		fork
+ #define lx_vfork	fork	/* vfork seg faults */
  #define lx_creat	creat	
  #define lx_link		link	
  #define lx_unlink	unlink	
***************
*** 29,38 ****
--- 30,42 ----
  #define lx_time		time	
  #define lx_mknod	mknod	
  #define lx_lchown	lchown	
+ #define lx_lchown32	lchown
  #define lx_lseek	lseek	
  #define lx_getpid	getpid	
  #define lx_setuid	setuid	
+ #define lx_setuid32	setuid	
  #define lx_getuid	getuid	
+ #define lx_getuid32	getuid	
  #define lx_stime	stime	
  #define lx_alarm	alarm	
  #define lx_pause	pause	
***************
*** 46,54 ****
--- 50,62 ----
  #define lx_dup		dup	
  #define lx_times	times	
  #define lx_setgid	setgid	
+ #define lx_setgid32	setgid	
  #define lx_getgid	getgid	
+ #define lx_getgid32	getgid	
  #define lx_geteuid	geteuid	
+ #define lx_geteuid32	geteuid	
  #define lx_getegid	getegid	
+ #define lx_getegid32	getegid	
  #define lx_setpgid	setpgid	
  #define lx_umask	umask	
  #define lx_chroot	chroot	
***************
*** 57,63 ****
--- 65,73 ----
  #define lx_getpgrp	getpgrp	
  #define lx_setsid	setsid	
  #define lx_setreuid	setreuid	
+ #define lx_setreuid32	setreuid	
  #define lx_setregid	setregid	
+ #define lx_setregid32	setregid	
  #define lx_sethostname	sethostname	
  #define lx_gettimeofday	gettimeofday	
  #define lx_settimeofday	settimeofday	
***************
*** 64,72 ****
--- 74,85 ----
  #define lx_symlink	symlink	
  #define lx_readlink	readlink	
  #define lx_truncate	truncate	
+ #define lx_truncate64	truncate64
  #define lx_ftruncate	ftruncate	
+ #define lx_ftruncate64	ftruncate64
  #define lx_fchmod	fchmod	
  #define lx_fchown	fchown	
+ #define lx_fchown32	fchown	
  #ifndef UW7
  #define lx_setitimer    setitimer
  #define lx_getitimer    getitimer
***************
*** 76,82 ****
  #define lx_getpgid	getpgid	
  #define lx_fchdir	fchdir	
  #define lx_sysfs	sysfs	
- #define lx_getdents	getdents	
  #define lx_getsid	getsid
  #if defined(SOLARIS)
  #define lx_nanosleep	__nanosleep
--- 89,94 ----
***************
*** 84,89 ****
--- 96,105 ----
  #define	lx_getcwd	getcwd
  #define lx_poll		poll
  #define lx_chown	chown
+ #define lx_chown32	chown
+ /* gid_t == int in Solaris, hence we can ... */
+ #define lx_getgroups32	getgroups
+ #define lx_setgroups32	setgroups
  
  
  /*
No differences encountered
*** version.c.dist	Sun Oct  1 20:21:03 2000
--- version.c	Mon Jul  7 11:50:18 2003
***************
*** 8,13 ****
   * This software is provided "as is" without express or implied warranty.
   */
  
! char build_version[]	= "0.9.6pre1";
  char build_date[]	= __DATE__;
  char build_time[]	= __TIME__;
--- 8,13 ----
   * This software is provided "as is" without express or implied warranty.
   */
  
! char build_version[]	= "0.9.6pre1-modified";
  char build_date[]	= __DATE__;
  char build_time[]	= __TIME__;
*** lock.h.dist	Sun Jan 16 22:21:55 2000
--- lock.h	Sun Jul  6 12:17:53 2003
***************
*** 25,33 ****
--- 25,39 ----
  # define ml_unlock(X)	(fprintf(stderr, "%s(%d): ml_unlock(%8.8x)\n", \
  					__FILE__,__LINE__,(X)),ML_unlock(X))
  #else
+ # if defined(NO_LOCKS)
+ # define ml_create()	(0)
+ # define ml_lock(X)	(0)
+ # define ml_unlock(X)	(0)
+ # else /* NO_LOCKS */
  # define ml_create	ML_create
  # define ml_lock	ML_lock
  # define ml_unlock	ML_unlock
+ # endif  /* NO_LOCKS */
  #endif
  
  void *	ML_create();
*** syscalls.h.dist	Mon Oct 25 22:50:58 1999
--- syscalls.h	Mon Jul  7 00:38:58 2003
***************
*** 95,101 ****
  SYS(uselib,		RET(int),	ARGS1(path)			)
  SYS(swapon,		RET(int),	ARGS1(mmpath)			)
  SYS(reboot,		RET(int),	ARGS3(hex, int, hex)		)
! SYS(readdir,		RET(int),	ARGS1(ptr)			)
  SYS(mmap,		RET(ptr),	ARGS1(mmap)			)
  SYS(munmap,		RET(int),	ARGS2(ptr, int)			)
  SYS(truncate,		RET(int),	ARGS2(mmpath, off)		)
--- 95,101 ----
  SYS(uselib,		RET(int),	ARGS1(path)			)
  SYS(swapon,		RET(int),	ARGS1(mmpath)			)
  SYS(reboot,		RET(int),	ARGS3(hex, int, hex)		)
! SYS(readdir,		RET(int),	ARGS3(fd, ptr, int)		)
  SYS(mmap,		RET(ptr),	ARGS1(mmap)			)
  SYS(munmap,		RET(int),	ARGS2(ptr, int)			)
  SYS(truncate,		RET(int),	ARGS2(mmpath, off)		)
***************
*** 190,201 ****
  SYS(pwrite,		RET(int),	ARGS4(fd, ptr, hex, int)	)
  SYS(chown,		RET(int),	ARGS3(mmpath, uid, gid)		)
  SYS(getcwd,		RET(int),	ARGS2(ptr, size)		)
! /*
! SYS(capget,		
! SYS(capset,
! SYS(sigaltstack,
! SYS(sendfile,
! SYS(getpmsg,
! SYS(putpmsg,
! SYS(vfork,
! */
--- 190,230 ----
  SYS(pwrite,		RET(int),	ARGS4(fd, ptr, hex, int)	)
  SYS(chown,		RET(int),	ARGS3(mmpath, uid, gid)		)
  SYS(getcwd,		RET(int),	ARGS2(ptr, size)		)
! SYS(capget,		RET(int),	ARGS0()				)
! SYS(capset,		RET(int),	ARGS0()				)
! SYS(sigaltstack,	RET(int),	ARGS0()				)
! SYS(sendfile,		RET(int),	ARGS0()				)
! SYS(getpmsg,		RET(int),	ARGS0()				)
! SYS(putpmsg,		RET(int),	ARGS0()				)
! SYS(vfork,		RET(int),	ARGS0()				)
! SYS(ugetrlimit,		RET(int),	ARGS0()				)
! SYS(mmap2,		RET(ptr),	ARGS6(ptr, size, hex, hex, fd, off))
! SYS(truncate64,		RET(int),	ARGS2(mmpath, off64)		)
! SYS(ftruncate64,	RET(int),	ARGS2(fd, off64)		)
! SYS(stat64,		RET(int),	ARGS2(path, stat64)		)
! SYS(lstat64,		RET(int),	ARGS2(path, stat64)		)
! SYS(fstat64,		RET(int),	ARGS2(int, stat64)		)
! SYS(lchown32,		RET(int),	ARGS3(mmpath, int, int)		)
! SYS(getuid32,		RET(int),	ARGS0()				)
! SYS(getgid32,		RET(int),	ARGS0()				)
! SYS(geteuid32,		RET(int),	ARGS0()				)
! SYS(getegid32,		RET(int),	ARGS0()				)
! SYS(setreuid32,		RET(int),	ARGS2(int, int)			)
! SYS(setregid32,		RET(int),	ARGS2(int, int)			)
! SYS(getgroups32,	RET(int),	ARGS2(int, ptr)			)
! SYS(setgroups32,	RET(int),	ARGS2(int, ptr)			)
! SYS(fchown32,		RET(int),	ARGS3(fd, int, int)		)
! SYS(setresuid32,	RET(int),	ARGS0()				)
! SYS(getresuid32,	RET(int),	ARGS0()				)
! SYS(setresgid32,	RET(int),	ARGS0()				)
! SYS(getresgid32,	RET(int),	ARGS0()				)
! SYS(chown32,		RET(int),	ARGS3(mmpath, int, int)		)
! SYS(setuid32,		RET(int),	ARGS1(int)			)
! SYS(setgid32,		RET(int),	ARGS1(int)			)
! SYS(setfsuid32,		RET(int),	ARGS0()				)
! SYS(setfsgid32,		RET(int),	ARGS0()				)
! SYS(pivot_root,		RET(int),	ARGS0()				)
! SYS(mincore,		RET(int),	ARGS0()				)
! SYS(madvise,		RET(int),	ARGS3(ptr, int, int)		)
! SYS(getdents64,		RET(int),	ARGS3(fd, ptr, int)		)
! SYS(fcntl64,		RET(int),	ARGS3(fd, hex, ptr)		)
*** traceargs.h.dist	Mon Mar 15 21:10:35 1999
--- traceargs.h	Sat Jul  5 22:39:40 2003
***************
*** 29,34 ****
--- 29,35 ----
  TRACE_ARG(statfs)
  TRACE_ARG(itv)
  TRACE_ARG(stat)
+ TRACE_ARG(stat64)
  TRACE_ARG(prot)
  TRACE_ARG(sigset)
  TRACE_ARG(fd_set)
***************
*** 39,44 ****
--- 40,46 ----
  TRACE_ARG(argv)
  TRACE_ARG(old_stat)
  TRACE_ARG(off)
+ TRACE_ARG(off64)
  TRACE_ARG(amode)
  TRACE_ARG(sig)
  TRACE_ARG(pipefds)
*** include/linux/fcntl.h.dist	Wed May 26 20:54:41 1999
--- include/linux/fcntl.h	Sat Jul  5 22:10:44 2003
***************
*** 57,60 ****
--- 57,69 ----
  	int	l_pid;
  };
  
+ struct lx_flock64
+ {
+ 	short	l_type;
+ 	short	l_whence;
+ 	long long	l_start;
+ 	long long	l_len;
+ 	int	l_pid;
+ };
+ 
  #endif
*** include/linux/stat.h.dist	Tue Apr 20 19:50:28 1999
--- include/linux/stat.h	Sat Jul  5 21:51:25 2003
***************
*** 43,46 ****
--- 43,68 ----
  	unsigned long  __unused5;
  };
  
+ struct lx_new_stat64 {
+ 	unsigned long long st_dev;
+ 	unsigned long __pad1;
+ 	unsigned long __st_ino;
+ 	unsigned long st_mode;
+ 	unsigned long st_nlink;
+ 	unsigned long st_uid;
+ 	unsigned long st_gid;
+ 	unsigned long long st_rdev;
+ 	unsigned long  __pad2;
+ 	unsigned long long  st_size;
+ 	unsigned long  st_blksize;
+ 	unsigned long long  st_blocks;
+ 	unsigned long  st__atime;
+ 	unsigned long  __unused1;
+ 	unsigned long  st__mtime;
+ 	unsigned long  __unused2;
+ 	unsigned long  st__ctime;
+ 	unsigned long  __unused3;
+ 	unsigned long long st_ino;
+ };
+ 
  #endif