Linux IO

本文最后更新于：2021年3月7日 晚上

概览：Linux IO

errno与输出

errno：属于Linux系统函数库，库里面的一个全局变量，记录的是最近的错误号。

可以通过函数perror(const char* s)来打印对应的错误描述。

1
2
3
4
#include <stdio.h>
void perror(const char *s);//作用：打印errno对应的错误描述

//s参数：用户描述，比如hello,最终输出的内容是  hello:xxx(实际的错误描述)

open函数1

1
2
3
4
5
6
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

// 打开一个已经存在的文件
int open(const char *pathname, int flags);

参数：

  • pathname：要打开的文件路径
  • flags：对文件的操作权限设置还有其他的设置
    • O_RDONLY, O_WRONLY, O_RDWR 这三个设置是互斥的
  • 返回值：返回一个新的文件描述符，如果调用失败，返回-1
  • 详细的可通过 man 2 open查看。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>	//close函数需要使用

int main(){

    //打开文件
    int fd = open("a.txt",O_RDONLY);

    if(fd == -1){	//若没有打开
        perror("open a.txt");
    }

    //关闭
    close(fd);

    return 0;
}

open函数2

1
2
3
4
5
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags, mode_t mode);

参数：

  • pathname：要创建的文件的路径
  • flags：对文件的操作权限和其他的设置
    • 必选项：O_RDONLY, O_WRONLY, O_RDWR 这三个之间是互斥的
    • 可选项：O_CREAT 文件不存在，创建新文件，
    • 可选项：O_APPEND，追加文件内容
    • 可选项：O_TRUNC，文件截断
    • 可选项：O_NONBLOCK，设置非阻塞。
  • mode：八进制的数，表示创建出的新的文件的操作权限，比如：0775
    • 最终的权限是：mode & ~umask
    • umask的作用就是抹去某些权限，一般情况下是0002，可直接在终端输入umask查看，也有相关函数可修改其值，可通过man来查看。
    • 例如 0777 & ~(0002) = 0775。这样文件的权限775，则文件的权限为rwxrwxr-x。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

int main(){

    //创建一个新文件
    int fd = open("create.txt", O_RDWR | O_CREAT, 0777);

    if(fd == -1){
        perror("create file");
    }

    //关闭文件描述符
    close(fd);

    return 0;
}

read、write函数

1
2
3
#include <unistd.h>

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

​ 参数：

  • fd：文件描述符，open得到的，通过这个文件描述符操作某个文件

  • buf：需要读取数据存放的地方，数组的地址（传出参数）

  • count：指定的数组的大小

  • 返回值：

    • 成功:
      • >0: 返回实际的读取到的字节数
      • =0：文件已经读取完了
    • 失败：-1 ，并且设置errno
1
2
3
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
  • 参数：
    • fd：文件描述符，open得到的，通过这个文件描述符操作某个文件
    • buf：要往磁盘写入的数据，数据
    • count：要写的数据的实际的大小
  • 返回值：
    • 成功：实际写入的字节数
    • 失败：返回-1，并设置errno

拷贝文件案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main(){

    //通过open获得文件描述符
    int srcfd = open("english.txt",O_RDONLY);
    if(srcfd == -1){
        perror("open 1");
        return -1;
    }

    int destfd = open("copy.txt",O_WRONLY|O_CREAT,0777);
    if(destfd == -1){
        perror("open 2");
        return -1;
    }

    //读取文件，然后写入文件
    char buffer[1024] = {0};//缓存
    int len = 0;            //读取的长度

    while((len = read(srcfd,buffer,sizeof(buffer))) > 0){
        write(destfd,buffer,len);
    }

    //关闭文件
    close(destfd);
    close(srcfd);

    return 0;
}

lseek函数

1
2
3
4
5
6
7
8
//标准C库的函数
#include <stdio.h>
int fseek(FILE *stream, long offset, int whence);

//Linux系统函数
#include <sys/types.h>
#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);

参数：

  • fd：文件描述符，通过open得到的，通过这个fd操作某个文件

  • offset：偏移量

  • whence:

    • SEEK_SET 设置文件指针的偏移量
    • SEEK_CUR 设置偏移量：当前位置 + 第二个参数offset的值
    • SEEK_END 设置偏移量：文件大小 + 第二个参数offset的值

  • 返回值：返回文件指针的位置

作用：
1.移动文件指针到文件头

1
lseek(fd, 0, SEEK_SET);

2.获取当前文件指针的位置

