This is a cache of https://blog.csdn.net/qq_55401402/article/details/149618669. It is a snapshot of the page as it appeared on 2025-08-24T04:18:55.079+0200.
【<strong>linux</strong> | 网络】多路转接IO之select-CSDN博客

【linux | 网络】多路转接IO之select

最新推荐文章于 2025-08-23 01:21:08 发布
最新推荐文章于 2025-08-23 01:21:08 发布
阅读量990 收藏 51
点赞数 54
CC 4.0 BY-SA版权
分类专栏： 【网络】 【linux】 文章标签： linux 网络 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55401402/article/details/149618669

在这里插入图片描述

一、select函数

#include <sys/select.h>

int select(int nfds, fd_set *readfds, fd_set *writefds, 
				fd_set *exceptfds, struct timeval *timeout);

功能：用于同时监控多个文件描述符的 IO 状态，通过 select，程序可以在单个线程中处理多个 IO 事件，避免为每个 IO 操作创建单独的线程，从而提高资源利用率和并发性能。但是select只负责等待，拷贝需要read、recv、write、send等负责。

参数：

  • nfds：需要检查的最大文件描述符值 + 1
  • readfds：输入输出型参数，fd_set本质上是一张位图
    • 输入时：
      • 比特位的位置：对应文件描述符的值
      • 比特位的内容：用户告诉内核，是否监控对应文件描述符的读事件
    • 输出时：
      • 比特位的位置：对应文件描述符的值
      • 比特位的内容：内核告诉用户，对应文件描述符的读事件 是否就绪
  • writefds：输入输出型参数，fd_set本质上是一张位图
    • 输入时：
      • 比特位的位置：对应文件描述符的值
      • 比特位的内容：用户告诉内核，是否监控对应文件描述符的写事件
    • 输出时：
      • 比特位的位置：对应文件描述符的值
      • 比特位的内容：内核告诉用户，对应文件描述符的写事件 是否就绪
  • exceptfds：输入输出型参数，fd_set本质上是一张位图
    • 输入时：
      • 比特位的位置：对应文件描述符的值
      • 比特位的内容：用户告诉内核，是否监控对应文件描述符的异常事件
    • 输出时：
      • 比特位的位置：对应文件描述符的值
      • 比特位的内容：内核告诉用户，对应文件描述符的异常事件 是否就绪
  • timeout：超时时间，控制 select 的阻塞行为：
    • NULL：永久阻塞，直到有文件描述符就绪
    • 0：立即返回（非阻塞模式）
    • >0：指定超时时间（秒 + 微秒），超时后返回。
      在这里插入图片描述

返回值：

  • 正数：表示就绪的文件描述符总数
  • 0：表示超时（无文件描述符就绪）
  • -1：表示错误，并设置 errno（如 EINTR 表示被信号中断）

操作系统不建议用户直接修改fd_set位图，所以操作系统提供以下宏操作，来操作fd_set位图。

FD_ZERO(fd_set *set);    // 清空集合
FD_SET(int fd, fd_set *set);  // 将 fd 添加到集合
FD_CLR(int fd, fd_set *set);  // 从集合中移除 fd
FD_ISSET(int fd, fd_set *set);  // 检查 fd 是否在集合中（就绪时返回非零）

二、select的优缺点

  • 优点
    • select只负责等待，可以等待多个文件描述符，在IO的时候效率会比较高
  • 缺点
    1. 使用select的时候，用户每次都需要对select的参数进行重置
    2. 在编写代码的时候，select需要用到第三方数组，会充满遍历，可能会影响select的效率
    3. 用户到内核，内核到用户，每次select的调用和返回，都需要对位图进行重置操作；用户和内核之间，需要一直进行数据拷贝
    4. select会让操作系统在底层遍历要关心的所有文件描述符，会导致效率降低
    5. fd_set是操作系统提供的一个类型，本身是一个位图，fd_set的大小是固定的，也就是fd_set的比特位位数是有上线的，所以select能够检测文件描述符的个数也是有限的

三、实现select服务器（只关心读事件）

3.1 Log.hpp（日志）

#pragma once

#include "LockGuard.hpp"
#include <iostream>
#include <string>
#include <stdarg.h>
#include <stdio.h>
#include <pthread.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>

using namespace std;

// 日志等级
enum
{
    Debug = 0, // 调试
    Info,      // 正常
    Warning,   // 警告
    Error,     // 错误，但程序并未直接退出
    Fatal      // 程序直接挂掉
};

