文件系统——Hash结构文件

实验四 文件系统——Hash结构文件    

一、实验目的

1、理解Linux文件系统的内部技术，掌握Linux与文件有关的系统调用命令，并在此基础上建立面向随机检索的hash结构文件。

2、Linux系统保持UNIX文件系统的风格，提供流式文件界面，这种结构具有简洁灵活的特点，但并不直接支持记录式文件和关键字检索。本实验是在Linux文件系统基础上，设计一组库函数，以提供对随机检索的支持。

 

二、实验内容

1、参考教材中hash文件构造算法，设计一组hash文件函数，包括hash文件创建、打开、关闭、读、写等。

2、编写一个测试程序，通过记录保存、查找、删除等操作，检查上述hash文件是否实现相关功能。

 

三、实验准备

1、教程Hash文件核心算法，包括记录保存、记录查找、记录删除等。

2、教程Linux系统有关文件的系统调用命令：creat，open，close，read，write，lseek。

 

四、实验设计

1、由于在Linux系统核心之外模拟实现hash文件，有关hash文件的说明信息不能保存 在inode中，而只能记录在文件的头部。这些信息包括hash文件标志、记录大小、文件 长度、记录数量等。

2、可以根据hash文件核心算法设计内部函数，包括记录的保存、查找、删除等，在此 基础上实现读、写等常规操作。 

 

五、实验源码

//hashfile.h

 

#include

#include

#define COLLISIONFACTOR 0.5

struct HashFileHeader

{

int sig; //Hash文件印鉴

int reclen; //记录长度

int total_rec_num; //总记录数

int current_rec_num; //当前记录数 

};

struct CFTag

{

char collision; //冲突计数

char free; //空闲标志

};

int hashfile_creat(const char *filename,mode_t mode,int reclen,int total_rec_num);

//int hashfile_open(const char *filename,int flags); 

int hashfile_open(const char *filename,int flags,mode_t mode);

int hashfile_close(int fd);

int hashfile_read(int fd,int keyoffset,int keylen,void *buf);

int hashfile_write(int fd,int keyoffset,int keylen,void *buf);

int hashfile_delrec(int fd,int keyoffset,int keylen,void *buf);

int hashfile_findrec(int fd,int keyoffset,int keylen,void *buf);

int hashfile_saverec(int fd,int keyoffset,int keylen,void *buf);

int hash(int keyoffset,int keylen,void *buf,int total_rec_num);

int checkHashFileFull(int fd);

int readHashFileHeader(int fd,struct HashFileHeader *hfh);

//hashfile.c

#include

#include

#include

#include

#include

#include

#include

#include"HashFile.h"

int hashfile_creat(const char *filename,mode_t mode,int reclen,int total_rec_num)

{

struct HashFileHeader hfh;

int fd;

int rtn;

char *buf;

int i=0;

hfh.sig = 31415926;

hfh.reclen = reclen;

hfh.total_rec_num = total_rec_num;

hfh.current_rec_num = 0;

//fd = open(filename,mode);

fd = creat(filename,mode);

if(fd != -1)

{

rtn = write(fd,&hfh,sizeof(struct HashFileHeader));

//lseek(fd,sizeof(struct HashFileHeader),SEEK_SET);

if(rtn != -1)

{

buf = (char*)malloc((reclen+sizeof(struct CFTag))*total_rec_num);

memset(buf,0,(reclen+sizeof(struct CFTag))*total_rec_num);   ////????

rtn = write(fd,buf,(reclen+sizeof(struct CFTag))*total_rec_num);

free(buf);

}

close(fd);

return rtn;

}

else{

close(fd);

return -1;

}

}

int hashfile_open(const char *filename,int flags,mode_t mode)

{

int fd = open(filename,flags,mode);

struct HashFileHeader hfh;

if(read(fd,&hfh,sizeof(struct HashFileHeader))!= -1)

{

lseek(fd,0,SEEK_SET);

if(hfh.sig == 31415926)

return fd;

else

return -1;

}

else return -1;

}

int hashfile_close(int fd)

{

return close(fd);

}

int hashfile_read(int fd,int keyoffset,int keylen,void *buf)

{

struct HashFileHeader hfh;

readHashFileHeader(fd,&hfh);

int offset = hashfile_findrec(fd,keyoffset,keylen,buf);

if(offset != -1)

{

lseek(fd,offset+sizeof(struct CFTag),SEEK_SET);

return read(fd,buf,hfh.reclen);

}

else

{

return -1;

}

}

int hashfile_write(int fd,int keyoffset,int keylen,void *buf)

{

return hashfile_saverec(fd,keyoffset,keylen,buf);

//return -1;

}

int hashfile_delrec(int fd,int keyoffset,int keylen,void *buf)

{

int offset;

offset = hashfile_findrec(fd,keyoffset,keylen,buf);

if(offset != -1)

{

struct CFTag tag;

read(fd,&tag,sizeof(struct CFTag));

tag.free =0; //置空闲标志 

lseek(fd,offset,SEEK_SET);

write(fd,&tag,sizeof(struct CFTag));

struct HashFileHeader hfh;

readHashFileHeader(fd,&hfh);

int addr = hash(keyoffset,keylen,buf,hfh.total_rec_num);

offset = sizeof(struct HashFileHeader)+addr*(hfh.reclen+sizeof(struct CFTag));

if(lseek(fd,offset,SEEK_SET)==-1)

return -1;

read(fd,&tag,sizeof(struct CFTag));

tag.collision--; //冲突计数减1

lseek(fd,offset,SEEK_SET);

write(fd,&tag,sizeof(struct CFTag));

hfh.current_rec_num--; //当前记录数减1

lseek(fd,0,SEEK_SET);

write(fd,&hfh,sizeof(struct HashFileHeader));

}

else{

return -1;

}

}

int hashfile_findrec(int fd,int keyoffset,int keylen,void *buf)

{

struct HashFileHeader hfh;

readHashFileHeader(fd,&hfh);

int addr = hash(keyoffset,keylen,buf,hfh.total_rec_num);

int offset = sizeof(struct HashFileHeader)+addr*(hfh.reclen+sizeof(struct CFTag));

if(lseek(fd,offset,SEEK_SET)==-1)

return -1;

struct CFTag tag;

read(fd,&tag,sizeof(struct CFTag));

char count = tag.collision;

if(count==0)

return -1; //不存在

recfree:

if(tag.free == 0)

{

offset += hfh.reclen+sizeof(struct CFTag);

if(lseek(fd,offset,SEEK_SET)==-1)

return -1;

read(fd,&tag,sizeof(struct CFTag));

goto recfree;

}

else{

char *p =(char*)malloc(hfh.reclen*sizeof(char));

read(fd,p,hfh.reclen);

//printf("Record is {%d , %s}\n",((struct jtRecord *)p)->key,((struct jtRecord *p)->other);

char *p1,*p2;

p1 = (char *)buf+keyoffset;

p2 = p + keyoffset;

int j=0;

while((*p1 == *p2)&&(j

{

p1++;

p2++;

j++;

}

if(j==keylen)

{

free(p);

p = NULL;

return(offset);

}

else{

if(addr == hash(keyoffset,keylen,p,hfh.total_rec_num))

{

count--;

if(count == 0)

{

free(p);

p = NULL;

return -1;//不存在 

}

}

free(p);

p = NULL;

offset += hfh.reclen+sizeof(struct CFTag);

if(lseek(fd,offset,SEEK_SET) == -1)

return -1;

read(fd,&tag,sizeof(struct CFTag));

goto recfree;

}

}

}

int hashfile_saverec(int fd,int keyoffset,int keylen,void *buf)

{

if(checkHashFileFull(fd))

{

return -1;

}

struct HashFileHeader hfh;

readHashFileHeader(fd,&hfh);

int addr = hash(keyoffset,keylen,buf,hfh.total_rec_num);

int offset = sizeof(struct HashFileHeader)+addr*(hfh.reclen+sizeof(struct CFTag));

if(lseek(fd,offset,SEEK_SET)==-1)

return -1;

struct CFTag tag;

read(fd,&tag,sizeof(struct CFTag));

tag.collision++;

lseek(fd,sizeof(struct CFTag)*(-1),SEEK_CUR);

write(fd,&tag,sizeof(struct CFTag));

while(tag.free!=0) //冲突，顺序探查

{

offset += hfh.reclen+sizeof(struct CFTag);

if(offset >= lseek(fd,0,SEEK_END))

offset = sizeof(struct HashFileHeader); //reach at and,then rewind

if(lseek(fd,offset,SEEK_SET)==-1)

return -1;

read(fd,&tag,sizeof(struct CFTag));

} 

tag.free =-1;

lseek(fd,sizeof(struct CFTag)*(-1),SEEK_CUR);

write(fd,&tag,sizeof(struct CFTag));

write(fd,buf,hfh.reclen);

hfh.current_rec_num++;

lseek(fd,0,SEEK_SET);

return write(fd,&hfh,sizeof(struct HashFileHeader));  //存入记录 

}

int hash(int keyoffset,int keylen,void *buf,int total_rec_num)

{

int i=0;

char *p =(char*)buf+keyoffset;

int addr =0;

for(i=0;i

{

addr += (int)(*p);

p++;

}

return addr%(int)(total_rec_num*COLLISIONFACTOR);

}

int checkHashFileFull(int fd)

{

struct HashFileHeader hfh;

readHashFileHeader(fd,&hfh);

if(hfh.current_rec_num

return 0;

else

return 1;

}

int readHashFileHeader(int fd,struct HashFileHeader *hfh)

{

lseek(fd,0,SEEK_SET);

return read(fd,hfh,sizeof(struct HashFileHeader));

}

//jtRecord.h

#define RECORDLEN 32

struct jtRecord

{

int key;

char other[RECORDLEN-sizeof(int)];

};

#ifdef HAVE_CONFIG_H

#include

#endif

//jtRecord.c

#ifdef HAVE_CONFIG_H

#include

#endif

#include

#include

#include

#include

#include

#include

#include"HashFile.h"

#include"jtRecord.h"

#define KEYOFFSET 0

#define KEYLEN sizeof(int)

#define FileNAME "jing.hash"

void showHashFile();

int main(int argc,char *argv[])

{

struct jtRecord rec[6] = {

{1,"jing"},{2,"wang"},{3,"li"},

{4,"zhang"},{5,"qing"},{6,"yuan"}

};

int j=0;

for(j=0;j<6;j++)

{

printf("<%d,%d>\t",rec[j].key,hash(KEYOFFSET,KEYLEN,&rec[j],6));

}

int fd = hashfile_creat(FileNAME,O_RDWR|O_CREAT,RECORDLEN,6);

int i=0;

printf("\nOpen and Save Record...\n");

fd = hashfile_open(FileNAME,O_RDWR,0);

for(i=0;i<6;i++)

{

hashfile_saverec(fd,KEYOFFSET,KEYLEN,&rec[i]);

}

hashfile_close(fd);

showHashFile();

//Demo find Rec

printf("\nFind Record...");

fd = hashfile_open(FileNAME,O_RDWR,0);

int offset = hashfile_findrec(fd,KEYOFFSET,KEYLEN,&rec[4]);

printf("\noffset is %d\n",offset);

hashfile_close(fd);

struct jtRecord jt;

struct CFTag tag;

fd = open(FileNAME,O_RDWR);

lseek(fd,offset,SEEK_SET);

read(fd,&tag,sizeof(struct CFTag));

printf("Tag is <%d,%d>\t",tag.collision,tag.free);

read(fd,&jt,sizeof(struct jtRecord));

printf("Record is {%d,%s}\n",jt.key,jt.other);

//Demo Delete Rec

printf("\nDelete Record...");

fd = hashfile_open(FileNAME,O_RDWR,0);

hashfile_delrec(fd,KEYOFFSET,KEYLEN,&rec[2]);

hashfile_close(fd);

showHashFile();

//Demo Read

fd = hashfile_open(FileNAME,O_RDWR,0);

char buf[32];

memcpy(buf,&rec[1],KEYLEN);

hashfile_read(fd,KEYOFFSET,KEYLEN,buf);

printf("\nRead Record is {%d,%s}\n",

((struct jtRecord *)buf)->key,((struct jtRecord *)buf)->other);

hashfile_close(fd);

//Demo Write

printf("\nWrite Record...");

fd = hashfile_open(FileNAME,O_RDWR,0);

hashfile_write(fd,KEYOFFSET,KEYLEN,&rec[3]);

hashfile_close(fd);

showHashFile();

return 0;

}

void showHashFile()

{

int fd;

printf("\n");

fd = open(FileNAME,O_RDWR);

lseek(fd,sizeof(struct HashFileHeader),SEEK_SET);

struct jtRecord jt;

struct CFTag tag;

while(1)

{

if(read(fd,&tag,sizeof(struct CFTag))<=0)

break;

printf("Tag is <%d,%d>\t",tag.collision,tag.free);

if(read(fd,&jt,sizeof(struct jtRecord))<=0)

break;

printf("Record is {%d,%s}\n",jt.key,jt.other);

}

close(fd);

}

六、实验结果

七、实验小结

编译成功后，要在管理员权限下运行，因为程序要运行文件的系统调用（create、write等）