Operating Systems Basics Quiz

Operating System Structures

• Operating systems provide an environment for program execution and services to programs and users.
• A set of operating-system services provides helpful functions for users.
• User interface: Almost all operating systems have a user interface (UI) that varies between command-line interfaces (CLIs), graphical user interfaces (GUIs), and batch interfaces.
• Program execution: Operating systems load programs into memory, run them, and end execution, either normally or abnormally (indicating an error).
• I/O operations: Running programs often require input/output (I/O). I/O may involve files or I/O devices.
• File-system manipulation: Programs interact with the file system, reading and writing files and directories, creating and deleting them, searching files, listing file information, and managing permissions.
• Communications: Processes exchange information on a computer or between computers over a network. Communication can occur via shared memory or through messages (packets moved by the OS).
• Error detection: Operating systems need to be aware of potential errors, including those in CPU and memory hardware, I/O devices, and user programs.
• Resource allocation: Multiple users or jobs running concurrently necessitate resource allocation procedures for resources such as CPU cycles, main memory, and file storage. Other resources (such as I/O devices) may use general request and release code.
• Protection and security: Owners of information stored in multiuser or networked systems may want to control how that information is used and prevent interfering processes.
• Accounting: Keeping track of resource use by users for different kinds of computer resources.

System Calls

• A system call is the interface to OS services. The API is an interface to system calls. APIs allow for program portability.
• Three common APIs:
  • Win32 API for Windows
  • POSIX for POSIX-based systems
  • Java API for the Java Virtual Machine (JVM)
• Program portability—the ability of a program to run on any system supporting the same API.
• Ease of use—system calls are sometimes more detailed and difficult to work with than available APIs for application programmers. API names are usually generic.

Types of System Calls

• Process control: Ending, executing, creating, terminating processes, getting and setting process attributes, waiting for time, or waiting for/signaling an event.
• File management: Creating, deleting, opening, closing files, reading, writing, repositioning within files, and getting/setting file attributes.
• Device management: Requesting and releasing devices, reading/writing/repositioning within devices, getting/setting device attributes, logicly attaching and detaching devices.
• Information maintenance: Getting/setting the time, date, system data, process, file, or device attributes.
• Communications: Creating/deleting communication connections, sending/receiving messages, and transferring status information to/from remote devices.

System Programs

• System programs provide a convenient environment for program development and execution.
• These programs are divided into:
  • File manipulation: Creating, deleting, copying, renaming, printing, dumping, listing, and generally manipulating files and directories.
  • Status information: Providing system information like date, time, available memory, disk space, number of users, performance information, logging information and debugging information.
  • Programming-language support: Compilers, assemblers, debuggers, and interpreters are sometimes directly provided.
  • Program loading and execution: Absolute loaders, relocatable loaders, linkage editors, and overlay loaders are part of program loading and execution support. Debugging systems are used for higher-level and machine-language programs.
  • Communications: Creating virtual connections among processes, users, and computer systems. This allows users to send messages, browse web pages, send electronic mail, log in remotely, and transfer files between machines.
  • Application programs: Other programs that are part of an operating system.

Operating System Design and Implementation

• Design and implementation of operating systems isn't solvable, but some approaches have proven successful.
• Internal structures of operating systems can vary widely.
• The choice of hardware and the type of system (e.g., desktop, laptop, mobile, distributed) can affect the design.
• User goals: Ease of use, fast response, reliability, and safety.
• System goals: Flexibility, reliability, maintainability, and efficiency.
• Mechanism vs. policy: separating what will be done (policy) from how it will be done (mechanism). The principle of separation allows maximum flexibility if policy decisions need to be changed.

Operating System Implementation

• OSes may be implemented in assembly language or using a combination of higher-level languages. System programs may be written in C/C++, higher-level languages or shell scripts.
• Lower levels are often implemented using assembly language for speed/efficiency and compactness.
• High-level languages are used for program development and debugging.
• Speed of execution is an area of concern for programming-language support.

OS Structures

• Simple structure: MS-DOS is an example. Not divided into modules, application programs can directly access hardware. Not well-structured, protected, or defined.
• UNIX: Limited by functionality, the original had limited structuring. Separable parts include systems programs and kernels.
• Monolithic structure: Many parts and functions combined in one kernel in operating systems like UNIX. Debugging is difficult.
• Layered structure: OS is divided into layers. Bottom layer is the hardware, top layer (level N) is the user interface. Inner layers hide details of outer layers.
• Microkernel structure: Removes non-essential services from the kernel, making the kernel smaller. Communication is via message passing. More reliable, easier to extend and port to other architectures. Considers performance overhead of different components.
• Modular structure: Uses an object-oriented approach. Each core component is separate. Core components communicate through known interfaces, are loadable as needed, and are similar to layered approaches.
• Virtual machines abstract the hardware of a single computer into multiple execution environments. Virtual machines treat the hardware and kernel like hardware. A host operating system creates an illusion of a process with its own CPU and virtual memory.

Operating System Debugging

• Debugging involves finding and fixing errors (bugs).
• OSes create log files for error information.
• An application failure may cause a core dump, capturing the memory contents of the process.
• Operating system errors may create crash dumps containing kernel memory.
• Performance tuning optimization can be used to improve system performance.
• Debugging is considered twice as hard as the initial writing of code. Clever programming may result in harder debugging.
• Some systems provide live instrumentation (e.g., DTrace in Solaris, FreeBSD).
• Probes capture a system's data which may be used to diagnose issues.

Operating System Generation

• OSes can be designed to run on various computer types
• SYSGEN programs obtain hardware configurations to generate the specific OS for a specific machine (e.g., CPU speed/type, available memory types/amount, devices interfaced).
• Bootstrapping involves starting a computer by loading the kernel, where a bootstrap program is stored in ROM and locates the kernel.
• The kernel is loaded into memory, and its execution is started.

System Boot

• The OS must be available for the hardware to start.
• Bootstrap loader is a small piece of code that locates the kernel, loads it into memory, and starts its execution.
• Bootstrap loaders sometimes consist of multiple parts.
• Execution starts at a fixed location in memory, and firmware is used to hold the initial boot code.