1

#include "module.h"

     2

#include "log.h"

     3

     4

#include <stdlib.h>

     5

#include <unistd.h>

     6

#include <dlfcn.h>

     7

#include <string.h>

     8

#include <assert.h>

     9

    10

err_t modules_create (struct modules **modules_ptr, struct nexus *nexus)

    11

{

    12

    struct modules *modules;

    13

    14

    // alloc

    15

    if ((modules = calloc(1, sizeof(*modules))) == NULL)

    16

        return ERR_CALLOC;

    17

    18

    // init

    19

    TAILQ_INIT(&modules->list);

    20

    21

    // store

    22

    modules->nexus = nexus;

    23

    24

    // ok

    25

    *modules_ptr = modules;

    26

    27

    return SUCCESS;

    28

}

    29

    30

const char* modules_path (struct modules *modules, const char *path)

    31

{

    32

    const char *old_path = modules->path;

    33

    34

    if (path)

    35

        // replace

    36

        modules->path = path;

    37

    38

    return old_path;

    39

}

    40

    41

/**

    42

 * module_get without the refcount stuff

    43

 */

    44

static struct module* modules_lookup (struct modules *modules, const char *name)

    45

{

    46

    struct module *module = NULL;

    47

    48

    // look for it...

    49

    TAILQ_FOREACH(module, &modules->list, modules_list) {

    50

        if (strcasecmp(module->info.name, name) == 0) {

    51

            // found it

    52

            return module;

    53

        }

    54

    }

    55

    56

    // no such module

    57

    return NULL;

    58

}

    59

    60

struct module* modules_get (struct modules *modules, const char *name)

    61

{

    62

    struct module *module;

    63

    64

    // get it

    65

    if (!(module = modules_lookup(modules, name)))

    66

        return NULL;

    67

    68

    // up the refcount

    69

    module->refcount++;

    70

    71

    // ok

    72

    return module;

    73

}

    74

    75

err_t modules_unload (struct modules *modules)

    76

{

    77

    struct module *module;

    78

    err_t err;

    79

    80

    // unload each module in turn

    81

    while ((module = TAILQ_FIRST(&modules->list))) {

    82

        if ((err = module_unload(module)))

    83

            log_warn("module_unload(%s) failed: %s", module->info.name, error_name(err));

    84

    }

    85

    86

    // ok

    87

    return SUCCESS;

    88

}

    89

    90

void modules_destroy (struct modules *modules)

    91

{

    92

    struct module *module;

    93

    94

    // destroy each module

    95

    while ((module = TAILQ_FIRST(&modules->list)))

    96

        module_destroy(module);

    97

    98

    // ourselves

    99

    free(modules);

   100

}

   101

   102

   103

const char* module_name (struct module *module)

   104

{

   105

    return module ? module->info.name : NULL;

   106

}

   107

   108

/**

   109

 * Load the symbol named "<module>_<suffix>".

   110

 */ 

   111

static err_t module_symbol (struct module *module, void **sym, const char *suffix)

   112

{

   113

    char sym_name[MODULE_SYMBOL_MAX];

   114

   115

    // validate the length of the suffix

   116

    assert(strlen(module->info.name) <= MODULE_NAME_MAX);

   117

    assert(strlen(suffix) <= MODULE_SUFFIX_MAX);

   118

   119

    // format

   120

    sprintf(sym_name, "%s_%s", module->info.name, suffix);

   121

   122

    // load

   123

    if ((*sym = dlsym(module->handle, sym_name)) == NULL)

   124

       return ERR_MODULE_SYM;

   125

   126

    // ok

   127

    return SUCCESS;

   128

}

   129

   130

/**

   131

 * XXX: ugly function to format to a dynamically allocated string

   132

 */

   133

char *strfmt (const char *fmt, ...)

   134

{

   135

    va_list vargs;

   136

    size_t len;

   137

    char *buf;

   138

   139

    // figure out the length of the resulting string

   140

    va_start(vargs, fmt);

   141

   142

    len = vsnprintf(NULL, 0, fmt, vargs) + 1;

   143

   144

    va_end(vargs);

   145

   146

    // malloc

   147

    if ((buf = malloc(len)) == NULL)

   148

        return NULL;

   149

   150

    // format

   151

    va_start(vargs, fmt);

   152

   153

    vsnprintf(buf, len, fmt, vargs);

   154

   155

    va_end(vargs);

   156

   157

    // ok

   158

    return buf;

   159

}

   160

   161

