0c76f22ef1
- bnc#633573 - System fail to boot after running several warm reboot tests 22749-vtd-workarounds.patch - Upstream patches from Jan 22744-ept-pod-locking.patch 22777-vtd-ats-fixes.patch 22781-pod-hap-logdirty.patch 22782-x86-emul-smsw.patch 22789-i386-no-x2apic.patch 22790-svm-resume-migrate-pirqs.patch 22816-x86-pirq-drop-priv-check.patch OBS-URL: https://build.opensuse.org/package/show/Virtualization/xen?expand=0&rev=94
5125 lines
129 KiB
Diff
5125 lines
129 KiB
Diff
xc_kexec utility, for domU kexec support.
|
|
|
|
Signed-off-by: Gerd Hoffmann <kraxel@suse.de>
|
|
---
|
|
tools/xcutils/Makefile | 10
|
|
tools/xcutils/helper/Makefile | 39 +
|
|
tools/xcutils/helper/console.c | 69 ++
|
|
tools/xcutils/helper/ctype.c | 35 +
|
|
tools/xcutils/helper/ctype.h | 54 +
|
|
tools/xcutils/helper/helper.h | 107 +++
|
|
tools/xcutils/helper/main.c | 651 +++++++++++++++++++
|
|
tools/xcutils/helper/make-offsets.c | 28
|
|
tools/xcutils/helper/printk.c | 1051 ++++++++++++++++++++++++++++++++
|
|
tools/xcutils/helper/string.c | 601 ++++++++++++++++++
|
|
tools/xcutils/helper/vsprintf.c | 842 +++++++++++++++++++++++++
|
|
tools/xcutils/helper/x86_32/div64.h | 48 +
|
|
tools/xcutils/helper/x86_32/entry.S | 49 +
|
|
tools/xcutils/helper/x86_32/hypercall.h | 360 ++++++++++
|
|
tools/xcutils/helper/x86_64/div64.h | 58 +
|
|
tools/xcutils/helper/x86_64/entry.S | 50 +
|
|
tools/xcutils/helper/x86_64/hypercall.h | 355 ++++++++++
|
|
tools/xcutils/kexec-syscall.h | 80 ++
|
|
tools/xcutils/xc_kexec.c | 503 +++++++++++++++
|
|
19 files changed, 4988 insertions(+), 2 deletions(-)
|
|
|
|
Index: xen-4.0.2-testing/tools/xcutils/Makefile
|
|
===================================================================
|
|
--- xen-4.0.2-testing.orig/tools/xcutils/Makefile
|
|
+++ xen-4.0.2-testing/tools/xcutils/Makefile
|
|
@@ -14,7 +14,7 @@ include $(XEN_ROOT)/tools/Rules.mk
|
|
CFLAGS += -Werror
|
|
CFLAGS += $(CFLAGS_libxenctrl) $(CFLAGS_libxenguest) $(CFLAGS_libxenstore)
|
|
|
|
-PROGRAMS = xc_restore xc_save readnotes lsevtchn
|
|
+PROGRAMS = xc_restore xc_save readnotes lsevtchn xc_kexec
|
|
|
|
LDLIBS = $(LDFLAGS_libxenctrl) $(LDFLAGS_libxenguest) $(LDFLAGS_libxenstore)
|
|
|
|
@@ -27,6 +27,11 @@ build: $(PROGRAMS)
|
|
$(PROGRAMS): %: %.o
|
|
$(CC) $(CFLAGS) $(LDFLAGS) $^ $(LDLIBS) -o $@
|
|
|
|
+xc_kexec.o: xc_kexec.c helper/blob.h
|
|
+
|
|
+helper/blob.h:
|
|
+ make -C helper
|
|
+
|
|
.PHONY: install
|
|
install: build
|
|
$(INSTALL_DIR) $(DESTDIR)$(PRIVATE_BINDIR)
|
|
@@ -37,5 +42,6 @@ install: build
|
|
clean:
|
|
$(RM) *.o $(PROGRAMS)
|
|
$(RM) $(DEPS)
|
|
+ make -C helper clean
|
|
|
|
-include $(DEPS)
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/Makefile
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/Makefile
|
|
@@ -0,0 +1,39 @@
|
|
+
|
|
+XEN_ROOT = ../../..
|
|
+include $(XEN_ROOT)/tools/Rules.mk
|
|
+
|
|
+OBJS := $(XEN_TARGET_ARCH)/entry.o
|
|
+OBJS += main.o console.o vsprintf.o string.o ctype.o
|
|
+
|
|
+CFLAGS += -g -I$(XEN_ROOT)/tools/libxc -I$(XEN_TARGET_ARCH) -I$(XEN_INCLUDE)
|
|
+
|
|
+ifeq ($(XEN_TARGET_ARCH),x86_32)
|
|
+HLP_LDFLAGS := -melf_i386
|
|
+endif
|
|
+
|
|
+HLP_LDFLAGS += --section-start .text=0x10000
|
|
+HLP_LDFLAGS += --section-start .data=0x20000
|
|
+HLP_LDFLAGS += --emit-relocs
|
|
+
|
|
+#####################
|
|
+# rules
|
|
+
|
|
+all: blob.h
|
|
+
|
|
+clean:
|
|
+ rm -rf helper.elf blob.h
|
|
+ rm -rf $(OBJS) *~
|
|
+
|
|
+helper.elf: $(OBJS)
|
|
+ ld $(HLP_LDFLAGS) -o $@ $^
|
|
+
|
|
+blob.h: helper.elf
|
|
+ hexdump -v -e '1/1 "0x%02x,\n"' $< > $@
|
|
+
|
|
+$(XEN_TARGET_ARCH)/offsets.h: make-offsets
|
|
+ ./make-offsets > $@
|
|
+
|
|
+#####################
|
|
+# dependencies
|
|
+
|
|
+$(XEN_TARGET_ARCH)/entry.o: $(XEN_TARGET_ARCH)/entry.S $(XEN_TARGET_ARCH)/offsets.h
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/console.c
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/console.c
|
|
@@ -0,0 +1,69 @@
|
|
+#include <inttypes.h>
|
|
+
|
|
+#include <xenctrl.h>
|
|
+#include <xen/io/console.h>
|
|
+#include "hypercall.h"
|
|
+
|
|
+#include "helper.h"
|
|
+
|
|
+static inline int notify_remote_via_evtchn(int port)
|
|
+{
|
|
+ struct evtchn_send send;
|
|
+ send.port = port;
|
|
+ return HYPERVISOR_event_channel_op(EVTCHNOP_send, &send);
|
|
+}
|
|
+
|
|
+static inline struct xencons_interface *xencons_interface(void)
|
|
+{
|
|
+ return (void*)(console_page);
|
|
+}
|
|
+
|
|
+static int xencons_ring_send(const char *data, unsigned len)
|
|
+{
|
|
+ int sent = 0;
|
|
+ struct xencons_interface *intf = xencons_interface();
|
|
+ XENCONS_RING_IDX cons, prod;
|
|
+
|
|
+ cons = intf->out_cons;
|
|
+ prod = intf->out_prod;
|
|
+ xen_mb();
|
|
+
|
|
+ while ((sent < len) && ((prod - cons) < sizeof(intf->out)))
|
|
+ intf->out[MASK_XENCONS_IDX(prod++, intf->out)] = data[sent++];
|
|
+
|
|
+ xen_wmb();
|
|
+ intf->out_prod = prod;
|
|
+
|
|
+ if (0 != notify_remote_via_evtchn(console_evtchn))
|
|
+ return -1;
|
|
+ return sent;
|
|
+}
|
|
+
|
|
+int printk(const char *fmt, ...)
|
|
+{
|
|
+ va_list args;
|
|
+ int r;
|
|
+
|
|
+ va_start(args, fmt);
|
|
+ r = vprintk(fmt, args);
|
|
+ va_end(args);
|
|
+
|
|
+ return r;
|
|
+}
|
|
+
|
|
+int vprintk(const char *fmt, va_list args)
|
|
+{
|
|
+ static char printk_buf[1024];
|
|
+ static char prefix[] = "printk: ";
|
|
+ int printed_len;
|
|
+
|
|
+ /* Emit the output into the temporary buffer */
|
|
+ printed_len = vscnprintf(printk_buf, sizeof(printk_buf), fmt, args);
|
|
+ if (xencons_ring_send(printk_buf, printed_len) < 0) {
|
|
+ /* shouldn't happen, but better have a fallback ;) */
|
|
+ HYPERVISOR_console_io(CONSOLEIO_write, strlen(prefix), prefix);
|
|
+ HYPERVISOR_console_io(CONSOLEIO_write, printed_len, printk_buf);
|
|
+ }
|
|
+
|
|
+ return printed_len;
|
|
+}
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/ctype.c
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/ctype.c
|
|
@@ -0,0 +1,35 @@
|
|
+/*
|
|
+ * linux/lib/ctype.c
|
|
+ *
|
|
+ * Copyright (C) 1991, 1992 Linus Torvalds
|
|
+ */
|
|
+
|
|
+#include "helper.h"
|
|
+
|
|
+unsigned char _ctype[] = {
|
|
+_C,_C,_C,_C,_C,_C,_C,_C, /* 0-7 */
|
|
+_C,_C|_S,_C|_S,_C|_S,_C|_S,_C|_S,_C,_C, /* 8-15 */
|
|
+_C,_C,_C,_C,_C,_C,_C,_C, /* 16-23 */
|
|
+_C,_C,_C,_C,_C,_C,_C,_C, /* 24-31 */
|
|
+_S|_SP,_P,_P,_P,_P,_P,_P,_P, /* 32-39 */
|
|
+_P,_P,_P,_P,_P,_P,_P,_P, /* 40-47 */
|
|
+_D,_D,_D,_D,_D,_D,_D,_D, /* 48-55 */
|
|
+_D,_D,_P,_P,_P,_P,_P,_P, /* 56-63 */
|
|
+_P,_U|_X,_U|_X,_U|_X,_U|_X,_U|_X,_U|_X,_U, /* 64-71 */
|
|
+_U,_U,_U,_U,_U,_U,_U,_U, /* 72-79 */
|
|
+_U,_U,_U,_U,_U,_U,_U,_U, /* 80-87 */
|
|
+_U,_U,_U,_P,_P,_P,_P,_P, /* 88-95 */
|
|
+_P,_L|_X,_L|_X,_L|_X,_L|_X,_L|_X,_L|_X,_L, /* 96-103 */
|
|
+_L,_L,_L,_L,_L,_L,_L,_L, /* 104-111 */
|
|
+_L,_L,_L,_L,_L,_L,_L,_L, /* 112-119 */
|
|
+_L,_L,_L,_P,_P,_P,_P,_C, /* 120-127 */
|
|
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 128-143 */
|
|
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 144-159 */
|
|
+_S|_SP,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P, /* 160-175 */
|
|
+_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P, /* 176-191 */
|
|
+_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U, /* 192-207 */
|
|
+_U,_U,_U,_U,_U,_U,_U,_P,_U,_U,_U,_U,_U,_U,_U,_L, /* 208-223 */
|
|
+_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L, /* 224-239 */
|
|
+_L,_L,_L,_L,_L,_L,_L,_P,_L,_L,_L,_L,_L,_L,_L,_L}; /* 240-255 */
|
|
+
|
|
+EXPORT_SYMBOL(_ctype);
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/ctype.h
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/ctype.h
|
|
@@ -0,0 +1,54 @@
|
|
+#ifndef _LINUX_CTYPE_H
|
|
+#define _LINUX_CTYPE_H
|
|
+
|
|
+/*
|
|
+ * NOTE! This ctype does not handle EOF like the standard C
|
|
+ * library is required to.
|
|
+ */
|
|
+
|
|
+#define _U 0x01 /* upper */
|
|
+#define _L 0x02 /* lower */
|
|
+#define _D 0x04 /* digit */
|
|
+#define _C 0x08 /* cntrl */
|
|
+#define _P 0x10 /* punct */
|
|
+#define _S 0x20 /* white space (space/lf/tab) */
|
|
+#define _X 0x40 /* hex digit */
|
|
+#define _SP 0x80 /* hard space (0x20) */
|
|
+
|
|
+extern unsigned char _ctype[];
|
|
+
|
|
+#define __ismask(x) (_ctype[(int)(unsigned char)(x)])
|
|
+
|
|
+#define isalnum(c) ((__ismask(c)&(_U|_L|_D)) != 0)
|
|
+#define isalpha(c) ((__ismask(c)&(_U|_L)) != 0)
|
|
+#define iscntrl(c) ((__ismask(c)&(_C)) != 0)
|
|
+#define isdigit(c) ((__ismask(c)&(_D)) != 0)
|
|
+#define isgraph(c) ((__ismask(c)&(_P|_U|_L|_D)) != 0)
|
|
+#define islower(c) ((__ismask(c)&(_L)) != 0)
|
|
+#define isprint(c) ((__ismask(c)&(_P|_U|_L|_D|_SP)) != 0)
|
|
+#define ispunct(c) ((__ismask(c)&(_P)) != 0)
|
|
+#define isspace(c) ((__ismask(c)&(_S)) != 0)
|
|
+#define isupper(c) ((__ismask(c)&(_U)) != 0)
|
|
+#define isxdigit(c) ((__ismask(c)&(_D|_X)) != 0)
|
|
+
|
|
+#define isascii(c) (((unsigned char)(c))<=0x7f)
|
|
+#define toascii(c) (((unsigned char)(c))&0x7f)
|
|
+
|
|
+static inline unsigned char __tolower(unsigned char c)
|
|
+{
|
|
+ if (isupper(c))
|
|
+ c -= 'A'-'a';
|
|
+ return c;
|
|
+}
|
|
+
|
|
+static inline unsigned char __toupper(unsigned char c)
|
|
+{
|
|
+ if (islower(c))
|
|
+ c -= 'a'-'A';
|
|
+ return c;
|
|
+}
|
|
+
|
|
+#define tolower(c) __tolower(c)
|
|
+#define toupper(c) __toupper(c)
|
|
+
|
|
+#endif
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/helper.h
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/helper.h
|
|
@@ -0,0 +1,107 @@
|
|
+#include <stdarg.h>
|
|
+#include <stddef.h>
|
|
+#include <limits.h>
|
|
+#include <inttypes.h>
|
|
+
|
|
+#if defined(__i386__)
|
|
+typedef unsigned int size_t;
|
|
+typedef int ptrdiff_t;
|
|
+#define BITS_PER_LONG 32
|
|
+#elif defined(__x86_64__)
|
|
+typedef unsigned long size_t;
|
|
+typedef long ptrdiff_t;
|
|
+#define BITS_PER_LONG 64
|
|
+#else
|
|
+#error fixme please: unknown arch
|
|
+#endif
|
|
+
|
|
+/* from linux */
|
|
+#include "ctype.h"
|
|
+#include "div64.h"
|
|
+
|
|
+/* some stuff to compile linux kernel sources almost unmodified */
|
|
+#define unlikely(x) (x)
|
|
+#define WARN_ON(x)
|
|
+#define BUG_ON(x)
|
|
+#define EXPORT_SYMBOL(x)
|
|
+
|
|
+#ifndef PAGE_SHIFT
|
|
+# define PAGE_SHIFT 12
|
|
+# define PAGE_SIZE (1<<PAGE_SHIFT)
|
|
+#endif
|
|
+
|
|
+#define _PAGE_PRESENT 0x001
|
|
+#define _PAGE_RW 0x002
|
|
+#define _PAGE_USER 0x004
|
|
+#define _PAGE_PWT 0x008
|
|
+#define _PAGE_PCD 0x010
|
|
+#define _PAGE_ACCESSED 0x020
|
|
+#define _PAGE_DIRTY 0x040
|
|
+#define _PAGE_PAT 0x080
|
|
+#define _PAGE_PSE 0x080
|
|
+#define _PAGE_GLOBAL 0x100
|
|
+
|
|
+/* entry.S: special pages */
|
|
+extern char hypercall_page[];
|
|
+
|
|
+/* entry.S: start kernel */
|
|
+extern void _start_kernel(void);
|
|
+extern void BUG(void);
|
|
+
|
|
+/* main.c */
|
|
+typedef __attribute__ ((aligned (PAGE_SIZE))) char page_t[PAGE_SIZE];
|
|
+extern page_t console_page;
|
|
+extern page_t xenstore_page;
|
|
+extern unsigned long virt_base;
|
|
+extern unsigned long virt_hypercall;
|
|
+extern unsigned long console_evtchn;
|
|
+extern struct vcpu_guest_context vcpu;
|
|
+extern struct start_info *old_info;
|
|
+
|
|
+void start_helper(void);
|
|
+
|
|
+/* console.c */
|
|
+int printk(const char *fmt, ...) __attribute__ ((format(printf, 1, 2)));
|
|
+int vprintk(const char *fmt, va_list args);
|
|
+
|
|
+/* linux: string.c */
|
|
+int strnicmp(const char *s1, const char *s2, size_t len);
|
|
+char *strcpy(char *dest, const char *src);
|
|
+char *strncpy(char *dest, const char *src, size_t count);
|
|
+size_t strlcpy(char *dest, const char *src, size_t size);
|
|
+char *strcat(char *dest, const char *src);
|
|
+char *strncat(char *dest, const char *src, size_t count);
|
|
+size_t strlcat(char *dest, const char *src, size_t count);
|
|
+size_t strlcat(char *dest, const char *src, size_t count);
|
|
+int strcmp(const char *cs, const char *ct);
|
|
+int strncmp(const char *cs, const char *ct, size_t count);
|
|
+char *strchr(const char *s, int c);
|
|
+char *strrchr(const char *s, int c);
|
|
+char *strnchr(const char *s, size_t count, int c);
|
|
+size_t strlen(const char *s);
|
|
+size_t strnlen(const char *s, size_t count);
|
|
+size_t strspn(const char *s, const char *accept);
|
|
+size_t strcspn(const char *s, const char *reject);
|
|
+char *strpbrk(const char *cs, const char *ct);
|
|
+char *strsep(char **s, const char *ct);
|
|
+void *memset(void *s, int c, size_t count);
|
|
+void *memcpy(void *dest, const void *src, size_t count);
|
|
+void *memmove(void *dest, const void *src, size_t count);
|
|
+int memcmp(const void *cs, const void *ct, size_t count);
|
|
+void *memscan(void *addr, int c, size_t size);
|
|
+char *strstr(const char *s1, const char *s2);
|
|
+void *memchr(const void *s, int c, size_t n);
|
|
+
|
|
+/* linux: vsprintf.c */
|
|
+unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base);
|
|
+long simple_strtol(const char *cp,char **endp,unsigned int base);
|
|
+unsigned long long simple_strtoull(const char *cp,char **endp,unsigned int base);
|
|
+long long simple_strtoll(const char *cp,char **endp,unsigned int base);
|
|
+int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
|
|
+int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
|
|
+int snprintf(char * buf, size_t size, const char *fmt, ...);
|
|
+int scnprintf(char * buf, size_t size, const char *fmt, ...);
|
|
+int vsprintf(char *buf, const char *fmt, va_list args);
|
|
+int sprintf(char * buf, const char *fmt, ...);
|
|
+int vsscanf(const char * buf, const char * fmt, va_list args);
|
|
+int sscanf(const char * buf, const char * fmt, ...);
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/main.c
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/main.c
|
|
@@ -0,0 +1,651 @@
|
|
+#include <xenctrl.h>
|
|
+#include "hypercall.h"
|
|
+
|
|
+#include "helper.h"
|
|
+#undef machine_to_phys_mapping
|
|
+
|
|
+/* filled by xc_kexec */
|
|
+unsigned long debug_level = 0;
|
|
+unsigned long virt_base;
|
|
+unsigned long virt_hypercall;
|
|
+unsigned long console_evtchn;
|
|
+#if defined(__i386__)
|
|
+unsigned long pae_paging;
|
|
+#endif
|
|
+struct vcpu_guest_context vcpu;
|
|
+
|
|
+/* passed by trampoline in %esi */
|
|
+struct start_info *old_info;
|
|
+
|
|
+/* my data */
|
|
+static struct start_info *new_info;
|
|
+static xen_pfn_t *phys_to_machine_mapping;
|
|
+static xen_pfn_t *machine_to_phys_mapping;
|
|
+static void (*start_kernel)(void);
|
|
+
|
|
+/* magic pages */
|
|
+page_t console_page;
|
|
+page_t xenstore_page;
|
|
+static page_t shared_info_page;
|
|
+static struct shared_info *shared_info = (void*)shared_info_page;
|
|
+
|
|
+#define dprintk if (debug_level >= 1) printk
|
|
+
|
|
+/* ------------------------------------------------------------------ */
|
|
+
|
|
+static unsigned char xen_features[XENFEAT_NR_SUBMAPS * 32];
|
|
+#define xen_feature(flag) (xen_features[flag])
|
|
+
|
|
+static void setup_xen_features(void)
|
|
+{
|
|
+ xen_feature_info_t fi;
|
|
+ int i, j;
|
|
+
|
|
+ for (i = 0; i < XENFEAT_NR_SUBMAPS; i++) {
|
|
+ fi.submap_idx = i;
|
|
+ if (HYPERVISOR_xen_version(XENVER_get_features, &fi) < 0)
|
|
+ break;
|
|
+ for (j=0; j<32; j++)
|
|
+ xen_features[i*32+j] = !!(fi.submap & 1<<j);
|
|
+ }
|
|
+}
|
|
+
|
|
+#if 0 /* DEBUG */
|
|
+#include <errno.h>
|
|
+#include <xen/io/xs_wire.h>
|
|
+static void xenstore_debug(void)
|
|
+{
|
|
+ struct xenstore_domain_interface *xs = (void*)xenstore_page;
|
|
+
|
|
+ printk("xs: req %4d -> %4d\r\n", xs->req_cons, xs->req_prod);
|
|
+ printk("xs: rsp %4d -> %4d\r\n", xs->rsp_cons, xs->rsp_prod);
|
|
+ if (xs->req_cons != xs->req_prod)
|
|
+ return;
|
|
+ if (xs->rsp_cons != xs->rsp_prod)
|
|
+ return;
|
|
+
|
|
+ memset(xenstore_page, 0, PAGE_SIZE);
|
|
+ xen_wmb();
|
|
+ printk("xs: debug fixup [zero page] done\r\n");
|
|
+}
|
|
+#endif
|
|
+
|
|
+/* ------------------------------------------------------------------ */
|
|
+
|
|
+#define INVALID_P2M_ENTRY (~0UL)
|
|
+#define FOREIGN_FRAME_BIT (1UL<<31)
|
|
+#define pfn_to_mfn(pfn) (phys_to_machine_mapping[pfn] & ~FOREIGN_FRAME_BIT)
|
|
+#define mfn_to_pfn(mfn) (machine_to_phys_mapping[mfn])
|
|
+#define set_phys_to_machine(pfn, mfn) (phys_to_machine_mapping[pfn] = mfn)
|
|
+#define phys_to_machine_mapping_valid(pfn) (phys_to_machine_mapping[pfn] != INVALID_P2M_ENTRY)
|
|
+
|
|
+void xen_machphys_update(unsigned long mfn, unsigned long pfn)
|
|
+{
|
|
+ mmu_update_t u;
|
|
+ int rc;
|
|
+
|
|
+ u.ptr = ((unsigned long long)mfn << PAGE_SHIFT) | MMU_MACHPHYS_UPDATE;
|
|
+ u.val = pfn;
|
|
+ rc = HYPERVISOR_mmu_update(&u, 1, NULL, DOMID_SELF);
|
|
+ if (0 == rc)
|
|
+ return;
|
|
+ printk("Oops: HYPERVISOR_mmu_update: rc=%d\r\n",rc);
|
|
+}
|
|
+
|
|
+static void swap_pages_p2m(unsigned long pfn1, unsigned long pfn2)
|
|
+{
|
|
+ unsigned long mfn1, mfn2;
|
|
+
|
|
+ mfn1 = phys_to_machine_mapping_valid(pfn1)
|
|
+ ? pfn_to_mfn(pfn1) : INVALID_P2M_ENTRY;
|
|
+ mfn2 = phys_to_machine_mapping_valid(pfn2)
|
|
+ ? pfn_to_mfn(pfn2) : INVALID_P2M_ENTRY;
|
|
+ dprintk("%s: pfn %5lx / mfn %5lx <=> pfn %5lx / mfn %5lx\r\n",
|
|
+ __FUNCTION__, pfn1, mfn1, pfn2, mfn2);
|
|
+
|
|
+ if (mfn1 != INVALID_P2M_ENTRY)
|
|
+ xen_machphys_update(mfn1, INVALID_P2M_ENTRY);
|
|
+ if (mfn2 != INVALID_P2M_ENTRY)
|
|
+ xen_machphys_update(mfn2, INVALID_P2M_ENTRY);
|
|
+
|
|
+ set_phys_to_machine(pfn2, mfn1);
|
|
+ if (mfn1 != INVALID_P2M_ENTRY)
|
|
+ xen_machphys_update(mfn1, pfn2);
|
|
+
|
|
+ set_phys_to_machine(pfn1, mfn2);
|
|
+ if (mfn2 != INVALID_P2M_ENTRY)
|
|
+ xen_machphys_update(mfn2, pfn1);
|
|
+}
|
|
+
|
|
+static void plug_holes_p2m(void)
|
|
+{
|
|
+ unsigned long pfns = shared_info->arch.max_pfn;
|
|
+ unsigned long take, give;
|
|
+ int count = 0;
|
|
+
|
|
+ take = 0;
|
|
+ give = pfns-1;
|
|
+
|
|
+ for (;;) {
|
|
+ while (take < give && phys_to_machine_mapping_valid(take))
|
|
+ take++;
|
|
+ for (; take < give; give--) {
|
|
+ if (!phys_to_machine_mapping_valid(give))
|
|
+ continue;
|
|
+ break;
|
|
+ }
|
|
+ if (take >= give)
|
|
+ break;
|
|
+ swap_pages_p2m(give--,take++);
|
|
+ count++;
|
|
+ }
|
|
+ if (!phys_to_machine_mapping_valid(take))
|
|
+ take--;
|
|
+
|
|
+ new_info->nr_pages = take+1;
|
|
+ dprintk("%s: %d swaps, nr_pages is 0x%lx (0x%lx max)\r\n",
|
|
+ __FUNCTION__, count, new_info->nr_pages, pfns);
|
|
+}
|
|
+
|
|
+static void fillup_memory_p2m(void)
|
|
+{
|
|
+ struct xen_memory_reservation reservation = {
|
|
+ .mem_flags = 0,
|
|
+ .extent_order = 0,
|
|
+ .nr_extents = 1,
|
|
+ .domid = DOMID_SELF,
|
|
+ };
|
|
+ unsigned long pfns = shared_info->arch.max_pfn;
|
|
+ unsigned long pfn, mfn;
|
|
+ int rc, count = 0;
|
|
+
|
|
+ for (pfn = new_info->nr_pages; pfn < pfns; count++, pfn++) {
|
|
+ set_xen_guest_handle(reservation.extent_start, &mfn);
|
|
+ rc = HYPERVISOR_memory_op(XENMEM_populate_physmap,
|
|
+ &reservation);
|
|
+ if (1 != rc)
|
|
+ break;
|
|
+ xen_machphys_update(mfn, pfn);
|
|
+ set_phys_to_machine(pfn, mfn);
|
|
+ }
|
|
+
|
|
+ new_info->nr_pages = pfn;
|
|
+ printk("%s: got %d pages, nr_pages is 0x%lx (0x%lx max)\r\n",
|
|
+ __FUNCTION__, count, new_info->nr_pages, pfns);
|
|
+}
|
|
+
|
|
+#define P2M_ENTRIES (PAGE_SIZE/sizeof(xen_pfn_t))
|
|
+#define mfn_to_addr(mfn) ((void*)(mfn_to_pfn(mfn) << PAGE_SHIFT))
|
|
+
|
|
+static void p2m_copy(void)
|
|
+{
|
|
+ xen_pfn_t *mfn_lol = NULL, *mfn_list = NULL;
|
|
+ unsigned int off_lol = 0, off_list = 0;
|
|
+ xen_pfn_t pfn;
|
|
+
|
|
+ phys_to_machine_mapping = (unsigned long*)(new_info->mfn_list - virt_base);
|
|
+ for (pfn = 0; pfn < shared_info->arch.max_pfn; pfn += P2M_ENTRIES) {
|
|
+ if (0 == pfn) {
|
|
+ mfn_lol = mfn_to_addr(shared_info->arch.pfn_to_mfn_frame_list_list);
|
|
+ off_lol = 0;
|
|
+ }
|
|
+ if (0 == (pfn % (P2M_ENTRIES * P2M_ENTRIES))) {
|
|
+ mfn_list = mfn_to_addr(mfn_lol[off_lol++]);
|
|
+ off_list = 0;
|
|
+ }
|
|
+ memcpy(phys_to_machine_mapping + pfn,
|
|
+ mfn_to_addr(mfn_list[off_list++]),
|
|
+ PAGE_SIZE);
|
|
+ }
|
|
+}
|
|
+
|
|
+static void xen_tlb_flush(void)
|
|
+{
|
|
+ struct mmuext_op op;
|
|
+ op.cmd = MMUEXT_TLB_FLUSH_LOCAL;
|
|
+ HYPERVISOR_mmuext_op(&op, 1, NULL, DOMID_SELF);
|
|
+}
|
|
+
|
|
+/* ------------------------------------------------------------------ */
|
|
+
|
|
+#if defined(__i386__)
|
|
+
|
|
+static void map_page_32(page_t page, unsigned long mfn, unsigned long flags)
|
|
+{
|
|
+ unsigned long vaddr = (unsigned long)page;
|
|
+ uint32_t *pgd = (void*)old_info->pt_base;
|
|
+ uint32_t *pte;
|
|
+ unsigned long pfn;
|
|
+ int pgd_off, pte_off;
|
|
+
|
|
+ pgd_off = (vaddr >> 22) & (1024-1);
|
|
+ pte_off = (vaddr >> 12) & (1024-1);
|
|
+
|
|
+ pfn = mfn_to_pfn(pgd[pgd_off] >> PAGE_SHIFT);
|
|
+ pte = (void*)(pfn << PAGE_SHIFT);
|
|
+
|
|
+ pte[pte_off] = (mfn << PAGE_SHIFT) | flags;
|
|
+}
|
|
+
|
|
+static void map_virt_base_32(void)
|
|
+{
|
|
+ mmu_update_t u;
|
|
+ xen_pfn_t pgd_mfn = pfn_to_mfn(old_info->pt_base >> PAGE_SHIFT);
|
|
+ uint32_t *pgd_ma = (void*)(pgd_mfn << PAGE_SHIFT);
|
|
+ uint32_t *pgd = (void*)old_info->pt_base;
|
|
+ uint32_t pgd_virt = virt_base >> 22;
|
|
+ uint32_t pgd_low = 0;
|
|
+
|
|
+ if (pgd_virt << 22 != virt_base) {
|
|
+ printk("%s: warning: virt_base is not at pgd entry border,\r\n"
|
|
+ " that will work only if old and new kernel have\r\n"
|
|
+ " an identical virt_base.\r\n", __FUNCTION__);
|
|
+ return;
|
|
+ }
|
|
+
|
|
+ for (;;) {
|
|
+ if (!(pgd[pgd_low] & _PAGE_PRESENT))
|
|
+ return;
|
|
+ u.ptr = (unsigned long)(pgd_ma + pgd_virt);
|
|
+ u.val = pgd[pgd_low];
|
|
+ if (HYPERVISOR_mmu_update(&u, 1, NULL, DOMID_SELF) < 0) {
|
|
+ printk("%s: mmu_update failed [l2 0x%x -> 0x%x]\r\n",
|
|
+ __FUNCTION__, pgd_low, pgd_virt);
|
|
+ return;
|
|
+ }
|
|
+ pgd_virt++;
|
|
+ pgd_low++;
|
|
+ }
|
|
+}
|
|
+
|
|
+static void map_page_pae(page_t page, unsigned long mfn, unsigned long flags)
|
|
+{
|
|
+ unsigned long vaddr = (unsigned long)page;
|
|
+ uint64_t *pgd = (void*)old_info->pt_base;
|
|
+ uint64_t *pmd;
|
|
+ uint64_t *pte;
|
|
+ unsigned long pfn;
|
|
+ int pgd_off, pmd_off, pte_off;
|
|
+
|
|
+ pgd_off = (vaddr >> 30) & (4-1);
|
|
+ pmd_off = (vaddr >> 21) & (512-1);
|
|
+ pte_off = (vaddr >> 12) & (512-1);
|
|
+
|
|
+ pfn = mfn_to_pfn(pgd[pgd_off] >> PAGE_SHIFT);
|
|
+ pmd = (void*)(pfn << PAGE_SHIFT);
|
|
+ pfn = mfn_to_pfn(pmd[pmd_off] >> PAGE_SHIFT);
|
|
+ pte = (void*)(pfn << PAGE_SHIFT);
|
|
+
|
|
+ pte[pte_off] = (mfn << PAGE_SHIFT) | flags;
|
|
+}
|
|
+
|
|
+static void map_virt_base_pae(void)
|
|
+{
|
|
+ mmu_update_t u;
|
|
+ xen_pfn_t pgd_mfn = pfn_to_mfn(old_info->pt_base >> PAGE_SHIFT);
|
|
+ uint64_t *pgd_ma = (void*)(pgd_mfn << PAGE_SHIFT);
|
|
+ uint64_t *pgd = (void*)old_info->pt_base;
|
|
+ int i;
|
|
+
|
|
+ for (i = 1; i <= 2; i++) {
|
|
+ u.ptr = (unsigned long)(pgd_ma + i);
|
|
+ u.val = pgd[0];
|
|
+ if (HYPERVISOR_mmu_update(&u, 1, NULL, DOMID_SELF) < 0) {
|
|
+ printk("%s: mmu_update failed [l3 0 -> %d]\r\n",
|
|
+ __FUNCTION__, i);
|
|
+ return;
|
|
+ }
|
|
+ }
|
|
+}
|
|
+
|
|
+static void map_page(page_t page, unsigned long mfn, unsigned long flags)
|
|
+{
|
|
+ if (pae_paging)
|
|
+ map_page_pae(page, mfn, flags);
|
|
+ else
|
|
+ map_page_32(page, mfn, flags);
|
|
+ xen_tlb_flush();
|
|
+ xen_wmb();
|
|
+}
|
|
+
|
|
+static void map_virt_base(void)
|
|
+{
|
|
+ if (pae_paging)
|
|
+ map_virt_base_pae();
|
|
+ else
|
|
+ map_virt_base_32();
|
|
+ xen_tlb_flush();
|
|
+ xen_wmb();
|
|
+}
|
|
+
|
|
+static void fixup_pagetables_32(void)
|
|
+{
|
|
+ uint32_t *pgd = (void*)new_info->pt_base - virt_base;
|
|
+ uint32_t *pte;
|
|
+ uint32_t flg;
|
|
+ unsigned long pfn;
|
|
+ int l2, l1;
|
|
+
|
|
+ dprintk("%s: pgd at 0x%p\r\n", __FUNCTION__, pgd);
|
|
+ for (l2 = 0; l2 < 1024; l2++) {
|
|
+ if (!pgd[l2] & 1)
|
|
+ continue;
|
|
+ flg = pgd[l2] & (PAGE_SIZE-1);
|
|
+ pfn = pgd[l2] >> PAGE_SHIFT;
|
|
+ pgd[l2] = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flg;
|
|
+
|
|
+#if 1
|
|
+ /* Dirty hack alert: Add identity map for first 4MB,
|
|
+ * so we don't kill ourself when activating the new
|
|
+ * kernel's page tables. May have the side effect of
|
|
+ * killing the kernel later. */
|
|
+ if (!pgd[0])
|
|
+ pgd[0] = pgd[l2];
|
|
+#endif
|
|
+
|
|
+ pte = (void*)(pfn << PAGE_SHIFT);
|
|
+ dprintk("%s: pte at 0x%p\r\n", __FUNCTION__, pte);
|
|
+ for (l1 = 0; l1 < 1024; l1++) {
|
|
+ if (!pte[l1] & 1)
|
|
+ continue;
|
|
+ flg = pte[l1] & (PAGE_SIZE-1);
|
|
+ pfn = pte[l1] >> PAGE_SHIFT;
|
|
+ pte[l1] = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flg;
|
|
+ }
|
|
+ }
|
|
+}
|
|
+
|
|
+static void fixup_pagetables_pae(void)
|
|
+{
|
|
+ uint64_t *pgd = (void*)new_info->pt_base - virt_base;
|
|
+ uint64_t *pmd;
|
|
+ uint64_t *pte;
|
|
+ uint64_t flg;
|
|
+ unsigned long pfn;
|
|
+ int l3, l2, l1;
|
|
+
|
|
+ dprintk("%s: pgd at 0x%p\r\n", __FUNCTION__, pgd);
|
|
+ for (l3 = 0; l3 < 4; l3++) {
|
|
+ if (!pgd[l3] & 1)
|
|
+ continue;
|
|
+ flg = pgd[l3] & (PAGE_SIZE-1);
|
|
+ pfn = pgd[l3] >> PAGE_SHIFT;
|
|
+ pgd[l3] = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flg;
|
|
+
|
|
+ pmd = (void*)(pfn << PAGE_SHIFT);
|
|
+ dprintk("%s: pmd at 0x%p\r\n", __FUNCTION__, pmd);
|
|
+ for (l2 = 0; l2 < 512; l2++) {
|
|
+ if (!pmd[l2] & 1)
|
|
+ continue;
|
|
+ flg = pmd[l2] & (PAGE_SIZE-1);
|
|
+ pfn = pmd[l2] >> PAGE_SHIFT;
|
|
+ pmd[l2] = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flg;
|
|
+
|
|
+ pte = (void*)(pfn << PAGE_SHIFT);
|
|
+ dprintk("%s: pte at 0x%p\r\n", __FUNCTION__, pte);
|
|
+ for (l1 = 0; l1 < 512; l1++) {
|
|
+ if (!pte[l1] & 1)
|
|
+ continue;
|
|
+ flg = pte[l1] & (PAGE_SIZE-1);
|
|
+ pfn = pte[l1] >> PAGE_SHIFT;
|
|
+ pte[l1] = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flg;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+}
|
|
+
|
|
+static void fixup_pagetables(void)
|
|
+{
|
|
+ if (pae_paging)
|
|
+ fixup_pagetables_pae();
|
|
+ else
|
|
+ fixup_pagetables_32();
|
|
+}
|
|
+
|
|
+#endif /* i386 */
|
|
+
|
|
+#if defined(__x86_64__)
|
|
+
|
|
+static void map_page(page_t page, unsigned long mfn, unsigned long flags)
|
|
+{
|
|
+ unsigned long vaddr = (unsigned long)page;
|
|
+ uint64_t *pgd = (void*)old_info->pt_base;
|
|
+ uint64_t *pud;
|
|
+ uint64_t *pmd;
|
|
+ uint64_t *pte;
|
|
+ xen_pfn_t pfn;
|
|
+ int pgd_off, pud_off, pmd_off, pte_off;
|
|
+
|
|
+ pgd_off = (vaddr >> 39) & (512-1);
|
|
+ pud_off = (vaddr >> 30) & (512-1);
|
|
+ pmd_off = (vaddr >> 21) & (512-1);
|
|
+ pte_off = (vaddr >> 12) & (512-1);
|
|
+
|
|
+ pfn = mfn_to_pfn(pgd[pgd_off] >> PAGE_SHIFT);
|
|
+ pud = (void*)(pfn << PAGE_SHIFT);
|
|
+ pfn = mfn_to_pfn(pud[pud_off] >> PAGE_SHIFT);
|
|
+ pmd = (void*)(pfn << PAGE_SHIFT);
|
|
+ pfn = mfn_to_pfn(pmd[pmd_off] >> PAGE_SHIFT);
|
|
+ pte = (void*)(pfn << PAGE_SHIFT);
|
|
+
|
|
+ pte[pte_off] = (mfn << PAGE_SHIFT) | flags;
|
|
+
|
|
+ xen_tlb_flush();
|
|
+ xen_wmb();
|
|
+}
|
|
+
|
|
+static void map_virt_base(void)
|
|
+{
|
|
+ mmu_update_t u;
|
|
+ xen_pfn_t pgd_mfn = pfn_to_mfn(old_info->pt_base >> PAGE_SHIFT);
|
|
+ uint64_t *pgd_ma = (void*)(pgd_mfn << PAGE_SHIFT);
|
|
+ uint64_t *pgd = (void*)old_info->pt_base;
|
|
+ uint64_t pgd_virt = (virt_base >> 39);
|
|
+ uint64_t pgd_low = 0;
|
|
+
|
|
+ if (pgd_virt << 39 != virt_base) {
|
|
+ printk("%s: warning: virt_base is not at pgd entry border,\r\n"
|
|
+ " that will work only if old and new kernel have\r\n"
|
|
+ " an identical virt_base.\r\n", __FUNCTION__);
|
|
+ return;
|
|
+ }
|
|
+
|
|
+ for (;;) {
|
|
+ if (!(pgd[pgd_low] & _PAGE_PRESENT))
|
|
+ break;
|
|
+ u.ptr = (unsigned long)(pgd_ma + pgd_virt);
|
|
+ u.val = pgd[pgd_low];
|
|
+ printk("%s: ptr 0x%" PRIx64" val 0x%" PRIx64"\r\n",
|
|
+ __FUNCTION__, u.ptr, u.val);
|
|
+ if (HYPERVISOR_mmu_update(&u, 1, NULL, DOMID_SELF) < 0) {
|
|
+ printk("%s: mmu_update failed [l4 0x%lx -> 0x%lx]\r\n",
|
|
+ __FUNCTION__, pgd_low, pgd_virt);
|
|
+ break;
|
|
+ }
|
|
+ pgd_virt++;
|
|
+ pgd_low++;
|
|
+ }
|
|
+ xen_tlb_flush();
|
|
+ xen_wmb();
|
|
+}
|
|
+
|
|
+static void fixup_pagetables(void)
|
|
+{
|
|
+ uint64_t *pgd = (void*)new_info->pt_base - virt_base;
|
|
+ uint64_t *pud;
|
|
+ uint64_t *pmd;
|
|
+ uint64_t *pte;
|
|
+ uint64_t flg;
|
|
+ unsigned long pfn;
|
|
+ int l4, l3, l2, l1;
|
|
+
|
|
+ dprintk("%s: pgd at 0x%p\r\n", __FUNCTION__, pgd);
|
|
+ for (l4 = 0; l4 < 512; l4++) {
|
|
+ if (!pgd[l4] & 1)
|
|
+ continue;
|
|
+ flg = pgd[l4] & (PAGE_SIZE-1);
|
|
+ pfn = pgd[l4] >> PAGE_SHIFT;
|
|
+ pgd[l4] = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flg;
|
|
+
|
|
+ pud = (void*)(pfn << PAGE_SHIFT);
|
|
+ dprintk("%s: pud at 0x%p\r\n", __FUNCTION__, pud);
|
|
+ for (l3 = 0; l3 < 512; l3++) {
|
|
+ if (!pud[l3] & 1)
|
|
+ continue;
|
|
+ flg = pud[l3] & (PAGE_SIZE-1);
|
|
+ pfn = pud[l3] >> PAGE_SHIFT;
|
|
+ pud[l3] = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flg;
|
|
+
|
|
+ pmd = (void*)(pfn << PAGE_SHIFT);
|
|
+ dprintk("%s: pmd at 0x%p\r\n", __FUNCTION__, pmd);
|
|
+ for (l2 = 0; l2 < 512; l2++) {
|
|
+ if (!pmd[l2] & 1)
|
|
+ continue;
|
|
+ flg = pmd[l2] & (PAGE_SIZE-1);
|
|
+ pfn = pmd[l2] >> PAGE_SHIFT;
|
|
+ pmd[l2] = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flg;
|
|
+
|
|
+ pte = (void*)(pfn << PAGE_SHIFT);
|
|
+ dprintk("%s: pte at 0x%p\r\n", __FUNCTION__, pte);
|
|
+ for (l1 = 0; l1 < 512; l1++) {
|
|
+ if (!pte[l1] & 1)
|
|
+ continue;
|
|
+ flg = pte[l1] & (PAGE_SIZE-1);
|
|
+ pfn = pte[l1] >> PAGE_SHIFT;
|
|
+ pte[l1] = (pfn_to_mfn(pfn) << PAGE_SHIFT) | flg;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+}
|
|
+
|
|
+#endif /* x86_64 */
|
|
+
|
|
+/* ------------------------------------------------------------------ */
|
|
+
|
|
+static void print_start_info(char *name, struct start_info *info)
|
|
+{
|
|
+ if (!debug_level)
|
|
+ return;
|
|
+ printk("%s start_info page @ %p\r\n", name, info);
|
|
+ printk(" magic \"%s\"\r\n", info->magic);
|
|
+ printk(" nr_pages 0x%lx\r\n", info->nr_pages);
|
|
+ printk(" shared_info 0x%lx\r\n", info->shared_info);
|
|
+ printk(" flags 0x%x\r\n", info->flags);
|
|
+ printk(" store_mfn 0x%lx\r\n", info->store_mfn);
|
|
+ printk(" store_evtchn %d\r\n", info->store_evtchn);
|
|
+ printk(" console.mfn 0x%lx\r\n", info->console.domU.mfn);
|
|
+ printk(" console.evtchn %d\r\n", info->console.domU.evtchn);
|
|
+ printk(" pt_base 0x%lx\r\n", info->pt_base);
|
|
+ printk(" nr_pt_frames 0x%lx\r\n", info->nr_pt_frames);
|
|
+ printk(" mfn_list 0x%lx\r\n", info->mfn_list);
|
|
+ printk(" mod_start 0x%lx\r\n", info->mod_start);
|
|
+ printk(" mod_len 0x%lx\r\n", info->mod_len);
|
|
+ printk(" cmd_line \"%s\"\r\n", info->cmd_line);
|
|
+ printk("\r\n");
|
|
+}
|
|
+
|
|
+void start_helper(void)
|
|
+{
|
|
+ int shadow_translated;
|
|
+ unsigned long cr3_mfn;
|
|
+
|
|
+ /* find m2p map */
|
|
+#if defined(__i386__)
|
|
+ if (pae_paging) {
|
|
+ machine_to_phys_mapping = (xen_pfn_t*)0xf5800000;
|
|
+ } else {
|
|
+ machine_to_phys_mapping = (xen_pfn_t*)0xfc000000;
|
|
+ }
|
|
+#endif
|
|
+#if defined(__x86_64__)
|
|
+ machine_to_phys_mapping = ((xen_pfn_t*)HYPERVISOR_VIRT_START);
|
|
+#endif
|
|
+
|
|
+ /* map magic pages */
|
|
+ map_page(console_page, old_info->console.domU.mfn,
|
|
+ _PAGE_PRESENT | _PAGE_RW);
|
|
+ map_page(xenstore_page, old_info->store_mfn,
|
|
+ _PAGE_PRESENT | _PAGE_RW);
|
|
+ map_page(shared_info_page, old_info->shared_info >> PAGE_SHIFT,
|
|
+ _PAGE_PRESENT | _PAGE_RW);
|
|
+
|
|
+ /* setup console, say hello world */
|
|
+ console_evtchn = old_info->console.domU.evtchn;
|
|
+ printk("\r\nHello world from xen kexec helper\r\n\r\n");
|
|
+
|
|
+ /* print old start info page */
|
|
+ print_start_info("old", old_info);
|
|
+
|
|
+ /* figure and print some info */
|
|
+ setup_xen_features();
|
|
+ shadow_translated = xen_feature(XENFEAT_auto_translated_physmap);
|
|
+ dprintk("shadow_translated is %s\r\n",
|
|
+ shadow_translated ? "on" : "off");
|
|
+#if defined(__i386__)
|
|
+ dprintk("pae paging is %s\r\n",
|
|
+ pae_paging ? "on" : "off");
|
|
+#endif
|
|
+ dprintk("virtual base is 0x%lx\r\n", virt_base);
|
|
+ if (-1 != virt_hypercall)
|
|
+ dprintk("hypercall page at is 0x%lx\r\n", virt_hypercall);
|
|
+ dprintk("kernel entry point is 0x%lx\r\n", (unsigned long)vcpu.user_regs.eip);
|
|
+ dprintk("start_info page is 0x%lx\r\n", (unsigned long)vcpu.user_regs.esi);
|
|
+ dprintk("kernel boot stack is 0x%lx\r\n", (unsigned long)vcpu.user_regs.esp);
|
|
+ dprintk("\r\n");
|
|
+
|
|
+// xenstore_debug();
|
|
+
|
|
+ /* fixup new start info page */
|
|
+ new_info = (struct start_info*)(vcpu.user_regs.esi - virt_base);
|
|
+ new_info->shared_info = old_info->shared_info;
|
|
+ new_info->store_mfn = old_info->store_mfn;
|
|
+ new_info->store_evtchn = old_info->store_evtchn;
|
|
+ new_info->console.domU.mfn = old_info->console.domU.mfn;
|
|
+ new_info->console.domU.evtchn = old_info->console.domU.evtchn;
|
|
+
|
|
+ if (shadow_translated) {
|
|
+ printk("TODO: handle magic pages\r\n");
|
|
+ cr3_mfn = (new_info->pt_base - virt_base) >> PAGE_SHIFT;
|
|
+ } else {
|
|
+ /* copy p2m table to final place */
|
|
+ dprintk("copy p2m map\r\n");
|
|
+ p2m_copy();
|
|
+
|
|
+ /* move magic pages, page order is important here:
|
|
+ * start_info, xenstore, console */
|
|
+ dprintk("setup magic pages: xenstore and console\r\n");
|
|
+ swap_pages_p2m(mfn_to_pfn(new_info->store_mfn),
|
|
+ ((unsigned long)new_info >> PAGE_SHIFT)+1);
|
|
+ swap_pages_p2m(mfn_to_pfn(new_info->console.domU.mfn),
|
|
+ ((unsigned long)new_info >> PAGE_SHIFT)+2);
|
|
+
|
|
+ if (-1 != virt_hypercall) {
|
|
+ dprintk("setup hypercall page\r\n");
|
|
+ memcpy((void*)(virt_hypercall - virt_base),
|
|
+ hypercall_page, PAGE_SIZE);
|
|
+ }
|
|
+
|
|
+ dprintk("setup main memory\r\n");
|
|
+ plug_holes_p2m();
|
|
+ fillup_memory_p2m();
|
|
+
|
|
+ dprintk("mirror lowmem at virt_base [0x%lx]\r\n", virt_base);
|
|
+ map_virt_base();
|
|
+ start_kernel = _start_kernel + virt_base;
|
|
+
|
|
+ dprintk("setup new kernel's page tables\r\n");
|
|
+ fixup_pagetables();
|
|
+ cr3_mfn = pfn_to_mfn((new_info->pt_base - virt_base) >> PAGE_SHIFT);
|
|
+ }
|
|
+ printk("\r\n");
|
|
+
|
|
+ /* print new start info page */
|
|
+ print_start_info("new", new_info);
|
|
+
|
|
+ /* boot kernel */
|
|
+ vcpu.ctrlreg[3] = cr3_mfn << PAGE_SHIFT;
|
|
+ printk("All done, bye folks, trying to boot the kernel ...\r\n");
|
|
+ printk("\r\n");
|
|
+ start_kernel();
|
|
+}
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/make-offsets.c
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/make-offsets.c
|
|
@@ -0,0 +1,28 @@
|
|
+#include <stdio.h>
|
|
+#include <xenctrl.h>
|
|
+
|
|
+#define vcpu_off(name,elem) printf("#define vcpu_%s 0x%lx\n", name, \
|
|
+ (unsigned long)offsetof(struct vcpu_guest_context, elem))
|
|
+
|
|
+int main(int argc, char **argv)
|
|
+{
|
|
+ vcpu_off("eax", user_regs.eax);
|
|
+ vcpu_off("ebx", user_regs.ebx);
|
|
+ vcpu_off("ecx", user_regs.ecx);
|
|
+ vcpu_off("edx", user_regs.edx);
|
|
+ vcpu_off("esi", user_regs.esi);
|
|
+ vcpu_off("edi", user_regs.edi);
|
|
+ vcpu_off("ebp", user_regs.ebp);
|
|
+ vcpu_off("esp", user_regs.esp);
|
|
+
|
|
+ vcpu_off("cs", user_regs.cs);
|
|
+ vcpu_off("ds", user_regs.ds);
|
|
+ vcpu_off("es", user_regs.es);
|
|
+ vcpu_off("fs", user_regs.fs);
|
|
+ vcpu_off("gs", user_regs.gs);
|
|
+ vcpu_off("ss", user_regs.ss);
|
|
+
|
|
+ vcpu_off("eip", user_regs.eip);
|
|
+ vcpu_off("cr3", ctrlreg[3]);
|
|
+ return 0;
|
|
+}
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/printk.c
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/printk.c
|
|
@@ -0,0 +1,1051 @@
|
|
+/*
|
|
+ * linux/kernel/printk.c
|
|
+ *
|
|
+ * Copyright (C) 1991, 1992 Linus Torvalds
|
|
+ *
|
|
+ * Modified to make sys_syslog() more flexible: added commands to
|
|
+ * return the last 4k of kernel messages, regardless of whether
|
|
+ * they've been read or not. Added option to suppress kernel printk's
|
|
+ * to the console. Added hook for sending the console messages
|
|
+ * elsewhere, in preparation for a serial line console (someday).
|
|
+ * Ted Ts'o, 2/11/93.
|
|
+ * Modified for sysctl support, 1/8/97, Chris Horn.
|
|
+ * Fixed SMP synchronization, 08/08/99, Manfred Spraul
|
|
+ * manfreds@colorfullife.com
|
|
+ * Rewrote bits to get rid of console_lock
|
|
+ * 01Mar01 Andrew Morton <andrewm@uow.edu.au>
|
|
+ */
|
|
+
|
|
+#include <linux/kernel.h>
|
|
+#include <linux/mm.h>
|
|
+#include <linux/tty.h>
|
|
+#include <linux/tty_driver.h>
|
|
+#include <linux/smp_lock.h>
|
|
+#include <linux/console.h>
|
|
+#include <linux/init.h>
|
|
+#include <linux/module.h>
|
|
+#include <linux/interrupt.h> /* For in_interrupt() */
|
|
+#include <linux/config.h>
|
|
+#include <linux/delay.h>
|
|
+#include <linux/smp.h>
|
|
+#include <linux/security.h>
|
|
+#include <linux/bootmem.h>
|
|
+#include <linux/syscalls.h>
|
|
+
|
|
+#include <asm/uaccess.h>
|
|
+
|
|
+#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
|
|
+
|
|
+/* printk's without a loglevel use this.. */
|
|
+#define DEFAULT_MESSAGE_LOGLEVEL 4 /* KERN_WARNING */
|
|
+
|
|
+/* We show everything that is MORE important than this.. */
|
|
+#define MINIMUM_CONSOLE_LOGLEVEL 1 /* Minimum loglevel we let people use */
|
|
+#define DEFAULT_CONSOLE_LOGLEVEL 7 /* anything MORE serious than KERN_DEBUG */
|
|
+
|
|
+DECLARE_WAIT_QUEUE_HEAD(log_wait);
|
|
+
|
|
+int console_printk[4] = {
|
|
+ DEFAULT_CONSOLE_LOGLEVEL, /* console_loglevel */
|
|
+ DEFAULT_MESSAGE_LOGLEVEL, /* default_message_loglevel */
|
|
+ MINIMUM_CONSOLE_LOGLEVEL, /* minimum_console_loglevel */
|
|
+ DEFAULT_CONSOLE_LOGLEVEL, /* default_console_loglevel */
|
|
+};
|
|
+
|
|
+EXPORT_SYMBOL(console_printk);
|
|
+
|
|
+/*
|
|
+ * Low lever drivers may need that to know if they can schedule in
|
|
+ * their unblank() callback or not. So let's export it.
|
|
+ */
|
|
+int oops_in_progress;
|
|
+EXPORT_SYMBOL(oops_in_progress);
|
|
+
|
|
+/*
|
|
+ * console_sem protects the console_drivers list, and also
|
|
+ * provides serialisation for access to the entire console
|
|
+ * driver system.
|
|
+ */
|
|
+static DECLARE_MUTEX(console_sem);
|
|
+struct console *console_drivers;
|
|
+/*
|
|
+ * This is used for debugging the mess that is the VT code by
|
|
+ * keeping track if we have the console semaphore held. It's
|
|
+ * definitely not the perfect debug tool (we don't know if _WE_
|
|
+ * hold it are racing, but it helps tracking those weird code
|
|
+ * path in the console code where we end up in places I want
|
|
+ * locked without the console sempahore held
|
|
+ */
|
|
+static int console_locked;
|
|
+
|
|
+/*
|
|
+ * logbuf_lock protects log_buf, log_start, log_end, con_start and logged_chars
|
|
+ * It is also used in interesting ways to provide interlocking in
|
|
+ * release_console_sem().
|
|
+ */
|
|
+static DEFINE_SPINLOCK(logbuf_lock);
|
|
+
|
|
+#define LOG_BUF_MASK (log_buf_len-1)
|
|
+#define LOG_BUF(idx) (log_buf[(idx) & LOG_BUF_MASK])
|
|
+
|
|
+/*
|
|
+ * The indices into log_buf are not constrained to log_buf_len - they
|
|
+ * must be masked before subscripting
|
|
+ */
|
|
+static unsigned long log_start; /* Index into log_buf: next char to be read by syslog() */
|
|
+static unsigned long con_start; /* Index into log_buf: next char to be sent to consoles */
|
|
+static unsigned long log_end; /* Index into log_buf: most-recently-written-char + 1 */
|
|
+
|
|
+/*
|
|
+ * Array of consoles built from command line options (console=)
|
|
+ */
|
|
+struct console_cmdline
|
|
+{
|
|
+ char name[8]; /* Name of the driver */
|
|
+ int index; /* Minor dev. to use */
|
|
+ char *options; /* Options for the driver */
|
|
+};
|
|
+
|
|
+#define MAX_CMDLINECONSOLES 8
|
|
+
|
|
+static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
|
|
+static int selected_console = -1;
|
|
+static int preferred_console = -1;
|
|
+
|
|
+/* Flag: console code may call schedule() */
|
|
+static int console_may_schedule;
|
|
+
|
|
+#ifdef CONFIG_PRINTK
|
|
+
|
|
+static char __log_buf[__LOG_BUF_LEN];
|
|
+static char *log_buf = __log_buf;
|
|
+static int log_buf_len = __LOG_BUF_LEN;
|
|
+static unsigned long logged_chars; /* Number of chars produced since last read+clear operation */
|
|
+
|
|
+/*
|
|
+ * Setup a list of consoles. Called from init/main.c
|
|
+ */
|
|
+static int __init console_setup(char *str)
|
|
+{
|
|
+ char name[sizeof(console_cmdline[0].name)];
|
|
+ char *s, *options;
|
|
+ int idx;
|
|
+
|
|
+ /*
|
|
+ * Decode str into name, index, options.
|
|
+ */
|
|
+ if (str[0] >= '0' && str[0] <= '9') {
|
|
+ strcpy(name, "ttyS");
|
|
+ strncpy(name + 4, str, sizeof(name) - 5);
|
|
+ } else
|
|
+ strncpy(name, str, sizeof(name) - 1);
|
|
+ name[sizeof(name) - 1] = 0;
|
|
+ if ((options = strchr(str, ',')) != NULL)
|
|
+ *(options++) = 0;
|
|
+#ifdef __sparc__
|
|
+ if (!strcmp(str, "ttya"))
|
|
+ strcpy(name, "ttyS0");
|
|
+ if (!strcmp(str, "ttyb"))
|
|
+ strcpy(name, "ttyS1");
|
|
+#endif
|
|
+ for (s = name; *s; s++)
|
|
+ if ((*s >= '0' && *s <= '9') || *s == ',')
|
|
+ break;
|
|
+ idx = simple_strtoul(s, NULL, 10);
|
|
+ *s = 0;
|
|
+
|
|
+ add_preferred_console(name, idx, options);
|
|
+ return 1;
|
|
+}
|
|
+
|
|
+__setup("console=", console_setup);
|
|
+
|
|
+static int __init log_buf_len_setup(char *str)
|
|
+{
|
|
+ unsigned long size = memparse(str, &str);
|
|
+ unsigned long flags;
|
|
+
|
|
+ if (size)
|
|
+ size = roundup_pow_of_two(size);
|
|
+ if (size > log_buf_len) {
|
|
+ unsigned long start, dest_idx, offset;
|
|
+ char *new_log_buf;
|
|
+
|
|
+ new_log_buf = alloc_bootmem(size);
|
|
+ if (!new_log_buf) {
|
|
+ printk(KERN_WARNING "log_buf_len: allocation failed\n");
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ spin_lock_irqsave(&logbuf_lock, flags);
|
|
+ log_buf_len = size;
|
|
+ log_buf = new_log_buf;
|
|
+
|
|
+ offset = start = min(con_start, log_start);
|
|
+ dest_idx = 0;
|
|
+ while (start != log_end) {
|
|
+ log_buf[dest_idx] = __log_buf[start & (__LOG_BUF_LEN - 1)];
|
|
+ start++;
|
|
+ dest_idx++;
|
|
+ }
|
|
+ log_start -= offset;
|
|
+ con_start -= offset;
|
|
+ log_end -= offset;
|
|
+ spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
+
|
|
+ printk(KERN_NOTICE "log_buf_len: %d\n", log_buf_len);
|
|
+ }
|
|
+out:
|
|
+ return 1;
|
|
+}
|
|
+
|
|
+__setup("log_buf_len=", log_buf_len_setup);
|
|
+
|
|
+/*
|
|
+ * Commands to do_syslog:
|
|
+ *
|
|
+ * 0 -- Close the log. Currently a NOP.
|
|
+ * 1 -- Open the log. Currently a NOP.
|
|
+ * 2 -- Read from the log.
|
|
+ * 3 -- Read all messages remaining in the ring buffer.
|
|
+ * 4 -- Read and clear all messages remaining in the ring buffer
|
|
+ * 5 -- Clear ring buffer.
|
|
+ * 6 -- Disable printk's to console
|
|
+ * 7 -- Enable printk's to console
|
|
+ * 8 -- Set level of messages printed to console
|
|
+ * 9 -- Return number of unread characters in the log buffer
|
|
+ * 10 -- Return size of the log buffer
|
|
+ */
|
|
+int do_syslog(int type, char __user *buf, int len)
|
|
+{
|
|
+ unsigned long i, j, limit, count;
|
|
+ int do_clear = 0;
|
|
+ char c;
|
|
+ int error = 0;
|
|
+
|
|
+ error = security_syslog(type);
|
|
+ if (error)
|
|
+ return error;
|
|
+
|
|
+ switch (type) {
|
|
+ case 0: /* Close log */
|
|
+ break;
|
|
+ case 1: /* Open log */
|
|
+ break;
|
|
+ case 2: /* Read from log */
|
|
+ error = -EINVAL;
|
|
+ if (!buf || len < 0)
|
|
+ goto out;
|
|
+ error = 0;
|
|
+ if (!len)
|
|
+ goto out;
|
|
+ if (!access_ok(VERIFY_WRITE, buf, len)) {
|
|
+ error = -EFAULT;
|
|
+ goto out;
|
|
+ }
|
|
+ error = wait_event_interruptible(log_wait,
|
|
+ (log_start - log_end));
|
|
+ if (error)
|
|
+ goto out;
|
|
+ i = 0;
|
|
+ spin_lock_irq(&logbuf_lock);
|
|
+ while (!error && (log_start != log_end) && i < len) {
|
|
+ c = LOG_BUF(log_start);
|
|
+ log_start++;
|
|
+ spin_unlock_irq(&logbuf_lock);
|
|
+ error = __put_user(c,buf);
|
|
+ buf++;
|
|
+ i++;
|
|
+ cond_resched();
|
|
+ spin_lock_irq(&logbuf_lock);
|
|
+ }
|
|
+ spin_unlock_irq(&logbuf_lock);
|
|
+ if (!error)
|
|
+ error = i;
|
|
+ break;
|
|
+ case 4: /* Read/clear last kernel messages */
|
|
+ do_clear = 1;
|
|
+ /* FALL THRU */
|
|
+ case 3: /* Read last kernel messages */
|
|
+ error = -EINVAL;
|
|
+ if (!buf || len < 0)
|
|
+ goto out;
|
|
+ error = 0;
|
|
+ if (!len)
|
|
+ goto out;
|
|
+ if (!access_ok(VERIFY_WRITE, buf, len)) {
|
|
+ error = -EFAULT;
|
|
+ goto out;
|
|
+ }
|
|
+ count = len;
|
|
+ if (count > log_buf_len)
|
|
+ count = log_buf_len;
|
|
+ spin_lock_irq(&logbuf_lock);
|
|
+ if (count > logged_chars)
|
|
+ count = logged_chars;
|
|
+ if (do_clear)
|
|
+ logged_chars = 0;
|
|
+ limit = log_end;
|
|
+ /*
|
|
+ * __put_user() could sleep, and while we sleep
|
|
+ * printk() could overwrite the messages
|
|
+ * we try to copy to user space. Therefore
|
|
+ * the messages are copied in reverse. <manfreds>
|
|
+ */
|
|
+ for (i = 0; i < count && !error; i++) {
|
|
+ j = limit-1-i;
|
|
+ if (j + log_buf_len < log_end)
|
|
+ break;
|
|
+ c = LOG_BUF(j);
|
|
+ spin_unlock_irq(&logbuf_lock);
|
|
+ error = __put_user(c,&buf[count-1-i]);
|
|
+ cond_resched();
|
|
+ spin_lock_irq(&logbuf_lock);
|
|
+ }
|
|
+ spin_unlock_irq(&logbuf_lock);
|
|
+ if (error)
|
|
+ break;
|
|
+ error = i;
|
|
+ if (i != count) {
|
|
+ int offset = count-error;
|
|
+ /* buffer overflow during copy, correct user buffer. */
|
|
+ for (i = 0; i < error; i++) {
|
|
+ if (__get_user(c,&buf[i+offset]) ||
|
|
+ __put_user(c,&buf[i])) {
|
|
+ error = -EFAULT;
|
|
+ break;
|
|
+ }
|
|
+ cond_resched();
|
|
+ }
|
|
+ }
|
|
+ break;
|
|
+ case 5: /* Clear ring buffer */
|
|
+ logged_chars = 0;
|
|
+ break;
|
|
+ case 6: /* Disable logging to console */
|
|
+ console_loglevel = minimum_console_loglevel;
|
|
+ break;
|
|
+ case 7: /* Enable logging to console */
|
|
+ console_loglevel = default_console_loglevel;
|
|
+ break;
|
|
+ case 8: /* Set level of messages printed to console */
|
|
+ error = -EINVAL;
|
|
+ if (len < 1 || len > 8)
|
|
+ goto out;
|
|
+ if (len < minimum_console_loglevel)
|
|
+ len = minimum_console_loglevel;
|
|
+ console_loglevel = len;
|
|
+ error = 0;
|
|
+ break;
|
|
+ case 9: /* Number of chars in the log buffer */
|
|
+ error = log_end - log_start;
|
|
+ break;
|
|
+ case 10: /* Size of the log buffer */
|
|
+ error = log_buf_len;
|
|
+ break;
|
|
+ default:
|
|
+ error = -EINVAL;
|
|
+ break;
|
|
+ }
|
|
+out:
|
|
+ return error;
|
|
+}
|
|
+
|
|
+asmlinkage long sys_syslog(int type, char __user *buf, int len)
|
|
+{
|
|
+ return do_syslog(type, buf, len);
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Call the console drivers on a range of log_buf
|
|
+ */
|
|
+static void __call_console_drivers(unsigned long start, unsigned long end)
|
|
+{
|
|
+ struct console *con;
|
|
+
|
|
+ for (con = console_drivers; con; con = con->next) {
|
|
+ if ((con->flags & CON_ENABLED) && con->write)
|
|
+ con->write(con, &LOG_BUF(start), end - start);
|
|
+ }
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Write out chars from start to end - 1 inclusive
|
|
+ */
|
|
+static void _call_console_drivers(unsigned long start,
|
|
+ unsigned long end, int msg_log_level)
|
|
+{
|
|
+ if (msg_log_level < console_loglevel &&
|
|
+ console_drivers && start != end) {
|
|
+ if ((start & LOG_BUF_MASK) > (end & LOG_BUF_MASK)) {
|
|
+ /* wrapped write */
|
|
+ __call_console_drivers(start & LOG_BUF_MASK,
|
|
+ log_buf_len);
|
|
+ __call_console_drivers(0, end & LOG_BUF_MASK);
|
|
+ } else {
|
|
+ __call_console_drivers(start, end);
|
|
+ }
|
|
+ }
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Call the console drivers, asking them to write out
|
|
+ * log_buf[start] to log_buf[end - 1].
|
|
+ * The console_sem must be held.
|
|
+ */
|
|
+static void call_console_drivers(unsigned long start, unsigned long end)
|
|
+{
|
|
+ unsigned long cur_index, start_print;
|
|
+ static int msg_level = -1;
|
|
+
|
|
+ if (((long)(start - end)) > 0)
|
|
+ BUG();
|
|
+
|
|
+ cur_index = start;
|
|
+ start_print = start;
|
|
+ while (cur_index != end) {
|
|
+ if (msg_level < 0 && ((end - cur_index) > 2) &&
|
|
+ LOG_BUF(cur_index + 0) == '<' &&
|
|
+ LOG_BUF(cur_index + 1) >= '0' &&
|
|
+ LOG_BUF(cur_index + 1) <= '7' &&
|
|
+ LOG_BUF(cur_index + 2) == '>') {
|
|
+ msg_level = LOG_BUF(cur_index + 1) - '0';
|
|
+ cur_index += 3;
|
|
+ start_print = cur_index;
|
|
+ }
|
|
+ while (cur_index != end) {
|
|
+ char c = LOG_BUF(cur_index);
|
|
+
|
|
+ cur_index++;
|
|
+ if (c == '\n') {
|
|
+ if (msg_level < 0) {
|
|
+ /*
|
|
+ * printk() has already given us loglevel tags in
|
|
+ * the buffer. This code is here in case the
|
|
+ * log buffer has wrapped right round and scribbled
|
|
+ * on those tags
|
|
+ */
|
|
+ msg_level = default_message_loglevel;
|
|
+ }
|
|
+ _call_console_drivers(start_print, cur_index, msg_level);
|
|
+ msg_level = -1;
|
|
+ start_print = cur_index;
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ _call_console_drivers(start_print, end, msg_level);
|
|
+}
|
|
+
|
|
+static void emit_log_char(char c)
|
|
+{
|
|
+ LOG_BUF(log_end) = c;
|
|
+ log_end++;
|
|
+ if (log_end - log_start > log_buf_len)
|
|
+ log_start = log_end - log_buf_len;
|
|
+ if (log_end - con_start > log_buf_len)
|
|
+ con_start = log_end - log_buf_len;
|
|
+ if (logged_chars < log_buf_len)
|
|
+ logged_chars++;
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Zap console related locks when oopsing. Only zap at most once
|
|
+ * every 10 seconds, to leave time for slow consoles to print a
|
|
+ * full oops.
|
|
+ */
|
|
+static void zap_locks(void)
|
|
+{
|
|
+ static unsigned long oops_timestamp;
|
|
+
|
|
+ if (time_after_eq(jiffies, oops_timestamp) &&
|
|
+ !time_after(jiffies, oops_timestamp + 30 * HZ))
|
|
+ return;
|
|
+
|
|
+ oops_timestamp = jiffies;
|
|
+
|
|
+ /* If a crash is occurring, make sure we can't deadlock */
|
|
+ spin_lock_init(&logbuf_lock);
|
|
+ /* And make sure that we print immediately */
|
|
+ init_MUTEX(&console_sem);
|
|
+}
|
|
+
|
|
+#if defined(CONFIG_PRINTK_TIME)
|
|
+static int printk_time = 1;
|
|
+#else
|
|
+static int printk_time = 0;
|
|
+#endif
|
|
+
|
|
+static int __init printk_time_setup(char *str)
|
|
+{
|
|
+ if (*str)
|
|
+ return 0;
|
|
+ printk_time = 1;
|
|
+ return 1;
|
|
+}
|
|
+
|
|
+__setup("time", printk_time_setup);
|
|
+
|
|
+__attribute__((weak)) unsigned long long printk_clock(void)
|
|
+{
|
|
+ return sched_clock();
|
|
+}
|
|
+
|
|
+/**
|
|
+ * printk - print a kernel message
|
|
+ * @fmt: format string
|
|
+ *
|
|
+ * This is printk. It can be called from any context. We want it to work.
|
|
+ *
|
|
+ * We try to grab the console_sem. If we succeed, it's easy - we log the output and
|
|
+ * call the console drivers. If we fail to get the semaphore we place the output
|
|
+ * into the log buffer and return. The current holder of the console_sem will
|
|
+ * notice the new output in release_console_sem() and will send it to the
|
|
+ * consoles before releasing the semaphore.
|
|
+ *
|
|
+ * One effect of this deferred printing is that code which calls printk() and
|
|
+ * then changes console_loglevel may break. This is because console_loglevel
|
|
+ * is inspected when the actual printing occurs.
|
|
+ *
|
|
+ * See also:
|
|
+ * printf(3)
|
|
+ */
|
|
+
|
|
+asmlinkage int printk(const char *fmt, ...)
|
|
+{
|
|
+ va_list args;
|
|
+ int r;
|
|
+
|
|
+ va_start(args, fmt);
|
|
+ r = vprintk(fmt, args);
|
|
+ va_end(args);
|
|
+
|
|
+ return r;
|
|
+}
|
|
+
|
|
+/* cpu currently holding logbuf_lock */
|
|
+static volatile unsigned int printk_cpu = UINT_MAX;
|
|
+
|
|
+asmlinkage int vprintk(const char *fmt, va_list args)
|
|
+{
|
|
+ unsigned long flags;
|
|
+ int printed_len;
|
|
+ char *p;
|
|
+ static char printk_buf[1024];
|
|
+ static int log_level_unknown = 1;
|
|
+
|
|
+ preempt_disable();
|
|
+ if (unlikely(oops_in_progress) && printk_cpu == smp_processor_id())
|
|
+ /* If a crash is occurring during printk() on this CPU,
|
|
+ * make sure we can't deadlock */
|
|
+ zap_locks();
|
|
+
|
|
+ /* This stops the holder of console_sem just where we want him */
|
|
+ spin_lock_irqsave(&logbuf_lock, flags);
|
|
+ printk_cpu = smp_processor_id();
|
|
+
|
|
+ /* Emit the output into the temporary buffer */
|
|
+ printed_len = vscnprintf(printk_buf, sizeof(printk_buf), fmt, args);
|
|
+
|
|
+ /*
|
|
+ * Copy the output into log_buf. If the caller didn't provide
|
|
+ * appropriate log level tags, we insert them here
|
|
+ */
|
|
+ for (p = printk_buf; *p; p++) {
|
|
+ if (log_level_unknown) {
|
|
+ /* log_level_unknown signals the start of a new line */
|
|
+ if (printk_time) {
|
|
+ int loglev_char;
|
|
+ char tbuf[50], *tp;
|
|
+ unsigned tlen;
|
|
+ unsigned long long t;
|
|
+ unsigned long nanosec_rem;
|
|
+
|
|
+ /*
|
|
+ * force the log level token to be
|
|
+ * before the time output.
|
|
+ */
|
|
+ if (p[0] == '<' && p[1] >='0' &&
|
|
+ p[1] <= '7' && p[2] == '>') {
|
|
+ loglev_char = p[1];
|
|
+ p += 3;
|
|
+ printed_len += 3;
|
|
+ } else {
|
|
+ loglev_char = default_message_loglevel
|
|
+ + '0';
|
|
+ }
|
|
+ t = printk_clock();
|
|
+ nanosec_rem = do_div(t, 1000000000);
|
|
+ tlen = sprintf(tbuf,
|
|
+ "<%c>[%5lu.%06lu] ",
|
|
+ loglev_char,
|
|
+ (unsigned long)t,
|
|
+ nanosec_rem/1000);
|
|
+
|
|
+ for (tp = tbuf; tp < tbuf + tlen; tp++)
|
|
+ emit_log_char(*tp);
|
|
+ printed_len += tlen - 3;
|
|
+ } else {
|
|
+ if (p[0] != '<' || p[1] < '0' ||
|
|
+ p[1] > '7' || p[2] != '>') {
|
|
+ emit_log_char('<');
|
|
+ emit_log_char(default_message_loglevel
|
|
+ + '0');
|
|
+ emit_log_char('>');
|
|
+ }
|
|
+ printed_len += 3;
|
|
+ }
|
|
+ log_level_unknown = 0;
|
|
+ if (!*p)
|
|
+ break;
|
|
+ }
|
|
+ emit_log_char(*p);
|
|
+ if (*p == '\n')
|
|
+ log_level_unknown = 1;
|
|
+ }
|
|
+
|
|
+ if (!cpu_online(smp_processor_id())) {
|
|
+ /*
|
|
+ * Some console drivers may assume that per-cpu resources have
|
|
+ * been allocated. So don't allow them to be called by this
|
|
+ * CPU until it is officially up. We shouldn't be calling into
|
|
+ * random console drivers on a CPU which doesn't exist yet..
|
|
+ */
|
|
+ printk_cpu = UINT_MAX;
|
|
+ spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
+ goto out;
|
|
+ }
|
|
+ if (!down_trylock(&console_sem)) {
|
|
+ console_locked = 1;
|
|
+ /*
|
|
+ * We own the drivers. We can drop the spinlock and let
|
|
+ * release_console_sem() print the text
|
|
+ */
|
|
+ printk_cpu = UINT_MAX;
|
|
+ spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
+ console_may_schedule = 0;
|
|
+ release_console_sem();
|
|
+ } else {
|
|
+ /*
|
|
+ * Someone else owns the drivers. We drop the spinlock, which
|
|
+ * allows the semaphore holder to proceed and to call the
|
|
+ * console drivers with the output which we just produced.
|
|
+ */
|
|
+ printk_cpu = UINT_MAX;
|
|
+ spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
+ }
|
|
+out:
|
|
+ preempt_enable();
|
|
+ return printed_len;
|
|
+}
|
|
+EXPORT_SYMBOL(printk);
|
|
+EXPORT_SYMBOL(vprintk);
|
|
+
|
|
+#else
|
|
+
|
|
+asmlinkage long sys_syslog(int type, char __user *buf, int len)
|
|
+{
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int do_syslog(int type, char __user *buf, int len)
|
|
+{
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static void call_console_drivers(unsigned long start, unsigned long end)
|
|
+{
|
|
+}
|
|
+
|
|
+#endif
|
|
+
|
|
+/**
|
|
+ * add_preferred_console - add a device to the list of preferred consoles.
|
|
+ * @name: device name
|
|
+ * @idx: device index
|
|
+ * @options: options for this console
|
|
+ *
|
|
+ * The last preferred console added will be used for kernel messages
|
|
+ * and stdin/out/err for init. Normally this is used by console_setup
|
|
+ * above to handle user-supplied console arguments; however it can also
|
|
+ * be used by arch-specific code either to override the user or more
|
|
+ * commonly to provide a default console (ie from PROM variables) when
|
|
+ * the user has not supplied one.
|
|
+ */
|
|
+int __init add_preferred_console(char *name, int idx, char *options)
|
|
+{
|
|
+ struct console_cmdline *c;
|
|
+ int i;
|
|
+
|
|
+ /*
|
|
+ * See if this tty is not yet registered, and
|
|
+ * if we have a slot free.
|
|
+ */
|
|
+ for(i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)
|
|
+ if (strcmp(console_cmdline[i].name, name) == 0 &&
|
|
+ console_cmdline[i].index == idx) {
|
|
+ selected_console = i;
|
|
+ return 0;
|
|
+ }
|
|
+ if (i == MAX_CMDLINECONSOLES)
|
|
+ return -E2BIG;
|
|
+ selected_console = i;
|
|
+ c = &console_cmdline[i];
|
|
+ memcpy(c->name, name, sizeof(c->name));
|
|
+ c->name[sizeof(c->name) - 1] = 0;
|
|
+ c->options = options;
|
|
+ c->index = idx;
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+/**
|
|
+ * acquire_console_sem - lock the console system for exclusive use.
|
|
+ *
|
|
+ * Acquires a semaphore which guarantees that the caller has
|
|
+ * exclusive access to the console system and the console_drivers list.
|
|
+ *
|
|
+ * Can sleep, returns nothing.
|
|
+ */
|
|
+void acquire_console_sem(void)
|
|
+{
|
|
+ if (in_interrupt())
|
|
+ BUG();
|
|
+ down(&console_sem);
|
|
+ console_locked = 1;
|
|
+ console_may_schedule = 1;
|
|
+}
|
|
+EXPORT_SYMBOL(acquire_console_sem);
|
|
+
|
|
+int try_acquire_console_sem(void)
|
|
+{
|
|
+ if (down_trylock(&console_sem))
|
|
+ return -1;
|
|
+ console_locked = 1;
|
|
+ console_may_schedule = 0;
|
|
+ return 0;
|
|
+}
|
|
+EXPORT_SYMBOL(try_acquire_console_sem);
|
|
+
|
|
+int is_console_locked(void)
|
|
+{
|
|
+ return console_locked;
|
|
+}
|
|
+EXPORT_SYMBOL(is_console_locked);
|
|
+
|
|
+/**
|
|
+ * release_console_sem - unlock the console system
|
|
+ *
|
|
+ * Releases the semaphore which the caller holds on the console system
|
|
+ * and the console driver list.
|
|
+ *
|
|
+ * While the semaphore was held, console output may have been buffered
|
|
+ * by printk(). If this is the case, release_console_sem() emits
|
|
+ * the output prior to releasing the semaphore.
|
|
+ *
|
|
+ * If there is output waiting for klogd, we wake it up.
|
|
+ *
|
|
+ * release_console_sem() may be called from any context.
|
|
+ */
|
|
+void release_console_sem(void)
|
|
+{
|
|
+ unsigned long flags;
|
|
+ unsigned long _con_start, _log_end;
|
|
+ unsigned long wake_klogd = 0;
|
|
+
|
|
+ for ( ; ; ) {
|
|
+ spin_lock_irqsave(&logbuf_lock, flags);
|
|
+ wake_klogd |= log_start - log_end;
|
|
+ if (con_start == log_end)
|
|
+ break; /* Nothing to print */
|
|
+ _con_start = con_start;
|
|
+ _log_end = log_end;
|
|
+ con_start = log_end; /* Flush */
|
|
+ spin_unlock(&logbuf_lock);
|
|
+ call_console_drivers(_con_start, _log_end);
|
|
+ local_irq_restore(flags);
|
|
+ }
|
|
+ console_locked = 0;
|
|
+ console_may_schedule = 0;
|
|
+ up(&console_sem);
|
|
+ spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
+ if (wake_klogd && !oops_in_progress && waitqueue_active(&log_wait))
|
|
+ wake_up_interruptible(&log_wait);
|
|
+}
|
|
+EXPORT_SYMBOL(release_console_sem);
|
|
+
|
|
+/**
|
|
+ * console_conditional_schedule - yield the CPU if required
|
|
+ *
|
|
+ * If the console code is currently allowed to sleep, and
|
|
+ * if this CPU should yield the CPU to another task, do
|
|
+ * so here.
|
|
+ *
|
|
+ * Must be called within acquire_console_sem().
|
|
+ */
|
|
+void __sched console_conditional_schedule(void)
|
|
+{
|
|
+ if (console_may_schedule)
|
|
+ cond_resched();
|
|
+}
|
|
+EXPORT_SYMBOL(console_conditional_schedule);
|
|
+
|
|
+void console_print(const char *s)
|
|
+{
|
|
+ printk(KERN_EMERG "%s", s);
|
|
+}
|
|
+EXPORT_SYMBOL(console_print);
|
|
+
|
|
+void console_unblank(void)
|
|
+{
|
|
+ struct console *c;
|
|
+
|
|
+ /*
|
|
+ * console_unblank can no longer be called in interrupt context unless
|
|
+ * oops_in_progress is set to 1..
|
|
+ */
|
|
+ if (oops_in_progress) {
|
|
+ if (down_trylock(&console_sem) != 0)
|
|
+ return;
|
|
+ } else
|
|
+ acquire_console_sem();
|
|
+
|
|
+ console_locked = 1;
|
|
+ console_may_schedule = 0;
|
|
+ for (c = console_drivers; c != NULL; c = c->next)
|
|
+ if ((c->flags & CON_ENABLED) && c->unblank)
|
|
+ c->unblank();
|
|
+ release_console_sem();
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Return the console tty driver structure and its associated index
|
|
+ */
|
|
+struct tty_driver *console_device(int *index)
|
|
+{
|
|
+ struct console *c;
|
|
+ struct tty_driver *driver = NULL;
|
|
+
|
|
+ acquire_console_sem();
|
|
+ for (c = console_drivers; c != NULL; c = c->next) {
|
|
+ if (!c->device)
|
|
+ continue;
|
|
+ driver = c->device(c, index);
|
|
+ if (driver)
|
|
+ break;
|
|
+ }
|
|
+ release_console_sem();
|
|
+ return driver;
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Prevent further output on the passed console device so that (for example)
|
|
+ * serial drivers can disable console output before suspending a port, and can
|
|
+ * re-enable output afterwards.
|
|
+ */
|
|
+void console_stop(struct console *console)
|
|
+{
|
|
+ acquire_console_sem();
|
|
+ console->flags &= ~CON_ENABLED;
|
|
+ release_console_sem();
|
|
+}
|
|
+EXPORT_SYMBOL(console_stop);
|
|
+
|
|
+void console_start(struct console *console)
|
|
+{
|
|
+ acquire_console_sem();
|
|
+ console->flags |= CON_ENABLED;
|
|
+ release_console_sem();
|
|
+}
|
|
+EXPORT_SYMBOL(console_start);
|
|
+
|
|
+/*
|
|
+ * The console driver calls this routine during kernel initialization
|
|
+ * to register the console printing procedure with printk() and to
|
|
+ * print any messages that were printed by the kernel before the
|
|
+ * console driver was initialized.
|
|
+ */
|
|
+void register_console(struct console *console)
|
|
+{
|
|
+ int i;
|
|
+ unsigned long flags;
|
|
+
|
|
+ if (preferred_console < 0)
|
|
+ preferred_console = selected_console;
|
|
+
|
|
+ /*
|
|
+ * See if we want to use this console driver. If we
|
|
+ * didn't select a console we take the first one
|
|
+ * that registers here.
|
|
+ */
|
|
+ if (preferred_console < 0) {
|
|
+ if (console->index < 0)
|
|
+ console->index = 0;
|
|
+ if (console->setup == NULL ||
|
|
+ console->setup(console, NULL) == 0) {
|
|
+ console->flags |= CON_ENABLED | CON_CONSDEV;
|
|
+ preferred_console = 0;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * See if this console matches one we selected on
|
|
+ * the command line.
|
|
+ */
|
|
+ for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
|
|
+ i++) {
|
|
+ if (strcmp(console_cmdline[i].name, console->name) != 0)
|
|
+ continue;
|
|
+ if (console->index >= 0 &&
|
|
+ console->index != console_cmdline[i].index)
|
|
+ continue;
|
|
+ if (console->index < 0)
|
|
+ console->index = console_cmdline[i].index;
|
|
+ if (console->setup &&
|
|
+ console->setup(console, console_cmdline[i].options) != 0)
|
|
+ break;
|
|
+ console->flags |= CON_ENABLED;
|
|
+ console->index = console_cmdline[i].index;
|
|
+ if (i == selected_console) {
|
|
+ console->flags |= CON_CONSDEV;
|
|
+ preferred_console = selected_console;
|
|
+ }
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ if (!(console->flags & CON_ENABLED))
|
|
+ return;
|
|
+
|
|
+ if (console_drivers && (console_drivers->flags & CON_BOOT)) {
|
|
+ unregister_console(console_drivers);
|
|
+ console->flags &= ~CON_PRINTBUFFER;
|
|
+ }
|
|
+
|
|
+ /*
|
|
+ * Put this console in the list - keep the
|
|
+ * preferred driver at the head of the list.
|
|
+ */
|
|
+ acquire_console_sem();
|
|
+ if ((console->flags & CON_CONSDEV) || console_drivers == NULL) {
|
|
+ console->next = console_drivers;
|
|
+ console_drivers = console;
|
|
+ if (console->next)
|
|
+ console->next->flags &= ~CON_CONSDEV;
|
|
+ } else {
|
|
+ console->next = console_drivers->next;
|
|
+ console_drivers->next = console;
|
|
+ }
|
|
+ if (console->flags & CON_PRINTBUFFER) {
|
|
+ /*
|
|
+ * release_console_sem() will print out the buffered messages
|
|
+ * for us.
|
|
+ */
|
|
+ spin_lock_irqsave(&logbuf_lock, flags);
|
|
+ con_start = log_start;
|
|
+ spin_unlock_irqrestore(&logbuf_lock, flags);
|
|
+ }
|
|
+ release_console_sem();
|
|
+}
|
|
+EXPORT_SYMBOL(register_console);
|
|
+
|
|
+int unregister_console(struct console *console)
|
|
+{
|
|
+ struct console *a, *b;
|
|
+ int res = 1;
|
|
+
|
|
+ acquire_console_sem();
|
|
+ if (console_drivers == console) {
|
|
+ console_drivers=console->next;
|
|
+ res = 0;
|
|
+ } else if (console_drivers) {
|
|
+ for (a=console_drivers->next, b=console_drivers ;
|
|
+ a; b=a, a=b->next) {
|
|
+ if (a == console) {
|
|
+ b->next = a->next;
|
|
+ res = 0;
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /* If last console is removed, we re-enable picking the first
|
|
+ * one that gets registered. Without that, pmac early boot console
|
|
+ * would prevent fbcon from taking over.
|
|
+ *
|
|
+ * If this isn't the last console and it has CON_CONSDEV set, we
|
|
+ * need to set it on the next preferred console.
|
|
+ */
|
|
+ if (console_drivers == NULL)
|
|
+ preferred_console = selected_console;
|
|
+ else if (console->flags & CON_CONSDEV)
|
|
+ console_drivers->flags |= CON_CONSDEV;
|
|
+
|
|
+ release_console_sem();
|
|
+ return res;
|
|
+}
|
|
+EXPORT_SYMBOL(unregister_console);
|
|
+
|
|
+/**
|
|
+ * tty_write_message - write a message to a certain tty, not just the console.
|
|
+ * @tty: the destination tty_struct
|
|
+ * @msg: the message to write
|
|
+ *
|
|
+ * This is used for messages that need to be redirected to a specific tty.
|
|
+ * We don't put it into the syslog queue right now maybe in the future if
|
|
+ * really needed.
|
|
+ */
|
|
+void tty_write_message(struct tty_struct *tty, char *msg)
|
|
+{
|
|
+ if (tty && tty->driver->write)
|
|
+ tty->driver->write(tty, msg, strlen(msg));
|
|
+ return;
|
|
+}
|
|
+
|
|
+/*
|
|
+ * printk rate limiting, lifted from the networking subsystem.
|
|
+ *
|
|
+ * This enforces a rate limit: not more than one kernel message
|
|
+ * every printk_ratelimit_jiffies to make a denial-of-service
|
|
+ * attack impossible.
|
|
+ */
|
|
+int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst)
|
|
+{
|
|
+ static DEFINE_SPINLOCK(ratelimit_lock);
|
|
+ static unsigned long toks = 10 * 5 * HZ;
|
|
+ static unsigned long last_msg;
|
|
+ static int missed;
|
|
+ unsigned long flags;
|
|
+ unsigned long now = jiffies;
|
|
+
|
|
+ spin_lock_irqsave(&ratelimit_lock, flags);
|
|
+ toks += now - last_msg;
|
|
+ last_msg = now;
|
|
+ if (toks > (ratelimit_burst * ratelimit_jiffies))
|
|
+ toks = ratelimit_burst * ratelimit_jiffies;
|
|
+ if (toks >= ratelimit_jiffies) {
|
|
+ int lost = missed;
|
|
+
|
|
+ missed = 0;
|
|
+ toks -= ratelimit_jiffies;
|
|
+ spin_unlock_irqrestore(&ratelimit_lock, flags);
|
|
+ if (lost)
|
|
+ printk(KERN_WARNING "printk: %d messages suppressed.\n", lost);
|
|
+ return 1;
|
|
+ }
|
|
+ missed++;
|
|
+ spin_unlock_irqrestore(&ratelimit_lock, flags);
|
|
+ return 0;
|
|
+}
|
|
+EXPORT_SYMBOL(__printk_ratelimit);
|
|
+
|
|
+/* minimum time in jiffies between messages */
|
|
+int printk_ratelimit_jiffies = 5 * HZ;
|
|
+
|
|
+/* number of messages we send before ratelimiting */
|
|
+int printk_ratelimit_burst = 10;
|
|
+
|
|
+int printk_ratelimit(void)
|
|
+{
|
|
+ return __printk_ratelimit(printk_ratelimit_jiffies,
|
|
+ printk_ratelimit_burst);
|
|
+}
|
|
+EXPORT_SYMBOL(printk_ratelimit);
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/string.c
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/string.c
|
|
@@ -0,0 +1,601 @@
|
|
+/*
|
|
+ * linux/lib/string.c
|
|
+ *
|
|
+ * Copyright (C) 1991, 1992 Linus Torvalds
|
|
+ */
|
|
+
|
|
+/*
|
|
+ * stupid library routines.. The optimized versions should generally be found
|
|
+ * as inline code in <asm-xx/string.h>
|
|
+ *
|
|
+ * These are buggy as well..
|
|
+ *
|
|
+ * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de>
|
|
+ * - Added strsep() which will replace strtok() soon (because strsep() is
|
|
+ * reentrant and should be faster). Use only strsep() in new code, please.
|
|
+ *
|
|
+ * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>,
|
|
+ * Matthew Hawkins <matt@mh.dropbear.id.au>
|
|
+ * - Kissed strtok() goodbye
|
|
+ */
|
|
+
|
|
+#include "helper.h"
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRNICMP
|
|
+/**
|
|
+ * strnicmp - Case insensitive, length-limited string comparison
|
|
+ * @s1: One string
|
|
+ * @s2: The other string
|
|
+ * @len: the maximum number of characters to compare
|
|
+ */
|
|
+int strnicmp(const char *s1, const char *s2, size_t len)
|
|
+{
|
|
+ /* Yes, Virginia, it had better be unsigned */
|
|
+ unsigned char c1, c2;
|
|
+
|
|
+ c1 = c2 = 0;
|
|
+ if (len) {
|
|
+ do {
|
|
+ c1 = *s1;
|
|
+ c2 = *s2;
|
|
+ s1++;
|
|
+ s2++;
|
|
+ if (!c1)
|
|
+ break;
|
|
+ if (!c2)
|
|
+ break;
|
|
+ if (c1 == c2)
|
|
+ continue;
|
|
+ c1 = tolower(c1);
|
|
+ c2 = tolower(c2);
|
|
+ if (c1 != c2)
|
|
+ break;
|
|
+ } while (--len);
|
|
+ }
|
|
+ return (int)c1 - (int)c2;
|
|
+}
|
|
+EXPORT_SYMBOL(strnicmp);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRCPY
|
|
+/**
|
|
+ * strcpy - Copy a %NUL terminated string
|
|
+ * @dest: Where to copy the string to
|
|
+ * @src: Where to copy the string from
|
|
+ */
|
|
+#undef strcpy
|
|
+char *strcpy(char *dest, const char *src)
|
|
+{
|
|
+ char *tmp = dest;
|
|
+
|
|
+ while ((*dest++ = *src++) != '\0')
|
|
+ /* nothing */;
|
|
+ return tmp;
|
|
+}
|
|
+EXPORT_SYMBOL(strcpy);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRNCPY
|
|
+/**
|
|
+ * strncpy - Copy a length-limited, %NUL-terminated string
|
|
+ * @dest: Where to copy the string to
|
|
+ * @src: Where to copy the string from
|
|
+ * @count: The maximum number of bytes to copy
|
|
+ *
|
|
+ * The result is not %NUL-terminated if the source exceeds
|
|
+ * @count bytes.
|
|
+ *
|
|
+ * In the case where the length of @src is less than that of
|
|
+ * count, the remainder of @dest will be padded with %NUL.
|
|
+ *
|
|
+ */
|
|
+char *strncpy(char *dest, const char *src, size_t count)
|
|
+{
|
|
+ char *tmp = dest;
|
|
+
|
|
+ while (count) {
|
|
+ if ((*tmp = *src) != 0)
|
|
+ src++;
|
|
+ tmp++;
|
|
+ count--;
|
|
+ }
|
|
+ return dest;
|
|
+}
|
|
+EXPORT_SYMBOL(strncpy);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRLCPY
|
|
+/**
|
|
+ * strlcpy - Copy a %NUL terminated string into a sized buffer
|
|
+ * @dest: Where to copy the string to
|
|
+ * @src: Where to copy the string from
|
|
+ * @size: size of destination buffer
|
|
+ *
|
|
+ * Compatible with *BSD: the result is always a valid
|
|
+ * NUL-terminated string that fits in the buffer (unless,
|
|
+ * of course, the buffer size is zero). It does not pad
|
|
+ * out the result like strncpy() does.
|
|
+ */
|
|
+size_t strlcpy(char *dest, const char *src, size_t size)
|
|
+{
|
|
+ size_t ret = strlen(src);
|
|
+
|
|
+ if (size) {
|
|
+ size_t len = (ret >= size) ? size - 1 : ret;
|
|
+ memcpy(dest, src, len);
|
|
+ dest[len] = '\0';
|
|
+ }
|
|
+ return ret;
|
|
+}
|
|
+EXPORT_SYMBOL(strlcpy);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRCAT
|
|
+/**
|
|
+ * strcat - Append one %NUL-terminated string to another
|
|
+ * @dest: The string to be appended to
|
|
+ * @src: The string to append to it
|
|
+ */
|
|
+#undef strcat
|
|
+char *strcat(char *dest, const char *src)
|
|
+{
|
|
+ char *tmp = dest;
|
|
+
|
|
+ while (*dest)
|
|
+ dest++;
|
|
+ while ((*dest++ = *src++) != '\0')
|
|
+ ;
|
|
+ return tmp;
|
|
+}
|
|
+EXPORT_SYMBOL(strcat);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRNCAT
|
|
+/**
|
|
+ * strncat - Append a length-limited, %NUL-terminated string to another
|
|
+ * @dest: The string to be appended to
|
|
+ * @src: The string to append to it
|
|
+ * @count: The maximum numbers of bytes to copy
|
|
+ *
|
|
+ * Note that in contrast to strncpy, strncat ensures the result is
|
|
+ * terminated.
|
|
+ */
|
|
+char *strncat(char *dest, const char *src, size_t count)
|
|
+{
|
|
+ char *tmp = dest;
|
|
+
|
|
+ if (count) {
|
|
+ while (*dest)
|
|
+ dest++;
|
|
+ while ((*dest++ = *src++) != 0) {
|
|
+ if (--count == 0) {
|
|
+ *dest = '\0';
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ return tmp;
|
|
+}
|
|
+EXPORT_SYMBOL(strncat);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRLCAT
|
|
+/**
|
|
+ * strlcat - Append a length-limited, %NUL-terminated string to another
|
|
+ * @dest: The string to be appended to
|
|
+ * @src: The string to append to it
|
|
+ * @count: The size of the destination buffer.
|
|
+ */
|
|
+size_t strlcat(char *dest, const char *src, size_t count)
|
|
+{
|
|
+ size_t dsize = strlen(dest);
|
|
+ size_t len = strlen(src);
|
|
+ size_t res = dsize + len;
|
|
+
|
|
+ /* This would be a bug */
|
|
+ BUG_ON(dsize >= count);
|
|
+
|
|
+ dest += dsize;
|
|
+ count -= dsize;
|
|
+ if (len >= count)
|
|
+ len = count-1;
|
|
+ memcpy(dest, src, len);
|
|
+ dest[len] = 0;
|
|
+ return res;
|
|
+}
|
|
+EXPORT_SYMBOL(strlcat);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRCMP
|
|
+/**
|
|
+ * strcmp - Compare two strings
|
|
+ * @cs: One string
|
|
+ * @ct: Another string
|
|
+ */
|
|
+#undef strcmp
|
|
+int strcmp(const char *cs, const char *ct)
|
|
+{
|
|
+ signed char __res;
|
|
+
|
|
+ while (1) {
|
|
+ if ((__res = *cs - *ct++) != 0 || !*cs++)
|
|
+ break;
|
|
+ }
|
|
+ return __res;
|
|
+}
|
|
+EXPORT_SYMBOL(strcmp);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRNCMP
|
|
+/**
|
|
+ * strncmp - Compare two length-limited strings
|
|
+ * @cs: One string
|
|
+ * @ct: Another string
|
|
+ * @count: The maximum number of bytes to compare
|
|
+ */
|
|
+int strncmp(const char *cs, const char *ct, size_t count)
|
|
+{
|
|
+ signed char __res = 0;
|
|
+
|
|
+ while (count) {
|
|
+ if ((__res = *cs - *ct++) != 0 || !*cs++)
|
|
+ break;
|
|
+ count--;
|
|
+ }
|
|
+ return __res;
|
|
+}
|
|
+EXPORT_SYMBOL(strncmp);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRCHR
|
|
+/**
|
|
+ * strchr - Find the first occurrence of a character in a string
|
|
+ * @s: The string to be searched
|
|
+ * @c: The character to search for
|
|
+ */
|
|
+char *strchr(const char *s, int c)
|
|
+{
|
|
+ for (; *s != (char)c; ++s)
|
|
+ if (*s == '\0')
|
|
+ return NULL;
|
|
+ return (char *)s;
|
|
+}
|
|
+EXPORT_SYMBOL(strchr);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRRCHR
|
|
+/**
|
|
+ * strrchr - Find the last occurrence of a character in a string
|
|
+ * @s: The string to be searched
|
|
+ * @c: The character to search for
|
|
+ */
|
|
+char *strrchr(const char *s, int c)
|
|
+{
|
|
+ const char *p = s + strlen(s);
|
|
+ do {
|
|
+ if (*p == (char)c)
|
|
+ return (char *)p;
|
|
+ } while (--p >= s);
|
|
+ return NULL;
|
|
+}
|
|
+EXPORT_SYMBOL(strrchr);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRNCHR
|
|
+/**
|
|
+ * strnchr - Find a character in a length limited string
|
|
+ * @s: The string to be searched
|
|
+ * @count: The number of characters to be searched
|
|
+ * @c: The character to search for
|
|
+ */
|
|
+char *strnchr(const char *s, size_t count, int c)
|
|
+{
|
|
+ for (; count-- && *s != '\0'; ++s)
|
|
+ if (*s == (char)c)
|
|
+ return (char *)s;
|
|
+ return NULL;
|
|
+}
|
|
+EXPORT_SYMBOL(strnchr);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRLEN
|
|
+/**
|
|
+ * strlen - Find the length of a string
|
|
+ * @s: The string to be sized
|
|
+ */
|
|
+size_t strlen(const char *s)
|
|
+{
|
|
+ const char *sc;
|
|
+
|
|
+ for (sc = s; *sc != '\0'; ++sc)
|
|
+ /* nothing */;
|
|
+ return sc - s;
|
|
+}
|
|
+EXPORT_SYMBOL(strlen);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRNLEN
|
|
+/**
|
|
+ * strnlen - Find the length of a length-limited string
|
|
+ * @s: The string to be sized
|
|
+ * @count: The maximum number of bytes to search
|
|
+ */
|
|
+size_t strnlen(const char *s, size_t count)
|
|
+{
|
|
+ const char *sc;
|
|
+
|
|
+ for (sc = s; count-- && *sc != '\0'; ++sc)
|
|
+ /* nothing */;
|
|
+ return sc - s;
|
|
+}
|
|
+EXPORT_SYMBOL(strnlen);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRSPN
|
|
+/**
|
|
+ * strspn - Calculate the length of the initial substring of @s which only
|
|
+ * contain letters in @accept
|
|
+ * @s: The string to be searched
|
|
+ * @accept: The string to search for
|
|
+ */
|
|
+size_t strspn(const char *s, const char *accept)
|
|
+{
|
|
+ const char *p;
|
|
+ const char *a;
|
|
+ size_t count = 0;
|
|
+
|
|
+ for (p = s; *p != '\0'; ++p) {
|
|
+ for (a = accept; *a != '\0'; ++a) {
|
|
+ if (*p == *a)
|
|
+ break;
|
|
+ }
|
|
+ if (*a == '\0')
|
|
+ return count;
|
|
+ ++count;
|
|
+ }
|
|
+ return count;
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(strspn);
|
|
+#endif
|
|
+
|
|
+/**
|
|
+ * strcspn - Calculate the length of the initial substring of @s which does
|
|
+ * not contain letters in @reject
|
|
+ * @s: The string to be searched
|
|
+ * @reject: The string to avoid
|
|
+ */
|
|
+size_t strcspn(const char *s, const char *reject)
|
|
+{
|
|
+ const char *p;
|
|
+ const char *r;
|
|
+ size_t count = 0;
|
|
+
|
|
+ for (p = s; *p != '\0'; ++p) {
|
|
+ for (r = reject; *r != '\0'; ++r) {
|
|
+ if (*p == *r)
|
|
+ return count;
|
|
+ }
|
|
+ ++count;
|
|
+ }
|
|
+ return count;
|
|
+}
|
|
+EXPORT_SYMBOL(strcspn);
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRPBRK
|
|
+/**
|
|
+ * strpbrk - Find the first occurrence of a set of characters
|
|
+ * @cs: The string to be searched
|
|
+ * @ct: The characters to search for
|
|
+ */
|
|
+char *strpbrk(const char *cs, const char *ct)
|
|
+{
|
|
+ const char *sc1, *sc2;
|
|
+
|
|
+ for (sc1 = cs; *sc1 != '\0'; ++sc1) {
|
|
+ for (sc2 = ct; *sc2 != '\0'; ++sc2) {
|
|
+ if (*sc1 == *sc2)
|
|
+ return (char *)sc1;
|
|
+ }
|
|
+ }
|
|
+ return NULL;
|
|
+}
|
|
+EXPORT_SYMBOL(strpbrk);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRSEP
|
|
+/**
|
|
+ * strsep - Split a string into tokens
|
|
+ * @s: The string to be searched
|
|
+ * @ct: The characters to search for
|
|
+ *
|
|
+ * strsep() updates @s to point after the token, ready for the next call.
|
|
+ *
|
|
+ * It returns empty tokens, too, behaving exactly like the libc function
|
|
+ * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
|
|
+ * Same semantics, slimmer shape. ;)
|
|
+ */
|
|
+char *strsep(char **s, const char *ct)
|
|
+{
|
|
+ char *sbegin = *s;
|
|
+ char *end;
|
|
+
|
|
+ if (sbegin == NULL)
|
|
+ return NULL;
|
|
+
|
|
+ end = strpbrk(sbegin, ct);
|
|
+ if (end)
|
|
+ *end++ = '\0';
|
|
+ *s = end;
|
|
+ return sbegin;
|
|
+}
|
|
+EXPORT_SYMBOL(strsep);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_MEMSET
|
|
+/**
|
|
+ * memset - Fill a region of memory with the given value
|
|
+ * @s: Pointer to the start of the area.
|
|
+ * @c: The byte to fill the area with
|
|
+ * @count: The size of the area.
|
|
+ *
|
|
+ * Do not use memset() to access IO space, use memset_io() instead.
|
|
+ */
|
|
+void *memset(void *s, int c, size_t count)
|
|
+{
|
|
+ char *xs = s;
|
|
+
|
|
+ while (count--)
|
|
+ *xs++ = c;
|
|
+ return s;
|
|
+}
|
|
+EXPORT_SYMBOL(memset);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_MEMCPY
|
|
+/**
|
|
+ * memcpy - Copy one area of memory to another
|
|
+ * @dest: Where to copy to
|
|
+ * @src: Where to copy from
|
|
+ * @count: The size of the area.
|
|
+ *
|
|
+ * You should not use this function to access IO space, use memcpy_toio()
|
|
+ * or memcpy_fromio() instead.
|
|
+ */
|
|
+void *memcpy(void *dest, const void *src, size_t count)
|
|
+{
|
|
+ char *tmp = dest;
|
|
+ const char *s = src;
|
|
+
|
|
+ while (count--)
|
|
+ *tmp++ = *s++;
|
|
+ return dest;
|
|
+}
|
|
+EXPORT_SYMBOL(memcpy);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_MEMMOVE
|
|
+/**
|
|
+ * memmove - Copy one area of memory to another
|
|
+ * @dest: Where to copy to
|
|
+ * @src: Where to copy from
|
|
+ * @count: The size of the area.
|
|
+ *
|
|
+ * Unlike memcpy(), memmove() copes with overlapping areas.
|
|
+ */
|
|
+void *memmove(void *dest, const void *src, size_t count)
|
|
+{
|
|
+ char *tmp;
|
|
+ const char *s;
|
|
+
|
|
+ if (dest <= src) {
|
|
+ tmp = dest;
|
|
+ s = src;
|
|
+ while (count--)
|
|
+ *tmp++ = *s++;
|
|
+ } else {
|
|
+ tmp = dest;
|
|
+ tmp += count;
|
|
+ s = src;
|
|
+ s += count;
|
|
+ while (count--)
|
|
+ *--tmp = *--s;
|
|
+ }
|
|
+ return dest;
|
|
+}
|
|
+EXPORT_SYMBOL(memmove);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_MEMCMP
|
|
+/**
|
|
+ * memcmp - Compare two areas of memory
|
|
+ * @cs: One area of memory
|
|
+ * @ct: Another area of memory
|
|
+ * @count: The size of the area.
|
|
+ */
|
|
+#undef memcmp
|
|
+int memcmp(const void *cs, const void *ct, size_t count)
|
|
+{
|
|
+ const unsigned char *su1, *su2;
|
|
+ int res = 0;
|
|
+
|
|
+ for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
|
|
+ if ((res = *su1 - *su2) != 0)
|
|
+ break;
|
|
+ return res;
|
|
+}
|
|
+EXPORT_SYMBOL(memcmp);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_MEMSCAN
|
|
+/**
|
|
+ * memscan - Find a character in an area of memory.
|
|
+ * @addr: The memory area
|
|
+ * @c: The byte to search for
|
|
+ * @size: The size of the area.
|
|
+ *
|
|
+ * returns the address of the first occurrence of @c, or 1 byte past
|
|
+ * the area if @c is not found
|
|
+ */
|
|
+void *memscan(void *addr, int c, size_t size)
|
|
+{
|
|
+ unsigned char *p = addr;
|
|
+
|
|
+ while (size) {
|
|
+ if (*p == c)
|
|
+ return (void *)p;
|
|
+ p++;
|
|
+ size--;
|
|
+ }
|
|
+ return (void *)p;
|
|
+}
|
|
+EXPORT_SYMBOL(memscan);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_STRSTR
|
|
+/**
|
|
+ * strstr - Find the first substring in a %NUL terminated string
|
|
+ * @s1: The string to be searched
|
|
+ * @s2: The string to search for
|
|
+ */
|
|
+char *strstr(const char *s1, const char *s2)
|
|
+{
|
|
+ int l1, l2;
|
|
+
|
|
+ l2 = strlen(s2);
|
|
+ if (!l2)
|
|
+ return (char *)s1;
|
|
+ l1 = strlen(s1);
|
|
+ while (l1 >= l2) {
|
|
+ l1--;
|
|
+ if (!memcmp(s1, s2, l2))
|
|
+ return (char *)s1;
|
|
+ s1++;
|
|
+ }
|
|
+ return NULL;
|
|
+}
|
|
+EXPORT_SYMBOL(strstr);
|
|
+#endif
|
|
+
|
|
+#ifndef __HAVE_ARCH_MEMCHR
|
|
+/**
|
|
+ * memchr - Find a character in an area of memory.
|
|
+ * @s: The memory area
|
|
+ * @c: The byte to search for
|
|
+ * @n: The size of the area.
|
|
+ *
|
|
+ * returns the address of the first occurrence of @c, or %NULL
|
|
+ * if @c is not found
|
|
+ */
|
|
+void *memchr(const void *s, int c, size_t n)
|
|
+{
|
|
+ const unsigned char *p = s;
|
|
+ while (n-- != 0) {
|
|
+ if ((unsigned char)c == *p++) {
|
|
+ return (void *)(p - 1);
|
|
+ }
|
|
+ }
|
|
+ return NULL;
|
|
+}
|
|
+EXPORT_SYMBOL(memchr);
|
|
+#endif
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/vsprintf.c
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/vsprintf.c
|
|
@@ -0,0 +1,842 @@
|
|
+/*
|
|
+ * linux/lib/vsprintf.c
|
|
+ *
|
|
+ * Copyright (C) 1991, 1992 Linus Torvalds
|
|
+ */
|
|
+
|
|
+/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
|
|
+/*
|
|
+ * Wirzenius wrote this portably, Torvalds fucked it up :-)
|
|
+ */
|
|
+
|
|
+/*
|
|
+ * Fri Jul 13 2001 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
|
|
+ * - changed to provide snprintf and vsnprintf functions
|
|
+ * So Feb 1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de>
|
|
+ * - scnprintf and vscnprintf
|
|
+ */
|
|
+
|
|
+#include "helper.h"
|
|
+
|
|
+/**
|
|
+ * simple_strtoul - convert a string to an unsigned long
|
|
+ * @cp: The start of the string
|
|
+ * @endp: A pointer to the end of the parsed string will be placed here
|
|
+ * @base: The number base to use
|
|
+ */
|
|
+unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base)
|
|
+{
|
|
+ unsigned long result = 0,value;
|
|
+
|
|
+ if (!base) {
|
|
+ base = 10;
|
|
+ if (*cp == '0') {
|
|
+ base = 8;
|
|
+ cp++;
|
|
+ if ((toupper(*cp) == 'X') && isxdigit(cp[1])) {
|
|
+ cp++;
|
|
+ base = 16;
|
|
+ }
|
|
+ }
|
|
+ } else if (base == 16) {
|
|
+ if (cp[0] == '0' && toupper(cp[1]) == 'X')
|
|
+ cp += 2;
|
|
+ }
|
|
+ while (isxdigit(*cp) &&
|
|
+ (value = isdigit(*cp) ? *cp-'0' : toupper(*cp)-'A'+10) < base) {
|
|
+ result = result*base + value;
|
|
+ cp++;
|
|
+ }
|
|
+ if (endp)
|
|
+ *endp = (char *)cp;
|
|
+ return result;
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(simple_strtoul);
|
|
+
|
|
+/**
|
|
+ * simple_strtol - convert a string to a signed long
|
|
+ * @cp: The start of the string
|
|
+ * @endp: A pointer to the end of the parsed string will be placed here
|
|
+ * @base: The number base to use
|
|
+ */
|
|
+long simple_strtol(const char *cp,char **endp,unsigned int base)
|
|
+{
|
|
+ if(*cp=='-')
|
|
+ return -simple_strtoul(cp+1,endp,base);
|
|
+ return simple_strtoul(cp,endp,base);
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(simple_strtol);
|
|
+
|
|
+/**
|
|
+ * simple_strtoull - convert a string to an unsigned long long
|
|
+ * @cp: The start of the string
|
|
+ * @endp: A pointer to the end of the parsed string will be placed here
|
|
+ * @base: The number base to use
|
|
+ */
|
|
+unsigned long long simple_strtoull(const char *cp,char **endp,unsigned int base)
|
|
+{
|
|
+ unsigned long long result = 0,value;
|
|
+
|
|
+ if (!base) {
|
|
+ base = 10;
|
|
+ if (*cp == '0') {
|
|
+ base = 8;
|
|
+ cp++;
|
|
+ if ((toupper(*cp) == 'X') && isxdigit(cp[1])) {
|
|
+ cp++;
|
|
+ base = 16;
|
|
+ }
|
|
+ }
|
|
+ } else if (base == 16) {
|
|
+ if (cp[0] == '0' && toupper(cp[1]) == 'X')
|
|
+ cp += 2;
|
|
+ }
|
|
+ while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
|
|
+ ? toupper(*cp) : *cp)-'A'+10) < base) {
|
|
+ result = result*base + value;
|
|
+ cp++;
|
|
+ }
|
|
+ if (endp)
|
|
+ *endp = (char *)cp;
|
|
+ return result;
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(simple_strtoull);
|
|
+
|
|
+/**
|
|
+ * simple_strtoll - convert a string to a signed long long
|
|
+ * @cp: The start of the string
|
|
+ * @endp: A pointer to the end of the parsed string will be placed here
|
|
+ * @base: The number base to use
|
|
+ */
|
|
+long long simple_strtoll(const char *cp,char **endp,unsigned int base)
|
|
+{
|
|
+ if(*cp=='-')
|
|
+ return -simple_strtoull(cp+1,endp,base);
|
|
+ return simple_strtoull(cp,endp,base);
|
|
+}
|
|
+
|
|
+static int skip_atoi(const char **s)
|
|
+{
|
|
+ int i=0;
|
|
+
|
|
+ while (isdigit(**s))
|
|
+ i = i*10 + *((*s)++) - '0';
|
|
+ return i;
|
|
+}
|
|
+
|
|
+#define ZEROPAD 1 /* pad with zero */
|
|
+#define SIGN 2 /* unsigned/signed long */
|
|
+#define PLUS 4 /* show plus */
|
|
+#define SPACE 8 /* space if plus */
|
|
+#define LEFT 16 /* left justified */
|
|
+#define SPECIAL 32 /* 0x */
|
|
+#define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
|
|
+
|
|
+static char * number(char * buf, char * end, unsigned long long num, int base, int size, int precision, int type)
|
|
+{
|
|
+ char c,sign,tmp[66];
|
|
+ const char *digits;
|
|
+ static const char small_digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
|
|
+ static const char large_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
+ int i;
|
|
+
|
|
+ digits = (type & LARGE) ? large_digits : small_digits;
|
|
+ if (type & LEFT)
|
|
+ type &= ~ZEROPAD;
|
|
+ if (base < 2 || base > 36)
|
|
+ return NULL;
|
|
+ c = (type & ZEROPAD) ? '0' : ' ';
|
|
+ sign = 0;
|
|
+ if (type & SIGN) {
|
|
+ if ((signed long long) num < 0) {
|
|
+ sign = '-';
|
|
+ num = - (signed long long) num;
|
|
+ size--;
|
|
+ } else if (type & PLUS) {
|
|
+ sign = '+';
|
|
+ size--;
|
|
+ } else if (type & SPACE) {
|
|
+ sign = ' ';
|
|
+ size--;
|
|
+ }
|
|
+ }
|
|
+ if (type & SPECIAL) {
|
|
+ if (base == 16)
|
|
+ size -= 2;
|
|
+ else if (base == 8)
|
|
+ size--;
|
|
+ }
|
|
+ i = 0;
|
|
+ if (num == 0)
|
|
+ tmp[i++]='0';
|
|
+ else while (num != 0)
|
|
+ tmp[i++] = digits[do_div(num,base)];
|
|
+ if (i > precision)
|
|
+ precision = i;
|
|
+ size -= precision;
|
|
+ if (!(type&(ZEROPAD+LEFT))) {
|
|
+ while(size-->0) {
|
|
+ if (buf <= end)
|
|
+ *buf = ' ';
|
|
+ ++buf;
|
|
+ }
|
|
+ }
|
|
+ if (sign) {
|
|
+ if (buf <= end)
|
|
+ *buf = sign;
|
|
+ ++buf;
|
|
+ }
|
|
+ if (type & SPECIAL) {
|
|
+ if (base==8) {
|
|
+ if (buf <= end)
|
|
+ *buf = '0';
|
|
+ ++buf;
|
|
+ } else if (base==16) {
|
|
+ if (buf <= end)
|
|
+ *buf = '0';
|
|
+ ++buf;
|
|
+ if (buf <= end)
|
|
+ *buf = digits[33];
|
|
+ ++buf;
|
|
+ }
|
|
+ }
|
|
+ if (!(type & LEFT)) {
|
|
+ while (size-- > 0) {
|
|
+ if (buf <= end)
|
|
+ *buf = c;
|
|
+ ++buf;
|
|
+ }
|
|
+ }
|
|
+ while (i < precision--) {
|
|
+ if (buf <= end)
|
|
+ *buf = '0';
|
|
+ ++buf;
|
|
+ }
|
|
+ while (i-- > 0) {
|
|
+ if (buf <= end)
|
|
+ *buf = tmp[i];
|
|
+ ++buf;
|
|
+ }
|
|
+ while (size-- > 0) {
|
|
+ if (buf <= end)
|
|
+ *buf = ' ';
|
|
+ ++buf;
|
|
+ }
|
|
+ return buf;
|
|
+}
|
|
+
|
|
+/**
|
|
+ * vsnprintf - Format a string and place it in a buffer
|
|
+ * @buf: The buffer to place the result into
|
|
+ * @size: The size of the buffer, including the trailing null space
|
|
+ * @fmt: The format string to use
|
|
+ * @args: Arguments for the format string
|
|
+ *
|
|
+ * The return value is the number of characters which would
|
|
+ * be generated for the given input, excluding the trailing
|
|
+ * '\0', as per ISO C99. If you want to have the exact
|
|
+ * number of characters written into @buf as return value
|
|
+ * (not including the trailing '\0'), use vscnprintf. If the
|
|
+ * return is greater than or equal to @size, the resulting
|
|
+ * string is truncated.
|
|
+ *
|
|
+ * Call this function if you are already dealing with a va_list.
|
|
+ * You probably want snprintf instead.
|
|
+ */
|
|
+int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
|
|
+{
|
|
+ int len;
|
|
+ unsigned long long num;
|
|
+ int i, base;
|
|
+ char *str, *end, c;
|
|
+ const char *s;
|
|
+
|
|
+ int flags; /* flags to number() */
|
|
+
|
|
+ int field_width; /* width of output field */
|
|
+ int precision; /* min. # of digits for integers; max
|
|
+ number of chars for from string */
|
|
+ int qualifier; /* 'h', 'l', or 'L' for integer fields */
|
|
+ /* 'z' support added 23/7/1999 S.H. */
|
|
+ /* 'z' changed to 'Z' --davidm 1/25/99 */
|
|
+ /* 't' added for ptrdiff_t */
|
|
+
|
|
+ /* Reject out-of-range values early */
|
|
+ if (unlikely((int) size < 0)) {
|
|
+ /* There can be only one.. */
|
|
+ static int warn = 1;
|
|
+ WARN_ON(warn);
|
|
+ warn = 0;
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ str = buf;
|
|
+ end = buf + size - 1;
|
|
+
|
|
+ if (end < buf - 1) {
|
|
+ end = ((void *) -1);
|
|
+ size = end - buf + 1;
|
|
+ }
|
|
+
|
|
+ for (; *fmt ; ++fmt) {
|
|
+ if (*fmt != '%') {
|
|
+ if (str <= end)
|
|
+ *str = *fmt;
|
|
+ ++str;
|
|
+ continue;
|
|
+ }
|
|
+
|
|
+ /* process flags */
|
|
+ flags = 0;
|
|
+ repeat:
|
|
+ ++fmt; /* this also skips first '%' */
|
|
+ switch (*fmt) {
|
|
+ case '-': flags |= LEFT; goto repeat;
|
|
+ case '+': flags |= PLUS; goto repeat;
|
|
+ case ' ': flags |= SPACE; goto repeat;
|
|
+ case '#': flags |= SPECIAL; goto repeat;
|
|
+ case '0': flags |= ZEROPAD; goto repeat;
|
|
+ }
|
|
+
|
|
+ /* get field width */
|
|
+ field_width = -1;
|
|
+ if (isdigit(*fmt))
|
|
+ field_width = skip_atoi(&fmt);
|
|
+ else if (*fmt == '*') {
|
|
+ ++fmt;
|
|
+ /* it's the next argument */
|
|
+ field_width = va_arg(args, int);
|
|
+ if (field_width < 0) {
|
|
+ field_width = -field_width;
|
|
+ flags |= LEFT;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /* get the precision */
|
|
+ precision = -1;
|
|
+ if (*fmt == '.') {
|
|
+ ++fmt;
|
|
+ if (isdigit(*fmt))
|
|
+ precision = skip_atoi(&fmt);
|
|
+ else if (*fmt == '*') {
|
|
+ ++fmt;
|
|
+ /* it's the next argument */
|
|
+ precision = va_arg(args, int);
|
|
+ }
|
|
+ if (precision < 0)
|
|
+ precision = 0;
|
|
+ }
|
|
+
|
|
+ /* get the conversion qualifier */
|
|
+ qualifier = -1;
|
|
+ if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
|
|
+ *fmt =='Z' || *fmt == 'z' || *fmt == 't') {
|
|
+ qualifier = *fmt;
|
|
+ ++fmt;
|
|
+ if (qualifier == 'l' && *fmt == 'l') {
|
|
+ qualifier = 'L';
|
|
+ ++fmt;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /* default base */
|
|
+ base = 10;
|
|
+
|
|
+ switch (*fmt) {
|
|
+ case 'c':
|
|
+ if (!(flags & LEFT)) {
|
|
+ while (--field_width > 0) {
|
|
+ if (str <= end)
|
|
+ *str = ' ';
|
|
+ ++str;
|
|
+ }
|
|
+ }
|
|
+ c = (unsigned char) va_arg(args, int);
|
|
+ if (str <= end)
|
|
+ *str = c;
|
|
+ ++str;
|
|
+ while (--field_width > 0) {
|
|
+ if (str <= end)
|
|
+ *str = ' ';
|
|
+ ++str;
|
|
+ }
|
|
+ continue;
|
|
+
|
|
+ case 's':
|
|
+ s = va_arg(args, char *);
|
|
+ if ((unsigned long)s < PAGE_SIZE)
|
|
+ s = "<NULL>";
|
|
+
|
|
+ len = strnlen(s, precision);
|
|
+
|
|
+ if (!(flags & LEFT)) {
|
|
+ while (len < field_width--) {
|
|
+ if (str <= end)
|
|
+ *str = ' ';
|
|
+ ++str;
|
|
+ }
|
|
+ }
|
|
+ for (i = 0; i < len; ++i) {
|
|
+ if (str <= end)
|
|
+ *str = *s;
|
|
+ ++str; ++s;
|
|
+ }
|
|
+ while (len < field_width--) {
|
|
+ if (str <= end)
|
|
+ *str = ' ';
|
|
+ ++str;
|
|
+ }
|
|
+ continue;
|
|
+
|
|
+ case 'p':
|
|
+ if (field_width == -1) {
|
|
+ field_width = 2*sizeof(void *);
|
|
+ flags |= ZEROPAD;
|
|
+ }
|
|
+ str = number(str, end,
|
|
+ (unsigned long) va_arg(args, void *),
|
|
+ 16, field_width, precision, flags);
|
|
+ continue;
|
|
+
|
|
+
|
|
+ case 'n':
|
|
+ /* FIXME:
|
|
+ * What does C99 say about the overflow case here? */
|
|
+ if (qualifier == 'l') {
|
|
+ long * ip = va_arg(args, long *);
|
|
+ *ip = (str - buf);
|
|
+ } else if (qualifier == 'Z' || qualifier == 'z') {
|
|
+ size_t * ip = va_arg(args, size_t *);
|
|
+ *ip = (str - buf);
|
|
+ } else {
|
|
+ int * ip = va_arg(args, int *);
|
|
+ *ip = (str - buf);
|
|
+ }
|
|
+ continue;
|
|
+
|
|
+ case '%':
|
|
+ if (str <= end)
|
|
+ *str = '%';
|
|
+ ++str;
|
|
+ continue;
|
|
+
|
|
+ /* integer number formats - set up the flags and "break" */
|
|
+ case 'o':
|
|
+ base = 8;
|
|
+ break;
|
|
+
|
|
+ case 'X':
|
|
+ flags |= LARGE;
|
|
+ case 'x':
|
|
+ base = 16;
|
|
+ break;
|
|
+
|
|
+ case 'd':
|
|
+ case 'i':
|
|
+ flags |= SIGN;
|
|
+ case 'u':
|
|
+ break;
|
|
+
|
|
+ default:
|
|
+ if (str <= end)
|
|
+ *str = '%';
|
|
+ ++str;
|
|
+ if (*fmt) {
|
|
+ if (str <= end)
|
|
+ *str = *fmt;
|
|
+ ++str;
|
|
+ } else {
|
|
+ --fmt;
|
|
+ }
|
|
+ continue;
|
|
+ }
|
|
+ if (qualifier == 'L')
|
|
+ num = va_arg(args, long long);
|
|
+ else if (qualifier == 'l') {
|
|
+ num = va_arg(args, unsigned long);
|
|
+ if (flags & SIGN)
|
|
+ num = (signed long) num;
|
|
+ } else if (qualifier == 'Z' || qualifier == 'z') {
|
|
+ num = va_arg(args, size_t);
|
|
+ } else if (qualifier == 't') {
|
|
+ num = va_arg(args, ptrdiff_t);
|
|
+ } else if (qualifier == 'h') {
|
|
+ num = (unsigned short) va_arg(args, int);
|
|
+ if (flags & SIGN)
|
|
+ num = (signed short) num;
|
|
+ } else {
|
|
+ num = va_arg(args, unsigned int);
|
|
+ if (flags & SIGN)
|
|
+ num = (signed int) num;
|
|
+ }
|
|
+ str = number(str, end, num, base,
|
|
+ field_width, precision, flags);
|
|
+ }
|
|
+ if (str <= end)
|
|
+ *str = '\0';
|
|
+ else if (size > 0)
|
|
+ /* don't write out a null byte if the buf size is zero */
|
|
+ *end = '\0';
|
|
+ /* the trailing null byte doesn't count towards the total
|
|
+ * ++str;
|
|
+ */
|
|
+ return str-buf;
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(vsnprintf);
|
|
+
|
|
+/**
|
|
+ * vscnprintf - Format a string and place it in a buffer
|
|
+ * @buf: The buffer to place the result into
|
|
+ * @size: The size of the buffer, including the trailing null space
|
|
+ * @fmt: The format string to use
|
|
+ * @args: Arguments for the format string
|
|
+ *
|
|
+ * The return value is the number of characters which have been written into
|
|
+ * the @buf not including the trailing '\0'. If @size is <= 0 the function
|
|
+ * returns 0.
|
|
+ *
|
|
+ * Call this function if you are already dealing with a va_list.
|
|
+ * You probably want scnprintf instead.
|
|
+ */
|
|
+int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
|
|
+{
|
|
+ int i;
|
|
+
|
|
+ i=vsnprintf(buf,size,fmt,args);
|
|
+ return (i >= size) ? (size - 1) : i;
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(vscnprintf);
|
|
+
|
|
+/**
|
|
+ * snprintf - Format a string and place it in a buffer
|
|
+ * @buf: The buffer to place the result into
|
|
+ * @size: The size of the buffer, including the trailing null space
|
|
+ * @fmt: The format string to use
|
|
+ * @...: Arguments for the format string
|
|
+ *
|
|
+ * The return value is the number of characters which would be
|
|
+ * generated for the given input, excluding the trailing null,
|
|
+ * as per ISO C99. If the return is greater than or equal to
|
|
+ * @size, the resulting string is truncated.
|
|
+ */
|
|
+int snprintf(char * buf, size_t size, const char *fmt, ...)
|
|
+{
|
|
+ va_list args;
|
|
+ int i;
|
|
+
|
|
+ va_start(args, fmt);
|
|
+ i=vsnprintf(buf,size,fmt,args);
|
|
+ va_end(args);
|
|
+ return i;
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(snprintf);
|
|
+
|
|
+/**
|
|
+ * scnprintf - Format a string and place it in a buffer
|
|
+ * @buf: The buffer to place the result into
|
|
+ * @size: The size of the buffer, including the trailing null space
|
|
+ * @fmt: The format string to use
|
|
+ * @...: Arguments for the format string
|
|
+ *
|
|
+ * The return value is the number of characters written into @buf not including
|
|
+ * the trailing '\0'. If @size is <= 0 the function returns 0. If the return is
|
|
+ * greater than or equal to @size, the resulting string is truncated.
|
|
+ */
|
|
+
|
|
+int scnprintf(char * buf, size_t size, const char *fmt, ...)
|
|
+{
|
|
+ va_list args;
|
|
+ int i;
|
|
+
|
|
+ va_start(args, fmt);
|
|
+ i = vsnprintf(buf, size, fmt, args);
|
|
+ va_end(args);
|
|
+ return (i >= size) ? (size - 1) : i;
|
|
+}
|
|
+EXPORT_SYMBOL(scnprintf);
|
|
+
|
|
+/**
|
|
+ * vsprintf - Format a string and place it in a buffer
|
|
+ * @buf: The buffer to place the result into
|
|
+ * @fmt: The format string to use
|
|
+ * @args: Arguments for the format string
|
|
+ *
|
|
+ * The function returns the number of characters written
|
|
+ * into @buf. Use vsnprintf or vscnprintf in order to avoid
|
|
+ * buffer overflows.
|
|
+ *
|
|
+ * Call this function if you are already dealing with a va_list.
|
|
+ * You probably want sprintf instead.
|
|
+ */
|
|
+int vsprintf(char *buf, const char *fmt, va_list args)
|
|
+{
|
|
+ return vsnprintf(buf, INT_MAX, fmt, args);
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(vsprintf);
|
|
+
|
|
+/**
|
|
+ * sprintf - Format a string and place it in a buffer
|
|
+ * @buf: The buffer to place the result into
|
|
+ * @fmt: The format string to use
|
|
+ * @...: Arguments for the format string
|
|
+ *
|
|
+ * The function returns the number of characters written
|
|
+ * into @buf. Use snprintf or scnprintf in order to avoid
|
|
+ * buffer overflows.
|
|
+ */
|
|
+int sprintf(char * buf, const char *fmt, ...)
|
|
+{
|
|
+ va_list args;
|
|
+ int i;
|
|
+
|
|
+ va_start(args, fmt);
|
|
+ i=vsnprintf(buf, INT_MAX, fmt, args);
|
|
+ va_end(args);
|
|
+ return i;
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(sprintf);
|
|
+
|
|
+/**
|
|
+ * vsscanf - Unformat a buffer into a list of arguments
|
|
+ * @buf: input buffer
|
|
+ * @fmt: format of buffer
|
|
+ * @args: arguments
|
|
+ */
|
|
+int vsscanf(const char * buf, const char * fmt, va_list args)
|
|
+{
|
|
+ const char *str = buf;
|
|
+ char *next;
|
|
+ char digit;
|
|
+ int num = 0;
|
|
+ int qualifier;
|
|
+ int base;
|
|
+ int field_width;
|
|
+ int is_sign = 0;
|
|
+
|
|
+ while(*fmt && *str) {
|
|
+ /* skip any white space in format */
|
|
+ /* white space in format matchs any amount of
|
|
+ * white space, including none, in the input.
|
|
+ */
|
|
+ if (isspace(*fmt)) {
|
|
+ while (isspace(*fmt))
|
|
+ ++fmt;
|
|
+ while (isspace(*str))
|
|
+ ++str;
|
|
+ }
|
|
+
|
|
+ /* anything that is not a conversion must match exactly */
|
|
+ if (*fmt != '%' && *fmt) {
|
|
+ if (*fmt++ != *str++)
|
|
+ break;
|
|
+ continue;
|
|
+ }
|
|
+
|
|
+ if (!*fmt)
|
|
+ break;
|
|
+ ++fmt;
|
|
+
|
|
+ /* skip this conversion.
|
|
+ * advance both strings to next white space
|
|
+ */
|
|
+ if (*fmt == '*') {
|
|
+ while (!isspace(*fmt) && *fmt)
|
|
+ fmt++;
|
|
+ while (!isspace(*str) && *str)
|
|
+ str++;
|
|
+ continue;
|
|
+ }
|
|
+
|
|
+ /* get field width */
|
|
+ field_width = -1;
|
|
+ if (isdigit(*fmt))
|
|
+ field_width = skip_atoi(&fmt);
|
|
+
|
|
+ /* get conversion qualifier */
|
|
+ qualifier = -1;
|
|
+ if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
|
|
+ *fmt == 'Z' || *fmt == 'z') {
|
|
+ qualifier = *fmt++;
|
|
+ if (unlikely(qualifier == *fmt)) {
|
|
+ if (qualifier == 'h') {
|
|
+ qualifier = 'H';
|
|
+ fmt++;
|
|
+ } else if (qualifier == 'l') {
|
|
+ qualifier = 'L';
|
|
+ fmt++;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ base = 10;
|
|
+ is_sign = 0;
|
|
+
|
|
+ if (!*fmt || !*str)
|
|
+ break;
|
|
+
|
|
+ switch(*fmt++) {
|
|
+ case 'c':
|
|
+ {
|
|
+ char *s = (char *) va_arg(args,char*);
|
|
+ if (field_width == -1)
|
|
+ field_width = 1;
|
|
+ do {
|
|
+ *s++ = *str++;
|
|
+ } while (--field_width > 0 && *str);
|
|
+ num++;
|
|
+ }
|
|
+ continue;
|
|
+ case 's':
|
|
+ {
|
|
+ char *s = (char *) va_arg(args, char *);
|
|
+ if(field_width == -1)
|
|
+ field_width = INT_MAX;
|
|
+ /* first, skip leading white space in buffer */
|
|
+ while (isspace(*str))
|
|
+ str++;
|
|
+
|
|
+ /* now copy until next white space */
|
|
+ while (*str && !isspace(*str) && field_width--) {
|
|
+ *s++ = *str++;
|
|
+ }
|
|
+ *s = '\0';
|
|
+ num++;
|
|
+ }
|
|
+ continue;
|
|
+ case 'n':
|
|
+ /* return number of characters read so far */
|
|
+ {
|
|
+ int *i = (int *)va_arg(args,int*);
|
|
+ *i = str - buf;
|
|
+ }
|
|
+ continue;
|
|
+ case 'o':
|
|
+ base = 8;
|
|
+ break;
|
|
+ case 'x':
|
|
+ case 'X':
|
|
+ base = 16;
|
|
+ break;
|
|
+ case 'i':
|
|
+ base = 0;
|
|
+ case 'd':
|
|
+ is_sign = 1;
|
|
+ case 'u':
|
|
+ break;
|
|
+ case '%':
|
|
+ /* looking for '%' in str */
|
|
+ if (*str++ != '%')
|
|
+ return num;
|
|
+ continue;
|
|
+ default:
|
|
+ /* invalid format; stop here */
|
|
+ return num;
|
|
+ }
|
|
+
|
|
+ /* have some sort of integer conversion.
|
|
+ * first, skip white space in buffer.
|
|
+ */
|
|
+ while (isspace(*str))
|
|
+ str++;
|
|
+
|
|
+ digit = *str;
|
|
+ if (is_sign && digit == '-')
|
|
+ digit = *(str + 1);
|
|
+
|
|
+ if (!digit
|
|
+ || (base == 16 && !isxdigit(digit))
|
|
+ || (base == 10 && !isdigit(digit))
|
|
+ || (base == 8 && (!isdigit(digit) || digit > '7'))
|
|
+ || (base == 0 && !isdigit(digit)))
|
|
+ break;
|
|
+
|
|
+ switch(qualifier) {
|
|
+ case 'H': /* that's 'hh' in format */
|
|
+ if (is_sign) {
|
|
+ signed char *s = (signed char *) va_arg(args,signed char *);
|
|
+ *s = (signed char) simple_strtol(str,&next,base);
|
|
+ } else {
|
|
+ unsigned char *s = (unsigned char *) va_arg(args, unsigned char *);
|
|
+ *s = (unsigned char) simple_strtoul(str, &next, base);
|
|
+ }
|
|
+ break;
|
|
+ case 'h':
|
|
+ if (is_sign) {
|
|
+ short *s = (short *) va_arg(args,short *);
|
|
+ *s = (short) simple_strtol(str,&next,base);
|
|
+ } else {
|
|
+ unsigned short *s = (unsigned short *) va_arg(args, unsigned short *);
|
|
+ *s = (unsigned short) simple_strtoul(str, &next, base);
|
|
+ }
|
|
+ break;
|
|
+ case 'l':
|
|
+ if (is_sign) {
|
|
+ long *l = (long *) va_arg(args,long *);
|
|
+ *l = simple_strtol(str,&next,base);
|
|
+ } else {
|
|
+ unsigned long *l = (unsigned long*) va_arg(args,unsigned long*);
|
|
+ *l = simple_strtoul(str,&next,base);
|
|
+ }
|
|
+ break;
|
|
+ case 'L':
|
|
+ if (is_sign) {
|
|
+ long long *l = (long long*) va_arg(args,long long *);
|
|
+ *l = simple_strtoll(str,&next,base);
|
|
+ } else {
|
|
+ unsigned long long *l = (unsigned long long*) va_arg(args,unsigned long long*);
|
|
+ *l = simple_strtoull(str,&next,base);
|
|
+ }
|
|
+ break;
|
|
+ case 'Z':
|
|
+ case 'z':
|
|
+ {
|
|
+ size_t *s = (size_t*) va_arg(args,size_t*);
|
|
+ *s = (size_t) simple_strtoul(str,&next,base);
|
|
+ }
|
|
+ break;
|
|
+ default:
|
|
+ if (is_sign) {
|
|
+ int *i = (int *) va_arg(args, int*);
|
|
+ *i = (int) simple_strtol(str,&next,base);
|
|
+ } else {
|
|
+ unsigned int *i = (unsigned int*) va_arg(args, unsigned int*);
|
|
+ *i = (unsigned int) simple_strtoul(str,&next,base);
|
|
+ }
|
|
+ break;
|
|
+ }
|
|
+ num++;
|
|
+
|
|
+ if (!next)
|
|
+ break;
|
|
+ str = next;
|
|
+ }
|
|
+ return num;
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(vsscanf);
|
|
+
|
|
+/**
|
|
+ * sscanf - Unformat a buffer into a list of arguments
|
|
+ * @buf: input buffer
|
|
+ * @fmt: formatting of buffer
|
|
+ * @...: resulting arguments
|
|
+ */
|
|
+int sscanf(const char * buf, const char * fmt, ...)
|
|
+{
|
|
+ va_list args;
|
|
+ int i;
|
|
+
|
|
+ va_start(args,fmt);
|
|
+ i = vsscanf(buf,fmt,args);
|
|
+ va_end(args);
|
|
+ return i;
|
|
+}
|
|
+
|
|
+EXPORT_SYMBOL(sscanf);
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/x86_32/div64.h
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/x86_32/div64.h
|
|
@@ -0,0 +1,48 @@
|
|
+#ifndef __I386_DIV64
|
|
+#define __I386_DIV64
|
|
+
|
|
+/*
|
|
+ * do_div() is NOT a C function. It wants to return
|
|
+ * two values (the quotient and the remainder), but
|
|
+ * since that doesn't work very well in C, what it
|
|
+ * does is:
|
|
+ *
|
|
+ * - modifies the 64-bit dividend _in_place_
|
|
+ * - returns the 32-bit remainder
|
|
+ *
|
|
+ * This ends up being the most efficient "calling
|
|
+ * convention" on x86.
|
|
+ */
|
|
+#define do_div(n,base) ({ \
|
|
+ unsigned long __upper, __low, __high, __mod, __base; \
|
|
+ __base = (base); \
|
|
+ asm("":"=a" (__low), "=d" (__high):"A" (n)); \
|
|
+ __upper = __high; \
|
|
+ if (__high) { \
|
|
+ __upper = __high % (__base); \
|
|
+ __high = __high / (__base); \
|
|
+ } \
|
|
+ asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (__base), "0" (__low), "1" (__upper)); \
|
|
+ asm("":"=A" (n):"a" (__low),"d" (__high)); \
|
|
+ __mod; \
|
|
+})
|
|
+
|
|
+/*
|
|
+ * (long)X = ((long long)divs) / (long)div
|
|
+ * (long)rem = ((long long)divs) % (long)div
|
|
+ *
|
|
+ * Warning, this will do an exception if X overflows.
|
|
+ */
|
|
+#define div_long_long_rem(a,b,c) div_ll_X_l_rem(a,b,c)
|
|
+
|
|
+static inline long
|
|
+div_ll_X_l_rem(long long divs, long div, long *rem)
|
|
+{
|
|
+ long dum2;
|
|
+ __asm__("divl %2":"=a"(dum2), "=d"(*rem)
|
|
+ : "rm"(div), "A"(divs));
|
|
+
|
|
+ return dum2;
|
|
+
|
|
+}
|
|
+#endif
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/x86_32/entry.S
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/x86_32/entry.S
|
|
@@ -0,0 +1,49 @@
|
|
+#include "offsets.h"
|
|
+
|
|
+/* --- stack -------------------------------------------------------- */
|
|
+
|
|
+ .data
|
|
+stack_bottom:
|
|
+ .fill 4096,1,0
|
|
+stack_top:
|
|
+
|
|
+/* --- text --------------------------------------------------------- */
|
|
+
|
|
+ .text
|
|
+ .globl _start,_start_kernel,BUG,hypercall_page
|
|
+
|
|
+_start:
|
|
+ movl %esi, old_info
|
|
+ lea stack_top,%esp
|
|
+ jmp start_helper
|
|
+
|
|
+_start_kernel:
|
|
+ movl vcpu+vcpu_ebx,%ebx /* load registers */
|
|
+ movl vcpu+vcpu_ecx,%ecx
|
|
+ movl vcpu+vcpu_edx,%edx
|
|
+ movl vcpu+vcpu_esi,%esi
|
|
+ movl vcpu+vcpu_edi,%edi
|
|
+ movl vcpu+vcpu_ebp,%ebp
|
|
+ movl vcpu+vcpu_esp,%esp /* using new kernels boot stack now */
|
|
+
|
|
+ movl vcpu+vcpu_eip,%eax /* push entry point */
|
|
+ push %eax
|
|
+ movl vcpu+vcpu_eax,%eax /* push eax */
|
|
+ push %eax
|
|
+ movl vcpu+vcpu_cr3,%eax /* activate new pagetables */
|
|
+ movl %eax,%cr3
|
|
+ pop %eax /* reload eax */
|
|
+ ret /* jump to new kernel */
|
|
+
|
|
+BUG:
|
|
+ /* crash the domain, make xen dump registers */
|
|
+ ud2
|
|
+ jmp BUG
|
|
+
|
|
+/* --- hypercall page ----------------------------------------------- */
|
|
+
|
|
+ .align 4096
|
|
+hypercall_page:
|
|
+ nop
|
|
+ .align 4096
|
|
+hypercall_end:
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/x86_32/hypercall.h
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/x86_32/hypercall.h
|
|
@@ -0,0 +1,359 @@
|
|
+/******************************************************************************
|
|
+ * hypercall.h
|
|
+ *
|
|
+ * Linux-specific hypervisor handling.
|
|
+ *
|
|
+ * Copyright (c) 2002-2004, K A Fraser
|
|
+ *
|
|
+ * This program is free software; you can redistribute it and/or
|
|
+ * modify it under the terms of the GNU General Public License version 2
|
|
+ * as published by the Free Software Foundation; or, when distributed
|
|
+ * separately from the Linux kernel or incorporated into other
|
|
+ * software packages, subject to the following license:
|
|
+ *
|
|
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
+ * of this source file (the "Software"), to deal in the Software without
|
|
+ * restriction, including without limitation the rights to use, copy, modify,
|
|
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
|
+ * and to permit persons to whom the Software is furnished to do so, subject to
|
|
+ * the following conditions:
|
|
+ *
|
|
+ * The above copyright notice and this permission notice shall be included in
|
|
+ * all copies or substantial portions of the Software.
|
|
+ *
|
|
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
+ * IN THE SOFTWARE.
|
|
+ */
|
|
+
|
|
+#ifndef __HYPERCALL_H__
|
|
+#define __HYPERCALL_H__
|
|
+
|
|
+
|
|
+#define __STR(x) #x
|
|
+#define STR(x) __STR(x)
|
|
+
|
|
+#define _hypercall0(type, name) \
|
|
+({ \
|
|
+ long __res; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res) \
|
|
+ : \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall1(type, name, a1) \
|
|
+({ \
|
|
+ long __res, __ign1; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=b" (__ign1) \
|
|
+ : "1" ((long)(a1)) \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall2(type, name, a1, a2) \
|
|
+({ \
|
|
+ long __res, __ign1, __ign2; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=b" (__ign1), "=c" (__ign2) \
|
|
+ : "1" ((long)(a1)), "2" ((long)(a2)) \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall3(type, name, a1, a2, a3) \
|
|
+({ \
|
|
+ long __res, __ign1, __ign2, __ign3; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=b" (__ign1), "=c" (__ign2), \
|
|
+ "=d" (__ign3) \
|
|
+ : "1" ((long)(a1)), "2" ((long)(a2)), \
|
|
+ "3" ((long)(a3)) \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall4(type, name, a1, a2, a3, a4) \
|
|
+({ \
|
|
+ long __res, __ign1, __ign2, __ign3, __ign4; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=b" (__ign1), "=c" (__ign2), \
|
|
+ "=d" (__ign3), "=S" (__ign4) \
|
|
+ : "1" ((long)(a1)), "2" ((long)(a2)), \
|
|
+ "3" ((long)(a3)), "4" ((long)(a4)) \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall5(type, name, a1, a2, a3, a4, a5) \
|
|
+({ \
|
|
+ long __res, __ign1, __ign2, __ign3, __ign4, __ign5; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=b" (__ign1), "=c" (__ign2), \
|
|
+ "=d" (__ign3), "=S" (__ign4), "=D" (__ign5) \
|
|
+ : "1" ((long)(a1)), "2" ((long)(a2)), \
|
|
+ "3" ((long)(a3)), "4" ((long)(a4)), \
|
|
+ "5" ((long)(a5)) \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_set_trap_table(
|
|
+ trap_info_t *table)
|
|
+{
|
|
+ return _hypercall1(int, set_trap_table, table);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_mmu_update(
|
|
+ mmu_update_t *req, int count, int *success_count, domid_t domid)
|
|
+{
|
|
+ return _hypercall4(int, mmu_update, req, count, success_count, domid);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_mmuext_op(
|
|
+ struct mmuext_op *op, int count, int *success_count, domid_t domid)
|
|
+{
|
|
+ return _hypercall4(int, mmuext_op, op, count, success_count, domid);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_set_gdt(
|
|
+ unsigned long *frame_list, int entries)
|
|
+{
|
|
+ return _hypercall2(int, set_gdt, frame_list, entries);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_stack_switch(
|
|
+ unsigned long ss, unsigned long esp)
|
|
+{
|
|
+ return _hypercall2(int, stack_switch, ss, esp);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_set_callbacks(
|
|
+ unsigned long event_selector, unsigned long event_address,
|
|
+ unsigned long failsafe_selector, unsigned long failsafe_address)
|
|
+{
|
|
+ return _hypercall4(int, set_callbacks,
|
|
+ event_selector, event_address,
|
|
+ failsafe_selector, failsafe_address);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_fpu_taskswitch(
|
|
+ int set)
|
|
+{
|
|
+ return _hypercall1(int, fpu_taskswitch, set);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_sched_op_compat(
|
|
+ int cmd, unsigned long arg)
|
|
+{
|
|
+ return _hypercall2(int, sched_op_compat, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_sched_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, sched_op, cmd, arg);
|
|
+}
|
|
+
|
|
+#if 0
|
|
+static inline long
|
|
+HYPERVISOR_set_timer_op(
|
|
+ u64 timeout)
|
|
+{
|
|
+ unsigned long timeout_hi = (unsigned long)(timeout>>32);
|
|
+ unsigned long timeout_lo = (unsigned long)timeout;
|
|
+ return _hypercall2(long, set_timer_op, timeout_lo, timeout_hi);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_dom0_op(
|
|
+ dom0_op_t *dom0_op)
|
|
+{
|
|
+ dom0_op->interface_version = DOM0_INTERFACE_VERSION;
|
|
+ return _hypercall1(int, dom0_op, dom0_op);
|
|
+}
|
|
+#endif
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_set_debugreg(
|
|
+ int reg, unsigned long value)
|
|
+{
|
|
+ return _hypercall2(int, set_debugreg, reg, value);
|
|
+}
|
|
+
|
|
+static inline unsigned long
|
|
+HYPERVISOR_get_debugreg(
|
|
+ int reg)
|
|
+{
|
|
+ return _hypercall1(unsigned long, get_debugreg, reg);
|
|
+}
|
|
+
|
|
+#if 0
|
|
+static inline int
|
|
+HYPERVISOR_update_descriptor(
|
|
+ u64 ma, u64 desc)
|
|
+{
|
|
+ return _hypercall4(int, update_descriptor, ma, ma>>32, desc, desc>>32);
|
|
+}
|
|
+#endif
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_memory_op(
|
|
+ unsigned int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, memory_op, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_multicall(
|
|
+ void *call_list, int nr_calls)
|
|
+{
|
|
+ return _hypercall2(int, multicall, call_list, nr_calls);
|
|
+}
|
|
+
|
|
+#if 0
|
|
+static inline int
|
|
+HYPERVISOR_update_va_mapping(
|
|
+ unsigned long va, pte_t new_val, unsigned long flags)
|
|
+{
|
|
+ unsigned long pte_hi = 0;
|
|
+#ifdef CONFIG_X86_PAE
|
|
+ pte_hi = new_val.pte_high;
|
|
+#endif
|
|
+ return _hypercall4(int, update_va_mapping, va,
|
|
+ new_val.pte_low, pte_hi, flags);
|
|
+}
|
|
+#endif
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_event_channel_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ int rc = _hypercall2(int, event_channel_op, cmd, arg);
|
|
+ /* FIXME: handle -ENOSYS */
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_acm_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, acm_op, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_xen_version(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, xen_version, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_console_io(
|
|
+ int cmd, int count, char *str)
|
|
+{
|
|
+ return _hypercall3(int, console_io, cmd, count, str);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_physdev_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ int rc = _hypercall2(int, physdev_op, cmd, arg);
|
|
+ /* FIXME: handle -ENOSYS */
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_grant_table_op(
|
|
+ unsigned int cmd, void *uop, unsigned int count)
|
|
+{
|
|
+ return _hypercall3(int, grant_table_op, cmd, uop, count);
|
|
+}
|
|
+
|
|
+#if 0
|
|
+static inline int
|
|
+HYPERVISOR_update_va_mapping_otherdomain(
|
|
+ unsigned long va, pte_t new_val, unsigned long flags, domid_t domid)
|
|
+{
|
|
+ unsigned long pte_hi = 0;
|
|
+#ifdef CONFIG_X86_PAE
|
|
+ pte_hi = new_val.pte_high;
|
|
+#endif
|
|
+ return _hypercall5(int, update_va_mapping_otherdomain, va,
|
|
+ new_val.pte_low, pte_hi, flags, domid);
|
|
+}
|
|
+#endif
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_vm_assist(
|
|
+ unsigned int cmd, unsigned int type)
|
|
+{
|
|
+ return _hypercall2(int, vm_assist, cmd, type);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_vcpu_op(
|
|
+ int cmd, int vcpuid, void *extra_args)
|
|
+{
|
|
+ return _hypercall3(int, vcpu_op, cmd, vcpuid, extra_args);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_suspend(
|
|
+ unsigned long srec)
|
|
+{
|
|
+ struct sched_shutdown sched_shutdown = {
|
|
+ .reason = SHUTDOWN_suspend
|
|
+ };
|
|
+
|
|
+ int rc = _hypercall3(int, sched_op, SCHEDOP_shutdown,
|
|
+ &sched_shutdown, srec);
|
|
+ /* FIXME: handle -ENOSYS */
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_nmi_op(
|
|
+ unsigned long op, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, nmi_op, op, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_callback_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, callback_op, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_xenoprof_op(
|
|
+ int op, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, xenoprof_op, op, arg);
|
|
+}
|
|
+
|
|
+
|
|
+#endif /* __HYPERCALL_H__ */
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/x86_64/div64.h
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/x86_64/div64.h
|
|
@@ -0,0 +1,57 @@
|
|
+#ifndef _ASM_GENERIC_DIV64_H
|
|
+#define _ASM_GENERIC_DIV64_H
|
|
+/*
|
|
+ * Copyright (C) 2003 Bernardo Innocenti <bernie@develer.com>
|
|
+ * Based on former asm-ppc/div64.h and asm-m68knommu/div64.h
|
|
+ *
|
|
+ * The semantics of do_div() are:
|
|
+ *
|
|
+ * uint32_t do_div(uint64_t *n, uint32_t base)
|
|
+ * {
|
|
+ * uint32_t remainder = *n % base;
|
|
+ * *n = *n / base;
|
|
+ * return remainder;
|
|
+ * }
|
|
+ *
|
|
+ * NOTE: macro parameter n is evaluated multiple times,
|
|
+ * beware of side effects!
|
|
+ */
|
|
+
|
|
+#include <linux/types.h>
|
|
+
|
|
+#if BITS_PER_LONG == 64
|
|
+
|
|
+# define do_div(n,base) ({ \
|
|
+ uint32_t __base = (base); \
|
|
+ uint32_t __rem; \
|
|
+ __rem = ((uint64_t)(n)) % __base; \
|
|
+ (n) = ((uint64_t)(n)) / __base; \
|
|
+ __rem; \
|
|
+ })
|
|
+
|
|
+#elif BITS_PER_LONG == 32
|
|
+
|
|
+extern uint32_t __div64_32(uint64_t *dividend, uint32_t divisor);
|
|
+
|
|
+/* The unnecessary pointer compare is there
|
|
+ * to check for type safety (n must be 64bit)
|
|
+ */
|
|
+# define do_div(n,base) ({ \
|
|
+ uint32_t __base = (base); \
|
|
+ uint32_t __rem; \
|
|
+ (void)(((typeof((n)) *)0) == ((uint64_t *)0)); \
|
|
+ if (likely(((n) >> 32) == 0)) { \
|
|
+ __rem = (uint32_t)(n) % __base; \
|
|
+ (n) = (uint32_t)(n) / __base; \
|
|
+ } else \
|
|
+ __rem = __div64_32(&(n), __base); \
|
|
+ __rem; \
|
|
+ })
|
|
+
|
|
+#else /* BITS_PER_LONG == ?? */
|
|
+
|
|
+# error do_div() does not yet support the C64
|
|
+
|
|
+#endif /* BITS_PER_LONG */
|
|
+
|
|
+#endif /* _ASM_GENERIC_DIV64_H */
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/x86_64/entry.S
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/x86_64/entry.S
|
|
@@ -0,0 +1,50 @@
|
|
+#include "offsets.h"
|
|
+
|
|
+/* --- stack -------------------------------------------------------- */
|
|
+
|
|
+ .data
|
|
+stack_bottom:
|
|
+ .fill 4096,1,0
|
|
+stack_top:
|
|
+
|
|
+/* --- text --------------------------------------------------------- */
|
|
+
|
|
+ .text
|
|
+ .globl _start,_start_kernel,hypercall_page,BUG
|
|
+
|
|
+_start:
|
|
+ /* setup stack */
|
|
+ movq %rsi, old_info
|
|
+ lea stack_top,%rsp
|
|
+ jmp start_helper
|
|
+
|
|
+_start_kernel:
|
|
+ movq vcpu+vcpu_ebx,%rbx /* load registers */
|
|
+ movq vcpu+vcpu_ecx,%rcx
|
|
+ movq vcpu+vcpu_edx,%rdx
|
|
+ movq vcpu+vcpu_esi,%rsi
|
|
+ movq vcpu+vcpu_edi,%rdi
|
|
+ movq vcpu+vcpu_ebp,%rbp
|
|
+ movq vcpu+vcpu_esp,%rsp /* using new kernels boot stack now */
|
|
+
|
|
+ movq vcpu+vcpu_eip,%rax
|
|
+ push %rax
|
|
+ movq vcpu+vcpu_eax,%rax
|
|
+ push %rax
|
|
+ movq vcpu+vcpu_cr3,%rax
|
|
+ movq %rax,%cr3 /* activate new pagetables */
|
|
+ pop %rax /* load rax */
|
|
+ ret /* jump to new kernel */
|
|
+
|
|
+BUG:
|
|
+ /* crash the domain, make xen dump registers */
|
|
+ ud2
|
|
+ jmp BUG
|
|
+
|
|
+/* --- hypercall page ----------------------------------------------- */
|
|
+
|
|
+ .align 4096
|
|
+hypercall_page:
|
|
+ nop
|
|
+ .align 4096
|
|
+hypercall_end:
|
|
Index: xen-4.0.2-testing/tools/xcutils/helper/x86_64/hypercall.h
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/helper/x86_64/hypercall.h
|
|
@@ -0,0 +1,354 @@
|
|
+/******************************************************************************
|
|
+ * hypercall.h
|
|
+ *
|
|
+ * Linux-specific hypervisor handling.
|
|
+ *
|
|
+ * Copyright (c) 2002-2004, K A Fraser
|
|
+ *
|
|
+ * 64-bit updates:
|
|
+ * Benjamin Liu <benjamin.liu@intel.com>
|
|
+ * Jun Nakajima <jun.nakajima@intel.com>
|
|
+ *
|
|
+ * This program is free software; you can redistribute it and/or
|
|
+ * modify it under the terms of the GNU General Public License version 2
|
|
+ * as published by the Free Software Foundation; or, when distributed
|
|
+ * separately from the Linux kernel or incorporated into other
|
|
+ * software packages, subject to the following license:
|
|
+ *
|
|
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
+ * of this source file (the "Software"), to deal in the Software without
|
|
+ * restriction, including without limitation the rights to use, copy, modify,
|
|
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
|
+ * and to permit persons to whom the Software is furnished to do so, subject to
|
|
+ * the following conditions:
|
|
+ *
|
|
+ * The above copyright notice and this permission notice shall be included in
|
|
+ * all copies or substantial portions of the Software.
|
|
+ *
|
|
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
+ * IN THE SOFTWARE.
|
|
+ */
|
|
+
|
|
+#ifndef __HYPERCALL_H__
|
|
+#define __HYPERCALL_H__
|
|
+
|
|
+
|
|
+#define __STR(x) #x
|
|
+#define STR(x) __STR(x)
|
|
+
|
|
+#define _hypercall0(type, name) \
|
|
+({ \
|
|
+ long __res; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res) \
|
|
+ : \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall1(type, name, a1) \
|
|
+({ \
|
|
+ long __res, __ign1; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=D" (__ign1) \
|
|
+ : "1" ((long)(a1)) \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall2(type, name, a1, a2) \
|
|
+({ \
|
|
+ long __res, __ign1, __ign2; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=D" (__ign1), "=S" (__ign2) \
|
|
+ : "1" ((long)(a1)), "2" ((long)(a2)) \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall3(type, name, a1, a2, a3) \
|
|
+({ \
|
|
+ long __res, __ign1, __ign2, __ign3; \
|
|
+ asm volatile ( \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=D" (__ign1), "=S" (__ign2), \
|
|
+ "=d" (__ign3) \
|
|
+ : "1" ((long)(a1)), "2" ((long)(a2)), \
|
|
+ "3" ((long)(a3)) \
|
|
+ : "memory" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall4(type, name, a1, a2, a3, a4) \
|
|
+({ \
|
|
+ long __res, __ign1, __ign2, __ign3; \
|
|
+ asm volatile ( \
|
|
+ "movq %7,%%r10; " \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=D" (__ign1), "=S" (__ign2), \
|
|
+ "=d" (__ign3) \
|
|
+ : "1" ((long)(a1)), "2" ((long)(a2)), \
|
|
+ "3" ((long)(a3)), "g" ((long)(a4)) \
|
|
+ : "memory", "r10" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+#define _hypercall5(type, name, a1, a2, a3, a4, a5) \
|
|
+({ \
|
|
+ long __res, __ign1, __ign2, __ign3; \
|
|
+ asm volatile ( \
|
|
+ "movq %7,%%r10; movq %8,%%r8; " \
|
|
+ "call hypercall_page + ("STR(__HYPERVISOR_##name)" * 32)"\
|
|
+ : "=a" (__res), "=D" (__ign1), "=S" (__ign2), \
|
|
+ "=d" (__ign3) \
|
|
+ : "1" ((long)(a1)), "2" ((long)(a2)), \
|
|
+ "3" ((long)(a3)), "g" ((long)(a4)), \
|
|
+ "g" ((long)(a5)) \
|
|
+ : "memory", "r10", "r8" ); \
|
|
+ (type)__res; \
|
|
+})
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_set_trap_table(
|
|
+ trap_info_t *table)
|
|
+{
|
|
+ return _hypercall1(int, set_trap_table, table);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_mmu_update(
|
|
+ mmu_update_t *req, int count, int *success_count, domid_t domid)
|
|
+{
|
|
+ return _hypercall4(int, mmu_update, req, count, success_count, domid);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_mmuext_op(
|
|
+ struct mmuext_op *op, int count, int *success_count, domid_t domid)
|
|
+{
|
|
+ return _hypercall4(int, mmuext_op, op, count, success_count, domid);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_set_gdt(
|
|
+ unsigned long *frame_list, int entries)
|
|
+{
|
|
+ return _hypercall2(int, set_gdt, frame_list, entries);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_stack_switch(
|
|
+ unsigned long ss, unsigned long esp)
|
|
+{
|
|
+ return _hypercall2(int, stack_switch, ss, esp);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_set_callbacks(
|
|
+ unsigned long event_address, unsigned long failsafe_address,
|
|
+ unsigned long syscall_address)
|
|
+{
|
|
+ return _hypercall3(int, set_callbacks,
|
|
+ event_address, failsafe_address, syscall_address);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_fpu_taskswitch(
|
|
+ int set)
|
|
+{
|
|
+ return _hypercall1(int, fpu_taskswitch, set);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_sched_op_compat(
|
|
+ int cmd, unsigned long arg)
|
|
+{
|
|
+ return _hypercall2(int, sched_op_compat, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_sched_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, sched_op, cmd, arg);
|
|
+}
|
|
+
|
|
+#if 0
|
|
+static inline long
|
|
+HYPERVISOR_set_timer_op(
|
|
+ u64 timeout)
|
|
+{
|
|
+ return _hypercall1(long, set_timer_op, timeout);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_dom0_op(
|
|
+ dom0_op_t *dom0_op)
|
|
+{
|
|
+ dom0_op->interface_version = DOM0_INTERFACE_VERSION;
|
|
+ return _hypercall1(int, dom0_op, dom0_op);
|
|
+}
|
|
+#endif
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_set_debugreg(
|
|
+ int reg, unsigned long value)
|
|
+{
|
|
+ return _hypercall2(int, set_debugreg, reg, value);
|
|
+}
|
|
+
|
|
+static inline unsigned long
|
|
+HYPERVISOR_get_debugreg(
|
|
+ int reg)
|
|
+{
|
|
+ return _hypercall1(unsigned long, get_debugreg, reg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_update_descriptor(
|
|
+ unsigned long ma, unsigned long word)
|
|
+{
|
|
+ return _hypercall2(int, update_descriptor, ma, word);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_memory_op(
|
|
+ unsigned int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, memory_op, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_multicall(
|
|
+ void *call_list, int nr_calls)
|
|
+{
|
|
+ return _hypercall2(int, multicall, call_list, nr_calls);
|
|
+}
|
|
+
|
|
+#if 0
|
|
+static inline int
|
|
+HYPERVISOR_update_va_mapping(
|
|
+ unsigned long va, pte_t new_val, unsigned long flags)
|
|
+{
|
|
+ return _hypercall3(int, update_va_mapping, va, new_val.pte, flags);
|
|
+}
|
|
+#endif
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_event_channel_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ int rc = _hypercall2(int, event_channel_op, cmd, arg);
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_acm_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, acm_op, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_xen_version(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, xen_version, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_console_io(
|
|
+ int cmd, int count, char *str)
|
|
+{
|
|
+ return _hypercall3(int, console_io, cmd, count, str);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_physdev_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ int rc = _hypercall2(int, physdev_op, cmd, arg);
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_grant_table_op(
|
|
+ unsigned int cmd, void *uop, unsigned int count)
|
|
+{
|
|
+ return _hypercall3(int, grant_table_op, cmd, uop, count);
|
|
+}
|
|
+
|
|
+#if 0
|
|
+static inline int
|
|
+HYPERVISOR_update_va_mapping_otherdomain(
|
|
+ unsigned long va, pte_t new_val, unsigned long flags, domid_t domid)
|
|
+{
|
|
+ return _hypercall4(int, update_va_mapping_otherdomain, va,
|
|
+ new_val.pte, flags, domid);
|
|
+}
|
|
+#endif
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_vm_assist(
|
|
+ unsigned int cmd, unsigned int type)
|
|
+{
|
|
+ return _hypercall2(int, vm_assist, cmd, type);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_vcpu_op(
|
|
+ int cmd, int vcpuid, void *extra_args)
|
|
+{
|
|
+ return _hypercall3(int, vcpu_op, cmd, vcpuid, extra_args);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_set_segment_base(
|
|
+ int reg, unsigned long value)
|
|
+{
|
|
+ return _hypercall2(int, set_segment_base, reg, value);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_suspend(
|
|
+ unsigned long srec)
|
|
+{
|
|
+ struct sched_shutdown sched_shutdown = {
|
|
+ .reason = SHUTDOWN_suspend
|
|
+ };
|
|
+
|
|
+ int rc = _hypercall3(int, sched_op, SCHEDOP_shutdown,
|
|
+ &sched_shutdown, srec);
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_nmi_op(
|
|
+ unsigned long op, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, nmi_op, op, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_callback_op(
|
|
+ int cmd, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, callback_op, cmd, arg);
|
|
+}
|
|
+
|
|
+static inline int
|
|
+HYPERVISOR_xenoprof_op(
|
|
+ int op, void *arg)
|
|
+{
|
|
+ return _hypercall2(int, xenoprof_op, op, arg);
|
|
+}
|
|
+
|
|
+#endif /* __HYPERCALL_H__ */
|
|
Index: xen-4.0.2-testing/tools/xcutils/kexec-syscall.h
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/kexec-syscall.h
|
|
@@ -0,0 +1,80 @@
|
|
+#ifndef KEXEC_SYSCALL_H
|
|
+#define KEXEC_SYSCALL_H
|
|
+
|
|
+#define __LIBRARY__
|
|
+#include <syscall.h>
|
|
+#include <sys/syscall.h>
|
|
+#include <unistd.h>
|
|
+
|
|
+#define LINUX_REBOOT_MAGIC1 0xfee1dead
|
|
+#define LINUX_REBOOT_MAGIC2 672274793
|
|
+#define LINUX_REBOOT_MAGIC2A 85072278
|
|
+#define LINUX_REBOOT_MAGIC2B 369367448
|
|
+
|
|
+#define LINUX_REBOOT_CMD_RESTART 0x01234567
|
|
+#define LINUX_REBOOT_CMD_HALT 0xCDEF0123
|
|
+#define LINUX_REBOOT_CMD_CAD_ON 0x89ABCDEF
|
|
+#define LINUX_REBOOT_CMD_CAD_OFF 0x00000000
|
|
+#define LINUX_REBOOT_CMD_POWER_OFF 0x4321FEDC
|
|
+#define LINUX_REBOOT_CMD_RESTART2 0xA1B2C3D4
|
|
+#define LINUX_REBOOT_CMD_EXEC_KERNEL 0x18273645
|
|
+#define LINUX_REBOOT_CMD_KEXEC_OLD 0x81726354
|
|
+#define LINUX_REBOOT_CMD_KEXEC_OLD2 0x18263645
|
|
+#define LINUX_REBOOT_CMD_KEXEC 0x45584543
|
|
+
|
|
+#ifdef __i386__
|
|
+#define __NR_kexec_load 283
|
|
+#endif
|
|
+#ifdef __ia64__
|
|
+#define __NR_kexec_load 1268
|
|
+#endif
|
|
+#ifdef __powerpc64__
|
|
+#define __NR_kexec_load 268
|
|
+#endif
|
|
+#ifdef __powerpc__
|
|
+#define __NR_kexec_load 268
|
|
+#endif
|
|
+#ifdef __x86_64__
|
|
+#define __NR_kexec_load 246
|
|
+#endif
|
|
+#ifdef __s390x__
|
|
+#define __NR_kexec_load 277
|
|
+#endif
|
|
+#ifdef __s390__
|
|
+#define __NR_kexec_load 277
|
|
+#endif
|
|
+#ifndef __NR_kexec_load
|
|
+#error Unknown processor architecture. Needs a kexec_load syscall number.
|
|
+#endif
|
|
+
|
|
+struct kexec_segment;
|
|
+
|
|
+static inline long kexec_load(void *entry, unsigned long nr_segments,
|
|
+ struct kexec_segment *segments, unsigned long flags)
|
|
+{
|
|
+ return (long) syscall(__NR_kexec_load, entry, nr_segments, segments, flags);
|
|
+}
|
|
+
|
|
+static inline long kexec_reboot(void)
|
|
+{
|
|
+ return (long) syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_KEXEC, 0);
|
|
+}
|
|
+
|
|
+
|
|
+#define KEXEC_ON_CRASH 0x00000001
|
|
+#define KEXEC_ARCH_MASK 0xffff0000
|
|
+
|
|
+/* These values match the ELF architecture values.
|
|
+ * Unless there is a good reason that should continue to be the case.
|
|
+ */
|
|
+#define KEXEC_ARCH_DEFAULT ( 0 << 16)
|
|
+#define KEXEC_ARCH_386 ( 3 << 16)
|
|
+#define KEXEC_ARCH_X86_64 (62 << 16)
|
|
+#define KEXEC_ARCH_PPC (20 << 16)
|
|
+#define KEXEC_ARCH_PPC64 (21 << 16)
|
|
+#define KEXEC_ARCH_IA_64 (50 << 16)
|
|
+#define KEXEC_ARCH_S390 (22 << 16)
|
|
+
|
|
+#define KEXEC_MAX_SEGMENTS 16
|
|
+
|
|
+#endif /* KEXEC_SYSCALL_H */
|
|
Index: xen-4.0.2-testing/tools/xcutils/xc_kexec.c
|
|
===================================================================
|
|
--- /dev/null
|
|
+++ xen-4.0.2-testing/tools/xcutils/xc_kexec.c
|
|
@@ -0,0 +1,503 @@
|
|
+#include <stdio.h>
|
|
+#include <stdlib.h>
|
|
+#include <unistd.h>
|
|
+#include <string.h>
|
|
+#include <inttypes.h>
|
|
+#include <malloc.h>
|
|
+#include <sys/mman.h>
|
|
+
|
|
+#include <xg_private.h>
|
|
+#include <xc_dom.h>
|
|
+#include <xen/libelf/libelf.h>
|
|
+
|
|
+#include "kexec-syscall.h"
|
|
+
|
|
+/* ------------------------------------------------------------------ */
|
|
+
|
|
+static unsigned long debug_level;
|
|
+
|
|
+static char hypercall_page[PAGE_SIZE];
|
|
+static unsigned long max_pfn;
|
|
+static unsigned long xen_start_info;
|
|
+static start_info_t start_info;
|
|
+
|
|
+/* -------------------------------------------------------------------------------- */
|
|
+
|
|
+static unsigned long kernel_find_symbol(char *name)
|
|
+{
|
|
+ FILE *file;
|
|
+ char line[256], type, symbol[256];
|
|
+ unsigned long addr, retval = 0;
|
|
+
|
|
+ file = fopen("/proc/kallsyms", "r");
|
|
+ if (NULL == file) {
|
|
+ perror("open /proc/kallsyms");
|
|
+ exit(1);
|
|
+ }
|
|
+ while (NULL != fgets(line, sizeof(line), file)) {
|
|
+ if (3 != sscanf(line, "%lx %c %127s", &addr, &type, symbol)) {
|
|
+ fprintf(stderr,"parse error: %s\n", line);
|
|
+ exit(1);
|
|
+ }
|
|
+ if (0 == strcmp(name, symbol)) {
|
|
+ retval = addr;
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+ fclose(file);
|
|
+ return retval;
|
|
+}
|
|
+
|
|
+static int kernel_core_read(void *dest, off_t start, size_t size)
|
|
+{
|
|
+ FILE *file;
|
|
+ int rc;
|
|
+
|
|
+ file = fopen("/proc/kcore", "r");
|
|
+ if (NULL == file) {
|
|
+ perror("open /proc/kcore");
|
|
+ exit(1);
|
|
+ }
|
|
+ rc = fseek(file, start, SEEK_SET);
|
|
+ if (rc < 0)
|
|
+ goto out;
|
|
+ rc = fread(dest, 1, size, file);
|
|
+ fclose(file);
|
|
+
|
|
+ out:
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+static off_t kernel_core_offset(unsigned long addr)
|
|
+{
|
|
+ static void *core_header = NULL;
|
|
+ static struct elf_binary elf;
|
|
+ const elf_phdr *phdr;
|
|
+ uint64_t p_type;
|
|
+ uint64_t p_vaddr;
|
|
+ uint64_t p_offset;
|
|
+ uint64_t p_filesz;
|
|
+ off_t offset = 0;
|
|
+ int h;
|
|
+
|
|
+ if (NULL == core_header) {
|
|
+ core_header = malloc(PAGE_SIZE);
|
|
+ if (PAGE_SIZE != kernel_core_read(core_header, 0, PAGE_SIZE))
|
|
+ goto out;
|
|
+ elf_init(&elf, core_header, PAGE_SIZE);
|
|
+ }
|
|
+
|
|
+ for (h = 0; h < elf_uval(&elf, elf.ehdr, e_phnum); h++) {
|
|
+ phdr = elf_phdr_by_index(&elf, h);
|
|
+ p_type = elf_uval(&elf, phdr, p_type);
|
|
+ p_vaddr = elf_uval(&elf, phdr, p_vaddr);
|
|
+ p_offset = elf_uval(&elf, phdr, p_offset);
|
|
+ p_filesz = elf_uval(&elf, phdr, p_filesz);
|
|
+ if (p_type != PT_LOAD)
|
|
+ continue;
|
|
+ if (addr > p_vaddr && addr < p_vaddr + p_filesz)
|
|
+ offset = p_offset + (addr - p_vaddr);
|
|
+ }
|
|
+
|
|
+ out:
|
|
+ return offset;
|
|
+}
|
|
+
|
|
+static int kernel_core_by_addr(void *dest, unsigned long addr, size_t size)
|
|
+{
|
|
+ off_t offset;
|
|
+ int rc = 0;
|
|
+
|
|
+ offset = kernel_core_offset(addr);
|
|
+ if (0 == addr) {
|
|
+ fprintf(stderr, "%s: addr 0x%lx not in /proc/kcore\n",
|
|
+ __FUNCTION__, addr);
|
|
+ goto out;
|
|
+ }
|
|
+ rc = kernel_core_read(dest, offset, size);
|
|
+ if (debug_level)
|
|
+ fprintf(stderr, "%s: vaddr %lx, offset %lx, %d bytes\n",
|
|
+ __FUNCTION__, addr, (unsigned long)offset, rc);
|
|
+
|
|
+ out:
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+static int kernel_core_by_name(void *dest, char *name, size_t size)
|
|
+{
|
|
+ unsigned long addr;
|
|
+ off_t offset;
|
|
+ int rc = 0;
|
|
+
|
|
+ addr = kernel_find_symbol(name);
|
|
+ if (0 == addr) {
|
|
+ fprintf(stderr, "%s: can't find symbol \"%s\" in /proc/kallsyms\n",
|
|
+ __FUNCTION__, name);
|
|
+ fprintf(stderr, "%s: try CONFIG_KALLSYMS_ALL=y\n", __FUNCTION__);
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ offset = kernel_core_offset(addr);
|
|
+ if (0 == addr) {
|
|
+ fprintf(stderr, "%s: symbol \"%s\" (0x%lx) not in /proc/kcore\n",
|
|
+ __FUNCTION__, name, addr);
|
|
+ goto out;
|
|
+ }
|
|
+ rc = kernel_core_read(dest, offset, size);
|
|
+ if (debug_level)
|
|
+ fprintf(stderr, "%s: vaddr %lx, offset %lx, %d bytes (%s)\n",
|
|
+ __FUNCTION__, addr, (unsigned long)offset, rc, name);
|
|
+
|
|
+ out:
|
|
+ return rc;
|
|
+}
|
|
+
|
|
+/* ------------------------------------------------------------------ */
|
|
+
|
|
+struct kexec_segment {
|
|
+ const void *buf;
|
|
+ size_t bufsz;
|
|
+ const void *mem;
|
|
+ size_t memsz;
|
|
+};
|
|
+
|
|
+struct kexec_segment segments[KEXEC_MAX_SEGMENTS];
|
|
+static unsigned int nsegments;
|
|
+static void *entry;
|
|
+
|
|
+static void kexec_add_segment(struct xc_dom_image *dom,
|
|
+ struct xc_dom_seg *xc_seg,
|
|
+ struct kexec_segment *kseg)
|
|
+{
|
|
+ if (0 == xc_seg->vend - xc_seg->vstart)
|
|
+ return;
|
|
+
|
|
+ kseg->buf = xc_dom_seg_to_ptr(dom, xc_seg);
|
|
+ kseg->bufsz = xc_seg->vend - xc_seg->vstart;
|
|
+ kseg->mem = (void*)(xc_seg->pfn << PAGE_SHIFT);
|
|
+ kseg->memsz = kseg->bufsz;
|
|
+ if (debug_level)
|
|
+ fprintf(stderr," kexec segment: 0x%08lx-0x%08lx (+0x%08lx)\n",
|
|
+ (unsigned long)kseg->mem,
|
|
+ (unsigned long)(kseg->mem+kseg->memsz-1),
|
|
+ (unsigned long)kseg->memsz);
|
|
+}
|
|
+
|
|
+static void kexec_add_page(struct xc_dom_image *dom, xen_pfn_t pfn,
|
|
+ struct kexec_segment *kseg)
|
|
+{
|
|
+ if (0 == pfn)
|
|
+ return;
|
|
+
|
|
+ kseg->buf = xc_dom_pfn_to_ptr(dom, pfn, 1);
|
|
+ kseg->bufsz = PAGE_SIZE;
|
|
+ kseg->mem = (void*)(pfn << PAGE_SHIFT);
|
|
+ kseg->memsz = kseg->bufsz;
|
|
+ if (debug_level)
|
|
+ fprintf(stderr," kexec page : 0x%08lx-0x%08lx\n",
|
|
+ (unsigned long)kseg->mem,
|
|
+ (unsigned long)(kseg->mem+kseg->memsz-1));
|
|
+}
|
|
+
|
|
+/* ------------------------------------------------------------------ */
|
|
+
|
|
+static const char helper_blob[] = {
|
|
+#include "helper/blob.h"
|
|
+};
|
|
+
|
|
+static void helper_parse(struct xc_dom_image *dom,
|
|
+ struct elf_binary *elf)
|
|
+{
|
|
+ if (debug_level)
|
|
+ fprintf(stderr, "%s\n", __FUNCTION__);
|
|
+ elf_init(elf, helper_blob, sizeof(helper_blob));
|
|
+ if (debug_level)
|
|
+ elf_set_logfile(elf, stderr, debug_level);
|
|
+ elf_parse_binary(elf);
|
|
+ elf->pstart = elf->pstart & PAGE_MASK;
|
|
+ elf->pend = (elf->pend + PAGE_SIZE - 1) & PAGE_MASK;
|
|
+
|
|
+ dom->extra_pages = (elf->pend - elf->pstart) >> PAGE_SHIFT;
|
|
+}
|
|
+
|
|
+static void *helper_load(struct xc_dom_image *dom,
|
|
+ struct elf_binary *elf)
|
|
+{
|
|
+ struct xc_dom_seg seg;
|
|
+ uint64_t entry;
|
|
+
|
|
+ if (debug_level)
|
|
+ fprintf(stderr, "%s\n", __FUNCTION__);
|
|
+
|
|
+ xc_dom_alloc_segment(dom, &seg, "kexec", 0, elf->pend - elf->pstart);
|
|
+ elf->dest = xc_dom_seg_to_ptr(dom, &seg);
|
|
+ elf->reloc_offset = seg.vstart - dom->parms.virt_base - elf->pstart;
|
|
+ if (debug_level)
|
|
+ fprintf(stderr,"%s: relocation offset: 0x%" PRIx64 "\n",
|
|
+ __FUNCTION__, elf->reloc_offset);
|
|
+
|
|
+ if (NULL == elf->dest)
|
|
+ goto err;
|
|
+ elf_load_binary(elf);
|
|
+ if (-1 == elf_reloc(elf))
|
|
+ goto err;
|
|
+ kexec_add_segment(dom, &seg, &segments[nsegments++]);
|
|
+
|
|
+ entry = elf_uval(elf, elf->ehdr, e_entry);
|
|
+ return (void*)((intptr_t)(entry + elf->reloc_offset));
|
|
+
|
|
+ err:
|
|
+ exit(1);
|
|
+}
|
|
+
|
|
+static void* ptr_symbol(struct elf_binary *elf, const char *symbol)
|
|
+{
|
|
+ unsigned long addr;
|
|
+
|
|
+ addr = elf_lookup_addr(elf, symbol);
|
|
+ if (-1 == addr)
|
|
+ exit(1);
|
|
+ return elf_get_ptr(elf, addr);
|
|
+}
|
|
+
|
|
+static void helper_pass_info(struct xc_dom_image *dom, struct elf_binary *elf)
|
|
+{
|
|
+ struct vcpu_guest_context ctxt;
|
|
+ struct vcpu_guest_context *vcpu;
|
|
+ unsigned long *addr;
|
|
+ void *page;
|
|
+
|
|
+ if (debug_level)
|
|
+ fprintf(stderr, "%s\n", __FUNCTION__);
|
|
+ dom->arch_hooks->vcpu(dom, &ctxt);
|
|
+ vcpu = ptr_symbol(elf, "vcpu");
|
|
+ *vcpu = ctxt;
|
|
+ addr = ptr_symbol(elf, "virt_base");
|
|
+ *addr = dom->parms.virt_base;
|
|
+ addr = ptr_symbol(elf, "virt_hypercall");
|
|
+ *addr = dom->parms.virt_hypercall;
|
|
+#if defined(__i386__)
|
|
+ addr = ptr_symbol(elf, "pae_paging");
|
|
+ *addr = dom->parms.pae;
|
|
+#endif
|
|
+ addr = ptr_symbol(elf, "debug_level");
|
|
+ *addr = debug_level;
|
|
+ page = ptr_symbol(elf, "hypercall_page");
|
|
+ memcpy(page, hypercall_page, PAGE_SIZE);
|
|
+}
|
|
+
|
|
+/* ------------------------------------------------------------------ */
|
|
+
|
|
+static char *kernel_name = "/boot/vmlinuz-xen";
|
|
+static char *ramdisk_name;
|
|
+static char *cmdline;
|
|
+static char *features; // = "auto_translated_physmap";
|
|
+static int do_exec = 0;
|
|
+static int do_load = 1;
|
|
+static int do_type = 0;
|
|
+
|
|
+static void usage(FILE *fp)
|
|
+{
|
|
+ fprintf(fp,
|
|
+ "\n"
|
|
+ "This is a xen kexec loader.\n"
|
|
+ "\n"
|
|
+ "usage: xen-kexec [ options ]\n"
|
|
+ "options:\n"
|
|
+ " -h print this text\n"
|
|
+ " -d enable debug messages\n"
|
|
+ " -e boot loaded kernel [%s]\n"
|
|
+ " -l load kernel [%s]\n"
|
|
+ " -k <file> kernel image [%s]\n"
|
|
+ " -i <file> initrd [%s]\n"
|
|
+ " -c <args> kernel command line [%s]\n"
|
|
+ " -f <feat> xen features [%s]\n"
|
|
+ " -t print kernel type\n"
|
|
+ "\n"
|
|
+ "(c) 2006 Gerd Hoffmann <kraxel@suse.de>\n",
|
|
+ do_exec ? "yes" : "no",
|
|
+ do_load ? "yes" : "no",
|
|
+ kernel_name, ramdisk_name,
|
|
+ cmdline ? : "-",
|
|
+ features ? : "-");
|
|
+}
|
|
+
|
|
+static void print_type(char *filename)
|
|
+{
|
|
+ struct xc_dom_image *dom;
|
|
+
|
|
+ dom = xc_dom_allocate(cmdline, features);
|
|
+ if (0 != xc_dom_kernel_file(dom, filename)) {
|
|
+ fprintf(stderr, "can't open %s: %s\n", filename, strerror(errno));
|
|
+ goto done;
|
|
+ }
|
|
+ if (0 != xc_dom_parse_image(dom)) {
|
|
+ printf("unknown-kernel\n");
|
|
+ goto done;
|
|
+ }
|
|
+#if defined(__i386__) || defined(__x86_64__)
|
|
+ if (NULL == dom->parms.elf_note_start && NULL == dom->parms.guest_info) {
|
|
+ printf("other-elf-kernel\n");
|
|
+ goto done;
|
|
+ }
|
|
+#endif
|
|
+ printf("%s\n", dom->guest_type);
|
|
+
|
|
+ done:
|
|
+ xc_dom_release(dom);
|
|
+}
|
|
+
|
|
+int main(int argc, char *argv[])
|
|
+{
|
|
+ struct xc_dom_image *dom = NULL;
|
|
+ struct elf_binary helper;
|
|
+ int fd,rc,c,xc;
|
|
+
|
|
+ /* figure defaults */
|
|
+ fd = open("/proc/cmdline", O_RDONLY);
|
|
+ if (-1 != fd) {
|
|
+ cmdline = malloc(1024);
|
|
+ rc = read(fd,cmdline,1024);
|
|
+ cmdline[rc-1] = 0;
|
|
+ close(fd);
|
|
+ }
|
|
+
|
|
+ /* parse args */
|
|
+ for (;;) {
|
|
+ if (-1 == (c = getopt(argc, argv, "hdletk:i:c:f:")))
|
|
+ break;
|
|
+ switch (c) {
|
|
+ case 'k':
|
|
+ kernel_name = optarg;
|
|
+ break;
|
|
+ case 'i':
|
|
+ if (strlen(optarg))
|
|
+ ramdisk_name = optarg;
|
|
+ else
|
|
+ ramdisk_name = NULL;
|
|
+ break;
|
|
+ case 'c':
|
|
+ cmdline = optarg;
|
|
+ break;
|
|
+ case 'f':
|
|
+ features = optarg;
|
|
+ break;
|
|
+ case 'd':
|
|
+ debug_level++;
|
|
+ break;
|
|
+
|
|
+ case 'e':
|
|
+ do_exec = 1;
|
|
+ do_load = 0;
|
|
+ do_type = 0;
|
|
+ break;
|
|
+ case 'l':
|
|
+ do_exec = 0;
|
|
+ do_load = 1;
|
|
+ do_type = 0;
|
|
+ break;
|
|
+ case 't':
|
|
+ do_exec = 0;
|
|
+ do_load = 0;
|
|
+ do_type = 1;
|
|
+ break;
|
|
+
|
|
+ case 'h':
|
|
+ usage(stdout);
|
|
+ exit(0);
|
|
+ default:
|
|
+ usage(stderr);
|
|
+ exit(1);
|
|
+ }
|
|
+ }
|
|
+
|
|
+ if (do_exec) {
|
|
+ kexec_reboot();
|
|
+ perror("kexec_reboot");
|
|
+ exit(1);
|
|
+ }
|
|
+
|
|
+ /* logging */
|
|
+ if (debug_level)
|
|
+ xc_dom_logfile = stderr;
|
|
+
|
|
+ if (do_type) {
|
|
+ print_type(kernel_name);
|
|
+ exit(0);
|
|
+ }
|
|
+
|
|
+ if (!do_load)
|
|
+ exit(0);
|
|
+
|
|
+ xc = xc_interface_open();
|
|
+ if (-1 == xc)
|
|
+ exit(1);
|
|
+
|
|
+ /* get info from kernel */
|
|
+ if (kernel_core_by_name(hypercall_page, "hypercall_page", PAGE_SIZE) <= 0)
|
|
+ goto out;
|
|
+ if (kernel_core_by_name(&max_pfn, "max_pfn", sizeof(max_pfn)) <= 0)
|
|
+ goto out;
|
|
+ if (kernel_core_by_name(&xen_start_info, "xen_start_info", sizeof(xen_start_info)) <= 0)
|
|
+ goto out;
|
|
+ if (kernel_core_by_addr(&start_info, xen_start_info, sizeof(start_info)) <= 0)
|
|
+ goto out;
|
|
+
|
|
+ /* build image */
|
|
+ dom = xc_dom_allocate(cmdline, features);
|
|
+ dom->xen_version = xc_version(xc, XENVER_version, NULL);
|
|
+ strcpy(dom->xen_caps, start_info.magic);
|
|
+
|
|
+ if (0 != (rc = xc_dom_kernel_file(dom, kernel_name)))
|
|
+ goto out;
|
|
+ if (ramdisk_name && strlen(ramdisk_name))
|
|
+ if (0 != (rc = xc_dom_ramdisk_file(dom, ramdisk_name)))
|
|
+ goto out;
|
|
+ if (0 != (rc = xc_dom_parse_image(dom)))
|
|
+ goto out;
|
|
+ if (0 != strcmp(start_info.magic, dom->guest_type)) {
|
|
+ fprintf(stderr,"incompatible kernel (need guest_type \"%s\")\n",
|
|
+ start_info.magic);
|
|
+ goto out;
|
|
+ }
|
|
+ helper_parse(dom, &helper);
|
|
+
|
|
+ if (0 != (rc = xc_dom_mem_init(dom, max_pfn >> (20 - PAGE_SHIFT))))
|
|
+ goto out;
|
|
+ if (0 != (rc = xc_dom_build_image(dom)))
|
|
+ goto out;
|
|
+ entry = helper_load(dom, &helper);
|
|
+ if (0 != (rc = dom->arch_hooks->setup_pgtables(dom)))
|
|
+ goto out;
|
|
+ dom->arch_hooks->start_info(dom);
|
|
+
|
|
+ /* setup kexec structs */
|
|
+ kexec_add_segment(dom, &dom->kernel_seg, &segments[nsegments++]);
|
|
+ kexec_add_segment(dom, &dom->ramdisk_seg, &segments[nsegments++]);
|
|
+ kexec_add_segment(dom, &dom->p2m_seg, &segments[nsegments++]);
|
|
+ kexec_add_page(dom, dom->start_info_pfn, &segments[nsegments++]);
|
|
+ kexec_add_segment(dom, &dom->pgtables_seg, &segments[nsegments++]);
|
|
+
|
|
+ dom->flags = start_info.flags;
|
|
+ dom->console_evtchn = start_info.console.domU.evtchn;
|
|
+ dom->xenstore_evtchn = start_info.store_evtchn;
|
|
+
|
|
+ /* setup helper code */
|
|
+ helper_pass_info(dom, &helper);
|
|
+
|
|
+ rc = kexec_load(entry, nsegments, segments, 0);
|
|
+ if (0 != rc) {
|
|
+ perror("kexec_load");
|
|
+ exit(1);
|
|
+ }
|
|
+ if (debug_level)
|
|
+ fprintf(stderr,"kexec_load ok [%p]\n", entry);
|
|
+
|
|
+ xc_dom_release(dom);
|
|
+ exit(0);
|
|
+
|
|
+ out:
|
|
+ if (dom)
|
|
+ xc_dom_release(dom);
|
|
+ exit(1);
|
|
+}
|