Sistema de Arquivos

[oney]

Poo favor me ajudem com esse sistema de arquivo ele ta dando um erro e nao consigo consertar....

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<time.h>



typedef struct disco{
int arq;//identificador do arquivo
int tam;//tam do disco indicado pelo usuario
int também;//tamanho dos blocos indicado pelo usuario
int numB;//numero de blocos no disco
int *fat;//tabela fat
int tamFat;//qdt de blocos q o fat vai ocupar
int iniRaiz;//bloco onde inicia a raiz
}disco;

typedef struct arquivos{
char *nome;
int tipo;
char *criado;
char *modificado;
int tam;
int blocoInicial;
int cont;
struct listaSubArq *subArq;
}arquivo;

typedef struct comando{
char *string;
char **matriz;
}comando;

typedef struct listaSubArq{
arquivo *arq;
struct listaSubArq *prox;
}lsa;

/*variavel globais*/
disco discoVirtual;//disco virtual rsrsrs
disco discoVirtual2;//disco virtual rsrsrs
arquivo *dirRaiz;
arquivo *dirAtual;
arquivo *dirAux;
arquivo arqAux;
char *dataAtual;

/**prototipos**************************************************/
char *alocaString();
char **alocaMatriz(int tam);
void iniciaCom(comando *com,int tamS ,int tamM);
void preencheDisco();
void imprimeAtributosDisco();
void geraFat();
int procuraBlocoLivre();
int abreDiscoVirtual();
void preencheAtributosDisco(comando com);
void formataDisco(comando com);
char **quebrarString(char *str,char *chr);
void gravaAtributosDisco();
void gravaFat();
arquivo *geraArq(char *nome,int tipo);
void iniciaVetorSubArq(arquivo **arq);
char *dataEHoraAtual();
void imprimeAtributosArq(arquivo *arq);
void lerAtributosDisco();
void lerFat();
void mudaTabelaFat(int bloco,int valor);
int cabeMais(int pos, int tipo);
void mudaBloco(int bloco);
void gravarAtributosArquivo(arquivo *arqTemp,int pos,int bloco);
int encontrarProximaPosFat(int bloco);
arquivo *lerAtributosArquivo(int pos,int bloco);
void lerAtributosDisco();
void lerRaiz();
//lsa *mkdir(lsa **ls,comando com);
void criaRaiz();
void gravarNovoNoDisco(int pos,arquivo **arqTemp);
arquivo *lerDiretorio(int bloco);
void ls(lsa *ls);
void imprime(arquivo *arq);
int tamAtributos();
/**************************************************************/

int main(){
comando com;
dirAtual = NULL;
dirAux = NULL;
int x = abreDiscoVirtual();
com.string = alocaString(400);
com.matriz = alocaMatriz(10);
while(1){
if(x==0) printf("Disco não foi formatado!\n\n");
printf("MeuSistemaDeArquivos->");

fgets(com.string,200*sizeof(char),stdin);

com.matriz = quebrarString(com.string," \n");

if(strcmp(com.matriz[0],"format")==0){
printf("format!!\n");
formataDisco(com);
x = 1;
}
else if(strcmp(com.matriz[0],"sair")==0) break;

else if(strcmp(com.matriz[0],"mkdir")==0){
printf("mkdir!!\n");
// mkdir(&dirRaiz->subArq,com);
dirRaiz->tam = dirRaiz->tam + tamAtributos();
}
else if(strcmp(com.matriz[0],"ls")==0){
printf("LS!!\n");
ls(dirRaiz->subArq);
}
}

close(discoVirtual.arq);
return 0;
}

//função simples pra alocar strings
char *alocaString(int tam){
char *vet = malloc(tam*sizeof(char));//alocando um vetor de strings de tamanho "tam"
return vet;
}

//função simples de alocação de matrizes
char **alocaMatriz(int tam){
char **mat = malloc(tam*sizeof(char*));
int i;
for(i = 0;i<tam;i++){
mat[i] = malloc(50*sizeof(char));
}
return mat;
}

//função pra alocar comandos
void iniciaCom(comando *com,int tamS ,int tamM){
com->string = alocaString(tamS);
com->matriz = alocaMatriz(tamM);
}

