int sfs_open(char *name){
int i;
int blocksFree;
int FATfree;
int freeFdt;
int DirFree;
int DIRIndex;
int exists = 0;
for(i=0; i< MAX_myfileS;i++){
if(strcmp(directory[i].name, name)==0){
myfile = directory[i];
DIRIndex = i;
exists = 1;
}
}
if(exists != 1){ //create and open new myfile
blocksFree = searchBlockSpace();
FATfree = searchFAT();
DirFree = findDirectory();
freeFdt = findFDT();
strcpy(directory[DirFree].name, name);
directory[DirFree].size = 0;
directory[DirFree].date = time(NULL);
directory[DirFree].indFAT = FATfree;
FAT[FATfree][0] = blocksFree;
FAT[FATfree][1] = EOF;
FDT[freeFdt].read= 0;
FDT[freeFdt].write= 0;
FDT[freeFdt].dirIndex= DirFree;
free_list[blocksFree] = '1';
updateDisk();
printf("%s <--Creation successfull\n", name);
}
else{ // open existing myfile
freeFdt = findFDT();
FDT[freeFdt].read= 0;
FDT[freeFdt].write= myfile.size;
FDT[freeFdt].dirIndex= DIRIndex;
printf("%s <--Successfully Opened\n", name);
}
return freeFdt;
}
static int cfs_mknod(const char *path, mode_t mode, dev_t rdev)
{
if (checkPath(path))
return -EACCES;
struct fileInfo fi;
int fd = open(cfsFile, O_RDWR);
COLA = (struct fileInfo*)mmap(0, colaSize, PROT_READ, MAP_SHARED, fd, 0);
if (find(path + 1,COLA) != EMPTY)
{
munmap(COLA,colaSize);
close(fd);
return -EEXIST;
}
munmap(COLA,colaSize);
//
strcpy((char*)&fi.name,path + 1);
fi.size = 0;
FAT = (int*)mmap(0, FATSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, OFFC);
fi.blockNum = searchFAT(FAT);
if (fi.blockNum == EMPTY)
{
munmap(FAT,FATSize);
close (fd);
return -ENOMEM;
}
FAT[fi.blockNum] = END;
munmap(FAT,FATSize);
//
COLA = (struct fileInfo*)mmap(0, colaSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (insert(fi,COLA) == 0)
{
munmap(COLA,colaSize);
close(fd);
return -ENOSPC;
}
munmap(COLA,colaSize);
close(fd);
return 0;
}
static int cfs_write(const char *path, const char *buf, size_t size, off_t offset,
struct fuse_file_info *fi)
{
if (checkPath(path))
return -EACCES;
int index = 0, blockNum = 0, tempOff = 0, left = 0, written = 0;
int fd = open(cfsFile, O_RDWR);
COLA = (struct fileInfo*)mmap(0, colaSize, PROT_READ, MAP_SHARED, fd, 0);
index = find(path+1,COLA);
if (index == EMPTY)
{
munmap(COLA,colaSize);
close(fd);
return -ENOENT;
}
blockNum = COLA[index].blockNum;
munmap(COLA,colaSize);
tempOff = offset;
if (tempOff > block)
{
FAT = (int*)mmap(0, FATSize, PROT_READ, MAP_SHARED, fd, OFFC);
while (tempOff > block)
{
blockNum = FAT[blockNum];
tempOff = tempOff - block;
}
munmap(FAT,FATSize);
}
if (tempOff + size > block)
{
data = (char*)mmap(0,block,PROT_READ | PROT_WRITE,MAP_SHARED,fd,OFFF + blockNum*block);
memcpy(data + tempOff, buf, block - tempOff);
munmap(data,block);
written = block - tempOff;
left = size - (block - tempOff);
FAT = (int*)mmap(0, FATSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, OFFC);
//if (FAT[blockNum] == EMPTY)
FAT[blockNum] = searchFAT(FAT);
if (FAT[blockNum] == EMPTY)
{
FAT[blockNum] = END;
munmap(FAT,FATSize);
return -ENOMEM;
}
blockNum = FAT[blockNum];
munmap(FAT,FATSize);
while (left > 0)
{
if (left > block)
{
data = (char*)mmap(0,block,PROT_READ | PROT_WRITE,MAP_SHARED,fd,OFFF + blockNum*block);
memcpy(data, buf + written, block);
munmap(data,block);
FAT = (int*)mmap(0, FATSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, OFFC);
//if (FAT[blockNum] == EMPTY)
FAT[blockNum] = searchFAT(FAT);
if (FAT[blockNum] == EMPTY)
{
FAT[blockNum] = END;
munmap(FAT,FATSize);
return -ENOMEM;
}
blockNum = FAT[blockNum];
munmap(FAT,FATSize);
left = left - block;
written += block;
}
else
{
data = (char*)mmap(0,block,PROT_READ | PROT_WRITE,MAP_SHARED,fd,OFFF + blockNum*block);
memcpy(data, buf + written, left);
munmap(data,block);
FAT = (int*)mmap(0, FATSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, OFFC);
int cur = FAT[blockNum];
int temp = 0;
while (FAT[cur] != EMPTY && FAT[cur] != END)
{
temp = FAT[cur];
FAT[cur] = EMPTY;
cur = temp;
}
FAT[cur] = EMPTY;
FAT[blockNum] = END;
munmap(FAT,FATSize);
written += left;
left = 0;
}
}
}
else
{
data = (char*)mmap(0,block,PROT_READ | PROT_WRITE,MAP_SHARED,fd,OFFF + blockNum*block);
memcpy(data + tempOff, buf, size);
munmap(data,block);
written += size;
}
COLA = (struct fileInfo*)mmap(0, colaSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
COLA[index].size = written + offset;
munmap(COLA,colaSize);
close(fd);
return size;
}
void sfs_write(int fd, char *buf, int length){
int i;
int position = 0;
int maxLength;
int apendLength;
int FATi;
int currFATi;
int newBlock;
writeLength = length;
currmyfile = fd;
writeBuff = (char *) malloc(length);
appendBuff = (char *) malloc(1024 + length);
for(i=0; i < writeLength; i++){
writeBuff[i] = buf[i];
}
writeBuff[writeLength] = 0;
myfile = directory[FDT[currmyfile].dirIndex];
rootFAT = myfile.indFAT;
currFATi = rootFAT;
for(i=0; i < 1024; i++){//get last block in myfile
if(FDT[currmyfile].write - position > 1024){
position = position + 1024;
currFATi = FAT[currFATi][1];
}
}
read_blocks(FAT[currFATi][0], 1, appendBuff);
appendBuff[FDT[currmyfile].write - position] = 0;
maxLength = FDT[currmyfile].write + writeLength;
strcat(appendBuff, writeBuff);
apendLength = FDT[currmyfile].write - position + writeLength;
appendBuff[apendLength] = 0;
for(i=0; i < apendLength;i++){
if(apendLength - 1024 <= 0){
write_blocks(FAT[currFATi][0],1,appendBuff);
FAT[currFATi][1] = EOF;
}
else{
write_blocks(FAT[currFATi][0],1,appendBuff);
appendBuff = appendBuff + 1024;
apendLength = apendLength - 1024;
newBlock = searchBlockSpace();
FATi = searchFAT();
if(newBlock > 0){
FAT[currFATi][1] = FATi;
FAT[FATi][0] = newBlock;
FAT[FATi][1] = EOF;
free_list[newBlock] = '1';
currFATi = FATi;
}
else{
error = 1;
}
}
}
if(error != 1){
FDT[currmyfile].write = maxLength;
directory[FDT[fd].dirIndex].date = time(NULL);
directory[FDT[fd].dirIndex].size = directory[FDT[fd].dirIndex].size + length;
updateDisk();
free(writeBuff);
free(appendBuff);
printf("Data writing successfull\n");
}
else{
printf("ERROR!!!--end of free blocks\n");
}
}
