SylixOS I/O系统

SylixOS I/O系统简介

SylixOS 兼容标准的POSIX输入输出系统，使用户非常容易上手。SylixOS 的I/O概念与UNIX兼容系统相同，认为一切都是文件。这些文件有不同的类型，它们包括：

目录文件：这个文件包含了其他文件的名字以及这些文件的指针。

块设备文件：这种文件提供的 I/O 接口标准符合 SylixOS 对块设备的定义。

字符设备文件：这是标准的不带缓冲的设备文件，系统中的设备不是块设备就是字符设备。

FIFO文件：管道通信文件。它对应了一个命名管道。

套接字（socket）文件：进程间或者主机间的网络通信。

在SylixOS中对文件的操作也同样遵循UNIX的方法，主要通过open、read、write、close等函数调用来操作文件。

SylixOS I/O驱动结构

SylixOS中I/O驱动结构分为ORIG型和NEW_1型，下面的两幅图分别对应了这两种类型的驱动结构。





从两幅图可以看出NEW_1型驱动结构在ORIG型驱动结构的基础上增加了文件节点层（这一层相当于UNIX系统的vnode），这一层的引入，使SylixOS对文件的操作支持了记录锁，文件权限的功能。下面我重点学习一下文件节点层之下的各层。

SylixOS设备头

typedef struct {
LW_LIST_LINE               DEVHDR_lineManage;              /*  设备头管理链表              */
UINT16                     DEVHDR_usDrvNum;                /*  设备驱动程序索引号           */
PCHAR                      DEVHDR_pcName;                  /*  设备名称                   */
UCHAR                      DEVHDR_ucType;                  /*  设备 dirent d_type        */
atomic_t                   DEVHDR_atomicOpenNum;           /*  打开的次数                 */
PVOID                      DEVHDR_pvReserve;               /*  保留                      */
} LW_DEV_HDR;
typedef LW_DEV_HDR            *PLW_DEV_HDR;

上面结构就是SylixOS设备头结构，此结构中包含以下一些信息：

DEVHDR_lineManage这是一个设备链表，设备安装时将自动链到系统设备链表上；

DEVHDR_usDrvNum设备驱动程序索引号，SylixOS内核维护了一个驱动表如上面的两个图所示，每一个SylixOS设备都对应了一个驱动表项，当然不同的设备可以对应到同一个驱动表项，也就是说可以拥有一套驱动方法；

DEVHDR_pcName设备名字，每一个SylixOS设备都应该有一个唯一的名字，如“/dev/hotplug”；

DEVHDR_ucType设备类型，例如，字符设备类型、块设备类型等；

DEVHDR_atomicOpenNum这个成员记录了设备的打开次数，内核提供了下面几个函数对它进行操作；

INT  LW_DEV_INC_USE_COUNT(PLW_DEV_HDR  pdevhdrHdr);  /* 增加一次打开计数    */
INT  LW_DEV_DEC_USE_COUNT(PLW_DEV_HDR  pdevhdrHdr);  /* 减少一次打开计数    */
INT  LW_DEV_GET_USE_COUNT(PLW_DEV_HDR  pdevhdrHdr);  /* 获得打开计数        */

DEVHDR_pvReserve暂时保留。

所有安装的设备将被链到下面这个链表头上，系统进行统一管理。

LW_LIST_LINE_HEADER   _S_plineDevHdrHeader;     /*  设备表表头                  */

SylixOS驱动结构

typedef struct {
LONGFUNCPTR                DEVENTRY_pfuncDevCreate;      /*  建立函数                    */
FUNCPTR                    DEVENTRY_pfuncDevDelete;      /*  删除函数                    */

LONGFUNCPTR                DEVENTRY_pfuncDevOpen;       /*  打开函数                    */
FUNCPTR                    DEVENTRY_pfuncDevClose;      /*  关闭函数                    */

SSIZETFUNCPTR              DEVENTRY_pfuncDevRead;       /*  读设备函数                  */
SSIZETFUNCPTR              DEVENTRY_pfuncDevWrite;       /*  写设备函数                  */

SSIZETFUNCPTR              DEVENTRY_pfuncDevReadEx;      /*  读设备函数扩展函数          */
SSIZETFUNCPTR              DEVENTRY_pfuncDevWriteEx;     /*  读设备函数扩展函数          */

FUNCPTR                    DEVENTRY_pfuncDevIoctl;      /*  设备控制函数                */
FUNCPTR                    DEVENTRY_pfuncDevSelect;     /*  select 功能                 */
OFFTFUNCPTR                DEVENTRY_pfuncDevLseek;     /*  lseek 功能                  */

FUNCPTR                    DEVENTRY_pfuncDevFstat;     /*  fstat 功能                  */
FUNCPTR                    DEVENTRY_pfuncDevLstat;     /*  lstat 功能                  */

FUNCPTR                    DEVENTRY_pfuncDevSymlink;    /*  建立链接文件                */
SSIZETFUNCPTR              DEVENTRY_pfuncDevReadlink;    /*  读取链接文件                */

FUNCPTR                    DEVENTRY_pfuncDevMmap;       /*  文件映射                    */
FUNCPTR                    DEVENTRY_pfuncDevUnmap;      /*  映射结束                    */

BOOL                       DEVENTRY_bInUse;            /*  是否被使用                  */
INT                        DEVENTRY_iType;             /*  设备驱动类型                */

LW_DRV_LICENSE             DEVENTRY_drvlicLicense;     /*  驱动程序许可证              */
} LW_DEV_ENTRY;
typedef LW_DEV_ENTRY          *PLW_DEV_ENTRY;