1
off_t off = lseek(fd, 0, SEEK_CUR);

3.获取文件长度

1
off_t len = lseek(fd, 0, SEEK_END);

4.拓展文件的长度，当前文件10b, 110b, 增加了100个字节

1
2
lseek(fd, 100, SEEK_END)
//注意：需要写一次数据

应用举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main(){

    int fd = open("file.txt",O_RDWR);
    if(fd ==-1){
        perror("open");
        return -1;
    }

    //获取文件长度
    off_t lens = lseek(fd,0,SEEK_END);

    printf("file.txt length: %ld \n",lens);

    //扩展文件
    lseek(fd,100,SEEK_END);

    //一定要写一次数据，否则无法成功。
    write(fd," ",1);

    //关闭文件
    close(fd);

    return 0;
}

stat、lstat函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

int stat(const char *pathname, struct stat *statbuf);
//作用：获取一个文件相关的一些信息

int lstat(const char *pathname, struct stat *statbuf);
//获取一个软链接的信息

struct stat {
    dev_t st_dev; // 文件的设备编号
    ino_t st_ino; // 节点
    mode_t st_mode; // 文件的类型和存取的权限
    nlink_t st_nlink; // 连到该文件的硬连接数目
    uid_t st_uid; // 用户ID
    gid_t st_gid; // 组ID
    dev_t st_rdev; // 设备文件的设备编号
    off_t st_size; // 文件字节数(文件大小)
    blksize_t st_blksize; // 块大小
    blkcnt_t st_blocks; // 块数
    time_t st_atime; // 最后一次访问时间
    time_t st_mtime; // 最后一次修改时间
    time_t st_ctime; // 最后一次改变时间(指属性)
};

参数：

  • pathname：操作的文件的路径
  • statbuf：结构体变量，传出参数，用于保存获取到的文件的信息
  • 返回值：
    • 成功：返回0
    • 失败：返回-1 设置errno

stat查看文件信息也可以通过在终端中使用stat来查看。

1
2
3
4
5
6
7
8
9
colourso@c:~/桌面/ch1linux/09io$ stat file.txt
  文件：file.txt
  大小：111       	块：8          IO 块：4096   普通文件
设备：801h/2049d	Inode：807444      硬链接：1
权限：(0664/-rw-rw-r--)  Uid：( 1000/colourso)   Gid：( 1000/colourso)
最近访问：2021-03-05 15:40:28.434659770 +0800
最近更改：2021-03-05 15:45:56.297896243 +0800
最近改动：2021-03-05 15:45:56.297896243 +0800
创建时间：-

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>

int main(){

    struct stat statbuf;

    int ret = stat("file.txt",&statbuf);

    if(ret == -1){
        perror("stat");
        return -1;
    }

    printf("file.txt size: %ld\n",statbuf.st_size);
    return 0;
}

案例：模仿ls -l命令查看文件信息

  • st_mode变量：文件的类型和存取的权限.
  • 下图中的数字均为8进制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <time.h>
#include <string.h>

// 模拟实现 ls -l 指令
int main(int argc, char * argv[]) {

    // 判断输入的参数是否正确
    if(argc < 2) {
        printf("%s filename\n", argv[0]);//提示使用方式
        return -1;
    }

    // 通过stat函数获取用户传入的文件的信息
    struct stat st;
    int ret = stat(argv[1], &st);
    if(ret == -1) {
        perror("stat");
        return -1;
    }

    // 获取文件类型和文件权限
    char perms[11] = {0};   // 用于保存文件类型和文件权限的字符串

    switch(st.st_mode & S_IFMT) {
        case S_IFLNK:
            perms[0] = 'l';
            break;
        case S_IFDIR:
            perms[0] = 'd';
            break;
        case S_IFREG:
            perms[0] = '-';
            break; 
        case S_IFBLK:
            perms[0] = 'b';
            break; 
        case S_IFCHR:
            perms[0] = 'c';
            break; 
        case S_IFSOCK:
            perms[0] = 's';
            break;
        case S_IFIFO:
            perms[0] = 'p';
            break;
        default:
            perms[0] = '?';
            break;
    }

    // 判断文件的访问权限

    // 文件所有者
    perms[1] = (st.st_mode & S_IRUSR) ? 'r' : '-';
    perms[2] = (st.st_mode & S_IWUSR) ? 'w' : '-';
    perms[3] = (st.st_mode & S_IXUSR) ? 'x' : '-';

    // 文件所在组
    perms[4] = (st.st_mode & S_IRGRP) ? 'r' : '-';
    perms[5] = (st.st_mode & S_IWGRP) ? 'w' : '-';
    perms[6] = (st.st_mode & S_IXGRP) ? 'x' : '-';

    // 其他人
    perms[7] = (st.st_mode & S_IROTH) ? 'r' : '-';
    perms[8] = (st.st_mode & S_IWOTH) ? 'w' : '-';
    perms[9] = (st.st_mode & S_IXOTH) ? 'x' : '-';

    // 硬连接数
    int linkNum = st.st_nlink;

    // 文件所有者
    char * fileUser = getpwuid(st.st_uid)->pw_name;//头文件#include <pwd.h>

    // 文件所在组
    char * fileGrp = getgrgid(st.st_gid)->gr_name;//头文件#include <grp.h>

    // 文件大小
    long int fileSize = st.st_size;

    // 获取修改的时间
    char * time = ctime(&st.st_mtime);//将秒数转为表示时间的字符串

    char mtime[512] = {0};
    strncpy(mtime, time, strlen(time) - 1);//去除换行符

    char buf[1024];
    sprintf(buf, "%s %d %s %s %ld %s %s", perms, linkNum, fileUser, fileGrp, fileSize, mtime, argv[1]);

    printf("%s\n", buf);

    return 0;
}