enum
{
    Screen = 10, // 打印到显示器上
    OneFile,     // 打印到一个文件中
    ClassFile    // 按照日志等级打印到不同的文件中
};

string LevelToString(int level)
{
    switch (level)
    {
    case Debug:
        return "Debug";
    case Info:
        return "Info";
    case Warning:
        return "Warning";
    case Error:
        return "Error";
    case Fatal:
        return "Fatal";
    default:
        return "Unknow";
    }
}

const char *default_filename = "log.";
const int default_style = Screen;
const char *defaultdir = "log";

class Log
{
public:
    Log()
        : style(default_style), filename(default_filename)
    {
        // mkdir(defaultdir,0775);
        pthread_mutex_init(&_log_mutex, nullptr);
    }

    void SwitchStyle(int sty)
    {
        style = sty;
    }

    void WriteLogToOneFile(const string &logname, const string &logmessage)
    {
        int fd = open(logname.c_str(), O_CREAT | O_WRONLY | O_APPEND, 0666);
        if (fd == -1)
            return;

        {
            LockGuard lockguard(&_log_mutex);
            write(fd, logmessage.c_str(), logmessage.size());
        }
        close(fd);
    }

    void WriteLogToClassFile(const string &levelstr, const string &logmessage)
    {
        mkdir(defaultdir, 0775);

        string name = defaultdir;
        name += "/";
        name += filename;
        name += levelstr;

        WriteLogToOneFile(name, logmessage);
    }

    void WriteLog(int level, const string &logmessage)
    {
        switch (style)
        {
        case Screen:
        {
            LockGuard lockguard(&_log_mutex);
            cout << logmessage;
        }
        break;
        case OneFile:
            WriteLogToClassFile("All", logmessage);
            break;
        case ClassFile:
            WriteLogToClassFile(LevelToString(level), logmessage);
            break;
        default:
            break;
        }
    }

    string GetTime()
    {
        time_t CurrentTime = time(nullptr);

        struct tm *curtime = localtime(&CurrentTime);
        char time[128];

        // localtime 的年是从1900开始的，所以要加1900， 月是从0开始的所以加1
        snprintf(time, sizeof(time), "%d-%d-%d %d:%d:%d",
                 curtime->tm_year + 1900, curtime->tm_mon + 1, curtime->tm_mday,
                 curtime->tm_hour, curtime->tm_min, curtime->tm_sec);

        return time;
        return "";
    }

    void LogMessage(int level, const char *format, ...)
    {
        char left[1024];
        string Levelstr = LevelToString(level).c_str();
        string Timestr = GetTime().c_str();
        string Idstr = to_string(getpid());
        snprintf(left, sizeof(left), "[%s][%s][%s] ",
                 Levelstr.c_str(), Timestr.c_str(), Idstr.c_str());

        va_list args;
        va_start(args, format);
        char right[1024];
        vsnprintf(right, sizeof(right), format, args);

        string logmessage = left;
        logmessage += right;

        WriteLog(level, logmessage);

        va_end(args);
    }

    ~Log()
    {
        pthread_mutex_destroy(&_log_mutex);
    };

private:
    int style;
    string filename;

    pthread_mutex_t _log_mutex;
};

Log lg;

class Conf
{
public:
    Conf()
    {
        lg.SwitchStyle(Screen);
    }
    ~Conf()
    {
    }
};

Conf conf;

3.2 Lockguard.hpp（自动管理锁）

#pragma once

#include <iostream>

class Mutex
{
public:
    Mutex(pthread_mutex_t* lock)
        :pmutex(lock)
    {}

    void Lock()
    {
        pthread_mutex_lock(pmutex);
    }

    void Unlock()
    {
        pthread_mutex_unlock(pmutex);
    }

    ~Mutex()
    {}
public:
    pthread_mutex_t* pmutex;
};

class LockGuard
{
public:
    LockGuard(pthread_mutex_t* lock)
        :mutex(lock)
    {
        mutex.Lock();
    }

    ~LockGuard()
    {
        mutex.Unlock();
    }
public:
    Mutex mutex;
};

3.3 Socket.hpp（封装套接字）

#pragma once

#include <iostream>
#include <string>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#define CONV(addrptr) (struct sockaddr*)addrptr

enum{
    Socket_err = 1,
    Bind_err,
    Listen_err
};

const static int defalutsockfd = -1;
const int defalutbacklog = 5;

