Flow_AI
Flow_AI

IOT-OS之RT-Thread（十）--- DFS文件系统管理与devfs/elmfat示例

文章目录

  • 一、DFS设备文件系统简介
    • 1.1 DFS简介
    • 1.2 DFS架构
  • 二、DFS文件系统管理
    • 2.1 DFS POSIX接口层
    • 2.2 DFS虚拟文件系统层
      • 2.2.1 devfs设备文件系统
      • 2.2.2 elmfat虚拟文件系统
    • 2.3 DFS设备抽象层
  • 三、DFS文件系统示例
    • 3.1 devfs文件系统示例
    • 3.2 elmfat文件系统示例
  • 更多文章：

在早期的嵌入式系统中，需要存储的数据比较少，数据类型也比较单一，往往使用直接在存储设备中的指定地址写入数据的方法来存储数据。然而随着嵌入式设备功能的发展，需要存储的数据越来越多，也越来越复杂，这时仍使用旧方法来存储并管理数据就变得非常繁琐困难。因此我们需要新的数据管理方式来简化存储数据的组织形式，这种方式就是我们接下来要介绍的文件系统。

文件系统是一套实现了数据的存储、分级组织、访问和获取等操作的抽象数据类型 (Abstract data type)，是一种用于向用户提供底层数据访问的机制。文件系统通常存储的基本单位是文件，即数据是按照一个个文件的方式进行组织。当文件比较多时，将导致文件繁多，不易分类、重名的问题。而文件夹作为一个容纳多个文件的容器而存在。

一、DFS设备文件系统简介

1.1 DFS简介

DFS 是 RT-Thread 提供的虚拟文件系统组件，全称为 Device File System，即设备虚拟文件系统，文件系统的名称使用类似 UNIX 文件、文件夹的风格，目录结构如下图所示：
IOT-OS之RT-Thread（十）--- DFS文件系统管理与devfs/elmfat示例_第1张图片
在 RT-Thread DFS 中，文件系统有统一的根目录，使用 / 来表示。而在根目录下的 f1.bin 文件则使用 /f1.bin 来表示，2018 目录下的 f1.bin 目录则使用 /data/2018/f1.bin 来表示。即目录的分割符号是 /，这与 UNIX/Linux 完全相同，与 Windows 则不相同（Windows 操作系统上使用 \ 来作为目录的分割符）。

1.2 DFS架构

DFS 的层次架构如下图所示，主要分为 POSIX 接口层、虚拟文件系统层和设备抽象层。
IOT-OS之RT-Thread（十）--- DFS文件系统管理与devfs/elmfat示例_第2张图片

  • POSIX 接口层：为应用程序提供统一的 POSIX 文件和目录操作接口：read、write、poll/select 等。

POSIX 表示可移植操作系统接口（Portable Operating System Interface of UNIX，缩写 POSIX），POSIX 标准定义了操作系统应该为应用程序提供的接口标准，是 IEEE 为要在各种 UNIX 操作系统上运行的软件而定义的一系列 API 标准的总称。

POSIX 标准意在期望获得源代码级别的软件可移植性。换句话说，为一个 POSIX 兼容的操作系统编写的程序，应该可以在任何其它 POSIX 操作系统（即使是来自另一个厂商）上编译执行。RT-Thread 支持 POSIX 标准接口，因此可以很方便的将 Linux/Unix 的程序移植到 RT-Thread 操作系统上。

在类 Unix 系统中，普通文件、设备文件、网络文件描述符是同一种文件描述符。而在 RT-Thread 操作系统中，使用 DFS 来实现这种统一性。有了这种文件描述符的统一性，我们就可以使用 poll/select 接口来对这几种描述符进行统一轮询，为实现程序功能带来方便。

使用 poll/select 接口可以阻塞地同时探测一组支持非阻塞的 I/O 设备是否有事件发生（如可读，可写，有高优先级的错误输出，出现错误等等），直至某一个设备触发了事件或者超过了指定的等待时间。这种机制可以帮助调用者寻找当前就绪的设备，降低编程的复杂度。

  • 虚拟文件系统层：支持多种类型的文件系统，如 FatFS、RomFS、DevFS 等，并提供普通文件、设备文件、网络文件描述符的管理。

用户可以将具体的文件系统注册到 DFS 中，如 FatFS、RomFS、DevFS 等，下面介绍几种常用的文件系统类型：

文件系统类型 文件系统功能描述
DevFS 设备文件系统，在 RT-Thread 操作系统中开启该功能后，可以将系统中的设备在 /dev 文件夹下虚拟成文件，使得设备可以按照文件的操作方式使用 read、write 等接口进行操作。
elmfat FS 专为小型嵌入式设备开发的一个兼容微软 FAT 格式的文件系统，采用 ANSI C 编写，具有良好的硬件无关性以及可移植性，是 RT-Thread 中最常用的文件系统类型。
Jffs2 一种日志闪存文件系统。主要用于 NOR 型闪存，基于 MTD 驱动层，特点是：可读写的、支持数据压缩的、基于哈希表的日志型文件系统，并提供了崩溃 / 掉电安全保护，提供写平衡支持等。
NFS 网络文件系统（Network File System）是一项在不同机器、不同操作系统之间通过网络共享文件的技术。在操作系统的开发调试阶段，可以利用该技术在主机上建立基于 NFS 的根文件系统，挂载到嵌入式设备上，可以很方便地修改根文件系统的内容。
RamFS 内存文件系统，它不能格式化，可以同时创建多个，在创建时可以指定其最大能使用的内存大小，优点是读写速度很快，但存在掉电丢失的风险。
RomFS 一种简单的、紧凑的、只读的文件系统，不支持动态擦写保存，按顺序存放数据，因而支持应用程序以 XIP(execute In Place，片内运行) 方式运行，在系统运行时, 节省 RAM 空间。
UFFS 超低功耗的闪存文件系统（Ultra-low-cost Flash File System）的简称。它是国人开发的、专为嵌入式设备等小内存环境中使用 Nand Flash 的开源文件系统。与嵌入式中常使用的 Yaffs 文件系统相比具有资源占用少、启动速度快、免费等优势。
  • 设备抽象层：支持多种类型的存储设备，如 SD Card、SPI Flash、Nand Flash 等。

设备抽象层将物理设备如 SD Card、SPI Flash、Nand Flash，抽象成符合文件系统能够访问的设备，例如 FAT 文件系统要求存储设备必须是块设备类型。

不同文件系统类型是独立于存储设备驱动而实现的，因此把底层存储设备的驱动接口和文件系统对接起来之后，才可以正确地使用文件系统功能。

二、DFS文件系统管理

本文依然按照与I / O设备模型框架类似的形式介绍DFS设备文件系统，逐层介绍其描述数据结构、接口函数、调用过程等。在DFS虚拟文件系统层，我们选择RT-Thread最常用的elmfat作为示例，同时启用DevFS来管理设备。

2.1 DFS POSIX接口层

文件系统至少有三个要素构成：文件系统、文件、目录，其中目录可以看作是文件的一种类型，所以文件系统至少需要提供描述文件系统本身和文件的数据结构及相应的接口函数。

  • 文件系统控制块

要想使用文件系统，需要先对其进行注册或挂载，要对文件系统操作，也需要对文件系统使用合理的数据结构进行描述，RT-Thread在DFS POSIX层对文件系统的描述如下：

// rt-thread-4.0.1\components\dfs\include\dfs_fs.h

/* Mounted file system */
struct dfs_filesystem
{
    rt_device_t dev_id;     /* Attached device */

    char *path;             /* File system mount point */
    const struct dfs_filesystem_ops *ops; /* Operations for file system type */

    void *data;             /* Specific file system data */
};

/* File system operations */
struct dfs_filesystem_ops
{
    char *name;
    uint32_t flags;      /* flags for file system operations */

    /* operations for file */
    const struct dfs_file_ops *fops;

    /* mount and unmount file system */
    int (*mount)    (struct dfs_filesystem *fs, unsigned long rwflag, const void *data);
    int (*unmount)  (struct dfs_filesystem *fs);

    /* make a file system */
    int (*mkfs)     (rt_device_t devid);
    int (*statfs)   (struct dfs_filesystem *fs, struct statfs *buf);

    int (*unlink)   (struct dfs_filesystem *fs, const char *pathname);
    int (*stat)     (struct dfs_filesystem *fs, const char *filename, struct stat *buf);
    int (*rename)   (struct dfs_filesystem *fs, const char *oldpath, const char *newpath);
};


// rt-thread-4.0.1\components\dfs\src\dfs.c

/* Global variables */
const struct dfs_filesystem_ops *filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX];
struct dfs_filesystem filesystem_table[DFS_FILESYSTEMS_MAX];

dfs_filesystem结构体中成员dev_id是该文件系统要挂载的设备句柄，path为该文件系统要挂载的路径，ops则是该文件系统支持的接口函数集合，data则指向其私有数据。

在系统中可能不止挂载一种文件系统，所以多个文件系统的dfs_filesystem结构体与相应的dfs_filesystem_ops接口函数集合以全局数组的形式组织起来。

  • 文件控制块

将需要的文件系统注册挂载成功后，用户使用文件系统主要是对文件的操作，在该文件系统中文件是如何描述的，支持哪些接口函数集合，也都需要相应的数据结构描述，RT-Thread在DFS POSIX层对文件的描述如下：

// rt-thread-4.0.1\components\dfs\include\dfs_file.h

/* file descriptor */
#define DFS_FD_MAGIC     0xfdfd
struct dfs_fd
{
    uint16_t magic;              /* file descriptor magic number */
    uint16_t type;               /* Type (regular or socket) */

    char *path;                  /* Name (below mount point) */
    int ref_count;               /* Descriptor reference count */

    struct dfs_filesystem *fs;
    const struct dfs_file_ops *fops;

    uint32_t flags;              /* Descriptor flags */
    size_t   size;               /* Size in bytes */
    off_t    pos;                /* Current file position */

    void *data;                  /* Specific file system data */
};

struct dfs_file_ops
{
    int (*open)     (struct dfs_fd *fd);
    int (*close)    (struct dfs_fd *fd);
    int (*ioctl)    (struct dfs_fd *fd, int cmd, void *args);
    int (*read)     (struct dfs_fd *fd, void *buf, size_t count);
    int (*write)    (struct dfs_fd *fd, const void *buf, size_t count);
    int (*flush)    (struct dfs_fd *fd);
    int (*lseek)    (struct dfs_fd *fd, off_t offset);
    int (*getdents) (struct dfs_fd *fd, struct dirent *dirp, uint32_t count);

    int (*poll)     (struct dfs_fd *fd, struct rt_pollreq *req);
};


// rt-thread-4.0.1\components\dfs\include\dfs.h

struct dfs_fdtable
{
    uint32_t maxfd;
    struct dfs_fd **fds;
};

// rt-thread-4.0.1\components\dfs\src\dfs.c

static struct dfs_fdtable _fdtab;

dfs_fd文件描述结构体包含magic幻数、type文件类型、path文件路径包括文件名，ref_count文件引用次数、fs文件系统句柄、fops文件操作接口函数集合、flags文件打开标识、size文件占用字节数、pos当前文件位置、data文件私有数据指针等。

一个文件系统一般会管理多个文件，这些文件也以全局数组的形式组织管理，文件描述符表结构体dfs_fdtable有两个成员：最大文件数量和文件描述符表的首地址，这两个成员可以描述一个数组的元素个数与首地址。

  • 文件系统初始化与注册

要想使用文件系统，需要先对其进行初始化，包括初始化文件系统的数据结构、将需要的文件系统挂载到指定设备的指定路径上。在DFS POSIC层的文件系统初始化过程如下：

// rt-thread-4.0.1\components\dfs\src\dfs.c

/**
 * this function will initialize device file system.
 */
int dfs_init(void)
{
    static rt_bool_t init_ok = RT_FALSE;

    if (init_ok)
    {
        rt_kprintf("dfs already init.\n");
        return 0;
    }

    /* clear filesystem operations table */
    memset((void *)filesystem_operation_table, 0, sizeof(filesystem_operation_table));
    /* clear filesystem table */
    memset(filesystem_table, 0, sizeof(filesystem_table));
    /* clean fd table */
    memset(&_fdtab, 0, sizeof(_fdtab));

    /* create device filesystem lock */
    rt_mutex_init(&fslock, "fslock", RT_IPC_FLAG_FIFO);

#ifdef DFS_USING_WORKDIR
    /* set current working directory */
    memset(working_directory, 0, sizeof(working_directory));
    working_directory[0] = '/';
#endif

#ifdef RT_USING_DFS_DEVFS
    {
        extern int devfs_init(void);

        /* if enable devfs, initialize and mount it as soon as possible */
        devfs_init();

        dfs_mount(NULL, "/dev", "devfs", 0, 0);
    }
#endif

    init_ok = RT_TRUE;

    return 0;
}
INIT_PREV_EXPORT(dfs_init);

dfs_init函数完成了filesystem_operation_table、filesystem_table、_fdtab三个表的重置初始化操作，同时完成了devfs设备文件系统的初始化与挂载操作（devfs初始化与挂载操作需要下面devfs文件系统层的支持），当使能宏定义RT_USING_DFS_DEVFS时devfs不需要用户再次挂载即可使用。dfs_init函数使用RT-Thread自动初始化组件，在系统启动前自动调用完成DFS框架初始化。

参考I / O设备管理模型，一个对象初始化后需要将该对象的接口函数集合注册到RT-Thread对象管理层后才能通过统一的对象管理接口操作该对象。对于DFS设备文件系统来说，在对文件系统对象完成初始化后，需要将该文件系统的操作函数集合dfs_filesystem_ops注册到DFS设备文件系统层后，用户才能通过DFS设备文件系统接口函数来操作该文件系统。DFS注册过程如下：

// rt-thread-4.0.1\components\dfs\src\dfs_fs.c

/**
 * this function will register a file system instance to device file system.
 *  * @param ops the file system instance to be registered.
 *  * @return 0 on successful, -1 on failed.
 */
int dfs_register(const struct dfs_filesystem_ops *ops)
{
    int ret = RT_EOK;
    const struct dfs_filesystem_ops **empty = NULL;
    const struct dfs_filesystem_ops **iter;

    /* lock filesystem */
    dfs_lock();
    /* check if this filesystem was already registered */
    for (iter = &filesystem_operation_table[0];
            iter < &filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX]; iter ++)
    {
        /* find out an empty filesystem type entry */
        if (*iter == NULL)
            (empty == NULL) ? (empty = iter) : 0;
        else if (strcmp((*iter)->name, ops->name) == 0)
        {
            rt_set_errno(-EEXIST);
            ret = -1;
            break;
        }
    }

    /* save the filesystem's operations */
    if (empty == NULL)
    {
        rt_set_errno(-ENOSPC);
        LOG_E("There is no space to register this file system (%s).", ops->name);
        ret = -1;
    }
    else if (ret == RT_EOK)
    {
        *empty = ops;
    }

    dfs_unlock();
    return ret;
}

dfs_register函数主要是从filesystem_operation_table数组中找出一个空元素，然后将待注册的dfs_filesystem_ops作为参数赋值给filesystem_operation_table中找到的空元素，后面如果想操作某个文件系统，从filesystem_operation_table数组中根据名称查找到对应的文件系统接口函数集合，然后通过对应的接口函数指针调用该文件系统注册的操作函数即可。

  • 文件系统接口函数

对文件系统的操作主要有创建、挂载、查询等操作。要想使用文件系统来管理文件，需要先将该文件系统挂载到设备某个位置（也即某个路径），要想将文件系统挂载到该设备某个路径下，需要先将该设备按照该文件系统的存储要求进行格式化，对该设备按文件系统需求进行格式化的过程称为在该设备上创建一个文件系统。文件系统在特定设备上创建，并挂载到特定路径后就可以正常使用该文件系统了，比如查询该文件系统的基本信息、使用该文件系统管理文件，也即在挂载路径下使用该文件系统提供的文件接口函数访问文件。

先看文件系统的创建过程：

// rt-thread-4.0.1\components\dfs\src\dfs_fs.c

/**
 * make a file system on the special device
 *
 * @param fs_name the file system name
 * @param device_name the special device name
 *
 * @return 0 on successful, otherwise failed.
 */
int dfs_mkfs(const char *fs_name, const char *device_name)
{
    int index;
    rt_device_t dev_id = NULL;

    /* 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);
        LOG_E("Device (%s) was not found", device_name);
        return -1;
    }

    /* lock file system */
    dfs_lock();
    /* find the file system operations */
    for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index ++)
    {
        if (filesystem_operation_table[index] != NULL &&
            strcmp(filesystem_operation_table[index]->name, fs_name) == 0)
            break;
    }
    dfs_unlock();

    if (index < DFS_FILESYSTEM_TYPES_MAX)
    {
        /* find file system operation */
        const struct dfs_filesystem_ops *ops = filesystem_operation_table[index];
        if (ops->mkfs == NULL)
        {
            LOG_E("The file system (%s) mkfs function was not implement", fs_name);
            rt_set_errno(-ENOSYS);
            return -1;
        }

        return ops->mkfs(dev_id);
    }

    LOG_E("File system (%s) was not found.", fs_name);

    return -1;
}

dfs_mkfs函数最终调用的是下面DFS虚拟文件系统层注册的ops->mkfs函数，该函数最终由要使用的文件系统实现。

下面看文件系统的挂载过程：

// rt-thread-4.0.1\components\dfs\src\dfs_fs.c

/**
 * this function will mount a file system on a specified path.
 *
 * @param device_name the name of device which includes a file system.
 * @param path the path to mount a file system
 * @param filesystemtype the file system type
 * @param rwflag the read/write etc. flag.
 * @param data the private data(parameter) for this file system.
 *
 * @return 0 on successful or -1 on failed.
 */
