精华内容
下载资源
问答
  • df 显示的已使用磁盘占用率比du 统计出来的结果要大很多。...一、实验情况1、创建并删除文件创建文件前的磁盘容量情况:引用# df -h文件系统容量已用 可用 已用% 挂载点/dev/sda112G5.7G5.5G51% /tmpfs 506M 0...

    df 显示的已使用磁盘占用率比du 统计出来的结果要大很多。原因,主要是由于两者计算结果的方式不同。

    一、实验情况

    1、创建并删除文件

    创建文件前的磁盘容量情况:

    引用

    # df -h

    文件系统              容量  已用 可用 已用% 挂载点

    /dev/sda1              12G  5.7G  5.5G  51% /

    tmpfs                 506M     0  506M   0% /dev/shm

    创建文件:

    引用

    # dd if=/dev/zero of=test.iso bs=1024k count=1000

    1000+0 records in

    1000+0 records out

    1048576000 bytes (1.0 GB) copied, 14.3055 seconds, 73.3 MB/s

    现在的磁盘情况:

    引用

    # df -h

    文件系统              容量  已用 可用 已用% 挂载点

    /dev/sda1              12G  6.7G  4.6G  60% /

    tmpfs                 506M     0  506M   0% /dev/shm

    模拟某个进程正在使用该文件:

    # tail -f /tmp/test.iso

    2、删除该文件

    打开另一个终端,登陆到系统中。

    查看是否有进程正在使用上面创建的文件:

    引用

    # lsof |grep test.iso

    tail      2175      root    3r      REG        8,1 1048576000     752972 /tmp/test.iso

    把该文件删掉,并确认:

    引用

    # rm /tmp/test.iso

    rm:是否删除 一般文件 “/tmp/test.iso”? y

    # ls /tmp/test.iso

    ls: /tmp/test.iso: 没有那个文件或目录

    查看是否还有进程在使用(注意结尾的标记):

    引用

    # lsof |grep test.iso

    tail      2175      root    3r      REG        8,1 1048576000     752972 /tmp/test.iso (deleted)

    查看磁盘使用情况:

    引用

    # df -h

    文件系统              容量  已用 可用 已用% 挂载点

    /dev/sda1              12G  6.7G  4.6G  60% /

    tmpfs                 506M     0  506M   0% /dev/shm

    # cat /proc/diskstats |grep sda1

    8    1 sda1 54385 5184 1626626 130090 20434 635997 5251448 5345733 0 111685 5475829

    可见,虽然从ls 已经无法找到该文件,但因为tail 进程仍在使用该文件,故实际上内核并没有把这文件所占用的空间释放出来(df 的结果)。

    3、停止相关进程

    回到第一终端,用Ctrl+C 终止tail 进程,查看结果:

    引用

    # df -h

    文件系统              容量  已用 可用 已用% 挂载点

    /dev/sda1              12G  5.7G  5.5G  51% /

    tmpfs                 506M     0  506M   0% /dev/shm

    # cat /proc/diskstats |grep sda1

    8    1 sda1 54473 5184 1627402 130617 20453 636042 5251960 5345756 0 112226 5476379

    至此,文件所占用的空间已完全释放。

    二、说明

    从上面的实验,可得出一些情况:

    引用

    1、若有进程在占用某个文件,而其他进程把这文件删掉,只会删除其在磁盘中的标记,而不会释放其占用的磁盘空间;直到所有访问该文件的进程退出为止;

    2、df 是从内核中获取磁盘占用情况数据的,而du是统计当前磁盘文件大小的结果,由于磁盘标记已被删掉,因此du 不会计算上述被删除文件的空间,导致df 与 du的结果不一致。

    三、解决问题

    通常的解决方法有两个:

    1、把占用文件的相关进程关闭

    这可通过下面的命令得到这些已被删除,但未释放空间的文件和进程信息:

    # lsof |grep deleted

    找到这些进程后,在安全的情况下把其关闭,空间自会马上释放。

    2、以清空的方式替代删除

    归根到底,产生问题的原因是,访问该文件的文件指针(句柄),在rm 动作后,因为进程仍在访问,因此,仍处在文件里面(中间或结尾处)。所以,如果用清空的方式,把文件指针重置,该文件所占用的空间也会马上释放出来。

    引用

    # echo > /tmp/test.iso

    # df -h

    文件系统              容量  已用 可用 已用% 挂载点

    /dev/sda1              12G  5.7G  5.5G  51% /

    tmpfs                 506M     0  506M   0% /dev/shm

    # tail -f /tmp/test.iso

    tail: /tmp/test.iso: file truncated

    所以,对于常发生类似问题的文件,如:日志记录文件等。以改名、清空、删除的顺序操作可避免问题。

    四、补充

    除rm外,有些不明显的操作,也会产生类似的问题。

    例如 gzip 命令,其对某个文件xxx.log进行压缩时,会产生一个新的xxx.log.gz文件,完成后,会把原来的xxx.log删除。

    这时,若仍有进程在使用xxx.log文件,那么,实际上,该文件还是只会标记为deleted,其空间也不会释放,问题与上面提到的情况是相同的。所以,在编写脚本时,可先判断是否仍有进程正在使用该文件,然后再进行gzip 操作。

    五 文件空洞

    文件读写时,如果先文件指针偏移很大一段,然后写入1byte;这样这个文件实际占用1byte空间,但是stat查看文件大小,或者读写时,都会发现文件很大;所有没有写内容的都返回0,且不占用空间,这样的文件叫'sparse file',即文件空洞

    容易发生在一个进程在写一个文件,这是人工进行清空文件操作,就会产生。

    展开全文
  • 1.稀疏文件文件系统提供的一种用时分配空间的机制,适合某些特殊的使用场景,比如vm disk image 2.不适合下载场景,下载需要预先抢占空间,用的是fallocate系列接口 3.某些场景需要预先申请一块大空间,然后用自己...

    rachelcrc写在最前面:

    下面是转载别人的,但里面有一些我认为不太对的地方:

    其实文章里写的对迅雷下载这部分是不太对的,转载的文章我没修改,在评论补充一下:
    1.稀疏文件是文件系统提供的一种用时分配空间的机制,适合某些特殊的使用场景,比如vm disk image
    2.不适合下载场景,下载需要预先抢占空间,用的是fallocate系列接口
    3.某些场景需要预先申请一块大空间,然后用自己的元数据管理,实际上大多数情况下只会用很小一部分,这就是稀疏文件的使用场景
    4.下载是实打实的要用那么多,不适合用稀疏文件,要不然下载过程中有没空间的风险

    ==============================================================================================

    from:http://www.topjishu.com/8277.html

    From:http://blog.csdn.net/clamercoder/article/details/38361815

    1、Linux文件空洞与稀疏文件

    2、文件系统数据存储

    3、文件系统调试

     

    文件空洞

    1. 在UNIX文件操作中,文件位移量可以大于文件的当前长度
      在这种情况下,对该文件的下一次写将延长该文件,并在文件中构成一个空洞。位于文件中但没有写过的字节
      都被设为 0。
    2. 如果 offset 比文件的当前长度更大,下一个写操作就会把文件“撑大(extend)”
      在文件里创造“空洞(hole)”。
      没有被实际写入文件的所有字节由重复的 0 表示。空洞是否占用硬盘空间是由文件系统(file system)决定

     

    20140913144536_1

     

    稀疏文件(Sparse File)

    1. 稀疏文件与其他普通文件基本相同,区别在于文件中的部分数据是全0,且这部分数据不占用磁盘
      空间。
      下面是稀疏文件的创建与查看
    [root@localhost ~]# dd if=/dev/zeroof=sparse-file bs=1 count=1 seek=1024k
    [root@localhost ~]# ls -l sparse-file
    -rw-r--r-- 1 root root 1048577 Oct 15 17:50 sparse-file
    [root@localhost ~]# du -sh sparse-file
    8.0K sparse-file
    [root@localhost ~]# cat anaconda-ks.cfg >> sparse-file
    [root@localhost ~]# du -sh sparse-file
    12K sparse-file
    [root@localhost ~]# du -sh anaconda-ks.cfg
    12K anaconda-ks.cfg
    [root@localhost ~]#

    Linux文件系统inode数据块存储

    索引节点采用了多重索引结构,主要体现在直接指针和3个间接指针。直接指针包含12个直接指
    针块,它们直接指向包含文件数据的数据块,紧接在后面的3个间接指针是为了适应文件的大小
    变化而设计。

    20140913144536_2

    Linux稀疏文件inode数据块存储

    文件系统存储稀疏文件时,inode索引节点中,只给出实际占用磁盘空间的Block 号,
    数据全零且不占用磁盘空间的文件Block并没有物理磁盘Block号。

    20140913144536_3

    Linux稀疏文件inode数据块存储

    • 文件空洞部分不占用磁盘空间
    • 文件所占用的磁盘空间仍然是连续的

    20140913144536_4

    实例:

    [root@localhost mnt]# du -sh sparse-file
    20K sparse-file
    [root@localhost mnt]# ls -lh sparse-file
    -rw-r--r-- 1 root root 1.1G Oct 15 10:36 sparse-file
    [root@localhost mnt]#
    debugfs: stat sparse-file
    Inode: 49153 Type: regular Mode: 0644 Flags:
    0x0 Generation: 3068382963
    User: 0 Group: 0 Size: 1073742848
    File ACL: 0 Directory ACL: 0
    Links: 1 Blockcount: 40
    Fragment: Address: 0 Number: 0 Size: 0
    ctime: 0x507b76af -- Mon Oct 15 10:36:31 2012
    atime: 0x507b765f -- Mon Oct 15 10:35:11 2012
    mtime: 0x507b76af -- Mon Oct 15 10:36:31 2012
    BLOCKS:
    (IND):106496, (256):106497, (DIND):106504,
    (IND):106505, (262144):106506
    TOTAL: 5

    Linux文件系统数据块存储多重索引

    • Linux文件系统数据存放采用inode多
      重索引结构,有直接指针和3个间接指
      针。
      类似于编程中的变量定义:
      unsigned long blk;
      unsigned long *blk;
      unsigned long **blk;
      unsigned long ***blk;
    • 直接指针直接指向保存数据的Block
      号。
    • 一级指针指向一个Block,该Block中
      的数据是Block指针,指向真正保存数
      据的Block。
      二级三级指针以此类推。

    20140913144536_5

    1. 前12个直接指针,直接指向存储的数据区域
      如Blocks大小为4096,则前12个直接指针就可以保存48KB文件。
    2. 一级指针可存储文件大小计算
      假设每个指针占用4个字节,则一级指针指向的Block可保存4096/4个
      指针,可指向1024个Blocks。一级指针可存储文件数据大小为1024*4096 =
      4MB。
    3. 二级指针可存储文件大小计算
      同样按照Blocks大小为4096,则二级指针可保存的Block指针数量为(4096/4) *
      (4096/4) = 1024*1024。则二级指针可保存的文件数量大小为(1024*1024)*4096
      = 4GB。
    4. 三级指针可存储文件大小计算
      以一级、二级指针计算方法类推,三级指针可存储的文件数据大小为
      (1024*1024*1024)*4096 = 4TB。

    20140913144536_6

     

     

     

     

    1.什么是空洞文件?

    “在UNIX文件操作中,文件位移量可以大于文件的当前长度,在这种情况下,对该文件的下一次写将延长该文件,并在文件中构成一个空洞,这一点是允许的。位于文件中但没有写过的字节都被设为 0。”      --摘自“百度百科”

    从上面的描述可以将空洞文件的特点表述为:offset > 实际文件大小。那这又有什么表现和意义呢?我们下面慢慢分析。

     

    http://blog.csdn.net/shenlanzifa/article/details/44016537 )

     

    文件空洞

    我们知道lseek()系统调用可以改变文件的偏移量,但如果程序调用使得文件偏移量跨越了文件结尾,然后再执行I/O操作,将会发生什么情况? read()调用将会返回0,表示文件结尾。令人惊讶的是,write()函数可以在文件结尾后的任意位置写入数据。在这种情况下,对该文件的下一次写将延长该文件,并在文件中构成一个空洞,这一点是允许的。从原来的文件结尾到新写入数据间的这段空间被成为文件空洞。调用write后文件结尾的位置已经发生变化。

     

    在Linux系统之中,文件结束符EOF根本不是一个字符,而是当系统读取到文件结尾,所返回的一个信号值(也就是-1),至于系统怎么知道文件的结尾,资料上说是通过比较文件的长度。

     

    文件空洞占用任何磁盘空间,直到后续某个时点,在文件空洞中写入了数据,文件系统才会为之分配磁盘块。空洞的存在意味着一个文件名义上的大小可能要比其占用的磁盘存储总量要大(有时大出许多)。向文件空洞中写入字节,内核需要为其分配存储单元,即使文件大小不变,系统的可用磁盘空间也将减少。这种情况并不常见,但也需要了解。

     

    下面看一个例子:(转自http://blog.csdn.net/wangxiaoqin00007/article/details/6617801)

    ls -l file        查看文件逻辑大小 ( 即文件的实际大小 )

    du -c file     查看文件实际占用的存储块多少 (即文件实际占用的磁盘空间大小)

    od -c file     查看文件存储的内容 (od命令:http://blog.csdn.net/freeking101/article/details/78182731

     

     

    空洞文件就是有空洞的文件,在日常的常识中,我们使用的文件存放在硬盘分区上的时候,有多大的内容就会占用多大的空间,比如这个文本文件里面写有1000个asc字符,那么就会占用磁盘上1000B的存储空间,为了便于管理文件,文件系统都是按块大小来分配给文件的,假如这个文件系统一个块是4096的话,那么这个文件就会占用一个块的,无论实际的内容是1B还是4000B.如果我们有一个4MB的文件,那么它会在分区中占用:4MB/4096B=1000个块.

    现在我们先做一个实际的无空洞文件来看看:

    #dd if=/dev/urandom of=testfile1 bs=4096 count=1000

    这个命令会从/dev/urandom文件复制1000个块,每块大小4096,到testfile1文件去.

    好了,我们已经有了testfile1这么一个4M的文件了,里面填充了一些随机的内容,你可以more一下.

    然后用ls -l查看这个文件的大小是4096000,用du -h testfile1来查看的话,文件占用的磁盘大小是4M,两者是一样的.

     

    下来是我们的重点,空洞文件,假如我们有一个文件,它有4M的大小,但是它里边很大一部分都是没有存放数据的,这样可不可以呢?试一下:

    #dd if=/dev/urandom of=testfile2 bs=4096 seek=999 count=1

    这个命令跟前一个命令相似,不同的是,它其实复制了1个块的内容,前面的999个块都跳过了.

    我们ls -l一下,发现文件的大小还是4096000,用du -h testfile2查看,占用的块大小是4K

    我们发现,虽然文件是4M,但是实际在磁盘上只占用了4K的大小,这就是空洞文件的神奇之处.

     

    实际中的空洞文件会在哪里用到呢?常见的场景有两个:

    一是在下载电影的时候,发现刚开始下载,文件的大小就已经到几百M了.

    二是在创建虚拟机的磁盘镜像的时候,你创建了一个100G的磁盘镜像,但是其实装起来系统之后,开始也不过只占用了3,4G的磁盘空间,如果一开始把100G都分配出去的话,无疑是很大的浪费.

     

     

    然后讲一下底层的实现吧,其实这个功能关键得文件系统支持,貌似FAT就不可以吧,linux下一直都很好的支持这一特性,我们举个最简单的ext的例子吧,ext中记录文件实际内容的对应信息的东东是一个叫索引表的东西,里面有十几个条目,每个条目存放对应文件内容块的块号,这样就可以顺序找到对应的文件内容了,大家可能说,几M的一个文件,十几个项哪够啊,不必担心,一般索引表前面几个项目是直接指向文件内容的,如果这几个不够的话,往后的第一个项目不会指向文件内容块,而会指向一个存放项目的块,这样一下多出N个项目来,如果这样还不够,下面的那个是存放指向指向的项目,不好意思,我也绕晕了,总之,前面的是直接指向,下面这个是二级指向,再下面的是二级指向,以此类推,这样,文件系统就可以处理T数量级别的文件,看下图:

     

    到了空洞文件这里呢,我们只需要把指向没有文件内容部分的索引项目置NULL就好了,这样就不会指向实际的数据块了,也不会占用磁盘空间了,就这么easy~

    至于btrfs这些新一代文件系统呢,在空洞文件这里的原理跟ext还是类似的.

    最后介绍一下linux对空洞文件的处理,经过我最近的一些测试所得:

    在同一文件系统ext4下,cat一个空洞文件到新文件,新文件不再是空洞文件,cp一个空洞文件到新文件,新文件仍然是空洞文件.

    在btrfs跟ext4之间做的结果同上面是一致的,但是在不同文件系统之间cp,因为不同文件系统分配的最小单元不同,所以du结果会不同.

    在nfs的客户端下,在nfs目录下去cp,新文件仍然是空洞文件!!!但是cp会逐个的去比较文件的内容,所以,受网络状况搞得影响,过程有时候会很慢.

     

     

     

    2.怎么获得一个空洞文件?

    在linux下,利用lseek人为的修改offset可以获得一个空洞文件。

     

    [cpp] view plain copy

    1. #include <stdio.h>  
    2. #include <stdlib.h>  
    3. #include <unistd.h>  
    4. #include <sys/stat.h>  
    5. #include <sys/types.h>  
    6. #include <fcntl.h>  
    7. #include <string.h>  
    8.   
    9. #define OFFSET_LENGTH 15000  
    10.   
    11. char buff1[] = "abcdefg";  
    12. char buff2[] = "ABCDEFG";  
    13.   
    14. int  
    15. main(int argc,char** argv)  
    16. {  
    17.     int fd = 0;  
    18.       
    19.     int buff1Length = strlen(buff1);  
    20.     int buff2Length = strlen(buff2);  
    21.       
    22.     char* buff3 = (char*)malloc(buff1Length + buff2Length + OFFSET_LENGTH);  
    23.     memset(buff3,2,buff1Length + buff2Length + OFFSET_LENGTH);  
    24.       
    25.     //create hole file  
    26.     if((fd = creat("./hole.f",S_IREAD|S_IWRITE)) < 0)  
    27.     {  
    28.         perror("create file error!");  
    29.     }  
    30.       
    31.     printf("fd:%d\n",fd);  
    32.     if(write(fd,buff1,buff1Length) != buff1Length)  
    33.     {  
    34.         perror("write error!");  
    35.     }  
    36.       
    37.     if(lseek(fd,OFFSET_LENGTH,SEEK_CUR) == -1)  
    38.     {  
    39.         perror("lseek error!");  
    40.     }  
    41.       
    42.     if(write(fd,buff2,buff2Length) != buff2Length)  
    43.     {  
    44.         perror("write error!");  
    45.     }  
    46.       
    47.     //create nohole file  
    48.     if((fd = creat("./nohole.f",S_IREAD|S_IWRITE)) < 0)  
    49.     {  
    50.         perror("create file error!");  
    51.     }  
    52.       
    53.     if(write(fd,buff3,strlen(buff3)) != strlen(buff3))  
    54.     {  
    55.         perror("write error!");  
    56.     }  
    57.       
    58.     free(buff3);  
    59.       
    60.     return 0;  
    61. }  

     

    上面的程序创建了一个空洞文件和一个同样大小的非空洞文件,接下来我们将以这两个文件作为基础进行空洞文件的分析。

     

    3.空洞文件的表现

    空洞文件特点就是offset大于实际大小,也就是说一个文件的两头有数据而中间为空,以‘\0‘填充。那文件系统会不会不做任何处理的将其存放在硬盘上呢?答案是否定的,文件系统没有傻到这种程度,因为这实际是中浪费,也是一种威胁,因为一旦黑客利用这个漏洞不断侵蚀磁盘资源,计算机就崩溃了。所以说,文件系统肯定会做相应的处理,下面我就来验证一下。

    用ls来展现两个文件:

    我们在用du来展现两个文件(du命令用于报告文件所使用的磁盘空间总量):

    可以看到,用ls展现的空洞和非空洞的大小完全相同,而用du命令展现的则有差别,一个占用了8个1024的字节块,而一个占用了16个1024的字节块。这里有个问题,文件大小为15014,算下来最多就15个block,为什么是16个呢?在《APUE》中有这样的解释:"文件系统使用了若干块以存放指向实际数据块的各个指针"。

    为什么会这样呢?原因是ls展现的文件的逻辑大小,也就是文件在文件系统表现出来的大小,而du展现的是文件物理大小,也就是文件在磁盘上实际所占的block数。所以说,空洞文件在文件系统表现的还是和普通文件一样的,但是实际上文件系统并没有给他分配所表现出来的那么多空间,只是存放了有用的信息。

    接下俩我们再来看一个现象:

    首先我们用cat来输出空洞文件中内容,然后重定向到一个新的文件中:

    我们再来用cp去复制一个文件:

    可以看到,用cat得到的文件,文件实际占用的block增加了,而cp的没有。那是因为cat在复制空洞文件时会将空洞补齐,将空洞填以0,因为cat命令就是简单的read和write的操作,read在遇到空洞时读出0,write则写入0,这时文件就变成了非空洞文件,而cp在复制文件时不会,cp命令会去判断文件是否有空洞,如果有,则会调用lseek进行空洞的模拟,所以还是会保持和源文件的一致性。

     

    4.空洞文件有什么用?

    空洞文件作用很大,例如迅雷下载文件,在未下载完成时就已经占据了全部文件大小的空间,这时候就是空洞文件。下载时如果没有空洞文件,多线程下载时文件就都只能从一个地方写入,这就不是多线程了。如果有了空洞文件,可以从不同的地址写入,就完成了多线程的优势任务。

    感觉这并不是空洞文件的全部作用,后续将进行补充。。。。

    展开全文
  • 文件空洞

    2020-02-22 20:39:48
  • Linux文件空洞解释

    2021-05-14 17:51:51
    desktop:~/fhole$ stat fileh File: “fileh” Size: 10010 Blocks: 24 IO Block: 4096 普通文件 Device: 801h/2049d Inode: 297793 Links: 1 Access: (0650/-rw-r-x---) Uid: ( 1000/ sudoo) Gid: ( 1000/ ...

    以例子结合命令理解,具体看下面内容

    /********

    hole.c

    ********/

    #include

    #include

    #include

    #include

    char buffer1[]="abcdefghijklmnop";

    char buffer2[]="1234567890";

    int main(void)

    {

    int fd;

    if((fd=open("filehole",O_RDWR|O_TRUNC|O_CREAT))<0)

    printf("create error/n");

    if(write(fd,buf1,strlen(buf1))!=16)

    printf("buf1 write error/n");

    if(lseek(fd,10000,SEEK_SET)==-1)

    printf("lseek error/n");

    if(write(fd,buf2,strlen(buf2))!=10);

    printf("buf2 write error/n");

    close(fd);

    return 0;

    }

    sudoo@sudoo-desktop:~/fhole$ gcc  -o hole hole.c

    sudoo@sudoo-desktop:~/fhole$ ./hole

    sudoo@sudoo-desktop:~/fhole$ ls

    filehole  hole  hole.c  hole.c~

    sudoo@sudoo-desktop:~/fhole$ ls -l filehole

    -rw-r-x--T 1 sudoo sudoo 10010 2010-03-31 19:59 filehole

    sudoo@sudoo-desktop:~/fhole$ cp  --sparse=never filehole  fileh

    sudoo@sudoo-desktop:~/fhole$ ls

    fileh  filehole  hole  hole.c  hole.c~

    sudoo@sudoo-desktop:~/fhole$ ls -l fileh

    -rw-r-x--- 1 sudoo sudoo 10010 2010-03-31 20:00 fileh

    sudoo@sudoo-desktop:~/fhole$ od -c filehole

    0000000   a b   c   d   e   f   g   h   i   j   k   l   m   n   o   p

    0000020  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0

    *

    0023420   1   2   3   4   5   6   7   8   9   0

    0023432

    sudoo@sudoo-desktop:~/fhole$ od -c fileh

    0000000   a b   c   d   e   f   g   h   i   j   k   l   m   n   o   p

    0000020  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0  /0

    *

    0023420   1   2   3   4   5   6   7   8   9   0

    0023432

    sudoo@sudoo-desktop:~/fhole$ stat filehole

    File: “filehole”

    Size: 10010           Blocks: 16       IO Block: 4096 普通文件

    Device: 801h/2049d       Inode: 297588      Links: 1

    Access: (1650/-rw-r-x--T)  Uid: ( 1000/   sudoo)   Gid: ( 1000/   sudoo)

    Access: 2010-03-31 19:59:41.000000000 +0800

    Modify: 2010-03-31 19:59:40.000000000 +0800

    Change: 2010-03-31 19:59:40.000000000 +0800

    sudoo@sudoo-desktop:~/fhole$ stat fileh

    File: “fileh”

    Size: 10010          Blocks: 24       IO Block: 4096 普通文件

    Device: 801h/2049d       Inode: 297793      Links: 1

    Access: (0650/-rw-r-x---)  Uid: ( 1000/   sudoo)   Gid: ( 1000/   sudoo)

    Access: 2010-03-31 20:00:37.000000000 +0800

    Modify: 2010-03-31 20:00:35.000000000 +0800

    Change: 2010-03-31 20:00:35.000000000 +0800

    sudoo@sudoo-desktop:~/fhole$ du filehole

    8     filehole

    sudoo@sudoo-desktop:~/fhole$ du fileh

    12    fileh

    sudoo@sudoo-desktop:~/fhole$ du -h filehole

    8.0K     filehole

    sudoo@sudoo-desktop:~/fhole$ du -h fileh

    12K fileh

    sudoo@sudoo-desktop:~/fhole$

    展开全文
  • 文件空洞与空洞文件 lseek()系统调用可以改变文件的偏移量,但如果程序调用使得文件偏移量跨越了文件结尾,然后在执行I/O操作,将会发生什么情况?read()调用会返回0,表示文件结尾。write()调用可以在文件尾...
  • 清除日志文件不产生文件空洞

    千次阅读 2020-02-10 14:33:57
    文件空洞:文件内容的大小小于文件磁盘占用的空间 产生原因:如java使用nohup java -jar xxx.jar > log.txt方式启动java程序,但随着日志内容的增多,服务器磁盘空间不足,需要清理日志文件,所以可采用命令echo '' ...
  • linux文件空洞

    千次阅读 2016-04-12 09:31:46
    lseek产生的文件空洞
  • Linux文件---文件空洞

    千次阅读 2017-09-02 16:41:55
    文件空洞若将lseek()函数的基准点设置为SEEK_END但是偏移量是正数(即从文件末尾再向后偏移),则会产生“文件空洞”的情况。 文件的偏移量是从文件开始位置开始计算的,若文件的偏移量大于了文件的实际数据长度,...
  • 试过很多命令都没有用的。 虽然一时清零了,但是日志文档留下了很大的空洞,什么内容都没有,但是却占内存。 一旦发送请求,有日志写入,日志立马变为原来的大小。 这个怎么解呀?
  • 慢慢欣赏linux 文件黑洞和文件空洞

    千次阅读 2019-01-25 00:04:57
    文件空洞:文件系统的hole可以不占用磁盘空间 linux 黑洞文件详解 http://blog.51cto.com/study2008/1784434 linux下文件大小不一致的情况分析,文件空洞 http://blog.51cto.com/drizzlewalk/425473 linux下文件...
  • 学习笔记:linux之文件空洞

    万次阅读 2015-03-02 14:33:01
    空洞文件就是有空洞文件,在日常的常识中,我们使用的文件存放在硬盘分区上的时候,有多大的内容就会占用多大的空间,比如这个文本文件里面写有1000个asc字符,那么就会占用磁盘上1000B的存储空间,为了便于管理文件,
  • 文件拷贝时候,scp一个占磁盘空间300G大小(du命令的结果)左右的目录到另外一台机器上,du命令发现该目录占用的磁盘空间变大了,约330多G。为什么会多出来这30G呢? 分析可能原因: 一.原机器的block大小为1024k...
  • 文件空洞的作用

    2019-05-11 16:55:26
    当两个文件需要共享内存的时候,由于不知道需要共享内存的大小,所以需要在文件创建后之后设置文件的大小,这时就需要用到空洞文件了。一开始文件的大小为0,如果要设置文件的大小为filesize,...
  • 文件空洞:文件系统的空洞(hole)可以不占用磁盘空间 在UNIX文件操作中,文件位移量可以大于文件的当前长度,在这种情况下,对该文件的下一次写将延长该文件,并在文件中构成一个空洞。位于文件中但没有写过的字节都...
  • 一、文件长度 二、文件空洞 图3-2程序(lseek函数):https://blog.csdn.net/qq_41453285/article/details/88929776
  • 文件IO(文件空洞

    2016-02-15 09:22:15
    可以通过lseek或者fseek来创建文件空洞,使用多线程多点同时读写文件,优化读写性能。   拓展: 每一次使用open()/fopen()都会获得一套管理文件操作的独立的内核资源,因此即便是打开同一个文件,都有各自...
  • 上次课上学了lseek这个函数,可以制造出“空洞文件。演示中,我们发现,用vi或者od命令查看带空洞文件空洞部分填满了字符0。于是产生了: 问题一:空洞文件和用字符0写同样长度的文件一样吗? 我们来写一个...
  • 文件空洞测试

    千次阅读 2013-04-04 02:52:38
    linux操作系统中,文件的偏移量可以大于文件的实际长度(用lseek函数设置偏移量),那么在接下来写时会加长extend这个文件,则中间就形成空洞hole,读出时hole里没有操作的空间会显示为null或0。在linux的文件系统下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,224
精华内容 5,689
关键字:

文件空洞