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

33
Kernel/drivers/keyboard.c
View File

@ -5,10 +5,9 @@ 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;
unsigned char *current = buffer;
unsigned char *last = buffer;
void saveChar(unsigned char c) {
*last++ = c;
@ -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);
@ -204,7 +193,7 @@ static unsigned char kbdus[250] = {
// };
static unsigned char kbdus_sh[250] =
{
{
0, 27, '!', '\"', '#', 0 /* shift+4 */, '%', '&', '/', '(', /* 9 */
')', '=', '?', '`', '\b', /* Backspace */
'\t', /* Tab */
@ -241,4 +230,4 @@ static unsigned char kbdus_sh[250] =
0, /* F11 Key */
0, /* F12 Key */
0, /* All other keys are undefined */
};
};

63
Kernel/drivers/naiveConsole.c
View File

@ -1,89 +1,68 @@
#include <naiveConsole.h>
static uint32_t uintToBase(uint64_t value, char * buffer, uint32_t base);
static uint32_t uintToBase(uint64_t value, char *buffer, uint32_t base);
static char buffer[64] = { '0' };
static uint8_t * const video = (uint8_t*)0xB8000;
static uint8_t * currentVideo = (uint8_t*)0xB8000;
static char buffer[64] = {'0'};
static uint8_t *const video = (uint8_t *) 0xB8000;
static uint8_t *currentVideo = (uint8_t *) 0xB8000;
static const uint32_t width = 80;
static const uint32_t height = 25 ;
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;

30
Kernel/drivers/time.c
View File

@ -1,4 +1,4 @@
#include <time.h>
#include "time.h"
static unsigned long ticks = 0;
@ -11,12 +11,11 @@ int ticks_elapsed() {
}
int seconds_elapsed() {
// return ticks / 18;
return ticks / 18;
}
int getTime(char option) {
switch(option) {
switch (option) {
case SECONDS:
return getTimeGen(SECONDS);
case MINUTES:
@ -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;

15
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 uint8_t *const video = (uint8_t *) 0xB8000;
static const int width = 80;
static const int height = 25;
static int currentX = 0;
@ -23,11 +21,10 @@ void increment() {
}
}
char checkIfEscapeSequence(const char * bufferAux) {
char checkIfEscapeSequence(const char *bufferAux) {
if (*bufferAux == '\e') {
bufferAux++;
if (*bufferAux == '\f') {
bufferAux++;
clear();
}
return 1;
@ -47,7 +44,7 @@ void scroll() {
}
}
int printStringLen(int color, const char * string, int maxLen) {
int printStringLen(int color, const char *string, int maxLen) {
int i = 0;
while (*string != '\0' && i <= maxLen) {
@ -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();

32
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,29 +10,25 @@ 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);
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 (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);
setup_IDT_entry(0x80, (uint64_t) &_systemCallsHandler);
picMasterMask(0xFC);
picSlaveMask(0xFF);
// _sti();
}
static void setup_IDT_entry (int index, uint64_t offset) {
static void setup_IDT_entry(int index, uint64_t offset) {
idt[index].selector = 0x08;
idt[index].offset_l = offset & 0xFFFF;
idt[index].offset_m = (offset >> 16) & 0xFFFF;

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) {

26
Kernel/interruptions/systemCalls.c
View File

@ -1,20 +1,7 @@
#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;
char *bufferAux = (char *) buffer;
int color = STDOUT_COLOR;
fd = getFdOut();
@ -31,7 +18,7 @@ uint64_t write(uint64_t fd, uint64_t buffer, uint64_t length) {
}
uint64_t read(uint64_t fd, uint64_t buffer, uint64_t length) {
char * bufferAux = (char *) buffer;
char *bufferAux = (char *) buffer;
int readBytes = 0;
if (!isForeground())
@ -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:

86
Kernel/kernel.c
View File

@ -18,26 +18,26 @@ extern uint8_t endOfKernel;
static const uint64_t PageSize = 0x1000;
static void * const sampleCodeModuleAddress = (void*)0x400000;
static void * const sampleDataModuleAddress = (void*)0x500000;
static void * const memoryModuleAddress = (void*)0x600000;
static void *const sampleCodeModuleAddress = (void *) 0x400000;
static void *const sampleDataModuleAddress = (void *) 0x500000;
static void *const memoryModuleAddress = (void *) 0x600000;
typedef int (*EntryPoint)();
void clearBSS(void * bssAddress, uint64_t bssSize) {
void clearBSS(void *bssAddress, uint64_t bssSize) {
memset(bssAddress, 0, bssSize);
}
void * getStackBase() {
return (void*)(
(uint64_t)&endOfKernel
void *getStackBase() {
return (void *) (
(uint64_t) & endOfKernel
+ PageSize * 8 //The size of the stack itself, 32KiB
- sizeof(uint64_t) //Begin at the top of the stack
);
}
void * initializeKernelBinary() {
void * moduleAddresses[] = {
void *initializeKernelBinary() {
void *moduleAddresses[] = {
sampleCodeModuleAddress,
sampleDataModuleAddress
};
@ -49,7 +49,9 @@ void * initializeKernelBinary() {
}
void load_idt();
uint64_t getRSP();
void printBottlerAndWait();
#include "test_util.h"
@ -62,30 +64,30 @@ void printBottlerAndWait();
#define MAX_MEMORY 352//1024-42x16 //Should be around 80% of memory managed by the MM
#endif
typedef struct MM_rq{
typedef struct MM_rq {
void *address;
uint32_t size;
}mm_rq;
} mm_rq;
void test_mm(){
void test_mm() {
mm_rq mm_rqs[MAX_BLOCKS];
uint8_t rq;
uint32_t total;
int i = 1000;
while (i-- != 0){
while (i-- != 0) {
// while (1){
rq = 0;
total = 0;
// Request as many blocks as we can
while(rq < MAX_BLOCKS && total < MAX_MEMORY){
while (rq < MAX_BLOCKS && total < MAX_MEMORY) {
mm_rqs[rq].size = GetUniform(MAX_MEMORY - total - 1) + 1;
mm_rqs[rq].address = pvPortMalloc(mm_rqs[rq].size);
// mm_rqs[rq].address = memMalloc(mm_rqs[rq].size);
if (mm_rqs[rq].address == NULL) {
for (int rqAux = 0; rqAux < rq; rqAux++) {
ncPrintDec(mm_rqs[rqAux].size );
ncPrintDec(mm_rqs[rqAux].size);
ncPrint(" - ");
}
// printStringLen(13, "malloc() -- ERROR", 20);
@ -112,7 +114,7 @@ void test_mm(){
// Check
for (i = 0; i < rq; i++)
if (mm_rqs[i].address != NULL)
if(!memcheck(mm_rqs[i].address, i, mm_rqs[i].size)) {
if (!memcheck(mm_rqs[i].address, i, mm_rqs[i].size)) {
// printStringLen(13, "memCheck() -- ERROR", 20);
// new_line();
ncPrint("memCheck -- null");
@ -145,8 +147,11 @@ void test_mm(){
void initScheduler();
void _cli();
void _sti();
void haltcpu();
void forceTimer();
int main() {
@ -163,66 +168,23 @@ int main() {
initMemoryManager(memoryModuleAddress);
initScheduler();
#ifndef BUDDY
#ifndef BUDDY
// SACAR DESPUÉS! ES SOLO PARA TESTEO... CORRER DE A UNO!
// if (testOne() == EXIT_FAILURE)
// return EXIT_FAILURE;
// if (testTwo() == EXIT_FAILURE)
// return EXIT_FAILURE;
#endif
#endif
// test_mm();
saveSampleRSP(getRSP());
// ((EntryPoint)sampleCodeModuleAddress)();
char * argv[] = {"SampleCode"};
char *argv[] = {"SampleCode"};
enqueueProcess(sampleCodeModuleAddress, 1, 1, argv, NULL);
clear();
// haltcpu();
_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();
}

58
Kernel/lib.c
View File

@ -1,46 +1,29 @@
#include <stdint.h>
#include "lib.h"
void * memset(void * destination, int32_t c, uint64_t length)
{
uint8_t chr = (uint8_t)c;
char * dst = (char*)destination;
void *memset(void *destination, int32_t c, uint64_t length) {
uint8_t chr = (uint8_t) c;
char *dst = (char *) destination;
while(length--)
while (length--)
dst[length] = chr;
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)
{
if ((uint64_t) destination % sizeof(uint32_t) == 0 &&
(uint64_t) source % sizeof(uint32_t) == 0 &&
length % sizeof(uint32_t) == 0) {
uint32_t *d = (uint32_t *) destination;
const uint32_t *s = (const uint32_t *)source;
const uint32_t *s = (const uint32_t *) source;
for (i = 0; i < length / sizeof(uint32_t); i++)
d[i] = s[i];
}
else
{
uint8_t * d = (uint8_t*)destination;
const uint8_t * s = (const uint8_t*)source;
} else {
uint8_t *d = (uint8_t *) destination;
const uint8_t *s = (const uint8_t *) source;
for (i = 0; i < length; i++)
d[i] = s[i];
@ -55,7 +38,7 @@ void swap(char *x, char *y) {
*y = t;
}
char * reverse(char * buffer, int i, int j) {
char *reverse(char *buffer, int i, int j) {
while (i < j) {
swap(&buffer[i++], &buffer[j--]);
}
@ -67,7 +50,7 @@ int abs(int value) {
return value < 0 ? -value : value;
}
char addSpaces(char * str, char qty) {
char addSpaces(char *str, char qty) {
char aux = qty;
while (qty-- > 0) {
*str++ = ' ';
@ -75,7 +58,7 @@ char addSpaces(char * str, char qty) {
return aux;
}
char * itoa(int value, char * buffer, int base, int length) {
char *itoa(int value, char *buffer, int base, int length) {
if (base < 2 || base > 32) {
return buffer;
}
@ -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,11 +89,7 @@ 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 strcpy(char *strDest, const char *strSrc) {
int i = 0;
while ((*strDest++ = *strSrc++)) {
i++;

10
Kernel/moduleLoader.c
View File

@ -3,22 +3,22 @@
#include <moduleLoader.h>
#include <naiveConsole.h>
static uint32_t readUint32(uint8_t ** address) {
uint32_t result = *(uint32_t*)(*address);
static uint32_t readUint32(uint8_t **address) {
uint32_t result = *(uint32_t *)(*address);
*address += sizeof(uint32_t);
return result;
}
static void loadModule(uint8_t ** module, void * targetModuleAddress) {
static void loadModule(uint8_t **module, void *targetModuleAddress) {
uint32_t moduleSize = readUint32(module);
memcpy(targetModuleAddress, *module, moduleSize);
*module += moduleSize;
}
void loadModules(void * payloadStart, void ** targetModuleAddress) {
void loadModules(void *payloadStart, void **targetModuleAddress) {
int i;
uint8_t * currentModule = (uint8_t*)payloadStart;
uint8_t *currentModule = (uint8_t *) payloadStart;
uint32_t moduleCount = readUint32(&currentModule);
for (i = 0; i < moduleCount; i++)

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;

196
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) {
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. */
@ -63,7 +62,7 @@ typedef struct xHeapStats
} HeapStats_t;
/* Prototype of the vPortGetHeapStats() function. */
void vPortGetHeapStats( HeapStats_t *xHeapStats );
void vPortGetHeapStats(HeapStats_t *xHeapStats);
/*-----------------------------------------------------------*/
@ -73,19 +72,20 @@ void vPortGetHeapStats( HeapStats_t *xHeapStats );
* the block in front it and/or the block behind it if the memory blocks are
* adjacent to each other.
*/
static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert );
static void prvInsertBlockIntoFreeList(BlockLink_t *pxBlockToInsert);
/*
* Called automatically to setup the required heap structures the first time
* pvPortMalloc() is called.
*/
static void prvHeapInit( void );
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 )
{
BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
void *pvReturn = NULL;
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,43 +119,37 @@ 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 ) );
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 );
pvReturn = (void *) (((uint8_t *) pxPreviousBlock->pxNextFreeBlock) + xHeapStructSize);
/* This block is being returned for use so must be taken out
of the list of free blocks. */
@ -165,13 +157,12 @@ 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
compiler. */
pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
pxNewBlockLink = (void *) (((uint8_t *) pxBlock) + xWantedSize);
// configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );
/* Calculate the sizes of two blocks split from the
@ -180,13 +171,12 @@ void *pvReturn = NULL;
pxBlock->xBlockSize = xWantedSize;
/* Insert the new block into the list of free blocks. */
prvInsertBlockIntoFreeList( pxNewBlockLink );
prvInsertBlockIntoFreeList(pxNewBlockLink);
}
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,30 +202,27 @@ void *pvReturn = NULL;
// configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
return pvReturn;
}
/*-----------------------------------------------------------*/
void vPortFree( void *pv )
{
uint8_t *puc = ( uint8_t * ) pv;
BlockLink_t *pxLink;
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;
/* This casting is to keep the compiler from issuing warnings. */
pxLink = ( void * ) puc;
pxLink = (void *) puc;
/* Check the block is actually allocated. */
// 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;
@ -244,70 +230,69 @@ BlockLink_t *pxLink;
{
/* Add this block to the list of free blocks. */
xFreeBytesRemaining += pxLink->xBlockSize;
prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
prvInsertBlockIntoFreeList(((BlockLink_t *) pxLink));
xNumberOfSuccessfulFrees++;
}
}
}
}
}
/*-----------------------------------------------------------*/
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 )
{
BlockLink_t *pxFirstFreeBlock;
uint8_t *pucAlignedHeap;
size_t uxAddress;
size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
static void prvHeapInit(void) {
BlockLink_t *pxFirstFreeBlock;
uint8_t *pucAlignedHeap;
size_t uxAddress;
size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
/* Ensure the heap starts on a correctly aligned boundary. */
uxAddress = ( size_t ) ucHeap;
uxAddress = (size_t) ucHeap;
if( ( uxAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
{
uxAddress += ( portBYTE_ALIGNMENT - 1 );
uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
xTotalHeapSize -= uxAddress - ( size_t ) ucHeap;
if ((uxAddress & portBYTE_ALIGNMENT_MASK) != 0) {
uxAddress += (portBYTE_ALIGNMENT - 1);
uxAddress &= ~((size_t)portBYTE_ALIGNMENT_MASK);
xTotalHeapSize -= uxAddress - (size_t) ucHeap;
}
pucAlignedHeap = ( uint8_t * ) uxAddress;
pucAlignedHeap = (uint8_t *) uxAddress;
/* xStart is used to hold a pointer to the first item in the list of free
blocks. The void cast is used to prevent compiler warnings. */
xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
xStart.xBlockSize = ( size_t ) 0;
xStart.pxNextFreeBlock = (void *) pucAlignedHeap;
xStart.xBlockSize = (size_t) 0;
/* pxEnd is used to mark the end of the list of free blocks and is inserted
at the end of the heap space. */
uxAddress = ( ( size_t ) pucAlignedHeap ) + xTotalHeapSize;
uxAddress = ((size_t) pucAlignedHeap) + xTotalHeapSize;
uxAddress -= xHeapStructSize;
uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
pxEnd = ( void * ) uxAddress;
uxAddress &= ~((size_t)portBYTE_ALIGNMENT_MASK);
pxEnd = (void *) uxAddress;
pxEnd->xBlockSize = 0;
pxEnd->pxNextFreeBlock = NULL;
/* To start with there is a single free block that is sized to take up the
entire heap space, minus the space taken by pxEnd. */
pxFirstFreeBlock = ( void * ) pucAlignedHeap;
pxFirstFreeBlock->xBlockSize = uxAddress - ( size_t ) pxFirstFreeBlock;
pxFirstFreeBlock = (void *) pucAlignedHeap;
pxFirstFreeBlock->xBlockSize = uxAddress - (size_t) pxFirstFreeBlock;
pxFirstFreeBlock->pxNextFreeBlock = pxEnd;
/* Only one block exists - and it covers the entire usable heap space. */
@ -315,49 +300,42 @@ size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
/* Work out the position of the top bit in a size_t variable. */
xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );
xBlockAllocatedBit = ((size_t) 1) << ((sizeof(size_t) * heapBITS_PER_BYTE) - 1);
}
/*-----------------------------------------------------------*/
static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert )
{
BlockLink_t *pxIterator;
uint8_t *puc;
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 )
{
puc = (uint8_t *) pxIterator;
if ((puc + pxIterator->xBlockSize) == (uint8_t *) pxBlockToInsert) {
pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
pxBlockToInsert = pxIterator;
}
/* 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 )
{
puc = (uint8_t *) pxBlockToInsert;
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,44 +343,40 @@ 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 )
{
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. */
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. */
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;
}
/* Move to the next block in the chain until the last block is
reached. */
pxBlock = pxBlock->pxNextFreeBlock;
} while( pxBlock != pxEnd );
} while (pxBlock != pxEnd);
}
pxHeapStats->xSizeOfLargestFreeBlockInBytes = xMaxSize;

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) {

66
Kernel/utils/pipe.c
View File

@ -2,10 +2,10 @@
static int fdIndex = 2;
node_t * firstPipe;
node_t *firstPipe;
char openPipe(int fds[2], char * name) {
pipe_t * pipe = pvPortMalloc(sizeof(pipe_t));
char openPipe(int fds[2], char *name) {
pipe_t *pipe = pvPortMalloc(sizeof(pipe_t));
pipe->name = pvPortMalloc(MAX_NAME);
pipe->buffer = pvPortMalloc(PIPE_MAX_SIZE);
strcpy(pipe->name, name);
@ -16,7 +16,7 @@ char openPipe(int fds[2], char * name) {
if ((pipe->fullSem = semOpen(FULL_SEM_NAME, 0)) == NULL)
return EXIT_FAILURE;
node_t * node = pvPortMalloc(sizeof(node_t));
node_t *node = pvPortMalloc(sizeof(node_t));
node->pipe = pipe;
node->next = firstPipe;
firstPipe = node;
@ -31,60 +31,60 @@ char openPipe(int fds[2], char * name) {
return EXIT_SUCCESS;
}
node_t * searchPipe(node_t ** previous, int fd) {
node_t * curr = firstPipe;
* previous = NULL;
node_t *searchPipe(node_t **previous, int fd) {
node_t *curr = firstPipe;
*previous = NULL;
while (curr != NULL) {
if (curr->pipe->fd[0] == fd || curr->pipe->fd[1] == fd) {
break;
}
* previous = curr;
*previous = curr;
curr = curr->next;
}
if (curr == NULL) {
* previous = NULL;
*previous = NULL;
return NULL;
}
return curr;
}
node_t * searchWPipe(node_t ** previous, int fd) {
node_t * curr = firstPipe;
* previous = NULL;
node_t *searchWPipe(node_t **previous, int fd) {
node_t *curr = firstPipe;
*previous = NULL;
while (curr != NULL) {
if (curr->pipe->fd[1] == fd) {
break;
}
* previous = curr;
*previous = curr;
curr = curr->next;
}
if (curr == NULL) {
* previous = NULL;
*previous = NULL;
return NULL;
}
return curr;
}
node_t * searchRPipe(node_t ** previous, int fd) {
node_t * curr = firstPipe;
* previous = NULL;
node_t *searchRPipe(node_t **previous, int fd) {
node_t *curr = firstPipe;
*previous = NULL;
while (curr != NULL) {
if (curr->pipe->fd[0] == fd) {
break;
}
* previous = curr;
*previous = curr;
curr = curr->next;
}
if (curr == NULL) {
* previous = NULL;
*previous = NULL;
return NULL;
}
return curr;
}
void writePipe(int fd, char c) {
node_t * prev = NULL;
node_t * node = searchWPipe(&prev, fd);
node_t *prev = NULL;
node_t *node = searchWPipe(&prev, fd);
semWait(node->pipe->sem);
@ -96,8 +96,8 @@ void writePipe(int fd, char c) {
}
char readPipe(int fd) {
node_t * prev = NULL;
node_t * node = searchRPipe(&prev, fd);
node_t *prev = NULL;
node_t *node = searchRPipe(&prev, fd);
semWait(node->pipe->sem);
@ -111,8 +111,8 @@ char readPipe(int fd) {
}
void closePipe(int fd) {
node_t * prev = NULL;
node_t * del = searchPipe(&prev, fd);
node_t *prev = NULL;
node_t *del = searchPipe(&prev, fd);
if (del == NULL)
return;
@ -130,7 +130,7 @@ void closePipe(int fd) {
vPortFree(del);
}
void getGenPipeData(char ** out, char * written, char toAdd, char * in, char isLast) {
void getGenPipeData(char **out, char *written, char toAdd, char *in, char isLast) {
char copied = strcpy(*out, in);
*out += copied;
*out += addSpaces(*out, toAdd - copied);
@ -141,7 +141,7 @@ void getGenPipeData(char ** out, char * written, char toAdd, char * in, char isL
}
}
char getPipeData(char * out, node_t * node) {
char getPipeData(char *out, node_t *node) {
if (node == NULL)
return EXIT_FAILURE;
@ -164,21 +164,21 @@ char getPipeData(char * out, node_t * node) {
char buffer[10];
getGenPipeData(&out, &written, MAX_ATTR_SIZE, itoa(node->pipe->fd[0], buffer, 10, 2), 0);
getGenPipeData(&out, &written, MAX_ATTR_SIZE, itoa(node->pipe->fd[1], buffer, 16, 10), 0);
char * aux = getEntering(node->pipe->sem);
char *aux = getEntering(node->pipe->sem);
getGenPipeData(&out, &written, MAX_PIDS_SIZE, aux, 1);
vPortFree(aux);
return written;
}
char * pipes(){
char * ans = pvPortMalloc((fdIndex / 2) * PIPE_DATA_MAX_SIZE);
char * ret = ans;
char *pipes() {
char *ans = pvPortMalloc((fdIndex / 2) * PIPE_DATA_MAX_SIZE);
char *ret = ans;
char * info = "name fdIn fdOut pids\n";
char *info = "name fdIn fdOut pids\n";
ans += strcpy(ans, info);
node_t * aux = firstPipe;
node_t *aux = firstPipe;
while (aux != NULL) {
char writtenChars = getPipeData(ans, aux);
if (writtenChars == EXIT_FAILURE)

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;
// }

118
Kernel/utils/scheduler.c
View File

@ -1,13 +1,12 @@
#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;
char * name;
struct processCDT *next;
char *name;
int pid;
int ppid;
uint64_t rsp;
@ -16,7 +15,7 @@ typedef struct processCDT {
char executions;
char foreground;
enum states state;
int * fd;
int *fd;
int children;
char backWait;
} processCDT;
@ -25,30 +24,29 @@ typedef struct sleepCDT {
int pid;
long time;
long secs;
struct sleepCDT * next;
struct sleepCDT *next;
} sleepCDT;
processCDT * firstBlockedIteration = NULL;
processCDT *firstBlockedIteration = NULL;
processCDT * firstProcess = NULL;
processCDT * lastProcess = NULL;
sleepCDT * firstSleep = NULL;
processCDT *firstProcess = NULL;
processCDT *lastProcess = NULL;
sleepCDT *firstSleep = NULL;
static processCDT * currentProcess = NULL;
static processCDT *currentProcess = NULL;
static int pids = IDLE_PID;
static char update = 1;
static char idleFlag = 2;
void removeProcess(processCDT * del, processCDT ** first, processCDT ** last) {
processCDT * prev = NULL;
void removeProcess(processCDT *del, processCDT **first, processCDT **last) {
processCDT *prev = NULL;
del = searchProcess(&prev, del->pid, *first);
if (prev == NULL) {
*first = del->next;
if (*last == del)
*last = NULL;
}
else {
} else {
prev->next = del->next;
if (*last == del)
*last = prev;
@ -58,28 +56,28 @@ void removeProcess(processCDT * del, processCDT ** first, processCDT ** last) {
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) {
processCDT *prev = currentProcess;
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) {
processCDT * del = currentProcess;
} 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;
@ -102,13 +100,13 @@ void idle() {
}
void initScheduler() {
char * argv[] = {"idle"};
char *argv[] = {"idle"};
nice(enqueueProcess(idle, 0, 1, argv, NULL), 19);
}
int enqueueProcess(void (*fn) (int, char **), char foreground, int argc, char *argv[], int * fd) {
int enqueueProcess(void (*fn)(int, char **), char foreground, int argc, char *argv[], int *fd) {
if (fd == NULL) {
int * aux = pvPortMalloc(2 * sizeof(int));
int *aux = pvPortMalloc(2 * sizeof(int));
aux[0] = 0;
aux[1] = 1;
fd = aux;
@ -126,13 +124,13 @@ int enqueueProcess(void (*fn) (int, char **), char foreground, int argc, char *a
}
processADT process = pvPortMalloc(sizeof(processCDT));
uint64_t * auxi = pvPortMalloc(STACK_SIZE);
uint64_t * rbp = STACK_SIZE + auxi;
uint64_t * rsp = rbp - 20;
uint64_t *auxi = pvPortMalloc(STACK_SIZE);
uint64_t *rbp = STACK_SIZE + auxi;
uint64_t *rsp = rbp - 20;
char priority = (foreground == 1) ? DEF_PRIORITY : MAX_PRIORITY/2;
char priority = (foreground == 1) ? DEF_PRIORITY : MAX_PRIORITY / 2;
char * aux = pvPortMalloc(10);
char *aux = pvPortMalloc(10);
int j;
for (j = 0; j < MAX_NAME_SIZE - 1 && argv[0][j] != 0; j++) {
aux[j] = argv[0][j];
@ -168,7 +166,7 @@ void sleep(int secs) {
if (currentProcess == NULL)
return;
sleepCDT * proc = pvPortMalloc(sizeof(sleepCDT));
sleepCDT *proc = pvPortMalloc(sizeof(sleepCDT));
proc->pid = currentProcess->pid;
proc->secs = secs;
proc->time = getTimeOfDay();
@ -178,7 +176,7 @@ void sleep(int secs) {
block(currentProcess->pid);
}
void wakeUp(sleepCDT * wake, sleepCDT * prev) {
void wakeUp(sleepCDT *wake, sleepCDT *prev) {
if (wake == firstSleep)
firstSleep = wake->next;
else {
@ -189,40 +187,39 @@ void wakeUp(sleepCDT * wake, sleepCDT * prev) {
}
void checkSleeping() {
sleepCDT * prev = NULL;
sleepCDT * aux = firstSleep;
while(aux != NULL) {
sleepCDT *prev = NULL;
sleepCDT *aux = firstSleep;
while (aux != NULL) {
if (getTimeOfDay() >= aux->time + aux->secs) {
wakeUp(aux, prev);
aux = prev->next;
}
else {
} else {
prev = aux;
aux = aux->next;
}
}
}
processADT searchProcess(processADT * previous, int pid, processADT first) {
processADT searchProcess(processADT *previous, int pid, processADT first) {
processADT curr = first;
* previous = NULL;
*previous = NULL;
while (curr != NULL) {
if (curr->pid == pid) {
break;
}
* previous = curr;
*previous = curr;
curr = curr->next;
}
if (curr == NULL) {
* previous = NULL;
*previous = NULL;
return NULL;
}
return curr;
}
void unblockIO() {
processCDT * aux = firstProcess;
while(aux != NULL) {
processCDT *aux = firstProcess;
while (aux != NULL) {
if (aux->state == BLOCKEDIO)
aux->state = READY;
@ -237,7 +234,7 @@ char blockIO() {
currentProcess->state = BLOCKEDIO;
}
processCDT * prev = NULL;
processCDT *prev = NULL;
processADT parent = searchProcess(&prev, currentProcess->ppid, firstProcess);
if (currentProcess->foreground) {
if (parent->backWait) {
@ -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;
@ -391,7 +386,7 @@ char isForeground() {
return currentProcess->foreground;
}
void getGenProcessData(char ** out, char * written, char toAdd, char * in, char isLast) {
void getGenProcessData(char **out, char *written, char toAdd, char *in, char isLast) {
char copied = strcpy(*out, in);
*out += copied;
*out += addSpaces(*out, toAdd - copied);
@ -402,7 +397,7 @@ void getGenProcessData(char ** out, char * written, char toAdd, char * in, char
}
}
char getProcessData(char * out, processCDT * proc) {
char getProcessData(char *out, processCDT *proc) {
if (proc == NULL)
return EXIT_FAILURE;
@ -428,19 +423,20 @@ 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;
}
char * processes(){
char * ans = pvPortMalloc(pids * PROCESS_DATA_MAX_SIZE);
char * ret = ans;
char *processes() {
char *ans = pvPortMalloc(pids * PROCESS_DATA_MAX_SIZE);
char *ret = ans;
char * info = "name pid prio rsp rbp fore state\n";
char *info = "name pid prio rsp rbp fore state\n";
ans += strcpy(ans, info);
processCDT * aux = firstProcess;
processCDT *aux = firstProcess;
while (aux != NULL) {
char writtenChars = getProcessData(ans, aux);
if (writtenChars == EXIT_FAILURE)

59
Kernel/utils/sem.c
View File

@ -3,18 +3,18 @@
static uint32_t semLock;
typedef struct node_t {
sem_t * sem;
struct node_t * next;
sem_t *sem;
struct node_t *next;
} node_t;
node_t * firstSem = NULL;
node_t *firstSem = NULL;
static char counter = 0;
sem_t * semOpen(char * name, unsigned int value) {
sem_t *semOpen(char *name, unsigned int value) {
enter_region(&semLock);
sem_t * sem = pvPortMalloc(sizeof(sem_t));
node_t * node = pvPortMalloc(sizeof(node_t));
sem_t *sem = pvPortMalloc(sizeof(sem_t));
node_t *node = pvPortMalloc(sizeof(node_t));
node->sem = sem;
node->next = firstSem;
firstSem = node;
@ -28,27 +28,27 @@ sem_t * semOpen(char * name, unsigned int value) {
return sem;
}
char semClose(sem_t * sem) {
char semClose(sem_t *sem) {
if (sem == NULL)
return EXIT_FAILURE;
enter_region(&semLock);
node_t * del = NULL;
node_t *del = NULL;
if (firstSem->sem == sem) {
del = firstSem;
firstSem = firstSem->next;
}
else {
node_t * aux = firstSem;
} 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;
}
}
@ -58,9 +58,9 @@ char semClose(sem_t * sem) {
return EXIT_FAILURE;
}
pid_t * pid = sem->entering;
pid_t *pid = sem->entering;
while (pid != NULL) {
pid_t * aux = pid;
pid_t *aux = pid;
pid = pid->next;
vPortFree(aux);
}
@ -74,16 +74,15 @@ char semClose(sem_t * sem) {
return EXIT_SUCCESS;
}
void semWait(sem_t * sem) {
void semWait(sem_t *sem) {
enter_region(&semLock);
if (sem->value > 0) {
sem->value--;
}
else {
} else {
leave_region(&semLock);
pid_t * curr = pvPortMalloc(sizeof(pid_t));
pid_t *curr = pvPortMalloc(sizeof(pid_t));
curr->pid = getPid();
curr->next = NULL;
if (sem->entering == NULL)
@ -100,13 +99,13 @@ void semWait(sem_t * sem) {
leave_region(&semLock);
}
void semPost(sem_t * sem) {
void semPost(sem_t *sem) {
enter_region(&semLock);
sem->value++;
if (sem->entering != NULL) {
pid_t * aux = sem->entering;
pid_t *aux = sem->entering;
sem->entering = sem->entering->next;
if (sem->entering == NULL)
sem->last = NULL;
@ -117,7 +116,7 @@ void semPost(sem_t * sem) {
leave_region(&semLock);
}
char getSemaphoresData(char * out, node_t * node) {
char getSemaphoresData(char *out, node_t *node) {
if (node == NULL)
return EXIT_FAILURE;
@ -157,11 +156,9 @@ 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;
char *getEntering(sem_t *sem) {
char *ans = pvPortMalloc(sizeof(pid_t * ));
pid_t *aux = sem->entering;
char buffer[MAX_PID];
while (aux != NULL) {
strcpy(ans, itoa(aux->pid, buffer, 10, 3));
@ -172,14 +169,14 @@ char * getEntering(sem_t * sem){
return ans;
}
char * getSems() {
char * ans = pvPortMalloc(counter * SEM_DATA_MAX_SIZE);
char * ret = ans;
char *getSems() {
char *ans = pvPortMalloc(counter * SEM_DATA_MAX_SIZE);
char *ret = ans;
char * info = "name value pidsWaiting\n";
char *info = "name value pidsWaiting\n";
ans += strcpy(ans, info);
node_t * aux = firstSem;
node_t *aux = firstSem;
while (aux != NULL) {
char writtenChars = getSemaphoresData(ans, aux);
if (writtenChars == EXIT_FAILURE)

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

13
Userland/SampleCodeModule/_loader.c
View File

@ -1,4 +1,3 @@
/* _loader.c */
#include <stdint.h>
extern char bss;
@ -6,21 +5,19 @@ extern char endOfBinary;
int main(int argc, char *argv[]);
void * memset(void * destiny, int32_t c, uint64_t length);
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;
void * memset(void * destination, int32_t c, uint64_t length) {
uint8_t chr = (uint8_t)c;
char * dst = (char*)destination;
while(length--)
while (length--)
dst[length] = chr;
return destination;

91
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( " Welcome to", 17);
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( " %%%%% ", 27);
printStringLen( " %%%% %%%% ", 22);
printStringLen( " %%%%% ", 30); new_line();
printStringLen( " %%%%% ", 28);
printStringLen( " (% %( ", 21);
printStringLen( " %%%%% ", 30); new_line();
printStringLen( " %%%%%%% %%%%%%% ", 80); new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line();
void bottler(int argc, char **argv) {
printStringLen(" ", 80);
new_line();
printStringLen(" (%( ", 80);
new_line();
printStringLen(" Welcome to", 17);
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(" %%%%% ", 27);
printStringLen(" %%%% %%%% ", 22);
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(" %%%%%%%%%%%%%%%%%%%%%%% ", 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(" % %* ", 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();
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 *);

75
Userland/SampleCodeModule/libc.c
View File

@ -1,35 +1,35 @@
#include "libc.h"
void printString(char * string) {
void printString(char *string) {
int len = strlen(string);
sys_write(1, string, len);
}
void printStringLen(char * string, int len) {
void printStringLen(char *string, int len) {
sys_write(1, string, len);
}
void printStringError(char * string) {
void printStringError(char *string) {
int len = strlen(string);
sys_write(2, string, len);
}
int strlen(const char * s) {
int strlen(const char *s) {
int i = 0;
for (i = 0; s[i] != '\0'; i++);
return i;
}
int strcmp(const char * s1, const char * s2) {
while(*s1 && (*s1 == *s2)) {
int strcmp(const char *s1, const char *s2) {
while (*s1 && (*s1 == *s2)) {
s1++;
s2++;
}
return *s1 - *s2;
}
char * strcat(char * dest, const char * src) {
char * rdest = dest;
char *strcat(char *dest, const char *src) {
char *rdest = dest;
while (*dest)
dest++;
@ -37,7 +37,7 @@ char * strcat(char * dest, const char * src) {
return rdest;
}
void putChar(char c){
void putChar(char c) {
char buffer = c;
sys_write(1, &buffer, 0);
}
@ -54,7 +54,7 @@ void winClear() {
sys_write(1, "\e\f", 2);
}
int strcpy(char * strDest, const char * strSrc) {
int strcpy(char *strDest, const char *strSrc) {
int i = 0;
while ((*strDest++ = *strSrc++)) {
i++;
@ -62,7 +62,7 @@ int strcpy(char * strDest, const char * strSrc) {
return i;
}
char* gtoa(int value, char* buffer, int base, int length) {
char *gtoa(int value, char *buffer, int base, int length) {
if (base < 2 || base > 32) {
return buffer;
}
@ -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,10 +101,12 @@ 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) {
char *reverse(char *buffer, int i, int j) {
while (i < j) {
swap(&buffer[i++], &buffer[j--]);
}
@ -117,7 +118,7 @@ int abs(int value) {
return value < 0 ? -value : value;
}
char* itoa(int value, char* buffer, int base) {
char *itoa(int value, char *buffer, int base) {
if (base < 2 || base > 32) {
return buffer;
}
@ -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') {
@ -184,7 +176,7 @@ int pow(int base, int exponent) {
return result;
}
char isFloat(char * str) {
char isFloat(char *str) {
int dot = 0;
if (*str == '-')
str++;
@ -201,8 +193,8 @@ char isFloat(char * str) {
float atof(char *arr) {
float val = 0;
int afterdot=0;
float scale=1;
int afterdot = 0;
float scale = 1;
int neg = 0;
if (*arr == '-') {
@ -211,8 +203,8 @@ float atof(char *arr) {
}
while (*arr) {
if (afterdot) {
scale = scale/10;
val = val + (*arr-'0')*scale;
scale = scale / 10;
val = val + (*arr - '0') * scale;
} else {
if (*arr == '.')
afterdot++;
@ -221,11 +213,11 @@ float atof(char *arr) {
}
arr++;
}
if(neg) return -val;
if (neg) return -val;
else return val;
}
char * strstrip(char * s, char c) {
char *strstrip(char *s, char c) {
while (*s != 0) {
if (*s != c)
break;
@ -234,7 +226,7 @@ char * strstrip(char * s, char c) {
return s;
}
char *strtok(char * s, char delim) {
char *strtok(char *s, char delim) {
char *ptr = s;
if (s == 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++;
}
@ -262,7 +253,7 @@ char isNumber(char c) {
#define MAX_PRECISION (10)
static const double rounders[MAX_PRECISION + 1] =
{
{
0.5, // 0
0.05, // 1
0.005, // 2
@ -274,12 +265,12 @@ static const double rounders[MAX_PRECISION + 1] =
0.000000005, // 8
0.0000000005, // 9
0.00000000005 // 10
};
};
void ftoa(double f, char * buf, int precision) {
char * ptr = buf;
char * p = ptr;
char * p1;
void ftoa(double f, char *buf, int precision) {
char *ptr = buf;
char *p = ptr;
char *p1;
char c;
long intPart;

9
Userland/SampleCodeModule/sampleCodeModule.c
View File

@ -1,20 +1,17 @@
/* 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();
char * argv1[] = {"bottler"};
char *argv1[] = {"bottler"};
sys_loadProcess(bottler, 1, 1, argv1, NULL);
sys_wait();
char * argv2[] = {"shell"};
char *argv2[] = {"shell"};
sys_loadProcess(shell, 1, 1, argv2, NULL);
sys_exit();

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

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

@ -1,32 +1,32 @@
#include "shell.h"
cmd_t commands[] = {
{ "help", help, 0, 1},
{ "cat", cat, 0, 1},
{ "time", time, 0, 1},
{ "block", block, 1, 1},
{ "unblock", unblock, 1, 1},
{ "inforeg", inforeg, 0, 1},
{ "excdiv", excdiv, 1, 1},
{ "excop", excop, 1, 1},
{ "filter", filter, 0, 1},
{ "clear", clear, 1, 1},
{ "cpufeatures", cpufeatures, 0, 1},
{ "nice", nice, 0, 1},
{ "ps", ps, 0, 1},
{ "pipes", pipes, 0, 1},
{ "kill", kill, 1, 1},
{ "sem", sem, 0, 1},
{ "quadratic", quadratic, 0, 1},
{ "printmem", printmem, 0, 1},
{ "phylo", phylo, 0, 1},
{ "wc", wc, 0, 1},
{ "loop", loop, 0, 0},
{ "loopcaca", loop, 0, 1},
{ NULL, NULL, 0, 0}
{"help", help, 0, 1},
{"cat", cat, 0, 1},
{"time", time, 0, 1},
{"block", block, 1, 1},
{"unblock", unblock, 1, 1},
{"inforeg", inforeg, 0, 1},
{"excdiv", excdiv, 1, 1},
{"excop", excop, 1, 1},
{"filter", filter, 0, 1},
{"clear", clear, 1, 1},
{"cpufeatures", cpufeatures, 0, 1},
{"nice", nice, 0, 1},
{"ps", ps, 0, 1},
{"pipes", pipes, 0, 1},
{"kill", kill, 1, 1},
{"sem", sem, 0, 1},
{"quadratic", quadratic, 0, 1},
{"printmem", printmem, 0, 1},
{"phylo", phylo, 0, 1},
{"wc", wc, 0, 1},
{"loop", loop, 0, 0},
{"loopcaca", loop, 0, 1},
{NULL, NULL, 0, 0}
};
int scanfNoPrint(char * buffer) {
int scanfNoPrint(char *buffer) {
char c;
int i = 0;
while ((c = getChar()) != '\n' && i < SIZE - 1) {
@ -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);
}
@ -45,9 +44,9 @@ int scanfNoPrint(char * buffer) {
return i;
}
void processInput(char * input) {
void processInput(char *input) {
int comm_flag0 = 0, comm_flag1 = 0, pipe = -1, end = -1, ampersand = -1;
char* tokens[SIZE] = {0};
char *tokens[SIZE] = {0};
tokens[0] = strstrip(input, ' ');
for (int i = 1; i < MAX_ARGS; i++) {
tokens[i] = strtok(tokens[i - 1], ' ');
@ -56,7 +55,7 @@ void processInput(char * input) {
pipe = i - 1;
}
if (tokens[i][0] == 0) {
if (i > 1 && !strcmp(tokens[i-1], "&")) {
if (i > 1 && !strcmp(tokens[i - 1], "&")) {
ampersand = end = i - 1;
break;
}
@ -70,7 +69,7 @@ void processInput(char * input) {
return;
}
int * fd, * fd1, * fd2;
int *fd, *fd1, *fd2;
fd1 = sys_malloc(2 * sizeof(int));
fd1[0] = 0;
fd1[1] = 1;
@ -86,8 +85,8 @@ void processInput(char * input) {
fd2[0] = fd[0];
fd2[1] = 1;
}
char ** argv0 = NULL;
char ** argv1 = NULL;
char **argv0 = NULL;
char **argv1 = NULL;
int comm0 = -1;
int comm1 = -1;
@ -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,21 +150,19 @@ 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) {
void incorrect_comm(char *buffer) {
printString(buffer);
printStringLen(" is not a BottlerShell command\n", 32);
}
void incorrect_arg(char * command) {
void incorrect_arg(char *command) {
printStringLen("Incorrect arguments for command ", 33);
printString(command);
new_line();