 @@ -1,600 +1,606 @@
-/*	$NetBSD: ibcs2_exec_coff.c,v 1.25 2010/07/22 03:19:02 christos Exp $	*/
+/*	$NetBSD: ibcs2_exec_coff.c,v 1.25.14.1 2017/08/19 04:13:51 snj Exp $	*/
 /*
  * Copyright (c) 1994, 1995, 1998 Scott Bartram
  * Copyright (c) 1994 Adam Glass
  * Copyright (c) 1993, 1994 Christopher G. Demetriou
  * All rights reserved.
+ *
  * originally from kern/exec_ecoff.c
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by Scott Bartram.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ibcs2_exec_coff.c,v 1.25 2010/07/22 03:19:02 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ibcs2_exec_coff.c,v 1.25.14.1 2017/08/19 04:13:51 snj Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/malloc.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/exec.h>
 #include <sys/exec_coff.h>
 #include <sys/resourcevar.h>
 #include <sys/mman.h>
 #include <sys/cpu.h>
 #include <machine/reg.h>
 #include <machine/ibcs2_machdep.h>
 #include <compat/ibcs2/ibcs2_types.h>
 #include <compat/ibcs2/ibcs2_exec.h>
 #include <compat/ibcs2/ibcs2_errno.h>
 #include <compat/ibcs2/ibcs2_util.h>
 int exec_ibcs2_coff_prep_omagic(struct lwp *, struct exec_package *,
 				     struct coff_filehdr *,
 				     struct coff_aouthdr *);
 int exec_ibcs2_coff_prep_nmagic(struct lwp *, struct exec_package *,
 				     struct coff_filehdr *,
 				     struct coff_aouthdr *);
 int exec_ibcs2_coff_prep_zmagic(struct lwp *, struct exec_package *,
 				     struct coff_filehdr *,
 				     struct coff_aouthdr *);
 void cpu_exec_ibcs2_coff_setup(int, struct proc *, struct exec_package *,
 				    void *);
 static int coff_load_shlib(struct lwp *, const char *,
 		struct exec_package *);
 static int coff_find_section(struct lwp *, struct vnode *,
 				  struct coff_filehdr *, struct coff_scnhdr *,
 				  int);
 /*
  * exec_ibcs2_coff_makecmds(): Check if it's an coff-format executable.
+ *
  * Given a proc pointer and an exec package pointer, see if the referent
  * of the epp is in coff format.  Check 'standard' magic numbers for
  * this architecture.  If that fails, return failure.
+ *
  * This function is  responsible for creating a set of vmcmds which can be
  * used to build the process's vm space and inserting them into the exec
  * package.
  */
 int
 exec_ibcs2_coff_makecmds(struct lwp *l, struct exec_package *epp)
+{
 	int error;
 	struct coff_filehdr *fp = epp->ep_hdr;
 	struct coff_aouthdr *ap;
 	if (epp->ep_hdrvalid < COFF_HDR_SIZE) {
 		DPRINTF(("ibcs2: bad coff hdr size\n"));
 		return ENOEXEC;
+	}
 	if (COFF_BADMAG(fp)) {
 		DPRINTF(("ibcs2: bad coff magic\n"));
 		return ENOEXEC;
+	}
 	ap = (void *)((char *)epp->ep_hdr + sizeof(struct coff_filehdr));
 	switch (ap->a_magic) {
 	case COFF_OMAGIC:
 		error = exec_ibcs2_coff_prep_omagic(l, epp, fp, ap);
 		break;
 	case COFF_NMAGIC:
 		error = exec_ibcs2_coff_prep_nmagic(l, epp, fp, ap);
 		break;
 	case COFF_ZMAGIC:
 		error = exec_ibcs2_coff_prep_zmagic(l, epp, fp, ap);
 		break;
 	default:
 		DPRINTF(("ibcs2: bad coff magic %x\n", ap->a_magic));
 		return ENOEXEC;
+	}
 	if (error) {
 		kill_vmcmds(&epp->ep_vmcmds);
 		DPRINTF(("ibcs2: error loading magic %x (%d)\n", ap->a_magic,
 		    error));
+	}
 	return error;
+}
 /*
  * exec_ibcs2_coff_prep_omagic(): Prepare a COFF OMAGIC binary's exec package
  */
 int
 exec_ibcs2_coff_prep_omagic(struct lwp *l, struct exec_package *epp, struct coff_filehdr *fp, struct coff_aouthdr *ap)
+{
 	epp->ep_taddr = COFF_SEGMENT_ALIGN(fp, ap, ap->a_tstart);
 	epp->ep_tsize = ap->a_tsize;
 	epp->ep_daddr = COFF_SEGMENT_ALIGN(fp, ap, ap->a_dstart);
 	epp->ep_dsize = ap->a_dsize;
 	epp->ep_entry = ap->a_entry;
 	DPRINTF(("ibcs2_omagic: text=%#lx/%#lx, data=%#lx/%#lx, bss=%#lx/%#lx, entry=%#lx\n",
 		epp->ep_taddr, epp->ep_tsize,
 		epp->ep_daddr, epp->ep_dsize,
 		ap->a_dstart + ap->a_dsize, ap->a_bsize,
 		epp->ep_entry));
 	/* set up command for text and data segments */
 	NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
 		  ap->a_tsize + ap->a_dsize, epp->ep_taddr, epp->ep_vp,
 		  COFF_TXTOFF(fp, ap),
 		  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
 	/* set up command for bss segment */
 	if (ap->a_bsize > 0) {
 		NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, ap->a_bsize,
 			  COFF_SEGMENT_ALIGN(fp, ap, ap->a_dstart + ap->a_dsize),
 			  NULLVP, 0,
 			  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
 		epp->ep_dsize += ap->a_bsize;
+	}
 	/* The following is to make obreak(2) happy.  It expects daddr
 	 * to on a page boundary and will round up dsize to a page
 	 * address.
 	 */
 	if (trunc_page(epp->ep_daddr) != epp->ep_daddr) {
 		epp->ep_dsize += epp->ep_daddr - trunc_page(epp->ep_daddr);
 		epp->ep_daddr = trunc_page(epp->ep_daddr);
 		if (epp->ep_taddr + epp->ep_tsize > epp->ep_daddr)
 			epp->ep_tsize = epp->ep_daddr - epp->ep_taddr;
+	}
 	return (*epp->ep_esch->es_setup_stack)(l, epp);
+}
 /*
  * exec_ibcs2_coff_prep_nmagic(): Prepare a 'native' NMAGIC COFF binary's exec
  *                          package.
  */
 int
 exec_ibcs2_coff_prep_nmagic(struct lwp *l, struct exec_package *epp, struct coff_filehdr *fp, struct coff_aouthdr *ap)
