Search by property

This page provides a simple browsing interface for finding entities described by a property and a named value. Other available search interfaces include the page property search, and the ask query builder.

List of results

Arguments Exercise + (Exercise on using pointers to retrieve arguments passed to a process.)
Shared memory Exercise + (Exercise to illustrate that memory can be private to a process or shared between processes. This also illustrates memory mapping when a shared location may appear at different addresses in different processes.)
Structs Exercise + (Exercise to review data structures and build and destroy these in C.)
Files + (Files are a form of (usually persistent) memory which are not, generally, directly addressable by the processor hardware.)
Disks + (For many years the magnetic disk has been … For many years the magnetic disk has been the choice for backing store - i.e. ‘memory’ which is not directly addressable by a processor. This is typically, but not always exclusively, for files. Sometimes other technologies are (inaccurately) called “disks” too!ies are (inaccurately) called “disks” too!)
Fragmentation + (Fragmentation is when something - such as a file - which would be nice to have as one big item has been split into several smaller parts.)
Memory Mapped Files + (Gaining access to files by making them appear as arrays in the address space.)
SETUID + (Granting permission whilst maintaining security.)
Fork Unix + (How Unix processes can create more Unix processes.)
File Systems + (How files are organised.)
File Access + (How files may be written and read.)
Daemons + (In Unix, a daemon is a background process belonging to the system.)
Unix Signals + (In Unix, a set of “signals” allow system-level inter-process communication. For example, this allows one process to destroy another (permissions permitting). A target process can intercept and handle most signals in its own way.)
Shell + (In Unix, the software which provides a command line interface - and more.)
Links + (In this context, means of connecting a file tree structure into a directed graph.)
Memory Protection + (Increasing security by limiting access to various memory areas. This includes preventing one process from corrupting any others' spaces.)
Environment Variables + (Information about Unix command-line interfaces.)
Shared Memory + (Issues connected with memory made visible to more than one process.)
Memory + (Memory is the fundamental element in conventional contemporary computers, (apparently) containing all the code and data of executing programs. Its management as a resource is a fundamental task.)
Metadata + (Metadata provides information about the ‘main’ data.)
Using Peripherals + (Methods by which the software can communicate with the I/O devices.)
Mutual exclusion + (Mutual exclusion means “one at a time”. In this case it is largely about only allowing one of many possible threads to change some structure or I/O device.)
Pointers + (Not restricted to OS code, pointers are used in all computer programming. They are used extensively in (and around) an OS and a thorough understanding is important.)
System Calls + (OS provided calls that provide privileged, protected services using trusted code. Used to provide access to I/O devices, system variables etc.)
Virtual Machines + (One 'box' can apparently be several independent computers.)

Virtual Networks + (One wire can support several independent connections.)

Monitoring page behaviour + (Optimisations can require the collection of information about behaviour. This looks at some approaches to finding the information using limited hardware support.)
PATH + (Ordered lists of places to look for something.)
Pipes + (Pipes are a convenient means of allowing processes to communicate. One process sends output into a pipe and another can read it from the other end when it wants to.)
Processes + (Processes are running programs. Many computers run - or appear to run - many processes simultaneously.)
File Locking + (Protecting files from confusion.)
Real Time + (Real time systems are those where a late answer is always a wrong answer. It is a requirement in, for example, control systems such as autonomous vehicles.)
Page Eviction + (Schemes for deciding/predicting which parts of memory are not really wanted too much, and won't be in the (near) future).)
Concepts + (Some 'highlight' principles which are widely applicable to operating systems and a range of other computing applications.)
Shell Scripting + (Some examples of jobs which can be done easily with simple ‘command line’ scripts.)
Bibliography + (Some further reading in a more "conventional" form.)
Interprocess Communication + (Some high-level notes on how two or more independent processes may communicate.)
Pointer Exercise + (Some practice (for beginners in C) in how to get at memory 'directly'.)
Software Exceptions + (Some processors will trap to the O.S. when the processor encounters an execution anomaly - e.g. division by zero.)
Errors + (Some run time errors are unavoidable. They should still be considered and handled in a defined way.)
Operation Ordering + (Sometimes the order in which operations are performed is vitally important - especially in a multi-threaded environment.)
Atomicity + (Sometimes two (or more) operations need to be performed 'simultaneously'. Since software cannot do this there need to be mechanisms to ensure no outside operations interfere.)
Process Priority + (Sometimes, some processes may be more important or urgent than others. Priority schemes can provide a greater share of resources (particularly processor time) for selected tasks. This can be particularly important in real-time systems.)
Introduction to Operating Systems + (Start here! This links to the major, top-level concepts.)
Acknowledgements + (Thanks to contributors to this site.)
Application Binary Interface (ABI) + (The Application Binary Interface specifies the way software elements communicate within a program.)
Synchronisation + (The act of collecting together disparate threads so all are at definitive points in their execution.)
Process States + (The basic data behind scheduling processes.)
Kernel + (The central, essential part of an operating system. Approaches vary.)
Context + (The context is the state of a running process.)
Paging + (The mechanism by which memory mapping is usually managed.)