int dfs_mount(const char   *device_name,
              const char   *path,
              const char   *filesystemtype,
              unsigned long rwflag,
              const void   *data)
{
    const struct dfs_filesystem_ops **ops;
    struct dfs_filesystem *iter;
    struct dfs_filesystem *fs = NULL;
    char *fullpath = NULL;
    rt_device_t dev_id;

    /* open specific device */
    if (device_name == NULL)
    {
        /* which is a non-device filesystem mount */
        dev_id = NULL;
    }
    else if ((dev_id = rt_device_find(device_name)) == NULL)
    {
        /* no this device */
        rt_set_errno(-ENODEV);
        return -1;
    }

    /* find out the specific filesystem */
    dfs_lock();

    for (ops = &filesystem_operation_table[0];
            ops < &filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX]; ops++)
        if ((*ops != NULL) && (strcmp((*ops)->name, filesystemtype) == 0))
            break;

    dfs_unlock();

    if (ops == &filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX])
    {
        /* can't find filesystem */
        rt_set_errno(-ENODEV);
        return -1;
    }

    /* check if there is mount implementation */
    if ((*ops == NULL) || ((*ops)->mount == NULL))
    {
        rt_set_errno(-ENOSYS);
        return -1;
    }

    /* make full path for special file */
    fullpath = dfs_normalize_path(NULL, path);
    if (fullpath == NULL) /* not an abstract path */
    {
        rt_set_errno(-ENOTDIR);
        return -1;
    }

    /* Check if the path exists or not, raw APIs call, fixme */
    if ((strcmp(fullpath, "/") != 0) && (strcmp(fullpath, "/dev") != 0))
    {
        struct dfs_fd fd;

        if (dfs_file_open(&fd, fullpath, O_RDONLY | O_DIRECTORY) < 0)
        {
            rt_free(fullpath);
            rt_set_errno(-ENOTDIR);

            return -1;
        }
        dfs_file_close(&fd);
    }

    /* check whether the file system mounted or not  in the filesystem table
     * if it is unmounted yet, find out an empty entry */
    dfs_lock();

    for (iter = &filesystem_table[0];
            iter < &filesystem_table[DFS_FILESYSTEMS_MAX]; iter++)
    {
        /* check if it is an empty filesystem table entry? if it is, save fs */
        if (iter->ops == NULL)
            (fs == NULL) ? (fs = iter) : 0;
        /* check if the PATH is mounted */
        else if (strcmp(iter->path, path) == 0)
        {
            rt_set_errno(-EINVAL);
            goto err1;
        }
    }

    if ((fs == NULL) && (iter == &filesystem_table[DFS_FILESYSTEMS_MAX]))
    {
        rt_set_errno(-ENOSPC);
        LOG_E("There is no space to mount this file system (%s).", filesystemtype);
        goto err1;
    }

    /* register file system */
    fs->path   = fullpath;
    fs->ops    = *ops;
    fs->dev_id = dev_id;
    /* release filesystem_table lock */
    dfs_unlock();

    /* open device, but do not check the status of device */
    if (dev_id != NULL)
    {
        if (rt_device_open(fs->dev_id,
                           RT_DEVICE_OFLAG_RDWR) != RT_EOK)
        {
            /* The underlaying device has error, clear the entry. */
            dfs_lock();
            memset(fs, 0, sizeof(struct dfs_filesystem));

            goto err1;
        }
    }

    /* call mount of this filesystem */
    if ((*ops)->mount(fs, rwflag, data) < 0)
    {
        /* close device */
        if (dev_id != NULL)
            rt_device_close(fs->dev_id);

        /* mount failed */
        dfs_lock();
        /* clear filesystem table entry */
        memset(fs, 0, sizeof(struct dfs_filesystem));

        goto err1;
    }

    return 0;

err1:
    dfs_unlock();
    rt_free(fullpath);

    return -1;
}

dfs_mount函数最终也是通过调用下层注册的(*ops)->mount函数实现，该函数最终由要使用的文件系统实现。

文件系统操作还有其他的一些接口函数，下面只给出函数声明：

// rt-thread-4.0.1\components\dfs\src\dfs_fs.c

/**
 * this function will unmount a file system on specified path.
 *
 * @param specialfile the specified path which mounted a file system.
 *
 * @return 0 on successful or -1 on failed.
 */
int dfs_unmount(const char *specialfile);

/**
 * this function will return the information about a mounted file system.
 *
 * @param path the path which mounted file system.
 * @param buffer the buffer to save the returned information.
 *
 * @return 0 on successful, others on failed.
 */
int dfs_statfs(const char *path, struct statfs *buffer);


// rt-thread-4.0.1\components\dfs\include\dfs.h
struct statfs
{
    size_t f_bsize;   /* block size */
    size_t f_blocks;  /* total data blocks in file system */
    size_t f_bfree;   /* free blocks in file system */
};

DFS POSIX接口主要是针对文件和目录的操作，对文件系统的操作比较少，也只提供了对文件系统的信息查询接口，实际调用的还是上面的dfs_statfs函数，DFS POSIX文件系统API如下：

// rt-thread-4.0.1\components\dfs\src\dfs_posix.c

/**
 * this function is a POSIX compliant version, which will return the
 * information about a mounted file system.
 *
 * @param path the path which mounted file system.
 * @param buf the buffer to save the returned information.
 *
 * @return 0 on successful, others on failed.
 */
int statfs(const char *path, struct statfs *buf)
{
    int result;

    result = dfs_statfs(path, buf);
    if (result < 0)
    {
        rt_set_errno(result);

        return -1;
    }

    return result;
}
RTM_EXPORT(statfs);
  • 文件访问接口函数

文件系统注册接口函数集合时，连同文件接口函数集合也一起注册了，回顾下前面dfs_filesystem_ops结构体中有一个成员dfs_file_ops *指向该文件系统中文件操作接口函数集合的地址。当文件系统挂载成功后，就可以直接使用该文件系统提供的文件操作接口函数对文件进行访问了。

对文件的访问最终还是通过调用该文件系统向上层注册的文件访问函数实现的，下面以文件打开函数为例，看下这个过程：

// rt-thread-4.0.1\components\dfs\src\dfs_file.c

/**
 * this function will open a file which specified by path with specified flags.
 *
 * @param fd the file descriptor pointer to return the corresponding result.
 * @param path the specified file path.
 * @param flags the flags for open operator.
 *
 * @return 0 on successful, -1 on failed.
 */
int dfs_file_open(struct dfs_fd *fd, const char *path, int flags)
{
    struct dfs_filesystem *fs;
    char *fullpath;
    int result;

    /* parameter check */
    if (fd == NULL)
        return -EINVAL;

    /* make sure we have an absolute path */
    fullpath = dfs_normalize_path(NULL, path);
    if (fullpath == NULL)
    {
        return -ENOMEM;
    }

    LOG_D("open file:%s", fullpath);

    /* find filesystem */
    fs = dfs_filesystem_lookup(fullpath);
    if (fs == NULL)
    {
        rt_free(fullpath); /* release path */

        return -ENOENT;
    }

    LOG_D("open in filesystem:%s", fs->ops->name);
    fd->fs    = fs;             /* set file system */
    fd->fops  = fs->ops->fops;  /* set file ops */

    /* initialize the fd item */
    fd->type  = FT_REGULAR;
    fd->flags = flags;
    fd->size  = 0;
    fd->pos   = 0;
    fd->data  = fs;

    if (!(fs->ops->flags & DFS_FS_FLAG_FULLPATH))
    {
        if (dfs_subdir(fs->path, fullpath) == NULL)
            fd->path = rt_strdup("/");
        else
            fd->path = rt_strdup(dfs_subdir(fs->path, fullpath));
        rt_free(fullpath);
        LOG_D("Actual file path: %s", fd->path);
    }
    else
    {
        fd->path = fullpath;
    }

    /* specific file system open routine */
    if (fd->fops->open == NULL)
    {
        /* clear fd */
        rt_free(fd->path);
        fd->path = NULL;

        return -ENOSYS;
    }

    if ((result = fd->fops->open(fd)) < 0)
    {
        /* clear fd */
        rt_free(fd->path);
        fd->path = NULL;

        LOG_D("%s open failed", fullpath);

        return result;
    }

    fd->flags |= DFS_F_OPEN;
    if (flags & O_DIRECTORY)
    {
        fd->type = FT_DIRECTORY;
        fd->flags |= DFS_F_DIRECTORY;
    }

    LOG_D("open successful");
    return 0;
}

在dfs_file_open中调用fd->fops->open（见：result = fd->fops->open(fd)）函数，足以说明DFS层的文件访问接口函数最终是通过调用所挂载文件系统内部提供的文件访问函数实现的。

从上面函数传入的参数可以看出，跟我们在Linux上使用的文件访问接口函数并不一致，我们更习惯把文件名作为参数传入，而不是把文件描述符作为参数传入。文件描述符信息较多，我们配置起来并不方便，为了兼容LInux的文件访问接口，DFS又提供了POSIX风格的接口函数，下面仍以文件打开函数为例，看POSIX风格的文件访问接口函数的实现过程：

// rt-thread-4.0.1\components\dfs\src\dfs_posix.c

/**
 * this function is a POSIX compliant version, which will open a file and
 * return a file descriptor according specified flags.
 *
 * @param file the path name of file.
 * @param flags the file open flags.
 *
 * @return the non-negative integer on successful open, others for failed.
 */
int open(const char *file, int flags, ...)
{
    int fd, result;
    struct dfs_fd *d;

    /* allocate a fd */
    fd = fd_new();
    if (fd < 0)
    {
        rt_set_errno(-ENOMEM);

        return -1;
    }
    d = fd_get(fd);

    result = dfs_file_open(d, file, flags);
    if (result < 0)
    {
        /* release the ref-count of fd */
        fd_put(d);
        fd_put(d);

        rt_set_errno(result);

        return -1;
    }

    /* release the ref-count of fd */
    fd_put(d);

    return fd;
}
RTM_EXPORT(open);

DFS POSIX风格的接口函数跟Linux一致，我们使用也更加方便，open函数实际上是对dfs_file_open函数的再封装，并且隐藏了文件描述符的配置管理过程，使用起来比较方便。

上面open函数中调用的fd_new / fd_get / fd_put是文件描述符管理函数，提供对文件描述符结构体的配置管理功能，这几个函数在.\components\dfs\src\dfs.c中实现，这里就不再展示其代码实现了。

DFS POSIX提供的文件访问接口还有很多，下面只展示其接口函数声明：

// rt-thread-4.0.1\components\dfs\src\dfs_posix.c

/**
 * this function is a POSIX compliant version, which will open a file and
 * return a file descriptor according specified flags.
 *
 * @param file the path name of file.
 * @param flags the file open flags.
 *
 * @return the non-negative integer on successful open, others for failed.
 */
int open(const char *file, int flags, ...);

/**
 * this function is a POSIX compliant version, which will close the open
 * file descriptor.
 *
 * @param fd the file descriptor.
 *
 * @return 0 on successful, -1 on failed.
 */
int close(int fd);