class Socket
{
public:
    virtual ~Socket(){};
    virtual void CreateSocketOrDie() = 0;
    virtual void BindSocketOrDie(uint16_t port) = 0;
    virtual void ListenSocketOrDie(int backlog) = 0;
    virtual Socket* AcceptConnection(std::string* ip , uint16_t* port) = 0;
    virtual bool ConnectServer(const std::string& serverip , uint16_t serverport) = 0;
    virtual int GetSockFd() = 0;
    virtual void SetSockFd(int sockfd) = 0;
    virtual void CloseSockFd() = 0;
    virtual bool Recv(std::string& buffer,int size) = 0;
    virtual void Send(const std::string& send_string) = 0;

public:
    void BuildListenSocketMethod(uint16_t port,int backlog = defalutbacklog)
    {
        CreateSocketOrDie();
        BindSocketOrDie(port);
        ListenSocketOrDie(backlog);
    }
    bool BuildConnectSocketMethod(const std::string& serverip , uint16_t serverport)
    {
        CreateSocketOrDie();
        return ConnectServer(serverip,serverport);
    }
    void BuildNormalSocketMethod(int sockfd)
    {
        SetSockFd(sockfd);
    }
};

class TcpSocket : public Socket
{
public:
    TcpSocket(int sockfd = defalutsockfd)
        :_sockfd(sockfd)
    {}
    ~TcpSocket(){};

    void CreateSocketOrDie() override
    {
        _sockfd = ::socket(AF_INET,SOCK_STREAM,0);
        if(_sockfd < 0) exit(Socket_err);
    }

    void BindSocketOrDie(uint16_t port) override
    {
        struct sockaddr_in addr;
        memset(&addr,0,sizeof(addr));

        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = INADDR_ANY;
        addr.sin_port = htons(port);
        socklen_t len = sizeof(addr);

        int n = ::bind(_sockfd,CONV(&addr),len);
        if(n < 0) exit(Bind_err);
    }

    void ListenSocketOrDie(int backlog) override
    {
        int n = ::listen(_sockfd,backlog);
        if(n < 0) exit(Listen_err);
    }

    Socket* AcceptConnection(std::string* clientip , uint16_t* clientport) override
    {
        struct sockaddr_in client;
        memset(&client,0,sizeof(client));
        socklen_t len = sizeof(client);
        int fd = ::accept(_sockfd,CONV(&client),&len);

        if(fd < 0) return nullptr;

        char buffer[64];
        inet_ntop(AF_INET,&client.sin_addr,buffer,len);
        *clientip = buffer;
        *clientport = ntohs(client.sin_port);

        Socket* s = new TcpSocket(fd);

        return s;
    }   

    bool ConnectServer(const std::string& serverip , uint16_t serverport) override
    {
        struct sockaddr_in server;
        memset(&server,0,sizeof(server));
        server.sin_family = AF_INET;
        // server.sin_addr.s_addr =  inet_addr(serverip.c_str());
        inet_pton(AF_INET,serverip.c_str(),&server.sin_addr);
        server.sin_port = htons(serverport);
        socklen_t len = sizeof(server);
        
        int n = connect(_sockfd,CONV(&server),len);
        if(n < 0) return false;
        else return true;
    }
    
    int GetSockFd() override
    {
        return _sockfd;
    }
    void SetSockFd(int sockfd) override
    {
        _sockfd = sockfd;
    }

    void CloseSockFd() override
    {
        if(_sockfd > defalutsockfd)
        {
            close(_sockfd);
        }
    }

    bool Recv(std::string& buffer , int size)override
    {
        char inbuffer[size];
        int n = recv(_sockfd,inbuffer,sizeof(inbuffer)-1,0);
        if(n > 0)
        {
            inbuffer[n] = 0;
        }
        else
        {
            return false;
        }

        buffer += inbuffer;

        return true;
    }

    void Send(const std::string& send_string)
    {
        send(_sockfd,send_string.c_str(),send_string.size(),0);
    }


private:
    int _sockfd;
};

3.4 SelectServer.hpp（服务端封装）

#pragma once

#include <iostream>
#include <string>
#include <sys/select.h>
#include "Socket.hpp"
#include "Log.hpp"
#include <memory>

using namespace std;

const static uint16_t defalutport = 8888;
const static int gbacklog = 8;
const static int num = sizeof(fd_set) * 8;

