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

Add BottlerOS files 

Co-authored-by: Juan Barmasch <jbarmasch@itba.edu.ar>
Co-authored-by: Ezequiel Bellver <ebellver@itba.edu.ar>
This commit is contained in:
Santiago Lo Coco 2021-09-19 10:24:58 -03:00
commit 2d6e9285db
102 changed files with 9542 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2309
.gdbinit Normal file
View File

File diff suppressed because it is too large Load Diff

11
.gitignore vendored Normal file
View File

@ -0,0 +1,11 @@
#Binary Files
*.bin
*.sys
#The images
*.img
*.qcow2
*.vmdk
#Object files
*.o

26
.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,26 @@
{
"files.associations": {
"interrupts.h": "c",
"time.h": "c",
"naiveconsole.h": "c",
"keyboard.h": "c",
"video.h": "c",
"lib.h": "c",
"libc.h": "c",
"cstdio": "c",
"shell.h": "c",
"defs.h": "c",
"idtloader.h": "c",
"exit.h": "c",
"help.h": "c",
"cstdlib": "c",
"inforeg.h": "c",
"cpuid.h": "c",
"cpu_id.h": "c",
"switch.h": "c",
"stdint.h": "c",
"pcb.h": "c",
"systemcalls.h": "c",
"quadratic.h": "c"
}
}

114
Bootloader/BMFS/BareMetal File System.md Normal file
View File

@ -0,0 +1,114 @@
# BareMetal File System (BMFS) - Version 1
BMFS is a new file system used by the BareMetal kernel and its related systems. The design is extremely simplified compared to conventional file systems. The system is also geared more toward a small number of very large files (databases, large data files). As all files are contiguous we can also implement memory mapped disk IO. BMFS was inspired by the [RT11 File System](http://en.wikipedia.org/wiki/RT11#File_system).
## Characteristics:
- Very simple layout
- All files are contiguous
- Disk is divided into 2 MiB blocks
- Flat organization; no subdirectories/subfolders
## Disk structure
**Blocks**
For simplicity, BMFS acts as an abstraction layer where a number of contiguous [sectors](http://en.wikipedia.org/wiki/Disk_sector) are accessed instead of individual sectors. With BMFS, each disk block is 2MiB. The disk driver will handle the optimal way to access the disk (based on if the disk uses 512 byte sectors or supports the new [Advanced Format](http://en.wikipedia.org/wiki/Advanced_Format) 4096 byte sectors). 2MiB blocks were chosen to match the 2MiB memory page allocation that is used within BareMetal.
**Free Blocks**
The location of free blocks can be calculated from the directory. As all files are contiguous we can extract the location of free blocks by comparing against the blocks that are currently in use. The calculation for locating free blocks only needs to be completed in the file create function.
**Disk layout**
The first and last disk blocks are reserved for file system usage. All other disk blocks can be used for data.
Block 0:
4KiB - Legacy MBR (Master Boot Sector) sector (512B)
- Free space (512B)
- BMFS marker (512B)
- Free space (2560B)
4KiB - Directory (Max 64 files, 64-bytes for each record)
The remaining space in Block 0 is free to use.
Block 1 .. n-1:
Data
Block n (last block on disk):
Copy of Block 0
**Directory**
BMFS supports a single directory with a maximum of 64 individual files. Each file record is 64 bytes. The directory structure is 4096 bytes and starts at sector 8.
**Directory Record structure**:
Filename (32 bytes) - Null-terminated ASCII string
Starting Block number (64-bit unsigned int)
Blocks reserved (64-bit unsigned int)
File size (64-bit unsigned int)
Unused (8 bytes)
A file name that starts with 0x00 marks the end of the directory. A file name that starts with 0x01 marks an unused record that should be ignored.
Maximum file size supported is 70,368,744,177,664 bytes (64 TiB) with a maximum of 33,554,432 allocated blocks.
## Files
The following system calls should be available:
- Create (Create and reserve space for a new file)
- Delete (Delete an existing file from the file system)
- Read (Read a file into system memory)
- Write (Write a section of system memory to a file)
- Directory/List (Prepare and display a list of file)
- Query (Query the existence/details of a file)
**Create**
The create function accepts two parameters:
Name = A null-terminated string no more that 31 characters
Reserved = The number of blocks to reserve for the file
**Delete**
The delete function accepts one parameter:
Name = The name of the file to delete
**Read**
The read function accepts two parameters:
Name = The name of the file to read
Destination = The memory address to store the file
**Write**
The write function accepts three parameters:
Name = The name of the file to write
Source = The memory address of the data
Size = The amount of bytes to write
**Directory/List**
The dir/ls function accepts no parameters
**Query**
The query function accepts one parameter:
Name = The name of the file to query
The query function will return the following:
Size = The current size of the file in bytes
Reserved = The amount of blocks reserved for the file (0 if it doesn't exist)

4
Bootloader/BMFS/Makefile Normal file
View File

@ -0,0 +1,4 @@
all:
gcc -ansi -std=c99 -Wall -pedantic -o bmfs.bin bmfs.c
clean:
rm -f bmfs.bin

69
Bootloader/BMFS/README.md Normal file
View File

@ -0,0 +1,69 @@
# BMFS
Utility for accessing a disk or disk image formatted with BareMetal File System (BMFS).
## Creating a new, formatted disk image
bmfs disk.image initialize 128M
## Creating a new disk image that boots BareMetal OS
bmfs disk.image initialize 128M path/to/bmfs_mbr.sys path/to/pure64.sys path/to/kernel64.sys
or if the Pure64 boot loader and BareMetal-OS kernel are combined into one file:
bmfs disk.image initialize 128M path/to/bmfs_mbr.sys path/to/software.sys
## Formatting a disk image
bmfs disk.image format
In Linux/Unix/Mac OS X you can also format a physical drive by passing the correct path.
sudo bmfs /dev/sdc format
## Display BMFS disk contents
bmfs disk.image list
Sample output:
C:\baremetal>utils\bmfs BMFS-256-flat.vmdk list
BMFS-256-flat.vmdk
Disk Size: 256 MiB
Name | Size (B)| Reserved (MiB)
==========================================================================
test.app 31 2
Another file.app 1 2
helloc.app 800 2
## Create a new file and reserve space for it
bmfs disk.image create FileName.Ext
You will be prompted for the size to reserve.
Alternately, you can specify the reserved size after the file name. The reserved size is given in Megabytes and will automatically round up to an even number.
bmfs disk.image create FileName.Ext 4
## Read from BMFS to a local file
bmfs disk.image read FileName.Ext
## Write a local file to BMFS
bmfs disk.image write FileName.Ext
## Delete a file on BMFS
bmfs disk.image delete FileName.Ext

822
Bootloader/BMFS/bmfs.c Normal file
View File

@ -0,0 +1,822 @@
/* BareMetal File System Utility */
/* Written by Ian Seyler of Return Infinity */
/* Global includes */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
/* Global defines */
struct BMFSEntry
{
char FileName[32];
unsigned long long StartingBlock;
unsigned long long ReservedBlocks;
unsigned long long FileSize;
unsigned long long Unused;
};
/* Global constants */
// Min disk size is 6MiB (three blocks of 2MiB each.)
const unsigned long long minimumDiskSize = (6 * 1024 * 1024);
/* Global variables */
FILE *file, *disk;
unsigned int filesize, disksize;
char tempfilename[32], tempstring[32];
char *filename, *diskname, *command;
char fs_tag[] = "BMFS";
char s_list[] = "list";
char s_format[] = "format";
char s_initialize[] = "initialize";
char s_create[] = "create";
char s_read[] = "read";
char s_write[] = "write";
char s_delete[] = "delete";
struct BMFSEntry entry;
void *pentry = &entry;
char *BlockMap;
char *FileBlocks;
char Directory[4096];
char DiskInfo[512];
/* Built-in functions */
int findfile(char *filename, struct BMFSEntry *fileentry, int *entrynumber);
void list();
void format();
int initialize(char *diskname, char *size, char *mbr, char *boot, char *kernel);
void create(char *filename, unsigned long long maxsize);
void read(char *filename);
void write(char *filename);
void delete(char *filename);
/* Program code */
int main(int argc, char *argv[])
{
/* Parse arguments */
if (argc < 3)
{
printf("BareMetal File System Utility v1.0 (2013 04 10)\n");
printf("Written by Ian Seyler @ Return Infinity (ian.seyler@returninfinity.com)\n\n");
printf("Usage: %s disk function file\n", argv[0]);
printf("Disk: the name of the disk file\n");
printf("Function: list, read, write, create, delete, format, initialize\n");
printf("File: (if applicable)\n");
exit(0);
}
diskname = argv[1];
command = argv[2];
filename = argv[3];
if (strcasecmp(s_initialize, command) == 0)
{
if (argc >= 4)
{
char *size = argv[3]; // Required
char *mbr = (argc > 4 ? argv[4] : NULL); // Opt.
char *boot = (argc > 5 ? argv[5] : NULL); // Opt.
char *kernel = (argc > 6 ? argv[6] : NULL); // Opt.
int ret = initialize(diskname, size, mbr, boot, kernel);
exit(ret);
}
else
{
printf("Usage: %s disk %s ", argv[0], command);
printf("size [mbr_file] ");
printf("[bootloader_file] [kernel_file]\n");
exit(1);
}
}
if ((disk = fopen(diskname, "r+b")) == NULL) // Open for read/write in binary mode
{
printf("Error: Unable to open disk '%s'\n", diskname);
exit(0);
}
else // Opened ok, is it a valid BMFS disk?
{
fseek(disk, 0, SEEK_END);
disksize = ftell(disk) / 1048576; // Disk size in MiB
fseek(disk, 1024, SEEK_SET); // Seek 1KiB in for disk information
fread(DiskInfo, 512, 1, disk); // Read 512 bytes to the DiskInfo buffer
fseek(disk, 4096, SEEK_SET); // Seek 4KiB in for directory
fread(Directory, 4096, 1, disk); // Read 4096 bytes to the Directory buffer
rewind(disk);
if (strcasecmp(DiskInfo, fs_tag) != 0) // Is it a BMFS formatted disk?
{
if (strcasecmp(s_format, command) == 0)
{
format();
}
else
{
printf("Error: Not a valid BMFS drive (Disk is not BMFS formatted).\n");
}
fclose(disk);
return 0;
}
}
if (strcasecmp(s_list, command) == 0)
{
list();
}
else if (strcasecmp(s_format, command) == 0)
{
if (argc > 3)
{
if (strcasecmp(argv[3], "/FORCE") == 0)
{
format();
}
else
{
printf("Format aborted!\n");
}
}
else
{
printf("Format aborted!\n");
}
}
else if (strcasecmp(s_create, command) == 0)
{
if (filename == NULL)
{
printf("Error: File name not specified.\n");
}
else
{
if (argc > 4)
{
int filesize = atoi(argv[4]);
if (filesize >= 1)
{
create(filename, filesize);
}
else
{
printf("Error: Invalid file size.\n");
}
}
else
{
printf("Maximum file size in MiB: ");
fgets(tempstring, 32, stdin); // Get up to 32 chars from the keyboard
filesize = atoi(tempstring);
if (filesize >= 1)
create(filename, filesize);
else
printf("Error: Invalid file size.\n");
}
}
}
else if (strcasecmp(s_read, command) == 0)
{
read(filename);
}
else if (strcasecmp(s_write, command) == 0)
{
write(filename);
}
else if (strcasecmp(s_delete, command) == 0)
{
delete(filename);
}
else
{
printf("Unknown command\n");
}
if (disk != NULL)
{
fclose( disk );
disk = NULL;
}
return 0;
}
int findfile(char *filename, struct BMFSEntry *fileentry, int *entrynumber)
{
int tint;
for (tint = 0; tint < 64; tint++)
{
memcpy(pentry, Directory+(tint*64), 64);
if (entry.FileName[0] == 0x00) // End of directory
{
tint = 64;
}
else if (entry.FileName[0] == 0x01) // Emtpy entry
{
// Ignore
}
else // Valid entry
{
if (strcmp(filename, entry.FileName) == 0)
{
memcpy(fileentry, pentry, 64);
*entrynumber = tint;
return 1;
}
}
}
return 0;
}
void list()
{
int tint;
printf("%s\nDisk Size: %d MiB\n", diskname, disksize);
printf("Name | Size (B)| Reserved (MiB)\n");
printf("==========================================================================\n");
for (tint = 0; tint < 64; tint++) // Max 64 entries
{
memcpy(pentry, Directory+(tint*64), 64);
if (entry.FileName[0] == 0x00) // End of directory, bail out
{
tint = 64;
}
else if (entry.FileName[0] == 0x01) // Emtpy entry
{
// Ignore
}
else // Valid entry
{
printf("%-32s %20lld %20lld\n", entry.FileName, entry.FileSize, (entry.ReservedBlocks*2));
}
}
}
void format()
{
memset(DiskInfo, 0, 512);
memset(Directory, 0, 4096);
memcpy(DiskInfo, fs_tag, 4); // Add the 'BMFS' tag
fseek(disk, 1024, SEEK_SET); // Seek 1KiB in for disk information
fwrite(DiskInfo, 512, 1, disk); // Write 512 bytes for the DiskInfo
fseek(disk, 4096, SEEK_SET); // Seek 4KiB in for directory
fwrite(Directory, 4096, 1, disk); // Write 4096 bytes for the Directory
printf("Format complete.\n");
}
int initialize(char *diskname, char *size, char *mbr, char *boot, char *kernel)
{
unsigned long long diskSize = 0;
unsigned long long writeSize = 0;
const char *bootFileType = NULL;
size_t bufferSize = 50 * 1024;
char * buffer = NULL;
FILE *mbrFile = NULL;
FILE *bootFile = NULL;
FILE *kernelFile = NULL;
int diskSizeFactor = 0;
size_t chunkSize = 0;
int ret = 0;
size_t i;
// Determine how the second file will be described in output messages.
// If a kernel file is specified too, then assume the second file is the
// boot loader. If no kernel file is specified, assume the boot loader
// and kernel are combined into one system file.
if (boot != NULL)
{
bootFileType = "boot loader";
if (kernel == NULL)
{
bootFileType = "system";
}
}
// Validate the disk size string and convert it to an integer value.
for (i = 0; size[i] != '\0' && ret == 0; ++i)
{
char ch = size[i];
if (isdigit(ch))
{
unsigned int n = ch - '0';
if (diskSize * 10 > diskSize ) // Make sure we don't overflow
{
diskSize *= 10;
diskSize += n;
}
else if (diskSize == 0) // First loop iteration
{
diskSize += n;
}
else
{
printf("Error: Disk size is too large\n");
ret = 1;
}
}
else if (i == 0) // No digits specified
{
printf("Error: A numeric disk size must be specified\n");
ret = 1;
}
else
{
switch (toupper(ch))
{
case 'K':
diskSizeFactor = 1;
break;
case 'M':
diskSizeFactor = 2;
break;
case 'G':
diskSizeFactor = 3;
break;
case 'T':
diskSizeFactor = 4;
break;
case 'P':
diskSizeFactor = 5;
break;
default:
printf("Error: Invalid disk size string: '%s'\n", size);
ret = 1;
break;
}
// If this character is a valid unit indicator, but is not at the
// end of the string, then the string is invalid.
if (ret == 0 && size[i+1] != '\0')
{
printf("Error: Invalid disk size string: '%s'\n", size);
ret = 1;
}
}
}
// Adjust the disk size if a unit indicator was given. Note that an
// input of something like "0" or "0K" will get past the checks above.
if (ret == 0 && diskSize > 0 && diskSizeFactor > 0)
{
while (diskSizeFactor--)
{
if (diskSize * 1024 > diskSize ) // Make sure we don't overflow
{
diskSize *= 1024;
}
else
{
printf("Error: Disk size is too large\n");
ret = 1;
}
}
}
// Make sure the disk size is large enough.
if (ret == 0)
{
if (diskSize < minimumDiskSize)
{
printf( "Error: Disk size must be at least %llu bytes (%lluMiB)\n", minimumDiskSize, minimumDiskSize / (1024*1024));
ret = 1;
}
}
// Open the Master boot Record file for reading.
if (ret == 0 && mbr != NULL)
{
mbrFile = fopen(mbr, "rb");
if (mbrFile == NULL )
{
printf("Error: Unable to open MBR file '%s'\n", mbr);
ret = 1;
}
}
// Open the boot loader file for reading.
if (ret == 0 && boot != NULL)
{
bootFile = fopen(boot, "rb");
if (bootFile == NULL )
{
printf("Error: Unable to open %s file '%s'\n", bootFileType, boot);
ret = 1;
}
}
// Open the kernel file for reading.
if (ret == 0 && kernel != NULL)
{
kernelFile = fopen(kernel, "rb");
if (kernelFile == NULL )
{
printf("Error: Unable to open kernel file '%s'\n", kernel);
ret = 1;
}
}
// Allocate buffer to use for filling the disk image with zeros.
if (ret == 0)
{
buffer = (char *) malloc(bufferSize);
if (buffer == NULL)
{
printf("Error: Failed to allocate buffer\n");
ret = 1;
}
}
// Open the disk image file for writing. This will truncate the disk file
// if it already exists, so we should do this only after we're ready to
// actually write to the file.
if (ret == 0)
{
disk = fopen(diskname, "wb");
if (disk == NULL)
{
printf("Error: Unable to open disk '%s'\n", diskname);
ret = 1;
}
}
// Fill the disk image with zeros.
if (ret == 0)
{
double percent;
memset(buffer, 0, bufferSize);
writeSize = 0;
while (writeSize < diskSize)
{
percent = writeSize;
percent /= diskSize;
percent *= 100;
printf("Formatting disk: %llu of %llu bytes (%.0f%%)...\r", writeSize, diskSize, percent);
chunkSize = bufferSize;
if (chunkSize > diskSize - writeSize)
{
chunkSize = diskSize - writeSize;
}
if (fwrite(buffer, chunkSize, 1, disk) != 1)
{
printf("Error: Failed to write disk '%s'\n", diskname);
ret = 1;
break;
}
writeSize += chunkSize;
}
if (ret == 0)
{
printf("Formatting disk: %llu of %llu bytes (100%%)%9s\n", writeSize, diskSize, "");
}
}
// Format the disk.
if (ret == 0)
{
rewind(disk);
format();
}
// Write the master boot record if it was specified by the caller.
if (ret == 0 && mbrFile !=NULL)
{
printf("Writing master boot record.\n");
fseek(disk, 0, SEEK_SET);
if (fread(buffer, 512, 1, mbrFile) == 1)
{
if (fwrite(buffer, 512, 1, disk) != 1)
{
printf("Error: Failed to write disk '%s'\n", diskname);
ret = 1;
}
}
else
{
printf("Error: Failed to read file '%s'\n", mbr);
ret = 1;
}
}
// Write the boot loader if it was specified by the caller.
if (ret == 0 && bootFile !=NULL)
{
printf("Writing %s file.\n", bootFileType);
fseek(disk, 8192, SEEK_SET);
for (;;)
{
chunkSize = fread( buffer, 1, bufferSize, bootFile);
if (chunkSize > 0)
{
if (fwrite(buffer, chunkSize, 1, disk) != 1)
{
printf("Error: Failed to write disk '%s'\n", diskname);
ret = 1;
}
}
else
{
if (ferror(disk))
{
printf("Error: Failed to read file '%s'\n", boot);
ret = 1;
}
break;
}
}
}
// Write the kernel if it was specified by the caller. The kernel must
// immediately follow the boot loader on disk (i.e. no seek needed.)
if (ret == 0 && kernelFile !=NULL)
{
printf("Writing kernel.\n");
for (;;)
{
chunkSize = fread( buffer, 1, bufferSize, kernelFile);
if (chunkSize > 0)
{
if (fwrite(buffer, chunkSize, 1, disk) != 1)
{
printf("Error: Failed to write disk '%s'\n", diskname);
ret = 1;
}
}
else
{
if (ferror(disk))
{
printf("Error: Failed to read file '%s'\n", kernel);
ret = 1;
}
break;
}
}
}
// Close any files that were opened.
if (mbrFile != NULL)
{
fclose(mbrFile);
}
if (bootFile != NULL)
{
fclose(bootFile);
}
if (kernelFile != NULL)
{
fclose(kernelFile);
}
if (disk != NULL)
{
fclose(disk);
disk = NULL;
}
// Free the buffer if it was allocated.
if (buffer != NULL)
{
free(buffer);
}
if (ret == 0)
{
printf("Disk initialization complete.\n");
}
return ret;
}
// helper function for qsort, sorts by StartingBlock field
static int StartingBlockCmp(const void *pa, const void *pb)
{
struct BMFSEntry *ea = (struct BMFSEntry *)pa;
struct BMFSEntry *eb = (struct BMFSEntry *)pb;
// empty records go to the end
if (ea->FileName[0] == 0x01)
return 1;
if (eb->FileName[0] == 0x01)
return -1;
// compare non-empty records by their starting blocks number
return (ea->StartingBlock - eb->StartingBlock);
}
void create(char *filename, unsigned long long maxsize)
{
struct BMFSEntry tempentry;
int slot;
if (maxsize % 2 != 0)
maxsize++;
if (findfile(filename, &tempentry, &slot) == 0)
{
unsigned long long blocks_requested = maxsize / 2; // how many blocks to allocate
unsigned long long num_blocks = disksize / 2; // number of blocks in the disk
char dir_copy[4096]; // copy of directory
int num_used_entries = 0; // how many entries of Directory are either used or deleted
int first_free_entry = -1; // where to put new entry
int tint;
struct BMFSEntry *pEntry;
unsigned long long new_file_start = 0;
unsigned long long prev_file_end = 1;
printf("Creating new file...\n");
// Make a copy of Directory to play with
memcpy(dir_copy, Directory, 4096);
// Calculate number of files
for (tint = 0; tint < 64; tint++)
{
pEntry = (struct BMFSEntry *)(dir_copy + tint * 64); // points to the current directory entry
if (pEntry->FileName[0] == 0x00) // end of directory
{
num_used_entries = tint;
if (first_free_entry == -1)
first_free_entry = tint; // there were no unused entires before, will use this one
break;
}
else if (pEntry->FileName[0] == 0x01) // unused entry
{
if (first_free_entry == -1)
first_free_entry = tint; // will use it for our new file
}
}
if (first_free_entry == -1)
{
printf("Cannot create file: no free directory entries.\n");
return;
}
// Find an area with enough free blocks
// Sort our copy of the directory by starting block number
qsort(dir_copy, num_used_entries, 64, StartingBlockCmp);
for (tint = 0; tint < num_used_entries + 1; tint++)
{
// on each iteration of this loop we'll see if a new file can fit
// between the end of the previous file (initially == 1)
// and the beginning of the current file (or the last data block if there are no more files).
unsigned long long this_file_start;
pEntry = (struct BMFSEntry *)(dir_copy + tint * 64); // points to the current directory entry
if (tint == num_used_entries || pEntry->FileName[0] == 0x01)
this_file_start = num_blocks - 1; // index of the last block
else
this_file_start = pEntry->StartingBlock;
if (this_file_start - prev_file_end >= blocks_requested)
{ // fits here
new_file_start = prev_file_end;
break;
}
if (tint < num_used_entries)
prev_file_end = pEntry->StartingBlock + pEntry->ReservedBlocks;
}
if (new_file_start == 0)
{
printf("Cannot create file of size %lld MiB.\n", maxsize);
return;
}
// Add file record to Directory
pEntry = (struct BMFSEntry *)(Directory + first_free_entry * 64);
pEntry->StartingBlock = new_file_start;
pEntry->ReservedBlocks = blocks_requested;
pEntry->FileSize = 0;
strcpy(pEntry->FileName, filename);
if (first_free_entry == num_used_entries && num_used_entries + 1 < 64)
{
// here we used the record that was marked with 0x00,
// so make sure to mark the next record with 0x00 if it exists
pEntry = (struct BMFSEntry *)(Directory + (num_used_entries + 1) * 64);
pEntry->FileName[0] = 0x00;
}
// Flush Directory to disk
fseek(disk, 4096, SEEK_SET); // Seek 4KiB in for directory
fwrite(Directory, 4096, 1, disk); // Write 4096 bytes for the Directory
// printf("Complete: file %s starts at block %lld, directory entry #%d.\n", filename, new_file_start, first_free_entry);
printf("Complete\n");
}
else
{
printf("Error: File already exists.\n");
}
}
void read(char *filename)
{
struct BMFSEntry tempentry;
FILE *tfile;
int tint, slot;
if (0 == findfile(filename, &tempentry, &slot))
{
printf("Error: File not found in BMFS.\n");
}
else
{
printf("Reading '%s' from BMFS to local file... ", filename);
if ((tfile = fopen(tempentry.FileName, "wb")) == NULL)
{
printf("Error: Could not open local file '%s'\n", tempentry.FileName);
}
else
{
fseek(disk, tempentry.StartingBlock*2097152, SEEK_SET); // Skip to the starting block in the disk
for (tint=0; tint<tempentry.FileSize; tint++)
{
putc(getc(disk), tfile); // This is really terrible.
// TODO: Rework with fread and fwrite (ideally with a 2MiB buffer)
}
fclose(tfile);
printf("Complete\n");
}
}
}
void write(char *filename)
{
struct BMFSEntry tempentry;
FILE *tfile;
int tint, slot;
unsigned long long tempfilesize;
if (0 == findfile(filename, &tempentry, &slot))
{
printf("Error: File not found in BMFS. A file entry must first be created.\n");
}
else
{
printf("Writing local file '%s' to BMFS... ", filename);
if ((tfile = fopen(filename, "rb")) == NULL)
{
printf("Error: Could not open local file '%s'\n", tempentry.FileName);
}
else
{
// Is there enough room in BMFS?
fseek(tfile, 0, SEEK_END);
tempfilesize = ftell(tfile);
rewind(tfile);
if ((tempentry.ReservedBlocks*2097152) < tempfilesize)
{
printf("Not enough reserved space in BMFS.\n");
}
else
{
fseek(disk, tempentry.StartingBlock*2097152, SEEK_SET); // Skip to the starting block in the disk
for (tint=0; tint<tempfilesize; tint++)
{
putc(getc(tfile), disk); // This is really terrible.
// TODO: Rework with fread and fwrite (ideally with a 2MiB buffer)
}
// Update directory
memcpy(Directory+(slot*64)+48, &tempfilesize, 8);
fseek(disk, 4096, SEEK_SET); // Seek 4KiB in for directory
fwrite(Directory, 4096, 1, disk); // Write new directory to disk
printf("Complete\n");
}
fclose(tfile);
}
}
}
void delete(char *filename)
{
struct BMFSEntry tempentry;
char delmarker = 0x01;
int slot;
if (0 == findfile(filename, &tempentry, &slot))
{
printf("Error: File not found in BMFS.\n");
}
else
{
printf("Deleting file '%s' from BMFS... ", filename);
// Update directory
memcpy(Directory+(slot*64), &delmarker, 1);
fseek(disk, 4096, SEEK_SET); // Seek 4KiB in for directory
fwrite(Directory, 4096, 1, disk); // Write new directory to disk
printf("Complete\n");
}
}
/* EOF */

11
Bootloader/Makefile Normal file
View File

@ -0,0 +1,11 @@
all: bmfs pure64
bmfs:
cd BMFS; $(MAKE) all
pure64:
cd Pure64; $(MAKE) all
clean:
cd BMFS; $(MAKE) clean
cd Pure64; $(MAKE) clean
.PHONY: all bmfs pure64 clean

15
Bootloader/Pure64/Makefile Normal file
View File

@ -0,0 +1,15 @@
ASM=nasm
BMFS_MBR=bmfs_mbr.sys
PXESTART=pxestart.sys
PURE64=pure64.sys
all: bmfs_mbr.sys pxestart.sys pure64.sys
$(BMFS_MBR):
$(ASM) src/bootsectors/bmfs_mbr.asm -o $(BMFS_MBR)
$(PXESTART):
$(ASM) src/bootsectors/pxestart.asm -o $(PXESTART)
$(PURE64):
cd src; $(ASM) pure64.asm -o ../$(PURE64)
clean:
rm -rf *.sys
.PHONY: all clean

91
Bootloader/Pure64/Pure64 Manual.md Normal file
View File

@ -0,0 +1,91 @@
# Pure64 - v0.6.1 Manual
Pure64 must be loaded to the 16-bit memory address `0x0000:0x8000`
Pure64 expects that the up to 26KiB of data after it is the software that will be loaded to address `0x0000000000100000`.
## System Requirements
A computer with at least one 64-bit Intel or AMD CPU (or anything else that uses the x86-64 architecture)
At least 2 MiB of RAM
The ability to boot via a hard drive, USB stick, or the network
## Hard disk / USB boot
`bmfs_mbr.asm` in the bootsectors folder shows how to boot via a BMFS formatted drive.
*Note*: Once Pure64 has executed you will lose access the the USB drive unless you have written a driver for it. The BIOS was used to load from it and you can't use the BIOS in 64-bit mode.
## Network boot
`pxestart.asm` in the bootsectors folder shows how to build a PXE image.
## Memory Map
This memory map shows how physical memory looks after Pure64 is finished.
| Start Address | End Address | Size | Description |
|--------------------| -------------------|------------|-------------|
| 0x0000000000000000 | 0x0000000000000FFF | 4 KiB | IDT - 256 descriptors (each descriptor is 16 bytes)|
| 0x0000000000001000 | 0x0000000000001FFF| 4 KiB | GDT - 256 descriptors (each descriptor is 16 bytes)|
| 0x0000000000002000 | 0x0000000000002FFF | 4 KiB | PML4 - 512 entries, first entry points to PDP at 0x3000|
| 0x0000000000003000 | 0x0000000000003FFF | 4 KiB |PDP - 512 enties|
| 0x0000000000004000 | 0x0000000000007FFF | 16 KiB | Pure64 Data |
| 0x0000000000008000 | 0x000000000000FFFF |32 KiB | Pure64 - After the OS is loaded and running this memory is free again|
| 0x0000000000010000 |0x000000000004FFFF| 256 KiB | PD - Room to map 64 GiB|
| 0x0000000000050000 |0x000000000009FFFF|320 KiB| Free |
| 0x00000000000A0000|0x00000000000FFFFF|384 KiB| ROM Area|
| | | | VGA mem at 0xA0000 (128 KiB) Color text starts at 0xB8000|
| | | | Video BIOS at 0xC0000 (64 KiB)|
| | | | Motherboard BIOS at F0000 (64 KiB)|
|0x0000000000100000|0xFFFFFFFFFFFFFFFF| 1+ MiB | Your software is loaded here|
When creating your Operating System or Demo you can use the sections marked free, however it is the safest to use memory above 1 MiB.
## Information Table
Pure64 stores an information table in memory that contains various pieces of data about the computer before it passes control over to the software you want it to load.
The Pure64 information table is located at `0x0000000000005000` and ends at `0x00000000000057FF` (2048 bytes).
|Memory Address|Variable Size | Name | Description |
|--------------|--------------|-------|-------------|
|0x5000 | 64-bits | ACPI | Address of the ACPI tables |
|0x5008 |32-bit |BSP_ID | APIC ID of the BSP|
|0x5010 |16-bit |CPUSPEED| Speed of the CPUs in MegaHertz [MHz](http://en.wikipedia.org/wiki/Mhz#Computing) |
|0x5012 |16-bits |CORES_ACTIVE |The number of CPU cores that were activated in the system|
|0x5014|16-bit|CORES_DETECT|The number of CPU cores that were detected in the system|
|0x5016 - 0x501F| | | For future use|
|0x5020|32-bit|RAMAMOUNT|Amount of system RAM in Mebibytes [MiB](http://en.wikipedia.org/wiki/Mebibyte)|
|0x5022 - 0x502F| | | For future use |
|0x5030|8-bit|IOAPIC_COUNT|Number of IO-APICs in the system|
|0x5031 - 0x503F| | |For future use |
|0x5040|64-bit|HPET|Base memory address for the High Precision Event Timer|
|0x5048 - 0x505F| || For future use|
|0x5060|64-bit|LAPIC|Local APIC address|
|0x5068 - 0x507F|64-bit|IOAPIC|IO-APIC addresses (based on IOAPIC_COUNT)|
|0x5080|32-bit|VIDEO_BASE|Base memory for video (if graphics mode set)|
|0x5084|16-bit|VIDEO_X|X resolution|
|0x5086|16-bit|VIDEO_Y|Y resolution|
|0x5088|8-bit|VIDEO_DEPTH|Color depth|
|0x5100-|8-bit|APIC_ID |APIC ID's for valid CPU cores (based on CORES_ACTIVE)|
A copy of the E820 System Memory Map is stored at memory address `0x0000000000004000`. Each E820 record is 24 bytes in length and the memory map is terminated by a blank record.
|Variable|Variable Size|Description|
|----|----|----|
|Starting Address|64-bit|The starting address for this record|
|Length|64-bit|The length of memory for this record|
|Memory Type|32-bit|Type 1 is usable memory, Type 2 is not usable|
For more information on the E820 Memory Map: [OSDev wiki on E820](http://wiki.osdev.org/Detecting_Memory_%28x86%29#BIOS_Function:_INT_0x15.2C_EAX_.3D_0xE820)

15
Bootloader/Pure64/build.bat Normal file
View File

@ -0,0 +1,15 @@
@echo off
REM This script assumes that 'nasm' is in your path
echo | set /p x=Building bmfs_mbr...
call nasm src\bootsectors\bmfs_mbr.asm -o bmfs_mbr.sys && (echo Success) || (echo Error!)
echo | set /p x=Building pxestart...
call nasm src\bootsectors\pxestart.asm -o pxestart.sys && (echo Success) || (echo Error!)
cd src
echo | set /p x=Building Pure64...
call nasm pure64.asm -o ..\pure64.sys && (echo Success) || (echo Error!)
cd ..
pause

17
Bootloader/Pure64/docs/CREDITS.TXT Normal file
View File

@ -0,0 +1,17 @@
===============================================================================
Pure64 -- a 64-bit loader written in Assembly for x86-64 systems
Copyright (C) 2007-2014 Return Infinity -- see LICENSE.TXT
===============================================================================
PROJECT ADMIN (MAIN CODE AND DOCUMENTATION)
* Ian Seyler -- ian.seyler@returninfinity.com
DEVELOPMENT AND TESTING
* Members of OSDev.org
===============================================================================

35
Bootloader/Pure64/docs/LICENSE.TXT Normal file
View File

@ -0,0 +1,35 @@
===============================================================================
Pure64 -- License
===============================================================================
Copyright (C) 2007-2014 Return Infinity -- http://www.returninfinity.com
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name Pure64 nor the names of any Pure64 contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY RETURN INFINITY AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL RETURN INFINITY BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
===============================================================================

25
Bootloader/Pure64/readme.md Normal file
View File

@ -0,0 +1,25 @@
# Pure64 -- The BareMetal OS kernel loader
Copyright (C) 2007-2014 Return Infinity -- see LICENSE.TXT
Pure64 is a 64-bit software loader for BareMetal OS. The loader gets the computer into a full 64-bit state with no legacy compatibility layers and also enables all available CPU Cores in the computer. Pure64 keeps an information table in memory that stores important details about the computer (Amount of RAM and memory layout, number of CPU cores and their APIC IDs, etc).
See LICENSE.TXT for redistribution/modification rights, and CREDITS.TXT for a list of people involved.
Ian Seyler (ian.seyler@returninfinity.com)
## Building
The only requirement for building Pure64 is [NASM](http://www.nasm.us/) (The Netwide Assembler). In Linux you can probably download it from the distro's repository. If you are using Windows or Mac OS X you can grab pre-compiled binaries [here](http://www.nasm.us/pub/nasm/releasebuilds/2.10.07/) in the `macosx` and `win32` directories, respectively.
Build scripts are included for Unix/Linux and Windows systems.
Mac OS X/Linux: `./build.sh`
Windows: `build.bat`
## Notes
Building Pure64 from source requires NASM v2.10 or higher; the version included in the OS X 10.9 Developer Tools is not recent enough. - *Seriously Apple? NASM v0.98 is from 2007!!*
If you use [MacPorts](http://www.macports.org), you can install NASM v2.10+ by executing: `sudo port install nasm`

178
Bootloader/Pure64/src/bootsectors/bmfs_mbr.asm Normal file
View File

@ -0,0 +1,178 @@
; =============================================================================
; Pure64 MBR -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; This Master Boot Record will load Pure64 from a pre-defined location on the
; hard drive without making use of the file system.
;
; In this code we are expecting a BMFS-formatted drive. With BMFS the Pure64
; binary is required to start at sector 16 (8192 bytes from the start). A small
; ckeck is made to make sure Pure64 was loaded by comparing a signiture.
; =============================================================================
USE16
org 0x7C00
entry:
cli ; Disable interrupts
; xchg bx, bx ; Bochs magic debug
xor ax, ax
mov ss, ax
mov es, ax
mov ds, ax
mov sp, 0x7C00
sti ; Enable interrupts
mov [DriveNumber], dl ; BIOS passes drive number in DL
mov si, msg_Load
call print_string_16
mov eax, 512 ; Number of sectors to load. 512 sectors = 262144 bytes = 256 KiB
mov ebx, 16 ; Start immediately after directory (offset 8192)
mov cx, 0x8000 ; Pure64 expects to be loaded at 0x8000
load_nextsector:
call readsector ; Load 512 bytes
dec eax
cmp eax, 0
jnz load_nextsector
mov eax, [0x8000]
cmp eax, 0xC03166FA ; Match against the Pure64 binary
jne magic_fail
mov ax, 0x0800 ; Segment where the bootloader and payload are loaded
mov cx, 0x6000 ; Segment where the bootloader and payload will be copied
copy_payload_to_free_mem: ; Move bootloader and payload to 0x60000
mov fs, ax ; From segment
mov es, cx ; To segment
mov bx, 0x0 ; Offset
copy_single_segment:
mov dl, [fs:bx]
mov [es:bx], dl
inc bx
jnz copy_single_segment
add ax, 0x1000
add cx, 0x1000
cmp cx, 0xA000 ; Last address (bootloader + payload = 256KiB total)
jnz copy_payload_to_free_mem
mov eax, 0x0 ; Reset
mov ebx, 0x0
mov ecx, 0x0
mov edx, 0x0
mov fs, ax
mov es, ax
mov si, msg_LoadDone
call print_string_16
jmp 0x0000:0x8000
magic_fail:
mov si, msg_MagicFail
call print_string_16
halt:
hlt
jmp halt
;------------------------------------------------------------------------------
; Read a sector from a disk, using LBA
; IN: EAX - High word of 64-bit DOS sector number
; EBX - Low word of 64-bit DOS sector number
; ES:CX - destination buffer
; OUT: ES:CX points one byte after the last byte read
; EAX - High word of next sector
; EBX - Low word of sector
readsector:
push eax
xor eax, eax ; We don't need to load from sectors > 32-bit
push dx
push si
push di
read_it:
push eax ; Save the sector number
push ebx
mov di, sp ; remember parameter block end
push eax ; [C] sector number high 32bit
push ebx ; [8] sector number low 32bit
push es ; [6] buffer segment
push cx ; [4] buffer offset
push byte 1 ; [2] 1 sector (word)
push byte 16 ; [0] size of parameter block (word)
mov si, sp
mov dl, [DriveNumber]
mov ah, 42h ; EXTENDED READ
int 0x13 ; http://hdebruijn.soo.dto.tudelft.nl/newpage/interupt/out-0700.htm#0651
mov sp, di ; remove parameter block from stack
pop ebx
pop eax ; Restore the sector number
jnc read_ok ; jump if no error
push ax
xor ah, ah ; else, reset and retry
int 0x13
pop ax
jmp read_it
read_ok:
add ebx, 1 ; increment next sector with carry
adc eax, 0
add cx, 512 ; Add bytes per sector
jnc no_incr_es ; if overflow...
incr_es:
mov dx, es
add dh, 0x10 ; ...add 1000h to ES
mov es, dx
no_incr_es:
pop di
pop si
pop dx
pop eax
ret
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; 16-bit function to print a string to the screen
; IN: SI - Address of start of string
print_string_16: ; Output string in SI to screen
pusha
mov ah, 0x0E ; int 0x10 teletype function
.repeat:
lodsb ; Get char from string
cmp al, 0
je .done ; If char is zero, end of string
int 0x10 ; Otherwise, print it
jmp short .repeat
.done:
popa
ret
;------------------------------------------------------------------------------
msg_Load db "BMFS MBR v1.0 - Loading Pure64", 0
msg_LoadDone db " - done.", 13, 10, "Executing...", 0
msg_MagicFail db " - Not found!", 0
DriveNumber db 0x00
times 446-$+$$ db 0
; False partition table entry required by some BIOS vendors.
db 0x80, 0x00, 0x01, 0x00, 0xEB, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF
times 510-$+$$ db 0
sign dw 0xAA55

66
Bootloader/Pure64/src/bootsectors/pxestart.asm Normal file
View File

@ -0,0 +1,66 @@
; =============================================================================
; Pure64 PXE Start -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; This is a stub file for loading Pure64 and a kernel via PXE.
;
; Windows - copy /b pxestart.bin + pure64.sys + kernel64.sys pxeboot.bin
; Unix - cat pxestart.bin pure64.sys kernel64.sys > pxeboot.bin
;
; Max size of the resulting pxeboot.bin is 33792 bytes. 1K for the PXE loader
; stub and up to 32KiB for the code/data. PXE loads the file to address
; 0x00007C00 (Just like a boot sector).
;
; File Sizes
; pxestart.bin 1024 bytes
; pure64.sys 6144 bytes
; kernel64.sys 16384 bytes (or so)
; =============================================================================
USE16
org 0x7C00
start:
xor eax, eax
xor esi, esi
xor edi, edi
mov ds, ax
mov es, ax
mov bp, 0x7c00
; Make sure the screen is set to 80x25 color text mode
mov ax, 0x0003 ; Set to normal (80x25 text) video mode
int 0x10
; Print message
mov si, msg_Load
call print_string_16
jmp 0x0000:0x8000
;------------------------------------------------------------------------------
; 16-bit Function to print a string to the screen
; input: SI - Address of start of string
print_string_16: ; Output string in SI to screen
pusha
mov ah, 0x0E ; int 0x10 teletype function
.repeat:
lodsb ; Get char from string
test al, al
jz .done ; If char is zero, end of string
int 0x10 ; Otherwise, print it
jmp short .repeat
.done:
popa
ret
;------------------------------------------------------------------------------
msg_Load db "Loading via PXE... ", 0
times 510-$+$$ db 0 ; Pad out for a normal boot sector
sign dw 0xAA55
times 1024-$+$$ db 0 ; Padding so that Pure64 will be aligned at 0x8000

297
Bootloader/Pure64/src/init/acpi.asm Normal file
View File

@ -0,0 +1,297 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; INIT ACPI
; =============================================================================
init_acpi:
mov rsi, 0x00000000000E0000 ; Start looking for the Root System Description Pointer Structure
mov rbx, 'RSD PTR ' ; This in the Signature for the ACPI Structure Table (0x2052545020445352)
searchingforACPI:
lodsq ; Load a quad word from RSI and store in RAX, then increment RSI by 8
cmp rax, rbx
je foundACPI
cmp rsi, 0x00000000000FFFFF ; Keep looking until we get here
jge noACPI ; ACPI tables couldn't be found, Fail.
jmp searchingforACPI
foundACPI: ; Found a Pointer Structure, verify the checksum
push rsi
xor ebx, ebx
mov ecx, 20 ; As per the spec only the first 20 bytes matter
sub rsi, 8 ; Bytes 0 thru 19 must sum to zero
nextchecksum:
lodsb ; Get a byte
add bl, al ; Add it to the running total
sub cl, 1
cmp cl, 0
jne nextchecksum
pop rsi
cmp bl, 0
jne searchingforACPI ; Checksum didn't check out? Then keep looking.
lodsb ; Checksum
lodsd ; OEMID (First 4 bytes)
lodsw ; OEMID (Last 2 bytes)
lodsb ; Grab the Revision value (0 is v1.0, 1 is v2.0, 2 is v3.0, etc)
add al, 49
mov [0x000B8098], al ; Print the ACPI version number
sub al, 49
cmp al, 0
je foundACPIv1 ; If AL is 0 then the system is using ACPI v1.0
jmp foundACPIv2 ; Otherwise it is v2.0 or higher
foundACPIv1:
xor eax, eax
lodsd ; Grab the 32 bit physical address of the RSDT (Offset 16).
mov rsi, rax ; RSI now points to the RSDT
lodsd ; Grab the Signiture
cmp eax, 'RSDT' ; Make sure the signiture is valid
jne novalidacpi ; Not the same? Bail out
sub rsi, 4
mov [os_ACPITableAddress], rsi ; Save the RSDT Table Address
add rsi, 4
xor eax, eax
lodsd ; Length
add rsi, 28 ; Skip to the Entry offset
sub eax, 36 ; EAX holds the table size. Subtract the preamble
shr eax, 2 ; Divide by 4
mov rdx, rax ; RDX is the entry count
xor ecx, ecx
foundACPIv1_nextentry:
lodsd
push rax
add ecx, 1
cmp ecx, edx
je findACPITables
jmp foundACPIv1_nextentry
foundACPIv2:
lodsd ; RSDT Address
lodsd ; Length
lodsq ; Grab the 64 bit physical address of the XSDT (Offset 24).
mov rsi, rax ; RSI now points to the XSDT
lodsd ; Grab the Signiture
cmp eax, 'XSDT' ; Make sure the signiture is valid
jne novalidacpi ; Not the same? Bail out
sub rsi, 4
mov [os_ACPITableAddress], rsi ; Save the XSDT Table Address
add rsi, 4
xor eax, eax
lodsd ; Length
add rsi, 28 ; Skip to the start of the Entries (offset 36)
sub eax, 36 ; EAX holds the table size. Subtract the preamble
shr eax, 3 ; Divide by 8
mov rdx, rax ; RDX is the entry count
xor ecx, ecx
foundACPIv2_nextentry:
lodsq
push rax
add ecx, 1
cmp ecx, edx
jne foundACPIv2_nextentry
findACPITables:
mov al, '3' ; Search through the ACPI tables
mov [0x000B809C], al
mov al, '4'
mov [0x000B809E], al
xor ecx, ecx
nextACPITable:
pop rsi
lodsd
add ecx, 1
mov ebx, 'APIC' ; Signature for the Multiple APIC Description Table
cmp eax, ebx
je foundAPICTable
mov ebx, 'HPET' ; Signiture for the HPET Description Table
cmp eax, ebx
je foundHPETTable
cmp ecx, edx
jne nextACPITable
jmp init_smp_acpi_done ;noACPIAPIC
foundAPICTable:
call parseAPICTable
jmp nextACPITable
foundHPETTable:
call parseHPETTable
jmp nextACPITable
init_smp_acpi_done:
ret
noACPI:
novalidacpi:
mov al, 'X'
mov [0x000B809A], al
jmp $
; -----------------------------------------------------------------------------
parseAPICTable:
push rcx
push rdx
lodsd ; Length of MADT in bytes
mov ecx, eax ; Store the length in ECX
xor ebx, ebx ; EBX is the counter
lodsb ; Revision
lodsb ; Checksum
lodsd ; OEMID (First 4 bytes)
lodsw ; OEMID (Last 2 bytes)
lodsq ; OEM Table ID
lodsd ; OEM Revision
lodsd ; Creator ID
lodsd ; Creator Revision
xor eax, eax
lodsd ; Local APIC Address
mov [os_LocalAPICAddress], rax ; Save the Address of the Local APIC
lodsd ; Flags
add ebx, 44
mov rdi, 0x0000000000005100 ; Valid CPU IDs
readAPICstructures:
cmp ebx, ecx
jge parseAPICTable_done
; call os_print_newline
lodsb ; APIC Structure Type
; call os_debug_dump_al
; push rax
; mov al, ' '
; call os_print_char
; pop rax
cmp al, 0x00 ; Processor Local APIC
je APICapic
cmp al, 0x01 ; I/O APIC
je APICioapic
cmp al, 0x02 ; Interrupt Source Override
je APICinterruptsourceoverride
; cmp al, 0x03 ; Non-maskable Interrupt Source (NMI)
; je APICnmi
; cmp al, 0x04 ; Local APIC NMI
; je APIClocalapicnmi
; cmp al, 0x05 ; Local APIC Address Override
; je APICaddressoverride
cmp al, 0x09 ; Processor Local x2APIC
je APICx2apic
; cmp al, 0x0A ; Local x2APIC NMI
; je APICx2nmi
jmp APICignore
APICapic:
xor eax, eax
xor edx, edx
lodsb ; Length (will be set to 8)
add ebx, eax
lodsb ; ACPI Processor ID
lodsb ; APIC ID
xchg eax, edx ; Save the APIC ID to EDX
lodsd ; Flags (Bit 0 set if enabled/usable)
bt eax, 0 ; Test to see if usable
jnc readAPICstructures ; Read the next structure if CPU not usable
inc word [cpu_detected]
xchg eax, edx ; Restore the APIC ID back to EAX
stosb
jmp readAPICstructures ; Read the next structure
APICioapic:
xor eax, eax
lodsb ; Length (will be set to 12)
add ebx, eax
lodsb ; IO APIC ID
lodsb ; Reserved
xor eax, eax
lodsd ; IO APIC Address
push rdi
push rcx
mov rdi, os_IOAPICAddress
xor ecx, ecx
mov cl, [os_IOAPICCount]
shl cx, 3 ; Quick multiply by 8
add rdi, rcx
pop rcx
stosd ; Store the IO APIC Address
lodsd ; System Vector Base
stosd ; Store the IO APIC Vector Base
pop rdi
inc byte [os_IOAPICCount]
jmp readAPICstructures ; Read the next structure
APICinterruptsourceoverride:
xor eax, eax
lodsb ; Length (will be set to 10)
add ebx, eax
lodsb ; Bus
lodsb ; Source
; call os_print_newline
; call os_debug_dump_al
; mov al, ' '
; call os_print_char
lodsd ; Global System Interrupt
; call os_debug_dump_eax
lodsw ; Flags
jmp readAPICstructures ; Read the next structure
APICx2apic:
xor eax, eax
xor edx, edx
lodsb ; Length (will be set to 16)
add ebx, eax
lodsw ; Reserved; Must be Zero
lodsd
xchg eax, edx ; Save the x2APIC ID to EDX
lodsd ; Flags (Bit 0 set if enabled/usable)
bt eax, 0 ; Test to see if usable
jnc APICx2apicEnd ; Read the next structure if CPU not usable
xchg eax, edx ; Restore the x2APIC ID back to EAX
call os_debug_dump_eax
call os_print_newline
; Save the ID's somewhere
APICx2apicEnd:
lodsd ; ACPI Processor UID
jmp readAPICstructures ; Read the next structure
APICignore:
xor eax, eax
lodsb ; We have a type that we ignore, read the next byte
add ebx, eax
add rsi, rax
sub rsi, 2 ; For the two bytes just read
jmp readAPICstructures ; Read the next structure
parseAPICTable_done:
pop rdx
pop rcx
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
parseHPETTable:
lodsd ; Length of HPET in bytes
lodsb ; Revision
lodsb ; Checksum
lodsd ; OEMID (First 4 bytes)
lodsw ; OEMID (Last 2 bytes)
lodsq ; OEM Table ID
lodsd ; OEM Revision
lodsd ; Creator ID
lodsd ; Creator Revision
lodsd ; Event Timer Block ID
lodsd ; Base Address Settings
lodsq ; Base Address Value
mov [os_HPETAddress], rax ; Save the Address of the HPET
lodsb ; HPET Number
lodsw ; Main Counter Minimum
lodsw ; Page Protection And OEM Attribute
ret
; -----------------------------------------------------------------------------
; =============================================================================
; EOF

142
Bootloader/Pure64/src/init/cpu.asm Normal file
View File

@ -0,0 +1,142 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; INIT CPU
; =============================================================================
init_cpu:
; Disable Cache
mov rax, cr0
btr rax, 29 ; Clear No Write Thru (Bit 29)
bts rax, 30 ; Set Cache Disable (Bit 30)
mov cr0, rax
; Flush Cache
wbinvd
; Diable Paging Global Extensions
mov rax, cr4
btr rax, 7 ; Clear Paging Global Extensions (Bit 7)
mov cr4, rax
mov rax, cr3
mov cr3, rax
; Disable MTRRs and Configure default memory type to UC
mov ecx, 0x000002FF
rdmsr
and eax, 0xFFFFF300 ; Clear MTRR Enable (Bit 11), Fixed Range MTRR Enable (Bit 10), and Default Memory Type (Bits 7:0) to UC (0x00)
wrmsr
; Setup variable-size address ranges
; Cache 0-64 MiB as type 6 (WB) cache
; See example in Intel Volume 3A. Example Base and Mask Calculations
; mov ecx, 0x00000200 ; MTRR_Phys_Base_MSR(0)
; mov edx, 0x00000000 ; Base is EDX:EAX, 0x0000000000000006
; mov eax, 0x00000006 ; Type 6 (write-back cache)
; wrmsr
; mov ecx, 0x00000201 ; MTRR_Phys_Mask_MSR(0)
;; mov edx, 0x00000000 ; Mask is EDX:EAX, 0x0000000001000800 (Because bochs sucks)
;; mov eax, 0x01000800 ; Bit 11 set for Valid
; mov edx, 0x0000000F ; Mask is EDX:EAX, 0x0000000F80000800 (2 GiB)
; mov eax, 0x80000800 ; Bit 11 set for Valid
; wrmsr
; MTRR notes:
; Base 0x0000000000000000 = 0 MiB
; Base 0x0000000080000000 = 2048 MiB, 2048 is 0x800
; Base 0x0000000100000000 = 4096 MiB, 4096 is 0x1000
; Mask 0x0000000F80000000 = 2048 MiB, 0xFFFFFFFFF - F80000000 = 7FFFFFFF = 2147483647 (~2 GiB)
; Mask 0x0000000FC0000000 = 1024 MiB, 0xFFFFFFFFF - FC0000000 = 3FFFFFFF = 1073741823 (~1 GiB)
; Mask 0x0000000FFC000000 = 64 MiB, 0xFFFFFFFFF - FFC000000 = 3FFFFFF = 67108863 (~64 MiB)
; Enable MTRRs
mov ecx, 0x000002FF
rdmsr
bts eax, 11 ; Set MTRR Enable (Bit 11), Only enables Variable Range MTRR's
wrmsr
; Flush Cache
wbinvd
; Enable Cache
mov rax, cr0
btr rax, 29 ; Clear No Write Thru (Bit 29)
btr rax, 30 ; Clear CD (Bit 30)
mov cr0, rax
; Enable Paging Global Extensions
; mov rax, cr4
; bts rax, 7 ; Set Paging Global Extensions (Bit 7)
; mov cr4, rax
; Enable Floating Point
mov rax, cr0
bts rax, 1 ; Set Monitor co-processor (Bit 1)
btr rax, 2 ; Clear Emulation (Bit 2)
mov cr0, rax
; Enable SSE
mov rax, cr4
bts rax, 9 ; Set Operating System Support for FXSAVE and FXSTOR instructions (Bit 9)
bts rax, 10 ; Set Operating System Support for Unmasked SIMD Floating-Point Exceptions (Bit 10)
mov cr4, rax
; Enable Math Co-processor
finit
; Enable and Configure Local APIC
mov rsi, [os_LocalAPICAddress]
cmp rsi, 0x00000000
je noMP ; Skip MP init if we didn't get a valid LAPIC address
xor eax, eax ; Clear Task Priority (bits 7:4) and Priority Sub-Class (bits 3:0)
mov dword [rsi+0x80], eax ; Task Priority Register (TPR)
mov eax, 0x01000000 ; Set bits 31-24 for all cores to be in Group 1
mov dword [rsi+0xD0], eax ; Logical Destination Register
xor eax, eax
sub eax, 1 ; Set EAX to 0xFFFFFFFF; Bits 31-28 set for Flat Mode
mov dword [rsi+0xE0], eax ; Destination Format Register
mov eax, dword [rsi+0xF0] ; Spurious Interrupt Vector Register
mov al, 0xF8
bts eax, 8 ; Enable APIC (Set bit 8)
mov dword [rsi+0xF0], eax
mov eax, dword [rsi+0x320] ; LVT Timer Register
bts eax, 16 ; Set bit 16 for mask interrupts
mov dword [rsi+0x320], eax
; mov eax, dword [rsi+0x350] ; LVT LINT0 Register
; mov al, 0 ;Set interrupt vector (bits 7:0)
; bts eax, 8 ;Delivery Mode (111b==ExtlNT] (bits 10:8)
; bts eax, 9
; bts eax, 10
; bts eax, 15 ;bit15:Set trigger mode to Level (0== Edge, 1== Level)
; btr eax, 16 ;bit16:unmask interrupts (0==Unmasked, 1== Masked)
; mov dword [rsi+0x350], eax
; mov eax, dword [rsi+0x360] ; LVT LINT1 Register
; mov al, 0 ;Set interrupt vector (bits 7:0)
; bts eax, 8 ;Delivery Mode (111b==ExtlNT] (bits 10:8)
; bts eax, 9
; bts eax, 10
; bts eax, 15 ;bit15:Set trigger mode to Edge (0== Edge, 1== Level)
; btr eax, 16 ;bit16:unmask interrupts (0==Unmasked, 1== Masked)
; mov dword [rsi+0x360], eax
; mov eax, dword [rsi+0x370] ; LVT Error Register
; mov al, 0 ;Set interrupt vector (bits 7:0)
; bts eax, 16 ;bit16:Mask interrupts (0==Unmasked, 1== Masked)
; mov dword [rsi+0x370], eax
ret
; =============================================================================
; EOF

154
Bootloader/Pure64/src/init/isa.asm Normal file
View File

@ -0,0 +1,154 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; INIT ISA
; =============================================================================
init_isa:
mov edi, 0x00004000 ; Clear out memory for the E820 map
xor eax, eax
mov ecx, 2048
rep stosd
; Get the BIOS E820 Memory Map
; use the INT 0x15, eax= 0xE820 BIOS function to get a memory map
; inputs: es:di -> destination buffer for 24 byte entries
; outputs: bp = entry count, trashes all registers except esi
do_e820:
mov edi, 0x00004000 ; location that memory map will be stored to
xor ebx, ebx ; ebx must be 0 to start
xor bp, bp ; keep an entry count in bp
mov edx, 0x0534D4150 ; Place "SMAP" into edx
mov eax, 0xe820
mov [es:di + 20], dword 1 ; force a valid ACPI 3.X entry
mov ecx, 24 ; ask for 24 bytes
int 0x15
jc nomemmap ; carry set on first call means "unsupported function"
mov edx, 0x0534D4150 ; Some BIOSes apparently trash this register?
cmp eax, edx ; on success, eax must have been reset to "SMAP"
jne nomemmap
test ebx, ebx ; ebx = 0 implies list is only 1 entry long (worthless)
je nomemmap
jmp jmpin
e820lp:
mov eax, 0xe820 ; eax, ecx get trashed on every int 0x15 call
mov [es:di + 20], dword 1 ; force a valid ACPI 3.X entry
mov ecx, 24 ; ask for 24 bytes again
int 0x15
jc memmapend ; carry set means "end of list already reached"
mov edx, 0x0534D4150 ; repair potentially trashed register
jmpin:
jcxz skipent ; skip any 0 length entries
cmp cl, 20 ; got a 24 byte ACPI 3.X response?
jbe notext
test byte [es:di + 20], 1 ; if so: is the "ignore this data" bit clear?
je skipent
notext:
mov ecx, [es:di + 8] ; get lower dword of memory region length
test ecx, ecx ; is the qword == 0?
jne goodent
mov ecx, [es:di + 12] ; get upper dword of memory region length
jecxz skipent ; if length qword is 0, skip entry
goodent:
inc bp ; got a good entry: ++count, move to next storage spot
add di, 32
skipent:
test ebx, ebx ; if ebx resets to 0, list is complete
jne e820lp
nomemmap:
mov byte [cfg_e820], 0 ; No memory map function
memmapend:
xor eax, eax ; Create a blank record for termination (32 bytes)
mov ecx, 8
rep stosd
; Enable the A20 gate
set_A20:
in al, 0x64
test al, 0x02
jnz set_A20
mov al, 0xD1
out 0x64, al
check_A20:
in al, 0x64
test al, 0x02
jnz check_A20
mov al, 0xDF
out 0x60, al
; Set up RTC
; Port 0x70 is RTC Address, and 0x71 is RTC Data
; http://www.nondot.org/sabre/os/files/MiscHW/RealtimeClockFAQ.txt
rtc_poll:
mov al, 0x0A ; Status Register A
out 0x70, al ; Select the address
in al, 0x71 ; Read the data
test al, 0x80 ; Is there an update in process?
jne rtc_poll ; If so then keep polling
mov al, 0x0A ; Status Register A
out 0x70, al ; Select the address
mov al, 00100110b ; UIP (0), RTC@32.768KHz (010), Rate@1024Hz (0110)
out 0x71, al ; Write the data
; Remap PIC IRQ's
mov al, 00010001b ; begin PIC 1 initialization
out 0x20, al
mov al, 00010001b ; begin PIC 2 initialization
out 0xA0, al
mov al, 0x20 ; IRQ 0-7: interrupts 20h-27h
out 0x21, al
mov al, 0x28 ; IRQ 8-15: interrupts 28h-2Fh
out 0xA1, al
mov al, 4
out 0x21, al
mov al, 2
out 0xA1, al
mov al, 1
out 0x21, al
out 0xA1, al
; Mask all PIC interrupts
mov al, 0xFF
out 0x21, al
out 0xA1, al
; Configure graphics if requested
cmp byte [cfg_vesa], 1 ; Check if VESA should be enabled
jne VBEdone ; If not then skip VESA init
mov edi, VBEModeInfoBlock ; VBE data will be stored at this address
mov ax, 0x4F01 ; GET SuperVGA MODE INFORMATION - http://www.ctyme.com/intr/rb-0274.htm
; CX queries the mode, it should be in the form 0x41XX as bit 14 is set for LFB and bit 8 is set for VESA mode
; 0x4112 is 640x480x24bit, 0x4129 should be 32bit
; 0x4115 is 800x600x24bit, 0x412E should be 32bit
; 0x4118 is 1024x768x24bit, 0x4138 should be 32bit
; 0x411B is 1280x1024x24bit, 0x413D should be 32bit
mov cx, 0x4118 ; Put your desired mode here
mov bx, cx ; Mode is saved to BX for the set command later
int 0x10
cmp ax, 0x004F ; Return value in AX should equal 0x004F if command supported and successful
jne VBEfail
cmp byte [VBEModeInfoBlock.BitsPerPixel], 24 ; Make sure this matches the number of bits for the mode!
jne VBEfail ; If set bit mode was unsuccessful then bail out
or bx, 0x4000 ; Use linear/flat frame buffer model (set bit 14)
mov ax, 0x4F02 ; SET SuperVGA VIDEO MODE - http://www.ctyme.com/intr/rb-0275.htm
int 0x10
cmp ax, 0x004F ; Return value in AX should equal 0x004F if supported and successful
jne VBEfail
jmp VBEdone
VBEfail:
mov si, msg_novesa
call print_string_16
mov byte [cfg_vesa], 0 ; Clear the VESA config as it was not successful
VBEdone:
ret
; =============================================================================
; EOF

40
Bootloader/Pure64/src/init/pic.asm Normal file
View File

@ -0,0 +1,40 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; INIT PIC
; =============================================================================
init_pic:
; Enable specific interrupts
in al, 0x21
mov al, 11111001b ; Enable Cascade, Keyboard
out 0x21, al
in al, 0xA1
mov al, 11111110b ; Enable RTC
out 0xA1, al
; Set the periodic flag in the RTC
mov al, 0x0B ; Status Register B
out 0x70, al ; Select the address
in al, 0x71 ; Read the current settings
push rax
mov al, 0x0B ; Status Register B
out 0x70, al ; Select the address
pop rax
bts ax, 6 ; Set Periodic(6)
out 0x71, al ; Write the new settings
sti ; Enable interrupts
; Acknowledge the RTC
mov al, 0x0C ; Status Register C
out 0x70, al ; Select the address
in al, 0x71 ; Read the current settings
ret
; =============================================================================
; EOF

160
Bootloader/Pure64/src/init/smp.asm Normal file
View File

@ -0,0 +1,160 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; INIT SMP
; =============================================================================
init_smp:
mov al, '5' ; Start of MP init
mov [0x000B809C], al
mov al, '0'
mov [0x000B809E], al
; Check if we want the AP's to be enabled.. if not then skip to end
; cmp byte [cfg_smpinit], 1 ; Check if SMP should be enabled
; jne noMP ; If not then skip SMP init
; Start the AP's one by one
xor eax, eax
xor edx, edx
mov rsi, [os_LocalAPICAddress]
add rsi, 0x20 ; Add the offset for the APIC ID location
lodsd ; APIC ID is stored in bits 31:24
shr rax, 24 ; AL now holds the BSP CPU's APIC ID
mov dl, al ; Store BSP APIC ID in DL
mov al, '8' ; Start the AP's
mov [0x000B809E], al
mov rsi, 0x0000000000005100
xor eax, eax
xor ecx, ecx
mov cx, [cpu_detected]
smp_send_INIT:
cmp cx, 0
je smp_send_INIT_done
lodsb
cmp al, dl ; Is it the BSP?
je smp_send_INIT_skipcore
; Broadcast 'INIT' IPI to APIC ID in AL
mov rdi, [os_LocalAPICAddress]
shl eax, 24
mov dword [rdi+0x310], eax ; Interrupt Command Register (ICR); bits 63-32
mov eax, 0x00004500
mov dword [rdi+0x300], eax ; Interrupt Command Register (ICR); bits 31-0
smp_send_INIT_verify:
mov eax, [rdi+0x300] ; Interrupt Command Register (ICR); bits 31-0
bt eax, 12 ; Verify that the command completed
jc smp_send_INIT_verify
smp_send_INIT_skipcore:
dec cl
jmp smp_send_INIT
smp_send_INIT_done:
mov rax, [os_Counter_RTC]
add rax, 10
wait1:
mov rbx, [os_Counter_RTC]
cmp rax, rbx
jg wait1
mov rsi, 0x0000000000005100
xor ecx, ecx
mov cx, [cpu_detected]
smp_send_SIPI:
cmp cx, 0
je smp_send_SIPI_done
lodsb
cmp al, dl ; Is it the BSP?
je smp_send_SIPI_skipcore
; Broadcast 'Startup' IPI to destination using vector 0x08 to specify entry-point is at the memory-address 0x00008000
mov rdi, [os_LocalAPICAddress]
shl eax, 24
mov dword [rdi+0x310], eax ; Interrupt Command Register (ICR); bits 63-32
mov eax, 0x00004608 ; Vector 0x08
mov dword [rdi+0x300], eax ; Interrupt Command Register (ICR); bits 31-0
smp_send_SIPI_verify:
mov eax, [rdi+0x300] ; Interrupt Command Register (ICR); bits 31-0
bt eax, 12 ; Verify that the command completed
jc smp_send_SIPI_verify
smp_send_SIPI_skipcore:
dec cl
jmp smp_send_SIPI
smp_send_SIPI_done:
mov al, 'A'
mov [0x000B809E], al
; Let things settle (Give the AP's some time to finish)
mov rax, [os_Counter_RTC]
add rax, 20
wait3:
mov rbx, [os_Counter_RTC]
cmp rax, rbx
jg wait3
; Finish up
noMP:
lock inc word [cpu_activated] ; BSP adds one here
xor eax, eax
mov rsi, [os_LocalAPICAddress]
add rsi, 0x20 ; Add the offset for the APIC ID location
lodsd ; APIC ID is stored in bits 31:24
shr rax, 24 ; AL now holds the CPU's APIC ID (0 - 255)
mov [os_BSP], eax ; Store the BSP APIC ID
mov al, 'C'
mov [0x000B809E], al
; Calculate speed of CPU (At this point the RTC is firing at 1024Hz)
cpuid
xor edx, edx
xor eax, eax
mov rcx, [os_Counter_RTC]
add rcx, 10
rdtsc
push rax
speedtest:
mov rbx, [os_Counter_RTC]
cmp rbx, rcx
jl speedtest
rdtsc
pop rdx
sub rax, rdx
xor edx, edx
mov rcx, 10240
div rcx
mov [cpu_speed], ax
; Clear the periodic flag in the RTC
mov al, 0x0B ; Status Register B
out 0x70, al ; Select the address
in al, 0x71 ; Read the current settings
push rax
mov al, 0x0B ; Status Register B
out 0x70, al ; Select the address
pop rax
btc ax, 6 ; Set Periodic(6)
out 0x71, al ; Write the new settings
mov al, 'E'
mov [0x000B809E], al
cli ; Disable Interrupts
ret
; =============================================================================
; EOF

176
Bootloader/Pure64/src/init/smp_ap.asm Normal file
View File

@ -0,0 +1,176 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; INIT SMP AP
; =============================================================================
USE16
init_smp_ap:
jmp 0x0000:clearcs_ap
clearcs_ap:
; Enable the A20 gate
set_A20_ap:
in al, 0x64
test al, 0x02
jnz set_A20_ap
mov al, 0xD1
out 0x64, al
check_A20_ap:
in al, 0x64
test al, 0x02
jnz check_A20_ap
mov al, 0xDF
out 0x60, al
; At this point we are done with real mode and BIOS interrupts. Jump to 32-bit mode.
lgdt [cs:GDTR32] ; load GDT register
mov eax, cr0 ; switch to 32-bit protected mode
or al, 1
mov cr0, eax
jmp 8:startap32
align 16
; =============================================================================
; 32-bit mode
USE32
startap32:
mov eax, 16 ; load 4 GB data descriptor
mov ds, ax ; to all data segment registers
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax
xor eax, eax
xor ebx, ebx
xor ecx, ecx
xor edx, edx
xor esi, esi
xor edi, edi
xor ebp, ebp
mov esp, 0x8000 ; Set a known free location for the stack
; Load the GDT
lgdt [GDTR64]
; Enable extended properties
mov eax, cr4
or eax, 0x0000000B0 ; PGE (Bit 7), PAE (Bit 5), and PSE (Bit 4)
mov cr4, eax
; Point cr3 at PML4
mov eax, 0x00002008 ; Write-thru (Bit 3)
mov cr3, eax
; Enable long mode and SYSCALL/SYSRET
mov ecx, 0xC0000080 ; EFER MSR number
rdmsr ; Read EFER
or eax, 0x00000101 ; LME (Bit 8)
wrmsr ; Write EFER
; Enable paging to activate long mode
mov eax, cr0
or eax, 0x80000000 ; PG (Bit 31)
mov cr0, eax
; Make the jump directly from 16-bit real mode to 64-bit long mode
jmp SYS64_CODE_SEL:startap64
align 16
; =============================================================================
; 64-bit mode
USE64
startap64:
xor rax, rax ; aka r0
xor rbx, rbx ; aka r3
xor rcx, rcx ; aka r1
xor rdx, rdx ; aka r2
xor rsi, rsi ; aka r6
xor rdi, rdi ; aka r7
xor rbp, rbp ; aka r5
xor rsp, rsp ; aka r4
xor r8, r8
xor r9, r9
xor r10, r10
xor r11, r11
xor r12, r12
xor r13, r13
xor r14, r14
xor r15, r15
mov ds, ax ; Clear the legacy segment registers
mov es, ax
mov ss, ax
mov fs, ax
mov gs, ax
mov rax, clearcs64_ap
jmp rax
nop
clearcs64_ap:
xor rax, rax
; Reset the stack. Each CPU gets a 1024-byte unique stack location
mov rsi, [os_LocalAPICAddress] ; We would call os_smp_get_id here but the stack is not ...
add rsi, 0x20 ; ... yet defined. It is safer to find the value directly.
lodsd ; Load a 32-bit value. We only want the high 8 bits
shr rax, 24 ; Shift to the right and AL now holds the CPU's APIC ID
shl rax, 10 ; shift left 10 bits for a 1024byte stack
add rax, 0x0000000000050400 ; stacks decrement when you "push", start at 1024 bytes in
mov rsp, rax ; Pure64 leaves 0x50000-0x9FFFF free so we use that
lgdt [GDTR64] ; Load the GDT
lidt [IDTR64] ; load IDT register
; Enable Local APIC on AP
mov rsi, [os_LocalAPICAddress]
add rsi, 0x00f0 ; Offset to Spurious Interrupt Register
mov rdi, rsi
lodsd
or eax, 0000000100000000b
stosd
call init_cpu ; Setup CPU
; Make sure exceptions are working.
; xor rax, rax
; xor rbx, rbx
; xor rcx, rcx
; xor rdx, rdx
; div rax
lock inc word [cpu_activated]
xor eax, eax
mov rsi, [os_LocalAPICAddress]
add rsi, 0x20 ; Add the offset for the APIC ID location
lodsd ; APIC ID is stored in bits 31:24
shr rax, 24 ; AL now holds the CPU's APIC ID (0 - 255)
mov rdi, 0x00005700 ; The location where the cpu values are stored
add rdi, rax ; RDI points to infomap CPU area + APIC ID. ex F701 would be APIC ID 1
mov al, 1
stosb
sti ; Activate interrupts for SMP
jmp ap_sleep
align 16
ap_sleep:
hlt ; Suspend CPU until an interrupt is received. opcode for hlt is 0xF4
jmp ap_sleep ; just-in-case of an NMI
; =============================================================================
; EOF

242
Bootloader/Pure64/src/interrupt.asm Normal file
View File

@ -0,0 +1,242 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; Interrupts
; =============================================================================
; -----------------------------------------------------------------------------
; Default exception handler
exception_gate:
mov rsi, int_string
call os_print_string
mov rsi, exc_string
call os_print_string
exception_gate_halt:
cli ; Disable interrupts
hlt ; Halt the system
jmp exception_gate_halt
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; Default interrupt handler
interrupt_gate: ; handler for all other interrupts
iretq
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; Keyboard interrupt. IRQ 0x01, INT 0x21
; This IRQ runs whenever there is input on the keyboard
align 16
keyboard:
push rdi
push rax
xor eax, eax
in al, 0x60 ; Get the scancode from the keyboard
test al, 0x80
jnz keyboard_done
mov [0x000B8088], al ; Dump the scancode to the screen
mov rax, [os_Counter_RTC]
add rax, 10
mov [os_Counter_RTC], rax
keyboard_done:
mov al, 0x20 ; Acknowledge the IRQ
out 0x20, al
pop rax
pop rdi
iretq
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; Cascade interrupt. IRQ 0x02, INT 0x22
cascade:
push rax
mov al, 0x20 ; Acknowledge the IRQ
out 0x20, al
pop rax
iretq
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; Real-time clock interrupt. IRQ 0x08, INT 0x28
align 16
rtc:
push rdi
push rax
add qword [os_Counter_RTC], 1 ; 64-bit counter started at bootup
mov al, 'R'
mov [0x000B8092], al
mov rax, [os_Counter_RTC]
and al, 1 ; Clear all but lowest bit (Can only be 0 or 1)
add al, 48
mov [0x000B8094], al
mov al, 0x0C ; Select RTC register C
out 0x70, al ; Port 0x70 is the RTC index, and 0x71 is the RTC data
in al, 0x71 ; Read the value in register C
mov al, 0x20 ; Acknowledge the IRQ
out 0xA0, al
out 0x20, al
pop rax
pop rdi
iretq
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; Spurious interrupt. INT 0xFF
align 16
spurious: ; handler for spurious interrupts
mov al, 'S'
mov [0x000B8080], al
iretq
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; CPU Exception Gates
exception_gate_00:
mov al, 0x00
jmp exception_gate_main
exception_gate_01:
mov al, 0x01
jmp exception_gate_main
exception_gate_02:
mov al, 0x02
jmp exception_gate_main
exception_gate_03:
mov al, 0x03
jmp exception_gate_main
exception_gate_04:
mov al, 0x04
jmp exception_gate_main
exception_gate_05:
mov al, 0x05
jmp exception_gate_main
exception_gate_06:
mov al, 0x06
jmp exception_gate_main
exception_gate_07:
mov al, 0x07
jmp exception_gate_main
exception_gate_08:
mov al, 0x08
jmp exception_gate_main
exception_gate_09:
mov al, 0x09
jmp exception_gate_main
exception_gate_10:
mov al, 0x0A
jmp exception_gate_main
exception_gate_11:
mov al, 0x0B
jmp exception_gate_main
exception_gate_12:
mov al, 0x0C
jmp exception_gate_main
exception_gate_13:
mov al, 0x0D
jmp exception_gate_main
exception_gate_14:
mov al, 0x0E
jmp exception_gate_main
exception_gate_15:
mov al, 0x0F
jmp exception_gate_main
exception_gate_16:
mov al, 0x10
jmp exception_gate_main
exception_gate_17:
mov al, 0x11
jmp exception_gate_main
exception_gate_18:
mov al, 0x12
jmp exception_gate_main
exception_gate_19:
mov al, 0x13
jmp exception_gate_main
exception_gate_main:
call os_print_newline
mov rsi, int_string
call os_print_string
mov rsi, exc_string00
and rax, 0xFF ; Clear out everything in RAX except for AL
shl eax, 3 ; Quick multiply by 3
add rsi, rax ; Use the value in RAX as an offset to get to the right message
call os_print_string
mov rsi, adr_string
call os_print_string
mov rax, [rsp]
call os_debug_dump_rax
call os_print_newline
call os_dump_regs
exception_gate_main_hang:
nop
jmp exception_gate_main_hang ; Hang. User must reset machine at this point
; Strings for the error messages
int_string db 'Pure64 - Exception ', 0
adr_string db ' @ 0x', 0
exc_string db '?? - Unknown', 0
align 16
exc_string00 db '00 - DE', 0
exc_string01 db '01 - DB', 0
exc_string02 db '02 ', 0
exc_string03 db '03 - BP', 0
exc_string04 db '04 - OF', 0
exc_string05 db '05 - BR', 0
exc_string06 db '06 - UD', 0
exc_string07 db '07 - NM', 0
exc_string08 db '08 - DF', 0
exc_string09 db '09 ', 0 ; No longer generated on new CPU's
exc_string10 db '10 - TS', 0
exc_string11 db '11 - NP', 0
exc_string12 db '12 - SS', 0
exc_string13 db '13 - GP', 0
exc_string14 db '14 - PF', 0
exc_string15 db '15 ', 0
exc_string16 db '16 - MF', 0
exc_string17 db '17 - AC', 0
exc_string18 db '18 - MC', 0
exc_string19 db '19 - XM', 0
; =============================================================================
; EOF

62
Bootloader/Pure64/src/pci.asm Normal file
View File

@ -0,0 +1,62 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; PCI Functions. http://wiki.osdev.org/PCI
; =============================================================================
; -----------------------------------------------------------------------------
; os_pci_read_reg -- Read a register from a PCI device
; IN: BL = Bus number
; CL = Device/Function number
; DL = Register number
; OUT: EAX = Register information
; All other registers preserved
; Data form is binary 10000000 bbbbbbbb dddddfff rrrrrr00
os_pci_read_reg:
push rdx
push rcx
push rbx
shl ebx, 16 ; Move Bus to bits 23 - 16
shl ecx, 8 ; Move Device/Function to bits 15 - 8
mov bx, cx
shl edx, 2 ; Move Register to bits 7 - 2
mov bl, dl
and ebx, 0x00ffffff ; Clear bits 31 - 24
or ebx, 0x80000000 ; Set bit 31
mov eax, ebx
mov dx, PCI_CONFIG_ADDRESS
out dx, eax
mov dx, PCI_CONFIG_DATA
in eax, dx
pop rbx
pop rcx
pop rdx
ret
; -----------------------------------------------------------------------------
;Configuration Mechanism One has two IO port rages associated with it.
;The address port (0xcf8-0xcfb) and the data port (0xcfc-0xcff).
;A configuration cycle consists of writing to the address port to specify which device and register you want to access and then reading or writing the data to the data port.
PCI_CONFIG_ADDRESS EQU 0x0CF8
PCI_CONFIG_DATA EQU 0x0CFC
;ddress dd 10000000000000000000000000000000b
; /\ /\ /\ /\ /\ /\
; E Res Bus Dev F Reg 0
; Bits
; 31 Enable bit = set to 1
; 30 - 24 Reserved = set to 0
; 23 - 16 Bus number = 256 options
; 15 - 11 Device/Slot number = 32 options
; 10 - 8 Function number = will leave at 0 (8 options)
; 7 - 2 Register number = will leave at 0 (64 options) 64 x 4 bytes = 256 bytes worth of accessible registers
; 1 - 0 Set to 0
; =============================================================================
; EOF

641
Bootloader/Pure64/src/pure64.asm Normal file
View File

@ -0,0 +1,641 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; Loaded from the first stage. Gather information about the system while
; in 16-bit mode (BIOS is still accessible), setup a minimal 64-bit
; environment, copy the 64-bit kernel from the end of the Pure64 binary to
; the 1MiB memory mark and jump to it!
;
; Pure64 requires a payload for execution! The stand-alone pure64.sys file
; is not sufficient. You must append your kernel or software to the end of
; the Pure64 binary. The maximum size of the kernel of software is 26KiB.
;
; Windows - copy /b pure64.sys + kernel64.sys
; Unix - cat pure64.sys kernel64.sys > pure64.sys
; Max size of the resulting pure64.sys is 32768 bytes (32KiB)
; =============================================================================
USE16
ORG 0x00008000
start:
cli ; Disable all interrupts
xor eax, eax
xor ebx, ebx
xor ecx, ecx
xor edx, edx
xor esi, esi
xor edi, edi
xor ebp, ebp
mov ds, ax
mov es, ax
mov ss, ax
mov fs, ax
mov gs, ax
mov esp, 0x8000 ; Set a known free location for the stack
ap_modify:
jmp start16 ; This command will be overwritten with 'NOP's before the AP's are started
nop ; The 'jmp' is only 3 bytes
%include "init/smp_ap.asm" ; AP's will start execution at 0x8000 and fall through to this code
;db '_16_' ; Debug
align 16
USE16
start16:
jmp 0x0000:clearcs
clearcs:
; Configure serial port
xor dx, dx ; First serial port
mov ax, 0000000011100011b ; 9600 baud, no parity, 1 stop bit, 8 data bits
int 0x14
; Make sure the screen is set to 80x25 color text mode
mov ax, 0x0003 ; Set to normal (80x25 text) video mode
int 0x10
; Disable blinking
mov ax, 0x1003
mov bx, 0x0000
int 0x10
; Print message
mov si, msg_initializing
call print_string_16
; Check to make sure the CPU supports 64-bit mode... If not then bail out
mov eax, 0x80000000 ; Extended-function 8000000h.
cpuid ; Is largest extended function
cmp eax, 0x80000000 ; any function > 80000000h?
jbe no_long_mode ; If not, no long mode.
mov eax, 0x80000001 ; Extended-function 8000001h.
cpuid ; Now EDX = extended-features flags.
bt edx, 29 ; Test if long mode is supported.
jnc no_long_mode ; Exit if not supported.
call init_isa ; Setup legacy hardware
; Hide the hardware cursor (interferes with print_string_16 if called earlier)
mov ax, 0x0200 ; VIDEO - SET CURSOR POSITION
mov bx, 0x0000 ; Page number
mov dx, 0x2000 ; Row / Column
int 0x10
; At this point we are done with real mode and BIOS interrupts. Jump to 32-bit mode.
lgdt [cs:GDTR32] ; Load GDT register
mov eax, cr0
or al, 0x01 ; Set protected mode bit
mov cr0, eax
jmp 8:start32 ; Jump to 32-bit protected mode
; 16-bit function to print a sting to the screen
print_string_16: ; Output string in SI to screen
pusha
mov ah, 0x0E ; http://www.ctyme.com/intr/rb-0106.htm
print_string_16_repeat:
lodsb ; Get char from string
cmp al, 0
je print_string_16_done ; If char is zero, end of string
int 0x10 ; Otherwise, print it
jmp print_string_16_repeat
print_string_16_done:
popa
ret
; Display an error message that the CPU does not support 64-bit mode
no_long_mode:
mov si, msg_no64
call print_string_16
jmp $
%include "init/isa.asm"
align 16
GDTR32: ; Global Descriptors Table Register
dw gdt32_end - gdt32 - 1 ; limit of GDT (size minus one)
dq gdt32 ; linear address of GDT
align 16
gdt32:
dw 0x0000, 0x0000, 0x0000, 0x0000 ; Null desciptor
dw 0xFFFF, 0x0000, 0x9A00, 0x00CF ; 32-bit code descriptor
dw 0xFFFF, 0x0000, 0x9200, 0x00CF ; 32-bit data descriptor
gdt32_end:
;db '_32_' ; Debug
align 16
; =============================================================================
; 32-bit mode
USE32
start32:
mov eax, 16 ; load 4 GB data descriptor
mov ds, ax ; to all data segment registers
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax
xor eax, eax
xor ebx, ebx
xor ecx, ecx
xor edx, edx
xor esi, esi
xor edi, edi
xor ebp, ebp
mov esp, 0x8000 ; Set a known free location for the stack
mov al, '2' ; Now in 32-bit protected mode (0x20 = 32)
mov [0x000B809C], al
mov al, '0'
mov [0x000B809E], al
; Clear out the first 4096 bytes of memory. This will store the 64-bit IDT, GDT, PML4, and PDP
mov ecx, 1024
xor eax, eax
mov edi, eax
rep stosd
; Clear memory for the Page Descriptor Entries (0x10000 - 0x4FFFF)
mov edi, 0x00010000
mov ecx, 65536
rep stosd
; Copy the GDT to its final location in memory
mov esi, gdt64
mov edi, 0x00001000 ; GDT address
mov ecx, (gdt64_end - gdt64)
rep movsb ; Move it to final pos.
; Create the Level 4 Page Map. (Maps 4GBs of 2MB pages)
; First create a PML4 entry.
; PML4 is stored at 0x0000000000002000, create the first entry there
; A single PML4 entry can map 512GB with 2MB pages.
cld
mov edi, 0x00002000 ; Create a PML4 entry for the first 4GB of RAM
mov eax, 0x00003007
stosd
xor eax, eax
stosd
mov edi, 0x00002800 ; Create a PML4 entry for higher half (starting at 0xFFFF800000000000)
mov eax, 0x00003007 ; The higher half is identity mapped to the lower half
stosd
xor eax, eax
stosd
; Create the PDP entries.
; The first PDP is stored at 0x0000000000003000, create the first entries there
; A single PDP entry can map 1GB with 2MB pages
mov ecx, 64 ; number of PDPE's to make.. each PDPE maps 1GB of physical memory
mov edi, 0x00003000
mov eax, 0x00010007 ; location of first PD
create_pdpe:
stosd
push eax
xor eax, eax
stosd
pop eax
add eax, 0x00001000 ; 4K later (512 records x 8 bytes)
dec ecx
cmp ecx, 0
jne create_pdpe
; Create the PD entries.
; PD entries are stored starting at 0x0000000000010000 and ending at 0x000000000004FFFF (256 KiB)
; This gives us room to map 64 GiB with 2 MiB pages
mov edi, 0x00010000
mov eax, 0x0000008F ; Bit 7 must be set to 1 as we have 2 MiB pages
xor ecx, ecx
pd_again: ; Create a 2 MiB page
stosd
push eax
xor eax, eax
stosd
pop eax
add eax, 0x00200000
inc ecx
cmp ecx, 2048
jne pd_again ; Create 2048 2 MiB page maps.
; Load the GDT
lgdt [GDTR64]
; Enable extended properties
mov eax, cr4
or eax, 0x0000000B0 ; PGE (Bit 7), PAE (Bit 5), and PSE (Bit 4)
mov cr4, eax
; Point cr3 at PML4
mov eax, 0x00002008 ; Write-thru (Bit 3)
mov cr3, eax
; Enable long mode and SYSCALL/SYSRET
mov ecx, 0xC0000080 ; EFER MSR number
rdmsr ; Read EFER
or eax, 0x00000101 ; LME (Bit 8)
wrmsr ; Write EFER
; Debug
mov al, '1' ; About to make the jump into 64-bit mode
mov [0x000B809C], al
mov al, 'E'
mov [0x000B809E], al
; Enable paging to activate long mode
mov eax, cr0
or eax, 0x80000000 ; PG (Bit 31)
mov cr0, eax
jmp SYS64_CODE_SEL:start64 ; Jump to 64-bit mode
;db '_64_' ; Debug
align 16
; =============================================================================
; 64-bit mode
USE64
start64:
; Debug
mov al, '4' ; Now in 64-bit mode (0x40 = 64)
mov [0x000B809C], al
mov al, '0'
mov [0x000B809E], al
mov al, 2
mov ah, 22
call os_move_cursor
xor rax, rax ; aka r0
xor rbx, rbx ; aka r3
xor rcx, rcx ; aka r1
xor rdx, rdx ; aka r2
xor rsi, rsi ; aka r6
xor rdi, rdi ; aka r7
xor rbp, rbp ; aka r5
mov rsp, 0x8000 ; aka r4
xor r8, r8
xor r9, r9
xor r10, r10
xor r11, r11
xor r12, r12
xor r13, r13
xor r14, r14
xor r15, r15
mov ds, ax ; Clear the legacy segment registers
mov es, ax
mov ss, ax
mov fs, ax
mov gs, ax
mov rax, clearcs64 ; Do a proper 64-bit jump. Should not be needed as the ...
jmp rax ; jmp SYS64_CODE_SEL:start64 would have sent us ...
nop ; out of compatibility mode and into 64-bit mode
clearcs64:
xor rax, rax
lgdt [GDTR64] ; Reload the GDT
; Debug
mov al, '2'
mov [0x000B809E], al
; Patch Pure64 AP code ; The AP's will be told to start execution at 0x8000
mov edi, ap_modify ; We need to remove the BSP Jump call to get the AP's
mov eax, 0x90909090 ; to fall through to the AP Init code
stosd
; Build the rest of the page tables (4GiB+)
mov rcx, 0x0000000000000000
mov rax, 0x000000010000008F
mov rdi, 0x0000000000014000
buildem:
stosq
add rax, 0x0000000000200000
add rcx, 1
cmp rcx, 30720 ; Another 60 GiB (We already mapped 4 GiB)
jne buildem
; We have 64 GiB mapped now
; Build a temporary IDT
xor rdi, rdi ; create the 64-bit IDT (at linear address 0x0000000000000000)
mov rcx, 32
make_exception_gates: ; make gates for exception handlers
mov rax, exception_gate
push rax ; save the exception gate to the stack for later use
stosw ; store the low word (15..0) of the address
mov ax, SYS64_CODE_SEL
stosw ; store the segment selector
mov ax, 0x8E00
stosw ; store exception gate marker
pop rax ; get the exception gate back
shr rax, 16
stosw ; store the high word (31..16) of the address
shr rax, 16
stosd ; store the extra high dword (63..32) of the address.
xor rax, rax
stosd ; reserved
dec rcx
jnz make_exception_gates
mov rcx, 256-32
make_interrupt_gates: ; make gates for the other interrupts
mov rax, interrupt_gate
push rax ; save the interrupt gate to the stack for later use
stosw ; store the low word (15..0) of the address
mov ax, SYS64_CODE_SEL
stosw ; store the segment selector
mov ax, 0x8F00
stosw ; store interrupt gate marker
pop rax ; get the interrupt gate back
shr rax, 16
stosw ; store the high word (31..16) of the address
shr rax, 16
stosd ; store the extra high dword (63..32) of the address.
xor rax, rax
stosd ; reserved
dec rcx
jnz make_interrupt_gates
; Set up the exception gates for all of the CPU exceptions
; The following code will be seriously busted if the exception gates are moved above 16MB
mov word [0x00*16], exception_gate_00
mov word [0x01*16], exception_gate_01
mov word [0x02*16], exception_gate_02
mov word [0x03*16], exception_gate_03
mov word [0x04*16], exception_gate_04
mov word [0x05*16], exception_gate_05
mov word [0x06*16], exception_gate_06
mov word [0x07*16], exception_gate_07
mov word [0x08*16], exception_gate_08
mov word [0x09*16], exception_gate_09
mov word [0x0A*16], exception_gate_10
mov word [0x0B*16], exception_gate_11
mov word [0x0C*16], exception_gate_12
mov word [0x0D*16], exception_gate_13
mov word [0x0E*16], exception_gate_14
mov word [0x0F*16], exception_gate_15
mov word [0x10*16], exception_gate_16
mov word [0x11*16], exception_gate_17
mov word [0x12*16], exception_gate_18
mov word [0x13*16], exception_gate_19
mov rdi, 0x21 ; Set up Keyboard handler
mov rax, keyboard
call create_gate
mov rdi, 0x22 ; Set up Cascade handler
mov rax, cascade
call create_gate
mov rdi, 0x28 ; Set up RTC handler
mov rax, rtc
call create_gate
lidt [IDTR64] ; load IDT register
; Debug
mov al, '4'
mov [0x000B809E], al
; Clear memory 0xf000 - 0xf7ff for the infomap (2048 bytes)
xor rax, rax
mov rcx, 256
mov rdi, 0x000000000000F000
clearmapnext:
stosq
dec rcx
cmp rcx, 0
jne clearmapnext
call init_acpi ; Find and process the ACPI tables
call init_cpu ; Configure the BSP CPU
call init_pic ; Configure the PIC(s), also activate interrupts
; Debug
mov al, '6' ; CPU Init complete
mov [0x000B809E], al
; Make sure exceptions are working.
; xor rax, rax
; xor rbx, rbx
; xor rcx, rcx
; xor rdx, rdx
; div rax
; Init of SMP
call init_smp
; Reset the stack to the proper location (was set to 0x8000 previously)
mov rsi, [os_LocalAPICAddress] ; We would call os_smp_get_id here but the stack is not ...
add rsi, 0x20 ; ... yet defined. It is safer to find the value directly.
lodsd ; Load a 32-bit value. We only want the high 8 bits
shr rax, 24 ; Shift to the right and AL now holds the CPU's APIC ID
shl rax, 10 ; shift left 10 bits for a 1024byte stack
add rax, 0x0000000000050400 ; stacks decrement when you "push", start at 1024 bytes in
mov rsp, rax ; Pure64 leaves 0x50000-0x9FFFF free so we use that
; Debug
mov al, '6' ; SMP Init complete
mov [0x000B809C], al
mov al, '0'
mov [0x000B809E], al
; Calculate amount of usable RAM from Memory Map
xor rcx, rcx
mov rsi, 0x0000000000004000 ; E820 Map location
readnextrecord:
lodsq
lodsq
lodsd
cmp eax, 0 ; Are we at the end?
je endmemcalc
cmp eax, 1 ; Useable RAM
je goodmem
cmp eax, 3 ; ACPI Reclaimable
je goodmem
cmp eax, 6 ; BIOS Reclaimable
je goodmem
lodsd
lodsq
jmp readnextrecord
goodmem:
sub rsi, 12
lodsq
add rcx, rax
lodsq
lodsq
jmp readnextrecord
endmemcalc:
shr rcx, 20 ; Value is in bytes so do a quick divide by 1048576 to get MiB's
add ecx, 1 ; The BIOS will usually report actual memory minus 1
and ecx, 0xFFFFFFFE ; Make sure it is an even number (in case we added 1 to an even number)
mov dword [mem_amount], ecx
; Debug
mov al, '2'
mov [0x000B809E], al
; Convert CPU speed value to string
xor rax, rax
mov ax, [cpu_speed]
mov rdi, speedtempstring
call os_int_to_string
; Convert CPU amount value to string
xor rax, rax
mov ax, [cpu_activated]
mov rdi, cpu_amount_string
call os_int_to_string
; Convert RAM amount value to string
xor rax, rax
mov eax, [mem_amount]
mov rdi, memtempstring
call os_int_to_string
; Build the infomap
xor rdi, rdi
mov di, 0x5000
mov rax, [os_ACPITableAddress]
stosq
mov eax, [os_BSP]
stosd
mov di, 0x5010
mov ax, [cpu_speed]
stosw
mov ax, [cpu_activated]
stosw
mov ax, [cpu_detected]
stosw
mov di, 0x5020
mov ax, [mem_amount]
stosd
mov di, 0x5030
mov al, [os_IOAPICCount]
stosb
mov di, 0x5040
mov rax, [os_HPETAddress]
stosq
mov di, 0x5060
mov rax, [os_LocalAPICAddress]
stosq
xor ecx, ecx
mov cl, [os_IOAPICCount]
mov rsi, os_IOAPICAddress
nextIOAPIC:
lodsq
stosq
sub cl, 1
cmp cl, 0
jne nextIOAPIC
mov di, 0x5080
mov eax, [VBEModeInfoBlock.PhysBasePtr] ; Base address of video memory (if graphics mode is set)
stosd
mov eax, [VBEModeInfoBlock.XResolution] ; X and Y resolution (16-bits each)
stosd
mov al, [VBEModeInfoBlock.BitsPerPixel] ; Color depth
stosb
; Initialization is now complete... write a message to the screen
mov rsi, msg_done
call os_print_string
; Debug
mov al, '4'
mov [0x000B809E], al
; Print info on CPU and MEM
mov ax, 0x0004
call os_move_cursor
mov rsi, msg_CPU
call os_print_string
mov rsi, speedtempstring
call os_print_string
mov rsi, msg_mhz
call os_print_string
mov rsi, cpu_amount_string
call os_print_string
mov rsi, msg_MEM
call os_print_string
mov rsi, memtempstring
call os_print_string
mov rsi, msg_mb
call os_print_string
; Move the trailing binary to its final location
mov rsi, 0x60000+6144 ; Memory offset to end of pure64.sys
mov rdi, 0x100000 ; Destination address at the 1MiB mark
mov rcx, 0x8000 ; For up to 256KiB kernel (262144 / 8)
rep movsq ; Copy 8 bytes at a time
; Print a message that the kernel is being started
mov ax, 0x0006
call os_move_cursor
mov rsi, msg_startingkernel
call os_print_string
; Debug
mov rdi, 0x000B8092 ; Clear the debug messages
mov ax, 0x0720
mov cx, 7
clearnext:
stosw
sub cx, 1
cmp cx, 0
jne clearnext
; Clear all registers (skip the stack pointer)
xor rax, rax
xor rbx, rbx
xor rcx, rcx
xor rdx, rdx
xor rsi, rsi
xor rdi, rdi
xor rbp, rbp
xor r8, r8
xor r9, r9
xor r10, r10
xor r11, r11
xor r12, r12
xor r13, r13
xor r14, r14
xor r15, r15
jmp 0x0000000000100000 ; Jump to the kernel
%include "init/acpi.asm"
%include "init/cpu.asm"
%include "init/pic.asm"
%include "init/smp.asm"
%include "syscalls.asm"
%include "interrupt.asm"
%include "sysvar.asm"
; Pad to an even KB file (6 KiB)
times 6144-($-$$) db 0x90
; =============================================================================
; EOF

351
Bootloader/Pure64/src/syscalls.asm Normal file
View File

@ -0,0 +1,351 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; System Calls
; =================================================================
; -----------------------------------------------------------------------------
; os_move_cursor -- Moves the virtual cursor in text mode
; IN: AH, AL = row, column
; OUT: Nothing. All registers preserved
os_move_cursor:
push rcx
push rbx
push rax
xor ebx, ebx
mov [screen_cursor_x], ah
mov [screen_cursor_y], al
mov bl, ah
; Calculate the new offset
and rax, 0x00000000000000FF ; only keep the low 8 bits
mov cl, 80
mul cl ; AX = AL * CL
add ax, bx
shl ax, 1 ; multiply by 2
add rax, 0x00000000000B8000
mov [screen_cursor_offset], rax
pop rax
pop rbx
pop rcx
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_print_newline -- Reset cursor to start of next line and scroll if needed
; IN: Nothing
; OUT: Nothing, all registers perserved
os_print_newline:
push rax
mov ah, 0 ; Set the cursor x value to 0
mov al, [screen_cursor_y] ; Grab the cursor y value
cmp al, 24 ; Compare to see if we are on the last line
je os_print_newline_scroll ; If so then we need to scroll the sreen
inc al ; If not then we can go ahead an increment the y value
jmp os_print_newline_done
os_print_newline_scroll:
mov ax, 0x0000 ; If we have reached the end then wrap back to the front
os_print_newline_done:
call os_move_cursor ; update the cursor
pop rax
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_print_string -- Displays text
; IN: RSI = message location (zero-terminated string)
; OUT: Nothing, all registers perserved
os_print_string:
push rsi
push rax
cld ; Clear the direction flag.. we want to increment through the string
os_print_string_nextchar:
lodsb ; Get char from string and store in AL
cmp al, 0 ; Strings are Zero terminated.
je os_print_string_done ; If char is Zero then it is the end of the string
cmp al, 13 ; Check if there was a newline character in the string
je os_print_string_newline ; If so then we print a new line
call os_print_char
jmp os_print_string_nextchar
os_print_string_newline:
call os_print_newline
jmp os_print_string_nextchar
os_print_string_done:
pop rax
pop rsi
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_print_char -- Displays a char
; IN: AL = char to display
; OUT: Nothing. All registers preserved
os_print_char:
push rdi
mov rdi, [screen_cursor_offset]
stosb
add qword [screen_cursor_offset], 2 ; Add 2 (1 byte for char and 1 byte for attribute)
pop rdi
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_print_char_hex -- Displays a char in hex mode
; IN: AL = char to display
; OUT: Nothing. All registers preserved
os_print_char_hex:
push rbx
push rax
mov rbx, hextable
push rax ; save rax for the next part
shr al, 4 ; we want to work on the high part so shift right by 4 bits
xlatb
call os_print_char
pop rax
and al, 0x0f ; we want to work on the low part so clear the high part
xlatb
call os_print_char
pop rax
pop rbx
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_debug_dump_(rax|eax|ax|al) -- Dump content of RAX, EAX, AX, or AL to the screen in hex format
; IN: RAX = content to dump
; OUT: Nothing, all registers preserved
os_debug_dump_rax:
ror rax, 56
call os_print_char_hex
rol rax, 8
call os_print_char_hex
rol rax, 8
call os_print_char_hex
rol rax, 8
call os_print_char_hex
rol rax, 32
os_debug_dump_eax:
ror rax, 24
call os_print_char_hex
rol rax, 8
call os_print_char_hex
rol rax, 16
os_debug_dump_ax:
ror rax, 8
call os_print_char_hex
rol rax, 8
os_debug_dump_al:
call os_print_char_hex
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_dump_regs -- Dump the values on the registers to the screen (For debug purposes)
; IN/OUT: Nothing
os_dump_regs:
push r15
push r14
push r13
push r12
push r11
push r10
push r9
push r8
push rsp
push rbp
push rdi
push rsi
push rdx
push rcx
push rbx
push rax
mov byte [os_dump_reg_stage], 0x00 ; Reset the stage to 0 since we are starting
mov rcx, rsp
call os_print_newline
os_dump_regs_again:
mov rsi, os_dump_reg_string00
xor rax, rax
xor rbx, rbx
mov al, [os_dump_reg_stage]
mov bl, 5 ; each string is 5 bytes
mul bl ; ax = bl x al
add rsi, rax
call os_print_string ; Print the register name
mov rax, [rcx]
add rcx, 8
call os_debug_dump_rax
add byte [os_dump_reg_stage], 1
cmp byte [os_dump_reg_stage], 0x10
jne os_dump_regs_again
pop rax
pop rbx
pop rcx
pop rdx
pop rsi
pop rdi
pop rbp
pop rsp
pop r8
pop r9
pop r10
pop r11
pop r12
pop r13
pop r14
pop r15
ret
os_dump_reg_string00: db ' A:', 0
os_dump_reg_string01: db ' B:', 0
os_dump_reg_string02: db ' C:', 0
os_dump_reg_string03: db ' D:', 0
os_dump_reg_string04: db ' SI:', 0
os_dump_reg_string05: db ' DI:', 0
os_dump_reg_string06: db ' BP:', 0
os_dump_reg_string07: db ' SP:', 0
os_dump_reg_string08: db ' 8:', 0
os_dump_reg_string09: db ' 9:', 0
os_dump_reg_string0A: db ' 10:', 0
os_dump_reg_string0B: db ' 11:', 0
os_dump_reg_string0C: db ' 12:', 0
os_dump_reg_string0D: db ' 13:', 0
os_dump_reg_string0E: db ' 14:', 0
os_dump_reg_string0F: db ' 15:', 0
os_dump_reg_stage: db 0x00
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_dump_mem -- Dump some memory content to the screen (For debug purposes)
; IN: RSI = memory to dump (512bytes)
;OUT:
os_dump_mem:
push rdx
push rcx
push rbx
push rax
push rsi
mov rcx, 512
dumpit:
lodsb
call os_print_char_hex
dec rcx
cmp rcx, 0
jne dumpit
pop rsi
; call os_print_newline
pop rax
pop rbx
pop rcx
pop rdx
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_int_to_string -- Convert a binary interger into an string string
; IN: RAX = binary integer
; RDI = location to store string
; OUT: RDI = pointer to end of string
; All other registers preserved
; Min return value is 0 and max return value is 18446744073709551615 so your
; string needs to be able to store at least 21 characters (20 for the number
; and 1 for the string terminator).
; Adapted from http://www.cs.usfca.edu/~cruse/cs210s09/rax2uint.s
os_int_to_string:
push rdx
push rcx
push rbx
push rax
mov rbx, 10 ; base of the decimal system
xor rcx, rcx ; number of digits generated
os_int_to_string_next_divide:
xor rdx, rdx ; RAX extended to (RDX,RAX)
div rbx ; divide by the number-base
push rdx ; save remainder on the stack
inc rcx ; and count this remainder
cmp rax, 0x0 ; was the quotient zero?
jne os_int_to_string_next_divide ; no, do another division
os_int_to_string_next_digit:
pop rdx ; else pop recent remainder
add dl, '0' ; and convert to a numeral
mov [rdi], dl ; store to memory-buffer
inc rdi
loop os_int_to_string_next_digit ; again for other remainders
mov al, 0x00
stosb ; Store the null terminator at the end of the string
pop rax
pop rbx
pop rcx
pop rdx
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; create_gate
; rax = address of handler
; rdi = gate # to configure
create_gate:
push rdi
push rax
shl rdi, 4 ; quickly multiply rdi by 16
stosw ; store the low word (15..0)
shr rax, 16
add rdi, 4 ; skip the gate marker
stosw ; store the high word (31..16)
shr rax, 16
stosd ; store the high dword (63..32)
pop rax
pop rdi
ret
; -----------------------------------------------------------------------------
; =============================================================================
; EOF

131
Bootloader/Pure64/src/sysvar.asm Normal file
View File

@ -0,0 +1,131 @@
; =============================================================================
; Pure64 -- a 64-bit OS loader written in Assembly for x86-64 systems
; Copyright (C) 2008-2014 Return Infinity -- see LICENSE.TXT
;
; System Variables
; =============================================================================
;CONFIG
cfg_smpinit: db 1 ; By default SMP is enabled. Set to 0 to disable.
cfg_vesa: db 0 ; By default VESA is disabled. Set to 1 to enable.
cfg_default: db 0 ; By default we don't need a config file so set to 0. If a config file is found set to 1.
cfg_e820: db 1 ; By default E820 should be present. Pure64 will set this to 0 if not found/usable.
cfg_mbr: db 0 ; Did we boot off of a disk with a proper MBR
cfg_hdd: db 0 ; Was a bootable drive detected
; Memory locations
E820Map: equ 0x0000000000004000
InfoMap: equ 0x0000000000005000
SystemVariables: equ 0x0000000000005A00
VBEModeInfoBlock: equ 0x0000000000005C00 ; 256 bytes
ahci_cmdlist: equ 0x0000000000070000 ; 4096 bytes 0x070000 -> 0x071FFF
ahci_cmdtable: equ 0x0000000000072000 ; 57344 bytes 0x072000 -> 0x07FFFF
; DQ - Starting at offset 0, increments by 0x8
os_ACPITableAddress: equ SystemVariables + 0x00
screen_cursor_offset: equ SystemVariables + 0x08
os_LocalX2APICAddress: equ SystemVariables + 0x10
os_Counter_Timer: equ SystemVariables + 0x18
os_Counter_RTC: equ SystemVariables + 0x20
os_LocalAPICAddress: equ SystemVariables + 0x28
os_IOAPICAddress: equ SystemVariables + 0x30
os_HPETAddress: equ SystemVariables + 0x38
; DD - Starting at offset 128, increments by 4
os_BSP: equ SystemVariables + 128
mem_amount: equ SystemVariables + 132
os_VideoBase: equ SystemVariables + 136
; DW - Starting at offset 256, increments by 2
cpu_speed: equ SystemVariables + 256
cpu_activated: equ SystemVariables + 258
cpu_detected: equ SystemVariables + 260
; DB - Starting at offset 384, increments by 1
screen_cursor_x: equ SystemVariables + 386
screen_cursor_y: equ SystemVariables + 387
memtempstring: equ SystemVariables + 390
speedtempstring: equ SystemVariables + 400
cpu_amount_string: equ SystemVariables + 410
os_key: equ SystemVariables + 421
os_IOAPICCount: equ SystemVariables + 424
;MISC
screen_cols: db 80
screen_rows: db 25
hextable: db '0123456789ABCDEF'
;STRINGS
msg_initializing: db 'Pure64 v0.6.1 - www.returninfinity.com', 13, 10, 13, 10, 'Initializing system... ', 0
msg_done: db ' Done', 0
msg_CPU: db '[CPU: ', 0
msg_mhz: db 'MHz x', 0
msg_MEM: db '] [MEM: ', 0
msg_mb: db ' MiB]', 0
msg_startingkernel: db 'Starting kernel...', 13, 13, 0
msg_no64: db 'ERROR: This computer does not support 64-bit mode.', 0
msg_novesa: db 'VESA error', 0
; VESA
; Mandatory information for all VBE revisions
VBEModeInfoBlock.ModeAttributes equ VBEModeInfoBlock + 0 ; DW - mode attributes
VBEModeInfoBlock.WinAAttributes equ VBEModeInfoBlock + 2 ; DB - window A attributes
VBEModeInfoBlock.WinBAttributes equ VBEModeInfoBlock + 3 ; DB - window B attributes
VBEModeInfoBlock.WinGranularity equ VBEModeInfoBlock + 4 ; DW - window granularity in KB
VBEModeInfoBlock.WinSize equ VBEModeInfoBlock + 6 ; DW - window size in KB
VBEModeInfoBlock.WinASegment equ VBEModeInfoBlock + 8 ; DW - window A start segment
VBEModeInfoBlock.WinBSegment equ VBEModeInfoBlock + 10 ; DW - window B start segment
VBEModeInfoBlock.WinFuncPtr equ VBEModeInfoBlock + 12 ; DD - real mode pointer to window function
VBEModeInfoBlock.BytesPerScanLine equ VBEModeInfoBlock + 16 ; DW - bytes per scan line
; Mandatory information for VBE 1.2 and above
VBEModeInfoBlock.XResolution equ VBEModeInfoBlock + 18 ; DW - horizontal resolution in pixels or characters
VBEModeInfoBlock.YResolution equ VBEModeInfoBlock + 20 ; DW - vertical resolution in pixels or characters
VBEModeInfoBlock.XCharSize equ VBEModeInfoBlock + 22 ; DB - character cell width in pixels
VBEModeInfoBlock.YCharSize equ VBEModeInfoBlock + 23 ; DB - character cell height in pixels
VBEModeInfoBlock.NumberOfPlanes equ VBEModeInfoBlock + 24 ; DB - number of memory planes
VBEModeInfoBlock.BitsPerPixel equ VBEModeInfoBlock + 25 ; DB - bits per pixel
VBEModeInfoBlock.NumberOfBanks equ VBEModeInfoBlock + 26 ; DB - number of banks
VBEModeInfoBlock.MemoryModel equ VBEModeInfoBlock + 27 ; DB - memory model type
VBEModeInfoBlock.BankSize equ VBEModeInfoBlock + 28 ; DB - bank size in KB
VBEModeInfoBlock.NumberOfImagePages equ VBEModeInfoBlock + 29 ; DB - number of image pages
VBEModeInfoBlock.Reserved equ VBEModeInfoBlock + 30 ; DB - reserved (0x00 for VBE 1.0-2.0, 0x01 for VBE 3.0)
; Direct Color fields (required for direct/6 and YUV/7 memory models)
VBEModeInfoBlock.RedMaskSize equ VBEModeInfoBlock + 31 ; DB - size of direct color red mask in bits
VBEModeInfoBlock.RedFieldPosition equ VBEModeInfoBlock + 32 ; DB - bit position of lsb of red mask
VBEModeInfoBlock.GreenMaskSize equ VBEModeInfoBlock + 33 ; DB - size of direct color green mask in bits
VBEModeInfoBlock.GreenFieldPosition equ VBEModeInfoBlock + 34 ; DB - bit position of lsb of green mask
VBEModeInfoBlock.BlueMaskSize equ VBEModeInfoBlock + 35 ; DB - size of direct color blue mask in bits
VBEModeInfoBlock.BlueFieldPosition equ VBEModeInfoBlock + 36 ; DB - bit position of lsb of blue mask
VBEModeInfoBlock.RsvdMaskSize equ VBEModeInfoBlock + 37 ; DB - size of direct color reserved mask in bits
VBEModeInfoBlock.RsvdFieldPosition equ VBEModeInfoBlock + 38 ; DB - bit position of lsb of reserved mask
VBEModeInfoBlock.DirectColorModeInfo equ VBEModeInfoBlock + 39 ; DB - direct color mode attributes
; Mandatory information for VBE 2.0 and above
VBEModeInfoBlock.PhysBasePtr equ VBEModeInfoBlock + 40 ; DD - physical address for flat memory frame buffer
VBEModeInfoBlock.Reserved1 equ VBEModeInfoBlock + 44 ; DD - Reserved - always set to 0
VBEModeInfoBlock.Reserved2 equ VBEModeInfoBlock + 48 ; DD - Reserved - always set to 0
; -----------------------------------------------------------------------------
align 16
GDTR64: ; Global Descriptors Table Register
dw gdt64_end - gdt64 - 1 ; limit of GDT (size minus one)
dq 0x0000000000001000 ; linear address of GDT
gdt64: ; This structure is copied to 0x0000000000001000
SYS64_NULL_SEL equ $-gdt64 ; Null Segment
dq 0x0000000000000000
SYS64_CODE_SEL equ $-gdt64 ; Code segment, read/execute, nonconforming
dq 0x0020980000000000 ; 0x00209A0000000000
SYS64_DATA_SEL equ $-gdt64 ; Data segment, read/write, expand down
dq 0x0000900000000000 ; 0x0020920000000000
gdt64_end:
IDTR64: ; Interrupt Descriptor Table Register
dw 256*16-1 ; limit of IDT (size minus one) (4096 bytes - 1)
dq 0x0000000000000000 ; linear address of IDT
; -----------------------------------------------------------------------------
; =============================================================================
; EOF

36
Image/Makefile Normal file
View File

@ -0,0 +1,36 @@
BOOTLOADER_PATH=../Bootloader
BMFS=$(BOOTLOADER_PATH)/BMFS/bmfs.bin
MBR=$(BOOTLOADER_PATH)/Pure64/bmfs_mbr.sys
MP=../Toolchain/ModulePacker/mp.bin
PURE64=$(BOOTLOADER_PATH)/Pure64/pure64.sys
OSIMAGENAME=x64BareBonesImage
VMDK=$(OSIMAGENAME).vmdk
QCOW2=$(OSIMAGENAME).qcow2
IMG=$(OSIMAGENAME).img
KERNEL=../Kernel/kernel.bin
USERLAND=../Userland/0000-sampleCodeModule.bin ../Userland/0001-sampleDataModule.bin
PACKEDKERNEL=packedKernel.bin
IMGSIZE=6291456
all: $(IMG) $(VMDK) $(QCOW2)
$(KERNEL):
cd ../Kernel; make
$(PACKEDKERNEL): $(KERNEL) $(USERLAND)
$(MP) $(KERNEL) $(USERLAND) -o $(PACKEDKERNEL)
$(IMG): $(BMFS) $(MBR) $(PURE64) $(PACKEDKERNEL)
$(BMFS) $(IMG) initialize $(IMGSIZE) $(MBR) $(PURE64) $(PACKEDKERNEL)
$(VMDK): $(IMG)
qemu-img convert -f raw -O vmdk $(IMG) $(VMDK)
$(QCOW2): $(IMG)
qemu-img convert -f raw -O qcow2 $(IMG) $(QCOW2)
clean:
rm -rf $(IMG) $(VMDK) $(QCOW2) *.bin
.PHONY: all clean

42
Kernel/Makefile Normal file
View File

@ -0,0 +1,42 @@
include Makefile.inc
KERNEL=kernel.bin
KERNEL_ELF=kernel.elf
SOURCES=$(wildcard *.c)
SOURCES_INTERRUPTIONS=$(wildcard interruptions/*.c)
SOURCES_DRIVERS=$(wildcard drivers/*.c)
SOURCES_INTERRUPTIONS_ASM=$(wildcard interruptions/*.asm)
SOURCES_ASM=$(wildcard asm/*.asm)
OBJECTS=$(SOURCES:.c=.o)
OBJECTS_DRIVERS=$(SOURCES_DRIVERS:.c=.o)
OBJECTS_INTERRUPTIONS=$(SOURCES_INTERRUPTIONS:.c=.o)
OBJECTS_INTERRUPTIONS_ASM=$(SOURCES_INTERRUPTIONS_ASM:.asm=.o)
OBJECTS_ASM=$(SOURCES_ASM:.asm=.o)
LOADERSRC=loader.asm
LOADEROBJECT=$(LOADERSRC:.asm=.o)
STATICLIBS=
ALL_OBJECTS= $(LOADEROBJECT) $(OBJECTS) $(OBJECTS_ASM) $(OBJECTS_INTERRUPTIONS) $(OBJECTS_INTERRUPTIONS_ASM) $(OBJECTS_DRIVERS)
all: $(KERNEL) $(KERNEL_ELF)
$(KERNEL): $(STATICLIBS) $(ALL_OBJECTS)
$(LD) $(LDFLAGS) -T kernel.ld -o $@ $^
$(KERNEL_ELF): $(STATICLIBS) $(ALL_OBJECTS)
$(LD) $(LDFLAGS) -T kernel.ld --oformat=elf64-x86-64 -o $@ $^
%.o: %.c
$(GCC) $(GCCFLAGS) -I./include -I./drivers -I./interruptions -c $< -o $@
%.o : %.asm
$(ASM) $(ASMFLAGS) $< -o $@
$(LOADEROBJECT):
$(ASM) $(ASMFLAGS) $(LOADERSRC) -o $(LOADEROBJECT)
clean:
rm -rf $(ALL_OBJECTS) *.bin
.PHONY: all clean

9
Kernel/Makefile.inc Normal file
View File

@ -0,0 +1,9 @@
GCC=gcc
LD=ld
AR=ar
ASM=nasm
GCCFLAGS=-m64 -fno-exceptions -fno-asynchronous-unwind-tables -mno-mmx -fno-builtin-malloc -fno-builtin-free -fno-builtin-realloc -mno-red-zone -Wall -ffreestanding -nostdlib -fno-common -std=c99 -g
ARFLAGS=rvs
ASMFLAGS=-felf64
LDFLAGS=--warn-common -z max-page-size=0x1000

263
Kernel/asm/interrupts.asm Executable file
View File

@ -0,0 +1,263 @@
GLOBAL _cli
GLOBAL _sti
GLOBAL picMasterMask
GLOBAL picSlaveMask
GLOBAL haltcpu
GLOBAL _hlt
GLOBAL _irq00Handler
GLOBAL _irq01Handler
GLOBAL _irq02Handler
GLOBAL _irq03Handler
GLOBAL _irq04Handler
GLOBAL _irq05Handler
GLOBAL _systemCallsHandler
GLOBAL _exception0Handler
GLOBAL _exception6Handler
EXTERN irqDispatcher
EXTERN exceptionDispatcher
EXTERN systemCallsDispatcher
EXTERN preserveStack
EXTERN newStack
EXTERN changeWindow
GLOBAL switchContext
GLOBAL loadProcess
GLOBAL _initialize_stack_frame
GLOBAL _switchContext
SECTION .text
%macro pushState 0
push rax
push rbx
push rcx
push rdx
push rbp
push rdi
push rsi
push r8
push r9
push r10
push r11
push r12
push r13
push r14
push r15
%endmacro
%macro popState 0
pop r15
pop r14
pop r13
pop r12
pop r11
pop r10
pop r9
pop r8
pop rsi
pop rdi
pop rbp
pop rdx
pop rcx
pop rbx
pop rax
%endmacro
%macro irqHandlerMaster 1
pushState
fsave [bytesForFPU]
fxsave [bytesForSSEAligned]
mov rdi, %1 ; pasaje de parametro
call irqDispatcher
; signal pic EOI (End of Interrupt)
mov al, 20h
out 20h, al
fxrstor [bytesForSSEAligned]
frstor [bytesForFPU]
popState
iretq
%endmacro
%macro exceptionHandler 1
mov [insPointer], rsp
push rax
lea rax, [rsp + 4 * 8]
mov [rspPointer], rax
pop rax
pushState
mov rdi, %1 ; pasaje de parametro
mov rsi, [insPointer]
mov rdx, [rspPointer]
mov rcx, rsp
call exceptionDispatcher
popState
iretq
%endmacro
_hlt:
sti
hlt
ret
_cli:
cli
ret
_sti:
sti
ret
picMasterMask:
push rbp
mov rbp, rsp
mov ax, di
out 21h,al
pop rbp
retn
picSlaveMask:
push rbp
mov rbp, rsp
mov ax, di ; ax = mascara de 16 bits
out 0A1h,al
pop rbp
retn
;8254 Timer (Timer Tick)
_irq00Handler:
irqHandlerMaster 0
;Keyboard
_irq01Handler:
irqHandlerMaster 1
;Cascade pic never called
_irq02Handler:
irqHandlerMaster 2
;Serial Port 2 and 4
_irq03Handler:
irqHandlerMaster 3
;Serial Port 1 and 3
_irq04Handler:
irqHandlerMaster 4
;USB
_irq05Handler:
irqHandlerMaster 5
;Zero Division Exception
_exception0Handler:
exceptionHandler 0
;Invalid OPCODE Exc
_exception6Handler:
exceptionHandler 6
haltcpu:
sti
hlt
cli
ret
%macro pushStateNoRax 0
push rbx
push rcx
push rdx
push rbp
push rdi
push rsi
push r8
push r9
push r10
push r11
push r12
push r13
push r14
push r15
%endmacro
%macro popStateNoRax 0
pop r15
pop r14
pop r13
pop r12
pop r11
pop r10
pop r9
pop r8
pop rsi
pop rdi
pop rbp
pop rdx
pop rcx
pop rbx
%endmacro
_initialize_stack_frame:
mov rcx, rsp
mov rsp, rsi
push 0x0 ; ss
push rsi ; sp
push 0x202 ; rflags
; 0x200 IF FLAG
; 0x002 always one
push 0x08 ; cs -- offset de la GDT
push rdi ; IP
pushState
mov rdi, rsp
call newStack
mov rax, rsp
mov rsp, rcx
ret
; System calls (int 80h)
_systemCallsHandler:
pushStateNoRax
fsave [bytesForFPU]
fxsave [bytesForSSEAligned]
call systemCallsDispatcher
fxrstor [bytesForSSEAligned]
frstor [bytesForFPU]
popStateNoRax
iretq
; switch Context (int 81h)
_switchContext:
pushState
call changeWindow
mov rdi, rsp
call preserveStack
mov rsp, rax
popState
iretq
SECTION .data
align 16
bytesForSSEAligned times 512 db 0
SECTION .bss
aux resq 1
bytesForSSE resb 512
bytesForFPU resb 108
insPointer resb 8
rspPointer resb 8

82
Kernel/asm/libasm.asm Normal file
View File

@ -0,0 +1,82 @@
GLOBAL getCharInterrupt, getTimeGen, getMemGen, getRegs, getRSP
section .text
getCharInterrupt:
push rbp
mov rbp, rsp
in al, 60h
mov rsp, rbp
pop rbp
ret
getTimeGen:
push rbp
mov rbp, rsp
xor rax, rax
mov rax, rdi
out 70h, al
in al, 71h
call bcdToDecimal
mov rsp, rbp
pop rbp
ret
bcdToDecimal:
push rbx
mov rbx, 0
mov bl, al
shr al, 4
mov bh, 10
mul bh
and bl, 0fh
add al, bl
pop rbx
ret
getMemGen:
push rbp
mov rbp, rsp
mov eax, dword [rdi]
mov rsp, rbp
pop rbp
ret
getRSP:
mov rax, rsp
ret
getRegs:
push rbp
mov rbp, rsp
mov [regs], rax
mov [regs + 8], rbx
mov [regs + 16], rcx
mov [regs + 24], rdx
mov [regs + 32], rsp
mov [regs + 40], rdi
mov [regs + 48], rsi
mov [regs + 56], r8
mov [regs + 64], r9
mov [regs + 72], r10
mov [regs + 80], r11
mov [regs + 88], r12
mov [regs + 96], r13
mov [regs + 104], r14
mov [regs + 112], r15
mov rax, regs
mov rsp, rbp
pop rbp
ret
section .bss
regs resb 120 ; 8 bytes * 16 regs

243
Kernel/drivers/keyboard.c Normal file
View File

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

95
Kernel/drivers/naiveConsole.c Normal file
View File

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

37
Kernel/drivers/time.c Executable file
View File

@ -0,0 +1,37 @@
#include <time.h>
static unsigned long ticks = 0;
void timer_handler() {
ticks++;
}
int ticks_elapsed() {
return ticks;
}
int seconds_elapsed() {
return ticks / 18;
}
int getTime(char option) {
switch(option) {
case SECONDS:
return getTimeGen(SECONDS);
case MINUTES:
return getTimeGen(MINUTES);
case HOURS:
return getTimeGen(HOURS);
case DAY:
return getTimeGen(DAY);
case MONTH:
return getTimeGen(MONTH);
case YEAR:
return getTimeGen(YEAR);
default: return -1;
}
}
void wait(long seconds) {
while (seconds_elapsed() < seconds);
}

138
Kernel/drivers/video.c Normal file
View File

@ -0,0 +1,138 @@
#include <stdint.h>
#include "video.h"
static uint8_t * const video = (uint8_t*)0xB8000;
static uint8_t * currentVideo = (uint8_t*)0xB8000;
static const int width = 80;
static const int height = 25;
static int currentX = 0;
static int currentY = 0;
int limitX[2] = {0, 80};
int limitY[2] = {0, 25};
char windowVideo = 1;
void changeWindow() {
windowVideo = 1 - windowVideo;
moveToWindowVideo(windowVideo);
}
void moveToWindowVideo(char window) {
if (window == -1) {
windowVideo = -1;
limitX[0] = 0;
limitX[1] = 80;
limitY[0] = 0;
limitY[1] = 25;
}
if (window == 1) {
windowVideo = 1;
limitX[0] = 40;
limitX[1] = 80;
limitY[0] = 0;
limitY[1] = 25;
}
if (window == 0) {
windowVideo = 0;
limitX[0] = 0;
limitX[1] = 40;
limitY[0] = 0;
limitY[1] = 25;
}
currentX = limitX[0];
currentY = limitY[0];
}
void increment() {
currentX++;
if (currentX >= limitX[1]) {
currentY++;
currentX = limitX[0];
if (currentY >= limitY[1])
currentY = limitY[0];
}
}
int atoi(char * string, int length) {
int res = 0, i = 0;
while (i < length) {
res = res * 10 + string[i++] - '0';
}
return res;
}
// "\e\f" para clear
char checkIfEscapeSequence(const char * bufferAux) {
if (*bufferAux == '\e') {
bufferAux++;
if (*bufferAux == '\f') {
bufferAux++;
clear();
}
return 1;
}
return 0;
}
int printStringLen(int color, const char * string, int maxLen) {
int i = 0;
while (*string != '\0' && i <= maxLen) {
if (currentX >= limitX[1]) {
currentX = limitX[0];
currentY++;
}
if (currentY >= limitY[1]) {
currentY = limitY[0];
}
if (*string == '\n') {
new_line();
return i;
}
else if (*string == '\b') {
backspace();
return i;
}
else if (checkIfEscapeSequence(string)) {
return i;
}
*(video + currentY * width * 2 + currentX * 2) = *string++;
*(video + currentY * width * 2 + currentX * 2 + 1) = color;
increment();
i++;
}
return i;
}
void backspace() {
if (currentVideo > video) {
currentVideo -= 2;
*currentVideo = ' ';
currentX--;
if (currentX < limitX[0]) {
currentX = limitX[1];
if (currentY > limitY[0])
currentY--;
}
}
}
void new_line() {
currentX = limitX[0];
currentY++;
if (currentY == limitY[1])
currentY = limitY[0];
}
void clear() {
for (int i = limitX[0]; i < (limitX[1] - limitX[0]) * 2 * (limitY[1] - limitY[0]); i++) {
printStringLen(15, " ", 1);
}
currentX = limitX[0];
currentY = limitY[0];
}

25
Kernel/include/defs.h Executable file
View File

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

6
Kernel/include/idtLoader.h Normal file
View File

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

30
Kernel/include/interrupts.h Executable file
View File

@ -0,0 +1,30 @@
#ifndef INTERRUPS_H_
#define INTERRUPS_H_
#include <idtLoader.h>
void _irq00Handler(void);
void _irq01Handler(void);
void _irq02Handler(void);
void _irq03Handler(void);
void _irq04Handler(void);
void _irq05Handler(void);
void _systemCallsHandler(void);
void _switchContext(void);
void _exception0Handler(void);
void _exception6Handler(void);
void _cli(void);
void _sti(void);
void _hlt(void);
void picMasterMask(uint8_t mask);
void picSlaveMask(uint8_t mask);
void haltcpu(void);
#endif /* INTERRUPS_H_ */

15
Kernel/include/keyboard.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef KEYBOARD_H
#define KEYBOARD_H
#include <stdint.h>
// static unsigned char kbdsp[250];
// static unsigned char kbdus[250];
// static unsigned char kbdsp_sh[250];
// static unsigned char kbdus_sh[250];
void keyboard_handler();
unsigned char getKeyFromBuffer();
unsigned char getCharInterrupt();
#endif

14
Kernel/include/lib.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef LIB_H
#define LIB_H
#include <stdint.h>
void * memset(void * destination, int32_t character, uint64_t length);
void * memcpy(void * destination, const void * source, uint64_t length);
void swap(char * x, char * y);
char * reverse(char * buffer, int i, int j);
int abs(int value);
char * itoa(int value, char * buffer, int base, int length);
#endif

6
Kernel/include/moduleLoader.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef MODULELOADER_H
#define MODULELOADER_H
void loadModules(void * payloadStart, void ** moduleTargetAddress);
#endif

15
Kernel/include/naiveConsole.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef NAIVE_CONSOLE_H
#define NAIVE_CONSOLE_H
#include <stdint.h>
void ncPrint(const char * string);
void ncPrintChar(char character);
void ncNewline();
void ncPrintDec(uint64_t value);
void ncPrintHex(uint64_t value);
void ncPrintBin(uint64_t value);
void ncPrintBase(uint64_t value, uint32_t base);
void ncClear();
#endif

20
Kernel/include/pcb.h Normal file
View File

@ -0,0 +1,20 @@
#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

11
Kernel/include/systemCalls.h Normal file
View File

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

19
Kernel/include/time.h Executable file
View File

@ -0,0 +1,19 @@
#ifndef _TIME_H_
#define _TIME_H_
void timer_handler();
int ticks_elapsed();
int seconds_elapsed();
#define SECONDS 0
#define MINUTES 2
#define HOURS 4
#define DAY 7
#define MONTH 8
#define YEAR 9
int getTimeGen(char option);
int getTime(char option);
void wait(long seconds);
#endif

14
Kernel/include/video.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef VIDEO_H
#define VIDEO_H
#include <stdint.h>
void moveToWindowVideo(char window);
int printStringLen(int color, const char * string, int maxLen);
void new_line();
void backspace();
void clear();
void increment();
void changeWindow();
#endif

105
Kernel/interruptions/exceptions.c Executable file
View File

@ -0,0 +1,105 @@
#include "lib.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;
typedef int (* fn)();
#define ZERO_EXCEPTION_ID 0
#define INVALID_OPCODE_ID 6
static void zero_division();
static void invalid_opcode();
static uint64_t ripValue;
static uint64_t rspValue;
static uint64_t * stackFrame;
void exceptionDispatcher(int exception, uint64_t rip, uint64_t rsp, uint64_t * rspStackFrame) {
ripValue = rip;
rspValue = rsp;
stackFrame = rspStackFrame;
switch (exception) {
case ZERO_EXCEPTION_ID:
zero_division();
break;
case INVALID_OPCODE_ID:
invalid_opcode();
break;
default:
return;
}
}
static char * regsNames[] = {
"RAX: ", "RBX: ", "RCX: ", "RDX: ", "RBP: ", "RDI: ", "RSI: ",
"R8: ", "R9: ", "R10: ", "R11: ", "R12: ", "R13: ", "R14: ", "R15: "};
void printRegs() {
uint64_t * regs = stackFrame;
// 8 bytes = 64 bits = 2^64
// máximo: 18.446.744.073.709.551.616 / 2
// máximo: 9.223.372.036.854.775.808 entonces de 0 a 18
// dejo el primero para un -
char buffer[20];
for (int i = 0; i < 15; i++) {
if (i % 5 == 0)
new_line();
printStringLen(15, regsNames[i], 6);
printStringLen(15, "0x", 3);
printStringLen(15, itoa(regs[14 - i], buffer, 16, 20), 20);
printStringLen(15, " - ", 4);
}
new_line();
uint64_t * ripValueA = (uint64_t *) ripValue;
uint64_t * rspValueA = (uint64_t *) rspValue;
printStringLen(15, "RIP: ", 6);
printStringLen(15, itoa(*ripValueA, buffer, 16, 20), 20);
new_line();
printStringLen(15, "OLD RSP: ", 10);
printStringLen(15, itoa(*rspValueA, buffer, 16, 20), 20);
new_line();
*ripValueA = (uint64_t) sampleCodeAddress;
*rspValueA = (uint64_t) getSampleRSP();
}
static void startOver() {
unsigned char key = 0;
while (key != '\n') {
_sti();
haltcpu();
key = getKeyFromBuffer();
}
clear();
cleanProcesses();
moveToWindowVideo(1);
//((fn)sampleCodeAddress)();
}
static void genericException(char * string, int len) {
moveToWindowVideo(-1);
clear();
printStringLen(15, string, len);
printRegs();
startOver();
}
static void zero_division() {
genericException("Exception 0: Zero division. Press enter to reboot", 50);
}
static void invalid_opcode() {
genericException("Exception 1: Invalid opcode. Press enter to reboot", 51);
}

47
Kernel/interruptions/idtLoader.c Executable file
View File

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

26
Kernel/interruptions/irqDispatcher.c Executable file
View File

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

42
Kernel/interruptions/systemCalls.c Normal file
View File

@ -0,0 +1,42 @@
#include <stdint.h>
#include "video.h"
#include "keyboard.h"
#include "time.h"
#include "pcb.h"
#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) {
char * bufferAux = (char *) buffer;
int color;
if (fd == STDOUT)
color = STDOUT_COLOR;
else if (fd == STDERR)
color = STDERR_COLOR;
return printStringLen(color, bufferAux, (int) length);
}
uint64_t read(uint64_t fd, uint64_t buffer, uint64_t length) {
char * bufferAux = (char *) buffer;
int readBytes = 0;
while (length-- > 0) {
*bufferAux = getKeyFromBuffer();
if (*bufferAux == 0)
break;
readBytes++;
bufferAux++;
}
return readBytes;
}
void createProcess(void (*fn)) {
newProcess(fn);
}

19
Kernel/interruptions/systemCallsDispatcher.c Normal file
View File

@ -0,0 +1,19 @@
#include <stdint.h>
#include "systemCalls.h"
uint64_t systemCallsDispatcher(uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_t rcx) {
switch (rdi) {
case 0:
return write(rsi, rdx, rcx);
case 1:
return read(rsi, rdx, rcx);
case 2:
return getTime(rsi, rdx, rcx);
case 3:
createProcess(rsi);
break;
default:
return -1;
}
return 1;
}

98
Kernel/kernel.c Normal file
View File

@ -0,0 +1,98 @@
#include <stdint.h>
#include <string.h>
#include <lib.h>
#include <moduleLoader.h>
#include <naiveConsole.h>
#include "video.h"
#include "keyboard.h"
#include "time.h"
#include "pcb.h"
extern uint8_t text;
extern uint8_t rodata;
extern uint8_t data;
extern uint8_t bss;
extern uint8_t endOfKernelBinary;
extern uint8_t endOfKernel;
static const uint64_t PageSize = 0x1000;
static void * const sampleCodeModuleAddress = (void*)0x400000;
static void * const sampleDataModuleAddress = (void*)0x500000;
typedef int (*EntryPoint)();
void clearBSS(void * bssAddress, uint64_t bssSize) {
memset(bssAddress, 0, bssSize);
}
void * getStackBase() {
return (void*)(
(uint64_t)&endOfKernel
+ PageSize * 8 //The size of the stack itself, 32KiB
- sizeof(uint64_t) //Begin at the top of the stack
);
}
void * initializeKernelBinary() {
void * moduleAddresses[] = {
sampleCodeModuleAddress,
sampleDataModuleAddress
};
loadModules(&endOfKernelBinary, moduleAddresses);
clearBSS(&bss, &endOfKernel - &bss);
return getStackBase();
}
void load_idt();
uint64_t getRSP();
int main() {
load_idt();
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();
saveSampleRSP(getRSP());
((EntryPoint)sampleCodeModuleAddress)();
return 0;
}

27
Kernel/kernel.ld Normal file
View File

@ -0,0 +1,27 @@
OUTPUT_FORMAT("binary")
ENTRY(loader)
SECTIONS
{
.text 0x100000 :
{
text = .;
*(.text*)
. = ALIGN(0x1000);
rodata = .;
*(.rodata*)
}
.data ALIGN(0x1000) : AT(ADDR(.data))
{
data = .;
*(.data*)
endOfKernelBinary = .;
}
.bss ALIGN(0x1000) : AT(ADDR(.bss))
{
bss = .;
*(.bss*)
*(EXCLUDE_FILE (*.o) COMMON)
}
. = ALIGN(0x1000);
endOfKernel = .;
}

100
Kernel/lib.c Normal file
View File

@ -0,0 +1,100 @@
#include <stdint.h>
void * memset(void * destination, int32_t c, uint64_t length)
{
uint8_t chr = (uint8_t)c;
char * dst = (char*)destination;
while(length--)
dst[length] = chr;
return destination;
}
void * memcpy(void * destination, const void * source, uint64_t length)
{
/*
* memcpy does not support overlapping buffers, so always do it
* forwards. (Don't change this without adjusting memmove.)
*
* For speedy copying, optimize the common case where both pointers
* and the length are word-aligned, and copy word-at-a-time instead
* of byte-at-a-time. Otherwise, copy by bytes.
*
* The alignment logic below should be portable. We rely on
* the compiler to be reasonably intelligent about optimizing
* the divides and modulos out. Fortunately, it is.
*/
uint64_t i;
if ((uint64_t)destination % sizeof(uint32_t) == 0 &&
(uint64_t)source % sizeof(uint32_t) == 0 &&
length % sizeof(uint32_t) == 0)
{
uint32_t *d = (uint32_t *) destination;
const uint32_t *s = (const uint32_t *)source;
for (i = 0; i < length / sizeof(uint32_t); i++)
d[i] = s[i];
}
else
{
uint8_t * d = (uint8_t*)destination;
const uint8_t * s = (const uint8_t*)source;
for (i = 0; i < length; i++)
d[i] = s[i];
}
return destination;
}
void swap(char *x, char *y) {
char t = *x;
*x = *y;
*y = t;
}
char * reverse(char * buffer, int i, int j) {
while (i < j) {
swap(&buffer[i++], &buffer[j--]);
}
return buffer;
}
int abs(int value) {
return value < 0 ? -value : value;
}
char * itoa(int value, char * buffer, int base, int length) {
if (base < 2 || base > 32) {
return buffer;
}
int n = abs(value);
int i = 0;
while (n && i < length) {
int r = n % base;
if (r >= 10) {
buffer[i++] = 65 + (r - 10);
}
else {
buffer[i++] = 48 + r;
}
n = n / base;
}
if (i == 0) {
buffer[i++] = '0';
}
if (value < 0 && base == 10) {
buffer[i++] = '-';
}
buffer[i] = '\0';
return reverse(buffer, 0, i - 1);
}

12
Kernel/loader.asm Normal file
View File

@ -0,0 +1,12 @@
global loader
extern main
extern initializeKernelBinary
loader:
call initializeKernelBinary ; Set up the kernel binary, and get thet stack address
mov rsp, rax ; Set up the stack with the returned address
call main
hang:
cli
hlt ; halt machine should kernel return
jmp hang

26
Kernel/moduleLoader.c Normal file
View File

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

41
Kernel/pcb.c Normal file
View File

@ -0,0 +1,41 @@
#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 processes[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) {
processes[activeProcesses++] = rsp;
}
uint64_t preserveStack(uint64_t rsp) {
if (currentProcess != -1) {
processes[currentProcess] = rsp;
}
if (++currentProcess >= activeProcesses) currentProcess = 0;
if (activeProcesses == 0) return 0;
return processes[currentProcess];
}
static uint64_t sampleRSP;
void saveSampleRSP(uint64_t rsp) {
sampleRSP = rsp;
}
uint64_t getSampleRSP() {
return sampleRSP;
}

6
License.txt Normal file
View File

@ -0,0 +1,6 @@
Copyright (c) 2015, Rodrigo Rearden All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

22
Makefile Normal file
View File

@ -0,0 +1,22 @@
all: bootloader kernel userland image
bootloader:
cd Bootloader; make all
kernel:
cd Kernel; make all
userland:
cd Userland; make all
image: kernel bootloader userland
cd Image; make all
clean:
cd Bootloader; make clean
cd Image; make clean
cd Kernel; make clean
cd Userland; make clean
.PHONY: bootloader image collections kernel userland all clean

31
Readme.txt Normal file
View File

@ -0,0 +1,31 @@
x64BareBones is a basic setup to develop operating systems for the Intel 64 bits architecture.
The final goal of the project is to provide an entry point for a kernel and the possibility to load extra binary modules separated from the main kernel.
Environment setup:
1- Install the following packages before building the Toolchain and Kernel:
nasm qemu gcc make
2- Build the Toolchain
Execute the following commands on the x64BareBones project directory:
user@linux:$ cd Toolchain
user@linux:$ make all
3- Build the Kernel
From the x64BareBones project directory run:
user@linux:$ make all
4- Run the kernel
From the x64BareBones project directory run:
user@linux:$ ./run.sh
Author: Rodrigo Rearden (RowDaBoat)
Collaborator: Augusto Nizzo McIntosh

9
Toolchain/Makefile Normal file
View File

@ -0,0 +1,9 @@
all: modulePacker
modulePacker:
cd ModulePacker; make all
clean:
cd ModulePacker; make clean
.PHONY: modulePacker all clean

12
Toolchain/ModulePacker/Makefile Normal file
View File

@ -0,0 +1,12 @@
MP=mp.bin
SOURCES=$(wildcard *.c)
all: $(MP)
$(MP): $(SOURCES)
gcc $(SOURCES) -o $(MP)
clean:
rm -rf $(MP)
.PHONY: all clean

152
Toolchain/ModulePacker/main.c Normal file
View File

@ -0,0 +1,152 @@
#include <stdio.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <argp.h>
#include "modulePacker.h"
//Parser elements
const char *argp_program_version =
"x64BareBones ModulePacker (C) v0.2";
const char *argp_program_bug_address =
"arq-catedra@googlegroups.com";
/* Program documentation. */
static char doc[] =
"ModulePacker is an appender of binary files to be loaded all together";
/* A description of the arguments we accept. */
static char args_doc[] = "KernelFile Module1 Module2 ...";
/* The options we understand. */
static struct argp_option options[] = {
{"output", 'o', "FILE", 0,
"Output to FILE instead of standard output" },
{ 0 }
};
/* Our argp parser. */
static struct argp argp = { options, parse_opt, args_doc, doc };
int main(int argc, char *argv[]) {
struct arguments arguments;
arguments.output_file = OUTPUT_FILE;
arguments.count = 0;
argp_parse (&argp, argc, argv, 0, 0, &arguments);
array_t fileArray = {arguments.args, arguments.count};
if(!checkFiles(fileArray)) {
return 1;
}
return !buildImage(fileArray, arguments.output_file);
}
int buildImage(array_t fileArray, char *output_file) {
FILE *target;
if((target = fopen(output_file, "w")) == NULL) {
printf("Can't create target file\n");
return FALSE;
}
//First, write the kernel
FILE *source = fopen(fileArray.array[0], "r");
write_file(target, source);
//Write how many extra binaries we got.
int extraBinaries = fileArray.length - 1;
fwrite(&extraBinaries, sizeof(extraBinaries), 1, target);
fclose(source);
int i;
for (i = 1 ; i < fileArray.length ; i++) {
FILE *source = fopen(fileArray.array[i], "r");
//Write the file size;
write_size(target, fileArray.array[i]);
//Write the binary
write_file(target, source);
fclose(source);
}
fclose(target);
return TRUE;
}
int checkFiles(array_t fileArray) {
int i = 0;
for(; i < fileArray.length ; i++) {
if(access(fileArray.array[i], R_OK)) {
printf("Can't open file: %s\n", fileArray.array[i]);
return FALSE;
}
}
return TRUE;
}
int write_size(FILE *target, char *filename) {
struct stat st;
stat(filename, &st);
uint32_t size = st.st_size;
fwrite(&size, sizeof(uint32_t), 1, target);
}
int write_file(FILE *target, FILE *source) {
char buffer[BUFFER_SIZE];
int read;
while (!feof(source)) {
read = fread(buffer, 1, BUFFER_SIZE, source);
fwrite(buffer, 1, read, target);
}
return TRUE;
}
/* Parse a single option. */
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
/* Get the input argument from argp_parse, which we
know is a pointer to our arguments structure. */
struct arguments *arguments = state->input;
switch (key)
{
case 'o':
arguments->output_file = arg;
break;
case ARGP_KEY_ARG:
arguments->args[state->arg_num] = arg;
break;
case ARGP_KEY_END:
if (state->arg_num < 1)
argp_usage (state);
arguments->count = state->arg_num;
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}

45
Toolchain/ModulePacker/modulePacker.h Normal file
View File

@ -0,0 +1,45 @@
#ifndef _MODULE_PACKER_H_
#define _MODULE_PACKER_H_
#include <argp.h>
#define FALSE 0
#define TRUE !FALSE
#define BUFFER_SIZE 128
#define OUTPUT_FILE "packedKernel.bin"
#define MAX_FILES 128
typedef struct {
char **array;
int length;
} array_t;
/* Used by main to communicate with parse_opt. */
struct arguments
{
char *args[MAX_FILES];
int silent, verbose;
char *output_file;
int count;
};
int buildImage(array_t fileArray, char *output_file);
int write_size(FILE *target, char *filename);
int write_file(FILE *target, FILE *source);
int checkFiles(array_t fileArray);
static error_t
parse_opt (int key, char *arg, struct argp_state *state);
#endif

18
Userland/Makefile Normal file
View File

@ -0,0 +1,18 @@
include Makefile.inc
SAMPLE_DATA=0001-sampleDataModule.bin
all: sampleCodeModule sampleDataModule
sampleCodeModule:
cd SampleCodeModule; make
sampleDataModule:
printf "This is sample data." >> $(SAMPLE_DATA) && dd if=/dev/zero bs=1 count=1 >> $(SAMPLE_DATA)
clean:
cd SampleCodeModule; make clean
rm -rf *.bin
.PHONY: sampleCodeModule all clean

9
Userland/Makefile.inc Normal file
View File

@ -0,0 +1,9 @@
GCC=gcc
GPP=g++
LD=ld
AR=ar
ASM=nasm
GCCFLAGS=-m64 -fno-exceptions -std=c99 -Wall -ffreestanding -nostdlib -fno-common -mno-red-zone -mno-mmx -fno-builtin-malloc -fno-builtin-free -fno-builtin-realloc -g
ARFLAGS=rvs
ASMFLAGS=-felf64

56
Userland/SampleCodeModule/Makefile Normal file
View File

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

28
Userland/SampleCodeModule/_loader.c Normal file
View File

@ -0,0 +1,28 @@
/* _loader.c */
#include <stdint.h>
extern char bss;
extern char endOfBinary;
int main();
void * memset(void * destiny, int32_t c, uint64_t length);
int _start() {
//Clean BSS
memset(&bss, 0, &endOfBinary - &bss);
return main();
}
void * memset(void * destiation, int32_t c, uint64_t length) {
uint8_t chr = (uint8_t)c;
char * dst = (char*)destiation;
while(length--)
dst[length] = chr;
return destiation;
}

278
Userland/SampleCodeModule/asm/libasm.asm Normal file
View File

@ -0,0 +1,278 @@
GLOBAL sys_read, sys_write, sys_time, quadSolver
GLOBAL _getMem, sys_loadProcess
GLOBAL raiseOpcodeExc
GLOBAL _getRegs, sys_switchContext
GLOBAL cpu_id, cpu_id_support
section .text
sys_write:
push rbp
mov rbp, rsp
push rdi
push rsi
push rdx
push rcx
mov rcx, rdx
mov rdx, rsi
mov rsi, rdi
mov rdi, 0
int 80h
pop rcx
pop rdx
pop rsi
pop rdi
mov rsp, rbp
pop rbp
ret
sys_read:
push rbp
mov rbp, rsp
push rdi
push rsi
push rdx
push rcx
mov rcx, rdx
mov rdx, rsi
mov rsi, rdi
mov rdi, 1
int 80h
pop rcx
pop rdx
pop rsi
pop rdi
mov rsp, rbp
pop rbp
ret
_getMem:
push rbp
mov rbp, rsp
mov eax, dword [rdi]
mov rsp, rbp
pop rbp
ret
_getRegs:
mov [regs], rax
mov [regs + 8], rbx
mov [regs + 16], rcx
mov [regs + 24], rdx
mov [regs + 32], rbp
mov [regs + 40], rdi
mov [regs + 48], rsi
mov [regs + 56], r8
mov [regs + 64], r9
mov [regs + 72], r10
mov [regs + 80], r11
mov [regs + 88], r12
mov [regs + 96], r13
mov [regs + 104], r14
mov [regs + 112], r15
lea rax, [rsp + 8]
mov [regs + 120], rax
mov rax, [rsp]
mov [regs + 128], rax
mov rax, regs
ret
cpu_id:
push rbp
mov rbp, rsp
push rax
mov rax, rdi
mov qword [auxRDI], rax
mov rax, rsi
mov qword [auxRSI], rax
mov rax, rdx
mov qword [auxRDX], rax
mov rax, rcx
mov qword [auxRCX], rax
mov eax, [rcx]
mov ecx, [rdx]
cpuid
push r12
mov r12, 0
mov r12, qword [auxRDI]
mov [r12], edx
mov r12, qword [auxRSI]
mov [r12], ecx
mov r12, qword [auxRDX]
mov [r12], ebx
mov r12, qword [auxRCX]
mov [r12], eax
pop r12
pop rax
mov rsp, rbp
pop rbp
ret
cpu_id_support:
pushfq ;Save EFLAGS
pushfq ;Store EFLAGS
xor dword [rsp], 0x00200000 ;Invert the ID bit in stored EFLAGS
popfq ;Load stored EFLAGS (with ID bit inverted)
pushfq ;Store EFLAGS again (ID bit may or may not be inverted)
pop rax ;eax = modified EFLAGS (ID bit may or may not be inverted)
xor rax, [rsp] ;eax = whichever bits were changed
popfq ;Restore original EFLAGS
and rax, 0x00200000 ;eax = zero if ID bit can't be changed, else non-zero
ret
raiseOpcodeExc:
ud2
sys_loadProcess:
push rbp
mov rbp, rsp
push rdi
push rsi
mov rsi, rdi
mov rdi, 3
int 80h
pop rsi
pop rdi
mov rsp, rbp
pop rbp
ret
sys_switchContext:
push rbp
mov rbp, rsp
int 81h
mov rsp, rbp
pop rbp
ret
sys_time:
push rbp
mov rbp, rsp
push rdi
push rsi
push rdx
push rcx
mov rsi, rdi ; option
mov rdi, 2
int 80h
pop rcx
pop rdx
pop rsi
pop rdi
mov rsp, rbp
pop rbp
ret
quadSolver:
push rbp
mov rbp, rsp
mov word [number4], -4
fild word [number4]
movsd qword [varA], xmm0
fld qword [varA] ; a
fmulp ; st(1) * st(0) y deja en st(1), ademas popea (saca st(0))
movsd qword [varC], xmm2
fld qword [varC] ; xmm2
fmulp ; ahora tengo -4ac
movsd qword [varB], xmm1
fld qword [varB] ; b
fld qword [varB] ; b
fmulp ; hago b**2 y dejo en st(0)
faddp
fstp qword [resAux]
mov word [number0], 0
fild word [number0]
fld qword [resAux]
fcomi st0, st1
jc .notReal ; si 0 > st(1)
faddp
fsqrt
mov qword [resAux], 0
fstp qword [resAux] ; guardo la raíz
fld qword [varA]
mov word [number2], 2
fild qword [number2]
fmulp
mov qword [number1], 1
fild qword [number1]
fdivrp ; divide 1/2a
fst qword [divAux] ; guardo el 1/2a
fld qword [varB]
fld qword [resAux]
fsubrp
fmulp
fstp qword [resOne]
movsd xmm4, qword [resOne]
movsd qword [rdi], xmm4 ; guardamos primera solucion
fld qword [varB]
fld qword [resAux]
fchs
fsubrp
fmul qword [divAux]
fstp qword [resTwo]
movsd xmm5, qword [resTwo]
movsd qword [rsi], xmm5 ; guardamos primera solucion
mov rax, 1
jmp .quit
.notReal:
mov rax, 0
.quit:
mov rsp, rbp
pop rbp
ret
section .bss
number4 resb 8
number0 resb 8
number1 resb 8
number2 resb 8
number5 resb 8
varA resb 8
varB resb 8
varC resb 8
resOne resb 8
resTwo resb 8
resAux resb 8
divAux resb 8
regs resb 120 ; 8 bytes * 16 regs
auxRDI resb 8
auxRSI resb 8
auxRDX resb 8
auxRCX resb 8

27
Userland/SampleCodeModule/include/libc.h Normal file
View File

@ -0,0 +1,27 @@
#ifndef LIBC
#define LIBC
#include "system.h"
void winClear();
void printString(char * string);
void printStringError(char * string);
void new_line();
char getChar();
int abs();
int atoi(char * buffer, int len);
int strlen(const char * s);
void scanf(char * buffer, int maxLen);
int strcmp(const char * s1, const char * s2);
char * itoa(int value, char* buffer, int base);
char isFloat(char * str);
float atof(char * arr);
char * strtok(char * s, char delim);
char isNumber(char c);
char * gtoa(int value, char * buffer, int base, int length);
char * reverse(char * buffer, int i, int j);
int pow(int base, int exponent);
char * strstrip(char * s, char c);
void ftoa(double f, char * buf, int precision);
#endif

10
Userland/SampleCodeModule/include/system.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef SYSTEM_H
#define SYSTEM_H
void sys_switchContext();
void sys_loadProcess();
int sys_time(char);
void sys_write(int, char *, int);
char sys_read(int, char *, int);
#endif

299
Userland/SampleCodeModule/libc.c Normal file
View File

@ -0,0 +1,299 @@
#include "libc.h"
void printString(char * string) {
int len = strlen(string);
sys_write(1, string, len);
}
void printStringError(char * string) {
int len = strlen(string);
sys_write(2, string, len);
}
int strlen(const char * s) {
int i = 0;
for (i = 0; s[i] != '\0'; i++);
return i;
}
int strcmp(const char * s1, const char * s2) {
while(*s1 && (*s1 == *s2)) {
s1++;
s2++;
}
return *s1 - *s2;
}
void putChar(char c){
char buffer = c;
sys_write(1, &buffer, 1);
}
void new_line() {
putChar('\n');
}
void winClear() {
sys_write(1, "\e\f", 2);
}
char* gtoa(int value, char* buffer, int base, int length) {
if (base < 2 || base > 32) {
return buffer;
}
int n = abs(value);
int i = 0;
while (n && i < length) {
int r = n % base;
if (r >= 10) {
buffer[i++] = 65 + (r - 10);
}
else {
buffer[i++] = 48 + r;
}
n = n / base;
}
if (i == 0) {
buffer[i++] = '0';
}
if (value < 0 && base == 10) {
buffer[i++] = '-';
}
buffer[i] = '\0';
return reverse(buffer, 0, i - 1);
}
char getChar() {
char buffer[1] = {0};
if (sys_read(0, buffer, 1) <= 0)
return -1;
return buffer[0];
}
void swap(char *x, char *y) {
char t = *x; *x = *y; *y = t;
}
char* reverse(char *buffer, int i, int j) {
while (i < j) {
swap(&buffer[i++], &buffer[j--]);
}
return buffer;
}
int abs(int value) {
return value < 0 ? -value : value;
}
char* itoa(int value, char* buffer, int base) {
if (base < 2 || base > 32) {
return buffer;
}
int n = abs(value);
int i = 0;
while (n) {
int r = n % base;
if (r >= 10) {
buffer[i++] = 65 + (r - 10);
}
else {
buffer[i++] = 48 + r;
}
n = n / base;
}
if (i == 0) {
buffer[i++] = '0';
}
if (value < 0 && base == 10) {
buffer[i++] = '-';
}
buffer[i] = '\0';
return reverse(buffer, 0, i - 1);
}
int atoi(char * string, int length) {
int res = 0, i = 0;
while (i < length) {
res = res * 10 + string[i++] - '0';
}
return res;
}
int pow(int base, int exponent) {
int result = 1;
for (; exponent > 0; exponent--) {
result = result * base;
}
return result;
}
char isFloat(char * str) {
int dot = 0;
if (*str == '-')
str++;
while (*str != 0) {
if (*str == '.' && !dot)
dot = 1;
else if (!isNumber(*str) || (*str == '.' && dot)) {
return 0;
}
str++;
}
return 1;
}
float atof(char *arr) {
float val = 0;
int afterdot=0;
float scale=1;
int neg = 0;
if (*arr == '-') {
arr++;
neg = 1;
}
while (*arr) {
if (afterdot) {
scale = scale/10;
val = val + (*arr-'0')*scale;
} else {
if (*arr == '.')
afterdot++;
else
val = val * 10.0 + (*arr - '0');
}
arr++;
}
if(neg) return -val;
else return val;
}
char * strstrip(char * s, char c) {
while (*s != 0) {
if (*s != c)
break;
s++;
}
return s;
}
char *strtok(char * s, char delim) {
char *ptr = s;
if (s == 0) {
return 0;
}
int flag = 0;
while (*ptr != 0) {
if (*ptr == delim) {
flag = 1;
*ptr = 0;
}
else if (flag == 1)
return ptr;
ptr++;
}
return ptr;
}
char isNumber(char c) {
return c <= '9' && c >= '0';
}
// Tomada y modificada de https://github.com/antongus/stm32tpl/blob/master/ftoa.c
#define MAX_PRECISION (10)
static const double rounders[MAX_PRECISION + 1] =
{
0.5, // 0
0.05, // 1
0.005, // 2
0.0005, // 3
0.00005, // 4
0.000005, // 5
0.0000005, // 6
0.00000005, // 7
0.000000005, // 8
0.0000000005, // 9
0.00000000005 // 10
};
void ftoa(double f, char * buf, int precision) {
char * ptr = buf;
char * p = ptr;
char * p1;
char c;
long intPart;
if (precision > MAX_PRECISION)
precision = MAX_PRECISION;
if (f < 0) {
f = -f;
*ptr++ = '-';
}
if (precision < 0) {
if (f < 1.0) precision = 6;
else if (f < 10.0) precision = 5;
else if (f < 100.0) precision = 4;
else if (f < 1000.0) precision = 3;
else if (f < 10000.0) precision = 2;
else if (f < 100000.0) precision = 1;
else precision = 0;
}
if (precision)
f += rounders[precision];
intPart = f;
f -= intPart;
if (!intPart)
*ptr++ = '0';
else {
p = ptr;
while (intPart) {
*p++ = '0' + intPart % 10;
intPart /= 10;
}
p1 = p;
while (p > ptr) {
c = *--p;
*p = *ptr;
*ptr++ = c;
}
ptr = p1;
}
if (precision && ((int) (f * pow(10, precision))) != 0) {
*ptr++ = '.';
while (precision-- && ((int) (f * pow(10, precision))) != 0) {
f *= 10.0;
c = f;
*ptr++ = '0' + c;
f -= c;
}
}
*ptr = 0;
}

17
Userland/SampleCodeModule/sampleCodeModule.c Normal file
View File

@ -0,0 +1,17 @@
/* sampleCodeModule.c */
#include "libc.h"
#include "shell/include/shell.h"
void sys_loadProcess(void (*fn));
void sys_switchContext();
int main() {
winClear();
sys_loadProcess(shell);
sys_loadProcess(shell);
sys_switchContext();
return 1;
}

21
Userland/SampleCodeModule/sampleCodeModule.ld Normal file
View File

@ -0,0 +1,21 @@
OUTPUT_FORMAT("binary")
ENTRY(_start)
SECTIONS
{
.text 0x400000 :
{
*(.text*)
. = ALIGN(0x1000);
*(.rodata*)
}
.data ALIGN(0x1000) :
{
*(.data*)
}
.bss ALIGN(0x1000) :
{
bss = .;
*(.bss*)
}
endOfBinary = .;
}

20
Userland/SampleCodeModule/shell/Makefile Normal file
View File

@ -0,0 +1,20 @@
# 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

6
Userland/SampleCodeModule/shell/commands/change.c Normal file
View File

@ -0,0 +1,6 @@
#include "system.h"
#include "change.h"
void change() {
sys_switchContext();
}

7
Userland/SampleCodeModule/shell/commands/clear.c Normal file
View File

@ -0,0 +1,7 @@
#include "libc.h"
#include "shell.h"
#include "clear.h"
void clear(char * window, int * offset) {
clearWindow(window, offset);
}

112
Userland/SampleCodeModule/shell/commands/cpuid.c Normal file
View File

@ -0,0 +1,112 @@
#include "cpu_id.h"
#include "shell.h"
int cpu_id(int *, int *, int *, int *);
int check_fpu() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return edx & CPUID_FEAT_EDX_FPU;
}
int check_sse() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return edx & CPUID_FEAT_EDX_SSE;
}
int check_sse2() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return edx & CPUID_FEAT_EDX_SSE2;
}
int check_sse41() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ecx & CPUID_FEAT_ECX_SSE4_1;
}
int check_sse42() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ecx & CPUID_FEAT_ECX_SSE4_2;
}
int check_avx() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ecx & CPUID_FEAT_ECX_AVX;
}
int check_fma() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ecx & CPUID_FEAT_ECX_FMA;
}
int check_f16c() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ecx & CPUID_FEAT_ECX_F16C;
}
int check_avx2() {
int eax = 7, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ebx & CPUID_FEAT_AVX2;
}
int check_vaesni() {
int eax = 7, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ebx & CPUID_FEAT_VAES;
}
int check_vpclmulqdq() {
int eax = 7, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ebx & CPUID_FEAT_VPCLMULQDQ;
}
int check_pclmulqdq() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ecx & CPUID_FEAT_ECX_PCLMUL;
}
int check_sse3() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ecx & CPUID_FEAT_ECX_SSSE3;
}
int check_mmx() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return edx & CPUID_FEAT_EDX_MMX;
}
int check_aes() {
int eax = 1, ebx = 0, ecx = 0, edx = 0;
cpu_id(&edx, &ecx, &ebx, &eax);
return ecx & CPUID_FEAT_ECX_AES;
}
int check_cpuid() {
return cpu_id_support();
}
static const int len = 16;
int (* checks[])() = {check_cpuid, check_mmx, check_sse, check_sse2, check_sse3, check_sse41, check_sse42, check_aes, check_pclmulqdq, check_avx, check_vaesni, check_vpclmulqdq, check_f16c, check_fma, check_avx2, check_fpu};
char * supports[] = {"cpuid_support", "mx_support", "sse_support", "sse2_support", "sse3_support", "sse41_support", "sse42_support", "aes_support", "pclmulqdq_support", "avx_support", "vaesni_support", "vpclmulqdq_support", "f16c_support", "fma_support", "avx2_support", "fpu_support"};
void cpufeatures(char * window, int * offset) {
for (int i = 0; i < len; i++) {
if (checks[i]()) {
addText(supports[i], window, offset);
substractLine(window, offset);
}
}
printWindow(window);
}

