[wip] add file creation, hardlinking, listing directory (in short and long formats)
This commit is contained in:
parent
a6d8c9e40e
commit
685f9fa5cb
1
config.h
1
config.h
|
|
@ -5,6 +5,7 @@
|
|||
#define DEBUG 1
|
||||
#define LOG_LEVEL 4
|
||||
#define ENABLE_FILE_LINE_IN_OTHER_PR 1
|
||||
#define ENABLE_STDOUT 1
|
||||
|
||||
|
||||
/* Output color config section */
|
||||
|
|
|
|||
|
|
@ -8,10 +8,14 @@
|
|||
#define COLOR_RESET "\e[0m"
|
||||
#define COLOR_RED "\e[0;31m"
|
||||
#define COLOR_YELLOW "\e[0;33m"
|
||||
#define COLOR_BLUE "\e[0;34m"
|
||||
#define COLOR_CYAN "\e[0;36m"
|
||||
#else
|
||||
#define COLOR_RESET ""
|
||||
#define COLOR_RED ""
|
||||
#define COLOR_YELLOW ""
|
||||
#define COLOR_BLUE ""
|
||||
#define COLOR_CYAN ""
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
|||
5
inc/fs.h
5
inc/fs.h
|
|
@ -36,7 +36,7 @@ struct fs_inode_extension {
|
|||
};
|
||||
|
||||
__attribute__((packed))
|
||||
struct fs_directory_block_data {
|
||||
struct fs_directory_record {
|
||||
unsigned char fname[60];
|
||||
unsigned int inode_no;
|
||||
};
|
||||
|
|
@ -44,7 +44,10 @@ struct fs_directory_block_data {
|
|||
char *fs_get_cwd(void);
|
||||
|
||||
int fs_create(void *d);
|
||||
int fs_ln(void *);
|
||||
int fs_use(void *d);
|
||||
int fs_mkfs(void *d);
|
||||
int fs_ls(void *d);
|
||||
int fs_la(void *d);
|
||||
int fs_allow_write(void *d);
|
||||
int fs_prohibit_write(void *d);
|
||||
|
|
|
|||
|
|
@ -13,6 +13,13 @@
|
|||
#endif
|
||||
|
||||
|
||||
#if ENABLE_STDOUT == 1
|
||||
#define pr_stdout(...) { printf(__VA_ARGS__); }
|
||||
#else
|
||||
#define pr_stdout(...) {}
|
||||
#endif
|
||||
|
||||
|
||||
#if LOG_LEVEL >= 2
|
||||
#if ENABLE_FILE_LINE_IN_OTHER_PR == 1
|
||||
#define pr_err(...) { \
|
||||
|
|
|
|||
|
|
@ -15,9 +15,12 @@ static const struct CliCommandEntry cmd[] = {
|
|||
// mandatory commands
|
||||
{"mkfs", 1, (enum CliArgType[]) {INT}, fs_mkfs},
|
||||
{"create", 1, (enum CliArgType[]) {STR}, fs_create},
|
||||
{"ls", 0, NULL, fs_ls},
|
||||
{"ln", 2, (enum CliArgType[]) {STR, STR}, fs_ln},
|
||||
|
||||
// custom commands
|
||||
{"use", 1, (enum CliArgType[]) {STR}, fs_use},
|
||||
{"la", 0, NULL, fs_la},
|
||||
{"prohibit-write", 0, NULL, fs_prohibit_write},
|
||||
{"allow-write", 0, NULL, fs_allow_write},
|
||||
{"exit", 0, NULL, ctrl_exit}
|
||||
|
|
|
|||
387
src/fs.c
387
src/fs.c
|
|
@ -2,6 +2,7 @@
|
|||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/stat.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "print.h"
|
||||
#include "fs.h"
|
||||
|
|
@ -10,6 +11,7 @@
|
|||
|
||||
const static int BLOCK_ADDRESSES_PER_INODE = (FS_BLOCK_SIZE-sizeof(int)*3) / sizeof(int);
|
||||
const static int BLOCK_ADDRESSES_PER_INODE_EXTENSION = (FS_BLOCK_SIZE-sizeof(int)) / sizeof(int);
|
||||
const static int DIRECTORY_RECORDS_PER_BLOCK = FS_BLOCK_SIZE / sizeof(struct fs_directory_record);
|
||||
|
||||
|
||||
static char used_file_path[FS_MAX_DEVICE_FILE_NAME_LEN+1];
|
||||
|
|
@ -19,6 +21,7 @@ static int write_permitted;
|
|||
static char fs_cwd[FS_MAX_PATH_LEN+1];
|
||||
static struct fs_header fsh_cache;
|
||||
static char fs_bitmap_cache[FS_BLOCK_SIZE * FS_MAX_BITMAP_SIZE];
|
||||
static unsigned int fs_cwd_inode_ptr;
|
||||
|
||||
|
||||
static int read_block(unsigned int block_no, void *data)
|
||||
|
|
@ -136,6 +139,75 @@ static unsigned int find_free_block(void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static unsigned int find_free_inode_ptr(void)
|
||||
{
|
||||
unsigned int i = 1; // inode0 always points to root dir, so can't be free
|
||||
|
||||
// search fs_header
|
||||
for ( ; i < BLOCK_ADDRESSES_PER_INODE; i++) {
|
||||
if (fsh_cache.inode_ptrs[i] == 0) {
|
||||
if (i < fsh_cache.max_inode_count) {
|
||||
return i;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// search fs_header_extensions
|
||||
struct fs_header_extension ext;
|
||||
unsigned int next_extension = fsh_cache.next_extension;
|
||||
|
||||
while (next_extension) {
|
||||
read_block(next_extension, (void *) &ext);
|
||||
next_extension = ext.next_extension;
|
||||
|
||||
for (int j = 0; j < BLOCK_ADDRESSES_PER_INODE_EXTENSION; j++, i++) {
|
||||
if (ext.inode_ptrs[j] == 0) {
|
||||
if (i < fsh_cache.max_inode_count) {
|
||||
return i;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (i < fsh_cache.max_inode_count) {
|
||||
return i;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static unsigned int read_inode_ptr(unsigned int inode_ptr)
|
||||
{
|
||||
if ((inode_ptr / BLOCK_ADDRESSES_PER_INODE) == 0) {
|
||||
// inode_ptr is in the fs_header
|
||||
struct fs_header fsh;
|
||||
int read_result = read_block(0, &fsh);
|
||||
if (FS_BLOCK_SIZE != read_result) {
|
||||
if (read_result < 0) {
|
||||
pr_err("failed to read fs header from device '%s'\n", used_file_path);
|
||||
} else {
|
||||
pr_err("failed to read full header from device (read %d/%d bytes)\n", read_result, FS_BLOCK_SIZE);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
return fsh.inode_ptrs[inode_ptr];
|
||||
} else {
|
||||
pr_err("inode_ptr %d is in fs_header_extension, reading is not implemented\n", inode_ptr);
|
||||
return 0;
|
||||
// TODO: find block with relevant inode_ptr
|
||||
/*
|
||||
unsigned int relevant_block_index = ((free_block_index - BLOCK_ADDRESSES_PER_INODE) / BLOCK_ADDRESSES_PER_INODE_EXTENSION) + 1;
|
||||
unsigned int relevant_block_record_offset = (free_block_index - BLOCK_ADDRESSES_PER_INODE) % BLOCK_ADDRESSES_PER_INODE_EXTENSION;
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
||||
static void write_inode_ptr(unsigned int inode_ptr, unsigned int block_ptr)
|
||||
{
|
||||
if ((inode_ptr / BLOCK_ADDRESSES_PER_INODE) == 0) {
|
||||
|
|
@ -167,6 +239,7 @@ static void write_inode_ptr(unsigned int inode_ptr, unsigned int block_ptr)
|
|||
|
||||
pr("Updated inode ptr %d -> %d\n", inode_ptr, block_ptr);
|
||||
} else {
|
||||
pr_err("inode_ptr %d is in fs_header_extension, writing is not implemented\n", inode_ptr);
|
||||
// TODO: find block with relevant inode_ptr, extend fs_header if needed
|
||||
/*
|
||||
unsigned int relevant_block_index = ((free_block_index - BLOCK_ADDRESSES_PER_INODE) / BLOCK_ADDRESSES_PER_INODE_EXTENSION) + 1;
|
||||
|
|
@ -214,9 +287,314 @@ int fs_prohibit_write(void *d)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static struct fs_directory_record *fs_read_dir(unsigned int fs_inode_ptr)
|
||||
{
|
||||
unsigned int inode_block_no = read_inode_ptr(fs_inode_ptr);
|
||||
struct fs_inode dir_inode;
|
||||
read_block(inode_block_no, &dir_inode);
|
||||
|
||||
if (dir_inode.size == 0) {
|
||||
pr("directory is empty\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct fs_directory_record *recs = malloc(fsh_cache.max_inode_count * sizeof(struct fs_directory_record));
|
||||
memset(recs, 0, fsh_cache.max_inode_count * sizeof(struct fs_directory_record));
|
||||
|
||||
// read block portion from dir_inode
|
||||
for (int i = 0; (i*DIRECTORY_RECORDS_PER_BLOCK < dir_inode.size) && (i < BLOCK_ADDRESSES_PER_INODE); i++) {
|
||||
if (dir_inode.blocks[i]) {
|
||||
read_block(dir_inode.blocks[i], &(recs[i*DIRECTORY_RECORDS_PER_BLOCK]));
|
||||
}
|
||||
}
|
||||
|
||||
// read block portions from inode extensions
|
||||
// TODO
|
||||
|
||||
return recs;
|
||||
}
|
||||
|
||||
static int fs_find_free_directory_record(unsigned int dir_inode_ptr)
|
||||
{
|
||||
struct fs_directory_record *recs = fs_read_dir(dir_inode_ptr);
|
||||
if (!recs) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
for (unsigned int i = 0; i < fsh_cache.max_inode_count; i++) {
|
||||
if (!recs[i].inode_no) {
|
||||
free(recs);
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
free(recs);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int fs_add_fname_to_directory(unsigned int dir_inode_ptr, unsigned int target_inode_ptr, char *fname)
|
||||
{
|
||||
int new_directory_record_index = fs_find_free_directory_record(dir_inode_ptr);
|
||||
if (new_directory_record_index < 0) {
|
||||
pr_err("no free inode pointer found\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (new_directory_record_index < DIRECTORY_RECORDS_PER_BLOCK * BLOCK_ADDRESSES_PER_INODE) {
|
||||
// record is located in base inode, writing to it
|
||||
int block_no = new_directory_record_index / DIRECTORY_RECORDS_PER_BLOCK;
|
||||
int block_offset = new_directory_record_index % DIRECTORY_RECORDS_PER_BLOCK;
|
||||
|
||||
struct fs_inode dir_inode;
|
||||
read_block(read_inode_ptr(dir_inode_ptr), (void *) &dir_inode);
|
||||
|
||||
if (dir_inode.blocks[block_no] == 0) {
|
||||
// allocate new block
|
||||
unsigned int new_block = find_free_block();
|
||||
if (new_block == 0) {
|
||||
pr_err("failed to allocate block to extend directory (inode_ptr=%d)\n", dir_inode_ptr);
|
||||
return -1;
|
||||
} else {
|
||||
pr("Allocated new physical block %d for inode_ptr=%d (inode=%d, inner_block_no=%d)\n",
|
||||
new_block, read_inode_ptr(dir_inode_ptr), block_no);
|
||||
}
|
||||
|
||||
char zero_data[FS_BLOCK_SIZE] = {};
|
||||
memset(zero_data, 0, FS_BLOCK_SIZE);
|
||||
write_block(new_block, &zero_data);
|
||||
|
||||
mark_used(new_block);
|
||||
|
||||
dir_inode.blocks[block_no] = new_block;
|
||||
if (dir_inode.size <= block_no * FS_BLOCK_SIZE) {
|
||||
pr("Updated directory size at inode_ptr=%d: %d -> %d\n",
|
||||
dir_inode_ptr, dir_inode.size, (block_no + 1) * FS_BLOCK_SIZE);
|
||||
dir_inode.size = (block_no + 1) * FS_BLOCK_SIZE;
|
||||
write_block(read_inode_ptr(dir_inode_ptr), (void *) &dir_inode);
|
||||
}
|
||||
}
|
||||
|
||||
struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
|
||||
read_block(dir_inode.blocks[block_no], (void *) &recs);
|
||||
|
||||
strcpy(recs[block_offset].fname, fname);
|
||||
recs[block_offset].inode_no = target_inode_ptr;
|
||||
|
||||
write_block(dir_inode.blocks[block_no], (void *) &recs);
|
||||
|
||||
pr("Written new directory record #%d for file '%s' (-> %d) in inode_ptr=%d\n",
|
||||
new_directory_record_index, fname, target_inode_ptr, dir_inode_ptr);
|
||||
|
||||
return 0;
|
||||
} else {
|
||||
// record is located in inode extension
|
||||
// TODO
|
||||
}
|
||||
|
||||
// I don't remember what was this, but this function shouldn't need it
|
||||
|
||||
// write new record
|
||||
//unsigned int inode_block_no = read_inode_ptr(fs_inode_ptr);
|
||||
}
|
||||
|
||||
int fs_create(void *d)
|
||||
{
|
||||
pr("[mock] Regular file '%s' created\n", *((char **) d));
|
||||
char *fname = *((char **) d);
|
||||
int fname_len = strlen(fname);
|
||||
|
||||
if (fname_len > 59) {
|
||||
pr_err("filename too long (%d > %d)\n", fname_len, 59);
|
||||
return 0;
|
||||
}
|
||||
|
||||
pr("Creating regular file '%s'\n", fname);
|
||||
|
||||
int inode_block_no = find_free_block();
|
||||
if (!inode_block_no) {
|
||||
pr_err("no free blocks available to save file inode\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// write new file inode
|
||||
struct fs_inode newf = {};
|
||||
newf.ftype = REGULAR;
|
||||
newf.ref_count = 1;
|
||||
newf.size = 0;
|
||||
|
||||
{
|
||||
int bytes_written = write_block(inode_block_no, (void *) &newf);
|
||||
|
||||
if (bytes_written < 0) {
|
||||
pr_err("failed to write inode block to device '%s'\n", used_file_path);
|
||||
return 0;
|
||||
} else if (bytes_written < FS_BLOCK_SIZE) {
|
||||
pr_err("failed to write full inode block to device '%s' (written %d/%d bytes)\n",
|
||||
used_file_path, bytes_written, FS_BLOCK_SIZE);
|
||||
return 0;
|
||||
} else {
|
||||
pr("Written inode block to device '%s'\n", used_file_path);
|
||||
}
|
||||
|
||||
mark_used(inode_block_no);
|
||||
}
|
||||
|
||||
// allocate and write inode pointer for new inode
|
||||
unsigned int inode_ptr_index = find_free_inode_ptr();
|
||||
if (!inode_ptr_index) {
|
||||
pr_err("no free inode ptr found\n");
|
||||
return 0;
|
||||
}
|
||||
write_inode_ptr(inode_ptr_index, inode_block_no);
|
||||
|
||||
// add filename to current directory inode
|
||||
fs_add_fname_to_directory(fs_cwd_inode_ptr, inode_ptr_index, fname);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fs_ln(void *d) {
|
||||
if (used_file_fd <= 0) {
|
||||
pr_err("no storage device\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
char *existing_fname = ((char **) d)[0];
|
||||
char *new_fname = ((char **)d)[1];
|
||||
int new_fname_len = strlen(new_fname);
|
||||
|
||||
if (new_fname_len > 59) {
|
||||
pr_err("new filename too long (%d > 59)\n", new_fname_len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
pr("Making hard link '%s' -> '%s'\n", new_fname, existing_fname);
|
||||
|
||||
// find original file name
|
||||
unsigned int original_inode_ptr = 0;
|
||||
|
||||
int dir_inode = read_inode_ptr(fs_cwd_inode_ptr);
|
||||
|
||||
struct fs_inode dir;
|
||||
read_block(dir_inode, (void *) &dir);
|
||||
|
||||
// list entries from base inode
|
||||
for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
|
||||
struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
|
||||
|
||||
if (dir.blocks[i]) {
|
||||
read_block(dir.blocks[i], (void *) &recs);
|
||||
|
||||
for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
|
||||
if (!recs[k].inode_no)
|
||||
continue;
|
||||
|
||||
if (!strcmp(existing_fname, recs[k].fname)) {
|
||||
original_inode_ptr = recs[k].inode_no;
|
||||
goto original_inode_ptr_found;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pr_err("no such file '%d'\n", existing_fname);
|
||||
return 0;
|
||||
|
||||
original_inode_ptr_found:
|
||||
pr("Original inode_ptr found (%d)\n", original_inode_ptr);
|
||||
|
||||
// register new filename with the same inode_ptr
|
||||
if (fs_add_fname_to_directory(fs_cwd_inode_ptr, original_inode_ptr, new_fname) < 0) {
|
||||
pr_err("failed to register filename in directory '%s'\n", fs_cwd_inode_ptr);
|
||||
return 0;
|
||||
} else {
|
||||
pr("Registered new filename in directory '%s'\n", fs_cwd_inode_ptr);
|
||||
}
|
||||
|
||||
// update ref_count in file inode
|
||||
struct fs_inode f;
|
||||
read_block(read_inode_ptr(original_inode_ptr), (void *) &f);
|
||||
f.ref_count++;
|
||||
write_block(read_inode_ptr(original_inode_ptr), (void *) &f);
|
||||
|
||||
pr("Updated inode ref_count (%d -> %d)\n", f.ref_count-1, f.ref_count);
|
||||
}
|
||||
|
||||
int fs_ls(void *d) {
|
||||
if (used_file_fd <= 0) {
|
||||
pr_err("no storage device\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
int dir_inode = read_inode_ptr(fs_cwd_inode_ptr);
|
||||
|
||||
struct fs_inode dir;
|
||||
read_block(dir_inode, (void *) &dir);
|
||||
|
||||
// list entries from base inode
|
||||
for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
|
||||
struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
|
||||
|
||||
if (dir.blocks[i]) {
|
||||
read_block(dir.blocks[i], (void *) &recs);
|
||||
|
||||
for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
|
||||
if (!recs[k].inode_no)
|
||||
continue;
|
||||
|
||||
pr_stdout("%s\n", recs[k].fname);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// list entries from inode extension
|
||||
// TODO
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fs_la(void *d) {
|
||||
if (used_file_fd <= 0) {
|
||||
pr_err("no storage device\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
int dir_inode = read_inode_ptr(fs_cwd_inode_ptr);
|
||||
|
||||
struct fs_inode dir;
|
||||
read_block(dir_inode, (void *) &dir);
|
||||
|
||||
pr_stdout("directory size: %d\n", dir.size);
|
||||
|
||||
// list entries from base inode
|
||||
for (int i = 0; i < BLOCK_ADDRESSES_PER_INODE; i++) {
|
||||
struct fs_directory_record recs[DIRECTORY_RECORDS_PER_BLOCK];
|
||||
|
||||
if (dir.blocks[i]) {
|
||||
read_block(dir.blocks[i], (void *) &recs);
|
||||
|
||||
for (int k = 0; k < DIRECTORY_RECORDS_PER_BLOCK; k++) {
|
||||
if (!recs[k].inode_no)
|
||||
continue;
|
||||
|
||||
struct fs_inode f_inode;
|
||||
read_block(read_inode_ptr(recs[k].inode_no), (void *) &f_inode);
|
||||
|
||||
if (f_inode.ftype == DIRECTORY) {
|
||||
pr_stdout(COLOR_BLUE "%s" COLOR_RESET
|
||||
"(inode_ptr=%d -> inode=%d, ref_count=%d, size=%d, type=dir)\n",
|
||||
recs[k].fname, recs[k].inode_no, read_inode_ptr(recs[k].inode_no),
|
||||
f_inode.ref_count, f_inode.size);
|
||||
} else {
|
||||
pr_stdout("%s (inode_ptr=%d -> inode=%d, ref_count=%d, size=%d, type=reg)\n",
|
||||
recs[k].fname, recs[k].inode_no, read_inode_ptr(recs[k].inode_no),
|
||||
f_inode.ref_count, f_inode.size);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// list entries from inode extension
|
||||
// TODO
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -304,6 +682,8 @@ int fs_use(void *d)
|
|||
|
||||
char *root_dir_path = "/";
|
||||
fs_chdir((void *) &root_dir_path);
|
||||
|
||||
fs_cwd_inode_ptr = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
@ -439,8 +819,13 @@ finish_current_block:
|
|||
// inode0 -> root_dir_block
|
||||
write_inode_ptr(0, free_block_index);
|
||||
|
||||
// update fsh cache
|
||||
memcpy(&fsh_cache, &fsh, FS_BLOCK_SIZE);
|
||||
|
||||
char *root_dir_path = "/";
|
||||
fs_chdir((void *) &root_dir_path);
|
||||
|
||||
fs_cwd_inode_ptr = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue