Copyright (c) Hyperion Entertainment and contributors.
UserDoc:Introduction to AmigaOS
Contents
AmigaOS, the flexible operating system
AmigaOS is an operating system. It is a program written specifically to operate a computer. It is the program the user will use to control the computer and the same program that is used by the computer to send feedback or results back to the user.
AmigaOS is designed with ease of use in mind. There are no stupid limitations like what can be found on other systems. As an example, the Amiga user can organise his/her data the way he/she likes (file hierarchy) and also organise his/her harddisk using long names and not just a letter (C:) or cryptic names (sda1).
Also the user does not need to instruct the operating system when he/she wants to shut the computer down. Why? Because if the user didn't start an action that writes to the disks then you can be sure there is no write running. AmigaOS does not do actions without the user knowing it. With AmigaOS the user controls the computer and not the other way around.
Since the first versions of AmigaOS, Amiga developers learnt how to optimise an application. It means they worked on their program to make it fast on the current hardware, instead of just hoping there would soon be a new powerful hardware to run their program.
AmigaOS platform targets
Whereas the older versions of AmigaOS would run on computer of the eighties, based on the 68k series of Motorola CPU, the current version runs on hardware based on a PowerPC processor. Basically these are the old Amiga computers (also called Classic Amigas) and the new generation Amiga computers. In this manual, we concentrate on newer hardware as these are the machines still manufactured. What is described here still apply to some extent to the Classic Amigas.
How to use AmigaOS?
You can use the AmigaOS system with a mouse and/or a keyboard but also by some other input devices the system can support. Another way to perform actions and get their result is to execute command scripts. They are a list of commands that will be executed. Each command will do an action.
There are different sets of commands you can use in scripts. There are AmigaDOS commands, AREXX commands or Python commands. Each of these language as its rules and you'll have to learn the one that suits better the actions you want to do.
The Shell
The Shell is a command line interface. You will need to enter commands using the keyboard. When a command is executed by the system, you will get the result of it.
The Workbench
The Workbench is the first thing you see when AmigaOS is fully started. It is the main place where you can control AmigaOS from. It will allow you to use your mouse to open programs, do actions or just to examine your disks and your data you stored on them. The Workbench is graphical interface between the user and the computer. Please see the section about the AmigaOS Workbench to learn more about it.
Scripts
You can create a script using a text editor. Then you will be able to run such script from the Workbench or from the shell (or from any other script).
What do you see in AmigaOS?
When AmigaOS is started, you see several graphical elements. Let's see what they are and how they are called in AmigaOS.
Icons
Icons are a small image which represents a disk, a directory or a file.
Windows
Windows are graphic areas which can contain different elements.
Screens
Screens are areas that contain windows.
Menus
Menus are lists of items that will allow you to control a specific program.
How is my data stored?
Files
Executable files
Programs you can start are stored in executable files. These are files with an executable bit, a flag that shows AmigaOS that such file will do something when started. An example is a music player. When you start this executable, the player opens and you can start playing music files.
Data files
Files that are not executable are data files. These contain some data that will be manipulated by programs. Some examples are a music file, a video file or a text document.
Directories/Drawers
In order to organise things a bit, files are not all of them in the same place. We create directories which like drawers of a cabinet will store different files of the same kind. The graphical interface of AmigaOS being called the Workbench, directories are often called drawers.
Disks, partitions and volumes
Disks
Disks are storage medium you can purchase on a computer store. We use them to store our files.
Partitions
A disk is often very big and many users prefer to make it more organised. This is done virtually splitting the disk into several smaller parts. This operation is known as creating partitions on a disk.
TODO: insert a disk image with partitions
Volumes
A partition is a physical area on a disk. To access it with AmigaOS we could read the physical data off the partition but it's not an easy way. To make it easier AmigaOS uses the concept of volumes. These are virtual representations of a partition. The volumes have a name so AmigaOS and therefore the user can access all files/directories stored on it in a very practical way: just by using its name.
AmigaOS components
AmigaOS is made of different components which have their own job in the system. The most important ones are mandatory. Without them the system does not even start. Other components are less important and the user can choose to use them or not. This is the case of drivers. For instance, a device driver may be omitted. If so, the corresponding device will just not work as AmigaOS will have no driver that allows it to know what to do with this device.
Kickstart modules
These components are the heart of AmigaOS. Their duties is to do graphics, to handle discs or to handle all reads/writes to files. Also one of them is the AmigaOS kernel which is some kind of director handling the work of all other components. You can find all these modules in the Kickstart directory in the system volume. Here is a list:
Mandatory modules
The following modules are required in any AmigaOS system. Without one of these, the system will not start.
- kernel - The kernel works like a conductor in an orchestra. Its job is to make everything works together. It creates processes, handle memory usage, defines the way other components will access peripherals...etc. Note that the AmigaOS kernel is not based on any other kernel. It is a self made kernel that works since 1983.
- loader - this component handles the loading of all other kickstart modules
- battclock.resource.kmod - this module handles reading/writing the battery backed up clock which is used on all computers to keep the date and time
- bootimage - this is the boot picture. It is displayed during the start sequence of AmigaOS
- bootmenu.kmod - this component handles the Early Startup Menu the use can use to define some settings before starting AmigaOS
- con-handler.kmod - it directs the read and write requests to the console window, to a serial AUX: device or any other supported interface
- console.device.kmod - it opens a window and reads/writes text to and from that window
- diskboot.kmod - handles the booting of AmigaOS from a supported disk
- diskboot.config - this is a text file experienced users can modify to change the boot behaviour of AmigaOS
- dos.library.kmod - this module is a collection of functions that any program can use to perform actions on disks, files and directories
- elf.library.kmod - handles the loading of executable programs
- env-handler.kmod - handles the read/writes of environment variables
- FileSystem.resource.kmod - handles the use of the different filesystems
- gadtools.library.kmod - collection of functions used to create all graphic objects like gadgets, sliders, menus...
- gameport.device.kmod - handles the read/writes of game pads and joysticks
- graphics.library.kmod - collection of functions used to draw graphic elements on the monitor
- hunk.library.kmod - set of functions to read a data stream into memory
- input.device.kmod - handles of input events like keyboard events or mouse clicks
- intuition.library.kmod - collection of functions to create and handle all graphic elements (screens, windows, the mouse pointer...)
- layers.library.kmod - set of functions to be used to handle different layers in graphic operations
- keyboard.device.kmod - driver for the keyboard
- keymap.library.kmod - functions to handle different keymaps
- newlib.library.kmod - collection of functions to perform memory operations (allocating memory, copying memory areas... )
- nonvolatile.library.kmod - provides a simple means for an application developer to manage nonvolatile storage
- nvram.resource.kmod - handles the read/writes to the EEPROM chip present on many AmigaOS computers
- PCIGraphics.card - driver that supports the use of different graphic cards
- ram-handler.kmod - functions that handles the Ram disk: special disk
- ramdrive.device.kmod - device that allows the usage of the ramdrive device RAD: disk
- ramlib.kmod - loads disk based libraries and devices for exec.library
- rtg.library - library of functions perform lowlevel graphic operations on graphic cards
- shell.kmod - the AmigaOS command line interface
- strap.kmod - module that handles booting on different disk devices
- timer.device.kmod - driver to give access to timing functions
Filesystem support
These kickstart modules can be loaded or left aside. If you want to use a particular filesystem on your disk partitions, you need to load the corresponding filesystem module.
- CDFileSystem - handles the CD-ROM disks with data stored in different formats: ISO9660, HFS...
- SmartFilesystem - allows to store data on partitions in SFS0 and SFS2
- JXFileSystem - allows to create partitions in JXFS
- FastFileSystem - allows the usage of partitions in FFS and FFS2 layouts
- diskcache.library.kmod - component required by the SmartFileSystem and JXFileSystem modules
Hardware drivers
Graphic cards drivers
- 3dfxVoodoo.chip
- 3DLabsPermedia2.chip
- ATIRadeon.chip
- RadeonHD.chip
- siliconmotion502.chip
Disk drivers
- it8212ide.device.kmod
- lsi53c8xx.device.kmod
- sam460sata.device.kmod
- sii3112ide.device.kmod
- sii3512ide.device.kmod
- sii3114ide.device.kmod
- sii0680ide.device.kmod
- sii3132ide.device.kmod
USB drivers
- hub.usbfd
- usbsys.device
- usbresource.library
- ehci.usbhcd
- ohci.usbhcd
- uhci.usbhcd
- massstorage.usbfd
Other drivers
- bootkeyboard.usbfd - allows a USB keyboard to be used even before the USB stack is loaded
- bootmouse.usbfd - allows a USB mouse to be used even before the USB stack is loaded
- fpga.resource.kmod - allows to use the FPGA components which are present on some Amiga computers
- i2c.resource.kmod - allows to use the i2c interface present on some Amiga computers
- xena.resource.kmod - provides access to the Xena chip on the AmigaOne X1000
Misc modules
- petunia.library.kmod - this module contains the Just-In-Time emulator that allows AmigaOS to run programs made for the Motorola 68k processor
System components
Beside the kickstart modules, AmigaOS uses many different components that can be loaded only when used. These files are stored in different directories in the system volume. Here is described a default AmigaOS installation.
- C
This directory contains AmigaDOS Commands
- Classes
contains different object elements easy to be used in any program: gadgets, requesters, graphic table, windows...
- Devs
contains definition for Devices
- Emulation
contains files used for the 68k emulation (though E-UAE)
- Fonts
contains various systems fonts
- Internet
contains a dialer to connect to Internet
- Kickstart
contains the kickstart modules
- L
contains handlers and filesystems
- Libs
contains dynamic Librairies of functions
- Locale
contains all files used to localise the system (catalogs, keymaps...)
- MUI
contains the needed files for programs that use the MUI third party graphic interface
- Prefs
contains the preference programs used to customise AmigaOS
- S
contains the Scripts
- SObjs
contains .so object files
- Storage
contains other optional files
- System
contains some programs used by the system itself (i.e. you don't need to run them yourself) or low-level programs like disk tools
- Utilities
contains several utilities
AmigaOS boot procedure
Basically a computer with AmigaOS does the following when the power button is pushed:
- the BIOS of the computer initialises the hardware
- the BIOS looks on the harddisk and finds a file called the Second Level Booter (SLB)
- the SLB will then analyses all Amiga partitions and load each system configuration it finds
- the SLB loads the kickstart files of the selected configuration
- the kickstart files are executed, AmigaOS becomes alive
- the file Startup-sequence is executed and with it all commands it contains
- the Workbench is started
At this point the user can use his/her computer.