emulators/qemu-user-static-devel: Update to the newest snapshot.

[arrowd]

Summary

This updated the port to the tip of blitz branch.

Test Plan

poudriere testport passes on amd64 CURRENT.

[imp]

Why do we need the patches? I don't understand that since it builds for me w/o them, so I'd like to understand that.

[arrowd]

• emulators/qemu-user-static-devel/files/patch-configure:

The port passes --python=${PYTHON_CMD} to the configure script and this makes it to die with error. The check looks like a safety belt to make sure that Python passed in --python and Python used by Meson are the same. This is true anyways for Ports tree.

• emulators/qemu-user-static-devel/files/patch-tests_fp_meson.build

The tests/fp/meson.build files tries to include a directory that comes from git submodule. This directory isn't present when pulling distfile from GitHub. I can arrange the port to pull this directory too, but all this looks to be test-related, so I thought it is safe to patch out.

• emulators/qemu-user-static-devel/files/patch-accel_tcg_user-exec.c

The compiler complained about undefined symbol T_PAGEFLT, which seems to be defined in x86/trap.h.

[imp]

Sorry, I've been taking some time off and am just getting back into the swing of things

In D31255#703950, @arrowd wrote:

• emulators/qemu-user-static-devel/files/patch-configure:

The port passes --python=${PYTHON_CMD} to the configure script and this makes it to die with error. The check looks like a safety belt to make sure that Python passed in --python and Python used by Meson are the same. This is true anyways for Ports tree.

OK

• emulators/qemu-user-static-devel/files/patch-tests_fp_meson.build

The tests/fp/meson.build files tries to include a directory that comes from git submodule. This directory isn't present when pulling distfile from GitHub. I can arrange the port to pull this directory too, but all this looks to be test-related, so I thought it is safe to patch out.

OK. This is fine.

• emulators/qemu-user-static-devel/files/patch-accel_tcg_user-exec.c

The compiler complained about undefined symbol T_PAGEFLT, which seems to be defined in x86/trap.h.

Ah, I've fixed this upstream. I need to rebase the blitz branch to pick it up.

[arrowd]

Remove sparc64 from the rc file.

[imp]

OK. I'd like to update the blitz branch this week. If I do, I'd like this to be rebased to that.
If I don't get to it this week, this looks good to go as it is.

[arrowd]

Hook qemu unit tests into the port.

[arrowd]

The test target is actually "check" according to docs/devel/testing.rst

[imp]

emulators/qemu-user-static-devel/Makefile

50

Cool that you've hooked this up.
Does this target test any bsd-user-mode functionality? My quick grep suggests not.

emulators/qemu-user-static-devel/files/patch-tests_fp_meson.build

10

I'd add a comment here # disable fp tests since they live in a subrepo not fetched in the github tarball

[imp]

I've updated the 'next' blitz branch to 6.1.0rc1. You can drop the patch-accel_tcg_user-exec.c since that's now fully resolved and upstreamed.
Otherwise, this should be the same (modulo fluff).
So blitz-next will float over the next couple of weeks until 6.1.0 is done. I'll then make it the real blitz branch.

[arrowd]

• Update to blitz-next.
• Remove unnecessary patch.

[arrowd]

emulators/qemu-user-static-devel/Makefile

50

My quick grep suggests not.

Yeah, I guess so.

emulators/qemu-user-static-devel/files/patch-tests_fp_meson.build

10

I'd add a comment here # disable fp tests since they live in a subrepo not fetched in the github tarball

Done this in the patch file itself.

[imp]

So other than a quibble over the config args, I think this is looking really good.

emulators/qemu-user-static-devel/Makefile

26–27

This isn't directly used by bsd-user. Do we need it still? If so, that's cool, but if not we should remove it here.

54

