Revision faf07963

b/Makefile
13 13

  
14 14
CPPFLAGS += -I. -I$(SRC_PATH) -MMD -MP
15 15
CPPFLAGS += -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE
16
CPPFLAGS += -DQEMU_TOOL
17 16
LIBS=
18 17
ifdef CONFIG_STATIC
19 18
BASE_LDFLAGS += -static
......
33 32

  
34 33
recurse-all: $(patsubst %,subdir-%, $(TARGET_DIRS))
35 34

  
35
#######################################################################
36
# BLOCK_OBJS is code used by both qemu system emulation and qemu-img
37

  
38
BLOCK_OBJS=cutils.o
39
BLOCK_OBJS+=block-cow.o block-qcow.o aes.o block-vmdk.o block-cloop.o
40
BLOCK_OBJS+=block-dmg.o block-bochs.o block-vpc.o block-vvfat.o
41
BLOCK_OBJS+=block-qcow2.o block-parallels.o
42

  
36 43
######################################################################
37
# libqemu_common.a: target indepedent part of system emulation. The
44
# libqemu_common.a: Target indepedent part of system emulation. The
38 45
# long term path is to suppress *all* target specific code in case of
39 46
# system emulation, i.e. a single QEMU executable should support all
40 47
# CPUs and machines.
41 48

  
42
OBJS+=cutils.o readline.o console.o 
43
#OBJS+=block.o block-raw.o
44
OBJS+=block-cow.o block-qcow.o aes.o block-vmdk.o block-cloop.o block-dmg.o block-bochs.o block-vpc.o block-vvfat.o block-qcow2.o block-parallels.o
49
OBJS=$(BLOCK_OBJS)
50
OBJS+=readline.o console.o 
51
OBJS+=block.o
45 52

  
46 53
ifdef CONFIG_WIN32
47 54
OBJS+=tap-win32.o
......
105 112

  
106 113
######################################################################
107 114

  
108
qemu-img$(EXESUF): qemu-img.o block.o block-raw.o libqemu_common.a
115
qemu-img$(EXESUF): qemu-img.o qemu-img-block.o qemu-img-block-raw.o $(BLOCK_OBJS)
109 116
	$(CC) $(LDFLAGS) $(BASE_LDFLAGS) -o $@ $^ -lz $(LIBS)
110 117

  
118
qemu-img-%.o: %.c
119
	$(CC) $(CFLAGS) $(CPPFLAGS) -DQEMU_IMG $(BASE_CFLAGS) -c -o $@ $<
120

  
111 121
%.o: %.c
112 122
	$(CC) $(CFLAGS) $(CPPFLAGS) $(BASE_CFLAGS) -c -o $@ $<
113 123

  
b/Makefile.target
24 24
endif
25 25
TARGET_PATH=$(SRC_PATH)/target-$(TARGET_BASE_ARCH)
26 26
VPATH=$(SRC_PATH):$(TARGET_PATH):$(SRC_PATH)/hw
27
CPPFLAGS=-I. -I.. -I$(TARGET_PATH) -I$(SRC_PATH) -MMD -MP
27
CPPFLAGS=-I. -I.. -I$(TARGET_PATH) -I$(SRC_PATH) -MMD -MP -DNEED_CPU_H
28 28
ifdef CONFIG_DARWIN_USER
29 29
VPATH+=:$(SRC_PATH)/darwin-user
30 30
CPPFLAGS+=-I$(SRC_PATH)/darwin-user -I$(SRC_PATH)/darwin-user/$(TARGET_ARCH)
......
398 398
# must use static linking to avoid leaving stuff in virtual address space
399 399
VL_OBJS=vl.o osdep.o monitor.o pci.o loader.o isa_mmio.o
400 400
# XXX: suppress QEMU_TOOL tests
401
VL_OBJS+=block.o block-raw.o
401
VL_OBJS+=block-raw.o
402 402
VL_OBJS+=irq.o
403 403

  
404 404
ifdef CONFIG_ALSA
b/aes.c
27 27
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
28 28
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 29
 */
30
#include "vl.h"
30
#include "qemu-common.h"
31 31
#include "aes.h"
32 32

  
33 33
#define NDEBUG
b/block-bochs.c
22 22
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 23
 * THE SOFTWARE.
24 24
 */
25
#include "vl.h"
25
#include "qemu-common.h"
26 26
#include "block_int.h"
27 27

  
28 28
/**************************************************************/
b/block-cloop.c
21 21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 22
 * THE SOFTWARE.
23 23
 */
