Operating Systems

• When you define an operating system as the one program that keeps running all the time on the computer, and has control over everything, it’s called a kernel.
• An OS is the kernel, along with drivers and user interfaces.

• It’s a program stored in ROM, and this is the first piece of software that runs on the system.
• It initializes the hardware, and then loads the OS kernel into the RAM.

• Number of transistors double every 18 months.

• An interrupt is a hardware or software signal that demands instant attention by an OS.
• Hardware interrupts are either done to let the OS know that it has completed some task (like printing), or it can request a service from the OS (like hitting a key on a keyboard should trigger some software action).
• Software interrupts are triggered by an operation called system/monitor call.
• Modern operating systems are interrupt-driven.
• Interrupt Service Routine (ISR) is a function that responds to an interrupt.
• An interrupt vector is a memory address that points to an ISR.
• Operating systems handle interrupts by looking up an interrupt vector table (a table full of interrupt vectors).

• It’s a communication system within the hardware of a computer, or between computers themselves.

• This is the physical interface between the computer’s I/O bus and the peripheral devices.
• They have their own special purpose registers, and their own amount of local buffer storage in RAM.

• It’s the software associated with device controller.

• First, the device driver loads instructions into registers for the device controller.
• The device controller reads all instructions given inside these registers and performs them.
• Once it’s done (or the device has new data which will be communicated via an interrupt), the CPU runs a part of the device driver called the interrupt handler.
• This processes the event (data copied between RAM and device), after which the CPU will get back to what it was doing before this.
• Interrupt Driven I/O is what’s used in keyboards and mice because they deal with low-data volume.
• This isn’t very efficient for large amounts of data, because the CPU does the data copy only after an interrupt.

• Inside the computer, there are 3 hardware components:
  • CPU
  • Device Controller
  • DMA Controller
• The DMA controller is a small processor whose job is to copy data between RAM and the device.
• High speed I/O devices can transfer blocks of data directly to/from RAM, without involving CPU.
• The CPU gets an interrupt after a bunch of bytes, not after every byte.

• A program counter is a register in a computer’s CPU that holds the memory address of the next instruction to be executed.
• Memory is allocated to a process, and a process can have one or more threads.

• When the computer runs out of RAM, inactive or less-used parts of programs like process data and kernel data.

• When a process needs to do something only a kernel can do, it makes a system call to the OS, and transfers control to the kernel.
• It switches the mode bit from 1 (User mode) to 0 (kernel mode).
• System interrupt also switches mode bit from 1 to 0, but this is for, say, notifying CPU for I/O events.
• These usually written in C/C++ (or any other high level language).

• User program runs in user mode
• When it needs OS services, it makes a system call
• System call switches to kernel mode
• OS executes the request
• Returns to user mode

• fork() is a system call in Unix/Linux used to create a new process, by duplicating the current process at whatever state of execution it’s in.

• This is what happens when you call fork:

            Parent
              |
              | fork()
              |
     ---------------------
     |                   |
  Parent continues     Child continues
  (pid > 0)            (pid = 0)
  
  

  If you’re running a program, and there’s a fork() happening, the current process (the parent) continues to execute, but there’s also a child process which resumes execution from that point.

• Both the parent and the child process runs simultaneously, regardless of whether you have a multicore CPU or not. This also means that the order of execution is not guaranteed.
• The way we distinguish between the two processes is by using the return value of fork() (it returns the process id).
• The process ID of a parent process could be any value greater than 0, but the process ID of the child process is always 0.

• Consider the below example:

  #include <stdio.h>
  #include <unistd.h>   // This is needed for fork()
  
  void main() {
      int num, pid, square, half;
      num = 6;
      pid = fork();     // child is created
      // both of the processes resume execution from this line in the program
      if (pid == 0) {   // child process
          square = num * num;
          printf("The square of the number is %d\n", square);
      } else {          // parent process
          half = num / 2;
          printf("The half of the number is %d\n", half);
      }
  }
  
  

    The half of the number is 3
    The square of the number is 36
  

• open() is a system call that enables you to open a file.
• It returns a file descriptor, which is a whole number used to represent an open I/O resource.

• These are possible values a file descriptor:

  FD	Meaning
  0	stdin (keyboard input)
  1	stdout (terminal output)
  2	stderr (error output)
  ≥ 3	user-opened files

