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 index.html
.bashrc .bashrc
.vscode/* .vscode/*
.idea/
#Binary Files #Binary Files
*.bin *.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 $@ $^ $(LD) $(LDFLAGS) -T kernel.ld --oformat=elf64-x86-64 -o $@ $^
%.o: %.c %.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 %.o : %.asm
$(ASM) $(ASMFLAGS) $< -o $@ $(ASM) $(ASMFLAGS) $< -o $@

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

@ -2,7 +2,9 @@
#define KEYBOARD_H #define KEYBOARD_H
#include <stdint.h> #include <stdint.h>
#include "schedulerLib.h" #include "../../utils/include/schedulerLib.h"
#define SIZE 1
void keyboard_handler(); void keyboard_handler();
unsigned char getKeyFromBuffer(); 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_ #ifndef TIME_H
#define _TIME_H_ #define TIME_H
void timer_handler(); void timer_handler();
int ticks_elapsed(); int ticks_elapsed();
@ -14,7 +14,6 @@ int seconds_elapsed();
int getTimeGen(char option); int getTimeGen(char option);
int getTime(char option); int getTime(char option);
// void wait(long seconds);
long getTimeOfDay(); long getTimeOfDay();
#endif #endif

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

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

197
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_sh[250];
// static unsigned char kbdsp[250]; // static unsigned char kbdsp[250];
#define SIZE 1
unsigned char buffer[SIZE] = {0}; unsigned char buffer[SIZE] = {0};
unsigned char * current = buffer; unsigned char *current = buffer;
unsigned char * last = buffer; unsigned char *last = buffer;
void saveChar(unsigned char c) { void saveChar(unsigned char c) {
*last++ = c; *last++ = c;
@ -24,35 +23,26 @@ void testKeyboardInterrupt(unsigned char c) {
if (c == 0x2A || c == 0x36) { if (c == 0x2A || c == 0x36) {
flag = 0; flag = 0;
return; return;
} } else if (c == 0xAA || c == 0xB6) {
else if (c == 0xAA || c == 0xB6) {
flag = 1; flag = 1;
return; return;
} } else if (c == 0x3A) {
else if (c == 0x3A) {
flag = ~(flag | 0xFE); flag = ~(flag | 0xFE);
} else if (c == 0x38) {
flagChangeAlt = 0;
} else if (c == 0x3B) {
flagChangeF1 = 0;
} }
else if (c == 0x38) {
flagChangeAlt = 0;
}
else if (c == 0x3B) {
flagChangeF1 = 0;
}
if (flagChangeAlt == 0 && flagChangeF1 == 0) { if (flagChangeAlt == 0 && flagChangeF1 == 0) {
flagChangeAlt = 1; flagChangeAlt = 1;
flagChangeF1 = 1; flagChangeF1 = 1;
saveChar('\v'); saveChar('\v');
return; return;
} } else if (c == 0xB8) {
else if (c == 0xB8) {
flagChangeAlt = 1; flagChangeAlt = 1;
return; return;
} } else if (c == 0xBB) {
else if (c == 0xBB) {
flagChangeF1 = 1; flagChangeF1 = 1;
return; return;
} }
@ -60,23 +50,22 @@ void testKeyboardInterrupt(unsigned char c) {
if (flag == 0) { if (flag == 0) {
c = kbdus_sh[c]; c = kbdus_sh[c];
if (c != 0) if (c != 0)
saveChar(c); saveChar(c);
} } else {
else {
c = kbdus[c]; c = kbdus[c];
if (c != 0) if (c != 0)
saveChar(c); saveChar(c);
} }
} }
unsigned char getKeyFromBuffer() { unsigned char getKeyFromBuffer() {
if (current - buffer == SIZE) { if (current - buffer == SIZE) {
current = buffer; current = buffer;
} }
char aux = *current; char aux = *current;
*current++ = 0; *current++ = 0;
return aux; return aux;
} }
void keyboard_handler() { void keyboard_handler() {
@ -125,42 +114,42 @@ void keyboard_handler() {
// }; // };
static unsigned char kbdus[250] = { static unsigned char kbdus[250] = {
0, 27, '1', '2', '3', '4', '5', '6', '7', '8', /* 9 */ 0, 27, '1', '2', '3', '4', '5', '6', '7', '8', /* 9 */
'9', '0', '-', '=', '\b', /* Backspace */ '9', '0', '-', '=', '\b', /* Backspace */
'\t', /* Tab */ '\t', /* Tab */
'q', 'w', 'e', 'r', /* 19 */ 'q', 'w', 'e', 'r', /* 19 */
't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', /* Enter key */ 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', /* Enter key */
0, /* 29 - Control */ 0, /* 29 - Control */
'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', /* 39 */ 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', /* 39 */
'\'', '`', 0, /* Left shift */ '\'', '`', 0, /* Left shift */
'\\', 'z', 'x', 'c', 'v', 'b', 'n', /* 49 */ '\\', 'z', 'x', 'c', 'v', 'b', 'n', /* 49 */
'm', ',', '.', '/', 0, /* Right shift */ 'm', ',', '.', '/', 0, /* Right shift */
'*', '*',
0, /* Alt */ 0, /* Alt */
' ', /* Space bar */ ' ', /* Space bar */
0, /* Caps lock */ 0, /* Caps lock */
0, /* 59 - F1 key ... > */ 0, /* 59 - F1 key ... > */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, /* < ... F10 */ 0, /* < ... F10 */
0, /* 69 - Num lock*/ 0, /* 69 - Num lock*/
0, /* Scroll Lock */ 0, /* Scroll Lock */
0, /* Home key */ 0, /* Home key */
0, /* Up Arrow */ 0, /* Up Arrow */
0, /* Page Up */ 0, /* Page Up */
'-', '-',
0, /* Left Arrow */ 0, /* Left Arrow */
0, 0,
0, /* Right Arrow */ 0, /* Right Arrow */
'+', '+',
0, /* 79 - End key*/ 0, /* 79 - End key*/
0, /* Down Arrow */ 0, /* Down Arrow */
0, /* Page Down */ 0, /* Page Down */
0, /* Insert Key */ 0, /* Insert Key */
0, /* Delete Key */ 0, /* Delete Key */
0, 0, 0, 0, 0, 0,
0, /* F11 Key */ 0, /* F11 Key */
0, /* F12 Key */ 0, /* F12 Key */
0, /* All other keys are undefined */ 0, /* All other keys are undefined */
}; };
// static unsigned char kbdsp_sh[250] = // static unsigned char kbdsp_sh[250] =
@ -204,41 +193,41 @@ static unsigned char kbdus[250] = {
// }; // };
static unsigned char kbdus_sh[250] = static unsigned char kbdus_sh[250] =
{ {
0, 27, '!', '\"', '#', 0 /* shift+4 */, '%', '&', '/', '(', /* 9 */ 0, 27, '!', '\"', '#', 0 /* shift+4 */, '%', '&', '/', '(', /* 9 */
')', '=', '?', '`', '\b', /* Backspace */ ')', '=', '?', '`', '\b', /* Backspace */
'\t', /* Tab */ '\t', /* Tab */
'Q', 'W', 'E', 'R', /* 19 */ 'Q', 'W', 'E', 'R', /* 19 */
'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n', /* Enter key */ 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n', /* Enter key */
0, /* 29 - Control */ 0, /* 29 - Control */
'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', /* 39 */ 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', /* 39 */
'\'', '>', 0, /* Left shift */ '\'', '>', 0, /* Left shift */
'|', 'Z', 'X', 'C', 'V', 'B', 'N', /* 49 */ '|', 'Z', 'X', 'C', 'V', 'B', 'N', /* 49 */
'M', ';', ':', '_', 0, /* Right shift */ 'M', ';', ':', '_', 0, /* Right shift */
'*', '*',
0, /* Alt */ 0, /* Alt */
' ', /* Space bar */ ' ', /* Space bar */
0, /* Caps lock */ 0, /* Caps lock */
0, /* 59 - F1 key ... > */ 0, /* 59 - F1 key ... > */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, /* < ... F10 */ 0, /* < ... F10 */
0, /* 69 - Num lock*/ 0, /* 69 - Num lock*/
0, /* Scroll Lock */ 0, /* Scroll Lock */
0, /* Home key */ 0, /* Home key */
0, /* Up Arrow */ 0, /* Up Arrow */
0, /* Page Up */ 0, /* Page Up */
'-', '-',
0, /* Left Arrow */ 0, /* Left Arrow */
0, 0,
0, /* Right Arrow */ 0, /* Right Arrow */
'+', '+',
0, /* 79 - End key*/ 0, /* 79 - End key*/
0, /* Down Arrow */ 0, /* Down Arrow */
0, /* Page Down */ 0, /* Page Down */
0, /* Insert Key */ 0, /* Insert Key */
0, /* Delete Key */ 0, /* Delete Key */
0, 0, '>', 0, 0, '>',
0, /* F11 Key */ 0, /* F11 Key */
0, /* F12 Key */ 0, /* F12 Key */
0, /* All other keys are undefined */ 0, /* All other keys are undefined */
}; };

113
Kernel/drivers/naiveConsole.c
View File

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

86
Kernel/drivers/time.c
View File

@ -1,77 +1,55 @@
#include <time.h> #include "time.h"
static unsigned long ticks = 0; static unsigned long ticks = 0;
void timer_handler() { void timer_handler() {
ticks++; ticks++;
} }
int ticks_elapsed() { int ticks_elapsed() {
return ticks; return ticks;
} }
int seconds_elapsed() { int seconds_elapsed() {
// return ticks / 18; return ticks / 18;
return ticks / 18;
} }
int getTime(char option) { int getTime(char option) {
switch(option) { switch (option) {
case SECONDS: case SECONDS:
return getTimeGen(SECONDS); return getTimeGen(SECONDS);
case MINUTES: case MINUTES:
return getTimeGen(MINUTES); return getTimeGen(MINUTES);
case HOURS: case HOURS:
return getTimeGen(HOURS); return getTimeGen(HOURS);
case DAY: case DAY:
return getTimeGen(DAY); return getTimeGen(DAY);
case MONTH: case MONTH:
return getTimeGen(MONTH); return getTimeGen(MONTH);
case YEAR: case YEAR:
return getTimeGen(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() { static long getTimeFrom2000() {
long years = 00 * 31557600; long years = 00 * 31557600;
long months = 1 * 2629800; long months = 1 * 2629800;
long days = 1 * 86400; long days = 1 * 86400;
// long aux = years + months + days; return years + months + days;
return years + months + days;
} }
long getTimeOfDay() { long getTimeOfDay() {
// long years = getTimeGen(YEAR) - 1970; long years = getTimeGen(YEAR) * 31557600;
long months = getTimeGen(MONTH) * 2629800;
long days = getTimeGen(DAY) * 86400;
long hours = getTimeGen(HOURS) * 3600;
long minutes = getTimeGen(MINUTES) * 60;
long seconds = getTimeGen(SECONDS);
// obtengo los segundos actuales (sumando todas las variables) y los resto por los de 1970? long total = years + months + days + hours + minutes + seconds;
long years = getTimeGen(YEAR) * 31557600;
long months = getTimeGen(MONTH) * 2629800;
long days = getTimeGen(DAY) * 86400;
long hours = getTimeGen(HOURS) * 3600;
long minutes = getTimeGen(MINUTES) * 60;
long seconds = getTimeGen(SECONDS);
long total = years + months + days + hours + minutes + seconds; return total - getTimeFrom2000();
return total - getTimeFrom2000();
} }

141
Kernel/drivers/video.c
View File

@ -1,8 +1,6 @@
#include <stdint.h>
#include "video.h" #include "video.h"
static uint8_t * const video = (uint8_t *) 0xB8000; static uint8_t *const video = (uint8_t *) 0xB8000;
// static uint8_t * currentVideo = (uint8_t *) 0xB8000;
static const int width = 80; static const int width = 80;
static const int height = 25; static const int height = 25;
static int currentX = 0; static int currentX = 0;
@ -12,95 +10,92 @@ int limitX[2] = {0, 80};
int limitY[2] = {0, 25}; int limitY[2] = {0, 25};
void increment() { void increment() {
currentX++; currentX++;
if (currentX == limitX[1]) { if (currentX == limitX[1]) {
currentY++; currentY++;
currentX = limitX[0]; currentX = limitX[0];
if (currentY >= limitY[1]) { if (currentY >= limitY[1]) {
scroll(); scroll();
currentY = limitY[1] - 1; currentY = limitY[1] - 1;
} }
} }
} }
char checkIfEscapeSequence(const char * bufferAux) { char checkIfEscapeSequence(const char *bufferAux) {
if (*bufferAux == '\e') { if (*bufferAux == '\e') {
bufferAux++; bufferAux++;
if (*bufferAux == '\f') { if (*bufferAux == '\f') {
bufferAux++; clear();
clear(); }
} return 1;
return 1; }
} return 0;
return 0;
} }
void scroll() { void scroll() {
for (int i = limitY[0]; i < limitY[1] - 1; i++) { for (int i = limitY[0]; i < limitY[1] - 1; i++) {
for (int j = limitX[0]; j < limitX[1]; j++) { for (int j = limitX[0]; j < limitX[1]; j++) {
*(video + i * width * 2 + j * 2) = *(video + (i + 1) * width * 2 + j * 2); *(video + i * width * 2 + j * 2) = *(video + (i + 1) * width * 2 + j * 2);
*(video + i * width * 2 + j * 2 + 1) = *(video + (i + 1) * width * 2 + j * 2 + 1); *(video + i * width * 2 + j * 2 + 1) = *(video + (i + 1) * width * 2 + j * 2 + 1);
} }
} }
for (int j = limitX[0]; j < limitX[1]; j++) { for (int j = limitX[0]; j < limitX[1]; j++) {
*(video + (limitY[1] - 1) * width * 2 + j * 2) = ' '; *(video + (limitY[1] - 1) * width * 2 + j * 2) = ' ';
} }
} }
int printStringLen(int color, const char * string, int maxLen) { int printStringLen(int color, const char *string, int maxLen) {
int i = 0; int i = 0;
while (*string != '\0' && i <= maxLen) { while (*string != '\0' && i <= maxLen) {
if (*string == '\n') { if (*string == '\n') {
new_line(); new_line();
string++; string++;
i++; i++;
continue; continue;
} } else if (*string == '\b') {
else if (*string == '\b') { backspace();
backspace(); return i;
return i; } else if (checkIfEscapeSequence(string)) {
} return i;
else if (checkIfEscapeSequence(string)) { }
return i;
}
*(video + currentY * width * 2 + currentX * 2) = *string++; *(video + currentY * width * 2 + currentX * 2) = *string++;
*(video + currentY * width * 2 + currentX * 2 + 1) = color; *(video + currentY * width * 2 + currentX * 2 + 1) = color;
increment(); increment();
i++; i++;
} }
return i; return i;
} }
void backspace() { void backspace() {
if (video + currentY * width * 2 + currentX * 2 > video) { if (video + currentY * width * 2 + currentX * 2 > video) {
currentX--; currentX--;
if (currentX < limitX[0]) { if (currentX < limitX[0]) {
currentX = limitX[1]; currentX = limitX[1];
if (currentY > limitY[0]) if (currentY > limitY[0])
currentY--; currentY--;
} }
} }
*(video + currentY * width * 2 + currentX * 2) = ' '; *(video + currentY * width * 2 + currentX * 2) = ' ';
} }
void new_line() { void new_line() {
currentX = limitX[0]; currentX = limitX[0];
currentY++; currentY++;
if (currentY == limitY[1]) { if (currentY == limitY[1]) {
scroll(); scroll();
currentY = limitY[1] - 1; currentY = limitY[1] - 1;
} }
} }
void clear() { void clear() {
currentX = limitX[0]; currentX = limitX[0];
currentY = limitY[0]; currentY = limitY[0];
for (int i = limitY[0]; i < limitY[1]; i++) { for (int i = limitY[0]; i < limitY[1]; i++) {
for (int j = limitX[0]; j < limitX[1]; j++) { for (int j = limitX[0]; j < limitX[1]; j++) {
*(video + i * width * 2 + j * 2) = ' '; *(video + i * width * 2 + j * 2) = ' ';
} }
} }
} }

7
Kernel/include/defs.h
View File

@ -1,12 +1,6 @@
/***************************************************
Defs.h
****************************************************/
#ifndef _defs_ #ifndef _defs_
#define _defs_ #define _defs_
/* Flags para derechos de acceso de los segmentos */
#define ACS_PRESENT 0x80 /* segmento presente en memoria */ #define ACS_PRESENT 0x80 /* segmento presente en memoria */
#define ACS_CSEG 0x18 /* segmento de codigo */ #define ACS_CSEG 0x18 /* segmento de codigo */
#define ACS_DSEG 0x10 /* segmento de datos */ #define ACS_DSEG 0x10 /* segmento de datos */
@ -16,7 +10,6 @@
#define ACS_INT_386 0x0E /* Interrupt GATE 32 bits */ #define ACS_INT_386 0x0E /* Interrupt GATE 32 bits */
#define ACS_INT ( ACS_PRESENT | ACS_INT_386 ) #define ACS_INT ( ACS_PRESENT | ACS_INT_386 )
#define ACS_CODE (ACS_PRESENT | ACS_CSEG | ACS_READ) #define ACS_CODE (ACS_PRESENT | ACS_CSEG | ACS_READ)
#define ACS_DATA (ACS_PRESENT | ACS_DSEG | ACS_WRITE) #define ACS_DATA (ACS_PRESENT | ACS_DSEG | ACS_WRITE)
#define ACS_STACK (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 "exceptions.h"
#include "time.h"
#include "naiveConsole.h"
#include "pcb.h"
#include "video.h"
#include "keyboard.h"
#include "interrupts.h"
static void * const sampleCodeAddress = (void *) 0x400000; static void * const sampleCodeAddress = (void *) 0x400000;
typedef int (* fn)(); typedef int (* fn)();
#define ZERO_EXCEPTION_ID 0
#define INVALID_OPCODE_ID 6
static void zero_division(); static void zero_division();
static void invalid_opcode(); static void invalid_opcode();
@ -42,12 +33,6 @@ static char * regsNames[] = {
void printRegs() { void printRegs() {
uint64_t * regs = stackFrame; 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]; char buffer[20];
for (int i = 0; i < 15; i++) { for (int i = 0; i < 15; i++) {
@ -95,7 +80,6 @@ static void startOver() {
} }
static void genericException(char * string, int len) { static void genericException(char * string, int len) {
// moveToWindowVideo(-1);
clear(); clear();
printStringLen(15, string, len); printStringLen(15, string, len);
printRegs(); printRegs();

36
Kernel/interruptions/idtLoader.c
View File

@ -1,12 +1,8 @@
#include <stdint.h> #include "idtLoader.h"
#include <idtLoader.h>
#include <defs.h>
#include <interrupts.h>
#pragma pack(push) /* Push de la alineación actual */ #pragma pack(push)
#pragma pack (1) /* Alinear las siguiente estructuras a 1 byte */ #pragma pack (1)
/* Descriptor de interrupcion */
typedef struct { typedef struct {
uint16_t offset_l, selector; uint16_t offset_l, selector;
uint8_t cero, access; uint8_t cero, access;
@ -14,29 +10,25 @@ typedef struct {
uint32_t offset_h, other_cero; uint32_t offset_h, other_cero;
} DESCR_INT; } 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() { 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(0x80, (uint64_t) &_systemCallsHandler);
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); picMasterMask(0xFC);
// setup_IDT_entry (0x81, (uint64_t)&_switchContext); picSlaveMask(0xFF);
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].selector = 0x08;
idt[index].offset_l = offset & 0xFFFF; idt[index].offset_l = offset & 0xFFFF;
idt[index].offset_m = (offset >> 16) & 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_ #ifndef INTERRUPS_H_
#define INTERRUPS_H_ #define INTERRUPS_H_
#include <idtLoader.h> #include "idtLoader.h"
#include <stdint.h>
void _irq00Handler(void); void _irq00Handler(void);
void _irq01Handler(void); void _irq01Handler(void);
@ -27,4 +28,4 @@ void picSlaveMask(uint8_t mask);
void haltcpu(void); 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 #ifndef SYSCALLSLIB_H
#define SYSCALLS_H #define SYSCALLSLIB_H
#include <stdint.h> #include <stdint.h>
uint64_t write(uint64_t, uint64_t, uint64_t); uint64_t write(uint64_t, uint64_t, uint64_t);
uint64_t read(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 #endif

24
Kernel/interruptions/irqDispatcher.c
View File

@ -1,26 +1,26 @@
#include <time.h>
#include <stdint.h> #include <stdint.h>
static void int_20(); static void int_20();
static void int_21(); static void int_21();
void keyboard_handler(); void keyboard_handler();
void timer_handler();
void irqDispatcher(uint64_t irq) { void irqDispatcher(uint64_t irq) {
switch (irq) { switch (irq) {
case 0: case 0:
int_20(); int_20();
break; break;
case 1: case 1:
int_21(); int_21();
break; break;
} }
return; return;
} }
void int_20() { void int_20() {
timer_handler(); timer_handler();
} }
void int_21() { void int_21() {
keyboard_handler(); keyboard_handler();
} }

32
Kernel/interruptions/systemCalls.c
View File

@ -1,27 +1,14 @@
#include <stdint.h> #include "systemCalls.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
uint64_t write(uint64_t fd, uint64_t buffer, uint64_t length) { uint64_t write(uint64_t fd, uint64_t buffer, uint64_t length) {
char * bufferAux = (char *) buffer; char *bufferAux = (char *) buffer;
int color = STDOUT_COLOR; int color = STDOUT_COLOR;
fd = getFdOut(); fd = getFdOut();
if (fd != STDOUT) { if (fd != STDOUT) {
int i = 0; int i = 0;
while (bufferAux[i] != '\0' && i <= length) { while (bufferAux[i] != '\0' && i <= length) {
writePipe(fd, bufferAux[i++]); writePipe(fd, bufferAux[i++]);
} }
return i; return i;
@ -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) { uint64_t read(uint64_t fd, uint64_t buffer, uint64_t length) {
char * bufferAux = (char *) buffer; char *bufferAux = (char *) buffer;
int readBytes = 0; int readBytes = 0;
if (!isForeground()) if (!isForeground())
@ -56,8 +43,7 @@ uint64_t read(uint64_t fd, uint64_t buffer, uint64_t length) {
bufferAux++; bufferAux++;
// blockIO(); // blockIO();
} }
} } else {
else {
while (length-- > 0) { while (length-- > 0) {
*bufferAux = readPipe(fd); *bufferAux = readPipe(fd);
if (*bufferAux == 0) if (*bufferAux == 0)
@ -67,9 +53,5 @@ uint64_t read(uint64_t fd, uint64_t buffer, uint64_t length) {
} }
} }
return readBytes; return readBytes;
} }
// void createProcess(void (*fn)) {
// newProcess(fn);
// }

16
Kernel/interruptions/systemCallsDispatcher.c
View File

@ -1,24 +1,18 @@
#include <stdint.h> #include <stdint.h>
#include "systemCalls.h" #include "systemCalls.h"
#include "memManager.h" #include "memManager.h"
#include "pipeLib.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 "semLib.h" #include "semLib.h"
#include "schedulerLib.h" #include "schedulerLib.h"
uint64_t systemCallsDispatcher(uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_t rcx, uint64_t r8, uint64_t r9) { uint64_t systemCallsDispatcher(uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_t rcx, uint64_t r8, uint64_t r9) {
switch (rdi) { switch (rdi) {
case 0: case 0:
return write(rsi, rdx, rcx); return write(rsi, rdx, rcx);
case 1: case 1:
return read(rsi, rdx, rcx); return read(rsi, rdx, rcx);
case 2: case 2:
return getTime(rsi, rdx, rcx); return getTime(rsi);
case 3: case 3:
return enqueueProcess((void (*)(int, char **)) rsi, rdx, rcx, (char **) r8, (int *) r9); return enqueueProcess((void (*)(int, char **)) rsi, rdx, rcx, (char **) r8, (int *) r9);
case 4: case 4:
@ -67,6 +61,6 @@ uint64_t systemCallsDispatcher(uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_
return pipes(); return pipes();
default: default:
return -1; return -1;
} }
return 1; return 1;
} }

266
Kernel/kernel.c
View File

@ -18,38 +18,40 @@ extern uint8_t endOfKernel;
static const uint64_t PageSize = 0x1000; static const uint64_t PageSize = 0x1000;
static void * const sampleCodeModuleAddress = (void*)0x400000; static void *const sampleCodeModuleAddress = (void *) 0x400000;
static void * const sampleDataModuleAddress = (void*)0x500000; static void *const sampleDataModuleAddress = (void *) 0x500000;
static void * const memoryModuleAddress = (void*)0x600000; static void *const memoryModuleAddress = (void *) 0x600000;
typedef int (*EntryPoint)(); typedef int (*EntryPoint)();
void clearBSS(void * bssAddress, uint64_t bssSize) { void clearBSS(void *bssAddress, uint64_t bssSize) {
memset(bssAddress, 0, bssSize); memset(bssAddress, 0, bssSize);
} }
void * getStackBase() { void *getStackBase() {
return (void*)( return (void *) (
(uint64_t)&endOfKernel (uint64_t) & endOfKernel
+ PageSize * 8 //The size of the stack itself, 32KiB + PageSize * 8 //The size of the stack itself, 32KiB
- sizeof(uint64_t) //Begin at the top of the stack - sizeof(uint64_t) //Begin at the top of the stack
); );
} }
void * initializeKernelBinary() { void *initializeKernelBinary() {
void * moduleAddresses[] = { void *moduleAddresses[] = {
sampleCodeModuleAddress, sampleCodeModuleAddress,
sampleDataModuleAddress sampleDataModuleAddress
}; };
loadModules(&endOfKernelBinary, moduleAddresses); loadModules(&endOfKernelBinary, moduleAddresses);
clearBSS(&bss, &endOfKernel - &bss); clearBSS(&bss, &endOfKernel - &bss);
return getStackBase(); return getStackBase();
} }
void load_idt(); void load_idt();
uint64_t getRSP(); uint64_t getRSP();
void printBottlerAndWait(); void printBottlerAndWait();
#include "test_util.h" #include "test_util.h"
@ -62,167 +64,127 @@ void printBottlerAndWait();
#define MAX_MEMORY 352//1024-42x16 //Should be around 80% of memory managed by the MM #define MAX_MEMORY 352//1024-42x16 //Should be around 80% of memory managed by the MM
#endif #endif
typedef struct MM_rq{ typedef struct MM_rq {
void *address; void *address;
uint32_t size; uint32_t size;
}mm_rq; } mm_rq;
void test_mm(){ void test_mm() {
mm_rq mm_rqs[MAX_BLOCKS]; mm_rq mm_rqs[MAX_BLOCKS];
uint8_t rq; uint8_t rq;
uint32_t total; uint32_t total;
int i = 1000; int i = 1000;
while (i-- != 0){ while (i-- != 0) {
// while (1){ // while (1){
rq = 0; rq = 0;
total = 0; total = 0;
// Request as many blocks as we can // 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].size = GetUniform(MAX_MEMORY - total - 1) + 1;
mm_rqs[rq].address = pvPortMalloc(mm_rqs[rq].size); mm_rqs[rq].address = pvPortMalloc(mm_rqs[rq].size);
// mm_rqs[rq].address = memMalloc(mm_rqs[rq].size); // mm_rqs[rq].address = memMalloc(mm_rqs[rq].size);
if (mm_rqs[rq].address == NULL) { if (mm_rqs[rq].address == NULL) {
for (int rqAux = 0; rqAux < rq; rqAux++) { for (int rqAux = 0; rqAux < rq; rqAux++) {
ncPrintDec(mm_rqs[rqAux].size ); ncPrintDec(mm_rqs[rqAux].size);
ncPrint(" - "); ncPrint(" - ");
} }
// printStringLen(13, "malloc() -- ERROR", 20); // printStringLen(13, "malloc() -- ERROR", 20);
// new_line(); // new_line();
ncPrint("Malloc -- null"); ncPrint("Malloc -- null");
ncNewline(); ncNewline();
} }
total += mm_rqs[rq].size; total += mm_rqs[rq].size;
rq++; rq++;
} }
// ncPrint("libre dps de malloc: ");
// ncPrintDec(xPortGetFreeHeapSize());
// ncNewline();
// ncPrint("cumpli maximo");
// ncNewline();
// Set // ncPrint("libre dps de malloc: ");
uint32_t i; // ncPrintDec(xPortGetFreeHeapSize());
for (i = 0; i < rq; i++) // ncNewline();
if (mm_rqs[i].address != NULL) // ncPrint("cumpli maximo");
memset(mm_rqs[i].address, i, mm_rqs[i].size); // ncNewline();
// Check // Set
for (i = 0; i < rq; i++) uint32_t i;
if (mm_rqs[i].address != NULL) for (i = 0; i < rq; i++)
if(!memcheck(mm_rqs[i].address, i, mm_rqs[i].size)) { if (mm_rqs[i].address != NULL)
// printStringLen(13, "memCheck() -- ERROR", 20); memset(mm_rqs[i].address, i, mm_rqs[i].size);
// new_line();
ncPrint("memCheck -- null");
ncNewline();
}
// Free // Check
for (i = 0; i < rq; i++) { for (i = 0; i < rq; i++)
if (mm_rqs[i].address != NULL) if (mm_rqs[i].address != NULL)
vPortFree(mm_rqs[i].address); if (!memcheck(mm_rqs[i].address, i, mm_rqs[i].size)) {
} // printStringLen(13, "memCheck() -- ERROR", 20);
// new_line();
ncPrint("memCheck -- null");
ncNewline();
}
// Free
for (i = 0; i < rq; i++) {
if (mm_rqs[i].address != NULL)
vPortFree(mm_rqs[i].address);
}
// memFree(mm_rqs[i].address); // memFree(mm_rqs[i].address);
// ncPrint("libre dps de free: ");
// ncPrintDec(xPortGetFreeHeapSize());
// ncNewline();
ncPrint("termine un loop regio");
ncNewline();
// if (i == 5) // ncPrint("libre dps de free: ");
// wait(3); // ncPrintDec(xPortGetFreeHeapSize());
// ncClear(); // ncNewline();
ncPrint("termine un loop regio");
ncNewline();
// printStringLen(13, "ALL GOOD", 9); // if (i == 5)
// new_line(); // wait(3);
} // ncClear();
// printStringLen(13, "ALL GOOD", 9);
// new_line();
}
} }
// void enqueueProcess(void (*fn) (int, char **), char foreground, int argc, char *argv[], int * fd); // void enqueueProcess(void (*fn) (int, char **), char foreground, int argc, char *argv[], int * fd);
void initScheduler(); void initScheduler();
void _cli(); void _cli();
void _sti(); void _sti();
void haltcpu(); void haltcpu();
void forceTimer(); void forceTimer();
int main() { int main() {
// _cli(); // _cli();
load_idt(); load_idt();
// if (initMemoryManager(memoryModuleAddress, memoryModuleAddress + sizeof(void *)) == -1) { // if (initMemoryManager(memoryModuleAddress, memoryModuleAddress + sizeof(void *)) == -1) {
// printStringLen(13, "createMemoryManager() -- ERROR", 31); // printStringLen(13, "createMemoryManager() -- ERROR", 31);
// new_line(); // new_line();
// return EXIT_FAILURE; // return EXIT_FAILURE;
// } // }
initMemoryManager(memoryModuleAddress); initMemoryManager(memoryModuleAddress);
initScheduler(); initScheduler();
#ifndef BUDDY #ifndef BUDDY
// SACAR DESPUÉS! ES SOLO PARA TESTEO... CORRER DE A UNO! // SACAR DESPUÉS! ES SOLO PARA TESTEO... CORRER DE A UNO!
// if (testOne() == EXIT_FAILURE) // if (testOne() == EXIT_FAILURE)
// return EXIT_FAILURE; // return EXIT_FAILURE;
// if (testTwo() == EXIT_FAILURE) // if (testTwo() == EXIT_FAILURE)
// return EXIT_FAILURE; // return EXIT_FAILURE;
#endif #endif
// test_mm(); // test_mm();
saveSampleRSP(getRSP()); saveSampleRSP(getRSP());
// ((EntryPoint)sampleCodeModuleAddress)(); char *argv[] = {"SampleCode"};
char * argv[] = {"SampleCode"};
enqueueProcess(sampleCodeModuleAddress, 1, 1, argv, NULL); enqueueProcess(sampleCodeModuleAddress, 1, 1, argv, NULL);
clear(); clear();
// haltcpu(); // haltcpu();
_sti(); _sti();
forceTimer(); forceTimer();
// printBottlerAndWait(); return EXIT_SUCCESS;
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();
} }

108
Kernel/lib.c
View File

@ -1,61 +1,44 @@
#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;
uint8_t chr = (uint8_t)c; char *dst = (char *) destination;
char * dst = (char*)destination;
while(length--) while (length--)
dst[length] = chr; dst[length] = chr;
return destination; return destination;
} }
void * memcpy(void * destination, const void * source, uint64_t length) void *memcpy(void *destination, const void *source, uint64_t length) {
{ uint64_t i;
/*
* 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.
*/
uint64_t i;
if ((uint64_t)destination % sizeof(uint32_t) == 0 && if ((uint64_t) destination % sizeof(uint32_t) == 0 &&
(uint64_t)source % 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;
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++) for (i = 0; i < length / sizeof(uint32_t); i++)
d[i] = s[i]; d[i] = s[i];
} } else {
else uint8_t *d = (uint8_t *) destination;
{ const uint8_t *s = (const uint8_t *) source;
uint8_t * d = (uint8_t*)destination;
const uint8_t * s = (const uint8_t*)source;
for (i = 0; i < length; i++) for (i = 0; i < length; i++)
d[i] = s[i]; d[i] = s[i];
} }
return destination; return destination;
} }
void swap(char *x, char *y) { void swap(char *x, char *y) {
char t = *x; char t = *x;
*x = *y; *x = *y;
*y = t; *y = t;
} }
char * reverse(char * buffer, int i, int j) { char *reverse(char *buffer, int i, int j) {
while (i < j) { while (i < j) {
swap(&buffer[i++], &buffer[j--]); swap(&buffer[i++], &buffer[j--]);
} }
@ -67,54 +50,49 @@ int abs(int value) {
return value < 0 ? -value : value; return value < 0 ? -value : value;
} }
char addSpaces(char * str, char qty) { char addSpaces(char *str, char qty) {
char aux = qty; char aux = qty;
while (qty-- > 0) { while (qty-- > 0) {
*str++ = ' '; *str++ = ' ';
} }
return aux; 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) { if (base < 2 || base > 32) {
return buffer; return buffer;
} }
int n = abs(value); int n = abs(value);
int i = 0; int i = 0;
while (n && i < length) { while (n && i < length) {
int r = n % base; int r = n % base;
if (r >= 10) { if (r >= 10) {
buffer[i++] = 65 + (r - 10); buffer[i++] = 65 + (r - 10);
} } else {
else {
buffer[i++] = 48 + r; buffer[i++] = 48 + r;
} }
n = n / base; n = n / base;
} }
if (i == 0) { if (i == 0) {
buffer[i++] = '0'; buffer[i++] = '0';
} }
if (value < 0 && base == 10) { if (value < 0 && base == 10) {
buffer[i++] = '-'; buffer[i++] = '-';
} }
buffer[i] = '\0'; buffer[i] = '\0';
return reverse(buffer, 0, i - 1); return reverse(buffer, 0, i - 1);
} }
void strlen(const char *str, int *len) { int strcpy(char *strDest, const char *strSrc) {
for (*len = 0; str[*len]; (*len)++); int i = 0;
}
int strcpy(char * strDest, const char * strSrc) {
int i = 0;
while ((*strDest++ = *strSrc++)) { while ((*strDest++ = *strSrc++)) {
i++; i++;
} }
return i; return i;
} }

28
Kernel/moduleLoader.c
View File

@ -3,24 +3,24 @@
#include <moduleLoader.h> #include <moduleLoader.h>
#include <naiveConsole.h> #include <naiveConsole.h>
static uint32_t readUint32(uint8_t ** address) { static uint32_t readUint32(uint8_t **address) {
uint32_t result = *(uint32_t*)(*address); uint32_t result = *(uint32_t *)(*address);
*address += sizeof(uint32_t); *address += sizeof(uint32_t);
return result; return result;
} }
static void loadModule(uint8_t ** module, void * targetModuleAddress) { static void loadModule(uint8_t **module, void *targetModuleAddress) {
uint32_t moduleSize = readUint32(module); uint32_t moduleSize = readUint32(module);
memcpy(targetModuleAddress, *module, moduleSize); memcpy(targetModuleAddress, *module, moduleSize);
*module += moduleSize; *module += moduleSize;
} }
void loadModules(void * payloadStart, void ** targetModuleAddress) { void loadModules(void *payloadStart, void **targetModuleAddress) {
int i; int i;
uint8_t * currentModule = (uint8_t*)payloadStart; uint8_t *currentModule = (uint8_t *) payloadStart;
uint32_t moduleCount = readUint32(&currentModule); uint32_t moduleCount = readUint32(&currentModule);
for (i = 0; i < moduleCount; i++) for (i = 0; i < moduleCount; i++)
loadModule(&currentModule, targetModuleAddress[i]); loadModule(&currentModule, targetModuleAddress[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 <stdint.h>
#include <stddef.h> #include <stddef.h>
#include <stdlib.h> #include <stdlib.h>
#include "lib.h" #include "../../include/lib.h"
#include "scheduler.h" #include "scheduler.h"
#include "memManager.h" #include "memManager.h"
#include "pipeLib.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 "memManager.h"
#include <stdlib.h> #include <stdlib.h>
#include "lib.h" #include "../../include/lib.h"
#include "time.h" #include "../../drivers/include/time.h"
#include <stddef.h> #include <stddef.h>
#include "schedulerLib.h" #include "schedulerLib.h"
@ -18,6 +18,7 @@ void haltcpu();
#define PROCESS_DATA_MAX_SIZE 100 #define PROCESS_DATA_MAX_SIZE 100
#define MAX_ATTR_SIZE 6 #define MAX_ATTR_SIZE 6
#define MAX_NAME_SIZE 10 #define MAX_NAME_SIZE 10
#define IDLE_PID 1
typedef struct processCDT * processADT; typedef struct processCDT * processADT;
@ -27,5 +28,6 @@ uint64_t nextProcess();
char updateRSP(uint64_t newRsp); char updateRSP(uint64_t newRsp);
char getProcessData(char * out, processADT proc); char getProcessData(char * out, processADT proc);
processADT searchProcess(processADT * previous, int pid, processADT first); processADT searchProcess(processADT * previous, int pid, processADT first);
uint64_t _initialize_stack_frame(void *, void *, int, char **);
#endif #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 <stdint.h>
#include <stddef.h> #include <stddef.h>
#include <stdlib.h> #include <stdlib.h>
#include "lib.h" #include "../../include/lib.h"
#include "scheduler.h" #include "scheduler.h"
#include "memManager.h" #include "memManager.h"
#include "semLib.h" #include "semLib.h"
#define MAX_SEM 100 #define MAX_SEM 100
#define SEM_DATA_MAX_SIZE 100 #define SEM_DATA_MAX_SIZE 100
#define MAX_PID 4
void enter_region(uint32_t * lock); void enter_region(uint32_t * lock);
void leave_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 { typedef struct sem_t {
unsigned int value; unsigned int value;
// char name[MAX_NAME];
char * name; char * name;
pid_t * entering; pid_t * entering;
pid_t * last; pid_t * last;

304
Kernel/utils/memManagerBuddy.c
View File

@ -17,23 +17,23 @@
// } // }
typedef struct meta { typedef struct meta {
unsigned char allo : 1; // 0000000_ - allocated unsigned char allo : 1; // 0000000_ - allocated
unsigned char left : 1; // 000000_0 - first or second unsigned char left : 1; // 000000_0 - first or second
unsigned char size : 6; // ______00 - n where (2^n)-1 is the block size unsigned char size : 6; // ______00 - n where (2^n)-1 is the block size
} Meta; } Meta;
// static char myblock[MANAGED_MEMORY_SIZE]; // static char myblock[MANAGED_MEMORY_SIZE];
static char *myblock; static char *myblock;
void initMemoryManager(void * managedMemory) { void initMemoryManager(void * managedMemory) {
myblock = managedMemory; myblock = managedMemory;
} }
void unpack(Meta * m, int pos); void unpack(Meta * m, int pos);
/* Fills myblock with zeros and creates first metadata */ /* Fills myblock with zeros and creates first metadata */
void init_block() { void init_block() {
memset(&myblock, '\0', MANAGED_MEMORY_SIZE); memset(&myblock, '\0', MANAGED_MEMORY_SIZE);
memset(&myblock, 54, 1); memset(&myblock, 54, 1);
} }
int ceil(float num) { int ceil(float num) {
@ -51,218 +51,218 @@ int ceil(float num) {
// /* Returns log base 2 of a double d */ // /* Returns log base 2 of a double d */
// double log2(double d) { // double log2(double d) {
// return log(d) / log(2); // return log(d) / log(2);
// } // }
/* Returns the level a reqSize will fit in */ /* Returns the level a reqSize will fit in */
int size_to_n(size_t reqSize) { int size_to_n(size_t reqSize) {
reqSize+=1; reqSize+=1;
double d = log2((double)reqSize); double d = log2((double)reqSize);
return (int)ceil(d); return (int)ceil(d);
} }
/* Returns the position of the next block of the correct size */ /* Returns the position of the next block of the correct size */
int jump_next(int n, int pos) { int jump_next(int n, int pos) {
int bits = pos>>(n); int bits = pos>>(n);
bits+=1; bits+=1;
int ret = bits<<(n); int ret = bits<<(n);
if (ret == MANAGED_MEMORY_SIZE) {
return ret;
} else {
return ret;
}
if (ret == MANAGED_MEMORY_SIZE) {
return ret;
} else {
return ret;
}
} }
/* Returns the position of the left half of a pair */ /* Returns the position of the left half of a pair */
int jump_back(int n, int pos) { int jump_back(int n, int pos) {
int bits = pos>>(n); int bits = pos>>(n);
bits-=1; bits-=1;
return bits<<(n); return bits<<(n);
} }
/* Fills a Meta struct with metadata at pos */ /* Fills a Meta struct with metadata at pos */
void unpack(Meta * m, int pos) { void unpack(Meta * m, int pos) {
memset(m, myblock[pos], 1); memset(m, myblock[pos], 1);
} }
/* Returns whether position at level n is left or right partner */ /* Returns whether position at level n is left or right partner */
int is_left(int n, int pos) { int is_left(int n, int pos) {
// Manipulate bits to set nth bit on // Manipulate bits to set nth bit on
int k = 1; int k = 1;
k<<=(n); k<<=(n);
// Manipulate bits to zero bits above n
unsigned int p = (unsigned int)pos;
p<<=(31-n);
p>>=(31-n);
if (k == p) { // Manipulate bits to zero bits above n
return 0; // Right unsigned int p = (unsigned int)pos;
} else { p<<=(31-n);
return 1; // Left p>>=(31-n);
}
if (k == p) {
return 0; // Right
} else {
return 1; // Left
}
} }
/* Mergee two unallocated blocks with same size */ /* Mergee two unallocated blocks with same size */
void merge(int pos, int pos2, int n) { void merge(int pos, int pos2, int n) {
// Create new meta and set size field
char newMeta = (n+1)<<2;
// Set left field // Create new meta and set size field
if (is_left(n+1, pos)) { char newMeta = (n+1)<<2;
newMeta+=2;
}
// Add new meta // Set left field
myblock[pos] = newMeta; if (is_left(n+1, pos)) {
newMeta+=2;
}
// Delete meta on right partner // Add new meta
myblock[pos2] = 0; myblock[pos] = newMeta;
// Delete meta on right partner
myblock[pos2] = 0;
} }
/* MYmymalloc */ /* MYmymalloc */
void * pvPortMalloc(size_t reqSize) { void * pvPortMalloc(size_t reqSize) {
// Check if too big // Check if too big
if (reqSize > MANAGED_MEMORY_SIZE - 1) { if (reqSize > MANAGED_MEMORY_SIZE - 1) {
// fprintf(stderr, "Error: Requested size too large\n"); // fprintf(stderr, "Error: Requested size too large\n");
return NULL; return NULL;
} }
// Traverse heap to find block of correct size - algo(n) // Traverse heap to find block of correct size - algo(n)
int n = size_to_n(reqSize); int n = size_to_n(reqSize);
int pos = 0; int pos = 0;
unsigned char c = 0; unsigned char c = 0;
Meta * m = memset(&c, 0, 1); Meta * m = memset(&c, 0, 1);
while (pos < MANAGED_MEMORY_SIZE) {
// Read metadata
unpack(m, pos);
// // Debugging while (pos < MANAGED_MEMORY_SIZE) {
// if (m->size == 0) { // Read metadata
// exit(0); unpack(m, pos);
// }
if (n <= m->size) { // // Debugging
if (m->allo == 1) { // if (m->size == 0) {
// Jump // exit(0);
pos = jump_next(n, pos); // }
continue;
} else if (m->size == n) {
// Allocate
myblock[pos]+=1;
pos+=1;
return (void*)((long int)&myblock+pos);
} else {
// Partition
// Get partner position if (n <= m->size) {
int partner = jump_next((m->size)-1, pos); if (m->allo == 1) {
// Jump
pos = jump_next(n, pos);
continue;
} else if (m->size == n) {
// Allocate
myblock[pos]+=1;
pos+=1;
return (void*)((long int)&myblock+pos);
} else {
// Partition
// Set Left // Get partner position
char meta_1 = 2; int partner = jump_next((m->size)-1, pos);
char meta_2 = 0;
// Set Size
char s = ((m->size)-1)<<2;
meta_1 = (meta_1 | s);
meta_2 = (meta_2 | s);
// Fill in metadata // Set Left
myblock[pos] = meta_1; char meta_1 = 2;
myblock[partner] = meta_2; char meta_2 = 0;
// Continue on same position with new size of block // Set Size
continue; char s = ((m->size)-1)<<2;
} meta_1 = (meta_1 | s);
} else { meta_2 = (meta_2 | s);
// Jump
pos = jump_next(n, pos); // Fill in metadata
continue; myblock[pos] = meta_1;
} myblock[partner] = meta_2;
}
// Continue on same position with new size of block
continue;
}
} else {
// Jump
pos = jump_next(n, pos);
continue;
}
}
//error //error
return 0; return 0;
} }
/* MYmyfree */ /* MYmyfree */
void vPortFree(void * ptr) { void vPortFree(void * ptr) {
// Error Checking
if (ptr <= (void *)&myblock || ptr > (void *)(&myblock + MANAGED_MEMORY_SIZE)) {
//error
return;
}
// Get position // Error Checking
// int pos = (int)(ptr-(void *)&myblock-1); if (ptr <= (void *)&myblock || ptr > (void *)(&myblock + MANAGED_MEMORY_SIZE)) {
//error
return;
}
// Get position
// int pos = (int)(ptr-(void *)&myblock-1);
int pos = (int)((char *)ptr-(char *)&myblock-1); int pos = (int)((char *)ptr-(char *)&myblock-1);
// Check if valid metadata location // Check if valid metadata location
if (pos%2 == 1 || myblock[pos] == 0) { if (pos%2 == 1 || myblock[pos] == 0) {
//error //error
return; return;
} }
// Initialize variables for merge // Initialize variables for merge
unsigned char c1 = 0; unsigned char c1 = 0;
unsigned char c2 = 0; unsigned char c2 = 0;
Meta * m1 = memset(&c1, 0, 1); Meta * m1 = memset(&c1, 0, 1);
Meta * m2 = memset(&c2, 0, 1); Meta * m2 = memset(&c2, 0, 1);
unpack(m1,pos); unpack(m1,pos);
// Change allocated field // Change allocated field
myblock[pos] = myblock[pos] - 1; myblock[pos] = myblock[pos] - 1;
while (pos >= 0 && pos <= 8196){ while (pos >= 0 && pos <= 8196){
// Read metadata // Read metadata
unpack(m1,pos); unpack(m1,pos);
if (m1->left) { // Left Partner if (m1->left) { // Left Partner
// Get position of other partner and read metadata // Get position of other partner and read metadata
int pos2 = jump_next(m1->size, pos); int pos2 = jump_next(m1->size, pos);
if (pos2 >= 0 && pos2 <= MANAGED_MEMORY_SIZE - 2) { if (pos2 >= 0 && pos2 <= MANAGED_MEMORY_SIZE - 2) {
unpack(m2,pos2); unpack(m2,pos2);
} else { } else {
break; break;
} }
// Merge or break // Merge or break
if (m2->allo || m2->size != m1->size) { if (m2->allo || m2->size != m1->size) {
break; break;
} else { } else {
merge(pos, pos2, m1->size); merge(pos, pos2, m1->size);
} }
} else { // Right Partner } else { // Right Partner
// Get position of other partner and read metadata // Get position of other partner and read metadata
int pos2 = jump_back(m2->size,pos); int pos2 = jump_back(m2->size,pos);
if (pos2 >= 0 && pos2 <= MANAGED_MEMORY_SIZE -2) { if (pos2 >= 0 && pos2 <= MANAGED_MEMORY_SIZE -2) {
unpack(m2,pos2); unpack(m2,pos2);
} else { } else {
break; break;
} }
// Merge or break // Merge or break
if (m2->allo || m2->size != m1->size) { if (m2->allo || m2->size != m1->size) {
break; break;
} else { } else {
merge(pos2, pos, m1->size); merge(pos2, pos, m1->size);
} }
} }
} }
} }
#endif #endif

534
Kernel/utils/memManagerFRT4.c
View File

@ -8,13 +8,13 @@
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
#define portCHAR char #define portCHAR char
#define portFLOAT float #define portFLOAT float
#define portDOUBLE double #define portDOUBLE double
#define portLONG long #define portLONG long
#define portSHORT short #define portSHORT short
#define portSTACK_TYPE uint32_t #define portSTACK_TYPE uint32_t
#define portBASE_TYPE long #define portBASE_TYPE long
typedef portSTACK_TYPE StackType_t; typedef portSTACK_TYPE StackType_t;
typedef long BaseType_t; typedef long BaseType_t;
@ -28,42 +28,41 @@ typedef unsigned long UBaseType_t;
// #define portBYTE_ALIGNMENT 16 // #define portBYTE_ALIGNMENT 16
#define portBYTE_ALIGNMENT_MASK ( 0x0007 ) // 8 #define portBYTE_ALIGNMENT_MASK ( 0x0007 ) // 8
// #define portBYTE_ALIGNMENT_MASK ( 0x000F ) // 16 // #define portBYTE_ALIGNMENT_MASK ( 0x000F ) // 16
#define pdFALSE ( ( BaseType_t ) 0 ) #define pdFALSE ( ( BaseType_t ) 0 )
#define pdTRUE ( ( BaseType_t ) 1 ) #define pdTRUE ( ( BaseType_t ) 1 )
#define portPOINTER_SIZE_TYPE uint32_t #define portPOINTER_SIZE_TYPE uint32_t
/* A few bytes might be lost to byte aligning the heap start address. */ /* A few bytes might be lost to byte aligning the heap start address. */
#define configADJUSTED_HEAP_SIZE ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT ) #define configADJUSTED_HEAP_SIZE ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )
#define heapBITS_PER_BYTE ( ( size_t ) 8 ) #define heapBITS_PER_BYTE ( ( size_t ) 8 )
#define heapMINIMUM_BLOCK_SIZE ( ( size_t ) ( xHeapStructSize << 1 ) ) #define heapMINIMUM_BLOCK_SIZE ( ( size_t ) ( xHeapStructSize << 1 ) )
/* Define the linked list structure. This is used to link free blocks in order /* Define the linked list structure. This is used to link free blocks in order
of their memory address. */ 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. */
struct A_BLOCK_LINK *pxNextFreeBlock; /*<< The next free block in the list. */ size_t xBlockSize; /*<< The size of the free block. */
size_t xBlockSize; /*<< The size of the free block. */
} BlockLink_t; } BlockLink_t;
static uint8_t *ucHeap; static uint8_t *ucHeap;
void initMemoryManager(void * managedMemory) {
ucHeap = managedMemory; void initMemoryManager(void *managedMemory) {
ucHeap = managedMemory;
} }
/* Definition of the Heap_stats_t structure. */ /* 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 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 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. */
size_t xSizeOfSmallestFreeBlockInBytes; /* The minimum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */ size_t xNumberOfFreeBlocks; /* The number of free memory blocks within the heap at the time vPortGetHeapStats() is called. */
size_t xNumberOfFreeBlocks; /* The number of free memory blocks within the heap at the time vPortGetHeapStats() is called. */ size_t xMinimumEverFreeBytesRemaining; /* The minimum amount of total free memory (sum of all free blocks) there has been in the heap since the system booted. */
size_t xMinimumEverFreeBytesRemaining; /* The minimum amount of total free memory (sum of all free blocks) there has been in the heap since the system booted. */ size_t xNumberOfSuccessfulAllocations; /* The number of calls to pvPortMalloc() that have returned a valid memory block. */
size_t xNumberOfSuccessfulAllocations; /* The number of calls to pvPortMalloc() that have returned a valid memory block. */ size_t xNumberOfSuccessfulFrees; /* The number of calls to vPortFree() that has successfully freed a block of memory. */
size_t xNumberOfSuccessfulFrees; /* The number of calls to vPortFree() that has successfully freed a block of memory. */
} HeapStats_t; } HeapStats_t;
/* Prototype of the vPortGetHeapStats() function. */ /* 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 * the block in front it and/or the block behind it if the memory blocks are
* adjacent to each other. * 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 * Called automatically to setup the required heap structures the first time
* pvPortMalloc() is called. * pvPortMalloc() is called.
*/ */
static void prvHeapInit( void ); static void prvHeapInit(void);
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
/* The size of the structure placed at the beginning of each allocated memory /* The size of the structure placed at the beginning of each allocated memory
block must by correctly byte aligned. */ 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. */ /* Create a couple of list links to mark the start and end of the list. */
static BlockLink_t xStart, *pxEnd = NULL; static BlockLink_t xStart, *pxEnd = NULL;
@ -105,314 +105,288 @@ static size_t xBlockAllocatedBit = 0;
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
void *pvPortMalloc( size_t xWantedSize ) void *pvPortMalloc(size_t xWantedSize) {
{ BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink; void *pvReturn = NULL;
void *pvReturn = NULL;
/* If this is the first call to malloc then the heap will require /* If this is the first call to malloc then the heap will require
initialisation to setup the list of free blocks. */ initialisation to setup the list of free blocks. */
if( pxEnd == NULL ) if (pxEnd == NULL) {
{ prvHeapInit();
prvHeapInit(); }
}
/* Check the requested block size is not so large that the top bit is /* Check the requested block size is not so large that the top bit is
set. The top bit of the block size member of the BlockLink_t structure 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 is used to determine who owns the block - the application or the
kernel, so it must be free. */ 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
/* The wanted size is increased so it can contain a BlockLink_t structure in addition to the requested amount of bytes. */
structure in addition to the requested amount of bytes. */ if (xWantedSize > 0) {
if( xWantedSize > 0 ) xWantedSize += xHeapStructSize;
{
xWantedSize += xHeapStructSize;
/* Ensure that blocks are always aligned to the required number /* Ensure that blocks are always aligned to the required number
of bytes. */ of bytes. */
if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 ) if ((xWantedSize & portBYTE_ALIGNMENT_MASK) != 0x00) {
{ /* Byte alignment required. */
/* Byte alignment required. */ xWantedSize += (portBYTE_ALIGNMENT - (xWantedSize & portBYTE_ALIGNMENT_MASK));
xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ); // configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );
// 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
/* Traverse the list from the start (lowest address) block until one of adequate size is found. */
one of adequate size is found. */ pxPreviousBlock = &xStart;
pxPreviousBlock = &xStart; pxBlock = xStart.pxNextFreeBlock;
pxBlock = xStart.pxNextFreeBlock; while ((pxBlock->xBlockSize < xWantedSize) && (pxBlock->pxNextFreeBlock != NULL)) {
while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) ) pxPreviousBlock = pxBlock;
{ pxBlock = pxBlock->pxNextFreeBlock;
pxPreviousBlock = pxBlock; }
pxBlock = pxBlock->pxNextFreeBlock;
}
/* If the end marker was reached then a block of adequate size /* If the end marker was reached then a block of adequate size
was not found. */ was not found. */
if( pxBlock != pxEnd ) if (pxBlock != pxEnd) {
{ /* Return the memory space pointed to - jumping over the
/* Return the memory space pointed to - jumping over the BlockLink_t structure at its start. */
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 /* This block is being returned for use so must be taken out
of the list of free blocks. */ of the list of free blocks. */
pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock; pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
/* If the block is larger than required it can be split into /* If the block is larger than required it can be split into
two. */ 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
/* This block is to be split into two. Create a new block following the number of bytes requested. The void
block following the number of bytes requested. The void cast is used to prevent byte alignment warnings from the
cast is used to prevent byte alignment warnings from the compiler. */
compiler. */ pxNewBlockLink = (void *) (((uint8_t *) pxBlock) + xWantedSize);
pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize ); // configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );
// configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );
/* Calculate the sizes of two blocks split from the /* Calculate the sizes of two blocks split from the
single block. */ single block. */
pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize; pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
pxBlock->xBlockSize = xWantedSize; pxBlock->xBlockSize = xWantedSize;
/* Insert the new block into the list of free blocks. */ /* Insert the new block into the list of free blocks. */
prvInsertBlockIntoFreeList( pxNewBlockLink ); prvInsertBlockIntoFreeList(pxNewBlockLink);
} }
xFreeBytesRemaining -= pxBlock->xBlockSize; xFreeBytesRemaining -= pxBlock->xBlockSize;
if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining ) if (xFreeBytesRemaining < xMinimumEverFreeBytesRemaining) {
{ xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
xMinimumEverFreeBytesRemaining = xFreeBytesRemaining; }
}
/* The block is being returned - it is allocated and owned /* The block is being returned - it is allocated and owned
by the application and has no "next" block. */ by the application and has no "next" block. */
pxBlock->xBlockSize |= xBlockAllocatedBit; pxBlock->xBlockSize |= xBlockAllocatedBit;
pxBlock->pxNextFreeBlock = NULL; pxBlock->pxNextFreeBlock = NULL;
xNumberOfSuccessfulAllocations++; xNumberOfSuccessfulAllocations++;
} }
} } else {
else {
// ncNewline(); // ncNewline();
// ncPrint("MALLOC: "); // ncPrint("MALLOC: ");
// ncPrintDec(xFreeBytesRemaining); // ncPrintDec(xFreeBytesRemaining);
// ncPrint(" "); // ncPrint(" ");
// ncPrintDec(xWantedSize); // ncPrintDec(xWantedSize);
// ncPrint(" "); // ncPrint(" ");
// ncPrintDec(configADJUSTED_HEAP_SIZE); // ncPrintDec(configADJUSTED_HEAP_SIZE);
// ncNewline(); // ncNewline();
} }
} }
// configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 ); // configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
return pvReturn; return pvReturn;
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
void vPortFree( void *pv ) void vPortFree(void *pv) {
{ uint8_t *puc = (uint8_t *) pv;
uint8_t *puc = ( uint8_t * ) pv; BlockLink_t *pxLink;
BlockLink_t *pxLink;
if( pv != NULL ) if (pv != NULL) {
{ /* The memory being freed will have an BlockLink_t structure immediately
/* The memory being freed will have an BlockLink_t structure immediately before it. */
before it. */ puc -= xHeapStructSize;
puc -= xHeapStructSize;
/* This casting is to keep the compiler from issuing warnings. */ /* This casting is to keep the compiler from issuing warnings. */
pxLink = ( void * ) puc; pxLink = (void *) puc;
/* Check the block is actually allocated. */ /* Check the block is actually allocated. */
// configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 ); // configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
// configASSERT( pxLink->pxNextFreeBlock == NULL ); // configASSERT( pxLink->pxNextFreeBlock == NULL );
if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 ) if ((pxLink->xBlockSize & xBlockAllocatedBit) != 0) {
{ if (pxLink->pxNextFreeBlock == NULL) {
if( pxLink->pxNextFreeBlock == NULL ) /* The block is being returned to the heap - it is no longer
{ allocated. */
/* The block is being returned to the heap - it is no longer pxLink->xBlockSize &= ~xBlockAllocatedBit;
allocated. */
pxLink->xBlockSize &= ~xBlockAllocatedBit;
{ {
/* Add this block to the list of free blocks. */ /* Add this block to the list of free blocks. */
xFreeBytesRemaining += pxLink->xBlockSize; xFreeBytesRemaining += pxLink->xBlockSize;
prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) ); prvInsertBlockIntoFreeList(((BlockLink_t *) pxLink));
xNumberOfSuccessfulFrees++; xNumberOfSuccessfulFrees++;
} }
} }
} }
} }
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
size_t xPortGetFreeHeapSize( void ) size_t xPortGetFreeHeapSize(void) {
{ return xFreeBytesRemaining;
return xFreeBytesRemaining;
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
size_t xPortGetMinimumEverFreeHeapSize( void ) size_t xPortGetMinimumEverFreeHeapSize(void) {
{ return xMinimumEverFreeBytesRemaining;
return xMinimumEverFreeBytesRemaining;
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
void vPortInitialiseBlocks( void ) void vPortInitialiseBlocks(void) {
{ /* This just exists to keep the linker quiet. */
/* This just exists to keep the linker quiet. */
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
static void prvHeapInit( void ) static void prvHeapInit(void) {
{ BlockLink_t *pxFirstFreeBlock;
BlockLink_t *pxFirstFreeBlock; uint8_t *pucAlignedHeap;
uint8_t *pucAlignedHeap; size_t uxAddress;
size_t uxAddress; size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
/* Ensure the heap starts on a correctly aligned boundary. */ /* Ensure the heap starts on a correctly aligned boundary. */
uxAddress = ( size_t ) ucHeap; uxAddress = (size_t) ucHeap;
if( ( uxAddress & portBYTE_ALIGNMENT_MASK ) != 0 ) if ((uxAddress & portBYTE_ALIGNMENT_MASK) != 0) {
{ uxAddress += (portBYTE_ALIGNMENT - 1);
uxAddress += ( portBYTE_ALIGNMENT - 1 ); uxAddress &= ~((size_t)portBYTE_ALIGNMENT_MASK);
uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK ); xTotalHeapSize -= uxAddress - (size_t) ucHeap;
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 /* 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. */ blocks. The void cast is used to prevent compiler warnings. */
xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap; xStart.pxNextFreeBlock = (void *) pucAlignedHeap;
xStart.xBlockSize = ( size_t ) 0; xStart.xBlockSize = (size_t) 0;
/* pxEnd is used to mark the end of the list of free blocks and is inserted /* pxEnd is used to mark the end of the list of free blocks and is inserted
at the end of the heap space. */ at the end of the heap space. */
uxAddress = ( ( size_t ) pucAlignedHeap ) + xTotalHeapSize; uxAddress = ((size_t) pucAlignedHeap) + xTotalHeapSize;
uxAddress -= xHeapStructSize; uxAddress -= xHeapStructSize;
uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK ); uxAddress &= ~((size_t)portBYTE_ALIGNMENT_MASK);
pxEnd = ( void * ) uxAddress; pxEnd = (void *) uxAddress;
pxEnd->xBlockSize = 0; pxEnd->xBlockSize = 0;
pxEnd->pxNextFreeBlock = NULL; pxEnd->pxNextFreeBlock = NULL;
/* To start with there is a single free block that is sized to take up the /* 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. */ entire heap space, minus the space taken by pxEnd. */
pxFirstFreeBlock = ( void * ) pucAlignedHeap; pxFirstFreeBlock = (void *) pucAlignedHeap;
pxFirstFreeBlock->xBlockSize = uxAddress - ( size_t ) pxFirstFreeBlock; pxFirstFreeBlock->xBlockSize = uxAddress - (size_t) pxFirstFreeBlock;
pxFirstFreeBlock->pxNextFreeBlock = pxEnd; pxFirstFreeBlock->pxNextFreeBlock = pxEnd;
/* Only one block exists - and it covers the entire usable heap space. */ /* Only one block exists - and it covers the entire usable heap space. */
xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize; xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize; xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
/* Work out the position of the top bit in a size_t variable. */ /* 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 ) static void prvInsertBlockIntoFreeList(BlockLink_t *pxBlockToInsert) {
{ BlockLink_t *pxIterator;
BlockLink_t *pxIterator; uint8_t *puc;
uint8_t *puc;
/* Iterate through the list until a block is found that has a higher address /* Iterate through the list until a block is found that has a higher address
than the block being inserted. */ 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. */ /* Nothing to do here, just iterate to the right position. */
} }
/* Do the block being inserted, and the block it is being inserted after /* Do the block being inserted, and the block it is being inserted after
make a contiguous block of memory? */ make a contiguous block of memory? */
puc = ( uint8_t * ) pxIterator; puc = (uint8_t *) pxIterator;
if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert ) if ((puc + pxIterator->xBlockSize) == (uint8_t *) pxBlockToInsert) {
{ pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
pxIterator->xBlockSize += pxBlockToInsert->xBlockSize; pxBlockToInsert = pxIterator;
pxBlockToInsert = pxIterator; }
}
/* Do the block being inserted, and the block it is being inserted before /* Do the block being inserted, and the block it is being inserted before
make a contiguous block of memory? */ make a contiguous block of memory? */
puc = ( uint8_t * ) pxBlockToInsert; puc = (uint8_t *) pxBlockToInsert;
if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock ) if ((puc + pxBlockToInsert->xBlockSize) == (uint8_t *) pxIterator->pxNextFreeBlock) {
{ if (pxIterator->pxNextFreeBlock != pxEnd) {
if( pxIterator->pxNextFreeBlock != pxEnd ) /* Form one big block from the two blocks. */
{ pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;
/* Form one big block from the two blocks. */ pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;
pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize; } else {
pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock; pxBlockToInsert->pxNextFreeBlock = pxEnd;
} }
else } else {
{ pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
pxBlockToInsert->pxNextFreeBlock = pxEnd; }
}
}
else
{
pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
}
/* If the block being inserted plugged a gab, so was merged with the block /* If the block being inserted plugged a gab, so was merged with the block
before and the block after, then it's pxNextFreeBlock pointer will have 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 already been set, and should not be set here as that would make it point
to itself. */ to itself. */
if( pxIterator != pxBlockToInsert ) if (pxIterator != pxBlockToInsert) {
{ pxIterator->pxNextFreeBlock = pxBlockToInsert;
pxIterator->pxNextFreeBlock = pxBlockToInsert; }
}
} }
/*-----------------------------------------------------------*/ /*-----------------------------------------------------------*/
void vPortGetHeapStats( HeapStats_t *pxHeapStats ) void vPortGetHeapStats(HeapStats_t *pxHeapStats) {
{ BlockLink_t *pxBlock;
BlockLink_t *pxBlock; size_t xBlocks = 0, xMaxSize = 0, xMinSize =
size_t xBlocks = 0, xMaxSize = 0, xMinSize = configTOTAL_HEAP_SIZE;//portMAX_DELAY; /* portMAX_DELAY used as a portable way of getting the maximum value. */ configTOTAL_HEAP_SIZE;//portMAX_DELAY; /* portMAX_DELAY used as a portable way of getting the maximum value. */
pxBlock = xStart.pxNextFreeBlock; pxBlock = xStart.pxNextFreeBlock;
/* pxBlock will be NULL if the heap has not been initialised. The heap /* pxBlock will be NULL if the heap has not been initialised. The heap
is initialised automatically when the first allocation is made. */ is initialised automatically when the first allocation is made. */
if( pxBlock != NULL ) if (pxBlock != NULL) {
{ do {
do /* Increment the number of blocks and record the largest block seen
{ so far. */
/* Increment the number of blocks and record the largest block seen xBlocks++;
so far. */
xBlocks++;
if( pxBlock->xBlockSize > xMaxSize ) if (pxBlock->xBlockSize > xMaxSize) {
{ xMaxSize = pxBlock->xBlockSize;
xMaxSize = pxBlock->xBlockSize; }
}
if( pxBlock->xBlockSize < xMinSize ) if (pxBlock->xBlockSize < xMinSize) {
{ xMinSize = pxBlock->xBlockSize;
xMinSize = pxBlock->xBlockSize; }
}
/* Move to the next block in the chain until the last block is /* Move to the next block in the chain until the last block is
reached. */ reached. */
pxBlock = pxBlock->pxNextFreeBlock; pxBlock = pxBlock->pxNextFreeBlock;
} while( pxBlock != pxEnd ); } while (pxBlock != pxEnd);
} }
pxHeapStats->xSizeOfLargestFreeBlockInBytes = xMaxSize; pxHeapStats->xSizeOfLargestFreeBlockInBytes = xMaxSize;
pxHeapStats->xSizeOfSmallestFreeBlockInBytes = xMinSize; pxHeapStats->xSizeOfSmallestFreeBlockInBytes = xMinSize;
pxHeapStats->xNumberOfFreeBlocks = xBlocks; pxHeapStats->xNumberOfFreeBlocks = xBlocks;
pxHeapStats->xAvailableHeapSpaceInBytes = xFreeBytesRemaining; pxHeapStats->xAvailableHeapSpaceInBytes = xFreeBytesRemaining;
pxHeapStats->xNumberOfSuccessfulAllocations = xNumberOfSuccessfulAllocations; pxHeapStats->xNumberOfSuccessfulAllocations = xNumberOfSuccessfulAllocations;
pxHeapStats->xNumberOfSuccessfulFrees = xNumberOfSuccessfulFrees; pxHeapStats->xNumberOfSuccessfulFrees = xNumberOfSuccessfulFrees;
pxHeapStats->xMinimumEverFreeBytesRemaining = xMinimumEverFreeBytesRemaining; pxHeapStats->xMinimumEverFreeBytesRemaining = xMinimumEverFreeBytesRemaining;
} }

32
Kernel/utils/pcb.c
View File

@ -1,37 +1,5 @@
#include "pcb.h" #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; static uint64_t sampleRSP;
void saveSampleRSP(uint64_t rsp) { void saveSampleRSP(uint64_t rsp) {

74
Kernel/utils/pipe.c
View File

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

138
Kernel/utils/scheduler.c
View File

@ -1,13 +1,12 @@
#include "scheduler.h" #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 { typedef struct processCDT {
struct processCDT * next; struct processCDT *next;
char * name; char *name;
int pid; int pid;
int ppid; int ppid;
uint64_t rsp; uint64_t rsp;
@ -16,7 +15,7 @@ typedef struct processCDT {
char executions; char executions;
char foreground; char foreground;
enum states state; enum states state;
int * fd; int *fd;
int children; int children;
char backWait; char backWait;
} processCDT; } processCDT;
@ -25,30 +24,29 @@ typedef struct sleepCDT {
int pid; int pid;
long time; long time;
long secs; long secs;
struct sleepCDT * next; struct sleepCDT *next;
} sleepCDT; } sleepCDT;
processCDT * firstBlockedIteration = NULL; processCDT *firstBlockedIteration = NULL;
processCDT * firstProcess = NULL; processCDT *firstProcess = NULL;
processCDT * lastProcess = NULL; processCDT *lastProcess = NULL;
sleepCDT * firstSleep = NULL; sleepCDT *firstSleep = NULL;
static processCDT * currentProcess = NULL; static processCDT *currentProcess = NULL;
static int pids = IDLE_PID; static int pids = IDLE_PID;
static char update = 1; static char update = 1;
static char idleFlag = 2; static char idleFlag = 2;
void removeProcess(processCDT * del, processCDT ** first, processCDT ** last) { void removeProcess(processCDT *del, processCDT **first, processCDT **last) {
processCDT * prev = NULL; processCDT *prev = NULL;
del = searchProcess(&prev, del->pid, *first); del = searchProcess(&prev, del->pid, *first);
if (prev == NULL) { if (prev == NULL) {
*first = del->next; *first = del->next;
if (*last == del) if (*last == del)
*last = NULL; *last = NULL;
} } else {
else {
prev->next = del->next; prev->next = del->next;
if (*last == del) if (*last == del)
*last = prev; *last = prev;
@ -58,28 +56,28 @@ void removeProcess(processCDT * del, processCDT ** first, processCDT ** last) {
uint64_t nextProcess(uint64_t currentRSP) { uint64_t nextProcess(uint64_t currentRSP) {
if (currentProcess != NULL) if (currentProcess != NULL)
currentProcess->rsp = currentRSP; currentProcess->rsp = currentRSP;
processCDT * prev = currentProcess; 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->executions = 0;
currentProcess = currentProcess->next; 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) { if (currentProcess == NULL) {
currentProcess = firstProcess; currentProcess = firstProcess;
} } else if (currentProcess == firstBlockedIteration) {
else if (currentProcess == firstBlockedIteration) {
idleFlag = 1; idleFlag = 1;
unblock(IDLE_PID); unblock(IDLE_PID);
prev = currentProcess; prev = currentProcess;
currentProcess = currentProcess->next; currentProcess = currentProcess->next;
} } else if (currentProcess->state == DEAD) {
else if (currentProcess->state == DEAD) { processCDT *del = currentProcess;
processCDT * del = currentProcess;
currentProcess = currentProcess->next; currentProcess = currentProcess->next;
removeProcess(del, &firstProcess, &lastProcess); removeProcess(del, &firstProcess, &lastProcess);
vPortFree((void *) del); vPortFree((void *) del);
} } else if (currentProcess->state == BLOCKED || currentProcess->state == WAITING ||
else if (currentProcess->state == BLOCKED || currentProcess->state == WAITING || currentProcess->state == BLOCKEDIO) { currentProcess->state == BLOCKEDIO) {
if (firstBlockedIteration == NULL) if (firstBlockedIteration == NULL)
firstBlockedIteration = currentProcess; firstBlockedIteration = currentProcess;
prev = currentProcess; prev = currentProcess;
@ -102,13 +100,13 @@ void idle() {
} }
void initScheduler() { void initScheduler() {
char * argv[] = {"idle"}; char *argv[] = {"idle"};
nice(enqueueProcess(idle, 0, 1, argv, NULL), 19); 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) { if (fd == NULL) {
int * aux = pvPortMalloc(2 * sizeof(int)); int *aux = pvPortMalloc(2 * sizeof(int));
aux[0] = 0; aux[0] = 0;
aux[1] = 1; aux[1] = 1;
fd = aux; fd = aux;
@ -126,13 +124,13 @@ int enqueueProcess(void (*fn) (int, char **), char foreground, int argc, char *a
} }
processADT process = pvPortMalloc(sizeof(processCDT)); processADT process = pvPortMalloc(sizeof(processCDT));
uint64_t * auxi = pvPortMalloc(STACK_SIZE); uint64_t *auxi = pvPortMalloc(STACK_SIZE);
uint64_t * rbp = STACK_SIZE + auxi; uint64_t *rbp = STACK_SIZE + auxi;
uint64_t * rsp = rbp - 20; uint64_t *rsp = rbp - 20;
char priority = (foreground == 1) ? DEF_PRIORITY : MAX_PRIORITY/2;
char * aux = pvPortMalloc(10); char priority = (foreground == 1) ? DEF_PRIORITY : MAX_PRIORITY / 2;
char *aux = pvPortMalloc(10);
int j; int j;
for (j = 0; j < MAX_NAME_SIZE - 1 && argv[0][j] != 0; j++) { for (j = 0; j < MAX_NAME_SIZE - 1 && argv[0][j] != 0; j++) {
aux[j] = argv[0][j]; aux[j] = argv[0][j];
@ -157,10 +155,10 @@ int enqueueProcess(void (*fn) (int, char **), char foreground, int argc, char *a
if (firstProcess == NULL) if (firstProcess == NULL)
firstProcess = process; firstProcess = process;
else else
lastProcess->next = process; lastProcess->next = process;
lastProcess = process; lastProcess = process;
return process->pid; return process->pid;
} }
@ -168,7 +166,7 @@ void sleep(int secs) {
if (currentProcess == NULL) if (currentProcess == NULL)
return; return;
sleepCDT * proc = pvPortMalloc(sizeof(sleepCDT)); sleepCDT *proc = pvPortMalloc(sizeof(sleepCDT));
proc->pid = currentProcess->pid; proc->pid = currentProcess->pid;
proc->secs = secs; proc->secs = secs;
proc->time = getTimeOfDay(); proc->time = getTimeOfDay();
@ -178,7 +176,7 @@ void sleep(int secs) {
block(currentProcess->pid); block(currentProcess->pid);
} }
void wakeUp(sleepCDT * wake, sleepCDT * prev) { void wakeUp(sleepCDT *wake, sleepCDT *prev) {
if (wake == firstSleep) if (wake == firstSleep)
firstSleep = wake->next; firstSleep = wake->next;
else { else {
@ -189,43 +187,42 @@ void wakeUp(sleepCDT * wake, sleepCDT * prev) {
} }
void checkSleeping() { void checkSleeping() {
sleepCDT * prev = NULL; sleepCDT *prev = NULL;
sleepCDT * aux = firstSleep; sleepCDT *aux = firstSleep;
while(aux != NULL) { while (aux != NULL) {
if (getTimeOfDay() >= aux->time + aux->secs) { if (getTimeOfDay() >= aux->time + aux->secs) {
wakeUp(aux, prev); wakeUp(aux, prev);
aux = prev->next; aux = prev->next;
} } else {
else {
prev = aux; prev = aux;
aux = aux->next; aux = aux->next;
} }
} }
} }
processADT searchProcess(processADT * previous, int pid, processADT first) { processADT searchProcess(processADT *previous, int pid, processADT first) {
processADT curr = first; processADT curr = first;
* previous = NULL; *previous = NULL;
while (curr != NULL) { while (curr != NULL) {
if (curr->pid == pid) { if (curr->pid == pid) {
break; break;
} }
* previous = curr; *previous = curr;
curr = curr->next; curr = curr->next;
} }
if (curr == NULL) { if (curr == NULL) {
* previous = NULL; *previous = NULL;
return NULL; return NULL;
} }
return curr; return curr;
} }
void unblockIO() { void unblockIO() {
processCDT * aux = firstProcess; processCDT *aux = firstProcess;
while(aux != NULL) { while (aux != NULL) {
if (aux->state == BLOCKEDIO) if (aux->state == BLOCKEDIO)
aux->state = READY; aux->state = READY;
aux = aux->next; aux = aux->next;
} }
} }
@ -237,7 +234,7 @@ char blockIO() {
currentProcess->state = BLOCKEDIO; currentProcess->state = BLOCKEDIO;
} }
processCDT * prev = NULL; processCDT *prev = NULL;
processADT parent = searchProcess(&prev, currentProcess->ppid, firstProcess); processADT parent = searchProcess(&prev, currentProcess->ppid, firstProcess);
if (currentProcess->foreground) { if (currentProcess->foreground) {
if (parent->backWait) { if (parent->backWait) {
@ -247,7 +244,7 @@ char blockIO() {
} }
forceTimer(); forceTimer();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
char block(int pid) { char block(int pid) {
@ -270,7 +267,7 @@ char block(int pid) {
forceTimer(); forceTimer();
} }
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
char unblock(int pid) { char unblock(int pid) {
@ -278,8 +275,7 @@ char unblock(int pid) {
processADT del = searchProcess(&prev, pid, firstProcess); processADT del = searchProcess(&prev, pid, firstProcess);
if (del == NULL || del->state == DEAD) { if (del == NULL || del->state == DEAD) {
return EXIT_FAILURE; return EXIT_FAILURE;
} } else {
else {
del->state = READY; del->state = READY;
} }
@ -347,8 +343,7 @@ char nice(int pid, char offset) {
processADT del = searchProcess(&prev, pid, firstProcess); processADT del = searchProcess(&prev, pid, firstProcess);
if (del == NULL) { if (del == NULL) {
return EXIT_FAILURE; return EXIT_FAILURE;
} } else {
else {
del->priority = offset + 20; del->priority = offset + 20;
} }
return EXIT_SUCCESS; return EXIT_SUCCESS;
@ -391,7 +386,7 @@ char isForeground() {
return currentProcess->foreground; 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); char copied = strcpy(*out, in);
*out += copied; *out += copied;
*out += addSpaces(*out, toAdd - 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) if (proc == NULL)
return EXIT_FAILURE; return EXIT_FAILURE;
@ -421,26 +416,27 @@ char getProcessData(char * out, processCDT * proc) {
out += addSpaces(out, 2); out += addSpaces(out, 2);
written += 2; written += 2;
char buffer[10]; char buffer[10];
getGenProcessData(&out, &written, MAX_ATTR_SIZE, itoa(proc->pid, buffer, 10, 10), 0); getGenProcessData(&out, &written, MAX_ATTR_SIZE, itoa(proc->pid, buffer, 10, 10), 0);
getGenProcessData(&out, &written, MAX_ATTR_SIZE, itoa(proc->priority, buffer, 10, 2), 0); getGenProcessData(&out, &written, MAX_ATTR_SIZE, itoa(proc->priority, buffer, 10, 2), 0);
getGenProcessData(&out, &written, MAX_NAME_SIZE, itoa(proc->rsp, buffer, 16, 10), 0); 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_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->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; return written;
} }
char * processes(){ char *processes() {
char * ans = pvPortMalloc(pids * PROCESS_DATA_MAX_SIZE); char *ans = pvPortMalloc(pids * PROCESS_DATA_MAX_SIZE);
char * ret = ans; 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); ans += strcpy(ans, info);
processCDT * aux = firstProcess; processCDT *aux = firstProcess;
while (aux != NULL) { while (aux != NULL) {
char writtenChars = getProcessData(ans, aux); char writtenChars = getProcessData(ans, aux);
if (writtenChars == EXIT_FAILURE) if (writtenChars == EXIT_FAILURE)

71
Kernel/utils/sem.c
View File

@ -3,20 +3,20 @@
static uint32_t semLock; static uint32_t semLock;
typedef struct node_t { typedef struct node_t {
sem_t * sem; sem_t *sem;
struct node_t * next; struct node_t *next;
} node_t; } node_t;
node_t * firstSem = NULL; node_t *firstSem = NULL;
static char counter = 0; static char counter = 0;
sem_t * semOpen(char * name, unsigned int value) { sem_t *semOpen(char *name, unsigned int value) {
enter_region(&semLock); enter_region(&semLock);
sem_t * sem = pvPortMalloc(sizeof(sem_t)); sem_t *sem = pvPortMalloc(sizeof(sem_t));
node_t * node = pvPortMalloc(sizeof(node_t)); node_t *node = pvPortMalloc(sizeof(node_t));
node->sem = sem; node->sem = sem;
node->next = firstSem; node->next = firstSem;
firstSem = node; firstSem = node;
sem->name = pvPortMalloc(MAX_NAME); sem->name = pvPortMalloc(MAX_NAME);
strcpy(sem->name, name); strcpy(sem->name, name);
@ -28,27 +28,27 @@ sem_t * semOpen(char * name, unsigned int value) {
return sem; return sem;
} }
char semClose(sem_t * sem) { char semClose(sem_t *sem) {
if (sem == NULL) if (sem == NULL)
return EXIT_FAILURE; return EXIT_FAILURE;
enter_region(&semLock); enter_region(&semLock);
node_t * del = NULL; node_t *del = NULL;
if (firstSem->sem == sem) { if (firstSem->sem == sem) {
del = firstSem; del = firstSem;
firstSem = firstSem->next; firstSem = firstSem->next;
} } else {
else { node_t *aux = firstSem;
node_t * aux = firstSem;
while (aux != NULL) { while (aux != NULL) {
if (aux->next != NULL) if (aux->next != NULL) {
if (aux->next->sem == sem) { if (aux->next->sem == sem) {
del = aux->next; del = aux->next;
aux->next = aux->next->next; aux->next = aux->next->next;
break; break;
} }
}
aux = aux->next; aux = aux->next;
} }
} }
@ -58,32 +58,31 @@ char semClose(sem_t * sem) {
return EXIT_FAILURE; return EXIT_FAILURE;
} }
pid_t * pid = sem->entering; pid_t *pid = sem->entering;
while (pid != NULL) { while (pid != NULL) {
pid_t * aux = pid; pid_t *aux = pid;
pid = pid->next; pid = pid->next;
vPortFree(aux); vPortFree(aux);
} }
vPortFree(sem->name); vPortFree(sem->name);
vPortFree(sem); vPortFree(sem);
vPortFree(del); vPortFree(del);
counter--; counter--;
leave_region(&semLock); leave_region(&semLock);
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
void semWait(sem_t * sem) { void semWait(sem_t *sem) {
enter_region(&semLock); enter_region(&semLock);
if (sem->value > 0) { if (sem->value > 0) {
sem->value--; sem->value--;
} } else {
else {
leave_region(&semLock); leave_region(&semLock);
pid_t * curr = pvPortMalloc(sizeof(pid_t)); pid_t *curr = pvPortMalloc(sizeof(pid_t));
curr->pid = getPid(); curr->pid = getPid();
curr->next = NULL; curr->next = NULL;
if (sem->entering == NULL) if (sem->entering == NULL)
@ -100,13 +99,13 @@ void semWait(sem_t * sem) {
leave_region(&semLock); leave_region(&semLock);
} }
void semPost(sem_t * sem) { void semPost(sem_t *sem) {
enter_region(&semLock); enter_region(&semLock);
sem->value++; sem->value++;
if (sem->entering != NULL) { if (sem->entering != NULL) {
pid_t * aux = sem->entering; pid_t *aux = sem->entering;
sem->entering = sem->entering->next; sem->entering = sem->entering->next;
if (sem->entering == NULL) if (sem->entering == NULL)
sem->last = NULL; sem->last = NULL;
@ -117,7 +116,7 @@ void semPost(sem_t * sem) {
leave_region(&semLock); leave_region(&semLock);
} }
char getSemaphoresData(char * out, node_t * node) { char getSemaphoresData(char *out, node_t *node) {
if (node == NULL) if (node == NULL)
return EXIT_FAILURE; return EXIT_FAILURE;
@ -136,7 +135,7 @@ char getSemaphoresData(char * out, node_t * node) {
out += addSpaces(out, 2); out += addSpaces(out, 2);
written += 2; written += 2;
char buffer[10]; char buffer[10];
char copied = strcpy(out, itoa(node->sem->value, buffer, 10, 2)); char copied = strcpy(out, itoa(node->sem->value, buffer, 10, 2));
out += copied; out += copied;
@ -146,7 +145,7 @@ char getSemaphoresData(char * out, node_t * node) {
written += 2; written += 2;
pid_t *aux_pid = node->sem->entering; pid_t *aux_pid = node->sem->entering;
while (aux_pid != NULL) { while (aux_pid != NULL) {
copied = strcpy(out, itoa(aux_pid->pid, buffer, 10, 10)); copied = strcpy(out, itoa(aux_pid->pid, buffer, 10, 10));
aux_pid = aux_pid->next; aux_pid = aux_pid->next;
@ -157,11 +156,9 @@ char getSemaphoresData(char * out, node_t * node) {
return written; return written;
} }
#define MAX_PID 4 char *getEntering(sem_t *sem) {
char *ans = pvPortMalloc(sizeof(pid_t * ));
char * getEntering(sem_t * sem){ pid_t *aux = sem->entering;
char * ans = pvPortMalloc(sizeof(pid_t *));
pid_t * aux = sem->entering;
char buffer[MAX_PID]; char buffer[MAX_PID];
while (aux != NULL) { while (aux != NULL) {
strcpy(ans, itoa(aux->pid, buffer, 10, 3)); strcpy(ans, itoa(aux->pid, buffer, 10, 3));
@ -172,14 +169,14 @@ char * getEntering(sem_t * sem){
return ans; return ans;
} }
char * getSems() { char *getSems() {
char * ans = pvPortMalloc(counter * SEM_DATA_MAX_SIZE); char *ans = pvPortMalloc(counter * SEM_DATA_MAX_SIZE);
char * ret = ans; char *ret = ans;
char * info = "name value pidsWaiting\n"; char *info = "name value pidsWaiting\n";
ans += strcpy(ans, info); ans += strcpy(ans, info);
node_t * aux = firstSem; node_t *aux = firstSem;
while (aux != NULL) { while (aux != NULL) {
char writtenChars = getSemaphoresData(ans, aux); char writtenChars = getSemaphoresData(ans, aux);
if (writtenChars == EXIT_FAILURE) if (writtenChars == EXIT_FAILURE)

95
Userland/SampleCodeModule/Makefile
View File

@ -1,58 +1,37 @@
include ../Makefile.inc include ../Makefile.inc
MODULE=0000-sampleCodeModule.bin MODULE=0000-sampleCodeModule.bin
MODULE_ELF=0000-sampleCodeModule.elf MODULE_ELF=0000-sampleCodeModule.elf
SOURCES=$(wildcard *.c) SOURCES=$(wildcard *.c)
SOURCES_SHELL=$(wildcard shell/*.c) SOURCES_SHELL=$(wildcard shell/*.c)
SOURCES_ASM=$(wildcard asm/*.asm) SOURCES_ASM=$(wildcard asm/*.asm)
SOURCES_PROMPT=$(wildcard shell/commands/*.c) SOURCES_PROMPT=$(wildcard shell/commands/*.c)
SOURCES_BOTTLER=$(wildcard bottler/*.c) SOURCES_BOTTLER=$(wildcard bottler/*.c)
OBJECTS=$(SOURCES:.c=.o) OBJECTS=$(SOURCES:.c=.o)
OBJECTS_SHELL=$(SOURCES_SHELL:.c=.o) OBJECTS_SHELL=$(SOURCES_SHELL:.c=.o)
OBJECTS_PROMPT=$(SOURCES_PROMPT:.c=.o) OBJECTS_PROMPT=$(SOURCES_PROMPT:.c=.o)
OBJECTS_BOTTLER=$(SOURCES_BOTTLER:.c=.o) OBJECTS_BOTTLER=$(SOURCES_BOTTLER:.c=.o)
OBJECTS_ASM=$(SOURCES_ASM:.asm=.o) OBJECTS_ASM=$(SOURCES_ASM:.asm=.o)
ALL_OBJECTS= $(OBJECTS) $(OBJECTS_ASM) $(OBJECTS_SHELL) $(OBJECTS_COMMANDS) $(OBJECTS_PROMPT) $(OBJECTS_BOTTLER) ALL_OBJECTS= $(OBJECTS) $(OBJECTS_ASM) $(OBJECTS_SHELL) $(OBJECTS_COMMANDS) $(OBJECTS_PROMPT) $(OBJECTS_BOTTLER)
STATICLIBS= STATICLIBS=
all: $(MODULE) $(MODULE_ELF) #shellModule all: $(MODULE) $(MODULE_ELF)
#shellModule: $(MODULE): $(STATICLIBS) $(ALL_OBJECTS)
# cd shell; make $(LD) $(LDFLAGS) -T sampleCodeModule.ld $(OBJECTS) $(OBJECTS_SHELL) $(OBJECTS_ASM) $(OBJECTS_PROMPT) $(OBJECTS_BOTTLER) -o ../$(MODULE)
$(MODULE): $(STATICLIBS) $(ALL_OBJECTS) $(MODULE_ELF): $(STATICLIBS) $(ALL_OBJECTS)
$(LD) $(LDFLAGS) -T sampleCodeModule.ld $(OBJECTS) $(OBJECTS_SHELL) $(OBJECTS_ASM) $(OBJECTS_PROMPT) $(OBJECTS_BOTTLER) -o ../$(MODULE) $(LD) $(LDFLAGS) -I./include -I./shell/include -I./bottler/include -T sampleCodeModule.ld --oformat=elf64-x86-64 $(OBJECTS) $(OBJECTS_SHELL) $(OBJECTS_ASM) $(OBJECTS_PROMPT) $(OBJECTS_BOTTLER) -o ../$(MODULE_ELF)
$(MODULE_ELF): $(STATICLIBS) $(ALL_OBJECTS) %.o:%.c
$(LD) $(LDFLAGS) -I./include -I./shell/include -I./bottler/include -T sampleCodeModule.ld --oformat=elf64-x86-64 $(OBJECTS) $(OBJECTS_SHELL) $(OBJECTS_ASM) $(OBJECTS_PROMPT) $(OBJECTS_BOTTLER) -o ../$(MODULE_ELF) $(GCC) $(GCCFLAGS) -T _loader.c -I./include -I./shell/include -I./bottler/include -c $< -o $@
%.o:%.c %.o:%.asm
$(GCC) $(GCCFLAGS) -T _loader.c -I./include -I./shell/include -I./bottler/include -c $< -o $@ $(ASM) $(ASMFLAGS) $< -o $@
%.o:%.asm clean:
$(ASM) $(ASMFLAGS) $< -o $@ rm -rf $(ALL_OBJECTS)
clean: .PHONY: all clean print
# cd shell; make clean
rm -rf *.o
cd shell; rm -rf *.o
cd shell/commands; rm -rf *.o
.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

21
Userland/SampleCodeModule/_loader.c
View File

@ -1,4 +1,3 @@
/* _loader.c */
#include <stdint.h> #include <stdint.h>
extern char bss; extern char bss;
@ -6,22 +5,20 @@ extern char endOfBinary;
int main(int argc, char *argv[]); 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[]) { int _start(int argc, char *argv[]) {
//Clean BSS memset(&bss, 0, &endOfBinary - &bss);
memset(&bss, 0, &endOfBinary - &bss);
return main(argc, argv); 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) { while (length--)
uint8_t chr = (uint8_t)c; dst[length] = chr;
char * dst = (char*)destination;
while(length--) return destination;
dst[length] = chr;
return destination;
} }

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

@ -1,41 +1,66 @@
#include "bottler.h" #include "bottler.h"
void bottler(int argc, char ** argv) { void bottler(int argc, char **argv) {
printStringLen(" ", 80); new_line(); printStringLen(" ", 80);
printStringLen(" (%( ", 80); new_line(); new_line();
printStringLen( " Welcome to", 17); printStringLen(" (%( ", 80);
printStringLen(" %%%%% ", 80); new_line(); new_line();
printStringLen( " BottlerOS", 18); printStringLen(" Welcome to", 17);
printStringLen(" %%% ", 80); new_line(); printStringLen(" %%%%% ", 80);
printStringLen( " %%%%%%%%%%%%% ", 80); new_line(); new_line();
printStringLen( " %%%%%%%%%%%%%%%%%%%%% ", 80); new_line(); printStringLen(" BottlerOS", 18);
printStringLen( " %%%%%%% %%%%%%% ", 80); new_line(); printStringLen(" %%% ", 80);
printStringLen( " %%%%% %%%%% ", 80); new_line(); new_line();
printStringLen( " %%%%% %%%%% ", 80); new_line(); printStringLen(" %%%%%%%%%%%%% ", 80);
printStringLen( " %%%%% ", 27); new_line();
printStringLen( " %%%% %%%% ", 22); printStringLen(" %%%%%%%%%%%%%%%%%%%%% ", 80);
printStringLen( " %%%%% ", 30); new_line(); new_line();
printStringLen( " %%%%% ", 28); printStringLen(" %%%%%%% %%%%%%% ", 80);
printStringLen( " (% %( ", 21); new_line();
printStringLen( " %%%%% ", 30); new_line(); printStringLen(" %%%%% %%%%% ", 80);
printStringLen( " %%%%%%% %%%%%%% ", 80); new_line(); new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line(); printStringLen(" %%%%% %%%%% ", 80);
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line(); new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%% ", 41); printStringLen(" %%%%% ", 27);
printStringLen( " % %* ", 8); printStringLen(" %%%% %%%% ", 22);
printStringLen(" %%%%%%%%% ", 30); new_line(); printStringLen(" %%%%% ", 30);
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80); new_line(); new_line();
printStringLen(" %%**%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/%% ", 80); new_line(); printStringLen(" %%%%% ", 28);
printStringLen(" %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%% ", 80); new_line(); printStringLen(" (% %( ", 21);
printStringLen(" %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%% ", 80); new_line(); printStringLen(" %%%%% ", 30);
printStringLen(" %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% ", 80); new_line(); new_line();
printStringLen( " ,%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%. ", 80); new_line(); printStringLen(" %%%%%%% %%%%%%% ", 80);
printStringLen( " %%. %%%%%%%%%%%%%%%%% .%% ", 80); new_line(); new_line();
printStringLen( " %%%%%%%%%%%%% ", 80); new_line(); printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80);
printStringLen( " %%%%%%% ", 80); new_line(); new_line();
printStringLen( " ", 80); new_line(); printStringLen(" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ", 80);
sys_sleep(3); new_line();
printStringLen(" %%%%%%%%%%%%%%%%%%%%%%% ", 41);
winClear(); 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();
sys_exit(); sys_exit();
} }

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

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

251
Userland/SampleCodeModule/libc.c
View File

@ -1,43 +1,43 @@
#include "libc.h" #include "libc.h"
void printString(char * string) { void printString(char *string) {
int len = strlen(string); int len = strlen(string);
sys_write(1, string, len); sys_write(1, string, len);
} }
void printStringLen(char * string, int len) { void printStringLen(char *string, int len) {
sys_write(1, string, len); sys_write(1, string, len);
} }
void printStringError(char * string) { void printStringError(char *string) {
int len = strlen(string); int len = strlen(string);
sys_write(2, string, len); sys_write(2, string, len);
} }
int strlen(const char * s) { int strlen(const char *s) {
int i = 0; int i = 0;
for (i = 0; s[i] != '\0'; i++); for (i = 0; s[i] != '\0'; i++);
return i; return i;
} }
int strcmp(const char * s1, const char * s2) { int strcmp(const char *s1, const char *s2) {
while(*s1 && (*s1 == *s2)) { while (*s1 && (*s1 == *s2)) {
s1++; s1++;
s2++; s2++;
} }
return *s1 - *s2; return *s1 - *s2;
} }
char * strcat(char * dest, const char * src) { char *strcat(char *dest, const char *src) {
char * rdest = dest; char *rdest = dest;
while (*dest) while (*dest)
dest++; dest++;
while ((*dest++ = *src++)); while ((*dest++ = *src++));
return rdest; return rdest;
} }
void putChar(char c){ void putChar(char c) {
char buffer = c; char buffer = c;
sys_write(1, &buffer, 0); sys_write(1, &buffer, 0);
} }
@ -54,33 +54,32 @@ void winClear() {
sys_write(1, "\e\f", 2); sys_write(1, "\e\f", 2);
} }
int strcpy(char * strDest, const char * strSrc) { int strcpy(char *strDest, const char *strSrc) {
int i = 0; int i = 0;
while ((*strDest++ = *strSrc++)) { while ((*strDest++ = *strSrc++)) {
i++; i++;
} }
return i; 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) { if (base < 2 || base > 32) {
return buffer; return buffer;
} }
int n = abs(value); int n = abs(value);
int i = 0; int i = 0;
while (n && i < length) { while (n && i < length) {
int r = n % base; int r = n % base;
if (r >= 10) { if (r >= 10) {
buffer[i++] = 65 + (r - 10); buffer[i++] = 65 + (r - 10);
} } else {
else {
buffer[i++] = 48 + r; buffer[i++] = 48 + r;
} }
n = n / base; n = n / base;
} }
if (i == 0) { if (i == 0) {
buffer[i++] = '0'; buffer[i++] = '0';
} }
@ -88,9 +87,9 @@ char* gtoa(int value, char* buffer, int base, int length) {
if (value < 0 && base == 10) { if (value < 0 && base == 10) {
buffer[i++] = '-'; buffer[i++] = '-';
} }
buffer[i] = '\0'; buffer[i] = '\0';
return reverse(buffer, 0, i - 1); return reverse(buffer, 0, i - 1);
} }
@ -102,61 +101,54 @@ char getChar() {
} }
void swap(char *x, char *y) { 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) { while (i < j) {
swap(&buffer[i++], &buffer[j--]); swap(&buffer[i++], &buffer[j--]);
} }
return buffer; return buffer;
} }
int abs(int value) { int abs(int value) {
return value < 0 ? -value : 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) { if (base < 2 || base > 32) {
return buffer; return buffer;
} }
int n = abs(value); int n = abs(value);
int i = 0; int i = 0;
while (n) { while (n) {
int r = n % base; int r = n % base;
if (r >= 10) { if (r >= 10) {
buffer[i++] = 65 + (r - 10); buffer[i++] = 65 + (r - 10);
} } else {
else {
buffer[i++] = 48 + r; buffer[i++] = 48 + r;
} }
n = n / base; n = n / base;
} }
if (i == 0) { if (i == 0) {
buffer[i++] = '0'; buffer[i++] = '0';
} }
if (value < 0 && base == 10) { if (value < 0 && base == 10) {
buffer[i++] = '-'; buffer[i++] = '-';
} }
buffer[i] = '\0'; buffer[i] = '\0';
return reverse(buffer, 0, i - 1); 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 atoi(char *str, int length) {
int i = 0, sign = 1, val = 0, nbr = 0; int i = 0, sign = 1, val = 0, nbr = 0;
while (str[i] != '\0') { while (str[i] != '\0') {
@ -177,14 +169,14 @@ int atoi(char *str, int length) {
} }
int pow(int base, int exponent) { int pow(int base, int exponent) {
int result = 1; int result = 1;
for (; exponent > 0; exponent--) { for (; exponent > 0; exponent--) {
result = result * base; result = result * base;
} }
return result; return result;
} }
char isFloat(char * str) { char isFloat(char *str) {
int dot = 0; int dot = 0;
if (*str == '-') if (*str == '-')
str++; str++;
@ -201,9 +193,9 @@ char isFloat(char * str) {
float atof(char *arr) { float atof(char *arr) {
float val = 0; float val = 0;
int afterdot=0; int afterdot = 0;
float scale=1; float scale = 1;
int neg = 0; int neg = 0;
if (*arr == '-') { if (*arr == '-') {
arr++; arr++;
@ -211,21 +203,21 @@ float atof(char *arr) {
} }
while (*arr) { while (*arr) {
if (afterdot) { if (afterdot) {
scale = scale/10; scale = scale / 10;
val = val + (*arr-'0')*scale; val = val + (*arr - '0') * scale;
} else { } else {
if (*arr == '.') if (*arr == '.')
afterdot++; afterdot++;
else else
val = val * 10.0 + (*arr - '0'); val = val * 10.0 + (*arr - '0');
} }
arr++; arr++;
} }
if(neg) return -val; if (neg) return -val;
else return val; else return val;
} }
char * strstrip(char * s, char c) { char *strstrip(char *s, char c) {
while (*s != 0) { while (*s != 0) {
if (*s != c) if (*s != c)
break; break;
@ -234,20 +226,19 @@ char * strstrip(char * s, char c) {
return s; return s;
} }
char *strtok(char * s, char delim) { char *strtok(char *s, char delim) {
char *ptr = s; char *ptr = s;
if (s == 0) { if (s == 0) {
return 0; return 0;
} }
int flag = 0; int flag = 0;
while (*ptr != 0) { while (*ptr != 0) {
if (*ptr == delim) { if (*ptr == delim) {
flag = 1; flag = 1;
*ptr = 0; *ptr = 0;
} } else if (flag == 1)
else if (flag == 1)
return ptr; return ptr;
ptr++; ptr++;
} }
@ -260,84 +251,84 @@ char isNumber(char c) {
// Tomada y modificada de https://github.com/antongus/stm32tpl/blob/master/ftoa.c // Tomada y modificada de https://github.com/antongus/stm32tpl/blob/master/ftoa.c
#define MAX_PRECISION (10) #define MAX_PRECISION (10)
static const double rounders[MAX_PRECISION + 1] = static const double rounders[MAX_PRECISION + 1] =
{ {
0.5, // 0 0.5, // 0
0.05, // 1 0.05, // 1
0.005, // 2 0.005, // 2
0.0005, // 3 0.0005, // 3
0.00005, // 4 0.00005, // 4
0.000005, // 5 0.000005, // 5
0.0000005, // 6 0.0000005, // 6
0.00000005, // 7 0.00000005, // 7
0.000000005, // 8 0.000000005, // 8
0.0000000005, // 9 0.0000000005, // 9
0.00000000005 // 10 0.00000000005 // 10
}; };
void ftoa(double f, char * buf, int precision) { void ftoa(double f, char *buf, int precision) {
char * ptr = buf; char *ptr = buf;
char * p = ptr; char *p = ptr;
char * p1; char *p1;
char c; char c;
long intPart; long intPart;
if (precision > MAX_PRECISION) if (precision > MAX_PRECISION)
precision = MAX_PRECISION; precision = MAX_PRECISION;
if (f < 0) { if (f < 0) {
f = -f; f = -f;
*ptr++ = '-'; *ptr++ = '-';
} }
if (precision < 0) { if (precision < 0) {
if (f < 1.0) precision = 6; if (f < 1.0) precision = 6;
else if (f < 10.0) precision = 5; else if (f < 10.0) precision = 5;
else if (f < 100.0) precision = 4; else if (f < 100.0) precision = 4;
else if (f < 1000.0) precision = 3; else if (f < 1000.0) precision = 3;
else if (f < 10000.0) precision = 2; else if (f < 10000.0) precision = 2;
else if (f < 100000.0) precision = 1; else if (f < 100000.0) precision = 1;
else precision = 0; else precision = 0;
} }
if (precision) if (precision)
f += rounders[precision]; f += rounders[precision];
intPart = f; intPart = f;
f -= intPart; f -= intPart;
if (!intPart) if (!intPart)
*ptr++ = '0'; *ptr++ = '0';
else { else {
p = ptr; p = ptr;
while (intPart) { while (intPart) {
*p++ = '0' + intPart % 10; *p++ = '0' + intPart % 10;
intPart /= 10; intPart /= 10;
} }
p1 = p; p1 = p;
while (p > ptr) { while (p > ptr) {
c = *--p; c = *--p;
*p = *ptr; *p = *ptr;
*ptr++ = c; *ptr++ = c;
} }
ptr = p1; ptr = p1;
} }
if (precision && ((int) (f * pow(10, precision))) != 0) { if (precision && ((int) (f * pow(10, precision))) != 0) {
*ptr++ = '.'; *ptr++ = '.';
while (precision-- && ((int) (f * pow(10, precision))) != 0) { while (precision-- && ((int) (f * pow(10, precision))) != 0) {
f *= 10.0; f *= 10.0;
c = f; c = f;
*ptr++ = '0' + c; *ptr++ = '0' + c;
f -= c; f -= c;
} }
} }
*ptr = 0; *ptr = 0;
} }

11
Userland/SampleCodeModule/sampleCodeModule.c
View File

@ -1,22 +1,19 @@
/* sampleCodeModule.c */
#include "libc.h" #include "libc.h"
#include "shell/include/shell.h" #include "shell/include/shell.h"
#include "bottler/include/bottler.h" #include "bottler/include/bottler.h"
#include <stddef.h> #include <stddef.h>
#include "system.h"
int sys_loadProcess(void (*fn) (int, char **), char foreground, int argc, char *argv[], int * fd);
void sys_exit();
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
winClear(); winClear();
char * argv1[] = {"bottler"}; char *argv1[] = {"bottler"};
sys_loadProcess(bottler, 1, 1, argv1, NULL); sys_loadProcess(bottler, 1, 1, argv1, NULL);
sys_wait(); sys_wait();
char * argv2[] = {"shell"}; char *argv2[] = {"shell"};
sys_loadProcess(shell, 1, 1, argv2, NULL); sys_loadProcess(shell, 1, 1, argv2, NULL);
sys_exit(); sys_exit();
return 1; return 1;
} }

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