LinuxKPI: Move linux/minmax.h content out of linux/kernel.h

[wulf]

Summary

To match Linux and allow direct linux/minmax.h inclusion.

Sponsored by: Serenity Cyber Security, LLC
MFC after: 1 week

[bz]

sys/compat/linuxkpi/common/include/linux/minmax.h

8

Looking at the history these are wrong. based on the 3 commits which seem to make out the lines removed from kernel.h (2ca3cc51324c4, abb14a540f751, fe657d68f54b7) all by Hans Petter Selasky the additional lines should be:

+ * Copyright (c) 2013-2015 Mellanox Technologies, Ltd.
+ * Copyright (c) 2014-2015 Fran<C3><A7>ois Tigeot

2016:

Obtained from:  kmacy @
Sponsored by:   Mellanox Technologies

2025:

Sponsored by:   Mellanox Technologies

So iX and Panasas can go but Fran<C3><A7>ois Tigeot should be added.

Can you please double check that I didn't foobar that?

45

Is there a reason not to keep the "clamp" ones together?

[emaste]

Also should be UFT-8-ized e.g. François Tigeot

[wulf]

Add Melanox and François to authors

Keep iX Systems and Panasas as origin of some macroses e.g. min & max may be
tracked to original ofed import and I do not want dig deeper in history than
git blame output.

Move clamp in to clamp group to preserve traditional FreeBSD order of macros
rather than switch to Linux one.

sys/compat/linuxkpi/common/include/linux/kernel.h

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/compat/linuxkpi/common/include/linux/minmax.h

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