Modul 1 - Processer

Question 1

Hur funkar heapen och vad allokeras här?

Answer 1

Heap är en region i data minnet som inte hanteras automatiskt. Utan du måste själv allokera minne genom kommandon malloc() eller calloc() som är inbyggda funktioner i C. När man allokerat minne i heapen, så ansvarar man själv för att frigöra minnet när man använt klart det. Används för det mesta för att allokera variabler som ska vara mer “långvariga” eller för större datastrukturer.

Unlike the stack, the heap does not have size restrictions on variable size (apart from the obvious physical limitations of your computer). Heap memory is slightly slower to be read from and written to, because one has to use pointers to access memory on the heap.

Unlike the stack, variables created on the heap are accessible by any function, anywhere in your program. Heap variables are essentially global in scope.

Question 2

Hur funkar stacken och vad allokeras här?

Answer 2

Stacken är en datastruktur som används för att lagra temporära variabler som skapas av varje funktion. Lagrar enligt “LIFO” (last in, first out). Varje gång en ny variabel deklareras läggs den i stacken och när programmet kör ut funktionen så kommer de variablerna som skapades i funktion bli fria “freed” d.v.s. de tas bort från stacken.

To summarize the stack:

• The stack grows and shrinks as functions push and pop local variables.
• There is no need to manage the memory yourself, variables are allocated and freed automatically.
• The stack has size limits.
• Stack variables only exist while the function that created them, is running.

Question 3

Stack vs heap?

Answer 3

Stack:

• Very fast access
• Don’t have to explicitly de-allocate variables
• Space is managed efficiently by CPU, memory will not become fragmented
• Local variables only
• Limit on stack size (OS-dependent)
• Variables cannot be resized

Heap:

• Variables can be accessed globally
• No limit on memory size
• (Relatively) slower access
• No guaranteed efficient use of space, memory may become fragmented over time as blocks of memory are allocated, then freed
• You must manage memory (you’re in charge of allocating and freeing variables)
• Variables can be resized using realloc()

Question 4

Vilka minnesaddresser brukar stacken, heapen och koden finnas? (Tenta fråga 1.3) .

Answer 4

-

Question 5

Hur funkar den inbyggda funktionen free()? (Heap)

Tenta fråga 1.4

Answer 5

-

Question 6

Skillnad mellan user mode och kernel mode?

Answer 6

-

Question 7

Vad gör instruktionen INT?

Answer 7

• The special instruction, INT 0x80, will set the execution in kernel mode and jump to the 0x80 position in the interrupt table (IDT).

Question 8

Vad är skillnaden mellan systemanrop och biblioteksrutiner? Vilka tillhör operativsystemet?

Answer 8

-

Question 9

Hur fungerar automatisk minneshantering på ex Java?

Answer 9

-

Question 10

Varför virtualiserar man CPU:n?

Answer 10

För att ge illusionen om att det finns flera CPU:n än vad det egentligen finns. Detta gör man så att flera processer kan köras samtidigt.

Question 11

Vad är en process?

Answer 11

En process är ett program som körs.

Question 12

Hur virtualiserar man CPU:n? (Basic)

Answer 12

Man virtualiserar genom att switcha mellan olika processer. Alltså köra en process en stund, sen stoppa den och byta till en annan process o.s.v.

Tekniken heter time sharing av CPU:n, låter användare köra många processer samtidigt. Den potentiella kostnaden är prestanda, då varje process kommer köra långsammare om CPU:n måste delas.

Question 13

Vad är time sharing?

Answer 13

En teknik som används av OS:n för att dela på en resurs. Genom att låta att resursen används en liten stund av en entitet (entity) och sen en liten stund av en annan o.s.v.

På detta sätt kan exempelvis CPU:n eller en nätverksläng delas av många samtidigt.

Question 14

Vad är en mekanism?

Answer 14

Det är låg level (low-level) metoder eller protokoll för att implementera nödvändig funktionalitet.

Mekanismer ger helt enkelt svaret på hur något ska ske. Exempelvis hur ska OS:n utföra en context switch?

Question 15

Vad är en policy?

Answer 15

En algoritm som gör beslut inom OS:n.

Exempelvis kommer schemaläggnings policyn bestämma vilket program OS:n ska köra givet många möjligt körbara program.

Policyn ger svaret på vilka grejer som ska ske. Exemeplvis vilken process ska OS:n köra?

Question 16

Vad är en context switch?

Answer 16

Det är en time sharing mekanism som ger OS:n förmågan att kunna stoppa ett program och köra ett annat program på en given CPU.

Question 17

Vad är en processens machine state?

Answer 17

Machine state är vad ett program kan läsa eller uppdatera när den körs.

