Linux指令（更新中）

Linux指令

文件操作

1.创建文件

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

/*
#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 文件不存在创建文件
        -mode：八进制的数，表示创建出的新文件的操作权限，比如：0775
        最终的权限是：mode & ~umask
        0777 -> 111111111   
    &
        0775 -> 111111101
    -----------------------------------------
                111111101
    按位与：0和任何数都为0
    umask抹去某些权限
    flags参数是一个int类型数据，占4个字节 32位
    flag 32个位 每一个位都是一个标志位。
*/
#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("open");
    }
    //关闭
    close(fd);
    return 0;
}

2.打开已存在文件

int open(const char &pathname,int flags);

/*
        #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
        errono：属于linux系统函数库，库里面的一个全局变量 记录的是最近的错误号。
        
        #include <stdio.h>
        void perror(const char *s); 作用：打印error对应的错误描述
            s参数：用户描述，比如hello，最终输出的内容是hello：xxx（实际的错误描述）

        #include <errno.h>

        //创建一个新的文件
        int open(const char &pathname,int flags,mode_t mode);

       
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<unistd.h>
#include<stdio.h>
int main(){
    int fd = open("a.txt", O_RDONLY);
    if(fd == -1){
        perror("open");
    }
    //读写操作
    
    //关闭
    close(fd);
    return 0;
}

3.复制文件

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

/*
    #include<unistd.h>
    ssize_t read(int fd,void *buf,size_t count);
        参数：
            -fd：文件描述符 ，open得到的，通过这个文件描述符操作某个文件
            -buf：需要读取数据存放的地方，数组的地址
            -count：指定的数组的大小
        返回值：
            -成功：
                >0:返回实际读取到的字节数
                =0：文件已经读取完成
            -失败：-1 ，并且设置perror
    #include<unistd.h>
    ssize_t write(int fd,void *buf,size_t count);
        参数：
            -fd:文件描述符，open得到的，通过这个文件描述符操作某个文件
            -buf：要往磁盘写入的数据，数据
            -count：要写的数据的实际大小
        返回值：
            -成功：
                >0:返回实际读取到的字节数
                -失败：-1 ，并且设置perror
*/
#include<unistd.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
int main(){
    //通过open打开english.txt
    int srcfd = open("english.txt", O_RDONLY);
    if(srcfd == -1){
        perror("open");
        return -1;
    }
    //创建一个新的文件（拷贝文件）
    int destfd = open("cpy.txt", O_WRONLY | O_CREAT, 0664);
    if(destfd == -1){
        perror("open");
        return -1;
    }
    //频繁的读写操作
    char buf[1024] = {0};
    int len = 0;
    while ((len = read(srcfd, buf, sizeof(buf)))>0){
        write(destfd, buf, len);
    }
    //关闭文件
    close(destfd);
    close(srcfd);
    return 0;
}

4.lseek

/*
    标准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.移动文件指针到文件头
        lseek(fd,0,SEEK_SET);
        
        2.获取当前文件指针的位置
        lseek(fd,0,SEEK_CUR);

        3.获取文件长度
        lseek(fd,0,SEEK_END);

        4.扩展文件的长度，当前文件10b，110b，增加了100b
        lseek(fd,100,SEEK_END);从文件末尾向后偏移100

        注意：需要写入一次数据
        
*/
#include <sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include <unistd.h>
#include<stdio.h>
int main(){
    int fd = open("hello.txt", O_RDWR);
    if(fd == -1){
        perror("open");
        return -1;
    }
    //扩展文件的长度
    int ret = lseek(fd, 100, SEEK_END);
    if(ret == -1){
        perror("lseek");
        return -1;
    }
    //写入一个空数据
    write(fd, " ", 1);
    close(fd);
    return 0;
}

5.获取文件信息

int stat(const char *pathname, struct stat *statbuf);

/*
       #include <sys/types.h>
       #include <sys/stat.h>
       #include <unistd.h>

       int stat(const char *pathname, struct stat *statbuf);
            作用：获取一个文件信息
            参数：
                -pathname：操作的文件的路径
                -statbuf：结构体变量，传出参数，用于保存获取到的信息
            返回值：
                成功：返回0
                失败：返回-1，设置errno

       int lstat(const char *pathname, struct stat *statbuf);
            参数：
                -pathname：操作的文件的路径
                -statbuf：结构体变量，传出参数，用于保存获取到的信息
            返回值：
                成功：返回0
                失败：返回-1，设置errno        

*/
#include<sys/types.h>
#include<stdio.h>
#include<sys/stat.h>
#include<unistd.h>
int main(){
    struct stat statbuf;
    int ret = stat("a.txt", &statbuf);
    if(ret == -1){
        perror("stat");
        return -1;
    }
    printf("size: %ld\n", statbuf.st_size);
    return 0;
}

6.判断某个文件是否有某个权限，或者某个文件是否存在

int access(const char * pathname,int mode);

/*
       #include <unistd.h>

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


#include<unistd.h>
#include<stdio.h>
int main(){
    int ret = access("a.txt", F_OK);
    if(ret == -1){
        perror("access");
        return -1;
    }
    printf("文件存在!!\n");
    return 0;
}

7.修改文件的权限

int chmod(const char *pathname,mode_t mode);

/*
       #include <sys/stat.h>

       int chmod(const char *pathname, mode_t mode);
        作用：修改文件的权限
        参数：
            -pathname 需要修改的文件的路径
            -mode:需要修改的权限值，八进制的数
        返回值：成功返回0 失败返回-1

*/
#include<unistd.h>
#include<sys/stat.h>
#include<stdio.h>
int main(){
    int ret = chmod("a.txt", 0777);
    if(ret == -1){
        perror("chmod");
        return -1;
    }
    return 0;
}

8.缩减或扩展文件到指定的大小

int truncate(const char *path,off_t length);

/*
SYNOPSIS
       #include <unistd.h>
       #include <sys/types.h>

       int truncate(const char *path, off_t length);
            作用：缩减或扩展文件的尺寸至指定的大小
            参数：
                -path：需要修改的文件的路径
                -length：需要最终文件变成的大小
            返回值:成功返回0 失败返回-1
*/
#include <unistd.h>
#include <sys/types.h>
#include<stdio.h>
int main(){
    int ret = truncate("b.txt", 5);
    if(ret == -1){
        perror("truncate");
        return -1;
    }
    return 0;
}

9.创建一个目录

int mkdir(const char* pathname,mode_t mode);

/*
       #include <sys/stat.h>
       #include <sys/types.h>

       int mkdir(const char *pathname, mode_t mode);
        作用：创建一个目录
        参数：  
            pathname：创建的目录的路径
            mode：权限 8进制的数
        返回值：
            成功返回0 失败返回-1
*/ 

#include <sys/stat.h>
#include <sys/types.h>
#include<stdio.h>
int main(){
    int ret = mkdir("aaa", 0777);
    if(ret == -1){
        perror("mkdir");
        return -1;
    }
    return 0;
}

10.修改目录名称

int rename(const char *oldpath,const char *newpath);

/*
       #include <stdio.h>

       int rename(const char *oldpath, const char *newpath);

*/
#include <stdio.h>
int main(){
    int ret = rename("aaa", "bbb");
    if(ret == -1){
        perror("rename");
        return -1;
    }
    return 0;
}

11.修改进程的工作目录

int chdir(const char *path);

/*
       #include <unistd.h>

       int chdir(const char *path);
            作用：修改进程的工作目录
                比如在/home/yxy目录下启动了一个可执行程序a.out,进程的工作目录/home/yxy
            参数：
                path：需要修改的工作目录

       #include <unistd.h>

       char *getcwd(char *buf, size_t size);
       作用：获取当前的工作目录
       参数：
            -buf：存储的路径，指向的是一个数组，传出参数
            -size：数组的大小

        返回值：
            返回的指向的一块内存，这个数据就是第一个参数


*/


#include <unistd.h>
#include<stdio.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>
int main(){
    //获取当前的工作目录
    char buf[128];
    getcwd(buf, sizeof(buf));
    printf("当前的工作目录是:%s\n",buf);

    //修改工作目录

    int ret = chdir("/home/yxy/Linux/lesson13");
    if(ret == -1){
        perror("chdir");
        return -1;
    }

    //创建一个新的文件
    int fd = open("chdir.txt", O_CREAT | O_RDWR, 0664);
    if(fd == -1){
        perror("open");
        return -1;
    }
    close(fd);

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

    return 0;
}

2.内存映射的注意事项

1.如果对mmap的返回值(ptr)做++操作，munmap是否能成功

void * ptr = mmap(….);
ptr++;可以进行++操作
munmap(ptr,len); //错误，要保存地址 new delete

2.如果open时O_RDONLY,mmap时prot参数指定PROT_READ | PROT_WRITE 会怎样？

错误，返回MAP_FAILED;
open()函数中的权限建议和PROT参数的权限保持一致

3.如果文件偏移量1000 会怎样？
偏移量必须是4k的整数倍，错误，返回MAP_FAILED

4.mmap什么情况下会调用失败？
-第二个参数 length = 0
-第三个参数 prot
-只指定了写权限
- prot PROT_READ | PROT_WRITE
第五个参数通过open函数时指定的O_RDONLY /O_WRONLY

5.可以open的时候O_CREAT 一个新文件来创建映射区吗？
-可以的，但是创建的文件的大小如果为0的话，肯定不行
-可以对新的文件进行扩展
-lseek()
-truncate()

6.mmap后关闭文件描述符，对mmap映射有没有影响？
int fd = open(“xxx”);
mmap(,,,fd,,);
close(fd);
映射区还在，创建映射区的fd被关闭了没有任何影响

7.对ptr越界操作会怎么样？
void * ptr = mmap(NULL,100,,,,);
4K
越界操作操作的是非法的内存，—>产生段错误

阻塞信号集和未决信号集

1.用户通过键盘 crtl + c产生2号信号SIGINT(信号被创建）
2.信号产生但是没有被处理（未决）
在内核中将所有的没有被处理的信号存储在一个集合中(未决信号集)
SIGINT信号状态被存储在第二个标志位上
这个标志位的值为0，说明信号不是未决状态
这个标志位的值为1，说明信号处于未决状态
3.这个未决状态的信号需要被处理，处理之前需要和另一个信号集(阻塞信号集)，进行一个比较。
-阻塞信号集默认不阻塞任何的信号
-如果先要阻塞某些信号，需要用户调用系统的API

4.在处理的时候和阻塞信号集中的标志位进行查询，看是不是对该信号设置阻塞。
-如果没有阻塞，这个信号就被处理。
-如果阻塞了，这个信号就继续处于未决状态，直到阻塞接触，这个信号被处理。