/*quebra uma string e retorna uma matriz com as palavras separadas*/
char **quebrarString(char *str,char *chr){
char **mat=malloc(10*sizeof(char**));
int i = 0;
printf("entrando no quebrar string\n");
/*quebrando a string a cada " "(espaço) encontrado*/
mat[i] = strtok(str,chr);
printf("matriz quebrar string na pos[%i]=%s\n",i,mat[i]);
do{ //uso o dowhile prq quero q ele faça isso pelo menos uma vez
i++;
mat[i] = strtok(NULL,chr);
printf("matriz quebrar string na pos[%i]=%s\n",i,mat[i]);
}while(mat[i]!=NULL); //quebra até encontrar um ponteiro nulo
/**************************************************/
printf("saindo da quebrar string\n");
return mat;
}
/*******************************************************************/

//preenxe o disco com o tam q o usuario entro
void preencheDisco(){
int i,n,c=0;
for(i=1;i<=(discoVirtual.tam*1024);i++){
lseek(discoVirtual.arq,0,2);
n = write(discoVirtual.arq,&c,1024);
}
}

//imprime atributos do disco
void imprimeAtributosDisco(){
printf("\natributos do disco");
printf("\n****************************************************************\n");
printf("tam %i \n",discoVirtual.tam);
printf("também %i \n",discoVirtual.também);
printf("numB %i \n",discoVirtual.numB);
printf("tamFat %i\n",discoVirtual.tamFat);
printf("iniRaiz %i \n",discoVirtual.iniRaiz);
printf("\n****************************************************************\n\n");
}

//função q gera a tabela fat
void geraFat(){
int i;
discoVirtual.fat =(int *)malloc((discoVirtual.numB+2)*sizeof(int));
for(i=0;i<discoVirtual.numB;i++){
if(i==0) discoVirtual.fat[0] = -1;//a posição 0 vai ser uculpada pelos dados sobre o disco
else if(i<discoVirtual.tamFat) discoVirtual.fat[i] = i+1;//estas são os blocos oculpados pelo proprio fat
else if(i==discoVirtual.tamFat) discoVirtual.fat[i] = -1;//este é o ultimo bloco oculpado pelo fat
else discoVirtual.fat[i] = -2;//blocos livres
}
for(i=0;i<(2+discoVirtual.tamFat);i++)
printf("%i,",discoVirtual.fat[i]);
}

//função q procura um -2 na tab fat
int procuraBlocoLivre(){
int i = 0;
while(i<discoVirtual.numB){
//printf("%i,",discoVirtual.fat[i]);
if(discoVirtual.fat[i]==-2)
return i;
i++;
}
printf("Disco cheio!!!");
return -1;
}

//preen che os atributos do disco conforme as entradas do user
void preencheAtributosDisco(comando com){
discoVirtual.tam = atoi(com.matriz[1]);
discoVirtual.também = atoi(com.matriz[2]);
discoVirtual.numB = ((discoVirtual.tam*1024)/(discoVirtual.também));
discoVirtual.tamFat = ((discoVirtual.numB)/(discoVirtual.também*256));
discoVirtual.iniRaiz = discoVirtual.tamFat + 1;
imprimeAtributosDisco();
geraFat();
}

//função q tenta abrir o arq disco virtual
int abreDiscoVirtual(){
discoVirtual.arq = open("discovirtual",O_RDWR);
if(discoVirtual.arq < 0){//arquivo provavelmente num existe
return 0;
}else {
lerAtributosDisco();
lerRaiz();
dirAtual = dirRaiz;
dirAux = dirRaiz;
return 1;
}
}

void formataDisco(comando com){
discoVirtual.arq = open("discovirtual",O_RDWR|O_CREAT|O_TRUNC,0766);//cria um arquivo e da permissões de leitura e escrita pra todo mundo
if(discoVirtual.arq < 0){//arquivo provavelmente num existe
printf("tem alguma coisa errada ai!! \n");
exit(0);
}
while(1){
if(com.matriz[2]==NULL) com.matriz[2] = "4";
if(((atoi(com.matriz[1])*1024)%atoi(com.matriz[2])) == 0)
break;
else if((atoi(com.matriz[2])!=1)|(atoi(com.matriz[2])!=2)|(atoi(com.matriz[2])!=4))
printf("\ntam de bloco invalido, tente de novo\n");
else if(((atoi(com.matriz[1])*1024)%atoi(com.matriz[2])) != 0)
printf("\ntam disco invalido tente de novo\n");
}
printf("\n\n");

printf("Formatando...\n");

printf("preencheAtributosDisco...\n");
preencheAtributosDisco(com);

imprimeAtributosDisco();

printf("preencheDisco...\n");
preencheDisco();

printf("gravando atributos\n");
gravaAtributosDisco();

printf("gerando raiz...\n");
criaRaiz();
}