I know once upon a time we needed the long list of disable. These days I think we just need '--disable-system'. The rest is automatically excluded. Inside ports, we may still need the extra stuff. I needed to use clang11, since clang12.0.1 has issues (though the 12.0.1rc2 didn't).
smbd isn't needed at all. That's just for qemu-system.
Also, both enable and disable docs? we can omit that.
capstone I'm unsure of in the ports env because I know that's a subrepo that gets grabbed from time to time when I build, and I never know why.

[kevans]

emulators/qemu-user-static-devel/Makefile

26–27

IIRC we only previously needed it because the build system couldn't cope with it missing, so it would indeed be spectacular if we can drop it now with the new hotness.

50

Ah, cool, this paves the way for more specific testing. :-)

[imp]

one last thing I forgot to mention here: clang 12.0.1 miscompiles bsd-user. 12.0.1rc2 is fine on a different machine, but I had to configure clang11 or gcc10 to build my development copies of bsd-user

[arrowd]

Remove some configuration options.

[arrowd]

emulators/qemu-user-static-devel/Makefile

26–27

IIRC we only previously needed it because the build system couldn't cope with it missing, so it would indeed be spectacular if we can drop it now with the new hotness.

It is still the case, the configure script fails if this dir isn't present. I can try patching it out, though.

[imp]

emulators/qemu-user-static-devel/Makefile

26–27

If we still need it, better to just grab it and use upstream with fewer modifications.

[arrowd]

Simplify post-install.

[arrowd]

Update to newest snapshot.

[arrowd]

Update to newest snapshot.

[imp]

Looking good. Feel free to commit any time. And thanks for doing this and putting up with my flakiness giving you feedback.

emulators/qemu-user-static-devel/Makefile

struct trampchunk {
         /* 0 -> allocated, 1 -> free */
         BITSET_DEFINE(, KINST_TRAMPS_PER_CHUNK) free;
 };
 
 static TAILQ_HEAD(, trampchunk)        kinst_trampchunks =
     TAILQ_HEAD_INITIALIZER(kinst_trampchunks);
 static struct sx                kinst_tramp_sx;
 SX_SYSINIT(kinst_tramp_sx, &kinst_tramp_sx, "kinst tramp");
+#ifdef __amd64__
 static eventhandler_tag         kinst_thread_ctor_handler;
 static eventhandler_tag         kinst_thread_dtor_handler;
+#endif
 
 /*
  * Fill the trampolines with KINST_TRAMP_FILL_PATTERN so that the kernel will
  * crash cleanly if things somehow go wrong.
  */
 static void
 kinst_trampoline_fill(uint8_t *addr, int size)
 {
if ((off = BIT_FFS(KINST_TRAMPS_PER_CHUNK, &chunk->free)) == 0)
                         continue;
                 /* BIT_FFS() returns indices starting at 1 instead of 0. */
                 off--;
                 break;
         }
         if (chunk == NULL) {
                 if ((how & M_NOWAIT) != 0)
                         return (NULL);
 
+                if ((chunk = kinst_trampchunk_alloc()) == NULL) {
+#ifdef __amd64__
                         /*
-                 * We didn't find any free trampoline in the current list,
-                 * allocate a new one.  If that fails the provider will no
-                 * longer be reliable, so try to warn the user.
+                         * We didn't find any free trampoline in the current
+                         * list, allocate a new one.  If that fails the
+                         * provider will no longer be reliable, so try to warn
+                         * the user.
                          */
-                if ((chunk = kinst_trampchunk_alloc()) == NULL) {
                         static bool once = true;
 
                         if (once) {
                                 once = false;
                                 KINST_LOG(
                                     "kinst: failed to allocate trampoline, "
                                     "probes may not fire");
                         }
+#endif
                         return (NULL);
                 }
                 off = 0;
         }
         BIT_CLR(KINST_TRAMPS_PER_CHUNK, off, &chunk->free);
         tramp = chunk->addr + off * KINST_TRAMP_SIZE;
         return (tramp);
 }

 void
 kinst_trampoline_dealloc(uint8_t *tramp)
 {
         sx_xlock(&kinst_tramp_sx);
         kinst_trampoline_dealloc_locked(tramp, true);
         sx_xunlock(&kinst_tramp_sx);
 }
 
