shm stuff, a lot of bug fixs, recvmsg() sendmsg() xfwm4 and xfce4-panel compiled trying to get working xfce4, starting to implementing syscalls

89 files changed, 3976 insertions, 479 deletions

diff --git a/build-pkg.sh b/build-pkg.sh
index 8b43a5d..0709603 100644
--- a/build-pkg.sh
+++ b/build-pkg.sh
@@ -7,7 +7,7 @@ export PKG_CONFIG_SYSROOT_DIR="$sysroot_path"
 export PKG_CONFIG_PATH="$sysroot_path/usr/lib/pkgconfig:$sysroot_path/usr/share/pkgconfig:$sysroot_path/usr/local/lib/pkgconfig:$sysroot_path/usr/local/share/pkgconfig:$HOME/opt/cross/orange/lib/pkgconfig:$HOME/opt/cross/orange/share/pkgconfig"
 INITRDDIR=""$(realpath initrd)""
 
-export CFLAGS="-fPIC -Wno-error -O0 -Wno-incompatible-pointer-types -fno-omit-frame-pointer -ggdb3 -fno-inline-functions-called-once -fno-optimize-sibling-calls  -fno-omit-frame-pointer"
+export CFLAGS="-fPIC -Wno-error -O2 -Wno-int-conversion -Wno-incompatible-pointer-types  -Wno-implicit-function-declaration -fno-omit-frame-pointer -ggdb3 -fno-inline-functions-called-once -fno-optimize-sibling-calls  -fno-omit-frame-pointer"
 export CXXFLAGS="$CFLAGS"
 
 cd tools/pkg/$1 
diff --git a/kernel/GNUmakefile b/kernel/GNUmakefile
index 36c6534..c5bda9c 100644
--- a/kernel/GNUmakefile
+++ b/kernel/GNUmakefile
@@ -19,7 +19,7 @@ CXX := c++
 LD := ld
 
 # User controllable C flags.
-CFLAGS := -g -pipe -Iinclude -Isrc/lib/Flanterm/src -Isrc/lib/uACPI/include -O3 -fno-omit-frame-pointer -ggdb3 -fno-inline-functions-called-once -fno-optimize-sibling-calls  -fno-omit-frame-pointer
+CFLAGS := -g -pipe -Iinclude -Isrc/lib/Flanterm/src -Wno-shift-count-overflow -Wno-unused-but-set-variable -fno-permissive -Wno-unused-label -Wno-misleading-indentation -Wno-unused-parameter -Wno-type-limits -Wno-return-type -Wno-cast-function-type -Wno-int-to-pointer-cast -Wno-delete-incomplete -Wno-unused-variable -Wno-stringop-overflow -Wno-sign-compare -Wno-maybe-uninitialized -Wno-write-strings -Isrc/lib/uACPI/include -O3 -fno-omit-frame-pointer -ggdb3 -fno-inline-functions-called-once -fno-optimize-sibling-calls  -fno-omit-frame-pointer
 
 # User controllable C++ flags. We default to same as C flags.
 CXXFLAGS := $(CFLAGS)
