libkmod/libkmod.c

   1 /*
   2  * libkmod - interface to kernel module operations
   3  *
   4  * Copyright (C) 2011  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
  33 #include "libkmod.h"
  34 #include "libkmod-private.h"
  35 #include "libkmod-index.h"
  36
  37 #define KMOD_HASH_SIZE (256)
  38 #define KMOD_LRU_MAX (128)
  39
  40 /**
  41  * SECTION:libkmod
  42  * @short_description: libkmod context
  43  *
  44  * The context contains the default values for the library user,
  45  * and is passed to all library operations.
  46  */
  47
  48 enum kmod_index {
  49         KMOD_INDEX_DEP = 0,
  50         KMOD_INDEX_ALIAS,
  51         KMOD_INDEX_SYMBOL,
  52         _KMOD_INDEX_LAST,
  53 };
  54
  55 static const char* index_files[] = {
  56         [KMOD_INDEX_DEP] = "modules.dep",
  57         [KMOD_INDEX_ALIAS] = "modules.alias",
  58         [KMOD_INDEX_SYMBOL] = "modules.symbols",
  59 };
  60
  61 static const char *default_config_paths[] = {
  62         "/run/modprobe.d",
  63         "/etc/modprobe.d",
  64         "/lib/modprobe.d",
  65         NULL
  66 };
  67
  68 /**
  69  * kmod_ctx:
  70  *
  71  * Opaque object representing the library context.
  72  */
  73 struct kmod_ctx {
  74         int refcount;
  75         int log_priority;
  76         void (*log_fn)(void *data,
  77                         int priority, const char *file, int line,
  78                         const char *fn, const char *format, va_list args);
  79         void *log_data;
  80         const void *userdata;
  81         char *dirname;
  82         struct kmod_config *config;
  83         struct kmod_hash *modules_by_name;
  84         struct index_mm *indexes[_KMOD_INDEX_LAST];
  85 };
  86
  87 void kmod_log(const struct kmod_ctx *ctx,
  88                 int priority, const char *file, int line, const char *fn,
  89                 const char *format, ...)
  90 {
  91         va_list args;
  92
  93         if (ctx->log_fn == NULL)
  94                 return;
  95
  96         va_start(args, format);
  97         ctx->log_fn(ctx->log_data, priority, file, line, fn, format, args);
  98         va_end(args);
  99 }
 100
 101 static void log_filep(void *data,
 102                         int priority, const char *file, int line,
 103                         const char *fn, const char *format, va_list args)
 104 {
 105         FILE *fp = data;
 106         fprintf(fp, "libkmod: %s: ", fn);
 107         vfprintf(fp, format, args);
 108 }
 109
 110 const char *kmod_get_dirname(const struct kmod_ctx *ctx)
 111 {
 112         return ctx->dirname;
 113 }
 114
 115 /**
 116  * kmod_get_userdata:
 117  * @ctx: kmod library context
 118  *
 119  * Retrieve stored data pointer from library context. This might be useful
 120  * to access from callbacks.
 121  *
 122  * Returns: stored userdata
 123  */
 124 KMOD_EXPORT void *kmod_get_userdata(const struct kmod_ctx *ctx)
 125 {
 126         if (ctx == NULL)
 127                 return NULL;
 128         return (void *)ctx->userdata;
 129 }
 130
 131 /**
 132  * kmod_set_userdata:
 133  * @ctx: kmod library context
 134  * @userdata: data pointer
 135  *
 136  * Store custom @userdata in the library context.
 137  */
 138 KMOD_EXPORT void kmod_set_userdata(struct kmod_ctx *ctx, const void *userdata)
 139 {
 140         if (ctx == NULL)
 141                 return;
 142         ctx->userdata = userdata;
 143 }
 144
 145 static int log_priority(const char *priority)
 146 {
 147         char *endptr;
 148         int prio;
 149
 150         prio = strtol(priority, &endptr, 10);
 151         if (endptr[0] == '\0' || isspace(endptr[0]))
 152                 return prio;
 153         if (strncmp(priority, "err", 3) == 0)
 154                 return LOG_ERR;
 155         if (strncmp(priority, "info", 4) == 0)
 156                 return LOG_INFO;
 157         if (strncmp(priority, "debug", 5) == 0)
 158                 return LOG_DEBUG;
 159         return 0;
 160 }
 161
 162 static const char *dirname_default_prefix = "/lib/modules";
 163
 164 static char *get_kernel_release(const char *dirname)
 165 {
 166         struct utsname u;
 167         char *p;
 168
 169         if (dirname != NULL)
 170                 return strdup(dirname);
 171
 172         if (uname(&u) < 0)
 173                 return NULL;
 174
 175         if (asprintf(&p, "%s/%s", dirname_default_prefix, u.release) < 0)
 176                 return NULL;
 177
 178         return p;
 179 }
 180
 181 /**
 182  * kmod_new:
 183  *
 184  * Create kmod library context. This reads the kmod configuration
 185  * and fills in the default values.
 186  *
 187  * The initial refcount is 1, and needs to be decremented to
 188  * release the resources of the kmod library context.
 189  *
 190  * @dirname: what to consider as linux module's directory, if NULL
 191  *           defaults to /lib/modules/`uname -r`.
 192  * @config_paths: ordered array of paths (directories or files) where
 193  *                to load from user-defined configuration parameters such as
 194  *                alias, blacklists, commands (install, remove). If
 195  *                NULL defaults to /run/modprobe.d, /etc/modprobe.d and
 196  *                /lib/modprobe.d. Give an empty vector if configuration should
 197  *                not be read. This array must be null terminated.
 198  *
 199  * Returns: a new kmod library context
 200  */
 201 KMOD_EXPORT struct kmod_ctx *kmod_new(const char *dirname,
 202                                         const char * const *config_paths)
 203 {
 204         const char *env;
 205         struct kmod_ctx *ctx;
 206         int err;
 207
 208         ctx = calloc(1, sizeof(struct kmod_ctx));
 209         if (!ctx)
 210                 return NULL;
 211
 212         ctx->refcount = 1;
 213         ctx->log_fn = log_filep;
 214         ctx->log_data = stderr;
 215         ctx->log_priority = LOG_ERR;
 216
 217         ctx->dirname = get_kernel_release(dirname);
 218
 219         /* environment overwrites config */
 220         env = getenv("KMOD_LOG");
 221         if (env != NULL)
 222                 kmod_set_log_priority(ctx, log_priority(env));
 223
 224         if (config_paths == NULL)
 225                 config_paths = default_config_paths;
 226         err = kmod_config_new(ctx, &ctx->config, config_paths);
 227         if (err < 0) {
 228                 ERR(ctx, "could not create config\n");
 229                 goto fail;
 230         }
 231
 232         ctx->modules_by_name = kmod_hash_new(KMOD_HASH_SIZE, NULL);
 233         if (ctx->modules_by_name == NULL) {
 234                 ERR(ctx, "could not create by-name hash\n");
 235                 goto fail;
 236         }
 237
 238         INFO(ctx, "ctx %p created\n", ctx);
 239         DBG(ctx, "log_priority=%d\n", ctx->log_priority);
 240
 241         return ctx;
 242
 243 fail:
 244         free(ctx->modules_by_name);
 245         free(ctx->dirname);
 246         free(ctx);
 247         return NULL;
 248 }
 249
 250 /**
 251  * kmod_ref:
 252  * @ctx: kmod library context
 253  *
 254  * Take a reference of the kmod library context.
 255  *
 256  * Returns: the passed kmod library context
 257  */
 258 KMOD_EXPORT struct kmod_ctx *kmod_ref(struct kmod_ctx *ctx)
 259 {
 260         if (ctx == NULL)
 261                 return NULL;
 262         ctx->refcount++;
 263         return ctx;
 264 }
 265
 266 /**
 267  * kmod_unref:
 268  * @ctx: kmod library context
 269  *
 270  * Drop a reference of the kmod library context. If the refcount
 271  * reaches zero, the resources of the context will be released.
 272  */
 273 KMOD_EXPORT struct kmod_ctx *kmod_unref(struct kmod_ctx *ctx)
 274 {
 275         if (ctx == NULL)
 276                 return NULL;
 277
 278         if (--ctx->refcount > 0)
 279                 return ctx;
 280
 281         INFO(ctx, "context %p released\n", ctx);
 282
 283         kmod_unload_resources(ctx);
 284         kmod_hash_free(ctx->modules_by_name);
 285         free(ctx->dirname);
 286         if (ctx->config)
 287                 kmod_config_free(ctx->config);
 288
 289         free(ctx);
 290         return NULL;
 291 }
 292
 293 /**
 294  * kmod_set_log_fn:
 295  * @ctx: kmod library context
 296  * @log_fn: function to be called for logging messages
 297  *
 298  * The built-in logging writes to stderr. It can be
 299  * overridden by a custom function, to plug log messages
 300  * into the user's logging functionality.
 301  */
 302 KMOD_EXPORT void kmod_set_log_fn(struct kmod_ctx *ctx,
 303                                         void (*log_fn)(void *data,
 304                                                 int priority, const char *file,
 305                                                 int line, const char *fn,
 306                                                 const char *format, va_list args),
 307                                         const void *data)
 308 {
 309         if (ctx == NULL)
 310                 return;
 311         ctx->log_fn = log_fn;
 312         ctx->log_data = (void *)data;
 313         INFO(ctx, "custom logging function %p registered\n", log_fn);
 314 }
 315
 316 /**
 317  * kmod_get_log_priority:
 318  * @ctx: kmod library context
 319  *
 320  * Returns: the current logging priority
 321  */
 322 KMOD_EXPORT int kmod_get_log_priority(const struct kmod_ctx *ctx)
 323 {
 324         if (ctx == NULL)
 325                 return -1;
 326         return ctx->log_priority;
 327 }
 328
 329 /**
 330  * kmod_set_log_priority:
 331  * @ctx: kmod library context
 332  * @priority: the new logging priority
 333  *
 334  * Set the current logging priority. The value controls which messages
 335  * are logged.
 336  */
 337 KMOD_EXPORT void kmod_set_log_priority(struct kmod_ctx *ctx, int priority)
 338 {
 339         if (ctx == NULL)
 340                 return;
 341         ctx->log_priority = priority;
 342 }
 343
 344 struct kmod_module *kmod_pool_get_module(struct kmod_ctx *ctx,
 345                                                         const char *key)
 346 {
 347         struct kmod_module *mod;
 348
 349         mod = kmod_hash_find(ctx->modules_by_name, key);
 350
 351         DBG(ctx, "get module name='%s' found=%p\n", key, mod);
 352
 353         return mod;
 354 }
 355
 356 void kmod_pool_add_module(struct kmod_ctx *ctx, struct kmod_module *mod,
 357                                                         const char *key)
 358 {
 359         DBG(ctx, "add %p key='%s'\n", mod, key);
 360
 361         kmod_hash_add(ctx->modules_by_name, key, mod);
 362 }
 363
 364 void kmod_pool_del_module(struct kmod_ctx *ctx, struct kmod_module *mod,
 365                                                         const char *key)
 366 {
 367         DBG(ctx, "del %p key='%s'\n", mod, key);
 368
 369         kmod_hash_del(ctx->modules_by_name, key);
 370 }
 371
 372 static int kmod_lookup_alias_from_alias_bin(struct kmod_ctx *ctx,
 373                                                 enum kmod_index index_number,
 374                                                 const char *name,
 375                                                 struct kmod_list **list)
 376 {
 377         int err, nmatch = 0;
 378         struct index_file *idx;
 379         struct index_value *realnames, *realname;
 380
 381         if (ctx->indexes[index_number] != NULL) {
 382                 DBG(ctx, "use mmaped index '%s' for name=%s\n",
 383                         index_files[index_number], name);
 384                 realnames = index_mm_searchwild(ctx->indexes[index_number],
 385                                                                         name);
 386         } else{
 387                 char fn[PATH_MAX];
 388
 389                 snprintf(fn, sizeof(fn), "%s/%s.bin", ctx->dirname,
 390                                                 index_files[index_number]);
 391
 392                 DBG(ctx, "file=%s name=%s\n", fn, name);
 393
 394                 idx = index_file_open(fn);
 395                 if (idx == NULL)
 396                         return -ENOSYS;
 397
 398                 realnames = index_searchwild(idx, name);
 399                 index_file_close(idx);
 400         }
 401
 402         for (realname = realnames; realname; realname = realnames->next) {
 403                 struct kmod_module *mod;
 404
 405                 err = kmod_module_new_from_alias(ctx, name, realname->value, &mod);
 406                 if (err < 0) {
 407                         ERR(ctx, "%s\n", strerror(-err));
 408                         goto fail;
 409                 }
 410
 411                 *list = kmod_list_append(*list, mod);
 412                 nmatch++;
 413         }
 414
 415         index_values_free(realnames);
 416         return nmatch;
 417
 418 fail:
 419         *list = kmod_list_remove_n_latest(*list, nmatch);
 420         return err;
 421
 422 }
 423
 424 int kmod_lookup_alias_from_symbols_file(struct kmod_ctx *ctx, const char *name,
 425                                                 struct kmod_list **list)
 426 {
 427         if (!startswith(name, "symbol:"))
 428                 return 0;
 429
 430         return kmod_lookup_alias_from_alias_bin(ctx, KMOD_INDEX_SYMBOL, name,
 431                                                                         list);
 432 }
 433
 434 int kmod_lookup_alias_from_aliases_file(struct kmod_ctx *ctx, const char *name,
 435                                                 struct kmod_list **list)
 436 {
 437         return kmod_lookup_alias_from_alias_bin(ctx, KMOD_INDEX_ALIAS, name,
 438                                                                         list);
 439 }
 440
 441 char *kmod_search_moddep(struct kmod_ctx *ctx, const char *name)
 442 {
 443         struct index_file *idx;
 444         char fn[PATH_MAX];
 445         char *line;
 446
 447         if (ctx->indexes[KMOD_INDEX_DEP]) {
 448                 DBG(ctx, "use mmaped index '%s' modname=%s\n",
 449                         index_files[KMOD_INDEX_DEP], name);
 450                 return index_mm_search(ctx->indexes[KMOD_INDEX_DEP], name);
 451         }
 452
 453         snprintf(fn, sizeof(fn), "%s/%s.bin", ctx->dirname,
 454                                                 index_files[KMOD_INDEX_DEP]);
 455
 456         DBG(ctx, "file=%s modname=%s\n", fn, name);
 457
 458         idx = index_file_open(fn);
 459         if (idx == NULL) {
 460                 ERR(ctx, "Could not open moddep file '%s'\n", fn);
 461                 return NULL;
 462         }
 463
 464         line = index_search(idx, name);
 465         index_file_close(idx);
 466
 467         return line;
 468 }
 469
 470 int kmod_lookup_alias_from_moddep_file(struct kmod_ctx *ctx, const char *name,
 471                                                 struct kmod_list **list)
 472 {
 473         char *line;
 474         int n = 0;
 475
 476         /*
 477          * Module names do not contain ':'. Return early if we know it will
 478          * not be found.
 479          */
 480         if (strchr(name, ':'))
 481                 return 0;
 482
 483         line = kmod_search_moddep(ctx, name);
 484         if (line != NULL) {
 485                 struct kmod_module *mod;
 486
 487                 n = kmod_module_new_from_name(ctx, name, &mod);
 488                 if (n < 0) {
 489                         ERR(ctx, "%s\n", strerror(-n));
 490                         goto finish;
 491                 }
 492
 493                 *list = kmod_list_append(*list, mod);
 494                 kmod_module_parse_depline(mod, line);
 495         }
 496
 497 finish:
 498         free(line);
 499
 500         return n;
 501 }
 502
 503 int kmod_lookup_alias_from_config(struct kmod_ctx *ctx, const char *name,
 504                                                 struct kmod_list **list)
 505 {
 506         struct kmod_config *config = ctx->config;
 507         struct kmod_list *l;
 508         int err, nmatch = 0;
 509
 510         kmod_list_foreach(l, config->aliases) {
 511                 const char *aliasname = kmod_alias_get_name(l);
 512                 const char *modname = kmod_alias_get_modname(l);
 513
 514                 if (fnmatch(aliasname, name, 0) == 0) {
 515                         struct kmod_module *mod;
 516
 517                         err = kmod_module_new_from_alias(ctx, aliasname,
 518                                                                 modname, &mod);
 519                         if (err < 0) {
 520                                 ERR(ctx, "%s\n", strerror(-err));
 521                                 goto fail;
 522                         }
 523
 524                         *list = kmod_list_append(*list, mod);
 525                         nmatch++;
 526                 }
 527         }
 528
 529         return nmatch;
 530
 531 fail:
 532         *list = kmod_list_remove_n_latest(*list, nmatch);
 533         return err;
 534 }
 535
 536 /**
 537  * kmod_module_get_filtered_blacklist:
 538  * @ctx: kmod library context
 539  * @input: list of kmod_module to be filtered with blacklist
 540  * @output: where to save the new list
 541  *
 542  * Given a list @input, this function filter it out with config's blacklist
 543  * ans save it in @output.
 544  *
 545  * Returns: 0 on success or < 0 otherwise. @output is saved with the updated
 546  * list.
 547  */
 548 KMOD_EXPORT int kmod_module_get_filtered_blacklist(const struct kmod_ctx *ctx,
 549                                                 const struct kmod_list *input,
 550                                                 struct kmod_list **output)
 551 {
 552         const struct kmod_config *config;
 553         const struct kmod_list *li;
 554
 555         if (ctx == NULL || output == NULL)
 556                 return -ENOENT;
 557
 558         *output = NULL;
 559         if (input == NULL)
 560                 return 0;
 561
 562         config = ctx->config;
 563         kmod_list_foreach(li, input) {
 564                 struct kmod_module *mod = li->data;
 565                 const struct kmod_list *lb;
 566                 struct kmod_list *node;
 567                 bool filtered = false;
 568                 kmod_list_foreach(lb, config->blacklists) {
 569                         const char *name = lb->data;
 570                         if (streq(name, kmod_module_get_name(mod))) {
 571                                 filtered = true;
 572                                 break;
 573                         }
 574                 }
 575                 if (filtered)
 576                         continue;
 577
 578                 node = kmod_list_append(*output, mod);
 579                 if (node == NULL)
 580                         goto fail;
 581                 *output = node;
 582                 kmod_module_ref(mod);
 583         }
 584         return 0;
 585
 586 fail:
 587         kmod_module_unref_list(*output);
 588         *output = NULL;
 589         return -ENOMEM;
 590 }
 591
 592 /**
 593  * kmod_load_resources:
 594  * @ctx: kmod library context
 595  *
 596  * Load indexes and keep them open in @ctx. This way it's faster to lookup
 597  * information within the indexes. If this function is not called before a
 598  * search, the necessary index is always opened and closed.
 599  *
 600  * If user will do more than one or two lookups, insertions, deletions, most
 601  * likely it's good to call this function first. Particularly in a daemon like
 602  * udev that on bootup issues hundreds of calls to lookup the index, calling
 603  * this function will speedup the searches.
 604  *
 605  * Returns: 0 on success or < 0 otherwise.
 606  */
 607 KMOD_EXPORT int kmod_load_resources(struct kmod_ctx *ctx)
 608 {
 609         size_t i;
 610
 611         if (ctx == NULL)
 612                 return -ENOENT;
 613
 614         for (i = 0; i < ARRAY_SIZE(index_files); i++) {
 615                 char path[PATH_MAX];
 616
 617                 if (ctx->indexes[i] == NULL) {
 618                         INFO(ctx, "Index %s already loaded\n", index_files[i]);
 619                         continue;
 620                 }
 621
 622                 snprintf(path, sizeof(path), "%s/%s.bin", ctx->dirname,
 623                                                         index_files[i]);
 624                 ctx->indexes[i] = index_mm_open(ctx, path, true);
 625                 if (ctx->indexes[i] == NULL)
 626                         goto fail;
 627         }
 628
 629         return 0;
 630
 631 fail:
 632         kmod_unload_resources(ctx);
 633         return -ENOMEM;
 634 }
 635
 636 /**
 637  * kmod_unload_resources:
 638  * @ctx: kmod library context
 639  *
 640  * Unload all the indexes. This will free the resources to maintain the index
 641  * open and all subsequent searches will need to open and close the index.
 642  *
 643  * User is free to call kmod_load_resources() and kmod_unload_resources() as
 644  * many times as wanted during the lifecycle of @ctx. For example, if a daemon
 645  * knows that when starting up it will lookup a lot of modules, it could call
 646  * kmod_load_resources() and after the first burst of searches is gone, it
 647  * could free the resources by calling kmod_unload_resources().
 648  *
 649  * Returns: 0 on success or < 0 otherwise.
 650  */
 651 KMOD_EXPORT void kmod_unload_resources(struct kmod_ctx *ctx)
 652 {
 653         size_t i;
 654
 655         if (ctx == NULL)
 656                 return;
 657
 658         for (i = 0; i < ARRAY_SIZE(index_files); i++) {
 659                 if (ctx->indexes[i] != NULL) {
 660                         index_mm_close(ctx->indexes[i]);
 661                         ctx->indexes[i] = NULL;
 662                 }
 663         }
 664 }
 665
 666 const struct kmod_list *kmod_get_options(const struct kmod_ctx *ctx)
 667 {
 668         return ctx->config->options;
 669 }
 670
 671 const struct kmod_list *kmod_get_install_commands(const struct kmod_ctx *ctx)
 672 {
 673         return ctx->config->install_commands;
 674 }
 675
 676 const struct kmod_list *kmod_get_remove_commands(const struct kmod_ctx *ctx)
 677 {
 678         return ctx->config->remove_commands;
 679 }