feat: added new but unfinished tty object to ksurface

cr4zyengineer · cr4zyengineer · commit edb70eddeb66 · 2026-02-24T11:42:35.000+01:00
diff --git a/Config.xcconfig b/Config.xcconfig
@@ -9,4 +9,4 @@
 // https://developer.apple.com/documentation/xcode/adding-a-build-configuration-file-to-your-project
 
 VERSION = 0.9.0
-BUILD_NUMBER = 20260224.75.US.seanistethered
+BUILD_NUMBER = 20260224.76.US.seanistethered
diff --git a/Nyxian.xcodeproj/project.pbxproj b/Nyxian.xcodeproj/project.pbxproj
@@ -223,7 +223,7 @@
 				LindChain/ProcEnvironment/Surface/proc/lookup.m,
 				LindChain/ProcEnvironment/Surface/proc/proc.m,
 				LindChain/ProcEnvironment/Surface/proc/remove.m,
-				LindChain/ProcEnvironment/Surface/radix/radix.m,
+				LindChain/ProcEnvironment/Surface/radix/radix.c,
 				LindChain/ProcEnvironment/Surface/surface.m,
 				LindChain/ProcEnvironment/Surface/sys/compat/bamset.m,
 				LindChain/ProcEnvironment/Surface/sys/compat/getent.m,
@@ -243,6 +243,8 @@
 				LindChain/ProcEnvironment/Surface/sys/proc/kill.m,
 				LindChain/ProcEnvironment/Surface/sys/proc/wait4.m,
 				LindChain/ProcEnvironment/Surface/sys/syscall.m,
+				LindChain/ProcEnvironment/Surface/tty/lookup.m,
+				LindChain/ProcEnvironment/Surface/tty/tty.m,
 				LindChain/ProcEnvironment/syscall.m,
 				LindChain/ProcEnvironment/Syscall/mach_syscall_client.m,
 				LindChain/ProcEnvironment/Syscall/mach_syscall_server.m,
diff --git a/Nyxian/LindChain/ProcEnvironment/Surface/lock.h b/Nyxian/LindChain/ProcEnvironment/Surface/lock.h
@@ -24,6 +24,10 @@
 #define proc_table_wrlock() pthread_rwlock_wrlock(&(ksurface->proc_info.struct_lock))
 #define proc_table_unlock() pthread_rwlock_unlock(&(ksurface->proc_info.struct_lock))
 
+#define tty_table_rdlock() pthread_rwlock_rdlock(&(ksurface->tty_info.struct_lock))
+#define tty_table_wrlock() pthread_rwlock_wrlock(&(ksurface->tty_info.struct_lock))
+#define tty_table_unlock() pthread_rwlock_unlock(&(ksurface->tty_info.struct_lock))
+
 #define host_rdlock() pthread_rwlock_rdlock(&(ksurface->host_info.struct_lock))
 #define host_wrlock() pthread_rwlock_wrlock(&(ksurface->host_info.struct_lock))
 #define host_unlock() pthread_rwlock_unlock(&(ksurface->host_info.struct_lock))
diff --git a/Nyxian/LindChain/ProcEnvironment/Surface/mapping.h b/Nyxian/LindChain/ProcEnvironment/Surface/mapping.h
@@ -91,6 +91,17 @@ typedef struct {
          */
         ksurface_proc_t *kern_proc;
     } proc_info;
+    
+    struct {
+        /* rwlock securing structures */
+        pthread_rwlock_t struct_lock;
+        
+        /*
+         * radix tree where all processes are
+         * listed inside.
+         */
+        radix_tree_t tty;
+    } tty_info;
 } ksurface_mapping_t;
 
 #endif /* PROCENVIRONMENT_MAPPING_H */
diff --git a/Nyxian/LindChain/ProcEnvironment/Surface/radix/radix.c b/Nyxian/LindChain/ProcEnvironment/Surface/radix/radix.c
@@ -24,15 +24,15 @@
 #include <stdlib.h>
 #include <stdbool.h>
 
-static inline int radix_chunk(pid_t pid,
+static inline int radix_chunk(uint64_t ident,
                               int level)
 {
     int shift = (RADIX_LEVELS - 1 - level) * RADIX_BITS;
-    return(pid >> shift) & RADIX_MASK;
+    return(ident >> shift) & RADIX_MASK;
 }
 
 void *radix_lookup(radix_tree_t *tree,
-                   pid_t pid)
+                   uint64_t ident)
 {
     radix_node_t *node = tree->root;
     
@@ -43,7 +43,7 @@ static inline int radix_chunk(pid_t pid,
             return NULL;
         }
         
-        int chunk = radix_chunk(pid, level);
+        int chunk = radix_chunk(ident, level);
         node = (radix_node_t *)node->slots[chunk];
     }
     