/**
 * this function is a POSIX compliant version, which will read specified data
 * buffer length for an open file descriptor.
 *
 * @param fd the file descriptor.
 * @param buf the buffer to save the read data.
 * @param len the maximal length of data buffer
 *
 * @return the actual read data buffer length. If the returned value is 0, it
 * may be reach the end of file, please check errno.
 */
int read(int fd, void *buf, size_t len);

/**
 * this function is a POSIX compliant version, which will write specified data
 * buffer length for an open file descriptor.
 *
 * @param fd the file descriptor
 * @param buf the data buffer to be written.
 * @param len the data buffer length.
 *
 * @return the actual written data buffer length.
 */
int write(int fd, const void *buf, size_t len);

/**
 * this function is a POSIX compliant version, which will seek the offset for
 * an open file descriptor.
 *
 * @param fd the file descriptor.
 * @param offset the offset to be seeked.
 * @param whence the directory of seek.
 *
 * @return the current read/write position in the file, or -1 on failed.
 */
off_t lseek(int fd, off_t offset, int whence);

/**
 * this function is a POSIX compliant version, which will rename old file name
 * to new file name.
 *
 * @param old the old file name.
 * @param new the new file name.
 *
 * @return 0 on successful, -1 on failed.
 *
 * note: the old and new file name must be belong to a same file system.
 */
int rename(const char *old, const char *new);

/**
 * this function is a POSIX compliant version, which will unlink (remove) a
 * specified path file from file system.
 *
 * @param pathname the specified path name to be unlinked.
 *
 * @return 0 on successful, -1 on failed.
 */
int unlink(const char *pathname);

/**
 * this function is a POSIX compliant version, which will get file information.
 *
 * @param file the file name
 * @param buf the data buffer to save stat description.
 *
 * @return 0 on successful, -1 on failed.
 */
int stat(const char *file, struct stat *buf);

/**
 * this function is a POSIX compliant version, which will get file status.
 *
 * @param fildes the file description
 * @param buf the data buffer to save stat description.
 *
 * @return 0 on successful, -1 on failed.
 */
int fstat(int fildes, struct stat *buf);

/**
 * this function is a POSIX compliant version, which shall request that all data
 * for the open file descriptor named by fildes is to be transferred to the storage
 * device associated with the file described by fildes.
 *
 * @param fildes the file description
 *
 * @return 0 on successful completion. Otherwise, -1 shall be returned and errno
 * set to indicate the error.
 */
int fsync(int fildes);

/**
 * this function is a POSIX compliant version, which shall perform a variety of
 * control functions on devices.
 *
 * @param fildes the file description
 * @param cmd the specified command
 * @param data represents the additional information that is needed by this
 * specific device to perform the requested function.
 *
 * @return 0 on successful completion. Otherwise, -1 shall be returned and errno
 * set to indicate the error.
 */
int fcntl(int fildes, int cmd, ...);

/**
 * this function is a POSIX compliant version, which shall perform a variety of
 * control functions on devices.
 *
 * @param fildes the file description
 * @param cmd the specified command
 * @param data represents the additional information that is needed by this
 * specific device to perform the requested function.
 *
 * @return 0 on successful completion. Otherwise, -1 shall be returned and errno
 * set to indicate the error.
 */
int ioctl(int fildes, int cmd, ...);


// rt-thread-4.0.1\components\dfs\src\select.c

/**
 * This function can monitor the I/O device for events.
 *
 * @param nfds the maximum value of all file descriptors plus 1
 * @param readfds Set of read event file descriptors that need to be monitored
 * @param writefds Set of write event file descriptors that need to be monitored
 * @param exceptfds Set of exception event file descriptors that need to be monitored
 *
 * @return >0 A read/write event or error occurred in the monitored file collection. 
 * 		   =0 Waiting for timeout, no readable or writable or erroneous files
 * 		   <0 Error
 */
 int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

select函数比较特殊复杂些，可以阻塞的同时探测一组支持非阻塞的I / O设备是否有事件发生（比如可读、可写、出现异常或错误等），直至某一个设备触发了事件或者超过了指定的等待时间。该函数的实现原理在《Socket API编程：基于Select的并发服务器》中有详细介绍，在lwip中把套接字作文文件描述符对象进行管理的。

目录也是一种特殊类型的文件，目录跟文件还是有些不同，所以DFS POSIC针对目录操作也提供了一组POSIX接口函数集合（实际调用的依然是dfs_file_ops函数集合），目录的数据描述及接口函数声明如下：

// rt-thread-4.0.1\components\dfs\include\dfs_posix.h
typedef struct
{
    int fd;     /* directory file */
    char buf[512];
    int num;
    int cur;
} DIR;


// rt-thread-4.0.1\components\dfs\src\dfs_posix.c

/**
 * this function is a POSIX compliant version, which will make a directory
 *
 * @param path the directory path to be made.
 * @param mode
 *
 * @return 0 on successful, others on failed.
 */
int mkdir(const char *path, mode_t mode);

/**
 * this function is a POSIX compliant version, which will remove a directory.
 *
 * @param pathname the path name to be removed.
 *
 * @return 0 on successful, others on failed.
 */
int rmdir(const char *pathname);

/**
 * this function is a POSIX compliant version, which will open a directory.
 *
 * @param name the path name to be open.
 *
 * @return the DIR pointer of directory, NULL on open directory failed.
 */
DIR *opendir(const char *name);

/**
 * this function is a POSIX compliant version, which will return a pointer
 * to a dirent structure representing the next directory entry in the
 * directory stream.
 *
 * @param d the directory stream pointer.
 *
 * @return the next directory entry, NULL on the end of directory or failed.
 */
struct dirent *readdir(DIR *d);

/**
 * this function is a POSIX compliant version, which will return current
 * location in directory stream.
 *
 * @param d the directory stream pointer.
 *
 * @return the current location in directory stream.
 */
long telldir(DIR *d);

/**
 * this function is a POSIX compliant version, which will set position of
 * next directory structure in the directory stream.
 *
 * @param d the directory stream.
 * @param offset the offset in directory stream.
 */
void seekdir(DIR *d, off_t offset);

/**
 * this function is a POSIX compliant version, which will reset directory
 * stream.
 *
 * @param d the directory stream.
 */
void rewinddir(DIR *d);

/**
 * this function is a POSIX compliant version, which will close a directory
 * stream.
 *
 * @param d the directory stream.
 *
 * @return 0 on successful, -1 on failed.
 */
int closedir(DIR *d);

/**
 * this function is a POSIX compliant version, which will change working
 * directory.
 *
 * @param path the path name to be changed to.
 *
 * @return 0 on successful, -1 on failed.
 */
int chdir(const char *path);

/**
 * this function is a POSIX compliant version, which will return current
 * working directory.
 *
 * @param buf the returned current directory.
 * @param size the buffer size.
 *
 * @return the returned current directory.
 */
char *getcwd(char *buf, size_t size);

上面这些DFS POSIX接口函数是在挂载文件系统后，用户使用文件系统访问文件或目录实际调用的接口函数，使用比较频繁。

2.2 DFS虚拟文件系统层

DFS虚拟文件系统层支持多种类型的文件系统，这里直介绍跟I / O设备管理模型配合的DevFS文件系统和最常用的elmfat文件系统。

2.2.1 devfs设备文件系统

首先看devfs文件系统的初始化过程：

// rt-thread-4.0.1\components\dfs\filesystems\devfs\devfs.c

int devfs_init(void)
{
    /* register rom file system */
    dfs_register(&_device_fs);

    return 0;
}

static const struct dfs_filesystem_ops _device_fs =
{
    "devfs",
    DFS_FS_FLAG_DEFAULT,
    &_device_fops,

    dfs_device_fs_mount,
    RT_NULL,
    RT_NULL,
    RT_NULL,

    RT_NULL,
    dfs_device_fs_stat,
    RT_NULL,
};

static const struct dfs_file_ops _device_fops =
{
    dfs_device_fs_open,
    dfs_device_fs_close,
    dfs_device_fs_ioctl,
    dfs_device_fs_read,
    dfs_device_fs_write,
    RT_NULL,                    /* flush */
    RT_NULL,                    /* lseek */
    dfs_device_fs_getdents,
    dfs_device_fs_poll,
};

前面介绍DFS POSIX时，devfs_init函数被dfs_init调用，不过需要定义条件宏RT_USING_DFS_DEVFS，也即在menuconfig中配置devfs启用后，devfs_init便会被自动调用，同时也会自动挂载devfs设备文件系统。

devfs主要用来管理I / O设备，向DFS POSIX注册的文件操作集合_device_fops最终还是通过调用 I / O设备管理层接口函数实现的，相当于在I / O设备管理框架基础上再封装一层DFS POSIX设备文件系统层，相当于可以直接用DFS POSIX访问文件的接口函数来访问注册到I / O设备管理框架的设备。下面以一个函数示例说明这种调用关系：

// rt-thread-4.0.1\components\dfs\filesystems\devfs\devfs.c

struct device_dirent
{
    rt_device_t *devices;
    rt_uint16_t read_index;
    rt_uint16_t device_count;
};

