admin/iloveos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #16 from SuperconductZB/fileioerrno

Browse Source 
added better errno to fileio
This commit is contained in:
FactorialN 2023-12-06 00:15:07 -08:00 committed by GitHub
commit 26be612d92
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 945 additions and 802 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/fs.hpp
View File

@ -18,7 +18,7 @@ public:
ssize_t read(INode_Data *inode_data, char buf[], size_t count, size_t offset);
ssize_t write(INode_Data *inode_data, const char buf[], size_t count,
size_t offset);
int truncate(INode_Data *inode_data, size_t length);
int truncate(INode_Data *inode_data, off_t length);
ssize_t lseek_next_data(INode_Data *inode_data, size_t offset);
ssize_t lseek_next_hole(INode_Data *inode_data, size_t offset);

4
include/fs/fs_data_types.hpp
View File

@ -41,6 +41,10 @@ public:
#define NUMBER_OF_DIRECT_BLOCKS \
(((INODE_SIZE - NUMBER_OF_METADATA_BYTES) / sizeof(u_int64_t)) - 3)
#define FILE_SIZE_MAX \
(IO_BLOCK_SIZE * (NUMBER_OF_DIRECT_BLOCKS + INDIRECT_BLOCKS + \
(INDIRECT_BLOCKS * INDIRECT_BLOCKS) + \
(INDIRECT_BLOCKS * INDIRECT_BLOCKS * INDIRECT_BLOCKS)))
u_int64_t single_indirect_block, double_indirect_block, triple_indirect_block;
u_int64_t direct_blocks[NUMBER_OF_DIRECT_BLOCKS];

2
include/fs_constants.hpp
View File

@ -2,6 +2,7 @@
#define FS_CONSTANTS_HPP
#include <algorithm>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <linux/fs.h>
@ -11,6 +12,7 @@
#include <sys/ioctl.h>
#include <unistd.h>
#define IO_BLOCK_SIZE 4096
#define INDIRECT_BLOCKS 512

322
lib/files.cpp
View File

