Operating System Services and System Calls

Operating System Services

• Operating systems provide an environment for program execution and services for programs and users.
• Services beneficial to users include:
  • User interfaces (command-line, GUI, batch).
  • Program execution (loading, running, ending).
  • I/O operations (file and device access).
  • File system manipulation (reading, writing, managing directories and permissions).
  • Communications (information exchange, shared memory, message passing).
  • Error detection and handling.
  • Debugging facilities.
• Services beneficial to the system include:
  • Resource allocation (CPU, memory, storage).
  • Accounting (tracking resource usage).
  • Protection and security (controlling access, preventing interference).

System Calls

• System calls are programming interfaces to OS services.
• They are written in high-level languages (e.g., C, C++).
• System call interactions are managed through an interface table indexed by system call numbers.
• The caller (program) interacts with the OS via API, which in turn uses libraries for low-level execution.
• Three common methods for parameter passing to the OS include: registers, memory blocks, and stack.

System Programs

• System programs provide an environment for program development and execution.
• Categories include:
  • File management (creating, deleting, copying files).
  • Status information (system resources, user activity).
  • File modification (editing, searching files).
  • Programming language support (compilers, assemblers).
  • Program loading and execution (loaders, debuggers).
  • Communications (network interactions).

Operating System Design and Implementation

• Operating system design is influenced by internal structure, defined goals, and hardware specifications.
• Design goals include user convenience, reliability, safety, and speed, as well as ease of design, implementation, maintenance, flexibility, reliability, and error-free execution.
• System calls are typically accessed via APIs for programmer convenience.
• API differences from system calls: API is the interface to system calls, simplifying programming.
• Common APIs include Win32, POSIX, and Java.
• APIs improve program portability (reliability in running on different systems supporting similar APIs).
• Key OS principles include separating policy and mechanism for flexibility, and ease of use, abstracting system calls.

System Call Implementation

• Associated with each system call is a number.
• The system call interface is a table indexed by system call numbers, invoking the intended OS kernel system call and returning a status and any return value.
• Programs don't need to know about system call implementation details; they only interact with APIs that simplify task complexity.

Virtual Machines

• Virtualization creates duplicate hardware environments.
• Virtualization implementation occurs in user mode, creating virtual user and kernel modes.
• Challenges include providing a perfect hardware duplicate and performance timing issues.
• Virtualization performance depends on hardware support; better support results in faster execution.
• Virtual machines share hardware resources while providing protection and controlled file-sharing.
• Uses include development, testing, and resource consolidation.

Bootstrap Programs and Booting

• Bootstrapping involves loading the OS kernel into memory and starting its execution, via ROM-resident code.
• Boot blocks in two-stage boot processes load bootloaders.
• OS configuration data is gathered during start-up, customizing OS for the specific hardware.
• Booting begins with fixed-memory address execution, controlled by firmware.

History and Benefits of Virtual Machines

• Virtual machine concepts originated in an IBM mainframe in 1972.
• Benefits include enabling multiple OS environments on the same hardware, protection, and controlled resource sharing for development, testing, and system consolidation.

Debugging

• Debugging finds and fixes errors (bugs) and optimizes performance.
• Log files contain error information.
• Application crashes result in core dump files (process memory).
• OS crashes result in crash dump files (kernel memory).
• Kernighan's Law states debugging is harder than coding; careful coding aids debugging.

Operating System Structures

• Operating systems may have simple (e.g., MS-DOS), monolithic (e.g., traditional Unix), layered, or microkernel structures.
• The choice of structure influences modularity, interfaces, and kernel size.
• Structures impact programming and maintenance complexities.
• Modularity and well-defined interfaces enhance extensibility and maintainability.