• WAP手机版 加入收藏  设为首页
  • 当前位置：首页 > 恢复问答
恢复问答

把vmdk文件模拟为块设备

时间：2019-4-7 15:07:38   作者：成都数据恢复中心   来源：本站原创   阅读：3005   评论：0
内容摘要：目标：基于linux平台，在内核态解析vmdk文件，把文件模拟为块设备，最后可以mount（主要是做一个简单的sparse文件读写，所以很多vmdk格式的内容没有考虑，后面会随着文档列出）环境：Ubuntu8.04linux-2.6.24-24gcc-4.2.4vmdk文件格式分析：注：这里只描述HostedSpars...
目标：基于linux平台，在内核态解析vmdk文件，把文件模拟为块设备，最后可以mount （主要是做一个简单的sparse文件读写，所以很多vmdk格式的内容没有考虑，后面会随着文档列出）

环境：Ubuntu8.04  linux-2.6.24-24  gcc-4.2.4

vmdk文件格式分析：

注：这里只描述Hosted Sparse Extents（所谓的稀疏文件，一开始创建时很小，随着数据的增多而变大）

在我们使用vmware虚拟机创建一个虚拟磁盘时，会提示你是一个single file 还是 多个split file 并且我们是sparse文件 不是flat文件。下面是一个sparse文件的格式



vmdk spec 1.1 给出的
把vmdk文件模拟为块设备 
Hosted Sparse Extent Header （对应上图的Sparse header）
The following example shows the content of a sparse extent’s header from a VMware hosted
product, such as VMware Workstation, VMware Player, VMware ACE, VMware Server, or VMware
GSX Server:
把vmdk文件模拟为块设备 
This structure (struct SparseExtentHeader) needs to be packed. If you use gcc to compile your application, you must use the
keyword __attribute__((__packed__)).
typedef uint64 SectorType;
typedef uint8 Bool;
struct vmdisk_header {
uint32_t version;
uint32_t flags;
int64_t capacity;//代表这个extent的大小，以扇区数表示
int64_t granularity;//一个grain的大小，以扇区数表示
int64_t desc_offset;//描述符的偏移，以扇区为基数
int64_t desc_size; //描述符的大小，以扇区为基数
int32_t num_gtes_per_gte;//graintable的entry数目，规范上是512 就是每个GDE对应的GTE的数目
int64_t rgd_offset;//这里指向的是redundant grain directory的位置
int64_t gd_offset;// 这里指向的是grain directory的位置
int64_t grain_offset;
char filler[1];
char check_bytes[4];
};
通过下面这个图可以找到需要的数据，其中数据都是以扇区为偏移的，在规范的11页有详细的计算方法
把vmdk文件模拟为块设备 
代码主要是根据读取文件来填充header结构体，然后根据header结构体，和上面这张图，来读取相应的位置的数据，如果是写数据，就计算好位置，写进去。
-----------------------------------------------------------------------------------------
代码部分：

vmdk.h //头文件
  1. #define SECTOR_BITS 9
  2. #define SECTOR_SIZE (1 << SECTOR_BITS)
  3. #define SECTOR_MASK (SECTOR_SIZE - 1)
  4. #define L1_BITS (SECTOR_BITS - 3)
  5. #define L1_SIZE (1 << L1_BITS)
  6. #define L1_MASK (L1_SIZE - 1)
  7. #define L2_BITS SECTOR_BITS
  8. #define L2_SIZE (1 << L2_BITS)
  9. #define L2_MASK (L2_SIZE - 1)
  10. #define MIN(x,y) (((x) < (y)) ? (x) : (y))
  11. struct vmdisk_header
  12. {
  13. uint32_t version;
  14. uint32_t flags;
  15. uint64_t capacity;
  16. uint64_t granularity;
  17. uint64_t desc_offset;
  18. uint64_t desc_size;
  19. uint32_t num_gtes_per_gte;
  20. uint64_t rgd_offset;
  21. uint64_t gd_offset;
  22. uint64_t grain_offset;
  23. char filler[1];
  24. char check_bytes[4];
  25. };
