From 428b10bb91a111934478771766f8c4e491bb33ac Mon Sep 17 00:00:00 2001 From: "bernard.xiong" Date: Sun, 25 Oct 2009 23:24:51 +0000 Subject: [PATCH] merge some semaphores to one mutex in DFS git-svn-id: https://rt-thread.googlecode.com/svn/trunk@135 bbd45198-f89e-11dd-88c7-29a3b14d5316 --- filesystem/dfs/include/dfs_fs.h | 7 ++- filesystem/dfs/src/dfs_fs.c | 77 ++++++++++++++++------------- filesystem/dfs/src/dfs_init.c | 54 ++++++++++---------- filesystem/dfs/src/dfs_posix.c | 22 +++++---- filesystem/dfs/src/dfs_raw.c | 87 +++++++++++++++++---------------- 5 files changed, 127 insertions(+), 120 deletions(-) diff --git a/filesystem/dfs/include/dfs_fs.h b/filesystem/dfs/include/dfs_fs.h index 4299e0d6ba..2431765856 100644 --- a/filesystem/dfs/include/dfs_fs.h +++ b/filesystem/dfs/include/dfs_fs.h @@ -78,10 +78,9 @@ int dfs_unmount(const char *specialfile); extern struct dfs_filesystem_operation* filesystem_operation_table[]; extern struct dfs_filesystem filesystem_table[]; -extern rt_sem_t filesystem_table_lock; -extern rt_sem_t filesystem_operation_table_lock; - extern char working_directory[]; -extern rt_sem_t working_directory_lock; + +void dfs_lock(void); +void dfs_unlock(void); #endif diff --git a/filesystem/dfs/src/dfs_fs.c b/filesystem/dfs/src/dfs_fs.c index 4b899dd423..a20b9b26c0 100644 --- a/filesystem/dfs/src/dfs_fs.c +++ b/filesystem/dfs/src/dfs_fs.c @@ -32,16 +32,22 @@ */ int dfs_register(struct dfs_filesystem_operation* ops) { - int index; + int index, result; - rt_sem_take(filesystem_operation_table_lock, RT_WAITING_FOREVER); + result = 0; + + /* lock filesystem */ + dfs_lock(); /* check if this filesystem was already registered */ for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++) { if (filesystem_operation_table[index] != RT_NULL && strcmp(filesystem_operation_table[index]->name, ops->name) == 0) + { + result = -1; goto err; + } } /* find out an empty filesystem type entry */ @@ -49,17 +55,18 @@ int dfs_register(struct dfs_filesystem_operation* ops) index++) ; /* filesystem type table full */ - if (index == DFS_FILESYSTEM_TYPES_MAX) goto err; + if (index == DFS_FILESYSTEM_TYPES_MAX) + { + result = -1; + goto err; + } /* save the filesystem's operations */ filesystem_operation_table[index] = ops; - rt_sem_release(filesystem_operation_table_lock); - return 0; - err: - rt_sem_release(filesystem_operation_table_lock); - return -1; + dfs_unlock(); + return result; } /* @@ -80,8 +87,8 @@ struct dfs_filesystem* dfs_filesystem_lookup(const char *path) fs = RT_NULL; prefixlen = 0; - /* lock filesystem table */ - rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER); + /* lock filesystem */ + dfs_lock(); /* lookup it in the filesystem table */ for (index = 0; index < DFS_FILESYSTEMS_MAX + 1; index++) @@ -97,7 +104,8 @@ struct dfs_filesystem* dfs_filesystem_lookup(const char *path) } } - rt_sem_release(filesystem_table_lock); + dfs_unlock(); + return fs; } @@ -191,7 +199,7 @@ int dfs_mount(const char* device_name, const char* path, struct dfs_filesystem_operation* ops; struct dfs_filesystem* fs; char *fullpath=RT_NULL; -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR char full_path[DFS_PATH_MAX + 1]; #endif rt_device_t dev_id; @@ -207,7 +215,7 @@ int dfs_mount(const char* device_name, const char* path, } /* find out specific filesystem */ - rt_sem_take(filesystem_operation_table_lock, RT_WAITING_FOREVER); + dfs_lock(); for ( index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++ ) { if (strcmp(filesystem_operation_table[index]->name, filesystemtype) == 0)break; @@ -217,22 +225,22 @@ int dfs_mount(const char* device_name, const char* path, if ( index == DFS_FILESYSTEM_TYPES_MAX ) { rt_set_errno(-DFS_STATUS_ENODEV); - rt_sem_release(filesystem_operation_table_lock); + dfs_unlock(); return -1; } ops = filesystem_operation_table[index]; - rt_sem_release(filesystem_operation_table_lock); + dfs_unlock(); /* make full path for special file */ fullpath = (char*)path; if ( fullpath[0] != '/') /* not an abstract path */ { -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR /* build full path */ fullpath = full_path; - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); + dfs_lock(); build_fullpath(working_directory, path, fullpath); - rt_sem_release(working_directory_lock); + dfs_unlock(); #else rt_set_errno(-DFS_STATUS_ENOTDIR); return -1; @@ -253,7 +261,7 @@ int dfs_mount(const char* device_name, const char* path, } /* check whether the file system mounted or not */ - rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER); + dfs_lock(); for (index =0; index < DFS_FILESYSTEMS_MAX; index++) { if ( filesystem_table[index].ops != RT_NULL && @@ -279,19 +287,17 @@ int dfs_mount(const char* device_name, const char* path, fs->ops = ops; fs->dev_id = dev_id; /* release filesystem_table lock */ - rt_sem_release(filesystem_table_lock); + dfs_unlock(); /* open device, but do not check the status of device */ rt_device_open(fs->dev_id, RT_DEVICE_OFLAG_RDWR); if ( ops->mount == RT_NULL ) /* there is no mount implementation */ { - rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER); - + dfs_lock(); /* clear filesystem table entry */ rt_memset(fs, 0, sizeof(struct dfs_filesystem)); - - rt_sem_release(filesystem_table_lock); + dfs_unlock(); rt_set_errno(-DFS_STATUS_ENOSYS); return -1; @@ -300,7 +306,7 @@ int dfs_mount(const char* device_name, const char* path, else if ( ops->mount(fs) < 0 ) { /* mount failed */ - rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER); + dfs_lock(); /* close device */ rt_device_close(fs->dev_id); @@ -308,14 +314,14 @@ int dfs_mount(const char* device_name, const char* path, /* clear filesystem table entry */ rt_memset(fs, 0, sizeof(struct dfs_filesystem)); - rt_sem_release(filesystem_table_lock); + dfs_unlock(); return -1; } return 0; err1: - rt_sem_release(filesystem_table_lock); + dfs_unlock(); return -1; } @@ -334,7 +340,7 @@ err1: int dfs_unmount(const char *specialfile) { char *fullpath; -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR char full_path[DFS_PATH_MAX + 1]; #endif struct dfs_filesystem* fs = RT_NULL; @@ -342,20 +348,20 @@ int dfs_unmount(const char *specialfile) fullpath = (char*)specialfile; if ( fullpath[0] != '/') { -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR /* build full path */ fullpath = full_path; - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); + dfs_lock(); build_fullpath(working_directory, specialfile, fullpath); - rt_sem_release(working_directory_lock); + dfs_unlock(); #else rt_set_errno(-DFS_STATUS_ENOTDIR); return -1; #endif } - /* lock filesystem table */ - rt_sem_take(filesystem_table_lock, RT_WAITING_FOREVER); + /* lock filesystem */ + dfs_lock(); fs = dfs_filesystem_lookup(fullpath); if (fs != RT_NULL && fs->ops->unmount != RT_NULL && fs->ops->unmount(fs) < 0) @@ -369,11 +375,12 @@ int dfs_unmount(const char *specialfile) /* clear this filesystem table entry */ rt_memset(fs, 0, sizeof(struct dfs_filesystem)); - rt_sem_release(filesystem_table_lock); + dfs_unlock(); return 0; err1: - rt_sem_release(filesystem_table_lock); + dfs_unlock(); + return -1; } diff --git a/filesystem/dfs/src/dfs_init.c b/filesystem/dfs/src/dfs_init.c index 5b72da71ed..7922bd438c 100644 --- a/filesystem/dfs/src/dfs_init.c +++ b/filesystem/dfs/src/dfs_init.c @@ -25,16 +25,18 @@ struct dfs_filesystem_operation* filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX + 1]; struct dfs_filesystem filesystem_table[DFS_FILESYSTEMS_MAX + 1]; -rt_sem_t filesystem_table_lock; -rt_sem_t filesystem_operation_table_lock; +/* device filesystem lock */ +struct rt_mutex dlock; -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR char working_directory[DFS_PATH_MAX + 1]; -rt_sem_t working_directory_lock; #endif -struct dfs_fd fd_table[DFS_FD_MAX + 1]; -rt_sem_t fd_table_lock; +#ifdef DFS_USING_STDIO +struct dfs_fd fd_table[3 + DFS_FD_MAX]; +#else +struct dfs_fd fd_table[DFS_FD_MAX]; +#endif /* +------------------------------------------------------------------------------ @@ -53,40 +55,34 @@ void dfs_init() for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX + 1; index++) filesystem_operation_table[index] = RT_NULL; - /* create filesystem operations table lock */ - filesystem_operation_table_lock = rt_sem_create("sem_fot", 1, RT_IPC_FLAG_FIFO); + /* create device filesystem lock */ + rt_mutex_init(&dlock, "dlock", RT_IPC_FLAG_FIFO); /* clear filesystem table */ - for (index = 0; index < DFS_FILESYSTEMS_MAX + 1; index++) - { - rt_memset(filesystem_table[index].path, 0, DFS_PATH_MAX + 1); + rt_memset(filesystem_table, 0, sizeof(filesystem_table)); - filesystem_table[index].ops = RT_NULL; - filesystem_table[index].dev_id = 0; - filesystem_table[index].block_id = 0; - filesystem_table[index].data = RT_NULL; - } - - /* create filesystem table lock */ - filesystem_table_lock = rt_sem_create("sem_fst", 1, RT_IPC_FLAG_FIFO); - -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR /* set current working directory */ strcpy(working_directory, "/"); - working_directory_lock = rt_sem_create("sem_wd", 1, RT_IPC_FLAG_FIFO); #endif /* clean fd table */ - for ( index = 0; index < DFS_FD_MAX; index ++) - { - rt_memset(&fd_table[index], 0, sizeof(struct dfs_fd)); - } - - /* create fd table lock */ - fd_table_lock = rt_sem_create("sem_fdt", 1, RT_IPC_FLAG_FIFO); + rt_memset(fd_table, 0, sizeof(fd_table)); #if defined(RT_USING_FINSH) && !defined(FINSH_USING_SYMTAB) dfs_export_finsh(); #endif } +void dfs_lock() +{ + rt_err_t result; + + result = rt_mutex_take(&dlock, RT_WAITING_FOREVER); + RT_ASSERT(result == RT_EOK); +} + +void dfs_unlock() +{ + rt_mutex_release(&dlock); +} diff --git a/filesystem/dfs/src/dfs_posix.c b/filesystem/dfs/src/dfs_posix.c index fb4a0ee2ed..b65bacb0c8 100644 --- a/filesystem/dfs/src/dfs_posix.c +++ b/filesystem/dfs/src/dfs_posix.c @@ -12,6 +12,8 @@ | 2009-05-27 Yi.qiu The first version. +------------------------------------------------------------------------------ */ +#include +#include #include /* @@ -521,20 +523,20 @@ int chdir(const char *path) { /* build full path */ fullpath = full_path; -#ifdef RT_USING_WORKDIR - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); +#ifdef DFS_USING_WORKDIR + dfs_lock(); build_fullpath(working_directory, path, fullpath); strcpy(working_directory, fullpath); - rt_sem_release(working_directory_lock); + dfs_unlock(); #endif } else { -#ifdef RT_USING_WORKDIR - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); +#ifdef DFS_USING_WORKDIR + dfs_lock(); rt_strncpy(working_directory, path, strlen(path) + 1); working_directory[strlen(path)] = '\0'; - rt_sem_release(working_directory_lock); + dfs_unlock(); #endif } @@ -554,10 +556,12 @@ int chdir(const char *path) */ char* getcwd(char *buf, rt_size_t size) { -#ifdef RT_USING_WORKDIR - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); +#ifdef DFS_USING_WORKDIR + dfs_lock(); rt_strncpy(buf, working_directory, size); - rt_sem_release(working_directory_lock); + dfs_unlock(); +#else + rt_kprintf("WARNING: not support working directory\n"); #endif return buf; } diff --git a/filesystem/dfs/src/dfs_raw.c b/filesystem/dfs/src/dfs_raw.c index a3be0b6a13..7a4f1cbc4a 100644 --- a/filesystem/dfs/src/dfs_raw.c +++ b/filesystem/dfs/src/dfs_raw.c @@ -16,8 +16,7 @@ #include #include -extern struct dfs_fd fd_table[DFS_FD_MAX + 1]; -extern rt_sem_t fd_table_lock; +extern struct dfs_fd fd_table[]; /* +------------------------------------------------------------------------------ @@ -35,26 +34,32 @@ int fd_new(void) struct dfs_fd* d; int idx; - rt_sem_take(fd_table_lock, RT_WAITING_FOREVER); + /* lock filesystem */ + dfs_lock(); /* find an empty fd entry */ -#ifdef RT_USING_STDIO - for (idx = 3; idx < DFS_FD_MAX && fd_table[idx].ref_count > 0; idx++); +#ifdef DFS_USING_STDIO + for (idx = 3; idx < DFS_FD_MAX + 3 && fd_table[idx].ref_count > 0; idx++); #else for (idx = 0; idx < DFS_FD_MAX && fd_table[idx].ref_count > 0; idx++); #endif /* can't find an empty fd entry */ +#ifdef DFS_USING_STDIO + if (idx == DFS_FD_MAX + 3) +#else if (idx == DFS_FD_MAX) +#endif { - rt_sem_release(fd_table_lock); - return -1; + idx = -1; + goto __result; } d = &(fd_table[idx]); d->ref_count = 1; - rt_sem_release(fd_table_lock); +__result: + dfs_unlock(); return idx; } @@ -73,17 +78,17 @@ struct dfs_fd* fd_get(int fd) { struct dfs_fd* d; -#ifdef RT_USING_STDIO - if ( fd < 3 || fd > DFS_FD_MAX ) return RT_NULL; +#ifdef DFS_USING_STDIO + if ( fd < 3 || fd > DFS_FD_MAX + 3) return RT_NULL; #else if ( fd < 0 || fd > DFS_FD_MAX ) return RT_NULL; #endif d = &fd_table[fd]; - rt_sem_take(fd_table_lock, RT_WAITING_FOREVER); + dfs_lock(); d->ref_count ++; - rt_sem_release(fd_table_lock); + dfs_unlock(); return d; } @@ -101,14 +106,14 @@ struct dfs_fd* fd_get(int fd) */ void fd_put(struct dfs_fd* fd) { - rt_sem_take(fd_table_lock, RT_WAITING_FOREVER); + dfs_lock(); fd->ref_count --; /* clear this fd entry */ if ( fd->ref_count == 0 ) { rt_memset(fd, 0, sizeof(struct dfs_fd)); } - rt_sem_release(fd_table_lock); + dfs_unlock(); }; /* @@ -126,7 +131,7 @@ int dfile_raw_open(struct dfs_fd* fd, const char *path, int flags) { struct dfs_filesystem* fs; char *fullpath; -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR char full_path[DFS_PATH_MAX + 1]; #endif int fspathlen, result; @@ -138,12 +143,12 @@ int dfile_raw_open(struct dfs_fd* fd, const char *path, int flags) fullpath = (char*)path; if ( fullpath[0] != '/') { -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR /* build full path */ fullpath = &full_path[0]; - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); + dfs_lock(); build_fullpath(working_directory, path, fullpath); - rt_sem_release(working_directory_lock); + dfs_unlock(); #else #ifdef RT_USING_FINSH rt_kprintf("bad filename"); @@ -341,7 +346,7 @@ int dfile_raw_unlink(const char *path) { struct dfs_filesystem* fs; char *fullpath, *real_path, search_path[DFS_PATH_MAX + 1]; -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR char full_path[DFS_PATH_MAX+1]; #endif struct dfs_fd* fd; @@ -351,12 +356,12 @@ int dfile_raw_unlink(const char *path) fullpath = (char*)path; if ( fullpath[0] != '/') { -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR /* build full path */ fullpath = full_path; - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); + dfs_lock(); build_fullpath(working_directory, path, fullpath); - rt_sem_release(working_directory_lock); + dfs_unlock(); #else #ifdef RT_USING_FINSH rt_kprintf("bad filename"); @@ -368,7 +373,7 @@ int dfile_raw_unlink(const char *path) if ( (fs = dfs_filesystem_lookup(fullpath)) == RT_NULL) return -DFS_STATUS_ENOENT; /* Check whether file is already open */ - rt_sem_take(fd_table_lock, RT_WAITING_FOREVER); + dfs_lock(); for (index = 0; index < DFS_FD_MAX; index++) { fd = &(fd_table[index]); @@ -377,11 +382,11 @@ int dfile_raw_unlink(const char *path) build_fullpath(fd->fs->path, fd->path, search_path); if (strcmp(fullpath, search_path) == 0) { - rt_sem_release(fd_table_lock); + dfs_unlock(); return -DFS_STATUS_EEXIST; } } - rt_sem_release(fd_table_lock); + dfs_unlock(); fspathlen = strlen(fs->path); real_path = search_path; @@ -452,7 +457,7 @@ int dfile_raw_stat(const char *path, struct dfs_stat *buf) { struct dfs_filesystem* fs; char* fullpath, real_path[DFS_PATH_MAX + 1]; -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR char full_path[DFS_PATH_MAX + 1]; #endif int fspathlen; @@ -460,15 +465,15 @@ int dfile_raw_stat(const char *path, struct dfs_stat *buf) fullpath = (char*)path; if ( fullpath[0] != '/' ) { -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR /* build full path */ fullpath = full_path; - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); + dfs_lock(); build_fullpath(working_directory, path, fullpath); - rt_sem_release(working_directory_lock); + dfs_unlock(); #else #ifdef RT_USING_FINSH - rt_kprintf("bad filename"); + rt_kprintf("not support working directory, bad filename\n"); #endif return -1; #endif @@ -509,42 +514,38 @@ int dfile_raw_rename(const char* oldpath, const char* newpath) { struct dfs_filesystem *oldfs, *newfs; char *oldfullpath, *newfullpath; - #ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR /* Change DFS_PATH_MAX to DFS_PATH_MAX + 1, yi.qiu@2008.09.23*/ char old_realpath[DFS_PATH_MAX + 1], new_realpath[DFS_PATH_MAX + 1]; - #endif +#endif oldfullpath = (char*)oldpath; newfullpath = (char*)newpath; if ( oldfullpath[0] != '/' ) { -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR /* build full path */ oldfullpath = old_realpath; - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); + dfs_lock(); build_fullpath(working_directory, oldpath, oldfullpath); - rt_sem_release(working_directory_lock); + dfs_unlock(); #else -#ifdef RT_USING_FINSH - rt_kprintf("bad filename"); -#endif + rt_kprintf("bad filename\n"); return -1; #endif } if ( newfullpath[0] != '/' ) { -#ifdef RT_USING_WORKDIR +#ifdef DFS_USING_WORKDIR /* build full path */ newfullpath = new_realpath; - rt_sem_take(working_directory_lock, RT_WAITING_FOREVER); + dfs_lock(); build_fullpath(working_directory, newpath, newfullpath); - rt_sem_release(working_directory_lock); + dfs_unlock(); #else -#ifdef RT_USING_FINSH rt_kprintf("bad filename"); -#endif return -1; #endif }