博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
Linux基础 文件和目录
阅读量：5930 次
发布时间：2019-06-19

本文共 12447 字，大约阅读时间需要 41 分钟。

文件和目录

前言

本章讨论文件属性和文件系统内容。除了上一章讨论的普通文件，Linux的文件概念还包括：目录、设备等。在Linux系统中，文件的种类包括：普通文件、目录、符号链接、块设备、字符设备、管道、套接字。

本章讨论的主要内容为普通文件、目录和符号链接。它们的公共特点是，真实的保存在了硬盘中，而其它类型的文件是内核产生的文件，在硬盘中并不存在。

文件属性

通过stat函数或者stat命令可以获得文件属性。

文件属性 解释
dev_t st_dev 设备号
ino_t st_ino inode编号
mode_t st_mode 访问权限相关
nlink_t st_nlink 硬链接数量
uid_t st_uid 拥有该文件的用户
gid_t st_gid 拥有该文件的组
dev_t st_rdev 设备号
off_t st_size 文件尺寸
blksize_t st_blksize 文件系统的IO尺寸
blkcnt_t st_blocks 占用的block数量，一个block为512字节
time_t st_atime 最后访问时间
time_t st_mtime 最后修改时间
time_t st_ctime 最后文件状态修改时间 
#include 
     
      #include 
      
       #include 
       
        #include 
        
          #include 
         
                 #include 
          
            #include 
           
            int main(){ struct stat buf; int ret = stat(".", &buf); if(ret < 0) { perror("stat"); return 0; } if(S_ISREG(buf.st_mode)) { printf("this is regular file\n"); } else if(S_ISDIR(buf.st_mode)) { printf("this is dir\n"); } // 测试拥有该文件的账户是否有读权限 if(S_IRUSR & buf.st_mode) { printf("user can read\n"); } open("a.txt", O_CREAT|O_RDWR, 0777); // access("./a.out", R_OK|W_OK|X_OK); printf("file size is %d\n", (int)buf.st_size); getchar(); return 0;}

 

3.3 文件类型

在前言中，提到文件类型包括七种，在stat结构题中，保存了文件的文件类型属性，它的文件类型属性保存在st_mode中。但是七种类型，只需要3位即可，而st_mode是一个整数，因此它还保存其它内容，如果需要判断一个文件属于何种类型，需要一些宏的帮助。

int main()
{
  struct stat buf;
  stat("a.txt", &stat);
  if(S_ISREG(buf.st_mode))
  {
    printf("%s\n", "这是普通文件");
  }
}

文件类型属性是只读的属性，无法修改。

3.4 用户和组

Linux是一个多用户操作系统，因此每个文件都有属性，记录着这个文件属于哪个用户/组。

用户/组信息可以被修改，可以通过chown来修改文件所属的用户和组信息。
修改文件所属用户和组，需要root权限。
新文件所属用户和组，是创建该文件的进程所属用户和组。

  • 实际账户和有效账户

账户 解释
实际账户 登陆系统时的账户
有效账户 决定进程的访问资源的账户

3.5 文件访问权限

文件使用了9个位来表示访问权限，和文件类型一起，保存在st_mode中。此9位分成3组，每组3个位，分别表示读/写/执行权限，而三个组分别表示拥有该文件的账户，拥有该文件的组，其它用户组的权限。如果对应位是1，表示有权限，如果是0表示没有权限。

文件访问权限经常用8进制来表示，比如上表的权限位可以表示为0755，意思是拥有它的账户对这个文件有读/写/执行权限，而拥有它的组有读/执行权限，其它账户对它有读/执行权限。

       Linux提供一些宏，来测试文件的权限位

            

  • 可以通过access函数来测试程序是否有访问某文件的权限。

  • 创建文件时，可以指定文件的访问权限位，但是会收到umask位影响。

  • 可以通过chmod来修改文件的权限位

3.6 其它权限位

3.6.1 SUID

只能对文件设置，如果文件设置了该位，那么该文件被运行时，对应的进程的权限，不是运行该程序账户的权限，而是拥有该用户的权限。

在对文件未设置SUID的情况下：

如果对文件设置了SUID，那么：

可以通过chmod u+s或者chmod u-s来设置获取去除SUID。

设置SUID可以让一个普通账户拥有它不该有的权限，容易产生安全漏洞。

3.6.2 SGID

可以对文件和目录设置，如果对文件设置，那么它的作用类似SUID，不过影响的是组。

如果对目录设置，那么拷贝到该目录下的文件都会被置位，除非拷贝是带-p参数。 在Ubuntu下测试并不如此。

在Ubuntu下设置了目录的SGID之后，在那个目录下创建的文件，拥有者是有效账户，而拥有组是该目录的拥有组。

命令：

chmod g+s
chmod g-s

3.6.3 StickyBit

可以对文件或者目录设置，如果对文件设置，那么当这个文件运行并退出后，系统依旧保留该文件对应的映象，这样这个程序再次运行时，就不需要加载再加载了。这个属性的作用并不大，因为它占用了内存。

如果对目录设置，那么表示在该目录下，账户只能删除和修改它自己创建的文件，对于其它账户创建的文件，它不能修改和删除。这个位作用比较大，在一些公共目录，往往有这个属性，比如/tmp

命令：

chmod o+t
chmod o-t

总结:

位 设置对象 设置方法 查看 效果
SUID 文件 chmod u+s 如果用户执行权限位为s或者S，则表示SUID有设置 当该文件被执行时，进程所拥有的权限是拥有该文件的账户权限
SUID 目录 不可设置    
SGID 文件 chmod g+s 如果组执行权限位为s或者S，则表示GUID有设置 当执行该文件时，进程所属组是该拥有该文件的组
SGID 目录 chmod g+s 同上 在该目录中创建文件时，该文件的所属组是目录的所属组
StickyBit 文件 chmod o+t 如果其他执行权限位为t或者T，那么该文件有设置StickyBit 执行该文件并退出后，系统保留该文件占用的一些内存，以便加快下一次的加载运行
StickyBit 目录 chmod o+t 同上 账户只能修改和删除该目录下属于该账户的文件，不能修改该目录下其他账户创建的文件

3.7 文件长度

st_size保存文件的长度，write函数会修改该属性，也可以通过truncate修改文件大小，truncate可以扩大文件或者缩小文件，缩小文件时，文件内容会被删减。

文件大小可以通过ls，wc -c，stat命令获取。

也可以通过fseek和ftell函数配合获取，或者直接通过stat函数获取文件长度。

3.8 文件系统

3.8.1 文件管理

文件系统描述文件在硬盘中的组织，保存在硬盘中的文件只有普通文件、目录、软链接。

为了更加方便的管理持久性文件存储，操作系统一般对硬盘进行有规划的管理，规划包括：

  • 分区

  • 格式化

文件系统指一个分区内，文件存储的组织方式。

在Linux下，通过mount命令将分区挂载到虚拟文件系统。

3.8.2 inode

一个硬盘分区，被格式化之后，可以认为硬盘被划分成两部分：管理数据和数据。管理数据部分保存着这个分区的分区信息，以及inode表。

inode保存文件的属性信息，stat命令能看到的信息，大部分都是保存在inode里的，一个inode占用128或者256字节，这个依赖具体的文件系统，每当在硬盘上创建一个文件/目录时，系统为这个文件/目录分配一个inode。值得注意的是，文件名，不存在inode中，而是存在文件所在目录的文件内容部分。

3.8.3 数据块

数据部分被简单的、按照等大尺寸的划分成n块，一般每块数据块的尺寸为1024-4096，由具体文件系统决定。

3.8.4 文件

当创建一个文件时，系统为该文件分配一个inode。如果往该文件写数据，那么系统为该文件分配数据块，inode会记录这个数据块位置，当一个数据块不够用时，系统会继续为它分配数据块。

3.8.5 目录

当创建一个目录时，系统为该目录分配一个inode，同时分配一个数据块，并且在该数据块中，记录文件.和..对应的inode。

如果在该目录下创建文件newfile，那么参考上一节内容，会为该文件创建inode，最后将newfile文件名和它的inode，作为一条记录，保存在目录的数据块中。

 

如果一个inode被别人引用，那么它的引用计数器会加1。

3.8.6 路径和寻址

Linux系统采用以/划分的路径字符串来寻址文件。

比如命令mkdir testdir，寻址和操作过程如下图：

思考：为什么mv命令很快，而cp命令很慢，rename如何实现的

补充：分区

查看磁盘信息

sudo fdisk -l

磁盘名字 sda sdb ..

分区名字 sda1 sda2 ...
分区

sudo fdisk /dev/sdb

n 创建新分区

p 输出分区信息
w 保存分区信息并退出

分区和挂载

sudo mkfs.ext4 /dev/sdb1
sudo mount /dev/sdb1 xxyy

挂载成功之后，对xxyy目录的读写，其实是在/dev/sdb1文件系统中。

开机自动挂载

通过mount挂载的目录是临时的。如果希望开酒就挂载，那么可以将挂载命令写入到/etc/profile。或者修改/etc/fstab文件，/etc/fstab描述了开机需要挂载的文件系统信息。

去除挂载

通过手动umount去除挂载。

3.8.7 硬链接和软链接

硬链接不占用inode，只占用目录项。

软链接占用inode。

创建链接命令ln，硬链接只将对应的inode在目录总增加一个名字，并且将inode的引用计数器+1。

为了可以跨文件系统和对目录进行链接，创建了软链接这种方式。ln -s

// file --> file2
int main()
{
    // get file2
    struct stat buf;
    stat("file", &buf);
 
    // get 链接文件file的信息
    struct stat buf2;
    lstat("file", &buf2);
 
    // 如果lstat的参数所指文件不是链接文件
    // 那么它的效果和stat一样
    struct stat buf3;
    lstat("file2", &buf3)
}
读取symlink内容使用readlink命令。
删除软链接不会删除软链接指向的文件。

思考：为什么硬链接不能跨文件系统，而且不能对目录进行硬链接

3.8.8 虚拟文件系统VFS

内存无法加载硬盘所有内容，因为一般内存比硬盘小，但是在Linux内核中，维护了一个虚拟文件系统，将硬盘的目录结构映射到内存中。这个映射一般只包含已经被打开的文件。

3.9 文件删除

使用unlink命令和函数可以删除一个文件。

如果此时文件已经打开，那么该文件也可以被unlink，但是删除操作不会立即执行，而会被保留到文件关闭时执行。

unlink 删除文件，如果是链接，就删除链接，如果不是链接就删除文件。
rmdir 只能删除空目录
rm 会判断参数类型，如果是文件那么调用unlink，如果是目录调用rmdir
如果要删除非空目录，要使用rm -r，-r选项先删除目录中的文件，再调用rmdir。
int rm(const char* path);
{
    // 怎么遍历目录
}

3.10 文件时间

对文件的访问，会导致文件时间发生变化。系统会自动记录用户对文件的操作的时间戳，以便将来可以查询文件修改时间。

如果需要故意修改，那么可以通过utime函数，修改文件的访问时间和修改时间。

touch命令也可以将文件的时间修改为当前时间。touch命令的副作用是，如果参数所指文件不存在，那么创建一个空文件。

当用户进行大规模拷贝时，cp操作会修改文件的访问时间，如果想提高效率，可以使用-p选项，避免文件属性的修改，同时加快速度。

  
#include 
      
              #include 
       
        int main(){    struct utimbuf buf;    buf.actime = 0;    buf.modtime = 0;    utime("a.out", &buf);}

 

利用utime来修改文件的访问时间和修改时间

#include "../h.h"
int main()
{
    struct utimbuf buf;
    buf.actime = 0;
    buf.modtime = 0;
    utime("testfile", &buf);
 
    struct timeval tv[2];
    tv[0].tv_sec = 100000;
    tv[0].tv_usec = 10000;
 
    tv[1].tv_sec = 100000;
    tv[1].tv_usec = 10000;
    utimes("testfile", tv);
}

3.11 目录操作

3.11.1 创建和删除目录

mkdir和rmdir

3.11.2 遍历目录

opendir，closedir，readdir，rewinddir，telldir，seekdir

遍历目录

#include "../h.h"
 
int rm(const char* path)
{
    // 判断path是个文件还是目录
    // 如果是文件，直接unlink然后返回
    struct stat stat_buf;
    int ret = stat(path, &stat_buf);
    if(ret < 0)
    {
        perror("stat");
        return -1;
    }
    if(!S_ISDIR(stat_buf.st_mode))
    {
        unlink(path);
        return 0;
    }
 
    // 如果path是目录，遍历目录中的所有目录项
    char buf[1024];
    DIR* dir = opendir(path);
    if(dir == NULL)
        return -1;
 
    struct dirent* entry = readdir(dir);
    while(entry)
    {
        // 通过entry得到文件信息
        sprintf(buf, "%s/%s", path, entry->d_name);
        if(entry->d_type == DT_REG || entry->d_type == DT_LNK)
        {
            unlink(buf);
        }
        if(entry->d_type == DT_DIR)
        {
            // 忽略.和..目录
            if(strcmp(entry->d_name, ".") == 0
                    ||strcmp( entry->d_name, "..") == 0)
            {
                entry = readdir(dir);
                continue;
            }
            rm(buf);
        }
        entry = readdir(dir);
    }
 
    closedir(dir);
    rmdir(path);
    return 0;
}
 
int main(int argc, char* argv[])
{
    if(argc == 1)
    {
        printf("usage: %s [pathname]\n", argv[0]);
        return 0;
    }
    rm(argv[1]);
    return 0;   
}

seekdir和telldir

 
#include "../h.h"
 
int main()
{
    long loc;
    DIR* dir = opendir("testdir");
 
    // no
    // seekdir(dir, 2);
    //
    struct dirent* entry;
    while(1)
    {
        loc = telldir(dir);
        entry = readdir(dir);
        if(entry == NULL) break;
 
        if(strcmp(entry->d_name, "a") == 0)
        {
            // 记录文件a的位置
            break;
        }
    }
 
    seekdir(dir, loc);
 
    while(1)
    {
        entry = readdir(dir);
        if(entry == NULL)
            break;
        printf("loc is %d, entry->d_name=%s\n", (int)telldir(dir), entry->d_name);
    }
 
    // 将文件指针回到a的位置
//    seekdir(dir, loc);
} 
#include 
      
       #include 
       
        #include 
        
         #include 
         
          int main(int argc, char* argv[]){    DIR* dir = opendir(argv[1]);    struct dirent* entry;    while(1)    {        entry = readdir(dir);        if(entry == NULL)            break;        // linux下，.开头是隐藏文件        if(entry->d_name[0] == '.')            continue;        printf("%s\n", entry->d_name);    }    closedir(dir);}

 

3.12 练习

3.12.1 实现文件拷贝，保留文件属性

#include "../h.h"
 
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        printf("usage: %s [srcfile] [dstfile]\n", argv[0]);
        return -1;
    }
 
    const char* filesrc = argv[1];
    const char* filedst = argv[2];
 
    FILE* fp_src = fopen(filesrc, "r");
    FILE* fp_dst = fopen(filedst, "w");
 
    char buf[4096];
    while(1)
    {
        int ret = fread(buf, 1, sizeof(buf), fp_src);
        if(ret <= 0)
            break;
        fwrite(buf, ret, 1, fp_dst);
    }
 
    fclose(fp_src);
    fclose(fp_dst);
 
 
    // 获取源文件属性
    struct stat src_stat;
    stat(filesrc, &src_stat);
 
    // 修改目标文件时间
    struct utimbuf timbuf;
    timbuf.actime = src_stat.st_atime;
    timbuf.modtime = src_stat.st_mtime;
    utime(filedst, &timbuf);
 
    // 修改权限
    chmod(filedst, src_stat.st_mode);
 
    // 修改所有者
    int ret = chown(filedst, src_stat.st_uid, src_stat.st_gid);
    if(ret < 0)
    {
        perror("chown");
    }
 
    return 0;
}

3.12.2 实现目录打包到文件，将文件解包成目录

 
#include "../h.h"
 
#include <map>
#include <string>
using namespace std;
 
map<ino_t, std::string> savedfiles;
 
void tarfile(const char* filename, FILE* fpOut)
{
    struct stat stat_buf;
    stat(filename, &stat_buf);
 
    // 检查这个文件是否已经保存过，是否是其他文件的硬链接
    std::string filesaved = savedfiles[stat_buf.st_ino];
    if(filesaved.size() != 0)
    {
        // 此ino之前已经存过了
        fprintf(fpOut, "h\n%s\n%s\n", filename, filesaved.c_str());
        return;
    }
 
    fprintf(fpOut, "f\n%s\n%lld\n", filename, (long long int)stat_buf.st_size);
 
    FILE* fpIn = fopen(filename, "r");
    char buf[4096];
    while(1)
    {
        int ret = fread(buf, 1, sizeof(buf), fpIn);
        if(ret <= 0)
            break;
        fwrite(buf, ret, 1, fpOut);
    }
    fclose(fpIn);
 //   savedfiles.insert(std::pair<ino_t, std::string>(stat_buf.st_ino, std::string(filename)));
    // 如果该文件不是别人的硬链接，那么将文件拷贝之后，在全局map中记录ino
    savedfiles[stat_buf.st_ino] = std::string(filename);
}
 
int tardir(const char* dirname, FILE* fpOut)
{
    char filepath[1024];
 
    // 写目录
    fprintf(fpOut, "d\n");
    fprintf(fpOut, "%s\n", dirname);
 
    DIR* dir = opendir(dirname);
    struct dirent* entry = readdir(dir);
    while(entry)
    {
        sprintf(filepath, "%s/%s", dirname, entry->d_name);
        // handle
        if(entry->d_type == DT_REG)
        {
            // write file
            tarfile(filepath, fpOut);
        }
        else if(entry->d_type == DT_DIR)
        {
            if(strcmp(entry->d_name, ".") == 0 ||
                    strcmp(entry->d_name, "..") == 0)
            {
                entry = readdir(dir);
                continue;
            }
 
            tardir(filepath, fpOut);
        }
        entry = readdir(dir);
    }
 
    closedir(dir);
}
 
int tar(const char* dirname, const char* outfile)
{
    FILE* fpOut = fopen(outfile, "w");
 
    fprintf(fpOut, "xgltar\n");
    fprintf(fpOut, "1.0\n");
 
    int ret = tardir(dirname, fpOut);
 
    fclose(fpOut);
    return ret;
}
 
 
#define line_buf_size 1024
char line_buf[line_buf_size];
#define get_line() fgets(buf, line_buf_size, fin)
 
int untar1(FILE* fin)
{
    char* buf = line_buf;
    if(get_line() == NULL)
        return -1;
 
    printf("now utar type=%s", buf);
 
    if(strcmp(buf, "d\n") == 0)
    {
        get_line();
        buf[strlen(buf)-1] = 0;
        mkdir(buf, 0777);
        printf("mkdir %s\n", buf);
    }
    else if(strcmp(buf, "f\n") == 0)
    {
        get_line();
        buf[strlen(buf)-1] = 0; // filename
        FILE* out = fopen(buf, "w");
        printf("create file %s\n", buf);
 
        get_line();
        long long int len = atoll(buf); // 1987\n
        printf("filelen %s\n", buf);
 
        while(len > 0)
        {
            // 避免粘包问题
            int readlen = len < line_buf_size ? len : line_buf_size;
            int ret = fread(buf, 1, readlen, fin);
            fwrite(buf, 1, ret, out);
            len -= ret;
        }
 
        fclose(out);
    }
    else if(strcmp(buf, "h\n") == 0)
    {
        get_line();
        buf[strlen(buf)-1] = 0; // filename new
        std::string new_path(buf);
 
        get_line();
        buf[strlen(buf)-1] = 0; // hardline filename old
 
        link(buf, new_path.c_str());
    }
 
    return 0;
}
 
int untar(const char* tarfile)
{
    char* buf = line_buf;
 
    FILE* fin = fopen(tarfile, "r");
    //fgets(buf, line_buf_size, fin);
    get_line();
    if(strcmp(buf, "xgltar\n") != 0)
    {
        printf("unknown file format\n");
        return -1;
    }
 
    get_line();
    if(strcmp(buf, "1.0\n") == 0)
    {
        while(1)
        {
            int ret = untar1(fin);
            if(ret != 0)
                break;
        }
 
    }
    else
    {
        printf("unknown version\n");
        return -1;
    }
    return 0;
}
 
 
// ./mytar -c dir tarfile.xgl
// ./mytar -u tarfile.xgl
int main(int argc, char* argv[])
{
    if(argc == 1)
    {
        printf("usage: \n\t%s -c [dir] [tarfile]\n\t%s -u [tarfile]\n", argv[0], argv[0]);
        return -1;
    }    
 
    const char* option = argv[1];
    if(strcmp(option, "-c") == 0)
    {
        const char* dirname = argv[2];
        const char* outfile = argv[3];
        return tar(dirname, outfile);
    }
    else if(strcmp(option, "-u") == 0)
    {
        const char* tarfile = argv[2];
        return untar(tarfile);
    }
 
    printf("option error\n");
    return -1;
}

3.13 函数和命令

3.13.1 函数

stat/lstat：查看文件属性

chmod：修改文件权限
chown：修改文件的所有者
utime：修改文件时间
unlink：删除文件
link：创建硬链接
symlink：创建软链接
rmdir：删除空目录
mkdir：创建空目录
opendir：打开目录
closedir：关闭目录
readdir：读取一个目录项，并且将目录项指针移到下一项
seekdir：修改目录项指针
rewainddir：重置目录项指针
telldir：获得当前目录向指针
判断权限位宏 S_IRUSR(stat.st_mode)
判断文件类型宏S_ISDIR(stat.st_mode)

3.13.2 命令

stat：查看文件属性

chmod：修改文件权限
chown
unlink：删除文件（不会跟随）
ln：创建链接
mkdir
rmdir
rm
cp
dd：拷贝数据（可以拷贝文件，也拷贝块设备）
wc：计算文件内容的行数、单词数、字节数
which：查找非内置的命令位置
fdisk：查看磁盘信息、分区
mkfs：在分区中创建文件系统（ext2,ext3,ext4, fat32, ntfs, xfs,nfs)
mount：挂载
umount：取消挂载