/**

   162

 * Looks up a module's path by name, returning a dynamically allocated string with the path on success

   163

 */

   164

static char* module_find (struct modules *modules, struct module_info *info, struct error_info *err)

   165

{

   166

    char *path = NULL;

   167

   168

    // build the path...

   169

    if ((path = strfmt("%s/mod_%s.so", modules->path, info->name)) == NULL)

   170

        JUMP_SET_ERROR(err, ERR_STRDUP);

   171

   172

    // exists and readable?

   173

    if (access(path, R_OK))

   174

        // XXX: this doesn't contain the path...

   175

        JUMP_SET_ERROR_STR(err, ERR_MODULE_PATH, "module not found in search path");

   176

   177

    // ok

   178

    return path;

   179

   180

error:

   181

    // release the dynamically allocated path

   182

    free(path);

   183

   184

    return NULL;

   185

}

   186

   187

err_t module_load (struct modules *modules, struct module **module_ptr, const struct module_info *_info, struct error_info *err)

   188

{

   189

    struct module *module;

   190

   191

    // validate the module name

   192

    if (strlen(_info->name) > MODULE_NAME_MAX)

   193

        return SET_ERROR(err, ERR_MODULE_NAME);

   194

   195

    // already open with the same name?

   196

    if (modules_lookup(modules, _info->name))

   197

        return SET_ERROR(err, ERR_MODULE_DUP);

   198

   199

    // alloc

   200

    if ((module = calloc(1, sizeof(*module))) == NULL)

   201

        return SET_ERROR(err, ERR_CALLOC);

   202

   203

    // initialize

   204

    module->info = *_info;

   205

    module->modules = modules;

   206

    module->refcount = 1;

   207

   208

    // add to modules list

   209

    TAILQ_INSERT_TAIL(&modules->list, module, modules_list);

   210

   211

    // lookup path?

   212

    if (!module->info.path) {

   213

        // have a search path?

   214

        if (!modules->path)

   215

            JUMP_SET_ERROR_STR(err, ERR_MODULE_PATH, "no module search path defined");

   216

   217

        // try and resolve the path automatically

   218

        if ((module->path_buf = module_find(modules, &module->info, err)) == NULL)

   219

            goto error;

   220

   221

        // use that path

   222

        module->info.path = module->path_buf;

   223

    }

   224

   225

    // clear dlerrors

   226

    (void) dlerror();

   227

   228

    // load it

   229

    if ((module->handle = dlopen(module->info.path, RTLD_NOW)) == NULL)

   230

        JUMP_SET_ERROR_STR(err, ERR_MODULE_OPEN, dlerror());

   231

   232

    // load the funcs symbol

   233

    if ((ERROR_CODE(err) = module_symbol(module, (void **) &module->desc, "module")))

   234

        JUMP_SET_ERROR_STR(err, ERROR_CODE(err), dlerror());

   235

   236

    // call the init func

   237

    if ((module->desc->init(modules->nexus, &module->ctx, err)))

   238

        goto error;

   239

   240

    // ok

   241

    if (module_ptr) {

   242

        module->refcount++;

   243

        *module_ptr = module;

   244

    }

   245

   246

    return SUCCESS;

   247

   248

error:

   249

    // cleanup

   250

    module->refcount = 0;

   251

    module_destroy(module);

   252

   253

    return ERROR_CODE(err);    

   254

}

   255

   256

void module_put (struct module *module)

   257

{

   258

    assert(module->refcount > 0);

   259

   260

    // decrement, just return if still alive

   261

    if (--module->refcount > 0)

   262

        return;

   263

   264

    // refcount zero, destroy

   265

    module_destroy(module);

   266

}

   267

   268

err_t module_conf_raw (struct module *module, const char *name, char *value, struct error_info *err)

   269