int dfs_device_fs_open(struct dfs_fd *file)
{
    rt_err_t result;
    rt_device_t device;

    /* open root directory */
    if ((file->path[0] == '/') && (file->path[1] == '\0') &&
        (file->flags & 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;

        /* lock scheduler */
        rt_enter_critical();

        /* traverse device object */
        information = rt_object_get_information(RT_Object_Class_Device);
        RT_ASSERT(information != RT_NULL);
        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 RT_EOK;
    }

    device = rt_device_find(&file->path[1]);
    if (device == RT_NULL)
        return -ENODEV;

#ifdef RT_USING_POSIX
    if (device->fops)
    {
        /* use device fops */
        file->fops = device->fops;
        file->data = (void *)device;

        /* use fops */
        if (file->fops->open)
        {
            result = file->fops->open(file);
            if (result == RT_EOK || result == -RT_ENOSYS)
            {
                return 0;
            }
        }
    }
    else
#endif
    {
        result = rt_device_open(device, RT_DEVICE_OFLAG_RDWR);
        if (result == RT_EOK || result == -RT_ENOSYS)
        {
            file->data = device;
            return RT_EOK;
        }
    }

    file->data = RT_NULL;
    /* open device failed. */
    return -EIO;
}

int dfs_device_fs_read(struct dfs_fd *file, void *buf, size_t count)
{
    int result;
    rt_device_t dev_id;

    RT_ASSERT(file != 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;

    return result;
}

为了便于通过路径文件名的方式访问设备，增加了设备目录描述结构体device_dirent，结构体device_dirent首成员指向设备对象rt_device的句柄，可以通过结构体device_dirent方便的获取已注册设备句柄，并通过设备句柄访问该设备。

结构体device_dirent首成员devices实际上是一个指针数组的首地址，数组元素是设备句柄（指针），数组索引和总元素个数由device_dirent的另外两个成员定义。

结构体device_dirent对象的首地址又被赋值给文件描述符的私有数据成员dfs_fd.data，这样就可以通过文件描述符dfs_fd方便的访问到相应的设备rt_device，实现DFS POSIX接口函数参数到 I / O 设备管理接口函数参数的转换。如果查找设备，文件路径名就包含了设备名，通过file->path[1]便可获得设备名，作为rt_device_find的传入参数。

上面的函数dfs_device_fs_open实际调用的是device->fops->open或rt_device_open，其中后者rt_device_open是我们介绍 I / O设备模型框架时常用的接口形式，前者在介绍设备对象rt_device时介绍过一个成员dfs_file_ops只有在定义条件宏RT_USING_POSIX时有效，成员dfs_file_ops恰是为了支持DFS设备文件系统而定义的。

2.2.2 elmfat虚拟文件系统

elmfat文件系统比devfs更复杂，我们先看下elmfat文件结构及文件依赖关系图：
IOT-OS之RT-Thread（十）--- DFS文件系统管理与devfs/elmfat示例_第3张图片
RT-Thread为了适配DFS框架，在此基础上新增了dfs_elm.c与dfs_elm.h两个文件，主要对ff.h内elmfat文件系统提供的接口按照DFS中dfs_filesystem_ops与dfs_file_ops的格式进行再封装，同时把封装好的符合DFS要求的文件系统接口函数集合dfs_elm注册到DFS框架中去。

elmfat文件系统初始化和注册过程如下：

// rt-thread-4.0.1\components\dfs\filesystems\elmfat\dfs_elm.c

int elm_init(void)
{
    /* register fatfs file system */
    dfs_register(&dfs_elm);

    return 0;
}
INIT_COMPONENT_EXPORT(elm_init);

static const struct dfs_filesystem_ops dfs_elm =
{
    "elm",
    DFS_FS_FLAG_DEFAULT,
    &dfs_elm_fops,

    dfs_elm_mount,
    dfs_elm_unmount,
    dfs_elm_mkfs,
    dfs_elm_statfs,

    dfs_elm_unlink,
    dfs_elm_stat,
    dfs_elm_rename,
};

static const struct dfs_file_ops dfs_elm_fops =
{
    dfs_elm_open,
    dfs_elm_close,
    dfs_elm_ioctl,
    dfs_elm_read,
    dfs_elm_write,
    dfs_elm_flush,
    dfs_elm_lseek,
    dfs_elm_getdents,
    RT_NULL, /* poll interface */
};

elmfat初始化函数被自动初始化组件调用，不需要用户再手动调用了。elmfat文件系统向上层DFS注册的接口函数集合就不展开讲了（如果展开介绍还需要再介绍ff.h与ff.c中elmfat文件系统的具体实现过程）。

要移植elmfat文件系统，还需要了解其对底层 I / O设备的操作，从elmfat文件结构可知，该部分接口在diskio.h中声明，要移植elmfat文件系统，需要我们把diskio.h中声明的函数实现出来。RT-Thread同样帮我们在dfs_elm.c中实现了，移植函数的实现如下：

// rt-thread-4.0.1\components\dfs\filesystems\elmfat\dfs_elm.c

/* Read Sector(s) */
DRESULT disk_read(BYTE drv, BYTE *buff, DWORD sector, UINT count)
{
    rt_size_t result;
    rt_device_t device = disk[drv];

    result = rt_device_read(device, sector, buff, count);
    if (result == count)
    {
        return RES_OK;
    }

    return RES_ERROR;
}

/* Write Sector(s) */
DRESULT disk_write(BYTE drv, const BYTE *buff, DWORD sector, UINT count)
{
    rt_size_t result;
    rt_device_t device = disk[drv];

    result = rt_device_write(device, sector, buff, count);
    if (result == count)
    {
        return RES_OK;
    }

    return RES_ERROR;
}

/* Miscellaneous Functions */
DRESULT disk_ioctl(BYTE drv, BYTE ctrl, void *buff)
{
    rt_device_t device = disk[drv];

    if (device == RT_NULL)
        return RES_ERROR;

    if (ctrl == GET_SECTOR_COUNT)
    {
        struct rt_device_blk_geometry geometry;

        rt_memset(&geometry, 0, sizeof(geometry));
        rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry);

        *(DWORD *)buff = geometry.sector_count;
        if (geometry.sector_count == 0)
            return RES_ERROR;
    }
    else if (ctrl == GET_SECTOR_SIZE)
    {
        struct rt_device_blk_geometry geometry;

        rt_memset(&geometry, 0, sizeof(geometry));
        rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry);

        *(WORD *)buff = (WORD)(geometry.bytes_per_sector);
    }
    else if (ctrl == GET_BLOCK_SIZE) /* Get erase block size in unit of sectors (DWORD) */
    {
        struct rt_device_blk_geometry geometry;

        rt_memset(&geometry, 0, sizeof(geometry));
        rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry);

        *(DWORD *)buff = geometry.block_size / geometry.bytes_per_sector;
    }
    else if (ctrl == CTRL_SYNC)
    {
        rt_device_control(device, RT_DEVICE_CTRL_BLK_SYNC, RT_NULL);
    }
    else if (ctrl == CTRL_TRIM)
    {
        rt_device_control(device, RT_DEVICE_CTRL_BLK_ERASE, buff);
    }

    return RES_OK;
}

从上面的代码可以看出，elmfat文件系统对磁盘设备的操作函数最终是通过调用 I / O设备管理接口函数实现的。

elmfat只能挂载到块设备上，比如SPI / QSPI Flash或SD Card等，前篇文章才介绍过SPI设备对象管理与SFUD管理，这里比较方便的办法是通过SFUD框架管理SPI / QSPI Flash，SFUD框架也会向 I / O设备管理层注册统一的接口函数集合，下面我们在前一篇通过SFUD访问W25Q128示例的基础上使用DFS文件系统。

2.3 DFS设备抽象层

DFS设备抽象层主要用于驱动具体的 I / O块设备，前一篇介绍的SFUD管理SPI / QSPI Flash的框架就属于DFS设备抽象层，这里就不再赘述了。

SFUD框架一般按物理设备的个数为单位驱动的，也即一个SPI Flash（比如W25Q128）为一个块设备，如果我们想对一个Flash分为多个逻辑设备或者多个分区，每个分区的作用不同或者挂载不同的文件系统，也即只想在一个Flash的一个分区上挂载某文件系统（比如elmfat），可以借助FAL（Flash Abstraction Layer)）Flash抽象层来实现该需求。

FAL可对多个物理Flash统一管理，也可能将某一物理Flash划分为多个逻辑分区，可以在每个分区上创建块设备，用于上层文件系统的挂载，FAL框架图如下：
IOT-OS之RT-Thread（十）--- DFS文件系统管理与devfs/elmfat示例_第4张图片
FAL Flash抽象层并非必要，这里限于篇幅留待后面再介绍，下面先基于SFUD框架展示DFS devfs与elmfat文件系统的使用示例。

三、DFS文件系统示例

这里在示例工程通过SFUD访问W25Q128示例的基础上新增，为了突出DFS文件系统组件，将stm32l475_device_sample复制一份并改名stm32l475_dfs_sample，DFS示例工程在stm32l475_dfs_sample的基础上新增。

3.1 devfs文件系统示例

切换到工程目录stm32l475_dfs_sample，打开env输入menuconfig，启用Device Virtual file system与devfs的配置界面如下：
IOT-OS之RT-Thread（十）--- DFS文件系统管理与devfs/elmfat示例_第5张图片
保存配置并退出，在projects\stm32l475_dfs_sample\applications目录下新建文件dfs_sample.c（将原先的pin_sample.c与spi_sample.c移到新建文件夹\applications\old_sample中不参与编译），打开文件dfs_sample.c编写devfs示例代码（我使用的VS Code代码编译器）。

本示例想同时包含目录访问与文件访问，devfs主要用于访问挂载到“/dev”目录下的设备，所以本示例先读取/dev目录下所有的设备，再通过DFS POSIX接口访问PIN设备中的蜂鸣器，实现配置蜂鸣器模式、读写蜂鸣器状态的功能。按照实现目标编写的代码如下：

// projects\stm32l475_dfs_sample\applications\dfs_sample.c

#include "rtdevice.h"
#include "rtthread.h"
#include "board.h"
#include "dfs_posix.h"


#define BEEP_PIN    GET_PIN(B, 2)

