修复wrong fs type, bad option, bad superblock

sudo fdisk -l

Disk /dev/sdb：29 GiB，31104958464 字节，60751872 个扇区
单元：扇区 / 1 * 512 = 512 字节
扇区大小(逻辑/物理)：512 字节 / 512 字节
I/O 大小(最小/最佳)：512 字节 / 512 字节
磁盘标签类型：dos
磁盘标识符：0x00000000

设备       启动    起点     末尾     扇区  大小 Id 类型
/dev/sdb1          2048  1050623  1048576  512M 83 Linux
/dev/sdb2       1050624 60751871 59701248 28.5G 83 Linux
但是电脑只显示sdb1加载进来了。

在执行

sudo df -h

/dev/sdb1       504M  3.4M  475M    1% /media/test/1a53898b-0dbe-4363-bce0-c244f136b4

s执行sudo fsck -t ext3 /dev/sdb2
fsck，来自 util-linux 2.31.1
e2fsck 1.44.1 (24-Mar-2018)
ext2fs_open2: 超级块中的幻数有错
fsck.ext3：超级块无效， 尝试备份块
/dev/sdb2 未被彻底卸载，强制进行检查。
第 1 步：检查inode、块和大小
第 2 步：检查目录结构
第 3 步：检查目录连接性
第 4 步：检查引用计数
第 5 步：检查组概要信息
组 #0的可用块计数错误（0，实际为0）。
处理<y>? 是
组 #1的可用块计数错误（0，实际为0）。
处理<y>? 是
组 #2的可用块计数错误（0，实际为0）。
处理<y>? 是
组 #3的可用块计数错误（0，实际为0）。
处理<y>? 是
组 #4的可用块计数错误（0，实际为0）。
处理<y>? 是
组 #5的可用块计数错误（0，实际为0）。
处理<y>? 是
组 #6的可用块计数错误（0，实际为0）。
处理<y>? 是
组 #7的可用块计数错误（0，实际为0）。
处理<y>? 全部回答“yes”
组 #8的可用块计数错误（0，实际为0）。
处理? yes

组 #9的可用块计数错误（0，实际为0）。
处理? yes

组 #10的可用块计数错误（0，实际为0）。
处理? yes

组 #11的可用块计数错误（0，实际为0）。
处理? yes

组 #12的可用块计数错误（0，实际为0）。
处理? yes

组 #13的可用块计数错误（0，实际为0）。
处理? yes

组 #14的可用块计数错误（0，实际为0）。
处理? yes

组 #15的可用块计数错误（0，实际为0）。
处理? yes

组 #16的可用块计数错误（0，实际为0）。
处理? yes

组 #17的可用块计数错误（0，实际为0）。
处理? yes

组 #18的可用块计数错误（0，实际为0）。
处理? yes

组 #19的可用块计数错误（0，实际为0）。
处理? yes

组 #20的可用块计数错误（0，实际为0）。
处理? yes

组 #21的可用块计数错误（0，实际为0）。
处理? yes

组 #22的可用块计数错误（0，实际为0）。
处理? yes

组 #23的可用块计数错误（0，实际为0）。
处理? yes

组 #24的可用块计数错误（0，实际为0）。
处理? yes

组 #25的可用块计数错误（0，实际为0）。
处理? yes

组 #26的可用块计数错误（0，实际为0）。
处理? yes

组 #27的可用块计数错误（0，实际为0）。
处理? yes

组 #28的可用块计数错误（0，实际为0）。
处理? yes

组 #29的可用块计数错误（0，实际为0）。
处理? yes

组 #30的可用块计数错误（0，实际为0）。
处理? yes

组 #31的可用块计数错误（0，实际为0）。
处理? yes

组 #32的可用块计数错误（0，实际为0）。
处理? yes

组 #33的可用块计数错误（0，实际为0）。
处理? yes

组 #34的可用块计数错误（0，实际为0）。
处理? yes

组 #35的可用块计数错误（0，实际为0）。
处理? yes

组 #36的可用块计数错误（0，实际为0）。
处理? yes

组 #37的可用块计数错误（0，实际为0）。
处理? yes

组 #38的可用块计数错误（0，实际为0）。
处理? yes

组 #39的可用块计数错误（0，实际为0）。
处理? yes

组 #40的可用块计数错误（0，实际为0）。
处理? yes

