Index: /trunk/src/emx/src/lib/misc/sysctl.c
===================================================================
--- /trunk/src/emx/src/lib/misc/sysctl.c	(revision 1916)
+++ /trunk/src/emx/src/lib/misc/sysctl.c	(revision 1917)
@@ -36,36 +36,39 @@
  */
 
+#include "libc-alias.h"
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/sys/kern/kern_sysctl.c,v 1.159 2004/07/28 06:42:41 kan Exp $");
-
-#include "opt_compat.h"
-#include "opt_mac.h"
+//__FBSDID("$FreeBSD: src/sys/kern/kern_sysctl.c,v 1.159 2004/07/28 06:42:41 kan Exp $");
 
 #include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
+#define _KERNEL
 #include <sys/sysctl.h>
-#include <sys/mac.h>
-#include <sys/malloc.h>
-#include <sys/proc.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/sx.h>
-#include <sys/sysproto.h>
-#include <vm/vm.h>
-#include <vm/vm_extern.h>
-
-static MALLOC_DEFINE(M_SYSCTL, "sysctl", "sysctl internal magic");
-static MALLOC_DEFINE(M_SYSCTLOID, "sysctloid", "sysctl dynamic oids");
-static MALLOC_DEFINE(M_SYSCTLTMP, "sysctltmp", "sysctl temp output buffer");
+#include <386/builtin.h>
+#include <sys/fmutex.h>
+#include <sys/smutex.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_MISC
+#include <InnoTekLIBC/logstrict.h>
+#undef printf
+#define printf LIBCLOG_MSG2
+#undef panic
+#define panic LIBC_ASSERTM_FAILED
+#undef copyout
+#define copyout(x,y,z)  !memcpy((y),(x),(z))
+#undef copyin
+#define copyin(x,y,z)   !memcpy((y),(x),(z))
+#undef securelevel_gt
+#define securelevel_gt(cr, level) 0
 
 /*
  * Locking - this locks the sysctl tree in memory.
  */
-static struct sx sysctllock;
-
-#define	SYSCTL_LOCK()		sx_xlock(&sysctllock)
-#define	SYSCTL_UNLOCK()		sx_xunlock(&sysctllock)
-#define	SYSCTL_INIT()		sx_init(&sysctllock, "sysctl lock")
+static _fmutex sysctllock;
+
+#define	SYSCTL_LOCK()		_fmutex_request(&sysctllock, 0)
+#define	SYSCTL_UNLOCK()		_fmutex_release(&sysctllock)
+#define	SYSCTL_INIT()		_fmutex_create2(&sysctllock, 0, "sysctl lock")
 
 static int sysctl_root(SYSCTL_HANDLER_ARGS);
@@ -92,5 +95,5 @@
  */
 
-void
+static void
 sysctl_register_oid(struct sysctl_oid *oidp)
 {
@@ -149,4 +152,5 @@
 }
 
+#if 0 /* no dynamic stuff */
 void
 sysctl_unregister_oid(struct sysctl_oid *oidp)
@@ -169,5 +173,5 @@
 	}
 
-	/* 
+	/*
 	 * This can happen when a module fails to register and is
 	 * being unloaded afterwards.  It should not be a panic()
@@ -177,4 +181,8 @@
 		printf("%s: failed to unregister sysctl\n", __func__);
 }
+#endif /* no dynamic stuff */
+
+
+#if 0 /* no context stuff */
 
 /* Initialize a new context to keep track of dynamically added sysctls. */
@@ -288,4 +296,7 @@
 }
 
+#endif /* no context stuff */
+
+#if 0 /* no dynamic stuff. */
 /*
  * Remove dynamically created sysctl trees.
@@ -431,10 +442,10 @@
 	return (0);
 }
+#endif /* no dynamic stuff. */
+
 
 /*
  * Register the kernel's oids on startup.
  */
-SET_DECLARE(sysctl_set, struct sysctl_oid);
-
 static void
 sysctl_register_all(void *arg)