class SelectServer
{
private:
    void HandlerEvent(fd_set &rfds)
    {
        for (int i = 0; i < num; i++)
        {
            // 是否监控
            if (!_rfds_array[i])
                continue;

            // 是否就绪
            int fd = _rfds_array[i]->GetSockFd();

            if (FD_ISSET(fd, &rfds))
            {
                // 是新连接到来，还是新数据到来
                // 新连接到来
                if (FD_ISSET(_listensock->GetSockFd(), &rfds))
                {
                    lg.LogMessage(Info, "get a new link\n");

                    string clientip;
                    uint16_t cilentport;
                    // 由于select已经检测到listensock已经就绪了，这里不会阻塞
                    Socket *sock = _listensock->AcceptConnection(&clientip, &cilentport);
                    if (!sock)
                    {
                        lg.LogMessage(Error, "accept error\n");
                        continue;
                    }
                    lg.LogMessage(Info, "get a client , client info# %s %d , fd:%d\n", clientip.c_str(), cilentport, sock->GetSockFd());

                    // 这里已经获取连接成功，由于底层数据不一定就绪
                    // 所以这里需要将新连接的文件描述符交给select托管
                    // 只需将文件描述符加入到_rfds_array即可
                    int pos = 0;
                    for (; pos < num; pos++)
                    {
                        if (_rfds_array[pos] == nullptr)
                        {
                            _rfds_array[pos] = sock;
                            break;
                        }
                    }

                    // fd_set能够存储的文件描述符是有上限的
                    if(pos == num)
                    {
                        sock->CloseSockFd();
                        delete sock;
                        lg.LogMessage(Warning, "server is full...!\n");
                    }
                }
                else
                {  // 是新数据来了
                    // 这里读是有问题的
                    string buffer;
                    bool flag = _rfds_array[i]->Recv(buffer,1024);
                    if(flag)  // 读取成功
                    {
                        lg.LogMessage(Info,"client say# %s\n",buffer.c_str());
                    }
                    else  // 读取失败
                    {
                        lg.LogMessage(Warning,"cilent quit !! close fd : %d\n",fd);
                        _rfds_array[i]->CloseSockFd();
                        delete _rfds_array[i];
                        _rfds_array[i] = nullptr;
                    }
                }
            }
        }
    }

public:
    SelectServer(uint16_t port = defalutport)
        : _port(port), _listensock(new TcpSocket()), _isrunning(false)
    {
    }

    void Init()
    {
        _listensock->BuildListenSocketMethod(_port, gbacklog);
        for (int i = 0; i < num; i++)
        {
            _rfds_array[i] = nullptr;
        }
        _rfds_array[0] = _listensock.get();
    }

    void Loop()
    {
        _isrunning = true;
        while (_isrunning)
        {
            fd_set rfds;
            FD_ZERO(&rfds);

            PrintDebug();

            // 设置需要监控的读事件文件描述符集，并找到最大的文件描述符
            int max_fd = _listensock->GetSockFd();
            for (int i = 0; i < num; i++)
            {
                if (_rfds_array[i] == nullptr)
                    continue;
                else
                {
                    int fd = _rfds_array[i]->GetSockFd();
                    // rfds本质是一个输入输出型参数，rfds是在select调用返回的时候，不断被修改，所以，每次都要重置
                    FD_SET(fd, &rfds);
                    if (max_fd < fd)
                    {
                        max_fd = fd;
                    }
                }
            }

            struct timeval timeout = {0, 0};
            ssize_t n = select(max_fd + 1, &rfds, nullptr, nullptr, &timeout);

            switch (n)
            {
            case -1:
            {
                lg.LogMessage(Fatal, "select Error , last time : %u.%u\n", timeout.tv_sec, timeout.tv_usec);
                break;
            }
            case 0:
            {
                lg.LogMessage(Info, "select timeout... , last time : %u.%u\n", timeout.tv_sec, timeout.tv_usec);
                break;
            }
            default:
            {
                lg.LogMessage(Info, "select success , begin handler event , last time : %u.%u\n", timeout.tv_sec, timeout.tv_usec);
                HandlerEvent(rfds);
                break;
            }
            }
        }
        _isrunning = false;
    }

    void Stop()
    {
        _isrunning = false;
    }

    // 查看当前哪些文件描述符需要被监控
    void PrintDebug()
    {
        std::cout << "current select rfds list is : ";
        for (int i = 0; i < num; i++)
        {
            if (_rfds_array[i] == nullptr)
                continue;
            else
                std::cout << _rfds_array[i]->GetSockFd() << " ";
        }
        std::cout << std::endl;
    }