+{
 	long toverlap, doverlap;
 	u_long tsize, tend;
 	epp->ep_taddr = ap->a_tstart;
 	epp->ep_tsize = ap->a_tsize;
 	epp->ep_daddr = ap->a_dstart;
 	epp->ep_dsize = ap->a_dsize;
 	epp->ep_entry = ap->a_entry;
 	DPRINTF(("ibcs2_nmagic: text=%#lx/%#lx, data=%#lx/%#lx, bss=%#lx/%#lx, entry=%#lx\n",
 		epp->ep_taddr, epp->ep_tsize,
 		epp->ep_daddr, epp->ep_dsize,
 		ap->a_dstart + ap->a_dsize, ap->a_bsize,
 		epp->ep_entry));
 	/* Do the text and data pages overlap?
 	 */
 	tend = epp->ep_taddr + epp->ep_tsize - 1;
 	if (trunc_page(tend) == trunc_page(epp->ep_daddr)) {
 		/* If the first page of text is the first page of data,
 		 * then we consider it all data.
 		 */
 		if (trunc_page(epp->ep_taddr) == trunc_page(epp->ep_daddr)) {
 			tsize = 0;
 		} else {
 			tsize = trunc_page(tend) - epp->ep_taddr;
+		}
 		/* If the text and data file and VA offsets are the
 		 * same, simply bring the data segment to start on
 		 * the start of the page.
 		 */
 		if (epp->ep_daddr - epp->ep_taddr ==
 		    COFF_DATOFF(fp, ap) - COFF_TXTOFF(fp, ap)) {
 			u_long diff = epp->ep_daddr - trunc_page(epp->ep_daddr);
 			toverlap = 0;
 			doverlap = -diff;
 		} else {
 			/* otherwise copy the individual pieces */
 			toverlap = epp->ep_tsize - tsize;
 			doverlap = round_page(epp->ep_daddr) - epp->ep_daddr;
 			if (doverlap > epp->ep_dsize)
 				doverlap = epp->ep_dsize;
+		}
 	} else {
 		tsize = epp->ep_tsize;
 		toverlap = 0;
 		doverlap = 0;
+	}
 	DPRINTF(("nmagic_vmcmds:"));
 	if (tsize > 0) {
 		/* set up command for text segment */
 		NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, tsize,
 			  epp->ep_taddr, epp->ep_vp, COFF_TXTOFF(fp, ap),
 			  VM_PROT_READ|VM_PROT_EXECUTE);
 		DPRINTF((" map_readvn(%#lx/%#lx@%#lx)",
 			epp->ep_taddr, tsize, (u_long) COFF_TXTOFF(fp, ap)));
+	}
 	if (toverlap > 0) {
 		NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, toverlap,
 			  epp->ep_taddr + tsize, epp->ep_vp,
 			  COFF_TXTOFF(fp, ap) + tsize,
 			  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
 		DPRINTF((" map_readvn(%#lx/%#lx@%#lx)",
 			epp->ep_taddr + tsize, toverlap,
 			COFF_TXTOFF(fp, ap) + tsize));
 		NEW_VMCMD(&epp->ep_vmcmds, vmcmd_readvn, doverlap,
 			  epp->ep_daddr, epp->ep_vp,
 			  COFF_DATOFF(fp, ap),
 			  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
 		DPRINTF((" readvn(%#lx/%#lx@%#lx)", epp->ep_daddr, doverlap,
 			COFF_DATOFF(fp, ap)));
+	}
 	if (epp->ep_dsize > doverlap || doverlap < 0) {
 		/* set up command for data segment */
 		NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
 			  epp->ep_dsize - doverlap, epp->ep_daddr + doverlap,
 			  epp->ep_vp, COFF_DATOFF(fp, ap) + doverlap,
 			  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
 		DPRINTF((" map_readvn(%#lx/%#lx@%#lx)",
 			epp->ep_daddr + doverlap, epp->ep_dsize - doverlap,
 			COFF_DATOFF(fp, ap) + doverlap));
+	}
 	/* Handle page remainders for pagedvn.
 	 */
 	/* set up command for bss segment */
 	if (ap->a_bsize > 0) {
 		u_long dend = round_page(epp->ep_daddr + epp->ep_dsize);
 		u_long dspace = dend - (epp->ep_daddr + epp->ep_dsize);
 		if (ap->a_bsize > dspace) {
 			NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero,
 				  ap->a_bsize - dspace, dend, NULLVP, 0,
 				  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
 			DPRINTF((" map_zero(%#lx/%#lx)",
 				dend, ap->a_bsize - dspace));
+		}
 		epp->ep_dsize += ap->a_bsize;
+	}
 	DPRINTF(("\n"));
 	/* The following is to make obreak(2) happy.  It expects daddr
 	 * to on a page boundary and will round up dsize to a page
 	 * address.
 	 */
 	if (trunc_page(epp->ep_daddr) != epp->ep_daddr) {
 		epp->ep_dsize += epp->ep_daddr - trunc_page(epp->ep_daddr);
 		epp->ep_daddr = trunc_page(epp->ep_daddr);
 		if (epp->ep_taddr + epp->ep_tsize > epp->ep_daddr)
 			epp->ep_tsize = epp->ep_daddr - epp->ep_taddr;
+	}
 	return (*epp->ep_esch->es_setup_stack)(l, epp);
+}
 /*
  * coff_find_section - load specified section header
+ *
  * TODO - optimize by reading all section headers in at once
  */
 static int
 coff_find_section(struct lwp *l, struct vnode *vp, struct coff_filehdr *fp, struct coff_scnhdr *sh, int s_type)
+{
 	int i, pos, siz, error;
 	size_t resid;
 	pos = COFF_HDR_SIZE;
 	for (i = 0; i < fp->f_nscns; i++, pos += sizeof(struct coff_scnhdr)) {
 		siz = sizeof(struct coff_scnhdr);
 		error = vn_rdwr(UIO_READ, vp, (void *) sh,
 		    siz, pos, UIO_SYSSPACE, IO_NODELOCKED, l->l_cred,
 		    &resid, NULL);
 		if (error) {
 			DPRINTF(("section hdr %d read error %d\n", i, error));
 			return error;
+		}
 		siz -= resid;
 		if (siz != sizeof(struct coff_scnhdr)) {
 			DPRINTF(("incomplete read: hdr %d ask=%d, rem=%lu got %d\n",
 				 s_type, sizeof(struct coff_scnhdr),
 				 (u_long) resid, siz));
 			return ENOEXEC;
+		}
 		/* DPRINTF(("found section: %x\n", sh->s_flags)); */
 		if (sh->s_flags == s_type)
 			return 0;
+	}
 	return ENOEXEC;
+}
 /*
  * exec_ibcs2_coff_prep_zmagic(): Prepare a COFF ZMAGIC binary's exec package
+ *
  * First, set the various offsets/lengths in the exec package.
+ *
  * Then, mark the text image busy (so it can be demand paged) or error
  * out if this is not possible.  Finally, set up vmcmds for the
  * text, data, bss, and stack segments.
  */
 int
 exec_ibcs2_coff_prep_zmagic(struct lwp *l, struct exec_package *epp, struct coff_filehdr *fp, struct coff_aouthdr *ap)