复制代码
vmdk.c //主文件
  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/moduleparam.h>
  4. #include <linux/blkdev.h>
  5. #include <linux/fs.h>
  6. #include <linux/bio.h>
  7. #include <linux/kthread.h>
  8. #include <linux/spinlock.h>
  9. #include <linux/types.h>
  10. #include <asm/div64.h>
  11. #include <asm/stat.h>
  12. #include "vmdk.h"
  13. #define KERNEL_SECTOR_SIZE 512
  14. #define _LARGEFILE_SOURCE
  15. #define _LARGEFILE64_SOURCE
  16. #define _FILE_OFFSET_BITS 64
  17. static char *name = NULL;
  18. //static char name_vmdk[30] = "/home/pengpeng/a.vmdk";
  19. struct bio_list {
  20. struct bio *head;
  21. struct bio *tail;
  22. };//直接引用内核中未导出的结构体了
  23. struct vmdk_dev{
  24. struct request_queue *vmdk_queue;
  25. struct gendisk *vmdk_disk;
  26. struct file *fvmdk;
  27. struct task_struct *vmdk_thread;
  28. wait_queue_head_t vmdk_event;
  29. struct bio_list vmdk_bio_list;
  30. uint64_t size;
  31. spinlock_t vmdk_lock;
  32. };
  33. struct block_device_operations vmdk_fops = {
  34. .owner                = THIS_MODULE,
  35. };
  36. static struct vmdk_dev *vmdk_device;
  37. static int vmdk_major;//因为要把vmdk文件模拟为一个块设备，所以需要设备号
  38. static int hardsect_size = 512;
  39. static struct vmdisk_header header4;
  40. static struct cowdisk_header header;
  41. static uint64_t disk_limit;//磁盘容量
  42. static unsigned int granule_size;
  43. static uint32_t *l1dir;//GDE存储位置
  44. static unsigned int cached_l2dir;//代表上一次访问的GDE索引，如果当前访问的位置和上一次位于同一个GDE代表的范围内，就不要读取GTE表格了，直接用上一次读取的GTE表格
  45. static uint32_t l2dir[L2_SIZE];//GTE表格内容 -512项
  46. static struct vmdk_prm {
  47. uint32_t grain_table_size; //对应num_gtes_per_gte
  48. uint32_t sectors_per_grain;//一个grain所包含的扇区数 手册上默认是128 即一个grain是64kB
  49. uint32_t sectors_per_table; //前两项的乘积，就是一个GTE table所代表的扇区数
  50. uint32_t directory_size;//GDE的项数
  51. } vdsk;
  52. //----------了解块设备驱动的应该很熟悉这个吧
  53. static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
  54. {
  55. bio->bi_next = NULL;
  56. if (bl->tail)
  57. bl->tail->bi_next = bio;
  58. else
  59. bl->head = bio;
  60. bl->tail = bio;
  61. }
  62. static inline int bio_list_empty(const struct bio_list *bl)
  63. {
  64. return bl->head == NULL;
  65. }
  66. static inline struct bio *bio_list_pop(struct bio_list *bl)
  67. {
  68. struct bio *bio = bl->head;
  69. if (bio) {
  70. bl->head = bl->head->bi_next;
  71. if (!bl->head)
  72. bl->tail = NULL;
  73. bio->bi_next = NULL;
  74. }
  75. return bio;
  76. }
  77. static void vmdk_add_bio(struct vmdk_dev *dev, struct bio *bio)
  78. {
  79. bio_list_add(&dev->vmdk_bio_list, bio);
  80. }
  81. static struct bio * vmdk_get_bio(struct vmdk_dev *dev)
  82. {
  83. return bio_list_pop(&dev->vmdk_bio_list);
  84. }
  85. //--------------------------------------------------------
  86. //------------从文件的offset偏移处读取length长度的文件，存放到buffer处
  87. static int read_physical(struct file *f, loff_t offset, size_t length, void *buffer)
  88. {
  89. size_t n;
  90. if(f->f_op->llseek(f, offset, SEEK_SET) == (loff_t)-1)
  91. return -1;
  92. n = f->f_op->read(f, buffer, length, &f->f_pos);
  93. if (n < 0) {
  94. printk(KERN_ALERT "read from disk %lld", offset);
  95. return -1;
  96. }

  98. return n;
  99. }
  100. //-----------写到文件的offset处
  101. static int write_physical(struct file *f, loff_t offset, size_t length, void *buffer)
  102. {
  103. size_t n;
  104. if(f->f_op->llseek(f, offset, SEEK_SET) == (loff_t)-1)
  105. return -1;
  106. n = f->f_op->write(f, buffer, length, &f->f_pos);
  107. if (n < 0) {
  108. printk(KERN_ALERT "write to disk %lld", offset);

  110. return -1;
  111. }
  112. //printk(KERN_ALERT "write_physical 0x%x\n", n);
  113. return n;
  114. }
  115. //读取某个GTE表格
  116. static int read_l2dir(struct file *f, size_t offset, int num)
  117. {
  118. return read_physical(f, offset << SECTOR_BITS, sizeof(l2dir[0]) * num, (char *)l2dir) != sizeof(l2dir);
  119. }
  120. //读取GDE
  121. static int read_l1dir(struct file *f, size_t offset, int num)
  122. {
  123. l1dir = kmalloc(sizeof(*l1dir) * num, GFP_KERNEL);
  124. if (!l1dir)
  125. return -1;
  126. return read_physical(f, offset << SECTOR_BITS, sizeof(*l1dir) * num, (char *)l1dir) != (sizeof(*l1dir) * num);
  127. }
  128. //主要是对需要的结构进行一些初始化设置
  129. static int open_disk(struct file *f)
  130. {
  131. char magic[4];
  132. int ret = 0;
  133. int d;
  134. uint64_t  m;
  135. mm_segment_t old_fs;
  136. old_fs = get_fs(); //-------内核中读写文件必须这两句吧
  137. set_fs(KERNEL_DS);//------

  139. if(f->f_op->read(f, magic, sizeof(magic), &f->f_pos) != sizeof(magic)){
  140. printk(KERN_ALERT "error magic\n");
  141. ret = -1;
  142. goto out_set_fs;
  143. }
  144. if (!memcmp(magic, "KDMV", sizeof(magic))) { //----代码其实只实现了vmdk格式
  145. d = 1;
  146. } else if (!memcmp(magic, "COWD", sizeof(magic))) {
  147. d = 2;
  148. } else {
  149. printk(KERN_ALERT "Not vmdk file\n");
  150. ret = -1;
  151. goto out_set_fs;
  152. }
  153. if(d == 1){
  154. if(f->f_op->read(f, (void*)&header4, sizeof(header4), &f->f_pos) != sizeof(header4)){
  155. printk(KERN_ALERT "error header\n");
  156. ret = -1;
  157. goto out_set_fs;
  158. }
  159. granule_size = header4.granularity << SECTOR_BITS;
  160. disk_limit = header4.capacity << SECTOR_BITS;
  161. cached_l2dir = -1;
  162. vdsk.grain_table_size = header4.num_gtes_per_gte;
  163. vdsk.sectors_per_grain = header4.granularity;
  164. vdsk.sectors_per_table = vdsk.grain_table_size * vdsk.sectors_per_grain;

  166. m = header4.capacity + vdsk.sectors_per_table - 1;
  167. do_div(m, vdsk.sectors_per_table);
  168. vdsk.directory_size = m + 1;
  169. //printk(KERN_ALERT "directory _size %d", vdsk.directory_size);
  170. if (read_l1dir(f, header4.rgd_offset, vdsk.directory_size)){
  171. ret = -1;
  172.    goto out_set_fs;
  173. }
  174. }
  175. else{
  176.    if(f->f_op->read(f, (void*)&header, sizeof(header), &f->f_pos) != sizeof(header)){
  177. printk(KERN_ALERT "error header\n");
  178. ret = -1;
  179. goto out_set_fs;
  180. }
  181. granule_size = header.granularity << SECTOR_BITS;
  182. vdsk.sectors_per_grain = header.granularity;
  183. vdsk.grain_table_size = L2_SIZE;
  184. vdsk.sectors_per_table = vdsk.grain_table_size * vdsk.sectors_per_grain;
  185. vdsk.directory_size = L1_SIZE;
  186. disk_limit = header.disk_sectors << SECTOR_BITS;
  187. if (read_l1dir(f, header.l1dir_offset, L1_SIZE))
  188. ret = -1;
  189. goto out_set_fs;
  190. }
  191. out_set_fs: 
  192. set_fs(old_fs);
  193. return ret;
  194. }
  195. static size_t copy_virtual(struct vmdk_prm *dsk, struct file *f, loff_t offset, void *buffer, unsigned long length)
  196. {
  197. unsigned int granule_offset;
  198. unsigned int grain_index;
  199. unsigned int sector_map_idx;
  200. int32_t l;
  201. uint64_t m;
  202. uint32_t n;
  203. l = length;
  204. while(l > 0){
  205. m = offset;
  206. granule_offset = do_div(m, granule_size);
  207. //printk(KERN_ALERT "granule_offset %d\n",granule_offset);
  208. // printk(KERN_ALERT "length %x\n",length);
  209. //length = MIN(length, granule_size - granule_offset);
  210. if(length > granule_size - granule_offset)
  211. length = granule_size - granule_offset;
  212. length = MIN(length, disk_limit - offset);
  213. //printk(KERN_ALERT "length %x\n",length);
  214. m = offset >> SECTOR_BITS;
  215. do_div(m, dsk->sectors_per_table);
  216. sector_map_idx = m;
  217. // printk(KERN_ALERT "sector_map_idx %d\n",sector_map_idx);
  218. if (sector_map_idx >= dsk->directory_size) {
  219. printk(KERN_ALERT "cannot locate grain table for %d in %d\n", sector_map_idx, dsk->directory_size);
  220. return -1;
  221. }
  222. if (l1dir[sector_map_idx] == 0) {
  223. printk(KERN_ALERT "l1zero\n");
  224. goto zero_fill;
  225. }
  226. if (sector_map_idx != cached_l2dir) {
  227. if (read_l2dir(f, l1dir[sector_map_idx], dsk->grain_table_size)) {
  228. printk(KERN_ALERT "read failed\n");
  229. return -1;
  230. }
  231. cached_l2dir = sector_map_idx;
  232. }

  234. m = offset >> SECTOR_BITS;
  235. n = do_div(m, dsk->sectors_per_table);
  236. grain_index = n / dsk->sectors_per_grain;
  237. if (grain_index >= dsk->grain_table_size) {
  238. printk(KERN_ALERT "grain to large\n");
  239. return -1;
  240. }
  241. if (l2dir[grain_index] == 0)
  242. {
  243. //printk(KERN_ALERT "l2zero\n");
  244. goto zero_fill;}
  245. if (read_physical(f, (l2dir[grain_index] << SECTOR_BITS) + granule_offset, length, buffer) != length) {
  246. printk(KERN_ALERT "read error 2\n");
  247. return -1;
  248. }
  249. goto zero_next;
  250. //return length;
  251. zero_fill:
  252. memset(buffer, 0 ,length);
  253. zero_next:
  254. offset += length;
  255. buffer += length;
  256. l -= length;
  257. //return length;
  258. }
  259. return 1;
  260. }
  261. static size_t write_virtual(struct vmdk_prm *dsk, struct file *f, loff_t offset, void *buffer, unsigned long length)
  262. {
  263. unsigned int granule_offset;
  264. unsigned int grain_index;
  265. unsigned int sector_map_idx;
  266. char tail = 1;
  267. loff_t l;
  268. uint64_t m;
  269. int32_t ll;
  270. uint32_t n;
  271. ll = length;//signed  unsigned
  272. while(ll > 0){//一开始没有考虑这个while，几乎导致个人的崩溃
  273. m = offset;
  274. granule_offset = do_div(m, granule_size);
  275. //length = MIN(length, granule_size - granule_offset);
  276. if(length > granule_size - granule_offset)
  277. length = granule_size - granule_offset;
  278. length = MIN(length, disk_limit - offset);
  279. m = offset >> SECTOR_BITS;
  280. do_div(m, dsk->sectors_per_table);
  281. sector_map_idx = m;
  282. if (sector_map_idx >= dsk->directory_size) {
  283. printk(KERN_ALERT "cannot locate grain table for %d in %d\n", sector_map_idx, dsk->directory_size);
  284. return -1;
  285. }
  286. if (l1dir[sector_map_idx] == 0)
  287. return -1;

  289. if (sector_map_idx != cached_l2dir) {
  290. if (read_l2dir(f, l1dir[sector_map_idx], dsk->grain_table_size)) {
  291. printk(KERN_ALERT "read failed\n");
  292. return -1;
  293. }
  294. cached_l2dir = sector_map_idx;
  295. }

  297. m = offset >> SECTOR_BITS;
  298. n = do_div(m, dsk->sectors_per_table);
  299. grain_index = n / dsk->sectors_per_grain;
  300. if (grain_index >= dsk->grain_table_size) {
  301. printk(KERN_ALERT "grain to large\n");
  302. return -1;
  303. }

  305. if (l2dir[grain_index] == 0){
  306. printk(KERN_ALERT "gaga\n");
  307. if((l = f->f_op->llseek(f, 0, SEEK_END)) == (loff_t)-1)
  308. return -1;

  310. l2dir[grain_index] = l >> SECTOR_BITS;
  311. if(write_physical(f, ((l1dir[sector_map_idx] << SECTOR_BITS) + (grain_index << 2)), 4, &l2dir[grain_index]) != 4)
  312. return -1;
  313. if(f->f_op->llseek(f, 64*1024 - 1, SEEK_END) == (loff_t)-1)
  314. return -1;
  315. if(f->f_op->write(f, &tail, 1, &f->f_pos) < 0)
  316. return -1;
  317. }
  318. //printk(KERN_ALERT "write_virtual 0x%x\n", length);
  319. if(write_physical(f, (l2dir[grain_index] << SECTOR_BITS) + granule_offset, length, buffer) != length){
  320. printk(KERN_ALERT "write error\n");
  321. return -1;
  322. }
  323. //return length;
  324. buffer += length;
  325. offset += length;
  326. ll -= length;
  327. }
  328. return 1;
  329. }
  330. static int vmdk_transfer(struct vmdk_dev *dev, unsigned long sector,
  331. unsigned long nsect, char *buffer, int write)
  332. {
  333. loff_t offset = sector*KERNEL_SECTOR_SIZE;
  334. loff_t nbytes = nsect*KERNEL_SECTOR_SIZE;
  335. int ret = 0;
  336. struct file *f = dev->fvmdk;
  337. mm_segment_t old_fs;
  338. if ((offset + nbytes) > dev->size) {
  339. printk (KERN_NOTICE "Beyond-end write %x\n", offset);
  340. printk (KERN_NOTICE "Beyond-end write %x\n", nbytes);
  341. return -1;
  342. }

  344. old_fs = get_fs();
  345. set_fs(KERNEL_DS);

  347. if (write){
  348. ret = (write_virtual(&vdsk, f, offset, buffer, nbytes) > 0);
  349. //ret = -1;

  351. }
  352. else{ 
  353. ret = (copy_virtual(&vdsk, f, offset, buffer, nbytes) > 0);

  355. //printk(KERN_ALERT "read %d", ret); 
  356. }

  358. set_fs(old_fs);
  359. return ((ret == -1) ? 1 : 0);
  360. }
  361. static void vmdk_handle_bio(struct vmdk_dev *dev, struct bio *bio)
  362. {
  363. int i;
  364. struct bio_vec *bvec;
  365. sector_t sector = bio->bi_sector;
  366. int status = 0;
  367. /* Do each segment independently. */
  368. bio_for_each_segment(bvec, bio, i) {
  369. char *buffer = kmap(bio_iovec_idx((bio), (i))->bv_page) + bio_iovec_idx((bio), (i))->bv_offset;
  370. status = vmdk_transfer(dev, sector, bio_cur_sectors(bio),
  371. buffer, bio_data_dir(bio) == WRITE);
  372. if(status)
  373. break;
  374. sector += bio_cur_sectors(bio);
  375. kunmap(bio_iovec_idx((bio), (i))->bv_page);
  376. }
  377. bio_endio(bio, status);
  378. }
  379. static int vmdk_rw_thread(void *data)
  380. {
  381. struct vmdk_dev *dev = data;
  382. struct bio *bio;
  383. set_user_nice(current, -20);
  384. while (!kthread_should_stop() || !bio_list_empty(&dev->vmdk_bio_list)) {
  385. if(wait_event_interruptible(dev->vmdk_event,
  386. !bio_list_empty(&dev->vmdk_bio_list) ||
  387. kthread_should_stop()))
  388. break;
  389. if (bio_list_empty(&dev->vmdk_bio_list))
  390. continue;
  391. spin_lock_irq(&dev->vmdk_lock);
  392. bio = vmdk_get_bio(dev);
  393. spin_unlock_irq(&dev->vmdk_lock);
  394. BUG_ON(!bio);
  395. vmdk_handle_bio(dev, bio);
  396. //bio_endio(bio, (status ? 0 : 1));
  397. }
  398. return 0;
  399. }
  400. static int vmdk_make_request(struct request_queue *q, struct bio *old_bio)
  401. {
  402. struct vmdk_dev *dev = q->queuedata;
  403. int rw = bio_rw(old_bio);
  404. if(rw == READA)
  405. rw = READ;
  406. BUG_ON(!dev || (rw != READ && rw != WRITE));

  408. spin_lock_irq(&dev->vmdk_lock);
  409. vmdk_add_bio(dev, old_bio);
  410. wake_up(&dev->vmdk_event); //这里唤醒内核线程，处理bio
  411. spin_unlock_irq(&dev->vmdk_lock);
  412. return 0;
  413. }
  414. struct vmdk_dev *vmdk_alloc(int i)//块设备驱动的一些初始化工作
  415. {
  416. struct vmdk_dev *dev;
  417. struct gendisk *disk;
  418. dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  419. if (!dev)
  420. goto out;
  421. dev->vmdk_queue = blk_alloc_queue(GFP_KERNEL);
  422. if (!dev->vmdk_queue)
  423. goto out_free_dev;
  424. blk_queue_make_request(dev->vmdk_queue, &vmdk_make_request);//vmdk_make_request 这个函数 当有数据请求是会调用这个函数
  425. blk_queue_hardsect_size(dev->vmdk_queue, hardsect_size);
  426. dev->vmdk_queue->queuedata = dev;

  428. disk = dev->vmdk_disk = alloc_disk(16);
  429. if (!disk)
  430. goto out_free_queue;
  431. dev->vmdk_thread = NULL;
  432. init_waitqueue_head(&dev->vmdk_event);
  433. spin_lock_init(&dev->vmdk_lock);
  434. disk->major = vmdk_major;
  435. disk->first_minor = i * 16;
  436. disk->fops = &vmdk_fops;
  437. disk->private_data = dev;
  438. disk->queue = dev->vmdk_queue;
  439. sprintf(disk->disk_name, "vmdk%c", 'a');
  440. dev->vmdk_thread = kthread_create(vmdk_rw_thread, dev, "vmdk%d", i);
  441. wake_up_process(dev->vmdk_thread);
  442. if(IS_ERR(dev->vmdk_thread))
  443. goto out_free_queue;
  444. return dev;
  445. out_free_queue:
  446. blk_cleanup_queue(dev->vmdk_queue);
  447. out_free_dev:
  448. kfree(dev);
  449. out:
  450. return NULL;
  451. }
  452. static int __init vmdk_init(void)
  453. {
  454. int status;
  455. struct file *f;
  456. vmdk_major = register_blkdev(0, "vmdk");
  457. if(vmdk_major <= 0){
  458. printk(KERN_ALERT "can not get major\n");
  459. return -EBUSY;
  460. }
  461. vmdk_device = vmdk_alloc(0);
  462. if(vmdk_device == NULL){
  463. printk(KERN_ALERT "no mem\n");
  464. goto Enomem;
  465. }

  467. if(!name)
  468. goto freedisk;
  469. vmdk_device->fvmdk = filp_open(name, O_RDWR | O_LARGEFILE, 0664);
  470. if(IS_ERR(vmdk_device->fvmdk))
  471. goto freedisk;
  472. f = vmdk_device->fvmdk;
  473. status = open_disk(f);
  474. if(status < 0)
  475. goto out_close_file;
  476. set_capacity(vmdk_device->vmdk_disk, header4.capacity);
  477. vmdk_device->size = (header4.capacity) << 9;
  478. add_disk(vmdk_device->vmdk_disk);

  480. return 0;
  481. out_close_file:
  482. if(l1dir)
  483. kfree(l1dir);
  484. filp_close(vmdk_device->fvmdk, current->files);
  485. freedisk:
  486. blk_cleanup_queue(vmdk_device->vmdk_queue);
  487. kfree(vmdk_device);
  488. Enomem:
  489. unregister_blkdev(vmdk_major, "vmdk");
  490. return -ENOMEM;

  492. }
  493. static void vmdk_exit(void)
  494. {
  495. kthread_stop(vmdk_device->vmdk_thread); 
  496. filp_close(vmdk_device->fvmdk,current->files);
  497. kfree(l1dir);
  498. blk_cleanup_queue(vmdk_device->vmdk_queue);
  499. del_gendisk(vmdk_device->vmdk_disk);
  500. kfree(vmdk_device);
  501. unregister_blkdev(vmdk_major, "vmdk");
  502. }
  503. module_init(vmdk_init);
  504. module_exit(vmdk_exit);
  505. module_param(name, charp, S_IRUGO);
  506. MODULE_LICENSE("GPL");