组 #41的可用块计数错误（0，实际为0）。
处理? yes

组 #42的可用块计数错误（0，实际为0）。
处理? yes

组 #43的可用块计数错误（0，实际为0）。
处理? yes

组 #44的可用块计数错误（0，实际为0）。
处理? yes

组 #45的可用块计数错误（0，实际为0）。
处理? yes

组 #46的可用块计数错误（0，实际为0）。
处理? yes

组 #47的可用块计数错误（0，实际为0）。
处理? yes

组 #48的可用块计数错误（0，实际为0）。
处理? yes

组 #49的可用块计数错误（0，实际为0）。
处理? yes

组 #50的可用块计数错误（0，实际为0）。
处理? yes

组 #51的可用块计数错误（0，实际为0）。
处理? yes

组 #52的可用块计数错误（0，实际为0）。
处理? yes

组 #53的可用块计数错误（0，实际为0）。
处理? yes

组 #54的可用块计数错误（0，实际为0）。
处理? yes

组 #55的可用块计数错误（0，实际为0）。
处理? yes

组 #56的可用块计数错误（0，实际为0）。
处理? yes

组 #57的可用块计数错误（0，实际为0）。
处理? yes

组 #58的可用块计数错误（0，实际为0）。
处理? yes

组 #59的可用块计数错误（0，实际为0）。
处理? yes

组 #60的可用块计数错误（0，实际为0）。
处理? yes

组 #61的可用块计数错误（0，实际为0）。
处理? yes

组 #62的可用块计数错误（0，实际为0）。
处理? yes

组 #63的可用块计数错误（0，实际为0）。
处理? yes

组 #64的可用块计数错误（0，实际为0）。
处理? yes

组 #65的可用块计数错误（0，实际为0）。
处理? yes

组 #66的可用块计数错误（0，实际为0）。
处理? yes

组 #67的可用块计数错误（0，实际为0）。
处理? yes

组 #68的可用块计数错误（0，实际为0）。
处理? yes

组 #69的可用块计数错误（0，实际为0）。
处理? yes

组 #70的可用块计数错误（0，实际为0）。
处理? yes

组 #71的可用块计数错误（0，实际为0）。
处理? yes

组 #72的可用块计数错误（0，实际为0）。
处理? yes

组 #73的可用块计数错误（0，实际为0）。
处理? yes

组 #74的可用块计数错误（0，实际为0）。
处理? yes

组 #75的可用块计数错误（0，实际为0）。
处理? yes

组 #76的可用块计数错误（0，实际为0）。
处理? yes

组 #77的可用块计数错误（0，实际为0）。
处理? yes

组 #78的可用块计数错误（0，实际为0）。
处理? yes

组 #79的可用块计数错误（0，实际为0）。
处理? yes

组 #80的可用块计数错误（0，实际为0）。
处理? yes

组 #81的可用块计数错误（0，实际为0）。
处理? yes

组 #82的可用块计数错误（0，实际为0）。
处理? yes

组 #83的可用块计数错误（0，实际为0）。
处理? yes

组 #84的可用块计数错误（0，实际为0）。
处理? yes

组 #85的可用块计数错误（0，实际为0）。
处理? yes

组 #86的可用块计数错误（0，实际为0）。
处理? yes

组 #87的可用块计数错误（0，实际为0）。
处理? yes

组 #88的可用块计数错误（0，实际为0）。
处理? yes

组 #89的可用块计数错误（0，实际为0）。
处理? yes

组 #90的可用块计数错误（0，实际为0）。
处理? yes

组 #91的可用块计数错误（0，实际为0）。
处理? yes

组 #92的可用块计数错误（0，实际为0）。
处理? yes

组 #93的可用块计数错误（0，实际为0）。
处理? yes

组 #94的可用块计数错误（0，实际为0）。
处理? yes

组 #95的可用块计数错误（0，实际为0）。
处理? yes

组 #96的可用块计数错误（0，实际为0）。
处理? yes

组 #97的可用块计数错误（0，实际为0）。
处理? yes

组 #98的可用块计数错误（0，实际为0）。
处理? yes

组 #99的可用块计数错误（0，实际为0）。
处理? yes

组 #100的可用块计数错误（0，实际为0）。
处理? yes

