marineltinnirello / kos-mos Goto Github PK

Provide the ability to single-step execution (via GUI buttons).

Alter the ver command to display your own data.

Develop your fsDD to insulate and encapsulate the implementation of the kernel-level I/O operations (noted above) from the byte-level details of your individual blocks on the local storage.

Develop a core memory prototype and implement it in the host OS.

Allow the OS to execute four or more concurrent user process by writing roll-out and roll-in routines to:

• Take a ready process and store it to the disk via your fsDD
• Load a swapped-out process from disk and put it in the ready queue
• Your ready queue should denote which processes are where

Develop a PCB prototype and implement it in the client OS.

Implement line-wrap in the CLI.

Develop a memory accessor prototype and implement it in the host OS.

Implement command line options for format:

• quick: Initialize the first four bytes of every directory and data block
• full: Same as quick and also initializes bytes 4-63 in directory and data blocks too

Add the following shell commands:

• clearmem: clear all memory partitions
• runall: execute all programs at once
• ps: display the PID and state of all processes
• kill : kill one process
• killall: kill all processes
• quantum : let the user set the Round Robin quantum (measured in CPU cycles)

Validate code if and only if it's in hex digits or spaces.

• load: validate the user code in the HTML5 text area (id= “taProgramInput”)

Modify the load command to copy the 6502a machine language op codes into main memory.

• Put the code at location $0000 in memory.
• Assign a Process ID (PID).
• Create a Process Control Block (PCB).
• Return the PID to the console and display it.

Store multiple programs in memory, each in their own partition /segment, allocated by the client OS (which obviously needs to keep track of available and used partitions/segments).

Develop a CPU prototype and implement it in the host OS.

Implement context switches with software interrupts. Be sure to update the mode bit (if appropriate), the PCBs, and the Ready queue.

Add the following shell commands:

• create: Create the file filename and display a message denoting success or failure
• read: Read and display the contents of filename or display an error if something went wrong
• write: Write the data inside the quotes to filename and display a message denoting success or failure
• delete: Remove filename from storage and display a message denoting success or failure
• format: Initialize all blocks in all sectors in all tracks and display a message denoting success or failure
• ls: List the files currently stored on the disk

Implement line-wrap in the CLI.

Allow the user to load three programs into memory at once.

Add a shell command, run , to run a program already in memory.

Create a Resident list for the loaded processes.

Support hidden files (that do not show up in ls output) with file names that begin with a period

Implement a File system in HTML5 session storage as discussed in class.

Allow the user to break the current program with Ctrl-C.

Enhance the host display with a graphic task bar that displays

• current date and time
• status : status messages as specified by the user

Load the fsDD in a similar manner as the keyboard device driver.

Default to round robin. Add non-preemptive priority and first come, first serve.

Add base and limit registers to your core memory access code in the host OS and to your PCB objects in the client OS.

As the programs executes, update and display the memory, PCB, and CPU status (program counter, instruction reg, accumulator, X reg, Y reg, Z Glag) in real time.

Display the Ready queue and its contents (including process state) in real time.

Develop a memory manager and implement it in the client OS.

Add some new shell commands:

• date: displays the current date and time
• whereami: displays the users current location (or made up location)
• original command

Detect and gracefully handle errors like invalid op codes, missing operands (if you can detect that), and most importantly, memory out of bounds or access violation attempts.

Implement scrolling in the client OS console/CLI.

Other console/CLI enhancements

• Accept and display punctuation characters and symbols
• Handle backspace appropriately
• Implement command completion with the tab key
• Provide command history recall via the up and down arrow keys

Track turnaround time and wait time for each process.

Include a file system viewer in your OS interface.

Add the following shell commands:

• setschedule: Allow the user to select a CPU scheduling algorithm
• getschedule: Return the currently selected CPU scheduling algorithm

Enforce memory partition boundaries at all times.

Instantiate a PCB for each loaded program and put it in the Resident list.

Add the following shell commands:

• ls -l: Lists all file names (even hidden ones) as well as their size and create date
• copy
• rename
• check disk and file system disk-like utilities

Create a Ready queue for the running processes.

Execute the running program (including displaying memory, CPU, and PCB status as well as any output). Be sure to synchronize the CPU execution cycles with clock ticks.

Develop a CPU scheduler in the client OS using Round Robin scheduling with the user-specified quantum measured in CPU cycles (default = 6).

• Make the client OS control the host CPU with the CPU scheduler.
• Log all scheduling events.

Display a BSOD message (on the CLI) when the kernel traps an OS error, also accessible via a command.