Question 18

Vilka kompontenter består processers “machine state” av?

Answer 18

Machinestate är vad ett program kan läsa eller uppdatera när den körs.

Består av:

Minnet - Då instruktioner och data som programmet läser och skriver till ligger här. Minnet som en process kan addressera till kallas för address space.

Register - Instruktioner läser eller uppdaterar register.

Program counter (PC) - Beskriver vilken instruktion i porgrammet som körs.

Stack pointer och frame pointer - Hanterar stacken för funktions parametrar, lokala variabler och retur addresser.

Lagringsenheter - Här finns exempelvis information om vilka filer som en process har för tillfället öppet.

Question 19

Explain what the instruction pointer (EIP) also known as program counter (PC), stack pointer (ESP), base pointer (EBP) and general purpose registers are? The CPU can be described by these.

Answer 19

• The instruction pointer (EIP): a reference to the next instruction to execute
• The stack pointer (ESP): a reference to the top of the stack.
• The base pointer (EBP): a reference to the current stack frame.
• General purpose registers: used by a process to store data.

Question 20

What is a stack frame?

Answer 20

The stack frame is the collection of all data on the stack associated with one subprogram call.

The stack frame generally includes the following components:

• The return address
• Argument variables passed on the stack
• Local variables
• Saved copies of any registers modified by the subprogram that need to be restored (e.g. $s0 - $s8).

Question 21

The heap API?

Answer 21

• void *malloc(size_t size) : allocate size bytes on the heap, returns a pointer to the structure.
• free(void *ptr) : deallocates a structure pointed to by ptr
• void *calloc(size_t nmemb, size_t size) : allocate an array of nmemb element of size bytes initialize it to zero.
• void *realloc(void *ptr, size_t size) : changes the size of the structure pointed to by ptr.

Question 22

How does the OS create a process from a program?

Answer 22

• The program is found on some external data storage (ex. hard-drive)
• Memory is allocated to hold the: code, static data, heap and stack.
• A process context is created holding the necessary register values.

Question 23

How does the process execution work?

Answer 23

• Direct execution:
  The operating system loads the code of the user process, sets the stack and heap pointers and jumps to the first instruction of the process.

1. Creates an process entry on the process list.
2. Allocates memory for the program.
3. Loads the program to the memory from the hard-drive.
4. Cleans the registers.
5. Executes main().

Question 24

Vad är en process lista?

Answer 24

En process lista används för att hålla reda på alla processer som är redo att köras och ytterliggare info för att se vilken process som körs.

Question 25

Process API?

Answer 25

Functions:

fork(), exec(), wait().

Question 26

How does fork() work?

Answer 26

• fork() creates a new process that is a copy of the process that called fork(). This new process is called the child and the calling process is the parent.
• The child process dosen’t start running on main() instead it runs as it had called fork() itself.
• fork() returns the process id PID of the child process to the parent and 0 to the child (returns twice).
• Which process that runs first is determined by the scheduler.
• The child process has its own address space (virtual memory)!!
• The memory of the two processes are separated from each other (but use the same addresses).
• Already open files are shared by the two processes.
• Newly open files are not shared.

Question 27

How does wait() work?

Answer 27

• wait() is used by a parent process to wait for the child process to finish executing.
• the wait() system call also reads the finished child process (dead child process) exit status and other information. Allows the parent process to get information from the dead process. After wait() is called, the zombie process is completely removed from memory.

. This

Question 28

How does exec() work?

Answer 28

• exec() is used to run a program that is different from the one calling exec(). While fork() is used to run copies of itself.
• exec() dosen’t create any new process, instead it transforms the running program to another running program.
• exec functions do not return when successful.
• There is execl, execlp, execle, execv, execvp, execvpe:
• e: pass an array of pointers to environment variables.
• l: arguments are passed individually to the function.
• v: arguments are passed as an array of strings.
• p: uses PATH environment variable to find the file that is executed.

Question 29

What is a zombie process (UNIX)?

Answer 29

When a process dies on Linux, it isn’t all removed from memory immediately — its process descriptor stays in memory (the process descriptor only takes a tiny amount of memory). The process’s status becomes EXIT_ZOMBIE and the process’s parent is notified that its child process has died with the SIGCHLD signal. The parent process is then supposed to execute the wait() system call to read the dead process’s exit status and other information. Allows the parent process to get information from the dead process. After wait() is called, the zombie process is completely removed from memory.

• It’s a child process that has finished executing but still exists in the process table.
• Happens if parent dosen’t call wait().

Question 30

What is an orphan process?

Answer 30