+#ifdef __amd64__
 static void
 kinst_thread_ctor(void *arg __unused, struct thread *td)
 {
         td->t_kinst_tramp = kinst_trampoline_alloc(M_WAITOK);
 }
 
 static void
 kinst_thread_dtor(void *arg __unused, struct thread *td)
 {
         void *tramp;
 
         tramp = td->t_kinst_tramp;
         td->t_kinst_tramp = NULL;
 
         /*
          * This assumes that the thread_dtor event permits sleeping, which
          * appears to be true for the time being.
          */
         kinst_trampoline_dealloc(tramp);
 }
+#endif
 
 int
 kinst_trampoline_init(void)
 {
+#ifdef __amd64__
         struct proc *p;
         struct thread *td;
         void *tramp;
         int error;
 
         kinst_thread_ctor_handler = EVENTHANDLER_REGISTER(thread_ctor,
             kinst_thread_ctor, NULL, EVENTHANDLER_PRI_ANY);
         kinst_thread_dtor_handler = EVENTHANDLER_REGISTER(thread_dtor,
FOREACH_THREAD_IN_PROC(p, td) {
                         td->t_kinst_tramp = tramp;
                         tramp = NULL;
                 }
                 PROC_UNLOCK(p);
         }
 out:
         sx_xunlock(&kinst_tramp_sx);
         sx_sunlock(&allproc_lock);
+#else
+        int error = 0;
+
+        sx_xlock(&kinst_tramp_sx);
+        TAILQ_INIT(&kinst_trampchunks);
+        sx_xunlock(&kinst_tramp_sx);
+#endif
+
         return (error);
 }
 
 int
 kinst_trampoline_deinit(void)
 {
+#ifdef __amd64__
         struct trampchunk *chunk, *tmp;
         struct proc *p;
         struct thread *td;
 
         EVENTHANDLER_DEREGISTER(thread_ctor, kinst_thread_ctor_handler);
         EVENTHANDLER_DEREGISTER(thread_dtor, kinst_thread_dtor_handler);
 
         sx_slock(&allproc_lock);
         sx_xlock(&kinst_tramp_sx);
         FOREACH_PROC_IN_SYSTEM(p) {
                 PROC_LOCK(p);
                 FOREACH_THREAD_IN_PROC(p, td) {
                         kinst_trampoline_dealloc_locked(td->t_kinst_tramp,
                             false);
                         td->t_kinst_tramp = NULL;
                 }
                 PROC_UNLOCK(p);
         }
         sx_sunlock(&allproc_lock);
         TAILQ_FOREACH_SAFE(chunk, &kinst_trampchunks, next, tmp)
                 kinst_trampchunk_free(chunk);
         sx_xunlock(&kinst_tramp_sx);
+#else
+        struct trampchunk *chunk, *tmp;
+
+        sx_xlock(&kinst_tramp_sx);
+        TAILQ_FOREACH_SAFE(chunk, &kinst_trampchunks, next, tmp)
+                kinst_trampchunk_free(chunk);
+        sx_xunlock(&kinst_tramp_sx);
+#endif
 
         return (0);
 }

emulators/qemu-user-static-devel/distinfo

struct trampchunk {
         /* 0 -> allocated, 1 -> free */
         BITSET_DEFINE(, KINST_TRAMPS_PER_CHUNK) free;
 };
 
 static TAILQ_HEAD(, trampchunk)        kinst_trampchunks =
     TAILQ_HEAD_INITIALIZER(kinst_trampchunks);
 static struct sx                kinst_tramp_sx;
 SX_SYSINIT(kinst_tramp_sx, &kinst_tramp_sx, "kinst tramp");
+#ifdef __amd64__
 static eventhandler_tag         kinst_thread_ctor_handler;
 static eventhandler_tag         kinst_thread_dtor_handler;
+#endif
 
 /*
  * Fill the trampolines with KINST_TRAMP_FILL_PATTERN so that the kernel will
  * crash cleanly if things somehow go wrong.
  */
 static void
 kinst_trampoline_fill(uint8_t *addr, int size)
 {
if ((off = BIT_FFS(KINST_TRAMPS_PER_CHUNK, &chunk->free)) == 0)
                         continue;
                 /* BIT_FFS() returns indices starting at 1 instead of 0. */
                 off--;
                 break;
         }
         if (chunk == NULL) {
                 if ((how & M_NOWAIT) != 0)
                         return (NULL);
 
+                if ((chunk = kinst_trampchunk_alloc()) == NULL) {
+#ifdef __amd64__
                         /*
-                 * We didn't find any free trampoline in the current list,
-                 * allocate a new one.  If that fails the provider will no
-                 * longer be reliable, so try to warn the user.
+                         * We didn't find any free trampoline in the current
+                         * list, allocate a new one.  If that fails the
+                         * provider will no longer be reliable, so try to warn
+                         * the user.
                          */
-                if ((chunk = kinst_trampchunk_alloc()) == NULL) {
                         static bool once = true;
 
                         if (once) {
                                 once = false;
                                 KINST_LOG(
                                     "kinst: failed to allocate trampoline, "
                                     "probes may not fire");
                         }
+#endif
                         return (NULL);
                 }
                 off = 0;
         }
         BIT_CLR(KINST_TRAMPS_PER_CHUNK, off, &chunk->free);
         tramp = chunk->addr + off * KINST_TRAMP_SIZE;
         return (tramp);
 }

 void
 kinst_trampoline_dealloc(uint8_t *tramp)
 {
         sx_xlock(&kinst_tramp_sx);
         kinst_trampoline_dealloc_locked(tramp, true);
         sx_xunlock(&kinst_tramp_sx);
 }
 
+#ifdef __amd64__
 static void
 kinst_thread_ctor(void *arg __unused, struct thread *td)
 {
         td->t_kinst_tramp = kinst_trampoline_alloc(M_WAITOK);
 }
 
 static void
 kinst_thread_dtor(void *arg __unused, struct thread *td)
 {
         void *tramp;
 
         tramp = td->t_kinst_tramp;
         td->t_kinst_tramp = NULL;
 
         /*
          * This assumes that the thread_dtor event permits sleeping, which
          * appears to be true for the time being.
          */
         kinst_trampoline_dealloc(tramp);
 }
+#endif
 
 int
 kinst_trampoline_init(void)
 {
+#ifdef __amd64__
         struct proc *p;
         struct thread *td;
         void *tramp;
         int error;
 
         kinst_thread_ctor_handler = EVENTHANDLER_REGISTER(thread_ctor,
             kinst_thread_ctor, NULL, EVENTHANDLER_PRI_ANY);
         kinst_thread_dtor_handler = EVENTHANDLER_REGISTER(thread_dtor,
FOREACH_THREAD_IN_PROC(p, td) {
                         td->t_kinst_tramp = tramp;
                         tramp = NULL;
                 }
                 PROC_UNLOCK(p);
         }
 out:
         sx_xunlock(&kinst_tramp_sx);
         sx_sunlock(&allproc_lock);
+#else
+        int error = 0;
+
+        sx_xlock(&kinst_tramp_sx);
+        TAILQ_INIT(&kinst_trampchunks);
+        sx_xunlock(&kinst_tramp_sx);
+#endif
+
         return (error);
 }
 
 int
 kinst_trampoline_deinit(void)
 {
+#ifdef __amd64__
         struct trampchunk *chunk, *tmp;
         struct proc *p;
         struct thread *td;
 
         EVENTHANDLER_DEREGISTER(thread_ctor, kinst_thread_ctor_handler);
         EVENTHANDLER_DEREGISTER(thread_dtor, kinst_thread_dtor_handler);
 
         sx_slock(&allproc_lock);
         sx_xlock(&kinst_tramp_sx);
         FOREACH_PROC_IN_SYSTEM(p) {
                 PROC_LOCK(p);
                 FOREACH_THREAD_IN_PROC(p, td) {
                         kinst_trampoline_dealloc_locked(td->t_kinst_tramp,
                             false);
                         td->t_kinst_tramp = NULL;
                 }
                 PROC_UNLOCK(p);
         }
         sx_sunlock(&allproc_lock);
         TAILQ_FOREACH_SAFE(chunk, &kinst_trampchunks, next, tmp)
                 kinst_trampchunk_free(chunk);
         sx_xunlock(&kinst_tramp_sx);
+#else
+        struct trampchunk *chunk, *tmp;
+
+        sx_xlock(&kinst_tramp_sx);
+        TAILQ_FOREACH_SAFE(chunk, &kinst_trampchunks, next, tmp)
+                kinst_trampchunk_free(chunk);
+        sx_xunlock(&kinst_tramp_sx);
+#endif
 
         return (0);
 }

