欧美午夜精品免费观看_中文字幕人妻无码视频1页_免费精品不卡在线播放_在线女同免费观看网站_“内射”的搜索结果_日韩欧美亚洲每日更新在线观看_森川安娜无码视频播放_无码av毛片一区二区

  • WAP手機版 加入收藏  設為首頁
恢復問答

把vmdk文件模擬為塊設備

時間：2019/4/7 15:07:38   作者：成都數據恢復中心   來源：本站原創   閱讀：2808   評論：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文檔

標簽：文件 模擬 設備 
相關評論
不良信息舉報中心成都網警網警110報警服務AAA級互聯網行業信用360網站安全檢測

數據恢復QQ交流群：378664983    站長QQ:958754010


蜀ICP備14015947號-2