os-k-team/os-k
os-k-team
/
os-k
2
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

stuff

This commit is contained in:
Julian Barathieu 2019-05-07 23:16:56 +02:00
parent 241eeb64cb
commit 39e46a072f
18 changed files with 364 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Makefile
View File

@ -37,7 +37,7 @@ CCNAME=x86_64-elf-gcc
ASMFLAGS=-f elf64
LDFLAGS=-melf_x86_64
COPTIM=-O2
CWARNS=-Wall -Wextra -Werror=implicit-function-declaration
CWARNS=-Wall -Wextra -Wno-unused-parameter -Werror=implicit-function-declaration
CINCLUDES=-Iinclude
CFLAGS1=-nostdlib -ffreestanding -mcmodel=large -std=gnu11
CFLAGS2= -c -mno-red-zone -mno-mmx -mno-sse -mno-sse2
@ -74,19 +74,22 @@ NC='\033[1;37m'
## SOURCES INSCRIPTION-------------------------------------------------------- #
# Lib C sources
# Lib C sources + libbuf source
LibCSources = libc/atoi.c libc/itoa.c \
libc/mem.c libc/ctype.c \
libc/rand.c libc/sprintf.c \
libc/status.c libc/string.c \
libc/strtol.c extras/argv.c \
extras/prog.c
libbuf/bopen.c libbuf/bputc.c libbuf/bscroll.c \
libbuf/bprint.c libbuf/bgetc.c libbuf/bscan.c \
libbuf/bflush.c libbuf/bwrite.c libbuf/bread.c \
libbuf/bmisc.c libbuf/bclose.c \
extras/prog.c \
KernObj=$(patsubst %.c,$(KOBJDIR)/%.o,$(KernSources))
# Kernel sources
KernSources = libbuf/buf.c libbuf/bputc.c libbuf/bscroll.c \
libbuf/bprint.c kernel/cpu/cpuid.c \
KernSources = kernel/cpu/cpuid.c \
kernel/cpu/idt.c kernel/init/init.c \
kernel/init/table.c kernel/io/cursor.c \
kernel/ke/log.c kernel/io/vga.c \

6
ProjectTree
View File

@ -71,6 +71,7 @@
│   │   │   │   ├── cursor.o
│   │   │   │   ├── keyb.o
│   │   │   │   ├── rtc.o
│   │   │   │   ├── spkr.o
│   │   │   │   └── vga.o
│   │   │   ├── ke
│   │   │   │   ├── log.o
@ -129,6 +130,7 @@
│   │   ├── mm.h
│   │   ├── proc.h
│   │   ├── sched.h
│   │   ├── speaker.h
│   │   └── time.h
│   ├── kalbase.h
│   ├── kaleid.h
@ -153,6 +155,7 @@
│   │   │   ├── cursor.c
│   │   │   ├── keyb.c
│   │   │   ├── rtc.c
│   │   │   ├── spkr.c
│   │   │   └── vga.c
│   │   ├── ke
│   │   │   ├── log.c
@ -165,6 +168,7 @@
│   │   └── ps
│   │   └── sched.c
│   ├── libbuf
│   │   ├── bgetc.c
│   │   ├── bprint.c
│   │   ├── bputc.c
│   │   ├── bscroll.c
@ -188,4 +192,4 @@
├── ProjectTree
└── README.md
37 directories, 126 files
37 directories, 130 files

35
include/extras/buf.h
View File

