← Back to branch summary

~ubuntu-branches/ubuntu/raring/libvirt/raring

« back to all changes in this revision

Viewing changes to src/qemu/qemu_capabilities.h

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-11-19 10:41:02 UTC
  • mfrom: (1.2.15) (223.1.2 raring-proposed)
  • Revision ID: package-import@ubuntu.com-20121119104102-l6ewdppikysbzztu
Tags: 1.0.0-0ubuntu2
debian/patches/add-armhf-sysinfo-infomration.patch: Disable
to fix FTBFS on arm.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/qemu/qemu_capabilities.h
15
15
 * Lesser General Public License for more details.
16
16
 *
17
17
 * You should have received a copy of the GNU Lesser General Public
18
 
 * License along with this library; if not, write to the Free Software
19
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 
18
 * License along with this library.  If not, see
 
19
 * <http://www.gnu.org/licenses/>.
20
20
 *
21
21
 * Author: Daniel P. Berrange <berrange@redhat.com>
22
22
 */
24
24
#ifndef __QEMU_CAPABILITIES_H__
25
25
# define __QEMU_CAPABILITIES_H__
26
26
 
27
 
# include "bitmap.h"
 
27
# include "virobject.h"
28
28
# include "capabilities.h"
29
29
# include "command.h"
 
30
# include "virobject.h"
 
31
# include "qemu_monitor.h"
30
32
 
31
33
/* Internal flags to keep track of qemu command line capabilities */
32
34
enum qemuCapsFlags {
43
45
    QEMU_CAPS_MIGRATE_QEMU_TCP   = 10, /* have qemu tcp migration */
44
46
    QEMU_CAPS_MIGRATE_QEMU_EXEC  = 11, /* have qemu exec migration */
45
47
    QEMU_CAPS_DRIVE_CACHE_V2     = 12, /* cache= flag wanting new v2 values */
46
 
    QEMU_CAPS_KVM                = 13, /* Whether KVM is compiled in */
 
48
    QEMU_CAPS_KVM                = 13, /* Whether KVM is enabled by default */
47
49
    QEMU_CAPS_DRIVE_FORMAT       = 14, /* Is -drive format= avail */
48
50
    QEMU_CAPS_VGA                = 15, /* Is -vga avail */
49
51
 
133
135
    QEMU_CAPS_HDA_MICRO          = 95, /* -device hda-micro */
134
136
    QEMU_CAPS_DUMP_GUEST_MEMORY  = 96, /* dump-guest-memory command */
135
137
    QEMU_CAPS_NEC_USB_XHCI       = 97, /* -device nec-usb-xhci */
 
138
    QEMU_CAPS_VIRTIO_S390        = 98, /* -device virtio-*-s390 */
 
139
    QEMU_CAPS_BALLOON_EVENT      = 99, /* Async event for balloon changes */
 
140
    QEMU_CAPS_NETDEV_BRIDGE      = 100, /* bridge helper support */
 
141
    QEMU_CAPS_SCSI_LSI           = 101, /* -device lsi */
 
142
    QEMU_CAPS_VIRTIO_SCSI_PCI    = 102, /* -device virtio-scsi-pci */
 
143
    QEMU_CAPS_BLOCKIO            = 103, /* -device ...logical_block_size & co */
 
144
    QEMU_CAPS_DISABLE_S3         = 104, /* S3 BIOS Advertisement on/off */
 
145
    QEMU_CAPS_DISABLE_S4         = 105, /* S4 BIOS Advertisement on/off */
 
146
    QEMU_CAPS_USB_REDIR_FILTER   = 106, /* usb-redir.filter */
 
147
    QEMU_CAPS_IDE_DRIVE_WWN      = 107, /* Is ide-drive.wwn available? */
 
148
    QEMU_CAPS_SCSI_DISK_WWN      = 108, /* Is scsi-disk.wwn available? */
 
149
    QEMU_CAPS_SECCOMP_SANDBOX    = 109, /* -sandbox */
 
150
    QEMU_CAPS_REBOOT_TIMEOUT     = 110, /* -boot reboot-timeout */
 
151
    QEMU_CAPS_DUMP_GUEST_CORE    = 111, /* dump-guest-core-parameter */
 
152
    QEMU_CAPS_SEAMLESS_MIGRATION = 112, /* seamless-migration for SPICE */
 
153
    QEMU_CAPS_BLOCK_COMMIT       = 113, /* block-commit */
 
154
    QEMU_CAPS_VNC                = 114, /* Is -vnc available? */
 
155
    QEMU_CAPS_DRIVE_MIRROR       = 115, /* drive-mirror monitor command */
136
156
 
137
157
    QEMU_CAPS_LAST,                   /* this must always be the last item */
138
158
};
139
159
 
140
 
virBitmapPtr qemuCapsNew(void);
141
 
 
142
 
# define qemuCapsFree(caps)  virBitmapFree(caps)
143
 
 
144
 