emulators/qemu-user-static-devel/files/patch-configure

struct trampchunk {
         /* 0 -> allocated, 1 -> free */
         BITSET_DEFINE(, KINST_TRAMPS_PER_CHUNK) free;
 };
 
 static TAILQ_HEAD(, trampchunk)        kinst_trampchunks =
     TAILQ_HEAD_INITIALIZER(kinst_trampchunks);
 static struct sx                kinst_tramp_sx;
 SX_SYSINIT(kinst_tramp_sx, &kinst_tramp_sx, "kinst tramp");
+#ifdef __amd64__
 static eventhandler_tag         kinst_thread_ctor_handler;
 static eventhandler_tag         kinst_thread_dtor_handler;
+#endif
 
 /*
  * Fill the trampolines with KINST_TRAMP_FILL_PATTERN so that the kernel will
  * crash cleanly if things somehow go wrong.
  */
 static void
 kinst_trampoline_fill(uint8_t *addr, int size)
 {
if ((off = BIT_FFS(KINST_TRAMPS_PER_CHUNK, &chunk->free)) == 0)
                         continue;
                 /* BIT_FFS() returns indices starting at 1 instead of 0. */
                 off--;
                 break;
         }
         if (chunk == NULL) {
                 if ((how & M_NOWAIT) != 0)
                         return (NULL);
 
+                if ((chunk = kinst_trampchunk_alloc()) == NULL) {
+#ifdef __amd64__
                         /*
-                 * We didn't find any free trampoline in the current list,
-                 * allocate a new one.  If that fails the provider will no
-                 * longer be reliable, so try to warn the user.
+                         * We didn't find any free trampoline in the current
+                         * list, allocate a new one.  If that fails the
+                         * provider will no longer be reliable, so try to warn
+                         * the user.
                          */
-                if ((chunk = kinst_trampchunk_alloc()) == NULL) {
                         static bool once = true;
 
                         if (once) {
                                 once = false;
                                 KINST_LOG(
                                     "kinst: failed to allocate trampoline, "
                                     "probes may not fire");
                         }
+#endif
                         return (NULL);
                 }
                 off = 0;
         }
         BIT_CLR(KINST_TRAMPS_PER_CHUNK, off, &chunk->free);
         tramp = chunk->addr + off * KINST_TRAMP_SIZE;
         return (tramp);
 }

 void
 kinst_trampoline_dealloc(uint8_t *tramp)
 {
         sx_xlock(&kinst_tramp_sx);
         kinst_trampoline_dealloc_locked(tramp, true);
         sx_xunlock(&kinst_tramp_sx);
 }
 
+#ifdef __amd64__
 static void
 kinst_thread_ctor(void *arg __unused, struct thread *td)
 {
         td->t_kinst_tramp = kinst_trampoline_alloc(M_WAITOK);
 }
 
 static void
 kinst_thread_dtor(void *arg __unused, struct thread *td)
 {
         void *tramp;
 
         tramp = td->t_kinst_tramp;
         td->t_kinst_tramp = NULL;
 
         /*
          * This assumes that the thread_dtor event permits sleeping, which
          * appears to be true for the time being.
          */
         kinst_trampoline_dealloc(tramp);
 }
+#endif
 
 int
 kinst_trampoline_init(void)
 {
+#ifdef __amd64__
         struct proc *p;
         struct thread *td;
         void *tramp;
         int error;
 
         kinst_thread_ctor_handler = EVENTHANDLER_REGISTER(thread_ctor,
             kinst_thread_ctor, NULL, EVENTHANDLER_PRI_ANY);
         kinst_thread_dtor_handler = EVENTHANDLER_REGISTER(thread_dtor,
FOREACH_THREAD_IN_PROC(p, td) {
                         td->t_kinst_tramp = tramp;
                         tramp = NULL;
                 }
                 PROC_UNLOCK(p);
         }
 out:
         sx_xunlock(&kinst_tramp_sx);
         sx_sunlock(&allproc_lock);
+#else
+        int error = 0;
+
+        sx_xlock(&kinst_tramp_sx);
+        TAILQ_INIT(&kinst_trampchunks);
+        sx_xunlock(&kinst_tramp_sx);
+#endif
+
         return (error);
 }
 
 int
 kinst_trampoline_deinit(void)
 {
+#ifdef __amd64__
         struct trampchunk *chunk, *tmp;
         struct proc *p;
         struct thread *td;
 
         EVENTHANDLER_DEREGISTER(thread_ctor, kinst_thread_ctor_handler);
         EVENTHANDLER_DEREGISTER(thread_dtor, kinst_thread_dtor_handler);
 
         sx_slock(&allproc_lock);
         sx_xlock(&kinst_tramp_sx);
         FOREACH_PROC_IN_SYSTEM(p) {
                 PROC_LOCK(p);
                 FOREACH_THREAD_IN_PROC(p, td) {
                         kinst_trampoline_dealloc_locked(td->t_kinst_tramp,
                             false);
                         td->t_kinst_tramp = NULL;
                 }
                 PROC_UNLOCK(p);
         }
         sx_sunlock(&allproc_lock);
         TAILQ_FOREACH_SAFE(chunk, &kinst_trampchunks, next, tmp)
                 kinst_trampchunk_free(chunk);
         sx_xunlock(&kinst_tramp_sx);
+#else
+        struct trampchunk *chunk, *tmp;
+
+        sx_xlock(&kinst_tramp_sx);
+        TAILQ_FOREACH_SAFE(chunk, &kinst_trampchunks, next, tmp)
+                kinst_trampchunk_free(chunk);
+        sx_xunlock(&kinst_tramp_sx);
+#endif
 
         return (0);
 }

emulators/qemu-user-static-devel/files/patch-tests_fp_meson.build

struct trampchunk {
         /* 0 -> allocated, 1 -> free */
         BITSET_DEFINE(, KINST_TRAMPS_PER_CHUNK) free;
 };
 
 static TAILQ_HEAD(, trampchunk)        kinst_trampchunks =
     TAILQ_HEAD_INITIALIZER(kinst_trampchunks);
 static struct sx                kinst_tramp_sx;
 SX_SYSINIT(kinst_tramp_sx, &kinst_tramp_sx, "kinst tramp");
+#ifdef __amd64__
 static eventhandler_tag         kinst_thread_ctor_handler;
 static eventhandler_tag         kinst_thread_dtor_handler;
+#endif
 
 /*
  * Fill the trampolines with KINST_TRAMP_FILL_PATTERN so that the kernel will
  * crash cleanly if things somehow go wrong.
  */
 static void
 kinst_trampoline_fill(uint8_t *addr, int size)
 {
if ((off = BIT_FFS(KINST_TRAMPS_PER_CHUNK, &chunk->free)) == 0)
                         continue;
                 /* BIT_FFS() returns indices starting at 1 instead of 0. */
                 off--;
                 break;
         }
         if (chunk == NULL) {
                 if ((how & M_NOWAIT) != 0)
                         return (NULL);
 
+                if ((chunk = kinst_trampchunk_alloc()) == NULL) {
+#ifdef __amd64__
                         /*
-                 * We didn't find any free trampoline in the current list,
-                 * allocate a new one.  If that fails the provider will no
-                 * longer be reliable, so try to warn the user.
+                         * We didn't find any free trampoline in the current
+                         * list, allocate a new one.  If that fails the
+                         * provider will no longer be reliable, so try to warn
+                         * the user.
                          */
-                if ((chunk = kinst_trampchunk_alloc()) == NULL) {
                         static bool once = true;
 
                         if (once) {
                                 once = false;
                                 KINST_LOG(
                                     "kinst: failed to allocate trampoline, "
                                     "probes may not fire");
                         }
+#endif
                         return (NULL);
                 }
                 off = 0;
         }
         BIT_CLR(KINST_TRAMPS_PER_CHUNK, off, &chunk->free);
         tramp = chunk->addr + off * KINST_TRAMP_SIZE;
         return (tramp);
 }

 void
 kinst_trampoline_dealloc(uint8_t *tramp)
 {
         sx_xlock(&kinst_tramp_sx);
         kinst_trampoline_dealloc_locked(tramp, true);
         sx_xunlock(&kinst_tramp_sx);
 }
 
+#ifdef __amd64__
 static void
 kinst_thread_ctor(void *arg __unused, struct thread *td)
 {
         td->t_kinst_tramp = kinst_trampoline_alloc(M_WAITOK);
 }
 
 static void
 kinst_thread_dtor(void *arg __unused, struct thread *td)
 {
         void *tramp;
 
         tramp = td->t_kinst_tramp;
         td->t_kinst_tramp = NULL;
 
         /*
          * This assumes that the thread_dtor event permits sleeping, which
          * appears to be true for the time being.
          */
         kinst_trampoline_dealloc(tramp);
 }
+#endif
 
 int
 kinst_trampoline_init(void)
 {
+#ifdef __amd64__
         struct proc *p;
         struct thread *td;
         void *tramp;
         int error;
 
         kinst_thread_ctor_handler = EVENTHANDLER_REGISTER(thread_ctor,
             kinst_thread_ctor, NULL, EVENTHANDLER_PRI_ANY);
         kinst_thread_dtor_handler = EVENTHANDLER_REGISTER(thread_dtor,
FOREACH_THREAD_IN_PROC(p, td) {
                         td->t_kinst_tramp = tramp;
                         tramp = NULL;
                 }
                 PROC_UNLOCK(p);
         }
 out:
         sx_xunlock(&kinst_tramp_sx);
         sx_sunlock(&allproc_lock);
+#else
+        int error = 0;
+
+        sx_xlock(&kinst_tramp_sx);
+        TAILQ_INIT(&kinst_trampchunks);
+        sx_xunlock(&kinst_tramp_sx);
+#endif
+
         return (error);
 }
 
 int
 kinst_trampoline_deinit(void)
 {
+#ifdef __amd64__
         struct trampchunk *chunk, *tmp;
         struct proc *p;
         struct thread *td;
 
         EVENTHANDLER_DEREGISTER(thread_ctor, kinst_thread_ctor_handler);
         EVENTHANDLER_DEREGISTER(thread_dtor, kinst_thread_dtor_handler);
 
         sx_slock(&allproc_lock);
         sx_xlock(&kinst_tramp_sx);
         FOREACH_PROC_IN_SYSTEM(p) {
                 PROC_LOCK(p);
                 FOREACH_THREAD_IN_PROC(p, td) {
                         kinst_trampoline_dealloc_locked(td->t_kinst_tramp,
                             false);
                         td->t_kinst_tramp = NULL;
                 }
                 PROC_UNLOCK(p);
         }
         sx_sunlock(&allproc_lock);
         TAILQ_FOREACH_SAFE(chunk, &kinst_trampchunks, next, tmp)
                 kinst_trampchunk_free(chunk);
         sx_xunlock(&kinst_tramp_sx);
+#else
+        struct trampchunk *chunk, *tmp;
+
+        sx_xlock(&kinst_tramp_sx);
+        TAILQ_FOREACH_SAFE(chunk, &kinst_trampchunks, next, tmp)
+                kinst_trampchunk_free(chunk);
+        sx_xunlock(&kinst_tramp_sx);
+#endif
 
         return (0);
 }