ⓘ Cosmos (operating system)

                                     

ⓘ Cosmos (operating system)

C# Open Source Managed Operating System is a toolkit for building operating systems, written mostly in the programming language C# and small amounts of a high level assembly language named X#. Cosmos is a backronym, in that the acronym was chosen before the meaning. It is open-source software released under a BSD license.

Cosmos encompasses an AOT compiler named IL2CPU to translate Common Intermediate Language CIL into native instructions. Cosmos compiles user-made programs and associated libraries using IL2CPU to create a bootable native executable that can be run with no support. The resulting output can be booted from a USB flash drive, CD-ROM, over a network via Preboot Execution Environment PXE, or inside a virtual machine. Recent releases also allow deploying to certain x86 embedded devices over Universal Serial Bus USB. While C# is the primary language used by developers both on the backend and by end users of Cosmos, many CLI languages can be used, provided they compile to pure CIL without the use of Platform Invocation Services P/Invokes. Cosmos is mainly intended for use with.NET Framework, with Mono support in the works.

As of 2016, Cosmos does not aim to become a full operating system, but rather a toolkit to allow other developers to simply and easily build their own operating systems, or as one of the project leaders put it, to act as operating system Legos ". It also functions as an abstraction layer, hiding much of the inner workings of the hardware from the eventual developer.

Older versions of Cosmos were released in Milestones, with the last being Milestone 5 released August, 2010. More recently, the project switched to simply naming new releases after the latest commit number. Releases of Cosmos are divided into two types: the Userkit, and the Devkit. The Userkit"is a pre-packaged release that is updated irregularly, as new and improved features are added. Userkits are generally considered stable, but do not include recent changes and may lack features. The Devkit refers to the source code of Cosmos, and must be built manually. The devkits are usually unstable as they may contain unfinished or untested code. The Devkit can be acquired on GitHub and uses Git as the source control management. Most work on Cosmos is currently aimed at improving debugger functionality and Visual Studio integration. Kernel work is focused on implementing file systems, memory management, and developing a reliable network interface. Syslinux serves as the projects bootloader.

                                     

1. Developing with Cosmos

Cosmos has many facilities to improve the experience of developing operating systems with it, designed to make the process as fast and painless as possible, knowledge of the assembly language is not required to use Cosmos.

                                     

1.1. Developing with Cosmos Visual Studio integration

A key feature of Cosmos, which separates it from other operating systems of its type, is its tight integration with Microsoft Visual Studio. Code can be written, compiled, debugged, and run entirely through Visual Studio, with only a few key presses. Cosmos no longer supports Visual Studio 2015, now it only supports Visual Studio 2017.

                                     

1.2. Developing with Cosmos Debugging

Cosmos can be seamlessly debugged through Visual Studio when running over PXE or in a virtual machine. Many standard debugging features are present, such as breakpoints, tracing, and logging. Additionally, debugging can be done via serial cables, if running on physical hardware. When running in VMWare, Cosmos supports stepping and breakpoints, even while an operating system is running.

                                     

1.3. Developing with Cosmos Running

Cosmos uses virtualization to help speed development by allowing developers to test their operating systems without having to restart their computers as often. By default, VMWare Player is used, due to its ease of use in terms of integration with the project. Other virtualization environments are supported as well, such as Bochs and VirtualPC. An ISO disk image may also be generated that can be burned to a USB flash drive, CD-ROM, or similar media.

PXE booting is also supported, allowing for remote machines to run Cosmos over a network connection.

                                     

2. Compile process

Syntax

The syntax of X# is simple. Despite being similar to C, X# syntax differs and is stricter.

Comments

X# supports only one kind of comment, the C-style single line comment, started with a double forward slash - //.

Labels

Labels in X# are mostly equivalent to labels in other assembly languages. The instruction to jump to a label uses the goto mnemonic, as opposed to the conventional jump or jmp mnemonic.

                                     

2.1. Compile process IL2CPU

To compile.NET CIL into assembly language, Cosmos developers created an ahead-of-time compiler named IL2CPU, designed to parse CIL and output x86 opcodes. IL To CPU is an AOT compiler that is written using a Common Intermediate Language compliant language C#. It translates Common Intermediate Language to machine code.



                                     

2.2. Compile process Syntax

The syntax of X# is simple. Despite being similar to C, X# syntax differs and is stricter.

                                     

2.3. Compile process Comments

X# supports only one kind of comment, the C-style single line comment, started with a double forward slash - //.

                                     

2.4. Compile process Constants

X# supports the definition of named constants which are declared outside of functions. Defining a numeric constant is similar to C++ - for instance,

. Referencing the constant elsewhere requires a # before the name - "#i", for instance.

  • To define a string constant, single quotes are used. To use a single quote in a string constant, it must be escaped by placing a backslash before it, as I\m so happy. X# strings are null terminated.
  • Hexadecimal constants are prefixed with a dollar sign $, followed by the constant. $B8000.
  • Binary and octal constants arent supported yet.
  • Decimal constants are not decorated but may not start with 0.
                                     

2.5. Compile process Labels

Labels in X# are mostly equivalent to labels in other assembly languages. The instruction to jump to a label uses the goto mnemonic, as opposed to the conventional jump or jmp mnemonic.

                                     

2.6. Compile process Namespaces

