-O $(BASEDIR)/include/xen/compile.h ]; then \
echo '$(TARGET).efi'; fi)
+ifdef CONFIG_XSPLICE
+all_symbols = --all-symbols
+else
+all_symbols =
+endif
+
$(TARGET): $(TARGET)-syms $(efi-y) boot/mkelf32
./boot/mkelf32 $(TARGET)-syms $(TARGET) 0x100000 \
`$(NM) -nr $(TARGET)-syms | head -n 1 | sed -e 's/^\([^ ]*\).*/0x\1/'`
$(LD) $(LDFLAGS) -T xen.lds -N prelink.o \
$(BASEDIR)/common/symbols-dummy.o -o $(@D)/.$(@F).0
$(NM) -pa --format=sysv $(@D)/.$(@F).0 \
- | $(BASEDIR)/tools/symbols --sysv --sort >$(@D)/.$(@F).0.S
+ | $(BASEDIR)/tools/symbols $(all_symbols) --sysv --sort \
+ >$(@D)/.$(@F).0.S
$(MAKE) -f $(BASEDIR)/Rules.mk $(@D)/.$(@F).0.o
$(LD) $(LDFLAGS) -T xen.lds -N prelink.o \
$(@D)/.$(@F).0.o -o $(@D)/.$(@F).1
$(NM) -pa --format=sysv $(@D)/.$(@F).1 \
- | $(BASEDIR)/tools/symbols --sysv --sort --warn-dup >$(@D)/.$(@F).1.S
+ | $(BASEDIR)/tools/symbols $(all_symbols) --sysv --sort --warn-dup \
+ >$(@D)/.$(@F).1.S
$(MAKE) -f $(BASEDIR)/Rules.mk $(@D)/.$(@F).1.o
$(LD) $(LDFLAGS) -T xen.lds -N prelink.o \
$(@D)/.$(@F).1.o -o $@
$(BASEDIR)/common/symbols-dummy.o -o $(@D)/.$(@F).$(base).0 &&) :
$(guard) efi/mkreloc $(foreach base,$(VIRT_BASE) $(ALT_BASE),$(@D)/.$(@F).$(base).0) >$(@D)/.$(@F).0r.S
$(guard) $(NM) -pa --format=sysv $(@D)/.$(@F).$(VIRT_BASE).0 \
- | $(guard) $(BASEDIR)/tools/symbols --sysv --sort >$(@D)/.$(@F).0s.S
+ | $(guard) $(BASEDIR)/tools/symbols $(all_symbols) --sysv --sort >$(@D)/.$(@F).0s.S
$(guard) $(MAKE) -f $(BASEDIR)/Rules.mk $(@D)/.$(@F).0r.o $(@D)/.$(@F).0s.o
$(foreach base, $(VIRT_BASE) $(ALT_BASE), \
$(guard) $(LD) $(call EFI_LDFLAGS,$(base)) -T efi.lds -N $< \
$(@D)/.$(@F).0r.o $(@D)/.$(@F).0s.o -o $(@D)/.$(@F).$(base).1 &&) :
$(guard) efi/mkreloc $(foreach base,$(VIRT_BASE) $(ALT_BASE),$(@D)/.$(@F).$(base).1) >$(@D)/.$(@F).1r.S
$(guard) $(NM) -pa --format=sysv $(@D)/.$(@F).$(VIRT_BASE).1 \
- | $(guard) $(BASEDIR)/tools/symbols --sysv --sort >$(@D)/.$(@F).1s.S
+ | $(guard) $(BASEDIR)/tools/symbols $(all_symbols) --sysv --sort >$(@D)/.$(@F).1s.S
$(guard) $(MAKE) -f $(BASEDIR)/Rules.mk $(@D)/.$(@F).1r.o $(@D)/.$(@F).1s.o
$(guard) $(LD) $(call EFI_LDFLAGS,$(VIRT_BASE)) -T efi.lds -N $< \
$(@D)/.$(@F).1r.o $(@D)/.$(@F).1s.o -o $@
static char name[KSYM_NAME_LEN + 1]; /* protected by xenpf_lock */
XEN_GUEST_HANDLE(char) nameh;
uint32_t namelen, copylen;
+ unsigned long addr;
guest_from_compat_handle(nameh, op->u.symdata.name);
ret = xensyms_read(&op->u.symdata.symnum, &op->u.symdata.type,
- &op->u.symdata.address, name);
-
+ &addr, name);
+ op->u.symdata.address = addr;
namelen = strlen(name) + 1;
if ( namelen > op->u.symdata.namelen )
# and xen_hello_world_func.o to be already compiled.
#
.PHONY: config.h
-config.h: OLD_CODE=$(call CODE_ADDR,$(BASEDIR)/xen-syms,xen_extra_version)
config.h: OLD_CODE_SZ=$(call CODE_SZ,$(BASEDIR)/xen-syms,xen_extra_version)
config.h: NEW_CODE_SZ=$(call CODE_SZ,$<,xen_hello_world)
config.h: xen_hello_world_func.o
(set -e; \
echo "#define NEW_CODE_SZ $(NEW_CODE_SZ)"; \
- echo "#define OLD_CODE_SZ $(OLD_CODE_SZ)"; \
- echo "#define OLD_CODE $(OLD_CODE)") > $@
+ echo "#define OLD_CODE_SZ $(OLD_CODE_SZ)") > $@
xen_hello_world.o: config.h
#include "config.h"
#include <xen/types.h>
+#include <xen/version.h>
#include <xen/xsplice.h>
#include <public/sysctl.h>
.version = XSPLICE_PAYLOAD_VERSION,
.name = hello_world_patch_this_fnc,
.new_addr = xen_hello_world,
- .old_addr = (void *)OLD_CODE,
+ .old_addr = xen_extra_version,
.new_size = NEW_CODE_SZ,
.old_size = OLD_CODE_SZ,
};
}
int xensyms_read(uint32_t *symnum, char *type,
- uint64_t *address, char *name)
+ unsigned long *address, char *name)
{
/*
* Symbols are most likely accessed sequentially so we remember position
return 0;
}
+
+unsigned long symbols_lookup_by_name(const char *symname)
+{
+ char name[KSYM_NAME_LEN + 1];
+ uint32_t symnum = 0;
+ char type;
+ unsigned long addr;
+ int rc;
+
+ if ( *symname == '\0' )
+ return 0;
+
+ do {
+ rc = xensyms_read(&symnum, &type, &addr, name);
+ if ( rc )
+ break;
+
+ if ( !strcmp(name, symname) )
+ return addr;
+
+ } while ( name[0] != '\0' );
+
+ return 0;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * tab-width: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
#include <xen/smp.h>
#include <xen/softirq.h>
#include <xen/spinlock.h>
+#include <xen/symbols.h>
#include <xen/vmap.h>
#include <xen/wait.h>
#include <xen/xsplice_elf.h>
struct list_head applied_list; /* Linked to 'applied_list'. */
struct xsplice_patch_func *funcs; /* The array of functions to patch. */
unsigned int nfuncs; /* Nr of functions to patch. */
+ const struct xsplice_symbol *symtab; /* All symbols. */
+ const char *strtab; /* Pointer to .strtab. */
+ unsigned int nsyms; /* Nr of entries in .strtab and symbols. */
char name[XEN_XSPLICE_NAME_SIZE]; /* Name of it. */
};
return 0;
}
+unsigned long xsplice_symbols_lookup_by_name(const char *symname)
+{
+ const struct payload *data;
+
+ ASSERT(spin_is_locked(&payload_lock));
+ list_for_each_entry ( data, &payload_list, list )
+ {
+ unsigned int i;
+
+ for ( i = 0; i < data->nsyms; i++ )
+ {
+ if ( !data->symtab[i].new_symbol )
+ continue;
+
+ if ( !strcmp(data->symtab[i].name, symname) )
+ return data->symtab[i].value;
+ }
+ }
+
+ return 0;
+}
+
static struct payload *find_payload(const char *name)
{
struct payload *data, *found = NULL;
rc = arch_xsplice_verify_func(f);
if ( rc )
return rc;
+
+ /* Lookup function's old address if not already resolved. */
+ if ( !f->old_addr )
+ {
+ f->old_addr = (void *)symbols_lookup_by_name(f->name);
+ if ( !f->old_addr )
+ {
+ f->old_addr = (void *)xsplice_symbols_lookup_by_name(f->name);
+ if ( !f->old_addr )
+ {
+ dprintk(XENLOG_ERR, XSPLICE "%s: Could not resolve old address of %s\n",
+ elf->name, f->name);
+ return -ENOENT;
+ }
+ }
+ dprintk(XENLOG_DEBUG, XSPLICE "%s: Resolved old address %s => %p\n",
+ elf->name, f->name, f->old_addr);
+ }
+ }
+
+ return 0;
+}
+
+static bool_t is_payload_symbol(const struct xsplice_elf *elf,
+ const struct xsplice_elf_sym *sym)
+{
+ if ( sym->sym->st_shndx == SHN_UNDEF ||
+ sym->sym->st_shndx >= elf->hdr->e_shnum )
+ return 0;
+
+ /*
+ * The payload is not a final image as we dynmically link against it.
+ * As such the linker has left symbols we don't care about and which
+ * binutils would have removed had it be a final image. Hence we:
+ * - For SHF_ALLOC - ignore symbols referring to sections that are not
+ * loaded.
+ */
+ if ( !(elf->sec[sym->sym->st_shndx].sec->sh_flags & SHF_ALLOC) )
+ return 0;
+
+ /* - And ignore empty symbols (\0). */
+ if ( *sym->name == '\0' )
+ return 0;
+
+ /*
+ * - For SHF_MERGE - ignore local symbols referring to mergeable sections.
+ * (ld squashes them all in one section and discards the symbols) when
+ * those symbols start with '.L' (like .LCx). Those are intermediate
+ * artifacts of assembly.
+ *
+ * See elf_link_input_bfd and _bfd_elf_is_local_label_name in binutils.
+ */
+ if ( (elf->sec[sym->sym->st_shndx].sec->sh_flags & SHF_MERGE) &&
+ !strncmp(sym->name, ".L", 2) )
+ return 0;
+
+ return 1;
+}
+
+static int build_symbol_table(struct payload *payload,
+ const struct xsplice_elf *elf)
+{
+ unsigned int i, j, nsyms = 0;
+ size_t strtab_len = 0;
+ struct xsplice_symbol *symtab;
+ char *strtab;
+
+ ASSERT(payload->nfuncs);
+
+ /* Recall that section @0 is always NULL. */
+ for ( i = 1; i < elf->nsym; i++ )
+ {
+ if ( is_payload_symbol(elf, elf->sym + i) )
+ {
+ nsyms++;
+ strtab_len += strlen(elf->sym[i].name) + 1;
+ }
+ }
+
+ symtab = xmalloc_array(struct xsplice_symbol, nsyms);
+ strtab = xmalloc_array(char, strtab_len);
+
+ if ( !strtab || !symtab )
+ {
+ xfree(strtab);
+ xfree(symtab);
+ return -ENOMEM;
}
+ nsyms = 0;
+ strtab_len = 0;
+ for ( i = 1; i < elf->nsym; i++ )
+ {
+ if ( is_payload_symbol(elf, elf->sym + i) )
+ {
+ symtab[nsyms].name = strtab + strtab_len;
+ symtab[nsyms].value = elf->sym[i].sym->st_value;
+ symtab[nsyms].new_symbol = 0; /* May be overwritten below. */
+ strtab_len += strlcpy(strtab + strtab_len, elf->sym[i].name,
+ KSYM_NAME_LEN) + 1;
+ nsyms++;
+ }
+ }
+
+ for ( i = 0; i < nsyms; i++ )
+ {
+ bool_t found = 0;
+
+ for ( j = 0; j < payload->nfuncs; j++ )
+ {
+ if ( symtab[i].value == (unsigned long)payload->funcs[j].new_addr )
+ {
+ found = 1;
+ break;
+ }
+ }
+
+ if ( !found )
+ {
+ if ( xsplice_symbols_lookup_by_name(symtab[i].name) )
+ {
+ dprintk(XENLOG_ERR, XSPLICE "%s: duplicate new symbol: %s\n",
+ elf->name, symtab[i].name);
+ xfree(symtab);
+ xfree(strtab);
+ return -EEXIST;
+ }
+ symtab[i].new_symbol = 1;
+ dprintk(XENLOG_DEBUG, XSPLICE "%s: new symbol %s\n",
+ elf->name, symtab[i].name);
+ }
+ else
+ {
+ /* new_symbol is not set. */
+ dprintk(XENLOG_DEBUG, XSPLICE "%s: overriding symbol %s\n",
+ elf->name, symtab[i].name);
+ }
+ }
+
+ payload->symtab = symtab;
+ payload->strtab = strtab;
+ payload->nsyms = nsyms;
+
return 0;
}
payload_cnt--;
payload_version++;
free_payload_data(data);
+ xfree((void *)data->symtab);
+ xfree((void *)data->strtab);
xfree(data);
}
if ( rc )
goto out;
+ rc = build_symbol_table(payload, &elf);
+ if ( rc )
+ goto out;
+
rc = secure_payload(payload, &elf);
out:
vfree(raw_data);
- if ( rc )
+ if ( rc && data )
+ {
+ xfree((void *)data->symtab);
+ xfree((void *)data->strtab);
xfree(data);
+ }
return rc;
}
#include <xen/errno.h>
#include <xen/lib.h>
+#include <xen/symbols.h>
#include <xen/xsplice_elf.h>
#include <xen/xsplice.h>
break;
case SHN_UNDEF:
- dprintk(XENLOG_ERR, XSPLICE "%s: Unknown symbol: %s\n",
- elf->name, elf->sym[i].name);
- rc = -ENOENT;
+ st_value = symbols_lookup_by_name(elf->sym[i].name);
+ if ( !st_value )
+ {
+ st_value = xsplice_symbols_lookup_by_name(elf->sym[i].name);
+ if ( !st_value )
+ {
+ dprintk(XENLOG_ERR, XSPLICE "%s: Unknown symbol: %s\n",
+ elf->name, elf->sym[i].name);
+ rc = -ENOENT;
+ break;
+ }
+ }
+ dprintk(XENLOG_DEBUG, XSPLICE "%s: Undefined symbol resolved: %s => %#"PRIxElfAddr"\n",
+ elf->name, elf->sym[i].name, st_value);
break;
case SHN_ABS:
#define SHF_WRITE 0x1 /* Writable */
#define SHF_ALLOC 0x2 /* occupies memory */
#define SHF_EXECINSTR 0x4 /* executable */
+#define SHF_MERGE 0x10 /* mergeable */
#define SHF_MASKPROC 0xf0000000 /* reserved bits for processor */
/* specific section attributes */
char *namebuf);
int xensyms_read(uint32_t *symnum, char *type,
- uint64_t *address, char *name);
+ unsigned long *address, char *name);
+
+unsigned long symbols_lookup_by_name(const char *symname);
#endif /*_XEN_SYMBOLS_H*/
/* ELF payload special section names. */
#define ELF_XSPLICE_FUNC ".xsplice.funcs"
+struct xsplice_symbol {
+ const char *name;
+ unsigned long value;
+ bool_t new_symbol;
+};
+
int xsplice_op(struct xen_sysctl_xsplice_op *);
void check_for_xsplice_work(void);
+unsigned long xsplice_symbols_lookup_by_name(const char *symname);
/* Arch hooks. */
int arch_xsplice_verify_elf(const struct xsplice_elf *elf);
projects / xen.git / commitdiff