Como verificar o tempo de modificação e acesso de um arquivo no Linux

Introdução

No sistema operacional Linux, cada arquivo possui timestamps (carimbos de data/hora) associados que rastreiam quando o arquivo foi modificado, acessado ou teve seus atributos alterados. Compreender esses timestamps é essencial para administradores de sistema, desenvolvedores e usuários regulares que precisam monitorar as atividades dos arquivos.

Este tutorial guia você pelas técnicas práticas para verificar os timestamps de arquivos no Linux. Você aprenderá como visualizar os horários de modificação e acesso usando diferentes comandos, ajudando você a rastrear melhor as alterações e monitorar os padrões de uso de arquivos em seu ambiente Linux.

Compreendendo os Timestamps de Arquivos no Linux

No Linux, cada arquivo possui três timestamps importantes que são mantidos automaticamente pelo sistema:

Tipos de Timestamps de Arquivos

1. Tempo de Modificação (mtime): Registra quando o conteúdo do arquivo foi modificado pela última vez.
2. Tempo de Acesso (atime): Registra quando o arquivo foi lido ou acessado pela última vez.
3. Tempo de Mudança (ctime): Registra quando os metadados do arquivo (permissões, propriedade) foram alterados pela última vez.

Vamos começar a explorar os timestamps de arquivos criando um arquivo de teste e examinando suas propriedades.

Primeiro, abra o terminal e navegue até o diretório do seu projeto:

cd ~/project

Crie um arquivo de texto simples usando o comando touch:

touch testfile.txt

O comando touch cria um arquivo vazio se ele não existir, ou atualiza os timestamps se ele já existir.

Vamos verificar as informações básicas do arquivo usando o comando ls com a opção -l (formato de listagem longa):

ls -l testfile.txt

Você deve ver uma saída semelhante a esta:

-rw-r--r-- 1 labex labex 0 May 15 14:30 testfile.txt

Nesta saída:

• A primeira coluna mostra as permissões do arquivo
• As colunas terceira e quarta mostram o proprietário e o grupo
• A quinta coluna mostra o tamanho do arquivo (0 bytes)
• A data e hora ("May 15 14:30" neste exemplo) mostram o tempo de modificação
• A última coluna é o nome do arquivo

Esta listagem básica mostra o tempo de modificação, mas não o tempo de acesso ou o tempo de mudança. Vamos explorar esses nos passos seguintes.

Usando o Comando stat para Visualizar Todos os Timestamps

Embora o comando ls nos forneça informações básicas sobre o arquivo, o comando stat fornece informações mais detalhadas sobre um arquivo, incluindo todos os três timestamps.

Vamos usar o comando stat para visualizar todos os timestamps do nosso arquivo de teste:

stat testfile.txt

Você deve ver uma saída semelhante a esta:

  File: testfile.txt
  Size: 0           Blocks: 0          IO Block: 4096   regular empty file
Device: 801h/2049d  Inode: 2101099     Links: 1
Access: (0644/-rw-r--r--)  Uid: (1000/labex)   Gid: (1000/labex)
Access: 2023-05-15 14:30:00.000000000 +0000
Modify: 2023-05-15 14:30:00.000000000 +0000
Change: 2023-05-15 14:30:00.000000000 +0000
 Birth: -

Nesta saída:

• Access (Acesso): Mostra quando o arquivo foi acessado pela última vez (atime)
• Modify (Modificar): Mostra quando o conteúdo do arquivo foi modificado pela última vez (mtime)
• Change (Mudança): Mostra quando os metadados do arquivo foram alterados pela última vez (ctime)
• Birth (Criação): Mostra o tempo de criação do arquivo (não suportado em todos os sistemas de arquivos)

Observe que todos os três timestamps são atualmente os mesmos porque acabamos de criar o arquivo. Vamos modificar o arquivo para ver como esses timestamps mudam.

Adicione algum conteúdo ao arquivo usando o comando echo:

echo "This is a test file" > testfile.txt

Agora vamos verificar os timestamps novamente:

stat testfile.txt

Você deve ver que o tempo de modificação (Modify) e o tempo de mudança (Change) foram atualizados, enquanto o tempo de acesso pode permanecer o mesmo, dependendo da configuração do seu sistema.

  File: testfile.txt
  Size: 19          Blocks: 8          IO Block: 4096   regular file
Device: 801h/2049d  Inode: 2101099     Links: 1
Access: (0644/-rw-r--r--)  Uid: (1000/labex)   Gid: (1000/labex)
Access: 2023-05-15 14:30:00.000000000 +0000
Modify: 2023-05-15 14:35:12.000000000 +0000
Change: 2023-05-15 14:35:12.000000000 +0000
 Birth: -

Verificando o Tempo de Modificação (mtime)

