gwj / at91sam9263 · Commits

Commit a3fb0cf9072c4aa89776526592b359b7caea1bb9

Authored by bellard
1 parent ea2384d3

removed unneeded tools 


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@1038 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 4 changed files with 0 additions and 492 deletions
cow.h deleted 100644 → 0
  View file @ea2384d
1   -/* user mode linux compatible COW file */
2   -#define COW_MAGIC 0x4f4f4f4d /* MOOO */
3   -#define COW_VERSION 2
4   -
5   -struct cow_header_v2 {
6   - uint32_t magic;
7   - uint32_t version;
8   - char backing_file[1024];
9   - int32_t mtime;
10   - uint64_t size;
11   - uint32_t sectorsize;
12   -};
13   -
qemu-mkcow.c deleted 100644 → 0
  View file @ea2384d
1   -/*
2   - * create a COW disk image
3   - *
4   - * Copyright (c) 2003 Fabrice Bellard
5   - *
6   - * Permission is hereby granted, free of charge, to any person obtaining a copy
7   - * of this software and associated documentation files (the "Software"), to deal
8   - * in the Software without restriction, including without limitation the rights
9   - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10   - * copies of the Software, and to permit persons to whom the Software is
11   - * furnished to do so, subject to the following conditions:
12   - *
13   - * The above copyright notice and this permission notice shall be included in
14   - * all copies or substantial portions of the Software.
15   - *
16   - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17   - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18   - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19   - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20   - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21   - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22   - * THE SOFTWARE.
23   - */
24   -#include <stdlib.h>
25   -#include <stdio.h>
26   -#include <stdarg.h>
27   -#include <string.h>
28   -#include <getopt.h>
29   -#include <inttypes.h>
30   -#include <unistd.h>
31   -#include <fcntl.h>
32   -#include <signal.h>
33   -#include <time.h>
34   -#include <sys/time.h>
35   -#include <errno.h>
36   -#include <sys/stat.h>
37   -#include <netinet/in.h>
38   -
39   -#include "cow.h"
40   -
41   -#include "bswap.h"
42   -
43   -int cow_create(int cow_fd, const char *image_filename,
44   - int64_t image_sectors)
45   -{
46   - struct cow_header_v2 cow_header;
47   - int fd;
48   - struct stat st;
49   -
50   - memset(&cow_header, 0, sizeof(cow_header));
51   - cow_header.magic = htonl(COW_MAGIC);
52   - cow_header.version = htonl(COW_VERSION);
53   - if (image_filename) {
54   - fd = open(image_filename, O_RDONLY);
55   - if (fd < 0) {
56   - perror(image_filename);
57   - exit(1);
58   - }
59   - image_sectors = lseek64(fd, 0, SEEK_END);
60   - if (fstat(fd, &st) != 0) {
61   - close(fd);
62   - return -1;
63   - }
64   - close(fd);
65   - image_sectors /= 512;
66   - cow_header.mtime = htonl(st.st_mtime);
67   - realpath(image_filename, cow_header.backing_file);
68   - }
69   - cow_header.sectorsize = htonl(512);
70   - cow_header.size = image_sectors * 512;
71   -#ifndef WORDS_BIGENDIAN
72   - cow_header.size = bswap64(cow_header.size);
73   -#endif
74   - write(cow_fd, &cow_header, sizeof(cow_header));
75   - /* resize to include at least all the bitmap */
76   - ftruncate(cow_fd, sizeof(cow_header) + ((image_sectors + 7) >> 3));
77   - lseek(cow_fd, 0, SEEK_SET);
78   - return 0;
79   -}
80   -
81   -void help(void)
82   -{
83   - printf("qemu-mkcow version " QEMU_VERSION ", Copyright (c) 2003 Fabrice Bellard\n"
84   - "usage: qemu-mkcow [-h] [-f disk_image] cow_image [cow_size]\n"
85   - "Create a Copy On Write disk image from an optional raw disk image\n"
86   - "\n"
87   - "-f disk_image set the raw disk image name\n"
88   - "cow_image the created cow_image\n"
89   - "cow_size the create cow_image size in MB if no raw disk image is used\n"
90   - "\n"
91   - "Once the cow_image is created from a raw disk image, you must not modify the original raw disk image\n"
92   - );
93   - exit(1);
94   -}
95   -
96   -int main(int argc, char **argv)
97   -{
98   - const char *image_filename, *cow_filename;
99   - int cow_fd, c, nb_args, simple_image;
100   - int64_t image_size;
101   -
102   - image_filename = NULL;
103   - image_size = 0;
104   - simple_image = 0;
105   - for(;;) {
106   - c = getopt(argc, argv, "hf:s");
107   - if (c == -1)
108   - break;
109   - switch(c) {
110   - case 'h':
111   - help();
112   - break;
113   - case 'f':
114   - image_filename = optarg;
115   - break;
116   - case 's':
117   - simple_image = 1;
118   - break;
119   - }
120   - }
121   - if (!image_filename)
122   - nb_args = 2;
123   - else
124   - nb_args = 1;
125   - if (optind + nb_args != argc)
126   - help();
127   -
128   - cow_filename = argv[optind];
129   - if (nb_args == 2) {
130   - image_size = (int64_t)atoi(argv[optind + 1]) * 2 * 1024;
131   - }
132   -
133   - cow_fd = open(cow_filename, O_RDWR | O_CREAT | O_TRUNC | O_LARGEFILE, 0644);
134   - if (!cow_fd < 0)
135   - return -1;
136   - if (simple_image) {
137   - ftruncate64(cow_fd, image_size * 512);
138   - } else {
139   - if (cow_create(cow_fd, image_filename, image_size) < 0) {
140   - fprintf(stderr, "%s: error while formating\n", cow_filename);
141   - exit(1);
142   - }
143   - }
144   - close(cow_fd);
145   - return 0;
146   -}
vmdk.h deleted 100644 → 0
  View file @ea2384d
