Una chiamata di sistema è un modo con cui un programma utente può interfacciarsi con il sistema operativo. Il programma richiede diversi servizi e il sistema operativo risponde invocando una serie di chiamate di sistema per soddisfare la richiesta. Una chiamata di sistema può essere scritta in linguaggio assembly o in un linguaggio di alto livello simile C O Pascal . Le chiamate di sistema sono funzioni predefinite che il sistema operativo può invocare direttamente se viene utilizzato un linguaggio di alto livello.
In questo articolo imparerai a conoscere le chiamate di sistema nel sistema operativo e ne discuterai i tipi e molte altre cose.
Cos'è una chiamata di sistema?
Una chiamata di sistema è un metodo con cui un programma per computer richiede un servizio dal kernel del sistema operativo su cui è in esecuzione. Una chiamata di sistema è un metodo per interagire con il sistema operativo tramite programmi. Una chiamata di sistema è una richiesta dal software del computer al kernel di un sistema operativo.
IL Interfaccia del programma applicativo (API) collega le funzioni del sistema operativo ai programmi utente. Funge da collegamento tra il sistema operativo e un processo, consentendo ai programmi a livello utente di richiedere servizi del sistema operativo. È possibile accedere al sistema kernel solo utilizzando le chiamate di sistema. Le chiamate di sistema sono necessarie per tutti i programmi che utilizzano risorse.
Come vengono effettuate le chiamate di sistema?
Quando un software per computer deve accedere al kernel del sistema operativo, effettua una chiamata di sistema. La chiamata di sistema utilizza un'API per esporre i servizi del sistema operativo ai programmi utente. È l'unico metodo per accedere al sistema kernel. Tutti i programmi o processi che richiedono risorse per l'esecuzione devono utilizzare chiamate di sistema, poiché fungono da interfaccia tra il sistema operativo e i programmi utente.
Di seguito sono riportati alcuni esempi di come una chiamata di sistema varia da una funzione utente.
caratteri di escape Java
- Una funzione di chiamata di sistema può creare e utilizzare processi del kernel per eseguire l'elaborazione asincrona.
- Una chiamata di sistema ha maggiore autorità di una subroutine standard. Una chiamata di sistema con privilegio in modalità kernel viene eseguita nel dominio di protezione del kernel.
- Alle chiamate di sistema non è consentito utilizzare librerie condivise o simboli non presenti nel dominio di protezione del kernel.
- Il codice e i dati per le chiamate di sistema sono archiviati nella memoria globale del kernel.
Perché sono necessarie le chiamate di sistema nel sistema operativo?
Esistono varie situazioni in cui è necessario richiedere chiamate di sistema nel sistema operativo. Le seguenti situazioni sono le seguenti:
- È necessario richiederlo quando un file system desidera creare o eliminare un file.
- Le connessioni di rete richiedono le chiamate di sistema per l'invio e la ricezione di pacchetti di dati.
- Se vuoi leggere o scrivere un file, devi effettuare chiamate di sistema.
- Se desideri accedere ai dispositivi hardware, inclusi stampante e scanner, hai bisogno di una chiamata di sistema.
- Le chiamate di sistema vengono utilizzate per creare e gestire nuovi processi.
Come funzionano le chiamate di sistema
Le applicazioni vengono eseguite in un'area di memoria nota come spazio utente. Una chiamata di sistema si connette al kernel del sistema operativo, che viene eseguito nello spazio del kernel. Quando un'applicazione crea una chiamata di sistema, deve prima ottenere l'autorizzazione dal kernel. Ciò avviene utilizzando una richiesta di interruzione, che mette in pausa il processo corrente e trasferisce il controllo al kernel.
Se la richiesta è consentita, il kernel esegue l'azione richiesta, come la creazione o l'eliminazione di un file. Come input, l'applicazione riceve l'output del kernel. L'applicazione riprende la procedura dopo aver ricevuto l'input. Al termine dell'operazione, il kernel restituisce i risultati all'applicazione e quindi sposta i dati dallo spazio del kernel allo spazio utente in memoria.
Una semplice chiamata di sistema può richiedere alcuni nanosecondi per fornire il risultato, come il recupero della data e dell'ora del sistema. Una chiamata di sistema più complicata, come la connessione a un dispositivo di rete, potrebbe richiedere alcuni secondi. La maggior parte dei sistemi operativi avvia un thread del kernel distinto per ciascuna chiamata di sistema per evitare colli di bottiglia. I moderni sistemi operativi sono multi-thread, il che significa che possono gestire diverse chiamate di sistema contemporaneamente.
Tipi di chiamate di sistema
Esistono comunemente cinque tipi di chiamate di sistema. Questi sono i seguenti:
Ora imparerai a conoscere tutti i diversi tipi di chiamate di sistema uno per uno.
Controllo di processo
Il controllo del processo è la chiamata di sistema utilizzata per dirigere i processi. Alcuni esempi di controllo del processo includono creazione, caricamento, interruzione, fine, esecuzione, elaborazione, terminazione del processo, ecc.
Gestione dei file
La gestione dei file è una chiamata di sistema utilizzata per gestire i file. Alcuni esempi di gestione dei file includono la creazione di file, l'eliminazione di file, l'apertura, la chiusura, la lettura, la scrittura, ecc.
nome dei caratteri speciali
Gestione dei dispositivi
La gestione dei dispositivi è una chiamata di sistema utilizzata per gestire i dispositivi. Alcuni esempi di gestione dei dispositivi includono lettura, dispositivo, scrittura, acquisizione attributi dispositivo, rilascio dispositivo, ecc.
Manutenzione delle informazioni
La manutenzione delle informazioni è una chiamata di sistema utilizzata per mantenere le informazioni. Esistono alcuni esempi di manutenzione delle informazioni, tra cui l'acquisizione dei dati di sistema, l'impostazione dell'ora o della data, l'acquisizione dell'ora o della data, l'impostazione dei dati di sistema, ecc.
Comunicazione
La comunicazione è una chiamata di sistema utilizzata per la comunicazione. Esistono alcuni esempi di comunicazione, tra cui creare, eliminare connessioni di comunicazione, inviare, ricevere messaggi, ecc.
Esempi di chiamate di sistema Windows e Unix
Esistono vari esempi di chiamate di sistema Windows e Unix. Questi sono elencati di seguito nella tabella:
| Processi | finestre | Unix |
|---|---|---|
| Controllo di processo | CreaProcesso() Processo di uscita() WaitForSingleObject() | Forchetta() Uscita() Aspettare() |
| Manipolazione dei file | CreaFile() LeggiFile() ScriviFile() ChiudiHandle() | Aprire() Leggere() Scrivere() Vicino() |
| Gestione dei dispositivi | Imposta modalità console() LeggiConsole() ScriviConsole() | Ioctl() Leggere() Scrivere() |
| Manutenzione delle informazioni | OttieniIDProcessoCorrente() SetTimer() Sonno() | Getpid() Allarme() Sonno() |
| Comunicazione | CreaPipe() CreaFileMapping() MapViewOfFile() | Tubo() Shmget() Mappa() |
| Protezione | SetFileSecurity() InizializzaSecurityDescriptor() SetSecurityDescriptorgroup() | Chmod() maschera() Chown() |
Qui imparerai brevemente alcuni metodi:
aprire()
IL aprire() La chiamata di sistema consente di accedere a un file su un file system. Assegna risorse al file e fornisce un handle a cui il processo può fare riferimento. Molti processi possono aprire un file contemporaneamente o solo tramite un singolo processo. È tutto basato sul file system e sulla struttura.
math.pow java
Leggere()
Viene utilizzato per ottenere dati da un file nel file system. Accetta tre argomenti in generale:
- Un descrittore di file.
- Un buffer per archiviare i dati letti.
- Il numero di byte da leggere dal file.
Il descrittore del file da leggere potrebbe essere utilizzato per identificarlo e aprirlo utilizzando aprire() prima di leggere.
Aspettare()
In alcuni sistemi, un processo potrebbe dover attendere che un altro processo completi la propria esecuzione prima di procedere. Quando un processo genitore crea un processo figlio, l'esecuzione del processo genitore viene sospesa fino al termine del processo figlio. IL Aspettare() la chiamata di sistema viene utilizzata per sospendere il processo genitore. Una volta che il processo figlio ha completato la sua esecuzione, il controllo viene restituito al processo genitore.
scrivere()
Viene utilizzato per scrivere dati da un buffer utente su un dispositivo come un file. Questa chiamata di sistema è un modo in cui un programma può generare dati. In generale sono necessari tre argomenti:
- Un descrittore di file.
- Puntatore al buffer in cui vengono salvati i dati.
- Il numero di byte da scrivere dal buffer.
forchetta()
I processi generano cloni di se stessi utilizzando il file forchetta() chiamata di sistema. È uno dei modi più comuni per creare processi nei sistemi operativi. Quando un processo genitore genera un processo figlio, l'esecuzione del processo genitore viene interrotta fino al completamento del processo figlio. Una volta che il processo figlio ha completato la sua esecuzione, il controllo viene restituito al processo genitore.
vicino()
Viene utilizzato per terminare l'accesso al file system. Quando viene richiamata questa chiamata di sistema, significa che il programma non richiede più il file e che i buffer vengono svuotati, le informazioni sul file vengono alterate e di conseguenza le risorse del file vengono deallocate.
python salva json su file
exec()
Quando un file eseguibile sostituisce un file eseguibile precedente in un processo già in esecuzione, viene richiamata questa funzione di sistema. Poiché non viene creato un nuovo processo, l'identificazione del vecchio processo rimane, ma il nuovo processo sostituisce dati, stack, dati, testa, ecc.
Uscita()
IL Uscita() è una chiamata di sistema utilizzata per terminare l'esecuzione del programma. Questa chiamata indica che l'esecuzione del thread è completa, il che è particolarmente utile in ambienti multi-thread. Il sistema operativo recupera le risorse spese dal processo in seguito all'utilizzo di Uscita() funzione del sistema.