linux编程：一个简单的记录CPU负载的小工具

于 2024-07-20 16:15:29 发布
阅读量255 收藏 5
点赞数 2
文章标签： linux 运维 cpu 负载 proc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stallion5632/article/details/140572921
版权

文章目录

0. 概要

在Linux系统中，监控进程的CPU负载是系统性能调试和分析的重要手段。
本文将介绍一个简单的记录CPU负载的小工具的实现。

目标是编写一个程序，它能够启动一个虚拟进程并定期监控其CPU使用情况，并将结果记录到一个文件中。具体需求包括：

  • 创建并启动一个虚拟进程。
  • 定期读取指定进程的CPU使用情况。

主要思想可参考之前的文章

1. 主要实现

1.1 监控进程的CPU负载

编写一个类来监控进程的CPU负载信息。

#include <dirent.h>
#include <vector>
#include <unordered_set>
#include <memory>

class ProcessCpuLoad {
public:
    struct Result {
        int id;
        float load;
        std::string name;
    };

    void RunOnce(const std::vector<std::string>& process_names_or_pids) {
        results_.clear();
        std::unordered_set<std::string> target_set(process_names_or_pids.begin(), process_names_or_pids.end());
        std::unique_ptr<DIR, decltype(&closedir)> dir(opendir("/proc"), closedir);
        if (!dir) {
            std::cerr << "Failed to open /proc directory." << std::endl;
            return;
        }

        struct dirent* entry;
        while ((entry = readdir(dir.get())) != nullptr) {
            if (entry->d_type == DT_DIR) {
                int pid = atoi(entry->d_name);
                if (pid > 0) {
                    std::string stat_path = "/proc/" + std::string(entry->d_name) + "/stat";
                    std::string comm_path = "/proc/" + std::string(entry->d_name) + "/comm";
                    try {
                        FilePtr stat_file(stat_path, "r");
                        FilePtr comm_file(comm_path, "r");

                        char comm[256];
                        if (fscanf(comm_file.get(), "%255s", comm) != 1) {
                            std::cerr << "Failed to read from " << comm_path << std::endl;
                            continue;
                        }
                        std::string pid_str = std::to_string(pid);
                        bool match_found = false;
                        for (const auto& target : target_set) {
                            if (pid_str.find(target) != std::string::npos || std::string(comm).find(target) != std::string::npos) {
                                match_found = true;
                                break;
                            }
                        }
                        if (match_found) { // 部分匹配目标进程
                            unsigned long utime, stime;
                            fseek(stat_file.get(), 13 * sizeof(unsigned long), SEEK_SET);  // Skip first 13 fields
                            if (fscanf(stat_file.get(), "%lu %lu", &utime, &stime) != 2) {
                                std::cerr << "Failed to read from " << stat_path << std::endl;
                                continue;
                            }
                            float total_time = static_cast<float>(utime + stime) / sysconf(_SC_CLK_TCK);
                            results_.push_back({pid, total_time, std::string(comm)});
                        }
                    } catch (const std::runtime_error& e) {
                        std::cerr << e.what() << std::endl;
                    }
                }
            }
        }
    }

    std::vector<Result> GetResult() const {
        return results_;
    }

private:
    std::vector<Result> results_;
};

1.2 记录CPU负载信息

还需要一个类来记录这些信息，并使用线程安全的方式进行日志记录。

#include <fstream>
#include <mutex>
#include <sstream>
#include <iomanip>

class CpuMonitor {
public:
    explicit CpuMonitor(const std::string& filename) : log_file_(filename, std::ios::out) {
        if (!log_file_.is_open()) {
            throw std::runtime_error("Failed to open log file: " + filename);
        } else {
            WriteHeader();
        }
    }

    ~CpuMonitor() {
        if (log_file_.is_open()) {
            log_file_.close();
        }
    }

    void LogCpuLoad(uint64_t time_us, const std::vector<ProcessCpuLoad::Result>& results) {
        std::lock_guard<std::mutex> lock(mutex_);
        LogTimestamp(time_us);
        LogCpuUsage(results);
        WriteToFile();
    }

private:
    void WriteHeader() {
        log_file_ << "Timestamp, ProcessID, ProcessName, CPULoad\n";
    }