24
#include "vl.h"
24
#include "qemu-common.h"
25 25
#include "block_int.h"
26 26
#include <zlib.h>
27 27

  
b/block-cow.c
22 22
 * THE SOFTWARE.
23 23
 */
24 24
#ifndef _WIN32
25
#include "vl.h"
25
#include "qemu-common.h"
26 26
#include "block_int.h"
27 27
#include <sys/mman.h>
28 28

  
b/block-dmg.c
21 21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 22
 * THE SOFTWARE.
23 23
 */
24
#include "vl.h"
24
#include "qemu-common.h"
25 25
#include "block_int.h"
26 26
#include "bswap.h"
27 27
#include <zlib.h>
b/block-parallels.c
23 23
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 24
 * THE SOFTWARE.
25 25
 */
26
#include "vl.h"
26
#include "qemu-common.h"
27 27
#include "block_int.h"
28 28

  
29 29
/**************************************************************/
b/block-qcow.c
21 21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 22
 * THE SOFTWARE.
23 23
 */
24
#include "vl.h"
24
#include "qemu-common.h"
25 25
#include "block_int.h"
26 26
#include <zlib.h>
27 27
#include "aes.h"
b/block-qcow2.c
21 21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 22
 * THE SOFTWARE.
23 23
 */
24
#include "vl.h"
24
#include "qemu-common.h"
25 25
#include "block_int.h"
26 26
#include <zlib.h>
27 27
#include "aes.h"
b/block-raw.c
21 21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 22
 * THE SOFTWARE.
23 23
 */
24
#ifdef QEMU_IMG
25
#include "qemu-common.h"
26
#else
24 27
#include "vl.h"
28
#endif
25 29
#include "block_int.h"
26 30
#include <assert.h>
27 31
#ifndef _WIN32
28 32
#include <aio.h>
29 33

  
30
#ifndef QEMU_TOOL
31
#include "exec-all.h"
32
#endif
33

  
34 34
#ifdef CONFIG_COCOA
35 35
#include <paths.h>
36 36
#include <sys/param.h>
......
59 59

  
60 60
//#define DEBUG_FLOPPY
61 61

  
62
#define DEBUG_BLOCK
63
#if defined(DEBUG_BLOCK) && !defined(QEMU_TOOL)
62
//#define DEBUG_BLOCK
63
#if defined(DEBUG_BLOCK) && !defined(QEMU_IMG)
64
#include "exec-all.h"
64 65
#define DEBUG_BLOCK_PRINT(formatCstr, args...) do { if (loglevel != 0)	\
65 66
    { fprintf(logfile, formatCstr, ##args); fflush(logfile); } } while (0)
66 67
#else
......
242 243

  
243 244
static void aio_signal_handler(int signum)
244 245
{
245
#ifndef QEMU_TOOL
246
#ifndef QEMU_IMG
246 247
    CPUState *env = cpu_single_env;
247 248
    if (env) {
248 249
        /* stop the currently executing cpu because a timer occured */
......
352 353
    sigset_t set;
353 354
    int nb_sigs;
354 355

  
355
#ifndef QEMU_TOOL
356
#ifndef QEMU_IMG
356 357
    if (qemu_bh_poll())
357 358
        return;
358 359
#endif
......
693 694
    return 0;
694 695
}
695 696

  
696
#if defined(__linux__) && !defined(QEMU_TOOL)
697
#if defined(__linux__) && !defined(QEMU_IMG)
697 698

  
698 699
/* Note: we do not have a reliable method to detect if the floppy is
699 700
   present. The current method is to try to open the floppy at every
......
976 977
    } else {
977 978
        create_flags = OPEN_EXISTING;
978 979
    }
979
#ifdef QEMU_TOOL
980
#ifdef QEMU_IMG
980 981
    overlapped = FILE_ATTRIBUTE_NORMAL;
981 982
#else
982 983
    overlapped = FILE_FLAG_OVERLAPPED;
......
1039 1040
}
1040 1041

  
1041 1042
#if 0
1042
#ifndef QEMU_TOOL
1043
#ifndef QEMU_IMG
1043 1044
static void raw_aio_cb(void *opaque)
1044 1045
{
1045 1046
    RawAIOCB *acb = opaque;
......
1078 1079
    acb->ov.OffsetHigh = offset >> 32;
1079 1080
    acb->ov.hEvent = acb->hEvent;
1080 1081
    acb->count = nb_sectors * 512;
1081
#ifndef QEMU_TOOL
1082
#ifndef QEMU_IMG
1082 1083
    qemu_add_wait_object(acb->ov.hEvent, raw_aio_cb, acb);
1083 1084
#endif
1084 1085
    return acb;
......
1100 1101
        qemu_aio_release(acb);
1101 1102
        return NULL;
1102 1103
    }
1103
#ifdef QEMU_TOOL
1104
#ifdef QEMU_IMG
1104 1105
    qemu_aio_release(acb);
1105 1106
#endif
1106 1107
    return (BlockDriverAIOCB *)acb;
......
1122 1123
        qemu_aio_release(acb);
1123 1124
        return NULL;
1124 1125
    }
1125
#ifdef QEMU_TOOL
1126
#ifdef QEMU_IMG
1126 1127
    qemu_aio_release(acb);
1127 1128
#endif
1128 1129
    return (BlockDriverAIOCB *)acb;
......
1130 1131

  
1131 1132
static void raw_aio_cancel(BlockDriverAIOCB *blockacb)
1132 1133
{
1133
#ifndef QEMU_TOOL
1134
#ifndef QEMU_IMG
1134 1135
    RawAIOCB *acb = (RawAIOCB *)blockacb;
1135 1136
    BlockDriverState *bs = acb->common.bs;
1136 1137
    BDRVRawState *s = bs->opaque;
......
1238 1239

  
1239 1240
void qemu_aio_wait(void)
1240 1241
{
1241
#ifndef QEMU_TOOL
1242
#ifndef QEMU_IMG
1242 1243
    qemu_bh_poll();
1243 1244
#endif
1244 1245
}
......
1344 1345
    }
1345 1346
    create_flags = OPEN_EXISTING;
1346 1347

  
1347
#ifdef QEMU_TOOL
1348
#ifdef QEMU_IMG
1348 1349
    overlapped = FILE_ATTRIBUTE_NORMAL;
1349 1350
#else
1350 1351
    overlapped = FILE_FLAG_OVERLAPPED;
b/block-vmdk.c
23 23
 * THE SOFTWARE.
24 24
 */
25 25

  
26
#include "vl.h"
26
#include "qemu-common.h"
27 27
#include "block_int.h"
28 28

  
29 29
#define VMDK3_MAGIC (('C' << 24) | ('O' << 16) | ('W' << 8) | 'D')
b/block-vpc.c
21 21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 22
 * THE SOFTWARE.
23 23
 */
24
#include "vl.h"
24
#include "qemu-common.h"
25 25
#include "block_int.h"
26 26

  
27 27
/**************************************************************/
b/block-vvfat.c
25 25
#include <sys/stat.h>
26 26
#include <dirent.h>
27 27
#include <assert.h>
28
#include "vl.h"
28
#include "qemu-common.h"
29 29
#include "block_int.h"
30 30

  
31 31
#ifndef S_IWGRP
b/block.c
21 21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 22
 * THE SOFTWARE.
23 23
 */
24
#ifdef QEMU_IMG
25
#include "qemu-common.h"
26
#else
24 27
#include "vl.h"
28
#endif
25 29
#include "block_int.h"
26 30

  
27 31
#ifdef _BSD
......
53 57
static int bdrv_write_em(BlockDriverState *bs, int64_t sector_num,
54 58
                         const uint8_t *buf, int nb_sectors);
55 59

  
56
static BlockDriverState *bdrv_first;
60
BlockDriverState *bdrv_first;
57 61
static BlockDriver *first_drv;
58 62

  
59 63
int path_is_absolute(const char *path)
......
859 863
        bdrv_flush(bs->backing_hd);
860 864
}
861 865

  
866
#ifndef QEMU_IMG
862 867
void bdrv_info(void)
863 868
{
864 869
    BlockDriverState *bs;
......
898 903
        term_printf("\n");
899 904
    }
900 905
}
906
#endif
901 907

  
902 908
void bdrv_get_backing_filename(BlockDriverState *bs,
903 909
                               char *filename, int filename_size)
......
1102 1108
/**************************************************************/
1103 1109
/* async block device emulation */
1104 1110

  
1105
#ifdef QEMU_TOOL
1111
#ifdef QEMU_IMG
1106 1112
static BlockDriverAIOCB *bdrv_aio_read_em(BlockDriverState *bs,
1107 1113
        int64_t sector_num, uint8_t *buf, int nb_sectors,
1108 1114
        BlockDriverCompletionFunc *cb, void *opaque)
......
1172 1178
    qemu_bh_cancel(acb->bh);
1173 1179
    qemu_aio_release(acb);
1174 1180
}
1175
#endif /* !QEMU_TOOL */
1181
#endif /* !QEMU_IMG */
1176 1182

  
1177 1183
/**************************************************************/
1178 1184
/* sync block device emulation */
b/block.h
1
#ifndef BLOCK_H
2
#define BLOCK_H
3

  
4
/* block.c */
5
typedef struct BlockDriverState BlockDriverState;
6
typedef struct BlockDriver BlockDriver;
7

  
8
extern BlockDriver bdrv_raw;
9
extern BlockDriver bdrv_host_device;
10
extern BlockDriver bdrv_cow;
11
extern BlockDriver bdrv_qcow;
12
extern BlockDriver bdrv_vmdk;
13
extern BlockDriver bdrv_cloop;
14
extern BlockDriver bdrv_dmg;
15
extern BlockDriver bdrv_bochs;
16
extern BlockDriver bdrv_vpc;
17
extern BlockDriver bdrv_vvfat;
18
extern BlockDriver bdrv_qcow2;
19
extern BlockDriver bdrv_parallels;
20

  
21
typedef struct BlockDriverInfo {
22
    /* in bytes, 0 if irrelevant */
23
    int cluster_size;
24
    /* offset at which the VM state can be saved (0 if not possible) */
25
    int64_t vm_state_offset;
26
} BlockDriverInfo;
27

  
28
typedef struct QEMUSnapshotInfo {
29
    char id_str[128]; /* unique snapshot id */
30
    /* the following fields are informative. They are not needed for
31
       the consistency of the snapshot */
32
    char name[256]; /* user choosen name */
33
    uint32_t vm_state_size; /* VM state info size */
34
    uint32_t date_sec; /* UTC date of the snapshot */
35
    uint32_t date_nsec;
36
    uint64_t vm_clock_nsec; /* VM clock relative to boot */
37
} QEMUSnapshotInfo;
38

  
39
#define BDRV_O_RDONLY      0x0000
40
#define BDRV_O_RDWR        0x0002
41
#define BDRV_O_ACCESS      0x0003
42
#define BDRV_O_CREAT       0x0004 /* create an empty file */
43
#define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
44
#define BDRV_O_FILE        0x0010 /* open as a raw file (do not try to
45
                                     use a disk image format on top of
46
                                     it (default for
47
                                     bdrv_file_open()) */
48

  
49
#ifndef QEMU_IMG
50
void bdrv_info(void);
51
#endif
52

  
53
void bdrv_init(void);
54
BlockDriver *bdrv_find_format(const char *format_name);
55
int bdrv_create(BlockDriver *drv,
56
                const char *filename, int64_t size_in_sectors,
57
                const char *backing_file, int flags);
58
BlockDriverState *bdrv_new(const char *device_name);
59
void bdrv_delete(BlockDriverState *bs);
60
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
61
int bdrv_open(BlockDriverState *bs, const char *filename, int flags);
62
int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
63
               BlockDriver *drv);
64
void bdrv_close(BlockDriverState *bs);
65
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
66
              uint8_t *buf, int nb_sectors);
67
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
68
               const uint8_t *buf, int nb_sectors);
69
int bdrv_pread(BlockDriverState *bs, int64_t offset,
70
               void *buf, int count);
71
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
72
                const void *buf, int count);
73
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
74
int64_t bdrv_getlength(BlockDriverState *bs);
75
void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
76
int bdrv_commit(BlockDriverState *bs);
77
void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
78
/* async block I/O */
79
typedef struct BlockDriverAIOCB BlockDriverAIOCB;
80
typedef void BlockDriverCompletionFunc(void *opaque, int ret);
81

  
82
BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
83
                                uint8_t *buf, int nb_sectors,
84
                                BlockDriverCompletionFunc *cb, void *opaque);
85
BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
86
                                 const uint8_t *buf, int nb_sectors,
87
                                 BlockDriverCompletionFunc *cb, void *opaque);
88
void bdrv_aio_cancel(BlockDriverAIOCB *acb);
89

  
90
void qemu_aio_init(void);
91
void qemu_aio_poll(void);
92
void qemu_aio_flush(void);
93
void qemu_aio_wait_start(void);
94
void qemu_aio_wait(void);
95
void qemu_aio_wait_end(void);
96

  
97
int qemu_key_check(BlockDriverState *bs, const char *name);
98

  
99
/* Ensure contents are flushed to disk.  */
100
void bdrv_flush(BlockDriverState *bs);
101

  
102
#define BDRV_TYPE_HD     0
103
#define BDRV_TYPE_CDROM  1
104
#define BDRV_TYPE_FLOPPY 2
105
#define BIOS_ATA_TRANSLATION_AUTO   0
106
#define BIOS_ATA_TRANSLATION_NONE   1
107
#define BIOS_ATA_TRANSLATION_LBA    2
108
#define BIOS_ATA_TRANSLATION_LARGE  3
109
#define BIOS_ATA_TRANSLATION_RECHS  4
110

  
111
void bdrv_set_geometry_hint(BlockDriverState *bs,
112
                            int cyls, int heads, int secs);
113
void bdrv_set_type_hint(BlockDriverState *bs, int type);
114
void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
115
void bdrv_get_geometry_hint(BlockDriverState *bs,
116
                            int *pcyls, int *pheads, int *psecs);
117
int bdrv_get_type_hint(BlockDriverState *bs);
118
int bdrv_get_translation_hint(BlockDriverState *bs);
119
int bdrv_is_removable(BlockDriverState *bs);
120
int bdrv_is_read_only(BlockDriverState *bs);
121
int bdrv_is_inserted(BlockDriverState *bs);
122
int bdrv_media_changed(BlockDriverState *bs);
123
int bdrv_is_locked(BlockDriverState *bs);
124
void bdrv_set_locked(BlockDriverState *bs, int locked);
125
void bdrv_eject(BlockDriverState *bs, int eject_flag);
126
void bdrv_set_change_cb(BlockDriverState *bs,
127
                        void (*change_cb)(void *opaque), void *opaque);
128
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
129
BlockDriverState *bdrv_find(const char *name);
130
void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);
131
int bdrv_is_encrypted(BlockDriverState *bs);
132
int bdrv_set_key(BlockDriverState *bs, const char *key);
133
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
134
                         void *opaque);
135
const char *bdrv_get_device_name(BlockDriverState *bs);
136
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
137
                          const uint8_t *buf, int nb_sectors);
138
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
139

  
140
void bdrv_get_backing_filename(BlockDriverState *bs,
141
                               char *filename, int filename_size);
142
int bdrv_snapshot_create(BlockDriverState *bs,
143
                         QEMUSnapshotInfo *sn_info);
144
int bdrv_snapshot_goto(BlockDriverState *bs,
145
                       const char *snapshot_id);
146
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
147
int bdrv_snapshot_list(BlockDriverState *bs,
148
                       QEMUSnapshotInfo **psn_info);
149
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
150

  
151
char *get_human_readable_size(char *buf, int buf_size, int64_t size);
152
int path_is_absolute(const char *path);
153
void path_combine(char *dest, int dest_size,
154
                  const char *base_path,
155
                  const char *filename);
156

  
157
#endif
b/block_int.h
24 24
#ifndef BLOCK_INT_H
25 25
#define BLOCK_INT_H
26 26

  
27
#include "block.h"
28

  
27 29
#define BLOCK_FLAG_ENCRYPT	1
28 30
#define BLOCK_FLAG_COMPRESS	2
29 31
#define BLOCK_FLAG_COMPAT6	4
......
133 135
                   void *opaque);
134 136
void qemu_aio_release(void *p);
135 137

  
138
BlockDriverState *bdrv_first;
139

  
136 140
#endif /* BLOCK_INT_H */
b/cutils.c
21 21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 22
 * THE SOFTWARE.
23 23
 */
24
#include "vl.h"
24
#include "qemu-common.h"
25 25

  
26 26
void pstrcpy(char *buf, int buf_size, const char *str)
27 27
{
b/qemu-common.h
1
/* Common header file that is included by all of qemu.  */
2
#ifndef QEMU_COMMON_H
3
#define QEMU_COMMON_H
4

  
5
/* we put basic includes here to avoid repeating them in device drivers */
6
#include <stdlib.h>
7
#include <stdio.h>
8
#include <stdarg.h>
9
#include <string.h>
10
#include <inttypes.h>
11
#include <limits.h>
12
#include <time.h>
13
#include <ctype.h>
14
#include <errno.h>
15
#include <unistd.h>
16
#include <fcntl.h>
17
#include <sys/stat.h>
18

  
19
#ifndef O_LARGEFILE
20
#define O_LARGEFILE 0
21
#endif
22
#ifndef O_BINARY
23
#define O_BINARY 0
24
#endif
25

  
26
#ifndef ENOMEDIUM
27
#define ENOMEDIUM ENODEV
28
#endif
29

  
30
#ifdef _WIN32
31
#include <windows.h>
32
#define fsync _commit
33
#define lseek _lseeki64
34
#define ENOTSUP 4096
35
extern int qemu_ftruncate64(int, int64_t);
36
#define ftruncate qemu_ftruncate64
37

  
38

  
39
static inline char *realpath(const char *path, char *resolved_path)
40
{
41
    _fullpath(resolved_path, path, _MAX_PATH);
42
    return resolved_path;
43
}
44

  
45
#define PRId64 "I64d"
46
#define PRIx64 "I64x"
47
#define PRIu64 "I64u"
48
#define PRIo64 "I64o"
49
#endif
50

  
51
/* FIXME: Remove NEED_CPU_H.  */
52
#ifndef NEED_CPU_H
53

  
54
#include "config-host.h"
55
#include <setjmp.h>
56
#include "osdep.h"
57
#include "bswap.h"
58

  
59
#else
60

  
61
#include "cpu.h"
62

  
63
#endif /* !defined(NEED_CPU_H) */
64

  
65
/* bottom halves */
66
typedef struct QEMUBH QEMUBH;
67

  
68
typedef void QEMUBHFunc(void *opaque);
69

  
70
QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
71
void qemu_bh_schedule(QEMUBH *bh);
72
void qemu_bh_cancel(QEMUBH *bh);
73
void qemu_bh_delete(QEMUBH *bh);
74
int qemu_bh_poll(void);
75

  
76
/* cutils.c */
77
void pstrcpy(char *buf, int buf_size, const char *str);
78
char *pstrcat(char *buf, int buf_size, const char *s);
79
int strstart(const char *str, const char *val, const char **ptr);
80
int stristart(const char *str, const char *val, const char **ptr);
81
time_t mktimegm(struct tm *tm);
82

  
83
#endif
b/qemu-img.c
21 21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 22
 * THE SOFTWARE.
23 23
 */
24
#include "vl.h"
24
#include "qemu-common.h"
25 25
#include "block_int.h"
26 26
#include <assert.h>
27 27

  
b/vl.h
24 24
#ifndef VL_H
25 25
#define VL_H
26 26

  
27
/* we put basic includes here to avoid repeating them in device drivers */
28
#include <stdlib.h>
29
#include <stdio.h>
30
#include <stdarg.h>
31
#include <string.h>
32
#include <inttypes.h>
33
#include <limits.h>
34
#include <time.h>
35
#include <ctype.h>
36
#include <errno.h>
37
#include <unistd.h>
38
#include <fcntl.h>
39
#include <sys/stat.h>
40

  
41
#ifndef O_LARGEFILE
42
#define O_LARGEFILE 0
43
#endif
44
#ifndef O_BINARY
45
#define O_BINARY 0
46
#endif
47

  
48
#ifndef ENOMEDIUM
49
#define ENOMEDIUM ENODEV
50
#endif
51

  
52
#ifdef _WIN32
53
#include <windows.h>
54
#define fsync _commit
55
#define lseek _lseeki64
56
#define ENOTSUP 4096
57
extern int qemu_ftruncate64(int, int64_t);
58
#define ftruncate qemu_ftruncate64
59

  
60

  
61
static inline char *realpath(const char *path, char *resolved_path)
62
{
63
    _fullpath(resolved_path, path, _MAX_PATH);
64
    return resolved_path;
65
}
66

  
67
#define PRId64 "I64d"
68
#define PRIx64 "I64x"
69
#define PRIu64 "I64u"
70
#define PRIo64 "I64o"
71
#endif
72

  
73
#ifdef QEMU_TOOL
74

  
75
/* we use QEMU_TOOL on code which does not depend on the target CPU
76
   type */
77
#include "config-host.h"
78
#include <setjmp.h>
79
#include "osdep.h"
80
#include "bswap.h"
81

  
82
#else
83

  
84
#include "cpu.h"
27
#include "qemu-common.h"
85 28

  
86
#endif /* !defined(QEMU_TOOL) */
29
/* FIXME: Remove this.  */
30
#include "block.h"
87 31

  
88 32
#ifndef glue
89 33
#define xglue(x, y) x ## y
......
118 62

  
119 63
#include "audio/audio.h"
120 64

  
121
/* cutils.c */
122
void pstrcpy(char *buf, int buf_size, const char *str);
123
char *pstrcat(char *buf, int buf_size, const char *s);
124
int strstart(const char *str, const char *val, const char **ptr);
125
int stristart(const char *str, const char *val, const char **ptr);
126
time_t mktimegm(struct tm *tm);
127

  
128 65
/* vl.c */
129 66
uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c);
130 67

  
......
297 234
void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque);
298 235
#endif
299 236

  
300
typedef struct QEMUBH QEMUBH;
301

  
302 237
/* character device */
303 238

  
304 239
#define CHR_EVENT_BREAK 0 /* serial break char */
......
604 539
void do_delvm(const char *name);
605 540
void do_info_snapshots(void);
606 541

  
607
/* bottom halves */
608
typedef void QEMUBHFunc(void *opaque);
609

  
610
QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
611
void qemu_bh_schedule(QEMUBH *bh);
612
void qemu_bh_cancel(QEMUBH *bh);
613
void qemu_bh_delete(QEMUBH *bh);
614
int qemu_bh_poll(void);
615

  
616
/* block.c */
617
typedef struct BlockDriverState BlockDriverState;
618
typedef struct BlockDriver BlockDriver;
619

  
620
extern BlockDriver bdrv_raw;
621
extern BlockDriver bdrv_host_device;
622
extern BlockDriver bdrv_cow;
623
extern BlockDriver bdrv_qcow;
624
extern BlockDriver bdrv_vmdk;
625
extern BlockDriver bdrv_cloop;
626
extern BlockDriver bdrv_dmg;
627
extern BlockDriver bdrv_bochs;
628
extern BlockDriver bdrv_vpc;
629
extern BlockDriver bdrv_vvfat;
630
extern BlockDriver bdrv_qcow2;
631
extern BlockDriver bdrv_parallels;
632

  
633
typedef struct BlockDriverInfo {
634
    /* in bytes, 0 if irrelevant */
635
    int cluster_size;
636
    /* offset at which the VM state can be saved (0 if not possible) */
637
    int64_t vm_state_offset;
638
} BlockDriverInfo;
639

  
640
typedef struct QEMUSnapshotInfo {
641
    char id_str[128]; /* unique snapshot id */
642
    /* the following fields are informative. They are not needed for
643
       the consistency of the snapshot */
644
    char name[256]; /* user choosen name */
645
    uint32_t vm_state_size; /* VM state info size */
646
    uint32_t date_sec; /* UTC date of the snapshot */
647
    uint32_t date_nsec;
648
    uint64_t vm_clock_nsec; /* VM clock relative to boot */
649
} QEMUSnapshotInfo;
650

  
651
#define BDRV_O_RDONLY      0x0000
652
#define BDRV_O_RDWR        0x0002
653
#define BDRV_O_ACCESS      0x0003
654
#define BDRV_O_CREAT       0x0004 /* create an empty file */
655
#define BDRV_O_SNAPSHOT    0x0008 /* open the file read only and save writes in a snapshot */
656
#define BDRV_O_FILE        0x0010 /* open as a raw file (do not try to
657
                                     use a disk image format on top of
658
                                     it (default for
659
                                     bdrv_file_open()) */
660

  
661
void bdrv_init(void);
662
BlockDriver *bdrv_find_format(const char *format_name);
663
int bdrv_create(BlockDriver *drv,
664
                const char *filename, int64_t size_in_sectors,
665
                const char *backing_file, int flags);
666
BlockDriverState *bdrv_new(const char *device_name);
667
void bdrv_delete(BlockDriverState *bs);
668
int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags);
669
int bdrv_open(BlockDriverState *bs, const char *filename, int flags);
670
int bdrv_open2(BlockDriverState *bs, const char *filename, int flags,
671
               BlockDriver *drv);
672
void bdrv_close(BlockDriverState *bs);
673
int bdrv_read(BlockDriverState *bs, int64_t sector_num,
674
              uint8_t *buf, int nb_sectors);
675
int bdrv_write(BlockDriverState *bs, int64_t sector_num,
676
               const uint8_t *buf, int nb_sectors);
677
int bdrv_pread(BlockDriverState *bs, int64_t offset,
678
               void *buf, int count);
679
int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
680
                const void *buf, int count);
681
int bdrv_truncate(BlockDriverState *bs, int64_t offset);
682
int64_t bdrv_getlength(BlockDriverState *bs);
683
void bdrv_get_geometry(BlockDriverState *bs, int64_t *nb_sectors_ptr);
684
int bdrv_commit(BlockDriverState *bs);
685
void bdrv_set_boot_sector(BlockDriverState *bs, const uint8_t *data, int size);
686
/* async block I/O */
687
typedef struct BlockDriverAIOCB BlockDriverAIOCB;
688
typedef void BlockDriverCompletionFunc(void *opaque, int ret);
689

  
690
BlockDriverAIOCB *bdrv_aio_read(BlockDriverState *bs, int64_t sector_num,
691
                                uint8_t *buf, int nb_sectors,
692
                                BlockDriverCompletionFunc *cb, void *opaque);
693
BlockDriverAIOCB *bdrv_aio_write(BlockDriverState *bs, int64_t sector_num,
694
                                 const uint8_t *buf, int nb_sectors,
695
                                 BlockDriverCompletionFunc *cb, void *opaque);
696
void bdrv_aio_cancel(BlockDriverAIOCB *acb);
697

  
698
void qemu_aio_init(void);
699
void qemu_aio_poll(void);
700
void qemu_aio_flush(void);
701
void qemu_aio_wait_start(void);
702
void qemu_aio_wait(void);
703
void qemu_aio_wait_end(void);
704

  
705
int qemu_key_check(BlockDriverState *bs, const char *name);
706

  
707
/* Ensure contents are flushed to disk.  */
708
void bdrv_flush(BlockDriverState *bs);
709

  
710
#define BDRV_TYPE_HD     0
711
#define BDRV_TYPE_CDROM  1
712
#define BDRV_TYPE_FLOPPY 2
713
#define BIOS_ATA_TRANSLATION_AUTO   0
714
#define BIOS_ATA_TRANSLATION_NONE   1
715
#define BIOS_ATA_TRANSLATION_LBA    2
716
#define BIOS_ATA_TRANSLATION_LARGE  3
717
#define BIOS_ATA_TRANSLATION_RECHS  4
718

  
719
void bdrv_set_geometry_hint(BlockDriverState *bs,
720
                            int cyls, int heads, int secs);
721
void bdrv_set_type_hint(BlockDriverState *bs, int type);
722
void bdrv_set_translation_hint(BlockDriverState *bs, int translation);
723
void bdrv_get_geometry_hint(BlockDriverState *bs,
724
                            int *pcyls, int *pheads, int *psecs);
725
int bdrv_get_type_hint(BlockDriverState *bs);
726
int bdrv_get_translation_hint(BlockDriverState *bs);
727
int bdrv_is_removable(BlockDriverState *bs);
728
int bdrv_is_read_only(BlockDriverState *bs);
729
int bdrv_is_inserted(BlockDriverState *bs);
730
int bdrv_media_changed(BlockDriverState *bs);
731
int bdrv_is_locked(BlockDriverState *bs);
732
void bdrv_set_locked(BlockDriverState *bs, int locked);
733
void bdrv_eject(BlockDriverState *bs, int eject_flag);
734
void bdrv_set_change_cb(BlockDriverState *bs,
735
                        void (*change_cb)(void *opaque), void *opaque);
736
void bdrv_get_format(BlockDriverState *bs, char *buf, int buf_size);
737
void bdrv_info(void);
738
BlockDriverState *bdrv_find(const char *name);
739
void bdrv_iterate(void (*it)(void *opaque, const char *name), void *opaque);
740
int bdrv_is_encrypted(BlockDriverState *bs);
741
int bdrv_set_key(BlockDriverState *bs, const char *key);
742
void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
743
                         void *opaque);
744
const char *bdrv_get_device_name(BlockDriverState *bs);
745
int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
746
                          const uint8_t *buf, int nb_sectors);
747
int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
748

  
749
void bdrv_get_backing_filename(BlockDriverState *bs,
750
                               char *filename, int filename_size);
751
int bdrv_snapshot_create(BlockDriverState *bs,
752
                         QEMUSnapshotInfo *sn_info);
753
int bdrv_snapshot_goto(BlockDriverState *bs,
754
                       const char *snapshot_id);
755
int bdrv_snapshot_delete(BlockDriverState *bs, const char *snapshot_id);
756
int bdrv_snapshot_list(BlockDriverState *bs,
757
                       QEMUSnapshotInfo **psn_info);
758
char *bdrv_snapshot_dump(char *buf, int buf_size, QEMUSnapshotInfo *sn);
759

  
760
char *get_human_readable_size(char *buf, int buf_size, int64_t size);
761
int path_is_absolute(const char *path);
762
void path_combine(char *dest, int dest_size,
763
                  const char *base_path,
764
                  const char *filename);
765

  
766

  
767 542
/* monitor.c */
768 543
void monitor_init(CharDriverState *hd, int show_banner);
769 544
void term_puts(const char *str);
......
804 579
/* x_keymap.c */
805 580
extern uint8_t _translate_keycode(const int key);
806 581

  
807
#ifndef QEMU_TOOL
582
#ifdef NEED_CPU_H
808 583

  
809 584
typedef void QEMUMachineInitFunc(int ram_size, int vga_ram_size,
810 585
                                 const char *boot_device,
......
1759 1534

  
1760 1535
#include "gdbstub.h"
1761 1536

  
1762
#endif /* defined(QEMU_TOOL) */
1537
#endif /* defined(NEED_CPU_H) */
1763 1538
#endif /* VL_H */

Also available in: Unified diff