← Back to branch summary

~ubuntu-branches/ubuntu/quantal/lxc/quantal-201208301614

« back to all changes in this revision

Viewing changes to src/lxc/state.c

  • Committer: Bazaar Package Importer
  • Author(s): Guido Trotter
  • Date: 2009-04-29 17:49:13 UTC
  • Revision ID: james.westby@ubuntu.com-20090429174913-jvahs1ykizqtodje
Tags: upstream-0.6.2
Import upstream version 0.6.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lxc/state.c
 
1
/*
 
2
 * lxc: linux Container library
 
3
 *
 
4
 * (C) Copyright IBM Corp. 2007, 2008
 
5
 *
 
6
 * Authors:
 
7
 * Daniel Lezcano <dlezcano at fr.ibm.com>
 
8
 *
 
9
 * This library is free software; you can redistribute it and/or
 
10
 * modify it under the terms of the GNU Lesser General Public
 
11
 * License as published by the Free Software Foundation; either
 
12
 * version 2.1 of the License, or (at your option) any later version.
 
13
 *
 
14
 * This library is distributed in the hope that it will be useful,
 
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
17
 * Lesser General Public License for more details.
 
18
 *
 
19
 * You should have received a copy of the GNU Lesser General Public
 
20
 * License along with this library; if not, write to the Free Software
 
21
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
22
 */
 
23
#include <stdio.h>
 
24
#include <string.h>
 
25
#include <fcntl.h>
 
26
#include <errno.h>
 
27
#include <unistd.h>
 
28
#include <sys/types.h>
 
29
#include <sys/types.h>
 
30
#include <sys/param.h>
 
31
#include <sys/stat.h>
 
32
#include <sys/file.h>
 
33
 
 
34
#include <lxc/lxc.h>
 
35
#include <lxc/log.h>
 
36
 
 
37
lxc_log_define(lxc_state, lxc);
 
38
 
 
39
static char *strstate[] = {
 
40
        "STOPPED", "STARTING", "RUNNING", "STOPPING",
 
41
        "ABORTING", "FREEZING", "FROZEN",
 
42
};
 
43
 
 
44
const char *lxc_state2str(lxc_state_t state)
 
45
{
 
46
        if (state < STOPPED || state > MAX_STATE - 1)
 
47
                return NULL;
 
48
        return strstate[state];
 
49
}
 
50
 
 
51
lxc_state_t lxc_str2state(const char *state)
 
52
{
 
53
        int i, len;
 
54
        len = sizeof(strstate)/sizeof(strstate[0]);
 
55
        for (i = 0; i < len; i++)
 
56
                if (!strcmp(strstate[i], state))
 
57
                        return i;
 
58
        return -1;
 
59
}
 
60
 
 
61
int lxc_setstate(const char *name, lxc_state_t state)
 
62
{
 
63
        int fd, err;
 
64
        char file[MAXPATHLEN];
 
65
        const char *str = lxc_state2str(state);
 
66
 
 
67
        if (!str)
 
68
                return -1;
 
69
 
 
70
        snprintf(file, MAXPATHLEN, LXCPATH "/%s/state", name);
 
71
 
 
72
        fd = open(file, O_WRONLY);
 
73
        if (fd < 0) {
 
74
                SYSERROR("failed to open %s file", file);
 
75
                return -1;
 
76
        }
 
77
 
 
78
        if (flock(fd, LOCK_EX)) {
 
79
                SYSERROR("failed to take the lock to %s", file);
 
80
                goto out;
 
81
        }
 
82
 
 
83
        if (ftruncate(fd, 0)) {
 
84
                SYSERROR("failed to truncate the file %s", file);
 
85
                goto out;
 
86
        }
 
87
 
 
88
        if (write(fd, str, strlen(str)) < 0) {
 
89
                SYSERROR("failed to write state to %s", file);
 
90
                goto out;
 
91
        }
 
92
 
 
93
        err = 0;
 
94
out:
 
95
        close(fd);
 
96
 
 
97
        lxc_monitor_send_state(name, state);
 
98
 
 
99
        return -err;
 
100
}
 
101
 
 
102
int lxc_mkstate(const char *name)
 
103
{
 
104
        int fd;
 
105
        char file[MAXPATHLEN];
 
106
 
 
107
        snprintf(file, MAXPATHLEN, LXCPATH "/%s/state", name);
 
108
        fd = creat(file, S_IRUSR|S_IWUSR);
 
109
        if (fd < 0) {
 
110
                SYSERROR("failed to create file %s", file);
 
111
                return -1;
 
112
        }
 
113
        close(fd);
 
114
        return 0;
 
115
}
 
116
 
 
117
int lxc_rmstate(const char *name)
 
118
{
 
119
        char file[MAXPATHLEN];
 
120
        snprintf(file, MAXPATHLEN, LXCPATH "/%s/state", name);
 
121
        unlink(file);
 
122
        return 0;
 
123
}
 
124
 
 
125
lxc_state_t lxc_getstate(const char *name)
 
126
{
 
127
        int fd, err;
 
128
        char file[MAXPATHLEN];
 
129
 
 
130
        snprintf(file, MAXPATHLEN, LXCPATH "/%s/state", name);
 
131
 
 
132
        fd = open(file, O_RDONLY);
 
133
        if (fd < 0) {
 
134
                SYSERROR("failed to open %s", file);
 
135
                return -1;
 
136
        }
 
137
 
 
138
        if (flock(fd, LOCK_SH)) {
 
139
                SYSERROR("failed to take the lock to %s", file);
 
140
                close(fd);
 
141
                return -1;
 
142
        }
 
143
 
 
144
        err = read(fd, file, strlen(file));
 
145
        if (err < 0) {
 
146
                SYSERROR("failed to read file %s", file);
 
147
                close(fd);
 
148
                return -1;
 
149
        }
 
150
        file[err] = '\0';
 
151
 
 
152
        close(fd);
 
153
        return lxc_str2state(file);
 
154
}
 
155
 
 
156
static int freezer_state(const char *name)
 
157
{
 
158
        char freezer[MAXPATHLEN];
 
159
        char status[MAXPATHLEN];
 
160
        FILE *file;
 
161
        int err;
 
162
 
 
163
        snprintf(freezer, MAXPATHLEN,
 
164
                 LXCPATH "/%s/freezer.state", name);
 
165
 
 
166
        file = fopen(freezer, "r");
 
167
        if (!file)
 
168
                return -1;
 
169
 
 
170
        err = fscanf(file, "%s", status);
 
171
        fclose(file);
 
172
 
 
173
        if (err == EOF) {
 
174
                SYSERROR("failed to read %s", freezer);
 
175
                return -1;
 
176
        }
 
177
 
 
178
        return lxc_str2state(status);
 
179
}
 
180
 
 
181
lxc_state_t lxc_state(const char *name)
 
182
{
 
183
        int state = freezer_state(name);
 
184
        if (state != FROZEN && state != FREEZING)
 
185
                state = lxc_getstate(name);
 
186
        return state;
 
187
}