@@ -52,12 +52,12 @@ static inline int radix_chunk(pid_t pid,
         return NULL;
     }
     
-    int chunk = radix_chunk(pid, RADIX_LEVELS - 1);
+    int chunk = radix_chunk(ident, RADIX_LEVELS - 1);
     return node->slots[chunk];
 }
 
 int radix_insert(radix_tree_t *tree,
-                 pid_t pid,
+                 uint64_t ident,
                  void *value)
 {
     if(tree->root == NULL)
@@ -69,7 +69,7 @@ int radix_insert(radix_tree_t *tree,
     
     for(int level = 0; level < RADIX_LEVELS - 1; level++)
     {
-        int chunk = radix_chunk(pid, level);
+        int chunk = radix_chunk(ident, level);
         
         if(node->slots[chunk] == NULL)
         {
@@ -79,13 +79,14 @@ int radix_insert(radix_tree_t *tree,
         node = (radix_node_t *)node->slots[chunk];
     }
     
-    int chunk = radix_chunk(pid, RADIX_LEVELS - 1);
+    int chunk = radix_chunk(ident, RADIX_LEVELS - 1);
     node->slots[chunk] = value;
     
     return 0;
 }
 
-void *radix_remove(radix_tree_t *tree, pid_t pid)
+void *radix_remove(radix_tree_t *tree,
+                   uint64_t ident)
 {
     radix_node_t *node = tree->root;
     radix_node_t *path[RADIX_LEVELS];
@@ -99,7 +100,7 @@ int radix_insert(radix_tree_t *tree,
         }
         
         path[level] = node;
-        chunks[level] = radix_chunk(pid, level);
+        chunks[level] = radix_chunk(ident, level);
         
         if(level < RADIX_LEVELS - 1)
         {
@@ -137,7 +138,7 @@ int radix_insert(radix_tree_t *tree,
 
 static void radix_walk_node(radix_node_t *node,
                             int level,
-                            pid_t pid_prefix,
+                            uint64_t ident_prefix,
                             radix_walk_fn callback,
                             void *ctx)
 {
@@ -153,15 +154,15 @@ static void radix_walk_node(radix_node_t *node,
             continue;
         }
         
-        pid_t pid = pid_prefix | (i << ((RADIX_LEVELS - 1 - level) * RADIX_BITS));
+        uint64_t ident = ident_prefix | (i << ((RADIX_LEVELS - 1 - level) * RADIX_BITS));
         
         if(level == RADIX_LEVELS - 1)
         {
-            callback(pid, node->slots[i], ctx);
+            callback(ident_prefix, node->slots[i], ctx);
         }
         else
         {
-            radix_walk_node((radix_node_t *)node->slots[i], level + 1, pid, callback, ctx);
+            radix_walk_node((radix_node_t *)node->slots[i], level + 1, ident_prefix, callback, ctx);
         }
     }
 }
diff --git a/Nyxian/LindChain/ProcEnvironment/Surface/radix/radix.h b/Nyxian/LindChain/ProcEnvironment/Surface/radix/radix.h
@@ -23,11 +23,11 @@
 #import <LindChain/ProcEnvironment/Surface/radix/type/tree.h>
 #include <stdlib.h>
 
-typedef void (*radix_walk_fn)(pid_t pid, void *value, void *ctx);
+typedef void (*radix_walk_fn)(uint64_t ident, void *value, void *ctx);
 
-void *radix_lookup(radix_tree_t *tree, pid_t pid);
-int radix_insert(radix_tree_t *tree, pid_t pid, void *value);
-void *radix_remove(radix_tree_t *tree, pid_t pid);
+void *radix_lookup(radix_tree_t *tree, uint64_t ident);
+int radix_insert(radix_tree_t *tree, uint64_t ident, void *value);
+void *radix_remove(radix_tree_t *tree, uint64_t ident);
 void radix_walk(radix_tree_t *tree, radix_walk_fn callback, void *ctx);
 
 #endif /* RADIX_H */
diff --git a/Nyxian/LindChain/ProcEnvironment/Surface/tty/def.h b/Nyxian/LindChain/ProcEnvironment/Surface/tty/def.h
@@ -0,0 +1,40 @@
+/*
+ Copyright (C) 2025 cr4zyengineer
+
+ This file is part of Nyxian.
+
+ Nyxian is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Nyxian is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Nyxian. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef TTY_DEF_H
+#define TTY_DEF_H
+
+#import <LindChain/ProcEnvironment/Surface/obj/kvobject.h>
+#import <LindChain/ProcEnvironment/Surface/proc/def.h>
+#import <limits.h>
+#include    <unistd.h>
+
+typedef struct ksurface_tty ksurface_tty_t;
+
+struct ksurface_tty {
+    /* object header */
+    kvobject_t header;
+    
+    /* file descriptors */
+    int masterfd;
+    int slavefd;
+    uint64_t slavehandle;
+};
+
+#endif /* TTY_DEF_H */
diff --git a/Nyxian/LindChain/ProcEnvironment/Surface/tty/lookup.h b/Nyxian/LindChain/ProcEnvironment/Surface/tty/lookup.h
@@ -0,0 +1,27 @@
+/*
+ Copyright (C) 2025 cr4zyengineer
+
+ This file is part of Nyxian.
+
+ Nyxian is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Nyxian is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Nyxian. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef TTY_LOOKUP_H
+#define TTY_LOOKUP_H
+
+#import <LindChain/ProcEnvironment/Surface/tty/def.h>
+
+ksurface_return_t tty_for_handle(uint64_t handle, ksurface_tty_t **tty);
+
+#endif /* TTY_LOOKUP_H */
diff --git a/Nyxian/LindChain/ProcEnvironment/Surface/tty/lookup.m b/Nyxian/LindChain/ProcEnvironment/Surface/tty/lookup.m
@@ -0,0 +1,49 @@
+/*
+ Copyright (C) 2025 cr4zyengineer
+
+ This file is part of Nyxian.
+
+ Nyxian is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Nyxian is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Nyxian. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#import <LindChain/ProcEnvironment/Surface/surface.h>
+#import <LindChain/ProcEnvironment/Surface/tty/lookup.h>
+
+ksurface_return_t tty_for_handle(uint64_t handle,
+                                 ksurface_tty_t **tty)
+{
+    /* sanity check */
+    if(tty == NULL)
+    {
+        return SURFACE_NULLPTR;
+    }
+    
+    /* tty lookup */
+    tty_table_rdlock();
+    *tty = radix_lookup(&(ksurface->tty_info.tty), handle);
+    tty_table_unlock();
+    
+    /*
+     * caller expects retained tty object, so
+     * attempting to retain it and if it doesnt work
+     * returning with an error.
+     */
+    if(*tty == NULL ||
+       !kvo_retain(*tty))
+    {
+        return SURFACE_RETAIN_FAILED;
+    }
+    
+    return SURFACE_SUCCESS;
+}
diff --git a/Nyxian/LindChain/ProcEnvironment/Surface/tty/tty.h b/Nyxian/LindChain/ProcEnvironment/Surface/tty/tty.h
@@ -0,0 +1,28 @@
+/*
+ Copyright (C) 2025 cr4zyengineer
+
+ This file is part of Nyxian.
+
+ Nyxian is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Nyxian is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Nyxian. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifndef TTY_TTY_H
+#define TTY_TTY_H
+
+#import <LindChain/ProcEnvironment/Surface/surface.h>
+#import <LindChain/ProcEnvironment/Surface/tty/def.h>
+
+DEFINE_KVOBJECT_MAIN_EVENT_HANDLER(tty);
+
+#endif /* TTY_TTY_H */
diff --git a/Nyxian/LindChain/ProcEnvironment/Surface/tty/tty.m b/Nyxian/LindChain/ProcEnvironment/Surface/tty/tty.m

Original file line number	Diff line number	Diff line change
`@@ -24,15 +24,15 @@`
`24`	`24`	`#include <stdlib.h>`
`25`	`25`	`#include <stdbool.h>`
`26`	`26`
`27`		`-static inline int radix_chunk(pid_t pid,`
	`27`	`+static inline int radix_chunk(uint64_t ident,`
`28`	`28`	`int level)`
`29`	`29`	`{`
`30`	`30`	`int shift = (RADIX_LEVELS - 1 - level) * RADIX_BITS;`
`31`		`- return(pid >> shift) & RADIX_MASK;`
	`31`	`+ return(ident >> shift) & RADIX_MASK;`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`void radix_lookup(radix_tree_t tree,`
`35`		`- pid_t pid)`
	`35`	`+ uint64_t ident)`
`36`	`36`	`{`
`37`	`37`	`radix_node_t *node = tree->root;`
`38`	`38`
`@@ -43,7 +43,7 @@ static inline int radix_chunk(pid_t pid,`
`43`	`43`	`return NULL;`
`44`	`44`	`}`
`45`	`45`
`46`		`- int chunk = radix_chunk(pid, level);`
	`46`	`+ int chunk = radix_chunk(ident, level);`
`47`	`47`	`node = (radix_node_t *)node->slots[chunk];`
`48`	`48`	`}`
`49`	`49`
`@@ -52,12 +52,12 @@ static inline int radix_chunk(pid_t pid,`
`52`	`52`	`return NULL;`
`53`	`53`	`}`
`54`	`54`
`55`		`- int chunk = radix_chunk(pid, RADIX_LEVELS - 1);`
	`55`	`+ int chunk = radix_chunk(ident, RADIX_LEVELS - 1);`
`56`	`56`	`return node->slots[chunk];`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`int radix_insert(radix_tree_t *tree,`
`60`		`- pid_t pid,`
	`60`	`+ uint64_t ident,`
`61`	`61`	`void *value)`
`62`	`62`	`{`
`63`	`63`	`if(tree->root == NULL)`
`@@ -69,7 +69,7 @@ int radix_insert(radix_tree_t *tree,`
`69`	`69`
`70`	`70`	`for(int level = 0; level < RADIX_LEVELS - 1; level++)`
`71`	`71`	`{`
`72`		`- int chunk = radix_chunk(pid, level);`
	`72`	`+ int chunk = radix_chunk(ident, level);`
`73`	`73`
`74`	`74`	`if(node->slots[chunk] == NULL)`
`75`	`75`	`{`
`@@ -79,13 +79,14 @@ int radix_insert(radix_tree_t *tree,`
`79`	`79`	`node = (radix_node_t *)node->slots[chunk];`
`80`	`80`	`}`
`81`	`81`
`82`		`- int chunk = radix_chunk(pid, RADIX_LEVELS - 1);`
	`82`	`+ int chunk = radix_chunk(ident, RADIX_LEVELS - 1);`
`83`	`83`	`node->slots[chunk] = value;`
`84`	`84`
`85`	`85`	`return 0;`
`86`	`86`	`}`
`87`	`87`
`88`		`-void radix_remove(radix_tree_t tree, pid_t pid)`
	`88`	`+void radix_remove(radix_tree_t tree,`
	`89`	`+ uint64_t ident)`
`89`	`90`	`{`
`90`	`91`	`radix_node_t *node = tree->root;`
`91`	`92`	`radix_node_t *path[RADIX_LEVELS];`
`@@ -99,7 +100,7 @@ int radix_insert(radix_tree_t *tree,`
`99`	`100`	`}`
`100`	`101`
`101`	`102`	`path[level] = node;`
`102`		`- chunks[level] = radix_chunk(pid, level);`
	`103`	`+ chunks[level] = radix_chunk(ident, level);`
`103`	`104`
`104`	`105`	`if(level < RADIX_LEVELS - 1)`
`105`	`106`	`{`
`@@ -137,7 +138,7 @@ int radix_insert(radix_tree_t *tree,`
`137`	`138`
`138`	`139`	`static void radix_walk_node(radix_node_t *node,`
`139`	`140`	`int level,`
`140`		`- pid_t pid_prefix,`
	`141`	`+ uint64_t ident_prefix,`
`141`	`142`	`radix_walk_fn callback,`
`142`	`143`	`void *ctx)`
`143`	`144`	`{`
`@@ -153,15 +154,15 @@ static void radix_walk_node(radix_node_t *node,`
`153`	`154`	`continue;`
`154`	`155`	`}`
`155`	`156`
`156`		`- pid_t pid = pid_prefix \| (i << ((RADIX_LEVELS - 1 - level) * RADIX_BITS));`
	`157`	`+ uint64_t ident = ident_prefix \| (i << ((RADIX_LEVELS - 1 - level) * RADIX_BITS));`
`157`	`158`
`158`	`159`	`if(level == RADIX_LEVELS - 1)`
`159`	`160`	`{`
`160`		`- callback(pid, node->slots[i], ctx);`
	`161`	`+ callback(ident_prefix, node->slots[i], ctx);`
`161`	`162`	`}`
`162`	`163`	`else`
`163`	`164`	`{`
`164`		`- radix_walk_node((radix_node_t *)node->slots[i], level + 1, pid, callback, ctx);`
	`165`	`+ radix_walk_node((radix_node_t *)node->slots[i], level + 1, ident_prefix, callback, ctx);`
`165`	`166`	`}`
`166`	`167`	`}`
`167`	`168`	`}`