1   -/*
2   - Copyright (C) Matthew Chapman 2003
3   -
4   - This program is free software; you can redistribute it and/or modify
5   - it under the terms of the GNU General Public License as published by
6   - the Free Software Foundation; either version 2 of the License, or
7   - (at your option) any later version.
8   -
9   - This program is distributed in the hope that it will be useful,
10   - but WITHOUT ANY WARRANTY; without even the implied warranty of
11   - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12   - GNU General Public License for more details.
13   -
14   - You should have received a copy of the GNU General Public License
15   - along with this program; if not, write to the Free Software
16   - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17   -*/
18   -
19   -#define SECTOR_BITS 9
20   -#define SECTOR_SIZE (1 << SECTOR_BITS)
21   -#define SECTOR_MASK (SECTOR_SIZE - 1)
22   -
23   -#define L1_BITS (SECTOR_BITS - 3)
24   -#define L1_SIZE (1 << L1_BITS)
25   -#define L1_MASK (L1_SIZE - 1)
26   -
27   -#define L2_BITS SECTOR_BITS
28   -#define L2_SIZE (1 << L2_BITS)
29   -#define L2_MASK (L2_SIZE - 1)
30   -
31   -#define MIN(x,y) (((x) < (y)) ? (x) : (y))
32   -
33   -struct cowdisk_header
34   -{
35   - uint32_t version;
36   - uint32_t flags;
37   - uint32_t disk_sectors;
38   - uint32_t granularity;
39   - uint32_t l1dir_offset;
40   - uint32_t l1dir_size;
41   - uint32_t file_sectors;
42   - uint32_t cylinders;
43   - uint32_t heads;
44   - uint32_t sectors_per_track;
45   -};
46   -
47   -struct cowdisk_header2
48   -{
49   - uint32_t parent_ts;
50   - uint32_t timestamp;
51   -};
52   -
53   -/* based on vdk 3.1 10-11-2003 by Ken Kato */
54   -
55   -struct vmdisk_header
56   -{
57   - uint32_t version;
58   - uint32_t flags;
59   -
60   - int64_t capacity;
61   - int64_t granularity;
62   - int64_t desc_offset;
63   - int64_t desc_size;
64   - int32_t num_gtes_per_gte;
65   - int64_t rgd_offset;
66   - int64_t gd_offset;
67   - int64_t grain_offset;
68   -
69   - char filler[1];
70   -
71   - char check_bytes[4];
72   -};
vmdk2raw.c deleted 100644 → 0
  View file @ea2384d
1   -/*
2   - vmdk2raw: convert vmware images to raw disk images
3   - Copyright (C) Net Integration Technologies 2004
4   - Copyright (C) Matthew Chapman 2003
5   -
6   - This program is free software; you can redistribute it and/or modify
7   - it under the terms of the GNU General Public License as published by
8   - the Free Software Foundation; either version 2 of the License, or
9   - (at your option) any later version.
10   -
11   - This program is distributed in the hope that it will be useful,
12   - but WITHOUT ANY WARRANTY; without even the implied warranty of
13   - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14   - GNU General Public License for more details.
15   -
16   - You should have received a copy of the GNU General Public License
17   - along with this program; if not, write to the Free Software
18   - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19   -*/
20   -
21   -#include <stdlib.h>
22   -#include <stdio.h>
23   -#include <unistd.h>
24   -#include <fcntl.h>
25   -#include <inttypes.h>
26   -#include <sys/types.h>
27   -#include <string.h>
28   -#include <sys/stat.h>
29   -#include <errno.h>
30   -#include "vmdk.h"
31   -#include "config-host.h"
32   -
33   -static struct cowdisk_header header;
34   -static struct vmdisk_header header4;
35   -static off64_t disk_limit;
36   -static unsigned int granule_size;
37   -static uint32_t *l1dir;
38   -
39   -static unsigned int cached_l2dir;
40   -static uint32_t l2dir[L2_SIZE];
41   -
42   -static struct vmdk_prm {
43   - uint32_t grain_table_size;
44   - uint32_t sectors_per_grain;
45   - uint32_t sectors_per_table;
46   - uint32_t directory_size;
47   -} vdsk;
48   -
49   -static size_t read_physical(int fd, off64_t offset, size_t length, void *buffer)
50   -{
51   - size_t n;
52   -
53   - if (lseek64(fd, offset, SEEK_SET) == -1) {
54   - printf(" error trying to seek lseek to %lld", offset);
55   - return -1;
56   - }
57   -
58   - n = read(fd, buffer, length);
59   -
60   - if (n == -1) {
61   - printf("read from disk %lld", offset);
62   - return -1;
63   - }
64   -
65   - return n;
66   -}
67   -
68   -static int read_l1dir(int fd, size_t offset, int num)
69   -{
70   - l1dir = malloc(sizeof(*l1dir) * num);
71   - if (!l1dir)
72   - return -1;
73   - return read_physical(fd, offset << SECTOR_BITS, sizeof(*l1dir) * num, (char *)l1dir) != (sizeof(*l1dir) * num);
74   -}
75   -
76   -static int read_l2dir(int fd, size_t offset, int num)
77   -{
78   - return read_physical(fd, offset << SECTOR_BITS, sizeof(l2dir[0]) * num, (char *)l2dir) != sizeof(l2dir);
79   -}
80   -
81   -static size_t copy_virtual(struct vmdk_prm *dsk, int in_fd, int out_fd, off64_t offset, void *buffer, size_t length)
82   -{
83   -
84   - unsigned int granule_offset;
85   - unsigned int grain_index;
86   - unsigned int sector_map_idx;
87   -
88   - granule_offset = offset % granule_size;
89   - length = MIN(length, granule_size - granule_offset);
90   - length = MIN(length, disk_limit - offset);
91   -
92   - sector_map_idx = (offset >> SECTOR_BITS) / dsk->sectors_per_table;
93   -
94   - if (sector_map_idx >= dsk->directory_size) {
95   - fprintf(stderr, "cannot locate grain table for %d in %d\n", sector_map_idx, dsk->directory_size);
96   - return -1;
97   - }
98   -
99   - if (l1dir[sector_map_idx] == 0)
100   - goto zero_fill;
101   -
102   - if (sector_map_idx != cached_l2dir) {
103   - if (read_l2dir(in_fd, l1dir[sector_map_idx], dsk->grain_table_size)) {
104   - fprintf(stderr, "read failed\n");
105   - return -1;
106   - }
107   - cached_l2dir = sector_map_idx;
108   - }
109   -
110   - grain_index = ((offset >> SECTOR_BITS) % dsk->sectors_per_table) / dsk->sectors_per_grain;
111   -
112   - if (grain_index >= dsk->grain_table_size) {
113   - fprintf(stderr, "grain to large");
114   - return -1;
115   - }
116   -
117   - if (l2dir[grain_index] == 0)
118   - goto zero_fill;
119   -
120   - if (read_physical(in_fd, (l2dir[grain_index] << SECTOR_BITS) + granule_offset, length, buffer) != length) {
121   - fprintf(stderr, "read error 2\n");
122   - return -1;
123   - }
124   -
125   - write(out_fd, buffer, length);
126   - return length;
127   -
128   -zero_fill:
129   - /* the last chunk of the file can not be sparse
130   - * or the file will be truncated */
131   - if (offset + length >= disk_limit) {
132   - if (lseek64(out_fd, length-1, SEEK_CUR) == (off_t)-1)
133   - perror("lseek");
134   - /* write the last NULL byte instead of seeking */
135   - const char nil = 0;
136   - write(out_fd, &nil, 1);
137   - } else {
138   - if (lseek64(out_fd, length, SEEK_CUR) == (off_t)-1)
139   - perror("lseek");
140   - }
141   - return length;
142   -}
143   -
144   -static int open_vmdk4(int fd)
145   -{
146   - if (read(fd, &header4, sizeof(header4)) != sizeof(header4)) {
147   - perror("read from disk");
148   - return -1;
149   - }
150   -
151   - granule_size = header4.granularity << SECTOR_BITS;
152   - disk_limit = header4.capacity << SECTOR_BITS;
153   -
154   - cached_l2dir = -1;
155   - vdsk.grain_table_size = header4.num_gtes_per_gte;
156   - vdsk.sectors_per_grain = header4.granularity;
157   - vdsk.sectors_per_table = vdsk.grain_table_size * vdsk.sectors_per_grain;
158   - vdsk.directory_size = (header4.capacity + vdsk.sectors_per_table - 1) / vdsk.sectors_per_table + 1;
159   -
160   - if (read_l1dir(fd, header4.rgd_offset, vdsk.directory_size))
161   - return -1;
162   -
163   - return 0;
164   -
165   -}
166   -
167   -static int open_vmdk3(int fd)
168   -{
169   - if (read(fd, &header, sizeof(header)) != sizeof(header)) {
170   - perror("read from disk\n");
171   - return -1;
172   - }
173   - granule_size = header.granularity << SECTOR_BITS;
174   - vdsk.sectors_per_grain = header.granularity;
175   - vdsk.grain_table_size = L2_SIZE;
176   - vdsk.sectors_per_table = vdsk.grain_table_size * vdsk.sectors_per_grain;
177   - vdsk.directory_size = L1_SIZE;
178   - if (read_l1dir(fd, header.l1dir_offset, L1_SIZE))
179   - return -1;
180   -
181   - disk_limit = header.disk_sectors << SECTOR_BITS;
182   -
183   - return fd;
184   -}
185   -
186   -static int open_vmdk(const char *filename)
187   -{
188   - int fd = open(filename, O_RDONLY | O_LARGEFILE);
189   - if (fd == -1) {
190   - perror(filename);
191   - return -1;
192   - }
193   -
194   - char magic[4];
195   - if (read(fd, &magic, sizeof(magic)) != sizeof(magic)) {
196   - perror("read from disk");
197   - return -1;
198   - }
199   -
200   - if (!memcmp(magic, "KDMV", sizeof(magic))) {
201   - open_vmdk4(fd);
202   - } else if (!memcmp(magic, "COWD", sizeof(magic))) {
203   - open_vmdk3(fd);
204   - } else {
205   - fprintf(stderr, "%s is not a VMware virtual disk image\n", filename);
206   - return -1;
207   - }
208   -
209   - cached_l2dir = -1;
210   - return fd;
211   -}
212   -
213   -static void help(void)
214   -{
215   - printf("vmdk2raw\n"
216   - "usage: vmdk2raw vmware_image output_image\n"
217   - "\n"
218   - "vmware_image a vmware cow image\n"
219   - "output_image the created disk image\n"
220   - );
221   - exit(1);
222   -}
223   -
224   -#define BUF_SIZE 0x10000
225   -static void copy_disk(in_fd, out_fd)
226   -{
227   - char buf[BUF_SIZE];
228   - off64_t i = 0;
229   - int ret;
230   - while (i < disk_limit) {
231   - ret = copy_virtual(&vdsk, in_fd, out_fd, i, buf, sizeof(buf));
232   - if (ret < 0) {
233   - fprintf(stderr, "copying failed\n");
234   - exit(-1);
235   - }
236   - i += ret;
237   - }
238   -}
239   -
240   -int main(int argc, char **argv)
241   -{
242   - int out_fd, in_fd;
243   -
244   - if (argc < 3)
245   - help();
246   -
247   - in_fd = open_vmdk(argv[1]);
248   - if (in_fd < 0) {
249   - return -1;
250   - }
251   -
252   - out_fd = open(argv[2], O_WRONLY | O_LARGEFILE | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
253   - if (out_fd < 0) {
254   - perror(argv[2]);
255   - return -1;
256   - }
257   -
258   - copy_disk(in_fd, out_fd);
259   - close(out_fd);
260   - return 0;
261   -}