Cenni storici sui Sistemi Operativi

Generalita' sui Sistemi Operativi
Il problema delle protezioni nella multiprogrammazione
Cenni sulla gestione dei Processi
Struttura interna di un sistema operativo
8086 Interrupt

• Macchina Virtuale
• Programma di Controllo
• Gestore delle Risorse

Evoluzione

A. Senza sistema operativo

Programmatore = Operatore

1 unico programma. Uso console, panel switch, schede.
Programmazione in codice binario, piuttosto difficile.
Operazioni simili sempre da riprogrammare da zero.

Soluzioni

Linguaggio Assembler e uso di assemblatori
Loader, linker, librerie di funzioni Device driver. Compilatori (Fortran, Cobol).

Problemi

Aumento del job setup time. La CPU rimane idle per molto tempo.

B. Monitor

Programmatore <> Operatore

Batch System Necessita' di raggruppare i job con simili caratteristiche.
Stop del computer in caso di errore (dump della memoria).

Soluzioni

Sequenzializzatore automatico dei job. Resident Monitor. Uso di Control Card.

                  +-----------------------+
                  |                       |
                  |  ( interrupt vector)  |
                  |  device drivers       |    MONITOR
                  |  job sequencing       |
                  |  interprete schede    |
                  |                       |
                  +-----------------------+
                  |                       |
                  |  Programmi utente     |
                  |                       |
                  +-----------------------+

Problemi

Lunghi tempi di CPU idle durante l'attesa per l'I/O.

C. Multiprogrammazione

1. Operazioni Off Line

        lettore            line
        schede     =====>  printer

   lettore       nastro                     nastro
   schede   ===> magnetico                  magnetico    printer
   ------------------------  ==>  CPU  ==>  -------------------- 
     Satellite Computer                      Satellite Computer

Primo caso di elaborazione distribuita.
Concetti di device independence e Logical I/O device.
Performance ==> Uso di lettori e printer multipli.

2. Buffering e Interrupt

I Buffer di memoria rosicchiano un po' di tempo "anticipando" o "ritardando" operazioni di I/O.
Difficile programmazione.
Passaggio da polling a interrupt.

3. Disk System e Spooling

Possibilita' di alternare rapidamente letture e scritture.
SPOOL: Simultaneous Peripheral OPeration On-Line.
Bufferizza su piu' job. Multiprocessing.

4. Multiprogrammazione

+-------------------------------------+
|          |        |        |        |
|  MONITOR |  job1  |  job2  |  job3  |
|          |        |        |        |
+-------------------------------------+

S.O. piu' complessi. Necessita' di gestione memoria.
Schede CPU, controllo concorrenza.
Necessita' di protezione.

5. Time Sharing

Problema batch: lunghe attese, scarsa interazione, difficolta' di debugging
(basato su dump binario di memoria).

Soluzioni: I/O da terminale, editori e debugger interattivi.

Risultati: miglioramento del response time
(ogni utente vede il computer come macchina a lui assegnata).

6. Personal Computer

Workstation di uso personale, con software user friendly.

Connessione network: ogni WS ha il suo S.O. e la connessione consente di utilizzare in modo condiviso device e memorie. (Network Operating System).

Sistemi Distribuiti: un unico sistema operativo distribuito su tutte le WS
(Distributed Operating System).

Sistemi Distribuiti come macchina parallela: un job puo' essere composto da piu' processi sequenziali ciascuno dei quali puo' essere eseguito su una diversa workstation.

Generazioni

Prima generazione: 1945-1955. Uso di valvole.

Seconda generazione: 1955-1965. Transistor. IBM 1401, IBM 7094.

Terza generazione: 1965-1980 . Circuiti integrati (IC).
IBM System/360 (famiglia) OS/360.
Sistema spooling e Time sharing opzionali (TSO: Time Sharing Option).

Quarta generazione: 1980-1990.
LSI-VLSI. IBM PC, DEC PDP11, .......

Real Time System

L'elaborazione deve avvenire entro un ben definito intervallo di tempo.

Sistema Operativo come gerarchia di macchine virtuali

Il S.O. puo' essere visto come gerarchia di macchine astratte strutturate in una architettura di sistema.

Ogni livello di astrazione mette a disposizione un linguaggio per interagire con l'utente e consentirgli di controllare le risorse.

A partire dai livelli piu' alti abbiamo:

• Interfaccia Utente
  Testuale
  Grafica (con finestre)
• Ambiente di programmazione
  editor, compilatori, debugger, ...
  Librerie, data base, ...
• Linguaggi di sistema
  L. programmazione applicazioni,
  L. configurazione (es. makefile),
  L. interfaccia utente (es. shell),
  L. servizi di sistema (funzioni del S.O.).

