feat: Massive OS expansion with IPC, Sound & TTS, Block layer, FAT32/ext2/sysfs, Signals, Syscalls, Modules, Drivers & 50+ LazyBox applets

ipc/ipc.c

@@ -0,0 +1,6 @@
+#include <ipc/ipc.h>
+#include <kernel/printk.h>
+
+void ipc_init(void) {
+    printk(KERN_INFO "IPC: Inter-Process Communication Engine (Pipes, MsgQueues, SHM, Semaphores) initialized\n");
+}

ipc/msg.c

@@ -0,0 +1,97 @@
+#include <ipc/msg.h>
+#include <mm/kmalloc.h>
+#include <lib/string.h>
+
+static msqid_ds_t msg_queues[MAX_MSG_QUEUES];
+
+int msgget(key_t key, int msgflg) {
+    (void)msgflg;
+    for (int i = 0; i < MAX_MSG_QUEUES; i++) {
+        if (msg_queues[i].in_use && msg_queues[i].key == key) {
+            return i;
+        }
+    }
+
+    for (int i = 0; i < MAX_MSG_QUEUES; i++) {
+        if (!msg_queues[i].in_use) {
+            msg_queues[i].in_use = true;
+            msg_queues[i].key = key;
+            msg_queues[i].msqid = i;
+            msg_queues[i].msg_qnum = 0;
+            msg_queues[i].msg_qbytes = MAX_MSG_PAYLOAD * MAX_MSGS_PER_QUEUE;
+            msg_queues[i].head = NULL;
+            msg_queues[i].tail = NULL;
+            return i;
+        }
+    }
+    return -1;
+}
+
+int msgsnd(int msqid, const void* msgp, size_t msgsz, int msgflg) {
+    (void)msgflg;
+    if (msqid < 0 || msqid >= MAX_MSG_QUEUES || !msg_queues[msqid].in_use || !msgp) return -1;
+    if (msgsz > MAX_MSG_PAYLOAD) return -1;
+
+    msqid_ds_t* q = &msg_queues[msqid];
+    if (q->msg_qnum >= MAX_MSGS_PER_QUEUE) return -1;
+
+    msg_entry_t* entry = (msg_entry_t*)kmalloc(sizeof(msg_entry_t));
+    if (!entry) return -1;
+
+    const msgbuf_t* mb = (const msgbuf_t*)msgp;
+    entry->mtype = mb->mtype;
+    entry->size = msgsz;
+    memcpy(entry->data, mb->mtext, msgsz);
+    entry->next = NULL;
+
+    if (!q->tail) {
+        q->head = entry;
+        q->tail = entry;
+    } else {
+        q->tail->next = entry;
+        q->tail = entry;
+    }
+    q->msg_qnum++;
+    return 0;
+}
+
+ssize_t msgrcv(int msqid, void* msgp, size_t msgsz, long msgtyp, int msgflg) {
+    (void)msgtyp; (void)msgflg;
+    if (msqid < 0 || msqid >= MAX_MSG_QUEUES || !msg_queues[msqid].in_use || !msgp) return -1;
+
+    msqid_ds_t* q = &msg_queues[msqid];
+    if (!q->head) return -1;
+
+    msg_entry_t* entry = q->head;
+    q->head = entry->next;
+    if (!q->head) q->tail = NULL;
+    q->msg_qnum--;
+
+    msgbuf_t* mb = (msgbuf_t*)msgp;
+    mb->mtype = entry->mtype;
+    size_t copy_len = entry->size < msgsz ? entry->size : msgsz;
+    memcpy(mb->mtext, entry->data, copy_len);
+
+    kfree(entry);
+    return (ssize_t)copy_len;
+}
+
+int msgctl(int msqid, int cmd, struct msqid_ds* buf) {
+    if (msqid < 0 || msqid >= MAX_MSG_QUEUES || !msg_queues[msqid].in_use) return -1;
+
+    if (cmd == IPC_RMID) {
+        msqid_ds_t* q = &msg_queues[msqid];
+        msg_entry_t* curr = q->head;
+        while (curr) {
+            msg_entry_t* next = curr->next;
+            kfree(curr);
+            curr = next;
+        }
+        memset(q, 0, sizeof(msqid_ds_t));
+        return 0;
+    } else if (cmd == IPC_STAT && buf) {
+        memcpy(buf, &msg_queues[msqid], sizeof(msqid_ds_t));
+        return 0;
+    }
+    return -1;
+}

ipc/pipe.c

@@ -0,0 +1,99 @@
+#include <ipc/pipe.h>
+#include <mm/kmalloc.h>
+#include <lib/string.h>
+
+static ssize_t pipe_vfs_read(vfs_node_t* node, off_t offset, size_t size, uint8_t* buffer) {
+    (void)offset;
+    pipe_t* p = (pipe_t*)node->ptr;
+    if (!p) return 0;
+    return pipe_read(p, buffer, size);
+}
+
+static ssize_t pipe_vfs_write(vfs_node_t* node, off_t offset, size_t size, const uint8_t* buffer) {
+    (void)offset;
+    pipe_t* p = (pipe_t*)node->ptr;
+    if (!p) return 0;
+    return pipe_write(p, buffer, size);
+}
+
+int pipe_create(int pipefd[2]) {
+    if (!pipefd) return -1;
+
+    pipe_t* p = (pipe_t*)kzalloc(sizeof(pipe_t));
+    if (!p) return -1;
+
+    p->read_open = true;
+    p->write_open = true;
+
+    vfs_node_t* rnode = (vfs_node_t*)kzalloc(sizeof(vfs_node_t));
+    vfs_node_t* wnode = (vfs_node_t*)kzalloc(sizeof(vfs_node_t));
+    if (!rnode || !wnode) {
+        kfree(p);
+        if (rnode) kfree(rnode);
+        if (wnode) kfree(wnode);
+        return -1;
+    }
+
+    strcpy(rnode->name, "pipe:[r]");
+    rnode->flags = FS_CHARDEVICE;
+    rnode->read = pipe_vfs_read;
+    rnode->ptr = (struct vfs_node*)p;
+
+    strcpy(wnode->name, "pipe:[w]");
+    wnode->flags = FS_CHARDEVICE;
+    wnode->write = pipe_vfs_write;
+    wnode->ptr = (struct vfs_node*)p;
+
+    p->read_node = rnode;
+    p->write_node = wnode;
+
+    pipefd[0] = vfs_open_node(rnode, O_RDONLY);
+    pipefd[1] = vfs_open_node(wnode, O_WRONLY);
+
+    return 0;
+}
+
+ssize_t pipe_read(pipe_t* p, void* buf, size_t count) {
+    if (!p || !buf || count == 0) return 0;
+
+    size_t read_bytes = 0;
+    uint8_t* out = (uint8_t*)buf;
+
+    while (read_bytes < count && p->count > 0) {
+        out[read_bytes++] = p->buffer[p->tail];
+        p->tail = (p->tail + 1) % PIPE_BUF_SIZE;
+        p->count--;
+    }
+
+    return (ssize_t)read_bytes;
+}
+
+ssize_t pipe_write(pipe_t* p, const void* buf, size_t count) {
+    if (!p || !buf || count == 0) return 0;
+    if (!p->read_open) return -1; // EPIPE
+
+    size_t written = 0;
+    const uint8_t* in = (const uint8_t*)buf;
+
+    while (written < count && p->count < PIPE_BUF_SIZE) {
+        p->buffer[p->head] = in[written++];
+        p->head = (p->head + 1) % PIPE_BUF_SIZE;
+        p->count++;
+    }
+
+    return (ssize_t)written;
+}
+
+void pipe_close_read(pipe_t* p) {
+    if (p) {
+        p->read_open = false;
+        if (!p->write_open) kfree(p);
+    }
+}
+
+void pipe_close_write(pipe_t* p) {
+    if (p) {
+        p->write_open = false;
+        if (!p->read_open) kfree(p);
+    }
+}

ipc/sem.c

@@ -0,0 +1,53 @@
+#include <ipc/sem.h>
+#include <lib/string.h>
+
+static semid_ds_t sem_sets[MAX_SEM_SETS];
+
+int semget(key_t key, int nsems, int semflg) {
+    (void)semflg;
+    if (nsems <= 0 || nsems > MAX_SEMS_PER_SET) return -1;
+
+    for (int i = 0; i < MAX_SEM_SETS; i++) {
+        if (sem_sets[i].in_use && sem_sets[i].key == key) {
+            return i;
+        }
+    }
+
+    for (int i = 0; i < MAX_SEM_SETS; i++) {
+        if (!sem_sets[i].in_use) {
+            sem_sets[i].in_use = true;
+            sem_sets[i].key = key;
+            sem_sets[i].semid = i;
+            sem_sets[i].nsems = (uint32_t)nsems;
+            for (int s = 0; s < nsems; s++) {
+                sem_sets[i].values[s] = 0;
+            }
+            return i;
+        }
+    }
+    return -1;
+}
+
+int semop(int semid, struct sembuf* sops, size_t nsops) {
+    if (semid < 0 || semid >= MAX_SEM_SETS || !sem_sets[semid].in_use || !sops) return -1;
+
+    semid_ds_t* set = &sem_sets[semid];
+    for (size_t i = 0; i < nsops; i++) {
+        if (sops[i].sem_num >= set->nsems) return -1;
+        set->values[sops[i].sem_num] += sops[i].sem_op;
+    }
+    return 0;
+}
+
+int semctl(int semid, int semnum, int cmd, ...) {
+    if (semid < 0 || semid >= MAX_SEM_SETS || !sem_sets[semid].in_use) return -1;
+
+    if (cmd == IPC_RMID) {
+        memset(&sem_sets[semid], 0, sizeof(semid_ds_t));
+        return 0;
+    }
+    if (semnum >= 0 && semnum < (int)sem_sets[semid].nsems) {
+        return sem_sets[semid].values[semnum];
+    }
+    return 0;
+}

ipc/shm.c

@@ -0,0 +1,64 @@
+#include <ipc/shm.h>
+#include <mm/kmalloc.h>
+#include <lib/string.h>
+
+static shmid_ds_t shm_segs[MAX_SHM_SEGS];
+
+int shmget(key_t key, size_t size, int shmflg) {
+    (void)shmflg;
+    if (size > SHM_MAX_SIZE) return -1;
+
+    for (int i = 0; i < MAX_SHM_SEGS; i++) {
+        if (shm_segs[i].in_use && shm_segs[i].key == key) {
+            return i;
+        }
+    }
+
+    for (int i = 0; i < MAX_SHM_SEGS; i++) {
+        if (!shm_segs[i].in_use) {
+            void* mem = kzalloc(size);
+            if (!mem) return -1;
+
+            shm_segs[i].in_use = true;
+            shm_segs[i].key = key;
+            shm_segs[i].shmid = i;
+            shm_segs[i].size = size;
+            shm_segs[i].addr = mem;
+            shm_segs[i].nattch = 0;
+            return i;
+        }
+    }
+    return -1;
+}
+
+void* shmat(int shmid, const void* shmaddr, int shmflg) {
+    (void)shmaddr; (void)shmflg;
+    if (shmid < 0 || shmid >= MAX_SHM_SEGS || !shm_segs[shmid].in_use) return (void*)-1;
+    shm_segs[shmid].nattch++;
+    return shm_segs[shmid].addr;
+}
+
+int shmdt(const void* shmaddr) {
+    if (!shmaddr) return -1;
+    for (int i = 0; i < MAX_SHM_SEGS; i++) {
+        if (shm_segs[i].in_use && shm_segs[i].addr == shmaddr) {
+            if (shm_segs[i].nattch > 0) shm_segs[i].nattch--;
+            return 0;
+        }
+    }
+    return -1;
+}
+
+int shmctl(int shmid, int cmd, struct shmid_ds* buf) {
+    if (shmid < 0 || shmid >= MAX_SHM_SEGS || !shm_segs[shmid].in_use) return -1;
+
+    if (cmd == IPC_RMID) {
+        if (shm_segs[shmid].addr) kfree(shm_segs[shmid].addr);
+        memset(&shm_segs[shmid], 0, sizeof(shmid_ds_t));
+        return 0;
+    } else if (cmd == IPC_STAT && buf) {
+        memcpy(buf, &shm_segs[shmid], sizeof(shmid_ds_t));
+        return 0;
+    }
+    return -1;
+}