kamkow1/mop3
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use clang-format

Browse Source
This commit is contained in:
Kamil Kowalczyk
2025-12-21 22:53:25 +01:00
parent 8794a61073
commit b2d8294b12
36 changed files with 925 additions and 842 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
kernel/libk/align.h
View File

@@ -2,7 +2,7 @@
#define _KERNEL_LIBK_ALIGN_H
#define div_align_up(x, div) (((x) + (div) - 1) / (div))
#define align_down(x, a) ((x) & ~((a) - 1))
#define align_up(x, a) (((x) + ((a) - 1)) & ~((a) - 1))
#define align_down(x, a) ((x) & ~((a) - 1))
#define align_up(x, a) (((x) + ((a) - 1)) & ~((a) - 1))
#endif // _KERNEL_LIBK_ALIGN_H

34
kernel/libk/bm.c
View File

@@ -1,74 +1,74 @@
#include <libk/std.h>
#include <libk/bm.h>
#include <libk/std.h>
#include <libk/string.h>
void bm_init(struct bm *bm, uint8_t *base, size_t nbits) {
void bm_init (struct bm* bm, uint8_t* base, size_t nbits) {
bm->base = base;
bm->nbits = nbits;
memset(bm->base, 0, (nbits + 7) / 8);
memset (bm->base, 0, (nbits + 7) / 8);
}
/*
* Set a bit in a bitmap.
*/
void bm_set(struct bm *bm, size_t k) {
void bm_set (struct bm* bm, size_t k) {
if (k >= bm->nbits)
return;
uint8_t *b = (uint8_t *)((uintptr_t)bm->base + (k / 8));
uint8_t* b = (uint8_t*)((uintptr_t)bm->base + (k / 8));
*b = ((*b) | (1 << (k % 8)));
}
/*
* Clear a bit in a bitmap.
*/
void bm_clear(struct bm *bm, size_t k) {
void bm_clear (struct bm* bm, size_t k) {
if (k >= bm->nbits)
return;
uint8_t *b = (uint8_t *)((uintptr_t)bm->base + (k / 8));
uint8_t* b = (uint8_t*)((uintptr_t)bm->base + (k / 8));
*b = ((*b) & ~(1 << (k % 8)));
}
/*
* Test (true/false) a bit in a bitmap.
*/
bool bm_test(struct bm *bm, size_t k) {
bool bm_test (struct bm* bm, size_t k) {
if (k >= bm->nbits)
return false;
uint8_t *b = (uint8_t *)((uintptr_t)bm->base + (k / 8));
uint8_t* b = (uint8_t*)((uintptr_t)bm->base + (k / 8));
return (*b) & (1 << (k % 8));
}
/*
* Set a range of bits in a bitmap. if starting bit is out of range, we fail.
*/
bool bm_set_region(struct bm *bm, size_t k, size_t m) {
bool bm_set_region (struct bm* bm, size_t k, size_t m) {
if ((k >= m) || (k >= bm->nbits) || (k + m >= bm->nbits))
return false;
for (size_t i = k; i < m; i++) {
bool taken = bm_test(bm, i);
bool taken = bm_test (bm, i);
if (taken)
return false;
}
for (size_t i = k; i < m; i++)
bm_set(bm, i);
bm_set (bm, i);
return true;
}
/*
* Clear a range of bits in a bitmap. starting bit must be in range.
*/
void bm_clear_region(struct bm *bm, size_t k, size_t m) {
void bm_clear_region (struct bm* bm, size_t k, size_t m) {
if ((k >= m) || (k >= bm->nbits) || (k + m >= bm->nbits))
return;
for (size_t i = k; i < m; i++)
bm_clear(bm, i);
bm_clear (bm, i);
}
/*
@@ -77,12 +77,12 @@ void bm_clear_region(struct bm *bm, size_t k, size_t m) {
* are out of range, act as if the bits are set / bitmap is full - this is
* useful for implementing the physical memory manager algorithm.
*/
bool bm_test_region(struct bm *bm, size_t k, size_t m) {
bool bm_test_region (struct bm* bm, size_t k, size_t m) {
if ((k >= m) || (k >= bm->nbits) || (k + m >= bm->nbits))
return true;
for (size_t i = k; i < m; i++) {
bool test = bm_test(bm, i);
bool test = bm_test (bm, i);
if (test)
return true;
}

16
kernel/libk/bm.h
View File

@@ -4,16 +4,16 @@
#include <libk/std.h>
struct bm {
uint8_t *base;
uint8_t* base;
size_t nbits;
};
void bm_init(struct bm *bm, uint8_t *base, size_t nbits);
void bm_set(struct bm *bm, size_t k);
bool bm_set_region(struct bm *bm, size_t k, size_t m);
void bm_clear(struct bm *bm, size_t k);
void bm_clear_region(struct bm *bm, size_t k, size_t m);
bool bm_test(struct bm *bm, size_t k);
bool bm_test_region(struct bm *bm, size_t k, size_t m);
void bm_init (struct bm* bm, uint8_t* base, size_t nbits);
void bm_set (struct bm* bm, size_t k);
bool bm_set_region (struct bm* bm, size_t k, size_t m);
void bm_clear (struct bm* bm, size_t k);
void bm_clear_region (struct bm* bm, size_t k, size_t m);
bool bm_test (struct bm* bm, size_t k);
bool bm_test_region (struct bm* bm, size_t k, size_t m);
#endif // _KERNEL_LIBK_BM_H

3
kernel/libk/putchar_.c
View File

@@ -1,3 +1,2 @@
void putchar_(char x) { (void)x; }
void putchar_ (char x) { (void)x; }

2
kernel/libk/std.h
View File

@@ -4,10 +4,10 @@
#include <limits.h>
#include <stdalign.h>
#include <stdarg.h>
#include <stdatomic.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdnoreturn.h>
#include <stdatomic.h>
#endif // _KERNEL_LIBK_STD_H

30
kernel/libk/string.c
View File

@@ -1,17 +1,17 @@
#include <libk/std.h>
#include <libk/string.h>
size_t memset(void *dst, uint8_t b, size_t n) {
uint8_t *dst1 = dst;
size_t memset (void* dst, uint8_t b, size_t n) {
uint8_t* dst1 = dst;
size_t i;
for (i = 0; i < n; i++)
dst1[i] = b;
return i;
}
size_t memcpy(void *dst, const void *src, size_t n) {
uint8_t *dst1 = dst;
const uint8_t *src1 = src;
size_t memcpy (void* dst, const void* src, size_t n) {
uint8_t* dst1 = dst;
const uint8_t* src1 = src;
size_t i;
for (i = 0; i < n; i++)
dst1[i] = src1[i];
@@ -19,20 +19,22 @@ size_t memcpy(void *dst, const void *src, size_t n) {
}
// SOURCE: https://stackoverflow.com/a/48967408
void strncpy(char* dst, const char* src, size_t n) {
size_t i = 0;
while(i++ != n && (*dst++ = *src++));
void strncpy (char* dst, const char* src, size_t n) {
size_t i = 0;
while (i++ != n && (*dst++ = *src++))
;
}
size_t strlen(const char *str) {
const char *s;
for (s = str; *s; ++s);
size_t strlen (const char* str) {
const char* s;
for (s = str; *s; ++s)
;
return (s - str);
}
int memcmp(const void *s1, const void *s2, size_t n) {
unsigned char *p = (unsigned char *)s1;
unsigned char *q = (unsigned char *)s2;
int memcmp (const void* s1, const void* s2, size_t n) {
unsigned char* p = (unsigned char*)s1;
unsigned char* q = (unsigned char*)s2;
while (n--) {
if (*p != *q) {

10
kernel/libk/string.h
View File

@@ -1,10 +1,10 @@
#ifndef _KERNEL_LIBK_STRING_H
#define _KERNEL_LIBK_STRING_H
size_t memset(void *dst, uint8_t b, size_t n);
size_t memcpy(void *dst, const void *src, size_t n);
void strncpy(char* dst, const char* src, size_t n);
size_t strlen(const char *str);
int memcmp(const void *s1, const void *s2, size_t n);
size_t memset (void* dst, uint8_t b, size_t n);
size_t memcpy (void* dst, const void* src, size_t n);
void strncpy (char* dst, const char* src, size_t n);
size_t strlen (const char* str);
int memcmp (const void* s1, const void* s2, size_t n);
#endif // _KERNEL_LIBK_STRING_H