libkmod/libkmod.c

   1 /*
   2  * libkmod - interface to kernel module operations
   3  *
   4  * Copyright (C) 2011-2012  ProFUSION embedded systems
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stddef.h>
  24 #include <stdarg.h>
  25 #include <limits.h>
  26 #include <unistd.h>
  27 #include <errno.h>
  28 #include <fnmatch.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31 #include <sys/utsname.h>
  32 #include <sys/stat.h>
  33
  34 #include "libkmod.h"
  35 #include "libkmod-private.h"
  36 #include "libkmod-index.h"
  37
  38 #define KMOD_HASH_SIZE (256)
  39 #define KMOD_LRU_MAX (128)
  40 #define _KMOD_INDEX_MODULES_SIZE KMOD_INDEX_MODULES_SYMBOL + 1
  41
  42 /**
  43  * SECTION:libkmod
  44  * @short_description: libkmod context
  45  *
  46  * The context contains the default values for the library user,
  47  * and is passed to all library operations.
  48  */
  49
  50 static struct _index_files {
  51         const char *fn;
  52         const char *prefix;
  53 } index_files[] = {
  54         [KMOD_INDEX_MODULES_DEP] = { .fn = "modules.dep", .prefix = "" },
  55         [KMOD_INDEX_MODULES_ALIAS] = { .fn = "modules.alias", .prefix = "alias " },
  56         [KMOD_INDEX_MODULES_SYMBOL] = { .fn = "modules.symbols", .prefix = "alias "},
  57 };
  58
  59 static const char *default_config_paths[] = {
  60         "/run/modprobe.d",
  61         SYSCONFDIR "/modprobe.d",
  62         ROOTPREFIX "/lib/modprobe.d",
  63         NULL
  64 };
  65
  66 /**
  67  * kmod_ctx:
  68  *
  69  * Opaque object representing the library context.
  70  */
  71 struct kmod_ctx {
  72         int refcount;
  73         int log_priority;
  74         void (*log_fn)(void *data,
  75                         int priority, const char *file, int line,
  76                         const char *fn, const char *format, va_list args);
  77         void *log_data;
  78         const void *userdata;
  79         char *dirname;
  80         struct kmod_config *config;
  81         struct hash *modules_by_name;
  82         struct index_mm *indexes[_KMOD_INDEX_MODULES_SIZE];
  83         unsigned long long indexes_stamp[_KMOD_INDEX_MODULES_SIZE];
  84 };
  85
  86 void kmod_log(const struct kmod_ctx *ctx,
  87                 int priority, const char *file, int line, const char *fn,
  88                 const char *format, ...)
  89 {
  90         va_list args;
  91
  92         if (ctx->log_fn == NULL)
  93                 return;
  94
  95         va_start(args, format);
  96         ctx->log_fn(ctx->log_data, priority, file, line, fn, format, args);
  97         va_end(args);
  98 }
  99
 100 static void log_filep(void *data,
 101                         int priority, const char *file, int line,
 102                         const char *fn, const char *format, va_list args)
 103 {
 104         FILE *fp = data;
 105         fprintf(fp, "libkmod: %s: ", fn);
 106         vfprintf(fp, format, args);
 107 }
 108
 109 const char *kmod_get_dirname(const struct kmod_ctx *ctx)
 110 {
 111         return ctx->dirname;
 112 }
 113
 114 /**
 115  * kmod_get_userdata:
 116  * @ctx: kmod library context
 117  *
 118  * Retrieve stored data pointer from library context. This might be useful
 119  * to access from callbacks.
 120  *
 121  * Returns: stored userdata
 122  */
 123 KMOD_EXPORT void *kmod_get_userdata(const struct kmod_ctx *ctx)
 124 {
 125         if (ctx == NULL)
 126                 return NULL;
 127         return (void *)ctx->userdata;
 128 }
 129
 130 /**
 131  * kmod_set_userdata:
 132  * @ctx: kmod library context
 133  * @userdata: data pointer
 134  *
 135  * Store custom @userdata in the library context.
 136  */
 137 KMOD_EXPORT void kmod_set_userdata(struct kmod_ctx *ctx, const void *userdata)
 138 {
 139         if (ctx == NULL)
 140                 return;
 141         ctx->userdata = userdata;
 142 }
 143
 144 static int log_priority(const char *priority)
 145 {
 146         char *endptr;
 147         int prio;
 148
 149         prio = strtol(priority, &endptr, 10);
 150         if (endptr[0] == '\0' || isspace(endptr[0]))
 151                 return prio;
 152         if (strncmp(priority, "err", 3) == 0)
 153                 return LOG_ERR;
 154         if (strncmp(priority, "info", 4) == 0)
 155                 return LOG_INFO;
 156         if (strncmp(priority, "debug", 5) == 0)
 157                 return LOG_DEBUG;
 158         return 0;
 159 }
 160
 161 static const char *dirname_default_prefix = ROOTPREFIX "/lib/modules";
 162
 163 static char *get_kernel_release(const char *dirname)
 164 {
 165         struct utsname u;
 166         char *p;
 167
 168         if (dirname != NULL)
 169                 return path_make_absolute_cwd(dirname);
 170
 171         if (uname(&u) < 0)
 172                 return NULL;
 173
 174         if (asprintf(&p, "%s/%s", dirname_default_prefix, u.release) < 0)
 175                 return NULL;
 176
 177         return p;
 178 }
 179
 180 /**
 181  * kmod_new:
 182  * @dirname: what to consider as linux module's directory, if NULL
 183  *           defaults to $rootprefix/lib/modules/`uname -r`. If it's relative,
 184  *           it's treated as relative to current the current working
 185  *           directory. Otherwise, give an absolute dirname.
 186  * @config_paths: ordered array of paths (directories or files) where
 187  *                to load from user-defined configuration parameters such as
 188  *                alias, blacklists, commands (install, remove). If
 189  *                NULL defaults to /run/modprobe.d, /etc/modprobe.d and
 190  *                $rootprefix/lib/modprobe.d. Give an empty vector if
 191  *                configuration should not be read. This array must be null
 192  *                terminated.
 193  *
 194  * Create kmod library context. This reads the kmod configuration
 195  * and fills in the default values.
 196  *
 197  * The initial refcount is 1, and needs to be decremented to
 198  * release the resources of the kmod library context.
 199  *
 200  * Returns: a new kmod library context
 201  */
 202 KMOD_EXPORT struct kmod_ctx *kmod_new(const char *dirname,
 203                                         const char * const *config_paths)
 204 {
 205         const char *env;
 206         struct kmod_ctx *ctx;
 207         int err;
 208
 209         ctx = calloc(1, sizeof(struct kmod_ctx));
 210         if (!ctx)
 211                 return NULL;
 212
 213         ctx->refcount = 1;
 214         ctx->log_fn = log_filep;
 215         ctx->log_data = stderr;
 216         ctx->log_priority = LOG_ERR;
 217
 218         ctx->dirname = get_kernel_release(dirname);
 219
 220         /* environment overwrites config */
 221         env = getenv("KMOD_LOG");
 222         if (env != NULL)
 223                 kmod_set_log_priority(ctx, log_priority(env));
 224
 225         if (config_paths == NULL)
 226                 config_paths = default_config_paths;
 227         err = kmod_config_new(ctx, &ctx->config, config_paths);
 228         if (err < 0) {
 229                 ERR(ctx, "could not create config\n");
 230                 goto fail;
 231         }
 232
 233         ctx->modules_by_name = hash_new(KMOD_HASH_SIZE, NULL);
 234         if (ctx->modules_by_name == NULL) {
 235                 ERR(ctx, "could not create by-name hash\n");
 236                 goto fail;
 237         }
 238
 239         INFO(ctx, "ctx %p created\n", ctx);
 240         DBG(ctx, "log_priority=%d\n", ctx->log_priority);
 241
 242         return ctx;
 243
 244 fail:
 245         free(ctx->modules_by_name);
 246         free(ctx->dirname);
 247         free(ctx);
 248         return NULL;
 249 }
 250
 251 /**
 252  * kmod_ref:
 253  * @ctx: kmod library context
 254  *
 255  * Take a reference of the kmod library context.
 256  *
 257  * Returns: the passed kmod library context
 258  */
 259 KMOD_EXPORT struct kmod_ctx *kmod_ref(struct kmod_ctx *ctx)
 260 {
 261         if (ctx == NULL)
 262                 return NULL;
 263         ctx->refcount++;
 264         return ctx;
 265 }
 266
 267 /**
 268  * kmod_unref:
 269  * @ctx: kmod library context
 270  *
 271  * Drop a reference of the kmod library context. If the refcount
 272  * reaches zero, the resources of the context will be released.
 273  */
 274 KMOD_EXPORT struct kmod_ctx *kmod_unref(struct kmod_ctx *ctx)
 275 {
 276         if (ctx == NULL)
 277                 return NULL;
 278
 279         if (--ctx->refcount > 0)
 280                 return ctx;
 281
 282         INFO(ctx, "context %p released\n", ctx);
 283
 284         kmod_unload_resources(ctx);
 285         hash_free(ctx->modules_by_name);
 286         free(ctx->dirname);
 287         if (ctx->config)
 288                 kmod_config_free(ctx->config);
 289
 290         free(ctx);
 291         return NULL;
 292 }
 293
 294 /**
 295  * kmod_set_log_fn:
 296  * @ctx: kmod library context
 297  * @log_fn: function to be called for logging messages
 298  * @data: data to pass to log function
 299  *
 300  * The built-in logging writes to stderr. It can be
 301  * overridden by a custom function, to plug log messages
 302  * into the user's logging functionality.
 303  */
 304 KMOD_EXPORT void kmod_set_log_fn(struct kmod_ctx *ctx,
 305                                         void (*log_fn)(void *data,
 306                                                 int priority, const char *file,
 307                                                 int line, const char *fn,
 308                                                 const char *format, va_list args),
 309                                         const void *data)
 310 {
 311         if (ctx == NULL)
 312                 return;
 313         ctx->log_fn = log_fn;
 314         ctx->log_data = (void *)data;
 315         INFO(ctx, "custom logging function %p registered\n", log_fn);
 316 }
 317
 318 /**
 319  * kmod_get_log_priority:
 320  * @ctx: kmod library context
 321  *
 322  * Returns: the current logging priority
 323  */
 324 KMOD_EXPORT int kmod_get_log_priority(const struct kmod_ctx *ctx)
 325 {
 326         if (ctx == NULL)
 327                 return -1;
 328         return ctx->log_priority;
 329 }
 330
 331 /**
 332  * kmod_set_log_priority:
 333  * @ctx: kmod library context
 334  * @priority: the new logging priority
 335  *
 336  * Set the current logging priority. The value controls which messages
 337  * are logged.
 338  */
 339 KMOD_EXPORT void kmod_set_log_priority(struct kmod_ctx *ctx, int priority)
 340 {
 341         if (ctx == NULL)
 342                 return;
 343         ctx->log_priority = priority;
 344 }
 345
 346 struct kmod_module *kmod_pool_get_module(struct kmod_ctx *ctx,
 347                                                         const char *key)
 348 {
 349         struct kmod_module *mod;
 350
 351         mod = hash_find(ctx->modules_by_name, key);
 352
 353         DBG(ctx, "get module name='%s' found=%p\n", key, mod);
 354
 355         return mod;
 356 }
 357
 358 void kmod_pool_add_module(struct kmod_ctx *ctx, struct kmod_module *mod,
 359                                                         const char *key)
 360 {
 361         DBG(ctx, "add %p key='%s'\n", mod, key);
 362
 363         hash_add(ctx->modules_by_name, key, mod);
 364 }
 365
 366 void kmod_pool_del_module(struct kmod_ctx *ctx, struct kmod_module *mod,
 367                                                         const char *key)
 368 {
 369         DBG(ctx, "del %p key='%s'\n", mod, key);
 370
 371         hash_del(ctx->modules_by_name, key);
 372 }
 373
 374 static int kmod_lookup_alias_from_alias_bin(struct kmod_ctx *ctx,
 375                                                 enum kmod_index index_number,
 376                                                 const char *name,
 377                                                 struct kmod_list **list)
 378 {
 379         int err, nmatch = 0;
 380         struct index_file *idx;
 381         struct index_value *realnames, *realname;
 382
 383         if (ctx->indexes[index_number] != NULL) {
 384                 DBG(ctx, "use mmaped index '%s' for name=%s\n",
 385                         index_files[index_number].fn, name);
 386                 realnames = index_mm_searchwild(ctx->indexes[index_number],
 387                                                                         name);
 388         } else {
 389                 char fn[PATH_MAX];
 390
 391                 snprintf(fn, sizeof(fn), "%s/%s.bin", ctx->dirname,
 392                                         index_files[index_number].fn);
 393
 394                 DBG(ctx, "file=%s name=%s\n", fn, name);
 395
 396                 idx = index_file_open(fn);
 397                 if (idx == NULL)
 398                         return -ENOSYS;
 399
 400                 realnames = index_searchwild(idx, name);
 401                 index_file_close(idx);
 402         }
 403
 404         for (realname = realnames; realname; realname = realname->next) {
 405                 struct kmod_module *mod;
 406
 407                 err = kmod_module_new_from_alias(ctx, name, realname->value, &mod);
 408                 if (err < 0) {
 409                         ERR(ctx, "%s\n", strerror(-err));
 410                         goto fail;
 411                 }
 412
 413                 *list = kmod_list_append(*list, mod);
 414                 nmatch++;
 415         }
 416
 417         index_values_free(realnames);
 418         return nmatch;
 419
 420 fail:
 421         *list = kmod_list_remove_n_latest(*list, nmatch);
 422         return err;
 423
 424 }
 425
 426 int kmod_lookup_alias_from_symbols_file(struct kmod_ctx *ctx, const char *name,
 427                                                 struct kmod_list **list)
 428 {
 429         if (!strstartswith(name, "symbol:"))
 430                 return 0;
 431
 432         return kmod_lookup_alias_from_alias_bin(ctx, KMOD_INDEX_MODULES_SYMBOL,
 433                                                                 name, list);
 434 }
 435
 436 int kmod_lookup_alias_from_aliases_file(struct kmod_ctx *ctx, const char *name,
 437                                                 struct kmod_list **list)
 438 {
 439         return kmod_lookup_alias_from_alias_bin(ctx, KMOD_INDEX_MODULES_ALIAS,
 440                                                                 name, list);
 441 }
 442
 443 char *kmod_search_moddep(struct kmod_ctx *ctx, const char *name)
 444 {
 445         struct index_file *idx;
 446         char fn[PATH_MAX];
 447         char *line;
 448
 449         if (ctx->indexes[KMOD_INDEX_MODULES_DEP]) {
 450                 DBG(ctx, "use mmaped index '%s' modname=%s\n",
 451                                 index_files[KMOD_INDEX_MODULES_DEP].fn, name);
 452                 return index_mm_search(ctx->indexes[KMOD_INDEX_MODULES_DEP],
 453                                                                         name);
 454         }
 455
 456         snprintf(fn, sizeof(fn), "%s/%s.bin", ctx->dirname,
 457                                         index_files[KMOD_INDEX_MODULES_DEP].fn);
 458
 459         DBG(ctx, "file=%s modname=%s\n", fn, name);
 460
 461         idx = index_file_open(fn);
 462         if (idx == NULL) {
 463                 ERR(ctx, "could not open moddep file '%s'\n", fn);
 464                 return NULL;
 465         }
 466
 467         line = index_search(idx, name);
 468         index_file_close(idx);
 469
 470         return line;
 471 }
 472
 473 int kmod_lookup_alias_from_moddep_file(struct kmod_ctx *ctx, const char *name,
 474                                                 struct kmod_list **list)
 475 {
 476         char *line;
 477         int n = 0;
 478
 479         /*
 480          * Module names do not contain ':'. Return early if we know it will
 481          * not be found.
 482          */
 483         if (strchr(name, ':'))
 484                 return 0;
 485
 486         line = kmod_search_moddep(ctx, name);
 487         if (line != NULL) {
 488                 struct kmod_module *mod;
 489
 490                 n = kmod_module_new_from_name(ctx, name, &mod);
 491                 if (n < 0) {
 492                         ERR(ctx, "%s\n", strerror(-n));
 493                         goto finish;
 494                 }
 495
 496                 *list = kmod_list_append(*list, mod);
 497                 kmod_module_parse_depline(mod, line);
 498         }
 499
 500 finish:
 501         free(line);
 502
 503         return n;
 504 }
 505
 506 int kmod_lookup_alias_from_config(struct kmod_ctx *ctx, const char *name,
 507                                                 struct kmod_list **list)
 508 {
 509         struct kmod_config *config = ctx->config;
 510         struct kmod_list *l;
 511         int err, nmatch = 0;
 512
 513         kmod_list_foreach(l, config->aliases) {
 514                 const char *aliasname = kmod_alias_get_name(l);
 515                 const char *modname = kmod_alias_get_modname(l);
 516
 517                 if (fnmatch(aliasname, name, 0) == 0) {
 518                         struct kmod_module *mod;
 519
 520                         err = kmod_module_new_from_alias(ctx, aliasname,
 521                                                                 modname, &mod);
 522                         if (err < 0) {
 523                                 ERR(ctx, "%s\n", strerror(-err));
 524                                 goto fail;
 525                         }
 526
 527                         *list = kmod_list_append(*list, mod);
 528                         nmatch++;
 529                 }
 530         }
 531
 532         return nmatch;
 533
 534 fail:
 535         *list = kmod_list_remove_n_latest(*list, nmatch);
 536         return err;
 537 }
 538
 539 int kmod_lookup_alias_from_commands(struct kmod_ctx *ctx, const char *name,
 540                                                 struct kmod_list **list)
 541 {
 542         struct kmod_config *config = ctx->config;
 543         struct kmod_list *l, *node;
 544         int err, nmatch = 0;
 545
 546         kmod_list_foreach(l, config->install_commands) {
 547                 const char *modname = kmod_command_get_modname(l);
 548
 549                 if (streq(modname, name)) {
 550                         const char *cmd = kmod_command_get_command(l);
 551                         struct kmod_module *mod;
 552
 553                         err = kmod_module_new_from_name(ctx, modname, &mod);
 554                         if (err < 0) {
 555                                 ERR(ctx, "%s\n", strerror(-err));
 556                                 return err;
 557                         }
 558
 559                         node = kmod_list_append(*list, mod);
 560                         if (node == NULL) {
 561                                 ERR(ctx, "out of memory\n");
 562                                 return -ENOMEM;
 563                         }
 564
 565                         *list = node;
 566                         nmatch = 1;
 567
 568                         kmod_module_set_install_commands(mod, cmd);
 569
 570                         /*
 571                          * match only the first one, like modprobe from
 572                          * module-init-tools does
 573                          */
 574                         break;
 575                 }
 576         }
 577
 578         if (nmatch)
 579                 return nmatch;
 580
 581         kmod_list_foreach(l, config->remove_commands) {
 582                 const char *modname = kmod_command_get_modname(l);
 583
 584                 if (streq(modname, name)) {
 585                         const char *cmd = kmod_command_get_command(l);
 586                         struct kmod_module *mod;
 587
 588                         err = kmod_module_new_from_name(ctx, modname, &mod);
 589                         if (err < 0) {
 590                                 ERR(ctx, "%s\n", strerror(-err));
 591                                 return err;
 592                         }
 593
 594                         node = kmod_list_append(*list, mod);
 595                         if (node == NULL) {
 596                                 ERR(ctx, "out of memory\n");
 597                                 return -ENOMEM;
 598                         }
 599
 600                         *list = node;
 601                         nmatch = 1;
 602
 603                         kmod_module_set_remove_commands(mod, cmd);
 604
 605                         /*
 606                          * match only the first one, like modprobe from
 607                          * module-init-tools does
 608                          */
 609                         break;
 610                 }
 611         }
 612
 613         return nmatch;
 614 }
 615
 616 static bool is_cache_invalid(const char *path, unsigned long long stamp)
 617 {
 618         struct stat st;
 619
 620         if (stat(path, &st) < 0)
 621                 return true;
 622
 623         if (stamp != ts_usec(&st.st_mtim))
 624                 return true;
 625
 626         return false;
 627 }
 628
 629 /**
 630  * kmod_validate_resources:
 631  * @ctx: kmod library context
 632  *
 633  * Check if indexes and configuration files changed on disk and the current
 634  * context is not valid anymore.
 635  *
 636  * Returns: KMOD_RESOURCES_OK if resources are still valid,
 637  * KMOD_RESOURCES_MUST_RELOAD if it's sufficient to call
 638  * kmod_unload_resources() and kmod_load_resources() or
 639  * KMOD_RESOURCES_MUST_RECREATE if @ctx must be re-created.
 640  */
 641 KMOD_EXPORT int kmod_validate_resources(struct kmod_ctx *ctx)
 642 {
 643         struct kmod_list *l;
 644         size_t i;
 645
 646         if (ctx == NULL || ctx->config == NULL)
 647                 return KMOD_RESOURCES_MUST_RECREATE;
 648
 649         kmod_list_foreach(l, ctx->config->paths) {
 650                 struct kmod_config_path *cf = l->data;
 651
 652                 if (is_cache_invalid(cf->path, cf->stamp))
 653                         return KMOD_RESOURCES_MUST_RECREATE;
 654         }
 655
 656         for (i = 0; i < _KMOD_INDEX_MODULES_SIZE; i++) {
 657                 char path[PATH_MAX];
 658
 659                 if (ctx->indexes[i] == NULL)
 660                         continue;
 661
 662                 snprintf(path, sizeof(path), "%s/%s.bin", ctx->dirname,
 663                                                 index_files[i].fn);
 664
 665                 if (is_cache_invalid(path, ctx->indexes_stamp[i]))
 666                         return KMOD_RESOURCES_MUST_RELOAD;
 667         }
 668
 669         return KMOD_RESOURCES_OK;
 670 }
 671
 672 /**
 673  * kmod_load_resources:
 674  * @ctx: kmod library context
 675  *
 676  * Load indexes and keep them open in @ctx. This way it's faster to lookup
 677  * information within the indexes. If this function is not called before a
 678  * search, the necessary index is always opened and closed.
 679  *
 680  * If user will do more than one or two lookups, insertions, deletions, most
 681  * likely it's good to call this function first. Particularly in a daemon like
 682  * udev that on bootup issues hundreds of calls to lookup the index, calling
 683  * this function will speedup the searches.
 684  *
 685  * Returns: 0 on success or < 0 otherwise.
 686  */
 687 KMOD_EXPORT int kmod_load_resources(struct kmod_ctx *ctx)
 688 {
 689         size_t i;
 690
 691         if (ctx == NULL)
 692                 return -ENOENT;
 693
 694         for (i = 0; i < _KMOD_INDEX_MODULES_SIZE; i++) {
 695                 char path[PATH_MAX];
 696
 697                 if (ctx->indexes[i] != NULL) {
 698                         INFO(ctx, "Index %s already loaded\n",
 699                                                         index_files[i].fn);
 700                         continue;
 701                 }
 702
 703                 snprintf(path, sizeof(path), "%s/%s.bin", ctx->dirname,
 704                                                         index_files[i].fn);
 705                 ctx->indexes[i] = index_mm_open(ctx, path, true,
 706                                                 &ctx->indexes_stamp[i]);
 707                 if (ctx->indexes[i] == NULL)
 708                         goto fail;
 709         }
 710
 711         return 0;
 712
 713 fail:
 714         kmod_unload_resources(ctx);
 715         return -ENOMEM;
 716 }
 717
 718 /**
 719  * kmod_unload_resources:
 720  * @ctx: kmod library context
 721  *
 722  * Unload all the indexes. This will free the resources to maintain the index
 723  * open and all subsequent searches will need to open and close the index.
 724  *
 725  * User is free to call kmod_load_resources() and kmod_unload_resources() as
 726  * many times as wanted during the lifecycle of @ctx. For example, if a daemon
 727  * knows that when starting up it will lookup a lot of modules, it could call
 728  * kmod_load_resources() and after the first burst of searches is gone, it
 729  * could free the resources by calling kmod_unload_resources().
 730  *
 731  * Returns: 0 on success or < 0 otherwise.
 732  */
 733 KMOD_EXPORT void kmod_unload_resources(struct kmod_ctx *ctx)
 734 {
 735         size_t i;
 736
 737         if (ctx == NULL)
 738                 return;
 739
 740         for (i = 0; i < _KMOD_INDEX_MODULES_SIZE; i++) {
 741                 if (ctx->indexes[i] != NULL) {
 742                         index_mm_close(ctx->indexes[i]);
 743                         ctx->indexes[i] = NULL;
 744                         ctx->indexes_stamp[i] = 0;
 745                 }
 746         }
 747 }
 748
 749 /**
 750  * kmod_dump_index:
 751  * @ctx: kmod library context
 752  * @type: index to dump
 753  * @fd: file descriptor to dump index to
 754  *
 755  * Dump index to file descriptor
 756  *
 757  * Returns: 0 on success or < 0 otherwise.
 758  */
 759 KMOD_EXPORT int kmod_dump_index(struct kmod_ctx *ctx, enum kmod_index type,
 760                                                                         int fd)
 761 {
 762         if (ctx == NULL)
 763                 return -ENOSYS;
 764
 765         if (type < 0 || type >= _KMOD_INDEX_MODULES_SIZE)
 766                 return -ENOENT;
 767
 768         if (ctx->indexes[type] != NULL) {
 769                 DBG(ctx, "use mmaped index '%s'\n", index_files[type].fn);
 770                 index_mm_dump(ctx->indexes[type], fd,
 771                                                 index_files[type].prefix);
 772         } else {
 773                 char fn[PATH_MAX];
 774                 struct index_file *idx;
 775
 776                 snprintf(fn, sizeof(fn), "%s/%s.bin", ctx->dirname,
 777                                                 index_files[type].fn);
 778
 779                 DBG(ctx, "file=%s\n", fn);
 780
 781                 idx = index_file_open(fn);
 782                 if (idx == NULL)
 783                         return -ENOSYS;
 784
 785                 index_dump(idx, fd, index_files[type].prefix);
 786                 index_file_close(idx);
 787         }
 788
 789         return 0;
 790 }
 791
 792 const struct kmod_list *kmod_get_blacklists(const struct kmod_ctx *ctx)
 793 {
 794         return ctx->config->blacklists;
 795 }
 796
 797 const struct kmod_list *kmod_get_options(const struct kmod_ctx *ctx)
 798 {
 799         return ctx->config->options;
 800 }
 801
 802 const struct kmod_list *kmod_get_install_commands(const struct kmod_ctx *ctx)
 803 {
 804         return ctx->config->install_commands;
 805 }
 806
 807 const struct kmod_list *kmod_get_remove_commands(const struct kmod_ctx *ctx)
 808 {
 809         return ctx->config->remove_commands;
 810 }
 811
 812 const struct kmod_list *kmod_get_softdeps(const struct kmod_ctx *ctx)
 813 {
 814         return ctx->config->softdeps;
 815 }
 816
 817 const struct kmod_list *kmod_get_aliases(const struct kmod_ctx *ctx)
 818 {
 819         return ctx->config->aliases;
 820 }