developerWorks 社区
要想恢复误删除的文件，必须清楚数据在磁盘上究竟是如何存储的，以及如何定位并恢复数据。本文从数据恢复的角度，着重介绍了 ext2 文件系统中使用的一些基本概念和重要数据结构，并通过几个实例介绍了如何手工恢复已经删除的文件。最后针对 ext2 现有实现存在的大文件无法正常恢复的问题，通过修改内核中的实现，给出了一种解决方案。
(), 软件工程师, IBM Japan
冯锐，软件工程师，目前在 IBM 开发中心从事 AIX 性能测试方面的工作。您可以通过 fengrui@ 与他联系。
(), 软件工程师, IBM
丁成，软件工程师，目前在 IBM 开发中心从事 AIX 性能测试方面的工作，您可以通过 dingc@ 与他联系。
对于很多 Linux 的用户来说，可能有一个问题一直都非常头疼：对于那些不小心删除的数据来说，怎样才能恢复出来呢？大家知道，在 Windows 系统上，回收站中保存了最近使用资源管理器时删除的文件。即便是对于那些在命令行中删除的文件来说，也有很多工具（例如recover4all，FinalData Recovery）可以把这些已经删除的文件恢复出来。在Linux 下这一切是否可能呢？实际上，为了方便用户的使用，现在 Linux 上流行的桌面管理工具（例如gnome和KDE）中都已经集成了回收站的功能。其基本思想是在桌面管理工具中捕获对文件的删除操作，将要删除的文件移动到用户根目录下的 .Trash 文件夹中，但却并不真正删除该文件。当然，像在 Windows 上一样，如果用户在删除文件的同时，按下了 Shift 键并确认删除该文件，那么这个文件就不会被移动到 .Trash 文件夹中，也就无从恢复了。此时，习惯了使用 Windows 上各种恢复工具的人就会顿足捶胸，抱怨 Linux 上工具的缺乏了。但是请稍等一下，难道按照这种方式删除的文件就真的无从恢复了么？或者换一个角度来看，使用 rm 命令删除的文件是否还有办法能够恢复出来呢？背景知识在开始真正进行实践之前，让我们首先来了解一下在 Linux 系统中，文件是如何进行存储和定位的，这对于理解如何恢复文件来说非常重要。我们知道，数据最终以数据块的形式保存在磁盘上，而操作系统是通过文件系统来管理这些数据的。ext2/ext3 是 Linux 上应用最为广泛的文件系统，本文将以 ext2 文件系统为例展开介绍。我们知道，在操作系统中，文件系统是采用一种层次化的形式表示的，通常可以表示成一棵倒置的树。所有的文件和子目录都是通过查找其父目录项来定位的，目录项中通过匹配文件名可以找到对应的索引节点号（inode），通过查找索引节点表（inode table）就可以找到文件在磁盘上的位置，整个过程如图1所示。图 1. 文件数据定位过程对于 ext2 类型的文件系统来说，目录项是使用一个名为 ext2_dir_entry_2 的结构来表示的，该结构定义如下所示：清单 1. ext2_dir_entry_2 结构定义struct ext2_dir_entry_2 {
/* 索引节点号 */
/* 目录项的长度 */
/* 文件名长度 */
/* 文件类型 */
name[EXT2_NAME_LEN];
/* 文件名 */
};在 Unix/Linux 系统中，目录只是一种特殊的文件。目录和文件是通过 file_type 域来区分的，该值为 1 则表示是普通文件，该值为 2 则表示是目录。对于每个 ext2 分区来说，其在物理磁盘上的布局如图 2 所示：图 2. ext2 分区的布局从图 2 中可以看到，对于 ext2 文件系统来说，磁盘被划分成一个个大小相同的数据块，每个块的大小可以是 或 4096 个字节。其中，第一个块称为引导块，一般保留做引导扇区使用，因此 ext2 文件系统一般都是从第二个块开始的。剩余的块被划分为一个个的块组，ext2 文件系统会试图尽量将相同文件的数据块都保存在同一个块组中，并且尽量保证文件在磁盘上的连续性，从而提高文件读写时的性能。至于一个分区中到底有多少个块组，这取决于两个因素：
分区大小。
块大小。最终的计算公式如下：分区中的块组数＝分区大小/(块大小*8)这是由于在每个块组中使用了一个数据块位图来标识数据块是否空闲，因此每个块组中最多可以有（块大小*8）个块；该值除上分区大小就是分区中总的块组数。每个块组都包含以下内容：
超级块。存放文件系统超级块的一个拷贝。
组描述符。该块组的组描述符。
数据块位图。标识相应的数据块是否空闲。
索引节点位图。标识相应的索引节点是否空闲。
索引节点表。存放所有索引节点的数据。
数据块。该块组中用来保存实际数据的数据块。在每个块组中都保存了超级块的一个拷贝，默认情况下，只有第一个块组中的超级块结构才会被系统内核使用；其他块组中的超级块可以在 e2fsck 之类的程序对磁盘上的文件系统进行一致性检查使用。在 ext2 文件系统中，超级块的结构会通过一个名为 ext2_super_block 的结构进行引用。该结构的一些重要域如下所示：清单 2. ext2_super_block 结构定义struct ext2_super_block {
/* 索引节点总数 */
/* 块数，即文件系统以块为单位的大小 */
s_r_blocks_
/* 系统预留的块数 */
s_free_blocks_
/* 空闲块数 */
s_free_inodes_
/* 空闲索引节点数 */
s_first_data_
/* 第一个可用数据块的块号 */
s_log_block_
/* 块大小 */
s_blocks_per_
/* 每个块组中的块数 */
s_inodes_per_
/* 每个块组中的索引节点个数 */
}每个块组都有自己的组描述符，在 ext2 文件系统中是通过一个名为 ext2_group_desc的结构进行引用的。该结构的定义如下：清单 3. ext2_group_desc 结构定义/*
* Structure of a blocks group descriptor
struct ext2_group_desc
/* 数据块位图的块号 */
/* 索引节点位图的块号 */
/* 第一个索引节点表的块号 */
bg_free_blocks_
/* 该组中空闲块数 */
bg_free_inodes_
/* 该组中空闲索引节点数 */
bg_used_dirs_
/* 该组中的目录项 */
bg_reserved[3];
};数据块位图和索引节点位图分别占用一个块的大小，其每一位描述了对应数据块或索引节点是否空闲，如果该位为0，则表示空闲；如果该位为1，则表示已经使用。索引节点表存放在一系列连续的数据块中，每个数据块中可以包括若干个索引节点。每个索引节点在 ext2 文件系统中都通过一个名为 ext2_inode 的结构进行引用，该结构大小固定为 128 个字节，其中一些重要的域如下所示：清单 4. ext2_inode 结构定义/*
* Structure of an inode on the disk
struct ext2_inode {
/* 文件模式 */
/* 文件所有者的 uid */
/* 以字节为单位的文件长度 */
/* 最后一次访问该文件的时间 */
/* 索引节点最后改变的时间 */
/* 文件内容最后改变的时间 */
/* 文件删除的时间 */
/* 文件所有者的 gid */
/* 硬链接数 */
/* 文件的数据块数 */
i_block[EXT2_N_BLOCKS];/* 指向数据块的指针 */
};第一个索引节点所在的块号保存在该块组描述符的 bg_inode_table 域中。请注意 i_block 域，其中就包含了保存数据的数据块的位置。有关如何对数据块进行寻址，请参看后文“数据块寻址方式”一节的内容。需要知道的是，在普通的删除文件操作中，操作系统并不会逐一清空保存该文件的数据块的内容，而只会释放该文件所占用的索引节点和数据块，方法是将索引节点位图和数据块位图中的相应标识位设置为空闲状态。因此，如果我们可以找到文件对应的索引节点，由此查到相应的数据块，就可能从磁盘上将已经删除的文件恢复出来。幸运的是，这一切都是可能的！本文将通过几个实验来了解一下如何从磁盘上恢复删除的文件。数据块寻址方式回想一下，ext2_inode 结构的 i_block 域是一个大小为 EXT2_N_BLOCKS 的数组，其中保存的就是真正存放文件数据的数据块的位置。通常来说，EXT2_N_BLOCKS 大小为 15。在 ext2 文件系统，采用了直接寻址和间接寻址两种方式来对数据块进行寻址，原理如图3 所示：图 3. 数据块寻址方式
对于 i_block 的前 12 个元素（i_block[0]到i_block[11]）来说，其中存放的就是实际的数据块号，即对应于文件的 0 到 11 块。这种方式称为直接寻址。
对于第13个元素（i_block[12]）来说，其中存放的是另外一个数据块的逻辑块号；这个块中并不存放真正的数据，而是存放真正保存数据的数据块的块号。即 i_block[12] 指向一个二级数组，其每个元素都是对应数据块的逻辑块号。由于每个块号需要使用 4 个字节表示，因此这种寻址方式可以访问的对应文件的块号范围为 12 到 (块大小/4)+11。这种寻址方式称为间接寻址。
对于第14个元素（i_block[13]）来说，其中存放也是另外一个数据块的逻辑块号。与间接寻址方式不同的是，i_block[13] 所指向的是一个数据块的逻辑块号的二级数组，而这个二级数组的每个元素又都指向一个三级数组，三级数组的每个元素都是对应数据块的逻辑块号。这种寻址方式称为二次间接寻址，对应文件块号的寻址范围为 (块大小/4)+12 到 (块大小/4)2+(块大小/4)+11。
对于第15个元素（i_block[14]）来说，则利用了三级间接索引，其第四级数组中存放的才是逻辑块号对应的文件块号，其寻址范围从 (块大小/4)2+(块大小/4)+12 到 (块大小/4)3+ (块大小/4)2+(块大小/4)+11。ext2 文件系统可以支持和4096字节三种大小的块，对应的寻址能力如下表所示：表 1. 各种数据块对应的文件寻址范围
二次间接寻址
三次间接寻址
掌握上面介绍的知识之后，我们就可以开始恢复文件的实验了。准备文件系统为了防止破坏已有系统，本文将采用一个新的分区进行恢复删除文件的实验。首先让我们准备好一个新的分区，并在上面创建 ext2 格式的文件系统。下面的命令可以帮助创建一个 20GB 的分区：清单 5. 新建磁盘分区# fdisk /dev/sdb && END
END在笔者的机器上，这个分区是 /dev/sdb6。然后创建文件系统：清单 6. 在新分区上创建 ext2 文件系统# mke2fs /dev/sdb6并将其挂载到系统上来：清单 7. 挂载创建的 ext2 文件系统# mkdir /tmp/test
# mount /dev/sdb6 /tmp/test在真正使用这个文件系统之前，让我们首先使用系统提供的一个命令 dumpe2fs 来熟悉一下这个文件系统的一些具体参数：清单 8. 使用 dumpe2fs 熟悉这个文件系统的参数# dumpe2fs /dev/sdb6
dumpe2fs 1.39 (29-May-2006)
Filesystem volume name:
Last mounted on:
&not available&
Filesystem UUID:
d8b10aa9-c065-4aa5-ab6f-96a9bcda52ce
Filesystem magic number:
Filesystem revision #:
1 (dynamic)
Filesystem features:
ext_attr resize_inode dir_index filetype sparse_super large_file
Default mount options:
Filesystem state:
Errors behavior:
Filesystem OS type:
Inode count:
Block count:
Reserved block count:
Free blocks:
Free inodes:
First block:
Block size:
Fragment size:
Reserved GDT blocks:
Blocks per group:
Fragments per group:
Inodes per group:
Inode blocks per group:
Filesystem created:
Mon Oct 29 20:04:16 2007
Last mount time:
Mon Oct 29 20:06:52 2007
Last write time:
Mon Oct 29 20:08:31 2007
Mount count:
Maximum mount count:
Last checked:
Mon Oct 29 20:04:16 2007
Check interval:
Next check after:
Sat Apr 26 20:04:16 2008
Reserved blocks uid:
0 (user root)
Reserved blocks gid:
0 (group root)
First inode:
Inode size:
Default directory hash:
Directory Hash Seed:
ddef-a26fef9d5e8
Group 0: (Blocks 0-32767)
Primary superblock at 0, Group descriptors at 1-2
Reserved GDT blocks at 3-1024
Block bitmap at 1025 (+1025), Inode bitmap at 1026 (+1026)
Inode table at
31224 free blocks, 16276 free inodes, 2 directories
Free blocks: ,
Free inodes: 12, 14-16288
Group 149: (Blocks 5759)
Block bitmap at 4882432 (+0), Inode bitmap at 4882433 (+1)
Inode table at 2942 (+2)
2817 free blocks, 16288 free inodes, 0 directories
Free blocks: 5759
Free inodes: 3200应用前面介绍的一些知识，我们可以看到，这个文件系统中，块大小（Block size）为4096字节，因此每个块组中的块数应该是68个（Blocks per group），每个块组的大小是 128MB，整个分区被划分成20GB/(4KB*3个。但是为什么我们只看到 150 个块组（0到149）呢？实际上，在 fdisk 中，我们虽然输入要创建的分区大小为 20GB，但实际上，真正分配的空间并不是严格的20GB，而是只有大约 20*109 个字节，准确地说，应该是 (4885760 * 4096) / (24) = 18.64GB。这是由于不同程序的计数单位的不同造成的，在使用存储设备时经常遇到这种问题。因此，这个分区被划分成 150 个块组，前 149 个块组分别包含 32768 个块（即 128B），最后一个块组只包含 3328 个块。另外，我们还可以看出，每个索引节点的大小是 128 字节，每个块组中包含 16288 个索引节点，在磁盘上使用 509 个块来存储（96），在第一个块组中，索引节点表保存在 1027 到 1535 块上。数据块和索引节点是否空闲，是分别使用块位图和索引节点位图来标识的，在第一个块组中，块位图和索引节点位图分别保存在 1025 和 1026 块上。dumpe2fs 的输出结果中还包含了其他一些信息，我们暂时先不用详细关心这些信息。准备测试文件现在请将附件中的 createfile.sh 文件下载到本地，并将其保存到 /tmp/test 目录中，这个脚本可以帮助我们创建一个特殊的文件，其中每行包含 1KB 字符，最开始的14个字符表示行号。之所以采用这种文件格式，是为了方便地确认所恢复出来的文件与原始文件之间的区别。这个脚本的用法如下：清单 9. createfile.sh 脚本的用法# ./createfile.sh [size in KB] [filename]第 1 个参数表示所生成的文件大小，单位是 KB；第 2 个参数表示所生成文件的名字。下面让我们创建几个测试文件：清单 10. 准备测试文件# cd /tmp/test
#./createfile.sh 35 testfile.35K
#./createfile.sh 10240 testfile.10M
# cp testfile.35K testfile.35K.orig
# cp testfile.10M testfile.10M.orig上面的命令新创建了大小为 35 KB 和 9000KB 的两个文件，并为它们各自保存了一个备份，备份文件的目的是为了方便使用 diff 之类的工具验证最终恢复出来的文件与原始文件完全一致。ls 命令的 –i 选项可以查看有关保存文件使用的索引节点的信息：清单11. 查看文件的索引节点号# ls -li | sort
11 drwx------ 2 root root
16384 Oct 29 20:08 lost+found
12 -rwxr-xr-x 1 root root
1406 Oct 29 20:09 createfile.sh
13 -rw-r--r-- 1 root root
35840 Oct 29 20:09 testfile.35K
14 -rw-r--r-- 1 root root
Oct 29 20:10 testfile.10M
15 -rw-r--r-- 1 root root
35840 Oct 29 20:10 testfile.35K.orig
16 -rw-r--r-- 1 root root
Oct 29 20:11 testfile.10M.orig第一列中的数字就是索引节点号。从上面的输出结果我们可以看出，索引节点号是按照我们创建文件的顺序而逐渐自增的，我们刚才创建的 35K 大小的文件的索引节点号为 13，10M 大小的文件的索引节点号为 14。debugfs 中提供了很多工具，可以帮助我们了解进一步的信息。现在执行下面的命令：清单12. 查看索引节点 &13& 的详细信息# echo "stat &13&" | debugfs /dev/sdb6
debugfs 1.39 (29-May-2006)
Type: regular
Flags: 0x0
Generation:
Size: 35840
File ACL: 0
Directory ACL: 0
Blockcount: 72
Address: 0
ctime: 0x -- Mon Oct 29 20:09:59 2007
atime: 0x4726849d -- Mon Oct 29 20:10:53 2007
mtime: 0x -- Mon Oct 29 20:09:59 2007
TOTAL: 9输出结果显示的就是索引节点 13 的详细信息，从中我们可以看到诸如文件大小（35840=35K）、权限（0644）等信息，尤其需要注意的是最后 3 行的信息，即该文件被保存到磁盘上的 4096 到 4104 总共 9 个数据块中。下面再看一下索引节点 14 （即 testfile.10M 文件）的详细信息：清单13. 查看索引节点 &14& 的详细信息# echo "stat &14&" | debugfs /dev/sdb6
debugfs 1.39 (29-May-2006)
Type: regular
Mode: 0644
Flags: 0x0
Generation:
File ACL: 0
Directory ACL: 0
Blockcount: 20512
Address: 0
ctime: 0x -- Mon Oct 29 20:10:29 2007
atime: 0x -- Mon Oct 29 20:11:01 2007
mtime: 0x -- Mon Oct 29 20:10:29 2007
(0-11):, (IND):24588, (12--25612, (DIND):25613, (IND):25614,
():, (IND):26639, ():
TOTAL: 2564和索引节点 13
相比，二者之间最重要的区别在于 BLOCKS 的数据，testfile.10M 在磁盘上总共占用了 2564 个数据块，由于需要采用二级间接寻址模式进行访问，所以使用了4个块来存放间接寻址的信息，分别是2、2，其中25613块中存放的是二级间接寻址的信息。恢复删除文件现在将刚才创建的两个文件删除：清单14. 删除测试文件# rm -f testfile.35K testfile.10Mdebugfs 的 lsdel 命令可以查看文件系统中删除的索引节点的信息：清单15. 使用 lsdel 命令搜索已删除的文件# echo "lsdel" | debugfs /dev/sdb6
debugfs 1.39 (29-May-2006)
Time deleted
Mon Oct 29 20:32:05 2007
0 /2564 Mon Oct 29 20:32:05 2007
2 deleted inodes found.回想一下 inode 结构中有 4 个有关时间的域，分别是 i_atime、i_ctime、i_mtime和i_dtime，分别表示该索引节点的最近访问时间、创建时间、修改时间和删除时间。其中 i_dtime域只有在该索引节点对应的文件或目录被删除时才会被设置。dubugfs 的 lsdel 命令会去扫描磁盘上索引节点表中的所有索引节点，其中 i_dtime 不为空的项就被认为是已经删除的文件所对应的索引节点。从上面的结果可以看到，刚才删除的两个文件都已经找到了，我们可以通过文件大小区分这两个文件，二者一个大小为35K，另外一个大小为10M，正式我们刚才删除的两个文件。debugfs 的 dump 命令可以帮助恢复文件：清单16. 使用 dump 命令恢复已删除的文件# echo "dump &13& /tmp/recover/testfile.35K.dump" | debugfs /dev/sdb6
# echo "dump &14& /tmp/recover/testfile.10M.dump" | debugfs /dev/sdb6执行上面的命令之后，在 /tmp/recover 目录中会生成两个文件，比较这两个文件与我们前面备份的文件的内容就会发现，testfile.35K.dump 与 testfile.35K.orig 的内容完全相同，而 testfile.10M.dump 文件中则仅有前 48K 数据是对的，后面的数据全部为 0 了。这是否意味着删除文件时间已经把数据也同时删除了呢？实际上不是，我们还是有办法把数据全部恢复出来的。记得我们刚才使用 debugfs 的 stat 命令查看索引节点 14 时的 BLOCKS 的数据吗？这些数据记录了整个文件在磁盘上存储的位置，有了这些数据就可以把整个文件恢复出来了，请执行下面的命令：清单 17. 使用 dd 命令手工恢复已删除的文件# dd if=/dev/sdb6 of=/tmp/recover/testfile.10M.dd.part1 bs=4096 count=12 skip=24576
# dd if=/dev/sdb6 of=/tmp/recover/testfile.10M.dd.part2 bs=4096 count=1024 skip=24589
# dd if=/dev/sdb6 of=/tmp/recover/testfile.10M.dd.part2 bs=4096 count=1024 skip=25615
# dd if=/dev/sdb6 of=/tmp/recover/testfile.10M.dd.part4 bs=4096 count=500 skip=26640
# cat /tmp/recover/testfile.10M.dd.part[1-4] & /tmp/recover/ testfile.10M.dd比较一下最终的 testfile.10M.dd 文件和已经备份过的 testfile.10M.orig 文件就会发现，二者完全相同：清单 18. 使用 diff 命令对恢复文件和原文件进行比较# diff /tmp/recover/ testfile.10M.dd /tmp/test/ testfile.10M.orig数据明明存在，但是刚才我们为什么没法使用 debugfs 的 dump 命令将数据恢复出来呢？现在使用 debugfs 的 stat 命令再次查看一下索引节点 14 的信息：清单 19. 再次查看索引节点 &14& 的详细信息# echo "stat &14&" | debugfs /dev/sdb6
debugfs 1.39 (29-May-2006)
Type: regular
Flags: 0x0
Generation:
File ACL: 0
Directory ACL: 0
Blockcount: 20512
Address: 0
ctime: 0x -- Mon Oct 29 20:32:05 2007
atime: 0x -- Mon Oct 29 20:11:01 2007
mtime: 0x -- Mon Oct 29 20:10:29 2007
dtime: 0x -- Mon Oct 29 20:32:05 2007
BLOCKS:(0-11):, (IND):24588, (DIND):25613TOTAL: 14与前面的结果比较一下不难发现，BLOCKS后面的数据说明总块数为 14，而且也没有整个文件所占据的数据块的详细说明了。既然文件的数据全部都没有发生变化，那么间接寻址所使用的那些索引数据块会不会有问题呢？现在我们来查看一下 24588 这个间接索引块中的内容：清单 20. 查看间接索引块 24588 中的内容# dd if=/dev/sdb6 of=block. 24588 bs=4096 count=1 skip=24588
# hexdump block. 24588
0 00 00 0000
0001000显然，这个数据块的内容被全部清零了。debugfs 的dump 命令按照原来的寻址方式试图恢复文件时，所访问到的实际上都是第0 个数据块（引导块）中的内容。这个分区不是可引导分区，因此这个数据块中没有写入任何数据，因此 dump 恢复出来的数据只有前48K是正确的，其后所有的数据全部为0。实际上，ext2 是一种非常优秀的文件系统，在磁盘空间足够的情况下，它总是试图将数据写入到磁盘上的连续数据块中，因此我们可以假定数据是连续存放的，跳过间接索引所占据的 2、2，将从24576 开始的其余 2500 个数据块读出，就能将整个文件完整地恢复出来。但是在磁盘空间有限的情况下，这种假设并不成立，如果系统中磁盘碎片较多，或者同一个块组中已经没有足够大的空间来保存整个文件，那么文件势必会被保存到一些不连续的数据块中，此时上面的方法就无法正常工作了。反之，如果在删除文件的时候能够将间接寻址使用的索引数据块中的信息保存下来，那么不管文件在磁盘上是否连续，就都可以将文件完整地恢复出来了，但是这样就需要修改 ext2 文件系统的实现了。在 ext2 的实现中，与之有关的有两个函数：ext2_free_data 和 ext2_free_branches（都在 fs/ext2/inode.c 中）。2.6 版本内核中这两个函数的实现如下：清单 21. 内核中 ext2_free_data 和 ext2_free_branches 函数的实现814 /**
ext2_free_data - free a list of data blocks
@inode: inode we are dealing with
array of block numbers
points immediately past the end of array
We are freeing all blocks refered from that array (numbers are
stored as little-endian 32-bit) and updating @inode-&i_blocks
appropriately.
824 static inline void ext2_free_data(struct inode *inode, __le32 *p, __le32 *q)
unsigned long block_to_free = 0, count = 0;
for ( ; p & p++) {
nr = le32_to_cpu(*p);
/* accumulate blocks to free if they're contiguous */
if (count == 0)
goto free_
else if (block_to_free == nr - count)
mark_inode_dirty(inode);
ext2_free_blocks (inode, block_to_free, count);
free_this:
block_to_free =
count = 1;
if (count & 0) {
mark_inode_dirty(inode);
ext2_free_blocks (inode, block_to_free, count);
ext2_free_branches - free an array of branches
@inode: inode we are dealing with
array of block numbers
pointer immediately past the end of array
@depth: depth of the branches to free
We are freeing all blocks refered from these branches (numbers are
stored as little-endian 32-bit) and updating @inode-&i_blocks
appropriately.
864 static void ext2_free_branches(struct inode *inode, __le32 *p, __le32 *q, int depth)
struct buffer_head *
if (depth--) {
int addr_per_block = EXT2_ADDR_PER_BLOCK(inode-&i_sb);
for ( ; p & p++) {
nr = le32_to_cpu(*p);
bh = sb_bread(inode-&i_sb, nr);
* A read failure? Report error and clear slot
* (should be rare).
if (!bh) {
ext2_error(inode-&i_sb, "ext2_free_branches",
"Read failure, inode=%ld, block=%ld",
inode-&i_ino, nr);
ext2_free_branches(inode,
(__le32*)bh-&b_data,
(__le32*)bh-&b_data + addr_per_block,
bforget(bh);
ext2_free_blocks(inode, nr, 1);
mark_inode_dirty(inode);
ext2_free_data(inode, p, q);
897 }注意第 832 和 875 这两行就是用来将对应的索引项置为 0 的。将这两行代码注释掉（对于最新版本的内核 2.6.23 可以下载本文给的补丁）并重新编译 ext2 模块，然后重新加载新编译出来的模块，并重复上面的实验，就会发现利用 debugfs 的 dump 命令又可以完美地恢复出整个文件来了。显然，这个补丁并不完善，因为这个补丁中的处理只是保留了索引数据块中的索引节点数据，但是还没有考虑数据块位图的处理，如果对应的数据块没有设置为正在使用的状态，并且刚好这些数据块被重用了，其中的索引节点数据就有可能会被覆盖掉了，这样就彻底没有办法再恢复文件了。感兴趣的读者可以沿用这个思路自行开发一个比较完善的补丁。小结本文介绍了 ext2 文件系统中的一些基本概念和重要数据结构，并通过几个实例介绍如何恢复已经删除的文件，最后通过修改内核中 ext2 文件系统的实现，解决了大文件无法正常恢复的问题。本系列的下一篇文章中，将介绍如何恢复 ext2 文件系统中的一些特殊文件，以及如何恢复整个目录等方面的问题。
下载描述名字大小创建测试文件使用的脚本2KB针对 2.6.23 版本内核解决大文件无法恢复问题的补丁2KB
developerWorks: 登录
标有星（*）号的字段是必填字段。
保持登录。
单击提交则表示您同意developerWorks 的条款和条件。 查看条款和条件。
在您首次登录 developerWorks 时，会为您创建一份个人概要。您的个人概要中的信息（您的姓名、国家/地区，以及公司名称）是公开显示的，而且会随着您发布的任何内容一起显示，除非您选择隐藏您的公司名称。您可以随时更新您的 IBM 帐户。
所有提交的信息确保安全。
选择您的昵称
当您初次登录到 developerWorks 时，将会为您创建一份概要信息，您需要指定一个昵称。您的昵称将和您在 developerWorks 发布的内容显示在一起。昵称长度在 3 至 31 个字符之间。
您的昵称在 developerWorks 社区中必须是唯一的，并且出于隐私保护的原因，不能是您的电子邮件地址。
标有星（*）号的字段是必填字段。
(昵称长度在 3 至 31 个字符之间)
单击提交则表示您同意developerWorks 的条款和条件。 .
所有提交的信息确保安全。
文章、教程、演示，帮助您构建、部署和管理云应用。
立即加入来自 IBM 的专业 IT 社交网络。
免费下载、试用软件产品，构建应用并提升技能。
static.content.url=/developerworks/js/artrating/SITE_ID=10Zone=LinuxArticleID=277028ArticleTitle=如何恢复 Linux 上删除的文件，第 1 部分publish-date=