0.24.0 --- openkal 0.23: a region at an address, MAP_FIXED_NOREPLACE; a name with every link followed, O_PATH and /proc/self/fd

Co-authored-by: speak-agent <248744407+speak-agent@users.noreply.github.com>

Author: Sunrisepeak

README.md

@@ -5,10 +5,10 @@ for Linux, written on the kernel's own system-call interface.
 
 ```toml
 [dependencies]
-openkal = "0.22.0"
+openkal = "0.23.0"
 
 [target.'cfg(os = "linux")'.dependencies]
-openkal-linux = "0.23.0"
+openkal-linux = "0.24.0"
 ```
 
 ## Why it does not use a C library
@@ -102,6 +102,13 @@ A program that carries a runtime of its own answers from that runtime instead
 (`pthread_getattr_np`), because in that arrangement the runtime is what owns the
 stacks and is what a program above openkal would ask for itself.
 
+## What 0.24 adds (openkal 0.23)
+
+**A region at an address.** `kal_exec_alloc_at` maps the region with
+`MAP_FIXED_NOREPLACE`, which refuses rather than replaces what is there; a kernel
+before 4.17 reads the flag as a hint, so a mapping placed elsewhere is released
+and the request refused. `KAL_EXEC_PROP_PLACE` is claimed.
+
 ## What 0.23 adds (openkal 0.22)
 
 **The null device at a position.** `KAL_SPAWN_NULL_IN`, `KAL_SPAWN_NULL_OUT` and

mcpp.toml

@@ -1,7 +1,7 @@
 [package]
 namespace   = "mcpplibs"
 name        = "openkal-linux"
-version     = "0.23.0"
+version     = "0.24.0"
 description = "The reference implementation of openkal for Linux, written on the kernel's own system-call interface so that it can be placed beneath a C library as well as above one."
 license     = "Apache-2.0"
 
@@ -65,7 +65,7 @@ provides-interfaces = [
 ]
 
 [dependencies]
-openkal = "0.22.0"
+openkal = "0.23.0"
 
 # The package contributes definitions and no modules. The interface it
 # implements is declared by the specification package, which this package

src/exec.cpp

@@ -51,6 +51,26 @@ void* kal_exec_alloc(kal_uintptr size) {
     return reinterpret_cast<void*>(r);
 }
 
+// AT AN ADDRESS (0.23): MAP_FIXED_NOREPLACE, which refuses rather than replaces
+// what is there. A kernel before 4.17 does not know the flag and reads the
+// address as a hint, so the answer is compared and a mapping placed elsewhere
+// released: the address is either given or refused, never approximated.
+void* kal_exec_alloc_at(void* at, kal_uintptr size) {
+    const okl_uptr where = reinterpret_cast<okl_uptr>(at);
+    if (size == 0 || where == 0 || (where & (page() - 1)) != 0) return nullptr;
+    const okl_uptr bytes = round_up(static_cast<okl_uptr>(size), page());
+    const okl_long r = okl::sys(okl::nr_mmap, static_cast<okl_long>(where), static_cast<okl_long>(bytes),
+                                okl::prot_read | okl::prot_write,
+                                okl::map_private | okl::map_anonymous | 0x100000 /* MAP_FIXED_NOREPLACE */,
+                                -1, 0);
+    if (okl::failed(r)) return nullptr;
+    if (static_cast<okl_uptr>(r) != where) {
+        okl::sys(okl::nr_munmap, r, static_cast<okl_long>(bytes));
+        return nullptr;
+    }
+    return at;
+}
+
 int kal_exec_publish(void* p, kal_uintptr size) {
     if (p == nullptr || size == 0) return kal_err_invalid;
     const okl_uptr bytes = round_up(static_cast<okl_uptr>(size), page());
@@ -163,7 +183,7 @@ void kal_exec_free(void* p, kal_uintptr size) {
 kal_uintptr kal_exec_props(void) {
     // Executable memory is available to every artifact on this kernel: nothing
     // here is granted only to a program produced in a particular way.
-    return KAL_EXEC_PROP_REPUBLISH | KAL_EXEC_PROP_AVAILABLE | KAL_EXEC_PROP_FILE;
+    return KAL_EXEC_PROP_REPUBLISH | KAL_EXEC_PROP_AVAILABLE | KAL_EXEC_PROP_FILE | KAL_EXEC_PROP_PLACE;
 }
 
 }  // extern "C"

src/fs.cpp

@@ -825,8 +825,24 @@ int kal_fs_list_next(kal_dir d, kal_uintptr* iter,
 // filesystem it mounts, and `renameat' within one directory is atomic by POSIX.
 // Case sensitivity and links are claimed only where the format is known to have
 // them.
+// WHETHER THE KERNEL NAMES A DESCRIPTOR (/proc/self/fd), which a name with
+// every link followed is read from (0.23). Asked once: /proc is mounted for the
+// process or it is not, whatever the volume.
+static bool descriptor_names() {
+    static int known = -1;
+    if (known < 0) {
+        char b[8];
+        known = okl::failed(okl::sys(okl::nr_readlinkat, okl::at_fdcwd,
+                                     reinterpret_cast<okl_long>("/proc/self/cwd"),
+                                     reinterpret_cast<okl_long>(b), static_cast<okl_long>(sizeof b))) ? 0 : 1;
+    }
+    return known == 1;
+}
+
 kal_uintptr kal_fs_props(kal_dir d) {
-    return volume_props(okl::unpack(d.h));
+    const int fd = okl::unpack(d.h);
+    if (fd < 0) return 0;
+    return volume_props(fd) | (descriptor_names() ? KAL_FS_PROP_RESOLVED_NAME : 0u);
 }
 
 // --- exclusion upon a range of a file --------------------------------------
@@ -938,6 +954,39 @@ int kal_fs_link_create(kal_dir base, const char* name, kal_uintptr len,
     return okl::failed(r) ? okl::translate(r) : kal_ok;
 }
 
+// THE NAME WITH EVERY LINK FOLLOWED (0.23): the node opened for its path alone
+// (O_PATH, which needs no permission upon it and follows every link), and the
+// kernel's record of that descriptor's name read, as this system's own C
+// library answers `realpath' of an open file. Two calls and a close, where a
+// walk asks about every component of the name.
+kal_intptr kal_fs_resolved_name(kal_dir base, const char* name, kal_uintptr len,
+                                char* out, kal_uintptr cap) {
+    const int b = okl::unpack(base.h);
+    if (b < 0 || !okl::acceptable(name, len)) return -kal_err_invalid;
+    if (!descriptor_names()) return -kal_err_not_supported;
+    okl::terminated t(name, len); if (!t.ok) return -kal_err_invalid;
+    const okl_long fd = okl::sys(okl::nr_openat, b, reinterpret_cast<okl_long>(t.buf),
+                                 okl::o_path | okl::o_cloexec, 0);
+    if (okl::failed(fd)) return -okl::translate(fd);
+    char link[32] = "/proc/self/fd/";
+    {
+        okl_uptr at = 14;
+        char digits[20]; int n = 0;
+        okl_ulong v = static_cast<okl_ulong>(fd);
+        do { digits[n++] = static_cast<char>('0' + v % 10); v /= 10; } while (v);
+        while (n) link[at++] = digits[--n];
+        link[at] = '\0';
+    }
+    char own[2 * okl::max_name + 2];
+    const okl_long r = okl::sys(okl::nr_readlinkat, okl::at_fdcwd, reinterpret_cast<okl_long>(link),
+                                reinterpret_cast<okl_long>(own), static_cast<okl_long>(sizeof own));
+    okl::sys(okl::nr_close, fd);
+    if (okl::failed(r)) return -okl::translate(r);
+    if (out != nullptr)
+        for (okl_long i = 0; i < r && static_cast<okl_uptr>(i) < cap; ++i) out[i] = own[i];
+    return static_cast<kal_intptr>(r);
+}
+
 kal_intptr kal_fs_link_read(kal_dir base, const char* name, kal_uintptr len,
                             char* out, kal_uintptr cap) {
     const int b = okl::unpack(base.h);