Linux文件系统之sparse文件处理与传输

0. 什么是sparse文件

当用户申请一块很大的存储空间时，由于最开始并没有写入数据(全是空)，此时文件系统为了节省存储资源，提高资源利用率，不会分配实际存储空间，只有当真正写入数据时，操作系统才真正一点一点地分配空间，比如一次64KB。于是这个文件看起来很大，而占用空间很小，实际占用空间只与用户填的数据量有关。该文件看起来像一个大盒子，但可能装的东西不多，空洞很大，因此称为稀疏文件(Sparse file)。Sparse文件是Linux文件系统的一个高级特性，能够实现磁盘的超负载使用(overload)。它最经典的应用就是为虚拟机创建虚拟硬盘以及数据库快照，比如我们使用qemu-img创建一个大小为20GB的raw文件(注意qcow2格式不是sparse文件):

1. fgp@node1:~$ qemu-img create -f raw test.raw 20G 
2. Formatting 'test.raw', fmt=raw size=21474836480 
3. fgp@node1:~$ qemu-img info test.raw 
4. image: test.raw 
5. file format: raw 
6. virtual size: 20G (21474836480 bytes) 
7. disk size: 0 

以上我们使用qemu-img创建了一个20G的镜像文件，由qemu-img info显示，virtual size为我们分配的空间大小，而disk size为实际占用的空间,最开始并不占任何磁盘空间。

