slococo-uni
/
bottleros
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reformat code 

Co-authored-by: Ezequiel Bellver <ebellver@itba.edu.ar>
Co-authored-by: Juan Barmasch <jbarmasch@itba.edu.ar>
This commit is contained in:
Santiago Lo Coco 2021-10-31 23:18:54 -03:00
parent a56f7b5e31
commit 8838beda5e
52 changed files with 1348 additions and 1669 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -5,6 +5,7 @@
index.html
.bashrc
.vscode/*
.idea/
#Binary Files
*.bin

2
Kernel/Makefile
View File

@ -32,7 +32,7 @@ $(KERNEL_ELF): $(STATICLIBS) $(ALL_OBJECTS)
$(LD) $(LDFLAGS) -T kernel.ld --oformat=elf64-x86-64 -o $@ $^
%.o: %.c
$(GCC) $(GCCFLAGS) -I./include -I./drivers -I./interruptions -I./utils -I./tests $(MFLAG) -c $< -o $@
$(GCC) $(GCCFLAGS) -I./include -I./drivers/include -I./interruptions/include -I./utils/include -I./tests/include $(MFLAG) -c $< -o $@
%.o : %.asm
$(ASM) $(ASMFLAGS) $< -o $@

4
Kernel/include/keyboard.h → Kernel/drivers/include/keyboard.h
View File

@ -2,7 +2,9 @@
#define KEYBOARD_H
#include <stdint.h>
#include "schedulerLib.h"
#include "../../utils/include/schedulerLib.h"
#define SIZE 1
void keyboard_handler();
unsigned char getKeyFromBuffer();

0
Kernel/include/naiveConsole.h → Kernel/drivers/include/naiveConsole.h
View File

5
Kernel/include/time.h → Kernel/drivers/include/time.h
View File

@ -1,5 +1,5 @@
#ifndef _TIME_H_
#define _TIME_H_
#ifndef TIME_H
#define TIME_H
void timer_handler();
int ticks_elapsed();
@ -14,7 +14,6 @@ int seconds_elapsed();
int getTimeGen(char option);
int getTime(char option);
// void wait(long seconds);
long getTimeOfDay();
#endif

2
Kernel/include/video.h → Kernel/drivers/include/video.h
View File

@ -3,13 +3,11 @@
#include <stdint.h>
void moveToWindowVideo(char window);
int printStringLen(int color, const char * string, int maxLen);
void new_line();
void backspace();
void clear();
void increment();
void changeWindow();
void scroll();
#endif

25
Kernel/drivers/keyboard.c
View File

@ -5,7 +5,6 @@ static unsigned char kbdus_sh[250];
// static unsigned char kbdsp_sh[250];
// static unsigned char kbdsp[250];
#define SIZE 1
unsigned char buffer[SIZE] = {0};
unsigned char *current = buffer;
unsigned char *last = buffer;
@ -24,20 +23,14 @@ void testKeyboardInterrupt(unsigned char c) {
if (c == 0x2A || c == 0x36) {
flag = 0;
return;
}
else if (c == 0xAA || c == 0xB6) {
} else if (c == 0xAA || c == 0xB6) {
flag = 1;
return;
}
else if (c == 0x3A) {
} else if (c == 0x3A) {
flag = ~(flag | 0xFE);
}
else if (c == 0x38) {
} else if (c == 0x38) {
flagChangeAlt = 0;
}
else if (c == 0x3B) {
} else if (c == 0x3B) {
flagChangeF1 = 0;
}
@ -46,13 +39,10 @@ void testKeyboardInterrupt(unsigned char c) {
flagChangeF1 = 1;
saveChar('\v');
return;
}
else if (c == 0xB8) {
} else if (c == 0xB8) {
flagChangeAlt = 1;
return;
}
else if (c == 0xBB) {
} else if (c == 0xBB) {
flagChangeF1 = 1;
return;
}
@ -61,8 +51,7 @@ void testKeyboardInterrupt(unsigned char c) {
c = kbdus_sh[c];
if (c != 0)
saveChar(c);
}
else {
} else {
c = kbdus[c];
if (c != 0)
saveChar(c);

53
Kernel/drivers/naiveConsole.c
View File

@ -8,82 +8,61 @@ static uint8_t * currentVideo = (uint8_t*)0xB8000;
static const uint32_t width = 80;
static const uint32_t height = 25;
void ncPrint(const char * string)
{
int i;
for (i = 0; string[i] != 0; i++)
void ncPrint(const char *string) {
for (int i = 0; string[i] != 0; i++)
ncPrintChar(string[i]);
}
void ncPrintChar(char character)
{
void ncPrintChar(char character) {
*currentVideo = character;
currentVideo += 2;
}
void ncNewline()
{
do
{
void ncNewline() {
do {
ncPrintChar(' ');
}
while((uint64_t)(currentVideo - video) % (width * 2) != 0);
} while ((uint64_t)(currentVideo - video) % (width * 2) != 0);
}
void ncPrintDec(uint64_t value)
{
void ncPrintDec(uint64_t value) {
ncPrintBase(value, 10);
}
void ncPrintHex(uint64_t value)
{
void ncPrintHex(uint64_t value) {
ncPrintBase(value, 16);
}
void ncPrintBin(uint64_t value)
{
void ncPrintBin(uint64_t value) {
ncPrintBase(value, 2);
}
void ncPrintBase(uint64_t value, uint32_t base)
{
void ncPrintBase(uint64_t value, uint32_t base) {
uintToBase(value, buffer, base);
ncPrint(buffer);
}
void ncClear()
{
int i;
for (i = 0; i < height * width; i++)
void ncClear() {
for (int i = 0; i < height * width; i++)
video[i * 2] = ' ';
currentVideo = video;
}
static uint32_t uintToBase(uint64_t value, char * buffer, uint32_t base)
{
static uint32_t uintToBase(uint64_t value, char *buffer, uint32_t base) {
char *p = buffer;
char *p1, *p2;
uint32_t digits = 0;
//Calculate characters for each digit
do
{
do {
uint32_t remainder = value % base;
*p++ = (remainder < 10) ? remainder + '0' : remainder + 'A' - 10;
digits++;
}
while (value /= base);
} while (value /= base);
// Terminate string in buffer.
*p = 0;
//Reverse string in buffer.
p1 = buffer;
p2 = p - 1;
while (p1 < p2)
{
while (p1 < p2) {
char tmp = *p1;
*p1 = *p2;
*p2 = tmp;

28
Kernel/drivers/time.c
View File

@ -1,4 +1,4 @@
#include <time.h>
#include "time.h"
static unsigned long ticks = 0;
@ -11,7 +11,6 @@ int ticks_elapsed() {
}
int seconds_elapsed() {
// return ticks / 18;
return ticks / 18;
}
@ -29,41 +28,20 @@ int getTime(char option) {
return getTimeGen(MONTH);
case YEAR:
return getTimeGen(YEAR);
default: return -1;
default:
return -1;
}
}
// TODO
/* void wait(long seconds) {
// int initialSeconds = getTimeGen(SECONDS);
// int initialMinutes = getTimeGen(MINUTES);
// int runSeconds = 0;
// if (initialSeconds + seconds >= 60) {
// }
// int newSeconds = 0;
// while ((newSeconds = getTimeGen(SECONDS) - initialSeconds) < seconds)
// haltcpu();
// while (initialSeconds - seconds != initialSeconds) {
// }
// while (seconds_elapsed() < seconds);
} */
static long getTimeFrom2000() {
long years = 00 * 31557600;
long months = 1 * 2629800;
long days = 1 * 86400;
// long aux = years + months + days;
return years + months + days;
}
long getTimeOfDay() {
// long years = getTimeGen(YEAR) - 1970;
// obtengo los segundos actuales (sumando todas las variables) y los resto por los de 1970?
long years = getTimeGen(YEAR) * 31557600;
long months = getTimeGen(MONTH) * 2629800;
long days = getTimeGen(DAY) * 86400;

9
Kernel/drivers/video.c
View File

@ -1,8 +1,6 @@
#include <stdint.h>
#include "video.h"
static uint8_t *const video = (uint8_t *) 0xB8000;
// static uint8_t * currentVideo = (uint8_t *) 0xB8000;
static const int width = 80;
static const int height = 25;
static int currentX = 0;
@ -27,7 +25,6 @@ char checkIfEscapeSequence(const char * bufferAux) {
if (*bufferAux == '\e') {
bufferAux++;
if (*bufferAux == '\f') {
bufferAux++;
clear();
}
return 1;
@ -56,12 +53,10 @@ int printStringLen(int color, const char * string, int maxLen) {
string++;
i++;
continue;
}
else if (*string == '\b') {
} else if (*string == '\b') {
backspace();
return i;
}
else if (checkIfEscapeSequence(string)) {
} else if (checkIfEscapeSequence(string)) {
return i;
}

7
Kernel/include/defs.h
View File

@ -1,12 +1,6 @@
/***************************************************
Defs.h
****************************************************/
#ifndef _defs_
#define _defs_
/* Flags para derechos de acceso de los segmentos */
#define ACS_PRESENT 0x80 /* segmento presente en memoria */
#define ACS_CSEG 0x18 /* segmento de codigo */
#define ACS_DSEG 0x10 /* segmento de datos */
@ -16,7 +10,6 @@
#define ACS_INT_386 0x0E /* Interrupt GATE 32 bits */
#define ACS_INT ( ACS_PRESENT | ACS_INT_386 )
#define ACS_CODE (ACS_PRESENT | ACS_CSEG | ACS_READ)
#define ACS_DATA (ACS_PRESENT | ACS_DSEG | ACS_WRITE)
#define ACS_STACK (ACS_PRESENT | ACS_DSEG | ACS_WRITE)

6
Kernel/include/idtLoader.h
View File

@ -1,6 +0,0 @@
#ifndef __IDT_LOADER_H__
#define __IDT_LOADER_H__
void load_idt();
#endif

24
Kernel/include/memManager.h
View File

@ -1,24 +0,0 @@
#ifndef MEM_MANAGER_H
#define MEM_MANAGER_H
#include <stdlib.h>
// typedef struct MemoryManagerCDT * MemoryManagerADT;
// MemoryManagerADT createMemoryManager(void *const restrict memoryForMemoryManager, void *const restrict managedMemory);
// void *allocMemory(MemoryManagerADT const restrict memoryManager, const size_t memoryToAllocate);
// char initMemoryManager(void *const restrict memoryForMemoryManager, void *const restrict managedMemory);
void initMemoryManager(void * managedMemory);
void * memMalloc(unsigned nbytes);
void memFree(void *ap);
// void * memMalloc(const size_t memoryToAllocate);
void * pvPortMalloc(size_t xWantedSize);
void vPortFree( void *pv );
size_t xPortGetFreeHeapSize( void );
// SACAR DPS
char testOne();
char testTwo();
#endif

20
Kernel/include/pcb.h
View File

@ -1,20 +0,0 @@
#ifndef PCB_H
#define PCB_H
#include <stdint.h>
#include <defs.h>
#define MAX_PROCESSES 2
uint64_t loadProcess(uint64_t rsp, void (*fn), uint64_t rbp);
uint64_t preserveStack(uint64_t rsp);
void newProcess(void (*fn));
void newStack(uint64_t rsp);
void cleanProcesses();
void * _initialize_stack_frame(void * rip, const void * rsp);
void saveSampleRSP(uint64_t rsp);
uint64_t getSampleRSP();
#endif

8
Kernel/include/queue.h
View File

@ -1,8 +0,0 @@
// #include "scheduler.h"
// typedef struct queueCDT * queueADT;
// void queue(queueADT * my_queue, processADT * process);
// char isEmpty(queueADT * my_queue);
// processADT * dequeue(queueADT * my_queue);
// queueADT createQueue();

18
Kernel/interruptions/exceptions.c
View File

@ -1,17 +1,8 @@
#include "lib.h"
#include "time.h"
#include "naiveConsole.h"
#include "pcb.h"
#include "video.h"
#include "keyboard.h"
#include "interrupts.h"
#include "exceptions.h"
static void * const sampleCodeAddress = (void *) 0x400000;
typedef int (* fn)();
#define ZERO_EXCEPTION_ID 0
#define INVALID_OPCODE_ID 6
static void zero_division();
static void invalid_opcode();
@ -42,12 +33,6 @@ static char * regsNames[] = {
void printRegs() {
uint64_t * regs = stackFrame;
// 8 bytes = 64 bits = 2^64
// máximo: 18.446.744.073.709.551.616 / 2
// máximo: 9.223.372.036.854.775.808 entonces de 0 a 18
// dejo el primero para un -
char buffer[20];
for (int i = 0; i < 15; i++) {
@ -95,7 +80,6 @@ static void startOver() {
}
static void genericException(char * string, int len) {
// moveToWindowVideo(-1);
clear();
printStringLen(15, string, len);
printRegs();

18
Kernel/interruptions/idtLoader.c
View File

@ -1,12 +1,8 @@
#include <stdint.h>
#include <idtLoader.h>
#include <defs.h>
#include <interrupts.h>
#include "idtLoader.h"
#pragma pack(push) /* Push de la alineación actual */
#pragma pack (1) /* Alinear las siguiente estructuras a 1 byte */
#pragma pack(push)
#pragma pack (1)
/* Descriptor de interrupcion */
typedef struct {
uint16_t offset_l, selector;
uint8_t cero, access;
@ -14,26 +10,22 @@ typedef struct {
uint32_t offset_h, other_cero;
} DESCR_INT;
#pragma pack(pop) /* Reestablece la alinceación actual */
#pragma pack(pop)
DESCR_INT * idt = (DESCR_INT *) 0; // IDT de 255 entradas
DESCR_INT *idt = (DESCR_INT *) 0;
static void setup_IDT_entry(int index, uint64_t offset);
void load_idt() {
setup_IDT_entry(0x20, (uint64_t) &_irq00Handler);
setup_IDT_entry(0x21, (uint64_t) &_irq01Handler);
setup_IDT_entry(0x00, (uint64_t) &_exception0Handler);
setup_IDT_entry(0x06, (uint64_t) &_exception6Handler);
setup_IDT_entry(0x80, (uint64_t) &_systemCallsHandler);
// setup_IDT_entry (0x81, (uint64_t)&_switchContext);
picMasterMask(0xFC);
picSlaveMask(0xFF);
// _sti();
}
static void setup_IDT_entry(int index, uint64_t offset) {

15
Kernel/interruptions/include/exceptions.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef EXCEPTIONS_H
#define EXCEPTIONS_H
#include "lib.h"
#include "time.h"
#include "naiveConsole.h"
#include "pcb.h"
#include "video.h"
#include "keyboard.h"
#include "interrupts.h"
#define ZERO_EXCEPTION_ID 0
#define INVALID_OPCODE_ID 6
#endif

10
Kernel/interruptions/include/idtLoader.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef IDT_LOADER_H
#define IDT_LOADER_H
#include <defs.h>
#include <interrupts.h>
#include <stdint.h>
void load_idt();
#endif

5
Kernel/include/interrupts.h → Kernel/interruptions/include/interrupts.h
View File

@ -1,7 +1,8 @@
#ifndef INTERRUPS_H_
#define INTERRUPS_H_
#include <idtLoader.h>
#include "idtLoader.h"
#include <stdint.h>
void _irq00Handler(void);
void _irq01Handler(void);
@ -27,4 +28,4 @@ void picSlaveMask(uint8_t mask);
void haltcpu(void);
#endif /* INTERRUPS_H_ */
#endif

19
Kernel/interruptions/include/systemCalls.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef SYSCALLS_H
#define SYSCALLS_H
#include "video.h"
#include "keyboard.h"
#include "time.h"
#include "pcb.h"
#include "pipeLib.h"
#include "schedulerLib.h"
#include "systemCallsLib.h"
#define STDIN 0
#define STDOUT 1
#define STDERR 2
#define STDOUT_COLOR 0x0f
#define STDERR_COLOR 0x04
#endif

6
Kernel/include/systemCalls.h → Kernel/interruptions/include/systemCallsLib.h
View File

@ -1,11 +1,9 @@
#ifndef SYSCALLS_H
#define SYSCALLS_H
#ifndef SYSCALLSLIB_H
#define SYSCALLSLIB_H
#include <stdint.h>
uint64_t write(uint64_t, uint64_t, uint64_t);
uint64_t read(uint64_t, uint64_t, uint64_t);
uint64_t getTime(uint64_t, uint64_t, uint64_t);
void createProcess();
#endif

2
Kernel/interruptions/irqDispatcher.c
View File

@ -1,9 +1,9 @@
#include <time.h>
#include <stdint.h>
static void int_20();
static void int_21();
void keyboard_handler();
void timer_handler();
void irqDispatcher(uint64_t irq) {
switch (irq) {

22
Kernel/interruptions/systemCalls.c
View File

@ -1,17 +1,4 @@
#include <stdint.h>
#include "video.h"
#include "keyboard.h"
#include "time.h"
#include "pcb.h"
#include "pipeLib.h"
#include "schedulerLib.h"
#define STDIN 0
#define STDOUT 1
#define STDERR 2
#define STDOUT_COLOR 0x0f
#define STDERR_COLOR 0x04
#include "systemCalls.h"
uint64_t write(uint64_t fd, uint64_t buffer, uint64_t length) {
char *bufferAux = (char *) buffer;
@ -56,8 +43,7 @@ uint64_t read(uint64_t fd, uint64_t buffer, uint64_t length) {
bufferAux++;
// blockIO();
}
}
else {
} else {
while (length-- > 0) {
*bufferAux = readPipe(fd);
if (*bufferAux == 0)
@ -69,7 +55,3 @@ uint64_t read(uint64_t fd, uint64_t buffer, uint64_t length) {
return readBytes;
}
// void createProcess(void (*fn)) {
// newProcess(fn);
// }

10
Kernel/interruptions/systemCallsDispatcher.c
View File

@ -1,13 +1,7 @@
#include <stdint.h>
#include "systemCalls.h"
#include "memManager.h"
void exitProcess();
// void setFn(uint64_t, uint64_t, uint64_t);
char * processes();
// int enqueueProcess(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t);
char openPipe(int *, char *);
char nice(int, char);
#include "pipeLib.h"
#include "semLib.h"
#include "schedulerLib.h"
@ -18,7 +12,7 @@ uint64_t systemCallsDispatcher(uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_
case 1:
return read(rsi, rdx, rcx);
case 2:
return getTime(rsi, rdx, rcx);
return getTime(rsi);
case 3:
return enqueueProcess((void (*)(int, char **)) rsi, rdx, rcx, (char **) r8, (int *) r9);
case 4:

48
Kernel/kernel.c
View File

@ -49,7 +49,9 @@ void * initializeKernelBinary() {
}
void load_idt();
uint64_t getRSP();
void printBottlerAndWait();
#include "test_util.h"
@ -145,8 +147,11 @@ void test_mm(){
void initScheduler();
void _cli();
void _sti();
void haltcpu();
void forceTimer();
int main() {
@ -174,8 +179,6 @@ int main() {
saveSampleRSP(getRSP());
// ((EntryPoint)sampleCodeModuleAddress)();
char *argv[] = {"SampleCode"};
enqueueProcess(sampleCodeModuleAddress, 1, 1, argv, NULL);
clear();
@ -183,46 +186,5 @@ int main() {
_sti();
forceTimer();
// printBottlerAndWait();
return EXIT_SUCCESS;
}
void printBottlerAndWait() {
printStringLen(4, " ", 80); new_line();
printStringLen(4, " (%( ", 80); new_line();
printStringLen(15, " Welcome to", 17);
printStringLen(4, " %%%%% ", 80); new_line();
printStringLen(15, " BottlerOS", 18);
printStringLen(4, " %%% ", 80); new_line();
printStringLen(12, " %%%%%%%%%%%%% ", 80); new_line();
printStringLen(12, " %%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
printStringLen(12, " %%%%%%% %%%%%%% ", 80); new_line();
printStringLen(12, " %%%%% %%%%% ", 80); new_line();
printStringLen(14, " %%%%% %%%%% ", 80); new_line();
printStringLen(14, " %%%%% ", 27);
printStringLen(14, " %%%% %%%% ", 22);
printStringLen(14, " %%%%% ", 30); new_line();
printStringLen(14, " %%%%% ", 28);
printStringLen(14, " (% %( ", 21);
printStringLen(14, " %%%%% ", 30); new_line();
printStringLen(14, " %%%%%%% %%%%%%% ", 80); new_line();
printStringLen(2, " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
printStringLen(2, " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
printStringLen(2, " %%%%%%%%%%%%%%%%%%%%%%% ", 41);
printStringLen(12, " % %* ", 8);
printStringLen(2, " %%%%%%%%% ", 30); new_line();
printStringLen(2, " %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
printStringLen(9, " %%**%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/%% ", 80); new_line();
printStringLen(9, " %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%% ", 80); new_line();
printStringLen(9, " %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%% ", 80); new_line();
printStringLen(9, " %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% ", 80); new_line();
printStringLen(13, " ,%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%. ", 80); new_line();
printStringLen(13, " %%. %%%%%%%%%%%%%%%%% .%% ", 80); new_line();
printStringLen(13, " %%%%%%%%%%%%% ", 80); new_line();
printStringLen(13, " %%%%%%% ", 80); new_line();
printStringLen(13, " ", 80); new_line();
// wait(3);
clear();
}

34
Kernel/lib.c
View File

@ -1,7 +1,6 @@
#include <stdint.h>
#include "lib.h"
void * memset(void * destination, int32_t c, uint64_t length)
{
void *memset(void *destination, int32_t c, uint64_t length) {
uint8_t chr = (uint8_t) c;
char *dst = (char *) destination;
@ -11,34 +10,18 @@ void * memset(void * destination, int32_t c, uint64_t length)
return destination;
}
void * memcpy(void * destination, const void * source, uint64_t length)
{
/*
* memcpy does not support overlapping buffers, so always do it
* forwards. (Don't change this without adjusting memmove.)
*
* For speedy copying, optimize the common case where both pointers
* and the length are word-aligned, and copy word-at-a-time instead
* of byte-at-a-time. Otherwise, copy by bytes.
*
* The alignment logic below should be portable. We rely on
* the compiler to be reasonably intelligent about optimizing
* the divides and modulos out. Fortunately, it is.
*/
void *memcpy(void *destination, const void *source, uint64_t length) {
uint64_t i;
if ((uint64_t) destination % sizeof(uint32_t) == 0 &&
(uint64_t) source % sizeof(uint32_t) == 0 &&
length % sizeof(uint32_t) == 0)
{
length % sizeof(uint32_t) == 0) {
uint32_t *d = (uint32_t *) destination;
const uint32_t *s = (const uint32_t *) source;
for (i = 0; i < length / sizeof(uint32_t); i++)
d[i] = s[i];
}
else
{
} else {
uint8_t *d = (uint8_t *) destination;
const uint8_t *s = (const uint8_t *) source;
@ -87,8 +70,7 @@ char * itoa(int value, char * buffer, int base, int length) {
if (r >= 10) {
buffer[i++] = 65 + (r - 10);
}
else {
} else {
buffer[i++] = 48 + r;
}
@ -107,10 +89,6 @@ char * itoa(int value, char * buffer, int base, int length) {
return reverse(buffer, 0, i - 1);
}
void strlen(const char *str, int *len) {
for (*len = 0; str[*len]; (*len)++);
}
int strcpy(char *strDest, const char *strSrc) {
int i = 0;
while ((*strDest++ = *strSrc++)) {

0
Kernel/include/test_util.h → Kernel/tests/include/test_util.h
View File

14
Kernel/utils/include/memManager.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef MEM_MANAGER_H
#define MEM_MANAGER_H
#include <stdlib.h>
void initMemoryManager(void * managedMemory);
void * memMalloc(unsigned nbytes);
void memFree(void *ap);
// void * memMalloc(const size_t memoryToAllocate);
void * pvPortMalloc(size_t xWantedSize);
void vPortFree( void *pv );
size_t xPortGetFreeHeapSize( void );
#endif

9
Kernel/utils/include/pcb.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef PCB_H
#define PCB_H
#include <stdint.h>
void saveSampleRSP(uint64_t rsp);
uint64_t getSampleRSP();
#endif

2
Kernel/include/pipe.h → Kernel/utils/include/pipe.h
View File

@ -4,7 +4,7 @@
#include <stdint.h>
#include <stddef.h>
#include <stdlib.h>
#include "lib.h"
#include "../../include/lib.h"
#include "scheduler.h"
#include "memManager.h"
#include "pipeLib.h"

0
Kernel/include/pipeLib.h → Kernel/utils/include/pipeLib.h
View File

6
Kernel/include/scheduler.h → Kernel/utils/include/scheduler.h
View File

@ -3,8 +3,8 @@
#include "memManager.h"
#include <stdlib.h>
#include "lib.h"
#include "time.h"
#include "../../include/lib.h"
#include "../../drivers/include/time.h"
#include <stddef.h>
#include "schedulerLib.h"
@ -18,6 +18,7 @@ void haltcpu();
#define PROCESS_DATA_MAX_SIZE 100
#define MAX_ATTR_SIZE 6
#define MAX_NAME_SIZE 10
#define IDLE_PID 1
typedef struct processCDT * processADT;
@ -27,5 +28,6 @@ uint64_t nextProcess();
char updateRSP(uint64_t newRsp);
char getProcessData(char * out, processADT proc);
processADT searchProcess(processADT * previous, int pid, processADT first);
uint64_t _initialize_stack_frame(void *, void *, int, char **);
#endif

0
Kernel/include/schedulerLib.h → Kernel/utils/include/schedulerLib.h
View File

3
Kernel/include/sem.h → Kernel/utils/include/sem.h
View File

@ -4,13 +4,14 @@
#include <stdint.h>
#include <stddef.h>
#include <stdlib.h>
#include "lib.h"
#include "../../include/lib.h"
#include "scheduler.h"
#include "memManager.h"
#include "semLib.h"
#define MAX_SEM 100
#define SEM_DATA_MAX_SIZE 100
#define MAX_PID 4
void enter_region(uint32_t * lock);
void leave_region(uint32_t * lock);

1
Kernel/include/semLib.h → Kernel/utils/include/semLib.h
View File

@ -10,7 +10,6 @@ typedef struct pid_t {
typedef struct sem_t {
unsigned int value;
// char name[MAX_NAME];
char * name;
pid_t * entering;
pid_t * last;

122
Kernel/utils/memManagerFRT4.c
View File

@ -39,20 +39,19 @@ typedef unsigned long UBaseType_t;
/* Define the linked list structure. This is used to link free blocks in order
of their memory address. */
typedef struct A_BLOCK_LINK
{
typedef struct A_BLOCK_LINK {
struct A_BLOCK_LINK *pxNextFreeBlock; /*<< The next free block in the list. */
size_t xBlockSize; /*<< The size of the free block. */
} BlockLink_t;
static uint8_t *ucHeap;
void initMemoryManager(void *managedMemory) {
ucHeap = managedMemory;
}
/* Definition of the Heap_stats_t structure. */
typedef struct xHeapStats
{
typedef struct xHeapStats {
size_t xAvailableHeapSpaceInBytes; /* The total heap size currently available - this is the sum of all the free blocks, not the largest block that can be allocated. */
size_t xSizeOfLargestFreeBlockInBytes; /* The maximum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
size_t xSizeOfSmallestFreeBlockInBytes; /* The minimum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
@ -85,7 +84,8 @@ static void prvHeapInit( void );
/* The size of the structure placed at the beginning of each allocated memory
block must by correctly byte aligned. */
static const size_t xHeapStructSize = ( sizeof( BlockLink_t ) + ( ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
static const size_t xHeapStructSize =
(sizeof(BlockLink_t) + ((size_t)(portBYTE_ALIGNMENT - 1))) & ~((size_t)portBYTE_ALIGNMENT_MASK);
/* Create a couple of list links to mark the start and end of the list. */
static BlockLink_t xStart, *pxEnd = NULL;
@ -105,15 +105,13 @@ static size_t xBlockAllocatedBit = 0;
/*-----------------------------------------------------------*/
void *pvPortMalloc( size_t xWantedSize )
{
void *pvPortMalloc(size_t xWantedSize) {
BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
void *pvReturn = NULL;
/* If this is the first call to malloc then the heap will require
initialisation to setup the list of free blocks. */
if( pxEnd == NULL )
{
if (pxEnd == NULL) {
prvHeapInit();
}
@ -121,40 +119,34 @@ void *pvReturn = NULL;
set. The top bit of the block size member of the BlockLink_t structure
is used to determine who owns the block - the application or the
kernel, so it must be free. */
if( ( xWantedSize & xBlockAllocatedBit ) == 0 )
{
if ((xWantedSize & xBlockAllocatedBit) == 0) {
/* The wanted size is increased so it can contain a BlockLink_t
structure in addition to the requested amount of bytes. */
if( xWantedSize > 0 )
{
if (xWantedSize > 0) {
xWantedSize += xHeapStructSize;
/* Ensure that blocks are always aligned to the required number
of bytes. */
if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
{
if ((xWantedSize & portBYTE_ALIGNMENT_MASK) != 0x00) {
/* Byte alignment required. */
xWantedSize += (portBYTE_ALIGNMENT - (xWantedSize & portBYTE_ALIGNMENT_MASK));
// configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );
}
}
if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
{
if ((xWantedSize > 0) && (xWantedSize <= xFreeBytesRemaining)) {
/* Traverse the list from the start (lowest address) block until
one of adequate size is found. */
pxPreviousBlock = &xStart;
pxBlock = xStart.pxNextFreeBlock;
while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
{
while ((pxBlock->xBlockSize < xWantedSize) && (pxBlock->pxNextFreeBlock != NULL)) {
pxPreviousBlock = pxBlock;
pxBlock = pxBlock->pxNextFreeBlock;
}
/* If the end marker was reached then a block of adequate size
was not found. */
if( pxBlock != pxEnd )
{
if (pxBlock != pxEnd) {
/* Return the memory space pointed to - jumping over the
BlockLink_t structure at its start. */
pvReturn = (void *) (((uint8_t *) pxPreviousBlock->pxNextFreeBlock) + xHeapStructSize);
@ -165,8 +157,7 @@ void *pvReturn = NULL;
/* If the block is larger than required it can be split into
two. */
if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
{
if ((pxBlock->xBlockSize - xWantedSize) > heapMINIMUM_BLOCK_SIZE) {
/* This block is to be split into two. Create a new
block following the number of bytes requested. The void
cast is used to prevent byte alignment warnings from the
@ -185,8 +176,7 @@ void *pvReturn = NULL;
xFreeBytesRemaining -= pxBlock->xBlockSize;
if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
{
if (xFreeBytesRemaining < xMinimumEverFreeBytesRemaining) {
xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
}
@ -196,8 +186,7 @@ void *pvReturn = NULL;
pxBlock->pxNextFreeBlock = NULL;
xNumberOfSuccessfulAllocations++;
}
}
else {
} else {
// ncNewline();
// ncPrint("MALLOC: ");
@ -213,15 +202,14 @@ void *pvReturn = NULL;
// configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
return pvReturn;
}
/*-----------------------------------------------------------*/
void vPortFree( void *pv )
{
void vPortFree(void *pv) {
uint8_t *puc = (uint8_t *) pv;
BlockLink_t *pxLink;
if( pv != NULL )
{
if (pv != NULL) {
/* The memory being freed will have an BlockLink_t structure immediately
before it. */
puc -= xHeapStructSize;
@ -233,10 +221,8 @@ BlockLink_t *pxLink;
// configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
// configASSERT( pxLink->pxNextFreeBlock == NULL );
if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )
{
if( pxLink->pxNextFreeBlock == NULL )
{
if ((pxLink->xBlockSize & xBlockAllocatedBit) != 0) {
if (pxLink->pxNextFreeBlock == NULL) {
/* The block is being returned to the heap - it is no longer
allocated. */
pxLink->xBlockSize &= ~xBlockAllocatedBit;
@ -251,28 +237,28 @@ BlockLink_t *pxLink;
}
}
}
/*-----------------------------------------------------------*/
size_t xPortGetFreeHeapSize( void )
{
size_t xPortGetFreeHeapSize(void) {
return xFreeBytesRemaining;
}
/*-----------------------------------------------------------*/
size_t xPortGetMinimumEverFreeHeapSize( void )
{
size_t xPortGetMinimumEverFreeHeapSize(void) {
return xMinimumEverFreeBytesRemaining;
}
/*-----------------------------------------------------------*/
void vPortInitialiseBlocks( void )
{
void vPortInitialiseBlocks(void) {
/* This just exists to keep the linker quiet. */
}
/*-----------------------------------------------------------*/
static void prvHeapInit( void )
{
static void prvHeapInit(void) {
BlockLink_t *pxFirstFreeBlock;
uint8_t *pucAlignedHeap;
size_t uxAddress;
@ -281,8 +267,7 @@ size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
/* Ensure the heap starts on a correctly aligned boundary. */
uxAddress = (size_t) ucHeap;
if( ( uxAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
{
if ((uxAddress & portBYTE_ALIGNMENT_MASK) != 0) {
uxAddress += (portBYTE_ALIGNMENT - 1);
uxAddress &= ~((size_t)portBYTE_ALIGNMENT_MASK);
xTotalHeapSize -= uxAddress - (size_t) ucHeap;
@ -317,25 +302,24 @@ size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
/* Work out the position of the top bit in a size_t variable. */
xBlockAllocatedBit = ((size_t) 1) << ((sizeof(size_t) * heapBITS_PER_BYTE) - 1);
}
/*-----------------------------------------------------------*/
static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert )
{
static void prvInsertBlockIntoFreeList(BlockLink_t *pxBlockToInsert) {
BlockLink_t *pxIterator;
uint8_t *puc;
/* Iterate through the list until a block is found that has a higher address
than the block being inserted. */
for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )
{
for (pxIterator = &xStart;
pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock) {
/* Nothing to do here, just iterate to the right position. */
}
/* Do the block being inserted, and the block it is being inserted after
make a contiguous block of memory? */
puc = (uint8_t *) pxIterator;
if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
{
if ((puc + pxIterator->xBlockSize) == (uint8_t *) pxBlockToInsert) {
pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
pxBlockToInsert = pxIterator;
}
@ -343,21 +327,15 @@ uint8_t *puc;
/* Do the block being inserted, and the block it is being inserted before
make a contiguous block of memory? */
puc = (uint8_t *) pxBlockToInsert;
if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )
{
if( pxIterator->pxNextFreeBlock != pxEnd )
{
if ((puc + pxBlockToInsert->xBlockSize) == (uint8_t *) pxIterator->pxNextFreeBlock) {
if (pxIterator->pxNextFreeBlock != pxEnd) {
/* Form one big block from the two blocks. */
pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;
pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;
}
else
{
} else {
pxBlockToInsert->pxNextFreeBlock = pxEnd;
}
}
else
{
} else {
pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
}
@ -365,37 +343,33 @@ uint8_t *puc;
before and the block after, then it's pxNextFreeBlock pointer will have
already been set, and should not be set here as that would make it point
to itself. */
if( pxIterator != pxBlockToInsert )
{
if (pxIterator != pxBlockToInsert) {
pxIterator->pxNextFreeBlock = pxBlockToInsert;
}
}
/*-----------------------------------------------------------*/
void vPortGetHeapStats( HeapStats_t *pxHeapStats )
{
void vPortGetHeapStats(HeapStats_t *pxHeapStats) {
BlockLink_t *pxBlock;
size_t xBlocks = 0, xMaxSize = 0, xMinSize = configTOTAL_HEAP_SIZE;//portMAX_DELAY; /* portMAX_DELAY used as a portable way of getting the maximum value. */
size_t xBlocks = 0, xMaxSize = 0, xMinSize =
configTOTAL_HEAP_SIZE;//portMAX_DELAY; /* portMAX_DELAY used as a portable way of getting the maximum value. */
pxBlock = xStart.pxNextFreeBlock;
/* pxBlock will be NULL if the heap has not been initialised. The heap
is initialised automatically when the first allocation is made. */
if( pxBlock != NULL )
{
do
{
if (pxBlock != NULL) {
do {
/* Increment the number of blocks and record the largest block seen
so far. */
xBlocks++;
if( pxBlock->xBlockSize > xMaxSize )
{
if (pxBlock->xBlockSize > xMaxSize) {
xMaxSize = pxBlock->xBlockSize;
}
if( pxBlock->xBlockSize < xMinSize )
{
if (pxBlock->xBlockSize < xMinSize) {
xMinSize = pxBlock->xBlockSize;
}

32
Kernel/utils/pcb.c
View File

@ -1,37 +1,5 @@
#include "pcb.h"
// static const uint8_t * firstProcessAddress = (uint8_t *) 0x18000000;
// static const long stackSize = 0x4000000; // 2^26
// static const uint8_t * lastProcessAddress = (uint8_t *) 0x10000001; // 2^29 - 1
// int activeProcesses = 0, currentProcess = -1;
// uint64_t priority0[MAX_PROCESSES];
// uint64_t priority1[MAX_PROCESSES];
// uint64_t priority2[MAX_PROCESSES];
// void cleanProcesses() {
// activeProcesses = 0;
// currentProcess = -1;
// }
// void newProcess(void (*fn)) {
// if (firstProcessAddress - activeProcesses * stackSize + stackSize <= lastProcessAddress) return;
// _initialize_stack_frame(fn, firstProcessAddress - activeProcesses * stackSize);
// }
// void newStack(uint64_t rsp) {
// priority0[activeProcesses++] = rsp;
// }
// uint64_t preserveStack(uint64_t rsp) {
// if (currentProcess != -1) {
// priority0[currentProcess] = rsp;
// }
// if (++currentProcess >= activeProcesses) currentProcess = 0;
// if (activeProcesses == 0) return 0;
// return priority0[currentProcess];
// }
static uint64_t sampleRSP;
void saveSampleRSP(uint64_t rsp) {

51
Kernel/utils/queue.c
View File

@ -1,51 +0,0 @@
// #include "queue.h"
// #include "memManager.h"
// #include <stdint.h>
// typedef struct nodeT {
// processADT * process;
// struct nodeT * next;
// } nodeT;
// typedef struct queueCDT {
// nodeT * first;
// nodeT * last;
// int length;
// } queueCDT;
// queueADT createQueue() {
// queueADT aux = pvPortMalloc(sizeof(queueCDT));
// if (aux == NULL)
// return NULL;
// aux->first = NULL;
// aux->last = NULL;
// aux->length = 0;
// return aux;
// }
// void queue(queueADT * my_queue, processADT * process) {
// if (my_queue == NULL)
// return;
// nodeT * new_node = pvPortMalloc(sizeof(nodeT));
// if (new_node == NULL)
// return;
// new_node->process = process;
// new_node->next = NULL;
// (*my_queue)->last->next = new_node;
// (*my_queue)->last = new_node;
// (*my_queue)->length++;
// }
// processADT * dequeue(queueADT * my_queue) {
// if (my_queue == NULL || isEmpty(my_queue))
// return NULL;
// nodeT * aux = (*my_queue)->first;
// (*my_queue)->first = (*my_queue)->first->next;
// processADT * ans = aux->process;
// vPortFree(aux);
// return ans;
// }
// char isEmpty(queueADT * my_queue) {
// return (*my_queue)->length == 0;
// }

38
Kernel/utils/scheduler.c
View File

@ -1,9 +1,8 @@
#include "scheduler.h"
#define IDLE_PID 1
uint64_t _initialize_stack_frame(void *, void *, int, char**);
enum states {READY = 0, DEAD, BLOCKED, BBCHILDREN, WAITING, BLOCKEDIO};
enum states {
READY = 0, DEAD, BLOCKED, BBCHILDREN, WAITING, BLOCKEDIO
};
typedef struct processCDT {
struct processCDT *next;
@ -47,8 +46,7 @@ void removeProcess(processCDT * del, processCDT ** first, processCDT ** last) {
*first = del->next;
if (*last == del)
*last = NULL;
}
else {
} else {
prev->next = del->next;
if (*last == del)
*last = prev;
@ -59,27 +57,27 @@ uint64_t nextProcess(uint64_t currentRSP) {
if (currentProcess != NULL)
currentProcess->rsp = currentRSP;
processCDT *prev = currentProcess;
if (currentProcess != NULL && currentProcess->state == READY && currentProcess->executions == MAX_PRIORITY - currentProcess->priority + 1) {
if (currentProcess != NULL && currentProcess->state == READY &&
currentProcess->executions == MAX_PRIORITY - currentProcess->priority + 1) {
currentProcess->executions = 0;
currentProcess = currentProcess->next;
}
while (currentProcess == NULL || currentProcess->state == BLOCKED || currentProcess->state == DEAD || currentProcess->state == WAITING || currentProcess->state == BLOCKEDIO) {
while (currentProcess == NULL || currentProcess->state == BLOCKED || currentProcess->state == DEAD ||
currentProcess->state == WAITING || currentProcess->state == BLOCKEDIO) {
if (currentProcess == NULL) {
currentProcess = firstProcess;
}
else if (currentProcess == firstBlockedIteration) {
} else if (currentProcess == firstBlockedIteration) {
idleFlag = 1;
unblock(IDLE_PID);
prev = currentProcess;
currentProcess = currentProcess->next;
}
else if (currentProcess->state == DEAD) {
} else if (currentProcess->state == DEAD) {
processCDT *del = currentProcess;
currentProcess = currentProcess->next;
removeProcess(del, &firstProcess, &lastProcess);
vPortFree((void *) del);
}
else if (currentProcess->state == BLOCKED || currentProcess->state == WAITING || currentProcess->state == BLOCKEDIO) {
} else if (currentProcess->state == BLOCKED || currentProcess->state == WAITING ||
currentProcess->state == BLOCKEDIO) {
if (firstBlockedIteration == NULL)
firstBlockedIteration = currentProcess;
prev = currentProcess;
@ -195,8 +193,7 @@ void checkSleeping() {
if (getTimeOfDay() >= aux->time + aux->secs) {
wakeUp(aux, prev);
aux = prev->next;
}
else {
} else {
prev = aux;
aux = aux->next;
}
@ -278,8 +275,7 @@ char unblock(int pid) {
processADT del = searchProcess(&prev, pid, firstProcess);
if (del == NULL || del->state == DEAD) {
return EXIT_FAILURE;
}
else {
} else {
del->state = READY;
}
@ -347,8 +343,7 @@ char nice(int pid, char offset) {
processADT del = searchProcess(&prev, pid, firstProcess);
if (del == NULL) {
return EXIT_FAILURE;
}
else {
} else {
del->priority = offset + 20;
}
return EXIT_SUCCESS;
@ -428,7 +423,8 @@ char getProcessData(char * out, processCDT * proc) {
getGenProcessData(&out, &written, MAX_NAME_SIZE, itoa(proc->rsp, buffer, 16, 10), 0);
getGenProcessData(&out, &written, MAX_NAME_SIZE, itoa(proc->rbp, buffer, 16, 10), 0);
getGenProcessData(&out, &written, MAX_ATTR_SIZE, (proc->foreground == 1) ? "F" : "B", 0);
getGenProcessData(&out, &written, MAX_ATTR_SIZE, proc->state == BLOCKED ? "Block" : proc->state == DEAD ? "Killed" : "Ready", 1);
getGenProcessData(&out, &written, MAX_ATTR_SIZE,
proc->state == BLOCKED ? "Block" : proc->state == DEAD ? "Killed" : "Ready", 1);
return written;
}

11
Kernel/utils/sem.c
View File

@ -39,16 +39,16 @@ char semClose(sem_t * sem) {
if (firstSem->sem == sem) {
del = firstSem;
firstSem = firstSem->next;
}
else {
} else {
node_t *aux = firstSem;
while (aux != NULL) {
if (aux->next != NULL)
if (aux->next != NULL) {
if (aux->next->sem == sem) {
del = aux->next;
aux->next = aux->next->next;
break;
}
}
aux = aux->next;
}
}
@ -79,8 +79,7 @@ void semWait(sem_t * sem) {
if (sem->value > 0) {
sem->value--;
}
else {
} else {
leave_region(&semLock);
pid_t *curr = pvPortMalloc(sizeof(pid_t));
@ -157,8 +156,6 @@ char getSemaphoresData(char * out, node_t * node) {
return written;
}
#define MAX_PID 4
char *getEntering(sem_t *sem) {
char *ans = pvPortMalloc(sizeof(pid_t * ));
pid_t *aux = sem->entering;

25
Userland/SampleCodeModule/Makefile
View File

@ -17,10 +17,7 @@ ALL_OBJECTS= $(OBJECTS) $(OBJECTS_ASM) $(OBJECTS_SHELL) $(OBJECTS_COMMANDS) $(OB
STATICLIBS=
all: $(MODULE) $(MODULE_ELF) #shellModule
#shellModule:
# cd shell; make
all: $(MODULE) $(MODULE_ELF)
$(MODULE): $(STATICLIBS) $(ALL_OBJECTS)
$(LD) $(LDFLAGS) -T sampleCodeModule.ld $(OBJECTS) $(OBJECTS_SHELL) $(OBJECTS_ASM) $(OBJECTS_PROMPT) $(OBJECTS_BOTTLER) -o ../$(MODULE)
@ -35,24 +32,6 @@ $(MODULE_ELF): $(STATICLIBS) $(ALL_OBJECTS)
$(ASM) $(ASMFLAGS) $< -o $@
clean:
# cd shell; make clean
rm -rf *.o
cd shell; rm -rf *.o
cd shell/commands; rm -rf *.o
rm -rf $(ALL_OBJECTS)
.PHONY: all clean print
# include ../Makefile.inc
# MODULE=0000-sampleCodeModule.bin
# SOURCES=$(wildcard [^_]*.c)
# all: $(MODULE)
# $(MODULE): $(SOURCES)
# $(GCC) $(GCCFLAGS) -T sampleCodeModule.ld _loader.c $(SOURCES) -I./include -o ../$(MODULE)
# clean:
# rm -rf *.o
# .PHONY: all clean print

3
Userland/SampleCodeModule/_loader.c
View File

@ -1,4 +1,3 @@
/* _loader.c */
#include <stdint.h>
extern char bss;
@ -9,13 +8,11 @@ int main(int argc, char *argv[]);
void *memset(void *destiny, int32_t c, uint64_t length);
int _start(int argc, char *argv[]) {
//Clean BSS
memset(&bss, 0, &endOfBinary - &bss);
return main(argc, argv);
}
void *memset(void *destination, int32_t c, uint64_t length) {
uint8_t chr = (uint8_t) c;
char *dst = (char *) destination;

75
Userland/SampleCodeModule/bottler/bottler.c
View File

@ -1,39 +1,64 @@
#include "bottler.h"
void bottler(int argc, char **argv) {
printStringLen(" ", 80); new_line();
printStringLen(" (%( ", 80); new_line();
printStringLen(" ", 80);
new_line();
printStringLen(" (%( ", 80);
new_line();
printStringLen(" Welcome to", 17);
printStringLen(" %%%%% ", 80); new_line();
printStringLen(" %%%%% ", 80);
new_line();
printStringLen(" BottlerOS", 18);
printStringLen(" %%% ", 80); new_line();
printStringLen( " %%%%%%%%%%%%% ", 80); new_line();
printStringLen( " %%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
printStringLen( " %%%%%%% %%%%%%% ", 80); new_line();
printStringLen( " %%%%% %%%%% ", 80); new_line();
printStringLen( " %%%%% %%%%% ", 80); new_line();
printStringLen(" %%% ", 80);
new_line();
printStringLen(" %%%%%%%%%%%%% ", 80);
new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%% ", 80);
new_line();
printStringLen(" %%%%%%% %%%%%%% ", 80);
new_line();
printStringLen(" %%%%% %%%%% ", 80);
new_line();
printStringLen(" %%%%% %%%%% ", 80);
new_line();
printStringLen(" %%%%% ", 27);
printStringLen(" %%%% %%%% ", 22);
printStringLen( " %%%%% ", 30); new_line();
printStringLen(" %%%%% ", 30);
new_line();
printStringLen(" %%%%% ", 28);
printStringLen(" (% %( ", 21);
printStringLen( " %%%%% ", 30); new_line();
printStringLen( " %%%%%%% %%%%%%% ", 80); new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
printStringLen(" %%%%% ", 30);
new_line();
printStringLen(" %%%%%%% %%%%%%% ", 80);
new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80);
new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80);
new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%% ", 41);
printStringLen(" % %* ", 8);
printStringLen(" %%%%%%%%% ", 30); new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
printStringLen(" %%**%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/%% ", 80); new_line();
printStringLen(" %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%% ", 80); new_line();
printStringLen(" %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%% ", 80); new_line();
printStringLen(" %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% ", 80); new_line();
printStringLen( " ,%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%. ", 80); new_line();
printStringLen( " %%. %%%%%%%%%%%%%%%%% .%% ", 80); new_line();
printStringLen( " %%%%%%%%%%%%% ", 80); new_line();
printStringLen( " %%%%%%% ", 80); new_line();
printStringLen( " ", 80); new_line();
printStringLen(" %%%%%%%%% ", 30);
new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80);
new_line();
printStringLen(" %%**%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/%% ", 80);
new_line();
printStringLen(" %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%% ", 80);
new_line();
printStringLen(" %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%% ", 80);
new_line();
printStringLen(" %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% ", 80);
new_line();
printStringLen(" ,%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%. ", 80);
new_line();
printStringLen(" %%. %%%%%%%%%%%%%%%%% .%% ", 80);
new_line();
printStringLen(" %%%%%%%%%%%%% ", 80);
new_line();
printStringLen(" %%%%%%% ", 80);
new_line();
printStringLen(" ", 80);
new_line();
sys_sleep(3);
winClear();

4
Userland/SampleCodeModule/include/system.h
View File

@ -8,13 +8,11 @@ typedef struct pid_t {
typedef struct sem_t {
unsigned int value;
// char name[MAX_NAME];
char * name;
pid_t * entering;
pid_t * last;
} sem_t;
// void sys_switchContext();
int sys_loadProcess(void (*fn) (int, char **), char foreground, int argc, char *argv[], int * fd);
int sys_time(char);
void sys_exit();
@ -27,10 +25,8 @@ void * sys_free(void *);
void * sys_openPipe(int *, char *);
char sys_nice(int, char);
void sys_sleep(int);
// void sys_semWait(void *);
void sys_semWait(sem_t *);
void sys_semPost(sem_t *);
// void * sys_semOpen(char *, unsigned int);
sem_t * sys_semOpen(char *, unsigned int);
int sys_getPid();
char sys_semClose(void *);

21
Userland/SampleCodeModule/libc.c
View File

@ -74,8 +74,7 @@ char* gtoa(int value, char* buffer, int base, int length) {
int r = n % base;
if (r >= 10) {
buffer[i++] = 65 + (r - 10);
}
else {
} else {
buffer[i++] = 48 + r;
}
n = n / base;
@ -102,7 +101,9 @@ char getChar() {
}
void swap(char *x, char *y) {
char t = *x; *x = *y; *y = t;
char t = *x;
*x = *y;
*y = t;
}
char *reverse(char *buffer, int i, int j) {
@ -129,8 +130,7 @@ char* itoa(int value, char* buffer, int base) {
int r = n % base;
if (r >= 10) {
buffer[i++] = 65 + (r - 10);
}
else {
} else {
buffer[i++] = 48 + r;
}
n = n / base;
@ -149,14 +149,6 @@ char* itoa(int value, char* buffer, int base) {
return reverse(buffer, 0, i - 1);
}
// int atoi(char * string, int length) {
// int res = 0, i = 0;
// while (string[i] != 0 && i < length) {
// res = res * 10 + string[i++] - '0';
// }
// return res;
// }
int atoi(char *str, int length) {
int i = 0, sign = 1, val = 0, nbr = 0;
while (str[i] != '\0') {
@ -246,8 +238,7 @@ char *strtok(char * s, char delim) {
if (*ptr == delim) {
flag = 1;
*ptr = 0;
}
else if (flag == 1)
} else if (flag == 1)
return ptr;
ptr++;
}

5
Userland/SampleCodeModule/sampleCodeModule.c
View File

@ -1,11 +1,8 @@
/* sampleCodeModule.c */
#include "libc.h"
#include "shell/include/shell.h"
#include "bottler/include/bottler.h"
#include <stddef.h>
int sys_loadProcess(void (*fn) (int, char **), char foreground, int argc, char *argv[], int * fd);
void sys_exit();
#include "system.h"
int main(int argc, char *argv[]) {
winClear();

20
Userland/SampleCodeModule/shell/Makefile
View File

@ -1,20 +0,0 @@
# include ../../Makefile.inc
# SOURCES=$(wildcard *.c)
# SOURCES_COMMANDS=$(wildcard prompt_commands/*.c)
# OBJECTS=$(SOURCES:.c=.o)
# OBJECTS_COMMANDS=$(SOURCES_COMMANDS:.c=.o)
# ALL_OBJECTS= $(OBJECTS) $(OBJECTS_COMMANDS)
# STATICLIBS=
# all: $(OBJECTS)
# %.o:%.c
# $(GCC) $(GCCFLAGS) -I./include -c $< -o $@
# clean:
# rm -rf *.o
# .PHONY: all clean print

14
Userland/SampleCodeModule/shell/shell.c
View File

@ -34,8 +34,7 @@ int scanfNoPrint(char * buffer) {
if (c == '\b' && i > 0) {
buffer[--i] = ' ';
backspace();
}
else if (c != 0 && c != '\b') {
} else if (c != 0 && c != '\b') {
buffer[i++] = c;
putChar(c);
}
@ -98,8 +97,7 @@ void processInput(char * input) {
argv1 = sys_malloc(sizeof(char *) * (end - pipe - 1));
for (int i = pipe + 1; i < end; i++)
argv1[i - pipe - 1] = tokens[i];
}
else {
} else {
argv0 = sys_malloc(sizeof(char *) * end);
for (int i = 0; i < end; i++)
argv0[i] = tokens[i];
@ -125,8 +123,7 @@ void processInput(char * input) {
if (pipe != -1) {
sys_loadProcess(commands[comm0].func, commands[comm0].isForeground, pipe, argv0, fd1);
sys_loadProcess(commands[comm1].func, commands[comm0].isForeground, end - pipe - 1, argv1, fd2);
}
else {
} else {
if (commands[comm0].isBuiltIn)
commands[comm0].func(end, argv0);
else {
@ -143,8 +140,7 @@ void processInput(char * input) {
if (!comm_flag0) {
if (*tokens[0] != 0)
incorrect_comm(tokens[0]);
}
else if (!comm_flag1 && pipe != -1) {
} else if (!comm_flag1 && pipe != -1) {
if (*tokens[pipe + 1] != 0)
incorrect_comm(tokens[pipe + 1]);
}
@ -154,13 +150,11 @@ void shell(int argc, char *argv[]) {
printStringLen("$> ", 3);
char buffer[SIZE] = {0};
// while (1) {
while (scanfNoPrint(buffer) != 0) {
new_line();
processInput(buffer);
printStringLen("$> ", 3);
}
// }
}
void incorrect_comm(char *buffer) {