/* rfs_age_unit_base.c */
#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 512
#define MAX_PLAY_PATH_SIZE 1024
#define MAX_COMMAND_LEN (MAX_PLAY_PATH_SIZE+16)
#define NFS_MAXDATA 4096
//#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 EXIST 0
#define NON_EXIST 1
#define COMPLETE 3
#define ACTIVE 0
#define INACTIVE 1
#define DONT_CARE 2
#define FILE_RATIO 50
#define DISK_FRAGMENT_SIZE 4096
//#define FRAGMENT_NUM 5
//#define MIN_WRITE_SIZE 512
//#define MIN_WRITE_SIZE 2000000000

static char ftypename[3][32] = {"FILE", "DIR", "FTYPE_DONT_CARE"};
static char activename[3][32] = {"ACTIVE", "INACTIVE", "ACTIVE_DONT_CARE"};
static char existname[4][32] = {"EXIST", "NON_EXIST", "EXIST_DONT_CARE", "COMPLETE"};

typedef struct {
    char flag;
	char ftype;
	char exist_flag;
	int psfh;
	int size;
	int cur_size;
    //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 active_fh_max;
	//int index;
	//int htable_size;
} fh_info_t;

fh_info_t obj_fh;
profile_t read_line_profile, fgets_profile;
char trace_file[MAX_NAMELEN];
FILE * profile_fp = NULL;
char testdir[MAX_NAMELEN];

int active_obj_num = 0;
int exist_active_obj_num = 0;
static int active_file_num = 0, active_dir_num =0, age_file_num = 0, age_dir_num = 0;

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 rfs_debug = 0;


int ACTIVE_RATIO;
int FRAGMENT_NUM;
int MIN_WRITE_SIZE = 512;

int aging_dirs ()
{

}


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)
{
	int i;

	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);

	for (i=0; i<fh_size; i++)
		fh_infop->fh[i].flag = FH_T_FLAG_FREE;
}

int init()
{
//	init_fh_info ("file_fh", &file_fh, MAX_FILES, MAX_FILES);
//	init_fh_info ("dir_fh", &dir_fh, MAX_DIRS, MAX_DIRS);
	init_fh_info ("obj_fh", &obj_fh, MAX_FILES+MAX_DIRS, MAX_FILES+MAX_DIRS);
}

int add_fh_t (fh_info_t * fh_table, char * path, int sfh, int psfh, int size, int ftype, int exist_flag, int active_flag)
{
	int i;

	RFS_ASSERT (sfh >0);

	if (active_flag == ACTIVE)
		active_obj_num ++;
	else
		RFS_ASSERT (sfh >= fh_table->active_fh_max);

	if (rfs_debug)
		printf ("add to %s path %s sfh %d size %d %s %s %s\n", fh_table->name, path, sfh, size, 
		ftypename[ftype], existname[exist_flag], activename[active_flag]);

	RFS_ASSERT ( (sfh>=0) && (sfh<fh_table->fh_size) );
	RFS_ASSERT (fh_table->fh[sfh].flag==FH_T_FLAG_FREE);
	fh_table->fh[sfh].flag = FH_T_FLAG_IN_USE;
	if (sfh >= fh_table->fh_max)
		fh_table->fh_max = sfh+1;
	strcpy (fh_table->fh[sfh].path, path);
	fh_table->fh[sfh].psfh = psfh;
	fh_table->fh[sfh].size = size;
	fh_table->fh[sfh].cur_size = 0;
	fh_table->fh[sfh].ftype = ftype;
	fh_table->fh[sfh].exist_flag = exist_flag;
	if (active_flag == ACTIVE) {
		if (ftype == IS_FILE)
			active_file_num ++;
		else {
			RFS_ASSERT (ftype== IS_DIR);
			active_dir_num ++;
		}
	} else {
		if (ftype == IS_FILE)
			age_file_num ++;
		else {
			RFS_ASSERT (ftype== IS_DIR);
			age_dir_num ++;
		}
	}
	//print_fh_map(fh_table);
}


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) {
			printf ("fd %d\n", fd);
            perror ("loop write");
            exit (-1);
        }
        if (ret == buflen-pos)
            break;
        pos += ret;
    }
    return 0;
}

int assure_exist(int sfh, char * path, int ftype_flag)
{
	char name[MAX_NAMELEN];
	int ret;
	char *p, *q;
	int non_exist_flag = 0;
	int count=0;
	struct stat st;

	if (rfs_debug)
		printf("assure_exist %s\n", path);

	ret = stat (path, &st);
	if (ret == 0)
		return 0;
	RFS_ASSERT (errno == ENOENT);
	
	p = path;
	q = name;
	if (*p=='/') {
		*q='/';
		p++;
		q++;
	}
	while (count++<100) {
		/* copy the next component from path to name */
		for (; *p!=0 && *p!='/'; p++, q++ ) 
			*q = *p;
		*q = 0;
		ret = stat (name, &st);
		if (ret == -1) {
			RFS_ASSERT (errno == ENOENT)
			if ((*p)==0 && (ftype_flag==IS_FILE)) {
				ret = creat (name, S_IRWXU);
				if (ret == -1)
					perror (name);
				RFS_ASSERT (ret >=0);
				assure_create_num ++;
				if (rfs_debug)
					printf("sfh %d create %s\n", sfh, name);
				close(ret);
			} else {
				ret = mkdir (name, S_IRWXU);
				assure_mkdir_num ++;
				if (rfs_debug) {
					if (*p==0) 
						printf("sfh %d mkdir %s\n", sfh, name);
					else
						printf("sfh %d middle mkdir %s\n", sfh, name);
				}
				RFS_ASSERT (ret >=0);
			}
		}
		if ((*p)=='/') {
			*q = '/';
			p++; q++;
		} else {
			RFS_ASSERT ((*p)==0)
			return 0;
		}
	}
	RFS_ASSERT (0);
}


int print_fh_map(fh_info_t * fhp)
{
	int i;
	int num = 0;
	int active_obj_num = 0;


	for (i=0; i<fhp->fh_max; i++) {
		if (fhp->fh[i].flag == FH_T_FLAG_IN_USE) {
			num ++;
			if (i < fhp->active_fh_max)
				active_obj_num++;

			if (rfs_debug)
				printf("%s[%d] %s %s %s\n", fhp->name, i, fhp->fh[i].path, ftypename[fhp->fh[i].ftype], existname[fhp->fh[i].exist_flag]);
		}
	}
	fprintf(stderr, "fh_max %d active_fh_max %d, in_use_num %d entries active_obj_num %d \n", fhp->fh_max, fhp->active_fh_max, num, active_obj_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];
	int sfh;

	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 (rfs_debug)
			printf ("line %d %s", lineno, buf);
		if (lineno % 10000==0)
			printf("%d fh_map entry read\n", lineno);

		sfh = 0;
		if (!strncmp(buf, "::DIR ", strlen("::DIR "))) {
			strcpy (name, testdir);
			if (buf[6]=='/') {
				sscanf(buf, "::DIR %s %d\n", name+strlen(name), &sfh);
				add_fh_t (&obj_fh, name, sfh, -1, -1, IS_DIR, NON_EXIST, ACTIVE);
			} else { 
				RFS_ASSERT (!strncmp(buf,"::DIR Fake 1\n", strlen("::DIR Fake 1\n")));
				sfh = 1;
				add_fh_t (&obj_fh, name, sfh, -1, -1, IS_DIR, EXIST, ACTIVE);
				exist_active_obj_num ++;
			}
		} else {
			char * p;
			int psfh, sfh, size;
			char filename[MAX_NAMELEN];

			if (!strncmp(buf, "::TBDIR", strlen("::TBDIR"))) 
				continue; 

			p = strstr(buf, "parent");
			RFS_ASSERT (p);
			sscanf(p, "parent %d\n", &psfh);
			RFS_ASSERT (obj_fh.fh[psfh].flag == FH_T_FLAG_IN_USE);
			p = strstr(p, "name");
			RFS_ASSERT (p);
			if (!strncmp(p, "name xx", strlen("name xx"))) {
				sscanf(p, "name xx-%s sfh %d size %x", filename, &sfh, &size);
				//printf ("name xx-%s sfh %d\n", filename, sfh);
			} else {
				sscanf(p, "name \"%s sfh %d size %x", filename, &sfh, &size);
				//printf ("name %s sfh %d\n", filename, sfh);
				filename[strlen(filename)-1]=0;
			}
			strcpy (name, obj_fh.fh[psfh].path);	
			strcat (name, "/");
			strcat (name, filename);
			add_fh_t (&obj_fh, name, sfh, psfh, size, IS_FILE, NON_EXIST, ACTIVE);
		}
	}
			
	fclose(fp);
	obj_fh.active_fh_max  = obj_fh.fh_max;
	if (fh_map_debug) {
		print_fh_map (&obj_fh);
	}
}

int print_usage()
{
	printf("agefs ACTIVE_RATIO FRAGMENT_NUM fh_path_map testdir\n");
	printf("Note: if populate_scale is 4, the total active file size is 1GB\n");
	printf("      then the total initial file system size is about 4GB\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;
	static struct statfs first_stfs;
	static int first_entry = 1;

	ret = statfs (testdir, &stfs);
	RFS_ASSERT (ret == 0);
	if (first_entry) {
		first_entry = 0;
		first_stfs = stfs;
	}

	fprintf(stderr, "active_file_num %d active_dir_num %d age_file_num %d age_dir_num %d\n",
		active_file_num, active_dir_num, age_file_num, age_dir_num);
	fprintf(stderr, "number of used file nodes %d, used (4K) blocks in fs %d (%d MB)\n", first_stfs.f_ffree-stfs.f_ffree, first_stfs.f_bfree - stfs.f_bfree, (first_stfs.f_bfree-stfs.f_bfree)/(1000000/4096));
	fprintf(stderr, "assure_create_num %d assure_mkdir_num %d\n", assure_create_num, assure_mkdir_num);
}

typedef struct {
    int     pcnt;       /* percentile */
    int     size;       /* file size in KB */
} sfs_io_file_size_dist;

sfs_io_file_size_dist Default_file_size_dist[] = {
    /* percentage   KB size */
    {    94,     64},           /*  4% */
    {    97,    128},           /*  3% */
#ifdef notdef
    {    33,      1},           /* 33% */
    {    54,      2},           /* 21% */
    {    67,      4},           /* 13% */
    {    77,      8},           /* 10% */
    {    85,     16},           /*  8% */
    {    90,     32},           /*  5% */
    {    94,     64},           /*  4% */
    {    97,    128},           /*  3% */
#endif
    {    99,    256},           /*  2% */
    {   100,   1024},           /*  1% */
    {     0,      0}
};

/*
 * For a value between 0-99, return a size based on distribution
 */
static int
get_file_size()
{
	static file_array_initialized = 0;
	static int file_size_array[100];
	int i;

	i = random() % 100;

    if (i < 0 || i > 99)
    return (0);

    if (file_array_initialized == 0) {
	    int j, k;
    	for (j = 0, k = 0; j < 100; j++) {
        	if (j >= Default_file_size_dist[k].pcnt &&
            	Default_file_size_dist[k + 1].size != 0)
    	    k++;
        	file_size_array[j] = Default_file_size_dist[k].size * 1024;
    	}
    	file_array_initialized++;
    }
    return (file_size_array[i]);
}

int range_random(int min, int max)
{
	int i;
	i = random()%(max-min) + min;
	return i;
}

/* answer 1 with a probability of percent/100 */
int decide(int percent)
{
	int i = random()%100;
	if (i<percent)
		return 1;
	else
		return 0;
}

int select_obj (fh_info_t * fhp, int ftype, int exist_flag, int active_flag)
{
	int i;
	int min, max;
	int sfh, count = 0;

	//printf ("select_obj %s %s %s\n", ftypename[ftype], existname[exist_flag], activename[active_flag]);
	if (active_flag == ACTIVE) {
		sfh = range_random (0, fhp->active_fh_max);
		for (i=0; i<fhp->active_fh_max; i++) {
			if ((fhp->fh[sfh].flag == FH_T_FLAG_IN_USE) &&
				((ftype==DONT_CARE) || (ftype ==fhp->fh[sfh].ftype)) &&
				((exist_flag==DONT_CARE) || (fhp->fh[sfh].exist_flag == exist_flag))) 
				return sfh;
			sfh = (sfh+1) % fhp->active_fh_max;
		}
	} else {
		RFS_ASSERT (active_flag == DONT_CARE);
		RFS_ASSERT (exist_flag == EXIST);
		sfh = range_random (0, fhp->fh_max);
		for (i=0; i<fhp->fh_max; i++) {
			if ((fhp->fh[sfh].flag == FH_T_FLAG_IN_USE) &&
			    ((ftype==DONT_CARE) || (fhp->fh[sfh].ftype == ftype)) &&
				(fhp->fh[sfh].exist_flag == EXIST)) {
				return sfh;
			}
			sfh = (sfh+1) % fhp->fh_max;
		}
	}
	return -1;

	print_fh_map(&obj_fh);
	printf ("active_obj_num %d exist_active_obj_num %d \n", active_obj_num, exist_active_obj_num);
	printf ("failed select_obj %s %s\n", ftypename[ftype], activename[active_flag]);
	RFS_ASSERT (0);
}

/* append "size" to file "path" */
int append_file (int sfh, char * path, int size)
{
	int fd;
	int written_bytes = 0;
	static char buf[NFS_MAXDATA];

	if (rfs_debug)
		printf ("sfh %d append_file %s size %d\n", sfh, path, size);

	fd = open (path, O_WRONLY|O_APPEND);
	if (fd==-1)
		perror(path);
	RFS_ASSERT (fd > 0);
	
	while (written_bytes+NFS_MAXDATA < size) {
		loop_write (fd, buf, NFS_MAXDATA);
		written_bytes += NFS_MAXDATA;
	}
	loop_write (fd, buf, size-written_bytes);
	close(fd);
}

int get_write_size (int target_size, int cur_size)
{
	int i;
	if (target_size - cur_size < MIN_WRITE_SIZE)
		return (target_size - cur_size);

	/* target_size/FRAGMENT_NUM would be the average value of i */
	if (target_size < FRAGMENT_NUM) {
		i = MIN_WRITE_SIZE;
	} else {
		i = random() % (2*(target_size/FRAGMENT_NUM));
		if (i < MIN_WRITE_SIZE)
			i = MIN_WRITE_SIZE;
	}
	if (i > (target_size - cur_size))
		i = target_size - cur_size;

	return i;
}

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;
	int i;
	int ftype_flag = 0, active_flag = 0;
	char name[MAX_PLAY_PATH_SIZE];	
	int sfh, psfh;

	if (argc!=5) {
		print_usage();
		exit(0);
	}

	init();
	ACTIVE_RATIO = atoi(argv[1]);
	FRAGMENT_NUM = atoi(argv[2]);
	if (FRAGMENT_NUM==0)
		MIN_WRITE_SIZE = 2000000000;
	else
		MIN_WRITE_SIZE = DISK_FRAGMENT_SIZE;

	strcpy (testdir, argv[4]);
	ret = stat (testdir, &st);
	if ((ret == -1) && (errno==ENOENT)) {
		ret = mkdir (testdir, S_IRWXU);
	}
	RFS_ASSERT (ret >= 0);
	read_fh_map(argv[3]);
	print_fh_map(&obj_fh);
	init_profile_variables();

/* NOTE: should have put file and directories in one table */

	for (i=0; exist_active_obj_num < active_obj_num; i++) {

		if ((i!=0) && ((i%1000)==0)) {
			fprintf (stderr, "\n%d object created \n", i);
			print_result();
		}

		/* decide on the exact active obj or populated obj */
		if (decide(ACTIVE_RATIO)) {
			sfh = select_obj (&obj_fh, DONT_CARE, NON_EXIST, ACTIVE);
			if (sfh == -1)
				break;

			obj_fh.fh[sfh].exist_flag = EXIST;
			exist_active_obj_num ++;
			ftype_flag = obj_fh.fh[sfh].ftype;
			size = obj_fh.fh[sfh].size;

/*
			{
				int tmpfh = sfh;
			  	while (obj_fh.fh[--tmpfh].exist_flag == NON_EXIST) {
					if (strstr(obj_fh.fh[sfh].path, obj_fh.fh[tmpfh].path)) {
						obj_fh.fh[tmpfh].exist_flag = EXIST;
						//printf ("set %s to exist due to %s\n", obj_fh.fh[tmpfh].path, obj_fh.fh[sfh].path);
						exist_active_obj_num ++;
					}
				}	
			}
*/
		} else {
			psfh = select_obj (&obj_fh, IS_DIR, EXIST, DONT_CARE);
			strcpy (name, obj_fh.fh[psfh].path);
			sfh = obj_fh.fh_max;
			sprintf(name+strlen(name), "/AGE%d", obj_fh.fh_max); 

			/* decide next obj is file or directory */
			if (decide(FILE_RATIO)) {
				ftype_flag = IS_FILE;
				size = get_file_size();
			} else {
				ftype_flag = IS_DIR;
				size = -1;
			}
			add_fh_t (&obj_fh, name, sfh, psfh, size, ftype_flag, EXIST, INACTIVE);

		}

		/* make sure/create the  obj pathname on disk */
		assure_exist (sfh, obj_fh.fh[sfh].path, ftype_flag);
		/* write file to sizes according certain distribution 
		if (ftype_flag == IS_FILE) 
			append_file (obj_fh.fh[sfh].path, obj_fh.fh[sfh].size);
		*/

	}

	i = 0;
	printf ("start writing files\n");
	while (1) {
		int write_size;
		sfh = select_obj (&obj_fh, IS_FILE, EXIST, DONT_CARE);
		if (sfh == -1)
			break;
		write_size = get_write_size (obj_fh.fh[sfh].size, obj_fh.fh[sfh].cur_size);
		append_file (sfh, obj_fh.fh[sfh].path, write_size);
		obj_fh.fh[sfh].cur_size += write_size;
		if (obj_fh.fh[sfh].cur_size == obj_fh.fh[sfh].size) {
			obj_fh.fh[sfh].exist_flag = COMPLETE;
		}
		if ((i%100)==0)
			printf ("%d append_file operation performed\n", i);
		i++;
	}

	printf ("end of file system object creation\n");
	print_fh_map(&obj_fh);
	print_result();
}

#ifdef notdef
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 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 aging_files ()
{
	char name[MAX_NAMELEN];
	int sfh;	/* file to be aged */
	int psfh;
	int ret;
	struct stat st;
	int agefd;

	/* get the sfh and size of the selected file to be aged */
	sfh = select_obj (&obj_fh, IS_FILE, EXIST, ACTIVE);
	ret = stat (obj_fh.fh[sfh].path, &st);
	RFS_ASSERT (ret == 0);
	ret = truncate(obj_fh.fh[i].path, st.st_size/2);
	RFS_ASSERT (ret==0);

	psfh = obj_fh.fh[sfh].psfh;
	strcpy (name, obj_fh.fh[psfh].path);
	sprintf(name+strlen(name), "/AGE%d", obj_fh.fh_max); 
	agefd = creat (name, S_IRWXU);
	//write (agefs, buf, 0);

	add_fh_t (&obj_fh, name, sfh, psfh, size, ftype_flag, EXIST, INACTIVE);
}
#endif