wash/magenta
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

kernel: remove unused functionality

Browse Source
This commit is contained in:
max 🍓
2026-03-29 14:47:07 +01:00
parent 325699d64a
commit 8b41f5e681
10 changed files with 0 additions and 510 deletions
Download Patch File Download Diff File Expand all files Collapse all files
arch/x86_64/acpi/local_apic.cpp
View File
ds/ringbuffer.c
-189
View File
@@ -1,189 +0,0 @@
#include <kernel/ringbuffer.h>
#include <kernel/sched.h>
#include <kernel/vm.h>
size_t ringbuffer_unread(struct ringbuffer *ring_buffer)
{
if (ring_buffer->r_read_ptr == ring_buffer->r_write_ptr) {
return 0;
}
if (ring_buffer->r_read_ptr > ring_buffer->r_write_ptr) {
return (ring_buffer->r_size - ring_buffer->r_read_ptr)
+ ring_buffer->r_write_ptr;
} else {
return (ring_buffer->r_write_ptr - ring_buffer->r_read_ptr);
}
}
size_t ringbuffer_avail(struct ringbuffer *ring_buffer)
{
if (ring_buffer->r_read_ptr == ring_buffer->r_write_ptr) {
return ring_buffer->r_size - 1;
}
if (ring_buffer->r_read_ptr > ring_buffer->r_write_ptr) {
return ring_buffer->r_read_ptr - ring_buffer->r_write_ptr - 1;
} else {
return (ring_buffer->r_size - ring_buffer->r_write_ptr)
+ ring_buffer->r_read_ptr - 1;
}
}
static inline void increment_read(struct ringbuffer *ring_buffer)
{
ring_buffer->r_read_ptr++;
if (ring_buffer->r_read_ptr == ring_buffer->r_size) {
ring_buffer->r_read_ptr = 0;
}
}
static inline void increment_write(struct ringbuffer *ring_buffer)
{
ring_buffer->r_write_ptr++;
if (ring_buffer->r_write_ptr == ring_buffer->r_size) {
ring_buffer->r_write_ptr = 0;
}
}
size_t ringbuffer_read(
struct ringbuffer *ring_buffer,
size_t size,
void *p,
mango_flags_t flags)
{
if (!ring_buffer) {
return 0;
}
unsigned char *buffer = p;
unsigned long lock_flags;
size_t collected = 0;
while (collected < size) {
spin_lock_irqsave(&ring_buffer->r_lock, &lock_flags);
while (ringbuffer_unread(ring_buffer) > 0 && collected < size) {
buffer[collected]
= ring_buffer
->r_buffer[ring_buffer->r_read_ptr];
increment_read(ring_buffer);
collected++;
}
wakeup_queue(&ring_buffer->r_wait_writers);
if (flags & S_NOBLOCK) {
spin_unlock_irqrestore(
&ring_buffer->r_lock,
lock_flags);
break;
}
struct wait_item waiter;
wait_item_init(&waiter, current_thread());
thread_wait_begin(&waiter, &ring_buffer->r_wait_readers);
spin_unlock_irqrestore(&ring_buffer->r_lock, lock_flags);
if (collected < size) {
schedule(SCHED_NORMAL);
}
thread_wait_end(&waiter, &ring_buffer->r_wait_readers);
}
wakeup_queue(&ring_buffer->r_wait_writers);
return collected;
}
size_t ringbuffer_write(
struct ringbuffer *ring_buffer,
size_t size,
const void *p,
mango_flags_t flags)
{
if (!ring_buffer || !size) {
return 0;
}
const unsigned char *buffer = p;
unsigned long lock_flags;
size_t written = 0;
while (written < size) {
spin_lock_irqsave(&ring_buffer->r_lock, &lock_flags);
while (ringbuffer_avail(ring_buffer) > 0 && written < size) {
ring_buffer->r_buffer[ring_buffer->r_write_ptr]
= buffer[written];
increment_write(ring_buffer);
written++;
}
wakeup_queue(&ring_buffer->r_wait_readers);
if (flags & S_NOBLOCK) {
spin_unlock_irqrestore(
&ring_buffer->r_lock,
lock_flags);
break;
}
struct wait_item waiter;
wait_item_init(&waiter, current_thread());
thread_wait_begin(&waiter, &ring_buffer->r_wait_writers);
spin_unlock_irqrestore(&ring_buffer->r_lock, lock_flags);
if (written < size) {
schedule(SCHED_NORMAL);
}
thread_wait_end(&waiter, &ring_buffer->r_wait_writers);
}
wakeup_queue(&ring_buffer->r_wait_readers);
return written;
}
struct ringbuffer *ringbuffer_create(size_t size)
{
struct ringbuffer *out = kzalloc(sizeof(struct ringbuffer), VM_NORMAL);
if (!out) {
return NULL;
}
if (ringbuffer_init(out, size) != KERN_OK) {
kfree(out);
return NULL;
}
return out;
}
void ringbuffer_destroy(struct ringbuffer *ring_buffer)
{
ringbuffer_deinit(ring_buffer);
kfree(ring_buffer);
}
kern_status_t ringbuffer_init(struct ringbuffer *buf, size_t size)
{
buf->r_buffer = kmalloc(size, VM_NORMAL);
if (!buf->r_buffer) {
return KERN_NO_MEMORY;
}
buf->r_write_ptr = 0;
buf->r_read_ptr = 0;
buf->r_size = size;
buf->r_lock = SPIN_LOCK_INIT;
return KERN_OK;
}
kern_status_t ringbuffer_deinit(struct ringbuffer *buf)
{
kfree(buf->r_buffer);
buf->r_buffer = NULL;
return KERN_OK;
}
include/kernel/fb.h
-49
View File
@@ -1,49 +0,0 @@
#ifndef KERNEL_FB_H_
#define KERNEL_FB_H_
#include <stdint.h>
enum framebuffer_flags {
FB_MODE_RGB = 0x01u,
FB_MODE_VGATEXT = 0x02u,
FB_MODE_PALETTE = 0x04u,
};
struct framebuffer_bitfield {
uint32_t b_offset;
uint16_t b_length;
};
struct framebuffer_varinfo {
enum framebuffer_flags fb_flags;
uint32_t fb_xres;
uint32_t fb_yres;
uint32_t fb_bpp;
uint32_t fb_stride;
union {
struct {
uint32_t fb_xcells;
uint32_t fb_ycells;
};
struct {
struct framebuffer_bitfield fb_red;
struct framebuffer_bitfield fb_green;
struct framebuffer_bitfield fb_blue;
struct framebuffer_bitfield fb_alpha;
};
struct {
uintptr_t fb_palette_addr;
uint16_t fb_palette_nr_colours;
};
};
};
struct framebuffer_fixedinfo {
uint64_t fb_baseptr;
};
#endif
include/kernel/flags.h
-11
View File
@@ -1,11 +0,0 @@
#ifndef KERNEL_FLAGS_H_
#define KERNEL_FLAGS_H_
#include <stdint.h>
typedef enum {
S_NORMAL = 0x00u,
S_NOBLOCK = 0x01u,
} mango_flags_t;
#endif
include/kernel/input.h
-184
View File
@@ -1,184 +0,0 @@
#ifndef KERNEL_INPUT_H_
#define KERNEL_INPUT_H_
#include <stdint.h>
#include <kernel/queue.h>
#include <mango/status.h>
enum input_event_hook_flags {
INPUT_HOOK_SQUASH_EVENT = 0x01u,
};
struct device;
enum input_event_type {
INPUT_TYPE_UNKNOWN = 0x00u,
INPUT_TYPE_KEY = 0x01u,
INPUT_TYPE_MOTION = 0x02u,
};
enum input_event_motion_type {
INPUT_MOTION_TYPE_MOUSE = 0x01u,
INPUT_MOTION_TYPE_SCROLL = 0x02u,
};
enum input_keycode {
KEY_UNKNOWN = 0x00u,
KEY_A = 0x01u,
KEY_B = 0x02u,
KEY_C = 0x03u,
KEY_D = 0x04u,
KEY_E = 0x05u,
KEY_F = 0x06u,
KEY_G = 0x07u,
KEY_H = 0x08u,
KEY_I = 0x09u,
KEY_J = 0x0Au,
KEY_K = 0x0Bu,
KEY_L = 0x0Cu,
KEY_M = 0x0Du,
KEY_N = 0x0Eu,
KEY_O = 0x0Fu,
KEY_P = 0x10u,
KEY_Q = 0x11u,
KEY_R = 0x12u,
KEY_S = 0x13u,
KEY_T = 0x14u,
KEY_U = 0x15u,
KEY_V = 0x16u,
KEY_W = 0x17u,
KEY_X = 0x18u,
KEY_Y = 0x19u,
KEY_Z = 0x1Au,
KEY_KEY_1 = 0x1Bu,
KEY_KEY_2 = 0x1Cu,
KEY_KEY_3 = 0x1Du,
KEY_KEY_4 = 0x1Eu,
KEY_KEY_5 = 0x1Fu,
KEY_KEY_6 = 0x20u,
KEY_KEY_7 = 0x21u,
KEY_KEY_8 = 0x22u,
KEY_KEY_9 = 0x23u,
KEY_KEY_0 = 0x24u,
KEY_ENTER = 0x25u,
KEY_ESCAPE = 0x26u,
KEY_BACKSPACE = 0x27u,
KEY_TAB = 0x28u,
KEY_SPACE = 0x29u,
KEY_MINUS = 0x2Au,
KEY_EQUALS = 0x2Bu,
KEY_LEFT_BRACE = 0x2Cu,
KEY_RIGHT_BRACE = 0x2Du,
KEY_BACKSLASH = 0x2Eu,
KEY_NON_US_HASH = 0x2Fu,
KEY_SEMICOLON = 0x30u,
KEY_APOSTROPHE = 0x31u,
KEY_GRAVE_ACCENT = 0x32u,
KEY_COMMA = 0x33u,
KEY_DOT = 0x34u,
KEY_SLASH = 0x35u,
KEY_CAPS_LOCK = 0x36u,
KEY_F1 = 0x37u,
KEY_F2 = 0x38u,
KEY_F3 = 0x39u,
KEY_F4 = 0x3Au,
KEY_F5 = 0x3Bu,
KEY_F6 = 0x3Cu,
KEY_F7 = 0x3Du,
KEY_F8 = 0x3Eu,
KEY_F9 = 0x3Fu,
KEY_F10 = 0x40u,
KEY_F11 = 0x41u,
KEY_F12 = 0x42u,
KEY_PRINT_SCREEN = 0x43u,
KEY_SCROLL_LOCK = 0x44u,
KEY_PAUSE = 0x45u,
KEY_INSERT = 0x46u,
KEY_HOME = 0x47u,
KEY_PAGE_UP = 0x48u,
KEY_DELETE = 0x49u,
KEY_END = 0x4Au,
KEY_PAGE_DOWN = 0x4Bu,
KEY_RIGHT = 0x4Cu,
KEY_LEFT = 0x4Du,
KEY_DOWN = 0x4Eu,
KEY_UP = 0x4Fu,
KEY_NUM_LOCK = 0x50u,
KEY_KEYPAD_SLASH = 0x51u,
KEY_KEYPAD_ASTERISK = 0x52u,
KEY_KEYPAD_MINUS = 0x53u,
KEY_KEYPAD_PLUS = 0x54u,
KEY_KEYPAD_ENTER = 0x55u,
KEY_KEYPAD_1 = 0x56u,
KEY_KEYPAD_2 = 0x57u,
KEY_KEYPAD_3 = 0x58u,
KEY_KEYPAD_4 = 0x59u,
KEY_KEYPAD_5 = 0x5Au,
KEY_KEYPAD_6 = 0x5Bu,
KEY_KEYPAD_7 = 0x5Cu,
KEY_KEYPAD_8 = 0x5Du,
KEY_KEYPAD_9 = 0x5Eu,
KEY_KEYPAD_0 = 0x5Fu,
KEY_KEYPAD_DOT = 0x60u,
KEY_NON_US_BACKSLASH = 0x61u,
KEY_KEYPAD_EQUALS = 0x62u,
KEY_MENU = 0x63u,
KEY_LEFT_CTRL = 0x64u,
KEY_LEFT_SHIFT = 0x65u,
KEY_LEFT_ALT = 0x66u,
KEY_LEFT_META = 0x67u,
KEY_RIGHT_CTRL = 0x68u,
KEY_RIGHT_SHIFT = 0x69u,
KEY_RIGHT_ALT = 0x6Au,
KEY_RIGHT_META = 0x6Bu,
KEY_MEDIA_MUTE = 0x6Cu,
KEY_MEDIA_VOLUME_INCREMENT = 0x6Du,
KEY_MEDIA_VOLUME_DECREMENT = 0x6Eu,
};
enum input_key_state {
INPUT_KEYSTATE_DOWN = 0x00u,
INPUT_KEYSTATE_UP = 0x01u,
};
enum input_button {
INPUT_BUTTON_MOUSE_LEFT = 0x00u,
INPUT_BUTTON_MOUSE_MIDDLE = 0x01u,
INPUT_BUTTON_MOUSE_RIGHT = 0x02u,
INPUT_BUTTON_MOUSE_BACK = 0x03u,
INPUT_BUTTON_MOUSE_FORWARD = 0x04u,
};
enum input_button_state {
INPUT_BUTTON_DOWN = 0x00u,
INPUT_BUTTON_UP = 0x01u,
};
struct input_event {
enum input_event_type ev_type;
union {
struct {
enum input_event_motion_type type;
int16_t movement_x;
int16_t movement_y;
} ev_motion;
struct {
enum input_button button;
enum input_button_state state;
} ev_button;
struct {
enum input_keycode key;
enum input_key_state state;
} ev_key;
};
};
struct input_event_hook {
void(*hook_callback)(struct device *, struct input_event *, enum input_event_hook_flags *, void *);
void *hook_arg;
struct queue_entry hook_head;
};
#endif
include/kernel/object.h
-1
View File
@@ -2,7 +2,6 @@
#define KERNEL_OBJECT_H_
#include <kernel/atomic.h>
#include <kernel/flags.h>
#include <kernel/locks.h>
#include <kernel/vm.h>
#include <kernel/wait.h>
include/kernel/ringbuffer.h
-45
View File
@@ -1,45 +0,0 @@
#ifndef KERNEL_RINGBUFFER_H_
#define KERNEL_RINGBUFFER_H_
#include <kernel/flags.h>
#include <kernel/locks.h>
#include <kernel/types.h>
#include <kernel/wait.h>
struct ringbuffer {
unsigned char *r_buffer;
size_t r_write_ptr;
size_t r_read_ptr;
size_t r_size;
spin_lock_t r_lock;
struct waitqueue r_wait_readers;
struct waitqueue r_wait_writers;
};
extern struct ringbuffer *ringbuffer_create(size_t size);
extern void ringbuffer_destroy(struct ringbuffer *buf);
extern kern_status_t ringbuffer_init(struct ringbuffer *buf, size_t size);
extern kern_status_t ringbuffer_deinit(struct ringbuffer *buf);
extern size_t ringbuffer_unread(struct ringbuffer *buf);
extern size_t ringbuffer_avail(struct ringbuffer *buf);
extern size_t ringbuffer_read(
struct ringbuffer *buf,
size_t size,
void *buffer,
mango_flags_t flags);
extern size_t ringbuffer_write(
struct ringbuffer *buf,
size_t size,
const void *buffer,
mango_flags_t flags);
/* TODO */
// extern size_t ringbuffer_peek(struct ringbuffer *buf, size_t at, size_t size,
// void *buffer); extern size_t ringbuffer_skip(struct ringbuffer *buf, size_t
// count);
extern int ringbuffer_write_would_block(struct ringbuffer *buf);
#endif
include/kernel/test.h
-14
View File
@@ -1,14 +0,0 @@
#ifndef KERNEL_TEST_H_
#define KERNEL_TEST_H_
#ifdef __cplusplus
extern "C" {
#endif
extern int run_all_tests(void);
#ifdef __cplusplus
}
#endif
#endif
include/kernel/vm.h
-15
View File
@@ -14,8 +14,6 @@
extern "C" {
#endif
struct bcache;
/* maximum number of NUMA nodes */
#define VM_MAX_NODES 64
/* maximum number of memory zones per node */
@@ -25,11 +23,6 @@ struct bcache;
/* maximum number of sparse memory sectors */
#define VM_MAX_SECTORS 8192
/* maximum number of disk sectors that can be stored in a single
page. AKA the number of bits in the sector bitmap.
used by the block cache */
#define VM_MAX_SECTORS_PER_PAGE 32
#define VM_CHECK_ALIGN(p, mask) ((((p) & (mask)) == (p)) ? 1 : 0)
#define VM_CACHE_INITIALISED(c) ((c)->c_obj_count != 0)
@@ -207,7 +200,6 @@ struct vm_page {
/* owner-specific pointer */
union {
struct vm_slab *p_slab;
struct bcache *p_bcache;
void *p_priv0;
};
@@ -218,8 +210,6 @@ struct vm_page {
lists.
- vm_object uses it to maintain a btree of allocated pages keyed
by offset/size.
- the block cache uses this to maintain a tree of pages keyed by
block number.
*/
union {
struct queue_entry p_list;
@@ -231,15 +221,10 @@ struct vm_page {
};
union {
/* used by bcache when sector size is < page size. bitmap of
* present/missing sectors */
DECLARE_BITMAP(p_blockbits, VM_MAX_SECTORS_PER_PAGE);
uint32_t p_priv2;
};
union {
/* sector address, used by bcache */
sectors_t p_blockid;
/* offset of this page within the vm_object it is a part of */
off_t p_vmo_offset;
init/main.c
-2
View File
@@ -5,7 +5,6 @@
#include <kernel/cpu.h>
#include <kernel/handle.h>
#include <kernel/init.h>
#include <kernel/input.h>
#include <kernel/libc/stdio.h>
#include <kernel/machine/init.h>
#include <kernel/object.h>
@@ -14,7 +13,6 @@
#include <kernel/printk.h>
#include <kernel/sched.h>
#include <kernel/task.h>
#include <kernel/test.h>
#include <kernel/thread.h>
#include <kernel/vm-object.h>
#include <stdint.h>