qemu_domain.h 13.8 KB
Newer Older
1 2 3
/*
 * qemu_domain.h: QEMU domain private state
 *
4
 * Copyright (C) 2006-2014 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17
 * Copyright (C) 2006 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library.  If not, see
O
Osier Yang 已提交
19
 * <http://www.gnu.org/licenses/>.
20 21 22 23 24 25 26
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#ifndef __QEMU_DOMAIN_H__
# define __QEMU_DOMAIN_H__

27
# include "virthread.h"
28
# include "vircgroup.h"
29
# include "domain_addr.h"
30
# include "domain_conf.h"
31
# include "snapshot_conf.h"
32
# include "qemu_monitor.h"
D
Daniel P. Berrange 已提交
33
# include "qemu_agent.h"
34
# include "qemu_conf.h"
35
# include "qemu_capabilities.h"
36
# include "virchrdev.h"
37

M
Matthias Bolte 已提交
38 39 40 41 42 43
# define QEMU_EXPECTED_VIRT_TYPES      \
    ((1 << VIR_DOMAIN_VIRT_QEMU) |     \
     (1 << VIR_DOMAIN_VIRT_KQEMU) |    \
     (1 << VIR_DOMAIN_VIRT_KVM) |      \
     (1 << VIR_DOMAIN_VIRT_XEN))

44 45 46 47
# define QEMU_DOMAIN_FORMAT_LIVE_FLAGS      \
    (VIR_DOMAIN_XML_SECURE |                \
     VIR_DOMAIN_XML_UPDATE_CPU)

48 49 50
# if ULONG_MAX == 4294967295
/* Qemu has a 64-bit limit, but we are limited by our historical choice of
 * representing bandwidth in a long instead of a 64-bit int.  */
51
#  define QEMU_DOMAIN_MIG_BANDWIDTH_MAX ULONG_MAX
52
# else
53
#  define QEMU_DOMAIN_MIG_BANDWIDTH_MAX (INT64_MAX / (1024 * 1024))
54
# endif
55

56 57
# define JOB_MASK(job)                  (1 << (job - 1))
# define DEFAULT_JOB_MASK               \
58 59 60
    (JOB_MASK(QEMU_JOB_QUERY) |         \
     JOB_MASK(QEMU_JOB_DESTROY) |       \
     JOB_MASK(QEMU_JOB_ABORT))
61

62 63 64 65 66
/* Jobs which have to be tracked in domain state XML. */
# define QEMU_DOMAIN_TRACK_JOBS         \
    (JOB_MASK(QEMU_JOB_DESTROY) |       \
     JOB_MASK(QEMU_JOB_ASYNC))

67 68 69 70 71
/* Only 1 job is allowed at any time
 * A job includes *all* monitor commands, even those just querying
 * information, not merely actions */
enum qemuDomainJob {
    QEMU_JOB_NONE = 0,  /* Always set to 0 for easy if (jobActive) conditions */
72 73 74 75
    QEMU_JOB_QUERY,         /* Doesn't change any state */
    QEMU_JOB_DESTROY,       /* Destroys the domain (cannot be masked out) */
    QEMU_JOB_SUSPEND,       /* Suspends (stops vCPUs) the domain */
    QEMU_JOB_MODIFY,        /* May change state */
76
    QEMU_JOB_ABORT,         /* Abort current async job */
77
    QEMU_JOB_MIGRATION_OP,  /* Operation influencing outgoing migration */
78

79
    /* The following two items must always be the last items before JOB_LAST */
80 81
    QEMU_JOB_ASYNC,         /* Asynchronous job */
    QEMU_JOB_ASYNC_NESTED,  /* Normal job within an async job */
82 83

    QEMU_JOB_LAST
84
};
85
VIR_ENUM_DECL(qemuDomainJob)
86 87 88 89 90 91 92 93 94 95 96

/* Async job consists of a series of jobs that may change state. Independent
 * jobs that do not change state (and possibly others if explicitly allowed by
 * current async job) are allowed to be run even if async job is active.
 */
