Skip to content

R
rt-thread

Mr_Pangza / rt-thread
与 Fork 源项目一致

Fork自 RT-Thread / rt-thread

通知 2
Star 1
Fork 1
R
rt-thread

体验新版 GitCode，发现更多精彩内容 >>

提交 8e430738 编写于 作者: B bernard
浏览文件
操作

[DFS] update JFFS2 with RT-Thread 3.0.x.

上级 f6a95087
隐藏空白更改
内联 并排
Showing with 593 addition and 822 deletion
components/dfs/Kconfig
浏览文件 @ 8e430738
......@@ -157,6 +157,11 @@ if RT_USING_DFS
endif
config RT_USING_DFS_JFFS2
bool "Enable JFFS2 file system"
select RT_USING_MTD_NOR
default n
config RT_USING_DFS_NFS
bool "Using NFS v3 client file system"
select RT_USING_LWIP
......
components/dfs/filesystems/jffs2/cyg/compress/src/zutil.h
浏览文件 @ 8e430738
......@@ -28,7 +28,7 @@
# include <stddef.h>
# endif
# include <string.h>
//# include <stdlib.h> //remove by prife @ 2012/1/30
# include <stdlib.h>
#endif
#ifdef NO_ERRNO_H
# ifdef _WIN32_WCE
......
components/dfs/filesystems/jffs2/cyg/compress/zconf.h
浏览文件 @ 8e430738
......@@ -12,11 +12,16 @@
#undef __ECOS__
#define __ECOS__
#include <rtthread.h>
#define malloc rt_malloc
#define free rt_free
#define printf rt_kprintf
#ifndef RT_USING_LIBC
#define malloc rt_malloc
#define free rt_free
#define printf rt_kprintf
#endif
//#define Z_PREFIX //by prife
//#include <pkgconf/compress_zlib.h> //prife no such file.
#if CYGINT_COMPRESS_ZLIB_LOCAL_ALLOC != 0
#define MY_ZCALLOC
#endif
......
components/dfs/filesystems/jffs2/cyg/fileio/fileio.h
浏览文件 @ 8e430738
......@@ -313,13 +313,13 @@ struct CYG_FILEOPS_TAG
struct CYG_FILE_TAG
{
cyg_uint32 f_flag; /* file state */
cyg_uint32 f_flag; /* file state */
cyg_uint16 f_ucount; /* use count */
cyg_uint16 f_type; /* descriptor type */
cyg_uint16 f_type; /* descriptor type */
cyg_uint32 f_syncmode; /* synchronization protocol */
struct CYG_FILEOPS_TAG *f_ops; /* file operations */
off_t f_offset; /* current offset */
CYG_ADDRWORD f_data; /* file or socket */
off_t f_offset; /* current offset */
CYG_ADDRWORD f_data; /* file or socket */
CYG_ADDRWORD f_xops; /* extra type specific ops */
cyg_mtab_entry *f_mte; /* mount table entry */
};
......
components/dfs/filesystems/jffs2/dfs_jffs2.c
浏览文件 @ 8e430738
/*
* File : rtthread.h
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006-2012, RT-Thread Development Team
* File : dfs_jffs2.c
* This file is part of Device File System in RT-Thread RTOS
* COPYRIGHT (C) 2006-2017, 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.
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2012-1-7 prife the first version
*/
*/
#include <rtthread.h>
#include <rtdevice.h>
......@@ -21,7 +32,7 @@
#undef mode_t
#include <dfs_fs.h>
#include <dfs_def.h>
#include <dfs_file.h>
#include "dfs_jffs2.h"
#include "jffs2_config.h"
......@@ -29,51 +40,50 @@
#include <string.h>
#if DEVICE_PART_MAX > 1
#error "support only one jffs2 partition on a flash device!"
#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 device_part
{
struct cyg_mtab_entry * mte;
struct rt_mtd_nor_device *dev;
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_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_lseek jffs2_dirops.fo_lseek
//#define jffs2_dir_ioctl jffs2_dirops.fo_ioctl
#define jffs2_dir_select jffs2_dirops.fo_select
#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_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
......@@ -82,649 +92,610 @@ static struct rt_mutex jffs2_lock;
* RT-Thread Device Interface for jffs2
*/
/* these code is in src/flashio.c */
/* 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;
if (result < 0) return result;
if (result > 0) return -result;
return 0;
}
/*
* RT-Thread DFS Interface for jffs2
*/
static int dfs_jffs2_mount(struct dfs_filesystem* fs,
unsigned long rwflag,
const void* data)
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)
{
device_partition[index].dev = NULL;
return jffs2_result_to_dfs(result);
}
/* save this pointer */
device_partition[index].mte = mte;
return 0;
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 -ENOSPC;
mte = rt_malloc(sizeof(struct cyg_mtab_entry));
if (mte == RT_NULL)
return -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)
{
device_partition[index].dev = NULL;
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;
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;
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 RT_EOK;
}
}
return -ENOENT;
}
static int dfs_jffs2_mkfs(rt_device_t dev_id)
{
/* just erase all blocks on this nand partition */
return -DFS_STATUS_ENOSYS;
/* just erase all blocks on this nand partition */
return -ENOSYS;
}
static int dfs_jffs2_statfs(struct dfs_filesystem* fs,
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;
/* 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 -ENOENT;
RT_ASSERT(mte->data != 0);
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);
}
int result;
int oflag, mode;
const char * name;
cyg_file * jffs2_file;
struct dfs_filesystem *fs;
struct cyg_mtab_entry * mte;
oflag = file->flags;
fs = (struct dfs_filesystem *)file->data;
RT_ASSERT(fs != RT_NULL);
jffs2_file = rt_malloc(sizeof(cyg_file));
if (jffs2_file == RT_NULL)
return -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, fs->dev_id);
if (result)
{
rt_free(jffs2_file);
return -ENOENT;
}
/* set mount table */
jffs2_file->f_mte = mte;
if (oflag & O_DIRECTORY) /* operations about dir */
{
rt_mutex_take(&jffs2_lock, RT_WAITING_FOREVER);
if (oflag & 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;
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);
/* save this pointer, it will be used by dfs_jffs2_getdents*/
file->data = jffs2_file;
return 0;
}
/* regular file operations */
mode = JFFS2_O_RDONLY;
if (oflag & O_WRONLY) mode |= JFFS2_O_WRONLY;
if (oflag & O_RDWR) mode |= JFFS2_O_RDWR;
/* Opens the file, if it is existing. If not, a new file is created. */
if (oflag & O_CREAT) mode |= JFFS2_O_CREAT;
/* Creates a new file. If the file is existing, it is truncated and overwritten. */
if (oflag & O_TRUNC) mode |= JFFS2_O_TRUNC;
/* Creates a new file. The function fails if the file is already existing. */
if (oflag & O_EXCL) mode |= JFFS2_O_EXCL;
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);
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;
}
/* 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)), SEEK_END);
jffs2_file->f_offset = (off_t)file->pos;
rt_mutex_release(&jffs2_lock);
if (oflag & 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;
int result;
cyg_file * jffs2_file;
RT_ASSERT(file->data != NULL);
jffs2_file = (cyg_file *)(file->data);
if (file->flags & 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;
return -ENOSYS;
}
static int dfs_jffs2_read(struct dfs_fd* file, void* buf, rt_size_t len)
static int dfs_jffs2_read(struct dfs_fd* file, void* buf, 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);
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;
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)
static int dfs_jffs2_write(struct dfs_fd* file,
const void* buf,
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);
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;
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;
/* infact, jffs2 not support, jffs2_fo_sync just return ok */
return -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,
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;
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, 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)
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;
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;
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;
int result;
#if !defined (CYGPKG_FS_JFFS2_RET_DIRENT_DTYPE)
RT_ASSERT(file->data != RT_NULL);
jffs2_file = (cyg_file*)(file->data);
mte = jffs2_file->f_mte;
result = _find_fs(&mte, file->fs->dev_id);
if (result)
return -DFS_STATUS_ENOENT;
#endif
//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;
/* 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;
/* make integer count, usually count is 1 */
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
if (count == 0) return -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;
}
switch(jffs2_d.d_type & JFFS2_S_IFMT)
{
case JFFS2_S_IFREG: d->d_type = DT_REG; break;
case JFFS2_S_IFDIR: d->d_type = DT_DIR; break;
default: d->d_type = 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;
}
fullname = rt_malloc(FILE_PATH_MAX);
if(fullname == RT_NULL)
return -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 = DT_REG; break;
case JFFS2_S_IFDIR: d->d_type = DT_DIR; break;
default: d->d_type = 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);
/* 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;
int result;
struct jffs2_stat s;
cyg_mtab_entry * mte;
result = _find_fs(&mte, fs->dev_id);
if (result)
return -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,
static int dfs_jffs2_rename(struct dfs_filesystem* fs,
const char* oldpath,
const char* newpath)
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;
int result;
cyg_mtab_entry * mte;
result = _find_fs(&mte, fs->dev_id);
if (result)
return -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;
return 0;
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 -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 = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
S_IWUSR | S_IWGRP | S_IWOTH;
break;
case JFFS2_S_IFDIR:
st->st_mode = S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
break;
default:
st->st_mode = DT_UNKNOWN; //fixme
break;
}
st->st_dev = 0;
st->st_size = s.st_size;
st->st_mtime = s.st_mtime;
return 0;
}
static const struct dfs_filesystem_operation dfs_jffs2_ops =
static const struct dfs_file_ops _jffs2_fops =
{
"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,
dfs_jffs2_open,
dfs_jffs2_close,
dfs_jffs2_ioctl,
dfs_jffs2_read,
dfs_jffs2_write,
dfs_jffs2_flush,
dfs_jffs2_lseek,
dfs_jffs2_getdents,
};
static const struct dfs_filesystem_ops _jffs2_ops =
{
"jffs2",
DFS_FS_FLAG_DEFAULT,
&_jffs2_fops,
dfs_jffs2_mount,
dfs_jffs2_unmount,
dfs_jffs2_mkfs,
dfs_jffs2_statfs,
dfs_jffs2_unlink,
dfs_jffs2_stat,
dfs_jffs2_rename,
};
int dfs_jffs2_init(void)
{
/* register fatfs file system */
dfs_register(&dfs_jffs2_ops);
dfs_register(&_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;
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;
}
INIT_COMPONENT_EXPORT(dfs_jffs2_init);
components/dfs/filesystems/jffs2/include/linux/jffs2.h
浏览文件 @ 8e430738
......@@ -74,6 +74,8 @@
/* These can go once we've made sure we've caught all uses without
byteswapping */
#include <stdint.h>
#if defined(__GNUC__) || (__CC_ARM)
typedef struct {
uint32_t v32;
......
components/dfs/filesystems/jffs2/include/port/codes.h
浏览文件 @ 8e430738
......@@ -86,94 +86,9 @@ extern "C" {
typedef int Cyg_ErrNo;
#include <rtthread.h>
/* CONSTANT DEFINITIONS */
/* If adding to this list, you must also update strerror() with its text
* If there is a common error of the same purpose on Unix, try and use its
* name and number. If not, use one above 200 to prevent future conflicts
*
* Do not use negative numbers, so that functions can return positive on
* success and -ESOMETHING on error, and it all works consistently.
*/
#define ENOERR 0 /* No error */
#define EPERM 1 /* Not permitted */
#define ENOENT 2 /* No such entity */
#define ESRCH 3 /* No such process */
#define EINTR 4 /* Operation interrupted */
#define EIO 5 /* I/O error */
#define EBADF 9 /* Bad file handle */
#define EAGAIN 11 /* Try again later */
#define EWOULDBLOCK EAGAIN
#define ENOMEM 12 /* Out of memory */
#define EBUSY 16 /* Resource busy */
#define EXDEV 18 /* Cross-device link */
#define ENODEV 19 /* No such device */
#define ENOTDIR 20 /* Not a directory */
#define EISDIR 21 /* Is a directory */
#define EINVAL 22 /* Invalid argument */
#define ENFILE 23 /* Too many open files in system */
#define EMFILE 24 /* Too many open files */
#define EFBIG 27 /* File too large */
#define ENOSPC 28 /* No space left on device */
#define ESPIPE 29 /* Illegal seek */
#define EROFS 30 /* Read-only file system */
#define EDOM 33 /* Argument to math function outside valid */
/* domain */
#define ERANGE 34 /* Math result cannot be represented */
#define EDEADLK 35 /* Resource deadlock would occur */
#define EDEADLOCK EDEADLK
#define ENOSYS 38 /* Function not implemented */
#define ENAMETOOLONG 60 /* File name too long */
#define ENOTEMPTY 66 /* Directory not empty */
#define ENOTSUP 95 /* Not supported error */
#define EEOF 200 /* End of file reached */
#define ENOSUPP 201 /* Operation not supported */
#define EDEVNOSUPP 202 /* Device does not support this operation */
/* Additional errors used by networking */
#define ENXIO 300 /* Device not configured */
#define EACCES 301 /* Permission denied */
#define EEXIST 302 /* File exists */
#define ENOTTY 303 /* Inappropriate ioctl for device */
#define EPIPE 304 /* Broken pipe */
/* non-blocking and interrupt i/o */
#define EINPROGRESS 310 /* Operation now in progress */
#define EALREADY 311 /* Operation already in progress */
/* ipc/network software -- argument errors */
#define ENOTSOCK 320 /* Socket operation on non-socket */
#define EDESTADDRREQ 321 /* Destination address required */
#define EMSGSIZE 322 /* Message too long */
#define EPROTOTYPE 323 /* Protocol wrong type for socket */
#define ENOPROTOOPT 324 /* Protocol not available */
#define EPROTONOSUPPORT 325 /* Protocol not supported */
#define ESOCKTNOSUPPORT 326 /* Socket type not supported */
#define EOPNOTSUPP 327 /* Operation not supported */
#define EPFNOSUPPORT 328 /* Protocol family not supported */
#define EAFNOSUPPORT 329 /* Address family not supported by */
/* protocol family */
#define EADDRINUSE 330 /* Address already in use */
#define EADDRNOTAVAIL 331 /* Can't assign requested address */
/* ipc/network software -- operational errors */
#define ENETDOWN 350 /* Network is down */
#define ENETUNREACH 351 /* Network is unreachable */
#define ENETRESET 352 /* Network dropped connection on reset */
#define ECONNABORTED 353 /* Software caused connection abort */
#define ECONNRESET 354 /* Connection reset by peer */
#define ENOBUFS 355 /* No buffer space available */
#define EISCONN 356 /* Socket is already connected */
#define ENOTCONN 357 /* Socket is not connected */
#define ESHUTDOWN 358 /* Can't send after socket shutdown */
#define ETOOMANYREFS 359 /* Too many references: can't splice */
#define ETIMEDOUT 360 /* Operation timed out */
#define ECONNREFUSED 361 /* Connection refused */
#define EHOSTDOWN 364 /* Host is down */
#define EHOSTUNREACH 365 /* No route to host */
#define ENOERR RT_EOK
#ifdef __cplusplus
} /* extern "C" */
......
components/dfs/filesystems/jffs2/include/port/fcntl.h
浏览文件 @ 8e430738
#ifndef CYGONCE_ISO_FCNTL_H
#define CYGONCE_ISO_FCNTL_H
#if defined(__CC_ARM) || defined(MSVC)
/* File access modes used for open() and fnctl() */
#define O_RDONLY (1<<0) /* Open for reading only */
#define O_WRONLY (1<<1) /* Open for writing only */
#define O_RDWR (O_RDONLY|O_WRONLY) /* Open for reading and writing */
/* File access mode mask */
#define O_ACCMODE (O_RDONLY|O_RDWR|O_WRONLY)
/* open() mode flags */
#define O_CREAT (1<<3) /* Create file it it does not exist */
#define O_EXCL (1<<4) /* Exclusive use */
#define O_NOCTTY (1<<5) /* Do not assign a controlling terminal */
#define O_TRUNC (1<<6) /* Truncate */
/* File status flags used for open() and fcntl() */
#define O_APPEND (1<<7) /* Set append mode */
#define O_DSYNC (1<<8) /* Synchronized I/O data integrity writes */
#define O_NONBLOCK (1<<9) /* No delay */
#define O_RSYNC (1<<10) /* Synchronized read I/O */
#define O_SYNC (1<<11) /* Synchronized I/O file integrity writes */
/*------------------------------------------------------------------------*/
/* for dfs_jffs2.c */
/* for dfs_jffs2.c */
/*------------------------------------------------------------------------*/
/* File access modes used for open() and fnctl() */
#define JFFS2_O_RDONLY (1<<0) /* Open for reading only */
#define JFFS2_O_WRONLY (1<<1) /* Open for writing only */
#define JFFS2_O_RDONLY (O_RDONLY) /* Open for reading only */
#define JFFS2_O_WRONLY (O_WRONLY) /* Open for writing only */
#define JFFS2_O_RDWR (O_RDONLY|O_WRONLY) /* Open for reading and writing */
/* File access mode mask */
......@@ -36,45 +14,18 @@
/* open() mode flags */
#define JFFS2_O_CREAT (1<<3) /* Create file it it does not exist */
#define JFFS2_O_EXCL (1<<4) /* Exclusive use */
#define JFFS2_O_NOCTTY (1<<5) /* Do not assign a controlling terminal */
#define JFFS2_O_TRUNC (1<<6) /* Truncate */
/* File status flags used for open() and fcntl() */
#define JFFS2_O_APPEND (1<<7) /* Set append mode */
#define JFFS2_O_DSYNC (1<<8) /* Synchronized I/O data integrity writes */
#define JFFS2_O_NONBLOCK (1<<9) /* No delay */
#define JFFS2_O_RSYNC (1<<10) /* Synchronized read I/O */
#define JFFS2_O_SYNC (1<<11) /* Synchronized I/O file integrity writes */
#elif defined(__GNUC__)
/*------------------------------------------------------------------------*/
/* for dfs_jffs2.c */
/*------------------------------------------------------------------------*/
/* File access modes used for open() and fnctl() */
#define JFFS2_O_RDONLY (DFS_O_RDONLY) /* Open for reading only */
#define JFFS2_O_WRONLY (DFS_O_WRONLY) /* Open for writing only */
#define JFFS2_O_RDWR (DFS_O_RDONLY|DFS_O_WRONLY) /* Open for reading and writing */
/* File access mode mask */
#define JFFS2_O_ACCMODE (DFS_O_RDONLY|DFS_O_RDWR|DFS_O_WRONLY)
/* open() mode flags */
#define JFFS2_O_CREAT (DFS_O_CREAT) /* Create file it it does not exist */
#define JFFS2_O_EXCL (DFS_O_EXCL) /* Exclusive use */
#define JFFS2_O_NOCTTY (DFS_O_NOCTTY) /* Do not assign a controlling terminal */
#define JFFS2_O_TRUNC (DFS_O_TRUNC) /* Truncate */
#define JFFS2_O_CREAT (O_CREAT) /* Create file it it does not exist */
#define JFFS2_O_EXCL (O_EXCL) /* Exclusive use */
#define JFFS2_O_NOCTTY (O_NOCTTY) /* Do not assign a controlling terminal */
#define JFFS2_O_TRUNC (O_TRUNC) /* Truncate */
/* File status flags used for open() and fcntl() */
#define JFFS2_O_APPEND (DFS_O_APPEND) /* Set append mode */
#define JFFS2_O_DSYNC (DFS_O_DSYNC) /* Synchronized I/O data integrity writes */
#define JFFS2_O_NONBLOCK (DFS_O_NONBLOCK)/* No delay */
#define JFFS2_O_RSYNC (DFS_O_RSYNC) /* Synchronized read I/O */
#define JFFS2_O_SYNC (DFS_O_SYNC) /* Synchronized I/O file integrity writes */
#define JFFS2_O_APPEND (O_APPEND) /* Set append mode */
#define JFFS2_O_DSYNC (O_DSYNC) /* Synchronized I/O data integrity writes */
#define JFFS2_O_NONBLOCK (O_NONBLOCK)/* No delay */
#define JFFS2_O_RSYNC (O_RSYNC) /* Synchronized read I/O */
#define JFFS2_O_SYNC (O_SYNC) /* Synchronized I/O file integrity writes */
#endif
#endif
/* EOF fcntl.h */
components/dfs/filesystems/jffs2/include/port/sys/stat.h
浏览文件 @ 8e430738
......@@ -271,51 +271,6 @@ typedef void *cyg_io_handle_t;
#define __stat_mode_LNK (1<<8)
#define __stat_mode_SOCK (1<<9)
#if !defined(_POSIX_C_SOURCE) || (_POSIX_C_SOURCE >= 200112L)
#define S_IFDIR (__stat_mode_DIR)
#define S_IFCHR (__stat_mode_CHR)
#define S_IFBLK (__stat_mode_BLK)
#define S_IFREG (__stat_mode_REG)
#define S_IFIFO (__stat_mode_FIFO)
#define S_IFLNK (__stat_mode_LNK)
#define S_IFSOCK (__stat_mode_SOCK)
#define S_IFMT (S_IFDIR|S_IFCHR|S_IFBLK|S_IFREG| \
S_IFIFO|S_IFLNK|S_IFSOCK)
#endif
#define S_ISDIR(__mode) ((__mode) & __stat_mode_DIR )
#define S_ISCHR(__mode) ((__mode) & __stat_mode_CHR )
#define S_ISBLK(__mode) ((__mode) & __stat_mode_BLK )
#define S_ISREG(__mode) ((__mode) & __stat_mode_REG )
#define S_ISFIFO(__mode) ((__mode) & __stat_mode_FIFO )
#if !defined(_POSIX_C_SOURCE) || (_POSIX_C_SOURCE >= 200112L)
#define S_ISLNK(__mode) ((__mode) & __stat_mode_LNK )
#define S_ISSOCK(__mode) ((__mode) & __stat_mode_SOCK )
#endif
#define S_TYPEISMQ(__buf) ((__buf)->st_mode & __stat_mode_MQ )
#define S_TYPEISSEM(__buf) ((__buf)->st_mode & __stat_mode_SEM )
#define S_TYPEISSHM(__buf) ((__buf)->st_mode & __stat_mode_SHM )
#define S_IRUSR (1<<16)
#define S_IWUSR (1<<17)
#define S_IXUSR (1<<18)
#define S_IRWXU (S_IRUSR|S_IWUSR|S_IXUSR)
#define S_IRGRP (1<<19)
#define S_IWGRP (1<<20)
#define S_IXGRP (1<<21)
#define S_IRWXG (S_IRGRP|S_IWGRP|S_IXGRP)
#define S_IROTH (1<<22)
#define S_IWOTH (1<<23)
#define S_IXOTH (1<<24)
#define S_IRWXO (S_IROTH|S_IWOTH|S_IXOTH)
#define S_ISUID (1<<25)
#define S_ISGID (1<<26)
#if defined(MSVC)
/* for time_t */
#include <time.h>
......@@ -333,22 +288,6 @@ typedef long time_t;
#include <sys/types.h>
#endif
struct stat {
mode_t st_mode; /* File mode */
ino_t st_ino; /* File serial number */
dev_t st_dev; /* ID of device containing file */
nlink_t st_nlink; /* Number of hard links */
uid_t st_uid; /* User ID of the file owner */
gid_t st_gid; /* Group ID of the file's group */
off_t st_size; /* File size (regular files only) */
time_t st_atime; /* Last access time */
time_t st_mtime; /* Last data modification time */
time_t st_ctime; /* Last file status change time */
};
//fcntl.h
#define O_NONBLOCK (1<<9) /* No delay */
#endif /* CYGONCE_ISO_SYS_TYPES_H multiple inclusion protection */
/* EOF sys/types.h */
......
components/dfs/filesystems/jffs2/kernel/linux/fs.h
浏览文件 @ 8e430738
......@@ -2,12 +2,5 @@
#define __LINUX_FS_H__
#include <linux/stat.h>
/*
* File types
*/
#define DT_UNKNOWN 0
#define DT_DIR 4
#define DT_REG 8
#endif /* __LINUX_FS_H__ */
components/dfs/filesystems/jffs2/kernel/linux/types.h
浏览文件 @ 8e430738
......@@ -3,17 +3,7 @@
#include "cyg/infra/cyg_type.h"
#define uint8_t cyg_uint8
#define uint16_t cyg_uint16
#define uint32_t cyg_uint32
#define int8_t cyg_int8
#define int16_t cyg_int16
#define int32_t cyg_int32
#define loff_t off_t
#define kvec iovec
#endif /* __LINUX_TYPES_H__ */
components/dfs/filesystems/jffs2/src/flashio.c
浏览文件 @ 8e430738
......@@ -16,7 +16,7 @@
#include "nodelist.h"
#include <rtdevice.h>
int jffs2_flash_read(struct jffs2_sb_info * c, uint32_t offset,
int jffs2_flash_read(struct jffs2_sb_info * c, cyg_uint32 offset,
const size_t size,
size_t * return_size,
unsigned char *buffer)
......@@ -33,7 +33,7 @@ int jffs2_flash_read(struct jffs2_sb_info * c, uint32_t offset,
}
int jffs2_flash_write(struct jffs2_sb_info * c,
uint32_t offset, const size_t size,
cyg_uint32 offset, const size_t size,
size_t * return_size, unsigned char *buffer)
{
uint32_t len;
......
components/dfs/filesystems/jffs2/src/readinode.c
浏览文件 @ 8e430738
......@@ -188,7 +188,7 @@ read_direntry(struct jffs2_sb_info *c,
int already = read - sizeof(*rd);
err = jffs2_flash_read(c, (ref_offset(ref)) + read,
rd->nsize - already, &read, &fd->name[already]);
rd->nsize - already, (size_t*)&read, &fd->name[already]);
if (unlikely(read != rd->nsize - already) && likely(!err))
return -EIO;
......@@ -278,7 +278,7 @@ read_dnode(struct jffs2_sb_info *c,
return -ENOMEM;
err = jffs2_flash_read(c, ref_offset(ref) + sizeof(*rd), je32_to_cpu(rd->csize),
&read, buf);
(size_t*)&read, buf);
if (unlikely(read != je32_to_cpu(rd->csize)) && likely(!err))
err = -EIO;
if (err) {
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或