dfs_fs.c 文件参考

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

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

浏览该文件的源代码.

宏定义
#define	DBG_TAG   "DFS.fs"
#define	DBG_LVL   DBG_INFO
#define	REMNT_UNSUPP_FLAGS   (~(MS_REMOUNT | MS_RMT_MASK))
#define	DPT_ADDRESS   0x1be /* device partition offset in Boot Sector */
#define	DPT_ITEM_SIZE   16 /* partition item size */

函数
struct dfs_filesystem_type *	dfs_filesystems (void)
int	dfs_register (struct dfs_filesystem_type *fs)
int	dfs_unregister (struct dfs_filesystem_type *fs)
int	dfs_remount (const char *path, rt_ubase_t flags, void *data)
int	dfs_mount (const char *device_name, const char *path, const char *filesystemtype, unsigned long rwflag, const void *data)
int	dfs_umount (const char *specialfile, int flags)
int	dfs_unmount (const char *specialfile)
int	dfs_is_mounted (struct dfs_mnt *mnt)
int	dfs_mkfs (const char *fs_name, const char *device_name)
int	dfs_statfs (const char *path, struct statfs *buffer)
const char *	dfs_filesystem_get_mounted_path (struct rt_device *device)
int	dfs_filesystem_get_partition (struct dfs_partition *part, uint8_t *buf, uint32_t pindex)

变量
rt_list_t	_mnt_list

宏定义说明

DBG_TAG

#define DBG_TAG   "DFS.fs"

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

DBG_LVL

#define DBG_LVL   DBG_INFO

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

REMNT_UNSUPP_FLAGS

#define REMNT_UNSUPP_FLAGS   (~(MS_REMOUNT | MS_RMT_MASK))

在文件 dfs_fs.c 第 98 行定义.

DPT_ADDRESS

#define DPT_ADDRESS   0x1be /* device partition offset in Boot Sector */

DPT_ITEM_SIZE

#define DPT_ITEM_SIZE   16 /* partition item size */

函数说明

dfs_filesystems()

struct dfs_filesystem_type * dfs_filesystems

(

void

)

在文件 dfs_fs.c 第 50 行定义.

{
    return file_systems;
}

dfs_register()

int dfs_register

(

struct dfs_filesystem_type *

fs

)

在文件 dfs_fs.c 第 55 行定义.

{
    int ret = 0;
    struct dfs_filesystem_type **type = _find_filesystem(fs->fs_ops->name);
 
    LOG_D("register %s file system.", fs->fs_ops->name);
 
    if (*type)
    {
        ret = -EBUSY;
    }
    else
    {
        *type = fs;
    }
 
    return ret;
}

引用了 dfs_filesystem_type::fs_ops, LOG_D , 以及 dfs_filesystem_ops::name.

dfs_unregister()

int dfs_unregister

(

struct dfs_filesystem_type *

fs

)

在文件 dfs_fs.c 第 74 行定义.

{
    int ret = 0;
    struct dfs_filesystem_type **type;
 
    if (fs)
    {
        LOG_D("unregister %s file system.", fs->fs_ops->name);
 
        for (type = &file_systems; *type; type = &(*type)->next)
        {
            if (strcmp((*type)->fs_ops->name, fs->fs_ops->name) == 0)
            {
                *type = (*type)->next;
                break;
            }
        }
 
        if (!*type) ret = -EINVAL;
    }
 
    return ret;
}

引用了 dfs_filesystem_type::fs_ops, LOG_D, dfs_filesystem_ops::name , 以及 dfs_filesystem_type::next.

dfs_remount()

int dfs_remount	(	const char *	path,
		rt_ubase_t	flags,
		void *	data )

在文件 dfs_fs.c 第 99 行定义.

{
    int rc = 0;
    char *fullpath = RT_NULL;
    struct dfs_mnt *mnt = RT_NULL;
 
    if (flags & REMNT_UNSUPP_FLAGS)
    {
        return -EINVAL;
    }
 
    fullpath = dfs_normalize_path(RT_NULL, path);
    if (!fullpath)
    {
        rc = -ENOENT;
    }
    else
    {
        DLOG(msg, "dfs", "mnt", DLOG_MSG, "mnt = dfs_mnt_lookup(%s)", fullpath);
        mnt = dfs_mnt_lookup(fullpath);
        if (mnt)
        {
            dfs_lock();
            dfs_mnt_setflags(mnt, flags);
            dfs_unlock();
        }
        else
        {
            struct stat buf = {0};
            if (dfs_file_stat(fullpath, &buf) == 0 && S_ISBLK(buf.st_mode))
            {
                /* path was not already mounted on target */
                rc = -EINVAL;
            }
            else
            {
                /* path is not a directory */
                rc = -ENOTDIR;
            }
        }
    }
 
    return rc;
}

