【Linux文件篇】系统文件、文件描述符与重定向的实用指南

最新推荐文章于 2024-07-11 10:51:42 发布
最新推荐文章于 2024-07-11 10:51:42 发布
阅读量1k 收藏 32
点赞数 11
分类专栏： Linux 文章标签： linux 运维 java 算法 服务器 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74755811/article/details/139564250
版权

W...Y的主页 😊 

代码仓库分享💕 

 前言：相信大家对文件都不会太陌生、也不会太熟悉。在没有学习Linux操作系统时，我们在学习C或C++时都学过如何去创建、打开、读写等待文件的操作，知道一些语言级别的一些接口与函数。但是我相信对于没有学习操作系统的对文件的认识还很浅，今天我们就进入文件，好好学习操作系统与文件的关系。相信大家看完文件篇后会对文件有了新的认识和启发。话不多说我们开始学习。

目录

铺垫

代码回顾C文件接口

系统文件I/O 

open接口

write read close类比C文件相关接口

文件描述符fd

文件描述符的分配规则

 Linux中的重定向

 使用 dup2 系统调用

在自治shell中加入重定向 

铺垫

1.当我们创建一个文件但不对文件进行写入时，需不需要开辟一些空间呢？肯定是需要的。因为文件 = 内容 + 属性。文件的名称、创建时间、修改时间……对应的信息都需要进行存储。

2.我们访问文件之前，都得先打开文件，修改文件都是通过代码的方式完成修改的。而我们不能通过代码对磁盘中的文件直接做修改，是直接将文件加载到内存中后通过CPU进行对文件的修改。

3.我们在C语言中都知道，想要操作一个文件就必须使用fopen函数将文件打开，那是谁打开的文件呢？当我们在打开文件之前，必须要将想要访问文件的程序跑起来，所以归根结底是进程打开了文件。

4.一个进程也可以打开多个文件。所以一定时间段内，系统中存在多个进程，也可能存在更多被打开的文件。OS就要对这些被打开的文件进行管理，所以内核中一定要有描述被打开文件的结构体，并用其定义对象。

5.系统中不是所有的文件都是被打开的，被打开的文件叫内存文件，没有被打开的文件叫磁盘文件。

代码回顾C文件接口

hello.c写文件

#include <stdio.h>
#include <string.h>
int main()
{
    FILE *fp = fopen("myfile", "w");
    if (!fp)
    {
        printf("fopen error!\n");
    }
    const char *msg = "hello why!\n";
    int count = 5;
    while (count--)
    {
        fwrite(msg, strlen(msg), 1, fp);
    }
    fclose(fp);
    return 0;
}

fopen模式中有很多模式：

r ： 打开文本文件进行阅读，流位于文件的开头。

r+：开放阅读和写作，流位于文件的开头。

w：截断（缩短）文件为零长度或创建文本文件进行写入，流位于文件的开头。

w+：开放阅读和写作，如果文件不存在，则创建该文件，否则将被截断，流位于文件的开头。

a：打开以进行追加（写在文件末尾）。如果文件不存在，则创建该文件，流位于文件的末尾。

a+：打开以供读取和追加（在文件末尾写入）。如果文件不存在，则创建该文件。初始文件位置。对于阅读是在文件的开头，但输出始终附加到文件末尾。

#include <stdio.h>
#include <string.h>
int main()
{
    FILE *fp = fopen("myfile", "r");
    if (!fp)
    {
        printf("fopen error!\n");
    }
    char buf[1024];
    const char *msg = "hello bit!\n";
    while (1)
    {
        // 注意返回值和参数，此处有坑，仔细查看man手册关于该函数的说明
        size_t s = fread(buf, 1, strlen(msg), fp);
        if (s > 0)
        {
            buf[s] = 0;
            printf("%s", buf);
        }
        if (feof(fp))
        {
            break;
        }
    }
    fclose(fp);
    return 0;
}

fwrite与fread函数都是C语言提供对文件读写的接口， 其就是将对应的内容输入或输出对应的文件流。

fread函数参数：

void * buffer 也就是想要把读取的数据到的地方的地址 比如一个叫做a的整形变量的地址 也就是&a 又或许是一个结构体对象 假设他叫s 那便是&s

