xref: /netbsd-src/sys/compat/netbsd32/netbsd32_ioctl.c (revision c2f489221e6bef1a8efa6f93091db60d97764d82)

/*	$NetBSD: netbsd32_ioctl.c,v 1.122 2024/11/10 16:20:12 riastradh Exp $	*/

/*
 * Copyright (c) 1998, 2001 Matthew R. Green
 * 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.
 *
 * 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.
 */

/*
 * handle ioctl conversions from netbsd32 -> 64-bit kernel
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: netbsd32_ioctl.c,v 1.122 2024/11/10 16:20:12 riastradh Exp $");

#if defined(_KERNEL_OPT)
#include "opt_ntp.h"
#endif

#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/systm.h>
#include <sys/filedesc.h>
#include <sys/ioctl.h>
#include <sys/file.h>
#include <sys/proc.h>
#include <sys/socketvar.h>
#include <sys/audioio.h>
#include <sys/disklabel.h>
#include <sys/dkio.h>
#include <sys/ataio.h>
#include <sys/sockio.h>
#include <sys/socket.h>
#include <sys/ttycom.h>
#include <sys/mount.h>
#include <sys/syscallargs.h>
#include <sys/ktrace.h>
#include <sys/kmem.h>
#include <sys/envsys.h>
#include <sys/wdog.h>
#include <sys/clockctl.h>
#include <sys/exec_elf.h>
#include <sys/ksyms.h>
#include <sys/drvctlio.h>
#include <sys/compat_stub.h>

#include <sys/vnode.h>
#include <sys/conf.h>
#include <miscfs/specfs/specdev.h>

#ifdef __sparc__
#include <dev/sun/fbio.h>
#include <machine/openpromio.h>
#endif

#include <net/if.h>
#include <net/route.h>

#include <net/if_pppoe.h>
#include <net/if_sppp.h>

#include <net/bpf.h>
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <netinet/igmp.h>
#include <netinet/igmp_var.h>
#include <netinet/ip_mroute.h>

#include <netinet6/nd6.h>
#include <netinet6/in6_var.h>

#include <compat/sys/sockio.h>

#include <compat/netbsd32/netbsd32.h>
#include <compat/netbsd32/netbsd32_ioctl.h>
#include <compat/netbsd32/netbsd32_syscallargs.h>
#include <compat/netbsd32/netbsd32_conv.h>

#include <dev/fssvar.h>
#include <dev/vndvar.h>

/* convert to/from different structures */

#if 0
static inline void
netbsd32_to_format_op(struct netbsd32_format_op *s32p,
    struct format_op *p, u_long cmd)
{

	p->df_buf = (char *)NETBSD32PTR64(s32p->df_buf);
	p->df_count = s32p->df_count;
	p->df_startblk = s32p->df_startblk;
	memcpy(p->df_reg, s32p->df_reg, sizeof(s32p->df_reg));
}
#endif

static inline void
netbsd32_to_ifreq(struct netbsd32_ifreq *s32p, struct ifreq *p, u_long cmd)
{

	memcpy(p, s32p, sizeof *s32p);
	/*
	 * XXX
	 * struct ifreq says the same, but sometimes the ifr_data
	 * union member needs to be converted to 64 bits... this
	 * is very driver specific and so we ignore it for now..
	 */
	switch (cmd) {
	case SIOCGIFDATA:
	case SIOCZIFDATA:
	case SIOCGIFGENERIC:
	case SIOCSIFGENERIC:
		p->ifr_data = (void *)NETBSD32PTR64(s32p->ifr_data);
		break;
	}
}

static inline void
netbsd32_to_oifreq(struct netbsd32_oifreq *s32p, struct oifreq *p, u_long cmd)
{

	memcpy(p, s32p, sizeof *s32p);
	/*
	 * XXX
	 * struct ifreq says the same, but sometimes the ifr_data
	 * union member needs to be converted to 64 bits... this
	 * is very driver specific and so we ignore it for now..
	 */
	if (cmd == SIOCGIFDATA || cmd == SIOCZIFDATA)
		p->ifr_data = (void *)NETBSD32PTR64(s32p->ifr_data);
}

static inline void
netbsd32_to_ifdatareq(struct netbsd32_ifdatareq *s32p, struct ifdatareq *p, u_long cmd)
{

	memcpy(p, s32p, sizeof *s32p);
	switch (cmd) {
	case SIOCGIFDATA:
	case SIOCZIFDATA:
		netbsd32_to_timespec(&s32p->ifdr_data.ifi_lastchange,
		    &p->ifdr_data.ifi_lastchange);
		break;
	}
}

static inline void
netbsd32_to_if_addrprefreq(const struct netbsd32_if_addrprefreq *ifap32,
    struct if_addrprefreq *ifap, u_long cmd)
{

	memcpy(ifap->ifap_name, ifap32->ifap_name, IFNAMSIZ);
	ifap->ifap_preference = ifap32->ifap_preference;
	memcpy(&ifap->ifap_addr, &ifap32->ifap_addr,
	    uimin(ifap32->ifap_addr.ss_len, _SS_MAXSIZE));
}

static inline void
netbsd32_to_ifconf(struct netbsd32_ifconf *s32p, struct ifconf *p, u_long cmd)
{

	p->ifc_len = s32p->ifc_len;
	/* ifc_buf & ifc_req are the same size so this works */
	p->ifc_buf = (void *)NETBSD32PTR64(s32p->ifc_buf);
}

static inline void
netbsd32_to_ifmediareq(struct netbsd32_ifmediareq *s32p,
    struct ifmediareq *p, u_long cmd)
{

	memcpy(p, s32p, sizeof *s32p);
	p->ifm_ulist = (int *)NETBSD32PTR64(s32p->ifm_ulist);
}

static inline void
netbsd32_to_in_nbrinfo(struct netbsd32_in_nbrinfo *s32p, struct in_nbrinfo *p,
    u_long cmd)
{

	memcpy(p->ifname, s32p->ifname, sizeof p->ifname);
	memcpy(&p->addr, &s32p->addr, sizeof p->addr);
	p->asked = s32p->asked;
	p->state = s32p->state;
	p->expire = s32p->expire;
}

static inline void
netbsd32_to_in6_nbrinfo(struct netbsd32_in6_nbrinfo *s32p, struct in6_nbrinfo *p,
    u_long cmd)
{

	memcpy(p->ifname, s32p->ifname, sizeof p->ifname);
	memcpy(&p->addr, &s32p->addr, sizeof p->addr);
	p->asked = s32p->asked;
	p->isrouter = s32p->isrouter;
	p->state = s32p->state;
	p->expire = s32p->expire;
}

static inline void
netbsd32_to_pppoediscparms(struct netbsd32_pppoediscparms *s32p,
    struct pppoediscparms *p, u_long cmd)
{

	memcpy(p->ifname, s32p->ifname, sizeof p->ifname);
	memcpy(p->eth_ifname, s32p->eth_ifname, sizeof p->eth_ifname);
	p->ac_name = (char *)NETBSD32PTR64(s32p->ac_name);
	p->ac_name_len = s32p->ac_name_len;
	p->service_name = (char *)NETBSD32PTR64(s32p->service_name);
	p->service_name_len = s32p->service_name_len;
}

static inline void
netbsd32_to_spppauthcfg(struct netbsd32_spppauthcfg *s32p,
    struct spppauthcfg *p, u_long cmd)
{

	memcpy(p->ifname, s32p->ifname, sizeof p->ifname);
	p->hisauth = s32p->hisauth;
	p->myauth = s32p->myauth;
	p->myname_length = s32p->myname_length;
	p->mysecret_length = s32p->mysecret_length;
	p->hisname_length = s32p->hisname_length;
	p->hissecret_length = s32p->hissecret_length;
	p->myauthflags = s32p->myauthflags;
	p->hisauthflags = s32p->hisauthflags;
	p->myname = (char *)NETBSD32PTR64(s32p->myname);
	p->mysecret = (char *)NETBSD32PTR64(s32p->mysecret);
	p->hisname = (char *)NETBSD32PTR64(s32p->hisname);
	p->hissecret = (char *)NETBSD32PTR64(s32p->hissecret);
}