enum qemuDomainAsyncJob {
    QEMU_ASYNC_JOB_NONE = 0,
    QEMU_ASYNC_JOB_MIGRATION_OUT,
    QEMU_ASYNC_JOB_MIGRATION_IN,
    QEMU_ASYNC_JOB_SAVE,
    QEMU_ASYNC_JOB_DUMP,
97
    QEMU_ASYNC_JOB_SNAPSHOT,
98 99

    QEMU_ASYNC_JOB_LAST
100
};
101
VIR_ENUM_DECL(qemuDomainAsyncJob)
102

103
struct qemuDomainJobObj {
104 105
    virCond cond;                       /* Use to coordinate jobs */
    enum qemuDomainJob active;          /* Currently running job */
106
    unsigned long long owner;           /* Thread id which set current job */
107

108 109
    virCond asyncCond;                  /* Use to coordinate with async jobs */
    enum qemuDomainAsyncJob asyncJob;   /* Currently active async job */
110
    unsigned long long asyncOwner;      /* Thread which set current async job */
J
Jiri Denemark 已提交
111
    int phase;                          /* Job phase (mainly for migrations) */
112 113
    unsigned long long mask;            /* Jobs allowed during async job */
    unsigned long long start;           /* When the async job started */
114
    bool dump_memory_only;              /* use dump-guest-memory to do dump */
115 116
    qemuMonitorMigrationStatus status;  /* Raw async job progress data */
    virDomainJobInfo info;              /* Processed async job progress data */
117
    bool asyncAbort;                    /* abort of async job requested */
118 119
};

120
typedef void (*qemuDomainCleanupCallback)(virQEMUDriverPtr driver,
121
                                          virDomainObjPtr vm);
122 123
typedef struct _qemuDomainCCWAddressSet qemuDomainCCWAddressSet;
typedef qemuDomainCCWAddressSet *qemuDomainCCWAddressSetPtr;
124

125 126 127
typedef struct _qemuDomainObjPrivate qemuDomainObjPrivate;
typedef qemuDomainObjPrivate *qemuDomainObjPrivatePtr;
struct _qemuDomainObjPrivate {
128
    struct qemuDomainJobObj job;
129 130

    qemuMonitorPtr mon;
131
    virDomainChrSourceDefPtr monConfig;
E
Eric Blake 已提交
132
    bool monJSON;
133 134
    bool monError;
    unsigned long long monStart;
D
Daniel P. Berrange 已提交
135 136 137 138 139

    qemuAgentPtr agent;
    bool agentError;
    unsigned long long agentStart;

140
    bool gotShutdown;
141
    bool beingDestroyed;
142
    char *pidfile;
143 144 145 146

    int nvcpupids;
    int *vcpupids;

147
    virDomainPCIAddressSetPtr pciaddrs;
148
    qemuDomainCCWAddressSetPtr ccwaddrs;
149
    int persistentAddrs;
150

151
    virQEMUCapsPtr qemuCaps;
152
    char *lockState;
153 154

    bool fakeReboot;
155 156

    int jobs_queued;
157 158

    unsigned long migMaxBandwidth;
J
Jiri Denemark 已提交
159
    char *origname;
160
    int nbdPort; /* Port used for migration with NBD */
161
    unsigned short migrationPort;
162
    int preMigrationState;
163

164
    virChrdevsPtr devs;
165 166 167 168

    qemuDomainCleanupCallback *cleanupCallbacks;
    size_t ncleanupCallbacks;
    size_t ncleanupCallbacks_max;
169 170

    virCgroupPtr cgroup;
171 172 173

    virCond unplugFinished; /* signals that unpluggingDevice was unplugged */
    const char *unpluggingDevice; /* alias of the device that is being unplugged */
174
    char **qemuDevices; /* NULL-terminated list of devices aliases known to QEMU */
175 176

    bool hookRun;  /* true if there was a hook run over this domain */
177 178

    bool quiesced; /* true if filesystems are quiesced */
179 180
};

C
Chen Fan 已提交
181 182
typedef enum {
    QEMU_PROCESS_EVENT_WATCHDOG = 0,
183
    QEMU_PROCESS_EVENT_GUESTPANIC,
184
    QEMU_PROCESS_EVENT_DEVICE_DELETED,
C
Chen Fan 已提交
185 186 187 188 189

    QEMU_PROCESS_EVENT_LAST
} qemuProcessEventType;