void qemuCapsSet(virBitmapPtr caps,
 
160
typedef struct _qemuCaps qemuCaps;
 
161
typedef qemuCaps *qemuCapsPtr;
 
162
 
 
163
typedef struct _qemuCapsCache qemuCapsCache;
 
164
typedef qemuCapsCache *qemuCapsCachePtr;
 
165
 
 
166
qemuCapsPtr qemuCapsNew(void);
 
167
qemuCapsPtr qemuCapsNewCopy(qemuCapsPtr caps);
 
168
qemuCapsPtr qemuCapsNewForBinary(const char *binary,
 
169
                                 const char *libDir,
 
170
                                 const char *runDir);
 
171
 
 
172
int qemuCapsProbeQMP(qemuCapsPtr caps,
 
173
                     qemuMonitorPtr mon);
 
174
 
 
175
void qemuCapsSet(qemuCapsPtr caps,
145
176
                 enum qemuCapsFlags flag) ATTRIBUTE_NONNULL(1);
146
177
 
147
 
void qemuCapsSetList(virBitmapPtr caps, ...) ATTRIBUTE_NONNULL(1);
 
178
void qemuCapsSetList(qemuCapsPtr caps, ...) ATTRIBUTE_NONNULL(1);
148
179
 
149
 
void qemuCapsClear(virBitmapPtr caps,
 
180
void qemuCapsClear(qemuCapsPtr caps,
150
181
                   enum qemuCapsFlags flag) ATTRIBUTE_NONNULL(1);
151
182
 
152
 
bool qemuCapsGet(virBitmapPtr caps,
 
183
bool qemuCapsGet(qemuCapsPtr caps,
153
184
                 enum qemuCapsFlags flag);
154
185
 
155
 
virCapsPtr qemuCapsInit(virCapsPtr old_caps);
156
 
 
157
 
int qemuCapsProbeMachineTypes(const char *binary,
158
 
                              virBitmapPtr qemuCaps,
159
 
                              virCapsGuestMachinePtr **machines,
160
 
                              int *nmachines);
161
 
 
162
 
int qemuCapsProbeCPUModels(const char *qemu,
163
 
                           virBitmapPtr qemuCaps,
164
 
                           const char *arch,
165
 
                           unsigned int *count,
166
 
                           const char ***cpus);
167
 
 
168
 
int qemuCapsExtractVersion(virCapsPtr caps,
169
 
                           unsigned int *version);
170
 
int qemuCapsExtractVersionInfo(const char *qemu, const char *arch,
171
 
                               unsigned int *version,
172
 
                               virBitmapPtr *qemuCaps);
173
 
 
 
186
char *qemuCapsFlagsString(qemuCapsPtr caps);
 
187
 
 
188
const char *qemuCapsGetBinary(qemuCapsPtr caps);
 
189
const char *qemuCapsGetArch(qemuCapsPtr caps);
 
190
unsigned int qemuCapsGetVersion(qemuCapsPtr caps);
 
191
unsigned int qemuCapsGetKVMVersion(qemuCapsPtr caps);
 
192
int qemuCapsAddCPUDefinition(qemuCapsPtr caps,
 
193
                             const char *name);
 
194
size_t qemuCapsGetCPUDefinitions(qemuCapsPtr caps,
 
195
                                 char ***names);
 
196
size_t qemuCapsGetMachineTypes(qemuCapsPtr caps,
 
197
                               char ***names);
 
198
const char *qemuCapsGetCanonicalMachine(qemuCapsPtr caps,
 
199
                                        const char *name);
 
200
 
 
201
int qemuCapsGetMachineTypesCaps(qemuCapsPtr caps,
 
202
                                size_t *nmachines,
 
203
                                virCapsGuestMachinePtr **machines);
 
204
 
 
205
bool qemuCapsIsValid(qemuCapsPtr caps);
 
206
 
 
207
 
 
208
qemuCapsCachePtr qemuCapsCacheNew(const char *libDir, const char *runDir);
 
209
qemuCapsPtr qemuCapsCacheLookup(qemuCapsCachePtr cache, const char *binary);
 
210
qemuCapsPtr qemuCapsCacheLookupCopy(qemuCapsCachePtr cache, const char *binary);
 
211
void qemuCapsCacheFree(qemuCapsCachePtr cache);
 
212
 
 
213
virCapsPtr qemuCapsInit(qemuCapsCachePtr cache);
 
214
 
 
215
int qemuCapsGetDefaultVersion(virCapsPtr caps,
 
216
                              qemuCapsCachePtr capsCache,
 
217
                              unsigned int *version);
 
218
 
 
219
/* Only for use by test suite */
174
220
int qemuCapsParseHelpStr(const char *qemu,
175
221
                         const char *str,
176
 
                         virBitmapPtr qemuCaps,
 
222
                         qemuCapsPtr caps,
177
223
                         unsigned int *version,
178
224
                         unsigned int *is_kvm,
179
225
                         unsigned int *kvm_version,
180
226
                         bool check_yajl);
181
 
int qemuCapsParseDeviceStr(const char *str,
182
 
                           virBitmapPtr qemuCaps);
183
 
 
184
 
virCommandPtr qemuCapsProbeCommand(const char *qemu,
185
 
                                   virBitmapPtr qemuCaps);
 
227
/* Only for use by test suite */
 
228
int qemuCapsParseDeviceStr(qemuCapsPtr caps, const char *str);
186
229
 
187
230
VIR_ENUM_DECL(qemuCaps);
188
231