1#include "qemu/osdep.h"
2#include "hw/xen/xen_backend.h"
3#include "xen_domainbuild.h"
4#include "qemu/timer.h"
5#include "qemu/log.h"
6
7#include <xenguest.h>
8
9static int xenstore_domain_mkdir(char *path)
10{
11 struct xs_permissions perms_ro[] = {{
12 .id = 0,
13 },{
14 .id = xen_domid,
15 .perms = XS_PERM_READ,
16 }};
17 struct xs_permissions perms_rw[] = {{
18 .id = 0,
19 },{
20 .id = xen_domid,
21 .perms = XS_PERM_READ | XS_PERM_WRITE,
22 }};
23 const char *writable[] = { "device", "control", "error", NULL };
24 char subpath[256];
25 int i;
26
27 if (!xs_mkdir(xenstore, 0, path)) {
28 fprintf(stderr, "%s: xs_mkdir %s: failed\n", __FUNCTION__, path);
29 return -1;
30 }
31 if (!xs_set_permissions(xenstore, 0, path, perms_ro, 2)) {
32 fprintf(stderr, "%s: xs_set_permissions failed\n", __FUNCTION__);
33 return -1;
34 }
35
36 for (i = 0; writable[i]; i++) {
37 snprintf(subpath, sizeof(subpath), "%s/%s", path, writable[i]);
38 if (!xs_mkdir(xenstore, 0, subpath)) {
39 fprintf(stderr, "%s: xs_mkdir %s: failed\n", __FUNCTION__, subpath);
40 return -1;
41 }
42 if (!xs_set_permissions(xenstore, 0, subpath, perms_rw, 2)) {
43 fprintf(stderr, "%s: xs_set_permissions failed\n", __FUNCTION__);
44 return -1;
45 }
46 }
47 return 0;
48}
49
50int xenstore_domain_init1(const char *kernel, const char *ramdisk,
51 const char *cmdline)
52{
53 char *dom, uuid_string[42], vm[256], path[256];
54 int i;
55
56 snprintf(uuid_string, sizeof(uuid_string), UUID_FMT,
57 qemu_uuid[0], qemu_uuid[1], qemu_uuid[2], qemu_uuid[3],
58 qemu_uuid[4], qemu_uuid[5], qemu_uuid[6], qemu_uuid[7],
59 qemu_uuid[8], qemu_uuid[9], qemu_uuid[10], qemu_uuid[11],
60 qemu_uuid[12], qemu_uuid[13], qemu_uuid[14], qemu_uuid[15]);
61 dom = xs_get_domain_path(xenstore, xen_domid);
62 snprintf(vm, sizeof(vm), "/vm/%s", uuid_string);
63
64 xenstore_domain_mkdir(dom);
65
66 xenstore_write_str(vm, "image/ostype", "linux");
67 if (kernel)
68 xenstore_write_str(vm, "image/kernel", kernel);
69 if (ramdisk)
70 xenstore_write_str(vm, "image/ramdisk", ramdisk);
71 if (cmdline)
72 xenstore_write_str(vm, "image/cmdline", cmdline);
73
74
75 xenstore_write_str(vm, "name", qemu_name ? qemu_name : "no-name");
76 xenstore_write_str(vm, "uuid", uuid_string);
77 xenstore_write_str(dom, "name", qemu_name ? qemu_name : "no-name");
78 xenstore_write_int(dom, "domid", xen_domid);
79 xenstore_write_str(dom, "vm", vm);
80
81
82 xenstore_write_int(dom, "memory/target", ram_size >> 10);
83 xenstore_write_int(vm, "memory", ram_size >> 20);
84 xenstore_write_int(vm, "maxmem", ram_size >> 20);
85
86
87 for (i = 0; i < smp_cpus; i++) {
88 snprintf(path, sizeof(path), "cpu/%d/availability",i);
89 xenstore_write_str(dom, path, "online");
90 }
91 xenstore_write_int(vm, "vcpu_avail", smp_cpus);
92 xenstore_write_int(vm, "vcpus", smp_cpus);
93
94
95 xenstore_write_str(vm, "vncpassword", "" );
96
97 free(dom);
98 return 0;
99}
100
101int xenstore_domain_init2(int xenstore_port, int xenstore_mfn,
102 int console_port, int console_mfn)
103{
104 char *dom;
105
106 dom = xs_get_domain_path(xenstore, xen_domid);
107
108
109 xs_introduce_domain(xenstore,
110 xen_domid,
111 xenstore_mfn,
112 xenstore_port);
113
114
115 xenstore_write_int(dom, "store/ring-ref", xenstore_mfn);
116 xenstore_write_int(dom, "store/port", xenstore_port);
117
118
119 xenstore_write_str(dom, "console/type", "ioemu");
120 xenstore_write_int(dom, "console/limit", 128 * 1024);
121 xenstore_write_int(dom, "console/ring-ref", console_mfn);
122 xenstore_write_int(dom, "console/port", console_port);
123 xen_config_dev_console(0);
124
125 free(dom);
126 return 0;
127}
128
129
130
131static QEMUTimer *xen_poll;
132
133
134static void xen_domain_poll(void *opaque)
135{
136 struct xc_dominfo info;
137 int rc;
138
139 rc = xc_domain_getinfo(xen_xc, xen_domid, 1, &info);
140 if ((rc != 1) || (info.domid != xen_domid)) {
141 qemu_log("xen: domain %d is gone\n", xen_domid);
142 goto quit;
143 }
144 if (info.dying) {
145 qemu_log("xen: domain %d is dying (%s%s)\n", xen_domid,
146 info.crashed ? "crashed" : "",
147 info.shutdown ? "shutdown" : "");
148 goto quit;
149 }
150
151 timer_mod(xen_poll, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
152 return;
153
154quit:
155 qemu_system_shutdown_request();
156}
157
158static int xen_domain_watcher(void)
159{
160 int qemu_running = 1;
161 int fd[2], i, n, rc;
162 char byte;
163
164 if (pipe(fd) != 0) {
165 qemu_log("%s: Huh? pipe error: %s\n", __FUNCTION__, strerror(errno));
166 return -1;
167 }
168 if (fork() != 0)
169 return 0;
170
171
172
173 n = getdtablesize();
174 for (i = 3; i < n; i++) {
175 if (i == fd[0])
176 continue;
177 close(i);
178 }
179
180
181
182
183
184 xen_xc = xc_interface_open(0, 0, 0);
185
186
187 signal(SIGINT, SIG_IGN);
188 signal(SIGTERM, SIG_IGN);
189
190
191 while (qemu_running) {
192 rc = read(fd[0], &byte, 1);
193 switch (rc) {
194 case -1:
195 if (errno == EINTR)
196 continue;
197 qemu_log("%s: Huh? read error: %s\n", __FUNCTION__, strerror(errno));
198 qemu_running = 0;
199 break;
200 case 0:
201
202 qemu_running = 0;
203 break;
204 default:
205 qemu_log("%s: Huh? data on the watch pipe?\n", __FUNCTION__);
206 break;
207 }
208 }
209
210
211 qemu_log("%s: destroy domain %d\n", __FUNCTION__, xen_domid);
212 xc_domain_destroy(xen_xc, xen_domid);
213 _exit(0);
214}
215
216
217static void xen_domain_cleanup(void)
218{
219 char *dom;
220
221 dom = xs_get_domain_path(xenstore, xen_domid);
222 if (dom) {
223 xs_rm(xenstore, 0, dom);
224 free(dom);
225 }
226 xs_release_domain(xenstore, xen_domid);
227}
228
229int xen_domain_build_pv(const char *kernel, const char *ramdisk,
230 const char *cmdline)
231{
232 uint32_t ssidref = 0;
233 uint32_t flags = 0;
234 xen_domain_handle_t uuid;
235 unsigned int xenstore_port = 0, console_port = 0;
236 unsigned long xenstore_mfn = 0, console_mfn = 0;
237 int rc;
238
239 memcpy(uuid, qemu_uuid, sizeof(uuid));
240 rc = xen_domain_create(xen_xc, ssidref, uuid, flags, &xen_domid);
241 if (rc < 0) {
242 fprintf(stderr, "xen: xc_domain_create() failed\n");
243 goto err;
244 }
245 qemu_log("xen: created domain %d\n", xen_domid);
246 atexit(xen_domain_cleanup);
247 if (xen_domain_watcher() == -1) {
248 goto err;
249 }
250
251 xenstore_domain_init1(kernel, ramdisk, cmdline);
252
253 rc = xc_domain_max_vcpus(xen_xc, xen_domid, smp_cpus);
254 if (rc < 0) {
255 fprintf(stderr, "xen: xc_domain_max_vcpus() failed\n");
256 goto err;
257 }
258
259#if 0
260 rc = xc_domain_setcpuweight(xen_xc, xen_domid, 256);
261 if (rc < 0) {
262 fprintf(stderr, "xen: xc_domain_setcpuweight() failed\n");
263 goto err;
264 }
265#endif
266
267 rc = xc_domain_setmaxmem(xen_xc, xen_domid, ram_size >> 10);
268 if (rc < 0) {
269 fprintf(stderr, "xen: xc_domain_setmaxmem() failed\n");
270 goto err;
271 }
272
273 xenstore_port = xc_evtchn_alloc_unbound(xen_xc, xen_domid, 0);
274 console_port = xc_evtchn_alloc_unbound(xen_xc, xen_domid, 0);
275
276 rc = xc_linux_build(xen_xc, xen_domid, ram_size >> 20,
277 kernel, ramdisk, cmdline,
278 0, flags,
279 xenstore_port, &xenstore_mfn,
280 console_port, &console_mfn);
281 if (rc < 0) {
282 fprintf(stderr, "xen: xc_linux_build() failed\n");
283 goto err;
284 }
285
286 xenstore_domain_init2(xenstore_port, xenstore_mfn,
287 console_port, console_mfn);
288
289 qemu_log("xen: unpausing domain %d\n", xen_domid);
290 rc = xc_domain_unpause(xen_xc, xen_domid);
291 if (rc < 0) {
292 fprintf(stderr, "xen: xc_domain_unpause() failed\n");
293 goto err;
294 }
295
296 xen_poll = timer_new_ms(QEMU_CLOCK_REALTIME, xen_domain_poll, NULL);
297 timer_mod(xen_poll, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 1000);
298 return 0;
299
300err:
301 return -1;
302}
303