上面就是SylixOS目前支持的驱动方法，基本上涵盖了设备的各种操作，当然， Linux程序员可能更习惯于struct file_operations，SylixOS为了兼容这部分，也加入了struct file_operations。

SylixOS字符设备驱动

通过上面的一个简单介绍，接下来我们写一个简单的字符设备驱动来简单的练习一下。下面的程序展示了一个SylixOS字符设备的编写方法，程序实现了一个字符设备的读、写。

#define __SYLIXOS_KERNEL
#include <SylixOS.h>

typedef struct {
LW_DEV_HDR   CDEV_devhdr;
CHAR         CDEV_cBuf[64];
time_t       CDEV_time;
} CDEV;

static INT  devDrvNum = -1;

static LONG  devOpen (CDEV  *pcdev, PCHAR  pcName, INT  iFlag, INT  iMode)
{
if (!pcdev) {
_ErrorHandle(EFAULT);
return  (PX_ERROR);
}

LW_DEV_INC_USE_COUNT(&pcdev->CDEV_devhdr);

return  ((LONG)pcdev);
}

static INT  devClose (CDEV  *pcdev)
{
if (!pcdev) {
_ErrorHandle(EFAULT);
return  (PX_ERROR);
}

if (LW_DEV_GET_USE_COUNT(&pcdev->CDEV_devhdr)) {
LW_DEV_DEC_USE_COUNT(&pcdev->CDEV_devhdr);
}

return  (ERROR_NONE);
}

static ssize_t devRead (CDEV  *pcdev, PVOID  pvBuf,  size_t  stLen)
{
ssize_t   stTempLen;

stTempLen = min(stLen, 64);

lib_memcpy(pvBuf, (PVOID)&pcdev->CDEV_cBuf[0], stTempLen);

return  (stTempLen);
}

static ssize_t devWrite (CDEV  *pcdev, PVOID  pvBuf,  size_t  stLen)
{
ssize_t   stTempLen;

stTempLen = min(stLen, 64);

lib_memcpy((PVOID)&pcdev->CDEV_cBuf[0], pvBuf, stTempLen);

return  (stTempLen);
}

static INT  devIoctl (CDEV  *pcdev, INT iCmd, LONG  lArg)
{
INT                  iError = ERROR_NONE;
struct stat         *pstatGet;

switch (iCmd) {

case FIOFSTATGET:
pstatGet = (struct stat *)lArg;
if (pstatGet) {
pstatGet->st_dev     = (dev_t)pcdev;
pstatGet->st_ino     = (ino_t)0;          /*  相当于唯一节点              */
pstatGet->st_mode    = 0666 | S_IFCHR;
pstatGet->st_nlink   = 1;
pstatGet->st_uid     = 0;
pstatGet->st_gid     = 0;
pstatGet->st_rdev    = 1;
pstatGet->st_size    = 0;
pstatGet->st_blksize = 0;
pstatGet->st_blocks  = 0;
pstatGet->st_atime   = pcdev->CDEV_time;
pstatGet->st_mtime   = pcdev->CDEV_time;
pstatGet->st_ctime   = pcdev->CDEV_time;

} else {
errno  = EINVAL;
iError = (PX_ERROR);
}
}

return  (iError);
}

static struct file_operations  fop = {
.owner = THIS_MODULE,
.fo_open = devOpen,
.fo_close = devClose,
.fo_read = devRead,
.fo_write = devWrite,
.fo_ioctl = devIoctl
};

INT  devDrvInstall (VOID)
{
if (devDrvNum > 0) {
return  (ERROR_NONE);
}

devDrvNum = API_IosDrvInstallEx(&fop);

DRIVER_LICENSE(devDrvNum,     "Dual BSD/GPL->Ver 1.0");
DRIVER_AUTHOR(devDrvNum,      "xx.xxx");
DRIVER_DESCRIPTION(devDrvNum, "char dev driver.");

return  (devDrvNum > 0 ? ERROR_NONE : PX_ERROR);
}

INT devCreate (VOID)
{
CDEV  *pcdev;
INT    iRet;

pcdev = __SHEAP_ALLOC(sizeof(CDEV));
if (!pcdev) {
return  (PX_ERROR);
}

lib_bzero(pcdev, sizeof(CDEV));

iRet = API_IosDevAddEx(&pcdev->CDEV_devhdr, "/dev/cdev", devDrvNum, DT_CHR);
if (iRet != ERROR_NONE) {
__SHEAP_FREE(pcdev);
return  (PX_ERROR);
}

pcdev->CDEV_time = lib_time(LW_NULL);

return  (ERROR_NONE);
}

VOID devDelete (VOID)
{
PCHAR        pcTail;
PLW_DEV_HDR  pdevhdr;

pdevhdr = API_IosDevFind("/dev/cdev", &pcTail);

API_IosDevDelete(pdevhdr);
API_IosDrvRemove(devDrvNum, LW_TRUE);
}

void module_init (void)
{
INT  iRet;

iRet = devDrvInstall();
if (iRet == ERROR_NONE) {
iRet = devCreate();
if (iRet != ERROR_NONE) {
printk(KERN_ERR "Char device install failed.\n");
}
} else {
printk(KERN_ERR "Char driver install failed.\n");
}
}

void module_exit (void)
{
devDelete();
}