libkmod/libkmod.c

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