DragonOS Rust 操作系统

DragonOS网络子系统介绍

更新时间 DragonOS网络子系统介绍有0条评论

本文将对DragonOS网络子系统进行简要介绍。出于“快速实现功能”的考虑，DragonOS目前网络子系统基于Smoltcp协议栈进行开发，具体协议部分采用smoltcp的实现。计划在将来重构网络子系统时，采用独立开发的协议栈，以支持“服务器系统”的需求。

分层设计

网络子系统自上而下分为：系统调用接口层、Socket层、Smoltcp协议栈、网络设备层。目前底层承接收发网络功能的是VirtIO网卡。

系统调用接口层

系统调用接口层对外提供了十多个符合posix规范的接口，语义与Linux一致。在这一层内，会对用户传入的参数进行基本的校验，并把Posix规定的参数类型，转换为DragonOS具体实现的类型。然后，调用Socket层的函数，进行操作。

以下是当前提供的所有系统调用接口：

具体的接口含义请看函数注释

Socket层

Socket层是对smoltcp协议栈的各种socket的封装。原因在于，smoltcp提供的socket，只是非常“纯粹”的功能，不包含操作系统所需的诸如端口绑定管理（bind的时候需要找空闲端口）之类的功能。并且，Socket层还将每个Socket抽象为一个Inode，使得用户能像读写文件一样操作socket。

目前DragonOS仅支持TCP、UDP、Raw Socket，可考虑添加NetLink Socket和Packet Socket的支持。这两个功能的实现，也是基于smoltcp协议栈的基础能力，在Socket层封装新的Socket类型即可实现。

Smoltcp协议栈

smoltcp是一个独立的、事件驱动的TCP/IP堆栈，专为裸机实时系统设计。它的设计目标是简单和可靠。

之所以选择smoltcp协议栈，很重要的原因在于，它是用Rust编写的，能够较好的与现有代码融合，并提供较好的安全性和可靠性。

它目前作为DragonOS网络子系统的一部分，支撑了网络子系统的主要功能。但是，在开发过程中，我们发现它存在一定的问题：由于其设计为嵌入式的网络栈，并且它为了在嵌入式场景实现的简便性，对多请求并发的场景表现的并不是特别好。举例：

  • smoltcp不支持backlog，因此在多请求同时到达的情况下，容易出现connection refused的情况。
  • 协议栈内过早地获取设备的可变引用，导致临界区较大，导致显而易见的性能损耗。

网络设备层

目前把所有的网络设备都放置在了一个叫做NET_DRIVERS的BTreeMap之中。由于网卡中断尚未实现，因此目前会通过系统定时器机制，每10ms轮询所有网卡，读取数据并更新socket的状态。

所有网络设备都需要实现一个叫做“NetDriver”的trait。

pub trait NetDriver: Driver {
    /// @brief 获取网卡的MAC地址
    fn mac(&self) -> EthernetAddress;

    fn name(&self) -> String;

    /// @brief 获取网卡的id
    fn nic_id(&self) -> usize;

    fn poll(&self, sockets: &mut iface::SocketSet) -> Result<(), SystemError>;

    fn update_ip_addrs(&self, ip_addrs: &[wire::IpCidr]) -> Result<(), SystemError>;

    /// @brief 获取smoltcp的网卡接口类型
    fn inner_iface(&self) -> &SpinLock<smoltcp::iface::Interface>;
}

一个TCP数据包的发送过程

由于DragonOS的网络相关系统调用语义与Linux一致，因此在Linux上能正常运行的tcp服务器程序，也能正常在DragonOS上运行。

下面对这样一段代码片段所实现的tcp服务器功能进行追踪，帮助我们了解TCP数据包是如何在DragonOS中传递的。

void tcp_server()
{
    printf("TCP Server is running...\n");
    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("socket() ok, server_sockfd=%d\n", server_sockfd);
    struct sockaddr_in server_sockaddr;
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(SERVER_PORT);
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(server_sockfd, (struct sockaddr *)&server_sockaddr, sizeof(server_sockaddr)))
    {
        perror("Server bind error.\n");
        exit(1);
    }

    printf("TCP Server is listening...\n");
    if (listen(server_sockfd, CONN_QUEUE_SIZE) == -1)
    {
        perror("Server listen error.\n");
        exit(1);
    }

    printf("listen() ok\n");

    char buffer[BUFFER_SIZE];
    struct sockaddr_in client_addr;
    socklen_t client_length = sizeof(client_addr);
    /*
        Await a connection on socket FD.
        When a connection arrives, open a new socket to communicate with it,
        set *ADDR (which is *ADDR_LEN bytes long) to the address of the connecting
        peer and *ADDR_LEN to the address's actual length, and return the
        new socket's descriptor, or -1 for errors.
     */
    conn = accept(server_sockfd, (struct sockaddr *)&client_addr, &client_length);
    printf("Connection established.\n");
    if (conn < 0)
    {
        printf("Create connection failed, code=%d\n", conn);
        exit(1);
    }
    send(conn, logo, sizeof(logo), 0);
    while (1)
    {
        memset(buffer, 0, sizeof(buffer));
        int len = recv(conn, buffer, sizeof(buffer), 0);
        if (len <= 0)
        {
            printf("Receive data failed! len=%d\n", len);
            break;
        }
        if (strcmp(buffer, "exit\n") == 0)
        {
            break;
        }

        printf("Received: %s\n", buffer);
        send(conn, buffer, len, 0);
    }
    close(conn);
    close(server_sockfd);
}

创建socket

server_sockfd = socket(AF_INET, SOCK_STREAM, 0);

