Use device_delete_children instead of explicit calls to device_delete_child

[jhb]

Summary

This is simpler and more robust in the face of potential double-frees
(e.g. if called after bus_generic_detach which will delete devices in
a future commit).

sys/arm/allwinner/aw_mmc.c

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);
 }

sys/arm64/broadcom/genet/if_genet.c

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);
 }

sys/dev/intpm/intpm.c

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);
 }