Phenquestions
Den här artikeln visar hur Inotify används för att spåra skapande, radering eller modifiering av filer och kataloger i Linux-filsystemet.
Följ dessa steg för att övervaka en viss fil eller katalog med Inotify:
- Skapa en inotify-instans med inotify_init ()
- Lägg till hela sökvägen till katalogen eller filen som ska övervakas och händelserna att titta på med funktionen inotify_add_watch (). I samma funktion anger vi vilka händelser (ON CREATE, ON ACCESS, ON MODIFY etc.), ändringar i filerna eller ändringar i katalogen måste övervakas.
- Vänta tills händelser inträffar och läs bufferten, som innehåller en eller flera händelser som inträffade, med hjälp av läsa() eller Välj()
- Bearbeta händelsen som inträffat, återgå sedan till steg 3 för att vänta på fler händelser och upprepa.
- Ta bort klockbeskrivaren med hjälp av inotify_rm_watch ()
- Stäng inotify-instansen.
Nu ser vi de funktioner som används för Inotify API.
Rubrikfil: sys / inotify.h
inotify_init () funktion:
Syntax: int inotify_init (ogiltigt)
Argument: Inga argument.
Returvärden: Efter framgång returnerar funktionen en ny filbeskrivare, för fel returnerar funktionen -1.
inotify_add_watch () fungera:
Syntax: int inotify_add_watch (int fd, const char * pathname, uint32_t mask)
Argument:
Denna funktion tar tre argument.
Den 1st argument (fd) är en filbeskrivare som hänvisar till inotify-instansen (returvärdet för inotify_init () fungera) .
2nd argument är sökvägen till katalogen eller filen som övervakas.
3rd argument är en bitmask. Bitmasken representerar de händelser som övervakas. Vi kan titta på en eller flera händelser med bitvis-ELLER.
Returvärden: Vid framgång returnerar funktionen en klockbeskrivare, för fel returnerar funktionen -1.
inotify_rm_watch () fungera:
Syntax: int inotify_rm_watch (int fd, int32_t wd)
Argument:
Denna funktion tar två argument.
Den 1st argument (fd) är en filbeskrivare som hänvisar till inotify-instansen (returvärdet för inotify_init () fungera) .
2nd argument (wd) är en klockbeskrivare (returvärdet av inotify_add_watch () fungera) .
Returvärden: Vid framgång returnerar funktionen 0, för fel returnerar funktionen -1.
Vi använder läsa() funktion (deklareras i unistd.h rubrik fil) för att läsa bufferten, som lagras informationen om händelserna inträffade i form av inotify_event strukturera. De inotify_event struktur förklaras i sys / inotify.h rubrikfil:
struct inotify_eventint32t wd;
uint32_t mask;
uint32_t cookie;
uint32_t len;
karaktärsnamn[];
De inotify_event struktur representerar en filsystemhändelse som returneras av inotify-systemet och innehåller följande medlemmar:
- wd: Watch descriptor (returvärde av inotify_add_watch () fungera)
- mask: En bitmask som innehåller alla typer av händelser
- kaka: Unikt nummer som identifierar händelser
- len: Antal byte i namnfältet
- namn: Namnet på filen eller katalogen där händelsen inträffade
Nedan följer ett fungerande exempel som använder Inotify API:
Inotify.c-fil:
#omfatta#omfatta
#omfatta
#omfatta
#omfatta
#omfatta
#define MAX_EVENTS 1024 / * Maximalt antal händelser att bearbeta * /
#define LEN_NAME 16 / * Förutsatt att filnamnets längd
överstiger inte 16 byte * /
#define EVENT_SIZE (sizeof (struct inotify_event)) / * storlek på en händelse * /
#define BUF_LEN (MAX_EVENTS * (EVENT_SIZE + LEN_NAME))
/ * buffert för att lagra data för händelser * /
int fd, wd;
ogiltig sig_handler (int sig)
/ * Steg 5. Ta bort klockbeskrivaren och stäng inotify-instansen * /
inotify_rm_watch (fd, wd);
stäng (fd);
exit (0);
int main (int argc, char ** argv)
char * path_to_be_watch;
signal (SIGINT, sig_handler);
path_to_be_watched = argv [1];
/* Steg 1. Initiera inotify * /
fd = inotify_init ();
om (fcntl (fd, F_SETFL, O_NONBLOCK) < 0) // error checking for fcntl
utgång (2);
/* Steg 2. Lägg till klocka * /
wd = inotify_add_watch (fd, path_to_be_watch, IN_MODIFY | IN_CREATE | IN_DELETE);
om (wd == - 1)
printf ("Kunde inte titta:% s \ n", sökväg_till_vakt);
annan
printf ("Watching:% s \ n", path_to_be_watched);
medan (1)
int i = 0, längd;
char buffert [BUF_LEN];
/* Steg 3. Läs buffert * /
längd = läs (fd, buffert, BUF_LEN);
/ * Steg 4. Bearbeta de händelser som har inträffat * /
medan jag
struct inotify_event * event = (struct inotify_event *) & buffert [i];
if (event-> len)
if (event-> mask & IN_CREATE)
if (event-> mask & IN_ISDIR)
printf ("Katalogen% s skapades.\ n ", event-> namn);
annat
printf ("Filen% s skapades.\ n ", händelse-> namn);
annars om (event-> mask & IN_DELETE)
if (event-> mask & IN_ISDIR)
printf ("Katalogen% s raderades.\ n ", event-> namn);
annat
printf ("Filen% s raderades.\ n ", event-> namn);
annars om (event-> mask & IN_MODIFY)
if (event-> mask & IN_ISDIR)
printf ("Katalogen% s modifierades.\ n ", event-> namn);
annat
printf ("Filen% s modifierades.\ n ", händelse-> namn);
i + = EVENT_SIZE + händelse-> len;
Produktion:
För att köra programmet och se utdata måste vi först öppna två terminaler. En terminal används för att köra programmet Inotify.c. I den andra terminalen går vi till den väg som bevakas av Inotify.c. Om vi skapar någon katalog eller fil, ändrar någon fil eller tar bort någon katalog eller fil kommer vi att se dessa på den första terminalen.
I Inotify.c exempel unistd.h header-fil används för läsa() och stänga() funktion, stdlib.h header-fil används för utgång() funktion, signal.h header-fil används för signal() funktion och SIG_INT makro (se signalhantering för mer information) och fcntl.h header-fil används för fcntl () fungera.
Vi förklarar fd (inotify instans) och wd (watch descriptor) som globala variabler så att dessa variabler är tillgängliga från alla funktioner.
De fcntl () funktionen används så att när vi läser med hjälp av fd beskrivning, kommer tråden inte att blockeras.
Därefter lägger vi till en klocka med hjälp av inotify_add_watch () fungera. Här passerar vi fd, sökvägen till katalogen som kommer att ses och masken. Du kan skicka masken för händelserna du vill övervaka med bitvis-ELLER.
Läs nu bufferten. Information om en eller flera händelser lagras i bufferten. Du kan bearbeta alla händelser en efter en med loop. Du kan kontrollera händelse-> masken för att veta vilken typ av händelser som har hänt.
Vi använder en oändlig while-loop för att kontinuerligt kontrollera när händelser inträffade. Om inga händelser har hänt kommer funktionen read () att returneras med ett 0. Returvärdet för funktionen read () lagras i längdvariabeln. När värdet på längdvariabeln är större än noll har en eller flera händelser inträffat.
Vi använder SIG_INT signal (tryck Ctrl + C) för att avsluta processen. När du trycker på Ctrl + C, visas sig_handler () funktionen kallas (se signalhantering för detaljer). Denna funktion tar bort klockbeskrivaren, stänger inotify-instansen fd, och avslutar programmet.
Slutsats
Du kan använda Inotify API i dina egna applikationer för övervakning, felsökning, automatisering och mer på ditt eget sätt. Här har vi sett körningsflödet för Inotify API.
