Operating system

Operating systems
Common features
Process management Interrupts Memory management File system Device drivers Networking Security Input/output
v t e

An operating system (OS) is system software that manages computer hardware and software resources, and provides common services for computer programs.

As of September 2024[update], Android is the most popular operating system with a 46% market share, followed by Microsoft Windows at 26%, iOS and iPadOS at 18%, macOS at 5%, and Linux at 1%. Android, iOS, and iPadOS are mobile operating systems, while Windows, macOS, and Linux are desktop operating systems.^[3] Linux distributions are dominant in the server and supercomputing sectors. Other specialized classes of operating systems (special-purpose operating systems),^[4][5] such as embedded and real-time systems, exist for many applications. Security-focused operating systems also exist. Some operating systems have low system requirements (e.g. light-weight Linux distribution). Others may have higher system requirements.

Some operating systems require installation or may come pre-installed with purchased computers (

An operating system is difficult to define,[6] but has been called "the layer of software that manages a computer's resources for its users and their applications".^[7] Operating systems include the software that is always running, called a kernel—but can include other software as well.^[6][8] The two other types of programs that can run on a computer are system programs—which are associated with the operating system, but may not be part of the kernel—and applications—all other software.^[8]

There are three main purposes that an operating system fulfills:^[9]

• Operating systems allocate resources between different applications, deciding when they will receive central processing unit (CPU) time or space in memory.^[9] On modern personal computers, users often want to run several applications at once. In order to ensure that one program cannot monopolize the computer's limited hardware resources, the operating system gives each application a share of the resource, either in time (CPU) or space (memory).^[10][11] The operating system also must isolate applications from each other to protect them from errors and security vulnerabilities in another application's code, but enable communications between different applications.^[12]
• Operating systems provide an interface that abstracts the details of accessing hardware details (such as physical memory) to make things easier for programmers.^[9][13] Virtualization also enables the operating system to mask limited hardware resources; for example, virtual memory can provide a program with the illusion of nearly unlimited memory that exceeds the computer's actual memory.^[14]
• Operating systems provide common services, such as an interface for accessing network and disk devices. This enables an application to be run on different hardware without needing to be rewritten.^[15] Which services to include in an operating system varies greatly, and this functionality makes up the great majority of code for most operating systems.^[16]

With

A real-time operating system is an operating system that guarantees to process events or data by or at a specific moment in time. Hard real-time systems require exact timing and are common in manufacturing, avionics, military, and other similar uses.^[28] With soft real-time systems, the occasional missed event is acceptable; this category often includes audio or multimedia systems, as well as smartphones.^[28] In order for hard real-time systems be sufficiently exact in their timing, often they are just a library with no protection between applications, such as eCos.^[28]

A hypervisor is an operating system that runs a virtual machine. The virtual machine is unaware that it is an application and operates as if it had its own hardware.^[14][29] Virtual machines can be paused, saved, and resumed, making them useful for operating systems research, development,^[30] and debugging.^[31] They also enhance portability by enabling applications to be run on a computer even if they are not compatible with the base operating system.^[14]

A library operating system (libOS) is one in which the services that a typical operating system provides, such as networking, are provided in the form of libraries and composed with a single application and configuration code to construct a unikernel: ^[32] a specialized (only the absolute necessary pieces of code are extracted from libraries and bound together ^[33]), single address space, machine image that can be deployed to cloud or embedded environments.

The operating system code and application code are not executed in separated protection domains (there is only a single application running, at least conceptually, so there is no need to prevent interference between applications) and OS services are accessed via simple library calls (potentially inlining them based on compiler thresholds), without the usual overhead of context switches, ^[34] in a way similarly to embedded and real-time OSes. Note that this overhead is not negligible: to the direct cost of mode switching it's necessary to add the indirect pollution of important processor structures (like CPU caches, the instruction pipeline, and so on) which affects both user-mode and kernel-mode performance. ^[35]

The first computers in the late 1940s and 1950s were directly programmed either with

The invention of

The kernel is the part of the operating system that provides

The operating system provides an interface between an application program and the computer hardware, so that an application program can interact with the hardware only by obeying rules and procedures programmed into the operating system. The operating system is also a set of services which simplify development and execution of application programs. Executing an application program typically involves the creation of a process by the operating system kernel, which assigns memory space and other resources, establishes a priority for the process in multi-tasking systems, loads program binary code into memory, and initiates execution of the application program, which then interacts with the user and with hardware devices. However, in some systems an application can request that the operating system execute another application within the same process, either as a subroutine or in a separate thread, e.g., the LINK and ATTACH facilities of OS/360 and successors.

An interrupt (also known as an abort, exception, fault, signal,^[52] or trap)^[53] provides an efficient way for most operating systems to react to the environment. Interrupts cause the central processing unit (CPU) to have a control flow change away from the currently running program to an interrupt handler, also known as an interrupt service routine (ISR).^[54][55] An interrupt service routine may cause the central processing unit (CPU) to have a context switch.^[56][a] The details of how a computer processes an interrupt vary from architecture to architecture, and the details of how interrupt service routines behave vary from operating system to operating system.^[57] However, several interrupt functions are common.^[57] The architecture and operating system must:^[57]

1. transfer control to an interrupt service routine.
2. save the state of the currently running process.
3. restore the state after the interrupt is serviced.

A software interrupt is a message to a process that an event has occurred.^[52] This contrasts with a hardware interrupt — which is a message to the central processing unit (CPU) that an event has occurred.^[58] Software interrupts are similar to hardware interrupts — there is a change away from the currently running process.^[59] Similarly, both hardware and software interrupts execute an interrupt service routine.

Software interrupts may be normally occurring events. It is expected that a time slice will occur, so the kernel will have to perform a context switch.^[60] A computer program may set a timer to go off after a few seconds in case too much data causes an algorithm to take too long.^[61]

Software interrupts may be error conditions, such as a malformed machine instruction.^[61] However, the most common error conditions are division by zero and accessing an invalid memory address.^[61]

Users can send messages to the kernel to modify the behavior of a currently running process.^[61] For example, in the command-line environment, pressing the interrupt character (usually Control-C) might terminate the currently running process.^[61]

To generate software interrupts for x86 CPUs, the INT assembly language instruction is available.^[62] The syntax is INT X, where X is the offset number (in hexadecimal format) to the interrupt vector table.

To generate software interrupts in Unix-like operating systems, the kill(pid,signum) system call will send a signal to another process.^[63] pid is the process identifier of the receiving process. signum is the signal number (in mnemonic format)^[b] to be sent. (The abrasive name of kill was chosen because early implementations only terminated the process.)^[64]

In Unix-like operating systems, signals inform processes of the occurrence of asynchronous events.^[63] To communicate asynchronously, interrupts are required.^[65] One reason a process needs to asynchronously communicate to another process solves a variation of the classic reader/writer problem.^[66] The writer receives a pipe from the shell for its output to be sent to the reader's input stream.^[67] The command-line syntax is alpha | bravo. alpha will write to the pipe when its computation is ready and then sleep in the wait queue.^[68] bravo will then be moved to the ready queue and soon will read from its input stream.^[69] The kernel will generate software interrupts to coordinate the piping.^[69]

Signals may be classified into 7 categories.^[63] The categories are:

1. when a process finishes normally.
2. when a process has an error exception.
3. when a process runs out of a system resource.
4. when a process executes an illegal instruction.
5. when a process sets an alarm event.
6. when a process is aborted from the keyboard.
7. when a process has a tracing alert for debugging.

Input/output (I/O) devices are slower than the CPU. Therefore, it would slow down the computer if the CPU had to wait for each I/O to finish. Instead, a computer may implement interrupts for I/O completion, avoiding the need for polling or busy waiting.^[70]

Some computers require an interrupt for each character or word, costing a significant amount of CPU time. Direct memory access (DMA) is an architecture feature to allow devices to bypass the CPU and access main memory directly.^[71] (Separate from the architecture, a device may perform direct memory access^[c] to and from main memory either directly or via a bus.)^[72][d]

This section needs expansion. You can help by making an edit requestadding to it . (April 2022)

When a computer user types a key on the keyboard, typically the character appears immediately on the screen. Likewise, when a user moves a mouse, the cursor immediately moves across the screen. Each keystroke and mouse movement generates an interrupt called Interrupt-driven I/O. An interrupt-driven I/O occurs when a process causes an interrupt for every character^[72] or word^[73] transmitted.

Devices such as hard disk drives, solid-state drives, and magnetic tape drives can transfer data at a rate high enough that interrupting the CPU for every byte or word transferred, and having the CPU transfer the byte or word between the device and memory, would require too much CPU time. Data is, instead, transferred between the device and memory independently of the CPU by hardware such as a channel or a direct memory access controller; an interrupt is delivered only when all the data is transferred.^[74]

If a computer program executes a system call to perform a block I/O write operation, then the system call might execute the following instructions:

• Set the contents of the CPU's registers (including the program counter) into the process control block.^[75]
• Create an entry in the device-status table.^[76] The operating system maintains this table to keep track of which processes are waiting for which devices. One field in the table is the memory address of the process control block.
• Place all the characters to be sent to the device into a memory buffer.^[65]
• Set the memory address of the memory buffer to a predetermined device register.^[77]
• Set the buffer size (an integer) to another predetermined register.^[77]
• Execute the machine instruction to begin the writing.
• Perform a context switch to the next process in the ready queue.

While the writing takes place, the operating system will context switch to other processes as normal. When the device finishes writing, the device will interrupt the currently running process by asserting an

• Push the contents of the program counter (a register) followed by the status register onto the call stack.^[57]
• Push the contents of the other registers onto the call stack. (Alternatively, the contents of the registers may be placed in a system table.)^[78]
• Read the integer from the data bus. The integer is an offset to the interrupt vector table. The vector table's instructions will then:

• Access the device-status table.
• Extract the process control block.
• Perform a context switch back to the writing process.

When the writing process has its time slice expired, the operating system will:^[79]

• Pop from the call stack the registers other than the status register and program counter.
• Pop from the call stack the status register.
• Pop from the call stack the address of the next instruction, and set it back into the program counter.

With the program counter now reset, the interrupted process will resume its time slice.^[57]

Among other things, a multiprogramming operating system kernel must be responsible for managing all system memory which is currently in use by the programs. This ensures that a program does not interfere with memory already in use by another program. Since programs time share, each program must have independent access to memory.

Cooperative memory management, used by many early operating systems, assumes that all programs make voluntary use of the kernel's memory manager, and do not exceed their allocated memory. This system of memory management is almost never seen anymore, since programs often contain bugs which can cause them to exceed their allocated memory. If a program fails, it may cause memory used by one or more other programs to be affected or overwritten. Malicious programs or viruses may purposefully alter another program's memory, or may affect the operation of the operating system itself. With cooperative memory management, it takes only one misbehaved program to crash the system.

In both segmentation and paging, certain

Windows versions 3.1 through ME had some level of memory protection, but programs could easily circumvent the need to use it. A general protection fault would be produced, indicating a segmentation violation had occurred; however, the system would often crash anyway.

The use of virtual memory addressing (such as paging or segmentation) means that the kernel can choose what memory each program may use at any given time, allowing the operating system to use the same memory locations for multiple tasks.

If a program tries to access memory that is not accessible^[e] memory, but nonetheless has been allocated to it, the kernel is interrupted (see § Memory management). This kind of interrupt is typically a page fault.

When the kernel detects a page fault it generally adjusts the virtual memory range of the program which triggered it, granting it access to the memory requested. This gives the kernel discretionary power over where a particular application's memory is stored, or even whether or not it has been allocated yet.

In modern operating systems, memory which is accessed less frequently can be temporarily stored on a disk or other media to make that space available for use by other programs. This is called

Virtual memory provides the programmer or the user with the perception that there is a much larger amount of RAM in the computer than is really there.^[80]

Concurrency refers to the operating system's ability to carry out multiple tasks simultaneously.^[81] Virtually all modern operating systems support concurrency.^[82]

Permanent storage devices used in twenty-first century computers, unlike

System calls (which are sometimes wrapped by libraries) enable applications to create, delete, open, and close files, as well as link, read, and write to them. All these operations are carried out by the operating system on behalf of the application.^[100] The operating system's efforts to reduce latency include storing recently requested blocks of memory in a cache and prefetching data that the application has not asked for, but might need next.^[101] Device drivers are software specific to each input/output (I/O) device that enables the operating system to work without modification over different hardware.^[102][103]

Another component of file systems is a

Security means protecting users from other users of the same computer, as well as from those who seeking remote access to it over a network.

Some operating system designs are more secure than others. Those with no isolation between the kernel and applications are least secure, while those with a monolithic kernel like most general-purpose operating systems are still vulnerable if any part of the kernel is compromised. A more secure design features microkernels that separate the kernel's privileges into many separate security domains and reduce the consequences of a single kernel breach.^[115] Unikernels are another approach that improves security by minimizing the kernel and separating out other operating systems functionality by application.^[115]

Most operating systems are written in

A user interface (UI) is essential to support human interaction with a computer. The two most common user interface types for any computer are

• command-line interface, where computer commands are typed, line-by-line,
• graphical user interface (GUI) using a visual environment, most commonly a combination of the window, icon, menu, and pointer elements, also known as WIMP.

For personal computers, including

A hobby operating system may be classified as one whose code has not been directly derived from an existing operating system, and has few users and active developers.^[131]

In some cases, hobby development is in support of a "homebrew" computing device, for example, a simple single-board computer powered by a 6502 microprocessor. Or, development may be for an architecture already in widespread use. Operating system development may come from entirely new concepts, or may commence by modeling an existing operating system. In either case, the hobbyist is her/his own developer, or may interact with a small and sometimes unstructured group of individuals who have like interests.

Examples of hobby operating systems include Syllable and TempleOS.

If an application is written for use on a specific operating system, and is

Another approach is for operating system vendors to adopt standards. For example, POSIX and OS abstraction layers provide commonalities that reduce porting costs.

As of September 2024^[update], Android is the most popular operating system with a 46% market share, followed by Microsoft Windows at 26%, iOS and iPadOS at 18%, macOS at 5%, and Linux at 1%. Android, iOS, and iPadOS are mobile operating systems, while Windows, macOS, and Linux are desktop operating systems.^[132]

Linux is a free software distributed under the GNU General Public License (GPL), which means that all of its derivatives are legally required to release their source code.^[133] Linux was designed by programmers for their own use, thus emphasizing simplicity and consistency, with a small number of basic elements that can be combined in nearly unlimited ways, and avoiding redundancy.^[134]

Its design is similar to other UNIX systems not using a

Windows is a

References

1. ^ Stallings (2005). Operating Systems, Internals and Design Principles. Pearson: Prentice Hall. p. 6.
2. ^ Dhotre, I.A. (2009). Operating Systems. Technical Publications. p. 1.
3. ^ "Operating System Market Share Worldwide". StatCounter Global Stats. Retrieved 20 December 2024.
4. ^ "VII. Special-Purpose Systems - Operating System Concepts, Seventh Edition [Book]". www.oreilly.com. Archived from the original on 13 June 2021. Retrieved 8 February 2021.
5. ^ "Special-Purpose Operating Systems - RWTH AACHEN UNIVERSITY Institute for Automation of Complex Power Systems - English". www.acs.eonerc.rwth-aachen.de. Archived from the original on 14 June 2021. Retrieved 8 February 2021.
6. ^ ^{a b} Tanenbaum & Bos 2023, p. 4.
7. ^ Anderson & Dahlin 2014, p. 6.
8. ^ ^{a b} Silberschatz et al. 2018, p. 6.
9. ^ ^{a b c} Anderson & Dahlin 2014, p. 7.
10. ^ Anderson & Dahlin 2014, pp. 9–10.
11. ^ Tanenbaum & Bos 2023, pp. 6–7.
12. ^ Anderson & Dahlin 2014, p. 10.
13. ^ Tanenbaum & Bos 2023, p. 5.
14. ^ ^{a b c} Anderson & Dahlin 2014, p. 11.
15. ^ Anderson & Dahlin 2014, pp. 7, 9, 13.
16. ^ Anderson & Dahlin 2014, pp. 12–13.
17. ^ Tanenbaum & Bos 2023, p. 557.
18. ^ Tanenbaum & Bos 2023, p. 558.
19. ^ ^{a b} Tanenbaum & Bos 2023, p. 565.
20. ^ Tanenbaum & Bos 2023, p. 562.
21. ^ Tanenbaum & Bos 2023, p. 563.
22. ^ Tanenbaum & Bos 2023, p. 569.
23. ^ Tanenbaum & Bos 2023, p. 571.
24. ^ Tanenbaum & Bos 2023, p. 579.
25. ^ Tanenbaum & Bos 2023, p. 581.
26. ^ Tanenbaum & Bos 2023, pp. 37–38.
27. ^ Tanenbaum & Bos 2023, p. 39.
28. ^ ^{a b c d} Tanenbaum & Bos 2023, p. 38.
29. ^ Silberschatz et al. 2018, pp. 701.
30. ^ Silberschatz et al. 2018, pp. 705.
31. ^ Anderson & Dahlin 2014, p. 12.
32. ISSN 1542-7730
    . Retrieved 7 August 2024.
33. ^ "Build Process - Unikraft". Archived from the original on 22 April 2024. Retrieved 8 August 2024.
34. ^ "Leave your OS at home: the rise of library operating systems". ACM SIGARCH. 14 September 2017. Archived from the original on 1 March 2024. Retrieved 7 August 2024.
35. ^ Soares, Livio Baldini; Stumm, Michael (4 October 2010). FlexSC: Flexible System Call Scheduling with Exception-Less System Calls. OSDI '10, 9th USENIX Symposium on Operating System Design and Implementation. USENIX. Retrieved 9 August 2024. p. 2: Synchronous implementation of system calls negatively impacts the performance of system intensive workloads, both in terms of the direct costs of mode switching and, more interestingly, in terms of the indirect pollution of important processor structures which affects both user-mode and kernel-mode performance. A motivating example that quantifies the impact of system call pollution on application performance can be seen in Figure 1. It depicts the user-mode instructions per cycles (kernel cycles and instructions are ignored) of one of the SPEC CPU 2006 benchmarks (Xalan) immediately before and after a pwrite system call. There is a significant drop in instructions per cycle (IPC) due to the system call, and it takes up to 14,000 cycles of execution before the IPC of this application returns to its previous level. As we will show, this performance degradation is mainly due to interference caused by the kernel on key processor structures.
36. ^ ^{a b} Tanenbaum & Bos 2023, p. 8.
37. ^ Arpaci-Dusseau, Remzi; Arpaci-Dusseau, Andrea (2015). Operating Systems: Three Easy Pieces. Archived from the original on 25 July 2016. Retrieved 25 July 2016.
38. ^ Tanenbaum & Bos 2023, p. 10.
39. ^ Tanenbaum & Bos 2023, pp. 11–12.
40. ^ Tanenbaum & Bos 2023, pp. 13–14.
41. ^ Tanenbaum & Bos 2023, pp. 14–15.
42. ^ Tanenbaum & Bos 2023, p. 15.
43. ^ Tanenbaum & Bos 2023, pp. 15–16.
44. ^ ^{a b} Tanenbaum & Bos 2023, p. 16.
45. ^ Tanenbaum & Bos 2023, p. 17.
46. ^ Tanenbaum & Bos 2023, p. 18.
47. ^ Tanenbaum & Bos 2023, pp. 19–20.
48. ^ Anderson & Dahlin 2014, pp. 39–40.
49. ^ Tanenbaum & Bos 2023, p. 2.
50. ^ Anderson & Dahlin 2014, pp. 41, 45.
51. ^ Anderson & Dahlin 2014, pp. 52–53.
52. ^
    ISBN 978-1-59327-220-3
    . A signal is a notification to a process that an event has occurred. Signals are sometimes described as software interrupts.
53. ^ Hyde, Randall (1996). "Chapter Seventeen: Interrupts, Traps and Exceptions (Part 1)". The Art Of Assembly Language Programming. No Starch Press. Archived from the original on 22 December 2021. Retrieved 22 December 2021. The concept of an interrupt is something that has expanded in scope over the years. The 80x86 family has only added to the confusion surrounding interrupts by introducing the int (software interrupt) instruction. Indeed, different manufacturers have used terms like exceptions, faults, aborts, traps and interrupts to describe the phenomena this chapter discusses. Unfortunately there is no clear consensus as to the exact meaning of these terms. Different authors adopt different terms to their own use.
54. ISBN 978-0-13-854662-5
    . Like the trap, the interrupt stops the running program and transfers control to an interrupt handler, which performs some appropriate action. When finished, the interrupt handler returns control to the interrupted program.
55. ISBN 978-0-201-50480-4
    . When an interrupt (or trap) occurs, the hardware transfers control to the operating system. First, the operating system preserves the state of the CPU by storing registers and the program counter. Then, it determines which type of interrupt has occurred. For each type of interrupt, separate segments of code in the operating system determine what action should be taken.
56. ISBN 978-0-201-50480-4
    . Switching the CPU to another process requires saving the state of the old process and loading the saved state for the new process. This task is known as a context switch.
57. ^
    ISBN 978-0-201-50480-4
    .
58. ISBN 978-0-201-50480-4
    . Hardware may trigger an interrupt at any time by sending a signal to the CPU, usually by way of the system bus.
59. ISBN 978-1-59327-220-3
    . Signals are analogous to hardware interrupts in that they interrupt the normal flow of execution of a program; in most cases, it is not possible to predict exactly when a signal will arrive.
60. ISBN 978-1-59327-220-3
    . Among the types of events that cause the kernel to generate a signal for a process are the following: A software event occurred. For example, ... the process's CPU time limit was exceeded[.]
61. ^
    ISBN 978-1-59327-220-3
    .
62. Intel Corporation. September 2016. p. 610. Archived
    (PDF) from the original on 23 March 2022. Retrieved 5 May 2022.
63. ^
    ISBN 0-13-201799-7
    .
64. ISBN 978-1-59327-220-3
    .
65. ^
    ISBN 978-0-13-854662-5
    .
66. ISBN 978-0-201-50480-4
    .
67. ISBN 0-201-12919-1
    .
68. ISBN 0-201-12919-1
    .
69. ^
    ISBN 0-201-12919-1
    .
70. ISBN 978-0-13-854662-5
    .
71. ^ IBM (September 1968), "Main Storage" (PDF), IBM System/360 Principles of Operation (PDF), Eighth Edition, p. 7, archived (PDF) from the original on 19 March 2022, retrieved 13 April 2022
72. ^ ^{a b} Tanenbaum, Andrew S. (1990). Structured Computer Organization, Third Edition. Prentice Hall. p. 294.
    ISBN 978-0-13-854662-5
    .
73. ^ "Program Interrupt Controller (PIC)" (PDF). Users Handbook - PDP-7 (PDF). Digital Equipment Corporation. 1965. pp. 48. F-75. Archived (PDF) from the original on 10 May 2022. Retrieved 20 April 2022.
74. ^ PDP-1 Input-Output Systems Manual (PDF). Digital Equipment Corporation. pp. 19–20. Archived (PDF) from the original on 25 January 2019. Retrieved 16 August 2022.
75. ISBN 978-0-201-50480-4
    .
76. ISBN 978-0-201-50480-4
    .
77. ^
    ISBN 978-0-13-854662-5
    .
78. ^
    ISBN 978-0-13-854662-5
    .
79. ISBN 978-0-13-854662-5
    .
80. ISBN 978-81-203-2962-1
    .
81. ^ Anderson & Dahlin 2014, p. 129.
82. ^ Silberschatz et al. 2018, p. 159.
83. ^ Anderson & Dahlin 2014, p. 130.
84. ^ Anderson & Dahlin 2014, p. 131.
85. ^ Anderson & Dahlin 2014, pp. 157, 159.
86. ^ Anderson & Dahlin 2014, p. 139.
87. ^ Silberschatz et al. 2018, p. 160.
88. ^ Anderson & Dahlin 2014, p. 183.
89. ^ Silberschatz et al. 2018, p. 162.
90. ^ Silberschatz et al. 2018, pp. 162–163.
91. ^ Silberschatz et al. 2018, p. 164.
92. ^ Anderson & Dahlin 2014, pp. 492, 517.
93. ^ Tanenbaum & Bos 2023, pp. 259–260.
94. ^ Anderson & Dahlin 2014, pp. 517, 530.
95. ^ Tanenbaum & Bos 2023, p. 260.
96. ^ Anderson & Dahlin 2014, pp. 492–493.
97. ^ Anderson & Dahlin 2014, p. 496.
98. ^ Anderson & Dahlin 2014, pp. 496–497.
99. ^ Tanenbaum & Bos 2023, pp. 274–275.
100. ^ Anderson & Dahlin 2014, pp. 502–504.
101. ^ Anderson & Dahlin 2014, p. 507.
102. ^ Anderson & Dahlin 2014, p. 508.
103. ^ Tanenbaum & Bos 2023, p. 359.
104. ^ Anderson & Dahlin 2014, p. 545.
105. ^ ^{a b} Anderson & Dahlin 2014, p. 546.
106. ^ Anderson & Dahlin 2014, p. 547.
107. ^ Anderson & Dahlin 2014, pp. 589, 591.
108. ^ Anderson & Dahlin 2014, pp. 591–592.
109. ^ Tanenbaum & Bos 2023, pp. 385–386.
110. ^ ^{a b} Anderson & Dahlin 2014, p. 592.
111. ^ Tanenbaum & Bos 2023, pp. 605–606.
112. ^ Tanenbaum & Bos 2023, p. 608.
113. ^ Tanenbaum & Bos 2023, p. 609.
114. ^ Tanenbaum & Bos 2023, pp. 609–610.
115. ^ ^{a b} Tanenbaum & Bos 2023, p. 612.
116. ^ Tanenbaum & Bos 2023, pp. 648, 657.
117. ^ Tanenbaum & Bos 2023, pp. 668–669, 674.
118. ^ Tanenbaum & Bos 2023, pp. 679–680.
119. ^ Tanenbaum & Bos 2023, pp. 605, 617–618.
120. ^ Tanenbaum & Bos 2023, pp. 681–682.
121. ^ Tanenbaum & Bos 2023, p. 683.
122. ^ Tanenbaum & Bos 2023, p. 685.
123. ^ Tanenbaum & Bos 2023, p. 689.
124. ^ Richet & Bouaynaya 2023, p. 92.
125. ^ Richet & Bouaynaya 2023, pp. 92–93.
126. ^ Berntsso, Strandén & Warg 2017, pp. 130–131. sfn error: no target: CITEREFBerntssoStrandénWarg2017 (help)
127. ^ Tanenbaum & Bos 2023, p. 611.
128. ^ Tanenbaum & Bos 2023, pp. 396, 402.
129. ^ Tanenbaum & Bos 2023, pp. 395, 408.
130. ^ Tanenbaum & Bos 2023, p. 402.
131. ^ Holwerda, Thom (20 December 2009). "My OS Is Less Hobby than Yours". OS News. Retrieved 4 June 2024.
132. ^ "Operating System Market Share Worldwide". StatCounter Global Stats. Retrieved 20 December 2024.
133. ^ Silberschatz et al. 2018, pp. 779–780.
134. ^ Tanenbaum & Bos 2023, pp. 713–714.
135. ^ ^{a b} Silberschatz et al. 2018, p. 780.
136. ^ Vaughan-Nichols, Steven (2022). "Linus Torvalds prepares to move the Linux kernel to modern C". ZDNET. Retrieved 7 February 2024.
137. ^ Silberschatz et al. 2018, p. 781.
138. ^ Tanenbaum & Bos 2023, pp. 715–716.
139. ^ Tanenbaum & Bos 2023, pp. 793–794.
140. ^ Tanenbaum & Bos 2023, p. 793.
141. ^ Tanenbaum & Bos 2023, pp. 1021–1022.
142. ^ Tanenbaum & Bos 2023, p. 871.
143. ^ Silberschatz et al. 2018, p. 826.
144. ^ ^{a b} Tanenbaum & Bos 2023, p. 1035.
145. ^ ^{a b} Tanenbaum & Bos 2023, p. 1036.
146. ^ Silberschatz et al. 2018, p. 821.
147. ^ Silberschatz et al. 2018, p. 827.

Further reading

• ISBN 978-0-9856735-2-9
  .
• Auslander, M. A.; Larkin, D. C.; Scherr, A. L. (September 1981). "The Evolution of the MVS Operating System". IBM Journal of Research and Development. 25 (5): 471–482.
  ISSN 0018-8646
  .
• Berntsson, Petter Sainio; Strandén, Lars; Warg, Fredrik (2017). Evaluation of Open Source Operating Systems for Safety-Critical Applications. Springer International Publishing. pp. 117–132.
  ISBN 978-3-319-65948-0
  .
• Deitel, Harvey M.; Deitel, Paul; Choffnes, David (25 December 2015). Operating Systems. Pearson/Prentice Hall.
  ISBN 978-0-13-092641-8
  .
• Bic, Lubomur F.; Shaw, Alan C. (2003). Operating Systems. Pearson: Prentice Hall.
• Silberschatz, Avi; Galvin, Peter; Gagne, Greg (2008). Operating Systems Concepts.
  ISBN 978-0-470-12872-5
  .
• O'Brien, J. A., & Marakas, G. M.(2011). Management Information Systems. 10e. McGraw-Hill Irwin.
• Leva, Alberto; Maggio, Martina; Papadopoulos, Alessandro Vittorio; Terraneo, Federico (2013). Control-based Operating System Design.
  ISBN 978-1-84919-609-3
  .
• Richet, Jean-Loup; Bouaynaya, Wafa (2023). "Understanding and Managing Complex Software Vulnerabilities: An Empirical Analysis of Open-Source Operating Systems". Systèmes d'information & management. 28 (1): 87–114.
  doi:10.54695/sim.28.1.0087 (inactive 1 November 2024).{{cite journal}}: CS1 maint: DOI inactive as of November 2024 (link
  )
• Silberschatz, Abraham; Galvin, Peter B.; Gagne, Greg (2018). Operating System Concepts (10 ed.). Wiley.
  ISBN 978-1-119-32091-3
  .
• Tanenbaum, Andrew S.; Bos, Herbert (2023). Modern Operating Systems, Global Edition. Pearson Higher Ed.
  ISBN 978-1-292-72789-9
  .

External links

Look up operating system in Wiktionary, the free dictionary.

Wikimedia Commons has media related to Operating systems.

Wikiversity has learning resources about Operating Systems

• Multics History and the history of operating systems