X# program files must begin with a namespace directive. X# lacks a namespace hierarchy, so any directive will change the current namespace until its changed again or the file ends. Variables or constants in different namespaces may have the same name as the namespace is prefixed to the members name on assembly output. Namespaces cannot reference each other except through "cheats" using native-assembly-level operations.

                                     

2.7. Compile process Functions

All X# executive code should be placed in functions defined by the function keyword. Unlike C, X# does not support any formal parameter declaration in the header of the functions, so the conventional parentheses after the function name are omitted. Because line-fixed patterns are specified in syntax implemented in code parser, the opening curly bracket cant be placed on the next line, unlike in many other C-style languages.

Because X# is a low-level language, there are no stack frames inserted, so by default, there should be the return EIP address on the top of the stack. X# function calls do contain arguments enclosed in parentheses, unlike in function headers. Arguments passed to functions can be registers, addresses, or constants. These arguments are pushed onto the stack in reverse order. Note that the stack on x86 platforms cannot push or pop one-byte registers.

The return keyword returns execution to the return EIP address saved in the stack.



                                     

2.8. Compile process Arithmetic and bitwise operations

X# can work with three low-level data structures: the registers, the stack and the memory, on different ports. The registers are the base of all normal operations for X#. A register can be copied to another by writing DST = SRC as opposed to mov or load/store instructions. Registers can be incremented or decremented just as easily. Arithmetic operations are written as dest op src where src is a constant, variable, or register, and dest is both an operand and the location where the result is stored.

Examples of assignment and arithmetic operations are shown below.

Register shifting and rolling is similar to C.

Other bitwise operations are similar to arithmetic operations.

                                     

2.9. Compile process Stack

Stack manipulation in X# is performed using + and - prefixes, where + pushes a register, value, constant or all registers onto the stack and - pops a value to some register. All constants are pushed on stack as double words, unless stated otherwise pushing single bytes is not supported.

                                     

2.10. Compile process Variables

Variables are defined within namespaces as there are no stack frames, local variables arent supported using the var keyword. Arrays can be defined by adding the arrays type and size on the end of the declaration. Variables and arrays are zeroed by default. To reference a variables value, it must be prefixed with a dot. Prefixing that with an will reference the variables address.

X# can access an address with a specified offset using square brackets:

                                     

2.11. Compile process Comparison

There are two ways of comparing values: pure comparison and if-comparison.

  • Pure comparison leaves the result in FLAGS so it can be used in native assembly or using the if keyword without specifying comparison members.
  • If comparison compares two members directly after an if keyword.

Here are two ways of writing a slow X# string length strlenfunction:

There are six available comparison operators: < > = =!=. These operators can be used in both comparisons and loops. Note that theres also a bitwise AND operator which tests bits:

                                     

3. Writing Cosmos code

An operating system built with Cosmos is developed in a similar fashion to any.NET C# console program. Additional references are made in the start of the program which give access to the Cosmos libraries. These libraries override the system libraries normally used in C# console programs since the resulting binary wont be running on an installation of Microsoft Windows.

User Kit and Visual Studio

The Cosmos User Kit is a part of Cosmos designed to make Cosmos easier to use for developers using Microsoft Visual Studio. When installed, the user kit adds a new project type to Visual Studio, called a Cosmos Project. This is a modified version of a console application, with the Cosmos compiler and bootup stub code already added.

                                     

4. Compiling a project

Once the code is complete, it may be compiled using.NET compiler. This converts the application from the original source code C# or otherwise into Common Intermediate Language CIL, the native language of.NET Framework. Next the application is run, showing the Cosmos Builder Window, which presents the developer with options which determine exactly how the project is compiled. These options include how to boot the project - via emulators such as Quick Emulator QEMU, Virtual PC, and VMWare, writing to a disk image ISO file that can later be written to a CD-ROM, or via Preboot Execution Environment PXE network booting - as well as debug options using Cosmos built-in debugger, and other options.

When the user has chosen their desired options, they press the Build button. This invokes the IL2CPU compiler which systematically scans through all of the applications CIL code excluding the Cosmos compiler code, converting it into assembly language for the selected processor architecture. As of 2016, only x86 is supported. Next, Cosmos invokes the selected assembler to convert this assembly language code into native central processing unit CPU opcode. Finally, the desired output option is activated, be this starting an emulator, starting a PXE engine, or producing an ISO disk image file from the binary code opcode.



                                     

4.1. Compiling a project Debug options

Cosmos offers several options as to how to deploy the resulting OS and how to debug the output.

                                     

4.2. Compiling a project Virtualization

Cosmos allows users to boot the operating system in an emulated environment using a virtual machine. This lets developers test the system on their own computer without having to reboot, giving the advantages of not requiring extra hardware or that developers exit their development environment. Currently only VMWare is supported. Bochs support is underway. QEMU and VirtualBox are not officially supported.

                                     

4.3. Compiling a project Disk images

This option writes the operating system to a disk image ISO file, which can be loaded into some emulators such as Bochs, QEMU or more commonly VMware or written to a CD-ROM and booted on real hardware. This option also allows deploying to a USB mass storage device, such as a USB flash drive, to boot on devices that may not have an optical disc drive. Because networking is not in place yet, debugging is unsupported with this deploy option.

                                     

4.4. Compiling a project Cosmos assembler

The Cosmos Project team have also created an assembler that is designed to eventually become the main assembler for the Cosmos system. However, the assembler is still inefficient and slow, and so the Netwide Assembler NASM is used instead.