@ -69,7 +69,7 @@ typedef struct Buffer_t Buffer_t;
// When a buffer is full, if the flusher doesn'tchange buf->wp and bputc()
// is called again, it will produce a EENDF error and set the BF_EOF flag
//
// Unless line buffering with auto-scrolldown enabled, nothing is
// Unless terminal buffering with auto-scrolldown enabled, nothing is
// removed from the buffer by the libbuf functions themselves, if you want
// the buffer to be emptied on flush then do that in the flusher
//
@ -115,8 +115,8 @@ void BDisableAutoScroll(Buffer_t *);
// 'source' is the internal buffer, if you want
// to give it yourself
//
// If *pbuf==NULL, malloc's the structure
// If source==NULL, malloc's the buffer
// If *pbuf==NULL, malloc's the structure (Ex's only)
// BCloseBuf() handles the de-allocations
//
error_t BCloseBuf(Buffer_t *);
@ -137,19 +137,36 @@ int BGetFlags(Buffer_t *);
int BGetState(Buffer_t *);
error_t BFlushBuf(Buffer_t *);
error_t BPutOnBuf(Buffer_t *, uchar);
error_t BPrintOnBuf(Buffer_t *, const char *fmt, ...);
error_t BPrintOnBufV(Buffer_t *, const char *fmt, va_list);
error_t BWriteOnBuf(Buffer_t *, uchar *, size_t); // TODO
error_t BPrintOnBuf(Buffer_t *, const char *, ...);
error_t BPrintOnBufV(Buffer_t *, const char *, va_list);
error_t BGetFromBuf(Buffer_t *, uchar *);
error_t BReadBuf(Buffer_t *, uchar *, size_t);
error_t BScanBuf(Buffer_t *, const char *, ...);
error_t BScanBufV(Buffer_t *, const char *, va_list);
void BLockBuf(Buffer_t *);
void BUnlockBuf(Buffer_t *);
bool BTrylockBuf(Buffer_t *);
// Internal, non-locking functions; don't use unless you
// have a good reason why
error_t bputc(Buffer_t *buf, uchar ch);
error_t bprintf(Buffer_t *buf, const char *fmt, ...);
error_t vbprintf(Buffer_t *buf, const char *fmt, va_list ap);
//
// Non-locking functions, also perform less checks
// Only use when not caring about locks, or between BLockBuf()/BUnlockBuf()
//
error_t bputc(Buffer_t *, uchar);
error_t bwrite(Buffer_t *, uchar *, size_t);
error_t bprintf(Buffer_t *, const char *, ...);
error_t vbprintf(Buffer_t *, const char *, va_list);
error_t bgetc(Buffer_t *, uchar *);
error_t bread(Buffer_t *, uchar *, size_t);
error_t bscanf(Buffer_t *, const char *, ...);
error_t vbscanf(Buffer_t *, const char *, va_list);
error_t bscrolldown(Buffer_t *buf);
#endif

4
include/kalext.h
View File

@ -26,13 +26,9 @@
#include <kalbase.h>
#endif
//------------------------------------------//
#ifndef _KALEXT_H
#define _KALEXT_H
//------------------------------------------//
// Extra headers //
//------------------------------------------//
#ifndef _KALEXTRAS_LOCKS_H

2
include/kernel/base.h
View File

@ -170,6 +170,8 @@ noreturn void KeStartPanic(const char *, ...);
#define BUG() XBUG('B')
#define BUGON(x) if(x)BUG()
//----------------------------------------------------------------------------//
#define __GET_GETRIP() \
__attribute__((__noinline__)) \
static ulong __getrip() \

6
include/kernel/iomisc.h
View File

