← Back to branch summary

~serge-hallyn/ubuntu/natty/lxc/lxc-clone

« back to all changes in this revision

Viewing changes to src/lxc/lxc_checkpoint.c

  • Committer: Bazaar Package Importer
  • Author(s): Guido Trotter
  • Date: 2010-06-28 10:15:48 UTC
  • mfrom: (1.1.4 upstream) (3.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20100628101548-3m2wszl7kdo32u2n
Tags: 0.7.1-1
* New upstream version
* Convert to quilt format
* Use pristine-tar option in git-buildpackage
* lxc-$distro scripts (debian, fedora, sshd, ubuntu, busybox) are now
  shipped under /usr/lib/lxc/lxc/templates/
* Bump up standards version

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lxc/lxc_checkpoint.c
21
21
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22
22
 */
23
23
#define _GNU_SOURCE
 
24
#include <assert.h>
24
25
#include <stdio.h>
25
26
#include <stdlib.h>
26
27
#include <unistd.h>
27
28
#include <errno.h>
28
29
#include <sys/stat.h>
29
30
#include <sys/types.h>
 
31
#include <fcntl.h>
30
32
 
31
33
#include <lxc/lxc.h>
32
34
#include <lxc/log.h>
39
41
 
40
42
static int my_checker(const struct lxc_arguments* args)
41
43
{
42
 
        if (!args->statefile) {
 
44
        if ((!args->statefile) && (args->statefd == -1)) {
43
45
                lxc_error(args, "no statefile specified");
44
46
                return -1;
45
47
        }
46
48
 
 
49
        if ((args->statefile) && (args->statefd != -1)) {
 
50
                lxc_error(args, "--statefile AND --statefd abnormally set");
 
51
                return -1;
 
52
        }
 
53
 
47
54
        return 0;
48
55
}
49
56
 
52
59
        switch (c) {
53
60
        case 'k': args->flags = LXC_FLAG_HALT; break;
54
61
        case 'p': args->flags = LXC_FLAG_PAUSE; break;
55
 
        case 'd': args->statefile = arg; break;
 
62
        case 'S': args->statefile = arg; break;
 
63
        case 'd': {
 
64
                        int fd;
 
65
                        fd = lxc_arguments_str_to_int(args, arg);
 
66
                        if (fd < 0)
 
67
                                return -1;
 
68
 
 
69
                        args->statefd = fd;
 
70
                        break;
 
71
                }
56
72
        }
57
73
        return 0;
58
74
}
60
76
static const struct option my_longopts[] = {
61
77
        {"kill", no_argument, 0, 'k'},
62
78
        {"pause", no_argument, 0, 'p'},
63
 
        {"directory", required_argument, 0, 'd'},
 
79
        {"statefile", required_argument, 0, 'S'},
 
80
        {"statefd", required_argument, 0, 'd'},
64
81
        LXC_COMMON_OPTIONS
65
82
};
66
83
 
67
84
static struct lxc_arguments my_args = {
68
85
        .progname = "lxc-checkpoint",
69
86
        .help     = "\
70
 
--name=NAME --directory STATEFILE\n\
 
87
--name=NAME --statefile FILE\n\
71
88
\n\
72
 
lxc-checkpoint checkpoints in STATEFILE the NAME container\n\
 
89
lxc-checkpoint checkpoints in FILE the NAME container\n\
73
90
\n\
74
91
Options :\n\
75
92
  -n, --name=NAME      NAME for name of the container\n\
76
93
  -k, --kill           stop the container after checkpoint\n\
77
94
  -p, --pause          don't unfreeze the container after the checkpoint\n\
78
 
  -d, --directory=STATEFILE where to store the statefile\n",
 
95
  -S, --statefile=FILE write the container state into this file, or\n\
 
96
  -d, --statefd=FD write the container state into this file descriptor\n",
79
97
 
80
98
        .options  = my_longopts,
81
99
        .parser   = my_parser,
82
100
        .checker  = my_checker,
83
101
 
84
 
        .rcfile   = NULL,
 
102
        .statefd  = -1,
85
103
};
86
104
 
87
 
static int create_statefile(const char *dir)
88
 
{
89
 
        if (mkdir(dir, 0700) == -1 && errno != EEXIST) {
90
 
                ERROR("'%s' creation error : %m", dir);
91
 
                return -1;
92
 
        }
93
 
 
94
 
        return 0;
95
 
}
96
 
 
97
105
int main(int argc, char *argv[])
98
106
{
99
107
        int ret;
 
108
        int sfd = -1;
100
109
 
101
110
        ret = lxc_arguments_parse(&my_args, argc, argv);
102
111
        if (ret)
107
116
        if (ret)
108
117
                return ret;
109
118
 
110
 
        ret = create_statefile(my_args.statefile);
111
 
        if (ret)
112
 
                return ret;
113
 
 
114
 
        ret = lxc_checkpoint(my_args.name, my_args.statefile, my_args.flags);
 
119
        if (my_args.statefd != -1)
 
120
                sfd = my_args.statefd;
 
121
 
 
122
#define OPEN_WRITE_MODE O_CREAT | O_RDWR | O_EXCL | O_CLOEXEC | O_LARGEFILE
 
123
        if (my_args.statefile) {
 
124
                sfd = open(my_args.statefile, OPEN_WRITE_MODE, 0600);
 
125
                if (sfd < 0) {
 
126
                        ERROR("'%s' open failure : %m", my_args.statefile);
 
127
                        return sfd;
 
128
                }
 
129
        }
 
130
 
 
131
        ret = lxc_checkpoint(my_args.name, sfd, my_args.flags);
 
132
 
 
133
        assert(ret == 0 || ret == -1);
 
134
 
115
135
        if (ret)
116
136
                ERROR("failed to checkpoint '%s'", my_args.name);
117
137
        else
118
138
                INFO("'%s' checkpointed", my_args.name);
119
139
 
 
140
        if (my_args.statefile)
 
141
                close(sfd);
120
142
        return ret;
121
143
}