--- /dev/null
+#include <sys/vfs.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include "rfs_assert.h"
+#include "profile.h"
+#define MKDIR 1
+#define RMDIR 2
+#define CREATE 3
+#define REMOVE 4
+#define WRITE 5
+#define TRUNCATE 6
+
+#define MAX_FILES 100000
+#define MAX_DIRS 100000
+#define FILE_FH_HTABLE_SIZE MAX_FILES
+#define MAX_NAMELEN 256
+#define MAX_PLAY_PATH_SIZE 256
+#define MAX_COMMAND_LEN (MAX_PLAY_PATH_SIZE+16)
+#define NFS_MAXDATA 32768
+#define TRACE_FH_SIZE 64
+
+#define FH_T_FLAG_FREE 0
+#define FH_T_FLAG_IN_USE 1
+#define IS_FILE 0
+#define IS_DIR 1
+#define NOT_EXIST 0
+#define EXIST 1
+
+typedef struct {
+ char flag;
+ //char trace_fh [TRACE_FH_SIZE+1];
+ char path[MAX_PLAY_PATH_SIZE];
+} fh_t;
+
+typedef struct {
+ char name[32];
+ fh_t * fh;
+ //struct generic_entry * htable;
+ int fh_size;
+ int fh_max;
+ int index;
+ //int htable_size;
+} fh_info_t;
+
+fh_info_t file_fh, dir_fh;
+profile_t read_line_profile, fgets_profile;
+char trace_file[MAX_NAMELEN];
+FILE * profile_fp = NULL;
+char testdir[MAX_NAMELEN];
+
+int age_create_num = 0;
+int age_mkdir_num = 0;
+int assure_create_num = 0;
+int assure_mkdir_num = 0;
+int age_write_num = 0;
+int nonage_write_num = 0;
+int overlap_write_num = 0;
+
+int init_profile_variables()
+{
+ init_profile ("read_line profile", &read_line_profile);
+ init_profile ("fgets profile", &fgets_profile);
+}
+
+int init_fh_info (char * name, fh_info_t * fh_infop, int fh_size, int htable_size)
+{
+ RFS_ASSERT (strlen(name) < sizeof(fh_infop->name));
+ strcpy (fh_infop->name, name);
+ fh_infop->fh_max = 0;
+ fh_infop->index = 0;
+ fh_infop->fh_size = fh_size;
+ //fh_infop->htable_size = htable_size;
+ fh_infop->fh = (fh_t *)malloc (sizeof(fh_t)*fh_size);
+ RFS_ASSERT (fh_infop->fh);
+ //fh_infop->htable = malloc (sizeof(struct*generic_entry)*htable_size);
+ //RFS_ASSERT (fh_infop->htable);
+ printf("initialize %s size %d bytes\n",
+ //name, sizeof(fh_t)*fh_size + sizeof(struct*generic_entry)*htable_size);
+ name, sizeof(fh_t)*fh_size);
+}
+
+int init()
+{
+ init_fh_info ("file_fh", &file_fh, MAX_FILES, MAX_FILES);
+ init_fh_info ("dir_fh", &dir_fh, MAX_DIRS, MAX_DIRS);
+}
+
+int add_fh_t (fh_info_t * fh_table, char * path, int exist_flag)
+{
+ int i;
+
+ for (i=0; i<fh_table->fh_size; i++,fh_table->index++) {
+ if (fh_table->index==fh_table->fh_size)
+ fh_table->index = 0;
+ if (fh_table->fh[fh_table->index].flag == FH_T_FLAG_FREE) {
+ fh_table->fh[fh_table->index].flag = FH_T_FLAG_IN_USE;
+ //RFS_ASSERT(strlen(path)<MAX_PLAY_PATH_SIZE);
+ strcpy (fh_table->fh[fh_table->index].path, path);
+ if (fh_table->index > fh_table->fh_max)
+ fh_table->fh_max = fh_table->index;
+ return 0;
+ }
+ }
+ //print_fh_map(fh_table);
+ RFS_ASSERT (0);
+}
+
+int create_mkdir_op (int flag)
+{
+ static int fhno = 0;
+ char name[MAX_NAMELEN];
+ char command[MAX_COMMAND_LEN];
+ int i;
+ int fd;
+ int count = 0;
+ fh_info_t * fh_infop;
+
+ while (count++ < 100) {
+ i = random()%dir_fh.fh_max;
+ if (dir_fh.fh[i].flag==FH_T_FLAG_IN_USE) {
+ assure_exist(dir_fh.fh[i].path);
+ strcpy (name, dir_fh.fh[i].path);
+ if (flag == IS_FILE) {
+ sprintf (name+strlen(name), "AGEfile%d", fhno++);
+ fd = creat (name, S_IRWXU);
+ age_create_num++;
+ //printf ("create fd %d\n", fd);
+ close(fd);
+ fh_infop = &file_fh;
+ } else {
+ sprintf (name+strlen(name), "AGEdir%d", fhno++);
+ fd = mkdir (name, S_IRWXU);
+ age_mkdir_num++;
+ fh_infop = &dir_fh;
+ }
+ if (fd == -1) {
+ perror("");
+ if (errno == ENOENT) {
+ dir_fh.fh[i].flag = FH_T_FLAG_FREE;
+ continue;
+ } else
+ RFS_ASSERT (0);
+ }
+ add_fh_t (fh_infop, name, EXIST);
+ RFS_ASSERT (fd >=0);
+ return 0;
+ }
+ };
+ return -1;
+}
+
+int remove_op ()
+{
+ int i;
+ int count = 0;
+ int ret;
+
+ while (count++<100) {
+ i = random()%file_fh.fh_max;
+ if (file_fh.fh[i].flag == FH_T_FLAG_IN_USE) {
+/*
+ if (!strstr(file_fh.fh[i].path, "AGE"))
+ continue;
+*/
+ assure_exist(file_fh.fh[i].path);
+ ret = remove (file_fh.fh[i].path);
+ RFS_ASSERT (ret ==0);
+ file_fh.fh[i].flag = FH_T_FLAG_FREE;
+ return 0;
+ }
+ }
+ return -1;
+}
+
+int rmdir_op()
+{
+ int i;
+ int count=0;
+ char command[MAX_COMMAND_LEN];
+ int ret;
+
+ while (count++<100) {
+ i = random()%dir_fh.fh_max;
+ if ( (dir_fh.fh[i].flag == FH_T_FLAG_IN_USE) ) {
+/*
+ if (!strstr(file_fh.fh[i].path, "AGE"))
+ continue;
+*/
+ assure_exist(file_fh.fh[i].path);
+ ret = rmdir (dir_fh.fh[i].path);
+ if (ret == 0) {
+ dir_fh.fh[i].flag = FH_T_FLAG_FREE;
+ return 0;
+ }
+ RFS_ASSERT ((ret == -1) && (errno == ENOTEMPTY));
+ //strcpy (command, "rm -r %s", dir_fh.fh[i].path);
+ //system (command);
+ }
+ }
+ return -1;
+}
+
+int loop_write (int fd, char * buf, int buflen)
+{
+ int ret;
+ int pos = 0;
+
+ while (1) {
+ ret = write (fd, buf+pos, buflen-pos);
+
+ if (ret == -1) {
+ perror ("loop write");
+ exit (-1);
+ }
+ if (ret == buflen-pos)
+ break;
+ pos += ret;
+ }
+ return 0;
+}
+
+int assure_exist(char * path)
+{
+ char name[MAX_NAMELEN];
+ int ret;
+ char *p, *q;
+ int non_exist_flag = 0;
+ int count=0;
+ struct stat st;
+
+ ret = stat (path, &st);
+ if (ret == 0)
+ return 0;
+ RFS_ASSERT (errno == ENOENT);
+
+ RFS_ASSERT (!strstr (path, "AGE"));
+ p = path;
+ q = name;
+ while (count++<100) {
+ for (; *p!=0 && *p!='/'; p++, q++ )
+ *q = *p;
+ *q = 0;
+ ret = stat (name, &st);
+ if (ret == -1) {
+ RFS_ASSERT (errno == ENOENT)
+ if ((*p)==0) {
+ ret = creat (name, S_IRWXU);
+ assure_create_num ++;
+ RFS_ASSERT (ret >=0);
+ close(ret);
+ } else {
+ ret = mkdir (name, S_IRWXU);
+ assure_mkdir_num ++;
+ RFS_ASSERT (ret >=0);
+ }
+ }
+ if ((*p)=='/') {
+ *q = '/';
+ p++; q++;
+ } else {
+ RFS_ASSERT ((*p)==0)
+ return 0;
+ }
+ }
+ RFS_ASSERT (0);
+}
+
+int write_op (int off, int size)
+{
+ static char buf[NFS_MAXDATA];
+ int i;
+ int count=0;
+ int fd;
+ int ret;
+ struct stat st;
+
+ RFS_ASSERT (size <= NFS_MAXDATA);
+ while (count++<100) {
+ i = random()%file_fh.fh_max;
+ if ( (file_fh.fh[i].flag == FH_T_FLAG_IN_USE) ) {
+ assure_exist(file_fh.fh[i].path);
+ fd = open(file_fh.fh[i].path, O_WRONLY);
+ if (fd == -1)
+ perror("");
+ //else
+ //printf ("write fd %d\n", fd);
+ RFS_ASSERT (fd!=-1);
+ fstat (fd, &st);
+ if (st.st_size < (off+size)) {
+ int written_bytes = 0;
+ while (written_bytes+NFS_MAXDATA < off+size-st.st_size) {
+ loop_write (fd, buf, NFS_MAXDATA);
+ written_bytes += NFS_MAXDATA;
+ }
+ loop_write (fd, buf, off+size-st.st_size-written_bytes);
+ if (strstr(file_fh.fh[i].path, "AGE")) {
+ age_write_num+=(written_bytes+NFS_MAXDATA-1)/NFS_MAXDATA;
+ } else
+ nonage_write_num+=(written_bytes+NFS_MAXDATA-1)/NFS_MAXDATA;
+ } else
+ overlap_write_num++;
+/*
+ if (strstr(file_fh.fh[i].path, "AGE")) {
+ age_write_num++;
+ } else
+ nonage_write_num++;
+ loop_write (fd, buf, size);
+*/
+ close(fd);
+ return 0;
+ };
+ }
+ return -1;
+}
+
+int truncate_op(int size)
+{
+ int i;
+ int count=0;
+ int ret;
+
+ while (count++<100) {
+ i = random()%file_fh.fh_max;
+ if ( (file_fh.fh[i].flag == FH_T_FLAG_IN_USE) ) {
+/*
+ if (!strstr(file_fh.fh[i].path, "AGE"))
+ continue;
+*/
+ assure_exist (file_fh.fh[i].path);
+ ret = truncate(file_fh.fh[i].path, size);
+ if (ret ==0)
+ return 0;
+ RFS_ASSERT (errno == ENOENT);
+ file_fh.fh[i].flag = FH_T_FLAG_FREE;
+ continue;
+ }
+ };
+ return -1;
+}
+
+int print_fh_map(fh_info_t * fhp)
+{
+ int i;
+ int num = 0;
+ for (i=0; i<fhp->fh_max; i++) {
+ if (fhp->fh[i].flag == FH_T_FLAG_IN_USE) {
+ num ++;
+ printf("%s[%d] %s\n", fhp->name, i, fhp->fh[i].path);
+ }
+ }
+ fprintf(stderr, "fh_max %d total %d entries \n", fhp->fh_max, num);
+}
+
+void read_fh_map(char * fh_map_file)
+{
+ FILE * fp;
+ int i = 0;
+ char buf[1024];
+ char trace_fh[TRACE_FH_SIZE];
+ char intbuf[9];
+ char * trace_path;
+ char * p;
+ int map_flag;
+ int lineno = 0;
+ int fh_map_debug =0;
+ char name[MAX_NAMELEN];
+
+ fp = fopen(fh_map_file, "r");
+ if (!fp) {
+ printf ("can not opern %s\n", fh_map_file);
+ perror("open");
+ exit (0);
+ }
+ RFS_ASSERT (fp!=NULL);
+
+ intbuf[8]=0;
+
+ memset(buf, 0, sizeof(buf));
+ while (fgets(buf, 1024, fp)) {
+ RFS_ASSERT (fh_map_debug==0);
+ lineno ++;
+ if (lineno % 10000==0)
+ printf("%d fh_map entry read\n", lineno);
+
+ RFS_ASSERT (buf[strlen(buf)-1]=='\n');
+ buf[strlen(buf)-1]=0;
+
+ trace_path = buf + TRACE_FH_SIZE +1;
+
+ strcpy (name, testdir);
+ strcat (name, trace_path);
+ if ((*(buf+strlen(buf)-1))=='/') {
+ *(buf+strlen(buf)-1)=0;
+ add_fh_t (&dir_fh, name, NOT_EXIST);
+ } else {
+ add_fh_t (&file_fh, name, NOT_EXIST);
+ }
+ }
+
+ fclose(fp);
+ if (fh_map_debug) {
+ print_fh_map (&file_fh);
+ print_fh_map (&dir_fh);
+ }
+}
+
+int print_usage()
+{
+ printf("age trace_file fh_path_map testdir\n");
+}
+
+inline char * read_line (int disk_index)
+{
+ static FILE * fp=NULL;
+ static int start=0;
+ static int start_disk_index=0;
+ int i;
+ static int finish_flag = 0;
+
+#define READ_LINE_BUF_SIZE 1000
+#define READ_LINE_LENGTH 32
+
+ static char line_buf[READ_LINE_BUF_SIZE][READ_LINE_LENGTH];
+ start_profile (&read_line_profile);
+
+ if (fp==NULL) {
+ if (strcmp(trace_file, "stdin")) {
+ fp = fopen(trace_file, "r");
+ if (!fp) {
+ printf("can not open files %s\n", fp);
+ perror("open");
+ }
+ } else {
+ fp = stdin;
+ }
+ RFS_ASSERT (fp!=NULL);
+ for (i=0; i<READ_LINE_BUF_SIZE; i++) {
+ start_profile(&fgets_profile);
+ if (!fgets(line_buf[i], READ_LINE_LENGTH, fp)) {
+ RFS_ASSERT (0);
+ }
+ end_profile(&fgets_profile);
+ //printf ("read_line, line_buf[%d]:%s", i, line_buf[i]);
+ }
+ }
+
+ RFS_ASSERT (disk_index <= start_disk_index+READ_LINE_BUF_SIZE)
+ if (disk_index==(start_disk_index+READ_LINE_BUF_SIZE)) {
+ if (finish_flag) {
+ return NULL;
+ }
+ start_profile(&fgets_profile);
+ if (!fgets(line_buf[start], READ_LINE_LENGTH, fp)) {
+ end_profile(&fgets_profile);
+ fclose(fp);
+ finish_flag = 1;
+ return NULL;
+ }
+ end_profile(&fgets_profile);
+ //printf ("read_line, line_buf[%d]:%s", start, line_buf[start]);
+ start = (start+1) % READ_LINE_BUF_SIZE;
+ start_disk_index ++;
+ }
+ RFS_ASSERT (disk_index < start_disk_index+READ_LINE_BUF_SIZE)
+ i = (start+disk_index-start_disk_index)%READ_LINE_BUF_SIZE;
+
+ end_profile (&read_line_profile);
+ return (line_buf[i]);
+}
+
+int f()
+{};
+
+int print_result()
+{
+ struct statfs stfs;
+ int ret;
+ ret = statfs (testdir, &stfs);
+ RFS_ASSERT (ret == 0);
+ fprintf(stderr, "number of files %d size of file system %d\n", stfs.f_files, stfs.f_bfree);
+ fprintf(stderr, "assure_create_num %d assure_mkdir_num %d, age_create_num %d age_mkdir_num %d age_write_num %d nonage_write_num %d overlap_write_num %d\n",
+ assure_create_num, assure_mkdir_num, age_create_num, age_mkdir_num, age_write_num, nonage_write_num, overlap_write_num);
+ printf("assure_create_num %d assure_mkdir_num %d, age_create_num %d age_mkdir_num %d age_write_num %d nonage_write_num %d overlap_write_num %d\n",
+ assure_create_num, assure_mkdir_num, age_create_num, age_mkdir_num, age_write_num, nonage_write_num, overlap_write_num);
+}
+
+int main(int argc, char ** argv)
+{
+ char * buf;
+ static int disk_index=0;
+ int j, nfs3proc, size, off, count;
+ char procname[16];
+ struct stat st;
+ int ret;
+
+ if (argc!=4) {
+ print_usage();
+ exit(0);
+ }
+
+ init();
+ strcpy (trace_file, argv[1]);
+ strcpy (testdir, argv[3]);
+ ret = stat (testdir, &st);
+ RFS_ASSERT (ret == 0);
+ read_fh_map(argv[2]);
+ init_profile_variables();
+
+ while ((buf=read_line(++disk_index))!=NULL) {
+
+ memset (procname, 0, sizeof(procname));
+ //printf ("line[%d] %s", disk_index, buf);
+ sscanf (&buf[0], "%s", procname);
+ j = 0;
+ while ((*(buf+j)!=' ') && (*(buf+j)!='\n'))
+ j++;
+ j++;
+ if (!strcmp(procname, "write"))
+ sscanf (&buf[j], "off %x count %x", &off, &count);
+
+ if (!strcmp(procname, "setattr"))
+ sscanf (&buf[j], "size %x", &size);
+
+ if (!strcmp(procname, "write"))
+ ret = write_op(off, count);
+ else if (!strcmp(procname, "create"))
+ ret = create_mkdir_op(IS_FILE);
+ else if (!strcmp(procname, "mkdir"))
+ ret = create_mkdir_op(IS_DIR);
+ else if (!strcmp(procname, "remove"))
+ ret = remove_op();
+ else if (!strcmp(procname, "rmdir"))
+ ret = rmdir_op();
+ else if (!strcmp(procname, "setattr"))
+ ret = truncate_op(size);
+ else {
+ printf("disk_index %d procname %s\n", disk_index, procname);
+ RFS_ASSERT (0);
+ }
+ if (ret!=0) {
+ printf("execute disk_line[%d] %s error\n", disk_index, buf);
+ }
+ if ((disk_index%100)==0) {
+ fprintf (stderr, "%d disk trace parsed \n", disk_index);
+ print_result();
+ }
+ }
+ print_result();
+}
projects / bluesky.git / blobdiff