fsInit.c

/**************************************************************
* Class::  CSC-415-01 Summer 2025
* Name:: Anmol Tadikonda, Yuhang Wei, Bryan Escobar, Edgar Jaquez
* Student IDs:: 922643511, 923749629, 922876796, 923919292
* GitHub-Name:: csc415-filesystem-JustinWei110
* Group-Name:: Operating System 2
* Project:: Basic File System
*
* File:: fsInit.c
*
* Description:: The implementation for the main driver for file system assignment.
*
* 
*
**************************************************************/


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

#include "fsLow.h"
#include "fsInit.h"
#include "mfs.h"
#include <math.h>

static uint32_t mapStart = 0;
static uint32_t mapLength = 0;
static uint32_t tolBlocks = 0;
static uint32_t blockSize = 0;

int deallocate_blocks(uint32_t blockStart, uint32_t size) {
	uint8_t* bitmap = NULL;

	uint32_t numBlocks = ceil(size / blockSize);

	bitmap = malloc(mapLength * blockSize);
	if (!bitmap)
	{
		perror("Failed to load bitmap");
		return 1;
	}
	LBAread(bitmap, mapLength, mapStart);

	for (uint32_t i = blockStart; i < blockStart + numBlocks; i++) {

		if (i > tolBlocks) {
			printf("Tried to deallocate out of disk");
			return 1;
		}

		int byte = i / 8;
		int bit = i % 8;

		bitmap[byte] &= ~(1 << bit);
	}

	LBAwrite(bitmap, mapLength, mapStart);
	free(bitmap);
	return 0; 
}

uint32_t allocate_blocks(uint32_t numBlocks) {
	uint8_t* bitmap = NULL;

	//loading bitmap

	bitmap = malloc(mapLength * blockSize);
	if (!bitmap)
	{
		perror("Failed to load bitmap");
		return 1;
	}
	LBAread(bitmap, mapLength, mapStart);

	// free blocks
	uint32_t startBlock = 0;
	uint32_t Freeblocks = 0;

	//find free blocks
	for (uint32_t i = 0; i < tolBlocks; i++) {
		int byte = i / 8;
		int bit = i % 8;

		//checking for free blocks
		if (!(bitmap[byte] & (1 << bit))) {
			Freeblocks++;
			if (Freeblocks == numBlocks) {
				startBlock = i - numBlocks + 1;
				break;
			}
		}
		else {
			Freeblocks = 0;
		}
	}
	if (Freeblocks < numBlocks) {
		return -1;
	}
	//used blocks
	for (uint32_t i = startBlock; i < startBlock + numBlocks; i++) {
		int bytes = i / 8;
		int bits = i % 8;

		bitmap[bytes] |= (1 << bits);
	}
	//updates bitmap
	LBAwrite(bitmap, mapLength, mapStart);

	free(bitmap);

	return startBlock;

}

int initFreeSpace(uint64_t numberOfBlocks) {

	int bitMapNumBlocks = ceil(((float)numberOfBlocks / 8.0f) / (float)blockSize);
	
	u_int8_t* spaceBitMap = calloc(1, blockSize * bitMapNumBlocks);
	if (!spaceBitMap) {
		perror("Can't allocate bitmap");
		return 1;
	}

	for (int i = 0; i < 6; i++) {
		int index = i / 8;
		int offset = i % 8;
		spaceBitMap[index] |= (1 << offset);
	}
	

	uint64_t write = LBAwrite(spaceBitMap, bitMapNumBlocks, 1);
	if (write != bitMapNumBlocks) {
		perror("Can't write bit map to disk");
		free(spaceBitMap);
		return 1;
	}

	free(spaceBitMap);

	return bitMapNumBlocks;
}

int initFileSystem(uint64_t numberOfBlocks, uint64_t givenBlockSize)
{
	blockSize = givenBlockSize;
	printf("Initializing File System with %ld blocks with a block size of %ld\n", numberOfBlocks, givenBlockSize);

	struct VCBtype* VCB = NULL;

	VCB = malloc(givenBlockSize);
	if (!VCB)
	{
		perror("Can't allocate VCB");
		return 1;
	}

	// Check if first block actually contains a valid VCB
	LBAread(VCB, 1, 0);

	if (VCB->signature != PART_SIGNATURE && VCB->signature != PART_SIGNATURE2) {

		// If it doesn't then initialize it
		VCB->numberOfBlocks = numberOfBlocks;
		VCB->blockSize = givenBlockSize;
		VCB->signature = PART_SIGNATURE;


		// Initialize free space
		int bitMapNumBlocks = initFreeSpace(numberOfBlocks);

		mapStart = 1;
		mapLength = bitMapNumBlocks;
		tolBlocks = numberOfBlocks;

		VCB->mapStart = 1;
		VCB->mapLength = bitMapNumBlocks;

		// Initialize root directory
		// *TO DO*

		uint32_t entries = 50;
		uint32_t size = 60;
		uint32_t bytes = entries * size;
		uint32_t blocksNeed = ceil((double)bytes / (double)blockSize);

		// memory for directory entries
		void* rootEntries = malloc(blocksNeed * blockSize);
		if (!rootEntries)
		{
			perror("Failed to allocate entries");
			free(VCB);
			return 1;
		}
		//Initialize to 0
		memset(rootEntries, 0, blocksNeed * blockSize);

		mapStart = VCB->mapStart;
		mapLength = VCB->mapLength;
		tolBlocks = VCB->numberOfBlocks;
		blockSize = VCB->blockSize;

		//get blocks from free space
		uint32_t StartBlock = allocate_blocks(blocksNeed);
		if (StartBlock == (uint32_t)-1) {
			perror("Failed to allocate blocks");
			free(rootEntries);
			free(VCB);
			return 1;
		}
		// set "." beginning of rootEntries
		struct DirectoryEntry* entry = (struct DirectoryEntry*)rootEntries;

		strncpy(entry[0].name, ".", 32);
		entry[0].fileSize = (entries - 2) * size;
		entry[0].inWhichBlock = StartBlock;
		entry[0].createdTime = time(NULL);
		entry[0].isDirectory = 1;


		//setting entry ".."
		strncpy(entry[1].name, "..", 32);
		entry[1].fileSize = entry[0].fileSize;
		entry[1].inWhichBlock = StartBlock;
		entry[1].createdTime = entry[0].createdTime;
		entry[1].isDirectory = 1;

		

		//root directory to disk
		if (LBAwrite(rootEntries, blocksNeed, StartBlock) != blocksNeed)
		{
			perror("Failed to write root directory");
			free(rootEntries);
			free(VCB);
			return 1;
		}
		//VCB with root directory Location
		VCB->rootDir = StartBlock;

		u_int64_t write = LBAwrite(VCB, 1, 0);
		if (write != 1)
		{
			perror("Can't write VCB to disk");
			free(rootEntries);
			free(VCB);
			return 1;
		}

		free(rootEntries);
	}
	else {
		mapStart = VCB->mapStart;
		mapLength = VCB->mapLength;
		tolBlocks = VCB->numberOfBlocks;
		blockSize = VCB->blockSize;
	}

	free(VCB);
	return 0;
}

void exitFileSystem()
{
	printf("System exiting\n");
}