struct qemuProcessEvent {
190
    virDomainObjPtr vm;
C
Chen Fan 已提交
191
    qemuProcessEventType eventType;
192
    int action;
193
    void *data;
194 195
};

J
Jiri Denemark 已提交
196 197 198 199 200
const char *qemuDomainAsyncJobPhaseToString(enum qemuDomainAsyncJob job,
                                            int phase);
int qemuDomainAsyncJobPhaseFromString(enum qemuDomainAsyncJob job,
                                      const char *phase);

201
void qemuDomainEventFlush(int timer, void *opaque);
202

203
void qemuDomainEventQueue(virQEMUDriverPtr driver,
204
                          virObjectEventPtr event);
205

206
int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
207
                          virDomainObjPtr obj,
208 209
                          enum qemuDomainJob job)
    ATTRIBUTE_RETURN_CHECK;
210
int qemuDomainObjBeginAsyncJob(virQEMUDriverPtr driver,
211
                               virDomainObjPtr obj,
212 213 214
                               enum qemuDomainAsyncJob asyncJob)
    ATTRIBUTE_RETURN_CHECK;

215
bool qemuDomainObjEndJob(virQEMUDriverPtr driver,
216
                         virDomainObjPtr obj)
217
    ATTRIBUTE_RETURN_CHECK;
218
bool qemuDomainObjEndAsyncJob(virQEMUDriverPtr driver,
219
                              virDomainObjPtr obj)
220
    ATTRIBUTE_RETURN_CHECK;
221
void qemuDomainObjAbortAsyncJob(virDomainObjPtr obj);
222
void qemuDomainObjSetJobPhase(virQEMUDriverPtr driver,
J
Jiri Denemark 已提交
223 224
                              virDomainObjPtr obj,
                              int phase);
225 226
void qemuDomainObjSetAsyncJobMask(virDomainObjPtr obj,
                                  unsigned long long allowedJobs);
227 228
void qemuDomainObjRestoreJob(virDomainObjPtr obj,
                             struct qemuDomainJobObj *job);
229
void qemuDomainObjTransferJob(virDomainObjPtr obj);
230
void qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver,
231
                                  virDomainObjPtr obj);
232
void qemuDomainObjReleaseAsyncJob(virDomainObjPtr obj);
233

234
void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
235 236
                               virDomainObjPtr obj)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
237
void qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
238 239
                              virDomainObjPtr obj)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
240
int qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
241 242 243
                                   virDomainObjPtr obj,
                                   enum qemuDomainAsyncJob asyncJob)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
D
Daniel P. Berrange 已提交
244 245


246 247 248 249
void qemuDomainObjEnterAgent(virDomainObjPtr obj)
    ATTRIBUTE_NONNULL(1);
void qemuDomainObjExitAgent(virDomainObjPtr obj)
    ATTRIBUTE_NONNULL(1);
D
Daniel P. Berrange 已提交
250 251


252 253 254 255
void qemuDomainObjEnterRemote(virDomainObjPtr obj)
    ATTRIBUTE_NONNULL(1);
void qemuDomainObjExitRemote(virDomainObjPtr obj)
    ATTRIBUTE_NONNULL(1);
256

257 258 259 260
virDomainDefPtr qemuDomainDefCopy(virQEMUDriverPtr driver,
                                  virDomainDefPtr src,
                                  unsigned int flags);

261
int qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
262 263 264 265
                           virDomainDefPtr vm,
                           unsigned int flags,
                           virBuffer *buf);

266
char *qemuDomainDefFormatXML(virQEMUDriverPtr driver,
267
                             virDomainDefPtr vm,
268
                             unsigned int flags);
269

270
char *qemuDomainFormatXML(virQEMUDriverPtr driver,
271
                          virDomainObjPtr vm,
272
                          unsigned int flags);
273

274
char *qemuDomainDefFormatLive(virQEMUDriverPtr driver,
275
                              virDomainDefPtr def,
276 277
                              bool inactive,
                              bool compatible);
278

279
void qemuDomainObjTaint(virQEMUDriverPtr driver,
280
                        virDomainObjPtr obj,
281 282
                        enum virDomainTaintFlags taint,
                        int logFD);
283

