int main(int argc, char **argv) { printf("\nTest de l'allocation/liberation des blocs - ASE TP 8\n====================================================\n Alexis Beaujet M1\n\n\n"); mount(); makefs(currentVol); char choix[200]; do{ printf("\n\nMenu : (EOF pour sortir)\n\n 1- Tests d'allocation/libération de blocs (gestion de la freelist et du superblock) : SUR PETIT VOLUME SINON LENT\n 2- Tests d'allocation de datablocks et de tables d'indirection au sein d'un inode\n\n"); fflush(stdin); if(scanf("%s", choix) == EOF) exit(0); }while(strlen(choix) != 1 || atoi(choix) > 2 || atoi(choix) < 1); switch (atoi(choix)){ case 1: testsAllocationBlocks(); break; case 2: testAllocationDataBlocks(); break; default: printf("Loule.\n"); } printf("\n"); exit(EXIT_SUCCESS); }
int do_mkfs(){ s8 ret,i=0; u8 ch; u8 password[PASSWORD_LENGTH]; vd_puts("enter the new admin password you want to set ::"); while (i <= PASSWORD_LENGTH && ( ch = password[i++] = getch()) != (u8)('\n') && ch != (u8)('\r') )vd_putchar('#'); password[--i] = 0; vd_puts("\n"); ret=makefs(password); flpchange=0; if(ret == -1){ ERROR_NO=0; ret=makefs(password); flpchange=0; if (ret == -1){ vd_puts("CANNOT CREATE FILE SYSTEM\n") ; errormessage(geterror()); return 1; } } fl_clean(); return 0; }
void testDBlks(UINT nDBlks, UINT nINodes) { printf("\n==== dblk test ====\n"); //test makefs printf("\n---- makefs ----\n"); FileSystem fs; UINT succ = makefs(nDBlks, nINodes, &fs); if(succ == 0) { printf("makefs succeeded with filesystem size: %d\n", fs.nBytes); } printf("\nSuperblock:\n"); printSuperBlock(&fs.superblock); printf("\nINodes:\n"); printINodes(&fs); printf("\nData blocks:\n"); printDBlks(&fs); printf("\nFree inode cache:\n"); printFreeINodeCache(&fs.superblock); printf("\nFree dblk cache:\n"); printFreeDBlkCache(&fs.superblock); assert(fs.diskINodeBlkOffset == 1); assert(fs.diskDBlkOffset == 1 + nINodes / INODES_PER_BLK); //test allocDBlk until no free dblks are left printf("\n---- allocDBlk ----\n"); for(int i = 0; i < nDBlks; i++) { UINT id = allocDBlk(&fs); printf("allocDBlk call %d returned ID %d\n", i, id); } assert(fs.superblock.nFreeDBlks == 0); //allocDBlk should fail gracefully when no free dblks are left UINT id = allocDBlk(&fs); printf("Invalid allocDBlk call returned ID %d\n", id); assert(id == -1); printf("\nSuperblock:\n"); printSuperBlock(&fs.superblock); printf("\nDBlks:\n"); printDBlks(&fs); printf("\nFree dblk cache:\n"); printFreeDBlkCache(&fs.superblock); //test random freeDBlk printf("\n---- random freeDBlk ----\n"); //produce a random ordering to free int shuffled[nDBlks]; for(int i = 0; i < nDBlks; i++) { shuffled[i] = i; } shuffle(shuffled, nDBlks); for(int i = 0; i < nDBlks; i++) { printf("Freeing dblk id: %d\n", shuffled[i]); succ = freeDBlk(&fs, shuffled[i]); printFreeDBlkCache(&fs.superblock); assert(succ == 0); } assert(fs.superblock.nFreeDBlks == nDBlks); printf("\nSuperblock:\n"); printSuperBlock(&fs.superblock); printf("\nDBlks:\n"); printDBlks(&fs); printf("\nFree dblk cache:\n"); printFreeDBlkCache(&fs.superblock); //test allocDBlk until no free dblks are left printf("\n---- allocDBlk ----\n"); for(int i = 0; i < nDBlks; i++) { UINT id = allocDBlk(&fs); printf("allocDBlk call %d returned ID %d\n", i, id); } assert(fs.superblock.nFreeDBlks == 0); //test ordered freeDBlk printf("\n---- ordered freeDBlk ----\n"); for(int i = 0; i < nDBlks; i++) { printf("Freeing dblk id: %d\n", i); succ = freeDBlk(&fs, i); printFreeDBlkCache(&fs.superblock); assert(succ == 0); } assert(fs.superblock.nFreeDBlks == nDBlks); printf("\nSuperblock:\n"); printSuperBlock(&fs.superblock); printf("\nDBlks:\n"); printDBlks(&fs); printf("\nFree dblk cache:\n"); printFreeDBlkCache(&fs.superblock); //temporary variables for read/write test if(nDBlks < NUM_TEST_DBLKS) { printf("\nError: must have at least %d dblks to do read/write test!\n", NUM_TEST_DBLKS); exit(1); } BYTE dblks[NUM_TEST_DBLKS][BLK_SIZE]; UINT dblkIds[NUM_TEST_DBLKS]; for(int i = 0; i < NUM_TEST_DBLKS; i++) { dblkIds[i] = -1; } //test allocDBlk printf("\n---- allocDBlk (2) ----\n"); for(int i = 0; i < NUM_TEST_DBLKS; i++) { dblkIds[i] = allocDBlk(&fs); printf("allocDBlk call %d returned ID %d\n", i, dblkIds[i]); //ensure dblk IDs are valid and unique assert(dblkIds[i] >= 0 && dblkIds[i] < nDBlks); for(UINT j = 0; j < i; j++) { assert(dblkIds[i] != dblkIds[j]); } } //test group writeDBlk printf("\n---- writeDBlk ----\n"); for(int i = 0; i < NUM_TEST_DBLKS; i++) { UINT* buf = (UINT*) &dblks[i]; for(int j = 0; j < BLK_SIZE / sizeof(UINT); j++) { buf[j] = -j; } printf("Writing test data to dblk id: %d\n", dblkIds[i]); succ = writeDBlk(&fs, dblkIds[i], dblks[i]); assert(succ == 0); } printf("\nDBlks:\n"); printDBlks(&fs); //test group readDBlk printf("\n---- readDBlk ----\n"); for(int i = 0; i < NUM_TEST_DBLKS; i++) { BYTE testDBlk[BLK_SIZE]; printf("Reading test data from dblk id: %d\n", dblkIds[i]); succ = readDBlk(&fs, dblkIds[i], testDBlk); printDBlkInts(testDBlk); assert(succ == 0); UINT* buf = (UINT*) &testDBlk; for(int j = 0; j < BLK_SIZE / sizeof(UINT); j++) { assert(buf[j] == -j); } } //test writeDBlkOffset printf("\n---- writeDBlkOffset ----\n"); for(int i = 0; i < NUM_TEST_DBLKS; i++) { UINT* buf = (UINT*) &dblks[i]; for(int j = 0; j < TEST_DBLK_BYTE_LEN / sizeof(UINT); j++) { buf[j] = - (int) (j+ TEST_DBLK_BYTE_OFF / sizeof(UINT) + 3); } printf("Writing test data to dblk id: %d, with offset: %d, and length: %d\n", dblkIds[i], TEST_DBLK_BYTE_OFF, TEST_DBLK_BYTE_LEN); succ = writeDBlkOffset(&fs, dblkIds[i], (BYTE*) buf, TEST_DBLK_BYTE_OFF, TEST_DBLK_BYTE_LEN); assert(succ == 0); } //test readDblkOffset printf("\n---- readDBlkOffset ----\n"); for(int i = 0; i < NUM_TEST_DBLKS; i++) { BYTE testDBlkOff[TEST_DBLK_BYTE_LEN]; printf("Reading test data from dblk id: %d, with offset: %d, and length: %d\n", dblkIds[i], TEST_DBLK_BYTE_OFF, TEST_DBLK_BYTE_LEN); succ = readDBlkOffset(&fs, dblkIds[i], testDBlkOff, TEST_DBLK_BYTE_OFF, TEST_DBLK_BYTE_LEN); assert(succ == 0); UINT* buf = (UINT*) &testDBlkOff; for(int j = 0; j < TEST_DBLK_BYTE_LEN / sizeof(UINT); j++) { //printf("%d, %d\n", buf[j], - (int) (j + TEST_READ_DBLK_OFF / sizeof(UINT) + 3)); assert(buf[j] == - (int) (j + TEST_DBLK_BYTE_OFF / sizeof(UINT) + 3)); } } //test modifying read/writeDBlk printf("\n---- modify read/writeDBlk ----\n"); printDBlks(&fs); for(int i = NUM_TEST_DBLKS - 1; i >= 0; i--) { succ = readDBlk(&fs, dblkIds[i], dblks[i]); assert(succ == 0); printf("Modifying dblk id: %d\n", dblkIds[i]); UINT* buf = (UINT*) &dblks[i]; for(int j = 0; j < BLK_SIZE / sizeof(UINT); j++) { buf[j] = dblkIds[i]; } succ = writeDBlk(&fs, dblkIds[i], dblks[i]); assert(succ == 0); BYTE testDBlk2[BLK_SIZE]; succ = readDBlk(&fs, dblkIds[i], testDBlk2); printDBlkInts(testDBlk2); assert(succ == 0); UINT* buf2 = (UINT*) &testDBlk2; for(int j = 0; j < BLK_SIZE / sizeof(UINT); j++) { assert(buf2[j] == dblkIds[i]); } } printf("\n---- closefs ----\n"); succ = closefs(&fs); assert(succ == 0); printf("\n==== dblk test complete ====\n"); }
void testINodes(UINT nDBlks, UINT nINodes) { printf("\n==== inode test ====\n"); //test makefs printf("\n---- makefs ----\n"); FileSystem fs; UINT succ = makefs(nDBlks, nINodes, &fs); if(succ == 0) { printf("makefs succeeded with filesystem size: %d\n", fs.nBytes); } printf("\nSuperblock:\n"); printSuperBlock(&fs.superblock); printf("\nINodes:\n"); printINodes(&fs); printf("\nData blocks:\n"); printDBlks(&fs); printf("\nFree inode cache:\n"); printFreeINodeCache(&fs.superblock); printf("\nFree dblk cache:\n"); printFreeDBlkCache(&fs.superblock); assert(fs.diskINodeBlkOffset == 1); assert(fs.diskDBlkOffset == 1 + nINodes / INODES_PER_BLK); //test allocINode until no free inodes are left printf("\n---- allocINode ----\n"); for(int i = 0; i < nINodes; i++) { INode testINode; UINT id = allocINode(&fs, &testINode); printf("allocINode call %d returned ID %d\n", i, id); printINode(&testINode); } assert(fs.superblock.nFreeINodes == 0); //allocINode should fail gracefully when no free inodes are left INode testINode; UINT id = allocINode(&fs, &testINode); printf("Invalid allocINode call returned ID %d\n", id); assert(id == -1); printf("\nSuperblock:\n"); printSuperBlock(&fs.superblock); printf("\nINodes:\n"); printINodes(&fs); printf("\nFree inode cache:\n"); printFreeINodeCache(&fs.superblock); //test random freeINode printf("\n---- random freeINode ----\n"); int shuffled[nINodes]; for(int i = 0; i < nINodes; i++) { shuffled[i] = i; } shuffle(shuffled, nINodes); for(int i = 0; i < nINodes; i++) { printf("Freeing inode id: %d\n", shuffled[i]); succ = freeINode(&fs, shuffled[i]); assert(succ == 0); } printf("%d, %d\n", fs.superblock.nFreeINodes, nINodes); assert(fs.superblock.nFreeINodes == nINodes); printf("\nSuperblock:\n"); printSuperBlock(&fs.superblock); printf("\nINodes:\n"); printINodes(&fs); printf("\nFree inode cache:\n"); printFreeINodeCache(&fs.superblock); //test allocINode until no free inodes are left printf("\n---- allocINode ----\n"); for(int i = 0; i < nINodes; i++) { INode testINode; UINT id = allocINode(&fs, &testINode); printf("allocINode call %d returned ID %d\n", i, id); } assert(fs.superblock.nFreeINodes == 0); //test ordered freeINode printf("\n---- ordered freeINode ----\n"); for(int i = 0; i < nINodes; i++) { printf("Freeing inode id: %d\n", i); succ = freeINode(&fs, i); assert(succ == 0); } assert(fs.superblock.nFreeINodes == nINodes); printf("\nSuperblock:\n"); printSuperBlock(&fs.superblock); printf("\nINodes:\n"); printINodes(&fs); printf("\nFree inode cache:\n"); printFreeINodeCache(&fs.superblock); //temporary variables for read/write test if(nINodes < NUM_TEST_INODES) { printf("\nError: must have at least %d inodes to do read/write test!\n", NUM_TEST_INODES); exit(1); } INode inodes[NUM_TEST_INODES]; UINT inodeIds[NUM_TEST_INODES]; for(int i = 0; i < NUM_TEST_INODES; i++) { inodeIds[i] = -1; } //test allocINode printf("\n---- allocINode (2) ----\n"); for(int i = 0; i < NUM_TEST_INODES; i++) { inodeIds[i] = allocINode(&fs, &inodes[i]); printf("allocINode call %d returned ID %d\n", i, inodeIds[i]); printINode(&inodes[i]); //ensure allocated IDs are valid and unique assert(inodeIds[i] >= 0 && inodeIds[i] < nINodes); for(UINT j = 0; j < i; j++) { assert(inodeIds[i] != inodeIds[j]); } } //test group writeINode printf("\n---- writeINode ----\n"); for(int i = 0; i < NUM_TEST_INODES; i++) { //inodes[i]._in_owner = TEST_OWNER; strcpy(inodes[i]._in_owner, TEST_OWNER); inodes[i]._in_permissions = TEST_PERMISSIONS; inodes[i]._in_modtime = TEST_MODTIME; inodes[i]._in_accesstime = TEST_ACCESSTIME; inodes[i]._in_filesize = TEST_FILESIZE; printf("Writing test data to inode id: %d\n", inodeIds[i]); succ = writeINode(&fs, inodeIds[i], &inodes[i]); assert(succ == 0); } printINodes(&fs); //test group readINode printf("\n---- readINode ----\n"); for(int i = 0; i < NUM_TEST_INODES; i++) { INode testINode; printf("Reading test data from inode id: %d\n", inodeIds[i]); succ = readINode(&fs, inodeIds[i], &testINode); printINode(&testINode); assert(succ == 0); //assert(testINode._in_owner = TEST_OWNER); assert(!strcmp(testINode._in_owner, TEST_OWNER)); assert(testINode._in_permissions = TEST_PERMISSIONS); assert(testINode._in_modtime = TEST_MODTIME); assert(testINode._in_accesstime = TEST_ACCESSTIME); assert(testINode._in_filesize = TEST_FILESIZE); } //test modifying read/writeINode printf("\n---- modify read/writeINode ----\n"); printINodes(&fs); for(int i = NUM_TEST_INODES - 1; i >= 0; i--) { succ = readINode(&fs, inodeIds[i], &inodes[i]); assert(succ == 0); printf("Modifying inode id: %d\n", inodeIds[i]); //inodes[i]._in_owner = "WILL"; strcpy(inodes[i]._in_owner, "WILL"); inodes[i]._in_permissions = TEST_PERMISSIONS - 1; inodes[i]._in_modtime = TEST_MODTIME - 1; inodes[i]._in_accesstime = TEST_ACCESSTIME - 1; inodes[i]._in_filesize = TEST_FILESIZE - 1; succ = writeINode(&fs, inodeIds[i], &inodes[i]); assert(succ == 0); INode testINode2; succ = readINode(&fs, inodeIds[i], &testINode2); printINode(&testINode2); assert(succ == 0); //assert(testINode2._in_owner = inodes[i]._in_owner); assert(!strcmp(testINode2._in_owner, inodes[i]._in_owner)); assert(testINode2._in_permissions = inodes[i]._in_permissions); assert(testINode2._in_modtime = inodes[i]._in_modtime); assert(testINode2._in_accesstime = inodes[i]._in_accesstime); assert(testINode2._in_filesize = inodes[i]._in_filesize); } printf("\n---- closefs ----\n"); succ = closefs(&fs); assert(succ == 0); printf("\n==== inode test complete ====\n"); }