+{
 	int error;
 	u_long offset;
 	long dsize, baddr, bsize;
 	struct coff_scnhdr sh;
 	/* DPRINTF(("enter exec_ibcs2_coff_prep_zmagic\n")); */
 	/* set up command for text segment */
 	error = coff_find_section(l, epp->ep_vp, fp, &sh, COFF_STYP_TEXT);
 	if (error) {
 		DPRINTF(("can't find text section: %d\n", error));
 		return error;
+	}
 	/* DPRINTF(("COFF text addr %x size %d offset %d\n", sh.s_vaddr,
 		 sh.s_size, sh.s_scnptr)); */
 	epp->ep_taddr = COFF_ALIGN(sh.s_vaddr);
 	offset = sh.s_scnptr - (sh.s_vaddr - epp->ep_taddr);
 	epp->ep_tsize = sh.s_size + (sh.s_vaddr - epp->ep_taddr);
 	/* DPRINTF(("VMCMD: addr %x size %d offset %d\n", epp->ep_taddr,
 		 epp->ep_tsize, offset)); */
 #ifdef notyet
 	error = vn_marktext(epp->ep_vp);
 	if (error)
 		return (error);
 	NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_pagedvn, epp->ep_tsize,
 		  epp->ep_taddr, epp->ep_vp, offset,
 		  VM_PROT_READ|VM_PROT_EXECUTE);
 #else
 	NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, epp->ep_tsize,
 		  epp->ep_taddr, epp->ep_vp, offset,
 		  VM_PROT_READ|VM_PROT_EXECUTE);
 #endif
 	/* set up command for data segment */
 	error = coff_find_section(l, epp->ep_vp, fp, &sh, COFF_STYP_DATA);
 	if (error) {
 		DPRINTF(("can't find data section: %d\n", error));
 		return error;
+	}
 	/* DPRINTF(("COFF data addr %x size %d offset %d\n", sh.s_vaddr,
 		 sh.s_size, sh.s_scnptr)); */
 	epp->ep_daddr = COFF_ALIGN(sh.s_vaddr);
 	offset = sh.s_scnptr - (sh.s_vaddr - epp->ep_daddr);
 	dsize = sh.s_size + (sh.s_vaddr - epp->ep_daddr);
 	epp->ep_dsize = dsize + ap->a_bsize;
 	/* DPRINTF(("VMCMD: addr %x size %d offset %d\n", epp->ep_daddr,
 		 dsize, offset)); */
 #ifdef notyet
 	NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_pagedvn, dsize,
 		  epp->ep_daddr, epp->ep_vp, offset,
 		  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
 #else
 	NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
 		  dsize, epp->ep_daddr, epp->ep_vp, offset,
 		  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
 #endif
 	/* set up command for bss segment */
 	baddr = round_page(epp->ep_daddr + dsize);
 	bsize = epp->ep_daddr + epp->ep_dsize - baddr;
 	if (bsize > 0) {
 		/* DPRINTF(("VMCMD: addr %x size %d offset %d\n",
 			 baddr, bsize, 0)); */
 		NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero,
 			  bsize, baddr, NULLVP, 0,
 			  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
+	}
 	/* load any shared libraries */
 	error = coff_find_section(l, epp->ep_vp, fp, &sh, COFF_STYP_SHLIB);
 	if (!error) {
 		size_t resid;
 		struct coff_slhdr *slhdr;
 		char *tbuf, *bufp;
 		size_t len = sh.s_size, path_index, entry_len;
 		if (len > 64 * 1024)
 			return ENOEXEC;
 		tbuf = malloc(len, M_TEMP, M_WAITOK);
 		if (tbuf == NULL)
 			return ENOEXEC;
 		/* DPRINTF(("COFF shlib size %d offset %d\n",
 			 sh.s_size, sh.s_scnptr)); */
 		error = vn_rdwr(UIO_READ, epp->ep_vp, tbuf,
 				len, sh.s_scnptr,
 				UIO_SYSSPACE, IO_NODELOCKED, l->l_cred,
 				&resid, NULL);
 		if (error) {
 			DPRINTF(("shlib section read error %d\n", error));
 			free(tbuf, M_TEMP);
 			return ENOEXEC;
+		}
 		bufp = tbuf;
 		while (len) {
 			if (len < sizeof(struct coff_slhdr)) {
 				free(tbuf, M_TEMP);
 				return ENOEXEC;
+			}
 			slhdr = (struct coff_slhdr *)bufp;
 			if (slhdr->path_index > LONG_MAX / sizeof(long) ||
 			    slhdr->entry_len > LONG_MAX / sizeof(long)) {
 				free(tbuf, M_TEMP);
 				return ENOEXEC;
+			}
 			path_index = slhdr->path_index * sizeof(long);
 			entry_len = slhdr->entry_len * sizeof(long);
-			if (entry_len > len) {
+			if (entry_len < sizeof(struct coff_slhdr) ||
 			    entry_len > len ||
 			    strnlen(slhdr->sl_name, entry_len) == entry_len) {
 				free(tbuf, M_TEMP);
 				return ENOEXEC;
+			}
 			/* DPRINTF(("path_index: %d entry_len: %d name: %s\n",
 				 path_index, entry_len, slhdr->sl_name)); */
 			error = coff_load_shlib(l, slhdr->sl_name, epp);
 			if (error) {
 				free(tbuf, M_TEMP);
 				return ENOEXEC;
+			}
 			bufp += entry_len;
 			len -= entry_len;
+		}
 		free(tbuf, M_TEMP);
+	}
 	/* set up entry point */
 	epp->ep_entry = ap->a_entry;
 	DPRINTF(("ibcs2_zmagic: text addr: %#lx size: %#lx data addr: %#lx size: %#lx entry: %#lx\n",
 		 epp->ep_taddr, epp->ep_tsize,
 		 epp->ep_daddr, epp->ep_dsize,
 		 epp->ep_entry));
 	/* The following is to make obreak(2) happy.  It expects daddr
 	 * to on a page boundary and will round up dsize to a page
 	 * address.
 	 */
 	if (trunc_page(epp->ep_daddr) != epp->ep_daddr) {
 		epp->ep_dsize += epp->ep_daddr - trunc_page(epp->ep_daddr);
 		epp->ep_daddr = trunc_page(epp->ep_daddr);
 		if (epp->ep_taddr + epp->ep_tsize > epp->ep_daddr)
 			epp->ep_tsize = epp->ep_daddr - epp->ep_taddr;
+	}
 	return (*epp->ep_esch->es_setup_stack)(l, epp);
+}
 static int
 coff_load_shlib(struct lwp *l, const char *path, struct exec_package *epp)
+{
 	int error, siz;
 	int taddr, tsize, daddr, dsize, offset;
 	size_t resid;
 	struct vnode *vp;
 	struct coff_filehdr fh, *fhp = &fh;
 	struct coff_scnhdr sh, *shp = &sh;
 	/*
 	 * 1. open shlib file
 	 * 2. read filehdr
 	 * 3. map text, data, and bss out of it using VM_*
 	 */
 	/* first get the vnode */
 	error = namei_simple_kernel(path, NSM_FOLLOW_TRYEMULROOT, &vp);
 	if (error != 0) {
 		DPRINTF(("coff_load_shlib: can't find library %s\n", path));
 		return error;
+	}
 	siz = sizeof(struct coff_filehdr);
 	error = vn_rdwr(UIO_READ, vp, (void *) fhp, siz, 0,
 	    UIO_SYSSPACE, IO_NODELOCKED, l->l_cred, &resid, l);
 	if (error) {
 	    DPRINTF(("filehdr read error %d\n", error));
 	    vrele(vp);
 	    return error;
+	}
 	siz -= resid;
 	if (siz != sizeof(struct coff_filehdr)) {
 	    DPRINTF(("coff_load_shlib: incomplete read: ask=%d, rem=%lu got %d\n",
 		     sizeof(struct coff_filehdr), (u_long) resid, siz));
 	    vrele(vp);
 	    return ENOEXEC;
+	}
 	/* load text */
 	error = coff_find_section(l, vp, fhp, shp, COFF_STYP_TEXT);
 	if (error) {
 	    DPRINTF(("can't find shlib text section\n"));
 	    vrele(vp);
 	    return error;
+	}
 	/* DPRINTF(("COFF text addr %x size %d offset %d\n", sh.s_vaddr,
 		 sh.s_size, sh.s_scnptr)); */
 	taddr = COFF_ALIGN(shp->s_vaddr);
 	offset = shp->s_scnptr - (shp->s_vaddr - taddr);
 	tsize = shp->s_size + (shp->s_vaddr - taddr);
 	/* DPRINTF(("VMCMD: addr %x size %d offset %d\n", taddr, tsize, offset)); */
 	NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, tsize, taddr,
 		  vp, offset,
 		  VM_PROT_READ|VM_PROT_EXECUTE);
 	/* load data */
 	error = coff_find_section(l, vp, fhp, shp, COFF_STYP_DATA);
 	if (error) {
 	    DPRINTF(("can't find shlib data section\n"));
 	    vrele(vp);
 	    return error;
+	}
 	/* DPRINTF(("COFF data addr %x size %d offset %d\n", shp->s_vaddr,
 		 shp->s_size, shp->s_scnptr)); */
 	daddr = COFF_ALIGN(shp->s_vaddr);
 	offset = shp->s_scnptr - (shp->s_vaddr - daddr);
 	dsize = shp->s_size + (shp->s_vaddr - daddr);
 	/* epp->ep_dsize = dsize + ap->a_bsize; */
 	/* DPRINTF(("VMCMD: addr %x size %d offset %d\n", daddr, dsize, offset)); */
 	NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
 		  dsize, daddr, vp, offset,
 		  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
 	/* load bss */
 	error = coff_find_section(l, vp, fhp, shp, COFF_STYP_BSS);
 	if (!error) {
 		int baddr = round_page(daddr + dsize);
 		int bsize = daddr + dsize + shp->s_size - baddr;
 		if (bsize > 0) {
 			/* DPRINTF(("VMCMD: addr %x size %d offset %d\n",
 			   baddr, bsize, 0)); */
 			NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero,
 				  bsize, baddr, NULLVP, 0,
 				  VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
+	    }
+	}
 	vrele(vp);
 	return 0;
+}

 @@ -1,571 +1,574 @@
-/*	$NetBSD: ibcs2_ioctl.c,v 1.45 2008/06/24 10:03:17 gmcgarry Exp $	*/
+/*	$NetBSD: ibcs2_ioctl.c,v 1.45.36.1 2017/08/19 04:13:51 snj Exp $	*/
 /*
  * Copyright (c) 1994, 1995 Scott Bartram
  * All rights reserved.
+ *
  * based on compat/sunos/sun_ioctl.c
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ibcs2_ioctl.c,v 1.45 2008/06/24 10:03:17 gmcgarry Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ibcs2_ioctl.c,v 1.45.36.1 2017/08/19 04:13:51 snj Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/dirent.h>
 #include <sys/proc.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/filedesc.h>
 #include <sys/ioctl.h>
 #include <sys/kernel.h>
 #include <sys/mbuf.h>
 #include <sys/mman.h>
 #include <sys/mount.h>
 #include <sys/reboot.h>
 #include <sys/resource.h>
 #include <sys/resourcevar.h>
 #include <sys/signal.h>
 #include <sys/signalvar.h>
 #include <sys/socket.h>
 #include <sys/termios.h>
 #include <sys/time.h>
 #include <sys/times.h>
 #include <sys/tty.h>
 #include <sys/vnode.h>
 #include <sys/uio.h>
 #include <sys/wait.h>
 #include <sys/utsname.h>
 #include <sys/unistd.h>
 #include <net/if.h>
 #include <sys/syscallargs.h>
 #include <compat/ibcs2/ibcs2_types.h>
 #include <compat/ibcs2/ibcs2_signal.h>
 #include <compat/ibcs2/ibcs2_socksys.h>
 #include <compat/ibcs2/ibcs2_stropts.h>
 #include <compat/ibcs2/ibcs2_syscallargs.h>
 #include <compat/ibcs2/ibcs2_termios.h>
 #include <compat/ibcs2/ibcs2_util.h>
 /*
  * iBCS2 ioctl calls.
  */
 static const struct speedtab sptab[] = {
 	{ 0, 0 },
 	{ 50, 1 },
 	{ 75, 2 },
 	{ 110, 3 },
 	{ 134, 4 },
 	{ 135, 4 },
 	{ 150, 5 },
 	{ 200, 6 },
 	{ 300, 7 },
 	{ 600, 8 },
 	{ 1200, 9 },
 	{ 1800, 10 },
 	{ 2400, 11 },
 	{ 4800, 12 },
 	{ 9600, 13 },
 	{ 19200, 14 },
 	{ 38400, 15 },
 	{ -1, -1 }
 };
 static const u_long s2btab[] = {
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 };
 static void stios2btios(struct ibcs2_termios *, struct termios *);
 static void btios2stios(struct termios *, struct ibcs2_termios *);
 static void stios2stio(struct ibcs2_termios *, struct ibcs2_termio *);
 static void stio2stios(struct ibcs2_termio *, struct ibcs2_termios *);
 static void
 stios2btios(struct ibcs2_termios *st, struct termios *bt)