7
Userland/SampleCodeModule/shell/commands/excDiv.c Normal file
View File

@ -0,0 +1,7 @@
#include "excDiv.h"
void excdiv() {
int cero = 0;
int res = 1/cero;
res = res + 1;
}

7
Userland/SampleCodeModule/shell/commands/excOP.c Normal file
View File

@ -0,0 +1,7 @@
#include "excOP.h"
void raiseOpcodeExc();
void excop() {
raiseOpcodeExc();
}

13
Userland/SampleCodeModule/shell/commands/help.c Normal file
View File

@ -0,0 +1,13 @@
#include "libc.h"
#include "shell.h"
static char * info[] = {"change: Change the current working terminal (alternatively, press ALT+F1)", "clear: Clear the shell window", "cpufeatures: Show the features the cpu supports", "excdiv: Throw exception 0 (zero division)", "excop: Throw exception 6 (opcode error)", "help: Print information about commands", "inforeg: Print values of registers","printmem: Prints 32 bytes of memory, starting at a given direction", "quadratic: Receives 3 floats, quadratic coefficients, prints roots if real", "time: Prints date and time in UTC" };
static const int len = 10;
void help(char * window, int * offset) {
for (int i = 0; i < len; i++) {
addText(info[i], window, offset);
substractLine(window, offset);
}
printWindow(window);
}

29
Userland/SampleCodeModule/shell/commands/inforeg.c Normal file
View File

@ -0,0 +1,29 @@
#include "inforeg.h"
#include <stdint.h>
#include "libc.h"
#include "shell.h"
uint64_t _getRegs();
static char * regsNames[] = {
"RAX: ", "RBX: ", "RCX: ", "RDX: ", "RBP: ", "RDI: ", "RSI: ",
"R8: ", "R9: ", "R10: ", "R11: ", "R12: ", "R13: ", "R14: ", "R15: ",
"RSP: ", "RIP: "};
void inforeg(char * window, int * offset) {
uint64_t * regs = (uint64_t *) _getRegs();
char bufferAux[20];
for (int i = 0; i < 17; i++) {
if (i % 3 == 0 && i != 0)
substractLine(window, offset);
addText(regsNames[i], window, offset);
addText("0x", window, offset);
addText(gtoa(regs[i], bufferAux, 16, 20), window, offset);
if (i != 14 && i % 3 != 2)
addText(" - ", window, offset);
}
printWindow(window);
substractLine(window, offset);
}

28
Userland/SampleCodeModule/shell/commands/printmem.c Normal file
View File

@ -0,0 +1,28 @@
#include "inforeg.h"
#include <stdint.h>
#include "shell.h"
#include "libc.h"
int _getMem(int);
void getMem(int * buffer, int initialAddress) {
int * bufferAux = (int *) buffer;
for (int i = 0; i < 8; i++) {
bufferAux[i] = (int) _getMem(initialAddress + (i * 4));
}
}
void printmem(char * window, int * offset, long dir) {
int buffer[8];
getMem(buffer, dir);
for (int i = 0; i < 8; i++) {
char bufferAux[8];
addText("0x", window, offset);
addText(itoa(buffer[i], bufferAux, 16), window, offset);
substractLine(window, offset);
}
printWindow(window);
}

42
Userland/SampleCodeModule/shell/commands/quadratic.c Normal file
View File

@ -0,0 +1,42 @@
#include "libc.h"
#include "quadratic.h"
#include "shell.h"
void quadratic(char * window, int * offset, double a, double b, double c) {
double sol1, sol2;
if (a == 0) {
addText("First argument cannot be 0", window, offset);
printWindow(window);
substractLine(window, offset);
return;
}
int cond = quadSolver(a, b, c, &sol1, &sol2);
if (cond == 0) {
addText("Not real!", window, offset);
printWindow(window);
substractLine(window, offset);
return;
}
char buffer[30] = {0};
addText("Roots for ", window, offset);
ftoa(a, buffer, 10);
addText(buffer, window, offset);
addText("x^2 + ", window, offset);
ftoa(b, buffer, 10);
addText(buffer, window, offset);
addText("x + ", window, offset);
ftoa(c, buffer, 10);
addText(buffer, window, offset);
substractLine(window, offset);
ftoa(sol1, buffer, 10);
addText(buffer, window, offset);
addText(" and ", window, offset);
char buffer2[30] = {0};
ftoa(sol2, buffer2, 10);
addText(buffer2, window, offset);
printWindow(window);
substractLine(window, offset);
}

0
Userland/SampleCodeModule/shell/commands/switch.c Normal file
View File

