Chiamata di sistema nel sistema operativo (Operating System): cos'è, tipologie ed esempi
Nathaniel Brooks
⚡ Riepilogo intelligente
La chiamata di sistema è l'interfaccia controllata che un processo utilizza per richiedere servizi del kernel come l'accesso ai file, il controllo dei processi e la comunicazione con i dispositivi, consentendo il passaggio sicuro della CPU dalla modalità utente alla modalità kernel privilegiata.
Cos'è la chiamata di sistema in Operasistema?
A chiamata di sistema è un meccanismo che fornisce l'interfaccia tra un processo e il sistema operativo. È un metodo programmatico in cui un programma per computer richiede un servizio dal kernel del sistema operativo.
La chiamata di sistema offre i servizi del sistema operativo ai programmi utente tramite API (Application Programming Interface). Le chiamate di sistema sono gli unici punti di ingresso per il sistema kernel.
Il sistema chiama in entrata Operasistema di ting
Esempio di chiamata di sistema
Ad esempio, per scrivere un programma che legga i dati da un file e li copi in un altro, il programma ha bisogno innanzitutto dei nomi dei due file: il file di input e il file di output.
In un sistema interattivo, questo tipo di esecuzione del programma richiede alcune chiamate di sistema da parte del sistema operativo.
- La prima operazione consiste nello scrivere un messaggio di suggerimento sullo schermo.
- Il secondo metodo consiste nel leggere, dalla tastiera, i caratteri che definiscono i due file.
Come funziona la chiamata di sistema?
Ecco i passaggi per una chiamata di sistema nel sistema operativo:
Archistruttura della System Call
Come potete vedere nel diagramma delle chiamate di sistema qui sopra:
Passo 1) I processi vengono eseguiti in modalità utente finché una chiamata di sistema non li interrompe.
Passo 2) Dopodiché, la chiamata di sistema viene eseguita in modalità kernel in base alla priorità.
Passo 3) Una volta terminata l'esecuzione della chiamata di sistema, il controllo ritorna alla modalità utente.
Passo 4) L'esecuzione dei processi utente riprende, passando dalla modalità utente alla modalità utente e modalità kernel come richiesto.
Perché hai bisogno delle chiamate di sistema nel sistema operativo?
Di seguito sono elencate le situazioni che richiedono chiamate di sistema nel sistema operativo:
- La lettura e la scrittura da file richiedono chiamate di sistema.
- Se un file system desidera creare o eliminare file, sono necessarie le chiamate di sistema.
- Le chiamate di sistema vengono utilizzate per la creazione e la gestione di nuovi processi.
- Le connessioni di rete necessitano di chiamate di sistema per inviare e ricevere pacchetti.
- L'accesso a dispositivi hardware come scanner o stampanti richiede una chiamata di sistema.
Tipi di chiamate di sistema
Ecco i cinque tipi di chiamate di sistema presenti nei sistemi operativi:
- Controllo del Processo
- Gestione dei file
- Gestione dei dispositivi
- Manutenzione delle informazioni
- Communication
Tipi di chiamate di sistema nel sistema operativo
Controllo del Processo
Queste chiamate di sistema svolgono l'attività di creazione e terminazione dei processi, ecc.
Funzioni:
- Termina e interrompi
- Carica ed esegui
- Crea processo e termina processo
- Aspetta e Signal Event
- Assegnare e liberare memoria
Gestione dei file
Le chiamate del sistema di gestione dei file gestiscono lavori di manipolazione dei file come la creazione di un file, la lettura e la scrittura, ecc.
Funzioni:
- Crea un file
- Cancella il file
- Apri e chiudi il file
- Leggi, scrivi e riposiziona
- Ottieni e imposta gli attributi del file
Gestione dei dispositivi
La gestione dei dispositivi si occupa della manipolazione dei dispositivi stessi, ad esempio della lettura dai buffer dei dispositivi, della scrittura nei buffer dei dispositivi, ecc.
Funzioni:
- Richiesta e rilascio dispositivo
- Collegare o scollegare logicamente i dispositivi
- Ottenere e impostare gli attributi del dispositivo
Manutenzione delle informazioni
Gestisce le informazioni e il loro trasferimento tra il sistema operativo e il programma utente.
Funzioni:
- Ottieni o imposta ora e data
- Ottieni attributi di processo e dispositivo
Communication
Questi tipi di chiamate di sistema sono utilizzati specificamente per la comunicazione tra processi.
Funzioni:
- Creare ed eliminare connessioni di comunicazione
- Inviare e ricevere messaggi
- Aiuta il sistema operativo a trasferire le informazioni sullo stato
- Collega o scollega dispositivi remoti
Regole per il passaggio dei parametri per la chiamata di sistema
Ecco le regole generali per il passaggio dei parametri alla chiamata di sistema:
- I parametri devono essere inseriti o rimossi dallo stack dal sistema operativo.
- I parametri possono essere passati nei registri.
- Quando i parametri sono più numerosi dei registri disponibili, è necessario memorizzarli in un blocco e passare l'indirizzo del blocco tramite un registro.
Chiamate di sistema importanti utilizzate nel sistema operativo
aspettare()
In alcuni sistemi, un processo deve attendere il completamento di un altro. Ciò si verifica quando un processo padre crea un processo figlio e il padre rimane sospeso finché il figlio non termina.
La sospensione del processo padre avviene automaticamente tramite la chiamata di sistema wait(). Quando il processo figlio termina l'esecuzione, il controllo torna al processo padre.
forchetta()
I processi utilizzano questa chiamata di sistema per creare processi che sono copie di se stessi. Con l'aiuto di fork(), un processo padre crea un processo figlio e il padre viene sospeso finché il processo figlio non viene eseguito.
exec ()
Questa chiamata di sistema esegue un file eseguibile all'interno di un processo già in esecuzione, sostituendo quello precedente. L'identificativo del processo originale rimane invariato poiché non viene creato un nuovo processo, ma lo stack, i dati, l'heap, ecc., vengono sostituiti dal nuovo processo.
uccisione()
La chiamata di sistema kill() viene utilizzata dal sistema operativo per inviare un segnale di terminazione a un processo, invitandolo a terminare. Tuttavia, una chiamata di sistema kill non significa necessariamente terminare il processo e può avere diversi significati.
Uscita()
La chiamata di sistema exit() viene utilizzata per terminare l'esecuzione di un programma. In particolare, in un ambiente multi-thread, questa chiamata indica che l'esecuzione del thread è completata. Il sistema operativo recupera le risorse utilizzate dal processo dopo la chiamata exit().