@@ -443,13 +454,26 @@
 
 	SYSCTL_INIT();
-	SET_FOREACH(oidp, sysctl_set)
-		sysctl_register_oid(*oidp);
-}
-SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_ANY, sysctl_register_all, 0);
-
+        extern int __sysctl_set__;
+        int *ptr = &__sysctl_set__;
+	if (*ptr == -2)
+            for (oidp = (struct sysctl_oid **)(ptr + 1); *oidp != NULL; oidp++)
+                sysctl_register_oid(*oidp);
+        else
+        {
+            if (*ptr == -1) --ptr;      /* Fix GNU ld bug */
+            int n = *ptr++;              /* Get size of vector */
+            if (*ptr == -1)             /* First element must be -1, see crt0.s */
+                for (oidp = (struct sysctl_oid **)(ptr + 1); n > 1; oidp++, n--)
+                    sysctl_register_oid(*oidp);
+        }
+
+}
+//SYSINIT(sysctl, SI_SUB_KMEM, SI_ORDER_ANY, sysctl_register_all, 0);
+
+#if 0 /* no debug stuff just yet */
 /*
  * "Staff-functions"
  *
- * These functions implement a presently undocumented interface 
+ * These functions implement a presently undocumented interface
  * used by the sysctl program to walk the tree, and get the type
  * so it can print the value.
@@ -519,4 +543,5 @@
 SYSCTL_PROC(_sysctl, 0, debug, CTLTYPE_STRING|CTLFLAG_RD,
 	0, 0, sysctl_sysctl_debug, "-", "");
+#endif /* no debug stuff just yet */
 
 static int
@@ -559,5 +584,5 @@
 			name++;
 
-			if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE) 
+			if ((oid->oid_kind & CTLTYPE) != CTLTYPE_NODE)
 				break;
 
@@ -576,5 +601,5 @@
 
 static int
-sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen, 
+sysctl_sysctl_next_ls(struct sysctl_oid_list *lsp, int *name, u_int namelen,
 	int *next, int *len, int level, struct sysctl_oid **oidpp)
 {
@@ -590,11 +615,11 @@
 
 		if (!namelen) {
-			if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE) 
+			if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE)
 				return 0;
-			if (oidp->oid_handler) 
+			if (oidp->oid_handler)
 				/* We really should call the handler here...*/
 				return 0;
 			lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
-			if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1, 
+			if (!sysctl_sysctl_next_ls(lsp, 0, 0, next+1,
 				len, level+1, oidpp))
 				return 0;
@@ -611,5 +636,5 @@
 				return 0;
 			lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
-			if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, 
+			if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1,
 				next+1, len, level+1, oidpp))
 				return (0);
@@ -623,5 +648,5 @@
 
 		lsp = (struct sysctl_oid_list *)oidp->oid_arg1;
-		if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1, 
+		if (!sysctl_sysctl_next_ls(lsp, name+1, namelen-1, next+1,
 			len, level+1, oidpp))
 			return (0);
@@ -670,5 +695,5 @@
 	*len = 0;
 
-	for (p = name; *p && *p != '.'; p++) 
+	for (p = name; *p && *p != '.'; p++)
 		;
 	i = *p;
@@ -701,5 +726,5 @@
 		oidp = SLIST_FIRST(lsp);
 		name = p+1;
-		for (p = name; *p && *p != '.'; p++) 
+		for (p = name; *p && *p != '.'; p++)
 				;
 		i = *p;
@@ -717,14 +742,14 @@
 	struct sysctl_oid *op = 0;
 
-	if (!req->newlen) 
+	if (!req->newlen)
 		return ENOENT;
 	if (req->newlen >= MAXPATHLEN)	/* XXX arbitrary, undocumented */
 		return (ENAMETOOLONG);
 
-	p = malloc(req->newlen+1, M_SYSCTL, M_WAITOK);
+	p = malloc(req->newlen+1/*, M_SYSCTL, M_WAITOK*/);
 
 	error = SYSCTL_IN(req, p, req->newlen);
 	if (error) {
-		free(p, M_SYSCTL);
+		free(p/*, M_SYSCTL*/);
 		return (error);
 	}
@@ -734,5 +759,5 @@
 	error = name2oid(p, oid, &len, &op);
 
-	free(p, M_SYSCTL);
+	free(p/*, M_SYSCTL*/);
 
 	if (error)
@@ -743,6 +768,10 @@
 }
 
-SYSCTL_PROC(_sysctl, 3, name2oid, CTLFLAG_RW|CTLFLAG_ANYBODY, 0, 0, 
+SYSCTL_PROC(_sysctl, 3, name2oid, CTLFLAG_RW|CTLFLAG_ANYBODY, 0, 0,
 	sysctl_sysctl_name2oid, "I", "");
+
+static int
+sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid,
+    int *nindx, struct sysctl_req *req);
 
 static int
@@ -866,13 +895,13 @@
 retry:
 	outlen = strlen((char *)arg1)+1;
-	tmparg = malloc(outlen, M_SYSCTLTMP, M_WAITOK);
+	tmparg = malloc(outlen/*, M_SYSCTLTMP, M_WAITOK*/);
 
 	if (strlcpy(tmparg, (char *)arg1, outlen) >= outlen) {
-		free(tmparg, M_SYSCTLTMP);
+		free(tmparg/*, M_SYSCTLTMP*/);
 		goto retry;
 	}
 
 	error = SYSCTL_OUT(req, tmparg, outlen);
-	free(tmparg, M_SYSCTLTMP);
+	free(tmparg/*, M_SYSCTLTMP*/);
 
 	if (error || !req->newptr)
@@ -898,6 +927,6 @@
 sysctl_handle_opaque(SYSCTL_HANDLER_ARGS)
 {
-	int error, tries;
-	u_int generation;
+	int error/*, tries*/;
+//	u_int generation;
 	struct sysctl_req req2;
 
@@ -909,16 +938,16 @@
 	 * If we encounter an error, stop immediately.
 	 */
-	tries = 0;
+//	tries = 0;
 	req2 = *req;
-retry:
-	generation = curthread->td_generation;
+//retry:
+	//generation = curthread->td_generation;
 	error = SYSCTL_OUT(req, arg1, arg2);
 	if (error)
 		return (error);
-	tries++;
-	if (generation != curthread->td_generation && tries < 3) {
-		*req = req2;
-		goto retry;
-	}
+	//tries++;
+	//if (generation != curthread->td_generation && tries < 3) {
+	//	*req = req2;
+	//	goto retry;
+	//}
 
 	error = SYSCTL_IN(req, arg1, arg2);
@@ -927,4 +956,5 @@
 }
 
+#if 0 /* not used */
 /*
  * Transfer functions to/from kernel space.
@@ -997,6 +1027,6 @@
 	error = sysctl_root(0, name, namelen, &req);
 
-	if (req.lock == REQ_WIRED && req.validlen > 0)
-		vsunlock(req.oldptr, req.validlen);
+	//if (req.lock == REQ_WIRED && req.validlen > 0)
+	//	vsunlock(req.oldptr, req.validlen);
 
 	SYSCTL_UNLOCK();
@@ -1035,4 +1065,5 @@
 	return (error);
 }
+#endif /* not used */
 
 /*
@@ -1049,7 +1080,7 @@
 	if (req->oldptr == NULL)
 		return (0);
-	if (req->lock == REQ_LOCKED)
-		WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
-		    "sysctl_old_user()");
+	//if (req->lock == REQ_LOCKED)
+	//	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
+	//	    "sysctl_old_user()");
 	i = l;
 	len = req->validlen;
@@ -1082,4 +1113,5 @@
 }
 
+#if 0 /* don't need you.. */
 /*
  * Wire the user space destination buffer.  If set to a value greater than
@@ -1113,6 +1145,7 @@
 	return (0);
 }
-
-int
+#endif /* don't need you.. */
+
+static int
 sysctl_find_oid(int *name, u_int namelen, struct sysctl_oid **noid,
     int *nindx, struct sysctl_req *req)