使用：

1
2
3
4
5
6
7
colourso@c:~/桌面/ch1linux/09io$ gcc -o myls ls-l.c 
colourso@c:~/桌面/ch1linux/09io$ ./myls
./myls filename
colourso@c:~/桌面/ch1linux/09io$ ./myls file.txt
-rw-rw-r-- 1 colourso colourso 111 Fri Mar  5 15:45:56 2021 file.txt
colourso@c:~/桌面/ch1linux/09io$ ls -l file.txt 
-rw-rw-r-- 1 colourso colourso 111 3月   5 15:45 file.txt

文件属性操作函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <unistd.h>
int access(const char *pathname, int mode);

/*
作用：判断某个文件是否有某个权限，或者判断文件是否存在
    参数：
    - pathname: 判断的文件路径
    - mode:
            R_OK: 判断是否有读权限
            W_OK: 判断是否有写权限
            X_OK: 判断是否有执行权限
            F_OK: 判断文件是否存在
    返回值：成功返回0， 失败返回-1
*/

#include <sys/stat.h>
int chmod(const char *pathname, mode_t mode);

/*
修改文件的权限
    参数：
    - pathname: 需要修改的文件的路径
    - mode:需要修改的权限值，八进制的数
    返回值：成功返回0，失败返回-1
*/

#include <unistd.h>
#include <sys/types.h>
int truncate(const char *path, off_t length);

/*
作用：缩减或者扩展文件的尺寸至指定的大小
    参数：
    - path: 需要修改的文件的路径
    - length: 需要最终文件变成的大小
    返回值：
    成功返回0， 失败返回-1
*/

案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>

int main(){

    //查看文件是否存在
    int ret = access("a.txt",F_OK);
    if(ret == -1){
        perror("access");
        return -1;
    }

    printf("a.txt is exit!\n");

    //修改文件权限
    ret = chmod("a.txt",0777);
    if(ret == -1){
        perror("chmod");
        return -1;
    }

    printf("chmod success\n");

    //查看文件原有大小
    struct stat st;

    ret = stat("a.txt",&st);

    if(ret == -1){
        perror("stat1");
        return -1;
    }

    printf("a.txt size is %ld\n",st.st_size);
    
    //扩展文件尺寸
    ret = truncate("a.txt",20);

    if(ret == -1){
        perror("truncate");
        return -1;
    }

    //再次获取文件大小
    ret = stat("a.txt",&st);

    if(ret == -1){
        perror("stat2");
        return -1;
    }

    printf("a.txt size is %ld\n",st.st_size);

    return 0;
}

除此之外：

  • /etc/passwd下存储了许多的用户名、uid所在组等信息
  • /etc/group下存储了许多的组、gid等信息

目录操作函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <sys/stat.h>
#include <sys/types.h>
int mkdir(const char *pathname, mode_t mode);

/*
    作用：创建一个目录，注意目录没有x权限是不能进入的
    参数：
        pathname: 创建的目录的路径
        mode: 权限，八进制的数
    返回值：
        成功返回0， 失败返回-1
*/   

#include <sys/stat.h>
#include <sys/types.h>
int rmdir(const char *pathname);//只能删除空目录，作用很小

#include <stdio.h>
int rename(const char *oldpath, const char *newpath);//修改名称
/*
返回值：
        成功返回0， 失败返回-1
*/

#include <unistd.h>
int chdir(const char *path);

/*
    作用：修改进程的工作目录
        比如在/home/nowcoder 启动了一个可执行程序a.out, 进程的工作目录 /home/nowcoder
    参数：
        path : 需要修改的工作目录
    返回值：
        成功返回0， 失败返回-1
*/

#include <unistd.h>
char *getcwd(char *buf, size_t size);

/*
    作用：获取当前工作目录
    参数：
        - buf : 存储的路径，指向的是一个数组（传出参数）
        - size: 数组的大小
    返回值：
        返回的指向的一块内存，这个数据就是第一个参数
        
*/

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main(){

    //获取当前的工作目录
    char buf[128];
    getcwd(buf,sizeof(buf));
    printf("now work path: %s\n",buf);


    //修改当前进程所在工作目录
    int ret = chdir("/home/colourso/桌面/ch1linux/09io");

    if(ret == -1){
        perror("chdir");
        return -1;
    }

    //获取当前的工作目录
    char buf1[128];
    getcwd(buf1,sizeof(buf1));
    printf("now work path: %s\n",buf1);

    //创建一个目录
    ret = mkdir("dir1",0777);
    if(ret == -1){
        perror("mkdir");
        return -1;
    }

    printf("dir1 create success\n");

    //修改目录名
    ret = rename("dir1","dir2");

    if(ret == -1){
        perror("rename");
        return -1;
    }

    printf("dir1 rename dir2\n");

    return 0;
}

目录遍历函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 打开一个目录
#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name);
/*
    参数：
        - name: 需要打开的目录的名称
    返回值：
        DIR * 类型，理解为目录流
        错误返回NULL
    man 3 ...
*/

// 读取目录中的数据
#include <dirent.h>
struct dirent *readdir(DIR *dirp);

/*
    - 参数：dirp是opendir返回的结果
    - 返回值：
        struct dirent，代表读取到的文件的信息
        读取到了末尾或者失败了，返回NULL
*/

// 关闭目录
#include <sys/types.h>
#include <dirent.h>
int closedir(DIR *dirp);

struct dirent结构体：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
struct dirent
{
    // 此目录进入点的inode
    ino_t d_ino; 
    // 目录文件开头至此目录进入点的位移
    off_t d_off; 
    // d_name 的长度, 不包含NULL字符
    unsigned short int d_reclen; 
    // d_name 所指的文件类型
    unsigned char d_type; 
    // 文件名
    char d_name[256];
};

d_type
DT_BLK - 块设备
DT_CHR - 字符设备
DT_DIR - 目录
DT_LNK - 软连接
DT_FIFO - 管道
DT_REG - 普通文件
DT_SOCK - 套接字
DT_UNKNOWN - 未知

案例：读取某个目录下所有普通文件个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <sys/types.h>
#include <dirent.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int getFileNum(const char* path){


    //1.打开目录
    DIR* dir = opendir(path);

    if(dir == NULL){
        perror("opendir");
        exit(0);
    }

    //2.记录普通文件个数
    int total = 0;

    struct dirent *dirp = NULL;

    while((dirp = readdir(dir)) != NULL){
        
        //获取目录名称
        if(dirp->d_type == DT_DIR){
            char * dirname = dirp->d_name;

            //排除 . 与 ..两个目录
            if(strcmp(dirname,".") == 0 || strcpy(dirname,"..") == 0){
                continue;
            }

            //递归其他目录
            //拼接目录名
            char pathname[256];
            sprintf(pathname,"%s/%s",path,dirname);
            total += getFileNum(pathname);
        }

        //文件总数相加
        if(dirp->d_type == DT_REG){
            total++;
        }

    }

    //3.关闭目录
    closedir(dir);

    return total;
}

int main(int argc,char * argv[]){

    if(argc <2){
        printf("%s path\n",argv[0]);
        exit(0);
    }

    int num = getFileNum(argv[1]);

    printf("普通文件个数为%d\n",num);

    return 0;
}

dup、dup2函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <unistd.h>
int dup(int oldfd);
/*
    作用：复制一个新的文件描述符
    fd=3, int fd1 = dup(fd),
    fd指向的是a.txt, fd1也是指向a.txt
    从空闲的文件描述符表中找一个最小的，作为新的拷贝的文件描述符
*/

