Qual è la relazione tra chiamate di sistema, passaggio di messaggi e interruzioni?

Sto leggendo l'articolo di Wikipedia per la gestione dei processi . Il mio focus è su Linux. Non riesco a capire la relazione e le differenze tra chiamata di sistema, passaggio di messaggi e interruzione, nei loro concetti e scopi. Sono tutti per i processi che fanno richieste al kernel per risorse e servizi?

Alcune citazioni dall'articolo e altre:

1. Esistono due modi possibili per un sistema operativo di riprendere il controllo del processore durante l'esecuzione di un programma in modo che il sistema operativo possa eseguire la disallocazione o l'allocazione:

   1. Il processo emette una chiamata di sistema (a volte chiamata interruzione software); ad esempio, si verifica una richiesta I / O che richiede di accedere a un file sul disco rigido.
   2. Si verifica un interrupt di processo; ad esempio, è stato premuto un tasto sulla tastiera oppure è scaduto un timer (utilizzato nel multitasking preventivo).

2. Esistono due tecniche mediante le quali un programma in esecuzione in modalità utente può richiedere i servizi del kernel:

   * System call
   * Message passing
   

3. un interrupt è un segnale asincrono che indica la necessità di attenzione o un evento sincrono nel software che indica la necessità di un cambiamento nell'esecuzione.

   Un interrupt di processo fa sì che il processore salvi il suo stato di esecuzione e inizi l'esecuzione di un gestore di interrupt. Gli interrupt software sono di solito implementati come istruzioni nel set di istruzioni, che causano un cambio di contesto a un gestore di interrupt simile a un interrupt di processo.

