BUG FIXES

rushitjasani · rushitjasani · commit 594ded15fecb · 2018-11-29T11:40:49.000+05:30
diff --git a/file_operation.cpp b/file_operation.cpp
@@ -105,7 +105,7 @@ int create_file(char *name)
 {
     string filename = string(name);
     //check if file already exist in disk
-    if (dir_map.find(filename) != dir_map.end())
+    if (file_to_inode_map.find(filename) != file_to_inode_map.end())
     {
         cout << string(RED) << "Create File Error : File already present !!!" << string(DEFAULT) << endl;
         return -1;
@@ -135,7 +135,7 @@ int create_file(char *name)
     inode_arr[next_avl_inode].pointer[0] = next_avl_datablock;
     inode_arr[next_avl_inode].filesize = 0;
 
-    dir_map[filename] = next_avl_inode;
+    file_to_inode_map[filename] = next_avl_inode;
     inode_to_file_map[next_avl_inode] = filename;
 
     file_inode_mapping_arr[next_avl_inode].inode_num = next_avl_inode;
@@ -150,14 +150,14 @@ int delete_file(char *name)
     string filename = string(name);
 
     //check if file exist or not
-    if (dir_map.find(filename) == dir_map.end())
+    if (file_to_inode_map.find(filename) == file_to_inode_map.end())
     {
         cout << string(RED) << "Delete File Error : File doesn't exist !!!" << string(DEFAULT) << endl;
         return -1;
     }
 
     //getting inode of file
-    int cur_inode = dir_map[filename];
+    int cur_inode = file_to_inode_map[filename];
 
     for (int i = 0; i < NO_OF_FILE_DESCRIPTORS; i++)
     {
@@ -175,8 +175,8 @@ int delete_file(char *name)
     strcpy(file_inode_mapping_arr[cur_inode].file_name, emptyname);
     file_inode_mapping_arr[cur_inode].inode_num = -1;
 
-    inode_to_file_map.erase(dir_map[filename]);
-    dir_map.erase(filename);
+    inode_to_file_map.erase(file_to_inode_map[filename]);
+    file_to_inode_map.erase(filename);
 
     cout << string(GREEN) << "File Deleted successfully :) " << string(DEFAULT) << endl;
 
@@ -186,7 +186,7 @@ int delete_file(char *name)
 int open_file(char *name)
 {
     string filename = string(name);
-    if (dir_map.find(filename) == dir_map.end())
+    if (file_to_inode_map.find(filename) == file_to_inode_map.end())
     {
         cout << string(RED) << "Open File Error : File not found !!!" << string(DEFAULT) << endl;
         return -1;
@@ -209,7 +209,7 @@ int open_file(char *name)
         }
     } while (file_mode < 0 || file_mode > 2);
 
-    int cur_inode = dir_map[filename];
+    int cur_inode = file_to_inode_map[filename];
 
     /* checking if file is already open in write or append mode. */
     if (file_mode == 1 || file_mode == 2)
diff --git a/file_read_write.cpp b/file_read_write.cpp
@@ -17,30 +17,6 @@ string user_input()
     return s;
 }
 
-int _block_write(int block, char *buf, int size, int start_position)
-{
-
-    if ((block < 0) || (block >= DISK_BLOCKS))
-    {
-        fprintf(stderr, "block_write: block index out of bounds\n");
-        return -1;
-    }
-
-    if (fseek(diskptr, (block * BLOCK_SIZE) + start_position, SEEK_SET) < 0)
-    {
-        perror("block_write: failed to lseek");
-        return -1;
-    }
-
-    if (fwrite(buf, sizeof(char), size, diskptr) < 0)
-    {
-        perror("block_write: failed to write");
-        return -1;
-    }
-
-    return 0;
-}
-
 int _write_into_file(int fd, char *buff, int len, int *bytes_written)
 {
 
@@ -55,7 +31,7 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
         if (filled_data_block < 10)
         {
             int data_block_to_write = inode_arr[file_inode].pointer[filled_data_block];
-            _block_write(data_block_to_write, buff, len, cur_pos % BLOCK_SIZE);
+            block_write(data_block_to_write, buff, len, cur_pos % BLOCK_SIZE);
             inode_arr[file_inode].filesize += len;
             file_descriptor_map[fd].second += len; //updating the cur pos in the file
             *bytes_written += len;
@@ -70,7 +46,7 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
             memcpy(block_pointers, read_buf, sizeof(read_buf));
 
             int data_block_to_write = block_pointers[filled_data_block - 10];
-            _block_write(data_block_to_write, buff, len, cur_pos % BLOCK_SIZE);
+            block_write(data_block_to_write, buff, len, cur_pos % BLOCK_SIZE);
             inode_arr[file_inode].filesize += len;
             file_descriptor_map[fd].second += len; //updating the cur pos in the file
             *bytes_written += len;
@@ -90,7 +66,7 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
             memcpy(block_pointers2, read_buf, sizeof(read_buf));
 
             int data_block_to_write = block_pointers[(filled_data_block - 1034) / 1024];
-            _block_write(data_block_to_write, buff, len, cur_pos % BLOCK_SIZE);
+            block_write(data_block_to_write, buff, len, cur_pos % BLOCK_SIZE);
             inode_arr[file_inode].filesize += len;
             file_descriptor_map[fd].second += len; //updating the cur pos in the file
             *bytes_written += len;
@@ -102,7 +78,7 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
         /* if filesize = 0 means file is empty then start writting into file from first direct block. */
         if (inode_arr[file_descriptor_map[fd].first].filesize == 0)
         {
-            _block_write(inode_arr[file_inode].pointer[0], buff, len, 0);
+            block_write(inode_arr[file_inode].pointer[0], buff, len, 0);
             inode_arr[file_inode].filesize += len;
             file_descriptor_map[fd].second += len;
             *bytes_written += len;
@@ -126,7 +102,7 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
                     free_data_block_vector.pop_back();
                     inode_arr[file_inode].pointer[0] = next_avl_datablock;
                 }
-                _block_write(inode_arr[file_inode].pointer[0], buff, len, 0);
+                block_write(inode_arr[file_inode].pointer[0], buff, len, 0);
                 inode_arr[file_inode].filesize += len;
                 file_descriptor_map[fd].second += len;
                 *bytes_written += len;
@@ -145,7 +121,7 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
                     free_data_block_vector.pop_back();
                     inode_arr[file_inode].pointer[filled_data_block] = data_block_to_write;
 
-                    _block_write(data_block_to_write, buff, len, cur_pos % BLOCK_SIZE);
+                    block_write(data_block_to_write, buff, len, cur_pos % BLOCK_SIZE);
                     inode_arr[file_inode].filesize += len;
                     file_descriptor_map[fd].second += len; //updating the cur pos in the file
                     *bytes_written += len;
@@ -172,7 +148,7 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
                         char temp_buf[BLOCK_SIZE];
                         memcpy(temp_buf, block_pointers, BLOCK_SIZE);
 
-                        _block_write(data_block_single_indirect, temp_buf, BLOCK_SIZE, 0);
+                        block_write(data_block_single_indirect, temp_buf, BLOCK_SIZE, 0);
                     }
 
                     int block = inode_arr[file_inode].pointer[10];
@@ -194,10 +170,10 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
                     block_pointers[filled_data_block - 10] = data_block_to_write;
                     char temp_buf[BLOCK_SIZE];
                     memcpy(temp_buf, block_pointers, BLOCK_SIZE);
-                    _block_write(block, temp_buf, BLOCK_SIZE, 0);
+                    block_write(block, temp_buf, BLOCK_SIZE, 0);
 
                     //write data into DB
-                    _block_write(data_block_to_write, buff, len, 0);
+                    block_write(data_block_to_write, buff, len, 0);
                     inode_arr[file_inode].filesize += len;
                     file_descriptor_map[fd].second += len; //updating the cur pos in the file
                     *bytes_written += len;
@@ -223,7 +199,7 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
                         char temp_buf[BLOCK_SIZE];
                         memcpy(temp_buf, block_pointers, BLOCK_SIZE);
 
-                        _block_write(data_block_double_indirect, temp_buf, BLOCK_SIZE, 0);
+                        block_write(data_block_double_indirect, temp_buf, BLOCK_SIZE, 0);
                     }
                     if ((filled_data_block - 1034) % 1024 == 0) //i.e if filled_data_block is multiple of 1024 means need new DB to be assigned
                     {
@@ -248,10 +224,10 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
                         block_pointers[(filled_data_block - 1034) / 1024] = data_block_double_indirect2;
                         char temp_buf[BLOCK_SIZE];
                         memcpy(temp_buf, block_pointers2, BLOCK_SIZE);
-                        _block_write(data_block_double_indirect2, temp_buf, BLOCK_SIZE, 0);
+                        block_write(data_block_double_indirect2, temp_buf, BLOCK_SIZE, 0);
 
                         memcpy(temp_buf, block_pointers, BLOCK_SIZE);
-                        _block_write(block, temp_buf, BLOCK_SIZE, 0);
+                        block_write(block, temp_buf, BLOCK_SIZE, 0);
                     }
 
                     int block = inode_arr[file_inode].pointer[11];
@@ -275,12 +251,12 @@ int _write_into_file(int fd, char *buff, int len, int *bytes_written)
                     int data_block_to_write = free_data_block_vector.back(); //to store block_pointers[1024] into db_for_double_indirect
                     free_data_block_vector.pop_back();
                     block_pointers2[(filled_data_block - 1034) % 1024] = data_block_to_write;
-                    _block_write(data_block_to_write, buff, len, 0); //writing data into db_to_write DB
+                    block_write(data_block_to_write, buff, len, 0); //writing data into db_to_write DB
 
                     //now restore block_pointers2 back to the block2
                     char temp_buf[BLOCK_SIZE];
                     memcpy(temp_buf, block_pointers2, BLOCK_SIZE);
-                    _block_write(block2, temp_buf, BLOCK_SIZE, 0);
+                    block_write(block2, temp_buf, BLOCK_SIZE, 0);
 
                     //updating the filesize
                     inode_arr[file_inode].filesize += len;
diff --git a/inode.cpp b/inode.cpp
@@ -8,7 +8,7 @@ struct super_block sb;
 struct file_to_inode_mapping file_inode_mapping_arr[NO_OF_INODES];
 struct inode inode_arr[NO_OF_INODES];
 
-map<string, int> dir_map;                     //file name as key maps to inode (value)
+map<string, int> file_to_inode_map;           //file name as key maps to inode (value)
 vector<int> free_inode_vector;                //denote free inodes
 vector<int> free_data_block_vector;           //denote free data blocks
 vector<int> free_filedescriptor_vector;       //denote free filedescriptor.
@@ -152,7 +152,7 @@ int mount_disk(char *name)
     for (int i = NO_OF_INODES - 1; i >= 0; --i)
         if (sb.inode_freelist[i] == true)
         {
-            dir_map[string(file_inode_mapping_arr[i].file_name)] = file_inode_mapping_arr[i].inode_num;
+            file_to_inode_map[string(file_inode_mapping_arr[i].file_name)] = file_inode_mapping_arr[i].inode_num;
             inode_to_file_map[file_inode_mapping_arr[i].inode_num] = string(file_inode_mapping_arr[i].file_name);
         }
         else
@@ -236,7 +236,7 @@ int unmount_disk()
     free_filedescriptor_vector.clear();
     file_descriptor_mode_map.clear();
     file_descriptor_map.clear();
-    dir_map.clear();
+    file_to_inode_map.clear();
     inode_to_file_map.clear();
 
     cout << string(GREEN) << "Disk Unmounted!!!" << string(DEFAULT) << endl;
@@ -280,43 +280,33 @@ int block_read(int block, char *buf)
     return 0;
 }
 
-int block_write(int block, char *buf)
+int block_write(int block, char *buf, int size, int start_position)
 {
-    cout << string(RED);
-    if (!active)
-    {
-        fprintf(stderr, "block_write: disk not active\n");
-        cout << string(DEFAULT);
-        return -1;
-    }
 
     if ((block < 0) || (block >= DISK_BLOCKS))
     {
         fprintf(stderr, "block_write: block index out of bounds\n");
-        cout << string(DEFAULT);
         return -1;
     }
 
-    if (fseek(diskptr, block * BLOCK_SIZE, SEEK_SET) < 0)
+    if (fseek(diskptr, (block * BLOCK_SIZE) + start_position, SEEK_SET) < 0)
     {
         perror("block_write: failed to lseek");
-        cout << string(DEFAULT);
         return -1;
     }
 
-    if (fwrite(buf, sizeof(char), BLOCK_SIZE, diskptr) < 0)
+    if (fwrite(buf, sizeof(char), size, diskptr) < 0)
     {
         perror("block_write: failed to write");
-        cout << string(DEFAULT);
         return -1;
     }
-    cout << string(DEFAULT);
+
     return 0;
 }
 
 void print_list_open_files()
 {
-    cout << string(BOLD) << "### List of opened files ###" << string(DEFAULT) << endl;
+    cout << string(GREEN) << "List of opened files " << string(DEFAULT) << endl;
     for (auto i : file_descriptor_map)
     {
         int fd = i.first;
@@ -334,8 +324,8 @@ void print_list_open_files()
 
 void print_list_files()
 {
-    cout << string(BOLD) << "### List of All files ###" << string(DEFAULT) << endl;
-    for (auto i : dir_map)
+    cout << string(GREEN) << "List of All files" << string(DEFAULT) << endl;
+    for (auto i : file_to_inode_map)
     {
         cout << i.first << " with inode : " << i.second << endl;
     }
@@ -425,6 +415,7 @@ int user_handle()
         }
     }
 }
+
 int main()
 {
     int choice;
diff --git a/inode.h b/inode.h
@@ -75,7 +75,7 @@ extern struct inode inode_arr[NO_OF_INODES];
 
 extern FILE *diskptr;
 extern int openfile_count;                           // keeps track of number of files opened.
-extern map<string, int> dir_map;                     // filename->inode file name as key maps to inode (value)
+extern map<string, int> file_to_inode_map;           // filename->inode file name as key maps to inode (value)
 extern map<int, string> inode_to_file_map;           // indoe-> filename inode to file mapping
 
 extern vector<int> free_inode_vector;                // denote free inodes
@@ -97,6 +97,8 @@ int unmount_disk();                     /* close a previously opened disk (file)
 int open_file(char *name);              /* open file to get its file descriptor        */
 int close_file(int fd);                 /* close the file                              */
 int block_read(int block, char *buf);   /* read block */
+int block_write(int block, char *buf, 
+        int size, int start_position);  /* Write block */
 int create_file(char *name);            /* to create file */
 int delete_file(char *name);            /* to delete file */
 int write_into_file(int fd, int mode);  /* to write content into file */

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ struct super_block sb;`
`8`	`8`	`struct file_to_inode_mapping file_inode_mapping_arr[NO_OF_INODES];`
`9`	`9`	`struct inode inode_arr[NO_OF_INODES];`
`10`	`10`
`11`		`-map<string, int> dir_map; //file name as key maps to inode (value)`
	`11`	`+map<string, int> file_to_inode_map; //file name as key maps to inode (value)`
`12`	`12`	`vector<int> free_inode_vector; //denote free inodes`
`13`	`13`	`vector<int> free_data_block_vector; //denote free data blocks`
`14`	`14`	`vector<int> free_filedescriptor_vector; //denote free filedescriptor.`
`@@ -152,7 +152,7 @@ int mount_disk(char *name)`
`152`	`152`	`for (int i = NO_OF_INODES - 1; i >= 0; --i)`
`153`	`153`	`if (sb.inode_freelist[i] == true)`
`154`	`154`	`{`
`155`		`- dir_map[string(file_inode_mapping_arr[i].file_name)] = file_inode_mapping_arr[i].inode_num;`
	`155`	`+ file_to_inode_map[string(file_inode_mapping_arr[i].file_name)] = file_inode_mapping_arr[i].inode_num;`
`156`	`156`	`inode_to_file_map[file_inode_mapping_arr[i].inode_num] = string(file_inode_mapping_arr[i].file_name);`
`157`	`157`	`}`
`158`	`158`	`else`
`@@ -236,7 +236,7 @@ int unmount_disk()`
`236`	`236`	`free_filedescriptor_vector.clear();`
`237`	`237`	`file_descriptor_mode_map.clear();`
`238`	`238`	`file_descriptor_map.clear();`
`239`		`- dir_map.clear();`
	`239`	`+ file_to_inode_map.clear();`
`240`	`240`	`inode_to_file_map.clear();`
`241`	`241`
`242`	`242`	`cout << string(GREEN) << "Disk Unmounted!!!" << string(DEFAULT) << endl;`
`@@ -280,43 +280,33 @@ int block_read(int block, char *buf)`
`280`	`280`	`return 0;`
`281`	`281`	`}`
`282`	`282`
`283`		`-int block_write(int block, char *buf)`
	`283`	`+int block_write(int block, char *buf, int size, int start_position)`
`284`	`284`	`{`
`285`		`- cout << string(RED);`
`286`		`- if (!active)`
`287`		`- {`
`288`		`- fprintf(stderr, "block_write: disk not active\n");`
`289`		`- cout << string(DEFAULT);`
`290`		`- return -1;`
`291`		`- }`
`292`	`285`
`293`	`286`	`if ((block < 0) \|\| (block >= DISK_BLOCKS))`
`294`	`287`	`{`
`295`	`288`	`fprintf(stderr, "block_write: block index out of bounds\n");`
`296`		`- cout << string(DEFAULT);`
`297`	`289`	`return -1;`
`298`	`290`	`}`
`299`	`291`
`300`		`- if (fseek(diskptr, block * BLOCK_SIZE, SEEK_SET) < 0)`
	`292`	`+ if (fseek(diskptr, (block * BLOCK_SIZE) + start_position, SEEK_SET) < 0)`
`301`	`293`	`{`
`302`	`294`	`perror("block_write: failed to lseek");`
`303`		`- cout << string(DEFAULT);`
`304`	`295`	`return -1;`
`305`	`296`	`}`
`306`	`297`
`307`		`- if (fwrite(buf, sizeof(char), BLOCK_SIZE, diskptr) < 0)`
	`298`	`+ if (fwrite(buf, sizeof(char), size, diskptr) < 0)`
`308`	`299`	`{`
`309`	`300`	`perror("block_write: failed to write");`
`310`		`- cout << string(DEFAULT);`
`311`	`301`	`return -1;`
`312`	`302`	`}`
`313`		`- cout << string(DEFAULT);`
	`303`	`+`
`314`	`304`	`return 0;`
`315`	`305`	`}`
`316`	`306`
`317`	`307`	`void print_list_open_files()`
`318`	`308`	`{`
`319`		`- cout << string(BOLD) << "### List of opened files ###" << string(DEFAULT) << endl;`
	`309`	`+ cout << string(GREEN) << "List of opened files " << string(DEFAULT) << endl;`
`320`	`310`	`for (auto i : file_descriptor_map)`
`321`	`311`	`{`
`322`	`312`	`int fd = i.first;`
`@@ -334,8 +324,8 @@ void print_list_open_files()`
`334`	`324`
`335`	`325`	`void print_list_files()`
`336`	`326`	`{`
`337`		`- cout << string(BOLD) << "### List of All files ###" << string(DEFAULT) << endl;`
`338`		`- for (auto i : dir_map)`
	`327`	`+ cout << string(GREEN) << "List of All files" << string(DEFAULT) << endl;`
	`328`	`+ for (auto i : file_to_inode_map)`
`339`	`329`	`{`
`340`	`330`	`cout << i.first << " with inode : " << i.second << endl;`
`341`	`331`	`}`
`@@ -425,6 +415,7 @@ int user_handle()`
`425`	`415`	`}`
`426`	`416`	`}`
`427`	`417`	`}`
	`418`	`+`
`428`	`419`	`int main()`
`429`	`420`	`{`
`430`	`421`	`int choice;`