size_t size 这就是接收数据的变量所占空间的大小 如果他是一个int类型 那就是sizeof(int)

size_t count 要写入数据的个数

FILE*stream 这是管理文件操作的指针 一般会在开始对文件开始操作前定义 这个指针会指向我们接下来要操作的文件

fwrite函数参数与fread参数相同，只是方向刚好相反。

 输出信息到显示器，你有哪些方法：

#include <stdio.h>
#include <string.h>
int main()
{
    const char *msg = "hello fwrite\n";
    fwrite(msg, strlen(msg), 1, stdout);
    printf("hello printf\n");
    fprintf(stdout, "hello fprintf\n");
    return 0;
}

 stdin & stdout & stderr

C默认会打开三个输入输出流，分别是stdin, stdout, stderr
仔细观察发现，这三个流的类型都是FILE*, fopen返回值类型，文件指针

系统文件I/O 

操作文件，除了上述C接口（当然，C++也有接口，其他语言也有），我们还可以采用系统接口来进行文件访问，先来直接以代码的形式，实现和上面一模一样的代码：

写文件：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main()
{
    umask(0);
    int fd = open("myfile", O_WRONLY | O_CREAT, 0644);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
    int count = 5;
    const char *msg = "hello bit!\n";
    int len = strlen(msg);
    while (count--)
    {
        write(fd, msg, len); // fd: 后面讲， msg：缓冲区首地址， len: 本次读取，期望写入多少个字节的数据。 返回值：实际写了多少字节数据
    }
    close(fd);
    return 0;
}

 读文件：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
int main()
{
int fd = open("myfile", O_RDONLY);
if(fd < 0){
perror("open");
return 1;
}
const char *msg = "hello bit!\n";
char buf[1024];
while(1){
ssize_t s = read(fd, buf, strlen(msg));//类比write
if(s > 0){
printf("%s", buf);
}else{
break;
}
}
close(fd);
return 0;
}

open接口

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
pathname: 要打开或创建的目标文件
flags: 打开文件时，可以传入多个参数选项，用下面的一个或者多个常量进行“或”运算，构成flags。
参数:
O_RDONLY: 只读打开
O_WRONLY: 只写打开
O_RDWR : 读，写打开
这三个常量，必须指定一个且只能指定一个
O_CREAT : 若文件不存在，则创建它。需要使用mode选项，来指明新文件的访问权限
O_APPEND: 追加写

其实我们可以使用|的方式将flags参数进行组合，因为他们就是宏。

返回值：
成功：新打开的文件描述符
失败：-1

mode的意思就是创建目标文件时所需要的权限。

 open 函数具体使用哪个，和具体应用场景相关，如目标文件不存在，需要open创建，则第三个参数表示创建文件的默认权限,否则，使用两个参数的open。

write read close类比C文件相关接口

在认识返回值之前，先来认识一下两个概念: 系统调用 和 库函数

上面的 fopen fclose fread fwrite 都是C标准库当中的函数，我们称之为库函数（libc）。
而， open close read write lseek 都属于系统提供的接口，称之为系统调用接口
回忆一下我们讲操作系统概念时，画的一张图

系统调用接口和库函数的关系，一目了然。
所以，可以认为，f#系列的函数，都是对系统调用的封装，方便二次开发。 

文件描述符fd

 通过学习open函数我们知道在成功打开文件后会返回一个文件描述符，而这些文件描述符就是一些整数，当我们打开多个文件后这些数字会从3开始一直往后延续，那为什么0、1、2没有人用呢？

0 & 1 & 2

Linux进程默认情况下会有3个缺省打开的文件描述符，分别是标准输入0， 标准输出1， 标准错误2.0,1,2对应的物理设备一般是：键盘，显示器，显示器

在系统层面我们可以看出，这写接口都是以的是系统提供的接口所使用的参数是文件描述符，而在语言层面上使用的都是File*指针，这个File是C语言分装的一个结构体。

 