{

   270

    // sanity-check

   271

    if (!module->desc->config_options)

   272

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "module does not have any config options");

   273

   274

    // wrong state

   275

    if (module->unloading)

   276

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "module is being unloaded");

   277

   278

    // parse/apply using the module's stuff    

   279

    return config_apply_raw(module->desc->config_options, module->modules->nexus, module->ctx, name, value, err);

   280

}

   281

   282

const struct config_option* module_conf_lookup (struct module *module, const char *name, struct error_info *err)

   283

{

   284

    // sanity-check

   285

    if (!module->desc->config_options)

   286

        JUMP_SET_ERROR_STR(err, ERR_MODULE_CONF, "module does not have any config options");

   287

   288

    // direct lookup

   289

    return config_lookup(module->desc->config_options, name, err);

   290

   291

error:

   292

    return NULL;    

   293

}

   294

   295

err_t module_conf (struct module *module, const struct config_option *opt, const struct config_value *value, struct error_info *err)

   296

{

   297

    // wrong state

   298

    if (module->unloading)

   299

        RETURN_SET_ERROR_STR(err, ERR_MODULE_CONF, "module is being unloaded");

   300

   301

    // apply with the module's ctx

   302

    return config_apply_opt(opt, module->ctx, value, err);

   303

}

   304

   305

err_t module_unload (struct module *module)

   306

{

   307

    err_t err;

   308

   309

    // wrong state

   310

    if (module->unloading)

   311

        return ERR_MODULE_STATE;

   312

   313

    // remove from modules list

   314

    TAILQ_REMOVE(&module->modules->list, module, modules_list);

   315

   316

    // update status

   317

    module->unloading = true;

   318

   319

    if (module->desc->unload) {

   320

        // invoke the unload func, passing it our reference

   321

        // note that the module might not exist anymore after calling this

   322

        if ((err = module->desc->unload(module->ctx, module))) {

   323

            // mark it as "unloaded"

   324

            module_unloaded(module);

   325

   326

            return err;

   327

        }

   328

   329

    } else {

   330

        // no unload procedure, just destroy it as soon as needed

   331

        module_unloaded(module);

   332

   333

    }

   334

    // ok

   335

    return SUCCESS;

   336

}

   337

   338

/**

   339

 * A wrapper for module_destroy suitable for use as a libevent callback

   340

 */

   341

static void _module_destroy (int fd, short what, void *arg)

   342

{

   343

    struct module *module = arg;

   344

   345

    (void) fd;

   346

    (void) what;

   347

   348

    // execute

   349

    module_destroy(module);

   350

}

   351

   352

void module_unloaded (struct module *module)

   353

{

   354

    struct timeval tv = { 0, 0 };

   355

    assert(module->refcount > 0);

   356

   357

    // decrement, just return if still alive

   358

    if (--module->refcount > 0)

   359

        return;

   360

   361

    // schedule a deferred module_destroy

   362

    if (event_base_once(module->modules->nexus->ev_base, -1, EV_TIMEOUT, &_module_destroy, module, &tv))

   363

        // XXX: how to reach?

   364

        log_fatal("event_base_once failed, unable to schedule deferred module_destroy");

   365

}

   366

   367

void module_destroy (struct module *module)

   368

{

   369

    // XXX: warn about destroy with significant refcount...

   370

    if (module->refcount)

   371

        log_warn("destroying module %s with refcount>0: %zu", module_name(module), module->refcount);

   372

    else

   373

        log_debug("destroying module %s", module_name(module));

   374

   375

    // still need to remove from modules_list?

   376

    if (!module->unloading)

   377

        TAILQ_REMOVE(&module->modules->list, module, modules_list);

   378

   379

    // run the destroy hook

   380

    if (module->desc && module->desc->destroy && module->ctx)

   381

        module->desc->destroy(module->ctx);

   382

   383

    // unload the dl handle

   384

    if (module->handle && dlclose(module->handle))

   385

        log_error("dlclose(%s): %s", module->info.name, dlerror());

   386

   387

    // release the path buf, if any

   388

    free(module->path_buf);

   389

   390

    // free the module info

   391

    free(module);

   392

}

   393

   394