void gravaAtributosDisco(){
int n,aux;
lseek(discoVirtual.arq,0L,SEEK_SET);
aux = discoVirtual.tam;
n = write(discoVirtual.arq,&aux,sizeof(int));

lseek(discoVirtual.arq,0L,SEEK_CUR );
aux = discoVirtual.também;
n = write(discoVirtual.arq,&aux,sizeof(int));

lseek(discoVirtual.arq,0L,SEEK_CUR);
aux = discoVirtual.numB;
n = write(discoVirtual.arq,&aux,sizeof(int));

lseek(discoVirtual.arq,0,SEEK_CUR);
aux = discoVirtual.tamFat;
n = write(discoVirtual.arq,&aux,sizeof(int));

lseek(discoVirtual.arq,0,SEEK_CUR);
aux = discoVirtual.iniRaiz;
n = write(discoVirtual.arq,&aux,sizeof(int));

gravaFat();

}

void gravaFat(){
int i,j,n,aux;
for(i=1;i<=discoVirtual.tamFat;i++){
/*apontando pro primeiro byte do bloco*/
int blocoCorrente = (i*discoVirtual.também*1024);
lseek(discoVirtual.arq,blocoCorrente,SEEK_SET);
for(j=0;j<(discoVirtual.também*256);j++){ //(discoVirtual.também*256) é a qtd de indices do fat q cabe em um bloco
lseek(discoVirtual.arq,0,SEEK_CUR);
aux = discoVirtual.fat[j];
n = write(discoVirtual.arq,&aux,sizeof(aux));
}
}
}

arquivo *geraArq(char *nome,int tipo){
arquivo *novoArquivo = malloc(sizeof(arquivo));
(*novoArquivo).nome = nome;
(*novoArquivo).tipo = tipo;
(*novoArquivo).criado = dataEHoraAtual();
(*novoArquivo).modificado = dataEHoraAtual();
(*novoArquivo).tam = tamAtributos();
(*novoArquivo).blocoInicial = procuraBlocoLivre();
(*novoArquivo).cont = 0;
(*novoArquivo).subArq = malloc(30*sizeof(lsa));
imprimeAtributosArq(novoArquivo);
return novoArquivo;
}

int tamAtributos(){
return (3*sizeof(int) + 3*(100*sizeof(char)));
}

void imprimeAtributosArq(arquivo *arq){
printf("nome %s\n",(*arq).nome);
printf("tipo %i\n",(*arq).tipo);
printf("criado %s\n",(*arq).criado);
printf("modificado %s\n",(*arq).modificado);
printf("tam %i\n",(*arq).tam);
printf("blocoInicial %i\n",(*arq).blocoInicial);
printf("cont %i\n",(*arq).cont);
}

char *dataEHoraAtual(){
time_t timer;
timer = time(&timer);
return ctime(&timer);
}

void mudaTabelaFat(int bloco,int valor){
discoVirtual.fat[bloco] = valor;
gravaFat();
}

int cabeMais(int pos, int tipo){
int posDentroBloco, tam;
if(tipo == 1) tam = sizeof(int); //se for do tipo inteiro
else tam = 200*sizeof(char); //se for do tipo string

posDentroBloco = (pos % discoVirtual.também*1024);
if(((discoVirtual.também*1024)-pos) < tam) return 0; //se não cabe esse atributo
else return 1; //se cabe esse Atributo
}

void mudaBloco(int bloco){
int proxBloco = (procuraBlocoLivre()*discoVirtual.também*1024);
mudaTabelaFat(bloco,procuraBlocoLivre());
mudaTabelaFat(procuraBlocoLivre(),-1);
lseek(discoVirtual.arq,proxBloco,SEEK_SET);
}

