Remove old code

Signed-off-by: Richard Qin <richard.qin.x@gmail.com>

3 files changed, 0 insertions, 534 deletions

diff --git a/fs/ramfs/file.cc b/fs/ramfs/file.cc
deleted file mode 100644
index 6d9a070..0000000
--- a/fs/ramfs/file.cc
+++ /dev/null
@@ -1,216 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-/* Copyright (C) 2026 Richard Qin */
-
-/*
- * ramfs/file.cc — RamFS file operations (read/write via in-memory pages)
- *
- * Phase 1: simple flat buffer per-inode via i_private.
- * Will migrate to page_cache integration later.
- */
-
-#include <lume/fs.h>
-#include <lume/file.h>
-#include <lume/dcache.h>
-#include <lume/slab.h>
-#include <lume/errno.h>
-#include <lume/fs_types.h>
-
-/*
- * Simplest possible in-memory file storage:
- * i_private points to a dynamically grown buffer.
- */
-struct ramfs_file_data {
-    char*   buf;
-    uint64  capacity;
-};
-
-static ramfs_file_data* get_or_create_data(inode* ip)
-{
-    if (!ip->i_private) {
-        auto* data = new ramfs_file_data{};
-        data->buf = nullptr;
-        data->capacity = 0;
-        ip->i_private = data;
-    }
-    return static_cast<ramfs_file_data*>(ip->i_private);
-}
-
-static int ensure_capacity(ramfs_file_data* data, uint64 needed)
-{
-    if (needed <= data->capacity) return 0;
-
-    /* Round up to page size */
-    uint64 new_cap = (needed + 4095) & ~4095ULL;
-    char* new_buf = new char[new_cap];
-    if (!new_buf) return -ENOMEM;
-
-    /* Copy old data */
-    if (data->buf && data->capacity > 0) {
-        for (uint64 i = 0; i < data->capacity; i++)
-            new_buf[i] = data->buf[i];
-    }
-    /* Zero new region */
-    for (uint64 i = data->capacity; i < new_cap; i++)
-        new_buf[i] = 0;
-
-    delete[] data->buf;
-    data->buf = new_buf;
-    data->capacity = new_cap;
-    return 0;
-}
-
-/* ================================================================== */
-/*  ramfs_read                                                        */
-/* ================================================================== */
-
-static int64 ramfs_read(file* fp, char* buf, uint64 count, int64* pos)
-{
-    inode* ip = file_inode(fp);
-    int64 offset = *pos;
-
-    if (offset < 0) return -EINVAL;
-    if (offset >= ip->i_size) return 0;
-
-    int64 avail = ip->i_size - offset;
-    if (static_cast<int64>(count) > avail)
-        count = static_cast<uint64>(avail);
-
-    auto* data = static_cast<ramfs_file_data*>(ip->i_private);
-    if (!data || !data->buf) return 0;
-
-    /* Copy to user buffer.
-     * TODO: use copy_to_user when called from syscall context */
-    for (uint64 i = 0; i < count; i++)
-        buf[i] = data->buf[offset + i];
-
-    *pos += count;
-    return static_cast<int64>(count);
-}
-
-/* ================================================================== */
-/*  ramfs_write                                                       */
-/* ================================================================== */
-
-static int64 ramfs_write(file* fp, const char* buf, uint64 count, int64* pos)
-{
-    inode* ip = file_inode(fp);
-    int64 offset = *pos;
-
-    if (fp->f_flags & O_APPEND)
-        offset = ip->i_size;
-
-    if (offset < 0) return -EINVAL;
-
-    auto* data = get_or_create_data(ip);
-    uint64 end = static_cast<uint64>(offset) + count;
-
-    int err = ensure_capacity(data, end);
-    if (err) return err;
-
-    /* Copy from user buffer */
-    for (uint64 i = 0; i < count; i++)
-        data->buf[offset + i] = buf[i];
-
-    if (static_cast<int64>(end) > ip->i_size)
-        ip->i_size = end;
-
-    *pos = end;
-    mark_inode_dirty(ip);
-    return static_cast<int64>(count);
-}
-
-/* ================================================================== */
-/*  ramfs_dir_iterate — getdents64                                    */
-/* ================================================================== */
-
-static int ramfs_dir_iterate(file* fp, dir_context* ctx)
-{
-    dentry* dir_de = file_dentry(fp);
-    inode* dir_ip = file_inode(fp);
-    int64 pos = ctx->pos;
-    int count = 0;
-
-    /* pos 0: emit "." */
-    if (pos == 0) {
-        if (!ctx->actor(ctx, ".", 1, pos, dir_ip->i_ino, DT_DIR))
-            return 0;
-        ctx->pos = 1;
-        pos = 1;
-        count++;
-    }
-
-    /* pos 1: emit ".." */
-    if (pos == 1) {
-        uint64 parent_ino = dir_de->d_parent->d_inode
-            ? dir_de->d_parent->d_inode->i_ino : dir_ip->i_ino;
-        if (!ctx->actor(ctx, "..", 2, pos, parent_ino, DT_DIR))
-            return 0;
-        ctx->pos = 2;
-        pos = 2;
-        count++;
-    }
-
-    /* pos >= 2: iterate children */
-    int64 child_idx = 2;
-    list_node* node;
-    list_for_each(node, &dir_de->d_children) {
-        dentry* child = list_entry(node, dentry, d_child);
-
-        if (!child->d_inode)
-            continue;  /* skip negative dentries */
-
-        if (child_idx >= pos) {
-            uint8 d_type = DT_UNKNOWN;
-            if (S_ISDIR(child->d_inode->i_mode)) d_type = DT_DIR;
-            else if (S_ISREG(child->d_inode->i_mode)) d_type = DT_REG;
-            else if (S_ISCHR(child->d_inode->i_mode)) d_type = DT_CHR;
-            else if (S_ISBLK(child->d_inode->i_mode)) d_type = DT_BLK;
-            else if (S_ISLNK(child->d_inode->i_mode)) d_type = DT_LNK;
-            else if (S_ISFIFO(child->d_inode->i_mode)) d_type = DT_FIFO;
-
-            if (!ctx->actor(ctx, child->d_name.name,
-                            static_cast<int>(child->d_name.len),
-                            child_idx, child->d_inode->i_ino, d_type))
-                return 0;
-
-            ctx->pos = child_idx + 1;
-            count++;
-        }
-        child_idx++;
-    }
-
-    return count;
-}
-
-extern file_operations ramfs_file_operations;
-extern file_operations ramfs_dir_operations;
-
-file_operations ramfs_file_operations;
-file_operations ramfs_dir_operations;
-
-void ramfs_file_ops_init()
-{
-    ramfs_file_operations.llseek         = nullptr;
-    ramfs_file_operations.read           = ramfs_read;
-    ramfs_file_operations.write          = ramfs_write;
-    ramfs_file_operations.iterate_shared = nullptr;
-    ramfs_file_operations.poll           = nullptr;
-    ramfs_file_operations.unlocked_ioctl = nullptr;
-    ramfs_file_operations.mmap           = nullptr;
-    ramfs_file_operations.open           = nullptr;
-    ramfs_file_operations.flush          = nullptr;
-    ramfs_file_operations.release        = nullptr;
-    ramfs_file_operations.fsync          = nullptr;
-
-    ramfs_dir_operations.llseek          = nullptr;
-    ramfs_dir_operations.read            = nullptr;
-    ramfs_dir_operations.write           = nullptr;
-    ramfs_dir_operations.iterate_shared  = ramfs_dir_iterate;
-    ramfs_dir_operations.poll            = nullptr;
-    ramfs_dir_operations.unlocked_ioctl  = nullptr;
-    ramfs_dir_operations.mmap            = nullptr;
-    ramfs_dir_operations.open            = nullptr;
-    ramfs_dir_operations.flush           = nullptr;
-    ramfs_dir_operations.release         = nullptr;
-    ramfs_dir_operations.fsync           = nullptr;
-}
diff --git a/fs/ramfs/inode.cc b/fs/ramfs/inode.cc
deleted file mode 100644
index c5e49bf..0000000
--- a/fs/ramfs/inode.cc
+++ /dev/null
@@ -1,164 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-/* Copyright (C) 2026 Richard Qin */
-
-/*
- * ramfs/inode.cc — RamFS inode operations
- *
- * A simple in-memory filesystem (like Linux tmpfs without swap).
- * All data lives in memory via the page cache.
- */
-
-#include <lume/fs.h>
-#include <lume/dcache.h>
-#include <lume/file.h>
-#include <lume/slab.h>
-#include <lume/errno.h>
-#include <lume/fs_types.h>
-
-/* Forward declarations */
-extern file_operations ramfs_file_operations;
-extern file_operations ramfs_dir_operations;
-extern inode_operations ramfs_dir_inode_operations;
-
-/* ================================================================== */
-/*  ramfs_get_inode — allocate + init an inode for ramfs               */
-/* ================================================================== */
-
-inode* ramfs_get_inode(super_block* sb, const inode* dir, uint32 mode, uint32 rdev)
-{
-    inode* ip = new_inode(sb);
-    if (!ip) return nullptr;
-
-    inode_init_owner(ip, dir, mode);
-    /* TODO: set timestamps to current time when we have a time source */
-
-    switch (mode & S_IFMT) {
-    case S_IFREG:
-        ip->i_op = nullptr;  /* regular files don't need inode_ops for Phase 1 */
-        ip->i_fop = &ramfs_file_operations;
-        break;
-    case S_IFDIR:
-        ip->i_op = &ramfs_dir_inode_operations;
-        ip->i_fop = &ramfs_dir_operations;
-        inc_nlink(ip);  /* directories start with nlink=2 (. and parent's link) */
-        break;
-    case S_IFLNK:
-        /* Symlink: stub for Phase 1 */
-        break;
-    default:
-        /* Character/block devices: i_rdev */
-        ip->i_rdev = rdev;
-        break;
-    }
-
-    return ip;
-}
-
-/* ================================================================== */
-/*  Directory inode operations                                        */
-/* ================================================================== */
-
-static dentry* ramfs_lookup(inode* dir, dentry* de, unsigned int flags)
-{
-    (void)dir;
-    (void)flags;
-    /* For ramfs, everything is in dcache. If we get here, it means
-     * d_lookup() already failed, so this is a negative dentry.
-     * Just return nullptr to let the caller see de->d_inode == NULL. */
-    return nullptr;
-}
-
-static int ramfs_create(inode* dir, dentry* de, uint32 mode, bool excl)
-{
-    (void)excl;
-    inode* ip = ramfs_get_inode(dir->i_sb, dir, mode | S_IFREG, 0);
-    if (!ip) return -ENOMEM;
-
-    d_instantiate(de, ip);
-    dget(de);
-    dir->i_size += de->d_name.len;
-    mark_inode_dirty(dir);
-    return 0;
-}
-
-static int ramfs_mkdir(inode* dir, dentry* de, uint32 mode)
-{
-    inode* ip = ramfs_get_inode(dir->i_sb, dir, mode | S_IFDIR, 0);
-    if (!ip) return -ENOMEM;
-
-    d_instantiate(de, ip);
-    dget(de);
-    inc_nlink(dir);
-    dir->i_size += de->d_name.len;
-    mark_inode_dirty(dir);
-    return 0;
-}
-
-static int ramfs_rmdir(inode* dir, dentry* de)
-{
-    /* Check if directory is empty */
-    if (!list_empty(&de->d_children))
-        return -ENOTEMPTY;
-
-    drop_nlink(de->d_inode);  /* remove . link */
-    drop_nlink(de->d_inode);  /* remove parent's link */
-    drop_nlink(dir);
-    d_delete(de);
-    dir->i_size -= de->d_name.len;
-    mark_inode_dirty(dir);
-    return 0;
-}
-
-static int ramfs_unlink(inode* dir, dentry* de)
-{
-    drop_nlink(de->d_inode);
-    d_delete(de);
-    dir->i_size -= de->d_name.len;
-    mark_inode_dirty(dir);
-    return 0;
-}
-
-static int ramfs_link(dentry* old_de, inode* dir, dentry* new_de)
-{
-    inode* ip = old_de->d_inode;
-    if (!ip) return -ENOENT;
-
-    inc_nlink(ip);
-    ihold(ip);
-    d_instantiate(new_de, ip);
-    dget(new_de);
-    dir->i_size += new_de->d_name.len;
-    mark_inode_dirty(dir);
-    return 0;
-}
-
-static int ramfs_mknod(inode* dir, dentry* de, uint32 mode, uint32 rdev)
-{
-    inode* ip = ramfs_get_inode(dir->i_sb, dir, mode, rdev);
-    if (!ip) return -ENOMEM;
-
-    d_instantiate(de, ip);
-    dget(de);
-    dir->i_size += de->d_name.len;
-    mark_inode_dirty(dir);
-    return 0;
-}
-
-inode_operations ramfs_dir_inode_operations;
-
-void ramfs_dir_inode_ops_init()
-{
-    ramfs_dir_inode_operations.lookup     = ramfs_lookup;
-    ramfs_dir_inode_operations.create     = ramfs_create;
-    ramfs_dir_inode_operations.link       = ramfs_link;
-    ramfs_dir_inode_operations.unlink     = ramfs_unlink;
-    ramfs_dir_inode_operations.symlink    = nullptr;
-    ramfs_dir_inode_operations.mkdir      = ramfs_mkdir;
-    ramfs_dir_inode_operations.rmdir      = ramfs_rmdir;
-    ramfs_dir_inode_operations.mknod      = ramfs_mknod;
-    ramfs_dir_inode_operations.rename     = nullptr;
-    ramfs_dir_inode_operations.setattr    = nullptr;
-    ramfs_dir_inode_operations.getattr    = nullptr;
-    ramfs_dir_inode_operations.get_link   = nullptr;
-    ramfs_dir_inode_operations.permission = nullptr;
-}
diff --git a/fs/ramfs/super.cc b/fs/ramfs/super.cc
deleted file mode 100644
index 6f929f2..0000000
--- a/fs/ramfs/super.cc
+++ /dev/null
@@ -1,154 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-/* Copyright (C) 2026 Richard Qin */
-
-/*
- * ramfs/super.cc — RamFS superblock: mount, fill_super, and init
- */
-
-#include <lume/fs.h>
-#include <lume/dcache.h>
-#include <lume/file.h>
-#include <lume/mount.h>
-#include <lume/slab.h>
-#include <lume/kprintf.h>
-#include <lume/errno.h>
-#include <lume/fs_types.h>
-
-extern inode* ramfs_get_inode(super_block* sb, const inode* dir,
-                              uint32 mode, uint32 rdev);
-
-/* Superblock allocation helper (defined in super.cc) */
-extern super_block* alloc_super(file_system_type* type);
-
-/* ================================================================== */
-/*  ramfs super_operations                                            */
-/* ================================================================== */
-
-static inode* ramfs_alloc_inode(super_block* sb)
-{
-    return new inode{};
-}
-
-static void ramfs_destroy_inode(inode* ip)
-{
-    /* Free ramfs_file_data if any */
-    if (ip->i_private) {
-        struct ramfs_file_data {
-            char* buf;
-            uint64 capacity;
-        };
-        auto* data = static_cast<ramfs_file_data*>(ip->i_private);
-        delete[] data->buf;
-        delete data;
-    }
-    delete ip;
-}
-
-static int ramfs_statfs(dentry* de, kstatfs* buf)
-{
-    /* Simple fake values */
-    buf->f_type = 0x858458f6;  /* RAMFS_MAGIC */
-    buf->f_bsize = 4096;
-    buf->f_blocks = 0;
-    buf->f_bfree = 0;
-    buf->f_bavail = 0;
-    buf->f_files = 0;
-    buf->f_ffree = 0;
-    buf->f_namelen = 255;
-    buf->f_frsize = 4096;
-    buf->f_flags = 0;
-    return 0;
-}
-
-static super_operations ramfs_sops;
-
-static void ramfs_sops_init()
-{
-    ramfs_sops.alloc_inode   = ramfs_alloc_inode;
-    ramfs_sops.destroy_inode = ramfs_destroy_inode;
-    ramfs_sops.free_inode    = nullptr;
-    ramfs_sops.dirty_inode   = nullptr;
-    ramfs_sops.write_inode   = nullptr;
-    ramfs_sops.drop_inode    = nullptr;
-    ramfs_sops.evict_inode   = nullptr;
-    ramfs_sops.put_super     = nullptr;
-    ramfs_sops.sync_fs       = nullptr;
-    ramfs_sops.statfs        = ramfs_statfs;
-    ramfs_sops.umount_begin  = nullptr;
-}
-
-/* ================================================================== */
-/*  ramfs_fill_super                                                  */
-/* ================================================================== */
-
-static int ramfs_fill_super(super_block* sb, void* data, int silent)
-{
-    sb->s_op = &ramfs_sops;
-    sb->s_magic = 0x858458f6;
-    sb->s_blocksize = 4096;
-    sb->s_blocksize_bits = 12;
-    sb->s_maxbytes = 0x7FFFFFFFFFFFFFFFLL;
-    sb->s_time_gran = 1;
-
-    /* Create root inode */
-    inode* root_ip = ramfs_get_inode(sb, nullptr, S_IFDIR | 0755, 0);
-    if (!root_ip) return -ENOMEM;
-
-    /* Create root dentry */
-    sb->s_root = d_make_root(root_ip);
-    if (!sb->s_root)
-        return -ENOMEM;
-
-    return 0;
-}
-
-/* ================================================================== */
-/*  ramfs_mount                                                       */
-/* ================================================================== */
-
-static super_block* ramfs_mount(file_system_type* type, int flags,
-                                const char* dev_name, void* data)
-{
-    super_block* sb = alloc_super(type);
-    if (!sb) return nullptr;
-
-    int err = ramfs_fill_super(sb, data, flags & SB_SILENT);
-    if (err) {
-        delete sb;
-        return nullptr;
-    }
-
-    return sb;
-}
-
-static void ramfs_kill_sb(super_block* sb)
-{
-    /* Phase 1: no cleanup needed for ramfs */
-    (void)sb;
-}
-
-/* ================================================================== */
-/*  Filesystem type registration                                      */
-/* ================================================================== */
-
-static file_system_type ramfs_fs_type;
-
-extern void ramfs_file_ops_init();
-extern void ramfs_dir_inode_ops_init();
-
-void ramfs_init()
-{
-    /* Runtime init to avoid un-relocated absolute pointers in .data */
-    ramfs_sops_init();
-    ramfs_file_ops_init();
-    ramfs_dir_inode_ops_init();
-
-    ramfs_fs_type.name     = "ramfs";
-    ramfs_fs_type.fs_flags = FS_NO_DEVICE;
-    ramfs_fs_type.mount    = ramfs_mount;
-    ramfs_fs_type.kill_sb  = ramfs_kill_sb;
-    list_init(&ramfs_fs_type.fs_list);
-
-    register_filesystem(&ramfs_fs_type);
-}
-