Example #1
0
void cmd_yaffs_ls(const char *mountpt, int longlist)
{
	int i;
	yaffs_DIR *d;
	struct yaffs_dirent *de;
	struct yaffs_stat stat;
	char tempstr[255];

	d = yaffs_opendir(mountpt);

	if (!d) {
		printf("opendir failed, %s\n", yaffs_error_str());
		return;
	}

	for (i = 0; (de = yaffs_readdir(d)) != NULL; i++) {
		if (longlist) {
			sprintf(tempstr, "%s/%s", mountpt, de->d_name);
			yaffs_lstat(tempstr, &stat);
			printf("%-25s\t%7ld",
					de->d_name,
					(long)stat.st_size);
			printf(" %5d %s\n",
					stat.st_ino,
					yaffs_file_type_str(&stat));
		} else {
			printf("%s\n", de->d_name);
		}
	}

	yaffs_closedir(d);
}
Example #2
0
void cmd_yaffs_ls(const char *mountpt, int longlist)
{
	int i;
	yaffs_DIR *d;
	yaffs_dirent *de;
	struct yaffs_stat stat;
	char tempstr[255];

	checkMount();
	d = yaffs_opendir(mountpt);

	if(!d)
	{
		printf("opendir failed\n");
	}
	else
	{
		for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
		{
			if (longlist)
			{
				sprintf(tempstr, "%s/%s", mountpt, de->d_name);
				yaffs_stat(tempstr, &stat);
				printf("%-25s\t%7ld\n",de->d_name, stat.st_size);
			}
			else
			{
				printf("%s\n",de->d_name);
			}
		}
	}
}
Example #3
0
/*==============================================================================
 * - cd()
 *
 * - change directory
 */
int cd(int argc, char *argv[])
{
    yaffs_DIR *d;
    char temp_dir[PATH_LEN_MAX];

    CHECK_ARG_NUM(2, "please type dir name");

    /*
     * get the new dir 
     */
    _make_abs_path(temp_dir, argv[1]);

    /*
     * try to open the new dir
     */
    d = yaffs_opendir(temp_dir);

    if (!d) {
        serial_printf("directory '%s' not exist", temp_dir);
        return CMD_ERROR;
    } else {
        strcpy(_G_pwd, temp_dir);
    }
    yaffs_closedir(d);

    /*
     * append a slash
     */
    if (_G_pwd[strlen(_G_pwd) - 1] != '/') {
        strcat(_G_pwd, "/");
    }

    return CMD_OK;
}
Example #4
0
/*==============================================================================
 * - _album_add_file()
 *
 * - search all file in <path> dir, and add extern with <ext> to list
 */
static int _album_add_file (const char *path, const char *ext)
{
    yaffs_DIR     *d;
    yaffs_dirent  *de;

    int            i;
    PIC_NAME_NODE *pNewPic = NULL;
    int            file_name_len;

    d = yaffs_opendir(path);

    for(i = 0; (de = yaffs_readdir(d)) != NULL; i++) {

        file_name_len = strlen (de->d_name);

        if (strlen(path) +  file_name_len < PATH_LEN_MAX && /* file name not too long */
            strcmp (de->d_name + file_name_len - strlen(ext), ext) == 0) {

            pNewPic = malloc (sizeof (PIC_NAME_NODE));
            if (pNewPic != NULL) {
                strcpy(pNewPic->name, path);
                strcat(pNewPic->name, de->d_name);

                dlist_add (&_G_pic_list, (DL_NODE *)pNewPic);
            }
        }
    }

    yaffs_closedir(d);

    return i;
}
Example #5
0
static int __yaffs_opendir(mount_point_t *point, file_t *file, const char *path)
{
    file->ctx = yaffs_opendir(vfs_path_add_mount_point(path));
    if (file->ctx == NULL) {
        return -1;
    } else {
        return 0;
    }
Example #6
0
int huge_directory_test_on_path(char *path)
{

	yaffs_DIR *d;
	yaffs_dirent *de;
	struct yaffs_stat s;

	int f;
	int i;

	int total = 0;
	int lastTotal = 0;
	
	char str[100];

	
	yaffs_StartUp();
	
	yaffs_mount(path);
	
	// Create a large number of files
	
	for(i = 0; i < 2000; i++)
	{
	  sprintf(str,"%s/%d",path,i);
	  
	   f = yaffs_open(str,O_CREAT,S_IREAD | S_IWRITE);
	   yaffs_close(f);
	}
	
	
	
	d = yaffs_opendir(path);
	i = 0;
	if (d) {
	while((de = yaffs_readdir(d)) != NULL) {
	if (total >lastTotal+100*9*1024||(i & 1023)==0){
	printf("files = %d, total = %d\n",i, total);
	lastTotal = total;
	}
		i++;
		sprintf(str,"%s/%s",path,de->d_name);
		yaffs_lstat(str,&s);
		switch(s.st_mode & S_IFMT){
		case S_IFREG:
	//printf("data file");
	total += s.st_size;
	break;
	}
	}
	
	yaffs_closedir(d);
	}
	
	return 0;
}
Example #7
0
/*
** Factory of directory iterators
*/
static int dir_iter_factory (lua_State *L) {
	const char *path = luaL_checkstring (L, 1);
	dir_data *d;
	lua_pushcfunction (L, dir_iter);
	d = (dir_data *) lua_newuserdata (L, sizeof(dir_data));
	luaL_getmetatable (L, DIR_METATABLE);
	lua_setmetatable (L, -2);
	d->closed = 0;
	d->dir = yaffs_opendir (path);
	if (d->dir == NULL)
          luaL_error (L, "cannot open %s: %s", path, strerror (errno));
	return 2;
}
Example #8
0
static void dump_directory_tree_worker(const char *dname,int recursive)
{
	yaffs_DIR *d;
	yaffs_dirent *de;
	struct yaffs_stat s;
	char str[1000];
			
	d = yaffs_opendir(dname);
	
	if(!d)
	{
		printf("opendir failed\n");
	}
	else
	{
		while((de = yaffs_readdir(d)) != NULL)
		{
			strcpy(str,dname);
			strcat(str,"/");
			strcat(str,de->d_name);
			
			yaffs_lstat(str,&s);
			
			printf("%s inode %d obj %x length %d mode %X ",str,s.st_ino,de->d_dont_use,(int)s.st_size,s.st_mode);
			switch(s.st_mode & S_IFMT)
			{
				case S_IFREG: printf("data file"); break;
				case S_IFDIR: printf("directory"); break;
				case S_IFLNK: printf("symlink -->");
							  if(yaffs_readlink(str,str,100) < 0)
								printf("no alias");
							  else
								printf("\"%s\"",str);    
							  break;
				default: printf("unknown"); break;
			}
			
			printf("\n");

			if((s.st_mode & S_IFMT) == S_IFDIR && recursive)
				dump_directory_tree_worker(str,1);
				
                        if(s.st_ino > 10000)
                          FatalError();
							
		}
		
		yaffs_closedir(d);
	}

}
Example #9
0
void dumpDirFollow(const char *dname)
{
	yaffs_DIR *d;
	yaffs_dirent *de;
	struct yaffs_stat s;
	char str[100];
			
	d = yaffs_opendir(dname);
	
	if(!d)
	{
		printf("opendir failed\n");
	}
	else
	{
		while((de = yaffs_readdir(d)) != NULL)
		{
			sprintf(str,"%s/%s",dname,de->d_name);
			
			yaffs_stat(str,&s);
			
			printf("%s ino %d length %d mode %X ",de->d_name,(int)s.st_ino,(int)s.st_size,s.st_mode);
			switch(s.st_mode & S_IFMT)
			{
				case S_IFREG: printf("data file"); break;
				case S_IFDIR: printf("directory"); break;
				case S_IFLNK: printf("symlink -->");
							  if(yaffs_readlink(str,str,100) < 0)
								printf("no alias");
							  else
								printf("\"%s\"",str);    
							  break;
				default: printf("unknown"); break;
			}
			
			printf("\n");           
		}
		
		yaffs_closedir(d);
	}
	printf("\n");
	
	printf("Free space in %s is %d\n\n",dname,(int)yaffs_freespace(dname));

}
Example #10
0
/*==============================================================================
 * - ls()
 *
 * - list the files and direcories in a directory
 */
int ls(int argc, char *argv[])
{
    int i, j;
    char dir[PATH_LEN_MAX];

    yaffs_DIR *d;
    yaffs_dirent *de;

    if (argc < 2) {
        strcpy(dir, _G_pwd);
    } else {
        _make_abs_path(dir, argv[1]);
    }

    d = yaffs_opendir(dir);

    if(!d) {
        serial_printf("opendir failed");
        return CMD_ERROR;
    } else {
        for(i = 0; (de = yaffs_readdir(d)) != NULL; i++) {
            if ((i != 0) && (i % NAMES_PER_LINE) == 0 ) {
                serial_printf("\n");
            }
            if (yaffs_is_dir2 (dir, de->d_name)) {
                serial_printf (COLOR_FG_GREEN);
            } else {
                serial_printf (COLOR_FG_WHITE);
            }
            serial_printf ("%s", de->d_name);
            for (j = strlen (de->d_name); j < NAME_WIDTH; j++) {
                serial_putc (' ');
            }
        }
        serial_printf (COLOR_FG_WHITE);
    }
    yaffs_closedir(d);

    return CMD_OK;
}
Example #11
0
/*==============================================================================
 * - _list_dir()
 *
 * - refresh the directory list nodes
 */
static int _list_dir (const char *path, DL_LIST *pDirList)
{
    int            i;
    yaffs_DIR     *d;
    yaffs_dirent  *de;
    DIR_LIST_NODE *pListNode = NULL;
    char           full_name[PATH_LEN_MAX];

    d = yaffs_opendir(path);

    /* free previous list nodes */
    pListNode = (DIR_LIST_NODE *)dlist_get (pDirList);
    while (pListNode != NULL) {
        free (pListNode);
        pListNode = (DIR_LIST_NODE *)dlist_get (&_G_dir_list);
    }

    if (!d) {
        return 0;
    }

    /* alloc new list nodes */
    for(i = 0; (de = yaffs_readdir(d)) != NULL; i++) {
        pListNode = malloc (sizeof (DIR_LIST_NODE));
        if (pListNode != NULL) {
            strcpy(pListNode->name, de->d_name);

            strcpy(full_name, path);
            strcat(full_name, de->d_name);
            if (yaffs_is_dir (full_name)) {
                strcat(pListNode->name, "/");
            }

            dlist_add (pDirList, (DL_NODE *)pListNode);
        }
    }
    yaffs_closedir(d);

    return i;
}
Example #12
0
void ListDir(const char *DirName)
{
	yaffs_DIR *d;
	yaffs_dirent *de;
	struct yaffs_stat s;
	char str[100];
			
	d = yaffs_opendir(DirName);
	
	if(!d)
	{
		printf("opendir failed\n");
	}
	else
	{
		printf("%s\n", DirName);
		while((de = yaffs_readdir(d)) != NULL)
		{
			sprintf(str,"%s/%s",DirName,de->d_name);
			yaffs_lstat(str,&s);
			printf("%20s        %8d     %5d    ", de->d_name, s.yst_size, s.yst_mode);
			
			switch(s.yst_mode & S_IFMT)
			{
				case S_IFREG: printf("data file"); break;
				case S_IFDIR: printf("directory"); break;
				case S_IFLNK: printf("symlink");   break;
				default: printf("unknown"); break;
			}
		
			printf("\n");		
		}
		
		yaffs_closedir(d);
	}
	
	printf("FreeSpace: %d\n\n", yaffs_freespace(DirName));
}
Example #13
0
void test_b(void *x)
{
	struct bovver_context *bc = (struct bovver_context *)x;
	int n = rand() % 20;
	
	bc->cycle++;

	if(!bc->dirH)
		bc->dirH = yaffs_opendir(bc->baseDir);

	if(!bc->dirH)
		return;

	if(n == 0){
		yaffs_closedir(bc->dirH);
		bc->dirH = NULL;
	} else {
		while(n > 1){
			n--;
			yaffs_readdir(bc->dirH);
		}
	}
}
Example #14
0
void lookup_test(const char *mountpt)
{
	int i;
	int h;
	char a[100];
	

	yaffs_DIR *d;
	yaffs_dirent *de;

	yaffs_StartUp();
	
	yaffs_mount(mountpt);
				
	d = yaffs_opendir(mountpt);
	
	if(!d)
	{
		printf("opendir failed\n");
	}
	else
	{
		
		for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
		{
			printf("unlinking %s\n",de->d_name);
			yaffs_unlink(de->d_name);
		}
		
		printf("%d files deleted\n",i);
	}
	
	
	for(i = 0; i < 2000; i++){
	sprintf(a,"%s/%d",mountpt,i);
		h =  yaffs_open(a,O_CREAT | O_TRUNC | O_RDWR, 0);
		yaffs_close(h);
	}

	yaffs_rewinddir(d);
	for(i = 0; (de = yaffs_readdir(d)) != NULL; i++)
	{
		printf("%d  %s\n",i,de->d_name);
	}	
	
	printf("%d files listed\n\n\n",i);
	
	yaffs_rewinddir(d);
	yaffs_readdir(d);
	yaffs_readdir(d);
	yaffs_readdir(d);
	
	for(i = 0; i < 2000; i++){
		sprintf(a,"%s/%d",mountpt,i);
		yaffs_unlink(a);
	}
	
		
	yaffs_unmount(mountpt);
	
}