组 #101的可用块计数错误（0，实际为0）。
处理? yes

组 #102的可用块计数错误（0，实际为0）。
处理? yes

组 #103的可用块计数错误（0，实际为0）。
处理? yes

组 #104的可用块计数错误（0，实际为0）。
处理? yes

组 #105的可用块计数错误（0，实际为0）。
处理? yes

组 #106的可用块计数错误（0，实际为0）。
处理? yes

组 #107的可用块计数错误（0，实际为0）。
处理? yes

组 #108的可用块计数错误（0，实际为0）。
处理? yes

组 #109的可用块计数错误（0，实际为0）。
处理? yes

组 #110的可用块计数错误（0，实际为0）。
处理? yes

组 #111的可用块计数错误（0，实际为0）。
处理? yes

组 #112的可用块计数错误（0，实际为0）。
处理? yes

组 #113的可用块计数错误（0，实际为0）。
处理? yes

组 #114的可用块计数错误（0，实际为0）。
处理? yes

组 #115的可用块计数错误（0，实际为0）。
处理? yes

组 #116的可用块计数错误（0，实际为0）。
处理? yes

组 #117的可用块计数错误（0，实际为0）。
处理? yes

组 #118的可用块计数错误（0，实际为0）。
处理? yes

组 #119的可用块计数错误（0，实际为0）。
处理? yes

组 #120的可用块计数错误（0，实际为0）。
处理? yes

组 #121的可用块计数错误（0，实际为0）。
处理? yes

组 #122的可用块计数错误（0，实际为0）。
处理? yes

组 #123的可用块计数错误（0，实际为0）。
处理? yes

组 #126的可用块计数错误（0，实际为0）。
处理? yes

组 #154的可用块计数错误（0，实际为0）。
处理? yes

组 #170的可用块计数错误（0，实际为0）。
处理? yes

组 #174的可用块计数错误（0，实际为0）。
处理? yes

组 #218的可用块计数错误（0，实际为0）。
处理? yes

可用块数错误（0，实际为0）
处理? yes

组 #0的可用inode计数错误（8181，实际为8172）。
处理? yes

组 #8的可用inode计数错误（8192，实际为7743）。
处理? yes

组 #8的目录计数错误（0，实际为115）
处理? yes

组 #14的可用inode计数错误（8192，实际为8165）。
处理? yes

组 #14的目录计数错误（0，实际为15）
处理? yes

组 #15的可用inode计数错误（8192，实际为6113）。
处理? yes

组 #15的目录计数错误（0，实际为356）
处理? yes

组 #16的可用inode计数错误（8192，实际为7490）。
处理? yes

组 #16的目录计数错误（0，实际为28）
处理? yes

组 #48的可用inode计数错误（8192，实际为4350）。
处理? yes

组 #48的目录计数错误（0，实际为101）
处理? yes

组 #49的可用inode计数错误（8192，实际为5736）。
处理? yes

组 #49的目录计数错误（0，实际为69）
处理? yes

组 #50的可用inode计数错误（8192，实际为5127）。
处理? yes

组 #50的目录计数错误（0，实际为227）
处理? yes

组 #51的可用inode计数错误（8192，实际为5479）。
处理? yes

组 #51的目录计数错误（0，实际为356）
处理? yes

组 #52的可用inode计数错误（8192，实际为5430）。
处理? yes

组 #52的目录计数错误（0，实际为370）
处理? yes

组 #53的可用inode计数错误（8192，实际为5427）。
处理? yes

组 #53的目录计数错误（0，实际为456）
处理? yes

组 #54的可用inode计数错误（8192，实际为5147）。
处理? yes

组 #54的目录计数错误（0，实际为386）
处理? yes

组 #55的可用inode计数错误（8192，实际为5582）。
处理? yes

组 #55的目录计数错误（0，实际为217）
处理? yes

组 #56的可用inode计数错误（8192，实际为5940）。
处理? yes

组 #56的目录计数错误（0，实际为257）
处理? yes

组 #57的可用inode计数错误（8192，实际为5948）。
处理? yes

组 #57的目录计数错误（0，实际为166）
处理? yes

组 #58的可用inode计数错误（8192，实际为5951）。
处理? yes

组 #58的目录计数错误（0，实际为226）
处理? yes

组 #59的可用inode计数错误（8192，实际为5860）。
处理? yes

