02-系统调用、文件、目录

于 2024-01-09 09:14:53 发布
阅读量974 收藏 19
点赞数 24
分类专栏： C/C++ Linux系统 文章标签： c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhb_feng/article/details/135471470
版权

系统调用、文件、目录

1. 系统调用

1.1 系统编程概述

  • 操作系统的职责：

    • 操作系统用来管理所有的资源，并将不同的设备和不同的程序关联起来。

  • 什么是 Linux 系统编程

    • 在有操作系统的环境下编程，并使用操作系统提供的系统调用及各种库，对系统资源进行访问。
    • C 语言 + 使用系统调用的方法，就可以进行 Linux 系统编程了。

1.2 系统调用概述

  • 是操作系统提供给用户使其可以 操作内核 提供服务的 一组函数接口。

在这里插入图片描述

  • Linux 的不同版本提供了 两三百个系统调用。

  • 用户程序可以通过这组接口获得操作系统（内核）提供的服务。

    • 在这里插入图片描述

    • 例如：

      • 用户可以通过文件系统相关的系统调用，请求系统打开文件、关闭文件或读写文件。

  • 系统调用按照功能逻辑大致 可分为:

    • 进程控制、进程间通信、文件系统控制、系统控制、内存管理、网络管理、 socket 控制、用户管理。

  • 系统调用的 返回值：

    • 通常，用一个 负的返回值 来表明错误，返回一个 0 值表明成功。错误信息存放在全局变量 errno 中，用户可用 perror 函数打印出错信息。

  • 系统调用遵循的规范：

    • 在 Linux 中，应用程序编程接口(API)遵循 POSIX 标准。
    • POSIX 标准基于当时现有的 UNIX实践和经验，描述了操作系统的系统调用编程接口（实际上就是 API），用于保证应用程序可以在源代码一级上在多种操作系统上移植运行。
    • 如：
      • linux 下写的 open、 write 、 read 可以直接移植到 unix 操作系统下。

1.3 用户态和内核态

1.3.1 引入

  • CPU 指令是可以直接操作硬件的，要是因为指令操作的不规范，造成的错误是会影响整个 计算机系统 的。好比你写 一个程序，但是因为你对 硬件操作 不熟悉，出现问题，那么影响范围是多大？是整个计算机系统，操作系统内核、及其其他所有正在运
    行的程序，都会因为你操作失误而受到不可挽回的错误，那么你只有重启整个计算机才行。

  • 而对于 硬件的操作 是非常复杂的，参数众多，出问题的几率相当大，必须及其谨慎的进行操作，这对于个人开发者来说是个艰巨的任务，同时个人开发者在这方面也是不被信任的。所以 操作系统内核 直接屏蔽了个人开发者对于硬件操作 的可能。

  • 这方面 系统内核 对 硬件操作 进行了封装处理，对外提供标准函数库，操作更简单、更安全。

    • 比如 我们要打开一个文件：
      • C标准函数库中对应的是 fopen()，
      • 其内部封装的是内核中的系统函数open()

  • 因为这个需求，硬件设备商直接提供了硬件级别的支持，做法就是对 CPU 指令设置了权限，不同级别的权限可以使用的 CPU 指令是有限制的。以 Inter CPU 为例，Inter 把 CPU 指令操作的 权限划为4级：

    • ring 0
    • ring 1
    • ring 2
    • ring 3

其中

  • ring 0 权限最高，可以使用所有 CPU 指令，
  • ring 3 权限最低，仅能使用常规 CPU 指令，这个级别的权限 不能使用访问硬件资源的指令，比如 IO 读写、网卡访问、申请内存都不行，都没有权限。

Linux 系统内核采用了：ring 0 和 ring 3 这2个权限

  • ring 0：内核态，完全在 操作系统内核 中运行，由专门的 内核线程 在 CPU 中执行其任务

  • ring 3：用户态，在 应用程序 中运行，由 用户线程 在 CPU 中执行其任务

Linux 系统中所有 对硬件资源的操作 都必须 在 内核态 状态下 执行，比如 IO 的读写，网络的操作

1.3.2 区别
  1. 用户态的代码必须由 用户线程 去执行；内核态的代码必须由 内核线程 去执行
  2. 用户态、内核态 或者说 用户线程、内核线程 可以使用的资源是不同的，尤体现在内存资源上。Linux 内核对每一个进程都会分配 4G 虚拟内存空间地址
    • 用户态： —> 只能操作 0-3G 的内存地址
    • 内核态： —> 0-4G 的内存地址都可以操作，尤其是对 3-4G 的高位地址必须由内核态去操作，因为所有进程的 3-4G 的高位地址使用的都是同一块、专门留给 系统内核 使用的 1G 物理内存
  3. 所有对 硬件资源、系统内核数据 的访问都必须由 内核态 去执行
1.3.3 如何切换内核态
  • 通过软件中断
1.3.4 软件中断与硬件中断
  • 软件中断
    • 软件中断是由软件程序触发的中断，如系统调用、软中断、异常等。软件中断不是由硬件设备触发的，而是由软件程序主动发起的，一般用于系统调用、进程切换、异常处理等任务。软件中断需要在程序中进行调用，其响应速度和实时性相对较差，但是具有灵活性和可控性高的特点。
    • 如：程序中出现的内存溢出，数组下标越界等。
  • 硬件中断
    • 硬件中断是由硬件设备触发的中断，如时钟中断、串口接收中断、外部中断等。当硬件设备有数据或事件需要处理时，会向CPU发送一个中断请求，CPU在收到中断请求后，会立即暂停当前正在执行的任务，进入中断处理程序中处理中断请求。硬件中断具有实时性强、可靠性高、处理速度快等特点。
    • 如：当点击按钮扫描系统高低电频时等。

1.4 系统调用与库函数的关系

  • 库函数可以调用系统调用提供的接口，也可以不调用系统调用提供的接口
  • 如：
    • 不调用系统调用的库函数：strcpy、bzero等
    • 调用系统调用的库函数：fread、printf等

在这里插入图片描述

1.5 注意

系统调用是需要时间的，程序中频繁的使用系统调用会降低程序的运行效率。当运行内核代码时，CPU 工作在内核态，在系统调用发生前需要保存用户态的栈和内存环境，然后转入内核态工作。系统调用结束后，又要切换回用户态。这种环境的切换会消耗掉许多时间。

2. 文件操作

2.1 文件描述符概念

文件描述符是一个非负整数，代表已打开的文件。

每一个进程都会创建一张文件描述符表 记录的是当前进程打开的所有文件描述符。

每一个进程默认打开三个文件描述符：

  • 0(标准输入设备scanf)
  • 1(标准输出设备printf)
  • 2(标准错误输入设备perror)。

新打开的文件描述符 为 最小可用文件描述符，一般以3开始。

在这里插入图片描述

位图表示：

在这里插入图片描述

2.1.1 ulimit 临时修改资源限制

ulimit是一个计算机命令，用于shell启动进程所占用的资源，可用于修改系统资源限制。使用ulimit命令用于 临时 修改资源限制，如果需要永久修改需要将设置写入配置文件/etc/security/limits.conf。

ulimit -a 查看open files打开的文件最大数。
ulimit -n 最大数 设置open files打开的文件最大数。

在这里插入图片描述
在这里插入图片描述

2.2 文件读写

2.2.1 文件磁盘权限

在这里插入图片描述

解释:
    第一位说是文件还是文件夹
    2~4位说明所有者权限
    5~7位说明同组用户权限
    8~10位说明其他用户权限

r	4
w	2
x	1

注意：

man 2 系统调用
在终端下 查看系统调用函数对应的头文件与函数信息
2.2.2 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：代码操作文件的权限
    • 必选项
      • O_RDONLY 以只读的方式打开
      • O_WRONLY 以只写的方式打开
      • O_RDWR 以可读、可写的方式打开
    • **可选项 **
      • O_CREAT 文件不存在则创建文件，使用此选项时需使用 mode 说明文件的权限
      • O_EXCL 如果同时指定了 O_CREAT，且文件已经存在，则打开，如果文件不存在则新建
      • O_TRUNC 如果文件存在，则清空文件内容
      • O_APPEND 写文件时，数据添加到文件末尾
      • O_NONBLOCK 对于设备文件，以 O_NONBLOCK 方式打开可以做 非阻塞
  • mode：文件在磁盘中的权限
    • 格式：
      • 0ddd
      • d的取值：4(可读)，2(可写)，1(可执行)
      • 第一个d：所有者权限
      • 第二个d：同组用户权限
      • 第三个d：其他用户权限
      • 如果需要可读可写就是6，可读可执行5等
    • 如:
      0666：所有者可读可写，同组用户可读可写，其他用户可读可写
      0765：所有者可读可写可执行，同组用户可读可写，其他用户可读可执行