引用了 dfs_file_stat(), dfs_lock(), dfs_mnt_lookup(), dfs_mnt_setflags(), dfs_normalize_path(), dfs_unlock(), DLOG, dfs_mnt::flags, dfs_mnt::fullpath, REMNT_UNSUPP_FLAGS, RT_NULL , 以及 stat().

函数调用图:

dfs_mount()

int dfs_mount	(	const char *	device_name,
		const char *	path,
		const char *	filesystemtype,
		unsigned long	rwflag,
		const void *	data )

在文件 dfs_fs.c 第 152 行定义.

{
    int ret = RT_EOK;
    char *fullpath = RT_NULL;
    rt_device_t dev_id = RT_NULL;
    struct dfs_mnt *mnt_parent = RT_NULL, *mnt_child = RT_NULL;
    struct dfs_dentry *mntpoint_dentry = RT_NULL;
    struct dfs_filesystem_type *type = *_find_filesystem(filesystemtype);
 
    if (type)
    {
        fullpath = dfs_normalize_path(RT_NULL, path);
        if (!fullpath)
        {
            rt_set_errno(EPERM);
            ret = -1;
        }
    }
    else
    {
        rt_set_errno(ENODEV);
        ret = -1;
    }
 
    if (fullpath)
    {
        DLOG(note, "mnt", "mount %s(%s) on path: %s", device_name, filesystemtype, fullpath);
 
        /* open specific device */
        if (device_name) dev_id = rt_device_find(device_name);
 
        if (!(type->fs_ops->flags & FS_NEED_DEVICE) ||
            ((type->fs_ops->flags & FS_NEED_DEVICE) && dev_id))
        {
            DLOG(msg, "dfs", "mnt", DLOG_MSG, "mnt_parent = dfs_mnt_lookup(%s)", fullpath);
            mnt_parent = dfs_mnt_lookup(fullpath);
            if ((!mnt_parent && (strcmp(fullpath, "/") == 0 || strcmp(fullpath, "/dev") == 0))
                || (mnt_parent && strcmp(fullpath, "/") == 0 && strcmp(mnt_parent->fullpath, fullpath) != 0))
            {
                LOG_D("no mnt found @ mount point %s, should be root.", fullpath);
                DLOG(msg, "mnt", "dfs", DLOG_MSG_RET, "no mnt");
 
                /* it's the root file system */
                /* the mount point dentry is the same as root dentry. */
 
                DLOG(msg, "dfs", "mnt", DLOG_MSG, "mnt_parent = dfs_mnt_create(path)");
                mnt_parent = dfs_mnt_create(fullpath); /* mnt->ref_count should be 1. */
                if (mnt_parent)
                {
                    DLOG(msg, "mnt", "dfs", DLOG_MSG_RET, "return mnt, ref_count=1");
 
                    mnt_parent->fs_ops = type->fs_ops;
                    mnt_parent->dev_id = dev_id;
                    if (mnt_parent->fs_ops->mount)
                    {
                        DLOG(msg, "dfs", type->fs_ops->name, DLOG_MSG, "fs_ops->mount(mnt_parent, rwflag, data)");
                        ret = mnt_parent->fs_ops->mount(mnt_parent, rwflag, data);
                        if (ret == RT_EOK)
                        {
                            DLOG(msg, type->fs_ops->name, "dfs", DLOG_MSG_RET, "mount OK, ret root_dentry");
 
                            mnt_child = mnt_parent;
                            mnt_child->flags |= MNT_IS_MOUNTED;
 
                            DLOG(note_right, "mnt", "mount sucessfully");
                            DLOG(msg, "dfs", "mnt", DLOG_MSG, "dfs_mnt_insert(, mnt_child)");
                            dfs_mnt_insert(RT_NULL, mnt_child);
 
                            /* unref it, because the ref_count = 1 when create */
                            DLOG(msg, "dfs", "mnt", DLOG_MSG, "dfs_mnt_unref(mnt_parent)");
                            dfs_mnt_unref(mnt_parent);
 
                            /*
                             * About root mnt:
                             * There are two ref_count:
                             * 1. the gobal root reference.
                             * 1. the mnt->parent reference.
                             */
                        }
                        else
                        {
                            LOG_W("mount %s failed with file system type: %s", fullpath, type->fs_ops->name);
                            DLOG(msg, "dfs", "mnt", DLOG_MSG, "dfs_mnt_destroy(mnt_parent)");
                            dfs_mnt_destroy(mnt_parent);
                            mnt_parent = RT_NULL;
                            rt_set_errno(EPERM);
                            ret = -1;
                        }
                    }
                    else
                    {
                        LOG_W("no mount method on file system type: %s", type->fs_ops->name);
                        DLOG(msg, "dfs", "mnt", DLOG_MSG, "dfs_mnt_destroy(mnt_parent), no mount method");
                        dfs_mnt_destroy(mnt_parent);
                        mnt_parent = RT_NULL;
                        rt_set_errno(EIO);
                        ret = -1;
                    }
                }
                else
                {
                    LOG_E("create a mnt point failed.");
                    rt_set_errno(ENOMEM);
                    ret = -1;
                }
            }
            else if (mnt_parent && (strcmp(mnt_parent->fullpath, fullpath) != 0))
            {
                DLOG(msg, "dfs", "dentry", DLOG_MSG, "mntpoint_dentry = dfs_dentry_lookup(mnt_parent, %s, 0)", fullpath);
                mntpoint_dentry = dfs_dentry_lookup(mnt_parent, fullpath, 0);
                if (mntpoint_dentry)
                {
                    DLOG(msg, "dentry", "dfs", DLOG_MSG_RET, "dentry exist");
                    DLOG(msg, "dfs", "mnt", DLOG_MSG, "mnt_child = dfs_mnt_create(path)");
                    mnt_child = dfs_mnt_create(fullpath);
                    if (mnt_child)
                    {
                        LOG_D("create mnt point %p", mnt_child);
 
                        mnt_child->fs_ops = type->fs_ops;
                        mnt_child->dev_id = dev_id;
 
                        if (mnt_child->fs_ops->mount)
                        {
                            DLOG(msg, "dfs", type->fs_ops->name, DLOG_MSG, "root_dentry = fs_ops->mount(mnt_child, rwflag, data)");
                            ret = mnt_child->fs_ops->mount(mnt_child, rwflag, data);
                            if (ret == RT_EOK)
                            {
                                mnt_child->flags |= MNT_IS_MOUNTED;
 
                                LOG_D("mount %s sucessfully", fullpath);
                                DLOG(msg, mnt_child->fs_ops->name, "dfs", DLOG_MSG_RET, "mount OK");
 
                                DLOG(msg, "dfs", "mnt", DLOG_MSG, "dfs_mnt_insert(mnt_parent, mnt_child)");
                                dfs_mnt_insert(mnt_parent, mnt_child);
 
                                /* unref it, because the ref_count = 1 when create */
                                DLOG(msg, "dfs", "mnt", DLOG_MSG, "dfs_mnt_unref(mnt_child)");
                                dfs_mnt_unref(mnt_child);
                            }
                            else
                            {
                                LOG_W("mount %s failed with file system type: %s", fullpath, type->fs_ops->name);
                                DLOG(msg, mnt_child->fs_ops->name, "dfs", DLOG_MSG_RET, "mount failed");
                                dfs_mnt_destroy(mnt_child);
                                rt_set_errno(EPERM);
                                ret = -1;
                            }
                        }
                        else
                        {
                            LOG_W("no mount method on file system type: %s", type->fs_ops->name);
                            dfs_mnt_destroy(mnt_child);
                            rt_set_errno(EIO);
                            ret = -1;
                        }
                    }
                    else
                    {
                        LOG_E("create a mnt point failed.");
                        rt_set_errno(ENOMEM);
                        ret = -1;
                    }
                    dfs_dentry_unref(mntpoint_dentry);
                }
                else
                {
                    LOG_W("no mount point (%s) in file system: %s", fullpath, mnt_parent->fullpath);
                    rt_set_errno(ENOTDIR);
                    ret = -1;
                }
            }
            else
            {
                LOG_E("mount point (%s) already mounted!", fullpath);
                rt_set_errno(EEXIST);
                ret = -1;
            }
        }
        else
        {
            LOG_E("No device found for this file system.");
            rt_set_errno(ENODEV);
            ret = -1;
        }
        rt_free(fullpath);
    }
 
    return ret;
}