    void LogTimestamp(uint64_t time_us) {
        buffer_ << "Timestamp: " << time_us << " us\n";
    }

    void LogCpuUsage(const std::vector<ProcessCpuLoad::Result>& results) {
        for (const auto& result : results) {
            buffer_ << result.id << ", " << result.name << ", " << std::fixed << std::setprecision(2) << result.load << "s\n";
        }
    }

    void WriteToFile() {
        if (log_file_.is_open()) {
            log_file_ << buffer_.str();
            buffer_.str("");
        }
    }

    std::ofstream log_file_;
    std::ostringstream buffer_;
    std::mutex mutex_;
};

2. 测试程序

2.1 创建虚拟进程

我们需要一个脚本来创建虚拟进程。这个脚本将被循环执行，并在接收到SIGTERM信号时优雅地退出。

#include <fstream>
#include <iostream>
#include <sys/stat.h>

bool CreateDummyProcessScript(const std::string& scriptPath) {
    std::ofstream scriptFile(scriptPath);
    if (scriptFile.is_open()) {
        scriptFile << "#!/bin/bash\n"
                   << "function handle_signal() {\n"
                   << "    echo \"[dummy_process] Received signal: $1\"\n"
                   << "    exit 0\n"
                   << "}\n"
                   << "trap 'handle_signal SIGTERM' SIGTERM\n"
                   << "while true; do\n"
                   << "    echo \"dummy_process is running...\"\n"
                   << "    sleep 1\n"
                   << "done\n";
        scriptFile.close();

        if (chmod(scriptPath.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == -1) {
            std::cerr << "Failed to set execute permission on " << scriptPath << std::endl;
            return false;
        }
        return true;
    } else {
        std::cerr << "Failed to create " << scriptPath << std::endl;
        return false;
    }
}

这个脚本会不断输出“dummy_process is running…”并在接收到SIGTERM信号时退出。

2.2 启动虚拟进程

使用fork和execl函数来启动这个虚拟进程。

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <iostream>

pid_t StartDummyProcess(const std::string& scriptPath) {
    pid_t pid = fork();
    if (pid < 0) {
        std::cerr << "Failed to fork process" << std::endl;
        return -1;
    } else if (pid == 0) {
        execl(scriptPath.c_str(), scriptPath.c_str(), static_cast<char*>(nullptr));
        _exit(EXIT_FAILURE);  // exec never returns
    }
    return pid;
}

2.3 主程序

最后，编写主程序来启动虚拟进程并定期记录其CPU负载信息。

#include <iostream>
#include <thread>
#include <chrono>
#include <unordered_map>

void TestCpuMonitor(int count_max, const std::vector<std::string>& process_names_or_pids) {
    ProcessCpuLoad cpu_load;
    CpuMonitor cpu_monitor("/tmp/cpuload.txt");

    int count = 0;
    auto init_time = std::chrono::steady_clock::now();

    std::unordered_map<int, float> previous_cpu_times;

    while (count++ < count_max) {
        std::this_thread::sleep_for(std::chrono::seconds(2));

        cpu_load.RunOnce(process_names_or_pids);
        auto now = std::chrono::steady_clock::now();
        auto time_us = std::chrono::duration_cast<std::chrono::microseconds

>(now - init_time).count();

        auto results = cpu_load.GetResult();

        // 计算每个进程的CPU使用率
        for (auto& result : results) {
            if (previous_cpu_times.find(result.id) != previous_cpu_times.end()) {
                float previous_time = previous_cpu_times[result.id];
                result.load = (result.load - previous_time) / 2.0f;  // 每两秒采样一次，计算使用率
            } else {
                result.load = 0.0f;
            }
            previous_cpu_times[result.id] = result.load;
        }

        // 输出调试信息
        std::cout << "Time: " << time_us << " us" << std::endl;
        for (const auto& result : results) {
            std::cout << "ProcessID: " << result.id << ", ProcessName: " << result.name << ", CPULoad: " << result.load << "%" << std::endl;
        }

        cpu_monitor.LogCpuLoad(time_us, results);
    }
}

int main() {
    const std::string scriptPath = "/tmp/dummy_process.sh";
    if (!CreateDummyProcessScript(scriptPath)) {
        return EXIT_FAILURE;
    }

    pid_t pid = StartDummyProcess(scriptPath);
    if (pid < 0) {
        return EXIT_FAILURE;
    }
    std::cout << "Started dummy process with PID: " << pid << std::endl;

    std::vector<std::string> processes_to_monitor = {"dummy_process"};
    TestCpuMonitor(5, processes_to_monitor);

    // 终止虚拟进程
    kill(pid, SIGTERM);
    waitpid(pid, nullptr, 0);

    return 0;
}

3. 完整代码

#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#include <chrono>
#include <csignal>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <memory>
#include <mutex>
#include <sstream>
#include <string>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <vector>

// RAII包装类，用于管理文件指针
class FilePtr {
 public:
  explicit FilePtr(const std::string& path, const char* mode) {
    file_ = fopen(path.c_str(), mode);
    if (!file_) {
      throw std::runtime_error("Failed to open file: " + path);
    }
  }

  ~FilePtr() {
    if (file_) {
      fclose(file_);
    }
  }

  FILE* get() const {
    return file_;
  }

 private:
  FILE* file_;
};

// 模拟的进程CPU负载信息类
class ProcessCpuLoad {
 public:
  struct Result {
    int id;
    float load;
    std::string name;
  };

  void RunOnce(const std::vector<std::string>& process_names_or_pids) {
    results_.clear();
    std::unordered_set<std::string> target_set(process_names_or_pids.begin(), process_names_or_pids.end());
    std::unique_ptr<DIR, decltype(&closedir)> dir(opendir("/proc"), closedir);
    if (!dir) {
      std::cerr << "Failed to open /proc directory." << std::endl;
      return;
    }

    struct dirent* entry;
    while ((entry = readdir(dir.get())) != nullptr) {
      if (entry->d_type == DT_DIR) {
        int pid = atoi(entry->d_name);
        if (pid > 0) {
          std::string stat_path = "/proc/" + std::string(entry->d_name) + "/stat";
          std::string comm_path = "/proc/" + std::string(entry->d_name) + "/comm";
          try {
            FilePtr stat_file(stat_path, "r");
            FilePtr comm_file(comm_path, "r");

            char comm[256];
            if (fscanf(comm_file.get(), "%255s", comm) != 1) {
              std::cerr << "Failed to read from " << comm_path << std::endl;
              continue;
            }
            std::string pid_str = std::to_string(pid);
            bool match_found = false;
            for (const auto& target : target_set) {
              if (pid_str.find(target) != std::string::npos || std::string(comm).find(target) != std::string::npos) {
                match_found = true;
                break;
              }
            }
            if (match_found) {  // 部分匹配目标进程
              unsigned long utime, stime;
              fseek(stat_file.get(), 13 * sizeof(unsigned long), SEEK_SET);  // Skip first 13 fields
              if (fscanf(stat_file.get(), "%lu %lu", &utime, &stime) != 2) {
                std::cerr << "Failed to read from " << stat_path << std::endl;
                continue;
              }
              float total_time = static_cast<float>(utime + stime) / sysconf(_SC_CLK_TCK);
              results_.push_back({pid, total_time, std::string(comm)});
            }
          } catch (const std::runtime_error& e) {
            std::cerr << e.what() << std::endl;
          }
        }
      }
    }
  }

  std::vector<Result> GetResult() const {
    return results_;
  }

 private:
  std::vector<Result> results_;
};

// CPU监控类：负责记录CPU及各进程的CPU占用率
class CpuMonitor {
 public:
  explicit CpuMonitor(const std::string& filename) : log_file_(filename, std::ios::out) {
    if (!log_file_.is_open()) {
      throw std::runtime_error("Failed to open log file: " + filename);
    } else {
      WriteHeader();
    }
  }

  ~CpuMonitor() {
    if (log_file_.is_open()) {
      log_file_.close();
    }
  }

  // 记录CPU负载信息
  void LogCpuLoad(uint64_t time_us, const std::vector<ProcessCpuLoad::Result>& results) {
    std::lock_guard<std::mutex> lock(mutex_);
    LogTimestamp(time_us);
    LogCpuUsage(results);
    WriteToFile();
  }

 private:
  // 写入文件头
  void WriteHeader() {
    log_file_ << "Timestamp, ProcessID, ProcessName, CPULoad\n";
  }

  // 记录时间戳
  void LogTimestamp(uint64_t time_us) {
    buffer_ << "Timestamp: " << time_us << " us\n";
  }

  // 记录CPU使用情况
  void LogCpuUsage(const std::vector<ProcessCpuLoad::Result>& results) {
    for (const auto& result : results) {
      buffer_ << result.id << ", " << result.name << ", " << std::fixed << std::setprecision(2) << result.load << "s\n";
    }
  }

  // 将缓冲区内容写入文件
  void WriteToFile() {
    if (log_file_.is_open()) {
      log_file_ << buffer_.str();
      buffer_.str("");
    }
  }

  std::ofstream log_file_;
  std::ostringstream buffer_;
  std::mutex mutex_;
};

// 测试CpuMonitor类
void TestCpuMonitor(int count_max, const std::vector<std::string>& process_names_or_pids) {
  ProcessCpuLoad cpu_load;
  CpuMonitor cpu_monitor("/tmp/cpuload.txt");

  int count = 0;
  auto init_time = std::chrono::steady_clock::now();

  std::unordered_map<int, float> previous_cpu_times;

  while (count++ < count_max) {
    std::this_thread::sleep_for(std::chrono::seconds(2));

    cpu_load.RunOnce(process_names_or_pids);
    auto now = std::chrono::steady_clock::now();
    auto time_us = std::chrono::duration_cast<std::chrono::microseconds>(now - init_time).count();

    auto results = cpu_load.GetResult();

    // 计算每个进程的CPU使用率
    for (auto& result : results) {
      if (previous_cpu_times.find(result.id) != previous_cpu_times.end()) {
        float previous_time = previous_cpu_times[result.id];
        result.load = (result.load - previous_time) / 2.0f;  // 每两秒采样一次，计算使用率
      } else {
        result.load = 0.0f;
      }
      previous_cpu_times[result.id] = result.load;
    }

    // 输出调试信息
    std::cout << "Time: " << time_us << " us" << std::endl;
    for (const auto& result : results) {
      std::cout << "ProcessID: " << result.id << ", ProcessName: " << result.name << ", CPULoad: " << result.load << "%"
                << std::endl;
    }

    cpu_monitor.LogCpuLoad(time_us, results);
  }
}

/ 如下为测试代码 /

// 创建虚拟进程脚本
bool CreateDummyProcessScript(const std::string& scriptPath) {
  std::ofstream scriptFile(scriptPath);
  if (scriptFile.is_open()) {
    scriptFile << "#!/bin/bash\n";
    scriptFile << "\n";
    scriptFile << "# Function to handle signals\n";
    scriptFile << "function handle_signal() {\n";
    scriptFile << "    echo \"[dummy_process] Received signal: $1\"\n";
    scriptFile << "    exit 0\n";  // Exit gracefully on signal
    scriptFile << "}\n";
    scriptFile << "\n";
    scriptFile << "# Trap signals\n";
    scriptFile << "trap 'handle_signal SIGTERM' SIGTERM\n";  // Handle SIGTERM signal
    scriptFile << "\n";
    scriptFile << "# Main loop\n";
    scriptFile << "while true; do\n";
    scriptFile << "    echo \"dummy_process is running...\"\n";
    scriptFile << "    sleep 1\n";
    scriptFile << "done\n";
    scriptFile.close();

    // Add executable permission to the script
    if (chmod(scriptPath.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == -1) {
      std::cerr << "Failed to set execute permission on " << scriptPath << std::endl;
      return false;
    }
    return true;
  } else {
    std::cerr << "Failed to create " << scriptPath << std::endl;
    return false;
  }
}

// 启动虚拟进程
pid_t StartDummyProcess(const std::string& scriptPath) {
  pid_t pid = fork();
  if (pid < 0) {
    std::cerr << "Failed to fork process" << std::endl;
    return -1;
  } else if (pid == 0) {
    // Child process
    execl(scriptPath.c_str(), scriptPath.c_str(), static_cast<char*>(nullptr));
    _exit(EXIT_FAILURE);  // exec never returns
  }
  return pid;
}
int main() {
  const std::string scriptPath = "/tmp/dummy_process.sh";
  if (!CreateDummyProcessScript(scriptPath)) {
    return EXIT_FAILURE;
  }

  pid_t pid = StartDummyProcess(scriptPath);
  if (pid < 0) {
    return EXIT_FAILURE;
  }
  std::cout << "Started dummy process with PID: " << pid << std::endl;

  std::vector<std::string> processes_to_monitor = {"dummy_process"};
  TestCpuMonitor(5, processes_to_monitor);

  // 终止虚拟进程
  kill(pid, SIGTERM);
  waitpid(pid, nullptr, 0);

  return 0;
}

执行结果

# g++ -std=c++14 -o cpu_load cpu_load.cpp
$ cat /tmp/cpuload.txt 
Timestamp, ProcessID, ProcessName, CPULoad
Timestamp: 2008916 us
15097, dummy_process.s, 0.00s
Timestamp: 4023839 us
15097, dummy_process.s, 35.28s
Timestamp: 6034096 us
15097, dummy_process.s, 17.64s
Timestamp: 8041633 us
15097, dummy_process.s, 26.46s
Timestamp: 10050709 us
15097, dummy_process.s, 22.05s
橘色的喵
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
linux查看cpu的负载
远方的少年
11-05 2363
linux可以通过top命令查看cpu负载信息，这个信息的后半部分会显示load average.它的意思是系统的平均载荷。数字越小，则载荷越小。三个数字分别表示最近1分钟，5分钟，15分钟内系统的平均负荷。 ...
workload:一个非常简单的工作负载，占用可配置的CPU内存量
03-25
总之，"workload:一个非常简单的工作负载，占用可配置的CPU内存量"是一个用C语言编写的实用工具，它对于系统测试、性能分析和基准设定具有重要价值。通过深入理解C语言和操作系统级别的资源管理，我们可以更好地理解...
linux 排查cpu负载过高原因
zjt921586518的专栏
07-01 4013
CPU负载查看方法： 使用vmstat查看系统维度的CPU负载 使用top查看进程维度的CPU负载 一、测试工具 1、使用 vmstat 查看系统纬度的 CPU 负载： 可以通过 vmstat 从系统维度查看 CPU 资源的使用情况。 用法说明： 格式：vmstat -n 1# -n 1 表示结果一秒刷新一次。示例输出： [root@wangerxiao ~]# vmstat -t 1 procs -----------memory---------- ---swap-- -----io----.
LinuxC完成cpu负载计算
weixin_45000480的博客
09-20 879
【代码】LinuxC完成cpu负载计算。
Linux系统：stress-ng测压工具
cronaldo91的博客
06-15 9501
（1）概念stress是Linux系统下的系统压力测试工具，可以测试Linux系统的CPU、内存、磁盘I/O等的负载。当stress测试CPU时，会不断调用进程，计算随机数的平方根；当测试内存时，会不断调用内存调用malloc和内存释放free函数；当测试磁盘I/O时，会不断调用sync()中断，以测试磁盘I/O。CentOS 7 的EPEL源包含2个压力测试工具，一个是标准的stress，另一个是其升级版stress-ng。
编程获取Linux的内存占用和CPU使用率
tugouxp的专栏
08-21 2211
Linux平台上有很多系统监控工具，自己用过的就有top、htop、glances，可以在上面看到系统平均负载，内存占用，CPU使用率等信息。除此之外还有uptime，lsblk，df，du，free，iftop等针对性查看系统资源的命令。准备在自己的程序中获取相关系统资源的信息，解析命令输出显得不伦不类，于是就找了找其它方法。
linux下查看cpu负载均衡,CentOS下如何查看多核负载?CentOS下查看多核负载的方法
weixin_30822467的博客
05-12 491
1. Linux下，如何看每个CPU的使用率：#top -M之后按下数字1. (或者top之后按1也一样)则显示多个CPU 的信息，和内存信息：[root@testpc ~]# top -Mtop - 15:38:40 up 2 days, 2:05, 2 users, load average: 0.00, 0.00, 0.00Tasks: 138 total, 1 running, ...
linux编程性能,Linux性能评估工具
weixin_34688479的博客
05-13 703
Linux性能评估工具2019-03-11编程之家https://www.jb51.cc编程之家收集整理的这篇文章主要介绍了Linux性能评估工具，编程之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。目录检测服务器当前的性能，主要检查的项目如下：负载：uptime内核信息： dmesg内存：vmstat、freecpu：top、mpstat、I/O：iostat网络：sar有些命令需要安装...
深入理解 Linux eBPF：一个完整阅读清单(转载)
热门推荐
宋宝华
07-12 2万+
linux eBPF是3.17内核开始引入的一个全新设计，代码目录主要在kernel/bpf 下，它的全称是 extended BPF(eBPF)， 目前关于eBPF的资料还比较乱，很难得看到一篇对ebpf总结的那么全的文章，转载自此：
解决Linux 负载过高问题过程记录
简jian单dan的博客
03-12 1876
解决问题的思路 1.top命令查看该机器的负载状况 2.cd/proc/pid 查看对应高占用程序的位置 3.进入对应程序中查看日志，根据CPU和内存这两个因素分析 4.ps -ajxf 查看进程及其之下的线程，通过stat查看是否存在D僵尸进程 1.什么是负载过高 1.1load Average 1：load Average 1.1：什么是Load？什么...
linux使用stress命令进行压力测试cpu
liu_chen_yang的博客
09-08 1万+
linux使用stress命令进行压力测试cpu
dashboard:一个简单的 Linux 仪表板
06-07
标题 "dashboard:一个简单的 Linux 仪表板" 指向的是一个专为 Linux 系统设计的、基于 Go 语言开发的轻量级监控工具。这个工具可能提供了一个直观的界面，用于展示系统的关键性能指标，如 CPU 使用率、内存使用情况...
linux系统使服务器cpu负载到达指定的阀值，基于go语言编写，送上源码 本人纯菜鸟，不对的地方还请大佬们指正
11-14
这篇描述提到了一个基于Go语言编写的Linux服务器CPU负载管理工具。让我们详细探讨一下这个话题，以及如何通过编程来实现这一功能。 首先，理解CPU负载的计算方式是至关重要的。在Linux中，CPU负载并非简单的CPU使用...
实验一Linux基础及LKM编程.docx
02-22
Linux是一个开源的操作系统，它提供了强大的命令行界面供用户进行各种操作。掌握常用的shell命令是Linux使用的基础，比如： - `cd ..`：用于切换到当前目录的上一级目录。 - `rm file`：删除指定的文件。 - `mv ...
xetxh:一个简单的GNUlinux工具，用于获取以python编写的系统信息
03-15
【xetxh：一个简单的GNU/Linux工具，用于获取Python编写的系统信息】 在Linux操作系统中，管理和了解系统的运行状态是管理员日常工作中不可或缺的一部分。`xetxh` 是一个专为GNU/Linux环境设计的简单工具，其主要...
LINUX:懒汉单例模式线程池
W2155的博客
07-16 446
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
定制 Linux 内核的意义
地球空间
07-17 287
2. **配置内核**：使用 `make menuconfig` 或 `make xconfig` 配置内核，选择需要支持的硬件和功能。1. **性能优化**：通过定制内核，可以针对特定的硬件或应用场景优化性能，比如减少不必要的驱动支持、优化调度算法等。7. **持续维护**：随着时间的推移，可能需要对内核进行更新和维护，以支持新的硬件和功能。6. **测试和调试**：启动系统，测试新内核的功能和性能，根据需要进行调试和优化。4. **安装内核**：编译完成后，将生成的内核镜像和相关的模块安装到系统中。
Qmi8658a姿态传感器使用心得（2）linux
最新发布
Starry的博客
07-19 859
COD 原理，CTRL9，自检（详细代码示例）
【Linux杂货铺】期末总结篇4：shell编程
聆风吟的博客
07-17 3516
本文主要分享作者本人期末复习的总结，欢迎大家借鉴浏览。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

橘色的喵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值