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
- Tempo de Modificação (mtime): Registra quando o conteúdo do arquivo foi modificado pela última vez.
- Tempo de Acesso (atime): Registra quando o arquivo foi lido ou acessado pela última vez.
- 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
lscom várias opções para exibir os timestamps dos arquivos - Usar o comando
statpara 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
touchpara 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.