diff --git a/kernel/include/arch/x86_64/scheduling.hpp b/kernel/include/arch/x86_64/scheduling.hpp
index f9e0e36..9c0310d 100644
--- a/kernel/include/arch/x86_64/scheduling.hpp
+++ b/kernel/include/arch/x86_64/scheduling.hpp
@@ -135,16 +135,23 @@ namespace arch {
             locks::spinlock lock;
             locks::spinlock kill_lock; /* Never should be setup by not kill() function */
 
+            locks::spinlock _3rd_kill_lock;
             locks::spinlock futex_lock;
 
-            std::uint32_t fd_ptr;
+            locks::spinlock fd_lock;
+
+            std::uint32_t alloc_fd;
+            std::uint32_t* fd_ptr;
+
+            int is_shared_fd;
 
             std::uint32_t reversedforid;
             std::uint32_t* vmm_id;
 
             userspace_fd_t* fd_pool;
+            vfs::passingfd_manager* pass_fd;
 
-            userspace_fd_t* fd;
+            void* fd;
 
             char* vmm_start;
             char* vmm_end;
@@ -157,6 +164,8 @@ namespace arch {
 
             int prio;
 
+            std::uint64_t ts;
+
             int exit_code;
             int is_cloned;
             std::uint64_t* original_cr3_pointer;
@@ -170,6 +179,8 @@ namespace arch {
 
             std::uint32_t parent_id;
 
+            int uid;
+
             int debug0;
             int debug1;
 
@@ -191,10 +202,11 @@ namespace arch {
             static process_t* create();
             static process_t* fork(process_t* proc,int_frame_t* ctx);
             static process_t* clone(process_t* proc,int_frame_t* ctx);
+            static process_t* by_pid(int pid);
             static void kill(process_t* proc);
             static void wakeup(process_t* proc);
-            static void futexwake(process_t* proc, int* lock);
-            static void futexwait(process_t* proc, int* lock, int val, int* original_lock);
+            static int futexwake(process_t* proc, int* lock);
+            static void futexwait(process_t* proc, int* lock, int val, int* original_lock, std::uint64_t ts);
             static int loadelf(process_t* proc,char* path,char** argv,char** envp,int free_mem);
             static process_t* head_proc_();
 
diff --git a/kernel/include/arch/x86_64/syscalls/shm.hpp b/kernel/include/arch/x86_64/syscalls/shm.hpp
new file mode 100644
index 0000000..af7bc7f
--- /dev/null
+++ b/kernel/include/arch/x86_64/syscalls/shm.hpp
@@ -0,0 +1,42 @@
+
+#include <cstdint>
+
+typedef long time_t;
+typedef unsigned short ushort;
+
+#define IPC_RMID 0
+#define IPC_SET 1
+#define IPC_STAT 2
+#define IPC_INFO 3
+
+struct ipc_perm {
+    std::uint32_t  key; 
+    ushort uid;   
+    ushort gid; 
+    ushort cuid;  
+    ushort cgid; 
+    ushort mode; 
+    ushort seq;   
+};
+
+
+struct shmid_ds {
+    struct ipc_perm shm_perm;   
+    int             shm_segsz;  
+    time_t          shm_atime;  
+    time_t          shm_dtime;
+    time_t          shm_ctime;   
+    unsigned short  shm_cpid;  
+    unsigned short  shm_lpid;   
+    short           shm_nattch;  
+};
+
+typedef struct shm_seg {
+    std::uint32_t key;
+    std::uint32_t id;
+    std::uint64_t phys;
+    std::uint64_t len;
+    int is_pending_rm;
+    struct shmid_ds ctl;
+    struct shm_seg* next;
+} shm_seg_t;
\ No newline at end of file
diff --git a/kernel/include/arch/x86_64/syscalls/sockets.hpp b/kernel/include/arch/x86_64/syscalls/sockets.hpp
index 8124b9a..17f6b4c 100644
--- a/kernel/include/arch/x86_64/syscalls/sockets.hpp
+++ b/kernel/include/arch/x86_64/syscalls/sockets.hpp
@@ -135,6 +135,7 @@ public:
 
 typedef struct socket_node {
 	char path[128];
+	uint64_t vars[8];
 	char is_used;
 	uint64_t socket_counter;
 	socket_pending_obj_t* pending_list;
diff --git a/kernel/include/arch/x86_64/syscalls/syscalls.hpp b/kernel/include/arch/x86_64/syscalls/syscalls.hpp
index 227c463..00c2c21 100644
--- a/kernel/include/arch/x86_64/syscalls/syscalls.hpp
+++ b/kernel/include/arch/x86_64/syscalls/syscalls.hpp
@@ -128,7 +128,7 @@ syscall_ret_t sys_write(int fd, const void *buf, size_t count);
 syscall_ret_t sys_read(int fd, void *buf, size_t count);
 syscall_ret_t sys_seek(int fd, long offset, int whence);
 syscall_ret_t sys_dup2(int fd, int flags, int newfd);
-syscall_ret_t sys_stat(int fd, void* out, int flags);
+syscall_ret_t sys_stat(int fd, void* out, int flags, int_frame_t* ctx);
 syscall_ret_t sys_dup(int fd, int flags);
 syscall_ret_t sys_pipe(int flags);
 syscall_ret_t sys_close(int fd);
@@ -159,6 +159,8 @@ syscall_ret_t sys_chmod(char* path, int mode);
 syscall_ret_t sys_ttyname(int fd, char *buf, size_t size);
 syscall_ret_t sys_rename(char* old, char* newp);
 
+syscall_ret_t sys_eventfd_create(unsigned int initval, int flags);
+
 /* Process */
 syscall_ret_t sys_mmap(std::uint64_t hint, std::uint64_t size, int fd0, int_frame_t* ctx);
 syscall_ret_t sys_free(void *pointer, size_t size);
@@ -207,8 +209,13 @@ syscall_ret_t sys_enabledebugmodepid(int pid);
 
 syscall_ret_t sys_dmesg(char* buf,std::uint64_t count);
 
+syscall_ret_t sys_getuid();
+syscall_ret_t sys_setuid(int uid);
+
+syscall_ret_t sys_kill(int pid, int sig);
+
 /* Futex */
-syscall_ret_t sys_futex_wait(int* pointer, int excepted);
+syscall_ret_t sys_futex_wait(int* pointer, int excepted, struct timespec* ts);
 syscall_ret_t sys_futex_wake(int* pointer);
 
 /* Socket */
@@ -222,6 +229,23 @@ syscall_ret_t sys_listen(int fd, int backlog);
 
 syscall_ret_t sys_copymemory(void* src, void* dest, int len);
 
+syscall_ret_t sys_socketpair(int domain, int type_and_flags, int proto);
+syscall_ret_t sys_getsockname(int fd, struct sockaddr_un* path, int len);
+
+syscall_ret_t sys_getsockopt(int fd, int layer, int number, int_frame_t* ctx);
+
+syscall_ret_t sys_msg_recv(int fd, struct msghdr *hdr, int flags);
+syscall_ret_t sys_msg_send(int fd, struct msghdr* hdr, int flags);
+
+syscall_ret_t sys_shutdown(int sockfd, int how);
+
+/* Shm stuff */
+
+syscall_ret_t sys_shmctl(int shmid, int cmd, struct shmid_ds *buf);
+syscall_ret_t sys_shmat(int shmid, std::uint64_t hint, int shmflg);
+syscall_ret_t sys_shmget(int key, size_t size, int shmflg);
+syscall_ret_t sys_shmdt(std::uint64_t base);
+
 struct pollfd {
     int fd;          
     short events;   
diff --git a/kernel/include/drivers/cmos.hpp b/kernel/include/drivers/cmos.hpp
index 278fb06..049b43e 100644
--- a/kernel/include/drivers/cmos.hpp
+++ b/kernel/include/drivers/cmos.hpp
@@ -56,4 +56,44 @@ namespace drivers {
             return 2000 + bcd_to_binary(year); 
         }
     };
-};
\ No newline at end of file
+};
+
+inline bool isLeapYear(int year) {
+    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
+}
+
+inline int daysInMonth(int month, int year) {
+    int days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+    if (month == 2 && isLeapYear(year)) {
+        return 29; 
+    }
+    return days[month - 1];
+}
+
+inline static uint64_t getUnixTime() {
+    int year = drivers::cmos::year();
+    int month = drivers::cmos::month();
+    int day = drivers::cmos::day();
+    int hour = drivers::cmos::hour();
+    int minute = drivers::cmos::minute();
+    int second = drivers::cmos::second();
+
+    long long daysSinceEpoch = 0;
+    for (int y = 1970; y < year; ++y) {
+        daysSinceEpoch += isLeapYear(y) ? 366 : 365;
+    }
+
+    for (int m = 1; m < month; ++m) {
+        daysSinceEpoch += daysInMonth(m, year);
+    }
+
+    daysSinceEpoch += (day - 1);
+
+    long long secondsSinceEpoch = daysSinceEpoch * 86400;
+
+    secondsSinceEpoch += hour * 3600;
+    secondsSinceEpoch += minute * 60;
+    secondsSinceEpoch += second;
+
+    return secondsSinceEpoch;
+}
\ No newline at end of file
diff --git a/kernel/include/etc/errno.hpp b/kernel/include/etc/errno.hpp
index 17eb61b..23b1ed3 100644
--- a/kernel/include/etc/errno.hpp
+++ b/kernel/include/etc/errno.hpp
@@ -134,4 +134,32 @@
 #define EOWNERDEAD      130
 #define ENOTRECOVERABLE 131
 #define ERFKILL         132
-#define EHWPOISON       133
\ No newline at end of file
+#define EHWPOISON       133
+
+#define SIGHUP    1
+#define SIGQUIT   3
+#define SIGTRAP   5
+#define SIGIOT    SIGABRT
+#define SIGBUS    7
+#define SIGKILL   9
+#define SIGUSR1   10
+#define SIGUSR2   12
+#define SIGPIPE   13
+#define SIGALRM   14
+#define SIGSTKFLT 16
+#define SIGCHLD   17
+#define SIGCONT   18
+#define SIGSTOP   19
+#define SIGTSTP   20
+#define SIGTTIN   21
+#define SIGTTOU   22
+#define SIGURG    23
+#define SIGXCPU   24
+#define SIGXFSZ   25
+#define SIGVTALRM 26
+#define SIGWINCH  28
+#define SIGPOLL   29
+#define SIGSYS    31
+#define SIGUNUSED SIGSYS
+#define SIGCANCEL 32
+#define SIGTIMER  33
\ No newline at end of file
diff --git a/kernel/include/generic/mm/paging.hpp b/kernel/include/generic/mm/paging.hpp
index 175e61d..05049bf 100644
--- a/kernel/include/generic/mm/paging.hpp
+++ b/kernel/include/generic/mm/paging.hpp
@@ -35,6 +35,9 @@ namespace memory {
         static void map(std::uint64_t cr3,std::uint64_t phys,std::uint64_t virt,std::uint64_t flags);
         static void mapid(std::uint64_t cr3,std::uint64_t phys,std::uint64_t virt,std::uint64_t flags,std::uint32_t id);
         static void maprange(std::uint64_t cr3,std::uint64_t phys,std::uint64_t virt,std::uint64_t len,std::uint64_t flags);
+        static void zerorange(std::uint64_t cr3,std::uint64_t virt,std::uint64_t len);
+        static void destroyrange(std::uint64_t cr3, std::uint64_t virt, std::uint64_t len);
+        static void duplicaterangeifexists(std::uint64_t src_cr3, std::uint64_t dest_cr3, std::uint64_t virt, std::uint64_t len, std::uint64_t flags);
         static void maprangeid(std::uint64_t cr3,std::uint64_t phys,std::uint64_t virt,std::uint64_t len,std::uint64_t flags, std::uint32_t id);
         static void mapentry(std::uint64_t cr3,std::uint8_t type,std::uint64_t add_flags);
         static void mapkernel(std::uint64_t cr3,std::uint32_t id);
@@ -45,6 +48,8 @@ namespace memory {
         static void alwaysmappedmap(std::uint64_t cr3,std::uint32_t id);
         static std::uint64_t kernelget();
 
+        static void destroy(std::uint64_t cr3);
+
         static void change(std::uint64_t cr3, std::uint64_t virt, std::uint64_t flags);
 
         static void changerange(std::uint64_t cr3, std::uint64_t virt, std::uint64_t len , std::uint64_t flags);
diff --git a/kernel/include/generic/mm/vmm.hpp b/kernel/include/generic/mm/vmm.hpp
index 9aee626..ad522e5 100644
--- a/kernel/include/generic/mm/vmm.hpp
+++ b/kernel/include/generic/mm/vmm.hpp
@@ -10,6 +10,9 @@
 
 #include <generic/mm/paging.hpp>
 #include <generic/mm/pmm.hpp>
+#include <arch/x86_64/syscalls/shm.hpp>
+
+#include <drivers/cmos.hpp>
 
 #include <config.hpp>
 
@@ -27,14 +30,18 @@ typedef struct vmm_obj {
     uint8_t is_mapped;
 
     uint8_t is_free;
-
     uint8_t is_lazy_alloc;
+    uint8_t is_lazy_allocated;
+
+    uint8_t is_even_need_to_free;
 
     int* how_much_connected; // used for sharedmem
     locks::spinlock lock;
 
     uint64_t src_len;
 
+    shm_seg_t* shm;
+
     struct vmm_obj* next;
 } __attribute__((packed)) vmm_obj_t;
 
@@ -57,6 +64,10 @@ namespace memory {
             proc->vmm_start = (char*)start;
             proc->vmm_end = (char*)end;
         }
+
+        inline static vmm_obj_t* find_free(vmm_obj_t* start, std::uint64_t len) {
+            return 0;
+        }
         
         inline static vmm_obj_t* v_alloc(vmm_obj_t* start,std::uint64_t len) {
             vmm_obj_t* current = start->next;
@@ -64,6 +75,16 @@ namespace memory {
             uint64_t found = 0;
 
             uint64_t align_length = ALIGNUP(len,4096);
+
+            vmm_obj_t* top = find_free(start,len);
+            if(top) {
+                top->is_lazy_alloc = 0;
+                top->is_lazy_allocated = 0;
+                top->is_free = 0;
+                top->is_shared = 0;
+                top->is_mapped = 0;
+                return top;
+            }
             
             while(current) {
 
@@ -76,6 +97,9 @@ namespace memory {
                         vmm_new->base = prev_end;
                         vmm_new->len = align_length;
                         vmm_new->is_lazy_alloc = 0;
+                        vmm_new->is_lazy_allocated = 0;
+                        vmm_new->is_shared = 0;
+                        vmm_new->is_free = 0;
                         prev->next = vmm_new;
                         vmm_new->next = current;
 
@@ -118,6 +142,10 @@ namespace memory {
 
                         vmm_new->base = base;
                         vmm_new->len = align_length;
+
+                        vmm_new->is_lazy_alloc = 0;
+                        vmm_new->is_lazy_allocated = 0;
+                        vmm_new->is_shared = 0;
                         
                         prev->next = vmm_new;
                         vmm_new->next = current;
@@ -161,6 +189,61 @@ namespace memory {
             return (void*)new_vmm->base;
         }
 
+        inline static void* custom_map(arch::x86_64::process_t* proc, std::uint64_t virt, std::uint64_t phys, std::uint64_t length, std::uint64_t flags) {
+            asm volatile("cli"); // bug if they are enabled
+            vmm_obj_t* current = (vmm_obj_t*)proc->vmm_start;
+            current->lock.lock();
+            void* new_virt = mark(proc,virt,phys,length,flags,0);
+            paging::maprangeid(proc->original_cr3,phys,(std::uint64_t)virt,length,flags,*proc->vmm_id);
+            current->lock.unlock();
+            vmm_obj_t* new_vmm = get(proc,virt);
+            new_vmm->is_mapped = 1;
+            new_vmm->src_len = length;
+
+            ((vmm_obj_t*)proc->vmm_start)->lock.unlock();
+
+            return (void*)virt;
+        } 
+
+        inline static std::uint64_t shm_map(arch::x86_64::process_t* proc, shm_seg_t* shm, std::uint64_t base) {
+            
+            vmm_obj_t* current = (vmm_obj_t*)proc->vmm_start;
+            current->lock.lock();
+            
+            if(base == 0) {
+                vmm_obj_t* new_vmm = v_alloc(current,shm->len);
+                new_vmm->flags = PTE_PRESENT | PTE_RW | PTE_USER;
+                new_vmm->phys = shm->phys;
+                new_vmm->src_len = shm->len;
+                new_vmm->is_mapped = 1;
+                new_vmm->shm = shm;
+                paging::maprangeid(proc->original_cr3,shm->phys,new_vmm->base,shm->len,PTE_PRESENT | PTE_RW | PTE_USER,*proc->vmm_id);
+                new_vmm->shm->ctl.shm_atime = getUnixTime();
+                new_vmm->shm->ctl.shm_lpid = proc->id;
+                new_vmm->shm->ctl.shm_nattch++;
+                ((vmm_obj_t*)proc->vmm_start)->lock.unlock();
+                return (std::uint64_t)new_vmm->base;
+            } else {
+
+                void* new_virt = mark(proc,base,shm->phys,shm->len,PTE_PRESENT | PTE_RW | PTE_USER,0);
+                paging::maprangeid(proc->original_cr3,shm->phys,(std::uint64_t)base,shm->len,PTE_PRESENT | PTE_RW | PTE_USER,*proc->vmm_id);
+                current->lock.unlock();
+                vmm_obj_t* new_vmm = get(proc,base);
+                new_vmm->is_mapped = 1;
+                new_vmm->src_len = shm->len;
+                new_vmm->shm = shm;
+
+                new_vmm->shm->ctl.shm_atime = getUnixTime();
+                new_vmm->shm->ctl.shm_lpid = proc->id;
+                new_vmm->shm->ctl.shm_nattch++;
+                ((vmm_obj_t*)proc->vmm_start)->lock.unlock();
+                return (std::uint64_t)base;
+            }
+
+            ((vmm_obj_t*)proc->vmm_start)->lock.unlock();
+            return 0;
+        }
+
         inline static void* mark(arch::x86_64::process_t* proc, std::uint64_t base, std::uint64_t phys, std::uint64_t length, std::uint64_t flags, int is_shared) {
             asm volatile("cli"); // bug if they are enabled
             vmm_obj_t* current = (vmm_obj_t*)proc->vmm_start;
@@ -219,6 +302,19 @@ namespace memory {
             asm volatile("cli"); // bug if they are enabled
             vmm_obj_t* current = (vmm_obj_t*)src_proc->vmm_start;
             current->lock.lock();
+
+            arch::x86_64::process_t* proc = dest_proc;
+
+            proc->ctx.cr3 = memory::pmm::_physical::alloc(4096);
+            proc->original_cr3 = proc->ctx.cr3;
+            std::uint64_t cr3 = proc->ctx.cr3;
+            
+            for(int i = 255; i < 512; i++) {
+                std::uint64_t* virt_usrcr3 = (std::uint64_t*)Other::toVirt(proc->ctx.cr3);
+                std::uint64_t* virt_kercr3 = (std::uint64_t*)Other::toVirt(memory::paging::kernelget());
+                virt_usrcr3[i] = virt_kercr3[i];
+            }
+
             if(dest_proc && src_proc) {
 
                 vmm_obj_t* src_current = (vmm_obj_t*)src_proc->vmm_start;
@@ -227,26 +323,35 @@ namespace memory {
 
                     uint64_t phys;
 
-                    if(src_current->phys) {
+                    if(!src_current->is_free && src_current->base != 0 && src_current->base != (std::uint64_t)Other::toVirt(0) - 4096) {
 
-                        if(src_current->is_shared) {
-                            *src_current->how_much_connected = *src_current->how_much_connected + 1;
-                            phys = src_current->phys;
-                        } else {
-                            if(src_current->src_len <= 4096 && !src_current->is_mapped)
-                                phys = memory::pmm::_physical::alloc(4096);
-                            else if(src_current->src_len > 4096 && !src_current->is_mapped)
-                                phys = memory::pmm::_physical::alloc(src_current->src_len);
-                            else if(src_current->is_mapped)
+                        if(!src_current->is_lazy_allocated && !src_current->is_lazy_alloc && src_current->phys) {
+                            if(src_current->is_shared) {
+                                *src_current->how_much_connected = *src_current->how_much_connected + 1;
                                 phys = src_current->phys;
-
-                            if(!src_current->is_mapped)
-                                memcpy((void*)Other::toVirt(phys),(void*)Other::toVirt(src_current->phys),src_current->len);
+                            } else {
+                                if(src_current->src_len <= 4096 && !src_current->is_mapped)
+                                    phys = memory::pmm::_physical::alloc(4096);
+                                else if(src_current->src_len > 4096 && !src_current->is_mapped)
+                                    phys = memory::pmm::_physical::alloc(src_current->src_len);
+                                else if(src_current->is_mapped)
+                                    phys = src_current->phys;
+
+                                if(!src_current->is_mapped)
+                                    memcpy((void*)Other::toVirt(phys),(void*)Other::toVirt(src_current->phys),src_current->len);
+                            }
+                            memory::paging::maprangeid(cr3,phys,src_current->base,src_current->len,src_current->flags,*proc->vmm_id);
+                        } else {
+                            phys = 0;
+                            memory::paging::duplicaterangeifexists(src_proc->original_cr3,dest_proc->original_cr3,src_current->base,src_current->len,src_current->flags);
                         }
 
                         mark(dest_proc,src_current->base,phys,src_current->src_len,src_current->flags,src_current->is_shared);
                         get(dest_proc,src_current->base)->is_mapped = src_current->is_mapped;
 
+                        get(dest_proc,src_current->base)->is_lazy_alloc = src_current->is_lazy_alloc;
+                        get(dest_proc,src_current->base)->is_lazy_allocated = src_current->is_lazy_allocated;
+
                     }
 
                     if(src_current->base == (std::uint64_t)Other::toVirt(0) - 4096)
@@ -310,6 +415,43 @@ namespace memory {
             }
         }
 
+        inline static void unmap(arch::x86_64::process_t* proc, std::uint64_t virt) {
+            vmm_obj_t* current = getlen(proc,virt);
+            if(!current)
+                return;
+            vmm_obj_t* start = (vmm_obj_t*)proc->vmm_start;
+            start->lock.lock();
+            vmm_obj_t* prev = start;
+            while(prev) {
+                if(prev->next == current)
+                    break;
+                prev = prev->next;
+            }
+            prev->next = current->next;
+
+            if(!current->shm) {
+                if(current->is_lazy_alloc) {
+                    memory::paging::destroyrange(proc->original_cr3,current->base,current->len);
+                    memory::paging::zerorange(proc->original_cr3,(std::uint64_t)current->base,current->len);
+                } else {
+                    memory::pmm::_physical::free(current->phys);
+                    memory::paging::zerorange(proc->original_cr3,(std::uint64_t)current->base,current->len);
+                }
+            } else {
+                current->shm->ctl.shm_dtime = getUnixTime();
+                current->shm->ctl.shm_lpid = proc->id;
+                current->shm->ctl.shm_nattch--;
+                memory::paging::zerorange(proc->original_cr3,(std::uint64_t)current->base,current->len);
+                current->shm = 0;
+            }
+
+            current->is_free = 1;
+
+            delete current;
+            
+            start->lock.unlock();
+        }
+
         inline static void free(arch::x86_64::process_t* proc) {
             vmm_obj_t* current = (vmm_obj_t*)proc->vmm_start;
 
@@ -332,14 +474,22 @@ namespace memory {
                 if(current->base == (std::uint64_t)Other::toVirt(0) - 4096)
                     next = 0;
 
-                if(!current->is_mapped && !current->is_shared && !current->is_lazy_alloc) {
-                    memory::pmm::_physical::free(current->phys);
-                } else if(current->is_shared && !current->is_mapped) {
-                    if(*current->how_much_connected == 1) {
-                        memory::pmm::_physical::free(current->phys);
-                        delete (void*)current->how_much_connected;
-                    } else
-                        *current->how_much_connected = *current->how_much_connected - 1;
+                if(!current->is_free) {
+                    if(current->base != 0 && current->base != (std::uint64_t)Other::toVirt(0) - 4096) {
+                        if(!current->is_lazy_allocated && !current->is_lazy_alloc) {
+                            if(!current->is_mapped && !current->is_shared && !current->is_lazy_alloc) {
+                                memory::pmm::_physical::free(current->phys);
+                            } else if(current->is_shared && !current->is_mapped) {
+                                if(*current->how_much_connected == 1) {
+                                    memory::pmm::_physical::free(current->phys);
+                                    delete (void*)current->how_much_connected;
+                                } else
+                                    *current->how_much_connected = *current->how_much_connected - 1;
+                            }
+                        } else {
+                            memory::paging::destroyrange(proc->original_cr3,current->base,current->len);
+                        }
+                    }
                 }
  
                 delete current;
@@ -350,8 +500,7 @@ namespace memory {
                 current = next;
             }
 
-            memory::pmm::_physical::fullfree(*proc->vmm_id);
-            memory::pmm::_physical::free(proc->original_cr3);
+            memory::paging::destroy(proc->original_cr3);
 
             proc->original_cr3 = 0;
 
@@ -388,6 +537,9 @@ namespace memory {
             new_vmm->src_len = len;
             new_vmm->is_mapped = 0;
             new_vmm->is_lazy_alloc = 1;
+            new_vmm->is_lazy_allocated = 1;
+            new_vmm->phys = 0;
+            memory::paging::zerorange(proc->original_cr3,(std::uint64_t)new_vmm->base,new_vmm->len);
             ((vmm_obj_t*)proc->vmm_start)->lock.unlock();
             return (void*)new_vmm->base;
         }
diff --git a/kernel/include/generic/vfs/fd.hpp b/kernel/include/generic/vfs/fd.hpp
index 01b5fd3..34206ab 100644
--- a/kernel/include/generic/vfs/fd.hpp
+++ b/kernel/include/generic/vfs/fd.hpp
@@ -8,10 +8,21 @@
 
 namespace vfs {
     class fdmanager {
+    private:
+        arch::x86_64::process_t* proc = 0;
     public:
 
-        inline static int create(arch::x86_64::process_t* proc) {
-            userspace_fd_t* current = proc->fd;
+        userspace_fd_t* fd_list = 0;
+        std::uint64_t used_counter = 0;
+
+        fdmanager(arch::x86_64::process_t* proc) {
+            this->proc = proc;
+            this->used_counter++;
+        }
+
+        int create() {
+            proc->fd_lock.lock();
+            userspace_fd_t* current = fd_list;
             while(current) {
                 if(current->state == USERSPACE_FD_STATE_UNUSED && current->index > 2) 
                     break;
@@ -21,9 +32,10 @@ namespace vfs {
             if(!current) {
                 current = new userspace_fd_t;
                 memset(current,0,sizeof(userspace_fd_t));
-                current->next = proc->fd;
-                proc->fd = current;
-                current->index = proc->fd_ptr++;
+                current->next = fd_list;
+                fd_list = current;
+                current->index = *proc->fd_ptr;
+                *proc->fd_ptr = *proc->fd_ptr + 1;
             }
 
             current->state = USERSPACE_FD_STATE_FILE;
@@ -32,8 +44,60 @@ namespace vfs {
             current->can_be_closed = 0;
             current->is_cached_path = 0;
             current->is_debug = 0;
+            current->pid = proc->id;
+            current->uid = proc->uid;
 
+            proc->fd_lock.unlock();
             return current->index;
+        }
+
+        void free() {
+            proc->fd_lock.lock();
+            this->used_counter--;
+            if(!proc->is_shared_fd) {
+                userspace_fd_t* fd = this->fd_list;
+                while(fd) {
+                    if(!fd->can_be_closed) {
+                        if(fd->state == USERSPACE_FD_STATE_PIPE)
+                            fd->pipe->close(fd->pipe_side);
+                        else if(fd->state == USERSPACE_FD_STATE_FILE || fd->state == USERSPACE_FD_STATE_SOCKET)
+                            vfs::vfs::close(fd);
+                        else if(fd->state == USERSPACE_FD_STATE_EVENTFD)
+                            fd->eventfd->close();
+                    }
+                    userspace_fd_t* next = fd->next;
+                    delete (void*)fd;
+                    fd = next;
+                }
+                proc->fd_lock.unlock();
+                delete this;
+                return;
+            }
+            proc->fd_lock.unlock();
+        }
+
+        void duplicate(fdmanager* dest) {
+            userspace_fd_t* fd = this->fd_list;
+            while(fd) {
+                userspace_fd_t* newfd = new userspace_fd_t;
+                memcpy(newfd,fd,sizeof(userspace_fd_t));
+                
+                if(newfd->state == USERSPACE_FD_STATE_PIPE) {
+                    newfd->pipe->create(newfd->pipe_side);
+                } else if(newfd->state == USERSPACE_FD_STATE_EVENTFD)
+                    newfd->eventfd->create();
+
+                newfd->next = dest->fd_list;
+                dest->fd_list = newfd;
+                fd = fd->next;
+            }
+
+        }
+
+        inline static int create(arch::x86_64::process_t* proc) {
+
+            fdmanager* fd = (fdmanager*)proc->fd;
+            return fd->create();
 
         }
 
@@ -42,7 +106,8 @@ namespace vfs {
             if(!proc)
                 return 0;
 
-            userspace_fd_t* current = proc->fd;
+            fdmanager* fd = (fdmanager*)proc->fd;
+            userspace_fd_t* current = fd->fd_list;
             userspace_fd_t* lowest = 0;
 
             while(current) {
@@ -58,17 +123,43 @@ namespace vfs {
             return lowest;
         }
 
+        inline static userspace_fd_t* searchlowestfrom(arch::x86_64::process_t* proc,std::uint32_t idx) {
+
+            if(!proc)
+                return 0;
+
+            fdmanager* fd = (fdmanager*)proc->fd;
+            userspace_fd_t* current = fd->fd_list;
+            userspace_fd_t* lowest = 0;
+
+            while(current) {
+                if(current->state == USERSPACE_FD_STATE_UNUSED || current->can_be_closed)  {
+                    if(!lowest && current->index >= idx)
+                        lowest = current;
+                    if(current->index < lowest->index && current->index >= idx)
+                        lowest = current;
+                }
+                current = current->next;
+            }
+
+            return lowest;
+        }
+
         inline static userspace_fd_t* search(arch::x86_64::process_t* proc,std::uint32_t idx) {
 
             if(!proc)
                 return 0;
 
-            userspace_fd_t* current = proc->fd;
+            proc->fd_lock.lock();
+
+            fdmanager* fd = (fdmanager*)proc->fd;
+            userspace_fd_t* current = fd->fd_list;
             while(current) {
-                if(current->index == idx && current->state != USERSPACE_FD_STATE_UNUSED) 
-                    return current;
+                if(current->index == idx && current->state != USERSPACE_FD_STATE_UNUSED) { proc->fd_lock.unlock();
+                    return current; }
                 current = current->next;
             }
+            proc->fd_lock.unlock();
             return 0;
         }
     };
diff --git a/kernel/include/generic/vfs/tmpfs.hpp b/kernel/include/generic/vfs/tmpfs.hpp
index ad090cc..6f2ee06 100644
--- a/kernel/include/generic/vfs/tmpfs.hpp
+++ b/kernel/include/generic/vfs/tmpfs.hpp
@@ -12,10 +12,17 @@
 namespace vfs {
 
     typedef struct tmpfs_node {
+        std::uint64_t id;
         std::uint64_t size;
         std::uint64_t busy;
         std::uint64_t vars[8];
         std::uint8_t type;
+
+        std::uint64_t create_time;
+        std::uint64_t access_time;
+
+        std::uint8_t is_non_allocated;
+
         std::uint8_t* content;
         std::uint64_t real_size; // real size in ram (optimization)
         struct tmpfs_node* next;
diff --git a/kernel/include/generic/vfs/vfs.hpp b/kernel/include/generic/vfs/vfs.hpp
index edb42d8..3d0fda0 100644
--- a/kernel/include/generic/vfs/vfs.hpp
+++ b/kernel/include/generic/vfs/vfs.hpp
@@ -14,12 +14,17 @@ extern "C" void yield();
 
 #include <etc/logging.hpp>
 
+#include <etc/errno.hpp>
+#include <etc/list.hpp>
+
 #include <algorithm>
 
 #define USERSPACE_FD_STATE_UNUSED 0
 #define USERSPACE_FD_STATE_FILE 1
 #define USERSPACE_FD_STATE_PIPE 2
 #define USERSPACE_FD_STATE_SOCKET 3
+#define USERSPACE_FD_STATE_SOCKETPAIR 4 // unused maybe in future
+#define USERSPACE_FD_STATE_EVENTFD 5
 
 #define VFS_TYPE_NONE 0
 #define VFS_TYPE_FILE 1
@@ -143,8 +148,154 @@ typedef struct {
 
 void __vfs_symlink_resolve(char* path, char* out);
 
+#define EFD_SEMAPHORE 1
+#define EFD_NONBLOCK O_NONBLOCK
+
+struct ucred {
+	int pid;
+	int uid;
+	int gid;
+};
+
 namespace vfs {
 
+    class eventfd {
+    private:
+        int used = 0;
+    public:
+        locks::spinlock lock;
+        std::uint64_t buffer = 0;
+        int flags = 0;
+    
+        eventfd(int init, int flags) {
+            this->buffer = init;
+            this->flags = flags;
+        }
+
+        void create() {
+            used++;
+        }
+
+        void close() {
+            used--;
+            if(used == 0)
+                delete this;
+        }
+
+        std::int64_t write(std::uint64_t val) {
+            this->lock.lock();
+            std::uint64_t future = buffer + val;
+            if(future >= (0xFFFFFFFFFFFFFFFF - 1)) {
+                if(flags & EFD_NONBLOCK) {
+                    this->lock.unlock();
+                    return -EAGAIN; 
+                } else {
+                    while(future >= (0xFFFFFFFFFFFFFFFF - 1)) {
+                        this->lock.unlock();
+                        yield();
+                        this->lock.lock();
+                        future = buffer + val;
+                    }
+                }
+            }
+            buffer += val;
+            this->lock.unlock();
+            return 8;
+        }
+
+        std::int64_t read(std::uint64_t* val) {
+            this->lock.lock();
+            if(this->buffer == 0) {
+                if(this->flags & EFD_NONBLOCK) {
+                    this->lock.unlock();
+                    return -EAGAIN; 
+                }
+                
+                while(this->buffer == 0) {
+                    this->lock.unlock();
+                    yield();
+                    this->lock.lock();
+                }
+            }
+            *val = this->buffer;
+            if(this->flags & EFD_SEMAPHORE)
+                this->buffer--;
+            else 
+                this->buffer = 0;
+            this->lock.unlock();
+            return 8;
+        }
+
+        ~eventfd() {
+
+        }
+    
+    };
+
+    // same as fdpassmanager but ucred
+    class ucred_manager {
+    private:
+        struct ucred* fds = 0;
+        Lists::Bitmap* bitmap = 0;
+        int fd_size = 0;
+        int current_ptr = 0;
+        
+        int allocate() {
+            for(int i = 0; i < 64; i++) {
+                if(!this->bitmap->test(i))
+                    return i;
+            }
+            return -1;
+        }
+
+        int find_free() {
+            for(int i = 0; i < 64; i++) {
+                if(this->bitmap->test(i))
+                    return i;
+            }
+            return -1;
+        }
+
+    public:
+        
+        locks::spinlock lock;
+
+        ucred_manager() {
+            this->fd_size = 64; // default to 16 passing fds 
+            this->fds = new struct ucred[this->fd_size];
+            this->bitmap = new Lists::Bitmap(this->fd_size);
+        }
+
+        ~ucred_manager() {
+            delete (void*)this->fds;
+            delete (void*)this->bitmap;
+        }
+
+        int pop(struct ucred* out) {
+            this->lock.lock();
+            int idx = find_free();
+            if(idx == -1) { this->lock.unlock();
+                return -1; } 
+            memcpy(out,&fds[idx],sizeof(struct ucred));
+            this->bitmap->clear(idx);
+            this->lock.unlock();
+            return 0;
+        }
+
+        int push(struct ucred* src) {
+            this->lock.lock();
+            int idx = allocate();
+            if(idx == -1) { this->lock.unlock();
+                return -1; }
+            memcpy(&fds[idx],src,sizeof(struct ucred));
+            this->bitmap->set(idx);
+            this->lock.unlock();
+            return 0;
+        }
+
+    };
+
+
     class pipe {
     private:
         
@@ -173,9 +324,16 @@ namespace vfs {
         std::uint32_t connected_to_pipe_write = 0;
         std::uint64_t flags = 0;
 
+        std::uint32_t zero_message_count = 0;
+        
+        int is_closed_socket = 0;
+
         int tty_ret = 0;
         termios_t* ttyflags = 0;
 
+        void* fd_pass = 0;
+        ucred_manager* ucred_pass = 0;
+
         pipe(std::uint64_t flags) {
             this->buffer = (char*)memory::pmm::_virtual::alloc(USERSPACE_PIPE_SIZE);
             this->total_size = USERSPACE_PIPE_SIZE;
@@ -238,6 +396,14 @@ namespace vfs {
         std::uint64_t write(const char* src_buffer, std::uint64_t count,int id) {
 
             std::uint64_t written = 0;
+
+            if(count == 0) {
+                this->lock.lock();
+                this->zero_message_count = 1;
+                this->lock.unlock();
+                return 0;
+            }
+
             while (written < count) {
                 this->lock.lock();
 
@@ -265,6 +431,35 @@ namespace vfs {
             return written;
         }
 
+        std::uint64_t nolock_write(const char* src_buffer, std::uint64_t count,int id) {
+
+            std::uint64_t written = 0;
+
+            if(count == 0) {
+                this->zero_message_count = 1;
+                return 0;
+            }
+
+            while (written < count) {
+
+                std::uint64_t space_left = this->total_size - this->size;
+
+                uint64_t old_size = this->size;
+
+                std::uint64_t to_write = (count - written) < space_left ? (count - written) : space_left;
+                if(to_write < 0)
+                    to_write = 0;
+
+
+                force_write(src_buffer + written, to_write);
+
+                written += to_write;
+                this->read_counter++;
+
+            }
+            return written;
+        }
+
         std::uint64_t ttyread(std::int64_t* read_count, char* dest_buffer, std::uint64_t count, int is_block) {
 
             std::uint64_t read_bytes = 0;
@@ -331,7 +526,7 @@ namespace vfs {
             return read_bytes;
         }
 
-        std::uint64_t read(std::int64_t* read_count, char* dest_buffer, std::uint64_t count, int is_block) {
+        std::int64_t read(std::int64_t* read_count, char* dest_buffer, std::uint64_t count, int is_block) {
 
             std::uint64_t read_bytes = 0;
             int tries = 0;
@@ -340,14 +535,21 @@ namespace vfs {
                 this->lock.lock();
 
                 if (this->size == 0) {
+
                     if (this->is_closed.test(std::memory_order_acquire)) {
                         this->lock.unlock();
                         return 0; 
                     }
-                    if (flags & O_NONBLOCK || is_block) {
+
+                    if(this->is_closed_socket) {
                         this->lock.unlock();
                         return 0;
                     }
+
+                    if (flags & O_NONBLOCK || is_block) {
+                        this->lock.unlock();
+                        return -11;
+                    }
                     this->lock.unlock();
                     yield();
                     continue;
@@ -376,6 +578,8 @@ namespace vfs {
 
         ~pipe() {
             memory::pmm::_virtual::free(this->buffer);
+            if(ucred_pass)
+                delete (void*)ucred_pass;
         }
 
     };
@@ -412,12 +616,18 @@ typedef struct userspace_fd {
     std::uint8_t state;
     std::uint8_t pipe_side;
 
+    int pid;
+    int uid;
+
     std::uint8_t can_be_closed;
 
     std::uint8_t is_listen;
     vfs::pipe* read_socket_pipe;
     vfs::pipe* write_socket_pipe;
 
+    int socket_pid;
+    int socket_uid;
+
     std::uint8_t is_a_tty;
 
     std::uint8_t other_state;
@@ -433,6 +643,8 @@ typedef struct userspace_fd {
     int is_cached_path;
     int is_debug;
 
+    vfs::eventfd* eventfd;
+
     vfs::pipe* pipe;
     char path[2048];
 
@@ -441,7 +653,74 @@ typedef struct userspace_fd {
 
 } userspace_fd_t;
 
+
+
+static_assert(sizeof(userspace_fd_t) < 4096,"userspace_fd size is bigger than page size");
+
 namespace vfs {
+
+    class passingfd_manager {
+    private:
+        userspace_fd_t* fds = 0;
+        Lists::Bitmap* bitmap = 0;
+        int fd_size = 0;
+        int current_ptr = 0;
+        
+        int allocate() {
+            for(int i = 0; i < 16; i++) {
+                if(!this->bitmap->test(i))
+                    return i;
+            }
+            return -1;
+        }
+
+        int find_free() {
+            for(int i = 0; i < 16; i++) {
+                if(this->bitmap->test(i))
+                    return i;
+            }
+            return -1;
+        }
+
+    public:
+        
+        locks::spinlock lock;
+
+        passingfd_manager() {
+            this->fd_size = 16; // default to 16 passing fds 
+            this->fds = new userspace_fd_t[this->fd_size];
+            this->bitmap = new Lists::Bitmap(this->fd_size);
+        }
+
+        ~passingfd_manager() {
+            delete (void*)this->fds;
+            delete (void*)this->bitmap;
+        }
+
+        int pop(userspace_fd_t* out) {
+            this->lock.lock();
+            int idx = find_free();
+            if(idx == -1) { this->lock.unlock();
+                return -1; } 
+            memcpy(out,&fds[idx],sizeof(userspace_fd_t));
+            this->bitmap->clear(idx);
+            this->lock.unlock();
+            return 0;
+        }
+
+        int push(userspace_fd_t* src) {
+            this->lock.lock();
+            int idx = allocate();
+            if(idx == -1) { this->lock.unlock();
+                return -1; }
+            memcpy(&fds[idx],src,sizeof(userspace_fd_t));
+            this->bitmap->set(idx);
+            this->lock.unlock();
+            return 0;
+        }
+
+    };
+
     class fd {
     public:
         /* Just helper function for non userspace usage */
@@ -478,6 +757,12 @@ namespace vfs {
 #define TMPFS_VAR_UNLINK 1
 #define DEVFS_VAR_ISATTY 2
 
+typedef long time_t;
+struct timespec {
+	time_t tv_sec;
+	long tv_nsec;
+};
+
 namespace vfs {
 
     static inline std::uint64_t resolve_count(char* str,std::uint64_t sptr,char delim) {
@@ -500,8 +785,6 @@ namespace vfs {
 
 
     static inline int normalize_path(const char* src, char* dest, std::uint64_t dest_size) {
-        memcpy(dest,src,strlen(src) + 1);
-        return 0;
         if (!src ||!dest || dest_size < 2) return -1;
         std::uint64_t j = 0;
         int prev_slash = 0;
@@ -535,8 +818,8 @@ namespace vfs {
         std::uint64_t ptr = strlen((char*)base);
         char is_first = 1;
         char is_full = 0;
+
         memcpy(inter,inter0,strlen(inter0) + 1);
-        
 
         if(strlen((char*)inter) == 1 && inter[0] == '.') {
             memcpy(result,base,strlen((char*)base) + 1);
@@ -558,6 +841,9 @@ namespace vfs {
         if(spec)
             is_first = 0;
 
+        if(!strcmp(base,"/"))
+            is_first = 0;
+
         buffer = strtok((char*)inter,"/");
         while(buffer) {
 
@@ -618,6 +904,8 @@ namespace vfs {
         __MLIBC_DIRENT_BODY;
     } dirent_t;
 
+    
+
     typedef struct {
         unsigned long st_dev;
         unsigned long st_ino;
@@ -630,7 +918,10 @@ namespace vfs {
         long st_size;
         long st_blksize;
         long st_blocks;
-
+        struct timespec st_atim;
+        struct timespec st_mtim;
+        struct timespec st_ctim;
+        long __unused[3];
     } __attribute__((packed)) stat_t;
 
     typedef struct {
diff --git a/kernel/src/arch/x86_64/cpu/smp.cpp b/kernel/src/arch/x86_64/cpu/smp.cpp
index 3f0aaf1..6ba2449 100644
--- a/kernel/src/arch/x86_64/cpu/smp.cpp
+++ b/kernel/src/arch/x86_64/cpu/smp.cpp
@@ -57,7 +57,7 @@ void __mp_bootstrap(struct LIMINE_MP(info)* smp_info) {
 
     arch::x86_64::cpu::data()->smp.cpu_id = balance_how_much_cpus++;
 
-    arch::x86_64::cpu::data()->lapic_block = arch::x86_64::cpu::lapic::init(2500);
+    arch::x86_64::cpu::data()->lapic_block = arch::x86_64::cpu::lapic::init(1000);
     arch::x86_64::cpu::sse::init();
     arch::x86_64::syscall::init();
     Log::Display(LEVEL_MESSAGE_OK,"Cpu %d is online \n",arch::x86_64::cpu::data()->smp.cpu_id);
diff --git a/kernel/src/arch/x86_64/interrupts/idt.cpp b/kernel/src/arch/x86_64/interrupts/idt.cpp
index a797814..12fff62 100644
--- a/kernel/src/arch/x86_64/interrupts/idt.cpp
+++ b/kernel/src/arch/x86_64/interrupts/idt.cpp
@@ -60,9 +60,11 @@ void arch::x86_64::interrupts::idt::set_entry(std::uint64_t base,std::uint8_t ve
 }
 
 std::uint8_t arch::x86_64::interrupts::idt::alloc() {
-    for(int i = 0;i < 255;i++)
+    for(int i = 0;i < 255;i++) {
         if(!idt_bitmap->test(i)) {
             idt_bitmap->set(i);
             return i;
-        }
+        } 
+    }
+    return 0;
 }
\ No newline at end of file
diff --git a/kernel/src/arch/x86_64/interrupts/panic.cpp b/kernel/src/arch/x86_64/interrupts/panic.cpp
index 4d5f79e..98070fa 100644
--- a/kernel/src/arch/x86_64/interrupts/panic.cpp
+++ b/kernel/src/arch/x86_64/interrupts/panic.cpp
@@ -33,7 +33,7 @@ void panic(int_frame_t* ctx, const char* msg) {
     }
 
     arch::x86_64::process_t* proc = arch::x86_64::cpu::data()->temp.proc;
-    if(proc && 1) {
+    if(proc && 1 && ctx) {
         uint64_t cr2;
         asm volatile("mov %%cr2, %0" : "=r"(cr2) : : "memory");
 
@@ -43,52 +43,34 @@ void panic(int_frame_t* ctx, const char* msg) {
         vmm_obj_t* obj = memory::vmm::getlen(proc,ctx->rip);
 
 
-        // if(ctx->vec == 14) {
-        //     vmm_obj_t* obj0 = memory::vmm::getlen(proc,cr2);
+        if(ctx->vec == 14) {
+            vmm_obj_t* obj0 = memory::vmm::getlen(proc,cr2);
             
-        //     if(obj0) {
-        //         if(obj0->cow_connect && !obj0->is_own_page && obj0->base != 0 ) {
-        //             Log::SerialDisplay(LEVEL_MESSAGE_INFO,"trying to cow 0x%p\n",cr2);
-        //             //memory::vmm::cow(proc,cr2);
-
-        //             if(ctx->cs & 3)
-        //                 ctx->ss |= 3;
-                        
-        //             if(ctx->ss & 3)
-        //                 ctx->cs |= 3;
-
-        //             if(ctx->cs == 0x20)
-        //                 ctx->cs |= 3;
-                        
-        //             if(ctx->ss == 0x18)
-        //                 ctx->ss |= 3;
-
-        //             if(ctx->cs != 0x08)
-        //                 asm volatile("swapgs");
-
-        //             schedulingEnd(ctx);
-        //         } else if(obj0->is_mapped) {
-        //             obj0->flags |= PTE_RW;
-        //             memory::paging::maprangeid(proc->original_cr3,obj0->phys,obj0->base,obj0->len,obj0->flags,*proc->vmm_id);
-        //             if(ctx->cs & 3)
-        //                 ctx->ss |= 3;
-                        
-        //             if(ctx->ss & 3)
-        //                 ctx->cs |= 3;
-
-        //             if(ctx->cs == 0x20)
-        //                 ctx->cs |= 3;
-                        
-        //             if(ctx->ss == 0x18)
-        //                 ctx->ss |= 3;
-
-        //             if(ctx->cs != 0x08)
-        //                 asm volatile("swapgs");
-
-        //             schedulingEnd(ctx);
-        //         }
-        //     }
-        // }
+            if(obj0) {
+               if(obj0->is_lazy_alloc && !obj0->is_free) {
+
+                    std::uint64_t new_phys = memory::pmm::_physical::alloc(4096);
+                    memory::paging::map(proc->original_cr3,new_phys,ALIGNDOWN(cr2,4096),obj0->flags);
+
+                    if(ctx->cs & 3)
+                        ctx->ss |= 3;
+                                        
+                    if(ctx->ss & 3)
+                        ctx->cs |= 3;
+
+                    if(ctx->cs == 0x20)
+                        ctx->cs |= 3;
+                                        
+                    if(ctx->ss == 0x18)
+                        ctx->ss |= 3;
+
+                    if(ctx->cs != 0x08)
+                        asm volatile("swapgs");
+
+                    schedulingEnd(ctx);
+               }
+            }
+        }
 
         Log::SerialDisplay(LEVEL_MESSAGE_FAIL,"process %d fired cpu exception with vec %d, rip 0x%p (offset 0x%p), cr2 0x%p, error code 0x%p, lastsys %d, rdx 0x%p rbp 0x%p\n",proc->id,ctx->vec,ctx->rip,ctx->rip - 0x41400000,cr2,ctx->err_code,proc->sys,ctx->rdx,ctx->rbp);
         
@@ -109,7 +91,7 @@ void panic(int_frame_t* ctx, const char* msg) {
 
         memory::paging::enablepaging(ctx->cr3);
         Log::SerialDisplay(LEVEL_MESSAGE_INFO,"[0] - 0x%016llX (current rip)\n",ctx->rip);
-        for (int i = 1; i < 25 && rbp; ++i) {
+        for (int i = 1; i < 10 && rbp; ++i) {
             std::uint64_t ret_addr = rbp->rip;
             Log::SerialDisplay(LEVEL_MESSAGE_INFO,"[%d] - 0x%016llX\n", i, ret_addr);
             rbp = (stackframe_t*)rbp->rbp;
diff --git a/kernel/src/arch/x86_64/scheduling.cpp b/kernel/src/arch/x86_64/scheduling.cpp
index 791a97b..f7a543e 100644
--- a/kernel/src/arch/x86_64/scheduling.cpp
+++ b/kernel/src/arch/x86_64/scheduling.cpp
@@ -14,6 +14,8 @@
 #include <arch/x86_64/interrupts/idt.hpp>
 #include <arch/x86_64/cpu/lapic.hpp>
 
+#include <generic/vfs/fd.hpp>
+
 #include <etc/libc.hpp>
 #include <etc/list.hpp>
 
@@ -264,6 +266,16 @@ void arch::x86_64::scheduling::wakeup(process_t* proc) {
     proc->lock.unlock(); /* Just clear */
 }
 
+arch::x86_64::process_t* arch::x86_64::scheduling::by_pid(int pid) {
+    process_t* proc = head_proc_();
+    while(proc) {
+        if(proc->id == pid)
+            return proc;
+        proc = proc->next;
+    }
+    return 0;
+}
+
 arch::x86_64::process_t* arch::x86_64::scheduling::clone(process_t* proc,int_frame_t* ctx) {
     process_t* nproc = create();
     memory::vmm::free(nproc);
@@ -271,6 +283,7 @@ arch::x86_64::process_t* arch::x86_64::scheduling::clone(process_t* proc,int_fra
     nproc->is_cloned = 1;
     nproc->ctx.cr3 = ctx->cr3;
     nproc->original_cr3 = ctx->cr3;
+    nproc->uid = proc->uid;
 
     nproc->vmm_end = proc->vmm_end;
     nproc->vmm_start = proc->vmm_start;
@@ -287,21 +300,30 @@ arch::x86_64::process_t* arch::x86_64::scheduling::clone(process_t* proc,int_fra
 
     memcpy(nproc->sse_ctx,proc->sse_ctx,arch::x86_64::cpu::sse::size());
 
+    nproc->is_shared_fd = 1;
     nproc->fd_ptr = proc->fd_ptr;
+    nproc->fd = proc->fd;
+
+    vfs::fdmanager* fd = (vfs::fdmanager*)proc->fd;
+
+    proc->fd_lock.lock();
+    fd->used_counter++;
+    proc->fd_lock.unlock();
 
-    userspace_fd_t* fd = proc->fd;
-    while(fd) {
-        userspace_fd_t* newfd = new userspace_fd_t;
-        memcpy(newfd,fd,sizeof(userspace_fd_t));
+    // userspace_fd_t* fd = proc->fd;
+    // while(fd) {
+    //     userspace_fd_t* newfd = new userspace_fd_t;
+    //     memcpy(newfd,fd,sizeof(userspace_fd_t));
         
-        if(newfd->state == USERSPACE_FD_STATE_PIPE) {
-            newfd->pipe->create(newfd->pipe_side);
-        }
+    //     if(newfd->state == USERSPACE_FD_STATE_PIPE) {
+    //         newfd->pipe->create(newfd->pipe_side);
+    //     } else if(newfd->state == USERSPACE_FD_STATE_EVENTFD)
+    //         newfd->eventfd->create();
 
-        newfd->next = nproc->fd;
-        nproc->fd = newfd;
-        fd = fd->next;
-    }
+    //     newfd->next = nproc->fd;
+    //     nproc->fd = newfd;
+    //     fd = fd->next;
+    // }
 
     memcpy(&nproc->ctx,ctx,sizeof(int_frame_t));
 
@@ -311,10 +333,10 @@ arch::x86_64::process_t* arch::x86_64::scheduling::clone(process_t* proc,int_fra
 arch::x86_64::process_t* arch::x86_64::scheduling::fork(process_t* proc,int_frame_t* ctx) {
     process_t* nproc = create();
     memory::vmm::clone(nproc,proc);
-    memory::vmm::reload(nproc);
 
     nproc->parent_id = proc->id;
     nproc->fs_base = proc->fs_base;
+    nproc->uid = proc->uid;
 
     memset(nproc->cwd,0,4096);
     memset(nproc->name,0,4096);
@@ -323,22 +345,11 @@ arch::x86_64::process_t* arch::x86_64::scheduling::fork(process_t* proc,int_fram
 
     memcpy(nproc->sse_ctx,proc->sse_ctx,arch::x86_64::cpu::sse::size());
 
-    nproc->fd_ptr = proc->fd_ptr;
-
-    userspace_fd_t* fd = proc->fd;
-    while(fd) {
-        userspace_fd_t* newfd = new userspace_fd_t;
-        memcpy(newfd,fd,sizeof(userspace_fd_t));
-        
-        if(newfd->state == USERSPACE_FD_STATE_PIPE) {
-            newfd->pipe->create(newfd->pipe_side);
-        }
-
-        newfd->next = nproc->fd;
-        nproc->fd = newfd;
-        fd = fd->next;
-    }
+    *nproc->fd_ptr = *proc->fd_ptr;
 
+    vfs::fdmanager* fd = (vfs::fdmanager*)proc->fd;
+    fd->duplicate((vfs::fdmanager*)nproc->fd);
+    
     memcpy(&nproc->ctx,ctx,sizeof(int_frame_t));
     nproc->ctx.cr3 = nproc->original_cr3;
 
@@ -349,6 +360,7 @@ void arch::x86_64::scheduling::kill(process_t* proc) {
     proc->lock.nowaitlock();
     proc->status = PROCESS_STATE_ZOMBIE;
     proc->exit_timestamp = time::counter();
+    delete proc->pass_fd;
 }
 
 void __scheduling_balance_cpus() {
@@ -373,8 +385,6 @@ arch::x86_64::process_t* arch::x86_64::scheduling::create() {
     proc->name = (char*)memory::pmm::_virtual::alloc(4096);
     proc->sse_ctx = (char*)memory::pmm::_virtual::alloc(arch::x86_64::cpu::sse::size());
 
-    proc->fd_ptr = 3;
-
     proc->syscall_stack = (std::uint64_t)memory::pmm::_virtual::alloc(SYSCALL_STACK_SIZE);
 
     fpu_head_t* head = (fpu_head_t*)proc->sse_ctx;
@@ -386,6 +396,11 @@ arch::x86_64::process_t* arch::x86_64::scheduling::create() {
     proc->status = PROCESS_STATE_RUNNING;
     proc->lock.nowaitlock();
     proc->kill_lock.unlock();
+    proc->fd_ptr = &proc->alloc_fd;
+    *proc->fd_ptr = 3;
+
+    vfs::fdmanager* z = new vfs::fdmanager(proc);
+    proc->fd = (void*)z;
 
     proc->next = head_proc;
     head_proc = proc;
@@ -393,6 +408,8 @@ arch::x86_64::process_t* arch::x86_64::scheduling::create() {
     proc->id = id_ptr++;
     proc->vmm_id = &proc->id;
 
+    proc->pass_fd = new vfs::passingfd_manager;
+
     memory::vmm::initproc(proc);
     memory::vmm::reload(proc);
 
@@ -405,35 +422,37 @@ arch::x86_64::process_t* arch::x86_64::scheduling::create() {
 
 locks::spinlock futex_lock;
 
-void arch::x86_64::scheduling::futexwake(process_t* proc, int* lock) {
+int arch::x86_64::scheduling::futexwake(process_t* proc, int* lock) {
     process_t* proc0 = head_proc;
     futex_lock.lock();
     while(proc0) {
-        if((proc0->parent_id == proc->id || proc->parent_id == proc0->id)) {
+        // if process vmm is same then they are connected
+        if(((proc0->parent_id == proc->id || proc->parent_id == proc0->id) || (proc->vmm_start == proc0->vmm_start)) && (proc0->futex == (std::uint64_t)lock || proc->futex == (std::uint64_t)lock)) {
             proc0->futex = 0;
             proc0->futex_lock.unlock();
-        } 
+            DEBUG(proc->is_debug,"futex_wakeup proccess %d from proc %d, futex 0x%p",proc0->id,proc->id,lock);
+        } else if((proc0->futex == (std::uint64_t)lock || proc->futex == (std::uint64_t)lock)) {
+            DEBUG(proc->is_debug,"same futex 0x%p but calling proc %d is not connected to proc %d",lock,proc->id,proc0->id);
+        }
         proc0 = proc0->next;
     }
     futex_lock.unlock();
+    return 0;
 }
 
-void arch::x86_64::scheduling::futexwait(process_t* proc, int* lock, int val, int* original_lock) {
+void arch::x86_64::scheduling::futexwait(process_t* proc, int* lock, int val, int* original_lock,std::uint64_t ts) {
     
     futex_lock.lock();
     int lock_val = *lock;
-    if(lock_val == val) {
-        proc->futex_lock.lock();
-        proc->futex = (std::uint64_t)original_lock;
-    } 
+    proc->futex_lock.lock();
+    proc->futex = (std::uint64_t)original_lock;
+    proc->ts = ts;
     futex_lock.unlock();
 }
-
 int l = 0;
 
 extern "C" void schedulingSchedule(int_frame_t* ctx) {
     extern int is_panic;
-    memory::paging::enablekernel();
 
     if(ctx) {
         if(ctx->cs != 0x08)
@@ -449,7 +468,7 @@ extern "C" void schedulingSchedule(int_frame_t* ctx) {
 
     if(ctx) {
         if(current) {
-            if(!current->kill_lock.test()) {
+            if(!current->kill_lock.test() && !current->_3rd_kill_lock.test()) {
                 current->ctx = *ctx;
                 current->fs_base = __rdmsr(0xC0000100);
                 arch::x86_64::cpu::sse::save((std::uint8_t*)current->sse_ctx);
@@ -459,7 +478,22 @@ extern "C" void schedulingSchedule(int_frame_t* ctx) {
     }
 
     if(current) { 
-        current->lock.unlock();
+        if(current->_3rd_kill_lock.test() && !current->kill_lock.test()) {
+            memory::paging::enablekernel();
+            arch::x86_64::scheduling::kill(current);
+            
+            if(1)
+                memory::vmm::free(current); 
+
+            vfs::fdmanager* fd = (vfs::fdmanager*)current->fd;
+            fd->free();
+
+            memory::pmm::_virtual::free(current->cwd);
+            memory::pmm::_virtual::free(current->name);
+            memory::pmm::_virtual::free(current->sse_ctx);
+        } else
+            current->lock.unlock();
+        
         current = current->next; 
     } 
 
@@ -468,44 +502,58 @@ extern "C" void schedulingSchedule(int_frame_t* ctx) {
     while (true) {
         while (current) {
 
-            if (!current->kill_lock.test() && current->id != 0 && current_cpu == current->target_cpu && !current->futex_lock.test()) {
-                if(!current->lock.test_and_set()) {
+            if (!current->kill_lock.test() && current->id != 0 && current_cpu == current->target_cpu) {
+            
+                futex_lock.lock();
+                if(current->futex_lock.test()) {
+                     if(current->ts != 0) {
+                         if(current->ts < drivers::tsc::currentus()) {
+                             current->ts = 0;
+                             current->futex_lock.unlock(); 
+                         }
+                     }
+                }
+                futex_lock.unlock();
+
+                if(!current->futex_lock.test()) {
+                    if(!current->lock.test_and_set()) {
 
-                    if(!ctx) {
-                        int_frame_t temp_ctx;
-                        ctx = &temp_ctx;
-                    }
+                        if(!ctx) {
+                            int_frame_t temp_ctx;
+                            ctx = &temp_ctx;
+                        }
 
-                    memcpy(ctx, &current->ctx, sizeof(int_frame_t));
+                        memcpy(ctx, &current->ctx, sizeof(int_frame_t));
 
-                    __wrmsr(0xC0000100, current->fs_base);
-                    arch::x86_64::cpu::sse::load((std::uint8_t*)current->sse_ctx);
+                        __wrmsr(0xC0000100, current->fs_base);
+                        arch::x86_64::cpu::sse::load((std::uint8_t*)current->sse_ctx);
 
-                    if(ctx->cs & 3)
-                        ctx->ss |= 3;
-                        
-                    if(ctx->ss & 3)
-                        ctx->cs |= 3;
+                        if(ctx->cs & 3)
+                            ctx->ss |= 3;
+                            
+                        if(ctx->ss & 3)
+                            ctx->cs |= 3;
 
-                    if(ctx->cs == 0x20)
-                        ctx->cs |= 3;
-                        
-                    if(ctx->ss == 0x18)
-                        ctx->ss |= 3;
+                        if(ctx->cs == 0x20)
+                            ctx->cs |= 3;
+                            
+                        if(ctx->ss == 0x18)
+                            ctx->ss |= 3;
 
-                    data->kernel_stack = current->syscall_stack + SYSCALL_STACK_SIZE;
-                    data->user_stack = current->user_stack;
-                    data->temp.proc = current;
+                        data->kernel_stack = current->syscall_stack + SYSCALL_STACK_SIZE;
+                        data->user_stack = current->user_stack;
+                        data->temp.proc = current;
 
-                    int prio_div = current->prio < 0 ? (current->prio * -1) : 1;
-                    prio_div++;
+                        int prio_div = current->prio < 0 ? (current->prio * -1) : 1;
+                        prio_div++;
 
-                    arch::x86_64::cpu::lapic::eoi();
+                        arch::x86_64::cpu::lapic::eoi();
 
-                    if(ctx->cs != 0x08)
-                        asm volatile("swapgs");
+                        if(ctx->cs != 0x08)
+                            asm volatile("swapgs");
 
-                    schedulingEnd(ctx);
+                        schedulingEnd(ctx);
+                    }
                 }
             }
             current = current->next;
diff --git a/kernel/src/arch/x86_64/syscalls/file.cpp b/kernel/src/arch/x86_64/syscalls/file.cpp
index c1a1500..fdb583f 100644
--- a/kernel/src/arch/x86_64/syscalls/file.cpp
+++ b/kernel/src/arch/x86_64/syscalls/file.cpp
@@ -48,7 +48,7 @@ syscall_ret_t sys_openat(int dirfd, const char* path, int flags, int_frame_t* ct
     memset(result,0,2048);
     vfs::resolve_path(kpath,first_path,result,1,0);
 
-    DEBUG(0,"Trying to open %s from proc %d",result,proc->id);
+    DEBUG(proc->is_debug,"Trying to open %s from proc %d",result,proc->id);
 
     if(result[0] == '\0') {
         result[0] = '/';
@@ -93,7 +93,7 @@ syscall_ret_t sys_openat(int dirfd, const char* path, int flags, int_frame_t* ct
         new_fd_s->state = USERSPACE_FD_STATE_UNUSED;
 
     if(status != 0)
-        DEBUG(proc->is_debug,"Failed to open %s from proc %d",result,proc->id);
+        DEBUG(proc->is_debug,"Failed to open %s (%s + %s) from proc %d",result,first_path,path,proc->id);
     
     new_fd_s->offset = 0;
 
@@ -122,8 +122,8 @@ syscall_ret_t sys_read(int fd, void *buf, size_t count) {
         if(fd_s->pipe_side != PIPE_SIDE_READ)
             return {1,EBADF,0};
         
-        bytes_read = fd_s->pipe->read(&fd_s->read_counter,temp_buffer,count,0);
-        if(bytes_read == 0 && (fd_s->pipe->flags & O_NONBLOCK || fd_s->flags & O_NONBLOCK) && !fd_s->pipe->is_closed.test()) 
+        bytes_read = fd_s->pipe->read(&fd_s->read_counter,temp_buffer,count,(fd_s->flags & O_NONBLOCK) ? 1 : 0);
+        if(bytes_read == -EAGAIN && (fd_s->pipe->flags & O_NONBLOCK || fd_s->flags & O_NONBLOCK) && !fd_s->pipe->is_closed.test()) 
             return {1,EAGAIN,0};
 
     } else if(fd_s->state == USERSPACE_FD_STATE_SOCKET) {
@@ -132,18 +132,26 @@ syscall_ret_t sys_read(int fd, void *buf, size_t count) {
             return {1,EFAULT,0};
 
         if(fd_s->other_state == USERSPACE_FD_OTHERSTATE_MASTER) {
-            bytes_read = fd_s->write_socket_pipe->read(&fd_s->read_counter,temp_buffer,count,0);
+            bytes_read = fd_s->write_socket_pipe->read(&fd_s->read_counter,temp_buffer,count,(fd_s->flags & O_NONBLOCK) ? 1 : 0);
         } else {
-            bytes_read = fd_s->read_socket_pipe->read(&fd_s->read_counter,temp_buffer,count,0);
+            bytes_read = fd_s->read_socket_pipe->read(&fd_s->read_counter,temp_buffer,count,(fd_s->flags & O_NONBLOCK) ? 1 : 0);
         }
 
-        if(bytes_read == 0)
+        if(bytes_read == -EAGAIN)
             return {1,EAGAIN,0};
 
+        if(bytes_read == 0)
+            return {1,0,0};
+
+    } else if(fd_s->state == USERSPACE_FD_STATE_EVENTFD) {
+        if(count != 8)
+            return {1,EINVAL,0};
+        std::uint64_t* _8sizebuf = (std::uint64_t*)buf;
+        bytes_read = fd_s->eventfd->read(_8sizebuf);
     } else
         return {1,EBADF,0};
 
-    DEBUG(proc->is_debug,"Read done from proc %d\n",proc->id);
+    DEBUG(proc->is_debug,"Read done from proc %d bytes-read %d\n",proc->id,bytes_read);
 
     return {1,bytes_read >= 0 ? 0 : (int)(+bytes_read), bytes_read};
 }
@@ -153,8 +161,10 @@ syscall_ret_t sys_write(int fd, const void *buf, size_t count) {
 
     arch::x86_64::process_t* proc = CURRENT_PROC;
     userspace_fd_t* fd_s = vfs::fdmanager::search(proc,fd);
-    if(!fd_s)
+    if(!fd_s) {
+        DEBUG(proc->is_debug,"fail write fd %d from proc %d, proc->fd is 0x%p\n",fd,proc->id,proc->fd);
         return {1,EBADF,0};
+    }
 
     if(fd_s->can_be_closed)
         fd_s->can_be_closed = 0;
@@ -162,8 +172,11 @@ syscall_ret_t sys_write(int fd, const void *buf, size_t count) {
     char* temp_buffer = (char*)buf;   
 
     const char* _0 = "Content view is disabled in files";
-   // DEBUG(proc->id == 15,"Writing %s fd %d state %d from proc %d count %d writ sock 0x%p",fd_s->state == USERSPACE_FD_STATE_FILE ? fd_s->path : "Not file",fd,fd_s->state,proc->id,count,fd_s->write_socket_pipe);
+    DEBUG(proc->is_debug && fd != 1 && fd != 2,"Writing %s with content %s fd %d state %d from proc %d count %d writ sock 0x%p",fd_s->state == USERSPACE_FD_STATE_FILE ? fd_s->path : "Not file",buf,fd,fd_s->state,proc->id,count,fd_s->write_socket_pipe);
 
+    if(fd == 1) {
+        //Log::SerialDisplay(LEVEL_MESSAGE_INFO,"%s\n",buf);
+    }
 
     std::int64_t bytes_written;
     if(fd_s->state == USERSPACE_FD_STATE_FILE)
@@ -184,10 +197,16 @@ syscall_ret_t sys_write(int fd, const void *buf, size_t count) {
         }
 
         if(bytes_written == 0)
-            return {1,EAGAIN,0};
+            return {1,0,0};
 
+    } else if(fd_s->state == USERSPACE_FD_STATE_EVENTFD) {
+        if(count != 8)
+            return {1,EINVAL,0};
+        std::uint64_t* _8sizebuf = (std::uint64_t*)buf;
+        bytes_written = fd_s->eventfd->write(*_8sizebuf);
     } else
         return {1,EBADF,0};
+        
 
     return {1,bytes_written >= 0 ? 0 : (int)(+bytes_written), bytes_written};
 }
@@ -207,6 +226,8 @@ syscall_ret_t sys_seek(int fd, long offset, int whence) {
     if(fd_s->state == USERSPACE_FD_STATE_PIPE || fd_s->is_a_tty)
         return {1,0,0};
 
+    proc->fd_lock.lock();
+
     switch (whence)
     {
         case SEEK_SET:
@@ -221,17 +242,21 @@ syscall_ret_t sys_seek(int fd, long offset, int whence) {
             vfs::stat_t stat;
             int res = vfs::vfs::stat(fd_s,&stat);
 
-            if(res != 0)
+            if(res != 0) {
+                proc->fd_lock.unlock();
                 return {1,res,0};
-        
+            }
+
             fd_s->offset = stat.st_size + offset;
             break;
         }
 
         default:
+            proc->fd_lock.unlock();
             return {1,EINVAL,0};
     }
 
+    proc->fd_lock.unlock();
     return {1,0,(std::int64_t)fd_s->offset};
 
 }
@@ -245,26 +270,37 @@ syscall_ret_t sys_close(int fd) {
     else if(fd < 3 && !fd_s)
         return {0,0,0}; // ignoring
 
-    DEBUG(0,"Closing %s\n",fd_s->path);
+    DEBUG(proc->is_debug,"closing %d from proc %d",fd,proc->id);
 
     if(fd_s->can_be_closed)
         return {0,EBADF,0};
 
+    proc->fd_lock.lock();
+
     if(fd < 3)
         fd_s->can_be_closed = 1;
 
     if(fd_s->state == USERSPACE_FD_STATE_PIPE) {
         fd_s->pipe->close(fd_s->pipe_side);
     } else if(fd_s->state == USERSPACE_FD_STATE_FILE || fd_s->state == USERSPACE_FD_STATE_SOCKET)
-        vfs::vfs::close(fd_s);
+        vfs::vfs::close(fd_s); 
+    else if(fd_s->state == USERSPACE_FD_STATE_EVENTFD)
+        fd_s->eventfd->close();
 
     if(!fd_s->is_a_tty && fd_s->index > 2)
         fd_s->state = USERSPACE_FD_STATE_UNUSED;
 
+    proc->fd_lock.unlock();
+
     return {0,0,0};
 }
 
-syscall_ret_t sys_stat(int fd, void* out, int flags) {
+typedef struct stackframe {
+    struct stackframe* rbp;
+    uint64_t rip;
+} __attribute__((packed)) stackframe_t;
+
+syscall_ret_t sys_stat(int fd, void* out, int flags, int_frame_t* ctx) {
     arch::x86_64::process_t* proc = CURRENT_PROC;
     userspace_fd_t* fd_s = vfs::fdmanager::search(proc,fd);
 
@@ -274,6 +310,7 @@ syscall_ret_t sys_stat(int fd, void* out, int flags) {
     DEBUG(proc->is_debug,"Trying to stat %s (fd %d) from proc %d",fd_s->path,fd,proc->id);
 
     if(fd_s->state == USERSPACE_FD_STATE_FILE) {
+
         vfs::stat_t stat;
         int status;
         if(flags & AT_SYMLINK_NOFOLLOW) 
@@ -326,11 +363,16 @@ syscall_ret_t sys_dup(int fd, int flags) {
     if(!fd_s)
         return {0,EBADF,0};
     
+    proc->fd_lock.lock();
+
+    int i = 0;
     userspace_fd_t* nfd_s = vfs::fdmanager::searchlowest(proc,0);
 
     if(!nfd_s) {
+        proc->fd_lock.unlock();
         int new_fd = vfs::fdmanager::create(proc);
         nfd_s = vfs::fdmanager::search(proc,new_fd);
+        i = 1;
     }
 
     DEBUG(proc->is_debug,"dup from %d to %d",fd,nfd_s->index);
@@ -348,11 +390,17 @@ syscall_ret_t sys_dup(int fd, int flags) {
     nfd_s->can_be_closed = 0;
     nfd_s->write_socket_pipe = fd_s->write_socket_pipe;
     nfd_s->read_socket_pipe = fd_s->read_socket_pipe;
+    nfd_s->eventfd = fd_s->eventfd;
 
     memcpy(nfd_s->path,fd_s->path,sizeof(fd_s->path));
 
-    if(nfd_s->state ==USERSPACE_FD_STATE_PIPE)
+    if(nfd_s->state == USERSPACE_FD_STATE_PIPE)
         nfd_s->pipe->create(nfd_s->pipe_side);
+    else if(nfd_s->state == USERSPACE_FD_STATE_EVENTFD)
+        nfd_s->eventfd->create();
+
+    if(i == 0)
+        proc->fd_lock.unlock();
 
     return {1,0,nfd_s->index};
 }
@@ -372,6 +420,8 @@ syscall_ret_t sys_dup2(int fd, int flags, int newfd) {
     } else {
         if(nfd_s->state == USERSPACE_FD_STATE_PIPE) 
             nfd_s->pipe->close(nfd_s->pipe_side);
+        else if(nfd_s->state == USERSPACE_FD_STATE_EVENTFD)
+            nfd_s->eventfd->close();
     }
 
     nfd_s->index = newfd;
@@ -388,9 +438,12 @@ syscall_ret_t sys_dup2(int fd, int flags, int newfd) {
     nfd_s->can_be_closed = fd_s->can_be_closed;
     nfd_s->read_socket_pipe = fd_s->read_socket_pipe;
     nfd_s->write_socket_pipe = fd_s->write_socket_pipe;
+    nfd_s->eventfd = fd_s->eventfd;
 
     if(nfd_s->state == USERSPACE_FD_STATE_PIPE)
         nfd_s->pipe->create(nfd_s->pipe_side);
+    else if(nfd_s->state == USERSPACE_FD_STATE_EVENTFD)
+        nfd_s->eventfd->create();
 
     memcpy(nfd_s->path,fd_s->path,sizeof(fd_s->path));
 
@@ -589,7 +642,7 @@ syscall_ret_t sys_fcntl(int fd, int request, std::uint64_t arg) {
     arch::x86_64::process_t* pproc = CURRENT_PROC;
     switch(request) {
         case F_DUPFD: {
-            return sys_dup(fd,arg);
+            return sys_dup(fd,0);
         }
 
         case F_GETFL: {
@@ -610,21 +663,9 @@ syscall_ret_t sys_fcntl(int fd, int request, std::uint64_t arg) {
 
             fd_s->flags &= ~(O_APPEND | O_ASYNC | O_NONBLOCK);
             fd_s->flags |= (arg & (O_APPEND | O_ASYNC | O_NONBLOCK));
-
-            if(fd_s->state == USERSPACE_FD_STATE_PIPE) {
-                fd_s->pipe->flags & ~(O_NONBLOCK);
-                fd_s->pipe->flags |= (arg & O_NONBLOCK);
-            } else if(fd_s->state == USERSPACE_FD_STATE_SOCKET) {
-                if(fd_s->read_socket_pipe) {
-                    fd_s->read_socket_pipe->flags & ~(O_NONBLOCK);
-                    fd_s->read_socket_pipe->flags |= (arg & O_NONBLOCK);
-                }
-
-                if(fd_s->write_socket_pipe) {
-                    fd_s->write_socket_pipe->flags & ~(O_NONBLOCK);
-                    fd_s->write_socket_pipe->flags |= (arg & O_NONBLOCK);
-                }
-
+            if(fd_s->state == USERSPACE_FD_STATE_EVENTFD) {
+                fd_s->eventfd->flags &= ~(O_NONBLOCK);
+                fd_s->eventfd->flags |= (arg & O_NONBLOCK);
             }
 
             return {1,0,0};
@@ -733,7 +774,7 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
         fd[i].revents = 0;
         
 
-        if(!fd0) { fd[i].events = 0; fd[i].revents = POLLNVAL; }
+        if(!fd0) { return {1,EBADF,0};}
 
         if(fd[i].events & POLLIN)
             total_events++;
@@ -747,7 +788,7 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
         if(proc->is_debug) {
             poll_to_str(fd[i].events,out);
 
-            DEBUG(proc->is_debug,"Trying to poll %s (%d) timeout %d event %s from proc %d",fd0->state == USERSPACE_FD_STATE_FILE ? fd0->path : "Not file",fd0->index,timeout,out,proc->id);
+            DEBUG(proc->is_debug,"Trying to poll %s (%d) timeout %d event %s with state %d from proc %d (%s)",fd0->state == USERSPACE_FD_STATE_FILE ? fd0->path : "Not file",fd0->index,timeout,out,fd0->state,proc->id,proc->name);
          
         }   
     }
@@ -759,110 +800,6 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
 
     int retry = 0;
 
-    if(1) {
-        for(int i = 0;i < count; i++) {
-            userspace_fd_t* fd0 = vfs::fdmanager::search(proc,fd[i].fd);
-            if(fd[i].events & POLLIN) {
-
-                if(fd0->state == USERSPACE_FD_STATE_SOCKET && !fd0->is_listen) {
-                        int if_pollin = 0;
-                        fd0->write_socket_pipe->lock.lock();
-                        fd0->read_socket_pipe->lock.lock();
-                        if(fd0->other_state == USERSPACE_FD_OTHERSTATE_MASTER) {
-                            if_pollin = fd0->write_socket_pipe->size > 0 ? 1 : 0;
-                        } else {
-                            if_pollin = fd0->read_socket_pipe->size > 0 ? 1 : 0;
-                        }
-                        if(if_pollin) {
-                            //DEBUG(proc->id == 17 && fd0->index < 40,"polin done fd %d writ sock 0x%p",fd0->index,fd0->write_socket_pipe);
-                            num_events++;
-                            fd[i].revents |= POLLIN;
-                        }
-                        fd0->write_socket_pipe->lock.unlock();
-                        fd0->read_socket_pipe->lock.unlock();
-                    } else if(fd0->state == USERSPACE_FD_STATE_SOCKET && fd0->is_listen) {
-                        if(fd0->read_counter == -1)
-                            fd0->read_counter = 0;
-                        if(sockets::find(fd0->path)->socket_counter > fd0->read_counter) {
-                            fd0->read_counter++;
-                            num_events++;
-                            fd[i].revents |= POLLIN;
-                        }
-                    } else if(fd0->state == USERSPACE_FD_STATE_PIPE) {
-                        if(fd0->pipe_side != PIPE_SIDE_READ)
-                            continue;
-                        fd0->pipe->lock.lock();
-                        if(fd0->pipe->size > 0) {
-                            num_events++;
-                            fd[i].revents |= POLLIN; 
-                        }
-                        fd0->pipe->lock.unlock();
-                    } else {
-
-                        std::int64_t ret = vfs::vfs::poll(fd0,POLLIN);
-
-                        if(ret != 0) {
-                            num_events++;
-                            fd[i].revents |= POLLIN;
-                        }
-                    }
-            }
-
-            if(fd[i].events & POLLOUT) {
-                    if(fd0->state == USERSPACE_FD_STATE_SOCKET) {
-                        fd0->write_socket_pipe->lock.lock();
-                        fd0->read_socket_pipe->lock.lock();
-                        int is_pollout = 0;
-                        if(fd0->other_state == USERSPACE_FD_OTHERSTATE_MASTER) {
-                            if(fd0->read_socket_pipe->size < fd0->read_socket_pipe->total_size)
-                                is_pollout = 1;
-                        } else {
-                            if(fd0->write_socket_pipe->size < fd0->write_socket_pipe->total_size)
-                                is_pollout = 1;
-                        }
-
-                        if(is_pollout) {
-                            num_events++;
-                            fd[i].revents |= POLLOUT;
-                        }
-
-                        fd0->write_socket_pipe->lock.unlock();
-                        fd0->read_socket_pipe->lock.unlock();
-                    } else if(fd0->state == USERSPACE_FD_STATE_PIPE) {
-                        if(fd0->pipe_side != PIPE_SIDE_READ)
-                            continue;
-                        fd0->pipe->lock.lock();
-                        if(fd0->pipe->size < fd0->pipe->total_size) {
-                            num_events++;
-                            fd[i].revents |= POLLOUT;
-                        }
-                        fd0->pipe->lock.unlock();
-                    } else {
-                        std::int64_t ret = vfs::vfs::poll(fd0,POLLOUT);
-                            
-                        if(ret != 0) {
-                            num_events++;
-                            fd[i].revents |= POLLOUT;
-                        }
-                    }
-
-                }
-
-            if(num_events)
-                success = false;
-        }
-    }
-
-    if(success == false) {
-        DEBUG(proc->is_debug,"Poll done (optimization) from proc %d",proc->id);
-        //copy_in_userspace(proc,fds,fd,count * sizeof(struct pollfd));
-        vfs::vfs::unlock();
-        return {1,0,num_events};
-    }
-
-    success = true;
-    num_events = 0;
-
     int is_first = 1;
 
     if(timeout == -1) {
@@ -881,6 +818,7 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
                         int if_pollin = 0;
                         fd0->write_socket_pipe->lock.lock();
                         fd0->read_socket_pipe->lock.lock();
+
                         if(fd0->other_state == USERSPACE_FD_OTHERSTATE_MASTER) {
                             if_pollin = fd0->write_socket_pipe->size > 0 ? 1 : 0;
                         } else {
@@ -891,6 +829,12 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
                             num_events++;
                             fd[i].revents |= POLLIN;
                         }
+
+                        if(fd0->write_socket_pipe->is_closed.test() && !if_pollin) {
+                            num_events++;
+                            fd[i].revents |= POLLHUP;
+                        }
+
                         fd0->write_socket_pipe->lock.unlock();
                         fd0->read_socket_pipe->lock.unlock();
                     } else if(fd0->state == USERSPACE_FD_STATE_SOCKET && fd0->is_listen) {
@@ -910,6 +854,13 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
                             fd[i].revents |= POLLIN; 
                         }
                         fd0->pipe->lock.unlock();
+                    } else if(fd0->state == USERSPACE_FD_STATE_EVENTFD) {
+                        fd0->eventfd->lock.lock();
+                        if(fd0->eventfd->buffer > 0) {
+                            num_events++;
+                            fd[i].revents |= POLLIN; 
+                        }
+                        fd0->eventfd->lock.unlock();
                     } else {
 
                         std::int64_t ret = vfs::vfs::poll(fd0,POLLIN);
@@ -940,6 +891,13 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
 
                         fd0->write_socket_pipe->lock.unlock();
                         fd0->read_socket_pipe->lock.unlock();
+                    } else if(fd0->state == USERSPACE_FD_STATE_EVENTFD) {
+                        fd0->eventfd->lock.lock();
+                        if(fd0->eventfd->buffer <= (0xFFFFFFFFFFFFFFFF - 1)) {
+                            num_events++;
+                            fd[i].revents |= POLLOUT;
+                        }
+                        fd0->eventfd->lock.unlock();
                     } else if(fd0->state == USERSPACE_FD_STATE_PIPE) {
                         if(fd0->pipe_side != PIPE_SIDE_READ)
                             continue;
@@ -991,6 +949,8 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
                         int if_pollin = 0;
                         fd0->write_socket_pipe->lock.lock();
                         fd0->read_socket_pipe->lock.lock();
+
+                        
                         if(fd0->other_state == USERSPACE_FD_OTHERSTATE_MASTER) {
                             if_pollin = fd0->write_socket_pipe->size > 0 ? 1 : 0;
                         } else {
@@ -1001,6 +961,12 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
                             num_events++;
                             fd[i].revents |= POLLIN;
                         }
+
+                        if(fd0->write_socket_pipe->is_closed.test() && !if_pollin) {
+                            num_events++;
+                            fd[i].revents |= POLLHUP;
+                        }
+
                         fd0->write_socket_pipe->lock.unlock();
                         fd0->read_socket_pipe->lock.unlock();
                     } else if(fd0->state == USERSPACE_FD_STATE_SOCKET && fd0->is_listen) {
@@ -1018,6 +984,13 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
                             fd[i].revents |= POLLIN; 
                         }
                         fd0->pipe->lock.unlock();
+                    } else if(fd0->state == USERSPACE_FD_STATE_EVENTFD) {
+                        fd0->eventfd->lock.lock();
+                        if(fd0->eventfd->buffer > 0) {
+                            num_events++;
+                            fd[i].revents |= POLLIN; 
+                        }
+                        fd0->eventfd->lock.unlock();
                     } else {
 
                         std::int64_t ret = vfs::vfs::poll(fd0,POLLIN);
@@ -1051,6 +1024,13 @@ syscall_ret_t sys_poll(struct pollfd *fds, int count, int timeout) {
 
                         fd0->write_socket_pipe->lock.unlock();
                         fd0->read_socket_pipe->lock.unlock();
+                    } else if(fd0->state == USERSPACE_FD_STATE_EVENTFD) {
+                        fd0->eventfd->lock.lock();
+                        if(fd0->eventfd->buffer <= (0xFFFFFFFFFFFFFFFF - 1)) {
+                            num_events++;
+                            fd[i].revents |= POLLOUT;
+                        }
+                        fd0->eventfd->lock.unlock();
                     } else if(fd0->state == USERSPACE_FD_STATE_PIPE) {
                         fd0->pipe->lock.lock();
                         if(fd0->pipe->size < fd0->pipe->total_size) {
@@ -1189,6 +1169,8 @@ syscall_ret_t sys_mkdirat(int dirfd, char* path, int mode) {
 
     int ret = vfs::vfs::create(result,VFS_TYPE_DIRECTORY);
 
+    //DEBUG(1,"mkdir %s %d\n",result,ret);
+
     userspace_fd_t fd;
     fd.is_cached_path = 0;
     memcpy(fd.path,result,2048);
@@ -1212,6 +1194,8 @@ syscall_ret_t sys_chmod(char* path, int mode) {
     memset(&fd,0,sizeof(fd));
     memcpy(fd.path,result,2048);
 
+    DEBUG(1,"chmod %s %d\n",path,mode);
+
     uint64_t value;
     int ret = vfs::vfs::var(&fd,(uint64_t)&value,TMPFS_VAR_CHMOD);
 
@@ -1284,4 +1268,294 @@ syscall_ret_t sys_rename(char* old, char* newp) {
     int status = vfs::vfs::rename(old_path,new_path);
 
     return {0,status,0};
+}
+
+typedef __SIZE_TYPE__    __mlibc_size;
+
+struct iovec {
+	void *iov_base;
+	__mlibc_size iov_len;
+};
+
+typedef unsigned socklen_t;
+
+struct msghdr {
+	void *msg_name;
+	socklen_t msg_namelen;
+	struct iovec *msg_iov;
+#if __INTPTR_WIDTH__ == 64 && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+	int __pad0;
+#endif
+	int msg_iovlen;
+#if __INTPTR_WIDTH__ == 64 && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+	int __pad0;
+#endif
+	void *msg_control;
+#if __INTPTR_WIDTH__ == 64 && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+	int __pad1;
+#endif
+	socklen_t msg_controllen;
+#if __INTPTR_WIDTH__ == 64 && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+	int __pad1;
+#endif
+	int msg_flags;
+};
+
+struct cmsghdr {
+#if __INTPTR_WIDTH__ == 64 && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+	int __pad;
+#endif
+	socklen_t cmsg_len;
+#if __INTPTR_WIDTH__ == 64 && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+	int __pad;
+#endif
+	int cmsg_level;
+	int cmsg_type;
+};
+
+#define SOL_SOCKET      1
+
+#define SCM_RIGHTS 1
+#define SCM_CREDENTIALS 2
+
+#define __CMSG_ALIGN(s) (((s) + __alignof__(size_t) - 1) & \
+		~(__alignof__(size_t) - 1))
+
+#if defined(_DEFAULT_SOURCE)
+#define CMSG_ALIGN(s) __CMSG_ALIGN(s)
+#endif /* defined(_DEFAULT_SOURCE) */
+
+/* Basic macros to return content and padding size of a control message. */
+#define CMSG_LEN(s) (__CMSG_ALIGN(sizeof(struct cmsghdr)) + (s))
+#define CMSG_SPACE(s) (__CMSG_ALIGN(sizeof(struct cmsghdr)) + __CMSG_ALIGN(s))
+
+/* Provides access to the data of a control message. */
+#define CMSG_DATA(c) ((unsigned char *)(c) + __CMSG_ALIGN(sizeof(struct cmsghdr)))
+
+#define __MLIBC_CMSG_NEXT(c) ((char *)(c) + __CMSG_ALIGN((c)->cmsg_len))
+#define __MLIBC_MHDR_LIMIT(m) ((char *)(m)->msg_control + (m)->msg_controllen)
+
+/* For parsing control messages only. */
+/* Returns a pointer to the first header or nullptr if there is none. */
+#define CMSG_FIRSTHDR(m) ((size_t)(m)->msg_controllen <= sizeof(struct cmsghdr) \
+	? (struct cmsghdr *)0 : (struct cmsghdr *) (m)->msg_control)
+
+/* For parsing control messages only. */
+/* Returns a pointer to the next header or nullptr if there is none. */
+#define CMSG_NXTHDR(m, c) \
+	((c)->cmsg_len < sizeof(struct cmsghdr) || \
+		(std::int64_t)(sizeof(struct cmsghdr) + __CMSG_ALIGN((c)->cmsg_len)) \
+			>= __MLIBC_MHDR_LIMIT(m) - (char *)(c) \
+	? (struct cmsghdr *)0 : (struct cmsghdr *)__MLIBC_CMSG_NEXT(c))
+
+syscall_ret_t sys_msg_send(int fd, struct msghdr* hdr, int flags) {
+    struct msghdr* msg = hdr;
+    SYSCALL_IS_SAFEA(hdr,sizeof(struct msghdr));
+    
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+
+    userspace_fd_t* fd_s = vfs::fdmanager::search(proc,fd);
+    if(!fd_s)
+        return {1,EBADF,0};
+
+    vfs::pipe* target_pipe = fd_s->other_state == USERSPACE_FD_OTHERSTATE_MASTER ? fd_s->read_socket_pipe : fd_s->write_socket_pipe;
+    if(!target_pipe)
+        return {1,EBADF,0};
+
+    std::uint64_t total_size = 0;
+    for (int i = 0; i < hdr->msg_iovlen; i++) {
+        SYSCALL_IS_SAFEA(hdr->msg_iov[i].iov_base,hdr->msg_iov[i].iov_len);
+        total_size += hdr->msg_iov[i].iov_len;
+    }
+
+    if(total_size > target_pipe->total_size)
+        return {1,EMSGSIZE,0};
+
+    target_pipe->lock.lock();
+    std::uint64_t space_left = target_pipe->total_size - target_pipe->size;
+    target_pipe->lock.unlock();
+    while(space_left < total_size) {
+        yield();
+        target_pipe->lock.lock();
+        space_left = target_pipe->total_size - target_pipe->size;
+        target_pipe->lock.unlock();
+    }
+
+    target_pipe->lock.lock();
+
+    struct cmsghdr *cmsg = 0;
+
+    for (cmsg = CMSG_FIRSTHDR(msg);
+        cmsg != NULL;
+        cmsg = CMSG_NXTHDR(msg, cmsg)) {
+             Log::SerialDisplay(LEVEL_MESSAGE_FAIL,"hello %d\n",cmsg->cmsg_type);
+        
+        if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
+            DEBUG(1,"scm\n");
+            int new_fd = 0;
+            memcpy(&new_fd, CMSG_DATA(cmsg), sizeof(int));
+
+            userspace_fd_t* fd_s1 = vfs::fdmanager::search(proc,new_fd);
+
+            if(!fd_s1) {
+                break;
+            }
+
+            proc->pass_fd->push(fd_s1);
+            target_pipe->fd_pass = (void*)proc->pass_fd; // transfer
+        
+        } else if(cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_CREDENTIALS) {
+            target_pipe->ucred_pass->push((struct ucred*)CMSG_DATA(cmsg));
+        }
+    }
+
+    std::int64_t total_written = 0;
+
+    for (int i = 0; i < hdr->msg_iovlen; i++) {
+        std::int64_t sent_bytes = target_pipe->nolock_write((const char*)hdr->msg_iov[i].iov_base,hdr->msg_iov[i].iov_len,0);
+        if(sent_bytes < 0) {
+            target_pipe->lock.unlock();
+            return {1,+sent_bytes,0};
+        }
+        total_written += sent_bytes;
+        if (sent_bytes < hdr->msg_iov[i].iov_len) {
+            break; 
+        }
+    }
+
+    DEBUG(proc->is_debug,"msg_send fd %d total_written %lli flags %d from proc %d\n",fd,total_written,flags,proc->id);
+
+    target_pipe->lock.unlock();
+    return {1,0,total_written};
+}
+
+syscall_ret_t sys_msg_recv(int fd, struct msghdr *hdr, int flags) {
+    struct msghdr* msg = hdr;
+    SYSCALL_IS_SAFEA(hdr,4096);
+    
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+
+    userspace_fd_t* fd_s = vfs::fdmanager::search(proc,fd);
+    if(!fd_s)
+        return {1,EBADF,0};
+
+    vfs::pipe* target_pipe = fd_s->other_state == USERSPACE_FD_OTHERSTATE_MASTER ? fd_s->write_socket_pipe : fd_s->read_socket_pipe;
+    if(!target_pipe)
+        return {1,EBADF,0};
+
+    std::uint64_t total_size = 0;
+    for (int i = 0; i < hdr->msg_iovlen; i++) {
+        SYSCALL_IS_SAFEA(hdr->msg_iov[i].iov_base,hdr->msg_iov[i].iov_len);
+        total_size += hdr->msg_iov[i].iov_len;
+    }
+
+    std::int64_t total_read = 0;
+
+    for (int i = 0; i < hdr->msg_iovlen; i++) {
+        std::int64_t recv_bytes = 0;
+        recv_bytes = target_pipe->read(&fd_s->read_counter,(char*)hdr->msg_iov[i].iov_base,hdr->msg_iov[i].iov_len,((fd_s->flags & O_NONBLOCK) ? 1 : 0));
+        if(recv_bytes == -EAGAIN) {
+            return {1,EAGAIN,0}; 
+        } else if(recv_bytes == -EAGAIN)
+            break; // just dont continue 
+        total_read += recv_bytes;
+    }
+
+    socklen_t new_msglen = 0;
+    socklen_t src_msglen = hdr->msg_controllen;
+
+    struct cmsghdr* cmsg = 0;
+
+    target_pipe->lock.lock();
+    for (cmsg = CMSG_FIRSTHDR(msg);
+        cmsg != 0;
+        cmsg = CMSG_NXTHDR(msg, cmsg)) {
+        if (1) {
+            int *fd_ptr = (int *) CMSG_DATA(cmsg);
+            userspace_fd_t fd_s1;
+            memset(&fd_s1,0,sizeof(userspace_fd_t));
+            vfs::passingfd_manager* pasfd = (vfs::passingfd_manager*)target_pipe->fd_pass;
+            if(pasfd != 0) {
+                if(pasfd->pop(&fd_s1) == 0) {
+                    cmsg->cmsg_level = SOL_SOCKET;
+                    cmsg->cmsg_type = SCM_RIGHTS;
+                    cmsg->cmsg_len = 24;
+                    new_msglen += 24;
+                    int new_fd = vfs::fdmanager::create(proc);
+                    userspace_fd_t* nfd_s = vfs::fdmanager::search(proc,new_fd);
+
+                    nfd_s->cycle = fd_s1.cycle;
+                    nfd_s->offset = fd_s1.offset;
+                    nfd_s->state = fd_s1.state;
+                    nfd_s->other_state = fd_s1.other_state;
+                    nfd_s->pipe = fd_s1.pipe;
+                    nfd_s->pipe_side = fd_s1.pipe_side;
+                    nfd_s->queue = fd_s1.queue;
+                    nfd_s->is_a_tty = fd_s1.is_a_tty;
+                    nfd_s->read_counter = fd_s1.read_counter;
+                    nfd_s->write_counter = fd_s1.write_counter;
+                    nfd_s->can_be_closed = 0;
+                    nfd_s->write_socket_pipe = fd_s1.write_socket_pipe;
+                    nfd_s->read_socket_pipe = fd_s1.read_socket_pipe;
+                    nfd_s->eventfd = fd_s1.eventfd;
+
+                   
+                    memcpy(nfd_s->path,fd_s1.path,sizeof(fd_s1.path));
+
+                    memcpy(CMSG_DATA(cmsg), &new_fd, sizeof(int));
+                    if(nfd_s->state == USERSPACE_FD_STATE_PIPE)
+                        nfd_s->pipe->create(nfd_s->pipe_side);
+                    else if(nfd_s->state == USERSPACE_FD_STATE_EVENTFD)
+                        nfd_s->eventfd->create();
+                } 
+            } else {
+                // fd pass is more important than ucred
+                if(target_pipe->ucred_pass->pop((struct ucred*)CMSG_DATA(cmsg)) == 0) {
+                    DEBUG(1,"ucred pass");
+                    cmsg->cmsg_level = SOL_SOCKET;
+                    cmsg->cmsg_type = SCM_CREDENTIALS;
+                    cmsg->cmsg_len = 28;
+                    new_msglen += 28;
+                }
+            }
+
+        }
+    }
+
+    if(new_msglen != 0) {
+        target_pipe->fd_pass = 0; // clear
+        target_pipe->lock.unlock();
+    } else
+        target_pipe->lock.unlock();
+
+    target_pipe->lock.unlock();
+    hdr->msg_controllen = new_msglen;
+
+    DEBUG(proc->is_debug,"msg_recv fd %d total_read %lli flags %d from proc %d, controllen %d srclen %d\n",fd,total_read,flags,proc->id,hdr->msg_controllen,src_msglen);
+    return {1,0,total_read};
+}
+
+syscall_ret_t sys_eventfd_create(unsigned int initval, int flags) {
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+
+    int new_fd = vfs::fdmanager::create(proc);
+
+    userspace_fd_t* new_fd_s = vfs::fdmanager::search(proc,new_fd);
+    memset(new_fd_s->path,0,2048);
+
+    new_fd_s->offset = 0;
+    new_fd_s->queue = 0;
+    new_fd_s->pipe = 0;
+    new_fd_s->pipe_side = 0;
+    new_fd_s->cycle = 0;
+    new_fd_s->is_a_tty = 0;
+
+    new_fd_s->state = USERSPACE_FD_STATE_EVENTFD;
+    new_fd_s->eventfd = new vfs::eventfd(initval,flags);
+
+    new_fd_s->eventfd->create();
+
+    DEBUG(proc->is_debug,"Creating eventfd %d from proc %d, proc->fd 0x%p",new_fd,proc->id,proc->fd);
+
+    return {1,0,new_fd};
 }
\ No newline at end of file
diff --git a/kernel/src/arch/x86_64/syscalls/futex.cpp b/kernel/src/arch/x86_64/syscalls/futex.cpp
index beb0d12..3f7968c 100644
--- a/kernel/src/arch/x86_64/syscalls/futex.cpp
+++ b/kernel/src/arch/x86_64/syscalls/futex.cpp
@@ -3,21 +3,43 @@
 #include <arch/x86_64/syscalls/syscalls.hpp>
 #include <arch/x86_64/cpu/data.hpp>
 #include <arch/x86_64/scheduling.hpp>
+#include <generic/vfs/vfs.hpp>
+#include <drivers/tsc.hpp>
 
-syscall_ret_t sys_futex_wait(int* pointer, int excepted) {
+syscall_ret_t sys_futex_wait(int* pointer, int excepted, struct timespec* ts) {
 
     arch::x86_64::process_t* proc = arch::x86_64::cpu::data()->temp.proc; 
+
+    std::uint64_t t = 0;
+    if(ts) {
+        t = (ts->tv_sec * (1000 * 1000)) + (ts->tv_nsec / 1000);
+        t += drivers::tsc::currentus();
+    }
+
+    if(*pointer != excepted)
+        return {0,EAGAIN,0};
+
     int copied_pointer_val = 0;
     copy_in_userspace(proc,&copied_pointer_val,pointer,sizeof(int));
-    //DEBUG(1,"Waiting for futex, pointer: 0x%p excepted: %d, pointer_value %d in proc %d",pointer,excepted,copied_pointer_val,proc->id);
-    arch::x86_64::scheduling::futexwait(proc,&copied_pointer_val,excepted,pointer);
+    DEBUG(proc->is_debug,"Waiting for futex, pointer: 0x%p excepted: %d, pointer_value %d in proc %d, ts->tv_nsec %lli ts->tv_sec %lli",pointer,excepted,copied_pointer_val,proc->id,ts != nullptr ? ts->tv_nsec : 0, ts != nullptr ? ts->tv_sec : 0);
+    
+    arch::x86_64::scheduling::futexwait(proc,&copied_pointer_val,excepted,pointer,t);
     yield();
+
+    if(ts) {
+        if(proc->ts == 0) {
+            proc->ts = 0;
+            Log::SerialDisplay(LEVEL_MESSAGE_WARN,"futexwait timeout\n");
+            return {0,ETIMEDOUT,0};
+        }
+    }
+
     return {0,0,0};
 }
 
 syscall_ret_t sys_futex_wake(int* pointer) {
     arch::x86_64::process_t* proc = arch::x86_64::cpu::data()->temp.proc; 
-    //DEBUG(1,"Wakeup futex with pointer 0x%p in proc %d",pointer,proc->id);
-    arch::x86_64::scheduling::futexwake(proc,pointer);
+    DEBUG(proc->is_debug,"Wakeup futex with pointer 0x%p in proc %d",pointer,proc->id);
+    int c = arch::x86_64::scheduling::futexwake(proc,pointer);
     return {0,0,0};
 }
diff --git a/kernel/src/arch/x86_64/syscalls/process.cpp b/kernel/src/arch/x86_64/syscalls/process.cpp
index d5c638b..1b19c01 100644
--- a/kernel/src/arch/x86_64/syscalls/process.cpp
+++ b/kernel/src/arch/x86_64/syscalls/process.cpp
@@ -42,7 +42,7 @@ syscall_ret_t sys_libc_log(const char* msg) {
     char buffer[2048];
     memset(buffer,0,2048);
     copy_in_userspace_string(proc,buffer,(void*)msg,2048);
-    DEBUG(proc->is_debug,"%s from proc %d",buffer,proc->id);
+    DEBUG(1,"%s from proc %d",buffer,proc->id);
 
     return {0,0,0};
 }
@@ -54,26 +54,16 @@ syscall_ret_t sys_exit(int status) {
     arch::x86_64::process_t* proc = CURRENT_PROC;
     proc->exit_code = status;
 
-    userspace_fd_t* fd = proc->fd;
-    while(fd) {
-        if(!fd->can_be_closed) {
-            if(fd->state == USERSPACE_FD_STATE_PIPE)
-                fd->pipe->close(fd->pipe_side);
-            else if(fd->state == USERSPACE_FD_STATE_FILE || fd->state == USERSPACE_FD_STATE_SOCKET)
-                vfs::vfs::close(fd);
-        }
-        userspace_fd_t* next = fd->next;
-        delete (void*)fd;
-        fd = next;
-    }
-
-      DEBUG(proc->is_debug,"Process %s (%d) exited with code %d",proc->name,proc->id,status);
+    DEBUG(proc->is_debug,"Process %s (%d) exited with code %d",proc->name,proc->id,status);
 
     arch::x86_64::scheduling::kill(proc);
     
     if(1)
         memory::vmm::free(proc); 
 
+    vfs::fdmanager* fd = (vfs::fdmanager*)proc->fd;
+    fd->free();
+
     memory::pmm::_virtual::free(proc->cwd);
     memory::pmm::_virtual::free(proc->name);
     memory::pmm::_virtual::free(proc->sse_ctx);
@@ -91,13 +81,17 @@ syscall_ret_t sys_mmap(std::uint64_t hint, std::uint64_t size, int fd0, int_fram
     std::uint64_t flags = ctx->r8;
     arch::x86_64::process_t* proc = CURRENT_PROC;
     if(flags & MAP_ANONYMOUS) {
+
         std::uint64_t new_hint = hint;
         int is_shared = (flags & MAP_SHARED) ? 1 : 0;
+
+        if(is_shared) {
+            DEBUG(1,"shared mem\n");
+            asm volatile("hlt");
+        }
+
         if(!new_hint) {
-            if(is_shared) {
-                new_hint = (std::uint64_t)memory::vmm::alloc(proc,size,PTE_PRESENT | PTE_USER | PTE_RW,0);
-            } else 
-                new_hint = (std::uint64_t)memory::vmm::alloc(proc,size,PTE_PRESENT | PTE_USER | PTE_RW,0);
+            new_hint = (std::uint64_t)memory::vmm::lazy_alloc(proc,size,PTE_PRESENT | PTE_USER | PTE_RW,0);
         } else 
             memory::vmm::customalloc(proc,new_hint,size,PTE_PRESENT | PTE_RW | PTE_USER,0);
 
@@ -154,17 +148,7 @@ syscall_ret_t sys_mmap(std::uint64_t hint, std::uint64_t size, int fd0, int_fram
 syscall_ret_t sys_free(void *pointer, size_t size) {
 
     arch::x86_64::process_t* proc = CURRENT_PROC;
-    std::uint64_t phys = memory::vmm::get(proc,(std::uint64_t)pointer)->phys;
-    vmm_obj_t* current = memory::vmm::get(proc, (std::uint64_t)pointer);
-    vmm_obj_t* start = (vmm_obj_t*)proc->vmm_start;
-    
-    start->lock.lock();
-    memory::pmm::_physical::free(current->phys);
-    start->lock.unlock();
-    
-    memory::paging::maprangeid(proc->original_cr3,0,(std::uint64_t)current->base,0,0,0);
-    current->phys = 0;
-    current->is_free = 1;
+    memory::vmm::unmap(proc,(std::uint64_t)pointer);
     
     return {0,0,0};
 }
@@ -179,7 +163,7 @@ syscall_ret_t sys_fork(int D, int S, int d, int_frame_t* ctx) {
 
     arch::x86_64::scheduling::wakeup(new_proc);
 
-    DEBUG(1,"Fork from proc %d, new proc %d",proc->id,new_proc->id);
+    DEBUG(0,"Fork from proc %d, new proc %d",proc->id,new_proc->id);
     new_proc->is_debug = proc->is_debug;
 
     return {1,0,new_proc->id};
@@ -288,13 +272,14 @@ syscall_ret_t sys_exec(char* path, char** argv, char** envp, int_frame_t* ctx) {
         if((stat.st_mode & S_IXUSR) && (stat.st_mode & S_IFREG)) {
 
             proc->fs_base = 0;
-
-            memset(&proc->ctx,0,sizeof(int_frame_t));
-
+ 
             memory::paging::enablekernel();
             memory::vmm::free(proc);
 
             memory::vmm::initproc(proc);
+
+            memset(&proc->ctx,0,sizeof(int_frame_t));
+
             memory::vmm::reload(proc);
             
             proc->ctx.cs = 0x20 | 3;
@@ -698,4 +683,41 @@ syscall_ret_t sys_dmesg(char* buf,std::uint64_t count) {
     dmesg_read(temp_buffer,count);
 
     return {1,0,0};
+}
+
+syscall_ret_t sys_getuid() {
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+    return {0,proc->uid,0};
+}
+
+syscall_ret_t sys_setuid(int uid) {
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+    if(proc->uid > 1000)
+        return {0,EPERM,0};
+    proc->uid = uid;
+    return {0,0,0};
+}
+
+syscall_ret_t sys_kill(int pid, int sig) {
+
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+    arch::x86_64::process_t* target_proc = arch::x86_64::scheduling::by_pid(pid);
+
+    Log::SerialDisplay(LEVEL_MESSAGE_INFO,"sys_kill pid %d sig %d from proc %d\n",pid,sig,proc->id);
+
+    if(!target_proc)
+        return {0,ESRCH,0};
+
+    if(!(proc->uid == 0 || proc->uid == target_proc->uid))
+        return {0,EPERM,0};
+
+    switch(sig) {
+        case SIGKILL:
+            target_proc->exit_code = 137;
+            target_proc->_3rd_kill_lock.nowaitlock(); 
+            break;
+        default:
+            return {0,0,0};
+    }
+    return {0,0,0};
 }
\ No newline at end of file
diff --git a/kernel/src/arch/x86_64/syscalls/shm.cpp b/kernel/src/arch/x86_64/syscalls/shm.cpp
new file mode 100644
index 0000000..006d798
--- /dev/null
+++ b/kernel/src/arch/x86_64/syscalls/shm.cpp
@@ -0,0 +1,224 @@
+
+#include <arch/x86_64/syscalls/syscalls.hpp>
+#include <generic/vfs/vfs.hpp>
+
+#include <arch/x86_64/cpu/data.hpp>
+#include <arch/x86_64/scheduling.hpp>
+
+#include <generic/mm/pmm.hpp>
+#include <generic/mm/vmm.hpp>
+
+#include <generic/vfs/fd.hpp>
+
+#include <etc/assembly.hpp>
+#include <etc/logging.hpp>
+
+#include <drivers/cmos.hpp>
+
+#include <etc/libc.hpp>
+
+#include <drivers/tsc.hpp>
+
+#include <etc/errno.hpp>
+
+#include <drivers/hpet.hpp>
+#include <drivers/kvmtimer.hpp>
+#include <generic/time.hpp>
+#include <generic/vfs/vfs.hpp>
+
+#include <etc/bootloaderinfo.hpp>
+#include <generic/locks/spinlock.hpp>
+
+static_assert(sizeof(shm_seg_t) < 4096, "shm_seg is bigger than page size !");
+
+locks::spinlock shm_lock;
+shm_seg_t* shm_head;
+
+int shm_id_ptr = 0;
+
+shm_seg_t* shm_find_by_key(int key) {
+    shm_seg_t* current = shm_head;
+    while(current) {
+        if(current->key == key)
+            return current;
+    }
+    return 0;
+}
+
+shm_seg_t* shm_find(int id) {
+    shm_seg_t* current = shm_head;
+    while(current) {
+        if(current->id == id)
+            return current;
+    }
+    return 0;
+}
+
+void shm_rm(shm_seg_t* seg) {
+    shm_seg_t* prev = shm_head;
+    while(prev) {
+        if(prev->next == seg)
+            break;
+        prev = prev->next;
+    }
+    if(prev)
+        prev->next = seg->next;
+    memory::pmm::_physical::free(seg->phys);
+    delete (void*)seg;
+}
+
+shm_seg_t* shm_create(int key, size_t size) {
+    shm_seg_t* new_seg = new shm_seg_t;
+    memset(new_seg,0,sizeof(shm_seg_t));
+    new_seg->next = shm_head;
+    shm_head = new_seg;
+    new_seg->key = key;
+    new_seg->id = shm_id_ptr++;
+    new_seg->len = size;
+    new_seg->phys = memory::pmm::_physical::alloc(new_seg->len);
+    return new_seg;
+}
+
+#define IPC_CREAT 01000
+#define IPC_EXCL 02000
+#define IPC_NOWAIT 04000
+
+syscall_ret_t sys_shmget(int key, size_t size, int shmflg) {
+
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+    std::uint64_t src_size = size;
+
+    if(size < 4096) { 
+        size = 4096; 
+    } else { 
+        size = ALIGNUP(size,4096); 
+    }
+
+    shm_lock.lock();
+
+    shm_seg_t* seg = shm_find_by_key(key);
+
+    shm_lock.unlock();
+
+    if(seg && ((shmflg & IPC_CREAT) && (shmflg & IPC_EXCL)))
+        return {1,EEXIST,0};
+
+    if(!seg && !(shmflg & IPC_CREAT))
+        return {1,ENOENT,0};
+    
+    shm_lock.lock();
+
+    if(shmflg & IPC_CREAT) {
+        seg = shm_create(key,size); 
+        seg->ctl.shm_segsz = src_size;
+        seg->ctl.shm_ctime = getUnixTime();
+        seg->ctl.shm_cpid = proc->id;
+        seg->ctl.shm_perm.cuid = proc->uid;
+        seg->ctl.shm_perm.uid = proc->uid;
+        seg->ctl.shm_perm.mode = shmflg & 0x1FF;
+    }
+
+    DEBUG(proc->is_debug,"Creating/getting shm for proc %d, id %d, size %lli, src_size %d, shmflg %d",proc->id,seg->id,size,src_size,shmflg);
+
+    shm_lock.unlock();
+        
+    return {1,0,seg->id};
+}
+
+// inline static void* map(arch::x86_64::process_t* proc, std::uint64_t base, std::uint64_t length, std::uint64_t flags) {
+
+// inline static void* custom_map(arch::x86_64::process_t* proc, std::uint64_t virt, std::uint64_t phys, std::uint64_t length, std::uint64_t flags) {
+
+syscall_ret_t sys_shmat(int shmid, std::uint64_t hint, int shmflg) {
+
+    shm_lock.lock();
+
+    shm_seg_t* seg = shm_find(shmid);
+
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+
+    if(!seg) { shm_lock.unlock();
+        return {1,EINVAL,0}; }
+
+    std::uint64_t new_hint = hint;
+
+    new_hint = memory::vmm::shm_map(proc,seg,hint);
+
+    memory::paging::enablepaging(proc->original_cr3); // try to reset tlb
+
+    DEBUG(proc->is_debug,"Attaching shm %d to 0x%p, shmflg %d from proc %d",shmid,new_hint,shmflg,proc->id);
+
+    shm_lock.unlock();
+    return {1,0,new_hint};
+}
+
+syscall_ret_t sys_shmdt(std::uint64_t base) {
+
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+
+    shm_lock.lock();
+    vmm_obj_t* vmm_new = memory::vmm::getlen(proc,base);
+
+    if(!vmm_new) { shm_lock.unlock();
+        return {0,EINVAL,0}; }
+
+    if(!vmm_new->shm) {
+        shm_lock.unlock();
+        return {0,EINVAL,0};
+    }
+
+    shm_seg_t* seg = vmm_new->shm;
+    memory::vmm::unmap(proc,vmm_new->base);
+
+    if(seg->ctl.shm_nattch == 0 && seg->is_pending_rm) {
+        shm_rm(seg);
+    }
+
+    DEBUG(proc->is_debug,"Removing shm %d, base 0x%p from proc %d",seg->id,base,proc->id);
+
+    shm_lock.unlock();
+    return {0,0,0};
+}
+
+syscall_ret_t sys_shmctl(int shmid, int cmd, struct shmid_ds *buf) {
+
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+
+    shm_lock.lock();
+
+    shm_seg_t* seg = shm_find(shmid);
+
+    if(!seg) { shm_lock.unlock();
+        return {0,EINVAL,0}; }
+
+    if(!buf) { shm_lock.unlock();
+        return {0,EINVAL,0};
+    }
+
+    switch(cmd) {
+    case IPC_RMID: {
+        seg->is_pending_rm = 1;
+        if(seg->ctl.shm_nattch == 0 && seg->is_pending_rm) {
+            shm_rm(seg);
+        }
+        break;
+    }
+    case IPC_STAT:
+        memcpy(buf,&seg->ctl,sizeof(shmid_ds));
+        break;
+    case IPC_SET:
+        seg->ctl.shm_perm.uid = buf->shm_perm.uid;
+        seg->ctl.shm_perm.gid = buf->shm_perm.gid;
+        seg->ctl.shm_ctime = getUnixTime();
+        seg->ctl.shm_perm.mode = buf->shm_perm.mode;
+        break;
+    default:
+        Log::SerialDisplay(LEVEL_MESSAGE_WARN,"Unknown shmctl cmd %d for id %d from proc %d\n",cmd,shmid,proc->id);
+        break;
+    }
+
+    DEBUG(proc->is_debug,"shmctl id %d cmd %d buf 0x%p from proc %d\n",shmid,cmd,buf,proc->id);
+
+    shm_lock.unlock();
+    return {0,0,0};
+}
\ No newline at end of file
diff --git a/kernel/src/arch/x86_64/syscalls/sockets.cpp b/kernel/src/arch/x86_64/syscalls/sockets.cpp
index 24969a8..093772a 100644
--- a/kernel/src/arch/x86_64/syscalls/sockets.cpp
+++ b/kernel/src/arch/x86_64/syscalls/sockets.cpp
@@ -114,6 +114,8 @@ int sockets::connect(userspace_fd_t* fd, struct sockaddr_un* path) {
     pending->is_accepted.unlock();
     node->pending_list = pending;
 
+    memcpy(fd->path,node->path,strlen(node->path) + 1);
+
     node->socket_counter++;
 
     while(!pending->is_accepted.test()) {  yield();  }
@@ -164,6 +166,12 @@ int sockets::accept(userspace_fd_t* fd, struct sockaddr_un* path) {
                 new_fd_s->read_socket_pipe->create(PIPE_SIDE_WRITE);    
                 new_fd_s->write_socket_pipe->create(PIPE_SIDE_READ);   
                 new_fd_s->write_socket_pipe->create(PIPE_SIDE_WRITE);
+
+                new_fd_s->read_socket_pipe->ucred_pass = new vfs::ucred_manager;
+                new_fd_s->write_socket_pipe->ucred_pass = new vfs::ucred_manager;
+
+                new_fd_s->socket_pid = pending_connections->son->pid;
+                new_fd_s->socket_uid = pending_connections->son->uid;
                 
                 pending_connections->son->read_socket_pipe = new_fd_s->read_socket_pipe;
                 pending_connections->son->write_socket_pipe = new_fd_s->write_socket_pipe;
@@ -211,11 +219,11 @@ syscall_ret_t sys_connect(int fd, struct sockaddr_un* path, int len) {
     memset(&spath,0,sizeof(spath));
     copy_in_userspace(proc,&spath,path,len > sizeof(spath) ? sizeof(spath) : len);
 
-    DEBUG(proc->is_debug,"Trying to connect to socket %s from proc %d",spath.sun_path,proc->id);
+    DEBUG(1,"Trying to connect to socket %s (fd %d) from proc %d",spath.sun_path,fd,proc->id);
 
     int status = sockets::connect(fd_s,&spath);
 
-    DEBUG(proc->is_debug,"Socket is connected %s from proc %d",spath.sun_path,proc->id);
+    DEBUG(1,"Socket is connected %s from proc %d, status %d",spath.sun_path,proc->id,status);
 
     return {0,status,0};
 }
@@ -236,7 +244,7 @@ syscall_ret_t sys_bind(int fd, struct sockaddr_un* path, int len) {
     memset(&spath,0,sizeof(spath));
     copy_in_userspace(proc,&spath,path,len > sizeof(spath) ? sizeof(spath) : len);
 
-    DEBUG(proc->is_debug,"Binding socket from fd %d to %s from proc %d",fd,spath.sun_path,proc->id);
+    DEBUG(1,"Binding socket from fd %d to %s from proc %d",fd,spath.sun_path,proc->id);
 
     int status = sockets::bind(fd_s,&spath);
 
@@ -270,13 +278,22 @@ syscall_ret_t sys_accept(int fd, struct sockaddr_un* path, int len) {
 
 #define SOCK_NONBLOCK  04000
 #define SOCK_CLOEXEC   02000000
+#define SOCK_STREAM    1
+#define SOCK_DGRAM     2
 
 syscall_ret_t sys_socket(int family, int type, int protocol) {
     arch::x86_64::process_t* proc = CURRENT_PROC;
 
     if(family != AF_UNIX)
-        return {0,ENOSYS,0};
+        return {1,ENOSYS,0};
 
+    std::uint8_t socket_type = type & 0xFF;
+
+    if(socket_type != SOCK_STREAM) {
+        Log::SerialDisplay(LEVEL_MESSAGE_WARN,"Tried to open non SOCK_STREAM socket which not implemented (socket type %d)\n",socket_type);
+        //return {1,ENOSYS,0}; 
+    }
+        
     int new_fd = vfs::fdmanager::create(proc);
 
     userspace_fd_t* new_fd_s = vfs::fdmanager::search(proc,new_fd);
@@ -293,7 +310,7 @@ syscall_ret_t sys_socket(int family, int type, int protocol) {
 
     new_fd_s->state = USERSPACE_FD_STATE_SOCKET;
 
-    DEBUG(proc->is_debug,"Creating socket on fd %d from proc %d",new_fd,proc->id);
+    DEBUG(1,"Creating socket on fd %d from proc %d",new_fd,proc->id);
 
     return {1,0,new_fd};
 }
@@ -314,3 +331,121 @@ syscall_ret_t sys_listen(int fd, int backlog) {
     
     return {0,0,0};
 }
+
+syscall_ret_t sys_socketpair(int domain, int type_and_flags, int proto) {
+
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+    int read_fd = vfs::fdmanager::create(proc);
+    int write_fd = vfs::fdmanager::create(proc);
+    userspace_fd_t* fd1 = vfs::fdmanager::search(proc,read_fd);
+    userspace_fd_t* fd2 = vfs::fdmanager::search(proc,write_fd);
+
+    vfs::pipe* first = new vfs::pipe(0);
+    vfs::pipe* second = new vfs::pipe(0);
+
+    fd1->read_socket_pipe = first;
+    fd2->write_socket_pipe = first;
+    fd1->write_socket_pipe = second;
+    fd2->read_socket_pipe = second;
+
+    fd1->other_state = USERSPACE_FD_OTHERSTATE_MASTER;
+    fd2->other_state = USERSPACE_FD_OTHERSTATE_MASTER;
+
+    fd1->read_socket_pipe->create(PIPE_SIDE_READ);
+    fd1->read_socket_pipe->create(PIPE_SIDE_WRITE);    
+    fd1->write_socket_pipe->create(PIPE_SIDE_READ);   
+    fd1->write_socket_pipe->create(PIPE_SIDE_WRITE);
+
+    fd1->state = USERSPACE_FD_STATE_SOCKET;
+    fd2->state = USERSPACE_FD_STATE_SOCKET;
+
+    return {1,read_fd,write_fd};
+}
+
+syscall_ret_t sys_getsockname(int fd, struct sockaddr_un* path, int len) {
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+    userspace_fd_t* fd_s = vfs::fdmanager::search(proc,fd);
+
+    if(!fd_s)
+        return {1,EBADF,0};
+
+    if(path) {
+        path->sun_family = AF_UNIX;
+        memcpy(path->sun_path,fd_s->path,strlen(fd_s->path) + 1);
+        return {1,0,strlen(fd_s->path)};
+    } else 
+        return {1,EINVAL,0};
+    return {1,0,0};
+}
+
+#define SO_PEERCRED     17
+
+syscall_ret_t sys_getsockopt(int fd, int layer, int number, int_frame_t* ctx) {
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+    userspace_fd_t* fd_s = vfs::fdmanager::search(proc,fd);
+
+    if(!fd_s)
+        return {1,EBADF,0};
+
+    void* buffer = (void*)ctx->r8;
+    if(!buffer)
+        return {1,EINVAL,0};
+
+    if(fd_s->state != USERSPACE_FD_STATE_SOCKET || !fd_s->read_socket_pipe)
+        return {1,EBADF,0};
+
+    switch(number) {
+        
+        case SO_PEERCRED: {
+            struct ucred* cred = (struct ucred*)buffer;
+            cred->pid = fd_s->socket_pid;
+            cred->uid = fd_s->socket_uid;
+            cred->gid = 0; // not implemented
+            return {1,0,sizeof(struct ucred)};
+        };
+
+        default: {
+            return {1,ENOSYS,0};
+        };
+    
+    }
+
+    return {1,0,0};
+
+}
+
+#define SHUT_RD 0
+#define SHUT_WR 1
+#define SHUT_RDWR 2
+
+syscall_ret_t sys_shutdown(int sockfd, int how) {
+    arch::x86_64::process_t* proc = CURRENT_PROC;
+    userspace_fd_t* fd_s = vfs::fdmanager::search(proc,sockfd);
+
+    if(!fd_s)
+        return {0,EBADF,0};
+
+    if(fd_s->state != USERSPACE_FD_STATE_SOCKET)
+        return {0,ENOTSOCK,0};
+
+    if(fd_s->is_listen || fd_s->read_socket_pipe == 0)
+        return {0,ENOTCONN,0};
+
+    switch(how) {
+    case SHUT_RD:
+    case SHUT_RDWR:
+        fd_s->read_socket_pipe->lock.lock();
+        fd_s->write_socket_pipe->lock.lock();
+        fd_s->read_socket_pipe->is_closed.test_and_set();
+        fd_s->write_socket_pipe->is_closed.test_and_set();
+        fd_s->read_socket_pipe->lock.unlock();
+        fd_s->write_socket_pipe->lock.unlock();
+        break;
+    case SHUT_WR:
+        return {0,ENOSYS,0};
+    default:
+        return {0,EINVAL,0};
+    }
+
+    return {0,0,0};
+}
\ No newline at end of file
diff --git a/kernel/src/arch/x86_64/syscalls/syscalls.cpp b/kernel/src/arch/x86_64/syscalls/syscalls.cpp
index aba44b8..dcf1cda 100644
--- a/kernel/src/arch/x86_64/syscalls/syscalls.cpp
+++ b/kernel/src/arch/x86_64/syscalls/syscalls.cpp
@@ -11,90 +11,109 @@
 
 #include <etc/errno.hpp>
 
-arch::x86_64::syscall_item_t sys_table[] = {
-    {1,(void*)sys_futex_wake},
-    {2,(void*)sys_futex_wait},
-    {3,(void*)sys_openat},
-    {4,(void*)sys_read},
-    {5,(void*)sys_write},
-    {6,(void*)sys_seek},
-    {7,(void*)sys_close},
-    {8,(void*)sys_tcb_set},
-    {9,(void*)sys_libc_log},
-    {10,(void*)sys_exit},
-    {11,(void*)sys_mmap},
-    {12,(void*)sys_free},
-    {13,(void*)sys_stat},
-    {14,(void*)sys_pipe},
-    {15,(void*)sys_fork},
-    {16,(void*)sys_dup},
-    {17,(void*)sys_dup2},
-    {18,(void*)sys_create_dev},
-    {19,(void*)sys_iopl},
-    {20,(void*)sys_ioctl},
-    {21,(void*)sys_create_ioctl},
-    {22,(void*)sys_setup_tty},
-    {23,(void*)sys_isatty},
-    {24,(void*)sys_setupmmap},
-    {25,(void*)sys_access_framebuffer},
-    {26,(void*)sys_ptsname},
-    {27,(void*)sys_setup_ring_bytelen},
-    {28,(void*)sys_read_dir},
-    {29,(void*)sys_exec},
-    {30,(void*)sys_getpid},
-    {31,(void*)sys_getppid},
-    {32,(void*)sys_gethostname},
-    {33,(void*)sys_getcwd},
-    {34,(void*)sys_waitpid},
-    {35,(void*)sys_fcntl},
-    {36,(void*)sys_fchdir},
-    {37,(void*)sys_sleep},
-    {38,(void*)sys_alloc_dma},
-    {39,(void*)sys_map_phys},
-    {40,(void*)sys_free_dma},
-    {41,(void*)sys_connect},
-    {42,(void*)sys_accept},
-    {43,(void*)sys_bind},
-    {44,(void*)sys_socket},
-    {45,(void*)sys_listen},
-    {46,(void*)sys_timestamp},
-    {47,(void*)sys_mkfifoat},
-    {48,(void*)sys_poll},
-    {49,(void*)sys_readlinkat},
-    {50,(void*)sys_link},
-    {51,(void*)sys_mkdirat},
-    {52,(void*)sys_chmod},
-    {53,(void*)sys_enabledebugmode},
-    {54,(void*)sys_clone},
-    {56,(void*)sys_ttyname},
-    {57,(void*)sys_breakpoint},
-    {58,(void*)sys_copymemory},
-    {59,(void*)sys_setpriority},
-    {60,(void*)sys_getpriority},
-    {61,(void*)sys_yield},
-    {62,(void*)sys_rename},
-    {63,(void*)sys_printdebuginfo},
-    {64,(void*)sys_dmesg},
-    {65,(void*)sys_enabledebugmodepid}
+syscall_ret_t sys_hello() {
+    DEBUG(1,"hello");
+    return {0,0,0};
+}
+
+#define MAX_SYSCALL 100
+
+void* sys_table0[] = {
+    (void*)sys_hello, // 0
+    (void*)sys_futex_wake, // 1
+    (void*)sys_futex_wait, // 2
+    (void*)sys_openat, // 3
+    (void*)sys_read, // 4
+    (void*)sys_write, // 5
+    (void*)sys_seek, // 6
+    (void*)sys_close, // 7
+    (void*)sys_tcb_set, // 8
+    (void*)sys_libc_log, // 9
+    (void*)sys_exit, // 10
+    (void*)sys_mmap, // 11
+    (void*)sys_free, // 12
+    (void*)sys_stat, // 13
+    (void*)sys_pipe, // 14
+    (void*)sys_fork, // 15
+    (void*)sys_dup, // 16
+    (void*)sys_dup2, // 17
+    (void*)sys_create_dev, // 18
+    (void*)sys_iopl, // 19 
+    (void*)sys_ioctl, // 20 
+    (void*)sys_create_ioctl, // 21
+    (void*)sys_setup_tty, // 22
+    (void*)sys_isatty, // 23
+    (void*)sys_setupmmap, // 24
+    (void*)sys_access_framebuffer, // 25
+    (void*)sys_ptsname, // 26
+    (void*)sys_setup_ring_bytelen, // 27
+    (void*)sys_read_dir, // 28
+    (void*)sys_exec, // 29
+    (void*)sys_getpid, // 30
+    (void*)sys_getppid, // 31
+    (void*)sys_gethostname, // 32
+    (void*)sys_getcwd, // 33
+    (void*)sys_waitpid, // 34
+    (void*)sys_fcntl, // 35
+    (void*)sys_fchdir, // 36
+    (void*)sys_sleep, // 37
+    (void*)sys_alloc_dma, // 38
+    (void*)sys_map_phys, // 39
+    (void*)sys_free_dma, // 40 
+    (void*)sys_connect, // 41 
+    (void*)sys_accept, // 42
+    (void*)sys_bind, // 43
+    (void*)sys_socket, // 44
+    (void*)sys_listen, // 45
+    (void*)sys_timestamp, // 46 
+    (void*)sys_mkfifoat, // 47
+    (void*)sys_poll, // 48
+    (void*)sys_readlinkat, // 49
+    (void*)sys_link, // 50
+    (void*)sys_mkdirat, // 51
+    (void*)sys_chmod, // 52
+    (void*)sys_enabledebugmode, // 53
+    (void*)sys_clone, // 54
+    (void*)sys_hello, // 55
+    (void*)sys_ttyname, // 55 + 1
+    (void*)sys_breakpoint, // 56 + 1
+    (void*)sys_copymemory, // 57 + 1
+    (void*)sys_setpriority, // 58 + 1
+    (void*)sys_getpriority, // 59 + 1
+    (void*)sys_yield, // 60 + 1
+    (void*)sys_rename, // 61 + 1
+    (void*)sys_printdebuginfo, // 62 + 1
+    (void*)sys_dmesg, // 63 + 1
+    (void*)sys_enabledebugmodepid, // 64 + 1
+    (void*)sys_socketpair, // 65 + 1
+    (void*)sys_getuid, // 66 + 1
+    (void*)sys_setuid, // 67 + 1
+    (void*)sys_getsockname, // 68  + 1
+    (void*)sys_getsockopt, // 69 + 1
+    (void*)sys_msg_send, // 70 + 1
+    (void*)sys_eventfd_create, // 71 + 1
+    (void*)sys_msg_recv, // 72 + 1
+    (void*)sys_kill, // 73 + 1 
+    (void*)sys_shutdown, // 74 + 1
+    (void*)sys_shmget, // 76
+    (void*)sys_shmat, // 77
+    (void*)sys_shmdt, // 78
+    (void*)sys_shmctl // 79
 };
 
-arch::x86_64::syscall_item_t* __syscall_find(int rax) {
-    for(int i = 0; i < sizeof(sys_table) / sizeof(arch::x86_64::syscall_item_t);i++) {
-        if(sys_table[i].syscall_num == rax)
-            return &sys_table[i];
-    }
+void* __syscall_find(int rax) {
+    if(rax < MAX_SYSCALL && rax > 0)
+        return sys_table0[rax];
     Log::SerialDisplay(LEVEL_MESSAGE_WARN,"unknown syscall %d",rax);
     return 0; // without it there will be ub
 }
 
 extern "C" void syscall_handler_c(int_frame_t* ctx) {
 
-    arch::x86_64::syscall_item_t* item = __syscall_find(ctx->rax);
+    void* item = __syscall_find(ctx->rax);
 
     if(!item) {
         return;
-    } else if(!item->syscall_func) {
-        return;
     } 
 
     arch::x86_64::process_t* proc = arch::x86_64::cpu::data()->temp.proc;
@@ -108,7 +127,7 @@ extern "C" void syscall_handler_c(int_frame_t* ctx) {
     DEBUG(0,"sys %d from %d rip 0x%p",ctx->rax,proc->id,ctx->rip);
         
 
-    syscall_ret_t (*sys)(std::uint64_t D, std::uint64_t S, std::uint64_t d, int_frame_t* frame) = (syscall_ret_t (*)(std::uint64_t, std::uint64_t, std::uint64_t, int_frame_t*))item->syscall_func;
+    syscall_ret_t (*sys)(std::uint64_t D, std::uint64_t S, std::uint64_t d, int_frame_t* frame) = (syscall_ret_t (*)(std::uint64_t, std::uint64_t, std::uint64_t, int_frame_t*))item;
     syscall_ret_t ret = sys(ctx->rdi,ctx->rsi,ctx->rdx,ctx);
     if(ret.is_rdx_ret) {
         ctx->rdx = ret.ret_val;
diff --git a/kernel/src/drivers/acpi.cpp b/kernel/src/drivers/acpi.cpp
index 6a1e6d4..a43d893 100644
--- a/kernel/src/drivers/acpi.cpp
+++ b/kernel/src/drivers/acpi.cpp
@@ -55,7 +55,7 @@ void drivers::acpi::init() {
     drivers::ioapic::init();
     Log::Display(LEVEL_MESSAGE_OK,"IOAPIC initializied\n");
 
-    arch::x86_64::cpu::data()->lapic_block = arch::x86_64::cpu::lapic::init(2500);
+    arch::x86_64::cpu::data()->lapic_block = arch::x86_64::cpu::lapic::init(1000);
 
     ret = uacpi_namespace_load();
 
diff --git a/kernel/src/etc/etc.cpp b/kernel/src/etc/etc.cpp
index b6540aa..2cf3d8c 100644
--- a/kernel/src/etc/etc.cpp
+++ b/kernel/src/etc/etc.cpp
@@ -77,12 +77,16 @@ extern "C" {
 
 void *operator new(size_t size)
 {
-    return memory::heap::malloc(size);
+    void* ptr = memory::heap::malloc(size);
+    memset(ptr,0,size);
+    return ptr;
 }
 
 void *operator new[](size_t size)
 {
-    return memory::heap::malloc(size);
+    void* ptr = memory::heap::malloc(size);
+    memset(ptr,0,size);
+    return ptr;
 }
 
 void operator delete(void *p)
diff --git a/kernel/src/generic/mm/paging.cpp b/kernel/src/generic/mm/paging.cpp
index ed4819a..e9221b5 100644
--- a/kernel/src/generic/mm/paging.cpp
+++ b/kernel/src/generic/mm/paging.cpp
@@ -8,6 +8,8 @@
 #include <limine.h>
 #include <etc/etc.hpp>
 
+#include <etc/libc.hpp>
+
 static void init();
 std::uint64_t kernel_cr3;
 alwaysmapped_t* alwmap = 0;
@@ -18,6 +20,12 @@ uint64_t* __paging_next_level(std::uint64_t* table,std::uint16_t idx,std::uint64
     return (uint64_t*)Other::toVirt(table[idx] & PTE_MASK_VALUE);
 }
 
+uint64_t* __paging_next_level_noalloc(std::uint64_t* table,std::uint16_t idx,std::uint64_t flags,std::uint32_t id) {
+    if(!(table[idx] & PTE_PRESENT))
+        return 0;
+    return (uint64_t*)Other::toVirt(table[idx] & PTE_MASK_VALUE);
+}
+
 void memory::paging::map(std::uint64_t cr3,std::uint64_t phys,std::uint64_t virt,std::uint64_t flags) {
     std::uint64_t align_phys = ALIGNDOWN(phys,4096);
     std::uint64_t align_virt = ALIGNDOWN(virt,4096);
@@ -50,12 +58,59 @@ void memory::paging::change(std::uint64_t cr3, std::uint64_t virt, std::uint64_t
     std::uint64_t new_flags = PTE_PRESENT | PTE_RW;
     if(PTE_INDEX(align_virt,39) < 256)
         new_flags |= PTE_USER;
-    uint64_t* pml3 = __paging_next_level(cr30,PTE_INDEX(align_virt,39),new_flags,0);
-    uint64_t* pml2 = __paging_next_level(pml3,PTE_INDEX(align_virt,30),new_flags,0);
-    uint64_t* pml = __paging_next_level(pml2,PTE_INDEX(align_virt,21),new_flags,0);
+    uint64_t* pml3 = __paging_next_level(cr30,PTE_INDEX(align_virt,39),new_flags,0);//1
+    uint64_t* pml2 = __paging_next_level(pml3,PTE_INDEX(align_virt,30),new_flags,0); // 2
+    uint64_t* pml = __paging_next_level(pml2,PTE_INDEX(align_virt,21),new_flags,0); // 3
     pml[PTE_INDEX(align_virt,12)] = (pml[PTE_INDEX(align_virt,12)] & PTE_MASK_VALUE) | flags;
 }
 
+std::int64_t __memory_paging_getphys(std::uint64_t cr3, std::uint64_t virt) {
+    std::uint64_t align_virt = virt;
+    std::uint64_t* cr30 = (std::uint64_t*)Other::toVirt(cr3);
+    if(cr30[PTE_INDEX(virt,39)] & PTE_PRESENT) {
+        std::uint64_t* pml3 = __paging_next_level_noalloc(cr30,PTE_INDEX(align_virt,39),0,0);//1
+        if(pml3[PTE_INDEX(virt,30)] & PTE_PRESENT) {
+            std::uint64_t* pml2 = __paging_next_level_noalloc(pml3,PTE_INDEX(align_virt,30),0,0); // 2
+            if(pml2[PTE_INDEX(virt,21)] & PTE_PRESENT) {
+                uint64_t* pml = __paging_next_level_noalloc(pml2,PTE_INDEX(align_virt,21),0,0); // 3
+                if(pml[PTE_INDEX(align_virt,12)] & PTE_PRESENT) {
+                    return pml[PTE_INDEX(virt,12)] & PTE_MASK_VALUE;
+                } else {
+                    return -1;
+                }
+            } else {
+                return -1;
+            }
+        } else {
+            return -1;
+        }
+    } else {
+        return -1;
+    }
+}
+
+void memory::paging::destroyrange(std::uint64_t cr3, std::uint64_t virt, std::uint64_t len) {
+    for(std::uint64_t i = 0;i < len; i += 4096) {
+        std::int64_t phys = __memory_paging_getphys(cr3,virt + i);
+        if(phys != -1 && phys != 0) {
+            memory::pmm::_physical::free((std::uint64_t)phys);
+            map(cr3,0,virt + i,0);
+        } 
+    }
+}
+
+void memory::paging::duplicaterangeifexists(std::uint64_t src_cr3, std::uint64_t dest_cr3, std::uint64_t virt, std::uint64_t len, std::uint64_t flags) {
+    zerorange(dest_cr3,virt,len);
+    for(std::uint64_t i = 0;i < len; i += 4096) {
+        std::int64_t phys = __memory_paging_getphys(src_cr3,virt + i);
+        if(phys != -1) {
+            std::uint64_t new_phys = memory::pmm::_physical::alloc(4096);
+            memcpy(Other::toVirt(new_phys),Other::toVirt(phys),4096);
+            map(dest_cr3,new_phys,virt + i,flags);
+        } 
+    }
+}
+
 void memory::paging::changerange(std::uint64_t cr3, std::uint64_t virt, std::uint64_t len , std::uint64_t flags) {
     for(std::uint64_t i = 0;i < len; i += 4096) {
         change(cr3,virt + i, flags);
@@ -68,6 +123,12 @@ void memory::paging::maprange(std::uint64_t cr3,std::uint64_t phys,std::uint64_t
     }
 }
 
+void memory::paging::zerorange(std::uint64_t cr3,std::uint64_t virt,std::uint64_t len) {
+    for(std::uint64_t i = 0; i <= len; i += 4096) {
+        map(cr3,0,virt + i,0);
+    }
+}
+
 void memory::paging::maprangeid(std::uint64_t cr3,std::uint64_t phys,std::uint64_t virt,std::uint64_t len,std::uint64_t flags, std::uint32_t id) {
     for(std::uint64_t i = 0; i <= len; i += 4096) {
         mapid(cr3,phys + i,virt + i,flags,id);
@@ -137,6 +198,34 @@ void memory::paging::alwaysmappedmap(std::uint64_t cr3,std::uint32_t id) {
     }
 }
 
+void __paging_destroy_table(std::uint64_t phys_table, int level) {
+    std::uint64_t* table = (std::uint64_t*)Other::toVirt(phys_table);
+    if(level != 3) { 
+        if(level == 0) { 
+            for(int i = 0; i < 256; i++) {
+                if(table[i] & PTE_PRESENT) {
+                    __paging_destroy_table(table[i] & PTE_MASK_VALUE,level + 1);
+                }
+            }
+        } else {
+            for(int i = 0;i < 512; i++) {
+                if(table[i] & PTE_PRESENT) {
+                    __paging_destroy_table(table[i] & PTE_MASK_VALUE,level + 1);
+                }
+            } 
+        }
+    }
+
+    if(level != 0)
+        memory::pmm::_physical::free(phys_table);
+}
+
+void memory::paging::destroy(std::uint64_t cr3) {
+    if(cr3 == kernel_cr3)
+        return;
+    __paging_destroy_table(cr3,0);
+}
+
 void memory::paging::init() {
     kernel_cr3 = memory::pmm::_physical::alloc(4096);
     mapentry(kernel_cr3,LIMINE_MEMMAP_USABLE,0);
diff --git a/kernel/src/generic/vfs/tmpfs.cpp b/kernel/src/generic/vfs/tmpfs.cpp
index aec20e9..99b879d 100644
--- a/kernel/src/generic/vfs/tmpfs.cpp
+++ b/kernel/src/generic/vfs/tmpfs.cpp
@@ -11,6 +11,8 @@
 #include <etc/libc.hpp>
 #include <etc/errno.hpp>
 
+#include <drivers/cmos.hpp>
+
 #include <etc/logging.hpp>
 
 vfs::tmpfs_node_t* head_node;
@@ -104,10 +106,12 @@ static vfs::tmpfs_node_t* allocate_node_from_pool() {
     return node;
 }
 
+std::uint64_t __tmpfs_ptr_id = 0;
+
 std::int32_t __tmpfs__create(char* path,std::uint8_t type) {
 
     if(__tmpfs__exists(path))
-        return EFAULT;
+        return EEXIST;
     
     char copy[2048];
     memset(copy,0,2048);
@@ -149,6 +153,10 @@ std::int32_t __tmpfs__create(char* path,std::uint8_t type) {
     node->content = 0;
     node->size = 0;
     node->busy = 0;
+    node->id = ++__tmpfs_ptr_id;
+
+    node->create_time = getUnixTime();
+    node->access_time = getUnixTime();
     
     memcpy(node->name,path,strlen(path));
 
@@ -175,6 +183,8 @@ void __tmpfs__dealloc(vfs::tmpfs_node_t* node){
     memory::pmm::_virtual::free(node->content);
 }
 
+std::uint8_t __tmpfs__dont_alloc_memory = 0;
+
 std::int64_t __tmpfs__write(userspace_fd_t* fd, char* path, void* buffer, std::uint64_t size) {
     if (!path || !buffer || !size) { vfs::vfs::unlock();
         return -EBADF; }
@@ -198,19 +208,22 @@ std::int64_t __tmpfs__write(userspace_fd_t* fd, char* path, void* buffer, std::u
         std::uint64_t offset = fd->offset;
         std::uint64_t new_size = offset + size;
 
-        if (new_size > node->real_size) {
+        if (new_size > node->real_size || node->is_non_allocated) {
             alloc_t new_content0 = memory::pmm::_physical::alloc_ext(new_size);
             std::uint8_t* new_content = (std::uint8_t*)new_content0.virt;
             if (node->content) {
                 memcpy(new_content, node->content, node->size); 
-                __tmpfs__dealloc(node);
+                if(!node->is_non_allocated)
+                    __tmpfs__dealloc(node);
             }
+            node->is_non_allocated = 0;
             node->content = new_content;
             node->real_size = new_content0.real_size;
         }
 
         node->size = new_size;
 
+        node->access_time = getUnixTime();
         memcpy(node->content + offset, buffer, size);
 
         fd->offset += size;
@@ -380,7 +393,21 @@ std::int32_t __tmpfs__stat(userspace_fd_t* fd, char* path, vfs::stat_t* out) {
     out->st_mode = node->type == TMPFS_TYPE_DIRECTORY ? S_IFDIR : S_IFREG;
     if(node->type == TMPFS_TYPE_SYMLINK) 
         out->st_mode = S_IFLNK;
-    out->st_mode |= (node->vars[0] & ~(S_IFDIR | S_IFREG | S_IFCHR | S_IFBLK | S_IFIFO | S_IFDIR | S_IFIFO | S_IFMT | S_IFLNK));
+    out->st_mode |= ((node->vars[0] & ~(S_IFDIR | S_IFREG | S_IFCHR | S_IFBLK | S_IFIFO | S_IFDIR | S_IFIFO | S_IFMT | S_IFLNK)) & 0xFFFFFFFF);
+    out->st_uid = 0;
+    out->st_gid = 0;
+    out->st_blksize = 4096;
+    out->st_ino = node->id;
+    out->st_nlink = 0; // unimplemented
+    out->st_dev = 0;
+    out->st_rdev = 0;
+    out->st_blocks = node->real_size / 4096;
+    out->st_atim.tv_sec = node->access_time;
+    out->st_mtim.tv_sec = node->access_time;
+    out->st_ctim.tv_sec = node->create_time;
+    out->st_atim.tv_nsec = 0;
+    out->st_mtim.tv_nsec = 0;
+    out->st_ctim.tv_nsec = 0;
 
     return 0;
 }
@@ -471,6 +498,7 @@ void vfs::tmpfs::mount(vfs_node_t* node) {
     head_node = (tmpfs_node_t*)memory::pmm::_virtual::alloc(4096);
 
     head_node->type = TMPFS_TYPE_DIRECTORY;
+    head_node->id = 0;
 
     memcpy(head_node->name,"/",1);
 
diff --git a/kernel/src/generic/vfs/ustar.cpp b/kernel/src/generic/vfs/ustar.cpp
index df7bdd3..1c0667f 100644
--- a/kernel/src/generic/vfs/ustar.cpp
+++ b/kernel/src/generic/vfs/ustar.cpp
@@ -37,6 +37,7 @@ void __ustar_fault(const char* msg) {
 }
 
 extern std::uint8_t __tmpfs__create_parent_dirs_by_default;
+extern std::uint8_t __tmpfs__dont_alloc_memory;
 
 void vfs::ustar::copy() {
     struct limine_module_response* initrd = BootloaderInfo::AccessInitrd();
@@ -54,11 +55,16 @@ void vfs::ustar::copy() {
                 int size = oct2bin((uint8_t*)current->file_size,strlen(current->file_size));
                 
                 userspace_fd_t fd;
+
                 memset(&fd,0,sizeof(userspace_fd_t));
                 memcpy(fd.path,file,strlen(file));
-                
+
+                __tmpfs__dont_alloc_memory = 1;
                 vfs::vfs::write(&fd,(char*)((std::uint64_t)current + 512),size);
-                vfs::vfs::var(&fd,(std::uint64_t)current->file_mode,TMPFS_VAR_CHMOD | (1 << 7));
+                __tmpfs__dont_alloc_memory = 0;
+
+                std::uint64_t actual_mode = oct2bin((uint8_t*)current->file_mode,8);
+                vfs::vfs::var(&fd,(std::uint64_t)&actual_mode,TMPFS_VAR_CHMOD | (1 << 7));
                 break;
             }
 
@@ -74,7 +80,11 @@ void vfs::ustar::copy() {
                 memset(&fd,0,sizeof(userspace_fd_t));
                 memcpy(fd.path,file,strlen(file));
                 vfs::vfs::create(file,VFS_TYPE_SYMLINK);
+
+                __tmpfs__dont_alloc_memory = 1;
                 vfs::vfs::write(&fd,current->name_linked,strlen(current->name_linked));
+                __tmpfs__dont_alloc_memory = 0;
+                
                 break;
             }
         }
diff --git a/kernel/src/generic/vfs/vfs.cpp b/kernel/src/generic/vfs/vfs.cpp
index e54b2c7..52d85aa 100644
--- a/kernel/src/generic/vfs/vfs.cpp
+++ b/kernel/src/generic/vfs/vfs.cpp
@@ -397,6 +397,16 @@ std::int32_t vfs::vfs::var(userspace_fd_t* fd, std::uint64_t value, std::uint8_t
     } else
         memcpy(out,fd->path,strlen(fd->path));
 
+    if((sockets::is_exists(out))) {
+        socket_node_t* node = sockets::find(out);
+        if(request & (1 << 7))
+            node->vars[request & ~(1 << 7)] = value;
+        else
+            *(std::uint64_t*)value = node->vars[request & ~(1 << 7)];
+        vfs_lock->unlock();
+        return 0;
+    }
+
     vfs_node_t* node = find_node(out);
     if(!node) { vfs::vfs::unlock();
         return ENOENT; }
@@ -542,6 +552,15 @@ void vfs::vfs::close(userspace_fd_t* fd) {
     char out0[2048];
     memset(out0,0,2048);
 
+    if(fd->state == USERSPACE_FD_STATE_SOCKET && !fd->is_listen && fd->read_socket_pipe) {
+        // fd->read_socket_pipe->lock.lock();
+        // fd->write_socket_pipe->lock.lock();
+        // fd->read_socket_pipe->is_closed.test_and_set();
+        // fd->write_socket_pipe->is_closed.test_and_set();
+        // fd->read_socket_pipe->lock.unlock();
+        // fd->write_socket_pipe->lock.unlock();
+    }
+
     if(!fd->is_cached_path) {
         __vfs_symlink_resolve(fd->path,out0);
         memcpy(fd->path,out0,strlen(out0));
diff --git a/tar-initrd.sh b/tar-initrd.sh
index 4a34259..a462275 100755
--- a/tar-initrd.sh
+++ b/tar-initrd.sh
@@ -7,7 +7,7 @@ export PATH="$HOME/opt/cross/orange/bin:$PATH"
 
 sysroot_path="$(realpath initrd)"
 
-export CFLAGS="-fPIC -Wno-error -O2 -Wno-incompatible-pointer-types"
+export CFLAGS="-fPIC -Wno-error -O2 -Wno-incompatible-pointer-types -Wno-implicit-function-declaration"
 export PKG_CONFIG_SYSROOT_DIR="$sysroot_path"
 export PKG_CONFIG_PATH="$sysroot_path/usr/lib/pkgconfig:$sysroot_path/usr/share/pkgconfig:$sysroot_path/usr/local/lib/pkgconfig:$sysroot_path/usr/local/share/pkgconfig:$HOME/opt/cross/orange/lib/pkgconfig:$HOME/opt/cross/orange/share/pkgconfig"
 if [ ! "$(which x86_64-orange-mlibc-gcc)" ]; then
diff --git a/tools/initbase/etc/X11/xfcerc b/tools/initbase/etc/X11/xfcerc
new file mode 100644
index 0000000..a85c342
--- /dev/null
+++ b/tools/initbase/etc/X11/xfcerc
@@ -0,0 +1,5 @@
+
+xwallpaper --zoom /etc/twmbg.png &
+st &
+
+exit
\ No newline at end of file
diff --git a/tools/initbase/etc/at-spi2/accessibility.conf b/tools/initbase/etc/at-spi2/accessibility.conf
new file mode 100644
index 0000000..d13764c
--- /dev/null
+++ b/tools/initbase/etc/at-spi2/accessibility.conf
@@ -0,0 +1,38 @@
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+
+  <type>accessibility</type>
+
+<servicedir>/usr/share/dbus-1/accessibility-services</servicedir>
+  <auth>EXTERNAL</auth>
+
+  <listen>unix:dir=/tmp</listen>
+
+  <policy context="default">
+    <!-- Allow root to connect -->
+    <allow user="root"/>
+    <!-- Allow everything to be sent -->
+    <allow send_destination="*"/>
+    <!-- All messages may be received by default -->
+    <allow receive_type="method_call"/>
+    <allow receive_type="method_return"/>
+    <allow receive_type="error"/>
+    <allow receive_type="signal"/>
+    <!-- Allow anyone to own anything -->
+    <allow own="*"/>
+  </policy>
+
+  <limit name="max_incoming_bytes">1000000000</limit>
+  <limit name="max_outgoing_bytes">1000000000</limit>
+  <limit name="max_message_size">1000000000</limit>
+  <limit name="service_start_timeout">120000</limit>  
+  <limit name="auth_timeout">240000</limit>
+  <limit name="max_completed_connections">100000</limit>  
+  <limit name="max_incomplete_connections">10000</limit>
+  <limit name="max_connections_per_user">100000</limit>
+  <limit name="max_pending_service_starts">10000</limit>
+  <limit name="max_names_per_connection">50000</limit>
+  <limit name="max_match_rules_per_connection">50000</limit>
+  <limit name="max_replies_per_connection">50000</limit>
+  <limit name="reply_timeout">300000</limit>
+</busconfig>
diff --git a/tools/initbase/etc/group b/tools/initbase/etc/group
new file mode 100644
index 0000000..4792d7b
--- /dev/null
+++ b/tools/initbase/etc/group
@@ -0,0 +1 @@
+root:x:0:root
\ No newline at end of file
diff --git a/tools/initbase/etc/init.sh b/tools/initbase/etc/init.sh
index 934c86b..958e5f4 100755
--- a/tools/initbase/etc/init.sh
+++ b/tools/initbase/etc/init.sh
@@ -1 +1,7 @@
+export TERM=linux
+export XDG_RUNTIME_DIR=/run/user/0
+export XDG_CONFIG_DIRS=/etc/xdg
+dbus-uuidgen --ensure
+dbus-daemon --session --address=unix:path=/run/user/1000/bus &
+export DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus
 orangeX
\ No newline at end of file
diff --git a/tools/initbase/etc/passwd b/tools/initbase/etc/passwd
index 0cabc85..7bae33f 100644
--- a/tools/initbase/etc/passwd
+++ b/tools/initbase/etc/passwd
@@ -1 +1,2 @@
-root:x:0:0::/root:/bin/bash
\ No newline at end of file
+root:x:0:0::/root:/bin/bash
+messagebus:x:81:81:System Message Bus:/:/usr/bin/nologin
\ No newline at end of file
diff --git a/tools/initbase/etc/xdg/xfce4/Xft.xrdb b/tools/initbase/etc/xdg/xfce4/Xft.xrdb
new file mode 100644
index 0000000..cd26513
--- /dev/null
+++ b/tools/initbase/etc/xdg/xfce4/Xft.xrdb
@@ -0,0 +1,7 @@
+! Those are fallback settings, use the ui plugin to change it
+! or add your overrides to ~/.Xresources
+! Xft.hintstyle: hintnone/hintslight/hintmedium/hintfull
+! Xft hinting: 1/0
+
+Xft.hinting: 1
+Xft.hintstyle: hintmedium
diff --git a/tools/initbase/etc/xdg/xfce4/helpers.rc b/tools/initbase/etc/xdg/xfce4/helpers.rc
new file mode 100644
index 0000000..9e2bb31
--- /dev/null
+++ b/tools/initbase/etc/xdg/xfce4/helpers.rc
@@ -0,0 +1,10 @@
+#
+# Default helpers.rc for Xfce's Preferred Applications
+#
+# Copyright (c) 2005-2006 Benedikt Meurer <benny@xfce.org>
+#
+
+WebBrowser=firefox
+MailReader=thunderbird
+TerminalEmulator=xfce4-terminal
+FileManager=thunar
diff --git a/tools/initbase/etc/xdg/xfce4/panel/default.xml b/tools/initbase/etc/xdg/xfce4/panel/default.xml
new file mode 100644
index 0000000..289a8de
--- /dev/null
+++ b/tools/initbase/etc/xdg/xfce4/panel/default.xml
@@ -0,0 +1,95 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<channel name="xfce4-panel" version="1.0">
+  <property name="configver" type="int" value="2"/>
+  <property name="panels" type="array">
+    <value type="int" value="1"/>
+    <value type="int" value="2"/>
+    <property name="dark-mode" type="bool" value="true"/>
+    <property name="panel-1" type="empty">
+      <property name="position" type="string" value="p=6;x=0;y=0"/>
+      <property name="length" type="uint" value="100"/>
+      <property name="position-locked" type="bool" value="true"/>
+      <property name="icon-size" type="uint" value="16"/>
+      <property name="size" type="uint" value="26"/>
+      <property name="plugin-ids" type="array">
+        <value type="int" value="1"/>
+        <value type="int" value="2"/>
+        <value type="int" value="3"/>
+        <value type="int" value="4"/>
+        <value type="int" value="5"/>
+        <value type="int" value="6"/>
+        <value type="int" value="7"/>
+        <value type="int" value="8"/>
+        <value type="int" value="9"/>
+        <value type="int" value="10"/>
+      </property>
+    </property>
+    <property name="panel-2" type="empty">
+      <property name="autohide-behavior" type="uint" value="1"/>
+      <property name="position" type="string" value="p=10;x=0;y=0"/>
+      <property name="length" type="uint" value="1"/>
+      <property name="position-locked" type="bool" value="true"/>
+      <property name="size" type="uint" value="48"/>
+      <property name="plugin-ids" type="array">
+        <value type="int" value="11"/>
+        <value type="int" value="12"/>
+        <value type="int" value="13"/>
+        <value type="int" value="14"/>
+        <value type="int" value="15"/>
+        <value type="int" value="16"/>
+        <value type="int" value="17"/>
+        <value type="int" value="18"/>
+      </property>
+    </property>
+  </property>
+  <property name="plugins" type="empty">
+    <property name="plugin-1" type="string" value="applicationsmenu"/>
+    <property name="plugin-2" type="string" value="tasklist">
+      <property name="grouping" type="uint" value="1"/>
+    </property>
+    <property name="plugin-3" type="string" value="separator">
+      <property name="expand" type="bool" value="true"/>
+      <property name="style" type="uint" value="0"/>
+    </property>
+    <property name="plugin-4" type="string" value="pager"/>
+    <property name="plugin-5" type="string" value="separator">
+        <property name="style" type="uint" value="0"/>
+    </property>
+    <property name="plugin-6" type="string" value="systray">
+        <property name="square-icons" type="bool" value="true"/>
+    </property>
+    <property name="plugin-7" type="string" value="separator">
+      <property name="style" type="uint" value="0"/>
+    </property>
+    <property name="plugin-8" type="string" value="clock"/>
+    <property name="plugin-9" type="string" value="separator">
+      <property name="style" type="uint" value="0"/>
+    </property>
+    <property name="plugin-10" type="string" value="actions"/>
+    <property name="plugin-11" type="string" value="showdesktop"/>
+    <property name="plugin-12" type="string" value="separator"/>
+    <property name="plugin-13" type="string" value="launcher">
+      <property name="items" type="array">
+        <value type="string" value="xfce4-terminal-emulator.desktop"/>
+      </property>
+    </property>
+    <property name="plugin-14" type="string" value="launcher">
+      <property name="items" type="array">
+        <value type="string" value="xfce4-file-manager.desktop"/>
+      </property>
+    </property>
+    <property name="plugin-15" type="string" value="launcher">
+      <property name="items" type="array">
+        <value type="string" value="xfce4-web-browser.desktop"/>
+      </property>
+    </property>
+    <property name="plugin-16" type="string" value="launcher">
+      <property name="items" type="array">
+        <value type="string" value="xfce4-appfinder.desktop"/>
+      </property>
+    </property>
+    <property name="plugin-17" type="string" value="separator"/>
+    <property name="plugin-18" type="string" value="directorymenu"/>
+  </property>
+</channel>
diff --git a/tools/initbase/etc/xdg/xfce4/panel/xfce4-clipman-actions.xml b/tools/initbase/etc/xdg/xfce4/panel/xfce4-clipman-actions.xml
new file mode 100644
index 0000000..0581b44
--- /dev/null
+++ b/tools/initbase/etc/xdg/xfce4/panel/xfce4-clipman-actions.xml
@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE actions [
+<!ELEMENT actions (action)+>
+<!ELEMENT action (name , regex , commands)>
+<!ELEMENT commands (command)+>
+<!ELEMENT command (name , exec)>
+<!ELEMENT name (#PCDATA)>
+<!ATTLIST name xml:lang CDATA #IMPLIED>
+<!ELEMENT regex (#PCDATA)>
+<!ELEMENT exec (#PCDATA)>
+]>
+<!--
+  Copyright (c) 2009-2011 Mike Massonnet <mmassonnet@xfce.org>
+
+  Default Clipman actions configuration file, which gets installed system-wide.
+  This should act more like an example, and is therefore kept simple.
+-->
+<actions>
+  <action>
+    <name>Image</name>
+    <name xml:lang="ur">تصویر</name>
+    <name xml:lang="ur-PK">تصویر</name>
+    <name xml:lang="ug">سۈرەت</name>
+    <name xml:lang="lv">Attēls</name>
+    <name xml:lang="ast">Imaxe</name>
+    <name xml:lang="ar">صورة</name>
+    <regex>(http|ftp).+\.(jpg|png|gif)</regex>
+    <commands>
+      <command>
+        <name>Edit with Gimp</name>
+        <name xml:lang="ur">گمپ سے مدون کریں</name>
+        <name xml:lang="ur-PK">گمپ سے مدون کریں</name>
+        <name xml:lang="ug">GIMP دە تەھرىرلەش</name>
+        <name xml:lang="lv">Rediģēt ar Gimp</name>
+        <name xml:lang="ast">Editar con GIMP</name>
+        <name xml:lang="ar">تحرير باستخدام جمب</name>
+        <exec>gimp "\0"</exec>
+      </command>
+      <command>
+        <name>View with Ristretto</name>
+        <name xml:lang="ur">ریسٹریٹو کے ذریعہ دیکھیں</name>
+        <name xml:lang="ur-PK">ریسٹریٹو کے ذریعہ دیکھیں</name>
+        <name xml:lang="ug">Ristretto دە كۆرسەت</name>
+        <name xml:lang="lv">Apskatīt ar Ristretto</name>
+        <name xml:lang="ast">Ver con Ristretto</name>
+        <name xml:lang="ar">عرض مع ريستريتو</name>
+        <exec>ristretto "\0"</exec>
+      </command>
+    </commands>
+  </action>
+  <action>
+    <name>Bugz</name>
+    <name xml:lang="ur">بگز</name>
+    <name xml:lang="ur-PK">بگز</name>
+    <name xml:lang="ug">Bugz</name>
+    <name xml:lang="lv">Bugz</name>
+    <name xml:lang="ast">Bugz</name>
+    <name xml:lang="ar">Bugz</name>
+    <regex>bug\s*#?\s*([0-9]+)</regex>
+    <commands>
+      <command>
+        <name>Xfce Bug</name>
+        <name xml:lang="ur">ایکسفس بگ</name>
+        <name xml:lang="ur-PK">ایکسفس بگ</name>
+        <name xml:lang="ug">Xfce  كەمتۈكى</name>
+        <name xml:lang="lv">Xfce Bug</name>
+        <name xml:lang="ast">Fallu de Xfce</name>
+        <name xml:lang="ar">علة Xfce</name>
+        <exec>exo-open https://bugzilla.xfce.org/show_bug.cgi?id=\1</exec>
+      </command>
+      <command>
+        <name>GNOME Bug</name>
+        <name xml:lang="ur">گنوم بگ</name>
+        <name xml:lang="ur-PK">گنوم بگ</name>
+        <name xml:lang="ug">گىنوم كەمتۈكى</name>
+        <name xml:lang="lv">GNOME Bug</name>
+        <name xml:lang="ast">Fallu de GNOME</name>
+        <name xml:lang="ar">علة جنوم</name>
+        <exec>exo-open https://bugzilla.gnome.org/show_bug.cgi?id=\1</exec>
+      </command>
+    </commands>
+  </action>
+  <action>
+    <name>Long URL</name>
+    <name xml:lang="ur">طویل ربط</name>
+    <name xml:lang="ur-PK">طویل ربط</name>
+    <name xml:lang="ug">ئۇزۇن URL</name>
+    <name xml:lang="lv">Garš URL</name>
+    <name xml:lang="ast">URL llarga</name>
+    <name xml:lang="ar">المسار طويل</name>
+    <regex>https?://[^\s]{120,}</regex>
+    <commands>
+      <command>
+        <name>Shrink the URL</name>
+        <name xml:lang="ur">روابط مختصر کریں</name>
+        <name xml:lang="ur-PK">روابط مختصر کریں</name>
+        <name xml:lang="ug">URL نى قىسقارتىڭ</name>
+        <name xml:lang="lv">Saīsināt URL</name>
+        <name xml:lang="ast">Acurtiar la URL</name>
+        <name xml:lang="ar">تقليص المسار</name>
+        <exec>exo-open https://tinyurl.com/create.php?url=\0</exec>
+      </command>
+    </commands>
+  </action>
+</actions>
diff --git a/tools/initbase/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml b/tools/initbase/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml
new file mode 100644
index 0000000..32901e3
--- /dev/null
+++ b/tools/initbase/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<channel name="xfce4-keyboard-shortcuts" version="1.0">
+  <property name="commands" type="empty">
+    <property name="default" type="empty">
+      <property name="&lt;Alt&gt;F1" type="string" value="xfce4-popup-applicationsmenu"/>
+      <property name="&lt;Alt&gt;F2" type="string" value="xfce4-appfinder --collapsed">
+        <property name="startup-notify" type="bool" value="true"/>
+      </property>
+      <property name="&lt;Alt&gt;F3" type="string" value="xfce4-appfinder">
+        <property name="startup-notify" type="bool" value="true"/>
+      </property>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Delete" type="string" value="xfce4-session-logout"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;l" type="string" value="xflock4"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;t" type="string" value="exo-open --launch TerminalEmulator"/>
+      <property name="XF86Display" type="string" value="xfce4-display-settings --minimal"/>
+      <property name="&lt;Super&gt;p" type="string" value="xfce4-display-settings --minimal"/>
+      <property name="&lt;Primary&gt;Escape" type="string" value="xfdesktop --menu"/>
+      <property name="XF86WWW" type="string" value="exo-open --launch WebBrowser"/>
+      <property name="HomePage" type="string" value="exo-open --launch WebBrowser"/>
+      <property name="XF86Mail" type="string" value="exo-open --launch MailReader"/>
+      <property name="Print" type="string" value="xfce4-screenshooter"/>
+      <property name="&lt;Alt&gt;Print" type="string" value="xfce4-screenshooter -w"/>
+      <property name="&lt;Shift&gt;Print" type="string" value="xfce4-screenshooter -r"/>
+      <property name="&lt;Super&gt;e" type="string" value="thunar"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;f" type="string" value="thunar"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Escape" type="string" value="xkill"/>
+      <property name="&lt;Primary&gt;&lt;Shift&gt;Escape" type="string" value="xfce4-taskmanager"/>
+      <property name="&lt;Super&gt;r" type="string" value="xfce4-appfinder -c">
+        <property name="startup-notify" type="bool" value="true"/>
+      </property>
+      <property name="&lt;Alt&gt;&lt;Super&gt;s" type="string" value="orca"/>
+    </property>
+  </property>
+  <property name="xfwm4" type="empty">
+    <property name="default" type="empty">
+      <property name="&lt;Alt&gt;Insert" type="string" value="add_workspace_key"/>
+      <property name="Escape" type="string" value="cancel_key"/>
+      <property name="Left" type="string" value="left_key"/>
+      <property name="Right" type="string" value="right_key"/>
+      <property name="Up" type="string" value="up_key"/>
+      <property name="Down" type="string" value="down_key"/>
+      <property name="&lt;Alt&gt;Tab" type="string" value="cycle_windows_key"/>
+      <property name="&lt;Alt&gt;&lt;Shift&gt;Tab" type="string" value="cycle_reverse_windows_key"/>
+      <property name="&lt;Alt&gt;Delete" type="string" value="del_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Down" type="string" value="down_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Left" type="string" value="left_workspace_key"/>
+      <property name="&lt;Shift&gt;&lt;Alt&gt;Page_Down" type="string" value="lower_window_key"/>
+      <property name="&lt;Alt&gt;F4" type="string" value="close_window_key"/>
+      <property name="&lt;Alt&gt;F6" type="string" value="stick_window_key"/>
+      <property name="&lt;Alt&gt;F7" type="string" value="move_window_key"/>
+      <property name="&lt;Alt&gt;F8" type="string" value="resize_window_key"/>
+      <property name="&lt;Alt&gt;F9" type="string" value="hide_window_key"/>
+      <property name="&lt;Alt&gt;F10" type="string" value="maximize_window_key"/>
+      <property name="&lt;Alt&gt;F11" type="string" value="fullscreen_key"/>
+      <property name="&lt;Alt&gt;F12" type="string" value="above_key"/>
+      <property name="&lt;Primary&gt;&lt;Shift&gt;&lt;Alt&gt;Left" type="string" value="move_window_left_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;End" type="string" value="move_window_next_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Home" type="string" value="move_window_prev_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Shift&gt;&lt;Alt&gt;Right" type="string" value="move_window_right_key"/>
+      <property name="&lt;Primary&gt;&lt;Shift&gt;&lt;Alt&gt;Up" type="string" value="move_window_up_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_1" type="string" value="move_window_workspace_1_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_2" type="string" value="move_window_workspace_2_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_3" type="string" value="move_window_workspace_3_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_4" type="string" value="move_window_workspace_4_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_5" type="string" value="move_window_workspace_5_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_6" type="string" value="move_window_workspace_6_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_7" type="string" value="move_window_workspace_7_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_8" type="string" value="move_window_workspace_8_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_9" type="string" value="move_window_workspace_9_key"/>
+      <property name="&lt;Alt&gt;space" type="string" value="popup_menu_key"/>
+      <property name="&lt;Shift&gt;&lt;Alt&gt;Page_Up" type="string" value="raise_window_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Right" type="string" value="right_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;d" type="string" value="show_desktop_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Up" type="string" value="up_workspace_key"/>
+      <property name="&lt;Super&gt;Tab" type="string" value="switch_window_key"/>
+      <property name="&lt;Primary&gt;F1" type="string" value="workspace_1_key"/>
+      <property name="&lt;Primary&gt;F2" type="string" value="workspace_2_key"/>
+      <property name="&lt;Primary&gt;F3" type="string" value="workspace_3_key"/>
+      <property name="&lt;Primary&gt;F4" type="string" value="workspace_4_key"/>
+      <property name="&lt;Primary&gt;F5" type="string" value="workspace_5_key"/>
+      <property name="&lt;Primary&gt;F6" type="string" value="workspace_6_key"/>
+      <property name="&lt;Primary&gt;F7" type="string" value="workspace_7_key"/>
+      <property name="&lt;Primary&gt;F8" type="string" value="workspace_8_key"/>
+      <property name="&lt;Primary&gt;F9" type="string" value="workspace_9_key"/>
+      <property name="&lt;Primary&gt;F10" type="string" value="workspace_10_key"/>
+      <property name="&lt;Primary&gt;F11" type="string" value="workspace_11_key"/>
+      <property name="&lt;Primary&gt;F12" type="string" value="workspace_12_key"/>
+      <property name="&lt;Super&gt;KP_Left" type="string" value="tile_left_key"/>
+      <property name="&lt;Super&gt;KP_Right" type="string" value="tile_right_key"/>
+      <property name="&lt;Super&gt;KP_Down" type="string" value="tile_down_key"/>
+      <property name="&lt;Super&gt;KP_Up" type="string" value="tile_up_key"/>
+      <property name="&lt;Super&gt;KP_Page_Up" type="string" value="tile_up_right_key"/>
+      <property name="&lt;Super&gt;KP_Home" type="string" value="tile_up_left_key"/>
+      <property name="&lt;Super&gt;KP_End" type="string" value="tile_down_left_key"/>
+      <property name="&lt;Super&gt;KP_Next" type="string" value="tile_down_right_key"/>
+    </property>
+  </property>
+</channel>
diff --git a/tools/initbase/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-session.xml b/tools/initbase/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-session.xml
new file mode 100644
index 0000000..3bd2f4a
--- /dev/null
+++ b/tools/initbase/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-session.xml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<channel name="xfce4-session" version="1.0">
+  <property name="general" type="empty">
+    <property name="FailsafeSessionName" type="string" value="Failsafe"/>
+    <property name="LockCommand" type="string" value=""/>
+  </property>
+  <property name="sessions" type="empty">
+    <property name="Failsafe" type="empty">
+      <property name="IsFailsafe" type="bool" value="true"/>
+      <property name="Count" type="int" value="5"/>
+      <property name="Client0_Command" type="array">
+        <value type="string" value="xfwm4"/>
+      </property>
+      <property name="Client0_Priority" type="int" value="15"/>
+      <property name="Client0_PerScreen" type="bool" value="false"/>
+      <property name="Client1_Command" type="array">
+        <value type="string" value="xfsettingsd"/>
+      </property>
+      <property name="Client1_Priority" type="int" value="20"/>
+      <property name="Client1_PerScreen" type="bool" value="false"/>
+      <property name="Client2_Command" type="array">
+        <value type="string" value="xfce4-panel"/>
+      </property>
+      <property name="Client2_Priority" type="int" value="25"/>
+      <property name="Client2_PerScreen" type="bool" value="false"/>
+      <property name="Client3_Command" type="array">
+        <value type="string" value="Thunar"/>
+        <value type="string" value="--daemon"/>
+      </property>
+      <property name="Client3_Priority" type="int" value="30"/>
+      <property name="Client3_PerScreen" type="bool" value="false"/>
+      <property name="Client4_Command" type="array">
+        <value type="string" value="xfdesktop"/>
+      </property>
+      <property name="Client4_Priority" type="int" value="35"/>
+      <property name="Client4_PerScreen" type="bool" value="false"/>
+    </property>
+  </property>
+  <property name="sessions" type="empty">
+    <property name="FailsafeWayland" type="empty">
+      <property name="IsFailsafe" type="bool" value="true"/>
+      <property name="Count" type="int" value="4"/>
+      <property name="Client0_Command" type="array">
+        <value type="string" value="xfsettingsd"/>
+      </property>
+      <property name="Client0_Priority" type="int" value="15"/>
+      <property name="Client0_PerScreen" type="bool" value="false"/>
+      <property name="Client1_Command" type="array">
+        <value type="string" value="xfce4-panel"/>
+      </property>
+      <property name="Client1_Priority" type="int" value="15"/>
+      <property name="Client1_PerScreen" type="bool" value="false"/>
+      <property name="Client2_Command" type="array">
+        <value type="string" value="Thunar"/>
+        <value type="string" value="--daemon"/>
+      </property>
+      <property name="Client2_Priority" type="int" value="15"/>
+      <property name="Client2_PerScreen" type="bool" value="false"/>
+      <property name="Client3_Command" type="array">
+        <value type="string" value="xfdesktop"/>
+      </property>
+      <property name="Client3_Priority" type="int" value="15"/>
+      <property name="Client3_PerScreen" type="bool" value="false"/>
+    </property>
+  </property>
+</channel>
diff --git a/tools/initbase/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xsettings.xml b/tools/initbase/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xsettings.xml
new file mode 100644
index 0000000..e983def
--- /dev/null
+++ b/tools/initbase/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xsettings.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Default values for the X settings registry as described in
+  http://www.freedesktop.org/wiki/Specifications/XSettingsRegistry
+-->
+
+<channel name="xsettings" version="1.0">
+  <property name="Net" type="empty">
+    <property name="ThemeName" type="string" value="Adwaita"/>
+    <property name="IconThemeName" type="string" value="elementary"/>
+    <property name="DoubleClickTime" type="int" value="400"/>
+    <property name="DoubleClickDistance" type="int" value="5"/>
+    <property name="DndDragThreshold" type="int" value="8"/>
+    <property name="CursorBlink" type="bool" value="true"/>
+    <property name="CursorBlinkTime" type="int" value="1200"/>
+    <property name="SoundThemeName" type="string" value="default"/>
+    <property name="EnableEventSounds" type="bool" value="false"/>
+    <property name="EnableInputFeedbackSounds" type="bool" value="false"/>
+  </property>
+  <property name="Xft" type="empty">
+    <property name="DPI" type="int" value="96"/>
+    <property name="Antialias" type="int" value="1"/>
+    <property name="Hinting" type="int" value="-1"/>
+    <property name="HintStyle" type="string" value="hintfull"/>
+    <property name="RGBA" type="string" value="none"/>
+  </property>
+  <property name="Gtk" type="empty">
+    <property name="CanChangeAccels" type="bool" value="false"/>
+    <property name="ColorPalette" type="string" value="black:white:gray50:red:purple:blue:light blue:green:yellow:orange:lavender:brown:goldenrod4:dodger blue:pink:light green:gray10:gray30:gray75:gray90"/>
+    <property name="FontName" type="string" value="Sans 10"/>
+    <property name="MonospaceFontName" type="string" value="Monospace 10"/>
+    <property name="IconSizes" type="string" value=""/>
+    <property name="KeyThemeName" type="string" value=""/>
+    <property name="MenuImages" type="bool" value="true"/>
+    <property name="ButtonImages" type="bool" value="true"/>
+    <property name="MenuBarAccel" type="string" value="F10"/>
+    <property name="CursorThemeName" type="string" value=""/>
+    <property name="CursorThemeSize" type="int" value="0"/>
+    <property name="DecorationLayout" type="string" value="menu:minimize,maximize,close"/>
+    <property name="DialogsUseHeader" type="bool" value="false"/>
+    <property name="TitlebarMiddleClick" type="string" value="lower"/>
+  </property>
+  <property name="Gdk" type="empty">
+    <property name="WindowScalingFactor" type="int" value="1"/>
+  </property>
+</channel>
diff --git a/tools/initbase/etc/xdg/xfce4/xinitrc b/tools/initbase/etc/xdg/xfce4/xinitrc
new file mode 100644
index 0000000..5970705
--- /dev/null
+++ b/tools/initbase/etc/xdg/xfce4/xinitrc
@@ -0,0 +1,159 @@
+#!/bin/sh
+
+# fix broken $UID on some system...
+if test "x$UID" = "x"; then
+  if test -x /usr/xpg4/bin/id; then
+    UID=`/usr/xpg4/bin/id -u`;
+  else
+    UID=`id -u`;
+  fi
+fi
+
+# set $XDG_MENU_PREFIX to "xfce-" so that "xfce-applications.menu" is picked
+# over "applications.menu" in all Xfce applications.
+if test "x$XDG_MENU_PREFIX" = "x"; then
+  XDG_MENU_PREFIX="xfce-"
+  export XDG_MENU_PREFIX
+fi
+
+# set DESKTOP_SESSION so that one can detect easily if an Xfce session is running
+if test "x$DESKTOP_SESSION" = "x"; then
+  DESKTOP_SESSION="xfce"
+  export DESKTOP_SESSION
+fi
+
+# set XDG_CURRENT_DESKTOP so that Qt 5 applications can identify user set Xfce theme
+if test "x$XDG_CURRENT_DESKTOP" = "x"; then
+  XDG_CURRENT_DESKTOP="XFCE"
+  export XDG_CURRENT_DESKTOP
+fi
+
+# $XDG_CONFIG_HOME defines the base directory relative to which user specific
+# configuration files should be stored. If $XDG_CONFIG_HOME is either not set
+# or empty, a default equal to $HOME/.config should be used.
+if test "x$XDG_CONFIG_HOME" = "x" ; then
+  XDG_CONFIG_HOME=$HOME/.config
+  export XDG_CONFIG_HOME
+fi
+[ -d "$XDG_CONFIG_HOME" ] || mkdir "$XDG_CONFIG_HOME"
+
+# $XDG_CACHE_HOME defines the base directory relative to which user specific
+# non-essential data files should be stored. If $XDG_CACHE_HOME is either not
+# set or empty, a default equal to $HOME/.cache should be used.
+if test "x$XDG_CACHE_HOME" = "x" ; then
+  XDG_CACHE_HOME=$HOME/.cache
+  export XDG_CACHE_HOME
+fi
+[ -d "$XDG_CACHE_HOME" ] || mkdir "$XDG_CACHE_HOME"
+
+# set up XDG user directores.  see
+# http://freedesktop.org/wiki/Software/xdg-user-dirs
+if command -v xdg-user-dirs-update >/dev/null 2>&1; then
+    xdg-user-dirs-update
+fi
+
+if test "x$XFCE4_SESSION_COMPOSITOR" = "x"
+then
+  # For now, start with an empty list
+  XRESOURCES=""
+
+  # Has to go prior to merging Xft.xrdb, as its the "Defaults" file
+  test -r "/etc/xdg/xfce4/Xft.xrdb" && XRESOURCES="$XRESOURCES /etc/xdg/xfce4/Xft.xrdb"
+  test -r $HOME/.Xdefaults && XRESOURCES="$XRESOURCES $HOME/.Xdefaults"
+
+  BASEDIR=$XDG_CONFIG_HOME/xfce4
+  if test -r "$BASEDIR/Xft.xrdb"; then
+    XRESOURCES="$XRESOURCES $BASEDIR/Xft.xrdb"
+  elif test -r "$XFCE4HOME/Xft.xrdb"; then
+    mkdir -p "$BASEDIR"
+    cp "$XFCE4HOME/Xft.xrdb" "$BASEDIR"/
+    XRESOURCES="$XRESOURCES $BASEDIR/Xft.xrdb"
+  fi
+
+  # merge in X cursor settings
+  test -r "$BASEDIR/Xcursor.xrdb" && XRESOURCES="$XRESOURCES $BASEDIR/Xcursor.xrdb"
+
+  # ~/.Xresources contains overrides to the above
+  test -r "$HOME/.Xresources" && XRESOURCES="$XRESOURCES $HOME/.Xresources"
+
+  # load all X resources (adds /dev/null to avoid an empty list that would hang the process)
+  cat /dev/null $XRESOURCES | xrdb -merge -
+
+  # load local modmap
+  test -r $HOME/.Xmodmap && xmodmap $HOME/.Xmodmap
+fi
+
+# ensure both the DBus session bus and systemd user session (if running) has
+# all the env vars it needs to properly populate the environment of child
+# processes
+if command -v dbus-update-activation-environment >/dev/null 2>&1; then
+  if command -v systemctl >/dev/null 2>&1 && systemctl --user list-jobs >/dev/null 2>&1; then # user session is running
+    systemd_arg='--systemd'
+  fi
+
+  dbus-update-activation-environment $systemd_arg \
+    DESKTOP_SESSION \
+    XAUTHLOCALHOSTNAME=$XAUTHLOCALHOSTNAME \
+    XDG_CACHE_HOME \
+    XDG_CONFIG_DIRS \
+    XDG_CONFIG_HOME \
+    XDG_CURRENT_DESKTOP \
+    XDG_DATA_DIRS \
+    XDG_DATA_HOME \
+    XDG_MENU_PREFIX \
+    XDG_RUNTIME_DIR \
+    XDG_SEAT \
+    XDG_SEAT_PATH \
+    XDG_SESSION_CLASS \
+    XDG_SESSION_DESKTOP \
+    XDG_SESSION_ID \
+    XDG_SESSION_PATH \
+    XDG_SESSION_TYPE \
+    XDG_STATE_HOME
+fi
+
+# source system xinitrc scripts
+if [ -d /etc/X11/xinit/xinitrc.d ]; then
+  for f in /etc/X11/xinit/xinitrc.d/?*.sh; do
+    [ -x "$f" ] && . "$f"
+  done
+  unset f
+fi
+
+# check if we start xfce4-session with ck-launch-session. this is only
+# required for starting from a console, not a login manager
+if test "x$XFCE4_SESSION_WITH_CK" = "x1"; then
+  if command -v ck-launch-session >/dev/null 2>&1; then
+    exec ck-launch-session xfce4-session
+  else
+    echo
+    echo "You have tried to start Xfce with consolekit support, but"
+    echo "ck-launch-session is not installed."
+    echo "Aborted startup..."
+    echo
+    exit 1
+  fi
+else
+  # workaround https://github.com/canonical/lightdm/issues/63
+  if [ -n "$XDG_VTNR" ] && [ -f "/sys/devices/virtual/tty/tty0/active" ]; then
+    VT_TEST_CNT=1
+    while true; do
+      CURRENT_VT=$(cat /sys/devices/virtual/tty/tty0/active)
+      if [ "$CURRENT_VT" = "tty$XDG_VTNR" ]; then
+        break
+      fi
+      VT_TEST_CNT=$((VT_TEST_CNT + 1))
+      if [ "$VT_TEST_CNT" -gt 100 ]; then
+        echo "VT $XDG_VTNR is expected but the switch did not happen in the last second, continuing anyway."
+        break
+      fi
+      sleep 0.01
+    done
+  fi
+
+  # start xfce4-session normally
+  exec ${XFCE4_SESSION_COMPOSITOR:-xfce4-session}
+fi
+
+# if we got here, then exec failed
+exit 1
diff --git a/tools/initbase/root/.bashrc b/tools/initbase/root/.bashrc
index b221318..04160ee 100644
--- a/tools/initbase/root/.bashrc
+++ b/tools/initbase/root/.bashrc
@@ -1,5 +1,4 @@
 PS1='\e[92m\u\e[0m@\e[38;5;214morange\e[0m-# '
-export TERM="linux"
 export SHELL="/bin/bash"
 export PATH="/usr/bin"
 
diff --git a/tools/initbase/root/.config/i3/config b/tools/initbase/root/.config/i3/config
index f7d571e..4a0ebb6 100644
--- a/tools/initbase/root/.config/i3/config
+++ b/tools/initbase/root/.config/i3/config
@@ -29,7 +29,7 @@ exec --no-startup-id dex --autostart --environment i3
 # xss-lock grabs a logind suspend inhibit lock and will use i3lock to lock the
 # screen before suspend. Use loginctl lock-session to lock your screen.
 exec --no-startup-id xss-lock --transfer-sleep-lock -- i3lock --nofork
-exec st
+exec "cd ~ && st"
 exec xwallpaper --zoom /etc/twmbg.png
 
 # NetworkManager is the most popular way to manage wireless networks on Linux,
@@ -47,7 +47,7 @@ bindsym XF86AudioMicMute exec --no-startup-id pactl set-source-mute @DEFAULT_SOU
 floating_modifier $mod
 
 # start a terminal
-bindsym $mod+Return exec st
+bindsym $mod+Return exec "cd ~ && st"
 
 # kill focused window
 bindsym $mod+Shift+q kill
diff --git a/tools/initbase/root/.config/xfce4/Xft.xrdb b/tools/initbase/root/.config/xfce4/Xft.xrdb
new file mode 100644
index 0000000..cd26513
--- /dev/null
+++ b/tools/initbase/root/.config/xfce4/Xft.xrdb
@@ -0,0 +1,7 @@
+! Those are fallback settings, use the ui plugin to change it
+! or add your overrides to ~/.Xresources
+! Xft.hintstyle: hintnone/hintslight/hintmedium/hintfull
+! Xft hinting: 1/0
+
+Xft.hinting: 1
+Xft.hintstyle: hintmedium
diff --git a/tools/initbase/root/.config/xfce4/helpers.rc b/tools/initbase/root/.config/xfce4/helpers.rc
new file mode 100644
index 0000000..9e2bb31
--- /dev/null
+++ b/tools/initbase/root/.config/xfce4/helpers.rc
@@ -0,0 +1,10 @@
+#
+# Default helpers.rc for Xfce's Preferred Applications
+#
+# Copyright (c) 2005-2006 Benedikt Meurer <benny@xfce.org>
+#
+
+WebBrowser=firefox
+MailReader=thunderbird
+TerminalEmulator=xfce4-terminal
+FileManager=thunar
diff --git a/tools/initbase/root/.config/xfce4/panel/default.xml b/tools/initbase/root/.config/xfce4/panel/default.xml
new file mode 100644
index 0000000..289a8de
--- /dev/null
+++ b/tools/initbase/root/.config/xfce4/panel/default.xml
@@ -0,0 +1,95 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<channel name="xfce4-panel" version="1.0">
+  <property name="configver" type="int" value="2"/>
+  <property name="panels" type="array">
+    <value type="int" value="1"/>
+    <value type="int" value="2"/>
+    <property name="dark-mode" type="bool" value="true"/>
+    <property name="panel-1" type="empty">
+      <property name="position" type="string" value="p=6;x=0;y=0"/>
+      <property name="length" type="uint" value="100"/>
+      <property name="position-locked" type="bool" value="true"/>
+      <property name="icon-size" type="uint" value="16"/>
+      <property name="size" type="uint" value="26"/>
+      <property name="plugin-ids" type="array">
+        <value type="int" value="1"/>
+        <value type="int" value="2"/>
+        <value type="int" value="3"/>
+        <value type="int" value="4"/>
+        <value type="int" value="5"/>
+        <value type="int" value="6"/>
+        <value type="int" value="7"/>
+        <value type="int" value="8"/>
+        <value type="int" value="9"/>
+        <value type="int" value="10"/>
+      </property>
+    </property>
+    <property name="panel-2" type="empty">
+      <property name="autohide-behavior" type="uint" value="1"/>
+      <property name="position" type="string" value="p=10;x=0;y=0"/>
+      <property name="length" type="uint" value="1"/>
+      <property name="position-locked" type="bool" value="true"/>
+      <property name="size" type="uint" value="48"/>
+      <property name="plugin-ids" type="array">
+        <value type="int" value="11"/>
+        <value type="int" value="12"/>
+        <value type="int" value="13"/>
+        <value type="int" value="14"/>
+        <value type="int" value="15"/>
+        <value type="int" value="16"/>
+        <value type="int" value="17"/>
+        <value type="int" value="18"/>
+      </property>
+    </property>
+  </property>
+  <property name="plugins" type="empty">
+    <property name="plugin-1" type="string" value="applicationsmenu"/>
+    <property name="plugin-2" type="string" value="tasklist">
+      <property name="grouping" type="uint" value="1"/>
+    </property>
+    <property name="plugin-3" type="string" value="separator">
+      <property name="expand" type="bool" value="true"/>
+      <property name="style" type="uint" value="0"/>
+    </property>
+    <property name="plugin-4" type="string" value="pager"/>
+    <property name="plugin-5" type="string" value="separator">
+        <property name="style" type="uint" value="0"/>
+    </property>
+    <property name="plugin-6" type="string" value="systray">
+        <property name="square-icons" type="bool" value="true"/>
+    </property>
+    <property name="plugin-7" type="string" value="separator">
+      <property name="style" type="uint" value="0"/>
+    </property>
+    <property name="plugin-8" type="string" value="clock"/>
+    <property name="plugin-9" type="string" value="separator">
+      <property name="style" type="uint" value="0"/>
+    </property>
+    <property name="plugin-10" type="string" value="actions"/>
+    <property name="plugin-11" type="string" value="showdesktop"/>
+    <property name="plugin-12" type="string" value="separator"/>
+    <property name="plugin-13" type="string" value="launcher">
+      <property name="items" type="array">
+        <value type="string" value="xfce4-terminal-emulator.desktop"/>
+      </property>
+    </property>
+    <property name="plugin-14" type="string" value="launcher">
+      <property name="items" type="array">
+        <value type="string" value="xfce4-file-manager.desktop"/>
+      </property>
+    </property>
+    <property name="plugin-15" type="string" value="launcher">
+      <property name="items" type="array">
+        <value type="string" value="xfce4-web-browser.desktop"/>
+      </property>
+    </property>
+    <property name="plugin-16" type="string" value="launcher">
+      <property name="items" type="array">
+        <value type="string" value="xfce4-appfinder.desktop"/>
+      </property>
+    </property>
+    <property name="plugin-17" type="string" value="separator"/>
+    <property name="plugin-18" type="string" value="directorymenu"/>
+  </property>
+</channel>
diff --git a/tools/initbase/root/.config/xfce4/panel/xfce4-clipman-actions.xml b/tools/initbase/root/.config/xfce4/panel/xfce4-clipman-actions.xml
new file mode 100644
index 0000000..0581b44
--- /dev/null
+++ b/tools/initbase/root/.config/xfce4/panel/xfce4-clipman-actions.xml
@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE actions [
+<!ELEMENT actions (action)+>
+<!ELEMENT action (name , regex , commands)>
+<!ELEMENT commands (command)+>
+<!ELEMENT command (name , exec)>
+<!ELEMENT name (#PCDATA)>
+<!ATTLIST name xml:lang CDATA #IMPLIED>
+<!ELEMENT regex (#PCDATA)>
+<!ELEMENT exec (#PCDATA)>
+]>
+<!--
+  Copyright (c) 2009-2011 Mike Massonnet <mmassonnet@xfce.org>
+
+  Default Clipman actions configuration file, which gets installed system-wide.
+  This should act more like an example, and is therefore kept simple.
+-->
+<actions>
+  <action>
+    <name>Image</name>
+    <name xml:lang="ur">تصویر</name>
+    <name xml:lang="ur-PK">تصویر</name>
+    <name xml:lang="ug">سۈرەت</name>
+    <name xml:lang="lv">Attēls</name>
+    <name xml:lang="ast">Imaxe</name>
+    <name xml:lang="ar">صورة</name>
+    <regex>(http|ftp).+\.(jpg|png|gif)</regex>
+    <commands>
+      <command>
+        <name>Edit with Gimp</name>
+        <name xml:lang="ur">گمپ سے مدون کریں</name>
+        <name xml:lang="ur-PK">گمپ سے مدون کریں</name>
+        <name xml:lang="ug">GIMP دە تەھرىرلەش</name>
+        <name xml:lang="lv">Rediģēt ar Gimp</name>
+        <name xml:lang="ast">Editar con GIMP</name>
+        <name xml:lang="ar">تحرير باستخدام جمب</name>
+        <exec>gimp "\0"</exec>
+      </command>
+      <command>
+        <name>View with Ristretto</name>
+        <name xml:lang="ur">ریسٹریٹو کے ذریعہ دیکھیں</name>
+        <name xml:lang="ur-PK">ریسٹریٹو کے ذریعہ دیکھیں</name>
+        <name xml:lang="ug">Ristretto دە كۆرسەت</name>
+        <name xml:lang="lv">Apskatīt ar Ristretto</name>
+        <name xml:lang="ast">Ver con Ristretto</name>
+        <name xml:lang="ar">عرض مع ريستريتو</name>
+        <exec>ristretto "\0"</exec>
+      </command>
+    </commands>
+  </action>
+  <action>
+    <name>Bugz</name>
+    <name xml:lang="ur">بگز</name>
+    <name xml:lang="ur-PK">بگز</name>
+    <name xml:lang="ug">Bugz</name>
+    <name xml:lang="lv">Bugz</name>
+    <name xml:lang="ast">Bugz</name>
+    <name xml:lang="ar">Bugz</name>
+    <regex>bug\s*#?\s*([0-9]+)</regex>
+    <commands>
+      <command>
+        <name>Xfce Bug</name>
+        <name xml:lang="ur">ایکسفس بگ</name>
+        <name xml:lang="ur-PK">ایکسفس بگ</name>
+        <name xml:lang="ug">Xfce  كەمتۈكى</name>
+        <name xml:lang="lv">Xfce Bug</name>
+        <name xml:lang="ast">Fallu de Xfce</name>
+        <name xml:lang="ar">علة Xfce</name>
+        <exec>exo-open https://bugzilla.xfce.org/show_bug.cgi?id=\1</exec>
+      </command>
+      <command>
+        <name>GNOME Bug</name>
+        <name xml:lang="ur">گنوم بگ</name>
+        <name xml:lang="ur-PK">گنوم بگ</name>
+        <name xml:lang="ug">گىنوم كەمتۈكى</name>
+        <name xml:lang="lv">GNOME Bug</name>
+        <name xml:lang="ast">Fallu de GNOME</name>
+        <name xml:lang="ar">علة جنوم</name>
+        <exec>exo-open https://bugzilla.gnome.org/show_bug.cgi?id=\1</exec>
+      </command>
+    </commands>
+  </action>
+  <action>
+    <name>Long URL</name>
+    <name xml:lang="ur">طویل ربط</name>
+    <name xml:lang="ur-PK">طویل ربط</name>
+    <name xml:lang="ug">ئۇزۇن URL</name>
+    <name xml:lang="lv">Garš URL</name>
+    <name xml:lang="ast">URL llarga</name>
+    <name xml:lang="ar">المسار طويل</name>
+    <regex>https?://[^\s]{120,}</regex>
+    <commands>
+      <command>
+        <name>Shrink the URL</name>
+        <name xml:lang="ur">روابط مختصر کریں</name>
+        <name xml:lang="ur-PK">روابط مختصر کریں</name>
+        <name xml:lang="ug">URL نى قىسقارتىڭ</name>
+        <name xml:lang="lv">Saīsināt URL</name>
+        <name xml:lang="ast">Acurtiar la URL</name>
+        <name xml:lang="ar">تقليص المسار</name>
+        <exec>exo-open https://tinyurl.com/create.php?url=\0</exec>
+      </command>
+    </commands>
+  </action>
+</actions>
diff --git a/tools/initbase/root/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml b/tools/initbase/root/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml
new file mode 100644
index 0000000..32901e3
--- /dev/null
+++ b/tools/initbase/root/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<channel name="xfce4-keyboard-shortcuts" version="1.0">
+  <property name="commands" type="empty">
+    <property name="default" type="empty">
+      <property name="&lt;Alt&gt;F1" type="string" value="xfce4-popup-applicationsmenu"/>
+      <property name="&lt;Alt&gt;F2" type="string" value="xfce4-appfinder --collapsed">
+        <property name="startup-notify" type="bool" value="true"/>
+      </property>
+      <property name="&lt;Alt&gt;F3" type="string" value="xfce4-appfinder">
+        <property name="startup-notify" type="bool" value="true"/>
+      </property>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Delete" type="string" value="xfce4-session-logout"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;l" type="string" value="xflock4"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;t" type="string" value="exo-open --launch TerminalEmulator"/>
+      <property name="XF86Display" type="string" value="xfce4-display-settings --minimal"/>
+      <property name="&lt;Super&gt;p" type="string" value="xfce4-display-settings --minimal"/>
+      <property name="&lt;Primary&gt;Escape" type="string" value="xfdesktop --menu"/>
+      <property name="XF86WWW" type="string" value="exo-open --launch WebBrowser"/>
+      <property name="HomePage" type="string" value="exo-open --launch WebBrowser"/>
+      <property name="XF86Mail" type="string" value="exo-open --launch MailReader"/>
+      <property name="Print" type="string" value="xfce4-screenshooter"/>
+      <property name="&lt;Alt&gt;Print" type="string" value="xfce4-screenshooter -w"/>
+      <property name="&lt;Shift&gt;Print" type="string" value="xfce4-screenshooter -r"/>
+      <property name="&lt;Super&gt;e" type="string" value="thunar"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;f" type="string" value="thunar"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Escape" type="string" value="xkill"/>
+      <property name="&lt;Primary&gt;&lt;Shift&gt;Escape" type="string" value="xfce4-taskmanager"/>
+      <property name="&lt;Super&gt;r" type="string" value="xfce4-appfinder -c">
+        <property name="startup-notify" type="bool" value="true"/>
+      </property>
+      <property name="&lt;Alt&gt;&lt;Super&gt;s" type="string" value="orca"/>
+    </property>
+  </property>
+  <property name="xfwm4" type="empty">
+    <property name="default" type="empty">
+      <property name="&lt;Alt&gt;Insert" type="string" value="add_workspace_key"/>
+      <property name="Escape" type="string" value="cancel_key"/>
+      <property name="Left" type="string" value="left_key"/>
+      <property name="Right" type="string" value="right_key"/>
+      <property name="Up" type="string" value="up_key"/>
+      <property name="Down" type="string" value="down_key"/>
+      <property name="&lt;Alt&gt;Tab" type="string" value="cycle_windows_key"/>
+      <property name="&lt;Alt&gt;&lt;Shift&gt;Tab" type="string" value="cycle_reverse_windows_key"/>
+      <property name="&lt;Alt&gt;Delete" type="string" value="del_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Down" type="string" value="down_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Left" type="string" value="left_workspace_key"/>
+      <property name="&lt;Shift&gt;&lt;Alt&gt;Page_Down" type="string" value="lower_window_key"/>
+      <property name="&lt;Alt&gt;F4" type="string" value="close_window_key"/>
+      <property name="&lt;Alt&gt;F6" type="string" value="stick_window_key"/>
+      <property name="&lt;Alt&gt;F7" type="string" value="move_window_key"/>
+      <property name="&lt;Alt&gt;F8" type="string" value="resize_window_key"/>
+      <property name="&lt;Alt&gt;F9" type="string" value="hide_window_key"/>
+      <property name="&lt;Alt&gt;F10" type="string" value="maximize_window_key"/>
+      <property name="&lt;Alt&gt;F11" type="string" value="fullscreen_key"/>
+      <property name="&lt;Alt&gt;F12" type="string" value="above_key"/>
+      <property name="&lt;Primary&gt;&lt;Shift&gt;&lt;Alt&gt;Left" type="string" value="move_window_left_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;End" type="string" value="move_window_next_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Home" type="string" value="move_window_prev_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Shift&gt;&lt;Alt&gt;Right" type="string" value="move_window_right_key"/>
+      <property name="&lt;Primary&gt;&lt;Shift&gt;&lt;Alt&gt;Up" type="string" value="move_window_up_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_1" type="string" value="move_window_workspace_1_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_2" type="string" value="move_window_workspace_2_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_3" type="string" value="move_window_workspace_3_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_4" type="string" value="move_window_workspace_4_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_5" type="string" value="move_window_workspace_5_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_6" type="string" value="move_window_workspace_6_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_7" type="string" value="move_window_workspace_7_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_8" type="string" value="move_window_workspace_8_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;KP_9" type="string" value="move_window_workspace_9_key"/>
+      <property name="&lt;Alt&gt;space" type="string" value="popup_menu_key"/>
+      <property name="&lt;Shift&gt;&lt;Alt&gt;Page_Up" type="string" value="raise_window_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Right" type="string" value="right_workspace_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;d" type="string" value="show_desktop_key"/>
+      <property name="&lt;Primary&gt;&lt;Alt&gt;Up" type="string" value="up_workspace_key"/>
+      <property name="&lt;Super&gt;Tab" type="string" value="switch_window_key"/>
+      <property name="&lt;Primary&gt;F1" type="string" value="workspace_1_key"/>
+      <property name="&lt;Primary&gt;F2" type="string" value="workspace_2_key"/>
+      <property name="&lt;Primary&gt;F3" type="string" value="workspace_3_key"/>
+      <property name="&lt;Primary&gt;F4" type="string" value="workspace_4_key"/>
+      <property name="&lt;Primary&gt;F5" type="string" value="workspace_5_key"/>
+      <property name="&lt;Primary&gt;F6" type="string" value="workspace_6_key"/>
+      <property name="&lt;Primary&gt;F7" type="string" value="workspace_7_key"/>
+      <property name="&lt;Primary&gt;F8" type="string" value="workspace_8_key"/>
+      <property name="&lt;Primary&gt;F9" type="string" value="workspace_9_key"/>
+      <property name="&lt;Primary&gt;F10" type="string" value="workspace_10_key"/>
+      <property name="&lt;Primary&gt;F11" type="string" value="workspace_11_key"/>
+      <property name="&lt;Primary&gt;F12" type="string" value="workspace_12_key"/>
+      <property name="&lt;Super&gt;KP_Left" type="string" value="tile_left_key"/>
+      <property name="&lt;Super&gt;KP_Right" type="string" value="tile_right_key"/>
+      <property name="&lt;Super&gt;KP_Down" type="string" value="tile_down_key"/>
+      <property name="&lt;Super&gt;KP_Up" type="string" value="tile_up_key"/>
+      <property name="&lt;Super&gt;KP_Page_Up" type="string" value="tile_up_right_key"/>
+      <property name="&lt;Super&gt;KP_Home" type="string" value="tile_up_left_key"/>
+      <property name="&lt;Super&gt;KP_End" type="string" value="tile_down_left_key"/>
+      <property name="&lt;Super&gt;KP_Next" type="string" value="tile_down_right_key"/>
+    </property>
+  </property>
+</channel>
diff --git a/tools/initbase/root/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-session.xml b/tools/initbase/root/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-session.xml
new file mode 100644
index 0000000..3bd2f4a
--- /dev/null
+++ b/tools/initbase/root/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-session.xml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<channel name="xfce4-session" version="1.0">
+  <property name="general" type="empty">
+    <property name="FailsafeSessionName" type="string" value="Failsafe"/>
+    <property name="LockCommand" type="string" value=""/>
+  </property>
+  <property name="sessions" type="empty">
+    <property name="Failsafe" type="empty">
+      <property name="IsFailsafe" type="bool" value="true"/>
+      <property name="Count" type="int" value="5"/>
+      <property name="Client0_Command" type="array">
+        <value type="string" value="xfwm4"/>
+      </property>
+      <property name="Client0_Priority" type="int" value="15"/>
+      <property name="Client0_PerScreen" type="bool" value="false"/>
+      <property name="Client1_Command" type="array">
+        <value type="string" value="xfsettingsd"/>
+      </property>
+      <property name="Client1_Priority" type="int" value="20"/>
+      <property name="Client1_PerScreen" type="bool" value="false"/>
+      <property name="Client2_Command" type="array">
+        <value type="string" value="xfce4-panel"/>
+      </property>
+      <property name="Client2_Priority" type="int" value="25"/>
+      <property name="Client2_PerScreen" type="bool" value="false"/>
+      <property name="Client3_Command" type="array">
+        <value type="string" value="Thunar"/>
+        <value type="string" value="--daemon"/>
+      </property>
+      <property name="Client3_Priority" type="int" value="30"/>
+      <property name="Client3_PerScreen" type="bool" value="false"/>
+      <property name="Client4_Command" type="array">
+        <value type="string" value="xfdesktop"/>
+      </property>
+      <property name="Client4_Priority" type="int" value="35"/>
+      <property name="Client4_PerScreen" type="bool" value="false"/>
+    </property>
+  </property>
+  <property name="sessions" type="empty">
+    <property name="FailsafeWayland" type="empty">
+      <property name="IsFailsafe" type="bool" value="true"/>
+      <property name="Count" type="int" value="4"/>
+      <property name="Client0_Command" type="array">
+        <value type="string" value="xfsettingsd"/>
+      </property>
+      <property name="Client0_Priority" type="int" value="15"/>
+      <property name="Client0_PerScreen" type="bool" value="false"/>
+      <property name="Client1_Command" type="array">
+        <value type="string" value="xfce4-panel"/>
+      </property>
+      <property name="Client1_Priority" type="int" value="15"/>
+      <property name="Client1_PerScreen" type="bool" value="false"/>
+      <property name="Client2_Command" type="array">
+        <value type="string" value="Thunar"/>
+        <value type="string" value="--daemon"/>
+      </property>
+      <property name="Client2_Priority" type="int" value="15"/>
+      <property name="Client2_PerScreen" type="bool" value="false"/>
+      <property name="Client3_Command" type="array">
+        <value type="string" value="xfdesktop"/>
+      </property>
+      <property name="Client3_Priority" type="int" value="15"/>
+      <property name="Client3_PerScreen" type="bool" value="false"/>
+    </property>
+  </property>
+</channel>
diff --git a/tools/initbase/root/.config/xfce4/xfconf/xfce-perchannel-xml/xsettings.xml b/tools/initbase/root/.config/xfce4/xfconf/xfce-perchannel-xml/xsettings.xml
new file mode 100644
index 0000000..e983def
--- /dev/null
+++ b/tools/initbase/root/.config/xfce4/xfconf/xfce-perchannel-xml/xsettings.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Default values for the X settings registry as described in
+  http://www.freedesktop.org/wiki/Specifications/XSettingsRegistry
+-->
+
+<channel name="xsettings" version="1.0">
+  <property name="Net" type="empty">
+    <property name="ThemeName" type="string" value="Adwaita"/>
+    <property name="IconThemeName" type="string" value="elementary"/>
+    <property name="DoubleClickTime" type="int" value="400"/>
+    <property name="DoubleClickDistance" type="int" value="5"/>
+    <property name="DndDragThreshold" type="int" value="8"/>
+    <property name="CursorBlink" type="bool" value="true"/>
+    <property name="CursorBlinkTime" type="int" value="1200"/>
+    <property name="SoundThemeName" type="string" value="default"/>
+    <property name="EnableEventSounds" type="bool" value="false"/>
+    <property name="EnableInputFeedbackSounds" type="bool" value="false"/>
+  </property>
+  <property name="Xft" type="empty">
+    <property name="DPI" type="int" value="96"/>
+    <property name="Antialias" type="int" value="1"/>
+    <property name="Hinting" type="int" value="-1"/>
+    <property name="HintStyle" type="string" value="hintfull"/>
+    <property name="RGBA" type="string" value="none"/>
+  </property>
+  <property name="Gtk" type="empty">
+    <property name="CanChangeAccels" type="bool" value="false"/>
+    <property name="ColorPalette" type="string" value="black:white:gray50:red:purple:blue:light blue:green:yellow:orange:lavender:brown:goldenrod4:dodger blue:pink:light green:gray10:gray30:gray75:gray90"/>
+    <property name="FontName" type="string" value="Sans 10"/>
+    <property name="MonospaceFontName" type="string" value="Monospace 10"/>
+    <property name="IconSizes" type="string" value=""/>
+    <property name="KeyThemeName" type="string" value=""/>
+    <property name="MenuImages" type="bool" value="true"/>
+    <property name="ButtonImages" type="bool" value="true"/>
+    <property name="MenuBarAccel" type="string" value="F10"/>
+    <property name="CursorThemeName" type="string" value=""/>
+    <property name="CursorThemeSize" type="int" value="0"/>
+    <property name="DecorationLayout" type="string" value="menu:minimize,maximize,close"/>
+    <property name="DialogsUseHeader" type="bool" value="false"/>
+    <property name="TitlebarMiddleClick" type="string" value="lower"/>
+  </property>
+  <property name="Gdk" type="empty">
+    <property name="WindowScalingFactor" type="int" value="1"/>
+  </property>
+</channel>
diff --git a/tools/initbase/root/.config/xfce4/xinitrc b/tools/initbase/root/.config/xfce4/xinitrc
new file mode 100644
index 0000000..5970705
--- /dev/null
+++ b/tools/initbase/root/.config/xfce4/xinitrc
@@ -0,0 +1,159 @@
+#!/bin/sh
+
+# fix broken $UID on some system...
+if test "x$UID" = "x"; then
+  if test -x /usr/xpg4/bin/id; then
+    UID=`/usr/xpg4/bin/id -u`;
+  else
+    UID=`id -u`;
+  fi
+fi
+
+# set $XDG_MENU_PREFIX to "xfce-" so that "xfce-applications.menu" is picked
+# over "applications.menu" in all Xfce applications.
+if test "x$XDG_MENU_PREFIX" = "x"; then
+  XDG_MENU_PREFIX="xfce-"
+  export XDG_MENU_PREFIX
+fi
+
+# set DESKTOP_SESSION so that one can detect easily if an Xfce session is running
+if test "x$DESKTOP_SESSION" = "x"; then
+  DESKTOP_SESSION="xfce"
+  export DESKTOP_SESSION
+fi
+
+# set XDG_CURRENT_DESKTOP so that Qt 5 applications can identify user set Xfce theme
+if test "x$XDG_CURRENT_DESKTOP" = "x"; then
+  XDG_CURRENT_DESKTOP="XFCE"
+  export XDG_CURRENT_DESKTOP
+fi
+
+# $XDG_CONFIG_HOME defines the base directory relative to which user specific
+# configuration files should be stored. If $XDG_CONFIG_HOME is either not set
+# or empty, a default equal to $HOME/.config should be used.
+if test "x$XDG_CONFIG_HOME" = "x" ; then
+  XDG_CONFIG_HOME=$HOME/.config
+  export XDG_CONFIG_HOME
+fi
+[ -d "$XDG_CONFIG_HOME" ] || mkdir "$XDG_CONFIG_HOME"
+
+# $XDG_CACHE_HOME defines the base directory relative to which user specific
+# non-essential data files should be stored. If $XDG_CACHE_HOME is either not
+# set or empty, a default equal to $HOME/.cache should be used.
+if test "x$XDG_CACHE_HOME" = "x" ; then
+  XDG_CACHE_HOME=$HOME/.cache
+  export XDG_CACHE_HOME
+fi
+[ -d "$XDG_CACHE_HOME" ] || mkdir "$XDG_CACHE_HOME"
+
+# set up XDG user directores.  see
+# http://freedesktop.org/wiki/Software/xdg-user-dirs
+if command -v xdg-user-dirs-update >/dev/null 2>&1; then
+    xdg-user-dirs-update
+fi
+
+if test "x$XFCE4_SESSION_COMPOSITOR" = "x"
+then
+  # For now, start with an empty list
+  XRESOURCES=""
+
+  # Has to go prior to merging Xft.xrdb, as its the "Defaults" file
+  test -r "/etc/xdg/xfce4/Xft.xrdb" && XRESOURCES="$XRESOURCES /etc/xdg/xfce4/Xft.xrdb"
+  test -r $HOME/.Xdefaults && XRESOURCES="$XRESOURCES $HOME/.Xdefaults"
+
+  BASEDIR=$XDG_CONFIG_HOME/xfce4
+  if test -r "$BASEDIR/Xft.xrdb"; then
+    XRESOURCES="$XRESOURCES $BASEDIR/Xft.xrdb"
+  elif test -r "$XFCE4HOME/Xft.xrdb"; then
+    mkdir -p "$BASEDIR"
+    cp "$XFCE4HOME/Xft.xrdb" "$BASEDIR"/
+    XRESOURCES="$XRESOURCES $BASEDIR/Xft.xrdb"
+  fi
+
+  # merge in X cursor settings
+  test -r "$BASEDIR/Xcursor.xrdb" && XRESOURCES="$XRESOURCES $BASEDIR/Xcursor.xrdb"
+
+  # ~/.Xresources contains overrides to the above
+  test -r "$HOME/.Xresources" && XRESOURCES="$XRESOURCES $HOME/.Xresources"
+
+  # load all X resources (adds /dev/null to avoid an empty list that would hang the process)
+  cat /dev/null $XRESOURCES | xrdb -merge -
+
+  # load local modmap
+  test -r $HOME/.Xmodmap && xmodmap $HOME/.Xmodmap
+fi
+
+# ensure both the DBus session bus and systemd user session (if running) has
+# all the env vars it needs to properly populate the environment of child
+# processes
+if command -v dbus-update-activation-environment >/dev/null 2>&1; then
+  if command -v systemctl >/dev/null 2>&1 && systemctl --user list-jobs >/dev/null 2>&1; then # user session is running
+    systemd_arg='--systemd'
+  fi
+
+  dbus-update-activation-environment $systemd_arg \
+    DESKTOP_SESSION \
+    XAUTHLOCALHOSTNAME=$XAUTHLOCALHOSTNAME \
+    XDG_CACHE_HOME \
+    XDG_CONFIG_DIRS \
+    XDG_CONFIG_HOME \
+    XDG_CURRENT_DESKTOP \
+    XDG_DATA_DIRS \
+    XDG_DATA_HOME \
+    XDG_MENU_PREFIX \
+    XDG_RUNTIME_DIR \
+    XDG_SEAT \
+    XDG_SEAT_PATH \
+    XDG_SESSION_CLASS \
+    XDG_SESSION_DESKTOP \
+    XDG_SESSION_ID \
+    XDG_SESSION_PATH \
+    XDG_SESSION_TYPE \
+    XDG_STATE_HOME
+fi
+
+# source system xinitrc scripts
+if [ -d /etc/X11/xinit/xinitrc.d ]; then
+  for f in /etc/X11/xinit/xinitrc.d/?*.sh; do
+    [ -x "$f" ] && . "$f"
+  done
+  unset f
+fi
+
+# check if we start xfce4-session with ck-launch-session. this is only
+# required for starting from a console, not a login manager
+if test "x$XFCE4_SESSION_WITH_CK" = "x1"; then
+  if command -v ck-launch-session >/dev/null 2>&1; then
+    exec ck-launch-session xfce4-session
+  else
+    echo
+    echo "You have tried to start Xfce with consolekit support, but"
+    echo "ck-launch-session is not installed."
+    echo "Aborted startup..."
+    echo
+    exit 1
+  fi
+else
+  # workaround https://github.com/canonical/lightdm/issues/63
+  if [ -n "$XDG_VTNR" ] && [ -f "/sys/devices/virtual/tty/tty0/active" ]; then
+    VT_TEST_CNT=1
+    while true; do
+      CURRENT_VT=$(cat /sys/devices/virtual/tty/tty0/active)
+      if [ "$CURRENT_VT" = "tty$XDG_VTNR" ]; then
+        break
+      fi
+      VT_TEST_CNT=$((VT_TEST_CNT + 1))
+      if [ "$VT_TEST_CNT" -gt 100 ]; then
+        echo "VT $XDG_VTNR is expected but the switch did not happen in the last second, continuing anyway."
+        break
+      fi
+      sleep 0.01
+    done
+  fi
+
+  # start xfce4-session normally
+  exec ${XFCE4_SESSION_COMPOSITOR:-xfce4-session}
+fi
+
+# if we got here, then exec failed
+exit 1
diff --git a/tools/initbase/run/user/0/.keep b/tools/initbase/run/user/0/.keep
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tools/initbase/run/user/0/.keep
diff --git a/tools/pkg/10/mesa-demos/pkg.sh b/tools/pkg/10/mesa-demos/pkg.sh
index c5b4728..5ce41ee 100644
--- a/tools/pkg/10/mesa-demos/pkg.sh
+++ b/tools/pkg/10/mesa-demos/pkg.sh
@@ -12,6 +12,8 @@ tar -xvf mesa-demos-9.0.0.tar.xz
 
 cd mesa-demos-9.0.0
 
+export CFLAGS="$CFLAGS -D_DEFAULT_SOURCE"
+
 mkdir build
 meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr -Dgles1=disabled -Dosmesa=disabled -Dlibdrm=disabled -Dx11=enabled -Dwith-system-data-files=true build
 
diff --git a/tools/pkg/12/xinerama/info.txt b/tools/pkg/12/xinerama/info.txt
new file mode 100644
index 0000000..bebedba
--- /dev/null
+++ b/tools/pkg/12/xinerama/info.txt
@@ -0,0 +1 @@
+xinerama
\ No newline at end of file
diff --git a/tools/pkg/12/xinerama/pkg.sh b/tools/pkg/12/xinerama/pkg.sh
new file mode 100644
index 0000000..35f92ba
--- /dev/null
+++ b/tools/pkg/12/xinerama/pkg.sh
@@ -0,0 +1,15 @@
+
+# 
+
+# https://archive.xfce.org/src/xfce/xfwm4/4.19/xfwm4-4.19.0.tar.bz2
+
+
+. ../../pkg-lib.sh
+
+rm -rf pack
+mkdir -p pack
+cd pack
+
+fast_install "$1" https://www.x.org/releases/individual/lib/libXinerama-1.1.5.tar.gz
+
+cd ..
\ No newline at end of file
diff --git a/tools/pkg/13/dbus_test/a.out b/tools/pkg/13/dbus_test/a.out
new file mode 100755
index 0000000..288dd23
--- /dev/null
+++ b/tools/pkg/13/dbus_test/a.out
diff --git a/tools/pkg/13/dbus_test/info.txt b/tools/pkg/13/dbus_test/info.txt
new file mode 100644
index 0000000..033a0ca
--- /dev/null
+++ b/tools/pkg/13/dbus_test/info.txt
@@ -0,0 +1 @@
+dbus_test
\ No newline at end of file
diff --git a/tools/pkg/13/dbus_test/main.c b/tools/pkg/13/dbus_test/main.c
new file mode 100644
index 0000000..bcbbc2f
--- /dev/null
+++ b/tools/pkg/13/dbus_test/main.c
@@ -0,0 +1,72 @@
+#include <dbus/dbus.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+    DBusConnection *conn;
+    DBusError err;
+    DBusMessage *msg;
+    DBusMessage *reply;
+    DBusError err_reply;
+
+    // Инициализация ошибок
+    dbus_error_init(&err);
+    dbus_error_init(&err_reply);
+
+    // Получение соединения с сеансовым bus
+    int b = 0;
+    printf("breakpoint %d\n",b++);
+    conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
+    printf("breakpoint %d\n",b++);
+    
+    if (dbus_error_is_set(&err)) {
+        fprintf(stderr, "Connection Error (%s)\n", err.message);
+        dbus_error_free(&err);
+        return 1;
+    }
+    printf("breakpoint %d\n",b++);
+    if (NULL == conn) {
+        fprintf(stderr, "Failed to connect to the D-Bus session bus\n");
+        return 1;
+    }
+    printf("breakpoint %d\n",b++);
+    // Создаём сообщение для вызова метода
+    msg = dbus_message_new_method_call(
+        "com.example.Hello",              // название сервиса
+        "/com/example/HelloObject",        // объект
+        "com.example.Hello",               // интерфейс
+        "SayHello"                         // метод
+    );
+    printf("breakpoint %d\n",b++);
+
+    if (NULL == msg) {
+        fprintf(stderr, "Message Null\n");
+        return 1;
+    }
+    printf("breakpoint %d\n",b++);
+    // Отправка сообщения и ожидание ответа
+    reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err);
+    printf("breakpoint %d\n",b++);
+    dbus_message_unref(msg);
+    printf("breakpoint %d\n",b++);
+    if (dbus_error_is_set(&err)) {
+        fprintf(stderr, "Error in method call: %s\n", err.message);
+        dbus_error_free(&err);
+        return 1;
+    }   
+    printf("breakpoint %d\n",b++);
+    // Получение строки из ответа
+    const char *reply_str;
+    if (dbus_message_get_args(reply, &err,
+                              DBUS_TYPE_STRING, &reply_str,
+                              DBUS_TYPE_INVALID)) {
+        printf("Response: %s\n", reply_str);
+    } else {
+        fprintf(stderr, "Failed to get args: %s\n", err.message);
+        dbus_error_free(&err);
+        return 1;
+    }
+    printf("breakpoint %d\n",b++);
+    dbus_message_unref(reply);
+    return 0;
+}
\ No newline at end of file
diff --git a/tools/pkg/13/dbus_test/pkg.sh b/tools/pkg/13/dbus_test/pkg.sh
new file mode 100644
index 0000000..91ce4cf
--- /dev/null
+++ b/tools/pkg/13/dbus_test/pkg.sh
@@ -0,0 +1 @@
+x86_64-orange-mlibc-g++ -o "$1/usr/bin/dbus_test" main.c -fPIC $(x86_64-orange-mlibc-pkg-config --cflags --libs dbus-1)
\ No newline at end of file
diff --git a/tools/pkg/13/xfwm/info.txt b/tools/pkg/13/xfwm/info.txt
new file mode 100644
index 0000000..88b5565
--- /dev/null
+++ b/tools/pkg/13/xfwm/info.txt
@@ -0,0 +1 @@
+xfwm
\ No newline at end of file
diff --git a/tools/pkg/13/xfwm/pkg.sh b/tools/pkg/13/xfwm/pkg.sh
new file mode 100644
index 0000000..b5d2bea
--- /dev/null
+++ b/tools/pkg/13/xfwm/pkg.sh
@@ -0,0 +1,74 @@
+
+# https://archive.xfce.org/src/xfce/xfwm4/4.19/xfwm4-4.19.0.tar.bz2
+
+
+. ../../pkg-lib.sh
+
+rm -rf pack
+mkdir -p pack
+cd pack
+
+fast_install "$1" https://archive.xfce.org/src/xfce/libxfce4util/4.19/libxfce4util-4.19.0.tar.bz2 "--disable-shared --enable-static --disable-introspection"
+fast_install "$1" https://archive.xfce.org/src/xfce/xfconf/4.19/xfconf-4.19.0.tar.bz2 "--disable-introspection"
+fast_install "$1" https://archive.xfce.org/src/xfce/libxfce4ui/4.19/libxfce4ui-4.19.0.tar.bz2 "--disable-introspection"
+
+# why not to compile libwnck-4
+git clone https://gitlab.gnome.org/GNOME/libwnck.git --depth=1
+cd libwnck
+
+mkdir build
+meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr -Dintrospection=disabled build
+
+cd build
+
+meson compile -j$(nproc)
+DESTDIR="$1" meson install --no-rebuild
+
+cd ../..
+
+# now compile libwnck-3
+wget https://github.com/GNOME/libwnck/archive/refs/tags/3.36.0.tar.gz
+tar -xvf 3.36.0.tar.gz
+cd libwnck-3.36.0
+
+mkdir build
+meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr -Dintrospection=disabled build
+
+cd build
+
+meson compile -j$(nproc)
+DESTDIR="$1" meson install --no-rebuild
+
+cd ../..
+
+fast_install "$1" https://archive.xfce.org/src/xfce/xfwm4/4.19/xfwm4-4.19.0.tar.bz2 "--disable-introspection"
+
+wget https://icon-theme.freedesktop.org/releases/hicolor-icon-theme-0.18.tar.xz
+tar -xvf hicolor-icon-theme-0.18.tar.xz
+cd hicolor-icon-theme-0.18
+
+mkdir build
+meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr build
+
+cd build
+
+meson compile -j$(nproc)
+DESTDIR="$1" meson install --no-rebuild
+
+cd ../..
+
+wget https://gitlab.freedesktop.org/xdg/shared-mime-info/-/archive/2.4/shared-mime-info-2.4.tar.gz
+tar -xvf shared-mime-info-2.4.tar.gz
+cd shared-mime-info-2.4
+
+mkdir build
+meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr build
+
+cd build
+
+meson compile -j$(nproc)
+DESTDIR="$1" meson install --no-rebuild
+
+cd ../..
+
+cd ..
\ No newline at end of file
diff --git a/tools/pkg/14/xfce4-panel/info.txt b/tools/pkg/14/xfce4-panel/info.txt
new file mode 100644
index 0000000..36ca0ab
--- /dev/null
+++ b/tools/pkg/14/xfce4-panel/info.txt
@@ -0,0 +1 @@
+xfce4-panel
\ No newline at end of file
diff --git a/tools/pkg/14/xfce4-panel/pkg.sh b/tools/pkg/14/xfce4-panel/pkg.sh
new file mode 100644
index 0000000..a9e62a3
--- /dev/null
+++ b/tools/pkg/14/xfce4-panel/pkg.sh
@@ -0,0 +1,71 @@
+
+# https://archive.xfce.org/src/xfce/xfwm4/4.19/xfwm4-4.19.0.tar.bz2
+
+
+. ../../pkg-lib.sh
+
+rm -rf pack
+mkdir -p pack
+cd pack
+
+wget https://archive.fr.xfce.org/src/xfce/libxfce4ui/4.21/libxfce4ui-4.21.3.tar.xz
+tar -xvf libxfce4ui-4.21.3.tar.xz
+cd libxfce4ui-4.21.3
+
+mkdir build
+meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr -Dintrospection=false build
+
+cd build
+
+meson compile -j$(nproc)
+DESTDIR="$1" meson install --no-rebuild
+
+cd ../..
+
+wget https://archive.xfce.org/src/xfce/garcon/4.21/garcon-4.21.0.tar.xz
+tar -xvf garcon-4.21.0.tar.xz
+cd garcon-4.21.0
+
+mkdir build
+meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr -Dintrospection=false build
+
+cd build
+
+meson compile -j$(nproc)
+DESTDIR="$1" meson install --no-rebuild
+
+cd ../..
+
+wget https://gitlab.freedesktop.org/emersion/libdisplay-info/-/archive/0.3.0/libdisplay-info-0.3.0.tar.bz2
+tar -xvf libdisplay-info-0.3.0.tar.bz2
+cd libdisplay-info-0.3.0
+
+mkdir build
+meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr build
+
+cd build
+
+meson compile -j$(nproc)
+DESTDIR="$1" meson install --no-rebuild
+
+cd ../..
+
+fast_install "$1" https://archive.xfce.org/src/xfce/libxfce4windowing/4.20/libxfce4windowing-4.20.5.tar.bz2 "--disable-introspection"
+
+wget https://archive.xfce.org/src/xfce/xfce4-panel/4.21/xfce4-panel-4.21.1.tar.xz
+tar -xvf xfce4-panel-4.21.1.tar.xz
+cd xfce4-panel-4.21.1
+
+mkdir build
+meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr -Dintrospection=false build
+
+cd build
+
+meson compile -j$(nproc)
+DESTDIR="$1" meson install --no-rebuild
+
+cd ../..
+
+fast_install "$1" https://archive.xfce.org/src/art/xfwm4-themes/4.10/xfwm4-themes-4.10.0.tar.bz2 "--sysconfdir=/etc"
+
+cd ..
\ No newline at end of file
diff --git a/tools/pkg/2/dbus_daemon/dbus-start-all.sh b/tools/pkg/2/dbus_daemon/dbus-start-all.sh
new file mode 100644
index 0000000..1920190
--- /dev/null
+++ b/tools/pkg/2/dbus_daemon/dbus-start-all.sh
@@ -0,0 +1,3 @@
+
+dbus-launch /usr/libexec/at-spi-bus-launcher &
+dbus-launch /usr/lib/xfce4/xfconf/xfconfd &
\ No newline at end of file
diff --git a/tools/pkg/2/dbus_daemon/info.txt b/tools/pkg/2/dbus_daemon/info.txt
new file mode 100644
index 0000000..7a73bb2
--- /dev/null
+++ b/tools/pkg/2/dbus_daemon/info.txt
@@ -0,0 +1 @@
+dbus_daemon
\ No newline at end of file
diff --git a/tools/pkg/2/dbus_daemon/main.c b/tools/pkg/2/dbus_daemon/main.c
new file mode 100644
index 0000000..5380e02
--- /dev/null
+++ b/tools/pkg/2/dbus_daemon/main.c
@@ -0,0 +1,15 @@
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <orange/dev.h>
+#include <orange/io.h>
+#include <orange/log.h>
+
+int main() {
+    log(LEVEL_MESSAGE_INFO,"Starting DBus\n");
+    system("dbus-daemon --system --fork");
+    exit(0);
+}
\ No newline at end of file
diff --git a/tools/pkg/2/dbus_daemon/pkg.sh b/tools/pkg/2/dbus_daemon/pkg.sh
new file mode 100644
index 0000000..67739c3
--- /dev/null
+++ b/tools/pkg/2/dbus_daemon/pkg.sh
@@ -0,0 +1,6 @@
+
+mkdir -p "$1/etc/drivers"
+
+cp -rf dbus-start-all.sh "$1/usr/bin/dbus-start-all.sh"
+chmod +x "$1/usr/bin/dbus-start-all.sh"
+x86_64-orange-mlibc-gcc -o "$1/etc/drivers/dbus.sys" main.c
\ No newline at end of file
diff --git a/tools/pkg/2/init/src/main.cpp b/tools/pkg/2/init/src/main.cpp
index ee5a9e5..9282a3e 100644
--- a/tools/pkg/2/init/src/main.cpp
+++ b/tools/pkg/2/init/src/main.cpp
@@ -1,4 +1,6 @@
 
+#define _XOPEN_SOURCE 700
+
 #include <linux/fb.h>
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/tools/pkg/2/ncurses/pkg.sh b/tools/pkg/2/ncurses/pkg.sh
index 3137859..a72ef6e 100644
--- a/tools/pkg/2/ncurses/pkg.sh
+++ b/tools/pkg/2/ncurses/pkg.sh
@@ -17,7 +17,7 @@ patch_config_sub "$(realpath $1/..)"
 cd ..
 
 cd ncurses-build
-../ncurses-6.5/configure --host=x86_64-orange-mlibc --prefix="/usr" --with-shared --without-ada CFLAGS="-std=gnu17"
+../ncurses-6.5/configure --host=x86_64-orange-mlibc --prefix="/usr" --with-shared --without-ada CFLAGS="-std=gnu17 -Wno-implicit-function-declaration"
 make -j$(nproc)
 make install -j$(nproc) DESTDIR="$1"
 
diff --git a/tools/pkg/2/ps2_driver/src/main.c b/tools/pkg/2/ps2_driver/src/main.c
index defa4e5..4b848df 100644
--- a/tools/pkg/2/ps2_driver/src/main.c
+++ b/tools/pkg/2/ps2_driver/src/main.c
@@ -166,8 +166,6 @@ typedef struct {
 
 int main() {
 
-    log(LEVEL_MESSAGE_WARN,"PS/2 driver is unstable and can be broken on some HW/VM, use USB instead of it\n");
-
     int pid = fork();
 
     if(pid > 0)
diff --git a/tools/pkg/2/xhci_driver/src/main.cpp b/tools/pkg/2/xhci_driver/src/main.cpp
index a712e3d..57eabf9 100644
--- a/tools/pkg/2/xhci_driver/src/main.cpp
+++ b/tools/pkg/2/xhci_driver/src/main.cpp
@@ -2,6 +2,8 @@
 #include <iostream>
 #include <xhci.hpp>
 
+#define _DEFAULT_SOURCE
+
 #include <unistd.h>
 
 #include <orange/dev.h>
@@ -1405,6 +1407,18 @@ void __usbkeyboard_handler(xhci_usb_device_t* usbdev, xhci_done_trb_t* trb) {
         if (!isPressed && data[i] != 0) {
             if (data[i] < 0x47) {
                 input_send(hid_to_ps2_layout[data[i]]);
+            } else if(data[i] == 0x4F) {
+                input_send(0xE0);
+                input_send(0x4D); 
+            } else if(data[i] == 0x50) {
+                input_send(0xE0);
+                input_send(0x4B); 
+            } else if(data[i] == 0x51) {
+                input_send(0xE0);
+                input_send(0x50); 
+            } else if(data[i] == 0x52) {
+                input_send(0xE0);
+                input_send(0x48); 
             }
         }
     }
@@ -1419,7 +1433,19 @@ void __usbkeyboard_handler(xhci_usb_device_t* usbdev, xhci_done_trb_t* trb) {
         }
         if (!isStillPressed && usbdev->add_buffer[i] != 0) {
             input_send(hid_to_ps2_layout[usbdev->add_buffer[i]] | 0x80);
-        }
+        } else if(usbdev->add_buffer[i] == 0x4F) {
+                input_send(0xE0 | 0x80);
+                input_send(0x4D | 0x80); 
+            } else if(usbdev->add_buffer[i] == 0x50) {
+                input_send(0xE0 | 0x80);
+                input_send(0x4B | 0x80); 
+            } else if(usbdev->add_buffer[i] == 0x51) {
+                input_send(0xE0 | 0x80);
+                input_send(0x50 | 0x80); 
+            } else if(usbdev->add_buffer[i] == 0x52) {
+                input_send(0xE0 | 0x80);
+                input_send(0x48 | 0x80); 
+            }
     }
 
     memcpy(usbdev->add_buffer, data, 8);
@@ -1466,8 +1492,6 @@ int main() {
     input0_fd = open("/dev/masterps2keyboard",O_RDWR);
     mouse_fd = open("/dev/mastermouse",O_RDWR);
 
-    log(LEVEL_MESSAGE_WARN,"XHCI Driver is currently under development so it's unstable\n");
-
     xhci_hid_register(__usbkeyboard_handler,USB_TYPE_KEYBOARD);
     xhci_hid_register(__usbmouse_handler,USB_TYPE_MOUSE);
 
diff --git a/tools/pkg/3/pthread_test/a.out b/tools/pkg/3/pthread_test/a.out
new file mode 100755
index 0000000..f192c45
--- /dev/null
+++ b/tools/pkg/3/pthread_test/a.out
diff --git a/tools/pkg/3/pthread_test/fdpass.c b/tools/pkg/3/pthread_test/fdpass.c
new file mode 100644
index 0000000..7dfdd3b
--- /dev/null
+++ b/tools/pkg/3/pthread_test/fdpass.c
@@ -0,0 +1,128 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <pthread.h>
+#include <fcntl.h>
+
+#define THREAD_COUNT 2
+
+// Shared socket pair file descriptors
+int socket_pair[2];
+
+// Thread to send a file descriptor
+void* sender_thread(void* arg) {
+    // Open a file to pass its descriptor
+    int fd = open("/etc/hostname", O_RDONLY);
+    if (fd < 0) {
+        perror("open");
+        return NULL;
+    }
+
+    // Prepare message to send
+    struct msghdr msg = {0};
+    char buf[CMSG_SPACE(sizeof(int))];
+    memset(buf, 0, sizeof(buf));
+    struct iovec io = {.iov_base = (void*)"FD", .iov_len = 2};
+
+    msg.msg_iov = &io;
+    msg.msg_iovlen = 1;
+
+    // Set control message to pass the file descriptor
+    struct cmsghdr* cmsg = (struct cmsghdr*)buf;
+    cmsg->cmsg_len = CMSG_LEN(sizeof(int));
+    cmsg->cmsg_level = SOL_SOCKET;
+    cmsg->cmsg_type = SCM_RIGHTS;
+
+    // Copy the fd into the control message
+    memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
+
+    msg.msg_control = cmsg;
+    msg.msg_controllen = CMSG_LEN(sizeof(int));
+
+    // Send message with the file descriptor
+    if (sendmsg(socket_pair[0], &msg, 0) < 0) {
+        perror("sendmsg");
+    } else {
+        printf("Sender: sent file descriptor\n");
+    }
+
+    close(fd);
+    return NULL;
+}
+
+// Thread to receive a file descriptor
+void* receiver_thread(void* arg) {
+    char buf[1];
+    struct msghdr msg = {0};
+    char ctrl_buf[CMSG_SPACE(sizeof(int))];
+
+    struct iovec io = {.iov_base = buf, .iov_len = 1};
+    msg.msg_iov = &io;
+    msg.msg_iovlen = 1;
+    msg.msg_control = ctrl_buf;
+    msg.msg_controllen = sizeof(ctrl_buf);
+
+    // Receive message and ancillary data
+    if (recvmsg(socket_pair[1], &msg, 0) < 0) {
+        perror("recvmsg");
+        return NULL;
+    }
+
+    // Extract the file descriptor from the control message
+    struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
+    int received_fd = -1;
+
+    if (cmsg && cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
+        memcpy(&received_fd, CMSG_DATA(cmsg), sizeof(int));
+        printf("Receiver: received file descriptor %d\n", received_fd);
+
+        // Read from the received file descriptor
+        char read_buf[128];
+        ssize_t n = read(received_fd, read_buf, sizeof(read_buf)-1);
+        if (n > 0) {
+            read_buf[n] = '\0';
+            printf("Content of the file: %s\n", read_buf);
+        } else {
+            perror("read");
+        }
+
+        close(received_fd);
+    } else {
+        printf("No file descriptor received (size %d)\n",0);
+    }
+    return NULL;
+}
+
+int main() {
+    pthread_t threads[THREAD_COUNT];
+
+    // Create a socket pair for communication
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, socket_pair) < 0) {
+        perror("socketpair");
+        exit(EXIT_FAILURE);
+    }
+
+    // Create sender thread
+    if (pthread_create(&threads[0], NULL, sender_thread, NULL) != 0) {
+        perror("pthread_create sender");
+        exit(EXIT_FAILURE);
+    }
+
+    // Create receiver thread
+    if (pthread_create(&threads[1], NULL, receiver_thread, NULL) != 0) {
+        perror("pthread_create receiver");
+        exit(EXIT_FAILURE);
+    }
+
+    // Wait for threads to finish
+    pthread_join(threads[0], NULL);
+    pthread_join(threads[1], NULL);
+
+    close(socket_pair[0]);
+    close(socket_pair[1]);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tools/pkg/3/pthread_test/main.c b/tools/pkg/3/pthread_test/main.c
deleted file mode 100644
index 12632f3..0000000
--- a/tools/pkg/3/pthread_test/main.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdio.h>
-#include <locale.h>
-#include <langinfo.h>
-
-int main() {
-    // Устанавливаем локаль по умолчанию
-    setlocale(LC_ALL, "");
-
-    // Пытаемся получить информацию о правилах сортировки (COLLATION)
-    // В POSIX это не предусмотрено напрямую, так что используем другие значения
-    printf("Hi: %s\n", nl_langinfo(CODESET));
-
-    return 0;
-}
\ No newline at end of file
diff --git a/tools/pkg/3/pthread_test/pkg.sh b/tools/pkg/3/pthread_test/pkg.sh
index afbb46e..2bbbfee 100644
--- a/tools/pkg/3/pthread_test/pkg.sh
+++ b/tools/pkg/3/pthread_test/pkg.sh
@@ -1 +1,4 @@
-x86_64-orange-mlibc-g++ -o "$1/usr/bin/pthread_test" main.c -fPIC 
\ No newline at end of file
+x86_64-orange-mlibc-g++ -o "$1/usr/bin/fdpass_test" fdpass.c -fPIC 
+x86_64-orange-mlibc-g++ -o "$1/usr/bin/ucred_test" ucred.c -fPIC
+x86_64-orange-mlibc-g++ -o "$1/usr/bin/signal_test" signaltest.c -fPIC
+x86_64-orange-mlibc-g++ -o "$1/usr/bin/shm_test" shm_test.c -fPIC
\ No newline at end of file
diff --git a/tools/pkg/3/pthread_test/shm_test.c b/tools/pkg/3/pthread_test/shm_test.c
new file mode 100644
index 0000000..5a66d37
--- /dev/null
+++ b/tools/pkg/3/pthread_test/shm_test.c
@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <string.h>
+
+#define SHM_SIZE 1024  // size of shared memory segment
+
+int main() {
+    key_t key;
+    int shmid;
+    char *shmaddr;
+
+    // Generate a unique key for shared memory
+    key = 100;
+
+    // Create shared memory segment with shmget()
+    shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0644);
+    if (shmid == -1) {
+        perror("shmget");
+        exit(1);
+    }
+    printf("Shared memory ID: %d\n", shmid);
+
+    // Attach to the shared memory segment with shmat()
+    shmaddr = (char*) shmat(shmid, NULL, 0);
+    if (shmaddr == (char*) -1) {
+        perror("shmat");
+        exit(1);
+    }
+
+    // Write to shared memory
+    strcpy(shmaddr, "Hello from shared memory!");
+
+    printf("Data written to shared memory: %s\n", shmaddr);
+
+    // Detach from shared memory with shmdt()
+    if (shmdt(shmaddr) == -1) {
+        perror("shmdt");
+        exit(1);
+    }
+
+    // Note: To remove the shared memory segment, use shmctl(shmid, IPC_RMID, NULL);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tools/pkg/3/pthread_test/signaltest.c b/tools/pkg/3/pthread_test/signaltest.c
new file mode 100644
index 0000000..777d1b2
--- /dev/null
+++ b/tools/pkg/3/pthread_test/signaltest.c
@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/types.h>
+
+void handle_sigusr1(int sig) {
+    printf("got SIGUSR1!\n");
+    void *ret_addr = __builtin_return_address(0);
+    printf("ret: %p\n", ret_addr);
+}
+
+void handle_sigusr2(int sig) {
+    printf("got SIGUSR2!\n");
+    void *ret_addr = __builtin_return_address(0);
+    printf("ret: %p\n", ret_addr);
+}
+
+void test() {
+    void *ret_addr = __builtin_return_address(0);
+    printf("ret: %p\n", ret_addr);
+}
+
+int main() {
+    pid_t pid;
+
+    signal(SIGUSR1, handle_sigusr1);
+    signal(SIGUSR2, handle_sigusr2);
+    test();
+    printf("%p\n",main);
+
+
+    pid = fork();
+
+    if (pid < 0) {
+        perror("fork");
+        exit(EXIT_FAILURE);
+    }
+
+    if (pid == 0) {
+
+        printf("child start. pid = %d\n", getpid());
+        while (1) {
+            printf("wait signal...\n");
+            pause();
+        }
+    } else {
+
+        printf("parent start. pid = %d, child pid = %d\n", getpid(), pid);
+        sleep(2);
+
+
+        printf("parent send SIGUSR1\n");
+        kill(pid, SIGUSR1);
+
+        sleep(2);
+
+        printf("parent send SIGUSR2\n");
+        kill(pid, SIGUSR2);
+
+        sleep(2);
+        kill(pid, SIGTERM);  
+        printf("parent end.\n");
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tools/pkg/3/pthread_test/ucred.c b/tools/pkg/3/pthread_test/ucred.c
new file mode 100644
index 0000000..e2ba317
--- /dev/null
+++ b/tools/pkg/3/pthread_test/ucred.c
@@ -0,0 +1,173 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/types.h>
+
+#define SOCKET_PATH "/tmp/my_unix_socket"
+#define BUFFER_SIZE 128
+
+void* server_thread(void *arg) {
+    int server_fd, client_fd;
+    struct sockaddr_un addr;
+
+    server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (server_fd == -1) {
+        perror("socket");
+        pthread_exit(NULL);
+    }
+
+    unlink(SOCKET_PATH);
+    memset(&addr, 0, sizeof(struct sockaddr_un));
+    addr.sun_family = AF_UNIX;
+    strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path) - 1);
+
+    if (bind(server_fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1) {
+        perror("bind");
+        close(server_fd);
+        pthread_exit(NULL);
+    }
+
+    if (listen(server_fd, 5) == -1) {
+        perror("listen");
+        close(server_fd);
+        pthread_exit(NULL);
+    }
+
+    printf("server start\n");
+
+    client_fd = accept(server_fd, NULL, NULL);
+    if (client_fd == -1) {
+        perror("accept");
+        close(server_fd);
+        pthread_exit(NULL);
+    }
+    printf("client connect\n");
+
+    struct msghdr msg = {0};
+    struct iovec iov;
+    char buf[BUFFER_SIZE];
+
+    char cmsg_buf[CMSG_SPACE(sizeof(struct ucred))];
+
+    iov.iov_base = buf;
+    iov.iov_len = sizeof(buf);
+
+    msg.msg_iov = &iov;
+    msg.msg_iovlen = 1;
+    msg.msg_control = cmsg_buf;
+    msg.msg_controllen = sizeof(cmsg_buf);
+
+    ssize_t num_bytes = recvmsg(client_fd, &msg, 0);
+    if (num_bytes == -1) {
+        perror("recvmsg");
+        close(client_fd);
+        close(server_fd);
+        unlink(SOCKET_PATH);
+        pthread_exit(NULL);
+    }
+
+    printf("got msg: %.*s\n", (int)num_bytes, buf);
+
+    struct ucred *cred = NULL;
+    struct cmsghdr *cmsg;
+    for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg,cmsg)) {
+        if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_CREDENTIALS) {
+            cred = (struct ucred *)CMSG_DATA(cmsg);
+            break;
+        }
+    }
+    if (cred != NULL) {
+        printf("uid: %d\n", cred->uid);
+        printf("gid: %d\n", cred->gid);
+        printf("pid: %d\n", cred->pid);
+    } else {
+        printf("rip\n");
+    }
+
+    close(client_fd);
+    close(server_fd);
+    unlink(SOCKET_PATH);
+    pthread_exit(NULL);
+}
+
+void* client_thread(void *arg) {
+    sleep(1); 
+
+    int sock = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (sock == -1) {
+        perror("socket");
+        pthread_exit(NULL);
+    }
+
+    struct sockaddr_un addr;
+    memset(&addr, 0, sizeof(struct sockaddr_un));
+    addr.sun_family = AF_UNIX;
+    strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path) - 1);
+
+    if (connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1) {
+        perror("connect");
+        close(sock);
+        pthread_exit(NULL);
+    }
+
+        // Внутри client_thread после установки соединения:
+    struct msghdr msg = {0};
+    struct iovec iov;
+    char message[] = "hi.";
+
+    iov.iov_base = message;
+    iov.iov_len = strlen(message);
+
+    char cmsg_buf[CMSG_SPACE(sizeof(struct ucred))];
+    struct cmsghdr *cmsg;
+
+    struct ucred cred;
+    cred.pid = getpid();  // текущий pid
+    cred.uid = getuid();  // текущий uid
+    cred.gid = getgid();  // текущий gid
+
+    // Формируем управляющее сообщение с учетными данными
+    msg.msg_control = cmsg_buf;
+    msg.msg_controllen = CMSG_SPACE(sizeof(struct ucred));
+
+    cmsg = CMSG_FIRSTHDR(&msg);
+    cmsg->cmsg_level = SOL_SOCKET;
+    cmsg->cmsg_type = SCM_CREDENTIALS;
+    cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
+
+    memcpy(CMSG_DATA(cmsg), &cred, sizeof(struct ucred));
+
+    msg.msg_iov = &iov;
+    msg.msg_iovlen = 1;
+
+    if (sendmsg(sock, &msg, 0) == -1) {
+        perror("sendmsg");
+    }
+    printf("send manual creds\n");
+    close(sock);
+    pthread_exit(NULL);
+}
+
+int main() {
+    pthread_t server_tid, client_tid;
+
+    if (pthread_create(&server_tid, NULL, server_thread, NULL) != 0) {
+        perror("pthread_create server");
+        return 1;
+    }
+
+    if (pthread_create(&client_tid, NULL, client_thread, NULL) != 0) {
+        perror("pthread_create client");
+        return 1;
+    }
+
+    pthread_join(server_tid, NULL);
+    pthread_join(client_tid, NULL);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tools/pkg/5/orangeutils/pkg.sh b/tools/pkg/5/orangeutils/pkg.sh
index 35aa855..5356787 100644
--- a/tools/pkg/5/orangeutils/pkg.sh
+++ b/tools/pkg/5/orangeutils/pkg.sh
@@ -1,4 +1,5 @@
 x86_64-orange-mlibc-gcc src/orangedebugenable.c -o "$1/usr/bin/orangedebugenable" -Wno-implicit-function-declaration
 x86_64-orange-mlibc-gcc src/orangeprintinfo.c -o "$1/usr/bin/orangeprintinfo" -Wno-implicit-function-declaration
 x86_64-orange-mlibc-gcc src/orangedebug.c -o "$1/usr/bin/orangedebug" -Wno-implicit-function-declaration
-x86_64-orange-mlibc-gcc src/dmesg.c -o "$1/usr/bin/dmesg" -Wno-implicit-function-declaration
\ No newline at end of file
+x86_64-orange-mlibc-gcc src/dmesg.c -o "$1/usr/bin/dmesg" -Wno-implicit-function-declaration
+x86_64-orange-mlibc-gcc src/nologin.c -o "$1/usr/bin/nologin" -Wno-implicit-function-declaration
\ No newline at end of file
diff --git a/tools/pkg/5/orangeutils/src/nologin.c b/tools/pkg/5/orangeutils/src/nologin.c
new file mode 100644
index 0000000..7bb8221
--- /dev/null
+++ b/tools/pkg/5/orangeutils/src/nologin.c
@@ -0,0 +1,7 @@
+
+#include <stdio.h>
+
+int main() {
+    printf("fuck off\n");
+    return -1;
+}
\ No newline at end of file
diff --git a/tools/pkg/5/orangex/main.sh b/tools/pkg/5/orangex/main.sh
index ba58124..268e8e6 100644
--- a/tools/pkg/5/orangex/main.sh
+++ b/tools/pkg/5/orangex/main.sh
@@ -6,7 +6,8 @@ while true; do
     echo "Select program to start:"
     echo "1) i3wm"
     echo "2) twm"
-    echo "3) bash"
+    echo "3) xfce4"
+    echo "4) bash"
     read -p "Select number: " choice
 
     stty -echo
@@ -19,6 +20,9 @@ while true; do
             xinit /etc/X11/twmrc > /dev/null 2> /dev/null
             ;;
         3)
+            xinit /etc/X11/xfcerc > /dev/null 2> /dev/null
+            ;;
+        4)
             stty echo
             bash
             ;;
diff --git a/tools/pkg/5/xorg-modules/pkg.sh b/tools/pkg/5/xorg-modules/pkg.sh
index 59dd75e..db20abb 100644
--- a/tools/pkg/5/xorg-modules/pkg.sh
+++ b/tools/pkg/5/xorg-modules/pkg.sh
@@ -18,13 +18,6 @@ fast_install "$1" https://www.x.org/archive//individual/font/font-util-1.4.1.tar
 
 fast_install "$1" https://www.x.org/pub/individual/font/font-alias-1.0.5.tar.xz
 
-wget https://ftp.debian.org/debian/pool/main/x/xfonts-base/xfonts-base_1.0.5_all.deb
-ar -x xfonts-base_1.0.5_all.deb
-
-tar -xvf data.tar.xz
-cp -rf usr/* "$1/usr"
-cp -rf etc/* "$1/etc"
-
 CFLAGS="-fPIC" SYSROOT="$1/" fast_install "$1" https://www.x.org/releases/individual/driver/xf86-video-fbdev-0.5.1.tar.gz "--disable-pciaccess --disable-static --enable-shared" "../../diff/xfbdev.diff"
 CFLAGS="-fPIC" SYSROOT="$1/" fast_install "$1" https://www.x.org/releases/individual/driver/xf86-input-keyboard-2.1.0.tar.gz "--disable-static --enable-shared" "../../diff/xkeyboard.diff"
 CFLAGS="-fPIC" SYSROOT="$1/" fast_install "$1" https://xorg.freedesktop.org/archive/individual/driver/xf86-input-mouse-1.9.5.tar.gz "--enable-shared" "../../diff/xmouse.diff"
\ No newline at end of file
diff --git a/tools/pkg/6/terms/pkg.sh b/tools/pkg/6/terms/pkg.sh
index efde636..ddd5ba9 100644
--- a/tools/pkg/6/terms/pkg.sh
+++ b/tools/pkg/6/terms/pkg.sh
@@ -17,6 +17,8 @@ cp -rf build/usr/local/* "$1/usr/"
 
 cd ..
 
+CFLAGS="$CFLAGS -D_XOPEN_SOURCE"
+
 fast_install "$1" https://invisible-mirror.net/archives/xterm/xterm-390.tgz "--disable-tcap-fkeys --disable-tcap-query --enable-256-color" "../../diff/xterm.diff"
 fast_install "$1" https://www.x.org/archive/individual/lib/libXrandr-1.5.3.tar.gz
 fast_install "$1" https://www.x.org/archive/individual/app/xev-1.2.5.tar.gz
diff --git a/tools/pkg/7/benchmark/a.out b/tools/pkg/7/benchmark/a.out
index d9ce416..2d2e9f7 100755
--- a/tools/pkg/7/benchmark/a.out
+++ b/tools/pkg/7/benchmark/a.out
diff --git a/tools/pkg/7/benchmark/main.c b/tools/pkg/7/benchmark/main.c
index b22e199..667035f 100644
--- a/tools/pkg/7/benchmark/main.c
+++ b/tools/pkg/7/benchmark/main.c
@@ -70,11 +70,11 @@ void mmap_test() {
         struct timespec start;
         struct timespec end;
         clock_gettime(CLOCK_MONOTONIC,&start);
-        void* addr = mmap(NULL, 4096, PROT_WRITE | PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+        void* addr = mmap(NULL, 0x80000, PROT_WRITE | PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
         if (addr == MAP_FAILED) {
             perror("mmap failed");
             continue;
-        }memset(addr,1,4096);
+        }memset(addr,1,0x80000);
         clock_gettime(CLOCK_MONOTONIC,&end);
         printf("OS mmap test %d - %d ns\n",i,end.tv_nsec - start.tv_nsec);
         
diff --git a/tools/pkg/8/gtk/pkg.sh b/tools/pkg/8/gtk/pkg.sh
index 521e951..7c17a54 100644
--- a/tools/pkg/8/gtk/pkg.sh
+++ b/tools/pkg/8/gtk/pkg.sh
@@ -42,7 +42,7 @@ diff_patch ../../diff/dbus.diff
 
 mkdir build
 
-meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr -Druntime_dir=/run -Dsystemd_system_unitdir=no -Dsystemd_user_unitdir=no -Dsystem_pid_file=/run/dbus/pid -Dsystem_socket=/run/dbus/system_bus_socket -Dselinux=disabled -Dapparmor=disabled -Dlibaudit=disabled -Dkqueue=disabled -Dlaunchd=disabled -Dsystemd=disabled -Dmodular_tests=disabled -Depoll=disabled build
+meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr -Druntime_dir=/run -Dsystemd_system_unitdir=no -Dsystemd_user_unitdir=no -Dsystem_pid_file=/run/dbus/pid -Dsystem_socket=/run/dbus/system_bus_socket -Dselinux=disabled -Dapparmor=disabled -Dlibaudit=disabled -Dkqueue=disabled -Dlaunchd=disabled -Dsystemd=disabled -Dmodular_tests=disabled -Depoll=disabled -Dverbose_mode=true build
 cd build
 
 meson compile -j$(nproc)
@@ -53,6 +53,8 @@ touch "$1/var/lib/dbus/.keep"
 
 cd ../..
 
+exit 0
+
 wget https://gitlab.gnome.org/GNOME/at-spi2-core/-/archive/2.56.6/at-spi2-core-2.56.6.tar
 tar -xvf at-spi2-core-2.56.6.tar
 cd at-spi2-core-2.56.6
@@ -67,11 +69,11 @@ DESTDIR="$1" meson install --no-rebuild
 
 cd ../..
 
-wget https://github.com/GNOME/gobject-introspection/archive/refs/tags/1.73.0.tar.gz
-mv 1.73.0.tar.gz intro.tar.gz
+wget https://github.com/GNOME/gobject-introspection/archive/refs/tags/1.86.0.tar.gz
+mv 1.86.0.tar.gz intro.tar.gz
 tar -xvf intro.tar.gz
 
-cd gobject-introspection-1.73.0
+cd gobject-introspection-1.86.0
 
 mkdir build
 meson --cross-file="$1/../tools/pkg/x86_64-orange.crossfile" --prefix=/usr -Dgtk_doc=false -Dbuild_introspection_data=false build
diff --git a/tools/pkg/build-pkg.sh b/tools/pkg/build-pkg.sh
index 9fabece..12f1ded 100644
--- a/tools/pkg/build-pkg.sh
+++ b/tools/pkg/build-pkg.sh
@@ -11,7 +11,7 @@ if [ ! "$(which x86_64-orange-mlibc-gcc)" ]; then
     echo 'Also you should have host gcc ~13 or ~ 14'
 fi
 
-for dir in {0..12}; do
+for dir in {0..14}; do
 	cd "$dir"
 	for pkg_dir in */; do
 		cd "$pkg_dir"