返回值：

成功：得到最小可用的文件描述符

失败：-1

建议:

操作已有文件使用两参

新建文件使用三参

2.2.3 close 关闭文件
//所需头文件
	#include <unistd.h>

//函数
	int close(int fd);

参数:

  • 关闭的文件描述符
  • 返回值
    • 成功：0
    • 失败： -1，并设置 errno

示例：以写的方式打开关闭文件

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    //文件不存在则创建文件
    int fd = open("test.txt", O_WRONLY|O_CREAT|O_APPEND, 0765);
    printf("fd=%d\n", fd);
    if(fd < 0)
    {
        printf("文件打开失败\n");
        return 0;
    }
    int x = close(fd);
    printf("x=%d\n", x);
    if(x < 0)
    {
        printf("文件关闭失败\n");
        return 0;
    }
    return 0;
}

// fd=3
// x=0
2.2.4 write写入
//所需头文件
	#include <unistd.h>
//函数
	ssize_t write(int fd, const void *buf, size_t count);

参数：

  • fd：写入的文件描述符
  • buf：写入的内容首地址
  • count：写入的长度,单位字节

返回值

  • 成功：返回 写入的内容的长度，单位字节
  • 失败：-1

示例：

#include <stdio.h>
#include <sys/types.h>      //open
#include <sys/stat.h>       //open
#include <fcntl.h>          //open
#include <unistd.h>         //close
int main(int argc, char const *argv[])
{
    int fd = open("test.txt", O_WRONLY | O_APPEND);
    if(fd < 0)
    {
        printf("文件打开失败\n");
        return 0;
    }
    char buf[] = "hello";
    //-1是为了去除字符串自带的\0
    int len = write(fd, buf, sizeof(buf) - 1);
    if(len < 0)
    {
        printf("写入失败\n");
    }
    if(close(fd) < 0)
    {
        printf("关闭失败\n");
    }
}
2.2.5 read读取
//所需头
	#include <unistd.h>

//函数
	ssize_t read(int fd, void *buf, size_t count);

参数：

  • fd：文件描述符
  • buf：内存首地址
  • count：读取的字节个数

返回值：

  • 成功：实际 读取到的字节个数
  • 失败：-1

示例：

#include <stdio.h>
#include <sys/types.h>      //open
#include <sys/stat.h>       //open
#include <fcntl.h>          //open
#include <unistd.h>         //close
int main(int argc, char const *argv[])
{
    int fd = open("test.txt",O_RDONLY);
    char buf[100] = "";
    int len = read(fd,buf,100);
    printf("len = %d\n",len);
    //buf的第len位赋值'\0',buf在此处结束
    buf[len] = '\0';
    printf("buf = %s\n",buf);
    close(fd);
    return 0;
}

// len = 5
// buf = hello

2.3 练习：文件的复制

#include <stdio.h>
#include <sys/types.h>      //open
#include <sys/stat.h>       //open
#include <fcntl.h>          //open
#include <unistd.h>         //close
int main(int argc, char const *argv[])
{
    //1、打开文件2个文件,一个读的文件,一个写入的文件
    int fd_r = open("test.txt", O_RDONLY);
    if(fd_r < 0)
    {
        printf("读文件打开失败");
        return 0;
    }
    int fd_w = open("info.txt", O_WRONLY | O_CREAT | O_APPEND, 0765);
    if(fd_w < 0)
    {
        printf("写文件打开失败");
        return 0;
    }
    //2、读取读文件中的内容(循环读取)
    while(1)
    {
        //大文件，一般一次读取的大小为1024
        char buf[10] = "";
        //len : 实际读取到的字节数
        int len = read(fd_r, buf, sizeof(buf));
        //3,将读取到的内容,写入到写文件中
        write(fd_w, buf, len);
        if(len < sizeof(buf))
        {
            break;
        }
    }
    return 0;
}

2.4 文件的阻塞特性

read默认为阻塞。如果读不到数据，将阻塞不继续执行 知道有数据可读，才继续往下执行。
非阻塞特性：如果没数据，立即返回，继续执行。
注意:阻塞与非阻塞是对于文件而言的，而不是指 read、write 等的属性。

示例：

#include <stdio.h>
#include <sys/types.h>      //open
#include <sys/stat.h>       //open
#include <fcntl.h>          //open
#include <unistd.h>         //close
int main(int argc, char const *argv[])
{
    // /dev/tty,当前终端对应的设备文件
    //O_NONBLOCK:设置打开的文件为非阻塞
    int fd = open("/dev/tty",O_RDONLY | O_NONBLOCK);
    char buf[10] = "";
    printf("请输入:\n");
    int len = read(fd,buf,10);
    close(fd);
    printf("buf = %s\n",buf);
    return 0;
}

结果：

在这里插入图片描述

通过open打开的文件可以设置非阻塞，但是如果不是通过open打开的文件怎么办?

通过fcntl函数来解决

2.4.1 fcntl 设置阻塞状态(已存在文件)

作用：针对已经存在的文件描述符设置阻塞状态

//所需头文件
    #include <unistd.h>
    #include <fcntl.h>

//函数:
	int fcntl(int fd, int cmd, ... /* arg */);

功能:

  • 改变已打开的文件性质，fcntl 针对描述符提供控制。

参数：

  • fd：操作的文件描述符
  • cmd：操作方式
  • arg：针对 cmd 的值，fcntl 能够接受第三个参数 int arg。

返回值：

  • 成功：返回某个其他值
  • 失败：-1

fcntl 函数有 5 种功能：

    1. 复制一个现有的描述符（cmd=F_DUPFD）
    1. 获得／设置文件描述符标记(cmd=F_GETFD 或 F_SETFD)
    1. 获得／设置文件状态标记(cmd=F_GETFL 或 F_SETFL)
    1. 获得／设置异步 I/O 所有权(cmd=F_GETOWN 或 F_SETOWN)
    1. 获得／设置记录锁(cmd=FGETLK, F_SETLK 或 F_SETLKW)

使用步骤：

  • 获取文件状态标记
  • 将得到的文件状态标记设置为非阻塞
  • 将修改后的文件非阻塞状态标记,设置到当前文件描述符中

示例：

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main(int argc, char const *argv[])
{ 
    //1,获取文件标记状态
    int status = fcntl(0,F_GETFL);
    //2修改状态为非阻塞状态
    status = status | O_NONBLOCK;
    //3,设置文件标记状态为非阻塞状态
    fcntl(0,F_SETFL,status);
    char buf[32]="";
    printf("开始读取\n");
    //0(标准输入设备scanf)
    int len = read(0,buf,sizeof(buf));
    printf("结束读取,读取到的内容为:%s\n",buf);
    return 0;
}

2.5 文件状态

作用：获取文件状态信息

//所需头
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <unistd.h>

//函数
    int stat(const char *path, struct stat *buf);
    int lstat(const char *pathname, struct stat *buf);

参数：

  • 1参：文件地址
  • 2参：保存文件信息的结构体

返回值

  • 0：成功
  • -1：失败
2.5.1 stat与lstat的区别

当文件是一个符号链接时：

  • lstat 返回的是该符号链接本身的信息；
  • stat 返回的是该链接指向的文件的信息。
2.5.2 stat结构体解释
struct stat {
    dev_t st_dev; //文件的设备编号
    ino_t st_ino; //节点
    mode_t st_mode; //文件的类型和存取的权限
    nlink_t st_nlink; //连到该文件的硬连接数目,刚建立的文件值为 1
    uid_t st_uid; //用户 ID
    gid_t st_gid; //组 ID
    dev_t st_rdev; //(设备类型)若此文件为设备文件，则为其设备编号
    off_t st_size; //文件字节数(文件大小)
    blksize_t st_blksize; //块大小(文件系统的 I/O 缓冲区大小)
    blkcnt_t st_blocks; //块数
    time_t st_atime; //最后一次访问时间
    time_t st_mtime; //最后一次修改时间
    time_t st_ctime; //最后一次改变时间(指属性)
};

stat结构体st_mode属性:

一个由16个字节组成,简称16位
0~2其他人权限
3~5所属组权限
6~8所有者权限
12~15文件类型
具体参考下图

在这里插入图片描述

存储权限

S_ISUID 04000 set-user-ID bit
S_ISGID 02000 set-group-ID bit (see below)
S_ISVTX 01000 sticky bit (see below)

S_IRWXU 00700 owner has read, write, and execute permission
S_IRUSR 00400 owner has read permission
S_IWUSR 00200 owner has write permission
S_IXUSR 00100 owner has execute permission

S_IRWXG 00070 group has read, write, and execute permission
S_IRGRP 00040 group has read permission
S_IWGRP 00020 group has write permission
S_IXGRP 00010 group has execute permission