这样代码会发起sys_socket系统调用，进入到这里：

https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/syscall.rs?r=cde5492f&mo=588&fi=24#24

sys_socket函数会抽出参数，然后传入到do_socket函数内。

do_socket函数在这里：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/syscall.rs?r=cde5492f&mo=588&fi=24#39

在do_socket函数内，将会根据地址族和socket类型创建不同类型的socket。然后把创建好的SocketInode存入进程的文件描述符数组中。

在do_socket函数内，会调用Tcp Socket的new方法，创建tcp socket。

TcpSocket::new()

代码：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/socket.rs?r=cde5492f#522

在Tcp Socket的new方法内，会进行以下操作：

  • 为新的socket创建发送、接收缓冲区
  • 在smoltcp协议栈中，创建socket
  • 把Socket添加到全局的SOCKET_SET集合之中，并且获得一个SocketHandle.
  • 创建TcpSocket结构体，存放上述的SocketHandle.
  • 返回创建好的TcpSocket结构体。

然后逐级返回，就回到了用户态，用户程序就能获取到这个新的socket的文件描述符了。

绑定端口

if (bind(server_sockfd, (struct sockaddr *)&server_sockaddr, sizeof(server_sockaddr)))

用户程序的这行代码中的bind()函数，会发起一个sys_bind()系统调用，进入到内核的这里：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/syscall.rs?r=cde5492f#242

提取出参数后，进入do_bind函数：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/syscall.rs?r=cde5492f#258

这个函数会根据用户传入的参数，生成一个endpoint结构体。并且，调用socket的bind方法，将socket与端口绑定，然后返回。

由于当前socket是Tcp Socket，因此264行实际调用的是Tcp的bind方法：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/socket.rs?r=cde5492f#737

这个方法里面，当传入的端口号为0时，内核会自动分配一个未使用的端口，作为本地的端口。请注意，这里的第264行的get_ephemeral_port方法并不能保证端口一定未使用。这是接下来需要优化的地方：为内核维护一个ListenTable，记录端口分配情况。

监听端口

    if (listen(server_sockfd, CONN_QUEUE_SIZE) == -1)

这行代码会发起一个sys_listen系统调用，以实现对端口的监听。请注意，由于smoltcp不支持backlog,因此listen()函数的第二个参数值无效，内核的动作永远与backlog=1时相同。

代码：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/syscall.rs?r=cde5492f&mo=13292&fi=443#443

与上面相似的，这里在do_listen里面，调用socket的listen方法，完成监听过程。

这里由于是TcpSocket，因此调用的是TcpSocket的listen方法：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/socket.rs?r=cde5492f#720

内部则是调用smoltcp的listen方法，表示当前socket已经在监听。

接受连接

    conn = accept(server_sockfd, (struct sockaddr *)&client_addr, &client_length);

这行用户代码会接受一个来自外部的tcp连接，并且返回新的连接的socket fd.

这里会发起一个叫做sys_accept的系统调用：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/syscall.rs?r=cde5492f&mo=14597&fi=491#491

这个系统调用与上面的类似，也是取出参数，然后调用内层socket的accept方法（这里就是TcpSocket的accept方法）。最后把新创建的文件描述符写入到进程的文件描述符数组内，然后返回。

与上面的不同，这里还多了一个“向用户空间写入客户端地址”的过程，也就是写入上述的”client_addr”和”client_length”这两个变量。

TcpSocket::accept()

这个函数在这里：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/socket.rs?r=cde5492f#757

它其实是一个不断轮询的过程，每个循环前，都轮询一遍所有的网卡，更新socket状态。接着再获取当前socket，判断是否为active。如果连接已经启动，那么就尝试获取远端地址，并创建新的socket来存储。如果连接没启动，就将当前进程加入等待队列，待全局SOCKET_SET中有socket的状态更新后，再检查当前socket是否已经连接。

注：是的，这里很低效，因此需要想个办法优化它。但是smoltcp在poll_iface的时候，并没有告诉我们到底是哪些sockets被更新了，它只是告诉我们有socket的状态被更新了。因此暂时没想到更好的方法。

这里需要注意的是，返回给用户的是一个新的Socket对象。而当前服务端监听用的socket已经与对端建立连接，因此，需要这样做：把监听用的socket的handle,转移给新创建的socket,接着为服务端监听用的socket创建新的handle。这样下来，监听用的socket才能再次与新的客户端建立连接。

发送数据

当连接被建立后，我们得到了一个新的socket，可以用它来发送数据。

send(conn, logo, sizeof(logo), 0);

发送数据的方法有几种，比如可以通过文件的write方法来发送，也可以使用网络的send方法。

这里会产生一个sys_sendto系统调用：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/syscall.rs?r=cde5492f&mo=14597&fi=491#298

最终调用的是tcp socket的write方法：

TcpSocket::write()

tcp socket的write方法较为简单，判断了连接是否打开，以及是否能够发送。接着就发送数据了：https://opengrok.ringotek.cn/xref/DragonOS/kernel/src/net/socket.rs?r=cde5492f#617

接收数据

int len = recv(conn, buffer, sizeof(buffer), 0);

这行代码会发起一个sys_recvfrom系统调用，然后进入到这些地方：

由于设计思路与前面的类似，在这里不多赘述。主要就是对连接状态进行判断、对端点地址进行处理，然后发送数据。

以上就是本文的全部内容，转载请注明来源：https://longjin666.cn/?p=1729

欢迎关注我的公众号“灯珑”，让我们一起了解更多的事物~

你也可能喜欢

发表评论