@ -97,6 +97,12 @@ error_t IdtRegisterIsr(void (*isr)(ISRFrame_t *regs), uchar isrNo);
static inline void IoWriteByteOnPort(port_t port, uchar val)
{ asm volatile ("outb %1, %0" : : "dN" (port), "a" (val)); }
static inline void IoWriteWordOnPort(port_t port, ushort val)
{ asm volatile ("outw %1, %0" : : "dN" (port), "a" (val)); }
static inline void IoWriteDWordOnPort(port_t port, uint val)
{ asm volatile ("outl %1, %0" : : "dN" (port), "a" (val)); }
static inline uchar IoReadByteFromPort(port_t port) {
uchar ret;
asm volatile ("inb %1, %0" : "=a"(ret) : "Nd"(port));

1
kaleid/kernel/io/keyb.c
View File

@ -31,6 +31,7 @@ char ScanCodes[100] = { 0 };
void KeybPrint(char code)
{
if (code) {
bputc(BStdIn, ScanCodes[(int)code]);
bputc(BStdOut, ScanCodes[(int)code]);
//bprintf(BStdOut, "%x ", code);
BStdOut->flusher(BStdOut);

3
kaleid/kernel/mm/malloc.c
View File

@ -45,6 +45,9 @@ error_t KalAllocMemoryEx(void **ptr, size_t req, int flags, size_t align)
brk = (size_t)_heap_start + MmGetHeapSize();
req = _ALIGN_UP(req + brk, align) - brk;
//DebugLog("MALLOC: start=%p, size=%lx, brk=%p, req=%lx\n",
// _heap_start, MmGetHeapSize(), brk, req);
rc = MmGrowHeap(req);

55
kaleid/libbuf/bclose.c Normal file
View File

@ -0,0 +1,55 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Buffer library //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <extras/buf.h>
#include <extras/locks.h>
//
// Closes a buffer, not flushing unless the proper flag is set
//
error_t BCloseBuf(Buffer_t *buf)
{
assert(buf && buf->initDone == INITOK);
ExAcquireLock(&buf->lock);
if (buf->flags & BF_FONCLOSE) {
BFlushBuf(buf);
}
if (buf->flags & BF_SALLOC && buf->buf) {
free(buf->buf);
}
buf->buf = buf->rp = buf->wp = NULL;
buf->initDone = buf->flags = buf->state = buf->size = 0;
ExReleaseLock(&buf->lock);
if (buf->flags & BF_BALLOC) {
free(buf);
}
return EOK;
}

51
kaleid/libbuf/bflush.c Normal file
View File

@ -0,0 +1,51 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Buffer library //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <extras/buf.h>
#include <extras/locks.h>
//
// Flushes a buffer, returns EBADF when not possible
//
error_t BFlushBuf(Buffer_t *buf)
{
error_t rc;
assert(buf && buf->initDone == INITOK);
if (!buf) return EINVAL;
if (buf->flags & (BF_EOF|BF_ERR)) {
return EENDF;
}
if (!buf->flusher) {
return EBADF;
}
ExAcquireLock(&buf->lock);
rc = buf->flusher(buf);
ExReleaseLock(&buf->lock);
return rc;
}

52
kaleid/libbuf/bgetc.c
View File

@ -0,0 +1,52 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Buffer library //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <extras/buf.h>
#include <extras/locks.h>
error_t BGetFromBuf(Buffer_t *buf, uchar *ch)
{
error_t rc;
assert(buf && buf->initDone == INITOK);
if (!buf) return EINVAL;
if (buf->state != BS_RDWR && buf->state != BS_RDONLY) {
return EBADF;
}
ExAcquireLock(&buf->lock);
rc = bgetc(buf, ch);
ExReleaseLock(&buf->lock);
return rc;
}
error_t bgetc(Buffer_t *buf, uchar *ch)
{
error_t rc = EOK;
if (buf->flags & (BF_EOF|BF_ERR)) return EENDF;
return EOK;
}

52
kaleid/libbuf/bmisc.c Normal file
View File

@ -0,0 +1,52 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Buffer library //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <extras/buf.h>
#include <extras/locks.h>
// Straightforward functions
int BGetFlags(Buffer_t *buf) { return buf->flags; }
int BGetState(Buffer_t *buf) { return buf->state; }
void BEnableLineBuffering(Buffer_t *buf)
{
assert(buf && !(buf->flags & BF_TERM));
buf->flags |= BF_LINE;
}
void BDisaleLineBuffering(Buffer_t *buf)
{
assert(buf && !(buf->flags & BF_TERM));
buf->flags &= ~BF_LINE;
}
void BLockBuf(Buffer_t *buf)
{
assert(buf && buf->initDone == INITOK);
ExAcquireLock(&buf->lock);
}
void BUnlockBuf(Buffer_t *buf) { ExReleaseLock(&buf->lock); }
bool BTrylockBuf(Buffer_t *buf) { return ExAttemptLock(&buf->lock); }

87
kaleid/libbuf/buf.c → kaleid/libbuf/bopen.c
View File

@ -26,68 +26,18 @@
#include <extras/locks.h>
#include <extras/malloc.h>
#include <kernel/base.h>
Buffer_t *BStdIn, *BStdOut, *BStdDbg;
// Straightforward functions
int BGetFlags(Buffer_t *buf) { return buf->flags; }
int BGetState(Buffer_t *buf) { return buf->state; }
void BEnableLineBuffering(Buffer_t *buf)
{
assert(buf && !(buf->flags & BF_TERM));
buf->flags |= BF_LINE;
}
void BDisaleLineBuffering(Buffer_t *buf)
{
assert(buf && !(buf->flags & BF_TERM));
buf->flags &= ~BF_LINE;
}
void BLockBuf(Buffer_t *buf)
{
assert(buf && buf->initDone == INITOK);
ExAcquireLock(&buf->lock);
}
void BUnlockBuf(Buffer_t *buf) { ExReleaseLock(&buf->lock); }
bool BTrylockBuf(Buffer_t *buf) { return ExAttemptLock(&buf->lock); }
//
// Closes a buffer, not flushing unless the proper flag is set
//
error_t BCloseBuf(Buffer_t *buf)
{
assert(buf && buf->initDone == INITOK);
ExAcquireLock(&buf->lock);
if (buf->flags & BF_FONCLOSE) {
BFlushBuf(buf);
}
if (buf->flags & BF_SALLOC && buf->buf) {
KalFreeMemory(buf->buf);
}
buf->buf = buf->rp = buf->wp = NULL;
buf->initDone = buf->flags = buf->state = buf->size = 0;
ExReleaseLock(&buf->lock);
if (buf->flags & BF_BALLOC) {
KalFreeMemory(buf);
}
return EOK;
}
//
// Creates an actual buffer
//
error_t BOpenPureBuf(Buffer_t **pbuf, int mode, size_t size)
{
if (*pbuf != NULL) {
assert(0);
return EINVAL;
}
return BOpenPureBufEx(pbuf, NULL, mode, size, NULL);
}
@ -145,6 +95,10 @@ error_t BOpenPureBufEx(Buffer_t **pbuf, char *source, int mode, size_t size,
error_t BOpenTermBuf(Buffer_t **pbuf, int mode,
int lineLen, int nLines, int pbCount)
{
if (*pbuf != NULL) {
assert(0);
return EINVAL;
}
return BOpenTermBufEx(pbuf, NULL, mode, lineLen, nLines, pbCount, NULL);
}
@ -168,26 +122,3 @@ error_t BOpenTermBufEx(Buffer_t **pbuf, char *source, int mode,
return rc;
}
//
// Flushes a buffer, returns EBADF when not possible
//
error_t BFlushBuf(Buffer_t *buf)
{
error_t rc;
assert(buf && buf->initDone == INITOK);
if (!buf) return EINVAL;
if (buf->flags & (BF_EOF|BF_ERR)) {
return EENDF;
}
if (!buf->flusher) {
return EBADF;
}
ExAcquireLock(&buf->lock);
rc = buf->flusher(buf);
ExReleaseLock(&buf->lock);
return rc;
}

39
kaleid/libbuf/bread.c Normal file
View File

@ -0,0 +1,39 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Buffer library //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <extras/buf.h>
#include <extras/locks.h>
error_t BReadBuf(Buffer_t *buf, uchar *out, size_t n)
{
error_t rc;
}
error_t bread(Buffer_t *buf, uchar * out, size_t n)
{
}

27
kaleid/libbuf/bscan.c Normal file
View File

@ -0,0 +1,27 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Buffer library //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <extras/buf.h>
#include <extras/locks.h>

27
kaleid/libbuf/bwrite.c Normal file
View File

@ -0,0 +1,27 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Buffer library //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <extras/buf.h>
#include <extras/locks.h>

2
kaleid/libc/mem.c
View File

@ -25,8 +25,6 @@
#include <kalbase.h>
#include <extras/malloc.h>
#include<kernel/heap.h>
/* DO NOT compile with strict aliasing on */
//------------------------------------------//

4
kaleid/libc/sprintf.c
View File

@ -75,12 +75,11 @@ size_t snprintf(char *str, size_t n, const char *fmt, ...)
return ret;
}
__GET_GETRIP();
size_t vsnprintf(char *str, size_t n, const char *fmt, va_list ap)
{
size_t ret;
error_t rc;
Buffer_t *buf;
Buffer_t *buf = NULL;
assert(str && fmt);
@ -110,7 +109,6 @@ size_t vsnprintf(char *str, size_t n, const char *fmt, va_list ap)
str[ret++] = 0;
assert(ret <= n);
//109e38 101c63
BCloseBuf(buf);
return ret;