From 44a2d720a02775987dca11dc6aab74e55c355a59 Mon Sep 17 00:00:00 2001 From: dzzxzz Date: Fri, 23 Dec 2011 02:11:55 +0000 Subject: [PATCH] unify the components/dfs coding style according to the /documentation/coding_style_cn.txt git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1866 bbd45198-f89e-11dd-88c7-29a3b14d5316 --- components/dfs/filesystems/elmfat/dfs_elm.c | 172 ++++--- components/dfs/filesystems/nfs/dfs_nfs.c | 415 ++++++++-------- components/dfs/filesystems/nfs/dfs_nfs.h | 13 + components/dfs/filesystems/romfs/dfs_romfs.c | 93 ++-- components/dfs/filesystems/romfs/dfs_romfs.h | 13 + components/dfs/include/dfs.h | 12 +- components/dfs/include/dfs_def.h | 7 +- components/dfs/include/dfs_elm.h | 25 +- components/dfs/include/dfs_file.h | 41 +- components/dfs/include/dfs_fs.h | 57 +-- components/dfs/include/dfs_init.h | 34 +- components/dfs/include/dfs_posix.h | 9 +- components/dfs/src/dfs.c | 75 +-- components/dfs/src/dfs_file.c | 135 +++--- components/dfs/src/dfs_fs.c | 485 ++++++++++--------- components/dfs/src/dfs_posix.c | 71 +-- 16 files changed, 896 insertions(+), 761 deletions(-) diff --git a/components/dfs/filesystems/elmfat/dfs_elm.c b/components/dfs/filesystems/elmfat/dfs_elm.c index f85411f108..d52874255c 100644 --- a/components/dfs/filesystems/elmfat/dfs_elm.c +++ b/components/dfs/filesystems/elmfat/dfs_elm.c @@ -73,7 +73,7 @@ static int elm_result_to_dfs(FRESULT result) return status; } -int dfs_elm_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data) +int dfs_elm_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data) { FATFS *fat; FRESULT result; @@ -87,12 +87,13 @@ int dfs_elm_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* d break; } } - if (index == _VOLUMES) return -DFS_STATUS_ENOSPC; + if (index == _VOLUMES) + return -DFS_STATUS_ENOSPC; /* get device */ disk[index] = fs->dev_id; - fat = (FATFS *) rt_malloc(sizeof(FATFS)); + fat = (FATFS *)rt_malloc(sizeof(FATFS)); if (fat == RT_NULL) { return -1; @@ -111,13 +112,13 @@ int dfs_elm_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* d return 0; } -int dfs_elm_unmount(struct dfs_filesystem* fs) +int dfs_elm_unmount(struct dfs_filesystem *fs) { FATFS *fat; FRESULT result; rt_uint32_t index; - fat = (FATFS*) fs->data; + fat = (FATFS *)fs->data; RT_ASSERT(fat != RT_NULL); @@ -141,7 +142,7 @@ int dfs_elm_unmount(struct dfs_filesystem* fs) return -DFS_STATUS_ENOENT; } -int dfs_elm_mkfs(const char* device_name) +int dfs_elm_mkfs(const char *device_name) { BYTE drv; rt_device_t dev; @@ -156,7 +157,7 @@ int dfs_elm_mkfs(const char* device_name) /* 1: no partition table */ /* 0: auto selection of cluster size */ result = f_mkfs(drv, 1, 0); - if ( result != FR_OK) + if (result != FR_OK) { rt_kprintf("format error\n"); return elm_result_to_dfs(result); @@ -171,7 +172,7 @@ int dfs_elm_mkfs(const char* device_name) return -DFS_STATUS_EIO; } -int dfs_elm_statfs(struct dfs_filesystem* fs, struct statfs *buf) +int dfs_elm_statfs(struct dfs_filesystem *fs, struct statfs *buf) { FATFS *f; FRESULT res; @@ -181,11 +182,12 @@ int dfs_elm_statfs(struct dfs_filesystem* fs, struct statfs *buf) RT_ASSERT(fs != RT_NULL); RT_ASSERT(buf != RT_NULL); - f = (FATFS*) fs->data; + f = (FATFS *)fs->data; rt_snprintf(driver, sizeof(driver), "%d:", f->drv); res = f_getfree(driver, &fre_clust, &f); - if (res) return elm_result_to_dfs(res); + if (res) + return elm_result_to_dfs(res); /* Get total sectors and free sectors */ tot_sect = (f->n_fatent - 2) * f->csize; @@ -202,9 +204,9 @@ int dfs_elm_statfs(struct dfs_filesystem* fs, struct statfs *buf) return 0; } -int dfs_elm_open(struct dfs_fd* file) +int dfs_elm_open(struct dfs_fd *file) { - FIL* fd; + FIL *fd; BYTE mode; FRESULT result; char *drivers_fn; @@ -215,9 +217,11 @@ int dfs_elm_open(struct dfs_fd* file) /* add path for ELM FatFS driver support */ vol = elm_get_vol((FATFS *)file->fs->data); - if (vol < 0) return -DFS_STATUS_ENOENT; + if (vol < 0) + return -DFS_STATUS_ENOENT; drivers_fn = rt_malloc(256); - if (drivers_fn == RT_NULL) return -DFS_STATUS_ENOMEM; + if (drivers_fn == RT_NULL) + return -DFS_STATUS_ENOMEM; rt_snprintf(drivers_fn, 256, "%d:%s", vol, file->path); #else @@ -267,17 +271,22 @@ int dfs_elm_open(struct dfs_fd* file) { mode = FA_READ; - if (file->flags & DFS_O_WRONLY) mode |= FA_WRITE; - if ((file->flags & DFS_O_ACCMODE) & DFS_O_RDWR) mode |= FA_WRITE; + if (file->flags & DFS_O_WRONLY) + mode |= FA_WRITE; + if ((file->flags & DFS_O_ACCMODE) & DFS_O_RDWR) + mode |= FA_WRITE; /* Opens the file, if it is existing. If not, a new file is created. */ - if (file->flags & DFS_O_CREAT) mode |= FA_OPEN_ALWAYS; + if (file->flags & DFS_O_CREAT) + mode |= FA_OPEN_ALWAYS; /* Creates a new file. If the file is existing, it is truncated and overwritten. */ - if (file->flags & DFS_O_TRUNC) mode |= FA_CREATE_ALWAYS; + if (file->flags & DFS_O_TRUNC) + mode |= FA_CREATE_ALWAYS; /* Creates a new file. The function fails if the file is already existing. */ - if (file->flags & DFS_O_EXCL) mode |= FA_CREATE_NEW; + if (file->flags & DFS_O_EXCL) + mode |= FA_CREATE_NEW; /* allocate a fd */ - fd = (FIL*)rt_malloc(sizeof(FIL)); + fd = (FIL *)rt_malloc(sizeof(FIL)); if (fd == RT_NULL) { return -DFS_STATUS_ENOMEM; @@ -309,16 +318,16 @@ int dfs_elm_open(struct dfs_fd* file) return DFS_STATUS_OK; } -int dfs_elm_close(struct dfs_fd* file) +int dfs_elm_close(struct dfs_fd *file) { FRESULT result; result = FR_OK; if (file->type == FT_DIRECTORY) { - DIR* dir; + DIR *dir; - dir = (DIR*)(file->data); + dir = (DIR *)(file->data); RT_ASSERT(dir != RT_NULL); /* release memory */ @@ -326,8 +335,8 @@ int dfs_elm_close(struct dfs_fd* file) } else if (file->type == FT_REGULAR) { - FIL* fd; - fd = (FIL*)(file->data); + FIL *fd; + fd = (FIL *)(file->data); RT_ASSERT(fd != RT_NULL); result = f_close(fd); @@ -341,14 +350,14 @@ int dfs_elm_close(struct dfs_fd* file) return elm_result_to_dfs(result); } -int dfs_elm_ioctl(struct dfs_fd* file, int cmd, void* args) +int dfs_elm_ioctl(struct dfs_fd *file, int cmd, void *args) { return -DFS_STATUS_ENOSYS; } -int dfs_elm_read(struct dfs_fd* file, void* buf, rt_size_t len) +int dfs_elm_read(struct dfs_fd *file, void *buf, rt_size_t len) { - FIL* fd; + FIL *fd; FRESULT result; UINT byte_read; @@ -357,20 +366,21 @@ int dfs_elm_read(struct dfs_fd* file, void* buf, rt_size_t len) return -DFS_STATUS_EISDIR; } - fd = (FIL*)(file->data); + fd = (FIL *)(file->data); RT_ASSERT(fd != RT_NULL); result = f_read(fd, buf, len, &byte_read); /* update position */ file->pos = fd->fptr; - if (result == FR_OK) return byte_read; + if (result == FR_OK) + return byte_read; return elm_result_to_dfs(result); } -int dfs_elm_write(struct dfs_fd* file, const void* buf, rt_size_t len) +int dfs_elm_write(struct dfs_fd *file, const void *buf, rt_size_t len) { - FIL* fd; + FIL *fd; FRESULT result; UINT byte_write; @@ -379,39 +389,40 @@ int dfs_elm_write(struct dfs_fd* file, const void* buf, rt_size_t len) return -DFS_STATUS_EISDIR; } - fd = (FIL*)(file->data); + fd = (FIL *)(file->data); RT_ASSERT(fd != RT_NULL); result = f_write(fd, buf, len, &byte_write); /* update position and file size */ file->pos = fd->fptr; file->size = fd->fsize; - if (result == FR_OK) return byte_write; + if (result == FR_OK) + return byte_write; return elm_result_to_dfs(result); } -int dfs_elm_flush(struct dfs_fd* file) +int dfs_elm_flush(struct dfs_fd *file) { - FIL* fd; + FIL *fd; FRESULT result; - fd = (FIL*)(file->data); + fd = (FIL *)(file->data); RT_ASSERT(fd != RT_NULL); result = f_sync(fd); return elm_result_to_dfs(result); } -int dfs_elm_lseek(struct dfs_fd* file, rt_off_t offset) +int dfs_elm_lseek(struct dfs_fd *file, rt_off_t offset) { FRESULT result = FR_OK; if (file->type == FT_REGULAR) { - FIL* fd; + FIL *fd; /* regular file type */ - fd = (FIL*)(file->data); + fd = (FIL *)(file->data); RT_ASSERT(fd != RT_NULL); result = f_lseek(fd, offset); @@ -424,9 +435,9 @@ int dfs_elm_lseek(struct dfs_fd* file, rt_off_t offset) else if (file->type == FT_DIRECTORY) { /* which is a directory */ - DIR* dir; + DIR *dir; - dir = (DIR*)(file->data); + dir = (DIR *)(file->data); RT_ASSERT(dir != RT_NULL); result = f_seekdir(dir, offset / sizeof(struct dirent)); @@ -441,20 +452,21 @@ int dfs_elm_lseek(struct dfs_fd* file, rt_off_t offset) return elm_result_to_dfs(result); } -int dfs_elm_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) +int dfs_elm_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count) { - DIR* dir; + DIR *dir; FILINFO fno; FRESULT result; rt_uint32_t index; - struct dirent* d; + struct dirent *d; - dir = (DIR*)(file->data); + dir = (DIR *)(file->data); RT_ASSERT(dir != RT_NULL); /* make integer count */ count = (count / sizeof(struct dirent)) * sizeof(struct dirent); - if ( count == 0 ) return -DFS_STATUS_EINVAL; + if (count == 0) + return -DFS_STATUS_EINVAL; #if _USE_LFN /* allocate long file name */ @@ -470,7 +482,8 @@ int dfs_elm_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count d = dirp + index; result = f_readdir(dir, &fno); - if (result != FR_OK || fno.fname[0] == 0) break; + if (result != FR_OK || fno.fname[0] == 0) + break; #if _USE_LFN fn = *fno.lfname? fno.lfname : fno.fname; @@ -479,15 +492,17 @@ int dfs_elm_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count #endif d->d_type = DFS_DT_UNKNOWN; - if (fno.fattrib & AM_DIR) d->d_type = DFS_DT_DIR; - else d->d_type = DFS_DT_REG; + if (fno.fattrib & AM_DIR) + d->d_type = DFS_DT_DIR; + else + d->d_type = DFS_DT_REG; d->d_namlen = rt_strlen(fn); d->d_reclen = (rt_uint16_t)sizeof(struct dirent); rt_strncpy(d->d_name, fn, rt_strlen(fn) + 1); index ++; - if ( index * sizeof(struct dirent) >= count ) + if (index * sizeof(struct dirent) >= count) break; } @@ -503,7 +518,7 @@ int dfs_elm_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count return index * sizeof(struct dirent); } -int dfs_elm_unlink(struct dfs_filesystem* fs, const char* path) +int dfs_elm_unlink(struct dfs_filesystem *fs, const char *path) { FRESULT result; @@ -514,9 +529,11 @@ int dfs_elm_unlink(struct dfs_filesystem* fs, const char* path) /* add path for ELM FatFS driver support */ vol = elm_get_vol((FATFS *)fs->data); - if (vol < 0) return -DFS_STATUS_ENOENT; + if (vol < 0) + return -DFS_STATUS_ENOENT; drivers_fn = rt_malloc(256); - if (drivers_fn == RT_NULL) return -DFS_STATUS_ENOMEM; + if (drivers_fn == RT_NULL) + return -DFS_STATUS_ENOMEM; rt_snprintf(drivers_fn, 256, "%d:%s", vol, path); #else @@ -531,7 +548,7 @@ int dfs_elm_unlink(struct dfs_filesystem* fs, const char* path) return elm_result_to_dfs(result); } -int dfs_elm_rename(struct dfs_filesystem* fs, const char* oldpath, const char* newpath) +int dfs_elm_rename(struct dfs_filesystem *fs, const char *oldpath, const char *newpath) { FRESULT result; @@ -543,10 +560,12 @@ int dfs_elm_rename(struct dfs_filesystem* fs, const char* oldpath, const char* n /* add path for ELM FatFS driver support */ vol = elm_get_vol((FATFS *)fs->data); - if (vol < 0) return -DFS_STATUS_ENOENT; + if (vol < 0) + return -DFS_STATUS_ENOENT; drivers_oldfn = rt_malloc(256); - if (drivers_oldfn == RT_NULL) return -DFS_STATUS_ENOMEM; + if (drivers_oldfn == RT_NULL) + return -DFS_STATUS_ENOMEM; drivers_newfn = newpath; rt_snprintf(drivers_oldfn, 256, "%d:%s", vol, oldpath); @@ -564,7 +583,7 @@ int dfs_elm_rename(struct dfs_filesystem* fs, const char* oldpath, const char* n return elm_result_to_dfs(result); } -int dfs_elm_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) +int dfs_elm_stat(struct dfs_filesystem *fs, const char *path, struct stat *st) { FILINFO file_info; FRESULT result; @@ -577,9 +596,11 @@ int dfs_elm_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) /* add path for ELM FatFS driver support */ vol = elm_get_vol((FATFS *)fs->data); - if (vol < 0) return -DFS_STATUS_ENOENT; + if (vol < 0) + return -DFS_STATUS_ENOENT; drivers_fn = rt_malloc(256); - if (drivers_fn == RT_NULL) return -DFS_STATUS_ENOMEM; + if (drivers_fn == RT_NULL) + return -DFS_STATUS_ENOMEM; rt_snprintf(drivers_fn, 256, "%d:%s", vol, path); #else @@ -600,7 +621,7 @@ int dfs_elm_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) if (result == FR_OK) { /* convert to dfs stat structure */ - st->st_dev = 0; + st->st_dev = 0; st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH; @@ -659,19 +680,19 @@ int elm_init(void) #include "diskio.h" /* Inidialize a Drive */ -DSTATUS disk_initialize (BYTE drv) +DSTATUS disk_initialize(BYTE drv) { return 0; } /* Return Disk Status */ -DSTATUS disk_status (BYTE drv) +DSTATUS disk_status(BYTE drv) { return 0; } /* Read Sector(s) */ -DRESULT disk_read (BYTE drv, BYTE *buff, DWORD sector, BYTE count) +DRESULT disk_read(BYTE drv, BYTE *buff, DWORD sector, BYTE count) { rt_size_t result; rt_device_t device = disk[drv]; @@ -686,7 +707,7 @@ DRESULT disk_read (BYTE drv, BYTE *buff, DWORD sector, BYTE count) } /* Write Sector(s) */ -DRESULT disk_write (BYTE drv, const BYTE *buff, DWORD sector, BYTE count) +DRESULT disk_write(BYTE drv, const BYTE *buff, DWORD sector, BYTE count) { rt_size_t result; rt_device_t device = disk[drv]; @@ -701,11 +722,12 @@ DRESULT disk_write (BYTE drv, const BYTE *buff, DWORD sector, BYTE count) } /* Miscellaneous Functions */ -DRESULT disk_ioctl (BYTE drv, BYTE ctrl, void *buff) +DRESULT disk_ioctl(BYTE drv, BYTE ctrl, void *buff) { rt_device_t device = disk[drv]; - if (device == RT_NULL) return RES_ERROR; + if (device == RT_NULL) + return RES_ERROR; if (ctrl == GET_SECTOR_COUNT) { @@ -714,8 +736,9 @@ DRESULT disk_ioctl (BYTE drv, BYTE ctrl, void *buff) rt_memset(&geometry, 0, sizeof(geometry)); rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry); - *(DWORD*)buff = geometry.sector_count; - if (geometry.sector_count == 0) return RES_ERROR; + *(DWORD *)buff = geometry.sector_count; + if (geometry.sector_count == 0) + return RES_ERROR; } else if (ctrl == GET_SECTOR_SIZE) { @@ -724,7 +747,7 @@ DRESULT disk_ioctl (BYTE drv, BYTE ctrl, void *buff) rt_memset(&geometry, 0, sizeof(geometry)); rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry); - *(WORD*)buff = geometry.bytes_per_sector; + *(WORD *)buff = geometry.bytes_per_sector; } else if (ctrl == GET_BLOCK_SIZE) /* Get erase block size in unit of sectors (DWORD) */ { @@ -733,19 +756,19 @@ DRESULT disk_ioctl (BYTE drv, BYTE ctrl, void *buff) rt_memset(&geometry, 0, sizeof(geometry)); rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry); - *(DWORD*)buff = geometry.block_size/geometry.bytes_per_sector; + *(DWORD *)buff = geometry.block_size/geometry.bytes_per_sector; } return RES_OK; } -rt_time_t get_fattime() +rt_time_t get_fattime(void) { return 0; } #if _FS_REENTRANT -int ff_cre_syncobj(BYTE drv, _SYNC_t* m) +int ff_cre_syncobj(BYTE drv, _SYNC_t *m) { char name[8]; rt_mutex_t mutex; @@ -770,7 +793,8 @@ int ff_del_syncobj(_SYNC_t m) int ff_req_grant(_SYNC_t m) { - if (rt_mutex_take(m, _FS_TIMEOUT) == RT_EOK) return RT_TRUE; + if (rt_mutex_take(m, _FS_TIMEOUT) == RT_EOK) + return RT_TRUE; return RT_FALSE; } diff --git a/components/dfs/filesystems/nfs/dfs_nfs.c b/components/dfs/filesystems/nfs/dfs_nfs.c index bf01607e5f..528d4d910e 100644 --- a/components/dfs/filesystems/nfs/dfs_nfs.c +++ b/components/dfs/filesystems/nfs/dfs_nfs.c @@ -1,3 +1,16 @@ +/* + * File : dfs_nfs.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rt-thread.org/license/LICENSE. + * + * Change Logs: + * Date Author Notes + */ + #include #include #include @@ -43,27 +56,30 @@ struct nfs_filesystem }; typedef struct nfs_file nfs_file; typedef struct nfs_dir nfs_dir; -nfs_dir *nfs_opendir(struct nfs_filesystem* nfs, const char *path); +nfs_dir *nfs_opendir(struct nfs_filesystem *nfs, const char *path); -static int nfs_parse_host_export(const char* host_export, - char* host, size_t host_len, - char* export, size_t export_len) +static int nfs_parse_host_export(const char *host_export, + char *host, size_t host_len, + char *export, size_t export_len) { int index; for (index = 0; index < host_len; index ++) { /* it's end of string, failed */ - if (host_export[index] == 0) return -1; + if (host_export[index] == 0) + return -1; /* copy to host buffer */ if (host_export[index] != ':') host[index] = host_export[index]; - else break; + else + break; } /* host buffer is not enough, failed */ - if (index == host_len) return -1; + if (index == host_len) + return -1; /* make RT_NULL */ host_len = index; @@ -90,38 +106,38 @@ static void copy_handle(nfs_fh3 *dest, const nfs_fh3 *source) { dest->data.data_len = source->data.data_len; dest->data.data_val = rt_malloc(dest->data.data_len); - if(dest->data.data_val==RT_NULL) + if (dest->data.data_val == RT_NULL) { - dest->data.data_len=0; + dest->data.data_len = 0; return; } memcpy(dest->data.data_val, source->data.data_val, dest->data.data_len); } -static nfs_fh3 *get_handle(struct nfs_filesystem* nfs, const char *name) +static nfs_fh3 *get_handle(struct nfs_filesystem *nfs, const char *name) { - nfs_fh3 *handle=RT_NULL; + nfs_fh3 *handle = RT_NULL; char *file; char *path; char *init; init = path = rt_malloc(strlen(name)+1); - if(init==RT_NULL) + if (init == RT_NULL) return RT_NULL; memcpy(init, name, strlen(name)+1); handle = rt_malloc(sizeof(nfs_fh3)); - if(handle==RT_NULL) + if (handle == RT_NULL) { rt_free(init); return RT_NULL; } - if(path[0]=='/') + if (path[0] == '/') { - path++; + path ++; copy_handle(handle, &nfs->root_handle); } else @@ -129,16 +145,16 @@ static nfs_fh3 *get_handle(struct nfs_filesystem* nfs, const char *name) copy_handle(handle, &nfs->current_handle); } - while((file=strtok_r(RT_NULL, "/", &path))!=RT_NULL) + while ((file = strtok_r(RT_NULL, "/", &path)) != RT_NULL) { LOOKUP3args args; LOOKUP3res res; memset(&res, 0, sizeof(res)); copy_handle(&args.what.dir, handle); xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - args.what.name=file; + args.what.name = file; - if(nfsproc3_lookup_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_lookup_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Lookup failed\n"); rt_free(init); @@ -146,7 +162,7 @@ static nfs_fh3 *get_handle(struct nfs_filesystem* nfs, const char *name) xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); return RT_NULL; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Lookup failed: %d\n", res.status); rt_free(init); @@ -164,28 +180,28 @@ static nfs_fh3 *get_handle(struct nfs_filesystem* nfs, const char *name) return handle; } -static nfs_fh3 *get_dir_handle(struct nfs_filesystem* nfs, const char *name) +static nfs_fh3 *get_dir_handle(struct nfs_filesystem *nfs, const char *name) { - nfs_fh3 *handle=RT_NULL; + nfs_fh3 *handle = RT_NULL; char *file; char *path; char *init; init = path = rt_malloc(strlen(name)+1); - if(init==RT_NULL) + if (init == RT_NULL) return RT_NULL; memcpy(init, name, strlen(name)+1); handle = rt_malloc(sizeof(nfs_fh3)); - if(handle == RT_NULL) + if (handle == RT_NULL) { rt_free(init); return RT_NULL; } - if(path[0]=='/') + if (path[0] == '/') { - path++; + path ++; copy_handle(handle, &nfs->root_handle); } else @@ -193,16 +209,16 @@ static nfs_fh3 *get_dir_handle(struct nfs_filesystem* nfs, const char *name) copy_handle(handle, &nfs->current_handle); } - while((file=strtok_r(RT_NULL, "/", &path))!=RT_NULL && path[0]!='\0') + while ((file = strtok_r(RT_NULL, "/", &path)) != RT_NULL && path[0] != '\0') { LOOKUP3args args; LOOKUP3res res; memset(&res, 0, sizeof(res)); copy_handle(&args.what.dir, handle); xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - args.what.name=file; + args.what.name = file; - if(nfsproc3_lookup_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_lookup_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Lookup failed\n"); rt_free(init); @@ -210,7 +226,7 @@ static nfs_fh3 *get_dir_handle(struct nfs_filesystem* nfs, const char *name) xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); return RT_NULL; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Lookup failed: %d\n", res.status); rt_free(init); @@ -228,7 +244,7 @@ static nfs_fh3 *get_dir_handle(struct nfs_filesystem* nfs, const char *name) return handle; } -static size_t nfs_get_filesize(struct nfs_filesystem* nfs, nfs_fh3 *handle) +static size_t nfs_get_filesize(struct nfs_filesystem *nfs, nfs_fh3 *handle) { GETATTR3args args; GETATTR3res res; @@ -246,14 +262,14 @@ static size_t nfs_get_filesize(struct nfs_filesystem* nfs, nfs_fh3 *handle) return 0; } - info=&res.GETATTR3res_u.resok.obj_attributes; + info = &res.GETATTR3res_u.resok.obj_attributes; size = info->size; xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res); return size; } -rt_bool_t nfs_is_directory(struct nfs_filesystem* nfs, const char* name) +rt_bool_t nfs_is_directory(struct nfs_filesystem *nfs, const char *name) { GETATTR3args args; GETATTR3res res; @@ -263,18 +279,19 @@ rt_bool_t nfs_is_directory(struct nfs_filesystem* nfs, const char* name) result = RT_FALSE; handle = get_handle(nfs, name); - if(handle == RT_NULL) return RT_FALSE; + if (handle == RT_NULL) + return RT_FALSE; args.object = *handle; memset(&res, '\0', sizeof(res)); - if (nfsproc3_getattr_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_getattr_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("GetAttr failed\n"); return RT_FALSE; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Getattr failed: %d\n", res.status); return RT_FALSE; @@ -282,7 +299,8 @@ rt_bool_t nfs_is_directory(struct nfs_filesystem* nfs, const char* name) info=&res.GETATTR3res_u.resok.obj_attributes; - if (info->type == NFS3DIR) result = RT_TRUE; + if (info->type == NFS3DIR) + result = RT_TRUE; xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res); xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); @@ -291,47 +309,47 @@ rt_bool_t nfs_is_directory(struct nfs_filesystem* nfs, const char* name) return result; } -int nfs_create(struct nfs_filesystem* nfs, const char *name, mode_t mode) +int nfs_create(struct nfs_filesystem *nfs, const char *name, mode_t mode) { CREATE3args args; CREATE3res res; - int ret=0; + int ret = 0; nfs_fh3 *handle; - if(nfs->nfs_client==RT_NULL) + if (nfs->nfs_client == RT_NULL) { return -1; } - handle=get_dir_handle(nfs, name); - if(handle==RT_NULL) + handle = get_dir_handle(nfs, name); + if (handle == RT_NULL) { return -1; } - args.where.dir=*handle; - args.where.name=strrchr(name, '/') + 1; - if(args.where.name==RT_NULL) + args.where.dir = *handle; + args.where.name = strrchr(name, '/') + 1; + if (args.where.name == RT_NULL) { - args.where.name=(char *)name; + args.where.name = (char *)name; } - args.how.mode=GUARDED; + args.how.mode = GUARDED; - args.how.createhow3_u.obj_attributes.mode.set_it=TRUE; - args.how.createhow3_u.obj_attributes.mode.set_mode3_u.mode=mode; - args.how.createhow3_u.obj_attributes.uid.set_it=FALSE; - args.how.createhow3_u.obj_attributes.gid.set_it=FALSE; - args.how.createhow3_u.obj_attributes.size.set_it=FALSE; - args.how.createhow3_u.obj_attributes.atime.set_it=DONT_CHANGE; - args.how.createhow3_u.obj_attributes.mtime.set_it=DONT_CHANGE; + args.how.createhow3_u.obj_attributes.mode.set_it = TRUE; + args.how.createhow3_u.obj_attributes.mode.set_mode3_u.mode = mode; + args.how.createhow3_u.obj_attributes.uid.set_it = FALSE; + args.how.createhow3_u.obj_attributes.gid.set_it = FALSE; + args.how.createhow3_u.obj_attributes.size.set_it = FALSE; + args.how.createhow3_u.obj_attributes.atime.set_it = DONT_CHANGE; + args.how.createhow3_u.obj_attributes.mtime.set_it = DONT_CHANGE; memset(&res, 0, sizeof(res)); - if(nfsproc3_create_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_create_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Create failed\n"); ret = -1; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Create failed: %d\n", res.status); ret = -1; @@ -343,46 +361,46 @@ int nfs_create(struct nfs_filesystem* nfs, const char *name, mode_t mode) return ret; } -int nfs_mkdir(struct nfs_filesystem* nfs, const char *name, mode_t mode) +int nfs_mkdir(struct nfs_filesystem *nfs, const char *name, mode_t mode) { MKDIR3args args; MKDIR3res res; - int ret=0; + int ret = 0; nfs_fh3 *handle; - if(nfs->nfs_client==RT_NULL) + if (nfs->nfs_client == RT_NULL) return -1; - handle=get_dir_handle(nfs, name); - if(handle==RT_NULL) + handle = get_dir_handle(nfs, name); + if (handle == RT_NULL) return -1; - args.where.dir=*handle; - args.where.name=strrchr(name, '/') + 1; - if(args.where.name==RT_NULL) + args.where.dir = *handle; + args.where.name = strrchr(name, '/') + 1; + if (args.where.name == RT_NULL) { - args.where.name=(char *)name; + args.where.name = (char *)name; } - args.attributes.mode.set_it=TRUE; - args.attributes.mode.set_mode3_u.mode=mode; - args.attributes.uid.set_it=FALSE; - args.attributes.gid.set_it=FALSE; - args.attributes.size.set_it=FALSE; - args.attributes.atime.set_it=DONT_CHANGE; - args.attributes.mtime.set_it=DONT_CHANGE; + args.attributes.mode.set_it = TRUE; + args.attributes.mode.set_mode3_u.mode = mode; + args.attributes.uid.set_it = FALSE; + args.attributes.gid.set_it = FALSE; + args.attributes.size.set_it = FALSE; + args.attributes.atime.set_it = DONT_CHANGE; + args.attributes.mtime.set_it = DONT_CHANGE; memset(&res, 0, sizeof(res)); - if(nfsproc3_mkdir_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_mkdir_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Mkdir failed\n"); - ret=-1; + ret = -1; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Mkdir failed: %d\n", res.status); - ret=-1; + ret = -1; } xdr_free((xdrproc_t)xdr_MKDIR3res, (char *)&res); xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); @@ -392,15 +410,15 @@ int nfs_mkdir(struct nfs_filesystem* nfs, const char *name, mode_t mode) } /* mount(RT_NULL, "/mnt", "nfs", 0, "192.168.1.1:/export") */ -int nfs_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data) +int nfs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data) { mountres3 res; - struct nfs_filesystem* nfs; + struct nfs_filesystem *nfs; - nfs = (struct nfs_filesystem*)rt_malloc(sizeof(struct nfs_filesystem)); + nfs = (struct nfs_filesystem *)rt_malloc(sizeof(struct nfs_filesystem)); memset(nfs, 0, sizeof(struct nfs_filesystem)); - if (nfs_parse_host_export((const char*)data, nfs->host, HOST_LENGTH, + if (nfs_parse_host_export((const char *)data, nfs->host, HOST_LENGTH, nfs->export, EXPORT_PATH_LENGTH) < 0) { rt_kprintf("host or export path error\n"); @@ -408,25 +426,25 @@ int nfs_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data) } nfs->mount_client=clnt_create((char *)nfs->host, MOUNT_PROGRAM, MOUNT_V3, "udp"); - if(nfs->mount_client==RT_NULL) + if (nfs->mount_client == RT_NULL) { rt_kprintf("create mount client failed\n"); goto __return; } memset(&res, '\0', sizeof(mountres3)); - if(mountproc3_mnt_3((char *)nfs->export, &res, nfs->mount_client)!=RPC_SUCCESS) + if (mountproc3_mnt_3((char *)nfs->export, &res, nfs->mount_client) != RPC_SUCCESS) { rt_kprintf("nfs mount failed\n"); goto __return; } - else if(res.fhs_status!=MNT3_OK) + else if (res.fhs_status != MNT3_OK) { rt_kprintf("nfs mount failed\n"); goto __return; } nfs->nfs_client=clnt_create((char *)nfs->host, NFS_PROGRAM, NFS_V3, "udp"); - if(nfs->nfs_client == RT_NULL) + if (nfs->nfs_client == RT_NULL) { rt_kprintf("creat nfs client failed\n"); goto __return; @@ -434,7 +452,7 @@ int nfs_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data) copy_handle(&nfs->root_handle, (nfs_fh3 *)&res.mountres3_u.mountinfo.fhandle); copy_handle(&nfs->current_handle, &nfs->root_handle); - nfs->nfs_client->cl_auth=authnone_create(); + nfs->nfs_client->cl_auth = authnone_create(); fs->data = nfs; return 0; @@ -460,9 +478,9 @@ __return: return -1; } -int nfs_unmount(struct dfs_filesystem* fs) +int nfs_unmount(struct dfs_filesystem *fs) { - struct nfs_filesystem* nfs; + struct nfs_filesystem *nfs; RT_ASSERT(fs != RT_NULL); RT_ASSERT(fs->data != RT_NULL); @@ -476,9 +494,9 @@ int nfs_unmount(struct dfs_filesystem* fs) } /* destroy nfs client */ - if(nfs->nfs_client != RT_NULL) + if (nfs->nfs_client != RT_NULL) { - if(nfs->nfs_client->cl_auth!=RT_NULL) + if (nfs->nfs_client->cl_auth != RT_NULL) { auth_destroy(nfs->nfs_client->cl_auth); nfs->nfs_client->cl_auth = RT_NULL; @@ -488,15 +506,15 @@ int nfs_unmount(struct dfs_filesystem* fs) } /* destroy mount client */ - if(nfs->mount_client != RT_NULL) + if (nfs->mount_client != RT_NULL) { - if(nfs->mount_client->cl_auth != RT_NULL) + if (nfs->mount_client->cl_auth != RT_NULL) { auth_destroy(nfs->mount_client->cl_auth); nfs->mount_client->cl_auth = RT_NULL; } clnt_destroy(nfs->mount_client); - nfs->mount_client=RT_NULL; + nfs->mount_client = RT_NULL; } rt_free(nfs); @@ -505,18 +523,18 @@ int nfs_unmount(struct dfs_filesystem* fs) return 0; } -int nfs_ioctl(struct dfs_fd* file, int cmd, void* args) +int nfs_ioctl(struct dfs_fd *file, int cmd, void *args) { return -DFS_STATUS_ENOSYS; } -int nfs_read(struct dfs_fd* file, void *buf, rt_size_t count) +int nfs_read(struct dfs_fd *file, void *buf, rt_size_t count) { READ3args args; READ3res res; ssize_t bytes; nfs_file *fd; - struct nfs_filesystem* nfs; + struct nfs_filesystem *nfs; if (file->type == FT_DIRECTORY) return -DFS_STATUS_EISDIR; @@ -527,35 +545,36 @@ int nfs_read(struct dfs_fd* file, void *buf, rt_size_t count) RT_ASSERT(file->fs->data != RT_NULL); nfs = (struct nfs_filesystem *)file->fs->data; - if(nfs->nfs_client==RT_NULL) + if (nfs->nfs_client == RT_NULL) return -1; /* end of file */ - if (fd->eof == TRUE) return 0; + if (fd->eof == TRUE) + return 0; - args.file=fd->handle; - args.offset=fd->offset; - args.count=count; + args.file = fd->handle; + args.offset = fd->offset; + args.count = count; memset(&res, 0, sizeof(res)); - if(nfsproc3_read_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + if (nfsproc3_read_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Read failed\n"); bytes = 0; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Read failed: %d\n", res.status); bytes = 0; } else { - if(res.READ3res_u.resok.eof) + if (res.READ3res_u.resok.eof) { /* something should probably be here */ fd->eof = TRUE; } - bytes=res.READ3res_u.resok.count; + bytes = res.READ3res_u.resok.count; fd->offset += bytes; /* update current position */ file->pos = fd->offset; @@ -566,13 +585,13 @@ int nfs_read(struct dfs_fd* file, void *buf, rt_size_t count) return bytes; } -int nfs_write(struct dfs_fd* file, const void *buf, rt_size_t count) +int nfs_write(struct dfs_fd *file, const void *buf, rt_size_t count) { WRITE3args args; WRITE3res res; ssize_t bytes; nfs_file *fd; - struct nfs_filesystem* nfs; + struct nfs_filesystem *nfs; if (file->type == FT_DIRECTORY) return -DFS_STATUS_EISDIR; @@ -583,31 +602,31 @@ int nfs_write(struct dfs_fd* file, const void *buf, rt_size_t count) RT_ASSERT(file->fs->data != RT_NULL); nfs = (struct nfs_filesystem *)file->fs->data; - if(nfs->nfs_client==RT_NULL) + if (nfs->nfs_client == RT_NULL) return -1; - args.file=fd->handle; - args.stable=FILE_SYNC; - args.offset=fd->offset; + args.file = fd->handle; + args.stable = FILE_SYNC; + args.offset = fd->offset; memset(&res, 0, sizeof(res)); args.data.data_val=(void *)buf; - args.count=args.data.data_len=count; + args.count=args.data.data_len = count; - if(nfsproc3_write_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_write_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Write failed\n"); bytes = 0; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Write failed: %d\n", res.status); bytes = 0; } else { - bytes=res.WRITE3res_u.resok.count; - fd->offset+=bytes; + bytes = res.WRITE3res_u.resok.count; + fd->offset += bytes; /* update current position */ file->pos = fd->offset; /* todo: update file size */ @@ -617,7 +636,7 @@ int nfs_write(struct dfs_fd* file, const void *buf, rt_size_t count) return bytes; } -int nfs_lseek(struct dfs_fd* file, rt_off_t offset) +int nfs_lseek(struct dfs_fd *file, rt_off_t offset) { nfs_file *fd; @@ -636,22 +655,22 @@ int nfs_lseek(struct dfs_fd* file, rt_off_t offset) return -DFS_STATUS_EIO; } -int nfs_close(struct dfs_fd* file) +int nfs_close(struct dfs_fd *file) { if (file->type == FT_DIRECTORY) { - struct nfs_dir* dir; + struct nfs_dir *dir; - dir = (struct nfs_dir*)file->data; + dir = (struct nfs_dir *)file->data; xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&dir->handle); xdr_free((xdrproc_t)xdr_READDIR3res, (char *)&dir->res); rt_free(dir); } else if (file->type == FT_REGULAR) { - struct nfs_file* fd; + struct nfs_file *fd; - fd = (struct nfs_file*)file->data; + fd = (struct nfs_file *)file->data; xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&fd->handle); rt_free(fd); @@ -661,9 +680,9 @@ int nfs_close(struct dfs_fd* file) return 0; } -int nfs_open(struct dfs_fd* file) +int nfs_open(struct dfs_fd *file) { - struct nfs_filesystem* nfs; + struct nfs_filesystem *nfs; RT_ASSERT(file->fs != RT_NULL); RT_ASSERT(file->fs->data != RT_NULL); @@ -695,12 +714,12 @@ int nfs_open(struct dfs_fd* file) } /* open file (get file handle ) */ - fp=rt_malloc(sizeof(nfs_file)); - if(fp == RT_NULL) + fp = rt_malloc(sizeof(nfs_file)); + if (fp == RT_NULL) return -1; handle = get_handle(nfs, file->path); - if(handle == RT_NULL) + if (handle == RT_NULL) { rt_free(fp); return -1; @@ -708,7 +727,7 @@ int nfs_open(struct dfs_fd* file) /* get size of file */ fp->size = nfs_get_filesize(nfs, handle); - fp->offset=0; + fp->offset = 0; fp->eof = FALSE; copy_handle(&fp->handle, handle); @@ -727,32 +746,32 @@ int nfs_open(struct dfs_fd* file) return 0; } -int nfs_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) +int nfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st) { GETATTR3args args; GETATTR3res res; fattr3 *info; nfs_fh3 *handle; - struct nfs_filesystem* nfs; + struct nfs_filesystem *nfs; RT_ASSERT(fs != RT_NULL); RT_ASSERT(fs->data != RT_NULL); nfs = (struct nfs_filesystem *)fs->data; handle = get_handle(nfs, path); - if(handle == RT_NULL) + if (handle == RT_NULL) return -1; args.object = *handle; memset(&res, '\0', sizeof(res)); - if (nfsproc3_getattr_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_getattr_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("GetAttr failed\n"); return -1; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Getattr failed: %d\n", res.status); return -1; @@ -760,7 +779,7 @@ int nfs_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) info = &res.GETATTR3res_u.resok.obj_attributes; - st->st_dev = 0; + st->st_dev = 0; st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH; @@ -781,19 +800,19 @@ int nfs_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) return 0; } -nfs_dir *nfs_opendir(struct nfs_filesystem* nfs, const char *path) +nfs_dir *nfs_opendir(struct nfs_filesystem *nfs, const char *path) { nfs_dir *dir; nfs_fh3 *handle; - dir=rt_malloc(sizeof(nfs_dir)); - if(dir==RT_NULL) + dir = rt_malloc(sizeof(nfs_dir)); + if (dir == RT_NULL) { return RT_NULL; } handle = get_handle(nfs, path); - if(handle == RT_NULL) + if (handle == RT_NULL) { rt_free(dir); return RT_NULL; @@ -803,63 +822,63 @@ nfs_dir *nfs_opendir(struct nfs_filesystem* nfs, const char *path) xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); rt_free(handle); - dir->cookie=0; + dir->cookie = 0; memset(&dir->cookieverf, '\0', sizeof(cookieverf3)); - dir->entry=RT_NULL; - dir->eof=FALSE; + dir->entry = RT_NULL; + dir->eof = FALSE; memset(&dir->res, '\0', sizeof(dir->res)); return dir; } -char *nfs_readdir(struct nfs_filesystem* nfs, nfs_dir *dir) +char *nfs_readdir(struct nfs_filesystem *nfs, nfs_dir *dir) { static char name[NAME_MAX]; - if(nfs->nfs_client==RT_NULL || dir == RT_NULL) + if (nfs->nfs_client == RT_NULL || dir == RT_NULL) return RT_NULL; - if(dir->entry==RT_NULL) + if (dir->entry == RT_NULL) { READDIR3args args; xdr_free((xdrproc_t)xdr_READDIR3res, (char *)&dir->res); memset(&dir->res, '\0', sizeof(dir->res)); - args.dir=dir->handle; - args.cookie=dir->cookie; + args.dir = dir->handle; + args.cookie = dir->cookie; memcpy(&args.cookieverf, &dir->cookieverf, sizeof(cookieverf3)); - args.count=1024; + args.count = 1024; - if(nfsproc3_readdir_3(args, &dir->res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_readdir_3(args, &dir->res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Readdir failed\n"); return RT_NULL; } - else if(dir->res.status!=NFS3_OK) + else if (dir->res.status != NFS3_OK) { rt_kprintf("Readdir failed: %d\n", dir->res.status); return RT_NULL; } memcpy(&dir->cookieverf, &dir->res.READDIR3res_u.resok.cookieverf, sizeof(cookieverf3)); - dir->eof=dir->res.READDIR3res_u.resok.reply.eof; - dir->entry=dir->res.READDIR3res_u.resok.reply.entries; + dir->eof = dir->res.READDIR3res_u.resok.reply.eof; + dir->entry = dir->res.READDIR3res_u.resok.reply.entries; } - if(dir->eof==TRUE && dir->entry==RT_NULL) + if (dir->eof == TRUE && dir->entry == RT_NULL) return RT_NULL; - dir->cookie=dir->entry->cookie; + dir->cookie = dir->entry->cookie; strncpy(name, dir->entry->name, NAME_MAX-1); - dir->entry=dir->entry->nextentry; - name[NAME_MAX - 1]='\0'; + dir->entry = dir->entry->nextentry; + name[NAME_MAX - 1] = '\0'; return name; } -int nfs_unlink(struct dfs_filesystem* fs, const char* path) +int nfs_unlink(struct dfs_filesystem *fs, const char *path) { int ret = 0; - struct nfs_filesystem* nfs; + struct nfs_filesystem *nfs; RT_ASSERT(fs != RT_NULL); RT_ASSERT(fs->data != RT_NULL); @@ -873,26 +892,27 @@ int nfs_unlink(struct dfs_filesystem* fs, const char* path) nfs_fh3 *handle; handle = get_dir_handle(nfs, path); - if(handle == RT_NULL) return -1; + if (handle == RT_NULL) + return -1; - args.object.dir=*handle; - args.object.name=strrchr(path, '/') + 1; - if(args.object.name==RT_NULL) + args.object.dir = *handle; + args.object.name = strrchr(path, '/') + 1; + if (args.object.name == RT_NULL) { - args.object.name=(char *)path; + args.object.name = (char *)path; } memset(&res, 0, sizeof(res)); - if(nfsproc3_remove_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_remove_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Remove failed\n"); - ret=-1; + ret = -1; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Remove failed: %d\n", res.status); - ret=-1; + ret = -1; } xdr_free((xdrproc_t)xdr_REMOVE3res, (char *)&res); xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); @@ -905,24 +925,25 @@ int nfs_unlink(struct dfs_filesystem* fs, const char* path) RMDIR3res res; nfs_fh3 *handle; - handle=get_dir_handle(nfs, path); - if(handle==RT_NULL) return -1; + handle = get_dir_handle(nfs, path); + if (handle == RT_NULL) + return -1; - args.object.dir=*handle; - args.object.name=strrchr(path, '/') + 1; - if(args.object.name==RT_NULL) + args.object.dir = *handle; + args.object.name = strrchr(path, '/') + 1; + if (args.object.name == RT_NULL) { - args.object.name=(char *)path; + args.object.name = (char *)path; } memset(&res, 0, sizeof(res)); - if(nfsproc3_rmdir_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_rmdir_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Rmdir failed\n"); ret = -1; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Rmdir failed: %d\n", res.status); ret = -1; @@ -936,48 +957,48 @@ int nfs_unlink(struct dfs_filesystem* fs, const char* path) return ret; } -int nfs_rename(struct dfs_filesystem* fs, const char *src, const char *dest) +int nfs_rename(struct dfs_filesystem *fs, const char *src, const char *dest) { RENAME3args args; RENAME3res res; nfs_fh3 *sHandle; nfs_fh3 *dHandle; - int ret=0; - struct nfs_filesystem* nfs; + int ret = 0; + struct nfs_filesystem *nfs; RT_ASSERT(fs != RT_NULL); RT_ASSERT(fs->data != RT_NULL); nfs = (struct nfs_filesystem *)fs->data; - if(nfs->nfs_client==RT_NULL) + if (nfs->nfs_client == RT_NULL) return -1; - sHandle=get_dir_handle(nfs, src); - if(sHandle==RT_NULL) + sHandle = get_dir_handle(nfs, src); + if (sHandle == RT_NULL) return -1; - dHandle=get_dir_handle(nfs, dest); - if(dHandle==RT_NULL) + dHandle = get_dir_handle(nfs, dest); + if (dHandle == RT_NULL) return -1; - args.from.dir=*sHandle; - args.from.name=strrchr(src, '/') + 1; - if(args.from.name==RT_NULL) - args.from.name=(char *)src; + args.from.dir = *sHandle; + args.from.name = strrchr(src, '/') + 1; + if (args.from.name == RT_NULL) + args.from.name = (char *)src; - args.to.dir=*dHandle; - args.to.name=strrchr(src, '/') + 1; - if(args.to.name==RT_NULL) - args.to.name=(char *)dest; + args.to.dir = *dHandle; + args.to.name = strrchr(src, '/') + 1; + if (args.to.name == RT_NULL) + args.to.name = (char *)dest; memset(&res, '\0', sizeof(res)); - if(nfsproc3_rename_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) + if (nfsproc3_rename_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) { rt_kprintf("Rename failed\n"); ret = -1; } - else if(res.status!=NFS3_OK) + else if (res.status != NFS3_OK) { rt_kprintf("Rename failed: %d\n", res.status); ret = -1; @@ -989,12 +1010,12 @@ int nfs_rename(struct dfs_filesystem* fs, const char *src, const char *dest) return ret; } -int nfs_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) +int nfs_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count) { nfs_dir *dir; rt_uint32_t index; - struct dirent* d; - struct nfs_filesystem* nfs; + struct dirent *d; + struct nfs_filesystem *nfs; char *name; dir = (nfs_dir *)(file->data); @@ -1005,7 +1026,8 @@ int nfs_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) /* make integer count */ count = (count / sizeof(struct dirent)) * sizeof(struct dirent); - if ( count == 0 ) return -DFS_STATUS_EINVAL; + if (count == 0) + return -DFS_STATUS_EINVAL; index = 0; while (1) @@ -1015,7 +1037,8 @@ int nfs_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) d = dirp + index; name = nfs_readdir(nfs, dir); - if (name == RT_NULL) break; + if (name == RT_NULL) + break; d->d_type = DFS_DT_REG; @@ -1024,7 +1047,7 @@ int nfs_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) rt_strncpy(d->d_name, name, rt_strlen(name) + 1); index ++; - if ( index * sizeof(struct dirent) >= count ) + if (index * sizeof(struct dirent) >= count) break; } diff --git a/components/dfs/filesystems/nfs/dfs_nfs.h b/components/dfs/filesystems/nfs/dfs_nfs.h index 843b6b9ddc..d45af577de 100644 --- a/components/dfs/filesystems/nfs/dfs_nfs.h +++ b/components/dfs/filesystems/nfs/dfs_nfs.h @@ -1,3 +1,16 @@ +/* + * File : dfs_nfs.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rt-thread.org/license/LICENSE. + * + * Change Logs: + * Date Author Notes + */ + #ifndef __NFS_H__ #define __NFS_H__ diff --git a/components/dfs/filesystems/romfs/dfs_romfs.c b/components/dfs/filesystems/romfs/dfs_romfs.c index b5effaf81c..760593b58c 100644 --- a/components/dfs/filesystems/romfs/dfs_romfs.c +++ b/components/dfs/filesystems/romfs/dfs_romfs.c @@ -1,35 +1,49 @@ +/* + * File : dfs_romfs.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rt-thread.org/license/LICENSE. + * + * Change Logs: + * Date Author Notes + */ + #include #include #include #include "dfs_romfs.h" -int dfs_romfs_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data) +int dfs_romfs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data) { - struct romfs_dirent* root_dirent; + struct romfs_dirent *root_dirent; - if (data == RT_NULL) return -DFS_STATUS_EIO; + if (data == RT_NULL) + return -DFS_STATUS_EIO; - root_dirent = (struct romfs_dirent*)data; + root_dirent = (struct romfs_dirent *)data; fs->data = root_dirent; return DFS_STATUS_OK; } -int dfs_romfs_unmount(struct dfs_filesystem* fs) +int dfs_romfs_unmount(struct dfs_filesystem *fs) { return DFS_STATUS_OK; } -int dfs_romfs_ioctl(struct dfs_fd* file, int cmd, void* args) +int dfs_romfs_ioctl(struct dfs_fd *file, int cmd, void *args) { return -DFS_STATUS_EIO; } -struct romfs_dirent* dfs_romfs_lookup(struct romfs_dirent* root_dirent, const char* path, rt_size_t *size) +struct romfs_dirent *dfs_romfs_lookup(struct romfs_dirent *root_dirent, const char *path, rt_size_t *size) { rt_size_t index, found; const char *subpath, *subpath_end; - struct romfs_dirent* dirent; + struct romfs_dirent *dirent; rt_size_t dirent_size; if (path[0] == '/' && path[1] == '\0') @@ -39,15 +53,17 @@ struct romfs_dirent* dfs_romfs_lookup(struct romfs_dirent* root_dirent, const ch } /* goto root directy entries */ - dirent = (struct romfs_dirent*)root_dirent->data; + dirent = (struct romfs_dirent *)root_dirent->data; dirent_size = root_dirent->size; /* get the end position of this subpath */ subpath_end = path; /* skip /// */ - while (*subpath_end && *subpath_end == '/') subpath_end ++; + while (*subpath_end && *subpath_end == '/') + subpath_end ++; subpath = subpath_end; - while ((*subpath_end != '/') && *subpath_end) subpath_end ++; + while ((*subpath_end != '/') && *subpath_end) + subpath_end ++; while (dirent != RT_NULL) { @@ -61,9 +77,11 @@ struct romfs_dirent* dfs_romfs_lookup(struct romfs_dirent* root_dirent, const ch dirent_size = dirent[index].size; /* skip /// */ - while (*subpath_end && *subpath_end == '/') subpath_end ++; + while (*subpath_end && *subpath_end == '/') + subpath_end ++; subpath = subpath_end; - while ((*subpath_end != '/') && *subpath_end) subpath_end ++; + while ((*subpath_end != '/') && *subpath_end) + subpath_end ++; if (!(*subpath)) { @@ -81,24 +99,26 @@ struct romfs_dirent* dfs_romfs_lookup(struct romfs_dirent* root_dirent, const ch else { /* return file dirent */ - if (subpath != RT_NULL) break; /* not the end of path */ + if (subpath != RT_NULL) + break; /* not the end of path */ return &dirent[index]; } } } - if (!found) break; /* not found */ + if (!found) + break; /* not found */ } /* not found */ return RT_NULL; } -int dfs_romfs_read(struct dfs_fd* file, void *buf, rt_size_t count) +int dfs_romfs_read(struct dfs_fd *file, void *buf, rt_size_t count) { rt_size_t length; - struct romfs_dirent* dirent; + struct romfs_dirent *dirent; dirent = (struct romfs_dirent *)file->data; RT_ASSERT(dirent != RT_NULL); @@ -117,7 +137,7 @@ int dfs_romfs_read(struct dfs_fd* file, void *buf, rt_size_t count) return length; } -int dfs_romfs_lseek(struct dfs_fd* file, rt_off_t offset) +int dfs_romfs_lseek(struct dfs_fd *file, rt_off_t offset) { if (offset <= file->size) { @@ -128,30 +148,31 @@ int dfs_romfs_lseek(struct dfs_fd* file, rt_off_t offset) return -DFS_STATUS_EIO; } -int dfs_romfs_close(struct dfs_fd* file) +int dfs_romfs_close(struct dfs_fd *file) { file->data = RT_NULL; return DFS_STATUS_OK; } -int dfs_romfs_open(struct dfs_fd* file) +int dfs_romfs_open(struct dfs_fd *file) { rt_size_t size; - struct romfs_dirent* dirent; - struct romfs_dirent* root_dirent; + struct romfs_dirent *dirent; + struct romfs_dirent *root_dirent; - root_dirent = (struct romfs_dirent*)file->fs->data; + root_dirent = (struct romfs_dirent *)file->fs->data; if (file->flags & (DFS_O_CREAT | DFS_O_WRONLY | DFS_O_APPEND | DFS_O_TRUNC | DFS_O_RDWR)) return -DFS_STATUS_EINVAL; dirent = dfs_romfs_lookup(root_dirent, file->path, &size); - if (dirent == RT_NULL) return -DFS_STATUS_ENOENT; + if (dirent == RT_NULL) + return -DFS_STATUS_ENOENT; /* entry is a directory file type */ if (dirent->type == ROMFS_DIRENT_DIR) { - if (!(file->flags & DFS_O_DIRECTORY) ) + if (!(file->flags & DFS_O_DIRECTORY)) return -DFS_STATUS_ENOENT; } else @@ -168,16 +189,17 @@ int dfs_romfs_open(struct dfs_fd* file) return DFS_STATUS_OK; } -int dfs_romfs_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) +int dfs_romfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st) { rt_size_t size; - struct romfs_dirent* dirent; - struct romfs_dirent* root_dirent; + struct romfs_dirent *dirent; + struct romfs_dirent *root_dirent; - root_dirent = (struct romfs_dirent*)fs->data; + root_dirent = (struct romfs_dirent *)fs->data; dirent = dfs_romfs_lookup(root_dirent, path, &size); - if (dirent == RT_NULL) return -DFS_STATUS_ENOENT; + if (dirent == RT_NULL) + return -DFS_STATUS_ENOENT; st->st_dev = 0; st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | @@ -196,22 +218,23 @@ int dfs_romfs_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) return DFS_STATUS_OK; } -int dfs_romfs_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) +int dfs_romfs_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count) { rt_size_t index; const char *name; - struct dirent* d; + struct dirent *d; struct romfs_dirent *dirent, *sub_dirent; - dirent = (struct romfs_dirent*) file->data; + dirent = (struct romfs_dirent *)file->data; RT_ASSERT(dirent->type == ROMFS_DIRENT_DIR); /* enter directory */ - dirent = (struct romfs_dirent*) dirent->data; + dirent = (struct romfs_dirent *)dirent->data; /* make integer count */ count = (count / sizeof(struct dirent)); - if ( count == 0 ) return -DFS_STATUS_EINVAL; + if (count == 0) + return -DFS_STATUS_EINVAL; index = 0; for (index = 0; index < count && file->pos < file->size; index ++) diff --git a/components/dfs/filesystems/romfs/dfs_romfs.h b/components/dfs/filesystems/romfs/dfs_romfs.h index 6a3f7ac1cc..3e0d7daf07 100644 --- a/components/dfs/filesystems/romfs/dfs_romfs.h +++ b/components/dfs/filesystems/romfs/dfs_romfs.h @@ -1,3 +1,16 @@ +/* + * File : dfs_romfs.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rt-thread.org/license/LICENSE. + * + * Change Logs: + * Date Author Notes + */ + #ifndef __DFS_ROMFS_H__ #define __DFS_ROMFS_H__ diff --git a/components/dfs/include/dfs.h b/components/dfs/include/dfs.h index 04fe678387..193c8b1678 100644 --- a/components/dfs/include/dfs.h +++ b/components/dfs/include/dfs.h @@ -1,7 +1,7 @@ /* * File : dfs.h * This file is part of Device File System in RT-Thread RTOS - * COPYRIGHT (C) 2004-2010, RT-Thread Development Team + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team * * The license and distribution terms for this file may be * found in the file LICENSE in this distribution or at @@ -21,14 +21,14 @@ extern "C" { #endif -char* dfs_normalize_path(const char* directory, const char* filename); -const char* dfs_subdir(const char* directory, const char* filename); +char *dfs_normalize_path(const char *directory, const char *filename); +const char *dfs_subdir(const char *directory, const char *filename); /* FD APIs */ int fd_new(void); -struct dfs_fd* fd_get(int fd); -void fd_put(struct dfs_fd* fd); -int fd_is_open(const char* pathname); +struct dfs_fd *fd_get(int fd); +void fd_put(struct dfs_fd *fd); +int fd_is_open(const char *pathname); #ifdef __cplusplus } diff --git a/components/dfs/include/dfs_def.h b/components/dfs/include/dfs_def.h index 0651813c9e..8c40123b14 100644 --- a/components/dfs/include/dfs_def.h +++ b/components/dfs/include/dfs_def.h @@ -1,7 +1,7 @@ /* * File : dfs_def.h * This file is part of Device File System in RT-Thread RTOS - * COPYRIGHT (C) 2004-2010, RT-Thread Development Team + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team * * The license and distribution terms for this file may be * found in the file LICENSE in this distribution or at @@ -13,6 +13,7 @@ * 2004-10-14 Beranard Clean up the code. * 2005-01-22 Beranard Clean up the code, port to MinGW */ + #ifndef __DFS_DEF_H__ #define __DFS_DEF_H__ @@ -277,11 +278,11 @@ struct dirent /* file descriptor */ struct dfs_fd { - char* path; /* Name (below mount point) */ + char *path; /* Name (below mount point) */ int type; /* Type (regular or socket) */ int ref_count; /* Descriptor reference count */ - struct dfs_filesystem* fs; /* Resident file system */ + struct dfs_filesystem *fs; /* Resident file system */ rt_uint32_t flags; /* Descriptor flags */ rt_size_t size; /* Size in bytes */ diff --git a/components/dfs/include/dfs_elm.h b/components/dfs/include/dfs_elm.h index c54ee83c1d..656ba07711 100644 --- a/components/dfs/include/dfs_elm.h +++ b/components/dfs/include/dfs_elm.h @@ -1,17 +1,16 @@ /* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_efs.h -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2010-02-06 Bernard Add elm_init function declaration -+------------------------------------------------------------------------------ -*/ + * File : dfs_elm.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2008-2011, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rt-thread.org/license/LICENSE. + * + * Change Logs: + * Date Author Notes + * 2010-02-06 Bernard Add elm_init function declaration + */ #ifndef __DFS_ELM_H__ #define __DFS_ELM_H__ diff --git a/components/dfs/include/dfs_file.h b/components/dfs/include/dfs_file.h index 3cf6681924..ba5f348605 100644 --- a/components/dfs/include/dfs_file.h +++ b/components/dfs/include/dfs_file.h @@ -1,17 +1,16 @@ /* -+------------------------------------------------------------------------------ -| Project : Device Filesystem -+------------------------------------------------------------------------------ -| Copyright 2004, 2005 www.fayfayspace.org. -| All rights reserved. -|------------------------------------------------------------------------------ -| File : dfs_raw.h, the raw APIs of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: -| Date Author Notes -| 2005-01-26 ffxz The first version -+------------------------------------------------------------------------------ -*/ + * File : dfs_file.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rt-thread.org/license/LICENSE. + * + * Change Logs: + * Date Author Notes + * 2005-01-26 Bernard The first version. + */ #ifndef __DFS_RAW_H__ #define __DFS_RAW_H__ @@ -20,16 +19,16 @@ #include #include -int dfs_file_open(struct dfs_fd* fd, const char *path, int flags); -int dfs_file_close(struct dfs_fd* fd); -int dfs_file_ioctl(struct dfs_fd* fd, int cmd, void *args); -int dfs_file_read(struct dfs_fd* fd, void *buf, rt_size_t len); -int dfs_file_getdents(struct dfs_fd* fd, struct dirent* dirp, rt_size_t nbytes); +int dfs_file_open(struct dfs_fd *fd, const char *path, int flags); +int dfs_file_close(struct dfs_fd *fd); +int dfs_file_ioctl(struct dfs_fd *fd, int cmd, void *args); +int dfs_file_read(struct dfs_fd *fd, void *buf, rt_size_t len); +int dfs_file_getdents(struct dfs_fd *fd, struct dirent *dirp, rt_size_t nbytes); int dfs_file_unlink(const char *path); -int dfs_file_write(struct dfs_fd* fd, const void *buf, rt_size_t len); -int dfs_file_lseek(struct dfs_fd* fd, rt_off_t offset); +int dfs_file_write(struct dfs_fd *fd, const void *buf, rt_size_t len); +int dfs_file_lseek(struct dfs_fd *fd, rt_off_t offset); int dfs_file_stat(const char *path, struct stat *buf); -int dfs_file_rename(const char* oldpath, const char* newpath); +int dfs_file_rename(const char *oldpath, const char *newpath); #endif diff --git a/components/dfs/include/dfs_fs.h b/components/dfs/include/dfs_fs.h index fafac355c1..2108d07c82 100644 --- a/components/dfs/include/dfs_fs.h +++ b/components/dfs/include/dfs_fs.h @@ -1,7 +1,7 @@ /* * File : dfs_fs.h * This file is part of Device File System in RT-Thread RTOS - * COPYRIGHT (C) 2004-2010, RT-Thread Development Team + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team * * The license and distribution terms for this file may be * found in the file LICENSE in this distribution or at @@ -11,6 +11,7 @@ * Date Author Notes * 2005-02-22 Bernard The first version. */ + #ifndef __DFS_FS_H__ #define __DFS_FS_H__ @@ -26,25 +27,25 @@ struct dfs_filesystem_operation char *name; /* mount and unmount file system */ - int (*mount) (struct dfs_filesystem* fs, unsigned long rwflag, const void* data); - int (*unmount) (struct dfs_filesystem* fs); + int (*mount) (struct dfs_filesystem *fs, unsigned long rwflag, const void *data); + int (*unmount) (struct dfs_filesystem *fs); /* make a file system */ - int (*mkfs) (const char* device_name); - int (*statfs) (struct dfs_filesystem* fs, struct statfs *buf); - - int (*open) (struct dfs_fd* fd); - int (*close) (struct dfs_fd* fd); - int (*ioctl) (struct dfs_fd* fd, int cmd, void *args); - int (*read) (struct dfs_fd* fd, void* buf, rt_size_t count); - int (*write) (struct dfs_fd* fd, const void* buf, rt_size_t count); - int (*flush) (struct dfs_fd* fd); - int (*lseek) (struct dfs_fd* fd, rt_off_t offset); - int (*getdents) (struct dfs_fd* fd, struct dirent* dirp, rt_uint32_t count); - - int (*unlink) (struct dfs_filesystem* fs, const char* pathname); - int (*stat) (struct dfs_filesystem* fs, const char* filename, struct stat* buf); - int (*rename) (struct dfs_filesystem* fs, const char* oldpath, const char* newpath); + int (*mkfs) (const char *device_name); + int (*statfs) (struct dfs_filesystem *fs, struct statfs *buf); + + int (*open) (struct dfs_fd *fd); + int (*close) (struct dfs_fd *fd); + int (*ioctl) (struct dfs_fd *fd, int cmd, void *args); + int (*read) (struct dfs_fd *fd, void *buf, rt_size_t count); + int (*write) (struct dfs_fd *fd, const void *buf, rt_size_t count); + int (*flush) (struct dfs_fd *fd); + int (*lseek) (struct dfs_fd *fd, rt_off_t offset); + int (*getdents) (struct dfs_fd *fd, struct dirent *dirp, rt_uint32_t count); + + int (*unlink) (struct dfs_filesystem *fs, const char *pathname); + int (*stat) (struct dfs_filesystem *fs, const char *filename, struct stat *buf); + int (*rename) (struct dfs_filesystem *fs, const char *oldpath, const char *newpath); }; /* Mounted file system */ @@ -52,8 +53,8 @@ struct dfs_filesystem { rt_device_t dev_id; /* Attached device */ - char* path; /* File system mount point */ - const struct dfs_filesystem_operation* ops; /* Operations for file system type */ + char *path; /* File system mount point */ + const struct dfs_filesystem_operation *ops; /* Operations for file system type */ void *data; /* Specific file system data */ }; @@ -67,23 +68,23 @@ struct dfs_partition rt_sem_t lock; }; -int dfs_register(const struct dfs_filesystem_operation* ops); -struct dfs_filesystem* dfs_filesystem_lookup(const char *path); -rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* buf, rt_uint32_t pindex); +int dfs_register(const struct dfs_filesystem_operation *ops); +struct dfs_filesystem *dfs_filesystem_lookup(const char *path); +rt_err_t dfs_filesystem_get_partition(struct dfs_partition *part, rt_uint8_t *buf, rt_uint32_t pindex); -int dfs_mount(const char* device_name, const char* path, - const char* filesystemtype, rt_uint32_t rwflag, const - void* data); +int dfs_mount(const char *device_name, const char *path, + const char *filesystemtype, rt_uint32_t rwflag, const + void *data); int dfs_unmount(const char *specialfile); /* extern variable */ -extern const struct dfs_filesystem_operation* filesystem_operation_table[]; +extern const struct dfs_filesystem_operation *filesystem_operation_table[]; extern struct dfs_filesystem filesystem_table[]; extern char working_directory[]; void dfs_lock(void); void dfs_unlock(void); -int dfs_statfs(const char* path, struct statfs* buffer); +int dfs_statfs(const char *path, struct statfs *buffer); #endif diff --git a/components/dfs/include/dfs_init.h b/components/dfs/include/dfs_init.h index bc4e6faab5..061e0e23e8 100644 --- a/components/dfs/include/dfs_init.h +++ b/components/dfs/include/dfs_init.h @@ -1,26 +1,16 @@ /* - -+------------------------------------------------------------------------------ - -| Project : Device Filesystem - -+------------------------------------------------------------------------------ - -| Copyright 2004, 2005 www.fayfayspace.org. - -| All rights reserved. - -|------------------------------------------------------------------------------ - -| File : dfs_init.h, the initilization definitions of Device FileSystem -|------------------------------------------------------------------------------ -| Chang Logs: - -| Date Author Notes - -| 2005-02-21 ffxz The first version. -+------------------------------------------------------------------------------ -*/ + * File : dfs_init.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rt-thread.org/license/LICENSE. + * + * Change Logs: + * Date Author Notes + * 2005-02-21 Bernard The first version. + */ #ifndef __DFS_INIT_H__ #define __DFS_INIT_H__ diff --git a/components/dfs/include/dfs_posix.h b/components/dfs/include/dfs_posix.h index 2eee57a1a8..93cd9747a4 100644 --- a/components/dfs/include/dfs_posix.h +++ b/components/dfs/include/dfs_posix.h @@ -1,7 +1,7 @@ /* * File : dfs_def.h * This file is part of Device File System in RT-Thread RTOS - * COPYRIGHT (C) 2004-2010, RT-Thread Development Team + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team * * The license and distribution terms for this file may be * found in the file LICENSE in this distribution or at @@ -13,6 +13,7 @@ * 2010-07-18 Bernard add stat and statfs structure definitions. * 2011-05-16 Yi.qiu Change parameter name of rename, "new" is C++ key word. */ + #ifndef __DFS_POSIX_H__ #define __DFS_POSIX_H__ @@ -82,9 +83,9 @@ typedef struct } DIR; /* directory api*/ -int mkdir (const char *path, mode_t mode); -DIR* opendir(const char* name); -struct dirent* readdir(DIR *d); +int mkdir(const char *path, mode_t mode); +DIR *opendir(const char *name); +struct dirent *readdir(DIR *d); long telldir(DIR *d); void seekdir(DIR *d, off_t offset); void rewinddir(DIR *d); diff --git a/components/dfs/src/dfs.c b/components/dfs/src/dfs.c index bf042a1b58..33b8f497a9 100644 --- a/components/dfs/src/dfs.c +++ b/components/dfs/src/dfs.c @@ -1,7 +1,7 @@ /* * File : dfs.c * This file is part of Device File System in RT-Thread RTOS - * COPYRIGHT (C) 2004-2010, RT-Thread Development Team + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team * * The license and distribution terms for this file may be * found in the file LICENSE in this distribution or at @@ -10,7 +10,6 @@ * Change Logs: * Date Author Notes * 2005-02-22 Bernard The first version. - * 2010-07-16 */ #include @@ -20,7 +19,7 @@ #define NO_WORKING_DIR "system does not support working dir\n" /* Global variables */ -const struct dfs_filesystem_operation* filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX]; +const struct dfs_filesystem_operation *filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX]; struct dfs_filesystem filesystem_table[DFS_FILESYSTEMS_MAX]; /* device filesystem lock */ @@ -44,7 +43,7 @@ struct dfs_fd fd_table[DFS_FD_MAX]; /** * this function will initialize device file system. */ -void dfs_init() +void dfs_init(void) { /* clear filesystem operations table */ rt_memset(filesystem_operation_table, 0, sizeof(filesystem_operation_table)); @@ -68,7 +67,7 @@ void dfs_init() * * @note please don't invoke it on ISR. */ -void dfs_lock() +void dfs_lock(void) { rt_err_t result; @@ -84,7 +83,7 @@ void dfs_lock() * * @note please don't invoke it on ISR. */ -void dfs_unlock() +void dfs_unlock(void) { rt_mutex_release(&fslock); } @@ -97,7 +96,7 @@ void dfs_unlock() */ int fd_new(void) { - struct dfs_fd* d; + struct dfs_fd *d; int idx; /* lock filesystem */ @@ -138,14 +137,16 @@ __result: * @return NULL on on this file descriptor or the file descriptor structure * pointer. */ -struct dfs_fd* fd_get(int fd) +struct dfs_fd *fd_get(int fd) { - struct dfs_fd* d; + struct dfs_fd *d; #ifdef DFS_USING_STDIO - if ( fd < 3 || fd > DFS_FD_MAX + 3) return RT_NULL; + if (fd < 3 || fd > DFS_FD_MAX + 3) + return RT_NULL; #else - if ( fd < 0 || fd > DFS_FD_MAX ) return RT_NULL; + if (fd < 0 || fd > DFS_FD_MAX) + return RT_NULL; #endif dfs_lock(); @@ -163,13 +164,13 @@ struct dfs_fd* fd_get(int fd) * * This function will put the file descriptor. */ -void fd_put(struct dfs_fd* fd) +void fd_put(struct dfs_fd *fd) { dfs_lock(); fd->ref_count --; /* clear this fd entry */ - if ( fd->ref_count == 0 ) + if (fd->ref_count == 0) { rt_memset(fd, 0, sizeof(struct dfs_fd)); } @@ -185,12 +186,12 @@ void fd_put(struct dfs_fd* fd) * * @return 0 on file has been open successfully, -1 on open failed. */ -int fd_is_open(const char* pathname) +int fd_is_open(const char *pathname) { char *fullpath; unsigned int index; - struct dfs_filesystem* fs; - struct dfs_fd* fd; + struct dfs_filesystem *fs; + struct dfs_fd *fd; fullpath = dfs_normalize_path(RT_NULL, pathname); if (fullpath != RT_NULL) @@ -207,16 +208,17 @@ int fd_is_open(const char* pathname) /* get file path name under mounted file system */ if (fs->path[0] == '/' && fs->path[1] == '\0') mountpath = fullpath; - else mountpath = fullpath + strlen(fs->path); + else + mountpath = fullpath + strlen(fs->path); dfs_lock(); for (index = 0; index < DFS_FD_MAX; index++) { fd = &(fd_table[index]); - if (fd->fs == RT_NULL) continue; + if (fd->fs == RT_NULL) + continue; - if (fd->fs == fs && - strcmp(fd->path, mountpath) == 0) + if (fd->fs == fs && strcmp(fd->path, mountpath) == 0) { /* found file in file descriptor table */ rt_free(fullpath); @@ -240,9 +242,9 @@ int fd_is_open(const char* pathname) * * @return the subdir pointer in filename */ -const char* dfs_subdir(const char* directory, const char* filename) +const char *dfs_subdir(const char *directory, const char *filename) { - const char* dir; + const char *dir; if (strlen(directory) == strlen(filename)) /* it's a same path */ return RT_NULL; @@ -263,7 +265,7 @@ const char* dfs_subdir(const char* directory, const char* filename) * * @return the built full file path (absoluted path) */ -char* dfs_normalize_path(const char* directory, const char* filename) +char *dfs_normalize_path(const char *directory, const char *filename) { char *fullpath; char *dst0, *dst, *src; @@ -311,7 +313,8 @@ char* dfs_normalize_path(const char* directory, const char* filename) /* './' case */ src += 2; - while ((*src == '/') && (*src != '\0')) src ++; + while ((*src == '/') && (*src != '\0')) + src ++; continue; } else if (src[1] == '.') @@ -327,37 +330,47 @@ char* dfs_normalize_path(const char* directory, const char* filename) /* '../' case */ src += 3; - while ((*src == '/') && (*src != '\0')) src ++; + while ((*src == '/') && (*src != '\0')) + src ++; goto up_one; } } } /* copy up the next '/' and erase all '/' */ - while ((c = *src++) != '\0' && c != '/') *dst ++ = c; + while ((c = *src++) != '\0' && c != '/') + *dst ++ = c; if (c == '/') { *dst ++ = '/'; - while (c == '/') c = *src++; + while (c == '/') + c = *src++; src --; } - else if (!c) break; + else if (!c) + break; continue; up_one: dst --; - if (dst < dst0) { rt_free(fullpath); return NULL;} - while (dst0 < dst && dst[-1] != '/') dst --; + if (dst < dst0) + { + rt_free(fullpath); + return NULL; + } + while (dst0 < dst && dst[-1] != '/') + dst --; } *dst = '\0'; /* remove '/' in the end of path if exist */ dst --; - if ((dst != fullpath) && (*dst == '/')) *dst = '\0'; + if ((dst != fullpath) && (*dst == '/')) + *dst = '\0'; return fullpath; } diff --git a/components/dfs/src/dfs_file.c b/components/dfs/src/dfs_file.c index f102c15d32..2746a11b66 100644 --- a/components/dfs/src/dfs_file.c +++ b/components/dfs/src/dfs_file.c @@ -1,7 +1,7 @@ /* * File : dfs_file.c * This file is part of Device File System in RT-Thread RTOS - * COPYRIGHT (C) 2004-2010, RT-Thread Development Team + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team * * The license and distribution terms for this file may be * found in the file LICENSE in this distribution or at @@ -11,6 +11,7 @@ * Date Author Notes * 2005-02-22 Bernard The first version. */ + #include #include @@ -28,14 +29,15 @@ * * @return 0 on successful, -1 on failed. */ -int dfs_file_open(struct dfs_fd* fd, const char *path, int flags) +int dfs_file_open(struct dfs_fd *fd, const char *path, int flags) { - struct dfs_filesystem* fs; + struct dfs_filesystem *fs; char *fullpath; int result; /* parameter check */ - if ( fd == RT_NULL ) return -DFS_STATUS_EINVAL; + if (fd == RT_NULL) + return -DFS_STATUS_EINVAL; /* make sure we have an absolute path */ fullpath = dfs_normalize_path(RT_NULL, path); @@ -48,7 +50,7 @@ int dfs_file_open(struct dfs_fd* fd, const char *path, int flags) /* find filesystem */ fs = dfs_filesystem_lookup(fullpath); - if ( fs == RT_NULL ) + if (fs == RT_NULL) { rt_free(fullpath); /* release path */ return -DFS_STATUS_ENOENT; @@ -92,7 +94,7 @@ int dfs_file_open(struct dfs_fd* fd, const char *path, int flags) } fd->flags |= DFS_F_OPEN; - if ( flags & DFS_O_DIRECTORY ) + if (flags & DFS_O_DIRECTORY) { fd->type = FT_DIRECTORY; fd->flags |= DFS_F_DIRECTORY; @@ -109,14 +111,16 @@ int dfs_file_open(struct dfs_fd* fd, const char *path, int flags) * * @return 0 on successful, -1 on failed. */ -int dfs_file_close(struct dfs_fd* fd) +int dfs_file_close(struct dfs_fd *fd) { int result = 0; - if (fd != RT_NULL && fd->fs->ops->close != RT_NULL) result = fd->fs->ops->close(fd); + if (fd != RT_NULL && fd->fs->ops->close != RT_NULL) + result = fd->fs->ops->close(fd); /* close fd error, return */ - if ( result < 0 ) return result; + if (result < 0) + return result; rt_free(fd->path); rt_memset(fd, 0, sizeof(struct dfs_fd)); @@ -133,14 +137,16 @@ int dfs_file_close(struct dfs_fd* fd) * * @return 0 on successful, -1 on failed. */ -int dfs_file_ioctl(struct dfs_fd* fd, int cmd, void *args) +int dfs_file_ioctl(struct dfs_fd *fd, int cmd, void *args) { - struct dfs_filesystem* fs; + struct dfs_filesystem *fs; - if (fd == RT_NULL || fd->type != FT_REGULAR) return -DFS_STATUS_EINVAL; + if (fd == RT_NULL || fd->type != FT_REGULAR) + return -DFS_STATUS_EINVAL; fs = fd->fs; - if (fs->ops->ioctl != RT_NULL) return fs->ops->ioctl(fd, cmd, args); + if (fs->ops->ioctl != RT_NULL) + return fs->ops->ioctl(fd, cmd, args); return -DFS_STATUS_ENOSYS; } @@ -154,17 +160,20 @@ int dfs_file_ioctl(struct dfs_fd* fd, int cmd, void *args) * * @return the actual read data bytes or 0 on end of file or failed. */ -int dfs_file_read(struct dfs_fd* fd, void *buf, rt_size_t len) +int dfs_file_read(struct dfs_fd *fd, void *buf, rt_size_t len) { - struct dfs_filesystem* fs; + struct dfs_filesystem *fs; int result = 0; - if (fd == RT_NULL) return -DFS_STATUS_EINVAL; + if (fd == RT_NULL) + return -DFS_STATUS_EINVAL; - fs = (struct dfs_filesystem*) fd->fs; - if (fs->ops->read == RT_NULL) return -DFS_STATUS_ENOSYS; + fs = (struct dfs_filesystem *)fd->fs; + if (fs->ops->read == RT_NULL) + return -DFS_STATUS_ENOSYS; - if ( (result = fs->ops->read(fd, buf, len)) < 0 ) fd->flags |= DFS_F_EOF; + if ((result = fs->ops->read(fd, buf, len)) < 0) + fd->flags |= DFS_F_EOF; return result; } @@ -178,15 +187,17 @@ int dfs_file_read(struct dfs_fd* fd, void *buf, rt_size_t len) * * @return the read dirent, others on failed. */ -int dfs_file_getdents(struct dfs_fd* fd, struct dirent* dirp, rt_size_t nbytes) +int dfs_file_getdents(struct dfs_fd *fd, struct dirent *dirp, rt_size_t nbytes) { - struct dfs_filesystem* fs; + struct dfs_filesystem *fs; /* parameter check */ - if (fd == RT_NULL || fd->type != FT_DIRECTORY) return -DFS_STATUS_EINVAL; + if (fd == RT_NULL || fd->type != FT_DIRECTORY) + return -DFS_STATUS_EINVAL; - fs = (struct dfs_filesystem*) fd->fs; - if (fs->ops->getdents != RT_NULL) return fs->ops->getdents(fd, dirp, nbytes); + fs = (struct dfs_filesystem *)fd->fs; + if (fs->ops->getdents != RT_NULL) + return fs->ops->getdents(fd, dirp, nbytes); return -DFS_STATUS_ENOSYS; } @@ -202,19 +213,19 @@ int dfs_file_unlink(const char *path) { int result; char *fullpath; - struct dfs_filesystem* fs; + struct dfs_filesystem *fs; result = DFS_STATUS_OK; /* Make sure we have an absolute path */ fullpath = dfs_normalize_path(RT_NULL, path); - if ( fullpath == RT_NULL) + if (fullpath == RT_NULL) { return -DFS_STATUS_EINVAL; } /* get filesystem */ - if ( (fs = dfs_filesystem_lookup(fullpath)) == RT_NULL) + if ((fs = dfs_filesystem_lookup(fullpath)) == RT_NULL) { result = -DFS_STATUS_ENOENT; goto __exit; @@ -250,14 +261,16 @@ __exit: * * @return the actual written data length. */ -int dfs_file_write(struct dfs_fd* fd, const void *buf, rt_size_t len) +int dfs_file_write(struct dfs_fd *fd, const void *buf, rt_size_t len) { - struct dfs_filesystem* fs; + struct dfs_filesystem *fs; - if (fd == RT_NULL) return -DFS_STATUS_EINVAL; + if (fd == RT_NULL) + return -DFS_STATUS_EINVAL; fs = fd->fs; - if (fs->ops->write == RT_NULL) return -DFS_STATUS_ENOSYS; + if (fs->ops->write == RT_NULL) + return -DFS_STATUS_ENOSYS; return fs->ops->write(fd, buf, len); } @@ -269,14 +282,16 @@ int dfs_file_write(struct dfs_fd* fd, const void *buf, rt_size_t len) * * @return 0 on successful, -1 on failed. */ -int dfs_file_flush(struct dfs_fd* fd) +int dfs_file_flush(struct dfs_fd *fd) { - struct dfs_filesystem* fs; + struct dfs_filesystem *fs; - if (fd == RT_NULL) return -DFS_STATUS_EINVAL; + if (fd == RT_NULL) + return -DFS_STATUS_EINVAL; fs = fd->fs; - if (fs->ops->flush == RT_NULL) return -DFS_STATUS_ENOSYS; + if (fs->ops->flush == RT_NULL) + return -DFS_STATUS_ENOSYS; return fs->ops->flush(fd); } @@ -289,13 +304,15 @@ int dfs_file_flush(struct dfs_fd* fd) * * @return the current position after seek. */ -int dfs_file_lseek(struct dfs_fd* fd, rt_off_t offset) +int dfs_file_lseek(struct dfs_fd *fd, rt_off_t offset) { int result; - struct dfs_filesystem* fs = fd->fs; + struct dfs_filesystem *fs = fd->fs; - if (fd == RT_NULL) return -DFS_STATUS_EINVAL; - if (fs->ops->lseek == RT_NULL) return -DFS_STATUS_ENOSYS; + if (fd == RT_NULL) + return -DFS_STATUS_EINVAL; + if (fs->ops->lseek == RT_NULL) + return -DFS_STATUS_ENOSYS; result = fs->ops->lseek(fd, offset); @@ -317,11 +334,11 @@ int dfs_file_lseek(struct dfs_fd* fd, rt_off_t offset) int dfs_file_stat(const char *path, struct stat *buf) { int result; - char* fullpath; - struct dfs_filesystem* fs; + char *fullpath; + struct dfs_filesystem *fs; fullpath = dfs_normalize_path(RT_NULL, path); - if ( fullpath == RT_NULL ) + if (fullpath == RT_NULL) { return -1; } @@ -339,7 +356,7 @@ int dfs_file_stat(const char *path, struct stat *buf) /* it's the root directory */ buf->st_dev = 0; - buf->st_mode = DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | + buf->st_mode = DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH; buf->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH; @@ -378,7 +395,7 @@ int dfs_file_stat(const char *path, struct stat *buf) * * @return 0 on successful, -1 on failed. */ -int dfs_file_rename(const char* oldpath, const char* newpath) +int dfs_file_rename(const char *oldpath, const char *newpath) { int result; struct dfs_filesystem *oldfs, *newfs; @@ -388,34 +405,34 @@ int dfs_file_rename(const char* oldpath, const char* newpath) newfullpath = RT_NULL; oldfullpath = dfs_normalize_path(RT_NULL, oldpath); - if ( oldfullpath == RT_NULL ) + if (oldfullpath == RT_NULL) { result = -DFS_STATUS_ENOENT; goto __exit; } newfullpath = dfs_normalize_path(RT_NULL, newpath); - if ( newfullpath == RT_NULL ) + if (newfullpath == RT_NULL) { result = -DFS_STATUS_ENOENT; goto __exit; } - if ( (oldfs = dfs_filesystem_lookup(oldfullpath)) == RT_NULL ) + if ((oldfs = dfs_filesystem_lookup(oldfullpath)) == RT_NULL) { result = -DFS_STATUS_ENOENT; goto __exit; } - if ( (newfs = dfs_filesystem_lookup(newfullpath)) == RT_NULL ) + if ((newfs = dfs_filesystem_lookup(newfullpath)) == RT_NULL) { result = -DFS_STATUS_ENOENT; goto __exit; } - if ( oldfs == newfs ) + if (oldfs == newfs) { - if ( oldfs->ops->rename == RT_NULL ) + if (oldfs->ops->rename == RT_NULL) { result = -DFS_STATUS_ENOSYS; goto __exit; @@ -440,7 +457,7 @@ __exit: static struct dfs_fd fd; static struct dirent dirent; -void ls(const char* pathname) +void ls(const char *pathname) { struct stat stat; int length; @@ -459,24 +476,25 @@ void ls(const char* pathname) } else { - path = (char*)pathname; + path = (char *)pathname; } /* list directory */ - if ( dfs_file_open(&fd, path, DFS_O_DIRECTORY) == 0 ) + if (dfs_file_open(&fd, path, DFS_O_DIRECTORY) == 0) { rt_kprintf("Directory %s:\n", path); do { rt_memset(&dirent, 0, sizeof(struct dirent)); length = dfs_file_getdents(&fd, &dirent, sizeof(struct dirent)); - if ( length > 0 ) + if (length > 0) { rt_memset(&stat, 0, sizeof(struct stat)); /* build full path for each file */ fullpath = dfs_normalize_path(path, dirent.d_name); - if (fullpath == RT_NULL) break; + if (fullpath == RT_NULL) + break; if (dfs_file_stat(fullpath, &stat) == 0) { @@ -502,11 +520,12 @@ void ls(const char* pathname) { rt_kprintf("No such directory\n"); } - if (pathname == RT_NULL) rt_free(path); + if (pathname == RT_NULL) + rt_free(path); } FINSH_FUNCTION_EXPORT(ls, list directory contents) -void rm(const char* filename) +void rm(const char *filename) { if (dfs_file_unlink(filename) < 0) { @@ -541,7 +560,7 @@ void cat(const char* filename) FINSH_FUNCTION_EXPORT(cat, print file) #define BUF_SZ 4096 -void copy(const char* src, const char* dst) +void copy(const char *src, const char *dst) { struct dfs_fd src_fd; rt_uint8_t *block_ptr; diff --git a/components/dfs/src/dfs_fs.c b/components/dfs/src/dfs_fs.c index da1e456c7b..fc27fe354a 100644 --- a/components/dfs/src/dfs_fs.c +++ b/components/dfs/src/dfs_fs.c @@ -1,7 +1,7 @@ /* * File : dfs_fs.c * This file is part of Device File System in RT-Thread RTOS - * COPYRIGHT (C) 2004-2010, RT-Thread Development Team + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team * * The license and distribution terms for this file may be * found in the file LICENSE in this distribution or at @@ -13,6 +13,7 @@ * 2010-06-30 Bernard Optimize for RT-Thread RTOS * 2011-03-12 Bernard fix the filesystem lookup issue. */ + #include #include @@ -28,43 +29,43 @@ * * @return 0 on sucessful, -1 on failed. */ -int dfs_register(const struct dfs_filesystem_operation* ops) +int dfs_register(const struct dfs_filesystem_operation *ops) { - int index, result; + int index, result; 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 */ - for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX && filesystem_operation_table[index] != RT_NULL; - index++) ; - - /* filesystem type table full */ - if (index == DFS_FILESYSTEM_TYPES_MAX) + /* 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 */ + for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX && filesystem_operation_table[index] != RT_NULL; + index++) ; + + /* filesystem type table full */ + if (index == DFS_FILESYSTEM_TYPES_MAX) { result = -1; goto err; - } + } - /* save the filesystem's operations */ - filesystem_operation_table[index] = ops; + /* save the filesystem's operations */ + filesystem_operation_table[index] = ops; err: dfs_unlock(); - return result; + return result; } /** @@ -75,42 +76,44 @@ err: * @return the found file system or NULL if no file system mounted on * specified path */ -struct dfs_filesystem* dfs_filesystem_lookup(const char *path) +struct dfs_filesystem *dfs_filesystem_lookup(const char *path) { - struct dfs_filesystem* fs; - rt_uint32_t index, fspath, prefixlen; + struct dfs_filesystem *fs; + rt_uint32_t index, fspath, prefixlen; - fs = RT_NULL; - prefixlen = 0; + fs = RT_NULL; + prefixlen = 0; - /* lock filesystem */ + /* lock filesystem */ dfs_lock(); - /* lookup it in the filesystem table */ - for (index = 0; index < DFS_FILESYSTEMS_MAX; index++) - { - if (filesystem_table[index].path == RT_NULL) continue; + /* lookup it in the filesystem table */ + for (index = 0; index < DFS_FILESYSTEMS_MAX; index++) + { + if (filesystem_table[index].path == RT_NULL) + continue; else { fspath = strlen(filesystem_table[index].path); - if (fspath < prefixlen) continue; + if (fspath < prefixlen) + continue; } - if ((filesystem_table[index].ops != RT_NULL) && - (strncmp(filesystem_table[index].path, path, fspath) == 0)) - { - /* check next path separator */ - if ( fspath > 1 && (strlen(path) > fspath) && - (path[fspath] != '/')) continue; + if ((filesystem_table[index].ops != RT_NULL) && + (strncmp(filesystem_table[index].path, path, fspath) == 0)) + { + /* check next path separator */ + if (fspath > 1 && (strlen(path) > fspath) && (path[fspath] != '/')) + continue; - fs = &filesystem_table[index]; - prefixlen = fspath; - } - } + fs = &filesystem_table[index]; + prefixlen = fspath; + } + } dfs_unlock(); - return fs; + return fs; } /** @@ -122,69 +125,66 @@ struct dfs_filesystem* dfs_filesystem_lookup(const char *path) * * @return RT_EOK on successful or -RT_ERROR on failed. */ -rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* buf, rt_uint32_t pindex) +rt_err_t dfs_filesystem_get_partition(struct dfs_partition *part, rt_uint8_t *buf, rt_uint32_t pindex) { #define DPT_ADDRESS 0x1be /* device partition offset in Boot Sector */ #define DPT_ITEM_SIZE 16 /* partition item size */ - rt_uint8_t* dpt; - rt_uint8_t type; - rt_err_t result; - - RT_ASSERT(part != RT_NULL); - RT_ASSERT(buf != RT_NULL); - - result = RT_EOK; - - dpt = buf + DPT_ADDRESS + pindex * DPT_ITEM_SIZE; - - if ((*dpt != 0x80) && (*dpt != 0x00)) - { - /* which is not a partition table */ - result = -RT_ERROR; - return result; - } - - /* get partition type */ - type = *(dpt+4); - - if (type != 0) - { - /* set partition type */ - part->type = type; - - /* get partition offset and size */ - part->offset = *(dpt+ 8) | *(dpt+ 9) << 8 | - *(dpt+10) << 16 | *(dpt+11) << 24; - part->size = *(dpt+12) | *(dpt+13) << 8 | - *(dpt+14) << 16 | *(dpt+15) << 24; - - rt_kprintf("found part[%d], begin: %d, size: ", - pindex, part->offset * 512); - if ( (part->size>>11) > 0 ) /* MB */ - { - unsigned int part_size; - part_size = part->size>>11;/* MB */ - if ( (part_size>>10) > 0) /* GB */ - { - rt_kprintf("%d.%d%s",part_size>>10,part_size&0x3FF,"GB\r\n");/* GB */ - } - else - { - rt_kprintf("%d.%d%s",part_size,(part->size>>1)&0x3FF,"MB\r\n");/* MB */ - } - } - else - { - rt_kprintf("%d%s",part->size>>1,"KB\r\n");/* KB */ - } - } - else - { - result = -RT_ERROR; - } - - return result; + rt_uint8_t *dpt; + rt_uint8_t type; + rt_err_t result; + + RT_ASSERT(part != RT_NULL); + RT_ASSERT(buf != RT_NULL); + + result = RT_EOK; + + dpt = buf + DPT_ADDRESS + pindex * DPT_ITEM_SIZE; + + if ((*dpt != 0x80) && (*dpt != 0x00)) + { + /* which is not a partition table */ + result = -RT_ERROR; + return result; + } + + /* get partition type */ + type = *(dpt+4); + + if (type != 0) + { + /* set partition type */ + part->type = type; + + /* get partition offset and size */ + part->offset = *(dpt+8) | *(dpt+9)<<8 | *(dpt+10)<<16 | *(dpt+11)<<24; + part->size = *(dpt+12) | *(dpt+13)<<8 | *(dpt+14)<<16 | *(dpt+15)<<24; + + rt_kprintf("found part[%d], begin: %d, size: ", pindex, part->offset*512); + if ((part->size>>11) > 0) /* MB */ + { + unsigned int part_size; + part_size = part->size >> 11;/* MB */ + if ((part_size>>10) > 0) /* GB */ + { + rt_kprintf("%d.%d%s",part_size>>10,part_size&0x3FF,"GB\r\n");/* GB */ + } + else + { + rt_kprintf("%d.%d%s",part_size,(part->size>>1)&0x3FF,"MB\r\n");/* MB */ + } + } + else + { + rt_kprintf("%d%s",part->size>>1,"KB\r\n");/* KB */ + } + } + else + { + result = -RT_ERROR; + } + + return result; } /** @@ -198,17 +198,17 @@ rt_err_t dfs_filesystem_get_partition(struct dfs_partition* part, rt_uint8_t* bu * * @return 0 on successful or -1 on failed. */ -int dfs_mount(const char* device_name, const char* path, - const char* filesystemtype, unsigned long rwflag, const - void* data) +int dfs_mount(const char *device_name, const char *path, + const char *filesystemtype, unsigned long rwflag, const + void *data) { - const struct dfs_filesystem_operation* ops; - struct dfs_filesystem* fs; - char *fullpath=RT_NULL; - rt_device_t dev_id; - int index; + const struct dfs_filesystem_operation *ops; + struct dfs_filesystem *fs; + char *fullpath=RT_NULL; + rt_device_t dev_id; + int index; - /* open specific device */ + /* open specific device */ if (device_name != RT_NULL) { dev_id = rt_device_find(device_name); @@ -225,112 +225,117 @@ int dfs_mount(const char* device_name, const char* path, dev_id = RT_NULL; } - /* find out specific filesystem */ + /* find out specific filesystem */ dfs_lock(); - for ( index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++ ) - { - if (strcmp(filesystem_operation_table[index]->name, filesystemtype) == 0)break; - } - - /* can't find filesystem */ - if ( index == DFS_FILESYSTEM_TYPES_MAX ) - { - rt_set_errno(-DFS_STATUS_ENODEV); - dfs_unlock(); - return -1; - } - ops = filesystem_operation_table[index]; - dfs_unlock(); - - /* make full path for special file */ + for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++) + { + if (strcmp(filesystem_operation_table[index]->name, filesystemtype) == 0) + break; + } + + /* can't find filesystem */ + if (index == DFS_FILESYSTEM_TYPES_MAX) + { + rt_set_errno(-DFS_STATUS_ENODEV); + dfs_unlock(); + return -1; + } + ops = filesystem_operation_table[index]; + dfs_unlock(); + + /* make full path for special file */ fullpath = dfs_normalize_path(RT_NULL, path); - if ( fullpath == RT_NULL) /* not an abstract path */ - { - rt_set_errno(-DFS_STATUS_ENOTDIR); - return -1; - } - - /* Check if the path exists or not, raw APIs call, fixme */ - if ( (strcmp(fullpath, "/") != 0) && (strcmp(fullpath, "/dev") != 0) ) - { - struct dfs_fd fd; - - if ( dfs_file_open(&fd, fullpath, DFS_O_RDONLY | DFS_O_DIRECTORY) < 0 ) - { - rt_free(fullpath); - rt_set_errno(-DFS_STATUS_ENOTDIR); - return -1; - } - dfs_file_close(&fd); - } - - /* check whether the file system mounted or not */ + if (fullpath == RT_NULL) /* not an abstract path */ + { + rt_set_errno(-DFS_STATUS_ENOTDIR); + return -1; + } + + /* Check if the path exists or not, raw APIs call, fixme */ + if ((strcmp(fullpath, "/") != 0) && (strcmp(fullpath, "/dev") != 0)) + { + struct dfs_fd fd; + + if (dfs_file_open(&fd, fullpath, DFS_O_RDONLY | DFS_O_DIRECTORY) < 0) + { + rt_free(fullpath); + rt_set_errno(-DFS_STATUS_ENOTDIR); + return -1; + } + dfs_file_close(&fd); + } + + /* check whether the file system mounted or not */ dfs_lock(); - for (index =0; index < DFS_FILESYSTEMS_MAX; index++) - { - if ( filesystem_table[index].ops != RT_NULL && - strcmp(filesystem_table[index].path, path) == 0 ) - { - rt_set_errno(-DFS_STATUS_EINVAL); - goto err1; - } - } - - /* find out en empty filesystem table entry */ - for (index = 0; index < DFS_FILESYSTEMS_MAX && filesystem_table[index].ops != RT_NULL; - index++) ; - if ( index == DFS_FILESYSTEMS_MAX ) /* can't find en empty filesystem table entry */ - { - rt_set_errno(-DFS_STATUS_ENOSPC); - goto err1; - } - - /* register file system */ - fs = &(filesystem_table[index]); + for (index =0; index < DFS_FILESYSTEMS_MAX; index++) + { + if (filesystem_table[index].ops != RT_NULL && + strcmp(filesystem_table[index].path, path) == 0) + { + rt_set_errno(-DFS_STATUS_EINVAL); + goto err1; + } + } + + /* find out en empty filesystem table entry */ + for (index = 0; index < DFS_FILESYSTEMS_MAX && filesystem_table[index].ops != RT_NULL; + index++) ; + if (index == DFS_FILESYSTEMS_MAX) /* can't find en empty filesystem table entry */ + { + rt_set_errno(-DFS_STATUS_ENOSPC); + goto err1; + } + + /* register file system */ + fs = &(filesystem_table[index]); fs->path = fullpath; - fs->ops = ops; - fs->dev_id = dev_id; - /* release filesystem_table lock */ + fs->ops = ops; + fs->dev_id = dev_id; + /* release filesystem_table lock */ dfs_unlock(); /* open device, but do not check the status of device */ - if (dev_id != RT_NULL) rt_device_open(fs->dev_id, RT_DEVICE_OFLAG_RDWR); - - if (ops->mount == RT_NULL) /* there is no mount implementation */ - { - if (dev_id != RT_NULL) rt_device_close(dev_id); - dfs_lock(); - /* clear filesystem table entry */ - rt_memset(fs, 0, sizeof(struct dfs_filesystem)); + if (dev_id != RT_NULL) + rt_device_open(fs->dev_id, RT_DEVICE_OFLAG_RDWR); + + if (ops->mount == RT_NULL) /* there is no mount implementation */ + { + if (dev_id != RT_NULL) + rt_device_close(dev_id); + dfs_lock(); + /* clear filesystem table entry */ + rt_memset(fs, 0, sizeof(struct dfs_filesystem)); dfs_unlock(); rt_free(fullpath); - rt_set_errno(-DFS_STATUS_ENOSYS); - return -1; - } - /* call mount of this filesystem */ - else if (ops->mount(fs, rwflag, data) < 0) - { - /* close device */ - if (dev_id != RT_NULL) rt_device_close(fs->dev_id); - - /* mount failed */ + rt_set_errno(-DFS_STATUS_ENOSYS); + return -1; + } + /* call mount of this filesystem */ + else if (ops->mount(fs, rwflag, data) < 0) + { + /* close device */ + if (dev_id != RT_NULL) + rt_device_close(fs->dev_id); + + /* mount failed */ dfs_lock(); - /* clear filesystem table entry */ - rt_memset(fs, 0, sizeof(struct dfs_filesystem)); + /* clear filesystem table entry */ + rt_memset(fs, 0, sizeof(struct dfs_filesystem)); dfs_unlock(); rt_free(fullpath); return -1; - } + } - return 0; + return 0; err1: - dfs_unlock(); - if (fullpath != RT_NULL) rt_free(fullpath); + dfs_unlock(); + if (fullpath != RT_NULL) + rt_free(fullpath); - return -1; + return -1; } /** @@ -342,42 +347,42 @@ err1: */ int dfs_unmount(const char *specialfile) { - char *fullpath; - struct dfs_filesystem* fs = RT_NULL; - - fullpath = dfs_normalize_path(RT_NULL, specialfile); - if (fullpath == RT_NULL) - { - rt_set_errno(-DFS_STATUS_ENOTDIR); - return -1; - } - - /* lock filesystem */ - dfs_lock(); - - fs = dfs_filesystem_lookup(fullpath); - if (fs != RT_NULL && fs->ops->unmount != RT_NULL && fs->ops->unmount(fs) < 0) - { - goto err1; - } - - /* close device, but do not check the status of device */ + char *fullpath; + struct dfs_filesystem *fs = RT_NULL; + + fullpath = dfs_normalize_path(RT_NULL, specialfile); + if (fullpath == RT_NULL) + { + rt_set_errno(-DFS_STATUS_ENOTDIR); + return -1; + } + + /* lock filesystem */ + dfs_lock(); + + fs = dfs_filesystem_lookup(fullpath); + if (fs != RT_NULL && fs->ops->unmount != RT_NULL && fs->ops->unmount(fs) < 0) + { + goto err1; + } + + /* close device, but do not check the status of device */ if (fs->dev_id != RT_NULL) - rt_device_close(fs->dev_id); + rt_device_close(fs->dev_id); - /* clear this filesystem table entry */ - rt_memset(fs, 0, sizeof(struct dfs_filesystem)); + /* clear this filesystem table entry */ + rt_memset(fs, 0, sizeof(struct dfs_filesystem)); dfs_unlock(); rt_free(fullpath); - return 0; + return 0; err1: dfs_unlock(); rt_free(fullpath); - return -1; + return -1; } /** @@ -388,18 +393,18 @@ err1: * * @return 0 on successful, otherwise failed. */ -int dfs_mkfs(const char* fs_name, const char* device_name) +int dfs_mkfs(const char *fs_name, const char *device_name) { - int index; + int index; /* lock filesystem */ dfs_lock(); - /* find the file system operations */ - for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++) - { - if (filesystem_operation_table[index] != RT_NULL && - strcmp(filesystem_operation_table[index]->name, fs_name) == 0) - { + /* find the file system operations */ + for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index++) + { + if (filesystem_operation_table[index] != RT_NULL && + strcmp(filesystem_operation_table[index]->name, fs_name) == 0) + { /* find file system operation */ const struct dfs_filesystem_operation* ops = filesystem_operation_table[index]; dfs_unlock(); @@ -408,8 +413,8 @@ int dfs_mkfs(const char* fs_name, const char* device_name) return ops->mkfs(device_name); break; - } - } + } + } dfs_unlock(); return -1; @@ -423,9 +428,9 @@ int dfs_mkfs(const char* fs_name, const char* device_name) * * @return 0 on successful, others on failed. */ -int dfs_statfs(const char* path, struct statfs* buffer) +int dfs_statfs(const char *path, struct statfs *buffer) { - struct dfs_filesystem* fs; + struct dfs_filesystem *fs; fs = dfs_filesystem_lookup(path); if (fs != NULL) @@ -439,13 +444,13 @@ int dfs_statfs(const char* path, struct statfs* buffer) #ifdef RT_USING_FINSH #include -void mkfs(const char* fs_name, const char* device_name) +void mkfs(const char *fs_name, const char *device_name) { dfs_mkfs(fs_name, device_name); } FINSH_FUNCTION_EXPORT(mkfs, make a file system); -void df(const char* path) +void df(const char *path) { struct statfs buffer; diff --git a/components/dfs/src/dfs_posix.c b/components/dfs/src/dfs_posix.c index 1c81e6c1fc..c21917d29a 100644 --- a/components/dfs/src/dfs_posix.c +++ b/components/dfs/src/dfs_posix.c @@ -1,7 +1,7 @@ /* * File : dfs_posix.c * This file is part of Device File System in RT-Thread RTOS - * COPYRIGHT (C) 2004-2010, RT-Thread Development Team + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team * * The license and distribution terms for this file may be * found in the file LICENSE in this distribution or at @@ -33,11 +33,12 @@ int open(const char *file, int flags, int mode) { int fd, result; - struct dfs_fd* d; + struct dfs_fd *d; /* allocate a fd */ fd = fd_new(); - if (fd < 0) return -1; + if (fd < 0) + return -1; d = fd_get(fd); result = dfs_file_open(d, file, flags); @@ -68,7 +69,7 @@ int open(const char *file, int flags, int mode) int close(int fd) { int result; - struct dfs_fd* d; + struct dfs_fd *d; d = fd_get(fd); if (d == RT_NULL) @@ -103,7 +104,7 @@ int close(int fd) int read(int fd, void *buf, size_t len) { int result; - struct dfs_fd* d; + struct dfs_fd *d; /* get the fd */ d = fd_get(fd); @@ -140,7 +141,7 @@ int read(int fd, void *buf, size_t len) int write(int fd, const void *buf, size_t len) { int result; - struct dfs_fd* d; + struct dfs_fd *d; /* get the fd */ d = fd_get(fd); @@ -177,7 +178,7 @@ int write(int fd, const void *buf, size_t len) off_t lseek(int fd, off_t offset, int whence) { int result; - struct dfs_fd* d; + struct dfs_fd *d; d = fd_get(fd); if (d == RT_NULL) @@ -200,7 +201,7 @@ off_t lseek(int fd, off_t offset, int whence) break; } - if( offset < 0 ) + if(offset < 0) { rt_set_errno(DFS_STATUS_EINVAL); return -1; @@ -229,7 +230,7 @@ off_t lseek(int fd, off_t offset, int whence) * * note: the old and new file name must be belong to a same file system. */ -int rename(const char* old, const char* new) +int rename(const char *old, const char *new) { int result; @@ -292,7 +293,7 @@ int stat(const char *file, struct stat *buf) */ int fstat(int fildes, struct stat *buf) { - struct dfs_fd* d; + struct dfs_fd *d; /* get the fd */ d = fd_get(fildes); @@ -303,7 +304,7 @@ int fstat(int fildes, struct stat *buf) } /* it's the root directory */ - buf->st_dev = 0; + buf->st_dev = 0; buf->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH; @@ -356,11 +357,15 @@ int statfs(const char *path, struct statfs *buf) int mkdir (const char *path, mode_t mode) { int fd; - struct dfs_fd* d; + struct dfs_fd *d; int result; fd = fd_new(); - if (fd == -1) { rt_kprintf("no fd\n"); return -1; } + if (fd == -1) + { + rt_kprintf("no fd\n"); + return -1; + } d = fd_get(fd); @@ -410,17 +415,21 @@ int rmdir(const char *pathname) * * @return the DIR pointer of directory, NULL on open failed. */ -DIR* opendir(const char* name) +DIR *opendir(const char *name) { - struct dfs_fd* d; + struct dfs_fd *d; int fd, result; - DIR* t; + DIR *t; t = RT_NULL; /* allocate a fd */ fd = fd_new(); - if (fd == -1) { rt_kprintf("no fd\n"); return RT_NULL; } + if (fd == -1) + { + rt_kprintf("no fd\n"); + return RT_NULL; + } d = fd_get(fd); result = dfs_file_open(d, name, DFS_O_RDONLY | DFS_O_DIRECTORY); @@ -459,10 +468,10 @@ DIR* opendir(const char* name) * * @return the next directory entry, NULL on the end of directory or failed. */ -struct dirent* readdir(DIR *d) +struct dirent *readdir(DIR *d) { int result; - struct dfs_fd* fd; + struct dfs_fd *fd; fd = fd_get(d->fd); if (fd == RT_NULL) @@ -488,7 +497,7 @@ struct dirent* readdir(DIR *d) } fd_put(fd); - return (struct dirent*)(d->buf+d->cur); + return (struct dirent *)(d->buf+d->cur); } /** @@ -501,7 +510,7 @@ struct dirent* readdir(DIR *d) */ long telldir(DIR *d) { - struct dfs_fd* fd; + struct dfs_fd *fd; long result; fd = fd_get(d->fd); @@ -526,7 +535,7 @@ long telldir(DIR *d) */ void seekdir(DIR *d, off_t offset) { - struct dfs_fd* fd; + struct dfs_fd *fd; fd = fd_get(d->fd); if (fd == RT_NULL) @@ -536,7 +545,8 @@ void seekdir(DIR *d, off_t offset) } /* seek to the offset position of directory */ - if (dfs_file_lseek(fd, offset) >= 0) d->num = d->cur = 0; + if (dfs_file_lseek(fd, offset) >= 0) + d->num = d->cur = 0; fd_put(fd); } @@ -547,7 +557,7 @@ void seekdir(DIR *d, off_t offset) */ void rewinddir(DIR *d) { - struct dfs_fd* fd; + struct dfs_fd *fd; fd = fd_get(d->fd); if (fd == RT_NULL) @@ -557,7 +567,8 @@ void rewinddir(DIR *d) } /* seek to the beginning of directory */ - if (dfs_file_lseek(fd, 0) >= 0) d->num = d->cur = 0; + if (dfs_file_lseek(fd, 0) >= 0) + d->num = d->cur = 0; fd_put(fd); } @@ -569,10 +580,10 @@ void rewinddir(DIR *d) * * @return 0 on successful, -1 on failed. */ -int closedir(DIR* d) +int closedir(DIR *d) { int result; - struct dfs_fd* fd; + struct dfs_fd *fd; fd = fd_get(d->fd); if (fd == RT_NULL) @@ -605,10 +616,10 @@ int closedir(DIR* d) */ int chdir(const char *path) { - char* fullpath; - DIR* d; + char *fullpath; + DIR *d; - if(path == RT_NULL) + if (path == RT_NULL) { dfs_lock(); rt_kprintf("%s\n", working_directory); -- GitLab