    ~SelectServer() {}

private:
    unique_ptr<Socket> _listensock;
    uint16_t _port;
    bool _isrunning;

    // Select服务器需要所有的fd以数据结构的方式组织起来
    Socket *_rfds_array[num];
};

3.5 Main.cpp（服务端）

#include <iostream>
#include <memory>
#include "SelectServer.hpp"

using namespace std;

// ./selectserver port
int main(int argc , char* argv[])
{
    if(argc != 2)
    {
        cout << "Usage : " << argv[0] << " port" << endl;
        exit(0); 
    }

    uint16_t localport = stoi(argv[1]);
    unique_ptr<SelectServer> svr = make_unique<SelectServer>(localport);

    svr->Init();
    svr->Loop();

    return 0;
}

结尾

如果有什么建议和疑问，或是有什么错误，大家可以在评论区中提出。
希望大家以后也能和我一起进步！！🌹🌹
如果这篇文章对你有用的话，希望大家给一个三连支持一下！！🌹🌹
在这里插入图片描述

linux网络 | 多路转接select
strive_mianyang的博客
02-15 720
linux高级IO | 多路转接select
【linux】多路转接select
加油，考上985的研究生
09-14 1385
系统提供的select函数来实现多路复用输入/输出模型。IO = 等 + 拷贝，select函数只负责进行对fd进行等待，有时间就绪，就进行事件的派发，这里可以同时对多个fd进行等待。
计算机网络 | IO多路转接技术 | select详解
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
09-19 1997
IO多路转接技术介绍以及select详解、代码示例。
多路IO转接之select(linux网络编程)
m0_50127633的博客
04-30 304
这里就是改进之前代码的问题，之前的代码，如果最大fd是1023，每次确定有事件发生的fd时，就要扫描3-1023的所有文件描述符，这看起来很蠢。于是定义一个数组，把要监听的文件描述符存下来，每次扫描这个数组就行了。看起来科学得多。代码6666/* 自定义数组client, 防止遍历1024个文件描符 FD_SETSIZE默认为1024 *//* rset 读事件文件描述符集合 allset用来暂存 */
linux编程:多路转接复用IO之select模型
qq_42613519的博客
02-16 374
linux编程:多路转接复用IO之select模型 多路转接IO概念 描述的是转接IO，就是对大量的描述符的IO状态进行监控，能够让程序知道哪个描述符IO是就绪的，可以进行IO操作，直接让程序针对就绪描述符进行IO操作，提高效率（更多用于网络通信服务器)。 IO就绪状态 可读状态:套接字接收缓冲区中，数据大小大于低水位标记（默认-1字节) 可写状态:套接字发送缓冲区中，剩余空间大小大于低水位标记（默认-1字节) 异常状态 select模型 实现思路就是在内核中轮询遍历所有监控的描述符，判断IO
linux网络编程 | c | select实现多路IO转接服务器
m0_74795952的博客
12-12 773
基于该视频完成通过响应式–多路IO转接实现。
多路转接——select
努力进大厂的小码娄
08-31 1148
select多路转接的详解，利用select编写简单的echo服务器。select编写的基本步骤。select的优点和缺点。
高级IO之IO多路转接
C_Rio的博客
10-12 1242
高级I/O（Advanced I/O）是指在计算机系统中进行输入和输出操作时使用的一种更高级的接口和技术。也就是当我们进行输入输出的时候本质其实都要进行等待内核缓冲区中数据到来才能进行读取和写入到用户缓冲区。而往往在等待的阶段都是需要进行阻塞的。而高级I/O提供了比传统的基本I/O操作更丰富和灵活的功能。
linux网络：多路转接 select
博客网站 https://async-area.com
12-12 1158
讲解linux中的Select系统调用，并实现一个EchoServer
linux网络：五种IO模型 & IO多路转接之select
m0_61088872的博客
09-10 815
5.异步IO：内核将数据拷贝完成后，通知应用程序（注意：与信号驱动拷贝相比，异步IO数据从内核拷贝到用户区是由系统进行的，用户空间直接进行IO操作即可。（一次等待多个文件描述符，任意一个就绪的概率增大，IO效率提高），详情看下面的介绍。recv，read，write，send这些IO接口进行IO时，都先要等待数据就绪，再进行拷贝操作。：fd_set位图被系统修改，需要检测的文件描述符中，就绪的文件描述符被设置到这个位图中返回给用户区。eg：设置0号文件描述符属性，让标准输出变成非阻塞，观察现象。
【linux】从零开始使用多路转接IO --- select
叫我龙翔的博客
11-03 2423
本文讲解了多路转接IO中的select方案，通过编程探索select接口！
linux网络编程：多路转接--select
qq_52568001的博客
08-25 830
select只负责等待，可以等待多个fd，select本身无数据拷贝的能力，拷贝需要read、write来完成。程序会停在select这里等待，直到被监视的文件描述符有一个或多个发生了状态改变。select系统调用是用来让我们的程序监视多个文件描述符的状态变化的;使用telnet作为客户端向服务器发消息时，收到了服务端的响应。系统提供select函数来实现多路复用输入/输出模型.下面的代码只考虑了写事件。2. select接口。
linux——多路转接IO（select、poll、epoll）
m0_46657980的博客
04-11 399
1、多路转接IO 多路转接IO：也叫多路复用IO，是一种模型技术——针对大量的描述符进行就绪事件监控，判断哪个描述符就绪了指定事件，让进程能够针对就绪的描述符进行操作，进而提高进程对描述符的处理效率，并且可以对某个描述符IO进行超时控制 应用场景：只有对描述符进行监控的需求或想要对描述的IO进行超时控制的需求都可以使用多路转接模型，常被用于高并发服务器中的事件触发模型 适用于有大量描述符需要监控，但是同一时间只有少量活跃的场景，或者就是单个描述符的IO超时控制的场景 多路转接模型与线程池： 多路
[特殊字符] 潜入深渊：探索 linux 内核源码的奇幻之旅与生存指南
kernelguru的博客
08-22 490
linux内核源码探索指南 linux内核源码是驱动数字世界的核心工程杰作，全球开发者协作的典范。关键目录包括：arch/（CPU架构相关）、drivers/（硬件驱动）、fs/（文件系统）、kernel/（进程调度等核心功能）。建议开发者通过具体问题切入（如系统调用流程），善用cscope/ctags等工具，结合官方文档逐步深入。内核开发采用邮件列表协作模式，补丁需经严格审查。初学者应注重理解主线逻辑，从简单驱动开始实践，警惕并发问题。探索内核源码是理解计算机系统本质的绝佳途径，虽具挑战但收获巨大。
20250822给荣品RD-RK3588开发板刷Rockchip原厂的Buildroot【linux-5.10】时点亮荣品的8寸屏
南岭笑笑生之家
08-22 641
摘要 本文记录了在荣品RD-RK3588开发板上刷写Rockchip原厂Buildroot(linux 5.10)系统并点亮荣品8寸MIPI屏幕的过程。主要工作包括修改设备树配置文件(rk3588-evb.dtsi和rk3588-evb7-lp4.dtsi)，解决GPIO冲突问题，配置MIPI-DSI接口参数，调整屏供电控制，以及修改背光控制相关设置。通过修改DSI面板参数、调整VOP分配、重新定义GPIO引脚等功能，最终实现了8寸屏幕(1200×1920分辨率)的正常显示。文中还提供了详细的设备树修改记录
linux统一的设备模型深度理解
最新发布
STCNXPARM的博客
08-23 601
1）使用文件目录、列表来管理设备，将设备信息都映射成文件；2）文件内容是动态更新的，设备文件也随系统进行增删改查；1）kobject相当于一个”基类“，kset/ktype辅助基类；2）kobject、kset、ktype共同作用，将设备组织成一个关系模型；3）内核的组织有了，如何将这些关系网，也呈现给用户层？答案是通过sysfs，将这个关系模型以目录文件呈现下面来逐一介绍1）术语2）源码目录3）数据结构#endifchar *buf);
【linux指南】gcc/g++编译器：从源码到可执行文件的全流程解析
热门推荐
倔强的石头的博客
08-18 2万+
在linux开发环境中，gcc和g++是最常用的编译器工具，它们承担着将源代码转化为可执行程序的核心任务。其中，gcc专注于C语言程序的编译，而g++则同时支持C和C++语言。理解这两款编译器的工作原理和使用方法，是掌握linux开发的基础技能。
Rockchip linux updateEngine 和 Rockchip linux RKDEVTOOL 的区别
m0_57249200的博客
08-21 829
这个问题问得非常好 👍，我给你详细拆解一下存在的原因和作用。
linux设备模型技术路线图
X
08-22 799
【代码】linux设备模型技术路线图。
评论 44
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值