Chiamate di sistema Linux

Le chiamate di sistema fornite dal kernel Linux sono esposte nel linguaggio di programmazione C tramite GLIBC. Quando viene utilizzata una chiamata di sistema, si sta comunicando al sistema operativo e al ritorno il sistema operativo ti comunica attraverso i parametri che vengono restituiti alle funzioni di chiamata di sistema (valori di ritorno).

Chiamata del sistema stat:

Stat System Call è una chiamata di sistema in Linux per verificare lo stato di un file come verificare quando si accede al file. La chiamata di sistema stat () restituisce effettivamente gli attributi del file. Gli attributi del file di un inode sono sostanzialmente restituiti dalla funzione stat (). Un inode contiene i metadati del file. Un inode contiene: il tipo di file, la dimensione del file, al momento dell'accesso al file (modificato, eliminato) che è timestamp e il percorso del file, l'ID utente e l'ID gruppo, collegamenti del file e indirizzo fisico del contenuto del file.

Possiamo dire che Inode contiene tutti i dati richiesti per la chiamata di sistema STAT () ed è il numero dell'indice per il file che viene salvato nella tabella INODE. Ogni volta che si crea un file viene creato un numero di inode per quel file. L'uso del sistema STAT Chiama le tabelle di sistema è possibile visualizzare.

Sintassi della chiamata del sistema stat C:

Per utilizzare la chiamata di sistema stat in linguaggio di programmazione C, è necessario includere il seguente file di intestazione:

#includere

Stat viene utilizzato per ottenere lo stato di un file. La sintassi della chiamata del sistema stat C potrebbe non essere la stessa per ogni sistema operativo. In Linux la sintassi per la chiamata di sistema stat è la seguente:

int stat (const char *percorso, struct stat *buf)

Il tipo di restituzione della funzione in int, se la funzione viene eseguita correttamente, 0 viene restituito se ci sono errori, -1 verrà restituito.

Qui percorso const char * Specifica il nome del file. Se il percorso del file è un collegamento simbolico, è necessario specificare il link anziché il nome del file.

Quindi nella funzione abbiamo una struttura stat in cui vengono archiviati i dati o le informazioni sul file che utilizza un puntatore denominato buf, che viene passato come parametro e compilato durante l'esecuzione della chiamata e leggibile dall'utente dopo la chiamata.

STRUTTURA STAT:

La struttura stat che è definita nel file di intestazione contiene i seguenti campi:

Struttura stat

modalità_t st_mode;
ino_t st_ino;
dev_t st_dev;
dev_t st_rdev;
nlink_t st_nlink;
uid_t st_uid;
GID_T ST_GID;
off_t st_size;
struct timspec st_atim;
struct timspec st_mtim;
struct timspec st_ctim;
blksize_t st_blksize;
blkcnt_t st_blocks;
;

Descrizione:

1. ST_DEV: È l'ID del dispositivo in cui abbiamo il nostro file che risiede attualmente.
2. ST_RDEV: Questo campo descrive che un particolare file rappresenta un particolare dispositivo.
3. St_ino: È il numero di inodo o il numero di serie del file. In quanto è un numero di indice, quindi dovrebbe essere univoco per tutti i file
4. st_size: st_size è la dimensione del file in byte.
5. st_atime: È l'ultima volta o il tempo recente in cui è stato accessibile al file.
6. st_ctime: È il momento recente in cui sono stati modificati lo stato o le autorizzazioni del file.
7. st_mtime: È il momento recente in cui il file è stato modificato.
8. st_blksize: Questo campo fornisce la dimensione del blocco preferita per il file system I/O che può variare da file a file.
9. ST_BLOCKS: Questo campo racconta il numero totale di blocchi in multipli di 512 byte.
10. st_nlink: Questo campo racconta il numero totale di collegamenti rigidi.
11. st_uid: Questo campo indica l'ID utente.
12. ST_GID: Questo campo indica l'ID del gruppo.
13. st_mode: Indica le autorizzazioni sul file, racconta le modalità su un file. Di seguito sono riportati i flag che dovrebbero essere definiti per il campo ST_MODE:

Bandiere	Descrizione	Valore della bandiera
S_IFMT	Una maschera bit usata per ottenere il valore della modalità di un file	0170000
S_ifsock	Una costante di file di socket	0140000
S_iflink	Una costante di file di collegamento simbolico	0120000
S_ifreg	File costante per file regolare	0100000
S_ifblk	File costante per file di blocco	0060000
S_ifdir	File costante per il file di directory	0040000
S_ifchr	File costante per il file dei caratteri	0020000
S_ififo	Una costante di file di FIFO	0010000
S_isuid	Imposta bit ID utente	0004000
S_isgid	Imposta bit ID gruppo	0002000
S_isvtx	Bit appiccicoso che indica il testo condiviso	0001000
S_irwxu	Autorizzazioni del proprietario (leggi, scrivi, esecuzione)	00700
S_irusr	Leggi le autorizzazioni per il proprietario	00400
S_iwusr	Scrivi autorizzazioni per il proprietario	00200
S_IXUSR	Eseguire autorizzazioni per il proprietario	00100
S_irwxg	Autorizzazioni di gruppo (leggere, scrivere, eseguire)	00070
S_irgrp	Leggi le autorizzazioni per il gruppo	00040
S_iwgrp	Scrivi le autorizzazioni per il gruppo	00020
S_ixgrp	Eseguire le autorizzazioni per il gruppo	00010
S_irwxo	Autorizzazioni per altri (leggi, scrivi, esegui)	00007
S_iroth	Leggi le autorizzazioni per gli altri	00004
S_iwoth	Scrivi le autorizzazioni per gli altri	00002
S_IXOTH	Eseguire autorizzazioni per gli altri	00001

