‘‘‘
术语规范：
简述：BS指256M，bs指256K
BS：指大小，256M
bs：指大小，256K
SecsPerBS：每BS扇区数
SecsPerbs：每bs扇区数
FRid：文件记录号
FRDs：文件记录在整个LUN上应该的物理扇区号
FRDBS：文件记录在整个LUN上应该的BS号
FRDbs：文件记录在整个LUN上应该的bs号
FRDbsiBS:文件记录所在的bs，在所在BS中的序号
FRDSibs：文件记录所在的扇区，在所在的bs中的序号
SMDid：位图所在的磁盘号
SMBS：位图所在的磁盘的BS号
SMbs：位图所在的磁盘的bs号
SMDs:位图的起始扇区号
SDid：源数据所在的磁盘号
SDBS：源数据所在的BS号
SDbs：源数据所在的bs号
SDs：源数据所在的扇区号
SDSibs：源数据所在的扇区，在所在的bs中的序号
SDbsiBS：源数据所在的bs，在所在的BS中的序号
Mbsi8GM：数据所在bs条目，在8G位图中的序号
MbsiBS：数据所在的bs条目，在当前BS位图中的序号
MBSi8GM：数据所在的BS条目，在8G位图中的序号
‘‘‘
import sys
import os
import struct
import sqlite3
import time
BS = 256 * 1024 * 1024
bs = 256 * 1024
SecsPerBS = BS // 512
SecsPerbs = bs // 512
bs_tnum = 128 * 1024 * 1024
def trans(FRid, MFT_Slice_List):
mft_no_clus = FRid // 8
mft_no_sec = (FRid % 8) * 2
for i in MFT_Slice_List:
if i[0] + i[2] > mft_no_clus:
if i[0] > mft_no_clus:
continue
FRDs = (mft_no_clus - i[0] + i[1]) * 16 + mft_no_sec
break
FRDs += 262208 # DBR pos
return FRDs
def find_FRid_SDbs(FRid):
mftlist = []
FRDS = trans(FRid, MFT_Slice_List)
# cu_mft 是 allv2.db 的cursor
cu_mft.execute(r"select * from mft_info WHERE FRID = %d" % FRid)
rows = cu_mft.fetchall()
# SDid, SDS, FRid 是 row[0], row[1], row[2]
new = 0
for row in rows:
if row[1] % 512 == FRDS % 512: # 扇区号一致
new += 1
SDid = row[0]
SDS = row[1]
mftlist.append([FRid, FRDS, SDid, SDS])
if new != 1: # 所选记录不唯一， 返回空的 mftlist
print("FR(%d), result not found or not only, new = %d, FRDS = %d" % (FRid, new, FRDS))
# os.system("pause")
# pass
return
return mftlist
def find_bs_SMBS(FRDs, SDid, SDs):
SMDBS_list = [] # 位图列表
FRbs = (FRDs // 512)
SDBS = SDs // SecsPerBS
SDbsiBS = (SDs % SecsPerBS) // SecsPerbs
print("FRDs,SDid,SDs is:",FRDs,SDid,SDs)
print("SDbsiBS is %d"%SDbsiBS)
# cu_m 是 map_v2.db 的 cursor
cu_m.execute(r"select * from map_info where v_num = %d" % (FRbs * 512 + 1)) # +1: 是因为v7000 MAP最低位为1，可能表示类型
rows = cu_m.fetchall()
print("rows: ", rows)
os.system("pause")
x = 0
# EM_SMDid, EM_SMBS, EM_Mbsi8GM, EM_FRDS_add_1 = range(4)
for row in rows:
Mbsi8GM = row[2] # 数据所在bs条目，在8G位图中的序号
FRDbsiBS = (FRDs % SecsPerBS) // SecsPerbs
MbsiBS = (Mbsi8GM + 2) % 1024 # 数据所在的bs条目，在当前BS位图中的序号
MBSi8GM = (Mbsi8GM + 2) // 1024 # 数据所在的BS条目，在8G位图中的序号
print("MBSi8GM,SDbsiBS,MbsiBS is", MBSi8GM, SDbsiBS, MbsiBS)
os.system("pause")
if MBSi8GM == 0:
if SDbsiBS == MbsiBS:
x += 1
SMDid = row[0] # 位图所在的磁盘号
SMBS = row[1] # 位图所在的磁盘的BS号
SMDBS_list.append([SMDid, SMBS, 0, SMDid, SMBS])
else:
if SDbsiBS == MbsiBS:
x += 1
SMDid = row[0] # 位图所在的磁盘号
SMBS = row[1] # 位图所在的磁盘的BS号
SMDBS_list.append([SMDid, SMBS, MBSi8GM, SDid, SDBS])
SMDBS_list.append([SMDid, SMBS, 0, SMDid, SMBS])
if x == 0:
print("FRDs:%d result not found!" % FRDs)
# os.system("pause")
# pass
print("line 131 ,x == 0")
return
os.system("pause")
print(SMDBS_list)
return SMDBS_list
#tmp1 writefile to disk
writedisk = False
if writedisk:
fd = open("\\\\.\\physicaldrive3",‘rb+‘)
def update_1Gmap(bsMapList, map1g_list):
SMDid, SMBS, MBSi8GM, SDid, SDBS = bsMapList
SMDs = SMBS * SecsPerBS + 1024
SDbs = SDBS * 1024
smFile = sDisk[SMDid][1] # 位图所在磁盘
sdFile = sDisk[SDid][1] # 数据所在磁盘
# 到指定位图位置，读取 bs = 256K 字节
smFile.seek(SMDs * 512)
mData = smFile.read(bs)
if MBSi8GM == 0: # 8GB 的第一个256K
mapitem = struct.unpack_from("1022Q", mData, 0)
start_sec = 1024
elif MBSi8GM < 32:
# print("MBSi8gm IS",MBSi8GM)
mapitem = struct.unpack_from("1024Q", mData, MBSi8GM * 8192 - 16) # 1024 * 8 代表一个256M
start_sec = 0
else:
return
t = 0
keyMap = SMDid * 1000000 + SMBS * 100 + MBSi8GM
cu.execute(r"INSERT or ignore into MAP values(%d, %d, %d, %d, %d, %d)" % (keyMap, SMDid, SMBS, MBSi8GM, SDid, SDBS))
cx.commit()
# print(keyMap, SMDid, SMBS, MBSi8GM, SDid, SDBS)
# os.system("pause")
for ii in mapitem:
if ii == 3: # 跳过位图为3的
t += 1
continue
FRDbs = (ii - 1) // 512
if FRDbs > bs_tnum:
t += 1
print("FRDBS is too large, FRDbs: %d" % FRDbs)
else:
value1 = (SDbs + t) * SecsPerbs + start_sec # value指应该的bs的扇区位置
value = value1 + (SDid << 48)
# valueT = 0
if map1g_list[FRDbs] != 0 and map1g_list[FRDbs] != value:
print("FRDBS is error, FRDbs: %d,\tmap1g_list[FRDbs]:%08X\tvalue:%08X" % (FRDbs, map1g_list[FRDbs], value))
os.system("pause")
# pass
else:
map1g_list[FRDbs] = value
#tmp1 write file
if writedisk:
fd.seek(FRDbs * 512)
sDisk[SDid][1].seek(value * 512)
tmpdata = sDisk[SDid][1].read(bs)
fd.write()
#tmp write file end
# SMDid, SMBS, MBSi8GM, SDid, SDBS
t += 1
sDisk = []
sDisk.append("")
sDisk.append("")
sDisk.append("")
sDisk.append("")
sDisk.append(["h:\mdisk4.img", 0])
sDisk.append(["g:\mdisk5.img", 0])
sDisk.append(["i:\mdisk6.img", 0])
sDisk.append(["d:\mdisk7.img", 0])
sDisk.append(["e:\mdisk8.img", 0])
sDisk.append(["f:\mdisk9.img", 0])
for disk in sDisk[4:10]:
disk[1] = open(disk[0], ‘rb‘)
cx_mft = sqlite3.connect("f:\zy\\new_mft\\allv2.db")
cu_mft = cx_mft.cursor()
cx_m = sqlite3.connect("F:\\zy\\map\\map_v2.db")
cu_m = cx_m.cursor()
cx = sqlite3.connect("f:\\zy\\map\\256M_to_disk_map.db")
cu = cx.cursor()
cu.execute("""create table if not exists MAP(
mapKey INT PRIMARY KEY NOT NULL,
SMDid int,
SMDBS int,
Mbsi8GM int,
SDid int,
SDDBS int
);
""")
# 打开1GMAP文件，读入LIST
MAP_file = "F:\\zy\\map\\1gmap_1.img"
f_map1g = open(MAP_file, ‘rb+‘)
dmap = f_map1g.read()
map1g_list = list(struct.unpack(‘%dQ‘ % bs_tnum, dmap))
# 前两个256M块
# cu.execute(r"INSERT or ignore into MAP values(%d, %d, %d, %d, %d, %d)" % (40080010, 4, 800, 10, 6, 814))
# cu.execute(r"INSERT or ignore into MAP values(%d, %d, %d, %d, %d, %d)" % (40080000, 4, 800, 0, 4, 800))
tlst = [[4, 800, 10, 6, 814], [4, 800, 0, 4, 800]]
update_1Gmap(tlst[0], map1g_list)
update_1Gmap(tlst[1], map1g_list)
# 解析mft_list 文件
f = open("mft_list.txt", ‘r‘) # 位置在哪？？
d = f.readlines()
MFT_Slice_List = []
for i in d:
t = i.split()
# t[0] 是 VCN 号, t[1] 是 LCN 号, t[2] 是 连续簇数
MFT_Slice_List.append([int(t[0]), int(t[1]), int(t[2])])
# MFT的编号；在LUN中应该的扇区位置；现在所在的磁盘号；现在所在磁盘的扇区位置
# EL_FRid, EL_FRDS, EL_SDid, EL_SDS = range(4)
for i in MFT_Slice_List[2:]:
print("start: ", i)
tt = 0 # 用于累计KB数， 1 KB是一个FR
curFRID = i[0] * 8
curFRID = 1988304 # test1
slice0p = trans(curFRID, MFT_Slice_List) # 要处理的第一个bs片断的起始扇区号
slice0s = 512 - slice0p % 512 # 第一个片断的扇区数
slice0FRnum = slice0s // 2
sliceEnd_s = (i[2] * 16 + slice0p) % 512 # 最后一个片断的扇区数
middle_bs = (i[2] * 16 - slice0s - sliceEnd_s) // 512 # 中间有多少个bs片断
for ii in range(middle_bs + 2):
if ii == 0: # 第一个片断
p = slice0p
start_fr = curFRID
fr_num = slice0FRnum
elif ii == middle_bs + 1: # 最后一个片断
p = ii * 512 - 512 + (slice0p + slice0s)
start_fr = curFRID + slice0FRnum + ii * 256
fr_num = sliceEnd_s // 2
else:
p = ii * 512 - 512 + (slice0p + slice0s)
start_fr = curFRID + slice0FRnum + ii * 256
fr_num = 256
FRDbs = p // 512
if map1g_list[FRDbs] != 0:
continue
isfoundmap = False
for FRid1 in range(start_fr, start_fr + fr_num + 1):
mftlist = find_FRid_SDbs(FRid1) # 在这个函数中，又求了一次 FRDS, ??
if mftlist is None:
continue
else:
SMDBS_list = find_bs_SMBS(mftlist[0][1], mftlist[0][2], mftlist[0][3])
# print("SMDBS_list: ", SMDBS_list)
# SMDBS_list 可能完成多个匹配
if SMDBS_list is None:
break
else:
isfoundmap = True
for lst in SMDBS_list:
# print("********************")
#SMDBS_list = find_bs_SMBS(lst[1], lst[2], lst[3]) # SMDBS_list 可能完成多个匹配
print("lins 293 ",lst)
update_1Gmap(lst, map1g_list)
if isfoundmap:
break;
print("line296")
os.system("pause")
print("line 298")
os.system("pause")
print("end:", time.strftime(‘%Y-%m-%d %H:%M:%S‘, time.localtime(time.time())))
dmap = struct.pack("%dQ" % bs_tnum, *map1g_list)
# 更新map文件
f_map1g.seek(0)
f_map1g.write(dmap)
f_map1g.close()
# cu.execute(r"INSERT or ignore into MAP values(%d, %d, %d, %d, %d, %d)" % (40080010, 4, 800, 10, 6, 814))
# 第一个256M块
# cu.execute(r"INSERT or ignore into MAP values(%d, %d, %d, %d, %d, %d)" % (40080000, 4, 800, 0, 4, 800))
# cx.commit()
# BS_ID含义如下：ABBBBBCC，A表示磁盘ID，BBBBB表示本片断位图在磁盘位置(256M块编号)，CC表示本次处理的256M块的编号(0-31)
# MAP_POS表示:256M的位置，一般位图仍要向后偏移1024个扇区
# BS_ID_indisk表示8G内的256M序号
# SOURCE_POS表示源磁盘的256M的位置
时间： 2024-12-31 05:44:00