Download Operating System Services and System Calls: An Overview and more Lecture notes Operating Systems in PDF only on Docsity!
2.0 Operating-System Structures References:
- Abraham Silberschatz, Greg Gagne, and Peter Baer Galvin, "Operating System Concepts, Ninth Edition ", Chapter 2 This chapter deals with how operating systems are structured and organized. Different design issues and choices are examined and compared, and the basic structure of several popular OSes are presented. 2.1 Operating-System Services Figure 2.1 - A view of operating system services OSes provide environments in which programs run, and services for the users of the system, including: User Interfaces - Means by which users can issue commands to the system. Depending on the system these may be a command-line interface (e.g. sh, csh, ksh, tcsh, etc.), a GUI interface (e.g. Windows, X-Windows, KDE, Gnome, etc.), or a batch command systems. The latter are generally older systems using punch cards of job-control language, JCL, but may still be used today for specialty systems designed for a single purpose. Program Execution - The OS must be able to load a program into RAM, run the program, and terminate the program, either normally or abnormally. I/O Operations - The OS is responsible for transferring data to and from I/O devices, including keyboards, terminals, printers, and storage devices. File-System Manipulation - In addition to raw data storage, the OS is also responsible for maintaining directory and subdirectory structures, mapping file names to specific blocks of data storage, and providing tools for navigating and utilizing the file system.
Communications - Inter-process communications, IPC, either between processes running on the same processor, or between processes running on separate processors or separate machines. May be implemented as either shared memory or message passing, (or some systems may offer both.) Error Detection - Both hardware and software errors must be detected and handled appropriately, with a minimum of harmful repercussions. Some systems may include complex error avoidance or recovery systems, including backups, RAID drives, and other redundant systems. Debugging and diagnostic tools aid users and administrators in tracing down the cause of problems. Other systems aid in the efficient operation of the OS itself: Resource Allocation - E.g. CPU cycles, main memory, storage space, and peripheral devices. Some resources are managed with generic systems and others with very carefully designed and specially tuned systems, customized for a particular resource and operating environment. Accounting - Keeping track of system activity and resource usage, either for billing purposes or for statistical record keeping that can be used to optimize future performance. Protection and Security - Preventing harm to the system and to resources, either through wayward internal processes or malicious outsiders. Authentication, ownership, and restricted access are obvious parts of this system. Highly secure systems may log all process activity down to excruciating detail, and security regulation dictate the storage of those records on permanent non-erasable medium for extended times in secure (off-site) facilities. 2.2 User Operating-System Interface 2.2.1 Command Interpreter Gets and processes the next user request, and launches the requested programs. In some systems the CI may be incorporated directly into the kernel. More commonly the CI is a separate program that launches once the user logs in or otherwise accesses the system. UNIX, for example, provides the user with a choice of different shells, which may either be configured to launch automatically at login, or which may be changed on the fly. (Each of these shells uses a different configuration file of initial settings and commands that are executed upon startup.) Different shells provide different functionality, in terms of certain commands that are implemented directly by the shell without launching any external programs. Most provide at least a rudimentary command interpretation structure for use in shell script programming (loops, decision constructs, variables, etc.) An interesting distinction is the processing of wild card file naming and I/O re- direction. On UNIX systems those details are handled by the shell, and the program which is launched sees only a list of filenames generated by the shell from the wild cards. On a DOS system, the wild cards are passed along to the programs, which can interpret the wild cards as the program sees fit.
Figure 2.3 - The iPad touchscreen 2.2.3 Choice of interface Most modern systems allow individual users to select their desired interface, and to customize its operation, as well as the ability to switch between different interfaces as needed. System administrators generally determine which interface a user starts with when they first log in. GUI interfaces usually provide an option for a terminal emulator window for entering command-line commands. Command-line commands can also be entered into shell scripts, which can then be run like any other programs.
Figure 2.4 - The Mac OS X GUI 2.3 System Calls System calls provide a means for user or application programs to call upon the services of the operating system. Generally written in C or C++, although some are written in assembly for optimal performance. Figure 2.4 illustrates the sequence of system calls required to copy a file:
The use of APIs instead of direct system calls provides for greater program portability between different systems. The API then makes the appropriate system calls through the system call interface, using a table lookup to access specific numbered system calls, as shown in Figure 2.6:
Figure 2.6 - The handling of a user application invoking the open( ) system call Parameters are generally passed to system calls via registers, or less commonly, by values pushed onto the stack. Large blocks of data are generally accessed indirectly, through a memory address passed in a register or on the stack, as shown in Figure 2.7: Figure 2.7 - Passing of parameters as a table 2.4 Types of System Calls Six major categories, as outlined in Figure 2.8 and the following six subsections:
Standard library calls may also generate system calls, as shown here:
2.4.1 Process Control Process control system calls include end, abort, load, execute, create process, terminate process, get/set process attributes, wait for time or event, signal event, and allocate and free memory. Processes must be created, launched, monitored, paused, resumed,and eventually stopped. When one process pauses or stops, then another must be launched or resumed When processes stop abnormally it may be necessary to provide core dumps and/or other diagnostic or recovery tools. Compare DOS ( a single-tasking system ) with UNIX ( a multi-tasking system ). o When a process is launched in DOS, the command interpreter first unloads as much of itself as it can to free up memory, then loads the process and transfers control to it. The interpreter does not resume until the process has completed, as shown in Figure 2.9:
Figure 2.10 - FreeBSD running multiple programs 2.4.2 File Management File management system calls include create file, delete file, open, close, read, write, reposition, get file attributes, and set file attributes. These operations may also be supported for directories as well as ordinary files. (The actual directory structure may be implemented using ordinary files on the file system, or through other means. Further details will be covered in chapters 11 and 12.) 2.4.3 Device Management Device management system calls include request device, release device, read, write, reposition, get/set device attributes, and logically attach or detach devices. Devices may be physical (e.g. disk drives), or virtual / abstract (e.g. files, partitions, and RAM disks). Some systems represent devices as special files in the file system, so that accessing the "file" calls upon the appropriate device drivers in the OS. See for example the /dev directory on any UNIX system. 2.4.4 Information Maintenance Information maintenance system calls include calls to get/set the time, date, system data, and process, file, or device attributes. Systems may also provide the ability to dump memory at any time, single step programs pausing execution after each instruction, and tracing the operation of programs, all of which can help to debug programs. 2.4.5 Communication Communication system calls create/delete communication connection, send/receive messages, transfer status information, and attach/detach remote devices.
The message passing model must support calls to: o Identify a remote process and/or host with which to communicate. o Establish a connection between the two processes. o Open and close the connection as needed. o Transmit messages along the connection. o Wait for incoming messages, in either a blocking or non-blocking state. o Delete the connection when no longer needed. The shared memory model must support calls to: o Create and access memory that is shared amongst processes (and threads.) o Provide locking mechanisms restricting simultaneous access. o Free up shared memory and/or dynamically allocate it as needed. Message passing is simpler and easier, (particularly for inter-computer communications), and is generally appropriate for small amounts of data. Shared memory is faster, and is generally the better approach where large amounts of data are to be shared, ( particularly when most processes are reading the data rather than writing it, or at least when only one or a small number of processes need to change any given data item. ) 2.4.6 Protection Protection provides mechanisms for controlling which users / processes have access to which system resources. System calls allow the access mechanisms to be adjusted as needed, and for non- privileged users to be granted elevated access permissions under carefully controlled temporary circumstances. Once only of concern on multi-user systems, protection is now important on all systems, in the age of ubiquitous network connectivity. 2.5 System Programs System programs provide OS functionality through separate applications, which are not part of the kernel or command interpreters. They are also known as system utilities or system applications. Most systems also ship with useful applications such as calculators and simple editors, (e.g. Notepad). Some debate arises as to the border between system and non-system applications. System programs may be divided into these categories: o File management - programs to create, delete, copy, rename, print, list, and generally manipulate files and directories. o Status information - Utilities to check on the date, time, number of users, processes running, data logging, etc. System registries are used to store and recall configuration information for particular applications. o File modification - e.g. text editors and other tools which can change file contents.
data / configuration files. For example the relative priority of background versus foreground tasks. 2.6.3 Implementation Traditionally OSes were written in assembly language. This provided direct control over hardware-related issues, but inextricably tied a particular OS to a particular HW platform. Recent advances in compiler efficiencies mean that most modern OSes are written in C, or more recently, C++. Critical sections of code are still written in assembly language, (or written in C, compiled to assembly, and then fine-tuned and optimized by hand from there.) Operating systems may be developed using emulators of the target hardware, particularly if the real hardware is unavailable (e.g. not built yet), or not a suitable platform for development, (e.g. smart phones, game consoles, or other similar devices.) 2.7 Operating-System Structure For efficient performance and implementation an OS should be partitioned into separate subsystems, each with carefully defined tasks, inputs, outputs, and performance characteristics. These subsystems can then be arranged in various architectural configurations: 2.7.1 Simple Structure When DOS was originally written its developers had no idea how big and important it would eventually become. It was written by a few programmers in a relatively short amount of time, without the benefit of modern software engineering techniques, and then gradually grew over time to exceed its original expectations. It does not break the system into subsystems, and has no distinction between user and kernel modes, allowing all programs direct access to the underlying hardware. (Note that user versus kernel mode was not supported by the 8088 chip set anyway, so that really wasn't an option back then.)
Figure 2.11 - MS-DOS layer structure The original UNIX OS used a simple layered approach, but almost all the OS was in one big layer, not really breaking the OS down into layered subsystems: Figure 2.12 - Traditional UNIX system structure 2.7.2 Layered Approach Another approach is to break the OS into a number of smaller layers, each of which rests on the layer below it, and relies solely on the services provided by the next lower layer. This approach allows each layer to be developed and debugged independently, with the assumption that all lower layers have already been debugged and are trusted to deliver proper services. The problem is deciding what order in which to place the layers, as no layer can call upon the services of any higher layer, and so many chicken-and-egg situations may arise.
Figure 2.14 - Architecture of a typical microkernel 2.7.4 Modules Modern OS development is object-oriented, with a relatively small core kernel and a set of modules which can be linked in dynamically. See for example the Solaris structure, as shown in Figure 2.13 below. Modules are similar to layers in that each subsystem has clearly defined tasks and interfaces, but any module is free to contact any other module, eliminating the problems of going through multiple intermediary layers, as well as the chicken- and-egg problems. The kernel is relatively small in this architecture, similar to microkernels, but the kernel does not have to implement message passing since modules are free to contact each other directly. Figure 2.15 - Solaris loadable modules
2.7.5 Hybrid Systems Most OSes today do not strictly adhere to one architecture, but are hybrids of several. 2.7.5.1 Mac OS X The Max OSX architecture relies on the Mach microkernel for basic system management services, and the BSD kernel for additional services. Application services and dynamically loadable modules ( kernel extensions ) provide the rest of the OS functionality: Figure 2.16 - The Mac OS X structure 2.7.5.2 IOS The iOS operating system was developed by Apple for iPhones and iPads. It runs with less memory and computing power needs than Max OS X, and supports touchscreen interface and graphics for small screens: Figure 2.17 - Architecture of Apple's iOS. 2.7.5.3 Android