---

Come utilizzare la chiamata del sistema stat:

Il seguente esempio mostra come utilizzare la chiamata del sistema stat in linguaggio di programmazione C in Linux, Ubuntu.

ESEMPIO 1:

Nel seguente codice troveremo la modalità di un file:

CODICE:

#includere
#includere
int main ()

// puntatore a stat struct
struct Stat Sfile;
// chiamata di sistema stat
stat ("Stat.C ", & Sfile);
// Accesso a ST_MODE (membro dei dati di STAT Struttura)
printf ("st_mode = %o", sfile.st_mode);
restituzione 0;

La compilazione e l'esecuzione del programma ritorna come di seguito:

In questo codice, abbiamo superato il nome del file nella chiamata del sistema stat e quindi il puntatore a stat struct che è SFILE. Il puntatore a stat struct viene quindi utilizzato per accedere a ST_MODE che visualizza la modalità del file utilizzando l'istruzione printf.

Viene utilizzato il file di intestazione in modo da poter utilizzare la chiamata di sistema stat. Il file di intestazione è il file della libreria di input/output standard in modo da poter utilizzare printf o scanf nel codice C.

Esempio 2:

Nel seguente codice otterremo informazioni sul file utilizzando la chiamata di sistema stat:

CODICE:

#includere
#includere
#includere
#includere
void SFILE (char const filename []);
int main ()
ssize_t leggi;
char* buffer = 0;
size_t buf_size = 0;
printf ("Immettere il nome di un file per controllare: \ n");
leggi = getline (& buffer, & buf_size, stdin);
if (leggi <=0 )
printf ("getline non riuscita \ n");
uscita (1);

if (buffer [read-1] == '\ n')
Buffer [read-1] = 0;

int s = open (buffer, o_rdonly);
if (s ==-1)
printf ("Il file non esiste \ n");
uscita (1);

altro
SFILE (buffer);

gratuito (buffer);
restituzione 0;

void SFILE (char const filename [])
struct Stat Sfile;
if (stat (fileName, & sfile) ==-1)
printf ("errore si è verificato \ n");

// Accesso ai membri dei dati di STAT Struttura
printf ("\ nfile st_uid %d \ n", sfile.st_uid);
printf ("\ nfile st_blksize %ld \ n", sfile.st_blksize);
printf ("\ nfile st_gid %d \ n", sfile.st_gid);
printf ("\ nfile st_blocks %ld \ n", sfile.st_blocks);
printf ("\ nfile st_size %ld \ n", sfile.st_size);
printf ("\ nfile st_nlink %u \ n", (unsigned int) sfile.st_nlink);
printf ("\ nfile autorizzazioni utente \ n");
printf ((SFILE.ST_MODE & S_IRUSR)? "R":"-");
printf ((SFILE.ST_MODE & S_IWUSR)? "w": "-");
printf ((SFILE.ST_MODE & S_IXUSR)? "X":"-");
printf ("\ n");
printf ("\ nfile per autorizzazioni \ n");
printf ((SFILE.ST_MODE & S_IRGRP)? "R":"-");
printf ((SFILE.ST_MODE & S_IWGRP)? "w": "-");
printf ((SFILE.ST_MODE & S_IXGRP)? "X":"-");
printf ("\ n");
printf ("\ nfile autorizzazioni altre \ n");
printf ((SFILE.ST_MODE & S_IROTH)? "R":"-");
printf ((SFILE.ST_MODE & S_IWOTH)? "w": "-");
printf ((SFILE.ST_MODE & S_IXOTH)? "X":"-");
printf ("\ n");

PRODUZIONE:

Nel codice C sopra, abbiamo inserito il nome del file e se il file non esiste, l'esecuzione del programma verrà arrestata. Questo è dimostrato nella seguente immagine:

Se esiste il nostro file, la funzione SFILE (N) verrà chiamata in cui abbiamo superato il nome del file. All'interno della funzione, prima di tutto abbiamo usato la chiamata di sistema stat, se stat () restituisce -1, allora deve essere necessario qualsiasi errore in modo che un messaggio verrà stampato e l'esecuzione del programma verrà arrestata.

Quindi nell'istruzione Printf abbiamo usato il nome della funzione e del separatore DOT per accedere ai membri dei dati di STRUTT STAT.

Quindi per la modalità di file abbiamo acceduto alle macro o ai flag di ST_MODE. Qui logico e operatore viene utilizzato per stampare le rispettive modalità. Abbiamo verificato le autorizzazioni per l'utente, il gruppo e altri per il file specificato (nome file inserito dall'utente).

Con questo puoi vedere come utilizzare la chiamata del sistema stat dal linguaggio di programmazione C per ottenere informazioni dal kernel del sistema operativo sui file. Se hai una domanda, sentiti libero, raccontaci tramite commenti.