static void devfs_sample(void)
{
    int fd;
    DIR *dirp;
    struct dirent *d;
    struct rt_device_pin_mode beepmode;
    struct rt_device_pin_status beepstatus, tempstatus;

    dirp = opendir("/dev");
    if(dirp == RT_NULL){
        rt_kprintf("open directory error!\n");
    }else{
        while ((d = readdir(dirp)) != RT_NULL){
            rt_kprintf("found device: %s\n", d->d_name);
        }
        closedir(dirp);
    }

    beepmode.pin = beepstatus.pin = tempstatus.pin = BEEP_PIN;
    beepmode.mode = PIN_MODE_OUTPUT;
    beepstatus.status = PIN_HIGH;

    rt_kprintf("Control beep via devfs.\n");
    
	/* 打开设备文件的标识RT_DEVICE_OFLAG_OPEN */
    fd = open("/dev/pin", RT_DEVICE_OFLAG_OPEN);
    if(fd >= 0){
        if(ioctl(fd, 0, &beepmode) == 0)
            rt_kprintf("Beep pin mode config finish.\n");

        if(write(fd, &beepstatus, sizeof(beepstatus)) == sizeof(beepstatus))
            rt_kprintf("Beep turn on.\n");

        if(read(fd, &tempstatus, sizeof(tempstatus)) == sizeof(tempstatus))
            rt_kprintf("Beep pin status: %d.\n", tempstatus.status);

        close(fd);
    }

    rt_thread_mdelay(3000);

    beepstatus.status = PIN_LOW;

    fd = open("/dev/pin", RT_DEVICE_OFLAG_OPEN);
    if(fd >= 0){
        if(write(fd, &beepstatus, sizeof(beepstatus)) == sizeof(beepstatus))
            rt_kprintf("Beep turn off.\n");

        if(read(fd, &tempstatus, sizeof(tempstatus)) == sizeof(tempstatus))
            rt_kprintf("Beep pin status: %d.\n", tempstatus.status);

        close(fd);
    }
}
MSH_CMD_EXPORT(devfs_sample, devfs sample);

在env环境中执行scons --target=mdk5生成MDK5工程代码，打开project.uvprojx编译报错，将编译器配置为ARM Compiler V5，重新编译无报错。将程序烧录到STM32L475潘多拉开发板上，运行结果如下：
IOT-OS之RT-Thread（十）--- DFS文件系统管理与devfs/elmfat示例_第6张图片
从串口工具putty通过finsh组件交互结果看，运行devfs_sample示例程序运行正常，通过读取目录/dev下的设备文件和list_device命令获取的设备列表一致，通过DFS POSIX接口也可以正常控制蜂鸣器PIN设备。

DFS除了提供POSIX接口函数外，还提供了FINSH部分命令，便于用户通过finsh访问设备文件和目录。

本示例工程源码下载地址：https://github.com/StreamAI/RT-Thread_Projects/tree/master/projects/stm32l475_dfs_sample

3.2 elmfat文件系统示例

该工作目录env环境输入menuconfig命令，新增elmfat文件系统配置如下：
IOT-OS之RT-Thread（十）--- DFS文件系统管理与devfs/elmfat示例_第7张图片
需要注意的是，elmfat文件系统默认的最大扇区大小maximum sector size是512，在前篇博客介绍W25Q128时谈到W25Q128 Flash的扇区大小为4096，本示例我们要将elmfat文件系统挂载到W25Q128 Flash上，所以需要将maximum sector size修改为4096，然后保存配置退出。

本示例目的是在W25Q128 Flash上挂载elmfat文件系统，在挂载前需要先在W25Q128 Flash上创建elmfat格式的文件系统，挂在成功后通过DFS POSIX接口获取该文件系统的统计信息。在挂载elmfat的路径“/”下新建目录“/user”，使用DFS POSIX接口打开、关闭文件，并往该文件中写入、读取数据。

前篇博客已经完成了使用SFUD框架管理W25Q128 Flash，并向 I / O设备管理层注册了访问W25Q128 Flash的接口函数集合，所以elmfat文件系统可以直接通过 I / O设备管理接口访问到W25Q128。在文件dfs_sample.c中新增elmfat示例代码如下：

// projects\stm32l475_dfs_sample\applications\dfs_sample.c

#include "drv_qspi.h"
#include "spi_flash_sfud.h"

#define QSPI_BUD_NAME       "qspi1"
#define QSPI_DEVICE_NAME    "qspi10"
#define W25Q_FLASH_NAME     "W25Q128"

#define QSPI_CS_PIN         GET_PIN(E, 11)

static int rt_hw_spi_flash_init(void)
{
    if(stm32_qspi_bus_attach_device(QSPI_BUD_NAME, QSPI_DEVICE_NAME, (rt_uint32_t)QSPI_CS_PIN, 1, RT_NULL, RT_NULL) != RT_EOK)
        return -RT_ERROR;

    if(rt_sfud_flash_probe(W25Q_FLASH_NAME, QSPI_DEVICE_NAME) == RT_NULL)
        return -RT_ERROR;

    return RT_EOK;
}
INIT_COMPONENT_EXPORT(rt_hw_spi_flash_init);

static void elmfat_sample(void)
{
    int fd, size;
    struct statfs elm_stat;
    char str[] = "elmfat mount to W25Q flash.", buf[80];

    if(dfs_mkfs("elm", W25Q_FLASH_NAME) == 0)
        rt_kprintf("make elmfat filesystem success.\n");

    if(dfs_mount(W25Q_FLASH_NAME, "/", "elm", 0, 0) == 0)
        rt_kprintf("elmfat filesystem mount success.\n");

    if(statfs("/", &elm_stat) == 0)
        rt_kprintf("elmfat filesystem block size: %d, total blocks: %d, free blocks: %d.\n", 
                    elm_stat.f_bsize, elm_stat.f_blocks, elm_stat.f_bfree);

    if(mkdir("/user", 0x777) == 0)
        rt_kprintf("make a directory: '/user'.\n");

    rt_kprintf("Write string '%s' to /user/test.txt.\n", str);

    /* 以创建和读写模式打开文件，如果该文件不存在则创建该文件*/
    fd = open("/user/test.txt", O_WRONLY | O_CREAT);
    if (fd >= 0)
    {
        if(write(fd, str, sizeof(str)) == sizeof(str))
            rt_kprintf("Write data done.\n");

        close(fd);   
    }

    /* 以只读模式打开文件 */
    fd = open("/user/test.txt", O_RDONLY);
    if (fd >= 0)
    {
        size = read(fd, buf, sizeof(buf));

        close(fd);

        if(size == sizeof(str))
            rt_kprintf("Read data from file test.txt(size: %d): %s \n", size, buf);
    }
}
MSH_CMD_EXPORT(elmfat_sample, elmfat sample);

在env环境中执行scons --target=mdk5生成MDK5工程代码，打开project.uvprojx，将编译器配置为ARM Compiler V5，编译无报错。将程序烧录到STM32L475潘多拉开发板上，运行结果如下：
IOT-OS之RT-Thread（十）--- DFS文件系统管理与devfs/elmfat示例_第8张图片
通过自动初始化组件配置了QSPI和SFUD，将elmfat文件系统挂载到W25Q128 Flash上的路径"/"成功，并通过DFS POSIX接口访问目录和文件正常。

DFS提供的finsh命令跟Linux访问目录和文件的命令类似，部分命令的使用也在上图给出了示范。

本示例工程源码下载地址：https://github.com/StreamAI/RT-Thread_Projects/tree/master/projects/stm32l475_dfs_sample

更多文章：

  • 《RT-Thread Sample Project Source Code Based on STM32L475》
  • 《IOT-OS之RT-Thread（九）— SPI设备对象管理与SFUD管理框架》
  • 《IOT-OS之RT-Thread（十一）— FAL分区管理与easyflash变量管理》

