119 lines
4.9 KiB
C++
119 lines
4.9 KiB
C++
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include "fs.h"
|
|
#include <inttypes.h>
|
|
|
|
int main(int argc, char *argv[]) {
|
|
const char* d = (argc < 2) ? "/dev/vdc" : argv[1];
|
|
|
|
RawDisk *H = new RawDisk(d);
|
|
|
|
printf("test inode\n");
|
|
INodeOperation inop;
|
|
inop.initialize(*H);//for inode initialization and datablock initialization
|
|
char buffer[8] = {0};
|
|
/**************************test inode Initialization***************************/
|
|
//test the begining of inode 1th
|
|
H->rawdisk_read((1) * SECTOR_SIZE, buffer, sizeof(buffer));
|
|
u_int64_t t = 0;
|
|
for (int j = 0; j < 8; j++)
|
|
t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
|
|
|
|
assert(t == 2);//the first 1th unused inode will store the next unused inode 2th
|
|
//test the number before end of inode 524286th
|
|
H->rawdisk_read((MAX_INODE - 2) * SECTOR_SIZE, buffer, sizeof(buffer));
|
|
t = 0;
|
|
for (int j = 0; j < 8; j++)
|
|
t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
|
|
|
|
assert(t == MAX_INODE - 1);//store the maximun th inode
|
|
//test the end of inode 524287th
|
|
H->rawdisk_read((MAX_INODE - 1) * SECTOR_SIZE, buffer, sizeof(buffer));
|
|
t = 0;
|
|
for (int j = 0; j < 8; j++)
|
|
t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
|
|
|
|
assert(t == 0);//the end of inode(524287th inode) do not have the next inode address
|
|
/**************************test datablock Initialization***************************/
|
|
//we separate 2048 4kB I/O block(1+2047) as a group and the first I/O block will manage the following 2047 I/O block usage.
|
|
//the first 8 bytes(0~7) in first I/O block store the address of next first I/O block, the following 256(8~263) bytes record 2047 I/O block usage.
|
|
//test the begining of free datablock
|
|
H->rawdisk_read((MAX_INODE) * SECTOR_SIZE, buffer, sizeof(buffer));//the begining of free datablock will store from address (MAX_INODE) * SECTOR_SIZE
|
|
t = 0;
|
|
for (int j = 0; j < 8; j++)
|
|
t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
|
|
|
|
assert(t == (MAX_INODE+2048*8)*SECTOR_SIZE);//the first 8 bytes of 4k I/O block will store the next address(after 2048*4k I/O block)
|
|
//test the end of the datablock
|
|
H->rawdisk_read((MAX_BLOCKNUM - 2048*8) * SECTOR_SIZE, buffer, sizeof(buffer));
|
|
t = 0;
|
|
for (int j = 0; j < 8; j++)
|
|
t |= ((u_int64_t)(unsigned char)buffer[j]) << (8 * j);
|
|
|
|
assert(t == (MAX_BLOCKNUM)*SECTOR_SIZE);
|
|
|
|
/***************************test inode de/allocation**********************************/
|
|
//when requesting an inode, the inode_allocation will give you the inode number, we use inode_list to store the sequence allocate inode
|
|
//arrary version
|
|
int inode_list[20] = {0};
|
|
int record_free[10] = {0};//should do a pop up structure to record the free inode
|
|
int rec = 9;
|
|
//printf("Allocate 20 inode num:{");
|
|
for(int i=0;i<20;i++){
|
|
inode_list[i] = inop.inode_allocate(*H);
|
|
assert(inode_list[i] == i+1);
|
|
//printf(" %d", inode_list[i]);
|
|
}
|
|
//printf("}\n");
|
|
for(int i=10;i<20;i++){
|
|
inop.inode_free(*H,inode_list[i]);//free the 10 element from inode_list[10]
|
|
record_free[i-10] = inode_list[i];
|
|
}
|
|
//allocate again the last 10
|
|
printf("Allocate again: inode num:{");
|
|
for(int i=10;i<20;i++){
|
|
inode_list[i] = inop.inode_allocate(*H);
|
|
//printf("inode %d, rec_f %d\n,", inode_list[i],record_free[rec]);
|
|
assert(inode_list[i] == record_free[rec]);
|
|
rec--;
|
|
}
|
|
printf("}\n");
|
|
/***************************test direct blocks[48] de/allocation**********************************/
|
|
//after free the datablock, the program will find the first smallest address of datablock to give to the inode
|
|
//should test random resize each node, but should use datablock_free data structure to record
|
|
INode inode_inside[10];
|
|
u_int64_t rec_datablock_free[10][3] = {0};//array version
|
|
for(int i=0;i<10;i++){
|
|
inode_inside[i].inode_construct(inode_list[i],*H);
|
|
//printf("%dth data block starting addres: ", i);
|
|
for(int j=0;j<6;j++){
|
|
inode_inside[i].datablock_allocate(*H);
|
|
//printf("%d," ,inode_inside[i].datablock_allocate(*H));
|
|
}
|
|
//printf("\n");
|
|
}
|
|
for(int i=0;i<10;i++){
|
|
//printf("%dth data block free addres: ", i);
|
|
for(int j = 2;j >=0;j--){
|
|
rec_datablock_free[i][j] = inode_inside[i].datablock_deallocate(*H);
|
|
//printf("", rec_datablock_free[i][j]);
|
|
}
|
|
//printf("\n");
|
|
}
|
|
|
|
for(int i=0;i<10;i++){
|
|
//printf("%dth data block allocate again addres: ", i);
|
|
for(int j=0;j<3;j++){
|
|
assert(inode_inside[i].datablock_allocate(*H) == rec_datablock_free[i][j]);
|
|
//printf("%d," ,inode_inside[i].datablock_allocate(*H));
|
|
}
|
|
//printf("\n");
|
|
}
|
|
|
|
//printf("}\n");
|
|
delete H; // Delete the RawDisk object
|
|
|
|
return 0;
|
|
}
|