← Back to branch summary

~ubuntu-branches/ubuntu/wily/qemu-kvm-spice/wily

« back to all changes in this revision

Viewing changes to migration-fd.c

  • Committer: Bazaar Package Importer
  • Author(s): Serge Hallyn
  • Date: 2011-10-19 10:44:56 UTC
  • Revision ID: james.westby@ubuntu.com-20111019104456-xgvskumk3sxi97f4
Tags: upstream-0.15.0+noroms
Import upstream version 0.15.0+noroms

Show diffs side-by-side

added added

removed removed

Lines of Context:
migration-fd.c
 
1
/*
 
2
 * QEMU live migration via generic fd
 
3
 *
 
4
 * Copyright Red Hat, Inc. 2009
 
5
 *
 
6
 * Authors:
 
7
 *  Chris Lalancette <clalance@redhat.com>
 
8
 *
 
9
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 
10
 * the COPYING file in the top-level directory.
 
11
 *
 
12
 */
 
13
 
 
14
#include "qemu-common.h"
 
15
#include "qemu_socket.h"
 
16
#include "migration.h"
 
17
#include "monitor.h"
 
18
#include "qemu-char.h"
 
19
#include "buffered_file.h"
 
20
#include "block.h"
 
21
#include "qemu_socket.h"
 
22
 
 
23
//#define DEBUG_MIGRATION_FD
 
24
 
 
25
#ifdef DEBUG_MIGRATION_FD
 
26
#define DPRINTF(fmt, ...) \
 
27
    do { printf("migration-fd: " fmt, ## __VA_ARGS__); } while (0)
 
28
#else
 
29
#define DPRINTF(fmt, ...) \
 
30
    do { } while (0)
 
31
#endif
 
32
 
 
33
static int fd_errno(FdMigrationState *s)
 
34
{
 
35
    return errno;
 
36
}
 
37
 
 
38
static int fd_write(FdMigrationState *s, const void * buf, size_t size)
 
39
{
 
40
    return write(s->fd, buf, size);
 
41
}
 
42
 
 
43
static int fd_close(FdMigrationState *s)
 
44
{
 
45
    DPRINTF("fd_close\n");
 
46
    if (s->fd != -1) {
 
47
        close(s->fd);
 
48
        s->fd = -1;
 
49
    }
 
50
    return 0;
 
51
}
 
52
 
 
53
MigrationState *fd_start_outgoing_migration(Monitor *mon,
 
54
                                            const char *fdname,
 
55
                                            int64_t bandwidth_limit,
 
56
                                            int detach,
 
57
                                            int blk,
 
58
                                            int inc)
 
59
{
 
60
    FdMigrationState *s;
 
61
 
 
62
    s = qemu_mallocz(sizeof(*s));
 
63
 
 
64
    s->fd = monitor_get_fd(mon, fdname);
 
65
    if (s->fd == -1) {
 
66
        DPRINTF("fd_migration: invalid file descriptor identifier\n");
 
67
        goto err_after_alloc;
 
68
    }
 
69
 
 
70
    if (fcntl(s->fd, F_SETFL, O_NONBLOCK) == -1) {
 
71
        DPRINTF("Unable to set nonblocking mode on file descriptor\n");
 
72
        goto err_after_open;
 
73
    }
 
74
 
 
75
    s->get_error = fd_errno;
 
76
    s->write = fd_write;
 
77
    s->close = fd_close;
 
78
    s->mig_state.cancel = migrate_fd_cancel;
 
79
    s->mig_state.get_status = migrate_fd_get_status;
 
80
    s->mig_state.release = migrate_fd_release;
 
81
 
 
82
    s->mig_state.blk = blk;
 
83
    s->mig_state.shared = inc;
 
84
 
 
85
    s->state = MIG_STATE_ACTIVE;
 
86
    s->mon = NULL;
 
87
    s->bandwidth_limit = bandwidth_limit;
 
88
 
 
89
    if (!detach) {
 
90
        migrate_fd_monitor_suspend(s, mon);
 
91
    }
 
92
 
 
93
    migrate_fd_connect(s);
 
94
    return &s->mig_state;
 
95
 
 
96
err_after_open:
 
97
    close(s->fd);
 
98
err_after_alloc:
 
99
    qemu_free(s);
 
100
    return NULL;
 
101
}
 
102
 
 
103
static void fd_accept_incoming_migration(void *opaque)
 
104
{
 
105
    QEMUFile *f = opaque;
 
106
 
 
107
    process_incoming_migration(f);
 
108
    qemu_set_fd_handler2(qemu_stdio_fd(f), NULL, NULL, NULL, NULL);
 
109
    qemu_fclose(f);
 
110
}
 
111
 
 
112
int fd_start_incoming_migration(const char *infd)
 
113
{
 
114
    int fd;
 
115
    QEMUFile *f;
 
116
 
 
117
    DPRINTF("Attempting to start an incoming migration via fd\n");
 
118
 
 
119
    fd = strtol(infd, NULL, 0);
 
120
    f = qemu_fdopen(fd, "rb");
 
121
    if(f == NULL) {
 
122
        DPRINTF("Unable to apply qemu wrapper to file descriptor\n");
 
123
        return -errno;
 
124
    }
 
125
 
 
126
    qemu_set_fd_handler2(fd, NULL, fd_accept_incoming_migration, NULL, f);
 
127
 
 
128
    return 0;
 
129
}