Skip to content

LEIAME.md

Latest commit

 

History

History
227 lines (163 loc) · 7.18 KB

LEIAME.md

File metadata and controls

227 lines (163 loc) · 7.18 KB
Raw

Tarefa de Conclusão do FAT-SYS

Visão Geral

Este repositório contém um pequeno projeto educacional de sistema de arquivos escrito em C. Ele simula um dispositivo de blocos e expõe um shell de linha de comando para interagir com a imagem do sistema de arquivos. A parte que falta é a implementação do sistema de arquivos estilo FAT em fat.c.

Sua tarefa é concluir o sistema de arquivos para que os comandos do shell funcionem como esperado.

Estrutura Atual do Projeto

  • cmd.c: shell interativo e comandos do usuário
  • ds.c / ds.h: abstração de disco simulado sobre um arquivo do hospedeiro
  • fat.c / fat.h: lógica do sistema de arquivos estilo FAT a ser implementada
  • Makefile: alvos básicos de compilação
  • imagem-pronta: imagem de disco de exemplo

Objetivo

Implemente a lógica ausente em fat.c para que o programa consiga:

  • formatar uma imagem de disco nova
  • montar um sistema de arquivos existente
  • imprimir metadados do sistema para depuração
  • criar arquivos no diretório raiz
  • deletar arquivos e recuperar seus blocos
  • informar o tamanho dos arquivos
  • ler o conteúdo dos arquivos
  • escrever o conteúdo dos arquivos
  • dar suporte à importação/exportação pelos comandos já existentes no shell

Contexto Importante

O layout do disco já está sugerido em fat.c:

  • bloco 0: superbloco
  • bloco 1: diretório
  • bloco 2 em diante: blocos da FAT

O código já define as principais estruturas em disco:

  • super: metadados do sistema de arquivos
  • dir_item: entrada do diretório raiz
  • fat: tabela de alocação em memória

Também existe uma flag global mountState que deve ser usada para impedir operações no sistema de arquivos antes de uma montagem bem-sucedida.

O Que Precisa Ser Implementado

Conclua estas funções em fat.c:

  • fat_format()
  • fat_mount()
  • fat_debug()
  • fat_create(char *name)
  • fat_delete(char *name)
  • fat_getsize(char *name)
  • fat_read(char *name, char *buff, int length, int offset)
  • fat_write(char *name, const char *buff, int length, int offset)

Expectativas Funcionais

Sua implementação deve suportar o comportamento abaixo.

1. Formatação

fat_format() deve:

  • inicializar o superbloco com um número mágico válido
  • calcular quantos blocos da FAT são necessários para o tamanho atual do disco
  • marcar blocos reservados como indisponíveis
  • limpar o diretório
  • inicializar as entradas da FAT
  • escrever as estruturas inicializadas no disco

2. Montagem

fat_mount() deve:

  • ler o superbloco do disco
  • validar o número mágico e os metadados básicos do sistema
  • alocar memória para a FAT em memória
  • carregar a FAT e o diretório a partir do disco
  • definir o estado de montado somente após validação bem-sucedida

3. Saída de Depuração

fat_debug() deve imprimir informações úteis, como:

  • valores do superbloco
  • número de blocos da FAT
  • número de entradas de diretório em uso
  • cadeias de blocos alocados para os arquivos

A saída não precisa seguir um formato rígido, mas deve ser útil para verificar a correção.

4. Criação de Arquivo

fat_create() deve:

  • rejeitar nomes inválidos
  • rejeitar nomes duplicados
  • encontrar uma entrada livre no diretório
  • criar uma entrada de arquivo vazia

5. Exclusão de Arquivo

fat_delete() deve:

  • localizar o arquivo no diretório
  • liberar cada bloco de dados em sua cadeia na FAT
  • limpar a entrada do diretório
  • persistir os metadados atualizados no disco

6. Consulta de Tamanho