void gravarAtributosArquivo(arquivo *arqTemp,int pos,int bloco){

int n,m,aux;

lseek(discoVirtual.arq,bloco*discoVirtual.também*1024,SEEK_SET);
n = lseek(discoVirtual.arq,pos,SEEK_CUR);

printf("grava 1,");
m = cabeMais(n, 2);
if(m == 0) mudaBloco(n/(discoVirtual.também*1024));
n = write(discoVirtual.arq,(*arqTemp).nome,200*sizeof(char));

lseek(discoVirtual.arq,0,SEEK_CUR);
aux = (*arqTemp).tipo;
m = cabeMais(n, 2);
if(m == 0) mudaBloco(n/(discoVirtual.também*1024));
n = write(discoVirtual.arq,&aux,sizeof(int));

lseek(discoVirtual.arq,0,SEEK_CUR);
m = cabeMais(n, 2);
if(m == 0) mudaBloco(n/(discoVirtual.também*1024));
n = write(discoVirtual.arq,(*arqTemp).criado,200*sizeof(char));

lseek(discoVirtual.arq,0,SEEK_CUR);
m = cabeMais(n, 2);
if(m == 0) mudaBloco(n/(discoVirtual.também*1024));
n = write(discoVirtual.arq,(*arqTemp).modificado,200*sizeof(char));

lseek(discoVirtual.arq,0,SEEK_CUR);
aux = (*arqTemp).tam;
m = cabeMais(n, 2);
if(m == 0) mudaBloco(n/(discoVirtual.também*1024));
n = write(discoVirtual.arq,&aux,sizeof(int));

lseek(discoVirtual.arq,0,SEEK_CUR);
aux = (*arqTemp).blocoInicial;
m = cabeMais(n, 2);
if(m == 0) mudaBloco(n/(discoVirtual.também*1024));
n = write(discoVirtual.arq,&aux,sizeof(int));

lseek(discoVirtual.arq,0,SEEK_CUR);
aux = (*arqTemp).cont;
m = cabeMais(n, 2);
if(m == 0) mudaBloco(n/(discoVirtual.também*1024));
n = write(discoVirtual.arq,&aux,sizeof(int));

printf("8,grava\n");
}

int encontrarProximaPosFat(int bloco){
return discoVirtual.fat[bloco];
}

arquivo *lerAtributosArquivo(int pos,int bloco){
int n,m,aux;
char *aux2=malloc(200*sizeof(char));
arquivo *novoArq = malloc(sizeof(arquivo));

lseek(discoVirtual.arq,bloco*discoVirtual.também*1024,SEEK_SET);
n = lseek(discoVirtual.arq,pos,SEEK_CUR);

m = cabeMais(n, 2);
if(m == 0) encontrarProximaPosFat(bloco);
n = read(discoVirtual.arq,aux2,200*sizeof(char));
novoArq->nome = aux2;
aux2 = NULL;

n = lseek(discoVirtual.arq,0,SEEK_CUR);
m = cabeMais(n, 2);
if(m == 0) encontrarProximaPosFat(bloco);
n = read(discoVirtual.arq,&aux,sizeof(int));
novoArq->tipo = aux;

aux2=malloc(200*sizeof(char));
n = lseek(discoVirtual.arq,0,SEEK_CUR);
m = cabeMais(n, 2);
if(m == 0) encontrarProximaPosFat(bloco);
n = read(discoVirtual.arq,aux2,200*sizeof(char));
novoArq->criado = aux2;
aux2 = NULL;

aux2=malloc(200*sizeof(char));
n = lseek(discoVirtual.arq,0,SEEK_CUR);
m = cabeMais(n, 2);
if(m == 0) encontrarProximaPosFat(bloco);
n = read(discoVirtual.arq,aux2,200*sizeof(char));
novoArq->modificado = aux2;
aux2 = NULL;

n = lseek(discoVirtual.arq,0,SEEK_CUR);
m = cabeMais(n, 2);
if(m == 0) encontrarProximaPosFat(bloco);
n = read(discoVirtual.arq,&aux,sizeof(int));
novoArq->tam = aux;

n = lseek(discoVirtual.arq,0,SEEK_CUR);
m = cabeMais(n, 2);
if(m == 0) encontrarProximaPosFat(bloco);
n = read(discoVirtual.arq,&aux,sizeof(int));
novoArq->blocoInicial = aux;

n = lseek(discoVirtual.arq,0,SEEK_CUR);
m = cabeMais(n, 2);
if(m == 0) encontrarProximaPosFat(bloco);
n = read(discoVirtual.arq,&aux,sizeof(int));
novoArq->cont = aux;

imprimeAtributosArq(novoArq);

return novoArq;
}

