void initSFS(int dev)
{ //Assuming only predefined sizes are used
char buf[4096];
int i;
init_superblock(&sb);
write(devfd[dev],(&sb),BLOCK);
init_inodetable(&inodetable);
//initialising root directory inode
head=init_inode(getinode(dev),1,1,BLOCK,IS_DIR,6); //4+2=>read+write
tail=head;
head->INODE->i_blocks[0]=alloc_data(dev);
strcpy(dentry.dirname,".");
dentry.i_node=head->i_node;
head->INODE->file_size=sizeof(dentry);
write(devfd[dev],head->INODE,sizeof(head->INODE));
for(i=1;i<INODETABSIZE;i++)
write(devfd[dev],&inodetable,sizeof(inodetable));
// printf("%d\n",p);
bzero(buf,PAGECOMP);
write(devfd[dev],buf,PAGECOMP);
write(devfd[dev],&dentry,BLOCK);
head->offset=sizeof(dentry);
for(i=1;i<DATABLOCK;i++)
{
if(i==DATABLOCK-1)
db.next=-1;
else
db.next=i+1;
db.cur=i;
write(devfd[dev],&db,BLOCK);
}
}
int main(int argc, char *argv[])
{
int rv, fd, i, is_ssd;
char *node;
struct stat st;
struct castle_slave_superblock_public super;
char buf[4096];
/* check args */
if(argc != 2) {
usage();
exit(2);
}
node = argv[1];
if(stat(node, &st)) {
fprintf(stderr, "%s: failed to stat %s: %s\n", argv[0], node, strerror(errno));
exit(2);
}
#if 0
if(!st.st_rdev) {
fprintf(stderr, "Warning: %s does not seem to be a device node\n", node);
}
#endif
is_ssd = check_ssd(node);
init_superblock(&super, is_ssd);
/* write */
if((fd = open(node, O_RDWR|O_LARGEFILE|O_SYNC)) == -1) {
/* open failed */
fprintf(stderr, "%s: failed to open %s: %s\n", argv[0], node, strerror(errno));
exit(1);
}
/* Set first MB of the disk to 0. */
memset(buf, 0 , 4096);
for(i=0; i<(MB / 4096); i++) {
if(write(fd, buf, 4096) != 4096) {
fprintf(stderr, "Failure setting up disk!\n");
return 0;
}
}
lseek(fd, 0, SEEK_SET);
if(!write_superblock(fd, &super)) {
fprintf(stderr, "%s: Error writing superblock on %s: %s", argv[0], node, strerror(errno));
exit(1);
}
if(close(fd)) {
fprintf(stderr, "%s: Warning: error closing %s: %s", argv[0], node, strerror(errno));
exit(1);
}
exit(0);
}
void mksfs(int fresh){
//Implement mksfs here
if (fresh == 1){
//deletes fs if it already exists
if(access(DISK_FILE, F_OK) != -1){
unlink(DISK_FILE);
}
//fs creation
printf("Initalizing sfs\n");
init_fresh_disk(DISK_FILE, BLOCK_SIZE, MAX_BLOCKS);
//zero_everything();
// writes superblock to the first block
printf("Writing superblocks\n");
init_superblock();
write_blocks(0, 1, &sb);
// write the inode table to the 2nd block
printf("Writing inode table\n");
init_inode_table();
//add_root_dir_inode();
//add_dummy_file_inode();
//write_blocks(1, 1, &inode_table);
// creates free list
init_free_list();
// write root directory data to the 3rd block
printf("Writing root dir\n");
init_root_dir();
//allocate memory for directory inode
inode_t *inode = malloc(ADJUST((MAX_FILES+1)*sizeof(inode_t)));
read_blocks(INODE_TABLE, INODE_TABLE_SIZE, inode);
if(inode == NULL){
return;
}
//set first inode to point to directory
inode[0].size = DIRECTORY_SIZE*BLOCK_SIZE;
inode[0].link_cnt = DIRECTORY_SIZE;
inode[0].exists = 1;
//check to see if we need to use ref_ptr
//if(DIRECTORY_SIZE > 12){
//inode[0].ref_ptr = search();
//setAlloc(inode[0].ref_ptr);
//unsigned int *buffer = malloc(BLOCK_SIZE);
//write_blocks(19 + inode[0].ref_ptr, 1, buffer);
//free(buffer);
//assign the pointers the location of directory files
int i;
for(i = 0; i < DIRECTORY_SIZE; i++){
if(i > 11){
unsigned int *buffer = malloc(BLOCK_SIZE);
read_blocks(19+ inode[0].ref_ptr, 1, buffer);
buffer[i - 12] = 2 + i;
write_blocks(19+ inode[0].ref_ptr, 1, buffer);
free(buffer);
}
else{
inode[0].data_ptrs[i] = 2 + i;
}
}
//update inode and free memory
write_blocks(INODE_TABLE, INODE_TABLE_SIZE, inode);
free(inode);
}
else if (fresh == 0){
if(init_disk(DISK_FILE, BLOCK_SIZE, MAX_BLOCKS) != 0){
printf("Error initializing disk\n");
return;
}
}
//allocate main memory for filesystem data structures
int *superblock = malloc(BLOCK_SIZE*SUPERBLOCK_SIZE);
if(superblock == NULL){
printf("Error allocating memory for superblock\n");
return;
}
read_blocks(0, SUPERBLOCK_SIZE, superblock);
//allocate main memory for directory
root_dir = malloc(ADJUST(sizeof(dir_entry_t)*MAX_FILES));
if(root_dir == NULL){
printf("Error allocating memory for root directory\n");
return;
}
read_blocks(2, DIRECTORY_SIZE, root_dir);
//allocate memory for inode table
inode_table = malloc(ADJUST(sizeof(inode_t)*(MAX_FILES+1)));
if(inode_table == NULL){
printf("Error allocating memory for inode table");
return;
}
read_blocks(INODE_TABLE, INODE_TABLE_SIZE, inode_table);
fileCount = 0;
fd_table = NULL;
return;
}
/*
* Creacio del fitxer on es te el sistema de fitxers.
* mi_mkfs <cantidad_bloques>
* codis de retorn:
* 0: correcte
* -1: nombre de parametres incorrecte
*/
int main(int argc, char **argv) {
int i = 0;
int nombre_blocs;
int n_inode;
emofs_superblock sb;
emofs_inode inode;
/* Some fun */
char author[][20] = { AUTHOR_B, AUTHOR_P };
char buf[80];
char path[MAX_PATH_LEN];
int ascii_art; /* ASCII art, descriptor de fitxer */
int pos;
int read_bytes;
emofs_block bloc_zero = block_of_zero();
if (argc != 2) {
nombre_blocs = DEFAULT_BLOCKS;
} else {
nombre_blocs = atoi(argv[1]);
}
bmount();
/* Inicialitzam tot el sistema de fitxers */
for (i = 0; i < nombre_blocs; i++) {
bwrite(i, &bloc_zero);
}
init_superblock(nombre_blocs);
init_bitmap();
init_inode_array();
/* Problema de bootstrap. Es necessita una ruta per crear un fitxer. */
n_inode = alloc_inode(DIRECTORY_INODE);
sbread(&sb);
sb.root_inode = n_inode;
sbwrite(&sb);
/* JUST FOR FUN */
/* Cream directori /authors */
if (fork() == 0) {
execl("mi_mkdir", "mi_mkdir", "/authors", (char *)0);
} else {
wait3(NULL, 0, NULL);
}
/* Cream i omplim /authors/author[i].ascii" */
for (i = 0; i < AUTHOR_COUNT; i++) {
ascii_art = open(author[i], O_RDONLY, S_IRUSR);
strcpy(path, "/authors/");
strcat(path, author[i]);
emofs_create(path);
pos = 0;
read_bytes = 1; /* per entrar al bucle */
while (read_bytes > 0) { /* Sortira amb el break */
lseek(ascii_art, pos, SEEK_SET);
read_bytes = read(ascii_art, buf, 80);
if (!read_bytes) break;
emofs_write(path, buf, pos, read_bytes);
pos += read_bytes;
}
close(ascii_art);
}
/* ending fun */
bumount();
return 0;
}
int main (int argc, char **argv)
{
int rc, c, opt_ind;
char *device_name;
size_t devblock_size;
struct mfs_sb_info sb;
/* Default is MinixFS V3 */
sb.magic = MFS_MAGIC_V3;
sb.fs_version = 3;
/* Default block size is 4Kb */
sb.block_size = MFS_MAX_BLOCKSIZE;
sb.dirsize = MFS3_DIRSIZE;
sb.n_inodes = 0;
sb.longnames = false;
sb.ino_per_block = V3_INODES_PER_BLOCK(MFS_MAX_BLOCKSIZE);
if (argc == 1) {
help_cmd_mkmfs(HELP_SHORT);
printf("Incorrect number of arguments, try `mkmfs --help'\n");
exit(0);
}
for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
c = getopt_long(argc, argv, "lh12b:i:",
long_options, &opt_ind);
switch (c) {
case 'h':
help_cmd_mkmfs(HELP_LONG);
exit(0);
case '1':
sb.magic = MFS_MAGIC_V1;
sb.block_size = MFS_BLOCKSIZE;
sb.fs_version = 1;
sb.ino_per_block = V1_INODES_PER_BLOCK;
sb.dirsize = MFS_DIRSIZE;
break;
case '2':
sb.magic = MFS_MAGIC_V2;
sb.block_size = MFS_BLOCKSIZE;
sb.fs_version = 2;
sb.ino_per_block = V2_INODES_PER_BLOCK;
sb.dirsize = MFS_DIRSIZE;
break;
case 'b':
sb.block_size = (uint32_t) strtol(optarg, NULL, 10);
break;
case 'i':
sb.n_inodes = (uint64_t) strtol(optarg, NULL, 10);
break;
case 'l':
sb.longnames = true;
sb.dirsize = MFSL_DIRSIZE;
break;
}
}
if (sb.block_size < MFS_MIN_BLOCKSIZE ||
sb.block_size > MFS_MAX_BLOCKSIZE) {
printf(NAME ":Error! Invalid block size.\n");
exit(0);
} else if (!is_power_of_two(sb.block_size)) {
/* Block size must be a power of 2. */
printf(NAME ":Error! Invalid block size.\n");
exit(0);
} else if (sb.block_size > MFS_BLOCKSIZE &&
sb.fs_version != 3) {
printf(NAME ":Error! Block size > 1024 is "
"supported by V3 filesystem only.\n");
exit(0);
} else if (sb.fs_version == 3 && sb.longnames) {
printf(NAME ":Error! Long filenames are supported "
"by V1/V2 filesystem only.\n");
exit(0);
}
if (sb.block_size == MFS_MIN_BLOCKSIZE)
shift = 1;
else if (sb.block_size == MFS_MAX_BLOCKSIZE)
shift = 3;
else
shift = 2;
argv += optind;
device_name = argv[0];
if (!device_name) {
help_cmd_mkmfs(HELP_LONG);
exit(0);
}
rc = loc_service_get_id(device_name, &service_id, 0);
if (rc != EOK) {
printf(NAME ": Error resolving device `%s'.\n", device_name);
return 2;
}
rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
if (rc != EOK) {
printf(NAME ": Error initializing libblock.\n");
return 2;
}
rc = block_get_bsize(service_id, &devblock_size);
if (rc != EOK) {
printf(NAME ": Error determining device block size.\n");
return 2;
}
rc = block_get_nblocks(service_id, &sb.dev_nblocks);
if (rc != EOK) {
printf(NAME ": Warning, failed to obtain "
"block device size.\n");
} else {
printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
sb.dev_nblocks);
}
if (devblock_size != 512) {
printf(NAME ": Error. Device block size is not 512 bytes.\n");
return 2;
}
/* Minimum block size is 1 Kb */
sb.dev_nblocks /= 2;
printf(NAME ": Creating Minix file system on device\n");
printf(NAME ": Writing superblock\n");
/* Initialize superblock */
if (init_superblock(&sb) != EOK) {
printf(NAME ": Error. Superblock initialization failed\n");
return 2;
}
printf(NAME ": Initializing bitmaps\n");
/* Initialize bitmaps */
if (init_bitmaps(&sb) != EOK) {
printf(NAME ": Error. Bitmaps initialization failed\n");
return 2;
}
printf(NAME ": Initializing the inode table\n");
/* Init inode table */
if (init_inode_table(&sb) != EOK) {
printf(NAME ": Error. Inode table initialization failed\n");
return 2;
}
printf(NAME ": Creating the root directory inode\n");
/* Make the root inode */
if (sb.fs_version == 1)
rc = make_root_ino(&sb);
else
rc = make_root_ino2(&sb);
if (rc != EOK) {
printf(NAME ": Error. Root inode initialization failed\n");
return 2;
}
/* Insert directory entries . and .. */
if (insert_dentries(&sb) != EOK) {
printf(NAME ": Error. Root directory initialization failed\n");
return 2;
}
block_fini(service_id);
return 0;
}