O tempo de modificação (mtime) é atualizado sempre que o conteúdo de um arquivo é alterado. Este é o timestamp mais comumente exibido por padrão nas listagens de arquivos.

Usando ls para Verificar o Tempo de Modificação

O comando padrão ls -l mostra o tempo de modificação por padrão:

ls -l testfile.txt

Saída:

-rw-r--r-- 1 labex labex 19 May 15 14:35 testfile.txt

Para arquivos modificados no ano atual, ls -l mostra o mês, o dia e a hora. Para arquivos modificados em anos anteriores, ele mostra o mês, o dia e o ano em vez da hora.

Personalizando o Formato de Tempo

Para ver informações de timestamp mais detalhadas, use a opção --time-style com ls:

ls -l --time-style=full-iso testfile.txt

Saída:

-rw-r--r-- 1 labex labex 19 2023-05-15 14:35:12.000000000 +0000 testfile.txt

Isso mostra o timestamp completo no formato ISO, incluindo ano, mês, dia, horas, minutos, segundos e fuso horário.

Você também pode usar outras opções de formato como long-iso ou iso:

ls -l --time-style=long-iso testfile.txt

Saída:

-rw-r--r-- 1 labex labex 19 2023-05-15 14:35 testfile.txt

Usando date para Exibir o Tempo de Modificação

Outra maneira de verificar o tempo de modificação é com o comando date usando a opção -r:

date -r testfile.txt

Saída:

Mon May 15 14:35:12 UTC 2023

Este comando exibe o tempo de modificação em um formato legível por humanos.

Verificando o Tempo de Acesso (atime)

O tempo de acesso (atime) é atualizado sempre que um arquivo é lido ou acessado. No entanto, muitos sistemas Linux modernos usam opções de montagem como relatime ou noatime para reduzir a frequência das atualizações de atime para melhor desempenho.

Usando ls para Verificar o Tempo de Acesso

Para visualizar o tempo de acesso em vez do tempo de modificação, use a opção -u com ls -l:

ls -lu testfile.txt

Saída:

-rw-r--r-- 1 labex labex 19 May 15 14:40 testfile.txt

O timestamp exibido agora é o tempo de acesso em vez do tempo de modificação.

Vamos acessar o arquivo para atualizar seu tempo de acesso:

cat testfile.txt

Saída:

This is a test file

Agora verifique o tempo de acesso novamente:

ls -lu testfile.txt

Você deve ver que o tempo de acesso foi atualizado para a hora atual.

Comparando Todos os Timestamps

Vamos usar o comando stat para ver todos os timestamps após acessar o arquivo:

stat testfile.txt

Saída:

  File: testfile.txt
  Size: 19          Blocks: 8          IO Block: 4096   regular file
Device: 801h/2049d  Inode: 2101099     Links: 1
Access: (0644/-rw-r--r--)  Uid: (1000/labex)   Gid: (1000/labex)
Access: 2023-05-15 14:41:05.000000000 +0000
Modify: 2023-05-15 14:35:12.000000000 +0000
Change: 2023-05-15 14:35:12.000000000 +0000
 Birth: -

Observe que apenas o tempo de acesso foi alterado, enquanto o tempo de modificação e o tempo de mudança permanecem os mesmos de antes.

Alterando as Permissões do Arquivo para Atualizar o Tempo de Mudança

Vamos atualizar o tempo de mudança (ctime) modificando as permissões do arquivo:

chmod 640 testfile.txt

Verifique todos os timestamps novamente:

stat testfile.txt

Saída:

  File: testfile.txt
  Size: 19          Blocks: 8          IO Block: 4096   regular file
Device: 801h/2049d  Inode: 2101099     Links: 1
Access: (0640/-rw-r-----)  Uid: (1000/labex)   Gid: (1000/labex)
Access: 2023-05-15 14:41:05.000000000 +0000
Modify: 2023-05-15 14:35:12.000000000 +0000
Change: 2023-05-15 14:42:30.000000000 +0000
 Birth: -

Você pode ver que o tempo de mudança (ctime) foi atualizado para a hora atual, enquanto o tempo de acesso e o tempo de modificação permanecem inalterados.

Manipulando Timestamps de Arquivos com touch

O comando touch permite que você não apenas crie arquivos, mas também atualize seus timestamps. Isso é útil para testes ou quando você precisa sincronizar timestamps entre arquivos.

Atualizando Todos os Timestamps

Para atualizar todos os timestamps (acesso, modificação e mudança) para a hora atual:

touch testfile.txt

Verifique os timestamps:

stat testfile.txt

Saída:

  File: testfile.txt
  Size: 19          Blocks: 8          IO Block: 4096   regular file
Device: 801h/2049d  Inode: 2101099     Links: 1
Access: (0640/-rw-r-----)  Uid: (1000/labex)   Gid: (1000/labex)
Access: 2023-05-15 14:45:10.000000000 +0000
Modify: 2023-05-15 14:45:10.000000000 +0000
Change: 2023-05-15 14:45:10.000000000 +0000
 Birth: -

Atualizando Apenas o Tempo de Acesso

Para atualizar apenas o tempo de acesso:

touch -a testfile.txt

Verifique os timestamps:

stat testfile.txt

Saída:

  File: testfile.txt
  Size: 19          Blocks: 8          IO Block: 4096   regular file
Device: 801h/2049d  Inode: 2101099     Links: 1
Access: (0640/-rw-r-----)  Uid: (1000/labex)   Gid: (1000/labex)
Access: 2023-05-15 14:46:15.000000000 +0000
Modify: 2023-05-15 14:45:10.000000000 +0000
Change: 2023-05-15 14:46:15.000000000 +0000
 Birth: -

Observe que o tempo de mudança (ctime) também é atualizado porque os metadados do arquivo foram alterados.

Atualizando Apenas o Tempo de Modificação

Para atualizar apenas o tempo de modificação:

touch -m testfile.txt

Verifique os timestamps:

stat testfile.txt

Saída:

  File: testfile.txt
  Size: 19          Blocks: 8          IO Block: 4096   regular file
Device: 801h/2049d  Inode: 2101099     Links: 1
Access: (0640/-rw-r-----)  Uid: (1000/labex)   Gid: (1000/labex)
Access: 2023-05-15 14:46:15.000000000 +0000
Modify: 2023-05-15 14:47:20.000000000 +0000
Change: 2023-05-15 14:47:20.000000000 +0000
 Birth: -

Novamente, o tempo de mudança também é atualizado.

Definindo Timestamps Específicos

Você pode definir um timestamp específico usando a opção -d com touch:

touch -d "2023-01-01 12:00:00" testfile.txt

Verifique os timestamps:

stat testfile.txt

Saída:

  File: testfile.txt
  Size: 19          Blocks: 8          IO Block: 4096   regular file
Device: 801h/2049d  Inode: 2101099     Links: 1
Access: (0640/-rw-r-----)  Uid: (1000/labex)   Gid: (1000/labex)
Access: 2023-01-01 12:00:00.000000000 +0000
Modify: 2023-01-01 12:00:00.000000000 +0000
Change: 2023-05-15 14:48:30.000000000 +0000
 Birth: -

Isso define os tempos de acesso e modificação para 1º de janeiro de 2023, às 12h00. O tempo de mudança ainda é atualizado para a hora atual.

Criando um Novo Arquivo com Timestamps de um Arquivo Existente

Você também pode usar a opção -r para referenciar os timestamps de outro arquivo:

## Crie um novo arquivo
touch newfile.txt

## Defina seus timestamps com base em testfile.txt
touch -r testfile.txt newfile.txt

Verifique os timestamps do novo arquivo:

stat newfile.txt

Saída:

  File: newfile.txt
  Size: 0           Blocks: 0          IO Block: 4096   regular empty file
Device: 801h/2049d  Inode: 2101100     Links: 1
Access: (0644/-rw-r--r--)  Uid: (1000/labex)   Gid: (1000/labex)
Access: 2023-01-01 12:00:00.000000000 +0000
Modify: 2023-01-01 12:00:00.000000000 +0000
Change: 2023-05-15 14:49:45.000000000 +0000
 Birth: -

Os tempos de acesso e modificação de newfile.txt agora correspondem aos de testfile.txt.

Resumo

Neste laboratório, você aprendeu a:

• Entender os três tipos de timestamps de arquivos no Linux: tempo de modificação (mtime), tempo de acesso (atime) e tempo de mudança (ctime)
• Usar o comando ls com várias opções para exibir os timestamps dos arquivos
• Usar o comando stat para visualizar informações detalhadas sobre os timestamps
• Ler o conteúdo de arquivos para atualizar o tempo de acesso
• Alterar as permissões dos arquivos para atualizar o tempo de mudança
• Usar o comando touch para manipular manualmente os timestamps dos arquivos
• Aplicar timestamps específicos aos arquivos
• Copiar timestamps de um arquivo para outro

Essas habilidades são essenciais para o gerenciamento e monitoramento eficazes de arquivos no Linux. Os timestamps de arquivos ajudam você a rastrear alterações, monitorar padrões de acesso e garantir que os arquivos estejam sendo mantidos adequadamente. Seja você um administrador de sistema rastreando alterações não autorizadas, um desenvolvedor depurando problemas relacionados a arquivos ou um usuário regular organizando seus arquivos, entender os timestamps de arquivos é uma habilidade valiosa no ambiente Linux.