internal: Use size_t instead of int for command line size.
[libguestfs.git] / src / virt.c
1 /* libguestfs
2  * Copyright (C) 2010 Red Hat Inc.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #include <config.h>
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <assert.h>
24
25 #ifdef HAVE_LIBVIRT
26 #include <libvirt/libvirt.h>
27 #include <libvirt/virterror.h>
28 #endif
29
30 #ifdef HAVE_LIBXML2
31 #include <libxml/xpath.h>
32 #include <libxml/parser.h>
33 #include <libxml/tree.h>
34 #endif
35
36 #define GUESTFS_PRIVATE_FOR_EACH_DISK 1
37
38 #include "guestfs.h"
39 #include "guestfs-internal.h"
40 #include "guestfs-internal-actions.h"
41 #include "guestfs_protocol.h"
42
43 #if defined(HAVE_LIBVIRT) && defined(HAVE_LIBXML2)
44
45 static void init_libxml2 (void) __attribute__((constructor));
46
47 static void
48 init_libxml2 (void)
49 {
50   /* I am told that you don't really need to call virInitialize ... */
51
52   xmlInitParser ();
53   LIBXML_TEST_VERSION;
54 }
55
56 struct guestfs___add_libvirt_dom_argv {
57   uint64_t bitmask;
58 #define GUESTFS___ADD_LIBVIRT_DOM_READONLY_BITMASK (UINT64_C(1)<<0)
59   int readonly;
60 #define GUESTFS___ADD_LIBVIRT_DOM_IFACE_BITMASK (UINT64_C(1)<<1)
61   const char *iface;
62 #define GUESTFS___ADD_LIBVIRT_DOM_LIVE_BITMASK (UINT64_C(1)<<2)
63   int live;
64 };
65
66 static int guestfs___add_libvirt_dom (guestfs_h *g, virDomainPtr dom, const struct guestfs___add_libvirt_dom_argv *optargs);
67
68 int
69 guestfs__add_domain (guestfs_h *g, const char *domain_name,
70                      const struct guestfs_add_domain_argv *optargs)
71 {
72   virErrorPtr err;
73   virConnectPtr conn = NULL;
74   virDomainPtr dom = NULL;
75   int r = -1;
76   const char *libvirturi;
77   int readonly;
78   int live;
79   const char *iface;
80   struct guestfs___add_libvirt_dom_argv optargs2 = { .bitmask = 0 };
81
82   libvirturi = optargs->bitmask & GUESTFS_ADD_DOMAIN_LIBVIRTURI_BITMASK
83                ? optargs->libvirturi : NULL;
84   readonly = optargs->bitmask & GUESTFS_ADD_DOMAIN_READONLY_BITMASK
85              ? optargs->readonly : 0;
86   iface = optargs->bitmask & GUESTFS_ADD_DOMAIN_IFACE_BITMASK
87           ? optargs->iface : NULL;
88   live = optargs->bitmask & GUESTFS_ADD_DOMAIN_LIVE_BITMASK
89          ? optargs->live : 0;
90
91   if (live && readonly) {
92     error (g, _("you cannot set both live and readonly flags"));
93     return -1;
94   }
95
96   /* Connect to libvirt, find the domain. */
97   conn = virConnectOpenReadOnly (libvirturi);
98   if (!conn) {
99     err = virGetLastError ();
100     error (g, _("could not connect to libvirt (code %d, domain %d): %s"),
101            err->code, err->domain, err->message);
102     goto cleanup;
103   }
104
105   dom = virDomainLookupByName (conn, domain_name);
106   if (!dom) {
107     err = virGetLastError ();
108     error (g, _("no libvirt domain called '%s': %s"),
109            domain_name, err->message);
110     goto cleanup;
111   }
112
113   if (readonly) {
114     optargs2.bitmask |= GUESTFS___ADD_LIBVIRT_DOM_READONLY_BITMASK;
115     optargs2.readonly = readonly;
116   }
117   if (iface) {
118     optargs2.bitmask |= GUESTFS___ADD_LIBVIRT_DOM_IFACE_BITMASK;
119     optargs2.iface = iface;
120   }
121   if (live) {
122     optargs2.bitmask |= GUESTFS___ADD_LIBVIRT_DOM_LIVE_BITMASK;
123     optargs2.live = live;
124   }
125
126   r = guestfs___add_libvirt_dom (g, dom, &optargs2);
127
128  cleanup:
129   if (dom) virDomainFree (dom);
130   if (conn) virConnectClose (conn);
131
132   return r;
133 }
134
135 /* This function is also used in virt-df to avoid having all that
136  * stupid XPath code repeated.  This is something that libvirt should
137  * really provide.
138  *
139  * The callback function 'f' is called once for each disk.
140  *
141  * Returns number of disks, or -1 if there was an error.
142  */
143 int
144 guestfs___for_each_disk (guestfs_h *g,
145                          virDomainPtr dom,
146                          int (*f) (guestfs_h *g,
147                                    const char *filename, const char *format,
148                                    void *data),
149                          void *data)
150 {
151   int i, nr_added = 0, r = -1;
152   virErrorPtr err;
153   xmlDocPtr doc = NULL;
154   xmlXPathContextPtr xpathCtx = NULL;
155   xmlXPathObjectPtr xpathObj = NULL;
156   char *xml = NULL;
157
158   /* Domain XML. */
159   xml = virDomainGetXMLDesc (dom, 0);
160
161   if (!xml) {
162     err = virGetLastError ();
163     error (g, _("error reading libvirt XML information: %s"),
164            err->message);
165     goto cleanup;
166   }
167
168   /* Now the horrible task of parsing out the fields we need from the XML.
169    * http://www.xmlsoft.org/examples/xpath1.c
170    */
171   doc = xmlParseMemory (xml, strlen (xml));
172   if (doc == NULL) {
173     error (g, _("unable to parse XML information returned by libvirt"));
174     goto cleanup;
175   }
176
177   xpathCtx = xmlXPathNewContext (doc);
178   if (xpathCtx == NULL) {
179     error (g, _("unable to create new XPath context"));
180     goto cleanup;
181   }
182
183   /* This gives us a set of all the <disk> nodes. */
184   xpathObj = xmlXPathEvalExpression (BAD_CAST "//devices/disk", xpathCtx);
185   if (xpathObj == NULL) {
186     error (g, _("unable to evaluate XPath expression"));
187     goto cleanup;
188   }
189
190   xmlNodeSetPtr nodes = xpathObj->nodesetval;
191   for (i = 0; i < nodes->nodeNr; ++i) {
192     xmlXPathObjectPtr xptype;
193
194     /* Change the context to the current <disk> node.
195      * DV advises to reset this before each search since older versions of
196      * libxml2 might overwrite it.
197      */
198     xpathCtx->node = nodes->nodeTab[i];
199
200     /* Filename can be in <source dev=..> or <source file=..> attribute.
201      * Check the <disk type=..> attribute first to find out which one.
202      */
203     xptype = xmlXPathEvalExpression (BAD_CAST "./@type", xpathCtx);
204     if (xptype == NULL ||
205         xptype->nodesetval == NULL ||
206         xptype->nodesetval->nodeNr == 0) {
207       xmlXPathFreeObject (xptype);
208       continue;                 /* no type attribute, skip it */
209     }
210     assert (xptype->nodesetval->nodeTab[0]);
211     assert (xptype->nodesetval->nodeTab[0]->type == XML_ATTRIBUTE_NODE);
212     xmlAttrPtr attr = (xmlAttrPtr) xptype->nodesetval->nodeTab[0];
213     char *type = (char *) xmlNodeListGetString (doc, attr->children, 1);
214     xmlXPathFreeObject (xptype);
215
216     xmlXPathObjectPtr xpfilename;
217
218     if (STREQ (type, "file")) { /* type = "file" so look at source/@file */
219       free (type);
220
221       xpathCtx->node = nodes->nodeTab[i];
222       xpfilename = xmlXPathEvalExpression (BAD_CAST "./source/@file", xpathCtx);
223       if (xpfilename == NULL ||
224           xpfilename->nodesetval == NULL ||
225           xpfilename->nodesetval->nodeNr == 0) {
226         xmlXPathFreeObject (xpfilename);
227         continue;             /* disk filename not found, skip this */
228       }
229     } else if (STREQ (type, "block")) { /* type = "block", use source/@dev */
230       free (type);
231
232       xpathCtx->node = nodes->nodeTab[i];
233       xpfilename = xmlXPathEvalExpression (BAD_CAST "./source/@dev", xpathCtx);
234       if (xpfilename == NULL ||
235           xpfilename->nodesetval == NULL ||
236           xpfilename->nodesetval->nodeNr == 0) {
237         xmlXPathFreeObject (xpfilename);
238         continue;             /* disk filename not found, skip this */
239       }
240     } else {
241       free (type);
242       continue;               /* type <> "file" or "block", skip it */
243     }
244
245     assert (xpfilename->nodesetval->nodeTab[0]);
246     assert (xpfilename->nodesetval->nodeTab[0]->type == XML_ATTRIBUTE_NODE);
247     attr = (xmlAttrPtr) xpfilename->nodesetval->nodeTab[0];
248     char *filename = (char *) xmlNodeListGetString (doc, attr->children, 1);
249
250     /* Get the disk format (may not be set). */
251     xmlXPathObjectPtr xpformat;
252
253     xpathCtx->node = nodes->nodeTab[i];
254     xpformat = xmlXPathEvalExpression (BAD_CAST "./driver/@type", xpathCtx);
255     char *format = NULL;
256     if (xpformat != NULL &&
257         xpformat->nodesetval &&
258         xpformat->nodesetval->nodeNr > 0) {
259       assert (xpformat->nodesetval->nodeTab[0]);
260       assert (xpformat->nodesetval->nodeTab[0]->type == XML_ATTRIBUTE_NODE);
261       attr = (xmlAttrPtr) xpformat->nodesetval->nodeTab[0];
262       format = (char *) xmlNodeListGetString (doc, attr->children, 1);
263     }
264
265     int t;
266     if (f)
267       t = f (g, filename, format, data);
268     else
269       t = 0;
270
271     xmlFree (filename);
272     xmlFree (format);
273     xmlXPathFreeObject (xpfilename);
274     xmlXPathFreeObject (xpformat);
275
276     if (t == -1)
277       goto cleanup;
278
279     nr_added++;
280   }
281
282   if (nr_added == 0) {
283     error (g, _("libvirt domain has no disks"));
284     goto cleanup;
285   }
286
287   /* Successful. */
288   r = nr_added;
289
290  cleanup:
291   free (xml);
292   if (xpathObj) xmlXPathFreeObject (xpathObj);
293   if (xpathCtx) xmlXPathFreeContext (xpathCtx);
294   if (doc) xmlFreeDoc (doc);
295
296   return r;
297 }
298
299 /* This was proposed as an external API, but it's not quite baked yet. */
300
301 static int add_disk (guestfs_h *g, const char *filename, const char *format, void *optargs_vp);
302 static int connect_live (guestfs_h *g, virDomainPtr dom);
303
304 static int
305 guestfs___add_libvirt_dom (guestfs_h *g, virDomainPtr dom,
306                            const struct guestfs___add_libvirt_dom_argv *optargs)
307 {
308   size_t cmdline_pos;
309   int r;
310   int readonly;
311   const char *iface;
312   int live;
313
314   readonly =
315     optargs->bitmask & GUESTFS___ADD_LIBVIRT_DOM_READONLY_BITMASK
316     ? optargs->readonly : 0;
317   iface =
318     optargs->bitmask & GUESTFS___ADD_LIBVIRT_DOM_IFACE_BITMASK
319     ? optargs->iface : NULL;
320   live =
321     optargs->bitmask & GUESTFS___ADD_LIBVIRT_DOM_LIVE_BITMASK
322     ? optargs->live : 0;
323
324   if (live && readonly) {
325     error (g, _("you cannot set both live and readonly flags"));
326     return -1;
327   }
328
329   if (!readonly) {
330     virDomainInfo info;
331     virErrorPtr err;
332     int vm_running;
333
334     if (virDomainGetInfo (dom, &info) == -1) {
335       err = virGetLastError ();
336       error (g, _("error getting domain info: %s"), err->message);
337       return -1;
338     }
339     vm_running = info.state != VIR_DOMAIN_SHUTOFF;
340
341     if (vm_running) {
342       /* If the caller specified the 'live' flag, then they want us to
343        * try to connect to guestfsd if the domain is running.  Note
344        * that live readonly connections are not possible.
345        */
346       if (live)
347         return connect_live (g, dom);
348
349       /* Dangerous to modify the disks of a running VM. */
350       error (g, _("error: domain is a live virtual machine.\n"
351                   "Writing to the disks of a running virtual machine can cause disk corruption.\n"
352                   "Either use read-only access, or if the guest is running the guestfsd daemon\n"
353                   "specify live access.  In most libguestfs tools these options are --ro or\n"
354                   "--live respectively.  Consult the documentation for further information."));
355       return -1;
356     }
357   }
358
359   /* Add the disks. */
360   struct guestfs_add_drive_opts_argv optargs2 = { .bitmask = 0 };
361   if (readonly) {
362     optargs2.bitmask |= GUESTFS_ADD_DRIVE_OPTS_READONLY_BITMASK;
363     optargs2.readonly = readonly;
364   }
365   if (iface) {
366     optargs2.bitmask |= GUESTFS_ADD_DRIVE_OPTS_IFACE_BITMASK;
367     optargs2.iface = iface;
368   }
369
370   /* Checkpoint the command line around the operation so that either
371    * all disks are added or none are added.
372    */
373   cmdline_pos = guestfs___checkpoint_cmdline (g);
374   r = guestfs___for_each_disk (g, dom, add_disk, &optargs2);
375   if (r == -1)
376     guestfs___rollback_cmdline (g, cmdline_pos);
377
378   return r;
379 }
380
381 static int
382 add_disk (guestfs_h *g, const char *filename, const char *format,
383           void *optargs_vp)
384 {
385   struct guestfs_add_drive_opts_argv *optargs = optargs_vp;
386
387   if (format) {
388     optargs->bitmask |= GUESTFS_ADD_DRIVE_OPTS_FORMAT_BITMASK;
389     optargs->format = format;
390   } else
391     optargs->bitmask &= ~GUESTFS_ADD_DRIVE_OPTS_FORMAT_BITMASK;
392
393   return guestfs__add_drive_opts (g, filename, optargs);
394 }
395
396 static int
397 connect_live (guestfs_h *g, virDomainPtr dom)
398 {
399   int i, r = -1;
400   virErrorPtr err;
401   xmlDocPtr doc = NULL;
402   xmlXPathContextPtr xpathCtx = NULL;
403   xmlXPathObjectPtr xpathObj = NULL;
404   char *xml = NULL;
405   char *path = NULL;
406   char *attach_method = NULL;
407
408   /* Domain XML. */
409   xml = virDomainGetXMLDesc (dom, 0);
410
411   if (!xml) {
412     err = virGetLastError ();
413     error (g, _("error reading libvirt XML information: %s"),
414            err->message);
415     goto cleanup;
416   }
417
418   /* Parse XML to document. */
419   doc = xmlParseMemory (xml, strlen (xml));
420   if (doc == NULL) {
421     error (g, _("unable to parse XML information returned by libvirt"));
422     goto cleanup;
423   }
424
425   xpathCtx = xmlXPathNewContext (doc);
426   if (xpathCtx == NULL) {
427     error (g, _("unable to create new XPath context"));
428     goto cleanup;
429   }
430
431   /* This gives us a set of all the <channel> nodes related to the
432    * guestfsd virtio-serial channel.
433    */
434   xpathObj = xmlXPathEvalExpression (BAD_CAST
435       "//devices/channel[@type=\"unix\" and "
436                         "./source/@mode=\"bind\" and "
437                         "./source/@path and "
438                         "./target/@type=\"virtio\" and "
439                         "./target/@name=\"org.libguestfs.channel.0\"]",
440                                      xpathCtx);
441   if (xpathObj == NULL) {
442     error (g, _("unable to evaluate XPath expression"));
443     goto cleanup;
444   }
445
446   xmlNodeSetPtr nodes = xpathObj->nodesetval;
447   for (i = 0; i < nodes->nodeNr; ++i) {
448     xmlXPathObjectPtr xppath;
449
450     /* See note in function above. */
451     xpathCtx->node = nodes->nodeTab[i];
452
453     /* The path is in <source path=..> attribute. */
454     xppath = xmlXPathEvalExpression (BAD_CAST "./source/@path", xpathCtx);
455     if (xppath == NULL ||
456         xppath->nodesetval == NULL ||
457         xppath->nodesetval->nodeNr == 0) {
458       xmlXPathFreeObject (xppath);
459       continue;                 /* no type attribute, skip it */
460     }
461     assert (xppath->nodesetval->nodeTab[0]);
462     assert (xppath->nodesetval->nodeTab[0]->type == XML_ATTRIBUTE_NODE);
463     xmlAttrPtr attr = (xmlAttrPtr) xppath->nodesetval->nodeTab[0];
464     path = (char *) xmlNodeListGetString (doc, attr->children, 1);
465     xmlXPathFreeObject (xppath);
466     break;
467   }
468
469   if (path == NULL) {
470     error (g, _("this guest has no libvirt <channel> definition for guestfsd\n"
471                 "See ATTACHING TO RUNNING DAEMONS in guestfs(3) for further information."));
472     goto cleanup;
473   }
474
475   /* Got a path. */
476   attach_method = safe_malloc (g, strlen (path) + 5 + 1);
477   strcpy (attach_method, "unix:");
478   strcat (attach_method, path);
479   r = guestfs_set_attach_method (g, attach_method);
480
481  cleanup:
482   free (path);
483   free (attach_method);
484   free (xml);
485   if (xpathObj) xmlXPathFreeObject (xpathObj);
486   if (xpathCtx) xmlXPathFreeContext (xpathCtx);
487   if (doc) xmlFreeDoc (doc);
488
489   return r;
490 }
491
492 #else /* no libvirt or libxml2 at compile time */
493
494 #define NOT_IMPL(r)                                                     \
495   error (g, _("add-domain API not available since this version of libguestfs was compiled without libvirt or libxml2")); \
496   return r
497
498 int
499 guestfs__add_domain (guestfs_h *g, const char *dom,
500                      const struct guestfs_add_domain_argv *optargs)
501 {
502   NOT_IMPL(-1);
503 }
504
505 #endif /* no libvirt or libxml2 at compile time */