Todo List

Global _file_flush_buffer (FILE *stream)

Text stream conversion here

Global _print_format (_print_ctx_t *ctx)

Implement floating point formatting

Global _scan_format_float (_scan_ctx_t *ctx, _scan_format_ctx_t *format)

Implement floating point scanning

Global _scan_format_scanset (_scan_ctx_t *ctx, _scan_format_ctx_t *format)

Wide chars

Global _time_zone_init (void)

Load time zone from a configuration file.

Struct _time_zone_t

Time zone handling is not compliant with the c standard (for now). Daylight savings time.

Struct acpi_device_cfg_t

Add more config stuff like memory ranges, DMA etc.

Global aml_data_ref_object_read (aml_term_list_ctx_t *ctx, aml_object_t *out)

Implement ObjectReference handling... somehow. I honestly have no clue what the spec wants you to do here. But everything seems to work fine by only reading DataObjects for now.

Struct aml_event_t

Implement event object functionality.

Global aml_field_unit_access (aml_state_t *state, aml_field_unit_t *fieldUnit, aml_object_t *data, aml_access_direction_t direction)

"An Operation Region object implicitly supports Mutex synchronization. Updates to the object, or a Field data object for the region, will automatically synchronize on the Operation Region object;" - Section 19.6.100

Global aml_osi_implementation (aml_method_t *method, aml_object_t **args, uint64_t argCount)

Implement _OSI strings properly. For now, we just return true for everything.

Global aml_patch_up_resolve_all (void)

I am still not sure when would be the best time to call this function, for now its called after the DSDT and all SSDTs have been loaded, i am quite sure that we will end up getting issues with unresolved references due to this, but instead of trying to solve that now, we will just fix it as issues arise.

Global aml_predefined_init (void)

Implement _GL properly.

Global aml_reference_type_opcode_read (aml_term_list_ctx_t *ctx)

Stare at the spec some more.

Global atof (const char *nptr)

Finish this implementation, missing NAN, INF 0x/0X handling.

Struct cnd_t

Implement user space cnd_t and tss_t.

Global domains

Optimize domain lookup?

Global dwm_next_timer (void)

Optimize this function to avoid iterating over all surfaces every time.

Global event_type_t

Global events are a security mess, when per-process namespaces stabilize we should consider if this could be done better.

Global exception_handler (interrupt_frame_t *frame)

Handle NMIs properly.

Struct filesystem_t

Add safety for if a module defining a filesystem is unloaded.

Global fread (void *_RESTRICT ptr, size_t size, size_t nmemb, FILE *_RESTRICT stream)

For better performance, read block-wise, not byte-wise.

Global fwrite (const void *_RESTRICT ptr, size_t size, size_t nmemb, FILE *_RESTRICT stream)

For better performance, write block-wise, not byte-wise.

Global interactive_handle_ansi (ansi_result_t *result)

Implement tab completion

Global ioring_ctx_complete (irp_t *irp, void *_ptr)

Handle overflow properly.

Global irq_virt_alloc (irq_virt_t *out, irq_phys_t phys, irq_flags_t flags, cpu_t *cpu)

CPU load balancing?

Module kernel_acpi_devices

Implement hotplugging support.

Module kernel_cpu_irq

Currently, this system is still simplistic. For example, it cant handle trees of IRQ chips, or multiple chips handling the same physical IRQs. This should be fixed in the future as needed.

Module kernel_io_irp

Write the IRP documentation.

Module kernel_io_ring

Decide if partial failures are a good idea or not.

Rewrite the Kernel-side I/O Ring Interface documentation to match the new system.

The I/O ring system is primarily a design document for now as it remains very work in progress and subject to change, currently being mostly unimplemented.

Module kernel_module

Currently module symbols and device types are cached in memory after the first load, for now this is fine. But in the future this cache could become very large so we might need a Linux-style cache file on disk or atleast a way to invalidate the cache.

Module kernel_sched_wait

Replace with a more optimized system for async stuff.

Module kernel_utils_map

Dynamically sized keys without heap allocation?

Module kernel_utils_rbtree

Cache minimum and maximum nodes for O(1) access.

Module kernel_vfs

Most of this is going to be removed when the new IRP system is fully implemented, but for now its usefull to keep it around during the refactor.

Struct keymap_entry_t

Implement keymap files.

Module libpatchwork_config

The current system is rather simplistic and in the future it might, if i can be bothered, be worth implementing a database like configuration system.

Module libstd_common_heap

Implement a slab allocator.

Module libstd_common_print

Implement floating point printing.

Module libstd_common_scan

Implement floating point scanning.

Module libstd_common_user_threading

Implement Thread Local Storage (TLS).

Write threading documentation.

Module libstd_setjmp

Add signal handling and 100 other things later.

Global main (void)

Use nonblocking sockets to avoid hanging on accept or read, or just wait until we have filesystem servers and do that instead.

Module module_drivers_ps2_mouse

Implement scrolling and buttons 4 and 5.

Global port_reserve (port_t *out, port_t minBase, port_t maxBase, uint64_t alignment, uint64_t length, const char *owner)

Find a way to store the owner of each reservation that does not use way to much memory, and isent super slow.

Module programs_boxd

Implement group and namespace specification for foreground boxes and the inherit profile.

Once filesystem servers are implemented the box deamon should use them instead of sockets.

Add a system for specifying environment variables.

Global rbtree_update_to_root (rbtree_t *tree, rbnode_t *node)

This could be optimized to avoid updating nodes multiple times for overlapping paths.

Global terminal_execute_ansi (terminal_t *term, element_t *elem, drawable_t *draw, ansi_sending_t *ansi)

Implement support for more advanced color stuff

Global vfs_stat (const pathname_t *pathname, stat_t *buffer, process_t *process)

Reimplement this after the async system.

Global vmm_tlb_shootdown (space_t *space, void *virtAddr, size_t pageAmount)

Currently this does a busy wait for acknowledgements. Use a wait queue?

Global WINDOW_RESIZABLE

Implement resize handles.