自学教程：C++ yaffs_open函数代码示例

void rename_over_test(const char *mountpt){	int i;	char a[100];	char b[100];	char c[100];		sprintf(a,"%s/a",mountpt);	sprintf(b,"%s/b",mountpt);	sprintf(c,"%s/c",mountpt);		yaffs_StartUp();		yaffs_mount(mountpt);		printf("Existing files/n");	dumpDirFollow(mountpt);				i = yaffs_open(c,O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);	printf("File c handle is %d/n",i);	yaffs_close(i);	i = yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR,  S_IREAD | S_IWRITE); 	yaffs_close(i);	i = yaffs_open(b,O_CREAT | O_TRUNC | O_RDWR,  S_IREAD | S_IWRITE);	yaffs_close(i);	yaffs_rename(a,b); // rename over	yaffs_rename(b,a); // rename back again (not renaimng over)	yaffs_rename(a,b); // rename back again (not renaimng over)			yaffs_unmount(mountpt);	}

int overwrite_test(const char *path){   char aname[100];   char bname[100];   int i;   int j;      int a;   int b;   yaffs_StartUp();      yaffs_mount(path);      sprintf(aname,"%s%s",path,"/a");   sprintf(bname,"%s%s",path,"/b");      b = yaffs_open(bname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);   for(j= 0; j < 500; j++){   	yaffs_write(b,bname,100);	a = yaffs_open(aname, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);   	for(i = 0; i < rand() % 20000; i++)   		yaffs_write(a,&a,sizeof(a));	yaffs_close(a);   }      return 0;   }

int test_yaffs_fsync_EROFS(void){	int output = 0;	int error_code = 0;	if (yaffs_close(yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	EROFS_setup();	handle = yaffs_open(FILE_PATH,O_CREAT  ,S_IREAD  );	if (handle<0){		print_message("failed to open file/n",2);		return -1;	}	output = yaffs_fsync(handle);	if (output==-1){		error_code=yaffs_get_error();		if (abs(error_code)==EROFS){			return 1;		} else {			print_message("different error than expected/n",2);			return -1;		}	} else {		print_message("file synced with EROFS set.(which is a bad thing)/n",2);		return -1;	}}

int cache_read_test(void){	int a,b,c;	int i;	int sizeOfFiles = 500000;	char buffer[100];		yaffs_StartUp();		yaffs_mount("/boot");		make_a_file("/boot/a",'a',sizeOfFiles);	make_a_file("/boot/b",'b',sizeOfFiles);	a = yaffs_open("/boot/a",O_RDONLY,0);	b = yaffs_open("/boot/b",O_RDONLY,0);	c = yaffs_open("/boot/c", O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);	do{		i = sizeOfFiles;		if (i > 100) i = 100;		sizeOfFiles  -= i;		yaffs_read(a,buffer,i);		yaffs_read(b,buffer,i);		yaffs_write(c,buffer,i);	} while(sizeOfFiles > 0);				return 1;	}

void File_Init(void){		int f1, f2;			yaffs_mount("/nand");											//挂载    		f1 = yaffs_open("nand/first_start", O_RDONLY, 0 );	  if ( f1 >= 0 )    //不是第一次启动文件系统 		{				printf("first_start open success!/n");				File_TpConfig_Exist();				//File_SubstationConfig_Exist();				//File_Data_Exist();		}		else              //第一次启动文件系统 	  {			  yaffs_unmount("/nand");				yaffs_format("/nand", 0, 0, 0);           //格式化				yaffs_mount("/nand");											//挂载				yaffs_mkdir("/nand/config", 0666);				//创建配置文件目录				yaffs_mkdir("/nand/data", 0666);					//创建上传数据目录								f1 = yaffs_open( "/nand/first_start",  O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE  );				if ( f1 >= 0 )				{						printf("first_start create success!/n");				}/*							f2 = yaffs_open( "/nand/config/TestpointConfig",  O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE  );							if ( f2 >= 0 )				{						printf("Testpoint Config Create Success!/n");						yaffs_close(f2);				}								f2 = yaffs_open( "/nand/config/SubstationConfig",  O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE  );							if ( f2 >= 0 )				{						printf("Substation Config Create Success!/n");						yaffs_close(f2);				}								f2 = yaffs_open( "/nand/data/SensorData",  O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE  );							if ( f2 >= 0 )				{						printf("SensorData Create Success!/n");						yaffs_close(f2);				}				*/		}				yaffs_close(f1);						return;}

void small_overwrite_test(const char *mountpt,int nmounts){	char a[30];	int i;	int j;	int h0;	int h1;		sprintf(a,"%s/a",mountpt);	yaffs_StartUp();				for(i = 0; i < nmounts; i++){				static char xx[8000];				printf("############### Iteration %d   Start/n",i);		if(1)			yaffs_mount(mountpt);		dump_directory_tree(mountpt);				yaffs_mkdir(a,0);				sprintf(xx,"%s/0",a);		h0 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);		sprintf(xx,"%s/1",a);		h1 = yaffs_open(xx, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);				for(j = 0; j < 1000000; j+=1000){			yaffs_ftruncate(h0,j);			yaffs_lseek(h0,j,SEEK_SET);			yaffs_write(h0,xx,7000);			yaffs_write(h1,xx,7000);						if(early_exit)				exit(0);		}				yaffs_close(h0);				printf("########### %d/n",i);		dump_directory_tree(mountpt);		if(1)			yaffs_unmount(mountpt);	}}

static void UpdateCounter(const char *name, unsigned *val,  int initialise){  int inh=-1;  int outh=-1;  unsigned x[2];  int nread = 0;  int nwritten = 0;    x[0] = x[1] = 0;    if(initialise){    x[0] = 0;     x[1] = 1;  } else {    inh = yaffs_open(name,O_RDONLY, S_IREAD | S_IWRITE);    if(inh >= 0){      nread = yaffs_read(inh,x,sizeof(x));      yaffs_close(inh);    }    if(nread != sizeof(x) ||       x[0] + 1 != x[1]){      printf("Error reading counter %s handle %d, x[0] %u x[1] %u last error %d/n",              name, inh, x[0], x[1],yaffsfs_GetLastError());      FatalError();                  }    x[0]++;    x[1]++;  }    outh = yaffs_open(fullTempCounterName, O_RDWR | O_TRUNC | O_CREAT, S_IREAD | S_IWRITE);  if(outh >= 0){    nwritten = yaffs_write(outh,x,sizeof(x));    yaffs_close(outh);    yaffs_rename(fullTempCounterName,name);  }    if(nwritten != sizeof(x)){      printf("Error writing counter %s handle %d, x[0] %u x[1] %u/n",              name, inh, x[0], x[1]);      FatalError();  }    *val = x[0];    printf("##/n"         "## Set counter %s to %u/n"         "##/n", name,x[0]);}

void leave_unlinked_file(const char *path,int maxIterations,int siz){	int i;	char str[50];	int h;		i = 0;		do{		sprintf(str,"%s/%d",path,i);		printf("create %s/n",str);		h = yaffs_open(str, O_CREAT | O_TRUNC | O_RDWR,S_IREAD | S_IWRITE);		if(h >= 0)		{			yaffs_unlink(str);		}		i++;	} while(h < 0 && i < maxIterations);		if(h >= 0)	{		for(i = 0; i < siz; i++)		{			yaffs_write(h,str,1);		}	}		printf("Leaving file %s open/n",str);}

void fill_disk(const char *path,int nfiles){	int h;	int n;	int result;	int f;        static char xx[600];		char str[50];		for(n = 0; n < nfiles; n++)	{		sprintf(str,"%s/%d",path,n);				h = yaffs_open(str, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);				printf("writing file %s handle %d ",str, h);				while ((result = yaffs_write(h,xx,600)) == 600)		{			f = yaffs_freespace(path);		}		result = yaffs_close(h);		printf(" close %d/n",result);	}}

void yaffs_device_flush_test(const char *path){	char fn[100];	int h;	int i;		yaffs_StartUp();			yaffs_mount(path);		do_some_file_stuff(path);		// Open and add some data to a few files	for(i = 0; i < 10; i++) {			sprintf(fn,"%s/ff%d",path,i);		h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IWRITE | S_IREAD);		yaffs_write(h,xxzz,2000);		yaffs_write(h,xxzz,2000);	}	yaffs_unmount(path);		yaffs_mount(path);}

void create_resized_file_of_size(const char *fn,int syze1,int reSyze, int syze2){	int h;		int iterations;		h = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);			iterations = (syze1 + strlen(fn) -1)/ strlen(fn);	while (iterations > 0)	{		yaffs_write(h,fn,strlen(fn));		iterations--;	}		yaffs_ftruncate(h,reSyze);		yaffs_lseek(h,0,SEEK_SET);	iterations = (syze2 + strlen(fn) -1)/ strlen(fn);	while (iterations > 0)	{		yaffs_write(h,fn,strlen(fn));		iterations--;	}		yaffs_close (h);}

int test_yaffs_open_EACCES(void){	int error_code=0;	int output =-1;	if (yaffs_access(FILE_PATH,0)!=0){		output=yaffs_close(test_yaffs_open());		if (output<0){			print_message("failed to open file/n",2);			return -1;		}	}	output=yaffs_chmod(FILE_PATH,S_IREAD);	if (output<0){		print_message("failed to chmod file/n",2);		return -1;	}	handle=yaffs_open(FILE_PATH, O_TRUNC| O_RDWR,FILE_MODE );	if (handle <0){		error_code=yaffs_get_error();		if (abs(error_code)==EACCES){			return 1;		}		else {			print_message("different error than expected/n",2);			return -1;		}	}	else {		print_message("file opened with read and write permissions, chmoded to read only.(which is a bad thing)/n",2);		return -1;	}}

void verify_200k_file(const char *fn){   int h1;   int i;   char x[11];   const char *s="0123456789";   int errCount = 0;      h1 = yaffs_open(fn, O_RDONLY, 0);      for(i = 0; i < 200000 && errCount < 10; i+= 10)   {   	yaffs_read(h1,x,10);	if(strncmp(x,s,10) != 0)	{		printf("File %s verification failed at %d/n",fn,i);		errCount++;	}   }   if(errCount >= 10)   	printf("Too many errors... aborted/n");         yaffs_close(h1);	   	}

void write_200k_file(const char *fn, const char *fdel, const char *fdel1){   int h1;   int i;   int offs;      h1 = yaffs_open(fn, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);      for(i = 0; i < 100000; i+= 10000)   {   	write_10k(h1);   }      offs = yaffs_lseek(h1,0,SEEK_CUR);   if( offs != 100000)   {   	printf("Could not write file/n");   }      yaffs_unlink(fdel);   for(i = 0; i < 100000; i+= 10000)   {   	write_10k(h1);   }      offs = yaffs_lseek(h1,0,SEEK_CUR);   if( offs != 200000)   {   	printf("Could not write file/n");   }      yaffs_close(h1);   yaffs_unlink(fdel1);   }

/*============================================================================== * - cat() * * - print a file context */int cat(int argc, char *argv[]){    int fd;    int read_byte;    char file_context[1024];    char path_name[PATH_LEN_MAX];    CHECK_ARG_NUM(2, "please type file name");    _make_abs_path(path_name, argv[1]);    /*     * open file     */    fd = yaffs_open(path_name, O_RDONLY, 0);    if ( fd ==  -1) {        serial_printf("cannot open file '%s'", path_name);        return CMD_ERROR;    }    /*     * read and print file context     */    read_byte = yaffs_read(fd, file_context, 1023);    while (read_byte > 0) {        file_context[read_byte] = '/0';        serial_printf(file_context);        read_byte = yaffs_read(fd, file_context, 1023);    }    yaffs_close(fd);    return CMD_OK;}

int  test_yaffs_rename_full_dir_over_dir(void){	int output=0;	int error_code =0;	if (yaffs_mkdir(DIR_PATH,O_CREAT | O_RDWR)==-1){		print_message("failed to create dir/n",1);		return -1;	}	if (yaffs_mkdir(DIR_PATH2,O_CREAT | O_RDWR)==-1){		print_message("failed to create dir2/n",1);		return -1;	}	if (yaffs_close(yaffs_open(DIR_PATH2_FILE,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	output = yaffs_rename( DIR_PATH2,DIR_PATH );	if (output<0){ 		print_message("could not rename a directory over a empty directory (which is a bad thing)/n",2);		return -1;	} 			return 1;}

int dump_file_data(char *fn){	int h;	int i = 0;	int ok = 1;	unsigned char b;		h = yaffs_open(fn, O_RDWR,0);					printf("%s/n",fn);	while(yaffs_read(h,&b,1)> 0)	{		printf("%02x",b);		i++;		if(i > 32) 		{		   printf("/n");		   i = 0;;		 }	}	printf("/n");	yaffs_close(h);	return ok;}

int  test_yaffs_rename_ENOTEMPTY(void){	int output=0;	int error_code =0;	if (yaffs_mkdir(DIR_PATH,O_CREAT | O_RDWR)==-1){		print_message("failed to create dir/n",1);		return -1;	}	if (yaffs_mkdir(DIR_PATH2,O_CREAT | O_RDWR)==-1){		print_message("failed to create dir2/n",1);		return -1;	}	if (yaffs_close(yaffs_open(DIR_PATH2_FILE,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	output = yaffs_rename( DIR_PATH,DIR_PATH2 );	if (output<0){ 		error_code=yaffs_get_error();		if (abs(error_code)==ENOTEMPTY){			return 1;		} else {			print_message("different error than expected/n",2);			return -1;		}		print_message("could not rename a directory over a nonempty directory (which is a bad thing)/n",2);		return -1;	} 			return 1;}

void read_a_file(char *fn){	int h;	int i = 0;	unsigned char b;	h = yaffs_open(fn, O_RDWR,0);	if(h<0)	{		printf("File not found/n");		return;	}	while(yaffs_read(h,&b,1)> 0)	{		printf("%02x ",b);		i++;		if(i > 32)		{		   printf("/n");		   i = 0;;		 }	}	printf("/n");	yaffs_close(h);}

int test_yaffs_ftruncate_EROFS(void){	int output = 0;	int error_code = 0;	handle = yaffs_open(FILE_PATH,O_CREAT | O_RDWR  , S_IREAD | S_IWRITE );	if (handle<0){		print_message("failed to open file/n",2);		return -1;	}	EROFS_setup();	output = yaffs_ftruncate(handle,FILE_SIZE_TRUNCATED );	if (output < 0){		error_code=yaffs_get_error();		//printf("EISDIR def %d, Error code %d/n", EISDIR,error_code);		if (abs(error_code) == EROFS){			return 1;		} else {			print_message("different error than expected/n", 2);			return -1;		}	} else {		print_message("file truncated with EROFS set.(which is a bad thing)/n", 2);		return -1;	}}

int test_yaffs_chmod_EROFS(void){	int error=0;	int output;	if (yaffs_close(yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	EROFS_setup();	output = yaffs_chmod(FILE_PATH,S_IREAD|S_IWRITE);	if (output<0){		error=yaffs_get_error();		if (abs(error)==EROFS){			return 1;		} else {			print_message("different error than expected/n",2);			return -1;		}	} else {		print_message("chmoded with EROFS setup (which is a bad thing)/n",2);		return -1;	}}

int check_pattern_file(char *fn){	int h;	int marker;	int i;	int size;	int ok = 1;		h = yaffs_open(fn, O_RDWR,0);	size = yaffs_lseek(h,0,SEEK_END);			for(i = 0; i < size; i+=256)	{		yaffs_lseek(h,i,SEEK_SET);		yaffs_read(h,&marker,sizeof(marker));		ok = (marker == ~i);		if(!ok)		{		   printf("pattern check failed on file %s, size %d at position %d. Got %x instead of %x/n",					fn,size,i,marker,~i);		}	}	yaffs_close(h);	return ok;}

void fill_empty_files_test(const char *mountpt){	int i;	yaffs_StartUp();	char name[100];	int result = 0;		int d,f;	for(i = 0; i < 5; i++)	{		yaffs_mount(mountpt);		for(d = 0; result >= 0 && d < 1000; d++){			sprintf(name,"%s/%d",mountpt,d);			result= yaffs_mkdir(name,0);			printf("creating directory %s result %d/n",name,result);						for(f = 0; result >= 0 && f < 100; f++){				sprintf(name,"%s/%d/%d",mountpt,d,f);				result= yaffs_open(name,O_CREAT, 0);				yaffs_close(result);				printf("creating file %s result %d/n",name,result);			}		}		yaffs_unmount(mountpt);	}	}

void handle_test(const char *mountpt){	int i;	int h;	int cycle;	char a[100];	sprintf(a,"%s/aaa",mountpt);		yaffs_StartUp();		yaffs_mount(mountpt);        for(cycle = 0; cycle < 5; cycle++){        printf("Start cycle %d/n",cycle); 	i = 0;	do {        h = yaffs_open(a, O_CREAT | O_TRUNC | O_RDWR, S_IREAD | S_IWRITE);	printf("%d  handle %d/n",i,h);	i++;	} while(h >= 0);		while(i >= -1) {	 yaffs_close(i);	 i--;        }        }		yaffs_unmount(mountpt);}

void verify_file_of_size(const char *fn,int syze){	int h;	int result;		char xx[200];	char yy[200];	int l;		int iterations = (syze + strlen(fn) -1)/ strlen(fn);		h = yaffs_open(fn, O_RDONLY, S_IREAD | S_IWRITE);			while (iterations > 0)	{		sprintf(xx,"%s %8d",fn,iterations);		l = strlen(xx);				result = yaffs_read(h,yy,l);		yy[l] = 0;				if(strcmp(xx,yy)){			printf("=====>>>>> verification of file %s failed near position %lld/n",fn,(long long)yaffs_lseek(h,0,SEEK_CUR));		}		iterations--;	}	yaffs_close (h);}

int test_yaffs_rmdir_ENOTDIR(void){	int output=0;	int error_code =0;	if (yaffs_close(yaffs_open(FILE_PATH,O_CREAT | O_RDWR, FILE_MODE))==-1){		print_message("failed to create file/n",1);		return -1;	}	if (0 !=  yaffs_access(DIR_PATH,0)) {		output = yaffs_mkdir(DIR_PATH,S_IWRITE | S_IREAD);		if (output < 0) {			print_message("failed to create directory/n",2);			return -1;		}	}	output = yaffs_rmdir("/yaffs2/test_dir/foo/dir/");	if (output<0){ 		error_code=yaffs_get_error();		if (abs(error_code)==ENOTDIR){			return 1;		} else {			print_message("returned error does not match the the expected error/n",2);			return -1;		}	} else{		print_message("removed /yaffs2/ directory (which is a bad thing)/n",2);		return -1;	}	}

int test_yaffs_open_ENAMETOOLONG(void){	int output = 0;	int x = 0;	int error_code = 0;	int file_name_length = 1000000;	char file_name[file_name_length];	strcat(file_name,YAFFS_MOUNT_POINT);	for (x = strlen(YAFFS_MOUNT_POINT); x<file_name_length -1; x++){		file_name[x] = 'a';	}	file_name[file_name_length-2]='/0';	handle = yaffs_open(file_name, O_CREAT | O_TRUNC| O_RDWR ,FILE_MODE );	if (handle == -1){		error_code = yaffs_get_error();		if (abs(error_code) == ENAMETOOLONG){			return 1;		} else {			print_message("different error than expected/n",2);			return -1;		}	} else {		//printf("handle %d /n",handle);		print_message("non existant file opened.(which is a bad thing)/n", 2);		return -1;	}}

void make_a_file(char *yaffsName, char bval, int sizeOfFile){	int outh;	int i;	unsigned char buffer[100];	outh = yaffs_open(yaffsName,				O_CREAT | O_RDWR | O_TRUNC,				S_IREAD | S_IWRITE);	if (outh < 0) {		printf("Error opening file: %d. %s/n", outh, yaffs_error_str());		return;	}	memset(buffer, bval, 100);	do {		i = sizeOfFile;		if (i > 100)			i = 100;		sizeOfFile -= i;		yaffs_write(outh, buffer, i);	} while (sizeOfFile > 0);	yaffs_close(outh);}

/*============================================================================== * - cp() * * - copy a file form here to there */int cp(int argc, char *argv[]){    int fd_in, fd_out;    int read_byte, write_byte;    char file_context[1024];    char old_path_name[PATH_LEN_MAX];    char new_path_name[PATH_LEN_MAX];    CHECK_ARG_NUM(3, "too few argument");    _make_abs_path(old_path_name, argv[1]);    fd_in = yaffs_open(old_path_name, O_RDONLY, 0);    CHECK_YAFFS_RETVAL(fd_in, "can't open file '%s'%s/n", old_path_name, "");    _make_abs_path(new_path_name, argv[2]);    fd_out = yaffs_open(new_path_name, O_CREAT|O_RDWR|O_TRUNC, S_IREAD|S_IWRITE);    if (fd_out == -1) {        yaffs_close(fd_in);        serial_printf("can't create file '%s'", new_path_name);        return CMD_ERROR;    }    /*     * read from fd_in and write to fd_out     */    read_byte = yaffs_read(fd_in, file_context, 1024);    while (read_byte > 0) {        write_byte = yaffs_write(fd_out, file_context, read_byte);        if (write_byte != read_byte) {            serial_printf("copy file failed!");            break;        }        read_byte = yaffs_read(fd_in, file_context, 1024);    }    yaffs_close(fd_in);    yaffs_close(fd_out);    if (read_byte > 0) {        return CMD_ERROR;    } else {        return CMD_OK;    }}

void V5M_SaveImageFile(char *str, char *buf, UINT32 len){	int h;	yaffs_unlink(str);	h = yaffs_open(str,  O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE);	yaffs_write(h, buf, (unsigned int)len);	yaffs_close(h);}