Discussion :

[0_Azerty_0]

Bonjour,

j'utilise inotify pour écouter un fichier. Seulement lorsque l'évènement s'est produit, si je veux continuer l'écoute, je dois recréer un watcher. Y a t-il une solution alternative permettant de poursuivre l'écoute sur en fichier (modification par exemple) sans devoir recréer le watcher à chaque fois ?

Merci d'avance

[phi1981]

Je n'ai jamais utilisé inotify, mais tel que je comprends la documentation, ou cet article :
http://www.linuxjournal.com/article/8478?page=0,2
le fonctionnement par défaut continue l'écoute, sauf si tu as spécifié l'option IN_ONESHOT lors du add_watch().

[0_Azerty_0]

Bonjour et merci à toi,

Effectivement, je ne comprends pas trop. Cet article très bien fait explique clairement qu'il faut mettre l'option IN_ONESHOT, seulement, je ne la mets pas et pourtant, en sortant le inotify_add_watch(...) de la boucle while et en le mettant juste avant, le code ne passe qu'une fois dans la fonction read et donc, le signal n'est envoyé qu'à la première modification de fichier... =/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <sys/inotify.h>
#include <stdlib.h>
#include <stdio.h>
 
 
// File descriptor & watch descriptor
int fd, wd;
 
int main() {
 
	// event structure
	struct inotify_event *event;
 
 
	// creates a notify instance
	fd  = inotify_init();
	if(fd < 0) {
        perror("inotify_init");
        return EXIT_FAILURE;
	}
 
	while(1) {
 
		// Starts waiting for file modification
		wd = inotify_add_watch( fd ,"./testin.txt", IN_MODIFY);
		if(wd < 0) {
			perror("inotify add watch ");
			return EXIT_FAILURE;
		}
 
		size_t r;
		char buffer[8192];
 
        // Get informaation when an event occurs
        r = read(fd, buffer, sizeof(buffer));
        if (r <= 0) {
            perror("read");
            return EXIT_FAILURE;
        }
 
		event = (struct inotify_event *) buffer;
        printf("Fichier surveillé n°%d\t", event->wd);
 
	}
 
	return 0;
}

[phi1981]

Méfies-toi : l'appel à read peut retourner plusieurs notifications. Dans ton cas, vu que tu passes un buffer de 8Ko et n'utilises pas la valeur de retour de read() pour savoir ce que tu as lu, rien ne prouve que tu as pas raté un tas de trucs.

D'après http://linux.die.net/man/7/inotify
la taille d'un évènement c'est sizeof(struct inotify_event)+len (len étant un des champs de la structure inotify_event.
Ton code doit donc parcourir le buffer de réception (que tu as nommé buffer) afin d'extraire tous les évènements.

[0_Azerty_0]

Bonjour et merci,

Tu as raison effectivement, mais je ne vois pas trop comment je vais faire pour "extraire" les évènements.
Tu parcours ton buffer en castant tous les x char (x correspondant à la taille dont tu parles donc) l'adresse en *inotify_event ?

J'ai essayé de redimenssionner le buffer comme il fallait mais cela me donne étrangement une erreur de segmentation :/

[phi1981]

Bonjour et merci,

Tu as raison effectivement, mais je ne vois pas trop comment je vais faire pour "extraire" les évènements.
Tu parcours ton buffer en castant tous les x char (x correspondant à la taille dont tu parles donc) l'adresse en *inotify_event ?

Oui c'est ca l'idee. Tu castes une copie du pointeur "buffer" en un pointeur vers un inotify_event. Puis tu regardes le champ len, et tu sais de combien tu dois avancer ton pointeur pour avoir le "inotify_event" suivant.
Enfin en tout cas c'est comme ca que je comprends la documentation.
En gros, qqchose comme ca (que je n'ai pas teste !!!) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
char *ptr = buffer;
size_t r = read (fd, buffer, sizeof(buffer));
if (r < 0)
  return -1;
 
do
{
   inotify_event* event=(inotify_event*) ptr;
   printf ("event name = %s\n", event->name);
   ptr += sizeof(inotify_event) + event->len;
} while (ptr < &buffer[r])

J'ai essayé de redimenssionner le buffer comme il fallait mais cela me donne étrangement une erreur de segmentation :/

Tu t'y es pris comment ?

p.-s. Je suis vraiment desole de ne pas mettre un seul accent a ce message, mais mon clavier ne me le permet pas.

[0_Azerty_0]

Et bien en donnant la taille d'un inotify_event au buffer, avec sizeof si mes souvenirs sont bons. Excuse moi du temps que j'ai mis à répondre, en fait, je me suis un peu orienté vers une autre méthode, je t'explique :

J'essaye de lire et écrire dans un port série. Je souhaitais ne pas faire de l'attente active, jusqu'à ce qu'on me dise que lire directement le tty avec inotify n'était pas forcément une meilleure idée. J'ai donc plus ou moins délaissé le inotify, mais ne t'inquiète pas, tes efforts ne sont pas vains, je suis content d'avoir découvert cela, et ca va bientôt me resservir !

A tout hasard, comment t'y prendrais tu pour lire et écrire dans un port série efficacement ?

Az