1. Tutti i moderni sistemi operativi supportano il multitasking. Ciò significa che il sistema è in grado di eseguire più processi contemporaneamente; sia in pseudo-parallelo (quando è disponibile solo una CPU) o oggigiorno con CPU multi-core comuni in parallelo (un task / core).

   Prendiamo il caso più semplice di una sola CPU disponibile. Ciò significa che se si eseguono contemporaneamente due processi diversi (diciamo un browser Web e un lettore musicale), il sistema non è in grado di eseguirli contemporaneamente. Quello che succede è che la CPU passa continuamente da un processo all'altro; ma questo sta accadendo in modo estremamente rapido, quindi non te ne accorgi mai.

   Ora supponiamo che mentre questi due processi sono in esecuzione, si preme il pulsante di ripristino (cattivo ragazzo). La CPU interromperà immediatamente qualsiasi operazione e riavvierà il sistema. Congratulazioni: hai generato un interrupt.

   Il caso è simile quando si sta programmando e si desidera richiedere un servizio dalla CPU. La differenza è che in questo caso si esegue il codice del software, in genere procedure di libreria che eseguono chiamate di sistema (ad esempio fopenper l'apertura di un file).

   Pertanto, 1 descrive due modi diversi per attirare l'attenzione dalla CPU.

2. La maggior parte dei sistemi operativi moderni supporta due modalità di esecuzione: modalità utente e modalità kernel. Per impostazione predefinita, un sistema operativo funziona in modalità utente. La modalità utente è molto limitata. Ad esempio, è vietato tutto l'I / O; pertanto, non è consentito aprire un file dal disco rigido. Ovviamente ciò non accade mai, perché quando si apre un file il sistema operativo passa in modo trasparente dalla modalità utente a quella kernel. In modalità kernel hai il controllo totale dell'hardware.

   Se ti stai chiedendo perché esistono queste due modalità, la risposta più semplice è per la protezione. I sistemi operativi basati su microkernel (ad esempio MINIX 3) hanno la maggior parte dei loro servizi in esecuzione in modalità utente, il che li rende meno dannosi. I kernel monolitici (come Linux) hanno quasi tutti i loro servizi in esecuzione in modalità kernel. Pertanto è improbabile che un driver che si arresta in modo anomalo in MINIX 3 possa far crollare l'intero sistema, mentre ciò non è insolito in Linux.

   Le chiamate di sistema sono la primitiva utilizzata nei kernel monolitici (modello di dati condivisi) per passare dalla modalità utente a quella kernel. Il passaggio dei messaggi è la primitiva utilizzata nei microkernel (modello client / server). Per essere più precisi, in un messaggio che passa i programmatori di sistema usano anche le chiamate di sistema per attirare l'attenzione della CPU. Il passaggio dei messaggi è visibile solo agli sviluppatori del sistema operativo. I kernel monolitici che utilizzano le chiamate di sistema sono più veloci ma meno affidabili, mentre i micro kernel che utilizzano il passaggio dei messaggi sono più lenti ma hanno un migliore isolamento dei guasti.

   Pertanto, 2 menziona due modi diversi di passare dalla modalità utente a quella kernel.

3. Per rivedere, il modo più comune di creare un interrupt software, noto anche come trap, è eseguire una chiamata di sistema. D'altra parte, gli interrupt sono generati esclusivamente dall'hardware.

   Quando interrompiamo la CPU (tramite software o hardware), è necessario salvare da qualche parte il suo stato attuale - il processo che esegue e a quel punto si è fermato - altrimenti non sarà in grado di riprendere il processo quando si torna indietro . Questo è chiamato interruttore di contesto ed ha senso: prima di spegnere il computer per fare qualcos'altro, devi prima assicurarti di aver salvato tutti i tuoi programmi / documenti, ecc. In modo da poter riprendere dal punto in cui hai interrotto il la prossima volta lo accenderai :)

   Pertanto, 3 spiega cosa deve essere fatto dopo aver eseguito una trappola o un interrupt e quanto sono simili i due casi.

Le chiamate di sistema, il passaggio di messaggi (come descritto nell'articolo di Wikipedia) e gli interrupt sono tutti elementi che causano un cambio di contesto o un passaggio dalla modalità utente a quella kernel. Come probabilmente saprai:

• modalità kernel: i programmi hanno una visione piatta o reale della memoria, e i programmi possono leggere / scrivere liberamente su tutta la memoria e tutti i dispositivi hardware direttamente senza restrizioni.

• modalità utente: i programmi hanno una vista virtualizzata della memoria, i programmi non possono leggere / scrivere liberamente su tutta la memoria e non possono leggere / scrivere direttamente i dispositivi hardware. Per ottenere più memoria o accedere a dispositivi hardware, il programma in modalità utente deve chiamare il kernel. Le chiamate di sistema e il passaggio dei messaggi sono due metodi per farlo.

Le chiamate di sistema comportano l'esecuzione di una specifica istruzione CPU o set di istruzioni, che fanno saltare la CPU (salvando prima l'indirizzo di ritorno nello stack) a un indirizzo predefinito (non scrivibile in modalità utente) e spostano la CPU dalla modalità utente alla modalità kernel (ring 3 per suonare 0 nell'architettura Intel).

Gli interrupt di processo fanno la stessa cosa, fanno saltare la CPU (salvando prima l'indirizzo di ritorno nello stack) a un indirizzo predefinito e spostano la CPU dalla modalità utente alla modalità kernel. Quindi in molte CPU lo stesso meccanismo può essere invocato dal software (chiamato "interruzione software") e può essere utilizzato per le chiamate CPU.

Il passaggio dei messaggi implica (almeno per me) che il kernel è un "processo in esecuzione" che riceverà un flusso di messaggi e che esiste una funzione accessibile in modalità utente che invierà tali messaggi. Oppure potrebbe essere che la funzione "send" inserisca i valori su uno stack e la prossima volta che il kernel ha il controllo (o se si verifica un blocco di processo o un interrupt) fa uscire i messaggi dallo stack e li invia alle routine interne di conseguenza.

In un'architettura di microkernel in cui l'attuale "kernel" è molto minimo e la maggior parte delle funzioni fornite da un kernel sono spostate in processi "server", che potrebbero essere in esecuzione contemporaneamente su un sistema multi-CPU, qualcosa del genere potrebbe essere maggiore utile del semplice approccio di chiamata del vecchio sistema. L'interpretazione e l'instradamento dei "messaggi" al "server" appropriato del kernel sarebbe uno dei pochi lavori del microkernel.

Il passaggio di messaggi è un concetto di livello superiore di un processo che invia un messaggio a un altro. È implementato da una chiamata di sistema (kernel), che chiede al kernel di passare il messaggio all'altro processo. Le chiamate di sistema chiedono al kernel di eseguire vari servizi per il processo. Sono implementati da un interrupt software / trap di sistema, che fa sì che la CPU salvi uno stato nello stack in modo che possa tornare in seguito, quindi passare alla modalità kernel e passare al gestore del kernel.

Sia gli interrupt hardware che software causano il salvataggio dello stato della CPU, il passaggio alla modalità kernel e il passaggio a un gestore definito per quell'interrupt. La differenza è che gli interrupt di processo sono generati da hardware esterno quando hanno bisogno di attenzione, come una tastiera che indica che è stato premuto un tasto. Il gestore della tastiera può quindi leggere la porta I / O della tastiera per vedere quale tasto è stato premuto e intraprendere le azioni appropriate, quindi tornare al programma che è stato interrotto.