title: Studying Operating System Using Docker Platform  
author: Shivani Dubey
profile: Madan Mohan Malaviya University of Technology, Gorakhpur

## Why do we study Operating System?

- Every computer system has an operating system, which manages the resources of the computer.

- IoT or IT Services can't work well without resource managements.

- To handle it, we have to understand the API of OS.

- To understand the API, it is better to see the implementations.

- For example, API for tuning priorities of the processes.

## Xv6 Operating System as an educational tool

- A Unix-like operating system developed in MIT, based on V6 kernel

- xv6 is written in ANSI C ( not in C++ )

- xv6 is small and simple (9628 lines of codes)

- It can run on Raspberry Pi ( Small PC board )

- Or on ARM emulator such as QEMU

## Xv6 development environment with QEMU

- QEMU emulates ARM CPU with virtual memory 

- Xv6 operating sytem itself is running on QEMU 

- gdb debugger can be attached to the emulated program (both in user space and system space)

- We can step and trace inside xv6 kernel

      ... but it requires complex development environments setup
      ... very time consuming

## Our development environments 


- homebrew (it simplifies installation of software in macOS)

- Mercurial repository of the lab where we saved everything using ssh 

- Cross Compilers 

- ARM libraries for C language

- QEMU (ARM Emulator)

## Introducing Docker

- What is Docker? It is a container.

- What is Container? An isolated envirornment such as file system.

- It has DockerFile, which describes how to setup the envrionment in the container.

- Docker can run on any computer using an emulator such as QEMU.

- Complex development environment can be build using DockerFile and docker built command.

# The DockerFile

```
FROM phitek/qemu-arm
RUN apt-get update -y
RUN apt-get remove gdb -y
RUN apt-get install gcc-arm-none-eabi gdb-arm-none-eabi qemu-system-arm -y
WORKDIR /code
COPY ["src", "."]
RUN make
CMD /bin/bash
```

- FROM line specifies the shared image in Docker repository.

- apt-get installs Linux cross compiling tools.

- Then it creates working directory, copies our sources to it, and executes make.

## Docker commands

- Create docker image and environment, and build xv6 kernel

  docker build --tag xv6-docker 

- Run xv6 kernel on QEMU in the container

  docker run --rm --privileged -it xv6-docker ./run-debug.sh

- Run gdb to connect the xv6 kernel running in the QEMU

  docker exec -it xv6-docker ./debug.sh





# Exercise : Adding priorities to the xv6 scheduler 

- Added getpriority() and setpriority() 

- get_highest_priority() functions in proc.c file of xv6

- Implemented it in schelduler()

- Added a test function testpriority() in usertests.c file of xv6 to implement our algorithm

##  Function used in our exercise to find highest priority process 
```c
int get_highest_priority_proc(void)
{
  int highest_priority;
  int pid = 0;
  int hpid = -1;
  int rpid = 0;
  highest_priority=100;
 
 struct proc *p;
  for(p = ptable.proc; p < &ptable.proc[NPROC]; p++, pid++){
    if(p->state != RUNNABLE) {
      continue;    }
    rpid = pid;
    if (highest_priority > p->priority) {
       highest_priority=p->priority;
       hpid = pid; } }
  return hpid > 0?hpid:rpid;
}
```
- It assumes at least one process to be RUNNABLE.

- It may allow no highest priority process.

- The correctness of the function is *important*.

## Docker Limitation


- If repository breaks, Docker poses a problem (a cloud problem).

- Cloud may be used conveniently but we must not rely on it.

- We can use a direct environment without Docker, since we have a Linux server.

- Docker images can easily eat up our disk spaces.

in ~/.zsh_history

```c
: 1561014922:0;docker system prune
: 1561014973:0;docker container prune
: 1561015350:0;docker image prune
: 1561015362:0;docker volume prune
```
# Conclusion


- Docker environment poses some problems, some of which are difficult to comprehend. 



- Yet, it gives a good insight of the underlying important concepts of operating system because it is well documented, fast and uses less resources.