void lerAtributosDisco(){
int n,aux;
lseek(discoVirtual.arq,0,SEEK_SET);
n = read(discoVirtual.arq,&aux,sizeof(int));
discoVirtual.tam = aux;

lseek(discoVirtual.arq,0,SEEK_CUR );
n = read(discoVirtual.arq,&aux,sizeof(int));
discoVirtual.também = aux;

lseek(discoVirtual.arq,0,SEEK_CUR);
n = read(discoVirtual.arq,&aux,sizeof(int));
discoVirtual.numB = aux;

lseek(discoVirtual.arq,0,SEEK_CUR);
n = read(discoVirtual.arq,&aux,sizeof(int));
discoVirtual.tamFat = aux;

lseek(discoVirtual.arq,0,SEEK_CUR);
n = read(discoVirtual.arq,&aux,sizeof(int));
discoVirtual.iniRaiz = aux;

imprimeAtributosDisco();

lerFat();
}

void lerFat(){
int i, j, n, blocoCorrente, aux;

discoVirtual.fat = malloc(discoVirtual.numB*sizeof(int));

for(i=1;i<=discoVirtual.tamFat;i++){
/*apontando pro primeiro byte do bloco*/
blocoCorrente = (i*discoVirtual.também*1024);
lseek(discoVirtual.arq,blocoCorrente,SEEK_SET);
for(j=0;j<(discoVirtual.também*256);j++){
n = read(discoVirtual.arq,&aux,sizeof(int));
discoVirtual.fat[j] = aux;
lseek(discoVirtual.arq,0,SEEK_CUR);
}
}

printf("\n**********************************************************************\n");
for(i=0;i<(discoVirtual.tamFat + 10);i++)
printf("[%i|%i],",i,discoVirtual.fat[i]);
printf("\n**********************************************************************\n");
}

void lerRaiz(){
dirRaiz = lerDiretorio(discoVirtual.iniRaiz);
dirAtual = dirRaiz;
}

/*lsa *mkdir(lsa **ls,comando com){
if(*ls){
(*ls)->prox = mkdir(&(*ls)->prox,com);
}else{
(*ls) = malloc(sizeof(lsa));
(*ls)->prox = NULL;
(*ls)->arq = geraArq(com.matriz[1],1);
gravarAtributosArquivo((*ls)->arq,0,(*ls)->arq->blocoInicial);
mudaTabelaFat((*ls)->arq->blocoInicial,-1);
}
return (*ls);
}

/*lsa *adicionarNaLista(lsa **ls,arquivo *arq){
if(*ls){
(*ls)->prox = adicionarNaLista(&(*ls)->prox,arq);
}else{
(*ls) = (lsa*)malloc(sizeof(lsa));
(*ls)->prox = NULL;
(*ls)->arq = arq;
}
return (*ls);
}
*/
void criaRaiz(){
dirRaiz = geraArq("/",1);
gravarAtributosArquivo(dirRaiz,0,discoVirtual.iniRaiz);
dirAux = dirRaiz;
dirAtual = dirRaiz;
}

void gravarNovoNoDisco(int pos,arquivo **arqTemp){
int bloco = pos/(discoVirtual.também*1024);
int posDentroBloco = pos%(discoVirtual.também*1024);

gravarAtributosArquivo(*arqTemp,posDentroBloco,bloco);
}

arquivo *lerDiretorio(int bloco){
arquivo *arqTemp = malloc(sizeof(arquivo));
arqTemp = lerAtributosArquivo(0,bloco);
dirAux = arqTemp;
int i = 0;
int pos, posDentroBloco;
while(i < arqTemp->cont){
pos = lseek(discoVirtual.arq,0,SEEK_CUR);
bloco = pos/(discoVirtual.também*1024);
posDentroBloco = pos%(discoVirtual.também*1024);
// arqTemp->subArq = adicionarNaLista(&arqTemp->subArq,lerAtributosArquivo(posDentroBloco,bloco));
arqTemp->cont++;
}
//imprimeListaSubArquivos(arqTemp->subArq);
return arqTemp;
}

void ls(lsa *lsArq){
if(lsArq){
printf("%s ",lsArq->arq->nome);
ls(lsArq->prox);
}
}

[Plateu]

Caro, oney, quando for postar códigos use a tag spoiler, por favor.

Att,

Plateu!

[oney]

Desculpe a minha duvida ta no mkdir ele num ta executando