static inline void
netbsd32_to_ifdrv(struct netbsd32_ifdrv *s32p, struct ifdrv *p, u_long cmd)
{

	memcpy(p->ifd_name, s32p->ifd_name, sizeof p->ifd_name);
	p->ifd_cmd = s32p->ifd_cmd;
	p->ifd_len = s32p->ifd_len;
	p->ifd_data = (void *)NETBSD32PTR64(s32p->ifd_data);
}

static inline void
netbsd32_to_sioc_vif_req(struct netbsd32_sioc_vif_req *s32p,
    struct sioc_vif_req *p, u_long cmd)
{

	p->vifi = s32p->vifi;
	p->icount = (u_long)s32p->icount;
	p->ocount = (u_long)s32p->ocount;
	p->ibytes = (u_long)s32p->ibytes;
	p->obytes = (u_long)s32p->obytes;
}

static inline void
netbsd32_to_sioc_sg_req(struct netbsd32_sioc_sg_req *s32p,
    struct sioc_sg_req *p, u_long cmd)
{

	p->src = s32p->src;
	p->grp = s32p->grp;
	p->pktcnt = (u_long)s32p->pktcnt;
	p->bytecnt = (u_long)s32p->bytecnt;
	p->wrong_if = (u_long)s32p->wrong_if;
}

static inline void
netbsd32_to_kfilter_mapping(struct netbsd32_kfilter_mapping *s32p,
    struct kfilter_mapping *p, u_long cmd)
{

	p->name = (char *)NETBSD32PTR64(s32p->name);
	p->len = s32p->len;
	p->filter = s32p->filter;
}

static inline void
netbsd32_to_atareq(struct netbsd32_atareq *s32p, struct atareq *p, u_long cmd)
{

	p->flags = (u_long)s32p->flags;
	p->command = s32p->command;
	p->features = s32p->features;
	p->sec_count = s32p->sec_count;
	p->sec_num = s32p->sec_num;
	p->head = s32p->head;
	p->cylinder = s32p->cylinder;
	p->databuf =  (char *)NETBSD32PTR64(s32p->databuf);
	p->datalen = (u_long)s32p->datalen;
	p->timeout = s32p->timeout;
	p->retsts = s32p->retsts;
	p->error = s32p->error;
}

static inline void
netbsd32_to_fss_set(struct netbsd32_fss_set *s32p, struct fss_set *p,
    u_long cmd)
{

	p->fss_mount = (char *)NETBSD32PTR64(s32p->fss_mount);
	p->fss_bstore = (char *)NETBSD32PTR64(s32p->fss_bstore);
	p->fss_csize = s32p->fss_csize;
	p->fss_flags = s32p->fss_flags;
}

static inline void
netbsd32_to_fss_get(struct netbsd32_fss_get *s32p, struct fss_get *p,
    u_long cmd)
{

	memcpy(p->fsg_mount, s32p->fsg_mount, MNAMELEN);
	netbsd32_to_timeval(&s32p->fsg_time, &p->fsg_time);
	p->fsg_csize = s32p->fsg_csize;
	p->fsg_mount_size = s32p->fsg_mount_size;
	p->fsg_bs_size = s32p->fsg_bs_size;

}

static inline void
netbsd32_to_vnd_ioctl(struct netbsd32_vnd_ioctl *s32p,
    struct vnd_ioctl *p, u_long cmd)
{

	p->vnd_file = (char *)NETBSD32PTR64(s32p->vnd_file);
	p->vnd_flags = s32p->vnd_flags;
	p->vnd_geom = s32p->vnd_geom;
	p->vnd_osize = s32p->vnd_osize;
	p->vnd_size = s32p->vnd_size;
}

static inline void
netbsd32_to_vnd_user(struct netbsd32_vnd_user *s32p,
    struct vnd_user *p, u_long cmd)
{

	p->vnu_unit = s32p->vnu_unit;
	p->vnu_dev = s32p->vnu_dev;
	p->vnu_ino = s32p->vnu_ino;
}

static inline void
netbsd32_to_vnd_ioctl50(struct netbsd32_vnd_ioctl50 *s32p,
    struct vnd_ioctl50 *p, u_long cmd)
{

	p->vnd_file = (char *)NETBSD32PTR64(s32p->vnd_file);
	p->vnd_flags = s32p->vnd_flags;
	p->vnd_geom = s32p->vnd_geom;
	p->vnd_size = s32p->vnd_size;
}

static inline void
netbsd32_to_plistref(struct netbsd32_plistref *s32p,
    struct plistref *p, u_long cmd)
{

	p->pref_plist = NETBSD32PTR64(s32p->pref_plist);
	p->pref_len = s32p->pref_len;
}

static inline void
netbsd32_to_nvlist_ref_t(netbsd32_nvlist_ref_t *s32p,
    nvlist_ref_t *p, u_long cmd)
{

	p->buf = NETBSD32PTR64(s32p->buf);
	p->len = s32p->len;
	p->flags = s32p->flags;
}

static inline void
netbsd32_to_u_long(netbsd32_u_long *s32p, u_long *p, u_long cmd)
{

	*p = (u_long)*s32p;
}

static inline void
netbsd32_to_voidp(netbsd32_voidp *s32p, voidp *p, u_long cmd)
{

	*p = (void *)NETBSD32PTR64(*s32p);
}

static inline void
netbsd32_to_wdog_conf(struct netbsd32_wdog_conf *s32p,
    struct wdog_conf *p, u_long cmd)
{

	p->wc_names = (char *)NETBSD32PTR64(s32p->wc_names);
	p->wc_count = s32p->wc_count;
}

static inline void
netbsd32_to_npf_ioctl_table(const struct netbsd32_npf_ioctl_table *s32p,
    struct npf_ioctl_table *p, u_long cmd)
{

       p->nct_cmd = s32p->nct_cmd;
       p->nct_name = NETBSD32PTR64(s32p->nct_name);
       switch (s32p->nct_cmd) {
       case NPF_CMD_TABLE_LOOKUP:
       case NPF_CMD_TABLE_ADD:
       case NPF_CMD_TABLE_REMOVE:
               p->nct_data.ent = s32p->nct_data.ent;
               break;
       case NPF_CMD_TABLE_LIST:
               p->nct_data.buf.buf = NETBSD32PTR64(s32p->nct_data.buf.buf);
               p->nct_data.buf.len = s32p->nct_data.buf.len;
               break;
       }
}

static inline void
netbsd32_to_bpf_program(struct netbsd32_bpf_program *s32p,
    struct bpf_program *p, u_long cmd)
{

	p->bf_insns = (void *)NETBSD32PTR64(s32p->bf_insns);
	p->bf_len = s32p->bf_len;
}

static inline void
netbsd32_to_bpf_dltlist(struct netbsd32_bpf_dltlist *s32p,
    struct bpf_dltlist *p, u_long cmd)
{

	p->bfl_list = (void *)NETBSD32PTR64(s32p->bfl_list);
	p->bfl_len = s32p->bfl_len;
}

/* wsdisplay stuff */
static inline void
netbsd32_to_wsdisplay_addscreendata(
    struct netbsd32_wsdisplay_addscreendata *asd32,
    struct wsdisplay_addscreendata *asd, u_long cmd)
{

	asd->screentype = (char *)NETBSD32PTR64(asd32->screentype);
	asd->emul = (char *)NETBSD32PTR64(asd32->emul);
	asd->idx = asd32->idx;
}

static inline void
netbsd32_to_ieee80211req(struct netbsd32_ieee80211req *ireq32,
    struct ieee80211req *ireq, u_long cmd)
{

	memcpy(ireq->i_name, ireq32->i_name, IFNAMSIZ);
	ireq->i_type = ireq32->i_type;
	ireq->i_val = ireq32->i_val;
	ireq->i_len = ireq32->i_len;
	ireq->i_data = NETBSD32PTR64(ireq32->i_data);
}

static inline void
netbsd32_to_ieee80211_nwkey(struct netbsd32_ieee80211_nwkey *nwk32,
    struct ieee80211_nwkey *nwk, u_long cmd)
{
	int i;

	memcpy(nwk->i_name, nwk32->i_name, IFNAMSIZ);
	nwk->i_wepon = nwk32->i_wepon;
	nwk->i_defkid = nwk32->i_defkid;
	for (i = 0; i < IEEE80211_WEP_NKID; i++) {
		nwk->i_key[i].i_keylen = nwk32->i_key[i].i_keylen;
		nwk->i_key[i].i_keydat =
		    NETBSD32PTR64(nwk32->i_key[i].i_keydat);
	}
}

static inline void
netbsd32_to_wsdisplay_cursor(struct netbsd32_wsdisplay_cursor *c32,
    struct wsdisplay_cursor *c, u_long cmd)
{

	c->which = c32->which;
	c->enable = c32->enable;
	c->pos.x = c32->pos.x;
	c->pos.y = c32->pos.y;
	c->hot.x = c32->hot.x;
	c->hot.y = c32->hot.y;
	c->size.x = c32->size.x;
	c->size.y = c32->size.y;
	c->cmap.index = c32->cmap.index;
	c->cmap.count = c32->cmap.count;
	c->cmap.red = NETBSD32PTR64(c32->cmap.red);
	c->cmap.green = NETBSD32PTR64(c32->cmap.green);
	c->cmap.blue = NETBSD32PTR64(c32->cmap.blue);
	c->image = NETBSD32PTR64(c32->image);
	c->mask = NETBSD32PTR64(c32->mask);
}

static inline void
netbsd32_to_wsdisplay_cmap(struct netbsd32_wsdisplay_cmap *c32,
    struct wsdisplay_cmap *c, u_long cmd)
{

	c->index = c32->index;
	c->count = c32->count;
	c->red   = NETBSD32PTR64(c32->red);
	c->green = NETBSD32PTR64(c32->green);
	c->blue  = NETBSD32PTR64(c32->blue);
}

static inline void
netbsd32_to_wsdisplay_font(struct netbsd32_wsdisplay_font *f32,
    struct wsdisplay_font *f, u_long cmd)
{

	f->name = NETBSD32PTR64(f32->name);
	f->firstchar = f32->firstchar;
	f->numchars = f32->numchars;
	f->encoding = f32->encoding;
	f->fontwidth = f32->fontwidth;
	f->fontheight = f32->fontheight;
	f->stride = f32->stride;
	f->bitorder = f32->bitorder;
	f->byteorder = f32->byteorder;
	f->data = NETBSD32PTR64(f32->data);
}

static inline void
netbsd32_to_wsdisplay_usefontdata(struct netbsd32_wsdisplay_usefontdata *f32,
    struct wsdisplay_usefontdata *f, u_long cmd)
{

	f->name = NETBSD32PTR64(f32->name);
}

static inline void
netbsd32_to_clockctl_settimeofday(
    const struct netbsd32_clockctl_settimeofday *s32p,
    struct clockctl_settimeofday *p, u_long cmd)
{

	p->tv = NETBSD32PTR64(s32p->tv);
	p->tzp = NETBSD32PTR64(s32p->tzp);
}

static inline void
netbsd32_to_clockctl_adjtime(
    const struct netbsd32_clockctl_adjtime *s32p,
    struct clockctl_adjtime *p, u_long cmd)
{

	p->delta = NETBSD32PTR64(s32p->delta);
	p->olddelta = NETBSD32PTR64(s32p->olddelta);
}

static inline void
netbsd32_to_clockctl_clock_settime(
    const struct netbsd32_clockctl_clock_settime *s32p,
    struct clockctl_clock_settime *p, u_long cmd)
{

	p->clock_id = s32p->clock_id;
	p->tp = NETBSD32PTR64(s32p->tp);
}

#ifdef NTP
static inline void
netbsd32_to_clockctl_ntp_adjtime(
    const struct netbsd32_clockctl_ntp_adjtime *s32p,
    struct clockctl_ntp_adjtime *p, u_long cmd)
{

	p->tp = NETBSD32PTR64(s32p->tp);
	p->retval = s32p->retval;
}
#endif

static inline void
netbsd32_to_ksyms_gsymbol(const struct netbsd32_ksyms_gsymbol *s32p,
    struct ksyms_gsymbol *p, u_long cmd)
{

	p->kg_name = NETBSD32PTR64(s32p->kg_name);
}

static inline void
netbsd32_to_ksyms_gvalue(const struct netbsd32_ksyms_gvalue *s32p,
    struct ksyms_gvalue *p, u_long cmd)
{

	p->kv_name = NETBSD32PTR64(s32p->kv_name);
}

static inline void
netbsd32_to_devlistargs(const struct netbsd32_devlistargs *s32p,
    struct devlistargs *p, u_long cmd)
{

	memcpy(p->l_devname, s32p->l_devname, sizeof(p->l_devname));
	p->l_children = s32p->l_children;
	p->l_childname = NETBSD32PTR64(s32p->l_childname);
}

static inline void
netbsd32_to_devrescanargs(const struct netbsd32_devrescanargs *s32p,
    struct devrescanargs *p, u_long cmd)
{

	memcpy(p->busname, s32p->busname, sizeof(p->busname));
	memcpy(p->ifattr, s32p->ifattr, sizeof(p->ifattr));
	p->numlocators = s32p->numlocators;
	p->locators = NETBSD32PTR64(s32p->locators);
}

static inline void
netbsd32_to_disk_strategy(const struct netbsd32_disk_strategy *s32p,
    struct disk_strategy *p, u_long cmd)
{

	memcpy(p->dks_name, s32p->dks_name, sizeof(p->dks_name));
	p->dks_param = NETBSD32PTR64(s32p->dks_param);
	p->dks_paramlen = s32p->dks_paramlen;
}

static inline void
netbsd32_to_dkwedge_list(const struct netbsd32_dkwedge_list *s32p,
    struct dkwedge_list *p, u_long cmd)
{

	p->dkwl_buf = NETBSD32PTR64(s32p->dkwl_buf);
	p->dkwl_bufsize = s32p->dkwl_bufsize;
	p->dkwl_nwedges = s32p->dkwl_nwedges;
	p->dkwl_ncopied = s32p->dkwl_ncopied;
}

/*
 * handle ioctl conversions from 64-bit kernel -> netbsd32
 */

#if 0
static inline void
netbsd32_from_format_op(struct format_op *p,
    struct netbsd32_format_op *s32p, u_long cmd)
{

/* filled in */
#if 0
	s32p->df_buf = (netbsd32_charp)p->df_buf;
#endif
	s32p->df_count = p->df_count;
	s32p->df_startblk = p->df_startblk;
	memcpy(s32p->df_reg, p->df_reg, sizeof(p->df_reg));
}
#endif

static inline void
netbsd32_from_ifreq(struct ifreq *p, struct netbsd32_ifreq *s32p, u_long cmd)
{

	/*
	 * XXX
	 * struct ifreq says the same, but sometimes the ifr_data
	 * union member needs to be converted to 64 bits... this
	 * is very driver specific and so we ignore it for now..
	 */
	memcpy(s32p, p, sizeof *s32p);
	switch (cmd) {
	case SIOCGIFDATA:
	case SIOCZIFDATA:
	case SIOCGIFGENERIC:
	case SIOCSIFGENERIC:
		NETBSD32PTR32(s32p->ifr_data, p->ifr_data);
		break;
	}
}

static inline void
netbsd32_from_oifreq(struct oifreq *p,
    struct netbsd32_oifreq *s32p, u_long cmd)
{

	/*
	 * XXX
	 * struct ifreq says the same, but sometimes the ifr_data
	 * union member needs to be converted to 64 bits... this
	 * is very driver specific and so we ignore it for now..
	 */
	memcpy(s32p, p, sizeof *s32p);
	if (cmd == SIOCGIFDATA || cmd == SIOCZIFDATA)
		NETBSD32PTR32(s32p->ifr_data, p->ifr_data);
}

static inline void
netbsd32_from_ifdatareq(const struct ifdatareq *p, struct netbsd32_ifdatareq *p32, u_long cmd)
{

	memcpy(p32, p, sizeof *p32);
	switch (cmd) {
	case SIOCGIFDATA:
	case SIOCZIFDATA:
		netbsd32_from_timespec(&p->ifdr_data.ifi_lastchange,
		    &p32->ifdr_data.ifi_lastchange);
		break;
	}
}

static inline void
netbsd32_from_if_addrprefreq(const struct if_addrprefreq *ifap,
    struct netbsd32_if_addrprefreq *ifap32, u_long cmd)
{

	memcpy(ifap32->ifap_name, ifap->ifap_name, IFNAMSIZ);
	ifap32->ifap_preference = ifap->ifap_preference;
	memcpy(&ifap32->ifap_addr, &ifap->ifap_addr,
	    uimin(ifap->ifap_addr.ss_len, _SS_MAXSIZE));
}

static inline void
netbsd32_from_ifconf(struct ifconf *p,
    struct netbsd32_ifconf *s32p, u_long cmd)
{

	s32p->ifc_len = p->ifc_len;
	/* ifc_buf & ifc_req are the same size so this works */
	NETBSD32PTR32(s32p->ifc_buf, p->ifc_buf);
}

static inline void
netbsd32_from_ifmediareq(struct ifmediareq *p,
    struct netbsd32_ifmediareq *s32p, u_long cmd)
{

	memcpy(s32p, p, sizeof *p);
/* filled in? */
#if 0
	s32p->ifm_ulist = (netbsd32_intp_t)p->ifm_ulist;
#endif
}

static inline void
netbsd32_from_in_nbrinfo(struct in_nbrinfo *p, struct netbsd32_in_nbrinfo *s32p,
    u_long cmd)
{

	memcpy(s32p->ifname, p->ifname, sizeof s32p->ifname);
	memcpy(&s32p->addr, &p->addr, sizeof s32p->addr);
	s32p->asked = p->asked;
	s32p->state = p->state;
	s32p->expire = p->expire;
}

static inline void
netbsd32_from_in6_nbrinfo(struct in6_nbrinfo *p, struct netbsd32_in6_nbrinfo *s32p,
    u_long cmd)
{

	memcpy(s32p->ifname, p->ifname, sizeof s32p->ifname);
	memcpy(&s32p->addr, &p->addr, sizeof s32p->addr);
	s32p->asked = p->asked;
	s32p->isrouter = p->isrouter;
	s32p->state = p->state;
	s32p->expire = p->expire;
}

static inline void
netbsd32_from_pppoediscparms(struct pppoediscparms *p,
    struct netbsd32_pppoediscparms *s32p, u_long cmd)
{

	memcpy(s32p->ifname, p->ifname, sizeof s32p->ifname);
	memcpy(s32p->eth_ifname, p->eth_ifname, sizeof s32p->eth_ifname);
	NETBSD32PTR32(s32p->ac_name, p->ac_name);
	s32p->ac_name_len = p->ac_name_len;
	NETBSD32PTR32(s32p->service_name, p->service_name);
	s32p->service_name_len = p->service_name_len;
}

static inline void
netbsd32_from_spppauthcfg(struct spppauthcfg *p,
    struct netbsd32_spppauthcfg *s32p, u_long cmd)
{

	memcpy(s32p->ifname, p->ifname, sizeof s32p->ifname);
	s32p->hisauth = p->hisauth;
	s32p->myauth = p->myauth;
	s32p->myname_length = p->myname_length;
	s32p->mysecret_length = p->mysecret_length;
	s32p->hisname_length = p->hisname_length;
	s32p->hissecret_length = p->hissecret_length;
	s32p->myauthflags = p->myauthflags;
	s32p->hisauthflags = p->hisauthflags;
	NETBSD32PTR32(s32p->myname, p->myname);
	NETBSD32PTR32(s32p->mysecret, p->mysecret);
	NETBSD32PTR32(s32p->hisname, p->hisname);
	NETBSD32PTR32(s32p->hissecret, p->hissecret);
}

static inline void
netbsd32_from_ifdrv(struct ifdrv *p, struct netbsd32_ifdrv *s32p, u_long cmd)
{

	memcpy(s32p->ifd_name, p->ifd_name, sizeof s32p->ifd_name);
	s32p->ifd_cmd = p->ifd_cmd;
	s32p->ifd_len = p->ifd_len;
	NETBSD32PTR32(s32p->ifd_data, p->ifd_data);
}

static inline void
netbsd32_from_sioc_vif_req(struct sioc_vif_req *p,
    struct netbsd32_sioc_vif_req *s32p, u_long cmd)
{

	s32p->vifi = p->vifi;
	s32p->icount = (netbsd32_u_long)p->icount;
	s32p->ocount = (netbsd32_u_long)p->ocount;
	s32p->ibytes = (netbsd32_u_long)p->ibytes;
	s32p->obytes = (netbsd32_u_long)p->obytes;
}

static inline void
netbsd32_from_sioc_sg_req(struct sioc_sg_req *p,
    struct netbsd32_sioc_sg_req *s32p, u_long cmd)
{

	s32p->src = p->src;
	s32p->grp = p->grp;
	s32p->pktcnt = (netbsd32_u_long)p->pktcnt;
	s32p->bytecnt = (netbsd32_u_long)p->bytecnt;
	s32p->wrong_if = (netbsd32_u_long)p->wrong_if;
}

static inline void
netbsd32_from_kfilter_mapping(struct kfilter_mapping *p,
    struct netbsd32_kfilter_mapping *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->name, p->name);
	s32p->len = p->len;
	s32p->filter = p->filter;
}

static inline void
netbsd32_from_atareq(struct atareq *p,
    struct netbsd32_atareq *s32p, u_long cmd)
{

	s32p->flags = (netbsd32_u_long)p->flags;
	s32p->command = p->command;
	s32p->features = p->features;
	s32p->sec_count = p->sec_count;
	s32p->sec_num = p->sec_num;
	s32p->head = p->head;
	s32p->cylinder = p->cylinder;
	NETBSD32PTR32(s32p->databuf, p->databuf);
	s32p->datalen = (netbsd32_u_long)p->datalen;
	s32p->timeout = p->timeout;
	s32p->retsts = p->retsts;
	s32p->error = p->error;
}

static inline void
netbsd32_from_fss_set(struct fss_set *p, struct netbsd32_fss_set *s32p,
    u_long cmd)
{

	NETBSD32PTR32(s32p->fss_mount, p->fss_mount);
	NETBSD32PTR32(s32p->fss_bstore, p->fss_bstore);
	s32p->fss_csize = p->fss_csize;
	s32p->fss_flags = p->fss_flags;
}

static inline void
netbsd32_from_fss_get(struct fss_get *p, struct netbsd32_fss_get *s32p,
    u_long cmd)
{

	memcpy(s32p->fsg_mount, p->fsg_mount, MNAMELEN);
	netbsd32_from_timeval(&p->fsg_time, &s32p->fsg_time);
	s32p->fsg_csize = p->fsg_csize;
	s32p->fsg_mount_size = p->fsg_mount_size;
	s32p->fsg_bs_size = p->fsg_bs_size;

}

static inline void
netbsd32_from_vnd_ioctl(struct vnd_ioctl *p,
    struct netbsd32_vnd_ioctl *s32p, u_long cmd)
{

	s32p->vnd_flags = p->vnd_flags;
	s32p->vnd_geom = p->vnd_geom;
	s32p->vnd_osize = p->vnd_osize;
	s32p->vnd_size = p->vnd_size;
}

static inline void
netbsd32_from_vnd_user(struct vnd_user *p,
    struct netbsd32_vnd_user *s32p, u_long cmd)
{

	s32p->vnu_unit = p->vnu_unit;
	s32p->vnu_dev = p->vnu_dev;
	s32p->vnu_ino = p->vnu_ino;
}

static inline void
netbsd32_from_vnd_ioctl50(struct vnd_ioctl50 *p,
    struct netbsd32_vnd_ioctl50 *s32p, u_long cmd)
{

	s32p->vnd_flags = p->vnd_flags;
	s32p->vnd_geom = p->vnd_geom;
	s32p->vnd_size = p->vnd_size;
}

static inline void
netbsd32_from_plistref(struct plistref *p,
    struct netbsd32_plistref *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->pref_plist, p->pref_plist);
	s32p->pref_len = p->pref_len;
}

static inline void
netbsd32_from_nvlist_ref_t(nvlist_ref_t *p,
    netbsd32_nvlist_ref_t *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->buf, p->buf);
	s32p->len = p->len;
	s32p->flags = p->flags;
}

static inline void
netbsd32_from_wdog_conf(struct wdog_conf *p,
    struct netbsd32_wdog_conf *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->wc_names, p->wc_names);
	s32p->wc_count = p->wc_count;
}

/* wsdisplay stuff */
static inline void
netbsd32_from_wsdisplay_addscreendata(struct wsdisplay_addscreendata *asd,
    struct netbsd32_wsdisplay_addscreendata *asd32, u_long cmd)
{

	NETBSD32PTR32(asd32->screentype, asd->screentype);
	NETBSD32PTR32(asd32->emul, asd->emul);
	asd32->idx = asd->idx;
}

static inline void
netbsd32_from_wsdisplay_cursor(struct wsdisplay_cursor *c,
    struct netbsd32_wsdisplay_cursor *c32, u_long cmd)
{

	c32->which = c->which;
	c32->enable = c->enable;
	c32->pos.x = c->pos.x;
	c32->pos.y = c->pos.y;
	c32->hot.x = c->hot.x;
	c32->hot.y = c->hot.y;
	c32->size.x = c->size.x;
	c32->size.y = c->size.y;
	c32->cmap.index = c->cmap.index;
	c32->cmap.count = c->cmap.count;
	NETBSD32PTR32(c32->cmap.red, c->cmap.red);
	NETBSD32PTR32(c32->cmap.green, c->cmap.green);
	NETBSD32PTR32(c32->cmap.blue, c->cmap.blue);
	NETBSD32PTR32(c32->image, c->image);
	NETBSD32PTR32(c32->mask, c->mask);
}

static inline void
netbsd32_from_wsdisplay_cmap(struct wsdisplay_cmap *c,
    struct netbsd32_wsdisplay_cmap *c32, u_long cmd)
{

	c32->index = c->index;
	c32->count = c->count;
	NETBSD32PTR32(c32->red, c->red);
	NETBSD32PTR32(c32->green, c->green);
	NETBSD32PTR32(c32->blue, c->blue);
}

static inline void
netbsd32_from_wsdisplay_font(struct wsdisplay_font *f,
    struct netbsd32_wsdisplay_font *f32, u_long cmd)
{
}

static inline void
netbsd32_from_wsdisplay_usefontdata(struct wsdisplay_usefontdata *f,
    struct netbsd32_wsdisplay_usefontdata *f32, u_long cmd)
{
}

static inline void
netbsd32_from_ieee80211req(struct ieee80211req *ireq,
    struct netbsd32_ieee80211req *ireq32, u_long cmd)
{

	memcpy(ireq32->i_name, ireq->i_name, IFNAMSIZ);
	ireq32->i_type = ireq->i_type;
	ireq32->i_val = ireq->i_val;
	ireq32->i_len = ireq->i_len;
	NETBSD32PTR32(ireq32->i_data, ireq->i_data);
}

static inline void
netbsd32_from_ieee80211_nwkey(struct ieee80211_nwkey *nwk,
    struct netbsd32_ieee80211_nwkey *nwk32, u_long cmd)
{
	int i;

	memcpy(nwk32->i_name, nwk->i_name, IFNAMSIZ);
	nwk32->i_wepon = nwk->i_wepon;
	nwk32->i_defkid = nwk->i_defkid;
	for (i = 0; i < IEEE80211_WEP_NKID; i++) {
		nwk32->i_key[i].i_keylen = nwk->i_key[i].i_keylen;
		NETBSD32PTR32(nwk32->i_key[i].i_keydat,
				nwk->i_key[i].i_keydat);
	}
}

static inline void
netbsd32_from_bpf_program(struct bpf_program *p,
    struct netbsd32_bpf_program *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->bf_insns, p->bf_insns);
	s32p->bf_len = p->bf_len;
}

static inline void
netbsd32_from_bpf_dltlist(struct bpf_dltlist *p,
    struct netbsd32_bpf_dltlist *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->bfl_list, p->bfl_list);
	s32p->bfl_len = p->bfl_len;
}

static inline void
netbsd32_from_u_long(u_long *p, netbsd32_u_long *s32p, u_long cmd)
{

	*s32p = (netbsd32_u_long)*p;
}

static inline void
netbsd32_from_voidp(voidp *p, netbsd32_voidp *s32p, u_long cmd)
{

	NETBSD32PTR32(*s32p, *p);
}

static inline void
netbsd32_from_clockctl_settimeofday(const struct clockctl_settimeofday *p,
    struct netbsd32_clockctl_settimeofday *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->tv, p->tv);
	NETBSD32PTR32(s32p->tzp, p->tzp);
}

static inline void
netbsd32_from_clockctl_adjtime(const struct clockctl_adjtime *p,
    struct netbsd32_clockctl_adjtime *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->delta, p->delta);
	NETBSD32PTR32(s32p->olddelta, p->olddelta);
}

static inline void
netbsd32_from_clockctl_clock_settime(const struct clockctl_clock_settime *p,
    struct netbsd32_clockctl_clock_settime *s32p, u_long cmd)
{

	s32p->clock_id = p->clock_id;
	NETBSD32PTR32(s32p->tp, p->tp);
}

#ifdef NTP
static inline void
netbsd32_from_clockctl_ntp_adjtime(const struct clockctl_ntp_adjtime *p,
    struct netbsd32_clockctl_ntp_adjtime *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->tp, p->tp);
	s32p->retval = p->retval;
}
#endif

static inline void
netbsd32_from_ksyms_gsymbol( const struct ksyms_gsymbol *p,
    struct netbsd32_ksyms_gsymbol *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->kg_name, p->kg_name);
	s32p->kg_sym = p->kg_sym;
}

static inline void
netbsd32_from_ksyms_gvalue(
    const struct ksyms_gvalue *p,
    struct netbsd32_ksyms_gvalue *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->kv_name, p->kv_name);
	s32p->kv_value = p->kv_value;
}

static inline void
netbsd32_from_npf_ioctl_table(const struct npf_ioctl_table *p,
    struct netbsd32_npf_ioctl_table *s32p, u_long cmd)
{

       s32p->nct_cmd = p->nct_cmd;
       NETBSD32PTR32(s32p->nct_name, p->nct_name);
       switch (p->nct_cmd) {
       case NPF_CMD_TABLE_LOOKUP:
       case NPF_CMD_TABLE_ADD:
       case NPF_CMD_TABLE_REMOVE:
               s32p->nct_data.ent = p->nct_data.ent;
               break;
       case NPF_CMD_TABLE_LIST:
               NETBSD32PTR32(s32p->nct_data.buf.buf, p->nct_data.buf.buf);
               s32p->nct_data.buf.len = p->nct_data.buf.len;
               break;
       }
}

static inline void
netbsd32_from_devlistargs(const struct devlistargs *p,
    struct netbsd32_devlistargs *s32p, u_long cmd)
{

	memcpy(s32p->l_devname, p->l_devname, sizeof(s32p->l_devname));
	s32p->l_children = p->l_children;
	NETBSD32PTR32(s32p->l_childname, p->l_childname);
}

static inline void
netbsd32_from_devrescanargs(const struct devrescanargs *p,
    struct netbsd32_devrescanargs *s32p, u_long cmd)
{

	memcpy(s32p->busname, p->busname, sizeof(s32p->busname));
	memcpy(s32p->ifattr, p->ifattr, sizeof(s32p->ifattr));
	s32p->numlocators = p->numlocators;
	NETBSD32PTR32(s32p->locators, p->locators);
}

static inline void
netbsd32_from_disk_strategy(const struct disk_strategy *p,
    struct netbsd32_disk_strategy *s32p, u_long cmd)
{

	memcpy(s32p->dks_name, p->dks_name, sizeof(p->dks_name));
	NETBSD32PTR32(s32p->dks_param, p->dks_param);
	s32p->dks_paramlen = p->dks_paramlen;
}

static inline void
netbsd32_from_dkwedge_list(const struct dkwedge_list *p,
    struct netbsd32_dkwedge_list *s32p, u_long cmd)
{

	NETBSD32PTR32(s32p->dkwl_buf, p->dkwl_buf);
	s32p->dkwl_bufsize = p->dkwl_bufsize;
	s32p->dkwl_nwedges = p->dkwl_nwedges;
	s32p->dkwl_ncopied = p->dkwl_ncopied;
}

static inline void
netbsd32_to_lsenable(struct netbsd32_lsenable *le32, struct lsenable *le,
    u_long cmd)
{

	le->le_csstart = le32->le_csstart;
	le->le_csend = le32->le_csend;
	le->le_lockstart = le32->le_lockstart;
	le->le_lockend = le32->le_lockend;
	le->le_nbufs = le32->le_nbufs;
	le->le_flags = le32->le_flags;
	le->le_mask = le32->le_mask;
}

static inline void
netbsd32_from_lsenable(struct lsenable *le, struct netbsd32_lsenable *le32,
    u_long cmd)
{

	le32->le_csstart = le->le_csstart;
	le32->le_csend = le->le_csend;
	le32->le_lockstart = le->le_lockstart;
	le32->le_lockend = le->le_lockend;
	le32->le_nbufs = le->le_nbufs;
	le32->le_flags = le->le_flags;
	le32->le_mask = le->le_mask;
}

static inline void
netbsd32_to_lsdisable(struct netbsd32_lsdisable *ld32, struct lsdisable *ld,
    u_long cmd)
{

	ld->ld_size = ld32->ld_size;
	netbsd32_to_timespec(&ld32->ld_time, &ld->ld_time);
	memcpy(&ld->ld_time, &ld32->ld_time, sizeof(ld->ld_time));
}

static inline void
netbsd32_from_lsdisable(struct lsdisable *ld, struct netbsd32_lsdisable *ld32,
    u_long cmd)
{

	ld->ld_size = ld32->ld_size;
	netbsd32_from_timespec(&ld->ld_time, &ld32->ld_time);
	memcpy(&ld->ld_time, &ld32->ld_time, sizeof(ld->ld_time));
}

#ifdef NTP
static int
netbsd32_do_clockctl_ntp_adjtime(struct file *fp,
    struct clockctl_ntp_adjtime *args)
{
	struct vnode *vp;
	struct specnode *sn;
	const char *name;

	struct netbsd32_timex ntv32;
	struct timex ntv;
	int error;

	/* Verify that the file descriptor is is to the clockctl device */
	if (fp->f_type != DTYPE_VNODE)
		return EINVAL;

	vp = fp->f_vnode;
	if (vp->v_type != VCHR)
		return EINVAL;

	sn = vp->v_specnode;
	name = cdevsw_getname(major(sn->sn_rdev));
	if (name == NULL || strcmp(name, "clockctl") != 0)
		return EINVAL;

	if (vec_ntp_adjtime1 == NULL)
		return EINVAL;

	error = copyin(args->tp, &ntv32, sizeof(ntv32));
	if (error)
		return error;

	netbsd32_to_timex(&ntv32, &ntv);
	(*vec_ntp_adjtime1)(&ntv);
	netbsd32_from_timex(&ntv, &ntv32);

	error = copyout(&ntv32, args->tp, sizeof(ntv32));
	if (error == 0)
		args->retval = ntp_timestatus();

	return error;
}
#endif

/*
 * main ioctl syscall.
 *
 * ok, here we are in the biggy.  we have to do fix ups depending
 * on the ioctl command before and afterwards.
 */
int
netbsd32_ioctl(struct lwp *l,
    const struct netbsd32_ioctl_args *uap, register_t *retval)
{
	/* {
		syscallarg(int) fd;
		syscallarg(netbsd32_u_long) com;
		syscallarg(netbsd32_voidp) data;
	} */
	struct file *fp;
	u_long com;
	int error = 0;
	size_t size;
	size_t alloc_size32, size32;
	void *data, *memp = NULL;
	void *data32, *memp32 = NULL;
	unsigned int fd;
	int tmp;
#define STK_PARAMS	128
	uint64_t stkbuf[STK_PARAMS/sizeof(uint64_t)];
	uint64_t stkbuf32[STK_PARAMS/sizeof(uint64_t)];

	/*
	 * we need to translate some commands (_IOW) before calling sys_ioctl,
	 * some after (_IOR), and some both (_IOWR).
	 */
#if 0
	{
		const char * const dirs[8] = {
		    "NONE!", "VOID", "OUT", "VOID|OUT!", "IN", "VOID|IN!",
		    "INOUT", "VOID|IN|OUT!"
		};

		printf("netbsd32_ioctl(%d, %x, %x): "
		    "%s group %c base %d len %d\n",
		    SCARG(uap, fd), SCARG(uap, com), SCARG(uap, data).i32,
		    dirs[((SCARG(uap, com) & IOC_DIRMASK)>>29)],
		    IOCGROUP(SCARG(uap, com)), IOCBASECMD(SCARG(uap, com)),
		    IOCPARM_LEN(SCARG(uap, com)));
	}
#endif

	memp = NULL;
	memp32 = NULL;
	alloc_size32 = 0;
	size32 = 0;
	size = 0;

	fd = SCARG(uap, fd);
	if ((fp = fd_getfile(fd)) == NULL)
		return EBADF;
	if ((fp->f_flag & (FREAD | FWRITE)) == 0) {
		error = EBADF;
		goto out;
	}

	switch (com = SCARG(uap, com)) {
	case FIONCLEX:
	case FIOCLEX:
		fd_set_exclose(l, fd, com == FIOCLEX);
		goto out;
	}

	/*
	 * Interpret high order word to find amount of data to be
	 * copied to/from the user's address space.
	 */
	size32 = IOCPARM_LEN(com);
	alloc_size32 = size32;

	/*
	 * The disklabel is now padded to a multiple of 8 bytes however the old
	 * disklabel on 32bit platforms wasn't.  This leaves a difference in
	 * size of 4 bytes between the two but are otherwise identical.
	 * To deal with this, we allocate enough space for the new disklabel
	 * but only copyin/out the smaller amount.
	 */
	if (IOCGROUP(com) == 'd') {
		u_long ncom = com ^ (DIOCGDINFO ^ DIOCGDINFO32);
		switch (ncom) {
		case DIOCGDINFO:
		case DIOCWDINFO:
		case DIOCSDINFO:
		case DIOCGDEFLABEL:
			com = ncom;
			if (IOCPARM_LEN(DIOCGDINFO32) < IOCPARM_LEN(DIOCGDINFO))
				alloc_size32 = IOCPARM_LEN(DIOCGDINFO);
			break;
		}
	}
	if (alloc_size32 > IOCPARM_MAX) {
		error = ENOTTY;
		goto out;
	}
	if (alloc_size32 > sizeof(stkbuf)) {
		memp32 = kmem_alloc(alloc_size32, KM_SLEEP);
		data32 = memp32;
	} else
		data32 = (void *)stkbuf32;
	if ((com >> IOCPARM_SHIFT) == 0)  {
		/* UNIX-style ioctl. */
		data32 = SCARG_P32(uap, data);
	} else {
		if (com&IOC_IN) {
			if (size32) {
				error = copyin(SCARG_P32(uap, data), data32,
				    size32);
				if (error) {
					goto out;
				}
				/*
				 * The data between size and alloc_size has
				 * not been overwritten.  It shouldn't matter
				 * but let's clear that anyway.
				 */
				if (__predict_false(size32 < alloc_size32)) {
					memset((char *)data32+size32, 0,
					    alloc_size32 - size32);
				}
				ktrgenio(fd, UIO_WRITE, SCARG_P32(uap, data),
				    size32, 0);
			} else
				*(void **)data32 = SCARG_P32(uap, data);
		} else if ((com&IOC_OUT) && size32) {
			/*
			 * Zero the buffer so the user always
			 * gets back something deterministic.
			 */
			memset(data32, 0, alloc_size32);
		} else if (com&IOC_VOID) {
			*(void **)data32 = SCARG_P32(uap, data);
		}
	}

	/*
	 * convert various structures, pointers, and other objects that
	 * change size from 32 bit -> 64 bit, for all ioctl commands.
	 */
	switch (SCARG(uap, com)) {
	case FIONBIO:
		mutex_enter(&fp->f_lock);
		if ((tmp = *(int *)data32) != 0)
			fp->f_flag |= FNONBLOCK;
		else
			fp->f_flag &= ~FNONBLOCK;
		mutex_exit(&fp->f_lock);
		error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (void *)&tmp);
		break;

	case FIOASYNC:
		mutex_enter(&fp->f_lock);
		if ((tmp = *(int *)data32) != 0)
			fp->f_flag |= FASYNC;
		else
			fp->f_flag &= ~FASYNC;
		mutex_exit(&fp->f_lock);
		error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, (void *)&tmp);
		break;

	case AUDIO_WSEEK32:
		IOCTL_CONV_TO(AUDIO_WSEEK, u_long);

#if 0	/* not implemented by anything */
	case DIOCRFORMAT32:
		IOCTL_STRUCT_CONV_TO(DIOCRFORMAT, format_op);
	case DIOCWFORMAT32:
		IOCTL_STRUCT_CONV_TO(DIOCWFORMAT, format_op);
#endif

	case KFILTER_BYFILTER32:
		IOCTL_STRUCT_CONV_TO(KFILTER_BYFILTER, kfilter_mapping);
	case KFILTER_BYNAME32:
		IOCTL_STRUCT_CONV_TO(KFILTER_BYNAME, kfilter_mapping);

	case ATAIOCCOMMAND32:
		IOCTL_STRUCT_CONV_TO(ATAIOCCOMMAND, atareq);

	case SIOCIFGCLONERS32:
		{
			struct netbsd32_if_clonereq *req =
			    (struct netbsd32_if_clonereq *)data32;
			char *buf = NETBSD32PTR64(req->ifcr_buffer);

			error = if_clone_list(req->ifcr_count,
			    buf, &req->ifcr_total);
			break;
		}

/*
 * only a few ifreq syscalls need conversion and those are
 * all driver specific... XXX
 */
#if 0
	case SIOCGADDRROM3232:
		IOCTL_STRUCT_CONV_TO(SIOCGADDRROM32, ifreq);
	case SIOCGCHIPID32:
		IOCTL_STRUCT_CONV_TO(SIOCGCHIPID, ifreq);
	case SIOCSIFADDR32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFADDR, ifreq);
	case OSIOCGIFADDR32:
		IOCTL_STRUCT_CONV_TO(OSIOCGIFADDR, ifreq);
	case SIOCGIFADDR32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFADDR, ifreq);
	case SIOCSIFDSTADDR32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFDSTADDR, ifreq);
	case OSIOCGIFDSTADDR32:
		IOCTL_STRUCT_CONV_TO(OSIOCGIFDSTADDR, ifreq);
	case SIOCGIFDSTADDR32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFDSTADDR, ifreq);
	case OSIOCGIFBRDADDR32:
		IOCTL_STRUCT_CONV_TO(OSIOCGIFBRDADDR, ifreq);
	case SIOCGIFBRDADDR32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFBRDADDR, ifreq);
	case SIOCSIFBRDADDR32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFBRDADDR, ifreq);
	case OSIOCGIFNETMASK32:
		IOCTL_STRUCT_CONV_TO(OSIOCGIFNETMASK, ifreq);
	case SIOCGIFNETMASK32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFNETMASK, ifreq);
	case SIOCSIFNETMASK32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFNETMASK, ifreq);
	case SIOCGIFMETRIC32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFMETRIC, ifreq);
	case SIOCSIFMETRIC32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFMETRIC, ifreq);
	case SIOCDIFADDR32:
		IOCTL_STRUCT_CONV_TO(SIOCDIFADDR, ifreq);
	case SIOCADDMULTI32:
		IOCTL_STRUCT_CONV_TO(SIOCADDMULTI, ifreq);
	case SIOCDELMULTI32:
		IOCTL_STRUCT_CONV_TO(SIOCDELMULTI, ifreq);
	case SIOCSIFMEDIA32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFMEDIA, ifreq);
	case SIOCSIFMTU32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFMTU, ifreq);
	case SIOCGIFMTU32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFMTU, ifreq);
	case BIOCGETIF32:
		IOCTL_STRUCT_CONV_TO(BIOCGETIF, ifreq);
	case BIOCSETIF32:
		IOCTL_STRUCT_CONV_TO(BIOCSETIF, ifreq);
	case SIOCPHASE132:
		IOCTL_STRUCT_CONV_TO(SIOCPHASE1, ifreq);
	case SIOCPHASE232:
		IOCTL_STRUCT_CONV_TO(SIOCPHASE2, ifreq);
#endif

	case OOSIOCGIFCONF32:
		IOCTL_STRUCT_CONV_TO(OOSIOCGIFCONF, ifconf);
	case OSIOCGIFCONF32:
		IOCTL_STRUCT_CONV_TO(OSIOCGIFCONF, ifconf);
	case SIOCGIFCONF32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFCONF, ifconf);

	case SIOCGIFFLAGS32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFFLAGS, ifreq);
	case SIOCSIFFLAGS32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFFLAGS, ifreq);

	case SIOCGIFADDRPREF32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFADDRPREF, if_addrprefreq);
	case SIOCSIFADDRPREF32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFADDRPREF, if_addrprefreq);

	case SIOCGIFDATA32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFDATA, ifdatareq);
	case SIOCZIFDATA32:
		IOCTL_STRUCT_CONV_TO(SIOCZIFDATA, ifdatareq);

	case OSIOCGIFFLAGS32:
		IOCTL_STRUCT_CONV_TO(OSIOCGIFFLAGS, oifreq);
	case OSIOCSIFFLAGS32:
		IOCTL_STRUCT_CONV_TO(OSIOCSIFFLAGS, oifreq);

	case SIOCGIFMEDIA32_80:
		IOCTL_STRUCT_CONV_TO(SIOCGIFMEDIA_80, ifmediareq);
	case SIOCGIFMEDIA32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFMEDIA, ifmediareq);

	case SIOCGNBRINFO32:
		IOCTL_STRUCT_CONV_TO(SIOCGNBRINFO, in_nbrinfo);
	case SIOCGNBRINFO_IN632:
		IOCTL_STRUCT_CONV_TO(SIOCGNBRINFO_IN6, in6_nbrinfo);

	case SIOCGIFGENERIC32:
		IOCTL_STRUCT_CONV_TO(SIOCGIFGENERIC, ifreq);
	case SIOCSIFGENERIC32:
		IOCTL_STRUCT_CONV_TO(SIOCSIFGENERIC, ifreq);

	case PPPOESETPARMS32:
		IOCTL_STRUCT_CONV_TO(PPPOESETPARMS, pppoediscparms);
	case PPPOEGETPARMS32:
		IOCTL_STRUCT_CONV_TO(PPPOEGETPARMS, pppoediscparms);
	case SPPPGETAUTHCFG32:
		IOCTL_STRUCT_CONV_TO(SPPPGETAUTHCFG, spppauthcfg);
	case SPPPSETAUTHCFG32:
		IOCTL_STRUCT_CONV_TO(SPPPSETAUTHCFG, spppauthcfg);

	case SIOCSDRVSPEC32:
		IOCTL_STRUCT_CONV_TO(SIOCSDRVSPEC, ifdrv);
	case SIOCGDRVSPEC32:
		IOCTL_STRUCT_CONV_TO(SIOCGDRVSPEC, ifdrv);

	case SIOCGETVIFCNT32:
		IOCTL_STRUCT_CONV_TO(SIOCGETVIFCNT, sioc_vif_req);

	case SIOCGETSGCNT32:
		IOCTL_STRUCT_CONV_TO(SIOCGETSGCNT, sioc_sg_req);

	case FSSIOCSET32:	/* XXX FSSIOCSET50 not yet handled */
		IOCTL_STRUCT_CONV_TO(FSSIOCSET, fss_set);
	case FSSIOCGET32:	/* XXX FSSIOCGET50 not yet handled */
		IOCTL_STRUCT_CONV_TO(FSSIOCGET, fss_get);

	case VNDIOCSET32:
		IOCTL_STRUCT_CONV_TO(VNDIOCSET, vnd_ioctl);
	case VNDIOCCLR32:
		IOCTL_STRUCT_CONV_TO(VNDIOCCLR, vnd_ioctl);
	case VNDIOCGET32:
		IOCTL_STRUCT_CONV_TO(VNDIOCGET, vnd_user);
	case VNDIOCSET5032:
		IOCTL_STRUCT_CONV_TO(VNDIOCSET50, vnd_ioctl50);
	case VNDIOCCLR5032:
		IOCTL_STRUCT_CONV_TO(VNDIOCCLR50, vnd_ioctl50);

	case ENVSYS_GETDICTIONARY32:
		IOCTL_STRUCT_CONV_TO(ENVSYS_GETDICTIONARY, plistref);
	case ENVSYS_SETDICTIONARY32:
		IOCTL_STRUCT_CONV_TO(ENVSYS_SETDICTIONARY, plistref);
	case ENVSYS_REMOVEPROPS32:
		IOCTL_STRUCT_CONV_TO(ENVSYS_REMOVEPROPS, plistref);

	case WDOGIOC_GWDOGS32:
		IOCTL_STRUCT_CONV_TO(WDOGIOC_GWDOGS, wdog_conf);

	case BIOCSETF32:
		IOCTL_STRUCT_CONV_TO(BIOCSETF, bpf_program);
	case BIOCSETWF32:
		IOCTL_STRUCT_CONV_TO(BIOCSETWF, bpf_program);
	case BIOCSTCPF32:
		IOCTL_STRUCT_CONV_TO(BIOCSTCPF, bpf_program);
	case BIOCSUDPF32:
		IOCTL_STRUCT_CONV_TO(BIOCSUDPF, bpf_program);
	case BIOCGDLTLIST32:
		IOCTL_STRUCT_CONV_TO(BIOCGDLTLIST, bpf_dltlist);
	case BIOCSRTIMEOUT32:
#define netbsd32_to_timeval(s32p, p, cmd) netbsd32_to_timeval(s32p, p)
#define netbsd32_from_timeval(p, s32p, cmd) netbsd32_from_timeval(p, s32p)
		IOCTL_STRUCT_CONV_TO(BIOCSRTIMEOUT, timeval);
#undef netbsd32_to_timeval
#undef netbsd32_from_timeval

	case WSDISPLAYIO_ADDSCREEN32:
		IOCTL_STRUCT_CONV_TO(WSDISPLAYIO_ADDSCREEN,
		    wsdisplay_addscreendata);

	case WSDISPLAYIO_GCURSOR32:
		IOCTL_STRUCT_CONV_TO(WSDISPLAYIO_GCURSOR, wsdisplay_cursor);
	case WSDISPLAYIO_SCURSOR32:
		IOCTL_STRUCT_CONV_TO(WSDISPLAYIO_SCURSOR, wsdisplay_cursor);

	case WSDISPLAYIO_GETCMAP32:
		IOCTL_STRUCT_CONV_TO(WSDISPLAYIO_GETCMAP, wsdisplay_cmap);
	case WSDISPLAYIO_PUTCMAP32:
		IOCTL_STRUCT_CONV_TO(WSDISPLAYIO_PUTCMAP, wsdisplay_cmap);

	case WSDISPLAYIO_LDFONT32:
		IOCTL_STRUCT_CONV_TO(WSDISPLAYIO_LDFONT, wsdisplay_font);
	case WSDISPLAYIO_SFONT32:
		IOCTL_STRUCT_CONV_TO(WSDISPLAYIO_SFONT, wsdisplay_usefontdata);

	case SIOCS8021132:
		IOCTL_STRUCT_CONV_TO(SIOCS80211, ieee80211req);
	case SIOCG8021132:
		IOCTL_STRUCT_CONV_TO(SIOCG80211, ieee80211req);
	case SIOCS80211NWKEY32:
		IOCTL_STRUCT_CONV_TO(SIOCS80211NWKEY, ieee80211_nwkey);
	case SIOCG80211NWKEY32:
		IOCTL_STRUCT_CONV_TO(SIOCG80211NWKEY, ieee80211_nwkey);

	case POWER_EVENT_RECVDICT32:
		IOCTL_STRUCT_CONV_TO(POWER_EVENT_RECVDICT, plistref);

	case CLOCKCTL_SETTIMEOFDAY32:
		IOCTL_STRUCT_CONV_TO(CLOCKCTL_SETTIMEOFDAY,
		    clockctl_settimeofday);
	case CLOCKCTL_ADJTIME32:
		IOCTL_STRUCT_CONV_TO(CLOCKCTL_ADJTIME, clockctl_adjtime);
	case CLOCKCTL_CLOCK_SETTIME32:
		IOCTL_STRUCT_CONV_TO(CLOCKCTL_CLOCK_SETTIME,
		    clockctl_clock_settime);
	case CLOCKCTL_NTP_ADJTIME32:
#ifdef NTP
		{
			size = IOCPARM_LEN(CLOCKCTL_NTP_ADJTIME);
			if (size > sizeof(stkbuf))
				data = memp = kmem_alloc(size, KM_SLEEP);
			else
				data = (void *)stkbuf;

			netbsd32_to_clockctl_ntp_adjtime(
				(const struct netbsd32_clockctl_ntp_adjtime *)data32,
				(struct clockctl_ntp_adjtime *)data,
				CLOCKCTL_NTP_ADJTIME);
			error = netbsd32_do_clockctl_ntp_adjtime(fp,
				(struct clockctl_ntp_adjtime *)data);
			netbsd32_from_clockctl_ntp_adjtime(
				(const struct clockctl_ntp_adjtime *)data,
				(struct netbsd32_clockctl_ntp_adjtime *)data32,
				CLOCKCTL_NTP_ADJTIME);

			break;
		}
#else
		error = ENOTTY;
		break;
#endif /* NTP */

	case KIOCGSYMBOL32:
		IOCTL_STRUCT_CONV_TO(KIOCGSYMBOL, ksyms_gsymbol);
	case KIOCGVALUE32:
		IOCTL_STRUCT_CONV_TO(KIOCGVALUE, ksyms_gvalue);

        case IOC_NPF_LOAD32:
                IOCTL_CONV_TO(IOC_NPF_LOAD, nvlist_ref_t);
        case IOC_NPF_TABLE32:
                IOCTL_STRUCT_CONV_TO(IOC_NPF_TABLE, npf_ioctl_table);
        case IOC_NPF_STATS32:
                IOCTL_CONV_TO(IOC_NPF_STATS, voidp);
        case IOC_NPF_SAVE32:
                IOCTL_CONV_TO(IOC_NPF_SAVE, nvlist_ref_t);
        case IOC_NPF_RULE32:
                IOCTL_CONV_TO(IOC_NPF_RULE, nvlist_ref_t);
        case IOC_NPF_CONN_LOOKUP32:
                IOCTL_CONV_TO(IOC_NPF_CONN_LOOKUP, nvlist_ref_t);

	case DRVRESCANBUS32:
		IOCTL_STRUCT_CONV_TO(DRVRESCANBUS, devrescanargs);
	case DRVLISTDEV32:
		IOCTL_STRUCT_CONV_TO(DRVLISTDEV, devlistargs);
	case DRVCTLCOMMAND32:
		IOCTL_STRUCT_CONV_TO(DRVCTLCOMMAND, plistref);
	case DRVGETEVENT32:
		IOCTL_STRUCT_CONV_TO(DRVGETEVENT, plistref);

	case DIOCGSTRATEGY32:
		IOCTL_STRUCT_CONV_TO(DIOCGSTRATEGY, disk_strategy);
	case DIOCSSTRATEGY32:
		IOCTL_STRUCT_CONV_TO(DIOCSSTRATEGY, disk_strategy);
	case DIOCGDISKINFO32:
		IOCTL_STRUCT_CONV_TO(DIOCGDISKINFO, plistref);
	case DIOCLWEDGES32:
		IOCTL_STRUCT_CONV_TO(DIOCLWEDGES, dkwedge_list);

	case IOC_LOCKSTAT_ENABLE32:
		IOCTL_STRUCT_CONV_TO(IOC_LOCKSTAT_ENABLE, lsenable);
	case IOC_LOCKSTAT_DISABLE32:
		IOCTL_STRUCT_CONV_TO(IOC_LOCKSTAT_DISABLE, lsdisable);

	default:
#ifdef NETBSD32_DRMKMS
		if (IOCGROUP(com) == 'd') {
			error = netbsd32_drm_ioctl(fp, com, data32, l);
			break;
		}
#endif
#ifdef NETBSD32_MD_IOCTL
		error = netbsd32_md_ioctl(fp, com, data32, l);
#else
		error = (*fp->f_ops->fo_ioctl)(fp, com, data32);
#endif
		break;
	}

	if (error == EPASSTHROUGH)
		error = ENOTTY;

	/*
	 * Copy any data to user, size was
	 * already set and checked above.
	 */
	if (error == 0 && (com&IOC_OUT) && size32) {
		error = copyout(data32, SCARG_P32(uap, data), size32);
		ktrgenio(fd, UIO_READ, SCARG_P32(uap, data),
		    size32, error);
	}

 out:
	/* If we allocated data, free it here. */
	if (memp32)
		kmem_free(memp32, alloc_size32);
	if (memp)
		kmem_free(memp, size);
	fd_putfile(fd);
	return error;
}