diff options
Diffstat (limited to 'direct/timothy_tests/yaffs_and_linux_mirror_tests')
22 files changed, 1530 insertions, 0 deletions
diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/Makefile b/direct/timothy_tests/yaffs_and_linux_mirror_tests/Makefile new file mode 100644 index 0000000..0ba8539 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/Makefile @@ -0,0 +1,119 @@ +# Makefile for YAFFS direct stress tests +# +# +# YAFFS: Yet another Flash File System. A NAND-flash specific file system. +# +# Copyright (C) 2003-2010 Aleph One Ltd. +# +# +# Created by Charles Manning <charles@aleph1.co.uk> +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# NB Warning this Makefile does not include header dependencies. +# +# $Id: Makefile,v 1.7 2010-02-25 22:34:47 charles Exp $ + +#EXTRA_COMPILE_FLAGS = -DYAFFS_IGNORE_TAGS_ECC + +CFLAGS = -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_YAFFS2 +CFLAGS += -DCONFIG_YAFFS_PROVIDE_DEFS -DCONFIG_YAFFSFS_PROVIDE_VALUES +CFLAGS += -Wall -g $(EXTRA_COMPILE_FLAGS) -Wstrict-aliasing +#CFLAGS += -fno-strict-aliasing +CFLAGS += -O0 +CFLAGS += -Wextra -Wpointer-arith +#CFLAGS += -DCONFIG_YAFFS_VALGRIND_TEST + +#CFLAGS+= -Wshadow -Wpointer-arith -Wwrite-strings -Wstrict-prototypes -Wmissing-declarations +#CFLAGS+= -Wmissing-prototypes -Wredundant-decls -Wnested-externs -Winline + + +COMMONTESTOBJS = yaffscfg2k.o yaffs_osglue.o yaffs_hweight.o \ + yaffs_ecc.o yaffs_fileem.o yaffs_fileem2k.o yaffsfs.o yaffs_guts.o \ + yaffs_packedtags1.o yaffs_ramdisk.o yaffs_ramem2k.o \ + yaffs_tagscompat.o yaffs_packedtags2.o yaffs_nand.o \ + yaffs_checkptrw.o yaffs_qsort.o\ + yaffs_nameval.o yaffs_attribs.o \ + yaffs_norif1.o ynorsim.o \ + yaffs_allocator.o \ + yaffs_bitmap.o \ + yaffs_yaffs1.o \ + yaffs_yaffs2.o \ + yaffs_verify.o \ + yaffs_error.o \ + yaffs_summary.o + +# yaffs_checkptrwtest.o\ + +TESTFILES = mirror_tests.o lib.o\ + linux_test_open.o yaffs_test_open.o\ + linux_test_truncate.o yaffs_test_truncate.o \ + linux_test_unlink.o yaffs_test_unlink.o \ + linux_test_write.o yaffs_test_write.o + + + + +YAFFSTESTOBJS = $(COMMONTESTOBJS) $(TESTFILES) + + +ALLOBJS = $(sort $(YAFFSTESTOBJS)) $(PYTHONOBJS) + +YAFFSSYMLINKS = yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yaffs_tagscompat.c yaffs_tagscompat.h \ + yaffs_packedtags1.c yaffs_packedtags1.h yaffs_packedtags2.c yaffs_packedtags2.h \ + yaffs_nand.c yaffs_nand.h yaffs_getblockinfo.h \ + yaffs_checkptrw.h yaffs_checkptrw.c \ + yaffs_nameval.c yaffs_nameval.h \ + yaffs_trace.h yaffs_attribs.h \ + yaffs_allocator.c yaffs_allocator.h \ + yaffs_yaffs1.c yaffs_yaffs1.h \ + yaffs_yaffs2.c yaffs_yaffs2.h \ + yaffs_bitmap.c yaffs_bitmap.h \ + yaffs_verify.c yaffs_verify.h \ + yaffs_summary.c yaffs_summary.h + +YAFFSDIRECTSYMLINKS = yaffsfs.c yaffs_flashif.h yaffs_flashif2.h\ + yaffsfs.h ydirectenv.h \ + yaffs_flashif.c yaffscfg.h yaffs_qsort.c \ + yaffs_nandemul2k.h yaffs_list.h \ + yaffs_attribs.c yaffs_osglue.h \ + yaffs_nandif.c yaffs_nandif.h yportenv.h \ + yaffs_hweight.h yaffs_hweight.c \ + yaffs_error.c + + +DIRECTEXTRASYMLINKS = yaffscfg2k.c yaffs_fileem2k.c yaffs_fileem2k.h\ + yaffs_fileem.c yaffs_norif1.c yaffs_norif1.h \ + yaffs_ramdisk.c yaffs_ramdisk.h yaffs_ramem2k.c \ + ynorsim.h ynorsim.c yaffs_osglue.c + +SYMLINKS = $(YAFFSSYMLINKS) $(YAFFSDIRECTSYMLINKS) $(DIRECTEXTRASYMLINKS) $(PYTONOSYMLINKS) +#all: directtest2k boottest + +all: mirror_tests + +$(ALLOBJS): %.o: %.c + gcc -c $(CFLAGS) -o $@ $< + +$(PYTONOSYMLINKS): + ln -s ../../python/$@ $@ + +$(YAFFSSYMLINKS): + ln -s ../../../$@ $@ + +$(YAFFSDIRECTSYMLINKS): + ln -s ../../$@ $@ + +$(DIRECTEXTRASYMLINKS): + ln -s ../../basic-test/$@ $@ + + +mirror_tests: $(SYMLINKS) $(ALLOBJS) + gcc $(CFLLAG) -o $@ $(ALLOBJS) + + + +clean: + rm -f mirror_tests $(ALLOBJS) core $(SYMLINKS) diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/README.txt b/direct/timothy_tests/yaffs_and_linux_mirror_tests/README.txt new file mode 100644 index 0000000..2c03959 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/README.txt @@ -0,0 +1,27 @@ +Made by Timothy Manning on 24/12/2010 <timothy@yaffs.net> + + + mirror_tests is designed to check that yaffs behaves the same way as linux. + This is done by applying the same command to both linux and yaffs and + then checking the output of the functions. + The default place for creating linux files is direct/timothy_tests/mirror_tests/tests/ + This directory is removed and is recreated at the beginning of each test, + However some of the files may be read only and cannot be deleted. + It is much better to remove this directory via the command line. + + rm test/*;rmdir test/;./mirror_tests -n 100 -v + +compile command: make +run command: mirror_tests + +Command line arguments + -yaffs_path [PATH] sets the path for yaffs. + -linux_path [PATH] sets the path for linux. + -p [NUMBER] sets the print level for mirror_tests. + -v verbose mode everything is printed + -q quiet mode nothing is printed. + -n [number] sets the number of random tests to run. + -s [number] seeds rand with the number + -t [number] sets yaffs_trace to the number + -clean removes emfile and test dir + diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/lib.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/lib.c new file mode 100644 index 0000000..079ed25 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/lib.c @@ -0,0 +1,141 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "lib.h" + +static int EXIT_ON_ERROR = 1; +static int PRINT_LEVEL = 2; //This sets the level of detail which is printed. There are 3 levels 0,1,2 and 3 + //0 just prints the number of tests passed and failed. + //1 is the basic print level. it will print the details of a failed test. + //2 will print if a test passes and cleans. +void set_print_level(int new_level) +{ + PRINT_LEVEL=new_level; +} +int get_print_level(void) +{ + return PRINT_LEVEL; +} + +void set_exit_on_error(int num) +{ + EXIT_ON_ERROR=num; +} + +int get_exit_on_error(void) +{ + return EXIT_ON_ERROR; +} + +void display_error(void) +{ + +} + +void get_error_yaffs(void) +{ + int error_code=0; + char message[30]; + message[0]='\0'; + + error_code=yaffs_get_error(); + sprintf(message,"yaffs_error code %d\n",error_code); + print_message(1,message); + sprintf(message,"error is : %s\n",yaffs_error_to_str(error_code)); + print_message(1,message); +} + +void get_error_linux(void) +{ + int error_code=0; + char message[30]; + message[0]='\0'; + + error_code=errno; + sprintf(message,"linux_error code %d\n",error_code); + print_message(1,message); + strcpy(message,"error code"); + sprintf(message,"error is : %s\n",yaffs_error_to_str(error_code)); + //perror(message); + print_message(1,message); +} +void generate_random_string(char *ptr,int length_of_str){ + unsigned int x; + unsigned int length=((rand() %(length_of_str-3))+3); /*creates a int with the number of charecters been between 1 and 51*/ + char letter='\0'; + strcpy(ptr,""); + //printf("generating string\n"); + //printf("string length is %d\n",length); + for (x=0; x <= (length-2) &&length>2 ; x++) + { + //printf("x=%d\n",x); + /* keep generating a charecter until the charecter is legal*/ + while((letter=='\0' )||(letter=='/')||(letter=='\\')){ + letter=(rand() % 125-59)+58; /*generate a number between 32 and 126 and uses it as a charecter (letter) */ + } + ptr[x]=letter; + //printf("charecter generated is %c\n",ptr[x]); + } + ptr[x+1]='\0'; /*adds NULL charecter to turn it into a string*/ + +} + +void join_paths(char *path1,char *path2,char *new_path ) +{ + char message[100]; + print_message(3,"joining paths\n"); + sprintf(message,"path1: %s\n",path1); + print_message(3,message); + sprintf(message,"path2: %s\n",path2); + print_message(3,message); + strcpy(new_path,""); + //strcat(new_path,path1); /*since all functions have this then pull it out*/ + if ( (path1[(sizeof(path1)/sizeof(char))-2]=='/') && path2[0]!='/') { + /*paths are compatiable. concatanate them. note -2 is because of \0*/ + strcat(new_path,path1); + strcat(new_path,path2); + //char new_path[(sizeof(path1)/sizeof(char))+(sizeof(path2)/sizeof(char))]; + //strcpy(new_path,strcat(path1,path2)); + //return new_path; + } else if ((path1[(sizeof(path1)/sizeof(char))-2]!='/') && path2[0]=='/') { + /*paths are compatiable. concatanate them*/ + strcat(new_path,path1); + strcat(new_path,path2); + + } else if ((path1[(sizeof(path1)/sizeof(char))-2]!='/') && path2[0]!='/') { + /*need to add a "/". */ + strcat(new_path,path1); + strcat(new_path,"/"); + strcat(new_path,path2); + + } else if ((path1[(sizeof(path1)/sizeof(char))-2]=='/') && path2[0]=='/') { + /*need to remove a "/". */ + /*yaffs does not mind the extra slash. */ + strcat(new_path,path1); + strcat(new_path,path2); + + } else { + //error + //return -1; + } +} + +void print_message(char print_level,char *message) +{ + if (print_level <= PRINT_LEVEL){ + printf(message); + } +} + + + diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/lib.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/lib.h new file mode 100644 index 0000000..0b33479 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/lib.h @@ -0,0 +1,53 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef _lib_h__ +#define _lib_h__ + +#include <stdio.h> +#include <string.h> +#include "yaffsfs.h" +#include <errno.h> + +typedef struct arg_temp2{ + char char1; + char char2; + char string1[100]; + char string2[100]; + int int1; + int int2; +} arg_temp; + + +typedef struct test_dir_temp +{ + int type_of_test; //used to tell if it is LINUX of YAFFS + char root_path[200]; +} test_dir; +test_dir yaffs_struct,linux_struct; + + + +void generate_random_string(char *ptr,int length_of_str); +void join_paths(char *path1,char *path2,char *new_path ); +void print_message(char print_level, char *message); +void set_print_level(int new_level); +int get_print_level(void); +void set_exit_on_error(int num); +int get_exit_on_error(void); +void display_error(void); +void get_error_yaffs(void); +void get_error_linux(void); +#endif diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_open.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_open.c new file mode 100644 index 0000000..871dc56 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_open.c @@ -0,0 +1,38 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "linux_test_open.h" + +int linux_test_open(arg_temp *args_struct) +{ + char path[250]; + char message[150]; + int output; + join_paths(linux_struct.root_path,args_struct->string1, path ); + sprintf(message,"file path: %s\n",path); + print_message(3,message); + + output= open(path,args_struct->char1 & (O_TRUNC|O_EXCL|O_CREAT|O_APPEND) ,args_struct->char2& (S_IREAD|S_IWRITE)); + if (output>=0){ + output=close(output); + if (output<0) { + print_message(3,"failed to close handle\n"); + return -1; + } else { + return 1; + } + } else { + print_message(3,"failed to open file\n"); + return -1; + } +} diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_open.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_open.h new file mode 100644 index 0000000..6274934 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_open.h @@ -0,0 +1,24 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __linux_test_open_h__ +#define __linux_test_open_h__ +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include "lib.h" + +int linux_test_open(arg_temp *args_struct); +#endif diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_truncate.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_truncate.c new file mode 100644 index 0000000..94e8959 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_truncate.c @@ -0,0 +1,27 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "linux_test_truncate.h" + +int linux_test_truncate(arg_temp *args_struct) +{ + char path[200]; + char message[200]; + int output=0; + join_paths(linux_struct.root_path,args_struct->string1, path ); + sprintf(message,"file path: %s\n",path); + print_message(3,message); + + output=truncate(path,args_struct->int1); + return output; +} diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_truncate.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_truncate.h new file mode 100644 index 0000000..7ef91d0 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_truncate.h @@ -0,0 +1,27 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __linux_test_truncate_h__ +#define __linux_test_truncate_h__ +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include "yaffsfs.h" +#include "lib.h" + +int linux_test_truncate(arg_temp *args_struct); + +#endif diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_unlink.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_unlink.c new file mode 100644 index 0000000..575e7ae --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_unlink.c @@ -0,0 +1,33 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "linux_test_unlink.h" + +int linux_test_unlink(arg_temp *args_struct) +{ + char path[250]; + char message[150]; + int output; + join_paths(linux_struct.root_path,args_struct->string1, path ); + sprintf(message,"file path: %s\n",path); + print_message(3,message); + + output= unlink(path); + + if (output<0) { + print_message(3,"failed to unlink file\n"); + return -1; + } else { + return 1; + } +} diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_unlink.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_unlink.h new file mode 100644 index 0000000..7572aa8 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_unlink.h @@ -0,0 +1,26 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __linux_test_unlink_h__ +#define __linux_test_unlink_h__ +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include "yaffsfs.h" +#include "lib.h" + +int linux_test_unlink(arg_temp *args_struct); + +#endif diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_write.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_write.c new file mode 100644 index 0000000..b46c211 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_write.c @@ -0,0 +1,37 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "linux_test_write.h" + +int linux_test_write(arg_temp *args_struct) +{ + char path[200]; + char message[200]; + int output=0; + int handle=-1; + join_paths(linux_struct.root_path,args_struct->string1, path ); + sprintf(message,"trying to write to: %s\nwith mode set to %o \n",path,args_struct->char1 ); + print_message(3,message); + printf("mode S_IREAD %d S_IWRITE %d\n",(args_struct->char2 & S_IREAD),(args_struct->char2 & S_IWRITE)); + handle=open(path,((args_struct->char1 &(O_TRUNC|O_EXCL|O_CREAT|O_APPEND))|O_RDWR),(args_struct->char2&(S_IREAD|S_IWRITE))); + printf("handle %d\n",handle); + if (handle<0){ + print_message(3,"failed to open a handle\n"); + return -1; //handle failed to open + } + sprintf(message,"trying to write: %d bytes into the file\n",strlen(args_struct->string2)); + print_message(3,message); + output=write(handle,args_struct->string2,strlen(args_struct->string2)); + close(handle); + return output; +} diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_write.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_write.h new file mode 100644 index 0000000..611fe7d --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/linux_test_write.h @@ -0,0 +1,27 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __linux_test_write_h__ +#define __linux_test_write_h__ +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include "yaffsfs.h" +#include "lib.h" + +int linux_test_write(arg_temp *args_struct); + +#endif diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/mirror_tests.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/mirror_tests.c new file mode 100644 index 0000000..cd4e5f2 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/mirror_tests.c @@ -0,0 +1,601 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "mirror_tests.h" + +int random_seed; +int simulate_power_failure = 0; + +int num_of_random_tests=1; + + + +typedef struct test_list_temp2{ + char *test_name; + int (*test_pointer)(arg_temp *args_struct); +}test_list_temp; + +typedef struct test_temp2 { + int num_of_tests; + test_list_temp test_list[]; +}test_temp; + +test_temp yaffs_tests={ + 4, + {{"yaffs_test_open",yaffs_test_open}, + {"yaffs_test_truncate",yaffs_test_truncate}, + {"yaffs_test_unlink",yaffs_test_unlink}, + {"yaffs_test_write",yaffs_test_write} + } +}; + +test_temp linux_tests={ + 4, + {{"linux_test_open",linux_test_open}, + {"linux_test_truncate",linux_test_truncate}, + {"linux_test_unlink",linux_test_unlink}, + {"linux_test_write",linux_test_write} + } +}; + +const struct option long_options[]={ + {"help", 0,NULL,'h'}, + {"yaffs_path", 1,NULL,'y'}, + {"linux_path", 1,NULL,'l'}, + {"print_level", 1,NULL,'p'}, + {"quiet", 0,NULL,'q'}, + {"number", 1,NULL,'n'}, + {"seed", 1,NULL,'s'}, + {"trace", 1,NULL,'t'}, + {"clean", 0,NULL,'c'}, + {"verbose", 0,NULL,'v'} +}; + +const char short_options[]="hy:l:p:qn:s:t:cv"; + + +int main(int argc, char *argv[]) +{ + char message[100]; + +// yaffs_tests.num_of_tests=(sizeof(yaffs_tests)/sizeof(test_temp)); +// linux_tests.num_of_tests=(sizeof(linux_tests)/sizeof(test_temp)); + + init(argc,argv); + print_message(1,"running mirror_tests\n"); + sprintf(message,"linux_root_path: %s\n",linux_struct.root_path); + print_message(3,message); + sprintf(message,"yaffs_root_path: %s\n",yaffs_struct.root_path); + print_message(3,message); + sprintf(message,"linux_num_of_tests: %d\n",linux_tests.num_of_tests); + print_message(3,message); + sprintf(message,"yaffs_num_of_tests: %d\n",yaffs_tests.num_of_tests); + print_message(3,message); + + run_random_test(num_of_random_tests); + //compare_linux_and_yaffs(); + yaffs_unmount("yaffs2"); + return 0; +} + +void init(int argc, char *argv[]) +{ + char dir[200]; + dir[0]='\0'; + int x=-1; + char message[100]; + int new_option; + + x=(unsigned)time(NULL); + sprintf(message,"seeding srand with: %d\n",x); + print_message(2,message); + srand(x); + yaffs_set_trace(0); + linux_struct.type_of_test =LINUX; + yaffs_struct.type_of_test =YAFFS; + + sprintf(message,"current absolute path is: %s\n",getcwd(dir,200)); + print_message(3,message); + strcpy(dir,getcwd(dir,200)); + + strcat(dir,"/test/"); + printf("dir: %s\n",dir); + strcpy(linux_struct.root_path,dir); + strcpy(yaffs_struct.root_path,"yaffs2/test/"); + + + do { + new_option=getopt_long(argc,argv,short_options,long_options,NULL); + if (new_option=='h'){ + printf("mirror_tests help\n"); + printf("arguments:\n"); + printf("\t-yaffs_path [PATH] //sets the path for yaffs.\n"); + printf("\t-linux_path [PATH] //sets the path for linux.\n"); + printf("\t-p [NUMBER] //sets the print level for mirror_tests.\n"); + printf("\t-v //verbose mode everything is printed\n"); + printf("\t-q //quiet mode nothing is printed.\n"); + printf("\t-n [number] //sets the number of random tests to run.\n"); + printf("\t-s [number] //seeds rand with the number\n"); + printf("\t-t [number] //sets yaffs_trace to the number\n"); + printf("\t-clean //removes emfile and test dir\n"); + exit(0); + } else if (new_option=='y'){ + strcpy(yaffs_struct.root_path, optarg); + } else if (new_option=='l'){ + strcpy(linux_struct.root_path, optarg); + } else if (new_option=='p'){ + set_print_level(atoi(optarg)); + } else if (new_option=='v'){ + set_print_level(5); + } else if (new_option=='q'){ + set_print_level(-1); + } else if (new_option=='n'){ + num_of_random_tests=atoi(optarg); + } else if (new_option=='s'){ + srand(atoi(argv[x+1])); + } else if (new_option=='t'){ + yaffs_set_trace(atoi(optarg)); + } else if (new_option=='c'){ + clean_dir(); + exit(0); + } else if (new_option==-1){ + + } else if (new_option=='?') { + printf("bad argument\n"); + exit(0); + } + + } while(new_option!=-1); + clean_dir(); + yaffs_start_up(); + print_message(2,"\nmounting yaffs\n"); + x=yaffs_mount("yaffs2"); + if (x<0) { + print_message(3,"failed to mount yaffs\n"); + get_error_yaffs(); + } else { + print_message(3,"mounted yaffs\n"); + } + + + print_message(3,"\nmaking linux test dir\n"); + x=mkdir(linux_struct.root_path,0777); + if (x<0) { + print_message(1,"failed to make dir\n"); + get_error_linux(); + } else { + print_message(3,"made dir\n"); + } + + print_message(3,"\nmaking yaffs test dir\n"); + x=yaffs_mkdir(yaffs_struct.root_path,0777); + if (x<0) { + print_message(1,"failed to make dir\n"); + get_error_yaffs(); + } else { + print_message(3,"made dir\n"); + } +} + +int run_random_test(int num_of_random_tests) +{ + int y=0; + int x=-1; + int id=0; + int test_id=-1; + int num_of_tests_before_check=1; + char message[200]; + arg_temp args_struct; + for (y=0;(y*num_of_tests_before_check)<num_of_random_tests;y++){ + for (x=0;x<num_of_tests_before_check && (x+(y*num_of_tests_before_check)<num_of_random_tests);x++) { + errno=0; + yaffs_set_error(0); + test_id = select_test_id(yaffs_tests.num_of_tests); + sprintf(message,"running test_id %d\n",test_id); + print_message(3,message); + generate_random_numbers(&args_struct); + run_yaffs_test(test_id, &args_struct); + + //check_mode(&args_struct); + + run_linux_test(test_id, &args_struct); + + if (get_print_level()>=4){ + get_error_yaffs(); + get_error_linux(); + } + + if ((abs(yaffs_get_error())!=abs(errno)) && + (abs(yaffs_get_error())!=EISDIR && abs(errno) != 0) && + (abs(yaffs_get_error())!=ENOENT && abs(errno) != EACCES)&& + (abs(yaffs_get_error())!=EINVAL && abs(errno) != EBADF) + ){ + print_message(2,"\ndifference in returned errors######################################\n"); + get_error_yaffs(); + get_error_linux(); + if (get_exit_on_error()){ + exit(0); + } + } + } + //check_mode(&args_struct); + compare_linux_and_yaffs(&args_struct); + //check_mode(&args_struct); + + } + compare_linux_and_yaffs(&args_struct); +} + +int select_test_id(int test_len) +{ + int id=0; + //printf("test_len = %d\n",test_len); + id=(rand() % test_len ); + //printf("id %d\n",id); + return id; + +} + +int check_mode(arg_temp *args_struct) +{ + char path[200]; + char message[200]; + int output=0; + + struct yaffs_stat yaffs_stat_struct; + join_paths(yaffs_struct.root_path,args_struct->string1, path ); + sprintf(message,"\ntrying to stat to: %s\n",path); + print_message(3,message); + output=yaffs_stat(path,&yaffs_stat_struct); + if (output < 0){ + sprintf(message,"failed to stat the file\n"); + print_message(3,message); + get_error_yaffs(); + } else { + sprintf(message,"stated the file\n"); + print_message(3,message); + sprintf(message," yaffs file mode is %d\n",(yaffs_stat_struct.st_mode & (S_IREAD| S_IWRITE))); + print_message(3,message); + sprintf(message,"mode S_IREAD %d S_IWRITE %d\n",(yaffs_stat_struct.st_mode & S_IREAD),(yaffs_stat_struct.st_mode & S_IWRITE)); + print_message(3,message); + } + return 1; +} + +int check_mode_file(char *path) +{ + char message[200]; + int output=0; + + struct yaffs_stat yaffs_stat_struct; + + sprintf(message,"\ntrying to stat to: %s\n",path); + print_message(3,message); + output=yaffs_stat(path,&yaffs_stat_struct); + if (output < 0){ + sprintf(message,"failed to stat the file\n"); + print_message(3,message); + get_error_yaffs(); + } else { + sprintf(message,"stated the file\n"); + print_message(3,message); + sprintf(message," yaffs file mode is %d\n",(yaffs_stat_struct.st_mode & (S_IREAD| S_IWRITE))); + print_message(3,message); + sprintf(message,"mode S_IREAD %d S_IWRITE %d\n\n",(yaffs_stat_struct.st_mode & S_IREAD),(yaffs_stat_struct.st_mode & S_IWRITE)); + print_message(3,message); + } + return 1; +} + +int compare_linux_and_yaffs(arg_temp *args_struct) +{ + int x=0,y=0; + char l_path[200]; + char y_path[200]; + char file_name[200]; + int exit_bool=0; + int number_of_files_in_yaffs=0; + int number_of_files_in_linux=0; + char message[200]; + char **yaffs_file_list=NULL; + char **linux_file_list=NULL; + + struct yaffs_stat yaffs_stat_struct; + struct stat linux_stat_struct; + yaffs_DIR *yaffs_open_dir; + yaffs_dirent *yaffs_current_file; + + DIR *linux_open_dir; + struct dirent *linux_current_file; + + l_path[0]='\0'; + y_path[0]='\0'; + file_name[0]='\0'; + message[0]='\0'; + print_message(2,"\n\n\n comparing folders\n"); +// check_mode_file("yaffs2/test/YY"); + //find out the number of files in the directory + yaffs_open_dir = yaffs_opendir(yaffs_struct.root_path); + if (yaffs_open_dir) { + for (x=0;yaffs_readdir(yaffs_open_dir);x++){} + number_of_files_in_yaffs=x; + sprintf(message,"number of files in yaffs dir= %d\n",number_of_files_in_yaffs); + print_message(2,message); + yaffs_rewinddir(yaffs_open_dir); + } else { + print_message(3,"failed to open yaffs test dir\n"); + } + //create array + yaffs_file_list= (char **)malloc(x*sizeof(char*)); + for (x=0;x<number_of_files_in_yaffs;x++) { + yaffs_file_list[x]=malloc(200); + } + + //check_mode_file("yaffs2/test/YY"); + //copy file names into array + if (yaffs_open_dir){ + yaffs_current_file =yaffs_readdir(yaffs_open_dir); + for (x=0 ;yaffs_current_file;x++) + { + printf("x= %d \n",x); + printf("yaffs_current_file->d_name = %s\n",yaffs_current_file->d_name); + if (yaffs_current_file){ + strcpy(yaffs_file_list[x],yaffs_current_file->d_name); + + } + yaffs_current_file =yaffs_readdir(yaffs_open_dir); + } + yaffs_closedir(yaffs_open_dir); + } else { + print_message(3,"failed to populate yaffs test list\n"); + } + + + //find out the number of files in the directory + linux_open_dir = opendir(linux_struct.root_path); + if (linux_open_dir){ + for (x=0;readdir(linux_open_dir);x++){} + number_of_files_in_linux=(x-2); + sprintf(message,"number of files in linux dir= %d\n",(number_of_files_in_linux)); + print_message(2,message); + //the -2 is because linux shows 2 extra files which are automaticly created. + + rewinddir(linux_open_dir); + } else { + print_message(3,"failed to open linux test dir\n"); + } + + //create array + linux_file_list= (char **)malloc(number_of_files_in_linux*sizeof(char*)); + + for (x=0;x<number_of_files_in_linux;x++) { + linux_file_list[x]=malloc(200); + } + + //check_mode_file("yaffs2/test/YY"); + //copy file names into array + if (linux_open_dir){ + linux_current_file =readdir(linux_open_dir); + for (x=0, y=0 ;linux_current_file;x++) + { + + if (linux_current_file){ + strcpy(message,linux_current_file->d_name); + print_message(7,"opened file: "); + print_message(7,message); + print_message(7,"\n"); + } + if (linux_current_file && + 0!=strcmp(message,".")&& + 0!=strcmp(message,"..")){ + strcpy(file_name,linux_current_file->d_name); + //sprintf("file opened: %s\n",linux_current_file->d_name); + //print_message(3,message); + print_message(7,"added file to list\n"); + strcpy(linux_file_list[y],file_name); + sprintf(message,"file added to list: %s\n",linux_file_list[y]); + print_message(7,message); + y++; + } + linux_current_file =readdir(linux_open_dir); + } + closedir(linux_open_dir); + } else { + print_message(3,"failed to populate linux test dir\n"); + } + + + //match the files in both folders + for (x=0;x<number_of_files_in_yaffs;x++){ + sprintf(message,"\nsearching for yaffs file: %s\n",yaffs_file_list[x]); + print_message(3,message); + for (y=0;y<number_of_files_in_linux;y++){ + sprintf(message,"comparing to linux file: %s\n",linux_file_list[y]); + print_message(7,message); + + if (0==strcmp(yaffs_file_list[x],linux_file_list[y])){ + sprintf(message,"file matched: %s\n",linux_file_list[y]); + print_message(3,message); + //check that the modes of both files are the same + join_paths(yaffs_struct.root_path,yaffs_file_list[x],y_path); + join_paths(linux_struct.root_path,linux_file_list[y],l_path); + if (yaffs_stat(y_path,&yaffs_stat_struct)>=0&& + stat(l_path,&linux_stat_struct)>=0){ + sprintf(message," yaffs file mode is %d\n",(yaffs_stat_struct.st_mode & (S_IREAD| S_IWRITE))); + print_message(3,message); + sprintf(message,"mode S_IREAD %d S_IWRITE %d\n",(yaffs_stat_struct.st_mode & S_IREAD),(yaffs_stat_struct.st_mode & S_IWRITE)); + print_message(3,message); + sprintf(message," linux file mode is %d\n",(linux_stat_struct.st_mode & (S_IREAD|S_IWRITE))); + print_message(3,message); + sprintf(message,"mode S_IREAD %d S_IWRITE %d\n",(linux_stat_struct.st_mode & S_IREAD),(linux_stat_struct.st_mode & S_IWRITE)); + print_message(3,message); + if ((yaffs_stat_struct.st_mode & (S_IREAD| S_IWRITE))== + ( linux_stat_struct.st_mode & (S_IREAD|S_IWRITE))){ + print_message(2,"file modes match\n"); + } else { + print_message(2,"file modes do not match\n"); + exit_bool=1; + } + linux_file_list[y][0]=NULL; + yaffs_file_list[x][0]=NULL; + } else { + print_message(2,"failed to stat one of the files\n"); + get_error_yaffs(); + get_error_linux(); + } + + //read file contents + + + break; + } + } + } + + //print remaining files + for (x=0;x<number_of_files_in_linux;x++){ + if (linux_file_list[x][0]){ + sprintf(message,"unmatched file in linux: %s\n",linux_file_list[x]); + print_message(2,message); + exit_bool=1; + } + } + for (x=0;x<number_of_files_in_yaffs;x++){ + if (yaffs_file_list[x][0]){ + sprintf(message,"unmatched file in yaffs: %s\n",yaffs_file_list[x]); + print_message(2,message); + exit_bool=1; + } + } + if (exit_bool==1&& get_exit_on_error()==1){ + print_message(2,"exiting program\n"); + exit(0); + } + + for (x=0;x<number_of_files_in_yaffs;x++) { + free(yaffs_file_list[x]); + } + free(yaffs_file_list); + + for (x=0;x<number_of_files_in_linux;x++) { + free(linux_file_list[x]); + } + free(linux_file_list); + + + //printf("file_name %s\n", yaffs_current_file->d_name); +// generate_array_of_objects_in_yaffs(); +// generate_array_of_objects_in_linux(); + //first do a check to see if both sides have the same objects on both sides. + //then stat all of the files and compare size and mode + //read the text of each file and compare them. + + //show the diffrences by printing them. + return 1; + +} + +void generate_random_numbers(arg_temp *args_struct) +{ + char string[51]; + args_struct->char1= (rand() % 255); + args_struct->char2= (rand() % 255); + args_struct->int1= (rand() % 100000); + args_struct->int2= (rand() % 100000); + generate_random_string(string,50); + strcpy(args_struct->string1, string); + generate_random_string(string,50); + strcpy(args_struct->string2, string); +} + +void run_yaffs_test(int id,arg_temp *args_struct) +{ + char message[200]; + int output =0; + print_message(3,"\n"); + //printf("id = %d\n",id); + sprintf(message,"running_test %s\n",yaffs_tests.test_list[id].test_name); + print_message(3,message); + output=yaffs_tests.test_list[id].test_pointer(args_struct); + if (output<0) { + sprintf(message,"test_failed %s\n",yaffs_tests.test_list[id].test_name); + print_message(3,message); + } else { + print_message(3,"test_passed\n"); + } +} + +void run_linux_test(int id,arg_temp *args_struct) +{ + char message[200]; + int output =0; + print_message(3,"\n"); + //printf("id = %d\n",id); + sprintf(message,"running_test %s\n",linux_tests.test_list[id].test_name); + print_message(3,message); + output=linux_tests.test_list[id].test_pointer(args_struct); + if (output<0) { + sprintf(message,"test_failed %s\n",linux_tests.test_list[id].test_name); + print_message(3,message); + } else { + print_message(3,"test_passed\n"); + } +} + + +void clean_dir(void) +{ + char string[200]; + char file[200]; + char message[200]; + DIR *linux_open_dir; + struct dirent *linux_current_file; + int x=0,output=0; + + getcwd(string,200); + strcat(string,"/emfile-2k-0"); + sprintf(message,"\n\nunlinking emfile at this path: %s\n",string); + print_message(3,message); + unlink(string); + + + linux_open_dir = opendir(linux_struct.root_path); + if (linux_open_dir){ + + do + { + + linux_current_file =readdir(linux_open_dir); + if (NULL!=linux_current_file){ + + strcpy(file,linux_struct.root_path); + strcat(file,linux_current_file->d_name); + sprintf(message,"unlinking file %s\n",file); + print_message(3,message); + print_message(3,"chmoding file\n"); + output=chmod(file,(S_IRUSR|S_IWUSR)); + if (output<0) { + get_error_linux(); + } + print_message(3,"unlinking file\n"); + output=unlink(file); + if (output<0) { + get_error_linux(); + } + } + } while(linux_current_file); + closedir(linux_open_dir); + rmdir(linux_struct.root_path); + } + +} diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/mirror_tests.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/mirror_tests.h new file mode 100644 index 0000000..9d30833 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/mirror_tests.h @@ -0,0 +1,61 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __mirror_tests_h__ +#define __mirror_tests_h__ + +#include <stdio.h> +#include <dirent.h> +#include <unistd.h> //used for getting the current directory. +#include <string.h> +#include <errno.h> +#include "yaffsfs.h" +#include "lib.h" +#include <time.h> +#include <getopt.h> +#include <sys/stat.h> + +#include "linux_test_open.h" +#include "yaffs_test_open.h" +#include "linux_test_truncate.h" +#include "yaffs_test_truncate.h" +#include "linux_test_unlink.h" +#include "yaffs_test_unlink.h" +#include "linux_test_write.h" +#include "yaffs_test_write.h" + +#define LINUX 1 +#define YAFFS 2 + + + + + +void init(int argc, char *argv[]); +int run_random_test(int num_of_random_tests); +int compare_linux_and_yaffs(arg_temp *args_struct); + +int select_test_id(int test_len); +void generate_random_numbers(arg_temp *args_struct); +void run_yaffs_test(int id,arg_temp *args_struct); +void run_linux_test(int id,arg_temp *args_struct); +void clean_dir(void); +int select_test_id(int test_len); +int check_mode(arg_temp *args_struct); +int check_mode_file(char *path); +//void generate_array_of_objects_in_yaffs(void); +//void generate_array_of_objects_in_linux(void); + +#endif diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_open.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_open.c new file mode 100644 index 0000000..daeb8a4 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_open.c @@ -0,0 +1,38 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "yaffs_test_open.h" + +int yaffs_test_open(arg_temp *args_struct) +{ + char path[200]; + char message[100]; + int output=0; + join_paths(yaffs_struct.root_path,args_struct->string1, path ); + sprintf(message,"file path: %s\n",path); + print_message(3,message); + + output=yaffs_open(path,args_struct->char1 &(O_TRUNC|O_EXCL|O_CREAT|O_APPEND),args_struct->char2&(S_IREAD|S_IWRITE)); + if (output>=0){ + output= yaffs_close(output); + if (output<0) { + print_message(3,"failed to close handle\n"); + return -1; + } else { + return 1; + } + } else { + print_message(3,"failed to open file\n"); + return -1; + } +} diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_open.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_open.h new file mode 100644 index 0000000..d64bd29 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_open.h @@ -0,0 +1,26 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __yaffs_test_open_h__ +#define __yaffs_test_open_h__ +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include "yaffsfs.h" +#include "lib.h" + +int yaffs_test_open(arg_temp *args_struct); + +#endif diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_truncate.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_truncate.c new file mode 100644 index 0000000..9e99590 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_truncate.c @@ -0,0 +1,27 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "yaffs_test_truncate.h" + +int yaffs_test_truncate(arg_temp *args_struct) +{ + char path[200]; + char message[200]; + int output=0; + join_paths(yaffs_struct.root_path,args_struct->string1, path ); + sprintf(message,"file path: %s\n",path); + print_message(3,message); + + output=yaffs_truncate(path,args_struct->int1); + return output; +} diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_truncate.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_truncate.h new file mode 100644 index 0000000..02517cb --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_truncate.h @@ -0,0 +1,26 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __yaffs_test_truncate_h__ +#define __yaffs_test_truncate_h__ +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include "yaffsfs.h" +#include "lib.h" + +int yaffs_test_truncate(arg_temp *args_struct); + +#endif diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_unlink.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_unlink.c new file mode 100644 index 0000000..6982e77 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_unlink.c @@ -0,0 +1,34 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "yaffs_test_unlink.h" + +int yaffs_test_unlink(arg_temp *args_struct) +{ + char path[250]; + char message[150]; + int output; + join_paths(yaffs_struct.root_path,args_struct->string1, path ); + sprintf(message,"file path: %s\n",path); + print_message(3,message); + + output= yaffs_unlink(path); + + if (output<0) { + print_message(3,"failed to unlink file\n"); + return -1; + } else { + return 1; + } + +} diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_unlink.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_unlink.h new file mode 100644 index 0000000..cb8fdf2 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_unlink.h @@ -0,0 +1,26 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __yaffs_test_unlink_h__ +#define __yaffs_test_unlink_h__ +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include "yaffsfs.h" +#include "lib.h" + +int yaffs_test_unlink(arg_temp *args_struct); + +#endif diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_write.c b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_write.c new file mode 100644 index 0000000..2820d68 --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_write.c @@ -0,0 +1,85 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "yaffs_test_write.h" + +int yaffs_test_write(arg_temp *args_struct) +{ + char path[200]; + char message[200]; + int output=0,output2=0; + int handle; + struct yaffs_stat yaffs_stat_struct; + join_paths(yaffs_struct.root_path,args_struct->string1, path ); + sprintf(message,"trying to write to: %s\nwith mode set to %o \n",path,args_struct->char1); + print_message(3,message); + printf("mode S_IREAD %d S_IWRITE %d\n",(args_struct->char2 & S_IREAD),(args_struct->char2 & S_IWRITE)); + handle=yaffs_open(path,((args_struct->char1 &(O_TRUNC|O_EXCL|O_CREAT|O_APPEND))|O_RDWR),(args_struct->char2&(S_IREAD|S_IWRITE))); + printf("handle %d\n",handle); + if (handle<0){ + print_message(3,"failed to open a handle\n"); + return -1; //handle failed to open + } + +/* output=yaffs_fstat(handle,&yaffs_stat_struct); + if (output < 0){ + sprintf(message,"failed to stat the file\n"); + print_message(3,message); + get_error_yaffs(); + } else { + sprintf(message,"stated the file\n"); + print_message(3,message); + sprintf(message," yaffs file mode is %d\n",(yaffs_stat_struct.st_mode & (S_IREAD| S_IWRITE))); + print_message(3,message); + sprintf(message,"mode S_IREAD %d S_IWRITE %d\n",(yaffs_stat_struct.st_mode & S_IREAD),(yaffs_stat_struct.st_mode & S_IWRITE)); + print_message(3,message); + } + + sprintf(message,"trying to write: %d bytes into the file\n",strlen(args_struct->string2)); + print_message(3,message); +*/ + output=yaffs_write(handle,&args_struct->string2,strlen(args_struct->string2)); + +/* print_message(3,"\n wrote to the file\n"); + output2=yaffs_fstat(handle,&yaffs_stat_struct); + if (output2 < 0){ + sprintf(message,"failed to stat the file\n"); + print_message(3,message); + get_error_yaffs(); + } else { + sprintf(message,"stated the file\n"); + print_message(3,message); + sprintf(message," yaffs file mode is %d\n",(yaffs_stat_struct.st_mode & (S_IREAD| S_IWRITE))); + print_message(3,message); + sprintf(message,"mode S_IREAD %d S_IWRITE %d\n",(yaffs_stat_struct.st_mode & S_IREAD),(yaffs_stat_struct.st_mode & S_IWRITE)); + print_message(3,message); + } +*/ yaffs_close(handle); +/* print_message(3,"\n closing the file\n"); + output2=yaffs_stat(path,&yaffs_stat_struct); + if (output2 < 0){ + sprintf(message,"failed to stat the file\n"); + print_message(3,message); + get_error_yaffs(); + } else { + sprintf(message,"stated the file\n"); + print_message(3,message); + sprintf(message," yaffs file mode is %d\n",(yaffs_stat_struct.st_mode & (S_IREAD| S_IWRITE))); + print_message(3,message); + sprintf(message,"mode S_IREAD %d S_IWRITE %d\n",(yaffs_stat_struct.st_mode & S_IREAD),(yaffs_stat_struct.st_mode & S_IWRITE)); + print_message(3,message); + } +*/ + + return output; +} diff --git a/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_write.h b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_write.h new file mode 100644 index 0000000..0332f6f --- /dev/null +++ b/direct/timothy_tests/yaffs_and_linux_mirror_tests/yaffs_test_write.h @@ -0,0 +1,27 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy@yaffs.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __yaffs_test_write_h__ +#define __yaffs_test_write_h__ +#include <unistd.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include "yaffsfs.h" +#include "lib.h" + +int yaffs_test_write(arg_temp *args_struct); + +#endif |