--- Net2/vm/vm_mmap.c	2018/04/24 18:09:20	1.1.1.3
+++ Net2/vm/vm_mmap.c	2018/04/24 18:14:56	1.1.1.4
@@ -37,7 +37,8 @@
  *
  * from: Utah $Hdr: vm_mmap.c 1.3 90/01/21$
  *
- *	@(#)vm_mmap.c	7.5 (Berkeley) 6/28/91
+ *	from: @(#)vm_mmap.c	7.5 (Berkeley) 6/28/91
+ *	vm_mmap.c,v 1.10 1993/07/17 15:24:54 mycroft Exp
  */
 
 /*
@@ -77,12 +78,14 @@ getpagesize(p, uap, retval)
 	return (0);
 }
 
+struct sbrk_args {
+	int	incr;
+};
+
 /* ARGSUSED */
 sbrk(p, uap, retval)
 	struct proc *p;
-	struct args {
-		int	incr;
-	} *uap;
+	struct sbrk_args *uap;
 	int *retval;
 {
 
@@ -90,12 +93,14 @@ sbrk(p, uap, retval)
 	return (EOPNOTSUPP);
 }
 
+struct sstk_args {
+	int	incr;
+};
+
 /* ARGSUSED */
 sstk(p, uap, retval)
 	struct proc *p;
-	struct args {
-		int	incr;
-	} *uap;
+	struct sstk_args *uap;
 	int *retval;
 {
 
@@ -103,16 +108,18 @@ sstk(p, uap, retval)
 	return (EOPNOTSUPP);
 }
 
+struct smmap_args {
+	caddr_t	addr;
+	int	len;
+	int	prot;
+	int	flags;
+	int	fd;
+	off_t	pos;
+};
+
 smmap(p, uap, retval)
 	struct proc *p;
-	register struct args {
-		caddr_t	addr;
-		int	len;
-		int	prot;
-		int	flags;
-		int	fd;
-		off_t	pos;
-	} *uap;
+	register struct smmap_args *uap;
 	int *retval;
 {
 	register struct filedesc *fdp = p->p_fd;
@@ -130,7 +137,7 @@ smmap(p, uap, retval)
 	if (mmapdebug & MDB_FOLLOW)
 		printf("mmap(%d): addr %x len %x pro %x flg %x fd %d pos %x\n",
 		       p->p_pid, uap->addr, uap->len, uap->prot,
-		       uap->flags, uap->fd, uap->pos);
+		       flags, uap->fd, uap->pos);
 #endif
 	/*
 	 * Make sure one of the sharing types is specified
@@ -186,22 +193,24 @@ smmap(p, uap, retval)
 		/*
 		 * Ensure that file protection and desired protection
 		 * are compatible.  Note that we only worry about writability
-		 * if mapping is shared.
+		 * if mapping is shared.  XXX (cgd) -- coalese access checks
+		 * and permissions setting.
 		 */
 		if ((uap->prot & PROT_READ) && (fp->f_flag & FREAD) == 0 ||
 		    ((flags & MAP_SHARED) &&
 		     (uap->prot & PROT_WRITE) && (fp->f_flag & FWRITE) == 0))
 			return(EACCES);
-		if ((flags & MAP_SHARED) && (fp->f_flag & FWRITE) == 0)
-			flags = (flags & ~MAP_SHARED) | MAP_PRIVATE;
 		handle = (caddr_t)vp;
 		/*
-		 * Map protections to MACH style
+		 * Map maximum protections to MACH style
 		 */
-                maxprot = VM_PROT_EXECUTE;
+		maxprot = VM_PROT_EXECUTE;	/* ??? */
 		if (fp->f_flag & FREAD)
 			maxprot |= VM_PROT_READ;
-		if (fp->f_flag & FWRITE)
+		if(uap->flags & MAP_SHARED) {
+			if (fp->f_flag & FWRITE)
+				maxprot |= VM_PROT_WRITE;
+		} else
 			maxprot |= VM_PROT_WRITE;
 	} else if (uap->fd != -1) {
                 maxprot = VM_PROT_ALL;
@@ -211,7 +220,7 @@ smmap(p, uap, retval)
 		handle = NULL;
 	}
 	/*
-	 * Map protections to MACH style
+	 * Map current protections to MACH style
 	 */
 	prot = VM_PROT_NONE;
 	if (uap->prot & PROT_READ)
@@ -228,12 +237,14 @@ smmap(p, uap, retval)
 	return(error);
 }
 
+struct msync_args {
+	caddr_t	addr;
+	int	len;
+};
+
 msync(p, uap, retval)
 	struct proc *p;
-	struct args {
-		caddr_t	addr;
-		int	len;
-	} *uap;
+	struct msync_args *uap;
 	int *retval;
 {
 	vm_offset_t addr, objoff, oaddr;
@@ -300,12 +311,14 @@ msync(p, uap, retval)
 	return(0);
 }
 
+struct munmap_args {
+	caddr_t	addr;
+	int	len;
+};
+
 munmap(p, uap, retval)
 	register struct proc *p;
-	register struct args {
-		caddr_t	addr;
-		int	len;
-	} *uap;
+	register struct munmap_args *uap;
 	int *retval;
 {
 	vm_offset_t addr;
@@ -347,13 +360,15 @@ munmapfd(p, fd)
 	p->p_fd->fd_ofileflags[fd] &= ~UF_MAPPED;
 }
 
+struct mprotect_args {
+	caddr_t	addr;
+	int	len;
+	int	prot;
+};
+
 mprotect(p, uap, retval)
 	struct proc *p;
-	struct args {
-		caddr_t	addr;
-		int	len;
-		int	prot;
-	} *uap;
+	struct mprotect_args *uap;
 	int *retval;
 {
 	vm_offset_t addr;
@@ -391,14 +406,16 @@ mprotect(p, uap, retval)
 	return (EINVAL);
 }
 
+struct madvise_args {
+	caddr_t	addr;
+	int	len;
+	int	behav;
+};
+
 /* ARGSUSED */
 madvise(p, uap, retval)
 	struct proc *p;
-	struct args {
-		caddr_t	addr;
-		int	len;
-		int	behav;
-	} *uap;
+	struct madvise_args *uap;
 	int *retval;
 {
 
@@ -406,14 +423,16 @@ madvise(p, uap, retval)
 	return (EOPNOTSUPP);
 }
 
+struct mincore_args {
+	caddr_t	addr;
+	int	len;
+	char	*vec;
+};
+
 /* ARGSUSED */
 mincore(p, uap, retval)
 	struct proc *p;
-	struct args {
-		caddr_t	addr;
-		int	len;
-		char	*vec;
-	} *uap;
+	struct mincore_args *uap;
 	int *retval;
 {
 
@@ -649,12 +668,8 @@ vm_mmap(map, addr, size, prot, maxprot,
 	/*
 	 * Correct protection (default is VM_PROT_ALL).
 	 * Note that we set the maximum protection.  This may not be
-	 * entirely correct.  Maybe the maximum protection should be based
-	 * on the object permissions where it makes sense (e.g. a vnode).
-	 *
-	 * XXX Changed my mind: leave max prot at VM_PROT_ALL.
-	 * Changed again: indeed set maximum protection based on
-	 * object permissions.
+	 * entirely correct.  The maximum protection is be based on
+	 * the object permissions where it makes sense (e.g. a vnode).
 	 */
 		rv = vm_map_protect(map, *addr, *addr+size, prot, FALSE);
 		if (rv != KERN_SUCCESS) {