The Flopperating System (tfos) - x86 32 bit Hobby OS | Operating System Development | Page 4

bold grove Jul 22, 2025, 3:39 AM

#

and the kernel gets 1gb

#

(32 bit reemeber)

#

im kinda

#

losing my mind

#

but i finall got this part done

#

uintptr_t virt_to_phys(uintptr_t vaddr) {
    vaddr = _align_down(vaddr);

    uint32_t pd_idx = _pd_index(vaddr);
    uint32_t pt_idx = _pt_index(vaddr);

    if (!RESOLVE_RECURSIVE_PD[pd_idx].present) return 0;
    pte_t* pt = RESOLVE_RECURSIVE_PT(pd_idx);
    if (!pt[pt_idx].present) return 0;

    // resolve paddr from vaddr
    // - frame_addr << 12: converts frame number to paddr (upper 20 bits)
    // - vaddr & 0xFFF: preserves the page offset (lower 12 bits)
    return (pt[pt_idx].frame_addr << 12) | (vaddr & 0xFFF);
}


uintptr_t phys_to_virt(uintptr_t paddr) {
    paddr = _align_down(paddr);

    for (uint32_t pd_idx = 0; pd_idx < PAGE_DIRECTORY_SIZE; pd_idx++) {
        if (!RESOLVE_RECURSIVE_PD[pd_idx].present) continue;

        pte_t* pt = RESOLVE_RECURSIVE_PT(pd_idx);
        for (uint32_t pt_idx = 0; pt_idx < PAGE_TABLE_SIZE; pt_idx++) {
            if (!pt[pt_idx].present) continue;

            // check if entry maps to paddr 
            if ((pt[pt_idx].frame_addr << 12) == paddr) {
                // resolve vaddr from paddr
                // - pd_idx << 22: pd index in bits 31-22
                // - pt_idx << 12: pt index in bits 21-12
                // - paddr & 0xFFF: page offset in bits 11-0
                return (pd_idx << 22) | (pt_idx << 12) | (paddr & 0xFFF);
            }
        }
    }
    return 0;
}

#

i added comments so i dont completely have a stroke reading this next time

small hound Jul 22, 2025, 3:56 AM

#

bold grove i added comments so i dont completely have a stroke reading this next time

or just make small functions that self document :^)

bold grove Jul 22, 2025, 3:57 AM

#

My stupid laptop ain’t connecting to wifi now

small hound Jul 22, 2025, 3:57 AM

#