+{
 	u_long l, r;
 	l = st->c_iflag;	r = 0;
 	if (l & IBCS2_IGNBRK)	r |= IGNBRK;
 	if (l & IBCS2_BRKINT)	r |= BRKINT;
 	if (l & IBCS2_IGNPAR)	r |= IGNPAR;
 	if (l & IBCS2_PARMRK)	r |= PARMRK;
 	if (l & IBCS2_INPCK)	r |= INPCK;
 	if (l & IBCS2_ISTRIP)	r |= ISTRIP;
 	if (l & IBCS2_INLCR)	r |= INLCR;
 	if (l & IBCS2_IGNCR)	r |= IGNCR;
 	if (l & IBCS2_ICRNL)	r |= ICRNL;
 	if (l & IBCS2_IXON)	r |= IXON;
 	if (l & IBCS2_IXANY)	r |= IXANY;
 	if (l & IBCS2_IXOFF)	r |= IXOFF;
 	if (l & IBCS2_IMAXBEL)	r |= IMAXBEL;
 	bt->c_iflag = r;
 	l = st->c_oflag;	r = 0;
 	if (l & IBCS2_OPOST)	r |= OPOST;
 	if (l & IBCS2_ONLCR)	r |= ONLCR;
 	if (l & IBCS2_TAB3)	r |= OXTABS;
 	bt->c_oflag = r;
 	l = st->c_cflag;	r = 0;
 	switch (l & IBCS2_CSIZE) {
 	case IBCS2_CS5:		r |= CS5; break;
 	case IBCS2_CS6:		r |= CS6; break;
 	case IBCS2_CS7:		r |= CS7; break;
 	case IBCS2_CS8:		r |= CS8; break;
+	}
 	if (l & IBCS2_CSTOPB)	r |= CSTOPB;
 	if (l & IBCS2_CREAD)	r |= CREAD;
 	if (l & IBCS2_PARENB)	r |= PARENB;
 	if (l & IBCS2_PARODD)	r |= PARODD;
 	if (l & IBCS2_HUPCL)	r |= HUPCL;
 	if (l & IBCS2_CLOCAL)	r |= CLOCAL;
 	bt->c_cflag = r;
 	bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0f];
 	l = st->c_lflag;	r = 0;
 	if (l & IBCS2_ISIG)	r |= ISIG;
 	if (l & IBCS2_ICANON)	r |= ICANON;
 	if (l & IBCS2_ECHO)	r |= ECHO;
 	if (l & IBCS2_ECHOE)	r |= ECHOE;
 	if (l & IBCS2_ECHOK)	r |= ECHOK;
 	if (l & IBCS2_ECHONL)	r |= ECHONL;
 	if (l & IBCS2_NOFLSH)	r |= NOFLSH;
 	if (l & IBCS2_TOSTOP)	r |= TOSTOP;
 	bt->c_lflag = r;
 	bt->c_cc[VINTR]	=
 	    st->c_cc[IBCS2_VINTR]  ? st->c_cc[IBCS2_VINTR]  : _POSIX_VDISABLE;
 	bt->c_cc[VQUIT] =
 	    st->c_cc[IBCS2_VQUIT]  ? st->c_cc[IBCS2_VQUIT]  : _POSIX_VDISABLE;
 	bt->c_cc[VERASE] =
 	    st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE;
 	bt->c_cc[VKILL] =
 	    st->c_cc[IBCS2_VKILL]  ? st->c_cc[IBCS2_VKILL]  : _POSIX_VDISABLE;
 	if (bt->c_lflag & ICANON) {
 		bt->c_cc[VEOF] =
 		    st->c_cc[IBCS2_VEOF] ? st->c_cc[IBCS2_VEOF] : _POSIX_VDISABLE;
 		bt->c_cc[VEOL] =
 		    st->c_cc[IBCS2_VEOL] ? st->c_cc[IBCS2_VEOL] : _POSIX_VDISABLE;
 	} else {
 		bt->c_cc[VMIN]  = st->c_cc[IBCS2_VMIN];
 		bt->c_cc[VTIME] = st->c_cc[IBCS2_VTIME];
+	}
 	bt->c_cc[VEOL2] =
 	    st->c_cc[IBCS2_VEOL2]  ? st->c_cc[IBCS2_VEOL2]  : _POSIX_VDISABLE;
 #if 0
 	bt->c_cc[VSWTCH] =
 	    st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE;
 #endif
 	bt->c_cc[VSTART] =
 	    st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE;
 	bt->c_cc[VSTOP] =
 	    st->c_cc[IBCS2_VSTOP]  ? st->c_cc[IBCS2_VSTOP]  : _POSIX_VDISABLE;
 	bt->c_cc[VSUSP] =
 	    st->c_cc[IBCS2_VSUSP]  ? st->c_cc[IBCS2_VSUSP]  : _POSIX_VDISABLE;
 	bt->c_cc[VDSUSP]   = _POSIX_VDISABLE;
 	bt->c_cc[VREPRINT] = _POSIX_VDISABLE;
 	bt->c_cc[VDISCARD] = _POSIX_VDISABLE;
 	bt->c_cc[VWERASE]  = _POSIX_VDISABLE;
 	bt->c_cc[VLNEXT]   = _POSIX_VDISABLE;
 	bt->c_cc[VSTATUS]  = _POSIX_VDISABLE;
+}
 static void
 btios2stios(struct termios *bt, struct ibcs2_termios *st)
+{
 	int i;
 	u_long l, r;
 	l = bt->c_iflag;	r = 0;
 	if (l & IGNBRK)		r |= IBCS2_IGNBRK;
 	if (l & BRKINT)		r |= IBCS2_BRKINT;
 	if (l & IGNPAR)		r |= IBCS2_IGNPAR;
 	if (l & PARMRK)		r |= IBCS2_PARMRK;
 	if (l & INPCK)		r |= IBCS2_INPCK;
 	if (l & ISTRIP)		r |= IBCS2_ISTRIP;
 	if (l & INLCR)		r |= IBCS2_INLCR;
 	if (l & IGNCR)		r |= IBCS2_IGNCR;
 	if (l & ICRNL)		r |= IBCS2_ICRNL;
 	if (l & IXON)		r |= IBCS2_IXON;
 	if (l & IXANY)		r |= IBCS2_IXANY;
 	if (l & IXOFF)		r |= IBCS2_IXOFF;
 	if (l & IMAXBEL)	r |= IBCS2_IMAXBEL;
 	st->c_iflag = r;
 	l = bt->c_oflag;	r = 0;
 	if (l & OPOST)		r |= IBCS2_OPOST;
 	if (l & ONLCR)		r |= IBCS2_ONLCR;
 	if (l & OXTABS)		r |= IBCS2_TAB3;
 	st->c_oflag = r;
 	l = bt->c_cflag;	r = 0;
 	switch (l & CSIZE) {
 	case CS5:		r |= IBCS2_CS5; break;
 	case CS6:		r |= IBCS2_CS6; break;
 	case CS7:		r |= IBCS2_CS7; break;
 	case CS8:		r |= IBCS2_CS8; break;
+	}
 	if (l & CSTOPB)		r |= IBCS2_CSTOPB;
 	if (l & CREAD)		r |= IBCS2_CREAD;
 	if (l & PARENB)		r |= IBCS2_PARENB;
 	if (l & PARODD)		r |= IBCS2_PARODD;
 	if (l & HUPCL)		r |= IBCS2_HUPCL;
 	if (l & CLOCAL)		r |= IBCS2_CLOCAL;
 	st->c_cflag = r;
 	l = bt->c_lflag;	r = 0;
 	if (l & ISIG)		r |= IBCS2_ISIG;
 	if (l & ICANON)		r |= IBCS2_ICANON;
 	if (l & ECHO)		r |= IBCS2_ECHO;
 	if (l & ECHOE)		r |= IBCS2_ECHOE;
 	if (l & ECHOK)		r |= IBCS2_ECHOK;
 	if (l & ECHONL)		r |= IBCS2_ECHONL;
 	if (l & NOFLSH)		r |= IBCS2_NOFLSH;
 	if (l & TOSTOP)		r |= IBCS2_TOSTOP;
 	st->c_lflag = r;
 	i = ttspeedtab(bt->c_ospeed, sptab);
 	if (i >= 0)
 		st->c_cflag |= i;
 	st->c_cc[IBCS2_VINTR] =
 	    bt->c_cc[VINTR]  != _POSIX_VDISABLE ? bt->c_cc[VINTR]  : 0;
 	st->c_cc[IBCS2_VQUIT] =
 	    bt->c_cc[VQUIT]  != _POSIX_VDISABLE ? bt->c_cc[VQUIT]  : 0;
 	st->c_cc[IBCS2_VERASE] =
 	    bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0;
 	st->c_cc[IBCS2_VKILL] =
 	    bt->c_cc[VKILL]  != _POSIX_VDISABLE ? bt->c_cc[VKILL]  : 0;
 	if (bt->c_lflag & ICANON) {
 		st->c_cc[IBCS2_VEOF] =
 		    bt->c_cc[VEOF] != _POSIX_VDISABLE ? bt->c_cc[VEOF] : 0;
 		st->c_cc[IBCS2_VEOL] =
 		    bt->c_cc[VEOL] != _POSIX_VDISABLE ? bt->c_cc[VEOL] : 0;
 	} else {
 		st->c_cc[IBCS2_VMIN]  = bt->c_cc[VMIN];
 		st->c_cc[IBCS2_VTIME] = bt->c_cc[VTIME];
+	}
 	st->c_cc[IBCS2_VEOL2] =
 	    bt->c_cc[VEOL2]  != _POSIX_VDISABLE ? bt->c_cc[VEOL2]  : 0;
 	st->c_cc[IBCS2_VSWTCH] =
 ;
 	st->c_cc[IBCS2_VSUSP] =
 	    bt->c_cc[VSUSP]  != _POSIX_VDISABLE ? bt->c_cc[VSUSP]  : 0;
 	st->c_cc[IBCS2_VSTART] =
 	    bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0;
 	st->c_cc[IBCS2_VSTOP] =
 	    bt->c_cc[VSTOP]  != _POSIX_VDISABLE ? bt->c_cc[VSTOP]  : 0;
 	st->c_line = 0;
+}
 static void
 stios2stio(struct ibcs2_termios *ts, struct ibcs2_termio *t)