引用了 dfs_mnt::dev_id, dfs_dentry_lookup(), dfs_dentry_unref(), dfs_mnt_create(), dfs_mnt_destroy(), dfs_mnt_insert(), dfs_mnt_lookup(), dfs_mnt_unref(), dfs_normalize_path(), DLOG, dfs_filesystem_ops::flags, dfs_mnt::flags, FS_NEED_DEVICE, dfs_filesystem_type::fs_ops, dfs_mnt::fs_ops, dfs_mnt::fullpath, LOG_D, LOG_E, LOG_W, MNT_IS_MOUNTED, dfs_filesystem_ops::mount, dfs_filesystem_ops::name, rt_device_find(), rt_free() , 以及 RT_NULL.

函数调用图:

dfs_umount()

int dfs_umount	(	const char *	specialfile,
		int	flags )

在文件 dfs_fs.c 第 347 行定义.

{
    int ret = -1;
    char *fullpath = RT_NULL;
    struct dfs_mnt *mnt = RT_NULL;
 
    fullpath = dfs_normalize_path(NULL, specialfile);
    if (fullpath)
    {
        DLOG(msg, "dfs", "mnt", DLOG_MSG, "mnt = dfs_mnt_lookup(%s)", fullpath);
        mnt = dfs_mnt_lookup(fullpath);
        if (mnt)
        {
            if (strcmp(mnt->fullpath, fullpath) == 0)
            {
                /* is the mount point */
                rt_base_t ref_count = rt_atomic_load(&(mnt->ref_count));
 
                if (!(mnt->flags & MNT_IS_LOCKED) && rt_list_isempty(&mnt->child) && (ref_count == 1 || (flags & MNT_FORCE)))
                {
#ifdef RT_USING_PAGECACHE
                    dfs_pcache_unmount(mnt);
#endif
                    /* destroy this mount point */
                    DLOG(msg, "dfs", "mnt", DLOG_MSG, "dfs_mnt_destroy(mnt)");
                    ret = dfs_mnt_destroy(mnt);
                }
                else
                {
                    LOG_I("the file system is busy!");
                    ret = -EBUSY;
                }
            }
            else
            {
                LOG_I("the path:%s is not a mountpoint!", fullpath);
                ret = -EINVAL;
            }
        }
        else
        {
            LOG_I("no filesystem found.");
        }
        rt_free(fullpath);
    }
    else
    {
        rt_set_errno(-ENOTDIR);
    }
 
    return ret;
}

引用了 dfs_mnt::child, dfs_mnt_destroy(), dfs_mnt_lookup(), dfs_normalize_path(), DLOG, dfs_mnt::flags, dfs_mnt::fullpath, LOG_I, MNT_FORCE, MNT_IS_LOCKED, dfs_mnt::ref_count, rt_atomic_load, rt_free(), rt_list_isempty() , 以及 RT_NULL.

函数调用图:

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

dfs_unmount()

int dfs_unmount

(

const char *

specialfile

)

在文件 dfs_fs.c 第 401 行定义.

{
    return dfs_umount(specialfile, 0);
}

引用了 dfs_umount().

函数调用图:

dfs_is_mounted()

int dfs_is_mounted

(

struct dfs_mnt *

mnt

)

在文件 dfs_fs.c 第 406 行定义.

{
    int ret = 0;
 
    if (mnt && !(mnt->flags & MNT_IS_MOUNTED))
    {
        ret = -1;
    }
 
    return ret;
}

引用了 dfs_mnt::flags , 以及 MNT_IS_MOUNTED.

dfs_mkfs()

int dfs_mkfs	(	const char *	fs_name,
		const char *	device_name )

在文件 dfs_fs.c 第 418 行定义.

{
    rt_device_t dev_id = NULL;
    struct dfs_filesystem_type *type;
    int ret = -RT_ERROR;
 
    type = *_find_filesystem(fs_name);
    if (!type)
    {
        rt_kprintf("no file system: %s found!\n", fs_name);
        return ret;
    }
    else
    {
        if (type->fs_ops->flags & FS_NEED_DEVICE)
        {
            /* check device name, and it should not be NULL */
            if (device_name != NULL)
                dev_id = rt_device_find(device_name);
 
            if (dev_id == NULL)
            {
                rt_set_errno(-ENODEV);
                rt_kprintf("Device (%s) was not found", device_name);
                return ret;
            }
        }
        else
        {
            dev_id = RT_NULL;
        }
    }
 
    if (type->fs_ops->mkfs)
    {
        ret = type->fs_ops->mkfs(dev_id, type->fs_ops->name);
#ifdef RT_USING_PAGECACHE
        if (ret == RT_EOK)
        {
            struct dfs_mnt *mnt = RT_NULL;
 
            mnt = dfs_mnt_dev_lookup(dev_id);
            if (mnt)
            {
                dfs_pcache_unmount(mnt);
            }
        }
#endif
    }
 
    return ret;
}

引用了 dfs_mnt::dev_id, dfs_mnt_dev_lookup(), dfs_filesystem_ops::flags, FS_NEED_DEVICE, dfs_filesystem_type::fs_ops, dfs_filesystem_ops::mkfs, dfs_filesystem_ops::name, rt_device_find(), rt_kprintf , 以及 RT_NULL.

函数调用图:

dfs_statfs()

int dfs_statfs	(	const char *	path,
		struct statfs *	buffer )

在文件 dfs_fs.c 第 471 行定义.

{
    struct dfs_mnt *mnt;
    char *fullpath;
    int ret = -RT_ERROR;
 
    fullpath = dfs_normalize_path(NULL, path);
    if (!fullpath)
    {
        return ret;
    }
 
    DLOG(msg, "dfs_file", "mnt", DLOG_MSG, "dfs_mnt_lookup(%s)", fullpath);
    mnt = dfs_mnt_lookup(fullpath);
    if (mnt)
    {
        if (mnt->fs_ops->statfs)
        {
            if (dfs_is_mounted(mnt) == 0)
            {
                ret = mnt->fs_ops->statfs(mnt, buffer);
            }
        }
    }
 
    return ret;
}

引用了 dfs_is_mounted(), dfs_mnt_lookup(), dfs_normalize_path(), DLOG, dfs_mnt::fs_ops, dfs_mnt::fullpath, dfs_filesystem_ops::statfs , 以及 statfs().

函数调用图:

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

dfs_filesystem_get_mounted_path()

const char * dfs_filesystem_get_mounted_path

(

struct rt_device *

device

)

this function will return the mounted path for specified device.

参数

device

the device object which is mounted.

返回

the mounted path or NULL if none device mounted.

在文件 dfs_fs.c 第 506 行定义.

{
    const char *path = NULL;
 
    return path;
}

dfs_filesystem_get_partition()

int dfs_filesystem_get_partition	(	struct dfs_partition *	part,
		uint8_t *	buf,
		uint32_t	pindex )

this function will fetch the partition table on specified buffer.

参数

part	the returned partition structure.
buf	the buffer contains partition table.
pindex	the index of partition table to fetch.

返回

RT_EOK on successful or -RT_ERROR on failed.

在文件 dfs_fs.c 第 522 行定义.

{
#define DPT_ADDRESS     0x1be       /* device partition offset in Boot Sector */
#define DPT_ITEM_SIZE   16          /* partition item size */
 
    uint8_t *dpt;
    uint8_t type;
 
    RT_ASSERT(part != NULL);
    RT_ASSERT(buf != NULL);
 
    dpt = buf + DPT_ADDRESS + pindex * DPT_ITEM_SIZE;
 
    /* check if it is a valid partition table */
    if ((*dpt != 0x80) && (*dpt != 0x00))
        return -EIO;
 
    /* get partition type */
    type = *(dpt + 4);
    if (type == 0)
        return -EIO;
 
    /* set partition information
     *    size is the number of 512-Byte */
    part->type = type;
    part->offset = *(dpt + 8) | *(dpt + 9) << 8 | *(dpt + 10) << 16 | *(dpt + 11) << 24;
    part->size = *(dpt + 12) | *(dpt + 13) << 8 | *(dpt + 14) << 16 | *(dpt + 15) << 24;
 
    rt_kprintf("found part[%d], begin: %ld, size: ",
               pindex, part->offset * 512);
    if ((part->size >> 11) == 0)
        rt_kprintf("%ld%s", part->size >> 1, "KB\n"); /* KB */
    else
    {
        unsigned int part_size;
        part_size = part->size >> 11;                /* MB */
        if ((part_size >> 10) == 0)
            rt_kprintf("%d.%ld%s", part_size, (part->size >> 1) & 0x3FF, "MB\n");
        else
            rt_kprintf("%d.%d%s", part_size >> 10, part_size & 0x3FF, "GB\n");
    }
 
    return RT_EOK;
}

引用了 DPT_ADDRESS, DPT_ITEM_SIZE, dfs_partition::offset, RT_ASSERT, rt_kprintf, dfs_partition::size , 以及 dfs_partition::type.

变量说明

_mnt_list

rt_list_t _mnt_list

extern