|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [PATCH] Add missing files in vnet patch
The last vnet patch was missing some files that had been added to my tree but did not appear in 'hg diff'. This patch adds them. Signed-off-by: Mike Wray <mike.wray@xxxxxx> diff -r 413c911e5780 tools/vnet/Make.env
--- /dev/null Mon Sep 12 12:48:33 2005
+++ b/tools/vnet/Make.env Mon Sep 12 14:19:24 2005
@@ -0,0 +1,20 @@
+# -*- mode: Makefile; -*-
+
+export XEN_ROOT = $(shell cd $(VNET_ROOT)/../.. && pwd)
+export LINUX_SERIES ?= 2.6
+
+DISTDIR ?= $(XEN_ROOT)/dist
+export DESTDIR ?= $(DISTDIR)/install
+
+export VNET_MODULE_DIR = $(VNET_ROOT)/vnet-module
+export VNETD_DIR = $(VNET_ROOT)/vnetd
+export LIBXUTIL_DIR = $(VNET_ROOT)/libxutil
+
+export GC_DIR = $(VNET_ROOT)/build/gc
+export GC_INCLUDE = $(GC_DIR)/include
+export GC_LIB_DIR = $(GC_DIR)/lib
+export GC_LIB_A = $(GC_LIB_DIR)/libgc.a
+export GC_LIB_SO = $(GC_LIB_DIR)/libgc.so
+
+#$(warning XEN_ROOT = $(XEN_ROOT))
+#$(warning DESTDIR = $(DESTDIR))
diff -r 413c911e5780 tools/vnet/examples/vnet-insert
--- /dev/null Mon Sep 12 12:48:33 2005
+++ b/tools/vnet/examples/vnet-insert Mon Sep 12 14:19:24 2005
@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Insert the vnet module if it can be found and
+# it's not already there.
+vnet_insert () {
+ local module="vnet_module"
+ local mod_dir=/lib/modules/$(uname -r)
+ local mod_obj=""
+
+ if lsmod | grep -q ${module} ; then
+ echo "VNET: ${module} loaded"
+ return
+ fi
+ local mods=$(find ${mod_dir} -name "${module}.*o")
+ if [[ ${mods} ]] ; then
+ for mod_obj in ${mods} ; do
+ break
+ done
+ fi
+ if [ -z "${mod_obj}" ] ; then
+ echo "VNET: ${module} not found"
+ exit 1
+ fi
+ echo "VNET: Loading ${module} from ${mod_obj}"
+ insmod ${mod_obj} "$@"
+}
+
+vnet_insert "$@"
diff -r 413c911e5780 tools/vnet/libxutil/mem_stream.c
--- /dev/null Mon Sep 12 12:48:33 2005
+++ b/tools/vnet/libxutil/mem_stream.c Mon Sep 12 14:19:24 2005
@@ -0,0 +1,319 @@
+/*
+ * Copyright (C) 2005 Mike Wray <mike.wray@xxxxxx>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/** @file
+ * IOStream subtype for input and output to memory.
+ * Usable from user or kernel code (with __KERNEL__ defined).
+ */
+
+#include "sys_string.h"
+#include "mem_stream.h"
+#include "allocate.h"
+
+/** Internal state for a memory stream.
+ *
+ * The memory stream buffer is treated as a circular buffer.
+ * The lo and hi markers indicate positions in the buffer, but
+ * are not reduced modulo the buffer size. This avoids the ambiguity
+ * between a full and empty buffer when using reduced values.
+ *
+ * If x is a marker, then buf + (x % buf_n) is the corresponding
+ * pointer into the buffer. When the buffer is empty, lo == hi,
+ * and the corresponding pointers are equal. When the buffer is
+ * full, hi == lo + buf_n, and the corresponding pointers
+ * are also equal.
+ *
+ * Data is written after the high pointer and read from the lo pointer.
+ * The value hi - lo is the number of bytes in the buffer.
+ */
+typedef struct MemData {
+ /** Data buffer. */
+ char *buf;
+ /** Low marker - start of readable area. */
+ unsigned long lo;
+ /** High marker - end of readable area, start of writeable area. */
+ unsigned long hi;
+ /** Size of the buffer. */
+ unsigned int buf_n;
+ /** Maximum size the buffer can grow to. */
+ unsigned int buf_max;
+ /** Error code. */
+ int err;
+} MemData;
+
+/** Get number of bytes available to read.
+ *
+ * @param data mem stream
+ * @return bytes
+ */
+static inline int mem_len(struct MemData *data){
+ return data->hi - data->lo;
+}
+
+/** Get available space left in the buffer.
+ *
+ * @param data mem stream
+ * @return bytes
+ */
+static inline int mem_room(struct MemData *data){
+ return data->buf_n - mem_len(data);
+}
+
+/** Get a pointer to the start of the data in the buffer.
+ *
+ * @param data mem stream
+ * @return lo pointer
+ */
+static inline char * mem_lo(struct MemData *data){
+ return data->buf + (data->lo % data->buf_n);
+}
+
+/** Get a pointer to the end of the data in the buffer.
+ *
+ * @param data mem stream
+ * @return hi pointer
+ */
+static inline char * mem_hi(struct MemData *data){
+ return data->buf + (data->hi % data->buf_n);
+}
+
+/** Get a pointer to the end of the buffer.
+ *
+ * @param data mem stream
+ * @return end pointer
+ */
+static inline char * mem_end(struct MemData *data){
+ return data->buf + data->buf_n;
+}
+
+static int mem_error(IOStream *io);
+static int mem_close(IOStream *io);
+static void mem_free(IOStream *io);
+static int mem_write(IOStream *io, const void *msg, size_t n);
+static int mem_read(IOStream *io, void *buf, size_t n);
+
+/** Minimum delta used to increment the buffer. */
+static int delta_min = 256;
+
+/** Methods for a memory stream. */
+static IOMethods mem_methods = {
+ read: mem_read,
+ write: mem_write,
+ error: mem_error,
+ close: mem_close,
+ free: mem_free,
+};
+
+/** Get the memory stream state.
+ *
+ * @param io memory stream
+ * @return state
+ */
+static inline MemData *get_mem_data(IOStream *io){
+ return (MemData*)io->data;
+}
+
+/** Get the number of bytes available to read.
+ *
+ * @param io memory stream
+ * @return number of bytes
+ */
+int mem_stream_avail(IOStream *io){
+ MemData *data = get_mem_data(io);
+ return (data->err ? -data->err : mem_len(data));
+}
+
+/** Copy bytes from a memory stream into a buffer.
+ *
+ * @param data mem stream
+ * @param buf buffer
+ * @param n number of bytes to copy
+ */
+static void mem_get(MemData *data, char *buf, size_t n){
+ char *start = mem_lo(data);
+ char *end = mem_end(data);
+ if (start + n < end) {
+ memcpy(buf, start, n);
+ } else {
+ int k = end - start;
+ memcpy(buf, start, k);
+ memcpy(buf + k, data->buf, n - k);
+ }
+}
+
+/** Copy bytes from a buffer into a memory stream.
+ *
+ * @param data mem stream
+ * @param buf buffer
+ * @param n number of bytes to copy
+ */
+static void mem_put(MemData *data, const char *buf, size_t n){
+ char *start = mem_hi(data);
+ char *end = mem_end(data);
+ if(start + n < end){
+ memcpy(start, buf, n);
+ } else {
+ int k = end - start;
+ memcpy(start, buf, k);
+ memcpy(data->buf, buf + k, n - k);
+ }
+}
+
+/** Expand the buffer used by a memory stream.
+ *
+ * @param data mem stream
+ * @param extra number of bytes to expand by
+ * @return 0 on success, negative error otherwise
+ */
+static int mem_expand(MemData *data, size_t extra){
+ int err = -ENOMEM;
+ int delta = (extra < delta_min ? delta_min : extra);
+ if(data->buf_max > 0){
+ int delta_max = data->buf_max - data->buf_n;
+ if(delta > delta_max){
+ delta = extra;
+ if(delta > delta_max) goto exit;
+ }
+ }
+ int buf_n = data->buf_n + delta;
+ char *buf = allocate(buf_n);
+ if(!buf) goto exit;
+ mem_get(data, buf, mem_len(data));
+ data->hi = mem_len(data);
+ data->lo = 0;
+ deallocate(data->buf);
+ data->buf = buf;
+ data->buf_n = buf_n;
+ err = 0;
+ exit:
+ if(err){
+ data->err = -err;
+ }
+ return err;
+}
+
+/** Write bytes from a buffer into a memory stream.
+ * The internal buffer is expanded as needed to hold the data,
+ * up to the stream maximum (if specified). If the buffer cannot
+ * be expanded -ENOMEM is returned.
+ *
+ * @param io mem stream
+ * @param buf buffer
+ * @param n number of bytes to write
+ * @return number of bytes written on success, negative error code otherwise
+ */
+static int mem_write(IOStream *io, const void *msg, size_t n){
+ MemData *data = get_mem_data(io);
+ if(data->err) return -data->err;
+ int room = mem_room(data);
+ if(n > room){
+ int err = mem_expand(data, n - room);
+ if(err) return err;
+ }
+ mem_put(data, msg, n);
+ data->hi += n;
+ return n;
+}
+
+/** Read bytes from a memory stream into a buffer.
+ *
+ * @param io mem stream
+ * @param buf buffer
+ * @param n maximum number of bytes to read
+ * @return number of bytes read on success, negative error code otherwise
+ */
+static int mem_read(IOStream *io, void *buf, size_t n){
+ MemData *data = get_mem_data(io);
+ if(data->err) return -data->err;
+ int k = mem_len(data);
+ if(n > k){
+ n = k;
+ }
+ mem_get(data, buf, n);
+ data->lo += n;
+ return n;
+}
+
+/** Test if a memory stream has an error.
+ *
+ * @param io mem stream
+ * @return 0 if ok, error code otherwise
+ */
+static int mem_error(IOStream *io){
+ MemData *data = get_mem_data(io);
+ return data->err;
+}
+
+/** Close a memory stream.
+ *
+ * @param io mem stream
+ * @return 0
+ */
+static int mem_close(IOStream *io){
+ MemData *data = get_mem_data(io);
+ if(!data->err){
+ data->err = ENOTCONN;
+ }
+ return 0;
+}
+
+/** Free a memory stream.
+ *
+ * @param io mem stream
+ */
+static void mem_free(IOStream *io){
+ MemData *data = get_mem_data(io);
+ deallocate(data->buf);
+ memzero(data, sizeof(*data));
+ deallocate(data);
+}
+
+/** Allocate and initialise a memory stream.
+ *
+ * @param buf_n initial buffer size (0 means default)
+ * @param buf_max maximum buffer size (0 means no max)
+ * @return new stream (free using IOStream_close)
+ */
+IOStream *mem_stream_new_size(size_t buf_n, size_t buf_max){
+ int err = -ENOMEM;
+ MemData *data = ALLOCATE(MemData);
+ if(!data) goto exit;
+ IOStream *io = ALLOCATE(IOStream);
+ if(!io) goto exit;
+ if(buf_n <= delta_min){
+ buf_n = delta_min;
+ }
+ if(buf_max > 0 && buf_max < buf_n){
+ buf_max = buf_n;
+ }
+ data->buf = allocate(buf_n);
+ if(!data->buf) goto exit;
+ data->buf_n = buf_n;
+ data->buf_max = buf_max;
+ io->methods = &mem_methods;
+ io->data = data;
+ io->nofree = 0;
+ err = 0;
+ exit:
+ if(err){
+ deallocate(data);
+ deallocate(io);
+ io = NULL;
+ }
+ return io;
+}
diff -r 413c911e5780 tools/vnet/libxutil/mem_stream.h
--- /dev/null Mon Sep 12 12:48:33 2005
+++ b/tools/vnet/libxutil/mem_stream.h Mon Sep 12 14:19:24 2005
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2005 Mike Wray <mike.wray@xxxxxx>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef _XUTIL_MEM_STREAM_H_
+#define _XUTIL_MEM_STREAM_H_
+
+#include "iostream.h"
+
+extern IOStream *mem_stream_new_size(size_t buf_n, size_t buf_max);
+
+extern int mem_stream_avail(IOStream *io);
+
+static inline IOStream *mem_stream_new(void){
+ return mem_stream_new_size(0, 0);
+}
+
+#endif /* !_XUTIL_MEM_STREAM_H_ */
diff -r 413c911e5780 tools/vnet/vnet-module/varp_util.c
--- /dev/null Mon Sep 12 12:48:33 2005
+++ b/tools/vnet/vnet-module/varp_util.c Mon Sep 12 14:19:24 2005
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2005 Mike Wray <mike.wray@xxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free software Foundation, Inc.,
+ * 59 Temple Place, suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+static int hex16(char *s, uint16_t *val)
+{
+ int err = -EINVAL;
+ uint16_t v = 0;
+
+ for( ; *s; s++){
+ v <<= 4;
+ if('0' <= *s && *s <= '9'){
+ v |= *s - '0';
+ } else if('A' <= *s && *s <= 'F'){
+ v |= *s - 'A' + 10;
+ } else if('a' <= *s && *s <= 'f'){
+ v |= *s - 'a' + 10;
+ } else {
+ goto exit;
+ }
+ }
+ err = 0;
+ exit:
+ *val = (err ? 0 : v);
+ return err;
+}
+
+int VnetId_aton(const char *s, VnetId *vnet){
+ int err = -EINVAL;
+ const char *p, *q;
+ uint16_t v;
+ char buf[5];
+ int buf_n = sizeof(buf) - 1;
+ int i, n;
+ const int elts_n = 8;
+
+ q = s;
+ p = strchr(q, ':');
+ i = (p ? 0 : elts_n - 1);
+ do {
+ if(!p){
+ if(i < elts_n - 1) goto exit;
+ p = s + strlen(s);
+ }
+ n = p - q;
+ if(n > buf_n) goto exit;
+ memcpy(buf, q, n);
+ buf[n] = '\0';
+ err = hex16(buf, &v);
+ if(err) goto exit;
+ vnet->u.vnet16[i] = htons(v);
+ q = p+1;
+ p = strchr(q, ':');
+ i++;
+ } while(i < elts_n);
+ err = 0;
+ exit:
+ if(err){
+ *vnet = (VnetId){};
+ }
+ return err;
+}
diff -r 413c911e5780 tools/vnet/vnet-module/varp_util.h
--- /dev/null Mon Sep 12 12:48:33 2005
+++ b/tools/vnet/vnet-module/varp_util.h Mon Sep 12 14:19:24 2005
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2004 Mike Wray <mike.wray@xxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free software Foundation, Inc.,
+ * 59 Temple Place, suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#ifndef _VNET_VARP_UTIL_H
+#define _VNET_VARP_UTIL_H
+
+#include "hash_table.h"
+
+/** Size of a string buffer to store a varp address. */
+#define VARP_ADDR_BUF 56
+
+/** Size of a string buffer to store a vnet id. */
+#define VNET_ID_BUF 56
+
+#ifndef NIPQUAD
+#define NIPQUAD(addr) \
+ ((unsigned char *)&addr)[0], \
+ ((unsigned char *)&addr)[1], \
+ ((unsigned char *)&addr)[2], \
+ ((unsigned char *)&addr)[3]
+#endif
+
+#ifndef NIP6
+#define NIP6(addr) \
+ ntohs((addr).s6_addr16[0]), \
+ ntohs((addr).s6_addr16[1]), \
+ ntohs((addr).s6_addr16[2]), \
+ ntohs((addr).s6_addr16[3]), \
+ ntohs((addr).s6_addr16[4]), \
+ ntohs((addr).s6_addr16[5]), \
+ ntohs((addr).s6_addr16[6]), \
+ ntohs((addr).s6_addr16[7])
+#endif
+
+
+static inline const char *VarpAddr_ntoa(VarpAddr *addr, char
buf[VARP_ADDR_BUF])
+{
+ switch(addr->family){
+ default:
+ case AF_INET:
+ sprintf(buf, "%u.%u.%u.%u",
+ NIPQUAD(addr->u.ip4));
+ break;
+ case AF_INET6:
+ sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
+ NIP6(addr->u.ip6));
+ break;
+ }
+ return buf;
+}
+
+static inline const char *VnetId_ntoa(VnetId *vnet, char buf[VNET_ID_BUF])
+{
+ sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
+ ntohs(vnet->u.vnet16[0]), \
+ ntohs(vnet->u.vnet16[1]), \
+ ntohs(vnet->u.vnet16[2]), \
+ ntohs(vnet->u.vnet16[3]), \
+ ntohs(vnet->u.vnet16[4]), \
+ ntohs(vnet->u.vnet16[5]), \
+ ntohs(vnet->u.vnet16[6]), \
+ ntohs(vnet->u.vnet16[7]));
+ return buf;
+}
+
+extern int VnetId_aton(const char *s, VnetId *vnet);
+
+/** Convert an unsigned in host order to a vnet id.
+ */
+static inline struct VnetId toVnetId(uint32_t vnetid){
+ struct VnetId vnet = {};
+ vnet.u.vnet32[3] = htonl(vnetid);
+ return vnet;
+}
+
+static inline uint32_t VnetId_hash(uint32_t h, VnetId *vnet)
+{
+ h = hash_hul(h, vnet->u.vnet32[0]);
+ h = hash_hul(h, vnet->u.vnet32[1]);
+ h = hash_hul(h, vnet->u.vnet32[2]);
+ h = hash_hul(h, vnet->u.vnet32[3]);
+ return h;
+}
+
+static inline int VnetId_eq(VnetId *vnet1, VnetId *vnet2)
+{
+ return memcmp(vnet1, vnet2, sizeof(VnetId)) == 0;
+}
+
+static inline uint32_t VarpAddr_hash(uint32_t h, VarpAddr *addr)
+{
+ h = hash_hul(h, addr->family);
+ if(addr->family == AF_INET6){
+ h = hash_hul(h, addr->u.ip6.s6_addr32[0]);
+ h = hash_hul(h, addr->u.ip6.s6_addr32[1]);
+ h = hash_hul(h, addr->u.ip6.s6_addr32[2]);
+ h = hash_hul(h, addr->u.ip6.s6_addr32[3]);
+ } else {
+ h = hash_hul(h, addr->u.ip4.s_addr);
+ }
+ return h;
+}
+
+static inline int VarpAddr_eq(VarpAddr *addr1, VarpAddr*addr2)
+{
+ return memcmp(addr1, addr2, sizeof(VarpAddr)) == 0;
+}
+
+static inline uint32_t Vmac_hash(uint32_t h, Vmac *vmac)
+{
+ h = hash_hul(h,
+ (vmac->mac[0] << 24) |
+ (vmac->mac[1] << 16) |
+ (vmac->mac[2] << 8) |
+ (vmac->mac[3] ));
+ h = hash_hul(h,
+ (vmac->mac[4] << 8) |
+ (vmac->mac[5] ));
+ return h;
+}
+
+static inline int Vmac_eq(Vmac *vmac1, Vmac *vmac2)
+{
+ return memcmp(vmac1, vmac2, sizeof(Vmac)) == 0;
+}
+
+#endif /* _VNET_VARP_UTIL_H */
_______________________________________________ Xen-devel mailing list Xen-devel@xxxxxxxxxxxxxxxxxxx http://lists.xensource.com/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |