[Qemu-devel] FreeBSD qemu port update - need testing and help with kqemu/amd64

[Juergen Lock]

Here is a new iteration of the FreeBSD qemu port update.  I have
added the kqemu free functions now (and changed kqemu_vmalloc to
just allocate kernel memory like the old wrapper did.)  kqemu seems
to work on 5.4 i386, still crashes on amd64 :(  Also 4.x still
needs testing.

- kqemu wrapper update
- disabled the win98 hack
- added notes about net.link.tap.user_open sysctl and about the
win98 hack to pkg-message

Removed files: files/BSDmakefile files/kmod_bsd.c
New files: files/kqemu-freebsd-patch files/patch-libmath2
        files/patch-vl.c files/patch-exec-all.h

Index: Makefile
===================================================================
RCS file: /home/ncvs/ports/emulators/qemu/Makefile,v
retrieving revision 1.27
diff -u -r1.27 Makefile
--- Makefile    19 Jul 2005 06:06:56 -0000      1.27
+++ Makefile    23 Aug 2005 17:06:13 -0000
@@ -6,12 +6,12 @@
 #
 
 PORTNAME=      qemu
-PORTVERSION=   0.7.0s.20050717
+PORTVERSION=   0.7.1s.20050822
 CATEGORIES=    emulators
 MASTER_SITES=  http://www.qemu.org/ \
                http://people.fruitsalad.org/nox/qemu/ \
                http://dad-answers.com/qemu/
-DISTNAME=      ${PORTNAME}-snapshot-2005-07-17_23
+DISTNAME=      ${PORTNAME}-snapshot-2005-08-22_23
 EXTRACT_ONLY=  ${DISTNAME}${EXTRACT_SUFX}
 
 MAINTAINER=    address@hidden
@@ -23,8 +23,9 @@
 .endif
 
 .if defined(WITH_KQEMU)
-DISTKQEMU=     kqemu-0.6.2-1.tar.gz
+DISTKQEMU=     kqemu-0.7.1-1.tar.gz
 DISTFILES=     ${EXTRACT_ONLY} ${DISTKQEMU}
+EXTRA_PATCHES= ${FILESDIR}/kqemu-freebsd-patch
 .endif
 
 HAS_CONFIGURE= yes
@@ -40,9 +41,11 @@
 ONLY_FOR_ARCHS=        amd64 i386
 .if defined(WITH_KQEMU)
 NO_PACKAGE=    Depends on kernel, and module not redistributable
+CONFIGURE_ARGS+=       --enable-kqemu
 PLIST_SUB=     WITH_KQEMU=""
 PLIST_SUB+=    KMODDIR=${KMODDIR}
 .else
+CONFIGURE_ARGS+=       --disable-kqemu
 PLIST_SUB=     WITH_KQEMU="@comment "
 .endif
 
@@ -52,7 +55,7 @@
 
 .if ${ARCH} == "amd64"
 ARCH=          x86_64
-.if ${OSVERSION} >= 502126
+.if ${OSVERSION} >= 502126 && ${OSVERSION} <= 600029
 BUILD_DEPENDS+=        gcc34:${PORTSDIR}/lang/gcc34
 GCCVERSION=    030402
 CC=            gcc34
@@ -63,16 +66,12 @@
 USE_GCC=       3.4
 .endif
 
-.if defined(WITH_KQEMU) && ${ARCH} != "i386"
-IGNORE=                kqemu only supported on i386
-.endif
-
 .if defined(WITH_KQEMU) && !exists(${SRC_BASE}/sys/Makefile)
 IGNORE=                kqemu requires kernel source to be installed
 .endif
 
 pre-everything::
-.if !defined(WITH_KQEMU) && ${ARCH} == "i386"
+.if !defined(WITH_KQEMU)
        @${ECHO_MSG} "Notice: you can build qemu with the (alpha!) kqemu 
accelerator kernel module"
        @${ECHO_MSG} "by defining WITH_KQEMU."
 .endif
@@ -85,7 +84,7 @@
 .if defined(WITH_KQEMU)
 post-extract:
        @cd ${WRKSRC} && ${TAR} xfz ${_DISTDIR}/${DISTKQEMU}
-       @${CP} ${FILESDIR}/BSDmakefile ${FILESDIR}/kmod_bsd.c ${WRKSRC}/kqemu
+       @${LN} -s Makefile.freebsd ${WRKSRC}/kqemu/BSDmakefile
 .endif
 
 pre-patch:
Index: distinfo
===================================================================
RCS file: /home/ncvs/ports/emulators/qemu/distinfo,v
retrieving revision 1.20
diff -u -r1.20 distinfo
--- distinfo    19 Jul 2005 06:06:56 -0000      1.20
+++ distinfo    23 Aug 2005 17:06:55 -0000
@@ -1,4 +1,4 @@
-MD5 (qemu-snapshot-2005-07-17_23.tar.bz2) = 5d21295c1f328ea00de19a54715ee7c3
-SIZE (qemu-snapshot-2005-07-17_23.tar.bz2) = 1114748
-MD5 (kqemu-0.6.2-1.tar.gz) = c6bb3b40fb3d526d731eb0f1f9dee7ee
-SIZE (kqemu-0.6.2-1.tar.gz) = 21002
+MD5 (qemu-snapshot-2005-08-22_23.tar.bz2) = 10840c688a6f41ca1dc84e35ee43cfdd
+SIZE (qemu-snapshot-2005-08-22_23.tar.bz2) = 1121573
+MD5 (kqemu-0.7.1-1.tar.gz) = 012498dac620eb8c212bf5f622414dd0
+SIZE (kqemu-0.7.1-1.tar.gz) = 76427
Index: pkg-message
===================================================================
RCS file: /home/ncvs/ports/emulators/qemu/pkg-message,v
retrieving revision 1.8
diff -u -r1.8 pkg-message
--- pkg-message 1 May 2005 07:39:10 -0000       1.8
+++ pkg-message 12 Aug 2005 16:31:34 -0000
@@ -1,6 +1,9 @@
 ====
 FreeBSD host notes:
 - needs to run as root in order to use /dev/tap* networking (why?)
+(actually RELENG_6 and above now has a sysctl net.link.tap.user_open
+to allow users to use it too.  don't forget to adjust device node
+permissions in /etc/devfs.conf.)
 - slirp (usermode networking) is fixed now in cvs, on FreeSBIE 1.0 guests
 you still have to manually do:
        echo nameserver 10.0.2.3 >/etc/resolv.conf
@@ -18,4 +21,8 @@
 ioctl.)
 - the -smb option (smb-export local dir to guest) needs the net/samba
 port/package installed in addition to qemu.
+- the kqemu win98 hack has been disabled because it interferes with
+FreeBSD guests.  if you have kqemu installed and want to run a win98
+guest start qemu with -no-kqemu (which essentially is the effect of
+the removed hack.)
 ====
Index: files/patch-fbsd
===================================================================
RCS file: /home/ncvs/ports/emulators/qemu/files/patch-fbsd,v
retrieving revision 1.2
diff -u -r1.2 patch-fbsd
--- files/patch-fbsd    5 May 2005 12:41:10 -0000       1.2
+++ files/patch-fbsd    11 Aug 2005 16:38:42 -0000
@@ -13,7 +13,7 @@
        $(MAKE) -C kqemu -f Makefile.winnt
  else
 -      $(MAKE) -C kqemu
-+      cd kqemu && $(BSD_MAKE)
++      ( cd kqemu && $(BSD_MAKE) )
  endif
  endif
  
Index: files/kqemu-freebsd-patch
@@ -0,0 +1,501 @@
+Index: qemu/kqemu/Makefile.freebsd
+@@ -1,9 +1,13 @@
++# $Id: Makefile.freebsd,v 1.1 2005/04/17 17:21:31 bellard Exp $
+ KMOD= kqemu
+ SRCS= kqemu-freebsd.c
+ .if ${MACHINE_ARCH} == "i386"
+ OBJS= kqemu-mod-i386.o
+ .elif ${MACHINE_ARCH} == "amd64"
+ OBJS= kqemu-mod-x86_64.o
++.endif
++.if ${OSVERSION} >= 500000
++CC=   cc
+ .endif
+ WERROR=
+ 
+Index: qemu/kqemu/kqemu-freebsd.c
+@@ -3,20 +3,33 @@
+ #include <sys/param.h>
+ #include <sys/systm.h>
+ #include <sys/conf.h>
++#include <sys/ctype.h>
++#include <sys/fcntl.h>
+ #include <sys/ioccom.h>
+ #include <sys/malloc.h>
+ #include <sys/module.h>
+ #include <sys/mutex.h>
+ #include <sys/proc.h>
++#include <sys/resourcevar.h>
++#if __FreeBSD_version >= 500000
+ #include <sys/sched.h>
++#endif
+ #include <sys/signalvar.h>
+ #include <sys/kernel.h>
++#include <sys/sysctl.h>
++#include <sys/uio.h>
++#if __FreeBSD_version < 500000
++#include <sys/buf.h>
++#endif
++
+ #include <vm/vm.h>
+ #include <vm/vm_param.h>
+ #include <vm/vm_extern.h>
+ #include <vm/pmap.h>
+ #include <vm/vm_map.h>
+ #include <vm/vm_kern.h>
++#include <vm/vm_page.h>
++
+ #include <machine/vmparam.h>
+ #include <machine/stdarg.h>
+ 
+@@ -27,10 +40,14 @@
+ MALLOC_DECLARE(M_KQEMU);
+ MALLOC_DEFINE(M_KQEMU, "kqemu", "kqemu buffers");
+ 
++int kqemu_debug;
++SYSCTL_INT(_debug, OID_AUTO, kqemu_debug, CTLFLAG_RW, &kqemu_debug, 0,
++        "kqemu debug flag");
++
+ #define       USER_BASE       0x1000
+ 
+ /* lock the page at virtual address 'user_addr' and return its
+-   physical page index. Return -1 if error */
++   physical page index. Return NULL if error */
+ struct kqemu_user_page *CDECL kqemu_lock_user_page(unsigned long *ppage_index,
+                                                    unsigned long user_addr)
+ {
+@@ -39,14 +56,18 @@
+     vm_paddr_t pa = 0;
+     int ret;
+     pmap_t pmap;
++#if __FreeBSD_version >= 500000
+     ret = vm_map_wire(&vm->vm_map, va, va+PAGE_SIZE, VM_MAP_WIRE_USER);
++#else
++    ret = vm_map_user_pageable(&vm->vm_map, va, va+PAGE_SIZE, FALSE);
++#endif
+     if (ret != KERN_SUCCESS) {
+-      printf("kqemu_lock_user_page(%08lx) failed, ret=%d\n", user_addr, ret);
++      kqemu_log("kqemu_lock_user_page(%08lx) failed, ret=%d\n", user_addr, 
ret);
+       return NULL;
+     }
+     pmap = vm_map_pmap(&vm->vm_map);
+     pa = pmap_extract(pmap, va);
+-    // printf("kqemu_lock_user_page(%08lx) va=%08x pa=%08x\n", user_addr, va, 
pa);
++    // kqemu_log("kqemu_lock_user_page(%08lx) va=%08x pa=%08x\n", user_addr, 
va, pa);
+     *ppage_index = pa >> PAGE_SHIFT;
+     return (struct kqemu_user_page *)va;
+ }
+@@ -56,12 +77,16 @@
+     struct vmspace *vm = curproc->p_vmspace;
+     vm_offset_t va;
+     int ret;
+-    // printf("kqemu_unlock_user_page(%08lx)\n", page_index);
++    // kqemu_log("kqemu_unlock_user_page(%08lx)\n", page_index);
+     va = (vm_offset_t)page;
++#if __FreeBSD_version >= 500000
+     ret = vm_map_unwire(&vm->vm_map, va, va+PAGE_SIZE, VM_MAP_WIRE_USER);
++#else
++    ret = vm_map_user_pageable(&vm->vm_map, va, va+PAGE_SIZE, TRUE);
++#endif
+ #if 0
+     if (ret != KERN_SUCCESS) {
+-      printf("kqemu_unlock_user_page(%08lx) failed, ret=%d\n", page_index, 
ret);
++      kqemu_log("kqemu_unlock_user_page(%08lx) failed, ret=%d\n", page_index, 
ret);
+     }
+ #endif
+ }
+@@ -78,20 +103,21 @@
+ 
+     va = kmem_alloc(kernel_map, PAGE_SIZE);
+     if (va == 0) {
+-      printf("kqemu_alloc_zeroed_page: NULL\n");
+-      return -1;
++      kqemu_log("kqemu_alloc_zeroed_page: NULL\n");
++      return NULL;
+     }
+     pmap = vm_map_pmap(kernel_map);
+     pa = pmap_extract(pmap, va);
+-    // printf("kqemu_alloc_zeroed_page: %08x\n", pa);
++    // kqemu_log("kqemu_alloc_zeroed_page: %08x\n", pa);
+     *ppage_index = pa >> PAGE_SHIFT;
+     return (struct kqemu_page *)va;
+ }
+ 
+ void CDECL kqemu_free_page(struct kqemu_page *page)
+ {
+-    //    printf("kqemu_free_page(%08lx)\n", page_index);
+-    /* XXX: do it */
++    if (kqemu_debug > 0)
++      kqemu_log("kqemu_free_page(%p)\n", page);
++    kmem_free(kernel_map, (vm_offset_t) page, PAGE_SIZE);
+ }
+ 
+ /* return kernel address of the physical page page_index */
+@@ -105,42 +131,29 @@
+    GB of physical memory */
+ void * CDECL kqemu_vmalloc(unsigned int size)
+ {
+-    struct vmspace *vm = curproc->p_vmspace;
+-    vm_offset_t va = USER_BASE;
+-    int rv;
+-    if (size % PAGE_SIZE != 0) {
+-      printf("kqemu_vmalloc(%d) not a multiple of page size\n", size);
+-      return NULL;
+-    }
+-    rv = vm_map_find(&vm->vm_map, NULL, 0, &va, size, 1,
+-                   VM_PROT_ALL, VM_PROT_ALL, 0);
+-    if (rv != KERN_SUCCESS) {
+-      printf("kqemu_vmalloc(%d) failed rv=%d\n", size, rv);
+-      return NULL;
+-    }
+-    printf("kqemu_vmalloc(%d): %08x\n", size, va);
+-    return (void *)va;
++    void *ptr = malloc(size, M_KQEMU, M_WAITOK);
++    if (kqemu_debug > 0)
++      kqemu_log("kqemu_vmalloc(%d): %p\n", size, ptr);
++    return ptr;
+ }
+ 
+ void CDECL kqemu_vfree(void *ptr)
+ {
+-    printf("kqemu_vfree(%p)\n", ptr);
++    if (kqemu_debug > 0)
++      kqemu_log("kqemu_vfree(%p)\n", ptr);
++    free(ptr, M_KQEMU);
+ }
+ 
+ /* return the physical page index for a given virtual page */
+ unsigned long CDECL kqemu_vmalloc_to_phys(const void *vaddr)
+ {
+-    struct vmspace *vm = curproc->p_vmspace;
+-    vm_paddr_t pa;
+-    pmap_t pmap;
+-
+-    pmap = vm_map_pmap(&vm->vm_map);
+-    pa = pmap_extract(pmap, (vm_offset_t)vaddr);
++    vm_paddr_t pa = vtophys(vaddr);
+     if (pa == 0) {
+-      printf("kqemu_vmalloc_to_phys(%p)->error\n", vaddr);
++      kqemu_log("kqemu_vmalloc_to_phys(%p)->error\n", vaddr);
+       return -1;
+     }
+-    printf("kqemu_vmalloc_to_phys(%p)->%08x\n", vaddr, pa);
++    if (kqemu_debug > 0)
++      kqemu_log("kqemu_vmalloc_to_phys(%p)->%08x\n", vaddr, pa);
+     return pa >> PAGE_SHIFT;
+ }
+ 
+@@ -156,16 +169,48 @@
+ {
+ }
+ 
++#if __FreeBSD_version < 500000
++static int
++curpriority_cmp(struct proc *p)
++{
++    int c_class, p_class;
++
++    c_class = RTP_PRIO_BASE(curproc->p_rtprio.type);
++    p_class = RTP_PRIO_BASE(p->p_rtprio.type);
++    if (p_class != c_class)
++      return (p_class - c_class);
++    if (p_class == RTP_PRIO_NORMAL)
++      return (((int)p->p_priority - (int)curpriority) / PPQ);
++    return ((int)p->p_rtprio.prio - (int)curproc->p_rtprio.prio);
++}
++
++/* return TRUE if a signal is pending (i.e. the guest must stop
++   execution) */
++int CDECL kqemu_schedule(void)
++{
++    struct proc *p = curproc;
++    if (curpriority_cmp(p) > 0) {
++      int s = splhigh();
++      p->p_priority = MAXPRI;
++      setrunqueue(p);
++      p->p_stats->p_ru.ru_nvcsw++;
++      mi_switch();
++      splx(s);
++    }
++    return issignal(curproc) != 0;
++}
++#else
+ /* return TRUE if a signal is pending (i.e. the guest must stop
+    execution) */
+ int CDECL kqemu_schedule(void)
+ {
+-    // printf("kqemu_schedule\n");
++    // kqemu_log("kqemu_schedule\n");
+     mtx_lock_spin(&sched_lock);
+     mi_switch(SW_VOL, NULL);
+     mtx_unlock_spin(&sched_lock);
+     return SIGPENDING(curthread);
+ }
++#endif
+ 
+ static char log_buf[4096];
+ 
+@@ -178,47 +223,149 @@
+     va_end(ap);
+ }
+ 
++#define KQEMU_MAX_INSTANCES 4
++
+ struct kqemu_instance { 
++#if __FreeBSD_version >= 500000
++    TAILQ_ENTRY(kqemu_instance) kqemu_ent;
++    struct cdev *kqemu_dev;
++#endif
+     //    struct semaphore sem;  
+     struct kqemu_state *state;
+ };
+ 
++static int kqemu_ref_count = 0;
++static int max_locked_pages;
++
++#if __FreeBSD_version < 500000
++static dev_t kqemu_dev;
++#else
++static struct clonedevs *kqemuclones;
++static TAILQ_HEAD(,kqemu_instance) kqemuhead = 
TAILQ_HEAD_INITIALIZER(kqemuhead);
++static eventhandler_tag clonetag;
++#endif
++
+ static d_close_t kqemu_close;
+ static d_open_t kqemu_open;
+ static d_ioctl_t kqemu_ioctl;
+ 
+ static struct cdevsw kqemu_cdevsw = {
++#if __FreeBSD_version < 500000
++      /* open */      kqemu_open,
++      /* close */     kqemu_close,
++      /* read */      noread,
++      /* write */     nowrite,
++      /* ioctl */     kqemu_ioctl,
++      /* poll */      nopoll,
++      /* mmap */      nommap,
++      /* strategy */  nostrategy,
++      /* name */      "kqemu",
++      /* maj */       KQEMU_MAJOR,
++      /* dump */      nodump,
++      /* psize */     nopsize,
++      /* flags */     0,
++      /* bmaj */      -1
++#else
+       .d_version =    D_VERSION,
+       .d_flags =      D_NEEDGIANT,
+       .d_open =       kqemu_open,
+       .d_ioctl =      kqemu_ioctl,
+       .d_close =      kqemu_close,
+       .d_name =       "kqemu"
++#endif
+ };
+ 
+-/* For use with make_dev(9)/destroy_dev(9). */
+-static struct cdev *kqemu_dev;
++#if __FreeBSD_version >= 500000
++static void
++kqemu_clone(void *arg, char *name, int namelen, struct cdev **dev)
++{
++    int unit, r;
++    if (*dev != NULL)
++      return;
++
++    if (strcmp(name, "kqemu") == 0)
++      unit = -1;
++    else if (dev_stdclone(name, NULL, "kqemu", &unit) != 1)
++      return;         /* Bad name */
++    if (unit != -1 && unit > KQEMU_MAX_INSTANCES)
++      return;
++
++    r = clone_create(&kqemuclones, &kqemu_cdevsw, &unit, dev, 0);
++    if (r) {
++      *dev = make_dev(&kqemu_cdevsw, unit2minor(unit),
++          UID_ROOT, GID_WHEEL, 0660, "kqemu%d", unit);
++      if (*dev != NULL) {
++          dev_ref(*dev);
++          (*dev)->si_flags |= SI_CHEAPCLONE;
++      }
++    }
++}
++#endif
++
++static void kqemu_destroy(struct kqemu_instance *ks)
++{
++    struct cdev *dev = ks->kqemu_dev;
++
++    if (ks->state) {
++        kqemu_delete(ks->state);
++        ks->state = NULL;
++    }
++
++    free(ks, M_KQEMU);
++    dev->si_drv1 = NULL;
++#if __FreeBSD_version >= 500000
++    TAILQ_REMOVE(&kqemuhead, ks, kqemu_ent);
++    destroy_dev(dev);
++#endif
++    --kqemu_ref_count;
++}
+ 
+ /* ARGSUSED */
+ static int
++#if __FreeBSD_version < 500000
++kqemu_open(dev_t dev, int flags, int fmt __unused, struct proc *p)
++{
++#else
+ kqemu_open(struct cdev *dev, int flags, int fmt __unused,
+     struct thread *td)
+ {
++    struct proc       *p = td->td_proc;
++#endif
+     struct kqemu_instance *ks;
++
++    if (dev->si_drv1 || kqemu_ref_count >= KQEMU_MAX_INSTANCES)
++      return(EBUSY);
++
++    if ((flags & (FREAD|FWRITE)) == FREAD)
++      return(EPERM);
++
+     ks = malloc(sizeof(struct kqemu_instance), M_KQEMU, M_WAITOK);
+     if (ks == NULL) {
+-      printf("malloc failed\n");
++      kqemu_log("malloc failed\n");
+       return ENOMEM;
+     }
+-    ks->state = NULL;
++    memset(ks, 0, sizeof *ks);
++#if __FreeBSD_version >= 500000
++    ks->kqemu_dev = dev;
++    TAILQ_INSERT_TAIL(&kqemuhead, ks, kqemu_ent);
++#endif
++    kqemu_ref_count++;
++
+     dev->si_drv1 = ks;
++    if (kqemu_debug > 0)
++      kqemu_log("opened by pid=%d\n", p->p_pid);
+     return 0;
+ }
+ 
+ /* ARGSUSED */
+ static int
++#if __FreeBSD_version < 500000
++kqemu_ioctl(dev_t dev, u_long cmd, caddr_t addr,
++    int flags __unused, struct proc *p)
++#else
+ kqemu_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, 
+     int flags __unused, struct thread *td)
++#endif
+ {
+     int error = 0;
+     int ret;
+@@ -233,8 +380,9 @@
+           break;
+       }
+       d1 = *(struct kqemu_init *)addr;
+-      printf("ram_base=%p ram_size=%ld\n", d1.ram_base, d1.ram_size);
+-      s = kqemu_init(d, 16000);
++      if (kqemu_debug > 0)
++          kqemu_log("ram_base=%p ram_size=%ld\n", d1.ram_base, d1.ram_size);
++      s = kqemu_init(d, max_locked_pages);
+       if (s == NULL) {
+           error = ENOMEM;
+           break;
+@@ -250,9 +398,16 @@
+       }
+       ctx = kqemu_get_cpu_state(s);
+       *ctx = *(struct kqemu_cpu_state *)addr;
++#if __FreeBSD_version >= 500000
+       DROP_GIANT();
++#endif
+       ret = kqemu_exec(s);
++#if __FreeBSD_version >= 500000
+       PICKUP_GIANT();
++      td->td_retval[0] = ret;
++#else
++      p->p_retval[0] = ret;
++#endif
+       *(struct kqemu_cpu_state *)addr = *ctx;
+       break;
+     }
+@@ -267,10 +422,22 @@
+ 
+ /* ARGSUSED */
+ static int
++#if __FreeBSD_version < 500000
++kqemu_close(dev_t dev, int flags, int fmt __unused, struct proc *p)
++{
++#else
+ kqemu_close(struct cdev *dev __unused, int flags, int fmt __unused,
+     struct thread *td)
+ {
+-      return 0;
++    struct proc     *p = td->td_proc;
++#endif
++    struct kqemu_instance *ks = (struct kqemu_instance *) dev->si_drv1;
++
++    kqemu_destroy(ks);
++
++    if (kqemu_debug > 0)
++      kqemu_log("closed by pid=%d\n", p->p_pid);
++    return 0;
+ }
+ 
+ /* ARGSUSED */
+@@ -278,15 +445,55 @@
+ kqemu_modevent(module_t mod __unused, int type, void *data __unused)
+ {
+     int error = 0;
++#if __FreeBSD_version < 500000
++    int rc;
++#else
++    struct kqemu_instance *ks;
++#endif
+ 
+     switch (type) {
+     case MOD_LOAD:
+       printf("kqemu version 0x%08x\n", KQEMU_VERSION);
++      max_locked_pages = physmem / (2 * KQEMU_MAX_INSTANCES);
++      if (max_locked_pages > 32768)
++          max_locked_pages = 32768;
++#if __FreeBSD_version < 500000
++      if ((rc = cdevsw_add(&kqemu_cdevsw))) {
++          kqemu_log("error registering cdevsw, rc=%d\n", rc);
++            error = ENOENT;
++            break;
++      }
+       kqemu_dev = make_dev(&kqemu_cdevsw, 0,
+-                           UID_ROOT, GID_WHEEL, 0666, "kqemu");
++                           UID_ROOT, GID_WHEEL, 0660, "kqemu");
++#else
++      clone_setup(&kqemuclones);
++      clonetag = EVENTHANDLER_REGISTER(dev_clone, kqemu_clone, 0, 1000);
++      if (!clonetag) {
++            error = ENOMEM;
++          break;
++      }
++#endif
++      kqemu_log("KQEMU installed, max_instances=%d max_locked_mem=%dkB.\n",
++                KQEMU_MAX_INSTANCES, max_locked_pages * 4);
++
++      kqemu_ref_count = 0;
+       break;
+     case MOD_UNLOAD:
++      if (kqemu_ref_count > 0) {
++            error = EBUSY;
++            break;
++        }
++#if __FreeBSD_version < 500000
+       destroy_dev(kqemu_dev);
++      if ((rc = cdevsw_remove(&kqemu_cdevsw)))
++          kqemu_log("error unregistering, rc=%d\n", rc);
++#else
++      EVENTHANDLER_DEREGISTER(dev_clone, clonetag);
++      while ((ks = TAILQ_FIRST(&kqemuhead)) != NULL) {
++          kqemu_destroy(ks);
++      }
++      clone_cleanup(&kqemuclones);
++#endif
+       break;
+     case MOD_SHUTDOWN:
+       break;
Index: files/patch-libmath2
@@ -0,0 +1,67 @@
+Index: qemu/bsd/Makefile
+@@ -16,7 +16,8 @@
+       ${MACHINE_ARCH}/s_rintl.c       \
+       ${MACHINE_ARCH}/s_round.c       \
+       ${MACHINE_ARCH}/s_sinl.S        \
+-      ${MACHINE_ARCH}/s_tanl.S
++      ${MACHINE_ARCH}/s_tanl.S        \
++      ${MACHINE_ARCH}/s_ldexpl.c
+ 
+ OBJS= ${SRCS:R:S/$/.o/}
+ 
+Index: qemu/bsd/i386/s_ldexpl.c
+@@ -0,0 +1,21 @@
++#include <math.h>
++#include <errno.h>
++#include <sysdep.h>
++
++long double __ldexpl(long double x, int expn)
++{
++  long double res;
++  if (!isfinite (x) || x == 0.0L)
++    return x;
++
++  __asm__ ("fscale"
++          : "=t" (res)
++          : "0" (x), "u" ((long double) expn));
++
++  if (!isfinite (res) || res == 0.0L)
++    errno = ERANGE;
++
++  return res;
++}
++
++weak_alias(__ldexpl,ldexpl)
+Index: qemu/bsd/amd64/s_ldexpl.c
+@@ -0,0 +1,21 @@
++#include <math.h>
++#include <errno.h>
++#include <sysdep.h>
++
++long double __ldexpl(long double x, int expn)
++{
++  long double res;
++  if (!isfinite (x) || x == 0.0L)
++    return x;
++
++  __asm__ ("fscale"
++          : "=t" (res)
++          : "0" (x), "u" ((long double) expn));
++
++  if (!isfinite (res) || res == 0.0L)
++    errno = ERANGE;
++
++  return res;
++}
++
++weak_alias(__ldexpl,ldexpl)
+Index: qemu/target-i386/helper.c
+@@ -2886,6 +2886,8 @@
+     ST0 = floatx_round_to_int(ST0, &env->fp_status);
+ }
+ 
++long double   ldexpl(long double, int);
++
+ void helper_fscale(void)
+ {
+     ST0 = ldexp (ST0, (int)(ST1)); 
Index: files/patch-vl.c
@@ -0,0 +1,21 @@
+Index: qemu/vl.c
+@@ -40,6 +40,10 @@
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <dirent.h>
++#ifdef __FreeBSD__
++#include <sys/types.h>
++#include <libutil.h>
++#endif
+ #ifdef _BSD
+ #include <sys/stat.h>
+ #ifndef __APPLE__
+@@ -1280,7 +1284,7 @@
+     return chr;
+ }
+ 
+-#if defined(__linux__)
++#if defined(__linux__) || defined(__FreeBSD__)
+ CharDriverState *qemu_chr_open_pty(void)
+ {
+     char slave_name[1024];
Index: files/patch-exec-all.h
@@ -0,0 +1,10 @@
+Index: qemu/exec-all.h
+@@ -620,7 +620,7 @@
+            (env->cr[0] & CR0_PE_MASK) && 
+            (env->eflags & IF_MASK) &&
+            !(env->eflags & VM_MASK)
+-#if 1
++#if 0
+            && (env->ldt.limit == 0 || env->ldt.limit == 0x27)
+ #endif
+            );