nihilazo
/
rockbox
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Makes apps and plugins interract with directories using a posix-like api instead of calling dircache / simulator functions (no additionnal layer added, only a cosmetic change) 

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@13943 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Kevin Ferrare 2007-07-20 17:06:55 +00:00
parent 930278bcc0
commit 011a325e32
20 changed files with 255 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
apps/filetree.c
View File

@ -38,7 +38,6 @@
#include "plugin.h"
#include "rolo.h"
#include "sprintf.h"
#include "dircache.h"
#include "splash.h"
#include "yesno.h"
#include "cuesheet.h"
@ -84,11 +83,11 @@ int ft_build_playlist(struct tree_context* c, int start_index)
static void check_file_thumbnails(struct tree_context* c)
{
int i;
struct dircache_entry *entry;
struct dirent *entry;
struct entry* dircache = c->dircache;
DIRCACHED *dir;
DIR *dir;
dir = opendir_cached(c->currdir);
dir = opendir(c->currdir);
if(!dir)
return;
/* mark all files as non talking, except the .talk ones */
@ -109,7 +108,7 @@ static void check_file_thumbnails(struct tree_context* c)
}
}
while((entry = readdir_cached(dir)) != 0) /* walk directory */
while((entry = readdir(dir)) != 0) /* walk directory */
{
int ext_pos;
@ -135,7 +134,7 @@ static void check_file_thumbnails(struct tree_context* c)
}
}
}
closedir_cached(dir);
closedir(dir);
}
/* support function for qsort() */
@ -209,12 +208,12 @@ int ft_load(struct tree_context* c, const char* tempdir)
{
int i;
int name_buffer_used = 0;
DIRCACHED *dir;
DIR *dir;
if (tempdir)
dir = opendir_cached(tempdir);
dir = opendir(tempdir);
else
dir = opendir_cached(c->currdir);
dir = opendir(c->currdir);
if(!dir)
return -1; /* not a directory */
@ -223,7 +222,7 @@ int ft_load(struct tree_context* c, const char* tempdir)
for ( i=0; i < global_settings.max_files_in_dir; i++ ) {
int len;
struct dircache_entry *entry = readdir_cached(dir);
struct dirent *entry = readdir(dir);
struct entry* dptr =
(struct entry*)(c->dircache + i * sizeof(struct entry));
if (!entry)
@ -301,7 +300,7 @@ int ft_load(struct tree_context* c, const char* tempdir)
}
c->filesindir = i;
c->dirlength = i;
closedir_cached(dir);
closedir(dir);
qsort(c->dircache,i,sizeof(struct entry),compare);

1
apps/playlist.c
View File

@ -88,7 +88,6 @@
#include "button.h"
#include "filetree.h"
#include "abrepeat.h"
#include "dircache.h"
#include "thread.h"
#include "usb.h"
#include "filetypes.h"

17
apps/plugin.c
View File

@ -222,18 +222,11 @@ static const struct plugin_api rockbox_api = {
create_numbered_filename,
/* dir */
PREFIX(opendir),
PREFIX(closedir),
PREFIX(readdir),
PREFIX(mkdir),
PREFIX(rmdir),
/* dir, cached */
#ifdef HAVE_DIRCACHE
opendir_cached,
readdir_cached,
closedir_cached,
#endif
opendir,
closedir,
readdir,
mkdir,
rmdir,
/* kernel/ system */
PREFIX(sleep),

23
apps/plugin.h
View File

@ -37,9 +37,6 @@
#include "config.h"
#include "system.h"
#include "dir.h"
#ifndef SIMULATOR
#include "dircache.h"
#endif
#include "kernel.h"
#include "thread.h"
#include "button.h"
@ -115,12 +112,12 @@
#define PLUGIN_MAGIC 0x526F634B /* RocK */
/* increase this every time the api struct changes */
#define PLUGIN_API_VERSION 62
#define PLUGIN_API_VERSION 63
/* update this to latest version if a change to the api struct breaks
backwards compatibility (and please take the opportunity to sort in any
new function which are "waiting" at the end of the function table) */
#define PLUGIN_MIN_API_VERSION 62
#define PLUGIN_MIN_API_VERSION 63
/* plugin return codes */
enum plugin_status {
@ -316,17 +313,11 @@ struct plugin_api {
int numberlen IF_CNFN_NUM_(, int *num));
/* dir */
DIR* (*PREFIX(opendir))(const char* name);
int (*PREFIX(closedir))(DIR* dir);
struct dirent* (*PREFIX(readdir))(DIR* dir);
int (*PREFIX(mkdir))(const char *name);
int (*PREFIX(rmdir))(const char *name);
/* dir, cached */
#ifdef HAVE_DIRCACHE
DIRCACHED* (*opendir_cached)(const char* name);
struct dircache_entry* (*readdir_cached)(DIRCACHED* dir);
int (*closedir_cached)(DIRCACHED* dir);
#endif
DIR* (*opendir)(const char* name);
int (*closedir)(DIR* dir);
struct dirent* (*readdir)(DIR* dir);
int (*mkdir)(const char *name);
int (*rmdir)(const char *name);
/* kernel/ system */
void (*PREFIX(sleep))(int ticks);

8
apps/plugins/doom/rockdoom.c
View File

@ -329,7 +329,7 @@ int Dbuild_filelistm(struct menu_item **names, char *firstentry, char *directory
char *startpt;
struct menu_item *temp;
filedir=opendir(directory);
filedir=rb->opendir(directory);
if(filedir==NULL)
{
@ -345,8 +345,8 @@ int Dbuild_filelistm(struct menu_item **names, char *firstentry, char *directory
i++;
// Reset the directory
closedir(filedir);
filedir=opendir(directory);
rb->closedir(filedir);
filedir=rb->opendir(directory);
i++;
temp=malloc(i*sizeof(struct opt_items));
@ -365,7 +365,7 @@ int Dbuild_filelistm(struct menu_item **names, char *firstentry, char *directory
i++;
}
}
closedir(filedir);
rb->closedir(filedir);
*names=temp;
return i;
}

11
apps/plugins/doom/rockmacros.h
View File

@ -40,26 +40,17 @@ char *my_strtok( char * s, const char * delim );
#define read_line(a,b,c) rb->read_line((a),(b),(c))
#ifdef SIMULATOR
#undef opendir
#undef closedir
#undef mkdir
#undef open
#undef lseek
#undef filesize
#define opendir(a) rb->sim_opendir((a))
#define closedir(a) rb->sim_closedir((a))
#define mkdir(a) rb->sim_mkdir((a))
#define open(a,b) rb->sim_open((a),(b))
#define lseek(a,b,c) rb->sim_lseek((a),(b),(c))
#define filesize(a) rb->sim_filesize((a))
#else /* !SIMULATOR */
#define opendir(a) rb->opendir((a))
#define closedir(a) rb->closedir((a))
#define filesize(a) rb->filesize((a))
#define mkdir(a) rb->mkdir((a))
#define open(a,b) my_open((a),(b))
#define close(a) my_close((a))
#define lseek(a,b,c) rb->lseek((a),(b),(c))
#define filesize(a) rb->filesize((a))
#endif /* !SIMULATOR */
#define strtok(a,b) my_strtok((a),(b))

53
apps/plugins/properties.c
View File

@ -59,30 +59,18 @@ static bool file_properties(char* selected_file)
{
bool found = false;
char tstr[MAX_PATH];
#ifdef HAVE_DIRCACHE
DIRCACHED* dir;
struct dircache_entry* entry;
#else
DIR* dir;
struct dirent* entry;
#endif
char* ptr = rb->strrchr(selected_file, '/') + 1;
int dirlen = (ptr - selected_file);
rb->strncpy(tstr, selected_file, dirlen);
tstr[dirlen] = 0;
#ifdef HAVE_DIRCACHE
dir = rb->opendir_cached(tstr);
#else
dir = rb->opendir(tstr);
#endif
if (dir)
{
#ifdef HAVE_DIRCACHE
while(0 != (entry = rb->readdir_cached(dir)))
#else
while(0 != (entry = rb->readdir(dir)))
#endif
{
if(!rb->strcmp(entry->d_name, selected_file+dirlen))
{
@ -103,11 +91,7 @@ static bool file_properties(char* selected_file)
break;
}
}
#ifdef HAVE_DIRCACHE
rb->closedir_cached(dir);
#else
rb->closedir(dir);
#endif
}
return found;
}
@ -128,30 +112,17 @@ static bool _dir_properties(DPS* dps)
and informs the user of the progress */
bool result;
int dirlen;
#ifdef HAVE_DIRCACHE
DIRCACHED* dir;
struct dircache_entry* entry;
#else
DIR* dir;
struct dirent* entry;
#endif
result = true;
dirlen = rb->strlen(dps->dirname);
#ifdef HAVE_DIRCACHE
dir = rb->opendir_cached(dps->dirname);
#else
dir = rb->opendir(dps->dirname);
#endif
if (!dir)
return false; /* open error */
/* walk through the directory content */
#ifdef HAVE_DIRCACHE
while(result && (0 != (entry = rb->readdir_cached(dir))))
#else
while(result && (0 != (entry = rb->readdir(dir))))
#endif
{
/* append name to current directory */
rb->snprintf(dps->dirname+dirlen, dps->len-dirlen, "/%s",
@ -189,12 +160,7 @@ static bool _dir_properties(DPS* dps)
result = false;
rb->yield();
}
#ifdef HAVE_DIRCACHE
rb->closedir_cached(dir);
#else
rb->closedir(dir);
#endif
return result;
}
@ -256,30 +222,17 @@ enum plugin_status plugin_start(struct plugin_api* api, void* file)
/* determine if it's a file or a directory */
bool found = false;
#ifdef HAVE_DIRCACHE
DIRCACHED* dir;
struct dircache_entry* entry;
#else
DIR* dir;
struct dirent* entry;
#endif
char* ptr = rb->strrchr((char*)file, '/') + 1;
int dirlen = (ptr - (char*)file);
rb->strncpy(str_dirname, (char*)file, dirlen);
str_dirname[dirlen] = 0;
#ifdef HAVE_DIRCACHE
dir = rb->opendir_cached(str_dirname);
#else
dir = rb->opendir(str_dirname);
#endif
if (dir)
{
#ifdef HAVE_DIRCACHE
while(0 != (entry = rb->readdir_cached(dir)))
#else
while(0 != (entry = rb->readdir(dir)))
#endif
{
if(!rb->strcmp(entry->d_name, file+dirlen))
{
@ -288,11 +241,7 @@ enum plugin_status plugin_start(struct plugin_api* api, void* file)
break;
}
}
#ifdef HAVE_DIRCACHE
rb->closedir_cached(dir);
#else
rb->closedir(dir);
#endif
}
/* now we know if it's a file or a dir or maybe something failed */

6
apps/plugins/rockboy/rockboy.c
View File

@ -71,11 +71,11 @@ void setoptions (void)
DIR* dir;
char optionsave[sizeof(savedir)+sizeof(optionname)];
dir=opendir(savedir);
dir=rb->opendir(savedir);
if(!dir)
mkdir(savedir);
rb->mkdir(savedir);
else
closedir(dir);
rb->closedir(dir);
snprintf(optionsave, sizeof(optionsave), "%s/%s", savedir, optionname);

13
apps/plugins/rockboy/rockmacros.h
View File

@ -71,22 +71,13 @@ void dynamic_recompile (struct dynarec_block *newblock);
#define isalnum(c) (isdigit(c) || (isalpha(c)))
#ifdef SIMULATOR
#undef opendir
#define opendir(a) rb->sim_opendir((a))
#undef closedir
#define closedir(a) rb->sim_closedir((a))
#undef mkdir
#define mkdir(a) rb->sim_mkdir((a))
#undef open
#define open(a,b) rb->sim_open((a),(b))
#undef close
#define close(a) rb->close((a))
#undef lseek
#define lseek(a,b,c) rb->sim_lseek((a),(b),(c))
#undef close
#define close(a) rb->close((a))
#else /* !SIMULATOR */
#define opendir(a) rb->opendir((a))
#define closedir(a) rb->closedir((a))
#define mkdir(a) rb->mkdir((a))
#define open(a,b) rb->open((a),(b))
#define lseek(a,b,c) rb->lseek((a),(b),(c))
#define close(a) rb->close((a))

22
apps/plugins/rockpaint.c
View File

@ -688,7 +688,7 @@ static bool browse( char *dst, int dst_size, const char *start )
while( 1 )
{
d = rb->PREFIX(opendir)( bbuf );
d = rb->opendir( bbuf );
if( !d )
{
/*
@ -702,7 +702,7 @@ static bool browse( char *dst, int dst_size, const char *start )
else if( errno == EACCES || errno == ENOENT )
{
bbuf[0] = '/'; bbuf[1] = '\0';
d = rb->PREFIX(opendir)( "/" );
d = rb->opendir( "/" );
}
else
{
@ -714,12 +714,12 @@ static bool browse( char *dst, int dst_size, const char *start )
li = -1;
while( i < fvi )
{
rb->PREFIX(readdir)( d );
rb->readdir( d );
i++;
}
while( top_inside+(i-fvi)*(fh+LINE_SPACE) < HEIGHT )
{
de = rb->PREFIX(readdir)( d );
de = rb->readdir( d );
if( !de )
{
li = i-1;
@ -737,12 +737,12 @@ static bool browse( char *dst, int dst_size, const char *start )
lvi = i-1;
if( li == -1 )
{
if( !rb->PREFIX(readdir)( d ) )
if( !rb->readdir( d ) )
{
li = lvi;
}
}
rb->PREFIX(closedir)( d );
rb->closedir( d );
rb->lcd_update();
@ -863,7 +863,7 @@ static bool browse_fonts( char *dst, int dst_size )
{
b_need_redraw = 0;
d = rb->PREFIX(opendir)( FONT_DIR "/" );
d = rb->opendir( FONT_DIR "/" );
if( !d )
{
return false;
@ -873,7 +873,7 @@ static bool browse_fonts( char *dst, int dst_size )
li = -1;
while( i < fvi )
{
rb->PREFIX(readdir)( d );
rb->readdir( d );
i++;
}
cp = top_inside+LINE_SPACE;
@ -883,7 +883,7 @@ static bool browse_fonts( char *dst, int dst_size )
while( cp < top+HEIGHT )
{
de = rb->PREFIX(readdir)( d );
de = rb->readdir( d );
if( !de )
{
li = i-1;
@ -920,7 +920,7 @@ static bool browse_fonts( char *dst, int dst_size )
lvi = i-1;
if( li == -1 )
{
if( !(de = rb->PREFIX(readdir)( d ) ) )
if( !(de = rb->readdir( d ) ) )
{
li = lvi;
}
@ -936,7 +936,7 @@ static bool browse_fonts( char *dst, int dst_size )
}
}
rb->font_load( old_font );
rb->PREFIX(closedir)( d );
rb->closedir( d );
}
rb->lcd_set_drawmode(DRMODE_COMPLEMENT);

24
apps/tagcache.c
View File

@ -70,7 +70,7 @@
#include "crc32.h"
#include "misc.h"
#include "settings.h"
#include "dircache.h"
#include "dir.h"
#include "structec.h"
#ifndef __PCTOOL__
#include "atoi.h"
@ -327,7 +327,7 @@ static bool do_timed_yield(void)
#if defined(HAVE_TC_RAMCACHE) && defined(HAVE_DIRCACHE)
static long find_entry_ram(const char *filename,
const struct dircache_entry *dc)
const struct dirent *dc)
{
static long last_pos = 0;
int i;
@ -626,7 +626,7 @@ static bool retrieve(struct tagcache_search *tcs, struct index_entry *idx,
# ifdef HAVE_DIRCACHE
if (tag == tag_filename && idx->flag & FLAG_DIRCACHE)
{
dircache_copy_path((struct dircache_entry *)seek,
dircache_copy_path((struct dirent *)seek,
buf, size);
return true;
}
@ -1329,7 +1329,7 @@ static bool get_next(struct tagcache_search *tcs)
# ifdef HAVE_DIRCACHE
if (tcs->type == tag_filename)
{
dircache_copy_path((struct dircache_entry *)tcs->position,
dircache_copy_path((struct dirent *)tcs->position,
buf, sizeof buf);
tcs->result = buf;
tcs->result_len = strlen(buf) + 1;
@ -1583,7 +1583,7 @@ static int check_if_empty(char **tag)
offset += entry.tag_length[tag]
#if defined(HAVE_TC_RAMCACHE) && defined(HAVE_DIRCACHE)
static void add_tagcache(char *path, const struct dircache_entry *dc)
static void add_tagcache(char *path, const struct dirent *dc)
#else
static void add_tagcache(char *path)
#endif
@ -3464,7 +3464,7 @@ static bool load_tagcache(void)
if (tag == tag_filename)
{
# ifdef HAVE_DIRCACHE
const struct dircache_entry *dc;
const struct dirent *dc;
# endif
// FIXME: This is wrong!
@ -3647,14 +3647,14 @@ static bool check_deleted_files(void)
static bool check_dir(const char *dirname)
{
DIRCACHED *dir;
DIR *dir;
int len;
int success = false;
dir = opendir_cached(dirname);
dir = opendir(dirname);
if (!dir)
{
logf("tagcache: opendir_cached() failed");
logf("tagcache: opendir() failed");
return false;
}
@ -3665,9 +3665,9 @@ static bool check_dir(const char *dirname)
while (!check_event_queue())
#endif
{
struct dircache_entry *entry;
struct dirent *entry;
entry = readdir_cached(dir);
entry = readdir(dir);
if (entry == NULL)
{
@ -3698,7 +3698,7 @@ static bool check_dir(const char *dirname)
curpath[len] = '\0';
}
closedir_cached(dir);
closedir(dir);
return success;
}

10
apps/tree.c
View File

@ -931,20 +931,20 @@ static long pltick;
static bool add_dir(char* dirname, int len, int fd)
{
bool abort = false;
DIRCACHED* dir;
DIR* dir;
/* check for user abort */
if (action_userabort(TIMEOUT_NOBLOCK))
return true;
dir = opendir_cached(dirname);
dir = opendir(dirname);
if(!dir)
return true;
while (true) {
struct dircache_entry *entry;
struct dirent *entry;
entry = readdir_cached(dir);
entry = readdir(dir);
if (!entry)
break;
if (entry->attribute & ATTR_DIRECTORY) {
@ -1021,7 +1021,7 @@ static bool add_dir(char* dirname, int len, int fd)
}
}
}
closedir_cached(dir);
closedir(dir);
return abort;
}

2
firmware/SOURCES
View File

@ -28,7 +28,7 @@ common/crc32-mi4.c
#endif
common/ctype.c
#ifndef SIMULATOR
common/dir.c
common/dir_uncached.c
common/file.c
#endif /* SIMULATOR */
#ifdef HAVE_DIRCACHE

60
firmware/common/dir.c → firmware/common/dir_uncached.c
View File

@ -5,7 +5,7 @@
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
* $Id: dir.c 13741 2007-06-30 02:08:27Z jethead71 $
*
* Copyright (C) 2002 by Björn Stenberg
*
@ -24,11 +24,11 @@
#include "dir.h"
#include "debug.h"
#include "atoi.h"
#include "dircache.h"
//#include "dircache.h"
#define MAX_OPEN_DIRS 8
static DIR opendirs[MAX_OPEN_DIRS];
static DIR_UNCACHED opendirs[MAX_OPEN_DIRS];
#ifdef HAVE_MULTIVOLUME
@ -78,7 +78,7 @@ static int strip_volume(const char* name, char* namecopy)
// release all dir handles on a given volume "by force", to avoid leaks
int release_dirs(int volume)
{
DIR* pdir = opendirs;
DIR_UNCACHED* pdir = opendirs;
int dd;
int closed = 0;
for ( dd=0; dd<MAX_OPEN_DIRS; dd++, pdir++)
@ -93,14 +93,14 @@ int release_dirs(int volume)
}
#endif /* #ifdef HAVE_HOTSWAP */
DIR* opendir(const char* name)
DIR_UNCACHED* opendir_uncached(const char* name)
{
char namecopy[MAX_PATH];
char* part;
char* end;
struct fat_direntry entry;
int dd;
DIR* pdir = opendirs;
DIR_UNCACHED* pdir = opendirs;
#ifdef HAVE_MULTIVOLUME
int volume;
#endif
@ -170,16 +170,16 @@ DIR* opendir(const char* name)
return pdir;
}
int closedir(DIR* dir)
int closedir_uncached(DIR_UNCACHED* dir)
{
dir->busy=false;
return 0;
}
struct dirent* readdir(DIR* dir)
struct dirent_uncached* readdir_uncached(DIR_UNCACHED* dir)
{
struct fat_direntry entry;
struct dirent* theent = &(dir->theent);
struct dirent_uncached* theent = &(dir->theent);
if (!dir->busy)
return NULL;
@ -191,7 +191,7 @@ struct dirent* readdir(DIR* dir)
&& dir->volumecounter < NUM_VOLUMES /* in range */
&& dir->fatdir.file.volume == 0) /* at volume 0 */
{ /* fake special directories, which don't really exist, but
will get redirected upon opendir() */
will get redirected upon opendir_uncached() */
while (++dir->volumecounter < NUM_VOLUMES)
{
if (fat_ismounted(dir->volumecounter))
@ -222,14 +222,14 @@ struct dirent* readdir(DIR* dir)
return theent;
}
int mkdir(const char *name)
int mkdir_uncached(const char *name)
{
DIR *dir;
DIR_UNCACHED *dir;
char namecopy[MAX_PATH];
char* end;
char *basename;
char *parent;
struct dirent *entry;
struct dirent_uncached *entry;
struct fat_dir newdir;
int rc;
@ -253,7 +253,7 @@ int mkdir(const char *name)
DEBUGF("mkdir: parent: %s, name: %s\n", parent, basename);
dir = opendir(parent);
dir = opendir_uncached(parent);
if(!dir) {
DEBUGF("mkdir: can't open parent dir\n");
@ -267,11 +267,11 @@ int mkdir(const char *name)
}
/* Now check if the name already exists */
while ((entry = readdir(dir))) {
while ((entry = readdir_uncached(dir))) {
if ( !strcasecmp(basename, entry->d_name) ) {
DEBUGF("mkdir error: file exists\n");
errno = EEXIST;
closedir(dir);
closedir_uncached(dir);
return - 4;
}
}
@ -279,23 +279,18 @@ int mkdir(const char *name)
memset(&newdir, sizeof(struct fat_dir), 0);
rc = fat_create_dir(basename, &newdir, &(dir->fatdir));
#ifdef HAVE_DIRCACHE
if (rc >= 0)
dircache_mkdir(name);
#endif
closedir(dir);
closedir_uncached(dir);
return rc;
}
int rmdir(const char* name)
int rmdir_uncached(const char* name)
{
int rc;
DIR* dir;
struct dirent* entry;
DIR_UNCACHED* dir;
struct dirent_uncached* entry;
dir = opendir(name);
dir = opendir_uncached(name);
if (!dir)
{
errno = ENOENT; /* open error */
@ -303,14 +298,14 @@ int rmdir(const char* name)
}
/* check if the directory is empty */
while ((entry = readdir(dir)))
while ((entry = readdir_uncached(dir)))
{
if (strcmp(entry->d_name, ".") &&
strcmp(entry->d_name, ".."))
{
DEBUGF("rmdir error: not empty\n");
errno = ENOTEMPTY;
closedir(dir);
closedir_uncached(dir);
return -2;
}
}
@ -321,14 +316,7 @@ int rmdir(const char* name)
errno = EIO;
rc = rc * 10 - 3;
}
#ifdef HAVE_DIRCACHE
else
{
dircache_rmdir(name);
}
#endif
closedir(dir);
closedir_uncached(dir);
return rc;
}

48
firmware/common/dircache.c
View File

@ -27,7 +27,6 @@
#include <errno.h>
#include <string.h>
#include <stdbool.h>
#include "dir.h"
#include "debug.h"
#include "atoi.h"
#include "system.h"
@ -44,7 +43,7 @@
#define DIRCACHE_STOP 2
#define MAX_OPEN_DIRS 8
DIRCACHED opendirs[MAX_OPEN_DIRS];
DIR_CACHED opendirs[MAX_OPEN_DIRS];
static struct dircache_entry *fd_bindings[MAX_OPEN_FILES];
static struct dircache_entry *dircache_root;
@ -165,7 +164,7 @@ static bool check_event_queue(void)
static int dircache_scan(struct travel_data *td)
{
#ifdef SIMULATOR
while ( ( td->entry = readdir(td->dir) ) )
while ( ( td->entry = readdir_uncached(td->dir) ) )
#else
while ( (fat_getnext(td->dir, &td->entry) >= 0) && (td->entry.name[0]))
#endif
@ -221,10 +220,10 @@ static int dircache_scan(struct travel_data *td)
strncpy(&dircache_cur_path[td->pathpos+1], td->entry->d_name,
sizeof(dircache_cur_path) - td->pathpos - 2);
td->newdir = opendir(dircache_cur_path);
td->newdir = opendir_uncached(dircache_cur_path);
if (td->newdir == NULL)
{
logf("Failed to opendir(): %s", dircache_cur_path);
logf("Failed to opendir_uncached(): %s", dircache_cur_path);
return -3;
}
#else
@ -269,7 +268,7 @@ static int dircache_scan(struct travel_data *td)
* Recursively scan the hard disk and build the cache.
*/
#ifdef SIMULATOR
static int dircache_travel(DIR *dir, struct dircache_entry *ce)
static int dircache_travel(DIR_UNCACHED *dir, struct dircache_entry *ce)
#else
static int dircache_travel(struct fat_dir *dir, struct dircache_entry *ce)
#endif
@ -292,7 +291,7 @@ static int dircache_travel(struct fat_dir *dir, struct dircache_entry *ce)
ce->d_name = ".";
ce->name_len = 2;
#ifdef SIMULATOR
closedir(dir_recursion[depth].dir);
closedir_uncached(dir_recursion[depth].dir);
ce->attribute = ATTR_DIRECTORY;
#else
ce->attribute = FAT_ATTR_DIRECTORY;
@ -519,7 +518,7 @@ int dircache_save(void)
static int dircache_do_rebuild(void)
{
#ifdef SIMULATOR
DIR *pdir;
DIR_UNCACHED *pdir;
#else
struct fat_dir dir, *pdir;
#endif
@ -532,7 +531,7 @@ static int dircache_do_rebuild(void)
dircache_initializing = true;
#ifdef SIMULATOR
pdir = opendir("/");
pdir = opendir_uncached("/");
if (pdir == NULL)
{
logf("Failed to open rootdir");
@ -1082,11 +1081,11 @@ void dircache_add_file(const char *path, long startcluster)
entry->startcluster = startcluster;
}
DIRCACHED* opendir_cached(const char* name)
DIR_CACHED* opendir_cached(const char* name)
{
struct dircache_entry *cache_entry;
int dd;
DIRCACHED* pdir = opendirs;
DIR_CACHED* pdir = opendirs;
if ( name[0] != '/' )
{
@ -1108,7 +1107,7 @@ DIRCACHED* opendir_cached(const char* name)
if (!dircache_initialized)
{
pdir->regulardir = opendir(name);
pdir->regulardir = opendir_uncached(name);
if (!pdir->regulardir)
return NULL;
@ -1130,9 +1129,9 @@ DIRCACHED* opendir_cached(const char* name)
return pdir;
}
struct dircache_entry* readdir_cached(DIRCACHED* dir)
struct dircache_entry* readdir_cached(DIR_CACHED* dir)
{
struct dirent *regentry;
struct dirent_uncached *regentry;
struct dircache_entry *ce;
if (!dir->busy)
@ -1140,7 +1139,7 @@ struct dircache_entry* readdir_cached(DIRCACHED* dir)
if (dir->regulardir != NULL)
{
regentry = readdir(dir->regulardir);
regentry = readdir_uncached(dir->regulardir);
if (regentry == NULL)
return NULL;
@ -1181,15 +1180,30 @@ struct dircache_entry* readdir_cached(DIRCACHED* dir)
return &dir->secondary_entry;
}
int closedir_cached(DIRCACHED* dir)
int closedir_cached(DIR_CACHED* dir)
{
if (!dir->busy)
return -1;
dir->busy=false;
if (dir->regulardir != NULL)
return closedir(dir->regulardir);
return closedir_uncached(dir->regulardir);
return 0;
}
int mkdir_cached(const char *name)
{
int rc=mkdir_uncached(name);
if (rc >= 0)
dircache_mkdir(name);
return(rc);
}
int rmdir_cached(const char* name)
{
int rc=rmdir_uncached(name);
if(rc>=0)
dircache_rmdir(name);
return(rc);
}

4
firmware/common/disk.c
View File

@ -22,9 +22,9 @@
#include "fat.h"
#ifdef HAVE_HOTSWAP
#include "hotswap.h"
#include "dir.h" /* for release_dirs() */
#include "file.h" /* for release_files() */
#endif
#include "file.h" /* for release_dirs() */
#include "dir.h" /* for release_files() */
#include "disk.h"
/* Partition table entry layout:

28
firmware/common/file.c
View File

@ -21,7 +21,7 @@
#include <stdbool.h>
#include "file.h"
#include "fat.h"
#include "dir.h"
#include "dir_uncached.h"
#include "debug.h"
#include "dircache.h"
#include "system.h"
@ -59,8 +59,8 @@ int creat(const char *pathname)
static int open_internal(const char* pathname, int flags, bool use_cache)
{
DIR* dir;
struct dirent* entry;
DIR_UNCACHED* dir;
struct dirent_uncached* entry;
int fd;
char pathnamecopy[MAX_PATH];
char* name;
@ -134,12 +134,12 @@ static int open_internal(const char* pathname, int flags, bool use_cache)
name=strrchr(pathnamecopy+1,'/');
if ( name ) {
*name = 0;
dir = opendir(pathnamecopy);
dir = opendir_uncached(pathnamecopy);
*name = '/';
name++;
}
else {
dir = opendir("/");
dir = opendir_uncached("/");
name = pathnamecopy+1;
}
if (!dir) {
@ -153,12 +153,12 @@ static int open_internal(const char* pathname, int flags, bool use_cache)
DEBUGF("Empty file name\n");
errno = EINVAL;
file->busy = false;
closedir(dir);
closedir_uncached(dir);
return -5;
}
/* scan dir for name */
while ((entry = readdir(dir))) {
while ((entry = readdir_uncached(dir))) {
if ( !strcasecmp(name, entry->d_name) ) {
fat_open(IF_MV2(dir->fatdir.file.volume,)
entry->startcluster,
@ -180,7 +180,7 @@ static int open_internal(const char* pathname, int flags, bool use_cache)
DEBUGF("Couldn't create %s in %s\n",name,pathnamecopy);
errno = EIO;
file->busy = false;
closedir(dir);
closedir_uncached(dir);
return rc * 10 - 6;
}
#ifdef HAVE_DIRCACHE
@ -193,18 +193,18 @@ static int open_internal(const char* pathname, int flags, bool use_cache)
DEBUGF("Couldn't find %s in %s\n",name,pathnamecopy);
errno = ENOENT;
file->busy = false;
closedir(dir);
closedir_uncached(dir);
return -7;
}
} else {
if(file->write && (file->attr & FAT_ATTR_DIRECTORY)) {
errno = EISDIR;
file->busy = false;
closedir(dir);
closedir_uncached(dir);
return -8;
}
}
closedir(dir);
closedir_uncached(dir);
file->cacheoffset = -1;
file->fileoffset = 0;
@ -327,7 +327,7 @@ int remove(const char* name)
int rename(const char* path, const char* newpath)
{
int rc, fd;
DIR* dir;
DIR_UNCACHED* dir;
char* nameptr;
char* dirptr;
struct filedesc* file;
@ -371,7 +371,7 @@ int rename(const char* path, const char* newpath)
dirptr = "/";
}
dir = opendir(dirptr);
dir = opendir_uncached(dirptr);
if(!dir)
return - 5;
@ -401,7 +401,7 @@ int rename(const char* path, const char* newpath)
return rc * 10 - 8;
}
rc = closedir(dir);
rc = closedir_uncached(dir);
if (rc<0) {
errno = EIO;
return rc * 10 - 9;

88
firmware/include/dir.h
View File

@ -7,7 +7,7 @@
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Björn Stenberg
* Copyright (C) 2007 by Kévin Ferrare
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
@ -16,76 +16,30 @@
* KIND, either express or implied.
*
****************************************************************************/
#ifndef _DIR_H_
#define _DIR_H_
#include <stdbool.h>
#include "file.h"
#define ATTR_READ_ONLY 0x01
#define ATTR_HIDDEN 0x02
#define ATTR_SYSTEM 0x04
#define ATTR_VOLUME_ID 0x08
#define ATTR_DIRECTORY 0x10
#define ATTR_ARCHIVE 0x20
#define ATTR_VOLUME 0x40 /* this is a volume, not a real directory */
#ifdef SIMULATOR
#define dirent sim_dirent
#define DIR SIM_DIR
#define opendir(x) sim_opendir(x)
#define readdir(x) sim_readdir(x)
#define closedir(x) sim_closedir(x)
#define mkdir(x) sim_mkdir(x)
#define rmdir(x) sim_rmdir(x)
#endif
#ifndef DIRENT_DEFINED
struct dirent {
unsigned char d_name[MAX_PATH];
int attribute;
long size;
long startcluster;
unsigned short wrtdate; /* Last write date */
unsigned short wrttime; /* Last write time */
};
#endif
#include "fat.h"
typedef struct {
#ifndef SIMULATOR
bool busy;
long startcluster;
struct fat_dir fatdir;
struct fat_dir parent_dir;
struct dirent theent;
#ifdef HAVE_MULTIVOLUME
int volumecounter; /* running counter for faked volume entries */
#endif
#ifdef HAVE_DIRCACHE
# include "dircache.h"
# define DIR DIR_CACHED
# define dirent dircache_entry
# define opendir opendir_cached
# define closedir closedir_cached
# define readdir readdir_cached
# define closedir closedir_cached
# define mkdir mkdir_cached
# define rmdir rmdir_cached
#else
/* simulator: */
void *dir; /* actually a DIR* dir */
char *name;
#endif
} DIR;
#ifdef HAVE_HOTSWAP
char *get_volume_name(int volume);
#include "dir_uncached.h"
# define DIR DIR_UNCACHED
# define dirent dirent_uncached
# define opendir opendir_uncached
# define closedir closedir_uncached
# define readdir readdir_uncached
# define closedir closedir_uncached
# define mkdir mkdir_uncached
# define rmdir rmdir_uncached
#endif
#ifndef DIRFUNCTIONS_DEFINED
extern DIR* opendir(const char* name);
extern int closedir(DIR* dir);
extern int mkdir(const char* name);
extern int rmdir(const char* name);
extern struct dirent* readdir(DIR* dir);
extern int release_dirs(int volume);
#endif /* DIRFUNCTIONS_DEFINED */
#endif

91
firmware/include/dir_uncached.h Normal file
View File

@ -0,0 +1,91 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id: dir.h 13741 2007-06-30 02:08:27Z jethead71 $
*
* Copyright (C) 2002 by Björn Stenberg
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifndef _DIR_UNCACHED_H_
#define _DIR_UNCACHED_H_
#include <stdbool.h>
#include "file.h"
#define ATTR_READ_ONLY 0x01
#define ATTR_HIDDEN 0x02
#define ATTR_SYSTEM 0x04
#define ATTR_VOLUME_ID 0x08
#define ATTR_DIRECTORY 0x10
#define ATTR_ARCHIVE 0x20
#define ATTR_VOLUME 0x40 /* this is a volume, not a real directory */
#ifdef SIMULATOR
#define dirent_uncached sim_dirent
#define DIR_UNCACHED SIM_DIR
#define opendir_uncached sim_opendir
#define readdir_uncached sim_readdir
#define closedir_uncached sim_closedir
#define mkdir_uncached sim_mkdir
#define rmdir_uncached sim_rmdir
#endif
#ifndef DIRENT_DEFINED
struct dirent_uncached {
unsigned char d_name[MAX_PATH];
int attribute;
long size;
long startcluster;
unsigned short wrtdate; /* Last write date */
unsigned short wrttime; /* Last write time */
};
#endif
#include "fat.h"
typedef struct {
#ifndef SIMULATOR
bool busy;
long startcluster;
struct fat_dir fatdir;
struct fat_dir parent_dir;
struct dirent_uncached theent;
#ifdef HAVE_MULTIVOLUME
int volumecounter; /* running counter for faked volume entries */
#endif
#else
/* simulator: */
void *dir; /* actually a DIR* dir */
char *name;
#endif
} DIR_UNCACHED;
#ifdef HAVE_HOTSWAP
char *get_volume_name(int volume);
#endif
#ifndef DIRFUNCTIONS_DEFINED
extern DIR_UNCACHED* opendir_uncached(const char* name);
extern int closedir_uncached(DIR_UNCACHED* dir);
extern int mkdir_uncached(const char* name);
extern int rmdir_uncached(const char* name);
extern struct dirent_uncached* readdir_uncached(DIR_UNCACHED* dir);
extern int release_dirs(int volume);
#endif /* DIRFUNCTIONS_DEFINED */
#endif

26
firmware/include/dircache.h
View File

@ -19,7 +19,7 @@
#ifndef _DIRCACHE_H
#define _DIRCACHE_H
#include "dir.h"
#include "dir_uncached.h"
#ifdef HAVE_DIRCACHE
@ -34,8 +34,8 @@ struct travel_data {
struct dircache_entry *ce;
struct dircache_entry *down_entry;
#ifdef SIMULATOR
DIR *dir, *newdir;
struct dirent *entry;
DIR_UNCACHED *dir, *newdir;
struct dirent_uncached *entry;
#else
struct fat_dir *dir;
struct fat_dir newdir;
@ -77,8 +77,8 @@ typedef struct {
struct dircache_entry *entry;
struct dircache_entry *internal_entry;
struct dircache_entry secondary_entry;
DIR *regulardir;
} DIRCACHED;
DIR_UNCACHED *regulardir;
} DIR_CACHED;
void dircache_init(void);
int dircache_load(void);
@ -103,17 +103,11 @@ void dircache_remove(const char *name);
void dircache_rename(const char *oldpath, const char *newpath);
void dircache_add_file(const char *path, long startcluster);
DIRCACHED* opendir_cached(const char* name);
struct dircache_entry* readdir_cached(DIRCACHED* dir);
int closedir_cached(DIRCACHED *dir);
#else /* HAVE_DIRCACHE */
# define DIRCACHED DIR
# define dircache_entry dirent
# define opendir_cached opendir
# define closedir_cached closedir
# define readdir_cached readdir
# define closedir_cached closedir
DIR_CACHED* opendir_cached(const char* name);
struct dircache_entry* readdir_cached(DIR_CACHED* dir);
int closedir_cached(DIR_CACHED *dir);
int mkdir_cached(const char *name);
int rmdir_cached(const char* name);
#endif /* !HAVE_DIRCACHE */
#endif