Phenquestions
Este artigo mostrará como o Inotify é usado para rastrear a criação, exclusão ou modificação de arquivos e diretórios do sistema de arquivos Linux.
Para monitorar um arquivo ou diretório específico usando o Inotify, siga estas etapas:
- Crie uma instância do inotify usando o inotify_init ()
- Adicione o caminho completo do diretório ou do arquivo a ser monitorado e os eventos a serem observados usando a função inotify_add_watch (). Na mesma função, especificamos quais eventos (ON CREATE, ON ACCESS, ON MODIFY etc.), as alterações nos arquivos ou no diretório devem ser monitoradas.
- Aguarde a ocorrência de eventos e leia o buffer, que contém um ou mais eventos que ocorreram, usando o leitura() ou select ()
- Processe o evento que ocorreu, volte para a etapa 3 para aguardar mais eventos e repita.
- Remova o descritor do relógio usando o inotify_rm_watch ()
- Feche a instância do inotify.
Agora, veremos as funções que são usadas para Inotify API.
Arquivo de cabeçalho: sys / inotify.h
inotify_init () função:
Sintaxe: int inotify_init (void)
Argumentos: sem argumentos.
Valores de retorno: Em caso de sucesso, a função retorna um novo descritor de arquivo, em caso de falha a função retorna -1.
inotify_add_watch () função:
Sintaxe: int inotify_add_watch (int fd, const char * pathname, uint32_t mask)
Argumentos:
Esta função leva três argumentos.
O 1st argumento (fd) é um descritor de arquivo que se refere à instância inotify (valor de retorno de inotify_init () função) .
O 2WL argumento é o caminho do diretório ou arquivo que está sendo monitorado.
Os 3rd argumento é uma máscara de bits. A máscara de bits representa os eventos que estão sendo observados. Podemos assistir a um ou mais eventos usando bitwise-OR.
Valores de retorno: Em caso de sucesso, a função retorna um descritor de observação, em caso de falha a função retorna -1.
inotify_rm_watch () função:
Sintaxe: int inotify_rm_watch (int fd, int32_t wd)
Argumentos:
Esta função leva dois argumentos.
O 1st argumento (fd) é um descritor de arquivo que se refere à instância inotify (valor de retorno de inotify_init () função) .
O 2WL argumento (wd) é um descritor de observação (valor de retorno de inotify_add_watch () função) .
Valores de retorno: Em caso de sucesso, a função retorna 0, em caso de falha, a função retorna -1.
Nós usamos leitura() função (declarada em unistd.h cabeçalho arquivo) para ler o buffer, onde são armazenadas as informações dos eventos ocorridos na forma do inotify_event estrutura. O inotify_event estrutura é declarada em sys / inotify.h arquivo de cabeçalho:
struct inotify_eventint32t wd;
uint32_t mask;
cookie uint32_t;
uint32_t len;
nome do personagem[];
O inotify_event estrutura representa um evento do sistema de arquivos retornado pelo sistema inotify e contém os seguintes membros:
- wd: Descritor do relógio (valor de retorno de inotify_add_watch () função)
- mascarar: Uma máscara de bits que inclui todos os tipos de eventos
- biscoito: Número único que identifica eventos
- len: Número de bytes no campo de nome
- nome: Nome do arquivo ou diretório em que o evento ocorreu
Abaixo está um exemplo funcional, usando a API Inotify:
Inotificar.arquivo c:
#incluir#incluir
#incluir
#incluir
#incluir
#incluir
#define MAX_EVENTS 1024 / * Número máximo de eventos para processar * /
# define LEN_NAME 16 / * Supondo que o comprimento do nome do arquivo
não excederá 16 bytes * /
#define EVENT_SIZE (sizeof (struct inotify_event)) / * tamanho de um evento * /
#define BUF_LEN (MAX_EVENTS * (EVENT_SIZE + LEN_NAME))
/ * buffer para armazenar os dados dos eventos * /
int fd, wd;
void sig_handler (int sig)
/ * Etapa 5. Remova o descritor do relógio e feche a instância do inotify * /
inotify_rm_watch (fd, wd);
fechar (fd);
saída (0);
int main (int argc, char ** argv)
char * path_to_be_watched;
sinal (SIGINT, sig_handler);
path_to_be_watched = argv [1];
/* Passo 1. Inicializar inotify * /
fd = inotify_init ();
if (fcntl (fd, F_SETFL, O_NONBLOCK) < 0) // error checking for fcntl
saída (2);
/* Passo 2. Adicionar relógio * /
wd = inotify_add_watch (fd, path_to_be_watched, IN_MODIFY | IN_CREATE | IN_DELETE);
if (wd == - 1)
printf ("Não foi possível assistir:% s \ n", path_to_be_watched);
senão
printf ("Assistindo:% s \ n", path_to_be_watched);
enquanto (1)
int i = 0, comprimento;
buffer char [BUF_LEN];
/* Etapa 3. Buffer de leitura * /
comprimento = leitura (fd, buffer, BUF_LEN);
/* Passo 4. Processe os eventos que ocorreram * /
enquanto eu
struct inotify_event * event = (struct inotify_event *) & buffer [i];
if (evento-> len)
if (evento-> máscara & IN_CREATE)
if (evento-> máscara & IN_ISDIR)
printf ("O diretório% s foi criado.\ n ", evento-> nome);
senão
printf ("O arquivo% s foi criado.\ n ", evento-> nome);
else if (evento-> máscara & IN_DELETE)
if (evento-> máscara & IN_ISDIR)
printf ("O diretório% s foi deletado.\ n ", evento-> nome);
senão
printf ("O arquivo% s foi deletado.\ n ", evento-> nome);
else if (evento-> máscara & IN_MODIFY)
if (evento-> máscara & IN_ISDIR)
printf ("O diretório% s foi modificado.\ n ", evento-> nome);
senão
printf ("O arquivo% s foi modificado.\ n ", evento-> nome);
i + = EVENT_SIZE + evento-> len;
Resultado:
Para executar o programa e ver a saída, devemos primeiro abrir dois terminais. Um terminal é usado para executar o programa Inotificar.c. No segundo terminal, vamos para o caminho que está sendo vigiado pelo Inotify.c. Se criarmos qualquer diretório ou arquivo, modificarmos qualquer arquivo ou excluirmos qualquer diretório ou arquivo, veremos isso no primeiro terminal.
No Inotificar.c exemplo, o unistd.h arquivo de cabeçalho é usado para o leitura() e perto() função, o stdlib.h arquivo de cabeçalho é usado para o saída() função, o sinal.h arquivo de cabeçalho é usado para o sinal() função e o SIG_INT macro (veja manipulação de sinal para detalhes), e o fcntl.h arquivo de cabeçalho é usado para o fcntl () função.
Nós declaramos fd (inotificar instância) e wd (descritor de observação) como variáveis globais para que essas variáveis sejam acessíveis a partir de todas as funções.
O fcntl () função é usada para que, quando lemos usando o fd descritor, o tópico não será bloqueado.
Em seguida, adicionamos um relógio usando o inotify_add_watch () função. Aqui, passamos fd, o caminho do diretório que será observado, e a máscara. Você pode passar a máscara dos eventos que deseja monitorar usando bitwise-OR.
Agora, leia o buffer. As informações sobre um ou mais eventos são armazenadas no buffer. Você pode processar todos os eventos um por um usando o loop. Você pode verificar o evento-> máscara para saber quais tipos de eventos aconteceram.
Usamos um loop while infinito para verificar continuamente quando os eventos ocorreram. Se nenhum evento aconteceu, a função read () retorna com um 0. O valor de retorno da função read () é armazenado na variável de comprimento. Quando o valor da variável de comprimento é maior que zero, um ou mais eventos ocorreram.
Nós usamos o SIG_INT sinal (pressione Ctrl + C) para sair do processo. Quando você pressiona Ctrl + C, o sig_handler () função é chamada (consulte o tratamento do sinal para obter detalhes). Esta função remove o descritor do relógio, fecha a instância do inotify fd, e sai do programa.
Conclusão
Você pode usar a API Inotify em seus próprios aplicativos para monitoramento, depuração, automação e muito mais, de sua própria maneira. Aqui, vimos o fluxo de execução da API Inotify.