复制代码
第一次写这个代码的时候没做什么注释，只是写了个简单的文档，其实是10年1月时写的代码，刚刚来道上混，不懂江湖规矩，大家将就一下吧。现在把代码拿出来拿出来与大家分享，想做点注释，但是又觉得麻烦。因为代码的调用关系很简单。并且也没有内核中那么复杂的merge算法，纯bio操作。如果你了解基本的块设备驱动的编写方法，并且有这方面的工作需求（都是b出来的），读这部分的代码应该很容易的。
写这个代码用了我大约40天的时间，呵呵。很痛苦的经历。虽然代码写的很简单，也不是多完善，功能上确实可以正常运行了。
个人觉得在编写代码中遇到的难点是：
1.如何在内核态读取文件，cu上很多类似的代码都是insmod时读取，但是如果你需要insmod之后读取呢，这时就需要自己建立一个进程上下文的环境，开启内核线程。
2.对vmdk文件格式的把握，然后在代码中严格按照格式去操作，代码中的copy_virtual
和write_virtual是历经磨难
3.对bio结构体的操作，需要kmap和kunmap
4.开启内核线程之后，需要互斥对bio链表的操作，内核发来bio，这时唤醒内核线程对bio操作，所以需要互斥
在加载驱动后，会在/dev下看到vmdka vmdka1之类的设备节点，如果你的vmdk文件是包括文件系统的，这时你可以mount这个设备节点，然后到相应的目录下进行操作就可以了
参考：
ldd3
ldk2
cu上赵磊大侠的文章
qemu源码 vmdk2raw.c
vmdk-loop.c
linux loop驱动
无数次的google
一两次的cu发帖
vm-spec文档

标签：文件 模拟 设备 
上一篇：什么是数据恢复
下一篇：pc3000 处理希捷服务区坏道对系统模块进行偏移Seagate F3.System Files
相关文章
相关评论
本类更新
本类推荐
本类排行
网站地图 - 论坛 - 眉山数据恢复 - 成都数据恢复 - 德阳数据恢复 - 绵阳数据恢复 - 南充数据恢复 - 巴中数据恢复 - 自贡数据恢复 - 宜宾数据恢复 - 泸州数据恢复 - 攀枝花数据恢复 - 广元数据恢复 - 遂宁数据恢复 - 内江数据恢复
不良信息举报中心成都网警网警110报警服务AAA级互联网行业信用360网站安全检测

数据恢复QQ交流群：378664983    站长QQ:958754010


蜀ICP备14015947号-2