Sistema Operativo come gestore di risorse

Il S.O. gestisce risorse software quali:

• Archiviazione dati e programmi
  database,
  librerie
• Esecuzione di programmi
  ambiente di programmazione,
  esecutori: compilatori, debugger)
• Ingresso e uscita (I/O)
  dispositivi di visualizzazione e stampa,
• Comunicazione
  posta elettronica,
  remote login,
  remote file transfer,

e risorse fisiche (processore, memoria, dispositivi), effettuandone l'allocazione agli utenti, ottimizzandone la gestione tramite opportune politiche e risolvendo i conflitti di accesso tramite sincronizzazione e mutua esclusione.

Il problema delle Protezioni nella
multiprogrammazione ( Indice )

Condivisione risorse

• errori con side effect non voluti (loop di lettura input, ...)
• errori voluti: maliziosi (furto di tempo della CPU)

Gli errori dovrebbero scoperti dall'hardware ==> interrupt e dump.

Protezione dell'I/O

Esempio: l'utente puo' scrivere un nuovo driver e usare quello per leggere schede (o altre informazioni di input) destinate ad altri utenti.

Soluzione

Due modi di operazione: User e Superuser (system o kernel).
Un bit del registro di controllo indica il modo operativo.
Le istruzioni di I/O possono essere eseguite solo in modo supervisor, altrimenti viene segnalato un errore.

Problema: Come si passa da modo utente a modo supervisor?

Le richieste di operazioni di I/O possono essere fatte dall'utente al Sistema Operativo solo attraverso System call (interruzioni software o trap) che consentono di passare in modo superuser.

Protezione della memoria

Possibilita' di modificare il vettore delle interruzioni.
Caricamento nella parte bassa della memoria.

Prima di eseguire una istruzione in modo user si confronta l'indirizzo del dato con il contenuto del fence register.

Protezione CPU

Timer per interrompere loop.
Modificabile in modo supervisor.

La gestione dei processi, la loro creazione e terminazione e la gestione delle comunicazioni fra processi e' la parte piu' importante (il nucleo) di un Sistema Operativo.

Processo sequenziale

Definizione usuale: e' una parte di codice in esecuzione assieme al suo ambiente: contenuto dei registri, stack ...).

Definizione piu' corretta: e' un'attivita' controllata da un programma che si svolge su un processore. Nel caso di sistemi multiprocessore, il processo puo' non essere legato ad un particolare processore.

Un processo puo' quindi non avanzare in modo continuo, pero' quando avanza, occupa in modo esclusivo un processore.

In un sistema possono esistere piu' processi solo se:

• si tratta di un sistema multiprocessore,
• si tratta di un sistema multiprogrammazione, in cui piu' processi condividono
       (in interleaving) la stessa CPU.

Un processo e' rappresentabile come una terna P = (IM, IP, S) dove:

Immagine in Memoria: insieme del codice e dei dati, modificabile dal processo in avanzamento. Puo' essere interamente contenuta in memoria, in modo statico, o essere presente solo parzialmente (gestione dinamica).

Immagine del Processore: Informazioni sul processo mantenute nei registri del processore, anch'esse modificabili.

Stato di avanzamento: un processo ha uno stato fra Ready, Running e Blocked.

• Stato Running: il processore e' assegnato al processo (dal S.O.) che puo' avanzare dell'esecuzione.
• Stato Blocked: il processo non dispone del processore perche' bloccato in attesa di un servizio.
• Stato Ready: il processo e' in attesa dell'assegnazione del processore, che e' occupato da un altro processo.

Processo esterno: Per comodita' di rappresentazione le attivita' esterne (svolte da periferici come stampanti, o dall'utente stesso) sono viste come processi esterni.

Un processo puo' essere bloccato o mandato in esecuzione a seconda della disponibilita' del processore e della politica di assegnazione della CPU ai processi.

I processi in stato ready (pronti) sono selezionati per l'esecuzione in base ad una opportuna politica (schedulazione). Gli obiettivi sono diversi:

1. evitare che la CPU sia inattiva,
2. fare avanzare i processi con velocita' dipendenti dalla loro priorita',
3. evitare che un processo debba attendere per un tempo indefinitamente lungo prima di essere eseguito (attesa indefinita o starvation).

Il software di gestione del processore include anche la gestione delle interruzioni e lo scambio di messaggi tra processi del sistema.

Implementazione Processi

Mantenimento di una Process Table (program counter, stack pointer, ...) per salvare alcuni dati riguardanti lo stato del processo.

Comunicazione fra processi

Puo' avvenire senza o con interruzioni, con condivisione di memoria o file.
Problema dovuto alla multiprogrammazione "invisibile":

Operazione: un processo prende il valore del puntatore, lo incrementa, lo rimemorizza modificato, poi aggiunge nel buffer il file da stampare.

Race: ProcA prende un puntatore, poi perde l'uso della CPU. ProcB prende lo stesso puntatore, lo incrementa e lo rimette a posto, poi inserisce il suo file nel buffer. ProcA riprende l'esecuzione, incrementa e salva il valore del puntatore, ed inserisce il file nello stesso slot del buffer che aveva usato ProcB.

l S.O. dal punto di vista del S.O.

E' un programma event (interrupt) driven. Un'interruzione puo' essere:

• system call (trap),
• I/O device interrupt,
• Errore del programma (trap).

Oltre alla tavola dei processi, ogni device ha una Device Status Table (tipo servizio, indirizzo, stato: functioning, idle, busy, ...).

Lista di richieste se busy:

Flusso di controllo del Sistema Operativo.

Chiamiamo nucleo o kernel di un S.O. la parte del sistema piu' a basso livello, il cui compito specifico e' quello di gestire i processi. Il kernel comprende, come minimo:

• le strutture dati necessarie per descrivere lo stato di un processo;
• i meccanismi per la generazione e la terminazione dei processi,
• i meccanismi per la gestione dell'interazione fra processi
  (condivisione di memoria o scambio di messaggi).

Le possibili organizzazioni di un S.O. differiscono nella collocazione del codice delle funzioni di gestione delle risorse.

L'intero S.O. tende ad essere identificato con il nucleo, che comprende anche le funzioni di gestione delle risorse. Normalmente il nucleo e' formato da un insieme di procedure (gestori delle risorse e dei processi), che sono linkate assieme, formando cosi' una struttura compatta.

Il nucleo ha una struttura gerarchica:

• al primo livello: gestione processi,
• procedure corrispondenti alle chiamate di sistema,
• utente.

Struttura caratteristica di UNIX.

L'interazione fra utente e sistema avviene secondo il modello

quando un processo utente richiede una funzione del nucleo, la esegue come se fosse una sua procedura (con una interruzione software per il passaggio di modo).

Lo stato di ogni risorsa e' descritto da dati comuni, su cui operano le procedure di sistema, si presuppone quindi la condivisione dei dati:

Poiche' alcune funzioni sono richiedibili da piu' processi contemporaneamente e i dati sono condivisi, si ha una alta probabilita' di errore (esempio: race condition). Sono quindi necessari ulteriori strumenti di protezione, del tipo di racchiudere entro strutture di monitor i dati e le procedure per la gestione delle risorse (protezione assicurata dal compilatore, non e' inoltre possibile usare altri strumenti di programmazione).

Questo modello non e' adatto ad essere usato in ambiente distribuito.

Sistemi monolitici a Livelli

THE. Primo esempio, S.O. (Dijkstra e studenti).

Il sistema era in multiprogrammazione, ma con un solo eseguibile, quindi non estendibile. Aveva 6 livelli, i primi 4 corrispondono al nucleo, gli ultimi due contengono i processi interprete dei comandi e i processi dell'operatore.

MULTICS Elaborato dal MIT (1965-70) per mainframe. Sistema di protezione con trap software. Da MULTICS derivera' UNIX (Bell Labs) che sara' implementato su PDP 11 nel 1970.

Macchina Virtuale
VM/370. Da IBM CP/CMS (1970) a VM/370.
Forniva la multiprogrammazione e funzioni virtuali.

Fra il livello user e quello del S.O. CMS si passava tramite trap, cosi' come fra S.O. CMS e VM/370.

Il nucleo e' minimo, gestisce unicamente i processi, mentre le risorse e i servizi sono gestiti tramite processi in user mode. E' possibile aggiungere funzionalita': sistema aperto.
E' garantito un maggior confinamento degli errori.

Il nucleo gestisce anche l'interazione fra i processi utenti e i servizi forniti dal S.O. Questa interazione puo' ancora essere basata sul modello "orientato alle procedure" come nel caso monolitico, oppure seguire il piu' evoluto modello

In quest'ultimo caso si distingue tra processi utente (client) e processi server che gestiscono servizi.

Interazione di tipo Client-Server
I processi client richiedono servizi ai processi server tramite

e utilizzano le risorse esclusivamente attraverso i relativi processi di controllo. Ogni risorsa e' gestita da un processo, l'unico che puo accedere ai dati che la descrivono. Questi dati sono protetti dal processore e dal nucleo.

I processi non condividono dati.

Non si esclude la possibilita' che i meccanismi del nucleo siano realizzati mediante dati condivisi.

Caratteristiche:

• separazione delle politiche dai meccanismi.
• modularita'.
• portabilita' anche verso sitemi distribuiti.

Poiche' solo il kernel lavora in modo superuser, deve fornire delle primitive che possono essere richieste dai server e che comprendono le istruzioni privilegiate.

Riprendiamo il problema della protezione dei S.O., sia per quanto riguarda la possibilita' di effettuare operazioni di I/O (solo kernel) sia per impedire ai processi l'accesso alla memoria riservata al kernel.

Vediamo meglio il meccanismo delle interruzioni, che possono essere:

• Interruzioni hardware (segnali provenienti da dispositivi esterni)
• Interruzione software o trap (provocate dall'esecuzione di una specifica istruzione di trap, e quindi detta anche interruzione sincrona)
• Interruzioni generate dall'hardware interno in caso di errori (es. divisione per zero).

In Figura 1.15 abbiamo uno schema hardware dell'Intel.

In Figura 1.16 e' rappresentato il flusso di controllo durante un'interruzione. L'operazione e' compiuta da un circuito hardware dedicato.

• IF - interrupt flag (la richiesta e' sospesa ma rimane attiva).
• TF - trap flag (single step execution)

La CPU ha al suo interno l'unita' aritmetica di calcolo e l'instruction register, che contiene il puntatore all'istruzione macchina che deve essere eseguita alla fine di quella in corso. Alla fine di ogni istruzione, viene attivata un circuito hardware che esegue le operazioni visibili in figura 1.16.

• Si controlla cioe' se ci sono delle interruzioni, ed eventualmente di quale tipo (se proviene dall'8259 si legge sul bus dei dati a quale numero corrisponde, le interruzioni software sono ugualmente associate ad un numero).
• Se c'e' un'interruzione che deve essere considerata, il contenuto dei flags, del code segment e dell'instruction pointer vengono automaticamente inseriti sul top dello stack (utilizzando il valore dello stack pointer register)
• Si passa in modo kernel (e' questo l'unico modo possibile per effettuare questa operazione)
• Vengono disabilitate le interruzioni (tranne la non masherabile, NMI)
• Si accede al vettore delle interruzioni usando come indice il tipo dell'interruzione: in quella posizione c'e' l'indirizzo ad una zona di memoria (parte alta della memoria, accessibile solo in modo kernel)
• Si effettua una chiamata alla procedura che inizia in quella locazione di memoria  (Interrupt Service routine della figura 1.16)

 La procedura e' dunque attivata con le interruzioni disabilitate. Possono essere riabilitate al suo interno usando l'istruzione enable interrupt. Alla fine la procedura non effettua un normale return, ma un return from interrupt, che causa l'esecuzione del micro codice: (harwdware)

• I valori al top dello stack (puntato dallo stack pointer) vengono copiati sul registro dei flags, sul code segment e sull'instruction register.
• A questo punto si chiude il loop. La CPU esegue l'istruzione puntata dall'instruction register.

Il vettore delle interruzioni dell'8086 occupa 255 posizioni di memoria a partire dall'indirizzo 0. Le prime sono dedicate (interruzioni hardware gia' presenti), altre sono vuote, ma riservate dall'Intel per future compatibilita', le altre sono libere per l'utente.  Fra le posizioni dedicate ad esempio, la posizione 4 corrisponde ad un overflow in esecuzione, la 2 e' attivata da una interruzione NMI, la 1 al single step e la 0 all'errore di divisione per zero.
 
 Il vettore si trova nell'area di memoria dedicata al kernel, protetta dal fence register. Solo i processi che operano in modo kernel possono accedere a quet'area. Per passare in modo kernel esiste un'unico meccanismo, quello delle interruzioni. E' chiaro quindi che se il vettore delle interruzioni e il codice e i dati "delicati" del kernel si trovano in quest'area, essa non po' essere acceduta ne' modificata da un processo in modo user (a meno di errori di chi scrive il kernel!!!).

Il meccanismo delle trap e' anche usato per la schedulazione e quindi per realizzare la multiprogrammazione.

Riassumendo, entrambi i meccanismi di protezione si basano sull'esistenza di due modi hdw operativi: modo user e superuser.

• La protezione della memoria si basa sul fatto che un processo che esegue in stato user non puo' accedere all'area di memoria piu' bassa, bloccata dal fence register.
• La protezione dell'I/O si basa sul fatto che un processo in modo user non puo' eseguire istruzioni di I/O.

Per passsare da modo user a superuser esiste solo il meccanismo delle interruzioni con l'accesso forzato al vettore delle interruzioni, posto in una parte di memoria protetta.