/* * File : rtthread.h * This file is part of RT-Thread RTOS * COPYRIGHT (C) 2006-2012, 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 * 2012-1-7 prife the first version */ #include #include #include "cyg/infra/cyg_type.h" #include "cyg/fileio/fileio.h" #include "port/codes.h" #include "port/fcntl.h" #undef mode_t #include #include #include "dfs_jffs2.h" #include "jffs2_config.h" #include "porting.h" #include #if DEVICE_PART_MAX > 1 #error "support only one jffs2 partition on a flash device!" #endif /* make sure the following struct var had been initilased to 0! */ struct device_part { struct cyg_mtab_entry * mte; struct rt_mtd_nor_device *dev; }; static struct device_part device_partition[DEVICE_PART_MAX] = {0}; static struct rt_mutex jffs2_lock; #define jffs2_mount jffs2_fste.mount #define jffs2_umount jffs2_fste.umount #define jffs2_open jffs2_fste.open #define jffs2_file_unlink jffs2_fste.unlink #define jffs2_mkdir jffs2_fste.mkdir #define jffs2_rmdir jffs2_fste.rmdir #define jffs2_rename jffs2_fste.rename #define jffs2_link jffs2_fste.link #define jffs2_opendir jffs2_fste.opendir #define jffs2_chdir jffs2_fste.chdir #define jffs2_ops_stat jffs2_fste.stat #define jffs2_getinfo jffs2_fste.getinfo #define jffs2_setinfo jffs2_fste.setinfo #define jffs2_file_read jffs2_fileops.fo_read #define jffs2_file_write jffs2_fileops.fo_write #define jffs2_file_lseek jffs2_fileops.fo_lseek #define jffs2_file_ioctl jffs2_fileops.fo_ioctl #define jffs2_file_select jffs2_fileops.fo_select #define jffs2_file_fsync jffs2_fileops.fo_fsync #define jffs2_file_colse jffs2_fileops.fo_close #define jffs2_file_fstat jffs2_fileops.fo_fstat #define jffs2_file_getinfo jffs2_fileops.fo_getinfo #define jffs2_file_setinfo jffs2_fileops.fo_setinfo #define jffs2_dir_read jffs2_dirops.fo_read //#define jffs2_dir_write jffs2_dirops.fo_write #define jffs2_dir_lseek jffs2_dirops.fo_lseek //#define jffs2_dir_ioctl jffs2_dirops.fo_ioctl #define jffs2_dir_select jffs2_dirops.fo_select //#define jffs2_dir_fsync jffs2_dirops.fo_fsync #define jffs2_dir_colse jffs2_dirops.fo_close //#define jffs2_dir_fstat jffs2_dirops.fo_fstat //#define jffs2_dir_getinfo jffs2_dirops.fo_getinfo //#define jffs2_dir_setinfo jffs2_dirops.fo_setinfo /* * RT-Thread Device Interface for jffs2 */ /* these code is in src/flashio.c */ static int jffs2_result_to_dfs(int result) { int status = -1; if (result < 0) result = -result; switch (result) { case ENOERR:/** no error */ break; case EACCES:/** Tried to open read-only file for writing, or files sharing mode does not allow specified operations, or given path is directory */ status = -DFS_STATUS_EINVAL; break;/* no suitable */ case EEXIST: /** _O_CREAT and _O_EXCL flags specified, but filename already exists */ status = -DFS_STATUS_EEXIST; break; case EINVAL: /** Invalid oflag or pmode argument */ status = -DFS_STATUS_EINVAL; break; case EMFILE: /** No more file handles available(too many open files) */ rt_kprintf("dfs_jffs2.c error: no more file handles available\r\n"); status = -1; break;//fixme case ENOENT: /** file or path not found */ status = -DFS_STATUS_ENOENT; break; case EBADF: /** invalid file handle */ status = -DFS_STATUS_EBADF; break; case ENOMEM:/** no enough memory */ status = -DFS_STATUS_ENOMEM; break; case EIO: /** I/O error from lower level flash operation */ status = -DFS_STATUS_EIO; break; case ENOTDIR: /** Not a directory */ status = -DFS_STATUS_ENOTDIR; break; case EISDIR: /** Is a directory */ status = -DFS_STATUS_EISDIR; break; case ENOSPC: /**//* No space left on device */ status = -DFS_STATUS_ENOSPC; break; default: rt_kprintf("dfs_jffs2.c error: %d\r\n", result); status = -1; break; /* unknown error! */ } return status; } /* * RT-Thread DFS Interface for jffs2 */ static int dfs_jffs2_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data) { unsigned index; struct cyg_mtab_entry * mte; int result; /* find a empty entry in partition table */ for (index = 0; index < DEVICE_PART_MAX; index ++) { if (device_partition[index].dev == RT_NULL) break; } if (index == DEVICE_PART_MAX) return -DFS_STATUS_ENOSPC; mte = rt_malloc(sizeof(struct cyg_mtab_entry)); if (mte == RT_NULL) return -DFS_STATUS_ENOMEM; mte->name = fs->path; mte->fsname = "jffs2"; mte->devname = NULL; /* note that, i use mte->data to store rtt's device * while, in jffs2_mount, mte->data will be copy into * s_dev in struct super_block, and mte->data will be * filled with jffs2_sb(see the source of jffs2_mount. */ mte->data = (CYG_ADDRWORD)fs->dev_id; device_partition[index].dev = RT_MTD_NOR_DEVICE(fs->dev_id); /* after jffs2_mount, mte->data will not be dev_id any more */ result = jffs2_mount(NULL, mte); if (result != 0) { return jffs2_result_to_dfs(result); } /* save this pointer */ device_partition[index].mte = mte; return 0; } static int _find_fs(struct cyg_mtab_entry ** mte, rt_device_t dev_id) { unsigned index; /* find device index */ for (index = 0; index < DEVICE_PART_MAX; index++) { if (device_partition[index].dev == RT_MTD_NOR_DEVICE(dev_id)) { *mte = device_partition[index].mte; return 0; } } rt_kprintf("error, could not found the fs!"); return -1; } static int dfs_jffs2_unmount(struct dfs_filesystem* fs) { int result; unsigned index; /* find device index, then umount it */ for (index = 0; index < DEVICE_PART_MAX; index++) { if (device_partition[index].dev == RT_MTD_NOR_DEVICE(fs->dev_id)) { result = jffs2_umount(device_partition[index].mte); if (result) return jffs2_result_to_dfs(result); rt_free(device_partition[index].mte); device_partition[index].dev = NULL; device_partition[index].mte = NULL; return DFS_STATUS_OK; } } return -DFS_STATUS_ENOENT; } static int dfs_jffs2_mkfs(const char* device_name) { /* just erase all blocks on this nand partition */ return -DFS_STATUS_ENOSYS; } static int dfs_jffs2_statfs(struct dfs_filesystem* fs, struct statfs *buf) { /* since the limit of unsigned long, so the max size of flash device is 4G */ struct cyg_mtab_entry * mte; struct jffs2_fs_info info; int result; result = _find_fs(&mte, fs->dev_id); if (result) return -DFS_STATUS_ENOENT; RT_ASSERT(mte->data != NULL); jffs2_get_info_from_sb((void *)mte->data, &info); buf->f_bsize = info.sector_size; buf->f_blocks = info.nr_blocks; buf->f_bfree = info.free_size / info.sector_size; return 0; } static const char jffs2_root_path[] = "."; static int dfs_jffs2_open(struct dfs_fd* file) { int oflag, mode; int result; cyg_file * jffs2_file; struct cyg_mtab_entry * mte; const char * name; oflag = file->flags; jffs2_file = rt_malloc(sizeof(cyg_file)); if (jffs2_file == RT_NULL) return -DFS_STATUS_ENOMEM; /* just escape '/' provided by dfs code */ name = file->path; if ((name[0] == '/') && (name[1] == 0)) name = jffs2_root_path; else /* name[0] still will be '/' */ name ++; result = _find_fs(&mte, file->fs->dev_id); if (result) { rt_free(jffs2_file); return -DFS_STATUS_ENOENT; } if (oflag & DFS_O_DIRECTORY) /* operations about dir */ { rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); if (oflag & DFS_O_CREAT) /* create a dir*/ { /* fixme, should test file->path can end with '/' */ result = jffs2_mkdir(mte, mte->root, name); if (result) { rt_mutex_release(&jffs2_lock); rt_free(jffs2_file); return jffs2_result_to_dfs(result); } } /* open dir */ result = jffs2_opendir(mte, mte->root, name, jffs2_file); rt_mutex_release(&jffs2_lock); if (result) { rt_free(jffs2_file); return jffs2_result_to_dfs(result); } #ifdef CONFIG_JFFS2_NO_RELATIVEDIR jffs2_file->f_offset = 2; #endif /* save this pointer, it will be used by dfs_jffs2_getdents*/ file->data = jffs2_file; return 0; } /* regular file operations */ mode = 0; if (oflag & DFS_O_RDONLY) mode |= JFFS2_O_RDONLY; if (oflag & DFS_O_WRONLY) mode |= JFFS2_O_WRONLY; if (oflag & DFS_O_RDWR) mode |= JFFS2_O_RDWR; /* Opens the file, if it is existing. If not, a new file is created. */ if (oflag & DFS_O_CREAT) mode |= JFFS2_O_CREAT; /* Creates a new file. If the file is existing, it is truncated and overwritten. */ if (oflag & DFS_O_TRUNC) mode |= JFFS2_O_TRUNC; /* Creates a new file. The function fails if the file is already existing. */ if (oflag & DFS_O_EXCL) mode |= JFFS2_O_EXCL; // if (oflag & DFS_O_APPEND) mode |= JFFS2_O_APPEND; rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_open(mte, 0, name, mode, jffs2_file); if (result != 0) { rt_mutex_release(&jffs2_lock); rt_free(jffs2_file); return jffs2_result_to_dfs(result); } /* save this pointer, it will be used when calling read()£¬write(), flush(), lessk(), and will be rt_free when calling close()*/ file->data = jffs2_file; file->pos = jffs2_file->f_offset; file->size = 0; jffs2_file_lseek(jffs2_file, (off_t *)(&(file->size)), DFS_SEEK_END); jffs2_file->f_offset = (off_t)file->pos; rt_mutex_release(&jffs2_lock); if (oflag & DFS_O_APPEND) { file->pos = file->size; jffs2_file->f_offset = file->size; } return 0; } static int dfs_jffs2_close(struct dfs_fd* file) { int result; cyg_file * jffs2_file; RT_ASSERT(file->data != NULL); jffs2_file = (cyg_file *)(file->data); if (file->flags & DFS_O_DIRECTORY) /* operations about dir */ { rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_dir_colse(jffs2_file); rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); rt_free(jffs2_file); return 0; } /* regular file operations */ rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_file_colse(jffs2_file); rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); /* release memory */ rt_free(jffs2_file); return 0; } static int dfs_jffs2_ioctl(struct dfs_fd* file, int cmd, void* args) { return -DFS_STATUS_ENOSYS; } static int dfs_jffs2_read(struct dfs_fd* file, void* buf, rt_size_t len) { cyg_file * jffs2_file; struct CYG_UIO_TAG uio_s; struct CYG_IOVEC_TAG iovec; int char_read; int result; RT_ASSERT(file->data != NULL); jffs2_file = (cyg_file *)(file->data); uio_s.uio_iov = &iovec; uio_s.uio_iov->iov_base = buf; uio_s.uio_iov->iov_len = len; uio_s.uio_iovcnt = 1; //must be 1 //uio_s.uio_offset //not used... uio_s.uio_resid = uio_s.uio_iov->iov_len; //seem no use in jffs2; char_read = jffs2_file->f_offset; /* the current offset */ rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_file_read(jffs2_file, &uio_s); rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); /* update position */ file->pos = jffs2_file->f_offset; char_read = jffs2_file->f_offset - char_read; return char_read; } static int dfs_jffs2_write(struct dfs_fd* file, const void* buf, rt_size_t len) { cyg_file * jffs2_file; struct CYG_UIO_TAG uio_s; struct CYG_IOVEC_TAG iovec; int char_write; int result; RT_ASSERT(file->data != NULL); jffs2_file = (cyg_file *)(file->data); uio_s.uio_iov = &iovec; uio_s.uio_iov->iov_base = (void *)buf; uio_s.uio_iov->iov_len = len; uio_s.uio_iovcnt = 1; //must be 1 //uio_s.uio_offset //not used... uio_s.uio_resid = uio_s.uio_iov->iov_len; //seem no use in jffs2; char_write = jffs2_file->f_offset; rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_file_write(jffs2_file, &uio_s); rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); /* update position */ file->pos = jffs2_file->f_offset; char_write = jffs2_file->f_offset - char_write; return char_write; } static int dfs_jffs2_flush(struct dfs_fd* file) { /* infact, jffs2 not support, jffs2_fo_sync just return ok */ return -DFS_STATUS_ENOSYS; } /* fixme warning: the offset is rt_off_t, so maybe the size of a file is must <= 2G*/ static int dfs_jffs2_lseek(struct dfs_fd* file, rt_off_t offset) { cyg_file * jffs2_file; int result; RT_ASSERT(file->data != NULL); jffs2_file = (cyg_file *)(file->data); /* set offset as current offset */ rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_file_lseek(jffs2_file, &offset, DFS_SEEK_SET); rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); /* update file position */ file->pos = offset; return offset; } /* return the size of struct dirent*/ static int dfs_jffs2_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) { cyg_file * jffs2_file; struct CYG_UIO_TAG uio_s; struct CYG_IOVEC_TAG iovec; struct jffs2_dirent jffs2_d; struct dirent * d; rt_uint32_t index; #if !defined (CYGPKG_FS_JFFS2_RET_DIRENT_DTYPE) struct jffs2_stat s; cyg_mtab_entry * mte; char * fullname; #endif int result; RT_ASSERT(file->data != RT_NULL); jffs2_file = (cyg_file*)(file->data); //set jffs2_d memset(&jffs2_d, 0, sizeof(struct jffs2_dirent)); //set CYG_UIO_TAG uio_s uio_s.uio_iov = &iovec; uio_s.uio_iov->iov_base = &jffs2_d; uio_s.uio_iov->iov_len = sizeof(struct jffs2_dirent);; uio_s.uio_iovcnt = 1; //must be 1 uio_s.uio_offset = 0;//not used... uio_s.uio_resid = uio_s.uio_iov->iov_len; //seem no use in jffs2; #if !defined (CYGPKG_FS_JFFS2_RET_DIRENT_DTYPE) result = _find_fs(&mte, file->fs->dev_id); if (result) return -DFS_STATUS_ENOENT; #endif /* make integer count, usually count is 1 */ count = (count / sizeof(struct dirent)) * sizeof(struct dirent); if (count == 0) return -DFS_STATUS_EINVAL; index = 0; /* usually, the while loop should only be looped only once! */ while (1) { d = dirp + index; rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_dir_read(jffs2_file, &uio_s); rt_mutex_release(&jffs2_lock); /* if met a error or all entry are read over, break while*/ if (result || jffs2_d.d_name[0] == 0) break; #if defined (CYGPKG_FS_JFFS2_RET_DIRENT_DTYPE) switch(jffs2_d.d_type & JFFS2_S_IFMT) { case JFFS2_S_IFREG: d->d_type = DFS_DT_REG; break; case JFFS2_S_IFDIR: d->d_type = DFS_DT_DIR; break; default: d->d_type = DFS_DT_UNKNOWN; break; } #else fullname = rt_malloc(FILE_PATH_MAX); if(fullname == RT_NULL) return -DFS_STATUS_ENOMEM; /* make a right entry */ if ((file->path[0] == '/') ) { if (file->path[1] == 0) strcpy(fullname, jffs2_d.d_name); else rt_sprintf(fullname, "%s/%s", file->path+1, jffs2_d.d_name); } else rt_sprintf(fullname, "%s/%s", file->path, jffs2_d.d_name); rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_porting_stat(mte, mte->root, fullname, (void *)&s); rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); rt_free(fullname); /* convert to dfs stat structure */ switch(s.st_mode & JFFS2_S_IFMT) { case JFFS2_S_IFREG: d->d_type = DFS_DT_REG; break; case JFFS2_S_IFDIR: d->d_type = DFS_DT_DIR; break; default: d->d_type = DFS_DT_UNKNOWN; break; } #endif /* write the rest fields of struct dirent* dirp */ d->d_namlen = rt_strlen(jffs2_d.d_name); d->d_reclen = (rt_uint16_t)sizeof(struct dirent); rt_strncpy(d->d_name, jffs2_d.d_name, d->d_namlen + 1); index ++; if (index * sizeof(struct dirent) >= count) break; } if (result) return jffs2_result_to_dfs(result); return index * sizeof(struct dirent); } static int dfs_jffs2_unlink(struct dfs_filesystem* fs, const char* path) { int result; struct jffs2_stat s; cyg_mtab_entry * mte; result = _find_fs(&mte, fs->dev_id); if (result) return -DFS_STATUS_ENOENT; /* deal path */ if (path[0] == '/') path++; /* judge file type, dir is to be delete by rmdir, others by unlink */ rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_porting_stat(mte, mte->root, path, (void *)&s); if (result) { rt_mutex_release(&jffs2_lock); return jffs2_result_to_dfs(result); } switch(s.st_mode & JFFS2_S_IFMT) { case JFFS2_S_IFREG: result = jffs2_file_unlink(mte, mte->root, path); break; case JFFS2_S_IFDIR: result = jffs2_rmdir(mte, mte->root, path); break; default: /* unknown file type */ rt_mutex_release(&jffs2_lock); return -1; } rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); return 0; } static int dfs_jffs2_rename(struct dfs_filesystem* fs, const char* oldpath, const char* newpath) { int result; cyg_mtab_entry * mte; result = _find_fs(&mte, fs->dev_id); if (result) return -DFS_STATUS_ENOENT; if (*oldpath == '/') oldpath += 1; if (*newpath == '/') newpath += 1; rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_rename(mte, mte->root, oldpath, mte->root, newpath); rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); return 0; } static int dfs_jffs2_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) { int result; struct jffs2_stat s; cyg_mtab_entry * mte; /* deal the path for jffs2 */ RT_ASSERT(!((path[0] == '/') && (path[1] == 0))); if (path[0] == '/') path++; result = _find_fs(&mte, fs->dev_id); if (result) return -DFS_STATUS_ENOENT; rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER); result = jffs2_porting_stat(mte, mte->root, path, (void *)&s); rt_mutex_release(&jffs2_lock); if (result) return jffs2_result_to_dfs(result); /* convert to dfs stat structure */ switch(s.st_mode & JFFS2_S_IFMT) { case JFFS2_S_IFREG: st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH; break; case JFFS2_S_IFDIR: st->st_mode = DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH; break; default: st->st_mode = DFS_DT_UNKNOWN; //fixme break; } st->st_dev = 0; st->st_size = s.st_size; st->st_mtime = s.st_mtime; st->st_blksize = 1;//fixme: what's this field? return 0; } static const struct dfs_filesystem_operation dfs_jffs2_ops = { "jffs2", /* file system type: jffs2 */ #if RTTHREAD_VERSION >= 10100 DFS_FS_FLAG_DEFAULT, /* use Relative Path */ #endif dfs_jffs2_mount, dfs_jffs2_unmount, dfs_jffs2_mkfs, dfs_jffs2_statfs, dfs_jffs2_open, dfs_jffs2_close, dfs_jffs2_ioctl, dfs_jffs2_read, dfs_jffs2_write, dfs_jffs2_flush, dfs_jffs2_lseek, dfs_jffs2_getdents, dfs_jffs2_unlink, dfs_jffs2_stat, dfs_jffs2_rename, }; int dfs_jffs2_init(void) { /* register fatfs file system */ dfs_register(&dfs_jffs2_ops); /* initialize mutex */ if (rt_mutex_init(&jffs2_lock, "jffs2lock", RT_IPC_FLAG_FIFO) != RT_EOK) { rt_kprintf("init jffs2 lock mutex failed\n"); } rt_kprintf("init jffs2 lock mutex okay\n"); return 0; }