Nell'informatica, a chiamata di sistema è un modo programmatico in cui un programma per computer richiede un servizio dal kernel del sistema operativo su cui viene eseguito. Una chiamata di sistema è un modo per i programmi di farlo interagire con il sistema operativo . Un programma per computer effettua una chiamata di sistema quando effettua una richiesta al kernel del sistema operativo. Chiamata di sistema fornisce i servizi del sistema operativo ai programmi utente tramite Application Program Interface (API). Fornisce un'interfaccia tra un processo e un sistema operativo per consentire ai processi a livello utente di richiedere servizi del sistema operativo. Le chiamate di sistema sono gli unici punti di ingresso nel file nocciolo sistema. Tutti i programmi che necessitano di risorse devono utilizzare le chiamate di sistema.
Un programma utente può interagire con il sistema operativo utilizzando una chiamata di sistema. Il programma richiede una serie di servizi e il sistema operativo risponde lanciando una serie di chiamate di sistema per soddisfare la richiesta. Una chiamata di sistema può essere scritta in linguaggi di alto livello come C o Pascal o in linguaggio assembly. Se viene utilizzato un linguaggio di alto livello, il sistema operativo può invocare direttamente le chiamate di sistema, che sono funzioni predefinite.
Una chiamata di sistema è un meccanismo utilizzato dai programmi per richiedere servizi da sistema operativo (sistema operativo). In termini più semplici, è un modo con cui un programma interagisce con il sistema sottostante, ad esempio accedendo alle risorse hardware o eseguendo operazioni privilegiate.
Una chiamata di sistema viene avviata dal programma che esegue un'istruzione specifica, che attiva un passaggio a nocciolo modalità, consentendo al programma di richiedere un servizio dal sistema operativo. Il sistema operativo quindi gestisce la richiesta, esegue le operazioni necessarie e restituisce il risultato al programma.
Le chiamate di sistema sono essenziali per il corretto funzionamento di un sistema operativo, poiché forniscono ai programmi un modo standardizzato per accedere alle risorse di sistema. Senza le chiamate di sistema, ogni programma dovrebbe implementare i propri metodi per accedere all'hardware e ai servizi di sistema, portando a comportamenti incoerenti e soggetti a errori.
Servizi forniti dalle chiamate di sistema
- Creazione e gestione dei processi
- Gestione della memoria principale
- Gestione dell'accesso ai file, delle directory e del file system
- Gestione del dispositivo (I/O)
- Protezione
- Rete, ecc.
- Controllo di processo: terminare, interrompere, creare, terminare, allocare e liberare memoria.
- Gestione dei file: creare, aprire, chiudere, eliminare, leggere file, ecc.
- Gestione dei dispositivi
- Manutenzione delle informazioni
- Comunicazione
Caratteristiche delle chiamate di sistema
- Interfaccia: Le chiamate di sistema forniscono un'interfaccia ben definita tra i programmi utente e il sistema operativo. I programmi effettuano richieste chiamando funzioni specifiche e il sistema operativo risponde eseguendo il servizio richiesto e restituendo un risultato.
- Protezione: Le chiamate di sistema vengono utilizzate per accedere a operazioni privilegiate che non sono disponibili per i normali programmi utente. Il sistema operativo utilizza questo privilegio per proteggere il sistema da accessi dannosi o non autorizzati.
- Modalità kernel: Quando viene effettuata una chiamata di sistema, il programma viene temporaneamente commutato dalla modalità utente alla modalità kernel. In modalità kernel, il programma ha accesso a tutte le risorse di sistema, inclusi hardware, memoria e altri processi.
- Cambio di contesto: Una chiamata di sistema richiede un cambio di contesto, che comporta il salvataggio dello stato del processo corrente e il passaggio alla modalità kernel per eseguire il servizio richiesto. Ciò può introdurre un sovraccarico, che può influire sulle prestazioni del sistema.
- Gestione degli errori: Le chiamate di sistema possono restituire codici di errore per indicare problemi con il servizio richiesto. I programmi devono verificare la presenza di questi errori e gestirli in modo appropriato.
- Sincronizzazione: Le chiamate di sistema possono essere utilizzate per sincronizzare l'accesso alle risorse condivise, come file o connessioni di rete. Il sistema operativo fornisce meccanismi di sincronizzazione, come blocchi o semafori, per garantire che più programmi possano accedere a queste risorse in modo sicuro.
Vantaggi delle chiamate di sistema
- Accesso alle risorse hardware: Le chiamate di sistema consentono ai programmi di accedere a risorse hardware come unità disco, stampanti e dispositivi di rete.
- Gestione della memoria: Le chiamate di sistema forniscono ai programmi un modo per allocare e deallocare la memoria, nonché per accedere ai dispositivi hardware mappati in memoria.
- Gestione dei processi: Le chiamate di sistema consentono ai programmi di creare e terminare processi, nonché di gestire la comunicazione tra processi.
- Sicurezza: Le chiamate di sistema forniscono ai programmi un modo per accedere a risorse privilegiate, come la possibilità di modificare le impostazioni di sistema o eseguire operazioni che richiedono autorizzazioni amministrative.
- Standardizzazione: Le chiamate di sistema forniscono un'interfaccia standardizzata per consentire ai programmi di interagire con il sistema operativo, garantendo coerenza e compatibilità tra diverse piattaforme hardware e versioni del sistema operativo.
Come funziona la chiamata di sistema?
Ecco la spiegazione dettagliata passo dopo passo di come funziona la chiamata di sistema:
- L'utente ha bisogno di risorse speciali: A volte i programmi devono eseguire alcune operazioni speciali che non possono essere eseguite senza l'autorizzazione del sistema operativo, come leggere da un file, scrivere su un file, ottenere informazioni dall'hardware o richiedere uno spazio in memoria.
- Il programma effettua una richiesta di chiamata di sistema: Esistono speciali istruzioni predefinite per effettuare una richiesta al sistema operativo. Queste istruzioni non sono altro che una semplice chiamata di sistema. Il programma utilizza queste chiamate di sistema nel suo codice quando necessario.
- Il sistema operativo vede la chiamata di sistema: Quando il sistema operativo vede la chiamata di sistema, riconosce che il programma ha bisogno di aiuto in questo momento, quindi interrompe temporaneamente l'esecuzione del programma e dà tutto il controllo a una parte speciale di se stesso chiamata 'Kernel'. Ora 'Kernel' risolve la necessità del programma.
- Il sistema operativo esegue le operazioni: Ora il sistema operativo esegue l'operazione richiesta dal programma. Esempio: leggere il contenuto di un file ecc.
- Il sistema operativo restituisce il controllo al programma: Dopo aver eseguito l'operazione speciale, il sistema operativo restituisce il controllo al programma per l'ulteriore esecuzione del programma.
Esempi di chiamate di sistema in Windows e Unix
Le chiamate di sistema per Windows e Unix sono disponibili in molte forme diverse. Questi sono elencati nella tabella seguente come segue:
| Processi | finestre | Unix |
|---|---|---|
| Controllo di processo | CreaProcesso() Processo di uscita() WaitForSingleObject() | Forchetta() Uscita() Aspettare() |
| Manipolazione dei file | CreaFile() LeggiFile() ScriviFile() | Aprire() Leggere() converti int in double java Scrivere() Vicino() |
| Gestione dei dispositivi | Imposta modalità console() LeggiConsole() ScriviConsole() | Ioctl() Scorciatoie da tastiera di Linux Leggere() Scrivere() |
| Manutenzione delle informazioni | OttieniIDProcessoCorrente() SetTimer() Sonno() | Getpid() Allarme() Sonno() |
| Comunicazione | CreaPipe() CreaFileMapping() MapViewOfFile() | Tubo() Shmget() Mappa() |
| Protezione | SetFileSecurity() InizializzaSecurityDescriptor() SetSecurityDescriptorgroup() | Chmod() smascherare() Chown() |
aprire(): L'accesso a un file su un file system è possibile con la chiamata di sistema open(). Fornisce le risorse file di cui ha bisogno e un handle che il processo può utilizzare. Un file può essere aperto da più processi contemporaneamente o da un solo processo. Tutto si basa sulla struttura e sul file system.
Leggere(): I dati da un file sul file system vengono recuperati utilizzandolo. In generale, accetta tre argomenti:
- Una descrizione di un file.
- Un buffer per l'archiviazione dei dati di lettura.
- Quanti byte devono essere letti dal file
Prima della lettura, il file da leggere può essere identificato dal suo descrittore di file e aperto utilizzando la funzione open().
Aspettare(): In alcuni sistemi, potrebbe essere necessario sospendere un processo fino al termine dell'esecuzione di un altro processo prima di continuare. Quando un processo genitore crea un processo figlio, l'esecuzione del processo genitore viene interrotta fino al completamento del processo figlio. Il processo genitore viene interrotto utilizzando la chiamata di sistema wait(). Il processo genitore riprende il controllo una volta che il processo figlio ha terminato l'esecuzione.
scrivere(): I dati di un buffer utente vengono scritti utilizzandolo su un dispositivo come un file. Un programma può produrre dati in un modo utilizzando questo chiamata di sistema . generalmente, ci sono tre argomenti:
- Una descrizione di un file.
- Un riferimento al buffer in cui sono archiviati i dati.
- La quantità di dati che verranno scritti dal buffer in byte.
forchetta(): La chiamata di sistema fork() viene utilizzata dai processi per creare copie di se stessi. È uno dei metodi utilizzati più frequentemente nei sistemi operativi per creare processi. Quando un processo genitore crea un processo figlio, l'esecuzione del processo genitore viene sospesa fino al termine del processo figlio. Il processo genitore riprende il controllo una volta che il processo figlio ha terminato l'esecuzione.
Uscita(): Una chiamata di sistema chiamata exit() viene utilizzata per terminare un programma. Negli ambienti con più thread, questa chiamata indica che l'esecuzione del thread è terminata. Dopo aver utilizzato la funzione di sistema exit(), il sistema operativo recupera le risorse utilizzate dal processo.
Metodi per passare i parametri al sistema operativo
Se si verifica una chiamata di sistema, dobbiamo passare il parametro alla parte Kernal del sistema operativo.
Ad esempio, guarda il dato aprire() chiamata di sistema:
C
controllo null Java
//function call example> #include> int> open(>const> char> *pathname,>int> flags, mode_t mode);> |
>
>
Qui nome del percorso , bandiere E modalità_t sono i parametri.
Quindi è da notare che:
- Non possiamo passare i parametri direttamente come in una normale chiamata di funzione.
- In modalità Kernal esiste un modo diverso per eseguire una chiamata di funzione.
Quindi non possiamo eseguirlo nel normale spazio degli indirizzi che il processo ha già creato e quindi non possiamo posizionare i parametri in cima allo stack perché non è disponibile per l'elaborazione da parte del Kernal del sistema operativo. quindi dobbiamo adottare eventuali altri metodi per passare i parametri al Kernal del sistema operativo.
linux $casa
Possiamo farcela,
- Passaggio di parametri nei registri
- L'indirizzo del blocco viene passato come parametro in un registro.
- I parametri vengono inseriti in uno stack.
Parliamo di ogni punto in dettaglio:
1. Passaggio dei parametri nei registri.
- È il metodo più semplice tra i tre
- Qui passiamo direttamente i parametri ai registri.
- Ma sarà limitato quando il numero di parametri è maggiore del numero di registri.
- Ecco il codice del programma C:
C
// Passing parameters in registers.> #include> #include> int> main()> {> >const> char>* pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> fd = open(pathname, flags, mode);> >// in function call open(), we passed the parameters pathanme,flags,mode to the kernal directly> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
2.L'indirizzo del blocco viene passato come parametro
- Può essere applicato quando il numero di parametri è maggiore del numero di registri.
- I parametri sono memorizzati in blocchi o tabelle.
- L'indirizzo del blocco viene passato ad un registro come parametro.
- Più comunemente usato in Linux e Solaris.
- Ecco il codice del programma C:
C
//Address of the block is passed as parameters> #include> #include> int> main() {> >const> char> *pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> params[3];> >// Block of data(parameters) in array> >params[0] = (>int>)pathname;> >params[1] = flags;> >params[2] = mode;> >int> fd = syscall(SYS_open, params);> >// system call> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
3.I parametri vengono inseriti in uno stack
- In questo metodo i parametri possono essere inseriti utilizzando il programma ed estratti utilizzando il sistema operativo
- Quindi il Kernal può accedere facilmente ai dati recuperando le informazioni dalla cima dello stack.
- Ecco il codice del programma C
C
//parameters are pushed into the stack> #include> #include> #include> int> main() {> >const> char> *pathname =>'example.txt'>;> >int> flags = O_RDONLY;> >mode_t mode = 0644;> >int> fd;> >asm>volatile>(> >'mov %1, %%rdi
'> >'mov %2, %%rsi
'> >'mov %3, %%rdx
'> >'mov , %%rax
'> >'syscall'> >:>'=a'> (fd)> >:>'r'> (pathname),>'r'> (flags),>'r'> (mode)> >:>'%rdi'>,>'%rsi'>,>'%rdx'> >);> >if> (fd == -1) {> >perror>(>'Error opening file'>);> >return> 1;> >}> >// File operations here...> >close(fd);> >return> 0;> }> |
>
>
strutture dati java
Domande frequenti
Q.1: Come funziona una chiamata di sistema?
Risposta:
Quando un programma esegue una chiamata di sistema, passa dalla modalità utente alla modalità kernel, che è una modalità con privilegi più elevati. La transizione viene generalmente avviata richiamando una funzione specifica o interrompendo un'istruzione fornita dal linguaggio di programmazione o dal sistema operativo.
Una volta in modalità kernel, la chiamata di sistema viene gestita dal sistema operativo. Il kernel esegue l'operazione richiesta per conto del programma e restituisce il risultato. Successivamente, il controllo viene restituito al programma a livello utente, che continua la sua esecuzione.
Q.2: Perché sono necessarie le chiamate di sistema?
Risposta:
Le chiamate di sistema sono necessarie per diversi motivi:
Accesso alle operazioni privilegiate: Molte operazioni, come la gestione dei dispositivi hardware o la modifica delle configurazioni di sistema, richiedono privilegi più elevati accessibili solo tramite chiamate di sistema.
Gestione delle risorse: Le chiamate di sistema forniscono un'interfaccia standardizzata per l'allocazione e la gestione delle risorse di sistema come memoria, file e dispositivi, garantendo un accesso equo e controllato da parte di diversi processi.
Astrazione: Le chiamate di sistema astraggono le complessità sottostanti del sistema operativo, consentendo agli sviluppatori di applicazioni di interagire con il sistema a un livello superiore e indipendente dalla piattaforma.
Sicurezza e protezione: Le chiamate di sistema applicano politiche di controllo e sicurezza degli accessi, impedendo l'accesso non autorizzato a risorse sensibili e proteggendo l'integrità del sistema.