而现在知道，文件描述符就是从0开始的小整数。当我们打开文件时，操作系统在内存中要创建相应的数据结构来描述目标文件。于是就有了file结构体。表示一个已经打开的文件对象。而进程执行open系统调用，所以必须让进程和文件关联起来。每个进程都有一个指针*files, 指向一张表files_struct,该表最重要的部分就是包涵一个指针数组，每个元素都是一个指向打开文件的指针！所以，本质上，文件描述符就是该数组的下标。所以，只要拿着文件描述符，就可以找到对应的文件 。

  

上图是源码，所以文件描述符的本质就是数组下标！！！ 

文件描述符的分配规则

直接看代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{
int fd = open("myfile", O_RDONLY);
if(fd < 0){
perror("open");
return 1;
}
printf("fd: %d\n", fd);
close(fd);
return 0;
}

输出发现是 fd: 3

关闭0或者2，在看

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{
close(0);
//close(2);
int fd = open("myfile", O_RDONLY);
if(fd < 0){
perror("open");
return 1;
}
printf("fd: %d\n", fd);
close(fd);
return 0;
}

 发现是结果是： fd: 0 或者 fd 2 可见，文件描述符的分配规则：在files_struct数组当中，找到当前没有被使用的最小的一个下标，作为新的文件描述符。

 Linux中的重定向

我们知道重定向可以向文件中写入内容。

但是当我们使用 > 对文件进行重定向时，多次对文件进行写入，然后进行查看我们只能看到文件中只有我们最后一次写的内容，清空了之前写的所有内容。这不就是我们fopen函数中的‘w’模式。

 当我们使用>>操作符对文件进行重定向时，每次对文件写入都不会清空文件中的内容。所以这就类比fopen函数中的‘a’模式。

当我们现在已经知道重定向的含义以及文件描述符的分配规则，并且我们知道在语言层面是stdin、stdout、strerr，在系统层面就是0、1、2，当我们关闭1，然后使用写打开一个文件时，使用stdout就可以往文件中写入，这种现象叫做输出重定向。

输出重定向代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
int main()
{
    close(1);
    int fd = open("myfile", O_WRONLY | O_CREAT, 00644);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
    printf("fd: %d\n", fd);
    fflush(stdout);
    close(fd);
    exit(0);
}

输入重定向代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
int main()
{
    close(0);
    int fd = open("test.txt", O_RDONLY);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
    int a = 0;
    scanf("%d", &a);
    printf("%d\n", a);
    close(fd);
    exit(0);
}

 追加重定向与输出重定向基本相同，唯一不同的就是将open函数中的flags参数改成O_WRONLY | O_CREAT|O_TRUNC即可。

 使用 dup2 系统调用

其中，oldfd表示待复制的文件描述符，newfd表示新的文件描述符。该函数返回新的文件描述符，若出错则返回-1。

dup2函数的工作原理相对简单，主要包括以下几个步骤：

  1. 检查oldfd和newfd是否相等，若相等则不进行任何操作，直接返回newfd；
  2. 检查newfd的合法性，若已经打开，则先关闭；
  3. 复制oldfd的文件表项到newfd，使得两者指向同一个文件表项；
  4. 返回newfd。

所以我们不需要进行close，直接使用dup2即可。

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main()
{
    int fd = open("./log", O_CREAT | O_RDWR);
    if (fd < 0)
    {
        perror("open");
        return 1;
    }
    close(1);
    dup2(fd, 1);
    for (;;)
    {
        char buf[1024] = {0};
        ssize_t read_size = read(0, buf, sizeof(buf) - 1);
        if (read_size < 0)
        {
            perror("read");
            break;
        }
        printf("%s", buf);
        fflush(stdout);
    }
    return 0;
}

在自治shell中加入重定向 

我们在命令行中可以使用echo指令进行重定向，我们之前做的简易shell中没有重定向，现在我们将代码补充完整：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>

#define SIZE 1024
#define MAX_ARGC 64
#define SEP " "
#define STREND '\0'

// 下面的都和重定向有关
#define NoneRedir  -1
#define StdinRedir  0
#define StdoutRedir 1
#define AppendRedir 2

#define IgnSpace(buf,pos) do{ while(isspace(buf[pos])) pos++; }while(0)

int redir_type = NoneRedir;
char *filename = NULL;

char *argv[MAX_ARGC];
char pwd[SIZE];
char env[SIZE]; // for test
int lastcode = 0;


// ls -a -l
// ls -a -l > log.txt


const char* HostName()
{
    char *hostname = getenv("HOSTNAME");
    if(hostname) return hostname;
    else return "None";
}

const char* UserName()
{
    char *hostname = getenv("USER");
    if(hostname) return hostname;
    else return "None";
}

const char *CurrentWorkDir()
{
    char *hostname = getenv("PWD");
    if(hostname) return hostname;
    else return "None";
}

char *Home()
{
    return getenv("HOME");
}

int Interactive(char out[], int size)
{
    // 输出提示符并获取用户输入的命令字符串"ls -a -l"
    printf("[%s@%s %s]$ ", UserName(), HostName(), CurrentWorkDir());
    fgets(out, size, stdin);
    out[strlen(out)-1] = 0; //'\0', commandline是空串的情况?
    return strlen(out);
}

void CheckRedir(char in[])
{
    // ls -a -l
    // ls -a -l > log.txt
    // ls -a -l >> log.txt
    // cat < log.txt
    redir_type = NoneRedir;
    filename = NULL;
    int pos = strlen(in) - 1;
    while( pos >= 0 )
    {
        if(in[pos] == '>')
        {
            if(in[pos-1] == '>')
            {
                redir_type = AppendRedir;
                in[pos-1] = STREND;
                pos++;
                IgnSpace(in, pos);
                filename = in+pos;
                break;
            }
            else
            {
                redir_type = StdoutRedir;
                in[pos++] = STREND;
                IgnSpace(in, pos);
                filename = in+pos;
                //printf("debug: %s, %d\n", filename, redir_type);
                break;
            }
        }
        else if(in[pos] == '<')
        {
            redir_type = StdinRedir;
            in[pos++] = STREND;
            IgnSpace(in, pos);
            filename = in+pos;
            //printf("debug: %s, %d\n", filename, redir_type);
            break;
        }
        else
        {
            pos--;
        }
    }
}

void Split(char in[])
{
    CheckRedir(in);
    int i = 0;
    argv[i++] = strtok(in, SEP); // "ls -a -l"
    while(argv[i++] = strtok(NULL, SEP)); // 故意将== 写成 =
    if(strcmp(argv[0], "ls") ==0)
    {
        argv[i-1] = (char*)"--color";
        argv[i] = NULL;
    }
}

void Execute()
{
    pid_t id = fork();
    if(id == 0)
    {
        int fd = -1;
        if(redir_type == StdinRedir)
        {
            fd = open(filename, O_RDONLY);
            dup2(fd, 0);
        }
        else if(redir_type == StdoutRedir)
        {
            fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC);
            dup2(fd, 1);
        }
        else if(redir_type == AppendRedir)
        {
            fd = open(filename, O_CREAT | O_WRONLY | O_APPEND);
            dup2(fd, 1);
        }
        else
        {
            // do nothing
        }

        // 让子进程执行命名
        execvp(argv[0], argv);
        exit(1);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid == id) lastcode = WEXITSTATUS(status); 
    //printf("run done, rid: %d\n", rid);
}

int BuildinCmd()
{
    int ret = 0;
    // 1. 检测是否是内建命令, 是 1, 否 0
    if(strcmp("cd", argv[0]) == 0)
    {
        // 2. 执行
        ret = 1;
        char *target = argv[1]; //cd XXX or cd
        if(!target) target = Home();
        chdir(target);
        char temp[1024];
        getcwd(temp, 1024);
        snprintf(pwd, SIZE, "PWD=%s", temp);
        putenv(pwd);
    }
    else if(strcmp("export", argv[0]) == 0)
    {
        ret = 1;
        if(argv[1])
        {
            strcpy(env, argv[1]);
            putenv(env);
        }
    }
    else if(strcmp("echo", argv[0]) == 0)
    {
        ret = 1;
        if(argv[1] == NULL) {
            printf("\n");
        }
        else{
            if(argv[1][0] == '$')
            {
                if(argv[1][1] == '?')
                {
                    printf("%d\n", lastcode);
                    lastcode = 0;
                }
                else{
                    char *e = getenv(argv[1]+1);
                    if(e) printf("%s\n", e);
                }
            }
            else{
                printf("%s\n", argv[1]);
            }
        }
    }
    return ret;
}

int main()
{
    while(1)
    {
        char commandline[SIZE];
        // 1. 打印命令行提示符，获取用户输入的命令字符串
        int n = Interactive(commandline, SIZE);
        if(n == 0) continue;
        // 2. 对命令行字符串进行切割
        Split(commandline);
        // 3. 处理内建命令
        n = BuildinCmd();
        if(n) continue;
        // 4. 执行这个命令
        Execute();
    }
  
    return 0;
}

 上面就是简易shell完整版，代码仅供参考！！！

以上就是本次全部内容，感谢大家观看。

W…Y
关注
  • 11
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
linux 进程间文件描述符传递,进程间传递文件描述符fd
weixin_28825959的博客
05-03 1542
众所周知，子进程会继承父进程已经打开的文件描述符fd，但是fork之后的是不会被继承的，这个时候是否无能无力了？答应是NO。Linux提供了一个系统调用sendmsg，借助它，可以实现进程间传递文件描述符fd，而且不仅限于父进程到子进程。sendmsg函数的原型如下：#includessize_tsendmsg(intsocket,conststructmsghdr*message,...
UNIX.shell范例精解(第4版)_带光盘文件.zip
06-24
8. **文件描述符与重定向**：学习如何利用文件描述符进行输入输出重定向，以及如何使用进程子句（`&`）实现后台执行。 9. **函数库与模块化编程**：了解如何组织和复用代码，创建可移植的Shell脚本库。 10. **调试...
Linux文件描述符详解
运维@小兵的博客
04-12 2350
文章目录一、概念二、手动创建文件描述符`2.1.语法`2.1.1.创建2.1.2.调用2.1.3.关闭`2.2.重定向输出的文件描述符``2.3.重定向输入的文件描述符``2.4.既可以输出又可以输入的文件描述符`三、使用read命令读取文件描述符 参考书籍：《Linux Shell核心编程指南》——丁明一 一、概念 文件描述符是一个非负整数，内核需要通过这个文件描述符才可以访问文件 文件描述符好比一本书的目录（索引），通过这个索引可以找到需要的内容 在Linux系统中内核默认为每个进程创建三个标准的文
『Linux从入门到精通』第 ⑲ 期 - 文件描述符及重定向——为何说Linux下，一切皆文件?
花想云的博客
07-03 1196
本章我们将深入学习Linux文件系统，深入理解文件操作的底层原理。首先我们将回忆在C语言阶段曾经学习过的文件操作相关函数，其次我们将认识何为文件描述符——OS管理进程对应文件的关键。最后，我们需要理解曾经只是了解过的重定向操作究竟在底层做了什么~
Linux 文件重定向；文件描述符复制(＞&,＞&-)；exec操作文件描述符
weixin_45878775的博客
07-08 199
然后我们又通过FD复制，将FD1指向FD3,此时数据流流向FD3指向的目标，即显示器，需要解释一下的是，因为FD1是原本就存在的，所以此时的复制功能更接近于重定向，之后的echo语句，则会在显示器上输出。上例中，通过exec操作FD1后，接下来使用echo都不会输出到显示器上，之后再次通过exec重定向后，才会输出到显示器上。exec命令可以操作文件描述符，而且使用exec操作文件描述符所进行的文件重定向，作用域是全局的。与之相对应的是，若在指令后嵌入重定向操作，则重定向的作用域只有本条指令。
Linux重定向和管道符使用避坑指南
u014389734的博客
06-15 418
本文就分享一下我在实践中使用重定向和管道符遇到的一些坑，搞明白一些底层原理，写脚本的效率能提升不少。 我很喜欢Linux系统，尤其是 Linux 的一些设计很漂亮，比如可以将一些复杂的问题分解成若干小问题，通过管道符和重定向机制灵活地用现成的工具解决，写成shell脚本就很高效。 本文就分享一下我在实践中使用重定向和管道符遇到的一些坑，搞明白一些底层原理，写脚本的效率能提升不少。 > 和 >> 重定向符的坑 先说第一个问题，执行如下命令会发生什么? $ cat file...
Linux_2_帮助、文件管理、管道与IO
qq_24472227的博客
07-01 328
1、获取Linux中的帮助 2、文件管理 3、文件元数据和节点表结构 4、标准I/O重定向和管道
Hadoop 分布式文件系统 (The Hadoop Distributed Filesystem)
devalone 的专栏
06-12 1396
Hadoop 分布式文件系统 (The Hadoop Distributed Filesystem) 当一个数据集过度成长为超过一台物理机器的存储能力时，切分它以跨多台台机器分别存储就变得必要了。管理通过网络连接的多台机器存储的文件系统称为分布式文件系统(distributed filesystems)。因为它们是基于网络的，带来了网络编程所有的复杂性，因而使分布式文件系统比常规的磁盘文件系统...
浅析Linux系统常规提权手段的原理与技巧
道阻且长，行则将至。
01-08 1248
渗透测试过程中，通过 Web 服务漏洞（比如文件上传漏洞）拿到服务器 Shell 后，经常会发现所获得的 Shell 仅有较低的权限，而为了进一步获得高权限 Shell（root），避免不了地就是进一步进行提权。本文来学习、总结下 Linux 系统一些常规的提权手段的原理与技巧。
linux与shell编程指南,LINUX与UNIX SHELL编程指南
weixin_39716044的博客
05-13 90
目 录译者序前言第一部分 shell第1章 文件安全与权限11.1 文件11.2 文件类型21.3 权限21.4 改变权限位41.4.1 符号模式41.4.2 chmod命令举例51.4.3 绝对模式51.4.4 chmod命令的其他例子61.4.5 可以选择使用符号模式或绝对模式71.5 目录71.6 suid/guid71.6.1 ...
linux-Bash风格指南规范最佳实践和实用技巧
08-13
**Linux Bash风格指南：规范、最佳实践与实用技巧** 在Linux世界中，Bash shell脚本是日常自动化任务和系统管理的重要工具。了解并遵循良好的Bash编程风格，不仅可以提高脚本的可读性和可维护性，还能避免潜在错误...
LINUX与UNIX SHELL编程指南
02-07
目 录 译者序 前言 第一部分 shell 第1章 文件安全与权限 1 ...18.7.10 while循环和文件描述符 196 18.8 使用break和continue控制循环 197 18.8.1 break 197 18.8.2 跳出case语句 197 18.8.3 continue 197 18.8.4 ...
【Linux】进程间通信——匿名管道
2201_76024104的博客
07-08 1155
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
【Linux】 GCC/G++与Makefile使用
Long_kin的博客
07-11 952
收藏向 使用解析
【Linux】：程序替换
Yikefore的博客
07-09 1085
程序替换的详细介绍以及各种程序替换接口介绍以及使用！
Linux —— 进程间通信
最新发布
学习C++的小陈同学
07-11 910
本篇整理了关于进程间通信的内容，以及详解的介绍了两种进程间通信的方式，以及相关的接口和代码演练
linux积累-core文件是干啥的
hebtu666
07-09 3876
核心转储（core dump）文件是一个程序崩溃时所产生的文件，它记录了程序崩溃时的内存状态，包括程序计数器和寄存器内容等信息。此外，如果程序是在特定的库或者环境中运行时崩溃的，你可能还需要安装那些库的调试符号，并在调试器中设置相应的环境变量。： 当你有了核心转储文件后，你可以使用像GDB（GNU调试器）这样的调试器来分析它。首先，你需要确保你有相应的程序的带调试符号的可执行文件。： 根据调试器提供的信息，你可以检查源代码中可能导致问题的部分，例如无效的指针引用、数组越界或其他违反程序逻辑的操作。
LVGL ArchLinux VSCode环境运行
Sandman06的博客
07-10 311
很多包在Arch中名字都不一样，我配合GPT，找到了相同功能的包，配合官方步骤，大致过程如下。vscode用AUR管理器安装”visual-studio-code-bin“LVGL官方的Demo是跑在Ubuntu系的系统上的。# 用如下指令代替Ubuntu系apt指令。git保证项目完整，各模块更新就能跑起来了。# VSCode安装。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

W…Y

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

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

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

打赏作者

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

抵扣说明：

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

余额充值