fat_getsize() deve:

  • retornar o tamanho do arquivo em bytes para um arquivo existente
  • retornar erro para um arquivo inexistente

7. Leitura

fat_read() deve:

  • ler a partir do deslocamento de byte solicitado
  • parar no fim do arquivo
  • lidar corretamente com leituras que atravessem vários blocos
  • retornar o número de bytes realmente lidos
  • retornar erro para requisições inválidas

8. Escrita

fat_write() deve:

  • escrever a partir do deslocamento de byte solicitado
  • alocar novos blocos quando o arquivo crescer
  • preservar dados existentes fora da faixa escrita
  • lidar corretamente com escritas que atravessem vários blocos
  • atualizar o tamanho do arquivo quando necessário
  • persistir FAT, diretório e blocos de dados modificados
  • retornar o número de bytes realmente escritos

Restrições e Observações

  • Mantenha as assinaturas públicas das funções existentes.
  • Preserve o tamanho de bloco atual definido em ds.h.
  • O diretório raiz tem tamanho fixo de acordo com o desenho atual.
  • Os nomes de arquivo são limitados por MAX_LETTERS; aplique isso de forma consistente.
  • Não reprojete o projeto inteiro, a menos que seja absolutamente necessário.
  • Prefira uma implementação clara e correta a uma implementação engenhosa.

Abordagem Recomendada

  1. Implemente algumas funções auxiliares privadas em fat.c.
  2. Faça fat_format() e fat_mount() funcionarem primeiro.
  3. Adicione auxiliares para busca no diretório e busca de entrada livre.
  4. Implemente auxiliares para alocação de blocos e percorrer cadeias de blocos.
  5. Implemente fat_create(), fat_getsize() e fat_delete().
  6. Implemente fat_read() e fat_write() por último.
  7. Use fat_debug() com frequência durante os testes.

Casos de Borda Para Tratar

  • operações antes da montagem
  • nomes de arquivo inválidos ou grandes demais
  • criação duplicada de arquivo
  • exclusão de arquivo vazio
  • leitura além do fim do arquivo
  • escrita em arquivo vazio
  • extensão de arquivo por vários blocos
  • falta de espaço livre
  • falta de entradas livres no diretório

Plano de Teste Manual Sugerido

Depois de implementar o código, verifique o comportamento com sequências como estas:

  1. Inicie o programa com uma imagem nova e formate-a.
  2. Monte o sistema de arquivos e inspecione-o com depurar.
  3. Crie um arquivo e confirme que seu tamanho é 0.
  4. Importe um pequeno arquivo de texto e exporte-o de volta.
  5. Leia o arquivo com ver.
  6. Importe um arquivo maior que um bloco.
  7. Delete arquivos e verifique se os blocos são reutilizados.
  8. Remonte a imagem e confirme que os dados persistem.

Entregáveis

Entregue:

  • o código-fonte concluído
  • quaisquer pequenas funções auxiliares adicionadas a fat.c
  • uma nota curta descrevendo decisões de projeto e limitações conhecidas

Definição de Conclusão

Esta tarefa está concluída quando:

  • todos os comandos do shell apoiados pela camada FAT funcionarem corretamente
  • os dados persistirem após fechar e remontar a imagem
  • a alocação e a recuperação de blocos se comportarem corretamente
  • a implementação for legível e razoavelmente documentada

Melhorias Opcionais

Estes itens são opcionais e só devem ser tentados depois que os requisitos centrais estiverem funcionando:

  • saída de depuração mais clara
  • validação mais forte durante a montagem
  • melhor consistência no tratamento de erros
  • pequenos refactors internos para legibilidade

Lembrete Final

Trate isto como uma tarefa de conclusão, não como uma reescrita. O projeto já fornece o shell, a simulação de disco, as estruturas básicas e a direção pretendida. Seu trabalho é concluir a implementação do sistema de arquivos de forma limpa e correta.