组 #59的目录计数错误（0，实际为263）
处理? yes

组 #60的可用inode计数错误（8192，实际为5945）。
处理? yes

组 #60的目录计数错误（0，实际为166）
处理? yes

组 #61的可用inode计数错误（8192，实际为5961）。
处理? yes

组 #61的目录计数错误（0，实际为150）
处理? yes

组 #62的可用inode计数错误（8192，实际为5889）。
处理? yes

组 #62的目录计数错误（0，实际为247）
处理? yes

组 #63的可用inode计数错误（8192，实际为5868）。
处理? yes

组 #63的目录计数错误（0，实际为161）
处理? yes

组 #64的可用inode计数错误（8192，实际为5431）。
处理? yes

组 #64的目录计数错误（0，实际为230）
处理? yes

组 #65的可用inode计数错误（8192，实际为5423）。
处理? yes

组 #65的目录计数错误（0，实际为283）
处理? yes

组 #66的可用inode计数错误（8192，实际为5187）。
处理? yes

组 #66的目录计数错误（0，实际为73）
处理? yes

组 #67的可用inode计数错误（8192，实际为5425）。
处理? yes

组 #67的目录计数错误（0，实际为100）
处理? yes

组 #68的可用inode计数错误（8192，实际为5437）。
处理? yes

组 #68的目录计数错误（0，实际为90）
处理? yes

组 #69的可用inode计数错误（8192，实际为5446）。
处理? yes

组 #69的目录计数错误（0，实际为44）
处理? yes

组 #70的可用inode计数错误（8192，实际为5414）。
处理? yes

组 #70的目录计数错误（0，实际为98）
处理? yes

组 #71的可用inode计数错误（8192，实际为5348）。
处理? yes

组 #71的目录计数错误（0，实际为72）
处理? yes

组 #72的可用inode计数错误（8192，实际为5390）。
处理? yes

组 #72的目录计数错误（0，实际为72）
处理? yes

组 #73的可用inode计数错误（8192，实际为5424）。
处理? yes

组 #73的目录计数错误（0，实际为103）
处理? yes

组 #74的可用inode计数错误（8192，实际为5324）。
处理? yes

组 #74的目录计数错误（0，实际为332）
处理? yes

组 #75的可用inode计数错误（8192，实际为5431）。
处理? yes

组 #75的目录计数错误（0，实际为121）
处理? yes

组 #76的可用inode计数错误（8192，实际为5428）。
处理? yes

组 #76的目录计数错误（0，实际为190）
处理? yes

组 #77的可用inode计数错误（8192，实际为5431）。
处理? yes

组 #77的目录计数错误（0，实际为43）
处理? yes

组 #78的可用inode计数错误（8192，实际为5430）。
处理? yes

组 #78的目录计数错误（0，实际为93）
处理? yes

组 #79的可用inode计数错误（8192，实际为5412）。
处理? yes

组 #79的目录计数错误（0，实际为68）
处理? yes

组 #80的可用inode计数错误（8192，实际为5424）。
处理? yes

组 #80的目录计数错误（0，实际为89）
处理? yes

组 #81的可用inode计数错误（8192，实际为5427）。
处理? yes

组 #81的目录计数错误（0，实际为121）
处理? yes

组 #82的可用inode计数错误（8192，实际为3394）。
处理? yes

组 #82的目录计数错误（0，实际为286）
处理? yes

组 #83的可用inode计数错误（8192，实际为5414）。
处理? yes

组 #83的目录计数错误（0，实际为331）
处理? yes

组 #84的可用inode计数错误（8192，实际为5349）。
处理? yes

组 #84的目录计数错误（0，实际为218）
处理? yes

组 #85的可用inode计数错误（8192，实际为4696）。
处理? yes

组 #85的目录计数错误（0，实际为480）
处理? yes

组 #86的可用inode计数错误（8192，实际为4802）。
处理? yes

组 #86的目录计数错误（0，实际为485）
处理? yes

组 #87的可用inode计数错误（8192，实际为6086）。
处理? yes

组 #87的目录计数错误（0，实际为575）
处理? yes

组 #88的可用inode计数错误（8192，实际为5309）。
处理? yes

组 #88的目录计数错误（0，实际为438）
处理? yes

组 #89的可用inode计数错误（8192，实际为4660）。
处理? yes

