From 773990abdb90078839ea0834fc15539e94a04fdf Mon Sep 17 00:00:00 2001 From: "yiyue.fang" Date: Wed, 26 Jun 2013 22:30:40 +0800 Subject: [PATCH] Embedded GPLv2 license in dfs --- components/dfs/filesystems/devfs/console.c | 21 +- components/dfs/filesystems/devfs/devfs.c | 443 ++-- components/dfs/filesystems/devfs/devfs.h | 23 + components/dfs/filesystems/elmfat/dfs_elm.c | 16 +- components/dfs/filesystems/nfs/dfs_nfs.c | 1962 +++++++++-------- components/dfs/filesystems/nfs/dfs_nfs.h | 16 +- components/dfs/filesystems/ramfs/dfs_ramfs.c | 74 +- components/dfs/filesystems/ramfs/dfs_ramfs.h | 18 +- components/dfs/filesystems/romfs/dfs_romfs.c | 16 +- components/dfs/filesystems/romfs/dfs_romfs.h | 16 +- components/dfs/filesystems/romfs/romfs.c | 52 +- .../dfs/filesystems/skeleton/skeleton.c | 78 +- .../dfs/filesystems/skeleton/skeleton.h | 23 + components/dfs/filesystems/uffs/dfs_uffs.c | 25 +- components/dfs/filesystems/uffs/dfs_uffs.h | 23 +- components/dfs/filesystems/uffs/uffs_nandif.c | 482 ++-- components/dfs/include/dfs.h | 16 +- components/dfs/include/dfs_def.h | 16 +- components/dfs/include/dfs_elm.h | 16 +- components/dfs/include/dfs_file.h | 16 +- components/dfs/include/dfs_fs.h | 16 +- components/dfs/include/dfs_init.h | 16 +- components/dfs/include/dfs_posix.h | 16 +- components/dfs/src/dfs.c | 16 +- components/dfs/src/dfs_file.c | 16 +- components/dfs/src/dfs_fs.c | 16 +- components/dfs/src/dfs_posix.c | 16 +- 27 files changed, 1935 insertions(+), 1529 deletions(-) diff --git a/components/dfs/filesystems/devfs/console.c b/components/dfs/filesystems/devfs/console.c index 82f1c94f2..0cac53a1c 100644 --- a/components/dfs/filesystems/devfs/console.c +++ b/components/dfs/filesystems/devfs/console.c @@ -1,7 +1,26 @@ /* - * RT-Thread Console Device File + * File : console.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team * + * 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 */ + #include struct console_device diff --git a/components/dfs/filesystems/devfs/devfs.c b/components/dfs/filesystems/devfs/devfs.c index 4d23f78bb..969c5d332 100644 --- a/components/dfs/filesystems/devfs/devfs.c +++ b/components/dfs/filesystems/devfs/devfs.c @@ -1,3 +1,26 @@ +/* + * File : devfs.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * 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 + */ + #include #include #include @@ -6,276 +29,276 @@ struct device_dirent { - rt_device_t *devices; - rt_uint16_t read_index; - rt_uint16_t device_count; + rt_device_t *devices; + rt_uint16_t read_index; + rt_uint16_t device_count; }; int dfs_device_fs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data) { - return DFS_STATUS_OK; + return DFS_STATUS_OK; } int dfs_device_fs_ioctl(struct dfs_fd *file, int cmd, void *args) { - rt_err_t result; - rt_device_t dev_id; + rt_err_t result; + rt_device_t dev_id; - RT_ASSERT(file != RT_NULL); + RT_ASSERT(file != RT_NULL); - /* get device handler */ - dev_id = (rt_device_t)file->data; - RT_ASSERT(dev_id != RT_NULL); + /* get device handler */ + dev_id = (rt_device_t)file->data; + RT_ASSERT(dev_id != RT_NULL); - /* close device handler */ - result = rt_device_control(dev_id, cmd, args); - if (result == RT_EOK) - return DFS_STATUS_OK; + /* close device handler */ + result = rt_device_control(dev_id, cmd, args); + if (result == RT_EOK) + return DFS_STATUS_OK; - return -DFS_STATUS_EIO; + return -DFS_STATUS_EIO; } int dfs_device_fs_read(struct dfs_fd *file, void *buf, rt_size_t count) { - int result; - rt_device_t dev_id; + int result; + rt_device_t dev_id; - RT_ASSERT(file != RT_NULL); + RT_ASSERT(file != RT_NULL); - /* get device handler */ - dev_id = (rt_device_t)file->data; - RT_ASSERT(dev_id != RT_NULL); + /* get device handler */ + dev_id = (rt_device_t)file->data; + RT_ASSERT(dev_id != RT_NULL); - /* read device data */ - result = rt_device_read(dev_id, file->pos, buf, count); - file->pos += result; + /* read device data */ + result = rt_device_read(dev_id, file->pos, buf, count); + file->pos += result; - return result; + return result; } int dfs_device_fs_write(struct dfs_fd *file, const void *buf, rt_size_t count) { - int result; - rt_device_t dev_id; + int result; + rt_device_t dev_id; - RT_ASSERT(file != RT_NULL); + RT_ASSERT(file != RT_NULL); - /* get device handler */ - dev_id = (rt_device_t)file->data; - RT_ASSERT(dev_id != RT_NULL); + /* get device handler */ + dev_id = (rt_device_t)file->data; + RT_ASSERT(dev_id != RT_NULL); - /* read device data */ - result = rt_device_write(dev_id, file->pos, buf, count); - file->pos += result; + /* read device data */ + result = rt_device_write(dev_id, file->pos, buf, count); + file->pos += result; - return result; + return result; } int dfs_device_fs_close(struct dfs_fd *file) { - rt_err_t result; - rt_device_t dev_id; + rt_err_t result; + rt_device_t dev_id; - RT_ASSERT(file != RT_NULL); + RT_ASSERT(file != RT_NULL); - if (file->type == FT_DIRECTORY) - { - struct device_dirent *root_dirent; + if (file->type == FT_DIRECTORY) + { + struct device_dirent *root_dirent; - root_dirent = (struct device_dirent *)file->data; - RT_ASSERT(root_dirent != RT_NULL); - - /* release dirent */ - rt_free(root_dirent); - return DFS_STATUS_OK; - } + root_dirent = (struct device_dirent *)file->data; + RT_ASSERT(root_dirent != RT_NULL); + + /* release dirent */ + rt_free(root_dirent); + return DFS_STATUS_OK; + } - /* get device handler */ - dev_id = (rt_device_t)file->data; - RT_ASSERT(dev_id != RT_NULL); + /* get device handler */ + dev_id = (rt_device_t)file->data; + RT_ASSERT(dev_id != RT_NULL); - /* close device handler */ - result = rt_device_close(dev_id); - if (result == RT_EOK) - { - file->data = RT_NULL; + /* close device handler */ + result = rt_device_close(dev_id); + if (result == RT_EOK) + { + file->data = RT_NULL; - return DFS_STATUS_OK; - } + return DFS_STATUS_OK; + } - return -DFS_STATUS_EIO; + return -DFS_STATUS_EIO; } int dfs_device_fs_open(struct dfs_fd *file) { - rt_device_t device; - - if (file->flags & DFS_O_CREAT) - return -DFS_STATUS_EINVAL; - - /* open root directory */ - if ((file->path[0] == '/') && (file->path[1] == '\0') && - (file->flags & DFS_O_DIRECTORY)) - { - struct rt_object *object; - struct rt_list_node *node; - struct rt_object_information *information; - struct device_dirent *root_dirent; - rt_uint32_t count = 0; - - extern struct rt_object_information rt_object_container[]; - - /* lock scheduler */ - rt_enter_critical(); - - /* traverse device object */ - information = &rt_object_container[RT_Object_Class_Device]; - for (node = information->object_list.next; node != &(information->object_list); node = node->next) - { - count ++; - } - - root_dirent = (struct device_dirent *)rt_malloc(sizeof(struct device_dirent) + - count * sizeof(rt_device_t)); - if (root_dirent != RT_NULL) - { - root_dirent->devices = (rt_device_t *)(root_dirent + 1); - root_dirent->read_index = 0; - root_dirent->device_count = count; - count = 0; - /* get all device node */ - for (node = information->object_list.next; node != &(information->object_list); node = node->next) - { - object = rt_list_entry(node, struct rt_object, list); - root_dirent->devices[count] = (rt_device_t)object; - count ++; - } - } - rt_exit_critical(); - - /* set data */ - file->data = root_dirent; - - return DFS_STATUS_OK; - } - - device = rt_device_find(&file->path[1]); - if (device == RT_NULL) - return -DFS_STATUS_ENODEV; - - file->data = device; - - return DFS_STATUS_OK; + rt_device_t device; + + if (file->flags & DFS_O_CREAT) + return -DFS_STATUS_EINVAL; + + /* open root directory */ + if ((file->path[0] == '/') && (file->path[1] == '\0') && + (file->flags & DFS_O_DIRECTORY)) + { + struct rt_object *object; + struct rt_list_node *node; + struct rt_object_information *information; + struct device_dirent *root_dirent; + rt_uint32_t count = 0; + + extern struct rt_object_information rt_object_container[]; + + /* lock scheduler */ + rt_enter_critical(); + + /* traverse device object */ + information = &rt_object_container[RT_Object_Class_Device]; + for (node = information->object_list.next; node != &(information->object_list); node = node->next) + { + count ++; + } + + root_dirent = (struct device_dirent *)rt_malloc(sizeof(struct device_dirent) + + count * sizeof(rt_device_t)); + if (root_dirent != RT_NULL) + { + root_dirent->devices = (rt_device_t *)(root_dirent + 1); + root_dirent->read_index = 0; + root_dirent->device_count = count; + count = 0; + /* get all device node */ + for (node = information->object_list.next; node != &(information->object_list); node = node->next) + { + object = rt_list_entry(node, struct rt_object, list); + root_dirent->devices[count] = (rt_device_t)object; + count ++; + } + } + rt_exit_critical(); + + /* set data */ + file->data = root_dirent; + + return DFS_STATUS_OK; + } + + device = rt_device_find(&file->path[1]); + if (device == RT_NULL) + return -DFS_STATUS_ENODEV; + + file->data = device; + + return DFS_STATUS_OK; } int dfs_device_fs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st) { - /* stat root directory */ - if ((path[0] == '/') && (path[1] == '\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; - st->st_mode &= ~DFS_S_IFREG; - st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH; - - st->st_size = 0; - st->st_mtime = 0; - st->st_blksize = 512; - - return DFS_STATUS_OK; - } - else - { - rt_device_t dev_id; - - dev_id = rt_device_find(&path[1]); - if (dev_id != RT_NULL) - { - st->st_dev = 0; - - st->st_mode = DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | - DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH; - - if (dev_id->type == RT_Device_Class_Char) - st->st_mode |= DFS_S_IFCHR; - else if (dev_id->type == RT_Device_Class_Block) - st->st_mode |= DFS_S_IFBLK; - else - st->st_mode |= DFS_S_IFREG; - - st->st_size = 0; - st->st_mtime = 0; - st->st_blksize = 512; - - return DFS_STATUS_OK; - } - } - - return -DFS_STATUS_ENOENT; + /* stat root directory */ + if ((path[0] == '/') && (path[1] == '\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; + st->st_mode &= ~DFS_S_IFREG; + st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH; + + st->st_size = 0; + st->st_mtime = 0; + st->st_blksize = 512; + + return DFS_STATUS_OK; + } + else + { + rt_device_t dev_id; + + dev_id = rt_device_find(&path[1]); + if (dev_id != RT_NULL) + { + st->st_dev = 0; + + st->st_mode = DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH | + DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH; + + if (dev_id->type == RT_Device_Class_Char) + st->st_mode |= DFS_S_IFCHR; + else if (dev_id->type == RT_Device_Class_Block) + st->st_mode |= DFS_S_IFBLK; + else + st->st_mode |= DFS_S_IFREG; + + st->st_size = 0; + st->st_mtime = 0; + st->st_blksize = 512; + + return DFS_STATUS_OK; + } + } + + return -DFS_STATUS_ENOENT; } int dfs_device_fs_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count) { - rt_uint32_t index; - rt_object_t object; - struct dirent *d; - struct device_dirent *root_dirent; - - root_dirent = (struct device_dirent *)file->data; - RT_ASSERT(root_dirent != RT_NULL); - - /* make integer count */ - count = (count / sizeof(struct dirent)); - if (count == 0) - return -DFS_STATUS_EINVAL; - - for (index = 0; index < count && index + root_dirent->read_index < root_dirent->device_count; - index ++) - { - object = (rt_object_t)root_dirent->devices[root_dirent->read_index + index]; - - d = dirp + index; - d->d_type = DFS_DT_REG; - d->d_namlen = RT_NAME_MAX; - d->d_reclen = (rt_uint16_t)sizeof(struct dirent); - rt_strncpy(d->d_name, object->name, RT_NAME_MAX); - } - - root_dirent->read_index += index; - - return index * sizeof(struct dirent); + rt_uint32_t index; + rt_object_t object; + struct dirent *d; + struct device_dirent *root_dirent; + + root_dirent = (struct device_dirent *)file->data; + RT_ASSERT(root_dirent != RT_NULL); + + /* make integer count */ + count = (count / sizeof(struct dirent)); + if (count == 0) + return -DFS_STATUS_EINVAL; + + for (index = 0; index < count && index + root_dirent->read_index < root_dirent->device_count; + index ++) + { + object = (rt_object_t)root_dirent->devices[root_dirent->read_index + index]; + + d = dirp + index; + d->d_type = DFS_DT_REG; + d->d_namlen = RT_NAME_MAX; + d->d_reclen = (rt_uint16_t)sizeof(struct dirent); + rt_strncpy(d->d_name, object->name, RT_NAME_MAX); + } + + root_dirent->read_index += index; + + return index * sizeof(struct dirent); } static const struct dfs_filesystem_operation _device_fs = { - "devfs", - DFS_FS_FLAG_DEFAULT, - dfs_device_fs_mount, - RT_NULL, - RT_NULL, - RT_NULL, - - dfs_device_fs_open, - dfs_device_fs_close, - dfs_device_fs_ioctl, - dfs_device_fs_read, - dfs_device_fs_write, - RT_NULL, - RT_NULL, - dfs_device_fs_getdents, - RT_NULL, - dfs_device_fs_stat, - RT_NULL, + "devfs", + DFS_FS_FLAG_DEFAULT, + dfs_device_fs_mount, + RT_NULL, + RT_NULL, + RT_NULL, + + dfs_device_fs_open, + dfs_device_fs_close, + dfs_device_fs_ioctl, + dfs_device_fs_read, + dfs_device_fs_write, + RT_NULL, + RT_NULL, + dfs_device_fs_getdents, + RT_NULL, + dfs_device_fs_stat, + RT_NULL, }; int devfs_init(void) { - /* register rom file system */ - dfs_register(&_device_fs); + /* register rom file system */ + dfs_register(&_device_fs); - return 0; + return 0; } INIT_FS_EXPORT(devfs_init); diff --git a/components/dfs/filesystems/devfs/devfs.h b/components/dfs/filesystems/devfs/devfs.h index 248aab91d..ef320b78c 100644 --- a/components/dfs/filesystems/devfs/devfs.h +++ b/components/dfs/filesystems/devfs/devfs.h @@ -1,3 +1,26 @@ +/* + * File : devfs.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * 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 + */ + #ifndef __DEVICE_FS_H__ #define __DEVICE_FS_H__ diff --git a/components/dfs/filesystems/elmfat/dfs_elm.c b/components/dfs/filesystems/elmfat/dfs_elm.c index 1a0eeb731..413750498 100644 --- a/components/dfs/filesystems/elmfat/dfs_elm.c +++ b/components/dfs/filesystems/elmfat/dfs_elm.c @@ -3,9 +3,19 @@ * 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. + * 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 diff --git a/components/dfs/filesystems/nfs/dfs_nfs.c b/components/dfs/filesystems/nfs/dfs_nfs.c index 7e8ceeb99..3709cc33f 100644 --- a/components/dfs/filesystems/nfs/dfs_nfs.c +++ b/components/dfs/filesystems/nfs/dfs_nfs.c @@ -3,9 +3,19 @@ * 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. + * 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 @@ -21,7 +31,7 @@ #include "mount.h" #include "nfs.h" -#define NAME_MAX 64 +#define NAME_MAX 64 #define DFS_NFS_MAX_MTU 1024 #ifdef _WIN32 @@ -30,1080 +40,1106 @@ struct nfs_file { - nfs_fh3 handle; /* handle */ - size_t offset; /* current offset */ + nfs_fh3 handle; /* handle */ + size_t offset; /* current offset */ - size_t size; /* total size */ - bool_t eof; /* end of file */ + size_t size; /* total size */ + bool_t eof; /* end of file */ }; struct nfs_dir { - nfs_fh3 handle; - cookie3 cookie; - cookieverf3 cookieverf; - entry3 *entry; - bool_t eof; - READDIR3res res; + nfs_fh3 handle; + cookie3 cookie; + cookieverf3 cookieverf; + entry3 *entry; + bool_t eof; + READDIR3res res; }; -#define HOST_LENGTH 32 -#define EXPORT_PATH_LENGTH 32 +#define HOST_LENGTH 32 +#define EXPORT_PATH_LENGTH 32 struct nfs_filesystem { - nfs_fh3 root_handle; - nfs_fh3 current_handle; - CLIENT *nfs_client; - CLIENT *mount_client; + nfs_fh3 root_handle; + nfs_fh3 current_handle; + CLIENT *nfs_client; + CLIENT *mount_client; - char host[HOST_LENGTH]; - char export[EXPORT_PATH_LENGTH]; + char host[HOST_LENGTH]; + char export[EXPORT_PATH_LENGTH]; }; typedef struct nfs_file nfs_file; typedef struct nfs_dir nfs_dir; 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) + 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; - - /* copy to host buffer */ - if (host_export[index] != ':') - host[index] = host_export[index]; - else - break; - } - - /* host buffer is not enough, failed */ - if (index == host_len) - return -1; - - /* make RT_NULL */ - host_len = index; - host[host_len] = '\0'; - - host_len ++; - - /* copy export path */ - for (index = host_len; index < host_len + export_len; index ++) - { - if (host_export[index] == 0) - { - export[index - host_len] = '\0'; - return 0; - } - - export[index - host_len] = host_export[index]; - } - - return -1; + int index; + + for (index = 0; index < host_len; index ++) + { + /* it's end of string, failed */ + if (host_export[index] == 0) + return -1; + + /* copy to host buffer */ + if (host_export[index] != ':') + host[index] = host_export[index]; + else + break; + } + + /* host buffer is not enough, failed */ + if (index == host_len) + return -1; + + /* make RT_NULL */ + host_len = index; + host[host_len] = '\0'; + + host_len ++; + + /* copy export path */ + for (index = host_len; index < host_len + export_len; index ++) + { + if (host_export[index] == 0) + { + export[index - host_len] = '\0'; + + return 0; + } + + export[index - host_len] = host_export[index]; + } + + return -1; } 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) - { - dest->data.data_len = 0; - return; - } - - memcpy(dest->data.data_val, source->data.data_val, dest->data.data_len); + 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) + { + 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) { - nfs_fh3 *handle = RT_NULL; - char *file; - char *path; - char *init; - - init = path = rt_malloc(strlen(name)+1); - if (init == RT_NULL) - return RT_NULL; - - memcpy(init, name, strlen(name)+1); - - handle = rt_malloc(sizeof(nfs_fh3)); - if (handle == RT_NULL) - { - rt_free(init); - return RT_NULL; - } - - if (path[0] == '/') - { - path ++; - copy_handle(handle, &nfs->root_handle); - } - else - { - copy_handle(handle, &nfs->current_handle); - } - - 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; - - if (nfsproc3_lookup_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) - { - rt_kprintf("Lookup failed\n"); - rt_free(init); - rt_free(handle); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); - return RT_NULL; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Lookup failed: %d\n", res.status); - rt_free(init); - rt_free(handle); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); - xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res); - return RT_NULL; - } - copy_handle(handle, &res.LOOKUP3res_u.resok.object); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); - xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res); - } - - rt_free(init); - return handle; + nfs_fh3 *handle = RT_NULL; + char *file; + char *path; + char *init; + + init = path = rt_malloc(strlen(name)+1); + if (init == RT_NULL) + return RT_NULL; + + memcpy(init, name, strlen(name)+1); + + handle = rt_malloc(sizeof(nfs_fh3)); + if (handle == RT_NULL) + { + rt_free(init); + + return RT_NULL; + } + + if (path[0] == '/') + { + path ++; + copy_handle(handle, &nfs->root_handle); + } + else + { + copy_handle(handle, &nfs->current_handle); + } + + 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; + + if (nfsproc3_lookup_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + { + rt_kprintf("Lookup failed\n"); + rt_free(init); + rt_free(handle); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); + + return RT_NULL; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Lookup failed: %d\n", res.status); + rt_free(init); + rt_free(handle); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); + xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res); + + return RT_NULL; + } + copy_handle(handle, &res.LOOKUP3res_u.resok.object); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); + xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res); + } + + rt_free(init); + + return handle; } static nfs_fh3 *get_dir_handle(struct nfs_filesystem *nfs, const char *name) { - nfs_fh3 *handle = RT_NULL; - char *file; - char *path; - char *init; - - init = path = rt_malloc(strlen(name)+1); - if (init == RT_NULL) - return RT_NULL; - memcpy(init, name, strlen(name)+1); - - handle = rt_malloc(sizeof(nfs_fh3)); - if (handle == RT_NULL) - { - rt_free(init); - return RT_NULL; - } - - if (path[0] == '/') - { - path ++; - copy_handle(handle, &nfs->root_handle); - } - else - { - copy_handle(handle, &nfs->current_handle); - } - - while ((file = strtok_r(RT_NULL, "/", &path)) != 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; - - if (nfsproc3_lookup_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) - { - rt_kprintf("Lookup failed\n"); - rt_free(init); - rt_free(handle); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); - return RT_NULL; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Lookup failed: %d\n", res.status); - rt_free(init); - rt_free(handle); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); - xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res); - return RT_NULL; - } - copy_handle(handle, &res.LOOKUP3res_u.resok.object); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); - xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res); - } - - rt_free(init); - return handle; + nfs_fh3 *handle = RT_NULL; + char *file; + char *path; + char *init; + + init = path = rt_malloc(strlen(name)+1); + if (init == RT_NULL) + return RT_NULL; + memcpy(init, name, strlen(name)+1); + + handle = rt_malloc(sizeof(nfs_fh3)); + if (handle == RT_NULL) + { + rt_free(init); + + return RT_NULL; + } + + if (path[0] == '/') + { + path ++; + copy_handle(handle, &nfs->root_handle); + } + else + { + copy_handle(handle, &nfs->current_handle); + } + + while ((file = strtok_r(RT_NULL, "/", &path)) != 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; + + if (nfsproc3_lookup_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + { + rt_kprintf("Lookup failed\n"); + rt_free(init); + rt_free(handle); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); + + return RT_NULL; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Lookup failed: %d\n", res.status); + rt_free(init); + rt_free(handle); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); + xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res); + + return RT_NULL; + } + copy_handle(handle, &res.LOOKUP3res_u.resok.object); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&args.what.dir); + xdr_free((xdrproc_t)xdr_LOOKUP3res, (char *)&res); + } + + rt_free(init); + + return handle; } static size_t nfs_get_filesize(struct nfs_filesystem *nfs, nfs_fh3 *handle) { - GETATTR3args args; - GETATTR3res res; - fattr3 *info; - size_t size; - - args.object = *handle; - - memset(&res, '\0', sizeof(res)); - - if ((nfsproc3_getattr_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) || - res.status != NFS3_OK) - { - rt_kprintf("GetAttr failed: %d\n", res.status); - return 0; - } - - info = &res.GETATTR3res_u.resok.obj_attributes; - size = info->size; - xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res); - - return size; + GETATTR3args args; + GETATTR3res res; + fattr3 *info; + size_t size; + + args.object = *handle; + + memset(&res, '\0', sizeof(res)); + + if ((nfsproc3_getattr_3(args, &res, nfs->nfs_client)!=RPC_SUCCESS) || + res.status != NFS3_OK) + { + rt_kprintf("GetAttr failed: %d\n", res.status); + + return 0; + } + + 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) { - GETATTR3args args; - GETATTR3res res; - fattr3 *info; - nfs_fh3 *handle; - rt_bool_t result; - - result = RT_FALSE; - handle = get_handle(nfs, name); - 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) - { - rt_kprintf("GetAttr failed\n"); - return RT_FALSE; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Getattr failed: %d\n", res.status); - return RT_FALSE; - } - - info=&res.GETATTR3res_u.resok.obj_attributes; - - if (info->type == NFS3DIR) - result = RT_TRUE; - - xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - rt_free(handle); - - return result; + GETATTR3args args; + GETATTR3res res; + fattr3 *info; + nfs_fh3 *handle; + rt_bool_t result; + + result = RT_FALSE; + handle = get_handle(nfs, name); + 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) + { + rt_kprintf("GetAttr failed\n"); + + return RT_FALSE; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Getattr failed: %d\n", res.status); + + return RT_FALSE; + } + + info=&res.GETATTR3res_u.resok.obj_attributes; + + if (info->type == NFS3DIR) + result = RT_TRUE; + + xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); + rt_free(handle); + + return result; } int nfs_create(struct nfs_filesystem *nfs, const char *name, mode_t mode) { - CREATE3args args; - CREATE3res res; - int ret = 0; - nfs_fh3 *handle; - - if (nfs->nfs_client == RT_NULL) - { - return -1; - } - - 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.name = (char *)name; - } - 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; - - memset(&res, 0, sizeof(res)); - - if (nfsproc3_create_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) - { - rt_kprintf("Create failed\n"); - ret = -1; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Create failed: %d\n", res.status); - ret = -1; - } - xdr_free((xdrproc_t)xdr_CREATE3res, (char *)&res); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - rt_free(handle); - - return ret; + CREATE3args args; + CREATE3res res; + int ret = 0; + nfs_fh3 *handle; + + if (nfs->nfs_client == RT_NULL) + { + return -1; + } + + 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.name = (char *)name; + } + 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; + + memset(&res, 0, sizeof(res)); + + if (nfsproc3_create_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + { + rt_kprintf("Create failed\n"); + ret = -1; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Create failed: %d\n", res.status); + ret = -1; + } + xdr_free((xdrproc_t)xdr_CREATE3res, (char *)&res); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); + rt_free(handle); + + return ret; } int nfs_mkdir(struct nfs_filesystem *nfs, const char *name, mode_t mode) { - MKDIR3args args; - MKDIR3res res; - int ret = 0; - nfs_fh3 *handle; - - if (nfs->nfs_client == RT_NULL) - return -1; - - 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.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; - - memset(&res, 0, sizeof(res)); - - if (nfsproc3_mkdir_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) - { - rt_kprintf("Mkdir failed\n"); - ret = -1; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Mkdir failed: %d\n", res.status); - ret = -1; - } - xdr_free((xdrproc_t)xdr_MKDIR3res, (char *)&res); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - rt_free(handle); - - return ret; + MKDIR3args args; + MKDIR3res res; + int ret = 0; + nfs_fh3 *handle; + + if (nfs->nfs_client == RT_NULL) + return -1; + + 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.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; + + memset(&res, 0, sizeof(res)); + + if (nfsproc3_mkdir_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + { + rt_kprintf("Mkdir failed\n"); + ret = -1; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Mkdir failed: %d\n", res.status); + ret = -1; + } + xdr_free((xdrproc_t)xdr_MKDIR3res, (char *)&res); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); + rt_free(handle); + + return ret; } /* mount(RT_NULL, "/mnt", "nfs", 0, "192.168.1.1:/export") */ int nfs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data) { - mountres3 res; - struct nfs_filesystem *nfs; - - 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, - nfs->export, EXPORT_PATH_LENGTH) < 0) - { - rt_kprintf("host or export path error\n"); - goto __return; - } - - nfs->mount_client=clnt_create((char *)nfs->host, MOUNT_PROGRAM, MOUNT_V3, "udp"); - 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) - { - rt_kprintf("nfs mount failed\n"); - goto __return; - } - 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) - { - rt_kprintf("creat nfs client failed\n"); - goto __return; - } - 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(); - fs->data = nfs; - - return 0; + mountres3 res; + struct nfs_filesystem *nfs; + + 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, + nfs->export, EXPORT_PATH_LENGTH) < 0) + { + rt_kprintf("host or export path error\n"); + goto __return; + } + + nfs->mount_client=clnt_create((char *)nfs->host, MOUNT_PROGRAM, MOUNT_V3, "udp"); + 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) + { + rt_kprintf("nfs mount failed\n"); + goto __return; + } + 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) + { + rt_kprintf("creat nfs client failed\n"); + goto __return; + } + 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(); + fs->data = nfs; + + return 0; __return: - if (nfs != RT_NULL) - { - if (nfs->mount_client != RT_NULL) - { - clnt_destroy(nfs->mount_client); - } - if (nfs->nfs_client != RT_NULL) - { - if (nfs->nfs_client->cl_auth != RT_NULL) - { - auth_destroy(nfs->nfs_client->cl_auth); - } - clnt_destroy(nfs->nfs_client); - } - rt_free(nfs); - } - - return -1; + if (nfs != RT_NULL) + { + if (nfs->mount_client != RT_NULL) + { + clnt_destroy(nfs->mount_client); + } + if (nfs->nfs_client != RT_NULL) + { + if (nfs->nfs_client->cl_auth != RT_NULL) + { + auth_destroy(nfs->nfs_client->cl_auth); + } + clnt_destroy(nfs->nfs_client); + } + rt_free(nfs); + } + + return -1; } int nfs_unmount(struct dfs_filesystem *fs) { - struct nfs_filesystem *nfs; - - RT_ASSERT(fs != RT_NULL); - RT_ASSERT(fs->data != RT_NULL); - nfs = (struct nfs_filesystem *)fs->data; - - if (nfs->mount_client != RT_NULL && - mountproc3_umnt_3((char *)nfs->export, RT_NULL, nfs->mount_client) != RPC_SUCCESS) - { - rt_kprintf("umount failed\n"); - return -1; - } - - /* destroy nfs client */ - if (nfs->nfs_client != RT_NULL) - { - if (nfs->nfs_client->cl_auth != RT_NULL) - { - auth_destroy(nfs->nfs_client->cl_auth); - nfs->nfs_client->cl_auth = RT_NULL; - } - clnt_destroy(nfs->nfs_client); - nfs->nfs_client = RT_NULL; - } - - /* destroy mount client */ - if (nfs->mount_client != 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; - } - - rt_free(nfs); - fs->data = RT_NULL; - - return 0; + struct nfs_filesystem *nfs; + + RT_ASSERT(fs != RT_NULL); + RT_ASSERT(fs->data != RT_NULL); + nfs = (struct nfs_filesystem *)fs->data; + + if (nfs->mount_client != RT_NULL && + mountproc3_umnt_3((char *)nfs->export, RT_NULL, nfs->mount_client) != RPC_SUCCESS) + { + rt_kprintf("umount failed\n"); + + return -1; + } + + /* destroy nfs client */ + if (nfs->nfs_client != RT_NULL) + { + if (nfs->nfs_client->cl_auth != RT_NULL) + { + auth_destroy(nfs->nfs_client->cl_auth); + nfs->nfs_client->cl_auth = RT_NULL; + } + clnt_destroy(nfs->nfs_client); + nfs->nfs_client = RT_NULL; + } + + /* destroy mount client */ + if (nfs->mount_client != 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; + } + + rt_free(nfs); + fs->data = RT_NULL; + + 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; + return -DFS_STATUS_ENOSYS; } int nfs_read(struct dfs_fd *file, void *buf, rt_size_t count) { - READ3args args; - READ3res res; - ssize_t bytes, total=0; - nfs_file *fd; - struct nfs_filesystem *nfs; - - if (file->type == FT_DIRECTORY) - return -DFS_STATUS_EISDIR; - - fd = (nfs_file *)(file->data); - RT_ASSERT(fd != RT_NULL); - RT_ASSERT(file->fs != RT_NULL); - RT_ASSERT(file->fs->data != RT_NULL); - nfs = (struct nfs_filesystem *)file->fs->data; - - if (nfs->nfs_client == RT_NULL) - return -1; - - /* end of file */ - if (fd->eof == TRUE) - return 0; - - args.file = fd->handle; - do { - args.offset = fd->offset; - args.count = count > DFS_NFS_MAX_MTU ? DFS_NFS_MAX_MTU : count; - count -= args.count; - - memset(&res, 0, sizeof(res)); - if (nfsproc3_read_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) - { - rt_kprintf("Read failed\n"); - total = 0; - break; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Read failed: %d\n", res.status); - total = 0; - break; - } - else - { - bytes = res.READ3res_u.resok.count; - total += bytes; - fd->offset += bytes; - /* update current position */ - file->pos = fd->offset; - memcpy(buf, res.READ3res_u.resok.data.data_val, bytes); - buf = (void *)((char *)buf + args.count); - if (res.READ3res_u.resok.eof) - { - /* something should probably be here */ - fd->eof = TRUE; - break; - } - } - xdr_free((xdrproc_t)xdr_READ3res, (char *)&res); - } while(count > 0); - - xdr_free((xdrproc_t)xdr_READ3res, (char *)&res); - return total; + READ3args args; + READ3res res; + ssize_t bytes, total=0; + nfs_file *fd; + struct nfs_filesystem *nfs; + + if (file->type == FT_DIRECTORY) + return -DFS_STATUS_EISDIR; + + fd = (nfs_file *)(file->data); + RT_ASSERT(fd != RT_NULL); + RT_ASSERT(file->fs != RT_NULL); + RT_ASSERT(file->fs->data != RT_NULL); + nfs = (struct nfs_filesystem *)file->fs->data; + + if (nfs->nfs_client == RT_NULL) + return -1; + + /* end of file */ + if (fd->eof == TRUE) + return 0; + + args.file = fd->handle; + do { + args.offset = fd->offset; + args.count = count > DFS_NFS_MAX_MTU ? DFS_NFS_MAX_MTU : count; + count -= args.count; + + memset(&res, 0, sizeof(res)); + if (nfsproc3_read_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + { + rt_kprintf("Read failed\n"); + total = 0; + break; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Read failed: %d\n", res.status); + total = 0; + break; + } + else + { + bytes = res.READ3res_u.resok.count; + total += bytes; + fd->offset += bytes; + /* update current position */ + file->pos = fd->offset; + memcpy(buf, res.READ3res_u.resok.data.data_val, bytes); + buf = (void *)((char *)buf + args.count); + if (res.READ3res_u.resok.eof) + { + /* something should probably be here */ + fd->eof = TRUE; + break; + } + } + xdr_free((xdrproc_t)xdr_READ3res, (char *)&res); + } while(count > 0); + + xdr_free((xdrproc_t)xdr_READ3res, (char *)&res); + + return total; } int nfs_write(struct dfs_fd *file, const void *buf, rt_size_t count) { - WRITE3args args; - WRITE3res res; - ssize_t bytes, total=0; - nfs_file *fd; - struct nfs_filesystem *nfs; - - if (file->type == FT_DIRECTORY) - return -DFS_STATUS_EISDIR; - - fd = (nfs_file *)(file->data); - RT_ASSERT(fd != RT_NULL); - RT_ASSERT(file->fs != RT_NULL); - RT_ASSERT(file->fs->data != RT_NULL); - nfs = (struct nfs_filesystem *)file->fs->data; - - if (nfs->nfs_client == RT_NULL) - return -1; - - args.file = fd->handle; - args.stable = FILE_SYNC; - - do { - args.offset = fd->offset; - - memset(&res, 0, sizeof(res)); - args.data.data_val=(void *)buf; - args.count = count > DFS_NFS_MAX_MTU ? DFS_NFS_MAX_MTU : count; - args.data.data_len = args.count; - count -= args.count; - buf = (const void *)((char *)buf + args.count); - - if (nfsproc3_write_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) - { - rt_kprintf("Write failed\n"); - total = 0; - break; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Write failed: %d\n", res.status); - total = 0; - break; - } - else - { - bytes = res.WRITE3res_u.resok.count; - fd->offset += bytes; - total += bytes; - /* update current position */ - file->pos = fd->offset; - /* todo: update file size */ - } - xdr_free((xdrproc_t)xdr_WRITE3res, (char *)&res); - } while (count > 0); - - xdr_free((xdrproc_t)xdr_WRITE3res, (char *)&res); - return total; + WRITE3args args; + WRITE3res res; + ssize_t bytes, total=0; + nfs_file *fd; + struct nfs_filesystem *nfs; + + if (file->type == FT_DIRECTORY) + return -DFS_STATUS_EISDIR; + + fd = (nfs_file *)(file->data); + RT_ASSERT(fd != RT_NULL); + RT_ASSERT(file->fs != RT_NULL); + RT_ASSERT(file->fs->data != RT_NULL); + nfs = (struct nfs_filesystem *)file->fs->data; + + if (nfs->nfs_client == RT_NULL) + return -1; + + args.file = fd->handle; + args.stable = FILE_SYNC; + + do { + args.offset = fd->offset; + + memset(&res, 0, sizeof(res)); + args.data.data_val=(void *)buf; + args.count = count > DFS_NFS_MAX_MTU ? DFS_NFS_MAX_MTU : count; + args.data.data_len = args.count; + count -= args.count; + buf = (const void *)((char *)buf + args.count); + + if (nfsproc3_write_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + { + rt_kprintf("Write failed\n"); + total = 0; + break; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Write failed: %d\n", res.status); + total = 0; + break; + } + else + { + bytes = res.WRITE3res_u.resok.count; + fd->offset += bytes; + total += bytes; + /* update current position */ + file->pos = fd->offset; + /* todo: update file size */ + } + xdr_free((xdrproc_t)xdr_WRITE3res, (char *)&res); + } while (count > 0); + + xdr_free((xdrproc_t)xdr_WRITE3res, (char *)&res); + + return total; } int nfs_lseek(struct dfs_fd *file, rt_off_t offset) { - nfs_file *fd; + nfs_file *fd; - if (file->type == FT_DIRECTORY) - return -DFS_STATUS_EISDIR; + if (file->type == FT_DIRECTORY) + return -DFS_STATUS_EISDIR; - fd = (nfs_file *)(file->data); - RT_ASSERT(fd != RT_NULL); + fd = (nfs_file *)(file->data); + RT_ASSERT(fd != RT_NULL); - if (offset <= fd->size) - { - fd->offset = offset; - return offset; - } + if (offset <= fd->size) + { + fd->offset = offset; - return -DFS_STATUS_EIO; + return offset; + } + + return -DFS_STATUS_EIO; } int nfs_close(struct dfs_fd *file) { - if (file->type == FT_DIRECTORY) - { - struct nfs_dir *dir; - - 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; - - fd = (struct nfs_file *)file->data; - - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&fd->handle); - rt_free(fd); - } - - file->data = RT_NULL; - return 0; + if (file->type == FT_DIRECTORY) + { + struct nfs_dir *dir; + + 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; + + fd = (struct nfs_file *)file->data; + + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)&fd->handle); + rt_free(fd); + } + + file->data = RT_NULL; + return 0; } int nfs_open(struct dfs_fd *file) { - struct nfs_filesystem *nfs; - - RT_ASSERT(file->fs != RT_NULL); - RT_ASSERT(file->fs->data != RT_NULL); - nfs = (struct nfs_filesystem *)file->fs->data; - - if (file->flags & DFS_O_DIRECTORY) - { - nfs_dir *dir; - - if (file->flags & DFS_O_CREAT) - { - if (nfs_mkdir(nfs, file->path, 0755) < 0) - return -1; - } - - /* open directory */ - dir = nfs_opendir(nfs, file->path); - file->data = dir; - } - else - { - nfs_file *fp; - nfs_fh3 *handle; - - /* create file */ - if (file->flags & DFS_O_CREAT) - { - if (nfs_create(nfs, file->path, 0664) < 0) return -1; - } - - /* open file (get file handle ) */ - fp = rt_malloc(sizeof(nfs_file)); - if (fp == RT_NULL) - return -1; - - handle = get_handle(nfs, file->path); - if (handle == RT_NULL) - { - rt_free(fp); - return -1; - } - - /* get size of file */ - fp->size = nfs_get_filesize(nfs, handle); - fp->offset = 0; - fp->eof = FALSE; - - copy_handle(&fp->handle, handle); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - rt_free(handle); - - if (file->flags & DFS_O_APPEND) - { - fp->offset = fp->size; - } - - /* set private file */ - file->data = fp; - } - - return 0; + struct nfs_filesystem *nfs; + + RT_ASSERT(file->fs != RT_NULL); + RT_ASSERT(file->fs->data != RT_NULL); + nfs = (struct nfs_filesystem *)file->fs->data; + + if (file->flags & DFS_O_DIRECTORY) + { + nfs_dir *dir; + + if (file->flags & DFS_O_CREAT) + { + if (nfs_mkdir(nfs, file->path, 0755) < 0) + return -1; + } + + /* open directory */ + dir = nfs_opendir(nfs, file->path); + file->data = dir; + } + else + { + nfs_file *fp; + nfs_fh3 *handle; + + /* create file */ + if (file->flags & DFS_O_CREAT) + { + if (nfs_create(nfs, file->path, 0664) < 0) + return -1; + } + + /* open file (get file handle ) */ + fp = rt_malloc(sizeof(nfs_file)); + if (fp == RT_NULL) + return -1; + + handle = get_handle(nfs, file->path); + if (handle == RT_NULL) + { + rt_free(fp); + + return -1; + } + + /* get size of file */ + fp->size = nfs_get_filesize(nfs, handle); + fp->offset = 0; + fp->eof = FALSE; + + copy_handle(&fp->handle, handle); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); + rt_free(handle); + + if (file->flags & DFS_O_APPEND) + { + fp->offset = fp->size; + } + + /* set private file */ + file->data = fp; + } + + return 0; } 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; - - 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) - return -1; - - args.object = *handle; - - memset(&res, '\0', sizeof(res)); - - if (nfsproc3_getattr_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) - { - rt_kprintf("GetAttr failed\n"); - return -1; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Getattr failed: %d\n", res.status); - return -1; - } - - info = &res.GETATTR3res_u.resok.obj_attributes; - - 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; - if (info->type == NFS3DIR) - { - st->st_mode &= ~DFS_S_IFREG; - st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH; - } - - st->st_size = info->size; - st->st_mtime = info->mtime.seconds; - st->st_blksize = 512; - - xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - rt_free(handle); - - return 0; + GETATTR3args args; + GETATTR3res res; + fattr3 *info; + nfs_fh3 *handle; + 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) + return -1; + + args.object = *handle; + + memset(&res, '\0', sizeof(res)); + + if (nfsproc3_getattr_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + { + rt_kprintf("GetAttr failed\n"); + return -1; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Getattr failed: %d\n", res.status); + return -1; + } + + info = &res.GETATTR3res_u.resok.obj_attributes; + + 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; + if (info->type == NFS3DIR) + { + st->st_mode &= ~DFS_S_IFREG; + st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH; + } + + st->st_size = info->size; + st->st_mtime = info->mtime.seconds; + st->st_blksize = 512; + + xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); + rt_free(handle); + + return 0; } 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) - { - return RT_NULL; - } - - handle = get_handle(nfs, path); - if (handle == RT_NULL) - { - rt_free(dir); - return RT_NULL; - } - - copy_handle(&dir->handle, handle); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - rt_free(handle); - - dir->cookie = 0; - memset(&dir->cookieverf, '\0', sizeof(cookieverf3)); - dir->entry = RT_NULL; - dir->eof = FALSE; - memset(&dir->res, '\0', sizeof(dir->res)); - - return dir; + nfs_dir *dir; + nfs_fh3 *handle; + + dir = rt_malloc(sizeof(nfs_dir)); + if (dir == RT_NULL) + { + return RT_NULL; + } + + handle = get_handle(nfs, path); + if (handle == RT_NULL) + { + rt_free(dir); + + return RT_NULL; + } + + copy_handle(&dir->handle, handle); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); + rt_free(handle); + + dir->cookie = 0; + memset(&dir->cookieverf, '\0', sizeof(cookieverf3)); + 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) { - static char name[NAME_MAX]; - - if (nfs->nfs_client == RT_NULL || dir == RT_NULL) - return 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; - memcpy(&args.cookieverf, &dir->cookieverf, sizeof(cookieverf3)); - args.count = 1024; - - 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) - { - 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; - } - if (dir->eof == TRUE && dir->entry == RT_NULL) - return RT_NULL; - - dir->cookie = dir->entry->cookie; - strncpy(name, dir->entry->name, NAME_MAX-1); - dir->entry = dir->entry->nextentry; - name[NAME_MAX - 1] = '\0'; - return name; + static char name[NAME_MAX]; + + if (nfs->nfs_client == RT_NULL || dir == RT_NULL) + return 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; + memcpy(&args.cookieverf, &dir->cookieverf, sizeof(cookieverf3)); + args.count = 1024; + + 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) + { + 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; + } + if (dir->eof == TRUE && dir->entry == RT_NULL) + return RT_NULL; + + dir->cookie = dir->entry->cookie; + strncpy(name, dir->entry->name, NAME_MAX-1); + dir->entry = dir->entry->nextentry; + name[NAME_MAX - 1] = '\0'; + + return name; } int nfs_unlink(struct dfs_filesystem *fs, const char *path) { - 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_is_directory(nfs, path) == RT_FALSE) - { - /* remove file */ - REMOVE3args args; - REMOVE3res res; - nfs_fh3 *handle; - - 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.name = (char *)path; - } - - memset(&res, 0, sizeof(res)); - - if (nfsproc3_remove_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) - { - rt_kprintf("Remove failed\n"); - ret = -1; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Remove failed: %d\n", res.status); - ret = -1; - } - xdr_free((xdrproc_t)xdr_REMOVE3res, (char *)&res); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - rt_free(handle); - } - else - { - /* remove directory */ - RMDIR3args args; - RMDIR3res res; - nfs_fh3 *handle; - - 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.name = (char *)path; - } - - memset(&res, 0, sizeof(res)); - - if (nfsproc3_rmdir_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) - { - rt_kprintf("Rmdir failed\n"); - ret = -1; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Rmdir failed: %d\n", res.status); - ret = -1; - } - - xdr_free((xdrproc_t)xdr_RMDIR3res, (char *)&res); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); - rt_free(handle); - } - - return ret; + 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_is_directory(nfs, path) == RT_FALSE) + { + /* remove file */ + REMOVE3args args; + REMOVE3res res; + nfs_fh3 *handle; + + 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.name = (char *)path; + } + + memset(&res, 0, sizeof(res)); + + if (nfsproc3_remove_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + { + rt_kprintf("Remove failed\n"); + ret = -1; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Remove failed: %d\n", res.status); + ret = -1; + } + xdr_free((xdrproc_t)xdr_REMOVE3res, (char *)&res); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); + rt_free(handle); + } + else + { + /* remove directory */ + RMDIR3args args; + RMDIR3res res; + nfs_fh3 *handle; + + 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.name = (char *)path; + } + + memset(&res, 0, sizeof(res)); + + if (nfsproc3_rmdir_3(args, &res, nfs->nfs_client) != RPC_SUCCESS) + { + rt_kprintf("Rmdir failed\n"); + ret = -1; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Rmdir failed: %d\n", res.status); + ret = -1; + } + + xdr_free((xdrproc_t)xdr_RMDIR3res, (char *)&res); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle); + rt_free(handle); + } + + return ret; } 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; - - RT_ASSERT(fs != RT_NULL); - RT_ASSERT(fs->data != RT_NULL); - nfs = (struct nfs_filesystem *)fs->data; - - if (nfs->nfs_client == RT_NULL) - return -1; - - sHandle = get_dir_handle(nfs, src); - if (sHandle == RT_NULL) - return -1; - - 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.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) - { - rt_kprintf("Rename failed\n"); - ret = -1; - } - else if (res.status != NFS3_OK) - { - rt_kprintf("Rename failed: %d\n", res.status); - ret = -1; - } - - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)sHandle); - xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)dHandle); - xdr_free((xdrproc_t)xdr_RENAME3res, (char *)&res); - return ret; + RENAME3args args; + RENAME3res res; + nfs_fh3 *sHandle; + nfs_fh3 *dHandle; + 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) + return -1; + + sHandle = get_dir_handle(nfs, src); + if (sHandle == RT_NULL) + return -1; + + 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.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) + { + rt_kprintf("Rename failed\n"); + ret = -1; + } + else if (res.status != NFS3_OK) + { + rt_kprintf("Rename failed: %d\n", res.status); + ret = -1; + } + + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)sHandle); + xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)dHandle); + xdr_free((xdrproc_t)xdr_RENAME3res, (char *)&res); + + return ret; } 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; - char *name; - - dir = (nfs_dir *)(file->data); - RT_ASSERT(dir != RT_NULL); - RT_ASSERT(file->fs != RT_NULL); - RT_ASSERT(file->fs->data != RT_NULL); - nfs = (struct nfs_filesystem *)file->fs->data; - - /* make integer count */ - count = (count / sizeof(struct dirent)) * sizeof(struct dirent); - if (count == 0) - return -DFS_STATUS_EINVAL; - - index = 0; - while (1) - { - char *fn; - - d = dirp + index; - - name = nfs_readdir(nfs, dir); - if (name == RT_NULL) - break; - - d->d_type = DFS_DT_REG; - - d->d_namlen = rt_strlen(name); - d->d_reclen = (rt_uint16_t)sizeof(struct dirent); - rt_strncpy(d->d_name, name, rt_strlen(name) + 1); - - index ++; - if (index * sizeof(struct dirent) >= count) - break; - } - - return index * sizeof(struct dirent); + nfs_dir *dir; + rt_uint32_t index; + struct dirent *d; + struct nfs_filesystem *nfs; + char *name; + + dir = (nfs_dir *)(file->data); + RT_ASSERT(dir != RT_NULL); + RT_ASSERT(file->fs != RT_NULL); + RT_ASSERT(file->fs->data != RT_NULL); + nfs = (struct nfs_filesystem *)file->fs->data; + + /* make integer count */ + count = (count / sizeof(struct dirent)) * sizeof(struct dirent); + if (count == 0) + return -DFS_STATUS_EINVAL; + + index = 0; + while (1) + { + char *fn; + + d = dirp + index; + + name = nfs_readdir(nfs, dir); + if (name == RT_NULL) + break; + + d->d_type = DFS_DT_REG; + + d->d_namlen = rt_strlen(name); + d->d_reclen = (rt_uint16_t)sizeof(struct dirent); + rt_strncpy(d->d_name, name, rt_strlen(name) + 1); + + index ++; + if (index * sizeof(struct dirent) >= count) + break; + } + + return index * sizeof(struct dirent); } static const struct dfs_filesystem_operation _nfs = { - "nfs", - DFS_FS_FLAG_DEFAULT, - nfs_mount, - nfs_unmount, - RT_NULL, /* mkfs */ - RT_NULL, /* statfs */ - nfs_open, - nfs_close, - nfs_ioctl, - nfs_read, - nfs_write, - RT_NULL, /* flush */ - nfs_lseek, - nfs_getdents, - nfs_unlink, - nfs_stat, - nfs_rename, + "nfs", + DFS_FS_FLAG_DEFAULT, + nfs_mount, + nfs_unmount, + RT_NULL, /* mkfs */ + RT_NULL, /* statfs */ + nfs_open, + nfs_close, + nfs_ioctl, + nfs_read, + nfs_write, + RT_NULL, /* flush */ + nfs_lseek, + nfs_getdents, + nfs_unlink, + nfs_stat, + nfs_rename, }; int nfs_init(void) { - /* register fatfs file system */ - dfs_register(&_nfs); + /* register fatfs file system */ + dfs_register(&_nfs); - return RT_EOK; + return RT_EOK; } INIT_FS_EXPORT(nfs_init); diff --git a/components/dfs/filesystems/nfs/dfs_nfs.h b/components/dfs/filesystems/nfs/dfs_nfs.h index d45af577d..adc36f82d 100644 --- a/components/dfs/filesystems/nfs/dfs_nfs.h +++ b/components/dfs/filesystems/nfs/dfs_nfs.h @@ -3,9 +3,19 @@ * 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. + * 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 diff --git a/components/dfs/filesystems/ramfs/dfs_ramfs.c b/components/dfs/filesystems/ramfs/dfs_ramfs.c index c6731ed89..65c662ae4 100644 --- a/components/dfs/filesystems/ramfs/dfs_ramfs.c +++ b/components/dfs/filesystems/ramfs/dfs_ramfs.c @@ -1,9 +1,21 @@ /* * File : dfs_ramfs.c - * This file is part of RT-Thread RTOS - * COPYRIGHT (C) 2011, Shanghai Real-Thread Technology Co., Ltd + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2013, RT-Thread Development Team * - * All rights reserved. + * 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 @@ -17,11 +29,14 @@ #include #include "dfs_ramfs.h" -int dfs_ramfs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data) +int dfs_ramfs_mount(struct dfs_filesystem *fs, + unsigned long rwflag, + const void *data) { struct dfs_ramfs* ramfs; - if (data == RT_NULL) return -DFS_STATUS_EIO; + if (data == RT_NULL) + return -DFS_STATUS_EIO; ramfs = (struct dfs_ramfs*) data; fs->data = ramfs; @@ -55,7 +70,9 @@ int dfs_ramfs_ioctl(struct dfs_fd *file, int cmd, void *args) return -DFS_STATUS_EIO; } -struct ramfs_dirent *dfs_ramfs_lookup(struct dfs_ramfs* ramfs, const char *path, rt_size_t *size) +struct ramfs_dirent *dfs_ramfs_lookup(struct dfs_ramfs *ramfs, + const char *path, + rt_size_t *size) { const char *subpath; struct ramfs_dirent *dirent; @@ -65,16 +82,18 @@ struct ramfs_dirent *dfs_ramfs_lookup(struct dfs_ramfs* ramfs, const char *path, if (! *subpath) /* is root directory */ { *size = 0; + return &(ramfs->root); } for (dirent = rt_list_entry(ramfs->root.list.next, struct ramfs_dirent, list); - dirent != &(ramfs->root); - dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list)) + dirent != &(ramfs->root); + dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list)) { if (rt_strcmp(dirent->name, subpath) == 0) { *size = dirent->size; + return dirent; } } @@ -122,6 +141,7 @@ int dfs_ramfs_write(struct dfs_fd *fd, const void *buf, rt_size_t count) if (ptr == RT_NULL) { rt_set_errno(-RT_ENOMEM); + return 0; } @@ -145,6 +165,7 @@ int dfs_ramfs_lseek(struct dfs_fd *file, rt_off_t offset) if (offset <= (rt_off_t)file->size) { file->pos = offset; + return file->pos; } @@ -154,6 +175,7 @@ int dfs_ramfs_lseek(struct dfs_fd *file, rt_off_t offset) int dfs_ramfs_close(struct dfs_fd *file) { file->data = RT_NULL; + return DFS_STATUS_OK; } @@ -195,8 +217,7 @@ int dfs_ramfs_open(struct dfs_fd *file) if (dirent == RT_NULL) { - if (file->flags & DFS_O_CREAT || - file->flags & DFS_O_WRONLY) + if (file->flags & DFS_O_CREAT || file->flags & DFS_O_WRONLY) { char *name_ptr; @@ -209,7 +230,8 @@ int dfs_ramfs_open(struct dfs_fd *file) /* remove '/' separator */ name_ptr = file->path; - while (*name_ptr == '/' && *name_ptr) name_ptr ++; + while (*name_ptr == '/' && *name_ptr) + name_ptr ++; strncpy(dirent->name, name_ptr, RAMFS_NAME_MAX); rt_list_init(&(dirent->list)); @@ -218,7 +240,8 @@ int dfs_ramfs_open(struct dfs_fd *file) /* add to the root directory */ rt_list_insert_after(&(ramfs->root.list), &(dirent->list)); } - else return -DFS_STATUS_ENOENT; + else + return -DFS_STATUS_ENOENT; } /* Creates a new file. If the file is existing, it is truncated and overwritten. */ @@ -282,8 +305,8 @@ int dfs_ramfs_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t cou index = 0; count = 0; for (dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list); - dirent != &(ramfs->root) && index < end; - dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list)) + dirent != &(ramfs->root) && index < end; + dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list)) { if (index >= (rt_size_t)file->pos) { @@ -312,7 +335,8 @@ int dfs_ramfs_unlink(struct dfs_filesystem *fs, const char *path) RT_ASSERT(ramfs != RT_NULL); dirent = dfs_ramfs_lookup(ramfs, path, &size); - if (dirent == RT_NULL) return -DFS_STATUS_ENOENT; + if (dirent == RT_NULL) + return -DFS_STATUS_ENOENT; rt_list_remove(&(dirent->list)); if (dirent->data != RT_NULL) @@ -322,7 +346,9 @@ int dfs_ramfs_unlink(struct dfs_filesystem *fs, const char *path) return DFS_STATUS_OK; } -int dfs_ramfs_rename(struct dfs_filesystem *fs, const char *oldpath, const char *newpath) +int dfs_ramfs_rename(struct dfs_filesystem *fs, + const char *oldpath, + const char *newpath) { struct ramfs_dirent *dirent; struct dfs_ramfs *ramfs; @@ -332,10 +358,12 @@ int dfs_ramfs_rename(struct dfs_filesystem *fs, const char *oldpath, const char RT_ASSERT(ramfs != RT_NULL); dirent = dfs_ramfs_lookup(ramfs, newpath, &size); - if (dirent != RT_NULL) return -DFS_STATUS_EEXIST; + if (dirent != RT_NULL) + return -DFS_STATUS_EEXIST; dirent = dfs_ramfs_lookup(ramfs, oldpath, &size); - if (dirent == RT_NULL) return -DFS_STATUS_ENOENT; + if (dirent == RT_NULL) + return -DFS_STATUS_ENOENT; strncpy(dirent->name, newpath, RAMFS_NAME_MAX); @@ -368,10 +396,11 @@ int dfs_ramfs_init(void) { /* register ram file system */ dfs_register(&_ramfs); + return 0; } -struct dfs_ramfs* dfs_ramfs_create(rt_uint8_t* pool, rt_size_t size) +struct dfs_ramfs* dfs_ramfs_create(rt_uint8_t *pool, rt_size_t size) { struct dfs_ramfs *ramfs; rt_uint8_t *data_ptr; @@ -385,9 +414,10 @@ struct dfs_ramfs* dfs_ramfs_create(rt_uint8_t* pool, rt_size_t size) size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE); result = rt_memheap_init(&ramfs->memheap, "ramfs", data_ptr, size); - if (result != RT_EOK) return RT_NULL; - /* detach this memheap object from the system */ - rt_object_detach((rt_object_t)&(ramfs->memheap)); + if (result != RT_EOK) + return RT_NULL; + /* detach this memheap object from the system */ + rt_object_detach((rt_object_t)&(ramfs->memheap)); /* initialize ramfs object */ ramfs->magic = RAMFS_MAGIC; diff --git a/components/dfs/filesystems/ramfs/dfs_ramfs.h b/components/dfs/filesystems/ramfs/dfs_ramfs.h index b47422b15..f744a544b 100644 --- a/components/dfs/filesystems/ramfs/dfs_ramfs.h +++ b/components/dfs/filesystems/ramfs/dfs_ramfs.h @@ -1,9 +1,21 @@ /* * File : dfs_ramfs.h - * This file is part of RT-Thread RTOS - * COPYRIGHT (C) 2011, Shanghai Real-Thread Technology Co., Ltd + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2013, RT-Thread Development Team * - * All rights reserved. + * 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 diff --git a/components/dfs/filesystems/romfs/dfs_romfs.c b/components/dfs/filesystems/romfs/dfs_romfs.c index 0cfe4d536..893b7fb0f 100644 --- a/components/dfs/filesystems/romfs/dfs_romfs.c +++ b/components/dfs/filesystems/romfs/dfs_romfs.c @@ -3,9 +3,19 @@ * 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. + * 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 diff --git a/components/dfs/filesystems/romfs/dfs_romfs.h b/components/dfs/filesystems/romfs/dfs_romfs.h index a4f6af271..d0898ecd9 100644 --- a/components/dfs/filesystems/romfs/dfs_romfs.h +++ b/components/dfs/filesystems/romfs/dfs_romfs.h @@ -3,9 +3,19 @@ * 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. + * 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 diff --git a/components/dfs/filesystems/romfs/romfs.c b/components/dfs/filesystems/romfs/romfs.c index 78545f060..90614a14a 100644 --- a/components/dfs/filesystems/romfs/romfs.c +++ b/components/dfs/filesystems/romfs/romfs.c @@ -1,23 +1,51 @@ +/* + * File : romfs.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * 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 + */ + #include -const static unsigned char _dummy_dummy_txt[] = { -0x74,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x61,0x20,0x66,0x69,0x6c,0x65,0x21,0x0d, -0x0a, +const static unsigned char _dummy_dummy_txt[] = +{ + 0x74,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x61,0x20,0x66,0x69,0x6c,0x65,0x21,0x0d,0x0a, }; -const static struct romfs_dirent _dummy[] = { - {ROMFS_DIRENT_FILE, "dummy.txt", _dummy_dummy_txt, sizeof(_dummy_dummy_txt)}, +const static struct romfs_dirent _dummy[] = +{ + {ROMFS_DIRENT_FILE, "dummy.txt", _dummy_dummy_txt, sizeof(_dummy_dummy_txt)}, }; -const static unsigned char _dummy_txt[] = { -0x74,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x61,0x20,0x66,0x69,0x6c,0x65,0x21,0x0d, -0x0a, +const static unsigned char _dummy_txt[] = +{ + 0x74,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x61,0x20,0x66,0x69,0x6c,0x65,0x21,0x0d,0x0a, }; -const struct romfs_dirent _root_dirent[] = { - {ROMFS_DIRENT_DIR, "dummy", (rt_uint8_t*) _dummy, sizeof(_dummy)/sizeof(_dummy[0])}, - {ROMFS_DIRENT_FILE, "dummy.txt", _dummy_txt, sizeof(_dummy_txt)}, +const struct romfs_dirent _root_dirent[] = +{ + {ROMFS_DIRENT_DIR, "dummy", (rt_uint8_t *)_dummy, sizeof(_dummy)/sizeof(_dummy[0])}, + {ROMFS_DIRENT_FILE, "dummy.txt", _dummy_txt, sizeof(_dummy_txt)}, }; -const struct romfs_dirent romfs_root = {ROMFS_DIRENT_DIR, "/", (rt_uint8_t*) _root_dirent, sizeof(_root_dirent)/sizeof(_root_dirent[0])}; +const struct romfs_dirent romfs_root = +{ + ROMFS_DIRENT_DIR, "/", (rt_uint8_t *)_root_dirent, sizeof(_root_dirent)/sizeof(_root_dirent[0]) +}; diff --git a/components/dfs/filesystems/skeleton/skeleton.c b/components/dfs/filesystems/skeleton/skeleton.c index ed2791ad4..74b015014 100644 --- a/components/dfs/filesystems/skeleton/skeleton.c +++ b/components/dfs/filesystems/skeleton/skeleton.c @@ -1,6 +1,26 @@ /* - * A skeleton of file system in Device File System + * File : skeleton.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * 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 */ + #include #include #include @@ -9,74 +29,74 @@ int dfs_skt_mount(struct dfs_filesystem* fs, unsigned long rwflag, const void* data) { - return DFS_STATUS_OK; + return DFS_STATUS_OK; } int dfs_skt_unmount(struct dfs_filesystem* fs) { - return DFS_STATUS_OK; + return DFS_STATUS_OK; } -int dfs_skt_ioctl(struct dfs_fd* file, int cmd, void* args) +int dfs_skt_ioctl(struct dfs_fd* file, int cmd, void* args) { - return -DFS_STATUS_EIO; + return -DFS_STATUS_EIO; } int dfs_skt_read(struct dfs_fd* file, void *buf, rt_size_t count) { - return count; + return count; } int dfs_skt_lseek(struct dfs_fd* file, rt_off_t offset) { - return -DFS_STATUS_EIO; + return -DFS_STATUS_EIO; } int dfs_skt_close(struct dfs_fd* file) { - return DFS_STATUS_OK; + return DFS_STATUS_OK; } int dfs_skt_open(struct dfs_fd* file) { - return DFS_STATUS_OK; + return DFS_STATUS_OK; } int dfs_skt_stat(struct dfs_filesystem* fs, const char *path, struct stat *st) { - return DFS_STATUS_OK; + return DFS_STATUS_OK; } int dfs_skt_getdents(struct dfs_fd* file, struct dirent* dirp, rt_uint32_t count) { - return count * sizeof(struct dirent); + return count * sizeof(struct dirent); } static const struct dfs_filesystem_operation _skt_fs = { - "skt", - DFS_FS_FLAG_DEFAULT, - dfs_skt_mount, - dfs_skt_unmount, - RT_NULL, - RT_NULL, + "skt", + DFS_FS_FLAG_DEFAULT, + dfs_skt_mount, + dfs_skt_unmount, + RT_NULL, + RT_NULL, - dfs_skt_open, - dfs_skt_close, - dfs_skt_ioctl, - dfs_skt_read, - RT_NULL, - RT_NULL, - dfs_skt_lseek, - dfs_skt_getdents, - RT_NULL, - dfs_skt_stat, - RT_NULL, + dfs_skt_open, + dfs_skt_close, + dfs_skt_ioctl, + dfs_skt_read, + RT_NULL, + RT_NULL, + dfs_skt_lseek, + dfs_skt_getdents, + RT_NULL, + dfs_skt_stat, + RT_NULL, }; int dfs_skt_init(void) { /* register rom file system */ dfs_register(&_skt_fs); - return 0; + return 0; } diff --git a/components/dfs/filesystems/skeleton/skeleton.h b/components/dfs/filesystems/skeleton/skeleton.h index 281e84497..844e91e4a 100644 --- a/components/dfs/filesystems/skeleton/skeleton.h +++ b/components/dfs/filesystems/skeleton/skeleton.h @@ -1,3 +1,26 @@ +/* + * File : skeleton.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2011, RT-Thread Development Team + * + * 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 + */ + #ifndef __SKELETON_H__ #define __SKELETON_H__ diff --git a/components/dfs/filesystems/uffs/dfs_uffs.c b/components/dfs/filesystems/uffs/dfs_uffs.c index f9c314622..faaee0990 100644 --- a/components/dfs/filesystems/uffs/dfs_uffs.c +++ b/components/dfs/filesystems/uffs/dfs_uffs.c @@ -1,18 +1,29 @@ /* - * File : rtthread.h - * This file is part of RT-Thread RTOS - * COPYRIGHT (C) 2006-2012, RT-Thread Development Team + * File : dfs_uffs.c + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-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. + * 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 * 2011-10-22 prife the first version * 2012-03-28 prife use mtd device interface * 2012-04-05 prife update uffs with official repo and use uffs_UnMount/Mount -*/ + */ + #include #include diff --git a/components/dfs/filesystems/uffs/dfs_uffs.h b/components/dfs/filesystems/uffs/dfs_uffs.h index f418f1b91..4f83413cd 100644 --- a/components/dfs/filesystems/uffs/dfs_uffs.h +++ b/components/dfs/filesystems/uffs/dfs_uffs.h @@ -1,8 +1,25 @@ /* - * dfs_uffs.h + * File : dfs_uffs.h + * This file is part of Device File System in RT-Thread RTOS + * COPYRIGHT (C) 2004-2012, RT-Thread Development Team * - * Created on: 2012-3-30 - * Author: prife + * 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-03-30 prife the first version */ #ifndef DFS_UFFS_H_ diff --git a/components/dfs/filesystems/uffs/uffs_nandif.c b/components/dfs/filesystems/uffs/uffs_nandif.c index f016263eb..47cb88b6a 100644 --- a/components/dfs/filesystems/uffs/uffs_nandif.c +++ b/components/dfs/filesystems/uffs/uffs_nandif.c @@ -8,338 +8,352 @@ static int nand_init_flash(uffs_Device *dev) { - return UFFS_FLASH_NO_ERR; + return UFFS_FLASH_NO_ERR; } static int nand_release_flash(uffs_Device *dev) { - return UFFS_FLASH_NO_ERR; + return UFFS_FLASH_NO_ERR; } static int nand_erase_block(uffs_Device *dev, unsigned block) { - int res; - res = rt_mtd_nand_erase_block(RT_MTD_NAND_DEVICE(dev->_private), block); - return res == RT_EOK ? UFFS_FLASH_NO_ERR : UFFS_FLASH_IO_ERR; + int res; + + res = rt_mtd_nand_erase_block(RT_MTD_NAND_DEVICE(dev->_private), block); + + return res == RT_EOK ? UFFS_FLASH_NO_ERR : UFFS_FLASH_IO_ERR; } #if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON) static int nand_check_block(uffs_Device *dev, unsigned block) { - int res; - res = rt_mtd_nand_check_block(RT_MTD_NAND_DEVICE(dev->_private), block); - return res == RT_EOK ? UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK; + int res; + + res = rt_mtd_nand_check_block(RT_MTD_NAND_DEVICE(dev->_private), block); + + return res == RT_EOK ? UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK; } static int nand_mark_badblock(uffs_Device *dev, unsigned block) { - int res; - res = rt_mtd_nand_mark_badblock(RT_MTD_NAND_DEVICE(dev->_private), block); - return res == RT_EOK ? UFFS_FLASH_NO_ERR : UFFS_FLASH_IO_ERR; + int res; + + res = rt_mtd_nand_mark_badblock(RT_MTD_NAND_DEVICE(dev->_private), block); + + return res == RT_EOK ? UFFS_FLASH_NO_ERR : UFFS_FLASH_IO_ERR; } #endif #if (RT_CONFIG_UFFS_ECC_MODE == UFFS_ECC_NONE) || (RT_CONFIG_UFFS_ECC_MODE == UFFS_ECC_SOFT) - -static int nand_read_page( - uffs_Device *dev, - u32 block, u32 page, - u8 *data, int data_len, - u8 * ecc, - rt_uint8_t *spare, int spare_len) +static int nand_read_page(uffs_Device *dev, + u32 block, + u32 page, + u8 *data, + int data_len, + u8 *ecc, + rt_uint8_t *spare, + int spare_len) { - int res; + int res; - page = block * dev->attr->pages_per_block + page; - if (data == NULL && spare == NULL) - { + page = block * dev->attr->pages_per_block + page; + if (data == NULL && spare == NULL) + { #if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON) - RT_ASSERT(0); //should not be here + RT_ASSERT(0); //should not be here #else - /* check block status: bad or good */ - rt_uint8_t spare[UFFS_MAX_SPARE_SIZE]; + /* check block status: bad or good */ + rt_uint8_t spare[UFFS_MAX_SPARE_SIZE]; + + rt_memset(spare, 0, UFFS_MAX_SPARE_SIZE); - rt_memset(spare, 0, UFFS_MAX_SPARE_SIZE); + rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private), + page, RT_NULL, 0, + spare, dev->attr->spare_size);//dev->mem.spare_data_size - rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private), - page, RT_NULL, 0, - spare, dev->attr->spare_size);//dev->mem.spare_data_size + res = spare[dev->attr->block_status_offs] == 0xFF ? + UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK; - res = spare[dev->attr->block_status_offs] == 0xFF ? - UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK; - return res; + return res; #endif - } + } - rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private), - page, data, data_len, spare, spare_len); + rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private), + page, data, data_len, spare, spare_len); - return UFFS_FLASH_NO_ERR; + return UFFS_FLASH_NO_ERR; } -static int nand_write_page( - uffs_Device *dev, - u32 block, u32 page, - const u8 *data, int data_len, - const u8 *spare, int spare_len) +static int nand_write_page(uffs_Device *dev, + u32 block, + u32 page, + const u8 *data, + int data_len, + const u8 *spare, + int spare_len) { - int res; + int res; - RT_ASSERT(UFFS_MAX_SPARE_SIZE >= dev->attr->spare_size); + RT_ASSERT(UFFS_MAX_SPARE_SIZE >= dev->attr->spare_size); - page = block * dev->attr->pages_per_block + page; + page = block * dev->attr->pages_per_block + page; - if (data == NULL && spare == NULL) - { + if (data == NULL && spare == NULL) + { #if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON) - RT_ASSERT(0); //should not be here + RT_ASSERT(0); //should not be here #else - /* mark bad block */ - rt_uint8_t spare[UFFS_MAX_SPARE_SIZE]; + /* mark bad block */ + rt_uint8_t spare[UFFS_MAX_SPARE_SIZE]; - rt_memset(spare, 0xFF, UFFS_MAX_SPARE_SIZE); - spare[dev->attr->block_status_offs] = 0x00; + rt_memset(spare, 0xFF, UFFS_MAX_SPARE_SIZE); + spare[dev->attr->block_status_offs] = 0x00; - res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private), - page, RT_NULL, 0, - spare, dev->attr->spare_size);//dev->mem.spare_data_size - if (res != RT_EOK) - goto __error; + res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private), + page, RT_NULL, 0, + spare, dev->attr->spare_size);//dev->mem.spare_data_size + if (res != RT_EOK) + goto __error; #endif - } + } - res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private), - page, data, data_len, spare, spare_len); - if (res != RT_EOK) - goto __error; + res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private), + page, data, data_len, spare, spare_len); + if (res != RT_EOK) + goto __error; - return UFFS_FLASH_NO_ERR; + return UFFS_FLASH_NO_ERR; __error: - return UFFS_FLASH_IO_ERR; + return UFFS_FLASH_IO_ERR; } const uffs_FlashOps nand_ops = { - nand_init_flash, /* InitFlash() */ - nand_release_flash, /* ReleaseFlash() */ - nand_read_page, /* ReadPage() */ - NULL, /* ReadPageWithLayout */ - nand_write_page, /* WritePage() */ - NULL, /* WirtePageWithLayout */ + nand_init_flash, /* InitFlash() */ + nand_release_flash, /* ReleaseFlash() */ + nand_read_page, /* ReadPage() */ + NULL, /* ReadPageWithLayout */ + nand_write_page, /* WritePage() */ + NULL, /* WirtePageWithLayout */ #if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON) - nand_check_block, - nand_mark_badblock, + nand_check_block, + nand_mark_badblock, #else - NULL, /* IsBadBlock(), let UFFS take care of it. */ - NULL, /* MarkBadBlock(), let UFFS take care of it. */ + NULL, /* IsBadBlock(), let UFFS take care of it. */ + NULL, /* MarkBadBlock(), let UFFS take care of it. */ #endif - nand_erase_block, /* EraseBlock() */ + nand_erase_block, /* EraseBlock() */ }; -void uffs_setup_storage( - struct uffs_StorageAttrSt *attr, - struct rt_mtd_nand_device * nand) +void uffs_setup_storage(struct uffs_StorageAttrSt *attr, + struct rt_mtd_nand_device *nand) { - rt_memset(attr, 0, sizeof(struct uffs_StorageAttrSt)); - -// attr->total_blocks = nand->end_block - nand->start_block + 1;/* no use */ - attr->page_data_size = nand->page_size; /* page data size */ - attr->pages_per_block = nand->pages_per_block; /* pages per block */ - attr->spare_size = nand->oob_size; /* page spare size */ - attr->ecc_opt = RT_CONFIG_UFFS_ECC_MODE; /* ecc option */ - attr->ecc_size = 0; /* ecc size is 0 , the uffs will calculate the ecc size*/ - attr->block_status_offs = attr->ecc_size; /* indicate block bad or good, offset in spare */ - attr->layout_opt = RT_CONFIG_UFFS_LAYOUT; /* let UFFS do the spare layout */ + rt_memset(attr, 0, sizeof(struct uffs_StorageAttrSt)); + +// attr->total_blocks = nand->end_block - nand->start_block + 1;/* no use */ + attr->page_data_size = nand->page_size; /* page data size */ + attr->pages_per_block = nand->pages_per_block; /* pages per block */ + attr->spare_size = nand->oob_size; /* page spare size */ + attr->ecc_opt = RT_CONFIG_UFFS_ECC_MODE; /* ecc option */ + attr->ecc_size = 0; /* ecc size is 0 , the uffs will calculate the ecc size*/ + attr->block_status_offs = attr->ecc_size; /* indicate block bad or good, offset in spare */ + attr->layout_opt = RT_CONFIG_UFFS_LAYOUT; /* let UFFS do the spare layout */ } #elif RT_CONFIG_UFFS_ECC_MODE == UFFS_ECC_HW_AUTO - -static int WritePageWithLayout( - uffs_Device *dev, u32 block, u32 page, - const u8 *data, int data_len, - const u8 *ecc, //NULL - const uffs_TagStore *ts) +static int WritePageWithLayout(uffs_Device *dev, + u32 block, + u32 page, + const u8 *data, + int data_len, + const u8 *ecc, //NULL + const uffs_TagStore *ts) { - int res; - int spare_len; - rt_uint8_t spare[UFFS_MAX_SPARE_SIZE]; + int res; + int spare_len; + rt_uint8_t spare[UFFS_MAX_SPARE_SIZE]; - RT_ASSERT(UFFS_MAX_SPARE_SIZE >= dev->attr->spare_size); + RT_ASSERT(UFFS_MAX_SPARE_SIZE >= dev->attr->spare_size); - page = block * dev->attr->pages_per_block + page; - spare_len = dev->mem.spare_data_size; + page = block * dev->attr->pages_per_block + page; + spare_len = dev->mem.spare_data_size; - if (data == NULL && ts == NULL) - { + if (data == NULL && ts == NULL) + { #if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON) - RT_ASSERT(0); //should not be here + RT_ASSERT(0); //should not be here #else - /* mark bad block */ - rt_memset(spare, 0xFF, UFFS_MAX_SPARE_SIZE); - spare[dev->attr->block_status_offs] = 0x00; - - res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private), - page, RT_NULL, 0, - spare, dev->attr->spare_size);//dev->mem.spare_data_size - if (res != RT_EOK) - goto __error; - - dev->st.io_write++; - return UFFS_FLASH_NO_ERR; - + /* mark bad block */ + rt_memset(spare, 0xFF, UFFS_MAX_SPARE_SIZE); + spare[dev->attr->block_status_offs] = 0x00; + + res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private), + page, RT_NULL, 0, + spare, dev->attr->spare_size);//dev->mem.spare_data_size + if (res != RT_EOK) + goto __error; + + dev->st.io_write++; + return UFFS_FLASH_NO_ERR; #endif - } + } - if (data != NULL && data_len != 0) - { - RT_ASSERT(data_len == dev->attr->page_data_size); + if (data != NULL && data_len != 0) + { + RT_ASSERT(data_len == dev->attr->page_data_size); - dev->st.page_write_count++; - dev->st.io_write += data_len; - } + dev->st.page_write_count++; + dev->st.io_write += data_len; + } - if (ts != RT_NULL) - { - uffs_FlashMakeSpare(dev, ts, RT_NULL, (u8 *)spare); - dev->st.spare_write_count++; - dev->st.io_write += spare_len; - } + if (ts != RT_NULL) + { + uffs_FlashMakeSpare(dev, ts, RT_NULL, (u8 *)spare); + dev->st.spare_write_count++; + dev->st.io_write += spare_len; + } - res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private), - page, data, data_len, spare, spare_len); - if (res != RT_EOK) - goto __error; + res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private), + page, data, data_len, spare, spare_len); + if (res != RT_EOK) + goto __error; - return UFFS_FLASH_NO_ERR; + return UFFS_FLASH_NO_ERR; __error: - return UFFS_FLASH_IO_ERR; + return UFFS_FLASH_IO_ERR; } -static URET ReadPageWithLayout( - uffs_Device *dev, u32 block, u32 page, - u8* data, int data_len, - u8 *ecc, //NULL - uffs_TagStore *ts, - u8 *ecc_store) //NULL +static URET ReadPageWithLayout(uffs_Device *dev, + u32 block, + u32 page, + u8 *data, + int data_len, + u8 *ecc, //NULL + uffs_TagStore *ts, + u8 *ecc_store) //NULL { - int res = UFFS_FLASH_NO_ERR; - int spare_len; - rt_uint8_t spare[UFFS_MAX_SPARE_SIZE]; + int res = UFFS_FLASH_NO_ERR; + int spare_len; + rt_uint8_t spare[UFFS_MAX_SPARE_SIZE]; - RT_ASSERT(UFFS_MAX_SPARE_SIZE >= dev->attr->spare_size); + RT_ASSERT(UFFS_MAX_SPARE_SIZE >= dev->attr->spare_size); - page = block * dev->attr->pages_per_block + page; - spare_len = dev->mem.spare_data_size; + page = block * dev->attr->pages_per_block + page; + spare_len = dev->mem.spare_data_size; - if (data == RT_NULL && ts == RT_NULL) - { + if (data == RT_NULL && ts == RT_NULL) + { #if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON) - RT_ASSERT(0); //should not be here + RT_ASSERT(0); //should not be here #else - /* check block good or bad */ + /* check block good or bad */ - rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private), - page, RT_NULL, 0, - spare, dev->attr->spare_size);//dev->mem.spare_data_size + rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private), + page, RT_NULL, 0, + spare, dev->attr->spare_size);//dev->mem.spare_data_size - dev->st.io_read++; + dev->st.io_read++; - res = spare[dev->attr->block_status_offs] == 0xFF ? - UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK; - return res; + res = spare[dev->attr->block_status_offs] == 0xFF ? + UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK; + return res; #endif - } - - if (data != RT_NULL) - { - dev->st.io_read += data_len; - dev->st.page_read_count++; - } - - res = rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private), - page, data, data_len, spare, spare_len); - if (res == 0) - res = UFFS_FLASH_NO_ERR; - else if (res == -1) - { - //TODO ecc correct, add code to use hardware do ecc correct - res = UFFS_FLASH_ECC_OK; - } - else - res = UFFS_FLASH_ECC_FAIL; - - if (ts != RT_NULL) - { - // unload ts and ecc from spare, you can modify it if you like - uffs_FlashUnloadSpare(dev, (const u8 *)spare, ts, RT_NULL); - - if ((spare[spare_len - 1] == 0xFF) && (res == UFFS_FLASH_NO_ERR)) - res = UFFS_FLASH_NOT_SEALED; - - dev->st.io_read += spare_len; - dev->st.spare_read_count++; - } - - return res; + } + + if (data != RT_NULL) + { + dev->st.io_read += data_len; + dev->st.page_read_count++; + } + + res = rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private), + page, data, data_len, spare, spare_len); + if (res == 0) + res = UFFS_FLASH_NO_ERR; + else if (res == -1) + { + //TODO ecc correct, add code to use hardware do ecc correct + res = UFFS_FLASH_ECC_OK; + } + else + res = UFFS_FLASH_ECC_FAIL; + + if (ts != RT_NULL) + { + // unload ts and ecc from spare, you can modify it if you like + uffs_FlashUnloadSpare(dev, (const u8 *)spare, ts, RT_NULL); + + if ((spare[spare_len - 1] == 0xFF) && (res == UFFS_FLASH_NO_ERR)) + res = UFFS_FLASH_NOT_SEALED; + + dev->st.io_read += spare_len; + dev->st.spare_read_count++; + } + + return res; } const uffs_FlashOps nand_ops = { - nand_init_flash, /* InitFlash() */ - nand_release_flash, /* ReleaseFlash() */ - NULL, /* ReadPage() */ - ReadPageWithLayout, /* ReadPageWithLayout */ - NULL, /* WritePage() */ - WritePageWithLayout,/* WirtePageWithLayout */ + nand_init_flash, /* InitFlash() */ + nand_release_flash, /* ReleaseFlash() */ + NULL, /* ReadPage() */ + ReadPageWithLayout, /* ReadPageWithLayout */ + NULL, /* WritePage() */ + WritePageWithLayout,/* WirtePageWithLayout */ #if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON) - nand_check_block, - nand_mark_badblock, + nand_check_block, + nand_mark_badblock, #else - NULL, /* IsBadBlock(), let UFFS take care of it. */ - NULL, /* MarkBadBlock(), let UFFS take care of it. */ + NULL, /* IsBadBlock(), let UFFS take care of it. */ + NULL, /* MarkBadBlock(), let UFFS take care of it. */ #endif - nand_erase_block, /* EraseBlock() */ + nand_erase_block, /* EraseBlock() */ }; static rt_uint8_t hw_flash_data_layout[UFFS_SPARE_LAYOUT_SIZE] = -{0x05, 0x08, 0xFF, 0x00}; +{ + 0x05, 0x08, 0xFF, 0x00 +}; static rt_uint8_t hw_flash_ecc_layout[UFFS_SPARE_LAYOUT_SIZE] = -{0x00, 0x04, 0xFF, 0x00}; +{ + 0x00, 0x04, 0xFF, 0x00 +}; -void uffs_setup_storage( - struct uffs_StorageAttrSt *attr, - struct rt_mtd_nand_device * nand) +void uffs_setup_storage(struct uffs_StorageAttrSt *attr, + struct rt_mtd_nand_device *nand) { - rt_memset(attr, 0, sizeof(struct uffs_StorageAttrSt)); - -// attr->total_blocks = nand->end_block - nand->start_block + 1;/* no use */ - attr->page_data_size = nand->page_size; /* page data size */ - attr->pages_per_block = nand->pages_per_block; /* pages per block */ - attr->spare_size = nand->oob_size; /* page spare size */ - attr->ecc_opt = RT_CONFIG_UFFS_ECC_MODE; /* ecc option */ - attr->ecc_size = nand->oob_size-nand->oob_free; /* ecc size */ - attr->block_status_offs = attr->ecc_size; /* indicate block bad or good, offset in spare */ - attr->layout_opt = RT_CONFIG_UFFS_LAYOUT; /* let UFFS do the spare layout */ - - /* calculate the ecc layout array */ - hw_flash_data_layout[0] = attr->ecc_size + 1; /* ecc size + 1byte block status */ - hw_flash_data_layout[1] = 0x08; - hw_flash_data_layout[2] = 0xFF; - hw_flash_data_layout[3] = 0x00; - - hw_flash_ecc_layout[0] = 0; - hw_flash_ecc_layout[1] = attr->ecc_size; - hw_flash_ecc_layout[2] = 0xFF; - hw_flash_ecc_layout[3] = 0x00; - - /* initialize _uffs_data_layout and _uffs_ecc_layout */ - rt_memcpy(attr->_uffs_data_layout, hw_flash_data_layout, UFFS_SPARE_LAYOUT_SIZE); - rt_memcpy(attr->_uffs_ecc_layout, hw_flash_ecc_layout, UFFS_SPARE_LAYOUT_SIZE); - - attr->data_layout = attr->_uffs_data_layout; - attr->ecc_layout = attr->_uffs_ecc_layout; + rt_memset(attr, 0, sizeof(struct uffs_StorageAttrSt)); + +// attr->total_blocks = nand->end_block - nand->start_block + 1;/* no use */ + attr->page_data_size = nand->page_size; /* page data size */ + attr->pages_per_block = nand->pages_per_block; /* pages per block */ + attr->spare_size = nand->oob_size; /* page spare size */ + attr->ecc_opt = RT_CONFIG_UFFS_ECC_MODE; /* ecc option */ + attr->ecc_size = nand->oob_size-nand->oob_free; /* ecc size */ + attr->block_status_offs = attr->ecc_size; /* indicate block bad or good, offset in spare */ + attr->layout_opt = RT_CONFIG_UFFS_LAYOUT; /* let UFFS do the spare layout */ + + /* calculate the ecc layout array */ + hw_flash_data_layout[0] = attr->ecc_size + 1; /* ecc size + 1byte block status */ + hw_flash_data_layout[1] = 0x08; + hw_flash_data_layout[2] = 0xFF; + hw_flash_data_layout[3] = 0x00; + + hw_flash_ecc_layout[0] = 0; + hw_flash_ecc_layout[1] = attr->ecc_size; + hw_flash_ecc_layout[2] = 0xFF; + hw_flash_ecc_layout[3] = 0x00; + + /* initialize _uffs_data_layout and _uffs_ecc_layout */ + rt_memcpy(attr->_uffs_data_layout, hw_flash_data_layout, UFFS_SPARE_LAYOUT_SIZE); + rt_memcpy(attr->_uffs_ecc_layout, hw_flash_ecc_layout, UFFS_SPARE_LAYOUT_SIZE); + + attr->data_layout = attr->_uffs_data_layout; + attr->ecc_layout = attr->_uffs_ecc_layout; } #endif diff --git a/components/dfs/include/dfs.h b/components/dfs/include/dfs.h index ff7de473b..9ef14d3cf 100644 --- a/components/dfs/include/dfs.h +++ b/components/dfs/include/dfs.h @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2004-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. + * 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 diff --git a/components/dfs/include/dfs_def.h b/components/dfs/include/dfs_def.h index 52560eae8..a73ff4ec8 100644 --- a/components/dfs/include/dfs_def.h +++ b/components/dfs/include/dfs_def.h @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2004-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. + * 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 diff --git a/components/dfs/include/dfs_elm.h b/components/dfs/include/dfs_elm.h index 18401ef8e..da8a21700 100644 --- a/components/dfs/include/dfs_elm.h +++ b/components/dfs/include/dfs_elm.h @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2008-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. + * 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 diff --git a/components/dfs/include/dfs_file.h b/components/dfs/include/dfs_file.h index a3fba3dad..87a178d02 100644 --- a/components/dfs/include/dfs_file.h +++ b/components/dfs/include/dfs_file.h @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2004-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. + * 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 diff --git a/components/dfs/include/dfs_fs.h b/components/dfs/include/dfs_fs.h index 8751c72a8..e8f42f663 100644 --- a/components/dfs/include/dfs_fs.h +++ b/components/dfs/include/dfs_fs.h @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2004-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. + * 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 diff --git a/components/dfs/include/dfs_init.h b/components/dfs/include/dfs_init.h index 16afd24aa..b421bdcb0 100644 --- a/components/dfs/include/dfs_init.h +++ b/components/dfs/include/dfs_init.h @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2004-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. + * 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 diff --git a/components/dfs/include/dfs_posix.h b/components/dfs/include/dfs_posix.h index c8d15fcf9..56a051142 100644 --- a/components/dfs/include/dfs_posix.h +++ b/components/dfs/include/dfs_posix.h @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2004-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. + * 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 diff --git a/components/dfs/src/dfs.c b/components/dfs/src/dfs.c index f5c2b5aaf..4e38615ba 100644 --- a/components/dfs/src/dfs.c +++ b/components/dfs/src/dfs.c @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2004-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. + * 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 diff --git a/components/dfs/src/dfs_file.c b/components/dfs/src/dfs_file.c index 0e757a273..05e76c96f 100644 --- a/components/dfs/src/dfs_file.c +++ b/components/dfs/src/dfs_file.c @@ -3,9 +3,19 @@ * 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. + * 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 diff --git a/components/dfs/src/dfs_fs.c b/components/dfs/src/dfs_fs.c index b37d4ffd1..c7fb80eff 100644 --- a/components/dfs/src/dfs_fs.c +++ b/components/dfs/src/dfs_fs.c @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2004-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. + * 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 diff --git a/components/dfs/src/dfs_posix.c b/components/dfs/src/dfs_posix.c index 5cb3b8ffa..96139837e 100644 --- a/components/dfs/src/dfs_posix.c +++ b/components/dfs/src/dfs_posix.c @@ -3,9 +3,19 @@ * This file is part of Device File System in RT-Thread RTOS * COPYRIGHT (C) 2004-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. + * 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 -- GitLab