API del kernel Linux

Passeremo attraverso l'interfaccia di programmazione dell'applicazione Linux, l'API. Il kernel Linux fornisce le chiamate di sistema che possono essere utilizzate per eseguire l'attività tramite il kernel. Discutiamo le poche chiamate di sistema ampiamente utilizzate di Linux.

Descrizione:

Il kernel Linux fornisce il set o l'elenco di funzioni che possono essere utilizzate dai programmi di spazio utente per utilizzare i servizi del kernel Linux.

Il diagramma a blocchi sembra il seguente:

Alcune delle poche chiamate di sistema ampiamente utilizzate sono aperte, chiuse, lette e scrivono. Queste sono chiamate di sistema di base fornite da Linux Kernel. Ogni attività viene eseguita tramite file in Linux. Quindi, le operazioni di base su qualsiasi file possono essere eseguite tramite apertura, chiusura, lettura e scrittura.

Facciamo un vero esempio in cui vogliamo stampare il "Hello World" sulla console seriale. Per ottenere questa attività tramite le chiamate di sistema, dobbiamo aprire il file del dispositivo per la console in /dev. Una volta individuato il file del dispositivo per console o UART, possiamo utilizzare la chiamata di sistema aperta per aprire il dispositivo.

Ecco la sintassi della chiamata del sistema aperto:

int Open (const char *pathname, flags int);
int Open (const char *pathname, flags int, modalità modalità_t);

Da questa sintassi, il primo argomento è il percorso del file che vogliamo aprire. Nel nostro caso, è il file del dispositivo che abbiamo individuato come dispositivo di console. Nel prossimo argomento, i flag forniscono all'utente una certa flessibilità di giocare con il file. Pochi esempio dei flag sono O_Creat, O_append, ecc. Queste bandiere hanno significati e scopi specifici e la discussione è fuori dall'ambito di questa discussione. Per maggiori dettagli su flag e parametri, consultare le pagine del kernel man.

Una volta che il file è aperto correttamente, dobbiamo utilizzare la chiamata del sistema di scrittura per inviare il "Hello World" al dispositivo console. Il prototipo della chiamata del sistema di scrittura è il seguente:

ssize_t write (int fd, const void *buf, size_t count);

Il primo parametro della chiamata del sistema di scrittura è il FD che è il descrittore dei file. Il "FD" ci viene dato dalla chiamata del sistema aperto. Dopo aver aperto correttamente il file, dovremmo ottenere il descrittore dei file. Questo FD viene utilizzato ulteriormente per scrivere i dati.

Il secondo parametro è l'indirizzo del buffer per l'invio dei dati al dispositivo console. Nel nostro caso, i dati di test sono "Hello World".

L'ultimo parametro è il numero totale di byte che l'utente desidera scrivere sul dispositivo console. Nel nostro caso, il numero di byte ha le dimensioni di "Hello World". Possiamo utilizzare l'operatore sizeof o la funzione Strlen per ottenere il numero di byte. Dovremmo stare attenti durante l'utilizzo di Strlen. Questa funzione ignora il carattere di terminazione stringa come "\ 0". Quindi, mentre leggiamo la stringa, dobbiamo garantire che il carattere nullo sia gestito correttamente. Altrimenti, finiremo con l'errore di segmentazione.

Ora, implementiamo la parte del codice di questo esempio. Innanzitutto, dobbiamo individuare la console seriale o il dispositivo UART. Nella macchina, quello che utilizziamo ha il dispositivo seriale TTY AS/Dev/PTS/0. Quindi, come discusso, dobbiamo prima aprire questo file. Dobbiamo anche includere il file più duro che fornisce la dichiarazione di chiamata di sistema aperto.

Il nostro codice per l'apertura del file del dispositivo sembra il seguente:

#includere
fd = open (“/dev/pts/0”, o_wronly);

Successivamente, quando vogliamo chiamare la chiamata del sistema di scrittura, utilizziamo il FD fornito da Open. La nostra chiamata per scrivere sembra la seguente:

#includere
char *data = "ciao mondo";
scrivere (FD, dati, strlen (dati) +1);

Il precedente frammento di codice scrive il "Hello World" alla console seriale che abbiamo individuato e vogliamo scrivere.

Mettiamo insieme tutti i pezzi:

#includere
#includere
#includere
#includere
#includere
int main ()

int fd; int rc;
char *data = "ciao mondo";
fd = open (“/dev/pts/0”, o_wronly);
if (fd<0)

printf ("File di apertura degli errori:%D", FD);
uscita (-1);

rc = write (fd, dati, strlen (dati) +1);
if (RC<0)

printf ("File di scrittura di errori:%D", RC);
uscita (-1);

chiudere (FD); // L'operazione del file viene eseguita, chiudere il file.
restituzione 0;

La compilazione del programma precedente è lo stesso della compilazione degli altri programmi C come i seguenti:

GCC Test_Write.c -o test_write.

Test_Write.C è il nome del file al nostro codice C.

Dopo la compilazione, otteniamo l'eseguibile con il nome test_write.

Fare riferimento alla seguente istantanea:

Dopo aver eseguito il binario compilato e generato, abbiamo la seguente uscita.

Il nostro output del nostro programma è evidenziato in grassetto. Di seguito è riportata l'istantanea per il riferimento:

Finora abbiamo visto un esempio in cui utilizziamo l'API Linux per visualizzare la stringa di prova sulla console. Questo è il semplice esempio. Ci sono molte altre offerte fornite dalla chiamata di sistema. Poche delle chiamate di sistema fornite da Linux sono le seguenti:

• Leggere: Leggere dal file.
• scrivere: Scrivere al file.
• aprire: Apertura del file.
• vicino: Chiusura del file.
• sondaggio: Sondaggio del dispositivo per la modifica dello stato.
• LSEEK: Alla ricerca di un particolare offset nel file.
• mmap: Mappatura della memoria virtuale alla memoria fisica.
• BRK: Cambia la dimensione del segmento.
• ioctl: Dispositivi di controllo.
• accesso: Accesso per ottenere le autorizzazioni del file.
• tubo: Si riferisce alla creazione di pipa.

e molti altri.

Questo è l'enorme elenco di funzioni fornite da Linux Kernel. Abbiamo visto e discusso pochissimi. Fare riferimento alla fonte del kernel per l'elenco completo delle chiamate di sistema fornite dal kernel.

Conclusione

Abbiamo discusso delle chiamate di sistema che è un modo per chiedere al kernel di eseguire le attività per i programmi di spazio utente. Senza la chiamata di sistema, non sarà possibile per i programmi di spazio utente eseguire l'attività dal kernel. Abbiamo preso un semplice compito o un esempio di scrittura dei dati di test, "Hello World", al dispositivo seriale. Abbiamo impiegato le API aperte, scritte e chiuse del kernel per completare l'attività in mano. Una cosa più importante è controllare il valore di restituzione della chiamata di sistema. Il kernel fornisce valori di restituzione adeguati per spiegare il motivo in caso di fallimento della funzione. L'utente può avere l'idea sul motivo di errore vedendo i valori di ritorno dalla chiamata di sistema. I valori di ritorno hanno qualche significato specifico e sono ben catturati nella documentazione del kernel.