• Child process that is still running but the parent process has finished executing or terminated.
• Will be “adopted” by another process, thus get a new parent process.
• In UNIX the new parent process is the init or systemd process
  - which is the parent of all processes.
  - has the process id (PID) = 1 .

Question 31

What is a daemon process?

Answer 31

• Process that runs automatically in the background instead of under direct control of a user.
• Performs operations at predefined times or in response to event.
• Runs most of the tasks in a system.

Question 32

What are pipes?

Answer 32

• Sends the output of one program to another programs input.
• Denoted by the symbol ‘|’
• Piping in the shell: combine serveral commands.

Ex: cat countries.txt | grep a | sort
Displays all countries that start with an ‘a’ and sorts them in alphabetic order.

• Pipes has built-in flow control. So for example if a consumer dosen’t read form the pipe then the producer will be suspended when it tries to write to the filled pipe.

Question 33

What does dup2() do?

Answer 33

dup2() is a system call similar to dup in that it duplicates one file descriptor, making them aliases, and then deleting the old file descriptor. This becomes very useful when attempting to redirect output, as it automatically takes care of closing the new file descriptor, performing the redirection in one elegant command. For example, if you wanted to redirect standard output to a file, then you would simply call dup2, providing the open file descriptor for the file as the first command and 1 (standard output) as the second command.

• Can be used to redirect stdout to an opened file.

Question 34

What are signals?

Answer 34

• Notifications sent to a process to inform that a certain event has occured.
• Causes a process to stop executing and handle the signal that has been received.
• SIGINT: interrupt a process from keyboard (Ctrel + C)
• SIGTERM: terminate a process
• SIGKILL: kill process immediately
• SIGFPE: arithmetic exeception (division by 0)
• SIGSEGV: invalid memory access (segmentation fault)
• Signals can be sent from the keyboard, the shell or using system calls.

Question 35

What is an Interupt descriptor table (IDT)?

Answer 35

• Used to determine the correct response to interrupts and exceptions.
• It contains pointers to different procedures that should be executed on different interrupts, each signal has its default action to be taken.
• The OS has one IDT
• Every process has its own Signal Table (holds the different signals)
• You can define your own signal handling procedures.

Question 36

Signal handlers?

Answer 36

• Each signal has a default handler. Ex. SIGINT - terminate a process.
• The action can be changed by using the sigaction structure.
• Define a function that is invoked when the signal is received.
• The default actions for SIGKILL and SIGSTOP cannot be changed.

Question 37

What does Sigaction do?

Answer 37

• Adds a new handler to a specific row in the IDT (interrupt descriptor table) for a process.
• sigaction(signal, action, oldaction)
• signal: the signal we want to handle
• action: the action that should be taken when reciving the signal
• oldaction: needed if you want to see what the old action was, should be set to NULL if it isn’t needed.

Question 38

Context information in the handler?

Answer 38

The context can be received by the handler function. It can receive up to 3 arguments
handler_function(int signal [, siginfo_t info, void* u_context] )

• siginfo_t - Signal information (pid of process etc.)
• u_context - The execution context. Things such as program counter and other registers.

Question 39

A simple way to kill a program is to hit ctrl-c. If we write a program we might not want to die or we might want to do some last operations before terminating. What mechanisms should we use in our program to handle this?

Answer 39

Answer: We should create a signal handler, a procedure that we will register for a specific signal, in this case SIGINT. When Ctrl-c is pressed a SIGINT will be sent to the process and thus our signal handler will be executed.

Question 40

What does the IDT (Interrupt Descriptor Table) contain and what happens when a user process executes the instruction INT (x86 assembler). Give a short description.

Answer 40

Answer: The IDT is set up by the kernel and contains
pointers to procedures that should be executed by different interrupts. When a user process executes for example INT 80 the process enters kernel mode and jumps to the procedure indicated by position 80 (hex).

Question 41

In a x86-architecture we have an IDT that is used when we implement among other things system calls. What does the operating system have to add to the IDT in order to make a system call possible?

Answer 41

Answer: The OS stores a pointer at a specified position in the table(0x80) to a procedure that handles all
system-signals. When a user process executes INT 0x80 the stored procedure will be put in charge, and will be executed in Kernel Mode.

Question 42

In the processor 80286, that was launched in 1982, Intel had added a privileged instruction LIDT (Load Interrupt Descriptor Table). What does it mean that the instruction is privileged and why does this instruction need to be privileged?

Answer 42

Answer: A privileged instruction can only be executed in kernel mode. The instruction will set a pointer to a table (IDT) that describes what should be done for each exception. This is nothing that a user process should be allowed to do.

Question 43

How does limited direct execution work?

Answer 43

Runs the program directly on the hardware CPU but limits its access. Lets programs run as fast as one might expect.

• Limited in that the user program isn’t able to execute all instructions.
• It can only access its own memory
• It is only allowed to execute for a limited time.

Question 44

Kernel mode?

Answer 44

• Kernel mode is where the OS runs and hasn’t any restrictions. OS has access to full resources of the machine.
• The kernel should not take for granted that it can trust memory references from user space - security and portability. It should use special procedures when
  reading or writing to user space.

Question 45

User mode?

Answer 45

• User mode is restricted in the sense that programs running in this mode doesn’t have full access of the hardware resources.
• User mode exists to ensure that a process dosen’t take complete control of the system. In user mode you can’t for example directly issue I/O calls.
• Processes in user mode are only allowed to access its own code, stack and heap.

Question 46

System calls?

Answer 46

System calls gives user programs the ability to perform some kind of privileged operations. Allows the kernel to carefully expose certain key pieces of functionality to user programs, such as accessing the file system, creating and destroying processes, communicating with other processes, and allocating more memory.

System calls executes special trap instruction.

Question 47

What is a trap instruction?

Answer 47

• A trap instruction jumps into the kernel and raises the privilege level to kernel mode, calls return-from-trap to go back to user mode.
• Trap instructions saves register states, changes hardware status to kernel mode and jumps into the OS trap table.

Question 48

Life of an execution.

Answer 48

1. Hardware - turn on power - start executing “BIOS”
   
   2. Kernel mode: load operating system - set up interrupt descriptor table (IDT)
   3. Kernel mode: load user program - set up stack, heap etc - start execution
2. User mode: run program
3. User mode: prepare system call - trap to kernel mode
4. Kernel mode: jump to system call handler
5. Kernel mode: handle system call - prepare result - return from trap
6. User mode: continue execution

Question 49

The purpose of a timer interrupt?

Answer 49

Timer interrupts are used to ensure that a program dosen’t run forever.

Question 50

What is a context switch?

Answer 50

• A context switch is performed to change which process is running.
• Gives the ability to stop running one program and starting running another on a given CPU
• These can happen during an interrupt or a system call.

When a context switch happens:
1. Save the current registers in the context (process table) of the current process.

2. Decide which other process that should run,
3. Load the stored registers of the selected process,
   reset the timer, switch to user mode and,
4. Set the instruction pointer of the selected process.

Question 51

What 3 basic things does a process consist of?

Answer 51

Address space - instructions, data

CPU State - program counter, stack pointer, registers

OS Resources - open files, network connections..

Question 52

What are the 4 areas of a process’s address space?

Answer 52

Stack (dynamic mem)

Heap (dynamic mem)

Static data (data segment)

Code (text segment)

Question 53

What data structure does the OS maintain to keep track of a process’s state?

Answer 53

Process Control Block (PCB) or process descriptor

Question 54

What sort of information does a Process Control Block include?

Answer 54

Process ID, Parent ID, execution state, Program counter, Stack pointer, registers etc.

Question 55

How can a different process be started?

Answer 55

First fork then exec()

Question 56

What does the exit() syscall do?

Answer 56

releases all resources

gets rid of most OS structures supporting the process

checks if parent is alive

if os, enters “zombie” state

otherwise dies

Question 57

How do programs request services from the OS?

Answer 57

Traps or exceptions.

Question 58

How does the OS regain control after the kernel has allowed a user process to execute?

Answer 58

• The user process executes a INT instruction.
• The hardware generates an interrupt.
• The kernel sets a timer interrupt before it allows the user process to execute.
• When the interrupt is generate by the hardware, the kernel can make a decision
  to schedule another process.

Question 59

Different types of interrupts?

Answer 59

• Asynchronous interrupts: raised by the hardware: keyboard, IO, etc, can be masked by the kernel.
• Synchronous interrupts - exceptions: raised by the CPU:
• faults: something strange happens, will be handled by the kernel and instruction is re-executed (if the kernel can fix it).
• traps: something special happens, used mainly by debugging.
• abort: severe errors that will not be fixed by the kernel.
• programmed exceptions (software exceptions): raised by for example the INT instruction, used by system calls and debuggers.

Question 60

Difference between a trap and an interrupt?

Answer 60

• A trap is an exception in a user process. It’s caused by division by zero or invalid memory access. It’s also the usual way to invoke a kernel routine (a system call) because those run with a higher priority than user code. Handling is synchronous (so the user code is suspended and continues afterwards). In a sense they are “active” - most of the time, the code expects the trap to happen and relies on this fact.
• An interrupt is something generated by the hardware (devices like the hard disk, graphics card, I/O ports, etc). These are asynchronous (i.e. they don’t happen at predictable places in the user code) or “passive” since the interrupt handler has to wait for them to happen eventually.