组 #89的目录计数错误（0，实际为285）
处理? yes

组 #90的可用inode计数错误（8192，实际为5196）。
处理? yes

组 #90的目录计数错误（0，实际为37）
处理? yes

组 #91的可用inode计数错误（8192，实际为1245）。
处理? yes

组 #91的目录计数错误（0，实际为37）
处理? yes

组 #92的可用inode计数错误（8192，实际为5406）。
处理? yes

组 #92的目录计数错误（0，实际为186）
处理? yes

组 #93的可用inode计数错误（8192，实际为5254）。
处理? yes

组 #93的目录计数错误（0，实际为140）
处理? yes

组 #94的可用inode计数错误（8192，实际为5417）。
处理? yes

组 #94的目录计数错误（0，实际为158）
处理? yes

组 #95的可用inode计数错误（8192，实际为2631）。
处理? yes

组 #95的目录计数错误（0，实际为18）
处理? yes

组 #96的可用inode计数错误（8192，实际为5384）。
处理? yes

组 #96的目录计数错误（0，实际为277）
处理? yes

组 #97的可用inode计数错误（8192，实际为5276）。
处理? yes

组 #97的目录计数错误（0，实际为333）
处理? yes

组 #98的可用inode计数错误（8192，实际为5161）。
处理? yes

组 #98的目录计数错误（0，实际为233）
处理? yes

组 #99的可用inode计数错误（8192，实际为5397）。
处理? yes

组 #99的目录计数错误（0，实际为346）
处理? yes

组 #100的可用inode计数错误（8192，实际为5291）。
处理? yes

组 #100的目录计数错误（0，实际为541）
处理? yes

组 #101的可用inode计数错误（8192，实际为5350）。
处理? yes

组 #101的目录计数错误（0，实际为449）
处理? yes

组 #102的可用inode计数错误（8192，实际为5347）。
处理? yes

组 #102的目录计数错误（0，实际为354）
处理? yes

组 #103的可用inode计数错误（8192，实际为5350）。
处理? yes

组 #103的目录计数错误（0，实际为346）
处理? yes

组 #104的可用inode计数错误（8192，实际为5333）。
处理? yes

组 #104的目录计数错误（0，实际为348）
处理? yes

组 #105的可用inode计数错误（8192，实际为5925）。
处理? yes

组 #105的目录计数错误（0，实际为154）
处理? yes

组 #106的可用inode计数错误（8192，实际为7214）。
处理? yes

组 #106的目录计数错误（0，实际为41）
处理? yes

组 #107的可用inode计数错误（8192，实际为6037）。
处理? yes

组 #107的目录计数错误（0，实际为340）
处理? yes

组 #108的可用inode计数错误（8192，实际为8185）。
处理? yes

组 #108的目录计数错误（0，实际为7）
处理? yes

组 #120的可用inode计数错误（8192，实际为6126）。
处理? yes

组 #120的目录计数错误（0，实际为176）
处理? yes

组 #121的可用inode计数错误（8192，实际为7782）。
处理? yes

组 #121的目录计数错误（0，实际为57）
处理? yes

组 #126的可用inode计数错误（8192，实际为7487）。
处理? yes

组 #126的目录计数错误（0，实际为343）
处理? yes

组 #154的可用inode计数错误（8192，实际为8191）。
处理? yes

组 #154的目录计数错误（0，实际为1）
处理? yes

组 #170的可用inode计数错误（8192，实际为8191）。
处理? yes

组 #170的目录计数错误（0，实际为1）
处理? yes

组 #174的可用inode计数错误（8192，实际为8081）。
处理? yes

组 #174的目录计数错误（0，实际为45）
处理? yes

组 #218的可用inode计数错误（8192，实际为8191）。
处理? yes

组 #218的目录计数错误（0，实际为1）
处理? yes

可用inode数错误（1867765，实际为1688473）
处理? yes

/dev/sdb2：***** 文件系统已修改 *****
/dev/sdb2：179303/1867776 文件（5.8% 为非连续的）， 1727136/7462656 块

sudo fsck -t ext3 /dev/sdb2
fsck，来自 util-linux 2.31.1
e2fsck 1.44.1 (24-Mar-2018)
/dev/sdb2：没有问题，179303/1867776 文件，1727136/7462656 块