你可能感兴趣的:(操作系统,STM32,流云的博客)

  • 龙蜥衍生版 KOS 助力厦门高校创新实验室智算 300 节点成功迁移 | 龙蜥案例 操作系统开源
    编者按：近期，龙蜥社区发布《龙蜥操作系统生态用户实践精选V2》，收录包括龙蜥社区版AnolisOS及衍生版AlibabaCloudLinux、浪潮信息云峦服务器操作系统KeyarchOS、统信服务器操作系统V20等案例，涉及政务、金融、交通、电力等重点行业。龙蜥公众号将详细介绍案例内容，形成「龙蜥案例」系列文章，为大家带来不同行业的标杆实践样板。随着CentOS停更，用户无法获得安全补丁和漏洞修复
  • 【docker】docker的起源与容器的由来、docker容器的隔离机制 {⌐■_■} docker
    Docker的起源与容器的由来1.虚拟机的局限：容器的需求萌芽在Docker出现之前，开发和部署软件主要依赖虚拟机（VMs）：虚拟机通过模拟硬件运行操作系统，每个应用程序可以运行在自己的独立环境中。虽然虚拟机解决了隔离问题，但它们的缺点也很明显：占用资源多：每个虚拟机需要运行一个完整的操作系统，占用大量内存和存储。启动慢：启动虚拟机往往需要几分钟，影响开发和测试效率。部署繁琐：跨环境迁移应用时，环
  • python 获取windows管理员权限 天涯望小楼 python开发语言
    Python,Windows相关视频讲解：python的or运算赋值用法用python编程Excel有没有用处？011_编程到底好玩在哪？查看python文件_输出py文件_cat_运行python文件_shelPython获取Windows管理员权限在Windows操作系统中，有时我们需要运行一些需要管理员权限的任务，例如修改系统设置、安装软件等。在Python中，我们可以通过一些方法来获取管理
  • 使用Python打开和执行BAT文件的简单指南 JmLei Winpython
    使用Python打开和执行BAT文件的简单指南在现代计算机中，批处理文件（.bat或.cmd文件）是一种强大的工具，可以有效地执行一系列命令，这些命令可以由操作系统直接运行。在某些情况下，我们希望通过Python程序来调用和执行这些批处理文件。本篇文章将详细介绍如何用Python打开和执行BAT文件，并提供代码示例。什么是BAT文件？BAT文件是一种文本文件，通常含有Windows命令行中的一系列
  • 你的Go应用真的用了正确的 CPU 核数吗？ go
    Go的调度模型是GMP，其中G是goroutine，M是线程，P是可用的CPU核数。多个G会共用一个M。M作为操作系统层面上的调度单位，在执行时需要绑定到P。如果操作系统认为的某个Go进程可用的CPU数，和该进程认为的可用的CPU数不一致，那么即使把M绑定到某个P上，操作系统也不一定会执行这个线程。所以能否获取准确的可用CPU核数会影响Go的调度效率。当用户在k8s中设置了资源限制：spec:co
  • Python 获取管理员权限 一台电脑可以让你哭吗 Pythonpython开发语言
    方法一：使用ctypes库调用系统APIPython中的【ctypes】库允许我们调用操作系统的动态链接库函数，来获取管理员权限。importctypesimportsysdefis_admin():try:returnctypes.windll.shell32.IsUserAnAdmin()except:returnFalseifnotis_admin():ctypes.windll.shell
  • 【QT进阶】Qt线程与并发之线程和并发的简单介绍 不吃~香菜 QT进阶qt开发语言线程并发
    往期回顾：【QT进阶】Qthttp编程之实现websocketserver服务器端-CSDN博客【QT进阶】Qthttp编程之实现websocketclient客户端-CSDN博客【QT进阶】Qt线程与并发之创建线程的三种方法(超详细介绍)-CSDN博客【QT进阶】Qt线程与并发之线程和并发的简单介绍一、什么是线程和并发主要是做一个简单的补充说明1、线程线程是程序执行的最小单元，是操作系统能够进行
  • python mysql库的三个库mysqlclient mysql-connector-python pymysql如何选择，他们之间的区别 zhangfeng1133 数据库pythonmysql
    三者的区别1.mysqlclient特点：是一个用于Python的MySQL数据库驱动程序，用于与MySQL数据库进行交互。依赖于MySQL的本地库，因此在安装时需要确保系统上已安装了必要的依赖项，如libmysqlclient-dev等。性能较好，但安装过程可能较为复杂，尤其是在某些操作系统上。安装：直接使用pip安装可能会遇到各种问题，如缺少依赖项、编译失败等。可以尝试使用预编译的二进制文件（
  • 如何安装和配置PHP开发环境？ m0_74824661 面试学习路线阿里巴巴java
    要安装和配置PHP开发环境，可以按照以下步骤进行：一、下载和安装PHP1：下载PHP：访问PHP官方网站（PHP:Downloads），选择适合您操作系统的版本进行下载。2：解压并安装PHP：下载完成后，将压缩包解压到指定目录。编辑php.ini文件，确保其中的displayerrors设置为on，以便在开发过程中能够看到错误信息。例如：display_errors=On二、下载和安装Apache
  • 一文了解Sublime Text基本 使用教程 SUDO-1 sublimetext编辑器
    SublimeText是一个非常受欢迎的跨平台源代码编辑器，以其高性能、轻量级和高度可定制性而闻名。下面是一些基本的使用技巧和配置方法，帮助你更高效地使用SublimeText：安装与基本设置安装：访问官方网站下载对应操作系统的版本。按照安装向导提示进行安装。基本设置：调整字体大小和行间距以适应个人喜好。设置自动完成和代码补全功能。启用行号显示。基本功能多光标编辑：使用Ctrl+D(Windows
  • Tesla V100驱动安装 郭宝才 linux服务器运维
    确认操作系统kernel版本，参考链接：https://docs.nvidia.com/cuda/archive/12.2.0/cuda-installation-guide-linux/index.html安装依赖yuminstall-ygccgcc-c++rdma-coredkmselfutils-libelf-develntpyuminstall-ykernel-devel-$(uname-
  • 多线程在打包工具中的运用 前端
    我们是袋鼠云数栈UED团队，致力于打造优秀的一站式数据中台产品。我们始终保持工匠精神，探索前端道路，为社区积累并传播经验价值。本文作者：UED团队现代操作系统都是「多任务」的，也就是操作系统可以「并发」处理多个任务，比如可以在浏览页面的时候同时播放音乐。但是，一般来说我们的PC只有一个物理CPU，那么它是如何做到在只有一个CPU的情况下，并发处理多个任务的呢？我们简单探究一下。前置知识我们先简单熟
  • 浏览器安全沙箱 weixin_43605299 jsjavascript安全
    一、概要：浏览器安全可以分为三大块—Web页面安全、浏览器网络安全、浏览器系统安全二、从安全的角度看待，为什么浏览器要从单进程发展？对于单进程应用，即整个浏览器只有一个进程。当浏览器出现一些重要的漏洞时，黑客可以直接攻击操作系统，获取操作系统中的用户信息。这毫无疑问是“核弹”级别的漏洞。对于多进程架构的浏览器。即使出现漏洞，那么黑客也只能攻击到渲染进程。而浏览器内核还是安全的。三、浏览器安全沙箱：
  • IBM X3400服务器网卡深度解析与应用指南 易个小小钡原子
    本文还有配套的精品资源，点击获取简介：IBMX3400服务器的网络适配器是连接服务器与网络的关键硬件，具备高可靠性和稳定性。本文将探讨IBMX3400网卡的特性、功能以及驱动程序安装与管理。网卡支持多种网络协议如TCP/IP、UDP，确保高效准确的数据传输。IBM官方提供的网卡驱动程序对于硬件的正确识别和性能至关重要，同时需确保其与WindowsServer2003等操作系统的兼容性。官方文档提供
  • STM32系列在电机控制领域的辨析 清风明月自在愁 总结c语言C++
    STM32系列在电机控制领域的辨析（F0、F1、F4、G4、H7）STM32系列微控制器在电机控制领域应用广泛，不同系列针对不同的性能需求和成本预算。以下是F0、F1、F4、G4、H7系列在电机控制中的特点对比，特别是针对FOC（磁场定向控制）的应用。—1.STM32F0系列内核：ARMCortex-M0-主频：最高48MHz-特点：-低成本、低功耗，适合入门级应用。-外设资源有限，适合简单的六步
  • GD32的GD库开发 SundayBear 单片机嵌入式硬件
    所有的Cortex-M处理器都有相同的SysTick定时器，因为CMSIS-Core头文件中定义了一个名为SysTick的结构体。这个定时器可以用作延时函数，不管是STM32的芯片还是GD32，AT32的芯片，delay函数都可以这么写，只要它是cortex-M3/M4的芯片。以下代码基于GD32F303，主频120M。延迟函数示例代码代码移植于江科大。/***@brief微秒级延时*@param
  • Flix：局域网内实现不同设备间文件传输 小马不是哥哥 pythondjangopygamejava
    在工作中的团队协作和家庭中的照片分享场景中，一个高效且安全的共享工具是十分重要的。今天，我给大家介绍一款专为局域网环境设计的跨设备文件和文本共享软件——flix。主要功能跨平台支持：兼容Windows、macOS、Linux以及主流的移动操作系统，能够轻松连接多种不同设备。文件共享：支持大文件和多文件的批量传输，用户无需担心文件大小或数量的限制。文本共享：可以方便快捷地共享文本内容，帮助用户快速传
  • 免费好用的多功能压缩和解压缩软件Bandizip 红枫下的独唱 软件分享压缩软件Bandizip
    一、软件介绍Bandizip是一款由韩国Bandisoft公司开发的多功能压缩和解压缩软件，广泛应用于Windows和macOS操作系统。它以其高效、快速、易用的特点受到用户好评，是目前市场上较为流行的压缩工具之一。二、主要功能1、支持多种格式Bandizip支持包括ZIP、7Z、RAR、TAR、GZ、XZ、LZH、ISO、EXE、APK、ARJ、AR、BZ2、BZ、JAR、ZPAQ、ZMA等在内
  • stm32 HAL读取GZP6816D传感器 西之可乐 stm32嵌入式硬件单片机
    GZP6816D是一款国产的压力传感器。读取数据的指令如下：代码如下。但在换算中，最后加上去的20，感觉跟实际大气压差了10Kpa，所有，在计算的时候加上去的是30。voidGet_GZP6816D_Data(void){constunsignedcharwrite_address=0xF0;//(0x78<<1);constunsignedcharread_address=0xF1;//(0x7
  • c++介绍与入门基础（详细总结） X_Pqk c++开发语言
    操作系统以及大型系统软件开发服务器端开发游戏开发嵌入式和物联网领域数字图像处理人工智能分布式应用C++关键字命名空间实际工程应用中：命名空间的作用：命名空间需求展示命名空间定义命名空间使用C++输入&输出c++的《helloworld》输入&输出说明：输入&输出展示std命名空间的使用惯例缺省参数缺省参数概念缺省参数分类函数重载函数重载概念C++支持函数重载的原理–名字修饰(nameManglin
  • Linux上安装Apache HTTP服务器 华科℡云 linux运维服务器
    ApacheHTTPServer，简称Apache，是世界上最流行的开源Web服务器软件之一。它以其高度的可靠性、强大的功能和广泛的兼容性而闻名。在Linux操作系统上安装Apache服务器是一个相对简单的过程，无论是用于个人网站托管、企业服务部署，还是作为开发测试环境，Apache都是一个不错的选择。以下是在Linux上安装ApacheHTTP服务器的详细步骤。1.更新软件包列表在安装任何新软件
  • 【window批处理文件快速入门学习--这份文档就够了】 少年近视 批处理adb学习batch
    一、简介1.1什么是批处理文件？批处理文件（BatchFile）是一种包含一系列DOS命令的文本文件，通常用于自动化重复性任务。文件的扩展名为.bat或.cmd，当在命令提示符下运行时，操作系统会按顺序执行文件中的命令。批处理文件的创建和使用为用户提供了高效的命令行操作方式。示例：创建一个简单的批处理文件，文件名为example.bat，内容如下：@echooffecho这是一个简单的批处理文件。
  • 从零基础开始实现一个Spring Boot + Vue 项目的详细步骤指南 软件职业规划 springspringbootvue.js后端
    一、准备工作1.开发环境搭建安装JDK（JavaDevelopmentKit）：前往Oracle官网（https://www.oracle.com/java/technologies/javase-jdk11-downloads.html，以JDK11为例）下载适合你操作系统的JDK安装包，按照安装向导完成安装。安装完成后，配置系统环境变量，确保在命令行中能通过java-version命令查看到正
  • 基于AT32(STM32)单片机的模块化代码之——按键代码模块化 大白哦 单片机c语言案例项目开发
    基于AT32(STM32)单片机的模块化代码之按键模块化1.环境介绍平台：AT32F415单片机，雅特力公司的AT32系列单片机其实跟STM32系列单片机大同小异，包括库函数等基本都是一样的，所以这款代码无论是AT32还是STM32都是适用的。开发环境：MDKV5forarm简介：最近做项目经常用得到按键模块，包括按键扫描，按键长按，短按，组合按的判定，所以特地把按键模块做了整理，让其模块化更加好
  • openbmc csu_fky c++
    openbmc这个开源项目编译出来的是固件，也可以说是镜像，它是一个可以运行在BMC芯片上的小型操作系统。我们可以在不同架构的CPU，不同的linux操作系统上面进行编译，最后得到的镜像适用于各个架构的CPU。在对固件进行测试时，可以通过网线与BMC开发板连接，进行相应的测试。在开发板资源不足时，可以通过qemu这个工具来代替。qemu可以虚拟出相应的硬件，例如它本身有x86或者arm架构的版本，
  • C51基础知识 promising-w 单片机单片机嵌入式硬件
    1.什么是C51？计算机平台——C语言单片机平台——C51计算机平台的CPU主频，内存和硬盘相较于单片机平台都是巨大的量级，另一方面，计算机平台的有不同的操作系统，如Windows，Linux，macOS等，单片机一般是没有操作系统的，（也会有一些简单的操作系统如：RTOS,但与计算机平台的系统相比，还是较为简单的）代码直接运行在芯片上，我们常称为裸机开发，计算机平台的开发叫做基于系统的开发。另外
  • Avalonia+ReactiveUI跨平台路由：打造丝滑UI交互的奇幻冒险 步、步、为营 ui交互.netc#
    一、引言在当今数字化时代，跨平台应用开发已成为大势所趋。开发者们迫切需要一种高效、灵活的方式，能够让应用程序在不同操作系统上无缝运行，为用户提供一致的体验。Avalonia和ReactiveUI的组合，宛如一对天作之合的舞者，在跨平台开发的舞台上翩翩起舞，为我们带来了前所未有的可能。Avalonia是一个开源的跨平台UI框架，它以其强大的跨平台能力而备受瞩目。无论是Windows、Linux还是m
  • 自定义HTTPS证书用于内网环境 小时候的阳光 运维https证书内网自定义nginx
    自定义HTTPS证书用于内网环境，记录一下简单步骤，方便后面查看自定义HTTPS证书通常用于开发和测试环境，而不是生产环境，因为自签名证书不会被浏览器和操作系统默认信任，自签名证书主要用于内网加密。以下是创建自签名HTTPS证书的步骤：1.安装OpenSSL确保你的系统上安装了OpenSSL。大多数Linux发行版和macOS都预装了OpenSSL。对于Windows，你可能需要手动安装。2.生成
  • 基于STM32的智能饮水机控制系统设计 STM32发烧友 stm32嵌入式硬件单片机
    目录引言系统设计硬件设计软件设计系统功能模块温度控制模块水位监测模块用户交互与显示模块自动清洁与维护模块数据上传与远程管理模块控制算法温控算法水位监测与提醒算法自动清洁调度算法代码实现温控与水位监测代码自动清洁与用户交互代码数据上传与远程管理代码系统调试与优化结论与展望1.引言智能饮水机通过自动化控制和联网功能提升了用户的饮水体验。相比传统饮水机，智能饮水机能够实时监控水温、水位、运行状态，并提供
  • 基于STM32的智能温室监控与控制系统设计 STM32发烧友 stm32嵌入式硬件单片机
    目录引言系统设计硬件设计软件设计系统功能模块温湿度监控模块CO2监测模块灌溉控制模块风扇控制模块数据通信模块代码实现4.1温湿度监控模块4.2CO2监测模块4.3灌溉控制模块4.4风扇控制模块4.5数据通信模块系统调试与优化结论与展望1.引言随着现代化温室农业的发展，传统的温室管理方法逐渐向自动化和智能化转型。智能温室监控与控制系统能够实时监控温室内的各项环境参数，并根据预设条件自动调节温室内的温
  • LeetCode[位运算] - #137 Single Number II Cwind javaAlgorithmLeetCode题解位运算
    原题链接：#137 Single Number II  要求： 给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间   难度：中等   分析： 与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
  • 《JavaScript语言精粹》笔记 aijuans JavaScript
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
  • 你应该更新的Java知识之常用程序库 Kai_Ge java
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 Guava Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
  • HttpClient 120153216 httpclient
    /** * 可以传对象的请求转发，对象已流形式放入HTTP中 */ public static Object doPost(Map<String,Object> parmMap,String url) { Object object = null; HttpClient hc = new HttpClient(); String fullURL
  • Django model字段类型清单 2002wmj django
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段) BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。 Cha
  • 在SQLSERVER中查找消耗CPU最多的SQL 357029540 SQL Server
    返回消耗CPU数目最多的10条语句 SELECT TOP 10    total_worker_time/execution_count AS avg_cpu_cost, plan_handle,    execution_count,    (SELECT SUBSTRING(text, statement_start_of
  • Myeclipse项目无法部署，Undefined exploded archive location 7454103 eclipseMyEclipse
    做个备忘！ 错误信息为：       Undefined exploded archive location 原因：           在工程转移过程中，导致工程的配置文件出错； 解决方法：    
  • GMT时间格式转换 adminjun GMT时间转换
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 1、可以使用 SimpleDateFormat SimpleDateFormat    EEE-三位星期 d-天 MMM-月 yyyy-四位年
  • Oracle数据库新装连接串问题 aijuans oracle数据库
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： Fatal NI connect error 12170.   VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
  • 回顾java数组复制 ayaoxinchao java数组
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
  • java web会话监听并使用spring注入 bewithme Java Web
            在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。        import java.util.ArrayList; import java.ut
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用) bijian1013 redis数据库NoSQL
    一 .Redis常用命令         Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。         a.键值相关命令         b.服务器相关命令 1.键值相关命令       &
  • java枚举序列化问题 bingyingao java枚举序列化
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 1.加一个枚举值 新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 2.删一个枚举值 新机器代码读分布式缓存中老对象，反序列
  • 【Spark七十八】Spark Kyro序列化 bit1129 spark
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 Spark
  • Hybridizing OO and Functional Design bookjovi erlanghaskell
      推荐博文： Tell Above, and Ask Below - Hybridizing OO and Functional Design 文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
  • Java-Collections Framework学习与总结-HashMap BrokenDreams Collections
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。  &nb
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请 * bylijinnan */ abstract class Handler { /*
  • Android中启动外部程序 cherishLC android
    1、启动外部程序 引用自： http://blog.csdn.net/linxcool/article/details/7692374 //方法一 Intent intent=new Intent(); //包名 包名+类名（全路径） intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
  • summary_keep_rate coollyj SUM
    BEGIN /*DECLARE minDate varchar(20) ; DECLARE maxDate varchar(20) ;*/ DECLARE stkDate varchar(20) ; DECLARE done int default -1; /* 游标中 注册服务器地址 */ DE
  • hadoop hdfs 添加数据目录出错 daizj hadoophdfs扩容
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
  • grep 目录级联查找 dongwei_6688 grep
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： grep -n -r "GET" .   上面的命令将会找出当前目录“.”及当前目录中所有下级目录
  • yii 修改模块使用的布局文件 dcj3sjt126com yiilayouts
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如: 'theme'=>'mythm', 那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件； 如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
  • 设计模式之单例模式 come_for_dream 设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。   *********************************
  • 8、数组 豆豆咖啡 二维数组数组一维数组
      一、概念       数组是同一种类型数据的集合。其实数组就是一个容器。   二、好处       可以自动给数组中的元素从0开始编号，方便操作这些元素   三、格式   //一维数组 1,元素类型[] 变量名 = new 元素类型[元素的个数] int[] arr =
  • Decode Ways hcx2013 decode
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 'A' -> 1 'B' -> 2 ... 'Z' -> 26 Given an encoded message containing digits, det
  • Spring4.1新特性——异步调度和事件机制的异常处理 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • squid3(高命中率)缓存服务器配置 liyonghui160com
        系统:centos 5.x   需要的软件:squid-3.0.STABLE25.tar.gz 1.下载squid wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz tar zxf squid-3.0.STABLE25.tar.gz &&
  • 避免Java应用中NullPointerException的技巧和最佳实践 pda158 java
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。 　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 Object unk
  • 如何在Swift语言中创建http请求 shoothao httpswift
    概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。 如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 在这里,我将作出一些建议来回答上述问题。常见的
  • Spring事务的传播方式 uule spring事务
    传播方式：        新建事务       required       required_new   - 挂起当前         非事务方式运行       supports   &nbs
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他