-
Notifications
You must be signed in to change notification settings - Fork 2
Home
NANO S16 is a small operating system for 16-bit x86 architectures which operates in real mode. Major functions of this operating system include:
- Memory and system resources management
- User programs execution management, providing them system services
- Implements a basic user interface and application programmer interface
System requirements:
- x86 compatible computer
- 128Kb of RAM (1MB recommended)
- 1.44Mb disk
- VGA graphics card
Realtek 8029AS network card is supported. PS2 mice are supported.
Developer notes: This software is a hobby operating system. Creator makes no warranty for the use of its products and assumes no responsibility for any errors which may appear in this document nor does it make a commitment to update the information contained herein.
This operating system is composed of several components, detailed in this section.
The kernel is the core of the operating system. It connects the application software to the hardware of a computer. The kernel manages memory access for user programs, determines how programs get access to hardware resources, and organizes the data for long-term non-volatile storage with file systems on disks.
This operating system implements a monolithic kernel written in C and NASM, which includes all of its services itself. This reduces the amount of messaging and synchronization involved.
The operating system provides an interface between an application program and the computer hardware, so that an application program can interact with the hardware by obeying rules and procedures programmed into the operating system. The operating system provides also a set of services which simplify development and execution of application programs. Executing an application program involves the creation of a process by the operating system kernel which assigns memory space and other resources, loads program binary code into memory, and initiates execution of the application program which then interacts with the user and with hardware devices.
This operating system implements a monotasking task model. Monotasking systems, also referred to as single-tasking systems, are operating systems in which only one thread of execution is run at a given time. When an application is executed, it takes control of the whole computer, save for the 'resident' part of the operating system which handles system calls and hardware interrupts.
Operating systems determine CPU operation mode. Modern CPUs support multiple modes. Real Mode is a simplistic 16-bit mode that is present on all x86 processors. It was the first x86 mode design and was used by many early operating systems before the birth of Protected Mode. For compatibility purposes, all x86 processors begin execution in Real Mode, emulating an Intel 8088 microprocessor. Real Mode allows unrestricted access to hardware.
This operating system operates kernel and applications in Real Mode.
An operating system kernel is responsible for managing the system memory. This ensures that a program does not interfere with memory already in use. In Real Mode, there is a little over 1 MB of "addressable" memory (if A20 line is enabled), which can be accessed using segmentation. There are 16 segments of 64KB each available.
This operating system enables A20 line (if available) and uses a mixed memory model: one segment for kernel (code, stack and data), one segment for user programs (code and stack) and multiple user programs data segments.
Memory map:
- 0x00000000-0x000003FF 1KB - Interrupt Vector Table
- 0x00000400-0x000004FF 256B - BIOS Data Area
- 0x00007C00-0x00007FFF 1KB - Boot data
- 0x00008000-0x00017FFF 64KB - Kernel segment (code, stack and data)
- 0x00018000-0x00027FFF 64KB - User programs code and stack segment
- 0x00028000-0x0009FC00 490KB - User programs data
- 0x0009FC00-0x0009FFFF 1KB - Extended BIOS Data Area
- 0x000A0000-0x000FFFFF 384KB - Video memory, ROM Area
Inside the kernel mapping area there is a dedicated buffer for performing disk operations, and another for kernel heap memory allocation.
File systems allow users and programs to organize and sort files on a computer. Computers usually store data on disks using files. The specific way in which files are stored on a disk is called a file system, and enables files to have names and attributes.
With an appropriate device driver, the kernel can then access the contents of the disk in a connected storage device in raw format. A file system driver is used to translate this raw data into a set of structures that the operating system can understand. Programs can then deal with these file systems on the basis of filenames.
This operating system supports hard disks and removable disks, and implements a custom file system (NSFS). The NSFS file system is simple, offers good performance and allows light-weight implementations.
NSFS divides disk space into logical blocks of contiguous space, following this layout:
[boot block | super block | entries table | data blocks]
- Boot block (block 0): Boot sector
- Super block (block 1): Contains information about the layout of the file system
- Entries table (blocks 2-n): Table of file and directory entries
- Data blocks (blocks n-end): Data blocks referenced by file entries
Every computer that is to be operated by a human requires a user interface. One of the most common forms of a user interface is the command-line interface (CLI), where computer commands are typed out line-by-line.
This operating system implements a CLI model, in which each command is typed out using the keyboard after the 'prompt', and then its output appears below, in a compatible display device. The User Manual section contains a more detailed description of the CLI.
When a computer is switched on or reset, it runs through a series of diagnostics called POST (Power-On Self-Test). This sequence culminates in locating a bootable device, such as a removable disk or a hard disk in the order that the firmware is configured to. A device is detected as bootable if it carries a boot sector (512 bytes) with the byte sequence 0x55, 0xAA in bytes 511 and 512 respectively. When the BIOS finds such a boot sector, it loads it into memory at 0x0000:0x7C00 (segment 0, offset 0x7C00). Execution is then transferred to this address.
The NANO system disk contains a bootloader in this sector. This bootloader scans then the boot disk and loads the kernel file at memory location 0x0800:0x0000. Once the bootloader has loaded the kernel, it jumps to this memory location to begin executing it.
The kernel execution starts, sets up needed drivers and initializes the Command Line Interface.
NANO executable file format does not contain metadata or sections. It only contains non-relocatable raw 16-bit x86 machine code assumed to be loaded at 0x1800:0x0000 address. Execution starts also at this address through a special far call instruction. The CLI requires a file name to contain the .bin suffix before starting the execution of such file. This is the only safety check performed in order to differentiate executable files.