284
void qemuDomainObjCheckTaint(virQEMUDriverPtr driver,
285 286
                             virDomainObjPtr obj,
                             int logFD);
287
void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
288
                                 virDomainObjPtr obj,
289 290
                                 virDomainDiskDefPtr disk,
                                 int logFD);
291
void qemuDomainObjCheckNetTaint(virQEMUDriverPtr driver,
292
                                virDomainObjPtr obj,
293 294
                                virDomainNetDefPtr net,
                                int logFD);
295

296

297 298 299
int qemuDomainCreateLog(virQEMUDriverPtr driver, virDomainObjPtr vm, bool append);
int qemuDomainOpenLog(virQEMUDriverPtr driver, virDomainObjPtr vm, off_t pos);
int qemuDomainAppendLog(virQEMUDriverPtr driver,
300 301 302
                        virDomainObjPtr vm,
                        int logFD,
                        const char *fmt, ...) ATTRIBUTE_FMT_PRINTF(4, 5);
303

304
const char *qemuFindQemuImgBinary(virQEMUDriverPtr driver);
305 306 307 308 309

int qemuDomainSnapshotWriteMetadata(virDomainObjPtr vm,
                                    virDomainSnapshotObjPtr snapshot,
                                    char *snapshotDir);

310
int qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
311 312 313 314 315
                                   virDomainObjPtr vm,
                                   virDomainSnapshotObjPtr snap,
                                   const char *op,
                                   bool try_all);

316
int qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
317 318 319 320 321
                              virDomainObjPtr vm,
                              virDomainSnapshotObjPtr snap,
                              bool update_current,
                              bool metadata_only);

322 323 324
typedef struct _virQEMUSnapRemove virQEMUSnapRemove;
typedef virQEMUSnapRemove *virQEMUSnapRemovePtr;
struct _virQEMUSnapRemove {
325
    virQEMUDriverPtr driver;
326 327 328 329 330 331 332 333 334 335
    virDomainObjPtr vm;
    int err;
    bool metadata_only;
    bool current;
};

void qemuDomainSnapshotDiscardAll(void *payload,
                                  const void *name,
                                  void *data);

336
int qemuDomainSnapshotDiscardAllMetadata(virQEMUDriverPtr driver,
337 338
                                         virDomainObjPtr vm);

339
void qemuDomainRemoveInactive(virQEMUDriverPtr driver,
340 341
                              virDomainObjPtr vm);

342
void qemuDomainSetFakeReboot(virQEMUDriverPtr driver,
343 344 345
                             virDomainObjPtr vm,
                             bool value);

346 347
bool qemuDomainJobAllowed(qemuDomainObjPrivatePtr priv,
                          enum qemuDomainJob job);
M
Michal Privoznik 已提交
348

349
int qemuDomainCheckDiskPresence(virQEMUDriverPtr driver,
M
Michal Privoznik 已提交
350 351
                                virDomainObjPtr vm,
                                bool start_with_state);
352

353
int qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
354
                                 virDomainObjPtr vm,
355 356
                                 virDomainDiskDefPtr disk,
                                 bool force);
357 358 359 360 361

int qemuDomainCleanupAdd(virDomainObjPtr vm,
                         qemuDomainCleanupCallback cb);
void qemuDomainCleanupRemove(virDomainObjPtr vm,
                             qemuDomainCleanupCallback cb);
362
void qemuDomainCleanupRun(virQEMUDriverPtr driver,
363 364
                          virDomainObjPtr vm);

365 366
extern virDomainXMLPrivateDataCallbacks virQEMUDriverPrivateDataCallbacks;
extern virDomainXMLNamespace virQEMUDriverDomainXMLNamespace;
367
extern virDomainDefParserConfig virQEMUDriverDomainDefParserConfig;
368

369 370 371
int qemuDomainUpdateDeviceList(virQEMUDriverPtr driver,
                               virDomainObjPtr vm);

372 373 374
bool qemuDomainDefCheckABIStability(virQEMUDriverPtr driver,
                                    virDomainDefPtr src,
                                    virDomainDefPtr dst);
375 376 377 378

bool qemuDomainAgentAvailable(qemuDomainObjPrivatePtr priv,
                              bool reportError);

379
#endif /* __QEMU_DOMAIN_H__ */