MFS File System Operations in C

Code fragment likely from mfs_readdir:

int inodo_root_previo = get_inodo_previo(fs, dir->path); // obtain prior entry inode
inode_read(fs, &ino_previo, inodo_root_previo);
// Checking to see if what we are reading is a directory or not, and storing in variables
if (inodo_root_previo != -1) {
    if (inodo_root_previo > 0)
        root_is_dir = is_dir(fs, &ino_previo, name(fs, dir->num_inodo));
    else
        root_is_dir = is_dir(fs, &ino_previo, dir->path);
    if (root_is_dir == 0) {
        if (inodo_root_previo > 0) {
            strcpy(entry->d_name, name(fs, dir->num_inodo)); // assign the name of the entry
        } else {
            strcpy(entry->d_name, dir->path); // Assign the name of the entry
        }
        dir->pos = -1;
        return input;
    }
}
if (dir->pos < (fs->sb.block_size / sizeof(struct entry)))
    dir->pos++;
else
    dir->pos = -1;
} else return NULL;
return input;

int mfs_closedir(MFS_DIR *dir)

int mfs_closedir(MFS_DIR *dir) {
    if (fs->dir.num_inodo == dir->num_inodo) {
        fs->dir.num_inodo = -1;
    }
    return 1;
}

int mfs_stat(const char *path, struct stat *buf)

int mfs_stat(const char *path, struct stat *buf) {
    struct disk_inode ino, root;
    int num_inodo;
    int es_directorio = 0;
    num_inodo = namei(fs, &fs->dir.inodo, path);
    num_inodo = get_inodo(fs, fs->dir.path);
    inode_read(fs, &ino, num_inodo);
    es_directorio = is_dir(fs, &root, path);
    buf->st_ino = num_inodo;
    buf->st_size = ino.size;
    buf->st_mode = 0;
    if (es_directorio == 1)
        buf->st_mode = S_IFDIR;
    if (num_inodo == -1 /* || num_inodo_root == -1 */)
        return -1;
    return 1;
}

int mfs_mkdir(const char *path, mode_t mode)

int mfs_mkdir(const char *path, mode_t mode) {
    char name[14];
    int i, inode;
    strcpy(name, path);
    fs = malloc(sizeof(struct file_system)); // Reading Filesystems
    fs->dev = block_open(filesystem_name);
    sb_read(fs->dev, &fs->sb);
    bitmap_read(fs);
    inode_read(fs, &fs->root, fs->sb.root_inode); //////
    inode = get_free_inode(fs); // Get free inode
    char block[fs->sb.block_size];
    struct entry *dire = (struct entry *)block;
    for (i = 0; i < fs->root.e.size; i++) { // Iterate through root directory entries
        data_read(fs, block, (fs->root.e.start + i));
        if (dire[i].inode == -1) {
            strncpy(dire[i].name, name, ENTRY_SIZE);
            printf("inode -> %d", inode);
            dire[i].inode = inode;
            data_write(fs, block, (fs->root.e.start + i));
            i = fs->root.e.size;
            break;
        }
        continue;
    }
    struct disk_inode directory;
    char block_dir[fs->sb.block_size]; // Use a different block variable name
    struct entry *dir = (struct entry *)block_dir;
    for (i = 0; i < fs->sb.block_size / sizeof(struct entry); i++) { // Initialize directory entries
        dir[i].inode = -1;
        strncpy(dir[i].name, name, ENTRY_SIZE);
    }
    directory.size = inode; // Assign the directory inode
    directory.e.size = 8; // default 8 blocks
    inode_read(fs, &directory, inode);
    for (i = 0; i < directory.e.size; i++) {
        data_write(fs, block_dir, directory.e.start + i); // Write directory block and update bitmap
        bitmap_set(fs, (directory.e.start + i));
    }
    bitmap_write(fs);
    inode_write(fs, &directory, inode);
    return 1;
}