• So for files, the file descriptor is likely 3.

• This is the basic syntax for open():

  int fd = open("file.txt", x);
  

  where x can be:

  • O_RDONLY: Only reads. The file must exist.
  • O_WRONLY: Only writes. The file must exist.
  • O_RDWR: Reads or writes. The file must exist.

• If you need to create the file in case it doesn’t exist, you’d have to do:

  int fd = open("file.txt", O_WRONLY | O_CREAT, 0644); // 0644 is permissions: rw-r--r--
  

  • The third argument is called the mode, and that’s to grant permissions to the file once created.
  • open() returns -1 in case of failure, or some non-negative number in case of success.

• This is the basic syntax for read():

  int n = read(fd, buffer, sizeof(buffer));
  
  // where the buffer is some array
  

  This take the file associated with file descriptor fd, and copies the contents into the array buffer.

• This is the basic syntax for write():

  int n = write(fd, buffer, sizeof(buffer));
  
  // where the buffer is some array
  

  write() copies the contents of the array buffer, into wherever the file descriptor fd says so.

• The return value of write() is the number of bytes actually written by write().

• Here’s an example of printing characters to stdout (fd = 1):

  #include <stdio.h>
  #include <string.h>
  #include <unistd.h>
  
  int main() {
   
    char msg[] = "Hello! This is a test.\n";
    int len = strlen(msg);            // = 23
   
    int written = write(1, msg, len);
    printf("\n\n%d", written);        // Output: 23%
    return 0;
  }
  
  

Commands to

• Create
• Delete
• Copy
• Rename files

• Date, time, memory available, disk space

• Text editors

• Compilers, assemblers, debuggers

• Email, web browsers, remote login, file transfer

• Launch at boot
• Run continuously (disk checking, process scheduling, printing)
• Important: Run in user context, NOT kernel context

• User applications (not part of OS)

• It consisted of
  • Application Programs
  • System Programs
  • Device Drivers
• Note that these aren’t layers.
• Only one process can execute at a time.
• There are no user modes and no hardware protection. Any program can do anything to the system.
• Every new process overwrites the previous process upon completion.
• It’s called monolithic as there is no seperation between system programs and kernel.

• Introduced User mode and kernel mode, which were essentially 2 layers of access.
• This is ever-so-slightly slower than a monolithic structure, but now the hardware is better protected.
• User mode was the layer on the top, which had all system programs.
• Kernel mode had everything else that would directly affect the hardware like I/O, CPU Scheduling or interrupt handling.
• The issue is that the kernel mode has too much of functionality.

• The same idea as before, but now we have multiple layers.
• Every layer can only access functions from a layer below.
• Now every layer can make changes independent to other layers.
• Furthermore, this is more modular.
• The issue is that it’s harder to define the layers, and it’s visibly more slower than having two layers.

• You keep the same Unix approach of having just 2 layers (user mode and kernel mode).
• This time, instead of defining system programs and pushing everything else to kernel, you do the opposite.
• You ensure that the kernel has minimal process and memory managment software, and everything else is in user mode.
• In the Unix approach, kernel mode used to be faster, but going from kernel to user mode is slow.
• Here in the microkernel approach, the user mode is fast because all functions are in the same layer, but moving to kernel mode is slower.

• Kernel operations are no longer in a single layer, but they are modules which are loaded as and when required.
• An example is Solaris (A unix based distribution that’s not linux).

• Usually data is moved from RAM to CPU Registers, then execution happens, and then the output moves from CPU Registers to the required spot in RAM.
• If there’s an interrupt, the intermediary output can’t go to this required spot, hence this intermediary output along with the state of the process is stored in PCB (a place in RAM).
• If the process has to be resumed, the data from PCB is moved back into CPU registers.

• All the threads of a process have one common PCB, heap segment, data segment and code segment.
• A process is the changeable entity (it contains heap, stack, etc.) while a thread is the scheduleable entity (these deal with the actual sequence of instructions).

The time taken by processes involve their burst time, and the time taken for the corresponding I/O operation.

• CPU Scheduler is a part of the kernel that schedules processes to be run on the CPU.
• Throughput is the number of processes completed per unit time.