注：qemu-img create -f raw相当于`truncate -s 20G test.raw’。

当然也会有问题，比如系统生成了一堆sparse文件，如果文件系统满了，则这些文件都会写入失败，为了避免这种情况，需要控制sparse文件的数量。

1.如何判断是否sparse文件

除了以上的镜像文件可能是sparse文件，其他文件类型也有可能是sparse文件，如何判断是否sparse文件呢?最简单的办法是使用ls命令和du命令分别查看大小，如果二者大小不一致，则说明是sparse文件。我们可以使用dd命令快速生成一个sparse文件：

1. dd if=/dev/zero of=sparse_file bs=1M seek=1024 count=0 

以上命令从第1024 * 1M处开始写文件(相当于中间空了1GB空间)，写入/dev/zero，实际写入了0个块(count=0)，因此实际上并没有写入任何数据。我们使用ls -lh查看其大小：

1. ~$ ls -lh sparse_file 
2. -rw-rw-r-- 1 fgp fgp 1.0G May 26 15:47 sparse_file 

可见该文件显示为1G。

我们再使用du -h命令查看其占用磁盘空间大小:

1. ~$ du -h sparse_file 
2. 0   sparse_file 

我们发现实际占用磁盘空间为0。

我们也可以直接使用ls的-s参数查看文件实际占用空间大小：

1. ~$ ls -slh sparse_file 
2. 0 -rw-rw-r-- 1 fgp fgp 1.0G May 26 15:47 sparse_file 

其中第一列为实际占用磁盘空间大小，第6列为文件大小(虚拟大小)。

另外使用truncate命令可以随意调节文件大小(如果该文件不存在则会自动创建)，比如:

1. ~$ truncate --size 1T sparse_file 
2. ~$ du -h sparse_file 
3. 0   sparse_file 
4. ~$ ls -lh sparse_file 
5. -rw-rw-r-- 1 fgp fgp 1.0T May 26 16:09 sparse_file 

以上我们把sparse_file文件大小调为1TB，实际上就是往后面追加空洞(extended part (hole) reads as zero bytes),因此不会占用实际磁盘空间。当然也可以缩小文件大小，但是如果比文件数据占用空间还小的话，就会截取数据，因此部分数据会丢失。

1. truncate -s 500M sparse_file 
2. ~$ ls -lh sparse_file 
3. -rw-rw-r-- 1 fgp fgp 500M May 26 16:12 sparse_file 

以上我们把该文件缩减为500MB。

2. sparse文件处理

sparse文件在处理时也存在一些问题，比如我们使用sed对一个sparse文件进行处理。

1. fgp@node1:~/tmp$ echo "Hello World" >test.raw 
2. fgp@node1:~/tmp$ truncate -s 1G test.raw 
3. fgp@node1:~/tmp$ ls -slh 
4. total 68K 
5. 4.0K -rw-rw-r-- 1 fgp fgp 1.0G May 28 14:52 test.raw 
6. fgp@node1:~/tmp$ sed -i 's/Hello/HELLO/g' test.raw 
7. fgp@node1:~/tmp$ ls -slh 
8. total 1.1G 
9. 1.1G -rw-rw-r-- 1 fgp fgp 1.0G May 28 14:53 test.raw 

以上我们使用truncate创建了一个sparse文件，然后通过sed命令把Hello改为HELLO，我们期望能够保留该文件的sparse特性，但实际上我们发现仅仅修改了该文件的一行数据，该文件的空洞被填满，瞬间占用磁盘空间为1G。一个只有4K大小的文件使用sed命令后变成了1G，这让人感到莫名其妙不是吗?

再比如我们我们使用tar命令对文件进行归档：

1. fgp@node1:~/tmp$ qemu-img create -f raw test.raw 1G 
2. Formatting 'test.raw', fmt=raw size=1073741824 
3. fgp@node1:~/tmp$ time tar -cf test.tar test.raw 
4.  
5. real    0m2.145s 
6. user    0m0.012s 
7. sys 0m1.640s 
8. fgp@node1:~/tmp$ time tar -cJf test.tar.xz test.raw 
9.  
10. real    1m0.692s 
11. user    0m59.060s 
12. sys 0m1.048s 
13. fgp@node1:~/tmp$ ls -lsh 
14. total 1.1G 
15.    0 -rw-r--r-- 1 fgp fgp 1.0G May 28 15:37 test.raw 
16. 1.1G -rw-rw-r-- 1 fgp fgp 1.1G May 28 15:37 test.tar 
17. 156K -rw-rw-r-- 1 fgp fgp 153K May 28 15:39 test.tar.xz 

以上我们创建了一个1G的sparse文件，当使用tar直接归档时发现该文件变成了非sparse文件，占用了1G的磁盘空间。而使用xz压缩时，虽然解决了存储空间的问题，同时也带来压缩时间开销问题(耗费了1分钟的时间进行压缩)。

接下来介绍下熟悉的经典命令cp,cp命令可谓无人不知。众所周知，它用于在本地拷贝文件。值得庆幸(为什么庆幸，因为并不是所有的命令都支持该特性)的是cp命令能够自动探测文件是否sparse文件，空洞数据不会拷贝，并且能够保留sparce文件副本的稀疏性质：

1. fgp@node1:~$ cp sparse_file sparse_file.copy 
2. fgp@node1:~$ ls -slh sparse_file* 
3. 0 -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:39 sparse_file 
4. 0 -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:39 sparse_file.copy 

我们看看和cp命令类似的命令scp,scp用于远程拷贝文件(远程传输文件):

1. fgp@node1:~$ scp sparse_file localhost:~/sparse_file.copy 
2. sparse_file                                            100% 2048MB  97.5MB/s   00:21 
3. fgp@node1:~$ ls -slh sparse_file* 
4.    0 -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:39 sparse_file 
5. 2.1G -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:42 sparse_file.copy 

我们发现scp不能识别sparse文件，传输一个sparse文件时会自动填满空洞，发送整个文件内容。

其实cp命令有一个针对sparse文件拷贝优化的参数--sparse=WHEN，其中WHEN的合法值为auto、always、never，默认为auto，能自动识别是否sparse文件。如果设置为never则会自动填满数据，拷贝整个文件：

1. fgp@node1:~$ cp --sparse=never sparse_file sparse_file.copy.2 
2. fgp@node1:~$ ls -lhs sparse_file* 
3.    0 -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:39 sparse_file 
4. 2.1G -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:42 sparse_file.copy 
5. 2.1G -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:50 sparse_file.copy.2 

可见sparse_file.copy.2填满了空洞，相当于把sparse文件转化成了非sparse文件。

如果指定为always，则cp会尝试把文件转换为sparse文件，减少磁盘占用空间：

1. fgp@node1:~$ cp --sparse=always sparse_file.copy sparse_file.copy.3 
2. fgp@node1:~$ ls -lsh sparse_file* 
3.    0 -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:39 sparse_file 
4. 2.1G -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:42 sparse_file.copy 
5. 2.1G -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:50 sparse_file.copy.2 
6.    0 -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:52 sparse_file.copy.3 

由结果发现，我们把非sparse文件sparse_file.copy转成了sparse文件sparse_file.copy.3。

注：cp命令黑科技，cp实现sparse文件的相互转换!

其实除了cp命令，我们上面的tar命令也支持–sparse参数：

1. fgp@node1:~/tmp$ time tar -cSf test.tar test.raw 
2.  
3. real    0m0.002s 
4. user    0m0.000s 
5. sys 0m0.000s 
6. fgp@node1:~/tmp$ time tar -cSJf test.tar.xz test.raw 
7.  
8. real    0m0.011s 
9. user    0m0.000s 
10. sys 0m0.008s 
11. fgp@node1:~/tmp$ ls -slh 
12. total 16K 
13.    0 -rw-r--r-- 1 fgp fgp 1.0G May 28 15:37 test.raw 
14.  12K -rw-rw-r-- 1 fgp fgp  10K May 28 15:42 test.tar 
15. 4.0K -rw-rw-r-- 1 fgp fgp  184 May 28 15:43 test.tar.xz 

对比前面的结果，我们发现使用tar的-S(–sparse)参数很好的处理sparse文件。

另外cpio也支持同样的参数，但可惜的是scp命令不支持，因此我们使用scp远程传输大量的sparse文件时效率极低，并且浪费大量网络空间。比如我们经常使用qemu-img创建了一个40GB的raw文件，然后需要拷贝镜像到其他机器上，虽然该文件可能只占了1GB左右的磁盘空间，可使用scp需要传输40GB的空间，并且远程需要预留40GB的磁盘空间。那有没有高效传输sparse文件的方法呢?实际上，很可惜，好像并没有，不过有比较好的方法，请看下一节内容。

3.相对高效传输sparse文件的方法

我们前面说了scp不支持sparse文件的处理，好在rsync命令支持sparse文件处理：

1. fgp@node1:~$ rsync  -av --sparse --progress sparse_file localhost:~/sparse_file.copy 
2. fgp@localhost's password: 
3. sending incremental file list 
4. sparse_file 
5.   2,147,483,648 100%   74.67MB/s    0:00:27 (xfr#1, to-chk=0/1) 
6.  
7. sent 2,148,008,037 bytes  received 35 bytes  66,092,556.06 bytes/sec 
8. total size is 2,147,483,648  speedup is 1.00 
9. fgp@node1:~$ ls -lhs sparse_file* 
10. 0 -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:39 sparse_file 
11. 0 -rw-rw-r-- 1 fgp fgp 2.0G May 26 16:39 sparse_file.copy 

遗憾的是，虽然目标文件保留了其sparse特性，节省了目标主机的存储空间，但并没有节省网络传输带宽，依然传输了2GB的数据,rsync不能过滤掉空洞数据的传输。

值得一提的是rsync有一个参数--inplace，这个参数能够探测源文件和目标文件是否修改的块，传输时只传递修改的块，当然第一次传输文件时，这个参数并没有什么用。但可惜的是–sparse参数和–inplace参数不能同时使用。通常做法是第一次传输文件时，使用–sparse参数，之后如果对文件进行了修改，需要同步远程时，使用–inplace参数，它只会在原文件的基础上传输更新的块。(可以先在远程目标机器上先使用truncate命令创建一个同名的sparse文件，再使用–inplace参数传递)。

当然如果我们传输的是镜像文件，可以通过qemu-img把raw格式在本地转化为qcow2格式后再传输:

1. fgp@node1:~/tmp$ ls -lsh 
2. total 0 
3. 0 -rw-rw-r-- 1 fgp fgp 10G May 28 15:00 test.raw 
4. fgp@node1:~/tmp$ qemu-img convert -f raw -O qcow2 test.raw test.qcow2 
5. fgp@node1:~/tmp$ ls -lsh 
6. total 196K 
7. 196K -rw-r--r-- 1 fgp fgp 193K May 28 15:12 test.qcow2 
8.    0 -rw-rw-r-- 1 fgp fgp  10G May 28 15:00 test.raw 

转化成qcow2格式后，不再是sparse文件，因此不会存在以上问题。由以上输出我们发现，该文件只有196K，因此传输量大幅度减少。