52
Userland/SampleCodeModule/shell/commands/time.c Normal file
View File

@ -0,0 +1,52 @@
#include "time.h"
#include "libc.h"
#include "shell.h"
#include "system.h"
int getSeconds() {
return sys_time(SECONDS);
}
int getMinutes() {
return sys_time(MINUTES);
}
int getHours() {
return sys_time(HOURS);
}
int getDay() {
return sys_time(DAY);
}
int getMonth() {
return sys_time(MONTH);
}
int getYear() {
return sys_time(YEAR);
}
void printTime(int number, char * window, int * offset) {
char buffer[3] = {0};
buffer[0] = number / 10 + '0';
buffer[1] = number % 10 + '0';
buffer[2] = '\0';
addText(buffer, window, offset);
}
void time(char * window, int * offset) {
printTime(getDay(), window, offset);
addText("/", window, offset);
printTime(getMonth(), window, offset);
addText("/", window, offset);
printTime(getYear(), window, offset);
addText(" ", window, offset);
printTime(getHours(), window, offset);
addText(":", window, offset);
printTime(getMinutes(), window, offset);
addText(":", window, offset);
printTime(getSeconds(), window, offset);
printWindow(window);
substractLine(window, offset);
}

6
Userland/SampleCodeModule/shell/include/change.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef CHANGE_H
#define CHANGE_H
void change();
#endif

6
Userland/SampleCodeModule/shell/include/clear.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef CLEAR_LIB
#define CLEAR_LIB
void clear(char * window, int * offset);
#endif

74
Userland/SampleCodeModule/shell/include/cpu_id.h Normal file
View File

@ -0,0 +1,74 @@
#ifndef CPUID
#define CPUID
// Tabla obtenidad de: https://wiki.osdev.org/CPUID
enum {
CPUID_FEAT_ECX_SSE3 = 1 << 0,
CPUID_FEAT_ECX_PCLMUL = 1 << 1,
CPUID_FEAT_ECX_DTES64 = 1 << 2,
CPUID_FEAT_ECX_MONITOR = 1 << 3,
CPUID_FEAT_ECX_DS_CPL = 1 << 4,
CPUID_FEAT_ECX_VMX = 1 << 5,
CPUID_FEAT_ECX_SMX = 1 << 6,
CPUID_FEAT_ECX_EST = 1 << 7,
CPUID_FEAT_ECX_TM2 = 1 << 8,
CPUID_FEAT_ECX_SSSE3 = 1 << 9,
CPUID_FEAT_ECX_CID = 1 << 10,
CPUID_FEAT_ECX_FMA = 1 << 12,
CPUID_FEAT_ECX_CX16 = 1 << 13,
CPUID_FEAT_ECX_ETPRD = 1 << 14,
CPUID_FEAT_ECX_PDCM = 1 << 15,
CPUID_FEAT_ECX_PCIDE = 1 << 17,
CPUID_FEAT_ECX_DCA = 1 << 18,
CPUID_FEAT_ECX_SSE4_1 = 1 << 19,
CPUID_FEAT_ECX_SSE4_2 = 1 << 20,
CPUID_FEAT_ECX_x2APIC = 1 << 21,
CPUID_FEAT_ECX_MOVBE = 1 << 22,
CPUID_FEAT_ECX_POPCNT = 1 << 23,
CPUID_FEAT_ECX_AES = 1 << 25,
CPUID_FEAT_ECX_XSAVE = 1 << 26,
CPUID_FEAT_ECX_OSXSAVE = 1 << 27,
CPUID_FEAT_ECX_AVX = 1 << 28,
CPUID_FEAT_ECX_F16C = 1 << 29,
CPUID_FEAT_EDX_FPU = 1 << 0,
CPUID_FEAT_EDX_VME = 1 << 1,
CPUID_FEAT_EDX_DE = 1 << 2,
CPUID_FEAT_EDX_PSE = 1 << 3,
CPUID_FEAT_EDX_TSC = 1 << 4,
CPUID_FEAT_EDX_MSR = 1 << 5,
CPUID_FEAT_EDX_PAE = 1 << 6,
CPUID_FEAT_EDX_MCE = 1 << 7,
CPUID_FEAT_EDX_CX8 = 1 << 8,
CPUID_FEAT_EDX_APIC = 1 << 9,
CPUID_FEAT_EDX_SEP = 1 << 11,
CPUID_FEAT_EDX_MTRR = 1 << 12,
CPUID_FEAT_EDX_PGE = 1 << 13,
CPUID_FEAT_EDX_MCA = 1 << 14,
CPUID_FEAT_EDX_CMOV = 1 << 15,
CPUID_FEAT_EDX_PAT = 1 << 16,
CPUID_FEAT_EDX_PSE36 = 1 << 17,
CPUID_FEAT_EDX_PSN = 1 << 18,
CPUID_FEAT_EDX_CLF = 1 << 19,
CPUID_FEAT_EDX_DTES = 1 << 21,
CPUID_FEAT_EDX_ACPI = 1 << 22,
CPUID_FEAT_EDX_MMX = 1 << 23,
CPUID_FEAT_EDX_FXSR = 1 << 24,
CPUID_FEAT_EDX_SSE = 1 << 25,
CPUID_FEAT_EDX_SSE2 = 1 << 26,
CPUID_FEAT_EDX_SS = 1 << 27,
CPUID_FEAT_EDX_HTT = 1 << 28,
CPUID_FEAT_EDX_TM1 = 1 << 29,
CPUID_FEAT_EDX_IA64 = 1 << 30,
CPUID_FEAT_EDX_PBE = 1 << 31,
CPUID_FEAT_AVX2 = 1 << 5,
CPUID_FEAT_VPCLMULQDQ = 1 << 10,
CPUID_FEAT_VAES = 1 << 9
};
void cpufeatures(char * window, int * offset);
int cpu_id_support(void);
#endif