@ -55,8 +55,7 @@ void FilesOperation::initialize(bool load) {
root_node = fischl_init_entry(1, "/", root_inode);
assert(root_node->self_info != NULL);
fs->load_superblock();
}
else{
} else {
initialize_rootinode();
}
}
@ -117,7 +116,9 @@ INode_Data *FilesOperation::create_new_inode(u_int64_t parent_inode_number,
bool allocated = false;
INode_Data *new_inode = new INode_Data();
fs->inode_manager->new_inode(getuid(), getgid(), mode, new_inode);
printf("NEW INODE %llu %llu %llu %o\n",new_inode->inode_num, new_inode->metadata.uid, new_inode->metadata.gid, (mode_t)new_inode->metadata.permissions);
printf("NEW INODE %llu %llu %llu %o\n", new_inode->inode_num,
new_inode->metadata.uid, new_inode->metadata.gid,
(mode_t)new_inode->metadata.permissions);
if ((mode & S_IFMT) == S_IFDIR) {
create_dot_dotdot(new_inode, parent_inode_number);
fs->inode_manager->save_inode(new_inode);
@ -212,8 +213,10 @@ u_int64_t FilesOperation::disk_namei(const char *path) {
u_int64_t FilesOperation::namei(const char *path) {
FileNode *filenode = fischl_load_entry(root_node, path);
if (filenode) return filenode->inode_number;
else return -1;
if (filenode)
return filenode->inode_number;
else
return -1;
}
bool FilesOperation::permission_check(int mask, INode_Data *inode) {
@ -234,8 +237,7 @@ bool FilesOperation::permission_check(int mask, INode_Data *inode) {
return false; // Permission denied for executing
}
return true;
}
else if(getgid() == gid){
} else if (getgid() == gid) {
if ((mask & R_OK) && !(per & S_IRGRP)) {
return false; // Permission denied for reading
}
@ -248,8 +250,7 @@ bool FilesOperation::permission_check(int mask, INode_Data *inode) {
return false; // Permission denied for executing
}
return true;
}
else{
} else {
if ((mask & R_OK) && !(per & S_IROTH)) {
return false; // Permission denied for reading
}
@ -265,7 +266,8 @@ bool FilesOperation::permission_check(int mask, INode_Data *inode) {
}
}
bool FilesOperation::permission_check_by_inode_num(int mask, u_int64_t inode_num) {
bool FilesOperation::permission_check_by_inode_num(int mask,
u_int64_t inode_num) {
INode_Data inode;
inode.inode_num = inode_num;
@ -302,9 +304,12 @@ int FilesOperation::fischl_mkdir(const char *path, mode_t mode) {
char *ParentPath = pathdup; // pathdup are separated by pathdup, so it take
// <parent path> only
FileNode *parent_filenode = strlen(ParentPath)? fischl_load_entry(root_node, ParentPath): root_node->self_info;
FileNode *parent_filenode = strlen(ParentPath)
? fischl_load_entry(root_node, ParentPath)
: root_node->self_info;
if (parent_filenode == NULL) {
fprintf(stderr,"[%s ,%d] ParentPath:{%s} not found\n",__func__,__LINE__, ParentPath);
fprintf(stderr, "[%s ,%d] ParentPath:{%s} not found\n", __func__, __LINE__,
ParentPath);
free(pathdup);
return -ENOENT; // parentpath directory does not exist
}
@ -313,11 +318,15 @@ int FilesOperation::fischl_mkdir(const char *path, mode_t mode) {
return -EACCES;
}
//printf("%s, %llu, %s\n", parent_filenode->name, parent_inode_number, newDirname);
//make new inode
INode_Data* ret = create_new_inode(parent_inode_number, newDirname, mode|S_IFDIR);//specify S_IFDIR as directory
if (ret == NULL) return -1;//ENOSPC but create_new_inode handle ENAMETOOLONG EEXIST
fischl_add_entry(parent_filenode->subdirectory, ret->inode_num, newDirname, ret);
// printf("%s, %llu, %s\n", parent_filenode->name, parent_inode_number,
// newDirname); make new inode
INode_Data *ret =
create_new_inode(parent_inode_number, newDirname,
mode | S_IFDIR); // specify S_IFDIR as directory
if (ret == NULL)
return -1; // ENOSPC but create_new_inode handle ENAMETOOLONG EEXIST
fischl_add_entry(parent_filenode->subdirectory, ret->inode_num, newDirname,
ret);
free(pathdup);
return 0; // SUCCESS
}
@ -328,13 +337,20 @@ int FilesOperation::fischl_mknod(const char* path, mode_t mode, dev_t dev) {
// check path
char *pathdup = strdup(path);
char *lastSlash = strrchr(pathdup, '/');
*lastSlash = '\0'; // Split the string into parent path and new directory name; <parent path>\0<direcotry name>
char *newFilename = lastSlash+1; //\0<direcotry name>, get from <direcotry name>
char *ParentPath = pathdup;//pathdup are separated by pathdup, so it take <parent path> only
// fprintf(stderr,"[%s ,%d] ParentPath:%s, strlen=%d\n",__func__,__LINE__, ParentPath, strlen(ParentPath));
FileNode *parent_filenode = strlen(ParentPath)? fischl_load_entry(root_node, ParentPath): root_node->self_info;
*lastSlash = '\0'; // Split the string into parent path and new directory
// name; <parent path>\0<direcotry name>
char *newFilename =
lastSlash + 1; //\0<direcotry name>, get from <direcotry name>
char *ParentPath = pathdup; // pathdup are separated by pathdup, so it take
// <parent path> only
// fprintf(stderr,"[%s ,%d] ParentPath:%s, strlen=%d\n",__func__,__LINE__,
// ParentPath, strlen(ParentPath));
FileNode *parent_filenode = strlen(ParentPath)
? fischl_load_entry(root_node, ParentPath)
: root_node->self_info;
if (parent_filenode == NULL) {
fprintf(stderr,"[%s ,%d] ParentPath:{%s} not found\n",__func__,__LINE__, ParentPath);
fprintf(stderr, "[%s ,%d] ParentPath:{%s} not found\n", __func__, __LINE__,
ParentPath);
free(pathdup);
return -1;
}
@ -344,26 +360,36 @@ int FilesOperation::fischl_mknod(const char* path, mode_t mode, dev_t dev) {
}
// make new inode
INode_Data *ret = create_new_inode(parent_inode_number, newFilename, mode);
if (ret == NULL) return -1;//ENOSPC but create_new_inode handle ENAMETOOLONG EEXIST
if (ret == NULL)
return -1; // ENOSPC but create_new_inode handle ENAMETOOLONG EEXIST
// make new node
fischl_add_entry(parent_filenode->subdirectory, ret->inode_num, newFilename, ret);
fischl_add_entry(parent_filenode->subdirectory, ret->inode_num, newFilename,
ret);
free(pathdup);
return 0; // SUCESS
}
/*
regular file
*/
int FilesOperation::fischl_create(const char* path, mode_t mode, struct fuse_file_info* fi) {
int FilesOperation::fischl_create(const char *path, mode_t mode,
struct fuse_file_info *fi) {
// check path
char *pathdup = strdup(path);
char *lastSlash = strrchr(pathdup, '/');
*lastSlash = '\0'; // Split the string into parent path and new directory name; <parent path>\0<direcotry name>
char *newFilename = lastSlash+1; //\0<direcotry name>, get from <direcotry name>
char *ParentPath = pathdup;//pathdup are separated by pathdup, so it take <parent path> only
// fprintf(stderr,"[%s ,%d] ParentPath:%s, strlen=%d\n",__func__,__LINE__, ParentPath, strlen(ParentPath));
FileNode *parent_filenode = strlen(ParentPath)? fischl_load_entry(root_node, ParentPath): root_node->self_info;
*lastSlash = '\0'; // Split the string into parent path and new directory
// name; <parent path>\0<direcotry name>
char *newFilename =
lastSlash + 1; //\0<direcotry name>, get from <direcotry name>
char *ParentPath = pathdup; // pathdup are separated by pathdup, so it take
// <parent path> only
// fprintf(stderr,"[%s ,%d] ParentPath:%s, strlen=%d\n",__func__,__LINE__,
// ParentPath, strlen(ParentPath));
FileNode *parent_filenode = strlen(ParentPath)
? fischl_load_entry(root_node, ParentPath)
: root_node->self_info;
if (parent_filenode == NULL) {
fprintf(stderr,"[%s ,%d] ParentPath:{%s} not found\n",__func__,__LINE__, ParentPath);
fprintf(stderr, "[%s ,%d] ParentPath:{%s} not found\n", __func__, __LINE__,
ParentPath);
free(pathdup);
return -1;
}
@ -373,11 +399,14 @@ int FilesOperation::fischl_create(const char* path, mode_t mode, struct fuse_fil
}
// make new inode
INode_Data *ret = create_new_inode(parent_inode_number, newFilename, mode);
if (ret == NULL) return -1;//ENOSPC but create_new_inode handle ENAMETOOLONG EEXIST
if (ret == NULL)
return -1; // ENOSPC but create_new_inode handle ENAMETOOLONG EEXIST
// make new node in RAM
fischl_add_entry(parent_filenode->subdirectory, ret->inode_num, newFilename, ret);
fischl_add_entry(parent_filenode->subdirectory, ret->inode_num, newFilename,
ret);
// directly give inode number rather than create file descriptor table
fi->fh = ret->inode_num;//assign file descriptor as inode number to fuse system
fi->fh =
ret->inode_num; // assign file descriptor as inode number to fuse system
free(pathdup);
return 0; // SUCESS
}
@ -406,7 +435,8 @@ int FilesOperation::fischl_getattr(const char *path, struct stat *stbuf,
stbuf->st_uid = inode.metadata.uid;
stbuf->st_gid = inode.metadata.gid;
stbuf->st_atime = (time_t)(inode.metadata.access_time / 1000000000ULL);
stbuf->st_mtime = (time_t)(inode.metadata.modification_time / 1000000000ULL);
stbuf->st_mtime =
(time_t)(inode.metadata.modification_time / 1000000000ULL);
stbuf->st_size = IO_BLOCK_SIZE;
stbuf->st_ino = inode.inode_num;
} else if (S_ISLNK(inode.metadata.permissions)) {
@ -415,7 +445,8 @@ int FilesOperation::fischl_getattr(const char *path, struct stat *stbuf,
stbuf->st_uid = inode.metadata.uid;
stbuf->st_gid = inode.metadata.gid;
stbuf->st_atime = (time_t)(inode.metadata.access_time / 1000000000ULL);
stbuf->st_mtime = (time_t)(inode.metadata.modification_time / 1000000000ULL);
stbuf->st_mtime =
(time_t)(inode.metadata.modification_time / 1000000000ULL);
stbuf->st_size = inode.metadata.size;
stbuf->st_ino = inode.inode_num;
} else {
@ -423,9 +454,12 @@ int FilesOperation::fischl_getattr(const char *path, struct stat *stbuf,
stbuf->st_nlink = inode.metadata.reference_count;
stbuf->st_uid = inode.metadata.uid;
stbuf->st_gid = inode.metadata.gid;
//printf("GETATTR %llu %llu %llu %o\n", inode.inode_num, inode.metadata.uid, inode.metadata.gid, (mode_t)inode.metadata.permissions);
// printf("GETATTR %llu %llu %llu %o\n", inode.inode_num,
// inode.metadata.uid, inode.metadata.gid,
// (mode_t)inode.metadata.permissions);
stbuf->st_atime = (time_t)(inode.metadata.access_time / 1000000000ULL);
stbuf->st_mtime = (time_t)(inode.metadata.modification_time / 1000000000ULL);
stbuf->st_mtime =
(time_t)(inode.metadata.modification_time / 1000000000ULL);
stbuf->st_size = inode.metadata.size;
stbuf->st_ino = inode.inode_num;
}
@ -466,7 +500,8 @@ int FilesOperation::fischl_readdir(const char *path, void *buf,
return 0;
}
int FilesOperation::fischl_releasedir(const char *path, struct fuse_file_info *fi){
int FilesOperation::fischl_releasedir(const char *path,
struct fuse_file_info *fi) {
if (fischl_load_entry(root_node, path) == NULL)
return -ENOENT;
// do with file descriptor that cannot be used
@ -478,7 +513,8 @@ void FilesOperation::unlink_inode(u_int64_t inode_number) {
INode_Data inode;
inode.inode_num = inode_number;
fs->inode_manager->load_inode(&inode);
if (inode.metadata.reference_count > 1 && (inode.metadata.permissions & S_IFMT) != S_IFDIR){
if (inode.metadata.reference_count > 1 &&
(inode.metadata.permissions & S_IFMT) != S_IFDIR) {
inode.metadata.reference_count -= 1;
fs->inode_manager->save_inode(&inode);
return;
@ -501,7 +537,8 @@ void FilesOperation::unlink_inode(u_int64_t inode_number) {
fs->inode_manager->free_inode(&inode);
}
int FilesOperation::fischl_opendir(const char* path, struct fuse_file_info* fi) {
int FilesOperation::fischl_opendir(const char *path,
struct fuse_file_info *fi) {
u_int64_t fh = namei(path);
@ -547,7 +584,8 @@ int FilesOperation::fischl_rmdir(const char* path) {
return -EACCES;
}
char rw_buffer[IO_BLOCK_SIZE] = {0};
for (u_int64_t idx=0; idx<parent_INode.metadata.size/IO_BLOCK_SIZE; idx++) {
for (u_int64_t idx = 0; idx < parent_INode.metadata.size / IO_BLOCK_SIZE;
idx++) {
fs->read(&parent_INode, rw_buffer, IO_BLOCK_SIZE, idx * IO_BLOCK_SIZE);
DirectoryEntry ent;
for (int i = 0; i <= IO_BLOCK_SIZE - 264; i += 264) {
@ -621,7 +659,6 @@ int FilesOperation::fischl_chown(const char *path, uid_t uid, gid_t gid,
return 0;
}
int FilesOperation::fischl_unlink(const char *path) {
char *pathdup = strdup(path);
@ -650,7 +687,8 @@ int FilesOperation::fischl_unlink(const char* path) {
return -EACCES;
}
char rw_buffer[IO_BLOCK_SIZE] = {0};
for (u_int64_t idx=0; idx<parent_INode.metadata.size/IO_BLOCK_SIZE; idx++) {
for (u_int64_t idx = 0; idx < parent_INode.metadata.size / IO_BLOCK_SIZE;
idx++) {
fs->read(&parent_INode, rw_buffer, IO_BLOCK_SIZE, idx * IO_BLOCK_SIZE);
DirectoryEntry ent;
for (int i = 0; i <= IO_BLOCK_SIZE - 264; i += 264) {
@ -687,8 +725,8 @@ int FilesOperation::fischl_unlink(const char* path) {
}
int FilesOperation::fischl_open(const char *path, struct fuse_file_info *fi) {
/*Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be filtered out / handled by the kernel.
if no files will use create function
/*Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be filtered out / handled by
the kernel. if no files will use create function
*/
FileNode *get_file;
if ((get_file = fischl_load_entry(root_node, path)) == NULL)
@ -715,15 +753,16 @@ int FilesOperation::fischl_open(const char *path, struct fuse_file_info *fi){
}
}
//if need to do with flag fi->flags ((fi->flags & O_ACCMODE)). Initial setting ALL access
//create function will handle file descriptor fi->fh
// if need to do with flag fi->flags ((fi->flags & O_ACCMODE)). Initial
// setting ALL access create function will handle file descriptor fi->fh
fi->fh = get_file->inode_number;
return 0; // SUCESS
}
int FilesOperation::fischl_release(const char *path, struct fuse_file_info *fi){
/*Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be filtered out / handled by the kernel.
if no files will use create function
int FilesOperation::fischl_release(const char *path,
struct fuse_file_info *fi) {
/*Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be filtered out / handled by
the kernel. if no files will use create function
*/
FileNode *get_file;
if ((get_file = fischl_load_entry(root_node, path)) == NULL)
@ -733,7 +772,8 @@ int FilesOperation::fischl_release(const char *path, struct fuse_file_info *fi){
return 0; // SUCESS
}
int FilesOperation::fischl_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi){
int FilesOperation::fischl_write(const char *path, const char *buf, size_t size,
off_t offset, struct fuse_file_info *fi) {
/** Write data to an open file
*
* Write should return exactly the number of bytes requested
@ -747,14 +787,17 @@ int FilesOperation::fischl_write(const char *path, const char *buf, size_t size,
// FileNode *get_file;
// if((get_file = fischl_load_entry(root_node, path)) == NULL)
// return -ENOENT;
// Caution! this based on content in file are multiple of IO_BLOCK_SIZE, not the exact write size.
// based on current write_datablock API implement, when write_datablock pass with actual size not index this function should be fixed
// Caution! this based on content in file are multiple of IO_BLOCK_SIZE, not
// the exact write size. based on current write_datablock API implement, when
// write_datablock pass with actual size not index this function should be
// fixed
INode_Data inode;
// Assuming inode is correctly initialized here based on 'path'
inode.inode_num = fi->fh;
fs->inode_manager->load_inode(&inode);
//size_t len = (inode.metadata.size/IO_BLOCK_SIZE) * IO_BLOCK_SIZE; // Assuming each block is 4096 bytes
// size_t len = (inode.metadata.size/IO_BLOCK_SIZE) * IO_BLOCK_SIZE; //
// Assuming each block is 4096 bytes
// Determine the length of the buffer
// Allocate memory for the new buffer
char *buffer = (char *)malloc(size);
@ -764,16 +807,19 @@ int FilesOperation::fischl_write(const char *path, const char *buf, size_t size,
size_t block_offset = offset % IO_BLOCK_SIZE; // Offset within the first block
while (bytes_write < size) {
char block_buffer[IO_BLOCK_SIZE]; // Temporary buffer for each block
size_t copy_size = std::min(size - bytes_write, IO_BLOCK_SIZE - block_offset);
memcpy(block_buffer + block_offset, buf + bytes_write, copy_size);
fs->write(&inode, block_buffer, IO_BLOCK_SIZE, block_index*IO_BLOCK_SIZE);
// fprintf(stderr,"[%s ,%d] inode.size %d, block_index %d, block_buffer %s\n",__func__,__LINE__, inode.size, block_index, block_buffer);
bytes_write += copy_size;
block_index++;
block_offset = 0; // Only the first block might have a non-zero offset
size_t copy_size = std::min(size - bytes_write, IO_BLOCK_SIZE -
block_offset); memcpy(block_buffer + block_offset, buf + bytes_write,
copy_size); fs->write(&inode, block_buffer, IO_BLOCK_SIZE,
block_index*IO_BLOCK_SIZE);
// fprintf(stderr,"[%s ,%d] inode.size %d, block_index %d, block_buffer
%s\n",__func__,__LINE__, inode.size, block_index, block_buffer); bytes_write
+= copy_size; block_index++; block_offset = 0; // Only the first block might
have a non-zero offset
}*/
fs->inode_manager->save_inode(&inode);
free(buffer);
if (bytes_write < 0)
return -errno;
return bytes_write; // Return the actual number of bytes read
}
@ -810,13 +856,20 @@ int FilesOperation::fischl_symlink(const char* to, const char* from){
// printf("SYMLINK %s %s\n", from, to);
char *pathdup = strdup(from);
char *lastSlash = strrchr(pathdup, '/');
*lastSlash = '\0'; // Split the string into parent path and new directory name; <parent path>\0<direcotry name>
char *newFilename = lastSlash+1; //\0<direcotry name>, get from <direcotry name>
char *ParentPath = pathdup;//pathdup are separated by pathdup, so it take <parent path> only
// fprintf(stderr,"[%s ,%d] ParentPath:%s, strlen=%d\n",__func__,__LINE__, ParentPath, strlen(ParentPath));
FileNode *parent_filenode = strlen(ParentPath)? fischl_load_entry(root_node, ParentPath): root_node->self_info;
*lastSlash = '\0'; // Split the string into parent path and new directory
// name; <parent path>\0<direcotry name>
char *newFilename =
lastSlash + 1; //\0<direcotry name>, get from <direcotry name>
char *ParentPath = pathdup; // pathdup are separated by pathdup, so it take
// <parent path> only
// fprintf(stderr,"[%s ,%d] ParentPath:%s, strlen=%d\n",__func__,__LINE__,
// ParentPath, strlen(ParentPath));
FileNode *parent_filenode = strlen(ParentPath)
? fischl_load_entry(root_node, ParentPath)
: root_node->self_info;
if (parent_filenode == NULL) {
fprintf(stderr,"[%s ,%d] ParentPath:{%s} not found\n",__func__,__LINE__, ParentPath);
fprintf(stderr, "[%s ,%d] ParentPath:{%s} not found\n", __func__, __LINE__,
ParentPath);
free(pathdup);
return -ENOENT;
}
@ -825,10 +878,13 @@ int FilesOperation::fischl_symlink(const char* to, const char* from){
return -EACCES;
}
// make new inode
INode_Data* ret = create_new_inode(parent_inode_number, newFilename, S_IFLNK|0777);
if (ret == NULL) return -1;//ENOSPC but create_new_inode handle ENAMETOOLONG EEXIST
INode_Data *ret =
create_new_inode(parent_inode_number, newFilename, S_IFLNK | 0777);
if (ret == NULL)
return -1; // ENOSPC but create_new_inode handle ENAMETOOLONG EEXIST
// make new node in RAM
fischl_add_entry(parent_filenode->subdirectory, ret->inode_num, newFilename, ret);
fischl_add_entry(parent_filenode->subdirectory, ret->inode_num, newFilename,
ret);
size_t size = strlen(to);
char *buffer = (char *)malloc(size);
memcpy(buffer, to, size);
@ -841,7 +897,9 @@ int FilesOperation::fischl_symlink(const char* to, const char* from){
return 0; // SUCESS
}
int FilesOperation::insert_inode_to(u_int64_t parent_inode_number, const char* name, INode_Data *new_inode, bool check_replace) {
int FilesOperation::insert_inode_to(u_int64_t parent_inode_number,
const char *name, INode_Data *new_inode,
bool check_replace) {
// trys to create a file under parent directory
if (strlen(name) >= 256) {
perror("Name too long, cannot create file or directory");
@ -851,7 +909,8 @@ int FilesOperation::insert_inode_to(u_int64_t parent_inode_number, const char* n
inode.inode_num = parent_inode_number;
fs->inode_manager->load_inode(&inode);
if ((inode.metadata.permissions & S_IFMT) != S_IFDIR) {
fprintf(stderr,"[%s ,%d] please create under directory\n",__func__,__LINE__);
fprintf(stderr, "[%s ,%d] please create under directory\n", __func__,
__LINE__);
return -1;
}
@ -865,13 +924,14 @@ int FilesOperation::insert_inode_to(u_int64_t parent_inode_number, const char* n
if (strcmp(ent.file_name, name) == 0 && ent.inode_number != 0) {
if (check_replace) {
if ((new_inode->metadata.permissions & S_IFMT) == S_IFDIR) {
fprintf(stderr,"[%s ,%d] %s/ already exists\n",__func__,__LINE__, name);
fprintf(stderr, "[%s ,%d] %s/ already exists\n", __func__, __LINE__,
name);
} else {
fprintf(stderr,"[%s ,%d] %s already exists\n",__func__,__LINE__, name);
fprintf(stderr, "[%s ,%d] %s already exists\n", __func__, __LINE__,
name);
}
return -1;
}
else{
} else {
// printf("RENAME HAPPENS %s %s\n", );
ent.inode_number = new_inode->inode_num;
ent.serialize(r_buffer + i);
@ -930,13 +990,20 @@ int FilesOperation::fischl_link(const char* from, const char* to){
// check path
char *pathdup = strdup(to);
char *lastSlash = strrchr(pathdup, '/');
*lastSlash = '\0'; // Split the string into parent path and new directory name; <parent path>\0<direcotry name>
char *newFilename = lastSlash+1; //\0<direcotry name>, get from <direcotry name>
char *ParentPath = pathdup;//pathdup are separated by pathdup, so it take <parent path> only
// fprintf(stderr,"[%s ,%d] ParentPath:%s, strlen=%d\n",__func__,__LINE__, ParentPath, strlen(ParentPath));
FileNode *parent_filenode = strlen(ParentPath)? fischl_load_entry(root_node, ParentPath): root_node->self_info;
*lastSlash = '\0'; // Split the string into parent path and new directory
// name; <parent path>\0<direcotry name>
char *newFilename =
lastSlash + 1; //\0<direcotry name>, get from <direcotry name>
char *ParentPath = pathdup; // pathdup are separated by pathdup, so it take
// <parent path> only
// fprintf(stderr,"[%s ,%d] ParentPath:%s, strlen=%d\n",__func__,__LINE__,
// ParentPath, strlen(ParentPath));
FileNode *parent_filenode = strlen(ParentPath)
? fischl_load_entry(root_node, ParentPath)
: root_node->self_info;
if (parent_filenode == NULL) {
fprintf(stderr,"[%s ,%d] ParentPath:{%s} not found\n",__func__,__LINE__, ParentPath);
fprintf(stderr, "[%s ,%d] ParentPath:{%s} not found\n", __func__, __LINE__,
ParentPath);
free(pathdup);
return -1;
}
@ -951,14 +1018,15 @@ int FilesOperation::fischl_link(const char* from, const char* to){
ret.metadata.reference_count += 1;
fs->inode_manager->save_inode(&ret);
fischl_add_entry(parent_filenode->subdirectory, ret.inode_num, newFilename, &ret);
fischl_add_entry(parent_filenode->subdirectory, ret.inode_num, newFilename,
&ret);
free(pathdup);
return 0;
}
// TODO: rename dir and rename fail
int FilesOperation::fischl_rename(const char *old_path, const char *new_path, unsigned int flags){
int FilesOperation::fischl_rename(const char *old_path, const char *new_path,
unsigned int flags) {
// find old path
char *pathdup = strdup(old_path);
char *lastSlash = strrchr(pathdup, '/');
@ -974,10 +1042,14 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
rename_info.exchangeExist = false;
rename_info.oldParentNode = fischl_load_entry(root_node, oldParentPath);
// if path end with / means to rename directory
rename_info.oldFileNode = strlen(filename)? fischl_load_entry(rename_info.oldParentNode->subdirectory, filename):rename_info.oldParentNode;
rename_info.oldFileNode =
strlen(filename)
? fischl_load_entry(rename_info.oldParentNode->subdirectory, filename)
: rename_info.oldParentNode;
if (rename_info.oldFileNode == NULL) {
fprintf(stderr,"[%s ,%d] path %s not found by fischl_load_entry\n",__func__,__LINE__, old_path);
fprintf(stderr, "[%s ,%d] path %s not found by fischl_load_entry\n",
__func__, __LINE__, old_path);
free(pathdup);
return -ENOENT;
}
@ -985,23 +1057,33 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
// find new path
char *new_pathdup = strdup(new_path);
lastSlash = strrchr(new_pathdup, '/');
*lastSlash = '\0'; // Split the string into parent path and new directory name; <parent path>\0<direcotry name>
char *newParentPath = new_pathdup;//pathdup are separated by pathdup, so it take <parent path> only
*lastSlash = '\0'; // Split the string into parent path and new directory
// name; <parent path>\0<direcotry name>
char *newParentPath = new_pathdup; // pathdup are separated by pathdup, so it
// take <parent path> only
// put new path info in rename struct
rename_info.newName = lastSlash+1; //\0<direcotry name>, get from <direcotry name>
rename_info.newName =
lastSlash + 1; //\0<direcotry name>, get from <direcotry name>
rename_info.newFileNode = fischl_load_entry(root_node, new_path);
rename_info.newParentNode = strlen(newParentPath)? fischl_load_entry(root_node, newParentPath): root_node->self_info;
rename_info.newParentNode = strlen(newParentPath)
? fischl_load_entry(root_node, newParentPath)
: root_node->self_info;
if(!permission_check_by_inode_num(W_OK, rename_info.oldParentNode->inode_number)){
if (!permission_check_by_inode_num(W_OK,
rename_info.oldParentNode->inode_number)) {
return -EACCES;
}
if(!permission_check_by_inode_num(W_OK, rename_info.newParentNode->inode_number)){
if (!permission_check_by_inode_num(W_OK,
rename_info.newParentNode->inode_number)) {
return -EACCES;
}
if(!permission_check_by_inode_num(W_OK, rename_info.oldFileNode->inode_number)){
if (!permission_check_by_inode_num(W_OK,
rename_info.oldFileNode->inode_number)) {
return -EACCES;
}
if(rename_info.newFileNode != NULL && !permission_check_by_inode_num(W_OK, rename_info.newFileNode->inode_number)){
if (rename_info.newFileNode != NULL &&
!permission_check_by_inode_num(W_OK,
rename_info.newFileNode->inode_number)) {
return -EACCES;
}
@ -1009,7 +1091,8 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
if (flags & RENAME_NOREPLACE) {
// Check if newpath exists and return error if it does
if (rename_info.newFileNode != NULL) {
fprintf(stderr,"[%s ,%d] newpath has already existed\n",__func__,__LINE__);
fprintf(stderr, "[%s ,%d] newpath has already existed\n", __func__,
__LINE__);
free(new_pathdup); // new path
free(pathdup); // old path
return -1;
@ -1019,7 +1102,8 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
if (flags & RENAME_EXCHANGE) {
// Ensure both oldpath and newpath exist and exchange them atomically
if (rename_info.newFileNode == NULL) {
fprintf(stderr,"[%s ,%d] newpath does not exist cannot exchange\n",__func__,__LINE__);
fprintf(stderr, "[%s ,%d] newpath does not exist cannot exchange\n",
__func__, __LINE__);
free(new_pathdup);
free(pathdup);
return -1;
@ -1032,7 +1116,8 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
bool change_flag = false;
// delete record on old path
for (u_int64_t idx=0; idx<parent_INode.metadata.size/IO_BLOCK_SIZE; idx++) {
for (u_int64_t idx = 0; idx < parent_INode.metadata.size / IO_BLOCK_SIZE;
idx++) {
fs->read(&parent_INode, rw_buffer, IO_BLOCK_SIZE, idx * IO_BLOCK_SIZE);
DirectoryEntry ent;
for (int i = 0; i <= IO_BLOCK_SIZE - 264; i += 264) {
@ -1056,14 +1141,16 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
change_flag = false;
// delete record on old path
for (u_int64_t idx=0; idx<parent_INode.metadata.size/IO_BLOCK_SIZE; idx++) {
for (u_int64_t idx = 0; idx < parent_INode.metadata.size / IO_BLOCK_SIZE;
idx++) {
fs->read(&parent_INode, rw_buffer, IO_BLOCK_SIZE, idx * IO_BLOCK_SIZE);
DirectoryEntry ent;
for (int i = 0; i <= IO_BLOCK_SIZE - 264; i += 264) {
ent.deserialize(rw_buffer + i);
if (ent.inode_number == rename_info.oldFileNode->inode_number) {
change_flag = true; // should be change
strncpy(ent.file_name, rename_info.newName, sizeof(ent.file_name) - 1);
strncpy(ent.file_name, rename_info.newName,
sizeof(ent.file_name) - 1);
ent.file_name[sizeof(ent.file_name) - 1] = '\0';
ent.serialize(rw_buffer + i);
break;
@ -1076,7 +1163,8 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
}
}
fischl_rm_entry(rename_info.oldParentNode->subdirectory, filename);
fischl_rm_entry(rename_info.newParentNode->subdirectory, rename_info.newName);
fischl_rm_entry(rename_info.newParentNode->subdirectory,
rename_info.newName);
return 0;
}
@ -1084,7 +1172,6 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
// Hard Disk rename
if (rename_info.oldFileNode->subdirectory != NULL) { // secure its directory
// remove its record from subdirectory; find .. from subdirectory
}
// remove its record from parent
INode_Data parent_INode;
@ -1096,12 +1183,14 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
INode_Data ret;
ret.inode_num = rename_info.oldFileNode->inode_number;
fs->inode_manager->load_inode(&ret);
if(insert_inode_to(rename_info.newParentNode->inode_number, rename_info.newName, &ret, false)<0){
if (insert_inode_to(rename_info.newParentNode->inode_number,
rename_info.newName, &ret, false) < 0) {
return -1;
}
bool change_flag = false;
// delete record on old path
for (u_int64_t idx=0; idx<parent_INode.metadata.size/IO_BLOCK_SIZE; idx++) {
for (u_int64_t idx = 0; idx < parent_INode.metadata.size / IO_BLOCK_SIZE;
idx++) {
fs->read(&parent_INode, rw_buffer, IO_BLOCK_SIZE, idx * IO_BLOCK_SIZE);
DirectoryEntry ent;
for (int i = 0; i <= IO_BLOCK_SIZE - 264; i += 264) {
@ -1121,7 +1210,8 @@ int FilesOperation::fischl_rename(const char *old_path, const char *new_path, un
}
}
if (rename_info.newParentNode != NULL) {
fischl_rm_entry(rename_info.newParentNode->subdirectory, rename_info.newName);
fischl_rm_entry(rename_info.newParentNode->subdirectory,
rename_info.newName);
}
fischl_rm_entry(rename_info.oldParentNode->subdirectory, filename);
@ -1149,6 +1239,8 @@ int FilesOperation::fischl_truncate(const char *path, off_t offset,
}
res = fs->truncate(&inode, offset);
fs->inode_manager->save_inode(&inode);
if (res < 0)
return -errno;
return res;
}
@ -1171,7 +1263,8 @@ int FilesOperation::fischl_read(const char *path, char *buf, size_t size,
// Assuming inode is correctly initialized here based on 'path'
inode.inode_num = fi->fh;
fs->inode_manager->load_inode(&inode);
//printf("OUT READ %llu %llu %llu\n", inode.inode_num, inode.single_indirect_block, inode.double_indirect_block);
// printf("OUT READ %llu %llu %llu\n", inode.inode_num,
// inode.single_indirect_block, inode.double_indirect_block);
ssize_t bytes_read = fs->read(&inode, buf, size, offset);
// printf("BYTES_READ %d\n",int(bytes_read));
// for (int i = 0; i < bytes_read; i++)printf("%x", buf[i]&0xff);
@ -1199,10 +1292,15 @@ int FilesOperation::fischl_read(const char *path, char *buf, size_t size,
buf, block_buffer); bytes_read += copy_size; block_index++; block_offset = 0;
// Only the first block might have a non-zero offset
}*/
if (bytes_read < 0)
return -errno;
return bytes_read; // Return the actual number of bytes read
}
int FilesOperation::fischl_utimens(const char *path, const struct timespec tv[2], struct fuse_file_info *fi){
int FilesOperation::fischl_utimens(const char *path,
const struct timespec tv[2],
struct fuse_file_info *fi) {
(void)fi;
int res = 0;
u_int64_t fh = namei(path);
@ -1214,8 +1312,10 @@ int FilesOperation::fischl_utimens(const char *path, const struct timespec tv[2]
INode_Data inode;
inode.inode_num = fh;
fs->inode_manager->load_inode(&inode);
inode.metadata.access_time = (u_int64_t)tv[0].tv_sec * 1000000000ULL + tv[0].tv_nsec;
inode.metadata.modification_time = (u_int64_t)tv[1].tv_sec * 1000000000ULL + tv[1].tv_nsec;
inode.metadata.access_time =
(u_int64_t)tv[0].tv_sec * 1000000000ULL + tv[0].tv_nsec;
inode.metadata.modification_time =
(u_int64_t)tv[1].tv_sec * 1000000000ULL + tv[1].tv_nsec;
fs->inode_manager->save_inode(&inode);
return 0;
}

8
lib/fs/datablock_manager.cpp
View File

@ -52,8 +52,10 @@ int DataBlock_Manager_Bitmap::new_datablock(u_int64_t *block_num) {
char zero_buf[IO_BLOCK_SIZE] = {0};
if (bitmap_block_num < block_segment_start ||
bitmap_block_num >= block_segment_end)
bitmap_block_num >= block_segment_end) {
perror("Error with new_datablock freelist head\n");
return -1;
}
if ((err = fs->disk->read_block(bitmap_block_num, bitmap.buf)) < 0)
return err;
@ -64,8 +66,10 @@ int DataBlock_Manager_Bitmap::new_datablock(u_int64_t *block_num) {
u_int64_t relative_block_num = bitmap.claim_relative_block();
if (relative_block_num == 0)
if (relative_block_num == 0) {
errno = ENOSPC;
return -1;
}
u_int64_t block_num_ = relative_block_num + bitmap_block_num;

53
lib/fs/fs_file_io.cpp
View File

@ -31,7 +31,8 @@ int Fs::sweep_inode_datablocks(INode_Data *inode_data,
DatablockOperation *op) {
int result;
//printf("SWEEP %llu %llu %llu\n", inode_data->inode_num, inode_data->single_indirect_block, inode_data->double_indirect_block);
// printf("SWEEP %llu %llu %llu\n", inode_data->inode_num,
// inode_data->single_indirect_block, inode_data->double_indirect_block);
u_int64_t start_index = start_block_index;
for (size_t i = start_index; i < NUMBER_OF_DIRECT_BLOCKS; ++i) {
@ -96,7 +97,8 @@ int Fs::sweep_datablocks(u_int64_t *block_num, int indirect_num,
}
}
//if((*block_num)>30000000000000LL)printf("DIES 1 %llu %d %llu\n", *block_num, indirect_num, start_block_index);
// if((*block_num)>30000000000000LL)printf("DIES 1 %llu %d %llu\n",
// *block_num, indirect_num, start_block_index);
if (indirect_num == 0) {
bool delete_block = false;
@ -175,7 +177,8 @@ public:
std::min(IO_BLOCK_SIZE - offset, count - bytes_completed);
if (block_num != 0) {
if((block_num)>3000000000000LL)printf("DIES 2\n");
if ((block_num) > 3000000000000LL)
printf("DIES 2\n");
if ((err = fs->disk->read_block(block_num, datablock_buf)) < 0)
return err;
@ -205,7 +208,8 @@ public:
std::min(IO_BLOCK_SIZE - offset, count - bytes_completed);
if (write_size < IO_BLOCK_SIZE) {
if((block_num)>3000000000000LL)printf("DIES 3\n");
if ((block_num) > 3000000000000LL)
printf("DIES 3\n");
if ((err = fs->disk->read_block(block_num, datablock_buf)) < 0)
return err;
}
@ -235,7 +239,8 @@ public:
(*delete_block) = true;
return 1;
}
if((block_num)>3000000000000LL)printf("DIES 4\n");
if ((block_num) > 3000000000000LL)
printf("DIES 4\n");
if ((err = fs->disk->read_block(block_num, datablock_buf)) < 0)
return err;
@ -289,9 +294,10 @@ ssize_t Fs::read(INode_Data *inode_data, char buf[], size_t count,
op.bytes_completed = 0;
op.fs = this;
//printf("IN READ %llu %llu %llu\n", inode_data->inode_num, inode_data->single_indirect_block, inode_data->double_indirect_block);
// printf("IN READ %llu %llu %llu\n", inode_data->inode_num,
// inode_data->single_indirect_block, inode_data->double_indirect_block);
if ((err = sweep_inode_datablocks(inode_data, start_block_index, false,
&op)) != 0)
&op)) < 0)
return err;
return op.bytes_completed;
@ -301,6 +307,11 @@ ssize_t Fs::write(INode_Data *inode_data, const char buf[], size_t count,
size_t offset) {
int err;
if (count + offset > FILE_SIZE_MAX) {
errno = EFBIG;
return -1;
}
u_int64_t start_block_index = offset / IO_BLOCK_SIZE;
size_t internal_offset = offset - (start_block_index * IO_BLOCK_SIZE);
@ -311,8 +322,8 @@ ssize_t Fs::write(INode_Data *inode_data, const char buf[], size_t count,
op.bytes_completed = 0;
op.fs = this;
if ((err = sweep_inode_datablocks(inode_data, start_block_index, true,
&op)) != 0)
if ((err = sweep_inode_datablocks(inode_data, start_block_index, true, &op)) <
0)
return err;
inode_data->metadata.size =
@ -321,9 +332,19 @@ ssize_t Fs::write(INode_Data *inode_data, const char buf[], size_t count,
return op.bytes_completed;
}
int Fs::truncate(INode_Data *inode_data, size_t length) {
int Fs::truncate(INode_Data *inode_data, off_t length) {
int err;
if (length > FILE_SIZE_MAX) {
errno = EFBIG;
return -1;
}
if (length < 0) {
errno = EINVAL;
return -1;
}
u_int64_t start_block_index = length / IO_BLOCK_SIZE;
size_t internal_offset = length - (start_block_index * IO_BLOCK_SIZE);
@ -343,8 +364,10 @@ int Fs::truncate(INode_Data *inode_data, size_t length) {
ssize_t Fs::lseek_next_data(INode_Data *inode_data, size_t offset) {
int err;
if (offset >= inode_data->metadata.size)
if (offset >= inode_data->metadata.size) {
errno = ENXIO;
return -1;
}
u_int64_t start_block_index = offset / IO_BLOCK_SIZE;
size_t internal_offset = offset - (start_block_index * IO_BLOCK_SIZE);
@ -359,8 +382,10 @@ ssize_t Fs::lseek_next_data(INode_Data *inode_data, size_t offset) {
&op)) < 0)
return err;
if (op.bytes_completed >= inode_data->metadata.size)
if (op.bytes_completed >= inode_data->metadata.size) {
errno = ENXIO;
return -1;
}
return op.bytes_completed;
}
@ -368,8 +393,10 @@ ssize_t Fs::lseek_next_data(INode_Data *inode_data, size_t offset) {
ssize_t Fs::lseek_next_hole(INode_Data *inode_data, size_t offset) {
int err;
if (offset >= inode_data->metadata.size)
if (offset >= inode_data->metadata.size) {
errno = ENXIO;
return -1;
}
u_int64_t start_block_index = offset / IO_BLOCK_SIZE;
size_t internal_offset = offset - (start_block_index * IO_BLOCK_SIZE);

6
lib/rawdisk.cpp
View File

@ -65,6 +65,7 @@ int RealRawDisk::read_block(u_int64_t block_number, char *buffer) {
if (lseek(fd, offset, SEEK_SET) == (u_int64_t)-1) {
printf("LSEEK ERROR %llu %llu\n", block_number, offset);
perror("Error seeking to offset");
errno = EIO;
return -1;
}
@ -75,6 +76,7 @@ int RealRawDisk::read_block(u_int64_t block_number, char *buffer) {
// printf("\n");
if (bytesRead < IO_BLOCK_SIZE) {
perror("Error reading from device");
errno = EIO;
return -1;
}
@ -86,6 +88,7 @@ int RealRawDisk::write_block(u_int64_t block_number, char *buffer) {
if (lseek(fd, offset, SEEK_SET) == (u_int64_t)-1) {
perror("Error seeking to offset");
errno = EIO;
return -1;
}
@ -93,6 +96,7 @@ int RealRawDisk::write_block(u_int64_t block_number, char *buffer) {
ssize_t bytesWritten = write(fd, buffer, IO_BLOCK_SIZE);
if (bytesWritten < IO_BLOCK_SIZE) {
perror("Error writing to device");
errno = EIO;
return -1;
}
@ -118,6 +122,7 @@ int FakeRawDisk::read_block(u_int64_t block_number, char *buffer) {
if (offset + IO_BLOCK_SIZE > diskSize) {
perror("Error reading past fake disk size");
errno = EIO;
return -1;
}
@ -131,6 +136,7 @@ int FakeRawDisk::write_block(u_int64_t block_number, char *buffer) {
if (offset + IO_BLOCK_SIZE > diskSize) {
perror("Error writing past fake disk size");
errno = EIO;
return -1;
}