Lec 4: OS structure (cont)

• virtual CPU w/ threads
• virtualize memory w/ address spaces

• virtualize I/O
• Use H/w privilege
• protected control transfer (syscall)

Previous lecture: virtualize CPU and memory

• CPU virtualization: Timer interrupts only fire every 1-100ms (every 1M instructions) upon which kernel saves execution context (i.e. CPU registers etc.)
• Memory virtualization: MMU translates virtual address to physical address (happens in h/w, very fast)

+--procdescriptor_t--------+
|   ....                   |
|registers (%eax,%esp,...) |
|  address space           |
|   ...                    |
+--------------------------+

Virtualize I/O

• Compared to CPU and memory, most I/O devices are slow (especially those in direct contact with humans - keyboard, mouse) overhead when handling I/O devices tends to be acceptable.
• It is dangerous to allow complete control over an I/O device. For instance, file protection on a hard drive
• It is good to have a similar high-level interface that works for all devices, regardless of manufacturer.

int read_file(char *filename, int offset, char *buffer, int len)

int read(int fd, char *buffer, int len)

off_t lseek(int fd, off_t offset, int whence)

int write(int fd, const void *data, int len)

int open(const char *name, int mode);

+--procdescriptor_t--------+
|   ....                   |
|registers (%eax,%esp,...) |
|  address space           |
|file descriptor table     |
+--------------------------+

+--file descriptor table--------------+
| ...                                 |
| "wordfile.txt", O_RDONLY, offset=10 |
| tcp_socket, O_RDWR,  ....           |
| ...                                 |
+-------------------------------------+

Waiting on I/O

read_ide_sector()
{
  while ((inb(0x1F7) & (0xC0)) != 0x40)
    /* do nothing */
}

+--procdescriptor_t--------+
|   ....                   |
|registers (%eax,%esp,...) |
|  address space           |
|file descriptor table     |
|process state             |
+--------------------------+

Basic Process interaction: Fork and Exec

pid_t pid;
pid = fork();
if (pid == 0) {
  //do child code
}else{
  //do parent code
}

• create new procdescriptor_t entry for the new process
• copy memory, registers, file descriptor table.
• For parent, set %eax=child's process ID, for child, set %eax = 0.

H/w Privilege

• timer interrupt to force an applicaiton process to give up CPU
• virtual memory to enforce memory protection

if (CPL != 0)
  raise exception;
else
  execute instruction;

Protected control transfer

1. Processor switches to a numerically lower pivilege level, e.g. with int
2. Processor performs stack switch if switching to a numerically lower pivilege level
3. Processor saves the EFLAGS, CS, EIP registers on the stack
4. Processor jumps to the interrupt/trap gate based on the interrupt #.
5. Kernel stores the general registers (%eax,%ebx,...) into memory
6. Kernel performs the rest of interrupt handling logic
7. Kernel invokes the iret instruction to return to interrupted procedure (restores saved EIP, CS, EFLAGS, performs stack switching, resets privilege)

System call

H/w vs. software fault isolation

• not possible for arbitary x86 code (unaligned code, self-modifying code)
• arbitary x86 code is difficult to disassemble correctly.
• possible if we enforce lots of structure in x86 code (read-only code segment, aligned code etc. it's an active research area)

• E.g. JVM runtime executes java bytecode. JVM can refuse to execute a "dangerous" instruction.
• Bad: Slow. Forces all apps to be written in java (or at least compile to Java bytecode).

Summary: Organization of a Modern Operating System

• servers: VM, FS, TCP/IP, Print, Display
• some servers have privileged access to h/w, some don't

Digression: H/w emulation

• The Bochs emulator works by
  • doing exactly what a real x86 PC would do,
  • only implemented in software rather than hardware!
• Runs as a normal process in a "host" operating system (e.g., Linux)
• Uses normal process storage to hold emulated hardware state:
  • Stores emulated CPU registers in global variables

    		int32_t regs[8];
    		#define REG_EAX 1;
    		#define REG_EBX 2;
    		#define REG_ECX 3;
    		...
    		int32_t eip;
    		int16_t segregs[4];
    		...
    		

  • Stores emulated physical memory in Boch's memory

                    char mem[256*1024*1024];
                    

• Execute instructions by simulating them in a loop:

  	for (;;) {
  		read_instruction();
  		switch (decode_instruction_opcode()) {
  		case OPCODE_ADD:
  			int src = decode_src_reg();
  			int dst = decode_dst_reg();
  			regs[dst] = regs[dst] + regs[src];
  			break;
  		case OPCODE_SUB:
  			int src = decode_src_reg();
  			int dst = decode_dst_reg();
  			regs[dst] = regs[dst] - regs[src];
  			break;
  		...
  		}
  		eip += instruction_length;
  	}
  	

• Simulate PC's physical memory map by decoding emulated "physical" addresses just like a PC would.
• Simulate I/O devices, etc., by detecting accesses to "special" memory and I/O space and emulating the correct behavior: e.g.,
  • Reads/writes to emulated hard disk transformed into reads/writes of a file on the host system
  • Writes to emulated VGA display hardware transformed into drawing into an X window
  • Reads from emulated PC keyboard transformed into reads from X input event queue