Phenquestions
Cet article vous montrera comment Inotify est utilisé pour suivre la création, la suppression ou la modification de fichiers et de répertoires du système de fichiers Linux.
Pour surveiller un fichier ou un répertoire spécifique à l'aide d'Inotify, procédez comme suit :
- Créez une instance inotify à l'aide de la inotify_init()
- Ajoutez le chemin complet du répertoire ou du fichier à surveiller et les événements à surveiller à l'aide de la fonction inotify_add_watch(). Dans la même fonction, nous spécifions quels événements (ON CREATE, ON ACCESS, ON MODIFY etc.), les modifications apportées aux fichiers ou les modifications apportées au répertoire doivent être surveillées.
- Attendez que des événements se produisent et lisez le tampon, qui contient un ou plusieurs événements survenus, à l'aide de la lis() ou alors sélectionner()
- Traitez l'événement qui s'est produit, puis revenez à l'étape 3 pour attendre d'autres événements et répétez.
- Supprimez le descripteur de montre à l'aide de la inotify_rm_watch()
- Fermez l'instance inotify.
Maintenant, nous allons voir les fonctions utilisées pour l'API Inotify.
En tête de fichier: sys/notifier.h
inotify_init() une fonction :
Syntaxe : int inotify_init (void)
Arguments : pas d'arguments.
Valeurs de retour : en cas de succès, la fonction renvoie un nouveau descripteur de fichier, en cas d'échec, la fonction renvoie -1.
inotify_add_watch() une fonction:
Syntaxe: int inotify_add_watch ( int fd, const char * pathname, uint32_t mask )
Arguments:
Cette fonction prend trois arguments.
Le 1st l'argument (fd) est un descripteur de fichier qui fait référence à l'instance inotify (valeur de retour de inotify_init() une fonction) .
Les deuxsd l'argument est le chemin du répertoire ou du fichier qui est surveillé.
Le 3rd l'argument est un masque de bits. Le masque de bits représente les événements qui sont surveillés. Nous pouvons regarder un ou plusieurs événements en utilisant bitwise-OR.
Valeurs de retour : En cas de succès, la fonction renvoie un descripteur de veille, en cas d'échec la fonction renvoie -1.
inotify_rm_watch() une fonction:
Syntaxe: int inotify_rm_watch ( int fd, int32_t wd )
Arguments:
Cette fonction prend deux arguments.
Le 1st l'argument (fd) est un descripteur de fichier qui fait référence à l'instance inotify (valeur de retour de inotify_init() une fonction) .
Les deuxsd argument (wd) est un descripteur de surveillance (valeur de retour de inotify_add_watch() une fonction) .
Valeurs de retour : En cas de succès, la fonction renvoie 0, en cas d'échec la fonction renvoie -1.
Nous utilisons lis() fonction (déclarée dans unistd.h entête fichier) pour lire le tampon, qui est stocké les informations des événements survenus sous la forme du inotify_event structure. le inotify_event la structure est déclarée dans sys/notifier.h En tête de fichier:
struct inotify_eventint32t wd ;
uint32_t masque ;
cookie uint32_t ;
uint32_t len;
nom de caractère[] ;
le inotify_event structure représente un événement de système de fichiers renvoyé par le système inotify et contient les membres suivants :
- wd: Descripteur de la montre (valeur de retour de inotify_add_watch() une fonction)
- masquer: Un masque de bits qui inclut tous les types d'événements
- biscuit: Numéro unique qui identifie les événements
- longueur: Nombre d'octets dans le champ du nom
- Nom: Nom du fichier ou du répertoire dans lequel l'événement s'est produit
Vous trouverez ci-dessous un exemple de travail utilisant l'API Inotify :
Inotifier.fichier c :
#inclure#inclure
#inclure
#inclure
#inclure
#inclure
#define MAX_EVENTS 1024 /* Nombre maximum d'événements à traiter*/
#define LEN_NAME 16 /* En supposant que la longueur du nom de fichier
ne dépassera pas 16 octets*/
#define EVENT_SIZE ( sizeof (struct inotify_event) ) /*taille d'un événement*/
#define BUF_LEN ( MAX_EVENTS * ( EVENT_SIZE + LEN_NAME ))
/*buffer pour stocker les données des événements*/
int fd,wd;
void sig_handler(int sig)
/* Étape 5. Supprimez le descripteur watch et fermez l'instance inotify*/
inotify_rm_watch( fd, wd );
close( fd );
sortie( 0 );
int main(int argc, char **argv)
char *path_to_be_watched;
signal(SIGINT,sig_handler);
path_to_be_watched = argv[1];
/* Étape 1. Initialiser inotify */
fd = inotify_init();
si (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) // error checking for fcntl
sortie(2);
/* Étape 2. Ajouter une montre */
wd = inotify_add_watch(fd,path_to_be_watched,IN_MODIFY | IN_CREATE | IN_DELETE);
if(wd==-1)
printf("Impossible de regarder : %s\n",path_to_be_watched);
autre
printf("Observation : %s\n",chemin_pour_être_observé);
tandis que(1)
entier i=0,longueur;
tampon de caractères[BUF_LEN] ;
/* Étape 3. Lire le tampon*/
longueur = read(fd,buffer,BUF_LEN);
/* Étape 4. Traiter les événements survenus */
alors que je
struct inotify_event *event = (struct inotify_event *) &buffer[i];
if(événement->len)
if ( événement-> masque & IN_CREATE )
if ( événement-> masque & IN_ISDIR )
printf( "Le répertoire %s a été créé.\n", événement->nom );
autre
printf( "Le fichier %s a été créé.\n", événement->nom );
else if ( événement-> masque & IN_DELETE )
if ( événement-> masque & IN_ISDIR )
printf( "Le répertoire %s a été supprimé.\n", événement->nom );
autre
printf( "Le fichier %s a été supprimé.\n", événement->nom );
else if ( événement-> masque & IN_MODIFY )
if ( événement-> masque & IN_ISDIR )
printf( "Le répertoire %s a été modifié.\n", événement->nom );
autre
printf( "Le fichier %s a été modifié.\n", événement->nom );
i += EVENT_SIZE + event->len;
Production:
Pour exécuter le programme et voir la sortie, nous devons d'abord ouvrir deux terminaux. Un terminal est utilisé pour exécuter le programme Inotifier.c. Dans le deuxième terminal, nous allons au chemin surveillé par l'Inotify.c. Si nous créons un répertoire ou un fichier, modifions un fichier ou supprimons un répertoire ou un fichier, nous les verrons sur le premier terminal.
Dans le Inotifier.c exemple, le unistd.h fichier d'en-tête est utilisé pour le lis() et Fermer() fonction, le stdlib.h fichier d'en-tête est utilisé pour le sortir() fonction, le signal.h fichier d'en-tête est utilisé pour le signal() fonction et le SIG_INT macro (voir gestion du signal pour plus de détails), et la fcntl.h fichier d'en-tête est utilisé pour le fcntl() une fonction.
Nous déclarons fd (notifier l'instance) et wd (watch descriptor) en tant que variables globales afin que ces variables soient accessibles depuis toutes les fonctions.
le fcntl() fonction est utilisée de sorte que lorsque nous lisons en utilisant le fd descripteur, le fil ne sera pas bloqué.
Ensuite, nous ajoutons une montre en utilisant le inotify_add_watch() une fonction. Ici, on passe fd, le chemin du répertoire qui sera surveillé, et le masque. Vous pouvez passer le masque des événements que vous souhaitez surveiller en utilisant bitwise-OR.
Maintenant, lisez le tampon. Les informations sur un ou plusieurs événements sont stockées dans le tampon. Vous pouvez traiter tous les événements un par un en utilisant la boucle. Vous pouvez vérifier l'événement-> masque pour savoir quel type d'événements se sont produits.
Nous utilisons une boucle while infinie pour vérifier en permanence quand les événements se sont produits. Si aucun événement ne s'est produit, la fonction read() renvoie un 0. La valeur de retour de la fonction read() est stockée dans la variable de longueur. Lorsque la valeur de la variable de longueur est supérieure à zéro, un ou plusieurs événements se sont produits.
Nous utilisons le SIG_INT signal (appuyez sur Ctrl+C) pour quitter le processus. Lorsque vous appuyez sur Ctrl+C, le sig_handler() la fonction est appelée (voir la gestion du signal pour plus de détails). Cette fonction supprime le descripteur watch, ferme l'instance inotify fd, et quitte le programme.
Conclusion
Vous pouvez utiliser l'API Inotify dans vos propres applications pour la surveillance, le débogage, l'automatisation, etc., à votre manière. Ici, nous avons vu le flux d'exécution de l'API Inotify.