void schedule(void) {
    struct scheduler *sched = get_this_core_sched();

    bool interrupts = spin_lock(&sched->lock);

    struct thread *curr = sched->current;
    struct thread *next = NULL;
    requeue_current_thread_if_runnable(sched, curr);

    struct thread *stolen = scheduler_try_do_steal(sched);

    next = stolen ? stolen : scheduler_pick_regular_thread(sched);

    if (!next) {
        next = load_idle_thread(sched);
    } else {
        change_timeslice(sched, next);
    }

    load_thread(sched, next);
    update_core_current_thread(next);

    spin_unlock(&sched->lock, interrupts);

    if (curr && next)
        switch_context(&curr->regs, &next->regs);
    else
        load_context(&next->regs);
}``` for example, here I tried a bit to make the code document itself

#

do you think you understand what is going on

bold grove Jul 22, 2025, 3:57 AM

#

Yeah perfectly

#

Shit let me true

#

Try*

small hound Jul 22, 2025, 3:57 AM

#

ya you can try that

bold grove Jul 22, 2025, 4:00 AM

#

Well

#

I’m restarting my bullshit fuckass router

#

idk

blissful grove Jul 22, 2025, 4:08 AM

#

Not quite, that would be fine but is doing extra work. You only need to invalidate tlb entries when reducing permissions.

small hound Jul 22, 2025, 4:10 AM

#

oh interesting, neat

bold grove Jul 22, 2025, 4:11 AM

#

blissful grove Not quite, that would be fine but is doing extra work. You only need to invalida...

oh okay

#

so

#

i did what you said @small hound

blissful grove Jul 22, 2025, 4:11 AM

#

That's for x86 only btw

bold grove Jul 22, 2025, 4:11 AM

#

uintptr_t virt_to_phys(uintptr_t vaddr) {
    vaddr = _align_down(vaddr);

    uint32_t pd_idx = _pd_index(vaddr);
    uint32_t pt_idx = _pt_index(vaddr);

    if (!RESOLVE_RECURSIVE_PD[pd_idx].present) return 0;
    pte_t* pt = RESOLVE_RECURSIVE_PT(pd_idx);
    if (!pt[pt_idx].present) return 0;

    uintptr_t paddr = _fetch_frame_paddr(pt[pt_idx].frame_addr);
    return _resolve_paddr(paddr, vaddr);
}

uintptr_t phys_to_virt(uintptr_t paddr) {
    paddr = _align_down(paddr);

    for (uint32_t pd_idx = 0; pd_idx < PAGE_DIRECTORY_SIZE; pd_idx++) {
        if (!RESOLVE_RECURSIVE_PD[pd_idx].present) continue;

        pte_t* pt = RESOLVE_RECURSIVE_PT(pd_idx);
        for (uint32_t pt_idx = 0; pt_idx < PAGE_TABLE_SIZE; pt_idx++) {
            if (!pt[pt_idx].present) continue;

            if (_fetch_frame_paddr(pt[pt_idx].frame_addr) == paddr) {
                return _resolve_vaddr(pd_idx, pt_idx, _fetch_page_offset(paddr));
            }
        }
    }
    return 0;
}

#

modularized it

#

and yes i always make subroutines have underscores

bold grove Jul 22, 2025, 4:12 AM

#

blissful grove That's for x86 only btw

so like ia32?

blissful grove Jul 22, 2025, 4:12 AM

#

Nah anything x86

bold grove Jul 22, 2025, 4:13 AM

#

ah okay

#

i see

blissful grove Jul 22, 2025, 4:13 AM

#

Long mode, protected mode whatever comes next

small hound Jul 22, 2025, 4:13 AM

#

bold grove ```c uintptr_t virt_to_phys(uintptr_t vaddr) { vaddr = _align_down(vaddr); ...

my thingy works like this (ignore the jank please, i didnt spend time making it pretty)

uintptr_t vmm_get_phys(uintptr_t virt) {

    struct page_table *current_table = kernel_pml4;
    for (uint64_t i = 0; i < 3; i++) {
        uint64_t level = virt >> (39 - (i * 9)) & 0x1FF;
        pte_t *entry = &current_table->entries[level];
        if (!ENTRY_PRESENT(*entry))
            return -1;

        current_table =
            (struct page_table *) ((*entry & PAGING_PHYS_MASK) + hhdm_offset);
    }

    uint64_t L1 = (virt >> 12) & 0x1FF;
    pte_t *entry = &current_table->entries[L1];
    if (!(ENTRY_PRESENT(*entry)))
        return (uintptr_t) -1;

    return (*entry & PAGING_PHYS_MASK) + (virt & 0xFFF);
}```

blissful grove Jul 22, 2025, 4:13 AM

#

Long double mode meme

bold grove Jul 22, 2025, 4:13 AM

#

blissful grove Long double mode <:meme:575445094589661215>

long long mode trl

#

wait

#

so in paging.c

#

i map the memory or whatever

#

i stat with identity map

#

then kernel space in upper 1g

#

and 3gb for the user

#

is this like

small hound Jul 22, 2025, 4:15 AM

#

why do you fix the memory amounts lol

bold grove Jul 22, 2025, 4:15 AM

#

void paging_init(void) {
    log("paging: Initializing paging...\n", LIGHT_GRAY);
    // zero page directory entries
    for (int i = 0; i < PAGE_DIRECTORY_SIZE; i++) {
        page_attrs_t attrs = {0};
        SET_PF((pte_t *)&pd[i], attrs);
    }

    // identity map first 4MB. nuke ts later
    for (int i = 0; i < PAGE_TABLE_SIZE; i++) {
        page_attrs_t attrs = {
            .present = 1,
            .rw = 1,
            .user = 0,
            .frame_addr = i
        };
        SET_PF(&pt0[i], attrs);
    }
    pd[0].present = 1;
    pd[0].rw = 1;
    pd[0].user = 0;
    pd[0].table_addr = ((uintptr_t)pt0) >> PAGE_SIZE_SHIFT;

    // map kernel at 3GB, starting from physical address 0x00100000
    for (int i = 0; i < PAGE_TABLE_SIZE; i++) {
        page_attrs_t attrs = {
            .present = 1,
            .rw = 1,
            .user = 0,
            .frame_addr = (K_PHYS_START >> PAGE_SIZE_SHIFT) + i
        };
        SET_PF(&pt1[i], attrs);
    }
    pd[K_PD_INDEX].present = 1;
    pd[K_PD_INDEX].rw = 1;
    pd[K_PD_INDEX].user = 0;
    pd[K_PD_INDEX].table_addr = ((uintptr_t)pt1) >> PAGE_SIZE_SHIFT;

    // map kernel heap 
    for (int i = 0; i < PAGE_TABLE_SIZE; i++) {
        page_attrs_t attrs = {
            .present = (i != PAGE_TABLE_SIZE - 1) ? 1 : 0,
            .rw = 1,
            .user = 0,
            .frame_addr = (K_HEAP_START >> PAGE_SIZE_SHIFT) + i
        };
        SET_PF(&pt2[i], attrs);
    }
    pd[K_HEAP_PD_INDEX].present = 1;
    pd[K_HEAP_PD_INDEX].rw = 1;
    pd[K_HEAP_PD_INDEX].user = 0;
    pd[K_HEAP_PD_INDEX].table_addr = ((uintptr_t)pt2) >> PAGE_SIZE_SHIFT;

    // map userspace (lower 3GB)
    for (int i = 1; i < K_PD_INDEX; i++) {
        pd[i].present = 1;
        pd[i].rw = 1;
        pd[i].user = 1;  
    }

    load_page_directory((uintptr_t)pd);
    enable_paging();
    log("paging: Paging initialized.\n", GREEN);

    // note: at some point after vmm_init, we need to remove the identity map
    
}

bold grove Jul 22, 2025, 4:15 AM

#

small hound why do you fix the memory amounts lol

ia32

#

4gb mem limit

small hound Jul 22, 2025, 4:16 AM

#

that doesnt mean u have to make the memory amounts static tho koreablob

bold grove Jul 22, 2025, 4:16 AM

#

it wont map past memory that doesnt exist

small hound Jul 22, 2025, 4:16 AM

#

no i mean you can dynamically adjust how much memory you give kernel vs userspace

#

like you can shrink the amount of memory you give to the kernel and give that to user

#

for example once you have a page cache and a userspace program starts up and eats a lot of memory, you might start evicting things from your page cache, thereby making kernel space memory "smaller" and userspace memory "bigger"

bold grove Jul 22, 2025, 4:17 AM

#

i see

#

yeah i do my page cache in pmm though

small hound Jul 22, 2025, 4:18 AM

#

no need to make them fully static

small hound Jul 22, 2025, 4:18 AM

#

bold grove yeah i do my page cache in pmm though

what? 💥

#

page caches are for the virtual filesystem

#

why would the memory managers deal with that lol

bold grove Jul 22, 2025, 4:18 AM

#

oh i was talking about

#

like page info

#

in the pmm

#

this

#

struct Page {
    uintptr_t address;
    uint32_t order;
    int is_free;
    struct Page* next;
};

small hound Jul 22, 2025, 4:20 AM

#

this is the allocator i suppose

#

neat

bold grove Jul 22, 2025, 4:20 AM

#

yeah

#

my pmm im also redoing

bold grove Jul 22, 2025, 4:22 AM

#

small hound page caches are for the virtual filesystem

i thought page info in the pmm is also called a page cache no?

#

@blissful grove is that wrong or am i tripping

small hound Jul 22, 2025, 4:22 AM

#

that is not what that is called, no

bold grove Jul 22, 2025, 4:22 AM

#

what is that called then

small hound Jul 22, 2025, 4:22 AM

#

here, probably freelists?

bold grove Jul 22, 2025, 4:23 AM

#

ohhhh

#

wait

#

i see

small hound Jul 22, 2025, 4:23 AM

#

ya it's a list

bold grove Jul 22, 2025, 4:23 AM

#

so

#

i should probably

#

change this naming scheme

small hound Jul 22, 2025, 4:23 AM

#

call it freelist_entry probably

bold grove Jul 22, 2025, 4:23 AM

#

static void _init_page_cache(struct Page* page, uintptr_t address, uint32_t order) {
    page->address = address;
    page->order = order;
    page->is_free = 1;
    page->next = buddy.free_list[order];
    buddy.free_list[order] = page;
}

static void create_page_cache(void) {
    for (uint32_t i = 0; i < buddy.total_pages; i++) {
        struct Page* page = &buddy.page_info[i];
        _init_page_cache(page, buddy.memory_start + (i * PAGE_SIZE), MAX_ORDER);
    }
}

small hound Jul 22, 2025, 4:24 AM

#

yea that's just your allocator initialization

#

something like pmm_freelist_init

bold grove Jul 22, 2025, 4:25 AM

#

mmmm

#

very nice

#

static void _add_page_to_free_list(struct Page* page, uintptr_t address, uint32_t order) {
    page->address = address;
    page->order = order;
    page->is_free = 1;
    page->next = buddy.free_list[order];
    buddy.free_list[order] = page;
}

static void _create_free_list(void) {
    for (uint32_t i = 0; i < buddy.total_pages; i++) {
        struct Page* page = &buddy.page_info[i];
        _init_page_cache(page, buddy.memory_start + (i * PAGE_SIZE), MAX_ORDER);
    }
}

static void buddy_init(uint64_t total_memory, uintptr_t memory_start) {
    buddy.total_pages = total_memory / PAGE_SIZE;
    buddy.memory_start = memory_start;
    buddy.memory_end = buddy.memory_start + buddy.total_pages * PAGE_SIZE;

    buddy.page_info = (struct Page*)buddy.memory_start;
    buddy.memory_start += buddy.total_pages * sizeof(struct Page);

    _create_free_list();
}

static uint64_t iterate_mb_mmap(multiboot_info_t* mb_info) {
    uintptr_t mmap_addr = (uintptr_t)mb_info->mmap_addr;
    uintptr_t mmap_end = mmap_addr + mb_info->mmap_length;
    multiboot_memory_map_t* mmap = (multiboot_memory_map_t*)mmap_addr;

    uint64_t total_memory = 0;

    // iterate through memory regions from mb
    while ((uintptr_t)mmap < mmap_end) {
        // add avaiable regions and skip reserved ones
        if (mmap->type == MULTIBOOT_MEMORY_AVAILABLE) {
            total_memory += mmap->len;
        }
        
        // move to next entry
        mmap = (multiboot_memory_map_t*)((uintptr_t)mmap + mmap->size + sizeof(mmap->size));
    }

    return total_memory;
}

#

lets gooo

#

man yll

#

maybe i should be sober for a while

#

i get shit done

#

this is the first night ive been sober in a few months honestly

small hound Jul 22, 2025, 4:26 AM

#

stress test when

bold grove Jul 22, 2025, 4:26 AM

#

oh this allocator design works great

#

unless youre talking about mental strength

#

ive already tested it

#

many times

small hound Jul 22, 2025, 4:27 AM

#

is it SMP compatible and lockless

#

or will there be big lock contention

bold grove Jul 22, 2025, 4:27 AM

#

no no its lockless and works with my scehduler

small hound Jul 22, 2025, 4:27 AM

#

are you multicore

#

or are you single core

bold grove Jul 22, 2025, 4:27 AM

#

yeah, but i limited it to 8 cores for now

#

im still sussint that shit out

#

smp is fucky on ia32

small hound Jul 22, 2025, 4:28 AM

#

so did you test if all 8 cores can concurrently do allocations

#

does that work without locks

#

how did you make this without locks

#

send your lockless singly linked list operations

#

for the freelist entries

bold grove Jul 22, 2025, 4:29 AM

#

like how im adding to the free list?

#

or

small hound Jul 22, 2025, 4:29 AM

#

yea

bold grove Jul 22, 2025, 4:30 AM

#

wait so

#

like in free_page

#

?

small hound Jul 22, 2025, 4:30 AM

#

bold grove ?

no, when you append to the list or remove from it

bold grove Jul 22, 2025, 4:30 AM

#

i do that in my buddy split and buddy merge functions

small hound Jul 22, 2025, 4:30 AM

#

how do they look

#

void list_push(lockless_list_t *list, node_t *new_node) {
    tagged_ptr_t old_head, new_head;

    do {
        old_head = atomic_load(&list->head);

        new_node->next = old_head.ptr;

        new_head.ptr = new_node;
        new_head.count = old_head.count + 1;

    } while (!atomic_compare_exchange_weak(&list->head, &old_head, new_head));
}
``` a lockless singly linked list should look something like this

bold grove Jul 22, 2025, 4:31 AM

#

oh nah

#

i dont got the atomic shit

small hound Jul 22, 2025, 4:31 AM

#

so it isn't lockless

#

so how is it SMP compatible/thread safe

bold grove Jul 22, 2025, 4:32 AM

#

it cant do it "concurrently"

#

like my scheduler doesnt support that

small hound Jul 22, 2025, 4:32 AM

#

bold grove no no its lockless and works with my scehduler

what did you mean here

small hound Jul 22, 2025, 4:32 AM

#

bold grove like my scheduler doesnt support that

how does this have to do with ur scheduler

bold grove Jul 22, 2025, 4:33 AM

#

no , what i mean is that i cant run many things at once so technically i dont have a need for a lockless system

small hound Jul 22, 2025, 4:33 AM

#

bold grove yeah, but i limited it to 8 cores for now

i cant run many things at once

so what do you do with 7 of your cores here

bold grove Jul 22, 2025, 4:34 AM

#

create queues for each one and switch through them when i call schedule()

#

which yeah is basically single core

small hound Jul 22, 2025, 4:34 AM

#

by cores do you mean threads

#

i am now very perplexed

bold grove Jul 22, 2025, 4:34 AM

#

no

#

its hard to explain

small hound Jul 22, 2025, 4:35 AM

#

bold grove create queues for each one and switch through them when i call schedule()

how is it single core if you make queues for each core and switch through them

bold grove Jul 22, 2025, 4:35 AM

#

basically

#

i have a global integer of what core is currently being used

#

and as i schedule

#

i switc between them

#

so if schedule() gets called

#

core 1 will do it

#

and the next time schedule is called

small hound Jul 22, 2025, 4:35 AM

#

why is it necessary to switch between cores 💥 ⁉️

bold grove Jul 22, 2025, 4:35 AM

#

core 2 will do it

small hound Jul 22, 2025, 4:36 AM

#

why not just run it all on core 0

bold grove Jul 22, 2025, 4:36 AM

#

i mean i guess i could

small hound Jul 22, 2025, 4:36 AM

#

that is what you should do

#

there is no need for needless task/thread migration

#

that just makes the cache unhappy and the performance is the same if you just run it all on one core

blissful grove Jul 22, 2025, 4:37 AM

#

bold grove i thought page info in the pmm is also called a page cache no?

nah - a page cache is for caching on-disk blocks in memory for faster access and use by mmap(). If you're talking about an array of metadata you store for each page, thats usually referred to as struct page or the pfndb (page frame number(?) database)

bold grove Jul 22, 2025, 4:38 AM

#

blissful grove nah - a page cache is for caching on-disk blocks in memory for faster access and...

oh yeahhhh thats what NT called the PFN

#

so array of page structs is a PFN

#

ill take that into accont

#

i for some reason thought a page cache was that

blissful grove Jul 22, 2025, 4:39 AM

#

well the pfndb refers to the whole array

#

nah they're different entities 🙂

bold grove Jul 22, 2025, 4:40 AM

#

man

blissful grove Jul 22, 2025, 4:40 AM

#

and dw about lockless stuff and migrating threads for now. Start simple and get it working with locks lol, then worry about that stuff

bold grove Jul 22, 2025, 4:40 AM

#

people always say the buddy system is the hard one to implment

#

but its really not

bold grove Jul 22, 2025, 4:40 AM

#

blissful grove and dw about lockless stuff and migrating threads for now. Start simple and get ...

bet

blissful grove Jul 22, 2025, 4:40 AM

#

yeah I think people are always put off by the little bit of theory at the start

bold grove Jul 22, 2025, 4:41 AM

#

i should spinlock at the beginning and end of each pmm function (thats what ive seen)

blissful grove Jul 22, 2025, 4:41 AM

#

but like all things it has pros and cons

small hound Jul 22, 2025, 4:41 AM

#

bold grove people always say the buddy system is the hard one to implment

it depends on how you wanna do it, a basic one is not hard lol ya

bold grove Jul 22, 2025, 4:41 AM

#

basically

blissful grove Jul 22, 2025, 4:41 AM

#

bold grove i should spinlock at the beginning and end of each pmm function (thats what ive ...

I'm not going to answer that directly, because you should understand what a lock does and why - then you can answer that.

bold grove Jul 22, 2025, 4:42 AM

#

yeah i know it prevents other cores and operations from happening

#

so yeah it should be like that

blissful grove Jul 22, 2025, 4:42 AM

#

only for things that need protecting

bold grove Jul 22, 2025, 4:42 AM

#

isnt that like

#

kernel shit

#

like pmm,vmm, scheduler

#

etc

#

pretty much everytihng that doesnt run in the userspace?

blissful grove Jul 22, 2025, 4:42 AM

#

yeah, so the easiest way to deal with locking is to have a big kernel lock

#

where you lock "the whole kernel" and dont allow any concurrent access

#

that does the job, but its not great

#

I'd suggest looking at locking per-subsystem

bold grove Jul 22, 2025, 4:43 AM

#

i think i can probably do that for now

small hound Jul 22, 2025, 4:43 AM

#

a good piece of advice is to "Do the finest grained locks you can easily do" - hyenasky

bold grove Jul 22, 2025, 4:43 AM

#

blissful grove I'd suggest looking at locking per-subsystem

oh yeah

#

i see many source codes

#

where they have like

#

a special scheduler mutex

#

and other ones for other subsystems

blissful grove Jul 22, 2025, 4:44 AM

#

so look at your pmm, and ask yourself "what would happen if this code ran on two cpus at the same time", or if you got interrupt at a random point and maybe even got pre-empted.

#

as an example

small hound Jul 22, 2025, 4:44 AM

#

bold grove and other ones for other subsystems

these are probably wrappers over the other locks

bold grove Jul 22, 2025, 4:44 AM

#

blissful grove so look at your pmm, and ask yourself "what would happen if this code ran on two...

instant fault

small hound Jul 22, 2025, 4:44 AM

#

small hound these are probably wrappers over the other locks

static inline void bcache_ent_lock(struct bcache_entry *ent) {
    mutex_lock(&ent->lock);
}

static inline void bcache_ent_unlock(struct bcache_entry *ent) {
    mutex_unlock(&ent->lock);
}``` lol like this

bold grove Jul 22, 2025, 4:44 AM

#

so basically

#

system doing its thing -> pmm operation call -> lock -> do the pmm operation -> unlock -> continue

blissful grove Jul 22, 2025, 4:45 AM

#

pretty much

bold grove Jul 22, 2025, 4:45 AM

#

and the system contnues as normal

#

okay i see

blissful grove Jul 22, 2025, 4:45 AM

#

but only if the pmm operation needs to access some shared state

#

if the pmm operation is "convert this paddr to its struct page index", you dont really need to lock on that

#

or maybe you do

bold grove Jul 22, 2025, 4:46 AM

#

like inline stuff?

#

if im accessing page tables or freeing or allocating its safe to say i should lock

small hound Jul 22, 2025, 4:46 AM

#

you also might wanna get refcounting up and running right now too, since you'll soon be designing subsystems where you want to free things only once all references are gone

#

refcounting is really simple

blissful grove Jul 22, 2025, 4:47 AM

#

bold grove if im accessing page tables or freeing or allocating its safe to say i should lo...

if someone else could also access those, then yes.

bold grove Jul 22, 2025, 4:48 AM

#

i get that but

#

what is an exampe of a shared state

#

like

#

something that is modified by many "subsystems"

small hound Jul 22, 2025, 4:49 AM

#

a file

#

you don't have to think about it in terms of "subsystems"

#

let's just say two user programs wanna write to the same file at the same time and give certain offsets and lengths for their operations

#

you'd wanna do some form of locking there

blissful grove Jul 22, 2025, 4:49 AM

#

bold grove what is an exampe of a shared state

if it can be accessed more than once at the same time, its shared

bold grove Jul 22, 2025, 4:50 AM

#

i see so files, memory, etc

#

i see

blissful grove Jul 22, 2025, 4:50 AM

#

so your pmm buddy is an example. If you call pm_alloc() in multiple places (say threads, these could run on the same or different cpus) what would happen?

#

what if someone calls pm_free() at the same time as a call to pm_alloc() is already ongoing?

bold grove Jul 22, 2025, 4:52 AM

#

it would cause some sort of fault

small hound Jul 22, 2025, 4:52 AM

#

or just corrupted state

bold grove Jul 22, 2025, 4:52 AM

#

ye ye

#

anything that is accessed in many places, needs to be locked before and afer the operation

#

so is pm free and alloc are called

#

at the same time

#

it will safely do the first operation

#

so

#

pm_alloc and pm_free called -> pm_alloc lock -> pm alloc operation -> pm_alloc unlock -> pm_free lock -> pm free operation -> pm_free unlock

#

and lets say

#

i need to access a file

#

if igot 2 requests or syscalls or whatever

#

that would be similar

#

ahh

#

i got it

#

but how do i determine the locking order?

small hound Jul 22, 2025, 4:55 AM

#

now is about the time you wanna get a blocking mutex

bold grove Jul 22, 2025, 4:55 AM

#

@blissful grove

small hound Jul 22, 2025, 4:55 AM

#

bold grove but how do i determine the locking order?

oh this is a great great question

bold grove Jul 22, 2025, 4:55 AM

#

isnt a mutex just a lock?

small hound Jul 22, 2025, 4:56 AM

#

bold grove isnt a mutex just a lock?

keyword: blocking

#

mutex has an owner thread and waiters

bold grove Jul 22, 2025, 4:56 AM

#

yeah mutual exclusion

small hound Jul 22, 2025, 4:56 AM

#

bold grove but how do i determine the locking order?

so basically, the first guy that hits the lock will acquire it

#

but you also have priority inheritance in some implementations

blissful grove Jul 22, 2025, 4:56 AM

#

yeah easy answer first is that a mutex is a blocking lock (if you fail to acquire it, you get suspened and will be run again when you can try to acquire it again) , compared to a spinlock that just spins

blissful grove Jul 22, 2025, 4:56 AM

#

bold grove but how do i determine the locking order?

you think about it carefully

small hound Jul 22, 2025, 4:57 AM

#

small hound but you also have priority inheritance in some implementations

where if a high priority thread sees a low priority thread on a mutex, it boosts the low prio thread and unboosts it once the lock is unlocked

#

oh i thought you meant the order in which things acquire a lock

#

nvm

blissful grove Jul 22, 2025, 4:57 AM

#

blissful grove you think about it carefully

although having just looked at your example thats overcomplicated. You could just have a single lock for the pmm, that both alloc and free use.

bold grove Jul 22, 2025, 4:58 AM

#

but generally thats how it would be done?

blissful grove Jul 22, 2025, 4:58 AM

#

yeah

small hound Jul 22, 2025, 4:58 AM

#

bold grove yeah mutual exclusion

except here, a blocking mutex will block the thread, mark it as a waiter on the mutex, and the unlock operation on the mutex will wake the waiter(s)

blissful grove Jul 22, 2025, 4:58 AM

#

you have 1 resource (the pmm buddy), so it gets 1 lock

bold grove Jul 22, 2025, 4:58 AM

#

and these can just be spinlocks right?

blissful grove Jul 22, 2025, 4:58 AM

#

yeah they can be, you can get away with spinlocks for a long time (lol)

#

they're not always the best choice though

small hound Jul 22, 2025, 4:58 AM

#

small hound except here, a blocking mutex will block the thread, mark it as a waiter on the ...

the amount of waiters you wake differs based on implementation. you can wake one like a normal person, or you can wake all waiters and have them race to acquire the lock again

blissful grove Jul 22, 2025, 4:58 AM

#

but yes, it would work

bold grove Jul 22, 2025, 4:59 AM

#

for a pmm it should be enough though?

small hound Jul 22, 2025, 4:59 AM

#

as long as it isn't super slow

#

if it somehow ends up taking a long time it might be less than ideal to spin

#

but yea it should be ok

bold grove Jul 22, 2025, 5:00 AM

#

yeah i wont like map entire huge ass regions with a spin lock or something

small hound Jul 22, 2025, 5:00 AM

#

for future reference once you implement wait-type locks

#

this is from NT, so i figured it might help u since i think you're familiar with NT

#

and their silly strange pushlocks

bold grove Jul 22, 2025, 5:00 AM

#

nt my beloved

small hound Jul 22, 2025, 5:00 AM

#

have you looked into their pushlocks

#

definitely an approach of all time to pointer sized locks

bold grove Jul 22, 2025, 5:01 AM

#

i read up on their locking stuff once

#

but maybe i should again

small hound Jul 22, 2025, 5:01 AM

#

bold grove i read up on their locking stuff once

what did you gain from that reading

bold grove Jul 22, 2025, 5:01 AM

#

well i learned how mutual exclusion works and how theres an owner and waiters and that stuff but

#

i didnt learn about the push lokcs

blissful grove Jul 22, 2025, 5:02 AM

#

dont worry about them for now lol

#

a spinlock is fine for your pmm

small hound Jul 22, 2025, 5:02 AM

#

bold grove well i learned how mutual exclusion works and how theres an owner and waiters an...

that's mostly a general purpose view on locking, and there's a lot more to locking than just simple owner/waiter systems

#

locking is cool

#

but yea dont worry about it until it becomes a genuine concern

bold grove Jul 22, 2025, 5:03 AM

#

okay

#

so for multiprocessing then

#

i should create a queue for each processor

#

but how can they run "concurrently"

#

imkinda struggling with that

blissful grove Jul 22, 2025, 5:04 AM

#

each cpu core is mostly independent, minus some MSRs they share

#

so they can all run code at the same time

small hound Jul 22, 2025, 5:04 AM

#

bold grove i should create a queue for each processor

I would suggest first making your current scheduler not migrate things between cores and test it on one core

#

I'm assuming it's just a simple round-robin

bold grove Jul 22, 2025, 5:04 AM

#

yeah

small hound Jul 22, 2025, 5:04 AM

#

then, start making a multicore round-robin, so make one scheduler per core

bold grove Jul 22, 2025, 5:04 AM

#

it works on one core thats how i initially made it

small hound Jul 22, 2025, 5:05 AM

#

small hound then, start making a multicore round-robin, so make one scheduler per core

you dont need to worry about rebalancing for now

#

once you get your multicore round-robin working, you can choose what direction you wanna go next. MLFQ is the next easy step up since that's just RR x how many queues you have. you can do CFS if you are high enough on drugs to wanna do that

#

and then you can implement work stealing/rebalancing

bold grove Jul 22, 2025, 5:05 AM

#

i see

#

but when i run a thread

#

how does it know whih cpu to run on?

small hound Jul 22, 2025, 5:06 AM

#

bold grove how does it know whih cpu to run on?

pick the cpu with the least threads in the scheduler runqueue

#

simple stuff

bold grove Jul 22, 2025, 5:06 AM

#

okay i see

small hound Jul 22, 2025, 5:06 AM

#

or just explicitly specify it if needed

blissful grove Jul 22, 2025, 5:06 AM

#

you choose that when the thread is marked as ready to run, you would place it that cpu's work queue

bold grove Jul 22, 2025, 5:06 AM

#

so for threads its just a circular doubly linked list for each core

#

mine is like that but just one

#

global one

small hound Jul 22, 2025, 5:07 AM

#

yes

blissful grove Jul 22, 2025, 5:07 AM

#

I wouldnt make it circular, its just a queue

small hound Jul 22, 2025, 5:07 AM

#

blissful grove I wouldnt make it circular, its just a queue

circular helps

#

faster

blissful grove Jul 22, 2025, 5:07 AM

#

?

bold grove Jul 22, 2025, 5:07 AM

#

how does that make it faster

small hound Jul 22, 2025, 5:07 AM

#

wait nvm, yeah it doesnt need to be circular

#

I misinterpreted that as double vs singularly linked

#

you'll probably want it doubly linked to avoid that O(n) removal

bold grove Jul 22, 2025, 5:08 AM

#

okay doubly linked list for each core got it

small hound Jul 22, 2025, 5:09 AM

#

bold grove okay doubly linked list for each core got it

for now you dont have to worry about thread priorities but don't forget to eventually do that too

bold grove Jul 22, 2025, 5:10 AM

#

well i had it in my old scheduler

#

my single core one

small hound Jul 22, 2025, 5:10 AM

#

how did that work

bold grove Jul 22, 2025, 5:10 AM

#

it was pretty primitive

#

well tasks with highest priorities were bumped from the bottom of the list

#

but the issue

#

is that i starved lower priorities

small hound Jul 22, 2025, 5:11 AM

#

"We have MLFQ at home"

small hound Jul 22, 2025, 5:12 AM

#

bold grove is that i starved lower priorities

the typical solution to this is to decay thread priorities over time

bold grove Jul 22, 2025, 5:12 AM

#

yeah thats what i was told

small hound Jul 22, 2025, 5:12 AM

#

and then boost them once enough time has passed

bold grove Jul 22, 2025, 5:12 AM

#

but then i kinda gave up

small hound Jul 22, 2025, 5:12 AM

#

MLFQ is better for this

#

RR is ok if you dont do thread priorities

bold grove Jul 22, 2025, 5:12 AM

#

i only have experience with schedulers in like 16 bit real mode

#

that was most of the os experience i had

small hound Jul 22, 2025, 5:12 AM

#

why were you scheduling in 16 bit real mode 😭

bold grove Jul 22, 2025, 5:13 AM

#

becaue i made a multutasking operating system for 16 bit real mode

small hound Jul 22, 2025, 5:13 AM

#

interesting

#

where are all of these operating systems now

bold grove Jul 22, 2025, 5:14 AM

#

well this 16 bit one i never will post and nevre want to

#

my old old 64 bit kernel islost to time

#

like idk where it went

#

i suck at version control

#

a lot of the desig of my 16 bit kernel went into this one

#

i quit 16 bit because of

#

segmentation

#

crywojak

#

Well guys

#

I got some stuff done tonight

#

Vmm rewrite works
Pmm rewrite works
Paging is good
I’m now using my allocator for Flanterm instead of the built in one

#

But now my scheduler is borked for some reason

#

More fun for tomorrow

#

I’m gonna keep myself to this

#

4 more days until GitHub repo drop

#

Goals for tomorrow:

fix sched
implement testing suite

#

Good night guys

#

Thank you for the help @blissful grove and @small hound

#

I promise you will have some fun code to look at soon

bold grove Jul 22, 2025, 11:29 PM

#

bold grove - Vmm rewrite works - Pmm rewrite works - Paging is good - I’m now using my a...

Famous last words 💀

#

I page fault

#

Whenever creating address spaces

#

In the lower 3g

#

#

Thats not my hands btw

#

😭😭

bold grove Jul 23, 2025, 3:28 AM

#

Everything is fucked up bro

#

😭😭

#

Maybe more progress tonight if I’m up to it. Shits just going down

bold grove Jul 24, 2025, 1:08 AM

#

i just want to take this time

violet anchor Jul 24, 2025, 1:08 AM

#

this OS is familar

bold grove Jul 24, 2025, 1:08 AM

#

to show how much of a fucking pain in the ass it is

violet anchor Jul 24, 2025, 1:08 AM

#

https://tenor.com/view/frodo-baggins-samwise-gamgee-because-weve-been-here-before-are-we-doing-this-again-gif-23030666

Tenor

bold grove Jul 24, 2025, 1:08 AM

#

to set up pixel buffer color

#


void framebuffer_set_pixel_buffer(int x, int y, uint32_t color) {
    if (x < 0 || (uint32_t)x >= _fb_instance.width ||
        y < 0 || (uint32_t)y >= _fb_instance.height) return;

    uint8_t *_dest_fb = _fb_instance.screen;
    switch (_fb_instance.bpp) {
        case 8: {
            uint8_t *pixel = _dest_fb + _fb_instance.pitch * y + x;
            *pixel = color & 0xFF;
            break;
        }
        case 15: {
            uint16_t *pixel = (uint16_t *)(_dest_fb + _fb_instance.pitch * y + 2 * x);
            uint16_t r = (color >> 16) & 0x1F;
            uint16_t g = (color >> 8) & 0x1F;
            uint16_t b = color & 0x1F;
            *pixel = (r << 10) | (g << 5) | b;
            break;
        }
        case 16: {
            uint16_t *pixel = (uint16_t *)(_dest_fb + _fb_instance.pitch * y + 2 * x);
            uint16_t r = (color >> 16) & 0x1F;
            uint16_t g = (color >> 8) & 0x3F;
            uint16_t b = color & 0x1F;
            *pixel = (r << 11) | (g << 5) | b;
            break;
        }
        case 24: {
            uint8_t *pixel = _dest_fb + _fb_instance.pitch * y + 3 * x;
            pixel[0] = (color >> 0) & 0xFF;   // Blue
            pixel[1] = (color >> 8) & 0xFF;   // Green
            pixel[2] = (color >> 16) & 0xFF;  // Red
            break;
        }
        case 32: {
            uint32_t *pixel = (uint32_t *)(_dest_fb + _fb_instance.pitch * y + 4 * x);
            *pixel = color;
            break;
        }
    }
}

violet anchor Jul 24, 2025, 1:08 AM

#

thats horrible, why multiboot2?

bold grove Jul 24, 2025, 1:09 AM

#

its multiboot 1

violet anchor Jul 24, 2025, 1:09 AM

#

even worse lol

bold grove Jul 24, 2025, 1:09 AM

#

i just like 32 bit

#

and ive just stuck with it idk

violet anchor Jul 24, 2025, 1:09 AM

#

no better bootloader?

bold grove Jul 24, 2025, 1:09 AM

#

i dont wanna end up being another one of the limine x64 kernels that use flanterm

bold grove Jul 24, 2025, 1:09 AM

#

violet anchor no better bootloader?

no, i kinda enjoy multiboot 1 honestly

violet anchor Jul 24, 2025, 1:09 AM

#

lol

bold grove Jul 24, 2025, 1:09 AM

#

once you get past the pain

#

its not so bad

violet anchor Jul 24, 2025, 1:10 AM

#

just ... dont be a posix sheep

#

and youll be unique

bold grove Jul 24, 2025, 1:10 AM

#

thats what i mean

#

im not conforming to that at all

#

my system calls im making

#

have nothing to d iwth unix

#

all the software im making for it

violet anchor Jul 24, 2025, 1:10 AM

#

conforming, im deliberately pretending it doesnt exist.

bold grove Jul 24, 2025, 1:10 AM

#

based

#

its obviusly like

#

reasonable to follow the standard

#

if you want shit to run

#

but no

#

i don want bash

#

i want flopsh

violet anchor Jul 24, 2025, 1:11 AM

#

well technically it "does", but in the "world" where my OS would exist, posix never spread outside expensive mainframes.

bold grove Jul 24, 2025, 1:11 AM

#

i havent reference the systemv abi ONCE

violet anchor Jul 24, 2025, 1:11 AM

#

my shell is rocketsh, its written in BASIC 😄

bold grove Jul 24, 2025, 1:11 AM

#

huh i wonder why

#

is your whole OS in basic?

violet anchor Jul 24, 2025, 1:12 AM

#

apart from the kernel yes

#

https://github.com/brainboxdotcc/retro-rocket/blob/master/os/programs/rocketsh.rrbasic

GitHub

retro-rocket/os/programs/rocketsh.rrbasic at master · brainboxdotc...

Retro Rocket BASIC Powered Operating System. Contribute to brainboxdotcc/retro-rocket development by creating an account on GitHub.

#

thats the shell

#

the kernel has a multitasking basic interpreter in it

bold grove Jul 24, 2025, 1:13 AM

#

userspace shell?

violet anchor Jul 24, 2025, 1:13 AM

#

there is no userspace

bold grove Jul 24, 2025, 1:13 AM

#

you made a tcp

#

impl

#

wjat the fuck

violet anchor Jul 24, 2025, 1:13 AM

#

everything is ring 0, it acts like an old microcomputer, "mess around and find out", its intentional

#

poke it, peek it, its single user

bold grove Jul 24, 2025, 1:14 AM

#

tcp in kernel space is

#

fucking awesome but horrible

#

at the same time lol

violet anchor Jul 24, 2025, 1:14 AM

#

linux has tcp in kernel space... just in a module

bold grove Jul 24, 2025, 1:14 AM

#

no no i know

#

but accessing the internet entirely from kernel space

#

is just funny

violet anchor Jul 24, 2025, 1:14 AM

#

there is no "kernel space" in my OS

bold grove Jul 24, 2025, 1:14 AM

#

you right

violet anchor Jul 24, 2025, 1:14 AM

#

its just all the same

bold grove Jul 24, 2025, 1:14 AM

#

everything is just

#

yeah

#

what does your gdt look lik then

#

is it a single address system too?

violet anchor Jul 24, 2025, 1:15 AM

#

youre protected from completely messing up by the security on the interpreter, but it doesnt protect you from your intentions only your mistakes

#

if you decide you want to directly poke the PCI regs, you can

bold grove Jul 24, 2025, 1:15 AM

#

i mean like single addres space

violet anchor Jul 24, 2025, 1:16 AM

#

oh and its all identity mapped

bold grove Jul 24, 2025, 1:16 AM

#

thats insane what

violet anchor Jul 24, 2025, 1:16 AM

#

the interpreter doesnt need sepatate address spaces to mutlitask

bold grove Jul 24, 2025, 1:16 AM

#

damn dude

violet anchor Jul 24, 2025, 1:16 AM

#

i strongly believe in keep it simple

bold grove Jul 24, 2025, 1:16 AM

#

kinda reminds me somehwt of temple os

violet anchor Jul 24, 2025, 1:16 AM

#

yeah

bold grove Jul 24, 2025, 1:16 AM

#

in the way that it doesnt really care about userspace

#

or like

violet anchor Jul 24, 2025, 1:16 AM

#

except in 64 bit long mode, without religious undertones

bold grove Jul 24, 2025, 1:16 AM

#

even has one at all

#

i thought temple was 64 bit long mode

violet anchor Jul 24, 2025, 1:17 AM

#

iirc it was real mode

#

no youre right its long mode

bold grove Jul 24, 2025, 1:19 AM

#

i just rewrote my slab allocator

#

it used to be like

#

400 lines

#

for nom reason

violet anchor Jul 24, 2025, 1:20 AM

#

yeah so its basically the same memory model as templeos except i do multitasking

#

i just looked it up

violet anchor Jul 24, 2025, 1:21 AM

#

bold grove i just rewrote my slab allocator

whats it look like now?

bold grove Jul 24, 2025, 1:31 AM

#

i cant paste the whole thing for now

#

but here is how

#

im creating a memory pool for the slab structs

#

// memory pool for allocating slab structs
// this prevents slab allocations for slab structs because that's retarded
// the pool is made up of a linked list of physical pages
// these are divided by the size of the slab_t struct, 
// we will start off with one physical page
// we will do a check in _slab_pool_alloc to see if we need to allocate a new page
// if we do, alloc a new page and append it to the linked list
typedef struct slab_pool_page {
    struct slab_pool_page* next;
    slab_t slab_array[]; // array of slab_t structs, size is determined by SLAB_METADATA_PER_PAGE
} slab_pool_page_t;

static slab_pool_page_t* slab_pool_head = NULL; // head of linked list
static uint32_t slab_meta_used = 0;
static slab_t* current_slab_array = NULL;

static void _slab_pool_init() {
    slab_pool_head = (slab_pool_page_t*)pmm_alloc_page();
    if (!slab_pool_head) return;

    slab_pool_head->next = NULL;
    current_slab_array = slab_pool_head->slab_array;
    slab_meta_used = 0;
}

static inline int _slab_pool_need_new_page() {
    return (!current_slab_array || slab_meta_used >= SLAB_METADATA_PER_PAGE);
}

static int _slab_pool_add_page() {
    slab_pool_page_t* new_page = (slab_pool_page_t*)pmm_alloc_page();
    if (!new_page) return 0;

    new_page->next = NULL;

    // Append to the linked list
    slab_pool_page_t* iter = slab_pool_head;
    while (iter->next) iter = iter->next;
    iter->next = new_page;

    current_slab_array = new_page->slab_array;
    slab_meta_used = 0;
    return 1;
}
static slab_t* _slab_pool_alloc() {
    if (_slab_pool_need_new_page()) {
        if (!_slab_pool_add_page()) return NULL;
    }
    return &current_slab_array[slab_meta_used++];
}

#

@violet anchor

#

fixed

bold grove Jul 24, 2025, 8:34 PM

#

Guys

#

I’m pagefaulting

#

😔

#

Fucking everywhere

#

I suspect it’s an issue in my vmm

violet anchor Jul 25, 2025, 7:53 AM

#

what has changed?

bold grove Jul 25, 2025, 10:07 PM

#

violet anchor what has changed?

Don’t know

#

I suspect

#

It has to do with how I’m mapping the kernel

#

I’m getting the size of the kernel via the linker

#

And I think somewhere I’m messing that up

#

I map the kernel, then the whole kernel space , then the userspace

bold grove Jul 26, 2025, 8:42 PM

#

guys

#

this is a dumbass

#

thing i did

#

my damn vmm

#

so basically i have submethods for the pd and pt levels

#

(remeber 32 bit)

#

so i walk those tables here

#

int map_page(uintptr_t vaddr, uintptr_t paddr, page_attrs_t attrs) {
    vaddr = _align_down(vaddr);
    paddr = _align_down(paddr);
    if (vaddr == 0) return -1; 

    uint32_t indices[2] = {_pd_index(vaddr), _pt_index(vaddr)};
    pte_t* tables[2] = {RESOLVE_RECURSIVE_PD, NULL};
    for (int i = 0; i < 2; i++) { // walk page table levels
        switch (i) {
            case 0:
                _pd_lvl(tables, indices, attrs);
            case 1:
                _pt_lvl(tables, indices, paddr, attrs);
        }
    }

    __asm__ volatile("invlpg (%0)" :: "a"(vaddr));
    return 0;
}

#

so

#

looks fine and dandy

#

my dumbass

#

made the pd and pt functions have different

#

return types

#

so one of the return types of void and one is int

#

static int _pd_lvl(pte_t* tables[2], uint32_t indices[2], page_attrs_t attrs) {
    if (!tables[0][indices[0]].present) {
        pte_t* new_pt = (pte_t*)pmm_alloc_page();
        if (!new_pt) return -1;
        _zero_pt((pte_t*)((uintptr_t)new_pt));

        page_attrs_t new_attrs = {
            .present = attrs.present,
            .rw = attrs.rw,
            .user = attrs.user,
            .frame_addr = ((uintptr_t)new_pt) >> 12
        };
        SET_PF((pte_t*)&tables[0][indices[0]], new_attrs);
    }
    tables[1] = RESOLVE_RECURSIVE_PT(indices[0]);
    return 0;
}

static void _pt_lvl(pte_t* tables[2], uint32_t indices[2], uintptr_t paddr, page_attrs_t attrs) {
    if (tables[1][indices[1]].present) {
        pmm_free_page((void*)(tables[1][indices[1]].frame_addr << 12));
    }
    attrs.frame_addr = paddr >> 12;
    SET_PF(&tables[1][indices[1]], attrs);
}

#

💀 💀

bold grove Jul 28, 2025, 4:09 AM

#

im rewriting my idt:)

#

and just my interrupts in general

bold grove Jul 28, 2025, 5:14 AM

#

im so fucking close guys

#

to the commit

small hound Jul 28, 2025, 5:22 AM

#

top ten things that would sound terrible out of context

bold grove Jul 28, 2025, 5:28 AM

#

small hound top ten things that would sound terrible out of context

that too

#

watchmojo.com

bold grove Jul 29, 2025, 2:08 AM

#

I rewrote my idt

#

I didn’t name it that though

#

I just have one folder called interrupts

#

And interrupts.c, interrupts,h, and interrupt_asm.asm

small hound Jul 29, 2025, 2:19 AM

#

might as well call it interrupts_c.c and interrupts_h.h to make the naming consistent trl

bold grove Jul 29, 2025, 2:35 AM

#

small hound might as well call it interrupts_c.c and interrupts_h.h to make the naming consi...

Okay vro

foggy cedar Jul 29, 2025, 3:22 PM

#

small hound might as well call it interrupts_c.c and interrupts_h.h to make the naming consi...

interrupt_descriptor_table.c

small hound Jul 29, 2025, 3:23 PM

#

forgot the _c

bold grove Jul 29, 2025, 9:25 PM

#

foggy cedar interrupt_descriptor_table.c

interrupt_service_routine_c.c

#

💀

#

i know that naming is unconventional but

bold grove Jul 29, 2025, 11:59 PM

#

i made a function to clone a pagemap

#

int clone_pagemap(uintptr_t src_base, uintptr_t dst_base, size_t size) {
    size_t pages = _align_up(size) / PAGE_SIZE;
    for (size_t i = 0; i < pages; i++) {
        uintptr_t src_vaddr = src_base + i * PAGE_SIZE;
        uintptr_t dst_vaddr = dst_base + i * PAGE_SIZE;

      
        uint32_t src_pd_idx = _pd_index(src_vaddr);
        uint32_t src_pt_idx = _pt_index(src_vaddr);

        if (!RESOLVE_RECURSIVE_PD[src_pd_idx].present)
            continue; 

        pte_t* src_pt = RESOLVE_RECURSIVE_PT(src_pd_idx);
        if (!src_pt[src_pt_idx].present)
            continue; 

        uintptr_t src_paddr = src_pt[src_pt_idx].frame_addr << 12;
        page_attrs_t attrs = {
            .present = src_pt[src_pt_idx].present,
            .rw = src_pt[src_pt_idx].rw,
            .user = src_pt[src_pt_idx].user
        };

        void* dst_frame = pmm_alloc_page();
        if (!dst_frame)
            return -1;

        void* src_frame = (void*)src_paddr;
        flop_memcpy(dst_frame, src_frame, PAGE_SIZE);

        attrs.frame_addr = ((uintptr_t)dst_frame) >> 12;

        if (map_page(dst_vaddr, (uintptr_t)dst_frame, attrs) < 0) {
            // Rollback previous mappings
            for (size_t j = 0; j < i; j++) {
                uintptr_t undo_vaddr = dst_base + j * PAGE_SIZE;
                unmap_page(undo_vaddr);
            }
            pmm_free_page(dst_frame);
            return -1;
        }
    }
    return 0;
}

summer shadow Jul 30, 2025, 12:19 AM

#

bold grove ```c int clone_pagemap(uintptr_t src_base, uintptr_t dst_base, size_t size) { ...

this looks cool

paper cloak Jul 30, 2025, 12:23 AM

#

dunno why you need size

bold grove Jul 30, 2025, 12:24 AM

#

You’re right

paper cloak Jul 30, 2025, 12:34 AM

#

also any reason why you cant just memcpy from dst_frame to src_frame why do you need to call map

violet anchor Jul 30, 2025, 12:01 PM

#

flopperating system doesn't copy memory, it flops it.

bold grove Jul 30, 2025, 8:32 PM

#

paper cloak also any reason why you cant just memcpy from dst_frame to src_frame why do you ...

I’m not copying memory I’m cloning mappings

paper cloak Jul 30, 2025, 8:53 PM

#

bold grove I’m not copying memory I’m cloning mappings

Where do you think these mappings are stored lol

bold grove Jul 30, 2025, 11:12 PM

#

@paper cloak

#

is this the correct way of doing it?

#

wait hold up

viscid zephyr Jul 31, 2025, 6:02 AM

#

violet anchor flopperating system doesn't copy memory, it flops it.

don't copy that floppa

bold grove Aug 3, 2025, 2:27 AM

#

@small hound

small hound Aug 3, 2025, 2:28 AM

#

huh

bold grove Aug 3, 2025, 2:28 AM

#

is this a decent way of yielding per core

#

void sched_yield_core(uint32_t core_id) {
    thread_t* old = core_current_thread[core_id];
    thread_t* t = old ? old->next : NULL;
    thread_list_t* list = &core_thread_lists[core_id];
    if (!list->head) return;
    if (!t) t = list->head;
    thread_t* start = t;
    do {
        if (t->state == THREAD_READY)
            break;
        if (t->state == THREAD_SLEEPING && global_tick_count >= t->wake_tick) {
            t->state = THREAD_READY;
            break;
        }
        t = t->next;
    } while (t != start);
    if (t->state != THREAD_READY && core_idle_thread[core_id])
        t = core_idle_thread[core_id];
    if (t != old) {
        core_current_thread[core_id] = t;
        ctx_switch(&old->ctx, &t->ctx);
    }
}

small hound Aug 3, 2025, 2:29 AM

#

uh what are wake ticks? is your sleep using scheduler ticks?

#

you should probably use a separate external timer like the hpet for that instead of tying it to the scheduler

small hound Aug 3, 2025, 2:29 AM

#

bold grove ```c void sched_yield_core(uint32_t core_id) { thread_t* old = core_current_...

have you tested this code

bold grove Aug 3, 2025, 2:29 AM

#

should i just forgo the ticks for now

#

yeah it works

small hound Aug 3, 2025, 2:33 AM

#

bold grove ```c void sched_yield_core(uint32_t core_id) { thread_t* old = core_current_...

if the list head is null you probably wanna load the idle thread

#

since that would mean no tasks left

small hound Aug 3, 2025, 2:33 AM

#

bold grove ```c void sched_yield_core(uint32_t core_id) { thread_t* old = core_current_...

some of the logic here just seems odd, like the initialization of the variable "t"

#

when would the current thread be null

#

    struct scheduler *sched = get_this_core_sched();
    bool interrupts = spin_lock(&sched->lock);

    struct thread *curr = sched->current;
    struct thread *next = NULL;

    save_current_thread(sched, curr);

    /* Checks if we can steal, finds a victim, and tries to steal.
     * NULL is returned if any step was unsuccessful */
    struct thread *stolen = scheduler_try_do_steal(sched);

    next = stolen ? stolen : scheduler_pick_regular_thread(sched);

    if (!next) {
        /* Nothing available via steal or in our queues? */
        next = load_idle_thread(sched);
    } else {
        /* Depending on what was loaded, we may or may not
         * need to adjust the timeslice. RT threads do not
         * have timeslices, so the timeslice needs to be
         * disabled if an RT thread is chosen to run */
        change_timeslice(sched, next);
    }

    load_thread(sched, next);
    spin_unlock(&sched->lock, interrupts);

    context_switch(curr, next);
}``` my thingy looks like this, maybe you can add work stealing and locks and load the idle thread if the head is null

#

other than that it ok

bold grove Aug 3, 2025, 2:36 AM

#

im rewriting it

bold grove Aug 3, 2025, 2:40 AM

#

small hound ```cvoid schedule(void) { struct scheduler *sched = get_this_core_sched(); ...

okay imma load tge idle thread of the head is null \

#

@small hound

#

is this how i could do that

#

if (!list->head || !list->head->next) {
        thread_t* idle = core_idle_thread[core_id];
        if (idle && old != idle) {
            core_current_thread[core_id] = idle;
            ctx_switch(&old->ctx, &idle->ctx);
        }
        return;
}

#

i have an idle thread for each core

#

and this would be the whole function

#

void sched_yield_core(uint32_t core_id) {
    thread_t* old = core_current_thread[core_id];
    thread_list_t* list = &core_thread_lists[core_id];

    if (!old) {
        old = core_idle_thread[core_id];
        core_current_thread[core_id] = old;
    }

    if (!list->head || !list->head->next) {
        thread_t* idle = core_idle_thread[core_id];
        if (idle && old != idle) {
            core_current_thread[core_id] = idle;
            ctx_switch(&old->ctx, &idle->ctx);
        }
        return;
    }

    thread_t* t = old->next ? old->next : list->head;
    thread_t* start = t;

    do {
        if (t->state == THREAD_READY)
            break;
        t = t->next ? t->next : list->head;
    } while (t != start);

    if (t->state != THREAD_READY)
        t = core_idle_thread[core_id];

    if (t && t != old) {
        core_current_thread[core_id] = t;
        ctx_switch(&old->ctx, &t->ctx);
    }
}

bold grove Aug 4, 2025, 7:04 AM

#

We got multi core scheduling boys

#

https://github.com/amar454/floppaos/blob/main/task/sched.c

GitHub

floppaos/task/sched.c at main · amar454/floppaos

floppaOS is a free and open source 32 bit operating system made in C. It is themed around the famous internet Caracal "Big Floppa" - amar454/floppaos

violet anchor Aug 4, 2025, 7:27 AM

#

uint32_t get_core_id() {
    uint32_t core_id;
    __asm__ volatile ("movl %%gs:0, %0" : "=r"(core_id));
    return core_id;
}

what fills gs?

#

if you're using the lapic id as your core id and relying on it to be sequentially numbered between 0 and MAX_CORES-1, that is an incorrect assumption

#

real hardware can give any 32 bit number

#

you might get 0, 2, 4 ,8 ,10, 12... or 1, 5, 9...

bold grove Aug 4, 2025, 7:34 PM

#

My kernel is

Hopes and prayers init - ok 
Multibootfuckshit init - ok 

Page allocator init - maybe  

Err: Page fault 
Get fucked

red dirge Aug 7, 2025, 9:44 PM

#

Very nice

#

Is this a 16-bit os?

bold grove Aug 7, 2025, 9:44 PM

#

Nah

#

32bit

red dirge Aug 7, 2025, 9:44 PM

#

bold grove 32bit

nice

#

does this have acpi support?

bold grove Aug 7, 2025, 9:45 PM

#

Kinda lol

red dirge Aug 7, 2025, 9:45 PM

#

bold grove Kinda lol

just like off and reboot?

bold grove Aug 7, 2025, 9:45 PM

#

Yeah

red dirge Aug 7, 2025, 9:45 PM

#

thats what my os has lol

bold grove Aug 7, 2025, 9:45 PM

#

And it works on hypervisors

red dirge Aug 7, 2025, 9:45 PM

#

whats the github link?

red dirge Aug 7, 2025, 9:45 PM

#

bold grove And it works on hypervisors

nice

bold grove Aug 7, 2025, 9:46 PM

#

red dirge whats the github link?

https://github.com/amar454/floppaos

GitHub

GitHub - amar454/floppaos: floppaOS is a free and open source 32 bi...

floppaOS is a free and open source 32 bit operating system made in C. It is themed around the famous internet Caracal "Big Floppa" - amar454/floppaos

red dirge Aug 7, 2025, 9:47 PM

#

bold grove https://github.com/amar454/floppaos

i followed you and stared all your repos :)

bold grove Aug 7, 2025, 9:47 PM

#

Thank you so much

#

I’ll do the sand

#

Same*

red dirge Aug 7, 2025, 10:07 PM

#

bold grove I’ll do the sand

Thanks!

#

rn im adding build numbers

#

that i can acsses in cDOS

#

so i can see if my computer is running the latest OS

red dirge Aug 7, 2025, 11:19 PM

#

nice now i have a nice working version thingy

#

only tool like a hour to do that lol

bold grove Aug 8, 2025, 11:36 PM

#

we're adding spinlocks gang

#

i finally read up on all that bullshit

small hound Aug 9, 2025, 12:14 AM

#

features galore

bold grove Aug 9, 2025, 12:18 AM

#

small hound features galore

yessir

bold grove Aug 9, 2025, 12:19 AM

#

small hound features galore

im doing a little bit of what you suggested a while ago

#

well it wasnt just you but

#

im doing the queue per cpu

small hound Aug 9, 2025, 12:19 AM

#

💥 incredible

bold grove Aug 9, 2025, 12:20 AM

#

so

#

static void sched_reschedule_core(uint32_t core_id) {
    if (core_id >= global_scheduler.core_count) return;
    
    thread_t* old = global_scheduler.current_threads[core_id];
    thread_list_t* ready = &global_scheduler.ready_queues[core_id];
    
    if (!old) {
        old = global_scheduler.idle_threads[core_id];
        global_scheduler.current_threads[core_id] = old;
    }
    
    if (!ready->head) {
        if (old != global_scheduler.idle_threads[core_id]) {
            global_scheduler.current_threads[core_id] = global_scheduler.idle_threads[core_id];
            ctx_switch(&old->ctx, &global_scheduler.idle_threads[core_id]->ctx);
        }
        return;
    }
    
    thread_t* next = ready->head;
    thread_t* start = next;
    
    do {
        if (next->state == THREAD_READY) break;
        next = next->next;
    } while (next != start);
    
    if (next->state != THREAD_READY) {
        next = global_scheduler.idle_threads[core_id];
    }
    
    if (next && next != old) {
        global_scheduler.current_threads[core_id] = next;
        old->state = THREAD_READY;
        next->state = THREAD_RUNNING;
        next->last_run = global_ticks;
        ctx_switch(&old->ctx, &next->ctx);
    }
}

void schedule() {
    uint32_t core_id = sched_get_core_id();
    sched_reschedule_core(core_id);
}

#

im also doing load rebalancing

#

void sched_balance_load() {
    spinlock(&global_scheduler.sched_lock);
    for (uint32_t i = 0; i < global_scheduler.core_count; ++i) {
        if (global_scheduler.ready_queues[i].count > 1) {
            thread_list_t* list = &global_scheduler.ready_queues[i];
            thread_t* current = list->head;
            thread_t* next = current->next;
            while (current != list->tail) {
                if (current->state == THREAD_READY && next->state == THREAD_READY) {
                    // Move next to a less loaded core      
                    uint32_t target_core = (i + 1) % global_scheduler.core_count;
                    while (global_scheduler.ready_queues[target_core].count >= global_scheduler.ready_queues[i].count) {
                        target_core = (target_core + 1) % global_scheduler.core_count;
                    }
                    sched_remove_thread(next);
                    next->core_id = target_core;
                    sched_add_thread(next);
                }
                current = next;
                next = next->next;
            }
        }
    }       
    spinlock_unlock(&global_scheduler.sched_lock, true);
}

paper cloak Aug 9, 2025, 12:55 AM

#

bold grove ```c void sched_balance_load() { spinlock(&global_scheduler.sched_lock); ...

aaa global lock

bold grove Aug 9, 2025, 12:55 AM

#

paper cloak aaa global lock

Is that a bad thing

paper cloak Aug 9, 2025, 12:55 AM

#

yes?

bold grove Aug 9, 2025, 12:56 AM

#

I just have a global lock for my scheduler

#

It’s only for use in the scheduler

#

i have a different lock for my pmm, etc

small hound Aug 9, 2025, 12:56 AM

#

BKL

small hound Aug 9, 2025, 12:57 AM

#

bold grove ```c void sched_balance_load() { spinlock(&global_scheduler.sched_lock); ...

lol what's with the global_scheduler variables

#

funny way to do that

bold grove Aug 9, 2025, 12:57 AM

#

Big kernel lock

small hound Aug 9, 2025, 12:57 AM

#

yes

bold grove Aug 9, 2025, 12:57 AM

#

small hound lol what's with the global_scheduler variables

Idk just how I named them for now

bold grove Aug 9, 2025, 12:58 AM

#

small hound BKL

Isn’t it better to have different locks

#

Like

#

I’m making a pmm lock, etc

small hound Aug 9, 2025, 12:58 AM

#

yes

bold grove Aug 9, 2025, 12:58 AM

#

Okay, just making sure

small hound Aug 9, 2025, 12:58 AM

#

even more fine grained than that would be better

bold grove Aug 9, 2025, 12:58 AM

#

Like

#

A lock for pmm free and pmm alloc

#

Separate?

small hound Aug 9, 2025, 12:59 AM

#

no that would break something

#

they both operate on the same structure right

#

that would break something

bold grove Aug 9, 2025, 1:00 AM

#

Oh I see

#

Any shared state

#

Should have a lock

#

Right?

small hound Aug 9, 2025, 1:00 AM

#

that's the general idea yeah

bold grove Aug 9, 2025, 1:00 AM

#

Okay

#

So I guess for my pmm

#

I will have a lock for freeing and allocating pages

small hound Aug 9, 2025, 1:01 AM

#

small hound that's the general idea yeah

there are nuances and caveats and edge cases but those don't matter tooo much for now

bold grove Aug 9, 2025, 1:01 AM

#

Yeah

#

So within critical sections

#

Spinlocking is generally the idea

#

So I should probably make a list of “shared states”

small hound Aug 9, 2025, 1:02 AM

#

bold grove Spinlocking is generally the idea

yea, you really don't wanna sleep/block during an ISR or something

bold grove Aug 9, 2025, 1:02 AM

#

Yeah

small hound Aug 9, 2025, 1:02 AM

#

bold grove So I should probably make a list of “shared states”

wait why a list?

#

are you doing lock profiling?

bold grove Aug 9, 2025, 1:02 AM

#

No just a list in my notes lol

small hound Aug 9, 2025, 1:02 AM

#

oh alright

bold grove Aug 9, 2025, 1:02 AM

#

Like not a programmatic list lol

#

But I will be making locks for a bunch of subsystems

small hound Aug 9, 2025, 1:03 AM

#

bold grove But I will be making locks for a bunch of subsystems

wdym making locks lol

#

do you mean integrating them

#

yea but sounds good 👍

#

for many things you will probably want to avoid the "Big Function Lock" approach but it'll be OK for now

#

for example one fairly performant memory allocation technique that jemalloc uses is per-thread arenas

bold grove Aug 9, 2025, 1:04 AM

#

small hound do you mean integrating them

Yes integrating

small hound Aug 9, 2025, 1:04 AM

#

small hound for example one fairly performant memory allocation technique that jemalloc uses...

since these are per-thread they don't need anything like a Big Function Lock

bold grove Aug 9, 2025, 1:04 AM

#

That makes sense

#

Is a big function lock

#

Just

#

Something you call at the end and beginning of a critical section

#

Like a pmm allocation or something

small hound Aug 9, 2025, 1:06 AM

#

just any lock that is really coarse grained and just used to wrap around a function yea

#

you've heard about the linux BKL I'm guessing right

#

suboptimal locking decision

bold grove Aug 9, 2025, 1:07 AM

#

Yeah that’s how I know about the whole acronym I heard of it a few times

#

I feel like that just fucks up lock contention lol

#

Having a giant ass lock

small hound Aug 9, 2025, 1:07 AM

#

yup it's typically why you wanna avoid doing that

bold grove Aug 9, 2025, 1:08 AM

#

small hound yup it's typically why you wanna avoid doing that

How long did the bkl exist in Linux?

#

Wait so having one big kernel lock means only one processor can execute kernel code at once right?

viscid zephyr Aug 9, 2025, 1:09 AM

#

bold grove Wait so having one big kernel lock means only one processor can execute kernel c...

basically yes

bold grove Aug 9, 2025, 1:10 AM

#

viscid zephyr basically yes

I can see why that’s not optimal lol

#

That comes with a huge ass performance hit I’m sure

small hound Aug 9, 2025, 1:10 AM

#

bold grove How long did the bkl exist in Linux?

until 2017

#

https://kernelnewbies.org/BigKernelLock

viscid zephyr Aug 9, 2025, 1:10 AM

#

it was not as big as it started out though

#

also usually bkl's are released across long waits like file IO

#

and re-acquired when the wait completes

#

which mitigates it a little

bold grove Aug 9, 2025, 1:11 AM

#

Dang it’s like

#

A plague

#

Within the kernel lmao

#

That took 20 years to remove

bold grove Aug 9, 2025, 1:12 AM

#

viscid zephyr which mitigates it a little

I’m assuming the lock contention issues made it extremely complex at some point

#

And they probably just

#

Decided it was bad lol

small hound Aug 9, 2025, 1:17 AM

#

bold grove I’m assuming the lock contention issues made it extremely complex at some point

well the reason for the BKL existing in the first place was more of a simplicity hack

#

so it's not that it got extremely complex, just extremely slow

#

people didn't like that

#

I believe (you can double check by reading the sources) that early linux (like pre-2.0) was not smp aware

bold grove Aug 9, 2025, 1:21 AM

#

small hound I believe (you can double check by reading the sources) that early linux (like p...

Dang so single core only??

small hound Aug 9, 2025, 1:21 AM

#

pretty much

bold grove Aug 9, 2025, 1:21 AM

#

Crazy

bold grove Aug 9, 2025, 5:39 AM

#

Alright so I’ve implemented smp

bold grove Aug 9, 2025, 6:14 AM

#

@small hound should I spinlock within vfs and tmpfs operations

#

Like read and stuff

bold grove Aug 9, 2025, 6:15 AM

#

viscid zephyr which mitigates it a little

Should I spinlock within filesystem operations

viscid zephyr Aug 9, 2025, 6:17 AM

#

bold grove Should I spinlock within filesystem operations

uh

#

when

#

what do you do while holding this spinlock

#

what does it guard

bold grove Aug 9, 2025, 6:24 AM

#

viscid zephyr what does it guard

The filesystem?

#

I have a tmpfs_lock

viscid zephyr Aug 9, 2025, 6:25 AM

#

what it for

bold grove Aug 9, 2025, 6:35 AM

#

viscid zephyr what it for

I have it so two things don’t access it at once

viscid zephyr Aug 9, 2025, 6:45 AM

#

bold grove I have it so two things don’t access it at once

that is way too vague

#

lol

bold grove Aug 9, 2025, 7:25 AM

#

viscid zephyr that is way too vague

If I have a tmpfs that’s in memory, don’t I have to prevent two processes from accessing it at once

#

Like writing to two inodes at the same time would cause issues right?

viscid zephyr Aug 9, 2025, 7:27 AM

#

no you should allow concurrent reads and writes

#

you would just say that concurrent writes to overlapping regions of a file will have undefined results wrt which data ends up in the file

#

your locking should guard fs metadata

#

to stop it from becoming inconsistent

#

but not necessarily file data

#

that service is often offered but its done with explicit "file range locking" which you have to ask for

#

otherwise its concurrent by default

small hound Aug 9, 2025, 1:23 PM

#

bold grove If I have a tmpfs that’s in memory, don’t I have to prevent two processes from a...

you can have a tree structure of byte ranges and lock the byte ranges when they are being read or written

so if you write to range 0-50, you'd see nothing is there doing any write, and insert that range into the tree and acquire the lock

then if someone else writes to 11-77, they'd see that 0-50 exists and is locked which overlaps with their write, and then after 0-50 finishes you'd insert the 11-77 node

but if you write to 88-100, that write would proceed and wouldn't get blocked

this is only for writes that explicitly call for their regions to be locked

#

very nice and fine grained 😃

#

locking also isn't done at the filesystem node level and it's done at the page cache page level

#

oh yeah and going back to what will said, you would make this concurrent by default, only protecting against file metadata being concurrently modified, and serialization would be explicitly asked for by the user

like on linux you have the fcntl utility and work say something like

struct flock fl = {
    .l_type = F_WRLCK,
    .l_whence = SEEK_SET,
    .l_start = start_offset,
    .l_len = length
};
fcntl(fd, F_SETLKW, &fl);

bold grove Aug 9, 2025, 10:18 PM

#

small hound you can have a tree structure of byte ranges and lock the byte ranges when they ...

I see, so basically not accessing portions that are being used by other processes

#

Can I just make like 20 byte ranges?

small hound Aug 9, 2025, 10:41 PM

#

bold grove Can I just make like 20 byte ranges?

why specifically 20

#

is that your favorite number

bold grove Aug 9, 2025, 11:16 PM

#

small hound why specifically 20

Idk I just threw some arbitrary number

small hound Aug 9, 2025, 11:17 PM

#

bold grove Idk I just threw some arbitrary number

well the thing with hardcoding it with a number like that is it becomes overly fine grained and you waste space

#

i'm assumed you'd do that with a bitmap

#

so bigger file -> lots of space wasted

#

better to just use a tree

bold grove Aug 9, 2025, 11:17 PM

#

What type of tree

#

And how would I implement that

small hound Aug 9, 2025, 11:19 PM

#

💥 a tree that holds ranges of places in the file, like a red black tree would work fine

for example

struct range {
    size_t start;
    size_t end;
    struct rbnode tree_node;
    spinlock_t lock;
};``` and the `.data` in the `tree_node` is sorted by the `start`

small hound Aug 9, 2025, 11:27 PM

#

bold grove And how would I implement that

user makes lock request

lookup begins

1. check if there are overlaps
2. if no overlap -> insert the node to represent this range
     
   else, if there is an overlap, and
     if it is non-blocking -> fail with EAGAIN
     if it is blocking -> attach to wait-queue of overlapping node, sleep until woken, and retry the lookup

then on unlock (operation has finished)
1. remove node
2. wake all waiters on the node

#

shrimple as that

bold grove Aug 10, 2025, 1:45 AM

#

small hound ``` user makes lock request lookup begins 1. check if there are overlaps 2. if...

Two hours later I’m getting there

bold grove Aug 10, 2025, 2:01 AM

#

small hound 💥 a tree that holds ranges of places in the file, like a red black tree would w...

I basically implanted this diagram

#

small hound Aug 10, 2025, 2:34 AM

#

bold grove

https://pages.cs.wisc.edu/~amer/ yes 👍

#

wait did you not know how rbts worked lol

#

you should go learn that first then 👍

bold grove Aug 10, 2025, 2:59 AM

#

small hound wait did you not know how rbts worked lol

I took a class on data structures last year in college so there was a lot of material and I just had to relearn some of the stuff about it

small hound Aug 10, 2025, 2:59 AM

#

no problem then

#

you might find it suboptimal to go and implement a rbt from scratch, linux already has one you can go nab

bold grove Aug 10, 2025, 3:00 AM

#

Yeah?

#

Idk I don’t wanna copy code

#

I did implement it

#

In the class and I’m working on it now

small hound Aug 10, 2025, 3:00 AM

#

ok then sounds great just use that then and make sure it works properly 👍

bold grove Aug 10, 2025, 3:01 AM

#

Yeah I’ll show you when it’s done and after I test it

paper cloak Aug 10, 2025, 3:26 AM

#

bold grove Idk I don’t wanna copy code

a good resource is CLRS

#

I literally just translated the pseudocode to C

#

galaxybrain

bold grove Aug 10, 2025, 3:43 AM

#

paper cloak a good resource is CLRS

Oh yeah

bold grove Aug 10, 2025, 3:43 AM

#

paper cloak I literally just translated the pseudocode to C

Translate pseudo code to c? I’ve been ready for this my whole life

bold grove Aug 10, 2025, 3:45 AM

#

paper cloak a good resource is CLRS

Hey would you be able to take a look at my spinlock impl

#

Just to make sure I’m not missing anything

paper cloak Aug 10, 2025, 3:45 AM

#

spinlock is literally spinning on a cmpxchg

bold grove Aug 10, 2025, 3:45 AM

#

#define SPINLOCK_INIT {ATOMIC_VAR_INIT(0)}
typedef struct spinlock {
    atomic_uint state;
} spinlock_t;

static inline void spinlock_init(spinlock_t* lock) {
    atomic_store(&lock->state, 0);
}

static inline bool spinlock(spinlock_t* lock) {
    bool interrupts_enabled = IA32_INT_ENABLED();
    __asm__ volatile ("cli");
    while (__atomic_test_and_set(&lock->state, __ATOMIC_ACQUIRE)) {
        IA32_CPU_RELAX();
    }
    return interrupts_enabled;
}

static inline void spinlock_unlock(spinlock_t* lock, bool restore_interrupts) {
    __atomic_clear(&lock->state, __ATOMIC_RELEASE);
    if (restore_interrupts) {
        __asm__ volatile ("sti");
    }
}

static inline void spinlock_noint(spinlock_t* lock) {
    while (__atomic_test_and_set(&lock->state, __ATOMIC_ACQUIRE)) {
        IA32_CPU_RELAX();
    }
}

static inline void spinlock_unlock_noint(spinlock_t* lock) {
    __atomic_clear(&lock->state, __ATOMIC_RELEASE);
}
#endif // SPINLOCK_H

paper cloak Aug 10, 2025, 3:46 AM

#

yea thats probably fine, tho disabling interrupts is not something you really wanna do ideally

bold grove Aug 10, 2025, 3:46 AM

#

paper cloak yea thats probably fine, tho disabling interrupts is not something you really wa...

Do you think I should aim to use the noint one instead?

paper cloak Aug 10, 2025, 3:46 AM

#

no

#

you should disable preemption

#

not interrupts entirely

bold grove Aug 10, 2025, 3:47 AM

#

Ahhh

#

I see

#

Speaking of that

paper cloak Aug 10, 2025, 3:47 AM

#

there are many ways of doing it

bold grove Aug 10, 2025, 3:47 AM

#

I need preemption lmao

paper cloak Aug 10, 2025, 3:47 AM

#

linux has preempt_enable() and preempt_disable()

#

the best way imo is to do the NT/VMS thing which is having interrupt priority levels

bold grove Aug 10, 2025, 3:48 AM

#

Oh I see. Which interrupts would be of “low” and “high” priority

paper cloak Aug 10, 2025, 3:48 AM

#

depends

#

usually the order is something like all interrupts enabled -> APCs disabled -> DPCs disabled (preemption) -> device interrupts disabled -> all interrupts disabled

bold grove Aug 10, 2025, 3:49 AM

#

I see, so I should just have some sort of way to describe how important an interrupt is

paper cloak Aug 10, 2025, 3:49 AM

#

so to disable preemption you raise your ipl to dpc/dispatch/whatever you wanna call it level

bold grove Aug 10, 2025, 3:49 AM

#

Should I just have an enum of some sort

paper cloak Aug 10, 2025, 3:50 AM

#

and to enable it you lower it back again

#

and with this its pretty easy to do DPCs which are like linux softirqs

bold grove Aug 10, 2025, 3:50 AM

#

paper cloak and to enable it you lower it back again

So at the beginning of the spin lock -> disable preemption -> spin -> enable preemption -> continue?

paper cloak Aug 10, 2025, 3:51 AM

#

yeah

#

disable preemption on lock

#

restore it on unlock

small hound Aug 10, 2025, 4:21 AM

#

paper cloak not interrupts entirely

do note that if you have some function that can be called both manually and via some device interrupt, you'd wanna disable interrupts to avoid a deadlock upon lock acquisition

like take the following scenario

function is called manually -> lock is acquired (interrupts still enabled) -> interrupt fires -> function is called again -> deadlock

so like linux has spin_lock_irqsave for this

paper cloak Aug 10, 2025, 4:21 AM

#

yeah

#

usually u can just have your spinlock function take a desired ipl tho

small hound Aug 10, 2025, 4:22 AM

#

VMS propaganda!!!!!!

#

yea but that works too if u have that infra

bold grove Aug 10, 2025, 7:47 AM

#

@paper cloak what do you think about diagrams in code

#

I want to start going in the educational direction

#

If that makes sense

bold grove Aug 10, 2025, 7:47 AM

#

small hound yea but that works too if u have that infra

Maybe your input could help too

bold grove Aug 10, 2025, 8:31 AM

#

Here is my cool little thing I did for recursive mapping

#


/* 
    * Recursive mapping:
    *
    * PDE 1023 points to the Page Directory itself:
    *
    *   +-------------------------+ 0xFFFFF000
    *   | Page Directory (PD)     | <--- PDE[1023] points here 
    *   +-------------------------+
    *              ^
    *              ^
    *   +-------------------------+ 0xFFC00000
    *   | Page Tables (PTs) area  |  Covers PDE[0..1022]
    *   | +---------------------+ |
    *   | | PT 0                | | <-- PDE[0]
    *   | +---------------------+ |
    *   | | PT 1                | | <-- PDE[1]
    *   | +---------------------+ |
    *   | |        ...            | <- PDE[...]
    *   | +---------------------+ |
    *   | | PT 1022             | | <-- PDE[1022]
    *   | +---------------------+ |
    *   +-------------------------+
    *
    * virt address bit layout (32 bits):
    *
    *   [10 bits PDE][10 bits PT][12 bits offset]
    *
    * get pt:
    *
    *   0xFFC00000 + (PDE_index << 12) + (PT_index * 4)
    *
    * get pd:
    *
    *   0xFFFFF000 + (PDE_index * 4)
    */

paper cloak Aug 10, 2025, 1:25 PM

#

bold grove <@379432087620550658> what do you think about diagrams in code

I have a few of my own

#

So Id say it's good

small hound Aug 10, 2025, 1:41 PM

#

bold grove <@379432087620550658> what do you think about diagrams in code

pretty good 👍

#

check out graphviz

bold grove Aug 10, 2025, 9:21 PM

#

paper cloak I have a few of my own

Okay so I’m gonna start going the educational route for this

#

Not super hardcore but

#

I want most of the files to have soemthing to learn from

#

Not just code

bold grove Aug 10, 2025, 9:24 PM

#

small hound check out graphviz

Okay thank you, imma start heading down the education path for this os soon

bold grove Aug 10, 2025, 11:10 PM

#

Okay I need to redo my heap allocator gang 🥀

bold grove Aug 10, 2025, 11:51 PM

#

This is going bad

#

I’m thinking about making kernel allocations maxed at below page size

paper cloak Aug 11, 2025, 12:14 AM

#

Why

small hound Aug 11, 2025, 12:34 AM

#

bold grove I’m thinking about making kernel allocations maxed at below page size

just make a separate allocator for allocating above one page 💥

bold grove Aug 11, 2025, 1:40 AM

#

small hound just make a separate allocator for allocating above one page 💥

That’s what I’ve been doing for a while

#

You think that’s good enough?

small hound Aug 11, 2025, 1:45 AM

#

bold grove You think that’s good enough?

no you should ideally make your other allocator not break when you allocate above one page lol

sometimes you have allocations where the size is not known at compile time

bold grove Aug 11, 2025, 5:24 AM

#

Quitting alcohol = 300% productivity increase

bold grove Aug 12, 2025, 4:36 AM

#

Hi guys I’m gonna redo lots of the allocator and vmm in the next few days I’ll show updates and stuff

bold grove Aug 12, 2025, 3:05 PM

#

Okay I’ve worked out my spinlock impl

bold grove Aug 12, 2025, 7:36 PM

#

Okay I’ve been working on address space protection more

#

And aslr

#

Gonna randomize the kernel loading address

#

I kinda have weird names for it

#

For spinlocks

#

Idk

bold grove Aug 12, 2025, 10:21 PM

#

The naming scheme is

#

spinlock(&lock) which calls try_spinlock

#

spinlock_unlock releases the lock

#

A lot of people do spinlock_acquire and release but idk I like this more

#

It’s not entirely clear to someone who doesn’t know what a lock is what it means to “acquire” one

#

So I think for the educational purposes it’s better like this

small hound Aug 12, 2025, 11:51 PM

#

acquire would make more sense for things that have both a refcount and a lock, you can use it there

bold grove Aug 13, 2025, 12:21 AM

#

I don’t have a refcount rn

bold grove Aug 13, 2025, 12:21 AM

#

small hound acquire would make more sense for things that have both a refcount and a lock, y...

Should I refcount every lock

small hound Aug 13, 2025, 12:29 AM

#

bold grove Should I refcount every lock

if you need to

violet anchor Aug 13, 2025, 12:37 AM

#

do you need to?

#

usually all you need to do is store the current rflags when entering the lock and restore it when leaving

#

while disabling interrupts while spinning

bold grove Aug 13, 2025, 12:47 AM

#

violet anchor while disabling interrupts while spinning

That’s exactly what I do

small hound Aug 13, 2025, 12:53 AM

#

violet anchor usually all you need to do is store the current rflags when entering the lock an...

well not all rflags lol, iflag is the one that you'd care about

#

seems a bit whimsical to restore all the other flags

small hound Aug 13, 2025, 12:54 AM

#

bold grove That’s exactly what I do

you can consider doing lock profiling by making the spinlock_init put the lock in some global list to track all of them, and then you can print out their stats after you run tests or whatever

#

helps you find locks that are highly contended without checking each one manually

violet anchor Aug 13, 2025, 8:03 AM

#

small hound well not *all* rflags lol, iflag is the one that you'd care about

yeah I suppose you could | it in

bold grove Aug 13, 2025, 11:36 PM

#

On the agenda for this week

✅ rework spinlock
✅diagrams in vmm and paging
❌aslr/security features
❌diagrams in the rest of mem/

small hound Aug 13, 2025, 11:37 PM

#

why diagramming

bold grove Aug 14, 2025, 12:22 AM

#

small hound why diagramming

Because education

small hound Aug 14, 2025, 12:23 AM

#

bold grove Because education

why education though

bold grove Aug 14, 2025, 12:37 AM

#

small hound why education though

Because I want to create an educational os

#

I want people to be able to learn something from it

small hound Aug 14, 2025, 12:37 AM

#

uhhhhhhhh

#

ok best of luck then

bold grove Aug 14, 2025, 12:44 AM

#

I’m not going for an “OSdev” tutorial

bold grove Aug 14, 2025, 12:46 AM

#

small hound ok best of luck then

I’m not doing the whole “here’s the GDT code🤓🤓” thing

#

I’m more trying to show the process/teach others how to learn and implement their own thing

#

My code is all gpl anyways, it can’t be copied

small hound Aug 14, 2025, 12:46 AM

#

bold grove My code is all gpl anyways, it can’t be copied

uhhhhhhhh

paper cloak Aug 14, 2025, 12:46 AM

#

bold grove I’m not going for an “OSdev” tutorial

and yet still doing 32-bit x86 🤦‍♂️

small hound Aug 14, 2025, 12:47 AM

#

bold grove My code is all gpl anyways, it can’t be copied

not how that works but ok

bold grove Aug 14, 2025, 12:47 AM

#

paper cloak and yet still doing 32-bit x86 🤦‍♂️

Yeah because it’s what I know

#

I wouldn’t want to do something I don’t know very well

paper cloak Aug 14, 2025, 12:47 AM

#

it's still vastly inferior

bold grove Aug 14, 2025, 12:47 AM

#

Yeah I know

paper cloak Aug 14, 2025, 12:47 AM

#

and shouldnt be taught anymore

bold grove Aug 14, 2025, 12:48 AM

#

I’m not teaching the Architecture specifics in this devlog

#

I want it to apply to x64, arm, longarch

#

Not necessarily just ia32

paper cloak Aug 14, 2025, 12:48 AM

#

ok so why are you making page table diagrams for x86

small hound Aug 14, 2025, 12:49 AM

#

ok sooooo we already have books, articles, papers, code documentation, Real Kernel Code, so there's no need to reinvent the wheel here unless you're documenting something fully unique and novel (which isn't happening I fear)

bold grove Aug 14, 2025, 12:49 AM

#

I’m not trying to reinvent the wheel I just want to help people if I can

#

Maybe I should just do long modes

paper cloak Aug 14, 2025, 12:50 AM

#

bold grove My code is all gpl anyways, it can’t be copied

also this is true for all licenses except public domain and equivalent

bold grove Aug 14, 2025, 1:24 AM

#

paper cloak and shouldnt be taught anymore

I guess you’re right

#

I think I’ll just diagram in this os and then eventually make something in x64 and make it educational

#

I do wanna write a devlog about this os though

bold grove Aug 14, 2025, 4:19 PM

#

Hi guys

#

I’m gonna work on some new stuff today

#

Particularly userspace

#

Syscalls

#

Idk what to call it so

#

Imma just make a folder sys/

#

And have a syscalls.c

#

Maybe c++

#

trl

#

I need to make a handler first

#

Okay we have sys_read and sys_write now

bold grove Aug 14, 2025, 5:04 PM

#

Okay so imma
Make an actual vfs

#

Instead of using my tmpfs for fucking everything

#

Okay started on that vfs

#

Big commit coming today probably

small hound Aug 14, 2025, 5:16 PM

#

page cache

violet anchor Aug 14, 2025, 5:16 PM

#

bold grove Big commit coming today probably

vfs when

bold grove Aug 14, 2025, 5:17 PM

#

violet anchor vfs when

Today

violet anchor Aug 14, 2025, 5:17 PM

#

nice would like to see code and compare to my Eldrich nightmare that is walk_to_node_internal

bold grove Aug 14, 2025, 5:20 PM

#

Bet

bold grove Aug 14, 2025, 5:20 PM

#

violet anchor nice would like to see code and compare to my Eldrich nightmare that is walk_to_...

I’ve made vfs_open so far

#

And vfs_transverse

bold grove Aug 14, 2025, 5:21 PM

#

small hound page cache

Isn’t that for swapping

#

I need block storage first

#

But that’s going on the list

#

Probably

small hound Aug 14, 2025, 5:22 PM

#

bold grove Isn’t that for swapping

didn't r4 tell u about the page cache a while back

bold grove Aug 14, 2025, 5:22 PM

#

Yeah I just remembered

small hound Aug 14, 2025, 5:22 PM

#

HE DID THE THING

#

NO WAY IT'S REAL

#

Shocked

#

pog

bold grove Aug 14, 2025, 5:23 PM

#

Bruh

#

It’s not that bad lol

small hound Aug 14, 2025, 5:23 PM

#

crazy statement ⁉️

#

#define TMP_MAX_FILE_SIZE 4096

#

oh this is so peak

bold grove Aug 14, 2025, 5:24 PM

#

Just saying I made this a long ass time ago when I didn’t know much so

small hound Aug 14, 2025, 5:24 PM

#

you can trivially make this like 5x better by just doing an array of pointers to pages

bold grove Aug 14, 2025, 5:24 PM

#

It will obviously be improved

#

I’m studying an actual vfs impl

#

FreeBSD

#

So

#

It won’t be that bad soon

small hound Aug 14, 2025, 5:25 PM

#

no way flopfs is vibe coded too?

bold grove Aug 14, 2025, 5:26 PM

#

Yeah but

small hound Aug 14, 2025, 5:26 PM

#

peak

bold grove Aug 14, 2025, 5:26 PM

#

Yet again

#

HELLA LONG AGO

#

I’m getting rid of it rn lol

#

It’s not even in the makefile

bold grove Aug 14, 2025, 5:26 PM

#

small hound peak

I just removed it

#

I made that in like November

small hound Aug 14, 2025, 5:27 PM

#

bold grove Okay we have sys_read and sys_write now

how do you say stuff like this when tmpfs doesn't even dynamically allocate its memory for nodes lol

bold grove Aug 14, 2025, 5:27 PM

#

I was talking about the system call handler

small hound Aug 14, 2025, 5:27 PM

#

uhhhhhhhhh ok

#

I can't believe the filesystem design gif is real now

#

https://cdn.discordapp.com/attachments/829403502349647952/1292284234265919488/attachment-36.gif

bold grove Aug 14, 2025, 5:28 PM

#

Aight

#

But yeah

#

I made that shit

#

WAYY before I had much knowledge

small hound Aug 14, 2025, 5:29 PM

#

we have spinlock at home

#

why is that even necessary

#

you should be handling locking at the level of the driver that is using these instructions

bold grove Aug 14, 2025, 5:30 PM

#

This is yet again wayyyyy before

small hound Aug 14, 2025, 5:30 PM

#

like if core 0 is writing to port 4 and core 3 is reading from port 80 those dont need a lock

bold grove Aug 14, 2025, 5:31 PM

#

I just did like this before I had synchronization

small hound Aug 14, 2025, 5:31 PM

#

bold grove This is yet again wayyyyy before

yea but like if you're going to make an "educational OS" the code should be correct ykwim

#

is this all getting rewritten

bold grove Aug 14, 2025, 5:31 PM

#

Yeah

#

Absolutely lol

#

I’ve spent months on mem/ and other stuff

#

Haven’t really done anything with drivers or fs

small hound Aug 14, 2025, 5:32 PM

#

why is alloc not threadsafe

bold grove Aug 14, 2025, 5:33 PM

#

Haven’t migrated it yet

#

@small hound

#

Does this looks better

small hound Aug 14, 2025, 5:33 PM

#

allocating zero pages

bold grove Aug 14, 2025, 5:33 PM

#

typedef enum {
    TMP_NODE_FILE,
    TMP_NODE_DIR
} TmpNodeType;

typedef struct TmpNode {
    TmpNodeType type;
    char *name;
    struct TmpNode *parent;
    struct TmpNode **children;
    uint32_t child_count;
    void *file_data;
    uint32_t size;
    TmpPerms perms;
} TmpNode;

typedef struct {
    TmpNode *root;
} TmpFileSystem;

At least for the structs

small hound Aug 14, 2025, 5:33 PM

#

no

bold grove Aug 14, 2025, 5:34 PM

#

small hound allocating zero pages

No. (Order, pages)

small hound Aug 14, 2025, 5:34 PM

#

bold grove ``` typedef enum { TMP_NODE_FILE, TMP_NODE_DIR } TmpNodeType; typedef s...

it is better than what you had before

#

not good though

#

don't you have some tree implementation? you can use a tree here to store tmpfs pages

bold grove Aug 14, 2025, 5:34 PM

#

I got rid of the static sizes

#

Yeah I do

#

Not in my os but I do

small hound Aug 14, 2025, 5:34 PM

#

also the file_data is not store at the tmpfs level, tmpfs essentially lives in the page cache

bold grove Aug 14, 2025, 5:35 PM

#

Oh so the file data should be a pointer to a page in the page cache?

#

Or something like that

small hound Aug 14, 2025, 5:35 PM

#

no it shouldn't exist at all

#

you use a radix tree to do the lookup

bold grove Aug 14, 2025, 5:35 PM

#

Ohhhh, I see

#

Within tmpfs_read for example

#

Right?

#

So these structs should only contain metadata

small hound Aug 14, 2025, 5:37 PM

#

bold grove Ohhhh, I see

oh wait i thought you were talking about the contiguous "file_data" pointer you had

#

no you do want a pointer to page cache structures lol nvm

bold grove Aug 14, 2025, 5:37 PM

#

Ohhh okay

small hound Aug 14, 2025, 5:37 PM

#

but the node itself isn't where "the data is stored"

bold grove Aug 14, 2025, 5:37 PM

#

Each tmpnode should have a pointer to the page in the page cache, got it

#

Yeah it’s just a pointer to where it is

small hound Aug 14, 2025, 5:38 PM

#

bold grove Each tmpnode should have a pointer to the page in the page cache, got it

not a page, but the file page cache

bold grove Aug 14, 2025, 5:38 PM

#

Should I just create an array of uintptr_t’s to pages

#

In each tmpnode

small hound Aug 14, 2025, 5:39 PM

#

why would you need that

#

you just keep one backpointer like
struct address_space *i_mapping;

bold grove Aug 14, 2025, 5:39 PM

#

Ah okay

#

So it should be an address space for each node

small hound Aug 14, 2025, 5:40 PM

#

yea

bold grove Aug 14, 2025, 5:40 PM

#

Okay. Isn’t that like a lot of overhead tho?

small hound Aug 14, 2025, 5:40 PM

#

for example

small hound Aug 14, 2025, 5:40 PM

#

bold grove Okay. Isn’t that like a lot of overhead tho?

why would it be

bold grove Aug 14, 2025, 5:40 PM

#

Creating an entire virtual address space for each file?

small hound Aug 14, 2025, 5:41 PM

#

uhhh it's not really a virtual address space

#

struct address_space {
    struct inode        *host;
    struct xarray        i_pages;
    struct rw_semaphore    invalidate_lock;
    gfp_t            gfp_mask;
    atomic_t        i_mmap_writable;
#ifdef CONFIG_READ_ONLY_THP_FOR_FS
    /* number of thp, only for non-shmem files */
    atomic_t        nr_thps;
#endif
    struct rb_root_cached    i_mmap;
    unsigned long        nrpages;
    pgoff_t            writeback_index;
    const struct address_space_operations *a_ops;
    unsigned long        flags;
    errseq_t        wb_err;
    spinlock_t        i_private_lock;
    struct list_head    i_private_list;
    struct rw_semaphore    i_mmap_rwsem;
    void *            i_private_data;
} __attribute__((aligned(sizeof(long)))) __randomize_layout;```

bold grove Aug 14, 2025, 5:41 PM

#

Ohhhh

#

I see now

#

What does i_mmap_rwsem mean

small hound Aug 14, 2025, 5:42 PM

#

it's a semaphore

bold grove Aug 14, 2025, 5:42 PM

#

Why is there so many locks

#

I mean I know fine grain locks

small hound Aug 14, 2025, 5:42 PM

#

because linux is a multitasking smp compatible kernel

bold grove Aug 14, 2025, 5:43 PM

#

Oh this is Linux

#

Ahh

#

I see

#

Is it just acceptable for me to spinlock

#

Within tmpfs operations

#

Instead of doing all of that

small hound Aug 14, 2025, 5:43 PM

#

sure but for an ""educational OS"" you'd wanna tell people that almost everything you're doing is suboptimal

#

and then tell them to go look at real kernel code or something

bold grove Aug 14, 2025, 5:44 PM

#

How is it suboptimal to spinlock when everyone here does it lol

#

Like every kernel is

#

Spinlock; do shit; spinlock_unlock

small hound Aug 14, 2025, 5:44 PM

#

no it's not that it's suboptimal to spinlock, but it is suboptimal when you're doing things like a pmm_lock

bold grove Aug 14, 2025, 5:45 PM

#

Well I know I should have locks for certain shared states

small hound Aug 14, 2025, 5:45 PM

#

and people reading an "educational OS" can get easily misled by that

bold grove Aug 14, 2025, 5:45 PM

#

I guess

#

I guess I won’t do the education thing

#

I don’t think I’m really good enough for it or any of this stuff

small hound Aug 14, 2025, 5:46 PM

#

bold grove Aug 14, 2025, 5:46 PM

#

I’m just gonna study file system implementations

#

Just kinda demotivated for now

small hound Aug 14, 2025, 5:46 PM

#

sounds good

bold grove Aug 14, 2025, 5:48 PM

#


typedef struct {
    uintptr_t *pages;   
    uint32_t   num; 
    uint64_t   size;   
    uint32_t   flags;
    spinlock_t lock;
} address_space_t;
``` @small hound is this good enough for the “address space”

small hound Aug 14, 2025, 5:49 PM

#

you'd wanna use a tree to store the pages

#

radix tree is what most do

bold grove Aug 14, 2025, 5:49 PM

#

Yeah it’s a placeholder for now I’m gonna start that impl

small hound Aug 14, 2025, 5:50 PM

#

bold grove ```c typedef struct { uintptr_t *pages; uint32_t num; uint64_...

the primary issue with the big array of pointers is that the memory usage explodes

bold grove Aug 14, 2025, 5:51 PM

#

Yeah I see that lol

#

I should probably make a file in lib/ called radix.c

#

I already have a radix implementation

#The Flopperating System (tfos) - x86 32 bit Hobby OS