S_IRWXO 00007 others (not in group) have read, write, and execute permission
S_IROTH 00004 others have read permission
S_IWOTH 00002 others have write permission
S_IXOTH 00001 others have execute permission

示例：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    struct stat buf;
    int tag = stat("test.txt",&buf);
    if (tag < 0)
    {
        printf("读取失败\n");
        return 0;
    }

    //说明当前文件为普通文件
    if (S_ISREG(buf.st_mode))
    {
        printf("test.txt是文件\n");
    }
    else if(S_ISDIR(buf.st_mode))
    {
        printf("test.txt是目录\n");
    }   
    
    printf("当前文件的大小为:%d\n",buf.st_size);
    return 0;
}

// test.txt是文件
// 当前文件的大小为:5

3. 目录操作

3.1 打开目录 opendir

作用：打开目录

//所有头文件:
    #include <sys/types.h>
    #include <dirent.h>

//函数:
	DIR *opendir(const char *name);

参数：

  • name：目录名

返回值：

  • 成功：返回指向该目录结构体指针(DIR *)
  • 失败：NULL
  • DIR：中文名称句柄，其实就是目录的结构体指针

3.2 读取目录 readdir

作用：读取目录

//所需头文件
	#include <dirent.h>

//函数
	struct dirent *readdir(DIR *dirp);

参数：

  • dirp：opendir 的返回值

返回值：

  • 成功：目录结构体指针
  • 失败：NULL

注意：一次读取一个文件。

相关结构体：

struct dirent
{
    ino_t d_ino; // 此目录进入点的 inode
    off_t d_off; // 目录文件开头至此目录进入点的位移
    signed short int d_reclen; // d_name 的长度, 不包含 NULL 字符
    unsigned char d_type; // d_type 所指的文件类型
    char d_name[256]; // 文件名
};

d_type说明：

  • DT_BLK这是一个块设备。(块设备如:磁盘)
  • DT_CHR这是一个字符设备。(字符设备如:键盘,打印机)
  • DT_DIR这是一个目录。
  • DT_FIFO这是一个命名管道（FIFO）。
  • DT_LNK这是一个符号链接。
  • DT_REG这是一个常规文件。
  • DT_SOCK这是一个UNIX域套接字。
  • DT_UNKNOWN文件类型未知。

3.3 关闭目录 closedir

作用：关闭目录

//所需头文件
    #include <sys/types.h>
    #include <dirent.h>

//函数
	int closedir(DIR *dirp);

参数：

  • dirp：opendir 返回的指针

返回值：

  • 成功：0
  • 失败：-1

3.4 示例1

打印制定目录下的文件名

#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    DIR *dir = opendir("/home/zhb/iot2302_3/02_file");
    if(dir == NULL)
    {
        printf("打开目录失败");
        return 0;
    }
    while(1)
    {
        struct dirent *p;
        p = readdir(dir);
        if(p == NULL)
        {
            break;
        }
        //.和.. 排除
        if(strcmp(p->d_name, ".") == 0 || strcmp(p->d_name, "..") == 0)
        {
            continue;;
        }
        printf("%s\n", p->d_name);
    }
    return 0;
}

// info.txt
// 07_code.c
// 01_code.c
// 05_code.c
// 06_code.c
// 00_code.c
// 03_code.c
// test.txt
// a.out

3.5 示例2 递归打印文件夹、文件名

#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include <string.h>

void traversalDir(char *path)
{
    char filepath[256] = "";
    strcpy(filepath, path);
    DIR *dir = opendir(filepath);
    if(dir == NULL)
    {
        printf("打开目录失败\n");
        return;
    }
    while (1)
    {
        struct dirent *p;
        p = readdir(dir);
        if(p == NULL)
        {
            break;
        }
        if(p->d_type == DT_DIR && strcmp(p->d_name, ".") != 0 && strcmp(p->d_name, "..") != 0)
        {
            //拼接目录下的目录递归遍历
            char newpath[256] = "";
            strcpy(newpath, filepath);
            strcat(newpath, "/");
            strcat(newpath, p->d_name);
            printf("%s\n", newpath);
            traversalDir(newpath);
        }
        if (p->d_type == DT_REG)
        {
            printf("%s/%s\n", filepath, p->d_name);
        }
    }
    closedir(dir);
}

int main(int argc, char const *argv[])
{
    traversalDir("/home/zhb/iot2302_3");
    return 0;
}
小玖工作坊
关注
  • 24
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值