文件系统

最新推荐文章于 2022-03-20 12:43:28 发布
最新推荐文章于 2022-03-20 12:43:28 发布
阅读量235 收藏
点赞数
文章标签： 操作系统
原文链接：http://www.cnblogs.com/Basasuya/p/8433721.html
版权

这个代码讲道理 不是我写的
我是了别人的代码 然后自己借鉴了后重写的
并修了3,4个bug，并且剪短了很多
可以rmdir该目录以及所有下属，可以cd多层目录

三个问题，
1.一个目录文件只删中间一部分，我的写发是这时length不变的，最好修改为read遍历对于free的文件直接跳过(想了想这也不好解决)
2.和老师还讨论了一个问题，如果close了父亲，那么儿子就找不到父亲了，这个可以通过我觉得可以在fcb中加int dirno;int diroff;
3.覆盖写的用处不大，感觉可以修改下write

#include<bits/stdc++.h>
using namespace std;
#define BLOCKSIZE     1024
#define SIZE          1024000
#define END           65535
#define FREE          0
#define MAXOPENFILE   10
#define MAX_TEXT_SIZE 10000

typedef struct FCB {
    char filename[8];
    char exname[5];
    unsigned char attribute;
    unsigned short time;
    unsigned short date;
    unsigned short first;
    unsigned long length;
    char free;
} fcb;
typedef struct FAT{
    unsigned short id;
} fat;
typedef struct USEROPEN {
    char filename[8];
    char exname[5];
    unsigned char attribute;
    unsigned short time;
    unsigned short date;
    unsigned short first;
    unsigned long length;
    char free;

    int dirno;
    int diroff;
    char dir[80];
    int off;
    char fcbstate;
    char topenfile;
} useropen;
typedef struct BLOCK0 {
    char magic_number[8];
    char information[200];
    unsigned short root;
    unsigned char *startblock;
} block0;
unsigned char *myvhard;
useropen openfilelist[MAXOPENFILE];
int currfd;
unsigned char *startp;
char *FileName = "basasuya.txt";

void setZero(fcb *fcbPtr) {
    fcbPtr->date = 0;
    fcbPtr->time = 0;
    fcbPtr->exname[0] = '\0';
    fcbPtr->filename[0] = '\0';
    fcbPtr->first = 0;
    fcbPtr->free = 0;
    fcbPtr->length = 0;
}
int getFreeOpenfilelist() {
    for(int i = 0; i < MAXOPENFILE; ++i) {
        if(openfilelist[i].topenfile == 0) {
            openfilelist[i].topenfile = 1;
            return i;
        }
    }
    return -1;
}
unsigned short getFreeBLOCK() {
    fat* fat1 = (fat*)(myvhard + BLOCKSIZE);
    for(int i = 0; i < (int)(SIZE/BLOCKSIZE); ++i) {
        if(fat1[i].id == FREE) {
            return i;
        }
    }
    return END;
}
int find_father_dir(int fd) {
    for(int i = 0; i < MAXOPENFILE; ++i) {
        if(openfilelist[i].first == openfilelist[fd].dirno && openfilelist[i].topenfile == 1) {
            return i;
        }
    }
    return -1;
}
void my_format() {
    block0 *boot = (block0 *)myvhard;
    strcpy(boot->magic_number,"10101010");
    strcpy(boot->information,"0:引导块 1,2:FAT1 3,4:FAT2 数据");
    boot->root = 5;
    boot->startblock = myvhard + BLOCKSIZE*5;

    fat* fat1 = (fat*)(myvhard + BLOCKSIZE);
    for(int i = 0; i <= 5; ++i) {
        fat1[i].id = END;
    }
    for(int i = 6; i < 1000; ++i) {
        fat1[i].id = FREE;
    }
    fat* fat2 = (fat*)(myvhard + BLOCKSIZE*3);
    memcpy(fat2, fat1, BLOCKSIZE);

    fcb *root = (fcb*)(myvhard + BLOCKSIZE*5);

    strcpy(root->filename,".");
    strcpy(root->exname,"di");
    root->attribute = 0;
    time_t rawTime = time(NULL);
    struct tm *time = localtime(&rawTime);
    root->time = time->tm_hour * 2048 + time->tm_min*32 + time->tm_sec/2;
    root->date = (time->tm_year-100)*512 + (time->tm_mon+1)*32 + (time->tm_mday);
    root->first = 5; root->free = 1;
    root->length = 2*sizeof(fcb);
    fcb* root2 = root+1;
    memcpy(root2, root, sizeof(fcb));
    strcpy(root2->filename, "..");

    for(int i = 2; i < int(BLOCKSIZE / sizeof(fcb)); ++i) { // let the whole fcb be zero
        root2 ++; strcpy(root2->filename, "");
        root2->free = 0;
    }
    FILE *fp = fopen(FileName, "w");
    fwrite(myvhard, SIZE, 1, fp);
    fclose(fp);
}
void startSys() {
    unsigned char buffer[SIZE];
    myvhard = (unsigned char *)malloc(SIZE);
    FILE *file;
    if((file = fopen(FileName, "r")) != NULL) {
        fread(buffer, SIZE, 1, file);
        if(memcmp(buffer, "10101010", 8) != 0) {
            my_format();
        }
        else memcpy(myvhard, buffer, SIZE);
        fclose(file);
    }else {
        my_format();
    }
    fcb *root;
    root = (fcb*)(myvhard + 5*BLOCKSIZE);
    strcpy(openfilelist[0].filename, root->filename);
    strcpy(openfilelist[0].exname, root->exname);
    openfilelist[0].attribute = root->attribute;
    openfilelist[0].time = root->time;
    openfilelist[0].date = root->date;
    openfilelist[0].first = root->first;
    openfilelist[0].length = root->length;
    openfilelist[0].free = root->free;
    openfilelist[0].dirno = 5;
    openfilelist[0].diroff = 0;
    strcpy(openfilelist[0].dir,"/root/");
    openfilelist[0].off = 0;
    openfilelist[0].fcbstate = 0;
    openfilelist[0].topenfile = 1;
    startp = ((block0*)myvhard)->startblock;
    currfd = 0;
    return ;
}
int doread(int fd, int len, char *text) {
    int lenTmp = len;
    unsigned char* buf = (unsigned char*)malloc(1024);
    if(buf == NULL) {
        printf("do_read申请空间失败\n"); return -1;
    }
    int off = openfilelist[fd].off;
    int blockNum = openfilelist[fd].first;
    fat* fatPtr = (fat *)(myvhard+BLOCKSIZE) + blockNum;
    while(off >= BLOCKSIZE) {
        off -= BLOCKSIZE;
        blockNum = fatPtr->id;
        if(blockNum == END) {
            printf("do_read寻找的块不存在\n"); return -1;
        }
        fatPtr = (fat*)(myvhard + BLOCKSIZE) + blockNum;
    }
    unsigned char* blockPtr = myvhard +BLOCKSIZE*blockNum;
    memcpy(buf, blockPtr, BLOCKSIZE);
    char *textPtr = text;
    while(len > 0) {
        if(BLOCKSIZE - off > len) {
            memcpy(textPtr,buf+off, len);
            textPtr += len;
            off += len;
            openfilelist[fd].off += len;
            len = 0;
        }else {
            memcpy(textPtr, buf+off, BLOCKSIZE-off);
            textPtr += BLOCKSIZE - off;
            off = 0;
            len -= BLOCKSIZE - off;
            blockNum = fatPtr->id;
            if(blockNum == END) {
                printf("len 长度过长，超过文件限制！\n"); break;
            }
            fatPtr = (fat*)(myvhard + BLOCKSIZE) + blockNum;
            blockPtr = myvhard + BLOCKSIZE*blockNum;
            memcpy(buf, blockPtr, BLOCKSIZE);
        }
    }
    free(buf);
    return lenTmp - len;
}
void Read(int fd) {
    if(fd >= MAXOPENFILE || fd < 0) {
        printf("文件不存在\n");
        return ;
    }
    openfilelist[fd].off = 0;
    char text[MAX_TEXT_SIZE] = "\0";
    doread(fd, openfilelist[fd].length, text);
    printf("%s\n",text);
}
int dowrite(int fd, char *text, int len, char wstyle) {
    int blockNum = openfilelist[fd].first;
    fat *fatPtr = (fat*)(myvhard + BLOCKSIZE) + blockNum;
    fat* fat1 = (fat*)(myvhard+BLOCKSIZE);
    if(wstyle == 0) {
        openfilelist[fd].off = 0; openfilelist[fd].length = 0;
    }else if(wstyle == 1) {
        if(openfilelist[fd].attribute == 1 && openfilelist[fd].length != 0 && openfilelist[fd].off != 0) {
            openfilelist[fd].off --;
        }
    }else {
        if(openfilelist[fd].attribute == 0) {
            openfilelist[fd].off = openfilelist[fd].length;
        }else if(openfilelist[fd].attribute == 1 && openfilelist[fd].length != 0) {
            openfilelist[fd].off = openfilelist[fd].length - 1;
        }
    }
    int off = openfilelist[fd].off;
    while(off >= BLOCKSIZE) {
        blockNum = fatPtr->id;
        if(blockNum == END) {
            blockNum = getFreeBLOCK();
            if(blockNum == END) {
                printf("盘块不足\n"); return -1;
            }else {
                fatPtr->id = blockNum;
                fatPtr = (fat*)(myvhard + BLOCKSIZE) + blockNum;
                fatPtr->id = END;
            }
        }
        fatPtr = (fat*)(myvhard + BLOCKSIZE) + blockNum;
        off -= BLOCKSIZE;
    }
    unsigned char *buf = (unsigned char*)malloc(BLOCKSIZE * sizeof(unsigned char));
    unsigned char *blockPtr = (unsigned char *)(myvhard + BLOCKSIZE*blockNum);
    int lenTmp = 0;
    char *textPtr = text;
    while(len > lenTmp) {
        memcpy(buf, blockPtr, BLOCKSIZE);
        for(; off < BLOCKSIZE; ++off) {
            *(buf + off) = *textPtr;
            textPtr ++;
            lenTmp ++;
            if(len == lenTmp) {
                break;
            }
        }
        memcpy(blockPtr, buf, BLOCKSIZE);
        if(off == BLOCKSIZE && len != lenTmp) {
            off = 0;
            blockNum = fatPtr->id;
            if(blockNum == END) {
                blockNum = getFreeBLOCK();
                if(blockNum == END) {
                    printf("盘块用完\n"); return -1;
                }else {
                    blockPtr = (unsigned char *)(myvhard + BLOCKSIZE*blockNum);
                    fatPtr->id = blockNum;
                    fatPtr = (fat *)(myvhard + BLOCKSIZE) + blockNum;
                    fatPtr->id = END;
                }
            }else {
                blockPtr = (unsigned char *)(myvhard + BLOCKSIZE * blockNum);
                fatPtr = (fat *)(myvhard + BLOCKSIZE ) + blockNum;
            }
        }
    }
    openfilelist[fd].off += len;
    if(openfilelist[fd].off > openfilelist[fd].length)
        openfilelist[fd].length = openfilelist[fd].off;
    free(buf);

    memcpy((fat*)(myvhard + BLOCKSIZE*3), (fat*)(myvhard + BLOCKSIZE),sizeof(fcb));
    return len;
}
void Write(int fd) {
    if(fd < 0 || fd >= MAXOPENFILE) {
        printf("文件不存在\n"); return;
    }
    int wstype; printf("输入: 0=截断写, 1=覆盖写, 2=追加写\n");
    scanf("%d",&wstype);
    if(wstype < 0 || wstype > 2) {
        printf("输入超过限制\n"); return;
    }
    char text[MAX_TEXT_SIZE] = "\0";
    char textTmp[MAX_TEXT_SIZE] = "\0";
    printf("请输入文件系统，以end为文件系统\n");
    while(scanf("%s",textTmp)) {
        if(strcmp(textTmp, "end") == 0) {
            break;
        }
        strcat(text, textTmp);
        strcat(text, " ");
    }
    dowrite(fd,text,strlen(text)+1, wstype);
    openfilelist[fd].fcbstate = 1;
}
void Changecurrdlength(char *text) {
    fcb *fcbPtr = (fcb *)text;
    fcbPtr->length = openfilelist[currfd].length;
    openfilelist[currfd].off = 0;
    dowrite(currfd, (char*)fcbPtr, sizeof(fcb), 1);
    openfilelist[currfd].fcbstate = 1;
}
int Close(int fd) {
    if(fd > MAXOPENFILE || fd < 0) {
        printf("不存在这个文件\n"); return -1;
    }
    int fatherFd = find_father_dir(fd);
    if(fatherFd == -1) {
        printf("不存在父目录\n");
        return -1;
    }
    if(openfilelist[fd].fcbstate == 1) {
        char buf[MAX_TEXT_SIZE];
        doread(fatherFd, openfilelist[fatherFd].length, buf);
        fcb* fcbPtr = (fcb *)(buf + sizeof(fcb)*openfilelist[fd].diroff);
        strcpy(fcbPtr->exname, openfilelist[fd].exname);
        strcpy(fcbPtr->filename, openfilelist[fd].filename);
        fcbPtr->first = openfilelist[fd].first;
        fcbPtr->free = openfilelist[fd].free;
        fcbPtr->length = openfilelist[fd].length;
        fcbPtr->time = openfilelist[fd].time;
        fcbPtr->date = openfilelist[fd].date;
        fcbPtr->attribute = openfilelist[fd].attribute;
        openfilelist[fatherFd].off = openfilelist[fd].diroff * sizeof(fcb);
        dowrite(fatherFd, (char *)fcbPtr, sizeof(fcb), 1);
    }
    memset(&openfilelist[fd], 0, sizeof(USEROPEN));
    currfd = fatherFd;
    return currfd;
}
void Remove(char *filename){
    char* fname = strtok(filename, ".");
    char* exname = strtok(NULL, ".");
    if(!exname){
        printf("请输入后缀\n");
        return;
    }
    if(strcmp(exname,"di") == 0){
        printf("不可以输入目录\n");
        return ;
    }

    char buf[MAX_TEXT_SIZE];
    openfilelist[currfd].off = 0;
    doread(currfd,openfilelist[currfd].length,buf);
    int i;
    fcb* fcbPtr = (fcb*)buf;
    for(i=0; i < int(openfilelist[currfd].length / sizeof(fcb)); i++, fcbPtr++){
        if(strcmp(fcbPtr->filename,fname) == 0  && strcmp(fcbPtr->exname,exname) == 0){
            break;
        }
    }
    if( i == int(openfilelist[currfd].length / sizeof(fcb))){
        printf("没有这个文件\n");
        return;
    }

    int blockNum = fcbPtr->first;
    fat* fat1 = (fat*)(myvhard + BLOCKSIZE);
    int next = 0;
    while(1){
        next = fat1[blockNum].id;
        fat1[blockNum].id = FREE;
        if(next != END){
            blockNum = next;
        }
        else{
            break;
        }
    }
    fat1 = (fat*)(myvhard + BLOCKSIZE);
    fat* fat2 = (fat*)(myvhard + BLOCKSIZE*3);
    memcpy(fat2, fat1, sizeof(fat));

    setZero(fcbPtr);

    openfilelist[currfd].off = i * sizeof(fcb);
    dowrite(currfd,(char*)fcbPtr,sizeof(fcb),1);
    Changecurrdlength(buf);
}
void Cd(char *dirname){
    if(openfilelist[currfd].attribute == 1){
        printf("数据文件不能cd");
        return ;
    }else{
        char *buf = (char *)malloc(MAX_TEXT_SIZE);
        openfilelist[currfd].off = 0;
        doread(currfd,openfilelist[currfd].length,buf);
        char tmp[20]; int tot = 0; int fl = 0;
        for(int i = 0; dirname[i]; ++i) {
            if(fl) tmp[tot++] = dirname[i];
            else if(dirname[i] == '/') {
                fl = 1; dirname[i] = 0;
            }
        }
        tmp[tot] = 0;

        int i = 0;
        fcb* fcbPtr = (fcb*)buf;
        for(; i < int(openfilelist[currfd].length / sizeof(fcb)); i++,fcbPtr++){
            if(strcmp(fcbPtr->filename, dirname) == 0 && fcbPtr->attribute == 0){
                break;
            }
        }
        if(strcmp(fcbPtr->exname, "di") != 0){
            printf("不含有非数据文件\n");
            return;
        }else {
            if(strcmp(fcbPtr->filename,".") == 0){
                return;
            } else if(strcmp(fcbPtr->filename, "..") == 0){
                if(currfd == 0){
                    return;
                }else{
                    currfd = Close(currfd);
                    return;
                }
            }
            else{


                int fd = getFreeOpenfilelist();
                if(fd == -1){
                    return;
                }
                else{
                    openfilelist[fd].attribute = fcbPtr->attribute;
                    openfilelist[fd].off = 0;
                    openfilelist[fd].date = fcbPtr->date;
                    openfilelist[fd].time = fcbPtr->time;
                    strcpy(openfilelist[fd].filename, fcbPtr->filename);
                    strcpy(openfilelist[fd].exname,fcbPtr->exname);
                    openfilelist[fd].first = fcbPtr->first;
                    openfilelist[fd].free = fcbPtr->free;

                    openfilelist[fd].fcbstate = 0;
                    openfilelist[fd].length = fcbPtr->length;
                    strcpy(openfilelist[fd].dir,
                    (char*)(string(openfilelist[currfd].dir) + string(dirname) + string("/")).c_str());
                    openfilelist[fd].topenfile = 1;
                    openfilelist[fd].dirno = openfilelist[currfd].first;
                    openfilelist[fd].diroff = i;
                    currfd = fd;
                }
                if(tot) Cd(tmp);
            }
        }
    }
}
void Mkdir(char *dirname) {
    char* fname = strtok(dirname, ".");
    char* exname = strtok(NULL, ".");
    if(exname) {
        printf("不允许输入后缀名\n");
        return;
    }
    char text[MAX_TEXT_SIZE];
    openfilelist[currfd].off = 0;
    int fileLen = doread(currfd, openfilelist[currfd].length, text);
    fcb *fcbPtr = (fcb*)text;
    for(int i = 0; i < (int)(fileLen/sizeof(fcb)); ++i) {
        if(strcmp(dirname, fcbPtr[i].filename) == 0 && fcbPtr->attribute == 0) {
            printf("目录名已经存在!\n"); return;
        }
    }
    int fd = getFreeOpenfilelist();
    if(fd == -1) {
        printf("打开文件表已经被占用\n"); return;
    }
    unsigned short int blockNum = getFreeBLOCK();
    if(blockNum == END) {
        printf("盘块应经被用完\n");
        openfilelist[fd].topenfile = 0; return;
    }
    fat *fat1 = (fat *)(myvhard + BLOCKSIZE);
    fat *fat2 = (fat *)(myvhard + BLOCKSIZE*3);
    fat1[blockNum].id = END;
    fat2[blockNum].id = END;
    int i;
    for(i=0;i < (int)(fileLen/sizeof(fcb)); ++i) {
        if(fcbPtr[i].free == 0) break;
    }
    openfilelist[currfd].off = i*sizeof(fcb);
    openfilelist[currfd].fcbstate = 1;
    fcb* fcbtmp = new fcb;
    fcbtmp->attribute = 0;
    time_t rawtime = time(NULL);
    struct tm* time = localtime(&rawtime);
    fcbtmp->date = (time->tm_year-100)*512 + (time->tm_mon+1)*32 + (time->tm_mday);
    fcbtmp->time = (time->tm_hour)*2048 + (time->tm_min)*32 + (time->tm_sec) / 2;
    strcpy(fcbtmp->filename , dirname);
    strcpy(fcbtmp->exname, "di");
    fcbtmp->first = blockNum;
    fcbtmp->length = 2 * sizeof(fcb);
    fcbtmp->free = 1;
    dowrite(currfd,(char *)fcbtmp,sizeof(fcb),1);
    openfilelist[fd].attribute = 0;
    openfilelist[fd].off = 0;
    openfilelist[fd].date = fcbtmp->date;
    openfilelist[fd].time = fcbtmp->time;
    openfilelist[fd].dirno = openfilelist[currfd].first;
    openfilelist[fd].diroff = i;
    strcpy(openfilelist[fd].exname,"di");
    strcpy(openfilelist[fd].filename,dirname);
    openfilelist[fd].fcbstate = 0;
    openfilelist[fd].first = fcbtmp->first;
    openfilelist[fd].free = fcbtmp->free;
    openfilelist[fd].length = fcbtmp->length;
    openfilelist[fd].topenfile = 1;
    strcpy(openfilelist[fd].dir, (char*)(string(openfilelist[currfd].dir) + string(dirname) + string("/")).c_str());

    strcpy(fcbtmp->filename, ".");
    strcpy(fcbtmp->exname, "di");
    fcbtmp->first = blockNum;
    fcbtmp->length = 2 * sizeof(fcb);
    dowrite(fd,(char*)fcbtmp,sizeof(fcb),1);
    fcb *fcbtmp2 = new fcb;
    memcpy(fcbtmp2,fcbtmp,sizeof(fcb));
    strcpy(fcbtmp2->filename,"..");
    fcbtmp2->first = openfilelist[currfd].first;
    fcbtmp2->length = openfilelist[currfd].length;
    fcbtmp2->date = openfilelist[currfd].date;
    fcbtmp2->time = openfilelist[currfd].time;
    dowrite(fd,(char*)fcbtmp2,sizeof(fcb),1);
    Changecurrdlength(text);
    Close(fd);

}
void Rmdir(char *dirname) {
    char* fname = strtok(dirname, ".");
    char* exname = strtok(NULL, ".");
    if(strcmp(dirname, ".") == 0 || strcmp(dirname, "..") == 0) {
        printf("不能删除特殊目录项\n");
        return ;
    }
    if(exname) {
        printf("删除目录文件 没有后缀名\n"); return;
    }
    char buf[MAX_TEXT_SIZE];
    openfilelist[currfd].off = 0;
    doread(currfd,openfilelist[currfd].length,buf);
    int i;
    fcb* fcbPtr = (fcb*)buf;
    for(i=0; i < int(openfilelist[currfd].length / sizeof(fcb)); i++, fcbPtr++){
        if(strcmp(fcbPtr->filename,fname) == 0  && fcbPtr->attribute == 0){
            break;
        }
    }
    if( i == int(openfilelist[currfd].length / sizeof(fcb))){
        printf("没有这个文件\n");
        return;
    }

    Cd(dirname);
    openfilelist[currfd].off = 0;
    doread(currfd,openfilelist[currfd].length,buf);
    fcbPtr = (fcb*)buf;
    for(i=0; i < int(openfilelist[currfd].length / sizeof(fcb)); i++, fcbPtr++);
    for(fcbPtr--,i--; i >= 0; --i, fcbPtr--){
        if(fcbPtr->attribute == 1){
            char *tmp = fcbPtr->filename; strcat(tmp, "."); strcat(tmp, fcbPtr->exname);
            Remove(tmp);
        }else if(strcmp(fcbPtr->filename,".") == 0 || strcmp(fcbPtr->filename,"..") == 0) continue;
        else {
            char *tmp = fcbPtr->filename;
            Rmdir(tmp);
        }
    }
    Cd("..");

    openfilelist[currfd].off = 0;
    doread(currfd,openfilelist[currfd].length,buf);
    fcbPtr = (fcb*)buf;
    for(i=0; i < int(openfilelist[currfd].length / sizeof(fcb)); i++, fcbPtr++){
        if(strcmp(fcbPtr->filename,fname) == 0  && fcbPtr->attribute == 0){
            break;
        }
    }
    int blockNum = fcbPtr->first;
    fat* fat1 = (fat*)(myvhard + BLOCKSIZE);
    int next = 0;
    while(1) {
        next = fat1[blockNum].id;
        fat1[blockNum].id = FREE;
        if(next != END) {
            blockNum = next;
        }else break;
    }

    fat1 = (fat*)(myvhard + BLOCKSIZE);
    fat* fat2 = (fat*)(myvhard + BLOCKSIZE*3);
    memcpy(fat2, fat1, sizeof(fat));
    setZero(fcbPtr);
    openfilelist[currfd].off = i * sizeof(fcb);
    dowrite(currfd,(char*)fcbPtr,sizeof(fcb),1);
    Changecurrdlength(buf);
}
void Touch(char *filename) {
    char* fname = strtok(filename, ".");
    char* exname = strtok(NULL,".");
    if(strcmp(fname,"") == 0) {
        printf("请输入文件名\n"); return ;
    }
    if(!exname) {
        printf("请输入后缀名\n"); return;
    }
    if(openfilelist[currfd].attribute == 1) {
        printf("数据文件下不允许使用create\n"); return;
    }

    openfilelist[currfd].off = 0;
    char buf[MAX_TEXT_SIZE];
    doread(currfd, openfilelist[currfd].length, buf);
    int i;
    fcb* fcbPtr = (fcb*)(buf);

    for(i=0; i < int(openfilelist[currfd].length / sizeof(fcb)); ++i,++fcbPtr) {
        if(strcmp(fcbPtr->filename,filename)==0 && strcmp(fcbPtr->exname,exname)==0){
            printf("文件已存在\n");
            return;
        }
    }

    fcbPtr = (fcb*)(buf);
    for(i=0; i < int(openfilelist[currfd].length / sizeof(fcb)); ++i,++fcbPtr) {
        if(fcbPtr->free == 0) break;
    }
    int blockNum = getFreeBLOCK();
    if(blockNum == -1){
        printf("没有空闲的盘块号\n");
        return ;
    }
    fat* fat1 = (fat*)(myvhard + BLOCKSIZE);
    fat1[blockNum].id = END;
    fat* fat2 = (fat*)(myvhard + BLOCKSIZE * 3);
    memcmp(fat2, fat1, BLOCKSIZE*2);

    strcpy(fcbPtr->filename,filename);
    strcpy(fcbPtr->exname,exname);
    time_t rawtime = time(NULL);
    struct tm* time = localtime(&rawtime);
    fcbPtr->date = (time->tm_year-100)*512 + (time->tm_mon+1)*32 + (time->tm_mday);
    fcbPtr->time = (time->tm_hour)*2048 + (time->tm_min)*32 + (time->tm_sec) / 2;
    fcbPtr->first = blockNum;
    fcbPtr->free = 1;
    fcbPtr->length = 0;
    fcbPtr->attribute = 1;
    openfilelist[currfd].off = i * sizeof(fcb);
    dowrite(currfd,(char *)fcbPtr,sizeof(fcb),1);

    Changecurrdlength(buf);
}
void Ls(){
   if(openfilelist[currfd].attribute == 1){
        printf("数据文件不能用ls\n");
        return;
    }
    char buf[MAX_TEXT_SIZE];

    openfilelist[currfd].off = 0;
    doread(currfd, openfilelist[currfd].length, buf);
    fcb* fcbPtr = (fcb*)buf;
    for(int i=0; i < (int)(openfilelist[currfd].length / sizeof(fcb)); i++){
        if(fcbPtr->free == 1){
            if(fcbPtr->attribute == 0){
                printf("%s\\\t<DIR>\t%d/%d/%d\t%d:%d:%d\n",
                       fcbPtr->filename,
                       (fcbPtr->date>>9)+2000,
                       (fcbPtr->date>>5)&0x000f,
                       (fcbPtr->date)&0x001f,
                       (fcbPtr->time>>11),
                       (fcbPtr->time>>5)&0x003f,
                       (fcbPtr->time)&0x001f * 2);
            }
            else{
                unsigned int length = fcbPtr->length;
                if(length != 0)
                    length -= 2;
                printf("%s.%s\t%dB\t%d/%d/%d\t%02d:%02d:%02d\n",
                       fcbPtr->filename,
                       fcbPtr->exname,
                       length,
                       (fcbPtr->date>>9)+2000,
                       (fcbPtr->date>>5)&0x000f,
                       (fcbPtr->date)&0x001f,
                       (fcbPtr->time>>11),
                       (fcbPtr->time>>5)&0x003f,
                       (fcbPtr->time)&0x001f * 2);
            }
        }
        fcbPtr++;
    }
}
void Open(char *filename){
    char buf[MAX_TEXT_SIZE];
    openfilelist[currfd].off = 0;
    doread(currfd, openfilelist[currfd].length, buf);
    char *fname = strtok(filename,".");
    char *exname = strtok(NULL, ".");
    if(!exname){
        printf("请输入后缀名\n");
        return ;
    }
    int i;
    fcb* fcbPtr = (fcb*)buf;
    for(i=0; i < int(openfilelist[currfd].length / sizeof(fcb)); i++, fcbPtr++){
        if(strcmp(fcbPtr->filename,fname) == 0 && strcmp(fcbPtr->exname,exname) == 0 && fcbPtr->attribute == 1){
            break;
        }
    }
    if(i == int(openfilelist[currfd].length / sizeof(fcb))){
        printf("不存在此文件\n");
        return ;
    }
    int fd = getFreeOpenfilelist();
    if(fd == -1){
        printf("文件打开已满\n");
        return ;
    }
    openfilelist[fd].attribute = 1;
    openfilelist[fd].off = 0;
    openfilelist[fd].date = fcbPtr->date;
    openfilelist[fd].time = fcbPtr->time;
    strcpy(openfilelist[fd].exname, exname);
    strcpy(openfilelist[fd].filename,fname);
    openfilelist[fd].length = fcbPtr->length;
    openfilelist[fd].first = fcbPtr->first;
    strcpy(openfilelist[fd].dir,(string(openfilelist[currfd].dir) + string(filename)).c_str());
    openfilelist[fd].dirno = openfilelist[currfd].first;
    openfilelist[fd].diroff = i;
    openfilelist[fd].free = 1;
    openfilelist[fd].topenfile = 1;
    openfilelist[fd].fcbstate = 0;
    currfd = fd;
}
void Exit() {
    while(currfd) {
        Close(currfd);
    }
    FILE *fp = fopen(FileName,"w");
    fwrite(myvhard, SIZE, 1, fp);
    fclose(fp);
}

int main() {
    char cmd[][10] = {"mkdir", "rmdir", "ls", "cd", "touch", "rm", "open", "close", "write", "read", "exit"};
    printf("*************欢迎使用 basasuya文件操作系统**************\n");
    startSys();
    while(1) {
        printf("%s>",openfilelist[currfd].dir);
        char s[20];
        scanf("%s",s);
        int i;
        for(i = 0; i < 12; ++i) {
            if(strcmp(s, cmd[i]) == 0) break;
        }
        if(i == 0) {
            scanf("%s",s); Mkdir(s);
        }else if(i == 1) {
            scanf("%s",s); Rmdir(s);
        }else if(i == 2) {
            Ls();
        }else if(i == 3) {
            scanf("%s",s); Cd(s);
        }else if(i == 4) {
            scanf("%s",s); Touch(s);
        }else if(i == 5) {
            scanf("%s",s); Remove(s);
        }else if(i == 6) {
            scanf("%s",s); Open(s);
        }else if(i == 7) {
            Close(currfd);
        }else if(i == 8) {
            Write(currfd);
        }else if(i == 9) {
            Read(currfd);
        }else if(i == 10) {
            Exit();
            printf("退出文件系统\n"); break;
        }else printf("命令不合法\n");
    }
    return 0;
}

转载于:https://www.cnblogs.com/Basasuya/p/8433721.html

diankeng5481
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux lsof详解
guoguo1980的专栏
04-24 22万+
lsof简介lsof（list open files）是一个列出当前系统打开文件的工具。在linux环境下，任何事物都以文件的形式存在，通过文件不仅仅可以访问常规数据，还可以访问网络连接和硬件。所以如传输控制协议 (TCP) 和用户数据报协议 (UDP) 套接字等，系统在后台都为该应用程序分配了一个文件描述符，无论这个文件的本质如何，该文件描述符为应用程序与基础操作系统之间的交互提供了通用
【操作系统】C语言编写的FAT16文件系统
东东里个乖乖
10-25 7783
这是上学期操作系统的课程设计的
操作系统文件系统部分函数（二）
qq_36639952的博客
06-13 245
int my_mkdir(char *dirname) { int i,j; struct FCB *cur_mkdir = root; char dir ; for(j = fd ; j &gt;= 0 ; j--) if(openfilelist[j].attribute == 0) break; dir = openfilelist[j].nextdirectory...
简单文件系统实现
allen6268198的专栏
04-16 5483
#include #include #include #include //*********************定义的常量************************ #define NULL 0 #define BLOCKSIZE 1024 //磁盘块大小 #define SIZE 1024000 //虚拟磁盘空间大小 #define END 65535 /
c语言fat文件系统,【操作系统】简单FAT文件系统实现
weixin_35315373的博客
05-19 3288
模拟文件系统，在磁盘上创建一个文件，然后在内存中开辟出一段空间出来，然后将内容复制到的内存之中，如果文件不存在，则要先对该区域进行格式话，最后在操作完成之后，将其写会到我们的文件之中。开始和同学一起合作着来写，结果在我不知不自觉中同学写完了，然后出现的问题也挺多的，看起来是非常的费劲，通过这次阅读别人的代码，自己的一个很大的体会就是在逻辑上，还有变量声明上，如果不清晰，让人看起来真的是非常的费劲，...
实现简单的文件系统
01-26
在退出这个简单的文件系统时，将该虚拟文件系统保存到磁盘上，以便下次再将它恢复到内存的虚拟磁盘空间中。 2.提供以下操作： •new：建立一个新的简单文件系统； •sfs：打开一个简单文件系统； •exit：退出打开的...
分布式文件系统
05-30
分布式文件系统概述，内容涉及发展历史、系统架构、共享语义、共享锁、访问接口、元数据服务模型、数据分布模式、系统扩展性、系统可用性、cache一致性和典型案例。
模拟磁盘文件系统实现
05-01
了解磁盘文件系统的结构、功能和实现。并可练习合作完成系统的团队精神和提高程序设计能力。 设计一个简单的文件系统，用文件模拟磁盘，用数组模拟缓冲区，要求： （1） 支持多级目录结构，支持文件的绝对读路径； ...
模拟文件系统（Java版）
01-21
一个用Java实现的一个虚拟文件系统，支持多用户使用，模拟了数据分块，实现了一些基本的文件目录操作，如创建目录，目录跳转，目录的重命名，复制拷贝，删除，以及文件的创建，编辑，重命名和删除，查看目录和文件的...
单片机读写fat32 51单片机读写sd卡 51读写文件系统源码
12-14
单片机读写fat32文件系统的源码工程，keil工程，绝对可用，打开编译即可，亲测通过编译通过， 8051单片机读写sd卡内容的例子，51单片机读写fat问系统范例，单片机文件系统，fat16文件系统，51单片机读写sd卡读写...
一个c语言写的文件系统,C语言写的虚拟文件系统
weixin_39603573的博客
05-22 474
#include#include#include#include#define BLOCKSIZE 1024 //磁盘块大小#define SIZE1024000 //虚拟磁盘空间大小#define ROOTBLOCKNUM 2//根目录区所占盘块总数#define MAXOPENFILE10 //最多同时打开文件数typedef struct FCB{char filename[8]; //文件...
[操作系统实践][简单的文件系统]
学习之路
06-07 4389
简单文件系统的实现要求 内存中开辟一块虚拟磁盘空间作为文件存储分区，在其上实现一个简单的基于多级目录的单用户单任务系统中的文件系统。 在退出该文件系统的使用时，虚拟文件系统以一个文件的方式保存到磁盘中，以便下次可以把它恢复到内存的虚拟存储空间 实际实现 以上两点均实现 能处理绝对路径和相对路径的命令例如 : cd /home/zy/Desktop/ 这样的绝对路径 cd ../hah/1/2
第 82 章 lsof - list open files 文件监控
weixin_34400525的博客
12-20 116
Command、PID 和 User 列分别表示进程的名称 进程标识符 (PID) 和所有者名称. FD: 文件描述符,应用程序通过文件描述符识别该文件.如cwd txt等 (1) cwd : current working directory 应用程序的当前工作目录,这是该应用程序启动的目录,除非它本身对这个目录进行更改 (2...
解决未明确关闭流时Files.list()打开文件非常耗占资源
封神之路
09-22 1150
问题： 使用lsof -p< pid>检查打开的文件句柄时我仍然可以看到“/”的打开文件句柄列表变得越来越长. while (true) { Files.list(Paths.get("/")).forEach(path -> { System.out.println(path); }); Thread.sleep(5000); System.gc(); System.runFinalization(); } 解决 ： try-wi
linux open files讲解,lsof（list open files） 详解
weixin_39769627的博客
05-25 933
lsof(list open files)是一个列出当前系统打开文件的工具。在linux环境下，任何事物都以文件的形式存在，通过文件不仅仅可以访问常规数据，还可以访问网络连接和硬件。所以如传输控制协议 (TCP) 和用户数据报协议 (UDP) 套接字等，系统在后台都为该应用程序分配了一个文件描述符，无论这个文件的本质如何，该文件描述符为应用程序与基础操作系统之间的交互提供了通用接口。因为应用程序打...
c语言隐私信息管理系统2022
weixin_46337464的博客
03-20 2532
重要的事情说三遍： 不要抄，抄对你没有好处！ 不要抄，抄对你没有好处！ 不要抄，抄对你没有好处！ 题目要求： 隐私信息管理系统 本题要求采用结构体数组（或链表）存储数据。具体要求如下： 1)程序执行时，首先要进行密码检测，以不让非法用户使用本程序。标准密码预先在程序中设定，程序运行时，若用户的输入密码和标准密码相同，则显示“口令正确！”并转去执行后续程序；若不相等，重新输入，3次都不相等则显示“您是非法用户！”并终止程序的执行。 2)现在每个人在不同网站都有用户名和密码等信息，还有银行卡..
Linux编程实践——文件操作里神秘的当前指针
weixin_30511039的博客
09-15 83
在《Unix\Linux编程实践教程》 一书第56页有一段话： Unix每次打开一个文件都会保存一个指针来记录文件的当前位置，如图示 read从当前位置读入指定长度的数据， 然后移动当前位置指针， 指向下一个未读的数据 当从文件读数据时，内核从指针所标明的地方开始， 读取指定的字节，然后移动位置指针， 指向下一个未被读取的字节，写文件的操作也是类似的。 指针是与文件描述符相关联...
操作系统实验六 文件管理
热门推荐
Time木的博客
06-15 1万+
操作系统实验六 文件管理
操作系统原理 实验六 文件管理
bearcat303295的博客
06-30 1万+
实验六 文件管理 1、实验目的 通过设计一个简单的文件系统，加深理解文件、目录和文件系统等概念，理解文件系统的内部功能及内部实现。 2、实验预备内容 （1）阅读Linux文件系统相关源码 （2）掌握文件、目录和文件系统等概念。 3、实验内容 为linux系统设计一个简单的二级文件系统。要求做到以下几点： （1）可以实现下列几条命令（至少4条）； login 用户登陆 dir 列文件目录 create 创建文件 delete 删除文件 open 打开文件 close 关闭文件 read 读文件
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值