#include <unistd.h>
int dup2(int oldfd, int newfd);
/*
    作用：重定向文件描述符
    oldfd 指向 a.txt, newfd 指向 b.txt
    调用函数成功后：newfd 和 b.txt 做close, newfd 指向了 a.txt
    oldfd 必须是一个有效的文件描述符
    oldfd和newfd值相同，相当于什么都没有做
*/

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(){

    //dup(oldfd) 返回一个新的文件描述符
    int fd = open("a.txt",O_RDWR);

    if(fd == -1){
        perror("open");
        return -1;
    }

    int newfd = dup(fd);
    if(newfd == -1){
        perror("dup");
        return -1;
    }

    printf("fd: %d,newfd: %d\n",fd,newfd);//3,4

    //关闭fd，尝试向a.txt写入数据
    close(fd);

    char* buf = "hello world!";
    write(newfd,buf,strlen(buf));

    //关闭newfd
    close(newfd);

    //dup2(oldfd,newfd) 重定向
    int fd1 = open("1.txt",O_RDWR|O_CREAT,0664);
    int fd2 = open("2.txt",O_RDWR|O_CREAT,0664);

    if(fd1 == -1 || fd2 == -1){
        perror("open2");
        return -1;
    }

    printf("fd1: %d,fd2: %d\n",fd1,fd2);

    int fd3 = dup2(fd1,fd2);//重定向 fd2 --> fd1的文件
    if(fd3 == -1){
        perror("dup2");
        return -1;
    }

    printf("fd1: %d,fd2: %d,fd3: %d\n",fd1,fd2,fd3);

    //使用 fd2来操作文件
    char *buffer1 = "hello world -- by fd1";
    char *buffer2 = "hello world -- by fd2";

    write(fd1,buffer1,strlen(buffer1));
    write(fd2,buffer2,strlen(buffer2));

    //关闭
    close(fd1);
    close(fd3);

    return 0;
}

执行结果：

1
2
3
4
fd: 3,newfd: 4
fd1: 3,fd2: 4
fd1: 3,fd2: 4,fd3: 4
//实际上 内容均写入到了1.txt之中

fctnl函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ...);
/*
参数：
    fd : 表示需要操作的文件描述符
    cmd: 表示对文件描述符进行如何操作
        - F_DUPFD : 复制文件描述符,复制的是第一个参数fd，得到一个新的文件描述符（返回值）
            int ret = fcntl(fd, F_DUPFD);

        - F_GETFL : 获取指定的文件描述符文件状态flag
            获取的flag和我们通过open函数传递的flag是一个东西。

        - F_SETFL : 设置文件描述符文件状态flag
            必选项：O_RDONLY, O_WRONLY, O_RDWR 不可以被修改
            可选性：O_APPEND, O)NONBLOCK
            O_APPEND 表示追加数据
            NONBLOK 设置成非阻塞
    
    阻塞和非阻塞：描述的是函数调用的行为。
*/

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main(){

    //使用fctnl修改文件的权限
    //这里的文件权限指的是 open函数中的权限，且 O_RDONLY O_WRONLY O_RDWR必须还存在

    int fd = open("a.txt",O_RDWR);
    if(fd == -1){
        perror("open");
        return -1;
    }

    //先获取文件的权限
    int flag = fcntl(fd,F_GETFL);
    if(flag == -1){
        perror("fctnl");
        return -1;
    }

    //然后追加文件权限 O_APPEND，原来的三大权限都需要保留
    flag = flag | O_APPEND;

    //设置文件权限
    int ret = fcntl(fd,F_SETFL,flag);

    if(ret == -1){
        perror("fctnl2");
        return -1;
    }

    //向文件以追加的方式写入数据
    char * buf = "\n你好世界";

    ret = write(fd,buf,strlen(buf));
    if(ret == -1){
        perror("write");
        return -1;
    }

    //关闭文件
    close(fd);

    return 0;
}

标准库IO与Linux IO

一般情况下推荐使用标准库的io，在多平台容易同统一，并且标准IO库还有缓冲区的使用，效率比普通的系统IO高。

虚拟地址空间

上述是虚拟的32位的linux的虚拟空间。具体的细节可参看CSAPP。

linux每一个运行的程序：即进程。操作系统都会为其分配一个0-4G的地址空间，即虚拟地址空间。

文件描述符

Linux
Linux C/C++

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！