6
Userland/SampleCodeModule/shell/include/excDiv.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef EXCDIV_LIB
#define EXCDIV_LIB
void excdiv();
#endif

6
Userland/SampleCodeModule/shell/include/excOP.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef EXCOP_LIB
#define EXCOP_LIB
void excop();
#endif

6
Userland/SampleCodeModule/shell/include/help.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef HELP_LIB
#define HELP_LIB
void help(char * window, int * offset);
#endif

6
Userland/SampleCodeModule/shell/include/inforeg.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef REG_LIB
#define REG_LIB
void inforeg(char*, int*);
#endif

6
Userland/SampleCodeModule/shell/include/printmem.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef MEM_LIB
#define MEM_LIB
void printmem(char* window, int* offset, long);
#endif

7
Userland/SampleCodeModule/shell/include/quadratic.h Normal file
View File

@ -0,0 +1,7 @@
#ifndef QUAD_LIB
#define QUAD_LIB
int quadSolver(double, double, double, double *, double *);
void quadratic(char*, int*, double, double, double);
#endif

14
Userland/SampleCodeModule/shell/include/shell.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef SHELL
#define SHELL
#include "system.h"
void shell(void);
void printWindow(char * window);
void addText(char * buffer, char * window, int * offset);
void incorrect_comm(char * buffer, char * window, int * offset);
void incorrect_arg(char * command, char * window, int * offset);
void clearWindow(char * window, int * offset);
void substractLine(char * window, int * offset);
#endif

21
Userland/SampleCodeModule/shell/include/time.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef TIME
#define TIME
int getSeconds();
int getMinutes();
int getHours();
int getDays();
int getMonths();
int getYears();
void time(char * window, int * offset);
#define SECONDS 0
#define MINUTES 2
#define HOURS 4
#define DAY 7
#define MONTH 8
#define YEAR 9
#define UTC -3
#endif

146
Userland/SampleCodeModule/shell/shell.c Normal file
View File

@ -0,0 +1,146 @@
#include "libc.h"
#include "help.h"
#include "clear.h"
#include "time.h"
#include "shell.h"
#include "inforeg.h"
#include "printmem.h"
#include "excDiv.h"
#include "excOP.h"
#include "quadratic.h"
#include "cpu_id.h"
#include "change.h"
#define SIZE 100
#define MAX_ARGS 5
#define COLS 40
#define ROWS 25
const int len = 8;
char *commands_void[] = {"help", "time", "inforeg", "excdiv", "excop", "clear", "cpufeatures", "change"};
void (*func []) (char *, int *) = {help, time, inforeg, excdiv, excop, clear, cpufeatures, change};
void substractLine(char * window, int * offset) {
for (int i = 0; i < ROWS - 1; i++) {
for (int j = 0; j < COLS; j++) {
window[i * COLS + j] = window[(i + 1) * COLS + j];
}
}
for (int i = 0; i < COLS; i++) {
window[(ROWS - 1) * COLS + i - 1] = ' ';
window[ROWS * COLS] = 0;
}
*offset = (ROWS - 1) * COLS;
}
void addText(char * buffer, char * window, int * offset) {
while (*buffer != 0) {
if (*offset == ROWS * COLS - 1) substractLine(window, offset);
window[(*offset)++] = *buffer++;
}
}
void printWindow(char * window) {
printString(window);
}
void scanfNoPrint(char * buffer, int maxSize, char * window, int * offset) {
char c;
int i = 0;
while ((c = getChar()) != '\n' && i < maxSize - 1) {
if (c != -1) {
if (c == '\v')
sys_switchContext();
else if (c == '\b' && i > 0) {
buffer[--i] = ' ';
window[--(*offset)] = ' ';
printWindow(window);
}
else if (c != 0 && c != '\b') {
buffer[i++] = c;
if (*offset == ROWS * COLS - 1) substractLine(window, offset);
window[(*offset)++] = c;
printWindow(window);
}
}
}
buffer[i] = '\0';
if (*offset == ROWS * COLS - 1) substractLine(window, offset);
window[*offset] = ' ';
}
void clearWindow(char * window, int * offset) {
for (int i = 0; i <= ROWS * COLS; i++) {
window[i] = ' ';
}
window[ROWS * COLS] = 0;
*offset = (ROWS - 1) * COLS;
printWindow(window);
}
void shell() {
char window[ROWS * COLS + 1] = {[0 ... ROWS * COLS - 1] = ' ', 0};
int offset = (ROWS - 1) * COLS;
printWindow(window);
while (1) {
int comm_flag = 0;
addText("$> ", window, &offset);
printWindow(window);
char buffer[SIZE] = {0};
scanfNoPrint(buffer, SIZE, window, &offset);
substractLine(window, &offset);
char* tokens[SIZE] = {0};
tokens[0] = strstrip(buffer, ' ');
for (int i = 1; i < MAX_ARGS; i++) {
tokens[i] = strtok(tokens[i - 1], ' ');
}
for (int i = 0; i < len; i++) {
if (!strcmp(tokens[0], commands_void[i])) {
if (*tokens[1] != 0)
incorrect_arg(tokens[0], window, &offset);
else
(*func[i])(window, &offset);
comm_flag = 1;
}
}
if (!strcmp(tokens[0], "quadratic")) {
if (*tokens[4] != 0 || *tokens[3] == 0)
incorrect_arg(tokens[0], window, &offset);
else if (!isFloat(tokens[1]) || !isFloat(tokens[2]) || !isFloat(tokens[3]))
incorrect_arg(tokens[0], window, &offset);
else
quadratic(window, &offset, atof(tokens[1]), atof(tokens[2]), atof(tokens[3]));
comm_flag = 1;
}
if (!strcmp(tokens[0], "printmem")) {
if (*tokens[2] != 0 || *tokens[1] == 0)
incorrect_arg(tokens[0], window, &offset);
else {
int length = strlen(tokens[1]);
printmem(window, &offset, atoi(tokens[1], length));
}
comm_flag = 1;
}
if (!comm_flag) {
if (*tokens[0] != 0)
incorrect_comm(tokens[0], window, &offset);
}
}
}
void incorrect_comm(char * buffer, char* window, int * offset) {
addText(buffer, window, offset);
addText(" is not a BottlerShell command", window, offset);
printWindow(window);
substractLine(window, offset);
}
void incorrect_arg(char * command, char* window, int * offset) {
addText("Incorrect arguments for command ", window, offset);
addText(command, window, offset);
printWindow(window);
substractLine(window, offset);
}

1
run.bat Normal file
View File

@ -0,0 +1 @@
qemu-system-x86_64.exe -hda Image/x64BareBonesImage.qcow2 -m 512

Some files were not shown because too many files have changed in this diff Show More