@@ -1182,5 +1215,5 @@
 		return (EPERM);
 
-	KASSERT(req->td != NULL, ("sysctl_root(): req->td == NULL"));
+	//KASSERT(req->td != NULL, ("sysctl_root(): req->td == NULL"));
 
 	/* Is this sysctl sensitive to securelevels? */
@@ -1194,4 +1227,5 @@
 	/* Is this sysctl writable by only privileged users? */
 	if (req->newptr && !(oid->oid_kind & CTLFLAG_ANYBODY)) {
+#if 0 //ignore
 		int flags;
 
@@ -1203,4 +1237,5 @@
 		if (error)
 			return (error);
+#endif
 	}
 
@@ -1225,4 +1260,8 @@
 	return (error);
 }
+
+static int
+userland_sysctl(struct thread *td, int *name, u_int namelen, void *old,
+    size_t *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval);
 
 #ifndef _SYS_SYSPROTO_H_
@@ -1237,8 +1276,9 @@
 #endif
 
+#if 0 /* see bottom */
 /*
  * MPSAFE
  */
-int
+static int
 __sysctl(struct thread *td, struct sysctl_args *uap)
 {
@@ -1269,4 +1309,5 @@
 	return (error);
 }
+#endif
 
 /*
@@ -1274,5 +1315,5 @@
  * must be in kernel space.
  */
-int
+static int
 userland_sysctl(struct thread *td, int *name, u_int namelen, void *old,
     size_t *oldlenp, int inkernel, void *new, size_t newlen, size_t *retval)
@@ -1297,12 +1338,12 @@
 
 	if (old) {
-		if (!useracc(old, req.oldlen, VM_PROT_WRITE))
-			return (EFAULT);
+		//if (!useracc(old, req.oldlen, VM_PROT_WRITE))
+		//	return (EFAULT);
 		req.oldptr= old;
 	}
 
 	if (new != NULL) {
-		if (!useracc(new, req.newlen, VM_PROT_READ))
-			return (EFAULT);
+		//if (!useracc(new, req.newlen, VM_PROT_READ))
+		//	return (EFAULT);
 		req.newlen = newlen;
 		req.newptr = new;
@@ -1321,6 +1362,6 @@
 	} while (error == EAGAIN);
 
-	if (req.lock == REQ_WIRED && req.validlen > 0)
-		vsunlock(req.oldptr, req.validlen);
+	//if (req.lock == REQ_WIRED && req.validlen > 0)
+	//	vsunlock(req.oldptr, req.validlen);
 
 	SYSCTL_UNLOCK();
@@ -1554,2 +1595,54 @@
 }
 #endif /* COMPAT_43 */
+
+
+/**
+ * BSD like sysctl interface.
+ *
+ * This does not support half of the objects and operations as the real thing,
+ * but it's enough to get around bothersome patching elsewhere.
+ *
+ */
+int _STD(sysctl)(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen)
+{
+    int     error;
+    size_t  j;
+
+    /*
+     * Lazy init
+     */
+    static _smutex  smtx;
+    static int      fInitialized = 0;
+    _smutex_request(&smtx);
+    if (!fInitialized)
+    {
+        sysctl_register_all(NULL);
+        fInitialized = 1;
+    }
+    _smutex_release(&smtx);
+
+    /*
+     * Validate input.
+     */
+    if (namelen > CTL_MAXNAME || namelen < 2)
+        return (EINVAL);
+
+    /*
+     * Do work.
+     */
+    error = userland_sysctl((struct thread *)(void *)&userland_sysctl, name, namelen, oldp, oldlenp, 0, newp, newlen, &j);
+
+    /*
+     * Handle the result.
+     */
+    if (error && error != ENOMEM) /* (ENOMEM is used for buffer size conditions). */
+        ;
+    else if (oldlenp)
+        *oldlenp = j;
+    if (!error)
+        return 0;
+    errno = error;
+    return -1;
+
+}
+
Index: /trunk/src/emx/src/lib/misc/sysctl_mib.c
===================================================================
--- /trunk/src/emx/src/lib/misc/sysctl_mib.c	(revision 1916)
+++ /trunk/src/emx/src/lib/misc/sysctl_mib.c	(revision 1917)
@@ -36,19 +36,17 @@
  */
 
+#include "libc-alias.h"
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/sys/kern/kern_mib.c,v 1.71 2004/04/05 21:03:34 imp Exp $");
-
-#include "opt_posix.h"
+//__FBSDID("$FreeBSD: src/sys/kern/kern_mib.c,v 1.71 2004/04/05 21:03:34 imp Exp $");
+
+//#include "opt_posix.h"
 
 #include <sys/param.h>
-#include <sys/kernel.h>
-#include <sys/systm.h>
+#include <sys/unistd.h>
+#define _KERNEL
 #include <sys/sysctl.h>
-#include <sys/proc.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/jail.h>
-#include <sys/smp.h>
-#include <sys/unistd.h>
+
+
+asm (".stabs  \"___sysctl_set__\", 21, 0, 0, 0xffffffff\n");
 
 SYSCTL_NODE(, 0,	  sysctl, CTLFLAG_RW, 0,
@@ -77,5 +75,5 @@
 SYSCTL_NODE(, OID_AUTO,  compat, CTLFLAG_RW, 0,
 	"Compatibility code");
-SYSCTL_NODE(, OID_AUTO, security, CTLFLAG_RW, 0, 
+SYSCTL_NODE(, OID_AUTO, security, CTLFLAG_RW, 0,
      	"Security");
 #ifdef REGRESSION
@@ -84,18 +82,18 @@
 #endif
 
-SYSCTL_STRING(_kern, OID_AUTO, ident, CTLFLAG_RD,
-    kern_ident, 0, "Kernel identifier");
-
-SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease, CTLFLAG_RD,
-    osrelease, 0, "Operating system release");
-
-SYSCTL_INT(_kern, KERN_OSREV, osrevision, CTLFLAG_RD,
-    0, BSD, "Operating system revision");
-
-SYSCTL_STRING(_kern, KERN_VERSION, version, CTLFLAG_RD,
-    version, 0, "Kernel version");
-
-SYSCTL_STRING(_kern, KERN_OSTYPE, ostype, CTLFLAG_RD,
-    ostype, 0, "Operating system type");
+//SYSCTL_STRING(_kern, OID_AUTO, ident, CTLFLAG_RD,
+//    kern_ident, 0, "Kernel identifier");
+
+//SYSCTL_STRING(_kern, KERN_OSRELEASE, osrelease, CTLFLAG_RD,
+//    osrelease, 0, "Operating system release");
+
+//SYSCTL_INT(_kern, KERN_OSREV, osrevision, CTLFLAG_RD,
+//    0, BSD, "Operating system revision");
+
+//SYSCTL_STRING(_kern, KERN_VERSION, version, CTLFLAG_RD,
+//    version, 0, "Kernel version");
+
+//SYSCTL_STRING(_kern, KERN_OSTYPE, ostype, CTLFLAG_RD,
+//    ostype, 0, "Operating system type");
 
 /*
@@ -103,16 +101,16 @@
  * /usr/include/osreldate.h
  */
-extern int osreldate;
-SYSCTL_INT(_kern, KERN_OSRELDATE, osreldate, CTLFLAG_RD,
-    &osreldate, 0, "Kernel release date");
-
-SYSCTL_INT(_kern, KERN_MAXPROC, maxproc, CTLFLAG_RDTUN,
-    &maxproc, 0, "Maximum number of processes");
-
-SYSCTL_INT(_kern, KERN_MAXPROCPERUID, maxprocperuid, CTLFLAG_RW,
-    &maxprocperuid, 0, "Maximum processes allowed per userid");
-
-SYSCTL_INT(_kern, OID_AUTO, maxusers, CTLFLAG_RDTUN,
-    &maxusers, 0, "Hint for kernel tuning");
+//extern int osreldate;
+//SYSCTL_INT(_kern, KERN_OSRELDATE, osreldate, CTLFLAG_RD,
+//    &osreldate, 0, "Kernel release date");
+
+//SYSCTL_INT(_kern, KERN_MAXPROC, maxproc, CTLFLAG_RDTUN,
+//    &maxproc, 0, "Maximum number of processes");
+
+//SYSCTL_INT(_kern, KERN_MAXPROCPERUID, maxprocperuid, CTLFLAG_RW,
+//    &maxprocperuid, 0, "Maximum processes allowed per userid");
+
+//SYSCTL_INT(_kern, OID_AUTO, maxusers, CTLFLAG_RDTUN,
+//    &maxusers, 0, "Hint for kernel tuning");
 
 SYSCTL_INT(_kern, KERN_ARGMAX, argmax, CTLFLAG_RD,
@@ -136,8 +134,8 @@
 #endif
 
-char kernelname[MAXPATHLEN] = "/kernel";	/* XXX bloat */
-
-SYSCTL_STRING(_kern, KERN_BOOTFILE, bootfile, CTLFLAG_RW,
-    kernelname, sizeof kernelname, "Name of kernel file booted");
+//char kernelname[MAXPATHLEN] = "/kernel";	/* XXX bloat */
+//
+//SYSCTL_STRING(_kern, KERN_BOOTFILE, bootfile, CTLFLAG_RW,
+//    kernelname, sizeof kernelname, "Name of kernel file booted");
 
 #ifdef SMP
@@ -155,4 +153,5 @@
     0, PAGE_SIZE, "System memory page size");
 
+#if 0
 static int
 sysctl_hw_physmem(SYSCTL_HANDLER_ARGS)
@@ -178,11 +177,13 @@
 SYSCTL_PROC(_hw, HW_USERMEM, usermem, CTLTYPE_ULONG | CTLFLAG_RD,
 	0, 0, sysctl_hw_usermem, "LU", "");
-
-SYSCTL_ULONG(_hw, OID_AUTO, availpages, CTLFLAG_RD, &physmem, 0, "");
-
-static char	machine_arch[] = MACHINE_ARCH;
-SYSCTL_STRING(_hw, HW_MACHINE_ARCH, machine_arch, CTLFLAG_RD,
-    machine_arch, 0, "System architecture");
-
+#endif
+
+//SYSCTL_ULONG(_hw, OID_AUTO, availpages, CTLFLAG_RD, &physmem, 0, "");
+
+//static char	machine_arch[] = MACHINE_ARCH;
+//SYSCTL_STRING(_hw, HW_MACHINE_ARCH, machine_arch, CTLFLAG_RD,
+//    machine_arch, 0, "System architecture");
+
+#if 0
 char hostname[MAXHOSTNAMELEN];
 
@@ -228,5 +229,7 @@
        CTLTYPE_STRING|CTLFLAG_RW|CTLFLAG_PRISON,
        0, 0, sysctl_hostname, "A", "Hostname");
-
+#endif /* no hostname stuff yet. */
+
+#if 0/* no stuff of this kind either. */
 static int	regression_securelevel_nonmonotonic = 0;
 
@@ -299,4 +302,5 @@
 u_long hostid;
 SYSCTL_ULONG(_kern, KERN_HOSTID, hostid, CTLFLAG_RW, &hostid, 0, "Host ID");
+#endif /* no stuff of this kind either. */
 
 /*
@@ -346,4 +350,5 @@
     0, 0, "Min Maximum number of types supported for timezone names");
 
+#if 0 /* no sizes and stuff */
 #include <sys/vnode.h>
 SYSCTL_INT(_debug_sizeof, OID_AUTO, vnode, CTLFLAG_RD,
@@ -374,2 +379,5 @@
     &__elfN(fallback_brand), sizeof(__elfN(fallback_brand)),
     "compatibility for kern.fallback_elf_brand");
+
+#endif /* no sizes and stuff */
+