转载于:https://www.cnblogs.com/w-x-me/p/Linux.html

你可能感兴趣的文章
js/jquery/插件表单验证
查看>>
Bandwidth内存带宽測试工具
查看>>
为Node.js编写组件的几种方式
查看>>
(轉貼) Anders Hejlsberg談C#、Java和C++中的泛型 (.NET) (C#)
查看>>
30天敏捷结果（24）：恢复你的精力
查看>>
JNI——访问数组
查看>>
C#开发和调用Web Service
查看>>
Android6.0机型上调用系统相机拍照返回的resultCode值始终等于0的问题
查看>>
全面理解Git
查看>>
JS敏感信息泄露：不容忽视的WEB漏洞
查看>>
让我们荡起双桨，Android 小船波浪动画
查看>>
ApacheCN 翻译活动进度公告 2019.2.18
查看>>
分布式memcached服务器代理magent安装配置（CentOS6.6）
查看>>
Create Volume 操作（Part III） - 每天5分钟玩转 OpenStack（52）
查看>>
物联网的广泛应用将扭转发展中经济体的局面 为全球发展带来新机遇
查看>>
Polar码引发舆论狂欢 5G标准远未定局
查看>>
IntersectionObserver + Custom Elements 实现图片懒加载(滚动加载)/点击重试
查看>>
KSImageNamed-Xcode-master
查看>>
memcache
查看>>
Struts2参数知识点
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-12-28 09:31:16   当前IP: 3.145.37.211   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我