Archipelago » qemu

block-modules = $(foreach o,$(block-obj-m),"$(basename $(subst /,-,$o))",) NULL

util/module.o-cflags = -D'CONFIG_BLOCK_MODULES=$(block-modules)'

  --with-confsuffix=SUFFIX suffix for QEMU data inside datadir/libdir/sysconfdir [$confsuffix]

for i in gthread-2.0 gmodule-2.0; do

    if $pkg_config --atleast-version=$glib_req_ver $i; then

        glib_cflags=`$pkg_config --cflags $i`

        glib_libs=`$pkg_config --libs $i`

        CFLAGS="$glib_cflags $CFLAGS"

        LIBS="$glib_libs $LIBS"

        libs_qga="$glib_libs $libs_qga"

    else

        error_exit "glib-$glib_req_ver $i is required to compile QEMU"

    fi

done

##########################################

# SHA command probe for modules

if test "$modules" = yes; then

    shacmd_probe="sha1sum sha1 shasum"

    for c in $shacmd_probe; do

        if which $c &>/dev/null; then

            shacmd="$c"

            break

        fi

    done

    if test "$shacmd" = ""; then

        error_exit "one of the checksum commands is required to enable modules: $shacmd_probe"

    fi

qemu_moddir=$libdir$confsuffix

echo "module directory  `eval echo $qemu_moddir`"

echo "qemu_moddir=$qemu_moddir" >> $config_host_mak

  # $shacmd can generate a hash started with digit, which the compiler doesn't

  # like as an symbol. So prefix it with an underscore

  echo "CONFIG_STAMP=_`(echo $qemu_version; echo $pkgversion; cat $0) | $shacmd - | cut -f1 -d\ `" >> $config_host_mak

#include "qemu/osdep.h"

#define DSO_STAMP_FUN         glue(qemu_stamp, CONFIG_STAMP)

#define DSO_STAMP_FUN_STR     stringify(DSO_STAMP_FUN)

#ifdef BUILD_DSO

void DSO_STAMP_FUN(void);

/* This is a dummy symbol to identify a loaded DSO as a QEMU module, so we can

 * distinguish "version mismatch" from "not a QEMU module", when the stamp

 * check fails during module loading */

void qemu_module_dummy(void);

#define module_init(function, type)                                         \

static void __attribute__((constructor)) do_qemu_init_ ## function(void)    \

{                                                                           \

    register_dso_module_init(function, type);                               \

}

#else

static void __attribute__((constructor)) do_qemu_init_ ## function(void)    \

{                                                                           \

#endif

void register_dso_module_init(void (*fn)(void), module_init_type type);

#include "config-host.h"

#include "qemu/module.h"

void qemu_module_dummy(void)

{

}

void DSO_STAMP_FUN(void)

{

}

	@# Copy to build root so modules can be loaded when program started without install

	$(if $(findstring /,$@),$(call quiet-command,cp $@ $(subst /,-,$@), "  CP    $(subst /,-,$@)"))

    $(eval $o-objs += module-common.o)

 DSOSUF=*)

    echo "#define HOST_DSOSUF \"${line#*=}\""

    ;;

#include <stdlib.h>

#include <gmodule.h>

    module_init_type type;

static ModuleTypeList dso_init_list;

static void init_lists(void)

    QTAILQ_INIT(&dso_init_list);

    init_lists();

    e->type = type;

void register_dso_module_init(void (*fn)(void), module_init_type type)

{

    ModuleEntry *e;

    init_lists();

    e = g_malloc0(sizeof(*e));

    e->init = fn;

    e->type = type;

    QTAILQ_INSERT_TAIL(&dso_init_list, e, node);

}

static void module_load(module_init_type type);

    module_load(type);

#ifdef CONFIG_MODULES

static int module_load_file(const char *fname)

{

    GModule *g_module;

    void (*sym)(void);

    const char *dsosuf = HOST_DSOSUF;

    int len = strlen(fname);

    int suf_len = strlen(dsosuf);

    ModuleEntry *e, *next;

    int ret;

    if (len <= suf_len || strcmp(&fname[len - suf_len], dsosuf)) {

        /* wrong suffix */

        ret = -EINVAL;

        goto out;

    }

    if (access(fname, F_OK)) {

        ret = -ENOENT;

        goto out;

    }

    assert(QTAILQ_EMPTY(&dso_init_list));

    g_module = g_module_open(fname, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);

    if (!g_module) {

        fprintf(stderr, "Failed to open module: %s\n",

                g_module_error());

        ret = -EINVAL;

        goto out;

    }

    if (!g_module_symbol(g_module, DSO_STAMP_FUN_STR, (gpointer *)&sym)) {

        fprintf(stderr, "Failed to initialize module: %s\n",

                fname);

        /* Print some info if this is a QEMU module (but from different build),

         * this will make debugging user problems easier. */

        if (g_module_symbol(g_module, "qemu_module_dummy", (gpointer *)&sym)) {

            fprintf(stderr,

                    "Note: only modules from the same build can be loaded.\n");

        }

        g_module_close(g_module);

        ret = -EINVAL;

    } else {

        QTAILQ_FOREACH(e, &dso_init_list, node) {

            register_module_init(e->init, e->type);

        }

        ret = 0;

    }

    QTAILQ_FOREACH_SAFE(e, &dso_init_list, node, next) {

        QTAILQ_REMOVE(&dso_init_list, e, node);

        g_free(e);

    }

out:

    return ret;

}

#endif

void module_load(module_init_type type)

{

#ifdef CONFIG_MODULES

    char *fname = NULL;

    const char **mp;

    static const char *block_modules[] = {

        CONFIG_BLOCK_MODULES

    };

    char *exec_dir;

    char *dirs[3];

    int i = 0;

    int ret;

    if (!g_module_supported()) {

        fprintf(stderr, "Module is not supported by system.\n");

        return;

    }

    switch (type) {

    case MODULE_INIT_BLOCK:

        mp = block_modules;

        break;

    default:

        /* no other types have dynamic modules for now*/

        return;

    }

    exec_dir = qemu_get_exec_dir();

    dirs[i++] = g_strdup_printf("%s", CONFIG_QEMU_MODDIR);

    dirs[i++] = g_strdup_printf("%s/..", exec_dir ? : "");

    dirs[i++] = g_strdup_printf("%s", exec_dir ? : "");

    assert(i == ARRAY_SIZE(dirs));

    g_free(exec_dir);

    exec_dir = NULL;

    for ( ; *mp; mp++) {

        for (i = 0; i < ARRAY_SIZE(dirs); i++) {

            fname = g_strdup_printf("%s/%s%s", dirs[i], *mp, HOST_DSOSUF);

            ret = module_load_file(fname);

            /* Try loading until loaded a module file */

            if (!ret) {

                break;

            }

            g_free(fname);

            fname = NULL;

        }

        if (ret == -ENOENT) {

            fprintf(stderr, "Can't find module: %s\n", *mp);

        }

        g_free(fname);

    }

    for (i = 0; i < ARRAY_SIZE(dirs); i++) {

        g_free(dirs[i]);

    }

#endif

}