dfs_file.c 文件参考

#include "errno.h"
#include "fcntl.h"
#include <dfs.h>
#include "dfs_file.h"
#include "dfs_dentry.h"
#include "dfs_fs.h"
#include "dfs_mnt.h"
#include "dfs_private.h"
#include <rtdbg.h>

dfs_file.c 的引用(Include)关系图:

浏览该文件的源代码.

宏定义
#define	DBG_TAG   "DFS.file"
#define	DBG_LVL   DBG_WARNING
#define	MAX_RW_COUNT   0xfffc0000
#define	_COLOR_RED   "\033[31m"
#define	_COLOR_GREEN   "\033[32m"
#define	_COLOR_YELLOW   "\033[33m"
#define	_COLOR_BLUE   "\033[34m"
#define	_COLOR_CYAN   "\033[36m"
#define	_COLOR_WHITE   "\033[37m"
#define	_COLOR_NORMAL   "\033[0m"
#define	BUF_SZ   4096
#define	FLAG_SRC_TYPE   0x03
#define	FLAG_SRC_IS_DIR   0x01
#define	FLAG_SRC_IS_FILE   0x02
#define	FLAG_SRC_NON_EXSIT   0x00
#define	FLAG_DST_TYPE   0x0C
#define	FLAG_DST_IS_DIR   0x04
#define	FLAG_DST_IS_FILE   0x08
#define	FLAG_DST_NON_EXSIT   0x00

函数
rt_inline int	_first_path_len (const char *path)
ssize_t	rw_verify_area (struct dfs_file *file, off_t *ppos, size_t count)
off_t	dfs_file_get_fpos (struct dfs_file *file)
void	dfs_file_set_fpos (struct dfs_file *file, off_t fpos)
void	dfs_file_init (struct dfs_file *file)
void	dfs_file_deinit (struct dfs_file *file)
char *	dfs_file_realpath (struct dfs_mnt **mnt, const char *fullpath, int mode)
int	dfs_file_open (struct dfs_file *file, const char *path, int oflags, mode_t mode)
int	dfs_file_close (struct dfs_file *file)
ssize_t	dfs_file_pread (struct dfs_file *file, void *buf, size_t len, off_t offset)
ssize_t	dfs_file_read (struct dfs_file *file, void *buf, size_t len)
ssize_t	dfs_file_pwrite (struct dfs_file *file, const void *buf, size_t len, off_t offset)
ssize_t	dfs_file_write (struct dfs_file *file, const void *buf, size_t len)
off_t	generic_dfs_lseek (struct dfs_file *file, off_t offset, int whence)
off_t	dfs_file_lseek (struct dfs_file *file, off_t offset, int wherece)
int	dfs_file_stat (const char *path, struct stat *buf)
int	dfs_file_lstat (const char *path, struct stat *buf)
int	dfs_file_fstat (struct dfs_file *file, struct stat *buf)
int	dfs_file_setattr (const char *path, struct dfs_attr *attr)
int	dfs_file_ioctl (struct dfs_file *file, int cmd, void *args)
int	dfs_file_fcntl (int fd, int cmd, unsigned long arg)
int	dfs_file_fsync (struct dfs_file *file)
int	dfs_file_unlink (const char *path)
int	dfs_file_link (const char *oldname, const char *newname)
int	dfs_file_symlink (const char *target, const char *linkpath)
int	dfs_file_readlink (const char *path, char *buf, int bufsize)
int	dfs_file_rename (const char *old_file, const char *new_file)
int	dfs_file_ftruncate (struct dfs_file *file, off_t length)
int	dfs_file_flush (struct dfs_file *file)
int	dfs_file_getdents (struct dfs_file *file, struct dirent *dirp, size_t nbytes)
int	dfs_file_isdir (const char *path)
int	dfs_file_access (const char *path, mode_t mode)
void	ls (const char *pathname)
void	cat (const char *filename)
int	mkdir (const char *path, mode_t mode)
void	copy (const char *src, const char *dst)

宏定义说明

DBG_TAG

#define DBG_TAG   "DFS.file"

在文件 dfs_file.c 第 26 行定义.

DBG_LVL

#define DBG_LVL   DBG_WARNING

在文件 dfs_file.c 第 27 行定义.

MAX_RW_COUNT

#define MAX_RW_COUNT   0xfffc0000

在文件 dfs_file.c 第 30 行定义.

_COLOR_RED

#define _COLOR_RED   "\033[31m"

在文件 dfs_file.c 第 1965 行定义.

_COLOR_GREEN

#define _COLOR_GREEN   "\033[32m"

在文件 dfs_file.c 第 1966 行定义.

_COLOR_YELLOW

#define _COLOR_YELLOW   "\033[33m"

在文件 dfs_file.c 第 1967 行定义.

_COLOR_BLUE

#define _COLOR_BLUE   "\033[34m"

在文件 dfs_file.c 第 1968 行定义.

_COLOR_CYAN

#define _COLOR_CYAN   "\033[36m"

在文件 dfs_file.c 第 1969 行定义.

_COLOR_WHITE

#define _COLOR_WHITE   "\033[37m"

在文件 dfs_file.c 第 1970 行定义.

_COLOR_NORMAL

#define _COLOR_NORMAL   "\033[0m"

在文件 dfs_file.c 第 1971 行定义.

BUF_SZ

#define BUF_SZ   4096

在文件 dfs_file.c 第 2179 行定义.

FLAG_SRC_TYPE

#define FLAG_SRC_TYPE   0x03

FLAG_SRC_IS_DIR

#define FLAG_SRC_IS_DIR   0x01

FLAG_SRC_IS_FILE

#define FLAG_SRC_IS_FILE   0x02

FLAG_SRC_NON_EXSIT

#define FLAG_SRC_NON_EXSIT   0x00

FLAG_DST_TYPE

#define FLAG_DST_TYPE   0x0C

FLAG_DST_IS_DIR

#define FLAG_DST_IS_DIR   0x04

FLAG_DST_IS_FILE

#define FLAG_DST_IS_FILE   0x08

FLAG_DST_NON_EXSIT

#define FLAG_DST_NON_EXSIT   0x00

函数说明

_first_path_len()

rt_inline int _first_path_len

(

const char *

path

)

在文件 dfs_file.c 第 32 行定义.

{
    int i = 0;
 
    if (path[i] == '/')
    {
        i++;
        while (path[i] != '\0' && path[i] != '/')
        {
            i++;
        }
    }
 
    return i;
}

这是这个函数的调用关系图:

rw_verify_area()

ssize_t rw_verify_area	(	struct dfs_file *	file,
		off_t *	ppos,
		size_t	count )

在文件 dfs_file.c 第 145 行定义.

{
    off_t pos;
    ssize_t retval = -EINVAL;
 
    if ((size_t)count < 0)
        return retval;
    pos = *ppos;
    if (pos < 0)
    {
        if (count >= -pos) /* both values are in 0..LLONG_MAX */
            return -EOVERFLOW;
    }
 
    return count > MAX_RW_COUNT ? MAX_RW_COUNT : count;
}

引用了 MAX_RW_COUNT.

这是这个函数的调用关系图:

dfs_file_get_fpos()

off_t dfs_file_get_fpos

(

struct dfs_file *

file

)

在文件 dfs_file.c 第 162 行定义.

{
    if (file)
    {
        if (file->vnode->type == FT_REGULAR)
        {
            rt_mutex_take(&file->pos_lock, RT_WAITING_FOREVER);
        }
        return file->fpos;
    }
 
    return 0;
}

引用了 dfs_file::fpos, dfs_file::pos_lock, rt_mutex_take(), RT_WAITING_FOREVER, dfs_vnode::type , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_set_fpos()

void dfs_file_set_fpos	(	struct dfs_file *	file,
		off_t	fpos )

在文件 dfs_file.c 第 176 行定义.

{
    if (file)
    {
        if (file->vnode->type != FT_REGULAR)
        {
            rt_mutex_take(&file->pos_lock, RT_WAITING_FOREVER);
        }
        file->fpos = fpos;
        rt_mutex_release(&file->pos_lock);
    }
}

引用了 dfs_file::fpos, dfs_file::pos_lock, rt_mutex_release(), rt_mutex_take(), RT_WAITING_FOREVER, dfs_vnode::type , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_init()

void dfs_file_init

(

struct dfs_file *

file

)

在文件 dfs_file.c 第 189 行定义.

{
    if (file)
    {
        rt_memset(file, 0x00, sizeof(struct dfs_file));
        file->magic = DFS_FD_MAGIC;
        rt_mutex_init(&file->pos_lock, "fpos", RT_IPC_FLAG_PRIO);
        rt_atomic_store(&(file->ref_count), 1);
    }
}

引用了 DFS_FD_MAGIC, dfs_file::magic, dfs_file::pos_lock, dfs_file::ref_count, rt_atomic_store, RT_IPC_FLAG_PRIO , 以及 rt_mutex_init().

函数调用图:

这是这个函数的调用关系图:

dfs_file_deinit()

void dfs_file_deinit

(

struct dfs_file *

file

)

在文件 dfs_file.c 第 200 行定义.

{
    if (file)
    {
        rt_mutex_detach(&file->pos_lock);
    }
}

引用了 dfs_file::pos_lock , 以及 rt_mutex_detach().

函数调用图:

这是这个函数的调用关系图:

dfs_file_realpath()

char * dfs_file_realpath	(	struct dfs_mnt **	mnt,
		const char *	fullpath,
		int	mode )

在文件 dfs_file.c 第 253 行定义.

{
    int path_len = 0, index = 0;
    char *path = RT_NULL, *link_fn, *tmp_path;
    struct dfs_mnt *tmp_mnt;
 
    if (*mnt && fullpath)
    {
        int len, link_len;
 
        path = (char *)rt_malloc((DFS_PATH_MAX * 3) + 3); // path + \0 + link_fn + \0 + tmp_path + \0
        if (!path)
        {
            return RT_NULL;
        }
 
        link_fn = path + DFS_PATH_MAX + 1;
        tmp_path = link_fn + (DFS_PATH_MAX + 1);
 
        len = rt_strlen(fullpath);
        if (len > DFS_PATH_MAX)
        {
            goto _ERR_RET;
        }
 
        index = (DFS_PATH_MAX - len);
        rt_strcpy(tmp_path + index, fullpath);
 
        if (mode == DFS_REALPATH_ONLY_LAST)
        {
            path_len = _get_parent_path(fullpath, path);
            index += path_len;
        }
 
        while ((len = _first_path_len(tmp_path + index)) > 0)
        {
            if (len + path_len > DFS_PATH_MAX)
            {
                goto _ERR_RET;
            }
 
            rt_memcpy(path + path_len, tmp_path + index, len);
            path[path_len + len] = '\0';
            index += len;
 
            tmp_mnt = dfs_mnt_lookup(path);
            if (tmp_mnt == RT_NULL)
            {
                goto _ERR_RET;
            }
 
            *mnt = tmp_mnt;
 
            /* the last should by mode process. */
            if ((tmp_path[index] == '\0') && (mode == DFS_REALPATH_EXCEPT_LAST))
            {
                break;
            }
 
            link_len = _try_readlink(path, *mnt, link_fn);
            if (link_len > 0)
            {
                if (link_fn[0] == '/')
                {
                    int ret = _insert_link_path(link_fn, link_len, tmp_path, &index);
                    if (ret < 0)
                    {
                        goto _ERR_RET;
                    }
                    path_len = 0;
                }
                else
                {
                    char *fp = _dfs_normalize_path(path, path_len, link_fn, link_len);
                    if (fp)
                    {
                        int pos = rt_strncmp(path, fp, path_len);
                        if (pos == 0)
                        {
                            int ret = _insert_link_path(fp + path_len, rt_strlen(fp + path_len), tmp_path, &index);
                            if (ret < 0)
                            {
                                rt_free(fp);
                                goto _ERR_RET;
                            }
                        }
                        else
                        {
                            int pos;
 
                            while(1)
                            {
                                while(path_len > 0 && path[path_len] != '/')
                                {
                                    path_len--;
                                }
 
                                if (path_len > 0)
                                {
                                    pos = rt_strncmp(path, fp, path_len);
                                }
                                else
                                {
                                    pos = -1;
                                }
 
                                if (pos == 0 || path_len == 0)
                                {
                                    int ret;
 
                                    ret = _insert_link_path(fp + path_len, rt_strlen(fp + path_len), tmp_path, &index);
                                    if (ret < 0)
                                    {
                                        rt_free(fp);
                                        goto _ERR_RET;
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                                else
                                {
                                    path_len--;
                                }
                            }
                        }
                        rt_free(fp);
                    }
                }
            }
            else
            {
                path_len += len;
            }
        }
 
        return path;
 
_ERR_RET:
        rt_free(path);
        path = RT_NULL;
    }
 
    return path;
}

引用了 _first_path_len(), dfs_mnt_lookup(), DFS_PATH_MAX, DFS_REALPATH_EXCEPT_LAST, DFS_REALPATH_ONLY_LAST, dfs_mnt::fullpath, rt_free(), rt_malloc() , 以及 RT_NULL.

函数调用图:

这是这个函数的调用关系图:

dfs_file_open()

int dfs_file_open	(	struct dfs_file *	file,
		const char *	path,
		int	oflags,
		mode_t	mode )

this function will open a file which specified by path with specified oflags.

参数

fd	the file descriptor pointer to return the corresponding result.
path	the specified file path.
oflags	the oflags for open operator.

返回

0 on successful, -1 on failed.

在文件 dfs_file.c 第 409 行定义.

{
    int ret = -RT_ERROR;
    char *fullpath = RT_NULL;
    struct dfs_dentry *dentry = RT_NULL;
    int fflags = dfs_fflags(oflags);
 
    if (mode == 0)
    {
        mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); /* 0666 */
    }
 
    if (file && path)
    {
        fullpath = dfs_normalize_path(NULL, path);
        if (fullpath)
        {
            struct dfs_mnt *mnt = RT_NULL;
 
            DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
            mnt = dfs_mnt_lookup(fullpath);
            if (mnt)
            {
                char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
                if (tmp)
                {
                    rt_free(fullpath);
                    fullpath = tmp;
                }
 
                DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", fullpath);
                dentry = dfs_dentry_lookup(mnt, fullpath, oflags);
                if (dentry && dentry->vnode->type == FT_SYMLINK)
                {
                    /* it's a symbol link but not follow */
                    if (oflags & O_NOFOLLOW)
                    {
                        /* no follow symbol link */
                        dfs_dentry_unref(dentry);
                        dentry = RT_NULL;
                    }
                    else
                    {
                        struct dfs_dentry *target_dentry = RT_NULL;
                        char *path = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_ONLY_LAST);
                        if (path)
                        {
                            target_dentry = dfs_dentry_lookup(mnt, path, oflags);
                            rt_free(path);
                        }
                        dfs_dentry_unref(dentry);
                        dentry = target_dentry;
                    }
                }
 
                if (dentry)
                {
                    if (oflags & O_DIRECTORY)
                    {
                        if (dentry->vnode->type != FT_DIRECTORY)
                        {
                            dfs_dentry_unref(dentry);
                            dentry = RT_NULL;
                        }
                    }
                    else if (dentry->vnode->type == FT_DIRECTORY)
                    {
                        if (fflags & (DFS_F_FWRITE))
                        {
                            dfs_dentry_unref(dentry);
                            dentry = RT_NULL;
                        }
                        else
                        {
                            oflags |= O_DIRECTORY;
                        }
                    }
                }
 
                if (oflags & O_CREAT)
                {
                    if (dentry)
                    {
                        oflags &= ~O_CREAT;
 
                        if (oflags & O_EXCL)
                        {
                            oflags &= ~O_EXCL;
                            /* the dentry already exists */
                            dfs_dentry_unref(dentry);
                            ret = -EEXIST;
                            goto _ERR_RET;
                        }
                    }
                    else
                    {
                        /* create file/directory */
                        if (mnt->fs_ops->create_vnode)
                        {
                            struct dfs_vnode *vnode = RT_NULL;
 
                            DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_create(%s)", fullpath);
                            dfs_file_lock();
                            dentry = dfs_dentry_create(mnt, fullpath);
                            if (dentry)
                            {
                                DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->create_vnode");
 
                                if (dfs_is_mounted(mnt) == 0)
                                {
                                    vnode = mnt->fs_ops->create_vnode(dentry, oflags & O_DIRECTORY ? FT_DIRECTORY:FT_REGULAR, mode);
                                }
 
                                if (vnode)
                                {
                                    /* set vnode */
                                    dentry->vnode = vnode;  /* the refcount of created vnode is 1. no need to reference */
                                    dfs_dentry_insert(dentry);
                                }
                                else
                                {
                                    DLOG(msg, mnt->fs_ops->name, "dfs_file", DLOG_MSG_RET, "create failed.");
                                    dfs_dentry_unref(dentry);
                                    dentry = RT_NULL;
                                }
                            }
                            dfs_file_unlock();
                        }
                    }
                }
 
                if (dentry)
                {
                    rt_bool_t permission = RT_TRUE;
                    file->dentry = dentry;
                    file->vnode = dentry->vnode;
                    file->fops  = dentry->mnt->fs_ops->default_fops;
                    file->flags = oflags;
 
                    /* check permission */
                    if (!(oflags & O_CREAT))
                    {
                        if (fflags & DFS_F_FWRITE)
                        {
                            if (!(file->vnode->mode & S_IWUSR))
                            {
                                permission = RT_FALSE;
                            }
                        }
 
                        if (fflags & DFS_F_FREAD)
                        {
                            if (!(file->vnode->mode & S_IRUSR))
                            {
                                permission = RT_FALSE;
                            }
                        }
 
                        if (oflags & O_EXEC)
                        {
                            if (!(file->vnode->mode & S_IXUSR))
                            {
                                permission = RT_FALSE;
                            }
                        }
                    }
 
                    if (permission && file->fops->open)
                    {
                        DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fops->open(file)");
 
                        if (dfs_is_mounted(file->vnode->mnt) == 0)
                        {
                            dfs_file_lock();
                            ret = file->fops->open(file);
                            dfs_file_unlock();
                        }
                        else
                        {
                            ret = -EINVAL;
                        }
 
                        if (ret < 0)
                        {
                            LOG_I("open %s failed in file system: %s", path, dentry->mnt->fs_ops->name);
                            DLOG(msg, mnt->fs_ops->name, "dfs_file", DLOG_MSG_RET, "open failed.");
                            dfs_file_unref(file);
                        }
                        else
                        {
                            /* for char/block device */
                            if ((S_ISCHR(file->vnode->mode)) || (S_ISBLK(file->vnode->mode)))
                            {
                                file->fops = file->vnode->fops;
                            }
                        }
                    }
                    else
                    {
                        DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "no permission or fops->open");
                        dfs_file_unref(file);
                        ret = -EPERM;
                    }
                }
                else
                {
                    LOG_I("lookup file:%s failed in file system", path);
                    ret = -ENOENT;
                }
            }
        }
 
        if (ret >= 0 && (oflags & O_TRUNC))
        {
            /* trunc file */
            if (!(fflags & DFS_F_FWRITE) || file->vnode->type == FT_DIRECTORY)
            {
                /* truncate on read a only file or a directory */
                DLOG(msg, "dfs_file", "dfs_file", DLOG_MSG, "dfs_file_unref(file), trunc on RDOnly or directory");
                ret = -RT_ERROR;
            }
            else
            {
                if (file->fops->truncate)
                {
                    DLOG(msg, "dfs_file", dentry->mnt->fs_ops->name, DLOG_MSG, "fops->truncate(file, 0)");
 
                    if (dfs_is_mounted(file->vnode->mnt) == 0)
                    {
#ifdef RT_USING_PAGECACHE
                        if (file->vnode->aspace)
                        {
                            dfs_aspace_clean(file->vnode->aspace);
                        }
#endif
                        ret = file->fops->truncate(file, 0);
                    }
                    else
                    {
                        ret = -EINVAL;
                    }
                }
            }
 
            if (ret < 0)
            {
                dfs_file_unref(file);
            }
 
            file->flags &= ~O_TRUNC;
        }
    }
 
_ERR_RET:
    if (fullpath != NULL)
    {
        rt_free(fullpath);
    }
    return ret;
}

引用了 dfs_vnode::aspace, dfs_filesystem_ops::create_vnode, dfs_filesystem_ops::default_fops, dfs_file::dentry, dfs_dentry_create(), dfs_dentry_insert(), dfs_dentry_lookup(), dfs_dentry_unref(), DFS_F_FREAD, DFS_F_FWRITE, dfs_fflags(), dfs_file_lock(), dfs_file_realpath(), dfs_file_unlock(), dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_LAST, DFS_REALPATH_ONLY_LAST, DLOG, dfs_file::flags, dfs_file::fops, dfs_vnode::fops, dfs_mnt::fs_ops, dfs_mnt::fullpath, LOG_I, dfs_dentry::mnt, dfs_vnode::mnt, dfs_vnode::mode, dfs_filesystem_ops::name, dfs_file_ops::open, RT_FALSE, rt_free(), RT_NULL, RT_TRUE, dfs_file_ops::truncate, dfs_vnode::type, dfs_dentry::vnode , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_close()

int dfs_file_close

(

struct dfs_file *

file

)

在文件 dfs_file.c 第 670 行定义.

{
    int ret = -RT_ERROR;
 
    if (file)
    {
        if (dfs_file_lock() == RT_EOK)
        {
            rt_atomic_t ref_count = rt_atomic_load(&(file->ref_count));
 
            if (ref_count == 1 && file->fops && file->fops->close)
            {
                DLOG(msg, "dfs_file", file->dentry->mnt->fs_ops->name, DLOG_MSG, "fops->close(file)");
#ifdef RT_USING_PAGECACHE
                if (file->vnode->aspace)
                {
                    dfs_aspace_flush(file->vnode->aspace);
                }
#endif
                ret = file->fops->close(file);
 
                if (ret == 0) /* close file sucessfully */
                {
                    DLOG(msg, "dfs_file", "dfs_file", DLOG_MSG, "dfs_file_unref(file)");
                    dfs_file_unref(file);
                }
                else
                {
                    LOG_W("close file:%s failed on low level file system", file->dentry->pathname);
                }
            }
            else
            {
                DLOG(msg, "dfs_file", "dfs_file", DLOG_MSG, "dfs_file_unref(file)");
                dfs_file_unref(file);
                ret = 0;
            }
            dfs_file_unlock();
        }
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, dfs_file_ops::close, dfs_file::dentry, dfs_file_lock(), dfs_file_unlock(), DLOG, dfs_file::fops, dfs_mnt::fs_ops, LOG_W, dfs_dentry::mnt, dfs_filesystem_ops::name, dfs_dentry::pathname, dfs_file::ref_count, dfs_vnode::ref_count, rt_atomic_load , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_pread()

ssize_t dfs_file_pread	(	struct dfs_file *	file,
		void *	buf,
		size_t	len,
		off_t	offset )

在文件 dfs_file.c 第 714 行定义.

{
    ssize_t ret = -EBADF;
 
    if (file)
    {
        /* check whether read */
        if (!(dfs_fflags(file->flags) & DFS_F_FREAD))
        {
            ret = -EPERM;
        }
        else if (!file->fops || !file->fops->read)
        {
            ret = -ENOSYS;
        }
        else if (file->vnode && file->vnode->type != FT_DIRECTORY)
        {
            off_t pos = offset;
 
            ret = rw_verify_area(file, &pos, len);
            if (ret > 0)
            {
                len = ret;
 
                if (dfs_is_mounted(file->vnode->mnt) == 0)
                {
#ifdef RT_USING_PAGECACHE
                    if (file->vnode->aspace && !(file->flags & O_DIRECT))
                    {
                        ret = dfs_aspace_read(file, buf, len, &pos);
                    }
                    else
#endif
                    {
                        ret = file->fops->read(file, buf, len, &pos);
                    }
                }
                else
                {
                    ret = -EINVAL;
                }
            }
        }
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, DFS_F_FREAD, dfs_fflags(), dfs_is_mounted(), dfs_file::flags, dfs_file::fops, dfs_vnode::mnt, dfs_file_ops::read, rw_verify_area(), dfs_vnode::type , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_read()

ssize_t dfs_file_read	(	struct dfs_file *	file,
		void *	buf,
		size_t	len )

在文件 dfs_file.c 第 762 行定义.

{
    ssize_t ret = -EBADF;
 
    if (file)
    {
        /* check whether read */
        if (!(dfs_fflags(file->flags) & DFS_F_FREAD))
        {
            ret = -EPERM;
        }
        else if (!file->fops || !file->fops->read)
        {
            ret = -ENOSYS;
        }
        else if (file->vnode && file->vnode->type != FT_DIRECTORY)
        {
            /* fpos lock */
            off_t pos = dfs_file_get_fpos(file);
 
            ret = rw_verify_area(file, &pos, len);
            if (ret > 0)
            {
                len = ret;
 
                if (dfs_is_mounted(file->vnode->mnt) == 0)
                {
#ifdef RT_USING_PAGECACHE
                    if (file->vnode->aspace && !(file->flags & O_DIRECT))
                    {
                        ret = dfs_aspace_read(file, buf, len, &pos);
                    }
                    else
#endif
                    {
                        ret = file->fops->read(file, buf, len, &pos);
                    }
                }
                else
                {
                    ret = -EINVAL;
                }
            }
            /* fpos unlock */
            dfs_file_set_fpos(file, pos);
        }
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, DFS_F_FREAD, dfs_fflags(), dfs_file_get_fpos(), dfs_file_set_fpos(), dfs_is_mounted(), dfs_file::flags, dfs_file::fops, dfs_vnode::mnt, dfs_file_ops::read, rw_verify_area(), dfs_vnode::type , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_pwrite()

ssize_t dfs_file_pwrite	(	struct dfs_file *	file,
		const void *	buf,
		size_t	len,
		off_t	offset )

在文件 dfs_file.c 第 813 行定义.

{
    ssize_t ret = -EBADF;
 
    if (file)
    {
        if (!(dfs_fflags(file->flags) & DFS_F_FWRITE))
        {
            LOG_W("bad write flags.");
            ret = -EBADF;
        }
        else if (!file->fops || !file->fops->write)
        {
            LOG_W("no fops write.");
            ret = -ENOSYS;
        }
        else if (file->vnode && file->vnode->type != FT_DIRECTORY)
        {
            off_t pos = offset;
 
            ret = rw_verify_area(file, &pos, len);
            if (ret > 0)
            {
                len = ret;
                DLOG(msg, "dfs_file", file->dentry->mnt->fs_ops->name, DLOG_MSG,
                    "dfs_file_write(fd, buf, %d)", len);
 
                if (dfs_is_mounted(file->vnode->mnt) == 0)
                {
#ifdef RT_USING_PAGECACHE
                    if (file->vnode->aspace && !(file->flags & O_DIRECT))
                    {
                        ret = dfs_aspace_write(file, buf, len, &pos);
                    }
                    else
#endif
                    {
                        ret = file->fops->write(file, buf, len, &pos);
                    }
 
                    if (file->flags & O_SYNC)
                    {
                        file->fops->flush(file);
                    }
                }
                else
                {
                    ret = -EINVAL;
                }
            }
        }
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, dfs_file::dentry, DFS_F_FWRITE, dfs_fflags(), dfs_is_mounted(), DLOG, dfs_file::flags, dfs_file_ops::flush, dfs_file::fops, dfs_mnt::fs_ops, LOG_W, dfs_dentry::mnt, dfs_vnode::mnt, dfs_filesystem_ops::name, rw_verify_area(), dfs_vnode::type, dfs_file::vnode , 以及 dfs_file_ops::write.

函数调用图:

这是这个函数的调用关系图:

dfs_file_write()

ssize_t dfs_file_write	(	struct dfs_file *	file,
		const void *	buf,
		size_t	len )

在文件 dfs_file.c 第 869 行定义.

{
    ssize_t ret = -EBADF;
 
    if (file)
    {
        if (!(dfs_fflags(file->flags) & DFS_F_FWRITE))
        {
            LOG_W("bad write flags.");
            ret = -EBADF;
        }
        else if (!file->fops || !file->fops->write)
        {
            LOG_W("no fops write.");
            ret = -ENOSYS;
        }
        else if (file->vnode && file->vnode->type != FT_DIRECTORY)
        {
            off_t pos;
 
            if (!(file->flags & O_APPEND))
            {
                /* fpos lock */
                pos = dfs_file_get_fpos(file);
            }
            else
            {
                pos = file->vnode->size;
            }
 
            ret = rw_verify_area(file, &pos, len);
            if (ret > 0)
            {
                len = ret;
                DLOG(msg, "dfs_file", file->dentry->mnt->fs_ops->name, DLOG_MSG,
                    "dfs_file_write(fd, buf, %d)", len);
 
                if (dfs_is_mounted(file->vnode->mnt) == 0)
                {
#ifdef RT_USING_PAGECACHE
                    if (file->vnode->aspace && !(file->flags & O_DIRECT))
                    {
                        ret = dfs_aspace_write(file, buf, len, &pos);
                    }
                    else
#endif
                    {
                        ret = file->fops->write(file, buf, len, &pos);
                    }
 
                    if (file->flags & O_SYNC)
                    {
                        file->fops->flush(file);
                    }
                }
                else
                {
                    ret = -EINVAL;
                }
            }
            if (!(file->flags & O_APPEND))
            {
                /* fpos unlock */
                dfs_file_set_fpos(file, pos);
            }
        }
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, dfs_file::dentry, DFS_F_FWRITE, dfs_fflags(), dfs_file_get_fpos(), dfs_file_set_fpos(), dfs_is_mounted(), DLOG, dfs_file::flags, dfs_file_ops::flush, dfs_file::fops, dfs_mnt::fs_ops, LOG_W, dfs_dentry::mnt, dfs_vnode::mnt, dfs_filesystem_ops::name, rw_verify_area(), dfs_vnode::size, dfs_vnode::type, dfs_file::vnode , 以及 dfs_file_ops::write.

函数调用图:

这是这个函数的调用关系图:

generic_dfs_lseek()

off_t generic_dfs_lseek	(	struct dfs_file *	file,
		off_t	offset,
		int	whence )

在文件 dfs_file.c 第 940 行定义.

{
    off_t foffset;
 
    if (whence == SEEK_SET)
        foffset = offset;
    else if (whence == SEEK_CUR)
        foffset = file->fpos + offset;
    else if (whence == SEEK_END)
        foffset = file->vnode->size + offset;
    else
        return -EINVAL;
 
    return foffset;
}

引用了 dfs_file::fpos, dfs_vnode::size , 以及 dfs_file::vnode.

dfs_file_lseek()

off_t dfs_file_lseek	(	struct dfs_file *	file,
		off_t	offset,
		int	wherece )

在文件 dfs_file.c 第 956 行定义.

{
    off_t retval = -EINVAL;
 
    if (file && file->fops->lseek)
    {
        if (dfs_is_mounted(file->vnode->mnt) == 0)
        {
            /* fpos lock */
            off_t pos = dfs_file_get_fpos(file);
            retval = file->fops->lseek(file, offset, wherece);
            if (retval >= 0)
            {
                pos = retval;
            }
            /* fpos unlock */
            dfs_file_set_fpos(file, pos);
        }
    }
 
    return retval;
}

引用了 dfs_file_get_fpos(), dfs_file_set_fpos(), dfs_is_mounted(), dfs_file::fops, dfs_file_ops::lseek, dfs_vnode::mnt , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_stat()

int dfs_file_stat	(	const char *	path,
		struct stat *	buf )

在文件 dfs_file.c 第 979 行定义.

{
    int ret = -ENOENT;
    char *fullpath = RT_NULL;
    struct dfs_mnt *mnt = RT_NULL;
    struct dfs_dentry *dentry = RT_NULL;
 
    fullpath = dfs_normalize_path(NULL, path);
    if (fullpath)
    {
        DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
        mnt = dfs_mnt_lookup(fullpath);
        if (mnt)
        {
            char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_NONE);
            if (tmp)
            {
                rt_free(fullpath);
                fullpath = tmp;
            }
 
            DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dentry = dfs_dentry_lookup(mnt, %s)", fullpath);
            dentry = dfs_dentry_lookup(mnt, fullpath, 0);
            if (dentry)
            {
                DLOG(msg, "dentry", "dfs_file", DLOG_MSG_RET, "return dentry");
                if (mnt->fs_ops->stat)
                {
                    DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->stat(dentry, buf)");
 
                    if (dfs_is_mounted(mnt) == 0)
                    {
                        ret = mnt->fs_ops->stat(dentry, buf);
                    }
                }
 
                /* unref dentry */
                DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_unref(dentry)");
                dfs_dentry_unref(dentry);
                dentry = RT_NULL;
            }
        }
 
        rt_free(fullpath);
        fullpath = RT_NULL;
    }
    else
    {
        ret = -ENOMEM;
    }
 
    return ret;
}

引用了 dfs_dentry_lookup(), dfs_dentry_unref(), dfs_file_realpath(), dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_NONE, DLOG, dfs_mnt::fs_ops, dfs_dentry::mnt, dfs_filesystem_ops::name, rt_free(), RT_NULL, dfs_filesystem_ops::stat , 以及 stat().

函数调用图:

这是这个函数的调用关系图:

dfs_file_lstat()

int dfs_file_lstat	(	const char *	path,
		struct stat *	buf )

在文件 dfs_file.c 第 1033 行定义.

{
    int ret = -ENOENT;
    char *fullpath = RT_NULL;
    struct dfs_mnt *mnt = RT_NULL;
    struct dfs_dentry *dentry = RT_NULL;
 
    fullpath = dfs_normalize_path(NULL, path);
    if (fullpath)
    {
        DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
        mnt = dfs_mnt_lookup(fullpath);
        if (mnt)
        {
            char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
            if (tmp)
            {
                rt_free(fullpath);
                fullpath = tmp;
            }
 
            DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dentry = dfs_dentry_lookup(mnt, %s)", fullpath);
            dentry = dfs_dentry_lookup(mnt, fullpath, 0);
            if (dentry)
            {
                DLOG(msg, "dentry", "dfs_file", DLOG_MSG_RET, "return dentry");
                if (mnt->fs_ops->stat)
                {
                    DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->stat(dentry, buf)");
 
                    if (dfs_is_mounted(mnt) == 0)
                    {
                        ret = mnt->fs_ops->stat(dentry, buf);
                    }
                }
 
                /* unref dentry */
                DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_unref(dentry)");
                dfs_dentry_unref(dentry);
                dentry = RT_NULL;
            }
        }
 
        rt_free(fullpath);
        fullpath = RT_NULL;
    }
    else
    {
        ret = -ENOMEM;
    }
 
    rt_set_errno(-ret);
 
    return ret;
}

引用了 dfs_dentry_lookup(), dfs_dentry_unref(), dfs_file_realpath(), dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_LAST, DLOG, dfs_mnt::fs_ops, dfs_dentry::mnt, dfs_filesystem_ops::name, rt_free(), RT_NULL, dfs_filesystem_ops::stat , 以及 stat().

函数调用图:

这是这个函数的调用关系图:

dfs_file_fstat()

int dfs_file_fstat	(	struct dfs_file *	file,
		struct stat *	buf )

在文件 dfs_file.c 第 1089 行定义.

{
    size_t ret = -EBADF;
 
    if (file)
    {
        if (file->fops && file->fops->ioctl)
        {
            // ret = file->fops->fstat(file, buf);
        }
        else
        {
            ret = -ENOSYS;
        }
    }
    else
    {
        ret = -EBADF;
    }
 
    return ret;
}

引用了 dfs_file::fops, dfs_file_ops::ioctl , 以及 stat().

函数调用图:

dfs_file_setattr()

int dfs_file_setattr	(	const char *	path,
		struct dfs_attr *	attr )

在文件 dfs_file.c 第 1112 行定义.

{
    int ret = -RT_ERROR;
    char *fullpath = RT_NULL;
    struct dfs_mnt *mnt = RT_NULL;
    struct dfs_dentry *dentry = RT_NULL;
 
    fullpath = dfs_normalize_path(NULL, path);
    if (fullpath)
    {
        DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
        mnt = dfs_mnt_lookup(fullpath);
        if (mnt)
        {
            char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
            if (tmp)
            {
                rt_free(fullpath);
                fullpath = tmp;
            }
 
            DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dentry = dfs_dentry_lookup(mnt, %s)", fullpath);
            dentry = dfs_dentry_lookup(mnt, fullpath, 0);
            if (dentry)
            {
                DLOG(msg, "dentry", "dfs_file", DLOG_MSG_RET, "return dentry");
                if (mnt->fs_ops->setattr)
                {
                    DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->setattr(dentry, attr)");
 
                    if (dfs_is_mounted(mnt) == 0)
                    {
                        ret = mnt->fs_ops->setattr(dentry, attr);
                    }
                }
 
                /* unref dentry */
                DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_unref(dentry)");
                dfs_dentry_unref(dentry);
                dentry = RT_NULL;
            }
        }
 
        rt_free(fullpath);
        fullpath = RT_NULL;
    }
 
    return ret;
}

引用了 dfs_dentry_lookup(), dfs_dentry_unref(), dfs_file_realpath(), dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_LAST, DLOG, dfs_mnt::fs_ops, dfs_dentry::mnt, dfs_filesystem_ops::name, rt_free(), RT_NULL , 以及 dfs_filesystem_ops::setattr.

函数调用图:

这是这个函数的调用关系图:

dfs_file_ioctl()

int dfs_file_ioctl	(	struct dfs_file *	file,
		int	cmd,
		void *	args )

在文件 dfs_file.c 第 1162 行定义.

{
    size_t ret = 0;
 
    if (file)
    {
        if (file->fops && file->fops->ioctl)
        {
            if (dfs_is_mounted(file->vnode->mnt) == 0)
            {
                ret = file->fops->ioctl(file, cmd, args);
            }
            else
            {
                ret = -EINVAL;
            }
        }
        else
        {
            ret = -ENOSYS;
        }
    }
    else
    {
        ret = -EBADF;
    }
 
    return ret;
}

引用了 dfs_is_mounted(), dfs_file::fops, dfs_file_ops::ioctl, dfs_vnode::mnt , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_fcntl()

int dfs_file_fcntl	(	int	fd,
		int	cmd,
		unsigned long	arg )

在文件 dfs_file.c 第 1192 行定义.

{
    int ret = 0;
    struct dfs_file *file;
 
    file = fd_get(fd);
    if (file)
    {
        switch (cmd)
        {
        case F_DUPFD:
            ret = dfs_dup(fd, arg);
            break;
        case F_GETFD:
            ret = file->mode;
            break;
        case F_SETFD:
            file->mode = arg;
            break;
        case F_GETFL:
            ret = file->flags;
            break;
        case F_SETFL:
        {
            int flags = (int)(rt_base_t)arg;
            int mask =
#ifdef O_ASYNC
                        O_ASYNC |
#endif
#ifdef O_DIRECT
                        O_DIRECT |
#endif
#ifdef O_NOATIME
                        O_NOATIME |
#endif
                        O_APPEND | O_NONBLOCK;
 
            flags &= mask;
            file->flags &= ~mask;
            file->flags |= flags;
            break;
        }
        case F_GETLK:
            break;
        case F_SETLK:
        case F_SETLKW:
            break;
#ifdef RT_USING_MUSLLIBC
        case F_DUPFD_CLOEXEC:
            ret = -EINVAL;
            break;
#endif
        default:
            ret = -EPERM;
            break;
        }
    }
    else
    {
        ret = -EBADF;
    }
 
    return ret;
}

引用了 dfs_dup(), fd_get(), dfs_file::flags , 以及 dfs_file::mode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_fsync()

int dfs_file_fsync

(

struct dfs_file *

file

)

在文件 dfs_file.c 第 1257 行定义.

{
    int ret = -EBADF;
 
    if (file)
    {
        if (file->fops->flush)
        {
            if (dfs_is_mounted(file->vnode->mnt) == 0)
            {
#ifdef RT_USING_PAGECACHE
                if (file->vnode->aspace)
                {
                    dfs_aspace_flush(file->vnode->aspace);
                }
#endif
                ret = file->fops->flush(file);
            }
            else
            {
                ret = -EINVAL;
            }
        }
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, dfs_is_mounted(), dfs_file_ops::flush, dfs_file::fops, dfs_vnode::mnt , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_unlink()

int dfs_file_unlink

(

const char *

path

)

在文件 dfs_file.c 第 1285 行定义.

{
    int ret = -RT_ERROR;
    char *fullpath = RT_NULL;
    struct dfs_mnt *mnt = RT_NULL;
    struct dfs_dentry *dentry = RT_NULL;
 
    fullpath = dfs_normalize_path(NULL, path);
    if (fullpath)
    {
        DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
        mnt = dfs_mnt_lookup(fullpath);
        if (mnt)
        {
            char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
            if (tmp)
            {
                rt_free(fullpath);
                fullpath = tmp;
            }
 
            if (strcmp(mnt->fullpath, fullpath) != 0)
            {
                DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", fullpath);
                dentry = dfs_dentry_lookup(mnt, fullpath, 0);
                if (dentry)
                {
                    rt_bool_t has_child = RT_FALSE;
 
                    has_child = dfs_mnt_has_child_mnt(mnt, fullpath);
#ifdef RT_USING_PAGECACHE
                    if (dentry->vnode->aspace)
                    {
                        dfs_aspace_clean(dentry->vnode->aspace);
                    }
#endif
                    dfs_file_lock();
 
                    if (has_child == RT_FALSE)
                    {
                        /* no child mnt point, unlink it */
                        ret = -RT_ERROR;
 
                        if (mnt->fs_ops->unlink)
                        {
                            if (dfs_is_mounted(mnt) == 0)
                            {
                                ret = mnt->fs_ops->unlink(dentry);
                            }
                        }
                    }
                    else
                    {
                        ret = -EBUSY;
                    }
                    dfs_file_unlock();
 
                    /* release this dentry */
                    dfs_dentry_unref(dentry);
                }
                else
                {
                    /* no this entry */
                    ret = -ENOENT;
                }
            }
            else
            {
                /* it's a mount point, failed for busy */
                ret = -EBUSY;
            }
        }
        else
        {
            ret = -ENOENT;
        }
 
        /* release fullpath */
        rt_free(fullpath);
    }
    else
    {
        ret = -ENOMEM;
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, dfs_dentry_lookup(), dfs_dentry_unref(), dfs_file_lock(), dfs_file_realpath(), dfs_file_unlock(), dfs_is_mounted(), dfs_mnt_has_child_mnt(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_LAST, DLOG, dfs_mnt::fs_ops, dfs_mnt::fullpath, dfs_dentry::mnt, RT_FALSE, rt_free(), RT_NULL, dfs_filesystem_ops::unlink , 以及 dfs_dentry::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_link()

int dfs_file_link	(	const char *	oldname,
		const char *	newname )

在文件 dfs_file.c 第 1373 行定义.

{
    int ret = -1;
    struct stat stat;
    struct dfs_mnt *mnt = RT_NULL;
    char *old_fullpath, *new_fullpath;
 
    if (dfs_file_isdir(oldname) == 0)
    {
        rt_set_errno(-EPERM);
        return ret;
    }
 
    if (dfs_file_lstat(newname, &stat) >= 0)
    {
        return ret;
    }
 
    old_fullpath = dfs_normalize_path(NULL, oldname);
    if (old_fullpath)
    {
        DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", old_fullpath);
        mnt = dfs_mnt_lookup(old_fullpath);
        if (mnt == RT_NULL)
        {
            rt_free(old_fullpath);
            return -1;
        }
 
        char *tmp = dfs_file_realpath(&mnt, old_fullpath, DFS_REALPATH_EXCEPT_LAST);
        if (tmp)
        {
            rt_free(old_fullpath);
            old_fullpath = tmp;
        }
    }
 
    new_fullpath = dfs_normalize_path(NULL, newname);
    if (new_fullpath)
    {
        char *tmp = dfs_file_realpath(&mnt, new_fullpath, DFS_REALPATH_EXCEPT_LAST);
        if (tmp)
        {
            rt_free(new_fullpath);
            new_fullpath = tmp;
        }
    }
 
    if (old_fullpath && new_fullpath)
    {
        struct dfs_dentry *old_dentry, *new_dentry;
 
        DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", old_fullpath);
        old_dentry = dfs_dentry_lookup(mnt, old_fullpath, 0);
        DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_create(%s)", new_fullpath);
        new_dentry = dfs_dentry_create(mnt, new_fullpath);
 
        if (old_dentry && new_dentry)
        {
            if (mnt->fs_ops->link)
            {
                if (dfs_is_mounted(mnt) == 0)
                {
                    ret = mnt->fs_ops->link(old_dentry, new_dentry);
                }
            }
        }
 
        dfs_dentry_unref(old_dentry);
        dfs_dentry_unref(new_dentry);
    }
 
    if (old_fullpath)
    {
        rt_free(old_fullpath);
    }
 
    if (new_fullpath)
    {
        rt_free(new_fullpath);
    }
 
    return ret;
}

引用了 dfs_dentry_create(), dfs_dentry_lookup(), dfs_dentry_unref(), dfs_file_isdir(), dfs_file_lstat(), dfs_file_realpath(), dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_LAST, DLOG, dfs_mnt::fs_ops, dfs_filesystem_ops::link, dfs_dentry::mnt, rt_free(), RT_NULL , 以及 stat().

函数调用图:

dfs_file_symlink()

int dfs_file_symlink	(	const char *	target,
		const char *	linkpath )

在文件 dfs_file.c 第 1459 行定义.

{
    int ret = -RT_ERROR;
    char *fullpath = RT_NULL, *parent = RT_NULL;
    struct dfs_mnt *mnt = RT_NULL;
    struct dfs_dentry *dentry = RT_NULL;
 
    if (target && linkpath)
    {
        if (linkpath[0] != '/')
        {
           fullpath = dfs_normalize_path(NULL, linkpath);
        }
        else
        {
            fullpath = (char*)linkpath;
        }
 
        /* linkpath should be not exist */
        if (dfs_file_access(fullpath, O_RDONLY) != 0)
        {
            char *index;
 
            /* get parent path */
            index = strrchr(fullpath, '/');
            if (index)
            {
                int length = index - fullpath;
                if (length > 0)
                {
                    parent = (char*) rt_malloc (length + 1);
                    if (parent)
                    {
                        memcpy(parent, fullpath, length);
                        parent[length] = '\0';
                    }
                }
                else
                {
                    parent = (char*) rt_malloc (1 + 1);
                    if (parent)
                    {
                        parent[0] = '/';
                        parent[1] = '\0';
                    }
                }
            }
 
            if (parent)
            {
                DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
                mnt = dfs_mnt_lookup(parent);
                if (mnt)
                {
                    char *tmp = dfs_file_realpath(&mnt, parent, DFS_REALPATH_EXCEPT_LAST);
                    if (tmp)
                    {
                        rt_free(parent);
                        parent = tmp;
                    }
 
                    DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", fullpath);
                    dentry = dfs_dentry_lookup(mnt, parent, DFS_REALPATH_EXCEPT_LAST);
                    if (dentry)
                    {
                        if (dentry->mnt->fs_ops->symlink)
                        {
                            char *path = dfs_normalize_path(parent, target);
                            if (path)
                            {
                                ret = rt_strncmp(parent, path, strlen(parent));
                                if (ret == 0)
                                {
                                    tmp = path + strlen(parent);
                                    if (*tmp == '/')
                                    {
                                        tmp ++;
                                    }
                                }
                                else
                                {
                                    tmp = path;
                                }
 
                                if (dfs_is_mounted(mnt) == 0)
                                {
                                    ret = mnt->fs_ops->symlink(dentry, tmp, index + 1);
                                }
 
                                rt_free(path);
                            }
                        }
                        else
                        {
                            ret = -ENOSYS;
                        }
 
                        dfs_dentry_unref(dentry);
                    }
                    else
                    {
                        ret = -ENOENT;
                    }
                }
                else
                {
                    ret = -ENOENT;
                }
 
                rt_free(parent);
            }
        }
        else
        {
            rt_set_errno(-EPERM);
        }
 
        if (fullpath != linkpath)
            rt_free(fullpath);
    }
    else
    {
        ret = -EINVAL;
    }
 
    return ret;
}

引用了 dfs_dentry_lookup(), dfs_dentry_unref(), dfs_file_access(), dfs_file_realpath(), dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_LAST, DLOG, dfs_mnt::fs_ops, dfs_dentry::mnt, rt_free(), rt_malloc(), RT_NULL , 以及 dfs_filesystem_ops::symlink.

函数调用图:

dfs_file_readlink()

int dfs_file_readlink	(	const char *	path,
		char *	buf,
		int	bufsize )

在文件 dfs_file.c 第 1587 行定义.

{
    int ret = -RT_ERROR;
    char *fullpath = RT_NULL;
    struct dfs_mnt *mnt = RT_NULL;
    struct dfs_dentry *dentry = RT_NULL;
 
    fullpath = dfs_normalize_path(NULL, path);
    if (fullpath)
    {
        DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
        mnt = dfs_mnt_lookup(fullpath);
        if (mnt)
        {
            char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
            if (tmp)
            {
                rt_free(fullpath);
                fullpath = tmp;
            }
 
            DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", fullpath);
            dentry = dfs_dentry_lookup(mnt, fullpath, 0);
            if (dentry)
            {
                if (mnt->fs_ops->readlink)
                {
                    if (dfs_is_mounted(mnt) == 0)
                    {
                        ret = mnt->fs_ops->readlink(dentry, buf, bufsize);
                    }
                }
                else
                {
                    ret = -ENOSYS;
                }
 
                /* release this dentry */
                dfs_dentry_unref(dentry);
            }
            else
            {
                /* no this entry */
                ret = -ENOENT;
            }
        }
        else
        {
            ret = -ENOENT;
        }
 
        /* release fullpath */
        rt_free(fullpath);
    }
    else
    {
        ret = -ENOMEM;
    }
 
    return ret;
}

引用了 dfs_dentry_lookup(), dfs_dentry_unref(), dfs_file_realpath(), dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_LAST, DLOG, dfs_mnt::fs_ops, dfs_dentry::mnt, dfs_filesystem_ops::readlink, rt_free() , 以及 RT_NULL.

函数调用图:

这是这个函数的调用关系图:

dfs_file_rename()

int dfs_file_rename	(	const char *	old_file,
		const char *	new_file )

在文件 dfs_file.c 第 1649 行定义.

{
    int ret = -1;
    struct dfs_mnt *mnt = RT_NULL;
    char *old_fullpath, *new_fullpath;
 
    old_fullpath = dfs_normalize_path(NULL, old_file);
    if (old_fullpath)
    {
        DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", old_fullpath);
        mnt = dfs_mnt_lookup(old_fullpath);
        if (mnt == RT_NULL)
        {
            rt_free(old_fullpath);
            return -1;
        }
 
        char *tmp = dfs_file_realpath(&mnt, old_fullpath, DFS_REALPATH_EXCEPT_LAST);
        if (tmp)
        {
            rt_free(old_fullpath);
            old_fullpath = tmp;
        }
    }
 
    new_fullpath = dfs_normalize_path(NULL, new_file);
    if (new_fullpath)
    {
        char *tmp = dfs_file_realpath(&mnt, new_fullpath, DFS_REALPATH_EXCEPT_LAST);
        if (tmp)
        {
            rt_free(new_fullpath);
            new_fullpath = tmp;
        }
    }
 
    if (old_fullpath && new_fullpath)
    {
        struct dfs_dentry *old_dentry, *new_dentry;
 
        DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_lookup(mnt, %s)", old_fullpath);
        old_dentry = dfs_dentry_lookup(mnt, old_fullpath, 0);
        DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_create(%s)", new_fullpath);
        new_dentry = dfs_dentry_create(mnt, new_fullpath);
 
        if (old_dentry && new_dentry)
        {
            if (mnt->fs_ops->rename)
            {
                if (dfs_is_mounted(mnt) == 0)
                {
#ifdef RT_USING_PAGECACHE
                    if (old_dentry->vnode->aspace)
                    {
                        dfs_aspace_clean(old_dentry->vnode->aspace);
                    }
#endif
                    ret = mnt->fs_ops->rename(old_dentry, new_dentry);
                }
            }
        }
 
        dfs_dentry_unref(old_dentry);
        dfs_dentry_unref(new_dentry);
    }
 
    if (old_fullpath)
    {
        rt_free(old_fullpath);
    }
 
    if (new_fullpath)
    {
        rt_free(new_fullpath);
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, dfs_dentry_create(), dfs_dentry_lookup(), dfs_dentry_unref(), dfs_file_realpath(), dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_LAST, DLOG, dfs_mnt::fs_ops, dfs_dentry::mnt, dfs_filesystem_ops::rename, rt_free(), RT_NULL , 以及 dfs_dentry::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_ftruncate()

int dfs_file_ftruncate	(	struct dfs_file *	file,
		off_t	length )

在文件 dfs_file.c 第 1728 行定义.

{
    int ret = 0;
 
    if (file)
    {
        if (file->fops->truncate)
        {
            if (dfs_is_mounted(file->vnode->mnt) == 0)
            {
#ifdef RT_USING_PAGECACHE
                if (file->vnode->aspace)
                {
                    dfs_aspace_clean(file->vnode->aspace);
                }
#endif
                ret = file->fops->truncate(file, length);
            }
            else
            {
                ret = -EINVAL;
            }
        }
        else
        {
            ret = -ENOSYS;
        }
    }
    else
    {
        ret = -EBADF;
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, dfs_is_mounted(), dfs_file::fops, dfs_vnode::mnt, dfs_file_ops::truncate , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_flush()

int dfs_file_flush

(

struct dfs_file *

file

)

在文件 dfs_file.c 第 1764 行定义.

{
    int ret = 0;
 
    if (file)
    {
        if (file->fops->flush)
        {
            if (dfs_is_mounted(file->vnode->mnt) == 0)
            {
#ifdef RT_USING_PAGECACHE
                if (file->vnode->aspace)
                {
                    dfs_aspace_flush(file->vnode->aspace);
                }
#endif
                ret = file->fops->flush(file);
            }
            else
            {
                ret = -EINVAL;
            }
        }
        else
        {
            ret = -ENOSYS;
        }
    }
    else
    {
        ret = -EBADF;
    }
 
    return ret;
}

引用了 dfs_vnode::aspace, dfs_is_mounted(), dfs_file_ops::flush, dfs_file::fops, dfs_vnode::mnt , 以及 dfs_file::vnode.

函数调用图:

dfs_file_getdents()

int dfs_file_getdents	(	struct dfs_file *	file,
		struct dirent *	dirp,
		size_t	nbytes )

在文件 dfs_file.c 第 1800 行定义.

{
    int ret = -RT_ERROR;
 
    if (file)
    {
        if (file->vnode && S_ISDIR(file->vnode->mode))
        {
            if (file->fops && file->fops->getdents)
            {
                DLOG(msg, "dfs_file", file->dentry->mnt->fs_ops->name, DLOG_MSG, "fops->getdents()");
 
                if (dfs_is_mounted(file->vnode->mnt) == 0)
                {
                    ret = file->fops->getdents(file, dirp, nbytes);
                }
                else
                {
                    ret = -EINVAL;
                }
            }
        }
    }
    else
    {
        ret = -EBADF;
    }
 
    return ret;
}

引用了 dfs_file::dentry, dfs_is_mounted(), DLOG, dfs_file::fops, dfs_mnt::fs_ops, dfs_file_ops::getdents, dfs_dentry::mnt, dfs_vnode::mnt, dfs_vnode::mode, dfs_filesystem_ops::name , 以及 dfs_file::vnode.

函数调用图:

这是这个函数的调用关系图:

dfs_file_isdir()

int dfs_file_isdir

(

const char *

path

)

this function will check the path is it a directory.

参数

path	the file path.

返回

0 on is dir, -1 on not dir.

在文件 dfs_file.c 第 1838 行定义.

{
    int ret = -RT_ERROR;
    char *fullpath = RT_NULL;
    struct dfs_mnt *mnt = RT_NULL;
    struct dfs_dentry *dentry = RT_NULL;
 
    fullpath = dfs_normalize_path(NULL, path);
    if (fullpath)
    {
        DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
        mnt = dfs_mnt_lookup(fullpath);
        if (mnt)
        {
            char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_NONE);
            if (tmp)
            {
                rt_free(fullpath);
                fullpath = tmp;
            }
 
            DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dentry = dfs_dentry_lookup(mnt, %s)", fullpath);
            dentry = dfs_dentry_lookup(mnt, fullpath, 0);
            if (dentry)
            {
                DLOG(msg, "dentry", "dfs_file", DLOG_MSG_RET, "return dentry");
                if (mnt->fs_ops->stat)
                {
                    struct stat stat = {0};
                    DLOG(msg, "dfs_file", mnt->fs_ops->name, DLOG_MSG, "fs_ops->stat(dentry, buf)");
 
                    if (dfs_is_mounted(mnt) == 0)
                    {
                        ret = mnt->fs_ops->stat(dentry, &stat);
                    }
 
                    if (ret == RT_EOK && S_ISDIR(stat.st_mode))
                    {
                        ret = RT_EOK;
                    }
                    else
                    {
                        ret = -RT_ERROR;
                    }
                }
 
                /* unref dentry */
                DLOG(msg, "dfs_file", "dentry", DLOG_MSG, "dfs_dentry_unref(dentry)");
                dfs_dentry_unref(dentry);
                dentry = RT_NULL;
            }
        }
 
        rt_free(fullpath);
        fullpath = RT_NULL;
    }
 
    return ret;
}

引用了 dfs_dentry_lookup(), dfs_dentry_unref(), dfs_file_realpath(), dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_REALPATH_EXCEPT_NONE, DLOG, dfs_mnt::fs_ops, dfs_dentry::mnt, dfs_filesystem_ops::name, rt_free(), RT_NULL, dfs_filesystem_ops::stat , 以及 stat().

函数调用图:

这是这个函数的调用关系图:

dfs_file_access()

int dfs_file_access	(	const char *	path,
		mode_t	mode )

在文件 dfs_file.c 第 1898 行定义.

{
    int ret;
    struct dfs_file file;
 
    dfs_file_init(&file);
 
    if (dfs_file_open(&file, path, O_RDONLY, mode) >= 0)
    {
        ret = 0;
        dfs_file_close(&file);
    }
    else
    {
        ret = -1;
    }
 
    dfs_file_deinit(&file);
 
    return ret;
}

引用了 dfs_file_close(), dfs_file_deinit(), dfs_file_init(), dfs_file_open() , 以及 dfs_file::mode.

函数调用图:

这是这个函数的调用关系图:

ls()

void ls

(

const char *

pathname

)

在文件 dfs_file.c 第 1973 行定义.

{
    struct dirent dirent;
    struct stat stat;
    int length;
    char *fullpath, *path;
    struct dfs_file file;
 
    if (pathname == NULL)
    {
#ifdef DFS_USING_WORKDIR
        /* open current working directory */
        path = rt_strdup(working_directory);
#else
        path = rt_strdup("/");
#endif
        if (path == NULL)
        {
            return; /* out of memory */
        }
    }
    else
    {
        path = dfs_normalize_path(NULL, (char *)pathname);
        if (path == NULL)
        {
            return; /* out of memory */
        }
    }
 
    dfs_file_init(&file);
 
    /* list directory */
    DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_open(%s, O_DIRECTORY, 0)", path);
    if (dfs_file_open(&file, path, O_DIRECTORY, 0) >= 0)
    {
        char *link_fn = (char *)rt_malloc(DFS_PATH_MAX);
        if (link_fn)
        {
            rt_kprintf("Directory %s:\n", path);
            do
            {
                memset(&dirent, 0, sizeof(struct dirent));
 
                DLOG(group, "foreach_item");
                DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_getdents(&dirent)");
                length = dfs_file_getdents(&file, &dirent, sizeof(struct dirent));
                if (length > 0)
                {
                    DLOG(msg, "dfs_file", "dfs", DLOG_MSG_RET, "dirent.d_name=%s", dirent.d_name);
                    memset(&stat, 0, sizeof(struct stat));
 
                    /* build full path for each file */
                    fullpath = dfs_normalize_path(path, dirent.d_name);
                    if (fullpath == NULL)
                        break;
 
                    DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_lstat(%s, &stat)", fullpath);
                    if (dfs_file_lstat(fullpath, &stat) == 0)
                    {
                        if (S_ISDIR(stat.st_mode))
                        {
                            rt_kprintf(_COLOR_BLUE "%-20s" _COLOR_NORMAL, dirent.d_name);
                            rt_kprintf("%-25s\n", "<DIR>");
                        }
                        else if (S_ISLNK(stat.st_mode))
                        {
                            int ret = 0;
 
                            rt_kprintf(_COLOR_CYAN "%-20s" _COLOR_NORMAL, dirent.d_name);
 
                            ret = dfs_file_readlink(fullpath, link_fn, DFS_PATH_MAX);
                            if (ret > 0)
                            {
                                char *link_path = link_fn;
                                struct dfs_mnt *mnt = RT_NULL;
 
                                mnt = dfs_mnt_lookup(fullpath);
                                if (mnt)
                                {
                                    char *tmp = dfs_file_realpath(&mnt, fullpath, DFS_REALPATH_EXCEPT_LAST);
                                    if (tmp)
                                    {
                                        char *index;
 
                                        index = strrchr(fullpath, '/');
                                        if (index)
                                        {
                                            int length = index - fullpath;
                                            char *parent = (char*) rt_malloc (length + 1);
                                            if (parent)
                                            {
                                                rt_memcpy(parent, fullpath, length);
                                                parent[length] = '\0';
 
                                                ret = rt_strncmp(parent, link_fn, length);
                                                if (ret == 0)
                                                {
                                                    link_path = link_fn + length;
                                                    if (*link_path == '/')
                                                    {
                                                        link_path ++;
                                                    }
                                                }
                                                rt_free(parent);
                                            }
                                        }
                                        rt_free(tmp);
                                    }
                                }
 
                                rt_kprintf("-> %s\n", link_path);
                            }
                            else
                            {
                                rt_kprintf(_COLOR_RED "-> link_error\n" _COLOR_NORMAL);
                            }
                        }
                        else if (stat.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
                        {
                            rt_kprintf(_COLOR_GREEN "%-20s" _COLOR_NORMAL, dirent.d_name);
                            rt_kprintf("%-25lu\n", (unsigned long)stat.st_size);
                        }
                        else if (S_ISCHR(stat.st_mode))
                        {
                            rt_kprintf(_COLOR_YELLOW "%-20s" _COLOR_NORMAL, dirent.d_name);
                            rt_kprintf("%-25s\n", "<CHR>");
                        }
                        else
                        {
                            rt_kprintf("%-20s", dirent.d_name);
                            rt_kprintf("%-25lu\n", (unsigned long)stat.st_size);
                        }
                    }
                    else
                    {
                        rt_kprintf(_COLOR_RED "%-20s\n" _COLOR_NORMAL, dirent.d_name);
                    }
 
                    rt_free(fullpath);
                }
                else
                {
                    DLOG(msg, "dfs_file", "dfs", DLOG_MSG_RET, "return NULL");
                }
 
                DLOG(group_end);
            } while (length > 0);
 
            rt_free(link_fn);
        }
 
        DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_close()");
        dfs_file_close(&file);
    }
    else
    {
        rt_kprintf("No such directory\n");
    }
 
    dfs_file_deinit(&file);
 
    DLOG(msg, "dfs_file", "dfs", DLOG_MSG_RET, "return");
    rt_free(path);
}

引用了 _COLOR_BLUE, _COLOR_CYAN, _COLOR_GREEN, _COLOR_NORMAL, _COLOR_RED, _COLOR_YELLOW, dfs_file_close(), dfs_file_deinit(), dfs_file_getdents(), dfs_file_init(), dfs_file_lstat(), dfs_file_open(), dfs_file_readlink(), dfs_file_realpath(), dfs_mnt_lookup(), dfs_normalize_path(), DFS_PATH_MAX, DFS_REALPATH_EXCEPT_LAST, DLOG, dfs_mnt::fullpath, dfs_mnt::parent, rt_free(), rt_kprintf, rt_malloc(), RT_NULL, stat() , 以及 working_directory.

函数调用图:

cat()

void cat

(

const char *

filename

)

在文件 dfs_file.c 第 2139 行定义.

{
    int length = 0;
    char buffer[81];
    struct dfs_file file;
 
    if (filename && dfs_file_isdir(filename) == 0)
    {
        rt_kprintf("cat: %s Is a directory\n", filename);
        return;
    }
 
    dfs_file_init(&file);
 
    DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_open(%s, O_RDONLY, 0)", filename);
    if (dfs_file_open(&file, filename, O_RDONLY, 0) < 0)
    {
        rt_kprintf("Open %s failed\n", filename);
        dfs_file_deinit(&file);
        return;
    }
 
    do
    {
        rt_memset(buffer, 0x0, sizeof(buffer));
        DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_read(fd, buffer, %d)", sizeof(buffer) - 1);
        length = dfs_file_read(&file, (void *)buffer, sizeof(buffer) - 1);
        if (length > 0)
        {
            buffer[length] = '\0';
            rt_kprintf("%s", buffer);
        }
    } while (length > 0);
    rt_kprintf("\n");
 
    DLOG(msg, "dfs", "dfs_file", DLOG_MSG, "dfs_file_close()");
    dfs_file_close(&file);
    dfs_file_deinit(&file);
}

引用了 dfs_file_close(), dfs_file_deinit(), dfs_file_init(), dfs_file_isdir(), dfs_file_open(), dfs_file_read(), DLOG , 以及 rt_kprintf.

函数调用图:

copy()

void copy	(	const char *	src,
		const char *	dst )

在文件 dfs_file.c 第 2321 行定义.

{
#define FLAG_SRC_TYPE      0x03
#define FLAG_SRC_IS_DIR    0x01
#define FLAG_SRC_IS_FILE   0x02
#define FLAG_SRC_NON_EXSIT 0x00
 
#define FLAG_DST_TYPE      0x0C
#define FLAG_DST_IS_DIR    0x04
#define FLAG_DST_IS_FILE   0x08
#define FLAG_DST_NON_EXSIT 0x00
 
    struct stat stat;
    uint32_t flag = 0;
 
    /* check the staus of src and dst */
    if (dfs_file_lstat(src, &stat) < 0)
    {
        rt_kprintf("copy failed, bad %s\n", src);
        return;
    }
    if (S_ISDIR(stat.st_mode))
        flag |= FLAG_SRC_IS_DIR;
    else
        flag |= FLAG_SRC_IS_FILE;
 
    if (dfs_file_stat(dst, &stat) < 0)
    {
        flag |= FLAG_DST_NON_EXSIT;
    }
    else
    {
        if (S_ISDIR(stat.st_mode))
            flag |= FLAG_DST_IS_DIR;
        else
            flag |= FLAG_DST_IS_FILE;
    }
 
    //2. check status
    if ((flag & FLAG_SRC_IS_DIR) && (flag & FLAG_DST_IS_FILE))
    {
        rt_kprintf("cp faild, cp dir to file is not permitted!\n");
        return ;
    }
 
    //3. do copy
    if (flag & FLAG_SRC_IS_FILE)
    {
        if (flag & FLAG_DST_IS_DIR)
        {
            char *fdst;
            fdst = dfs_normalize_path(dst, _get_path_lastname(src));
            if (fdst == NULL)
            {
                rt_kprintf("out of memory\n");
                return;
            }
            copyfile(src, fdst);
            rt_free(fdst);
        }
        else
        {
            copyfile(src, dst);
        }
    }
    else //flag & FLAG_SRC_IS_DIR
    {
        if (flag & FLAG_DST_IS_DIR)
        {
            char *fdst;
            fdst = dfs_normalize_path(dst, _get_path_lastname(src));
            if (fdst == NULL)
            {
                rt_kprintf("out of memory\n");
                return;
            }
            mkdir(fdst, 0);
            copydir(src, fdst);
            rt_free(fdst);
        }
        else if ((flag & FLAG_DST_TYPE) == FLAG_DST_NON_EXSIT)
        {
            mkdir(dst, 0);
            copydir(src, dst);
        }
        else
        {
            copydir(src, dst);
        }
    }
}

引用了 dfs_file_lstat(), dfs_file_stat(), dfs_normalize_path(), FLAG_DST_IS_DIR, FLAG_DST_IS_FILE, FLAG_DST_NON_EXSIT, FLAG_DST_TYPE, FLAG_SRC_IS_DIR, FLAG_SRC_IS_FILE, mkdir(), rt_free(), rt_kprintf , 以及 stat().

函数调用图: