把vmdk文件模拟为块设备

木叉叉木大

不是高手，代码很搓，第一次发出自己的内容来，希望大家指教 代码部分的排版比较乱，直接从博客上copy过来的，不会用wordpress啊

目标：基于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 给出的

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:

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页有详细的计算方法

代码主要是根据读取文件来填充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. }
    
97. 
    
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);
     
109. 
     
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);//------
     
138. 
     
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;
     
165. 
     
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. }
     
233. 
     
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;
     
288. 
     
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. }
     
296. 
     
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. }
     
304. 
     
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;
     
309. 
     
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. }
     
343. 
     
344. old_fs = get_fs();
     
345. set_fs(KERNEL_DS);
     
346. 
     
347. if (write){
     
348. ret = (write_virtual(&vdsk, f, offset, buffer, nbytes) > 0);
     
349. //ret = -1;
     
350. 
     
351. }
     
352. else{
     
353. ret = (copy_virtual(&vdsk, f, offset, buffer, nbytes) > 0);
     
354. 
     
355. //printk(KERN_ALERT "read %d", ret);
     
356. }
     
357. 
     
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));
     
407. 
     
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;
     
427. 
     
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. }
     
466. 
     
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);
     
479. 
     
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;
     
491. 
     
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文档

almeydifer

我觉得楼主发这个贴很有意义呀，不过最好能够把文字在梳理一遍，这样可读性会更强。

顺便问一下楼主，GDE和GTE是用来干什么用的呢？是用来在spare file里实现动态增长的核心数据结构吗？

木叉叉木大

回复 2# almeydifer


    GDE GTE 其实和linux的页表原理差不多   因为我们平时虚拟机里面的操作系统所用的数据 都是存储在创建的那个大文件里面 ，其实就是那个大文件就是一个磁盘数据+磁盘信息+数据定位信息等
你如果要访问某个位置的数据，首先计算位于哪个GDE 然后计算位于哪个GTE entry  然后再计算具体位置  。如果是写的话，也是和读一样，因为是sparse文件，如果要写入的地方，在GTE entry中是空的，
那么说明需要增长sparse文件，代码中是往文件尾追加64K（我觉得这里可能不是很好的实现方式，敬请指正，为什么追加64k，是因为一个GTE entry 默认代表128个扇区 也就是64K），直到增大到sparse
文件描述符所指名的capacity为止。

    我有点懒得整理了，呵呵。其实完全不用vmdk 你可以自己创建一个flat格式的文件，然后把它模拟为一个块设备。

almeydifer

回复 3# 木叉叉木大


    谢谢啦。打听一下，您做这个是自己的爱好，还是工作/科研的需要呢？

木叉叉木大

回复 4# almeydifer


This is the detail. The goal is to port the last code to colinux , in order to make colinux boot from sparse file not just flat file. And I really did that.
But I do not know whether it is commercialized,because i quit the job to take further study.If possible , i will also share with people the porting code.

almeydifer

回复 5# 木叉叉木大

谢谢您的回复呀。

我有个问题就是：为什么colinux要用到spare file?

我的理解是：spare file虽然可以容量动态增长，节省空间，但是在传统的旋转磁盘上，这种方式会造成磁盘碎片，如果此时有多个虚拟机或者OS instances同时做磁盘I/O，性能会更加变得难以分析或者理解。

木叉叉木大

sorry, I do not have the enough knowledge to answer your question about the performance. becasue the original colinux vm machine only support flat file.The size of flat file do not change whether you write to the flat file or not.

As we all know, vmware ,qemu or virtualbox all support sparse file in order to save space.

I am a newbie. The manager ask me to do that,and what I care is how to make it.

The author of colinux gaveme a suggestion to porting the sparse code in windows platform not modifying the linux kernel ,and in this way the switch between linux and windows will take less consuption of system resource. But I modified the linux kernel just for no knowledge of windows platform.

chenrvmldd

回复 1# 木叉叉木大


    先Mark一下，到时候再看！

Godbach

回复 1# 木叉叉木大


    感谢 LZ  分享

almeydifer

sorry, I do not have the enough knowledge to answer your question about the performance. becasue the ...
木叉叉木大 发表于 2011-07-08 10:26

嗯，没关系，这么说来colinux应该是在pc上取代VMware workstation的一个较轻量级的方案啦，是应该用sparse file。