+Mon Dec 5 12:15:16 CET 2005 Daniel Veillard <veillard@redhat.com>
+
+ * Makefile.am README TODO autogen.sh configure.in libvir.pc.in
+ libvir.spec.in docs/Makefile.am docs/apibuild.py docs/structures.fig
+ include/Makefile.am include/libvir.h src/Makefile.am src/hash.c
+ src/hash.h src/internal.h src/libvir.c src/libvir_sym.version
+ src/virsh.c: renamed to libvir
+
Fri Dec 2 15:15:26 CET 2005 Daniel Veillard <veillard@redhat.com>
* include/libxen.h src/libxen.c src/libxen_sym.version: adding
## Process this file with automake to produce Makefile.in
SUBDIRS = src include docs
-EXTRA_DIST = libxen.spec.in libxen.spec COPYING.LIB \
- libxen.pc.in libxen.pc TODO AUTHORS ChangeLog \
+EXTRA_DIST = libvir.spec.in libvir.spec COPYING.LIB \
+ libvir.pc.in libvir.pc TODO AUTHORS ChangeLog \
NEWS README
pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = libxen.pc
+pkgconfig_DATA = libvir.pc
rpm: clean
@(unset CDPATH ; $(MAKE) dist && rpmbuild -ta $(distdir).tar.gz)
- LibXen : simple library to use the Xen hypervisor
+ LibVir : simple library to use the Xen hypervisor
As of Wed Nov 2 2005, this is a completely new project, it is not
usable in any way yet.
Done:
- make dist and make rpm targets
-- set a no public by default policy for libxen symbols
+- set a no public by default policy for libvir symbols
exit 1
fi
-test -f src/libxen.c || {
+test -f src/libvir.c || {
echo "You must run this script in the top-level libxen directory"
exit 1
}
$srcdir/configure "$@"
echo
-echo "Now type 'make' to compile libxen."
+echo "Now type 'make' to compile libvir."
dnl Process this file with autoconf to produce a configure script.
-AC_INIT(src/libxen.c)
+AC_INIT(src/libvir.c)
AM_CONFIG_HEADER(config.h)
AC_CANONICAL_HOST
VERSION=${LIBXEN_VERSION}
-AM_INIT_AUTOMAKE(libxen, $VERSION)
+AM_INIT_AUTOMAKE(libvir, $VERSION)
dnl Checks for programs.
AC_PROG_CC
dnl
dnl specific tests to setup DV devel environments with debug etc ...
dnl
-if [[ "${LOGNAME}" = "veillard" -a "`pwd`" = "/u/veillard/libxen" ]] ; then
+if [[ "${LOGNAME}" = "veillard" -a "`pwd`" = "/u/veillard/libvir" ]] ; then
if test "${GCC}" = "yes" ; then
CFLAGS="-g -O -pedantic -W -Wformat -Wunused -Wimplicit -Wreturn-type -Wswitch -Wcomment -Wtrigraphs -Wformat -Wchar-subscripts -Wuninitialized -Wparentheses -Wshadow -Wpointer-arith -Wcast-align -Wwrite-strings -Waggregate-return -Wstrict-prototypes -Wmissing-prototypes -Wnested-externs -Winline -Wredundant-decls -Wall"
fi
AC_SEARCH_LIBS(xc_domain_create, [xenctrl], [], [AC_MSG_ERROR([Xen control library not found])])
AC_SEARCH_LIBS(xs_read, [xenstore], [], [AC_MSG_ERROR([Xen store library not found])])
-AC_OUTPUT(Makefile src/Makefile include/Makefile docs/Makefile libxen.pc libxen.spec)
+AC_OUTPUT(Makefile src/Makefile include/Makefile docs/Makefile libvir.pc libvir.spec)
APIPAGES=APIconstructors.html APIfiles.html APIfunctions.html \
APIsymbols.html APIchunk0.html
EXTRA_DIST= \
- libxen-api.xml apibuild.py
+ libvir-api.xml apibuild.py
man_MANS=
all: web $(man_MANS)
-api: libxen-api.xml libxen-refs.xml
+api: libvir-api.xml libvir-refs.xml
web: $(PAGES)
# echo "Validating the resulting XHTML pages" ; \
# $(XMLLINT) --nonet --valid --noout html/*.html ; fi );
-libxen-api.xml libxen-refs.xml: apibuild.py ../include/*.h ../src/*.h ../src/*.c
+libvir-api.xml libvir-refs.xml: apibuild.py ../include/*.h ../src/*.h ../src/*.c
-(./apibuild.py)
clean-local:
rm -f *~ *.bak *.hierarchy *.signals *-unused.txt
maintainer-clean-local: clean-local
- rm -rf libxen-api.xml libxen-refs.xml
+ rm -rf libvir-api.xml libvir-refs.xml
rebuild: api all
# C parser analysis code
#
ignored_files = {
- "xensh.c": "testing tool",
+ "virsh.c": "testing tool",
"hash.c": "internal hash table stuff",
"hash.h": "internal hash table stuff",
}
if self.collect_ref == 1:
oldtok = token
token = self.token()
- if oldtok[0] == "name" and oldtok[1][0:3] == "xen":
+ if oldtok[0] == "name" and oldtok[1][0:3] == "vir":
if token[0] == "sep" and token[1] == "(":
self.index_add_ref(oldtok[1], self.filename,
0, "function")
def rebuild():
builder = None
- if glob.glob("../src/libxen.c") != [] :
- print "Rebuilding API description for libxen"
- builder = docBuilder("libxen", ["../src", "../include"],
+ if glob.glob("../src/libvir.c") != [] :
+ print "Rebuilding API description for libvir"
+ builder = docBuilder("libvir", ["../src", "../include"],
[])
elif glob.glob("src/parser.c") != [] :
- print "Rebuilding API description for libxml2"
- builder = docBuilder("libxen", ["src", "include"],
+ print "Rebuilding API description for libvir"
+ builder = docBuilder("libvir", ["src", "include"],
[])
else:
print "rebuild() failed, unable to guess the module"
2250 4800 3900 4800
4 0 0 50 -1 0 18 0.0000 4 195 1005 1275 1125 Domains\001
4 0 0 50 -1 0 18 0.0000 4 195 585 1275 1440 hash \001
-4 0 0 50 -1 0 18 0.0000 4 195 1650 4725 750 xenDomainPtr\001
-4 0 0 50 -1 0 18 0.0000 4 195 2055 975 5700 xenConnectionPtr\001
+4 0 0 50 -1 0 18 0.0000 4 195 1650 4725 750 virDomainPtr\001
+4 0 0 50 -1 0 18 0.0000 4 195 2055 975 5700 virConnectionPtr\001
4 0 0 50 -1 0 18 0.0000 4 195 945 900 4200 domains\001
4 0 0 50 -1 0 18 0.0000 4 135 555 3450 2475 conn\001
4 0 0 50 -1 0 18 0.0000 4 135 615 6075 1050 name\001
## Process this file with automake to produce Makefile.in
-xenincdir = $(includedir)/libxen
+virincdir = $(includedir)/libvir
-xeninc_HEADERS = libxen.h
+virinc_HEADERS = libvir.h
install-exec-hook:
- $(mkinstalldirs) $(DESTDIR)$(xenincdir)
+ $(mkinstalldirs) $(DESTDIR)$(virincdir)
--- /dev/null
+/*
+ * libvir.h: interface for the libvir library to handle Xen domains
+ * from a process running in domain 0
+ *
+ * Copyright (C) 2005 Red Hat, Inc.
+ *
+ * See COPYING.LIB for the License of this software
+ *
+ * Daniel Veillard <veillard@redhat.com>
+ */
+
+#ifndef __VIR_VIRLIB_H__
+#define __VIR_VIRLIB_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * virConnect:
+ *
+ * a virConnect is a private structure representing a connection to
+ * the Xen Hypervisor.
+ */
+typedef struct _virConnect virConnect;
+
+/**
+ * virConnectPtr:
+ *
+ * a virConnectPtr is pointer to a virConnect private structure, this is the
+ * type used to reference a connection to the Xen Hypervisor in the API.
+ */
+typedef virConnect *virConnectPtr;
+
+/**
+ * virDomain:
+ *
+ * a virDomain is a private structure representing a Xen domain.
+ */
+typedef struct _virDomain virDomain;
+
+/**
+ * virDomainPtr:
+ *
+ * a virDomainPtr is pointer to a virDomain private structure, this is the
+ * type used to reference a Xen domain in the API.
+ */
+typedef virDomain *virDomainPtr;
+
+/**
+ * virDomainFlags:
+ *
+ * Flags OR'ed together to provide specific behaviour when creating a
+ * Domain.
+ */
+typedef enum {
+ VIR_DOMAIN_NONE = 0
+} virDomainFlags;
+
+/*
+ * Connection and disconnections to the Hypervisor
+ */
+virConnectPtr virConnectOpen (const char *name);
+virConnectPtr virConnectOpenReadOnly (const char *name);
+int virConnectClose (virConnectPtr conn);
+unsigned long virConnectGetVersion (virConnectPtr conn);
+
+/*
+ * Gather list of running domains
+ */
+int virConnectListDomains (virConnectPtr conn,
+ int *ids,
+ int maxids);
+
+/*
+ * Domain creation and destruction
+ */
+virDomainPtr virDomainCreateLinux (virConnectPtr conn,
+ const char *kernel_path,
+ const char *initrd_path,
+ const char *cmdline,
+ unsigned long memory,
+ unsigned int flags);
+virDomainPtr virDomainLookupByName (virConnectPtr conn,
+ const char *name);
+virDomainPtr virDomainLookupByID (virConnectPtr conn,
+ int id);
+int virDomainDestroy (virDomainPtr domain);
+
+/*
+ * Domain suspend/resume
+ */
+int virDomainSuspend (virDomainPtr domain);
+int virDomainResume (virDomainPtr domain);
+
+/*
+ * Dynamic control of domains
+ */
+const char * virDomainGetName (virDomainPtr domain);
+unsigned int virDomainGetID (virDomainPtr domain);
+unsigned long virDomainGetMaxMemory (virDomainPtr domain);
+int virDomainSetMaxMemory (virDomainPtr domain,
+ unsigned long memory);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __VIR_VIRLIB_H__ */
## Process this file with automake to produce Makefile.in
-xenincdir = $(includedir)/libxen
+virincdir = $(includedir)/libvir
-xeninc_HEADERS = libxen.h
+virinc_HEADERS = libvir.h
install-exec-hook:
- $(mkinstalldirs) $(DESTDIR)$(xenincdir)
+ $(mkinstalldirs) $(DESTDIR)$(virincdir)
+++ /dev/null
-/*
- * libxen.h: interface for the libxen library to handle Xen domains
- * from a process running in domain 0
- *
- * Copyright (C) 2005 Red Hat, Inc.
- *
- * See COPYING.LIB for the License of this software
- *
- * Daniel Veillard <veillard@redhat.com>
- */
-
-#ifndef __XEN_XENLIB_H__
-#define __XEN_XENLIB_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * xenConnect:
- *
- * a xenConnect is a private structure representing a connection to
- * the Xen Hypervisor.
- */
-typedef struct _xenConnect xenConnect;
-
-/**
- * xenConnectPtr:
- *
- * a xenConnectPtr is pointer to a xenConnect private structure, this is the
- * type used to reference a connection to the Xen Hypervisor in the API.
- */
-typedef xenConnect *xenConnectPtr;
-
-/**
- * xenDomain:
- *
- * a xenDomain is a private structure representing a Xen domain.
- */
-typedef struct _xenDomain xenDomain;
-
-/**
- * xenDomainPtr:
- *
- * a xenDomainPtr is pointer to a xenDomain private structure, this is the
- * type used to reference a Xen domain in the API.
- */
-typedef xenDomain *xenDomainPtr;
-
-/**
- * xenDomainFlags:
- *
- * Flags OR'ed together to provide specific behaviour when creating a
- * Domain.
- */
-typedef enum {
- XEN_DOMAIN_NONE = 0
-} xenDomainFlags;
-
-/*
- * Connection and disconnections to the Hypervisor
- */
-xenConnectPtr xenConnectOpen (const char *name);
-xenConnectPtr xenConnectOpenReadOnly (const char *name);
-int xenConnectClose (xenConnectPtr conn);
-unsigned long xenConnectGetVersion (xenConnectPtr conn);
-
-/*
- * Gather list of running domains
- */
-int xenConnectListDomains (xenConnectPtr conn,
- int *ids,
- int maxids);
-
-/*
- * Domain creation and destruction
- */
-xenDomainPtr xenDomainCreateLinux (xenConnectPtr conn,
- const char *kernel_path,
- const char *initrd_path,
- const char *cmdline,
- unsigned long memory,
- unsigned int flags);
-xenDomainPtr xenDomainLookupByName (xenConnectPtr conn,
- const char *name);
-xenDomainPtr xenDomainLookupByID (xenConnectPtr conn,
- int id);
-int xenDomainDestroy (xenDomainPtr domain);
-
-/*
- * Domain suspend/resume
- */
-int xenDomainSuspend (xenDomainPtr domain);
-int xenDomainResume (xenDomainPtr domain);
-
-/*
- * Dynamic control of domains
- */
-const char * xenDomainGetName (xenDomainPtr domain);
-unsigned int xenDomainGetID (xenDomainPtr domain);
-unsigned long xenDomainGetMaxMemory (xenDomainPtr domain);
-int xenDomainSetMaxMemory (xenDomainPtr domain,
- unsigned long memory);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __XEN_XENLIB_H__ */
Summary: Library providing an API to use the Xen virtualization
-Name: libxen
+Name: libvir
Version: @VERSION@
Release: 1
License: LGPL
Group: Development/Libraries
-Source: libxen-%{version}.tar.gz
+Source: libvir-%{version}.tar.gz
BuildRoot: %{_tmppath}/%{name}-%{version}-root
URL: http://www.gnome.org/~veillard/gamin/
BuildRequires: xen
This C library provides an API to use the Xen virtualization framework
%package devel
-Summary: Libraries, includes, etc. to compile with the libxen library
+Summary: Libraries, includes, etc. to compile with the libvir library
Group: Development/Libraries
-Requires: libxen = %{version}
+Requires: libvir = %{version}
%description devel
This C library provides an API to use the Xen virtualization framework
%{_libdir}/lib*.so
%{_libdir}/*a
-%{_includedir}/libxen/*.h
-%{_libdir}/pkgconfig/libxen.pc
+%{_includedir}/libvir/*.h
+%{_libdir}/pkgconfig/libvir.pc
%changelog
* Wed Nov 2 2005 Daniel Veillard <veillard@redhat.com> 0.0.1-1
## Process this file with automake to produce Makefile.in
INCLUDES = -I$(top_builddir)/include -I@srcdir@/include
-DEPS = libxen.la
-LDADDS = @STATIC_BINARIES@ libxen.la
+DEPS = libvir.la
+LDADDS = @STATIC_BINARIES@ libvir.la
-EXTRA_DIST = libxen_sym.version
+EXTRA_DIST = libvir_sym.version
-lib_LTLIBRARIES = libxen.la
-libxen_la_LIBADD =
-libxen_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libxen_sym.version \
+lib_LTLIBRARIES = libvir.la
+libvir_la_LIBADD =
+libvir_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libvir_sym.version \
-version-info @LIBXEN_VERSION_INFO@
-libxen_la_SOURCES = libxen.c internal.h hash.c hash.h
+libvir_la_SOURCES = libvir.c internal.h hash.c hash.h
-noinst_PROGRAMS=xensh
+noinst_PROGRAMS=virsh
-xensh_SOURCES=xensh.c
-xensh_LDFLAGS =
-xensh_DEPENDENCIES = $(DEPS)
-xensh_LDADD= $(LDADDS)
+virsh_SOURCES=virsh.c
+virsh_LDFLAGS =
+virsh_DEPENDENCIES = $(DEPS)
+virsh_LDADD= $(LDADDS)
/*
* A single entry in the hash table
*/
-typedef struct _xenHashEntry xenHashEntry;
-typedef xenHashEntry *xenHashEntryPtr;
-struct _xenHashEntry {
- struct _xenHashEntry *next;
+typedef struct _virHashEntry virHashEntry;
+typedef virHashEntry *virHashEntryPtr;
+struct _virHashEntry {
+ struct _virHashEntry *next;
char *name;
void *payload;
int valid;
/*
* The entire hash table
*/
-struct _xenHashTable {
- struct _xenHashEntry *table;
+struct _virHashTable {
+ struct _virHashEntry *table;
int size;
int nbElems;
};
/*
- * xenHashComputeKey:
+ * virHashComputeKey:
* Calculate the hash key
*/
static unsigned long
-xenHashComputeKey(xenHashTablePtr table, const char *name) {
+virHashComputeKey(virHashTablePtr table, const char *name) {
unsigned long value = 0L;
char ch;
}
/**
- * xenHashCreate:
+ * virHashCreate:
* @size: the size of the hash table
*
- * Create a new xenHashTablePtr.
+ * Create a new virHashTablePtr.
*
* Returns the newly created object, or NULL if an error occured.
*/
-xenHashTablePtr
-xenHashCreate(int size) {
- xenHashTablePtr table;
+virHashTablePtr
+virHashCreate(int size) {
+ virHashTablePtr table;
if (size <= 0)
size = 256;
- table = malloc(sizeof(xenHashTable));
+ table = malloc(sizeof(virHashTable));
if (table) {
table->size = size;
table->nbElems = 0;
- table->table = malloc(size * sizeof(xenHashEntry));
+ table->table = malloc(size * sizeof(virHashEntry));
if (table->table) {
- memset(table->table, 0, size * sizeof(xenHashEntry));
+ memset(table->table, 0, size * sizeof(virHashEntry));
return(table);
}
free(table);
}
/**
- * xenHashGrow:
+ * virHashGrow:
* @table: the hash table
* @size: the new size of the hash table
*
* Returns 0 in case of success, -1 in case of failure
*/
static int
-xenHashGrow(xenHashTablePtr table, int size) {
+virHashGrow(virHashTablePtr table, int size) {
unsigned long key;
int oldsize, i;
- xenHashEntryPtr iter, next;
- struct _xenHashEntry *oldtable;
+ virHashEntryPtr iter, next;
+ struct _virHashEntry *oldtable;
#ifdef DEBUG_GROW
unsigned long nbElem = 0;
#endif
if (oldtable == NULL)
return(-1);
- table->table = malloc(size * sizeof(xenHashEntry));
+ table->table = malloc(size * sizeof(virHashEntry));
if (table->table == NULL) {
table->table = oldtable;
return(-1);
}
- memset(table->table, 0, size * sizeof(xenHashEntry));
+ memset(table->table, 0, size * sizeof(virHashEntry));
table->size = size;
/* If the two loops are merged, there would be situations where
for (i = 0; i < oldsize; i++) {
if (oldtable[i].valid == 0)
continue;
- key = xenHashComputeKey(table, oldtable[i].name);
- memcpy(&(table->table[key]), &(oldtable[i]), sizeof(xenHashEntry));
+ key = virHashComputeKey(table, oldtable[i].name);
+ memcpy(&(table->table[key]), &(oldtable[i]), sizeof(virHashEntry));
table->table[key].next = NULL;
}
* put back the entry in the new table
*/
- key = xenHashComputeKey(table, iter->name);
+ key = virHashComputeKey(table, iter->name);
if (table->table[key].valid == 0) {
- memcpy(&(table->table[key]), iter, sizeof(xenHashEntry));
+ memcpy(&(table->table[key]), iter, sizeof(virHashEntry));
table->table[key].next = NULL;
free(iter);
} else {
#ifdef DEBUG_GROW
xmlGenericError(xmlGenericErrorContext,
- "xenHashGrow : from %d to %d, %d elems\n", oldsize, size, nbElem);
+ "virHashGrow : from %d to %d, %d elems\n", oldsize, size, nbElem);
#endif
return(0);
}
/**
- * xenHashFree:
+ * virHashFree:
* @table: the hash table
* @f: the deallocator function for items in the hash
*
* deallocated with @f if provided.
*/
void
-xenHashFree(xenHashTablePtr table, xenHashDeallocator f) {
+virHashFree(virHashTablePtr table, virHashDeallocator f) {
int i;
- xenHashEntryPtr iter;
- xenHashEntryPtr next;
+ virHashEntryPtr iter;
+ virHashEntryPtr next;
int inside_table = 0;
int nbElems;
}
/**
- * xenHashAddEntry3:
+ * virHashAddEntry3:
* @table: the hash table
* @name: the name of the userdata
* @userdata: a pointer to the userdata
* Returns 0 the addition succeeded and -1 in case of error.
*/
int
-xenHashAddEntry(xenHashTablePtr table, const char *name,
+virHashAddEntry(virHashTablePtr table, const char *name,
void *userdata) {
unsigned long key, len = 0;
- xenHashEntryPtr entry;
- xenHashEntryPtr insert;
+ virHashEntryPtr entry;
+ virHashEntryPtr insert;
if ((table == NULL) || (name == NULL))
return(-1);
/*
* Check for duplicate and insertion location.
*/
- key = xenHashComputeKey(table, name);
+ key = virHashComputeKey(table, name);
if (table->table[key].valid == 0) {
insert = NULL;
} else {
if (insert == NULL) {
entry = &(table->table[key]);
} else {
- entry = malloc(sizeof(xenHashEntry));
+ entry = malloc(sizeof(virHashEntry));
if (entry == NULL)
return(-1);
}
table->nbElems++;
if (len > MAX_HASH_LEN)
- xenHashGrow(table, MAX_HASH_LEN * table->size);
+ virHashGrow(table, MAX_HASH_LEN * table->size);
return(0);
}
/**
- * xenHashUpdateEntry:
+ * virHashUpdateEntry:
* @table: the hash table
* @name: the name of the userdata
* @userdata: a pointer to the userdata
* Returns 0 the addition succeeded and -1 in case of error.
*/
int
-xenHashUpdateEntry(xenHashTablePtr table, const char *name,
- void *userdata, xenHashDeallocator f) {
+virHashUpdateEntry(virHashTablePtr table, const char *name,
+ void *userdata, virHashDeallocator f) {
unsigned long key;
- xenHashEntryPtr entry;
- xenHashEntryPtr insert;
+ virHashEntryPtr entry;
+ virHashEntryPtr insert;
if ((table == NULL) || name == NULL)
return(-1);
/*
* Check for duplicate and insertion location.
*/
- key = xenHashComputeKey(table, name);
+ key = virHashComputeKey(table, name);
if (table->table[key].valid == 0) {
insert = NULL;
} else {
if (insert == NULL) {
entry = &(table->table[key]);
} else {
- entry = malloc(sizeof(xenHashEntry));
+ entry = malloc(sizeof(virHashEntry));
if (entry == NULL)
return(-1);
}
}
/**
- * xenHashLookup:
+ * virHashLookup:
* @table: the hash table
* @name: the name of the userdata
*
* Returns the a pointer to the userdata
*/
void *
-xenHashLookup(xenHashTablePtr table, const char *name) {
+virHashLookup(virHashTablePtr table, const char *name) {
unsigned long key;
- xenHashEntryPtr entry;
+ virHashEntryPtr entry;
if (table == NULL)
return(NULL);
if (name == NULL)
return(NULL);
- key = xenHashComputeKey(table, name);
+ key = virHashComputeKey(table, name);
if (table->table[key].valid == 0)
return(NULL);
for (entry = &(table->table[key]); entry != NULL; entry = entry->next) {
}
/**
- * xenHashSize:
+ * virHashSize:
* @table: the hash table
*
* Query the number of elements installed in the hash @table.
* -1 in case of error
*/
int
-xenHashSize(xenHashTablePtr table) {
+virHashSize(virHashTablePtr table) {
if (table == NULL)
return(-1);
return(table->nbElems);
}
/**
- * xenHashRemoveEntry:
+ * virHashRemoveEntry:
* @table: the hash table
* @name: the name of the userdata
* @f: the deallocator function for removed item (if any)
* Returns 0 if the removal succeeded and -1 in case of error or not found.
*/
int
-xenHashRemoveEntry(xenHashTablePtr table, const char *name,
- xenHashDeallocator f) {
+virHashRemoveEntry(virHashTablePtr table, const char *name,
+ virHashDeallocator f) {
unsigned long key;
- xenHashEntryPtr entry;
- xenHashEntryPtr prev = NULL;
+ virHashEntryPtr entry;
+ virHashEntryPtr prev = NULL;
if (table == NULL || name == NULL)
return(-1);
- key = xenHashComputeKey(table, name);
+ key = virHashComputeKey(table, name);
if (table->table[key].valid == 0) {
return(-1);
} else {
entry->valid = 0;
} else {
entry = entry->next;
- memcpy(&(table->table[key]), entry, sizeof(xenHashEntry));
+ memcpy(&(table->table[key]), entry, sizeof(virHashEntry));
free(entry);
}
}
* Author: Bjorn Reese <bjorn.reese@systematic.dk>
*/
-#ifndef __XEN_HASH_H__
-#define __XEN_HASH_H__
+#ifndef __VIR_HASH_H__
+#define __VIR_HASH_H__
#ifdef __cplusplus
extern "C" {
/*
* The hash table.
*/
-typedef struct _xenHashTable xenHashTable;
-typedef xenHashTable *xenHashTablePtr;
+typedef struct _virHashTable virHashTable;
+typedef virHashTable *virHashTablePtr;
/*
* function types:
*/
/**
- * xenHashDeallocator:
+ * virHashDeallocator:
* @payload: the data in the hash
* @name: the name associated
*
* Callback to free data from a hash.
*/
-typedef void (*xenHashDeallocator)(void *payload, char *name);
+typedef void (*virHashDeallocator)(void *payload, char *name);
/*
* Constructor and destructor.
*/
-xenHashTablePtr xenHashCreate (int size);
+virHashTablePtr virHashCreate (int size);
void
- xenHashFree (xenHashTablePtr table,
- xenHashDeallocator f);
-int xenHashSize (xenHashTablePtr table);
+ virHashFree (virHashTablePtr table,
+ virHashDeallocator f);
+int virHashSize (virHashTablePtr table);
/*
* Add a new entry to the hash table.
*/
-int xenHashAddEntry (xenHashTablePtr table,
+int virHashAddEntry (virHashTablePtr table,
const char *name,
void *userdata);
-int xenHashUpdateEntry(xenHashTablePtr table,
+int virHashUpdateEntry(virHashTablePtr table,
const char *name,
void *userdata,
- xenHashDeallocator f);
+ virHashDeallocator f);
/*
* Remove an entry from the hash table.
*/
-int xenHashRemoveEntry(xenHashTablePtr table,
+int virHashRemoveEntry(virHashTablePtr table,
const char *name,
- xenHashDeallocator f);
+ virHashDeallocator f);
/*
* Retrieve the userdata.
*/
-void * xenHashLookup (xenHashTablePtr table,
+void * virHashLookup (virHashTablePtr table,
const char *name);
#ifdef __cplusplus
}
#endif
-#endif /* ! __XEN_HASH_H__ */
+#endif /* ! __VIR_HASH_H__ */
* internal.h: internal definitions just used by code from the library
*/
-#ifndef __XEN_INTERNAL_H__
-#define __XEN_INTERNAL_H__
+#ifndef __VIR_INTERNAL_H__
+#define __VIR_INTERNAL_H__
#ifdef __cplusplus
extern "C" {
}
#endif /* __cplusplus */
-#endif /* __XEN_INTERNAL_H__ */
+#endif /* __VIR_INTERNAL_H__ */
/*
- * libxen.h: Main interfaces for the libxen library to handle virtualization
+ * libvir.h: Main interfaces for the libvir library to handle virtualization
* domains from a process running in domain 0
*
* Copyright (C) 2005 Red Hat, Inc.
* Daniel Veillard <veillard@redhat.com>
*/
-#include "libxen.h"
+#include "libvir.h"
#include <stdio.h>
#include <stdlib.h>
* - memory wrappers for malloc/free ?
*/
-#define XEN_CONNECT_MAGIC 0x4F23DEAD
+#define VIR_CONNECT_MAGIC 0x4F23DEAD
/*
* Flags for Xen connections
*/
-#define XEN_CONNECT_RO 1
+#define VIR_CONNECT_RO 1
/**
- * _xenConnect:
+ * _virConnect:
*
* Internal structure associated to a connection
*/
-struct _xenConnect {
+struct _virConnect {
unsigned int magic; /* specific value to check */
int handle; /* internal handle used for hypercall */
struct xs_handle *xshandle; /* handle to talk to the xenstore */
- xenHashTablePtr domains; /* hash table for known domains */
+ virHashTablePtr domains; /* hash table for known domains */
int flags; /* a set of connection flags */
};
-#define XEN_DOMAIN_MAGIC 0xDEAD4321
+#define VIR_DOMAIN_MAGIC 0xDEAD4321
/**
- * _xenDomain:
+ * _virDomain:
*
* Internal structure associated to a domain
*/
-struct _xenDomain {
+struct _virDomain {
unsigned int magic; /* specific value to check */
- xenConnectPtr conn; /* pointer back to the connection */
+ virConnectPtr conn; /* pointer back to the connection */
char *name; /* the domain external name */
char *path; /* the domain internal path */
int handle; /* internal handle for the dmonain ID */
};
/**
- * xenConnectOpen:
+ * virConnectOpen:
* @name: optional argument currently unused, pass NULL
*
* This function should be called first to get a connection to the
*
* Returns a pointer to the hypervisor connection or NULL in case of error
*/
-xenConnectPtr
-xenConnectOpen(const char *name) {
- xenConnectPtr ret = NULL;
+virConnectPtr
+virConnectOpen(const char *name) {
+ virConnectPtr ret = NULL;
int handle = -1;
struct xs_handle *xshandle = NULL;
if (xshandle == NULL)
goto failed;
- ret = (xenConnectPtr) malloc(sizeof(xenConnect));
+ ret = (virConnectPtr) malloc(sizeof(virConnect));
if (ret == NULL)
goto failed;
- ret->magic = XEN_CONNECT_MAGIC;
+ ret->magic = VIR_CONNECT_MAGIC;
ret->handle = handle;
ret->xshandle = xshandle;
- ret->domains = xenHashCreate(20);
+ ret->domains = virHashCreate(20);
ret->flags = 0;
if (ret->domains == NULL)
goto failed;
}
/**
- * xenConnectOpenReadOnly:
+ * virConnectOpenReadOnly:
* @name: optional argument currently unused, pass NULL
*
* This function should be called first to get a read-only connection to the
*
* Returns a pointer to the hypervisor connection or NULL in case of error
*/
-xenConnectPtr
-xenConnectOpenReadOnly(const char *name) {
- xenConnectPtr ret = NULL;
+virConnectPtr
+virConnectOpenReadOnly(const char *name) {
+ virConnectPtr ret = NULL;
struct xs_handle *xshandle = NULL;
/* we can only talk to the local Xen supervisor ATM */
if (xshandle == NULL)
goto failed;
- ret = (xenConnectPtr) malloc(sizeof(xenConnect));
+ ret = (virConnectPtr) malloc(sizeof(virConnect));
if (ret == NULL)
goto failed;
- ret->magic = XEN_CONNECT_MAGIC;
+ ret->magic = VIR_CONNECT_MAGIC;
ret->handle = -1;
ret->xshandle = xshandle;
- ret->domains = xenHashCreate(20);
- ret->flags = XEN_CONNECT_RO;
+ ret->domains = virHashCreate(20);
+ ret->flags = VIR_CONNECT_RO;
if (ret->domains == NULL)
goto failed;
}
/**
- * xenDomainDestroyName:
+ * virDomainDestroyName:
* @domain: a domain object
*
* Destroy the domain object, this is just used by the domain hash callback.
* Returns 0 in case of success and -1 in case of failure.
*/
static int
-xenDomainDestroyName(xenDomainPtr domain, const char *name ATTRIBUTE_UNUSED) {
- return(xenDomainDestroy(domain));
+virDomainDestroyName(virDomainPtr domain, const char *name ATTRIBUTE_UNUSED) {
+ return(virDomainDestroy(domain));
}
/**
- * xenConnectClose:
+ * virConnectClose:
* @conn: pointer to the hypervisor connection
*
* This function closes the connection to the Hypervisor. This should
* Returns 0 in case of success or -1 in case of error.
*/
int
-xenConnectClose(xenConnectPtr conn) {
- if ((conn == NULL) || (conn->magic != XEN_CONNECT_MAGIC))
+virConnectClose(virConnectPtr conn) {
+ if ((conn == NULL) || (conn->magic != VIR_CONNECT_MAGIC))
return(-1);
- xenHashFree(conn->domains, (xenHashDeallocator) xenDomainDestroyName);
+ virHashFree(conn->domains, (virHashDeallocator) virDomainDestroyName);
conn->magic = -1;
xs_daemon_close(conn->xshandle);
conn->xshandle = NULL;
}
/**
- * xenConnectGetVersion:
+ * virConnectGetVersion:
* @conn: pointer to the hypervisor connection
*
* Get the version level of the Hypervisor running.
* Returns -1 in case of error or major * 10,000 + minor * 100 + rev otherwise
*/
unsigned long
-xenConnectGetVersion(xenConnectPtr conn) {
+virConnectGetVersion(virConnectPtr conn) {
if (conn == NULL)
return(-1);
TODO
}
/**
- * xenConnectListDomains:
+ * virConnectListDomains:
* @conn: pointer to the hypervisor connection
* @ids: array to collect the list of IDs of active domains
* @maxids: size of @ids
* Returns the number of domain found or -1 in case of error
*/
int
-xenConnectListDomains(xenConnectPtr conn, int *ids, int maxids) {
+virConnectListDomains(virConnectPtr conn, int *ids, int maxids) {
struct xs_transaction_handle* t;
int ret = -1;
unsigned int num, i;
long id;
char **idlist = NULL, *endptr;
- if ((conn == NULL) || (conn->magic != XEN_CONNECT_MAGIC) ||
+ if ((conn == NULL) || (conn->magic != VIR_CONNECT_MAGIC) ||
(ids == NULL) || (maxids <= 0))
return(-1);
}
/**
- * xenDomainCreateLinux:
+ * virDomainCreateLinux:
* @conn: pointer to the hypervisor connection
* @kernel_path: the file path to the kernel image
* @initrd_path: an optional file path to an initrd
* @cmdline: optional command line parameters for the kernel
* @memory: the memory size in kilobytes
- * @flags: an optional set of xenDomainFlags
+ * @flags: an optional set of virDomainFlags
*
* Launch a new Linux guest domain
*
* Returns a new domain object or NULL in case of failure
*/
-xenDomainPtr
-xenDomainCreateLinux(xenConnectPtr conn, const char *kernel_path,
+virDomainPtr
+virDomainCreateLinux(virConnectPtr conn, const char *kernel_path,
const char *initrd_path, const char *cmdline,
unsigned long memory, unsigned int flags) {
- if ((conn == NULL) || (conn->magic != XEN_CONNECT_MAGIC) ||
+ if ((conn == NULL) || (conn->magic != VIR_CONNECT_MAGIC) ||
(kernel_path == NULL) || (memory < 4096))
return(NULL);
TODO
}
/**
- * xenDomainLookupByName:
+ * virDomainLookupByName:
* @conn: pointer to the hypervisor connection
* @name: name for the domain
*
*
* Returns a new domain object or NULL in case of failure
*/
-xenDomainPtr
-xenDomainLookupByName(xenConnectPtr conn, const char *name) {
- if ((conn == NULL) || (conn->magic != XEN_CONNECT_MAGIC) || (name == NULL))
+virDomainPtr
+virDomainLookupByName(virConnectPtr conn, const char *name) {
+ if ((conn == NULL) || (conn->magic != VIR_CONNECT_MAGIC) || (name == NULL))
return(NULL);
TODO
return(NULL);
}
/**
- * xenConnectDoStoreQuery:
+ * virConnectDoStoreQuery:
* @conn: pointer to the hypervisor connection
* @path: the absolute path of the data in the store to retrieve
*
* Returns a string which must be freed by the caller or NULL in case of error
*/
static char *
-xenConnectDoStoreQuery(xenConnectPtr conn, const char *path) {
+virConnectDoStoreQuery(virConnectPtr conn, const char *path) {
struct xs_transaction_handle* t;
char *ret = NULL;
unsigned int len = 0;
}
/**
- * xenDomainDoStoreQuery:
+ * virDomainDoStoreQuery:
* @domain: a domain object
* @path: the relative path of the data in the store to retrieve
*
* Returns a string which must be freed by the caller or NULL in case of error
*/
static char *
-xenDomainDoStoreQuery(xenDomainPtr domain, const char *path) {
+virDomainDoStoreQuery(virDomainPtr domain, const char *path) {
struct xs_transaction_handle* t;
char s[256];
char *ret = NULL;
}
/**
- * xenDomainLookupByID:
+ * virDomainLookupByID:
* @conn: pointer to the hypervisor connection
* @id: the domain ID number
*
*
* Returns a new domain object or NULL in case of failure
*/
-xenDomainPtr
-xenDomainLookupByID(xenConnectPtr conn, int id) {
+virDomainPtr
+virDomainLookupByID(virConnectPtr conn, int id) {
char *path;
- xenDomainPtr ret;
+ virDomainPtr ret;
xc_dominfo_t info;
int res;
- if ((conn == NULL) || (conn->magic != XEN_CONNECT_MAGIC) || (id < 0))
+ if ((conn == NULL) || (conn->magic != VIR_CONNECT_MAGIC) || (id < 0))
return(NULL);
- if ((conn->flags & XEN_CONNECT_RO) == 0) {
+ if ((conn->flags & VIR_CONNECT_RO) == 0) {
res = xc_domain_getinfo(conn->handle, (uint32_t) id, 1, &info);
if (res != 1) {
return(NULL);
if (path == NULL) {
return(NULL);
}
- ret = (xenDomainPtr) malloc(sizeof(xenDomain));
+ ret = (virDomainPtr) malloc(sizeof(virDomain));
if (ret == NULL) {
free(path);
return(NULL);
}
- ret->magic = XEN_DOMAIN_MAGIC;
+ ret->magic = VIR_DOMAIN_MAGIC;
ret->conn = conn;
ret->handle = id;
ret->path = path;
- ret->name = xenDomainDoStoreQuery(ret, "name");
+ ret->name = virDomainDoStoreQuery(ret, "name");
return(ret);
}
/**
- * xenDomainDestroy:
+ * virDomainDestroy:
* @domain: a domain object
*
* Destroy the domain object. The running instance is shutdown if not down
* Returns 0 in case of success and -1 in case of failure.
*/
int
-xenDomainDestroy(xenDomainPtr domain) {
- if ((domain == NULL) || (domain->magic != XEN_DOMAIN_MAGIC))
+virDomainDestroy(virDomainPtr domain) {
+ if ((domain == NULL) || (domain->magic != VIR_DOMAIN_MAGIC))
return(-1);
TODO
return(-1);
}
/**
- * xenDomainSuspend:
+ * virDomainSuspend:
* @domain: a domain object
*
* Suspends an active domain, the process is frozen without further access
* to CPU resources and I/O but the memory used by the domain at the
- * hypervisor level will stay allocated. Use xenDomainResume() to reactivate
+ * hypervisor level will stay allocated. Use virDomainResume() to reactivate
* the domain.
*
* Returns 0 in case of success and -1 in case of failure.
*/
int
-xenDomainSuspend(xenDomainPtr domain) {
- if ((domain == NULL) || (domain->magic != XEN_DOMAIN_MAGIC))
+virDomainSuspend(virDomainPtr domain) {
+ if ((domain == NULL) || (domain->magic != VIR_DOMAIN_MAGIC))
return(-1);
TODO
return(-1);
}
/**
- * xenDomainResume:
+ * virDomainResume:
* @domain: a domain object
*
* Resume an suspended domain, the process is restarted from the state where
- * it was frozen by calling xenSuspendDomain().
+ * it was frozen by calling virSuspendDomain().
*
* Returns 0 in case of success and -1 in case of failure.
*/
int
-xenDomainResume(xenDomainPtr domain) {
- if ((domain == NULL) || (domain->magic != XEN_DOMAIN_MAGIC))
+virDomainResume(virDomainPtr domain) {
+ if ((domain == NULL) || (domain->magic != VIR_DOMAIN_MAGIC))
return(-1);
TODO
return(-1);
}
/**
- * xenDomainGetName:
+ * virDomainGetName:
* @domain: a domain object
*
* Get the public name for that domain
* its lifetime will be the same as the domain object.
*/
const char *
-xenDomainGetName(xenDomainPtr domain) {
- if ((domain == NULL) || (domain->magic != XEN_DOMAIN_MAGIC))
+virDomainGetName(virDomainPtr domain) {
+ if ((domain == NULL) || (domain->magic != VIR_DOMAIN_MAGIC))
return(NULL);
return(domain->name);
}
/**
- * xenDomainGetID:
+ * virDomainGetID:
* @domain: a domain object
*
* Get the hypervisor ID number for the domain
* Returns the domain ID number or (unsigned int) -1 in case of error
*/
unsigned int
-xenDomainGetID(xenDomainPtr domain) {
- if ((domain == NULL) || (domain->magic != XEN_DOMAIN_MAGIC))
+virDomainGetID(virDomainPtr domain) {
+ if ((domain == NULL) || (domain->magic != VIR_DOMAIN_MAGIC))
return((unsigned int) -1);
return(domain->handle);
}
/**
- * xenDomainGetMaxMemory:
+ * virDomainGetMaxMemory:
* @domain: a domain object or NULL
*
* Retrieve the maximum amount of physical memory allocated to a
* Returns the memory size in kilobytes or 0 in case of error.
*/
unsigned long
-xenDomainGetMaxMemory(xenDomainPtr domain) {
- if ((domain == NULL) || (domain->magic != XEN_DOMAIN_MAGIC))
+virDomainGetMaxMemory(virDomainPtr domain) {
+ if ((domain == NULL) || (domain->magic != VIR_DOMAIN_MAGIC))
return(0);
TODO
return(0);
}
/**
- * xenDomainSetMaxMemory:
+ * virDomainSetMaxMemory:
* @domain: a domain object or NULL
* @memory: the memory size in kilobytes
*
* Returns 0 in case of success and -1 in case of failure.
*/
int
-xenDomainSetMaxMemory(xenDomainPtr domain, unsigned long memory) {
- if ((domain == NULL) || (domain->magic != XEN_DOMAIN_MAGIC) ||
+virDomainSetMaxMemory(virDomainPtr domain, unsigned long memory) {
+ if ((domain == NULL) || (domain->magic != VIR_DOMAIN_MAGIC) ||
(memory < 4096))
return(-1);
TODO
--- /dev/null
+{
+ global:
+ virConnectOpen;
+ virConnectOpenReadOnly;
+ virConnectClose;
+ virConnectGetVersion;
+ virDomainCreateLinux;
+ virConnectListDomains;
+ virDomainLookupByName;
+ virDomainLookupByID;
+ virDomainDestroy;
+ virDomainSuspend;
+ virDomainResume;
+ virDomainGetName;
+ virDomainGetID;
+ virDomainGetMaxMemory;
+ virDomainSetMaxMemory;
+ local: *;
+};
+++ /dev/null
-{
- global:
- xenConnectOpen;
- xenConnectOpenReadOnly;
- xenConnectClose;
- xenConnectGetVersion;
- xenDomainCreateLinux;
- xenConnectListDomains;
- xenDomainLookupByName;
- xenDomainLookupByID;
- xenDomainDestroy;
- xenDomainSuspend;
- xenDomainResume;
- xenDomainGetName;
- xenDomainGetID;
- xenDomainGetMaxMemory;
- xenDomainSetMaxMemory;
- local: *;
-};
/*
- * xensh.c: a Xen shell used to exercise the libxen API
+ * virsh.c: a Xen shell used to exercise the libvir API
*
* Copyright (C) 2005 Red Hat, Inc.
*
* Daniel Veillard <veillard@redhat.com>
*/
-#include "libxen.h"
+#include "libvir.h"
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#define MAX_DOM 100
int errcode = 0;
-xenConnectPtr conn;
-xenDomainPtr dom0;
+virConnectPtr conn;
+virDomainPtr dom0;
int ids[MAX_DOM];
-static void printDomain(xenDomainPtr dom) {
- printf("id %d: name %s\n", xenDomainGetID(dom), xenDomainGetName(dom));
+static void printDomain(virDomainPtr dom) {
+ printf("id %d: name %s\n", virDomainGetID(dom), virDomainGetName(dom));
}
int main(int argc, char **argv) {
int ret, i;
- xenDomainPtr dom;
+ virDomainPtr dom;
if (getuid() == 0) {
- conn = xenConnectOpen(NULL);
+ conn = virConnectOpen(NULL);
} else {
- conn = xenConnectOpenReadOnly(NULL);
+ conn = virConnectOpenReadOnly(NULL);
}
if (conn == NULL) {
fprintf(stderr, "Failed to connect to the hypervisor\n");
errcode = 1;
goto done;
}
- dom0 = xenDomainLookupByID(conn, 0);
+ dom0 = virDomainLookupByID(conn, 0);
if (dom0 == NULL) {
fprintf(stderr, "Failed to get domain 0 informations\n");
errcode = 2;
printf("Dom0: ");
printDomain(dom0);
- ret = xenConnectListDomains(conn, &ids[0], MAX_DOM);
+ ret = virConnectListDomains(conn, &ids[0], MAX_DOM);
if (ret < 0) {
fprintf(stderr, "Failed to list active domains\n");
errcode = 3;
if (ids[i] == 0)
continue;
printf(" ");
- dom = xenDomainLookupByID(conn, ids[i]);
+ dom = virDomainLookupByID(conn, ids[i]);
if (dom == NULL) {
printf("domain %d disapeared\n", ids[i]);
} else {
done:
if (conn != NULL) {
- ret = xenConnectClose(conn);
+ ret = virConnectClose(conn);
if (ret != 0) {
fprintf(stderr, "Failed to connect to the hypervisor\n");
if (errcode == 0)
projects / thirdparty / libvirt.git / commitdiff
