EXPORT void
wire_model(void) {
int reader, upsamp, midear, gamma, haircell, tts, writer;
/* START TEST CONFIG */
reader = lookup_module("Reader");
writer = lookup_module("Writer");
wire_module(reader, 1, writer, 1);
return;
/* END TEST CONFIG */
upsamp = lookup_module("UpSample");
midear = lookup_module("MidEar");
gamma = lookup_module("Gamma");
haircell = lookup_module("Haircell");
tts = lookup_module("TTS");
writer = lookup_module("Writer");
wire_module(reader, 1, upsamp, 1);
wire_module(upsamp, 1, midear, 1);
wire_module(midear, 1, gamma, 1);
wire_module(gamma, 1, writer, 1);
}
EXPORT void
set_parameters_model(void) {
int reader, upsamp, midear, gamma, haircell, tts, writer;
reader = lookup_module("Reader");
set_parameters_module(reader, "sine_120dB.txt");
WaitModuleReady();
/* START TEST CONFIG */
writer = lookup_module("Writer");
set_parameters_module(writer, "writer.par");
WaitModuleReady();
/* END TEST CONFIG */
#ifdef REAL_CONFIG
upsamp = lookup_module("UpSample");
midear = lookup_module("MidEar");
gamma = lookup_module("Gamma");
haircell = lookup_module("Haircell");
tts = lookup_module("TTS");
writer = lookup_module("Writer");
set_parameters_module(upsamp, "upamp.par");
set_parameters_module(midear, "midear.par");
set_parameters_module(gamma, "gamma.par");
set_parameters_module(haircell, "haircell.par");
set_parameters_module(tts, "tts.par");
set_parameters_module(writer, "whale.out");
#endif
}
/**
* gwy_module_get_description:
* @name: Module name.
*
* Obtains the description of a registered module.
*
* Returns: The description as a string owned by the module.
**/
const gchar*
gwy_module_get_description(const gchar *name)
{
ModuleInfo *modinfo = lookup_module(name, TRUE, FALSE);
// FIXME: Translate here or later?
return modinfo ? modinfo->module_info->description : NULL;
}
// path in module specific load
oql_rc_t oqlDatabase::LoadSdlModule()
{
// for shore, scan a module
#ifndef NO_SDL
Ref<sdlModule> m;
// the name can be 1: an sdl module
// 2: a registered, sdl object
// 3: a directory.
// get a ref.
m = lookup_module(_name);
if (m==0)
{
errstream() << "couldn't find module" << _name;
return OQL_OK;
}
Ref<sdlDeclaration> bpt;
for (bpt = m->decl_list; bpt != 0; bpt = bpt->next)
// insert types in db.
{
Type *nt;
if(bpt->kind==TypeName)
{
nt = AddShoreType(bpt->type);
if (nt!=0)
{
if (nt->isObject()) {
// Add to the list of extents
extents.add(bpt->name, new SetType(nt));
}
}
else
errstream()<< "create_Type faied for "
<< bpt->name.string() << "in module " << _name;
}
}
#endif
// Assume that the _cat is open. Assume that the
// mutex has been taken
#ifdef NO_SDL
AutoMutex myMutex(*(_cat->mutex));
W_COERCE(myMutex.acquire());
uint4 numExtents = _cat->dbCache.extentCnt;
uint4 i;
if (numExtents) assert(t_array = new Type*[numExtents]);
// Now go thru each extent...
for (i = 0; i < numExtents; i++)
Do(_cat->extentCache[i], t_array[i]);
// That's it...
if (t_array) delete [] t_array;
#endif
return OQL_OK;
}
/*
* Attempt to load a TUX application module.
* This is the slow path, we cache ('link') the module's
* API vector to the inode.
* The module loading path is serialized, and we handshake
* with the loaded module and fetch its API vector.
*/
tcapi_template_t * lookup_tuxmodule (const char *filename)
{
tcapi_template_t *tcapi;
spin_lock(&tuxmodules_lock);
tcapi = lookup_module(filename);
if (!tcapi)
Dprintk("did not find module vfs:{%s}\n", filename);
spin_unlock(&tuxmodules_lock);
return tcapi;
}
static void include_modules(VALUE module, VALUE included_modules)
{
long j;
VALUE v;
VALUE name;
rb_check_type(included_modules, T_ARRAY);
for(j = 0; j < RARRAY_LEN(included_modules); ++j)
{
name = RARRAY_PTR(included_modules)[j];
v = lookup_module(name);
rb_funcall(module, rb_intern("include"), 1, v);
}
}
EXPORT void
init_model(void) {
float samplerate;
int inputsamples, samples, channels;
int id;
whale_init(&samplerate, &inputsamples, &samples, &channels);
printf("Sample rate %.3f: input samples %d, samples %d, channels %d\n",
samplerate, inputsamples, samples, channels);
/* Set runtime sizes in module i/o descriptors */
/* Reader */
id = lookup_module("Reader");
config_module_output(id, 1, inputsamples, 1, 1, 1);
/***********************/
/* START TEST CONFIG **/
id = lookup_module("Writer");
config_module_input(id, 1, inputsamples, 1, 1, 1);
return;
/* END TEST CONFIG */
/**********************/
/* Up Sample */
id = lookup_module("UpSample");
config_module_input(id, 1, inputsamples, 1, 1, 1);
config_module_output(id, 1, samples, 1, 1, 1);
/* Midear */
id = lookup_module("MidEar");
config_module_input(id, 1, samples, 1, 1, 1);
config_module_output(id, 1, samples, 1, 1, 1);
/* Gamma */
id = lookup_module("Gamma");
config_module_input(id, 1, samples, 1, 1, 1);
config_module_output(id, 1, samples, channels, 1, 1);
/* Haircell */
id = lookup_module("Haircell");
config_module_input(id, 1, samples, channels, 1, 1);
config_module_output(id, 1, samples, channels, 1, 1);
/* Writer */
id = lookup_module("Writer");
config_module_input(id, 1, samples, channels, 1, 1);
}
tcapi_template_t * unregister_tuxmodule (char *vfs_name)
{
tcapi_template_t *tcapi;
int err = 0;
spin_lock(&tuxmodules_lock);
tcapi = lookup_module(vfs_name);
if (!tcapi) {
Dprintk("huh, module %s not registered??\n", vfs_name);
err = -1;
} else {
list_del(&tcapi->modules);
Dprintk("TUX module %s unregistered.\n", vfs_name);
}
spin_unlock(&tuxmodules_lock);
return tcapi;
}
int register_tuxmodule (tcapi_template_t *tcapi)
{
int ret = -EEXIST;
spin_lock(&tuxmodules_lock);
if (lookup_module(tcapi->vfs_name)) {
Dprintk("module with VFS binding '%s' already registered!\n",
tcapi->vfs_name);
goto out;
}
list_add(&tcapi->modules, &tuxmodules_list);
ret = 0;
Dprintk("TUX module %s registered.\n", tcapi->vfs_name);
out:
spin_unlock(&tuxmodules_lock);
return ret;
}
static int
process_bind(char *lname)
{
Ref<sdlModule> bmod;
Set<Ref<sdlModule> > omods;
// first, [re]open stdout for appropriate name.
// do this outside of a transaction..
W_COERCE(Shore::begin_transaction(3));
bmod = lookup_module(lname);
if (bmod == 0) // null value
{
cerr << "couldn't find module " << lname << endl;
return -1;
}
omods.add(bmod);
if (open_output_file(lname)==0)
print_cxx_binding(omods);
// this should be a readonly transaction, so never commit.
SH_DO(SH_COMMIT_TRANSACTION);
return 0;
}
static int
process_link(char *lname)
// process the string as the name of an sdl module object.
{
Ref<sdlModule> lmod;
int errcount;
W_COERCE(Shore::begin_transaction(3));
lmod = lookup_module(lname);
sdl_linking = 1;
if (lmod!= 0)
{
lmod.update()->resolve_types();
if (sdl_errors)
{
cerr << sdl_errors << " found linking module " << lname << endl;
Shore::abort_transaction();
return sdl_errors;
}
}
SH_DO(SH_COMMIT_TRANSACTION);
return 0;
}
/**
* gwy_module_get_copyright:
* @name: Module name.
*
* Obtains the copyright holder of a registered module.
*
* Returns: The copyright holder as a string owned by the module.
**/
const gchar*
gwy_module_get_copyright(const gchar *name)
{
ModuleInfo *modinfo = lookup_module(name, TRUE, FALSE);
return modinfo ? modinfo->module_info->copyright : NULL;
}
/**
* gwy_module_get_date:
* @name: Module name.
*
* Obtains the date of a registered module.
*
* Returns: The date as a string owned by the module.
**/
const gchar*
gwy_module_get_date(const gchar *name)
{
ModuleInfo *modinfo = lookup_module(name, TRUE, FALSE);
return modinfo ? modinfo->module_info->date : NULL;
}
static void
set_param(char *lvalue, char *rvalue, int param_level)
{
int param_index;
char module[255], variable[255];
int num_items;
param_index = lookup_name(lvalue);
if (param_index == -1)
{
num_items = sscanf(lvalue, "%[^_]_%s", module, variable);
if (num_items != 2) {
carmen_warn("Ill-formed parameter name %s%s%s. Could not find "
"module and variable name.\n"
"Not setting this parameter.\n", carmen_red_code,
lvalue, carmen_normal_code);
return;
}
check_param_space();
param_index = num_params;
num_params++;
param_list[param_index].lvalue = (char *)calloc
(strlen(lvalue)+1, sizeof(char));
carmen_test_alloc(param_list[param_index].lvalue);
strcpy(param_list[param_index].lvalue, lvalue);
param_list[param_index].module_name = (char *)calloc
(strlen(module)+1, sizeof(char));
carmen_test_alloc(param_list[param_index].module_name);
strcpy(param_list[param_index].module_name, module);
if (lookup_module(module) == -1)
add_module(module);
param_list[param_index].variable_name = (char *)calloc
(strlen(variable)+1, sizeof(char));
carmen_test_alloc(param_list[param_index].variable_name);
strcpy(param_list[param_index].variable_name, variable);
if (param_level == PARAM_LEVEL_NOCHANGE)
param_level = PARAM_LEVEL_BASIC;
}
else
{
free(param_list[param_index].rvalue);
}
param_list[param_index].rvalue = (char *)calloc
(strlen(rvalue)+1, sizeof(char));
carmen_test_alloc(param_list[param_index].rvalue);
strcpy(param_list[param_index].rvalue, rvalue);
if (param_level != PARAM_LEVEL_NOCHANGE)
param_list[param_index].expert = param_level;
carmen_verbose("Added %s %s%s: %s = %s \n",
param_list[param_index].module_name,
param_list[param_index].variable_name,
param_list[param_index].expert ? " (expert)" : "",
param_list[param_index].lvalue,
param_list[param_index].rvalue);
publish_new_param(param_index);
}
errval_t spawn_xcore_monitor(coreid_t coreid, int hwid,
enum cpu_type cpu_type,
const char *cmdline,
struct frame_identity urpc_frame_id,
struct capref kcb)
{
uint64_t start = 0;
const char *monitorname = NULL, *cpuname = NULL;
genpaddr_t arch_page_size;
errval_t err;
err = get_architecture_config(cpu_type, &arch_page_size,
&monitorname, &cpuname);
assert(err_is_ok(err));
DEBUG("loading kernel: %s\n", cpuname);
DEBUG("loading 1st app: %s\n", monitorname);
// compute size of frame needed and allocate it
DEBUG("%s:%s:%d: urpc_frame_id.base=%"PRIxGENPADDR"\n",
__FILE__, __FUNCTION__, __LINE__, urpc_frame_id.base);
DEBUG("%s:%s:%d: urpc_frame_id.size=%d\n",
__FILE__, __FUNCTION__, __LINE__, urpc_frame_id.bits);
if (benchmark_flag) {
start = bench_tsc();
}
static size_t cpu_binary_size;
static lvaddr_t cpu_binary = 0;
static genpaddr_t cpu_binary_phys;
static const char* cached_cpuname = NULL;
if (cpu_binary == 0) {
cached_cpuname = cpuname;
// XXX: Caching these for now, until we have unmap
err = lookup_module(cpuname, &cpu_binary, &cpu_binary_phys,
&cpu_binary_size);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Can not lookup module");
return err;
}
}
// Ensure caching actually works and we're
// always loading same binary. If this starts to fail, get rid of caching.
assert (strcmp(cached_cpuname, cpuname) == 0);
static size_t monitor_binary_size;
static lvaddr_t monitor_binary = 0;
static genpaddr_t monitor_binary_phys;
static const char* cached_monitorname = NULL;
if (monitor_binary == 0) {
cached_monitorname = monitorname;
// XXX: Caching these for now, until we have unmap
err = lookup_module(monitorname, &monitor_binary,
&monitor_binary_phys, &monitor_binary_size);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Can not lookup module");
return err;
}
}
// Again, ensure caching actually worked (see above)
assert (strcmp(cached_monitorname, monitorname) == 0);
if (benchmark_flag) {
bench_data->load = bench_tsc() - start;
start = bench_tsc();
}
struct capref cpu_memory_cap;
struct frame_identity frameid;
size_t cpu_memory;
err = allocate_kernel_memory(cpu_binary, arch_page_size,
&cpu_memory_cap, &cpu_memory, &frameid);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Can not allocate space for new app kernel.");
return err;
}
err = cap_mark_remote(cpu_memory_cap);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Can not mark cap remote.");
return err;
}
void *cpu_buf_memory;
err = vspace_map_one_frame(&cpu_buf_memory, cpu_memory, cpu_memory_cap,
NULL, NULL);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_VSPACE_MAP);
}
if (benchmark_flag) {
bench_data->alloc_cpu = bench_tsc() - start;
start = bench_tsc();
}
/* Chunk of memory to load monitor on the app core */
struct capref spawn_memory_cap;
struct frame_identity spawn_memory_identity;
err = frame_alloc_identify(&spawn_memory_cap,
X86_CORE_DATA_PAGES * arch_page_size,
NULL, &spawn_memory_identity);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_FRAME_ALLOC);
}
err = cap_mark_remote(spawn_memory_cap);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Can not mark cap remote.");
return err;
}
if (benchmark_flag) {
bench_data->alloc_mon = bench_tsc() - start;
start = bench_tsc();
}
/* Load cpu */
struct elf_allocate_state state;
state.vbase = (char *)cpu_buf_memory + arch_page_size;
assert(sizeof(struct x86_core_data) <= arch_page_size);
state.elfbase = elf_virtual_base(cpu_binary);
struct Elf64_Ehdr *cpu_head = (struct Elf64_Ehdr *)cpu_binary;
genvaddr_t cpu_entry;
err = elf_load(cpu_head->e_machine, elfload_allocate, &state,
cpu_binary, cpu_binary_size, &cpu_entry);
if (err_is_fail(err)) {
return err;
}
if (benchmark_flag) {
bench_data->elf_load = bench_tsc() - start;
start = bench_tsc();
}
err = relocate_cpu_binary(cpu_binary, cpu_head, state, frameid, arch_page_size);
if (err_is_fail(err)) {
DEBUG_ERR(err, "Can not relocate new kernel.");
return err;
}
if (benchmark_flag) {
bench_data->elf_reloc = bench_tsc() - start;
}
genvaddr_t cpu_reloc_entry = cpu_entry - state.elfbase
+ frameid.base + arch_page_size;
/* Compute entry point in the foreign address space */
forvaddr_t foreign_cpu_reloc_entry = (forvaddr_t)cpu_reloc_entry;
/* Setup the core_data struct in the new kernel */
struct x86_core_data *core_data = (struct x86_core_data *)cpu_buf_memory;
switch (cpu_head->e_machine) {
case EM_X86_64:
case EM_K1OM:
core_data->elf.size = sizeof(struct Elf64_Shdr);
core_data->elf.addr = cpu_binary_phys + (uintptr_t)cpu_head->e_shoff;
core_data->elf.num = cpu_head->e_shnum;
break;
case EM_386:
core_data->elf.size = sizeof(struct Elf32_Shdr);
struct Elf32_Ehdr *head32 = (struct Elf32_Ehdr *)cpu_binary;
core_data->elf.addr = cpu_binary_phys + (uintptr_t)head32->e_shoff;
core_data->elf.num = head32->e_shnum;
break;
default:
return SPAWN_ERR_UNKNOWN_TARGET_ARCH;
}
core_data->module_start = cpu_binary_phys;
core_data->module_end = cpu_binary_phys + cpu_binary_size;
core_data->urpc_frame_base = urpc_frame_id.base;
core_data->urpc_frame_bits = urpc_frame_id.bits;
core_data->monitor_binary = monitor_binary_phys;
core_data->monitor_binary_size = monitor_binary_size;
core_data->memory_base_start = spawn_memory_identity.base;
core_data->memory_bits = spawn_memory_identity.bits;
core_data->src_core_id = disp_get_core_id();
core_data->src_arch_id = my_arch_id;
core_data->dst_core_id = coreid;
struct frame_identity fid;
err = invoke_frame_identify(kcb, &fid);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "Invoke frame identity for KCB failed. "
"Did you add the syscall handler for that architecture?");
}
DEBUG("%s:%s:%d: fid.base is 0x%"PRIxGENPADDR"\n",
__FILE__, __FUNCTION__, __LINE__, fid.base);
core_data->kcb = (genpaddr_t) fid.base;
#ifdef CONFIG_FLOUNDER_BACKEND_UMP_IPI
core_data->chan_id = chanid;
#endif
if (cmdline != NULL) {
// copy as much of command line as will fit
snprintf(core_data->kernel_cmdline, sizeof(core_data->kernel_cmdline),
"%s %s", cpuname, cmdline);
// ensure termination
core_data->kernel_cmdline[sizeof(core_data->kernel_cmdline) - 1] = '\0';
DEBUG("%s:%s:%d: %s\n", __FILE__, __FUNCTION__, __LINE__, core_data->kernel_cmdline);
}
/* Invoke kernel capability to boot new core */
if (cpu_type == CPU_X86_64 || cpu_type == CPU_K1OM) {
start_aps_x86_64_start(hwid, foreign_cpu_reloc_entry);
}
#ifndef __k1om__
else if (cpu_type == CPU_X86_32) {
start_aps_x86_32_start(hwid, foreign_cpu_reloc_entry);
}
#endif
/* Clean up */
// XXX: Should not delete the remote caps?
err = cap_destroy(spawn_memory_cap);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "cap_destroy failed");
}
err = vspace_unmap(cpu_buf_memory);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "vspace unmap CPU driver memory failed");
}
err = cap_destroy(cpu_memory_cap);
if (err_is_fail(err)) {
USER_PANIC_ERR(err, "cap_destroy failed");
}
return SYS_ERR_OK;
}
int main(int argc, char **argv) {
GetOpt opt(argc,argv,"8vfcSLBDs:l:b:d:o:r:");
int c, rc;
argv0 = argv[0];
while ((c = opt()) != EOF) {
switch (c) {
case '8': // 8 byte serial #; for janet only.
long_oids = 1;
break;
case 'v': // verbose
verbose_flag = 1;
break;
case 'f' : // overwrite existing module if found.
overwrite_module = 1;
break;
case 'c' : // syntax check only
scheck_only = 1;
break;
case 'S': // read from standard input
src_args[src_count++] = "-";
break;
case 'B': // print out language binding for all modules processed.
bind_all = 1;
break;
case 'L': // link all modules processed (from source).
link_all = 1;
break;
case 'D':
debug++;
break;
case 's':
src_args[src_count++] = opt.optarg;
break;
case 'r':
rm_args[rm_count++] = opt.optarg;
break;
case 'l':
link_args[link_count++] = opt.optarg;
break;
case 'b':
bind_args[bind_count++] = opt.optarg;
break;
case 'd':
dir_args[dir_count++] = opt.optarg;
break;
case 'o':
if (output_arg)
{
cerr << "only one output file name allowed" <<endl;
usage(argv[0]);
}
output_arg = opt.optarg;
break;
default:
usage(argv[0]);
return 1;
}
}
int i;
if (debug || verbose_flag) {
fprintf(stderr,"sdl: command line was\n\t");
for (i = 0; i < argc; i++)
fprintf(stderr,"%s ",argv[i]);
fprintf(stderr,"\n");
if (src_count>0)
{
fprintf(stderr,"compiling sdl source files: ");
for (i = 0; i<src_count; i++)
fprintf(stderr,"%s ",src_args[i]);
fprintf(stderr,"\n");
}
if (link_count>0)
{
fprintf(stderr,"linking moudles: ");
for (i = 0; i<link_count; i++)
fprintf(stderr,"%s ",link_args[i]);
fprintf(stderr,"\n");
}
if (bind_count>0)
{
fprintf(stderr,"creating language binding for modules: ");
for (i = 0; i<bind_count; i++)
fprintf(stderr,"%s ",bind_args[i]);
fprintf(stderr,"\n");
}
if (dir_count>0)
{
fprintf(stderr,"shore directory search path: ");
for (i = 0; i<dir_count; i++)
fprintf(stderr,"%s ",dir_args[i]);
fprintf(stderr,"\n");
}
if ( bind_all)
fprintf(stderr,"-B: printing language binding for all source processed\n");
if ( link_all)
fprintf(stderr,"-L: linking modules for all source processed\n");
if ( overwrite_module)
fprintf(stderr,"-f: deleting existing modules\n");
if (scheck_only)
fprintf(stderr,"-c: syntax check only\n");
}
// initialization:
if (!scheck_only)
metaobj_init(argc,argv);
if (src_count)
insert_rwords();
if (dir_count)
{
w_rc_t crc;
for (i=0; i<dir_count; i++)
add_dir(dir_args[i]);
// also, chdir to 1st dir arg, creating it if necessary.
W_COERCE(Shore::begin_transaction(3));
crc = Shore::chdir(dir_args[0]);
if (crc)
{
if (crc.err_num() != SH_NotFound)
crc.fatal(); //give up
SH_DO(Shore::mkdir(dir_args[0],0755));
SH_DO(Shore::chdir(dir_args[0]));
}
SH_DO(SH_COMMIT_TRANSACTION);
}
// first, remove anything specified by -r
if (rm_count >0)
rm_files(rm_count,rm_args);
for (i = 0; i<src_count; i++) {
if ((rc = process_src( src_args[i])))
return rc;
if (sdl_errors)
{
fprintf(stderr,"found %d errors processing sdl source file %s\n",
sdl_errors,src_args[i]);
return sdl_errors;
}
}
if (src_count && (g_module_list!= 0)) // say what we created
{
char * m_dir = dir_count? dir_args[0]: "/types";
W_COERCE(Shore::begin_transaction(3));
Ref<sdlDeclaration> lpt;
for (lpt = g_module_list; lpt != NULL; lpt = lpt->next)
fprintf(stderr,"created module %s/%s\n",m_dir,(char *)lpt->name);
SH_DO(SH_COMMIT_TRANSACTION);
}
if ( scheck_only && (link_count || bind_all || bind_count))
{
fprintf(stderr,"cannot link or bind with -c flag\n");
return sdl_errors;
}
if (link_all)
if (rc = link_all_modules())
return rc;
for (i = 0; i < link_count; i++) {
if ((rc = process_link( link_args[i])))
return rc;
}
if (bind_all) //orint all bindings from src module list
if (rc = print_all_bindings())
return rc;
if (bind_count == 1) // old style binding printout
{
if ((rc = process_bind(bind_args[i])))
return rc;
}
else if (bind_count > 0)
{
Set<Ref<sdlModule> > omods;
W_COERCE(Shore::begin_transaction(3));
for (i = 0; i < bind_count; i++)
{
Ref<sdlModule> bmod;
bmod = lookup_module(bind_args[i]);
if (bmod == 0) // null value
{
cerr << "couldn't find module " << bind_args[i] << endl;
break;
}
omods.add(bmod);
}
if (omods.get_size()>0
&& open_output_file(omods.get_elt(0)->name.string()) == 0)
print_cxx_binding(omods);
W_COERCE(SH_COMMIT_TRANSACTION);
}
return sdl_errors;
}
/**
* gwy_module_get_version:
* @name: Module name.
*
* Obtains the version of a registered module.
*
* Returns: The version as a string owned by the module.
**/
const gchar*
gwy_module_get_version(const gchar *name)
{
ModuleInfo *modinfo = lookup_module(name, TRUE, FALSE);
return modinfo ? modinfo->module_info->version : NULL;
}