+{
 	t->c_iflag = ts->c_iflag;
 	t->c_oflag = ts->c_oflag;
 	t->c_cflag = ts->c_cflag;
 	t->c_lflag = ts->c_lflag;
 	t->c_line  = ts->c_line;
 	memcpy(t->c_cc, ts->c_cc, IBCS2_NCC);
+}
 static void
 stio2stios(struct ibcs2_termio *t, struct ibcs2_termios *ts)
+{
 	ts->c_iflag = t->c_iflag;
 	ts->c_oflag = t->c_oflag;
 	ts->c_cflag = t->c_cflag;
 	ts->c_lflag = t->c_lflag;
 	ts->c_line  = t->c_line;
 	memcpy(ts->c_cc, t->c_cc, IBCS2_NCC);
+}
 int
 ibcs2_sys_ioctl(struct lwp *l, const struct ibcs2_sys_ioctl_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(int) cmd;
 		syscallarg(void *) data;
 	} */
 	struct proc *p = l->l_proc;
 	struct file *fp;
 	int (*ctl)(struct file *, u_long, void *);
 	struct termios bts;
 	struct ibcs2_termios sts;
 	struct ibcs2_termio st;
 	struct sys_ioctl_args bsd_ua;
 	int error, t;
 	SCARG(&bsd_ua, fd) = SCARG(uap, fd);
 	SCARG(&bsd_ua, data) = SCARG(uap, data);
 	/* Handle the easy ones first */
 	switch ((unsigned long)SCARG(uap, cmd)) {
 	case IBCS2_TIOCGWINSZ:
 		SCARG(&bsd_ua, com) = TIOCGWINSZ;
 		return sys_ioctl(l, &bsd_ua, retval);
 	case IBCS2_TIOCSWINSZ:
 		SCARG(&bsd_ua, com) = TIOCSWINSZ;
 		return sys_ioctl(l, &bsd_ua, retval);
 	case IBCS2_TIOCGPGRP:
 		return copyout(&p->p_pgrp->pg_id, SCARG(uap, data),
 		    sizeof(p->p_pgrp->pg_id));
 	case IBCS2_TIOCSPGRP:	/* XXX - is uap->data a pointer to pgid? */
+	    {
 		struct sys_setpgid_args sa;
 		SCARG(&sa, pid) = 0;
 		SCARG(&sa, pgid) = (int)SCARG(uap, data);
 		if ((error = sys_setpgid(l, &sa, retval)) != 0)
 			return error;
 		return 0;
+	    }
 	case IBCS2_TCGETSC:	/* SCO console - get scancode flags */
 	case IBCS2_TCSETSC:	/* SCO console - set scancode flags */
 		return ENOSYS;
 	case IBCS2_SIOCSOCKSYS:
 		return ibcs2_socksys(l, (const void *)uap, retval);
 	case IBCS2_I_NREAD:     /* STREAMS */
 		SCARG(&bsd_ua, com) = FIONREAD;
 		return sys_ioctl(l, &bsd_ua, retval);
 	default:
 		break;
+	}
 	if ((fp = fd_getfile(SCARG(uap, fd))) == NULL) {
 		DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid,
 			 SCARG(uap, fd)));
 		return EBADF;
+	}
 	if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
 		DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid));
 		error = EBADF;
 		goto out;
+	}
 	ctl = fp->f_ops->fo_ioctl;
 	switch ((unsigned long)SCARG(uap, cmd)) {
 	case IBCS2_TCGETA:
 	case IBCS2_XCGETA:
 	case IBCS2_OXCGETA:
 		if ((error = (*ctl)(fp, TIOCGETA, &bts)) != 0)
 			goto out;
 		memset(&sts, 0, sizeof(sts));
 		btios2stios(&bts, &sts);
 		if (SCARG(uap, cmd) == IBCS2_TCGETA) {
 			memset(&st, 0, sizeof(st));
 			stios2stio(&sts, &st);
 			error = copyout(&st, SCARG(uap, data), sizeof(st));
 			if (error)
 				DPRINTF(("ibcs2_ioctl(%d): copyout failed ",
 				     p->p_pid));
 		} else
 			error = copyout(&sts, SCARG(uap, data), sizeof(sts));
 		break;
 	case IBCS2_TCSETA:
 	case IBCS2_TCSETAW:
 	case IBCS2_TCSETAF:
 		if ((error = copyin(SCARG(uap, data), &st, sizeof(st))) != 0) {
 			DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ",
 			    p->p_pid));
 			goto out;
+		}
 		/* get full BSD termios so we don't lose information */
 		if ((error = (*ctl)(fp, TIOCGETA, &bts)) != 0) {
 			DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
 			    p->p_pid, SCARG(uap, fd)));
 			goto out;
+		}
 		/*
 		 * convert to iBCS2 termios, copy in information from
 		 * termio, and convert back, then set new values.
 		 */
 		btios2stios(&bts, &sts);
 		stio2stios(&st, &sts);
 		stios2btios(&sts, &bts);
 		t = SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA;
 		error = (*ctl)(fp, t, &bts);
 		break;
 	case IBCS2_XCSETA:
 	case IBCS2_XCSETAW:
 	case IBCS2_XCSETAF:
 		if ((error = copyin(SCARG(uap, data), &sts, sizeof(sts))) != 0)
 			goto out;
 		stios2btios(&sts, &bts);
 		t = SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA;
 		error = (*ctl)(fp, t, &bts);
 		break;
 	case IBCS2_OXCSETA:
 	case IBCS2_OXCSETAW:
 	case IBCS2_OXCSETAF:
 		if ((error = copyin(SCARG(uap, data), &sts, sizeof(sts))) != 0)
 			goto out;
 		stios2btios(&sts, &bts);
 		t = SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA;
 		error = (*ctl)(fp, t, &bts);
 		break;
 	case IBCS2_TCSBRK:
 		t = (int) SCARG(uap, data);
 		t = (t ? t : 1) * hz * 4;
 		t /= 10;
 		if ((error = (*ctl)(fp, TIOCSBRK, NULL)) != 0)
 			goto out;
 		error = tsleep(&t, PZERO | PCATCH, "ibcs2_tcsbrk", t);
 		if (error == EINTR || error == ERESTART) {
 			(void)(*ctl)(fp, TIOCCBRK, NULL);
 			error = EINTR;
 		} else
 			error = (*ctl)(fp, TIOCCBRK, NULL);
 		break;
 	case IBCS2_TCXONC:
 		switch ((int)SCARG(uap, data)) {
 		case 0:
 		case 1:
 			DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid));
 			error = ENOSYS;
 			break;
 		case 2:
 			error = (*ctl)(fp, TIOCSTOP, NULL);
 			break;
 		case 3:
 			error = (*ctl)(fp, TIOCSTART, (void *)1);
 			break;
 		default:
 			error = EINVAL;
 			break;
+		}
 		break;
 	case IBCS2_TCFLSH:
 		switch ((int)SCARG(uap, data)) {
 		case 0:
 			t = FREAD;
 			break;
 		case 1:
 			t = FWRITE;
 			break;
 		case 2:
 			t = FREAD | FWRITE;
 			break;
 		default:
 			error = EINVAL;
 			goto out;
+		}
 		error = (*ctl)(fp, TIOCFLUSH, &t);
 		break;
 	case IBCS2_FIONBIO:
 		if ((error = copyin(SCARG(uap, data), &t, sizeof(t))) != 0)
 			goto out;
 		error = (*ctl)(fp, FIONBIO, (void *)&t);
 		break;
 	default:
 		DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%x ",
 		    p->p_pid, SCARG(uap, cmd)));
 		error = ENOSYS;
 		break;
+	}
  out:
 	fd_putfile(SCARG(uap, fd));
 	return error;
+}
 int
 ibcs2_sys_gtty(struct lwp *l, const struct ibcs2_sys_gtty_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(struct sgttyb *) tb;
 	} */
 	struct file *fp;
 	struct sgttyb tb;
 	struct ibcs2_sgttyb itb;
 	int error;
 	if ((fp = fd_getfile(SCARG(uap, fd))) == NULL) {
 		DPRINTF(("ibcs2_sys_gtty(%d): bad fd %d ", curproc->p_pid,
 			 SCARG(uap, fd)));
 		return EBADF;
+	}
 	if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
 		DPRINTF(("ibcs2_sys_gtty(%d): bad fp flag ", curproc->p_pid));
 		error = EBADF;
 		goto out;
+	}
 	error = (*fp->f_ops->fo_ioctl)(fp, TIOCGETP, (void *)&tb);
 	if (error)
 		goto out;
 	fd_putfile(SCARG(uap, fd));
 	memset(&itb, 0, sizeof(itb));
 	itb.sg_ispeed = tb.sg_ispeed;
 	itb.sg_ospeed = tb.sg_ospeed;
 	itb.sg_erase = tb.sg_erase;
 	itb.sg_kill = tb.sg_kill;
 	itb.sg_flags = tb.sg_flags & ~(IBCS2_GHUPCL|IBCS2_GXTABS);
 	return copyout((void *)&itb, SCARG(uap, tb), sizeof(itb));
 out:
 	fd_putfile(SCARG(uap, fd));
 	return error;
+}

 @@ -1,336 +1,340 @@
-/*	$NetBSD: ibcs2_stat.c,v 1.47 2009/06/29 05:08:16 dholland Exp $	*/
+/*	$NetBSD: ibcs2_stat.c,v 1.47.18.1 2017/08/19 04:13:51 snj Exp $	*/
 /*
  * Copyright (c) 1995, 1998 Scott Bartram
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ibcs2_stat.c,v 1.47 2009/06/29 05:08:16 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ibcs2_stat.c,v 1.47.18.1 2017/08/19 04:13:51 snj Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/proc.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/filedesc.h>
 #include <sys/ioctl.h>
 #include <sys/kernel.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/syscallargs.h>
 #include <sys/vfs_syscalls.h>
 #include <compat/ibcs2/ibcs2_types.h>
 #include <compat/ibcs2/ibcs2_fcntl.h>
 #include <compat/ibcs2/ibcs2_signal.h>
 #include <compat/ibcs2/ibcs2_stat.h>
 #include <compat/ibcs2/ibcs2_statfs.h>
 #include <compat/ibcs2/ibcs2_syscallargs.h>
 #include <compat/ibcs2/ibcs2_ustat.h>
 #include <compat/ibcs2/ibcs2_util.h>
 #include <compat/ibcs2/ibcs2_utsname.h>
 static void bsd_stat2ibcs_stat(struct stat *, struct ibcs2_stat *);
 static int cvt_statfs(struct statvfs *, void *, int);
 static int cvt_statvfs(struct statvfs *, void *, int);
 static void
 bsd_stat2ibcs_stat(struct stat *st, struct ibcs2_stat *st4)
+{
 	memset(st4, 0, sizeof(*st4));
 	st4->st_dev = (ibcs2_dev_t)st->st_dev;
 	st4->st_ino = (ibcs2_ino_t)st->st_ino;
 	st4->st_mode = (ibcs2_mode_t)st->st_mode;
 	if (st->st_nlink >= (1 << 15))
 		st4->st_nlink = (1 << 15) - 1;
 	else
 		st4->st_nlink = (ibcs2_nlink_t)st->st_nlink;
 	st4->st_uid = (ibcs2_uid_t)st->st_uid;
 	st4->st_gid = (ibcs2_gid_t)st->st_gid;
 	st4->st_rdev = (ibcs2_dev_t)st->st_rdev;
 	st4->st_size = (ibcs2_off_t)st->st_size;
 	st4->st_atim = (ibcs2_time_t)st->st_atime;
 	st4->st_mtim = (ibcs2_time_t)st->st_mtime;
 	st4->st_ctim = (ibcs2_time_t)st->st_ctime;
+}
 static int
 cvt_statfs(struct statvfs *sp, void *tbuf, int len)
+{
 	struct ibcs2_statfs ssfs;
 	if (len < 0)
 		return (EINVAL);
 	if (len > sizeof(ssfs))
 		len = sizeof(ssfs);
 	memset(&ssfs, 0, sizeof ssfs);
 	ssfs.f_fstyp = 0;
 	ssfs.f_bsize = sp->f_bsize;
 	ssfs.f_frsize = sp->f_frsize;
 	ssfs.f_blocks = sp->f_blocks;
 	ssfs.f_bfree = sp->f_bfree;
 	ssfs.f_files = sp->f_files;
 	ssfs.f_ffree = sp->f_ffree;
 	ssfs.f_fname[0] = 0;
 	ssfs.f_fpack[0] = 0;
 	return copyout((void *)&ssfs, tbuf, len);
+}
 static int
 cvt_statvfs(struct statvfs *sp, void *tbuf, int len)
+{
 	struct ibcs2_statvfs ssvfs;
 	if (len < 0)
 		return (EINVAL);
 	if (len > sizeof(ssvfs))
 		len = sizeof(ssvfs);
 	memset(&ssvfs, 0, sizeof ssvfs);
 	ssvfs.f_bsize = sp->f_bsize;
 	ssvfs.f_frsize = sp->f_frsize;
 	ssvfs.f_blocks = sp->f_blocks;
 	ssvfs.f_bfree = sp->f_bfree;
 	ssvfs.f_bavail = sp->f_bavail;
 	ssvfs.f_files = sp->f_files;
 	ssvfs.f_ffree = sp->f_ffree;
 	ssvfs.f_favail = sp->f_favail;
 	ssvfs.f_fsid = sp->f_fsidx.__fsid_val[0];
 	strncpy(ssvfs.f_basetype, sp->f_fstypename, 15);
 	ssvfs.f_flag = 0;
 	ssvfs.f_namemax = PATH_MAX;
 	ssvfs.f_fstr[0] = 0;
 	return copyout((void *)&ssvfs, tbuf, len);
+}
 int
 ibcs2_sys_statfs(struct lwp *l, const struct ibcs2_sys_statfs_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const char *) path;
 		syscallarg(struct ibcs2_statfs *) buf;
 		syscallarg(int) len;
 		syscallarg(int) fstype;
 	} */
 	struct mount *mp;
 	struct statvfs *sp;
 	int error;
 	struct vnode *vp;
 	error = namei_simple_user(SCARG(uap, path),
 				NSM_FOLLOW_TRYEMULROOT, &vp);
 	if (error != 0)
 		return (error);
 	mp = vp->v_mount;
 	sp = &mp->mnt_stat;
 	vrele(vp);
 	if ((error = VFS_STATVFS(mp, sp)) != 0)
-		return (error);
+		goto out;
 	sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
-	return cvt_statfs(sp, (void *)SCARG(uap, buf), SCARG(uap, len));
+	error = cvt_statfs(sp, (void *)SCARG(uap, buf), SCARG(uap, len));
 out:
 	vrele(vp);
 	return (error);
+}
 int
 ibcs2_sys_fstatfs(struct lwp *l, const struct ibcs2_sys_fstatfs_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(struct ibcs2_statfs *) buf;
 		syscallarg(int) len;
 		syscallarg(int) fstype;
 	} */
 	file_t *fp;
 	struct mount *mp;
 	struct statvfs *sp;
 	int error;
 	/* fd_getvnode() will use the descriptor for us */
 	if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
 		return (error);
 	mp = ((struct vnode *)fp->f_data)->v_mount;
 	sp = &mp->mnt_stat;
 	if ((error = VFS_STATVFS(mp, sp)) != 0)
 		goto out;
 	sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
 	error = cvt_statfs(sp, (void *)SCARG(uap, buf), SCARG(uap, len));
  out:
  	fd_putfile(SCARG(uap, fd));
 	return (error);
+}
 int
 ibcs2_sys_statvfs(struct lwp *l, const struct ibcs2_sys_statvfs_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const char *) path;
 		syscallarg(struct ibcs2_statvfs *) buf;
 	} */
 	struct mount *mp;
 	struct statvfs *sp;
 	int error;
 	struct vnode *vp;
 	error = namei_simple_user(SCARG(uap, path),
 				NSM_FOLLOW_TRYEMULROOT, &vp);
 	if (error != 0)
 		return (error);
 	mp = vp->v_mount;
 	sp = &mp->mnt_stat;
 	vrele(vp);
 	if ((error = VFS_STATVFS(mp, sp)) != 0)
-		return (error);
+		goto out;
 	sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
-	return cvt_statvfs(sp, (void *)SCARG(uap, buf),
+	error = cvt_statvfs(sp, (void *)SCARG(uap, buf),
-			   sizeof(struct ibcs2_statvfs));
+	    sizeof(struct ibcs2_statvfs));
 out:
 	vrele(vp);
 	return error;
+}
 int
 ibcs2_sys_fstatvfs(struct lwp *l, const struct ibcs2_sys_fstatvfs_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(struct ibcs2_statvfs *) buf;
 	} */
 	file_t *fp;
 	struct mount *mp;
 	struct statvfs *sp;
 	int error;
 	/* fd_getvnode() will use the descriptor for us */
 	if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
 		return (error);
 	mp = ((struct vnode *)fp->f_data)->v_mount;
 	sp = &mp->mnt_stat;
 	if ((error = VFS_STATVFS(mp, sp)) != 0)
 		goto out;
 	sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
 	error = cvt_statvfs(sp, SCARG(uap, buf), sizeof(struct ibcs2_statvfs));
  out:
  	fd_putfile(SCARG(uap, fd));
 	return (error);
+}
 int
 ibcs2_sys_stat(struct lwp *l, const struct ibcs2_sys_stat_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const char *) path;
 		syscallarg(struct ibcs2_stat *) st;
 	} */
 	struct stat sb;
 	struct ibcs2_stat ibcs2_st;
 	int error;
 	error = do_sys_stat(SCARG(uap, path), FOLLOW, &sb);
 	if (error != 0)
 		return error;
 	bsd_stat2ibcs_stat(&sb, &ibcs2_st);
 	return copyout(&ibcs2_st, SCARG(uap, st), sizeof (ibcs2_st));
+}
 int
 ibcs2_sys_lstat(struct lwp *l, const struct ibcs2_sys_lstat_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const char *) path;
 		syscallarg(struct ibcs2_stat *) st;
 	} */
 	struct stat sb;
 	struct ibcs2_stat ibcs2_st;
 	int error;
 	error = do_sys_stat(SCARG(uap, path), NOFOLLOW, &sb);
 	if (error != 0)
 		return error;
 	bsd_stat2ibcs_stat(&sb, &ibcs2_st);
 	return copyout((void *)&ibcs2_st, (void *)SCARG(uap, st),
 		       sizeof (ibcs2_st));
+}
 int
 ibcs2_sys_fstat(struct lwp *l, const struct ibcs2_sys_fstat_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(struct ibcs2_stat *) st;
 	} */
 	struct stat sb;
 	struct ibcs2_stat ibcs2_st;
 	int error;
 	error = do_sys_fstat(SCARG(uap, fd), &sb);
 	if (error != 0)
 		return error;
 	bsd_stat2ibcs_stat(&sb, &ibcs2_st);
 	return copyout(&ibcs2_st, SCARG(uap, st), sizeof (ibcs2_st));
+}
 int
 ibcs2_sys_utssys(struct lwp *l, const struct ibcs2_sys_utssys_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) a1;
 		syscallarg(int) a2;
 		syscallarg(int) flag;
 	} */
 	switch (SCARG(uap, flag)) {
 	case 0:			/* uname(struct utsname *) */
+	{
 		struct ibcs2_utsname sut;
 		memset(&sut, 0, ibcs2_utsname_len);
 		memcpy(sut.sysname, ostype, sizeof(sut.sysname) - 1);
 		memcpy(sut.nodename, hostname, sizeof(sut.nodename));
 		sut.nodename[sizeof(sut.nodename)-1] = '\0';
 		memcpy(sut.release, osrelease, sizeof(sut.release) - 1);
 		strlcpy(sut.version, "1", sizeof(sut.version));
 		memcpy(sut.machine, machine, sizeof(sut.machine) - 1);
 		return copyout((void *)&sut, (void *)SCARG(uap, a1),
 			       ibcs2_utsname_len);
+	}
 	case 2:			/* ustat(dev_t, struct ustat *) */
+	{
 		struct ibcs2_ustat xu;
 		xu.f_tfree = 20000; /* XXX fixme */
 		xu.f_tinode = 32000;
 		xu.f_fname[0] = 0;
 		xu.f_fpack[0] = 0;
 		return copyout((void *)&xu, (void *)SCARG(uap, a2),
                                ibcs2_ustat_len);
+	}
 	default:
 		return ENOSYS;
+	}
+}